From e3fea890e8b9993e2bb19305a0957d839b49ca3e Mon Sep 17 00:00:00 2001 From: Egor Date: Tue, 23 Jan 2024 20:22:54 +0300 Subject: [PATCH 01/31] add individual constructor --- sampo/scheduler/genetic/base.py | 10 ++++- sampo/scheduler/genetic/converter.py | 2 +- sampo/scheduler/genetic/operators.py | 46 ++++++++++----------- sampo/scheduler/genetic/schedule_builder.py | 11 +++-- 4 files changed, 41 insertions(+), 28 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index 368cd6ff..b9748851 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -40,14 +40,16 @@ def __init__(self, rand: Optional[random.Random] = None, seed: Optional[float or None] = None, n_cpu: int = 1, - weights: list[int] = None, + weights: Optional[list[int] or None] = None, fitness_constructor: Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, + fitness_weights: tuple = (-1,), scheduler_type: SchedulerType = SchedulerType.Genetic, resource_optimizer: ResourceOptimizer = IdentityResourceOptimizer(), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, optimize_resources: bool = False, only_lft_initialization: bool = False, + use_pareto_domination: bool = False, verbose: bool = True): super().__init__(scheduler_type=scheduler_type, resource_optimizer=resource_optimizer, @@ -59,6 +61,7 @@ def __init__(self, self.size_of_population = size_of_population self.rand = rand or random.Random(seed) self.fitness_constructor = fitness_constructor + self.fitness_weights = fitness_weights self.work_estimator = work_estimator self.sgs_type = sgs_type @@ -66,6 +69,7 @@ def __init__(self, self._n_cpu = n_cpu self._weights = weights self._only_lft_initialization = only_lft_initialization + self._use_pareto_domination = use_pareto_domination self._verbose = verbose self._time_border = None @@ -144,6 +148,9 @@ def set_verbose(self, verbose: bool): def set_only_lft_initialization(self, only_lft_initialization: bool): self._only_lft_initialization = only_lft_initialization + def set_use_pareto_domination(self, use_pareto_domination: bool): + self._use_pareto_domination = use_pareto_domination + @staticmethod def generate_first_population(wg: WorkGraph, contractors: list[Contractor], @@ -252,6 +259,7 @@ def schedule_with_cache(self, spec, landscape, self.fitness_constructor, + self.fitness_weights, self.work_estimator, self.sgs_type, self._n_cpu, diff --git a/sampo/scheduler/genetic/converter.py b/sampo/scheduler/genetic/converter.py index bf9fa589..687f0b34 100644 --- a/sampo/scheduler/genetic/converter.py +++ b/sampo/scheduler/genetic/converter.py @@ -19,7 +19,7 @@ from sampo.schemas.time_estimator import WorkTimeEstimator, DefaultWorkEstimator from sampo.utilities.linked_list import LinkedList -ChromosomeType = tuple[np.ndarray, np.ndarray, np.ndarray, ScheduleSpec, np.ndarray] +ChromosomeType = list[np.ndarray, np.ndarray, np.ndarray, ScheduleSpec, np.ndarray] class ScheduleGenerationScheme(Enum): diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index cf02aa0a..7f122558 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -173,13 +173,6 @@ def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: for schedule in evaluated] -# create class FitnessMin, the weights = -1 means that fitness - is function for minimum - -creator.create('FitnessMin', base.Fitness, weights=(-1.0,)) -creator.create('Individual', list, fitness=creator.FitnessMin) -Individual = creator.Individual - - def init_toolbox(wg: WorkGraph, contractors: list[Contractor], worker_pool: WorkerContractorPool, @@ -214,6 +207,10 @@ def init_toolbox(wg: WorkGraph, :return: Object, included tools for genetic algorithm """ + creator.create('FitnessMin', base.Fitness, weights=(-1.0,)) + creator.create('Individual', list, fitness=creator.FitnessMin) + Individual = creator.Individual + toolbox = base.Toolbox() # generate chromosome toolbox.register('generate_chromosome', generate_chromosome, wg=wg, contractors=contractors, @@ -285,9 +282,10 @@ def generate_population(n: int, contractor_borders: np.ndarray, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], rand: random.Random, + individual_constructor, work_estimator: WorkTimeEstimator = None, landscape: LandscapeConfiguration = LandscapeConfiguration(), - only_lft_initialization: bool = False) -> list[Individual]: + only_lft_initialization: bool = False) -> list[ChromosomeType]: """ Generates population. Do not use `generate_chromosome` function. @@ -304,8 +302,8 @@ def randomized_init(is_topological: bool = False) -> ChromosomeType: contractor2index, contractor_borders, schedule, spec, landscape) if only_lft_initialization: - chromosomes = [Individual(randomized_init(is_topological=False)) for _ in range(n - 1)] - chromosomes.append(Individual(init_chromosomes['lft'][0])) + chromosomes = [individual_constructor(randomized_init(is_topological=False)) for _ in range(n - 1)] + chromosomes.append(individual_constructor(init_chromosomes['lft'][0])) return chromosomes count_for_specified_types = (n // 3) // len(init_chromosomes) @@ -332,11 +330,11 @@ def randomized_init(is_topological: bool = False) -> ChromosomeType: for generated_type in chromosome_types: match generated_type: case 'topological': - ind = Individual(randomized_init(is_topological=True)) + ind = individual_constructor(randomized_init(is_topological=True)) case 'rand_lft': - ind = Individual(randomized_init(is_topological=False)) + ind = individual_constructor(randomized_init(is_topological=False)) case _: - ind = Individual(init_chromosomes[generated_type][0]) + ind = individual_constructor(init_chromosomes[generated_type][0]) chromosomes.append(ind) @@ -352,8 +350,9 @@ def generate_chromosome(wg: WorkGraph, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], spec: ScheduleSpec, rand: random.Random, + individual_constructor, work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), - landscape: LandscapeConfiguration = LandscapeConfiguration()) -> Individual: + landscape: LandscapeConfiguration = LandscapeConfiguration()) -> ChromosomeType: """ It is necessary to generate valid scheduling, which are satisfied to current dependencies That's why will be used the approved order of works (HEFT order and Topological sorting) @@ -386,7 +385,7 @@ def randomized_init() -> ChromosomeType: else: chromosome = randomized_init() - return Individual(chromosome) + return individual_constructor(chromosome) def select_new_population(population: list[ChromosomeType], pop_size: int) -> list[ChromosomeType]: @@ -452,8 +451,8 @@ def get_order_part(order: np.ndarray, other_order: np.ndarray) -> np.ndarray: return np.array([node for node in other_order if node not in order]) -def mate_scheduling_order(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, copy: bool = True) \ - -> tuple[ChromosomeType, ChromosomeType]: +def mate_scheduling_order(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, + individual_constructor, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ Two-Point crossover for order. @@ -464,7 +463,8 @@ def mate_scheduling_order(ind1: ChromosomeType, ind2: ChromosomeType, rand: rand :return: two mated individuals """ - child1, child2 = (Individual(copy_chromosome(ind1)), Individual(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (individual_constructor(copy_chromosome(ind1)), + individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) order1, order2 = child1[0], child2[0] parent1 = ind1[0].copy() @@ -563,7 +563,7 @@ def mutate_scheduling_order(ind: ChromosomeType, mutpb: float, rand: random.Rand return ind -def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, +def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, individual_constructor, optimize_resources: bool, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ One-Point crossover for resources. @@ -576,7 +576,7 @@ def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Rand :return: two mated individuals """ - child1, child2 = (Individual(copy_chromosome(ind1)), Individual(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (individual_constructor(copy_chromosome(ind1)), individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) res1, res2 = child1[1], child2[1] num_works = len(res1) @@ -778,8 +778,8 @@ def mutate_values(chromosome_part: np.ndarray, row_indexes: np.ndarray, col_inde cur_row[col_index] = rand.choices(choices, weights=weights)[0] -def mate_for_zones(ind1: ChromosomeType, ind2: ChromosomeType, - rand: random.Random, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: +def mate_for_zones(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, individual_constructor, + copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ CxOnePoint for zones @@ -790,7 +790,7 @@ def mate_for_zones(ind1: ChromosomeType, ind2: ChromosomeType, :return: two mated individuals """ - child1, child2 = (Individual(copy_chromosome(ind1)), Individual(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (individual_constructor(copy_chromosome(ind1)), individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) zones1 = child1[4] zones2 = child2[4] diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index 8b8f9380..af26d749 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -32,11 +32,13 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, str, tuple[Schedule, list[GraphNode] | None, ScheduleSpec, float]], rand: random.Random, spec: ScheduleSpec = ScheduleSpec(), + fitness_weights: tuple = (-1,), work_estimator: WorkTimeEstimator = None, sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, assigned_parent_time: Time = Time(0), landscape: LandscapeConfiguration = LandscapeConfiguration(), only_lft_initialization: bool = False, + use_pareto_domination: bool = False, verbose: bool = True) \ -> tuple[Toolbox, dict[str, int], dict[int, dict[int, Worker]], dict[int, set[int]]]: start = time.time() @@ -139,6 +141,7 @@ def build_schedule(wg: WorkGraph, landscape: LandscapeConfiguration = LandscapeConfiguration(), fitness_constructor: Callable[ [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, + fitness_weights: tuple = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, n_cpu: int = 1, @@ -149,6 +152,7 @@ def build_schedule(wg: WorkGraph, optimize_resources: bool = False, deadline: Time | None = None, only_lft_initialization: bool = False, + use_pareto_domination: bool = False, verbose: bool = True) \ -> tuple[ScheduleWorkDict, Time, Timeline, list[GraphNode]]: """ @@ -170,9 +174,10 @@ def build_schedule(wg: WorkGraph, toolbox, *mapping_objects = create_toolbox_and_mapping_objects(wg, contractors, worker_pool, population_size, mutpb_order, mutpb_res, mutpb_zones, init_schedules, - rand, spec, work_estimator, sgs_type, - assigned_parent_time, landscape, - only_lft_initialization, verbose) + rand, spec, fitness_weights, work_estimator, + sgs_type, assigned_parent_time, landscape, + only_lft_initialization, use_pareto_domination, + verbose) worker_name2index, worker_pool_indices, parents = mapping_objects From b0392429009961b646775c5048b37e1ea940101e Mon Sep 17 00:00:00 2001 From: Timotshak Date: Wed, 24 Jan 2024 23:54:49 +0300 Subject: [PATCH 02/31] Adapt Genetic Algorithm to multi-objective tasks - Add fitness_weights and use_pareto_domination parameters in genetic algorithm - Add Individual and IndividualFitness classes - Add NSGA-II selection in genetic algorithm --- sampo/scheduler/genetic/converter.py | 2 +- sampo/scheduler/genetic/operators.py | 126 ++++++++++++-------- sampo/scheduler/genetic/schedule_builder.py | 4 +- 3 files changed, 82 insertions(+), 50 deletions(-) diff --git a/sampo/scheduler/genetic/converter.py b/sampo/scheduler/genetic/converter.py index 687f0b34..bf9fa589 100644 --- a/sampo/scheduler/genetic/converter.py +++ b/sampo/scheduler/genetic/converter.py @@ -19,7 +19,7 @@ from sampo.schemas.time_estimator import WorkTimeEstimator, DefaultWorkEstimator from sampo.utilities.linked_list import LinkedList -ChromosomeType = list[np.ndarray, np.ndarray, np.ndarray, ScheduleSpec, np.ndarray] +ChromosomeType = tuple[np.ndarray, np.ndarray, np.ndarray, ScheduleSpec, np.ndarray] class ScheduleGenerationScheme(Enum): diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index 7f122558..ba7c0df0 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -7,7 +7,7 @@ from typing import Callable, Iterable import numpy as np -from deap import creator, base +from deap import base, tools from sampo.scheduler.genetic.converter import (convert_chromosome_to_schedule, convert_schedule_to_chromosome, ChromosomeType, ScheduleGenerationScheme) @@ -65,9 +65,10 @@ def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]], self._resources_names = list(resources_names) if resources_names is not None else None @staticmethod - def prepare(resources_names: Iterable[str]) -> Callable[[list[ChromosomeType]], list[Schedule]]: + def prepare(resources_names: Iterable[str]) \ + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: """ - Returns the constructor of that fitness function prepared to use in Genetic + Returns the constructor of that fitness function prepared to use in Genetic algorithm """ return partial(SumOfResourcesPeaksFitness, resources_names=resources_names) @@ -87,9 +88,10 @@ def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]], self._resources_names = list(resources_names) if resources_names is not None else None @staticmethod - def prepare(resources_names: Iterable[str]) -> Callable[[list[ChromosomeType]], list[Schedule]]: + def prepare(resources_names: Iterable[str]) \ + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: """ - Returns the constructor of that fitness function prepared to use in Genetic + Returns the constructor of that fitness function prepared to use in Genetic algorithm """ return partial(SumOfResourcesFitness, resources_names=resources_names) @@ -109,9 +111,10 @@ def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]], self._resources_names = list(resources_names) if resources_names is not None else None @staticmethod - def prepare(resources_names: Iterable[str]) -> Callable[[list[ChromosomeType]], list[Schedule]]: + def prepare(resources_names: Iterable[str]) \ + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: """ - Returns the constructor of that fitness function prepared to use in Genetic + Returns the constructor of that fitness function prepared to use in Genetic algorithm """ return partial(TimeWithResourcesFitness, resources_names=resources_names) @@ -134,9 +137,9 @@ def __init__(self, deadline: Time, evaluator: Callable[[list[ChromosomeType]], l @staticmethod def prepare(deadline: Time, resources_names: Iterable[str] | None = None) \ - -> Callable[[list[ChromosomeType]], list[Schedule]]: + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: """ - Returns the constructor of that fitness function prepared to use in Genetic + Returns the constructor of that fitness function prepared to use in Genetic algorithm """ return partial(DeadlineResourcesFitness, deadline, resources_names=resources_names) @@ -160,9 +163,9 @@ def __init__(self, deadline: Time, evaluator: Callable[[list[ChromosomeType]], l @staticmethod def prepare(deadline: Time, resources_names: Iterable[str] | None = None) \ - -> Callable[[list[ChromosomeType]], list[Schedule]]: + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: """ - Returns the constructor of that fitness function prepared to use in Genetic + Returns the constructor of that fitness function prepared to use in Genetic algorithm """ return partial(DeadlineCostFitness, deadline, resources_names=resources_names) @@ -173,6 +176,19 @@ def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: for schedule in evaluated] +class Individual(list): + def __init__(self, individual_fitness_constructor: Callable[[], base.Fitness], *args, **kwargs): + super().__init__(*args, **kwargs) + self.fitness = individual_fitness_constructor() + + @staticmethod + def prepare(individual_fitness_constructor: Callable[[], base.Fitness]) -> Callable[[Iterable], list]: + """ + Returns the constructor of Individual prepared to use in Genetic algorithm + """ + return partial(Individual, individual_fitness_constructor) + + def init_toolbox(wg: WorkGraph, contractors: list[Contractor], worker_pool: WorkerContractorPool, @@ -198,25 +214,29 @@ def init_toolbox(wg: WorkGraph, children: dict[int, set[int]], resources_border: np.ndarray, assigned_parent_time: Time = Time(0), + fitness_weights: tuple = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, - only_lft_initialization: bool = False) -> base.Toolbox: + only_lft_initialization: bool = False, + use_pareto_domination: bool = False) -> base.Toolbox: """ Object, that include set of functions (tools) for genetic model and other functions related to it. list of parameters that received this function is sufficient and complete to manipulate with genetic algorithm :return: Object, included tools for genetic algorithm """ - creator.create('FitnessMin', base.Fitness, weights=(-1.0,)) - creator.create('Individual', list, fitness=creator.FitnessMin) - Individual = creator.Individual + class IndividualFitness(base.Fitness): + weights = fitness_weights + + individual_constructor = Individual.prepare(IndividualFitness) toolbox = base.Toolbox() # generate chromosome toolbox.register('generate_chromosome', generate_chromosome, wg=wg, contractors=contractors, work_id2index=work_id2index, worker_name2index=worker_name2index, contractor2index=contractor2index, contractor_borders=contractor_borders, spec=spec, - init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape) + init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape, + individual_constructor=individual_constructor) # create population # toolbox.register('population', tools.initRepeat, list, lambda: toolbox.generate_chromosome()) @@ -224,29 +244,30 @@ def init_toolbox(wg: WorkGraph, work_id2index=work_id2index, worker_name2index=worker_name2index, contractor2index=contractor2index, contractor_borders=contractor_borders, spec=spec, init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape, - only_lft_initialization=only_lft_initialization) + only_lft_initialization=only_lft_initialization, individual_constructor=individual_constructor) # selection - toolbox.register('select', select_new_population, pop_size=population_size) + selection = tools.selNSGA2 if use_pareto_domination else select_new_population + toolbox.register('select', selection, k=population_size) # combined crossover - toolbox.register('mate', mate, rand=rand) + toolbox.register('mate', mate, rand=rand, individual_constructor=individual_constructor) # combined mutation toolbox.register('mutate', mutate, order_mutpb=mut_order_pb, res_mutpb=mut_res_pb, zone_mutpb=mut_zone_pb, rand=rand, parents=parents, children=children, resources_border=resources_border, statuses_available=statuses_available) # crossover for order - toolbox.register('mate_order', mate_scheduling_order, rand=rand) + toolbox.register('mate_order', mate_scheduling_order, rand=rand, individual_constructor=individual_constructor) # mutation for order toolbox.register('mutate_order', mutate_scheduling_order, mutpb=mut_order_pb, rand=rand, parents=parents, children=children) # crossover for resources - toolbox.register('mate_resources', mate_resources, rand=rand) + toolbox.register('mate_resources', mate_resources, rand=rand, individual_constructor=individual_constructor) # mutation for resources toolbox.register('mutate_resources', mutate_resources, resources_border=resources_border, mutpb=mut_res_pb, rand=rand) # mutation for resource borders toolbox.register('mutate_resource_borders', mutate_resource_borders, contractor_borders=contractor_borders, mutpb=mut_res_pb, rand=rand) - toolbox.register('mate_post_zones', mate_for_zones, rand=rand) + toolbox.register('mate_post_zones', mate_for_zones, rand=rand, individual_constructor=individual_constructor) toolbox.register('mutate_post_zones', mutate_for_zones, rand=rand, mutpb=mut_zone_pb, statuses_available=landscape.zone_config.statuses.statuses_available()) @@ -256,20 +277,19 @@ def init_toolbox(wg: WorkGraph, work_id2index=work_id2index, worker_name2index=worker_name2index, contractor2index=contractor2index, contractor_borders=contractor_borders, spec=spec, landscape=landscape) - toolbox.register("chromosome_to_schedule", convert_chromosome_to_schedule, worker_pool=worker_pool, + toolbox.register('chromosome_to_schedule', convert_chromosome_to_schedule, worker_pool=worker_pool, index2node=index2node, index2contractor=index2contractor_obj, worker_pool_indices=worker_pool_indices, assigned_parent_time=assigned_parent_time, work_estimator=work_estimator, worker_name2index=worker_name2index, contractor2index=contractor2index, index2zone=index2zone, landscape=landscape, sgs_type=sgs_type) - toolbox.register('copy_individual', lambda ind: Individual(copy_chromosome(ind))) + toolbox.register('copy_individual', copy_individual, individual_constructor=individual_constructor) return toolbox -def copy_chromosome(chromosome: ChromosomeType) -> ChromosomeType: - return chromosome[0].copy(), chromosome[1].copy(), chromosome[2].copy(), \ - deepcopy(chromosome[3]), chromosome[4].copy() +def copy_individual(ind: Individual, individual_constructor: Callable[[Iterable], Individual]) -> Individual: + return individual_constructor((ind[0].copy(), ind[1].copy(), ind[2].copy(), deepcopy(ind[3]), ind[4].copy())) def generate_population(n: int, @@ -282,10 +302,10 @@ def generate_population(n: int, contractor_borders: np.ndarray, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], rand: random.Random, - individual_constructor, + individual_constructor: Callable[[Iterable], Individual], work_estimator: WorkTimeEstimator = None, landscape: LandscapeConfiguration = LandscapeConfiguration(), - only_lft_initialization: bool = False) -> list[ChromosomeType]: + only_lft_initialization: bool = False) -> list[Individual]: """ Generates population. Do not use `generate_chromosome` function. @@ -350,9 +370,9 @@ def generate_chromosome(wg: WorkGraph, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], spec: ScheduleSpec, rand: random.Random, - individual_constructor, + individual_constructor: Callable[[Iterable], Individual], work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), - landscape: LandscapeConfiguration = LandscapeConfiguration()) -> ChromosomeType: + landscape: LandscapeConfiguration = LandscapeConfiguration()) -> Individual: """ It is necessary to generate valid scheduling, which are satisfied to current dependencies That's why will be used the approved order of works (HEFT order and Topological sorting) @@ -388,13 +408,13 @@ def randomized_init() -> ChromosomeType: return individual_constructor(chromosome) -def select_new_population(population: list[ChromosomeType], pop_size: int) -> list[ChromosomeType]: +def select_new_population(population: list[Individual], k: int) -> list[Individual]: """ Selection operator for genetic algorithm. - Select top n individuals in population. + Select top k individuals in population. """ population = sorted(population, key=attrgetter('fitness'), reverse=True) - return population[:pop_size] + return population[:k] def is_chromosome_correct(chromosome: ChromosomeType, node_indices: list[int], parents: dict[int, set[int]], @@ -451,20 +471,22 @@ def get_order_part(order: np.ndarray, other_order: np.ndarray) -> np.ndarray: return np.array([node for node in other_order if node not in order]) -def mate_scheduling_order(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, - individual_constructor, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: +def mate_scheduling_order(ind1: Individual, ind2: Individual, rand: random.Random, + individual_constructor: Callable[[Iterable], Individual], + copy: bool = True) -> tuple[Individual, Individual]: """ Two-Point crossover for order. :param ind1: first individual :param ind2: second individual :param rand: the rand object used for randomized operations + :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (individual_constructor(copy_chromosome(ind1)), - individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (copy_individual(ind1, individual_constructor), + copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) order1, order2 = child1[0], child2[0] parent1 = ind1[0].copy() @@ -563,8 +585,9 @@ def mutate_scheduling_order(ind: ChromosomeType, mutpb: float, rand: random.Rand return ind -def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, individual_constructor, - optimize_resources: bool, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: +def mate_resources(ind1: Individual, ind2: Individual, rand: random.Random, + individual_constructor: Callable[[Iterable], Individual], + optimize_resources: bool, copy: bool = True) -> tuple[Individual, Individual]: """ One-Point crossover for resources. @@ -572,11 +595,13 @@ def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Rand :param ind2: second individual :param optimize_resources: if True resource borders should be changed after mating :param rand: the rand object used for randomized operations + :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (individual_constructor(copy_chromosome(ind1)), individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (copy_individual(ind1, individual_constructor), + copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) res1, res2 = child1[1], child2[1] num_works = len(res1) @@ -661,8 +686,9 @@ def mutate_resources(ind: ChromosomeType, mutpb: float, rand: random.Random, return ind -def mate(ind1: ChromosomeType, ind2: ChromosomeType, optimize_resources: bool, rand: random.Random) \ - -> tuple[ChromosomeType, ChromosomeType]: +def mate(ind1: Individual, ind2: Individual, optimize_resources: bool, rand: random.Random, + individual_constructor: Callable[[Iterable], Individual]) \ + -> tuple[Individual, Individual]: """ Combined crossover function of Two-Point crossover for order, One-Point crossover for resources and One-Point crossover for zones. @@ -671,11 +697,12 @@ def mate(ind1: ChromosomeType, ind2: ChromosomeType, optimize_resources: bool, r :param ind2: second individual :param optimize_resources: if True resource borders should be changed after mating :param rand: the rand object used for randomized operations + :param individual_constructor: prepared constructor of Individual class :return: two mated individuals """ - child1, child2 = mate_scheduling_order(ind1, ind2, rand, copy=True) - child1, child2 = mate_resources(child1, child2, rand, optimize_resources, copy=False) + child1, child2 = mate_scheduling_order(ind1, ind2, rand, individual_constructor, copy=True) + child1, child2 = mate_resources(child1, child2, rand, individual_constructor, optimize_resources, copy=False) # TODO Make better crossover for zones and uncomment this # child1, child2 = mate_for_zones(child1, child2, rand, copy=False) @@ -778,19 +805,22 @@ def mutate_values(chromosome_part: np.ndarray, row_indexes: np.ndarray, col_inde cur_row[col_index] = rand.choices(choices, weights=weights)[0] -def mate_for_zones(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, individual_constructor, - copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: +def mate_for_zones(ind1: Individual, ind2: Individual, rand: random.Random, + individual_constructor: Callable[[Iterable], Individual], + copy: bool = True) -> tuple[Individual, Individual]: """ CxOnePoint for zones :param ind1: first individual :param ind2: second individual :param rand: the rand object used for randomized operations + :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (individual_constructor(copy_chromosome(ind1)), individual_constructor(copy_chromosome(ind2))) if copy else (ind1, ind2) + child1, child2 = (copy_individual(ind1, individual_constructor), + copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) zones1 = child1[4] zones2 = child2[4] diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index af26d749..ec6c73f7 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -122,9 +122,11 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, children, resources_border, assigned_parent_time, + fitness_weights, work_estimator, sgs_type, - only_lft_initialization), worker_name2index, worker_pool_indices, parents + only_lft_initialization, + use_pareto_domination), worker_name2index, worker_pool_indices, parents def build_schedule(wg: WorkGraph, From 4aa3f703bdd2cf2ad4fdc6aa56e2809f927685fc Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 00:14:35 +0300 Subject: [PATCH 03/31] refactor build_schedule in genetic algorithm --- sampo/scheduler/genetic/schedule_builder.py | 54 +++++++++------------ 1 file changed, 22 insertions(+), 32 deletions(-) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index ec6c73f7..6f4bbf28 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -235,18 +235,7 @@ def build_schedule(wg: WorkGraph, rand.shuffle(pop) - offspring = [] - - for ind1, ind2 in zip(pop[::2], pop[1::2]): - # mate - offspring.extend(toolbox.mate(ind1, ind2, optimize_resources)) - - for mutant in offspring: - # mutation - if optimize_resources: - # resource borders mutation - toolbox.mutate_resource_borders(mutant) - toolbox.mutate(mutant) + offspring = make_offspring(toolbox, pop, optimize_resources) evaluation_start = time.time() @@ -264,10 +253,7 @@ def build_schedule(wg: WorkGraph, prev_best_fitness = best_fitness best_fitness = hof[0].fitness.values[0] - if best_fitness == prev_best_fitness: - plateau_steps += 1 - else: - plateau_steps = 0 + plateau_steps = plateau_steps + 1 if best_fitness == prev_best_fitness else 0 if have_deadline and best_fitness <= deadline: if all([ind.fitness.values[0] <= deadline for ind in pop]): @@ -332,19 +318,10 @@ def build_schedule(wg: WorkGraph, and (time_border is None or time.time() - global_start < time_border): if verbose: print(f'-- Generation {generation}, population={len(pop)}, best peak={best_fitness} --') - rand.shuffle(pop) - - offspring = [] - for ind1, ind2 in zip(pop[::2], pop[1::2]): - # mate - offspring.extend(toolbox.mate(ind1, ind2, optimize_resources)) + rand.shuffle(pop) - for mutant in offspring: - # resource borders mutation - toolbox.mutate_resource_borders(mutant) - # other mutation - toolbox.mutate(mutant) + offspring = make_offspring(toolbox, pop, optimize_resources) evaluation_start = time.time() @@ -369,10 +346,7 @@ def build_schedule(wg: WorkGraph, prev_best_fitness = best_fitness best_fitness = hof[0].fitness.values[0] - if best_fitness == prev_best_fitness: - plateau_steps += 1 - else: - plateau_steps = 0 + plateau_steps = plateau_steps + 1 if best_fitness == prev_best_fitness else 0 generation += 1 @@ -393,5 +367,21 @@ def build_schedule(wg: WorkGraph, return {node.id: work for node, work in scheduled_works.items()}, schedule_start_time, timeline, order_nodes -def compare_individuals(first: tuple[ChromosomeType], second: tuple[ChromosomeType]) -> bool: +def compare_individuals(first: ChromosomeType, second: ChromosomeType) -> bool: return (first[0] == second[0]).all() and (first[1] == second[1]).all() and (first[2] == second[2]).all() + + +def make_offspring(toolbox: Toolbox, population: list[ChromosomeType], optimize_resources: bool) -> list[ChromosomeType]: + offspring = [] + + for ind1, ind2 in zip(population[::2], population[1::2]): + # mate + offspring.extend(toolbox.mate(ind1, ind2, optimize_resources)) + + for mutant in offspring: + # resource borders mutation + toolbox.mutate_resource_borders(mutant) + # other mutation + toolbox.mutate(mutant) + + return offspring From 6a20fc774b5310355cf77382b05769f198ba9360 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 00:14:55 +0300 Subject: [PATCH 04/31] fix typing in Individual --- sampo/scheduler/genetic/operators.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index ba7c0df0..cf1b4e81 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -177,12 +177,12 @@ def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: class Individual(list): - def __init__(self, individual_fitness_constructor: Callable[[], base.Fitness], *args, **kwargs): - super().__init__(*args, **kwargs) + def __init__(self, individual_fitness_constructor: Callable[[], base.Fitness], chromosome: ChromosomeType): + super().__init__(chromosome) self.fitness = individual_fitness_constructor() @staticmethod - def prepare(individual_fitness_constructor: Callable[[], base.Fitness]) -> Callable[[Iterable], list]: + def prepare(individual_fitness_constructor: Callable[[], base.Fitness]) -> Callable[[ChromosomeType], list]: """ Returns the constructor of Individual prepared to use in Genetic algorithm """ From 18c1049941e8d874c283c8e74bd7aec6a990ec5b Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 00:18:06 +0300 Subject: [PATCH 05/31] fix typing in genetic operators --- sampo/scheduler/genetic/operators.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index cf1b4e81..306b868b 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -288,7 +288,7 @@ class IndividualFitness(base.Fitness): return toolbox -def copy_individual(ind: Individual, individual_constructor: Callable[[Iterable], Individual]) -> Individual: +def copy_individual(ind: Individual, individual_constructor: Callable[[ChromosomeType], Individual]) -> Individual: return individual_constructor((ind[0].copy(), ind[1].copy(), ind[2].copy(), deepcopy(ind[3]), ind[4].copy())) @@ -302,7 +302,7 @@ def generate_population(n: int, contractor_borders: np.ndarray, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], rand: random.Random, - individual_constructor: Callable[[Iterable], Individual], + individual_constructor: Callable[[ChromosomeType], Individual], work_estimator: WorkTimeEstimator = None, landscape: LandscapeConfiguration = LandscapeConfiguration(), only_lft_initialization: bool = False) -> list[Individual]: @@ -370,7 +370,7 @@ def generate_chromosome(wg: WorkGraph, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], spec: ScheduleSpec, rand: random.Random, - individual_constructor: Callable[[Iterable], Individual], + individual_constructor: Callable[[ChromosomeType], Individual], work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), landscape: LandscapeConfiguration = LandscapeConfiguration()) -> Individual: """ @@ -472,7 +472,7 @@ def get_order_part(order: np.ndarray, other_order: np.ndarray) -> np.ndarray: def mate_scheduling_order(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[Iterable], Individual], + individual_constructor: Callable[[ChromosomeType], Individual], copy: bool = True) -> tuple[Individual, Individual]: """ Two-Point crossover for order. @@ -586,7 +586,7 @@ def mutate_scheduling_order(ind: ChromosomeType, mutpb: float, rand: random.Rand def mate_resources(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[Iterable], Individual], + individual_constructor: Callable[[ChromosomeType], Individual], optimize_resources: bool, copy: bool = True) -> tuple[Individual, Individual]: """ One-Point crossover for resources. @@ -687,7 +687,7 @@ def mutate_resources(ind: ChromosomeType, mutpb: float, rand: random.Random, def mate(ind1: Individual, ind2: Individual, optimize_resources: bool, rand: random.Random, - individual_constructor: Callable[[Iterable], Individual]) \ + individual_constructor: Callable[[ChromosomeType], Individual]) \ -> tuple[Individual, Individual]: """ Combined crossover function of Two-Point crossover for order, One-Point crossover for resources @@ -806,7 +806,7 @@ def mutate_values(chromosome_part: np.ndarray, row_indexes: np.ndarray, col_inde def mate_for_zones(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[Iterable], Individual], + individual_constructor: Callable[[ChromosomeType], Individual], copy: bool = True) -> tuple[Individual, Individual]: """ CxOnePoint for zones From 617f8e06c6a0305b94772770b011b25204bc4d0b Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 02:25:42 +0300 Subject: [PATCH 06/31] introduce multi-criteria in genetic algorithm --- sampo/scheduler/genetic/base.py | 7 +- sampo/scheduler/genetic/operators.py | 151 +++++++++----------- sampo/scheduler/genetic/schedule_builder.py | 116 ++++++++------- 3 files changed, 133 insertions(+), 141 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index b9748851..f0ffcfb5 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -42,14 +42,13 @@ def __init__(self, n_cpu: int = 1, weights: Optional[list[int] or None] = None, fitness_constructor: Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, - fitness_weights: tuple = (-1,), + fitness_weights: tuple[int | float] = (-1,), scheduler_type: SchedulerType = SchedulerType.Genetic, resource_optimizer: ResourceOptimizer = IdentityResourceOptimizer(), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, optimize_resources: bool = False, only_lft_initialization: bool = False, - use_pareto_domination: bool = False, verbose: bool = True): super().__init__(scheduler_type=scheduler_type, resource_optimizer=resource_optimizer, @@ -69,7 +68,6 @@ def __init__(self, self._n_cpu = n_cpu self._weights = weights self._only_lft_initialization = only_lft_initialization - self._use_pareto_domination = use_pareto_domination self._verbose = verbose self._time_border = None @@ -148,9 +146,6 @@ def set_verbose(self, verbose: bool): def set_only_lft_initialization(self, only_lft_initialization: bool): self._only_lft_initialization = only_lft_initialization - def set_use_pareto_domination(self, use_pareto_domination: bool): - self._use_pareto_domination = use_pareto_domination - @staticmethod def generate_first_population(wg: WorkGraph, contractors: list[Contractor], diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index 306b868b..70b641df 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -37,7 +37,7 @@ def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]]): self._evaluator = evaluator @abstractmethod - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int | float]]: """ Calculate the value of fitness function of the all chromosomes. It is better when value is less. @@ -50,8 +50,8 @@ class TimeFitness(FitnessFunction): Fitness function that relies on finish time. """ - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: - return [schedule.execution_time.value for schedule in self._evaluator(chromosomes)] + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int]]: + return [(schedule.execution_time.value,) for schedule in self._evaluator(chromosomes)] class SumOfResourcesPeaksFitness(FitnessFunction): @@ -72,9 +72,9 @@ def prepare(resources_names: Iterable[str]) \ """ return partial(SumOfResourcesPeaksFitness, resources_names=resources_names) - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int]]: evaluated = self._evaluator(chromosomes) - return [resources_peaks_sum(schedule, self._resources_names) for schedule in evaluated] + return [(resources_peaks_sum(schedule, self._resources_names),) for schedule in evaluated] class SumOfResourcesFitness(FitnessFunction): @@ -95,9 +95,9 @@ def prepare(resources_names: Iterable[str]) \ """ return partial(SumOfResourcesFitness, resources_names=resources_names) - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int]]: evaluated = self._evaluator(chromosomes) - return [resources_sum(schedule, self._resources_names) for schedule in evaluated] + return [(resources_sum(schedule, self._resources_names),) for schedule in evaluated] class TimeWithResourcesFitness(FitnessFunction): @@ -118,9 +118,9 @@ def prepare(resources_names: Iterable[str]) \ """ return partial(TimeWithResourcesFitness, resources_names=resources_names) - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int]]: evaluated = self._evaluator(chromosomes) - return [schedule.execution_time.value + resources_peaks_sum(schedule, self._resources_names) + return [(schedule.execution_time.value + resources_peaks_sum(schedule, self._resources_names),) for schedule in evaluated] @@ -143,10 +143,10 @@ def prepare(deadline: Time, resources_names: Iterable[str] | None = None) \ """ return partial(DeadlineResourcesFitness, deadline, resources_names=resources_names) - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[float]]: evaluated = self._evaluator(chromosomes) - return [int(resources_peaks_sum(schedule, self._resources_names) - * max(1.0, schedule.execution_time.value / self._deadline.value)) + return [(resources_peaks_sum(schedule, self._resources_names) + * max(1.0, schedule.execution_time.value / self._deadline.value),) for schedule in evaluated] @@ -169,10 +169,11 @@ def prepare(deadline: Time, resources_names: Iterable[str] | None = None) \ """ return partial(DeadlineCostFitness, deadline, resources_names=resources_names) - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[int]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[float]]: evaluated = self._evaluator(chromosomes) # TODO Integrate cost calculation to native module - return [int(resources_costs_sum(schedule, self._resources_names) * max(1.0, schedule.execution_time.value / self._deadline.value)) + return [(resources_costs_sum(schedule, self._resources_names) + * max(1.0, schedule.execution_time.value / self._deadline.value),) for schedule in evaluated] @@ -214,60 +215,56 @@ def init_toolbox(wg: WorkGraph, children: dict[int, set[int]], resources_border: np.ndarray, assigned_parent_time: Time = Time(0), - fitness_weights: tuple = (-1,), + fitness_weights: tuple[int | float] = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, only_lft_initialization: bool = False, - use_pareto_domination: bool = False) -> base.Toolbox: + is_multiobjective: bool = False) -> base.Toolbox: """ Object, that include set of functions (tools) for genetic model and other functions related to it. list of parameters that received this function is sufficient and complete to manipulate with genetic algorithm :return: Object, included tools for genetic algorithm """ - class IndividualFitness(base.Fitness): - weights = fitness_weights - - individual_constructor = Individual.prepare(IndividualFitness) - toolbox = base.Toolbox() + toolbox.register('register_individual_constructor', register_individual_constructor, toolbox=toolbox) + toolbox.register_individual_constructor(fitness_weights) # generate chromosome toolbox.register('generate_chromosome', generate_chromosome, wg=wg, contractors=contractors, work_id2index=work_id2index, worker_name2index=worker_name2index, contractor2index=contractor2index, contractor_borders=contractor_borders, spec=spec, - init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape, - individual_constructor=individual_constructor) + init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape) # create population # toolbox.register('population', tools.initRepeat, list, lambda: toolbox.generate_chromosome()) - toolbox.register('population', generate_population, wg=wg, contractors=contractors, + toolbox.register('population_chromosomes', generate_chromosomes, wg=wg, contractors=contractors, work_id2index=work_id2index, worker_name2index=worker_name2index, contractor2index=contractor2index, contractor_borders=contractor_borders, spec=spec, init_chromosomes=init_chromosomes, rand=rand, work_estimator=work_estimator, landscape=landscape, - only_lft_initialization=only_lft_initialization, individual_constructor=individual_constructor) + only_lft_initialization=only_lft_initialization) # selection - selection = tools.selNSGA2 if use_pareto_domination else select_new_population + selection = tools.selNSGA2 if is_multiobjective else select_new_population toolbox.register('select', selection, k=population_size) # combined crossover - toolbox.register('mate', mate, rand=rand, individual_constructor=individual_constructor) + toolbox.register('mate', mate, rand=rand) # combined mutation toolbox.register('mutate', mutate, order_mutpb=mut_order_pb, res_mutpb=mut_res_pb, zone_mutpb=mut_zone_pb, rand=rand, parents=parents, children=children, resources_border=resources_border, statuses_available=statuses_available) # crossover for order - toolbox.register('mate_order', mate_scheduling_order, rand=rand, individual_constructor=individual_constructor) + toolbox.register('mate_order', mate_scheduling_order, rand=rand) # mutation for order toolbox.register('mutate_order', mutate_scheduling_order, mutpb=mut_order_pb, rand=rand, parents=parents, children=children) # crossover for resources - toolbox.register('mate_resources', mate_resources, rand=rand, individual_constructor=individual_constructor) + toolbox.register('mate_resources', mate_resources, rand=rand) # mutation for resources toolbox.register('mutate_resources', mutate_resources, resources_border=resources_border, mutpb=mut_res_pb, rand=rand) # mutation for resource borders toolbox.register('mutate_resource_borders', mutate_resource_borders, contractor_borders=contractor_borders, mutpb=mut_res_pb, rand=rand) - toolbox.register('mate_post_zones', mate_for_zones, rand=rand, individual_constructor=individual_constructor) + toolbox.register('mate_post_zones', mate_for_zones, rand=rand) toolbox.register('mutate_post_zones', mutate_for_zones, rand=rand, mutpb=mut_zone_pb, statuses_available=landscape.zone_config.statuses.statuses_available()) @@ -283,31 +280,37 @@ class IndividualFitness(base.Fitness): work_estimator=work_estimator, worker_name2index=worker_name2index, contractor2index=contractor2index, index2zone=index2zone, landscape=landscape, sgs_type=sgs_type) - toolbox.register('copy_individual', copy_individual, individual_constructor=individual_constructor) + toolbox.register('copy_individual', lambda ind: toolbox.Individual(copy_chromosome(ind))) return toolbox -def copy_individual(ind: Individual, individual_constructor: Callable[[ChromosomeType], Individual]) -> Individual: - return individual_constructor((ind[0].copy(), ind[1].copy(), ind[2].copy(), deepcopy(ind[3]), ind[4].copy())) +def register_individual_constructor(fitness_weights: tuple[int | float], toolbox: base.Toolbox): + class IndividualFitness(base.Fitness): + weights = fitness_weights + toolbox.register('Individual', Individual.prepare(IndividualFitness)) -def generate_population(n: int, - wg: WorkGraph, - contractors: list[Contractor], - spec: ScheduleSpec, - work_id2index: dict[str, int], - worker_name2index: dict[str, int], - contractor2index: dict[str, int], - contractor_borders: np.ndarray, - init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], - rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual], - work_estimator: WorkTimeEstimator = None, - landscape: LandscapeConfiguration = LandscapeConfiguration(), - only_lft_initialization: bool = False) -> list[Individual]: + +def copy_chromosome(ind: ChromosomeType) -> ChromosomeType: + return ind[0].copy(), ind[1].copy(), ind[2].copy(), deepcopy(ind[3]), ind[4].copy() + + +def generate_chromosomes(n: int, + wg: WorkGraph, + contractors: list[Contractor], + spec: ScheduleSpec, + work_id2index: dict[str, int], + worker_name2index: dict[str, int], + contractor2index: dict[str, int], + contractor_borders: np.ndarray, + init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], + rand: random.Random, + work_estimator: WorkTimeEstimator = None, + landscape: LandscapeConfiguration = LandscapeConfiguration(), + only_lft_initialization: bool = False) -> list[ChromosomeType]: """ - Generates population. + Generates n chromosomes. Do not use `generate_chromosome` function. """ @@ -322,8 +325,8 @@ def randomized_init(is_topological: bool = False) -> ChromosomeType: contractor2index, contractor_borders, schedule, spec, landscape) if only_lft_initialization: - chromosomes = [individual_constructor(randomized_init(is_topological=False)) for _ in range(n - 1)] - chromosomes.append(individual_constructor(init_chromosomes['lft'][0])) + chromosomes = [randomized_init(is_topological=False) for _ in range(n - 1)] + chromosomes.append(init_chromosomes['lft'][0]) return chromosomes count_for_specified_types = (n // 3) // len(init_chromosomes) @@ -350,11 +353,11 @@ def randomized_init(is_topological: bool = False) -> ChromosomeType: for generated_type in chromosome_types: match generated_type: case 'topological': - ind = individual_constructor(randomized_init(is_topological=True)) + ind = randomized_init(is_topological=True) case 'rand_lft': - ind = individual_constructor(randomized_init(is_topological=False)) + ind = randomized_init(is_topological=False) case _: - ind = individual_constructor(init_chromosomes[generated_type][0]) + ind = init_chromosomes[generated_type][0] chromosomes.append(ind) @@ -370,9 +373,8 @@ def generate_chromosome(wg: WorkGraph, init_chromosomes: dict[str, tuple[ChromosomeType, float, ScheduleSpec]], spec: ScheduleSpec, rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual], work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), - landscape: LandscapeConfiguration = LandscapeConfiguration()) -> Individual: + landscape: LandscapeConfiguration = LandscapeConfiguration()) -> ChromosomeType: """ It is necessary to generate valid scheduling, which are satisfied to current dependencies That's why will be used the approved order of works (HEFT order and Topological sorting) @@ -405,7 +407,7 @@ def randomized_init() -> ChromosomeType: else: chromosome = randomized_init() - return individual_constructor(chromosome) + return chromosome def select_new_population(population: list[Individual], k: int) -> list[Individual]: @@ -471,22 +473,19 @@ def get_order_part(order: np.ndarray, other_order: np.ndarray) -> np.ndarray: return np.array([node for node in other_order if node not in order]) -def mate_scheduling_order(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual], - copy: bool = True) -> tuple[Individual, Individual]: +def mate_scheduling_order(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, + copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ Two-Point crossover for order. :param ind1: first individual :param ind2: second individual :param rand: the rand object used for randomized operations - :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (copy_individual(ind1, individual_constructor), - copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) + child1, child2 = (copy_chromosome(ind1), copy_chromosome(ind2)) if copy else (ind1, ind2) order1, order2 = child1[0], child2[0] parent1 = ind1[0].copy() @@ -585,9 +584,8 @@ def mutate_scheduling_order(ind: ChromosomeType, mutpb: float, rand: random.Rand return ind -def mate_resources(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual], - optimize_resources: bool, copy: bool = True) -> tuple[Individual, Individual]: +def mate_resources(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, + optimize_resources: bool, copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ One-Point crossover for resources. @@ -595,13 +593,11 @@ def mate_resources(ind1: Individual, ind2: Individual, rand: random.Random, :param ind2: second individual :param optimize_resources: if True resource borders should be changed after mating :param rand: the rand object used for randomized operations - :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (copy_individual(ind1, individual_constructor), - copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) + child1, child2 = (copy_chromosome(ind1), copy_chromosome(ind2)) if copy else (ind1, ind2) res1, res2 = child1[1], child2[1] num_works = len(res1) @@ -686,9 +682,8 @@ def mutate_resources(ind: ChromosomeType, mutpb: float, rand: random.Random, return ind -def mate(ind1: Individual, ind2: Individual, optimize_resources: bool, rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual]) \ - -> tuple[Individual, Individual]: +def mate(ind1: ChromosomeType, ind2: ChromosomeType, optimize_resources: bool, rand: random.Random) \ + -> tuple[ChromosomeType, ChromosomeType]: """ Combined crossover function of Two-Point crossover for order, One-Point crossover for resources and One-Point crossover for zones. @@ -697,12 +692,11 @@ def mate(ind1: Individual, ind2: Individual, optimize_resources: bool, rand: ran :param ind2: second individual :param optimize_resources: if True resource borders should be changed after mating :param rand: the rand object used for randomized operations - :param individual_constructor: prepared constructor of Individual class :return: two mated individuals """ - child1, child2 = mate_scheduling_order(ind1, ind2, rand, individual_constructor, copy=True) - child1, child2 = mate_resources(child1, child2, rand, individual_constructor, optimize_resources, copy=False) + child1, child2 = mate_scheduling_order(ind1, ind2, rand, copy=True) + child1, child2 = mate_resources(child1, child2, rand, optimize_resources, copy=False) # TODO Make better crossover for zones and uncomment this # child1, child2 = mate_for_zones(child1, child2, rand, copy=False) @@ -805,22 +799,19 @@ def mutate_values(chromosome_part: np.ndarray, row_indexes: np.ndarray, col_inde cur_row[col_index] = rand.choices(choices, weights=weights)[0] -def mate_for_zones(ind1: Individual, ind2: Individual, rand: random.Random, - individual_constructor: Callable[[ChromosomeType], Individual], - copy: bool = True) -> tuple[Individual, Individual]: +def mate_for_zones(ind1: ChromosomeType, ind2: ChromosomeType, rand: random.Random, + copy: bool = True) -> tuple[ChromosomeType, ChromosomeType]: """ CxOnePoint for zones :param ind1: first individual :param ind2: second individual :param rand: the rand object used for randomized operations - :param individual_constructor: prepared constructor of Individual class :param copy: if True individuals will be copied before mating so as not to change them :return: two mated individuals """ - child1, child2 = (copy_individual(ind1, individual_constructor), - copy_individual(ind2, individual_constructor)) if copy else (ind1, ind2) + child1, child2 = (copy_chromosome(ind1), copy_chromosome(ind2)) if copy else (ind1, ind2) zones1 = child1[4] zones2 = child2[4] diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index 6f4bbf28..2fafc3e1 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -32,13 +32,13 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, str, tuple[Schedule, list[GraphNode] | None, ScheduleSpec, float]], rand: random.Random, spec: ScheduleSpec = ScheduleSpec(), - fitness_weights: tuple = (-1,), + fitness_weights: tuple[int | float] = (-1,), work_estimator: WorkTimeEstimator = None, sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, assigned_parent_time: Time = Time(0), landscape: LandscapeConfiguration = LandscapeConfiguration(), only_lft_initialization: bool = False, - use_pareto_domination: bool = False, + is_multiobjective: bool = False, verbose: bool = True) \ -> tuple[Toolbox, dict[str, int], dict[int, dict[int, Worker]], dict[int, set[int]]]: start = time.time() @@ -126,7 +126,7 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, work_estimator, sgs_type, only_lft_initialization, - use_pareto_domination), worker_name2index, worker_pool_indices, parents + is_multiobjective), worker_name2index, worker_pool_indices, parents def build_schedule(wg: WorkGraph, @@ -143,7 +143,7 @@ def build_schedule(wg: WorkGraph, landscape: LandscapeConfiguration = LandscapeConfiguration(), fitness_constructor: Callable[ [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, - fitness_weights: tuple = (-1,), + fitness_weights: tuple[int | float] = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, n_cpu: int = 1, @@ -154,7 +154,7 @@ def build_schedule(wg: WorkGraph, optimize_resources: bool = False, deadline: Time | None = None, only_lft_initialization: bool = False, - use_pareto_domination: bool = False, + is_multiobjective: bool = False, verbose: bool = True) \ -> tuple[ScheduleWorkDict, Time, Timeline, list[GraphNode]]: """ @@ -178,7 +178,7 @@ def build_schedule(wg: WorkGraph, mutpb_order, mutpb_res, mutpb_zones, init_schedules, rand, spec, fitness_weights, work_estimator, sgs_type, assigned_parent_time, landscape, - only_lft_initialization, use_pareto_domination, + only_lft_initialization, is_multiobjective, verbose) worker_name2index, worker_pool_indices, parents = mapping_objects @@ -186,37 +186,39 @@ def build_schedule(wg: WorkGraph, native = NativeWrapper(toolbox, wg, contractors, worker_name2index, worker_pool_indices, parents, work_estimator) # create population of a given size - pop = toolbox.population(n=population_size) + chromosomes = toolbox.population_chromosomes(n=population_size) if verbose: print(f'Toolbox initialization & first population took {(time.time() - start) * 1000} ms') if native.native: native_start = time.time() - best_chromosome = native.run_genetic(pop, mutpb_order, mutpb_order, mutpb_res, mutpb_res, mutpb_res, mutpb_res, - population_size) + best_chromosome = native.run_genetic(chromosomes, mutpb_order, mutpb_order, mutpb_res, mutpb_res, mutpb_res, + mutpb_res, population_size) if verbose: print(f'Native evaluated in {(time.time() - native_start) * 1000} ms') else: have_deadline = deadline is not None # save best individuals - hof = tools.HallOfFame(1, similar=compare_individuals) + hof = tools.ParetoFront(similar=compare_individuals) fitness_f = fitness_constructor(native.evaluate) if not have_deadline else TimeFitness(native.evaluate) + if have_deadline: + toolbox.register_individual_constructor((-1,)) + pop = [toolbox.Individual(chromosome) for chromosome in chromosomes if toolbox.validate(chromosome)] evaluation_start = time.time() # map to each individual fitness function - pop = [ind for ind in pop if toolbox.validate(ind)] fitness = fitness_f.evaluate(pop) evaluation_time = time.time() - evaluation_start for ind, fit in zip(pop, fitness): - ind.fitness.values = [fit] + ind.fitness.values = fit hof.update(pop) - best_fitness = hof[0].fitness.values[0] + best_fitness = hof[0].fitness.values if verbose: print(f'First population evaluation took {evaluation_time * 1000} ms') @@ -235,27 +237,28 @@ def build_schedule(wg: WorkGraph, rand.shuffle(pop) - offspring = make_offspring(toolbox, pop, optimize_resources) + offspring_chromosomes = make_offspring(toolbox, pop, optimize_resources) + offspring = [toolbox.Individual(chromosome) for chromosome in offspring_chromosomes] evaluation_start = time.time() offspring_fitness = fitness_f.evaluate(offspring) for ind, fit in zip(offspring, offspring_fitness): - ind.fitness.values = [fit] + ind.fitness.values = fit evaluation_time += time.time() - evaluation_start # renewing population pop += offspring pop = toolbox.select(pop) - hof.update([pop[0]]) + hof.update(pop) prev_best_fitness = best_fitness - best_fitness = hof[0].fitness.values[0] + best_fitness = hof[0].fitness.values plateau_steps = plateau_steps + 1 if best_fitness == prev_best_fitness else 0 - if have_deadline and best_fitness <= deadline: + if have_deadline and best_fitness[0] <= deadline: if all([ind.fitness.values[0] <= deadline for ind in pop]): break @@ -265,52 +268,53 @@ def build_schedule(wg: WorkGraph, if have_deadline: - fitness_resource = fitness_constructor(native.evaluate) - - if best_fitness > deadline: - print(f'Deadline not reached !!! Deadline {deadline} < best time {best_fitness}') - # save best individuals - hof = tools.HallOfFame(1, similar=compare_individuals) - pop = [ind for ind in pop if ind.fitness.values[0] == best_fitness] - - evaluation_start = time.time() + fitness_resource_f = fitness_constructor(native.evaluate) + toolbox.register_individual_constructor(fitness_weights) + # save best individuals + del hof + hof = tools.ParetoFront(similar=compare_individuals) - fitness = fitness_resource.evaluate(pop) - for ind, res_peak in zip(pop, fitness): - ind.time = ind.fitness.values[0] - ind.fitness.values = [res_peak] + for ind in pop: + ind.time = ind.fitness.values[0] - evaluation_time += time.time() - evaluation_start - - hof.update(pop) + if best_fitness[0] > deadline: + print(f'Deadline not reached !!! Deadline {deadline} < best time {best_fitness[0]}') + pop = [ind for ind in pop if ind.time == best_fitness[0]] else: optimize_resources = True - # save best individuals - hof = tools.HallOfFame(1, similar=compare_individuals) + pop = [ind for ind in pop if ind.time <= deadline] - pop = [ind for ind in pop if ind.fitness.values[0] <= deadline] + new_pop = [] + for ind in pop: + ind_time = ind.time + new_ind = toolbox.copy_individual(ind) + new_ind.time = ind_time + new_pop.append(new_ind) + del pop + pop = new_pop - evaluation_start = time.time() + evaluation_start = time.time() - fitness = fitness_resource.evaluate(pop) - for ind, res_peak in zip(pop, fitness): - ind.time = ind.fitness.values[0] - ind.fitness.values = [res_peak] + fitness = fitness_resource_f.evaluate(pop) + for ind, res_fit in zip(pop, fitness): + ind.fitness.values = res_fit - evaluation_time += time.time() - evaluation_start + evaluation_time += time.time() - evaluation_start - hof.update(pop) + hof.update(pop) + if best_fitness[0] <= deadline: + # Optimizing resources plateau_steps = 0 new_generation_number = generation_number - generation + 1 max_plateau_steps = max_plateau_steps if max_plateau_steps is not None else new_generation_number - best_fitness = hof[0].fitness.values[0] + best_fitness = hof[0].fitness.values if len(pop) < population_size: individuals_to_copy = rand.choices(pop, k=population_size - len(pop)) copied_individuals = [toolbox.copy_individual(ind) for ind in individuals_to_copy] for copied_ind, ind in zip(copied_individuals, individuals_to_copy): - copied_ind.fitness.values = [ind.fitness.values[0]] + copied_ind.fitness.values = ind.fitness.values copied_ind.time = ind.time pop += copied_individuals @@ -321,31 +325,32 @@ def build_schedule(wg: WorkGraph, rand.shuffle(pop) - offspring = make_offspring(toolbox, pop, optimize_resources) + offspring_chromosomes = make_offspring(toolbox, pop, optimize_resources) + offspring = [toolbox.Individual(chromosome) for chromosome in offspring_chromosomes] evaluation_start = time.time() fitness = fitness_f.evaluate(offspring) for ind, t in zip(offspring, fitness): - ind.time = t + ind.time = t[0] offspring = [ind for ind in offspring if ind.time <= deadline] - fitness_res = fitness_resource.evaluate(offspring) + fitness_res = fitness_resource_f.evaluate(offspring) - for ind, res_peak in zip(offspring, fitness_res): - ind.fitness.values = [res_peak] + for ind, res_fit in zip(offspring, fitness_res): + ind.fitness.values = res_fit evaluation_time += time.time() - evaluation_start # renewing population pop += offspring pop = toolbox.select(pop) - hof.update([pop[0]]) + hof.update(pop) prev_best_fitness = best_fitness - best_fitness = hof[0].fitness.values[0] + best_fitness = hof[0].fitness.values plateau_steps = plateau_steps + 1 if best_fitness == prev_best_fitness else 0 generation += 1 @@ -353,7 +358,7 @@ def build_schedule(wg: WorkGraph, native.close() if verbose: - print(f'Final time: {best_fitness}') + print(f'Final fitness: {best_fitness}') print(f'Generations processing took {(time.time() - start) * 1000} ms') print(f'Full genetic processing took {(time.time() - global_start) * 1000} ms') print(f'Evaluation time: {evaluation_time * 1000}') @@ -371,7 +376,8 @@ def compare_individuals(first: ChromosomeType, second: ChromosomeType) -> bool: return (first[0] == second[0]).all() and (first[1] == second[1]).all() and (first[2] == second[2]).all() -def make_offspring(toolbox: Toolbox, population: list[ChromosomeType], optimize_resources: bool) -> list[ChromosomeType]: +def make_offspring(toolbox: Toolbox, population: list[ChromosomeType], optimize_resources: bool) \ + -> list[ChromosomeType]: offspring = [] for ind1, ind2 in zip(population[::2], population[1::2]): From 7c6ea6d224640e02f780c01cf5cc5f4071e35b5b Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 18:42:53 +0300 Subject: [PATCH 07/31] introduce multi-criteria in Genetic Scheduler --- sampo/scheduler/genetic/base.py | 129 +++++++++++++++----- sampo/scheduler/genetic/schedule_builder.py | 79 ++++++------ 2 files changed, 136 insertions(+), 72 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index f0ffcfb5..b4a9378f 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -3,7 +3,7 @@ from sampo.scheduler.base import Scheduler, SchedulerType from sampo.scheduler.genetic.operators import FitnessFunction, TimeFitness -from sampo.scheduler.genetic.schedule_builder import build_schedule +from sampo.scheduler.genetic.schedule_builder import build_schedules from sampo.scheduler.genetic.converter import ChromosomeType, ScheduleGenerationScheme from sampo.scheduler.heft.base import HEFTScheduler, HEFTBetweenScheduler from sampo.scheduler.lft.base import LFTScheduler @@ -41,7 +41,8 @@ def __init__(self, seed: Optional[float or None] = None, n_cpu: int = 1, weights: Optional[list[int] or None] = None, - fitness_constructor: Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, + fitness_constructor: Callable[ + [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, fitness_weights: tuple[int | float] = (-1,), scheduler_type: SchedulerType = SchedulerType.Genetic, resource_optimizer: ResourceOptimizer = IdentityResourceOptimizer(), @@ -234,6 +235,68 @@ def schedule_with_cache(self, :param timeline: :return: """ + schedule, schedule_start_time, timeline, order_nodes = self._build_schedules(wg, contractors, landscape, spec, + assigned_parent_time, timeline, + is_multiobjective=False)[0] + + if validate: + validate_schedule(schedule, wg, contractors) + + return schedule, schedule_start_time, timeline, order_nodes + + def schedule_multiobjective(self, + wg: WorkGraph, + contractors: list[Contractor], + spec: ScheduleSpec = ScheduleSpec(), + validate: bool = False, + start_time: Time = Time(0), + timeline: Timeline | None = None, + landscape: LandscapeConfiguration = LandscapeConfiguration()) \ + -> list[Schedule]: + """ + Implementation of a multiobjective scheduling process + + :return: list of pareto-efficient Schedules + """ + if wg is None or len(wg.nodes) == 0: + raise ValueError('None or empty WorkGraph') + if contractors is None or len(contractors) == 0: + raise ValueError('None or empty contractor list') + schedules = self.schedule_multiobjective_with_cache(wg, contractors, landscape, spec, validate, start_time, + timeline) + schedules = [schedule for schedule, _, _, _ in schedules] + return schedules + + def schedule_multiobjective_with_cache(self, + wg: WorkGraph, + contractors: list[Contractor], + landscape: LandscapeConfiguration = LandscapeConfiguration(), + spec: ScheduleSpec = ScheduleSpec(), + validate: bool = False, + assigned_parent_time: Time = Time(0), + timeline: Timeline | None = None) \ + -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: + """ + Build pareto-efficient schedules for received graph of workers and return their current states + """ + schedules = self._build_schedules(wg, contractors, landscape, spec, assigned_parent_time, timeline, + is_multiobjective=True) + + if validate: + for schedule, _, _, _ in schedules: + validate_schedule(schedule, wg, contractors) + + return schedules + + def _build_schedules(self, + wg: WorkGraph, + contractors: list[Contractor], + landscape: LandscapeConfiguration = LandscapeConfiguration(), + spec: ScheduleSpec = ScheduleSpec(), + assigned_parent_time: Time = Time(0), + timeline: Timeline | None = None, + is_multiobjective: bool = False) \ + -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: init_schedules = GeneticScheduler.generate_first_population(wg, contractors, landscape, spec, self.work_estimator, self._deadline, self._weights) @@ -241,34 +304,34 @@ def schedule_with_cache(self, worker_pool = get_worker_contractor_pool(contractors) deadline = None if self._optimize_resources else self._deadline - scheduled_works, schedule_start_time, timeline, order_nodes = build_schedule(wg, - contractors, - worker_pool, - size_of_population, - self.number_of_generation, - mutate_order, - mutate_resources, - mutate_zones, - init_schedules, - self.rand, - spec, - landscape, - self.fitness_constructor, - self.fitness_weights, - self.work_estimator, - self.sgs_type, - self._n_cpu, - assigned_parent_time, - timeline, - self._time_border, - self._max_plateau_steps, - self._optimize_resources, - deadline, - self._only_lft_initialization, - self._verbose) - schedule = Schedule.from_scheduled_works(scheduled_works.values(), wg) - - if validate: - validate_schedule(schedule, wg, contractors) - - return schedule, schedule_start_time, timeline, order_nodes + schedules = build_schedules(wg, + contractors, + worker_pool, + size_of_population, + self.number_of_generation, + mutate_order, + mutate_resources, + mutate_zones, + init_schedules, + self.rand, + spec, + landscape, + self.fitness_constructor, + self.fitness_weights, + self.work_estimator, + self.sgs_type, + self._n_cpu, + assigned_parent_time, + timeline, + self._time_border, + self._max_plateau_steps, + self._optimize_resources, + deadline, + self._only_lft_initialization, + is_multiobjective, + self._verbose) + schedules = [ + (Schedule.from_scheduled_works(scheduled_works.values(), wg), schedule_start_time, timeline, order_nodes) + for scheduled_works, schedule_start_time, timeline, order_nodes in schedules] + + return schedules diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index 2fafc3e1..e4cbd576 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -91,7 +91,7 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, contractor2index, contractor_borders, schedule, chromosome_spec, landscape, order), importance, chromosome_spec) - if schedule is not None else None + if schedule is not None else None for name, (schedule, order, chromosome_spec, importance) in init_schedules.items()} if verbose: @@ -129,34 +129,34 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, is_multiobjective), worker_name2index, worker_pool_indices, parents -def build_schedule(wg: WorkGraph, - contractors: list[Contractor], - worker_pool: WorkerContractorPool, - population_size: int, - generation_number: int, - mutpb_order: float, - mutpb_res: float, - mutpb_zones: float, - init_schedules: dict[str, tuple[Schedule, list[GraphNode] | None, ScheduleSpec, float]], - rand: random.Random, - spec: ScheduleSpec, - landscape: LandscapeConfiguration = LandscapeConfiguration(), - fitness_constructor: Callable[ - [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, - fitness_weights: tuple[int | float] = (-1,), - work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), - sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, - n_cpu: int = 1, - assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None, - time_border: int | None = None, - max_plateau_steps: int | None = None, - optimize_resources: bool = False, - deadline: Time | None = None, - only_lft_initialization: bool = False, - is_multiobjective: bool = False, - verbose: bool = True) \ - -> tuple[ScheduleWorkDict, Time, Timeline, list[GraphNode]]: +def build_schedules(wg: WorkGraph, + contractors: list[Contractor], + worker_pool: WorkerContractorPool, + population_size: int, + generation_number: int, + mutpb_order: float, + mutpb_res: float, + mutpb_zones: float, + init_schedules: dict[str, tuple[Schedule, list[GraphNode] | None, ScheduleSpec, float]], + rand: random.Random, + spec: ScheduleSpec, + landscape: LandscapeConfiguration = LandscapeConfiguration(), + fitness_constructor: Callable[ + [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, + fitness_weights: tuple[int | float] = (-1,), + work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), + sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, + n_cpu: int = 1, + assigned_parent_time: Time = Time(0), + timeline: Timeline | None = None, + time_border: int | None = None, + max_plateau_steps: int | None = None, + optimize_resources: bool = False, + deadline: Time | None = None, + only_lft_initialization: bool = False, + is_multiobjective: bool = False, + verbose: bool = True) \ + -> list[tuple[ScheduleWorkDict, Time, Timeline, list[GraphNode]]]: """ Genetic algorithm. Structure of chromosome: @@ -193,8 +193,8 @@ def build_schedule(wg: WorkGraph, if native.native: native_start = time.time() - best_chromosome = native.run_genetic(chromosomes, mutpb_order, mutpb_order, mutpb_res, mutpb_res, mutpb_res, - mutpb_res, population_size) + best_chromosomes = [native.run_genetic(chromosomes, mutpb_order, mutpb_order, mutpb_res, mutpb_res, mutpb_res, + mutpb_res, population_size)] if verbose: print(f'Native evaluated in {(time.time() - native_start) * 1000} ms') else: @@ -270,9 +270,8 @@ def build_schedule(wg: WorkGraph, fitness_resource_f = fitness_constructor(native.evaluate) toolbox.register_individual_constructor(fitness_weights) - # save best individuals - del hof - hof = tools.ParetoFront(similar=compare_individuals) + # clear best individuals + hof.clear() for ind in pop: ind.time = ind.fitness.values[0] @@ -363,13 +362,15 @@ def build_schedule(wg: WorkGraph, print(f'Full genetic processing took {(time.time() - global_start) * 1000} ms') print(f'Evaluation time: {evaluation_time * 1000}') - best_chromosome = hof[0] + best_chromosomes = [chromosome for chromosome in hof] - scheduled_works, schedule_start_time, timeline, order_nodes = toolbox.chromosome_to_schedule(best_chromosome, - landscape=landscape, - timeline=timeline) + best_schedules = [toolbox.chromosome_to_schedule(best_chromosome, landscape=landscape, timeline=timeline) + for best_chromosome in best_chromosomes] + best_schedules = [({node.id: work for node, work in scheduled_works.items()}, + schedule_start_time, timeline, order_nodes) + for scheduled_works, schedule_start_time, timeline, order_nodes in best_schedules] - return {node.id: work for node, work in scheduled_works.items()}, schedule_start_time, timeline, order_nodes + return best_schedules def compare_individuals(first: ChromosomeType, second: ChromosomeType) -> bool: From ef5e0b1fac15cf5b7a18a0f91d607f2b16285a93 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 18:55:01 +0300 Subject: [PATCH 08/31] introduce multi-objective fitness function --- sampo/scheduler/genetic/operators.py | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index 70b641df..85fa9c82 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -37,7 +37,7 @@ def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]]): self._evaluator = evaluator @abstractmethod - def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int | float]]: + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int | float, ...]]: """ Calculate the value of fitness function of the all chromosomes. It is better when value is less. @@ -177,6 +177,30 @@ def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[float]]: for schedule in evaluated] +class TimeAndResourcesFitness(FitnessFunction): + """ + Bi-objective fitness function of finish time and sum of resources peaks. + """ + + def __init__(self, evaluator: Callable[[list[ChromosomeType]], list[Schedule]], + resources_names: Iterable[str] | None = None): + super().__init__(evaluator) + self._resources_names = list(resources_names) if resources_names is not None else None + + @staticmethod + def prepare(resources_names: Iterable[str]) \ + -> Callable[[Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction]: + """ + Returns the constructor of that fitness function prepared to use in Genetic algorithm + """ + return partial(TimeAndResourcesFitness, resources_names=resources_names) + + def evaluate(self, chromosomes: list[ChromosomeType]) -> list[tuple[int, int]]: + evaluated = self._evaluator(chromosomes) + return [(schedule.execution_time.value, resources_peaks_sum(schedule, self._resources_names)) + for schedule in evaluated] + + class Individual(list): def __init__(self, individual_fitness_constructor: Callable[[], base.Fitness], chromosome: ChromosomeType): super().__init__(chromosome) From ace2cffd3d2a50a478362cb1938f065f20712b57 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 19:02:51 +0300 Subject: [PATCH 09/31] fix imports --- sampo/scheduler/genetic/__init__.py | 3 +++ tests/scheduler/resources_in_time/basic_res_test.py | 3 +-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/sampo/scheduler/genetic/__init__.py b/sampo/scheduler/genetic/__init__.py index 0b71feb6..0b416136 100644 --- a/sampo/scheduler/genetic/__init__.py +++ b/sampo/scheduler/genetic/__init__.py @@ -1,2 +1,5 @@ from sampo.scheduler.genetic.base import GeneticScheduler from sampo.scheduler.genetic.converter import ScheduleGenerationScheme +from sampo.scheduler.genetic.operators import (TimeFitness, SumOfResourcesPeaksFitness, SumOfResourcesFitness, + TimeWithResourcesFitness, DeadlineResourcesFitness, DeadlineCostFitness, + TimeAndResourcesFitness) diff --git a/tests/scheduler/resources_in_time/basic_res_test.py b/tests/scheduler/resources_in_time/basic_res_test.py index c8ead55a..6cd3a10c 100644 --- a/tests/scheduler/resources_in_time/basic_res_test.py +++ b/tests/scheduler/resources_in_time/basic_res_test.py @@ -1,8 +1,7 @@ import pytest import math -from sampo.scheduler.genetic.base import GeneticScheduler -from sampo.scheduler.genetic.operators import DeadlineResourcesFitness, SumOfResourcesPeaksFitness +from sampo.scheduler.genetic import GeneticScheduler, DeadlineResourcesFitness, SumOfResourcesPeaksFitness from sampo.scheduler.heft.base import HEFTScheduler from sampo.scheduler.resources_in_time.average_binary_search import AverageBinarySearchResourceOptimizingScheduler from sampo.utilities.resource_usage import resources_costs_sum, resources_peaks_sum From 78a2f5e4e84a7a80361871f447b3c834bc2198cb Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 19:08:11 +0300 Subject: [PATCH 10/31] fix typing --- sampo/scheduler/genetic/base.py | 2 +- sampo/scheduler/genetic/operators.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index b4a9378f..dc841e64 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -43,7 +43,7 @@ def __init__(self, weights: Optional[list[int] or None] = None, fitness_constructor: Callable[ [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, - fitness_weights: tuple[int | float] = (-1,), + fitness_weights: tuple[int | float, ...] = (-1,), scheduler_type: SchedulerType = SchedulerType.Genetic, resource_optimizer: ResourceOptimizer = IdentityResourceOptimizer(), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index 85fa9c82..e8b72a76 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -239,7 +239,7 @@ def init_toolbox(wg: WorkGraph, children: dict[int, set[int]], resources_border: np.ndarray, assigned_parent_time: Time = Time(0), - fitness_weights: tuple[int | float] = (-1,), + fitness_weights: tuple[int | float, ...] = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, only_lft_initialization: bool = False, @@ -309,7 +309,7 @@ def init_toolbox(wg: WorkGraph, return toolbox -def register_individual_constructor(fitness_weights: tuple[int | float], toolbox: base.Toolbox): +def register_individual_constructor(fitness_weights: tuple[int | float, ...], toolbox: base.Toolbox): class IndividualFitness(base.Fitness): weights = fitness_weights From 6248ec7308e5b3d8ad19411ed0b71bae27ab6ffe Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 19:19:20 +0300 Subject: [PATCH 11/31] fix typing --- sampo/scheduler/genetic/schedule_builder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index e4cbd576..bf075201 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -32,7 +32,7 @@ def create_toolbox_and_mapping_objects(wg: WorkGraph, str, tuple[Schedule, list[GraphNode] | None, ScheduleSpec, float]], rand: random.Random, spec: ScheduleSpec = ScheduleSpec(), - fitness_weights: tuple[int | float] = (-1,), + fitness_weights: tuple[int | float, ...] = (-1,), work_estimator: WorkTimeEstimator = None, sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, assigned_parent_time: Time = Time(0), @@ -143,7 +143,7 @@ def build_schedules(wg: WorkGraph, landscape: LandscapeConfiguration = LandscapeConfiguration(), fitness_constructor: Callable[ [Callable[[list[ChromosomeType]], list[Schedule]]], FitnessFunction] = TimeFitness, - fitness_weights: tuple[int | float] = (-1,), + fitness_weights: tuple[int | float, ...] = (-1,), work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, n_cpu: int = 1, From 2e788085f595aa33ac3a2da69818a9e986cca68c Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 20:43:05 +0300 Subject: [PATCH 12/31] fix schedule_builder --- sampo/scheduler/genetic/schedule_builder.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index bf075201..f6028d13 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -386,8 +386,9 @@ def make_offspring(toolbox: Toolbox, population: list[ChromosomeType], optimize_ offspring.extend(toolbox.mate(ind1, ind2, optimize_resources)) for mutant in offspring: - # resource borders mutation - toolbox.mutate_resource_borders(mutant) + if optimize_resources: + # resource borders mutation + toolbox.mutate_resource_borders(mutant) # other mutation toolbox.mutate(mutant) From 77b1543589f763bc0a7490a12e8fab3b57dfae9a Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 20:53:39 +0300 Subject: [PATCH 13/31] fix schedule_builder --- sampo/scheduler/genetic/schedule_builder.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index f6028d13..a1892837 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -228,9 +228,9 @@ def build_schedules(wg: WorkGraph, generation = 1 plateau_steps = 0 new_generation_number = generation_number if not have_deadline else generation_number // 2 - max_plateau_steps = max_plateau_steps if max_plateau_steps is not None else new_generation_number + new_max_plateau_steps = max_plateau_steps if max_plateau_steps is not None else new_generation_number - while generation <= new_generation_number and plateau_steps < max_plateau_steps \ + while generation <= new_generation_number and plateau_steps < new_max_plateau_steps \ and (time_border is None or time.time() - global_start < time_border): if verbose: print(f'-- Generation {generation}, population={len(pop)}, best fitness={best_fitness} --') @@ -306,7 +306,7 @@ def build_schedules(wg: WorkGraph, # Optimizing resources plateau_steps = 0 new_generation_number = generation_number - generation + 1 - max_plateau_steps = max_plateau_steps if max_plateau_steps is not None else new_generation_number + new_max_plateau_steps = max_plateau_steps if max_plateau_steps is not None else new_generation_number best_fitness = hof[0].fitness.values if len(pop) < population_size: @@ -317,7 +317,7 @@ def build_schedules(wg: WorkGraph, copied_ind.time = ind.time pop += copied_individuals - while generation <= generation_number and plateau_steps < max_plateau_steps \ + while generation <= generation_number and plateau_steps < new_max_plateau_steps \ and (time_border is None or time.time() - global_start < time_border): if verbose: print(f'-- Generation {generation}, population={len(pop)}, best peak={best_fitness} --') From e7bd3f3a423491274c77edebad8772660d7a9b2e Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 21:00:42 +0300 Subject: [PATCH 14/31] add multiobjective tests --- tests/scheduler/genetic/full_scheduling.py | 4 ++-- .../genetic/multiobjective_scheduling.py | 19 +++++++++++++++++++ 2 files changed, 21 insertions(+), 2 deletions(-) create mode 100644 tests/scheduler/genetic/multiobjective_scheduling.py diff --git a/tests/scheduler/genetic/full_scheduling.py b/tests/scheduler/genetic/full_scheduling.py index ba6e1980..2337013c 100644 --- a/tests/scheduler/genetic/full_scheduling.py +++ b/tests/scheduler/genetic/full_scheduling.py @@ -1,7 +1,7 @@ from sampo.scheduler import GeneticScheduler -def test_multiprocessing(setup_scheduler_parameters): +def test_genetic_scheduling(setup_scheduler_parameters): setup_wg, setup_contractors, setup_landscape = setup_scheduler_parameters genetic = GeneticScheduler(number_of_generation=10, @@ -9,4 +9,4 @@ def test_multiprocessing(setup_scheduler_parameters): mutate_resources=0.005, size_of_population=50) - genetic.schedule(setup_wg, setup_contractors, landscape=setup_landscape) + genetic.schedule(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) diff --git a/tests/scheduler/genetic/multiobjective_scheduling.py b/tests/scheduler/genetic/multiobjective_scheduling.py new file mode 100644 index 00000000..5cb73c3f --- /dev/null +++ b/tests/scheduler/genetic/multiobjective_scheduling.py @@ -0,0 +1,19 @@ +from sampo.scheduler.genetic import GeneticScheduler, TimeAndResourcesFitness +from sampo.utilities.resource_usage import resources_sum + + +def test_multiobjective_genetic_scheduling(setup_scheduler_parameters): + setup_wg, setup_contractors, setup_landscape = setup_scheduler_parameters + + genetic = GeneticScheduler(number_of_generation=100, + mutate_order=0.05, + mutate_resources=0.005, + size_of_population=50, + fitness_constructor=TimeAndResourcesFitness, + fitness_weights=(-1, -1), + optimize_resources=True) + + schedules = genetic.schedule_multiobjective(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) + assert isinstance(schedules, list) and len(schedules) + fitnesses = [(schedule.execution_time.value, resources_sum(schedule)) for schedule in schedules] + print(fitnesses) From 1802d1f769c9182f7b02c98a32176be630e30f6a Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 22:09:50 +0300 Subject: [PATCH 15/31] refactor resource_usage --- sampo/utilities/resource_usage.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sampo/utilities/resource_usage.py b/sampo/utilities/resource_usage.py index 2399d817..05c13e4d 100644 --- a/sampo/utilities/resource_usage.py +++ b/sampo/utilities/resource_usage.py @@ -9,7 +9,7 @@ def get_total_resources_usage(schedule: Schedule, resources_names: Iterable[str] | None = None) -> dict[str, np.ndarray]: df = schedule.full_schedule_df - points = df[['start', 'finish']].to_numpy().copy() + points = df[['start', 'finish']].to_numpy() points = SortedList(set(points.flatten())) usage = defaultdict(lambda: np.zeros_like(points)) @@ -20,7 +20,7 @@ def get_total_resources_usage(schedule: Schedule, resources_names: Iterable[str] start = points.bisect_left(swork.start_time) finish = points.bisect_left(swork.finish_time) for worker in swork.workers: - if worker.name in resources_names or is_none: + if is_none or worker.name in resources_names: usage[worker.name][start: finish] += worker.count return usage From 16496be09023d8bbe06023ba4c8fb23593c90b56 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 23:43:45 +0300 Subject: [PATCH 16/31] fix resources mutation probability --- sampo/scheduler/genetic/base.py | 2 +- tests/scheduler/genetic/full_scheduling.py | 2 +- tests/scheduler/resources_in_time/basic_res_test.py | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index dc841e64..422b503e 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -96,7 +96,7 @@ def get_params(self, works_count: int) -> tuple[float, float, float, int]: mutate_resources = self.mutate_resources if mutate_resources is None: - mutate_resources = 0.005 + mutate_resources = 0.05 mutate_zones = self.mutate_zones if mutate_zones is None: diff --git a/tests/scheduler/genetic/full_scheduling.py b/tests/scheduler/genetic/full_scheduling.py index 2337013c..8f633b8a 100644 --- a/tests/scheduler/genetic/full_scheduling.py +++ b/tests/scheduler/genetic/full_scheduling.py @@ -6,7 +6,7 @@ def test_genetic_scheduling(setup_scheduler_parameters): genetic = GeneticScheduler(number_of_generation=10, mutate_order=0.05, - mutate_resources=0.005, + mutate_resources=0.05, size_of_population=50) genetic.schedule(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) diff --git a/tests/scheduler/resources_in_time/basic_res_test.py b/tests/scheduler/resources_in_time/basic_res_test.py index 6cd3a10c..d9cf35e5 100644 --- a/tests/scheduler/resources_in_time/basic_res_test.py +++ b/tests/scheduler/resources_in_time/basic_res_test.py @@ -88,7 +88,7 @@ def test_lexicographic_genetic_deadline_planning(setup_scheduler_parameters): scheduler_combined = GeneticScheduler(number_of_generation=5, mutate_order=0.05, - mutate_resources=0.005, + mutate_resources=0.05, size_of_population=50, fitness_constructor=DeadlineResourcesFitness.prepare(deadline), optimize_resources=True, @@ -98,7 +98,7 @@ def test_lexicographic_genetic_deadline_planning(setup_scheduler_parameters): scheduler_lexicographic = GeneticScheduler(number_of_generation=5, mutate_order=0.05, - mutate_resources=0.005, + mutate_resources=0.05, size_of_population=50, fitness_constructor=SumOfResourcesPeaksFitness, verbose=False) From 0fd8033434998c4083e1e3cc7285cb1cce274e09 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Thu, 25 Jan 2024 23:44:17 +0300 Subject: [PATCH 17/31] multiobjective tests --- sampo/scheduler/genetic/schedule_builder.py | 3 ++- .../scheduler/genetic/multiobjective_scheduling.py | 13 +++++++------ 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index a1892837..b31d3034 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -374,7 +374,8 @@ def build_schedules(wg: WorkGraph, def compare_individuals(first: ChromosomeType, second: ChromosomeType) -> bool: - return (first[0] == second[0]).all() and (first[1] == second[1]).all() and (first[2] == second[2]).all() + return ((first[0] == second[0]).all() and (first[1] == second[1]).all() and (first[2] == second[2]).all() + or first.fitness == second.fitness) def make_offspring(toolbox: Toolbox, population: list[ChromosomeType], optimize_resources: bool) \ diff --git a/tests/scheduler/genetic/multiobjective_scheduling.py b/tests/scheduler/genetic/multiobjective_scheduling.py index 5cb73c3f..3ea3a943 100644 --- a/tests/scheduler/genetic/multiobjective_scheduling.py +++ b/tests/scheduler/genetic/multiobjective_scheduling.py @@ -1,5 +1,5 @@ -from sampo.scheduler.genetic import GeneticScheduler, TimeAndResourcesFitness -from sampo.utilities.resource_usage import resources_sum +from sampo.scheduler.genetic import GeneticScheduler, TimeAndResourcesFitness, ScheduleGenerationScheme +from sampo.utilities.resource_usage import resources_peaks_sum def test_multiobjective_genetic_scheduling(setup_scheduler_parameters): @@ -7,13 +7,14 @@ def test_multiobjective_genetic_scheduling(setup_scheduler_parameters): genetic = GeneticScheduler(number_of_generation=100, mutate_order=0.05, - mutate_resources=0.005, + mutate_resources=0.05, size_of_population=50, fitness_constructor=TimeAndResourcesFitness, fitness_weights=(-1, -1), - optimize_resources=True) + optimize_resources=True, + sgs_type=ScheduleGenerationScheme.Serial) schedules = genetic.schedule_multiobjective(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) assert isinstance(schedules, list) and len(schedules) - fitnesses = [(schedule.execution_time.value, resources_sum(schedule)) for schedule in schedules] - print(fitnesses) + fitnesses = [(schedule.execution_time.value, resources_peaks_sum(schedule)) for schedule in schedules] + print('\nPareto-efficient fitnesses:\n', fitnesses) From 58addd57a271381954c65514090f21d7f908a8e1 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Fri, 26 Jan 2024 01:40:20 +0300 Subject: [PATCH 18/31] fix tests --- tests/scheduler/genetic/operators_test.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/scheduler/genetic/operators_test.py b/tests/scheduler/genetic/operators_test.py index 31e041cc..516d6cba 100644 --- a/tests/scheduler/genetic/operators_test.py +++ b/tests/scheduler/genetic/operators_test.py @@ -51,7 +51,7 @@ def test_mate_order(setup_toolbox, setup_wg): tb, _, _, _, _, _ = setup_toolbox _, _, _, population_size = get_params(setup_wg.vertex_count) - population = tb.population(n=population_size) + population = tb.population_chromosomes(n=population_size) for i in range(TEST_ITERATIONS): individual1, individual2 = population[:2] @@ -71,7 +71,7 @@ def test_mate_resources(setup_toolbox, setup_wg): tb, resources_border, _, _, _, _ = setup_toolbox _, _, _, population_size = get_params(setup_wg.vertex_count) - population = tb.population(n=population_size) + population = tb.population_chromosomes(n=population_size) for i in range(TEST_ITERATIONS): individual1, individual2 = random.sample(population, 2) From 3a080cf5898a946ffa607b77afa9d46c025fe89d Mon Sep 17 00:00:00 2001 From: Egor Date: Fri, 9 Feb 2024 17:10:34 +0300 Subject: [PATCH 19/31] refactor generic scheduler and pipeline to new format of scheduling --- sampo/pipeline/default.py | 98 ++++++++++++++++++++---------------- sampo/scheduler/base.py | 9 ++-- sampo/scheduler/generic.py | 4 +- sampo/scheduler/lft/base.py | 4 +- sampo/schemas/apply_queue.py | 6 +-- 5 files changed, 67 insertions(+), 54 deletions(-) diff --git a/sampo/pipeline/default.py b/sampo/pipeline/default.py index 15ef99a5..6a2b6e70 100644 --- a/sampo/pipeline/default.py +++ b/sampo/pipeline/default.py @@ -57,7 +57,7 @@ def __init__(self): self._contractors: list[Contractor] | pd.DataFrame | str | tuple[ContractorGenerationMethod, int] | None \ = ContractorGenerationMethod.AVG, 1 self._work_estimator: WorkTimeEstimator = DefaultWorkEstimator() - self._node_order: list[GraphNode] | None = None + self._node_orders: list[list[GraphNode]] | None = None self._lag_optimize: LagOptimizationStrategy = LagOptimizationStrategy.NONE self._spec: ScheduleSpec | None = ScheduleSpec() self._assigned_parent_time: Time | None = Time(0) @@ -180,8 +180,8 @@ def work_estimator(self, work_estimator: WorkTimeEstimator) -> 'InputPipeline': self._work_estimator = work_estimator return self - def node_order(self, node_order: list[GraphNode]) -> 'InputPipeline': - self._node_order = node_order + def node_order(self, node_orders: list[list[GraphNode]]) -> 'InputPipeline': + self._node_orders = node_orders return self def optimize_local(self, optimizer: OrderLocalOptimizer, area: range) -> 'InputPipeline': @@ -230,72 +230,84 @@ def prioritization(wg: WorkGraph, work_estimator: WorkTimeEstimator): match self._lag_optimize: case LagOptimizationStrategy.NONE: wg = self._wg - schedule, _, _, node_order = scheduler.schedule_with_cache(wg, self._contractors, - self._landscape_config, - self._spec, - assigned_parent_time=self._assigned_parent_time) - self._node_order = node_order + schedules = scheduler.schedule_with_cache(wg, self._contractors, + self._landscape_config, + self._spec, + assigned_parent_time=self._assigned_parent_time) + node_orders = [node_order for _, _, _, node_order in schedules] + schedules = [schedule for schedule, _, _, _ in schedules] + self._node_orders = node_orders case LagOptimizationStrategy.AUTO: # Searching the best wg1 = graph_restructuring(self._wg, False) - schedule1, _, _, node_order1 = scheduler.schedule_with_cache(wg1, self._contractors, - self._landscape_config, - self._spec, - assigned_parent_time=self._assigned_parent_time) - wg2 = graph_restructuring(self._wg, True) - schedule2, _, _, node_order2 = scheduler.schedule_with_cache(wg2, self._contractors, - self._landscape_config, - self._spec, - assigned_parent_time=self._assigned_parent_time) + schedules = scheduler.schedule_with_cache(wg1, self._contractors, + self._landscape_config, + self._spec, + assigned_parent_time=self._assigned_parent_time) + node_orders1 = [node_order for _, _, _, node_order in schedules] + schedules1 = [schedule for schedule, _, _, _ in schedules] + min_time1 = min([schedule.execution_time for schedule in schedules1]) - if schedule1.execution_time < schedule2.execution_time: - self._node_order = node_order1 + wg2 = graph_restructuring(self._wg, True) + schedules = scheduler.schedule_with_cache(wg2, self._contractors, + self._landscape_config, + self._spec, + assigned_parent_time=self._assigned_parent_time) + node_orders2 = [node_order for _, _, _, node_order in schedules] + schedules2 = [schedule for schedule, _, _, _ in schedules] + min_time2 = min([schedule.execution_time for schedule in schedules2]) + + if min_time1 < min_time2: + self._node_orders = node_orders1 wg = wg1 - schedule = schedule1 + schedules = schedules1 else: - self._node_order = node_order2 + self._node_orders = node_orders2 wg = wg2 - schedule = schedule2 + schedules = schedules2 case _: wg = graph_restructuring(self._wg, self._lag_optimize.value) - schedule, _, _, node_order = scheduler.schedule_with_cache(wg, self._contractors, - self._landscape_config, - self._spec, - assigned_parent_time=self._assigned_parent_time) - self._node_order = node_order + schedules = scheduler.schedule_with_cache(wg, self._contractors, + self._landscape_config, + self._spec, + assigned_parent_time=self._assigned_parent_time) + node_orders = [node_order for _, _, _, node_order in schedules] + schedules = [schedule for schedule, _, _, _ in schedules] + self._node_orders = node_orders - return DefaultSchedulePipeline(self, wg, schedule) + return DefaultSchedulePipeline(self, wg, schedules) # noinspection PyProtectedMember class DefaultSchedulePipeline(SchedulePipeline): - def __init__(self, s_input: DefaultInputPipeline, wg: WorkGraph, schedule: Schedule): + def __init__(self, s_input: DefaultInputPipeline, wg: WorkGraph, schedules: list[Schedule]): self._input = s_input self._wg = wg self._worker_pool = get_worker_contractor_pool(s_input._contractors) - self._schedule = schedule - self._scheduled_works = {wg[swork.id]: - swork for swork in schedule.to_schedule_work_dict.values()} + self._schedules = schedules + self._scheduled_works = [{wg[swork.id]: swork for swork in schedule.to_schedule_work_dict.values()} + for schedule in schedules] self._local_optimize_stack = ApplyQueue() self._start_date = None def optimize_local(self, optimizer: ScheduleLocalOptimizer, area: range) -> 'SchedulePipeline': self._local_optimize_stack.add(optimizer.optimize, - ( - self._input._node_order, self._input._contractors, - self._input._landscape_config, - self._input._spec, self._worker_pool, self._input._work_estimator, - self._input._assigned_parent_time, area)) + self._input._contractors, self._input._landscape_config, + self._input._spec, self._worker_pool, self._input._work_estimator, + self._input._assigned_parent_time, area) return self - def finish(self) -> ScheduledProject: - processed_sworks = self._local_optimize_stack.apply(self._scheduled_works) - schedule = Schedule.from_scheduled_works(processed_sworks.values(), self._wg) - return ScheduledProject(self._input._wg, self._wg, self._input._contractors, schedule) + def finish(self) -> list[ScheduledProject]: + scheduled_projects = [] + for scheduled_works, node_order in zip(self._scheduled_works, self._input._node_orders): + processed_sworks = self._local_optimize_stack.apply(scheduled_works, node_order) + schedule = Schedule.from_scheduled_works(processed_sworks.values(), self._wg) + scheduled_projects.append(ScheduledProject(self._input._wg, self._wg, self._input._contractors, schedule)) + return scheduled_projects - def visualization(self, start_date: str) -> 'Visualization': + def visualization(self, start_date: str) -> list['Visualization']: from sampo.utilities.visualization import Visualization - return Visualization.from_project(self.finish(), start_date) + return [Visualization.from_project(project, start_date) for project in self.finish()] diff --git a/sampo/scheduler/base.py b/sampo/scheduler/base.py index 74985298..2c0971e0 100644 --- a/sampo/scheduler/base.py +++ b/sampo/scheduler/base.py @@ -53,7 +53,7 @@ def schedule(self, start_time: Time = Time(0), timeline: Timeline | None = None, landscape: LandscapeConfiguration = LandscapeConfiguration()) \ - -> Schedule: + -> list[Schedule]: """ Implementation of a scheduling process. 'schedule' version returns only Schedule. @@ -63,9 +63,10 @@ def schedule(self, raise ValueError('None or empty WorkGraph') if contractors is None or len(contractors) == 0: raise ValueError('None or empty contractor list') - schedule = self.schedule_with_cache(wg, contractors, landscape, spec, validate, start_time, timeline)[0] + schedules = self.schedule_with_cache(wg, contractors, landscape, spec, validate, start_time, timeline) + schedules = [schedule[0] for schedule in schedules] # print(f'Schedule exec time: {schedule.execution_time} days') - return schedule + return schedules @abstractmethod def schedule_with_cache(self, @@ -76,7 +77,7 @@ def schedule_with_cache(self, validate: bool = False, assigned_parent_time: Time = Time(0), timeline: Timeline | None = None) \ - -> tuple[Schedule, Time, Timeline, list[GraphNode]]: + -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: """ Extended version of 'schedule' method. Returns much inner info about a scheduling process, not only Schedule. diff --git a/sampo/scheduler/generic.py b/sampo/scheduler/generic.py index 096eeac4..23febf11 100644 --- a/sampo/scheduler/generic.py +++ b/sampo/scheduler/generic.py @@ -106,7 +106,7 @@ def schedule_with_cache(self, validate: bool = False, assigned_parent_time: Time = Time(0), timeline: Timeline | None = None) \ - -> tuple[Schedule, Time, Timeline, list[GraphNode]]: + -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: ordered_nodes = self.prioritization(wg, self.work_estimator) schedule, schedule_start_time, timeline = \ @@ -120,7 +120,7 @@ def schedule_with_cache(self, if validate: validate_schedule(schedule, wg, contractors) - return schedule, schedule_start_time, timeline, ordered_nodes + return [(schedule, schedule_start_time, timeline, ordered_nodes)] def build_scheduler(self, ordered_nodes: list[GraphNode], diff --git a/sampo/scheduler/lft/base.py b/sampo/scheduler/lft/base.py index 98f1ce0f..49512732 100644 --- a/sampo/scheduler/lft/base.py +++ b/sampo/scheduler/lft/base.py @@ -122,7 +122,7 @@ def schedule_with_cache(self, spec: ScheduleSpec = ScheduleSpec(), validate: bool = False, assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) -> tuple[Schedule, Time, Timeline, list[GraphNode]]: + timeline: Timeline | None = None) -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: # get contractors borders worker_pool = get_worker_contractor_pool(contractors) @@ -149,7 +149,7 @@ def schedule_with_cache(self, if validate: validate_schedule(schedule, wg, contractors) - return schedule, schedule_start_time, timeline, ordered_nodes + return [(schedule, schedule_start_time, timeline, ordered_nodes)] def _contractor_workers_assignment(self, wg: WorkGraph, contractors: list[Contractor], worker_pool: WorkerContractorPool, spec: ScheduleSpec = ScheduleSpec() diff --git a/sampo/schemas/apply_queue.py b/sampo/schemas/apply_queue.py index 95c6316d..97a355ef 100644 --- a/sampo/schemas/apply_queue.py +++ b/sampo/schemas/apply_queue.py @@ -6,7 +6,7 @@ class ApplyQueue: def __init__(self): self.stack = [] - def add(self, function, args: tuple) -> 'ApplyQueue': + def add(self, function, *args) -> 'ApplyQueue': """ Adds function and args to queue. args should be (first arg, second arg, ...). The zero arg applied to `f` is the result of previous function in the queue. @@ -14,13 +14,13 @@ def add(self, function, args: tuple) -> 'ApplyQueue': self.stack.append((function, args)) return self - def apply(self, first_args): + def apply(self, *first_args): """ Sequentially applies functions to the result of previous function and the args stored in queue. """ res = first_args for f, args in self.stack: - res = f(res, *args) + res = (f(*res, *args),) return res def empty(self) -> bool: From 169380ac872fadeac5bfc3098e7ef048d473a4ff Mon Sep 17 00:00:00 2001 From: Egor Date: Fri, 9 Feb 2024 18:23:46 +0300 Subject: [PATCH 20/31] refactor pipeline, generic and genetic schedulers to new format of scheduling --- sampo/pipeline/default.py | 8 +- sampo/scheduler/base.py | 6 +- sampo/scheduler/generic.py | 4 +- sampo/scheduler/genetic/base.py | 102 +++++------------- sampo/scheduler/genetic/operators.py | 6 +- sampo/scheduler/genetic/schedule_builder.py | 4 +- sampo/scheduler/lft/base.py | 4 +- .../average_binary_search.py | 5 +- sampo/schemas/apply_queue.py | 2 +- 9 files changed, 43 insertions(+), 98 deletions(-) diff --git a/sampo/pipeline/default.py b/sampo/pipeline/default.py index 6a2b6e70..63cd3105 100644 --- a/sampo/pipeline/default.py +++ b/sampo/pipeline/default.py @@ -231,8 +231,8 @@ def prioritization(wg: WorkGraph, work_estimator: WorkTimeEstimator): case LagOptimizationStrategy.NONE: wg = self._wg schedules = scheduler.schedule_with_cache(wg, self._contractors, - self._landscape_config, self._spec, + landscape=self._landscape_config, assigned_parent_time=self._assigned_parent_time) node_orders = [node_order for _, _, _, node_order in schedules] schedules = [schedule for schedule, _, _, _ in schedules] @@ -242,8 +242,8 @@ def prioritization(wg: WorkGraph, work_estimator: WorkTimeEstimator): # Searching the best wg1 = graph_restructuring(self._wg, False) schedules = scheduler.schedule_with_cache(wg1, self._contractors, - self._landscape_config, self._spec, + landscape=self._landscape_config, assigned_parent_time=self._assigned_parent_time) node_orders1 = [node_order for _, _, _, node_order in schedules] schedules1 = [schedule for schedule, _, _, _ in schedules] @@ -251,8 +251,8 @@ def prioritization(wg: WorkGraph, work_estimator: WorkTimeEstimator): wg2 = graph_restructuring(self._wg, True) schedules = scheduler.schedule_with_cache(wg2, self._contractors, - self._landscape_config, self._spec, + landscape=self._landscape_config, assigned_parent_time=self._assigned_parent_time) node_orders2 = [node_order for _, _, _, node_order in schedules] schedules2 = [schedule for schedule, _, _, _ in schedules] @@ -270,8 +270,8 @@ def prioritization(wg: WorkGraph, work_estimator: WorkTimeEstimator): case _: wg = graph_restructuring(self._wg, self._lag_optimize.value) schedules = scheduler.schedule_with_cache(wg, self._contractors, - self._landscape_config, self._spec, + landscape=self._landscape_config, assigned_parent_time=self._assigned_parent_time) node_orders = [node_order for _, _, _, node_order in schedules] schedules = [schedule for schedule, _, _, _ in schedules] diff --git a/sampo/scheduler/base.py b/sampo/scheduler/base.py index 2c0971e0..2df6c0a4 100644 --- a/sampo/scheduler/base.py +++ b/sampo/scheduler/base.py @@ -63,7 +63,7 @@ def schedule(self, raise ValueError('None or empty WorkGraph') if contractors is None or len(contractors) == 0: raise ValueError('None or empty contractor list') - schedules = self.schedule_with_cache(wg, contractors, landscape, spec, validate, start_time, timeline) + schedules = self.schedule_with_cache(wg, contractors, spec, validate, start_time, timeline, landscape) schedules = [schedule[0] for schedule in schedules] # print(f'Schedule exec time: {schedule.execution_time} days') return schedules @@ -72,11 +72,11 @@ def schedule(self, def schedule_with_cache(self, wg: WorkGraph, contractors: list[Contractor], - landscape: LandscapeConfiguration = LandscapeConfiguration(), spec: ScheduleSpec = ScheduleSpec(), validate: bool = False, assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) \ + timeline: Timeline | None = None, + landscape: LandscapeConfiguration = LandscapeConfiguration()) \ -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: """ Extended version of 'schedule' method. Returns much inner info diff --git a/sampo/scheduler/generic.py b/sampo/scheduler/generic.py index 23febf11..6153da49 100644 --- a/sampo/scheduler/generic.py +++ b/sampo/scheduler/generic.py @@ -101,11 +101,11 @@ def run_with_contractor(contractor: Contractor) -> tuple[Time, Time, list[Worker def schedule_with_cache(self, wg: WorkGraph, contractors: list[Contractor], - landscape: LandscapeConfiguration() = LandscapeConfiguration(), spec: ScheduleSpec = ScheduleSpec(), validate: bool = False, assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) \ + timeline: Timeline | None = None, + landscape: LandscapeConfiguration() = LandscapeConfiguration()) \ -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: ordered_nodes = self.prioritization(wg, self.work_estimator) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index 4eae385a..0c13b490 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -48,6 +48,7 @@ def __init__(self, work_estimator: WorkTimeEstimator = DefaultWorkEstimator(), sgs_type: ScheduleGenerationScheme = ScheduleGenerationScheme.Parallel, optimize_resources: bool = False, + is_multiobjective: bool = False, only_lft_initialization: bool = False): super().__init__(scheduler_type=scheduler_type, resource_optimizer=resource_optimizer, @@ -64,6 +65,7 @@ def __init__(self, self.sgs_type = sgs_type self._optimize_resources = optimize_resources + self._is_multiobjective = is_multiobjective self._weights = weights self._only_lft_initialization = only_lft_initialization @@ -128,6 +130,9 @@ def set_weights(self, weights: list[int]): def set_optimize_resources(self, optimize_resources: bool): self._optimize_resources = optimize_resources + def set_is_multiobjective(self, is_multiobjective: bool): + self._is_multiobjective = is_multiobjective + def set_only_lft_initialization(self, only_lft_initialization: bool): self._only_lft_initialization = only_lft_initialization @@ -156,34 +161,33 @@ def generate_first_population(wg: WorkGraph, weights = [2, 2, 2, 1, 1, 1, 1] init_lft_schedule = (LFTScheduler(work_estimator=work_estimator).schedule(wg, contractors, spec, - landscape=landscape), None, spec) + landscape=landscape)[0], None, spec) def init_k_schedule(scheduler_class, k) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - return scheduler_class(work_estimator=work_estimator, - resource_optimizer=AverageReqResourceOptimizer(k)) \ - .schedule(wg, contractors, - spec, - landscape=landscape), list(reversed(prioritization(wg, work_estimator))), spec + schedule, _, _, node_order = (scheduler_class(work_estimator=work_estimator, + resource_optimizer=AverageReqResourceOptimizer(k)) + .schedule_with_cache(wg, contractors, spec, landscape=landscape))[0] + return schedule, node_order, spec except NoSufficientContractorError: return None, None, None if deadline is None: def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - return scheduler_class(work_estimator=work_estimator).schedule(wg, contractors, spec, - landscape=landscape), \ - list(reversed(prioritization(wg, work_estimator))), spec + schedule, _, _, node_order = (scheduler_class(work_estimator=work_estimator) + .schedule_with_cache(wg, contractors, spec, landscape=landscape))[0] + return schedule, node_order, spec except NoSufficientContractorError: return None, None, None else: def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - (schedule, _, _, _), modified_spec = AverageBinarySearchResourceOptimizingScheduler( + (schedule, _, _, node_order), modified_spec = AverageBinarySearchResourceOptimizingScheduler( scheduler_class(work_estimator=work_estimator) ).schedule_with_cache(wg, contractors, deadline, spec, landscape=landscape) - return schedule, list(reversed(prioritization(wg, work_estimator))), modified_spec + return schedule, node_order, modified_spec except NoSufficientContractorError: return None, None, None @@ -200,14 +204,14 @@ def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | N def schedule_with_cache(self, wg: WorkGraph, contractors: list[Contractor], - landscape: LandscapeConfiguration = LandscapeConfiguration(), spec: ScheduleSpec = ScheduleSpec(), validate: bool = False, assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) \ - -> tuple[Schedule, Time, Timeline, list[GraphNode]]: + timeline: Timeline | None = None, + landscape: LandscapeConfiguration = LandscapeConfiguration()) \ + -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: """ - Build schedule for received graph of workers and return the current state of schedule + Build schedules for received graph of workers and return the current state of schedules It's needed to use this method in multy agents model :param landscape: @@ -219,68 +223,6 @@ def schedule_with_cache(self, :param timeline: :return: """ - schedule, schedule_start_time, timeline, order_nodes = self._build_schedules(wg, contractors, landscape, spec, - assigned_parent_time, timeline, - is_multiobjective=False)[0] - - if validate: - validate_schedule(schedule, wg, contractors) - - return schedule, schedule_start_time, timeline, order_nodes - - def schedule_multiobjective(self, - wg: WorkGraph, - contractors: list[Contractor], - spec: ScheduleSpec = ScheduleSpec(), - validate: bool = False, - start_time: Time = Time(0), - timeline: Timeline | None = None, - landscape: LandscapeConfiguration = LandscapeConfiguration()) \ - -> list[Schedule]: - """ - Implementation of a multiobjective scheduling process - - :return: list of pareto-efficient Schedules - """ - if wg is None or len(wg.nodes) == 0: - raise ValueError('None or empty WorkGraph') - if contractors is None or len(contractors) == 0: - raise ValueError('None or empty contractor list') - schedules = self.schedule_multiobjective_with_cache(wg, contractors, landscape, spec, validate, start_time, - timeline) - schedules = [schedule for schedule, _, _, _ in schedules] - return schedules - - def schedule_multiobjective_with_cache(self, - wg: WorkGraph, - contractors: list[Contractor], - landscape: LandscapeConfiguration = LandscapeConfiguration(), - spec: ScheduleSpec = ScheduleSpec(), - validate: bool = False, - assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) \ - -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: - """ - Build pareto-efficient schedules for received graph of workers and return their current states - """ - schedules = self._build_schedules(wg, contractors, landscape, spec, assigned_parent_time, timeline, - is_multiobjective=True) - - if validate: - for schedule, _, _, _ in schedules: - validate_schedule(schedule, wg, contractors) - - return schedules - - def _build_schedules(self, - wg: WorkGraph, - contractors: list[Contractor], - landscape: LandscapeConfiguration = LandscapeConfiguration(), - spec: ScheduleSpec = ScheduleSpec(), - assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None, - is_multiobjective: bool = False) \ - -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: init_schedules = GeneticScheduler.generate_first_population(wg, contractors, landscape, spec, self.work_estimator, self._deadline, self._weights) @@ -310,9 +252,13 @@ def _build_schedules(self, self._optimize_resources, deadline, self._only_lft_initialization, - is_multiobjective) + self._is_multiobjective) schedules = [ (Schedule.from_scheduled_works(scheduled_works.values(), wg), schedule_start_time, timeline, order_nodes) for scheduled_works, schedule_start_time, timeline, order_nodes in schedules] + if validate: + for schedule, *_ in schedules: + validate_schedule(schedule, wg, contractors) + return schedules diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index e575e3d5..5af67268 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -277,10 +277,10 @@ def generate_chromosomes(n: int, def randomized_init(is_topological: bool = False) -> ChromosomeType: if is_topological: schedule = RandomizedTopologicalScheduler(work_estimator, int(rand.random() * 1000000)) \ - .schedule(wg, contractors, landscape=landscape) + .schedule(wg, contractors, spec, landscape=landscape)[0] else: schedule = RandomizedLFTScheduler(work_estimator=work_estimator, rand=rand).schedule(wg, contractors, spec, - landscape=landscape) + landscape=landscape)[0] return convert_schedule_to_chromosome(work_id2index, worker_name2index, contractor2index, contractor_borders, schedule, spec, landscape) @@ -348,7 +348,7 @@ def generate_chromosome(wg: WorkGraph, def randomized_init() -> ChromosomeType: schedule = RandomizedTopologicalScheduler(work_estimator, int(rand.random() * 1000000)) \ - .schedule(wg, contractors, spec, landscape=landscape) + .schedule(wg, contractors, spec, landscape=landscape)[0] return convert_schedule_to_chromosome(work_id2index, worker_name2index, contractor2index, contractor_borders, schedule, spec, landscape) diff --git a/sampo/scheduler/genetic/schedule_builder.py b/sampo/scheduler/genetic/schedule_builder.py index 09a44d04..81ca6c5f 100644 --- a/sampo/scheduler/genetic/schedule_builder.py +++ b/sampo/scheduler/genetic/schedule_builder.py @@ -1,6 +1,5 @@ import random import time -from typing import Callable from deap import tools from deap.base import Toolbox @@ -11,7 +10,6 @@ from sampo.scheduler.genetic.operators import init_toolbox, ChromosomeType, FitnessFunction, TimeFitness from sampo.scheduler.genetic.utils import prepare_optimized_data_structures from sampo.scheduler.timeline.base import Timeline -from sampo.scheduler.utils import WorkerContractorPool from sampo.schemas.contractor import Contractor from sampo.schemas.graph import GraphNode, WorkGraph from sampo.schemas.landscape import LandscapeConfiguration @@ -50,7 +48,7 @@ def create_toolbox(wg: WorkGraph, contractor2index, contractor_borders, schedule, chromosome_spec, landscape, order), importance, chromosome_spec) - if schedule is not None else None + if schedule is not None else None for name, (schedule, order, chromosome_spec, importance) in init_schedules.items()} if verbose: diff --git a/sampo/scheduler/lft/base.py b/sampo/scheduler/lft/base.py index 49512732..c77e8147 100644 --- a/sampo/scheduler/lft/base.py +++ b/sampo/scheduler/lft/base.py @@ -118,11 +118,11 @@ def optimize_resources_def(node: GraphNode, contractors: list[Contractor], spec: def schedule_with_cache(self, wg: WorkGraph, contractors: list[Contractor], - landscape: LandscapeConfiguration() = LandscapeConfiguration(), spec: ScheduleSpec = ScheduleSpec(), validate: bool = False, assigned_parent_time: Time = Time(0), - timeline: Timeline | None = None) -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: + timeline: Timeline | None = None, + landscape: LandscapeConfiguration() = LandscapeConfiguration()) -> list[tuple[Schedule, Time, Timeline, list[GraphNode]]]: # get contractors borders worker_pool = get_worker_contractor_pool(contractors) diff --git a/sampo/scheduler/resources_in_time/average_binary_search.py b/sampo/scheduler/resources_in_time/average_binary_search.py index 857a5644..eb0df9f6 100644 --- a/sampo/scheduler/resources_in_time/average_binary_search.py +++ b/sampo/scheduler/resources_in_time/average_binary_search.py @@ -35,8 +35,9 @@ def call_scheduler(k: float, inner_spec: ScheduleSpec) \ -> tuple[tuple[Schedule, Time, Timeline, list[GraphNode]], ScheduleSpec]: self._resource_optimizer.k = k try: - return self._base_scheduler.schedule_with_cache(wg, contractors, landscape, inner_spec, validate, - assigned_parent_time), inner_spec + return self._base_scheduler.schedule_with_cache(wg, contractors, inner_spec, validate, + assigned_parent_time, + landscape=landscape)[0], inner_spec except NoSufficientContractorError: return (None, Time.inf(), None, None), inner_spec diff --git a/sampo/schemas/apply_queue.py b/sampo/schemas/apply_queue.py index 97a355ef..4f5a637f 100644 --- a/sampo/schemas/apply_queue.py +++ b/sampo/schemas/apply_queue.py @@ -21,7 +21,7 @@ def apply(self, *first_args): res = first_args for f, args in self.stack: res = (f(*res, *args),) - return res + return res[0] def empty(self) -> bool: return len(self.stack) == 0 From 96c2f73bfc0396d6b738490ead55b314e6e6ab22 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Mon, 12 Feb 2024 14:19:51 +0300 Subject: [PATCH 21/31] fix tests --- sampo/pipeline/base.py | 2 +- tests/conftest.py | 2 +- tests/pipeline/basic_pipeline_test.py | 6 +++--- tests/scheduler/empty_scheduling_test.py | 2 +- tests/scheduler/genetic/converter_test.py | 2 +- tests/scheduler/lft/scheduling_test.py | 2 +- tests/scheduler/material_scheduling_test.py | 4 ++-- tests/scheduler/resources_in_time/basic_res_test.py | 10 +++++----- tests/scheduler/timeline/zone_timeline_test.py | 2 +- 9 files changed, 16 insertions(+), 16 deletions(-) diff --git a/sampo/pipeline/base.py b/sampo/pipeline/base.py index bafeff8a..3c1f0f7f 100644 --- a/sampo/pipeline/base.py +++ b/sampo/pipeline/base.py @@ -90,5 +90,5 @@ def optimize_local(self, optimizer: ScheduleLocalOptimizer, area: range) -> 'Sch ... @abstractmethod - def finish(self) -> ScheduledProject: + def finish(self) -> list[ScheduledProject]: ... diff --git a/tests/conftest.py b/tests/conftest.py index 5bb09ab8..4e3102b5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -211,6 +211,6 @@ def setup_schedule(setup_scheduler, setup_scheduler_parameters, setup_landscape_ return setup_scheduler.schedule(setup_wg, setup_contractors, validate=False, - landscape=landscape), setup_scheduler_type, setup_scheduler_parameters + landscape=landscape)[0], setup_scheduler_type, setup_scheduler_parameters except NoSufficientContractorError: pytest.skip('Given contractor configuration can\'t support given work graph') diff --git a/tests/pipeline/basic_pipeline_test.py b/tests/pipeline/basic_pipeline_test.py index 192c2c9d..87d259c6 100644 --- a/tests/pipeline/basic_pipeline_test.py +++ b/tests/pipeline/basic_pipeline_test.py @@ -19,7 +19,7 @@ def test_plain_scheduling(setup_scheduler_parameters): .contractors(setup_contractors) \ .landscape(setup_landscape) \ .schedule(HEFTScheduler()) \ - .finish() + .finish()[0] print(f'Scheduled {len(project.schedule.to_schedule_work_dict)} works') @@ -34,7 +34,7 @@ def test_local_optimize_scheduling(setup_scheduler_parameters): .optimize_local(SwapOrderLocalOptimizer(), range(0, setup_wg.vertex_count // 2)) \ .schedule(HEFTScheduler()) \ .optimize_local(ParallelizeScheduleLocalOptimizer(JustInTimeTimeline), range(0, setup_wg.vertex_count // 2)) \ - .finish() + .finish()[0] print(f'Scheduled {len(project.schedule.to_schedule_work_dict)} works') @@ -63,7 +63,7 @@ def test_plain_scheduling_with_parse_data(): .wg(wg=wg, sep=';', all_connections=True) \ .lag_optimize(LagOptimizationStrategy.TRUE) \ .schedule(HEFTScheduler()) \ - .finish() + .finish()[0] schedule = project.schedule schedule = schedule.merged_stages_datetime_df('2022-01-01') diff --git a/tests/scheduler/empty_scheduling_test.py b/tests/scheduler/empty_scheduling_test.py index 718c3b61..f3c0a6fc 100644 --- a/tests/scheduler/empty_scheduling_test.py +++ b/tests/scheduler/empty_scheduling_test.py @@ -22,6 +22,6 @@ def setup_empty_contractors(setup_empty_req_work_graph) -> list[Contractor]: def test_empty_graph_empty_contractor(setup_empty_req_work_graph, setup_empty_contractors, setup_scheduler): schedule = setup_scheduler.schedule(setup_empty_req_work_graph, setup_empty_contractors, - validate=False) + validate=False)[0] assert not schedule.execution_time.is_inf() diff --git a/tests/scheduler/genetic/converter_test.py b/tests/scheduler/genetic/converter_test.py index 63bb97e8..d031ba11 100644 --- a/tests/scheduler/genetic/converter_test.py +++ b/tests/scheduler/genetic/converter_test.py @@ -15,7 +15,7 @@ def test_convert_schedule_to_chromosome(setup_toolbox): tb, _, setup_wg, setup_contractors, _, setup_landscape_many_holders = setup_toolbox schedule = HEFTScheduler().schedule(setup_wg, setup_contractors, validate=True, - landscape=setup_landscape_many_holders) + landscape=setup_landscape_many_holders)[0] chromosome = tb.schedule_to_chromosome(schedule=schedule) assert tb.validate(chromosome) diff --git a/tests/scheduler/lft/scheduling_test.py b/tests/scheduler/lft/scheduling_test.py index ea80e98a..370a75c2 100644 --- a/tests/scheduler/lft/scheduling_test.py +++ b/tests/scheduler/lft/scheduling_test.py @@ -7,7 +7,7 @@ def test_lft_scheduling(setup_schedulers_and_parameters): schedule = scheduler.schedule(setup_wg, setup_contractors, validate=True, - landscape=setup_landscape) + landscape=setup_landscape)[0] lft_time = schedule.execution_time assert not lft_time.is_inf() diff --git a/tests/scheduler/material_scheduling_test.py b/tests/scheduler/material_scheduling_test.py index dda608c7..5213a774 100644 --- a/tests/scheduler/material_scheduling_test.py +++ b/tests/scheduler/material_scheduling_test.py @@ -11,7 +11,7 @@ def test_just_in_time_scheduling_with_materials(setup_default_schedules): pytest.skip('Non-material graph') scheduler = HEFTScheduler() - schedule = scheduler.schedule(setup_wg, setup_contractors, validate=False, landscape=landscape) + schedule = scheduler.schedule(setup_wg, setup_contractors, validate=False, landscape=landscape)[0] try: validate_schedule(schedule, setup_wg, setup_contractors) @@ -26,7 +26,7 @@ def test_momentum_scheduling_with_materials(setup_default_schedules): pytest.skip('Non-material graph') scheduler = HEFTBetweenScheduler() - schedule = scheduler.schedule(setup_wg, setup_contractors, validate=True, landscape=landscape) + schedule = scheduler.schedule(setup_wg, setup_contractors, validate=True, landscape=landscape)[0] try: validate_schedule(schedule, setup_wg, setup_contractors) diff --git a/tests/scheduler/resources_in_time/basic_res_test.py b/tests/scheduler/resources_in_time/basic_res_test.py index 64380d1b..a9da7a07 100644 --- a/tests/scheduler/resources_in_time/basic_res_test.py +++ b/tests/scheduler/resources_in_time/basic_res_test.py @@ -24,7 +24,7 @@ def test_deadline_planning(setup_scheduler_parameters): scheduler = HEFTScheduler() - schedule, _, _, _ = scheduler.schedule_with_cache(setup_wg, setup_contractors, landscape=setup_landscape) + schedule, _, _, _ = scheduler.schedule_with_cache(setup_wg, setup_contractors, landscape=setup_landscape)[0] print(f'Plain planning time: {schedule.execution_time}, cost: {resources_costs_sum(schedule)}') @@ -42,7 +42,7 @@ def test_genetic_deadline_planning(setup_scheduler_parameters): scheduler.set_deadline(deadline) - schedule = scheduler.schedule(setup_wg, setup_contractors, landscape=landscape) + schedule = scheduler.schedule(setup_wg, setup_contractors, landscape=landscape)[0] print(f'Planning for deadline time: {schedule.execution_time}, ' + f'peaks: {resources_peaks_sum(schedule)}, cost: {resources_costs_sum(schedule)}') @@ -76,7 +76,7 @@ def test_lexicographic_genetic_deadline_planning(setup_scheduler_parameters): setup_wg, setup_contractors, setup_landscape = setup_scheduler_parameters scheduler = HEFTScheduler() - schedule, _, _, _ = scheduler.schedule_with_cache(setup_wg, setup_contractors, landscape=setup_landscape) + schedule, _, _, _ = scheduler.schedule_with_cache(setup_wg, setup_contractors, landscape=setup_landscape)[0] # assigning deadline to the time-10^(order_of_magnitude(time) - 1) # time - time of schedule from HEFT @@ -102,13 +102,13 @@ def test_lexicographic_genetic_deadline_planning(setup_scheduler_parameters): scheduler_lexicographic.set_deadline(deadline) - schedule = scheduler_combined.schedule(setup_wg, setup_contractors, landscape=setup_landscape) + schedule = scheduler_combined.schedule(setup_wg, setup_contractors, landscape=setup_landscape)[0] time_combined = schedule.execution_time print(f'\tCombined genetic: time = {time_combined}, ' + f'peak = {resources_peaks_sum(schedule)}') - schedule = scheduler_lexicographic.schedule(setup_wg, setup_contractors, landscape=setup_landscape) + schedule = scheduler_lexicographic.schedule(setup_wg, setup_contractors, landscape=setup_landscape)[0] time_lexicographic = schedule.execution_time print(f'\tLexicographic genetic: time = {time_lexicographic}, ' + diff --git a/tests/scheduler/timeline/zone_timeline_test.py b/tests/scheduler/timeline/zone_timeline_test.py index 9cc00e83..d5d16223 100644 --- a/tests/scheduler/timeline/zone_timeline_test.py +++ b/tests/scheduler/timeline/zone_timeline_test.py @@ -57,5 +57,5 @@ def setup_landscape_config(request) -> LandscapeConfiguration: def test_zoned_scheduling(setup_zoned_wg, setup_landscape_config, setup_scheduler): contractors = [get_contractor_by_wg(setup_zoned_wg, scaler=1000)] - schedule = setup_scheduler.schedule(wg=setup_zoned_wg, contractors=contractors, landscape=setup_landscape_config) + schedule = setup_scheduler.schedule(wg=setup_zoned_wg, contractors=contractors, landscape=setup_landscape_config)[0] print(schedule.execution_time) From 45b555db345579104a4d20cebd62237295ed9897 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Mon, 12 Feb 2024 16:15:18 +0300 Subject: [PATCH 22/31] fix tests --- sampo/scheduler/genetic/base.py | 12 +++++++----- tests/scheduler/genetic/operators_test.py | 4 ++-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index 0c13b490..e567c71d 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -160,15 +160,17 @@ def generate_first_population(wg: WorkGraph, if weights is None: weights = [2, 2, 2, 1, 1, 1, 1] - init_lft_schedule = (LFTScheduler(work_estimator=work_estimator).schedule(wg, contractors, spec, - landscape=landscape)[0], None, spec) + schedule, _, _, node_order = LFTScheduler(work_estimator=work_estimator).schedule_with_cache(wg, contractors, + spec, + landscape=landscape)[0] + init_lft_schedule = (schedule, node_order[::-1], spec) def init_k_schedule(scheduler_class, k) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: schedule, _, _, node_order = (scheduler_class(work_estimator=work_estimator, resource_optimizer=AverageReqResourceOptimizer(k)) .schedule_with_cache(wg, contractors, spec, landscape=landscape))[0] - return schedule, node_order, spec + return schedule, node_order[::-1], spec except NoSufficientContractorError: return None, None, None @@ -177,7 +179,7 @@ def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | N try: schedule, _, _, node_order = (scheduler_class(work_estimator=work_estimator) .schedule_with_cache(wg, contractors, spec, landscape=landscape))[0] - return schedule, node_order, spec + return schedule, node_order[::-1], spec except NoSufficientContractorError: return None, None, None @@ -187,7 +189,7 @@ def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | N (schedule, _, _, node_order), modified_spec = AverageBinarySearchResourceOptimizingScheduler( scheduler_class(work_estimator=work_estimator) ).schedule_with_cache(wg, contractors, deadline, spec, landscape=landscape) - return schedule, node_order, modified_spec + return schedule, node_order[::-1], modified_spec except NoSufficientContractorError: return None, None, None diff --git a/tests/scheduler/genetic/operators_test.py b/tests/scheduler/genetic/operators_test.py index ab03a8b2..269839f7 100644 --- a/tests/scheduler/genetic/operators_test.py +++ b/tests/scheduler/genetic/operators_test.py @@ -51,7 +51,7 @@ def test_mate_order(setup_toolbox, setup_wg): tb, _, _, _, _, _ = setup_toolbox _, _, _, population_size = get_params(setup_wg.vertex_count) - population = tb.population_chromosomes(n=population_size) + population = tb.population(n=population_size) for i in range(TEST_ITERATIONS): individual1, individual2 = population[:2] @@ -71,7 +71,7 @@ def test_mate_resources(setup_toolbox, setup_wg): tb, resources_border, _, _, _, _ = setup_toolbox _, _, _, population_size = get_params(setup_wg.vertex_count) - population = tb.population_chromosomes(n=population_size) + population = tb.population(n=population_size) for i in range(TEST_ITERATIONS): individual1, individual2 = random.sample(population, 2) From e00f621638bfe4b88c279dcae745351550211336 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Mon, 12 Feb 2024 20:01:07 +0300 Subject: [PATCH 23/31] fix pipeline --- sampo/pipeline/default.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sampo/pipeline/default.py b/sampo/pipeline/default.py index 63cd3105..ba53a737 100644 --- a/sampo/pipeline/default.py +++ b/sampo/pipeline/default.py @@ -185,7 +185,7 @@ def node_order(self, node_orders: list[list[GraphNode]]) -> 'InputPipeline': return self def optimize_local(self, optimizer: OrderLocalOptimizer, area: range) -> 'InputPipeline': - self._local_optimize_stack.add(optimizer.optimize, (area,)) + self._local_optimize_stack.add(optimizer.optimize, area) return self def schedule(self, scheduler: Scheduler) -> 'SchedulePipeline': From 3fe1f51b41842f9fd0d9776091defb39c54adb54 Mon Sep 17 00:00:00 2001 From: Timotshak Date: Mon, 12 Feb 2024 21:29:23 +0300 Subject: [PATCH 24/31] fix multiobjective test --- tests/scheduler/genetic/multiobjective_scheduling.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/scheduler/genetic/multiobjective_scheduling.py b/tests/scheduler/genetic/multiobjective_scheduling.py index 2b58295d..f63780f8 100644 --- a/tests/scheduler/genetic/multiobjective_scheduling.py +++ b/tests/scheduler/genetic/multiobjective_scheduling.py @@ -12,9 +12,10 @@ def test_multiobjective_genetic_scheduling(setup_scheduler_parameters): fitness_constructor=TimeAndResourcesFitness(), fitness_weights=(-1, -1), optimize_resources=True, + is_multiobjective=True, sgs_type=ScheduleGenerationScheme.Serial) - schedules = genetic.schedule_multiobjective(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) + schedules = genetic.schedule(setup_wg, setup_contractors, validate=True, landscape=setup_landscape) assert isinstance(schedules, list) and len(schedules) fitnesses = [(schedule.execution_time.value, resources_peaks_sum(schedule)) for schedule in schedules] print('\nPareto-efficient fitnesses:\n', fitnesses) From ff7215425563919c7c5e8aeec3cda5ee169028fe Mon Sep 17 00:00:00 2001 From: Timotshak Date: Mon, 12 Feb 2024 21:42:17 +0300 Subject: [PATCH 25/31] fix backend --- sampo/backend/multiproc.py | 26 +++++++++++++------------- sampo/scheduler/genetic/base.py | 4 +--- sampo/scheduler/genetic/operators.py | 1 - 3 files changed, 14 insertions(+), 17 deletions(-) diff --git a/sampo/backend/multiproc.py b/sampo/backend/multiproc.py index 11f456c1..05ea10ef 100644 --- a/sampo/backend/multiproc.py +++ b/sampo/backend/multiproc.py @@ -13,7 +13,6 @@ from sampo.scheduler.genetic.operators import Individual from sampo.scheduler.genetic.utils import create_toolbox_using_cached_chromosomes, init_chromosomes_f from sampo.scheduler.heft import HEFTScheduler, HEFTBetweenScheduler -from sampo.scheduler.heft.prioritization import prioritization from sampo.scheduler.resource import AverageReqResourceOptimizer from sampo.scheduler.resources_in_time import AverageBinarySearchResourceOptimizingScheduler from sampo.scheduler.topological.base import RandomizedTopologicalScheduler @@ -42,7 +41,7 @@ def scheduler_info_initializer(wg: WorkGraph, only_lft_initialization: bool, is_multiobjective: bool): global g_wg, g_contractors, g_landscape, g_spec, g_toolbox, g_work_estimator, g_deadline, g_rand, g_weights, \ - g_sgs_type, g_only_lft_initialization, g_is_multiobjective + g_sgs_type, g_only_lft_initialization, g_is_multiobjective g_wg = wg g_contractors = contractors @@ -157,35 +156,36 @@ def generate_first_population(self, size_population: int) -> list[Individual]: def mapper(key: str): def randomized_init(): schedule, _, _, order = RandomizedTopologicalScheduler(g_work_estimator, int(g_rand.random() * 1000000)) \ - .schedule_with_cache(g_wg, g_contractors, landscape=g_landscape) + .schedule_with_cache(g_wg, g_contractors, landscape=g_landscape)[0] return schedule, order, g_spec def init_k_schedule(scheduler_class, k) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - return scheduler_class(work_estimator=g_work_estimator, - resource_optimizer=AverageReqResourceOptimizer(k)) \ - .schedule(g_wg, g_contractors, - g_spec, - landscape=g_landscape), list(reversed(prioritization(g_wg, g_work_estimator))), g_spec + schedule, _, _, node_order = (scheduler_class(work_estimator=g_work_estimator, + resource_optimizer=AverageReqResourceOptimizer(k)) + .schedule_with_cache(g_wg, g_contractors, g_spec, + landscape=g_landscape))[0] + return schedule, node_order[::-1], g_spec except NoSufficientContractorError: return None, None, None if g_deadline is None: def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - return scheduler_class(work_estimator=g_work_estimator).schedule(g_wg, g_contractors, - landscape=g_landscape), \ - list(reversed(prioritization(g_wg, g_work_estimator))), g_spec + schedule, _, _, node_order = (scheduler_class(work_estimator=g_work_estimator) + .schedule_with_cache(g_wg, g_contractors, g_spec, + landscape=g_landscape))[0] + return schedule, node_order[::-1], g_spec except NoSufficientContractorError: return None, None, None else: def init_schedule(scheduler_class) -> tuple[Schedule | None, list[GraphNode] | None, ScheduleSpec | None]: try: - (schedule, _, _, _), modified_spec = AverageBinarySearchResourceOptimizingScheduler( + (schedule, _, _, node_order), modified_spec = AverageBinarySearchResourceOptimizingScheduler( scheduler_class(work_estimator=g_work_estimator) ).schedule_with_cache(g_wg, g_contractors, g_deadline, g_spec, landscape=g_landscape) - return schedule, list(reversed(prioritization(g_wg, g_work_estimator))), modified_spec + return schedule, node_order[::-1], modified_spec except NoSufficientContractorError: return None, None, None diff --git a/sampo/scheduler/genetic/base.py b/sampo/scheduler/genetic/base.py index e567c71d..ddb869b4 100644 --- a/sampo/scheduler/genetic/base.py +++ b/sampo/scheduler/genetic/base.py @@ -1,5 +1,5 @@ import random -from typing import Optional, Callable +from typing import Optional from sampo.api.genetic_api import ChromosomeType from sampo.scheduler.base import Scheduler, SchedulerType @@ -8,13 +8,11 @@ from sampo.scheduler.genetic.converter import ScheduleGenerationScheme from sampo.scheduler.heft.base import HEFTScheduler, HEFTBetweenScheduler from sampo.scheduler.lft.base import LFTScheduler -from sampo.scheduler.heft.prioritization import prioritization from sampo.scheduler.resource.average_req import AverageReqResourceOptimizer from sampo.scheduler.resource.base import ResourceOptimizer from sampo.scheduler.resource.identity import IdentityResourceOptimizer from sampo.scheduler.resources_in_time.average_binary_search import AverageBinarySearchResourceOptimizingScheduler from sampo.scheduler.timeline.base import Timeline -from sampo.scheduler.utils import get_worker_contractor_pool from sampo.schemas.contractor import Contractor from sampo.schemas.exceptions import NoSufficientContractorError from sampo.schemas.graph import WorkGraph, GraphNode diff --git a/sampo/scheduler/genetic/operators.py b/sampo/scheduler/genetic/operators.py index 5af67268..6f200e08 100644 --- a/sampo/scheduler/genetic/operators.py +++ b/sampo/scheduler/genetic/operators.py @@ -1,7 +1,6 @@ import math import random from copy import deepcopy -from functools import partial from operator import attrgetter from typing import Callable, Iterable From 3aa8247234fc8c0d89951bc78d839253a574c2a1 Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 15:35:02 +0300 Subject: [PATCH 26/31] fix experiments --- experiments/algorithms_2_multi_agency.py | 2 +- experiments/genetic2baseline.py | 4 ++-- experiments/genetic_2_multi_agency.py | 4 ++-- experiments/genetic_init.py | 4 ++-- experiments/neural_network/wg_algo_dataset_generation.py | 2 +- experiments/psplib/genetic_PSPLIB.py | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/experiments/algorithms_2_multi_agency.py b/experiments/algorithms_2_multi_agency.py index 26a00848..c3bd27e6 100644 --- a/experiments/algorithms_2_multi_agency.py +++ b/experiments/algorithms_2_multi_agency.py @@ -56,6 +56,6 @@ def log(message: str, logfile: IO): print(f'Best algo: {best_algo}') - schedule = best_algo.schedule(conjuncted, contractors) + schedule = best_algo.schedule(conjuncted, contractors)[0] print(f'Best algo res: {schedule.execution_time}') diff --git a/experiments/genetic2baseline.py b/experiments/genetic2baseline.py index 452dcdc7..591d7a8a 100644 --- a/experiments/genetic2baseline.py +++ b/experiments/genetic2baseline.py @@ -52,7 +52,7 @@ def generate_contractors(wg: WorkGraph, num_contractors: int, contractor_min_res top_border=GRAPH_SIZE + BORDER_RADIUS) contractors = generate_contractors(wg, 1, 0) -baseline_result = BaselineGeneticScheduler().schedule(wg, contractors) -my_result = GeneticScheduler().schedule(wg, contractors) +baseline_result = BaselineGeneticScheduler().schedule(wg, contractors)[0] +my_result = GeneticScheduler().schedule(wg, contractors)[0] print(f'Baseline result: {baseline_result.execution_time}') print(f'My result: {my_result.execution_time}') diff --git a/experiments/genetic_2_multi_agency.py b/experiments/genetic_2_multi_agency.py index 7f51600e..bc5f9ff3 100644 --- a/experiments/genetic_2_multi_agency.py +++ b/experiments/genetic_2_multi_agency.py @@ -37,7 +37,7 @@ def obstruction_getter(i: int) -> Obstruction | None: conjuncted = bg.to_work_graph() print(f'Conjunction finished: {conjuncted.vertex_count} works') - # schedule = agents[0].scheduler.schedule(conjuncted, contractors) + # schedule = agents[0].scheduler.schedule(conjuncted, contractors)[0] scheduled_blocks = manager.manage_blocks(bg, logger=print) @@ -50,7 +50,7 @@ def obstruction_getter(i: int) -> Obstruction | None: print(f'Best genetic: {best_genetic}') - schedule = best_genetic.schedule(conjuncted, contractors) + schedule = best_genetic.schedule(conjuncted, contractors)[0] ma_res = max(sblock.end_time for sblock in scheduled_blocks.values()) genetic_res = schedule.execution_time diff --git a/experiments/genetic_init.py b/experiments/genetic_init.py index 08d106ca..f0093741 100644 --- a/experiments/genetic_init.py +++ b/experiments/genetic_init.py @@ -24,8 +24,8 @@ def run_test(args) -> list[tuple[Time, Time]]: size_of_population=200) optimized_genetic.set_weights([14, 11, 1, 1, 1, 1, 10]) - baseline_result = baseline_genetic.schedule(wg, contractors) - my_result = optimized_genetic.schedule(wg, contractors) + baseline_result = baseline_genetic.schedule(wg, contractors)[0] + my_result = optimized_genetic.schedule(wg, contractors)[0] result.append((baseline_result.execution_time, my_result.execution_time)) diff --git a/experiments/neural_network/wg_algo_dataset_generation.py b/experiments/neural_network/wg_algo_dataset_generation.py index 2b621ddd..d4c63f3c 100644 --- a/experiments/neural_network/wg_algo_dataset_generation.py +++ b/experiments/neural_network/wg_algo_dataset_generation.py @@ -50,7 +50,7 @@ def display_top(snapshot, key_type='lineno', limit=3): def generate() -> tuple: wg = ss.work_graph(top_border=GRAPHS_TOP_BORDER) encoding = encode_graph(wg) - schedulers_results = [int(scheduler.schedule(wg, contractors).execution_time) for scheduler in schedulers] + schedulers_results = [int(scheduler.schedule(wg, contractors)[0].execution_time) for scheduler in schedulers] generated_label = argmin(schedulers_results) del wg del schedulers_results diff --git a/experiments/psplib/genetic_PSPLIB.py b/experiments/psplib/genetic_PSPLIB.py index 37d6b7c6..f3415e23 100644 --- a/experiments/psplib/genetic_PSPLIB.py +++ b/experiments/psplib/genetic_PSPLIB.py @@ -58,7 +58,7 @@ def run_scheduler(wg_info): scheduler = GeneticScheduler(20, size_of_population=50, work_estimator=work_estimator, sgs_type=ScheduleGenerationScheme.Serial, only_lft_initialization=True) start = time.time() - schedule = scheduler.schedule(wg, contractor) + schedule = scheduler.schedule(wg, contractor)[0] finish = time.time() # merged_schedule = schedule.merged_stages_datetime_df('2022-01-01') From e46ce419b38d0749535fd71c47d862b95a2a673d Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 15:35:26 +0300 Subject: [PATCH 27/31] fix examples --- examples/field_development/field_development_scheduling.py | 2 +- examples/generator_scenarios.py | 4 ++-- examples/simple_synthetic_graph_scheduling.py | 2 +- .../stochastic_maintenance/aircraft_stochastic_maintenance.py | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/field_development/field_development_scheduling.py b/examples/field_development/field_development_scheduling.py index a9fb01eb..33efa61f 100644 --- a/examples/field_development/field_development_scheduling.py +++ b/examples/field_development/field_development_scheduling.py @@ -46,7 +46,7 @@ start_date = "2023-01-01" # Set up the project's start date # Schedule field development tasks -schedule = scheduler_type.schedule(structured_wg, contractors, validate=True) +schedule = scheduler_type.schedule(structured_wg, contractors, validate=True)[0] schedule_df = schedule.merged_stages_datetime_df(start_date) # Schedule's gant chart visualization diff --git a/examples/generator_scenarios.py b/examples/generator_scenarios.py index f744590b..f07c423f 100644 --- a/examples/generator_scenarios.py +++ b/examples/generator_scenarios.py @@ -15,7 +15,7 @@ p_rand = SimpleSynthetic(rand=231) wg = p_rand.work_graph(top_border=3000) contractors = [p_rand.contractor(i) for i in range(10, 31, 10)] -schedule = HEFTScheduler().schedule(wg, contractors) +schedule = HEFTScheduler().schedule(wg, contractors)[0] print(len(wg.nodes)) print("\nDefault contractors") @@ -24,7 +24,7 @@ print("\nContractor by work graph") for pack_counts in []:#[1, 2, 10]: contractors = [get_contractor_by_wg(wg, scaler=pack_counts)] - execution_time = HEFTScheduler().schedule(wg, contractors).execution_time + execution_time = HEFTScheduler().schedule(wg, contractors)[0].execution_time print(f"Execution time: {execution_time}, pack count: {pack_counts}") print("\nNames extension") diff --git a/examples/simple_synthetic_graph_scheduling.py b/examples/simple_synthetic_graph_scheduling.py index 1a61d5c2..0fdf701b 100644 --- a/examples/simple_synthetic_graph_scheduling.py +++ b/examples/simple_synthetic_graph_scheduling.py @@ -44,7 +44,7 @@ contractors = [get_contractor_by_wg(wg)] # Schedule works -schedule = scheduler.schedule(wg, contractors) +schedule = scheduler.schedule(wg, contractors)[0] schedule_df = schedule.merged_stages_datetime_df(start_date) # Schedule's gant chart visualization gant_fig = schedule_gant_chart_fig(schedule_df, diff --git a/examples/stochastic_maintenance/aircraft_stochastic_maintenance.py b/examples/stochastic_maintenance/aircraft_stochastic_maintenance.py index 1e2b56eb..75f5bb97 100644 --- a/examples/stochastic_maintenance/aircraft_stochastic_maintenance.py +++ b/examples/stochastic_maintenance/aircraft_stochastic_maintenance.py @@ -67,7 +67,7 @@ def statuses_available(self) -> int: .work_estimator(work_estimator) \ .landscape(landscape_config) \ .schedule(genetic_scheduler) \ - .finish() + .finish()[0] merged_schedule = aircraft_project.schedule.merged_stages_datetime_df('2022-01-01') From 699b9439f190da0997ef5612aeaab936cccaee60 Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 15:35:45 +0300 Subject: [PATCH 28/31] fix multi-agency --- sampo/scheduler/multi_agency/multi_agency.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sampo/scheduler/multi_agency/multi_agency.py b/sampo/scheduler/multi_agency/multi_agency.py index 409fd8d9..5eef6fa9 100644 --- a/sampo/scheduler/multi_agency/multi_agency.py +++ b/sampo/scheduler/multi_agency/multi_agency.py @@ -45,7 +45,7 @@ def offer(self, wg: WorkGraph, parent_time: Time) -> tuple[Time, Time, Schedule, """ schedule, start_time, timeline, _ = \ self._scheduler.schedule_with_cache(wg, self._contractors, - assigned_parent_time=parent_time, timeline=deepcopy(self._timeline)) + assigned_parent_time=parent_time, timeline=deepcopy(self._timeline))[0] return start_time, schedule.execution_time, schedule, timeline def confirm(self, timeline: Timeline, start: Time, end: Time): From df2369fad419783098e5b3cea2c7abb51cf34d19 Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 15:35:57 +0300 Subject: [PATCH 29/31] fix readme --- README.rst | 8 ++++---- docs/source/Usage.rst | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/README.rst b/README.rst index 57c5c682..097bb313 100644 --- a/README.rst +++ b/README.rst @@ -130,14 +130,14 @@ To use SAMPO for the schedule generation you need to prepare: from sampo.scheduler.genetic import GeneticScheduler - scheduler = GeneticScheduler(mutate_order=0.1, - mutate_resources=0.3) + scheduler = GeneticScheduler(mutate_order=0.05, + mutate_resources=0.05) 2.2. Schedule generation .. code-block:: python - schedule = scheduler.schedule(wg, contractors) + schedule = scheduler.schedule(wg, contractors)[0] 3. Pipeline structure @@ -151,7 +151,7 @@ When data was prepared and scheduler built, you should use scheduling pipeline t .wg(wg) \ .contractors(contractors) \ .schedule(HEFTScheduler()) \ - .finish() + .finish()[0] Supported by ============ diff --git a/docs/source/Usage.rst b/docs/source/Usage.rst index ea8a6106..60ecfb80 100644 --- a/docs/source/Usage.rst +++ b/docs/source/Usage.rst @@ -72,14 +72,14 @@ To use SAMPO for the schedule generation you need to prepare: from sampo.scheduler.genetic import GeneticScheduler - scheduler = GeneticScheduler(mutate_order=0.1, - mutate_resources=0.3) + scheduler = GeneticScheduler(mutate_order=0.05, + mutate_resources=0.05) 2.2. Schedule generation .. code-block:: python - schedule = scheduler.schedule(wg, contractors) + schedule = scheduler.schedule(wg, contractors)[0] 3. Pipeline structure @@ -93,4 +93,4 @@ When data was prepared and scheduler built, you should use scheduling pipeline t .wg(wg) \ .contractors(contractors) \ .schedule(HEFTScheduler()) \ - .finish() \ No newline at end of file + .finish()[0] \ No newline at end of file From 03a1a6c3a438d5828f7da3e4218450588d832def Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 16:18:05 +0300 Subject: [PATCH 30/31] fix notebooks --- examples/local_optimization.ipynb | 175 +- examples/scheduling_project.ipynb | 276 +- examples/simple_generation.ipynb | 399 +- examples/visualization.ipynb | 28260 ++++++++++---------- experiments/neural_network/nn2ma.ipynb | 39 +- experiments/stochastic_productivity.ipynb | 236 +- 6 files changed, 14863 insertions(+), 14522 deletions(-) diff --git a/examples/local_optimization.ipynb b/examples/local_optimization.ipynb index 0ffa03e3..89223859 100644 --- a/examples/local_optimization.ipynb +++ b/examples/local_optimization.ipynb @@ -4,10 +4,13 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2023-10-31T08:06:06.215669600Z", "start_time": "2023-10-31T08:06:05.535679400Z" + }, + "collapsed": true, + "jupyter": { + "outputs_hidden": true } }, "outputs": [], @@ -21,16 +24,29 @@ }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 1. Data preparation" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:06:06.275585700Z", + "start_time": "2023-10-31T08:06:06.215669600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# SimpleSynthetic object used for the simple work graph structure generation\n", @@ -49,38 +65,47 @@ "contractors = [get_contractor_by_wg(simple_wg)]\n", "\n", "scheduler = HEFTScheduler()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:06:06.275585700Z", - "start_time": "2023-10-31T08:06:06.215669600Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 2. Local optimization\n", "There are two types of local optimization in SAMPO: order and schedule." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Scheduling order optimization\n", "This local optimization should rearrange scheduling order to improve scheduling results." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:06:06.450877800Z", + "start_time": "2023-10-31T08:06:06.365998300Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -91,7 +116,9 @@ }, { "data": { - "text/plain": "1194" + "text/plain": [ + "1194" + ] }, "execution_count": 3, "metadata": {}, @@ -108,35 +135,43 @@ " .contractors(contractors) \\\n", " .optimize_local(local_optimizer, range(0, 10)) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:06:06.450877800Z", - "start_time": "2023-10-31T08:06:06.365998300Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Schedule optimization\n", "This local optimization should recalculate parts of schedule to make it better." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:06:06.635515100Z", + "start_time": "2023-10-31T08:06:06.465560600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { - "text/plain": "1194" + "text/plain": [ + "1194" + ] }, "execution_count": 4, "metadata": {}, @@ -154,32 +189,38 @@ " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", " .optimize_local(local_optimizer, range(0, 5)) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:06:06.635515100Z", - "start_time": "2023-10-31T08:06:06.465560600Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Both\n", "Using pipeline you can apply both type of optimizations.\n", "You also can stack local optimizers, they should be applied sequentially." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:06:06.860829700Z", + "start_time": "2023-10-31T08:06:06.690476Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -306,7 +347,9 @@ }, { "data": { - "text/plain": "1240" + "text/plain": [ + "1240" + ] }, "execution_count": 5, "metadata": {}, @@ -327,51 +370,47 @@ " .schedule(scheduler) \\\n", " .optimize_local(schedule_optimizer, range(0, simple_wg.vertex_count // 2)) \\\n", " .optimize_local(schedule_optimizer, range(simple_wg.vertex_count // 2, simple_wg.vertex_count)) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:06:06.860829700Z", - "start_time": "2023-10-31T08:06:06.690476Z" - } - } + ] }, { "cell_type": "code", "execution_count": 5, - "outputs": [], - "source": [], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T08:06:06.870912400Z", "start_time": "2023-10-31T08:06:06.855820800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/examples/scheduling_project.ipynb b/examples/scheduling_project.ipynb index 9dd45ae6..4987021c 100644 --- a/examples/scheduling_project.ipynb +++ b/examples/scheduling_project.ipynb @@ -4,10 +4,13 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2023-10-31T07:27:22.658921Z", "start_time": "2023-10-31T07:27:22.164401500Z" + }, + "collapsed": true, + "jupyter": { + "outputs_hidden": true } }, "outputs": [], @@ -18,34 +21,50 @@ }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 1. Graph generation" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:22.663942900Z", + "start_time": "2023-10-31T07:27:22.658921Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# SimpleSynthetic object used for the simple work graph structure generation\n", "\n", "r_seed = 231\n", "ss = SimpleSynthetic(r_seed)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:22.663942900Z", - "start_time": "2023-10-31T07:27:22.658921Z" - } - } + ] }, { "cell_type": "code", "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:22.703949100Z", + "start_time": "2023-10-31T07:27:22.663942900Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# simple graph\n", @@ -55,18 +74,21 @@ " cluster_counts=10,\n", " bottom_border=100,\n", " top_border=200)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:22.703949100Z", - "start_time": "2023-10-31T07:27:22.663942900Z" - } - } + ] }, { "cell_type": "code", "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:29.632916Z", + "start_time": "2023-10-31T07:27:22.708956400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# complex graph\n", @@ -75,54 +97,66 @@ "advanced_wg = ss.advanced_work_graph(works_count_top_border=2000,\n", " uniq_works=300,\n", " uniq_resources=100)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:29.632916Z", - "start_time": "2023-10-31T07:27:22.708956400Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 2. Contractor generation" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 5, - "outputs": [], - "source": [ - "from uuid import uuid4\n", - "from sampo.schemas.resources import Worker\n", - "from sampo.schemas.contractor import Contractor" - ], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T07:27:29.651210500Z", "start_time": "2023-10-31T07:27:29.633954Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [ + "from uuid import uuid4\n", + "from sampo.schemas.resources import Worker\n", + "from sampo.schemas.contractor import Contractor" + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Manual generation\n", "To create contractor, you should provide minimal info: unique id, contractor name, and supplied workers (simple renewable resources)." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:29.674082Z", + "start_time": "2023-10-31T07:27:29.653754100Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "contractors = [\n", @@ -130,99 +164,122 @@ " name=\"OOO Berezka\",\n", " workers={'worker' : Worker(id='0', name='worker', count=100)})\n", "]" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:29.674082Z", - "start_time": "2023-10-31T07:27:29.653754100Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Generation from graph" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 7, - "outputs": [], - "source": [ - "from sampo.generator.environment.contractor_by_wg import get_contractor_by_wg\n", - "\n", - "contractors = [get_contractor_by_wg(simple_wg)]" - ], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T07:27:29.694269700Z", "start_time": "2023-10-31T07:27:29.674082Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [ + "from sampo.generator.environment.contractor_by_wg import get_contractor_by_wg\n", + "\n", + "contractors = [get_contractor_by_wg(simple_wg)]" + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 3. Scheduling" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Scheduler construction\n", "Before scheduling you should specify scheduling algorithm used for transforming input data to the final schedule.\n", "At this time SAMPO contains heuristic algorithms, such as HEFTAddEnd, HEFTAddBetween and Topological scheduler, and the Genetic algorithm.\n", "While creation, you can specify the hyperparameters to fit the algorithm." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:29.733816500Z", + "start_time": "2023-10-31T07:27:29.694269700Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "from sampo.scheduler.heft.base import HEFTScheduler\n", "\n", "# here we can just create simple heuristic scheduler\n", "scheduler = HEFTScheduler()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:29.733816500Z", - "start_time": "2023-10-31T07:27:29.694269700Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Scheduling process\n", "SAMPO provides a simple interface to all its features.\n", "It called SchedulingPipeline.\n", "Using it you only should pass all the scheduling arguments, it remembers them, and you can produce schedules in many ways." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T07:27:30.018935700Z", + "start_time": "2023-10-31T07:27:29.733816500Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { - "text/plain": "1194" + "text/plain": [ + "1194" + ] }, "execution_count": 9, "metadata": {}, @@ -236,66 +293,65 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T07:27:30.018935700Z", - "start_time": "2023-10-31T07:27:29.733816500Z" - } - } + ] }, { "cell_type": "code", "execution_count": 10, - "outputs": [], - "source": [ - "project.dump('.', 'project_test')" - ], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T07:27:30.233814800Z", "start_time": "2023-10-31T07:27:30.113622300Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [ + "project.dump('.', 'project_test')" + ] }, { "cell_type": "code", "execution_count": 10, - "outputs": [], - "source": [], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T07:27:30.254027100Z", "start_time": "2023-10-31T07:27:30.233814800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/examples/simple_generation.ipynb b/examples/simple_generation.ipynb index ba977213..b547cd6d 100644 --- a/examples/simple_generation.ipynb +++ b/examples/simple_generation.ipynb @@ -4,10 +4,13 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2023-10-31T08:17:22.640827Z", "start_time": "2023-10-31T08:17:22.161108400Z" + }, + "collapsed": true, + "jupyter": { + "outputs_hidden": true } }, "outputs": [], @@ -18,34 +21,50 @@ }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 1. Graph generation" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:22.663581500Z", + "start_time": "2023-10-31T08:17:22.640827Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# SimpleSynthetic object used for the simple work graph structure generation\n", "\n", "r_seed = 231\n", "ss = SimpleSynthetic(r_seed)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:22.663581500Z", - "start_time": "2023-10-31T08:17:22.640827Z" - } - } + ] }, { "cell_type": "code", "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:22.701082400Z", + "start_time": "2023-10-31T08:17:22.681145200Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# simple graph\n", @@ -55,18 +74,21 @@ " cluster_counts=10,\n", " bottom_border=100,\n", " top_border=200)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:22.701082400Z", - "start_time": "2023-10-31T08:17:22.681145200Z" - } - } + ] }, { "cell_type": "code", "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:29.710850800Z", + "start_time": "2023-10-31T08:17:22.701082400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "# complex graph\n", @@ -75,54 +97,66 @@ "advanced_wg = ss.advanced_work_graph(works_count_top_border=2000,\n", " uniq_works=300,\n", " uniq_resources=100)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:29.710850800Z", - "start_time": "2023-10-31T08:17:22.701082400Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 2. Contractor generation" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 5, - "outputs": [], - "source": [ - "from uuid import uuid4\n", - "from sampo.schemas.resources import Worker\n", - "from sampo.schemas.contractor import Contractor" - ], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T08:17:29.731148Z", "start_time": "2023-10-31T08:17:29.710850800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [ + "from uuid import uuid4\n", + "from sampo.schemas.resources import Worker\n", + "from sampo.schemas.contractor import Contractor" + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Manual generation\n", "To create contractor, you should provide minimal info: unique id, contractor name, and supplied workers (simple renewable resources)." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:29.751365800Z", + "start_time": "2023-10-31T08:17:29.731148Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "contractors = [\n", @@ -130,83 +164,101 @@ " name=\"OOO Berezka\",\n", " workers={'worker' : Worker(id='0', name='worker', count=100)})\n", "]" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:29.751365800Z", - "start_time": "2023-10-31T08:17:29.731148Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Generation from graph" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 7, - "outputs": [], - "source": [ - "from sampo.generator.environment.contractor_by_wg import get_contractor_by_wg\n", - "\n", - "contractors = [get_contractor_by_wg(simple_wg)]" - ], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T08:17:29.770932Z", "start_time": "2023-10-31T08:17:29.751365800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [ + "from sampo.generator.environment.contractor_by_wg import get_contractor_by_wg\n", + "\n", + "contractors = [get_contractor_by_wg(simple_wg)]" + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 3. Scheduling" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Scheduler construction\n", "Before scheduling you should specify scheduling algorithm used for transforming input data to the final schedule.\n", "At this time SAMPO contains heuristic algorithms, such as HEFTAddEnd, HEFTAddBetween and Topological scheduler, and the Genetic algorithm.\n", "While creation, you can specify the hyperparameters to fit the algorithm." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:29.831002900Z", + "start_time": "2023-10-31T08:17:29.770932Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "from sampo.scheduler.heft.base import HEFTScheduler\n", "\n", "# here we can just create simple heuristic scheduler\n", "scheduler = HEFTScheduler()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:29.831002900Z", - "start_time": "2023-10-31T08:17:29.770932Z" - } - } + ] }, { "cell_type": "code", "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:17:29.851237100Z", + "start_time": "2023-10-31T08:17:29.811172300Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -220,32 +272,38 @@ "from sampo.scheduler.genetic.base import GeneticScheduler\n", "\n", "# or more complex genetic scheduler\n", - "scheduler = GeneticScheduler(mutate_order=0.1,\n", - " mutate_resources=0.3)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:17:29.851237100Z", - "start_time": "2023-10-31T08:17:29.811172300Z" - } - } + "scheduler = GeneticScheduler(mutate_order=0.05,\n", + " mutate_resources=0.05)" + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Scheduling process\n", "SAMPO provides a simple interface to all its features.\n", "It called SchedulingPipeline.\n", "Using it you only should pass all the scheduling arguments, it remembers them, and you can produce schedules in many ways." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:21:13.881802200Z", + "start_time": "2023-10-31T08:17:29.851237100Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -312,7 +370,9 @@ }, { "data": { - "text/plain": "951" + "text/plain": [ + "951" + ] }, "execution_count": 10, "metadata": {}, @@ -326,34 +386,40 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:21:13.881802200Z", - "start_time": "2023-10-31T08:17:29.851237100Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Other metrics\n", "Genetic scheduler can do more than just optimize MakeSpan. It supports more metrics.\n", "Metrics are represented by `FitnessFunction` class and can be passed to `GeneticScheduler` on constructing.\n", "\n", "Here we're constructing Genetic that should optimize resources to deadline." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:27:06.272880400Z", + "start_time": "2023-10-31T08:21:13.896735100Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -408,7 +474,9 @@ }, { "data": { - "text/plain": "1756" + "text/plain": [ + "1756" + ] }, "execution_count": 11, "metadata": {}, @@ -421,10 +489,10 @@ "\n", "deadline = Time(2000)\n", "# calling `prepare` method to pass explicit parameters to fitness function\n", - "fitness_constructor = DeadlineResourcesFitness.prepare(deadline)\n", + "fitness_constructor = DeadlineResourcesFitness(deadline)\n", "\n", - "scheduler = GeneticScheduler(mutate_order=0.1,\n", - " mutate_resources=0.3,\n", + "scheduler = GeneticScheduler(mutate_order=0.05,\n", + " mutate_resources=0.05,\n", " fitness_constructor=fitness_constructor)\n", "scheduler.set_deadline(deadline)\n", "\n", @@ -432,30 +500,36 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:27:06.272880400Z", - "start_time": "2023-10-31T08:21:13.896735100Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "Additionally, you can construct other metrics: deadline cost, time with resources (without deadline) fitness:" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:28:08.257361900Z", + "start_time": "2023-10-31T08:27:06.276925900Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -485,7 +559,9 @@ }, { "data": { - "text/plain": "1737" + "text/plain": [ + "1737" + ] }, "execution_count": 12, "metadata": {}, @@ -495,10 +571,10 @@ "source": [ "from sampo.scheduler.genetic.operators import DeadlineCostFitness\n", "\n", - "fitness_constructor = DeadlineCostFitness.prepare(deadline)\n", + "fitness_constructor = DeadlineCostFitness(deadline)\n", "\n", - "scheduler = GeneticScheduler(mutate_order=0.1,\n", - " mutate_resources=0.3,\n", + "scheduler = GeneticScheduler(mutate_order=0.05,\n", + " mutate_resources=0.05,\n", " fitness_constructor=fitness_constructor)\n", "scheduler.set_deadline(deadline)\n", "\n", @@ -506,21 +582,24 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:28:08.257361900Z", - "start_time": "2023-10-31T08:27:06.276925900Z" - } - } + ] }, { "cell_type": "code", "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-31T08:35:20.615297500Z", + "start_time": "2023-10-31T08:28:08.257361900Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -588,7 +667,9 @@ }, { "data": { - "text/plain": "1441" + "text/plain": [ + "1441" + ] }, "execution_count": 13, "metadata": {}, @@ -598,10 +679,10 @@ "source": [ "from sampo.scheduler.genetic.operators import TimeWithResourcesFitness\n", "\n", - "fitness_constructor = TimeWithResourcesFitness\n", + "fitness_constructor = TimeWithResourcesFitness()\n", "\n", - "scheduler = GeneticScheduler(mutate_order=0.1,\n", - " mutate_resources=0.3,\n", + "scheduler = GeneticScheduler(mutate_order=0.05,\n", + " mutate_resources=0.05,\n", " fitness_constructor=fitness_constructor)\n", "scheduler.set_deadline(deadline)\n", "\n", @@ -609,51 +690,47 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish[0]\n", "\n", "project.schedule.execution_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-31T08:35:20.615297500Z", - "start_time": "2023-10-31T08:28:08.257361900Z" - } - } + ] }, { "cell_type": "code", "execution_count": 13, - "outputs": [], - "source": [], "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-10-31T08:35:20.674007700Z", "start_time": "2023-10-31T08:35:20.615367400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } - } + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/examples/visualization.ipynb b/examples/visualization.ipynb index 6faa8a2e..da7e1d24 100644 --- a/examples/visualization.ipynb +++ b/examples/visualization.ipynb @@ -2,16 +2,29 @@ "cells": [ { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 1. Scheduling" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-04T13:35:22.110623700Z", + "start_time": "2023-10-04T13:35:21.940615600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "from sampo.generator.base import SimpleSynthetic\n", @@ -37,30 +50,36 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish()\n", + " .finish()[0]\n", "\n", "schedule = project.schedule" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-04T13:35:22.110623700Z", - "start_time": "2023-10-04T13:35:21.940615600Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 2. WorkGraph visualization" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-04T13:35:26.139585600Z", + "start_time": "2023-10-04T13:35:23.754591600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stderr", @@ -74,8 +93,10 @@ }, { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAACdgAAAmJCAYAAACgJ43pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAC4jAAAuIwF4pT92AAEAAElEQVR4nOzdeXwM1v7/8fdkJSIbSS0XsdReO3XRhq6KVlBFq42tVarVtKToIpR7W3TltrV1odWi9raq1Fq1b6WURhI0tpBVQtb5/eFnviaZJDMyMSNez8fD4zpnzvKZhYebvuccg9FoNAoAAAAAAAAAAAAAAAAAAJhxcXQBAAAAAAAAAAAAAAAAAAA4IwJ2AAAAAAAAAAAAAAAAAABYQMAOAAAAAAAAAAAAAAAAAAALCNgBAAAAAAAAAAAAAAAAAGABATsAAAAAAAAAAAAAAAAAACwgYAcAAAAAAAAAAAAAAAAAgAUE7AAAAAAAAAAAAAAAAAAAsICAHQAAAAAAAAAAAAAAAAAAFhCwAwAAAAAAAAAAAAAAAADAAgJ2AAAAAAAAAAAAAAAAAABYQMAOAAAAAAAAAAAAAAAAAAALCNgBAAAAAAAAAAAAAAAAAGABATsAAAAAAAAAAAAAAAAAACwgYAcAAAAAAAAAAAAAAAAAgAUE7AAAAAAAAAAAAAAAAAAAsICAHQAAAAAAAAAAAAAAAAAAFhCwAwAAAAAAAAAAAAAAAADAAgJ2AAAAAAAAAAAAAAAAAABYQMAOAAAAAAAAAAAAAAAAAAALCNgBAAAAAAAAAAAAAAAAAGABATsAAAAAAAAAAAAAAAAAACwgYAcAAAAAAAAAAAAAAAAAgAUE7AAAAAAAAAAAAAAAAAAAsICAHQAAAAAAAAAAAAAAAAAAFhCwAwAAAAAAAAAAAAAAAADAAgJ2AAAAAAAAAAAAAAAAAABYQMAOAAAAAAAAAAAAAAAAAAAL3BxdAJxfUlKSNm3aZGpXq1ZNnp6eDqwIAAAAAAAAAAAAAAAAgCNlZGTo1KlTpnZISIj8/PwcV1AJIWCHIm3atEmhoaGOLgMAAAAAAAAAAAAAAACAk1q+fLm6d+/u6DLsjitiAQAAAAAAAAAAAAAAAACwgIAdAAAAAAAAAAAAAAAAAAAWcEUsilStWjWz9vLly1WnTh0HVQMAAAAAAAAAAAAAAADA0aKiohQaGmpq580YlRYE7FAkT09Ps3adOnXUqFEjB1UDAAAAAAAAAAAAAAAAwNnkzRiVFlwRCwAAAAAAAAAAAAAAAACABQTsAAAAAAAAAAAAAAAAAACwgIAdAAAAAAAAAAAAAAAAAAAWELADAAAAAAAAAAAAAAAAAMACAnYAAAAAAAAAAAAAAAAAAFhAwA4AAAAAAAAAAAAAAAAAAAsI2AEAAAAAAAAAAAAAAAAAYAEBOwAAAAAAAAAAAAAAAAAALCBgBwAAAAAAAAAAAAAAAACABQTsAAAAAAAAAAAAAAAAAACwgIAdAAAAAAAAAAAAAAAAAAAWELADAAAAAAAAAAAAAAAAAMACAnYAAAAAAAAAAAAAAAAAAFhAwA4AAAAAAAAAAAAAAAAAAAvcHF0AAAAAAAAAAAAAABTEaDQqNzdXRqPR0aUAAAA4NYPBIBcXFxkMBkeXUqoQsAMAAAAAAAAAAADgNHJycpSWlqbU1FSlpaUpJyfH0SUBAADcUlxdXVWuXDmVL19e5cqVk6urq6NLuqURsAMAAAAAAAAAAADgcDk5OTpz5oxSU1MdXQoAAMAtLScnRykpKUpJSZEklS9fXpUrVyZod4MI2AEAAAAAAAAAAABwqKysLJ06dUoZGRmOLgUAAKDUSU1NVWZmpqpVqyZ3d3dHl3PLcXF0AQAAAAAAAAAAAABuXxkZGYqNjSVcBwAAUIL4N9eN4wQ7AABwy0hISDAdYwzYm4+PjwICAhxdBgAAAAAAwG3n3Llzys7ONuszGAzy8vJS+fLlVbZsWbm6uspgMDioQgAAgFuD0WhUTk6OLl++rNTUVKWnp8toNJoez87O1rlz51S9enUHVnnrIWAHAACcTuLZBJ04GKNmD7Y09SUkJKh2cG0lpSY5rjCUan7l/XQ89jghOwAAAAAAgJsoKytLaWlpZn0eHh6qVq2aPDw8HFQVAADArcvd3V1lypSRv7+/MjMzderUKWVmZpoeT0tLU1ZWFlfF2oCAHQAAcDpZVzL10TPvqO/4Z/TQ0G4yGAxKSUlRUmqSPrnjAwW5BTq6RJQy57PjNfxcuFJSUgjYAQAAAAAA3ETJyclmbRcXF9WoUUNubvxnTAAAgOLy8PBQjRo1dPz4ceXm5pr6k5OTVbFiRQdWdmvhX6YAAMApGXNz9e34L3UmKk79/zvE1B/kFqjKbpUcWBkAAAAAAAAAe8kbsPPx8SFcBwAAYEdubm7y8fFRUlKSqY+AnW1cHF0AAABAYTbOX6v3+k7S5ZR0R5cCAAAAAAAAwI6MRqPZdWXS1YAdAAAA7Cvvv7GysrJkNBodVM2th69/AACAEnEpMVUX4y7oXPQZm+cmnL5g1j7y20GdH3xW5V3L2as8AAAAAAAAAA52/TVl17i7uzugEgAAgNIt77+xjEajjEajDAaDgyq6tRCwAwAAJWLfz7s09+X/2W29iyfj1dW/ky7kxquyuCIW9vX7Q3/qFY3V9Imz7LZmRnamZsybZrf1AAAAAAAAShtLp6a4uHABFwAAgL1Z+jdWbm4u//ayEgE7AABwy3A3uCldaY4uA6WUvb+h4+nmYdf1AAAAAAAAAAAAANx8BOwAAECJqPfvhqp8Z1Wd+TtO3hV8VL9dI6vnpsQn6dj2I2Z9ZXzKasWJNeoe9Li9SwUkWf7G9I3iOG0AAAAAAAAAAACgdCBgBwAASkRQcCX5BPrpzN9xqlqvmkbMGWX13POxZxVx9wum9h21Kqv3u2GaGfJNSZQKqN0vjfR4XH/FxMQoODi4WGu9OmicfYoCAAAAAAAAAAAA4HAE7AAAgFNr0L6xXpg7SheSLzq6FAAAAAAAAAAAAADAbcbF0QUAAAAUJKT/A3p14Zvy9i/v6FIAAAAAAAAAAAAAALchTrADAABOx+Dion4TBuihod1kMBjMHjufHe+gqlCa8bkCAAAAAAAAAAAAYAkBOwAA4HQCqwfp4ecfNevz8fGRX3k/DT8X7qCqUNr5lfeTj4+Po8sAAAAAAAAAAAAA4EQI2AEAgFtCQECAjsceV0pKiqNLQSnl4+OjgIAAR5cBAAAAAAAAAFYZMGCAvvrqK1M7JiZGwcHBjivoNnH9zTshISHauHGj44opptjYWNWsWdPUDgsL05dffum4ggDASRGwAwAAt4yAgAACUAAAAAAAAACAAsXExOjQoUM6deqUUlJSlJubK39/f/n7+6tBgwZq3LixXF1dHV0mAAC4hRCwAwAAAAAAAAAAAADcsg4ePKhZs2Zp2bJliouLK3Ssl5eX2rdvr/79+6tXr14qV66cVXvEx8dr586dZr8SEhLMxhiNxht+DgAAwHkRsAMAAAAAAAAAAAAA3HJOnjyp8PBwLV261Oo56enpWrt2rdauXasXX3xRY8aMUXh4uMqUKZNv7JEjRzRhwgTt3LlTMTEx9iwdAADcQgjYAQAAAE4uISFBKSkpji4DpZSPjw/XbwMAAAAASoX/ZM13dAmlxjj3px1dQpF++OEH9e/fX8nJyRYf9/f3V2BgoHx9fXXhwgWdO3dO6enpZmNSUlI0btw4LV26VLt27cq3xtGjR7Vw4cISqR8AANw6CNgBAAAATuLPI4fVoF59ubi4mPoSEhJUq05tJScmOa4wlGq+/n6KjjpOyA4AAAAAANwyvvnmG4WFhSknJ8esv2XLlho8eLC6dOmiGjVq5Jt39OhRrVixQosWLdKePXtM/fHx8TbX4O3trUuXLtlePAAAuOUQsAMAAACcxFeL5is7J0v/fX2yPD09JV39Fm1yYpKe3fC6fKsSgIJ9JcclaHanyUpJSSFgBwAAAAAAbgm7d+/WoEGDzMJ1vr6+mjFjhp566ikZDIYC59arV08RERGKiIjQsmXLNHbsWB09erTIPcuWLatmzZqpTZs2at26tVq3bi13d3fVqlXLLs8JAAA4NwJ2AAAAgBM5cvqwno0YqvffnKaKFSua+n2rBsg/ONCBlQEAAAAAAACOlZKSoj59+igzM9PUFxQUpDVr1qhZs2Y2rdWjRw917dpVw4cP17p16yyOadOmjfbu3au77rpLbm7m/2k9NjbW1vIBAMAtyqXoIQAAAABupvi08xr6+jD9efiwo0sBAAAAAAAAnEZkZKSio6NNbRcXFy1fvtzmcN01Hh4emjNnjt5//32Lj1epUkXNmzfPF64DAAC3F/4lAAAAADih9Jw0vfb+GD350JOOLgUAAAAAAABwuKSkJM2ePdus7+WXX9a///3vYq/ds2fPYq/hjC5evKgtW7YoOjpaV65cUaVKlVS3bl21a9dOLi7FP4snKSlJW7du1enTp3XhwgV5e3srKChIzZs3V926de3wDMxdvHhR27dv1+nTpxUfHy9vb2917ty5yL0yMzO1fft2xcbGKj4+Xrm5uQoMDNSdd96ptm3bytXV1a51njx5Ur///rtOnjwpo9GowMBANWvWTM2bNy/0CmNrHT16VPv27dP58+eVlpamihUrqkqVKurQoYN8fX3t8Axsl56erq1btyouLk7nz5+Xq6urgoKC1LBhQ7Vo0cIuz7ukHD16VAcOHFB8fLySk5MVEBBgej0DAgLsutfly5e1efNm/fXXX7p06ZL8/f0VHByskJAQlStXzq57AbAvAnYAAACAHZ01/KMruqIyhjJ6ZEiXYq2Vo2x9/ct8tenQ1k7VAeYy/ojSiMXP6/09U6Q99lmzjFsZTelu+VvfAAAAAAAAN2rmzJm6dOmSqe3h4aGxY8c6sCLnFRsbq4iICC1dulQ5OTn5Hq9SpYpeeeUVvfzyyzcULtu8ebMmTJigzZs3Kzs72+KYOnXqaPjw4XrhhRfk4eFh1brBwcE6ceKEJKlGjRqma3i3bdum//73v/r555+VlZVlNueDDz4oMGB36NAhTZw4UatXrzb77FzPz89P/fv315tvvqmgoCCr6izIrl27NGbMGK1fv97i49WqVdPEiRM1YMAAm9fOyMjQ9OnT9dlnn+n48eMWx7i5uSkkJESRkZHq0KGDzXvciK1bt2ry5Mlav369MjIyLI4JCgrS0KFDNXr0aJUvX/6m1FWUS5cu6b333tNXX32lmJgYi2NcXV11zz33aOLEibrnnnusWnfAgAH66quvTO2YmBgFBwcrOTlZEyZM0KxZs5SWlpZvnoeHhwYPHqyJEyeqYsWKBa4/YsQI/e9//zO158yZo8GDB1tV2/U6deqkjRs3mtq7du1Sq1atbF4HuJ1wRSwAAABgR1d0WemGS7qiy3ZZzyijKtQN0OVjyXZZD8jL3t8evZJ9xa7rAQAAAAAASNLSpUvN2j169Cg0iHKriYyMlMFgMP3q2LHjDa2zYcMGNWnSRIsXL7YYrpOk06dPa9SoUWrfvr0SEhKsXjszM1PPPPOMQkJCtH79+gLDdZIUFRWlV155RY0bN9Zff/1l8/O4ZsqUKWrfvr1WrVqVL1xXkOzsbL344otq2rSpFi9eXGC4Trp6Ct+MGTNUp04d/fjjjzdc58cff6x///vfBYbrJOnUqVMaOHCgnnvuOeXm5lq99p9//qmGDRtq9OjRBYbrpKvP+9dff9U999yjQYMGWf163Yi0tDQ98cQT6tChg1avXl1guE6Szp8/r7ffflt169bVrl27Sqwma/3www+qXbu2IiMjCwzXSVJOTo42btyoe++9V0OHDi30816Yw4cPq2nTpvrggw8shuukq3+2Pv30U7Vt29YULLUkLCzMrD1v3jyb6zlx4oQ2bdpkajds2JBwHWAFAnYAAACAE3OVm6K2HVfZuo452h+ln9FodHQJAAAAAAAAhUpLS9PevXvN+rp37+6gapzX4cOH9dhjjyk1NVXS1S9W1qxZU61atVKNGjXyjd+xY4cefvhh0/jCZGRkqGvXrpo/f36+xypXrqxWrVqpbt26cnd3N3vs77//VocOHbRv3z6bn8/MmTP12muvmX5+5eHhobp166p169aqWrWqxS+Opqenq1u3bpoxY0a+EFulSpXUrFkztWjRIt9pdampqerevbsWL15sc52fffaZRo4caQo0li1bVg0aNFDr1q1VpUqVfONnz56tDz/80Kq1d+/erXvuuUfR0dFm/e7u7rrzzjvVqlUri3t88cUXeuyxx5SZmWnz8ynK+fPnFRISYvG1+te//qWWLVuqWbNm8vf3N3vs7Nmz6tixo3777Te712StWbNmKTQ0VOfPnzfr9/LyUoMGDdSmTRvVqVMn3xXKs2bN0uOPP27zz1JjY2N1//33m05mlK6ezti6dWs1aNAg3wmSx48fV8+ePQsM812bd82WLVsKDeRZMm/ePLPnkTe0B8AyrogFAAAASsjqOT/ZND5iwlgdPHXA1PZyLacX+g7X/XPvs3dpgCTJs0kdTav7qumqguJ4aclw+xQFAAAAAACQx/bt2/MFTjhxKb/hw4fr0qVLMhgMGjFihEaNGqXq1aubHj9+/LgmT56sL774wtS3e/duRURE6NNPPy107XHjxmndunVmfaGhoZowYYKaNGli6ktISNDcuXM1fvx4Xb589ZaPixcvqnfv3tq/f7+8vb2tei4JCQkKDw+XdDXAN2nSJPXu3dvsitGYmJh8J4INGzZMa9asMbW9vb0VHh6ugQMHqmbNmmZjDxw4oEmTJun777+XdPXEssGDB6t58+aqU6eOVXVGRUVp5MiRkqQGDRpo0qRJ6tKli8qUKWMas3fvXo0YMULbtm0z9b355psKCwtThQoVClw7NTVVvXv3VmJioqnPy8tLkZGRGjx4sAICAkz9f/zxh8aPH6/ly5eb+n7++We99dZbeuedd6x6LtbIzc1V3759tWfPHlNfYGCgIiIi1L9/f1WqVMls7LZt2/TWW2+ZTvZLT09Xv379tH///kKfe0n49ddfNWzYMLPg5aOPPqpXX31V7du3l5vb/8VnEhISNGfOHE2aNMkUQF2xYoWmTJmi1157zeo9Bw8erLNnz6ps2bIaPXq0hg4dahaITExM1LvvvqspU6aYQm/79u3T7NmzNWzYMItrhoWFacyYMZKufnl6/vz5evPNN62u6fqQrIuLi/r372/1XOB2xgl2AAAAgBMKKneHZv7nM9XK80MfAAAAAAAA4HaT94pRb29vqwNQt5MTJ07IYDBo3rx5+vjjj83CdZJUu3Ztff755/lOT5s5c6Z27NhR4Lq7du3SBx98YNb31ltvadmyZWbhOkkKCAjQ6NGjtWXLFvn4+Jj6jx8/rjfeeMPq55KamqrLly+rQYMG2rt3rwYNGmQWrpOkmjVrqnHjxqb2woULza7MrF27tvbv36+JEyfmC9dJMl0hO2XKFLN9X331VavrjIuLU2Zmph5++GHt3r1bPXv2NAvXSVKLFi20bt06NW3a1NSXnp6ur7/+utC1x40bZ3Y6ma+vr3777TeNHj3aLFwnSU2aNNGyZcv0+uuvm/VPnTo13+mPxTF16lRt2LDB1L777rt16NAhjRo1yixcJ10Nb7Vv315r167ViBEjTP3//POPJk6caLearJGUlKT+/fubwnUuLi6aO3euVq5cqZCQELNwnXT1cxwREaHt27crMDDQ1P/WW2/p7NmzVu8bHR2tgIAAbdq0SRMmTMh32qC/v7/eeecdvf3222b9s2bNKnDN/v37m52wZ8s1sb///rv+/vtvU/vBBx+0eAIigPwI2AEAAABOpmHVRpo9daYq3uRv8AEAAAAAAADOKCEhwawdGBho8XpQSC+88EKRJ1KNHDlSffv2NbWNRqM++uijAsd/8MEHZldKduvWTRMmTCh0j5YtW+YLCc2ZM0fJycmFzrueu7u7Fi1alC+4ZYnRaFRkZKSp7eXlpTVr1qh27dpFzh09erR69+5taq9atUrHjh2zus7q1atr4cKF8vLyKnCMl5dXvpPkVq9eXeD4pKQkff7552Z9c+fOVfPmzQutZdKkSXrkkUdM7dzc3HzhyBuVnp5uFkasXLmyfvrpp3zX7ebl4uKiDz/8UG3btjX1ff7550pKSrJLXdb47LPPzIJxkydP1qBBg4qc17BhQ3355ZemdmZmpmbMmGHT3nPnzlXr1q0LHfPaa6/pX//6l6m9f/9+nTt3zuLYqlWr6oEHHjC1o6Ki9Pvvv1tVS94wHtfDAtYjYAcAAAA4CRcXFz3UsrPemzBVHh4eji4HAAAAAAAAcAp5A3Z+fn6OKaQERUZGymg0mn5t3LjR5jXKlClTZPDtmnfeecfsFKylS5daDDwlJSVpyZIlprbBYNB7771n1R59+vQxC1WlpaVpwYIFVs29Nv/6E+oKs2bNGrOTDkeOHGlVuO6a60/XMxqNWrZsmdVzx4wZI19f3yLHPfjgg/L39ze1CztZbsGCBUpPTze127dvr169ellVz/vvv2/WXrRokU3BxoLMmzfP7M9iZGRkvpP0CuLq6qqxY8ea2pcuXTK7yrck5eTkaPr06aZ29erVbTqlsEuXLmbBxuv/PBSlTZs2Cg0NLXKcm5ubevbsadZ3/TW8eeUNxllzil1GRoYWLlxoavv4+FhVG4Cr3IoeAgAAAOBmGDX8lQJPrUuOS7DYDxQHnysAAAAAAHArSE1NNWuXK1fOQZU4t65du1odeKpRo4ZCQkJM131mZGRo+/bt6ty5s9m4bdu2KTMz09Tu0KGD6tata3VNgwYN0vbt203tzZs3a9iwYVbN7devn9X7/PTTT2btp59+2uq50tUrVitVqmQ65WzLli167bXXipxnMBj0xBNPWLWHq6ur7rrrLm3evFmSFB8fr4yMDHl6euYbu2nTJrO2NaetXVO/fn21a9fOdKpZZmamtm/frocfftjqNSy5/jV2c3MzOwXRGvfff79cXFxM17Ru2bJFffr0KVZN1jhw4IBOnz5tavft21fu7u42rfHQQw9p3759kq5eWX3hwgVVrFixyHm2PL9mzZqZtU+dOlXg2B49esjHx0cpKSmSrl6P/NFHH1n8LF2zcuVKsxDtE088obJly1pdH3C7I2AHAAAAOAlL4TofHx/5+vtpdqfJDqgItwNffz/5+Pg4ugwAAAAAAIAClS9f3qydlpbmoEqcW8eOHW0efy1gJ0k7d+7MF7DbsWOHWfu+++6zaY/777/frH192K4obdq0sXrsli1bTL8vV66c6tevb/Xca6pVq2YK2B05csSqOcHBwapQwJemLcl7nWpycrLFK1bt8bpff21ocQN2RqNRW7duNbXr1q1r888Uy5UrpwoVKig+Pl6S9a9xcV3/2ZCkVq1a2bxG9erVzdpHjhzRPffcU+Q8W/ay9NkoSNmyZfXEE09ozpw5kq6eNLly5Uqzq47z+uqrr8zaXA8L2IaAHQAAAODEAgICFB113PRNNMDefHx8rP5mMwAAAAAAgCPk/dmFPa67LI2svU61oPExMTH5xpw4ccKs3aRJE5v2qFWrlsqXL286hfDUqVMyGo0yGAyFzvP29rbqhLBrrg9rpaWlmV1/eyPyXktcEEvhuMLkPX3x8uXL+cYYjUaz08t8fHwUHBxs0z5NmzY1a588edKm+XmdO3fO7DU5fPhwke9hUax9jYsrb5DP2hMHC1MSnw9rPhvXCwsLMwXspKvXxBYUsDt//rzZlby1a9dWhw4drK4NAAE7AAAAwOkFBAQQgAIAAAAAAMBtK+/Pxq6dgAVztpykZmn89ddHXpOYmGjWtiX0dv0+1wJ2OTk5Sk1NLfL0M1tOR0tLS1NGRobNdRXG2hBnmTJlirWP0Wi0uPe1a1Ql299XKf/7lPd9tNXFixeLNd+SmxWUdWTtxfl8WPpsXK9Dhw6qXbu2jh8/Lkn6+eefdf78eYuhvm+++UbZ2dmm9jPPPHPDdQG3q+LFtgEAAAAAAAAAAAAAKEF5r/tMTU1VVFSUg6pxXl5eXjaNz3ti1qVLl/KNyduXd86N7HMtbFcYd3d3q9e3FAwsrqLCTSXJUa95YUriNb4+RFiSbuXai3J9UC47O1sLFiywOG7evHmm3xsMBgJ2wA3gBDsAAADAySUkJHBFLEoMV8QCAAAAAABn17ZtW7m5uZmdwLR7927VqVPHgVU5n/T0dJvGp6WlmbW9vb3zjcnbl3fOjexTvnx5m9coTN5gYUBAgBYuXGjXPW4mZ3zN877GDRs21EcffVSsNcuWLVus+dbKW/s777yjli1bFmvNRo0aFWu+vTzzzDOKjIw0BULnzZunl19+2WzMwYMHtX//flP73nvvtfnKYQAE7AAAAACnkZmZKQ8PD7O+hIQE1apTW8mJSY4pCqWer7+foqOOE7IDAAAAAABOq1y5cmrRooV27txp6lu5cqX69u3rwKqcz4ULF2wan/fqTD8/v3xj/P39C51j6z6urq52D9j5+fmZBTAvX76sBx54wK573Ey+vr5ycXExnZJ2I6953s9C3vfRVnmvnDUajbfMa5y39po1a94ytRclODhY9957rzZt2iRJ2rdvnw4dOqTGjRubxnz11Vdmc8LCwm5qjUBpQcAOAAAAcBL//fBdNWvUTN27PmrqS0lJUXJikp7d8Lp8qxKAgn0lxyVodqfJSklJIWAHAAAAAACcWo8ePcwCdkuXLtXFixdVoUIFB1blXA4dOqROnTpZPf7gwYNm7Zo1a+YbU6NGDbP2gQMH1KNHD6v3iI6ONruetHr16jIYDFbPt4bBYFCNGjV0/PhxSVcDdqdPn1aVKlXsus/NYjAYVK1aNZ04cULS1Z8Rx8bG2nTq2IEDB8zaed9HW1WqVElly5bV5cuXJUknTpxQVlaWTVf5Okrez3Vpu146LCzMFLCTrgbqpk6dKknKycnRN998Y3rMy8tLjz/++E2vESgNCNgBAAAATiLtcro+W/apYk/FauTzL5o95ls1QP7BgQ6qDAAAAAAAAHCsoUOHavLkybp06ZIkKSMjQ++++66mTJni4Mqcx6ZNm/Tiiy8WPfC68ddr06ZNvjFt27Y1a69fv16RkZFW77F+/fpC17OXTp06mQJ21/bt379/iex1M7Rt29YUsJOuPp9BgwZZPd/er7u7u7vat2+vdevWSbp6HfGOHTvUoUOHYq17M+QNna5fv17jxo1zUDX29/jjj2vEiBGmK6K/+eYbvfPOO3J1ddUvv/yis2fPmsb27NnT7idIArcLF0cXAAAAAMDcz7tXa3Tka8rMzHR0KQAAAAAAAIBT8Pf31+DBg8363n//fe3YsaPYa//000/FXsMZ/Pjjj0pISLBq7IkTJ8wCdp6enhZDWG3btpWHh4ep/dtvv9l0Atjnn39u1g4JCbF6ri06d+5s1p4xY0aJ7HOz5H2dvvzyS6vnHj16VFu3bjW1PT09dffddxe7pryv8fTp04u95s3Qpk0bsyty169fr8OHDzuwIvsqX768evXqZWqfOXNGa9eulcT1sIA9EbADAAAAnNChfw7q2YjnlZSc7OhSAAAAAAAAAKcQGRlpdk1mTk6OQkND8111aq2srCyNGjVKL7zwgp0qdKwrV65o/PjxVo0dM2aMcnNzTe0ePXrIz88v3zg/Pz+zKyWNRqNGjRpl1R7ff/+9tm3bZmp7e3urX79+Vs21VWhoqOrUqWNq79ixQ59++mmJ7HUz9OvXT+XKlTO1t2zZouXLl1s199VXXzVrP/HEE/L19S12TUOGDDH7jHz//ff68ccfi71uSXN3d9fLL79sahuNRg0dOlRZWVmOK8rO8gbn5s2bp+TkZK1YscLU969//Uv33XffzS4NKDUI2AEAAAAl5JEhXWz6dfDUAbP55y+d1dufvK3AO4Ic9AwAAAAAAAAA5+Hn56eFCxfK3d3d1Hf27FmFhITo22+/ldFotHqtTZs2qVWrVnrvvfdsmldSIiMjZTAYTL86dux4Q+v873//0zfffFPomI8//ljfffedqW0wGDRy5MgCx4eHh8vF5f+iBStWrNCkSZMK3WP//v0aMmSIWd+QIUPk4+NT6Lwb5erqqrffftusb+TIkZo9e7ZN6xw7dkzPPfec4uLi7Fmezfz8/PJdCTto0CD98ccfhc4bP368WejNxcVF4eHhdqnJ19dXr732mqmdm5urfv36aeXKlTats2fPHvXp08cuNVlr5MiRuuOOO0zt3377TY8//riSbfiCe1pamj7++GPNnTu3JEoslk6dOqlatWqm9vLlyzVnzhxduXLF1Pf000+b/TkGYBs3RxcAAAAAlCaZyjD73+JKz0lX665tdCUqWQoOtMuawDUZf0RpxOLn9f6eKdIeR1cDAAAAAABQtDZt2mj27NkaNGiQ6QS2xMREPfnkk/rggw80ePBgPfLII6pevXq+uX///bdWrVqV72S1wuzZs0eJiYn5+s+dO5evb926dRbX8Pf3V8uWLa3arzhq1KihEydO6Omnn9aOHTs0evRos9BNdHS0Jk+enO/a1meffdbi9bDXtGrVSuHh4XrvvfdMfW+++ab279+vyMhINW7c2NSfmJiouXPnavz48UpPTzf1165du8hQXnH17dtXGzdu1MyZMyVdPaHwueee03fffafw8HB16tTJ7FS4a2MOHz6sDRs2aMmSJdq6dauMRqPGjRtXorVaY/LkyVq1apViY2MlXX1t27VrpwkTJmjQoEFm154eOnRI48eP19KlS83WGD16tJo3b263miIiIrRlyxbTtcqpqakKDQ1VaGioRowYofbt28vT09NszpUrV/THH39o3bp1WrJkifbu3StJWrhwod3qKoqvr68WL16s+++/33Ry3cqVK9WoUSOFh4erd+/eFv/OOHXqlHbs2KHly5dr1apVSklJsfqUyJvJxcVFTz/9tP7zn/9Iki5fvqw33njDbAzXwwLFQ8AOAAAAsKNc5Zr9rz1kXMiQR3B5u60HXM9gMDi6BAAAAAAAAJuEhYXJ19dXYWFhSklJMfXv2rVLu3btkiQFBAQoMDBQvr6+unjxos6cOWMW+Lpe5cqVC9zr1Vdf1aZNm6yq68EHH7TYHxISoo0bN1q1RnF88skn6tu3r1JTUzV9+nTNmDFDNWvWVIUKFRQfH28Kal2vefPmmjp1apFrT548WQcOHDALES5ZskRLlixRlSpVVKVKFaWmpio6Ojrf1ZsVKlTQokWL8oXbSsL06dOVmJioRYsWmfrWr1+v9evXy83NTTVq1FBAQICys7OVlJSkuLg4ZWZmlnhdN6J8+fJavHixHnroIVPIMy0tTaNGjdLYsWNVs2ZN+fj46MyZMxZP3OvcubMmTpxo15pcXFy0YMEChYaGmj7TRqNRy5Yt07Jly+Tp6akaNWrI399fV65cUVJSkv755x/l5OTYtY4bcc8992jevHkaOHCg6WS3uLg4jRo1SqNGjVLlypUVFBQkT09PJScn6/z58xbDtc4qLCzMFLCTZHZ63d1336169eo5oiyg1CBgBwAAAJSQVZ/ZdjT+uMlv6OAp8yP+77vrfkW8PErNp3W2Z2mAidFoJGQHAAAAAABuOaGhoTpw4IBefvllrVixIt/jCQkJSkhIKHSNChUq6I033tALL7xQUmXeVA0bNtSKFSsUGhqqlJQUGY1GRUdHKzo62uL41q1ba/Xq1VZd2+rp6akff/xRgwcP1tdff2322OnTp3X69GmL8+68806tXLlS9evXt/0J3QB3d3ctXLhQLVu2VGRkpC5fvmx6LDs7W8ePH9fx48cLXaNixYoqW7ZsSZdqlVatWmnz5s3q3r272fuYlZWlY8eOFThvwIABmjVrltl1yvbi6+urtWvX6rXXXtPHH3+s7Oxs02MZGRmF1nXN9Scr3kx9+/bVnXfeqSeffDJfnWfOnNGZM2cKne/q6qoqVaqUZIk3rG7dumrbtq22b9+e7zFOrwOKj4AdAAAAUELc3Gz95/b/hZxc5aYXnhiuBnXrK+LlUfYtDPj/PJvU0bS6ryomJkbBwcHFWuulJcPtUxQAAAAAAICVgoODtXz5cu3fv1+zZ8/W0qVLdfbs2ULnlCtXTvfee6/CwsIUGhqa7zrLW12nTp104MABjR49WsuWLbN4cljlypUVHh6uV155Ra6urlav7eHhofnz52vIkCGaOHGiNm/ebBauul7t2rU1fPhwjRgxQh4eHjf8fG5URESEwsLCNG3aNC1atEgnT54sdHylSpX0wAMPqGfPnurWrVuJBNNuVOPGjXX48GFNnz5dn376aYGBSTc3N4WEhCgyMlIdOnQo0Zrc3Nz03nvv6YUXXtC7776r5cuX6/z584XOCQ4O1kMPPaTHH39c999/f4nWV5iWLVvq8OHDWrBggT755BPt2rWr0BP2PD091b59e3Xp0kVPPvlkoSdeOlpYWFi+gJ2Hh4f69u3roIqA0sNgNBqNji4Czu3PP/9U48aNTe1Dhw6pUaNGDqwIAHCr+G+Pt3T09z9Vr10jjV1m32PIAWfVdXA35Rpy5WJ00Y9zf7BpbsSEsTp46oDKunppwkuRuqtRY8XGxqpmzZoadew9+QcHllDVuF0lxsaXSMDu416fFLMyAAAAAMDtIDs7W3///bdZ35133nkDX1oE/s/x48d16NAhnTp1SqmpqTIajfLz81NAQIAaNmyoRo0a2RQqu5VduHBBW7ZsUXR0tDIyMhQUFKR69eqpffv2cnFxKfb6SUlJ+u2333T69GldvHhR5cqV0x133KFmzZo53XWUUVFR2r9/v+Lj45WYmCg3Nzf5+vqqevXqatCgQbF/NnYz/fXXX9q3b5/Onz+v9PR0VahQQVWrVlWHDh3k6+vrkJqMRqP+/PNP/fnnn7pw4YKSkpLk6ekpX19f1axZUw0bNnTak9+Sk5O1fft2nT59WhcuXFBWVpbKly+voKAg1a9fX/Xq1VOZMmUcXSZQbCX1767bJVPEv04BAAAAJ1LRK1DvvTlNQYGE6QAAAAAAAABb1a5dW7Vr13Z0GU6hYsWK6tGjR4mt7+fnp27dupXY+vZUp04d1alTx9Fl2EX9+vVv2pW71jIYDGrcuLFZyOZW4evrq4cfftjRZQBwcgTsAAAAACfx0L0P6p527S1eS5Ecl+CAilDa8bkCAAAAAAAAAAAoHAE7AAAAwEk80Om+fH0+Pj7y9ffT7E6THVARbge+/n7y8fFxdBkAAAAAAAAAAABOiYAdAAAA4MQCAgIUHXVcKSkpji4FpZSPj48CAgIcXQYAAAAAAAAAAIBTImAHAAAAOLmAgAACUAAAAAAAAAAAAIAD3PYBu0uXLunPP//UX3/9pYsXL+rKlSvy8/NTUFCQWrVqpeDgYLvv+eeff2rPnj06c+aMcnJyVKFCBTVu3Fh333233Nxu+7cEAAAAAAAAAAAAAADcBhITE7Vnzx67r9uoUSNVrlzZ7usCuD05bZorLi5OO3fu1I4dO7Rz507t3r1bqamppsdr1Kih2NjYG1p7x44dWr58uX799Vft2bNHubm5BY6tUaOGnn/+eQ0dOlT+/v43tJ8kGY1GffHFF3r33Xd17Ngxi2MqVKigYcOGacyYMSpXrtwN7wUAAAAAAAAAAAAAAODsDhw4oAcffNDu637xxRcaMGCA3dcFcHtyqoDd1q1b9d5772nHjh06ffq03dffv3+/evXqpejoaKvnnDhxQmPHjtVHH32kL774Qp07d7Z536SkJD3xxBNau3ZtoeMuXryoSZMmacGCBVq5cqUaNWpk814AAAAofRISEpSSkuLoMlBK+fj4cAUxAAAAAAAAAABAAZwqYLdr1y4tW7asxNb/559/CgzX+fr6qlKlSvL19dWFCxcUExMjo9Foevzs2bPq2rWrvvnmG/Xt29fqPS9fvqyHH35YO3fuNOv38PBQcHCwPD09FR0drbS0NNNj0dHR6tSpk37//XfVqVPHxmcJAACAW9U3i77VAyH36Y477jD1JSQkqFad2kpOTHJcYSjVfP39FB11nJAdAAAAAAAAAACABU4VsCuMt7e3Ll26ZNc127Ztq/79+6tTp05q2LCh2WPx8fGaPXu2Jk+erPT0dElSbm6unnnmGdWrV0/Nmze3ao9XXnnFLFzn4uKi119/XeHh4aYrZzMzM7VgwQK98sorSkxMNO3/xBNPaNeuXXJ1dbXH0wUAAICTO3DkDy35dYkiXxyvJo3vkiSlpKQoOTFJz254Xb5VCUDBvpLjEjS702SlpKQQsAMAAAAAAABw03Xs2NHs8CMAcEZOGbArX768WrZsqdatW6tNmzZq3bq1YmJi1KlTp2Kv7eLioieffFJjxowp9ArWwMBAjRs3Tt26dVOnTp2UkJAgScrKytLLL7+sTZs2FbnXX3/9pdmzZ5v1ff311+rXr59Zn4eHhwYMGKDWrVurQ4cOSkpKkiTt27dP8+bN08CBA218lgAAALhVXc5J17gPx+n5x4epW+cupn7fqgHyDw50YGUAAAAAAAAAAADA7cfF0QVc79FHH9Wff/6ppKQkbdiwQVOmTNHjjz+uGjVq2GX9unXr6o8//tD8+fMLDdddr0mTJvriiy/M+jZv3qyoqKgi544fP145OTmm9tNPP50vXHe9Ro0aadq0aWZ9EyZMUFZWllW1AgAAoHTIUY7+9/0M/W/2J44uBQAAAAAAAAAAALitOdUJdrVr1y7R9evWrXtD8x577DE1bNhQhw8fNvX9/PPPGjFiRIFzEhMTtXTpUlPbYDAoMjKyyL0GDhyot99+WydOnJAknThxQuvWrdMjjzxyQ7UDAADAceZ/941N40+cizVr/7DjB/0de1wGF4MdqwIAAAAAAAAAAABgLacK2Dmze+65xyxgd/LkyULH//jjj8rOzja1O3bsqFq1ahW5j4uLiwYOHGgWxlu+fDkBOwAAgFtErnJN/7tgnW0BO0uOnjuiR/p0VXZKZrHXAvLK+CNKIxY/r/f3TJH2OLoaAAAAAAAAAAAA5+NUV8Q6M39/f7N2cnJyoeN//PFHs/ZDDz1k9V4PPvigWfuHH36wei4AAABKH4OHQTkpWY4uA6WUwcAJiQAAAAAAAAAAAAXhBDsrxcXFmbUrVKhQ6Pj9+/ebtdu1a2f1Xi1btpSnp6cyMjIkSadPn1Z8fLwCAwOtXgMAAACOV82vuk3jTyXlPyU50CtI389dpAavd7RTVYA5o9FIyA4AAAAAAAAAAKAABOysYDQa9dtvv5n11a1bt8DxWVlZioqKMutr2LCh1ft5enqqdu3aZlfSHjlyhIAdAADALWbWtM9sGh8xYawOnjpgat9Vramee2qw5k//yt6lAZIkzyZ1NK3uq4qJiVFwcHCx1nppyXD7FAUAAAAAAAAAAOBEuCLWChs3blRMTIypbTAY1Llz5wLHR0dHKzs729QuW7asKlasaNOe1apVM2sfPXrUpvkAAAC4tXVt001Txv9Xbm58JwYAAAAAAAAAAABwFP5rXRFyc3M1duxYs77OnTurUqVKBc45f/68Wbtq1ao275t3Tt41b9T58+cVHx9v05y8p/EBAACg5LjKVUN7Pa9HH+nq6FIAAAAAAAAAAACA2x4BuyJMmzZNO3bsMLVdXFw0efLkQudcunTJrF2uXDmb9807J++aN+qTTz7RhAkT7LIWAAAA7KvqHVX0VM9+anpXk3yPJcclOKAilHZ8rgAAAAAAAAAAAApHwK4QW7Zs0euvv27W9/LLL6t58+aFzssbhitTpozNe5ctW7bQNQEAAFD6jHz+xXx9Pj4+8vX30+xOhX/JA7hRvv5+8vHxcXQZAAAAAAAAAAAATomAXQGio6PVs2dPZWdnm/qaNWum//znP0XOvXLlilnbw8PD5v09PT3N2pcvX7Z5DQAAANz6AgICFB11XCkpKY4uBaWUj4+PAgICHF0GAAAAAAAAAACAUyJgZ8GFCxf0yCOP6MKFC6a+O+64Q0uXLs0XfLMk74l1mZmZNteQkZFR6Jo3avjw4erdu7dNc6KiohQaGmqX/QEAAGC7gIAAAlAAAAAAAAAAAACAAxCwyyM1NVWPPPKIjh07Zurz9fXVmjVrVLNmTavW8Pb2NmvnPdHOGnlPrMu75o0KCgpSUFCQXdYCAAAAAAAAAAAAAAAAgNLMxdEFOJMrV67oscce0+7du019Xl5e+vHHH9W0aVOr18kbhktLS7O5lrxz7BWwAwAAAAAAAAAAAAAAAABYhxPs/r+srCw98cQT2rhxo6nPw8NDS5cuVfv27W1aK+8JcXFxcTbXk3cOp84BAADcvhISEpSSkuLoMlBK+fj4cAUxAAAAAAAAAABAAQjYScrNzdUzzzyjVatWmfpcXV21YMECPfzwwzavV6tWLbm5uSk7O1vS1ete4+PjFRgYaPUaJ0+eNGvXr1/f5joAAABwa/nzyGE1qFdfLi7/d9B0QkKCatWpreTEJMcVhlLN199P0VHHCdkBAAAAAAAAAABYcNsH7IxGo5577jl99913pj6DwaA5c+aoV69eN7Smu7u7ateuraNHj5r6Dh8+rJCQEKvmZ2RkKDo62qyPgB0AAEDp99Wi+crOydJ/X58sT09PSVJKSoqSE5P07IbX5VuVABTsKzkuQbM7TVZKSgoBOwAAAAAAAAAAAAtu+4BdeHi45s6da9b38ccfa8CAAcVat1mzZmYBu99//93qgN2ePXuUkZFhaleuXJkrYgEAAG4TR04f1rMRQ/X+m9NUsWJFU79v1QD5B1t/IjIAAAAAAAAAAACA4nMpekjp9eabb+qjjz4y6/vPf/6jESNGFHvtbt26mbXXrl1r9dy8Yx999NFi1wMAAIBbR3zaeQ19fZj+PHzY0aUAAAAAAAAAAAAAt7XbNmA3depUTZo0yaxv7NixGjt2rF3W79Kli9zc/u+AwI0bN+a79tUSo9GoL7/80qyve/fudqkJAAAAt470nDS99v4Y/b5zu6NLAQAAAAAAAOCEBgwYIIPBYPoVGxvr6JJuC9e/5h07dnR0OcUSGxtr9nyKe9MfAJRWt+UVsTNnzlRERIRZ34gRI/Sf//zHbnsEBAQoNDRU33//vaSrwbnIyEjNmzev0Hmff/652T98atSooQceeMBudQEAAODmeWRIl2LNz1G2vv5lvtp0aGunigBzGX9EacTi5/X+ninSHkdXAwAAAAAAUHwxMTE6dOiQTp06pZSUFOXm5srf31/+/v5q0KCBGjduLFdXV0eXCQAAbiG3XcBuwYIFGj58uFnfwIED9fHHH9t9rwkTJmjp0qXKzc2VJM2fP1+PPPKI+vXrZ3H84cOHNWrUKLO+N998Ux4eHnavDQAAALcGo4yqUDdAl48lyz840NHloBQyGAyOLgEAAAAAAKBYDh48qFmzZmnZsmWKi4srdKyXl5fat2+v/v37q1evXipXrpxVe8THx2vnzp1mvxISEszGGI3GG34OAADAeTldwG7r1q26fPlyvv4DBw6Yta9cuaJ169ZZXKNKlSpq2LBhvv5169YpLCzMFHiTpPr166tPnz769ddfbarT399fLVu2LHRMw4YNNWTIEM2aNcvU179/fx05ckTh4eHy9/eXJGVlZembb77RK6+8oqSkJNPYJk2aKCwszKa6AAAAULq4yk3Hth1TozH3O7oUlFJGo5GQHQAAAAAAuCWdPHlS4eHhWrp0qdVz0tPTtXbtWq1du1YvvviixowZo/DwcJUpUybf2CNHjmjChAnauXOnYmJi7Fk6AAC4hThdwO6pp57SiRMnihx37tw5PfjggxYfCwsL05dffpmv/7ffflN2drZZ319//aXOnTvbXGdISIg2btxY5LgPPvhAe/fu1e7duyVJubm5evvtt/Xuu++qZs2a8vT0VHR0tC5dumQ2r2LFilq8eLHc3JzuLQIAAICVVs/5yabxERPG6uCp//tiiZdrOb3Qd7jun3ufvUsDJEmeTepoWt1XFRMTo+Dg4GKt9dKS4UUPAgAAAACgBP10aaqjSyg1uniPdnQJRfrhhx/Uv39/JScnW3zc399fgYGB8vX11YULF3Tu3Dmlp6ebjUlJSdG4ceO0dOlS7dq1K98aR48e1cKFC0ukfgAAcOsgvVXCvLy8tGbNGvXu3Vvr16839WdmZuro0aMW5wQHB2vlypWqW7fuzSoTAAAATiao3B16761pupSa6uhSAAAAAAAAAKfyzTffKCwsTDk5OWb9LVu21ODBg9WlSxfVqFEj37yjR49qxYoVWrRokfbs2WPqj4+Pt7kGb2/vfIeoAACA0snF0QXcDgICArR27VrNmjVLderUKXTcuHHjdPDgQd111103sUIAAAA4k4ZVG2n21JmqWKGCo0sBAAAAAAAAnMru3bs1aNAgs3Cdr6+v5s+fr127dmnYsGEWw3WSVK9ePUVERGj37t1aunSp6tWrZ9WeZcuW1b///W+NHDlSX3/9tY4ePao//vjDLs8HAAA4P6c7wS42NrbE1o6MjFRkZGSJrV8YFxcXPfvss3r22Wd18OBB7d27V2fOnFFOTo4qVKigxo0b6+6775a7u7tD6gMAAIDjubi46KGWnRU+7CVHlwIAAAAAAAA4nZSUFPXp00eZmZmmvqCgIK1Zs0bNmjWzaa0ePXqoa9euGj58uNatW2dxTJs2bbR3717dddddcnMz/0/rJfnftQEAgHNxuoDd7eCuu+7ihDoAAADkM2r4KwWeWpccl3CTq8HtgM8VAAAAAAC4lURGRio6OtrUdnFx0fLly20O113j4eGhOXPmaOnSpRYfr1KliqpUqXJDawMAgNKDgB0AAADgJCyF63x8fOTr76fZnSY7oCLcDnz9/eTj4+PoMgAAAAAAAAqVlJSk2bNnm/W9/PLL+ve//13stXv27FnsNZzRxYsXtWXLFkVHR+vKlSuqVKmS6tatq3bt2snFxaXY6yclJWnr1q06ffq0Lly4IG9vbwUFBal58+aqW7euHZ6BuYsXL2r79u06ffq04uPj5e3trc6dOxe5V2ZmprZv367Y2FjFx8crNzdXgYGBuvPOO9W2bVu5urratc6TJ0/q999/18mTJ2U0GhUYGKhmzZqpefPmMhgMxV7/6NGj2rdvn86fP6+0tDRVrFhRVapUUYcOHeTr62uHZ2C79PR0bd26VXFxcTp//rxcXV0VFBSkhg0bqkWLFnZ53vaWnZ2trVu3KioqSufOnVOZMmVUu3Zt3XPPPQoICCixfW/0c+yM77s9REVFaceOHYqLi5MkVa1aVS1atFCDBg2Kte7Zs2e1d+9excbGKiUlRbm5ufLy8lJQUJBq1aqlxo0by9vb2x5PAbcJAnYAAACAEwsICFB01HGlpKQ4uhSUUj4+PiX6AyMAAAAAAAB7mDlzpi5dumRqe3h4aOzYsQ6syHnFxsYqIiJCS5cuVU5OTr7Hq1SpoldeeUUvv/zyDYXLNm/erAkTJmjz5s3Kzs62OKZOnToaPny4XnjhBXl4eFi1bnBwsE6cOCFJqlGjhuka3m3btum///2vfv75Z2VlZZnN+eCDDwoMJh06dEgTJ07U6tWrzT471/Pz81P//v315ptvKigoyKo6C7Jr1y6NGTNG69evt/h4tWrVNHHiRA0YMMDmtTMyMjR9+nR99tlnOn78uMUxbm5uCgkJUWRkpDp06GDzHjdi69atmjx5stavX6+MjAyLY4KCgjR06FCNHj1a5cuXvyl1FSYjI0P/+c9/9Mknn+jChQv5Hnd1ddXjjz+uKVOmqHr16oqNjVXNmjVNj4eFhenLL78scH17fo5L6n2PjIzUhAkTTO0NGzaoY8eOVs211+uxceNGjR07Vtu3b7c4r2nTppo8ebK6du1qVV3XLF68WB988IG2bdtW6DhXV1c1adJEoaGhGjFiBD8jR5EI2AEAAABOLiAggP9zBwAAAAAAgNta3mtce/TooYoVKzqoGvvLG3gJCQnRxo0bbV5nw4YN6t69u1JTUwscc/r0aY0aNUqLFy/WTz/9ZPXPHjMzMzVkyBDNnz+/yLFRUVF65ZVX9Omnn2rlypWqX7++1c/helOmTNGYMWNkNBqtnpOdna3w8HB98sknys3NLXRsUlKSZsyYoa+++krffvutzWGeaz7++GO98sorFgON15w6dUoDBw7U77//rs8++8zqUwT//PNPPfbYY2bXI1uSnZ2tX3/9Vb/++qsGDhyomTNnyt3d3abnYa20tDQNHDhQixcvLnLs+fPn9fbbb2v27NlauXKlWrduXSI1WePkyZN6+OGH9ddffxU4JicnRwsXLtTPP/+sFStWqEaNGsXe90Y+x874vtvL1KlT9dprrxX6ehw4cEDdunXT0KFD9emnnxZ5CmJGRob69eunZcuWWVVDTk6O9u3bp3379qldu3Z64IEHbHoOuP0U/9xXAAAAAAAAAAAAAABKSFpamvbu3WvW1717dwdV47wOHz6sxx57zBSuMxgMqlmzplq1amUxJLRjxw49/PDDhYbxrsnIyFDXrl0thusqV66sVq1aqW7duvmCPX///bc6dOigffv22fx8Zs6caRbC8fDwUN26ddW6dWtVrVrVYuAmPT1d3bp104wZM/KF6ypVqqRmzZqpRYsW+U6rS01NVffu3a0KjOX12WefaeTIkaZwXdmyZdWgQQO1bt1aVapUyTd+9uzZ+vDDD61ae/fu3brnnnvyhazc3d115513qlWrVhb3+OKLL/TYY48pMzPT5udTlPPnzyskJMTia/Wvf/1LLVu2VLNmzeTv72/22NmzZ9WxY0f99ttvdq/JGmfPnlWnTp3yhesMBoNq1aql1q1bq1atWqbPVXJysh599NFCw3jWuJHPsTO+7/Yyf/58RUREmF4PT09P1atXTy1atFBgYGC+8TNnztTzzz9f5LpDhgyxGK67dm1127Zt1ahRI4t7ANbgBDsAAADAySUkJHBFLEoMV8QCAAAAAABnt3379nxXkbZq1cpB1Tiv4cOH69KlSzIYDBoxYoRGjRql6tWrmx4/fvy4Jk+erC+++MLUt3v3bkVEROjTTz8tdO1x48Zp3bp1Zn2hoaGaMGGCmjRpYupLSEjQ3LlzNX78eF2+fFmSdPHiRfXu3Vv79++Xt7e3Vc8lISFB4eHhkq4G+CZNmqTevXubXTEaExOjtLQ0s3nDhg3TmjVrTG1vb2+Fh4dr4MCBZtdaSldPyJo0aZK+//57SVdPtBo8eLCaN2+uOnXqWFVnVFSURo4cKUlq0KCBJk2apC5duqhMmTKmMXv37tWIESPMrqx88803FRYWpgoVKhS4dmpqqnr37q3ExERTn5eXlyIjIzV48GCzn+n98ccfGj9+vJYvX27q+/nnn/XWW2/pnXfeseq5WCM3N1d9+/bVnj17TH2BgYGKiIhQ//79ValSJbOx27Zt01tvvWW6Njc9PV39+vXT/v37C33uJWHo0KFmgTU3NzeNGjVKL774ollYLS4uTh9//LHef/99paamavjw4Te85418jp3xfbeX5ORkvfjii5Kk8uXLa9KkSRowYIB8fHxMY37//XeNGjXK7M/LrFmzdN9996lPnz4W1921a5e+/vprU9vNzU2jR4/W0KFDLYaLz507py1btmjVqlU3FKrF7YmAHQAAAOAkMjMz5eHhYdaXkJCgWnVqKzkxyTFFodTz9fdTdNRxQnYAAAAAAMBp5T1Bytvb2+oA1O3kxIkTMhgMmjdvnvr375/v8dq1a+vzzz9X06ZN9fLLL5v6Z86cqQEDBujuu++2uO6uXbv0wQcfmPW99dZbZlfaXhMQEKDRo0frvvvu03333Wf64vDx48f1xhtvWH1y27VT9Ro0aKD169ebBbeuyRuYW7hwoebNm2f2fNesWaPatWtb3KNp06ZavHixpk6dqoiICNO+r776qlasWGFVnXFxcZKkhx9+WEuXLpWXl1e+MS1atNC6devUrl07HThwQNLVoNnXX39tCudZMm7cOMXGxpravr6+2rBhg5o3b55vbJMmTbRs2TK98cYbmjx5sql/6tSpeuKJJ9SiRQurnk9Rpk6dqg0bNpjad999t1auXJnvREBJcnFxUfv27bV27VqNHDlSM2bMkCT9888/mjhxoj766CO71GSNVatWaeXKlaa2u7u7li1bZvFK4KpVq+rdd99Vhw4d1LNnT8XExNzwvjfyOXbG991ekpKSJEn+/v7avHmzGjdunG9Mu3bttGXLFvXp00dLliwx9Y8cOVJdu3a1GNLNG5KbNWuWBg4cWGAdd9xxhx5//HE9/vjjev/994u8ShqQCNgBAAAATuO/H76rZo2aqXvXR019KSkpSk5M0rMbXpdvVQJQsK/kuATN7jRZKSkpBOwAAAAAAIDTSkhIMGsHBgZavFYR0gsvvGAxXHe9kSNHavv27fruu+8kSUajUR999JEWLFhgcfwHH3xgus5Rkrp162YxXHe9li1batasWerbt6+pb86cOZowYYJ8fX2tei7u7u5atGiRxVBSXkajUZGRkaa2l5dXoeG6640ePVq7du0yhXRWrVqlY8eOqW7dulbVWb16dS1cuNBiuO76et555x098sgjpr7Vq1cXGLBLSkrS559/btY3d+5ciyGr602aNEl79+7V6tWrJV09Re6DDz6weLWvrdLT0zVlyhRTu3Llyvrpp5+K/Lmii4uLPvzwQ+3evVvbt2+XJH3++eeaMGGC/Pz8il2XNT7++GOz9uuvv24xXHe9Rx99VGPGjNGkSZOKtbctn2NnfN9LwuzZsy2G665xdXXV119/rT179pjChufOndOCBQv03HPP5Rt/7Ngx0++9vb31zDPPWF3LzT5JEbcuAnYAAACAk0i7nK7Pln2q2FOxGvn8i2aP+VYNkH9woIMqAwAAAAAAABwnb8DuZoVybqbIyEizgNiNKFOmTJHBt2veeecdLVq0yHRy09KlS5WUlJTvtU1KSjI7RcpgMOi9996zao8+ffroww8/NIWq0tLStGDBAg0bNszq+YWFcK63Zs0as5MOR44caVW47po33njDFLAzGo1atmyZXnvtNavmjhkzxqrQ4IMPPih/f3/T1Z979+4tcOyCBQuUnp5uardv3169evWyqp7333/fFLSSpEWLFmnGjBlWBxsLMm/ePLM/i5GRkVZ/adfV1VVjx45V9+7dJUmXLl3SmjVrCrzy057i4uL066+/mtp+fn5Wv7djx47V9OnTlZycfMP72/I5dsb33d5at25t1XMqU6aMJk6caBaW+/zzzy0G7K5dRy1dDXS6uLjYp1jgOnyqAAAAACfz8+7VGh35mjIzMx1dCgAAAAAAAOBw165ZvKZcuXIOqsS5de3a1erAU40aNRQSEmJqZ2RkmIJw19u2bZvZzyk7dOhg9clukjRo0CCz9ubNm62e269fP6vH/vTTT2btp59+2uq50tWrNq8/YWzLli1WzTMYDHriiSesGuvq6qq77rrL1I6Pj1dGRobFsZs2bTJr530dC1O/fn21a9fO1M7MzLT43trq+tfYzc3N7HRCa9x///1mwSdrX+Pi+v33381OYOzVq5fKlClj1VwvLy/17NmzWPvb8jl2xvfd3mw5Xa5Xr15mV8Lu3r1baWlp+cZVqVLF9PuUlBStWrWqeEUCFhCwAwAAAJzQoX8O6tmI55VUjG/GAQAAAAAAAKVB+fLlzdqWAhaQOnbsWKzxO3fuzDdmx44dZu377rvPpj3uv/9+s7YtgZ82bdpYPfb6sFa5cuVUv359q+deU61aNdPvjxw5YtWc4OBgm66YDAoKMmsXdDKaI193S4xGo7Zu3Wpq161bVz4+PjatUa5cObPXytrXuLh2795t1r4+hGYNW8fnZcvn2Nne95Jgy99TXl5eat26tamdk5OjPXv25Bv34IMPmrWfeuopvffee0pKSrrRMoF8uCIWAAAAKCGPDOlSrPnnL53V25+8rcA7gooeDAAAAAAAAJRSeU9lK851jaWZtddQFjQ+JiYm35gTJ06YtZs0aWLTHrVq1VL58uVNpxCeOnVKRqNRBoOh0Hne3t6qWLGi1ftcH9ZKS0sr9hWRea8lLkjewFxR8p6+eP3VltcYjUadOnXK1Pbx8VFwcLBN+zRt2tSsffLkSZvm53Xu3Dmz1+Tw4cNFvodFsfY1Lq64uDizdoMGDWyab+v469nyOXbG993eXF1dbQ6/Nm7cWBs2bDC1Y2JidO+995qN6d27tyZPnqzDhw9LunoF8ahRozRu3DiFhITovvvuU4cOHdSqVSurTy8E8iJgBwAAADix9Jx0te7aRleikqXgQEeXg1Im448ojVj8vN7fM0XK/8U/AAAAAAAAp5A3YBcfH++gSpybLSepWRpv6bSnxMREs7Ytobfr97kWsMvJyVFqamqRp5/ZcjpaWlpagVet3ihrQ5zFDetcf3Xp9Xvn5uaa2ra+r1L+9ynv+2irixcvFmu+JTcrKJv3c+3r62vTfD8/vxve25bPsTO+7/bm6+srNzfbYkrW/D3l7u6uVatWqUuXLjp69KipPzMzU2vXrtXatWslSZ6envr3v/+t7t27q1+/frrjjjtsfxK4bXFFLAAAAODkMi5kyCO4fNEDgRtQ3G+aAgAAAAAAlLS8Jx6lpqYqKirKQdU4Ly8vL5vG5z1N7dKlS/nG5O3LO+dG9rkWtiuMu7u71euXxDWQloJvN4ujXvPClMRrfH2YrCTlDV96eHjYNN/T0/OG97blc+yM77u92fp3lGTd31PS1dMy9+7dq8mTJ6tq1aoWx2RkZGjjxo0KDw9X9erV9dJLLzndawTnxQl2AAAAQAlZ9dlKm8aPm/yGDp76w6zvvrvuV8TLo9R8Wmd7lgaYWHMlBwAAAAAAgCO1bdtWbm5uys7ONvXt3r1bderUcWBVzic9Pd2m8WlpaWZtb2/vfGPy9uWdcyP7lC9v3y8T5w3tBAQEaOHChXbd42Zyxtc872vcsGFDffTRR8Vas2zZssWab628J9YVFNAqSEpKij3LKZAzvu/2ZuvfUZJ1f09d4+XlpXHjxmnMmDHaunWr1q9fr40bN2rHjh35rmPOzMzU9OnT9csvv2jz5s02X/eM2w8BOwAAAKCE2HrUufR/ISdXuemFJ4arQd36inh5lH0LA/4/zyZ1NK3uq4qJiVFwcHCx1nppyXD7FAUAAAAAAJBHuXLl1KJFC+3cudPUt3LlSvXt29eBVTmfCxcu2DQ+77Wflq7C9Pf3L3SOrfu4urraPfTj5+dnFsC8fPmyHnjgAbvucTP5+vrKxcXFdMLbjbzmeT8Led9HW+W9etRoNN4yr3HeK6ZPnz6tZs2aWT3/9OnTdq7Ispv5vhfnC9c3EpK7Jjk5WVlZWTad7GfN31N5ubi46J577tE999yj8ePHKysrS7t379bPP/+sBQsWmJ2AevToUQ0YMEA//fST1TXh9sQVsQAAAICTKevqpf+G/0ePPMSpdQAAAAAAAIAk9ejRw6y9dOnSGwqglGaHDh2yafzBgwfN2jVr1sw3pkaNGmbtAwcO2LRHdHS02RWM1atXt/ttCgaDwazOy5cv37RQVEkwGAyqVq2aqZ2SkqLY2Fib1sj7PuV9H21VqVIlsxPnTpw4oaysrGKtebM0bNjQrL1v3z6b5u/fv9+O1RTsZr7vZcqUMWvnPd2tMPHx8TbVdL2cnBz99ddfNs2x5u+pori7u+vf//63JkyYoGPHjul///ufXFz+Ly61evVqHTlyxOZ1cXshYAcAAAA4kYpegfps0qe6q1FjR5cCAAAAAAAAOI2hQ4eaXQ2YkZGhd99914EVOZ9NmzYVa3ybNm3yjWnbtq1Ze/369TbtkXd83vXspVOnToXue6txttfd3d1d7du3N7XT09O1Y8eOYq15s+T9XP/www82zV+5cqU9yynUzXrffXx8zNrnzp2zeo9du3bZVFNetvw9lZ6ert27d5varq6uatmyZbH2NxgMGj58uJ588kmz/t9++61Y66L044pYAAAAwEk8dO+Duqdde3l6euZ7LDkuwQEVobTjcwUAAAAAAG4V/v7+Gjx4sD766CNT3/vvv69evXrp7rvvLtbaP/30k7p06VLcEh3uxx9/VEJCQr4rMS05ceKEWdDF09PTYhinbdu28vDwUGZmpqSrIZSoqCjVqVPHqpo+//xzs3ZISIhV82zVuXNnzZkzx9SeMWOG+vfvXyJ73QwhISFauHChqf3ll19q0KBBVs09evSotm7damp7enoW+8+IdPU1Xrdunak9ffp0dejQodjrlrTWrVvrjjvuMIXItm/frj179lgV1Nq5c2exA2W2uFnve96T7fbt26cBAwZYtc/19d2IefPmacSIEVaNXbJkiS5dumRqt2zZUuXKlSvW/te0b99eX3/9talt6xXbuP0QsAMAAACcxAOd7svX5+PjI19/P83uNNkBFeF24Ovvl+8biwAAAAAAAM4oMjJSK1asMF2bmJOTo9DQUP3yyy+66667bF4vKytLY8eO1ZIlSxQTE2Pnam++K1euaPz48Zo+fXqRY8eMGaPc3FxTu0ePHvLz88s3zs/PT48//rgWLFggSTIajRo1apSWL19e5B7ff/+9tm3bZmp7e3urX79+RT+RGxAaGqo6deooKipKkrRjxw59+umnGjZsWInsV9L69eun0aNHKy0tTZK0ZcsWLV++XKGhoUXOffXVV83aTzzxhHx9fYtd05AhQzRp0iQlJSVJuvr+/vjjj+ratWux1y5J7u7uGjhwoN555x1T37Bhw7R58+Z8V6Ve7/Lly3r++edvRokmN+t9b9GihVl72bJleu+99+TmVniEaOnSpWYnyt2IXbt2acmSJerVq1eh4679fXY9a8OG1sgbqPP397fb2iidCNgBAAAATiwgIEDRUceVkpLi6FJQSvn4+Fj1rWYAAAAAAABH8/Pz08KFC9WhQwdlZWVJks6ePauQkBD973//U9++fWUwGKxaa9OmTXrppZf0xx9/5DvNyREiIyM1YcIEUzskJEQbN260eZ3//e9/atu2rZ566qkCx3z88cf67rvvTG2DwaCRI0cWOD48PFzfffedKZC3YsUKTZo0SW+88UaBc/bv368hQ4aY9Q0ZMqTEvujp6uqqt99+2yzAN3LkSLm5uenZZ5+1ep1jx45p2rRpGj9+vKpWrVoSpVrFz89PgwYNMgtLDho0SLVq1VKTJk0KnDd+/Hj9+OOPpraLi4vCw8PtUpOvr69ee+01jR07VpKUm5urfv366euvv9Zjjz1m9Tp79uzRlClTin0Smi3Cw8M1a9YsJSRcvdFj165d6t69u+bPn6+goKB848+dO6ennnpK+/btk8FgkNFovCl13qz3vVKlSmrevLn27dsnSTp16pSmTJmicePGFThn165d+f5M36hnn31W9erVU+PGjS0+npubq6efftos+BwUFJTvWtdrnnrqKT333HNWn5CZmJhoduKlpGJfPYvSj4AdAAAA4OQCAgIIQAEAAAAAAACS2rRpo9mzZ2vQoEGmwFdiYqKefPJJffDBBxo8eLAeeeQRVa9ePd/cv//+W6tWrcp3slph9uzZo8TExHz9166bvN7112dez9/f/6aEN2rUqKETJ07o6aef1o4dOzR69GhVq1bN9Hh0dLQmT56c79rWZ5991uL1sNe0atVK4eHheu+990x9b775pvbv36/IyEizkExiYqLmzp2r8ePHKz093dRfu3ZtTZo0yR5Ps0B9+/bVxo0bNXPmTElXTyh87rnn9N133yk8PFydOnXKd71kVlaWDh8+rA0bNmjJkiXaunWrjEZjoUGjm2Xy5MlatWqV6cTGxMREtWvXThMmTNCgQYPMTtw6dOiQxo8fr6VLl5qtMXr0aDVv3txuNUVERGjLli366aefJEmpqakKDQ1VaGioRowYofbt28vT09NszpUrV/THH39o3bp1WrJkifbu3Sup+FeN2iIoKEgfffSRnn76aVPfL7/8onr16qlv377q0KGDAgICdPHiRf3222/67rvvlJycLEkaOnSoPvvss5tW681635999lkNHz7c1H7jjTeUmpqqiIgIsz1Onz6tmTNnaurUqbp8+bJq166t48eP39Bz8/PzU25uruk5TZ48WWFhYWbB223btmnUqFH6/fffzeZ++OGHKl++vMV1f/zxRy1YsEANGjRQ79691blzZzVt2lReXl5m4y5fvqwffvhBr7/+uk6cOGHqb9q0qVq3bn1Dzwm3DwJ2AAAAAAAAAAAAAIBbRlhYmHx9fRUWFmZ288OuXbu0a9cuSVe/tBoYGChfX19dvHhRZ86cMQt8Xa9y5coF7vXqq69q06ZNVtX14IMPWuy/0dPobPXJJ5+ob9++Sk1N1fTp0zVjxgzVrFlTFSpUUHx8vCmwc73mzZtr6tSpRa49efJkHThwwCxEuGTJEi1ZskRVqlRRlSpVlJqaqujoaNPpgtdUqFBBixYtyhduKwnTp09XYmKiFi1aZOpbv3691q9fLzc3N9WoUUMBAQHKzs5WUlKS4uLilJmZWeJ13Yjy5ctr8eLFeuihh0whz7S0NI0aNUpjx45VzZo15ePjozNnziguLi7f/M6dO2vixIl2rcnFxUULFixQaGio6TNtNBq1bNkyLVu2TJ6enqpRo4b8/f115coVJSUl6Z9//lFOTo5d67gR/fv3V2xsrN58801TX1JSkj777LMCA3ShoaEaPXq02eNFXaNaXDfrfX/22Wc1e/Zs0yl2RqNR77zzjqZNm6a6devK29tb8fHxZqfIVapUSXPnzlXHjh1v6Ln5+vrq7bff1jPPPKPU1FS99NJLGj16tGrVqiUvLy+dOnVK58+fzzdv8ODBVl0vfeTIEU2cOFETJ06Uq6ur/vWvfykgIEAeHh5KSkqy+PeTl5dXvtAxYImLowsAAAAAAAAAAAAAAMAWoaGhOnDggLp3727x8YSEBB09elQ7d+7U8ePHLYbrKlSooA8++ECbN28u6XJvioYNG2rFihWm06CMRqOio6O1a9cui+G61q1ba+3atVZd2+rp6akff/xR/fv3z/fY6dOntXv3bh09ejRfeOXOO+/Ub7/9phYtWtzYk7KRu7u7Fi5cqHfffVdly5Y1eyw7O1vHjx/Xrl27tG/fPsXExFgM11WsWDHfXEdp1aqVNm/erFq1apn1Z2Vl6dixY9q9e7fFkNWAAQO0cuVKeXh42L0mX19frV27Vq+88kq+sFlGRoaOHTumHTt26MCBAzpx4oTFcN31JyveTG+88Ya++OILsxPaLDEYDHrhhRe0aNGifH93+Pr6lmSJkm7O++7m5qalS5eqdu3aZv3Z2dk6fPiwdu7caRauq169utatW1fsK7WffvppTZ061XSdd0ZGho4cOaI9e/YUGK6bNWuWzfvk5OToxIkT2rdvn3bs2GHx76eqVatq3bp1N+3vJ9zaOMEOAAAAcHIJCQlm38QF7MnHx4criAEAAAAAwC0pODhYy5cv1/79+zV79mwtXbpUZ8+eLXROuXLldO+99yosLEyhoaH5rrO81XXq1EkHDhzQ6NGjtWzZMovhpsqVKys8PFyvvPKKXF1drV7bw8ND8+fP15AhQzRx4kRt3rxZ2dnZFsfWrl1bw4cP14gRI0ok5FWUiIgIhYWFadq0aVq0aJFOnjxZ6PhKlSrpgQceUM+ePdWtWze5u7vfpEqL1rhxYx0+fFjTp0/Xp59+qujoaIvj3NzcFBISosjISHXo0KFEa3Jzc9N7772nF154Qe+++66WL19uMRx1veDgYD300EN6/PHHdf/995dofYUZMGCAunXrpq+//lrLli1TVFSU4uPj5enpqVq1aqljx44aMmSI7rrrLklXfz5/vZsRsJNuzvseHBysHTt26K233tLcuXOVkZGRb0zZsmVNf+b9/PwshnVtNWrUKLVu3VoRERHauXOnxTF33XWXJk+erEcffbTI9Xbu3KkVK1ZozZo12r59u9LS0godX6dOHYWFhSk8PPymnKyJ0sFgNBqNji4Czu3PP/9U48aNTe1Dhw6pUaNGDqwIAHCr+G+Pt3T09z9Vr10jjV1m32PIAWf1yOAukkGSUVo99yeb5n6z6Fs9EHKf7rjjDlNfQkKCatWpreTEJPsWCvx/vv5+io46XuyQ3UtLhpt+/3GvT4pbFgAAAADgNpCdna2///7brO/OO+8s8ev3ULodP35chw4d0qlTp5Samiqj0Sg/Pz8FBASoYcOGatSokU2hslvZhQsXtGXLFkVHRysjI0NBQUGqV6+e2rdvLxeX4l92l5SUpN9++02nT5/WxYsXVa5cOd1xxx1q1qyZ6tWrZ4dnYD9RUVHav3+/4uPjlZiYKDc3N/n6+qp69epq0KCBgoODHV2i1f766y/t27dP58+fV3p6uipUqKCqVauqQ4cONy38lZfRaNSff/6pP//8UxcuXFBSUpI8PT3l6+urmjVrqmHDhqpSpYpDaiuuGTNm6MUXXzS1v/zyS4WFhd30Okr6fU9LS9OmTZsUExOjpKQkeXl5qX79+rr33nuLFUILDg7WiRMnJEk1atTIF9CLiorS9u3bFRcXJ4PBoMqVK6tFixY3nEnJycnRkSNH9PfffysuLk6pqamSrl69W7VqVTVr1kw1a9a84edzKyupf3fdLpki/nUKAAAAOIkDR/7Qkl+XKPLF8WrS+Oq341JSUpScmKRnN7wu36qcMgb7So5L0OxOk5WSksIpdgAAAAAAoFSoXbt2visPb1cVK1ZUjx49Smx9Pz8/devWrcTWt6c6deqoTp06ji7DLurXr6/69es7ugwzBoNBjRs3NgvZlBa//vqrWbtVq1YOqaOk3/dy5cqpS5cuJbZ+Qez9Z9PV1bXUfhbhWATsAAAAACdyOSdd4z4cp+cfH6Zunf/v/8z6Vg2Qf3CgAysDAAAAAAAAAOD2ERsbq1WrVpnaAQEBatCggQMrAuAoBOwAAAAAJ5OjHP3v+xk6cSpWXR+8+d8YAwAAAAAAAACgtDEajTIYDFaNzcrKUlhYmHJyckx9YWFhdrleGcCth4AdAAAAUELmf/eNTeNPnIs1a/+w4wf9HXtcBhfr/g8/AAAAAAAAAACwrEWLFho7dqxCQ0Pl4eFR4Ljo6GgNHDhQmzdvNvV5enpq+PDhN6NMAE6IgB0AAABQQhassy1gZ8nRc0f0SJ+uyk7JtENFgLmMP6I0YvHzen/PFGmPo6sBAAAAAAAAgJKzf/9+9enTR35+fnr44YfVunVr1ahRQ97e3kpNTdXJkye1ceNGrV692uzkOkmaNGmS6tSp46DKATgaATsAAADAyRk8DMpJyXJ0GSilrL0SAQAAAAAAAADsLTExUXv22P/bv40aNVLlypUtPpaUlKSFCxdq4cKFVq310ksv6ZVXXrFneQBuMQTsAAAAgBJSza+6TeNPJZ3M1xfoFaTv5y5Sg9c72qkqwJzRaCRkBwAAAAAAAMAhDhw4oAcffNDu637xxRcaMGCAWV/VqlUVFxdn9RrVqlXTxIkT860D4PZDwA4AAAAoIbOmfWbT+IgJY3Xw1AFT+65qTfXcU4M1f/pX9i4NkCR5NqmjaXVfVUxMjIKDg4u11ktLhtunKAAAAAAAAAAoAadOndK2bdu0YcMG7dy5U8ePH9fp06d16dIlubi4yN/fX0FBQWrbtq3uv/9+hYaGysPDw9FlA3ACBOwAAAAAJ9S1TTeNeG64YmNjHV0KAAAAAAAAAAC3PIPBoHbt2qldu3aOLuW2wX/jQGlBwA4AAABwIq5y1dBez+vRR7o6uhQAAAAAAAAAAEpUx44dZTQaHV0GABSKgB0AAADgJKreUUVP9eynpnc1yfdYclyCAypCacfnCgAAAAAAAAAAoHAE7AAAAAAnMfL5F/P1+fj4yNffT7M7TXZARbgd+Pr7ycfHx9FlAAAAAAAAAAAAOCUCdgAAAIATCwgIUHTUcaWkpDi6FJRSPj4+CggIcHQZAAAAAAAAAAAATomAHQAAAODkAgICCEABAAAAAAAAAAAADuDi6AIAAAAAAAAAAAAAAAAAAHBGBOwAAAAAAAAAAAAAAAAAALCAK2IBAAAAJ5eQkKCUlBRHl4FSysfHhyuIAQAAAAAAAAAACkDADgAAAHASB/78Q3c1aCwXl/87aDohIUE169RSSmKyAytDaebj76uYqGhCdgAAAAAAAAAAABYQsAMAAACcxCfffKqs7Cx9MvF/KlPGU5KUkpKilMRktV/cU2UreTu4QpQ2l89e0tbeS5WSkkLADgAAAAAAAAAAwAICdgAAAIATORR3UI+/1FtzJ8/RHYFBpv6ylbzlVc3HgZUBAAAAAAAAAAAAtx+XoocAAAAAuJnOp51Tn1f7at+h/Y4uBQAAAAAAAAAAALitEbADAAAAnFB6TpqG//cF/bp1g6NLAQAAAAAAAAAAAG5bXBELAAAA2JFRkuH//2+bp+4u1lo5ytasn2aqYZvG9igNyMflVKbajAjR+1s/VZk9ZYq11j/xSabfRywZX8zKgFtLWfeyerJNL9WrdKejSwEAAAAAAAAA2BkBOwAAAMCuro/Y2WM1o7xrl5NiMqVqdlkSMDFczlXAnYH6+2K0Xdc9GHfYrusBt4oJj41xdAkAAAAAAAAAADsjYAcAAAA4MTe56Z/dcfIZXs/RpaAUMpZ1UeK+c7q77d0qU6Z4J9hFxf9t+n2dQE7xwu0jOj5WaZnpupx12dGlAAAAAAAAAABKAAE7AAAAoITs/GaHTeOHjhumfSf2mtrl3MppzDNj1HnBwyJeh5KQW81DO2ds0sJXv1RwcHCx1nppyXDT76f0mlDMyoBbR8SS8ZzaCAAAAAAAAAClGAE7AAAAwAnd4V1ZcyfPVvqlNEeXAgAAAAAAAAAAANy2XBxdAAAAAABzd/2rqb6fvlBBFQMdXQoAAAAAAAAAAABwWyNgBwAAADgJFxcXPdrmMc19d5Y8PTwdXQ4AAAAAAAAAAABw2+OKWAAAAMBJTHg5ssBT6y6fvXSTq8HtgM8VAAAAAAAAAABA4QjYAQAAAE7CUrjOx8dHPv6+2tp7qQMqwu3Ax99XPj4+ji4DAAAAAAAATio4OFgnTpyQJNWoUUOxsbGOLeg28OWXX2rgwIGm9hdffKEBAwY4pBaDwWD6fUhIiDZu3OiQOgDAkQjYAQAAAE4sICBAMVHRSklJcXQpKKV8fHwUEBDg6DIAAAAAAADsIiYmRocOHdKpU6eUkpKi3Nxc+fv7y9/fXw0aNFDjxo3l6urq6DIBAMAthIAdAAAA4OQCAgIIQAEAAAAAAAAFOHjwoGbNmqVly5YpLi6u0LFeXl5q3769+vfvr169eqlcuXJW7REfH6+dO3ea/UpISDAbYzQab/g5AAAA5+Xi6AIAAAAAAAAAAAAAALDVyZMn1atXLzVp0kQzZswoMlwnSenp6Vq7dq3CwsJUpUoV/fe//9WVK1csjj1y5Ij69u2rWrVqKSgoSN26ddPEiRP1888/5wvXofQIDg6WwWCQwWBQcHCwo8u5pURGRppeO4PBwHWyAEoNTrADAAAAnFxCQgJXxKLEcEUsAAAAAKC0eGDOQEeXUGqsG/KFo0so0g8//KD+/fsrOTnZ4uP+/v4KDAyUr6+vLly4oHPnzik9Pd1sTEpKisaNG6elS5dq165d+dY4evSoFi5cWCL1AwCAWwcBOwAAAMBJZGRmyNPD06wvISFBNevUUkqi5R8UAsXl4++rmKhoQnYAAAAAAOCW8c033ygsLEw5OTlm/S1bttTgwYPVpUsX1ahRI9+8o0ePasWKFVq0aJH27Nlj6o+Pj7e5Bm9vb126dMn24gErDBgwQAMGDHB0GZK4+hgAJAJ2AAAAgNMYN+UNtb6rtfp2f8LUl5KSopTEZLVf3FNlK3k7sDqURpfPXtLW3kuVkpJCwA4AAAAAANwSdu/erUGDBpmF63x9fTVjxgw99dRTMhgMBc6tV6+eIiIiFBERoWXLlmns2LE6evRokXuWLVtWzZo1U5s2bdS6dWu1bt1a7u7uqlWrll2eEwAAcG4E7AAAAAAncSn9kt5f9J6Onzyu118ca/ZY2Ure8qrm46DKAAAAAAAAAMdLSUlRnz59lJmZaeoLCgrSmjVr1KxZM5vW6tGjh7p27arhw4dr3bp1Fse0adNGe/fu1V133SU3N/P/tB4bG2tr+QAA4BZFwA4AAABwMiu2L1fs6VjNmPCxo0sBAAAAAAAAnEZkZKSio6NNbRcXFy1fvtzmcN01Hh4emjNnjpYuXWrx8SpVqqhKlSo3tDYAACg9CNgBAAAATujAyf3q/WIfRQ57y9GlAAAAAAAAAA6XlJSk2bNnm/W9/PLL+ve//13stXv27FnsNZxJZmamtm/frtjYWMXHxys3N1eBgYG688471bZtW7m6ut70mnJycrR7925FRUXp/PnzysjIUGBgoGrWrKn27dvL09PTLvukpaVp27ZtiouLU3x8vLKysuTj46OaNWuqSZMm+te//mWXfYojIyNDW7du1T///KMzZ87I1dVVrVu3VkhIiN33SkpK0rZt23TmzBlduHBBubm58vPzU+3atdW0aVMFBQXZfU8AKI0I2AEAAAAlpM1Tdxdr/tlLZ/TK+6PkHxhgp4oAAAAAAACAW9PMmTN16dIlU9vDw0Njx451YEXO59ChQ5o4caJWr15t9lpdz8/PT/3799ebb755U8JVsbGxevvtt7V8+XIlJCRYHOPl5aWePXtq4sSJqlmz5g3ts3r1ak2bNk2//fab2RXCeTVo0EB9+vTRc889p8qVK5v6BwwYoK+++irf+BMnTshgMBS4XlhYmL788kuzvrxrxcTEKDg4WP/884/efvttLVq0SElJSWZzunfvbhaw+/LLLzVw4EBT+4svvtCAAQMKrON6ubm5WrhwoT7++GPt2rVLOTk5FscZDAY1b95cTz31lAYOHCh/f/8Cx10TEhKijRs3mj2+ceNGderUyeLcgvqvMRqNkqTnn39eM2fONPV/8803evLJJwuda0mLFi20b98+U/vw4cNq0KCBzesAQF4E7AAAAAAnlp6TproP1JNiM6Vqjq4GpY3LqUy1GRGi97d+qjJ7yhRrrX/ik0y/j1gyvpiVAbeO6PhYSVJ65mXHFgIAAAAApVzea1x79OihihUrOqga+4uMjNSECRNMbUtBpoJkZ2crPDxcn3zyiXJzcwsdm5SUpBkzZuirr77St99+q65duxan7EJNmjRJb7/9dqGBN0lKT0/X119/rUWLFumTTz7R4MGDrd7jzJkz6tu3rzZv3mzV+CNHjigyMlIxMTH5gnElad26dXr88ceVnJxcovv89ddfeuKJJ3Tw4MEixxqNRu3du1d79+5VSkqKIiMjS7S2wgwdOtQsYDdnzhybA3Z79uwxC9d16NCBcB0AuyFgBwAAADi5nIs5Mv7L3dFloBQyXM5VwJ2B+vtitF3XPRh32K7rAbeC8ynxji4BAAAAAEqttLQ07d2716yve/fuDqrGuaSnp6tnz55as2ZNvscqVaqkSpUqycXFRf/884/Onz9veiw1NVXdu3fXt99+q969e9u1ppycHA0ePNjiiXAVKlRQ1apV5eHhoTNnziguLs70WGZmpoYMGaKUlBSFh4cXuc/BgwfVpUsX/fPPP/ke8/f3V5UqVeTl5aWkpCTFxsYqKyureE/sBu3bt0/9+/dXenq6qa9GjRoKDAxUYmKiTp48aZd9NmzYoJ49e+Y7HU+SAgMDVblyZXl4eCghIUGxsbFFhjFvpubNm6tNmzbauXOnpKun4kVFRalOnTpWr5H3Culnn33WrjUCuL0RsAMAAABKyO9fbbVp/PA3X9T+k+Y/KHykeRdNHB2pB96sb8/SAEmSsayLEved091t71aZMsU7wS4q/m/T7+sE3lnc0oBbxp+n/1KuMVe5Ruf5oTQAAAAAlDbbt29Xdna2WV+rVq0cVI1zGTZsmFm4ztvbW+Hh4Ro4cGC+61YPHDigSZMm6fvvv5f0f0G45s2b2xRkKsrEiRPNwnXu7u4aPny4nnvuOTVs2NBs7PHjxzV16lTNmjXLdF1oRESE7r77brVr167APZKSktS9e3ezcJ2Li4sGDBig4cOHq0WLFmZXm165ckW7d+/WkiVL9PXXX+dbLyIiQv3795ck9e/fX+fOnZMk3XHHHRbHX1OlSpXCXgpJV9+j9PR0lSlTRqNGjdLzzz+vqlWrmj2XP/74o8h1ChMbG6tevXqZhes8PT01YsQIDRo0KN/rfunSJW3btk3ff/+9FixYUKy9mzZtqrVr10qS5s2bp/nz55semzZtmpo2bWrVOkOHDjUF7IxGo+bMmaN33nnHqrlpaWn69ttvTW0/Pz+7B0cB3N4I2AEAAAAlxM3Ntn9uX/fzHrnKTRH9R6t5g2aaODrSvoUB/19uNQ/tnLFJC1/9UsHBwcVa66Ulw02/n9JrQiEjgdLl8c/ClJaZXvRAAAAAAMAN++uvv8za3t7edg2E3aoWLlyoefPmmdq1a9fWmjVrVLt2bYvjmzZtqsWLF2vq1KmKiIiQdPUku1dffVUrVqywS02///67Jk2aZGpXrFhRq1evLjAQWbt2bX322Wfq1KmTnnzySeXm5io7O1vDhg3TgQMHCtxn2LBhiomJMbV9fHy0fPlyderUyeL4MmXKqEOHDurQoYMmT56cL9DWsGFDUwjt+i+ililTRg888EDRT7wQ586dk7e3t1avXq0OHTrke9zPz0/33ntvsfZ48sknlZiYaGpXqVJFP//8s+666y6L4729vfXggw/qwQcf1H//+99inaLn7+9veo1+++03s8datmypjh07WrVO37599corr5iu0f3yyy/19ttvy9296NtdFi1apJSUFFP7qaeeUtmyZa18BgBQNBdHFwAAAADAnJerl/732gz1eCTU0aUAAAAAAAAADpeQkGDWDgwMNDud7HZkNBoVGRlpant5eRUarrve6NGjzU73WrVqlY4dO2aXuiZOnGi6etTFxUUrVqyw6rTBPn366NVXXzW1//jjD61bt87i2L/++ksLFy40tQ0GgxYtWlRguC4vLy8vtW3b1qqx9jJt2jSL4Tp7+OWXX7Rt2zZT29PTs9BwXV4BAQFq1qxZidRmCy8vLz399NOm9rlz57Rq1Sqr5nI9LICSRsAOAAAAcCKBXkH6buq3atGkuaNLAQAAAAAAAJxC3oCdn5+fYwopQZGRkTIajaZfGzduLHT8mjVrzE72GzlypFXhumveeOMN0++NRqOWLVtmc815HTlyxOy62j59+hR6zWter732mtmtIEuWLLE47uOPPzZdJytdvdL14YcfvoGKb47q1auXaODrww8/NGtHRERYHa5zNs8//7xZO29wzpI///zTLGDYunVrq6+lBQBrcUUsAAAA4CQe7dRND9zzgMqU8cz32OWzlxxQEUo7PlcAAAAAAOBWkJqaatYuV66cgypxHj/99JNZ+/qTv6zRpEkTVapUSWfPnpUkbdmyRa+99lqxalq9enWxaqpQoYJatmypHTt2mGqy5JdffjFrv/TSSzbtc7P16dNHLi4lc/ZRVlaWWRjTzc1Nw4cPL5G9boZGjRqpffv22rp1q6Sr7/XJkydVvXr1AufMmTPHrM3pdQBKAgE7AAAAwEl0e7Brvj4fHx/5+Ptqa++lDqgItwMff1/5+Pg4ugwAAAAAAIAClS9f3qydlpbmoEqcx/Xhs3Llyql+/fo2r1GtWjVTwO7IkSN2rUmSVVfD5lW9enVTwO6vv/6S0Wg0uw74zJkzOn78uKkdFBR0Q/vcTG3atCmxtXfv3q3Lly+b2s2bN1elSpVKbL+b4fnnnzcF7HJzczV37lxNmDDB4tiMjAzNnz/f1Pb29la/fv1uSp0Abi8E7AAAAAAnFhAQoJioaKWkpDi6FJRSPj4+CggIcHQZAAAAAAAABcr7s4vk5GQHVeI8rg/EpaWlFfuEtLzX8N6IvCG9oKCgYq2Xk5OjlJQU+fr6mvquD9dJUsuWLYu1x81Qs2bNEls77+vh7GFDa/Tu3Vsvv/yyLl68KEn6/PPPNX78eIuf8aVLl5rGSVLfvn3l7e1902oFcPsgYAcAAAA4uYCAAAJQAAAAAAAAuG3l/dlYfHy8gypxDmlpacrIyLDrmvYILV4fdLKX5ORks4Bd3iBgcUN8N0NJ3h5xK74eRfH09FRYWJjef/99SdI///yjn3/+WV26dMk3luthAdwsJXPRNwAAAAAAAAAAAAAAdpD3+tPU1FRFRUU5qBrHS0pKsvuaRqOx2GuURF25ublm7dTUVLP2rXBambu7e4mtfSu+HtYYOnSoWXv27Nn5xhw/flwbNmwwtZs0aVKi1/ECuL1xgh0AAAAAAAAAAAAAwGm1bdtWbm5uys7ONvXt3r1bderUcWBVjuPl5WXWDggI0MKFCx1Uzf/x8vJSSkqKqb169Wq5uRUvklCpUiWzdvny5c3aly5dKtb6t7rS+nrUrVtXnTp1MgXofvjhB509e9bs8zBnzhyzYCin1wEoSQTsAAAAACeXkJBg9oMpwJ58fHy4ghgAAAAAADi1cuXKqUWLFtq5c6epb+XKlerbt68Dq3IcPz8/s8Dh5cuX9cADDzi4KqlixYpmP8ds0aKF3a8szftzrPPnz9t1/VtNaX49nn/+eVPALjs7W1988YXGjh1ran/55ZemsWXLllX//v0dUSaA2wQBOwAAAMBJzP5mjro+0FVV7qhs6ktISFDNOrWUkpjswMpQmvn4+yomKpqQHQAAAAAAcGo9evQwC9gtXbpUFy9eVIUKFRxYlWMYDAbVqFFDx48fl3Q1YHf69GlVqVLFoXXVrFlT0dHRpnZUVJTdA3Z5Ty3cs2ePXde/1dx5551m7d27dzuoEvvr0aOHgoKCTKHBOXPmaMyYMTIYDKYT7a7p3bu3/Pz8HFQpgNsBATsAAADASez+c4++XvON3h/1nlo2aSFJSklJUUpistov7qmylbwdXCFKm8tnL2lr76VKSUkhYAcAAAAAAJza0KFDNXnyZNMVmBkZGXr33Xc1ZcoUB1fmGJ06dTIF7CRp/fr1Dj/Bq1OnTvr1119N7fXr16tdu3Z23aNSpUq688479ffff0u6emLb7t271apVK7vt4eLiYvr99VeQOqMWLVrIy8tL6enpkqR9+/blu0r1Zrr+tZOK9/q5u7tr0KBBeueddyRJ0dHRWr9+ve6//37Nnj3bbCzXwwIoaQTsAAAAACdyOSddI94doVf7varHu/Uy9Zet5C2vaj4OrAwAAAAAAABwHH9/fw0ePFgfffSRqe/9999Xr169dPfddxdr7Z9++kldunQpbok3VefOnTVnzhxTe8aMGQ4P2HXu3FlvvPGGqT1r1iy99tprcnd3t/s+1wJ2kvTxxx9r3rx5dlu/XLlypt9fC645K3d3d91///1atWqVpKtXp37yySeaOHGiQ+q5/rWTiv/6Pffcc3r33XdNQb3Zs2erXr16WrNmjWlM/fr11aFDh2LtAwBFcSl6CAAAAICbKUc5mvLtFL3zv6mOLgUAAAAAAABwGpGRkQoODja1c3JyFBoaqoMHD97QellZWRo1apReeOEFO1V484SGhppdl7pjxw59+umnDqxIatmypTp16mRqnzp1yixwZy8vvvii2UlpX3/9tX755Re7rX/9TQ8XL15Uamqq3dYuCSNHjjRrT5ky5Yb/TBRX3lsyYmJiirVezZo19dBDD5nay5Yt05QpU5STk2Pq4/Q6ADcDATsAAACghMycP9umX9Fnos3mL/39e02YMUkGF4ODngEAAAAAAADgPPz8/LRw4UKzE9HOnj2rkJAQffvttzZdR7lp0ya1atVK7733nlNcAxoZGSmDwWD61bFjx0LHu7q66u233zbrGzlyZL6rM4ty7NgxPffcc4qLi7O1ZIvefvtts/DblClTNHHiRJte43/++UejR4/Wrl27LD5+55136sknnzS1jUajevfurY0bN1q1flpamrZv317g440aNTJbe8mSJdYV7iD333+/7rnnHlM7IyNDnTt3tjpkl5CQoP3799ullutfO0l2ee2ef/550+8zMzM1ffp0U9vDw0PPPPNMsfcAgKJwRSwAAABQQub+PKfoQUX488xBte3eTrqUU/RgwEYupzLVZkSI3t/6qcrsKVOstf6JTzL9PmLJ+GJWBtw6LmddkSTlGHMdXAkAAAAA3B7atGmj2bNna9CgQcrNvfr/xRITE/Xkk0/qgw8+0ODBg/XII4+oevXq+eb+/fffWrVqlb7//ntt27bNqv327NmjxMTEfP3nzp3L17du3TqLa/j7+6tly5ZW7WeLvn37auPGjZo5c6akqyfyPffcc/ruu+8UHh6uTp065buyMysrS4cPH9aGDRu0ZMkSbd26VUajUePGjbNLTe3bt9fkyZM1duxYU9/48eO1cuVKjRo1Sg8//LD8/f3N5uTk5OjYsWPasmWLlixZovXr1ys7O1tdu3YtcJ8ZM2bo999/V3T01S8tp6Sk6IEHHtCAAQM0fPhwNW/eXAbD/31x+cqVK9q9e7eWLFmi+fPnq1u3bmrbtq3FtR966CGz0wCHDRumPXv2qF27dgoICJCrq6vpsSpVqqhhw4a2vUgl4Ouvv1bz5s2VkJAgSTp9+rTatGmjESNGaPDgwapfv77Z+LS0NP3+++9avHixvv32W7366qtq1qxZseto3ry5KlasqAsXLkiSNm7cqPvuu09PPPGEqlevLg8PD7PxDzzwQJFrduvWTVWqVNHp06fzPdajRw9VrFix2HUDQFEI2AEAAADOzkPSJcd/ixalj+FyrgLuDNTfF6OLHmyDg3GH7boecCvIys50dAkAAAAAcNsICwuTr6+vwsLClJKSYurftWuX6dSzgIAABQYGytfXVxcvXtSZM2eUnp5ucb3KlSsXuNerr76qTZs2WVXXgw8+aLE/JCTE6tPVbDV9+nQlJiZq0aJFpr7169dr/fr1cnNzU40aNRQQEKDs7GwlJSUpLi5OmZkl+/9hx4wZo/Pnz+uDDz4w9e3Zs0f9+vWTi4uLqlevrgoVKkiSkpKSCn1vCuLr66uVK1eqc+fO+ueffyRdDerNnTtXc+fOVUBAgKpWraqyZcsqMTFRsbGxysrKsmrtbt26qV69ejp69Kikq+G8GTNmaMaMGfnGhoWF6csvv7Sp9pJQvXp1LV26VKGhoUpKSpJ0te5p06Zp2rRpCgoKUuXKleXh4aGLFy8qNjbWFFC1J3d3d7300kt66623TH0bNmzQhg0bLI635mRDNzc3DRkyRBMnTsz3GNfDArhZCNgBAAAAJaSGf7BN408kxubru6NcJa2dv0b3jKhtn6KA6xjLuihx3znd3fZulSlTvBPsouL/Nv2+TuCdxS0NuGVcC5QSgwYAAACAmys0NFQHDhzQyy+/rBUrVuR7PCEhwXSaV0EqVKigN954Qy+88EJJlVni3N3dtXDhQrVs2VKRkZG6fPmy6bHs7GwdP35cx48fL3SNihUrqmzZsnat6/3331ezZs00cuRIU+BLknJzcxUbG/v/2Lvv8CiL/f3j96ZDIGUhAUILTaQjIF2agAVpUhW+goIi2EBEwRo44qGo2EVAAQGld5EmUgQl9C4tCSW0QBI2BRKS7O8PfuxhSduQspvk/bourrMzz8w895PdeDB+MqOwsLAM5xcvXlw+Pj4ZjqlVq5Z27typXr16aceOHVbXbHn/0+Pi4qIlS5aoa9eumX7tHEnr1q21fft29ezZU8eOHbO6duXKFV25ciVPcrz77rs6ceKE5s6dm2NrDh48WOPHj1dy8v9OeqlcubLatWuXY/cAgIxQYAcAAADkkkXfLMjS+CHvDtW+M3st7YcqNtCoF0aq2vSVOR0NkCSllHdT8DdbtGDkLAUGBmZrrdeXDLO8ntRjbDaTAflHp6/7KIXjYQEAAADALgIDA7V8+XLt379f06dP19KlS3Xp0qUM53h6eqpVq1YaMGCAunXrJnd39zxKm7vefvttDRgwQJ9++qkWLlyos2fPZji+dOnSat++vZ5++mk99dRTcnV1zfFMzz33nLp27aqvv/5ac+bM0YkTJzIc7+vrq0cffVRdunRRjx49VLRo0UzvERAQoO3bt2vZsmX67LPP9M8//1gVYd3NYDCoXr16euaZZ/TCCy9kuG6tWrV08OBBLVy4UL/99psOHjyoy5cvKzY2Nt31HUHNmjV16NAhzZ49W998843279+f7i5xzs7OatKkifr166f/+7//y7EMzs7OmjNnjl5++WX9+uuv2rVrl0JCQhQTE6OEhIT7WrN8+fJq37691q1bZ+kbPHiw1THAAJCbDGZb9txEoXbkyBHVrl3b0j58+LBq1aplx0QAgPziv90/1PEdR1S9eS2NWZZ6626gIHp80BMyGAwym81a++PvWZp7d4Fd9+ZPa8wr7ygsLEyVKlVS+23PqWh5r9yIjEIs/pxJGx/5WaGhoTlaYPdVj++ymQzIP+4U2DkZnPTba1krrAYAAAAKu6SkJJ08edKqr1q1anJxYY8Q3L/Tp0/r8OHDOnfunGJiYmQ2m+Xj4yOj0aiaNWuqVq1acnZ2tnfMXHfq1Cnt379fERERioqKkouLi7y9vVWhQgXVqFEj2z8Luh/h4eHatWuXrly5omvXrsnJyUleXl4qW7asatSooSpVqsjJySlb94iKitKOHTt08eJFXb16VQaDQd7e3qpSpYrq1asnf3//HHqa/OHy5cv6+++/dfnyZV27dk0uLi7y9fVVtWrVVL9+/Ux3CXQUZrNZlSpV0pkzZyTd3mXw3LlzKl26tJ2TAflHbv29q7DUFPG3UwAAAMCBOMtZI/q+qd6de9o7CgAAAAAAAJDvVKlSRVWqVLF3DLurWrWqqlatau8YVsqWLauyZcvm6j18fX3VqVOnXL1HflKqVCl169bN3jGybcOGDZbiOkl66qmnKK4DkKcosAMAAAAcRIUyFTS49yA9XL9Rqms3LsXaIREKOj5XAAAAAAAAABzdDz/8YNUeMmSInZIAKKwosAMAAAAcxHuvjUnV5+XlJS9fb23vtdQOiVAYePl6y8uL44cBAAAAAAAAOJ4TJ05o+fLllnbVqlX12GOP2S8QgEKJAjsAAADAgRmNRoWeCpHJZLJ3FBRQXl5eMhqN9o4BAAAAAAAAAFaSk5M1bNgwpaSkWPqGDx8ug8Fgx1QACiMK7AAAAAAHZzQaKYACAAAAAAAAABRoe/bsUVRUlJKSkhQaGqpp06Zp//79lusVKlTQ4MGD7RcQQKFFgR0AAAAAAAAAAAAAAADsauTIkdqyZUu617/77ju5u7vnYSIAuM3J3gEAAAAAAAAAAAAAAACAtBgMBk2YMEGdOnWydxQAhRQ72AEAAAAOLjIyUiaTyd4xUEB5eXlxBDEAAAAAAAAAh+Li4qJSpUqpRYsWev3119WiRQt7RwJQiFFgBwAAADiIA0cOqk6N2nJy+t9G05GRkapUtbJMUdftmAwFmZevt0JPhVBkBwAAAAAAAMCuNm/ebO8IAJAmCuwAAAAAB/HdvO91K+mWvhv3rTw83CVJJpNJpqjrarHoaRUpXczOCVHQ3LgUq+29lspkMlFgBwAAAAAAAAAAkAYK7AAAAAAHcjj8kHq+3ks/jp+hUn7+lv4ipYupaHkvOyYDAAAAAAAAAAAACh+nzIcAAAAAyEtX4i6rz8i+2nd4v72jAAAAAAAAAAAAAIUaBXYAAACAA4pPjtOw/76iP7b/ae8oAAAAAAAAAAAAQKHFEbEAAABALmncr0m25icrSdPW/KCajWvnUCLAmtO5RDV+tbU+3/69PPZ4ZGut8xHRltdvL/kom8mA/CPFnCJJMsts5yQAAAAAAAAAgNxAgR0AAADgwMwyq1gVTyk0USpv7zQoaAw3UmSs5qeT10JydN1D4UdzdD0gPzCbKbADAAAAAAAAgIKIAjsAAADAgbnIRed3h8trWHV7R0EBZC7ipKh9l9WkaRN5eGRvB7tTESctr6v6VctuNCDfoKAUAAAAAAAAAAo2CuwAAACAXBI8b2eWxg95d6j2ndlraXu6eGr0c6P1+C+PifI65IaU8m4K/maLFoycpcDAwGyt9fqSYZbXk3qMzWYyIP944qte9o4AAAAAAAAAAMhFFNgBAAAADqhUsTL6cfx0xcfG2TsKAAAAAAAAAAAAUGg52TsAAAAAAGt1ytXT4q8XyL+kn72jAAAAAAAAAAAAAIUaBXYAAACAg3ByclLnxl3048Rpcndzt3ccAAAAAAAAAAAAoNDjiFgAAADAQYwdHpTurnU3LsXmcRoUBnyuAAAAAAAAAAAAMkaBHQAAAOAg0iqu8/Lykpevt7b3WmqHRCgMvHy95eXlZe8YAAAAAAAAAAAADokCOwAAAMCBGY1GhZ4KkclksncUFFBeXl4yGo32jgEAAAAAAAAAAOCQKLADAAAAHJzRaKQACgAAAAAAAAAAALADJ3sHAAAAAAAAAAAAAAAAAADAEbGDHQAAAODgIiMjOSIWuYYjYgEAAAAAAAAAANJHgR0AAADgIBISE+Tu5m7VFxkZqUpVKssUfd1OqVDQefl4K/R0CEV2AAAAAAAAAAAAaaDADgAAAHAQ74weo8YNG+vZfn0tfSaTSabo62r49hNy9y1qx3QoiBKi4rVn0u8ymUwU2AEAAAAAAAAAAKSBAjsAAADAQcTGxerTnybrVMgpffjB+1bX3H2LqkjJ4nZKBgAAAAAAAAAAABROTvYOAAAAAMDa8s3L9MKLg5WQmGDvKAAAAAAAAABQoISFhclgMFj+DBw40N6RkI7AwEDL+xQYGGjvOAAKMXawAwAAABzQ/pB96t6nhz5+f5y9owAAAAAAAAD5RmhoqA4fPqxz587JZDIpJSVFvr6+8vX1VY0aNVS7dm05OzvbOyYAAMhHKLADAAAAckmDRxtma/4l00W9/u5weXv75EwgAAAAAAAAoAA6dOiQpk2bpmXLlik8PDzDsUWLFlWLFi3Uv39/9ejRQ56enjbdIyIiQsHBwVZ/IiMjrcaYzeb7fgYAAOC4KLADAAAAHFh8UpyqNqgmpytJUkl7p0FB43ozRQ2fbanJq76Rh4dHttY6E3HN8nrk9PezGw0AAAAAACBTZ8+e1YgRI7R06VKb58THx2vDhg3asGGDXnvtNY0ePVojRoxI82cjx44d09ixYxUcHKzQ0NCcjA4AAPIRCuwAAAAAB5diSlFySY6tQM5zSjbLt2JJnbh4OkfXPRh7JEfXAxyZcylnGQwGe8cAAAAAIGlH4B/2jlBgNA971N4RMrV69Wr1799f169fT/O6r6+v/Pz85O3tratXr+ry5cuKj4+3GmMymfTuu+9q6dKl2rVrV6o1jh8/rgULFuRKfgAAkH9QYAcAAADkkuB1O7M0fsiwYdp3eo9VX6fmnfTxx/9R856BOZgMuC3F2SBTSISaNG2S7R3sTkWctLyu6lctu9GAfONo/HF7RwAAAACAQmfevHkaMGCAkpOTrfobNmyoQYMG6cknn1TFihVTzTt+/LhWrFihhQsXas+e//0cLiIiIssZihUrptjY2KyHh90FBgZynG8+ERYWZu8IACCJAjsAAAAg17i4ZO2v23dvgOQiF70z9B01bNRAH3/8nxxOBtx2y8NJe375S4vHz1FgYGC21np9yTDL6896fJzNZED+8cRXvewdAQAAAAAKld27d+uFF16wKq7z9vbWN998o379+mW4y3j16tX19ttv6+2339ayZcs0ZswYHT+e+S9OFSlSRPXr11fjxo318MMP6+GHH5arq6sqV66cI88EAAAcGwV2AAAAgIMp6lJUX47/Ug0bNeA39AAAAAAAAID/z2QyqU+fPkpMTLT0+fv7a926dapfv36W1urevbs6deqkYcOGaePGjWmOady4sfbu3as6deqk+mVafm4HAEDhQYEdAAAA4ED8i5XSrKk/qXSZ0vaOAgAAAAAAADiUoKAghYSEWNpOTk5avnx5lovr7nBzc9OMGTO0dOnSNK8HBAQoICDgvtYGAAAFBwV2AAAAgIPo2qmLOnRsLw8Pj1TXEqLi7ZAIBR2fKwAAAAAAkF9ER0dr+vTpVn3Dhw9Xs2bNsr32008/ne01HEliYqL++ecfhYWFKSIiQikpKfLz81O1atXUtGlTOTs75+j9zp49qx07dujs2bMym83y8/NT/fr19dBDD2V4ZK8trl27pi1btig8PFwxMTEyGo2qU6dOrjzH/bp+/bq2bt2qU6dO6caNGypRooSqVq2qli1byt3dPdvrm81mHTx4UMeOHdOVK1cUFxenkiVLqly5cnrkkUdUrFixHHgKKT4+Xtu3b1d4eLiuXLkiZ2dn+fv7q2bNmmrQoEG238t7nT59WgcPHtSFCxcUHR2tkiVLqm/fvvL29s7R+9xx69Yt7dixQ4cPH1Z0dLS8vLxUvnx5tW7dWr6+vtla22w2Kzg4WMeOHdOlS5fk4uKiihUrqkWLFhTpAgUEBXYAAACAg+jc5alUfV5eXvLy8daeSb/bIREKAy8fb3l5edk7BgAAAAAAQIZ++OEHxcbGWtpubm4aM2aMHRM5nsOHD2vcuHH6/fffrb5Wd/Px8VH//v31wQcfyN/f36Z17y6sat26tTZv3ixJ2rVrl0aPHq1NmzalOa98+fIaN26cBg4cmKXnkKQTJ05o5MiRWrt2rZKSklJd9/f311tvvaURI0bIxcVFQUFBGjt2rOX6n3/+qTZt2qS5dlhYmCpVqmRpDxgwQLNmzUo3S5s2bbRlyxZL22w2S5IuXryo9957T/PmzbM6tvgOT09PDR8+XGPGjJGnp2dmj5xKRESE/vvf/2r+/Pm6ePFimmPc3Nz0+OOP6z//+Y/q1q2b5XtI0vbt2zV+/Hht2rRJCQkJaY7x9/fXkCFDNGrUKBUvXjzTNTP6Gs+dO1dff/21goODU81r0qSJ1Y6UgYGBOnPmjCSpYsWKGR7NnN5nICEhQZMmTdIXX3yhyMjIVPOcnZ3Vs2dPTZw4URUrVsz02e6WkpKib775RpMnT9b58+dTXTcYDHrsscc0adIk1alTx9J3x93fTwAcGwV2AAAAgAMzGo0KPR0ik8lk7ygooLy8vGQ0Gu0dAwAAAAAAIEP3HuPavXt3lSxZ0k5pct69xUFZKbxJSkrSiBEj9N133yklJSXDsdHR0frmm280e/Zs/frrr+rUqdN95f3qq6/05ptvKjk5Od0x586d0/PPP68dO3Zo6tSpcnJysmntn3/+WS+99FK6xV6SdOXKFb399ttavXq1Vq5cmeX82bVt2zZ169YtzYKtO+Li4jR+/HitX79ea9euzdLP4H788UeNGDFCMTExGY5LTEzUypUrtXr1an300Uf68MMPbb5HXFycnn/+eS1atCjTsVeuXNF//vMfTZ8+XStXrtTDDz9s833uSEhI0LPPPpvukcy5ITw8XE899ZT279+f7pjk5GQtWLBAf/zxh9avX6+HHnrIprWjo6PVqVMn7dixI90xZrNZa9eu1aZNm/Tzzz+rT58+WX0EAA6CAjsAAADAwRmNRgqgAAAAAAAAUGjFxcVp7969Vn1du3a1UxrHEh8fr6efflrr1q1Lda106dIqXbq0nJycdP78eV25csVyLSYmRl27dtWvv/6qXr16ZemeU6dO1RtvvGFpFylSRIGBgSpWrJjCw8N14cIFq/HTp0/Xgw8+qDfffDPTtefPn6/nn38+VaGgp6enAgMD5ebmprNnz+ratWuSpK1bt6pPnz5q0qRJlp4hO/bs2aMnnnhCcXFxkiQnJydVqlRJJUqUUFRUlE6dOmXZ5U66vdPfwIEDbS4E/OCDD/Txxx+n6r9zpKmnp6euXLlitZtbSkqKPvroI127dk1ffvllpve4cuWKnnzySe3ZsyfVtXLlyqlUqVJKTk7WmTNnFBUVZbl26dIltWnTRuvWrVPLli1tep47Bg4caFVcV7x4cVWoUEFubm46d+6crl69mqX1MhMdHa327dvr33//tfSVLVtWZcqU0c2bN3Xy5EmrIs6rV6+qS5cuOnLkSKYnfsTFxaljx47atWtXqmsVKlRQqVKlFBUVpbCwMCUlJSkxMVH9+/dX6dKlc+4BAeQp20rEAQAAAAAAAAAAAACwg3/++SfVMaGNGjWyUxrHMnToUKviumLFiumDDz5QSEiILl68qH379mnPnj26fPmy9u/fr549e1rGJicna9CgQTp16pTN9zt16pSluK5GjRpasmSJIiMjdfToUQUHBys8PFx79uxRs2bNrOZ98MEHlqK49Jw9e1YvvviiVXFdxYoVtXDhQl27dk2HDx/W3r17FRERob/++kstWrSQJK1bt05z5syx+Rmyq3fv3oqLi5PRaNTnn3+uK1eu6NSpU9q5c6dOnDih8+fPpzoWd9WqVfr9998zXXvmzJlWxXUGg0HPPfecdu3apaioKB0+fFg7d+5UaGiowsPDNWbMGLm6ulrGf/XVV1q4cGGG90hJSVHfvn2tiuv8/Pw0efJkXbx4UefOndPu3bu1b98+Xb16VX/99ZfatWtnGRsfH69nnnkm0/fzbmvXrtX8+fMl3f7eXbdunSIjI63e07///ltly5a1ec3MjBw5Uv/++69cXFz06quv6tSpUzp//rx27dqlQ4cO6dq1a/r000+tvn7nz5/X+PHjM117zJgxVsV1BoNBgwcP1qlTp3TmzBkFBwfr5MmTunTpkiZMmKCiRYsqKSlJzz//fI49H4C8RYEdAAAAAAAAAAAAAMBh3b0DlXS7iKxq1ap2SuM4FixYoJ9//tnSrlKlivbv369x48apUqVKqcbXq1dPixYt0qRJkyx9MTExGjlypM33DA8PV2Jioh577DHt3r1bTz/9tDw8PKzGNGjQQBs3blS9evUsffHx8Zo7d26Ga48YMUKxsbGWdp06dbR371716tVL7u7uln6DwaAWLVpo69ateuaZZyRJoaGhNj9DdoWEhCgwMFDBwcEaMWKESpQoYXU9ICBAM2fO1IsvvmjVP23atEzXffXVVy3tIkWK6LffftPs2bPVqFGjVEfsBgQE6JNPPtHGjRtVpEgRS/9rr72mmzdvpnufyZMn688//7S0mzRposOHD+utt95KtcOak5OTWrRooQ0bNlhlO3/+vMaNG5fh89zt8uXLkqRevXrp77//VseOHeXiYn3gYtOmTeXn52fzmpkJCQmRu7u7VqxYoa+//lpVqlSxuu7p6amRI0dq5syZVv2zZs3SrVu30l33wIED+vbbb636pk6dqunTp6e6R4kSJfTOO+/ozz//VPHixfP0cwogZ3FELAAAAODgIiMjZTKZ7B0DBZSXlxdHEAMAAAAAAIcWGRlp1fbz85PBYLBTGsdgNpsVFBRkaRctWlTr1q1LVeCTllGjRmnXrl1atGiRpNu7q504cUIPPPCATfeuUKGCFixYoKJFi6Y7pmjRopowYYKeeOIJS9/vv/9udbTs3c6dO6fly5db2m5ublqyZEmGP7dycnLSzJkztWvXriztwpddzs7OWrRoUaZf64kTJ2rOnDmWYrf169crJSUlVaHcHZMmTVJ8fLyl/dNPP1l9/dLTqlUrffrpp3rllVck3T7+de7cuRo8eHCqsfHx8VYFlmXKlNGaNWsy/fmgk5OTvvjiC+3evVv//POPJd/YsWPl4+OTaUZJqly5smbPnp2qsC43TZgwQU8++WSGY/r166evv/5aO3fulHT767dnzx41bdo0zfHffPON1S6LAwcO1EsvvZThPRo3bqwpU6ak+Z4AyB8osAMAAAAcxGezZ6h3x04qX6aMpS8yMlKBVSorJvq6HZOhICvu462w0yEU2QEAAAAAAId1b4GdrQU9+UlQUJBVwVxm1q1bZ7Wz3xtvvGFTcd0d77//vqXAzmw2a9myZXrnnXdsmjt69Gh5e3tnOq5Dhw7y9fVVVFSUJGnv3r3pjp07d65V0dILL7ygatWqZXoPd3d3jR07Vv369bMhec7o0aOHTUcU+/r6qmPHjlq5cqWk28Vt//77r2rWrJlqbGRkpNVuhM2aNVPfvn1tzvTiiy9q7NixunLliiRpyZIlaRZz/fzzz1bfT0FBQTb/XNDZ2VljxoxR165dJUmxsbFat26d+vTpY9P8d99912qnvdxWtmxZS9FhZvr06WMpsJNuf1bTKrBLTEy0HHUr3f6a2HKkrHT7Mz1p0iSdOHHCpvEAHAsFdgAAAICD2HF4j6atmauZYz5X8/oNJEkmk0kx0dflMqObDP6edk6IgsZ8JU4xg5fLZDJRYAcAAAAAABxWTEyMVdvTk5+TrVmzxqr9f//3f1maX7duXZUuXVqXLl2SJG3bts2mAjuDwaDevXvbdA9nZ2fVqVNHW7dulSRFREQoISHB6rjXO/766y+rdlYK5rp37y5PT0/FxcXZPCc7bC0ok6T69etbCuyk2zv1pVVgt3nzZt24ccPSzur76erqqrZt22rBggWSpB07dqS5W97dnxsXF5csFfFJ0qOPPionJydLMeS2bdts+no4Ozvb/LnJKU8//bRcXV1tGlu/fn2r9rlz59Icd+DAAatjjNu0aaOAgACb7mEwGNSvXz999NFHNo0H4FgosAMAAAAcSHxyvJ79+BUF9R+pgd16WvoN/p4yBHjZMRkAAAAAAABgH8WLF7dq51UhlSPbtm2b5bWnp6cefPDBLK9Rvnx5S4HdsWPHbJoTGBioEiVK2HwPf39/q/b169dT9UnS7t27La9dXFz08MMP23yPIkWKqH79+tq+fbvNc7LDlt3r7kjr+dNy9/uZ1XvcUaFCBctrk8mk8PBwlS9f3tJnNputvkYPPPCAvLyy9jNnT09PlShRQhEREZJs/9w8+OCDqb6Pc1tuvE93f04lqXnz5lnKlNXxABwHBXYAAACAg0lWsj6YO0n/ngnRy13z9rf6AAAAAAAAAEdz78776RW/FCZ3FzbFxcWl2qksq+49hjc9aRXHZeTe3Qbv3qXtjqSkJMvRppJUuXLlNHe5y0iNGjXyrMAuK18DW55fSl2o1rhx46wHu0dkZKRVgd3ly5et3uejR4/KYDBk+x62qFSpUrbucz9y430KDw+3ateoUSNLmbI6HoDjoMAOAAAAyCWTZ03L0vgTF05btedtW6wjIcclZe+HHAAAAAAAAEB+dm+B3Z3dswqruLg4JSQk5OiathYtenh4ZOs+ZrM5VV90dLRV29vbO8vr+vj43GeirMvO1yCt55eka9eu3fea6bn3Pc2Le6Qnqzvl5YTceJ+y+1nNy88pgJxFgR0AAACQS75aPSPba+wPP6TKnZrpYlyyknMgE3C3UpdvyW1IK723+bts/3D0ZESU5fWg+R9mNxqQb1xNNMtgkIo72zsJAAAAABRc9x5/GhMTo1OnTqlq1ap2SmRf9xb55IT0Corywr3Fgm5ublleI6s73jma3HhPU1JS8vwe6XF1dc3xe9tDdj+r+f1zChRmFNgBAAAADs7sKrnEmSmwQ45zv5kizyp+OhwRkqPr7j53NEfXAxye/f4bBAAAAAAUCk2bNpWLi4uSkpIsfbt37y60BXZFixa1ahuNRi1YsMBOabLv3l3AYmNjs7yGyWTKqTh2ce97OnPmTJUrVy5ba9arVy/De9SsWVNffvlltu5RpEiRbM3Pb7L7Wc3vn1OgMKPADgAAAMgllY2BWRofEhmWqq+MZ2ntW7hehhcqcVAsclyCh5PMhy+padMmObCD3UnL62p+1bIbDcg39pw7KrMkO/6iPwAAAAAUeJ6enmrQoIGCg4MtfStXrlTfvn3tmMp+fHx8rAoOb9y4ofbt29s51f0rVqyYXF1ddevWLUnShQsXsrzG/cxxJCVLlrRq16xZU40bN87Ve5jN5nz9ubGHe4+rzurnLr9/ToHCjAI7AAAAIJdsmbYwS+N7jBqq4NA9lnbjSg01YchIPfBzNRWMDfThaC6XctWtH7bqj9GzFRgYmK21Xl8yzPL6qx7jspkMyD8e/rSnEimuAwAAAIBc1717d6sCu6VLl+ratWsqUaKEHVPZh8FgUMWKFXX69GlJtwvsLly4oICAADsnu381a9bUgQMHJEkREREKDw9X2bJlbZ6/f//+XEqWNypVqmTVPnXqVI4X2JUuXVpFihTRjRs3JElnzpzRrVu3CszxrXmhZs2aVu19+/ZlaX5+/5wChZmTvQMAAAAASO3Zlj20ZPL3cnXhd2IAAAAAAACAIUOGqFixYpZ2QkKCJk6caMdE9tW2bVur9qZNm+yUJGfcW0y2evVqm+cePXrUUmyYX+XF++nq6qoWLVpY2vHx8dq5c2eO36cgu/dzumbNGqWkpNg8f+XKlTkdCUAeocAOAAAAcCDOctbYfm9r4vB37B0FAAAAAAAAcBi+vr4aNGiQVd/nn3+eIwVCa9asyfYaee3xxx+3an/zzTd2SpIzunTpYtWeOnWqzYVL+f3ZJal9+/ZyueuXrefPn69r167l+H3u/dx8/fXXOX6PgiwgIEANGza0tC9cuKDly5fbNPfs2bNatWpVLiUDkNvYDgMAAABwEJXKlNeIZwapZYNGqa6Zr8TZIREKOj5XAAAAAAAgPwkKCtKKFSsUFhYmSUpOTla3bt20fv161alTJ8vr3bp1S2PGjNGSJUsUGhqaw2lzV7du3VS1alWdOnVKkrRz5059//33Gjp0qJ2T3Z8nnnhC5cqV0/nz5yXdPkpzypQpGjlyZIbztm/frmnTpuVFxFxVqlQp/d///Z9mzpwpSYqLi9Mrr7yi+fPn5+h9Bg8erI8//ljR0dGSpMWLF+u3335Tp06dcvQ+BdmLL76oPXv2WNpvvvmmWrduneFx1SkpKRo6dKhu3ryZFxEB5AIK7AAAAAAH8emb76bq8/LyUnEfb8UMXp73gVAoFPfxlpeXl71jAAAAAAAAZMrHx0cLFixQy5YtdevWLUnSpUuX1Lp1a3377bfq27evDAaDTWtt2bJFr7/+ug4ePKiKFSvmZmybBAUFaezYsZZ269attXnz5nTHOzs76z//+Y+eeeYZS98bb7whFxcXvfjiizbf98SJE/r000/10UcfqWzZsveVPSc4OzsrKChIgwcPtvSNGjVKzs7OeuONN9J8Xzdu3KhevXopOTlZBoNBZrM5LyPnuPfff18LFixQfHy8JGnBggXy9vbW119/LTc3N5vWiIyM1Hfffad69eqpc+fOqa57e3vrnXfe0ZgxYyTdLvx65plnNHfu3FS7CGZkz549mjRpkhYsWGDznIJiwIAB+uyzz3Ty5ElJ0pkzZ9ShQwctXrxYlStXTjXeZDJp6NChWrNmTYH4nAKFFQV2AAAAgAMzGo0KOx0ik8lk7ygooLy8vGQ0Gu0dAwAAAAAAwCaNGzfW9OnT9cILL1iOEI2KitKzzz6rKVOmaNCgQXriiSdUoUKFVHNPnjypVatWafHixfr7779tut+ePXsUFRWVqv/y5cup+jZu3JjmGr6+vlbHSuaUvn37avPmzfrhhx8k3d6R76WXXtL8+fM1YsQItW3bVp6enlZzbt26paNHj+rPP//UkiVLtH37dpnNZr37bupf/s1rgwYN0vz58y1fR7PZrBEjRuinn35S37599eCDD8rV1VVnzpzRqlWrtH79eklS0aJF1aNHD82ZM8ee8bOtcuXK+vHHH62KJqdNm6bNmzfrrbfeUpcuXVSqVCmrOWazWSEhIdqxY4eWLVumtWvX6saNG5ad8NLy9ttva9u2bZajkWNiYtStWzd169ZNr776qlq0aCF3d3erOTdv3tTBgwe1ceNGLVmyRHv37pWkQllg5+HhoenTp6tdu3aWfwbt27dPtWvXVq9evdS2bVv5+/vr+vXr2r17t3755RddunRJkjRkyBBNnTrVnvEB3CcK7AAAAAAHZzQaKYACAAAAAAAA/r8BAwbI29tbAwYMsPrF1F27dmnXrl2Sbv9Mzc/PT97e3rp27ZouXrxo2RnsXmXKlEn3XiNHjtSWLVtsytWhQ4c0+zPbjS47vv76a0VFRWnhwoWWvk2bNmnTpk1ycXFRxYoVZTQalZSUpOjoaIWHhysxMTFXsuSERYsWqX379lZHcB46dEiHDh1Kc7yzs7NmzZqlI0eOWPW7uOTPUoi+ffvqwoULGjVqlKV468SJE3rppZf00ksvqXz58ipZsqRcXFwUHR2tS5cuKSYmJkv3cHJy0i+//KJu3bpZPpdms1nLli3TsmXL5O7urooVK8rX11c3b95UdHS0zp8/r+Tk5Jx+3HyrdevWmjlzpp5//nnL+3Tjxg39/PPP+vnnn9Oc06RJE33++edWBXb59XMKFEZO9g4AAAAAAAAAAAAAAEBWdOvWTQcOHFDXrl3TvB4ZGanjx48rODhYp0+fTrO4rkSJEpoyZYq2bt2a23FzjaurqxYsWKCJEyeqSJEiVteSkpJ0+vRp7dq1S/v27VNoaGiaxXUlS5ZMNddefHx8tHHjRg0YMCDTsSVLltTy5cvVq1cvxcbGWl3z9vbOrYi57s0339SaNWvSLPw8d+6c9u3bp127dunkyZNpFte5u7vL398/w3t4e3trw4YNevPNN1MVeSUkJOjEiRPauXOnDhw4oDNnzqRZXFe+fPksPlnB8txzz2nlypUqV65cpmN79eqlDRs2pPo65ufPKVDYUGAHAAAAAAAAAAAAAMh3AgMDtXz5cu3bt0/Dhg1T6dKlM53j6empJ554QvPnz1d4eLiGDx8uV1fXPEibu95++22FhobqrbfeSvN43HuVLl1a/fv319KlS3XhwoVUR4/ak4+Pj2bNmqVdu3bpjTfeUO3ateXr6ysXFxf5+/urXbt2mjJlik6fPq2nnnpK0u2Cyrvl98Klxx57TCEhIfrqq69Ut25dGQyGDMcXK1ZMnTp10vfff6+LFy/qySefzPQeLi4u+uyzz3T8+HG99NJLmRblSbe/51566SWtX79eYWFhtj5OgdWpUycdO3ZM06ZNU8eOHVW+fHm5ubmpaNGievDBBzV48GD99ddfWrhwoYoXL17gPqdAYWIwm81me4eAYzty5Ihq165taR8+fFi1atWyYyIAQH7x3+4f6viOI6revJbGLBtn7zhAnnh80BMyGAwym81a++PvObJmZGSk1VEXQE7y8vLKkSOIX18yzPL6qx7fZXs9IL94+NOeSjRLbgZp11uL7R0HAAAAyFeSkpJ08uRJq75q1apxZB6y5fTp0zp8+LDOnTunmJgYmc1m+fj4yGg0qmbNmqpVq5acnZ3tHTPXnTp1Svv371dERISioqLk4uIib29vVahQQTVq1FBgYKC9I+aoRo0aWY6VdXNzU0xMjNzc3OycKudERERo586dunTpkq5du6aUlBR5eXmpdOnSqlGjhqpVq5btQlGz2awjR47oyJEjunr1qqKjo+Xu7i5vb29VqlRJNWvWVEBAQA49UeG0evVqde7c2dIOCgrSRx99ZMdEKExy6+9dhaWmiL+dAgAAAA4i+NBBNapVW05O/9toOjIyUoFVKism+rodk6EgK+7jrbDTITlSZAcAAAAAAGBvVapUUZUqVewdw+6qVq2qqlWr2jtGnrh69aoOHjxoadetW7dAFddJkp+fn2W3vtxiMBhUu3Ztq0IZ5Kw//vjDqt2oUSM7JQGQVRTYAQAAAA5i4s/f69atW1ow4VsV8XCXJJlMJsVEX5fLjG4y+HvaOSEKGvOVOMUMXi6TyUSBHQAAAAAAAPKl77+//XPVO1q0aGHHNEDaTCaTZs+ebWm7uLioSZMmdkwEICsosAMAAAAcyL7zB9Xq5V5aMWm6AvxLWfoN/p4yBHjZMRkAAAAAAAAA5C6z2SyDwWDz+AMHDuiTTz6x6nvhhRdyOhaQSlY+q2azWUOHDlVUVJSlr3PnzipZsmRuxQOQw5wyHwIAAAAgL12KvaR2r/fVzoP77R0FAAAAAAAAAPLMvHnz9Nxzz+nAgQOZjl2yZInatGmjmzdvWvratWununXr5mZEQJLUoUMHzZgxQ3FxcRmOu3Tpknr37q1ffvnF0mcwGDR8+PBcTgggJ7GDHQAAAOCA4pLi1HfcML3Z9UV7RwEAAAAAAACAPJGUlKQ5c+Zozpw5qlmzptq1a6d69erJ399fLi4uioyM1KFDh/Tbb7/pyJEjVnOLFy+uGTNm2Ck5CptTp07pxRdf1BtvvKGOHTuqcePGqly5sry9vRUXF6cLFy5o27ZtWrVqlVURqCQNGzZMrVq1slNyAPeDAjsAAAAgl5Tv2Thb85OUpMkrpiqgQS1F5FAm4G6lLt+S25BWem/zd/Lw8MjWWicj/ne8waD5H2Y3GpBv3DLf/t8U+8YAAAAAAKDAOXr0qI4ePWrTWG9vby1ZskSVKlXK5VSAtfj4eC1fvlzLly+3aXzPnj316aef5m4oADmOAjsAAADAgZlllnOgp4qfSVRsgL3ToKBxv5kizyp+OhwRkqPr7j5n2w8+gYIk2WzvBAAAAAAA5H8lS5aUu7u7EhISbJ7TsWNHffHFF6pRo0YuJgOslStXTmfOnLF5fIkSJTR69GiNHDlSBoMhF5MByA0U2AEAAAAOzEUuMu0PV8zAauJfuZHTEjycZD58SU2bNsmBHexOWl5X86uW3WhAvkFBKQAAAAAAOeepp57SlStXtG7dOv311186ePCgQkNDde3aNd24cUNFixaV0WhUYGCgWrdurc6dO6tRo0b2jo1C6K+//tL+/fu1ceNG7dy5UydPntT58+cVGxurlJQU+fr6qmTJkmrUqJHatm2rnj17qlixYvaODeA+UWAHAAAA5JJzi4OzNL7HqKEKDt1jaXu6FNPkQaPVpeNjcs3pcICky6VcdeuHrfpj9GwFBgZma63XlwyzvP6qx7hsJgPyj/qTe4rN6wAAAAAAyDleXl7q1auXevXqZe8oQIbq16+v+vXr2zsGgDxAgR0AAADggMoUK6OVk2foZlycvaMAAAAAAAAAAAAAhZaTvQMAAAAAsNagfD1tm7ZQpf387B0FAAAAAAAAAAAAKNQosAMAAAAchJPBSb2adtWKKdPl7uZu7zgAAAAAAAAAAABAoccRsQAAAICD+HpUULq71pmvcFQsch6fKwAAAAAAAAAAgIxRYAcAAAA4iLSK67y8vFTcx1sxg5fnfSAUCsV9vOXl5WXvGAAAAAAAAAAAAA6JAjsAAADAgRmNRoWdDpHJZLJ3FBRQXl5eMhqN9o4BAAAAAAAAAADgkCiwAwAAAByc0WikAAoAAAAAAAAAAACwAyd7BwAAAAAAAAAAAAAAAAAAwBGxgx0AAADg4CIjIzkiFrmGI2IBAAAAAAAAAADSR4EdAAAA4CASEhPk7uZu1RcZGanAKpUVE33dTqlQ0BX38VbY6RCK7AAAAAAAAAAAANJAgR0AAADgIIaMf08t6zbW4B69LX0mk0kx0dflMqObDP6edkyHgsh8JU4xg5fLZDJRYAcAAAAAAAAAAJAGCuwAAAAABxETH6exv36qf8+c0qdvvmt1zeDvKUOAl52SAQAAAAAAAAAAAIWTk70DAAAAALC2YMdydRv5khISE+wdBQAAAAAAAAAAACjUKLADAAAAHNCeM/vVakhvXY2KtHcUAAAAAAAAAAAAoNDiiFgAAAAgl5Tv2Thb8y/EXFT/CSPlWcKoxBzKBAAAAAAAAAAAAMB2FNgBAAAADiwuOU4lWz8g07lExQXYOw0KmlKXb8ltSCu9t/k7eXh4ZGutkxFRlteD5n+Y3WhAvmG+538BAAAAAAAAAAULBXYAAACAgzNEJSu2jKsM9g6CAsf9Zoo8q/jpcERIjq67+9zRHF0PAAAAAAAAAADAXiiwAwAAAHJJ6PwdWRrfe/Sr2hW216qvR6NO+nJMkFxHPJCT0QBJUoKHk8yHL6lp0yY5sIPdScvran7VshsNyDcoKAUAAAAAAACAgo0COwAAACCXuLhk7a/bBsP/9qhzkYvGDXhbj9Spry/HBOVwMuC2y6VcdeuHrfpj9GwFBgZma63XlwyzvP6qx7hsJgPyj3qTe9o7AgAAAAAAAAAgFznZOwAAAAAAa0Wdi+qX97/V/3XuZu8oAAAAAAAAAAAAQKFGgR0AAADgQEp5+uuPr+arWf2H7B0FAAAAAAAAgAMbOHCgDAaD5U9YWJi9IxV4mzdvtvqaBwUFZTg+MDDQMja7J0gAAOyHI2IBAAAAB9Gn/VPq3Lq9ini4p7pmvhJnh0Qo6PhcAQAAAACAgiY0NFSHDx/WuXPnZDKZlJKSIl9fX/n6+qpGjRqqXbu2nJ2d7R0TAADkIxTYAQAAAA6i92OdUvV5eXmpuI+3YgYvz/tAKBSK+3jLy8vL3jEAAAAAAADu26FDhzRt2jQtW7ZM4eHhGY4tWrSoWrRoof79+6tHjx7y9PS06R4REREKDg62+hMZGWk1xmw23/czAAAAx0WBHQAAAODAjEajwk6HyGQy2TsKCigvLy8ZjUZ7xwAAAAAAINvGbv2vvSMUGB+1GmPvCDY5e/asRowYoaVLl9o8Jz4+Xhs2bNCGDRv02muvafTo0RoxYoQ8PDxSjT127JjGjh2r4OBghYaG5mR0AA7GYDBYXrdu3VqbN2+2XxgADocCOwAAAMDBGY1GCqAAAAAAAACAu6xevVr9+/fX9evX07zu6+srPz8/eXt76+rVq7p8+bLi4+OtxphMJr377rtaunSpdu3alWqN48ePa8GCBbmSHwAA5B8U2AEAAAAAAAAAAAAA8o158+ZpwIABSk5Otupv2LChBg0apCeffFIVK1ZMNe/48eNasWKFFi5cqD179lj6IyIispyhWLFiio2NzXp4FCphYWH2jgAAyAFO9g4AAAAAAAAAAAAAAIAtdu/erRdeeMGquM7b21tz5szRrl27NHTo0DSL6ySpevXqevvtt7V7924tXbpU1atXt+meRYoUUbNmzfTGG29o7ty5On78uA4ePJgjzwMAABwfO9gBAAAADi4yMlImk8neMVBAeXl5cQQxAAAAAADIF0wmk/r06aPExERLn7+/v9atW6f69etnaa3u3burU6dOGjZsmDZu3JjmmMaNG2vv3r2qU6eOXFys/9M6O5MBAFB4UGAHAAAAOIjPZs9Q746dVL5MGUtfZGSkAqtUVkz0dTsmQ0FW3MdbYadDKLIDAAAAAAAOLygoSCEhIZa2k5OTli9fnuXiujvc3Nw0Y8YMLV26NM3rAQEBCggIuK+1AQBAwUGBHQAAAOAgdhzeo2lr5mrmmM/VvH4DSbd/Kzcm+rpcZnSTwd/TzglR0JivxClm8HKZTCYK7AAAAAAAgEOLjo7W9OnTrfqGDx+uZs2aZXvtp59+OttrOKIbN25o69at+vfffxUbGytfX18FBgaqdevW8vTM3s8aQ0NDdeTIEZ09e1bXr1+Xi4uLjEajKlasqKZNm6pYsWI59BT/c/36dW3dulWnTp3SjRs3VKJECVWtWlUtW7aUu7t7tta+deuWtmzZopCQEF29elWenp6qVq2aHnnkERUvXjyHniB7bt26pR07dujw4cOKjo6Wl5eXypcvr9atW8vX1zdba5vNZgUHB+vYsWO6dOmSXFxcVLFiRbVo0cKhi0xTUlJ09OhRHTx4UBEREYqJiZGbm5uKFSum8uXLq2rVqqpevbqcnJzyPFtsbKyOHDmif//9V9euXdONGzfk7e2tkiVLqkGDBnrggQdy5D5JSUnavn27Tp06pcuXL8vDw0NVqlTRI488kis/842OjtaOHTt08eJFRUREyMPDQ35+fnrooYdUs2bNHL8f4CgosAMAAAAcSHxyvJ79+BUF9R+pgd16WvoN/p4yBHjZMRkAAAAAAABgPz/88INiY2MtbTc3N40ZM8aOiRzX9evXNXbsWE2bNk1xcXGprru5uWnQoEEaN26cSpYsadOaN2/e1G+//aalS5dq06ZNunTpUrpjnZ2d9eijj2rMmDFq06aNzbnbtGmjLVu2WNpms1mSdPHiRb333nuaN2+e1fHAd3h6emr48OEaM2ZMlgsHb9y4oXHjxmnatGmKjIxMdd3d3V3PPfecPvnkE5u/VncLDAzUmTNnJEkVK1bM8GjhoKAgjR071tL+888/1aZNGyUkJGjSpEn64osv0szo7Oysnj17auLEiapYsWKW8qWkpOibb77R5MmTdf78+VTXDQaDHnvsMU2aNEl16tSx9N3RunVrbd68OUv3zAkmk0kTJkzQrFmzdPHixQzHenl5qVWrVurfv7/69Oljde3ez9wdW7ZssXrOe3300UcKCgpK1X/ixAn9+uuvWrt2rXbv3q2kpKR01yhdurSGDh2q11577b4KJBMSEvTJJ5/ou+++09WrV1Ndv/O5mDRpkipUqKCwsDBVqlTJcn3AgAGaNWuWzfdbtWqVPv30U+3YsSPd56pQoYKGDx+uYcOGZbvoFXA0eV+mCwAAACBDyUrWB3MnafSXk+wdBQAAAAAAAHAI9x7j2r179/sqeHJUQUFBMhgMlj9ZKUy729GjR1WvXj1NmTIlzeI6SUpMTNT333+vpk2bZljwdbeWLVuqZ8+e+uWXXzIsrpOk5ORkrV+/Xm3bttWrr76aYZFRZrZt26batWtr5syZaRbXSVJcXJzGjx+vtm3bplmAlp7Q0FDVq1dPEyZMSHdeQkKCpk+frnr16unQoUP39QzZER4erqZNm+rDDz9MN2NycrIWLFigRo0aad++fTavHR0drUceeURvvPFGmsV10u0ix7Vr16pRo0ZasGDBfT1DTjtw4IBq1Kih//73v5kW10m3i/FWr16tkSNH5mqu1atXq3r16goKCtI///yT6ef+0qVL+uijj1SnTh3t2rUrS/c6e/as6tevr3HjxqVZXCf973NRt27dNIsIbXXlyhW1bdtWXbp00datWzN8rrNnz+rNN99U3bp1dfr06fu+J+CI2MEOAAAAyCWTZ03L0vgTF6z/hXPetsU6EnJcUvq/KQcAAAAAAAAUdHFxcdq7d69VX9euXe2UxnGFhYXpmWeesSqAq1ixovz9/RUbG6sTJ04oOTnZcu306dN6+umnFRwcLBeXjEsHbt68maovICBARqNRxYoVU1xcnOW42Lt9++23io+P108//ZTl59mzZ4+eeOIJS6Ggk5OTKlWqpBIlSigqKkqnTp2y7HInSbt27dLAgQO1cuXKTNe+cOGC2rVrl6rA0NnZWZUqVZKPj48uXLigCxcuWMY//vjj+vzzz7P8HPcrOjpa7du317///mvpK1u2rMqUKaObN2/q5MmTSkhIsFy7evWqunTpoiNHjsjLK+PTUOLi4tSxY8c0C7sqVKigUqVKKSoqSmFhYUpKSlJiYqL69++v0qVL59wD3ofLly/r0Ucf1bVr16z67xxpe+dI1OvXr+vs2bNpfm5zS1r3KlKkiMqXL6/ixYvLYDDo2rVrOnPmjFJSUixjwsPD1aZNG+3evVs1atTI9D6XLl1S27ZtFRISYtVvMBgs3x/Xrl1TaGiozGazrl+/rs6dO2vhwoVZfqaTJ0/qscceU2hoaKp7VaxYUSVLllRCQoJCQ0Otdhg9ceKEmjVrpr/++ivHjsIF7I0COwAAACCXfLV6RrbX2B9+SJU7NdPFuGQlZz4cyJJSl2/JbUgrvbf5O3l4eGRrrZMRUZbXg+Z/mN1oAAAAAAAAFmntBtWoUSM7pXFcgwYN0qVLl1SkSBGNGjVKQ4YMUUBAgOV6VFSUJk6cqEmTJlkK0/bt26fp06dr6NChma5foUIF9erVS08++aQaNWqUqojLbDbr0KFDmjp1qqZNm2Yp5ps5c6Y6d+6s7t27Z+l5evfurbi4OBmNRr3//vt67rnnVKJECcv1Cxcu6L333rM65nLVqlX6/fff9cQTT2S49qBBg6yK69zc3PTuu+9q6NCh8vf3t/QfOXJEH374oZYuXaoLFy5o9OjRWXqG7Bg5cqRCQkLk4uKil19+WcOHD1eVKlUs1+Pi4jR16lSNGTNGt27dkiSdP39e48eP18SJEzNce8yYMVbFdQaDQYMGDdLo0aOt7nHt2jXNmDFD48aNU3x8vJ5//vkcfsqsGTdunFVxXeXKlTV+/Hh17tw51fHAycnJOn78uNatW6fFixfr7Nmzqdb77LPPFBV1++eaHTp0sPTXrVtXn332Wbo5KleunGa/s7OzHn/8cXXp0kXt2rVT5cqV5eRkfbBkTEyMVq5cqXHjxunEiROSpPj4eD377LPau3dvhkfTStKQIUOsiutcXFz01ltv6bXXXrP6fg8PD9dXX32lzz//XDExMRo2bFiG694rPj5eXbt2tSquq1SpkkaPHq1evXpZHWublJSkjRs36r333rMUQ0dERKhPnz76559/OC4WBQIFdgAAAICDM7tKLnFmCuyQ49xvpsizip8OR4RkPjgLdp87mqPrAQAAAACAwu3uHbwkqVixYqpataqd0jiukJAQGY1GrV27Vg8//HCq676+vpowYYKKFy+u999/39I/bdq0TAvsvv/+ezVv3lzOzs7pjjEYDKpbt66+++47de/eXZ07d7bssDZhwoQsF9iFhIQoMDBQGzdutCr6uiMgIEAzZ86Uq6urpk+fbvU8GRXYLVy4UGvXrrW03d3dtWbNGrVr1y7V2Fq1amnJkiV6//33NX78eJuP1M0JISEhcnd319KlS/Xkk0+muu7p6amRI0eqdOnS6t+/v6V/1qxZ+vjjj+Xq6prmugcOHNC3335r1Td16lS99NJLqcaWKFFC77zzjtq2bav27dun2sksry1evNjy2s/PT3///bdVQeTdnJ2dVbNmTdWsWVMjRozQsWPHUo1p2LBhmnN9fX3Vvn37LGVr2LChTp8+rYoVK2Y4rnjx4urXr5969OihHj16aM2aNZKk/fv3a+3atRl+dletWmW1Q6Orq6uWLVumTp06pRpbtmxZTZw4US1bttTTTz+d5fdu5MiRVl+zzp0765dfflGxYsVSjXVxcdHjjz+utm3b6plnntGyZcssz/Tdd99pxIgRWbo34IgosAMAAABySWVjYJbGh0SGpeor41la+xaul+GFShwUixyX4OEk8+FLatq0SQ7sYHfS8rqaX7XsRgPyDQpKAQAAACD3RUZGWrX9/Pwy3eWpsPrxxx/TLK672zvvvKOpU6fq/Pnzkm4XwVy+fFmlSpVKd84jjzySpRwdOnTQqFGj9PHHH0uSgoODdfToUdWsWdPmNZydnbVo0aI0i+vuNnHiRM2ZM8dyROf69euVkpKSauewO6ZMmWLVHj9+fJrFdXf7+OOPFRwcrA0bNticPydMmDAhzeK6u/Xr109ff/21du7cKUm6cuWK9uzZo6ZNm6Y5/ptvvrE6onTgwIFpFtfdrXHjxpoyZYoGDx6cxSfIOdHR0bpy5Yql3aNHj3SL69Jiy/Gr2VGpUqUsjffw8NCcOXNUuXJly9HKM2fOzLDA7quvvrJqv/fee2kW192tc+fOGj16tOV70Rbnzp3TjBn/O6Gnbt26WrRoUaY70bm7u2vu3LmqVauWpRj1yy+/1Ouvv55hcS6QH1BgBwAAAOSSLdMWZml8j1FDFRy6x9JuXKmhJgwZqQd+rqa0f9cQyJ7LpVx164et+mP0bAUGBmZrrdeX/O+Iga96jMtmMiD/qDe5p70jAAAAAECBd2+BnY+Pj32C5KKgoCAFBQVla43GjRurW7dumY5zcXHR008/bVWss2fPnkwLubKqf//+VkU9O3bsyFKBXY8ePWw6CtjX11cdO3a07OwVHx+vf//9N817HTt2TP/884+lXbZsWb3++us25Zk8ebLq169vW/gcULZsWb3yyis2je3Tp4+lwE6S9u7dm2aBXWJioubPn29pOzs7a/z48Tbd44UXXtCkSZMsx5rmtRs3bli109uhLz8xGo164oknLO/Jjh070h0bHh6uP/74w9L28fHRO++8Y9N9xowZo6+//tpSyJeZb7/91upY7smTJ9t8zGvRokU1YsQIvfHGG5KkM2fOaPfu3WrSpIlN8wFHlXbJNgAAAAC7erZlDy2Z/L1cXfidGAAAAAAAABRuMTExVm1PT087JXFsffr0sXnsvYVi586dy+E0qXf02rdvX5bm58bzbN682ardt29fmwu16tWrl6cFdk8//bTN2Wx9/gMHDig2NtbSbtOmjQICAmy6h8FgUL9+/WwamxtKliwpNzc3S3v16tU2F4w5sru/T8LDwxUREZHmuB07dshsNlvaPXr0sPlUkqJFi+rpp5+2OdOdY2slqXTp0lk+Lrdjx45W7W3btmVpPuCIKLADAAAAHIiznDW239uaONy23zwDAAAAAAAACrrixYtbtePi4uyUxLHZstvbHfcerZmVQqXg4GC9++67evLJJ1W5cmUZjUa5urrKYDBY/bl3x6urV6/afA8pd54nODjYqt2mTZssZcrq+OzIjeffvXu3Vbt58+ZZypTV8TnJ1dVVrVu3trRDQ0PVtm1brVu3zurIW0cQHR2tH3/8Uc8//7waNGigMmXKyNPTM9X3iMFg0H//+1+ruel9n+TVexcVFaXDhw9b2g0aNEj3uOX0VKhQwap97NixLM0HHBHbYQAAAAAOolKZ8hrxzCC1bJD6ByfmK/zQEDmPzxUAAAAAAMgPjEajVbsg7FqVG+4tssrIvbsA3nv8Zlq2bdumV199VQcPHsxyNul20VFW5MbzhIaGWrVr166dpUx16tTJ0vjsyI3nDw8Pt2rXqFEjS5myOj6nffDBB/rjjz8sBXX79u3T448/rlKlSunxxx9XmzZt1KxZM1WvXt0u+eLi4jR27Fh99dVXSkhIuK810vs+yav37vjx41Y75a1Zs0YGgyFL97rXvcd8A/kRBXYAAACAg/j0zXdT9Xl5eam4j7diBi/P+0AoFIr7eMvLy8veMQAAAAAAANJ1b4FdekcoFna2HheZlrsLatLyww8/aOjQoZmOy0hWC45y43nuLV4qUaJEltbN6vjsyIvn9/b2ztK6Pj4+95koZzzyyCOaMWOGXn75ZSUmJlr6L1++rNmzZ2v27NmSbh9r+uijj6pPnz56/PHHbT5qNzuuXr2qdu3a6dChQ9laJ73vk7x6765du5aldW1BUTQKAgrsAAAAAAdmNBoVdjpEJpPJ3lFQQHl5eaX6ITUAAAAAAIAjefDBB63aMTExOnXqlKpWrWqnRIXLn3/+maq4zsXFRS1btlSTJk1UsWJF+fv7y8PDI9WxsB06dMjruBmKjY21ahctWjRL8+/dKS6/ubd4y83NLUvz731/7eH5559Xs2bNNHbsWC1dutSq0O6OS5cuad68eZo3b54CAwP1ySef6JlnnsnVXL169UpVXFe+fHm1bdtWNWvWVLly5VSsWDEVKVLE6sjVn3/+WXPmzMl0/bx677K606QtHO0IX+B+UGAHAAAAODij0UgBFAAAAAAAAAqtpk2bysXFRUlJSZa+3bt3U2CXR0aOHGlVXNepUydNnTpV5cqVy3De/R6RmZvuLZCLj49X8eLFbZ4fFxeX05Hy1L27nt1bcJgZR/lF8AcffFC//vqroqKitH79em3evFlbt27VsWPHUu3eFxYWpmeffVbBwcGaMmVKruRZuXKlNm/ebGkXL15c33//vZ555hmrYrq0/PHHHzbdI6/eu3uLTtu2bat33019+k5W+Pr6Zms+4AgosAMAAAAAAAAAAAAAOCxPT081aNBAwcHBlr6VK1eqb9++dkxVOJw4cUL79u2ztGvXrq2lS5fatHtWZGRkbka7L/cek3n16tUsFdjlxvGZeeneX+S+cOFCluZndXxu8/X1VZ8+fdSnTx9Jt9/PLVu2aOXKlVq8eLHi4+MtY7/44gs1a9ZMvXv3zvEc8+fPt2r/8MMPNu+YZ+v3SVrvXf369W2ae2e8LUqWLGnV9vDwUPv27W2+D1BQZVwqCwAAAAAAAAAAAACAnXXv3t2qvXTp0nxf7JQf/PPPP1btwYMH23w05ZEjR3IjUrZUrlzZqn348OEszT948GBOxslzNWvWtGrfXTxpi/379+dgmpxXsmRJ9ejRQ7Nnz9aZM2f05JNPWl3/7LPPcuW+d3+flChRIktFfLZ+n+TVe1epUiWr9qlTp7J0H6CgYgc7AAAAwMFFRkY6zNb7KHi8vLw4ghgAAAAAADi8IUOGaPz48ZZjERMSEjRx4kRNmjTJzskKtsuXL1u1q1evbvPcTZs25XScbHv44Yc1a9YsS3vLli3q3LmzzfO3bNmSC6nyTuPGja3aa9asUUpKSqbHmN6xcuXK3IiVK0qWLKlffvlFZcuWtRztu3v3biUkJMjd3T3VeIPBYDle9t5jZjNz9/dJ1apV5ezsbNM8k8mkPXv22DT23vdu9erVeu+992zOaOt7V65cOVWtWtVSWHfy5EmdO3dO5cuXt/leQEFEgR0AAADgIIIPHVSjWrWtfpgRGRmpwCqVFRN93Y7JUJAV9/FW2OkQiuwAAAAAAIBD8/X11aBBg/Tll19a+j7//HP16NFDTZo0ydbaa9asSbXTFW67t9AoMTHRpnkJCQn66aefciNStrRp08aqPX/+fP33v/+Vq6trpnMPHDjg8Du4ZSYgIEANGza0FHVduHBBy5cv19NPP53p3LNnz2rVqlW5HTFHeXt7q3bt2tq5c6ckKSUlRZGRkSpTpkyqsZ6enpYC3ruPlrXF3d8ntn6PSNJPP/2kmzdv2jT24YcfVqlSpSzFfP/884/27Nmjhg0bZjo3ODhYu3btsjnX448/rm+++cbS/uabbzRx4kSb5wMFEQV2AAAAgIOY+PP3unXrlhZM+FZFPG7/Bp3JZFJM9HW5zOgmg7+nnROioDFfiVPM4OUymUwU2AEAAAAAAIcXFBSkFStWKCwsTJKUnJysbt26af369apTp06W17t165bGjBmjJUuWKDQ0NIfTFgylS5e2av/111/q0qVLpvM++OCDVLvfOYKaNWuqSZMmloKr8PBwffXVVxo5cmSmc0eNGpXb8fLEiy++aLVr2ptvvqnWrVurRIkS6c5JSUnR0KFDbS4GcyRXr161avv6+qY5zmg0Wgrs7vwzxlalS5e2/DPkyJEjio6Olo+PT4ZzwsPDNXbsWJvv4erqqueff14TJkyw9A0dOlRbt26Vh4dHuvNu3Lihl19+2eb7SNKIESM0depUJSUlSZK+/vpr9enTRw0aNMjSOkBBQoEdAAAA4ED2nT+oVi/30opJ0xXgX8rSb/D3lCHAy47JAAAAAAAAAPvy8fHRggUL1LJlS926dUuSdOnSJbVu3Vrffvut+vbtK4PBYNNaW7Zs0euvv66DBw+qYsWKuRnbJkFBQVbFNq1bt9bmzZvtF+j/a968uVV76tSpeumll1S1atV05/zwww/69NNPczvafRs+fLieeeYZS/u9995TgwYN1LZt23TnfPDBB9qwYUNexMt1AwYM0GeffaaTJ09Kks6cOaMOHTpo8eLFqly5cqrxJpNJQ4cO1Zo1a6yOUc1rmzZt0vr16/X6668rICDApjnLli3T6dOnLe2aNWumW4xWq1YtnT17VtLtorzNmzen2vEwPc2bN7cU2CUmJmrMmDH6/vvv0x0fERGhp556StHR0Tatf8eIESM0bdo0RUZGSpJ27dqlrl27as6cOfL39081/vLly+rXr5/27duXpfeucuXKGjRokH744QdJt4v0nnrqKS1ZskTNmjWzOe+mTZs0f/58TZs2zeY5gKOy7SBtAAAAAHnmUuwltXu9r3Ye3G/vKAAAAAAAAIBDady4saZPny4np//9p+6oqCg9++yzatKkiX744QdLkcy9Tp48qc8//1zNmzdXmzZtdPDgwUzvt2fPHm3cuDHVn+3bt6cam9a4jRs3Wu0Wlt9UrVrVqqAmJiZGrVq10qJFiyy7W91x4MAB9enTRy+//LLMZrNq1KiR13Ft0rdvX7Vv397STkhI0OOPP66xY8cqIiLCauzRo0fVs2dPffzxx5KkwMDAvIyaKzw8PFJ9D+3bt0+1a9fWgAEDNGvWLK1Zs0a//vqrRo4cqerVq+uXX36RJA0ZMsResWUymTRx4kQFBgbqySef1I8//qgTJ06kWTR27tw5ffjhh+rTp49V/4svvpju+h07drRqd+/eXaNHj9aiRYu0fv16q+/pkJAQq7HPPfecVXvq1KkaMGCAzpw5Y9UfExOjH3/8UXXr1rUcN5yV7xN/f3+rY7Ilaf369apevbqGDh2qefPm6ffff9fcuXP18ssvq3r16vrjjz8kZf29mzJlih566CFL++LFi2rVqpWef/55/fPPP6m+/yUpNjZWf/31l9577z09+OCDevTRR7V+/fos3RdwVOxgBwAAADiguKQ49R03TG92Tf9f+AEAAAAAAIDCaMCAAfL29taAAQNkMpks/bt27dKuXbsk3T7u0c/PT97e3rp27ZouXryo+Pj4NNcrU6ZMuvcaOXKktmzZYlOuDh06pNnvKLvR3a9PP/1Ubdq0sewaePHiRfXu3VvFihVTtWrV5OTkpPPnz1sdCevp6al58+Y57JGSM2fOVMuWLS0FUImJiQoKCtLHH3+sSpUqycfHRxcvXtT58+ctc8qWLasJEyaob9++9oqdY1q3bq2ZM2fq+eefV0pKiqTbu5T9/PPP+vnnn9Oc06RJE33++eeaOnWqpc/FJe9LTm7duqXff/9dv//+uySpePHiKlOmjHx8fJSSkqILFy7owoULqea1bNlSr732WrrrPvfccxo/frzlSNno6GhNnDgxzbEfffSRgoKCLO2OHTvqySef1Jo1ayx9d76WlStXlp+fn6KjoxUaGqrExETLmGeffVbVqlXL0lGx/fv3V1hYmD744ANLX3R0tKZOnWr13tytW7duGjVqVJbeuyJFimjlypV68skndejQIUlSUlKSZs2apVmzZsnT01Ply5eXt7e34uPjFRUVpfDwcLvtcAjkNgrsAAAAgFxSvmfjbM1PUpImr5iqgAa1FJH5cCDLSl2+JbchrfTe5u/SPRrBVicjoiyvB83/MLvRAAAAAAAAMtStWzcdOHBAw4cP14oVK1Jdj4yMtByjmJ4SJUro/fff1yuvvJJbMQuE5s2ba/r06XrxxRctRXbS7d2q9u3bl2q8r6+vli5darX7laMpV66c/vjjDz322GNWR4gmJSVZjk69W0BAgNauXWspvioInnvuOZUoUUIvv/yyVSFhWnr16qUff/xRycnJVv3e3t65GdEmMTExiomJyXBMly5dNG/ePDk7O6c7xmg0asmSJerVq5euXLmS5Rzz5s3TY489puDgYKv+kJCQVDveSbd3Upw5c6Y++eSTLN/r/fffV7ly5fTmm28qKioq3XEGg0HDhg3TlClTdPz4catrtrx35cqV099//62XX35Z8+bNsyqei4uL07///pvpGhUqVMh0DJAfUGAHAAAAODCzzHIO9FTxM4mKDbB3GhQ07jdT5FnFT4cjUv+AJzt2nzuao+sBAAAAAACkJTAwUMuXL9f+/fs1ffp0LV26VJcuXcpwjqenp1q1aqUBAwaoW7ducnd3z6O0+duAAQNUvXp1vfPOO9q6dWuaYzw8PPTss8/q448/znBXQEdRpUoVHTx4UOPGjdO0adPSLFRyd3fXc889p08++UQlS5bM1zsRpqVTp046duyYfv31Vy1evFjHjh3T5cuX5eLiogoVKqhly5YaOHCgWrRoIUmpjl/OywK7Tp06acOGDVq1apU2bdqkI0eOZLhbmrOzs9q1a6fXX39dTz31lE33aNWqlf7991/98ssvWrdunQ4fPqyrV68qLi7OstNfenx8fLR161aNHz9eX331la5fv57muFq1aum9997TM888Y1Om9AwcOFBPPfWU5s6dq2XLlunUqVOKiIiQu7u7KleurDZt2mjw4MGqU6eOJKUqOLb1vfP09NScOXM0atQoTZgwQb///ruio6MznPPggw/qscceU58+fayOmAbyM4OZ/RmRiSNHjqh27dqW9uHDh1WrVi07JgIA5Bf/7f6hju84ourNa2nMsnH2jgPkiccHPSGDwSCz2awj169lez0Xuci0L1wxXzwiQ4BXDiQE/sd/3zW57b6kpk2b5MAOdv/7zd5qftWyGw3IN+4uKD0warEdkwAAAAD5T1o7RVWrVs0uRw6i4Dh9+rQOHz6sc+fOKSYmRmazWT4+PjIajapZs6Zq1aqV4S5WyFxYWJi2b9+uixcvKiEhQT4+PqpevbqaN2+uokWL2jvefUlMTNSWLVsUEhKiq1evytPTU9WqVVOrVq1UvHhxe8dzGKtXr1bnzp0t7aCgIH300Ud2yXL9+nUdOXJEp0+fVkREhOLj4+Xu7i4fHx9Vq1ZN9evXl4+Pj12y3bx5U3///beOHTumqKgoubm5KSAgQA8//LAeeOABu2T65ptvrI7InTVrlgYMGJDldVJSUrR3716dOHFCV69elclkUtGiReXj46MqVaqoZs2a8vPzy8noyCG59feuwlJTxN9OAQAAgFxybnFw5oPu0mPUUAWH7rG0PV2KafKg0erS8TG55nQ4QNLlUq669cNW/TF6tgIDA7O11utLhllef9WDomoUHvUm97R3BAAAAADAXapUqaIqVarYO0aBFhgYmO2fJTkaNzc3dejQwd4xHN4ff/xh1W7UqJGdktzega158+Zq3ry53TKkx8PDQ23btlXbtm3tHcUip947JycnNWrUyK7vPWAPFNgBAAAADqhMsTJaOXmGbsbF2TsKAAAAAAAAAKCQM5lMmj17tqXt4uKiJk2a2DERbBUWFqZVq1ZZ2kajUTVq1LBjIiD/cbJ3AAAAAADWGpSvp23TFqo026gDAAAAAAAAAHKB2WzO0tihQ4cqKirK0te5c2eVLFkyN6IhE1l5727duqUBAwYoOTnZ0jdgwAA5OVEuBGQF3zEAAACAg3AyOKlX065aMWW63N3c7R0HAAAAAAAAAFBAdejQQTNmzFBcJqeoXLp0Sb1799Yvv/xi6TMYDBo+fHguJ0R6GjRooIULFyoxMTHDcSEhIWrfvr22bt1q6XN3d9ewYcNyOyJQ4HBELAAAAOAgvh4VlO6udeYrHBWLnMfnCgAAAAAAACicTp06pRdffFFvvPGGOnbsqMaNG6ty5cry9vZWXFycLly4oG3btmnVqlW6efOm1dxhw4apVatWdkqO/fv3q0+fPvLx8dFjjz2mhx9+WBUrVlSxYsUUExOjs2fPavPmzfr999+tdq6TpI8//lhVq1a1U3Ig/6LADgAAAHAQaRXXeXl5qbiPt2IGL8/7QCgUivt4y8vLy94xAAAAAAAAANhBfHy8li9fruXLl9s0vmfPnvr000/TvLZ9+3bduHEjB9NJvr6+atiwYY6uWVBER0drwYIFWrBggU3jX3/9db355pu5nAoomCiwAwAAAByY0WhU2OkQmUwme0dBAeXl5SWj0WjvGAAAAAAAAADyULly5XTmzBmbx5coUUKjR4/WyJEjZTAY0hzTr1+/LK1pi9atW2vz5s05umZ+V7ZsWYWHh9s8vnz58ho3bpwGDhyYe6GAAo4COwAAAMDBGY1GCqAAAAAAAAAAADnmr7/+0v79+7Vx40bt3LlTJ0+e1Pnz5xUbG6uUlBT5+vqqZMmSatSokdq2bauePXuqWLFi9o4NSefOndPff/+tP//8U8HBwTp9+rQuXLig2NhYOTk5ydfXV/7+/mratKkeffRRdevWTW5ubvaODeRrFNgBAAAAAAAAAAAAAAAUMvXr11f9+vXtHQNZZDAY1Lx5czVv3tzeUYBCgwI7AAAAwMFFRkZyRCxyDUfEAgAAAAAAAMgJYWFh9o4AALmCAjsAAADAQSQkJsjdzd2qLzIyUoFVKism+rqdUqGgK+7jrbDTIRTZAQAAAAAAAAAApIECOwAAAMBBDBn/nlrWbazBPXpb+kwmk2Kir8tlRjcZ/D3tmA4FkflKnGIGL5fJZKLADgAAAAAAAAAAIA0U2AEAAAAOIiY+TmN//VT/njmlT9981+qawd9ThgAvOyUDAAAAAAAAAAAACicnewcAAAAAYG3BjuXqNvIlJSQm2DsKAAAAAAAAAAAAUKhRYAcAAAA4oD1n9qvVkN66GhVp7ygAAAAAAAAAAABAocURsQAAAEAuKd+zcbbmX4i5qP4TRsqzhFGJOZQJAAAAAAAAAAAAgO0osAMAAAAcWFxynEq2fkCmc4mKC7B3GhQ0pS7fktuQVnpv83fy8PDI1lonI6IsrwfN/zC70QAAAAAAAAAAABwCBXYAAACAgzNEJSu2jKsM9g6CAsf9Zoo8q/jpcERIjq67+9zRHF0PAAAAAAAAAADAXiiwAwAAAHJJ6PwdWRrfe/Sr2hW216qvR6NO+nJMkFxHPJCT0QBJUoKHk8yHL6lp0yY5sIPdScvran7VshsNyDcoKAUAAAAAAACAgo0COwAAACCXuLhk7a/bBsP/9qhzkYvGDXhbj9Spry/HBOVwMuC2y6VcdeuHrfpj9GwFBgZma63XlwyzvP6qx7hsJgPyj3qTe9o7AgAAAAAAAAAgFznZOwAAAAAAa0Wdi+qX97/V/3XuZu8oAAAAAAAAAAAAQKHGDnYAAACAAynl6a/lk2aoXKnS9o4CAAAAAAAAAAAAFHoU2AEAAAAOok/7p9S5dXsV8XBPdc18Jc4OiVDQ8bkCAAAAAAAAAADIGAV2AAAAgIPo/VinVH1eXl4q7uOtmMHL8z4QCoXiPt7y8vKydwwAAAAAAAAAAACHRIEdAAAA4MCMRqPCTofIZDLZOwoKKC8vLxmNRnvHAAAAAAAAAAAAcEgU2AEAAAAOzmg0UgAFAAAAAAAAAAAA2IGTvQMAAAAAAAAAAAAAAAAAAOCIKLADAAAAAAAAAAAAAAAAACANHBELAAAAOLjIyEiZTCZ7x0AB5eXlxRHEAAAAAAAAAAAA6aDADgAAAHAQn82eod4dO6l8mTKWvsjISAVWqayY6Ot2TIaCrLiPt8JOh1BkBwAAAAAAAAAAkAYK7AAAAAAHsePwHk1bM1czx3yu5vUbSJJMJpNioq/LZUY3Gfw97ZwQBY35SpxiBi+XyWSiwA4AAAAAACCfCQoK0tixYy3tP//8U23atEl3vMFgsLxu3bq1Nm/enIvpbLN582a1bdvW0v7oo48UFBRkv0AAAKSBAjsAAADAgcQnx+vZj19RUP+RGtitp6Xf4O8pQ4CXHZMBAAAAAAAAji80NFSHDx/WuXPnZDKZlJKSIl9fX/n6+qpGjRqqXbu2nJ2d7R0TAADkIxTYAQAAAA4mWcn6YO4k/XsmRC937W3vOAAAAAAAAIBDO3TokKZNm6Zly5YpPDw8w7FFixZVixYt1L9/f/Xo0UOenradGhEREaHg4GCrP5GRkVZjzGbzfT8DAABwXBTYAQAAALlk8qxpWRp/4sJpq/a8bYt1JOS4JEPaEwAAAAAAAGDR9cxr9o5QYKyo+LW9I9jk7NmzGjFihJYuXWrznPj4eG3YsEEbNmzQa6+9ptGjR2vEiBHy8PBINfbYsWMaO3asgoODFRoampPRYQdt2rTRli1bLG0KIgs+3nMAOYUCOwAAACCXfLV6RrbX2B9+SJU7NdPFuGQl50Am4G6lLt+S25BWem/zd2n+EDkrTkZEWV4Pmv9hdqMBAAAAAABkaPXq1erfv7+uX7+e5nVfX1/5+fnJ29tbV69e1eXLlxUfH281xmQy6d1339XSpUu1a9euVGscP35cCxYsyJX8AAAg/6DADgAAAHBwZlfJJc5MgR1ynPvNFHlW8dPhiJAcXXf3uaM5uh4AAAAAAMDd5s2bpwEDBig52fonZg0bNtSgQYP05JNPqmLFiqnmHT9+XCtWrNDChQu1Z88eS39ERESWMxQrVkyxsbFZD29H7N4FAMD9ocAOAAAAyCWVjYFZGh8SGZaqr4xnae1buF6GFypxUCxyXIKHk8yHL6lp0yY5sIPdScvran7VshsNyDcoKAUAAACAvLV792698MILVsV13t7e+uabb9SvXz8ZDOn/FK169ep6++239fbbb2vZsmUaM2aMjh8/nuk9ixQpovr166tx48Z6+OGH9fDDD8vV1VWVK1fOkWcCAACOjQI7AAAAIJdsmbYwS+N7jBqq4ND//eZs40oNNWHISD3wczW55nQ4QNLlUq669cNW/TF6tgIDA7O11utLhllef9VjXDaTAflHvck97R0BAAAAAAoNk8mkPn36KDEx0dLn7++vdevWqX79+llaq3v37urUqZOGDRumjRs3pjmmcePG2rt3r+rUqSMXF+v/tB4WFpbV+AAAIJ+iwA4AAABwQM+27KGJw9/hB3UAAAAAAADA/xcUFKSQkBBL28nJScuXL89ycd0dbm5umjFjhpYuXZrm9YCAAAUEBNzX2gAAoOCgwA4AAABwIM5y1of9RuqF7uyIBAAAAAAAANwRHR2t6dOnW/UNHz5czZo1y/baTz/9dLbXKAyuXbumLVu2KDw8XDExMTIajapTp46aNm0qZ2fnXLvvgQMHtHv3bl25ckXu7u4qXbq0mjdvnu0TGfKD2NhY/fXXXzp37pwiIiLk7e2tBg0aqGnTphkehyxJ58+f144dO3T27FklJyerdOnSatGihapWrZqtTOfPn9eRI0cUGhqq69evS5KMRqPKli2rZs2aydfXN1vrS9KZM2e0b98+nT9/XiaTSQaDQZ6enipTpowqV66sWrVqycPDI9v3yapLly5p7969CgsLk8lkUkpKiooWLSp/f39VrlxZtWvXVrFixfI8F4DcR4EdAAAA4CAqlSmvEc8MUssGjVJdM1+Js0MiFHR8rgAAAAAAQH7xww8/KDY21tJ2c3PTmDFj7Jgo/7m7IKt169bavHmzTfNOnDihkSNHau3atUpKSkp13d/fX2+99ZZGjBghFxcXBQUFaezYsZbrf/75p9q0aZPlvL/++qvGjh2r48ePp3m9SZMm+vTTT9WyZct017g3y90yKlDLytcnOwYOHKjZs2db2qGhoQoMDFR4eLg+/PBDLVy40Opzf0eVKlX0xRdf6Kmnnkp1bf/+/XrnnXe0YcMGmc3mVNcfeeQRfffdd6pdu7ZNGZOSkrRx40YtXrxYGzdu1JkzZ9IdazAY1LRpU7399tvq2rVrpkWAd0tJSdGMGTP07bff6uDBgxmOdXNzU8OGDdWjRw8NGzZMRYoUsVzLjfd80aJFmjJliv7+++8Mczk7O6tu3brq1q2bXn31VRmNxgzHA8g/KLADAAAAHMSnb76bqs/Ly0vFfbwVM3h53gdCoVDcx1teXl72jgEAAAAAAJChe49x7d69u0qWLGmnNDnv3qKgvCrwyszPP/+sl156SQkJCemOuXLlit5++22tXr1aK1euzPY9ExMT9cILL2jevHkZjtu5c6fatGmjGTNmaODAgdm+r6P4+++/1blzZ127di3dMadPn1aXLl305Zdf6rXXXrP0//jjjxo6dKhu3bqV7txt27apWbNmWrt2rVq0aJFpnr59+2rJkiU2ZTebzfr777/VvXt3Pf300/r555/l6emZ6byoqCh17txZ27dvt+k+iYmJ+vvvv/X333+ra9eu2d6VLz0JCQl65plntGzZMpvGJycna9++fdq3b5+aN2+u9u3b50ouAHmPAjsAAADAgRmNRoWdDpHJZLJ3FBRQXl5e/CYlAAAAAABwaHFxcdq7d69VX9euXe2UpvCYP3++nn/+eaWkpFj1e3p6KjAwUG5ubjp79qylEGzr1q3q06ePmjRpkq37DhgwQPPnz7e0fX19Vb58ebm4uCgkJETR0dGWa8nJyRo8eLBq1aqlhx9+OFv3dQQnT55U7969Lc/o4uKiKlWqyMvLSxcuXFB4eLhlrNls1vDhw1W/fn098sgj+vXXX/Xiiy9adq278z55eHgoJCREUVFRlrmxsbHq3r27jh8/numRrjdv3kzV5+fnJz8/PxUvXlw3b95UeHi4rl69ajVm6dKlun79utavXy8nJ6d01zebzeratWuq4jqDwaAyZcqodOnScnV1VUxMjC5cuGD1/ue2wYMHp1lc5+/vr7Jly8rd3V0xMTG6cuWKIiIi8iwXgLxHgR0AAADg4IxGIwVQAAAAAAAAKLT++eefVEeTNmrUyE5pCoezZ8/qxRdftCquq1ixoiZPnqwuXbrI3d1d0u3iqB07duidd97R9u3btW7dOp04ceK+7ztnzhyFhIRIkh5//HF99NFHatKkieVoz+TkZK1atUqvvPKKLly4YOl79dVXtXPnzlTrPffcc5YjZEeOHGl19OiGDRvSzZFZ0VlueemllxQdHS0fHx8FBQVpwIAB8vHxsVwPDg7W4MGDdejQIUm3j1V98803NX/+fA0ePFhms1kPPPCAJkyYoE6dOsnNzU3S7a/RkiVLNGTIEEuBWkREhD7++GN99tlnmeYqWbKkevfurU6dOqlx48Zp7h556tQp/fTTT5oyZYqlKO+PP/7Ql19+qREjRqS79uLFi7Vt2zZL29PTU0FBQfq///s/lSpVKtX4c+fO6c8//9SKFSvS3DExp97zXbt2ae7cuZa2i4uLRo0apSFDhqhixYqp5l++fFnbtm3TqlWrtGjRonTvAyB/osAOAAAAAAAAAAAAAOCw/v33X6t2sWLFcu1ISNw2YsQIxcbGWtp16tTR5s2bU/0isMFgUIsWLbR161b1799fv/76q0JDQ+/7vneK6z744AONGzcu1XVnZ2d169ZNNWvW1EMPPaT4+HhJtwvPDhw4oHr16lmNr1y5sipXriwpdQGVIx7fGRYWplKlSmnTpk2qWbNmquuNGzfWpk2bVKtWLV25ckWStHv3bnXu3Fnx8fF65JFH9Ntvv6l48eJW85ydndW7d2/5+fmpXbt2lv45c+ZowoQJcnV1TTfTe++9p4ceekgeHh4ZZq9atao++eQT9e7dW48++qgiIyMlSZ999plee+01ubikXZ5ybzHaqlWr1LZt23TvU758eT333HN67rnndO7cuVTva0695/fmmjZtmp5//vl0x5cqVUo9e/ZUz5499fnnn6fa+RFA/pb+PpwAAAAAAAAAAAAAANjZnUKdO/z8/Cw7miHnnTt3TsuXL7e03dzctGTJkgxP2XByctLMmTNzpPCxa9euaRbX3e2BBx7Qa6+9ZtX3+++/Z/vejmDWrFlpFtfdUbJkSb355ptWfceOHZPRaNTChQtTFdfdrW3bturYsaOlHRERod27d2eYp1mzZpkW192tfv36mjRpkqUdHh6u9evXpzv+7h0PH3zwwQyL6+5Vvnx5FStWzObxWXF3rmLFium5556zeW6JEiXk5+eXG7EA2Ak72AEAAAAOLjIyUiaTyd4xUEB5eXlxBDEAAAAAAHBo9xbY3X1kZkERFBSkoKAge8eQJM2dO9dq960XXnhB1apVy3Seu7u7xo4dq379+mXr/p988olN4/r06aOJEyda2nv37s3WfR1B8+bN9fjjj2c6rkuXLho9erRV37Bhw1S6dOlM53bt2tWq4G3fvn1q1qxZ1sNmoG/fvhoyZIiSk5MlSTt27NCTTz6Z5tgbN25YXme0k15euzuXk5OTnJzYvwoozCiwAwAAABxE8KGDalSrttW/qEdGRiqwSmXFRF+3YzIUZMV9vBV2OoQiOwAAAAAA4LBiYmKs2p6ennZKUjj89ddfVu2sFMx1795dnp6eiouLu69716lTJ8Pd2+5Wu3Ztubi4KCkpSdLtnffyu169etk07oEHHpCbm5sSExMtfT179rRpbp06dazaZ8+etT2gjTw9PeXv76+LFy9Kul3El56AgADLbnFHjx7Vvn379NBDD+V4pqwKCAiwvDaZTFq1apW6dOlix0QA7IkCOwAAAMBBTPz5e926dUsLJnyrIh7ukm7/i3tM9HW5zOgmgz8/OETOMl+JU8zg5TKZTBTYAQAAAAAAh3XvkZf3W7wF29x9ZKiLi4sefvhhm+cWKVJE9evX1/bt2+/r3o0aNbJ5rKurq3x8fHT16lVJ0vXr+f+XlBs2bGjTOGdnZ3l7eysiIkLS7a9F7dq1bZpbokQJq3ZWTk85cuSIFi9erL179+ro0aOKioqSyWTSrVu3Mpx35z1KS4cOHbR582ZJUnJysh5//HGNHz9ezz77rIoWLWpztpzWoUMHzZo1y9Lu16+fgoKCNGjQoAK5iyaAjFFgBwAAADiQfecPqtXLvbRi0nQF+Jey9Bv8PWUI8LJjMgAAAAAAAMA+7v3FwIJQSOWokpKSdOXKFUu7cuXKcnd3z9IaNWrUuO8CO39//yyN9/T0tBRv3X2kZ37l5+dn89i7i8+MRqOcnZ2zPE+y7et26NAhvfrqq9q6davN+e4WHR2d7rWXX35ZX331lS5fvixJunLlil588UW98cYbat++vdq2basWLVqofv36eXqEbK9evTR+/HgdPXpUkhQbG6u33npL7777rlq3bq127dqpZcuWatSokTw8PPIsFwD74JBoAAAAwMFcir2kdq/31c6D++0dBQAAAAAAALC7ewvs7uzahZx3byGUt7d3ltfIzu5e2SlUMpvN9z3XUdzv8+fm12316tVq1KjRfRfXSVJCQkK614xGo1avXq0yZcpY9cfHx2vlypUaMWKEGjduLKPRqCeffFIzZszIsGAvp7i6umrVqlWqXr26VX9iYqI2bNigMWPG6JFHHpGPj4/atm2rL774wlIkCKDgocAOAAAAcEBxSXHqO26YVm37095RAAAAAAAAALt68MEHrdoxMTE6deqUndIUbPcWQrm5uWV5jazueAfHdeLECfXs2VOJiYmWPoPBoCZNmmjEiBH6+uuvtWjRIq1atUobNmyw+lOqVKkMVrbWqFEjHT58WKNGjUpVUHtHbGysfv/9d7344ouqUKGCgoKCMj2aNrsqV66svXv3avz48SpbtmyaYxISErR582aNGDFCFSpU0Ouvv66YmJhczQUg73FELAAAAJBLyvdsnK35SUrS5BVTFdCglvidXOSGUpdvyW1IK723+btsH2NwMiLK8nrQ/A+zGw0AAAAAAMCiadOmcnFxUVJSkqVv9+7dqlq1qh1TFUz37lgXGxub5TVMJlNOxYGdjR492qrosnHjxpo9e3aqote0GAyGLN3LaDRq0qRJ+vjjj7V582b9+eef2rJli3bv3p2qkC4mJkZjx47Vxo0btX79+lTH3uakokWL6t1339Xo0aO1fft2bdq0SZs3b9bOnTtTHa+bmJior7/+WuvXr9fWrVuzfOQxAMdFgR0AAADgwMwyyznQU8XPJCo2wN5pUNC430yRZxU/HY4IydF1d587mqPrAQAAAACAws3T01MNGjRQcHCwpW/lypXq27evHVMVTMWKFZOrq6uloOnChQtZXuN+5sDxxMbG6rfffrO0S5UqpbVr18rX19em+VFRUZkPSoObm5s6duyojh07SpJu3Lihf/75R2vWrNEvv/xi9fnavn273nrrLX333Xf3da+scHJy0iOPPKJHHnlEH330kW7duqXdu3dr7dq1+uWXX6x21Tx+/LgGDhyoNWvW5HouAHmDAjsAAADAgbnIRab94YoZWE1Z+30/IHMJHk4yH76kpk2b5MAOdictr6v5VctuNCDfoKAUAAAAAPJG9+7drQrsli5dqmvXrqlEiRJ2TFUw1axZUwcOHJAkRUREKDw8PN3jMdOyf//+XEqGvLR3716ro2GfeeYZm4vrTp06leq44ftVpEgRtW3bVm3bttUnn3yisWPHavz48ZbrM2bM0IQJE+Tl5ZUj97OVq6urmjVrpmbNmikoKEjff/+9XnvtNaWkpEiSfv/9dx07dkw1atTI01wAcgcFdgAAAEAuObc4OPNBd+kxaqiCQ/dY2p4uxTR50Gh16fiYXHM6HCDpcilX3fphq/4YPVuBgYHZWuv1JcMsr7/qMS6byYD8o97knvaOAAAAAACFwpAhQzR+/HjLkaUJCQmaOHGiJk2aZOdkBU/jxo0tBXaStHr1ag0ZMsSmuUePHtXp06dzK1q2ODk5WbXNZnOWjzEtTC5fvmzVrl69us1zN23alNNxJN0uavv444+1ZcsW/fXXX5KkW7duaefOnerQoUOq8Xn1nhsMBg0bNkx///235s6da+n/66+/KLADCginzIcAAAAAyGtlipXR5q8XqE61B+wdBQAAAAAAALA7X19fDRo0yKrv888/186dO7O9Nsc4WuvSpYtVe+rUqZZduTLzzTff5EakHOHp6WnVjo+Pt1OS/MFsNlu1797NLrN533//fW5EsmjRooVV++rVq2mOy+v33NZcAPIfCuwAAAAAB9OgfD1tm7ZQpf387B0FAAAAAAAAcBhBQUFWu/AnJyerW7duOnTo0H2td+vWLb311lt65ZVXcihhwfDEE0+oXLlylvb+/fs1ZcqUTOdt375d06ZNy81o2WI0Gq3aoaGhdkqSP5QuXdqqfWfHuMx8//33uX5M8L2Fa+kdXZvX77mtuQDkPxTYAQAAAA7CyeCkXk27asWU6XJ3c7d3HAAAAAAAAMCh+Pj4aMGCBXJ1dbX0Xbp0Sa1bt9avv/6aasetjGzZskWNGjXSZ599lqV5uSUoKEgGg8Hyp02bNnbL4uzsrKCgIKu+UaNG6Ysvvkj3a7Vx40Y99dRTSk5OdthjV2vVqmXVXrx4sZ2S5A8NGzaUm5ubpb106VLt2LEjwzmrV6/Wm2++afM9TCaT+vXrp3379tk8JywszOq9c3JyUv369dMcm533vF+/ftqyZYvN46OiojRjxgyrvoYNG9o8H4Bjc7F3AAAAAAC3fT0qKN1d68xX4vI4DQoDPlcAAAAAACC/ady4saZPn64XXnjBcmxpVFSUnn32WU2ZMkWDBg3SE088oQoVKqSae/LkSa1atUqLFy/W33//bdP99uzZo6ioqFT9ly9fTtW3cePGNNfw9fXNd4U2gwYN0vz58y3PZDabNWLECP3000/q27evHnzwQbm6uurMmTNatWqV1q9fL0kqWrSoevTooTlz5tgzfpo6dOigd955x9L+z3/+ozNnzqhdu3by8/OTi8v/yify43uW0zw9PdWjRw/9+uuvkm7vGPnEE09o8uTJeu655+Th4WEZe/LkSU2ZMkU//PCDUlJS5O/vr+TkZF27di3De6SkpOiXX37RL7/8okaNGqlnz57q0KGDateubVXcJ90uxlu0aJHef/99Xb9+3dLfuXPnVLvt3ZGd9/y3337TL7/8oho1aqhXr156/PHHVa9ePRUtWtTqHjdu3NDq1av13nvv6cyZM5b+evXq6eGHH87w+QHkHxTYAQAAAA4ireI6Ly8vFffxVszg5XkfCIVCcR9veXl52TsGAAAAAACAzQYMGCBvb28NGDBAJpPJ0r9r1y7t2rVL0u2jIf38/OTt7a1r167p4sWLio+PT3O9MmXKpHuvkSNH2ryLVYcOHdLsb926tTZv3mzTGo5k0aJFat++vfbs2WPpO3ToULpH8jo7O2vWrFk6cuSIVf/dRUz29NBDD6ldu3batGmTpNvFXbNmzdKsWbNSjc2v71lO+89//qPffvvN8n1mMpk0ZMgQvfHGG3rggQfk7u6uixcv6vz585Y5dz4HQ4cOzbTA7m67d+/W7t27NXr0aLm5ualcuXLy9fWVs7Ozrl27prCwMCUnJ1vN8fPz09dff53umjnxnh87dkzjxo3TuHHj5OzsrHLlysloNMrNzU3R0dEKCQnRrVu3rOYULVpUP/30k83PDsDxOcb/kwEAAABIk9FoVNjpEKsfFAI5ycvLS0aj0d4xAAAAAAAAsqRbt246cOCAhg8frhUrVqS6HhkZqcjIyAzXKFGihN5//3298soruRUzX/Px8dHGjRs1fPhwzZ49O8OxJUuW1MyZM/XUU09p586dVte8vb1zM2aWzJkzR507d9bevXvtHSVfqFKlihYtWqQePXooNjbW0n/z5k0dPHgw1XgPDw/NmjVLTzzxRLbum5iYqJCQkAzHPPjgg1qxYoXKly+f4bicfM+Tk5N15swZq53q7lW2bFktWrRIDRo0yPb9ADgOCuwAAAAAB2c0GimAAgAAAAAAyMSKiunvYoSCKTAwUMuXL9f+/fs1ffp0LV26VJcuXcpwjqenp1q1aqUBAwaoW7ducnd3z6O0+ZOPj49mzZqlV199VXPnztUff/yh8PBwxcTEyGg0qnbt2urcubNeeOEFyykJ9xY2OlKBXUBAgP755x+tWLFCy5Yt04EDBxQeHq7Y2FglJSXZO55D6tixo3bt2qW3335bq1atSnOMi4uLunXrpvHjx+uBBx6weW0fHx/t27dPK1as0IYNG7R7924lJCRkOKdu3boaPHiwXn75Zbm6umZ6j/t9z4ODg7VixQqtW7dO//zzj+Li4jK8T9WqVTVgwACNGDFCnp6emeYCkL8YzGaz2d4h4NiOHDmi2rVrW9qHDx9WrVq17JgIAJBf/Lf7hzq+44iqN6+lMcvG2TsOkCceH/SEDAaDzGaz1v74u73jAHnm9SXDLK+/6vGdHZMAeave5J6W1wdGLbZjEgAAACD/SUpK0smTJ636qlWr5jDHSSJ/On36tA4fPqxz584pJiZGZrNZPj4+MhqNqlmzpmrVqiVnZ2d7xyzQGjVqZDlW1s3NTTExMXJzc7NzKuSEixcvatu2bTp//rzi4+Pl5eWlqlWrqnnz5vLx8cn2+gkJCTp69KhOnTqlixcvKjY2VgaDQV5eXgoMDFT9+vVVtmzZ7D9IFiUnJ+vYsWM6efKkpcBUkooXL66yZcuqfv36qlSpUp7nArIit/7eVVhqivjbKQAAAODgIiMjOSIWuYYjYgEAAAAAQEFSpUoVValSxd4xCq2rV69aHR1at25diusKkDJlyqh37965tr67u7seeughPfTQQ7l2j/vh7Oys2rVrWxURAShcKLADAAAAHERCYoLc3ayPpIiMjFRglcqKib5up1Qo6Ir7eCvsdAhFdgAAAAAAAMi277//Xrdu3bK0W7RoYcc0AADkDArsAAAAAAcxZPx7alm3sQb3+N9vAJpMJsVEX5fLjG4y+HvaMR0KIvOVOMUMXi6TyUSBHQAAAAAAAKyYzWYZDAabxx84cECffPKJVd8LL7yQ07EAAMhzFNgBAAAADiImPk5jf/1U/545pU/ffNfqmsHfU4YALzslAwAAAAAAAFDYzJs3T+vXr9fIkSNVr169DMcuWbJEgwcP1s2bNy197dq1U926dXM7JgAAuY4COwAAAMDBLNixXKfCw7Tgv1/bOwoAAAAAAACAQiopKUlz5szRnDlzVLNmTbVr10716tWTv7+/XFxcFBkZqUOHDum3337TkSNHrOYWL15cM2bMsFNyAAByFgV2AAAAgAPac2a/Wg3prW9f/8jeUQAAAAAAAAAUckePHtXRo0dtGuvt7a0lS5aoUqVKuZwqdx09elQXLlzI8XXbt2+f42sCAHIXBXYAAABALinfs3G25l+Iuaj+E0bKs4RRiTmUCQAAAAAAAABsUbJkSbm7uyshIcHmOR07dtQXX3yhGjVq5GKyvDFp0iTNnj07x9c1m805viYAIHdRYAcAAAA4sLjkOJVs/YBM5xIVF2DvNChoSl2+JbchrfTe5u/k4eGRrbVORkRZXg+a/2F2owEAAAAAAMDOnnrqKV25ckXr1q3TX3/9pYMHDyo0NFTXrl3TjRs3VLRoURmNRgUGBqp169bq3LmzGjVqZO/YAADkOArsAAAAAAdniEpWbBlXGewdBAWO+80UeVbx0+GIkBxdd/c5244LAQAAAAAAgGPz8vJSr1691KtXL3tHAQDAbiiwAwAAAHJJ6PwdWRrfe/Sr2hW216qvR6NO+nJMkFxHPJCT0QBJUoKHk8yHL6lp0yY5sIPdScvran7VshsNyDcoKAUAAAAAoGCaNWuWZs2aZe8YAAAHQIEdAAAAkEtcXLL2122D4X971LnIReMGvK1H6tTXl2OCcjgZcNvlUq669cNW/TF6tgIDA7O11utLhllef9VjXDaTAflHvck97R0BAAAAAAAAAJCLnOwdAAAAAIC1os5F9cv73+r/OnezdxQAAAAAAAAAAACgUGMHOwAAAMCBlPL01/JJM1SuVGl7RwEAAAAAAAAAAAAKPQrsAAAAAAfRp/1T6ty6vYp4uKe6Zr4SZ4dEKOj4XAEAAAAAAAAAAGSMAjsAAADAQfR+rFOqPi8vLxX38VbM4OV5HwiFQnEfb3l5edk7BgAAAAAAAAAAgEOiwA4AAABwYEajUWGnQ2QymewdBQWUl5eXjEajvWMAAAAAAAAAAAA4JArsAAAAAAdnNBopgAIAAAAAAAAAAADswMneAQAAAAAAAAAAAAAAAAAAcEQU2AEAAAAAAAAAAAAAAAAAkAaOiAUAAAAcXGRkpEwmk71joIDy8vLiCGIAAAAAAAAAAIB0UGAHAAAAOIjPZs9Q746dVL5MGUtfZGSkAqtUVkz0dTsmQ0FW3MdbYadDKLIDAAAAAAAAAABIAwV2AAAAgIPYcXiPpq2Zq5ljPlfz+g0kSSaTSTHR1+Uyo5sM/p52ToiCxnwlTjGDl8tkMlFgBwAAAAAAAAAAkAYK7AAAAAAHEp8cr2c/fkVB/UdqYLeeln6Dv6cMAV52TAYAAAAAAAAAAAAUPk72DgAAAADAWrKS9cHcSRr95SR7RwEAAAAAAAAAAAAKNXawA4D/x959hzdB7X8c/6QDSktXgJYhUJYIAiJ7b1FxADJEQKaK4kT2UCqKIogDvCrjKioOkC0OpgUBoQVZBURGW6DQAZ2U2ZLfH/zIJV0kNG1C+349D8/tOTnjmzap3PLpOQAA5JMZC+baNP7f08cs2t/9uUQHjh+WZLBjVQAAAAAAAAAAAACsRcAOAAAAyCezVs/P8xp7over6iPNdSYtQxl2qAm4WWDsVRUb1kYTQz6Th4dHntY6Ep9o/njoj2/mtTQAAAAAAAAAAACnQMAOAAAAcHImd8ktzUTADnZX/NI1eVUro/D443Zdd+fJg3ZdDwAAAAAAAAAAwFEI2AEAAAD5pKoxyKbxxxMis/SV8yqr3YvXyjCkChfFwu4ue7jIFB6jZs2a2uEEuyPmj2uUqZHX0oA7BoFSAAAAAAAAACjcCNgBAAAA+WTT3MU2je8x+gWFRuwyt5tUaahpw0bq7m9qyN3exQGSYgPddXXOZm0Y97WCgoLytNYrS4ebP57VY0oeKwPuHPfN6OnoEgAAAAAAAAAA+cjF0QUAAAAAyKpvqx5aOuNzubvxOzEAAAAAAAAAHCMyMlIGg8H8Z9CgQbmOHzRokMX4yMjIAqkTjteuXTuLrz2QWVBQkPn1kddf+AYKGv9aBwAAADgRV7nqzX4jNaQ7JyIBAAAAAAAAtoqIiFB4eLhOnjyplJQUXbt2Tf7+/vL391etWrVUp04dubq6OrpMAABwByFgBwAAADiJKuUqasRTQ9WqQaMsj5ni0hxQEQo7XlcAAAAAAKAw2L9/v+bOnavly5crOjo617Genp5q2bKl+vfvrx49esjLy8uqPeLj4xUaGmrxJyEhwWKMyWS67ecAAACcFwE7AAAAwEl88PqELH0+fVZOwAABAABJREFUPj7y9vNV6jMrCr4gFAnefr7y8fFxdBkAAAAAAAA2O3HihEaMGKFly5ZZPefChQtat26d1q1bp5dfflnjxo3TiBEj5OHhkWXsoUOH9NZbbyk0NFQRERH2LB0AANxBCNgBAAAATsxoNCry2HGlpKQ4uhQUUj4+PjIajY4uAwAAAACAPBv3RClHl1BoTFt2ztEl3NLq1avVv39/JScnZ/u4v7+/ypQpI19fX509e1axsbG6cOGCxZiUlBRNmDBBy5YtU1hYWJY1Dh8+rEWLFuVL/QAA4M5BwA4AAABwckajkQAUAAAAAAAA8P++++47DRw4UBkZGRb9DRs21NChQ9WlSxdVrlw5y7zDhw9r5cqVWrx4sXbt2mXuj4+Pt7mGkiVL6vz587YXf4cJCgri6lsAdhEZGenoEoDb5uLoAgAAAAAAAAAAAAAAsMbOnTs1ZMgQi3Cdr6+vvv32W4WFhemFF17INlwnSTVr1tSYMWO0c+dOLVu2TDVr1rRqzxIlSqh58+Z69dVXtXDhQh0+fFj79u2zy/MBAADOjxPsAAAAAAAAAAAAAABOLyUlRU8++aSuXLli7gsICNCaNWtUv359m9bq3r27HnnkEQ0fPlzr16/PdkyTJk30999/q27dunJzs/yndU5iAgCg6CBgBwAAADi5hIQEpaSkOLoMFFI+Pj5cQQwAAAAAAO4IwcHBOn78uLnt4uKiFStW2Byuu6FYsWKaP3++li1blu3j5cuXV/ny5W9rbQAAUHgQsAMAAACcROj+fWp0bx25uLiY+xISEhRUrapSk5IdWBkKM28/X0UeO07IDgAAAAAAOLWkpCTNmzfPou+1115T8+bN87z2E088kec1nMnhw4e1e/duxcXFKS0tTaVLl1b58uXVqlUr+fr6Orq8Anfp0iVt3rxZEREROnv2rEqWLKm7775brVu3VsmSJe22T1xcnMLDw3Xs2DElJSUpPT1dRqNRZcuWVdOmTVW2bNk87xETE6O///5bkZGRSklJ0bVr1+Tp6amAgABVrVpVderUsetzKmhxcXHatm2bYmJilJCQIF9fXwUGBqpp06aqWLGi3fc7ceKEtm3bphMnTshkMqlMmTKqX7++7r//fhkMhjytfe7cOW3atEnR0dFKTU2V0WhU3bp11axZM7m6utrpGeS/S5cuaevWrTp06JCSk5NlNBpVuXJltWvXTp6eng6rKzU1VX/++aeOHDmitLQ0lSlTRlWrVlWbNm3k7u5ulz1OnDihnTt3KjY2VomJifL19VXZsmXVsmXLPL+fC/t7uTAiYAcAAAA4ife/+VxXr17Vomn/UQmP4pKuX3uRmpQst/ndZAjwcnCFKGxMcWlKfWaFUlJSCNgBAAAAAACnNmfOHJ0/f97cLlasmMaPH+/AipzL5cuXNXv2bH3xxRc6duxYtmPc3NzUtm1bBQcHq1WrVlatGxkZqSpVqpjbAwcO1IIFC+xRcr5LTk7WpEmT9PXXXys1NTXL4x4eHho4cKCmTp2qUqVKKSQkRO3btzc/PnnyZAUHB+e4vslk0pYtW7R48WKtW7dOhw8fzrWeunXrauTIkerXr1+WK4dv5aefftJHH32kv/76K9dxrq6uqlevnrp166aXXnrpjvmZ34oVKzRt2jSFhobKZDJlO+bG5+/pp5+2+CX13Nwckmvbtq1CQkIkSWFhYRo3bpw2btyY7byKFStqypQpGjRokE3PQ5L+/fdfjRw5Ur///rvS09OzPB4QEKBRo0ZpxIgRcnNzU3BwsN566y3z43/88YfatWtn8763a8GCBRo8eLC5/dVXX2nQoEFKS0vTlClT9Pnnn2f7/ilZsqT69++v9957T35+flbtFRQUpKioKElS5cqVc71qO6fPS3x8vCZOnKhvvvlGly9fzjLPaDRq2LBhevPNN+Xh4WFVXTe7cuWKPv/8c82dO1cHDx7MdozBYFDDhg31xhtv6PHHH7dp/cL+Xi7MCNgBAAAATmT3qX1q83wvrZw+T+UDAs39hgAvGcr7OLAyAAAAAAAAwHEyX+PavXt3lS5d2kHV2F/mMMnNYaBbOXDggB5//HGL63Ozk56erg0bNmjDhg0aPHiw5syZY7eTnpzN3r179fDDD+vMmTM5jrl06ZLmzJmj1atXa82aNTbvMXr0aM2cOdPq8fv379egQYM0f/58LV26VAEBAbecc/nyZT311FNavny5VXtkZGRo9+7d2r17t1q0aKFOnTpZXZ8jJCcnq3fv3lq7du0tx974/P3nP//RypUrVa5cudvac9asWXr99deVkZGR45iTJ09q8ODB2rZtm7744gurA33ffPONnnvuuWyDXzfExcVpzJgxWr16tVatWmVz/QXh5MmT6ty5s/75558cx5w/f15ffPGFVq5cqZ9//lkNGzbM97r279+vBx98MNf3dUJCgt577z0tXbpUa9asUVBQkNXr79ixQ0899ZQiIiJyHWcymbRz50517dpVjz32mH744Qd5eeV+QEJhfy8XBdZ9FwAAAABQYGLOx6jDK320Y98eR5cCAAAAAAAAOFxaWpr+/vtvi76uXbs6qBrnsnPnTrVu3TpLuM7d3V01atRQo0aNVL58+SzzvvrqKz3++OO6cuVKQZVaYA4dOqROnTplCeG4ubmZPyc3XzcaHR2thx56SHFxcTbtc+nSpSx9/v7+qlWrlpo2bar69etnGwLbsmWLOnTooIsXL95yj2eeeSbbQE5AQIDuv/9+NWvWTPfee6/KlCljU+3OICEhQe3atcs2XFepUiU1atRIVatWzRJuCwsLU8uWLc0nodniiy++0KuvvmoO15UoUUK1atVS48aNs32fzJs3Tx9//LFVa//4448aPHhwlnCdl5eX7r33Xt1///0qVaqUuX/z5s168sknczyxz1EuXLigLl26WITrAgMD1bBhQ919991ZQrlnzpzRgw8+qPDw8HytKzY2Vg899JDF+/quu+7K8XXy77//qkOHDjp9+rRV6//8889q3759lnBdsWLFVLNmTTVp0kT33HNPltMnf/75Z3Xo0CHb7wc3K8zv5aKCgB0AAADghNLS09RnynD9/Ocfji4FAAAAAAAAcKjt27dnuWqxUaNGDqrGeaSmpqpXr15KTEw093l6emr69OmKiYnRv//+q7CwMEVHR2vv3r3q1q2bxfzff/9db775ZgFXnb/S09PVv39/nT171tzn5eWl6dOnKzY21vw5OXHihI4cOaIhQ4ZIkk6dOqVx48bZvJ+3t7cGDx6sJUuW6PTp00pISNDBgwe1fft27d69W6dPn9apU6c0bdo0i2s0Dxw4cMv9wsLCtHDhQnPbzc1N48ePV2RkpGJjY/X333/rr7/+Unh4uOLi4hQTE6OffvpJAwYMUIkSJWx+LgXtueee0549eyz6nn32WR09elRRUVEKCwvTsWPHdPLkSY0bN84i2BQREaG+ffvmegpdZkePHtWrr74qSapVq5aWLl1q/nqFhoYqOjpau3btUvPmzS3mvfHGGzp37lyua584cULPPvusrl27Zu6rXLmyFi9erHPnzik8PFx///234uPjtWXLFrVs2VKStGbNGn377bdWP4eCMH36dHNYrlOnTtq5c6diYmK0c+dOHT58WDExMZo2bZrF9avnzp1T3759dfXq1Xyra+zYseawXJ8+fXTo0CGdPHnS4nUyevRoubq6mudERERo6NCht1z7wIEDevLJJy1Cr61bt9bq1auVnJysf/75Rzt27NChQ4eUkJCguXPnKjDwfzcQhYaGasSIETmuX9jfy0UFV8QCAAAA+aRizyZ5mp+udM1Y+YXKN7hX8XaqCbhZYOxVFRvWRhNDPrP4gcjtOBL/vx/kDv2xcP1gFgAAAAAAOFbmawpLliyp6tWrO6ga5zFhwgRFRkaa276+vvrjjz90//33Zxlbr149LV++XJMmTdLUqVPN/TNmzFDv3r3VoEGDgig5333++ecWpx36+Phow4YN2QYyq1evrv/+979q1KiRhg8ffstrITMbPHiw3n33Xfn4+OQ6rkKFCho7dqz69OljcULWvHnzNHnyZBmNxmzn/fTTTxbtuXPnavDgwTnuExgYqJ49e6pnz5768MMPLcJezmbp0qVaunSpRd/8+fOzDUOVL19e7733nlq3bq1u3bqZQ1zbtm3T7Nmz9dprr1m1Z3R0tCTpwQcf1LJly+Tp6ZllTIMGDbR+/Xq1aNFCe/fulXT9RLeFCxeaw3nZGTFihM6fP29u161bVyEhIVm+tgaDQS1bttTmzZvVv39//fDDDza/7vLbjZMBn332Wc2ZM0cGg8HicaPRqLFjx6pNmzbq1KmTLly4IOn69a0ff/yxRo8ena91vfPOO5o4cWKWx8uXL6/p06erWbNm6t27tzl8+fvvv+unn35Sr169sl03PT1dffr0sQjXvfXWW3rjjTeyPHfpeqj22WefVZcuXdS+fXsdOXJE0vXTEZ977rlsv/8W5vdyUULADgAAAHBiJpnkGuQl76grOp/1hHogT4pfuiavamUUHn/81oNtsPPkQbuuBwAAAAAAiraEhASLdpkyZbINPhQlSUlJ+vLLLy36/vvf/2Yb7rjZO++8o7///lu//fabJOnatWv66KOPnO4Urds1e/Zsi/asWbNuedrhCy+8oG3btlmcMGWNhg0b2jS+cuXKmjdvnjp16iRJunjxon788UcNHz482/H//vuv+eOSJUtqwIABVu9181WkzmjmzJkW7ZdeeumWJ4116dJFb7/9tsXJfx9//LFefvlli1PLclOpUiUtWrQo23DdDZ6enpo2bZoefvhhc99vv/2WY8Du5MmTWrFihbldrFgxLV26NMfgpCS5uLjoq6++UlhYmI4ePWpV7QXpvvvu0+eff57r99nmzZvrww8/1PPPP2/umz17tl5//XWrvx62evTRR7MN193siSee0OjRozVt2jRz30cffZRjwG7JkiUW19sOGzbMqpM9K1SooKVLl6p+/frmANzMmTOz/T5SmN/LRQkBOwAAAMCJuclNKXuilTqohor2jwyRHy57uMgUHqNmzZra4QS7I+aPa5SpkdfSgDsGgVIAAAAAyH+ZA3Y3X7VZWAQHBys4ONjq8d9//7355ChJatmypXr06GHV3A8//NAcsJOkxYsX69NPP5Wvr6/V+zujv/76y3yalHT9GlBrgyzvvvuuvv/++3w/Kapjx44qV66czpw5I+n6KWw5BexuPlHLxcVFLi4u+VpbQTl48KD++usvc9vLy0tvv/22VXNff/11/ec//9HJkyclXT/VbO3atRZhuNyMGzfOqtf5Aw88IH9/f/P1yzefipjZwoULLV43Q4YMUY0at/75aPHixfXWW2+pX79+VlResN59912rQnLPPvusZs6caX7fnTx5UuvWrdNDDz2UL3W9//77Vo2bOHGiPvvsM6WkpEi6/r3h0KFDqlWrVpaxH3/8sfljT09Pvffee1bXU7duXXXt2lXLly+XJK1cuVIZGRlZPneF9b1c1BCwAwAAAPLJySWhNo3vMfoFhUbsMre93EpqxtBxerzzg3K3d3GApNhAd12ds1kbxn2toKCgPK31ytL//SBwVo8peawMuHPcN6Ono0sAAAAAgEIvNTXVou3l5eWgSpzHpk2bLNpDhgyxeu4999yjFi1aaNu2bZKkK1euaPv27XrwwQftWmNB27Jli0W7b9++Vp90WLFiRbVt21Z//PFHfpRmISgoyByw2717d47jypf/35UmKSkp+vnnn/X444/ne335LfNr94knnrA6NOvu7q6nn35a7777rrlv8+bNVgXsDAaDevfubdU+rq6uqlu3rjZv3ixJio+P1+XLl1W8ePEsYzO/7mwJzHXv3l1eXl5KS0uzek5+CwwMtPp7gYuLi/r376/Jkyeb+0JCQvIlYNewYUPVrl3bqrElS5ZUjx499NVXX5n7Nm3alCVgd+7cOYWG/u/fcR599FH5+/vbVFfnzp3NAbvz589r9+7dWU7NLKzv5aKGWCQAAADghMqVLKeQ2YtUt8bdji4FAAAAAAAAcChvb2+LtjOFURxlx44dFu0OHTrYNL9jx44W7e3bt+e5JkfbuXOnRbtFixY2zbd1/M0iIyM1ffp09erVS7Vq1VKZMmVUvHhxGQyGLH9uPr3t7NmzOa75wAMPWLT79eunmTNnKikp6bbrdAaOeu0GBQXZdN1mQECARTs5OTnbcTe/7tzc3NS4cWOr9yhRooTq169v9fiC0KpVK5uueG3Xrp1F++bAmj1l3sfW8dnVtWXLFplMJnP7VtdJZ6dSpUoW7UOHDmUZU1jfy0UNATsAAADAyTSoeJ/+nLtYZcuUcXQpAAAAAAAAgMMZjUaLdk5Bl6LCZDKZr8iUJB8fH5tvJ7jvvvss2idOnLBHaQ4VHR1t0c7uOsjc2Dpeun5Fabdu3VS1alWNHTtWS5Ys0T///KOzZ8/qypUrt5yfW8CmV69eFid2nT9/XqNGjVJgYKA6d+6sadOmacuWLbp06ZLNdTtSVFSURbtevXo2zb/d127mwNytZD4p8+ZrPm9IT09XXFycuV21atVsT7nLze287vJTnTp18jQ+IiLCnuXkuI+t47OrK3MYbsyYMdmGYnP788gjj1iskflKc6nwvpeLGq6IBQAAAJyEi8FFvZp11YejJjq6FAAAAAAAAMBpZA7YxcfHO6gS55CcnKxr166Z27acynVD6dKlLdqJiYl5rsvRMofVfH19bZpv7TWlN4SGhqpz5855CnzmFsJzd3fXzz//rC5duujw4cMWc9atW6d169ZJkooXL67mzZura9eueuqppxQYGHjb9RSEzK+1zK/FWzEajXJxcTG/B6x97Xp4eNi0T2Y3n3R2Q15fc5Ltr7v8Zuv3E39/f4uvR36dymZrXZnHZ1fXuXPn8lJStrL7flBY38tFDQE7AAAAwEnMHh2c46l1pjiuvYD98boCAAAAAAB3gnvuuceinZqaqqNHj6p69eoOqsixzp8/b9HOfNKWNTLPSU1NzVNNzuDy5csW7WLFitk035aTx86dO6cuXbpkCdPUq1dPrVu3VvXq1VW+fHmVKFFCHh4eMhgM5jEjR47Uvn37rNqnatWq+vvvv/Xxxx/rs88+y3JKn3T9eYeEhCgkJERjx47VsGHDNHXq1CxXKzuLvL5+DQaDSpQoYb4q2pGv3by+5iTbXncFwdPT06bxmb8emb++9mJrXZlfV9nVlR9hwJvDzzcrjO/looaAHQAAAOAksgvX+fj4yNvPV6nPrCj4glAkePv5ysfHx9FlAAAAAAAA5KhZs2Zyc3NTenq6uW/nzp1FNmBXsmRJi/aNYIstMs8pDAGOzKeHnT9/3qbTwVJSUqweO3XqVIvTr2rUqKGFCxeqSZMmt5xra1DI09NTEyZM0Lhx47R161Zt3LhRISEh2rFjR5ZrS69cuaLZs2dr7dq12rx5s83XohaE7F6/tpxOZjKZLJ63I1+72b3mbGXL664gXLhwwabxmb8emb++9mJrXZm/x2VXV+b34muvvZblyldbVa1aNcfHCtt7uaghYAcAAAA4MaPRqMhjx53u/2Sj8PDx8clyzQoAAAAAAIAz8fLyUoMGDRQaGmruW7Vqlfr06ePAqhzH19fX4krG27nm8OzZsxZtf39/u9TmSJl/xnX69GmbAnanT5+2euyiRYvMH3t4eOj333/PNVhzs4SEBKv3uZmLi4tat26t1q1ba/Lkybp69ap27typ33//Xd9//72OHj1qHnv48GENGjRIv/76623tlZ8yv9bOnTunSpUqWT0/ISHB4pQwR752S5YsKXd3d129elWSba+hG25nTn7K/L3hVhITEy2+Hvl15a2tdWX+vphdXZmvJy5Xrpw6depkc222Kizv5aKGgN3/u3TpkrZt26Z//vlHiYmJKlasmO666y41bdrU6v8QWuvYsWMKDQ3VqVOndOXKFfn7++uee+5RixYt8nzvNwAAAAofo9FIAAoAAAAAAABFWvfu3S0CdsuWLdO5c+dsOvmqsDAYDKpYsaKioqIkXT8BKzIyUkFBQVavsXfvXot25cqV7VmiQ9SuXVvr1q0zt3fv3q3atWtbPX/Pnj1WjTtx4oRFKOqhhx6yOlNw8eJFRUREWF1Tbtzd3dW8eXM1b95cwcHB+vzzz/Xyyy+bw06//fabDh06pFq1atllP3vJ/Frbu3ev7r//fqvnO9trt3bt2uaa4uPjFR0drQoVKlg939rXXUEJDw+3afz+/fst2lWqVLFnOWb5UVfmvpuDbQXpTn0vFzUuji4gJ9HR0Vq+fLnGjRunDh06yMfHRwaDwfzHlr8c5CY+Pl4vvfSSSpcurY4dO+rFF1/UpEmTNGbMGPXt21fVqlVTo0aNtHLlyjzvtWLFCjVs2FDVq1dX3759NWbMGE2aNEkvvviiOnbsqDJlyujll1+2OXkLAAAAAAAAAAAAAIXZsGHDLK74u3z5st5//30HVuRYzZo1s2hv3LjRpvmZx2de706U+XrW1atXWz03IyNDv/zyi1VjY2NjLdo1a9a0ep8///zTfNqZPRkMBg0fPlx9+/a16N+yZYvd98qrwvbazcvr7uDBgzp27Ji9S8qTLVu2KCMjw+rxmzZtsmhbc03y7ci8j63js6urffv2Fm1bX4v54U56Lxc1TnWC3datWzVz5kzt2LGjQI7BDAkJUa9evW4ZaNu1a5e6deumAQMGaN68eSpWrJhN+1y+fFlDhw7Vd999l+u48+fP69NPP9WiRYu0ZMkStWnTxqZ9AAAAUDglJCRwRSzyDVfEAgAAAACAO4G/v7+GDh2qTz75xNz34YcfqkePHmratGme1v7111/VpUuXvJZYoNq2bWtxTemCBQs0ZMgQq+YePnxYW7duNbeLFy+e58+hM+jcubOKFy+uy5cvS5JWrlxp9WliS5cuVUxMjFX7mEwmi/aVK1esrvGzzz6zeuztaNmypRYuXGhuO+PhPm3btrVoL1++XMnJyfL19b3l3KtXr+rbb7/Ndb2C9vjjj2vevHnm9hdffKFnn31WLi63Pu/q008/zc/SbktcXJzWrFlj1ffEa9euWbzepPz7euzatUsHDx606lTK8+fPa+nSpbesq0KFCqpTp475dLxjx47pt99+08MPP2yfovPgTngvFzVOFbALCwvT8uXLC2SvLVu2qEuXLrp48aJFv5+fn6pUqaLExESdPHnSIpn7zTff6Pz581qyZIkMBoNV+1y7dk1PPvlklhPwXF1dValSJfn6+ioiIkLJycnmx+Lj4/Xwww9r/fr1at68eR6eJQAAAO4kl69cVvFixS36EhISFFStqlKTknOYBeSNt5+vIo8dJ2QHAAAAAACcXnBwsFauXKnIyEhJ108d69atm9auXau6devavN7Vq1c1fvx4LV261G7XdhaUp556SqNHj1ZaWpqk6yejrVixQt26dbvl3JEjR1q0e/fubVW4ydmVLl1a3bt3148//ijp+nWsw4cP1/Lly3MNO8XHx2vUqFFW71O2bFmLtrUnS/366692uTkvN5lDOP7+/vm63+2oVauWWrRooW3btkm6HoaaPHmyPv7441vO/eSTT3TixAlzOygoSA888EB+lWqVhx9+WHfddZdOnTol6fqVrx999FGW91lmW7du1dy5cwuiRJtNmDBBDz74oFxdXXMdN2/ePB05csTcvuuuu9S5c+d8q2vs2LH6+eefbzlu6tSpFocWNGvWLMfrVUePHq2BAwea26+99ppatGjh8O+Jd8J7uahxqoBdbkqWLKnz58/bZa3ExEQ9+eSTFuG6ypUr65NPPtHjjz9uDs+dOnVK77zzjubMmWMet2zZMn300Ud6/fXXrdprxowZWf4j+fzzz+uNN95Q+fLlJV0P4a1cuVKvvfaa+T8GFy5cUO/evRUeHu7wNy4AAAAKxrCpE9WqXhM906O3uS8lJUWpSclym99NhgAvB1aHwsgUl6bUZ1YoJSWFgB0AAAAAAHB6fn5+WrRokVq1amW+ZjMmJkZt27bVf/7zH/Xp08fqg1I2bdqkV155Rfv27VPlypXzs2yrBAcH66233jK327Ztq5CQkBzH+/n5aciQIZo9e7a5b8iQIapatarq1auX47zJkydbXIXq4uKiESNG5K14J/LGG29o2bJl5lPlVq1apYEDB+qzzz6Tt7d3lvFHjx5Vr169dPLkSRkMhiyn02WnUqVKqlChgqKjoyVdP0ho0aJFevLJJ3OcExoaqv79+9v0XPr166fnnnvO6hPBEhMTNX/+fIu+hg0b2rRnQRk5cqQ5YCdJs2bNUoMGDTRgwIAc56xZs0YTJ0606HvttdesOikuP7m6uio4OFjPPPOMuW/06NFydXXVq6++mu33pPXr16tXr17KyMiw+nVXkPbu3avhw4dbZGUy2759e5bczEsvvXTLUF5erF69Wu+++64mTJiQ45jly5drxowZFn2vvfZajuP79eun6dOn68CBA5Kkf//9Vw8//LCWLFlizvTcytWrV/X9998rJiZGY8eOzXaPwvpeLkqcMmDn7e2thg0bqnHjxmrSpIkaN26siIiILPcf364ZM2ZYXEFbpUoVbdmyJcub46677tIXX3yhSpUqWXyjnjJligYPHnzLhOi5c+c0depUi7733ntP48aNs+hzcXFR9+7d1aRJE7Vq1cr8GxenTp3Shx9+aPEXKQAAABReqRfS9NYPH+ifqKP64HXL/4NoCPCSobyPgyoDAAAAAAAAnEOTJk00b948DRkyRNeuXZN0PYzQt29fffTRRxo6dKgefvhhVapUKcvcI0eO6Oeff9aSJUv0119/WbXfrl27lJiYmKU/NjY2S9/69euzXcPf3z9fwhFTp07Vzz//bP735cTERLVo0UJvvfWWhgwZYvHv2eHh4Zo8ebKWLVtmscbo0aN1//332702R6ldu7beeOMNvfHGG+a+hQsXasOGDerbt68aNWokHx8fxcXFaePGjfrpp5906dIlSdKwYcP0xRdfWLXPgAED9N5771m0jx8/rhdffFE+Pv/7Oe6pU6f0xRdf6IMPPtDly5fl4eGhsmXLmr9mufnll1/0/fffq1atWurVq5ceeugh3XffffL09LQYd/HiRa1evVoTJ05UVFSUuf++++5T48aNrXo+Be2JJ55Qjx49zNd4mkwmDRo0SNu2bdOYMWNUtWpV89gzZ85o9uzZmjFjhtLT0839LVq00EsvvVTgtWdn6NCh+vHHH83fA0wmk0aMGKEvv/xSffr00T333CN3d3dFRUXp559/1tq1ayVJnp6e6tGjR5Zrbx2pcuXKioqK0ty5cxUREaFp06apQYMG5scTExM1b948TZ482fzekaQ6depYfVBVXuqaOHGi+ftZzZo1zY+fOXNGH3/8sWbOnGlxU2Xnzp1zDb+6urpq6dKlatq0qfnmyb/++kt16tTRyy+/rH79+unuu+/OMi82NlZhYWH6+eeftXz5csXHx1uchHezwvxeLkqcKmD32GOPqXPnzrrnnnuypIztdSRvfHy8RYpfun5sZW7J0/Hjx2vNmjXavHmzJCk5OVkffPBBlvBcZtOnT1dqaqq53aZNm2zTqjdUqFBB8+fPV6dOncx9H330kV555RWVKlUq170AAABQeCzatkJHoyO16L3Ztx4MAAAAAAAAFDEDBw6Ur6+vBg4caHENYFhYmMLCwiRJRqNRZcqUka+vr86dO6czZ87owoUL2a5Xrly5HPcaOXKkNm3aZFVdOV1VeavT6G6Xt7e3fvrpJ3Xu3NkcAkxLS9OoUaM0fvx4ValSRT4+Pjpz5oz5tLWbPfTQQ5oyZYrd63K0G+GUm0+AOnPmjGbOnJnjnJdffllPPPGERcDOzS3nOMWoUaP07bffmq8FvXLliiZMmKA333xTNWvWlJeXl+Lj4xUZGWlxOtmsWbP03XffWRWwu+HQoUOaMmWKpkyZIldXV911110yGo0qVqyYkpKSdPz4cfOJjjd4enrqyy+/tHoPR5g7d66OHj2qvXv3SroeSpszZ47mzJmjoKAglSlTRgkJCYqIiDCHaW+oUqWKvv/++3w9Lc1WP/30kzp16qRdu3aZ+/bv36/9+/dnO97V1VULFiwwn5x2Q26vu4IwZswYffHFF9q/f7/WrVundevWqWzZsrrrrruUmpqa7evN399f3333ndzd3fOtrvfff1+vv/66Tp8+rR9++EE//PCDKlWqpMDAQCUmJur48eNZXieVK1fWf//731uuXbNmTS1fvlw9evQwfy9NTEw0v+9Kly6tsmXLysvLSykpKTp79qzi4+Ntfg6F9b1cVDj2rMxMqlWrptq1a+frEZ4//vijxVWzbdq0UceOHXOdYzAYNHnyZIu+L7/8MtdjOq9du6avvvrKoi84OPiWRxJ37NhRrVu3NrdTU1O1ePHiXOcAAACg8NkVtUdthvXW2cQER5cCAAAAAAAAOJ1u3bpp79696tq1a7aPJyQk6PDhwwoNDdWxY8eyDdeVKlVKH330kfmglTtRo0aNtHnzZosTv6TrVxb++++/2rlzZ7bhukGDBmnVqlUqVqxYQZVaYAwGg+bOnav3339fJUqUyHWsm5ub3n77bc2aNcsiRyBJvr6+Oc4zGo1atWqVAgMDLfrT09N14MABhYaGKiIiwpwpcHFx0Ycffqhnn332Np/VdRkZGYqKitLu3bu1Y8cOHT58OEsgp0KFClq/fr3FqWPOyGg0atOmTdkGUyMjIxUWFqZjx45lCU01btxYW7dudYqrnW/m5+en9evX53iK2c1Kly6tFStWqFevXja97gqCp6enfv31V9WqVcvcFxMTo507d2b7egsMDNSaNWtyvZraHm7sc/PhWSdOnFBYWJiOHj2a5XVSvXp1bdy4UXfddZdV67dv315hYWHZnhR39uxZhYeHa8eOHTp06FC24TqDwaCKFSta/XwK03u5qHCqgF1BWLlypUV76NChVs1r3769qlSpYm7HxMRo+/btOY7ftm2bxZuqatWqateunVV7Za5pxYoVVs0DAACAc6nYs4lNf0IjdlnMP516Rv2njZRXKaODngEAAAAAAADgvIKCgrRixQrt3r1bw4cPV9myZW85x8vLSw8//LB+/PFHRUdH67XXXsvXU5cKQp06dXTw4EHNmDEjS9DuZm5uburYsaP+/PNPffXVV3f8886NwWDQmDFjdPjwYb3zzjtq1qyZAgMD5ebmJl9fXzVq1Ejjxo3Tv//+q0mTJkm6Hsq82a2CTvfff7927dql/v3753iSmsFg0AMPPKDt27drxIgRNj2H0NBQTZ8+XR07dpSXl9ctx1evXl1vv/22Dh8+rObNm9u0l6P4+vpq7dq1WrZsmZo0aZLrgUV16tTRV199pe3bt+d66qQj+fn5acGCBQoLC9Orr76qOnXqyN/fX25ubgoICFCHDh300Ucf6dixY3r00Ucl2f66Kwh33XWXwsLCNHr0aJUsWTLbMV5eXnruued08ODBAru+tE6dOtqzZ4+eeeYZFS9ePNsx/v7+Gjt2rPbt25fr98PsVKtWTaGhoVq1apU6dOhwywCyq6urmjdvrilTpujo0aN6++23sx1XFN7LRYHBlNsxbE4kJCRE7du3N7crV65s07GpknT+/HkZjUaL1OeZM2es+ouWJD333HOaN2+euT1hwoQcr4kdP368pk2bZm7bcl/76dOnVaFCBXO7WLFiSkhIsOqNlh8OHDigOnXqmNvh4eG69957HVILAODO8l73N3V42wHVbHGvxi8vfMfMA9l5aOjDMhgMMplMOpB8zi5ruppcldKxotKalrbLesANAbvPqdjOGDVr1lQeHh55WutI/BHzxzXK1MhracAdY+fJg+aP945e4sBKAAAAgDtPenq6jhw5YtFXo0YNh1+PhzvbsWPHFB4erpMnTyo1NVUmk0l+fn4yGo2qXbu27r33Xqe6VjI//PPPP9q9e7fi4uJ04cIFlSpVShUqVFCrVq2cIrzjrEaNGmVxjWxISIjatm1r1dyEhARt3rxZUVFRSk1NlZeXl6pUqaIWLVooICAgz7VlZGTo0KFDOnLkiKKjo5Wamirp+jXBFSpUUP369S0ODLpTxcbGatu2bYqJiVFiYqJ8fHwUGBiopk2bqlKlSo4uL180atTIfK1ssWLFlJqaWqAnSy5YsECDBw82t7/66isNGjTI3L506ZK2bNmiQ4cOKSUlRf7+/qpcubLat28vT0/PfKsrODhYb731lrn9xx9/WBxqlZKSoj///FNHjhxRWlqaSpcubT74yl7h4QsXLmj79u06efKkzp07p4sXL6pkyZIqXbq0atasqVq1atmc43Hkezm//t5VVDJFRepvpwcOHLAI11WpUsXqcJ0ktWzZ0iJgt2fPnhzHZn6sRYsWVu9Tvnx5BQUFmQOEV65cKdDULwAAAJyLITFD58u5K+ff3QNuT/FL1+RVrYzC44/bdd2bA0cAAAAAAAAFqVq1aqpWrZqjy3Coe+65R/fcc4+jy7jjbNiwwfyxi4uLTdcyGo1GdevWLR+qus7V1VV16tSxCLEURoGBgerevbujyygwZ8+e1b59+8ztevXqOd21zR4eHurUqZM6derk6FIs+Pj46JFHHsnXPTw9PdWhQwe7rllU3suFUZEK2B06dMiiXbt2bZvmZx6feT1773XzCX2HDh0iYAcAAHCHifhxm03je497SWGRf1v09Wj0iD4ZHyz3EXfbszRAknTZw0WmcE6wA/KCQCkAAAAAAHe+P//80+IQnbp168rb29txBaFI+Pzzzy0OiWrZsqUDqwGQmyIVsDt8+LBFu2LFijbNzzw+KipKly5dyvIPURcvXtSJEyfsulfm2gEAAOD8bD1W22D43xl1bnLTlIFj1LpufX0yPtjOlQHXxQa66+qczdow7msFBQXlaa1Xlg43fzyrB9eCo+i4b0ZPR5cAAAAAAABuYjKZLH7WeispKSl69tlnLfqGDBli77JQyNn6utu7d6/effddiz5ed4DzcnF0AQUpLi7Oon3XXXfZND8wMNDiH0mvXbumc+fOZRl39uxZmUwmc9vd3d3me9UrVKhg0c5cOwAAAAovT1dPfT/pP3r6sW6OLgUAAAAAAAAA7ihRUVFq27atfv/9d2VkZOQ6ds+ePWrZsqXFgTelSpXSgAED8rtMFDLfffedBgwYoL17995y7NKlS9WuXTtdunTJ3NehQwfVq1cvP0sEkAdF6gS78+fPW7S9vLxsmm8wGFSiRAmlpqbmuGZ2fZ6enjYllbOrLbt9bkdcXJzi4+NtmnP06FG77A0AAIBbC/QK0Irp83VXYFlHlwIAAAAAAAAAd6TNmzdr8+bNCgwM1EMPPaSGDRuqQoUK8vT0VHJyso4dO6YNGzZo48aNWeZ+8cUX8vPzK/iicUdLT0/Xt99+q2+//Va1a9dWhw4ddN999ykgIEBubm5KSEjQ/v379csvv+jAgQMWc729vTV//nwHVQ7AGkU6YJf5aldr3E7A7nb3yW3N2/XZZ5/prbfesstaAAAAsK8nOz2qx9p2UgmP4lkeM8WlOaAiFHa8rgAAAAAAAFBQzpw5kyVYZA8NGzaUv79/to/Fxsbq66+/1tdff33LdQwGg95//3317NnT3iU63NatW3Xx4kW7runv76+GDRvadc3C4uDBgzp48KBVY319fbV06VJVqVIly2OOeM8AyF6RCtjdfLymJBUrVszmNYoXt/zHzuz+I1RQ+wAAAKBw6f3gI1n6fHx85O3nq9RnVhR8QSgSvP185ePj4+gyAAAAAAAAUMitWbNGgwcPtvu6f/zxh9q1a2due3h4qFSpUjp37pzVa9SqVUvTp0/Xo48+avf6nEG/fv0UFRVl1zXbtm2rkJAQu655JytdurSKFy+uy5cvWz2nc+fO+vjjj1WrVq1sHy+o9wyAWytSAbvMJ8lduXLF5jUyfzPM7nS6gtoHAAAAhZ/RaFTkseNKSUlxdCkopHx8fGQ0Gh1dBgAAAAAAAGAXZcuWVUxMjDZt2qSQkBDt2rVLx44dU2xsrNLS0uTm5iaj0ahy5cqpZcuWeuCBB9SlSxe5uLg4unTcwR599FHFxcVpzZo12rJli/bt26eIiAidO3dOFy9elKenp4xGo4KCgtS2bVs99thjatSokaPLBmClIhWwK1mypEU780lz1sh8klzmNQtyn9sxfPhw9erVy6Y5R48eVbdu3eyyPwAAAGxnNBoJQAEAAAAAAACAldzc3NSxY0d17NjR0aWgCPHx8VGvXr1szmQ40qBBgzRo0CBHl5FFcHCwgoODHV0GYFakA3ZpaWk2zTeZTLcVsLtw4YJMJpMMBoPVe2WuzV4Bu4CAAAUEBNhlLQAAAAAAAAAAAAAArOGsQZ6iIDIy0tEl4DbwngGcR5E64zRzsOzUqVM2zY+NjVV6erq57eLiotKlS2cZV7p0aYsw3dWrVxUXF2fTXtHR0RZtQnEAAAAAAAAAAAAAAAAAULCK1Al2NWvWtGifOHHCpvmZx1euXFkeHh5ZxpUoUUKVKlVSVFSUxdzAwMDb3uuee+6xqVYAAAAUHgkJCUpJSXF0GSikfHx8uIIYAAAAAAAAAAAgB0UqYJc5pHbw4EGb5h86dCjX9TI/dnPA7uDBg2rcuHG+7AUAAIDCYebX89W78yOqWK6cuS8hIUFB1aoqNSnZgZWhMPP281XkseOE7AAAAAAAAAAAALJRpAJ29957r9zd3XX16lVJ1+8ZP3PmjMrd9A+Yudm6datFu379+jmOrV+/vtasWWNub9u2TQMHDrRqnzNnzljcge7u7q7atWtbNRcAAAB3rm3huzT314X6avyHalG/gSQpJSVFqUnJcpvfTYYALwdXiMLGFJem1GdWKCUlhYAdAAAAAAAAAABANopUwM7b21tt2rTRhg0bzH3r1q3TgAEDbjnXZDJp/fr1Fn2PPfZYjuMfffRRvf/+++b2+vXrZTKZZDAYbrnX2rVrLdrt27dXyZIlbzkPAAAAd74LGRfU950XFdx/pAZ162nuNwR4yVDex4GVAQAAAAAAAAAAAEWPi6MLKGiPP/64Rfu///2vVfP++OMPRUREmNuBgYFq2rRpjuNbtGih0qVLm9vHjx9XSEiIVXtlrqlr165WzQMAAEDhkKEMvbFwusZ9Mt3RpQAAAAAAAAAAAABFWpE6wU6S+vTpowkTJigtLU2StHnzZm3cuFEdOnTIcY7JZNJbb71l0Td48GC5uOScT3RxcdGgQYP0wQcfmPveeusttWvXLtdT7DZs2KA///zT3Pb29lbv3r1v+bwAAADgfGYsmGvT+H9PH7Nof/fnEh04fljSrU9BBgAAAAAAAAAAAGB/RS5gFxAQoJdeesni+tZnnnlGW7ZsUfny5bOd895772nz5s3mtq+vr0aPHn3LvcaOHasvvvhC58+flyRt2rRJ77//vsaNG5ft+OjoaD3zzDMWfa+++qrFSXgAAAC4c8xaPT/Pa+yJ3q+qjzTXmbQMZdihJuBmgbFXVWxYG00M+UweHh55WutIfKL546E/vpnX0gAAAAAAAAAAAJyC0wXstm7dqosXL2bp37t3r0X70qVLWr9+fbZrlC9fXrVr185xjzFjxujrr79WTEyMJCkiIkItWrTQrFmz9Nhjj5lPmDt16pTeeecdzZkzx2L+xIkTZTQab/lcSpcurQkTJmjChAnmvvHjx+vEiROaNGmSOdB37do1rVq1Sq+++qpOnDhh8TxGjhx5y30AAABQuJncJbc0EwE72F3xS9fkVa2MwuOP23XdnScP2nU9AAAAAAAAAAAAR3G6gF2/fv0UFRV1y3GxsbF64IEHsn1s4MCBWrBgQY5zjUajFi1apAcffFCXLl2SJEVFRalr167y8/NTlSpVlJSUpBMnTigjw/KfMbt27apRo0ZZ/XzGjh2rbdu2afXq1ea+zz//XHPnzlXlypXl6+uriIgIJSUlWcwrUaKEFi9eLD8/P6v3AgAAgHOpagyyafzxhMgsfeW8ymr34rUyDKnCRbGwu8seLjKFx6hZs6Z2OMHuiPnjGmVq5LU04I5BoBQAAAAAAAAACjenC9gVlDZt2uiXX35Rr169lJCQYO5PSkrS7t27s53Tt29fffnll+YT7qzh4uKin376SYMHD9aPP/5o7s/IyNDx49mfElGqVCktWbJELVu2tHofAAAAOJ9NcxfbNL7H6BcUGrHL3G5SpaGmDRupu7+pIXd7FwdIig1019U5m7Vh3NcKCgrK01qvLB1u/nhWjyl5rAy4c9w3o6ejSwAAAAAAAAAA5CMXRxfgSB06dNDBgwf1wgsvyNPTM8dx999/v5YuXarvvvtOxYsXt3kfDw8P/fDDD1qyZInq16+f4zgvLy8NHz5cBw8eVLt27WzeBwAAAIVH31Y9tHTG53J3K7K/EwMAAAAAAAAAAAA4nNP9a11kZGSB7hcYGKjPPvtMM2fO1LZt23To0CElJSWpWLFiqlChgpo2barq1avbZa8ePXqoR48eOnr0qHbs2KHo6GhduXJFfn5+qlWrllq2bJnna5kAAABwZ3OVq97sN1JDunMiEgAAAAAAAAAAAOBoThewc5QSJUqoY8eO6tixY77vVb16dbuF9gAAAFB4VClXUSOeGqpWDRplecwUl+aAilDY8boCAAAAAAAAAADIHQE7AAAAwEl88PqELH0+Pj7y9vNV6jMrCr4gFAnefr7y8fFxdBkAAAAAAAAAAABOiYAdAAAA4MSMRqMijx1XSkqKo0tBIeXj4yOj0ejoMgAAAAAAAAAAAJwSATsAAADAyRmNRgJQAAAAAAAAAAAAgAO4OLoAAAAAAAAAAAAAAAAAAACcEQE7AAAAAAAAAAAAAAAAAACywRWxAAAAgJNLSEhQSkqKo8tAIeXj48MVxAAAAAAAAAAAADkgYAcAAAA4idD9+9To3jpycfnfQdMJCQkKqlZVqUnJDqwMhZm3n68ijx0nZAcAAAAAAIAsIiMjVaVKFXN74MCBWrBgQY7jBw0apK+//trcjoiIUFBQUD5WiKJmwYIFGjx4sLn91VdfadCgQY4rCECRQMAOAAAAcBLvf/O5rl69qkXT/qMSHsUlSSkpKUpNSpbb/G4yBHg5uEIUNqa4NKU+s0IpKSkE7AAAAAAAQKEQERGh8PBwnTx5UikpKbp27Zr8/f3l7++vWrVqqU6dOnJ1dXV0mQAA4A5CwA4AAABwIrtP7VOb53tp5fR5Kh8QaO43BHjJUN7HgZUBAAAAAAAAzmn//v2aO3euli9frujo6FzHenp6qmXLlurfv7969OghLy/rfqk1Pj5eoaGhFn8SEhIsxphMptt+DgAAwHm53HoIAAAAgIIUcz5GHV7pox379ji6FAAAAAAAAMBpnThxQj169FC9evX06aef3jJcJ0kXLlzQunXrNHDgQJUvX17vvfeeLl26lO3YQ4cOqU+fPqpataoCAgL06KOPasqUKfr999+zhOsAAM7BYDCY/7Rr187R5aCQ4AQ7AAAAwAmlpaepz5Ther3rs44uBQAAAAAA4I5QfNdwR5dQaFxu+JmjS7il1atXq3///kpOTs72cX9/f5UpU0a+vr46e/asYmNjdeHCBYsxKSkpmjBhgpYtW6awsLAsaxw+fFiLFi3Kl/oBAMCdg4AdAAAAkE8q9mySp/npSteMlV+ofIN7FW+nmoCbBcZeVbFhbTQx5DN5eHjkaa0j8Ynmj4f++GZeSwMAAAAAAMjRd999p4EDByojI8Oiv2HDhho6dKi6dOmiypUrZ5l3+PBhrVy5UosXL9auXbvM/fHxtv/0rWTJkjp//rztxd9hgoKCuPoWTmXQoEEaNGiQo8sAUMQQsAMAAACcmEkmuQZ5yTvqis6Xd3Q1KGyKX7omr2plFB5/3K7r7jx50K7rAQAAAAAA3LBz504NGTLEIlzn6+urTz/9VP369ZPBYMhxbs2aNTVmzBiNGTNGy5cv1/jx43X48OFb7lmiRAnVr19fTZo0UePGjdW4cWO5u7uratWqdnlOAADAuRGwAwAAAJyYm9yUsidaqYNqKOcfDQK357KHi0zhMWrWrKkdTrA7Yv64RpkaeS0NuGMQKAUAAACAgpOSkqInn3xSV65cMfcFBARozZo1ql+/vk1rde/eXY888oiGDx+u9evXZzumSZMm+vvvv1W3bl25uVn+03pkZKSt5QMAgDsUATsAAAAgn5xcEmrT+B6jX1BoxP+upvByK6kZQ8fp8c4Pyt3exQGSYgPddXXOZm0Y97WCgoLytNYrS4ebP57VY0oeKwPuHPfN6OnoEgAAAACgyAgODtbx4/87id/FxUUrVqywOVx3Q7FixTR//nwtW7Ys28fLly+v8uW5VgIAgKKOgB0AAADghMqVLKdVM+brUlqao0sBAAAAAAAAHC4pKUnz5s2z6HvttdfUvHnzPK/9xBNP5HkNZ3L48GHt3r1bcXFxSktLU+nSpVW+fHm1atVKvr6+ji6vwF26dEmbN29WRESEzp49q5IlS+ruu+9W69atVbJkSbvtExcXp/DwcB07dkxJSUlKT0+X0WhU2bJl1bRpU5UtWzbPe8TExOjvv/9WZGSkUlJSdO3aNXl6eiogIEBVq1ZVnTp17Pqc7Ono0aPasWOHoqOjJUkVKlRQgwYNVKtWLYfWFR4erp07dyomJkbu7u6qUKGCmjVrludfSL7hypUr2r59uyIjIxUfH69r166pTJkyqlGjhpo1ayZXV1e77JOfDh8+rB07duj06dNydXVVQECAmjRpYrev3YULF7R161ZFR0crLi7OvEft2rXVoEGDXK/+BgoKATsAAADAyTSoeJ8Wv/+pihcrrkgCdgAAAAAAAIDmzJmj8+fPm9vFihXT+PHjHViRc7l8+bJmz56tL774QseOHct2jJubm9q2bavg4GC1atXKqnUjIyNVpUoVc3vgwIFasGCBPUrOd8nJyZo0aZK+/vprpaamZnncw8NDAwcO1NSpU1WqVCmFhISoffv25scnT56s4ODgHNc3mUzasmWLFi9erHXr1unw4cO51lO3bl2NHDlS/fr1y3Ll8K389NNP+uijj/TXX3/lOs7V1VX16tVTt27d9NJLL8loNNq0T14EBQUpKipKklS5cmXzNcohISEaP368tm/fnu28++67T1OnTtUjjzxi1T4LFizQ4MGDze2vvvpKgwYNynH8zeGstm3bKiQkRJK0bNkyvfHGGzp48GC2c1q0aKEZM2bcdog3PDxcU6ZM0W+//Wbxvetmfn5+6t+/v9544w0FBATc1j55ldt7fO3atZo4caJ27tyZ7dxatWrp/fff12OPPXZbe2/dulVTp07Vxo0bdfny5WzHBAQEaNiwYRo9erS8vb1zXKtdu3batGlTlv5NmzblGtC71fscuMHF0QUAAAAAuM7F4KJezbpq5UfzVLxYcUeXAwAAAAAAADiNzNe4du/eXaVLl3ZQNfYXHBwsg8Fg/tOuXTur5x44cEC1a9fW6NGjcwzXSVJ6ero2bNig1q1ba8iQIbp69aodKndOe/fuVa1atfTpp59mG66Trp9sN2fOHN133306cOCAzXuMHj1abdq00aeffnrLcJ0k7d+/X4MGDVL79u0VFxdn1R6XL1/WE088od69e98yXCdJGRkZ2r17tyZPnqy///7bqj3y04wZM9ShQ4ccw3XS9a/Vo48+queff14mkynfazKZTHr55ZfVo0ePbMN1N8Zs3bpVrVq10ttvv23T+unp6Xr55Zd133336aeffsoxXCddP5nz008/VfXq1fXLL7/YtE9+GzNmjB588MEcw3WSdOjQIT3++OM2f47S0tLUu3dvtWrVSr/99luO4Trp+smQb7/9tu6++26FhYXZtA9gT5xgBwAAADiJ2aODVbZMmWwfM8Vxkh3sj9cVAAAAAAC4E6SlpWUJC3Xt2tVB1TiXnTt3qnPnzkpMTLTod3d3V1BQkHx9fXX69GmdPn3a4vGvvvpKZ86c0cqVK1WsWLGCLDnfHTp0SJ06ddLZs2ct+t3c3FSlShX5+voqNjZWJ0+elCRFR0froYce0syZM23a59KlS1n6/P39VbZsWfn4+Ojy5cuKjY3VmTNnLMZs2bJFHTp0UFhYmEqUKJHrHs8884yWL1+epT8gIEAVKlRQ8eLFlZqaqri4OMXHx9tUf3779ttvNWbMGHO7ePHiCgoKkpeXl06ePJml3jlz5shkMmnOnDn5Wtc777yjTz/91Nz29PRUlSpV5O7ursjISCUlJZkfu3btmt588025u7tr3Lhxt1z7woULeuKJJ7RmzZosj5UtW1Zly5aVi4uLTp06ZRGyTE1NVdeuXfXDDz+oV69eeXuCdjBu3DjNmDHD3Pb29lalSpVUokQJRUVFZfnavfnmm7r33nutum47Li5OXbp00a5du7I8dtdddykwMFAZGRmKioqy+L4WExOjdu3aac2aNVafwAnYEwE7AAAAwElkF67z8fGRt5+vUp9ZUfAFoUjw9vOVj4+Po8sAAAAAAADI0fbt25Wenm7R16hRIwdV4zxSU1PVq1cvixCKp6engoODNXToUIvrQfft26fJkydrxYoV5r7ff/9db775pqZNm1aQZeer9PR09e/f3yJc5+XlpcmTJ2f5nBw9elTvvfeevvzyS506dcqqAFVm3t7e6tmzpx555BG1aNFC5cqVyzImOjpaCxcu1LRp08zhrQMHDmjcuHH65JNPclw7LCxMCxcuNLfd3Nw0evRoDRs2TJUrV84yPjY2Vn/++ad+/vln/fTTTzY/F3tKTk7Wyy+/LOn65+idd97RoEGDLH4OuW3bNo0aNcriZL65c+eqQ4cOevLJJ/OlrqNHj2rr1q2SpMDAQM2YMUO9evWSh4eHpOsnAK5fv14jRozQoUOHzPMmTpyotm3b3vK62BdeeMEiXFeyZEmNGDFCgwcPtriGVbp+ct8777yjJUuWmPceOnSo7r//flWvXt0uz/d2bN68WREREZKkpk2b6u2331b79u3N1xqbTCZt2rRJL7zwgv755x/zvFdeeUWPP/54rtcfX7t2TX369LEI15UpU0ZjxoxR//79VbZsWYuxf/31l958801t3LhR0vUA41NPPaU9e/aoVKlSFmvPnDnT/L3wgQceMPfXq1cv1/Bs1apVb/k5ASQCdgAAAIBTMxqNijx2XCkpKY4uBYWUj4+PxQ8WAQAAAAAAnM3NIQ7pemjFkQEUZzFhwgRFRkaa276+vvrjjz90//33Zxlbr149LV++XJMmTdLUqVPN/TNmzFDv3r3VoEGDgig5333++ecWpx36+Phow4YN2QYyq1evrv/+979q1KiRhg8fbg4VWWvw4MF69913b/nLqxUqVNDYsWPVp08ftW/f3rzPvHnzNHny5Bx/Npc5JDd37lwNHjw4x30CAwPVs2dP9ezZUx9++KGuXbtm0/OxpxtBQn9/f23evFl16tTJMqZFixb6888/9eSTT2rp0qXm/ldffVWPPPKISpYsafe6oqOjJUmVK1fW1q1bVaFCBYvHXV1dzdeidu7c2RzGu3btmp577jnt27dPBoMh27UXLVqkb775xtyuVq2a1qxZo2rVqmU7/sYVsjNmzDCf9JeamqqRI0dq5cqVeX6ut+vG63PQoEGaP3++XF1dLR6/cYX15s2bVb9+ffPpmNHR0frll19yPV10xowZ+uOPP8ztpk2batWqVQoICMgy1sXFRS1bttS6dev06quvmk8dPHXqlKZMmZIlnNqwYcNs9/T391enTp2seOZA7gjYAQAAAE7OaDQSgAIAAAAAAECRlZCQYNEuU6ZMjiGXoiIpKUlffvmlRd9///vfbMN1N3vnnXf0999/67fffpN0PTj00Ucf6dtvv823WgvS7NmzLdqzZs265WmHL7zwgrZt22ZxWpw1cgr05KRy5cqaN2+eOexz8eJF/fjjjxo+fHi24//991/zxyVLltSAAQOs3ivz6V6OMm/evGzDdTe4urpq4cKF2rVrlzksGhsbq++//17PPfdcvtRkMBj0008/ZQnX3czT01PLli3T3XffreTkZElSeHi41q1bp86dO2cZbzKZFBwcbDE/t3DdzUaPHq2wsDBzoPLnn3/Wv//+q7vvvtvGZ2Y/jRo10ty5c7OE625WpkwZvfHGG3rhhRfMfb/99luOAbsLFy5o+vTp5na5cuX066+/3vLfPlxcXPTxxx9r586d2r59uyTpyy+/1FtvvSU/Pz8bnhWQNy6OLgAAAAAAAAAAAAAAgJxkDtgVxlBFcHCwTCaT+U9ISEiu47///ntduHDB3G7ZsqV69Ohh1V4ffvihRXvx4sXmENGd7K+//tKRI0fM7Vq1alkdSnv33Xfl4pL/8YmOHTtaXCO7bdu2HMdevHjR/LGLi0uB1GdPjRs3tuo16eHhoSlTplj0ZQ6P2lPPnj3VuHHjW44LCAjQyJEjLfpyqmvNmjUWJ22++uqrVoXrbpg0aZL5Y5PJpOXLl1s9Nz9MmTJF7u7utxzXu3dvi/bNp0dm9s0331h8Lw8ODrb6YAFXV1eNHz/e3D5//rzFVbxAQeAEOwAAAMDJJSQkcEUs8g1XxAIAAAAAAGeXmppq0fby8nJQJc5j06ZNFu0hQ4ZYPfeee+5RixYtzOGuK1euaPv27XrwwQftWmNB27Jli0W7b9++Vp90WLFiRbVt29bi+sr8EhQUpDNnzkiSdu/eneO48uXLmz9OSUnRzz//rMcffzzf67MXW07c69Gjh4YPH67z589Lknbu3Km0tLR8ea/bUteAAQM0efJkmUwmSVnfdzf8+uuvFu2nn37apprq1aunsmXLKiYmRpL0559/auzYsTatYS++vr5Wfy8wGo2qVKmSTpw4IUk6efJkjmNv/hy5ubmpT58+NtXVsWNHubi4mK8+vnG9MFBQCNgBAAAATuLylcsqXqy4RV9CQoKCqlVVatKd/xukcE7efr6KPHackB0AAAAAAHBa3t7eFu20tDQHVeI8duzYYdHu0KGDTfM7duxocXpaYQjY7dy506LdokULm+a3aNHitgN2kZGRWrx4scLCwhQeHq6zZ88qJSVFV65cyXXe2bNnc3zsgQce0IIFC8ztfv36KTg4WEOHDr0jTnFs166d1WM9PT3VuHFj8+c/IyNDu3btUps2bexak8FgUNu2ba0eX7lyZQUFBSkiIkKSFBMToxMnTqhSpUoW4/7880/zx15eXrrnnntsrq1ixYrmgN2hQ4dsnm8vDRo0sOm0xICAAHPALqeTME0mk7Zu3Wpu33333fLx8bGpLi8vL5UqVUrx8fGSHPs5QtFEwA4AAABwEsOmTlSrek30TI//HauekpKi1KRkuc3vJkMAv5kL+zLFpSn1mRVKSUkhYAcAAAAAAJxW5p9bFIbrTPPCZDJZnBTl4+OjoKAgm9a47777LNo3AjJ3sujoaIt2rVq1bJpv63hJioqK0quvvqpVq1aZTzmzRVJSUo6P9erVS1OnTtXBgwclXb8Wc9SoUZowYYLatm2rDh06qFWrVmrUqJE8PDxs3js/ubq62hwyq1OnjkXAMSIiwu4Bu0qVKmUJ7FpT142A3Y26Mgfsbg57paWl5fk638zXYhekgIAAm8bffMrgzdca3yw2NtbiOR08eNDq0yVz4sjPEYomAnYAAACAk0i9kKa3fvhA/0Qd1QevT7B4zBDgJUN5236jCwAAAAAAACgMMgfsbpxgVFQlJyebr0mUpFKlStm8RunSpS3aiYmJea7L0TKH1Xx9fW2ab+upcKGhoercuXOeAp+5nXDn7u6un3/+WV26dNHhw4ct5qxbt07r1q2TJBUvXlzNmzdX165d9dRTTykwMPC267EXX19fubnZFkfJ/DrOLXx4u27nvXKrutLS0nT58uW8lJWFI0PE+RHWPHfunN3XLOpBaxQ8AnYAAACAk1m0bYWORkdq0XuzHV0KAAAAAAAA4HCZT8JKTU3V0aNHVb16dQdV5Fjnz5+3aN98gpS1Ms9JTU3NU03OIHPIqVixYjbNL168uNVjz507py5dumQJ+dSrV0+tW7dW9erVVb58eZUoUUIeHh4Wp3WNHDlS+/bts2qfqlWr6u+//9bHH3+szz77LMspfdL15x0SEqKQkBCNHTtWw4YN09SpU20+qc2ePD09bZ6T+TWZ+XVuD/lRV34EAW/nNERnlh+fo5tDxkBBIGAHAAAAOKFdUXvUZlhv/eeVyY4uBQAAAAAAAHCoZs2ayc3NTenp6ea+nTt3FtmAXcmSJS3aaWlpNq+ReY4jw1j2kvnEuvPnz9t0Kl1KSorVY6dOnWpxKleNGjW0cOFCNWnS5JZzbQ15eXp6asKECRo3bpy2bt2qjRs3KiQkRDt27MhyJeeVK1c0e/ZsrV27Vps3b7b5uk97uXDhgs1zMr8mM7/O7SE/6sr89TQajVq0aJHtxRVimT9HtWvX1ieffJKnNUuUKJGn+YCtCNgBAAAA+aRiz1v/MCU3p1PPqP+0kfIqZVTOFwUAAAAAAAAAhZuXl5caNGig0NBQc9+qVavUp08fB1blOL6+vnJxcTGf4HQ71y+ePXvWou3v72+X2hwp81XCp0+ftilgd/r0aavH3hyg8vDw0O+//66qVataNTchIcHqfW7m4uKi1q1bq3Xr1po8ebKuXr2qnTt36vfff9f333+vo0ePmscePnxYgwYN0q+//npbe+VVcnKyrl69Knd3d6vnZH4d23plrzUyv+6tcau6/Pz8LALAFy9eVKdOnW67xsIo85XUJpOJzxHuOATsAAAAACeWlpGm0m3vVsrJK0or7+hqUNgExl5VsWFtNDHkM3l4eORprSPxieaPh/74Zl5LAwAAAAAAsNC9e3eLgN2yZct07tw5lSpVyoFVOYbBYFDFihUVFRUl6frJa5GRkQoKCrJ6jb1791q0K1eubM8SHaJ27dpat26dub17927Vrl3b6vl79uyxatyJEycswngPPfSQ1eG6ixcvKiIiwuqacuPu7q7mzZurefPmCg4O1ueff66XX37ZHLz87bffdOjQIdWqVcsu+9kiIyND//zzj+rWrWv1nP3791u0q1SpYu+ydPLkSaWkpMjHx8fqObeqy2AwqHLlyjp27Jik61/j06dPq3x5fqB/Q9myZVWiRAnziYtRUVE2BzABRyNgBwAAADg5Q2KGzpdzl8HRhaDQKX7pmryqlVF4/HG7rrvz5EG7rgcAAAAAADBs2DBNnTpV58+flyRdvnxZ77//vqZPn+7gyhyjWbNm5oCdJG3cuFFDhgyxev7GjRuzrHeny3w96+rVq9WvXz+r5mZkZOiXX36xamxsbKxFu2bNmtYVKOnPP//U1atXrR5vLYPBoOHDh+uvv/7SwoULzf1btmxxSMBOkjZt2mR1wO7ChQvauXOnue3q6qqGDRvavSaTyaTNmzfr0UcftWp8VFSUIiMjze2yZcuqUqVKWca1b9/eHLCTrr+/+vfvn+d6Cwt3d3e1bNlS69evl3T9671jxw61atUqX/YzGAwymUySZP5fIK8I2AEAAAD5JOLHbTaN7z3uJYVF/m3R16PRI/pkfLDcR9xtz9IASdJlDxeZwmPUrFlTO5xgd8T8cY0yNfJaGnDHIFAKAAAAAAXD399fQ4cO1SeffGLu+/DDD9WjRw81bdo0T2v/+uuv6tKlS15LLFBt27a1uKZ0wYIFVgfsDh8+rK1bt5rbxYsXz/Pn0Bl07txZxYsX1+XLlyVJK1euVHR0tCpUqHDLuUuXLlVMTIxV+2QO7Fy5csXqGj/77DOrx96Oli1bWgTsbudKVHv55ptv9NJLL1k1dunSpebwrCQ1bNhQXl5e+VaXtQG7b775xqLdpk2bbMc99NBDmj9/vrn96aefErDL5KGHHjIH7CRp9uzZ+Raw8/LyMr+eLly4kC97oOghYAcAAADkEzc32/66bTD874w6N7lpysAxal23vj4ZH2znyoDrYgPddXXOZm0Y97VNV4hk55Wlw80fz+oxJY+VAXeO+2b0dHQJAAAAAFBkBAcHa+XKleYTpTIyMtStWzetXbvWpqsob7h69arGjx+vpUuX2u3azoLy1FNPafTo0UpLS5N0/WS0FStWqFu3brecO3LkSIt279695evrmx9lFqjSpUure/fu+vHHHyVdv6pz+PDhWr58uVxcXHKcFx8fr1GjRlm9T9myZS3aW7ZssWrer7/+qpUrV1q9z+3IHKjz9/fP1/1yExYWpqVLl6pHjx65jrt06ZImT55s0WfLaYy2WrJkicLCwtS4ceNcx8XFxWnmzJlW1dWtWzdVr15dR48elSTt2LFDn3/+uV544QX7FF0IPPPMM3rnnXeUlJQk6frX4ZdfftEjjzxi972MRqM5YHfzCYRAXuT8XxEAAAAADuHp6qnvJ/1HTz/WzdGlAAAAAAAAAE7Dz89PixYtkru7u7kvJiZGbdu21Q8//GDTVYCbNm1So0aNNHPmTKe4QjA4OFgGg8H8p127drmO9/PzyxL2GTJkiPbt25frvMmTJ1tcheri4qIRI0bcdt3O5o033lCxYsXM7VWrVmngwIFKTU3NdvzRo0fVuXNnnTx50uIXoHNTqVIli1PxwsLCLE4TzE5oaKjNJ5r169dPmzZtsnp8YmKixSlqkvLlmlVbPPvsswoPD8/x8WvXrunpp5+2CLgGBASob9+++VaTyWRS7969dfr06RzHXLx4UU888YSSk5PNfbVr11bnzp2zHe/q6qq3337bou/VV1/VvHnzbKrt33//1XPPPafo6Gib5t0JfH19NXbsWHP72rVreuqpp7Rq1Sqb1tm1a5eefPLJXMfce++95o/Pnj2rkJAQm/YAskPADgAAAHAigV4B2jDrRzWvf7+jSwEAAAAAAACcTpMmTTRv3jyLE8kSExPVt29fNW3aVHPmzNGJEyeynXvkyBF9+OGHatGihdq1a3fLMJp0Pcyxfv36LH9uvmL1huzGrV+/Xrt27br9J5yLqVOnWtxKkJiYqBYtWmjmzJlKTEy0GBseHq4ePXpoyhTLmwdGjx6t++8vPD+LrF27tt544w2LvoULF6pmzZoaNWqUfvzxR/36669asGCBBgwYoLp162rPnj2SpGHDhlm9z4ABA7K033vvPaWkpFj0nzp1SpMmTVKbNm2UmJgoDw8Pq2+S+OWXX9SuXTvVrl1bkydP1l9//ZXtdZcXL17UTz/9pKZNmyoqKsrcf999993ylLb84ufnJx8fH/Nrcvbs2Vk+N3/99Zdat26tJUuWWPR//PHH8vb2zpe6KlSoIDc3N0VGRqpBgwZauHChLl26ZH782rVrWrNmjRo1amTxHjcYDJo7d26uIcw+ffpYvIauXr2q5557Th07dtTq1avNp03e7OrVq9q7d68+/vhjtW7dWvfcc4/mzZunq1ev2ukZO5cxY8ZYXMedmpqqbt266YknntDGjRvN1zvf7NKlSwoNDdW7776rhg0bqlGjRlq8eHGu+2QOQnbv3l3jxo3TTz/9pLVr11p8fz5+/Lh9nhwKPa6IBQAAAJzEk50e1WNtO6mER/Esj5nisv6fbyCveF0BAAAAAIA70cCBA+Xr66uBAwdahHbCwsIUFhYm6foVgWXKlJGvr6/OnTunM2fOZBtOkqRy5crluNfIkSOtPkXsgQceyLa/bdu2+XKCkre3t3766Sd17tzZHKhLS0vTqFGjNH78eFWpUkU+Pj46c+ZMtidiPfTQQ1kCd4XBxIkTFRUVZXGa25kzZ7Jc93mzl19+WU888YS++OILc5+bW85xilGjRunbb7/VqVOnJElXrlzRhAkT9Oabb6pmzZry8vJSfHy8IiMjLU5InDVrlr777jubrq08dOiQpkyZoilTpsjV1VV33XWXjEajihUrpqSkJB0/fjxLIMvT01Nffvml1XvYm6+vr95++20NGDBAqampeuWVVzR69GhVrVpVnp6eOnnypOLi4rLMGzp0qJ566ql8q6t69ep6/vnn9cYbbyg2NlZPP/20nn/+eVWpUkXu7u6KjIzMEk6VpClTpqhly5a3XH/27NlKTEy0CIBt3LhRGzdulJubmypXriyj0aj09HQlJSUpOjpaV65csetzdGYuLi76/vvv1a1bN/P3RJPJpOXLl2v58uUqXry4KleuLH9/f126dElJSUk6deqUMjIybNpnwIABmjp1qvnK5KSkJL3//vvZjp08ebKCg4Pz8rRQRBCwAwAAAJxE7wcfydLn4+Mjbz9fpT6zouALQpHg7ecrHx8fR5cBAAAAAABgk27dumnv3r167bXXtHLlyiyPJyQkKCEhIdc1SpUqpUmTJunFF1/MrzLzXaNGjbR582Z17drV4iSmq1ev6t9//81x3qBBgzR37lyL63YLixunjdWoUUPBwcG6ePFijmPd3Nw0efJkTZo0SatXr7Z4zNfXN8d5RqNRq1at0sMPP6zY2Fhzf3p6ug4cOJBlvIuLiz744AM9++yz+u67727jWV2XkZGhqKgoi5PqMqtQoYJ++uknNWjQ4Lb3sYenn35asbGxGjNmjEwmky5fvqxDhw7lOH7o0KGaO3duvtc1adIkxcfHa9asWZKuh1JzusbWxcVFb7zxhiZNmmTV2u7u7lq0aJEaNmyY5bWXnp6uY8eO6dixY7muUbp0aZUoUcLKZ3Pn8fX11bp16zR27FjNmjVL6enp5scuX76c6/etGypWrJjr40ajUUuXLlWvXr2yDXICt4OAHQAAAODEjEajIo8dz3J8PmAvPj4+MhqNji4DAAAAAADAZkFBQVqxYoX27NmjefPmadmyZYqJicl1jpeXl9q0aaOBAweqW7duKl48620Sd5o6dero4MGDmj17tj7//PMcrzx0c3NT27ZtFRwcrFatWhVwlQXLYDBozJgxeuqpp/TNN99o9erVioiI0Llz5+Tl5aUaNWqoU6dOeu6551SlShVJyhLIzC1gJ0n333+/du3apXHjxumHH37I9pQtg8GgTp06aerUqTZf1xoaGqqVK1dqzZo12r59e7ZXjN6sevXqGjhwoEaMGCEvLy+b9sovo0aNUuPGjTVmzBiFhoZmO6Zu3bqaOnWqHnvssQKr65NPPlHbtm01adKkHEN/LVq00IwZM9SiRQub1x8zZowGDhyoDz74QIsXL87x2uobypYtq06dOumJJ57Qo48+WiiDrzdzc3PTzJkz9eKLL+r999/XihUrbhmECwoKUufOndWzZ0917Njxlnu0adNG//zzj77//nutWbNG4eHhOnv2rNLS0nTt2jV7PRUUIQbTzeeRAtk4cOCA6tSpY26Hh4fr3nvvdWBFAIA7xXvd39ThbQdUs8W9Gr+88B0zD2TnoaEPy2AwyGQy6ff//ubocoAC88rS4eaPZ/X4zIGVAAXrvhk9zR/vHb3EgZUAAAAAd5709HQdOXLEoq9GjRq5XssI3MqxY8cUHh6ukydPKjU1VSaTSX5+fjIajapdu7buvfdeubq6OrrMfPXPP/9o9+7diouL04ULF1SqVClVqFBBrVq1umVorCgbNWqUxTWyISEhatu2rVVzExIStHnzZkVFRSk1NVVeXl6qUqWKWrRooYCAgDzXlpGRoUOHDunIkSOKjo5WamqqpOvXBFeoUEH169c3BwUdJSgoyHyyXuXKlbNcg3v06FFt375d0dHRMhgMKleunBo0aJDv2QODwWD+OLvrmvfv36+dO3cqJiZGxYoVU7ly5dS8eXO7fj6PHj2qPXv2KD4+XomJiXJzc5Ovr68qVaqkWrVqKSgoyG573YlMJpMOHDigAwcO6OzZs0pKSlLx4sXl6+urKlWqqHbt2ipfvryjy7zj5dffu4pKpoi/nQIAAAAAAAAAAAAACoVq1aqpWrVqji7Doe655x7dc889ji7jjrNhwwbzxy4uLjZdsWo0GtWtW7d8qOo6V1dX1alTxyLEcqepXr26qlev7ugysqhbt67q1q2br3s463N3FgaD4Y5/faPwc3F0AQAAAAAAAAAAAAAAAI7y559/as+ePeZ23bp15e3t7biCAABOhRPsAAAAACeXkJCglJQUR5eBQsrHx0dGo9HRZQAAAAAAAAB2YTKZLK4FvZWUlBQ9++yzFn1Dhgyxd1kAgDsYATsAAADAScz8er56d35EFcuVM/clJCQoqFpVpSYlO7AyFGbefr6KPHackB0AAAAAAAAKhaioKA0cOFDjx4/XAw88IFdX1xzH7tmzR08//bQOHz5s7itVqpQGDBhQEKUCAO4QBOwAAAAAJ7EtfJfm/rpQX43/UC3qN5B0/bcnU5OS5Ta/mwwBXg6uEIWNKS5Nqc+sUEpKCgE7AAAAAAAAFBqbN2/W5s2bFRgYqIceekgNGzZUhQoV5OnpqeTkZB07dkwbNmzQxo0bs8z94osv5OfnV/BFAwCcFgE7AAAAwIlcyLigvu+8qOD+IzWoW09zvyHAS4byPg6sDAAAAAAAAABu35kzZ3TgwAG7r9uwYUP5+/tn+1hsbKy+/vprff3117dcx2Aw6P3331fPnj1vOfZOs3XrVl28eNGua/r7+6thw4Z2XROWLl26pC1btth93apVq6pq1ap2XxcozAjYAQAAAE4mQxl6Y+F0/RN1XM937e3ocgAAAAAAAAAgz9asWaPBgwfbfd0//vhD7dq1M7c9PDxUqlQpnTt3zuo1atWqpenTp+vRRx+1e33OoF+/foqKirLrmm3btlVISIhd14SlmJgYPfDAA3Zfd/LkyQoODrb7ukBhRsAOAAAAyCczFsy1afy/p49ZtL/7c4kOHD8syWDHqgAAAAAAAACg8CpbtqxiYmK0adMmhYSEaNeuXTp27JhiY2OVlpYmNzc3GY1GlStXTi1bttQDDzygLl26yMXFxdGlAwCcFAE7AAAAIJ/MWj0/z2vsid6vqo8015m0DGXYoSbgZoGxV1VsWBtNDPlMHh4eeVrrSHyi+eOhP76Z19IAAAAAAACA2+bm5qaOHTuqY8eOji6lyIiMjHR0CdkymUyOLgFAIUDADgAAAHByJnfJLc1EwA52V/zSNXlVK6Pw+ON2XXfnyYN2XQ8AAAAAAAB3vkGDBmnQoEGOLqNIctbwG3IXFBREQBBwEgTsAAAAgHxS1Rhk0/jjCZFZ+sp5ldXuxWtlGFKFi2Jhd5c9XGQKj1GzZk3tcILdEfPHNcrUyGtpwB2DQCkAAAAAAAAAFG4E7AAAAIB8smnuYpvG9xj9gkIjdpnbTao01LRhI3X3NzXkbu/iAEmxge66OmezNoz7WkFBQXla65Wlw80fz+oxJY+VAXeO+2b0dHQJAAAAAAAAAIB85OLoAgAAAABk1bdVDy2d8bnc3fidGAAAAAAAAAAAAMBR+Nc6AAAAwIm4ylVv9hupId05EQkAAAAAAAAAAABwNAJ2AAAAgJOoUq6iRjw1VK0aNMrymCkuzQEVobDjdQUAAAAAAAAAAJA7AnYAAACAk/jg9QlZ+nx8fOTt56vUZ1YUfEEoErz9fOXj4+PoMgAAAAAAAAAAAJwSATsAAADAiRmNRkUeO66UlBRHl4JCysfHR0aj0dFlAAAAAAAAAAAAOCUCdgAAAICTMxqNBKAAAAAAAAAAAAAAB3BxdAEAAAAAAAAAAAAAAAAAADgjAnYAAAAAAAAAAAAAAAAAAGSDK2IBAAAAJ5eQkKCUlBRHl4FCysfHhyuIAQAAAAAAAAAAckDADgAAAHASofv3qdG9deTi8r+DphMSEhRUrapSk5IdWBkKM28/X0UeO07IDgAAAAAAAAAAIBsE7AAAAAAn8f43n+vq1ataNO0/KuFRXJKUkpKi1KRkuc3vJkOAl4MrRGFjiktT6jMrlJKSQsAOAAAAAAAAAAAgGwTsAAAAACey+9Q+tXm+l1ZOn6fyAYHmfkOAlwzlfRxYGQAAAAAAAAAAAFD0uNx6CAAAAICCFHM+Rh1e6aMd+/Y4uhQAAAAAAAAAAACgSCNgBwAAADihtPQ09ZkyXD//+YejSwEAAAAAAAAAAACKLK6IBQAAAPJJxZ5N8jQ/XemasfILlW9wr+LtVBNws8DYqyo2rI0mhnwmDw+PPK11JD7R/PHQH9/Ma2kAAAAAAAAAAABOgYAdAAAA4MRMMsk1yEveUVd0vryjq0FhU/zSNXlVK6Pw+ON2XXfnyYN2XQ8AAAAAAAAAAMBRCNgBAAAATsxNbkrZE63UQTVkcHQxKHQue7jIFB6jZs2a2uEEuyPmj2uUqZHX0oA7BoFSAAAAAAAAACjcCNgBAAAA+eTkklCbxvcY/YJCI3aZ215uJTVj6Dg93vlBudu7OEBSbKC7rs7ZrA3jvlZQUFCe1npl6XDzx7N6TMljZcCd474ZPR1dAgAAAAAAAAAgHxGwAwAAAJxQuZLltGrGfF1KS3N0KQAAAAAAAAAAAECR5eLoAgAAAABYalDxPv05d7HKlinj6FIAAAAAAAAAoFBbsGCBDAaD+c+CBQscXRIAwMlwgh0AAADgJFwMLurVrKs+HDXR0aUAAAAAAAAAd6SIiAiFh4fr5MmTSklJ0bVr1+Tv7y9/f3/VqlVLderUkaurq6PLBAAAdxACdgAAAICTmD06OMdT60xxXBUL++N1BQAAAAAACoP9+/dr7ty5Wr58uaKjo3Md6+npqZYtW6p///7q0aOHvLy8rNojPj5eoaGhFn8SEhIsxphMptt+DgAAwHkRsAMAAACcRHbhOh8fH3n7+Sr1mRUFXxCKBG8/X/n4+Di6DAAAAAAA8uzRavc7uoRCY/Wx3Y4uwSonTpzQiBEjtGzZMqvnXLhwQevWrdO6dev08ssva9y4cRoxYoQ8PDyyjD106JDeeusthYaGKiIiwp6lAwCAOwgBOwAAAMCJGY1GRR47rpSUFEeXgkLKx8dHRqPR0WUAAAAAAADYZPXq1erfv7+Sk5Ozfdzf319lypSRr6+vzp49q9jYWF24cMFiTEpKiiZMmKBly5YpLCwsyxqHDx/WokWL8qV+AABw5yBgBwAAADg5o9FIAAoAAAAAAAD4f999950GDhyojIwMi/6GDRtq6NCh6tKliypXrpxl3uHDh7Vy5UotXrxYu3btMvfHx8fbXEPJkiV1/vx524sHAAB3HBdHFwAAAAAAAAAAAAAAgDV27typIUOGWITrfH199e233yosLEwvvPBCtuE6SapZs6bGjBmjnTt3atmyZapZs6ZVe5YoUULNmzfXq6++qoULF+rw4cPat2+fXZ4PAABwfpxgBwAAADi5hIQErohFvuGKWAAAAAAAcKdISUnRk08+qStXrpj7AgICtGbNGtWvX9+mtbp3765HHnlEw4cP1/r167Md06RJE/3999+qW7eu3Nws/2k9MjLS1vIBAMAdioAdAAAA4CQuX7ms4sWKW/QlJCQoqFpVpSYlO6gqFHbefr6KPHackB0AAAAAAHB6wcHBOn78uLnt4uKiFStW2Byuu6FYsWKaP3++li1blu3j5cuXV/ny5W9rbQAAUHgQsAMAAACcxLCpE9WqXhM906O3uS8lJUWpSclym99NhgAvB1aHwsgUl6bUZ1YoJSWFgB0AAAAAAHBqSUlJmjdvnkXfa6+9pubNm+d57SeeeCLPazijy5cva+vWrTp16pTOnDkjV1dXNW7cWG3bts11XlxcnLZt26aYmBglJCTI19dXgYGBatq0qSpWrJjnuuLi4hQeHq5jx44pKSlJ6enpMhqNKlu2rJo2baqyZcvmeQ9JunDhgkJCQhQVFWV+HrVq1VLLli3l4eFhlz0AAEUDATsAAADASaReSNNbP3ygf6KO6oPXJ1g8ZgjwkqG8j4MqAwAAAAAAABxrzpw5On/+vLldrFgxjR8/3oEVOd6gQYP09ddfm9sREREKCgrSqVOn9Pbbb2vx4sVKSkqymNO1a9ccA3YrVqzQtGnTFBoaKpPJlO2YunXrauTIkXr66afl4uJiVZ0mk0lbtmzR4sWLtW7dOh0+fDjX8Tf26NevX5area2RmJio8ePHa+HChUpLS8vyuLe3t1544QW9+eab8vLil5oBALdm3X/xAAAAABSYRdtWqNvI53T5ymVHlwIAAAAAAAA4hczXuHbv3l2lS5d2UDX2FxwcLIPBYP7Trl2721pn/fr1qlOnjubOnZslXJeT5ORkPfjgg+revbt27NiRY7hOkvbv369BgwapWbNmOnPmjFXrjx49Wm3atNGnn356y3DdzXu0b99ecXFxVu1xw86dO1W7dm3NmTMn23CdJKWmpmr69Olq3LixTp06ZdP6AICiiYAdAAAA4IR2Re1Rm2G9dTYxwdGlAAAAAAAAAA6Vlpamv//+26Kva9euDqrGee3evVtdu3ZVcnKyua9y5cpq1KiRqlWrJnd39yxzEhIS1K5dO61duzbLY5UqVVKjRo1UtWrVLKfVhYWFqWXLloqKirplXZcuXcrS5+/vr1q1aqlp06aqX7++ypUrl2XMli1b1KFDB128ePGWe0hSeHi4HnzwQcXExFj0FytWTDVr1lTDhg0VEBBg7j906JC6dOli9foAgKKLK2IBAACAfFKxZ5M8zT+dekb9p42UVymjrtipJgAAAAAAAOBOs337dqWnp1v0NWrUyEHVOK8XXnhBFy5ckIeHh0aNGqXnn39eFSpUMD+elJSkffv2Wcx57rnntGfPHou+Z599VmPHjlW1atXMfadPn9bs2bP1wQcfmL8WERER6tu3rzZv3ixXV9dca/P29lbPnj31yCOPqEWLFtkG6qKjo7Vw4UJNmzbNfPregQMHNG7cOH3yySe5rn/16lX17dtXCQn/+4Vlb29vvfPOOxo4cKB8fX3N/Tt27NCYMWO0efNm7d+/X9OnT891bQAACNgBAAAATiwtI02l296tlJNXlFbe0dWgsAmMvapiw9poYshn8vDwyNNaR+ITzR8P/fHNvJYGAAAAAABg9s8//1i0S5YsqerVqzuoGucVGxurkiVL6rffflOrVq2yPO7n56c2bdqY20uXLtXSpUstxsyfP19Dhw7NMrd8+fJ677331Lp1a3Xr1k1Xr16VJG3btk2zZ8/Wa6+9lmNdgwcP1rvvvisfH59c669QoYLGjh2rPn36qH379oqIiJAkzZs3T5MnT5bRaMxx7kcffaT9+/eb2/7+/tq8ebPq1KmTZWzTpk0VEhKigQMH6ttvv1VkZGSudQEAQMAOAAAAcHKGxAydL+cug6MLQaFT/NI1eVUro/D443Zdd+fJg3ZdDwAAAAAAFG03n0omSWXKlJHBwE/LsvPBBx9kG67LzsyZMy3aL730Urbhupt16dJFb7/9tsaNG2fu+/jjj/Xyyy/neIpdw4YNrarnhsqVK2vevHnq1KmTJOnixYv68ccfNXz48GzHZ2RkaNasWRZ98+bNyzZcd4PBYNB///tf7dq1SwcP8rMsAEDuCNgBAAAA+STix202je897iWFRf5t0dej0SP6ZHyw3Efcbc/SAEnSZQ8XmcJj1KxZUzucYHfE/HGNMjXyWhpwxyBQCgAAAAD5L3PAzs/PzzGF5KPg4GAFBwfnaY1KlSrp2WeftWrswYMH9ddff5nbXl5eevvtt62a+/rrr+s///mPTp48KUmKiorS2rVr9fDDD9tedA46duyocuXK6cyZM5Kun5SXU8Bu7dq1io6ONrcbN26sHj163HIPd3d3vfvuu+rWrZtdagYAFF4E7AAAAIB84uZm21+3b/6tWze5acrAMWpdt74+GR9s58qA62ID3XV1zmZtGPe1goKC8rTWK0v/9wPOWT2m5LEy4M5x34yeji4BAAAAAAq91NRUi7aXl5eDKnFuTz75pFxcXKwau2nTJov2E088YXVw0d3dXU8//bTeffddc9/mzZvtGrCTpKCgIHPAbvfu3TmOCwkJsWgPGDDA6j0eeeQRlSlTRvHx8bdVIwCgaLDuv64AAAAACoynq6e+n/QfPf1YN0eXAgAAAAAAADict7e3RTstLc1BlTi3Jk2aWD12x44dFu0OHTrYtFfHjh0t2tu3b7dqXmRkpKZPn65evXqpVq1aKlOmjIoXLy6DwZDlz80n7J09ezbHNUNDQy3a7dq1s/p5uLm5qWXLllaPBwAUTZxgBwAAADiRQK8ArZg+X3cFlnV0KQAAAAAAAIBTMBqNFu3k5GQHVeLcqlSpYvXYqKgoi3a9evVs2uu+++6zaJ84ceKW+7366qtatWqVTCaTTXtJUlJSUo6PRUREmD92dXXVPffcY9PadevW1YoVK2yuCQBQdBCwAwAAAJzEk50e1WNtO6mER/Esj5ni+K1c2B+vKwAAAAAAcCfIHLDjOs/s+fj4WD02MTHRol26dGmb9jIajXJxcdG1a9eyXe9moaGh6ty5c56CkVeuXMnxsZvDd76+vnJzsy0GUapUqdstCwBQRBCwAwAAAJxE7wcfydLn4+Mjbz9fpT6zouALQpHg7edr0w9fAQAAAAAAClrmE8lSU1N19OhRVa9e3UEVOSd3d3erx54/f96i7eXlZdNeBoNBJUqUMF/Xm5qamu24c+fOqUuXLlnCdfXq1VPr1q1VvXp1lS9fXiVKlJCHh4cMBoN5zMiRI7Vv3z6bnounp6dNz0Oy/bkDAIoeAnYAAACAEzMajYo8dlwpKSmOLgWFlI+PT5bfAgcAAAAAAHAmzZo1k5ubm9LT0819O3fuJGCXByVLlrRop6Wl2XSSm8lk0sWLF81tb2/vbMdNnTpV586dM7dr1KihhQsXqkmTJrfcw9qwnJeXl/nnpxcuXLBqzs1uhAQBAMgJATsAAADAyRmNRgJQAAAAAAAAKLK8vLzUoEEDhYaGmvtWrVqlPn36OLCqO5u/v79F+9y5c6pUqZLV8xMSEszXw2a33g2LFi0yf+zh4aHff/9dVatWtXoPa/j5+ZkDdsnJybp69apNp/ndHAAEACA7Lo4uAAAAAAAAAAAAAACA3HTv3t2ivWzZMoJReVC5cmWL9t69e22an3l85vUk6cSJEzp9+rS5/dBDD1kdrrt48aIiIiKsGnvzmhkZGfrnn3+smneDNdfQAgCKNgJ2AAAAAAAAAAAAAACnNmzYMItrTS9fvqz333/fgRXd2Zo1a2bR3rhxo03zM4/PvJ4kxcbGWrRr1qxp9fp//vmnrl69atXYxo0bW7Q3bdpk9T7p6enaunWr1eMBAEUTV8QCAAAATi4hIcF8xQFgbz4+PlxBDAAAAAAAnJ6/v7+GDh2qTz75xNz34YcfqkePHmratGme1v7111/VpUuXvJZ4R2nbtq1Fe/ny5UpOTpavr+8t5169elXffvttrutJkslksmhfuXLF6vo+++wzq8e2a9dOM2bMMLe/+eYbvfTSS1bN/eWXX3T27Fmr9wIAFE0E7AAAAAAnMfPr+erd+RFVLFfO3JeQkKCgalWVmpTswMpQmHn7+Sry2HFCdgAAAAAAwOkFBwdr5cqVioyMlHT9OtBu3bpp7dq1qlu3rs3rXb16VePHj9fSpUutvo60sKhVq5ZatGihbdu2SZLOnz+vyZMn6+OPP77l3E8++UQnTpwwt4OCgvTAAw9kGVe2bFmL9pYtW6yq7ddff9XKlSutGitJDz74oCpUqKDo6GhJUlhYmJYuXaoePXrkOu/G1x8AgFshYAcAAAA4iW3huzT314X6avyHalG/gSQpJSVFqUnJcpvfTYYALwdXiMLGFJem1GdWKCUlhYAdAAAAAABwen5+flq0aJFatWplvj40JiZGbdu21X/+8x/16dNHBoPBqrU2bdqkV155Rfv27VPlypXzs2yrBAcH66233jK327Ztq5CQkHzdc+TIkeaAnSTNmjVLDRo00IABA3Kcs2bNGk2cONGi77XXXpOLi0uWsZUqVcoSfFu0aJGefPLJHNcPDQ1V//79bXoerq6ueumllyzCcs8++6xq1qypOnXqZDvHZDLpmWee0aFDh2zaCwBQNBGwAwAAAJzIhYwL6vvOiwruP1KDuvU09xsCvGQo7+PAygAAAAAAAADHa9KkiebNm6chQ4bo2rVrkqTExET17dtXH330kYYOHaqHH35YlSpVyjL3yJEj+vnnn7VkyRL99ddfVu23a9cuJSYmZumPjY3N0rd+/fps1/D391fDhg2t2q8gPfHEE+rRo4eWLl0q6XrobNCgQdq2bZvGjBmjqlWrmseeOXNGs2fP1owZM5Senm7ub9GiRa7XsQ4YMEDvvfeeRfv48eN68cUX5ePzv593njp1Sl988YU++OADXb58WR4eHipbtqz5tMJbef311/Xtt9/q4MGDkq6/Jlq0aKGpU6dq4MCBFnuFhoZqzJgx2rRpk6TrJ/BZuw8AoGgiYAcAAAA4mQxl6I2F0/VP1HE937W3o8sBAAAAAAAAnMrAgQPl6+urgQMHKiUlxdwfFhamsLAwSZLRaFSZMmXk6+urc+fO6cyZM7pw4UK265UrVy7HvUaOHGkOYt1KdtekSgVzGt3tmjt3ro4ePaq9e/dKuh6ymzNnjubMmaOgoCCVKVNGCQkJioiIMAcab6hSpYq+//57ubq65rj+qFGj9O233+rUqVOSpCtXrmjChAl68803VbNmTXl5eSk+Pl6RkZEymUzmebNmzdJ3331ndfCtWLFi+uGHH9SuXTtzIDI1NVWvvPKKRo8erSpVqsjLy0snT55UXFyceV69evX0/PPPa/jw4VbtAwAomgjYAQAAAPlkxoK5No3/9/Qxi/Z3fy7RgeOHJVl3rQUAAAAAAABQVHTr1k179+7Va6+9ppUrV2Z5PCEhQQkJCbmuUapUKU2aNEkvvvhifpXp9IxGozZt2qRevXpp3bp1Fo9FRkbmGHBr3LixVq5cmWs48cb6q1at0sMPP2xx6l96eroOHDiQZbyLi4s++OADPfvss/ruu+9sei716tXT77//rscee8wiRHf58mX9888/WcbXqlVLv/zyS44nDwIAcAMBOwAAACCfzFo9P89r7Iner6qPNNeZtAxl2KEm4GaBsVdVbFgbTQz5TB4eHnla60j8/65KGfrjm3ktDQAAAAAAm60+ttvRJaCABQUFacWKFdqzZ4/mzZunZcuWKSYmJtc5Xl5eatOmjQYOHKhu3bqpePHiBVSt8/L19dXatWu1fPlyTZs2TWFhYRanyd2sTp06GjlypAYMGCAXFxer1r///vu1a9cujRs3Tj/88IMyMrL+pNNgMKhTp06aOnWqGjdufNvPpUmTJjp06JDGjRun7777LttTC729vfX8889r8uTJ8vLyuu29AABFh8GU038Zgf934MAB1alTx9wODw/Xvffe68CKAAB3ive6v6nD2w6oZot7NX75FEeXAxSIh4Y+LIPBIJPJpAPJ5+yypnuGu84+WlGX6xvtsh5wQ8W/4uV1kf9LCNjL3tFLHF0CAAAAcEdJT0/XkSNHLPpq1KghNzfOCMHtO3bsmMLDw3Xy5EmlpqbKZDLJz89PRqNRtWvX1r333pvrlaaQYmNjtW3bNsXExCgxMVE+Pj4KDAxU06ZNValSpTytnZCQoM2bNysqKkqpqany8vJSlSpV1KJFCwUEBNjpGVyXlpamP/74Q1FRUUpMTJSvr69q1aqlVq1a5fmXTQHgTpNff+8qKpki/nYKAAAA5JOqxiCbxh9PiMzSV86rrHYvXivDkCpcFAu7u+zhIlN4jJo1a2qHE+z+93/Ma5SpkdfSgDvGzpMHHV0CAAAAAOAm1apVU7Vq1Rxdxh0tMDBQ3bt3z5e1jUajunXrli9rZ+bl5aVHH320QPYCABRuBOwAAACAfLJp7mKbxvcY/YJCI3aZ202qNNS0YSN19zc15G7v4gBJsYHuujpnszaM+1pBQUF5WuuVpcPNH8/qwamlKDrum9HT0SUAAAAAAAAAAPKRdZeiAwAAAChQfVv10NIZn8udK1EAAAAAAAAAAAAAh+Ff6wAAAAAn4ipXvdlvpIZ050QkAAAAAAAAAAAAwNEI2AEAAABOokq5ihrx1FC1atAoy2OmuDQHVITCjtcVAAAAAAAAAABA7gjYAQAAAE7ig9cnZOnz8fGRt5+vUp9ZUfAFoUjw9vOVj4+Po8sAAAAAAAAAAABwSgTsAAAAACdmNBoVeey4UlJSHF0KCikfHx8ZjUZHlwEAAAAAAAAAAOCUCNgBAAAATs5oNBKAAgAAAAAAAAAAABzAxdEFAAAAAAAAAAAAAAAAAADgjAjYAQAAAAAAAAAAAAAAAACQDa6IBQAAAJxcQkKCUlJSHF0GCikfHx+uIAYAAAAAAAAAAMgBATsAAADASRw4dFC1at4jF5f/HTSdkJCgqtWrKTkxyXGFoVDz9ffT8aPHCNkBAAAAAAAAAABkg4AdAAAA4CS+Xvyt0jOu6r2JU1W8eHFJUkpKipITk/TsHxPlW4EAFOwrOTpB89pPVUpKCgE7AAAAAAAAAACAbBCwAwAAAJzIodMH9eyYYfrwjQ9UunRpc79vBaP8g8o4sDIAAAAAAAAAAACg6HG59RAAAAAABSk+LU7DJr6gAwcPOroUAAAAAAAAAAAAoEgjYAcAAAA4oQsZaRr74ThtC93u6FIAAAAAAAAAAACAIosrYgEAAIB88vAzXfI0P0PpWrj2WzVp1cxOFQGWLu87qpd+el4f7pou7XJ0NQAAAAAAAAAAAM6HE+wAAAAAJ2aSSaXuNuriv8mOLgWFlMFgcHQJAAAAAAAAAAAATouAHQAAAODEXOWmo38dU4m7fR1dCgopk8nk6BIAAAAAAAAAAACcFlfEAgAAAPnkt/m/2jR+zFvjtf/kXnPb09VLL/YZro7/7WDv0gBJUvF61fXB3SMVERGhoKCgPK31ytLh9ikKAAAAAAAAAADAiRCwAwAAAJxQgFegZr75gc6npjq6FAAAAAAAAAAAAKDI4opYAAAAwMnUrnCv5s2Yo9KlSjm6FAAAAAAAAAAAAKBI4wQ7AAAAwEm4uLioc8OHNOKFVxxdCgAAAAAAAAAAAAARsAMAAACcxqjhr+d4al1ydEIBV4OigNcVAAAAAAAAAABA7gjYAQAAAE4iu3Cdj4+PfP39NK/9VAdUhKLA199PPj4+ji4DAAAAAAAAAADAKRGwAwAAAJyY0WjU8aPHlJKS4uhSUEj5+PjIaDQ6ugwAAAAAAAAAAACnRMAOAAAAcHJGo5EAFAAAAAAAAAAAAOAALo4uAAAAAAAAAAAAAAAAAAAAZ8QJdgAAAICTS0hI4IpY5BuuiAUAAAAAALgztWvXTps2bTK3TSaTA6spGiIjI1WlShVze+DAgVqwYIHjCsqjkJAQtW/f3tyePHmygoODHVcQADgpAnYAAACAk7hy5YqKFStm0ZeQkKCq1aspOTHJMUWh0PP199Pxo8cI2QEAAAAAgEIhIiJC4eHhOnnypFJSUnTt2jX5+/vL399ftWrVUp06deTq6npba0dHR2v//v2KjIxUUlKSXF1d5e/vr6CgIDVt2lTe3t52fjYAAMAZELADAAAAnMR7H7+v+vfWV9dHHjP3paSkKDkxSc/+MVG+FQhAwb6SoxM0r/1UpaSkELADAAAAAAB3rP3792vu3Llavny5oqOjcx3r6empli1bqn///urRo4e8vLxyHJuWlqbVq1frt99+04YNG3Tq1Kkcx7q6uqpt27Z69dVX9fjjj9/2cwEAAM6HgB0AAADgJNIuXtAXyz/X/7F352FRVv//x18DiODCAIpCLuCS5VK5kGZaau5lLmkupYKaaVYuLbhmpmmp7WrlkkuZnyyV3HPJNXcx99LcEUVENgVFgfn94c/5OmwOMjCjPh/X5fXlnPvc57znnpGP8X1xzqnwUxrQ922La8ZS3vIK8LFTZQAAAAAAAIDjOXPmjAYNGqRFixZZfU9SUpLWrFmjNWvW6O2339aQIUM0aNAgubm5WYz75JNPNHbsWCUmJlo1b2pqqtatW6d169apRYsWmjVrlnx9fXP0egAAgGMiYAcAAAA4mD92r9TZUWc1dtgYe5cCAAAAAABwz3hya297l3Df2PX0dHuXcEfLli1T165dFR8fn+l1Ly8v+fj4yGg0Kjo6WhcuXFBSUpLFmISEBA0bNkyLFi3Srl27LK6FhYVlGq4zGAzy9fVVyZIlZTAYFB4erujoaIsxf/zxh+rXr6/NmzfLz88vl68UAADYm5O9CwAAAACQ0cGzB9Q7pK/isvgBIQAAAAAAAPCg+vnnn9W2bdsM4bpatWrp22+/1alTpxQTE6MjR45o586dOnHihBITE/Xvv/9q/PjxqlWrlsV9Fy9ezHY9d3d3de/eXQsXLtTFixd17tw5/f3339qzZ4+ioqK0a9euDMfCHj9+XG3atFFaWpptXjQAALAbdrADAAAA8kjL157P1f1RVyI15tsx8ilZwkYVAQAAAAAAAPe23bt3q2fPnkpNTTX3GY1GTZ48Wa+++qoMBkOW9z7yyCMKCQlRSEiIQkNDNXToUB05ciTL8T4+PhoyZIh69eolo9GY6RiDwaDAwEAtXrxYY8eO1YgRI8zXdu3apTlz5qhHjx538UoBAICjIGAHAAAAOLCk1CQ9+UJtXTsWLwX42Lsc3GeS9x/TW7/11RdhE6Qwe1cDAAAAAACQvYSEBHXq1EnXr18395UoUUKrVq1S9erVczRXu3bt9MILL6hfv35au3Zthut9+vTR7NmzVaRIEavnHD58uMLCwhQaGmrumzFjBgE7AADucRwRCwAAADi45OhkuQYUtXcZuE9l91vdAAAAAAAAjmTUqFE6ceKEue3k5KTff/89x+G6W1xdXTVjxgx98cUXGa41bdo0R+G6W4YOHWrR3r59uxISEu6qPgAA4BjYwQ4AAADII0u/X5Kj8cPGjtCB8P0Wfc891lghA99Tjc9a2LI0wMxkMhGyAwAAAAAADi8uLk7Tp0+36Bs4cKDq1q2b67lfeumlXM9xS2BgoNzd3XX16lVJUlpams6ePasqVarYbA1rRUREaOvWrTp9+rRSUlLk5+enatWqqVatWjaZPyoqSlu3blVkZKRiYmJkNBpVsmRJ1alTR2XKlLHJGreLiIhQWFiYzp07p0uXLsnT01Pt2rXTQw89lO19SUlJ2rJliyIiIhQVFSVnZ2eVKFFCVapUUc2aNW3+s7EjR45ox44dOnfunHmt2rVrq3LlyjaZf+/evTp8+LCioqJ07do1lShRQmXKlFH9+vXl7u5ukzVyKi4uTlu3btX58+d18eJFubm5ycfHRzVq1LDLZ99aJpNJ+/fv1z///KOoqCglJiaqePHiKl26tJ555pm7CtlmJz4+Xps2bdKxY8d09epVFStWTBUrVlT9+vVVsGBBm64FwLYI2AEAAAB5xMUlp//c/r8f5DjLRW927KfKlR5VyMD3bFsY8P8VfLyiPqv0rk6ePKmAgIBczdV/YT/bFAUAAAAAAJCJqVOn6sqVK+a2q6trht3iHIHBYJDRaDQH7KSboZr8tG/fPoWEhGjNmjUymUwZrleoUEEjRoxQcHDwXc3/+++/69NPP9XOnTsznV+SHnvsMb377rvq1q2bnJysO1jv9qBbgwYNtGHDBknS8uXL9cUXX2jDhg1KS0uzuKdUqVJq27ZtpvNt2bJFY8eO1bp165ScnJzpmBIlSqhPnz56//33VbRo7k4RWb16tYYPH67du3dner1y5coaP368XnzxxRzPffnyZY0fP16zZs3SuXPnMh3j5uamFi1aaMyYMapWrVqO17gbS5cu1WeffaatW7cqJSUl0zFly5bVwIED1a9fP4cJkV28eFGffPKJfvnlF50/fz7TMa6urubn+fjjj1s1b8OGDbVx40Zz+9bfj/Pnz2v48OH6+eefLY64vqVw4cIaOHCghg4dqsKFC2c5f6tWrbR8+XJze+3atWrcuLFVtd1eU4UKFXTy5ElJkrOzs86ePStfX98czQM8aDgiFgAAAHAw7s6F9MmgcWrZjF3rAAAAAAAAAElatGiRRbtdu3YqXry4narJ2o0bN3Tx4kWLvmLFit3xvuDgYBkMBvOfuw2//e9//9OTTz6p1atXZxl+O378uHr06KHWrVtnGTzLTHx8vJo3b6527dppx44dWc4vSQcOHFBwcLCeeuqpLANMd2IymfT222+rVatWWrduXYZwXVYSExPVsWNH1a9fXytXrsz2NUZFRWnMmDGqVKmSdu3adVd1SlJISIiaN2+eZbhOkv755x+1bt1aY8aMydHcGzduVMWKFTV27Ngsw3WSdO3aNfORycOHD8/RGjkVFRWlRo0aqXXr1tq0aVOW4TpJOnPmjN555x09/vjjOn78eJ7WZY0ffvhBFSpU0JdffpntZ/P69etasmSJatSoodGjR9/1eps3b1a1atU0a9asTMN10s3P7NixY9WoUSPFxMRkOVdQUJBF+8cff7yrem6F6ySpefPmhOsAKxCwAwAAABxI8UI++v7j7/RY1fz5DUMAAAAAAADA0SUmJmrPnj0WfW3atLFTNdnbunWrUlNTze2CBQuqbNmy+bL2+vXr1b17d924cUPSzZ2pKlasqMDAwEyPUV26dKnat2+fbTjqlpiYGDVs2FCrV6/OcK1s2bIKDAxU+fLlM+xWt2vXLtWrV0+nT5/O8esZNmyYJk+ebG67u7vr0UcfVa1atbIMBEVFRalBgwb67bffMlwrXbq0atWqperVq8vLy8viWmRkpBo2bKi//vorx3UOGTJEEydONLeLFi2qqlWrKjAwUD4+PhnGjxw5MkNgNCvLly9XixYtFBUVZdHv5uamRx99VDVr1sywRmpqqsaNG6devXrl+LVY47///tNTTz1l3mHwFoPBoICAAAUGBuqxxx7LcLzq0aNHVbduXR09ejRP6rLGBx98oNdee02XL1+26Pfw8FDVqlVVu3btDCd9pKWl6cMPP9SAAQNyvF5YWJhatmxpDs05OTmpQoUKql27th5++OEMxxPv2rUr23Bt69atLT67ixYtUmJiYo5qmjNnjkU7fWgPQOY4IhYAAABwEM2ebapnnq6X6Tb58RFZ/9YacLf4XAEAAAAAgHvB9u3bM4TAAgMD7VRN9mbOnGnRfu655+Tm5pYva/fo0UMpKSlydXXVsGHD1K9fP4vw1f79+zV8+HAtW7bM3Ld8+XJ9/vnnGjx4cLZzv/7669q7d69FX+/evTV48GBVqFDB3Hfu3DlNmjRJn332mfk9O3nypF555RVt2rRJzs7OVr2Ww4cPa/PmzZKkhx9+WOPGjVOrVq0snuXBgwdVqFAhczstLU2dO3dWWFiYuc/Hx0chISHq2rWrRSgvLS1N27Zt08iRI7Vu3TpJUlJSkrp06aK9e/dateugJG3atMm8G1idOnU0ZswYNWrUSC4uN6MYJpNJGzdu1BtvvKF///3XfF///v3VunVr87jMhIeHq2vXrrp27Zq5r1ixYvr000/VuXNniwDbtm3bFBISYhEQnDlzpp588kn17dvXqtdijaSkJLVp08ZiB7Ry5cppyJAhevnlly3CXykpKVq7dq2GDx9uDshevHhRnTp10vbt2/P9uNhZs2bp448/NrcNBoO6deumt99+WzVr1rQIh547d06TJ0/WZ599Zg6sfvPNN6pXr546duxo9ZodO3ZUYmKivL29NWLECHXv3t3is3Xu3DkNHz5cs2fPNvctXbpUK1euVMuWLTPMV7BgQXXq1Enff/+9JOnKlStatGiRunXrZlU9V69e1YIFC8xtT09PtW7d2urXAzzICNgBAAAADqJJo+cy9Hl4eMjo5anpjcbaoSI8CIxenvLw8LB3GQAAAAAAAFm6PZgkSUWKFFHFihXtVE3W9u/fr59//tmi726Per0bp0+fVsGCBbVixQo991zGnzU+/vjjWrp0qd555x19+eWX5v6PPvpIXbp0yXKnvYULF2rhwoUWfTNmzMh0h7SHHnpIn3zyiZ555hm1bdvWHE7aunWrJk2apIEDB1r1Wm4ds/vMM89oxYoVGXZDk6Rq1SxPAZk4caLWr19vbtepU0dLlixRiRIlMtzr5OSkevXqac2aNRowYIB5p7yzZ89q9OjR+vrrr62q81bQLDg4WDNmzMgQIDQYDGrYsKE2bdqk6tWrm494jYiI0PLly7PdibFfv36Ki4szt8uUKaPNmzfL398/w9i6detq48aNCg4O1k8//WTuf/fdd9W6detMdzC8G++++67++ecfc/vFF1/UvHnzMn1/XFxc1KJFCzVq1EhdunRRaGioJGnv3r369ttvNWjQIJvUZI0TJ07orbfeMrfd3d21cOHCTENs0s3P8bhx49SiRQu1aNFCV69elSS9/fbbat26tdWh2RMnTiggIEBr1661CKLevs6sWbNUoEABTZ8+3dw/bdq0LGsLCgoyB+ykmzvSWRuwCw0NVUJCgrndqVOnfAsAA/c6AnYAAACAA/P29taJY8ct/qMXsCUPDw95e3vbuwwAAAAAAIAs3Tpe8RYfH58MRyvaW3JysoKDgy2Oh61Zs6Y6dOiQr3WMHTs203Dd7T7//HNt375d27Ztk3RzV6vvv/9e48aNy3L87d566607Hj/6/PPPa8yYMRoyZIi576uvvtLbb79t9S52Xl5e+vXXXzMNb6WXlJSkCRMmmNt+fn5asWLFHX/u5eTkpK+++kq7d+/W9u3bJd3c+e2jjz6Sp6enVXUGBgZq2rRp2b4uHx8fffDBB3rjjTfMfStXrswyYHfkyBEtX77cos4FCxZkGq67fczMmTO1d+9eHThwQNLN5/Ldd99pzJgxVr2W7ISHh2vGjBnm9uOPP67ffvvtjjvRFSxYUHPnzlXVqlV16tQpSdLXX3+t/v37W/1ZyK0JEyYoKSnJ3J45c2aWAbbbPfvss/rss8/05ptvSrp5BPHcuXP12muvWbWus7Ozfvvtt0zDdbcbP368fvrpJ/NuhatXr1ZaWlqGI5cl6amnnlKlSpXMR+2uX79eZ8+eVenSpe9Yz48//mjR5nhYwHoE7AAAAAAH5+3tTQAKAAAAAAAAD6z0ATtrg0/5qX///vr777/NbRcXF02fPj3TgExmZs+ebXFM5N0oVaqU+vfvf8dxBoNB48eP17PPPmvumzVrlsaOHZshuHj48GFzEE+SChcubHVY65133tGUKVMUHh4u6eYOe6tXr7Yq2CRJb775psWxrtn58ccfLT4no0aNsvpnqs7Ozho6dKg57HblyhWtWrVKnTp1sur+0aNHq0CBAncc17FjR4uA3a1jUzPzww8/yGQymdtdunRR7dq177iGi4uLJk6cqBYtWpj7pk+frtGjR+c6lDplyhSLo5onTpxo9TGvhQoV0qBBgzRgwABJNz8Lu3fvVp06dXJVkzViYmIsgmV169ZV586drb6/d+/e+uijjxQVFSXp5o6O1gbs2rdvb9Vx1l5eXmrWrJmWLFki6WYw8t9//1WVKlUyHR8UFKThw4dLunnc8dy5cy3CrJk5f/681q5da25XqlRJdevWtep1AJCs+19zAAAAAAAAAAAAAADs4PLlyxbtwoUL26mSzE2aNEnTpk2z6Pv4449Vs2bNfK2jc+fOVgW9pJtHr5YvX97cjoyM1JEjRzKM27hxo0X7pZdesjrgWKBAgQxHV27atMmqe6WboTJrrVixwvy1i4tLjgJUktS4cWOLMOTmzZutus9oNKp58+ZWjfX29rY4hvdW8DAz6Z97z549rVpDkpo2bWqxm9mFCxfMu53lxu3P2NfXV02aNMnR/c2aNbNoW/uMc2vDhg3mI14lWX2c6i0FChRQo0aNzO2tW7cqLS3NqnutDWlKUvXq1S3a2X0+unXrZvF5Tb8zXWbmzp1rscNm9+7dra4NAAE7AAAAAAAAAAAAAIADK1q0qEU7MTHRTpVkFBoaqoEDB1r0derUSSEhIfleS8OGDXM0vkGDBhbtnTt3ZhizY8cOi/adjp9Nr3HjxhbtW8ew3knRokVVuXJlq8aaTCZt2bLF3K5UqZI8PDysL1I3Q5vFihUzt//55x+r7qtZs6bVuxRKUokSJcxfx8fHZzomOTlZe/fuNbcLFCig+vXrW72Gk5OTRSBMsv65ZyU2NlYHDx40t3P6uiVZhAsl659xbqUP8lmzo1x6t9eekJCgiIgIq+7LyVq3fzakrD8fklSmTBmLv4v//POPdu3ale38t4fwDAZDjoOGwIOOI2IBAAAABxcTE6OEhAR7l4H7lIeHB0cQAwAAAAAAh5b+ZxfZBU/y04YNG9SlSxeL3ayaNWumH3/8MdfHcd6NatWq5Wr8yZMnM4w5ffq0Rfvxxx/P0RpPPPGERfvMmTNW3efv72/1M7xw4YLF8bCHDx/O9fNPfyxxVtKHou7k9t0Xb99V7XaRkZG6fv26uf3oo4/K1dU1R+s88cQT+umnn8xta597Vo4cOWJxZO2KFSvy7RnnVvognzVH7d5JTEyMypQpc8dxOfl8pN+ZM6vPxy1BQUEWR77++OOPevLJJzMdu2fPHouAZKNGjTIEHgFkj4AdAAAA4CB+/vV/atLgOZUsWdLcFxMTo/IVKyg+Ns5+heG+ZvTy1IljxwnZAQAAAAAAh5X+5xYXL160UyX/Z/fu3WrdurWSk5PNfXXr1tWiRYtyHIayldt3YLub8XFxcRnGxMbGWrSLFy+eozW8vb3l5ORkDiGmny8rOdmB7tKlSzmqyRrWhjjd3NxsvnZun3lm91j73LNiz2ecW/fq5+P2QGNmXnrpJfXr1898hPb//vc/ffHFF5keEz1nzhyLdlBQ0F3XBTyoCNgBAAAADmLfP/u18M+FGvX2h3q82mOSbm43Hx8bp97rh8tYigAUbCs+IkbTG41VQkICATsAAAAAAOCwHn30UYv25cuXdezYMVWsWNEu9Rw6dEgtWrQwB1ukmzuGrVixIsMuVPmpUKFCORqfvtYrV65kGJO+L6evz2AwyN3d3Xys7+3PLDuZhYSyklkwMLdu35Uwv+X2mWd2j7XPPSv38jO+l2vPTqFChdShQwfNmjVL0s0g4fLly9W2bVuLcTdu3ND//vc/c7tIkSJq3759fpYK3BcI2AEAAAAO5GpqkoZ9NUx9O7yhVi2eN/cbS3nLK8DHjpUBAAAAAAAA9vHUU0/JxcVFKSkp5r7du3fbJWB3/PhxNW3a1GJXrEqVKmn16tXy9PTM93pul5SUpKJFi1o9/lbo7ZYiRYpkGJO+LzExMUc75ZlMJoujLnNSn7XSBwurVKmir7/+Oldzuru75+r+3MjsmedU+nty+9zTP+NGjRpp2LBhuZrTy8srV/dbK33ts2bNUunSpXM1Z/qjj+0lKCjIHLCTbh4Tmz5gt3LlSotdP9u3b2/XIDBwryJgBwAAADiYVKVqyoLJOh1+Si80ff7ONwAAAAAAAAD3scKFC6tmzZrauXOnuW/JkiXq3LlzvtYRHh6uxo0b6/z58+a+smXLau3atSpRokS+1pKZ6OjoHAWp0h+dmVlAMH0I6tKlSypbtqzVa8TExFjs9pUXoar0x6GaTCY1adLE5uvkl8yeeU5FR0dnO2dOpX/Gbm5u98wzTl97lSpVVLt2bTtVY1vPPvusAgICdOrUKUnS8uXLdenSJYsQ7I8//mhxD8fDAneHgB0AAACQR3765eccjT994ZRFe9mOZfrv1HEZnAw2rAoAAAAAAAC497Rr184iYLdo0aIMQZK8FBUVpSZNmuj06dPmPl9fX/35558qU6ZMvtRwJwcPHlS5cuWsHn/gwAGLdmb3+vv7W7T37dunGjVqWL3Gvn37sp3PFnx9feXu7m7eKe/06dO6ceNGjo6ZdSR+fn5ydXXV9evXJUn//vuvrl+/LldXV6vnsPVzT//ZOHbsWK7my0+Z1X6/BOwMBoO6d++u0aNHS5KuX7+uX375RW+++aYkKTY2VkuXLjWP9/f3V8OGDe1RKnDPI2AHAAAA5JF5a3MWsMvMkQv/qGWnF5SScN0GFQGWkvcf01u/9dUXYROkMHtXAwAAAAAAkLU+ffpo7NixunLliiQpOTlZ48eP14QJE/J87djYWDVt2lRHjx4193l7e2vNmjV2OaY2Kxs3btSLL75o9fhNmzZZtDMLHT311FOaM2eOub1u3ToFBwdbvca6desyzGdrBQoUUL169bR27VpJN4/K3bFjh+rXr2/ztfKDq6uratSooR07dki6GZr666+/9Nxzz1l1v8lk0oYNGyz6cvvcS5curYoVK5qDdf/995/Cw8MdJlyanUaNGumHH34wt9etW6dXXnnFjhXZVvfu3TVmzBiZTCZJN3esuxWw++WXX8xBTUnq1q2bDAZ+oR+4G072LgAAAABA9gyuBqUm3LB3GbhP8QMVAAAAAABwL/Dy8lKvXr0s+r744gtzCCk3VqxYkeW1K1euqGXLltq/f7+5z8PDQ6tWrVK1atVyvbYt/fLLL7pxw7qfI27evFknTpwwt319ffXII49kGNegQQOLdmhoqOLj461a48aNG/rpp5+ync9WWrRoYdGeNGlSnqyTX9I/p9mzZ1t975o1axQeHm5u+/n5qVKlSrmuKf0znjx5cq7nzA9NmjSRi8v/7T31yy+/3NWxu46qQoUKFmHSnTt36t9//5Uki3CsdDOMB+DuELADAAAA8kgZz7I5+pMZn0IltO63tSpYunA+V48Hxa3fbAQAAAAAAHB0o0aNUkBAgLmdmpqqtm3bZjjq1Fo3btzQe++9Z97tKb1r166pdevWFiE+d3d3LVu2TIGBgXe1Zl6KiIjQN998c8dxJpNJgwcPtugLDg7O9BcxK1eurKefftrcvnLlij788EOr6vn666915swZczsgIEBNmza16t6ceu211+Tp6WluL1iwQMuXL8+TtfJDr169LN6Pn3/+WWFhdz6CIjU1VSEhIRZ9r732mk1qGjRokEVQbdKkSdqzZ49N5s5LJUuWVLdu3cztxMTELP/O36uCgoIs2j/++KOOHj1q8b3r6aef1sMPP5zfpQH3DY6IBQAAAPLItM++z9H4kI+G6kD4PnP7sTJP6PVXe+mnSXOyuQu4ewUfr6jPKr2rkydPWvxw+m70X9jPNkUBAAAAAABkwdPTU/Pnz1f9+vXNO7VFRkaqQYMGmjJlijp37mz1bv0bN25U//79tX//fvn7+2e4npKSopdfflnr168397m6uio0NFTPPPOMbV7QbYKDgy12mwoKCsrRrmW3DB8+XDVr1lSjRo2yHPPuu+9q27Zt5rabm5v69u2b7fitW7ea2998841q1qyZ7W5Yq1at0vDhwy36Bg4cKCenvNkDyGg0avDgwRo6dKgkKS0tTV26dNHcuXPVunVrq+cJCwvThAkTNH/+/Dyp01qVKlVSq1attHTpUkk3X0/79u31119/qXTp0pneYzKZ9Nprr2nfvv/7GXPhwoWzfW9zonz58urVq5emTp0qSbp69apatWqlhQsXqm7dulbPs27dOv3yyy+aNm2aTeqyxogRIzR//nwlJSVJkubPny+j0ahJkybJ1dXVqjliYmL07bff6oknnsjRUcz54eWXX9bbb7+tq1evSpLmzp2b4Rer04fwAOQMO9gBAAAADuiF2q004cNPLH4jEAAAAAAAAHjQ1a5dW9OnT7cIasXGxuqVV15RnTp1NHXqVItd027333//6YsvvtDTTz+thg0bWhz7ml7v3r21bNmyDH3Ozs5au3Ztjv6cP3/eNi/+Dvz9/ZWcnKwWLVroo48+0sWLFy2uHzhwQK1bt9aXX35p0T9y5MhMQ4a3vPTSS2rfvr25bTKZFBwcrL59+1ocMytJ58+f17Bhw9SqVStdv37d3P/000/rrbfeys3Lu6OQkBA9//zz5vbly5fVtm1bvfTSS1q3bp2Sk5Mz3HPt2jXt3LlT48aNU61atRQYGKhff/01T+u01rfffmuxK9/p06dVo0YNzZw5U4mJiRZjt2/froYNG2YIZX722Wd66KGHbFbTl19+qRo1apjb58+f17PPPqsePXpo+/btSklJyXDPlStX9Ndff2n48OF69NFH1bhxY61evdpmNVmjfPny+uGHHyz6pk2bpscee0zTp0/XhQsXMtxjMpl0/Phx/fTTT3rppZdUunRpffDBBw55vKyHh4fatWtnboeHh+urr74yt93c3NSxY0c7VAbcP/j/1gEAAAAOxFnO6tO+r15s+YK9SwEAAAAAAAAcUlBQkIxGo4KCgpSQkGDu37Vrl3bt2iVJ8vb2lo+Pj4xGoy5duqTz58+bd69Kz8/PL0Pf7TvX3TJlyhRNmTIlx/XOmjVLwcHBOb7vbtZp1qyZrl+/rlGjRunjjz9WuXLlZDQadf78eUVERGS4p3nz5nrvvffuOPe0adN07Ngx8+5oJpNJU6dO1dSpUxUQECAfHx/FxMTo5MmTSktLs7i3XLlymjdvnpydnW3zQrPg5OSkefPmqW3bttqwYYO5ztDQUIWGhqpgwYLy9/eXl5eXrl27pri4OJ09e1apqal5WtfdKl26tObOnav27dubw4HR0dHq1auX3nrrLZUrV07u7u4KDw9XVFRUhvt79uxps93rbnF3d9eSJUv0/PPPm49mTklJ0ezZszV79mwVLlxYZcqUkdFoVFJSkmJjYxUREZFhNzV76Ny5s86dO6f333/f/Bk9evSoXn/9db3++usqU6aMihcvLhcXF8XFxSkyMlKXL1+2c9XWCwoK0rx588zta9eumb9u06aNRVgTQM4RsAMAAAAcRKmSD+nVl7roiccez3AtPiLGDhXhfsfnCgAAAAAA3Kvatm2rffv2aeDAgVq8eHGG6zExMYqJyf5nH8WKFdOIESP05ptv5lWZ+apRo0b66aefFBQUpOvXryslJUX//fdfluOff/55LViwQAUKFLjj3N7e3tq4caNefvllrVmzxuLaqVOndOrUqUzve/LJJ7V48eJMQ4x5wWg0as2aNRo8eLC++eYbix3VkpOTdfTo0TvOUaZMmbwsMUdeeOEFrVq1Sh07drQI0V29elWHDx/O9B5nZ2eFhIRo3LhxeVJT6dKltW3bNvXt21c///yzRXguMTFR//777x3nKFu2bJ7UdifvvPOOqlatqh49emTYWTI8PFzh4eHZ3l+wYEGVKFEiL0u8a02aNFGpUqUyDdJyPCyQewTsAAAAAAcxoO/bGfo8PDxk9PLU9EZj7VARHgRGL095eHjYuwwAAAAAAIAcCwgI0O+//669e/dq+vTpWrRokSIjI7O9p3Dhwnr22WcVFBSktm3bqmDBgvlUbf7o3LmzKleurPfffz9DEO6W8uXLa8SIEerRo0eO5jYajVq9erVCQ0P16aefateuXVnuTFatWjW9++676t69u8VxvvnBxcVFn3/+ud58802NHz9ev//+e6Y7vN0uICBAzZo1U4cOHdS4ceN8qtQ6DRo00LFjx/Tpp59q9uzZOnfuXKbj3Nzc1KJFC40ePVqPPfZYntZUuHBh/fTTT3r//ff16aefauXKlYqLi8v2nkcffVTNmzdXp06dVLdu3TytLzvNmzfXiRMnNH36dM2YMUMHDhzIdoe9IkWKqEGDBmrVqpU6deokLy+vfKzWek5OTuratavGjx9v0e/r66tmzZrZqSrg/mEwOcJenHBohw4dUrVq1cztgwcPqmrVqnasCABwr/ik3Ugd2XpIjzxdVUNDR9u7HCBftOjVUgaDQSaTSX/8sNImc8bExFgcdQHYkoeHh7y9vXM9T/+F/cxff9P+21zPB9wrnpjYwfz1vvcX2LESAAAA4N6T2e5aDz/8sFxc2CMEd+/48eM6ePCgwsPDdfnyZZlMJnl6esrb21tVqlRR1apV8/yoUkdx9uxZbdmyRWfOnFFKSor8/PxUrVo1BQYG2mT+CxcuaOvWrYqMjFRsbKw8PDxUsmRJ1alTx247lGXGZDLp0KFDOnTokKKjoxUXF6eCBQvKaDSqXLlyqlKlih566CF7l2m1vXv36tChQ4qKilJycrJ8fHxUpkwZ1a9fX4UKFbJLTWlpadqzZ4+OHj2q6OhoJSQkqFChQvL09FSFChVUpUoV+fj42KW2O7l48aJ27NihyMhIXbp0SWlpafLw8JCvr68qV66shx9+2KpdHgFHl1f/7npQMkX86xQAAABwcN7e3jYJQAEAAAAAAAD3uwoVKqhChQr2LsMhlC5dWp06dcqz+UuWLKl27drl2fy2YjAYVK1aNYsAyL2sevXqql69ur3LsODk5KTAwECbhTfzk4+Pj1q1amXvMgA4uPzdixUAAAAAAAAAAAAAAAAAgHsEATsAAAAAAAAAAAAAAAAAADLBEbEAAACAg4uJiVFCQoK9y8B9ysPDgyOIAQAAAAAAAAAAskDADgAAAHAQh/45rMqPPConp//baDomJkblK1ZQfGyc/QrDfc3o5akTx44TsgMAAAAAAAAAAMgEATsAAADAQcz59SelpN7QJ8PHqmDBgpKkhIQExcfGqff64TKWIgAF24qPiNH0RmOVkJBAwA4AAAAAAABAvjt//rwOHTpk83lr1aolLy8vm88L4MFEwA4AAABwIP+cO6zeIX30xQefqXjx4uZ+YylveQX42LEyAAAAAAAAAABsa9WqVerRo4fN512/fr0aNmxo83kBPJic7jwEAAAAQH66mBilPsPf0KHDh+1dCgAAAAAAAAAAAPBAI2AHAAAAOKCk1EQN/mKItu7cbu9SAAAAAAAAAAAAgAcWR8QCAAAAeaTla8/n6v5UpWju6p9Uu/5TNqoIsJS8/5je+q2vvgibIIXZuxoAAAAAAAAAD5rg4GAFBwfbuwwAyBY72AEAAAAOzCSTilXy1tWj8fYuBfcpg8Fg7xIAAAAAAAAAAAAcFgE7AAAAwIE5y0XHth2XeyWjvUvBfcpkMtm7BAAAAAAAAAAAAIfFEbEAAABAHlk5Y0WOxod8NFQHwveZ24WcC+vNzv3U+IfnbF0aIEkq+HhFfVbpXZ08eVIBAQG5mqv/wn62KQoAAAAAAAAAAMCBELADAAAAHFCJwiX1+cjPdOXyZXuXAgAAAAAAAAAAADywOCIWAAAAcDBVSlXV9IlTVbxYMXuXAgAAAAAAAAAAADzQ2MEOAAAAcBBOTk5qVquFBr3R396lAAAAAAAAAAAAABABOwAAAMBhvNfvnSx3rYuPiMnnavAg4HMFAAAAAAAAAACQPQJ2AAAAgIPILFzn4eEho5enpjcaa4eK8CAwennKw8PD3mUAAAAAAAAAAAA4JAJ2AAAAgAPz9vbWiWPHlZCQYO9ScJ/y8PCQt7e3vcsAAAAAAAAAAABwSATsAAAAAAfn7e1NAAoAAAAAAAAAAACwAyd7FwAAAAAAAAAAAAAAAAAAgCNiBzsAAAAAgMOJiYnhaGTkKY5HBgAAAAAAAABYg4AdAAAAAMCuLsRFqqSnr7kdExOjChXLKy423o5V4X7n6WXU8WMnCNkBAAAAAAAAALJFwA4AAAAAYFdj/xytjtVfUf0K9SVJCQkJiouN14RVb6h4KaOdq8P9KDoiXiHNv1NCQgIBOwAAAAAAAABAtgjYAQAAAADs7te98/RP5AH1rveGua94KaNK+hN+AgAAAAAAAAAA9uNk7wIAAAAAAJCkA5EHNGLZUHuXAQAAAAAAAAAAYEbADgAAAADgMBKS4/Vl2ER7lwEAAAAAAAAAACCJI2IBAAAAALk0Z8dMi3b/hf1yNZ9JJr31W19du3YtV/MAAAAAAAAAAADkFgE7AAAAAECuHI8+ZvM5DQaD/jmVrJL+1+Tm5mbz+fFgCz8Rr3bvNNf8nbPktp/PFwAAAAAAAAAgawTsAAAAAAAOx2QyydXFQLgOeeLqlRSVquSrs7Gn7V0KAAAAAAAAAMDBEbADAAAAAOTKsMYjFbL8HXN79AvjcnT/yOXDMvQdXv+Puvarm+vagMy4F3HRkd1nVKdOnVyHODclhNmoKgAAAAAAcqZhw4bauHGjuW0ymexYzYPh1KlTKleunLkdFBSk2bNn26+gXNqwYYMaNWpkbn/44YcaNWqU/QoCAAdFwA4AAAAAkCvpA0qebp65mq+F//Oa9O13BOyQZ8qUN+rD1qv0xcnvFRAQkKu5Zk7sYJuiAAAAAAA2cfLkSR08eFDh4eFKSEhQWlqavLy85OXlpcqVK6tatWpydna+q7kjIiJ04MABnTp1SnFxcXJ2dpaXl5cCAgJUp04dFS1a1MavBgAAOAICdgAAAAAAhzH6hXGKi4yzdxkAAAAAAOAecuDAAU2bNk2hoaGKiIjIdmyhQoVUr149de3aVe3bt1fhwoWzHJuYmKhly5Zp5cqV+vPPP3X27Nksxzo7O6tBgwYaMGCAWrdufdevBQAAOB4CdgAAAAAAuzPIoK/bT5EkxSnOvsUAAAAAAO5JF5avtncJ942SLzSzdwlWOXPmjAYNGqRFixZZfU9SUpLWrFmjNWvW6O2339aQIUM0aNCgDDv0f/LJJxo7dqwSExOtmjc1NVXr1q3TunXr1KJFC82aNUu+vr45ej0AAMAxEbADAAAAANhVUVcPjX3x0wz90RHxdqgGDwI+WwAAAABw71u2bJm6du2q+PjM/xvPy8tLPj4+MhqNio6O1oULF5SUlGQxJiEhQcOGDdOiRYu0a9cui2thYWGZhusMBoN8fX1VsmRJGQwGhYeHKzo62mLMH3/8ofr162vz5s3y8/PL5SsFAAD2RsAOAAAAAGBX6cN1Hh4e8vQyKqT5d3aqCA8CTy+jPDw87F0GAAAAAOAu/PzzzwoKClJqaqpFf61atdSrVy89//zz8vf3z3DfkSNHtHjxYv36668KCwsz91+8eDHb9dzd3fXyyy+rTZs2atCggYoVK2a+ZjKZFBYWpjFjxmjJkiXm/uPHj6tNmzbavn27nJyc7valAgAAB0DADgAAAADgULy9vXX82AklJCTYuxTcxzw8POTt7W3vMgAAAAAAObR792717NnTIlxnNBo1efJkvfrqqzIYDFne+8gjjygkJEQhISEKDQ3V0KFDdeTIkSzH+/j4aMiQIerVq5eMRmOmYwwGgwIDA7V48WKNHTtWI0aMMF/btWuX5syZox49etzFKwUAAI6CgB0AAAAAwOF4e3sTfgIAAAAAABYSEhLUqVMnXb9+3dxXokQJrVq1StWrV8/RXO3atdMLL7ygfv36ae3atRmu9+nTR7Nnz1aRIkWsnnP48OEKCwtTaGiouW/GjBkE7AAAuMexFy0AAAAAAAAAAAAAwOGNGjVKJ06cMLednJz0+++/5zhcd4urq6tmzJihL774IsO1pk2b5ihcd8vQoUMt2tu3b2eXfgAA7nHsYAcAAAAAAAAAAAAAcGhxcXGaPn26Rd/AgQNVt27dXM/90ksv5XqOWwIDA+Xu7q6rV69KktLS0nT27FlVqVLFZmtYKyIiQlu3btXp06eVkpIiPz8/VatWTbVq1bLJ/FFRUdq6dasiIyMVExMjo9GokiVLqk6dOipTpoxN1rhdRESEwsLCdO7cOV26dEmenp5q166dHnrooWzvS0pK0pYtWxQREaGoqCg5OzurRIkSqlKlimrWrJntscJ348iRI9qxY4fOnTtnXqt27dqqXLmyTebfu3evDh8+rKioKF27dk0lSpRQmTJlVL9+fbm7u9tkjZyKi4vT1q1bdf78eV28eFFubm7y8fFRjRo17PLZt8a1a9e0adMmnTx5UtHR0SpSpIgqVaqkZ5555q7Ctda628+xI77vtnDw4EHt3r1bkZGRKlCggEqVKqWnnnpKAQEBuZr39OnT+vvvv3X27FklJCTIYDCocOHC8vPzU/ny5VW1alW5ubnZ5kXggUDADgAAAADgcGJiYvjtbuQpDw8PjiEGAAAAgHvI1KlTdeXKFXPb1dU1w25xjsBgMMhoNJoDdpIUHx+frzXs27dPISEhWrNmjUwmU4brFSpU0IgRIxQcHHxX8//+++/69NNPtXPnzkznl6THHntM7777rrp16yYnJ+sO1rs96NagQQNt2LBBkrR8+XJ98cUX2rBhg9LS0izuKVWqlNq2bZvpfFu2bNHYsWO1bt06JScnZzqmRIkS6tOnj95//30VLVrUqjqzsnr1ag0fPly7d+/O9HrlypU1fvx4vfjiizme+/Llyxo/frxmzZqlc+fOZTrGzc1NLVq00JgxY1StWrUcr3E3li5dqs8++0xbt25VSkpKpmPKli2rgQMHql+/fipYsGC+1JWd+Ph4jRgxQnPmzNHly5czXHdzc1NQUJDGjh2rYsWKacOGDWrUqJH5+ocffqhRo0ZlOb8tP8d59b4HBwdrzpw55vbJkyetDrTZ6nksWrRIH3zwgQ4fPpzpPU8//bQmTpyYoxB1WlqaZsyYoSlTpmj//v3ZjnV1dVWtWrXUvn179evX754OKSJ/ELADAAAAANjVgIVv6uv2U8ztmJgYVahYXnGx+fvDZzxYPL2MOn7sBCE7AAAAALhHLFq0yKLdrl07FS9e3E7VZO3GjRu6ePGiRV+xYsXueF/6wEtQUJBmz56d4/X/97//KSgoSDdu3MhyzPHjx9WjRw8tWrRIv/32m9Whp/j4eHXs2FGrV6++49gDBw4oODhYU6ZM0eLFi+Xn52f1a7jFZDKpf//+mjx5co7uS0xMVI8ePfTbb7/dcWxUVJTGjBmj6dOna8mSJXryySdzXKckhYSEaOLEidmO+eeff9S6dWuNHj1aH3zwgdVzb9y4UR07dlRUVFS2465du6bff/9dS5cu1eDBgzV27Fir18ipqKgoderUyRyWys6ZM2f0zjvv6Pvvv9eKFStUoUKFPKvrTvbt26eWLVvq/PnzWY65du2apk6dqmXLlmnVqlW5XvNuP8eO+L7bgjXPw2QyacuWLapfv75GjRpl1d+X2NhYvfjii9qyZYtVdVy/fl3btm3Ttm3b1KZNG1WsWNHq14AHEwE7AAAAAIBdmWRS/4X9NLzxSJX09FVCQoLiYuM1YdUbKl7KaO/ycB+KjohXSPPvlJCQQMAOAAAAAO4BiYmJ2rNnj0VfmzZt7FRN9rZu3arU1FRzu2DBgipbtmy+rL1+/Xp1797dvJOYs7OzypUrJ09PT507dy7DDlhLly5V+/bt9fvvv8vFJfvoQExMjBo3bqy9e/dmuFa2bFmVKFFCMTExOnXqlMXuXLt27VK9evW0fv16+fv75+j1DBs2zCKE4+7uLn9/fxUuXFgRERGKjIzMcE9UVJSef/55hYWFZbhWunRplSxZUqmpqTp9+rRiY2PN1yIjI9WwYUOtWrVK9evXz1GdQ4YMsQjXFS1aVGXLlpW7u7tOnz6dIXA5cuRIVa1a1aqjiZcvX64OHTro2rVrFv1ubm4KCAhQoUKFFB4ebrFGamqqxo0bp8jISP3www85ei3W+O+//9S8eXOdPHnSot9gMMjf31/FixdXcnKyTp48abHr5NGjR1W3bl399ddfqlSpks3rupN//vlHTZo0UXR0tEW/i4uLypUrJ6PRqAsXLig8PFzSzaNcW7Rooc8//zxX697N59gR33db+fjjjy2eR6FChVSuXDkVKFBAp06dUlxcnPlaWlqaRo4cqQIFCmjIkCFZzmkymdSmTZsM4TqDwSA/Pz/5+vqqQIECunz5ss6dO2exBmAtAnYAAAAAAIcw9s/R6lKjq/ycHpIkFS9lVEl/wk8AAAAAADzotm/fnuH4ycDAQDtVk72ZM2datJ977jm5ubnly9o9evRQSkqKXF1dNWzYMPXr108+Pj7m6/v379fw4cO1bNkyc9/y5cv1+eefa/DgwdnO/frrr2cI1/Xu3VuDBw+22JHs3LlzmjRpkj777DPze3by5Em98sor2rRpk5ydna16LYcPH9bmzZslSQ8//LDGjRunVq1aWTzLgwcPqlChQuZ2WlqaOnfubBGu8/HxUUhIiLp27SpfX1+Lsdu2bdPIkSO1bt06SVJSUpK6dOmivXv3WrXroCRt2rTJHDSrU6eOxowZo0aNGpkDiyaTSRs3btQbb7yhf//913xf//791bp162yDjeHh4eratatFyKpYsWL69NNP1blzZxUpUsTcv23bNoWEhOivv/4y982cOVNPPvmk+vbta9VrsUZSUpLatGljEa4rV66chgwZopdfflleXl7m/pSUFK1du1bDhw83B2QvXryoTp06afv27fl6XGxKSoq6du1qEa4rXLiwPvzwQ/Xq1cviFzCPHTumTz75RDNnztTZs2ezDXbdyd18jh3xfbeVY8eOmUNwJUuW1MSJE/Xyyy+bn0dqaqrWrl2rQYMG6Z9//jHfN3z4cDVo0CDL42IXLFhgfs7Szfd21KhR6tatm0qWLJlhfHh4uNavX6/FixdryZIltnyJuI9Zd9g5AAAAAAD54H9/z9Xv/y2680AAAAAAAPDAuD2YJElFihRxyOP89u/fr59//tmiLzg4ON/WP336tAoWLKiVK1fqww8/tAjXSdLjjz+upUuXatCgQRb9H330kc6cOZPlvAsXLtTChQst+mbMmKFp06ZlOO7zoYce0ieffKLFixerQIEC5v6tW7dq0qRJVr+WixcvKi0tTc8884z27NmjDh06ZAgqVqtWTeXLlze3J06cqPXr15vbderU0cGDB/Xee+9ZhOskycnJSfXq1dOaNWv01ltvmfvPnj2r0aNHW13nraBZcHCwtmzZoqZNm1qE5gwGgxo2bKhNmzbpoYceMvdHRERo+fLl2c7dr18/i522ypQpo7CwML322msWIStJqlu3rjZu3Khu3bpZ9L/77rsZdi7MjXfffdci+PTiiy9q//79ev311y3CddLNneFatGihrVu3ql27dub+vXv36ttvv7VZTdb47rvvLHbB9PDw0IYNG/T+++9nON2gYsWK+uGHH8w1pt+pLyfu5nPsiO+7rURERCglJUX+/v4KCwtTt27dLJ6Hs7Ozmjdvrt27d6tevXrm/rS0NL3++usymUyZzpv+OOilS5fqvffeyzRcJ918pt27d9fChQt14sSJDN8fgMwQsAMAAAAA5Mr+s3st2u+GDsjRn/ROJBxTt8mv5FP1AAAAAADA0cXExFi0fXx8ZDAY7FRN5pKTkxUcHGxxPGzNmjXVoUOHfK1j7Nixeu6557Id8/nnn1vsBHX16lV9//332Y6/3VtvvaVevXplu8bzzz+vMWPGWPR99dVXFs/nTry8vPTrr79mCBVlJikpSRMmTDC3/fz8tGLFCpUoUSLb+5ycnPTVV1/pqaeeMvfNnDkzR0dIBgYGatq0adnuzufj46MPPvjAom/lypVZjj9y5IhFAM/JyUkLFizI9phdJycnzZw5U4899pi5LykpSd999501L+OOwsPDNWPGDHP78ccf12+//XbH96dgwYKaO3euAgICzH1ff/11jj4LuZU+3PnNN9/ccRfMN954Q127ds312jn5HDvi+25rBoNBv/32m0qVKpXlmEKFCmnRokUyGo3mvoMHD2rNmjWZjj969Kj560cffVSNGjWyup4yZcpY9d4AHBELAAAAAMiVBft+tWjfSLuR6zmNJT3097/xasERscgD4Sfi1e6d5pq/c5bc9ufPMT0AAAAAgLuXPmDn6elpn0Ky0b9/f/3999/mtouLi6ZPny4nJ+v2vJk9e7Zmz56dqxpKlSql/v3733GcwWDQ+PHj9eyzz5r7Zs2apbFjx2YILh4+fFjbtm0ztwsXLpwhOJeVd955R1OmTFF4eLikmzvsrV69Wi1btrTq/jfffNPqnaV+/PFHi8/JqFGjMuxMlhVnZ2cNHTpUbdq0kSRduXJFq1atUqdOnay6f/To0Ra79WWlY8eOeuONN8zt23dUS++HH36w2K2rS5cuql279h3XcHFx0cSJE9WiRQtz3/Tp0zV69Ohch1KnTJlicVTzxIkTrT7mtVChQho0aJAGDLj5y7anT5/W7t27VadOnVzVZI1t27bpv//+M7crV66s7t27W3XvuHHjNG/ePKWlpd31+jn5HDvi+25rHTp00JNPPnnHcSVKlNC7776rkSNHmvtmzpypZs2aZRh79epV89fW/F0E7gY72AEAAAAAHM6tH/xcu3bNzpXgfnT1SopKVfLV2djTOnb+SK7+AAAAAADy3uXLly3ahQsXtlMlmZs0aZKmTZtm0ffxxx+rZs2a+VpH586drQ6XPPPMMxbHUkZGRurIkYz/nbtx40aL9ksvvWR1wLFAgQIZjq7ctGmTVfdKN8NF1lqxYoX5axcXF3Xu3NnqeyWpcePGFmHIzZs3W3Wf0WhU8+bNrRrr7e2tsmXLmtu3goeZSf/ce/bsadUaktS0aVOVLl3a3L5w4YLFDl936/Zn7OvrqyZNmuTo/vTBKGufcW799ddfFu1XXnnF6tBZmTJl1KBBg1ytn5PPsSO+77Zmbbjx1tjb36v0z+eW249fPnz4sEXYGbAVAnYAAAAAgFyp7f/UnQflUMr1FNV41Cg3N3YXg+25F3FRxNFIlfbyV0W/R3L1BwAAAACQ94oWLWrRTkxMtFMlGYWGhmrgwIEWfZ06dVJISEi+19KwYcMcjU8fHNq5c2eGMTt27LBo3+n42fQaN25s0d6+fbtV9xUtWlSVK1e2aqzJZNKWLVvM7UqVKsnDw8P6InUztFmsWDFz+59//rHqvpo1a1q9S6EkiyNr4+PjMx2TnJysvXv3mtsFChRQ/fr1rV7DyckpwxGZ1j73rMTGxurgwYPmdk5ftySLcKFk/TPOrd27d1u0n3766Rzdn9Pxt8vJ59gR33dbMxgMOQos+vv7WxwtHBkZqTNnzmQY17RpU/PXqampatGihWbMmKGkpKRc1QvcjiNiAQAAAAC50qpaa60+8oe5/U37b3N0f/+F/SzaRVyK6pMOE/TkwSE2qQ9Ir0x5oz5svUpfnPze4od0d2PmxA62KQoAAAAAkKX0R31mFUzKbxs2bFCXLl0sjo9s1qyZfvzxR7scy1itWrVcjT958mSGMadPn7ZoP/744zla44knnrBoZxaOyYy/v7/Vz/DChQsWx8MePnw4188//bHEWbk9MGeN23dfvP1Yy9tFRkbq+vXr5vajjz4qV1fXHK3zxBNP6KeffjK3rX3uWTly5IjF0aUrVqzIt2ecWxERERZtawNvdzv+djn5HDvi+25rZcuWzRCYvpNq1apZfG86efJkhrBm37599c033+jChQuSpKioKPXu3VsDBgxQkyZN1KhRI9WrV0/Vq1fnCFncNXawAwAAAAA4jOoPVdfrT7xh7zIAAAAAAIADSR+wu3jxop0q+T+7d+9W69atlZycbO6rW7euFi1alONQjK3cvgPb3YyPi4vLMCY2NtaiXbx48Ryt4e3tbbHTWfr5spKTHeguXbqUo5qsYW2IMy9OX8jtM8/sHmufe1bs+YxzK/3n2mg05uh+a49EzkxOPseO+L7bWk6/R2V2T2bfp7y9vbVs2TL5+flZ9CclJWnJkiUaNGiQateuLW9vbz3//POaMWNGpvMA2SFgBwAAAABwCF1qdFXPuq/buwwAAAAAAOBgHn30UYv25cuXdezYMTtVIx06dEgtWrTQ5cuXzX1PPPGEVqxYYbFDWX4rVKhQjsanr/XKlSsZxqTvy+nrMxgMcnd3N7dvf2bZyckuU3kRlLl9V8L8lttnntk91j73rNzLz/j2EKykHAdgCxYseNdr5+Rz7Ijvu63l9HuUZN33KUkKDAzUwYMH9f7772cIZd9+78qVK9W7d2+VLVtWo0aN0o0bN3JcEx5MHBELAAAAALC74Y1HqqSnr0VfdIRjHPeC+w+fLQAAAAC4tzz11FNycXFRSkqKuW/37t2qWLFivtdy/PhxNW3a1GJHr0qVKmn16tW52unKFpKSknJ0/GJiYqJFu0iRIhnGpO9LTEzM0S5UJpPJ4ijUnB4PaY30oZ0qVaro66+/ztWct4cC81tmzzyn0t+T2+ee/hk3atRIw4YNy9WcXl5eubrfWul3rLty5UqO/q4mJCTYuKLMOeL7bmtJSUk5vsea71O3eHt7a8KECfr444+1YcMGrV+/Xhs3btTu3bszBOkuX76sjz76SGvXrtXq1avvKvyHBwsBOwAAAACAXX3T/luLtoeHhzy9jApp/p2dKsKDwNPLmKNjOgAAAAAA9lO4cGHVrFlTO3fuNPctWbJEnTt3ztc6wsPD1bhxY50/f97cV7ZsWa1du1YlSpTI11oyEx0dnaNATfpjPzMLHaUPQV26dElly5a1eo2YmBiLncryIlSV/lhMk8mkJk2a2Hyd/JLZM8+p6OjobOfMqfTP2M3N7Z55xul3Mzt37lyOAnbnzp2zcUWZy8/33WAw5HjuW+4mJHdL+vqsYc33qfRcXV3VrFkzNWvWTJJ09epVbd++XStWrNC8efMs3tMtW7bovffe07fffpvVdIAkAnYAAAAAAAfj7e2t48dO5Ntvh+LB5OHhkeVxEQAAAAAAx9OuXTuLgN2iRYt06dKlHO2mlhtRUVFq0qSJTp8+be7z9fXVn3/+qTJlyuRLDXdy8OBBlStXzurxBw4csGhndq+/v79Fe9++fapRo4bVa+zbty/b+WzB19dX7u7u5p3yTp8+rRs3buToeE5H4ufnJ1dXV12/fl2S9O+//+r69es5OtrU1s89/WfDnkc051SVKlW0Zs0ac/vvv/9WlSpVrL5/7969eVBVRvn5vru5uVm0b99l8k4uXrxo9dj0wsPDlZCQkKNferXm+9SduLu7q1GjRmrUqJHGjRunjz76SGPHjjVfnzFjhj799FN+GRfZImAHAAAAAHA43t7ehJ8AAAAAAIBZnz59NHbsWF25ckWSlJycrPHjx2vChAl5vnZsbKyaNm2qo0ePmvu8vb21Zs0auxxTm5WNGzfqxRdftHr8pk2bLNq1a9fOMOapp57SnDlzzO1169YpODjY6jXWrVuXYT5bK1CggOrVq6e1a9dKurnD1o4dO1S/fn2br5UfXF1dVaNGDe3YsUOSdP36df3111967rnnrLrfZDJpw4YNFn25fe6lS5dWxYoVzcG6//77T+Hh4Q4TLs1O+s/1smXL9Oqrr1p1b2pqqpYvX54XZWWQn+97+iDZhQsXVLlyZavW2bVrl1XjMmMymbRp0ya1atXKqvGnT5/WqVOnzG1fX98c7aCZmQIFCujjjz/Wxo0b9ddff0mSbty4oR07dqhp06a5mhv3Nyd7FwAAAAAAAAAAAAAAQHa8vLzUq1cvi74vvvjCHEbJjRUrVmR57cqVK2rZsqX2799v7vPw8NCqVatUrVq1XK9tS7/88otu3Lhh1djNmzfrxIkT5ravr68eeeSRDOMaNGhg0Q4NDVV8fLxVa9y4cUM//fRTtvPZSosWLSzakyZNypN18kv65zR79myr712zZo3Cw8PNbT8/P1WqVCnXNaV/xpMnT871nPmhWbNmKliwoLm9ePFiRUREWHXvwoULFRkZmVelZZBf73v6ne3+/vtvq9a4ceOGQkNDra4pMz/++ONdj3322Wdztfbt6tWrZ9G+m+Nr8WAhYAcAAAAAAAAAAAAAcHijRo1SQECAuZ2amqq2bdtmOELQWjdu3NB7772nN998M9Pr165dU+vWrS1CfO7u7lq2bJkCAwPvas28FBERoW+++eaO40wmkwYPHmzRFxwcLIPBkGFs5cqV9fTTT5vbV65c0YcffmhVPV9//bXOnDljbgcEBOTZDlGvvfaaPD09ze0FCxbk285jeaFXr14W78fPP/+ssLCwO96XmpqqkJAQi77XXnvNJjUNGjRILi7/d0jipEmTtGfPHpvMnZeKFy+udu3amdtXr15Vv379lJaWlu19Fy9e1HvvvZfX5VnIr/e9Zs2aFu1ff/3VqvomTZqkc+fOWTU2KwsWLLBqF7yoqCh9/vnnFn09e/bM1dq3Sx+o8/LystncuD9xRCwAAAAAwOHExMQoISHB3mXgPubh4cExxAAAAABwj/H09NT8+fNVv359805tkZGRatCggaZMmaLOnTtnGhLLzMaNG9W/f3/t378/w25OkpSSkqKXX35Z69evN/e5uroqNDRUzzzzjG1e0G2Cg4MtjmINCgrK0e5VtwwfPlw1a9ZUo0aNshzz7rvvatu2bea2m5ub+vbtm+34rVu3mtvffPONatasqe7du2d5z6pVqzR8+HCLvoEDB8rJKW/2ADIajRo8eLCGDh0qSUpLS1OXLl00d+5ctW7d2up5wsLCNGHCBM2fPz9P6rRWpUqV1KpVKy1dulTSzdfTvn17/fXXXypdunSm95hMJr322mvat2+fua9w4cLZvrc5Ub58efXq1UtTp06VdDOo1qpVKy1cuFB169a1ep5169bpl19+0bRp02xSlzU++OADLVq0SNevX5ckLVmyREFBQfr2229VtGjRDOOPHTuml19+WeHh4TIYDDKZTPlSZ36977Vq1VKJEiUUFRUlSdq+fbvmzZunV155Jct7VqxYoWHDht3Ny8pQb8eOHbVlyxY99NBDmY65evWqXnrpJYvdMqtUqaJmzZplGJuQkKA33nhD7733nmrUqGFVDadOndKCBQvMbScnJ1WvXj1nLwQPHAJ2AAAAAAC7mrp5ivo883+/KR4TE6MKFcsrLta640aAu+HpZdTxYycI2QEAAADAPaZ27dqaPn26evbsad6BKjY2Vq+88oq+/PJL9erVSy1btlTZsmUz3Pvff/9p6dKlWrBggUXALDO9e/fWsmXLMvQ5Oztr7dq1Oaq5atWq8vPzy9E9d8Pf31+nT59WixYtNGzYMPXr108+Pj7m6wcOHNDw4cPN4Z1bRo4cmWnI8JaXXnpJ7du318KFCyXdDMgEBwdr69atCgkJUfny5c1jz58/r0mTJmnixIlKSUkx9z/99NN66623bPVSMxUSEqLNmzebj/y9fPmy2rZtq7Zt2+qtt95SvXr1LI4KlW7uUrh//36tXbtWCxcuNO/IZu+AnSR9++232rx5s+Li4iRJp0+fVo0aNTR+/Hh16tRJhQsXNo/dvn27Bg8erE2bNlnM8dlnn2UZYrobX375pXbu3Gk+UvT8+fN69tln1bVrV/Xp00eBgYEWu9xJN3c93Lt3r1auXKmFCxfqyJEj2X7e8kKVKlX0wQcf6IMPPjD3zZ07V3/++adeeeUVBQYGysPDQ1FRUVq3bp1+++03Xbt2TZLUp08fff/99/lWa3687wUKFFBwcLAmTJhg7uvRo4fOnz+vvn37Wqxx/Phxff311/r222+VmpqqChUq6Pjx43f12kqVKqULFy7o1KlTqlmzpj777DN16NBBbm5ukm4GCtesWaN33nlHhw8fNt9nMBg0bdq0TAPUaWlpmjdvnubNm6fAwEB16NBBTZs2VbVq1eTq6moxNiEhQb/99ptGjBhhEd578cUX5evre1evCQ8OAnYAAAAAALs6FHVIw5YO1rgXx0u6+YOOuNh4TVj1hoqXMtq5OtyPoiPiFdL8OyUkJBCwAwAAAIB7UFBQkIxGo4KCgix2wN+1a5f56EFvb2/5+PjIaDTq0qVLOn/+vJKSkjKdL7Pw2+07190yZcoUTZkyJcf1zpo1S8HBwTm+727Wadasma5fv65Ro0bp448/Vrly5WQ0GnX+/HlFRERkuKd58+ZWHYM5bdo0HTt2zLxLlslk0tSpUzV16lQFBATIx8dHMTExOnnyZIajN8uVK6d58+bJ2dnZNi80C05OTpo3b57atm2rDRs2mOsMDQ1VaGioChYsKH9/f3l5eenatWuKi4vT2bNnlZqamqd13a3SpUtr7ty5at++vZKTkyXdPNayV69eeuutt1SuXDm5u7srPDzcvBPZ7Xr27Gmz3etucXd315IlS/T888+bj2ZOSUnR7NmzNXv2bBUuXFhlypSR0WhUUlKSYmNjFRERkW87wGVn+PDhOn36tGbMmGHuO3/+fIZjSG/39ttv66WXXrII2KUPENpafr3vw4cP188//2z+vnD9+nW99957Gj58uB5++GG5ubkpMjJSZ8+eNd/z6KOP6pNPPrE4cjcnKlasqL59++qDDz7QhQsX1K1bN/Xt21flypVTgQIFdOrUKcXGxma4b/To0apXr94d59+9e7d2796tIUOGyNXVVaVLl5aXl5ecnZ116dIlnTp1KsPfdx8fH02aNOmuXg8eLATsAAAAAAB2d+X6ZQ1c+Ja+aj/Z3Fe8lFEl/Qk/AQAAAACAjNq2bat9+/Zp4MCBWrx4cYbrMTExiomJyXaOYsWKacSIEXrzzTezHXevaNSokX766ScFBQXp+vXrSklJ0X///Zfl+Oeff14LFixQgQIF7ji3t7e3Nm7cqJdffllr1qyxuHbq1CmdOnUq0/uefPJJLV68OF928JNuHhW7Zs0aDR48WN98843FLnrJyck6evToHecoU6ZMXpaYIy+88IJWrVqljh07WoSprl69arHD1+2cnZ0VEhKicePG5UlNpUuX1rZt29S3b1/9/PPPFuG5xMRE/fvvv3ecI7MdJvParV3QHn74YY0aNUpXr17NcqyLi4s+/PBDjRgxIsNOlkZj3v9CcH687x4eHlqyZImaN2+u6Ohoc39ycrIOHjyYYfwTTzyh5cuXZ/s9xRojRozQxYsX9c0330i6+ZnJbD3pZmj2gw8+0IgRI3K8zvXr13XixIlsxzz66KNavHixQ/2dh+PKmwPOAQAAAADIoTSlqf/Cfoq7FmfvUgAAAAAAwD0gICBAv//+u/7++2/169fPqiP+ChcurJYtW+qXX35RRESEBg4caFXA7F7RuXNn7dy5U02bNs1yTPny5TVz5kwtX75c7u7uVs9tNBq1evVqLVq0SLVr1870uMZbqlWrplmzZmn79u35Fq67xcXFRZ9//rmOHDmi119/XSVKlLjjPQEBAXr99de1evXqLMOC9tKgQQMdO3ZMw4YNy/bYTzc3N7Vt21Z///13noXrbilcuLB++ukn7d27V126dJGnp+cd73n00Uc1YMAAbd26NcORpvnFYDAoJCRER44c0ccff6ynnnpKJUuWlIuLi4xGowIDAzVkyBAdPXrUHOpKH9TNj4CdlD/ve82aNRUWFqYuXbpkucOkp6enRo4cqe3bt6tUqVI5mj8rX3/9tRYuXKjKlStnOebpp5/W5s2bNWrUqGzn8vT01N9//61Ro0Zlegx0Zh5//HF988032r9/vypVqpTT8vGAMpgcYS9OOLRDhw6pWrVq5vbBgwdVtWpVO1YEALhXfNJupI5sPaRHnq6qoaGj7V0OkC9a9Gopg8Egk8mkP35Yae9ygHzTf2E/89fftP/2ru+9Zcmny/Th7FfZwQ554sLpGPWs9qlOnjypgICAXM31xMQO5q/3vb8gl5UBAAAAD5bMdtd6+OGH8/z4Pdzfjh8/roMHDyo8PFyXL1+WyWSSp6envL29VaVKFVWtWjXPjyp1FGfPntWWLVt05swZpaSkyM/PT9WqVVNgYKBN5r9w4YK2bt2qyMhIxcbGysPDQyVLllSdOnXsskNZVkwmkw4dOqRDhw4pOjpacXFxKliwoIxGo8qVK6cqVapkG2ByNHv37tWhQ4cUFRWl5ORk+fj4qEyZMqpfv74KFSpkl5rS0tK0Z88eHT16VNHR0UpISFChQoXk6empChUqqEqVKvLx8bFLbbn13nvvWRwju2HDBjVo0CDf68jr9z0uLk4bNmxQeHi44uPjZTQaVbVqVatDa1m5PYjboEED8/HNtxw4cEC7d+9WZGSkXF1d5efnp7p166pcuXJ3tV5ycrIOHz6sY8eO6fz587py5YoMBoM8PDwUEBCg6tWr2ywoeK/Jq393PSiZIv51CgAAAADIlXGrLEPUmQXmcurFwS/oZMQVAnbIE+En4tXuneaav3OW3Pa72bscAAAAAIANVahQQRUqVLB3GQ6hdOnS6tSpU57NX7JkSbVr1y7P5rcVg8GgatWqWQRA7mXVq1dX9erV7V2GBScnJwUGBtosvOlI/vzzT/PXTk5Oqlmzpl3qyOv33dPTU23bts2z+bPy2GOP6bHHHrPZfAULFlSNGjVUo0YNm80JSATsAAAAAAC5dC3lms3nNBgMirucqmvXrsnNjQAUbOvqlRSVquSrs7Gn7V0KAAAAAAAAHNTmzZu1d+9ec/uxxx5T0aJF7VcQALshYAcAAAAAyJVihXwUdy3OpnOaTCb5+7kRrkOecC/ioiO7z6hOnTq5/oxtSgizUVUAAAAAAADIKyaTyeK40jtJSEhQ7969Lfp69uxp67IA3CMI2AEAAAAAcmVAo0EWx8J+0/7bHN2f2ZGyk7t9r5m7h+S6NiAzZcob9WHrVfri5PcKCAjI1VwzJ3awTVEAAAAAAADIM6dPn1ZQUJCGDh2qpk2bytnZOcuxe/fuVbdu3XTkyBFzX7FixdS9e/f8KBWAAyJgBwAAAABwGE5y0sBa72nSte/sXQoAAAAAAACA+8imTZu0adMmlSxZUi1atFCtWrVUqlQpFSpUSPHx8Tp+/Lj+/PNPrVu3LsO933//vTw9PfO/aAAOgYAdAAAAAMAhFHX10NgXP9WpU6fsXQoAAAAAAACAfHD+/HkdOnTI5vPWqlVLXl5emV67cOGC5syZozlz5txxHoPBoPHjx6tDB04xAB5kBOwAAAAAAHZX2aey3nj2bXuXAQAAAAAAACAfrVq1Sj169LD5vOvXr1fDhg3NbTc3NxUrVkyXLl2yeo7KlStrwoQJatWqlc3rA3BvIWAHAAAAALCrjtVfUf0K9TP0R0fE26EaPAj4bAEAAAAAADxYfH19FRkZqY0bN2rDhg0KCwvT8ePHdeHCBSUmJsrFxUXe3t7y8/NTvXr11LRpUz3//PNycnKyd+kAHAABOwAAAACAXaUP13l4eMjTy6iQ5t/ZqSI8CDy9jPLw8LB3GQAAAAAAAMgnLi4uaty4sRo3bmzvUh4YJpPJ3iUANkHADgAAAADgULy9vXX82AklJCTYuxTcxzw8POTt7W3vMgAAAAAAAB5owcHBCg4OtncZAJAtAnYAAAAAAIfj7e1N+AkAAAAAAAAAANgdh0UDAAAAAAAAAAAAAAAAAJAJdrADAAAAADicmJgYjohFnuKIWAAAAAAAAACANQjYAQAAAADs6kJcpEp6+prbMTExqlCxvOJi4+1YFe53nl5GHT92gpAdAAAAAAAAACBbBOwAAAAAAHY19s/R6lj9FdWvUF+SlJCQoLjYeE1Y9YaKlzLauTrcj6Ij4hXS/DslJCQQsAMAAAAAAAAAZIuAHQAAAADA7n7dO0//RB5Q73pvmPuKlzKqpD/hJwAAAAAAAAAAYD9O9i4AAAAAAABJOhB5QCOWDbV3GQAAAAAAAAAAAGYE7AAAAAAADiMhOV5fhk20dxkAAAAAAAAAAACSOCIWAAAAAJBLc3bMtGj3X9gvV/OZZNJbv/XVtWvXcjUPAAAAAAAAAABAbhGwAwAAAADkyvHoYzaf02Aw6J9TySrpf01ubm42nx8PtvAT8Wr3TnPN3zlLbvv5fAEAAAAAAAAAskbADgAAAADgcEwmk1xdDITrkCeuXklRqUq+Oht72t6lAAAAAAAAAAAcHAE7AAAAAECuDGs8UiHL3zG3R78wLkf3j1w+LEPf4fX/qGu/urmuDciMexEXHdl9RnXq1Ml1iHNTQpiNqgIAAAAAAAAAOCICdgAAAACAXEkfUPJ088zVfC38n9ekb78jYIc8U6a8UR+2XqUvTn6vgICAXM01c2IH2xQFAAAAAAAAAHBIBOwAAAAAAA5j9AvjFBcZZ+8yAAAAAAAAAAAAJBGwAwAAAAA4AIMM+rr9FElSnOLsWwwAAAAAAAAAAMD/R8AOAAAAAGBXRV09NPbFTzP0R0fE26EaPAj4bAEAAAAAAAAArEXADgAAAABgV+nDdR4eHvL0Miqk+Xd2qggPAk8vozw8POxdBgAAAAAAAADAwRGwAwAAAAA4FG9vbx0/dkIJCQn2LgX3MQ8PD3l7e9u7DAAAAAAAAACAgyNgBwAAAABwON7e3oSfAAAAAAAAAACA3TnZuwAAAAAAAAAAAAAAAAAAABwRATsAAAAAAAAAAAAAAJApg8Fg/tOwYUN7l/NAGDVqlMVz37Bhg13qOHXqlEUdwcHBdqkDAOyNI2IBAAAAAA4nJiZGCQkJ9i4D9zEPDw+OIQYAAACA+9DJkyd18OBBhYeHKyEhQWlpafLy8pKXl5cqV66satWqydnZ+a7mjoiI0IEDB3Tq1CnFxcXJ2dlZXl5eCggIUJ06dVS0aFEbvxoAAOAICNgBAAAAAOxqwMI39XX7KeZ2TEyMKlQsr7jYeDtWhfudp5dRx4+dIGQHAAAAAPeBAwcOaNq0aQoNDVVERES2YwsVKqR69eqpa9euat++vQoXLpzl2MTERC1btkwrV67Un3/+qbNnz2Y51tnZWQ0aNNCAAQPUunXru34tAADA8RCwAwAAAADYlUkm9V/YT8Mbj1RJT18lJCQoLjZeE1a9oeKljPYuD/eh6Ih4hTT/TgkJCQTsAAAAgPtI05XsHmYra1petncJVjlz5owGDRqkRYsWWX1PUlKS1qxZozVr1ujtt9/WkCFDNGjQILm5uVmM++STTzR27FglJiZaNW9qaqrWrVundevWqUWLFpo1a5Z8fX1z9HrgGAwGg/nrBg0a2O141ntRcHCw5syZY26fPHlSAQEB9isIAGyEgB0AAAAAwCGM/XO0utToKj+nhyRJxUsZVdKf8BMAAAAAAMho2bJl6tq1q+LjM98B38vLSz4+PjIajYqOjtaFCxeUlJRkMSYhIUHDhg3TokWLtGvXLotrYWFhmYbrDAaDfH19VbJkSRkMBoWHhys6OtpizB9//KH69etr8+bN8vPzy+UrBQAA9kbADgAAAADgMP7391yV96ho7zIAAAAAAIAD+/nnnxUUFKTU1FSL/lq1aqlXr156/vnn5e/vn+G+I0eOaPHixfr1118VFhZm7r948WK267m7u+vll19WmzZt1KBBAxUrVsx8zWQyKSwsTGPGjNGSJUvM/cePH1ebNm20fft2OTk53e1LxQNq1KhRGjVqlL3LUEBAgEwmk73LAAC7I2AHAAAAAMiV/Wf3WrTfDR2Qq/lOJBxTt8mv5GoOAAAAAABwf9q9e7d69uxpEa4zGo2aPHmyXn31VYvjPdN75JFHFBISopCQEIWGhmro0KE6cuRIluN9fHw0ZMgQ9erVS0ajMdMxBoNBgYGBWrx4scaOHasRI0aYr+3atUtz5sxRjx497uKVAgAAR0HADgAAAACQKwv2/WrRvpF2I9dzGkt66O9/49WCI2KRB8JPxKvdO801f+csue13s3c5AAAAAAArJSQkqFOnTrp+/bq5r0SJElq1apWqV6+eo7natWunF154Qf369dPatWszXO/Tp49mz56tIkWKWD3n8OHDFRYWptDQUHPfjBkzCNgBAHCPI2AHAAAAAHA4t37b/Nq1a3JzIwAF27p6JUWlKvnqbOxpe5cCAAAAAMiBUaNG6cSJE+a2k5OTfv/99xyH625xdXXVjBkztGjRogzXmjZteldzDh061CJgt337diUkJMjDw+Ou5gMAAPZHwA4AAAAAkCu1/Z/S6iN/2HTOlOspevLxYoTrkCfci7joyO4zqlOnTq4/Y5sSwmxUFQAAAAAgO3FxcZo+fbpF38CBA1W3bt1cz/3SSy/leo5bAgMD5e7urqtXr0qS0tLSdPbsWVWpUsVma9xJUlKStmzZooiICEVFRcnZ2VklSpRQlSpVVLNmzWyP0c0r169f1/bt23Xq1CldvHhRaWlp8vHx0cMPP6ynnnpKzs7ONlknLi5O27Zt0/nz5xUdHa20tDR5enqqQoUKeuKJJ1SiRAmbrJMbV65c0ZYtW3Tu3DlFRkbKzc1NDRo0UM2aNW2+1oULF7Rjxw5FRUUpOjpaTk5O8vT0VKVKlVS9enV5enrafE0AuB8RsAMAAAAA5Eqraq0tAnbftP82R/f3X9jPol3Epag+6TBBTx4cYpP6gPTKlDfqw9ar9MXJ7xUQEJCruWZO7GCbogAAAAAA2Zo6daquXLlibru6umro0KF2rChzBoNBRqPRHLCTpPj4+HxZe8uWLRo7dqzWrVun5OTkTMeUKFFCffr00fvvv6+iRYvmeU0HDx7U6NGjtXLlSov373aenp7q2rWrPvjgg7sKwKWlpWn+/Pn65ptvtGvXLqWmpmY6zmAwqEaNGnr11VfVo0cPeXl5ma81bNhQGzduzHDPxo0bsw0kfvjhhxo1apRFX/q5TCaTJOnw4cP6+OOPtXjxYiUlJVncM2DAAIuA3ahRo/TRRx+Z2+vXr1fDhg2zrON2169f14wZMzR16lQdOHDAvH56zs7OeuqppxQcHKxXXnlFhQoVyjDm1KlTKleunLkdFBSk2bNnW4yZPXt2lscg335vev7+/jp16pQkqUWLFlq1apX52pYtW/T0009neW9mbty4odKlSysqKkqS5ObmpnPnzlm8zwBwt5zsXQAAAAAAALdUf6i6Xn/iDXuXAQAAAAAAHEz6Y1zbtWun4sWL26marN24cUMXL1606CtWrNgd7wsODpbBYDD/CQ4OtnrNxMREdezYUfXr19fKlSuzDNdJUlRUlMaMGaNKlSpp165dVq+RUykpKXr77bf1xBNP6LfffssyXCfd3HVu8uTJqlixopYvX56jdf79919Vr15dr7zyirZv355luE66GXTbs2eP3n33XX399dc5Wie3fv75Z9WoUUP/+9//MoTrbGnbtm2qVKmS3nzzTe3fvz/LcJ0kpaamasuWLerdu7d+/fXXPKvJGn369LFoz5gxI8dzLFmyxByuk6QOHToQrgNgMwTsAAAAAAAOoUuNrupZ93V7lwEAAAAAABxMYmKi9uzZY9HXpk0bO1WTva1bt1qEvAoWLKiyZcvm2XpRUVFq0KCBfvvttwzXSpcurVq1aql69eoZgkaRkZFq2LCh/vrrL5vXlJSUpFatWmny5MlKS0uzuObr66vq1aurZs2aGXaru3z5stq0aZPpa8nM+vXrVbduXR04cCDDNR8fHz3++OMKDAxU+fLl5eRkv2jEihUr1L17d12/fl2S5OTkpAoVKujJJ5+Uv7+/zY7H/eWXX9SoUSOdPn06wzU/Pz/VqFFDNWvWzNPP49168cUX9dBDD5nbv/76qxISEnI0R/ojpHv37m2T2gBA4ohYAAAAAIADGN54pEp6+lr0RUfkz/EpePDw2QIAAACAe8v27duVkpJi0RcYGGinarI3c+ZMi/Zzzz0nNze3PFkrLS1NnTt3VlhYmLnPx8dHISEh6tq1q3x9fS3Gbtu2TSNHjtS6desk3QzCdenSRXv37rVqlz1rvfHGGxbHfRYpUkSDBg1Sjx49MhwZum/fPn388cdasGCBpJu7qvXq1Us1atRQxYoVs1zj1KlTat++veLi4sx9BQsW1FtvvaWePXuqSpUqFuOvXLmibdu2acGCBZo3b16G+T7//HPFxsZKkpo2bWruf/zxx/X5559nWUf58uWzvHZLz549lZaWJqPRqJEjR6p79+4Wuy9euHAh01BcTuzatUtBQUHmEJ8keXh46P3331fXrl0VEBBgMT42NlabNm3Sr7/+an72d6t58+Zas2aNJGnixIlavXq1+drcuXNVsmTJTO9zd3c3f+3i4qJevXppzJgxkm6GaufNm6e+fftaVcPp06fNNUjSI488omeffTbHrwUAskLADgAAAABgV9+0/9ai7eHhIU8vo0Kaf2enivAg8PQyysPDw95lAAAAAACs8O+//1q0ixQpkm34yl7279+vn3/+2aIvJ0e95tTEiRO1fv16c7tOnTpasmRJhp3hpJu7ptWrV09r1qzRgAEDNHnyZEnS2bNnNXr0aJsdmTp//nz9+OOP5naFChW0atUqVahQIdPxt46QnThxokJCQiTd3Mnu3Xff1eLFi7Nc55VXXjEH4iTpoYce0h9//KHHHnss0/FFihRR06ZN1bRpU33yySc6c+aMxfVatWplep+Xl5eaNGmSZR3WuHDhgnx9fbV+/Xo9+uijGa6XLFkyyxCaNZKTk9WxY0eLcF2VKlX0xx9/qEyZMpne4+XlpTZt2qhNmzaaMGFCtkf43omfn5/8/Pwk3QzU3a5evXoZwn1Z6d27t8aNG2feAXL69OlWB+xmzpxpsVvia6+9ZtV9AGAtAnYAAAAAAIfi7e2t48dO5PgYCCAnPDw85O3tbe8yAAAAAABWiImJsWj7+PjIYDDYqZrMJScnKzg42OJ42Jo1a6pDhw55sl5SUpImTJhgbvv5+WnFihV3/G9dJycnffXVV9q9e7e2b98u6WY46aOPPpKnp2euajKZTBo1apS5XahQoWzDdbd7//33tWvXLvPxsEuXLtXRo0dVqVKlDGNXr16tbdu2mdsFCxbMNlyXnre3d77/TGD27NmZhutsYc6cOTp16pS5XaxYMa1du9YceruTUqVK5UldOVWmTBm1bNlSy5YtkyTt2bNHe/bsUc2aNbO9LzU11WLnSFdXVwUFBeVprQAePATsAAAAAAAOxx4/6AQAAAAAAI4pfcAut0GwvNC/f3/9/fff5raLi4umT58uJycnq+6fPXu2Zs+ebfV6P/74o8VzGTVqlNU/S3F2dtbQoUPVpk0bSTePT121apU6depk9fqZWbVqlcVugwMGDLAqXHfLiBEjzAE7k8mk0NBQDR48OMO4r776yqIdEhJidbjOHurXr6/mzZvn2fzpn8eECROsDtc5mr59+5oDdtLNXey++y77Uy7++OMPnT171txu06aNfHx88qxGAA8m6/7XHAAAAAAAAAAAAAAAO7h8+bJFu3DhwnaqJHOTJk3StGnTLPo+/vjjO+68lRsrVqwwf+3i4qLOnTvn6P7GjRtbhP82b95s05okqVu3bjm6//HHH5evr2+2Nd24cUMbNmwwt11cXNSvX7+cFZrPunTpkmdznz17Vv/884+5XaxYMb366qt5tl5ea9mypcqWLWtuz5s3T0lJSdneM2PGDIt2796986Q2AA82AnYAAAAAAAAAAAAAAIdVtGhRi3ZiYqKdKskoNDRUAwcOtOjr1KmTQkJC8mxNk8mkLVu2mNuVKlWSh4dHjuYoXLiwihUrZm7fHtK6W7cH4goXLnxXR6KWKVMm25p2796tq1evmts1atSwCOU5otq1a+fZ3OlDiM8995wKFiyYZ+vlNScnJ4uAXEJCgubPn5/l+MjISIsd78qVK6cmTZrkaY0AHkwcEQsAAAAAcDgxMTFKSEiwdxm4j3l4eHAMMQAAAADcI9L/91t8fLydKrG0YcMGdenSRWlpaea+Zs2a6ccff5TBYMizdS9cuGBxPOzhw4dzvV76Y3jvxu2BuMTERKuPx81KZjUdP37coh0YGJirNfJDuXLl8mzue/F53EmvXr300UcfKSUlRdLNY2J79OiR6dhZs2aZx926Ny//7gF4cBGwAwAAAADY1dTNU9TnmTfN7ZiYGFWoWF5xsY7xw3Lcnzy9jDp+7AQhOwAAAAC4B6T/b7eLFy/aqZL/s3v3brVu3VrJycnmvrp162rRokVydXXN07UvXbpk8zlzG1pMTEy0eBa2kFlN6UN3JUqUsOmaeSGnuwvmxL34PO7Ez89PrVu31qJFiyRJ27Zt0+HDh1WlShWLcSaTST/88IO57ezsnGUQDwByi4AdAAAAAMCuDkUd0rClgzXuxfGSbh79EBcbrwmr3lDxUkY7V4f7UXREvEKaf6eEhAQCdgAAAABwD0h/1Ojly5d17NgxVaxY0S71HDp0SC1atNDly5fNfU888YRWrFihwoUL5/n6cXFxNp/z9l347kZe1GQymTL03f7MJalIkSI2X9fWChQokGdz34vPwxp9+/Y1B+ykm7vYffnllxZj1q9fb7GD3wsvvKCHHnoo32oE8GAhYAcAAAAAsLsr1y9r4MK39FX7yea+4qWMKulP+AkAAAAAgAfdU089JRcXF4ujIHfv3m2XgN3x48fVtGlTi13kKlWqpNWrV8vT0zNfaihUqJBFu0qVKvr6669zNae7u3uu7k9fk7e3t+bPn5+rOTNTtGhRi/aVK1dsvsa95H59Hk2aNFGFChXMAbqffvpJn376qQoWLGgeM336dIt7evfuna81AniwELADAAAAADiENKWp/8J+6ln1dXuXAgAAAAAAHEjhwoVVs2ZN7dy509y3ZMkSde7cOV/rCA8PV+PGjXX+/HlzX9myZbV27dp8PZqzePHiFm2TyaQmTZrk2/qZ8fT0tAhBXr16NU9qSr8TfVRUlM3XuJfcr8/DYDDo9ddf1+DBgyXdPBZ50aJF6tKli7kdGhpqHl+6dGm1bNnSLrUCeDA42bsAAAAAAABuN/PQNPkHlrF3GQAAAAAAwIG0a9fOor1o0SKLXeTyWlRUlJo0aaLTp0+b+3x9ffXnn3+qTJn8/TmGr6+vxY5zp0+f1o0bN/K1hvQMBoP8/f3N7atXr+rcuXM2X+fhhx+2aO/evdvma9xL7ufn0aNHD7m6uprbt+9Y99NPPyk5Odnc7tmzp5ydnfO1PgAPFnawAwAAAADkyrhVoy3a/Rf2y/WcLw5+QScjrnBELPJE+Il4tXunuebvnCW3/W72LgcAAAAAYIU+ffpo7Nix5iMwk5OTNX78eE2YMCHP146NjVXTpk119OhRc5+3t7fWrFljl2NqCxQooHr16mnt2rWSpKSkJO3YsUP169fP91pu16hRI/ORnpK0bt06de3a1aZr1KxZU4UKFVJSUpIk6e+//1ZkZKR8fX1ttobBYJDJZJIk8/91VM8884xFe926dUpOTrY4SjU/OTlZ7vGUm+fn4+Ojl156Sb/88oskacOGDTp27JgqVqyoGTNmWKzZs2fPu14HAKzBDnYAAAAAgFy5lnLN5nMaDAbFXU7VtWu2nxu4eiVFpSr56mzsaR07fyRXfwAAAAAA+cPLy0u9evWy6Pviiy+0Y8eOXM+9YsWKLK9duXJFLVu21P79+819Hh4eWrVqlapVq5brte9WixYtLNqTJk2yUyX/J31NkydPtvkaBQoUUOPGjc3tlJQUffvttzZdo3DhwuavbwX5HNVDDz2kxx57zNy+dOmSfv75Z7vVc/uzk3L//Pr06WP+2mQyacaMGdq2bZsOHTpk7m/WrJnF7okAkBcI2AEAAAAAcqVYIR+bz2kymVTWt6Dc3NhdDLbnXsRFEUcjVdrLXxX9HsnVHwAAAABA/hk1apQCAgLM7dTUVLVt21YHDhy4q/lu3Lih9957T2+++Wam169du6bWrVtbhPjc3d21bNkyBQYG3tWatvLaa6/J09PT3F6wYIGWL19uv4IktW3b1mJHvx07dui7776z+ToDBgywaE+YMOGuPwOZ8fb+vxMVTp06ZbN580r65xESEqLz58/bpZbbn50knTx5MlfzNWzYUI8++qi5PXv27AyByt69e+dqDQCwBkfEAgAAAAByZUCjQRbHwn7TPme/NZzZkbKTu32vmbuH5Lo2IDNlyhv1YetV+uLk9xb/j5m7MXNiB9sUBQAAAAC4I09PT82fP1/169fXjRs3JEmRkZFq0KCBpkyZos6dO8tgMFg118aNG9W/f3/t378/092vUlJS9PLLL2v9+vXmPldXV4WGhmY4ltMWgoODNWfOHHM7KChIs2fPznK80WjU4MGDNXToUElSWlqaunTporlz56p169ZWrxsWFqYJEyZo/vz5d137Lc7OzhozZoy6dOli7hswYIBcXFxyFII6evSoPvvsM3344YcqVapUhuuNGzfWM888o82bN0u6eVxwixYt9Mcff1js5paVmJgYnTlzRtWrV8/0etWqVXXmzBlJUnR0tDZs2KCGDRtaXX9+69atmz755BPz8byXLl1SkyZNtGrVKpUuXfqO90dEROjKlSt65JHc/yJh1apVLdoLFixQq1atcjVnnz59NGjQIEnShQsXNHfuXPO1kiVL6sUXX8zV/ABgDQJ2AAAAAACH4SQnDaz1niZds/1vNwMAAAAAgHtf7dq1NX36dPXs2VNpaWmSpNjYWL3yyiv68ssv1atXL7Vs2VJly5bNcO9///2npUuXasGCBdq2bVu26/Tu3VvLli3L0Ofs7Ky1a9fmqOaqVavKz88vR/dYIyQkRJs3bzYfcXv58mW1bdtWbdu21VtvvaV69eqpYMGCFvdcu3ZN+/fv19q1a7Vw4ULt2bNHkmwSsJOkzp07a8OGDZo6daqkm7sEvv766/rll180aNAgNWrUKMMxojdu3NDhw4e1fv16LVy4UFu2bJHJZNKwYcOyXGfu3LmqUaOGYmJiJEnnzp1T7dq19dZbb6lXr14Wu55JUmJiorZu3arffvtN//vf//Tuu+9mGbBr1qyZVq5caW63a9dOffr0Ua1atWQ0GuXk9H8HBZYvX17ly5fP0TOyNVdXV82fP1/16tVTcnKyJOnw4cOqVq2a3n//fXXt2jVDiDQuLk4bN27U/PnztXDhQk2dOtUmAbuGDRuqQIEC5gDsnDlzlJCQoFatWsnPz08FChQwj3V3d1e9evXuOGdQUJCGDh2qa9euZbgWHBxsMScA5BUCdgAAAAAAh1DU1UNjX/z0njh6AwAAAAAA2E9QUJCMRqOCgoKUkJBg7t+1a5d27dol6eZRlT4+PjIajbp06ZLOnz+vpKSkTOfLLPx2+851t0yZMkVTpkzJcb2zZs1ScHBwju+7EycnJ82bN09t27bVhg0bJEkmk0mhoaEKDQ1VwYIF5e/vLy8vL127dk1xcXE6e/asUlNTbV7L7SZNmqTY2Fj9+uuv5r5169Zp3bp1cnFxkb+/v7y9vZWSkqK4uDhFRETo+vXrOVqjbNmyWrRokdq2bau4uDhJN8ODn332mT777DOVKFFCfn5+cnV11aVLl3Tq1ClzIPNOunfvrrFjxyo6OlrSzTDa+PHjMx374YcfatSoUTmqPS/UqlVLP/74o7p3724O2cXHx2vEiBEaMWKESpUqpZIlS8pgMOjixYsKDw+XyWSyeR0lSpRQt27dNHPmTHPfrc9jev7+/lb9HNDLy0sdO3bUjz/+aNFvMBj02muv5bpmALCG052HAAAAAACQtyr7VNbYFz+1dxkAAAAAAOAe0bZtW+3bt09t2rTJ9HpMTIyOHDminTt36vjx45mG64oVK6Yvv/xSmzZtyuty84zRaNSaNWv0zjvvyMXFcn+d5ORkHT16VDt27NC+fft0+vTpTMN1ZcqUsWlNBQoU0Pz58zV+/Hi5u7tbXEtJSdHx48e1a9cu/f333zp58mSm4brixYtnuDe9Bg0aaMuWLapcuXKGa1FRUdq3b5927dqlEydOWB2uk26GMxcuXKgSJUpYfY8j6Nixo9auXZvpsbARERHas2ePwsLCdObMmTwJ193y1VdfqWnTpjads0+fPhn6GjZsqIoVK9p0HQDICjvYAQAAAADsqmP1V1S/Qv0M/dER8XaoBg8CPlsAAADA/WlNy8v2LgH5LCAgQL///rv27t2r6dOna9GiRYqMjMz2nsKFC+vZZ59VUFCQ2rZtm+EI1XuRi4uLPv/8c7355psaP368fv/9d0VFRWV7T0BAgJo1a6YOHTqocePGeVJXSEiIgoKC9Nlnn+nXX3/VmTNnsh3v6+urJk2a6KWXXlKrVq2sOvqzSpUqOnDggObMmaPJkydr7969WYbHnJ2dVadOHb366qvq1q1btvM+++yz+vfffzVv3jytWrVKBw8eVHR0tBITE3MU1stv9evX13///advv/1W06ZN05EjR7Ic6+rqav678PLLL9ushqJFi2rVqlVavXq1fv31V+3Zs0dnzpzR5cuXzUfH5tTTTz+tRx55xOL19O7d21YlA8AdGUx5GU3GfeHQoUOqVq2auX3w4EFVrVrVjhUBAO4Vn7QbqSNbD+mRp6tqaOhoe5cD5IsWvVrKYDDIZDLpjx9W2rscIN/0X9jP/PU37b/N1VwxMTGqULG84mIJQSHveHoZdfzYCXl7e+dqnicmdjB/ve/9BbktCwAAAHigpKSk6L///rPoe/jhhzPswgXkxPHjx3Xw4EGFh4fr8uXLMplM8vT0lLe3t6pUqaKqVavK2dnZ3mXmKZPJpEOHDunQoUOKjo5WXFycChYsKKPRqHLlyqlKlSp66KGH8r2uY8eOae/evbp48aJiY2Pl4uIio9GosmXLqnLlygoICMj1GhcuXNC2bdt04cIFXbp0SS4uLvLy8tLDDz+s6tWry9PTM9dr3EtOnz6tXbt2KSoqSrGxsSpYsKC8vb31yCOPqHr16ipcuLC9S7TK5cuX5efnp8TEREk3d5+MiIi4LwKyQH7Jq393PSiZIv51CgAAAABwKN7e3jp+7IQSEhLsXQruYx4eHrkO1wEAAAAAHE+FChVUoUIFe5dhVwaDQdWqVbMIPDiCihUr5vmRniVLllTbtm3zdI17ib+/v/z9/e1dRq7973//M4frJKlbt26E6wDkKwJ2AAAAAACH4+3tTfgJAAAAAAAAgKZOnWrRfv311+1UCYAHlZO9CwAAAAAAAAAAAAAAAADSW7t2rfbs2WNuP/fcc6pcubIdKwLwIGIHOwAAAACAw4mJieGIWOQpjogFAAAAAABwbImJiRo4cKBF3zvvvGOfYgA80AjYAQAAAADs6kJcpEp6+prbMTExqlCxvOJi4+1YFe53nl5GHT92gpAdAAAAAACAg9iyZYuuXr2q5ORkHT16VFOmTNHx48fN1+vUqaMXXnjBjhUCeFARsAMAAAAA2NXYP0erY/VXVL9CfUlSQkKC4mLjNWHVGypeymjn6nA/io6IV0jz75SQkEDADgAAAAAAwEG8+uqrOn36dKbXChQooO+//z6fKwKAmwjYAQAAAADs7te98/RP5AH1rveGua94KaNK+hN+AgAAAAAAAB5kBQoU0MyZM1W9enV7lwLgAeVk7wIAAAAAAJCkA5EHNGLZUHuXAQAAAAAAAMDOXF1dFRAQoB49eigsLExdu3a1d0kAHmDsYAcAAAAAcBgJyfH6MmyivcsAAAAAAAAAkM9OnTpl7xIAIFME7AAAAAAAuTJnx0yLdv+F/XI1n0kmvfVbX127di1X8wAAAAAAAAAAAOQWATsAAAAAQK4cjz5m8zkNBoP+OZWskv7X5ObmZvP58WALPxGvdu801/yds+S2n88XAAAAAAAAACBrBOwAAAAAAA7HZDLJ1cVAuA554uqVFJWq5KuzsaftXQoAAAAAAAAAwMERsAMAAAAA5MqwxiMVsvwdc3v0C+NydP/I5cMy9B1e/4+69qub69qAzLgXcdGR3WdUp06dXIc4NyWE2agqAAAAAAAAAIAjImAHAAAAAMiV9AElTzfPXM3Xwv95Tfr2OwJ2yDNlyhv1YetV+uLk9woICMjVXDMndrBNUQAAAAAAAAAAh0TADgAAAADgMEa/ME5xkXH2LgMAAAAAAAAAAEASATsAAAAAgAMwyKCv20+RJMUpzr7FAAAAAAAAAAAA/H8E7AAAAAAAdlXU1UNjX/w0Q390RLwdqsGDgM8WAAAAAAAAAMBaBOwAAAAAAHaVPlzn4eEhTy+jQpp/Z6eK8CDw9DLKw8PD3mUAAAAAAAAAABwcATsAAAAAgEPx9vbW8WMnlJCQYO9ScB/z8PCQt7e3vcsAAAAAAAAAADg4AnYAAAAAAIfj7e1N+AkAAAAAAAAAANidk70LAAAAAAAAAAAAAAAAAADAERGwAwAAAAAAAAAAAAAAAAAgExwRCwAAAABwODExMUpISLB3GbiPeXh4cAwxAAAAAAAAAOCOCNgBAAAAAOxqwMI39XX7KeZ2TEyMKlQsr7jYeDtWhfudp5dRx4+dIGQHAAAAAAAAAMgWATsAAAAAgF2ZZFL/hf00vPFIlfT0VUJCguJi4zVh1RsqXspo7/JwH4qOiFdI8++UkJBAwA4AAAAAAAAAkC0CdgAAAAAAhzD2z9HqUqOr/JwekiQVL2VUSX/CTwAAAAAAAAAAwH4I2AEAAAAAHMb//p6r8h4V7V0GAAAAAAAAAACAJAJ2AAAAAIBc2n92r0X73dABuZrvRMIxdZv8Sq7mAAAAAAAAAAAAsAUCdgAAAACAXFmw71eL9o20G7me01jSQ3//G68WHBGLPBB+Il7t3mmu+TtnyW2/m73LAQAAAAAA+WjDhg1q1KiRuf3hhx9q1KhR9isIWTIYDOavGzRooA0bNtivGAAPNAJ2AAAAAACHc+uHZ9euXZObGwEo2NbVKykqVclXZ2NP27sUAAAAAICNnTx5UgcPHlR4eLgSEhKUlpYmLy8veXl5qXLlyqpWrZqcnZ3vau6IiAgdOHBAp06dUlxcnJydneXl5aWAgADVqVNHRYsWtfGrAQAAjoCAHQAAAAAgV2r7P6XVR/6w6Zwp11P05OPFCNchT7gXcdGR3WdUp06dXH/GNiWE2agqAAAAAMDdOnDggKZNm6bQ0FBFRERkO7ZQoUKqV6+eunbtqvbt26tw4cJZjk1MTNSyZcu0cuVK/fnnnzp79myWY52dndWgQQMNGDBArVu3vuvXAgAAHA8BOwAAAABArrSq1toiYPdN+29zdH//hf0s2kVciuqTDhP05MEhNqkPSK9MeaM+bL1KX5z8XgEBAbmaa+bEDrYpCgAAAACQY2fOnNGgQYO0aNEiq+9JSkrSmjVrtGbNGr399tsaMmSIBg0alOEXsD755BONHTtWiYmJVs2bmpqqdevWad26dWrRooVmzZolX1/fHL0eAADgmAjYAQAAAAAcRvWHqus5v2b6RBPsXQoAAAAA4B6zYthwe5dw33h+3Fh7l3BHy5YtU9euXRUfH5/pdS8vL/n4+MhoNCo6OloXLlxQUlKSxZiEhAQNGzZMixYt0q5duyyuhYWFZRquMxgM8vX1VcmSJWUwGBQeHq7o6GiLMX/88Yfq16+vzZs3y8/PL5evFAAA2BsBOwAAAACAQ+hSo6vqln9ap06dsncpAAAAAADAgf38888KCgpSamqqRX+tWrXUq1cvPf/88/L3989w35EjR7R48WL9+uuvCgsLM/dfvHgx2/Xc3d318ssvq02bNmrQoIGKFStmvmYymRQWFqYxY8ZoyZIl5v7jx4+rTZs22r59u5ycnO72pSIPNGzYUCaTyd5lwAq8TwAcBQE7AAAAAIDdDW88UiU9LY9NiY7I/DfQgdziswUAAAAA967du3erZ8+eFuE6o9GoyZMn69VXX5XBYMjy3kceeUQhISEKCQlRaGiohg4dqiNHjmQ53sfHR0OGDFGvXr1kNBozHWMwGBQYGKjFixdr7NixGjFihPnarl27NGfOHPXo0eMuXikAAHAUBOwAAAAAAHb1TftvLdoeHh7y9DIqpPl3dqoIDwJPL6M8PDzsXQYAAAAAIAcSEhLUqVMnXb9+3dxXokQJrVq1StWrV8/RXO3atdMLL7ygfv36ae3atRmu9+nTR7Nnz1aRIkWsnnP48OEKCwtTaGiouW/GjBkE7AAAuMcRsAMAAAAAOMTWN0sAAQAASURBVBRvb28dP3ZCCQkJ9i4F9zEPDw95e3vbuwwAAAAAQA6MGjVKJ06cMLednJz0+++/5zhcd4urq6tmzJihRYsWZbjWtGnTu5pz6NChFgG77du3KyEhgV/yAgDgHkbADgAAAADgcLy9vQk/AQAAAAAAs7i4OE2fPt2ib+DAgapbt26u537ppZdyPcctgYGBcnd319WrVyVJaWlpOnv2rKpUqWKzNe4kKSlJW7ZsUUREhKKiouTs7KwSJUqoSpUqqlmzZrbH6N6NI0eOaMeOHTp37px5rdq1a6ty5cq5njsiIkJbtmzRuXPndPXqVfn4+Kh69eqqVauWzV/H3YqKitLmzZt18uRJ3bhxQ8WLF1eVKlX01FNPydnZOdfzp6amavfu3Tp27JiioqKUnJwsHx8flStXTvXq1VPBggVt8Cpu/h3bunWrzp8/r4sXL8rNzU0+Pj6qUaNGnnx+Dx48qH/++Ufnz5/XlStXVLJkSXXv3l0FChSw+VqSdPXqVW3atEn//vuvrlz5f+zdeZzNdf//8eeZfQyzMbbBjD1LkoRQKAzKTpamhtRl6QqVpiyVRFkqZV8qdJXrki1bdgaRLNkTZmOMffYZZsz2+8PP+TqzOWOWM8Pjfrtdt5v3+7yX12fOQdd4zvsdLzc3N3l7e6tVq1ZycnLK09opKSnau3evAgMDdfXqVTk4OKh69ep69tln+R4n8JAgYPf/JSUl6ciRIzp9+rSioqJ069YtOTs7q2zZsmrUqJFq1KiRL39Bp6Sk6M8//9TJkycVEREha2trVahQQU899ZTq1auXD08CAAAAAAAAAAAAAA+X+fPnKz4+3ti2s7PT6NGjLVhR1gwGg1xcXIwBO0mKiYkplL337t2rSZMmaceOHUpKSspyTNmyZTV48GC9//77KlWq1H3XDA0NVdWqVY1tPz8/LV68WJK0ZcsWjR07VocOHcpybp06dTRlyhR17tw5189y8OBBjRo1Snv27FF6enqm1729vTVu3DgNGjRIkjRgwAAtWbLE+HpISIi8vb2zXDsgIEBt2rQxtj/55BONHz8+21q8vb11/vx5SZKXl5dCQ0MlSWfPntWHH36oNWvWKC0tLdO80qVLa8yYMXr77bcfKDQWGhqqzz77TL/++qsiIyOzHFOiRAn16NFDEyZMMHmfcmPdunX68ssvtW/fPqWkpGQ5pkqVKho5cqSGDRtmVqAvu69xSkqK5s6dq/nz5+vUqVOZ5vXs2VOurq7G9r0ZjVatWikgICDbPbP7DMTExOjTTz/VggULlJCQkGmenZ2dBg0apAkTJqhMmTL3fbZ7JSUl6fPPP9ecOXN048aNTK9bW1urV69emjp1qqpUqZLj7ycARdsjH7A7fPiwpk+frhUrVmT7HxmS5OnpqUGDBmnEiBEPlDCOj4/X5MmTNXfu3Gz/8qtdu7Y++OADDRgwoMik7QEAAAAAAAAAAADA0jJe49q9e/dch2EKQ3Jysq5fv27SV7p06fvOyxgOyk3wJiEhQQMHDtTy5cvvO/batWv67LPPtHDhQq1du1ZPP/20WXtk5O/vr2nTpuU45vTp0+rSpYsmTJigjz76yOy1J0+erLFjx2YZWrsrNDRUb7zxhjZv3qyffvrJ7LXzy4oVK/Taa6+ZBCkzioiI0HvvvacdO3ZoxYoVcnBwMHv9iRMn6rPPPtPt27dzHHfz5k399NNP+uWXXzRnzhxj4NAc165dU58+fXIMrd114cIFvfvuu5o3b55+++03Va9e3ex97oqKilKXLl30+++/53rug/r777/VqVMnY0AyK7dv39bcuXO1ZcsWbdu2LdtgZkYXLlyQj4+P/vnnn2zHpKamatmyZdq0aZPWrFkjLy+v3D4CgCLikQ3YpaWlacyYMZo2bVqOfzHfFR4ergkTJmj+/PlavHixOnToYPZeJ06cUNeuXRUSEpLjuDNnzuj111/XsmXLtGzZMrm4uJi9BwAAAAA8TCIjIxUbG2vpMvAQc3Z25ooOAAAAACgmEhIS9Ndff5n0de3a1ULV5Gzfvn1KTU01tu3t7VWlSpUC2+/atWvq1KmTDh8+nOm1SpUqqVy5ckpNTdX58+cVFRVlfO3KlStq3bq1Nm/erJYtW+Zqzw8//NAkXFeqVClVqVJFjo6OOn/+fKaA4ccff6x69eqZdRXvtGnTsjyZ0NXVVV5eXkpPT9f58+eNpwIuX77c5MSzwrBhwwb17dvX+D7b2tqqatWqcnV11bVr14wn3N073t/fXzNmzLjv2qmpqRo0aJBJ2PKu0qVLy9PTU3Z2drp8+bLCw8ONr92+fVtvvPGGYmNj9c4779x3n3PnzsnHxydThsFgMMjLy0tlypRRUlKSQkJCTE6OPHv2rJ555hn9/vvvqlWr1n33uSslJSVTuM7NzU2VK1eWJJP3NL+EhoaqX79+unLlirHPy8tLZcuWVXx8vM6ePWvyezUoKEg9evTQgQMHZGOTc5TmypUratOmjYKDg036DQaDqlatqtKlSysiIkIhISFKT09XTEyMOnfurF9++SVfnxFA4XlkA3aDBw/Wd999l6m/RIkSql69uhwdHRUREaHg4GCTI2evXr2qrl276tdff1XHjh3vu8+ZM2f0/PPPZzoOtGTJkqpWrZpu3bql0NBQJScnG1/bvHmzOnbsqB07duQqxQ4AAAAAxdH8PbM1+Nm3jO3IyEhVr1FN0VGFc30KHk2ubi4KCgwmZAcAAAAAxcD+/fszXV3ZuHFjC1WTsx9++MGk/fzzzxfYv/mmpaWpb9++JuE6Dw8P+fv7y9fXV+XLlzcZ+8cff+jjjz/Wjh07JN05/axfv346evSoWafsSdLu3buNoaymTZvqs88+U5s2bYyBpPT0dO3atUtDhw41Odlr+PDh6tKlS47BpYMHD2YK19WvX19ffvml2rZtK2tra0l3Qmhbt27VqFGjdOrUKS1cuPCBr0fNrZiYGL366qtKTU1VpUqVNGHCBPXq1cvkut1z587pnXfe0YYNG4x9s2fP1uDBg1WvXr0c158wYYJJuM7W1lbDhg3Tv/71L9WtW9dkbFBQkKZNm6YFCxYYMw3+/v5q2rSpmjdvnu0eN2/ezHRAUNWqVfXhhx+qd+/ecnNzM/anpKRo27ZtGjt2rDHkev36dfXp00f79+8367pYSfruu+909epVSVLbtm316aefqlmzZrKyspJ053Ozfft2OTo6mrWeOQYNGqQrV67I0dFR77//vgYPHqyKFSsaX4+KitKUKVM0depU49fvyJEjWrhwoYYOHZrj2oMHDzYJ19nY2GjUqFF6++23TfYIDw/XjBkz9PXXXysuLk7Dhg3Lt+cDULgeyYDdihUrMoXr6tatq2nTpql9+/Ymf6lfv35dc+fO1aRJk4zHr96+fVt+fn46c+aMyV8uGaWkpKh3794m4Tp3d3dNnz5d/fr1M96zHhkZqa+//lpffPGF8TS9P/74w+wUOwAAAAAUZ6eundKYdR/o885TJEmxsbGKjorR1M1DVcaTk72R/26Ex8jfZ65iY2MJ2AEAAABAMZDxCsaSJUuqRo0aFqome8ePH9fPP/9s0jdgwIAC22/atGnauXOnsd20aVOtXbtWZcuWzTTWyspKLVq00NatWzVixAjNmjVLknTx4kVNmDBB3377rVl73g1lDRgwQN99950x9HaXwWBQ69attXv3bjVs2FCXLl2SdCdotGHDhhxPHhwyZIjJiWLPP/+8NmzYkCmgaG1trQ4dOqhVq1bq2LGjdu3add/b5PJLdHS0JKlRo0batGmTPDw8Mo2pWbOm1qxZo5deekmbNm2SdCfg+N1332n69OnZrr1v3z5NnDjR2C5Tpow2btyYbZi0evXqmjdvntq0aaP+/fsrLS1NKSkpGjp0qI4dO5btPu+9955Onz5tbHfu3FlLly5VyZIlM421sbFRhw4d1KZNG/Xr10+rV6+WJB09elRz5swx67Q8ScZw3ciRI7P8GhgMBrVt29astcwVHHznBys3bdqU5VXIbm5umjx5skqVKqVx48YZ+xcsWJBjwG7dunVau3atsW1ra6vVq1frxRdfzDTW09NTU6ZMUcuWLdWjR49C+5wCyH+PZMDu008/NWk3btxYAQEBcnJyyjTWw8NDH3/8sVq2bCkfHx/jT0Zcv35d8+bNy/J42rt++OEHnThxwth2c3PTnj17MiXL3d3dNXHiRNWtW1evvPKKsX/u3Ll6++23VbNmzQd6TgAAAAAoLuJvx2nkyn/rm56zjH1lPF1UzovwEwAAAAAAj7rIyEiTtoeHhwwGg4WqyVpSUpIGDBhgEhBr1KiRevXqVSD73bx5U1OnTjW2K1SooN9+++2+P0hmZWWlb775RocOHdL+/fsl3fl37U8//dTsq1YbN26sBQsWZArX3cvDw0MfffSRSVBp48aN2Qbs9u7da3INcOnSpbV8+fIcT/9zdHTUihUrVKtWLZPrbwuas7OzVq1alWW47i5ra2tNnz7dGLCT7jx/TgG7CRMmGA/ksbKy0po1a8w6qbFPnz46fPiw8dre48ePa9u2bVkG1sLCwkwOI2rQoIGWL19+35Po7O3t9dNPP6levXrGK3C//fZbDR8+PMfPwb2aN2+ur7/+2qyx+eX777/PMlx3rw8++EDz5s3TxYsXJd0JD169elXlypXLcnzGQ5LGjh2bZbjuXp07d9aHH35oEqAEULxYWbqAwhYcHKyTJ0+a9M2ZMyfLcN29nn/+eQ0aNMikb926ddmOv337dqY/HL/88stM4bp79e/fX76+vsZ2SkqKxo8fn2NdAAAAAPCwSFOahq8cpujEaEuXAgAAAAAAipCMATtzg2CFafjw4Tpy5IixbWNjo4ULFxqvwLyfxYsXKz093fi/xYsX5zj+xx9/NPm6jB8/3uxT2q2trU0OkomPj9fmzZvNmivdCYLdva0tJy+//LJJ+94AXUY//vijSfv9998363nKlCmjUaNG3XdcfhoyZIi8vLzuO+6xxx5TgwYNjO1z584pPj4+y7GnT582eQ/69OmT4zWvGX3wwQcmN/WtXLkyy3GzZ882uW552rRpZl/zWqJECZMT686fP69Dhw6ZXeOECRMKNRjbpEkTdevW7b7jbGxs1KNHD5O+e69dvld4eLi2b99ubLu6uuqDDz4wq57Ro0fLxYXbOoDi6pEL2J05c8akXalSpfsmlu/q2bOnSTswMDDbsZs3b1ZYWJix7e3trYEDB953j/Hjx5v8pbJ8+XLFxMSYVR8AAAAAPAx+OLVAXo0rW7oMAAAAAABQRMTFxZm073d4SmGbOXOmFixYYNI3ceJENWrUqMD2/O2334y/trGxUd++fXM1/4UXXjAJ/+3Zs8eseS4uLvLx8TFrrLu7u6pUqWJs3/vv5xn9/vvvJu3+/fubtYckk0NsCkOfPn3MHtuwYUPjr9PS0hQeHp7luI0bN5q0X3311VzVVLp0aT311FPGdnbv572fm/Lly+f6Wtb27dubtM393JQrV07PP/98rvbKqwd9n6TsP6v79u1Tenq6sd2zZ88cT1m8V4kSJTIF+QAUH4/cFbEZf7qhcmXz/9Hm3r/8pf+7Xz0ra9asMWkPHDjQrDR29erV1apVKwUEBEiSkpOT9dtvv6lfv35m1wkAAAAAhenzzRNM2sNXDsvzmp0/eFEh4fFcEYsCERYco+7v+mjZgUVyOG7eN0EBAAAAAJZTqlQpk3ZCQoKFKsls9erVGjlypElfnz595O/vX2B7pqena+/evcZ2rVq15OzsnKs1nJycVLp0aV2/fl3SnRPUzNGoUSOzT+WTpLJly+rChQuSlO3BMvHx8frnn3+M7cqVK+f63/E9PT2zDa/lJ1tbWz3xxBNmjy9btqxJO7uvQcagmjlXw2ZUpUoV/fnnn5Kkf/75R+np6SYZhaioKJPb/nL7Xt7d417mfm4aN25c6Nc65+ZraO77lPHEvtycMnh3/KJFi3I1B0DR8MgF7DIeuXnr1i2z52YcW6ZMmWzHbtiwwaSdMcmdk3bt2hkDdpK0fv16AnYAAAAAiqzElMR8X9NgMCg6LlWJiYlm/xQoYK5b8SnyrFVeF6POW7oUAAAAAIAZMl4VWlRuAAsICFC/fv2UlpZm7Gvfvr1+/PHHAg0TXb161eRgmb///jvP+2U8qCY7GYNI93PvaYPZ/dv8lStXTL6GderUydUed+cURsDO3d1d1tbWZo/PeNpidl+DjEG13H6dM0pNTVVsbKxJPuLMmTMmp6/99ttvhfa5qVq1ap72eRC5+Rqa+z5l/Izl9rP6IJ9tAEXDIxewy3i05+nTp5WQkGDWMcIHDhwwaTdp0iTLcVevXtWVK1eMbXt7+1wd/9uiRQuT9tGjR82eCwAAAACFrXQJD0UnRufrmunp6fKq4EC4DgXCsaSNzhy6oKZNm+b5M7Y79nA+VQUAAAAAyE7GgN3dU9cs6dChQ+rSpYuSkpKMfc8884xWrVolOzu7At07IiIi39c0N7RYEN+ryXhzXMZDc8zh6uqaP8XcR16f/96A270K6j2992tpyc9Nbk9YzA95ea+ye5/y+lktrM8pgPz3yAXsKlWqpObNm2vfvn2SpKSkJM2YMUOjR4/OcV5SUpK++eYbk75BgwZlOTZjurxGjRq5+o+ounXrmrQDAwOVkpIiG5tH7u0CAAAAUAyMaPOOybWwM3rOydX8rK6UnfXqPP1w6MM81wZkpXI1F33SZbO+Dpknb2/vPK31w7Re+VMUAAAAACBbjz32mEk7Li5OgYGBqlGjhkXqOXXqlDp06KC4uDhj3xNPPKHffvvNrINd8ipjyCc/3HuCXGG7N6Qo6YECivb29vlVjkUUxntqyc+Nra1tvu9tCXn9rBb3zynwKHskE1tTpkxRq1atjH/Yf/zxx6pYsaL8/PyyHB8dHa1XX33VJDjXuXNnde7cOcvxZ86cMWnn5n54SfLw8JCDg4MSE+9cs3T79m2FhISoZs2auVoHAAAAAIobK1lp5FOjNDNxrqVLAQAAAAAARUSzZs1kY2OjlJQUY9+hQ4csErALCgpSu3btTE4Dq1WrlrZs2VJop1OVKFHCpF23bl19++23eVrT0dExT/PzIuMpYPHx8bleIzY2Nr/KsYgSJUqYPMPGjRvzfABP+fLlM+1xrzZt2mjMmDF52sPNzS1P84ubvH5Wi/vnFHiUPZIBu5YtW2rWrFl66623lJ6erpSUFA0YMECzZ89Wjx49VLt2bTk6OurGjRv6888/tXTpUpO7w9u1a6f//ve/2a5/7do1k3alSpVyXWPFihUVHBxssiYBOwAAAAAPs1J2zprUebJCQ0MtXQoAAAAAAChCnJyc1KhRIx04cMDYt3btWvXt27dQ6wgLC9MLL7ygy5cvG/uqVKmibdu2qWzZsoVWR5kyZUza6enpatu2baHtn98yXgF86dKlXK/xIHOKkjJlypiErxo1apTvn6mMnxsHB4di/bmxhKw+qw0bNjR7fnH/nAKPskcyYCdJQ4cOVe3atTV8+HCdOnVKknTw4EEdPHgw2znVqlWTv7+/3nzzTVlZWWU7LmNK+UGOAc4450FS+lm5du2arl+/nqs5gYGB+bI3AAAAAGSnjkcdDX3ubUuXAQAAAAAAiqju3bubBOxWrVqliIgIlS5dulD2v3btmtq2bavz588b+8qXL6/t27fn+kazvCpfvrwcHR1169YtSdL58+eVnJxcbK/hrFChgtzc3BQVFSVJOnnypFJSUsw+wS0lJcX4b/7FVdWqVU0O4AkMDMz3gF3VqlVN2uQAcq9u3bom7SNHjqhTp05mzz969Gg+VwSgsDyyATtJev7553Xw4EF9/PHHmj59ulJTU7MdW6VKFY0aNUr9+/fPMVwnZQ7DOTg45Lq2jEfw5lfAbs6cOfr000/zZS0AAAAAyA8vN+yvltVbZuq/ER5jgWrwKOCzBQAAAADFz+DBgzVp0iTjv5smJSVpypQpmjp1aoHvHRUVpXbt2uns2bPGPnd3d23dutUi19Ta2tqqRYsW2rZtmyTp5s2b+vPPP9WyZebvrxQHBoNBjRs31tatWyVJt27d0vbt2+Xj42PW/C1btigxMbEgSyxwbdq00fbt243tHTt2qHnz5vm6R6VKlVSjRg1jsO7cuXMKCwsr9IBocdakSROT9vr16zV27Fiz569duza/SwJQSB7pgN28efM0YcIEkyN8s3PhwgUNGzZM48aN07Rp0/T6669nOzbjX952dna5rs3e3t6kffenDwAAAADgYZMxXOfs7CxXNxf5+8y1UEV4FLi6ucjZ2dnSZQAAAAAAzOTm5qZBgwbp22+/NfZ9/fXX6tmzp5o2bZqntX/77bdsT6GKj49Xx44ddfz4cWOfs7OzNm/erPr16+dp37zo0KGDMWAnSTNnziy2ATtJ6tKlizFgJ0mzZ882O2A3a9asgiqr0HTo0EHjxo0zthcsWKAPPvgg308l7NChg8nXa9asWZoyZUq+7vEwe/rpp1WuXDldvXpVkrR//34dPnxYTz311H3nHjhwIMcbFQEUbY9kwC45OVn9+vXTypUrjX3u7u7697//rZdeekk1a9aUk5OTbty4oUOHDmnRokX69ddflZ6ersjISA0aNEinT5/WtGnTslw/44l1t2/fznWNSUlJOa4JAAAAAA8rd3d3BQUGKzY21tKl4CHm7Owsd3d3S5cBAAAAAMiF8ePHa82aNQoNDZUkpaamqlu3btqyZYsef/zxXK+XnJys0aNHa+XKlQoJCcn0emJiorp06aI///zT2Ofo6Kj169ercePGD/wc+eGNN97QxIkTFR0dLUlasWKFNmzYoBdffNGidT0oX19f+fv7Gw+eWbdunVauXKmePXvmOO9///ufNm7cWBglFqinnnpKbdq00c6dOyVJYWFhGjduXL6H39555x3NmzdPKSkpku4EM/v06aNGjRrl6z4PK1tbWw0cOFCTJ0829g0dOlS7d+/OMdNx69YtDRkypDBKBFBAHsmA3dChQ03CdU2aNNGaNWtUvnx5k3EVKlRQ586d1blzZ61du1Z9+vQxnk735Zdfqm7duho4cGCm9UuWLGnSfpDjaDOeWJdxzQc1bNgw9e7dO1dzAgMD1a1bt3zZHwAAAADM4e7uTvgJAAAAAACYcHV11bJly9SyZUslJydLkq5cuaJWrVpp9uzZ6tu3rwwGg1lr7dq1S8OHD9fx48fl5eWV6fWUlBT17t3bGHiS7txctnr1aj377LP580D3GDBggJYsWWJs+/n5afHixdmOd3Fx0QcffKDRo0dLktLS0tSvXz/99NNP6tKli9n7Hj58WFOnTtWyZcseuPb84Orqqvfee08TJ0409r3yyitKTk5W3759s5yzdOlS481zBoNB6enphVJrQfnss8/03HPPKS0tTZI0depUOTk56aOPPjL7c33x4kV9++23evnll/X0009ner1atWoaNGiQ5s+fL+lOLuGll17SypUr9cwzz5hd644dO/S///1PCxYsMHvOw+Kdd97RggULFBkZKUk6ePCgunbtqv/85z8qW7ZspvFXr17VK6+8oiNHjjwUn1PgUfXIBewCAgL0/fffG9tly5bV+vXr5eHhkeO8Ll26aPbs2Ro0aJCx7/3331ffvn3l6OhoMjZjGC4hISHXdWack18Bu7Jly2b5hzoAAAAAAAAAAAAAFHVNmjTRwoUL9frrrxuDSFFRUerfv7+mT5+uQYMGqWPHjqpSpUqmuefOndO6deu0YsUK/fHHHznu8+abb2r9+vWZ+qytrU2uZjVHvXr1VKFChVzNMYe/v7/27Nmj3377TZIUFxenbt26qVu3bvr3v/+tFi1ayN7e3mROYmKijh8/rm3btmnlypX666+/JMniATtJGjdunFatWqW///5b0p1b3/r166eZM2eqZ8+eql69utLT0xUUFKSVK1ca38Py5curadOmWrNmjSXLz7MWLVpo0qRJxtCkJH3yySdau3atRo0aJR8fH7m5uZnMSU1N1dmzZ7Vnzx6tXLlSO3bsUEpKSo4nGU6fPl0HDhzQkSNHJEmXL1/Wc889J19fXw0ePFiNGzeWjY1plCQ+Pl5Hjx7Vxo0btXLlSp05cybLYOqjoGzZsvr222/16quvGvu2bNmi2rVrq2/fvmrZsqXc3d0VERGh33//Xf/73/8UExMjSRo8eLDmzZtnqdIB5MEjF7CbMWOGSXvkyJH3DdfdNWDAAE2ZMkVnz56VJEVERGjVqlV65ZVXTMZlDLBdvHgx13VeunQpxzUBAAAA4GEWGRnJFbEoUFwRCwAAAADFl5+fn1xcXOTn52fy/YODBw/q4MGDku6cju/h4SEXFxdFRETo8uXLunnzZpbrZRV+u/fkurtmz56t2bNn57reRYsWacCAAbmedz9WVlZaunSpunXrpoCAAElSenq6Vq9erdWrV8ve3l5eXl5yc3NTYmKioqOjdfHiRaWmpuZ7LfnB3t5emzZtUqtWrUyu7N23b5/27duX5RxHR0etWLFCCxcuNOnPGBArLj788ENdu3ZN06dPN/YdPnxY/fr1k5WVlapUqaLSpUtLkqKjo3P8XGfH0dFRa9euVadOnXTixAlJd05sXLx4sRYvXiwnJydVrlxZLi4uunnzpqKiohQeHs7Ja/fw9fVVaGioPvroI2NfdHS05s2bl22Arlu3bnr//fdNXi+un1PgUfRI/W5NT0/Xjh07TPo6d+5s9nwrKyu9+OKLxoCdJO3evTtTwK527dom7QsXLuSqzmvXrplcK2tnZ6dq1arlag0AAAAAKC6uRl9ROdfyxnZkZKSq16im6KgYC1aFh52rm4uCAoMJ2QEAAABAMdWtWzcdO3ZMI0eOzPLkssjISOMVjtkpXbq0xo0bp7feequgyixwLi4u2rp1qz744APNmDFDKSkpxteSkpJM/m07O5UrVy7IEnOlcuXK2rNnj4YMGZLpBMGMvL299d///lfNmjUzCaRJd74uxdXXX3+thg0basSIEYqOjjb2p6WlKTQ0VKGhoTnOL1WqlFxdXXMcU6lSJf3xxx8aMmSIfv75Z5PwXEJCgv7555/71pnVKZGPknHjxqlSpUp69913FRUVle04g8GgYcOGafr06Tpz5ozJa8X5cwo8ah6pgF1UVJTx6M27qlatmqs1Mo4PDw/PNOaxxx4zaQcFBen27duys7Mza4/Tp0+btKtXr05yGQAAAMBDa9L2CXq5YX+1rN5SkhQbG6voqBhN3TxUZTz5JhPy343wGPn7zFVsbCwBOwAAAAAoxry9vfXrr7/q6NGjWrhwoVatWqUrV67kOMfJyUnPPfec/Pz81K1bt0xXqBZHNjY2+uqrr/TWW29pypQp+vXXX3Xt2rUc53h7e6t9+/bq1auXXnjhhUKq1Dyenp5at26ddu7cqaVLl+r3339XeHi4EhMT5eHhoYYNG6p79+7y9fWVg4ODJJmEKa2srFSyZElLlZ8vXnvtNXXt2lUzZ87Uf/7zn/sGJd3c3PTCCy+oS5cu6tmzp0qUKHHfPZycnPSf//xH77//viZPnqyNGzeaBPqy8thjj8nHx0d9+vTRM888k5tHeigNGDBAL730kn766SetXr1agYGBun79uuzt7VWtWjW1bt1ab7zxhh5//HFJyhT6JWAHFB+PVGorKSkpU19ug2u2trYm7ayOzy1fvrzKly9v/I+3pKQkHT582Oy/YPbu3WvSbtiwYa5qBAAAAIDi5pejS3X6ygm92WKosa+Mp4vKeRF+AgAAAACYp9PnkyxdAiykYcOGxutbg4KCdPLkSYWFhSkuLk7p6elydXWVu7u76tatq3r16sna2vq+a97vlLD8dvd6zryoVq2a5s+fr3nz5unUqVM6deqUbty4oejoaNnb28vFxUVVq1ZV3bp1VbFiRbPW9Pb2ztPVoHevrn0Qbdq0UZs2bcwae/eqU+nOyWoGgyHbsa1bt87VM+XlszB+/HiNHz/+gea6uLho3LhxGjdunMLDw3Xw4EFdu3ZNERERsrKykrOzszw9PVWnTh1Vr15dVlZWD7RPgwYNtHTpUqWlpemvv/7S2bNndePGDcXGxqpEiRJydXVV9erVVbduXXl4eJi1Zm6/xtnJzRp5+T2Ul3rLlCmjkSNHauTIkfcde/z4cZO2l5fXA+0JoPA9UgG7u3eR3+vSpUu5OsUu44l12f0F8uKLL+r77783trdu3Wp2wG7r1q0m7dxcYwsAAAAAxdWJKyc0bv1ovVF/sKVLAQAAAAAAxVT16tVVvXp1S5dhUQaDQfXr11f9+vUtXUqhOHbsmG7cuGFsN27c2ILVFAxPT095enoW6B5WVlZq3LjxQ/n1Kyq2b99u0uZrDRQfDxZhLqbs7OxUoUIFk74dO3bkao2Mf+Bl9x9nXbp0MWkvWrTIrMRzUFCQdu3aZWzb2tqqU6dOuaoRAAAAAIqr2KQYTT88zdJlAAAAAAAAoJiYMWOGSbtFixYWqgTIXmhoqNatW2dsu7u7q06dOhasCEBuPFIn2EnSCy+8oJ9++snY/uabb+Tn52fWVbG7du3SH3/8kWm9rPj4+KhSpUq6ePGipDt/WC5atEivv/56jnuMHz/eJIjXs2dP7t0GAAAAUKQt+fMHk/bwlcPytF660vXv5UOUmJiYp3UAAAAAAABQvKSnp+d4vWtGmzZt0qJFi4xtOzs7vfLKKwVRGmAiN5/V5ORk+fn5KTU11djn5+f3wNf6Aih8j1zAztfX1yRgd/LkSQ0bNkzz5s3L8Q+vwMBA9e/f36SvZs2a2V77am9vr7Fjx2ro0KHGvlGjRqlZs2aqW7dulnOWLl1qUpu1tbU+/fRTs54LAAAAACwl6EZgvq9pMBh0OjRJ5bwS5eDgkO/r49EWFhyj7u/6aNmBRXI4zucLAAAAAICiYurUqQoPD9eIESNyvOo3NTVV3333nUaMGGFygI2vr688PDwKo1Q84ho1aqTRo0erW7dusrOzy3ZccHCwBg4cqN27dxv77O3tNWxY3n5IGUDheuQCdj4+PmrTpo127txp7Fu4cKFOnz6t8ePHq1WrVian2UVERGjx4sX67LPPFBMTY7LW559/Lmtr62z3GjRokGbNmqVTp05JkqKiovTss89q+vTp6t+/v3GfyMhITZ8+XZ9//rnJ/MGDB6tWrVp5fmYAAAAAKG7S09NlZ2MgXIcCcSs+RZ61yuti1HlLlwIAAAAAAO5x69YtzZw5UzNnzlTjxo313HPP6fHHH1eZMmUk3fn3+7/++kvr1q1TSEiIydxKlSrpq6++skTZeAQdPXpUffr0kaurq3x8fPT000/Ly8tLJUuWVFxcnC5cuKCAgABt3LjR5OQ6SZo4caJq1KhhocoBPIhHLmAn3Tkprnnz5iZ/4f7+++9q27atSpYsqapVq8rR0VEREREKDg42Sbzf9d5776lXr1457mNra6vly5erZcuWioyMlHQnTOfn56e33npL1atX161btxQSEqLk5GSTuU2aNNGXX36ZD08LAAAAAAVrzAsfy3/Du8b2hBc/z2F0Zh9vGJOp7++dp+U7LOsTw4G8cixpozOHLqhp06Z5DnHujj2cT1UBAAAAAIB7HTp0SIcOHTJrrKenp9avXy9XV9eCLQrIIDo6WsuWLdOyZcvMGj98+HC9++679x8IoEh5JAN25cuX165du/Taa68pICDA5LX4+HidOHEi27m2trb67LPP5O/vb9ZederU0Y4dO9S1a1edP/9/PxkfHx+vY8eOZTmnbdu2Wr58uRwdHc3aAwAAAAAsKWNAydXBNU/rdfDqpJlz5hKwQ4GpXM1Fn3TZrK9D5snb2ztPa/0wLecfvgMAAAAAAOYrX768rK2tM534lR0rKyv16tVLX3/9tTw9PQu4OuD/eHp6Kjw83OzxlStX1oQJEzRgwICCKwpAgXkkA3bSnT+8tm/frpUrV2rOnDnavXu30tLSsh3v4uKi/v37a8SIEapdu3au9nriiSd04sQJffHFF5o3b56ioqKyHFezZk35+/tr0KBBMhgMudoDAAAAAB4GE178XNFXoi1dBgAAAAAAACxgyJAh6tmzpzZt2qS9e/fq5MmTCg0NVVRUlBITE1WqVCm5u7urZs2aat26tbp3767HHnvM0mXjERQWFqY//vhDO3fu1IEDBxQUFKRLly4pPj5eVlZWcnNzU9myZdWsWTO98MIL6tatm+zs7CxdNoAH9MgG7KQ7afbevXurd+/eiouL06FDhxQcHKzo6GglJibK2dlZpUuXVoMGDVS3bl1ZWVk98F6lSpXS559/rk8//VR//vmnTp48qYiICFlbW6tChQpq1KiRHn/88Xx8OgAAAAAoPgwy6NuesyVJ0Yq2bDEAAAAAAACwGA8PD7366qt69dVXLV0KkC2DwaDmzZurefPmli4FQCF4pAN29ypVqpTatGmjNm3aFOg+tra2atmypVq2bFmg+wAAAABAcVHKzlmTOk/O1H8jPMYC1eBRwGcLAAAAAAAAAGAuAnYAAAAAAIvKGK5zdnaWq5uL/H3mWqgiPApc3Vzk7Oxs6TIAAAAAAAAAAEUcATsAAAAAQJHi7u6uoMBgxcbGWroUPMScnZ3l7u5u6TIAAAAAAAAAAEUcATsAAAAAQJHj7u5O+AkAAAAAAAAAAFiclaULAAAAAAAAAAAAAAAAAACgKCJgBwAAAAAAAAAAAAAAAABAFrgiFgAAAABQ5ERGRio2NtbSZeAh5uzszDXEAAAAAAAAAID7ImAHAAAAALCoESvf0rc9ZxvbkZGRql6jmqKjYixYFR52rm4uCgoMJmQHAAAAAAAAAMgRATsAAAAAgEWlK13DVw7T2Bc+VjnX8oqNjVV0VIymbh6qMp4uli4PD6Eb4THy95mr2NhYAnYAAAAAAAAAgBwRsAMAAAAAFAmTtk9Qvyd9VcGqoiSpjKeLynkRfgIAAAAAAAAAAJZDwA4AAAAAUGT898hPquZcw9JlAAAAAAAAAAAASCJgBwAAAADIo+MXj5q031s9Ik/rBccG6tVZ/fO0BgAAAAAAAAAAQH4gYAcAAAAAyJMVx34xaSenJed5TZdyzjryT4w6cEUsCkBYcIy6v+ujZQcWyeG4g6XLAQAAAAAAAAAUYQTsAAAAAABFjsFgkCQlJibKwYEAFPLXrfgUedYqr4tR5y1dCgAAAAAAAACgiCNgBwAAAADIkyZezbTlzKZ8XTPldoqeblCacB0KhGNJG505dEFNmzbN82dsd+zhfKoKAAAAAAAAAFAUEbADAAAAAOTJS/W7mATsZvSck6v5w1cOM2mXtCmlL3pN1dMnP8yX+oCMKldz0SddNuvrkHny9vbO01o/TOuVP0UBAAAAAAAAAIokK0sXAAAAAADAXQ0rNtS/nhhq6TIAAAAAAAAAAAAkcYIdAAAAAKCI6Pekr56p1lyhoaGWLgUAAAAAAAAAAEASATsAAAAAQBEw9oWPVc61vEnfjfAYC1WDhx2fLQAAAAAAAACAuQjYAQAAAAAsakbPOSZtZ2dnubq5yN9nroUqwqPA1c1Fzs7Oli4DAAAAAAAAAFDEEbADAAAAABQp7u7uCgoMVmxsrKVLwUPM2dlZ7u7uli4DAAAAAIAH1rp1a+3atcvYTk9Pt2A1j4bFixdr4MCBxvaiRYs0YMCAbMcbDAbjr1u1aqWAgIACrA4AUFAI2AEAAAAAihx3d3fCTwAAAAAAINdCQkJ08uRJhYWFKTY2VmlpaXJzc5Obm5vq1Kmj+vXry9ra+oHWDg8P14kTJxQaGqro6GhZW1vLzc1N3t7eatq0qUqVKpXPTwMAAIoCAnYAAAAAAAAAAAAAgGLrxIkTWrBggVavXq3w8PAcx5YoUUItWrSQr6+vevbsKScnp2zHJiQkaP369dq4caO2b9+uixcvZjvW2tparVq10ogRI9SlS5cHfhYAAFD0WFm6AAAAAAAAAAAAAAAAcuvChQvq2bOnGjRooFmzZt03XCdJN2/e1NatW+Xn56eKFSvqiy++UGJiYqZxX3zxhcqVK6e+fftqyZIlOYbrJCk1NVU7duxQ165d1bFjR125cuWBnwtA4QoNDZXBYDD+L6drfwE8mjjBDgAAAABQ5ERGRio2NtbSZeAh5uzszDXEAAAAwEMmtdM4S5fw0LD+baKlS7iv9evXy9fXVzExMVm+7ubmJg8PD7m4uOjGjRu6evWqbt68aTImNjZWY8aM0apVq3Tw4EGT1w4fPqyEhIRM6xoMBpUvX17lypWTwWBQWFiYbty4YTJm06ZNatmypfbs2aMKFSrk8UkBAIClEbADAAAAAFjU/D2zNfjZt4ztyMhIVa9RTdFRWX+DHMgPrm4uCgoMJmQHAAAAAMXQzz//LD8/P6Wmppr0P/XUUxo0aJA6deokLy+vTPPOnDmjNWvW6JdfftHhw4eN/devX89xP0dHR/Xu3Vtdu3ZVq1atVLp0aeNr6enpOnz4sD777DOtXbvW2B8UFKSuXbtq//79srLiYrlHVXp6uqVLAADkAwJ2AAAAAACLOnXtlMas+0Cfd54i6c5Pj0dHxWjq5qEq4+li4erwMLoRHiN/n7mKjY0lYAcAAAAAxcyhQ4f0+uuvm4TrXFxcNGvWLL3yyisyGAzZzq1du7b8/f3l7++v1atXa/To0Tpz5ky24z08PPThhx9q0KBBcnHJ+nsUBoNBjRs31po1azRp0iSNG/d/JykePHhQS5Ys0cCBAx/gSQEAQFFBwA4AAAAAYHHxt+M0cuW/9U3PWca+Mp4uKudF+AkAAAAAANwRGxurPn366Pbt28a+smXLavPmzWrYsGGu1urevbtefPFFDRs2TNu2bcv0+uDBg7V48WKVLFnS7DXHjh2rw4cPa/Xq1ca+7777joAdAADFHGfRAgAAAACKhDSlafjKYYpOjLZ0KQAAAAAAoAgaP368goODjW0rKyv9+uuvuQ7X3WVnZ6fvvvtOX3/9dabX2rVrl6tw3V2jR482ae/fv1+xsbEPVB8AACgaOMEOAAAAAFCk/HBqgbwaV7Z0GQAAAAAAoAiJjo7WwoULTfpGjhypZ555Js9r9+jRI89r3NW4cWM5Ojrq1q1bkqS0tDRdvHhRdevWzbc9zBUTE6Pdu3crMDBQt27dUunSpVWjRg21bNlS9vb2D7xuWlqazp07p1OnTunSpUuKjY2Vvb293N3dVaNGDTVp0iRP62fn2rVr2rNnj0JCQpScnKwyZcqobt26atasmaytrfO09s2bNxUQEKDz588rMjJSLi4uqlOnjlq0aCEHB4d8eoK8uXXrlnbv3q1//vlH8fHxcnNzk7e3t1q1aiUnJ6c8rZ2SkqK9e/cqMDBQV69elYODg6pXr65nn31W7u5F94aJ5ORknThxQidPnlRERIQSEhJkb2+vUqVKycvLS7Vq1VL16tUtUlt0dLROnjypM2fOKCoqSrdv35arq6vKli2rp59+Wl5eXvmyT2Jionbv3q2QkBDduHFDJUuWVK1atfTss88+UEj4fq5du6b9+/frypUrioiIUMmSJVW2bFk1adJEVatWzff9gKKCgB0AAAAAIE8+3zzBpD185bA8r9n5gxcVEh7PFbEoEGHBMer+ro+WHVgkh+NF45vkAAAAAICczZ8/X/Hx8ca2nZ1dptPiigKDwSAXFxdjwE66E3QrTJcvX9bYsWP1888/m1yne5eTk5NGjhyp0aNHmx3MiouL0+rVq/Xrr78qICBAUVFR2Y61t7dX586dNXr0aDVq1Mjsur29vXX+/HlJkpeXl0JDQyVJZ8+e1Ycffqg1a9YoLS0t07zSpUtrzJgxevvtt2Vra2v2fpIUFRWl0aNH66efflJCQkKm10uVKqWhQ4fq448/fqAQm8FgMP66VatWCggIyHbsgAEDtGTJEmM7JCRE3t7eiomJ0aeffqoFCxZkWaOdnZ0GDRqkCRMmqEyZMrmqLykpSZ9//rnmzJmjGzduZHrd2tpavXr10tSpU1WlShWFhoaahKj8/Py0ePHiXO2ZH65cuaKJEydq6dKlOX4WJalMmTJ6/vnn9frrr8vHx8fktXs/c/dasmSJyXuR0aJFizRgwIBM/UeOHNH//vc/bdmyRceOHVN6enq2a1SrVk0jRozQm2++KUdHxxyfISsxMTEaN26clixZori4uEyvOzg4yM/PT5MmTVLp0qUVEBCgNm3aGF//5JNPNH78eLP2SktL008//aSZM2fq8OHD2T5XnTp15O/vr9dee01WVlyoiYcLATsAAAAAQJ4kpiTm+5oGg0HRcalKTEwsMj8ljIfHrfgUedYqr4tRmb+BCgAAAAAomlatWmXS7t69e67DRIUhOTlZ169fN+krXbr0fedlDFc9aHBpz5496tatmyIjI7Mdk5CQoEmTJmnLli3atGmTWSeUVa1aVREREWbVkJSUpBUrVmjlypWaOHGixowZY3b9Ga1YsUKvvfaaSWAxo4iICL333nvasWOHVqxYYfb3kg4dOqTOnTvrypUr2Y6Ji4vT1KlTtW7dOm3ZsiXX9efV33//rU6dOmUZArvr9u3bmjt3rrZs2aJt27bJ29vbrLUvXLggHx8f/fPPP9mOSU1N1bJly7Rp0yatWbMm305dy4utW7eqd+/eZgdXb9y4oV9++UXh4eGZAnb5adasWXr77bfNHh8cHKwRI0Zo/vz5WrNmjWrUqGH23GPHjqljx466fPlytmMSExM1f/58rV+/Xps3bzZ77YzOnTun3r1769ixY/cde/r0aQ0cOFDz58/X2rVr5eHh8cD7AkUNATsAAAAAQJ6ULuGh6MTofF0zPT1dXhUcCNehQDiWtNGZQxfUtGnTPH/GdscezqeqAAAAAADZSUhI0F9//WXS17VrVwtVk7N9+/YpNTXV2La3t1eVKlUKZe/Dhw+rY8eOxlPOrKysVLVqVZUuXVpRUVEKDAw0OXnq4MGDGjBggNauXXvftRMTTX/A0mAwqFKlSnJzc1OJEiUUFxenkJAQ3bx50zgmPT1dY8eOVUpKij7++ONcP8+GDRvUt29f49fT1tZWVatWlaurq65du2Y84e7e8f7+/poxY8Z91z558qR8fHwyBRHt7OxUtWpVlSxZUmFhYbp27ZqkO8GhTp06aejQobl+jgcVGhqqfv36mQQAvby8VLZsWcXHx+vs2bMmn7WgoCD16NFDBw4ckI1NzlGQK1euqE2bNgoODjbpNxgMxs9MRESEQkJClJ6erpiYGHXu3Fm//PJL/j5kLp06dUqdO3dWUlKSSb+9vb28vb3l4uKi1NRUxcTE6Pz580pOTi602jL+HpHunIBYsWJFubi4KCUlRdevX1dYWJjJmL///lvPPvusjh07prJly953n9OnT6tt27aZThy0sbFR1apV5eLioqtXrxr3CQ8PV4cOHfTVV1/l+pn+/PNPvfTSS5n2sra2VtWqVeXu7q74+HgFBwebPP/+/fv1zDPP6I8//iBkh4cGATsAAAAAQJ6MaPOOybWwM3rOydX8rK6UnfXqPP1w6MM81wZkpXI1F33SZbO+Dpln9k91Z+eHab3ypygAAAAAQLb279+vlJQUk77GjRtbqJqc/fDDDybt559/vtB+gPDll19WQkKC3N3dNW7cOL322msmp+ddunRJY8eONTkZb926ddq4caM6dux43/Ufe+wx9e7dWx07dtQTTzyhEiVKmLyelpamAwcO6Ntvv9X//vc/Y/+ECRPUsWNHPf3002Y/S0xMjF599VWlpqaqUqVKmjBhgnr16qVSpUoZx5w7d07vvPOONmzYYOybPXu2Bg8erHr16mW7dnJysvr3728SritVqpQmTpwoPz8/ubi4GPv//PNP+fv7a/fu3Tpx4oSmTp1q9jPk1aBBg3TlyhU5Ojrq/fff1+DBg1WxYkXj61FRUZoyZYqmTp1qDE4eOXJECxcuvG8QcPDgwSbhOhsbG40aNUpvv/22yR7h4eGaMWOGvv76a8XFxWnYsMzfxytM/v7+JuG6hg0bauLEiWrXrp3s7OxMxiYnJ+vkyZPauHGjyefxXj///LNu3bqlq1evytfX19jfvn17vf/++9nWkd3ny97eXl27dtVLL72kVq1aZRmujYiI0PLly/XZZ5/p0qVLku4EHt98802tWbMm+4eXlJKSIl9fX5PAm5OTkz755BMNGjTI5DTKwMBAffHFF/rhhx908eJFffhh7r7XeuXKFXXp0sVkrwYNGmj06NF66aWXVLJkSWN/YmKi1q5dqzFjxigoKEjSncDngAEDtH79epOrkoHiioAdAAAAAKDIsJKVRj41SjMT51q6FAAAAAAAUERkvMKyZMmSubpOsbAcP35cP//8s0nfgAEDCm3/4OBgeXt7a9u2bapevXqm1ytWrKhFixbJ1tZWCxcuNPYvWLDgvgG79evXq3Xr1jmOsbKyUrNmzdSsWTN17NhRfn5+ku5cM/rll19q2bJlZj9LdHS0JKlRo0batGlTlqdg1axZU2vWrNFLL72kTZs2SboT8vvuu+80ffr0bNeePn26Tpw4YWy7ublp9+7dql+/fqaxTZs2VUBAgPz8/PSf//wn06l5BSk4OFju7u7atGlTluFENzc3TZ48WaVKldK4ceOM/QsWLMgxYLdu3TqTUwttbW21evVqvfjii5nGenp6asqUKWrZsqV69OihkJCQPD7Vg4uJiTG5pvexxx7Tvn375OjomOV4W1tbPfnkk3ryySc1ZsyYLK/CbdGihSRlel8rVKigtm3b5qq+jh076rXXXrvvKXSlS5fWkCFD1KdPH7Vr106HD9+5HWHt2rX6+++/Vbdu3Wznzp071+Q0T2dnZ23fvj3LwHGNGjX0/fffq3Hjxho2bFiu37uBAwcaT3CUpH/961+aNWuWbG1tM411cHDQyy+/rPbt2+vFF1/Uvn37JEm//fabfv31V3Xv3j1XewNFkZWlCwAAAAAAQJJK2Tnrm56zLF0GAAAAAAAoYjJe4+nh4VHkTkRKSkrSgAEDTK7sbNSokXr1KryTz62trbV8+fIsw3X3mjJlismpelu2bFFaWlqOc+4XrsvotddeMzkRbNWqVYqJicnVGs7Ozlq1alWOV0xaW1tnCtNt3Lgx2/GpqamZrpBduHBhluG6uwwGg77//vscg08F5fvvv7/vyX8ffPCBKlWqZGwfPXpUV69ezXZ8xucfO3ZsluG6e3Xu3DnXJ6Dlt5CQEJOTLAcMGJBtuC4rjz32WEGUZVSvXj2zrni9y83NTf/9739lZfV/sZ17T5fMysyZM03aM2bMuO9pnkOHDjX5vWiO/fv3G0Or0p3w4Lx587IM193L1dVVK1euNDlp8kGupgWKIgJ2AAAAAACLq+NRR5M6T7Z0GQAAAAAAoAjKGLBzdXW1TCE5GD58uI4cOWJs29jYaOHChSbhmZwsXrxY6enpxv/dL2iTlZ49e5p1da6bm5vat29vbN+8eTPL073y6t5QT0pKig4ePJir+UOGDJGXl9d9xz322GNq0KCBsX3u3DnFx8dnOXbLli0KDw83tp9++mn17NnzvnvY2trq888/N6Pq/NOkSRN169btvuNsbGzUo0cPk767p6JlFB4eru3btxvbrq6u+uCDD8yqZ/To0SbX5xa2W7dumbTvF/YqDmrWrKkmTZoY23dPfsvKH3/8oXPnzhnbderU0WuvvWbWPp9//rnZfxZJ0jfffGPSnj59utmh5vLly+uNN94wtvfu3Ztj4BMoLrgiFgAAAABgUS837K+W1Vtm6r8RnrufagbMxWcLAAAAAIqXuLg4k7aTk5OFKsnazJkztWDBApO+iRMnqlGjRoVaR58+fcwe27BhQ5NrQsPCwvL9hLaqVauatI8cOZKrazdz+zzHjx+XdOea2PDwcNWuXTvTuICAAJO2uQElSXrxxRfl4eGh69evmz0nL3L7/PcKCwvLcty+ffuUnp5ubPfs2dPkNMOclChRQj169NCiRYvMris/VaxY0aT9yy+/6O233y72QbuqVatq//79kmQS0s3o999/N2n379/f7NBb5cqV1apVK+3cufO+Y9PS0kxOr2vSpEmWv5dy0r59e5OTJffs2VOop3kCBYGAHQAAAADAojKG65ydneXq5iJ/n7kWqgiPAlc3Fzk7O1u6DAAAAACAGe69blCSEhISLFRJZqtXr9bIkSNN+vr06SN/f/9Cr8Wc0+vuyniVpbnXt6alpSkgIEAbNmzQsWPHdO7cOcXExCguLu6+18zeuHHD7PpsbW31xBNPmD3e3Oc5cOCASTs3V9/a2NioRYsW+vXXX82ekxcF8X4eOnTIpN28efNc1dS8eXOLBey8vLxUs2ZN4yluf/75pzp06KDPPvss189R0K5evapffvlF+/fv1/Hjx3Xt2jXFxsYqMTExx3k3b97UrVu3srz6Nj/eO3MCdidOnDD5/OTmc3hXlSpVTNqnT5/O9RpAUUPADgAAAABQpLi7uysoMFixsbGWLgUPMWdnZ7m7u1u6DAAAAACAGTL+/zdzw2AFLSAgQP369TMJlrVv314//vij2SdL5aeMIaucZDwFMOP1m1lZs2aN3nnnHYWEhOS6NkmKjo42e6y7u7usra3NHm/u89xbu7W1tR577DGz95Ckxx9/vNACdgXxft57Pa5055rR3Mjt+Pw2fvx4vfLKK8b2jh07tGPHDnl7e8vHx0etWrVS8+bNzbpauCDcuHFD/v7++vHHH5WamvpAa0RHR2cZsCus9y5jGG7OnDmaM2dOrvbKKOM130BxRMAOAAAAAFDkuLu7E34CAAAAAACSMgfsCuuKzpwcOnRIXbp0UVJSkrHvmWee0apVq2RnZ2eRmsy96jMr914bmpUxY8boiy++eOD1JZl8re4nL88iZf8894b8XFxcZGOTu8hE6dKl81JWrhTE+5kx5Oji4pKrdV1dXR+wovzRv39/BQcH6+OPPzZ5xtDQUM2fP1/z58+XdOe0u/bt26tv375q06ZNoQReg4KC1Lp1a128eDFP62T3+6Sw3ruIiIhcrWuOohKKBvKCgB0AAAAAAAAAAAAAoMjKeMpYXFycAgMDVaNGDYvUc+rUKXXo0EFxcXHGvieeeEK//fZbppPEHgZLlizJFK5zdHTUs88+qyZNmqhKlSoqU6aM7O3tTcKFV69ela+vb2GXm6P4+Hjjr0uUKJHr+cX9/c0Y3sptGNTe3j4/y3kg48aNU7t27TRhwgRt3rw5y5Pizp8/r4ULF2rhwoWqX7++vv76a7Vr167Aarp9+7Y6deqUKVxXs2ZNtWrVSrVr15anp6ecnJzk6OhoEvibNm2atmzZct89Cuu9y81Jk+a63/XRQHFAwA4AAAAAUORERkZyRSwKFFfEAgAAAEDx0axZM9nY2CglJcXYd+jQIYsE7IKCgtSuXTuTU55q1aqlLVu2WPx0r4Jw+/ZtffDBByZ9r7/+uqZOnXrf09zOnDlTkKU9ECcnJ+P3nG7evJnr+QkJCfldUqHKeOrZvYFDcxSV79c1bdpUGzZs0OXLl7VlyxYFBARo9+7dCg4OzjT25MmT8vHx0VdffaV33nmnQOqZN2+ezp49a2yXK1dOixcvVocOHe479/vvvzdrj6zeu9z8mWPue5cxeNqvXz+9/vrrZu+TlYoVK+ZpPlAUELADAAAAAFjU1egrKuda3tiOjIxU9RrVFB3F1QEoOK5uLgoKDCZkBwAAAADFgJOTkxo1aqQDBw4Y+9auXau+ffsWah1hYWF64YUXdPnyZWNflSpVtG3bNpUtW7ZQayksAQEBunr1qrHdvn17swNBkZGRBVXWA3N1dTUGjWJiYpScnCxbW1uz5xfE9ZmFKeP3QS5duqSGDRuaPf/SpUv5XFHeVKhQQX5+fvLz85N0p74dO3bo119/1dq1a5WcnCzpzpW57733np555hk1a9Ys3+v43//+Z9JevXq1nnnmGbPmmvv7JKv3LjcBO3PfuzJlypi0XV1d1bZtW7P3AR5WBOwAAAAAABY1afsEvdywv1pWbynpzk9TRkfFaOrmoSrj6XKf2UDu3QiPkb/PXMXGxhKwAwAAAIBionv37iYBu1WrVikiIuK+p6jll2vXrqlt27Y6f/68sa98+fLavn27KleuXCg1WML+/ftN2sOGDTN77qlTp/K7nDyrVq2aLly4IElKTU3VP//8o8cff9zs+cePHy+o0gpF3bp1TdpHjhxRp06dzJ5/9OjRfK4of1WsWFG+vr7y9fXV+fPn1bt3bx08eFDSnZDd9OnTtWzZsnzdMy0tzbiHJDVs2NDscJ1k/u+TunXrauvWrcb2kSNHMr2fOTH3vatatapJOzAw0Ow9gIcZATsAAAAAgMX9cnSpTl85oTdbDDX2lfF0UTkvwk8AAAAAAEAaPHiwJk2aZLzSMikpSVOmTNHUqVMLfO+oqCi1a9fO5ApId3d3bd261SLX1Bame0+vk6TatWubPXfHjh35XU6ePf300woICDC2d+3aZXbALiUlRXv37i2gygpHkyZNTNrr16/X2LFjzZ6/du3a/C6pwHh5eWnp0qWqWbOmse/333/PcqyVlZVJOz093ex9IiIiTK6vzs3vkbNnzyo8PNyssVm9d6+88opZc1NTU7Vhwwaz9ylRooTxCuV9+/YpMTFRDg4OZs0HHlZW9x8CAAAAAEDBO3HlhMatH23pMgAAAAAAQBHk5uamQYMGmfR9/fXX+vPPP/O89m+//Zbta/Hx8erYsaPJyWXOzs7avHmz6tevn+e9i7qMQaPbt2+bNe/q1atatWpVQZSUJ61btzZp//jjj2bP3bBhg27cuJHPFRWup59+WuXKlTO29+/fr8OHD5s198CBAyYntRUHNWrUMHne7N4/Jycnk/bdcJk5HvT3iCTNmTPH7LHt27eXvb29sb1mzRqzw3krV67UlStXzBprZ2en559/3thOSEjQokWLzK4TeFgRsAMAAAAAFBmxSTGafniapcsAAAAAAABF0Pjx4+Xt7W1sp6amqlu3bjpx4sQDrZecnKxRo0bprbfeyvL1xMREdenSxSTE5+joqPXr16tx48YPtGdxU758eZN2dieAZfT2228rKSmpIErKEx8fH3l6ehrbBw8e1MqVK+87Lzk5WaNHF/8fDLW1tdXAgQNN+oYOHarExMQc5926dUtDhgwpyNIKxO3btxUbG2tsu7m5ZTnO2dlZ1tbWxnZISIjZe5QuXVo2Nv93eeT+/ftNTrTLztGjR3MVsCtTpoy6d+9ubN+6dUvDhg1TWlpajvOuX7+uUaNGmb2PJL3//vsm7U8++cR4tTLwqCJgBwAAAADIkyV//mDSHr5yWK7+l1G60vXv5UPu+409AAAAAADwaHF1ddWyZctka2tr7Lty5YpatWql//73v7m61nHXrl1q3LixvvrqqyznpaSkqHfv3tq5c6exz87OTqtXr9azzz6btwfJwoABA2QwGIz/GzBgQL7v8SCaN29u0p48efJ9T3EbN26cli9fXpBlPTBra2v9+9//Nul78803dfLkyWznpKen64033tDp06cLurxC8c4778jd3d3YPnjwoLp27apr165lOf7q1avq3Lmzjhw5IoPBUFhlZrJ06VJ98cUXioqKMnvO7NmzdevWLWP7qaeeynKcra2tatWqZWwfPXpUQUFBZu1hbW2tpk2bGtuXL1/WV199leOcwMBAde3aVcnJyWbtcddHH30kOzs7Y3vt2rXy8/NTXFxctvu0b99eYWFhuXrvnnvuOfn4+Bjb169fV/v27fXPP/+YvUZaWpp+/fVXffDBB2bPAYoym/sPAQAAAAAge0E3AvN9TYPBoNOhSSrnlSgHB4d8Xx+PtrDgGHV/10fLDiySw3E+XwAAAABQnDRp0kQLFy7U66+/bjy5KSoqSv3799f06dM1aNAgdezYUVWqVMk099y5c1q3bp1WrFihP/74I8d93nzzTa1fvz5Tn7W1tbZt25armuvVq6cKFSrkak5R0apVK3l5een8+fOSpLCwMLVo0UKzZs1S27ZtjaGd9PR0/fHHH/rkk0+MX586deoUyVDau+++q//85z/6+++/Jd35/DRv3lyTJk2Sn5+fnJ2djWMPHDggf39/7dq1S5Lk7e2t0NBQS5Sdb8qWLatvv/1Wr776qrFvy5Ytql27tvr27auWLVvK3d1dERER+v333/W///1PMTExkqTBgwdr3rx5Fqn72rVrGjNmjCZOnKiOHTuqZ8+eat68uby8vDKNPXv2rGbMmJHphLg333wz2/Xbt29v/Lympqbqueee07/+9S81aNBAJUuWNAmoZfw9/dprr2nv3r3G9ujRo3X9+nX5+/urbNmyxv4bN25oyZIl+uyzzxQTEyODwaBatWrpzJkzZn0N6tatq48++kgfffSRse+nn37S9u3b1b9/fzVu3FjOzs66du2aduzYoeXLlxt/iDm3792PP/6oxo0bKywsTJJ05swZPfXUU3rzzTc1cOBANWjQIFNoLyoqSocPH9aGDRu0cuVKhYWFqVWrVmbvCRRlBOwAAAAAAEVOenq67GwMhOtQIG7Fp8izVnldjDpv6VIAAAAAAA/Az89PLi4u8vPzM7n+8eDBgzp48KAkyd3dXR4eHnJxcVFERIQuX76smzdvZrleVuG3e0+uu2v27NmaPXt2rutdtGhRkTmRLrdsbW01bdo0vfzyy8a+s2fPqn379nJzc1O1atWUmpqqCxcuKDIy0jimXLlymj9/vp577jlLlJ0jOzs7/fe//1Xr1q2Np6HFxcVp+PDhev/991W1alU5OTkpLCzM5FS3Bg0aaMiQIRo2LPONDMWNr6+vQkNDTYJa0dHRmjdvXrYhrG7duun99983ef3eq1ELy82bN7Vy5Urj1b6urq4qX768XF1ddfv2bYWFhen69euZ5vXt21fdunXLdt1hw4Zp/vz5xkDapUuXNH78+CzHZvw9PXDgQM2dO1dHjx6VdOd7m1999ZWmT5+umjVrytXVVREREQoJCVFqaqpx3ujRoxUeHm52wE6Sxo4dq/Pnz+u7774z9t3v1Ly3335bPXr0yNV7V7ZsWW3YsEEvvviiMWR38+ZNffvtt/r222/l4uIiT09PlSpVSvHx8YqMjNTly5fNfg6guCFgBwAAAADIkzEvfCz/De8a2xNe/DxX8z/eMCZT3987T8t32DN5rg3IimNJG505dEFNmzbNc4hzd+zhfKoKAAAAAJAb3bp107FjxzRy5EitWbMm0+uRkZEmga+slC5dWuPGjdNbb71VUGU+FHr37q1JkyZp3LhxJtfp3j2tKqPKlSvrt99+U8mSJQuzzFxp0KCBNm3apM6dO5uE6JKSkrK8BrNOnTrasGFDrk8vLMrGjRunSpUq6d13383x2lWDwaBhw4Zp+vTpmYJgLi4uBV3mfUVHRys6OjrHMW+++Wam0+wyqlWrlv7zn/9o4MCBio+Pz1UNtra2WrNmjdq2batz584Z+9PS0rINz7377ruaOHGiBg4cmKu9DAaDFixYoJo1a2r8+PEmV+BmZGNjo08++UTjxo3LdCKnOe/d448/rsOHD+vVV1/V5s2bTV6LiYkxnmyYk6xOEwWKIwJ2AAAAAIA8yRhQcnVwzdN6Hbw6aeacuQTsUGAqV3PRJ1026+uQefL29s7TWj9M65U/RQEAAAAAcs3b21u//vqrjh49qoULF2rVqlW6cuVKjnOcnJz03HPPyc/PT926dZO9vX0hVVu8jRkzRk8++aRGjx6tY8eOZTnG2dlZb775pj766CO5uLgU+atUmzRpotOnT+vDDz/Uzz//nOUJh6VKldKQIUP0ySefyMnJyQJVFqwBAwbopZde0k8//aTVq1crMDBQ169fl729vapVq6bWrVvrjTfe0OOPPy5JmUKrhRmwGzx4sKpVq6Z169YpICBAgYGBOY63t7dXp06d9O6776ply5Zm7dGrVy+1aNFCP/74o3bu3Km///5bUVFRSkhIMAmXZqVKlSo6ePCgxo0bp++++854El5GzZo106effqr27dubVVNWDAaD/P391a9fP/34449av369QkJCFBERIScnJ9WsWVNt27bVv/71L1WtWlXSg793Hh4e2rRpk/bs2aNp06Zpx44dSkhIyLG2hg0bysfHR/379zd+doDizpB+vz8F8Mg7deqU6tevb2yfPHlS9erVs2BFAIDi4ovuH+vMvlOq3byeRq+eYOlygELRYVBHGQwGpaena9P3Gy1dDlBohq/8v6sxZvTM+adBc5o74cXPFX0lWlWrVtUPJz9UOS/3fKsRuOvq+Ui9Xn+yQkJC8hywe+KegN2x91fksTIAAADg0ZKSkmJy0o8k1axZ0yJXDuLhERQUpJMnTyosLExxcXFKT0+Xq6ur3N3dVbduXdWrV0/W1taWLrNYO336tP78809du3ZNKSkpKl26tOrUqaNmzZrJzs7O0uU9kISEBO3cuVPnz59XVFSUXFxcVKdOHbVs2TLPp98/TGbNmqW3337b2F68eLH8/PwsUsv169f1999/Kzg4WJGRkbp586ZKlCghNzc3PfbYY3riiScsFoqMj4/Xnj17FBgYqJiYGDk6Oqpy5cpq1qyZxU50GzVqlMk1sgEBAWrVqlWu10lOTtaBAwcUEhKiGzduKCEhQU5OTnJzc1OtWrVUt27dInGyITIrqP/uelQyRfzXKQAAAADA4gwy6NuesyVJ0Yq2bDEAAAAAAKDYql69uqpXr27pMh5qderUUZ06dSxdRr5ycnLSSy+9ZOkyirzt27ebtBs3bmyhSu6crNaqVasHCokVtJIlS6pjx46WLsPEve+dlZWVGjVq9EDr2NraqkWLFmrRokV+lQYUCwTsAAAAAAAWVcrOWZM6T87UfyM8xgLV4FHAZwsAAAAAACB3QkNDtW7dOmPb3d39oQtaPqz27Nmjo0ePGtuPP/64SpUqZbmCgGKIgB0AAAAAwKIyhuucnZ3l6uYif5+5FqoIjwJXNxc5OztbugwAAAAAAACLSE9Pl8FgMGtscnKy/Pz8lJqaauzz8/OTlZVVQZWHbOTmfZOk2NhYvfnmmyZ9r7/+en6XBTz0CNgBAAAAAIoUd3d3BQUGKzY21tKl4CHm7Owsd3d3S5cBAAAAAABgEY0aNdLo0aPVrVs32dnZZTsuODhYAwcO1O7du4199vb2GjZsWGGUiQzOnz8vPz8/jR49Wu3atZO1tXW2Y48ePapXX31VZ86cMfaVLl1ar732WmGUCjxUCNgBAAAAAIocd3d3wk8AAAAAAABAATl69Kj69OkjV1dX+fj46Omnn5aXl5dKliypuLg4XbhwQQEBAdq4caPJyXWSNHHiRNWoUcNClWP37t3avXu3ypUrpw4dOuipp56Sp6enSpQooZiYGAUFBWn79u3asWNHprnz5s2Tq6tr4RcNFHME7AAAAAAAAAAAAAAAAB5B0dHRWrZsmZYtW2bW+OHDh+vdd9/N8rVt27blZ2mSpIoVK6pu3br5vu7D4OrVq1qyZImWLFly37EGg0FTpkxRr169CqEy4OFDwA4AAAAAAAAAAAAAAOAR4unpqfDwcLPHV65cWRMmTNCAAQOyHdOuXbt8qMyUn5+fFi9enO/rFlcODg4qXbq0IiIizJ5Tp04dTZ06VS+99FIBVgY83AjYAQAAAACKnMjISMXGxlq6DDzEnJ2duYYYAAAAAAA8ssLCwvTHH39o586dOnDggIKCgnTp0iXFx8fLyspKbm5uKlu2rJo1a6YXXnhB3bp1k52dnaXLfuSVL19eV65c0a5duxQQEKDDhw8rKChIV69eVUJCgmxsbOTu7q4KFSqoRYsWateunTp16iQrKytLlw4UawTsAAAAAAAWNWLlW/q252xjOzIyUtVrVFN0VIwFq8LDztXNRUGBwYTsAAAAAADAI8lgMKh58+Zq3ry5pUtBLtnY2OiFF17QCy+8YOlSgEcGATsAAAAAgEWlK13DVw7T2Bc+VjnX8oqNjVV0VIymbh6qMp4uli4PD6Eb4THy95mr2NhYAnYAAAAAAAD5JD093dIlAECBIGAHAAAAACgSJm2foH5P+qqCVUVJUhlPF5XzIvwEAAAAAAAAAAAsh4AdAAAAAKDI+O+Rn1TNuYalywAAAAAAAAAAAJBEwA4AAAAAkEfHLx41ab+3ekSe1guODdSrs/rnaQ0AAAAAAAAAAID8QMAOAAAAAJAnK479YtJOTkvO85ou5Zx15J8YdeCKWBSAsOAYdX/XR8sOLJLDcQdLlwMAAAAAAAAAKMII2AEAAAAAihyDwSBJSkxMlIMDASjkr1vxKfKsVV4Xo85buhQAAAAAAAAAQBFHwA4AAAAAkCdNvJppy5lN+bpmyu0UPd2gNOE6FAjHkjY6c+iCmjZtmufP2O7Yw/lUFQAAAAAAAACgKCJgBwAAAADIk5fqdzEJ2M3oOSdX84evHGbSLmlTSl/0mqqnT36YL/UBGVWu5qJPumzW1yHz5O3tnae1fpjWK3+KAgAAAAAAAAAUSVaWLgAAAAAAgLsaVmyofz0x1NJlAAAAAAAAAAAASOIEOwAAAABAEdHvSV89U625QkNDLV0KAAAAAAAAAACAJAJ2AAAAAIAiYOwLH6uca3mTvhvhMRaqBg87PlsAAAAAAAAAAHMRsAMAAAAAWNSMnnNM2s7OznJ1c5G/z1wLVYRHgaubi5ydnS1dBgAAAAAAAACgiCNgBwAAAAAoUtzd3RUUGKzY2FhLl4KHmLOzs9zd3S1dBgAAAAAAAACgiCNgBwAAAAAoctzd3Qk/AQAAAAAAAAAAi7OydAEAAAAAAAAAAAAAAAAAABRFBOwAAAAAAAAAAAAAAAAAAMgCV8QCAAAAAIqcyMhIxcbGWroMPMScnZ25hhgAAAAAAAAAcF8E7AAAAAAAFjV/z2wNfvYtYzsyMlLVa1RTdFSMBavCw87VzUVBgcGE7AAAAAAAAAAAOSJgBwAAAACwqFPXTmnMug/0eecpkqTY2FhFR8Vo6uahKuPpYuHq8DC6ER4jf5+5io2NJWAHAAAAAAAAAMgRATsAAAAAgMXF347TyJX/1jc9Zxn7yni6qJwX4ScAAAAAAAAAAGA5VpYuAAAAAAAASUpTmoavHKboxGhLlwIAAAAAAAAAACCJgB0AAAAAoIj54dQCeTWubOkyAAAAAAAAirQBAwbIYDAY/xcaGprt2NDQUJOxAwYMKLQ6c7J48WKTuhYvXmzpkgAAyIQrYgEAAAAAefL55gkm7eErh+V5zc4fvKiQ8HiuiEWBCAuOUfd3fbTswCI5HHewdDkAAAAAgHwUEhKikydPKiwsTLGxsUpLS5Obm5vc3NxUp04d1a9fX9bW1g+0dnh4uE6cOKHQ0FBFR0fL2tpabm5u8vb2VtOmTVWqVKl8fhoAAFAUELADAAAAAORJYkpivq9pMBgUHZeqxMREOTgQgEL+uhWfIs9a5XUx6rylSwEAAAAA5IMTJ05owYIFWr16tcLDw3McW6JECbVo0UK+vr7q2bOnnJycsh2bkJCg9evXa+PGjdq+fbsuXryY7Vhra2u1atVKI0aMUJcuXR74WQAAQNFDwA4AAAAAkCelS3goOjE6X9dMT0+XVwUHwnUoEI4lbXTm0AU1bdo0z5+x3bGH86kqAAAAAEBuXbhwQe+8845WrVpl9pybN29q69at2rp1q95++219+OGHeueddzL9/8MvvvhCkyZNUkJCglnrpqamaseOHdqxY4c6dOigRYsWqXz58rl6HhQsb29vnT9/54ftvLy8crxSFw8H3nMA+YWAHQAAAAAgT0a0ecfkWtgZPefkan5WV8rOenWefjj0YZ5rA7JSuZqLPumyWV+HzJO3t3ee1vphWq/8KQoAAABAno3s/bmlS3hofLN8jKVLuK/169fL19dXMTExWb7u5uYmDw8Pubi46MaNG7p69apu3rxpMiY2NlZjxozRqlWrdPDgQZPXDh8+nGW4zmAwqHz58ipXrpwMBoPCwsJ048YNkzGbNm1Sy5YttWfPHlWoUCGPTwoAACzNytIFAAAAAABwl5Ws9O5T/lL+3zoLAAAAAAAeEj///LO6deuWKVz31FNPac6cOQoNDVVkZKTOnDmjAwcOKDg4WAkJCfrnn380ZcoUPfXUUybzrl+/nuN+jo6Oeu2117Ry5Updv35dly5d0pEjR/TXX3/p2rVrOnjwYKZrYYOCgtS1a1elpaXlz0Pnkbe3t9LT043/W7x4saVLAgCg2CBgBwAAAAAoEkrZOeubnrMsXQYAAAAAACjCDh06pNdff12pqanGPhcXF/3nP//RwYMHNXToUHl5eWU5t3bt2vL399ehQ4e0atUq1a5dO8e9PDw89NVXX+ny5ctasmSJevToodKlS5uMMRgMaty4sdasWaOJEyeavHbw4EEtWbLkAZ8UAAAUFQTsAAAAAAAWV8ejjiZ1nmzpMgAAAAAAQBEWGxurPn366Pbt28a+smXLKiAgQL6+vjIYDGav1b17dx0/flyDBg3K8vXBgwcrODhY7777rlxcXMxac+zYserevbtJ33fffWd2TQAAoGiysXQBAAAAAIBH28sN+6tl9ZaZ+m+Ex2QxGsg7PlsAAAAAUDyNHz9ewcHBxraVlZV+/fVXNWzY8IHWs7Oz03fffadVq1Zleq1du3YPtObo0aO1evVqY3v//v2KjY2Vs7PzA60HAAAsj4AdAAAAAMCiMobrnJ2d5ermIn+fuRaqCI8CVzcX/nEDAAAAAIqR6OhoLVy40KRv5MiReuaZZ/K8do8ePfK8xl2NGzeWo6Ojbt26JUlKS0vTxYsXVbdu3Xzbw1LCw8O1d+9eXbp0Sbdu3ZKHh4caNmyop556KlenB+ZGWlqaDhw4oGPHjikiIkJOTk6qUKGCnnvuOZUvX75A9ixKIiIitG/fPoWHhysyMlJlypRRkyZNzAqVBgYGav/+/bp06ZIMBoMqVqyo1q1by9PTM081hYSE6NSpU7pw4YJiYmJkY2Mjd3d3eXl5qVmzZipZsmSe1peks2fP6tixY7p8+bLi4uJkY2MjJycneXp6qnr16qpbt65sbAo/7nL+/HkdOXJEFy9eVGxsrAwGg/EzWa1aNdWrV08ODg6FXheAgkfADgAAAABQpLi7uysoMFixsbGWLgUPMWdnZ7m7u1u6DAAAAACAmebPn6/4+Hhj287OTqNHj7ZgRVkzGAxycXExBuwkKSbG8ieph4aGqmrVqsa2n5+fFi9ebNbcgwcPatSoUdqzZ4/S09Mzve7t7a1x48YZr9sdMGCAlixZYnw9JCRE3t7euao3LS1Nc+fO1eTJk3Xx4sVMrxsMBrVv315ffvml6tevn+06GWu56/z58zmGAnPz9cmL1q1ba9euXcb23a/vP//8o48//lhr1qwxuRL5rieffFKzZ8/OMmC6c+dOjRkzRvv378/0msFgUOfOnTVz5kxVqVLFrBoTExO1YcMGrVq1Sjt27NCVK1eyHWttba0XXnhBo0ePVuvWrc1a/66kpCR98803WrhwoYKCgnIc6+joqGeeeUa9e/fWkCFDTF7L7/c8LS1N3333nWbPnq3jx4/nWJednZ2eeuop9ezZU8OGDZOjo2OO4wEUHwTsAAAAAABFjru7O+EnAAAAAABglPEa1+7du6tMmTIWqiZ7ycnJun79uklf6dKl7zsvYyiosAJe9zN58mSNHTtWaWlp2Y4JDQ3VG2+8oc2bN+unn37K856xsbHq0aOHtm/fnu2Y9PR0bd68WXv27NGqVavk4+OT532LijVr1qhfv34mIc2Mjhw5olatWmnZsmXq3r27sf/TTz/Vp59+mmUQUrrzdVu7dq0OHDiggIAA1a5d+771tGzZUocPHzar9tTUVG3ZskVbtmzRW2+9pW+++cask+YuXLggHx8f/fPPP2btc+vWLe3YsUM7duzQG2+8UWCn2UVFRalz587au3evWeNv376tP/74Q3/88Ye6du2qGjVqFEhdAAofATsAAAAAAAAAAAAAQJGVkJCgv/76y6Sva9euFqomZ/v27VNqaqqxbW9vb/ZJYUXNtGnTsjwl0NXVVV5eXkpPT9f58+eNJ/QtX75crq6uedozOTlZL730kvbs2WPsK1u2rCpVqqSUlBQFBQUpISHB+NrNmzfVq1cvnTx5Ul5eXnnauyjYu3evXn75ZeOpdQ4ODqpataqcnJx0/vx5k/BmcnKyfH19dfToUdWsWVOTJ0/W+PHjja+7uLjIy8tLVlZWCgwMNDkB8sqVK+rRo4eOHj0qW1vbHGtKTEzM1FexYkW5u7urZMmSSkhIMF4Xe6/Zs2fr5s2b+uGHH3Jc/9atW2rbtq3OnTtn0m9lZaXKlSurTJkysra2VmxsrC5evGjyHAUpPT1dXbt2zRSuMxgMqlChgsqXLy9bW1vFxcXp0qVLio6OLpS6AFgGATsAAAAAQJETGRnJFbEoUFwRCwAAAADFx/79+5WSkmLS17hxYwtVk7OMYaLnn39eDg4OFqrmwR08eDBTuK5+/fr68ssv1bZtW1lbW0u6c2LZ1q1bNWrUKJ06dUoLFy40uYo2tyZPnqzg4GBJ0iuvvKIPPvhAjz/+uPH1pKQkLV26VCNHjjR+7yg+Pl7+/v5atmxZpvX8/f3l6+srSfL19dXVq1clSeXKlcvxtL2KFSs+8DPkha+vr27fvq2KFSvq888/V+/evVWiRAlJdwJfW7du1ZtvvqkLFy5IuhMwHDNmjEaOHKmxY8dKkp5++ml98cUXat26tfF9SkpK0g8//KB33nlHSUlJkqS///5b8+bN09tvv33fuqpUqaLevXurU6dOaty4sZydnU1eT09P14kTJzRv3jwtWLDAGDJdtGiROnfubHLKXkazZs0yCdd5eHho0qRJ6tWrl9zc3DLtExwcrG3btmnVqlXaunVrpvXy6z1fsWKFSdDTyclJ48eP16uvvqpy5cplmh8WFqadO3dqzZo1Wrt2bbb7ACieCNgBAAAAACzqavQVlXMtb2xHRkaqeo1qio6KyWEWkDeubi4KCgwmZAcAAAAAxUDGayNLlixZJK9ePH78uH7++WeTvgEDBlimmDwaMmSIyUl8zz//vDZs2JApLGhtba0OHTqoVatW6tixo3bt2qWQkJAH3jc4OFgGg0ELFizQG2+8kel1e3t7DRw4UDVq1FDr1q2NV9euXr1a169fl4eHh8n4unXrqm7dupJkUruDg4Patm37wHUWlNDQUNWuXVs7duzIFPgyGAxq3769tm7dqgYNGhiDcqtXr9axY8eUlpamXr16aenSpZlOpbO3t9fQoUPl6OiogQMHGvu///77+wbs5s6dq+bNmxvDelkxGAxq0KCB5syZo+7du6tz587G+iZPnpxjwG758uUmde7evVuPPfZYtvtUr15d1atX1+DBg/XPP/9kqiu/3vN765KkdevWqU2bNtmOr1y5sl577TW99tprCgsLyxQOBFC8EbADAAAAAFjUpO0T9HLD/mpZvaUkKTY2VtFRMZq6eajKeLpYuDo8jG6Ex8jfZ65iY2MJ2AEAAABAMRAZGWnS9vDwkMFgsFA1WUtKStKAAQNMQmmNGjVSr169LFjVg9m7d6/JlbylS5fW8uXLczyJz9HRUStWrFCtWrUUFRWVp/2HDx+eZbjuXs8++6x69+5tPLUuOTlZ27dvV9++ffO0t6XZ2trql19+yfEEvVq1amngwIGaN2+epDunCJ47d041atTQkiVLcrzy1c/PT5MnT9aZM2ckSceOHdPly5dVoUKFbOc8++yzuXqGdu3a6f3339fEiRMlSQcOHNDff/9tDL1ldPbsWeOv27Rpk224Liu5GZtb99b12GOP5Riuy6hy5coFURIACyJgBwAAAACwuF+OLtXpKyf0Zouhxr4yni4q50X4CQAAAACAR13GgJ2rq6tlCsnB8OHDdeTIEWPbxsZGCxculJWVlVnzFy9erMWLFxdQdbnz448/mrTff/99s35ArUyZMho1apTxqtIH4ejoqI8++sissX369DG5Fvavv/4q9gG73r17q0GDBvcd16VLF2PA7q4PP/zQeJ1sdgwGg7p06aJp06YZ+44cOZJjwO5B+Pr6GgN2krRv375sA3a3bt0y/jqncGBhK6p1AbAM8/42BwAAAACggJ24ckLj1o+2dBkAAAAAAKCIiYuLM2k7OTlZqJKszZw5UwsWLDDpmzhxoho1amShivLm999/N2n379/f7Lm+vr552rtt27YqXbq0WWMbNmxo0g4LC8vT3kVB7969zRpXv359k7bBYFCPHj3Mmvv444+btC9cuGBecblQtWpVk/a94dOM7j2tb/fu3QVSz4O4t66///47x2cA8PAjYAcAAAAAKDJik2I0/fC0+w8EAAAAAACPjFKlSpm0ExISLFRJZqtXr9bIkSNN+vr06SN/f3/LFJRH8fHx+ueff4ztypUr5+q6yypVqsjT0/OB92/cuLHZY8uWLWvSjomJeeB9i4qnnnrKrHEZQ4hVq1aVm5vbA82NjY01rzjdue51zJgx6tSpk6pVqyZ3d3fZ2trKYDCY/M/e3t5k3o0bN7Jds127dsZfx8TEqE2bNlq+fLmSk5PNrqsg3FtXamqqOnTooO+++043b960YFUALIUrYgEAAAAAebLkzx9M2sNXDsvTeulK17+XD1FiYmKe1gEAAAAAAA+HjNeTFpUgVUBAgPr166e0tDRjX/v27fXjjz/KYDBYsLIHd+XKFZPnqVOnTq7XqFOnjsLDwx9o/4yhuZxkPMnw3is9iysPDw+zxmW8CtbceVnNNefrtmfPHv373//W8ePHzd7nXtHR0dm+9v777+vnn382BteCg4P18ssvy9XVVT4+PmrdurWaN2+u+vXrm33lcn4YMmSIZsyYoatXr0qSrl27pjfffFMjRoxQ27Zt1aZNG7Vo0UINGzbkClngEUDADgAAAACQJ0E3AvN9TYPBoNOhSSrnlSgHB4d8Xx+PtrDgGHV/10fLDiySw3E+XwAAAABQ1GUM2F2/ft1ClfyfQ4cOqUuXLkpKSjL2PfPMM1q1apXs7OwsWFneZAxCubi45HoNV1fXB94/L98HSk9Pf+C5RcWDPn9Bft3mz5+voUOH5unre+/vk4xq1qypFStWqG/fvian6UVHR2vZsmVatmyZJMnNzU1t2rRRr1691K1bNzk6Oj5wPeZwd3fX+vXr1aVLF12+fNnYf/PmTa1du1Zr166VJJUsWVLPPvusevTooV69euXp8w+g6CJgBwAAAAAoctLT02VnYyBchwJxKz5FnrXK62LUeUuXAgAAAAAww2OPPWbSjouLU2BgoGrUqGGRek6dOqUOHTooLi7O2PfEE0/ot99+y3SqWnGTMQj1IGHBjNeDovjauXNnpnCdjY2NWrZsqaZNm8rLy0tly5aVg4NDpvf93itW76djx446deqUPvvsMy1dulTx8fGZxkRFRWnVqlVatWqVPDw89NFHH+nf//53gZ4W2bhxY508eVKTJ0/W999/r8jIyExj4uPjtXHjRm3cuFHvvvuu3n33XY0dO5ZT7YCHDAE7AAAAAECejHnhY/lveNfYnvDi57ma//GGMZn6/t55Wr7DnslzbUBWHEva6MyhC2ratGmeQ5y7Yw/nU1UAAAAAgOw0a9ZMNjY2SklJMfYdOnTIIgG7oKAgtWvXThEREca+WrVqacuWLQ/FyVUZT6zLKuh0P/eeQobi7b333jMJ17344ouaN2+eKlWqlOO8nE6sy06lSpU0f/58ff3119q2bZsCAgK0e/duHTt2TKmpqSZjr1+/ruHDh2vXrl1atmyZrK2tc72fudzd3TV16lRNnDhRAQEB2rlzp3bt2qVDhw4pOTnZZGxcXJw+/fRTbdu2TVu2bMl0HS+A4ouAHQAAAAAgTzIGlFwdXPO0XgevTpo5Zy4BOxSYytVc9EmXzfo6ZJ68vb3ztNYP03rlT1EAAAAAgGw5OTmpUaNGOnDggLFv7dq16tu3b6HWERYWphdeeMHkusgqVapo27ZtKlu2bKHWUlAyXsd76dKlXK/xIHNQ9Jw9e1ZHjhwxtuvXr2/2FchZnfRmLicnJ3Xt2lVdu3aVdCew+fvvv2vDhg3673//q6ioKOPYlStX6quvvpK/v/8D72cuOzs7tW/fXu3bt5ck3bp1S/v379dvv/2mpUuXmnzu9+7dq1GjRmnOnDkFXheAwmFl6QIAAAAAALhrwoufq26Z+pYuAwAAAAAAFDHdu3c3aa9atcrkFLmCdu3aNbVt21bnz5839pUvX17bt29X5cqVC62OglahQgW5ubkZ2ydPnjQ5OfB+UlJSdOrUqYIoDYVs//79Ju033njD7CuD8/Mz4OzsrE6dOmn27NkKCwvTwIEDTV6fPn26ySl7hcXR0VFt2rTRtGnTFBoaqrFjx5q8/t1333GaI/AQIWAHAAAAALA4gwya0XNOnk+/AwAAAAAAD6fBgwerZMmSxnZSUpKmTJlSKHtHRUWpXbt2Onv2rLHP3d1dW7dutcg1tQXJYDCocePGxvatW7e0fft2s+dv2bJFiYmJBVFanllZ/V88whKBrOLm6tWrJu3atWubPXfHjh35XY6kO6fbLViwwORGgitXrigwMDDL8YX1ntva2mrixIlq2bKlsS85OVl//vlnge0JoHBxRSwAAAAAwKJK2TlrUufJmfpvhMdYoBo8CvhsAQAAAEDx4+bmpkGDBunbb7819n399dfq2bOnmjZtmqe1f/vtN3Xq1CnL1+Lj49WxY0cdP37c2Ofs7KzNmzerfv2H8xT+Ll26aOvWrcb27Nmz5ePjY9bcWbNmFVRZeebk5GT89c2bNy1YSfGQMZB2+/Zts+YlJSXphx9+KIiSJEk2NjZq2rSpQkNDjX03btxQzZo1M40t7Pe8RYsW+v33303qAvBwIGAHAAAAALCojOE6Z2dnubq5yN9nroUqwqPA1c1Fzs7Oli4DAAAAAJAL48eP15o1a4zBmtTUVHXr1k1btmzR448/nuv1kpOTNXr0aK1cuVIhISGZXk9MTFSXLl1MTqFydHTU+vXrTU55e9j4+vrK399ft27dkiStW7dOK1euVM+ePXOc97///U8bN24sjBIfiLu7u/HXERERiouLU6lSpSxYUdFWvnx5k/bvv/+uLl263HfeRx99lOn0u/yWMbh277XG9yrs99zcugAUPwTsAAAAAABFiru7u4ICgxUbG2vpUvAQc3Z2NvkmKwAAAACg6HN1ddWyZcvUsmVLJScnS7pzPWSrVq00e/Zs9e3bVwaDway1du3apeHDh+v48ePy8vLK9HpKSop69+6tnTt3Gvvs7Oy0evVqPfvss/nzQPcYMGCAlixZYmz7+flp8eLF+b6POVxdXfXee+9p4sSJxr5XXnlFycnJ6tu3b5Zzli5dqtdff13SnWtmi+IVrPXq1dPu3bsl3TmdbeXKlRowYIBliyrCmjdvbtKeN2+e/vWvf+V4LfL8+fP15Zdfmr3H6dOnNWPGDL333ntmX7d88OBBBQQEGNuurq6qVq1almMf9D2PjY3V0KFDNWrUKD355JNm1RUaGqoVK1YY21ZWVmrYsKFZcwEUfQTsAAAAAABFjru7O+EnAAAAAACQSZMmTbRw4UK9/vrrSktLkyRFRUWpf//+mj59ugYNGqSOHTuqSpUqmeaeO3dO69at04oVK/THH3/kuM+bb76p9evXZ+qztrbWtm3bclVzvXr1VKFChVzNsbRx48Zp1apV+vvvvyXdufazX79+mjlzpnr27Knq1asrPT1dQUFBWrlypfHrWb58eTVt2lRr1qyxZPlZat++vebO/b8bE4YOHarDhw+refPmcnd3l7W1tfG1ihUrqm7dupYos8ioUaOGnnnmGeN7GxcXp+eee07ffvutunfvLhub/4ubHDt2TJ9//rl++eUXSVKdOnV0+vTp++6RlJSkefPmacGCBWrZsqV69eqlNm3aqE6dOibvhyRdv35d//nPfzR+/HilpqYa+/38/GRnZ5fl+g/6nqelpWnp0qVaunSpGjdurF69eqldu3aqX79+pr1iY2O1fPlyjRs3TjExMcb+zp07ZzoFEEDxRcAOAAAAAAAAAAAAAFBs+Pn5ycXFRX5+fiYn4B88eFAHDx6UdOeH9zw8POTi4qKIiAhdvnxZN2/ezHK9rMJv955cd9fs2bM1e/bsXNe7aNGiYndSmr29vTZt2qRWrVqZXJ+7b98+7du3L8s5jo6OWrFihRYuXGjSf28Qy5Jeeukl1a5dW2fOnJF05wrgWbNmadasWZnGWvIEwaLkyy+/VOvWrY0nRl6+fFkvv/yySpYsqZo1a8rKykoXL140uRLWyclJP//8sxo1amT2Pmlpadq9e7fxtDlHR0d5enoar1i9du2aLly4kOlkxJo1a+qzzz7Ldt38eM8PHTqkQ4cO6cMPP5SdnZ0qVaokNzc3WVtbKyIiQqGhoSaBP0ny8PDQzJkzzX5+AEWflaULAAAAAAAAAAAAAAAgN7p166Zjx46pa9euWb4eGRmpM2fO6MCBAwoKCsoyXFe6dGlNnz7dGOqBqcqVK2vPnj166aWX7jvW29tbO3bsUIsWLRQfH2/ymouLS0GVmCs2NjZauXKlqlevbulSio3mzZtr4cKFsrW1NemPj4/XkSNHdPjwYZNwnZubm9avX2/2tarZuXXrlgIDA42h2fPnz2cK1z3zzDPas2ePSpUqle06+f2e3759W8HBwTp8+LDxz5aM4brHHntMv//+uypXrpwvewIoGopGVBwAAAAAgHtERkaa/AQ6kN+cnZ25hhgAAAAAijlvb2/9+uuvOnr0qBYuXKhVq1bpypUrOc5xcnLSc889Jz8/P3Xr1k329vaFVG3x5OnpqXXr1mnnzp1aunSpfv/9d4WHhysxMVEeHh5q2LChunfvLl9fXzk4OEi6832du6ysrFSyZElLlZ9JvXr1dPz4cf3yyy/asGGDjh8/rqtXryo+Pj5TUAp3+Pn5qXbt2vrggw+yDaM6ODiof//+mjhxYq6uQ27QoIH27t2rtWvXatu2bTp27JhSUlJynNO8eXMNGTJEvr6+MhgM993jQd5zV1dXHTlyRGvWrNHWrVt16NAhJSUl3fdZ3njjDQ0ZMiRTIBFA8WdIzxjzBTI4deqU6tevb2yfPHlS9erVs2BFAIDi4ovuH+vMvlOq3byeRq+eYOlygELRYVBHGQwGpaena9P3Gy1dDlBohq8cZvz1jJ5zcjV3xMq39G3P/7teJTIyUtVrVFN0VEy+1Qdk5OrmoqDA4DyH7J6Y1sv462Pvr8hrWQAAAMAjJSUlRefOnTPpq1mzZpG5ThLFU1BQkE6ePKmwsDDFxcUpPT1drq6ucnd3V926dVWvXj1ZW1tbusyHmoeHh27cuCHpTgjy3itmUbyFhoZq7969unz5spKSkuTq6qratWurefPmKlGiRJ7XT0hI0KlTpxQUFKSrV68qISFBNjY2cnFxUbVq1fTkk0/Kw8MjH54kd5KSkvT3338rMDBQly9fVnx8vAwGg5ydneXt7a2GDRvK09Oz0OsCcqOg/rvrUckU8V+nAAAAAACLSle6hq8cprEvfKxyruUVGxur6KgYTd08VGU8i8YVIni43AiPkb/PXMXGxnKKHQAAAAA8ZKpXr84VoBZ07NgxY7hOkho3bmzBapDfvL295e3tXWDrOzk5qUmTJmrSpEmB7fEg7O3t9eSTT+b56lsAxRcBOwAAAABAkTBp+wT1e9JXFawqSpLKeLqonBfhJwAAAAAAgOJixowZJu0WLVpYqBIAAPIPATsAAAAAQJHx3yM/qZpzDUuXAQAAAAAA8MhLT0+XwWAwe/ymTZu0aNEiY9vOzk6vvPJKQZQGAEChImAHAAAAAMiT4xePmrTfWz0iT+sFxwbq1Vn987QGAAAAAAAA8mbq1KkKDw/XiBEjcrx2NzU1Vd99951GjBih9PR0Y7+vr688PDwKo1QAAAoUATsAAAAAQJ6sOPaLSTs5LTnPa7qUc9aRf2LUgStiUQDCgmPU/V0fLTuwSA7HHSxdDgAAAAAARdKtW7c0c+ZMzZw5U40bN9Zzzz2nxx9/XGXKlJEkRURE6K+//tK6desUEhJiMrdSpUr66quvLFE2AAD5joAdAAAAAKDIuXv9SGJiohwcCEAhf92KT5FnrfK6GHXe0qUAAAAAAFAsHDp0SIcOHTJrrKenp9avXy9XV9eCLaqAHT58WFFRUfm6pqOjo1q0aJGvawIACh4BOwAAAABAnjTxaqYtZzbl65opt1P0dIPShOtQIBxL2ujMoQtq2rRpnj9ju2MP51NVAAAAAAAULeXLl5e1tbVSU1PNGm9lZaVevXrp66+/lqenZwFXV/Dee+897dq1K1/X9PLyUmhoaL6uCQAoeATsAAAAAAB58lL9LiYBuxk95+Rq/vCVw0zaJW1K6YteU/X0yQ/zpT4go8rVXPRJl836OmSevL2987TWD9N65U9RAAAAAAAUMUOGDFHPnj21adMm7d27VydPnlRoaKiioqKUmJioUqVKyd3dXTVr1lTr1q3VvXt3PfbYY5YuGwCAfEfADgAAAABQZDSs2FDPV2ivLzTV0qUAAAAAAAA88jw8PPTqq6/q1VdftXQpAABYDAE7AAAAAECR0O9JXz1TrTnXZAAAAAAAAMDiAgICLF0CAKCIIGAHAAAAALC4sS98rHKu5U36boTHWKgaPOz4bAEAAAAAAAAAzEXADgAAAABgUTN6zjFpOzs7y9XNRf4+cy1UER4Frm4ucnZ2tnQZAAAAAAAAAIAijoAdAAAAAKBIcXd3V1BgsGJjYy1dCh5izs7Ocnd3t3QZAAAAAAAAAIAijoAdAAAAAKDIcXd3J/wEAAAAAAAAAAAszsrSBQAAAAAAAAAAAAAAAAAAUBQRsAMAAAAAAAAAAAAAAAAAIAtcEQsAAAAAKHIiIyMVGxtr6TLwEHN2duYaYgAAAAAAAADAfRGwAwAAAABY1Pw9szX42beM7cjISFWvUU3RUTEWrAoPO1c3FwUFBhOyAwAAAAAAAADkiIAdAAAAAMCiTl07pTHrPtDnnadIkmJjYxUdFaOpm4eqjKeLhavDw+hGeIz8feYqNjaWgB0AAAAAAAAAIEcE7AAAAAAAFhd/O04jV/5b3/ScZewr4+micl6EnwAAAAAAAAAAgOVYWboAAAAAAAAkKU1pGr5ymKIToy1dCgAAAAAAAAAAgCQCdgAAAACAIuaHUwvk1biypcsAAAAAAAAAAADgilgAAAAAQN58vnmCSXv4ymF5XrPzBy8qJDyeK2JRIMKCY9T9XR8tO7BIDscdLF0OAAAAAAAAAKAII2AHAAAAAMiTxJTEfF/TYDAoOi5ViYmJcnAgAIX8dSs+RZ61yuti1HlLlwIAAAAAAAAAKOII2AEAAAAA8qR0CQ9FJ0bn65rp6enyquBAuA4FwrGkjc4cuqCmTZvm+TO2O/ZwPlUFAAAAAAAAACiKCNgBAAAAAPJkRJt3TK6FndFzTq7mZ3Wl7KxX5+mHQx/muTYgK5WrueiTLpv1dcg8eXt752mtH6b1yp+iAAAAAAAAAABFkpWlCwAAAAAA4C4rWendp/yl/L91FgAAAAAAAAAAINcI2AEAAAAAioRSds76pucsS5cBAAAAAAAAAABgxBWxAAAAAACLq+NRR0Ofe9vSZQAAAAAAAAAAAJggYAcAAAAAsKiXG/ZXy+otM/XfCI+xQDV4FPDZAgAAAAAAAACYi4AdAAAAAMCiMobrnJ2d5ermIn+fuRaqCI8CVzcXOTs7W7oMAAAAAACKtICAALVp08bY/uSTTzR+/Phsx7du3Vq7du0yttPT0wuyPBQh3t7eOn/+vCTJy8tLoaGhli0IRY7BYDD+ulWrVgoICLBcMUAuEbADAAAAABQp7u7uCgoMVmxsrKVLwUPM2dlZ7u7uli4DAAAAAJDPQkJCdPLkSYWFhSk2NlZpaWlyc3OTm5ub6tSpo/r168va2vqB1g4PD9eJEycUGhqq6OhoWVtby83NTd7e3mratKlKlSqVz08DAACKAgJ2AAAAAIAix93dnfATAAAAAAAwy4kTJ7RgwQKtXr1a4eHhOY4tUaKEWrRoIV9fX/Xs2VNOTk7Zjk1ISND69eu1ceNGbd++XRcvXsx2rLW1tVq1aqURI0aoS5cuD/wsAACg6LGydAEAAAAAAAAAAAAAAOTWhQsX1LNnTzVo0ECzZs26b7hOkm7evKmtW7fKz89PFStW1BdffKHExMRM47744guVK1dOffv21ZIlS3IM10lSamqqduzYoa5du6pjx466cuXKAz8XAAAoWjjBDgAAAABQ5ERGRnJFLAoUV8QCAAAAD59LNS1dwcOj4jlLV3B/69evl6+vr2JiYrJ83c3NTR4eHnJxcdGNGzd09epV3bx502RMbGysxowZo1WrVungwYMmrx0+fFgJCQmZ1jUYDCpfvrzKlSsng8GgsLAw3bhxw2TMpk2b1LJlS+3Zs0cVKlTI45MCAABLI2AHAAAAALCoq9FXVM61vLEdGRmp6jWqKToq62+QA/nB1c1FQYHBhOwAAAAAoBj6+eef5efnp9TUVJP+p556SoMGDVKnTp3k5eWVad6ZM2e0Zs0a/fLLLzp8+LCx//r16znu5+joqN69e6tr165q1aqVSpcubXwtPT1dhw8f1meffaa1a9ca+4OCgtS1a1ft379fVlbF92K51q1bKz093dJlAHgI8GcJijMCdgAAAAAAi5q0fYJebthfLau3lHTnp8ejo2I0dfNQlfF0sXB1eBjdCI+Rv89cxcbGErADAAAAgGLm0KFDev31103CdS4uLpo1a5ZeeeUVGQyGbOfWrl1b/v7+8vf31+rVqzV69GidOXMm2/EeHh768MMPNWjQILm4ZP09iv/H3p2HRV3u/x9/DSCL6ACjIO64HHOr1Mx9LffKJc2lTD1aabZYZmbZoqYel8pjplaaoqXVcctd09wtTcxdMxVRwA0FGRBBgfn94c/5MoA4I+AgPB/X1XV533Mv74HPWIfz4r4NBoPq1q2r5cuXa9y4cfrwww+tr+3Zs0fz5s3Tv//973t4pwAAIK8gYAcAAAAAcLr/7V+oYxcO6eXGr1r7ipf2UYnyhJ8AAAAAAMAtZrNZPXr00I0bN6x9AQEBWr9+vWrVquXQWl26dNFTTz2lwYMHa+PGjRleHzhwoIKDg1WkSBG71xw5cqT27t2rZcuWWftmz55NwA4AgAfcg3sWLQAAAAAgXzl04ZA+XPW+s8sAAAAAAAB51KhRoxQaGmptu7i46JdffnE4XHebu7u7Zs+erS+++CLDa61bt3YoXHfb++/b/mxj165dMpvN91QfAADIGzjBDgAAAACQZ5iTYjVl72RnlwEAAAAAAPKYq1evatasWTZ9b731lho2bJjttZ999tlsr3Fb3bp15eXlpevXr0uSUlNTFRERoerVq+fYHnezf/9+HT16VJcuXVJiYqICAgJUtmxZNWnSRF5eXvetjrwiLi5OW7du1dmzZxUTEyMfHx9Vr15djRs3loeHR47tExERoSNHjuj06dOKjY2VJJlMJpUuXVoNGzaUn59ftvc4c+aM9u3bp4iICJnNZhkMBnl7e6tkyZKqWLGiatSoIU9Pz2zv4yxnz57Vn3/+qYsXLyo2NlYmk0mBgYFq3Lix/P39c3y/48ePa/fu3Tp37pxcXV0VEBCgevXqqVq1atleOzIyUjt37tS5c+d0/fp1+fv7q1atWnrssceyvMo6r4mLi9P27dt14sQJXbt2Tf7+/qpYsaKaNWumQoUKOa2uK1euaPv27QoNDVViYqICAwNVpUoVNWrUSC4uOXPW2PHjx3XgwAFFRUVZn8dSpUqpSZMmMpmyd/NKfv8s50cE7AAAAAAA2TJv9xyb9ptLBmdrPYssen3RICUmJmZrHQAAAAAAkH988803io+Pt7bd3d0znBaXFxgMBvn4+FgDdpKsYavcFBcXp4kTJ2ru3Lk6d+5cpmM8PT3Vrl07ffrpp6pZs6Zd627ZskUtW7a0tj/55BONGjUqJ0rOdefPn9e7776rJUuWZPpzJqPRqMGDB+ujjz5S4cKFFRwcbHOd79y5c9WvX787rp+cnKyNGzdq8eLF2rhxo86cOXPHsQaDQQ0aNNDw4cPVqVMnhwJWqampmj17tqZPn66DBw9mOdbd3V2PPfaYunbtqsGDBz8QgcrU1FQFBwdrypQpOnz4cKZjXFxcVK9ePX3wwQd65pln7Fo3LCxMFSpUsLb79u2r4OBgSdKvv/6qkSNHKiQkJNO51apV08SJE+3eK609e/Zo2LBh2r59uywWS4bXg4KC9OGHH2rAgAGSpH79+mnevHnW10+fPq2goCCH971Xo0aN0ujRo63tzZs3q0WLFoqKitLIkSM1f/58JSUlZZhnMpk0cOBAffzxx3YHwdI+982bN9eWLVvuOPZOX5ewsDANHz5cS5cuVUpKSoZ5pUqV0tChQ/XWW2/J1dXVrrrSio+P1+eff6558+bp9OnTmY5xdXVV06ZNNWbMGDVt2tTutfP7Zzm/I2AHAAAAAMiWU5dP5viaBoNBx8KSVKJ8Ir+phxwXHhqrLkPb6uc/58rzIM8XAAAAADwIli5datPu0qWLihcv7qRq7uzmzZuKioqy6StWrNhd56UPk6QNA93N1q1b1b17d126dCnLcYmJifrll1+0cuVKvffeexo3bpxd6z+INmzYoOeeey7LcKPZbNaECRO0cuVKrV+/3uE9evbsqSVLltg11mKx6I8//lCXLl307LPPav78+fL29r7rvJiYGD3zzDPauXOnXfvcuHFDf/zxh/744w916tRJlStXtmues0RGRqpjx47666+/shyXmpqqXbt2qWPHjmrfvr1+/vlnFS1a9J72HD58uCZPzvoGjWPHjqljx44aM2aMPvroI7vXnjBhgkaOHKnU1NQ7jgkLC9NLL72k9evX64cffrB77fvp0KFDatu2rc6fP3/HMdHR0frPf/6jJUuWaP369fclFLh582Z16tRJcXFxdxxz7tw5DRs2TIsWLdKaNWscOmlu1apVGjBgwF3/Lk1JSdGWLVvUrFkzvfLKK5o+fbrc3LKOX+X3z3JBQMAOAAAAAJDnWCwWubsZCNchV1yPT1bpKoGKiLnzb5YDAAAAAPKOa9euZQjgdOrUyUnVZO3333+3OVXJw8ND5cqVy7X9Vq9erW7dumU4oc3T01NBQUEqXLiwwsPDbUJ/KSkpGj9+vC5cuKDvvvsu12pzlq1bt6pTp042pwhK//c18fb2VmRkpC5cuCBJOnLkiDp06KBBgwY5tE9mp+L5+/vL399fRYsWVWJioiIjI3X58mWbMUuXLlVsbKx+/fXXLK+ytFgs6tSpU4ZAjsFgUMmSJRUYGKhChQopLi5O586d09WrVx2q39lOnz6tFi1a6OzZszb9Li4uCgoKkslkUlRUVIaTAdeuXauWLVtqw4YNDl+7O2LECJtwXdGiRVWuXDl5eXnpzJkzGcKxH3/8sWrUqGHXNdKTJ0/O9FRNX19flS9fXhaLRWfOnLGGPhctWiRfX1+H6r8fLl68qBdeeMEmXFemTBkFBgYqOjpaYWFhNgHCf/75R0888YR27NihUqVK5VpdR48eVY8ePawnmRoMBgUFBalYsWKZPie7d+9W27ZttWnTJrvCmN9++60GDx6c4VS8woULq3z58ipatKiio6MVGhpq8/6//fZbXbx4UcuWLbvjyZT5/bNcUBCwAwAAAABkywdPfqzhq4da22OeGu/Q/I9Xf5Ch7+jmY+o9uGG2awMy41XETcdDzqp+/frZDnFuM+/NoaoAAAAAAHeya9cuJScn2/TVrVvXSdVkbc6cOTbtJ554Itd+gTA8PFy9e/e2CXoVK1ZMEyZMUM+ePVWkSBFr/x9//KHhw4drx44dNrU+/vjjDgfL8jKz2azevXvbhOuKFSum//znP+rVq5fN1+TAgQP6+OOPtWLFCh08ePCup5plpnjx4urevbueeuop1atXL9NTFU+ePKk5c+ZoypQp1u/Vb7/9pqlTp+rtt9++49qLFy/W9u3brW1vb2+NGjVKL774okqUKJFhfHh4uDZv3qzly5drxYoVDr+X+yk5OVm9evWyCde5ublp2LBheuONN2yCWqdOndKECRM0e/Zsa9/evXv16quv6qeffrJ7z23btlmv/Kxfv74+/fRTtWzZ0nrymMVi0datW/Xqq6/q77//ts5788031bFjxyxPKNuzZ0+GcF3NmjX12WefqVWrVtarSlNSUrRhwwYNGzZMR44c0axZs2yusc0L3nvvPes10z179tQnn3yiqlWrWl8/d+6c/vvf/+qLL76whtFOnz6tAQMGaO3atblW1+DBgxUfHy+DwaDXX39dw4YNswkvnzp1SuPGjdPcuXOtfSEhIRo+fLhmzpyZ5dq//fabXn31VZvg3DPPPKN33nlHjRs3tvneR0dHa/bs2Ro7dqz1JL3ly5dr0qRJeu+99zJdPz9/lgsSAnYAAAAAgGxJ/0NiX0/fbK3XrnwHTZsxk4Adck3Zij76pON6fXH662xfXzFncrecKQoAAAAAcEdpwy6SVKRIkTx5Xd7Bgwe1YMECm75+/frl2n6DBw+2OemobNmy2r59u8qXL59hbMOGDbV161b169dP33//vbX/nXfeUceOHXP15Kn7afTo0YqIiLC2S5cure3bt2caYnr00Ue1fPlyjRgxQhMnTrSGr+w1cuRI1a5d+64BysqVK2v8+PHq3r27nnzySUVHR0uSPv/8c73xxht3DG4tWrTIpr1y5Uq1bNnyjvuULVtWffr0UZ8+fRQeHu7w6W7309SpU7V7925r293dXcuXL1e7du0yjK1UqZJmzZqlevXq6ZVXXrH2//zzz+rZs6c6d+5s1563v7/9+vXT7NmzraG32wwGg1q0aKFt27apVq1a1pBZZGSkVq9eneWpmYMGDbI5+eyJJ57Q6tWrMzwbrq6uateunZo3b6727dtr69atDj93ue32SXBjx47VyJEjM7xeqlQpTZo0SQ0aNFD37t2t73vdunVatGiRnnvuuVyry2AwaP78+erdu3eG1ytVqqQ5c+bo0Ucf1VtvvWXt/+abb9SvXz/Vr18/03WvXr2q3r17W8N1Li4umjVrlvr375/peJPJpOHDh+vpp59WixYtrKcefvzxx+rbt68CAwMzzMnPn+WC5M7njQIAAAAAcJ+NeWq8qhev6ewyAAAAAABAHnI7kHSbv7//Ha/ic5akpCT169fPJmRTp04ddeuWO7+Ydfz4ca1evdradnFx0eLFizMN16UdM2fOHD388MPWvoSEhLue7vSgSEhIyHDl7YIFC+56QtiECRPUtGlTh/dr2LChQ6cT1qpVS5MmTbK2IyMj9euvv95x/D///GP9c9WqVbMM5KRXtmxZm9P68pKUlBRNnTrVpm/8+PGZhuvSevnllzOctvj55587tHfdunX17bffZgjXpeXv76+PPvrIpi+rk9l27txpc4V1sWLFtGjRoiyfDS8vLy1evDjPBqeefvrpTMN1aT377LN69913bfqmTJmSm2XptddeyzRcl9aQIUPUs2dPa9tisWR43tL6+uuvrddFS9K4cePuGK5Lq3r16goODra2b9y4oa+++irTsfn1s1zQELADAAAAADidQQZ92XVGtk+/AwAAAAAA+U/6gJ2vr69zCsnCm2++qX379lnbbm5umjVrllxc7Pu/5IODg2WxWKz/pA1uZOa7776TxWKxtnv16qV69erddR83N7cMV6HOmjXLZq0H1fLlyxUbG2tt3z4pzB4TJkzIrbJs9OzZ0ybc9fvvv99xbNprbgsVKpSrdd1P69evV3h4uLVdvnx5DRkyxK6548aNU+HCha3tHTt26NixY3bvPWbMGLu+lt27d7dppw3QpTd//nyb9rvvviuTyXTXPYoXL65hw4bddZwzTJw40a5xI0eOlNFotLb/+OMPh74fjvD09NTo0aPtGjthwgSbv3uXLl1qc9rnbSkpKZo2bZq1Xa5cOb3zzjt219ShQwfVrl3b2l6yZEmm4/LrZ7mg4YpYAAAAAIBTFXU3atwzGX+IeTkyNpPRQPbxbAEAAADAgyUuLs6m7e3t7aRKMjdt2jR9++23Nn1jx45VnTp1cm3PrVu32rTtOXHpttatW6tMmTLWq1QvXryof/75Rw899FCO1ni/7dixw6b9wgsv2D23UaNGqlChQq5f1+nt7a2AgACdP39ekmxCmemVKlXKevLV0aNHtW/fPpswz4Mq/bPbp0+fO16Tm57JZFLnzp21cOFCa9+2bdtUrVq1u8718fFR27Zt7d6nXLlyOnv2rCTZBALTS//cPf/883btIUm9e/e+60lx99tjjz2m6tWr2zW2SJEi6tq1q+bOnWvt27p1q13fD0c99dRTdgUXpVuhzebNm2vz5s2Sbp0wumvXrgynJB44cMB6FbB0KwDraACuTZs21s/x33//rcuXL6t48eI2Y/LrZ7mgIWAHAAAAAHCq9OE6o9EoXz8fDW+bP64nQd7k6+dj8xu2AAAAAIC8q2jRojbta9euOamSjJYtW6a33nrLpq9Hjx4aPnx4ru2ZlJSk/fv3W9uFChVSkyZN7J7v4uKili1b6vvvv7f27dq164EP2IWEhNi0GzVq5ND8Ro0a3XPA7siRI1q8eLH++usvHT16VDExMTKbzbp582aW8y5fvnzH11q3bq0tW7ZIunXSVrt27TRu3Dg9//zzNqe4PWh2795t037iiSccmv/kk0/aBOx27dqlgQMH3nVenTp17D5RUpICAgKsAbu0JyOmFR8fr7///tvaLlu2rMqWLWv3HuXKlVPp0qUVGRlp95zc1qJFC4fHpw3Y/fnnnxmu8s0J91LX7YCddKuu9AG77du327Tr1q3rcF3lypWzaR87dizDldP59bNc0BCwAwAAAADkKSaTSadOhspsNju7FORjRqPR7t96BQAAAAA4V/r//XansMv9tmXLFvXq1UupqanWvjZt2mj+/PkyGAy5tu+FCxd048YNa7tq1apyd3d3aI1HH33UJmB3O0j0IEsbUvLw8FCFChUcmn8vp24dOnRIr7/+urZt2+bwXEmZXlt526BBg/Tll1/q4sWLkqRLly7p5Zdf1pAhQ9SqVSu1bNlSjRs3Vq1atR6oayfPnDlj037kkUccmv/oo4/atO19dgMCAhzaJ+1JmWmv+EzrwoULNp//e3mGqlWrlqcCdjVr1szW+Nw6BTI36kp/nW36q4HvRforzaX8+1kuaAjYAQAAAADyHJPJRPgJAAAAAABIyhiwi4qKclIl/yckJEQdO3ZUUlKSta9hw4ZaunSpw2E3R8XExNi0019HaI/0c9Kv+SBKG1YzGo0Ohxx9fX0dGr9q1Sp17drVJuzoqLTPT3omk0mrVq1Sx44drVfKSlJCQoJWrFihFStWSLp1TWfTpk317LPPqlu3bg6/j/st7bPm4uLi8M8A7/XZ9fT0dGgfe6QPSPr4+Di8Rl77fhUrVixb47MKjWZHbtR15cqV7JSUqcwC4Pn1s1zQ2H/+JQAAAAAAAAAAAAAA91nVqlVt2nFxcTp58qSTqrl1HWi7du0UFxdn7Xv00Ue1Zs0am1Ovckt8fLxN+172TD8n7Xt5UKUNq91LyNHDw8Pusf/884+6detmE64zGAyqX7++3n77bU2bNk2LFi3SypUrtWHDBpt/SpQoYfc+devW1eHDh/Xuu+/eMYgWHx+vtWvX6uWXX1a5cuU0atSou15N60xpn997uR4zLz276QOSuf3c3Q+Ofk/Sfz/S//2UU3KjrtwIA6Y90TCt/PhZLmg4wQ4AAAAAAAAAAAAAkGc1aNBAbm5uSk5OtvaFhISocuXK972WU6dOqXXr1jYnH1WpUkW//vrrfTttqEiRIjbta9euObxG+jlFixbNVk15gY+Pj/X7ci8hH7PZbPfYESNG2ISr6tWrp3nz5mUIg2bG0ZP1TCaTJk2apLFjx2rLli3avHmztm7dqpCQkAzhm7i4OI0ePVobN27Ur7/+ek8BttxWpEgR6ylfCQkJDs/PS89u+hPrcvu5ux8c/Z6k/36k//spp+RGXek/HxMmTNBjjz3meHFp1KhR446v5bfPckFDwA4AAAAAkOdER0fnuR8uIX8xGo1cQwwAAAAADwhvb2/VqVNHf/75p7VvxYoV6tmz532tIzw8XE8++aTNFX/lypXTxo0bFRAQcN/q8PPzs2nfyzWHly9fznLNB5HJZLJ+Lcxms+Lj4x0K+5w7d86ucfHx8Vq9erW1XaJECa1bt87ur+G9Xsfr7u6uNm3aqE2bNpKk69eva9euXVqzZo0WLlxoU//OnTs1bNgwzZgx4572yk1+fn7WgF1qaqpiYmIcev7y0rOb/mdL9j5D2Z2Tm9J/fe8m/d8/uRU0zo260l83XKFCBbVq1crh2hyVXz7LBQ0BOwAAAACAUw1Z8pqmdp1ubUdHR6tS5Yq6GhPrxKqQ3/n6+ejUyVBCdgAAAADwgOjSpYtNwG7p0qW6cuWKihUrdl/2v3Tpklq1aqUzZ85Y+wIDA/Xbb7+pbNmy96WG20qWLCl3d3fr9aR///23bty44dD1lAcOHLBply9fPkdrdIbq1avrxIkTkiSLxaIDBw6ocePGds/fv3+/XeP++usvm6the/XqZXfI6+TJkxmuFb1XXl5eatmypVq2bKnx48dr9OjRGjdunPX12bNna8KECTIajTmyX04pX768wsLCrO0DBw6oRYsWds/PS89uyZIl5efnZw1NHj58WMnJyXJzsy+Kk5ycrCNHjuRmiQ47fPiwQ+MPHTpk065QoUJOlmN1+PBhtWzZ0u7x9tSVvs9ZV48/qJ/lgoaAHQAAAADAqSyy6M0lgzXyyY9VwjdQZrNZV2NiNWn9qype2ufuCwAOuhwZq+FtZ8psNhOwAwAAAIAHxMCBAzVu3DjrFYxJSUmaOHGiJk2alOt7x8TEqHXr1vrnn3+sfSaTSRs2bHDKNbXu7u6qXbu2du/eLUm6ceOGduzYoSeeeMKu+RaLRVu2bLHpa9CgQU6Xed/Vq1dPy5cvt7ZXrVpld8AuJiZGO3bssGvsxYsXbdoPPfSQ3TVu2rTJ7rGOKFSokMaOHautW7da38fNmze1e/dutW7dOlf2vFcNGjTQ1q1bre1NmzY5FLBL/zV05rNrMBhUt25dbdiwQdKtk8h+++03tW3b1q75v/76qxITE3OzRIel/d7cy/h69erlZDk2+7zxxhsOjU8rs7rSB/Y2bdqkDz744N4KzCEP0me5oCFgBwAAAADIE8b9Nka9avdWSZdSkqTipX1UojzhJwAAAAAAcOsayAEDBmjq1KnWvi+++EJdu3ZV/fr1s7X2mjVr1KFDh0xfi4+PV/v27XXw4EFrn9Fo1Pr161WzZs1s7ZsdzZs3twbsJCk4ONjugN2GDRsUHh5ubZcsWVJVqlTJ8Rrvt2eeeUYjR460tufNm6cPP/xQ3t7ed507a9Ysu0+Ws1gsNu20p9ndbd7MmTPtGnuvGjdubBMUdPRazfuhefPmmjhxorX9ww8/6OOPP7br1LeYmBgtW7bMpq9Zs2Y5XqMjOnbsaA3YSdL06dPtDth99dVXuVXWPdu7d6+OHj2q6tWr33VsfHy8lixZYtPXvHnzXKlr9erVio6OtuuXZc+cOWMTsPPw8Mg0iFmvXj2bEwg3bdpk93vPbQ/CZ7mgcXF2AQAAAAAA3Pbjvh/0y4mlzi4DAAAAAADkQaNGjVJQUJC1nZKSos6dO2e4CtBeN2/e1LBhw/Taa69l+npiYqI6duxoE2Tz8vLSqlWrVLdu3XvaM6cMGDBABoPB2l6wYIH27t1713kpKSkaPny4Td9LL72U4/U5w8MPP2wTojl//rxGjBhx13knTpzQ2LFj7d4nMDDQpm3vyXczZ860+xrae5U+hGPv1bX3U5s2bVSuXDlr+/Tp03YHzT766CMlJCRY202bNlXVqlVzvEZH9O7dW15eXtb2ypUrM4TOMvPTTz9p7dq1uVnaPXvvvffsGjdu3DiZzWZru0GDBqpWrVqu1JSYmKhPPvnErrEjRoxQamqqtd2lSxf5+vpmGFeoUCG99dZb1rbFYtHAgQN18+bN7JabbQ/CZ7mgIWAHAAAAAMiWgxH7bdrvLBvi0D/phZpP6sWvnr9P1QMAAAAAgAeFr6+vfv75ZxUqVMjad+HCBTVv3lw//vhjhpPFsrJ161bVrVtXn3/+eabzkpOT9dxzz2nz5s3WPnd3dy1btkxNmzbN3hvJRL9+/WQwGKz/9OvXL8vxVapU0dNPP21tp6amqmvXroqIiLjjHIvFopdeekkHDhyw9nl7e2vQoEHZrj+v+PTTT23aX331lYYPH37HU+b++usvtWrVSnFxcTaBxaw89thjcnd3t7aXLl2q33//Pcs5q1at0tChQ+1aX5LMZrNeeOEF7du3z+45YWFhWrx4sbXt4uKiWrVq2T3/fnF1ddWQIbY/ExwxYoR+++23LOfNmTNHM2bMsOl75513crw+R/n6+mao44UXXtBPP/10xzkLFy60fsbtfe7up1WrVmn8+PFZjlm2bJkmT55s05c2rJYbpk+frgULFmQ55ssvv7T52hsMhgzPW1pDhgxRiRIlrO0dO3aoW7duio2Ntbuua9eu6csvv9R3332X4bX8/FkuaLgiFgAAAACQLYsP/M+mfTM1+7/h51PCqH1/x6odV8QiF4SHxqrL0Lb6+c+58jzo6exyAAAAAAAOqFevnmbNmqX+/ftbTyiKiYnR888/rylTpmjAgAFq3769zQlZt504cUIrV67U4sWL9ccff2S5z8svv6xVq1Zl6HN1ddXGjRsdqrlGjRoqWbKkQ3PsMWPGDG3fvl1Xr16VdOtaxNq1a2vixInq0aOHzdWou3bt0nvvvadt27bZrPHZZ5+pVKlSOV6bs7Rq1UoDBgywCbpMnjxZS5Ys0QsvvKCHH35YhQsXVmRkpNavX6/ly5crJSVFLi4ueumll/Ttt9/edQ9vb2917dpVP/74o6RbpwK2b99ekydPVp8+feTp+X8/azhx4oSmTJmib775RqmpqQoICFBKSoquXLmS5R6pqalauHChFi5cqLp166pbt25q3bq1atasaRPuk24FeBYtWqQPP/zQJhT0zDPPZDhtL68YMmSI/ve//1lPh0xKSlL79u317rvv6vXXX7f5vISGhmrixImaNWuWTRi2R48e6tSp032vPTMffvihli5dqqNHj0q69X569eqladOmqWvXrqpUqZIsFotOnTqlJUuWWP/+CQwMVP369bV8+XJnlm+jfPnyOnPmjEaOHKnDhw/rk08+0UMPPWR9/fz58/rvf/+rzz//XCkpKdb+Nm3aqEePHrle14svvqjdu3fr3XffVdmyZa2vh4aGaty4cZozZ47NvJdffjnT62Fv8/Hx0aJFi/Tkk09aT65bsWKFatSoobffflvPPfdcpv8+CQ8P1+7du/XLL79o5cqVMpvNmZ6wl98/ywUJATsAAAAAQJ5z+zc3ExMTbX4oCeSE6/HJKl0lUBExZ5xdCgAAAADgHvTt21c+Pj7q27evzfWEe/bs0Z49eyRJJpNJ/v7+8vHx0ZUrV3T+/HmbqyXTyiz8lvbkutumT5+u6dOnO1zv3Llz73oi3b0oU6aMfvjhB3Xt2lVJSUmSbl0rOGDAAL3++uuqUKGCvLy8FB4erkuXLmWY379//3x1et1tM2bM0Llz52yu3wwNDc1wul1akydPlslksgnYubndOU7x6aefavXq1dbnz2w2a+DAgRoyZIiqVKkiDw8PnT9/3uZEQVdXVwUHB+vVV1+9a8AurZCQEIWEhGjEiBFyd3dXmTJl5OfnJ1dXV125ckVhYWE2QSdJ8vf317Rp0+ze435zdXXVwoUL1bJlS509e1bSrSubx48frwkTJqhChQoymUyKiopSWFhYhvl16tTRzJkz73PVd+bh4aF169apefPmOn36tLX/999/v+Pphl5eXlq8eLFmzZpl05/Vc3c/TJw4UUOHDtW5c+f0448/6scff1S5cuVUokQJxcTEKDQ01Ob6VelW+C2z09ty0owZM9SzZ0/FxcVp2rRp+uqrr1ShQgUVK1bsjs9J7dq1M5yyl5mmTZtq/vz5+ve//63ExERJUmRkpIYNG6Zhw4apZMmSCggIkIeHh2JjY3Xp0iXFxMQ4/B7y42e5ICFgBwAAAADIlnrlG+jX4+tydM3kG8l6/JFihOuQK7yKuOl4yFnVr18/28/YNvPeHKoKAAAAAOCIzp0768CBA3rrrbcyPf0pOjpa0dHRWa5RrFgxffjhh3rttddyq8xc99RTT2n9+vXq3r27TYju+vXr1tO00nN1ddXw4cPvegXkg+r2Vb4ffvih/vvf/yo5OfmOY729vTV16lQNGDBAX331lc1rPj4+d5xXqVIlLVq0SF27dlV8fLy1PzExUQcPHsww3tPTU8HBwWrfvv09vKP/c+PGDYWGhmY5pmrVqlq+fLnN6V55UcWKFbVz50516tRJf/31l7U/NTVVp06d0qlTpzKd1759e/38888qWrTo/SrVLmXLltX27ds1aNCgDKdfphcUFKQff/xRDRo00JQpU2xey+q5ux9KlCih9evXq23btjp37pwk6ezZs9YgZHqVK1fW+vXrVaZMmVytq3r16lq+fLk6d+4ss9ksi8Wi0NDQO34eHn/8ca1du1ZGo9Gu9Xv27Kl//etfev755/XPP//YvHb+/HmdP38+y/murq4OnQaanz7LBQUBOwAAAABAtjxds6NNwO7LrjMcmv/mksE27SJuRfWfbpP0+OEROVIfkF7Zij76pON6fXH6awUFBWVrrTmTu+VMUQAAAAAAhwUFBemXX37R/v37NWvWLC1dulQXLlzIco63t7eaNWumvn37qnPnzvLw8LhP1eae5s2b6+TJk5owYYKCg4OtoZj0PD091a5dO40ZM0YPP/zwfa7y/vLw8NDkyZM1YMAAzZ8/X+vWrVN4eLhiYmLk4+OjatWqqV27dnr55ZdVokQJScoQyLxb0KlNmzbas2ePhg8frpUrV2Y6xs3NTZ07d9a4ceNUpUoVu+v39fXVvn37tHz5cm3YsEEhISHWUwrv5JFHHtFLL72kQYMGqVChQnbv5UxlypTRnj17NHfuXE2ZMkVHjhzJdJzBYFC9evX0wQcfqGPHjve5SvuVLl1aK1eu1ObNm7Vw4ULt2LFDkZGRSkxMlL+/v2rVqqUuXbqod+/e1l/6TPvcubi4qEiRIs4q36pmzZrav3+/PvjgA33//feZPnt+fn565ZVX9Mknn8jLy+u+1NWyZUsdOHBA7777rpYtW5bhtDfp1omkb7/9toYOHSpXV1eH1n/sscd09OhRLVy4UDNmzNCePXsy3eM2Dw8PNW7cWB06dNDzzz+f6WmoBeWzXBAYLGkvqQYyceTIEdWsWdPaPnz4sGrUqOHEigAAD4r/dPlYx38/ooca1dD7y8Y4uxzgvmg3oL0MBoMsFovWfbf27hOAfCJtSC47AbtapWrpiZJtVKFCBc05PEIlyptyrEbgtotnotW/5gSdPn062wG7R9ME7A68uziblQEAAAAFS3Jysk6cOGHT969//cvp1+PhwXbq1CkdPnxY4eHhiouLk8Vika+vr0wmk6pXr64aNWo4HLp40Ozfv19HjhzRpUuXlJSUJH9/f5UtW1ZNmjRR4cKFnV1entWtWzctWbLE2g4LC1P58uXtmnv+/Hlt375dERERSkhIkNFoVOXKldWoUSP5+vpmu7akpCQdPXpUJ0+e1Pnz5xUfHy+DwSCj0aigoCDVqlVLpUuXzvY+znb27Fnt3r1bFy9elNlslp+fn0qWLKlGjRopICDA2eXlCn9/f12+fFnSrdBw2itm74dRo0Zp9OjR1vbmzZvVokULa9tsNmv79u06ceKErl27puLFi6tixYpq0aJFroa/+vXrp3nz5lnb6X+Od/nyZW3fvl2hoaFKSkpSQECAHnroITVu3FguLi45UkNsbKx27dqlc+fO6fLly7p586aKFi2qgIAAVa1aVQ899JDDt2M487OcW//dVVAyRfzXKQAAAAAgT+hVu7caVmyksLAwZ5cCAAAAAAAeUJUqVVKlSpWcXYZT1apVS7Vq1XJ2GQ+Umzdvavv27da2v7+/3eE66dapWd27d8+N0iTdOimrdu3aql27dq7tkReUK1dO5cqVc3YZ982BAwes4TpJqlu3rhOryZzRaNRTTz3l7DIyKF68uLp06ZKre/j4+Kht27Y5umZB+SznRwTsAAAAAABON/LJj1XCN9Cm73JkrJOqQX7HswUAAAAAANL66aefdOnSJWu7UaNGTqwGBcWXX35p027cuLGTKgFwNwTsAAAAAABOlf5KWaPRKF8/Hw1vO9NJFaEg8PXzkdFodHYZAAAAAAAgh1ksFhkMBrvHR0REaOjQoTZ9/fv3z+mykM85+tytW7dOc+fOtbbd3d31wgsv5EZpAHIAATsAAAAAQJ5iMpl06mSozGazs0tBPmY0GmUymZxdBgAAAAAAyGHbtm3TF198oeHDh9/1RLAtW7boxRdftLmms0qVKnnySkzkbZMmTVJkZKSGDBmS5TXVKSkpmj17toYMGSKLxWLt7927t/z9/e9HqQDuAQE7AAAAAECeYzKZCD8BAAAAAADAYRaLRStWrNCKFSsUFBSk1q1bq06dOgoMDJSnp6diYmJ07NgxrV+/Xn/++afNXFdXV82fP1+urq5Oqh4PquvXr2vatGmaNm2a6tatq2bNmunhhx9W8eLFJUlXrlzRX3/9pZUrV+r06dM2c8uUKaPPP//cGWUDsBMBOwAAAAAAAAAAAAAAkKtCQ0MVGhqa4+s2adJEnp6emb4WFhamWbNm2bWOu7u75s6dq/r16+dkeXnCxo0bc3zNUqVKqXr16jm+bn4QEhKikJAQu8aWLl1aq1atkq+vb4bXnPGZAZA5AnYAAAAAAAAAAAAAACBXzZ8/X6NHj87xdU+fPq2goCBr28fHR0WKFFF8fLzda9SvX19TpkxRw4YNc7y+vKB169Y5vmbfvn0VHByc4+s+qAIDA+Xq6qqUlBS7xru4uKhbt2764osvVLp06UzH3K/PDIC7I2AHAAAAAMhzoqOjZTabnV0G8jGj0cg1xAAAAAAA5EO1a9dWVFSUNm7cqG3btmnfvn0KDQ1VVFSUrl+/Lnd3dxUrVkxlypRR06ZN1b59e7Vo0cLZZeMBN2jQIHXt2lXr1q3Tzp07dfjwYYWFhSkmJkaJiYkqWrSoTCaT/vWvf6lFixbq0qWLqlat6uyyAdiJgB0AAAAAwKm+2T5dA5u+Zm1HR0erUuWKuhoT68SqkN/5+vno1MlQQnYAAAAAAORDnp6eevrpp/X00087uxQUIP7+/nrxxRf14osvOrsUu40aNUqjRo1ydhkZBAcHc0Ii8hQCdgAAAAAApzpy6Yg+WPmexj8zUZJkNpt1NSZWk9a/quKlfZxcHfKjy5GxGt52psxmMwE7AAAAAADuk7wa5CkILBaLs0vAPeAzA+QdBOwAAAAAAE4XfyNOby15Xf/t+pW1r3hpH5UoT/gJAAAAAAAAAAA4j4uzCwAAAAAAQJJSlao3lwzW1cSrzi4FAAAAAAAAAABAEgE7AAAAAEAeM+fItypft6yzywAAAAAAAAAAAOCKWAAAAABA9oxfP8am/eaSwdle85n3ntLpyHiuiEWuCA+NVZehbfXzn3PledDT2eUAAAAAAAAAAPIwAnYAAAAAgGxJTE7M8TUNBoOuxqUoMTFRnp4EoJCzrscnq3SVQEXEnHF2KQAAAAAAAACAPI6AHQAAAAAgW4oV9tfVxKs5uqbFYlH5kp6E65ArvIq46XjIWdWvXz/bz9g2894cqgoAAAAAAAAAkBcRsAMAAAAAZMuQlm/bXAv7ZdcZDs3P7ErZr178WnNCRmS7NiAzZSv66JOO6/XF6a8VFBSUrbXmTO6WM0UBAAAAAAAAAPIkF2cXAAAAAADAbS5y0dDHhks5f+ssAAAAAAAAAACAwwjYAQAAAADyhKLuRv2361fOLgMAAAAAAAAAAMCKK2IBAAAAAE5Xzb+aXm32hrPLAAAAAAAAAAAAsEHADgAAAADgVN1rPa8mlZpk6L8cGeuEalAQ8GwBAAAAAAAAAOxFwA4AAAAA4FTpw3VGo1G+fj4a3namkypCQeDr5yOj0ejsMgAAAAAAAAAAeRwBOwAAAABAnmIymXTqZKjMZrOzS0E+ZjQaZTKZnF0GAAAAAAAAACCPI2AHAAAAAMhzTCYT4ScAAAAAAAAAAOB0Ls4uAAAAAAAAAAAAAAAAAACAvIgT7AAAAAAAeU50dDRXxCJXcUUsAAAAAAAAAMAeBOwAAAAAAE518eoFlfANtLajo6NVqXJFXY2JdWJVyO98/Xx06mQoITsAAAAAAAAAQJYI2AEAAAAAnGrcb2PUvdbzalKpiSTJbDbrakysJq1/VcVL+zi5OuRHlyNjNbztTJnNZgJ2AAAAAAAAAIAsEbADAAAAADjd//Yv1LELh/Ry41etfcVL+6hEecJPAAAAAAAAAADAeVycXQAAAAAAAJJ06MIhfbjqfWeXAQAAAAAAAAAAYEXADgAAAACQZ5iTYjVl72RnlwEAAAAAAABJW7ZskcFgsP4zatSoLMe3aNHCZjyQ00aNGmXzjG3ZssXZJQEoALgiFgAAAACQLfN2z7Fpv7lkcLbWs8ii1xcNUmJiYrbWAQAAAAAABc/p06d1+PBhhYeHy2w2KzU1VX5+fvLz81O1atVUs2ZNubq63tPakZGROnTokMLCwnT16lW5urrKz89PQUFBql+/vooWLZrD7wYAAOQFBOwAAAAAANly6vLJHF/TYDDoWFiSSpRPlKenZ46vj4ItPDRWXYa21c9/zpXnQZ4vAAAAAHjQHTp0SN9++62WLVumyMjILMcWLlxYjRs3Vu/evdW1a1d5e3vfcey1a9e0atUqrV27Vr/99psiIiLuONbV1VXNmzfXkCFD1LFjx3t+LwAAIO8hYAcAAAAAyHMsFovc3QyE65Arrscnq3SVQEXEnHF2KQAAAABy0Oq3lzq7hHzjqSnPOrsEu5w9e1Zvv/22li61/3ufkJCgDRs2aMOGDXrjjTc0YsQIvf322xl+BvGf//xH48aN07Vr1+xaNyUlRZs2bdKmTZvUrl07zZ07V4GBgQ69HwBA9oSFhalChQrWdt++fRUcHOy8gpBvELADAAAAAGTLB09+rOGrh1rbY54a79D8j1d/kKHv6OZj6j24YbZrAzLjVcRNx0POqn79+tkOcW4z782hqgAAAAAAjli1apV69+6t2NjYTF/38/OTv7+/fHx8dPnyZV28eFEJCQk2Y8xmsz744AMtXbpUe/bssXlt7969mYbrDAaDAgMDVaJECRkMBoWHh+vy5cs2Y9atW6cmTZpo+/btKlmyZDbfKQAAcDYCdgAAAACAbEkfUPL19M3Weu3Kd9C0GTMJ2CHXlK3oo086rtcXp79WUFBQttaaM7lbzhQFAAAAALDbggUL1LdvX6WkpNj0P/bYYxowYIA6dOig8uXLZ5h3/PhxLV++XP/73/+0d+///cJUVFRUlvt5eXnpueeeU6dOndS8eXMVK1bM+prFYtHevXv16aefasWKFdb+U6dOqVOnTtq1a5dcXFzu9a06XYsWLWSxWJxdBmA1atQojRo1ytllAChgHtx/kwMAAAAA8p0xT41X9eI1nV0GAAAAAADIo0JCQtS/f3+bcJ2Pj4++//577dmzR6+++mqm4TpJeuihhzR8+HCFhIRo6dKleuihh7Lcy9/fX59//rnOnz+vefPm6dlnn7UJ10m3TrSrW7euli9frrFjx9q8tmfPHs2bN+8e3ykAAMgrCNgBAAAAAJzOIIO+7Doj26ffAQAAAACA/MtsNqtHjx66ceOGtS8gIEBbtmxR7969ZTAY7F6rS5cuOnjwoAYMGJDp6wMHDlRoaKiGDh0qHx8fu9YcOXKkunTpYtM3e/Zsu2sCAAB5E1fEAgAAAACcqqi7UeOemZCh/3JkrBOqQUHAswUAAAAAD6ZRo0YpNDTU2nZxcdEvv/yiWrVq3dN67u7umj17tpYuXZrhtdatW9/Tmu+//76WLVtmbe/atUtms1lGo/Ge1gMAAM5HwA4AAAAA4FTpw3VGo1G+fj4a3namkypCQeDr58P/uQEAAAAAD5CrV69q1qxZNn1vvfWWGjZsmO21n3322WyvcVvdunXl5eWl69evS5JSU1MVERGh6tWr59ged7N//34dPXpUly5dUmJiogICAlS2bFk1adJEXl5e962OvCIuLk5bt27V2bNnFRMTIx8fH1WvXl2NGzeWh4dHju0TERGhI0eO6PTp04qNvfXLfSaTSaVLl1bDhg3l5+eX7T3OnDmjffv2KSIiQmazWQaDQd7e3ipZsqQqVqyoGjVqyNPTM9v75IbDhw8rJCREFy5cUKFChVS6dGk1aNBAQUFBTqvJYrFo79692r9/v6KiolS4cGGVLl1aTZs2VYkSJXJkj4SEBO3cuVORkZG6dOmSXF1dFRAQoOrVq6tOnToOnbzpLAcOHFBISIguXbokDw8PBQYGqlGjRjn2vbt69ap+//13nT9/XlFRUfL09JS/v79q1659X//uBLJCwA4AAAAAkKeYTCadOhkqs9ns7FKQjxmNRplMJmeXAQAAAACw0zfffKP4+Hhr293dXe+//74TK8qcwWCQj4+PNWAnyRq2yk1xcXGaOHGi5s6dq3PnzmU6xtPTU+3atdOnn36qmjVr2rXuli1b1LJlS2v7k08+0ahRo3Ki5Fx3/vx5vfvuu1qyZIkSExMzvG40GjV48GB99NFHKly4sIKDg/Xvf//b+vrcuXPVr1+/O66fnJysjRs3avHixdq4caPOnDlzx7EGg0ENGjTQ8OHD1alTJ4dCVampqZo9e7amT5+ugwcPZjnW3d1djz32mLp27arBgwff10Bl2vfUvHlzbdmyRZK0dOlSffTRRzp69Gimcxo1aqTJkyfbHZYdNWqURo8ebW1v3rxZLVq0yHRsWFiYKlSoYG337dtXwcHBslgsmj17tsaNG5fp983V1VVt2rTR559/rmrVqtlVV3o7d+7UuHHjtGnTJiUlJWU6JiAgQAMHDtS7776rokWL3tM+2ZXVZ/zHH3/U6NGjdfz48Uzn1q9fX5999pmaNGlyT3uvXLlSn332mX7//XclJydnOqZcuXJ66623NHjw4CwDsUFBQZl+L+fNm6d58+bdcd7dPufAbQTsAAAAAAB5jslkIvwEAAAAAACs0l/j2qVLFxUvXtxJ1dzZzZs3FRUVZdNXrFixu87r16+fTQjkdhDIHlu3blX37t116dKlLMclJibql19+0cqVK/Xee+9p3Lhxdq3/INqwYYOee+65LMONZrNZEyZM0MqVK7V+/XqH9+jZs6eWLFli11iLxaI//vhDXbp00bPPPqv58+fL29v7rvNiYmL0zDPPaOfOnXbtc+PGDf3xxx/6448/1KlTJ1WuXNmuebnBYrHozTff1FdffZXlmJ07d6pJkyYaNWqUPvroo1yv68aNG+rVq1emV0PflpKSorVr12rTpk2aOXOmTfDybq5du6Z///vfWrRo0V3HXrp0SZ9++qlmzZqlFStW6PHHH7d7n9x048YN9e/fXwsWLMhy3O7du9WiRQvNnj3boZDapUuX1KNHD2sIMytnz57V0KFD9fXXX2vNmjWqVKmS3fsAOYmAHQAAAAAAAAAAAAAgz7p27Zr++usvm75OnTo5qZqs/f7770pJSbG2PTw8VK5cuVzbb/Xq1erWrVuGE9o8PT0VFBSkwoULKzw83Cb0l5KSovHjx+vChQv67rvvcq02Z9m6das6depkc4qg9H9fE29vb0VGRurChQuSpCNHjqhDhw4aNGiQQ/tkdiqev7+//P39VbRoUSUmJioyMlKXL1+2GbN06VLFxsbq119/lYuLyx3Xt1gs6tSpU4ZwncFgUMmSJRUYGKhChQopLi5O586d09WrVx2qP7eNHTvWJlxXuHBhVahQQYUKFVJYWJhNvampqfr4449VqFAhjRgxIlfrevXVV23CdUajUUFBQUpNTVVYWJjNSZlJSUl66aWX5O7urhdeeOGua1+6dEkdOnTQ3r17M7xWpkwZlShRQikpKTpz5oxiYmKsr124cEEtWrTQ+vXr7/k0uJzUt29f/fTTT9a2n5+fypYtKzc3N4WGhtp871JSUvTSSy+pRo0adgUET5w4obZt2+r06dM2/QaDQeXLl1fx4sWVlJSk06dP23wv/vnnHzVs2FA7duxQlSpVsv8mAQfd+W9rAAAAAAAAAAAAAACcbNeuXRmuD6xbt66TqsnanDlzbNpPPPGEPD09c2Wv8PBw9e7d2yboVaxYMc2aNUtRUVE6duyY9u7dq0uXLun333/PENyZM2eOvv7661ypzVnMZrN69+5tE64rVqyYvv32W+vXJCQkROfPn9f+/fvVsWNHSdLBgwc1efJkh/crXry4Bg8erNWrVysqKkqXLl3SkSNHtGvXLu3fv19RUVE6ceKE3n//fZvn4LffftPUqVOzXHvx4sXavn27te3t7a3Jkyfr/PnzioyM1N69e7Vr1y4dOXJEMTExOnv2rObNm6dnn31Wbm7OPWvp5MmTGjNmjCSpRIkSmj9/vq5cuaLDhw9r3759unz5statW5fh+tWRI0fqjz/+yLW6tmzZYv2MVqpUScuXL9eVK1d04MABHTp0SFeuXNHPP/+s0qVLW+ekpqbqlVdeyRAISy81NVU9e/a0Cdf5+/tbv2fh4eEKCQmxvv8dO3boiSeesI5NSEhQr169dOXKlRx+1475/vvvreG6du3a6Y8//rB+jfbu3avLly9r2bJlKlWqlHVOSkqKXn/99buunZCQoE6dOtl8LStUqKBvvvlGV65c0enTp7Vnzx4dPHhQMTExWrt2rerUqWMdGxUVpR49emR65e6CBQu0YcMG/fDDDzb9bdq00YYNG+74T9u2bR3+GqFg4gQ7AAAAAECeEx0dLbPZ7OwykI8ZjUauIQYAAACAB8Tff/9t0y5SpIhTr768k4MHD2a4UtGRaxMdNXjwYJuTpMqWLavt27erfPnyGcY2bNhQW7duVb9+/fT9999b+9955x117NjRJizzIBs9erQiIiKs7dKlS2v79u2qUKFChrGPPvqoli9frhEjRmjixIl3DVClN3LkSNWuXfuuAcrKlStr/Pjx6t69u5588klFR0dLkj7//HO98cYbdwzDpb9idOXKlWrZsuUd9ylbtqz69OmjPn36KDw8XH5+fg69n5wUGRkpSSpfvrx27txpE1iTJFdXV7Vt21YhISFq06aN9ZS+22G2gwcPymAw5HhdZ86ckSTVqVNHmzdvltFotHnd3d1d3bt3V8uWLdWkSRP9888/km4Fw15//XWtXr36jmtPnjxZmzdvtrbr16+vFStWKCAgIMNYFxcXNW7cWBs2bNCQIUOsJ/1FRERozJgxdw1f5qbQ0FBJ0kcffWQNSabl6uqqzp07q3r16qpdu7YSEhIkSX/++acOHDigRx999I5rv/POOzp27Ji1/cwzz2jhwoUqUqRIhrFubm5q166dWrZsqV69emnZsmWSpP3792vGjBl6++23bcY3btxYkhQWFmbTX7JkSbVq1cqOdw5kjYAdAAAAAMCphix5TVO7Tre2o6OjValyRV2NiXViVcjvfP18dOpkKCE7AAAAAHgA3A4k3ebv758r4ZvsSEpKUr9+/Wyuh61Tp466deuWK/sdP37cJuzj4uKixYsXZxquSztmzpw52r9/vw4dOiTpVnBo5syZ+vTTT3OlzvspISEhw5W3CxYsyDRcl9aECRP0+++/25wWZ4+GDRs6NL5WrVqaNGmSXnrpJUm3Qmi//vqrOnTokOn42+EuSapatWqW4br0ypYt61BtucFgMGjRokUZwnVpFS5cWEuXLlWVKlUUG3vrZ4GHDx/Whg0b1KZNm1ypq3Dhwlq2bFmGcF1a/v7+WrJkiWrXrm09PXPNmjX6559/Mr2eNCEhQZMmTbK2S5YsqTVr1tz1504uLi7673//q5CQEO3atUvSrZMlR48eLV9f33t4dzmjU6dOmYbr0qpSpYreeOMNTZw40dq3du3aOwbswsPDNXv2bGv7kUce0aJFi+Th4ZHlPh4eHvrhhx9Uo0YNa3hu6tSpevPNN+Xq6mrnOwKyj4AdAAAAAMCpLLLozSWDNfLJj1XCN1Bms1lXY2I1af2rKl7ax9nlIR+6HBmr4W1nymw2E7ADAAAAgAdA+oCdM4Mnd/Lmm29q37591rabm5tmzZolFxcXu+YHBwcrODjY7v2+++47WSwWa7tXr16qV6/eXee5ublp8uTJateunbVv1qxZGjNmTJ4LLTpq+fLl1pCWdOt6y+bNm9s1d8KECdYTsHJTz549NXDgQGsQ8/fff79jwC7tNbeFChXK9dpyWrdu3fT444/fdVxAQIDeeecdffzxx9a+OXPm5FrA7rXXXlO5cuXuOq5mzZrq06ePzbXPc+bM0YQJEzKMnT9/vs3fU6NGjbL7Z06urq56//331alTJ0lSfHy81q9frx49etg1PzeMHz/ernE9evSwCdj99ddfdxw7ffp0m6u+J0+efNdw3W2FCxfW22+/rSFDhki6dRJhSEiI6tevb9d8ICcQsAMAAAAA5AnjfhujXrV7q6TLrStJipf2UYnyhJ8AAAAAACjo4uLibNre3t5OqiRz06ZN07fffmvTN3bsWNWpUyfX9ty6datNu3///nbPbd26tcqUKWO9SvXixYv6559/9NBDD+Vojffbjh07bNovvPCC3XMbNWqkChUqOHxNrKO8vb0VEBCg8+fPS5JNKDO9UqVKWU+xO3r0qPbt26fatWvnan05qU+fPg6N/eSTT6yh0fTPd05ypK6+ffvaBOy2bNmS6bg1a9ZY/+zm5qaePXs6VNOTTz4pFxcXpaamSpK2b9/utIDdww8/rOrVq9s1tmbNmnJzc7MG58LDw+84Nu3XKDAw0OFrW9MHLrdv307ADveVfXF5AAAAAADugx/3/aBfTix1dhkAAAAAACAPKVq0qE372rVrTqoko2XLlumtt96y6evRo4eGDx+ea3smJSVp//791nahQoXUpEkTu+e7uLhkuG709vWUD7KQkBCbdqNGjRya7+j4tI4cOaLRo0erU6dO+te//qXixYvL3d1dBoMhwz+3w3WSdPny5Tuu2bp1a+ufU1JS1K5dO82ePVsJCQn3XOf9YjAY7D49UJLKly+voKAga/vChQs6e/ZsjtdVrFgx1axZ0+7xDRs2lLu7u7W9f/9+3bx502aMxWLRzp07re0qVapkef1sZry9vVWsWDFr+9ixYw7Nz0l169a1e2yhQoVsThRNe4JkWjExMTp8+LC1XadOHbtP97wt/amDzvwaoWDiBDsAAAAAQLYcjNhv035n2ZBsrRdqPqkXv3o+W2sAAAAAAID8I/1Vi3cKcdxvW7ZsUa9evaynTkm3TlmaP39+rl63euHCBd24ccParlq1qk0IyB6PPvqovv/+e2s7N8JM91tkZKT1zx4eHqpQoYJD86tVq+bwnocOHdLrr7+ubdu2OTxXkq5evXrH1wYNGqQvv/xSFy9elCRdunRJL7/8soYMGaJWrVqpZcuWaty4sWrVqpXnrpAtV65chmDs3dSsWdPmBMHTp0/bdZWro3s4olChQnrooYd06NAhSbfCrefOnVP58uWtYy5evGhzPezRo0ez/flPfy32/RQQEODQeG9vb2tQNO21xmkdP37c5krrNWvWPNBfIxRMBOwAAAAAANmy+MD/bNo3U2/eYaT9fEoYte/vWLXjiljkgvDQWHUZ2lY//zlXngc9nV0OAAAAAOAu0gfsoqKinFTJ/wkJCVHHjh2VlJRk7WvYsKGWLl3qcNjNUTExMTbt4sWLO7xG+jnp13wQpQ2rGY1GhwM8aU/isseqVavUtWtXm7Cjo9I+P+mZTCatWrVKHTt2tDn1LiEhQStWrNCKFSskSUWKFFHTpk317LPPqlu3bg6/j9yQ9jS2e52TVfjwXuVUXWkDdleuXMl2Xek5M0Ts6XnvPytLG6JLK799jVAwEbADAAAAAOQ5t38AmpiYmK0f6gCZuR6frNJVAhURc8bZpQAAAAAA7FC1alWbdlxcnE6ePKnKlSs7pZ4jR46oXbt2iouLs/Y9+uijWrNmjby9vXN9//j4eJv2veyZfk7a9/KgShtWu5eQo4eHh91j//nnH3Xr1s0mXGcwGFSvXj01atRIFStWVGBgoDw9PTP8bKt3797WU+nupm7dujp8+LAmTJig7777LtNTu+Lj47V27VqtXbtWQ4cO1dChQzVy5EinnmpXuHBhh+ekfybTP+c5ITfqyo0gYNpTMfMDvkbIDwjYAQAAAACypV75Bvr1+LocXTP5RrIef6QY4TrkCq8ibjoeclb169fP9jO2zbw3h6oCAAAAANxJgwYN5ObmpuTkZGtfSEiIUwJ2p06dUuvWrW1OZKpSpYp+/fXX+3ZyWJEiRWza165dc3iN9HMcvc4zL/Lx8bF+X+4lnGU2m+0eO2LECJtAX7169TRv3rwMYdDMOHqynslk0qRJkzR27Fht2bJFmzdv1tatWxUSEqKbN21vkoiLi9Po0aO1ceNG/frrr/cUKMsJCQkJDs9J/0ymf85zQm7Ulf5rXL16dU2dOtXx4tLw8vLK1vy8Jv3XqGXLlvrggw+ytaafn1+25gOOImAHAAAAAMiWp2t2tAnYfdl1hkPz31wy2KZdxK2o/tNtkh4/PCJH6gPSK1vRR590XK8vTn+toKCgbK01Z3K3nCkKAAAAAHBH3t7eqlOnjv78809r34oVK9SzZ8/7Wkd4eLiefPJJm+s6y5Urp40bNyogIOC+1ZE+WHIv1y9evnw5yzUfRCaTyfq1MJvNio+Pdyikde7cObvGxcfHa/Xq1dZ2iRIltG7dOru/hvd6Ha+7u7vatGmjNm3aSJKuX7+uXbt2ac2aNVq4cKFN/Tt37tSwYcM0Y4ZjP6fLKemfL3ukf45zI7CaG3Wlv27ZYrGoVatWDu+Tn6X/Gnl6evI1wgPHxdkFAAAAAABwW61StfTKo686uwwAAAAAAJDHdOnSxaa9dOnSewqW3atLly6pVatWOnPmjLUvMDBQv/32m8qWLXvf6pCkkiVL2lyB+vfff9tcVWqPAwcO2LTLly+fI7U5U/Xq1a1/tlgsGd7j3ezfv9+ucX/99ZfN17tXr152h+tOnjxpc/Jddnh5eally5aaPHmywsLCNHLkSJvXZ8+e7dCpfDkpPDzc4b0PHTpk065QoUJOliRJOnz4sEPjb968qePHj1vbHh4eKlWqlM2YwMBAmxPnzpw5k+FkwYIu/ffy5MmTTqoEuHcE7AAAAAAAeUKv2r3Vv+Erzi4DAAAAAADkQQMHDrQ5jSwpKUkTJ068L3vHxMSodevW+ueff6x9JpNJGzZscMo1te7u7qpdu7a1fePGDe3YscPu+RaLRVu2bLHpa9CgQU6V5zT16tWzaa9atcruuTExMXZ/DS9evGjTfuihh+zeZ9OmTXaPdUShQoU0duxYNWnSxNp38+ZN7d69O1f2uxuLxaJt27bZPf7MmTMKCwuztgMDA1WuXLkcrys6OtqhkN0ff/xhE6asVauWChUqZDOmUKFCaty4sbWdkJDgtK97XlWmTBmbvytPnDih8PDwXNnLxcU2BmWxWHJlHxQ8XBELAAAAAHC6kU9+rBK+gTZ9lyNjnVQN8jueLQAAAAB48Pj5+WnAgAGaOnWqte+LL75Q165dVb9+/WytvWbNGnXo0CHT1+Lj49W+fXsdPHjQ2mc0GrV+/XrVrFkzW/tmR/PmzW1CPMHBwXriiSfsmrthwwabcEvJkiVVpUqVHK/xfnvmmWdsTnGbN2+ePvzwQ3l7e9917qxZs+w+WS59YMfe0wMtFotmzpxp19h71bhxY5ug4L1ciZpT5s+fr6efftrusWk1a9YsN0qy7jVp0iS7xs6bN8+m3bx580zHtWvXThs3brS2p02bZhN2xK2v0VdffWVtf/XVV7kSkk7/eU9ISMjxPVAwEbADAAAAADjVl11n2LSNRqN8/Xw0vG3u/sARBZuvn4+MRqOzywAAAAAAOGDUqFFavny59aSrlJQUde7cWb/++qsefvhhh9e7efOm3n//fS1ZskSnT5/O8HpiYqI6duxoE2Tz8vLSqlWrVLdu3Xt+HzlhwIABmjx5sjXstWDBAg0ZMkSPPfZYlvNSUlI0fPhwm76XXnop1+q8nx5++GE1aNBAu3btkiSdP39eI0aM0LRp07Kcd+LECY0dO9bufQIDbX9JdMeOHXrzzTfvOm/mzJl2X0N7r9IH6uy9ujY3LF68WHv27NHjjz+e5bhLly7p888/t+nr379/rtU1ffp0vfHGG3e92vnIkSMZgn93quull17S2LFjdfXqVUm33vvq1av11FNP5UjN+cHbb7+tr7/+WsnJyZJuhRB79OihOnXq5Og+RqNRrq6uSklJkaRM/24H7gUBOwAAAABAnmIymXTqZKjMZrOzS0E+ZjQaZTKZnF0GAAAAAMABvr6++vnnn9WkSRPdvHlTknThwgU1b95c06dPV8+ePWUwGOxaa+vWrXrzzTd18OBBlS9fPsPrycnJeu6557R582Zrn7u7u5YtW6amTZvmzBtKo1+/fjanZfXt21fBwcF3HF+lShU9/fTTWrlypSQpNTVVXbt21Y4dO1SmTJlM51gsFr300ks6cOCAtc/b21uDBg3KmTeRB3z66adq3bq1tf3VV1/Jy8tLY8eOlbu7e4bxf/31l7p06aK4uDgZDAa7rpN87LHH5O7ubj25bunSpfr999/VqFGjO85ZtWqVhg4davf7MJvNevXVVzVs2DCb64CzEhYWpsWLF1vbLi4uqlWrlt175jSLxaLu3btr586dKlWqVKZjrl+/rmeffVaxsf9320D16tXVpk2bXKsrISFBXbp00ebNm1W0aNFMx0RFRenZZ5+1hsGkWyew3ek6YB8fH7333nt6//33Jd36PPbq1Us//PCDOnbsaHdte/fu1aRJk/Tzzz878I4eDBUrVtSAAQP0zTffSLr1vX/66ae1ZMkSNWzY0O51Nm3apJ9++knffvttpq8XKlRIVapU0bFjxyRJ+/fv16lTp1SpUqXsvwkUaATsAAAAAAB5jslkIvwEAAAAAAAyqFevnmbNmqX+/fsrNTVVkhQTE6Pnn39eU6ZM0YABA9S+fXuVK1cuw9wTJ05o5cqVWrx4sf74448s93n55Ze1atWqDH2urq42V0Hao0aNGipZsqRDc+wxY8YMbd++3Xpq1pkzZ1S7dm1NnDhRPXr0sLkqcdeuXXrvvfe0bds2mzU+++yzO4afHkStWrXSgAED9N1331n7Jk+erCVLluiFF17Qww8/rMKFCysyMlLr16/X8uXLlZKSIhcXF7300kt3DO2k5e3tra5du+rHH3+UdOtUwPbt22vy5Mnq06ePPD09rWNPnDihKVOm6JtvvlFqaqoCAgKUkpKiK1euZLlHamqqFi5cqIULF6pu3brq1q2bWrdurZo1a2YICprNZi1atEgffvihTVDtmWeeyXDa3v1SunRpXbx4UWFhYapTp44+++wzdevWzfq1SU1N1YYNGzR06FAdPXrUOs9gMOjbb7+1OyjrqPLly+vMmTPau3evateurSlTpqh9+/Zyc7sVnblx44aWL1+uoUOHKiIiwjrPy8vL5nrTzAwfPlzbt2/XmjVrJElxcXHq3LmzOnfurNdff12NGzeWh4eHzZzExEQdPHhQGzdu1JIlS/TXX39JUr4M2EnSlClT9Oeff2rfvn2Sbp0y2axZM/Xu3VsDBw5U3bp1rd+L2+Lj47V//36tXbtWS5Ys0fHjxzMNRafVpk0ba8AuJSVFzZo10yuvvKJHHnlERYoUsXm+cuvvZ+Q/BOwAAAAAAAAAAAAAAA+Mvn37ysfHR3379rU5AX/Pnj3as2ePpFu/vOfv7y8fHx9duXJF58+fV0JCQqbrZRauSHty3W3Tp0/X9OnTHa537ty56tevn8Pz7qZMmTL64Ycf1LVrVyUlJUm6dUXogAED9Prrr6tChQry8vJSeHi4Ll26lGF+//7989XpdbfNmDFD586d09q1a619oaGh+vTTT+84Z/LkyTKZTDYBu/RBn7Q+/fRTrV692vr8mc1mDRw4UEOGDFGVKlXk4eGh8+fP24S0XF1dFRwcrFdfffWuAbu0QkJCFBISohEjRsjd3V1lypSRn5+fXF1ddeXKFYWFhVmvw7zN39//rlfj5qbKlStr0KBB+uijj3Tx4kW9+OKLGjRokCpUqKBChQopLCxMMTExGeaNGTNGjRs3zrW6WrRoITc3N3333Xc6deqUOnbsKB8fHwUFBclisej06dOKi4uzmWMwGPT111/f9QQ0FxcXLVy4UJ07d9aWLVsk3TrFb9myZVq2bJk8PDxUvnx5+fn5KTExUVevXlVERESG711+5uXlpRUrVqhDhw46dOiQpFunhQYHBys4OFje3t4qW7asfHx8lJCQoJiYGEVGRtp1smRagwcP1jfffKPExERJ0rlz5zRq1KhMx+bW38/If1ycXQAAAAAAAAAAAAAAAI7o3LmzDhw4oE6dOmX6enR0tI4fP64///xTp06dyjRcV6xYMU2ZMiXDqW4Pkqeeekrr169XQECATf/169d19OhR7d27N0O4ztXVVe+//77NKW/5ye2rfIcNG5ZlSE66dRrd7NmzNXToUMXHx9u85uPjc8d5lSpV0qJFi1SkSBGb/tsnku3Zs8cmXOfp6akFCxaoffv29/CO/s+NGzcUGhqqvXv3Wp/t9AGtqlWraseOHSpbtmy29squDz/8UG+++aa1fe3aNR0+fFj79u3LEK5zcXHRJ598og8//DDX65oxY4a6du1qbcfGxurAgQM6ePBghnCdu7u7vvnmG/Xp08eutX18fKwn86V/9pKSkvTPP/9o9+7dOnDggM6cOZNpuM7Z37fcVqZMGf3xxx/q3bt3hpMKr127pr///lu7d+/WoUOHFBERkWm4LrMTStOqUqWKvv/++wyfTyA7OMEOAAAAAJDnREdH2/wGOpDTjEYj1xADAAAAwAMuKChIv/zyi/bv369Zs2Zp6dKlunDhQpZzvL291axZM/Xt21edO3fOcGXjg6h58+Y6efKkJkyYoODgYJ07dy7TcZ6enmrXrp3GjBmjhx9++D5XeX95eHho8uTJGjBggObPn69169YpPDxcMTEx8vHxUbVq1dSuXTu9/PLLKlGihKRbP49KK6uAnXTrGso9e/Zo+PDhWrlyZaZj3Nzc1LlzZ40bN05VqlSxu35fX1/t27dPy5cv14YNGxQSEmI9pfBOHnnkEb300ksaNGiQChUqZPdeuWnq1Klq3ry5PvzwQ+uVnek1atRIkydPVqNGje5LTe7u7lq0aJFmz56tsWPH6uzZsxnGuLq6qlWrVvriiy9UvXp1h9Z3c3PT559/rtdee00TJ07UL7/8kukJkmkFBQWpTZs26tatm5588kmH9nsQeXt76/vvv9e7776rCRMmaO3atdarru+katWqatu2rXr06KGGDRvedY9u3bqpcePGmj9/vjZv3qyjR48qJiZG165dc/hEPECSDBaeHNzFkSNHVLNmTWv78OHDqlGjhhMrAgA8KP7T5WMd//2IHmpUQ+8vG+PscoD7ot2A9jIYDLJYLFr33dq7TwDyiTeXDLb++cuuMxya+8326RrY9DVrOzo6WpUqV9TVmNgcqw9Iz9fPR6dOhmY7ZPfo5G7WPx94d3F2ywIAAAAKlOTkZJ04ccKm71//+tddT5wCsnLq1CkdPnxY4eHhiouLk8Vika+vr0wmk6pXr64aNWrI1dXV2WXmqv379+vIkSO6dOmSkpKS5O/vr7Jly6pJkyYqXLiws8vLs7p166YlS5ZY22FhYSpfvrxdc8+fP6/t27crIiJCCQkJMhqNqly5sho1aiRfX99s15aUlKSjR4/q5MmTOn/+vOLj42UwGGQ0GhUUFKRatWqpdOnS2d4nO9KeRta8eXPrNam3HTp0SCEhIbpw4YLc3d1VsmRJNWzYUBUqVMi1msLCwmzW79u3r4KDg63t1NRU7d27V/v27dPly5fl5eWl0qVLq1mzZgoMDMyRGiwWi44cOaIjR47o8uXLunr1qjw8POTj46MKFSqoevXqKlWqVI7s9aBKTU3VX3/9pX/++UeXL1+W2WxW4cKF5evrq0qVKql69ery9/d3dpkPvNz6766Ckiniv04BAAAAAE515NIRfbDyPY1/ZqIkyWw262pMrCatf1XFS2f9m8LAvbgcGavhbWfKbDZzih0AAAAA5DOVKlVSpUqVnF2GU9WqVUu1atVydhkPlJs3b2r79u3Wtr+/v93hOkkqWbKkunfvnhulSbp1Il/t2rVVu3btXNsjtz388MN57uREFxcXPf7443r88cdzbQ+DwaCaNWvaBJBgy8XFRXXr1lXdunWdXQpwRwTsAAAAAABOF38jTm8teV3/7fqVta94aR+VKE/4CQAAAAAAALnrp59+srnG835dVwoAeDC4OLsAAAAAAAAkKVWpenPJYF1NvOrsUgAAAAAAAPCAslgsDo2PiIjQ0KFDbfr69++fkyUBAB5wBOwAAAAAAHnKnCPfqnzdss4uAwAAAAAAAA+gbdu2qVOnTtq5c+ddx27ZskUNGzbU5cuXrX1VqlTRU089lZslAgAeMFwRCwAAAADIlvHrx9i031wyONtrPvPeUzodGc8VscgV4aGx6jK0rX7+c648D3o6uxwAAAAAAJCDLBaLVqxYoRUrVigoKEitW7dWnTp1FBgYKE9PT8XExOjYsWNav369/vzzT5u5rq6umj9/vlxdXZ1UPQAgLyJgBwAAAADIlsTkxBxf02Aw6GpcihITE+XpSQAKOet6fLJKVwlURMwZZ5cCAAAAAECBERoaqtDQ0Bxft0mTJnf8+VFYWJhmzZpl1zru7u6aO3eu6tevn5Pl5QkbN27M8TVLlSql6tWr5/i6+D8xMTHau3dvjq9bo0YNlSxZMsfXBfIzAnYAAAAAgGwpVthfVxOv5uiaFotF5Ut6Eq5DrvAq4qbjIWdVv379bD9j28w5/0NOAAAAAADyo/nz52v06NE5vu7p06cVFBRkbfv4+KhIkSKKj4+3e4369etrypQpatiwYY7Xlxe0bt06x9fs27evgoODc3xd/J8DBw7kyvdu7ty56tevX46vC+RnBOwAAAAAANkypOXbNtfCftl1hkPzM7tS9qsXv9ackBHZrg3ITNmKPvqk43p9cfprmx/A34s5k7vlTFEAAAAAACBH1K5dW1FRUdq4caO2bdumffv2KTQ0VFFRUbp+/brc3d1VrFgxlSlTRk2bNlX79u3VokULZ5cNAMjDCNgBAAAAAPIMF7norceGaVriTGeXAgAAAAAAgAeUp6ennn76aT399NPOLqXAsFgszi4hg6CgoDxZF4AHDwE7AAAAAECeUNTdqHHPTFBYWJizSwEAAAAAAEAOGzVqlEaNGuXsMgokQmYPphYtWvC9A/IIAnYAAAAAAKer5l9NrzZ7w9llAAAAAAAAAAAA2CBgBwAAAABwqu61nleTSk0y9F+OjHVCNSgIeLYAAAAAAAAAAPYiYAcAAAAAcKr04Tqj0ShfPx8NbzvTSRWhIPD185HRaHR2GQAAAAAAAACAPI6AHQAAAAAgTzGZTDp1MlRms9nZpSAfMxqNMplMzi4DAAAAAAAAAJDHEbADAAAAAOQ5JpOJ8BMAAAAAAAAAAHA6F2cXAAAAAAAAAAAAAAAAAABAXsQJdgAAAEAeFx0dzVWZyDV59ZpMnnvktrz67AMAAAAAAAAA8hYCdgAAAEAecePGDbm7u9v0RUdHq2LlSoqNueqcopDv+fj5KvTkKacGjS5evaASvoHWdnR0tCpVrqirMbFOqwn5n6+fj06dDCVkBwAAAAAAAADIEgE7AAAAII/4z38nqlaNWur01DPWPrPZrNiYq3p580j5lCYEgpwVGxmtWS3HyWw2OzVkNO63Mepe63k1qdRE0q3n/mpMrCatf1XFS/s4rS7kX5cjYzW87UynP/sAAAAAAAAAgLyPgB0AAACQR1y7nqCvl81UWHiYhgx6w+Y1n9Im+QX5O6kyIPf9b/9CHbtwSC83ftXaV7y0j0qUJ/wEAAAAAAAAAACcx8XZBQAAAACwtS5krd4d9Z5u3Ljh7FKA++rQhUP6cNX7zi4DAAAAAAAAAADAioAdAAAAkAcdjjikl4cP0tXYWGeXAtxX5qRYTdk72dllAAAAAAAAAAAASOKKWAAAACDXtH+pQ7bmX4q/oE9nfCr/EgE5VBGQO+btnmPTfnPJ4GytZ5FFry8apMTExGytAwAAAAAAAAAAkF0E7AAAAIA8LCElQY8/VU+JJ2OlIH9nl4N8JungSb2+aJC+2DtJ2uvsamwZDAYdC0tSifKJ8vT0dHY5yGfCQ2PVZWhb/fznXHke5PkCAAAAAAAAANwZATsAAAAgj0u6nCT3oKLOLgP5lMFgcHYJmbJYLHJ3MxCuQ664Hp+s0lUCFRFzxtmlAAAAAAAAAADyOAJ2AAAAQC5Z+fUKh8Z/MO5DHQo/aNP3xMNPavhbw1T7s3Y5WRpgZbFYcjxkN+ap8Q6N/3j1Bxn6jm4+pt6DG+ZUSYANryJuOh5yVvXr1892iHObOY8d/wgAAAAAAAAAyFEE7AAAAIBc4ubm6H9u/1/IyVVueq37YFWrUlXD3xqWs4UB/5/HI5X1WZV3dPr0aQUFBTm7HKt25Tto2oyZBOyQa8pW9NEnHdfri9NfZ/vZnzO5W84UBQAAAAAAAADIkwjYAQAAAHmMl2thjX5zlB6uUVNhYWHOLge4r8Y8NV5XL1x1dhkAAAAAAAAAAACSCNgBAAAAeUrxwv76/KPPFODv7+xSgPvKIIOmdp0uSbqqq84tBgAAAAAAAAAA4P8jYAcAAADkEW2atVbTRo3l4eGR4bXYyGgnVIT8Lq88V0XdjRr3zIQM/ZcjY51QDQoCni0AAAAAAAAAgL0I2AEAAAB5RKuWT2ToMxqN8vHz1ayW45xQEQoCHz9fGY1Gp9aQPlxnNBrl6+ej4W1nOqkiFAS+fj5Of/YBAAAAAIDzjRo1SqNHj7a2N2/erBYtWjivIABAnkPADgAAAMjDTCaTQk+ektlsdnYpyKeMRqNMJpOzy7BhMpl06mQozz1yVV589gEAAAAA2Xf69GkdPnxY4eHhMpvNSk1NlZ+fn/z8/FStWjXVrFlTrq6u97R2ZGSkDh06pLCwMF29elWurq7y8/NTUFCQ6tevr6JFi+bwuwEAAHkBATsAAAAgjzOZTIRAUODw3AMAAAAAAHsdOnRI3377rZYtW6bIyMgsxxYuXFiNGzdW79691bVrV3l7e99x7LVr17Rq1SqtXbtWv/32myIiIu441tXVVc2bN9eQIUPUsWPHe34vAAAg7yFgBwAAAAAAAAAAAOCB96jX884uId84cH2hs0uwy9mzZ/X2229r6dKlds9JSEjQhg0btGHDBr3xxhsaMWKE3n77bXl6etqM+89//qNx48bp2rVrdq2bkpKiTZs2adOmTWrXrp3mzp2rwMBAh94PAADIm1ycXQAAAAAAAAAAAAAAAI5YtWqVHnnkkTuG6/z8/FSlShU9/vjjqlChggoXLpxhjNls1gcffKCmTZtmeG3v3r2ZhusMBoNKliypWrVqqXbt2ipevHiGMevWrVOTJk10/vz5e3hnAAAgr+EEOwAAACCPi46OltlsdnYZyKeMRiNXsQIAAAAAgAfKggUL1LdvX6WkpNj0P/bYYxowYIA6dOig8uXLZ5h3/PhxLV++XP/73/+0d+9ea39UVFSW+3l5eem5555Tp06d1Lx5cxUrVsz6msVi0d69e/Xpp59qxYoV1v5Tp06pU6dO2rVrl1xcOPcGAIAHGQE7AAAAII+YP+kztenRQ4Hly1r7oqOjVbFCkGLNcU6sDPmZj7GoQk+HEbIDAAAAAAAPhJCQEPXv398mXOfj46OvvvpKL7zwggwGwx3nPvTQQxo+fLiGDx+uZcuW6f3339fx48fvON7f318jRozQgAED5OPjk+kYg8GgunXravny5Ro3bpw+/PBD62t79uzRvHnz9O9///se3ikAAMgrCNgBAAAAecT+XTu06PuZGjtjvh5t2ljSrWsqYs1xeqFpURX14jddkbPirqdqwfY4mc1mAnYAAAAAACDPM5vN6tGjh27cuGHtCwgI0Pr161WrVi2H1urSpYueeuopDR48WBs3bszw+sCBAxUcHKwiRYrYvebIkSO1d+9eLVu2zNo3e/ZsAnYAADzgCNgBAAAAecj15Gsa/koPDR42Rp0G9Lf2F/VykY+3qxMrAwAAAAAAAJxr1KhRCg0NtbZdXFz0yy+/OByuu83d3V2zZ8/W0qVLM7zWunXre1rz/ffftwnY7dq1S2azWUaj8Z7WAwAAzkfADgAAAMhjUpSsaZ99oDN//62Orw12djkAAAAAAACA0129elWzZs2y6XvrrbfUsGHDbK/97LPPZnuN2+rWrSsvLy9dv35dkpSamqqIiAhVr149x/awV3x8vHbu3Klz587pwoUL8vT0VPPmzVWnTp0s5509e1Z//vmnLl68qNjYWJlMJgUGBqpx48by9/fPdl0RERE6cuSITp8+rdjYWEmSyWRS6dKl1bBhQ/n5+WV7D+nWM7NlyxZFRERYb3CoWbOmGjRoIDc3ohIAAPvxbw0AAAAglwRPmOTQ+LDTx23aK1bN14ljR2TIyaIAAAAAAACAB9A333yj+Ph4a9vd3V3vv/++EyvKnMFgkI+PjzVgJ8kaIstpLVq00NatW61ti8UiSTp69KjGjh2r5cuXKyEhwWbOkCFDMg3YpaamKjg4WFOmTNHhw4cz3c/FxUX16tXTBx98oGeeecbuOpOTk7Vx40YtXrxYGzdu1JkzZ+441mAwqEGDBho+fLg6deokg8Hxn45GRERo2LBhWrZsmc11wrf5+/vrnXfe0TvvvEPQDgBgF/5tAQAAAOSSH+Z9ke01jp3aq1aVyyklOf7ugwEHXTP6q0XbQH0zd5Q8PT2dXQ7wYHK1SAaD9P//TwwAAAAAQO5If41rly5dVLx4cSdVc2c3b95UVFSUTV+xYsXuOq9fv36aN2+etd23b18FBwc7vP+CBQvUv3//TINldxIZGamOHTvqr7/+ynJcamqqdu3apY4dO6p9+/b6+eefVbRo0buu37NnTy1ZssSuWiwWi/744w916dJFzz77rObPny9vb2+75krSmjVr1KtXL5nN5juOiYqK0ogRI7Rq1SqtWrXK7rUBAAUXATsAAAAgj3NxsSg12VVSirNLQT6T4uahgMDCCj1z1NmlAA+u6mWdXQEAAAAA5HvXrl3LEP7q1KmTk6rJ2u+//66UlP/7OZ6Hh4fKlSt3X/Zes2aN+vTpo9TUVEm3TpyrUKGCTCaTLl26pIiIiAxzTp8+rRYtWujs2bM2/S4uLgoKCpLJZFJUVFSGU+fWrl2rli1basOGDXe90jUxMTFDn7+/v/z9/VW0aFElJiYqMjJSly9fthmzdOlSxcbG6tdff5WLi8td3/+mTZvUtWvXDPsVLlxYFSpUUKFChXTmzBnFxMRIknbs2KHnnnsuR64ZBgDkbwTsAAAAgFxSrkRlh8afvXgyQ1+AT2n9sveg+gZ5S3LNocqAW1yTk3QuJlkN6jfgBDvgHv2tqLsPAgAAAABky65du5ScnGzTV7duXSdVk7U5c+bYtJ944on79nOX/v37KzU1VT4+Pvr444/Vp08fm1P+Ll68aBOUS05OVq9evWzCdW5ubho2bJjeeOMNlSpVytp/6tQpTZgwQbNnz7b27d27V6+++qp++umnu9ZWvHhxde/eXU899ZTq1auX6emDJ0+e1Jw5czRlyhRrSO63337T1KlT9fbbb2e5/tWrV/XCCy/YhOsCAgI0efJkPffcc/Ly8pJ06xS+TZs2aejQoTp06JA2bNigEydO3LV+AEDBRsAOAAAAyCVztuxwaPzQZzvr4LFd1vYj1Rpo8ITJ+vGhKjldGiBJ8jZHacuvsZr79ToFBQU5uxzggbR0UldnlwAAAAAA+d7ff/9t0y5SpIgqV3bsl1vvh4MHD2rBggU2ff369btv+1+8eFGBgYHavHmzqlatmuH1EiVKqESJEtb21KlTtXv3bmvb3d1dy5cvV7t27TLMrVSpkmbNmqV69erplVdesfb//PPP6tmzpzp37nzHukaOHKnatWvfNWhYuXJljR8/Xt27d9eTTz6p6OhoSdLnn3+uN954Q25ud443fPDBB7pw4YK1Xb58ee3cuVOlS5e2Gefi4qJWrVppz5496tChgzZt2qSwsLAs6wIA4O7nqAIAAAC4755+qo++WPqL3NwLObsUAAAAAAAAwKluB61u8/f3l8FgcFI1mUtKSlK/fv1sroetU6eOunXrdl/rCA4OzjRcl15KSoqmTp1q0zd+/PhMw3Vpvfzyyxo0aJBN3+eff57lnIYNGzp0il+tWrU0adIkazsyMlK//vrrHcdfvXpVwcHB1rbBYNCiRYsyhOvS8vDw0JIlS+Tv7293XQCAgouAHQAAAJCHuMpNb7wzXm99NunugwEAAAAAAIACIH3AztfX1zmFZOHNN9/Uvn37rG03NzfNmjVLLi72/V/ywcHBslgs1n/SBsbs1aRJE7Vt29ausevXr1d4eLi1Xb58eQ0ZMsSuuePGjVPhwoWt7R07dujYsWOOFXsXPXv2lKurq7X9+++/33Hsjz/+qOvXr1vb3bp10+OPP37XPXx9fTVy5MjsFQoAKBC4IhYAAADII8oEVdKLbw1T7WZNMrwWdz3VCRUhv+O5AgAAAAAAD4K4uDibtre3t5Mqydy0adP07bff2vSNHTtWderUua919OrVy+6xW7dutWn36dMnyytY0zKZTOrcubMWLlxo7du2bZuqVatm9/534+3trYCAAJ0/f16SbMKL6W3ZssWm3adPH7v3eeGFFzRs2DAlJyffU50AgIKBgB0AAACQRwz9IuNVCkajUT7GolqwPS6TGUD2+RiLymg0OrsMAAAAAACAOypatKhN+9q1a06qJKNly5bprbfesunr0aOHhg8fft9rqVevnt1jd+/ebdN+4oknHNrrySeftAnY7dq1SwMHDrzrvCNHjmjx4sX666+/dPToUcXExMhsNuvmzZtZzrt8+fIdX/vzzz+tfzYYDGrevLkd7+CW4sWLq2bNmtq/f7/dcwAABQ8BOwAAACAPM5lMCj0dJrPZ7OxSkE8ZjUaZTCZnlwEAAAAAAHBH6X92ERsb66RKbG3ZskW9evVSaur/3RLQpk0bzZ8/XwaD4b7XU6FCBbvHnjlzxqb9yCOPOLTXo48+atM+e/ZsluMPHTqk119/Xdu2bXNon9uuXr2aaX9qaqrNeylXrlyGQObdPPzwwwTsAABZImAHAAAA5HEmk4kAFAAAAAAAAAqs9D8bi4qKclIl/yckJEQdO3ZUUlKSta9hw4ZaunSp3N3dnVKTI7cUxMTEWP/s4uLi8M8fixcvfsf10lu1apW6du2qGzduOLRHWmm/zmmZzWZZLBZru1ixYg6vfS9zAAAFCwE7AAAAAAAAAAAAAECeVbVqVZt2XFycTp48qcqVKzulniNHjqhdu3aKi4uz9j366KNas2aNvL29nVKTJBUqVMjusfHx8dY/Fy5c2OG90r/PtF+LtP755x9169bNJlxnMBhUr149NWrUSBUrVlRgYKA8PT3l6elpM7d37966ePFilnWkfR9SzrwXAADSI2AHAAAAAAAAAAAAAMizGjRoIDc3NyUnJ1v7QkJCnBKwO3XqlFq3bq0rV65Y+6pUqaJff/1Vvr6+972ee1WkSBHrVbsJCQkOz7927ZpN+07Xso4YMcLm9Ll69epp3rx5GUKTmbHnmt304biceC8AAKRHwA4AAADI46Kjo2U2m51dBvIpo9HIFcQAAAAAACBP8/b2Vp06dfTnn39a+1asWKGePXve1zrCw8P15JNP6vz589a+cuXKaePGjQoICLivtWSXn5+fNWCXmpqqmJgY+fn52T3/8uXLGdZLLz4+XqtXr7a2S5QooXXr1tm9T1bXzt7m4+Mjg8FgvSY2fV32SBuWBAAgMwTsAAAAgDzi8K7dql7vcbm4uFj7oqOjVbFCkGLNmV+xAGSXj7GoQk+HEbIDAAAAAAB5WpcuXWwCdkuXLtWVK1dUrFix+7L/pUuX1KpVK505c8baFxgYqN9++01ly5a9LzXkpPLlyyssLMzaPnDggFq0aGH3/AMHDmRYL72//vrL5mrYXr162R2uO3nypM3Jd3fi4uJi817Cw8NlNptlNBrt2keSDh48aPdYAEDBRMAOAAAAyCPmTPqPkm/e1OSfF8ujsJckyWw2K9YcpxeaFlVRL5e7rAA4Ju56qhZsj5PZbCZgBwAAAAAA8rSBAwdq3Lhxio+PlyQlJSVp4sSJmjRpUq7vHRMTo9atW+uff/6x9plMJm3YsMEp19TmhAYNGmjr1q3W9qZNmxwK2G3atCnDeuldvHjRpv3QQw/d8/pZefzxx60BO4vFom3btunpp5+2a+7ly5d15MgRu/cCABRMBOwAAACAPOToyb3q90RjTV2ySgGlS1n7i3q5yMfb1YmVAQAAAAAAAM7j5+enAQMGaOrUqda+L774Ql27dlX9+vWztfaaNWvUoUOHTF+Lj49X+/btbU45MxqNWr9+vWrWrJmtfZ2pefPmmjhxorX9ww8/6OOPP5ab290jBDExMVq2bJlNX7NmzTKMu31t621pT7PLisVi0cyZM+0aK0ktWrTQokWLrO358+fbHbBbsGCBkpOT7d4LAFAwcQQGAAAAkMdExZ7TS+2b6dAfu5xdCgAAAAAAAJBnjBo1SkFBQdZ2SkqKOnfurEOHDt3Tejdv3tSwYcP02muvZfp6YmKiOnbsqN27d1v7vLy8tGrVKtWtW/ee9swr2rRpo3Llylnbp0+f1ldffWXX3I8++kgJCQnWdtOmTVW1atUM4wIDA23aO3bssGv9mTNnav/+/XaNlW5dPevp6WltL168WHv27LnrvKtXr2rcuHF27wMAKLgI2AEAAAB5UMLNeA0b0E07flnh7FIAAAAAAACAPMHX11c///yzChUqZO27cOGCmjdvrh9//DHDiWlZ2bp1q+rWravPP/8803nJycl67rnntHnzZmufu7u7li1bpqZNm2bvjWSiX79+MhgM1n/69euX43uk5erqqiFDhtj0jRgxQr/99luW8+bMmaMZM2bY9L3zzjuZjn3sscfk7u5ubS9dulS///57luuvWrVKQ4cOzXJMen5+furbt6+1bbFY1L17d507d+6Oc5KSktStWzdFRUU5tBcAoGDiilgAAAAgl7SqFnj3QVlIsSRr3jf/UZ0SJSUl3HU84KhrRn+1aBuob+aOsvktXwAO4PZuAAAAALiv6tWrp1mzZql///5KTU2VdOvK0ueff15TpkzRgAED1L59e5vT2W47ceKEVq5cqcWLF+uPP/7Icp+XX35Zq1atytDn6uqqjRs3OlRzjRo1VLJkSYfm3A9DhgzR//73P+sJfUlJSWrfvr3effddvf766zY1h4aGauLEiZo1a5ZNILFHjx7q1KlTput7e3ura9eu+vHHHyXdOnGwffv2mjx5svr06WPz86gTJ05oypQp+uabb5SamqqAgAClpKToypUrdr2X8ePHa9myZbp06ZIkKSwsTHXq1NHkyZP13HPPWfdKTU3V5s2bNXToUOu1v0FBQQoLC7PzqwYAKIgI2AEAAAB5mEUWmXylG9c8Je+bzi4H+UyKm4cCAgsr9MxRZ5cCPLiql3V2BQAAAABQ4PTt21c+Pj7q27evzGaztX/Pnj3Wq0FNJpP8/f3l4+OjK1eu6Pz58zbXmqaVWfgt7cl1t02fPl3Tp093uN65c+fm+ol098LV1VULFy5Uy5YtdfbsWUm3rs0dP368JkyYoAoVKshkMikqKirTAFqdOnU0c+bMLPf49NNPtXr1auv3yWw2a+DAgRoyZIiqVKkiDw8PnT9/XhERETZ1BQcH69VXX7U7YGcymbRgwQI9/fTTSkpKkiRdvHhRffr00aBBg1SxYkUVKlRIZ86cUXR0tHVemzZt1KBBA40ZM8aufQAABRMBOwAAACAPczW46dSF66pcPkUck4Sc5pqcpHMxyWpQvwEn2AH36G9xlQwAAAAAOEPnzp114MABvfXWW1q+fHmG16Ojo22CVJkpVqyYPvzwQ7322mu5VWaeV7FiRe3cuVOdOnXSX3/9Ze1PTU3VqVOndOrUqUzntW/fXj///LOKFi2a5fqVKlXSokWL1LVrV8XHx1v7ExMTrSfIpeXp6ang4GC1b9/e4ffSqlUrLV68WM8//7zi4uKs/QkJCTp8+HCG8U2aNNH//vc/TZkyxeG9AAAFCwE7AAAAIJdsPHbBofFDn+2sg8d2WduFCxXRm2O+UOsundRaPjldHiBvc5S2/BqruV+vU1BQkLPLAR5ISyd1dXYJAAAAAFBgBQUF6ZdfftH+/fs1a9YsLV26VBcuZP0zOW9vbzVr1kx9+/ZV586d5eHhcZ+qzbvKlCmjPXv2aO7cuZoyZYqOHDmS6TiDwaB69erpgw8+UMeOHe1ev02bNtqzZ4+GDx+ulStXZjrGzc1NnTt31rhx41SlSpV7eh+S9PTTT+vIkSN65513tHz5ct24cSPDmOLFi+udd97RsGHD5OZGZAIAcHf82wIAAADIgwJ8S+vLpasVn5To7FIAAAAAAAAeCAeuL3R2CXCSWrVqWa9vPXXqlA4fPqzw8HDFxcXJYrHI19dXJpNJ1atXV40aNeTqevebIjK7EjU3BQcHKzg42KE5W7ZsybH9XVxcNGDAAA0YMEBnz57V7t27dfHiRZnNZvn5+alkyZJq1KiRAgIC7mn9qlWrasWKFTp//ry2b9+uiIgIJSQkyGg0qnLlymrUqJF8fX1t5tzr96Bs2bL63//+p5iYGG3ZssX6LJhMJtWsWVMNGza0CdaNGjVKo0aNuqe9AAAFAwE7AAAAII+p8a/HNfl/i+Xu6aH4+/yDPAAAAAAAAOBBVqlSJVWqVMnZZTzQypUrp3LlyuXK2iVLllT37t1zZe30/Pz81KVLl/uyFwAgf3NxdgEAAAAAbnFxcVW7Nj01dcVKuXtyNQUAAAAAAAAAAADgbJxgBwAAAOQRI6ZNV/GSgZm+Fnc99T5Xg4KA5woAAAAAAAAAACBrBOwAAACAPCKzcJ3RaJSPsagWbI9zQkUoCHyMRWU0Gp1dBgAAAAAAAAAAQJ5EwA4AAADIw0wmk0JPh8lsNju7FORTRqNRJpPJ2WUAAAAAAAAAAADkSQTsAAAAgDzOZDIRgAIAAAAAAAAAAACcwMXZBQAAAAAAAAAAAAAAAAAAkBdxgh0AAACQx0VHR3NFLHINV8QCAAAAAAAAAADcGQE7AAAAII+4kZgkd08Pm77o6GhVrBCkWHOck6pCfudjLKrQ02GE7AAAAAAAAAAAADJBwA4AAADIIz595WXVadxUXQa+bO0zm82KNcfphaZFVdTLxYnVIT+Ku56qBdvjZDabCdgBAAAAAAAAAABkgoAdAAAAkEdcizdr+n8/0unjf2voF5/bvFbUy0U+3q5OqgwAAAAAAAAAAAAomDgCAwAAAMhj1qxdoLc7d9SNxCRnlwIAAAAAAAAAAAAUaATsAAAAgDzo0PE/9e+WjXX1UpSzSwEAAAAAAAAAAAAKLK6IBQAAAHJJq2qB2Zp/8WqEPh7QS8W9CudQRQAAAAAAAAAAAAAcQcAOAAAAyMMSkuNVu5yvbiSkSN43nV0O8plrRn+1aBuob+aOkqenp7PLAR5Mrs4uAAAAAAAAAACQmwjYAQAAAHncjUQ3FfK8JlIcyGkpbh4KCCys0DNHnV0K8OCqXtbZFQAAAAAAAAAAchEBOwAAACCXrDsU4dD44c911cG/d9v0tXqyu96fPk3VHvLJydIASZJrcpLOxSSrQf0GnGAH3KO/FeXsEgAAAAAAAAAAuYiAHQAAAJBL3Nwc/M9tg8H6R1eDm94c/h/VaNFU70+flsOVAbd4m6O05ddYzf16nYKCgpxdDvBAWjqpq7NLAAAAAAAAAADkIhdnFwAAAADAlpebtybNWqSn+r3o7FIAAAAAAAAAAACAAo0T7AAAAIA8pLixpL5cvFIBZcs4uxQAAAAAAAAAAACgwCNgBwAAAOQR7Z7rpeadOsqjsFeG1+KupzqhIuR3PFcAAAAAAAAAAABZI2AHAAAA5BFtevXI0Gc0GuVjLKoF2+OcUBEKAh9jURmNRmeXAQAAAAAAAAAAkCcRsAMAAADyMJPJpNDTYTKbzc4uBfmU0WiUyWRydhkAAAAAAAAAAAB5EgE7AAAAII8zmUwEoAAAAAAAAAAAAAAnIGCXiePHj+vAgQOKiIhQQkKCvLy8VKJECVWpUkWPPvqoPDw87nntxMRE/f777/r7778VExMjd3d3lSlTRvXr11fFihVz8F0AAAAAAAAAAAAAAAAAALKDgN3/FxcXp2nTpmn27Nk6ffr0Hce5u7urXr166tatm4YMGWL3+lFRURo9erSCg4N17dq1TMc89thj+uijj9SpUyeH6wcAAAAAAAAAAAAAAAAA5CwCdpJWrVqll156SRcvXrzr2Bs3bmjHjh06ceKE3QG7LVu26LnnntPly5ezHLd371517txZffr00axZs+Tu7m7X+gAAAMjfoqOjZTabnV0G8imj0cgVxAAAAAAAAAAAAHdQ4AN2U6ZM0TvvvCOLxWLT7+npqVKlSql48eK6fv26zp8/f9eAXGZ27NihDh066Pr16zb9vr6+qlChgmJiYhQeHq6UlBTra/Pnz1d8fLwWL14sg8Fwb28MAAAAD5z5kz5Tmx49FFi+rLUvOjpaFSsEKdYc58TKkJ/5GIsq9HQYITsAAAAAAAAAAIBMFOiA3XfffaehQ4fa9LVv315vvvmmWrZsKQ8PD5vXzp07p02bNumXX37Rn3/+edf1Y2Ji1KNHD5twXfny5TV16lR17NjRGp6LiIjQ2LFj9c0331jHLV26VFOmTMlQHwAAAPKv/bt2aNH3MzV2xnw92rSxJMlsNivWHKcXmhZVUS8XJ1eI/CbueqoWbI+T2WwmYAcAAAAAAFDApT38pXlCwqa3AAEAAElEQVTz5tqyZYvzikGB0KJFC23dutXaTn8wEgDkFQU2YHfy5Em9/vrr1nahQoU0b9489erV645zSpUqpd69e6t3796KiYm56x6TJ0/WuXPnrO0KFSpox44dKlWqlM24MmXK6Ouvv1a5cuU0cuRIa/+YMWP073//W35+fo68NQAAADzAridf0/BXemjwsDHqNKC/tb+ol4t8vF2dWBkAAAAAAAAAAABQ8BTYIzBeeeUVJSYmWtsLFizIMlyX3t1Cb1FRUZo2bZpN36xZszKE69J6//331axZM2s7NjZWn332md01AQAAIH9IUbKmffaBvnx3uLNLAQAAAAAAAAAAAAq0AnmC3fLly7V582Zr+7nnntNzzz2Xo3v89NNPio+Pt7abNWumJ598Mss5BoNBn3zyic24OXPmaOzYsTbH8QIAAODBEDxhkkPjw04ft2mvWDVfJ44dEf8lCAAAAAAAAAAAADhHgQzYffvttzbtTz75JMf3WL58uU17wIABds1r2bKlKlSooNOnT0uSLly4oF27dqlhw4Y5XiMAAABy1w/zvsj2GsdO7VWryuWUkhx/98GAg64Z/dWibaC+mTtKnp6ezi4HeDBxezcAAACQZxQve9DZJeQbl8MfcXYJAAAAeUaBC9hFRkZq/fr11natWrVUo0aNHN0jPj5e27Zts+lr06aNXXMNBoNatWqlWbNmWftWrVpFwA4AAKAAc3GxKDXZVVKKs0tBPpPi5qGAwMIKPXPU2aUAD67qZZ1dAQAAAAAAOcJisTi7BAAA8qQCF7Bbt26dUlL+7/+YbNmyZY7vceTIEd28edParlChggIDA+2e37hxY5uA3f79+3OyPAAAANwn5UpUdmj82YsnM/QF+JTWL3sPqm+QtzgmCTnNNTlJ52KS1aB+A06wA+7R34pydgkAAAAAAAAAgFxU4AJ2e/bssWk/+uij1j/v27dPc+fO1datW3X27FklJSUpICBA//rXv9S2bVv16tVLpUuXvusex44ds2lXr17doRrTj0+/HgAAAB4Mc7bscGj80Gc76+CxXdb2I9UaaPCEyfrxoSo5XRogSfI2R2nLr7Ga+/U6BQUFObsc4IG0dFJXZ5cAAAAAAAAAAMhFLs4u4H5LH7CrWLGi4uPjNWDAANWpU0fTpk3TwYMHdfXqVV2/fl1nzpzRxo0b9e677+pf//qXPvjgA5vT6TJz/Phxm3bZso5dF5N+/JkzZ5SYmOjQGgAAAHiwPf1UH32x9Be5uRdydikAAAAAAAAAAABAgVXgTrA7edL22i0XFxc1a9ZM+/btu+vc69ev6z//+Y/27NmjpUuXqmjRopmOu3Tpkk27TJkyDtVYokQJubm5KTk5WZKUmpqqK1eu2HV63t1cunRJUVGOXV+T/msGAACA3OMqNw1+Z4w6vdTf2aUAAAAAAAAAeVZcXJz27dun48eP6+rVq0pKSlLhwoXl5+enoKAgVa9eXSVKlLintVNSUhQSEqKTJ0/q0qVLSkpKkr+/vypUqKDGjRvLw8MjR9/LlStXtGvXLp07d05RUVEqUqSI2rVrpypVHrybLW5/7U6dOqXLly8rLi5ORYoUUenSpVW9enVVq1ZNBoPhntZOSEjQzp07FRkZqUuXLsnV1VUBAQGqXr266tSpc8/rFhRXr17Vzp07de7cOV2+fFlFihRRQECAateunSvPWl58rs+cOaN9+/YpIiJCZrNZBoNB3t7eKlmypCpWrKgaNWrI09PTafUByLsKVMAuNTVVcXFxNn1vvvmmNVxnMBj09NNPq0OHDipTpoyuXbumffv26fvvv9e5c+esczZu3Kh+/fppyZIlme4THx9v0/b29naoToPBIC8vL5ta0695r2bMmKHRo0fnyFoAAADIWWWCKunFt4apdrMmGV6Lu57qhIqQ3/FcAQAAAACA/8fefQdWWd3/A//kBsIIuQlXZKhIALcdKlpsrQtcrQPqKGqrVsVaR2uHu7Yu3LVWbR111N1aV7WiVkWp269arVZRKwm4UMCQXPZKfn/485awQ+7lCTev1z+959znOfcdeYpg3jlnTfOvf/0rRo0aFaNHj4558+Yt99r+/fvHnnvuGcccc0xsttlmK1x7woQJce6558bf/va3qKurW+o1Xbt2jX333TfOOeec6N+//0plrq6ujokTJ0ZERL9+/WLChAkREfH888/HBRdcEI888sgSp6hddtllkU6nY7311ouFCxdGRMT6668fEyZMaHGR7J///GfstNNOufGee+4ZDz744BLXLbrujjvuGGPHjl3pz3jzzTfj/PPPj9GjR0dDQ8Myr+vdu3cMGzYsjjnmmPjqV7+6Ums/++yzcd5558UTTzwRc+fOXeo1PXv2jKOPPjpOOumkZW6UUygTJ06M6urq3PiII46IG264Ybn33HfffbHvvvs2m7vlllvikEMOWe59J5xwQlxxxRW58ZtvvrnCZ/upp56Ks88+O5566qncJj+L22CDDeLYY4+N4447LsrKypa73hdW9bnOR8Huqquuih//+MfR2Pj5f98sLS2Na665JkaOHLnEtY2NjXH99dfHH/7wh3j99deXu25ZWVkMGjQo9ttvvzj22GOjS5curc4KFId2VbBraGiIpqamZnP/+te/IiJirbXWivvuuy+23377Zu+PGDEizjjjjDj66KPjjjvuyM3fe++9ccstt8Shhx66xOcsXoZblYZzoQp2AAC0XT//7aVLzKXT6ahMV8TtT09fyh3QepXpikin00nHAAAAAFihCy+8MH75y1/mSjUrUltbG7///e+jsrIyRo0atdxrR40aFeeee+4KS3uzZs2K2267Lf7617/GVVddFUceeeRK51/UxRdfHKeeeuoS379eVO/evWP33XePhx56KCIi3n///Rg7dmzsvPPOLfqsm2++udn4sMMOa3ngZZg/f36ccMIJce21167Ur8snn3wS1157bTzyyCO5QtayzJw5Mw4//PC46667Vrju5MmT49xzz43rrrsuHnjggdhmm21W9ktotX79+sWAAQOipqYmIiKeeOKJFd4zZsyYJeaeeOKJFRbsFr2vd+/eyy3XzZs3L0aOHBm33nrrCvO899578fOf/zyuvvrqeOCBB2KTTTZZ4T1LszLPdWudfvrpccEFF+TGXbt2jb/+9a+x5557LnHttGnTYu+9945nn312pdaeN29ePP/88/H888/HsGHDYoMNNshbbmDN1q4KdssqqZWWlsbo0aNj8ODBS32/W7duceutt8bUqVPj0Ucfzc2ff/75ccghhyzxEwJz5sxpNl7ZhveiFt9WePbs2S1eAwCANV8mk4ma2gmRzWaTjkKRSqfTkclkko4BAAAAsFw33HBDnHbaaUvMV1RURHV1dZSXl8fs2bOjrq4uPvzww5Uu+CxcuDCOPPLIJUpoEZ9v0rLuuutGWVlZTJo0KT766KPce1+Ul7LZbPzsZz9r0ddy7bXXximnnJIbl5WVRXV1dVRWVsbHH3/c7HS1ww47LFewi/h8l7OWFOxmzZoVd999d27cvXv32GeffVqUd1kaGhpin332iaeeemqJ97p06RJ9+/aN7t27RzabjQ8++KBFm8pMnjw5vv3tb8crr7yyxHvrrbde9OrVKxYuXBgTJ06MadOm5d775JNPYqeddop//OMf8c1vLnlSSKEMGTIkV7CbMGFC1NTUxIABA5Z5/dJKeCsq5n366afx5ptv5sbLew7mzp0be+21Vzz++ONLvNenT59Yd911I5vNRm1tbbNd5v773//GN7/5zXjsscdiyy23XG6exbXkuV4V8+fPjyOPPLJZYXDttdeOBx98ML72ta8tcX1TU1MMGzZsiXJdSUlJ9OnTJ3r37h0dO3aM6dOnx8cffxz19fWtygcUt3ZVsFvWTnIjR45cZrnuC6lUKq6++urYcMMNc837d955Z4ntdJf2OSv6KYelWXxr23yd833sscfGAQcc0KJ73nvvvRg+fHhePh8AgJbLZDIKUAAAAAC0W3Pnzo2TTz652dx+++0Xp512Wmy11VZLbIgyffr0eOmll+Khhx6K2267bblrn3POOc3KdR07doxjjz02fvjDHy6xO9j48ePjkksuiT/+8Y+5At/JJ58cgwcPjm984xsr9bXU1dXlCnl9+vSJUaNGxQEHHNDsWNPa2tqYOXNmRETss88+UVVVlSv/3HPPPfGHP/whunbtulKfd9999zU7OW3EiBFLbPayqg4//PAlynU77rhjnHbaabHTTjs1+5zGxsYYN25c3H///XHbbbfFrFmzlrluY2NjHHjggc3KdWuvvXacfPLJ8f3vfz969+7d7Nrnn38+fv3rX+cKarNmzYqDDjooXnvttVhrrbXy8rWuyNChQ+P666/PjZ944ollFuwmTZoU48aNW2L+/fffj/fee2+Zu6YtXsAbOnToMvOcfvrpS5Trhg8fHmeffXZ85Stfyc3V1dXFDTfcEGeeeWZu05/PPvssDjjggHjttdeiW7duy/yMRbX0uW6p6dOnx3777RePPfZYbm7AgAHxyCOPxIYbbrjUe+6+++54+umnc+Py8vI466yz4pBDDolevXotcf0HH3wQTz75ZNx///3xwAMPrFJOoHi1q4Ldsn7zP+qoo1bq/gEDBsQuu+zSbBe7pRXsFv+cxXe0WxmL71i3sv/iWpGePXtGz54987IWAAAAAAAAQKGNGTMm6urqcuNDDz10qTvOfaGioiKGDBkSQ4YMifPPPz8+/PDDpV733HPPNTs6tkePHvHwww/H1ltvvdTrBw4cGNdcc03svPPOcfDBB0djY2MsWLAgjjnmmPj3v/+9Ul/LF2W3TTfdNJ544olmZbEv9O/fP/e6c+fOMWLEiLj22mtz9997773x/e9/f6U+r1DHw1577bVx33335cYlJSVx8cUXx4knnrjU61OpVGy++eax+eabx2mnnRZjx45d5tqXXHJJPPnkk7nx4MGD44EHHljq97lTqVRst9128dhjj8UJJ5wQv//97yMi4sMPP4xzzjknLr/88lX8CltmyJAhzcZjxoyJkSNHLvXaRYtymUwmunXrFu+//37uvpUt2C3+mV946aWX4rLLLms29+tf/zrOPvvsJa7NZDJx0kkn5f7/8sVJKuPHj48zzjgjfve73y31MxbX0ue6JT755JP49re/Ha+++mpubtCgQTF69OilFuW+sPjRwn//+9+Xu+tf375949BDD41DDz00Pvjgg+jevfsq5QWKUyrpAKtTly5dorS0tNlcRUVFi7Y23XHHHZuNX3755SWuWbwM19IWdlNTU8EKdgAAAAAAAABrknfffbfZ+Nhjj13pe8vKypa5k9g555yTO70slUrF/fffv8xy3aJGjBgRv/jFL3Lj119/falHcS5Lx44d469//etSS0hLs3gp7pZbblmp+z766KMYM2ZMbrzRRhvFtttuu9I5l2XBggVx/vnnN5s77bTTllmuW1xJSckyi06zZs2Kiy++ODfu06dPPPTQQyvcRCaVSsXvfve7Zl/fjTfeuNqO/ezZs2dsvvnmufHyjntd9L2dd9652U50i/56Le++6urqZRbWLrvssmZHJO+1115LLdctatCgQfHHP/6x2dz1118fDQ0Ny71vUS19rlfG22+/HV//+teblev22GOPGDt27HLLdRHNf9/YZJNNWnS0ct++fXU0gGba1Q52EZ//i23SpEm58QYbbBCp1Mr3DDfeeONm48mTJy/1Mxa1rJ+IWJZPP/00FixYkBunUqno0aNHi9YAAKB41NXV5X5yEPItnU47ghgAAABo0xbfnKRjx46tXnPcuHHxj3/8IzceMWLESh/zGhFxyimnxGWXXZb7vu4999wTu+yyy0rdO2LEiPjSl7600p/19a9/PTbaaKNcYWjMmDHx0Ucfxbrrrrvc+2677bZcgTAif7vX3Xvvvbkd1yI+PwnurLPOysvat9xyS7PdCs8666yV/m9XpaWlcdppp8WwYcMiImLGjBnxj3/8I0aMGJGXbCsyZMiQePPNNyPi8x7Bf/7zn6X+Oi9alBs6dGik0+n405/+FBERY8eOjaampiWOPZ44cWLU1NQ0+6ylqa+vj3vuuSc3LikpiUsvvXSl8o8YMSJ+97vfxQsvvBARn28kdMcdd8Qxxxyz0ve35Llekeeeey723nvvZs/DYYcdFtdff3106LDiqsuiv2/k4/cMoH1rdwW7TTfdtFnBLp1Ot+j+xa+fNm3aEtcsXsJb9A8XK2Px6/v16xedO3du0RoAAKx5/vPCi7HZ17Zp9gMgdXV1MaB/dTRkpyeYjGJWma6ImtoJSnYAAABAm7XOOus0G992222x1VZbtWrNhx9+uNn4kEMOadH9a621VgwaNChefPHFiIh4+umnV/regw46qEWfFfH5sbhnnHFGREQ0NjbGbbfdFqeccspy71l0p7tUKtXir3FZHn300WbjY445Jm8Fpoceeij3ukOHDnHggQe26P6hQ4dGKpXKFQuffvrp1VawGzp0aFx55ZW58ZgxY5YonNXU1MSECRNy4yFDhjTrIEyZMiVef/31+OpXv9rsvsV3tlt017tFPf/88zFv3rzc+Jvf/GZstNFGK/01HHHEEbmCXUTEU089tdIFu1V5rpflb3/7Wxx88MHNSnKnn356nHfeeSu9xjrrrJMrpb711lvx6quvtuh0Q4BFtbuC3WabbdasET537twW3T9nzpxm465duy5xzSabbNJs/NZbb7XoM8aNG7fc9QAAKE43XnxBLJg/Py658+7o1LVLRERks9loyE6P721fERVdVn7nZVgZ02c3xu1PT49sNqtgBwAAALRZQ4YMidLS0li4cGFEfH4E5pw5c+LEE09c5vGvK7J4IW5ljoZd3Prrr58r2L399ttL3Xlsab72ta+1+LMOPfTQ+PWvf50rjt16663LLdi9/PLLzb5PvfPOO0ffvn1b/LlLs/g/u29/+9t5WbepqSmeffbZ3HijjTZq8YY55eXlsdZaa8WUKVMiYsnvvRfSjjvu2Ow5feKJJ+KEE05ods2iRbl11103t3nPpptumsv6xBNPrLBgt6wd7L54Hld03bIsXtxbtGy3IqvyXC/N1VdfHccff3yz45t///vfr3TR7wu77rprjB07NiIiFi5cGHvssUecd955cfDBBy+15wGwPO2uYLf4TzJ8+umnLbp/8SNh11prrSWu2XzzzaNjx44xf/78iIiYMGFCTJo0Kfr06bNSn7HoHxoiIrbYYosWZQQAYM311nuvxA+GbBeX3/Ng9Fz3fz+ZW9ElFZXlpQkmAwAAAIBk9O3bN4444oi47rrrcnNXX311XH311TFo0KDYZZddYocddohtt912pX+IcPHiVc+ePVuVceHChZHNZqOysnK513Xr1i169OjR4vX79u0bO++8c65o9eabb8Yrr7wSgwYNWur1i+5eF5G/42EjotlRpeXl5bHpppvmZd1PP/202XGgb7311koVFpdn0fUKraqqKrbccst4+eWXIyLin//8ZyxcuDBKS//333UXPx520ddfPJNjxoyJn/3sZ83WfvLJJ3OvN9100+jdu/dSM0ycOLHZ+Ctf+UqLvoYBAwZERUVFTJ/++YkqH3zwwUoVR1f1uV7cL3/5yzj//PNz4y5dusQdd9wRw4cPb/FaP/rRj+KKK67IdUImT54cRx11VJxwwgmxyy67xM477xzbbbddbLHFFo6QBVao3W2BseeeezY7cqu2trZF/1J95ZVXmo0XPw42IqKioiJ22GGHZnOPPfbYSq3f1NQUjz/+eLO5vffee6XzAQCw5pvS8HGM/NYO8cbzK//TgQAAAABQzK644oqlft/0lVdeiYsuuij23HPP6NGjR2y55ZZx+umnx5tvvrnc9T777LO8Z2xoaFjhNS3dkW1Ri5fkbr755qVeN3/+/Pjzn/+cG3fr1i323XffVf7cRWWz2ViwYEFu3KNHj1aX4L6Q1K9JPi26Y1xDQ0OubPeFRYtyixbsFr3vqaeeavbPeNy4cTFp0qSlXru4adOmNRuvSult0U2GFi5cmCvbLU9rnutFLVqu69ChQzz22GOrVK6LiMhkMvHggw8usRHSrFmz4oEHHoif/exn8bWvfS0ymUx8+9vfjuuvvz7q6+tbkR4oZu2uYNezZ8/Ybrvtms3de++9K3XvggUL4r777ms2t9NOOy312n322afZ+IYbblipz3jyySejtrY2N+7Vq1cMHjx4pe4FAKB4zJo/I048cv945m8PJB0FAAAAABLXuXPnuP/+++OOO+5Y5glgTU1N8dprr8UFF1wQX/rSl2KvvfaK9957b6nXFqJI88WRlsvTmp2y9t133+jWrVtu/Je//CV3qtqiHnrooZg6dWpuvP/++0d5efkqf+6iFi9bLZqntZL6NcmnxY9YXXTHuv/85z/NTthb9Nqddtopt1HQ9OnT46WXXsq9t/jxsIt/xqJmzJjRbLwqv+6L37MyBbt87QDXqVOn3OsFCxbEzTffHE1NTau83tZbbx3/+c9/4qSTTlrm7pYzZsyIhx9+OI466qhYf/3146yzzlrq/6+A9q3dHREbEXH00Uc3Oxf+kksuiUMOOaTZb9ZLc91118Unn3ySG6fT6dh9992Xeu2BBx4Yp59+esycOTMiPm+ZP/HEE8ttkzc1NcXZZ5/dbO7www9vtuMeAABrjl02Xfo2/StrYdOCuPnaC2KrXn0iYlZ+QsEiZqbXjp127x3X/ums6Ny5c9JxYM3k9G4AAIDVpqSkJA466KA46KCD4q233orHHnssxo4dG88880yzQtkXRo8eHU899VSMHj06tt9++2bvde3aNbLZbG788MMPR4cOrfv2+bKO7cyX8vLy2H///eOmm26KiIgpU6bEww8/vMTmL4vvbJfP42ErKiqajRcvdLVG165dm40322yzuPzyy1u1ZpcuXVp1f0t985vfjLKyspg3b15EfF6OO+200yKiedluo402inXXXTc37t69e2y11Va5He/GjBkTX//615e4L5VKLXMToIglC49f9BVaYvF7Fv81L6S//e1v8Z3vfCfmzJkTEZ93NObNmxc33njjKvcmMplMXHzxxTFq1KgYO3ZsPPnkk/HPf/4zXn755SWKdNOnT4+zzz47Hn/88Xj00UeXeCaB9qtdFuwOOuiguOiii+KNN96IiIh33303jj766OX+pvziiy/GySef3Gzu2GOPjcrKyqVe37Nnzzj++OPjoosuys2NHDkynnnmmVhnnXWWes8FF1wQTz31VG5cWVkZJ510Uou+NgAAiktTNEWmKmLezM4R5X5qjvxa2KFT9OzdNWomvpV0FFhzbdY36QQAAADt0mabbRabbbZZnHDCCdHU1BRvv/12PProo3H33XfHM888k7tu+vTpsf/++8f48eOblY969OjRrGC31VZbRc+ePVfr17AqDjvssFzBLuLzMt2iBbu6uroYPXp0btyvX7/Ycccd8/b56XQ6OnTokDvCdOrUqdHU1JSXY2IXP860qakpdtlll1avuzp17do1Bg8enNvw59lnn425c+dGp06dmu1Et7Rd6IYMGdKsYHfGGWdEY2NjjB07NnfNFltsEd27d1/m5y/+3qocu7voPaWlpau1YLfHHnvE6NGjY++9945Zsz7/ofObb7455s2bF7fcckurSrBlZWWx2267xW677RYREbNnz44XXnghHnroobjjjjvi448/zl377LPPxoknnhhXXXVV674goGi0y4JdKpWKyy67LHbdddfcdqI333xzfPTRR3HhhRfGoEGDctc2NDTEDTfcEGeeeWaz9v1GG20Up59++nI/5+STT46bb745t+tdbW1tfOMb34grrrgi9t5779wfMj788MMYNWpUXHvttc3u/+Uvf7nMbUoBAGgfSks6xPhPZscG/RaGbZLIt9IFc+PjaQti28Hb2sEOVtHbMSXpCAAAAO1eSUlJbLrpprHpppvGCSecEE8//XTsu+++uV3tJk+eHLfeemscc8wxuXv69+8fNTU1ufF77723RhTsdtxxx+jXr19MnDgxIiIefPDBmDZtWq5Y9ec//zm3e1pExKGHHpqX8tuiNthgg3j77bcj4vPdzsaNGxebbbZZq9ft3bt3dOnSJWbPnh0RERMnToz58+fn7fjR1WXIkCG5gt2cOXPiueeeix122KHZZjtLK9gNHTo0Lr744oiIeP7552P27Nnx1ltvxbRp05qtvTz9+vVrNv73v/8d3/nOd1Y6e01NTbMjYddff/28Pz8rMmTIkHjkkUdizz33zGX54rn+85//nLfnoUuXLrHzzjvHzjvvHOeff36cffbZcd555+Xev/766+PCCy+MdDqdl88D1mztsmAX8fm/nC644II49dRTc3OPP/54bL311tG7d+9Yb731YubMmTF+/PhmfwCJiFhrrbXi7rvvXmFTO5PJxJ133hm77757bgvTiRMnxrBhw6Kqqir69+8f9fX18f7778fChQub3Tts2LA48cQT8/TVAgCQhMfHfdKi63++7/B4fdwLuXHXjt3iJ+f8Nnb9zrDYNZa+czK0Rnl2Sox9tCH+dM0jUV1dnXQcWCPde/F+SUcAAABgMdtvv31ceOGFMXLkyNzcM88806xgt/POOzfbUeyJJ56Ib3zjG6s156ooKSmJQw89NM4999yIiJg3b1785S9/yX1tt9xyS7PrDz300Lxn2H777XMFu4iIhx56KC8Fu44dO8Z2220Xjz/+eEREzJo1K1588cX45je/2eq1V6ehQ4fG2WefnRuPGTMmunXrFvX19RHx+YZAO++88xL3LXq87Ny5c+PZZ5+NV199dYm1l2fbbbdtNn7iiSfirLPOWunsix5Hu7T1Vpftt98+Hn300dhjjz2ioaEhIiLuueee2G+//eKuu+6KTp065fXzOnbsGKNGjYp//vOfuR0w58+fHy+++GLsuuuuef0sYM20aodUF4lTTjklrrjiiiUazp988km8/PLLMW7cuCXKdRtvvHE8//zz8eUvf3mlPmOHHXaI0aNHL7ETXX19fbz66qtRW1u7RLnu4IMPjjvvvHO1N8EBAGg7elatGzf+45nYYIuvJB0FAAAAANY42223XbPxF7vZfWGPPfZoNv7jH/8Y8+fPL3iufDjssMOajW+++eaIiHj77bfj//7v/3Lz2223XWywwQZ5//zF/9ldffXVeftnt/jaV155ZV7WXZ223Xbb6Nq1a278xBNPNCtzbrHFFks9ya5r167NCm2L39exY8fYfvvtV/jZZWVlufEzzzwT77333kpnv/HGG5uN83m8cEttu+22MWbMmGb/rP7+97/H8OHDcxsc5duKft8A2q92XbCLiPjxj38cr7/+eowYMWK5W4n2798/Lr/88nj99ddjww03bNFnDBkyJN5666045phjmv2LdHFbbrll3HPPPXH77bfnvXENAMCaY/MNt4mbnnwuevTpnXQUAAAAAFgjLV6M+eII1S8MGjSo2S5iH3zwQZxxxhmrJVtrDRw4sNmubi+++GK8++67S+xet3gRL1+GDRvW7DSEmpqaFu2StjwjR46Mqqqq3Pjuu++O0aNH52Xt1aVjx47Nfn1eeumluP/++3Pj5R3zuugOdY888khuN7WIiK997WtRXl6+3M+uqqqK/fffPzduampa6ZPz7r777nj++edz427dusVBBx20UvcWyqBBg+LJJ5+MtddeOzf3yCOPxF577RWzZs3K++et6PcNoP1q9wW7iIhNNtkk/vKXv8TUqVPj4YcfjiuuuCLOPffcuOyyy+KOO+6It99+O2pqauInP/lJs7Z3S/Tq1SuuuuqqmDp1ajz++ONx5ZVXxrnnnhsXXXRR3HbbbfHf//43/vWvf8W+++6b568OAIA1RSpVGnvsdmBc/sDfo6yzH7gAAAAAgIiIX/3qV3HbbbfFggULVur6pqamuPTSS5vNDRo0aInrzj333Eil/vct84svvjjOOeecaGpqWulsH374YZx00knx0ksvrfQ9+bB4ee6mm26K2267LTfu3LlzfPe73y3IZ5eWli5RRrzggguW+Ge+LE1NTfHkk08u9b3Kyso45ZRTcuPGxsY46KCD4oEHHmhRxldeeSVGjBjRonvyadES3YIFC+KFF17IjZd3zOui97366qsxc+bMpb63PD/72c+aPdf3339/jBo1arn3vPbaa82OVI74vOyYTqdX6jML6Stf+UqMHTs2evf+3w+kjxkzJvbYY4+YMWPGUu/JZrPxve99b4kjdpdnwoQJcffdd+fGqVQqtthii1XODRSXDkkHaEvS6XTsscceS2w7m09dunSJoUOHrvBsdAAA2p9Tr/zDMnetmz67cTWnoT3wXAEAAABrgjfeeCNGjRoVv/jFL2LfffeNYcOGxTbbbBNrrbVWs+saGxvjueeei7PPPjsef/zx3HzXrl3j4IMPXmLd7bbbLs4777w47bTTcnNnnnlmPPDAA3HiiSfG7rvvvsQOVgsXLox33303nn766bjnnnviiSeeiAULFsSee+6Z5696+b773e/GT37yk5g9e3ZERFx22WXNjs0cPnx4VFZWFuzzjzzyyHjkkUdyhaQvdkobPXp0nHrqqbHjjjs2O7WtsbExxo0bF/fff3/ccsstMWfOnJgwYcJS1z755JPj6aefjoceeigiIqZPnx7Dhw+P4cOHx/HHHx/bbbfdEifCzZkzJ15//fV4/PHH45577ol//etfERFx5513FuCrX7Fl9QFWdMzr4MGDo7y8vFmxbkVrLm7rrbeOn/3sZ80Kj7/61a/itddei7POOiu+9KUv5eanTZsWN9xwQ5x55pnNdoQbOHDgCkt5q9Nmm20W//znP2PIkCHx0UcfRUTE008/Hbvttls8/PDDSzzrjY2Ncccdd8Qdd9wRW2+9dey///6x6667xpe+9KUlNlXKZrNx1113xRlnnBENDQ25+b333rtZqQ9o3xTsAACgjVhauS6dTkdluiJuf3p6AoloDyrTFW3iJ1EBAAAAVmTy5MlxzTXXxDXXXBMREX369IkePXrkCkm1tbVL3dHq0ksvjXXXXXepa5566qkxefLkuOyyy3Jzr7zyShx00EGRSqVi/fXXzxX56uvrY9KkSQU5mrKl0ul0DB8+PP785z9HRDQr10UU7njYRd1www0xZcqU+Oc//5mbe/LJJ+PJJ5+Mrl27Rt++faOqqiqmT58e77//frNfm379+i1z3VQqFXfccUcMHz48xo4dGxGfF/juu+++uO+++6JTp07Rr1+/6N69e8yZMyfq6+vjww8/jIULFxbsa22prbbaKqqqqqK+vr7Z/LbbbrvcY16/KOA98sgjzea7dOkSX//611f6888777z497//3axoes8998Q999wT66yzTqyzzjoxffr0qKmpifnz5ze7d6211oq//vWvKzyOdnXbaKON4qmnnoohQ4bExIkTIyLi+eefj1122SUeffTRZR7n+vLLL8fLL78cp556apSVlcV6660X3bt3j9LS0vjss89iwoQJSzw7a6+9dlx55ZUF/5qANYeCHQAAtGGZTCZqaidENptNOgpFKp1ORyaTSToGAAAAQItNmjQpJk2atMz3u3TpEpdddlkcffTRy13nt7/9bWyxxRZxwgknNCtENTY2xoQJE5a509oXKioqoqqqqgXJ8+Owww7LFewW1adPn9h1110L/vnpdDoeffTROO644+KGG25odrTurFmz4p133lnltSsrK+Oxxx6LU045Ja644opmxwPPnTs33n333RWu0bdv31X+/NZKpVKx4447xv33399sfmV2oRs6dOgSBbvttttuiZ3XlqdTp04xevToOPLII5sdHRwR8fHHH8fHH3+81Ps23HDDeOCBB2KTTTZZ6c9anQYMGJAr2Y0fPz4iPi/QDRkyJB577LHo0aPHcu+fN29e1NTULPeaTTbZJO6///5Enx+g7VGwAwCANi6TyShAAQAAANBuXXfddTFs2LAYPXp0PPPMM/Hpp58u9/pMJhPf/e5349RTT13uTmmLOvTQQ2PYsGFx5ZVXxq233rrCAlf37t1j6NChsc8++8R+++0XXbt2XemvJ1922WWXWGeddZYoS33ve9+L0tLS1ZKhrKwsrrvuujjuuOPi3HPPjX/84x9LPd70C/369Yvhw4fHj370oxWu3aFDh7j00kvjuOOOi4suuij+9re/xeTJk5d7T3V1dey2226x//77r/SRqoUydOjQJQp2Q4YMWan7Frcy9y2urKwsbr311hg5cmScc8458dRTTzUrKi5q4MCBceyxx8bxxx/foiJfEtZff/345z//GUOHDs2VOF977bXYaaedYsyYMdGrV6+oqqqKV199Ne6///547LHH4uWXX465c+cud92vfOUrMXLkyPjRj34UHTt2XB1fCrAGKWlatEYOS/Hmm282O4f9P//5T2y++eYJJgJgTXHBd34d7zz3Zmz8jc3jtPvOSToOrBZ7HPmtKCkpiaampnjkhoeTjgNAgX314v0iSkoimpri3yffk3QcAABYoyxYsCD++9//NpvbcMMNo0MHe4SwfLW1tfHOO+/ExIkTo6GhIebNmxfdunWLtddeO7785S/HZptt1urn6KOPPoqXXnopJk+eHJ999lmkUqlIp9Ox7rrrxqabbhoDBw6MVCqVp6+oeMydOzeef/75mDhxYkyZMiXmzZsXFRUVsf7668eXvvSlGDhw4Cqv3dTUFG+++Wa8+eabMXXq1Kivr49OnTpFZWVl9O/fPzbbbLNYZ5118vjVFJf6+vp45pln4uOPP47PPvssysvLo1evXrHFFlvExhtvnHS8gpo7d2689dZb8d5778WkSZNixowZUVJSEul0Oqqrq2OLLbZY5jHSUCwK9eeu9tIp8qdTAABo4+rq6hwRS8E4IhYAAABY0/Tv3z/69+9f0M9Yd911FW5WQadOnWKnnXYqyNolJSXxpS99qVmRg5VXVVUVe+21V9IxEtGpU6fYcsstY8stt0w6CrCGUrADAIA2Yt6cuVHWuVOzubq6uhjQvzoastMTSkWxq0xXRE3tBCU7AAAAAACApVCwAwCANuLcHx4VW223fXzn6KNyc9lsNhqy0+N721dERRdHTpBf02c3xu1PT49sNqtgBwAAAAAAsBQKdgAA0EbMnJGNP/zuV1H7ztvx899e2uy9ii6pqCwvTSgZAAAAAAAAtE+2wAAAgDbmoYdvj58N3yfmzZmbdBQAAAAAAABo1+xgBwAAbdAb7/xfHL7zdnHS5VcnHQUAAAAAYI02bdq0eOWVV/K+7uabbx59+vTJ+7oAtC0KdgAAUCC7bNq7Vfd/Wv9h/PrIg6JHl655SgQAAAAA0P78+9//jl133TXv6/7pT3+KH/zgB3lfF4C2RcEOAADasFkLZsSW61fFvFkLI8rnJx2HIjMzvXbstHvvuPZPZ0Xnzp2TjgNrptKkAwAAAAAAUEgKdgAA0MbNm9MhOnaeGVoc5NvCDp2iZ++uUTPxraSjwJprs75JJwAAAAAAoIAU7AAAoEAeeePDFl1/8gH7xetvv9hsbpeh343T/nBlbLpxZT6jQURElC6YGx9PWxDbDt7WDnawit6OKUlHAAAAAFZgp512iqampqRjALCGUrADAIAC6dChhX/cLinJvSwt6RA/OfmC2Hyn7eO0P1yZ52TwufLslBj7aEP86ZpHorq6Ouk4sEa69+L9ko4AAAAAAEABpZIOAAAANNelQ3lcfN1dsecPDkk6CgAAAAAAALRrdrADAIA2pEe6T1xx99+jZ9/1ko4CAAAAAAAA7Z6CHQAAtBF7HHBQ7Dhsn+jUtcsS702f3ZhAIoqd5woAAAAAAGD5FOwAAKCN2O2gEUvMpdPpqExXxO1PT08gEe1BZboi0ul00jEAAAAAAADaJAU7AABowzKZTNTUTohsNpt0FIpUOp2OTCaTdAwAAAAAAIA2ScEOAADauEwmowAFAAAAAAAACUglHQAAAAAAAAAAAADaIgU7AAAAAAAAYLUrKSlZYq6xsTGBJAAAxW1pf8ZKpdTGVpYjYgEAoI2rq6uLbDabdAyKVDqddgQxAAAAiVjaN3Xnz58fZWVlCaQBAChe8+fPbzYuKSlZ6g87sHQKdgAA0EbccvFvYrcRI6J3v765ubq6uhjQvzoastMTTEYxq0xXRE3tBCU7AAAAVruSkpIoKyuLefPm5eay2WyUl5cnmAoAoPgsvpFDx44dFexaQMEOAADaiNdeeCbuuvXqGHXVLfHV7beLiM//wtOQnR7f274iKrrYqpv8mj67MW5/enpks1kFOwAAABJRWVkZU6ZMyY2z2Wysvfba0aGDb2MCAOTDggULlijYVVZWJpRmzeRPpgAA0IbMXjAzTv7hiDj2xHNi2JFH5OYruqSisrw0wWQAAAAA+bd4wa6xsTEmTpwYffv2dVQsAEArzZs3Lz744INobGxsNq9g1zIKdgAA0MYsjAVx5W9Oj4lvvx37HHds0nEAAAAACqZjx45RXl4eM2fOzM3NmzcvampqomvXrtGtW7fo2rVrlJaWOsYMAGAFmpqaYuHChTFr1qyYMWNGzJo1K5qamppdU15eHh07dkwo4ZpJwQ4AAArkpgsvbtH1E2rfaTZ+4MFb4r/j3gz/6RgAAAAoZr169Yr3338/FixYkJtramqKmTNnNiveAQDQOh07doxevXolHWONo2AHAAAFctvNv231GuPGvxK7bLB+LFwwIw+JoLmZ6bVjp917x7V/Ois6d+6cdBxYMzm9GwAAWq1Tp05RXV0dH3zwQcydOzfpOAAARalTp07Rt29fu9etAgU7AABo41KppmhcUBoRC5OOQpFZ2KFT9OzdNWomvpV0FFhzbdY36QQAAFAUOnbsGP369YtJkybF9OnTk44DAFBUKioqok+fPlFa6ieGV4WCHQAAFMj6vTZo0fXvf/reEnM9K9eNv73yehxWXR62SSLfShfMjY+nLYhtB29rBztYRW/HlKQjAABA0SgtLY311lsvFi5cGDNnzowZM2bEjBkzYuFCP3QIANASpaWl0a1bt+jWrVuUl5cr1rWSgh0AABTIjWOfadH1P993eLw+7oXc+CubbhvHXnhJ/HnjjfIdDSIiojw7JcY+2hB/uuaRqK6uTjoOrJHuvXi/pCMAAEDRKS0tjXQ6Hel0OiIimpqaorGxMZqamhJOBgDQtpWUlEQqlYqSkpKkoxQVBTsAAGiD9trz0Pjpby6OCRMmJB0FAAAAIFElJSV2XQEAIDEKdgAA0IaURoc49hfnxLCRRyQdBQAAAAAAANo9BTsAAGgj1qseGIf89MTYcodvLvHe9NmNCSSi2HmuAAAAAAAAlk/BDgAA2oif//bSJebS6XRUpivi9qenJ5CI9qAyXRHpdDrpGAAAAAAAAG2Sgh0AALRhmUwmamonRDabTToKRSqdTkcmk0k6BgAAAAAAQJukYAcAAG1cJpNRgAIAAAAAAIAEpJIOAAAAAAAAAAAAAG2Rgh0AAAAAAAAAAAAshSNiAQCgjaurq4tsNpt0DIpUOp12BDEAAAAAAMAyKNgBAEAb8Z8XXozNvrZNpFL/22i6rq4uBvSvjobs9ASTUcwq0xVRUztByQ4AAAAAAGApFOwAAKCNuPHiC2LB/PlxyZ13R6euXSIiIpvNRkN2enxv+4qo6JJawQrQMtNnN8btT0+PbDarYAcAAAAAALAUCnYAANCGvPXeK/GDIdvF5fc8GD3XXSc3X9ElFZXlpQkmAwAAAAAAgPbHFhgAANDGTGn4OEZ+a4d44/kXko4CAAAAAAAA7ZqCHQAAtEGz5s+IE4/cP5752wNJRwEAAAAAAIB2yxGxAABQILts2rtV9y9sWhA3X3tBbNWrT0TMyk8oWMTM9Nqx0+6949o/nRWdO3dOOg6smZzeDQAAAABQ1BTsAACgDWuKpshURcyb2TmifH7ScSgyCzt0ip69u0bNxLeSjgJrrs36Jp0AAAAAAIACUrADAIA2rLSkQ4z/ZHZs0G9h2CaJfCtdMDc+nrYgth28rR3sYBW9HVOSjgAAAAAAQAEp2AEAQIE8Pu6TFl3/832Hx+vjXsiNu3bsFj8557ex63eGxa5Rme94EOXZKTH20Yb40zWPRHV1ddJxYI1078X7JR0BAAAAAIACUrADAIA2qGfVunHFvaNjxtw5SUcBAAAAAACAdiuVdAAAAKC5zTfcJm568rno0ad30lEAAAAAAACgXVOwAwCANiKVKo09djswLn/g71HWuVPScQAAAAAAAKDdc0QsAAC0Eade+Ydl7lo3fXbjak5De+C5AgAAAAAAWD4FOwAAaCOWVq5Lp9NRma6I25+enkAi2oPKdEWk0+mkYwAAAAAAALRJCnYAANCGZTKZqKmdENlsNukoFKl0Oh2ZTCbpGAAAAAAAAG2Sgh0AALRxmUxGAQoAAAAAAAASkEo6AAAAAAAAAAAAALRFdrADAIA2rq6uzhGxFExbPSLWc0+htdVnHwAAAACAtkXBDgAA2oh5c+ZGWedOzebq6upiQP/qaMhOTygVxa4yXRE1tRMSLRotXLAgSjv876+nnntWh7bw7AMAAAAA0PYp2AEAQBtx7g+Piq222z6+c/RRublsNhsN2enxve0roqJLKsF0FKPpsxvj9qenRzabTbRkdNEpI+KEs2+M8m6VEeG5p/DayrMPAAAAAEDbp2AHAABtxMwZ2fjD734Vte+8HT//7aXN3qvokorK8tKEkkFhvfbimPjlUUPjtN/cFb3W7Z+b99wDAAAAAABJsxUAAAC0MQ89fHv8bPg+MW/O3KSjwGrz4YR34tQjd4q3Xns26SgAAAAAAAA5CnYAANAGvfHO/8XhO28X9ZOnJB0FVpvpDXVxzo/3jpf+eX/SUQAAAAAAACLCEbEAAFAwu2zau1X3f1r/Yfz6yIOiR5eueUoEhTHlkw9izAM3x1OP/CUmT5rYqrUWLJgfd15zRmzetyyamprylBAAAAAAAGDVKNgBAEAbNmvBjNhy/aqYN2thRPn8pONQZOq79ojh31k3fn3WgZFKrfoG540LF8ac2TMiOkSk+q6fl2yb9Y2YVlISszqWREleVoT/mdu1Qww/qCTOvOAHrXr2IyKif/f8hAIAAAAAoE1SsAMAgDZu3pwO0bHzzIgoTToKRaaxrFOUdSmPudEY0di46guVRJR0Lc9fsEXMLciqEFEWEXPmzsrDSgp2AAAAAADFTMEOAAAK5JE3PmzR9ScfsF+8/vaLzeZ2GfrdOO0PV8amG1fmMxpERERq3tyYMz+iIl3R+l28/r/OXcqj93oDWnTPW68+GxH/Ow62rFPXmDR1RvSuKo0OpfavI//mRoeY21gS6Yp03p59AAAAAACKk4IdAAAUSIcOLfzjdsn/ikSlJR3iJydfEJvvtH2c9ocr85wMPlc1a2pc82hD1NbWRnV1dWI5vvvNqmhcuDAiIgZtt0d858izYtPNvhQ/2q0yKsvt3Ej+NcxcmLdn/6sX75efUAAAAAAAtEl+TBsAANqYLh3K4+Lr7oo9f3BI0lFgtdr7oB/HyRf9JTp3KcxxswAAAAAAAC1lBzsAAGhDeqT7xBV3/z169l0v6Siw2nQo7RiHn3RZ7Drs8KSjAAAAAAAANKNgBwAAbcQeBxwUOw7bJzp17bLEe9NnNyaQiGLXVp6rX152X2y+1TeXmG8r+Sg+ni0AAAAAAFaWgh0AALQRux00Yom5dDodlemKuP3p6Qkkoj2oTFdEOp1ONMPi5TrPPatDW3j2AQAAAABo+xTsAACgDctkMlFTOyGy2WzSUShS6XQ6MplM0jGa8dyzOrTFZx8AAAAAgLZHwQ4AANq4TCajBEK747kHAAAAAADaglTSAQAAAAAAAAAAAKAtUrADAAAAAAAAAACApXBELAAAtHF1dXWRzWaTjkGRSqfTjmIFAAAAAABYBgU7AABoI6695o+x9957xTrrrpObq6uri/4DB0S2viHBZBSzdFVl1I6vUbIDAAAAAABYCgU7AABoI1569eW45d5b4/LzfhdbbzMoIiKy2Wxk6xti0Mnfik7duyackGIzd9qseOXihyObzSrYAQAAAAAALIWCHQAAtCGzF86KY049Jk764Unx3REH5OY7de8aXXpUJJgMAAAAAAAA2p9U0gEAAIDmFsbCuPCPF8b551+YdBQAAAAAAABo1+xgBwAABXLVVde26PrxH4xvNr57zF3x9n/fiZIoyWcsAAAAAAAAYCUp2AEAQIFcf88fW73Gf95/Pbbe7msRcxrzkAia6zinMQYd/M245O+/j86dOycdBwAAAAAAoM1RsAMAgLauQ0TJ7KakU1CEUgubonu/HvHupPErvhhYuqpU0gkAAAAAACggBTsAACiQfj36t+j6iVNrl5jrVdE7nnx4TAzaY718xYKcxtKSyNZMicHbDraDHayix6eNSzoCAAAAAAAFpGAHAAAFct+dd7fo+pFH/zD+9d4rufFWGwyKU046KTa6f6N8R4OIiJjfORWv3PFM3H3erVFdXZ10HFgjffXi/ZKOAAAAAABAATnHBAAA2qD9huwf11/7x+jYoWPSUQAAAAAAAKDdsoMdAAC0IaVRGr846sQ48MDvJh0FAAAAAAAA2j0FOwAAaCPWX2/9OPqIH8Y2g7de4r2502YlkIhi57kCAAAAAABYPgU7AABoI379qzOWmEun05GuqoxXLn44gUS0B+mqykin00nHAAAAAAAAaJMU7AAAoA3LZDJRO74mstls0lEoUul0OjKZTNIxAAAAAAAA2iQFOwAAaOMymYwCFAAAAAAAACQglXQAAAAAAAAAAAAAaIsU7AAAAAAAAAAAAGApHBELAABtXF1dXWSz2aRjUKTS6bQjiAEAAAAAAJZBwQ4AANqIV//1Wnx1i69EKvW/jabr6uqi/8ABka1vSDAZxSxdVRm142uU7AAAAAAAAJZCwQ4AANqIP1x7VcyfPz+uverq6Ny5c0REZLPZyNY3xKCTvxWdundNOCHFZu60WfHKxQ9HNptVsAMAAAAAAFgKBTsAAGhD3pj4enznwP3iT9fcGL1798rNd+reNbr0qEgwGQAAAAAAALQ/qRVfAgAArE6fTv8kDjjsgHj1X68mHQUAAAAAAADaNQU7AABog2YumBlHn/SjePyxMUlHAQAAAAAAgHbLEbEAAFAgWw0d1Kr7F8SCuPovV8fGG2+ap0TQXMc5jTHo4G/GJX//fXTu3DnpOAAAAAAAAG2Ogh0AALRhTdEU5et0jdTkBRE9kk5DsUktbIru/XrEu5PGJx0F1lxVDgcAAAAAAChmCnYAANCGdYgO8fG7k6LfbtVJR6EINZaWRLZmSgzedrAd7GAVPT5tXNIRAAAAAAAoIAU7AAAokH+NeaVF1488+ofxr/f+d095h27xy5+eFt/69reiX3wt3/Eg5ndOxSt3PBN3n3drVFdXJx0H1khfvXi/pCMAAAAAAFBACnYAANAG9U73iZuuuTFmzZ6VdBQAAAAAAABot1JJBwAAAJr7SvVX474774mevXomHQUAAAAAAADaNQU7AABoI1IlqRi2w/C46YYbo1NZp6TjAAAAAAAAQLvniFgAAGgjRp19zjJ3rZs7zVGx5J/nCgAAAAAAYPkU7AAAoI1YWrkunU5HuqoyXrn44QQS0R6kqyojnU4nHQMAAAAAAKBNUrADAIA2LJPJRO34mshms0lHoUil0+nIZDJJxwAAAAAAAGiTFOwAAKCNy2QyClAAAAAAAACQgFTSAQAAAAAAAAAAAKAtsoMdAAC0cXV1dY6IpWAcEQsAAAAAALBsCnYAANBGzJ03NzqVdWo2V1dXF/0HDohsfUNCqSh26arKqB1fo2QHAAAAAACwFAp2AADQRpxy6mnxtUFfi4O/d2BuLpvNRra+IQad/K3o1L1rgukoRnOnzYpXLn44stmsgh0AAAAAAMBSKNgBAEAbMWPmjPjNjZfEezXvxa9/dUaz9zp17xpdelQklAwAAAAAAADap1TSAQAAgOb+Nva+OOKokTF33tykowAAAAAAAEC7pmAHAABt0Gs1r8Z3RuwXdZ/VJR0FAAAAAAAA2i1HxAIAQIFsNXRQq+7/JDspfnL6T6Oysio/gQAAAAAAAIAWUbADAIA2bNaCmbHBVhtGavKCiB5Jp6HYdJzTGIMO/mZc8vffR+fOnZOOAwAAAAAA0OYo2AEAQBvXmG2MhT1Kk45BEUotbIru/XrEu5PGJx0F1lxVqaQTAAAAAABQQAp2AABQIP/3jxdbdP3Rxx4br45/pdncnt/YM0aNOje+sX91HpPB5xpLSyJbMyUGbzvYDnawih6fNi7pCAAAAAAAFJCCHQAAFEiHDi3743ZJySL3Roc45ZhTYtDWW8WoUefmORl8bn7nVLxyxzNx93m3RnV1ddJxYI301Yv3SzoCAAAAAAAF5BwTAABoY7p26BpXX3R17Lf/vklHAQAAAAAAgHbNDnYAANCG9OzWK2665sbo3ad30lEAAAAAAACg3VOwAwCANmLYnvvErrvtEp07d17ivbnTZiWQiGLnuQIAAAAAAFg+BTsAAGgj9t5nryXm0ul0pKsq45WLH04gEe1Buqoy0ul00jEAAAAAAADaJAU7AABowzKZTNSOr4lsNpt0FIpUOp2OTCaTdAwAAAAAAIA2ScEOAADauEwmowAFAAAAAAAACUglHQAAAAAAAAAAAADaIgU7AAAAAAAAAAAAWApHxAIAAAAAwGpWV1cX2Ww26RgUqXQ6HZlMJukYAAAARUHBDgAAAAAACqTm7fGxYP6C2OjLG+fm6urqYuCAAVHf0JBgMopZVWVljK+pUbIDAADIAwU7AAAAAAAokOn10+O8H58VPxn18/jm7jtEREQ2m436hoa4+PuHRI+KioQTUmymTp8eJ992a2SzWQU7AACAPFCwAwAAAACAApo3d1785qQL46MJH8Z3f3hQbr5HRUX0qqpKLhgAAACwQgp2AAAAAACwGvz5D7fFR7Ufxt5HfCfpKAAAAMBKUrADAAAAAIDlqP9sWkyZNCUmf/xpi+995/W3m42femhsvF8zMTp1KMtXPAAAAKCAFOwAAAAAAGA5HvrLg/HXa/+ct/UmvF0bOwz8RmRnzoteVXlbFiIi4u8dP4jv/GTv+PllP8nbmh3mRPz12gfyth4AAMCaRMEOAAAAAABWs7LSjjF77oKkY1CsSvK73ILO+V0PAABgTaJgBwAAAAAAy/GNXb8Zz/7jqfhowkeR7p6OL239lZW+9/33JsaHtR80m+veMxP3PHN/7LfjofmOCp9ryuNaeS7rAQAArGkU7AAAAAAAYDmqN+ofVT0y8dGEj6LvwH5x8qWnr/S9/37htTjzh/+7fuOvbBLf/8UP4qatbi9EVIi95/eNI66+Kmpra6O6urpVa+17wj75CQUAALAGSyUdAAAAAAAA2oPtv7VjnHvDhVHRPZ10FAAAAGAl2cEOAAAAAAAK7KDjvh/f/eFBUVLivE0AAABYkyjYAQAAAABAgXTqXBYnXnxKfHOPHZd4b+r06Qkkoth5rgAAAPJLwQ4AAAAAAApkky02W2IunU5HVWVlnHzbrQkkoj2oqqyMdNpRxAAAAPmgYAcAAAAAAKtRJpOJ8TU1kc1mk45CkUqn05HJZJKOAQAAUBQU7AAAAAAAYDXLZDIKUAAAALAGSCUdAAAAAAAAAAAAANoiBTsAAAAAAAAAAABYCkfEAgAAAAAAUHB1dXWRzWaTjkERS6fTjt8GACDvFOwAAAAAAADIq5fffC223nyL3Liuri76DxwQ2fqG5EJR9NJVlVE7vkbJDgCAvFKwAwAAAAAAIK9OvvSC2GRA//j96edHKpWKbDYb2fqG2PiqvaKsZ3nS8ShC8ybPjHeOfTCy2ayCHQAAeaVgBwAAAAAAQF41NUX845mXYu/jfhB//e3VufmynuXRqU9FgskAAABaJpV0AAAAAAAAAIrT27UfxZAjDo6PJk9KOgoAAMAqUbADAAAAAACgYKZOmxE/PO/MqFpn7aSjAAAAtJgjYgEAAAAAAFjCR5Pnxuw5jdGlcyoG7jG0VWvNmbswenzly9HhrdkRjoilAAa9XR7bnHNEjLptVN7W3O4r28Xh+xyet/UAAFgz2cEOAAAAAACAJcye0xgzZzfG7DmNeVmvsSlixgszIurm52U9WFSqKaKkpCSvaz77+rN5XQ8AgDWTgh0AAAAAAAAF16E0ouselRGZjklHoQg1lkQ0NTUlHQMAgCLkiFgAAAAAAACWa/wjY1p0/c6Hj4j3J03NjdeqKo83Ro+JDY/YO9/RICIiXtlkZryx/51RW1sb1dXVrVpr5KiR+QkFAEBRsIMdAAAAAAAABbPpgPXipjMvjDkzZiUdBQAAoMUU7AAAAAAAACiIb2+/bTzw+z9F1y5dk44CAACwShwRCwAAAAAAQF51KusYPz304PjxwUcmHQUAAKBVFOwAAAAAAADIq5vO+2307tFzifl5k2cmkIb2wLMFAEChKNgBAAAAAACQV4uX69LpdKSrKuOdYx9MKBHtQbqqMtLpdNIxAAAoMgp2AAAAAAAAFFQmk4na8TWRzWaTjkIRS6fTkclkko4BAECRUbADAAAAAACg4DKZjPITAACwxkklHQAAAAAAAAAAAADaIjvYAQAAAAAAUHB1dXWOiKWgHBELAEAhKNgBAAAAAACQV3PnzYtOZWW5cV1dXfQfOCCy9Q0JpqLYpasqo3Z8jZIdAAB5pWAHAAAAAABAXn3/1OPjqP0Pit2+sXNERGSz2cjWN8TGV+0VZT3LE05HMZo3eWa8c+yDkc1mFewAAMgrBTsAAAAAAADyauq0hjju3FFxwiG1cfzBR+Tmy3qWR6c+FQkmAwAAaJlU0gEAAAAAAAAoPo1NEZfdcnv85PwzorGxMek4AAAAq8QOdgAAAAAAABTM6Keej/9OnBAlpfZ9AAAA1jwKdgAAAAAAACzXwD2Gtur+dydOio132yFi+sKIPnkKBQAAsBoo2AEAAAAAALCEufMbm/1va81rTEXTvdOi0w/LIzId87ImfGHQ2+WxzTlHxKjbRiUdBQCAImMvbgAAAAAAAJbQ2Nj8f/Ohywado6mqNH8Lwv+XaoooKSlJOgYAAEXIDnYAAAAAAAAs1zsP/qNF1+961MHx/qTPcuNUKmLWxAlRftQ20SFl/wfyr7EkItXYpGQHAEDeKdgBAAAAAACwXB06tPRbSv8rOXXu1CHO/OGPYsRe+8ZasU1+g8H/98omM+ON/e+M2traqK6ubtVaI0eNzE8oAACKgoIdAAAAAAAABbFWVXn85TdXRmpBU9JRAAAAVok9uAEAAAAAAMi7javXiTE33BED1uuXdBQAAIBVZgc7AAAAAAAA8upH3z0oDth9n0ilmu/1MG/yzIQSUew8WwAAFIqCHQAAAAAAAHk14lvDm43T6XSkqyrjnWMfTCYQ7UK6qjLS6XTSMQAAKDIKdgAAAAAAABRUJpOJ2vE1kc1mk45CEUun05HJZJKOAQBAkVGwAwAAAAAAoOAymYzyEwAAsMZJJR0AAAAAAAAAAAAA2iIFOwAAAAAAAAAAAFgKR8QCAAAAAABQcHV1dZHNZpOOQRFLp9OOIQYAIO8U7AAAAAAAAMir86+7PI478PCorEhHxOfluv4DB0S2viHhZBSzdFVl1I6vUbIDACCvFOwAAAAAAADIq8eeey7ue/zxuOOSy2PD9QdENpuNbH1DbHzVXlHWszzpeBSheZNnxjvHPhjZbFbBDgCAvFKwAwAAAAAAIO/qGmbF8ON/FFf88owY2Gv9iIgo61kenfpUJJwMAABg5aWSDgAAAAAAAEBxmjNvYfzo7HPizkcfSDoKAADAKrGDHQAAAAAAAMt12S3Xtuj6T6bW5V43NjbFH++9PwZ+Y4toamzMdzQAAICCUrADAAAAAABgCV904RobI35/x19bvV5TRSZSD2Wj6bCKKClzyBL5Nejt8tjmnCNi1G2jko4CAECR8bcXAAAAAAAAVouFMxoj5ixMOgZFKNUUUVJSknQMAACKkB3sAAAAAAAAWK4B6/Vs0fU1H05eYq5j45wo2W/dKEl3zFcsyGksiUg1NinZAQCQdwp2AAAAAAAALNdj1/+5RdfvfPiIeH/S1Nx41223imvP/k18+egR+Y4GERHxyiYz443974za2tqorq5u1VojR43MTygAAIqCI2IBAAAAAAAoiFQq4qTDD41Tf3Bc0lEAAABWiR3sAAAAAAAAyLtOZaVxxelnxC7b7hATJkxIOg4AAMAqUbADAAAAAAAgrzYd2D/+ePYFseH6A5KOAgAA0CoKdgAAAAAAAOTVVWdcuNT5eZNnruYktBeeLQAACkXBDgAAAAAAgIJKp9ORrqqMd459MOkoFLF0VWWk0+mkYwAAUGQU7AAAAAAAACioTCYTteNrIpvNJh2FIpZOpyOTySQdAwCAIqNgBwAAAAAAQMFlMhnlJwAAYI2TSjoAAAAAAAAAAAAAtEV2sAMAAAAAAKDg6urqHBFLQTkiFgCAQlCwAwAAAAAAIK9efvO12HrzLXLjurq66D9wQGTrG5ILRdFLV1VG7fgaJTsAAPJKwQ4AAAAAAIC8OvnSC2KTAf3j96efH6lUKrLZbGTrG2Ljq/aKsp7lScejCM2bPDPeOfbByGazCnYAAOSVgh0AAAAAAAB51dQU8Y9nXoq9j/tB/PW3V+fmy3qWR6c+FQkmAwAAaJlU0gEAAAAAAAAoTm/XfhRDjjg4Ppo8KekoAAAAq0TBDgAAAAAAgIKZOm1G/PC8M6NqnbWTjgIAANBijogFAAAAAABguQbuMbRV98+ZuzB6fOXL0eGt2RGOiKUAthlXHtucc0SMum1U0lEAACgydrADAAAAAACg4BqbIma8MCOibn7SUShSJSUlSUcAAKAIKdgBAAAAAABQcB1KI7ruURmR6Zh0FIpUU1NT0hEAAChCjogFAAAAAABgucY/MqZF1+98+Ih4f9LU3HitqvJ4Y/SY2PCIvfMdDSIi4qVNZ8Yb+98ZtbW1UV1d3aq1Ro4amZ9QAAAUBTvYAQAAAAAAUDCbDlgvbjrzwpgzY1bSUQAAAFpMwQ4AAAAAAICC+Pb228YDv/9TdO3SNekoAAAAq8QRsQAAAAAAAORVp7KO8dNDD44fH3xk0lEAAABaRcEOAAAAAACAvLrpvN9G7x49l5ifN3lmAmloDzxbAAAUioIdAAAAAAAAebV4uS6dTke6qjLeOfbBhBLRHqSrKiOdTicdAwCAIqNgBwAAAAAAQEFlMpmoHV8T2Ww26SgUsXQ6HZlMJukYAAAUGQU7AAAAAAAACi6TySg/AQAAa5xU0gEAAAAAAAAAAACgLbKDHQAAAAAAAAVXV1fniFgKyhGxAAAUgoIdAAAAAAAAeTV33rzoVFaWG9fV1UX/gQMiW9+QYCqKXbqqMmrH1yjZAQCQVwp2AAAAAAAA5NX3Tz0+jtr/oNjtGztHREQ2m41sfUNsfNVeUdazPOF0FKN5k2fGO8c+GNlsVsEOAIC8UrADAAAAAAAgr6ZOa4jjzh0VJxxSG8cffERuvqxneXTqU5FgMgAAgJZJJR0AAAAAAACA4tPYFHHZLbfHT84/IxobG5OOAwAAsErsYAcAAAAAAEDBjH7q+fjvxAlRUmrfBwAAYM2jYAcAAAAAAMByDdxjaKvuf3fipNh4tx0ipi+M6JOnUAAAAKuBgh0AAAAAAAAFN68xFU33TotOPyyPyHRMOg5FZptx5bHNOUfEqNtGJR0FAIAiYy9uAAAAAAAAVosuG3SOpqrSpGNQpEpKSpKOAABAEbKDHQAAAAAAAMv1zoP/aNH1ux51cLw/6bPcOJWKmDVxQpQftU10SNn/gcJoampSsgMAIO8U7AAAAAAAAFiuDh1a+i2l/5WcOnfqEGf+8EcxYq99Y63YJr/B4P97adOZ8cb+d0ZtbW1UV1e3aq2Ro0bmJxQAAEVBwQ4AAAAAAICCWKuqPP7ymysjtaAp6SgAAACrxB7cAAAAAAAA5N3G1evEmBvuiAHr9Us6CgAAwCqzgx0AAAAAAAB59aPvHhQH7L5PpFLN93qYN3lmQokodp4tAAAKRcEOAAAAAACAvBrxreHNxul0OtJVlfHOsQ8mE4h2IV1VGel0OukYAAAUGQU7AAAAAAAACiqTyUTt+JrIZrNJR6GIpdPpyGQySccAAKDIKNgBAAAAAABQcJlMRvkJAABY46SSDgAAAAAAAAAAAABtkYIdAAAAAAAAAAAALIUjYgEAAAAAACi4urq6yGazScegiKXTaccQAwCQdwp2AAAAAAAA5NX5110exx14eFRWpCPi83Jd/4EDIlvfkHAyilm6qjJqx9co2QEAkFcKdgAAAAAAAOTVY889F/c9/njcccnlseH6AyKbzUa2viE2vmqvKOtZnnQ8itC8yTPjnWMfjGw2q2AHAEBeKdgBAAAAAACQd3UNs2L48T+KK355RgzstX5ERJT1LI9OfSoSTgYAALDyUkkHAAAAAAAAoDjNmbcwfnT2OXHnow8kHQUAAGCV2MEOAAAAAACA5brslmtbdP0nU+tyrxsbm+KP994fA7+xRTQ1NuY7GgAAQEEp2AEAAAAAALBcv7/jr61eo6kiE6mHstF0WEWUlDlkifzaZlx5bHPOETHqtlFJRwEAoMj42wsAAAAAAACrxcIZjRFzFiYdgyJVUlKSdAQAAIqQHewAAAAAAABYrgHr9WzR9TUfTl5irmPjnCjZb90oSXfMVyxopqmpSckOAIC8U7ADAAAAAABguR67/s8tun7nw0fE+5Om5sa7brtVXHv2b+LLR4/IdzSIiIiXNp0Zb+x/Z9TW1kZ1dXWr1ho5amR+QgEAUBQcEQsAAAAAAEBBpFIRJx1+aJz6g+OSjgIAALBK7GAHAAAAAABA3nUqK40rTj8jdtl2h5gwYULScQAAAFaJgh0AAAAAAAB5tenA/vHHsy+IDdcfkHQUAACAVlGwAwAAAAAAIK+uOuPCpc7PmzxzNSehvfBsAQBQKAp2AAAAAAAAFFQ6nY50VWW8c+yDSUehiKWrKiOdTicdAwCAIqNgBwAAAAAAQEFlMpmoHV8T2Ww26SgUsXQ6HZlMJukYAAAUGQU7AAAAAAAACi6TySg/AQAAa5xU0gEAAAAAAAAAAACgLbKDHQAAAAAAAAVXV1fniFgKyhGxAAAUgoIdAAAAAAAAefX6/70RX/nal3Pjurq6GNB/QDRkGxJMRbGrTFdGTW2Nkh0AAHmlYAcAAAAAAEBenXPib2PDTavjvKt/FalUKrLZbDRkG2L/nY6Kii6VScejCE2f3RB3j70ustmsgh0AAHmlYAcAAAAAAEDePfHoK3HYt46Na+75bW6uoktlpMu7J5gKAACgZVJJBwAAAAAAAKA4vfvux3HAjkfGJx9+knQUAACAVaJgBwAAAAAAQMF8VjczThl5UfRK9046CgAAQIs5IhYAAAAAAIAlNUVEyef/O7j/Pq1aas7chdF/rW1ixvRpjoilIKpm1sdhmwyJh8++Ljp37tyqtdaeOCf3+k/HnNvaaLDG6NS1c+xwxHdivc03SDoKALQpCnYAAAAAAAAUXGNTxIcfT44e3ftEWacuScehyJQtmB/V6V7x6Vu1rV6r0yKvJ342rtXrwZrm4EtPSjoCALQpCnYAAAAAAAAUXIfSpui3fl/lOgpiXoeO8UndBzF4221bvYPduxPfyb3eqN/GrY0Ga4RP3p0Yc2fMirmz5qz4YgBoZxTsAAAAAAAAWK4Xax9o0fX773B4fPDBZ7lxJtM1nnrzwdh4o2PyHQ0iIqK+vCpufvuJOOvhG6K6urpVa40cNTL3+oIzftXKZLBm+NMx58bEf9mxEQCWJpV0AAAAAAAAAIrXxpusG7+95ayYNXdm0lEAAABaTMEOAAAAAACAgtjlW9vETaP/EF3KW3dkJwAAQFIcEQsAAAAAAEBelXXqGEefcEAc8dNDko4CAADQKgp2AAAAAAAA5NXlt54fa/fuscT89NkNCaShPfBsAQBQKAp2AAAAAAAA5NXi5bp0Oh2V6cq4e+x1CSWiPahMV0Y6nU46BgAARUbBDgAAAAAAgILKZDJRU1sT2Ww26SgUsXQ6HZlMJukYAAAUGQU7AAAAAAAACi6TySg/AQAAa5xU0gEAAAAAAAAAAACgLbKDHQAAAAAAAAVXV1fniFgKyhGxAAAUgoIdAAAAAAAAeTV37rzo1KksN66rq4sB/QdEQ7YhwVQUu8p0ZdTU1ijZAQCQVwp2AAAAAAAA5NWPDzw5vnf0frHjHttHREQ2m42GbEPsv9NRUdGlMuF0FKPpsxvi7rHXRTabVbADACCvFOwAAAAAAADIq7rPGuLUYy+Jo386IX7wk0Ny8xVdKiNd3j3BZAAAAC2TSjoAAAAAAAAAxaexKeLqy+6KM44bFY2NjUnHAQAAWCV2sAMAAAAAAKBgHnvo/6Lmv+9HaUlp0lEAAABaTMEOAAAAAACA5Rrcf59W3T/+v5/EthvsHgvmz8tTIgAAgNVDwQ4AAAAAAICCmz+/NGonToxuXdJR1qlL0nEoMlUz6+OwTYbEw2dfF507d27VWmtPnJN7/adjzm1tNFgjfPLuxIiImDtzdsJJAKDtUbADAAAAAABgtVire0V06Ngp6RgUobIF86M63Ss+fau21Wst+oRO/Gxcq9eDNUnDpKlJRwCANkfBDgAAAAAAgOV69r/3tuj6ETuPjA8/rMuNU6mSmDrzndh8rb0jlUrlOx7EvA4d45O6D2Lwttu2ege7dye+k3u9Ub+NWxsN1gjvv/ZONDU2RmNjY9JRAKDNUbADAAAAAABguTp0aNm3lEpKSnKvO3cqjZ+fdXgMP2hYbB975zsaREREfXlV3Pz2E3HWwzdEdXV1q9YaOWpk7vUFZ/yqlclgzXDB0JExd8aspGMAQJukYAcAAAAAAEBBrJUpj6vvuiiaUnZEAgAA1kz24AYAAAAAACDvNtiwT/x17HXRb8D6SUcBAABYZXawAwAAAAAAIK8O+dH+sfeB34pUqvleD9NnNySUiGLn2QIAoFAU7AAAAAAAAMirYQfv2WycTqejMl0Zd4+9LqFEtAeV6cpIp9NJxwAAoMgo2AEAAAAAAFBQmUwmamprIpvNJh2FIpZOpyOTySQdAwCAIqNgBwAAAAAAQMFlMhnlJwAAYI2TSjoAAAAAAAAAAAAAtEUKdgAAAAAAAAAAALAUjogFAAAAAACg4Orq6iKbzSYdgyKWTqcdQwwAQN4p2AEAAAAAAJBXF13z6zjmez+PdEVVRHxerus/sDqy9dOTDUZRS1dVRO34CUp2AADklYIdAAAAAAAAeTXm2TFx/6MPxK2/vTMGVm8c2Ww2svXTY+tLukSnHiVJx6MIzZ3aFC+fND2y2ayCHQAAeaVgBwAAAAAAQN7VNcyI/Y4ZFpf9+vLo32fjiIjo1KMkuvRKJZyM4tSYdAAAAIqUv8EAAAAAAABQEHPmLYjjfn183P3ILUlHAQAAWCV2sAMAAAAAAGC5rvjThS26/pMpU3OvGxub4vq7bomNBq8TTY31eU4GAABQWAp2AAAAAAAALNdVt13f6jVKyrvE/DGdomnElCjpmIdQsIi+b/eI/Yd0jLuv+2V07ty5VWt1mfhO7vXvzz2ytdFgjTB3zuyIiGhsXJhwEgBoexTsAAAAAAAAWC0WzExFzC6N6KjAQX51nd4p0r26xke1b7Z6rUW/gTp+3CutXg/WBOmFG0dJlMaCeXOTjgIAbY6CHQAAAAAAAMs1oO86Lbq+5oOPl5jr2LQguuw5JUrSqXzFgpxZFXMj+3ZjDN52cKt3sHtnkR3sNu63cWujwRphSu3MiKaIpqSDAEAbpGAHAAAAAADAcj1001Mtun63Q7aL9z/+NDfe5evfjD+cd3Nsd2jXfEeDiIj4YJOp8exFs+KSGx6P6urqVq01ctTI3Ovjz2j98ciwJjjrkYMjGpNOAQBtkx8RAgAAAAAAoCBSqYhfjDw+Thx5VtJRAAAAVokd7AAAAAAAAMi7TmUd4rJfXRZDvvGtmDBhQtJxAAAAVomCHQAAAAAAAHm1ycCN4+pzT4mB1RsnHQUAAKBVFOwAAAAAAADIqyvOunGp83OnNkVE4+oNQ7vw+bMFAAD5p2AHAAAAAABAQaXT6UhXVcTLJ01POgpFLF1VEel0OukYAAAUGQU7AAAAAAAACiqTyUTt+AmRzWaTjkIRS6fTkclkko4BAECRUbADAAAAAACg4DKZjPITAACwxkklHQAAAAAAAAAAAADaIjvYAQAAAAAAUHB1dXWOiKWgHBELAEAhKNgBAAAAAACQV2//a1xsstWmuXFdXV0MHDAw6hvqkwtF0auqrIrxNeOV7AAAyCsFOwAAAAAAAPLqytOujuqN+8YvfveLSKVSkc1mo76hPi46YFT06LZW0vEoQlNnfBan3HVGZLNZBTsAAPJKwQ4AAAAAAIC8aoqmeHbMv2PSvifHebefk5vv0W2t6FXZM8FkAAAALZNKOgAAAAAAAADFqea/n8Sxe/w0pn48JekoAAAAq0TBDgAAAAAAgIKZVjcrLjn+97F+975JRwEAAGgxR8QCAAAAAACwXMM3/36r7p87d2EMWmeH+GDqR46IpSAWfPZh/GyLvePFC2+Pf3fu3Kq1Np5Ymnt9/08vbW00WCNkOnSNxtKmmNk4N+koANDmKNgBAAAAAABQcI1NEa/XToiN19kgKrpUJB2HItM0b3ZsVLVOTHvng1avVREludeT6v/b6vVgTVCW+v/VgZLlXwcA7ZGCHQAAAAAAAAVXWtoUX99kc+U6CqKkrEu888l/Y/DgwdG5lTvYvTvx3dzrjfpt1NposEb46LV3I1VSEikNOwBYgoIdAAAAAAAAy/W3N29r0fXH7v7j+PjDablxVfcucd8rf409t94+39EgIiI6rLVeXPbAeVF73xVRXV3dqrVGjhqZe33SGb9oZTJYM1yx48goK1EfAIClSSUdAAAAAAAAgOI1cKM+cdp1v4jsnGzSUQAAAFpMwQ4AAAAAAICC2H7XLeOSey6KTl1ad2QnAABAUuzxCgAAAAAAQF6VdeoY3z9un9j/2O8mHQUAAKBVFOwAAAAAAADIq19f98vI9FprifmpMz5LIA3tgWcLAIBCUbADAAAAAAAgrxYv16XT6aiqrIpT7jojoUS0B1WVVZFOp5OOAQBAkVGwAwAAAAAAoKAymUyMrxkf2Ww26SgUsXQ6HZlMJukYAAAUGQW71WzOnDnx3HPPxdtvvx3Tpk2LsrKyWG+99WLw4MExYMCApOMBAAAAAAAURCaTUX4CAADWOAp2y3HQQQfFX/7yl2Zz/fr1iwkTJrR4rSlTpsTZZ58dN910U8ycOXOp1wwaNCh+9atfxbBhw1YlLgAAAAAAAAAAAHmkYLcMf//735co162qsWPHxgEHHBBTp05d7nWvvPJKDB8+PA499NC47rrroqysLC+fDwAAAAAAkLS6ujpHxFJQjogFAKAQFOyWoqGhIY455pi8rPXMM8/Et7/97Zg9e3az+aqqqujfv39MmzYtPvjgg1i4cGHuvVtuuSVmzJgRd999d5SUlOQlBwAAAAAAwOoyb+68KOv0v40E6urqYuCAgVHfUJ9cKIpeVWVVjK8Zr2QHAEBeKdgtxUknnRQfffRRRESUl5cv80jXFZk2bVqMGDGiWbmuX79+cfnll8c+++yTK899+OGHMWrUqLj22mtz1917771x2WWXxc9//vNWfCUAAAAAAACr31mHnx3DD987vrbrthERkc1mo76hPi46YFT06LZWwukoRlNnfBan3HVGZLNZBTsAAPJKwW4xY8eOjeuvvz4iIlKpVJx55plx8sknr9Jal1xySXz88ce5cf/+/eOZZ56JddZZp9l16623XlxzzTWx/vrrxy9/+cvc/DnnnBOHH354dO/efZU+HwAAAAAAIAn1n2Xjwp/9Pg4+7oPY/5gDcvM9uq0VvSp7JpgMAACgZVJJB2hLZs+eHSNHjoympqaIiPjxj38c22yzzSqtNWXKlLjyyiubzV133XVLlOsWddppp8UOO+yQGzc0NMRvfvObVfp8AAAAAACAJDU2Rdz2+/vjtz//bTQ2NiYdBwAAYJUo2C3iV7/6VYwfPz4iItZff/0YNWrUKq/1l7/8JWbMmJEb77DDDjF06NDl3lNSUhJnnnlms7kbb7wxV/gDAAAAAABY0zz1j3/FFT+9MkpLHKwEAACsefxN5v976aWX4ne/+11u/Ic//CG6deu2yuvdf//9zcZHHnnkSt238847R//+/aO2tjYiIj755JN44YUX4utf//oqZwEAAAAAAGiN4Zt/v1X3Txg/JYZ9eb+YPXd2nhIBAACsHgp2ETF//vw48sgjY+HChRERccABB8Ree+21yuvNmDEjnnrqqWZzu+2220rdW1JSErvssktcd911ubkHH3xQwQ4AAAAAAFijLVzQIZ5689VYqyITFV0qko5DkVnw2Yfxsy32jhcvvD3+3blzq9baeGJp7vX9P720tdFgjdCh5PPnviRKEk4CAG2Pgl1EXHDBBfHGG29ERERVVVVcccUVrVrvzTffjPnz5+fG/fv3j969e6/0/dttt12zgt1rr73WqjwAAAAAAABtQd+ePaK8U3nSMShCTfNmx0ZV68S0dz5o9VoVixSMJtX/t9XrwZogVfL5c19aomAHAItr9wW7t956K84777zc+KKLLmpRGW5pxo0b12y82Wabtej+xa9ffD0AAAAAAIDV6e5/39Si63/y7Z/Fxx9Ny41TqYja+jdin8HHRCqVynM6iCgp6xLvfPLfGDx4cHRu5Q527058N/d6o34btTYarBE+fu3dKCkpibCDHQAsoV0X7BobG+PII4+MefPmRUTE9ttvH0cddVSr133nnXeajfv27dui+xe/fuLEiTFnzpxW/2UAAAAAAABgVXTo0MJvKS3Sz+jUqTSOOP3A2OOAb+c3FCyiw1rrxWUPnBe1910R1dXVrVpr5KiRudcnnfGLViaDNcNVOx2tWgcAy9CuC3ZXXHFFvPDCCxERUVZWFn/84x//fyu/dSZPntxsvN5667Xo/l69ekWHDh1iwYIFEfF5EfCzzz6Lddddt9XZAAAAAAAAVpfu3bvGqFvPjPkl85OOAgAAsErabcGutrY2zjjjjNz4tNNOi0022SQva8+YMaPZuLy8vEX3l5SURJcuXWL69OnLXHNVTZ48OaZMmdKie9577728fDYAAAAAANB+9N+gV4y67dwor+gaEyZMSDoOAADAKmm3Bbsf/vCHMXPmzIiI2GSTTeL000/P29qLl+FW5WjXQhXsrrrqqjj77LPzshYAAAAAAMDS7Dty7xiy3y6RSqWazU+d8VlCiSh2ni0AAAqlXRbsbrjhhnj88ccj4vPd4v74xz9GWVlZ3tafM2dOs/GqrN2pU6dm49mzZ7cqEwAAAAAAwOqyywG7NRun0+moqqyKU+46Yxl3QOtVVVZFOp1OOgYAAEWm3RXsJk2aFCeeeGJuPHLkyNh+++3z+hmL71g3b968Fq8xd+7c5a4JAAAAAACwpshkMjG+Znxks9mko1DE0ul0ZDKZpGMAAFBk2l3B7rjjjov6+vqIiOjdu3dcfPHFef+Mbt26NRsvvqPdylh8x7rF11xVxx57bBxwwAEtuue9996L4cOH5+XzAQAAAACA9imTySg/AQAAa5x2VbC766674r777suNL7/88qiqqsr75yxehps5c2aL7m9qaipYwa5nz57Rs2fPvKwFAAAAAAAAAABQzFJJB1idTjrppNzrPffcM7773e8W5HMWL7B9+OGHLbr/008/jQULFuTGqVQqevTokZdsAAAAAAAAAAAArJx2tYPdF0fDRkSMHj06SkpKWrzGxIkTl7jv1VdfjS222CI33njjjZu9//7777foMxa/vl+/ftG5c+eWBQUAAAAAAGhD6urqIpvNJh2DIpZOpx1DDABA3rWrgt3qsskmmzQbv/XWWy26f9y4cctdDwAAAAAAoC275aKbYt8f7R/dKrtFxOfluoEDBkZ9Q32ywShqVZVVMb5mvJIdAAB5pWBXAJtvvnl07Ngx5s+fHxEREyZMiEmTJkWfPn1W6v5nn3222XjR3fEAAAAAAADauheeeCWeeODZOPfmX0XfDdaPbDYb9Q31cdEBo6JHt7WSjkcRmjrjszjlrjMim80q2AEAkFftqmB3//3350pvK+vf//53nHjiiblxr1694rbbbmt2zQYbbNBsXFFRETvssEOMGTMmN/fYY4/FoYceusLPa2pqiscff7zZ3N57792izAAAAAAAAEmrr58dJ373V3HSpcdHj/5rR0REj25rRa/KngknAwAAWHntqmC34447tvieDh2a/yPq3Llz7LLLLiu8b5999mlWsLvhhhtWqmD35JNPRm1tbW7cq1evGDx4cAsSAwAAAAAAtA1z5y6M839yeexz6NCkowAAAKySdlWwW50OPPDAOP3002PmzJkREfHUU0/FE088EUOGDFnmPU1NTXH22Wc3mzv88MMjlUoVNCsAAAAAAMDy/OWKP7fo+imfNuReNzZG/O2mMTFko52jsbEx39EAAAAKSsGuQHr27BnHH398XHTRRbm5kSNHxjPPPBPrrLPOUu+54IIL4qmnnsqNKysr46STTip4VgAAAAAAgOX5y7WjW71GRYd14qX3Xo9vbdUjOpb6FhX5teCzD+NnW+wdL154e/y7c+dWrbXxxNLc6/t/emlro8EaoSTpAADQhvnbSwGdfPLJcfPNN8cnn3wSERG1tbXxjW98I6644orYe++9o6Tk8z+mfPjhhzFq1Ki49tprm93/y1/+MjKZzGrPDQAAAAAAUAiz5s6LefPnKtiRd03zZsdGVevEtHc+aPVaFYtUjSbV/7fV68Ga4IvvXSvaAcCS/O2lgDKZTNx5552x++67x5w5cyIiYuLEiTFs2LCoqqqK/v37R319fbz//vuxcOHCZvcOGzYsTjzxxCRiAwAAAAAANNO3X48WXf/BxKlLzDWmZsQOm+0S5Z3L8xULckrKusQ7n/w3Bg8eHJ1buYPduxPfzb3eqN9GrY0Ga4SPX3s3V7IDAJpTsCuwHXbYIUaPHh0HHHBA1NXV5ebr6+vj1VdfXeo9Bx98cNx4443+AAMAAAAAALQJVz70uxZdf+zuP46PP5yWGw/eafM4/arTY/g2e+Q5GXyuw1rrxWUPnBe1910R1dXVrVpr5KiRudcnnfGLViaDNcPVOx2ddAQAaLNSSQdoD4YMGRJvvfVWHHPMMdG1a9dlXrflllvGPffcE7fffnt06tRpNSYEAAAAAADIv1Qq4rAT9o2DTjoo6SgAAACrxA52K7DTTjtFU1NTq9fp1atXXHXVVXHppZfGc889F+PGjYv6+vooKyuLddddNwYPHhwbbLBBHhIDAAAAAAAkr1NZaZz0m+Ni66FfiwkTJiQdBwAAYJUo2K1mXbp0iaFDh8bQoUOTjgIAAAAAAFAQ/TdeP077w4jou8H6SUcBAABoFQU7AAAAAAAA8uqkK05a6vzUGZ+t5iS0F54tAAAKRcEOAAAAAACAgkqn01FVWRWn3HVG0lEoYlWVVZFOp5OOAQBAkVGwAwAAAAAAoKAymUyMrxkf2Ww26SgUsXQ6HZlMJukYAAAUGQU7AAAAAAAACi6TySg/AQAAa5xU0gEAAAAAAAAAAACgLbKDHQAAAAAAAAVXV1fniFgKyhGxAAAUgoIdAAAAAAAAefX2v8bFJlttmhvX1dXFwAEDo76hPrlQFL2qyqoYXzNeyQ4AgLxSsAMAAAAAACCvrjzt6qjeuG/84ne/iFQqFdlsNuob6uOiA0ZFj25rJR2PIjR1xmdxyl1nRDabVbADACCvFOwAAAAAAADIq6ZoimfH/Dsm7XtynHf7Obn5Ht3Wil6VPRNMBgAA0DKppAMAAAAAAABQnGr++0kcu8dPY+rHU5KOAgAAsEoU7AAAAAAAACiYaXWz4pLjfx/rd++bdBQAgP/H3r/G2VnW9+L/dyZhskjInTUrQw6QhIGJRMs+0F1p+OGLg1ARFJOo4IGfm0IYykGwYoCIhqTSWE5JUQj2T5rUQ2sFpApsbasoCpSiodkVwSbBDJNIwvCDyZrJHUjIcf4P3J3tEIxJ1r1yJ3fe7yeu61rr/q6Puh7Iaz5eF8Aec0UsAAAAAAAAuzTtuI/V9PzmzdvjD444JV7oXuuKWOpi27o1cfXx74uf3vz1eLpUqmnWpNWD+l8/+Mn5tUYDAOAAp2AHAAAAAABA3e3oi/h556qYdMTEGH7o8LzjUDB9WzbFseUjomfFCzXPGh4N/a+7en9Z8zw4EDQ0NPzuDwHAQUrBDgAAAAAAgLobNKgv/p+3HqdcR100NB0aK176ZUyePDlKNZ5g99zq5/pfH3vUsbVGgwPCiz97TskOAH4LBTsAAAAAAAB26YFf/N0eff6Kd18VL67p6V+Xmw+Nby+9L9779pOzjgYRETF45Li4/aHPR+e374jW1taaZrXPbe9/fe2sGTUmgwPDX512ad4RAGC/1Zh3AAAAAAAAAIqr7dixcf1fz4j09TTvKAAAAHtMwQ4AAAAAAIC6OPldvx+3/cMtMeTQ2q7sBAAAyIsrYgEAAAAAAMhU05BD4mMfnxLnXvGhvKMAAADURMEOAAAAAACATM3+689GZfTInfa7X12XQxoOBn5bAADUi4IdAAAAAAAAmXpjuS5JkiiPKMfMb87KKREHg/KIciRJkncMAAAKRsEOAAAAAACAuqpUKtHxfEekaZp3FAosSZKoVCp5xwAAoGAU7AAAAAAAAKi7SqWi/AQAABxwGvMOAAAAAAAAAAAAAPsjJ9gBAAAAAABQd9Vq1RWx1JUrYgEAqAcFOwAAAAAAADK1ZfOWaBrS1L+uVqvRdkxb9K7vzS8UhVceUY6O5zuU7AAAyJSCHQAAAAAAAJn6s4s+F9Muel/84btOjIiINE2jd31v3HLe3Gg5bGTO6Sii7lfXxcxvzoo0TRXsAADIlIIdAAAAAAAAmepdl8bNVy+I8z/+Qpx7+Xn9+y2HjYzRI0blmAwAAGDPNOYdAAAAAAAAgOLZ0RfxdwsejL/81F/Gjh078o4DAACwV5xgBwAAAAAAQN089r3/Hb9a+UIMavBnKQAA4MDjn2QAAAAAAADYpWnHfaym51d1vBJT/+sHY9PmTRklAgAA2DcU7AAAAAAAAKi77dsGx2O/+PcYObwSww8dnnccCmbbujVx9fHvi5/e/PV4ulSqadak1YP6Xz/4yfm1RgMA4ACnYAcAAAAAAMA+MX5USwwbMizvGBRQ35ZNcWz5iOhZ8ULNs4ZHQ//rrt5f1jwPDgQNDQ2/+0MAcJBSsAMAAAAAAGCX7n/6K3v0+U+85+p4cW1P/7qxMaKz95mYMvnyaGxszDgdRDQ0HRorXvplTJ48OUo1nmD33Orn+l8fe9SxtUaDA8KLP3tOyQ4AfgsFOwAAAAAAAHZp8OA9/JPSb3Q0hgwZFNM/85E467z3ZBsKfsPgkePi9oc+H53fviNaW1trmtU+t73/9bWzZtSYDA4Mf3XapXlHAID9loIdAAAAAAAAddHcPDTm/u2c2NqwNe8oAAAAe8UZ3AAAAAAAAGTu6ImjY8E/fSGOPPrIvKMAAADsNSfYAQAAAAAAkKkPtL8vTv/gH0Vj48CzHrpfXZdTIorObwsAgHpRsAMAAAAAACBTf3TemQPWSZJEeUQ5Zn5zVk6JOBiUR5QjSZK8YwAAUDAKdgAAAAAAANRVpVKJjuc7Ik3TvKNQYEmSRKVSyTsGAAAFo2AHAAAAAABA3VUqFeUnAADggNOYdwAAAAAAAAAAAADYHynYAQAAAAAAAAAAwJtwRSwAAAAAAAB1V61WI03TvGNQYEmSuIYYAIDMKdgBAAAAAACQqa/d8pX4wGXnxmEjDouIX5fr2o5pi971vfkGo9DKI8rR8XyHkh0AAJlSsAMAAAAAACBTP3lkaTzy0BPx51+9IcZPnBBpmkbv+t645by50XLYyLzjUUDdr66Lmd+cFWmaKtgBAJApBTsAAAAAAAAy19u7Ka750A1x7fwro+XowyMiouWwkTF6xKickwEAAOy+xrwDAAAAAAAAUEybN2+Pv/jEF+PH3/xR3lEAAAD2ihPsAAAAAAAA2KV77vjGHn3+lf9vff/rHTsiHvjKD+P0Y98ZO3bsyDoaAABAXSnYAQAAAAAAsEv33P3dmmcMH3xEPLXy53H2/2iJQwb5ExXZ2rZuTVx9/Pvipzd/PZ4ulWqaNWn1oP7XD35yfq3RAAA4wPmnFwAAAAAAAPaJjZu3xJatmxXsyFzflk1xbPmI6FnxQs2zhkdD/+uu3l/WPA8OBA0NDb/7QwBwkPJPLwAAAAAAAOzS+KNa9ujzL6zu3mlvR+Orccrv/VEMKw3LKhb0a2g6NFa89MuYPHlylGo8we651c/1vz72qGNrjQYHhBd/9pySHQD8Fgp2AAAAAAAA7NKd//iFPfr8Fe++Kl5c09O/nnzacfGZL30mpp1wVsbJ4NcGjxwXtz/0+ej89h3R2tpa06z2ue39r6+dNaPGZHBg+KvTLs07AgDstxrzDgAAAAAAAEAxNTZG/PGffiA+eu1H844CAACwVxTsAAAAAAAAyNyQpkHxmS98It7/Jx/IOwoAAMBec0UsAAAAAAAAmTp60oS4/q4Px/iJE/KOAgAAUBMFOwAAAAAAADJ17R3Xvul+96vr9nESDhZ+WwAA1IuCHQAAAAAAAHWVJEmUR5Rj5jdn5R2FAiuPKEeSJHnHAACgYBTsAAAAAAAAqKtKpRIdz3dEmqZ5R6HAkiSJSqWSdwwAAApGwQ4AAAAAAIC6q1Qqyk8AAMABpzHvAAAAAAAAAAAAALA/coIdAAAAAAAAdVetVl0RS125IhYAgHpQsAMAAAAAACBTy//3snjr/3hb/7parUbbMW3Ru743v1AUXnlEOTqe71CyAwAgUwp2AAAAAAAAZOrO6/8qWieNjxlfmBGNjY2Rpmn0ru+NW86bGy2Hjcw7HgXU/eq6mPnNWZGmqYIdAACZUrADAAAAAAAgU33RF0/88Ono+sB18fmv39i/33LYyBg9YlSOyQAAAPZMY94BAAAAAAAAKKbnf/lSXHHWJ6P7xVfyjgIAALBXFOwAAAAAAACom57qxrjtygUxoXl83lEAAAD2mCtiAQAAAAAA2KVpx32spuc3b94ef3DEKfFC91pXxFIX29atiauPf1/89Oavx9OlUk2zJq0e1P/6wU/OrzUaAAAHOAU7AAAAAAAA6m5HX8TPO1fFpCMmxvBDh+cdh4Lp27Ipji0fET0rXqh51vBo6H/d1fvLmufBgaChoeF3fwgADlIKdgAAAAAAANTdoEF98f+89TjlOuqioenQWPHSL2Py5MlRqvEEu+dWP9f/+tijjq01GhwQXvzZc0p2APBbKNgBAAAAAACwSw/84u/26PNXvPuqeHFNT/+63HxofHvpffHet5+cdTSIiIjBI8fF7Q99Pjq/fUe0trbWNKt9bnv/62tnzagxGRwY/uq0S/OOAAD7rca8AwAAAAAAAFBcbceOjev/ekakr6d5RwEAANhjCnYAAAAAAADUxcnv+v247R9uiSGH1nZlJwAAQF5cEQsAAAAAAECmmoYcEh/7+JQ494oP5R0FAACgJgp2AAAAAAAAZGr2X382KqNH7rTf/eq6HNJwMPDbAgCgXhTsAAAAAAAAyNQby3VJkkR5RDlmfnNWTok4GJRHlCNJkrxjAABQMAp2AAAAAAAA1FWlUomO5zsiTdO8o1BgSZJEpVLJOwYAAAWjYAcAAAAAAEDdVSoV5ScAAOCA05h3AAAAAAAAAAAAANgfOcEOAAAAAACAuqtWq66Ipa5cEQsAQD0o2AEAAAAAAJCpzVu2xJCmpv51tVqNo9uOibR3fY6pKLqkPCI6O55XsgMAIFMKdgAAAAAAAGTqY5++Mi4596Nx5knvjIiINE0j7V0fk750TjSNGpZzOopoy8uvxYorvhNpmirYAQCQKQU7AAAAAAAAMtXdsz4+/udz40//Z2dcef70/v2mUcNiyNjhOSYDAADYM415BwAAAAAAAKB4dvRF3P61r8cn/mJW7NixI+84AAAAe8UJdgAAAAAAANTNdx97Mn65elU0DHLuAwAAcOBRsAMAAAAAAGCX2s46o6bnn1vdFZPOPCViw/aIsRmFAgAA2AcU7AAAAAAAAKi7LTsao+9bPTHkT4ZFVA7JOw4Fc8KyYXHCjdNj7t/NzTsKAAAF4yxuAAAAAAAA9olDJ5airzwo7xgUVENDQ94RAAAoICfYAQAAAAAAsEsrvvO9Pfr8uy45P37Vta5/3dgYsXH1qhh2yQkxuNH5D9RHX1+fkh0AAJlTsAMAAAAAAGCXBg/e0z8p/d+SU2nI4JjzJ5fFh8/5QIyME7INBv/HU297LZ45997o7OyM1tbWmma1z23PJhQAAIWgYAcAAAAAAEBdjCwPi3vm3RmN2/ryjgIAALBXnMENAAAAAABA5ia1HhE/XPz3ccy4o/KOAgAAsNecYAcAAAAAAECmLvvQR+O8d0+JxsaBZz1sefm1nBJRdH5bAADUi4IdAAAAAAAAmfrw2dMGrJMkiaQ8IlZc8Z18AnFQSMojIkmSvGMAAFAwCnYAAAAAAADUVaVSic6O5yNN07yjUGBJkkSlUsk7BgAABaNgBwAAAAAAQN1VKhXlJwAA4IDTmHcAAAAAAAAAAAAA2B8p2AEAAAAAAAAAAMCbcEUsAAAAAAAAdVetViNN07xjUGBJkriGGACAzCnYAQAAAAAAkKm/+Osvxsc/clGMGJ5ExK/LdUe3HRNp7/qck1FkSXlEdHY8r2QHAECmFOwAAAAAAADI1MP/+q/x7R/8IP7+ti/GWyYcE2maRtq7PiZ96ZxoGjUs73gU0JaXX4sVV3wn0jRVsAMAIFMKdgAAAAAAAGSuun5jTLvysrjjs7OibfSEiIhoGjUshowdnnMyAACA3deYdwAAAAAAAACK6fUt2+Oyz90Y937/obyjAAAA7BUn2AEAAAAAALBLt3/t7j36/Evd1f7XO3b0xcJvPRhtJx0ffTt2ZB0NAACgrhTsAAAAAAAA2KUFf39fzTP6hlei8R/T6Pvj4dHQ5JIlsnXCsmFxwo3TY+7fzc07CgAABeOfXgAAAAAAANgntr+6I+L17XnHoKAaGhryjgAAQAE5wQ4AAAAAAIBdOmbcqD36/PNrXt5p75Adr0fDB4+MhuSQrGLBAH19fUp2AABkTsEOAAAAAACAXXp40Tf26PPvvOjD8auu7v71u078H3H35+bFf730w1lHg4iIeOptr8Uz594bnZ2d0draWtOs9rnt2YQCAKAQXBELAAAAAABAXTQ2Rlx70QXx6Qs/nncUAACAveIEOwAAAAAAADI3pGlQ3PGZWfFHJ54Sq1atyjsOAADAXlGwAwAAAAAAIFNvazs6Fn7upnjLhGPyjgIAAFATBTsAAAAAAAAy9aVZN7/p/paXX9vHSThY+G0BAFAvCnYAAAAAAADUVZIkkZRHxIorvpN3FAosKY+IJEnyjgEAQMEo2AEAAAAAAFBXlUolOjuejzRN845CgSVJEpVKJe8YAAAUjIIdAAAAAAAAdVepVJSfAACAA05j3gEAAAAAAAAAAABgf+QEOwAAAAAAAOquWq26Ipa6ckUsAAD1oGAHAAAAAABApv7tFz+Ltx93fP+6Wq3G0W3HRNq7Pr9QFF5SHhGdHc8r2QEAkCkFOwAAAAAAADJ13fyb4q3HHB0LPvMX0djYGGmaRtq7PiZ96ZxoGjUs73gU0JaXX4sVV3wn0jRVsAMAIFMKdgAAAAAAAGSqry/ie//yVLzv4xfGfX/5V/37TaOGxZCxw3NMBgAAsGca8w4AAAAAAABAMS3vXBunTz8/1r7clXcUAACAvaJgBwAAAAAAQN1097waf/L5OVE+4vC8owAAAOwxV8QCAAAAAACwS21nnVHT869v3h4t/+2/xuD/2BThiljq4IRlw+KEG6fH3L+bm3cUAAAKxgl2AAAAAAAA1N2OvohXf/JqRHVr3lEoqIaGhrwjAABQQAp2AAAAAAAA1N3gQRFDzxoRUTkk7ygUVF9fX94RAAAoIFfEAgAAAAAAsEsd//zDPfr8Oy/6cPyqq7t/PbI8LJ757g/jLdPfl3U0iIiIp972Wjxz7r3R2dkZra2tNc1qn9ueTSgAAArBCXYAAAAAAADUzduOGRdfmXNzvP7qxryjAAAA7DEFOwAAAAAAAOriPSefGA8t+HIMPXRo3lEAAAD2iitiAQAAAAAAyNSQpkPikxecH1edf3HeUQAAAGqiYAcAAAAAAECmvvL5v4wxLaN22t/y8ms5pOFg4LcFAEC9KNgBAAAAAACQqTeW65IkiaQ8IlZc8Z2cEnEwSMojIkmSvGMAAFAwCnYAAAAAAADUVaVSic6O5yNN07yjUGBJkkSlUsk7BgAABaNgBwAAAAAAQN1VKhXlJwAA4IDTmHcAAAAAAAAAAAAA2B85wQ4AAAAAAIC6q1arroilrlwRCwBAPSjYAQAAAAAAkKnNW7bEkKam/nW1Wo2j246JtHd9jqkouqQ8Ijo7nleyAwAgUwp2AAAAAAAAZOpjn74yLjn3o3HmSe+MiIg0TSPtXR+TvnRONI0alnM6imjLy6/Fiiu+E2maKtgBAJApBTsAAAAAAAAy1d2zPj7+53PjT/9nZ1x5/vT+/aZRw2LI2OE5JgMAANgzjXkHAAAAAAAAoHh29EXc/rWvxyf+Ylbs2LEj7zgAAAB7xQl2AAAAAAAA1M13H3syfrl6VTQMcu4DAABw4FGwAwAAAAAAYJfazjqjpuefW90Vk848JWLD9oixGYUCAADYBxTsAAAAAAAAqLstOxqj71s9MeRPhkVUDsk7DgVzwrJhccKN02Pu383NOwoAAAXjLG4AAAAAAAD2iUMnlqKvPCjvGBRUQ0ND3hEAACggJ9gBAAAAAACwSyu+8709+vy7Ljk/ftW1rn/d2BixcfWqGHbJCTG40fkP1EdfX5+SHQAAmVOwAwAAAAAAYJcGD97TPyn935JTacjgmPMnl8WHz/lAjIwTsg0G/8dTb3stnjn33ujs7IzW1taaZrXPbc8mFAAAhaBgBwAAAAAAQF2MLA+Le+bdGY3b+vKOAgAAsFecwQ0AAAAAAEDmJrUeET9c/PdxzLij8o4CAACw15xgBwAAAAAAQKYu+9BH47x3T4nGxoFnPWx5+bWcElF0flsAANSLgh0AAAAAAACZ+vDZ0waskySJpDwiVlzxnXwCcVBIyiMiSZK8YwAAUDAKdgAAAAAAANRVpVKJzo7nI03TvKNQYEmSRKVSyTsGAAAFo2AHAAAAAABA3VUqFeUnAADggNOYdwAAAAAAAAAAAADYHynYAQAAAAAAAAAAwJtwRSwAAAAAAABAnVSr1UjTNO8YFFSSJK7fBoA6U7ADAAAAAAAAqNF9378vHv33R+OumXf171Wr1ZjY1hY9vb35BaPQmsvlWNnRoWQHAHWkYAcAAAAAAABQo96NvbF56+Zon9seC65ZEKVSKdI0jZ7e3njwlvkxtqUl74gUTFd3d0ydOSPSNFWwA4A6UrADAAAAAAAAyNCV866MWe2z+tdjW1piwugxOSYCAGBvNeYdAAAAAAAAAKBo5i6aG48/83jeMQAAqJET7AAAAAAAAAAi4uGfPDxgffnNl+/2s9u2bdtp79GnH40zLziz5lwAAORHwQ4AAAAAAAAgIu5/5P4B663bttY8c9zEcfHVF5+IG0Z/sOZZ8JvWrVgds0+fFssW3hOdpVLecQCgsBTsAAAAAAAAAOpoc2zPOwIFtGXDxjhu1JGxoXNNbMg7DAAUmIIdAAAAAAAAQEQcP+n4WLpsaaYzN726Ka6edFamMyEiomn40Fi6YnmcOHlylGo8wW5d17KMUgFA8SjYAQAAAAAAAETE5R+8PNrntvevF81atNvPLnxgYSx5dsmAvQmHT4g5N8yJqxcr2JG9kZOOihtvnR2di2+P1tbWmmYtf+TSbEIBQAE15h0AAAAAAAAAoGjef+r744J3X5B3DAAAauQEOwAAAAAAAIAMzWqfFa1jWmPVqlV5RwEAoEYKdgAAAAAAAAA1Gtz46z+9LrhmQZRKpZzTAACQFQU7AAAAAAAAgBpNnzI9pk+Z/qbvdXV37+M0HAz8rgBg31CwAwAAAAAAAKiDJEmiuVyOqTNn5B2FgmoulyNJkrxjAEChKdgBAAAAAAAA1EGlUomVHR2RpmneUSioJEmiUqnkHQMACk3BDgAAAAAAAKBOKpWKAhQAwAGsMe8AAAAAAAAAAAAAsD9ygh0AAAAAAABAnVSrVVfEUjeuiAWA+lOwAwAAAAAAAKjRkz9/Mta+sjbOPePc/r1qtRoT29qip7c3v2AUWnO5HCs7OpTsAKCOFOwAAAAAAAAAavTM88/EkmeXxLJVy+KGi2+IiIg0TaOntzcevGV+jG1pyTkhRdPV3R1TZ86INE0V7ACgjhTsAAAAAAAAADKyumt1XHXbVXHntXf2741taYkJo8fkmAoAgL3VmHcAAAAAAAAAgCLZtHlTXDL3knj99dfzjgIAQI0U7AAAAAAAAAAy1hd9Me/+eVEql/KOAgBADVwRCwAAAAAAABARV9xyxYB1+9z2mmee/6nz4+n0BVfEkrl1K1bH7NOnxbKF90RnSZETAOpFwQ4AAAAAAAAgIrZv3575zIaGhvjJq53xvjgh89kc3LZs2BjHjToyNnSuiQ15hwGAAlOwAwAAAAAAAIiIww49LNa/tj7TmX19ffGRkZMznQkREU3Dh8bSFcvjxMmTo1TjCXbrupZllAoAikfBDgAAAAAAACAi5l89f8C1sItmLdrtZxc+sDCWPLtkwF5DNMTi2YvjssWnZpYR/tPISUfFjbfOjs7Ft0dra2tNs5Y/cmk2oQCggBrzDgAAAAAAAABQNEOHDI3PfuyzeccAAKBGCnYAAAAAAAAAGTr6iKPjjmvvyDsGAAAZcEUsAAAAAAAAQEbOecc5Me2d0/KOAQBARhTsAAAAAAAAAGp02vGnxRlvPyPaxrXt9F5Xd3cOiSg6vysA2DcU7AAAAAAAAABqdGzrsTvtJUkSzeVyTJ05I4dEHAyay+VIkiTvGABQaAp2AAAAAAAAAHVQqVRiZUdHpGmadxQKKkmSqFQqeccAgEJTsAMAAAAAAACok0qlogAFAHAAa8w7AAAAAAAAAAAAAOyPnGAHAAAAAAAAUCfVatUVsdSNK2IBoP4U7AAAAAAAAABq1NvbG6VSKUqlUv9etVqNiW1t0dPbm18wCq25XI6VHR1KdgBQRwp2AAAAAAAAADW678f3xZJnl8T1F14fbePaIiIiTdPo6e2NB2+ZH2NbWnJOSNF0dXfH1JkzIk1TBTsAqCMFOwAAAAAAAICM3PSVm2LKKVNiyilT+vfGtrTEhNFjckwFAMDeasw7AAAAAAAAAECRPPTYQ3HTl2/KOwYAABlQsAMAAAAAAADIWMfajrjt3tvyjgEAQI1cEQsAAAAAAAAQEXPunjNg3T63vaZ5m7dujov+7KKaZgAAkC8FOwAAAAAAAICIeGndS5nPbBzUGHe/+Fh8fvSHMp/NwW3ditUx+/RpsWzhPdFZKuUdBwAKS8EOAAAAAAAAoE76+vpifFNz3jEooC0bNsZxo46MDZ1rYkPeYQCgwBTsAAAAAAAAACLii5/6Ylw578r+9bxr5u32s9/47jdi6bKlO+0/8dAT8beXfyaTfPCbmoYPjaUrlseJkydHqcYT7NZ1LcsoFQAUj4IdAAAAAAAAQMROJaVyqbzbzw4aNGinvfZz2mPxDYtrjQVvauSko+LGW2dH5+Lbo7W1taZZyx+5NJtQAFBAjXkHAAAAAAAAACiaBdcsiDHlMXnHAACgRk6wAwAAAAAAAMjIkKYhcdd1d+UdAwCAjCjYAQAAAAAAANRo/Kjx0TW6K+ZcMmen97q6u3NIRNH5XQHAvqFgBwAAAAAAAFCjs086O84+6ewBe0mSRHO5HFNnzsgpFUXXXC5HkiR5xwCAQlOwAwAAAAAAAKiDSqUSKzs6Ik3TvKNQUEmSRKVSyTsGABSagh0AAAAAAABAnVQqFQUoAIADWGPeAQAAAAAAAAAAAGB/pGAHAAAAAAAAAAAAb8IVsQAAAAAAAAB1Uq1WI03TvGNQUEmSuIIYAOpMwQ4AAAAAAACgRvd9/7549N8fjbtm3tW/V61WY2JbW/T09uYXjEJrLpdjZUeHkh0A1JGCHQAAAAAAAECNejf2xuatm6N9bnssuGZBlEqlSNM0enp748Fb5sfYlpa8I1IwXd3dMXXmjEjTVMEOAOpIwQ4AAAAAAAAgQ1fOuzJmtc/qX49taYkJo8fkmAgAgL3VmHcAAAAAAAAAgKKZu2huPP7M43nHAACgRk6wAwAAAAAAAIiIh3/y8ID15TdfvtvPbtu2bae9R59+NM684MyacwEAkB8FOwAAAAAAAICIuP+R+west27bWvPMcRPHxVdffCJuGP3BmmfBb1q3YnXMPn1aLFt4T3SWSnnHAYDCUrADAAAAAAAAqKPNsT3vCBTQlg0b47hRR8aGzjWxIe8wAFBgCnYAAAAAAAAAEXH8pONj6bKlmc7c9OqmuHrSWZnOhIiIpuFDY+mK5XHi5MlRqvEEu3VdyzJKBQDFo2AHAAAAAAAAEBGXf/DyaJ/b3r9eNGvRbj+78IGFseTZJQP2Jhw+IebcMCeuXqxgR/ZGTjoqbrx1dnQuvj1aW1trmrX8kUuzCQUABdSYdwAAAAAAAACAonn/qe+PC959Qd4xAACokRPsAAAAAAAAADI0q31WtI5pjVWrVuUdBQCAGinYAQAAAAAAANRocOOv//S64JoFUSqVck4DAEBWFOwAAAAAAAAAajR9yvSYPmX6m77X1d29j9NwMPC7AoB9Q8EOAAAAAAAAoA6SJInmcjmmzpyRdxQKqrlcjiRJ8o4BAIWmYAcAAAAAAABQB5VKJVZ2dESapnlHoaCSJIlKpZJ3DAAoNAU7AAAAAAAAgDqpVCoKUAAAB7DGvAMAAAAAAAAAAADA/sgJdgAAAAAAAAB1Uq1WXRFL3bgiFgDqT8EOAAAAAAAAoEZP/vzJWPvK2jj3jHP796rVakxsa4ue3t78glFozeVyrOzoULIDgDpSsAMAAAAAAACo0TPPPxNLnl0Sy1YtixsuviEiItI0jZ7e3njwlvkxtqUl54QUTVd3d0ydOSPSNFWwA4A6UrADAAAAAAAAyMjqrtVx1W1XxZ3X3tm/N7alJSaMHpNjKgAA9lZj3gEAAAAAAAAAimTT5k1xydxL4vXXX887CgAANVKwAwAAAAAAAMhYX/TFvPvnRalcyjsKAAA1cEUsAAAAAAAAQERcccsVA9btc9trnnn+p86Pp9MXXBFL5tatWB2zT58WyxbeE50lRU4AqBcFOwAAAAAAAICI2L59e+YzGxoa4ievdsb74oTMZ3Nw27JhYxw36sjY0LkmNuQdBgAKTMEOAAAAAAAAICIOO/SwWP/a+kxn9vX1xUdGTs50JkRENA0fGktXLI8TJ0+OUo0n2K3rWpZRKgAoHgU7AAAAAAAAgIiYf/X8AdfCLpq1aLefXfjAwljy7JIBew3REItnL47LFp+aWUb4TyMnHRU33jo7OhffHq2trTXNWv7IpdmEAoACasw7AAAAAAAAAEDRDB0yND77sc/mHQMAgBop2AEAAAAAAABk6Ogjjo47rr0j7xgAAGTAFbEAAAAAAAAAGTnnHefEtHdOyzsGAAAZUbADAAAAAAAAqNFpx58WZ7z9jGgb17bTe13d3Tkkouj8rgBg31CwAwAAAAAAAKjRsa3H7rSXJEk0l8sxdeaMHBJxMGgulyNJkrxjAEChKdgBAAAAAAAA1EGlUomVHR2RpmneUSioJEmiUqnkHQMACk3BDgAAAAAAAKBOKpWKAhQAwAGsMe8AAAAAAAAAAAAAsD9ygh0AAAAAAABAnVSrVVfEUjeuiAWA+lOwAwAAAAAAAKhRb29vlEqlKJVK/XvVajUmtrVFT29vfsEotOZyOVZ2dCjZAUAdKdgBAAAAAAAA1Oi+H98XS55dEtdfeH20jWuLiIg0TaOntzcevGV+jG1pyTkhRdPV3R1TZ86INE0V7ACgjhTsAAAAAAAAADJy01duiimnTIkpp0zp3xvb0hITRo/JMRUAAHurMe8AAAAAAAAAAEXy0GMPxU1fvinvGAAAZEDBDgAAAAAAACBjHWs74rZ7b8s7BgAANXJFLAAAAAAAAEBEzLl7zoB1+9z2muZt3ro5Lvqzi2qaAQBAvhTsAAAAAAAAACLipXUvZT6zcVBj3P3iY/H50R/KfDYHt3UrVsfs06fFsoX3RGeplHccACgsBTsAAAAAAACAOunr64vxTc15x6CAtmzYGMeNOjI2dK6JDXmHAYACU7ADAAAAAAAAiIgvfuqLceW8K/vX866Zt9vPfuO734ily5butP/EQ0/E317+mUzywW9qGj40lq5YHidOnhylGk+wW9e1LKNUAFA8CnYAAAAAAAAAETuVlMql8m4/O2jQoJ322s9pj8U3LK41FrypkZOOihtvnR2di2+P1tbWmmYtf+TSbEIBQAE15h0AAAAAAAAAoGgWXLMgxpTH5B0DAIAaOcEOAAAAAAAAICNDmobEXdfdlXcMAAAyomAHAAAAAAAAUKPxo8ZH1+iumHPJnJ3e6+ruziERRed3BQD7hoIdAAAAAAAAQI3OPunsOPukswfsJUkSzeVyTJ05I6dUFF1zuRxJkuQdAwAKTcEOAAAAAAAAoA4qlUqs7OiINE3zjkJBJUkSlUol7xgAUGgKdgAAAAAAAAB1UqlUFKAAAA5gjXkHAAAAAAAAAAAAgP2Rgh0AAAAAAAAAAAC8CVfEAgAAAAAAANRJtVqNNE3zjkFBJUniCmIAqDMFOwAAAAAAAIAa3ff9++LRf3807pp5V/9etVqNiW1t0dPbm18wCq25XI6VHR1KdgBQRwp2AAAAAAAAADXq3dgbm7dujva57bHgmgVRKpUiTdPo6e2NB2+ZH2NbWvKOSMF0dXfH1JkzIk1TBTsAqCMFOwAAAAAAAIAMXTnvypjVPqt/PbalJSaMHpNjIgAA9lZj3gEAAAAAAAAAimbuornx+DOP5x0DAIAaOcEOAAAAAAAAICIe/snDA9aX33z5bj+7bdu2nfYeffrROPOCM2vOBQBAfhTsAAAAAAAAACLi/kfuH7Deum1rzTPHTRwXX33xibhh9AdrngW/ad2K1TH79GmxbOE90Vkq5R0HAApLwQ4AAAAAAACgjjbH9rwjUEBbNmyM40YdGRs618SGvMMAQIEp2AEAAAAAAABExPGTjo+ly5ZmOnPTq5vi6klnZToTIiKahg+NpSuWx4mTJ0epxhPs1nUtyygVABSPgh0AAAAAAABARFz+wcujfW57/3rRrEW7/ezCBxbGkmeXDNibcPiEmHPDnLh6sYId2Rs56ai48dbZ0bn49mhtba1p1vJHLs0mFAAUUGPeAQAAAAAAAACK5v2nvj8uePcFeccAAKBGTrADAAAAAAAAyNCs9lnROqY1Vq1alXcUAABqpGAHAAAAAAAAUKPBjb/+0+uCaxZEqVTKOQ0AAFlRsAMAAAAAAACo0fQp02P6lOlv+l5Xd/c+TsPBwO8KAPYNBTsAAAAAAACAOkiSJJrL5Zg6c0beUSio5nI5kiTJOwYAFJqCHQAAAAAAAEAdVCqVWNnREWma5h2FgkqSJCqVSt4xAKDQFOwAAAAAAAAA6qRSqShAAQAcwBrzDgAAAAAAAAAAAAD7IyfYAQAAAAAAANRJtVp1RSx144pYAKg/BTsAAAAAAACAGj358ydj7Str49wzzu3fq1arMbGtLXp6e/MLRqE1l8uxsqNDyQ4A6kjBDgAAAAAAAKBGzzz/TCx5dkksW7Usbrj4hoiISNM0enp748Fb5sfYlpacE1I0Xd3dMXXmjEjTVMEOAOpIwQ4AAAAAAAAgI6u7VsdVt10Vd157Z//e2JaWmDB6TI6pAADYW415BwAAAAAAAAAokk2bN8Ulcy+J119/Pe8oAADUSMEOAAAAAAAAIGN90Rfz7p8XpXIp7ygAANTAFbEAAAAAAAAAEXHFLVcMWLfPba955vmfOj+eTl9wRSyZW7didcw+fVosW3hPdJYUOQGgXhTsAAAAAAAAACJi+/btmc9saGiIn7zaGe+LEzKfzcFty4aNcdyoI2ND55rYkHcYACgwBTsAAAAAAACAiDjs0MNi/WvrM53Z19cXHxk5OdOZEBHRNHxoLF2xPE6cPDlKNZ5gt65rWUapAKB4FOwAAAAAAAAAImL+1fMHXAu7aNai3X524QMLY8mzSwbsNURDLJ69OC5bfGpmGeE/jZx0VNx46+zoXHx7tLa21jRr+SOXZhMKAAqoMe8AAAAAAAAAAEUzdMjQ+OzHPpt3DAAAaqRgBwAAAAAAAJCho484Ou649o68YwAAkAFXxAIAAAAAAABk5Jx3nBPT3jkt7xgAAGREwQ4AAAAAAACgRqcdf1qc8fYzom1c207vdXV355CIovO7AoB9Q8EOAAAAAAAAoEbHth67016SJNFcLsfUmTNySMTBoLlcjiRJ8o4BAIWmYAcAAAAAAABQB5VKJVZ2dESapnlHoaCSJIlKpZJ3DAAoNAU7AAAAAAAAgDqpVCoKUAAAB7DGvAMAAAAAAAAAAADA/sgJdgAAAAAAAAB1Uq1WXRFL3bgiFgDqT8EOAAAAAAAAoEa9vb1RKpWiVCr171Wr1ZjY1hY9vb35BaPQmsvlWNnRoWQHAHWkYAcAAAAAAABQo/t+fF8seXZJXH/h9dE2ri0iItI0jZ7e3njwlvkxtqUl54QUTVd3d0ydOSPSNFWwA4A6UrADAAAAAAAAyMhNX7kpppwyJaacMqV/b2xLS0wYPSbHVAAA7K3GvAMAAAAAAAAAFMlDjz0UN335prxjAACQAQU7AAAAAAAAgIx1rO2I2+69Le8YAADUyBWxAAAAAAAAABEx5+45A9btc9trmrd56+a46M8uqmkGAAD5UrADAAAAAAAAiIiX1r2U+czGQY1x94uPxedHfyjz2Rzc1q1YHbNPnxbLFt4TnaVS3nEAoLAU7AAAAAAAAADqpK+vL8Y3NecdgwLasmFjHDfqyNjQuSY25B0GAApMwQ4AAAAAAAAgIr74qS/GlfOu7F/Pu2bebj/7je9+I5YuW7rT/hMPPRF/e/lnMskHv6lp+NBYumJ5nDh5cpRqPMFuXdeyjFIBQPEo2AEAAAAAAABE7FRSKpfKu/3soEGDdtprP6c9Ft+wuNZY8KZGTjoqbrx1dnQuvj1aW1trmrX8kUuzCQUABdSYdwAAAAAAAACAollwzYIYUx6TdwwAAGrkBDsAAAAAAACAjAxpGhJ3XXdX3jEAAMiIgh0AAAAAAABAjcaPGh9do7tiziVzdnqvq7s7h0QUnd8VAOwbCnYAAAAAAAAANTr7pLPj7JPOHrCXJEk0l8sxdeaMnFJRdM3lciRJkncMACg0BTsAAAAAAACAOqhUKrGyoyPSNM07CgWVJElUKpW8YwBAoSnYAQAAAAAAANRJpVJRgAIAOIA15h0AAAAAAAAAAAAA9kcKdgAAAAAAAAAAAPAmXBELAAAAAAAAUCfVajXSNM07BgWVJIkriAGgzhTsAAAAAAAAAGp03/fvi0f//dG4a+Zd/XvVajUmtrVFT29vfsEotOZyOVZ2dCjZAUAdKdgBAAAAAAAA1Kh3Y29s3ro52ue2x4JrFkSpVIo0TaOntzcevGV+jG1pyTsiBdPV3R1TZ86INE0V7ACgjhTsAAAAAAAAADJ05bwrY1b7rP712JaWmDB6TI6JAADYW415BwAAAAAAAAAomrmL5sbjzzyedwwAAGrkBDsAAAAAAACAiHj4Jw8PWF9+8+W7/ey2bdt22nv06UfjzAvOrDkXAAD5UbADAAAAAAAAiIj7H7l/wHrrtq01zxw3cVx89cUn4obRH6x5FvymdStWx+zTp8WyhfdEZ6mUdxwAKCwFOwAAAAAAAIA62hzb845AAW3ZsDGOG3VkbOhcExvyDgMABaZgBwAAAAAAABARx086PpYuW5rpzE2vboqrJ52V6UyIiGgaPjSWrlgeJ06eHKUaT7Bb17Uso1QAUDwKdgAAAAAAAAARcfkHL4/2ue3960WzFu32swsfWBhLnl0yYG/C4RNizg1z4urFCnZkb+Sko+LGW2dH5+Lbo7W1taZZyx+5NJtQAFBAjXkHAAAAAAAAACia95/6/rjg3RfkHQMAgBo5wQ4AAAAAAAAgQ7PaZ0XrmNZYtWpV3lEAAKiRgh0AAAAAAABAjQY3/vpPrwuuWRClUinnNAAAZEXBDgAAAAAAAKBG06dMj+lTpr/pe13d3fs4DQcDvysA2DcU7AAAAAAAAADqIEmSaC6XY+rMGXlHoaCay+VIkiTvGABQaAp2AAAAAAAAAHVQqVRiZUdHpGmadxQKKkmSqFQqeccAgEI76At2fX19sWrVqnjmmWdizZo10dvbG0OGDInm5uZ4y1veEieccEKUSqVMv3PDhg3xxBNPxHPPPRdpmsahhx4aRx11VJx00klxxBFHZPpdAAAAAAAAQH4qlYoCFADAAeygLNj19PTEAw88EP/8z/8cjzzySHTv4m76Qw45JN773vfGJz/5yTj11FNr+t7Ozs6YPXt23HfffbFly5ad3m9oaIhTTz01Pve5z8Upp5xS03cBAAAAAAAAAABQm4OuYPfxj388Fi1a9KYFtzezdevWeOCBB+KBBx6ICy64IO688869usP+vvvui4suuig2btz4Wz/T19cXP/7xj+O0006L6667Lm666aZoaGjY4+8CAAAAAAAA9g/VatUVsdSNK2IBoP4OuoLdT3/60zct1w0aNCjGjh0bo0ePjq1bt8bq1atj/fr1Az7zta99LZYvXx4//OEP47DDDtvt7/zmN78ZH/3oR2PHjh0D9g8//PAYP358vPzyy7F27dro6+uLiF8X7W655ZbYvHlz3H777Xvx7xIAAAAAAADYl578+ZOx9pW1ce4Z5/bvVavVmNjWFj29vfkFo9Cay+VY2dGhZAcAdXTQFex+U7lcjvPPPz/e+973xsknnxzDhw/vf2/79u3x+OOPx+zZs+Pxxx/v31+yZElceOGFcf/99+/Wd3R0dMRFF100oFz33//7f4/bb7893vnOd/bvrVixIj7zmc/Et771rf69L3zhC3HyySfHBz7wgVr+bQIAAAAAAAB19szzz8SSZ5fEslXL4oaLb4iIiDRNo6e3Nx68ZX6MbWnJOSFF09XdHVNnzog0TRXsAKCODsqCXWtra8yaNSvOP//8OPTQQ9/0M4MGDYrTTjstfvSjH8UVV1wRCxcu7H/vH/7hH+JHP/rRgILcb3PDDTfEa6+91r8+4YQT4gc/+MFO18xOmjQp7r///rjssssGfNd1110XU6ZMicGDD8r/qgAAAAAAAOCAsrprdVx121Vx57V39u+NbWmJCaPH5JgKAIC91Zh3gH3tc5/7XKxYsSIuvvji31qu+02DBg2KL33pS/H2t799wP6iRYt+57O/+MUv4t577+1fNzU1xVe/+tWdynX/qaGhIb74xS/GW97ylv69jo6O+PKXv/w7vwsAAAAAAADYP2zavCkumXtJvP7663lHAQCgRgddwe69731vNDU17dEzgwYNiuuuu27A3ve+973f+dzf/M3fDLga9iMf+Ui87W1v2+UzpVIpPv3pTw/Y250yHwAAAAAAALD/6Iu+mHf/vCiVS3lHAQCgBu4d3U0nn3zygPW6deti48aNMXTo0N/6zEMPPTRgffHFF+/Wd334wx+OT3ziE/1Xyz711FPx4osvxhFHHLGHqQEAAAAAAIDddcUtVwxYt89tr3nm+Z86P55OX3BFLJlbt2J1zD59WixbeE90lhQ5AaBeFOx2U3Nz805769ev/60FuxUrVsTKlSv718OGDYuTTjppt77rPz/78MMPR0REX19ffPe7341LLrlkL5IDAAAAAAAAu2P79u2Zz2xoaIifvNoZ74sTMp/NwW3Lho1x3KgjY0PnmtiQdxgAKDAFu920du3anfZGjhz5Wz//s5/9bMD6D//wD2Pw4N3/j/sd73hHf8HuzeYBAAAAAAAA2Trs0MNi/WvrM53Z19cXHxk5OdOZEBHRNHxoLF2xPE6cPDlKNZ5gt65rWUapAKB4FOx20+OPPz5gfdRRR0VTU9Nv/fyyZQP/B8jv/d7v7dH3vfHzb5wHAAAAAAAAZGv+1fMHXAu7aNai3X524QMLY8mzSwbsNURDLJ69OC5bfGpmGeE/jZx0VNx46+zoXHx7tLa21jRr+SOXZhMKAAqoMe8AB4q/+Zu/GbB+z3ves8vPr1ixYsB6/Pjxe/R9b/z8G+cBAAAAAAAA+6+hQ4bGZz/22bxjAABQIwW73fCP//iP8dhjjw3Yu/DCC3f5zMsvvzxgPW7cuD36ziOPPHLA+pVXXtmj5wEAAAAAAIB8HH3E0XHHtXfkHQMAgAy4IvZ3qFarcemlA4/DnTZtWvzhH/7hLp979dVXB6yHDRu2R9/7xs9v3bo1Nm/eHEOGDNmjOW/08ssv73FZb+XKlTV9JwAAAAAAABwsznnHOTHtndPyjgEAQEYU7HZhx44d8bGPfSzWrFnTvzdixIi4447f/f82eWPBrlQq7dF3H3rooW86s9aC3Ze+9KX43Oc+V9MMAAAAAAAAYKDTjj8tznj7GdE2rm2n97q6u3NIRNH5XQHAvqFgtwvXXntt/NM//dOAvbvvvjvGjx//O599/fXXB6ybmpr26LvfrEi3adOmPZoBAAAAAAAA7BvHth67016SJNFcLsfUmTNySMTBoLlcjiRJ8o4BAIWmYPdb3HHHHfGXf/mXA/auu+66+PCHP7xbz7/xxLotW7bs0fdv3rz5d84EAAAAAAAA9l+VSiVWdnREmqZ5R6GgkiSJSqWSdwwAKDQFuzfx93//9/HJT35ywN6FF14YN998827POOywwwas33ii3e/yZqfVvXHm3rjiiivivPPO26NnVq5cGdOmTav5uwEAAAAAAOBgU6lUFKAAAA5gCnZv8J3vfCf++I//OPr6+vr3PvCBD8SiRYuioaFht+e8sQz32muv7VGON35+8ODBmZxgN2rUqBg1alTNcwAAAAAAAAAAAIpOwe43/OhHP4rzzjsvtm3b1r/3rne9K77xjW/EoEGD9mjWG0tsa9as2aPn165dO2B9+OGH79HzAAAAAAAAQP6q1aorYqkbV8QCQP0p2P0fP/3pT2PKlCkDrnI96aST4tvf/nY0NTXt8bxJkyYNWP/qV7/ao+ff+Pm3vvWte5wBAAAAAAAA2Dd6e3ujVCoNuJWqWq3GxLa26OntzS8YhdZcLsfKjg4lOwCoIwW7iPj5z38eZ599drz66qv9e7//+78f//iP/xjDhg3bq5lvLMT9x3/8xx49v2zZsl3OAwAAAAAAAPYf9/34vljy7JK4/sLro21cW0REpGkaPb298eAt82NsS0vOCSmaru7umDpzRqRpqmAHAHV00BfsVqxYEe9617uip6enf+9tb3tbfO9734sRI0bs9dzjjz9+wPqpp56Kbdu2xeDBu/cf+RNPPLHLeQAAAAAAAMD+56av3BRTTpkSU06Z0r83tqUlJowek2MqAAD2VmPeAfK0evXq+KM/+qN4+eWX+/eOPvroePjhh+Pwww+vafZb3/rWaGtr61+/9tpr8a//+q+79exrr70WTz75ZP+6oaEhzjnnnJryAAAAAAAAAPvGQ489FDd9+aa8YwAAkIGDtmDX1dUVZ5xxRqxZs6Z/78gjj4wf/vCHceSRR2byHVOmTBmwXrx48W49d++99w64rvbtb397HHHEEZlkAgAAAAAAAOqvY21H3HbvbXnHAACgRgflFbHVajXe9a53RUdHR//e4YcfHg8//HAcffTRmX3P9OnT4wtf+EL09fVFRMQ999wTn/70p+Ntb3vbb33m9ddfj5tvvnnA3sUXX5xZJgAAAAAAAODNzbl7zoB1+9z2muZt3ro5Lvqzi2qaAQBAvg66gt2GDRvirLPOil/84hf9e+VyOb7//e/vsvi2N/7Lf/kv8aEPfSjuvffeiIjYsmVL/PEf/3H84Ac/iCRJdvp8X19ffPKTn4xf/vKX/XvHHHNMTJ8+PdNcAAAAAAAAwM5eWvdS5jMbBzXG3S8+Fp8f/aHMZ3NwW7didcw+fVosW3hPdJZKeccBgMI66Ap2U6ZMiaeeemrA3qc+9ano7u6OH/zgB3s06w/+4A+iubl5l5+ZO3du/K//9b9i48aNERHx1FNPxSmnnBJf+MIX4rTTTuv/3HPPPRfXX399fOtb3xrw/M033xyHHHLIHuUCAAAAAAAA9g99fX0xvmnXf1OEvbFlw8Y4btSRsaFzTWzIOwwAFNhBV7D78Y9/vNPe7Nmz92rWj370owEluTczceLEWLx4cZx//vn9V8U+/fTT8c53vjMOP/zwmDBhQrz88suxZs2a/vf/01VXXRXnnXfeXmUDAAAAAAAA9swXP/XFuHLelf3redfM2+1nv/Hdb8TSZUt32n/ioSfiby//TCb54Dc1DR8aS1csjxMnT45SjSfYretallEqACieg65gl4ePfOQj0dfXFxdffHFs2rSpf/+VV16JV1555U2fueaaa+LWW2/dVxEBAAAAAADgoPfGklK5VN7tZwcNGrTTXvs57bH4hsW1xoI3NXLSUXHjrbOjc/Ht0draWtOs5Y9cmk0oACigxrwDHCw++tGPxrPPPhvnn3/+Lq98PeWUU+LHP/5x3HbbbdHQ0LAPEwIAAAAAAABZWXDNghhTHpN3DAAAanTQnWD3xmtY96Vjjjkmvv71r8df/dVfxb/8y7/EL3/5y9iwYUOUSqWYMGFCvOMd74gjjzwyt3wAAAAAAABAbYY0DYm7rrsr7xgAAGTkoCvY7Q+SJIn3vOc9eccAAAAAAAAAMjJ+1PjoGt0Vcy6Zs9N7Xd3dOSSi6PyuAGDfULADAAAAAAAAqNHZJ50dZ5909oC9JEmiuVyOqTNn5JSKomsulyNJkrxjAEChKdgBAAAAAAAA1EGlUomVHR2RpmneUSioJEmiUqnkHQMACk3BDgAAAAAAAKBOKpWKAhQAwAGsMe8AAAAAAAAAAAAAsD9SsAMAAAAAAAAAAIA34YpYAAAAAAAAgDqpVquRpmneMSioJElcQQwAdaZgBwAAAAAAAFCj+75/Xzz674/GXTPv6t+rVqsxsa0tenp78wtGoTWXy7Gyo0PJDgDqSMEOAAAAAAAAoEa9G3tj89bN0T63PRZcsyBKpVKkaRo9vb3x4C3zY2xLS94RKZiu7u6YOnNGpGmqYAcAdaRgBwAAAAAAAJChK+ddGbPaZ/Wvx7a0xITRY3JMBADA3mrMOwAAAAAAAABA0cxdNDcef+bxvGMAAFAjJ9gBAAAAAAAARMTDP3l4wPrymy/f7We3bdu2096jTz8aZ15wZs25AADIj4IdAAAAAAAAQETc/8j9A9Zbt22teea4iePiqy8+ETeM/mDNs+A3rVuxOmafPi2WLbwnOkulvOMAQGEp2AEAAAAAAADU0ebYnncECmjLho1x3KgjY0PnmtiQdxgAKDAFOwAAAAAAAICIOH7S8bF02dJMZ256dVNcPemsTGdCRETT8KGxdMXyOHHy5CjVeILduq5lGaUCgOJRsAMAAAAAAACIiMs/eHm0z23vXy+atWi3n134wMJY8uySAXsTDp8Qc26YE1cvVrAjeyMnHRU33jo7OhffHq2trTXNWv7IpdmEAoACasw7AAAAAAAAAEDRvP/U98cF774g7xgAANTICXYAAAAAAAAAGZrVPitax7TGqlWr8o4CAECNFOwAAAAAAAAAajS48dd/el1wzYIolUo5pwEAICsKdgAAAAAAAAA1mj5lekyfMv1N3+vq7t7HaTgY+F0BwL6hYAcAAAAAAABQB0mSRHO5HFNnzsg7CgXVXC5HkiR5xwCAQlOwAwAAAAAAAKiDSqUSKzs6Ik3TvKNQUEmSRKVSyTsGABSagh0AAAAAAABAnVQqFQUoAIADWGPeAQAAAAAAAAAAAGB/5AQ7AAAAAAAAgDqpVquuiKVuXBELAPWnYAcAAAAAAABQoyd//mSsfWVtnHvGuf171Wo1Jra1RU9vb37BKLTmcjlWdnQo2QFAHSnYAQAAAAAAANTomeefiSXPLollq5bFDRffEBERaZpGT29vPHjL/Bjb0pJzQoqmq7s7ps6cEWmaKtgBQB0p2AEAAAAAAABkZHXX6rjqtqvizmvv7N8b29ISE0aPyTEVAAB7qzHvAAAAAAAAAABFsmnzprhk7iXx+uuv5x0FAIAaKdgBAAAAAAAAZKwv+mLe/fOiVC7lHQUAgBq4IhYAAAAAAAAgIq645YoB6/a57TXPPP9T58fT6QuuiCVz61asjtmnT4tlC++JzpIiJwDUi4IdAAAAAAAAQERs374985kNDQ3xk1c7431xQuazObht2bAxjht1ZGzoXBMb8g4DAAWmYAcAAAAAAAAQEYcdelisf219pjP7+vriIyMnZzoTIiKahg+NpSuWx4mTJ0epxhPs1nUtyygVABSPgh0AAAAAAABARMy/ev6Aa2EXzVq0288ufGBhLHl2yYC9hmiIxbMXx2WLT80sI/ynkZOOihtvnR2di2+P1tbWmmYtf+TSbEIBQAE15h0AAAAAAAAAoGiGDhkan/3YZ/OOAQBAjRTsAAAAAAAAADJ09BFHxx3X3pF3DAAAMuCKWAAAAAAAAICMnPOOc2LaO6flHQMAgIwo2AEAAAAAAADU6LTjT4sz3n5GtI1r2+m9ru7uHBJRdH5XALBvKNgBAAAAAAAA1OjY1mN32kuSJJrL5Zg6c0YOiTgYNJfLkSRJ3jEAoNAU7AAAAAAAAADqoFKpxMqOjkjTNO8oFFSSJFGpVPKOAQCFpmAHAAAAAAAAUCeVSkUBCgDgANaYdwAAAAAAAAAAAADYHznBDgAAAAAAAKBOqtWqK2KpG1fEAkD9KdgBAAAAAAAA1Ki3tzdKpVKUSqX+vWq1GhPb2qKntze/YBRac7kcKzs6lOwAoI4U7AAAAAAAAABqdN+P74slzy6J6y+8PtrGtUVERJqm0dPbGw/eMj/GtrTknJCi6erujqkzZ0Sapgp2AFBHCnYAAAAAAAAAGbnpKzfFlFOmxJRTpvTvjW1piQmjx+SYCgCAvdWYdwAAAAAAAACAInnosYfipi/flHcMAAAyoGAHAAAAAAAAkLGOtR1x27235R0DAIAauSIWAAAAAAAAICLm3D1nwLp9bntN8zZv3RwX/dlFNc0AACBfCnYAAAAAAAAAEfHSupcyn9k4qDHufvGx+PzoD2U+m4PbuhWrY/bp02LZwnuis1TKOw4AFJaCHQAAAAAAAECd9PX1xfim5rxjUEBbNmyM40YdGRs618SGvMMAQIEp2AEAAAAAAABExBc/9cW4ct6V/et518zb7We/8d1vxNJlS3faf+KhJ+JvL/9MJvngNzUNHxpLVyyPEydPjlKNJ9it61qWUSoAKB4FOwAAAAAAAICInUpK5VJ5t58dNGjQTnvt57TH4hsW1xoL3tTISUfFjbfOjs7Ft0dra2tNs5Y/cmk2oQCggBrzDgAAAAAAAABQNAuuWRBjymPyjgEAQI2cYAcAAAAAAACQkSFNQ+Ku6+7KOwYAABlRsAMAAAAAAACo0fhR46NrdFfMuWTOTu91dXfnkIii87sCgH1DwQ4AAAAAAACgRmefdHacfdLZA/aSJInmcjmmzpyRUyqKrrlcjiRJ8o4BAIWmYAcAAAAAAABQB5VKJVZ2dESapnlHoaCSJIlKpZJ3DAAoNAU7AAAAAAAAgDqpVCoKUAAAB7DGvAMAAAAAAAAAAADA/kjBDgAAAAAAAAAAAN6EK2IBAAAAAAAA6qRarUaapnnHoKCSJHEFMQDUmYIdAAAAAAAAQI3u+/598ei/Pxp3zbyrf69arcbEtrbo6e3NLxiF1lwux8qODiU7AKgjBTsAAAAAAACAGvVu7I3NWzdH+9z2WHDNgiiVSpGmafT09saDt8yPsS0teUekYLq6u2PqzBmRpqmCHQDUkYIdAAAAAAAAQIaunHdlzGqf1b8e29ISE0aPyTERAAB7qzHvAAAAAAAAAABFM3fR3Hj8mcfzjgEAQI2cYAcAAAAAAAAQEQ//5OEB68tvvny3n922bdtOe48+/WicecGZNecCACA/CnYAAAAAAAAAEXH/I/cPWG/dtrXmmeMmjouvvvhE3DD6gzXPgt+0bsXqmH36tFi28J7oLJXyjgMAhaVgBwAAAAAAAFBHm2N73hEooC0bNsZxo46MDZ1rYkPeYQCgwBTsAAAAAAAAACLi+EnHx9JlSzOduenVTXH1pLMynQkREU3Dh8bSFcvjxMmTo1TjCXbrupZllAoAikfBDgAAAAAAACAiLv/g5dE+t71/vWjWot1+duEDC2PJs0sG7E04fELMuWFOXL1YwY7sjZx0VNx46+zoXHx7tLa21jRr+SOXZhMKAAqoMe8AAAAAAAAAAEXz/lPfHxe8+4K8YwAAUCMn2AEAAAAAAABkaFb7rGgd0xqrVq3KOwoAADVSsAMAAAAAAACo0eDGX//pdcE1C6JUKuWcBgCArCjYAQAAAAAAANRo+pTpMX3K9Dd9r6u7ex+n4WDgdwUA+4aCHQAAAAAAAEAdJEkSzeVyTJ05I+8oFFRzuRxJkuQdAwAKTcEOAAAAAAAAoA4qlUqs7OiINE3zjkJBJUkSlUol7xgAUGgKdgAAAAAAAAB1UqlUFKAAAA5gjXkHAAAAAAAAAAAAgP2RE+wAAAAAAAAA6qRarboilrpxRSwA1J+CHQAAAAAAAECNnvz5k7H2lbVx7hnn9u9Vq9WY2NYWPb29+QWj0JrL5VjZ0aFkBwB1pGAHAAAAAAAAUKNnnn8mljy7JJatWhY3XHxDRESkaRo9vb3x4C3zY2xLS84JKZqu7u6YOnNGpGmqYAcAdaRgBwAAAAAAAJCR1V2r46rbroo7r72zf29sS0tMGD0mx1QAAOytxrwDAAAAAAAAABTJps2b4pK5l8Trr7+edxQAAGqkYAcAAAAAAACQsb7oi3n3z4tSuZR3FAAAauCKWAAAAAAAAICIuOKWKwas2+e21zzz/E+dH0+nL7gilsytW7E6Zp8+LZYtvCc6S4qcAFAvCnYAAAAAAAAAEbF9+/bMZzY0NMRPXu2M98UJmc/m4LZlw8Y4btSRsaFzTWzIOwwAFJiCHQAAAAAAAEBEHHboYbH+tfWZzuzr64uPjJyc6UyIiGgaPjSWrlgeJ06eHKUaT7Bb17Uso1QAUDwKdgAAAAAAAAARMf/q+QOuhV00a9FuP7vwgYWx5NklA/YaoiEWz14cly0+NbOM8J9GTjoqbrx1dnQuvj1aW1trmrX8kUuzCQUABdSYdwAAAAAAAACAohk6ZGh89mOfzTsGAAA1UrADAAAAAAAAyNDRRxwdd1x7R94xAADIgCtiAQAAAAAAADJyzjvOiWnvnJZ3DAAAMqJgBwAAAAAAAFCj044/Lc54+xnRNq5tp/e6urtzSETR+V0BwL6hYAcAAAAAAABQo2Nbj91pL0mSaC6XY+rMGTkk4mDQXC5HkiR5xwCAQlOwAwAAAAAAAKiDSqUSKzs6Ik3TvKNQUEmSRKVSyTsGABSagh0AAAAAAABAnVQqFQUoAIADWGPeAQAAAAAAAAAAAGB/5AQ7AAAAAAAA6q5arbomk7raX6/K9NunnvbX3z0AFImCHQAAAAAAAJnavGVLDGlq6l9Xq9U4uu2YSHvX55iKokvKI6Kz4/ncyka9vb1RKpWiVCr171Wr1ZjY1hY9vb25ZKL4msvlWNnRoWQHAHWkYAcAAAAAAECmPvbpK+OScz8aZ570zoiISNM00t71MelL50TTqGE5p6OItrz8Wqy44juRpmluRaP7fnxfLHl2SVx/4fXRNq4tIn792+/p7Y0Hb5kfY1tacslFcXV1d8fUmTNy/d0DwMFAwQ4AAAAAAIBMdfesj4//+dz40//ZGVeeP71/v2nUsBgydniOyaD+bvrKTTHllCkx5ZQp/XtjW1piwugxOaYCAGBvNeYdAAAAAAAAgOLZ0Rdx+9e+Hp/4i1mxY8eOvOPAPvXQYw/FTV++Ke8YAABkwAl2AAAAAAAA1M13H3syfrl6VTQMcu4DB5eOtR1x27235R0DAIAaKdgBAAAAAACwS21nnVHT88+t7opJZ54SsWF7xNiMQkEdzLl7zoB1+9z2muZt3ro5Lvqzi2qaAQBAvhTsAAAAAAAAqLstOxqj71s9MeRPhkVUDsk7DgVzwrJhccKN02Pu383NO8pOGgc1xt0vPhafH/2hvKNQMOtWrI7Zp0+LZQvvic5SKe84AFBYCnYAAAAAAADsE4dOLEVfeVA05B2EQmpo2D9/WX19fTG+qTnvGBTQlg0b47hRR8aGzjWxIe8wAFBgCnYAAAAAAADs0orvfG+PPv+uS86PX3Wt6183NkZsXL0qhl1yQgxubMw6HkTEr4tsWZfs5l0zb7c/+43vfiOWLlu60/4TDz0Rf3v5Z7KMBRER0TR8aCxdsTxOnDw5SjWeYLeua1lGqQCgeBTsAAAAAAAA2KXBg/f0T0r/t+RUGjI45vzJZfHhcz4QI+OEbIPB//HU216LZ869Nzo7O6O1tTWXDIMGDdppr/2c9lh8w+Ic0nAwGDnpqLjx1tnRufj2mn/3yx+5NJtQAFBACnYAAAAAAADUxcjysLhn3p3RuK0v7yiwzy24ZkG89NJLeccAAKBGzuAGAAAAAAAgc5Naj4gfLv77OGbcUXlHgX1qSNOQWDRrUc1XdgIAsH9wgh0AAAAAAACZuuxDH43z3j0lGhsHnvWw5eXXckpE0e0Pv63xo8ZH1+iumHPJnJ3e6+ruziERRed3BQD7hoIdAAAAAAAAmfrw2dMGrJMkiaQ8IlZc8Z18AnFQSMojIkmS3L7/7JPOjrNPOnvAXpIk0Vwux9SZM3JKRdE1l8u5/u4B4GCgYAcAAAAAAEBdVSqV6Ox4PtI0zTsKBZYkSVQqlbxjDFCpVGJlR4ffPnWzP/7uAaBoFOwAAAAAAACou0qlogTCQclvHwDgwNaYdwAAAAAAAAAAAADYHynYAQAAAAAAAAAAwJtwRSwAAAAAAAB1V61WI03TvGNQYEmSuIoVAIDMKdgBAAAAAACQqfuvfzDec927Ymjz0Ij4dblu4tEToyftyTkZRdacNMfKzpVKdgAAZErBDgAAAAAAgEwt/e6y+Jd7fhYz/+nSGPvWMZGmafSkPfHtIx+PsYPH5R2PAuratibev/bkSNNUwQ4AgEwp2AEAAAAAAJC59T2vx+dOXRBXfPkjkfzeYRERMXbwuBh/SGu+wQAAAPZAY94BAAAAAAAAKKbNm7fHFz/29fjp3yzNOwoAAMBecYIdAAAAAAAAu/Tgn//THn1+XdeG/tc7dkT88x3/Fu8beV7s6NuRdTQAAIC6UrADAAAAAABglx6Y/1jNM0Zua4vvbvuHuPiQT8SQhiEZpIL/a92gf4vZ4y6O/7j24Xi+VMo7DhxwGqIh7wgAsN9SsAMAAAAAAGCfeHX7xng9XoshoWBHtrY09sTvDT06Nvz85djwuz8OvNHYX/+Loh0A7EzBDgAAAAAAgF068pjmPfr82ud7dtrb1tQT5w75VIxoqGQVC/o17WiOf3/9pzH5xMlRcoId7LGeF17IOwIA7LcU7AAAAAAAANiluf/7uj36/PX/7eZ46Vfr+9f/4+yj4xP33BxXHvXprKNBRESM3P72uHHNedF526xobW3NOw4ccJ477Ym8IwDAfqsx7wAAAAAAAAAUU2NjxIdvOCPed9OZeUcBAADYKwp2AAAAAAAAZG7IkMb4xNf+3zhrxh/lHQUAAGCvuSIWAAAAAACATE34r2PiE/ddGGPfOibvKAAAADVRsAMAAAAAACBTl3/9wjfd79q2Zt8G4aDhtwUAQL0o2AEAAAAAAFBXSZJEc9Ic7197ct5RKLDmpDmSJMk7BgAABaNgBwAAAAAAQF1VKpVY2bky0jTNOwoFliRJVCqVvGMAAFAwCnYAAAAAAADUXaVSUX4CAAAOOI15BwAAAAAAAAAAAID9kRPsAAAAAAAAqLtqteqKWOrKFbEAANSDgh0AAAAAAACZWvmvHTHxpLb+dbVajYlHT4yetCfHVBRdc9IcKztXKtkBAJApBTsAAAAAAAAy9TeXfzPG/5cxcenfXhCNjY2Rpmn0pD3x7SMfj7GDx+UdjwLq2rYm3r/25EjTVMEOAIBMKdgBAAAAAACQqb6+iCXfXREvv+P2uO77H+/fHzt4XIw/pDW/YAAAAHuoMe8AAAAAAAAAFNOqZd3x2eNvjZ5f9eYdBQAAYK8o2AEAAAAAAFA3Pes2xd0fuj8mDj027ygAAAB7zBWxAAAAAAAA7NJF5etren7z69vjlCEfiP/o+1mMj9ZsQsFvWDfo32L2uIvjP659OJ4vlfKOAwBAgSjYAQAAAAAAUHc7dkQ8sWFJvL1yUoxsGJV3HApmS2NP/N7Qo2PDz1+ODXmHgQPR2LwDAMD+S8EOAAAAAACAuhs0uC/eO+ws5TrqomlHc/z76z+NySdOjpIT7GCP9bzwQt4RAGC/pWAHAAAAAADALn2596Y9+vz1/+3meOlX6/vXI0YOia/96s645LDLso4GERExcvvb48Y150XnbbOitbU17zhwwHnutCfyjgAA+63GvAMAAAAAAABQXK2/d3hc/tD50bOtmncUAACAPaZgBwAAAAAAQF2c+L63xQ3/8skYMqwp7ygAAAB7xRWxAAAAAAAAZKqpNCg++OnT4pxPvzvvKAAAADVRsAMAAAAAACBTVz9wSZSPKO+037Vtzb4Pw0HBbwsAgHpRsAMAAAAAACBTbyzXJUkSzUlzvH/tyfkE4qDQnDRHkiR5xwAAoGAU7AAAAAAAAKirSqUSKztXRpqmeUehwJIkiUqlkncMAAAKRsEOAAAAAACAuqtUKspPAADAAacx7wAAAAAAAAAAAACwP3KCHQAAAAAAAHVXrVZdEUtduSIWAIB6ULADAAAAAAAgU1tf3xqHlA7pX1er1Zh49MToSXtyTEXRNSfNsbJzpZIdAACZUrADAAAAAAAgU/Pf+/+Ld//pqfH7U/5bRESkaRo9aU98+8jHY+zgcTmno4i6tq2J9689OdI0VbADACBTCnYAAAAAAABkav0rr8WCC78RH5j5Urx35pn9+2MHj4vxh7TmFwwAAGAPNeYdAAAAAAAAgOLZsSPi/pt+FAv/+GuxY8eOvOMAAADsFSfYAQAAAAAAUDdPPrgs1ix/KQ5pOCTvKAAAAHtMwQ4AAAAAAIBduqh8fU3Pv7CiJ/5ny1Wxoa83m0AAAAD7iIIdAAAAAAAAdbdjS1Pcv+P++PghR8TIhlF5x6Fg1g36t5g97uL4j2sfjudLpbzjAABQIAp2AAAAAAAA7BNvGdoazdGSdwwKaEtjT/z/27vz6Kjqu3/gn0yAhCVDEhBUUAJSRaytW8VqVdzaute6+1jFR6uirdoqWq1rrbtPXdo+tVZrq9VaV2xFu7igVi2KaytqBYIIogIJTNgCWX5/+GseByISMpM7JK/XOT2H73fuvbw959tLMvOe7x3Za2jUvf5R1CUdBtZFGyQdAAAKl4IdAAAAAAAAq3XLvB+36fjzt7k6PpiZaRmnUhFTmv4eJ6dOilRRKtfxIHo0VcQryybFqB1GRakd7KDNat97L+kIAFCwFOwAAAAAAABYreJuxW08o6jlTyUlxXHYtXvGHsdcGVGe01jQol/jdvGjWYdG9TXnR1VVVdJxYJ3z79HPJh0BAAqWgh0AAAAAAAB5Ud6vNH7w6NhY2mNJ0lEAAADWij24AQAAAAAAyLkhm/WLy18+OwZuOiDpKAAAAGvNDnYAAAAAAADk1D7f2zV2OnZUpFLZez3MaZiVUCI6O2sLAIB8UbADAAAAAAAgp3Y+7stZ43Q6HRXpijho9s4JJaIrqEhXRDqdTjoGAACdjIIdAAAAAAAAeVVZWRlTq6dGJpNJOgqdWDqdjsrKyqRjAADQySjYAQAAAAAAkHeVlZXKTwAAwDonlXQAAAAAAAAAAAAAKEQKdgAAAAAAAAAAANAKj4gFAAAAAAAg72pqaiKTySQdg04snU57DDEAADmnYAcAAAAAAEBO3XfuQ7HP2XtFr4peEfFxuW740OFRm6lNOBmdWUW6IqZWT1WyAwAgpxTsAAAAAAAAyKmXJrwZf7/71Tjn0ZNigxHrRyaTidpMbTw46JnYoNvgpOPRCc1pmBUHzd45MpmMgh0AADmlYAcAAAAAAEDOLaxdFpfs+rM45bYjIj2yT0REbNBtcGzUvSrZYAAAAG2QSjoAAAAAAAAAnVN9fWPccPSdMenXLyUdBQAAYK3YwQ4AAAAAAIDVeujSR9t0/Pw5dS1/bmqK+PONk2P/fodGU3NTrqMBAADklYIdAAAAAAAAqzX+f55u9zX6NWwSExruj+O7nxYlRSU5SAX/Z37x5Lhw8PExZdzfYnppadJxAADoRBTsAAAAAAAA6BCLGpfEslgcJaFgR24tT9XGyF5Do+71j6Lusw8HVrZB0gEAoHAp2AEAAAAAALBag4ZVtOn42dNrV5lr6FEbh5R8P/oWVeYqFrTo0VQRryybFKN2GBWldrCDNqt9772kIwBAwVKwAwAAAAAAYLV+/PLZbTr+3C9cGR/MXNgy3mbvoXHa3VfGd4b8INfRICIi+jVuFz+adWhUX3N+VFVVJR0H1jn/Hv1s0hEAoGClkg4AAAAAAABA55RKRRx+wR6x/xVfTToKAADAWlGwAwAAAAAAIOdKSlJx2u3/FV8/c8+kowAAAKw1j4gFAAAAAAAgpzbecv047Z4xscGI9ZOOAgAA0C4KdgAAAAAAAOTU2DvHtDo/p2FWxwahy7C2AADIFwU7AAAAAAAA8iqdTkdFuiIOmr1z0lHoxCrSFZFOp5OOAQBAJ6NgBwAAAAAAQF5VVlbG1Oqpkclkko5CJ5ZOp6OysjLpGAAAdDIKdgAAAAAAAORdZWWl8hMAALDOSSUdAAAAAAAAAAAAAAqRHewAAAAAAADIu5qaGo+IJa88IhYAgHxQsAMAAAAAACCnpj43LYbvuEnLuKamJoYPHR61mdoEU9HZVaQrYmr1VCU7AABySsEOAAAAAACAnPr12Htjo8+vHyfdcUykUqnIZDJRm6mNBwc9Ext0G5x0PDqhOQ2z4qDZO0cmk1GwAwAgpxTsAAAAAAAAyKnm5ogXJrwdH+10XZz911Nb5jfoNjg26l6VXDAAAIA2SiUdAAAAAAAAgM5pxpvz4odbXR21MxckHQUAAGCtKNgBAAAAAACQN7Xzl8YvD7svhvfaNOkoAAAAbeYRsQAAAAAAAKzWceXntuv8+mWNsUvJN2NK86uxUVTlJhR8wvziyXHh4ONjyri/xfTS0qTjAADQiSjYAQAAAAAAkHdNTRHP1r0Q21XuGP2KBiQdh05meao2RvYaGnWvfxR1SYeBddEGSQcAgMKlYAcAAAAAAEDeFXdrjn17f125jrzo0VQRryybFKN2GBWldrCDNqt9772kIwBAwVKwAwAAAAAAYLVuW3BFm44/9wtXxgczF7aM+/Yridtn/jS+3efkXEeDiIjo17hd/GjWoVF9zflRVVWVdBxY5/x79LNJRwCAgpVKOgAAAAAAAACdV9XI9WLsH4+K2oaapKMAAAC0mYIdAAAAAAAAebHD/pvHBX8/I0p690g6CgAAwFrxiFgAAAAAAAByqkdpcRz8g9Gx3w++lnQUAACAdlGwAwAAAAAAIKe+N/7bUb5h+SrzcxpmdXwYugRrCwCAfFGwAwAAAAAAIKdWLtel0+moSFfEQbN3TiYQXUJFuiLS6XTSMQAA6GQU7AAAAAAAAMirysrKmFo9NTKZTNJR6MTS6XRUVlYmHQMAgE5GwQ4AAAAAAIC8q6ysVH4CAADWOamkAwAAAAAAAAAAAEAhsoMdAAAAAAAAeVdTU+MRseSVR8QCAJAPCnYAAAAAAADk1IplK6J7afeWcU1NTQwfOjxqM7UJpqKzq0hXxNTqqUp2AADklIIdAAAAAAAAOfU/+94UXzt919j6gC9EREQmk4naTG08OOiZ2KDb4ITT0RnNaZgVB83eOTKZjIIdAAA5pWAHAAAAAABATi2cuzh+Nub38c1zPoh9z/lqy/wG3QbHRt2rkgsGAADQRqmkAwAAAAAAAND5NDVF3HfFk3HzsbdHU1NT0nEAAADWih3sAAAAAAAAyJvnH3ozZr31QXQv6p50FAAAgDZTsAMAAAAAAGC1jis/t13nv/d2bXyr/3ejrnlBbgIBAAB0EAU7AAAAAAAA8q5peY+4r+m+OLX7htGvaEDScehk5hdPjgsHHx9Txv0tppeWJh0HAIBORMEOAAAAAACADvG5XlVREf2TjkEntDxVGyN7DY261z+KuqTDwLpog6QDAEDhUrADAAAAAABgtW6Z9+M2HX/+NlfHBzMzLeNUKmJK09/j5NRJkSpK5ToeRI+minhl2aQYtcOoKLWDHbRZ7XvvJR0BAAqWgh0AAAAAAACrVdytuI1nFLX8qaSkOA67ds/Y45grI8pzGgta9GvcLn4069Covub8qKqqSjoOrHP+PfrZpCMAQMFSsAMAAAAAACAvyvuVxg8eHRtLeyxJOgoAAMBasQc3AAAAAAAAOTdks35x+ctnx8BNByQdBQAAYK3ZwQ4AAAAAAICc2ud7u8ZOx46KVCp7r4c5DbMSSkRnZ20BAJAvCnYAAAAAAADk1M7HfTlrnE6noyJdEQfN3jmhRHQFFemKSKfTSccAAKCTUbADAAAAAAAgryorK2Nq9dTIZDJJR6ETS6fTUVlZmXQMAAA6GQU7AAAAAAAA8q6yslL5CQAAWOekkg4AAAAAAAAAAAAAhUjBDgAAAAAAAAAAAFrhEbEAAAAAAADkXU1NTWQymaRj0Iml0+mCfAyxtU8+Feq6B4DORMEOAAAAAACAnLrv3Idin7P3il4VvSLi44LR8KHDozZTm3AyOrOKdEVMrZ6aWNlo6dz6mPtybWz8tfVb5qx98i3pdQ8AXYGCHQAAAAAAADn10oQ34+93vxrnPHpSbDBi/chkMlGbqY0HBz0TG3QbnHQ8OqE5DbPioNk7RyaTSaxo1FjfGE/+94ux7fkjY4uTh0VRUZG1T14VwroHgK5AwQ4AAAAAAICcW1i7LC7Z9Wdxym1HRHpkn4iI2KDb4Nioe1WywSCfmiNeunRKZKYuilFXbNkybe0DAKy7UkkHAAAAAAAAoHOqr2+MG46+Myb9+qWko0CHeuf3M+NvR/4jVixsSDoKAADtZAc7AAAAAAAAVuuhSx9t0/Hz59S1/LmpKeLPN06O/fsdGk3NTbmOBjlVv2B5LJ69NDLTF7f53KUfLssaf/j8/Mh8uy7WLx6Uq3gAACRAwQ4AAAAAAIDVGv8/T7f7Gv0aNokJDffH8d1Pi5Kikhykgv/zXuqpuGXoj+OFA/8Uk1Nr/xCvphVN0bi0ca3P79Eze9w4P+KaId+L2UV/jtqi3mt9XWjNoh5z49ZNfhiTv3lPvNyOdR8REX1ykwkAOiMFOwAAAAAAADrEosYlsSwWR0ko2JFbjalM9CmOaF6WibWvx30sleNPUFMRsSKWxcKYn9sLQ0T0Lu4ZjYtXtHvdK9gBwKdTsAMAAAAAAGC1Bg2raNPxs6fXrjLX0KM2Din5fvQtqsxVLGhR3JSOhU2ZKCtLR6odO3k1NzdHc0NzNDc0RVFxUXTrveYfpzY1NMeKhStWChYxs746Nuvx+SgtKl3rXNCaRTE3Mk01kU63b90DAKunYAcAAAAAAMBq/fjls9t0/LlfuDI+mLmwZbzN3kPjtLuvjO8M+UGuo0FERGzUtGsc+u7QqK6ujqqqqkQyLJq1JO7f/vGWcVlVrxhx+aA4arfN4x9DqmOj7snkovN6b8WM2CFH6/6m0SfnJhQAdEJq7AAAAAAAAORFKhVx+AV7xP5XfDXpKNChBu5QGfs8vHP0qrJrHQDAuk7BDgAAAAAAgJwrKUnFabf/V3z9zD2TjgIdavgRG8Ved385Sit7JB0FAIAc8IhYAAAAAAAAcmrjLdeP0+4ZExuMWD/pKNBhilJFse35m8cWYzeJoqKipOMAAJAjCnYAAAAAAADk1Ng7x7Q6P6dhVscGocsohLXVe8Oe8flThrf6WiHko/OxrgCgYyjYAQAAAAAAkFfpdDoq0hVx0Oydk45CJ1aRroh0Op10jCzWPvlWiOseADobBTsAAAAAAADyqrKyMqZWT41MJpN0FDqxdDodlZWVScfIYu2Tb4W47gGgs1GwAwAAAAAAIO8qKyuVQOiSrH0AgHVbKukAAAAAAAAAAAAAUIjsYAcAAAAAAEDe1dTUeEwmeeVRmQAA5IOCHQAAAAAAADn10j//EdtuuUPLuKamJoZuUhWZBXUJpqKzS5eXRfW0GUp2AADklIIdAAAAAAAAOXXe1WfGZptsFtdfeEukUqnIZDKRWVAX213TM0r6FyUdj06ofl5zTB5XF5lMRsEOAICcUrADAAAAAAAgp5oj4q/PPB0HnbRX3HX9Qy3zJf2LoufAVHLB6MSakg4AAEAn5TcYAAAAAAAA8uLt6e/G147dOWZ/ODPpKAAAAGtFwQ4AAAAAAIC8mVdbF6decmJUbtA76SgAAABt5hGxAAAAAAAArNaIPYa36/xl9Q0xcOT60fzO4oiBi3KUCv7PRm/1j0N27x73/eqHUVpamnQcWOd0i+5JRwCAgqVgBwAAAAAAQN41NUcseLF3lH5+aaTKG5OOQyfTq64k0gN7xezqN5KOAuukzWKHpCMAQMFSsAMAAAAAACDvuhVHlO9Rq1xHXiwpq4/MW00xaodRdrCDtfF+0gEAoHAp2AEAAAAAALBabz0+tU3Hf/VbO8XM9z9sGfcr7xMv/3VKbHtU94hI5TgdRLw3Yl48e9WSuObWx6KqqirpOLDOuenxk5OOAAAFy28wAAAAAAAA5M3mmwyNW358ZyxbtCLpKAAAAG2mYAcAAAAAAEBe7L3rbnH/TX+Jnj17Jx0FAABgrXhELAAAAAAAADlV0qNHnDbm5DjlW2clHQUAAKBdFOwAAAAAAADIqVuuujMG9t9wlfn6ec0R0dTxgej0Pl5bAACQewp2AAAAAAAA5NTK5bp0Oh3p8rKYPK4uoUR0Benyskin00nHAACgk1GwAwAAAAAAIK8qKyujetqMyGQySUehE0un01FZWZl0DAAAOhkFOwAAAAAAAPKusrJS+QkAAFjnpJIOAAAAAAAAAAAAAIXIDnYAAAAAAADkXU1NjUfEklceEQsAQD4o2AEAAAAAAJBT9cuXRUmP0pZxTU1NDN2kKjIL6hJMRWeXLi+L6mkzlOwAAMgpBTsAAAAAAAByasyZh8Z/H35S7PWV/SIiIpPJRGZBXWx3Tc8o6V+UcDo6o/p5zTF5XF1kMhkFOwAAckrBDgAAAAAAgJyav6AmTr/4jPjumLdj7NFntsyX9C+KngNTCSaj82pKOgAAAJ2U32AAAAAAAADIuabmiBtu+0V8/9ITo6lJ+QkAAFg32cEOAAAAAACAvHlk4hPxzox3IlXs0bAAAMC6R8EOAAAAAACA1Rqxx/B2nf/OjPdii92HRiyaGzGwOUepAAAA8k/BDgAAAAAAgLxb3lgUmQkDouSYeZEqb0w6Dp3MRm/1j0N27x73/eqHUVpamnQcWOd0i+5JRwCAgqVgBwAAAAAAQIfoM3R5FKWV68i9XnUlkR7YK2ZXv5F0FFgnbRY7JB0BAAqWgh0AAAAAAACr9a+/vNWm4/cZs0vMnPNRyziVKoq6WbXR/1tLoyiVynU8iCVl9ZF5qylG7TDKDnawNt5POgAAFC4FOwAAAAAAAFarW7c2fqRUVNTyx9KSbnH+2Avi0AOOjiHRK8fJ4GPvjZgXz161JK659bGoqqpKOg6sc256/OSkIwBAwVKwAwAAAAAAIC/6VZTF7667J4oauycdBQAAYK3YgxsAAAAAAICc23ToxvHn3z4VQzf6XNJRAAAA1pod7AAAAAAAAMipbx9xUhy899GRSmXv9VA/rzkimpIJRaf28doCAIDcU7ADAAAAAAAgpw7d95iscTqdjnR5WUweV5dQIrqCdHlZpNPppGMAANDJKNgBAAAAAACQV5WVlVE9bUZkMpmko9CJpdPpqKysTDoGAACdjIIdAAAAAAAAeVdZWan8BAAArHNSSQcAAAAAAAAAAACAQqRgBwAAAAAAAAAAAK3wiFgAAAAAAADyrqamJjKZTNIx6MTS6bTHEAMAkHMKdgAAAAAAAOTUVTddGGP/6/uRLiuPiI/LdUM3qYrMgrpkg9GppcvLonraDCU7AABySsEOAAAAAACAnHr82cfjob/+Me74yR9ik6rNIpPJRGZBXWx3Tc8o6V+UdDw6ofp5zTF5XF1kMhkFOwAAckrBDgAAAAAAgJyrWbgoDh57YFx34Q0xdIPNIiKipH9R9ByYSjgZnVNT0gEAAOik/AYDAAAAAABAXixb3hCnXviduO/PtycdBQAAYK3YwQ4AAAAAAIDVuvG2K9t0/Adz57X8uampOW659/bYdNSG0dy0IMfJAAAA8kvBDgAAAAAAgNX639/d0u5rFPXuGSseL4nmw+dGUfcchIJP2Oit/nHI7t3jvl/9MEpLS5OOA+ucbuHGDACfRsEOAAAAAACADtGwOBWxtDiie2PSUehketWVRHpgr5hd/UbSUWCdtFnskHQEAChYCnYAAAAAAACs1rCNNmzT8dPfe3+Vue7NDdFz37lRlE7lKha0WFJWH5m3mmLUDqPsYAdrY9XbNgDw/ynYAQAAAAAAsFqP/ObpNh3/1W/tFDPf/7BlvOeXvxI/v+y3sdMxvXIdDSIi4r0R8+LZq5bENbc+FlVVVUnHgXXOTY+fnHQEAChYviIEAAAAAABAXqRSEWee8J0464SLk44CAACwVuxgBwAAAAAAQM6V9OgW111wXey+494xY8aMpOMAAACsFQU7AAAAAAAAcmrEJpvFLy49Jzap2izpKAAAAO2iYAcAAAAAAEBO3Xjxr1udr5/XHBFNHRuGLuHjtQUAALmnYAcAAAAAAEBepdPpSJeXxeRxdUlHoRNLl5dFOp1OOgYAAJ2Mgh0AAAAAAAB5VVlZGdXTZkQmk0k6Cp1YOp2OysrKpGMAANDJKNgBAAAAAACQd5WVlcpPAADAOieVdAAAAAAAAAAAAAAoRHawAwAAAAAAAACAdqqpqYlMJpN0DDqxdDptV+gEKNgBAAAAAAAAAEAbvDZ5anxxu+Et45qamqiqGh51dbUJpqKzKyuriBkzpirZdTAFOwAAAAAAAAAAaINrvnVzHHTePnHwt0ZHREQmk4m6utpIr3dbpIoHJhuOTqmp8cPIzD0uMpmMgl0HU7ADAAAAAAAAAIA2KGpojocumRAz3p4TZ/74yJb5VPHAKO42KMFkQK6lkg4AAAAAAAAAAADrmqKIeP3ul+PMI66PFSsako4D5ImCHQAAAAAAAAAArKV5k2fH5f99R5R075N0FCAPPCIWAAAAAAAAAIAu5ZnHXo/rz/pdFK9ojqbiiN5L2nb+yjtaNc1ZEvsPOyEmLV0QS5o8IhY6EzvYAQAAAAAAAADQpSxdvCyKVzRHz/qIVGNurtmroVts0+efEdGUmwsCBUHBDgAAAAAAAACALqXfwL5RlCrK6TVrui+JZxd8KdRxoHPxiFgAAAAAAAAAALqUbXfYLHr2KY3mpUujV7pn/Ob5H7Xp/G99blykmv9v3HerAXHH/T+IvuvvF8X6ddCp+L80AAAAAAAAAACsheaI2OqobeP71x4azR4NC52Sgh0AAAAAAAAAALRRY3HENy/ZP773oyOSjgLkkUfEAgAAAAAAAABAW/TpHt/7xbGx7Q6bJZ0EyDMFOwAAAAAAAAAAaIOfPHp2rLd++SrzTY0fdnwYugRrKzkKdgAAAAAAAAAA0AYrl+vS6XSUlVVEZu5xyQSiSygrq4h0Op10jC5HwQ4AAAAAAAAAANqhsrIyZsyYGplMJukodGLpdDoqKyuTjtHlKNgBAAAAAAAAAEA7VVZWKj9BJ5RKOgAAAAAAAAAAAAAUIjvYAQAAAACJqamp8fgc8qpQH59j7ZNP1j1dVaGufeiq3PfJp0K951v35Fuhrv3OTsEOAAAAAOgQDY2N0a24uGVcU1MTQ6uGRqbOhw/kT7osHdUzqhP7AKKhoSG6dct+K97aJ9+SXvcRq659656OUAhrH7qiZ2+6L3Y6+ZCsuZqamhg+dFjUZhYmlIrOriLdN6ZWT0/0nt/Y0BjF3bJ/x62qGh51dbWJZaLzKyuriBkzpvp5p4Mp2AEAAAAAHeKyq6+Pk48/JgYOWC8iIjKZTGTqMrFJjz2je/RMOB2d0YpYGtPqHotMJpPYhw+Tnn4tXnjmtTjjwuOiqKgoIqx98qsQ1n1ExI/O/FkcPmaf2GLrTSPCuif/CmXtQ1f02P/eH8/+6uE4+6XftMxlMpmozSyMiaOOicGlZcmFo1OatawuRk+6PfF7/g1jfxsnXXtE9O7bKyI+Xvd1dbWRXu+2SBUPTCwXnVdT44eRmXtc4mu/K1KwAwAAAAA6xDvTp8eJp50Vl198XmwxYrOW+e7RM3qk+iSYjE6rKekAH7vxst/G9H+/F9fc8oMo7VnSMm/tkxcFsu7nvPdRHLrbd+P6354fXz1w55Z56568KZC1D11RY1NzVH80Ny7d6r/i0LsviBEjRrS8Nri0LKp6lScXDvJoyrPvxI8O+Vl871fHxfpV67XMp4oHRnG3QQkmA3ItlXQAAAAAAKDrqKldEKeNOz8en/hM0lGgQz187xNxxJ6nx9wP5icdBTrM0iXL4uTDLoibrr0rmpubk44DQJ69P39B/O7gC+Px//lt0lGgw3xQPTd+dPBP481/TEs6CpBHdrADAAAAADrU8uXL4+Irro1v7r930lGgQ7324pvxjZ1Ojkt+9t2ko0CHaW5ujqvO+2W89tKUiChKOg4AeTY/szj+/MuHouqRF5OOAh1m8cKlcc2Ym2Pf03dNOgqQJwp2AAAAAMAaWbpsWdz5h/vjHy++FG+/0/5v5z/wp0dj0y23iXgnB+Egj5594qWYOf39iIiY9PSrMbTH2n9w9v57H8V3j/xx9CyqzFU86BDtWfcREX++/5lYv3jLaG72HE+AQjd2o33bdf6ipfXxTvV7cf22x+coEeRHzZwFsaJ+RXSLiCWZpXHs8HFrfa3Ghqb44/88Gdv22zWmhZ17obNRsAMAAAAA1siyZfXx27vuyek1B2wwOFb0ao6lrzdHNNvZiNzqt1597Faye5xx0PeiKJVa6+ssX1YfqWiM4uLcrNFlS+pjQPEW0dC8PHrk5Irwf5aPXhzDYvfY46TCKzWUpspjeSyO7s29I1VUnHQcOpnhfZpi0+JRcdd3r4/S0tKk48A65/3ZH0VERM+S7jm5Xv2Khnhn7ofxpxgY3+2Vk0tCi5s/LIkjqr4Tlx/4q0i14+f8psamKF7SEBER3Rtyk22L8i9FecMb8WrjoLB7L3QeCnYAAAAAQGIaGxti6XvFynXkRWlpUfTpVRLRWB/NjWt/ne7FEf/5cKyxKTe7UdQ3Z6K0KJ2Ta8EqCvSW2tzcHN2KekRRrP0H4fBp+nRrjvIe/eK9V22NC4WioqxXDCsq0H+UWKfVNhRFj+LSqF+8vN3X+s8KLcrRpnNLG5dE9YrBESlrHzoTBTsAAAAAYI2U903HVltuEa/+843Yasst4oarf9ym84858bvx7nuzWsYV5X3jiUcfio3qd40euhbkwbJlzdHUXB/pdLpdO9jF/3/EU1FRKr602xfj8V/9cI3PfPaJl+KYfc7KmvvqN3aKm++9MsqLN25HJliNHD+VrNuyiDeXPdmmc048+Ifx+ITnWsa9epdG9cIXY0j3r0SRsgV5sKihKJY0z4tRo3awgx2shfdf/XdEfLyD3Qk/PbtN59511vUxd2Fd1tzg/hVx/qt3xtRdT81ZRviPim7NMXNZfZSl0+3awS4iYumy5dHQ2BQ9BvWJWx+/oE3nfnuL86Jhxf99k2dAVWX84qmbo3v//aLY77jQqSjYAQAAAABrpKioKOI/pYiiorZ/kPGJPsVmn9skTj3h2PjTPXeEZ2SSL/PnlsRby/8a1dXVUVVVlUiGlf9/Mu7Sb8feh+0UN997RSJ56Px6TOwdby3/U6LrPiKySnSDhqwfl/78u7H713ZOLA+d39RFqXhr+aS44ad3J7r2oUv6xHcJilNFMaT/enHo/RfF+UPvTC4TndqJA+tj+FM/z8nPOyeed3O88a/q2ObzG7T5d9xP/rzzhV1HxL7f3zmu/fx5Ud6uREAh0pkFAAAAADrU6J13jJ9de0VUlPdNOgp0mNKeJfG/d/8oTjnnaLt30aVs++XPx/hnb4qhmw5OOgoAedaje7cYvt4GMe6l25KOAh1qr2O/Emf8ckyU9vbtMeis7GAHAAAAAHSYY448NI4/5qh2P8YH1iUDN+wfv3rg8thym82SjgId6sAj94qrfjkuSkpLYtGMhUnHASCPepeWRNUGG8R3nv550lGgw6S6peKYHx4Ue/zXjklHAfJMwQ4AAAAA6BBnfndsbP2Fz68yvyKWRjQlEIhOb0UsTTpCDNp4YIx/9qZYf9B6q7xm7ZMPhbDuIyKOP+OwGLXzF1fZsdG6J18KZe1DV9S3tFfsdPgu8bULTlnltVnL6hJIRGdXKOvqezf/d2y+wyarzDc1fphAGroCays5CnYAAAAAQIdYuVyXTqcjXZaOaXWPJZSIriBdlo50Op3Y3181fNXHYlr75FvS6z4iYoddtsoaW/d0hEJY+9AVnTn516vMpdPpqEj3jdGTbk8gEV1BRbpv4vf8lct16XQ6ysoqIjP3uIQS0RWUlVUkvva7IgU7AAAAACARlZWVUT2jOjKZTNJR6MTS6XRUVlYmHSOLtU++Wfd0VYW49qGrqqysjKnV0933yZtCvOdXVlbGjBlTrXvyqhDXflegYAcAAAAAJKaystIbw3RJ1j5dkXUP0LW479MVWffQOSnYJWTatGnxwgsvxKxZs2L58uVRUVERI0aMiB133DFKS0uTjgcAAAAAAAAAANDlKdh1sPHjx8ell14aL7/8cquv9+nTJ8aMGRMXXXRR9O/fv4PTAQAAAAAAAAAA8B8Kdh2kvr4+jj/++LjzzjtXe9yiRYviZz/7WfzhD3+I++67L3bZZZcOSrjuqqmp8Qxz8qZQn19u3ZNv1j5dUaGu+whrn/wq5LUPXZF7PvlUqPd86558K9S1DwAAAKwbFOw6QFNTUxx++OHx0EMPZc0XFxfHxhtvHH379o3q6upYuHBhy2tz586NvffeOx577LH48pe/3NGR1xk1NTVRVTU86upqk45CJ1VWVhEzZkxN9E3Y+//wdOx34A5RUtojIj5e90OrhkamzocP5E+6LB3VM6oTW/tzP/gw3v7nG/GVvXZvmbP2ybek131ExBMPPxrb7vTl6FtR3jJn7ZNvhbD2oSv60rn7RWO35nj50gktczU1NTFsk2GxcMHC1ZwJa69ved+YPm16ovf88X99MQ7Yc9tIpVIR4b0dOkYhvL8DAAAArLsU7DrANddcs0q57uSTT44LLrggNtxww4j4uIT30EMPxRlnnBEzZ86MiIglS5bEYYcdFv/617+ib9++HZ57XZDJZKKurjbS690WqeKBScehk2lq/DAyc4+LTCaT6BuwEx76R/z+9ifipt98L/qv1zcymUxk6jLx5Q2HR2lx98Ry0Xkta1wRz78/NdG1X19fH2cee2KcftG5ceSJ/x1FRUXWPnlVCOs+IuLVFybHzy+/Jn5yxy0xZJNhERHWPnlVKGsfuqJuy5qi/L2lsd15+8Xkyx+OiI/v+QsXLIzjfnpipNfzPgC5lZm7MG777s2J3/PvfOjv8ffJb8Wl3z88epb28N4OeVco7+8AAAAA6y4FuzybP39+XHbZZVlzV1xxRfzgBz/ImkulUnHQQQfF9ttvH1/5yldixowZERExa9as+MlPfhKXXHJJR0VeJ6WKB0Zxt0FJx4C8eenFf8dBe18Yt9xxVpT0/HiutLh79OpekmwwyKOmpqa47qLLYsbU6XH25Re3zFv7dHYzp8+I4/b5Zlx5y89j+513apm39gE6n+KG5uj35qLY4ax94x/X/t9Odun1+kbFBhUJJoP8mviPKXHCD34ZPzn/mJY57+0AAAAAUKhSSQfo7K6++uqoq6trGe+yyy5xzjnnfOrxgwYNiltuuSVr7rrrrov58+fnLSOwbpg1c24csu/FMem5t5OOAh3qwTt+H989ckwsytR99sHQSdQtzMRpRx4XD9zx+6SjAJBnRc0R5VMXx1dO3Tsee+pvSceBDvP29Pfj2LN+HlNnzk06CgAAAACslh3s8qipqSluu+22rLmLL744ioqKVnveHnvsETvvvHM888wzERFRV1cX99xzT4wdOzZvWYH8+vdbs+KDOTVRV7ekzee+9sq0lj8vWrQ0zvv+7VHWc9Nobs5lQsi9hbULYunixRERUTtvfjz2x0fW+NwP338/azz578/HeSecGiXFfnRh3dKWdR8R8eqkyS1/bmxoiCvG/TD2PeKQXMcCIEe2vmCfiLKeLeNR4/Zd43NLFzZkjfvMXhp3PHVvfPGMr+QsH+RDQ2NjLF22PCIiahcuisf+/s82nV/93kctf55XUxcX3vDHKN9gswi/4wIAAABQoIqam1U08uXvf/977Lzzzi3jYcOGxdSpUz+zYBcR8dvf/jbGjBnTMv7qV78af/nLX/IR8zO98cYb8fnPf75l/K9//Su22GKLRLKsbMaMGTF06NAoX/8RjxEh53osHx/N9U/FqB12iNLS0nZd68V/vBVNTbm93ZYVz4uNes6NNbilQJsULy6L4sYeUZZORyq19pvdNixfEbEsoji6xeKoixlFU9udraGpMcp6lEa6pFe7rwWf1DB6/Zxer6ioKJqbm2P+hNzsOrqgfkkM7lMRvXu0798jWFn9wO6xMLU8Ro0a1e6fd6ArevXt16OhV3FERDT07ha95yxr9zVX9C6OmqE94htf3aXd14JP+ssNc2L5sqLoVlwc7fpFsrk5GpsaoyiaozmKozmVm38/VtSXROPydET4JZfcam6uj4bl/4xRO/h5BwAAWNW/q+fEosXLYpvPD42bLz8x6TiwzinkTlEu2QYmjyZMmJA13muvvdaoXPefYz9p4sSJsXjx4ujdu3fO8gGrV9xcG916DIzXXq5OOkqrVjSXRFOkojiako5CJ1PS3DN6pfpELIpobsc2EsWf+DGjKUfrNFWUiibfDSBP1vTntCT0SHWzqQt5UdSzW1SW9Yp3pnkEPayN4ogozjR85nFtkVrRFKnm4pxeEyIiGlYURxSXRkNE+3eLS+V+w7nuJfXRvcTjYsmXjWPK1DlJhwAAAApY754lSUcACpiCXR69+uqrWeMdd9xxjc/dcMMNo6qqKmbMmBEREcuXL48pU6bEl770pRwmBFansagiGupfz8kOdjXzM7F40bLo3qNbjPz8kDad++ifXlhlrm7pO1FVvjiKi/ygR+7VFy2NhsbGdu9g19zUFI2NjbGiYXkUrRexx7Z7r/G5NfPmxSv/eDFrrne6LF6e8e/Ybv2ha50JVifXGzsvW7E89thvzdd9RMTjDz+6ytzWO46KW8f/IQb2HpGraNCieWlD1NQvsYMdrKWXq/8ZTd0+/nmpoXe3aOq+5j87lSxYEanG7H97/rN73a5bjsxpToiI6Na9MZYvW9L+Hezi45+bmiOiuFtp9O7V8zOP/6QFmSWrzNUvWRBNDUOiyO+45IEd7AAAgM/Su2dJnHDE7knHAAqYgl0evfnmm1njkSPb9gb5yJEjWwp2/7megh10nKWpL8WChRfF9TfdGlVVVYnl+O+jro4nH3s1IiJSqaIYe8Y+Me7co6OoYvPEMtG51fWYF0++92ZUv1id2Nqf9e7MOGjU6JbxxsOq4swrL4mddvWoNPJj+d/e/XjdVye37iMifnLhpfH7m29rGR954nFx4LFHxa8evDuxTHRujbMWxYvvvRn3/G58omsfuqIvf2+f6Fv9f0WjpZU9IjWkLF69+IHY9e4tE0xGZ7X9YaVxwxHXJP7zzqGnXhfV730UERElPbrHd/5rdBz1zT2ifP1HorjboMRy0Xk1NsyOBR+cG3+56zI/7wAAAABrZe23pWG1li5dGjNnzsya22ijjdp0jZWPf/ttj22CrqxPn55xy+/OikOO2CnpKNChttvpy/HrCQ/Ehhu37d9RWJcVFxfHuVf/OL7/owuiuNhjAgE6u0WDesa3j/1W3Hbs/yQdBTpM/8qy+NUVJ8aXtx6WdBQAAAAAWC072OXJvHnzsh4z1r179xgwYECbrjFoUPa3dj/66KOcZAPWPYM26h+33HFWjBi5cdbOltDZfePoI+KcKy6Jbt27R+3CBUnHgQ5R1jcdV/zqZzFql68kHQWAPGsuili4Se/4x7UTIiL8rE+XsenQDeK6C46Ngf37WvcAAAAAFDwFuzxZtGhR1rhXr15RVFTUpmv07t17tddcGx999FHMnTu3TedMnTq13X8vsPa2+dKmcfUNJ0X/9fomHQU6TKooFd+75Idx5In/3eZ/P2FdttHQqvj1hAeiaridXAA6u6ZuRTF/RJ+YfMXDSUeBDjV61Mg47tDR0atnSdJRAAAAAGCNKNjlycpluNLS0jZfo2fPnqu95tr43//937jkkkvafZ1C09T4YdIR6IQKZV1953vfaHV+WeOKjg1Cl1EIa2vDjQfHUScd3+prhZCPzqdQ1tWhx33rU18rlIx0LtYVJGfSNRM+9bXM3IUdmISuolDW1anHfK3V+UL5HZzOx9oCAAAA2kvBLk+WLVuWNe7Ro0ebr1FSkv1N3qVLl7YrU2eUTqejrKwiMnOPSzoKnVRZWUWk0+mkY2RJp9ORLkvH8+/bXZL8SZelrX26nEJc9xHWPvlXqGsfuqJ0Oh19y/vGbd+9OekodFJ9y/sW3D3fezt0hEJ8fwcAAABYdyjY5cnKO9YtX768zdeor69f7TWJqKysjBkzpkYmk0k6Cp1UOp2OysrKpGNkqaysjOoZ1dY9eWXt0xUV4rqPsPbJv0Jd+9AVVVZWxvRp093zyZtCvOd7b4eOUIhrHwAAAFh3KNjlSZ8+fbLGK+9otyZW3rFu5WuujVNOOSUOPfTQNp0zderU+MY3vtHuvztfKisrvUFGl2Pd01VZ+3RV1j5A1+GeT1dk3QMAAABQyBTs8mTlMtySJUuiubk5ioqK1vgaixcvXu0118aAAQNiwIAB7b4OAAAAAAAAAABAZ5dKOkBn1b9//6wy3YoVK+Kjjz5q0zVmz56dNVaMAwAAAAAAAAAA6DgKdnnSs2fP2HjjjbPmZs6c2aZrrHz8iBEj2p0LAAAAAAAAAACANaNgl0crF+KmTJnSpvPffPPN1V4PAAAAAAAAAACA/FGwy6Otttoqa/zcc8+t8blz5syJGTNmtIy7d+8eI0eOzFEyAAAAAAAAAAAAPouCXR7tt99+WePHHnssmpub1+jcv/71r1nj3XbbLfr06ZOzbAAAAAAAAAAAAKyegl0e7bjjjtG/f/+W8fTp02PixIlrdO6tt96aNT7wwANzGQ0AAAAAAAAAAIDPoGCXR6lUKsaMGZM1d8kll3zmLnaPP/54PPPMMy3jsrKyOOyww/IREQAAAAAAAAAAgE+hYJdn55xzTtajXZ966qm46qqrPvX42bNnxwknnJA1d/rpp2fthAcAAAAAAAAAAED+KdjlWf/+/eO8887Lmjv33HPjlFNOiffff79lrqmpKcaPHx877rhjzJgxo2V+ww03jDPPPLOj4gIAAAAAAAAAAPD/Kdh1gHPOOSf222+/rLlf/OIXsfHGG8cmm2wS22yzTfTr1y8OOuigmDlzZssxPXv2jHvuuSfKy8s7ODEAAAAAAAAAAAAKdh0glUrFvffeG0cccUTWfGNjY0yfPj1eeeWVWLBgQdZr/fr1i0ceeSR22mmnDkwKAAAAAAAAAADAfyjYdZDS0tL4/e9/H/fdd19stdVWn3pc796945RTTokpU6bE6NGjOywfAAAAAAAAAAAA2bolHaCrOfjgg+Pggw+OqVOnxqRJk2L27NmxfPnyKC8vj8033zx22mmnKC0tTTpmlvr6+qzx1KlTE0oCAAAAAAAAAAAUgpU7RCt3jDoLBbuEDB8+PIYPH550jDXy3nvvZY2/8Y1vJBMEAAAAAAAAAAAoSO+9915ss802ScfIOY+IBQAAAAAAAAAAoF0WLFiQdIS8ULADAAAAAAAAAACgXTKZTNIR8sIjYvlMu+66a4wfP75lvNFGG0VJSUlygf6/qVOnZj2udvz48evMY3cBaBv3fICuwz0foOtwzwfoOtzzAboW932ArmPKlClx2GGHtYy32267BNPkj4Idn6m8vDwOPPDApGN8puHDh8cWW2yRdAwAOoB7PkDX4Z4P0HW45wN0He75AF2L+z5A15FOp5OOkBceEQsAAAAAAAAAAACtULADAAAAAAAAAACAVijYAQAAAAAAAAAAQCsU7AAAAAAAAAAAAKAVCnYAAAAAAAAAAADQCgU7AAAAAAAAAAAAaIWCHQAAAAAAAAAAALRCwQ4AAAAAAAAAAABaoWAHAAAAAAAAAAAArVCwAwAAAAAAAAAAgFYo2AEAAAAAAAAAAEAruiUdANbWeuutFxdddFHWGIDOyT0foOtwzwfoOtzzAboO93yArsV9H6Dr6Cr3/KLm5ubmpEMAAAAAAAAAAABAofGIWAAAAAAAAAAAAGiFgh0AAAAAAAAAAAC0QsEOAAAAAAAAAAAAWqFgBwAAAAAAAAAAAK1QsAMAAAAAAAAAAIBWKNgBAAAAAAAAAABAKxTsAAAAAAAAAAAAoBUKdgAAAAAAAAAAANAKBTsAAAAAAAAAAABohYIdAAAAAAAAAAAAtELBDgAAAAAAAAAAAFqhYAcAAAAAAAAAAACtULADAAAAAAAAAACAVnRLOgCsjWnTpsULL7wQs2bNiuXLl0dFRUWMGDEidtxxxygtLU06HgDt1NzcHDNmzIh//vOfMWvWrFiwYEGUlJRERUVFfO5zn4svfelL7vcAANBJvP322/Haa6/FrFmzYsmSJdGzZ88YOHBgbLrppvHFL34xSkpKko4IQDvU19fHK6+8Em+++WbU1tbG0qVLI51Ox4ABA2KbbbaJ4cOHR1FRUdIxAUjIsmXL4rnnnou33noramtro0ePHjF48OAYNWpUDBs2LOl4AOTAokWL4o033oi33nor5s+fH8uWLYvy8vIYMGBAbLfddlFVVZV0xM+kYMc6Zfz48XHppZfGyy+/3Orrffr0iTFjxsRFF10U/fv37+B0ALRHbW1tjB8/Pv785z/HE088EfPmzfvUY7t37x777rtvnHHGGbHrrrt2YEoAOtKRRx4Zd999d9bckCFDYsaMGckEAiBn6urq4qc//WnccsstUV1d/anH9ejRI7bffvs45JBD4vTTT+/AhAC010svvRTXXXdd3HfffVFfX/+pxw0aNCiOP/74OP3006OysrIDEwLQmtmzZ8cLL7wQkyZNihdeeCEmT54cdXV1La/n6r2ZuXPnxiWXXBK/+c1vYvHixa0es+2228YFF1wQBx54YLv/PgBWlc97/qRJk2L8+PHx+OOPx0svvRRNTU2feuyQIUPi5JNPjpNOOikqKirW6u/Lt6Lm5ubmpEPAZ6mvr4/jjz8+7rzzzjU6fr311ov77rsvdtlllzwnAyAXTj311Ljlllti+fLlbT73mGOOiZ/+9KeRTqfzkAyApPzpT3+KAw44YJV5BTuAdd/DDz8cJ5xwQnz44YdrfM7AgQPjgw8+yGMqAHKlqakpzjvvvLjmmmtW+yHaygYOHBi/+c1v4utf/3oe0wHQmmeffTb+53/+JyZNmhTvv//+ao/NxXszEydOjEMPPXS1X7T/pGOOOSZ+9atfRY8ePdr19wKQ/3v+q6++GgcffHBMnz69zdnWX3/9uO222wryd4JU0gHgszQ1NcXhhx++SrmuuLg4hg4dGltttVX07ds367W5c+fG3nvvHc8//3xHRgVgLU2aNKnVcl1xcXEMHjw4tt122/jCF76wyv0+IuL222+PvfbaKxYtWtQRUQHoAAsXLoyxY8cmHQOAPLjuuuvigAMOWKVcV1paGsOGDYvtt98+ttxyS08mAFiHnXTSSXHVVVetUq7r1atXbLnllrH99tvHJptssspjYT/88MM48MAD49FHH+3IuABExIsvvhgPPvjgZxYtcuHvf/977LPPPquU68rLy2PrrbeOqqqqKC4uznrt9ttvjyOPPDLsHQTQfvm+58+aNetTy3V9+/aNzTbbLLbffvsYNmzYKr8TfPDBB7Hvvvuu8mSbQqBgR8G75ppr4qGHHsqaO/nkk2PmzJkxffr0eOWVV6KmpiYeeOCB2HjjjVuOWbJkSRx22GGxcOHCjo4MQDuUl5fHKaecEhMmTIja2tp47733YvLkyfHaa6/F/Pnz48knn4ydd94565wXXnghxowZk0xgAHJu3LhxMXv27IiI6N27d8JpAMiVW2+9Nb7//e9nfSi29957x6OPPhoLFiyIadOmxaRJk+L111+PuXPnxuzZs+OOO+6Igw8+2E4VAOuI++67L2655ZasuZEjR8aECRNi4cKF8frrr8ekSZNi6tSp8eGHH8Yll1ySdY9fvnx5HHvssVFbW9vR0QH4FH369MnZtWpra+Pwww+PpUuXtswNGTIkxo8fHzU1NfHyyy9HdXV1zJgxI0466aSscx944IG47rrrcpYFgFXl8p7/HzvssEP87Gc/izfeeCMWLFgQb731VkyaNCmmTZsWH374YVx22WXRq1evluObmprimGOOiVdeeSXnWdpDwY6CNn/+/Ljsssuy5q644or4xS9+ERtuuGHLXCqVioMOOiiee+65qKqqapmfNWtW/OQnP+mouAC0Q1VVVdxyyy3x/vvvx89//vPYZ599oqysLOuY4uLiGD16dDz55JNx4oknZr12//33x5NPPtmRkQHIg4kTJ7Z8IJdKpeKiiy5KOBEAuTB1BNZs2QAAGHlJREFU6tT4zne+0zLu3r173HXXXfHII4/E17/+9SgpKVnlnA033DCOPvrouO++++K1117ryLgArKVLLrkka7zddtvFCy+8EPvss09069Yt67X11lsvLrzwwnj00UezXps7d27cdNNNHZIXgGxlZWUxevToGDduXNx7770xY8aM+NOf/pSz619zzTVZOyYNHTo0nnvuuTjwwAOzdjEaPHhw3HTTTat8TvyjH/1ICRsgR/J5z0+lUnH00UfHv/71r3j++efj1FNPjZEjR65y3HrrrRfnnXdePP/881FZWdkyv2LFijjjjDNykiVXiprto0oBO+ecc+Lqq69uGe+yyy4xceLEVbaJ/KTHH3889txzz5ZxWVlZVFdXR79+/fKaFYC1N2HChNhrr73atCtFY2Nj7LDDDjF58uSWuaOOOmqVR4oDsO5YunRpbLnlljFt2rSIiDj99NPjG9/4Ruy2224txwwZMiRmzJiRUEIA1tbuu++e9YWYe+65Jw499NAEEwGQa9OnT49NNtkka+6FF16IL33pS5957sknnxy//OUvW8Zf/vKX47nnnst5RgBaN23atKivr48RI0ZEKpW9R8/EiRNz8t7M3LlzY9iwYbFo0aKWucceeyz22GOPTz2nubk5Ro8eHU8//XTL3HnnnbdK8Q6ANZfve/6///3vWLFiRWyxxRZtOu+Pf/xjHHjggVlz77zzTgwfPrxN18kXO9hRsJqamuK2227Lmrv44otXW66LiNhjjz2yHh1YV1cX99xzT14yApAb++67b5sf+VRcXBxnn3121txf/vKXXMYCoINdcMEFLeW6jTfeOH784x8nnAiAXHjooYeyynWHHnqoch1AJ/T2229njQcPHrxG5bqIiIMPPjhrPHXq1JzlAuCzbbLJJjFy5MhViha5dPfdd2eV63bZZZfVlusiIoqKilZ5usGvf/3rsIcQwNrL9z1/0003bXO5LiLigAMOWGWXuz//+c+5itVuCnYUrOeeey7mzp3bMh42bFiMHj16jc49/vjjs8bjx4/PYTIACsUnC9URHz9afMmSJQmlAaA9Xnzxxbj++utbxj//+c+jT58+yQUCIGduvvnmrLHHfwN0TjU1NVnjjTbaaI3P3XjjjbPGCxYsyEUkAArIQw89lDVe+fPcT7PbbrvF0KFDW8YffPBB/OMf/8hpNgAKw8qf/c6cOTOhJKtSsKNgTZgwIWu81157febudZ889pMmTpwYixcvzlk2AApDRUXFKnMLFy5MIAkA7bFixYo4/vjjo7GxMSI+3tlov/32SzgVALkwe/bsrJ2mt9pqq7X6FjMAha9v375Z46VLl67xuSsf279//5xkAqAwLFq0KOsxrxERX/3qV9fo3KKiothzzz2z5h5++OGcZQOgcKz82W8hfe6rYEfBevXVV7PGO+644xqfu+GGG0ZVVVXLePny5TFlypQcJQOgUMyePXuVuX79+iWQBID2uOKKK+Kf//xnRESUl5fHjTfemHAiAHLlz3/+c0uBOuLj3ScA6Jy22mqrrPGbb765xl98f+GFF7LG22+/fa5iAVAA3njjjVixYkXLeOjQobH++uuv8fk77bRT1njlz5EB6BxW/uy3kD73VbCjYL355ptZ45WftfxZVj5+5esBsO575plnssZDhgyJHj16JJQGgLUxZcqUuOyyy1rGV111VZveYAWgsL344otZ4y9+8Ystf37llVfitNNOiy9+8YtRUVERvXr1iqqqqthrr73i2muvbfULNQAUrsGDB2d9Ub6+vn6NvjxTX18f119/fdbcmj42EIB1g899Afgszc3N8fe//z1rbtNNN00ozaoU7ChIS5cuXeVZyhtttFGbrrHy8W+//Xa7cwFQWH79619njffZZ5+EkgCwNpqamuL444+P5cuXR0TEzjvvHN/+9rcTTgVALq1csBs2bFgsWrQojj/++Nhmm23ipz/9abz++uuxYMGCWLp0abz77rvx2GOPxbhx4+Jzn/tcnHfeeVk7XQBQ2K666qpIpf7vo6cLL7wwfvvb337q8QsWLIhDDjkkqyix//77x/7775/XnAB0rJU/p23v577vvvtuLFu2rN25ACgcEydOjOrq6pZxUVFRfP3rX08wUbZuSQeA1sybNy+am5tbxt27d48BAwa06RqDBg3KGn/00Uc5yQZAYXjkkUfi6aefzpobM2ZMMmEAWCs33nhj/OMf/4iIiB49esTNN98cRUVFCacCIJemTp2aNU6lUrHLLrvEK6+88pnnLl26NK644op48cUX44EHHoiysrJ8xQQgR77yla/Ez372szj11FOjubk5GhoaYsyYMfHzn/88vvnNb8Zmm20WPXv2jHnz5sWkSZPirrvuipqampbz99prr/j973+f4H8BAPmw8ue0gwcPbtP5AwcOjG7dukVDQ0NEfPylzfnz56/yeTAA66ampqY499xzs+a+/vWvF9TTbhTsKEiLFi3KGvfq1avNH7T17t17tdcEYN1VU1MTJ510UtbcN77xjdh+++0TSgRAW1VXV8f555/fMj733HNjxIgRCSYCINeampqirq4ua+60005rKdcVFRXFfvvtF/vss08MHjw4Fi9eHK+88krccccd8f7777ec89hjj8WYMWPi/vvv79D8AKydsWPHxmabbRannXZavPHGGxHx8Y6mK+9q+knDhg2Ls88+O7797W9n7YAHQOew8ue0K3+O+1mKioqiZ8+eWb9f+OwXoPO49tprY9KkSS3jVCoVl112WYKJVuW3FArSyj8QlZaWtvkaPXv2XO01AVg3NTU1xdFHHx2zZs1qmevbt2/ceOONCaYCoK1OPPHEWLx4cUREjBgxIs4777yEEwGQawsXLsx6QkFExMsvvxwREf369Yunnnoq/vjHP8bJJ58c++23Xxx++OFx5ZVXxttvvx1HHXVU1nkPPPBA3H777R2WHYD22X333ePFF1+Ms846K4qLi1d77MYbbxxnnXVWHHXUUcp1AJ2Uz34B+DTPPPNM/PCHP8yaO+OMM2LrrbdOKFHr/KZCQVq2bFnWuEePHm2+RklJSdZ46dKl7coEQGEYN25cPProo1lzv/zlL2OjjTZKKBEAbXXrrbfGY489FhEffwP55ptvXquf+QEobJ/2gVdxcXFMmDAhdt5551Zf79OnT9xxxx3x1a9+NWv+8ssvX6WwB0Bhuummm2KTTTaJa6+9NhobG1d77MyZM+OUU06Jqqqq+PWvf91BCQHoSD77BaA106dPj29+85stjwCPiNhqq63i8ssvTzBV6xTsKEgrf2th+fLlbb5GfX39aq8JwLrnxhtvjJ/85CdZc2effXYcfvjhCSUCoK3mzJkTZ511Vsv4hBNO+NSCBQDrtk97L+aEE06IUaNGrfbcVCoVv/jFL7J2Mnr77bfjqaeeymlGAHJrxYoVccghh8TYsWNjzpw5ERFRWVkZF154YbzwwgtRW1sby5cvj/fffz/++Mc/xkEHHRRFRUUREVFTUxPHH398jBs3Lsn/BADywGe/AKxs3rx5sffee8e8efNa5gYOHBgPPPDAKqXqQqBgR0Hq06dP1njlbzWsiZW/tbDyNQFYt9x1111xxhlnZM2NGTMmrrzyymQCAbBWTj311FiwYEFERKy//vpx9dVXJxsIgLz5tPdivv3tb6/R+cOGDYs999wza07BDqCwjR07Nu6///6W8fbbbx9vvPFGXHLJJfGlL30pysvLo3v37rHBBhvE/vvvHw888ECMHz8+qyRx7bXXxm233ZZEfADyxGe/AHxSXV1d7L333vHvf/+7Za5v377xl7/8JYYOHZpgsk+nYEdBWvkHoiVLlrT5ESCLFy9e7TUBWHc8/PDDceyxx2b9W/DNb34zbrnllpZvOQNQ+O6999548MEHW8Y33HBDlJeXJxcIgLzq2bNnFBcXZ82VlZXF1ltvvcbX2HXXXbPGkydPzkk2AHJv4sSJceutt7aMBwwYEA8//HCsv/76qz3vgAMOiJ///OdZc+PGjfPoP4BOZOXPaVf+HPezNDc3K9gBdBLLli2LAw44IOs9nl69esWECRPii1/8YoLJVk/BjoLUv3//rMLEihUr4qOPPmrTNWbPnp01HjBgQE6yAdCxnnzyyTj00EOjoaGhZW6vvfaK3//+96t8WAdAYfvko5723XffOOywwxJMA0BHWPn9mOHDh2c99vWzbLbZZlnjtr4/BEDHufHGG7PGZ5xxRqy33nprdO6YMWNi0003bRnPnz8/HnjggZzmAyA5K/9eMGvWrDad/+GHH2Z9RpBKpaJ///45yQZAx1mxYkUcdthhMXHixJa5Hj16xAMPPBA77bRTcsHWgIIdBalnz56x8cYbZ83NnDmzTddY+fgRI0a0OxcAHWvSpElxwAEHZG0Xv+OOO8aDDz4YPXr0SDAZAGvjP4+GjYiYMGFCFBUVfeb/dtttt6xrvPvuu6sc8+qrr3bsfwgAa2zzzTfPGqfT6Tadv/LxtbW17c4EQO41NzfHE088kTW3//77r/H5qVQq9t1336y5p59+OifZAEjeyl+cae/nvkOGDMl6vDgAha+pqSmOOeaY+NOf/tQyV1xcHHfddVd87WtfSzDZmlGwo2CtXIibMmVKm85/8803V3s9AArb66+/HnvvvXcsWrSoZW7rrbeORx55JHr37p1gMgAAYE2NHDkya1xfX9+m8z/5ZZuIjx8ZAkDhqa2tjYULF2bNDR06tE3XWPn4lZ9SA8C6y+e+AF1bc3NznHjiiXH33Xe3zBUVFcUtt9wSBx98cILJ1pyCHQVrq622yho/99xza3zunDlzYsaMGS3j7t27r/KGLgCF6+2334699tora3eKzTffPP7yl79E3759E0wGAAC0xTbbbJM1/vDDD9t0/sqPhO3Xr1+7MwGQe60VqLt169ama3Tv3j1r3NjY2K5MABSOLbbYIus+P2PGjJgzZ84an//ss89mjVf+HBmAwva9730vbr311qy5G2+8McaMGZNMoLXQtt9uoAPtt99+cdVVV7WMH3vssWhubo6ioqLPPPevf/1r1ni33XaLPn365DwjALn37rvvxp577pn1QdrQoUPjb3/7W6y33noJJgOgvR566KFYsWJFm8557bXX4qyzzmoZDxw4MH73u99lHTN8+PCc5AMg9/bdd99IpVLR1NQUERHV1dVRU1MTlZWVa3T+Sy+9lDVe+dFSABSG1grQ77//fpt2sVt5xzrvAwF0HmVlZbHLLrvE448/3jL3t7/9LY455pjPPLe5uTkee+yxrLm2PIYcgGRdcMEFccMNN2TNXX755fGd73wnoURrR8GOgrXjjjtG//79Y968eRERMX369Jg4cWLstttun3nuys3XAw88MC8ZAcitOXPmxB577BGzZs1qmRs0aFA8/vjjMWjQoASTAZALu+66a5vPWXnXi9LS0thzzz1zFQmAPBswYEDstNNO8cwzz7TMPfDAA3HCCSd85rkNDQ3x4IMPZs2NHj061xEByIEePXrEBhtskLUb0RNPPBHHH3/8Gl/jk6WLiIhNNtkkZ/kASN4BBxyQda+/9dZb16hg9+STT0Z1dXXLeODAgTFq1Ki8ZAQgt6655pr48Y9/nDV37rnnxrnnnptQorXnEbEUrFQqtcp2kJdcckk0Nzev9rzHH388603bsrKyOOyww/IREYAcqqmpib322iumTZvWMrfeeuvF3/72tzZ92xkAACgsJ510Utb4mmuuafVRgiv71a9+FR988EHLOJ1Ox9e+9rWc5wMgN/bYY4+s8fXXXx8NDQ1rdO5TTz0Vzz///GqvB8C67YgjjojevXu3jJ9++ul44oknVntOc3NzXHLJJVlzxx13XKRSag4Ahe6Xv/xlnH322Vlz3/nOd+Lyyy9PKFH7+JeHgnbOOedkPdr1qaeeynps7Mpmz569yjegTz/99Ojfv3/eMgLQfnV1dfH1r3893njjjZa58vLy+Otf/xqbb755gskAAID2OvLII2PLLbdsGf/73/+Ok046qeWxsa2ZNGnSKm/CnnLKKdG3b9+85QSgfY4++uis8b/+9a845ZRTVnu/j4iYOnVqHHXUUVlzn/vc5+LLX/5yzjMCkJwBAwas8jjAE044Id5///1PPeeKK66Ip59+umXct2/fGDduXN4yApAbd911V5xyyilZc8cdd1zceOONCSVqv6Lmz9oODBJ2xRVXxHnnnZc1N3bs2Dj//PNjww03jIiIpqam+OMf/xinn356zJw5s+W4DTfcMN54440oLy/vyMgAtNFuu+0WEydOzJr70Y9+tFZvpG677bZRUVGRo2QAJG3ixImx2267tYyHDBkSM2bMSC4QAGvl8ccfj7322ivryQR77rlnXHnllbHtttu2zC1cuDBuvfXWuOiii2LRokUt85tuumlMnjw5ysrKOjQ3AG2z++67x5NPPpk195WvfCUuvvji2HXXXaNbt24t8/Pnz4/f/OY3cemll8bChQuzzrn33nvjkEMO6ZDMAHzs2WefjaVLl64y/9prr8VZZ53VMh44cGD87ne/a/UaG264YYwcOfJT/46amprYYostsnaqHjJkSNx4442x//77R1FRUUREzJo1K3784x/HL3/5y6zzr776agU7gBzI5z3/sccei7333jtrN+sRI0bE9ddfH8XFxW3KWVFRkfW+UZIU7Ch4TU1NceCBB8bDDz+cNV9cXBxDhgyJvn37RnV1dSxYsCDr9Z49e8bf/va32GmnnTowLQBr4z+/NOfCk08+GaNHj87Z9QBIloIdQOdx1VVXxQ9+8INV5tdff/0YPHhwLF68OKZNmxbLly/Per1fv37x5JNPZu2CB0Bh+uCDD2LHHXeM6urqVV7r06dPDB06NHr27Bnz58+P6dOnR2sfUZ155plx7bXXdkRcAD6hqqoq3n333XZd49hjj43f/OY3qz3m6aefjq997WuxbNmyrPny8vIYOnRoLFiwIGbOnBmNjY1Zrx944IHx4IMP5vTzBICuKp/3/IsvvniVx3uvrV133XWVTVqS4hGxFLxUKhX33ntvHHHEEVnzjY2NMX369HjllVdWKdf169cvHnnkEeU6AAAAgAJxzjnnxI033hjdu3fPmv/ggw9i8uTJ8eabb65Srttss83i+eefV64DWEesv/768dRTT7X65cdFixbFP//5z3jhhRdi2rRpq5TrunfvHldeeWVcc801HZQWgCTssssuMWHChKisrMyaX7BgQbzyyitRXV29SrnuqKOOij/84Q/KdQAkRsGOdUJpaWn8/ve/j/vuuy+22mqrTz2ud+/eccopp8SUKVPsXgQAAABQYL773e/G66+/HocffvgqRbtPGjp0aNxwww3x+uuvx+c+97kOTAhAe2200Ubx+OOPxz333BOjR4+OVGr1H0X17ds3xo4dG//85z/jnHPOUZ4A6AJ23333mDJlSowdOzZ69er1qcdtvfXWcf/998edd94ZJSUlHZgQALJ5RCzrpKlTp8akSZNi9uzZsXz58igvL4/NN988dtpppygtLU06HgAAAACfIZPJxHPPPRfvvPNOLFy4MPr06RMDBw6MbbbZJjbbbLOk4wGQI3V1dTF58uSYPn16LFiwIJYtWxbpdDr69esXX/jCF2LkyJGfWcIDoPNaunRpPPfcc/Hmm2/GggULokePHjFo0KAYNWpUDB8+POl4ABARCnYAAAAAAAAAAADQKl8JAgAAAAAAAAAAgFYo2AEAAAAAAAAAAEArFOwAAAAAAAAAAACgFQp2AAAAAAAAAAAA0AoFOwAAAAAAAAAAAGiFgh0AAAAAAAAAAAC0QsEOAAAAAAAAAAAAWqFgBwAAAAAAAAAAAK1QsAMAAAAAAAAAAIBWKNgBAAAAAAAAAABAKxTsAAAAAAAAAAAAoBUKdgAAAAAAAAAAANAKBTsAAAAAAAAAAABohYIdAAAAAAAAAAAAtELBDgAAAAAAAAAAAFqhYAcAAAAAAAAAAACtULADAAAAAAAAAACAVijYAQAAAAAAAAAAQCsU7AAAAAAAAAAAAKAVCnYAAAAAAAAAAADQCgU7AAAAAAAAAAAAaIWCHQAAAAAAAAAAALRCwQ4AAAAAAAAAAABaoWAHAAAAAAAAAAAArVCwAwAAAAAAAAAAgFYo2AEAAAAAAAAAAEArFOwAAAAAAAAAAACgFQp2AAAAAAAAAAAA0AoFOwAAAAAAAAAAAGiFgh0AAAAAAAAAAAC0QsEOAAAAAAAAAAAAWqFgBwAAAAAAAAAAAK1QsAMAAAAAAAAAAIBWKNgBAAAAAAAAAABAKxTsAAAAAAAAAAAAoBUKdgAAAAAAAAAAANAKBTsAAAAAAAAAAABoxf8DryG78JGR0vsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -87,32 +108,41 @@ "# here we build a figure that shows nodes and edges in beautiful style\n", "fig = work_graph_fig(simple_wg, (10, 10))\n", "fig.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-04T13:35:26.139585600Z", - "start_time": "2023-10-04T13:35:23.754591600Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 3. Project Gant chart\n", "There diagram that shows scheduled works on time scale" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-10-04T13:35:26.718588500Z", + "start_time": "2023-10-04T13:35:26.139585600Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, "data": [ { "alignmentgroup": "True", @@ -259,7 +289,7 @@ [ "start of project", 0, - 0.0, + 0, "unit", "{}" ], @@ -294,28 +324,28 @@ [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], @@ -336,14 +366,14 @@ [ "KTP and NEP", 14000, - 1.0, + 1, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'electrician': 3}" ], [ "block water distribution", 17050, - 0.0, + 0, "unit", "{'driver': 6,
'fitter': 9,
'manager': 1,
'handyman': 12,
'engineer': 3}" ], @@ -357,21 +387,21 @@ [ "drainage tank", 11360, - 1.0, + 1, "unit", "{'driver': 7,
'manager': 1,
'handyman': 8}" ], [ "firewall tank", 12000, - 0.0, + 0, "unit", "{'driver': 7,
'manager': 1,
'handyman': 8}" ], [ "start filters system", 13140, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 5,
'manager': 1,
'handyman': 7,
'engineer': 2}" ], @@ -385,203 +415,203 @@ [ "block dosage inhibitor", 14000, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'engineer': 3}" ], [ "metering installation", 12420, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 5,
'manager': 1,
'handyman': 7,
'engineer': 2}" ], [ "metering installation", 14000, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'engineer': 3}" ], [ "block local automation", 13000, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 7,
'manager': 1,
'handyman': 10,
'engineer': 3}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 7140, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 3,
'manager': 1,
'handyman': 6}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 7140, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 3,
'manager': 1,
'handyman': 6}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 7140, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 3,
'manager': 1,
'handyman': 6}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], @@ -630,7 +660,7 @@ [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], @@ -707,21 +737,21 @@ [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], @@ -812,7 +842,7 @@ [ "finish of project", 0, - 0.0, + 0, "unit", "{}" ], @@ -847,84 +877,84 @@ [ "KTP and NEP", 14000, - 1.0, + 1, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'electrician': 3}" ], [ "block water distribution", 17050, - 0.0, + 0, "unit", "{'driver': 6,
'fitter': 9,
'manager': 1,
'handyman': 12,
'engineer': 3}" ], [ "drainage tank", 11360, - 1.0, + 1, "unit", "{'driver': 7,
'manager': 1,
'handyman': 8}" ], [ "firewall tank", 12000, - 0.0, + 0, "unit", "{'driver': 7,
'manager': 1,
'handyman': 8}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "node", 50400, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 7,
'manager': 7,
'handyman': 11,
'electrician': 5}" ], [ "start filters system", 13140, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 5,
'manager': 1,
'handyman': 7,
'engineer': 2}" ], [ "metering installation", 14000, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'engineer': 3}" ], [ "block dosage inhibitor", 14000, - 0.0, + 0, "unit", "{'driver': 5,
'fitter': 8,
'manager': 1,
'handyman': 11,
'engineer': 3}" ], [ "metering installation", 12420, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 5,
'manager': 1,
'handyman': 7,
'engineer': 2}" ], [ "block local automation", 13000, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 7,
'manager': 1,
'handyman': 10,
'engineer': 3}" ], @@ -945,35 +975,35 @@ [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], @@ -987,91 +1017,91 @@ [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 7140, - 0.0, + 0, "unit", "{'driver': 4,
'fitter': 3,
'manager': 1,
'handyman': 6}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], [ "borehole", 11310, - 0.0, + 0, "unit", "{'driver': 11,
'fitter': 8,
'manager': 2,
'handyman': 8}" ], @@ -1176,14 +1206,14 @@ [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], [ "mast", 1750, - 0.0, + 0, "unit", "{'driver': 3,
'fitter': 7,
'manager': 3,
'handyman': 11,
'electrician': 1}" ], @@ -1204,14 +1234,14 @@ [ "finish of project", 0, - 0.0, + 0, "unit", "{}" ], [ "finish of project", 0, - 0.0, + 0, "unit", "{}" ] @@ -1507,144 +1537,145 @@ "finish of project" ], "textposition": "outside", + "type": "bar", "x": [ - 8.64E7, - 3.456E8, - 1.296E9, - 3.1104E9, - 4.5792E9, - 1.2528E10, - 1.2528E10, - 1.2528E10, - 1.2528E10, - 2.5056E9, - 3.9744E9, - 4.4064E9, - 4.8384E9, - 5.2704E9, - 6.2208E9, - 6.5664E9, - 6.3936E9, - 1.728E9, - 4.4064E9, - 6.048E9, - 4.4064E9, - 4.5792E9, - 3.456E9, - 4.4928E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 4.4928E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 4.4928E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 1.296E9, - 1.8144E9, - 1.728E9, - 1.728E9, - 1.728E9, - 1.728E9, - 6.912E8, - 1.296E9, - 1.6416E9, - 5.184E8, - 6.048E8, - 6.048E8, - 4.32E8, - 5.184E8, - 6.048E8, - 5.184E8, - 6.048E8, - 6.912E8, - 6.912E8, - 6.912E8, - 3.456E8, - 4.32E8, - 3.456E8, - 2.592E8, - 2.592E8, - 1.728E8, - 2.592E8, - 1.728E8, - 1.728E8, - 1.728E8, - 1.728E8, - 2.592E8, - 8.64E7, - 2.592E8, - 9.504E8, - 3.8016E9, - 2.4192E9, - 4.4064E9, - 4.8384E9, - 6.2208E9, - 6.5664E9, - 1.2528E10, - 1.2528E10, - 1.2528E10, - 6.3936E9, - 4.4064E9, - 4.4064E9, - 6.048E9, - 4.5792E9, - 1.9008E9, - 3.1104E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.1104E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 4.4928E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 3.456E9, - 1.728E9, - 1.728E9, - 1.728E9, - 1.728E9, - 1.728E9, - 1.728E9, - 2.592E8, - 3.456E8, - 6.048E8, - 6.048E8, - 6.048E8, - 1.728E8, - 4.32E8, - 1.728E9, - 6.912E8, - 6.912E8, - 1.2096E9, - 2.592E8, - 8.64E7, - 8.64E7 + 86400000, + 345600000, + 1296000000, + 3110400000, + 4579200000, + 12528000000, + 12528000000, + 12528000000, + 12528000000, + 2505600000, + 3974400000, + 4406400000, + 4838400000, + 5270400000, + 6220800000, + 6566400000, + 6393600000, + 1728000000, + 4406400000, + 6048000000, + 4406400000, + 4579200000, + 3456000000, + 4492800000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 4492800000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 4492800000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 1296000000, + 1814400000, + 1728000000, + 1728000000, + 1728000000, + 1728000000, + 691200000, + 1296000000, + 1641600000, + 518400000, + 604800000, + 604800000, + 432000000, + 518400000, + 604800000, + 518400000, + 604800000, + 691200000, + 691200000, + 691200000, + 345600000, + 432000000, + 345600000, + 259200000, + 259200000, + 172800000, + 259200000, + 172800000, + 172800000, + 172800000, + 172800000, + 259200000, + 86400000, + 259200000, + 950400000, + 3801600000, + 2419200000, + 4406400000, + 4838400000, + 6220800000, + 6566400000, + 12528000000, + 12528000000, + 12528000000, + 6393600000, + 4406400000, + 4406400000, + 6048000000, + 4579200000, + 1900800000, + 3110400000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3110400000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 4492800000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 3456000000, + 1728000000, + 1728000000, + 1728000000, + 1728000000, + 1728000000, + 1728000000, + 259200000, + 345600000, + 604800000, + 604800000, + 604800000, + 172800000, + 432000000, + 1728000000, + 691200000, + 691200000, + 1209600000, + 259200000, + 86400000, + 86400000 ], "xaxis": "x", "y": [ @@ -1786,83 +1817,98 @@ 135, 136 ], - "yaxis": "y", - "type": "bar" + "yaxis": "y" } ], "layout": { + "autosize": true, + "barmode": "overlay", + "font": { + "size": 12 + }, + "legend": { + "title": { + "text": "contractor" + }, + "tracegroupgap": 0 + }, "template": { "data": { - "histogram2dcontour": [ + "bar": [ { - "type": "histogram2dcontour", - "colorbar": { - "outlinewidth": 0, - "ticks": "" + "error_x": { + "color": "#2a3f5f" }, - "colorscale": [ - [ - 0.0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1.0, - "#f0f921" - ] - ] + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" } ], "choropleth": [ { - "type": "choropleth", "colorbar": { "outlinewidth": 0, "ticks": "" - } + }, + "type": "choropleth" } ], - "histogram2d": [ + "contour": [ { - "type": "histogram2d", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -1898,22 +1944,31 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" } ], "heatmap": [ { - "type": "heatmap", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -1949,22 +2004,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmap" } ], "heatmapgl": [ { - "type": "heatmapgl", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -2000,31 +2055,34 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmapgl" } ], - "contourcarpet": [ + "histogram": [ { - "type": "contourcarpet", - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" } ], - "contour": [ + "histogram2d": [ { - "type": "contour", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -2060,22 +2118,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2d" } ], - "surface": [ + "histogram2dcontour": [ { - "type": "surface", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -2111,19 +2169,37 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2dcontour" } ], "mesh3d": [ { - "type": "mesh3d", "colorbar": { "outlinewidth": 0, "ticks": "" - } + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" } ], "scatter": [ @@ -2136,162 +2212,149 @@ "type": "scatter" } ], - "parcoords": [ + "scatter3d": [ { - "type": "parcoords", "line": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "scatterpolargl": [ - { - "type": "scatterpolargl", + }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } }, - "type": "bar" + "type": "scatter3d" } ], - "scattergeo": [ + "scattercarpet": [ { - "type": "scattergeo", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattercarpet" } ], - "scatterpolar": [ + "scattergeo": [ { - "type": "scatterpolar", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } }, - "type": "histogram" + "type": "scattergeo" } ], "scattergl": [ { - "type": "scattergl", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattergl" } ], - "scatter3d": [ + "scattermapbox": [ { - "type": "scatter3d", - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattermapbox" } ], - "scattermapbox": [ + "scatterpolar": [ { - "type": "scattermapbox", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolar" } ], - "scatterternary": [ + "scatterpolargl": [ { - "type": "scatterternary", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolargl" } ], - "scattercarpet": [ + "scatterternary": [ { - "type": "scattercarpet", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterternary" } ], - "carpet": [ + "surface": [ { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" + "colorbar": { + "outlinewidth": 0, + "ticks": "" }, - "type": "carpet" + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" } ], "table": [ @@ -2314,84 +2377,15 @@ }, "type": "table" } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } ] }, "layout": { - "autotypenumbers": "strict", - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "hovermode": "closest", - "hoverlabel": { - "align": "left" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "bgcolor": "#E5ECF6", - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "ternary": { - "bgcolor": "#E5ECF6", - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 }, + "autotypenumbers": "strict", "coloraxis": { "colorbar": { "outlinewidth": 0, @@ -2399,51 +2393,55 @@ } }, "colorscale": { - "sequential": [ + "diverging": [ [ - 0.0, - "#0d0887" + 0, + "#8e0152" ], [ - 0.1111111111111111, - "#46039f" + 0.1, + "#c51b7d" ], [ - 0.2222222222222222, - "#7201a8" + 0.2, + "#de77ae" ], [ - 0.3333333333333333, - "#9c179e" + 0.3, + "#f1b6da" ], [ - 0.4444444444444444, - "#bd3786" + 0.4, + "#fde0ef" ], [ - 0.5555555555555556, - "#d8576b" + 0.5, + "#f7f7f7" ], [ - 0.6666666666666666, - "#ed7953" + 0.6, + "#e6f5d0" ], [ - 0.7777777777777778, - "#fb9f3a" + 0.7, + "#b8e186" ], [ - 0.8888888888888888, - "#fdca26" + 0.8, + "#7fbc41" ], [ - 1.0, - "#f0f921" + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" ] ], - "sequentialminus": [ + "sequential": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -2479,106 +2477,125 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] ], - "diverging": [ + "sequentialminus": [ [ 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" + "#0d0887" ], [ - 0.2, - "#de77ae" + 0.1111111111111111, + "#46039f" ], [ - 0.3, - "#f1b6da" + 0.2222222222222222, + "#7201a8" ], [ - 0.4, - "#fde0ef" + 0.3333333333333333, + "#9c179e" ], [ - 0.5, - "#f7f7f7" + 0.4444444444444444, + "#bd3786" ], [ - 0.6, - "#e6f5d0" + 0.5555555555555556, + "#d8576b" ], [ - 0.7, - "#b8e186" + 0.6666666666666666, + "#ed7953" ], [ - 0.8, - "#7fbc41" + 0.7777777777777778, + "#fb9f3a" ], [ - 0.9, - "#4d9221" + 0.8888888888888888, + "#fdca26" ], [ 1, - "#276419" + "#f0f921" ] ] }, - "xaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" }, - "yaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "scene": { "xaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "yaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "zaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" } }, "shapedefaults": { @@ -2586,52 +2603,71 @@ "color": "#2a3f5f" } }, - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "geo": { - "bgcolor": "white", - "landcolor": "#E5ECF6", - "subunitcolor": "white", - "showland": true, - "showlakes": true, - "lakecolor": "white" + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "title": { "x": 0.05 }, - "mapbox": { - "style": "light" + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 } } }, + "title": { + "text": "Project tasks - Gant chart" + }, "xaxis": { "anchor": "y", "domain": [ - 0.0, - 1.0 + 0, + 1 ], - "type": "date", - "title": { - "text": "Date" - }, "range": [ "2021-12-30T00:00:00", "2026-05-13T00:00:00" - ] - }, - "yaxis": { - "anchor": "x", - "domain": [ - 0.0, - 1.0 ], "title": { - "text": "Project tasks" + "text": "Date" }, - "categoryorder": "array", + "type": "date" + }, + "yaxis": { + "anchor": "x", "categoryarray": [ 136, 135, @@ -2771,29 +2807,46 @@ 1, 0 ], + "categoryorder": "array", + "domain": [ + 0, + 1 + ], "showticklabels": false, - "type": "category" - }, - "legend": { "title": { - "text": "contractor" + "text": "Project tasks" }, - "tracegroupgap": 0 - }, - "title": { - "text": "Project tasks - Gant chart" - }, - "barmode": "overlay", - "font": { - "size": 12 - }, - "autosize": true - }, - "config": { - "plotlyServerURL": "https://plot.ly" + "type": "category" + } } }, - "text/html": "
" + "text/html": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -2811,41 +2864,49 @@ "fig = schedule_gant_chart_fig(schedule_dataframe=merged_schedule,\n", " visualization=VisualizationMode.ShowFig,\n", " remove_service_tasks=False)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-10-04T13:35:26.718588500Z", - "start_time": "2023-10-04T13:35:26.139585600Z" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "# 4. Resource employment figs\n", "There are a couple of figs that shows resource utilization." - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Resource employment by tasks" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, "data": [ { "alignmentgroup": "True", @@ -5828,1193 +5889,1194 @@ "orientation": "h", "showlegend": false, "text": [ - 69.0, - 69.0, - 69.0, - 29.0, - 5.0, - 5.0, - 5.0, - 5.0, - 69.0, - 5.0, - 7.0, - 7.0, - 7.0, - 3.0, - 5.0, - 6.0, - 23.0, - 5.0, - 3.0, - 5.0, - 4.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 4.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 4.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 4.0, - 11.0, - 11.0, - 11.0, - 19.0, - 11.0, - 22.0, - 25.0, - 23.0, - 11.0, - 11.0, - 6.0, - 10.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 2.0, - 69.0, - 69.0, - 29.0, - 69.0, - 5.0, - 7.0, - 6.0, - 5.0, - 7.0, - 5.0, - 3.0, - 5.0, - 5.0, - 5.0, - 3.0, - 4.0, - 69.0, - 11.0, - 11.0, - 7.0, - 11.0, - 5.0, - 11.0, - 11.0, - 11.0, - 11.0, - 4.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 9.0, - 25.0, - 26.0, - 25.0, - 17.0, - 23.0, - 3.0, - 3.0, - 3.0, - 3.0, - 8.0, - 9.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 2.0, - 44.0, - 44.0, - 44.0, - 5.0, - 7.0, - 7.0, - 7.0, - 7.0, - 45.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 15.0, - 1.0, - 1.0, - 1.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 12.0, - 2.0, - 16.0, - 16.0, - 15.0, - 7.0, - 7.0, - 2.0, - 6.0, - 3.0, - 2.0, - 2.0, - 3.0, - 2.0, - 2.0, - 2.0, - 2.0, - 3.0, - 3.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 29.0, - 29.0, - 5.0, - 29.0, - 7.0, - 1.0, - 1.0, - 7.0, - 1.0, - 1.0, - 1.0, - 7.0, - 1.0, - 1.0, - 1.0, - 1.0, - 45.0, - 2.0, - 2.0, - 1.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 6.0, - 16.0, - 17.0, - 16.0, - 11.0, - 15.0, - 3.0, - 2.0, - 2.0, - 2.0, - 5.0, - 6.0, - 2.0, - 2.0, - 3.0, - 2.0, - 2.0, - 2.0, - 137.0, - 137.0, - 137.0, - 29.0, - 11.0, - 11.0, - 11.0, - 11.0, - 134.0, - 11.0, - 8.0, - 8.0, - 8.0, - 7.0, - 11.0, - 12.0, - 23.0, - 11.0, - 7.0, - 11.0, - 10.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 6.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 6.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 6.0, - 8.0, - 8.0, - 8.0, - 19.0, - 8.0, - 25.0, - 25.0, - 23.0, - 11.0, - 12.0, - 6.0, - 10.0, - 11.0, - 3.0, - 3.0, - 11.0, - 3.0, - 3.0, - 3.0, - 3.0, - 11.0, - 11.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 137.0, - 137.0, - 29.0, - 137.0, - 11.0, - 8.0, - 12.0, - 11.0, - 8.0, - 11.0, - 7.0, - 11.0, - 11.0, - 11.0, - 7.0, - 10.0, - 90.0, - 8.0, - 8.0, - 8.0, - 8.0, - 11.0, - 8.0, - 8.0, - 8.0, - 8.0, - 6.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 9.0, - 25.0, - 26.0, - 25.0, - 17.0, - 23.0, - 11.0, - 3.0, - 3.0, - 3.0, - 8.0, - 9.0, - 3.0, - 3.0, - 11.0, - 3.0, - 3.0, - 4.0, - 2.0, - 3.0, - 3.0, - 2.0, - 3.0, - 3.0, - 4.0, - 4.0, - 3.0, - 2.0, - 3.0, - 3.0, - 2.0, - 3.0, - 4.0, - 7.0, - 7.0, - 7.0, - 7.0, - 69.0, - 8.0, - 5.0, - 8.0, - 9.0, - 23.0, - 8.0, - 5.0, - 8.0, - 7.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 3.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 3.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 3.0, - 8.0, - 8.0, - 8.0, - 19.0, - 8.0, - 25.0, - 25.0, - 23.0, - 11.0, - 11.0, - 6.0, - 10.0, - 7.0, - 3.0, - 3.0, - 7.0, - 3.0, - 3.0, - 3.0, - 3.0, - 7.0, - 7.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 7.0, - 9.0, - 7.0, - 8.0, - 5.0, - 7.0, - 8.0, - 8.0, - 5.0, - 7.0, - 69.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 3.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 9.0, - 25.0, - 26.0, - 25.0, - 17.0, - 23.0, - 7.0, - 3.0, - 3.0, - 3.0, - 8.0, - 9.0, - 3.0, - 3.0, - 7.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 45.0, - 3.0, - 3.0, - 15.0, - 12.0, - 16.0, - 16.0, - 15.0, - 7.0, - 7.0, - 2.0, - 6.0, - 1.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 5.0, - 5.0, - 3.0, - 5.0, - 45.0, - 3.0, - 6.0, - 16.0, - 17.0, - 16.0, - 11.0, - 15.0, - 1.0, - 2.0, - 2.0, - 2.0, - 5.0, - 6.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0 + 69, + 69, + 69, + 29, + 5, + 5, + 5, + 5, + 69, + 5, + 7, + 7, + 7, + 3, + 5, + 6, + 23, + 5, + 3, + 5, + 4, + 11, + 11, + 11, + 11, + 11, + 4, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 4, + 11, + 11, + 11, + 11, + 11, + 11, + 4, + 11, + 11, + 11, + 19, + 11, + 22, + 25, + 23, + 11, + 11, + 6, + 10, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 2, + 69, + 69, + 29, + 69, + 5, + 7, + 6, + 5, + 7, + 5, + 3, + 5, + 5, + 5, + 3, + 4, + 69, + 11, + 11, + 7, + 11, + 5, + 11, + 11, + 11, + 11, + 4, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 9, + 25, + 26, + 25, + 17, + 23, + 3, + 3, + 3, + 3, + 8, + 9, + 3, + 3, + 3, + 3, + 3, + 2, + 44, + 44, + 44, + 5, + 7, + 7, + 7, + 7, + 45, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 15, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 12, + 2, + 16, + 16, + 15, + 7, + 7, + 2, + 6, + 3, + 2, + 2, + 3, + 2, + 2, + 2, + 2, + 3, + 3, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 29, + 29, + 5, + 29, + 7, + 1, + 1, + 7, + 1, + 1, + 1, + 7, + 1, + 1, + 1, + 1, + 45, + 2, + 2, + 1, + 2, + 1, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 6, + 16, + 17, + 16, + 11, + 15, + 3, + 2, + 2, + 2, + 5, + 6, + 2, + 2, + 3, + 2, + 2, + 2, + 137, + 137, + 137, + 29, + 11, + 11, + 11, + 11, + 134, + 11, + 8, + 8, + 8, + 7, + 11, + 12, + 23, + 11, + 7, + 11, + 10, + 8, + 8, + 8, + 8, + 8, + 6, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 6, + 8, + 8, + 8, + 8, + 8, + 8, + 6, + 8, + 8, + 8, + 19, + 8, + 25, + 25, + 23, + 11, + 12, + 6, + 10, + 11, + 3, + 3, + 11, + 3, + 3, + 3, + 3, + 11, + 11, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 137, + 137, + 29, + 137, + 11, + 8, + 12, + 11, + 8, + 11, + 7, + 11, + 11, + 11, + 7, + 10, + 90, + 8, + 8, + 8, + 8, + 11, + 8, + 8, + 8, + 8, + 6, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 25, + 26, + 25, + 17, + 23, + 11, + 3, + 3, + 3, + 8, + 9, + 3, + 3, + 11, + 3, + 3, + 4, + 2, + 3, + 3, + 2, + 3, + 3, + 4, + 4, + 3, + 2, + 3, + 3, + 2, + 3, + 4, + 7, + 7, + 7, + 7, + 69, + 8, + 5, + 8, + 9, + 23, + 8, + 5, + 8, + 7, + 8, + 8, + 8, + 8, + 8, + 3, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 3, + 8, + 8, + 8, + 8, + 8, + 8, + 3, + 8, + 8, + 8, + 19, + 8, + 25, + 25, + 23, + 11, + 11, + 6, + 10, + 7, + 3, + 3, + 7, + 3, + 3, + 3, + 3, + 7, + 7, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 7, + 9, + 7, + 8, + 5, + 7, + 8, + 8, + 5, + 7, + 69, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 3, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 25, + 26, + 25, + 17, + 23, + 7, + 3, + 3, + 3, + 8, + 9, + 3, + 3, + 7, + 3, + 3, + 5, + 5, + 5, + 5, + 45, + 3, + 3, + 15, + 12, + 16, + 16, + 15, + 7, + 7, + 2, + 6, + 1, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 5, + 5, + 3, + 5, + 45, + 3, + 6, + 16, + 17, + 16, + 11, + 15, + 1, + 2, + 2, + 2, + 5, + 6, + 2, + 2, + 1, + 2, + 2 ], "textposition": "inside", + "type": "bar", "x": [ - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7 + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000 ], "xaxis": "x", "y": [ @@ -7611,83 +7673,128 @@ "electrician", "electrician" ], - "yaxis": "y", - "type": "bar" + "yaxis": "y" } ], "layout": { + "barmode": "overlay", + "coloraxis": { + "colorbar": { + "title": { + "text": "count" + } + }, + "colorscale": [ + [ + 0, + "rgb(237, 217, 163)" + ], + [ + 0.16666666666666666, + "rgb(246, 169, 122)" + ], + [ + 0.3333333333333333, + "rgb(250, 120, 118)" + ], + [ + 0.5, + "rgb(234, 79, 136)" + ], + [ + 0.6666666666666666, + "rgb(192, 54, 157)" + ], + [ + 0.8333333333333334, + "rgb(135, 44, 162)" + ], + [ + 1, + "rgb(75, 41, 145)" + ] + ] + }, + "legend": { + "tracegroupgap": 0 + }, "template": { "data": { - "histogram2dcontour": [ + "bar": [ { - "type": "histogram2dcontour", - "colorbar": { - "outlinewidth": 0, - "ticks": "" + "error_x": { + "color": "#2a3f5f" }, - "colorscale": [ - [ - 0.0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1.0, - "#f0f921" - ] - ] + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" } ], "choropleth": [ { - "type": "choropleth", "colorbar": { "outlinewidth": 0, "ticks": "" - } + }, + "type": "choropleth" } ], - "histogram2d": [ + "contour": [ { - "type": "histogram2d", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -7723,22 +7830,31 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" } ], "heatmap": [ { - "type": "heatmap", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -7774,22 +7890,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmap" } ], "heatmapgl": [ { - "type": "heatmapgl", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -7825,31 +7941,34 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmapgl" } ], - "contourcarpet": [ + "histogram": [ { - "type": "contourcarpet", - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" } ], - "contour": [ + "histogram2d": [ { - "type": "contour", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -7885,22 +8004,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2d" } ], - "surface": [ + "histogram2dcontour": [ { - "type": "surface", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -7936,187 +8055,192 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2dcontour" } ], "mesh3d": [ { - "type": "mesh3d", "colorbar": { "outlinewidth": 0, "ticks": "" - } - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 }, - "type": "scatter" + "type": "mesh3d" } ], "parcoords": [ { - "type": "parcoords", "line": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "parcoords" } ], - "scatterpolargl": [ + "pie": [ { - "type": "scatterpolargl", - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - } + "automargin": true, + "type": "pie" } ], - "bar": [ + "scatter": [ { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } + "fillpattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 }, - "type": "bar" + "type": "scatter" } ], - "scattergeo": [ + "scatter3d": [ { - "type": "scattergeo", + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatter3d" } ], - "scatterpolar": [ + "scattercarpet": [ { - "type": "scatterpolar", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattercarpet" } ], - "histogram": [ + "scattergeo": [ { "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 + "colorbar": { + "outlinewidth": 0, + "ticks": "" } }, - "type": "histogram" + "type": "scattergeo" } ], "scattergl": [ { - "type": "scattergl", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattergl" } ], - "scatter3d": [ + "scattermapbox": [ { - "type": "scatter3d", - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattermapbox" } ], - "scattermapbox": [ + "scatterpolar": [ { - "type": "scattermapbox", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolar" } ], - "scatterternary": [ + "scatterpolargl": [ { - "type": "scatterternary", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolargl" } ], - "scattercarpet": [ + "scatterternary": [ { - "type": "scattercarpet", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterternary" } ], - "carpet": [ + "surface": [ { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" + "colorbar": { + "outlinewidth": 0, + "ticks": "" }, - "type": "carpet" + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" } ], "table": [ @@ -8139,84 +8263,15 @@ }, "type": "table" } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } ] }, "layout": { - "autotypenumbers": "strict", - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "hovermode": "closest", - "hoverlabel": { - "align": "left" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "bgcolor": "#E5ECF6", - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "ternary": { - "bgcolor": "#E5ECF6", - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 }, + "autotypenumbers": "strict", "coloraxis": { "colorbar": { "outlinewidth": 0, @@ -8224,51 +8279,55 @@ } }, "colorscale": { - "sequential": [ + "diverging": [ [ - 0.0, - "#0d0887" + 0, + "#8e0152" ], [ - 0.1111111111111111, - "#46039f" + 0.1, + "#c51b7d" ], [ - 0.2222222222222222, - "#7201a8" + 0.2, + "#de77ae" ], [ - 0.3333333333333333, - "#9c179e" + 0.3, + "#f1b6da" ], [ - 0.4444444444444444, - "#bd3786" + 0.4, + "#fde0ef" ], [ - 0.5555555555555556, - "#d8576b" + 0.5, + "#f7f7f7" ], [ - 0.6666666666666666, - "#ed7953" + 0.6, + "#e6f5d0" ], [ - 0.7777777777777778, - "#fb9f3a" + 0.7, + "#b8e186" ], [ - 0.8888888888888888, - "#fdca26" + 0.8, + "#7fbc41" ], [ - 1.0, - "#f0f921" + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" ] ], - "sequentialminus": [ + "sequential": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -8304,106 +8363,125 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] ], - "diverging": [ + "sequentialminus": [ [ 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" + "#0d0887" ], [ - 0.2, - "#de77ae" + 0.1111111111111111, + "#46039f" ], [ - 0.3, - "#f1b6da" + 0.2222222222222222, + "#7201a8" ], [ - 0.4, - "#fde0ef" + 0.3333333333333333, + "#9c179e" ], [ - 0.5, - "#f7f7f7" + 0.4444444444444444, + "#bd3786" ], [ - 0.6, - "#e6f5d0" + 0.5555555555555556, + "#d8576b" ], [ - 0.7, - "#b8e186" + 0.6666666666666666, + "#ed7953" ], [ - 0.8, - "#7fbc41" + 0.7777777777777778, + "#fb9f3a" ], [ - 0.9, - "#4d9221" + 0.8888888888888888, + "#fdca26" ], [ 1, - "#276419" + "#f0f921" ] ] }, - "xaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" }, - "yaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "scene": { "xaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "yaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "zaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" } }, "shapedefaults": { @@ -8411,36 +8489,197 @@ "color": "#2a3f5f" } }, - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "geo": { - "bgcolor": "white", - "landcolor": "#E5ECF6", - "subunitcolor": "white", - "showland": true, - "showlakes": true, - "lakecolor": "white" + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "title": { "x": 0.05 }, - "mapbox": { - "style": "light" + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 } } }, + "title": { + "text": "Resource load by tasks - chart" + }, "xaxis": { "anchor": "y", "domain": [ - 0.0, - 1.0 + 0, + 1 ], - "type": "date", "tickangle": 75, "tickmode": "array", + "ticktext": [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + ], "tickvals": [ "2022-01-01T00:00:00", "2022-01-02T00:00:00", @@ -8576,202 +8815,47 @@ "2022-05-12T00:00:00", "2022-05-13T00:00:00" ], - "ticktext": [ - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - ] + "type": "date" }, "yaxis": { "anchor": "x", "domain": [ - 0.0, - 1.0 + 0, + 1 ], "title": { "text": "resource" } - }, - "coloraxis": { - "colorbar": { - "title": { - "text": "count" - } - }, - "colorscale": [ - [ - 0.0, - "rgb(237, 217, 163)" - ], - [ - 0.16666666666666666, - "rgb(246, 169, 122)" - ], - [ - 0.3333333333333333, - "rgb(250, 120, 118)" - ], - [ - 0.5, - "rgb(234, 79, 136)" - ], - [ - 0.6666666666666666, - "rgb(192, 54, 157)" - ], - [ - 0.8333333333333334, - "rgb(135, 44, 162)" - ], - [ - 1.0, - "rgb(75, 41, 145)" - ] - ] - }, - "legend": { - "tracegroupgap": 0 - }, - "title": { - "text": "Resource load by tasks - chart" - }, - "barmode": "overlay" - }, - "config": { - "plotlyServerURL": "https://plot.ly" + } } }, - "text/html": "
" + "text/html": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -8783,27 +8867,36 @@ "fig = resource_employment_fig(schedule=merged_schedule,\n", " fig_type=EmploymentFigType.WorkLabeled,\n", " vis_mode=VisualizationMode.ShowFig)" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "markdown", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "source": [ "### Resource employment by dates" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, "data": [ { "alignmentgroup": "True", @@ -37216,11365 +37309,11366 @@ "orientation": "h", "showlegend": false, "text": [ - 12.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 1.0, - 2.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 1.0, - 1.0, - 6.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 6.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 6.0, - 6.0, - 1.0, - 6.0, - 19.0, - 19.0, - 4.0, - 3.0, - 3.0, - 2.0, - 2.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 19.0, - 19.0, - 19.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 19.0, - 20.0, - 20.0, - 19.0, - 19.0, - 19.0, - 19.0, - 2.0, - 2.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 2.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 1.0, - 13.0, - 1.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 13.0, - 1.0, - 1.0, - 1.0, - 13.0, - 13.0, - 13.0, - 7.0, - 7.0, - 7.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 7.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 5.0, - 5.0, - 5.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 6.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 5.0, - 44.0, - 44.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 28.0, - 28.0, - 28.0, - 45.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 45.0, - 45.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 45.0, - 45.0, - 28.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 13.0, - 13.0, - 2.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 1.0, - 1.0, - 12.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 45.0, - 45.0, - 45.0, - 45.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 1.0, - 1.0, - 1.0, - 2.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 2.0, - 2.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 2.0, - 2.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 1.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 2.0, - 12.0, - 12.0, - 13.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 33.0, - 33.0, - 39.0, - 39.0, - 12.0, - 16.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 16.0, - 16.0, - 16.0, - 33.0, - 33.0, - 42.0, - 42.0, - 31.0, - 31.0, - 29.0, - 27.0, - 25.0, - 23.0, - 23.0, - 17.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 6.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 12.0, - 12.0, - 12.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 13.0, - 12.0, - 6.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 12.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 23.0, - 23.0, - 23.0, - 6.0, - 6.0, - 2.0, - 2.0, - 2.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 6.0, - 6.0, - 23.0, - 8.0, - 45.0, - 40.0, - 40.0, - 40.0, - 40.0, - 36.0, - 36.0, - 36.0, - 36.0, - 39.0, - 39.0, - 39.0, - 39.0, - 22.0, - 8.0, - 29.0, - 29.0, - 29.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 45.0, - 45.0, - 45.0, - 25.0, - 13.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 21.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 21.0, - 25.0, - 45.0, - 25.0, - 24.0, - 24.0, - 24.0, - 24.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 5.0, - 5.0, - 5.0, - 23.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 25.0, - 24.0, - 25.0, - 25.0, - 25.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 25.0, - 26.0, - 26.0, - 26.0, - 25.0, - 25.0, - 25.0, - 24.0, - 23.0, - 26.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 23.0, - 23.0, - 23.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 26.0, - 26.0, - 5.0, - 26.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 26.0, - 6.0, - 2.0, - 6.0, - 2.0, - 6.0, - 137.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 51.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 29.0, - 137.0, - 137.0, - 137.0, - 137.0, - 79.0, - 79.0, - 79.0, - 79.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 79.0, - 79.0, - 79.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 44.0, - 51.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 79.0, - 44.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 68.0, - 68.0, - 68.0, - 68.0, - 68.0, - 79.0, - 79.0, - 79.0, - 79.0, - 79.0, - 67.0, - 67.0, - 67.0, - 59.0, - 44.0, - 44.0, - 44.0, - 52.0, - 52.0, - 59.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 29.0, - 29.0, - 29.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 63.0, - 57.0, - 57.0, - 57.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 57.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 71.0, - 63.0, - 63.0, - 71.0, - 63.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 57.0, - 57.0, - 57.0, - 63.0, - 63.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 71.0, - 73.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 73.0, - 29.0, - 10.0, - 10.0, - 16.0, - 16.0, - 37.0, - 82.0, - 82.0, - 82.0, - 82.0, - 84.0, - 84.0, - 84.0, - 84.0, - 73.0, - 73.0, - 10.0, - 10.0, - 137.0, - 137.0, - 29.0, - 29.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 51.0, - 51.0, - 137.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 51.0, - 54.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 48.0, - 48.0, - 48.0, - 48.0, - 59.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 48.0, - 48.0, - 48.0, - 65.0, - 60.0, - 60.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 57.0, - 54.0, - 51.0, - 17.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 17.0, - 48.0, - 17.0, - 17.0, - 17.0, - 17.0, - 39.0, - 48.0, - 65.0, - 65.0, - 48.0, - 65.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 49.0, - 49.0, - 49.0, - 49.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 60.0, - 60.0, - 60.0, - 51.0, - 65.0, - 65.0, - 65.0, - 51.0, - 51.0, - 51.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 59.0, - 59.0, - 59.0, - 18.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 18.0, - 17.0, - 17.0, - 17.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 17.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 17.0, - 18.0, - 18.0, - 10.0, - 18.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 10.0, - 10.0, - 59.0, - 90.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 90.0, - 90.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 59.0, - 90.0, - 90.0, - 10.0, - 90.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 90.0, - 54.0, - 54.0, - 54.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 137.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 134.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 134.0, - 134.0, - 44.0, - 134.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 134.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 137.0, - 137.0, - 29.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 137.0, - 29.0, - 29.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 44.0, - 29.0, - 44.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 44.0, - 44.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 65.0, - 65.0, - 65.0, - 10.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 10.0, - 10.0, - 54.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 10.0, - 54.0, - 54.0, - 17.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 17.0, - 17.0, - 65.0, - 66.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 57.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 66.0, - 57.0, - 34.0, - 26.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 26.0, - 11.0, - 11.0, - 11.0, - 11.0, - 19.0, - 19.0, - 66.0, - 66.0, - 11.0, - 66.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 11.0, - 11.0, - 17.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 17.0, - 17.0, - 17.0, - 17.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 11.0, - 18.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 11.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 54.0, - 17.0, - 51.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 49.0, - 49.0, - 49.0, - 49.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 48.0, - 48.0, - 60.0, - 48.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 60.0, - 60.0, - 28.0, - 46.0, - 40.0, - 40.0, - 31.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 51.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 43.0, - 49.0, - 60.0, - 52.0, - 60.0, - 60.0, - 51.0, - 51.0, - 51.0, - 51.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 52.0, - 28.0, - 28.0, - 51.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 28.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 13.0, - 7.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 7.0, - 7.0, - 7.0, - 8.0, - 8.0, - 8.0, - 69.0, - 69.0, - 69.0, - 69.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 69.0, - 69.0, - 30.0, - 69.0, - 28.0, - 28.0, - 28.0, - 28.0, - 28.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 30.0, - 30.0, - 8.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 36.0, - 13.0, - 13.0, - 13.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 36.0, - 36.0, - 30.0, - 37.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 30.0, - 22.0, - 22.0, - 22.0, - 22.0, - 22.0, - 37.0, - 37.0, - 37.0, - 37.0, - 51.0, - 51.0, - 51.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 60.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 35.0, - 35.0, - 35.0, - 35.0, - 35.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 57.0, - 57.0, - 57.0, - 57.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 70.0, - 70.0, - 43.0, - 70.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 10.0, - 10.0, - 10.0, - 10.0, - 16.0, - 16.0, - 37.0, - 70.0, - 70.0, - 70.0, - 70.0, - 68.0, - 68.0, - 68.0, - 68.0, - 68.0, - 68.0, - 68.0, - 68.0, - 34.0, - 34.0, - 34.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 13.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 12.0, - 12.0, - 34.0, - 12.0, - 51.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 34.0, - 34.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 34.0, - 29.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 34.0, - 29.0, - 60.0, - 34.0, - 60.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 69.0, - 7.0, - 48.0, - 7.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 48.0, - 48.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 60.0, - 51.0, - 51.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 48.0, - 51.0, - 48.0, - 48.0, - 48.0, - 48.0, - 51.0, - 48.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 60.0, - 60.0, - 60.0, - 51.0, - 60.0, - 60.0, - 60.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 54.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 54.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 51.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 3.0, - 3.0, - 4.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 3.0, - 4.0, - 4.0, - 5.0, - 4.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 4.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 5.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 4.0, - 4.0, - 4.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 4.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 4.0, - 4.0, - 5.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 5.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 5.0, - 4.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 5.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 5.0, - 3.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 45.0, - 6.0, - 6.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 6.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 6.0, - 12.0, - 6.0, - 12.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 12.0, - 12.0, - 16.0, - 16.0, - 16.0, - 16.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 16.0, - 12.0, - 12.0, - 6.0, - 12.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 15.0, - 15.0, - 15.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 12.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 45.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 45.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 45.0, - 15.0, - 45.0, - 45.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 45.0, - 45.0, - 15.0, - 45.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 15.0, - 45.0, - 45.0, - 45.0, - 15.0, - 15.0, - 15.0, - 3.0, - 3.0, - 3.0, - 3.0, - 27.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 42.0, - 27.0, - 25.0, - 23.0, - 11.0, - 6.0, - 6.0, - 6.0, - 6.0, - 6.0, - 11.0, - 11.0, - 21.0, - 11.0, - 11.0, - 11.0, - 13.0, - 19.0, - 19.0, - 42.0, - 42.0, - 42.0, - 6.0, - 39.0, - 39.0, - 39.0, - 39.0, - 6.0, - 6.0, - 6.0, - 39.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 3.0, - 39.0, - 39.0, - 42.0, - 39.0, - 42.0, - 42.0, - 33.0, - 33.0, - 33.0, - 33.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 39.0, - 15.0, - 15.0, - 45.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 15.0, - 18.0, - 28.0, - 28.0, - 28.0, - 28.0, - 38.0, - 38.0, - 38.0, - 38.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 33.0, - 33.0, - 33.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 18.0, - 6.0, - 33.0, - 6.0, - 6.0, - 6.0, - 8.0, - 8.0, - 22.0, - 18.0, - 18.0, - 18.0, - 18.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 18.0, - 18.0, - 18.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 15.0, - 6.0, - 69.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 5.0, - 8.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 5.0, - 5.0, - 70.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 35.0, - 35.0, - 35.0, - 35.0, - 35.0, - 53.0, - 40.0, - 40.0, - 5.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 53.0, - 53.0, - 53.0, - 53.0, - 12.0, - 12.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 5.0, - 15.0, - 15.0, - 22.0, - 45.0, - 52.0, - 52.0, - 52.0, - 52.0, - 52.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 45.0, - 7.0, - 7.0, - 7.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 7.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 4.0, - 7.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 70.0, - 4.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 40.0, - 40.0, - 40.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 20.0, - 20.0, - 29.0, - 29.0, - 20.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 29.0, - 29.0, - 29.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 29.0, - 69.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 20.0, - 20.0, - 40.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 40.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 70.0, - 70.0, - 2.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 69.0, - 69.0, - 69.0, - 69.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 4.0, - 4.0, - 70.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 8.0, - 23.0, - 23.0, - 4.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 8.0, - 8.0, - 8.0, - 8.0, - 7.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 4.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 7.0, - 67.0, - 67.0, - 67.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 51.0, - 51.0, - 51.0, - 51.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 60.0, - 60.0, - 66.0, - 60.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 64.0, - 64.0, - 64.0, - 64.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 60.0, - 65.0, - 65.0, - 65.0, - 65.0, - 23.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 17.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 9.0, - 2.0, - 2.0, - 32.0, - 32.0, - 35.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 65.0, - 38.0, - 65.0, - 65.0, - 65.0, - 44.0, - 44.0, - 41.0, - 66.0, - 66.0, - 66.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 66.0, - 66.0, - 66.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 66.0, - 70.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 66.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 23.0, - 23.0, - 23.0, - 2.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 29.0, - 29.0, - 69.0, - 2.0, - 29.0, - 2.0, - 52.0, - 52.0, - 52.0, - 52.0, - 58.0, - 58.0, - 58.0, - 58.0, - 37.0, - 16.0, - 16.0, - 10.0, - 10.0, - 10.0, - 10.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 29.0, - 64.0, - 64.0, - 64.0, - 70.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 67.0, - 70.0, - 70.0, - 70.0, - 70.0, - 67.0, - 67.0, - 67.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 67.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 64.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 69.0, - 69.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 69.0, - 70.0, - 70.0, - 70.0, - 70.0, - 70.0, - 69.0, - 29.0, - 29.0, - 23.0, - 37.0, - 37.0, - 37.0, - 37.0, - 37.0, - 37.0, - 37.0, - 37.0, - 37.0, - 30.0, - 30.0, - 27.0, - 27.0, - 20.0, - 20.0, - 20.0, - 37.0, - 37.0, - 29.0, - 37.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 38.0, - 38.0, - 38.0, - 38.0, - 38.0, - 37.0, - 37.0, - 37.0, - 37.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 23.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 20.0, - 43.0, - 43.0, - 43.0, - 43.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 43.0, - 43.0, - 43.0, - 43.0, - 69.0, - 69.0, - 69.0, - 69.0, - 29.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 69.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 43.0, - 69.0 + 12, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 6, + 1, + 6, + 19, + 19, + 4, + 3, + 3, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 19, + 20, + 20, + 19, + 19, + 19, + 19, + 2, + 2, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 2, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 13, + 1, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 13, + 1, + 1, + 1, + 13, + 13, + 13, + 7, + 7, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 5, + 5, + 5, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 6, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 5, + 44, + 44, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 28, + 28, + 28, + 45, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 45, + 45, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 45, + 45, + 28, + 45, + 45, + 45, + 45, + 45, + 45, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 13, + 13, + 2, + 1, + 1, + 1, + 1, + 1, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 1, + 1, + 12, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 45, + 45, + 45, + 45, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 1, + 1, + 1, + 2, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 2, + 2, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 2, + 2, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 12, + 12, + 13, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 33, + 33, + 39, + 39, + 12, + 16, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 16, + 16, + 16, + 33, + 33, + 42, + 42, + 31, + 31, + 29, + 27, + 25, + 23, + 23, + 17, + 11, + 11, + 11, + 11, + 11, + 11, + 6, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 12, + 12, + 12, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 13, + 12, + 6, + 13, + 13, + 13, + 13, + 13, + 13, + 12, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 23, + 23, + 23, + 6, + 6, + 2, + 2, + 2, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 6, + 6, + 23, + 8, + 45, + 40, + 40, + 40, + 40, + 36, + 36, + 36, + 36, + 39, + 39, + 39, + 39, + 22, + 8, + 29, + 29, + 29, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 45, + 45, + 45, + 25, + 13, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 21, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 21, + 25, + 45, + 25, + 24, + 24, + 24, + 24, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 5, + 5, + 5, + 23, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 25, + 24, + 25, + 25, + 25, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 25, + 26, + 26, + 26, + 25, + 25, + 25, + 24, + 23, + 26, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 23, + 23, + 23, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 26, + 26, + 5, + 26, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 5, + 5, + 5, + 5, + 5, + 5, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 26, + 6, + 2, + 6, + 2, + 6, + 137, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 51, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 79, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 29, + 137, + 137, + 137, + 137, + 79, + 79, + 79, + 79, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 79, + 79, + 79, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 44, + 51, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 79, + 44, + 67, + 67, + 67, + 67, + 67, + 68, + 68, + 68, + 68, + 68, + 79, + 79, + 79, + 79, + 79, + 67, + 67, + 67, + 59, + 44, + 44, + 44, + 52, + 52, + 59, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 29, + 29, + 29, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 63, + 57, + 57, + 57, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 57, + 71, + 71, + 71, + 71, + 71, + 71, + 63, + 63, + 71, + 63, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 57, + 57, + 57, + 63, + 63, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 71, + 73, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 73, + 29, + 10, + 10, + 16, + 16, + 37, + 82, + 82, + 82, + 82, + 84, + 84, + 84, + 84, + 73, + 73, + 10, + 10, + 137, + 137, + 29, + 29, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 51, + 51, + 137, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 51, + 54, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 48, + 48, + 48, + 48, + 59, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 48, + 48, + 48, + 65, + 60, + 60, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 57, + 54, + 51, + 17, + 9, + 9, + 9, + 9, + 9, + 9, + 17, + 48, + 17, + 17, + 17, + 17, + 39, + 48, + 65, + 65, + 48, + 65, + 60, + 60, + 60, + 60, + 60, + 49, + 49, + 49, + 49, + 48, + 48, + 48, + 48, + 48, + 48, + 60, + 60, + 60, + 51, + 65, + 65, + 65, + 51, + 51, + 51, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 59, + 59, + 59, + 18, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 18, + 17, + 17, + 17, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 17, + 10, + 10, + 10, + 10, + 10, + 17, + 18, + 18, + 10, + 18, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 10, + 10, + 59, + 90, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 90, + 90, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 59, + 90, + 90, + 10, + 90, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 90, + 54, + 54, + 54, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 137, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 134, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 134, + 65, + 65, + 65, + 65, + 65, + 65, + 134, + 134, + 44, + 134, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 134, + 134, + 134, + 134, + 134, + 134, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 137, + 137, + 29, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 137, + 29, + 29, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 44, + 29, + 44, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 44, + 44, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 65, + 65, + 65, + 10, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 10, + 10, + 54, + 10, + 10, + 10, + 10, + 10, + 10, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 17, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 10, + 54, + 54, + 17, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 17, + 17, + 65, + 66, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 57, + 65, + 65, + 65, + 65, + 65, + 66, + 57, + 34, + 26, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 26, + 11, + 11, + 11, + 11, + 19, + 19, + 66, + 66, + 11, + 66, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 54, + 54, + 54, + 54, + 54, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 11, + 11, + 17, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 11, + 18, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 54, + 17, + 51, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 49, + 49, + 49, + 49, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 48, + 48, + 60, + 48, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 60, + 60, + 28, + 46, + 40, + 40, + 31, + 17, + 17, + 17, + 17, + 17, + 17, + 9, + 9, + 9, + 9, + 9, + 9, + 51, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 28, + 43, + 49, + 60, + 52, + 60, + 60, + 51, + 51, + 51, + 51, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 52, + 28, + 28, + 51, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 28, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 13, + 7, + 13, + 13, + 13, + 13, + 13, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 7, + 7, + 7, + 8, + 8, + 8, + 69, + 69, + 69, + 69, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 69, + 69, + 30, + 69, + 28, + 28, + 28, + 28, + 28, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 30, + 30, + 8, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 36, + 13, + 13, + 13, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 36, + 36, + 30, + 37, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 30, + 22, + 22, + 22, + 22, + 22, + 37, + 37, + 37, + 37, + 51, + 51, + 51, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 60, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 35, + 35, + 35, + 35, + 35, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 57, + 57, + 57, + 57, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 70, + 70, + 43, + 70, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 10, + 10, + 10, + 10, + 16, + 16, + 37, + 70, + 70, + 70, + 70, + 68, + 68, + 68, + 68, + 68, + 68, + 68, + 68, + 34, + 34, + 34, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 13, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 12, + 12, + 34, + 12, + 51, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 34, + 34, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 34, + 29, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 34, + 29, + 60, + 34, + 60, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 69, + 7, + 48, + 7, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 48, + 48, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 60, + 51, + 51, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 48, + 51, + 48, + 48, + 48, + 48, + 51, + 48, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 60, + 60, + 60, + 51, + 60, + 60, + 60, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 54, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 54, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 51, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 3, + 3, + 4, + 3, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 3, + 4, + 4, + 5, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 5, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 5, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 4, + 5, + 5, + 5, + 5, + 5, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 4, + 4, + 5, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 5, + 4, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 5, + 5, + 3, + 3, + 3, + 3, + 5, + 5, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 3, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 45, + 6, + 6, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 6, + 45, + 45, + 45, + 45, + 45, + 6, + 6, + 6, + 6, + 6, + 6, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 6, + 12, + 6, + 12, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 12, + 12, + 16, + 16, + 16, + 16, + 45, + 45, + 45, + 45, + 45, + 45, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 12, + 12, + 6, + 12, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 3, + 3, + 3, + 3, + 3, + 15, + 15, + 15, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 45, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 45, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 45, + 15, + 45, + 45, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 45, + 45, + 15, + 45, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 15, + 45, + 45, + 45, + 15, + 15, + 15, + 3, + 3, + 3, + 3, + 27, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 42, + 27, + 25, + 23, + 11, + 6, + 6, + 6, + 6, + 6, + 11, + 11, + 21, + 11, + 11, + 11, + 13, + 19, + 19, + 42, + 42, + 42, + 6, + 39, + 39, + 39, + 39, + 6, + 6, + 6, + 39, + 3, + 3, + 3, + 3, + 3, + 3, + 39, + 39, + 42, + 39, + 42, + 42, + 33, + 33, + 33, + 33, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 39, + 15, + 15, + 45, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 15, + 18, + 28, + 28, + 28, + 28, + 38, + 38, + 38, + 38, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 33, + 33, + 33, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 6, + 33, + 6, + 6, + 6, + 8, + 8, + 22, + 18, + 18, + 18, + 18, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 18, + 18, + 18, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 15, + 6, + 69, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 70, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 35, + 35, + 35, + 35, + 35, + 53, + 40, + 40, + 5, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 53, + 53, + 53, + 53, + 12, + 12, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 15, + 15, + 22, + 45, + 52, + 52, + 52, + 52, + 52, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 45, + 7, + 7, + 7, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 7, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 4, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 70, + 4, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 4, + 4, + 4, + 4, + 4, + 4, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 40, + 40, + 40, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 20, + 20, + 29, + 29, + 20, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 29, + 29, + 29, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 29, + 69, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 20, + 20, + 40, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 69, + 69, + 69, + 69, + 69, + 69, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 69, + 69, + 69, + 69, + 69, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 40, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 70, + 70, + 2, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 69, + 69, + 69, + 69, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 4, + 4, + 70, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 23, + 23, + 4, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 8, + 8, + 8, + 8, + 7, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 67, + 67, + 67, + 60, + 60, + 60, + 60, + 60, + 60, + 60, + 51, + 51, + 51, + 51, + 65, + 65, + 65, + 65, + 65, + 60, + 60, + 66, + 60, + 66, + 66, + 66, + 66, + 66, + 64, + 64, + 64, + 64, + 60, + 60, + 60, + 60, + 60, + 60, + 65, + 65, + 65, + 65, + 23, + 17, + 17, + 17, + 17, + 17, + 17, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 32, + 32, + 35, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 65, + 38, + 65, + 65, + 65, + 44, + 44, + 41, + 66, + 66, + 66, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 66, + 66, + 66, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 66, + 70, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 66, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 23, + 23, + 23, + 2, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 29, + 29, + 69, + 2, + 29, + 2, + 52, + 52, + 52, + 52, + 58, + 58, + 58, + 58, + 37, + 16, + 16, + 10, + 10, + 10, + 10, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 29, + 64, + 64, + 64, + 70, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 67, + 70, + 70, + 70, + 70, + 67, + 67, + 67, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 67, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 64, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 69, + 69, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 70, + 69, + 70, + 70, + 70, + 70, + 70, + 69, + 29, + 29, + 23, + 37, + 37, + 37, + 37, + 37, + 37, + 37, + 37, + 37, + 30, + 30, + 27, + 27, + 20, + 20, + 20, + 37, + 37, + 29, + 37, + 43, + 43, + 43, + 43, + 43, + 43, + 38, + 38, + 38, + 38, + 38, + 37, + 37, + 37, + 37, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 23, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 20, + 43, + 43, + 43, + 43, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 43, + 43, + 43, + 43, + 69, + 69, + 69, + 69, + 29, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 69, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 43, + 69 ], "textposition": "inside", + "type": "bar", "x": [ - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7, - 8.64E7 + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000, + 86400000 ], "xaxis": "x", "y": [ @@ -54257,83 +54351,128 @@ "driver", "driver" ], - "yaxis": "y", - "type": "bar" + "yaxis": "y" } ], "layout": { + "barmode": "overlay", + "coloraxis": { + "colorbar": { + "title": { + "text": "count" + } + }, + "colorscale": [ + [ + 0, + "rgb(237, 217, 163)" + ], + [ + 0.16666666666666666, + "rgb(246, 169, 122)" + ], + [ + 0.3333333333333333, + "rgb(250, 120, 118)" + ], + [ + 0.5, + "rgb(234, 79, 136)" + ], + [ + 0.6666666666666666, + "rgb(192, 54, 157)" + ], + [ + 0.8333333333333334, + "rgb(135, 44, 162)" + ], + [ + 1, + "rgb(75, 41, 145)" + ] + ] + }, + "legend": { + "tracegroupgap": 0 + }, "template": { "data": { - "histogram2dcontour": [ + "bar": [ { - "type": "histogram2dcontour", - "colorbar": { - "outlinewidth": 0, - "ticks": "" + "error_x": { + "color": "#2a3f5f" }, - "colorscale": [ - [ - 0.0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1.0, - "#f0f921" - ] - ] + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" } ], "choropleth": [ { - "type": "choropleth", "colorbar": { "outlinewidth": 0, "ticks": "" - } + }, + "type": "choropleth" } ], - "histogram2d": [ + "contour": [ { - "type": "histogram2d", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54369,22 +54508,31 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" } ], "heatmap": [ { - "type": "heatmap", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54420,22 +54568,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmap" } ], "heatmapgl": [ { - "type": "heatmapgl", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54471,31 +54619,34 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "heatmapgl" } ], - "contourcarpet": [ + "histogram": [ { - "type": "contourcarpet", - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" } ], - "contour": [ + "histogram2d": [ { - "type": "contour", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54531,22 +54682,22 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2d" } ], - "surface": [ + "histogram2dcontour": [ { - "type": "surface", "colorbar": { "outlinewidth": 0, "ticks": "" }, "colorscale": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54582,19 +54733,37 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] - ] + ], + "type": "histogram2dcontour" } ], "mesh3d": [ { - "type": "mesh3d", "colorbar": { "outlinewidth": 0, "ticks": "" - } + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" } ], "scatter": [ @@ -54607,162 +54776,149 @@ "type": "scatter" } ], - "parcoords": [ + "scatter3d": [ { - "type": "parcoords", "line": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "scatterpolargl": [ - { - "type": "scatterpolargl", + }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } }, - "type": "bar" + "type": "scatter3d" } ], - "scattergeo": [ + "scattercarpet": [ { - "type": "scattergeo", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattercarpet" } ], - "scatterpolar": [ + "scattergeo": [ { - "type": "scatterpolar", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } }, - "type": "histogram" + "type": "scattergeo" } ], "scattergl": [ { - "type": "scattergl", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattergl" } ], - "scatter3d": [ + "scattermapbox": [ { - "type": "scatter3d", - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scattermapbox" } ], - "scattermapbox": [ + "scatterpolar": [ { - "type": "scattermapbox", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolar" } ], - "scatterternary": [ + "scatterpolargl": [ { - "type": "scatterternary", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterpolargl" } ], - "scattercarpet": [ + "scatterternary": [ { - "type": "scattercarpet", "marker": { "colorbar": { "outlinewidth": 0, "ticks": "" } - } + }, + "type": "scatterternary" } ], - "carpet": [ + "surface": [ { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" + "colorbar": { + "outlinewidth": 0, + "ticks": "" }, - "type": "carpet" + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" } ], "table": [ @@ -54785,84 +54941,15 @@ }, "type": "table" } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } ] }, "layout": { - "autotypenumbers": "strict", - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "hovermode": "closest", - "hoverlabel": { - "align": "left" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "bgcolor": "#E5ECF6", - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "ternary": { - "bgcolor": "#E5ECF6", - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 }, + "autotypenumbers": "strict", "coloraxis": { "colorbar": { "outlinewidth": 0, @@ -54870,51 +54957,55 @@ } }, "colorscale": { - "sequential": [ + "diverging": [ [ - 0.0, - "#0d0887" + 0, + "#8e0152" ], [ - 0.1111111111111111, - "#46039f" + 0.1, + "#c51b7d" ], [ - 0.2222222222222222, - "#7201a8" + 0.2, + "#de77ae" ], [ - 0.3333333333333333, - "#9c179e" + 0.3, + "#f1b6da" ], [ - 0.4444444444444444, - "#bd3786" + 0.4, + "#fde0ef" ], [ - 0.5555555555555556, - "#d8576b" + 0.5, + "#f7f7f7" ], [ - 0.6666666666666666, - "#ed7953" + 0.6, + "#e6f5d0" ], [ - 0.7777777777777778, - "#fb9f3a" + 0.7, + "#b8e186" ], [ - 0.8888888888888888, - "#fdca26" + 0.8, + "#7fbc41" ], [ - 1.0, - "#f0f921" + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" ] ], - "sequentialminus": [ + "sequential": [ [ - 0.0, + 0, "#0d0887" ], [ @@ -54950,106 +55041,125 @@ "#fdca26" ], [ - 1.0, + 1, "#f0f921" ] ], - "diverging": [ + "sequentialminus": [ [ 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" + "#0d0887" ], [ - 0.2, - "#de77ae" + 0.1111111111111111, + "#46039f" ], [ - 0.3, - "#f1b6da" + 0.2222222222222222, + "#7201a8" ], [ - 0.4, - "#fde0ef" + 0.3333333333333333, + "#9c179e" ], [ - 0.5, - "#f7f7f7" + 0.4444444444444444, + "#bd3786" ], [ - 0.6, - "#e6f5d0" + 0.5555555555555556, + "#d8576b" ], [ - 0.7, - "#b8e186" + 0.6666666666666666, + "#ed7953" ], [ - 0.8, - "#7fbc41" + 0.7777777777777778, + "#fb9f3a" ], [ - 0.9, - "#4d9221" + 0.8888888888888888, + "#fdca26" ], [ 1, - "#276419" + "#f0f921" ] ] }, - "xaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" }, - "yaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" }, - "zerolinecolor": "white", - "automargin": true, - "zerolinewidth": 2 + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "scene": { "xaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "yaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" }, "zaxis": { "backgroundcolor": "#E5ECF6", "gridcolor": "white", + "gridwidth": 2, "linecolor": "white", "showbackground": true, "ticks": "", - "zerolinecolor": "white", - "gridwidth": 2 + "zerolinecolor": "white" } }, "shapedefaults": { @@ -55057,95 +55167,101 @@ "color": "#2a3f5f" } }, - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "geo": { - "bgcolor": "white", - "landcolor": "#E5ECF6", - "subunitcolor": "white", - "showland": true, - "showlakes": true, - "lakecolor": "white" + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } }, "title": { "x": 0.05 }, - "mapbox": { - "style": "light" + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 } } }, + "title": { + "text": "Resource load by days - chart" + }, "xaxis": { "anchor": "y", "domain": [ - 0.0, - 1.0 + 0, + 1 ], "type": "date" }, "yaxis": { "anchor": "x", "domain": [ - 0.0, - 1.0 + 0, + 1 ], "title": { "text": "resource" } - }, - "coloraxis": { - "colorbar": { - "title": { - "text": "count" - } - }, - "colorscale": [ - [ - 0.0, - "rgb(237, 217, 163)" - ], - [ - 0.16666666666666666, - "rgb(246, 169, 122)" - ], - [ - 0.3333333333333333, - "rgb(250, 120, 118)" - ], - [ - 0.5, - "rgb(234, 79, 136)" - ], - [ - 0.6666666666666666, - "rgb(192, 54, 157)" - ], - [ - 0.8333333333333334, - "rgb(135, 44, 162)" - ], - [ - 1.0, - "rgb(75, 41, 145)" - ] - ] - }, - "legend": { - "tracegroupgap": 0 - }, - "title": { - "text": "Resource load by days - chart" - }, - "barmode": "overlay" - }, - "config": { - "plotlyServerURL": "https://plot.ly" + } } }, - "text/html": "
" + "text/html": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -55157,40 +55273,40 @@ "fig = resource_employment_fig(schedule=merged_schedule,\n", " fig_type=EmploymentFigType.DateLabeled,\n", " vis_mode=VisualizationMode.ShowFig)" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": 6, - "outputs": [], - "source": [], "metadata": { - "collapsed": false - } + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/experiments/neural_network/nn2ma.ipynb b/experiments/neural_network/nn2ma.ipynb index a0b9ec98..c87fadfb 100644 --- a/experiments/neural_network/nn2ma.ipynb +++ b/experiments/neural_network/nn2ma.ipynb @@ -4,7 +4,10 @@ "cell_type": "code", "execution_count": 3, "metadata": { - "collapsed": true + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } }, "outputs": [ { @@ -137,6 +140,12 @@ { "cell_type": "code", "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -287,7 +296,7 @@ " outputs = model(encoding)\n", " _, predicted = torch.max(outputs.data, 0)\n", " # use predicted scheduler to generate schedule\n", - " nn_result = schedulers[predicted].schedule(wg, contractors).execution_time\n", + " nn_result = schedulers[predicted].schedule(wg, contractors)[0].execution_time\n", " nn_time = time.time() - nn_start\n", "\n", " agents = [Agent(str(scheduler), scheduler, deepcopy(contractors)) for scheduler in schedulers]\n", @@ -302,40 +311,40 @@ " print(f'Prediction mismatch | predicted: {schedulers[predicted]}, actual: {block_schedule[0].agent.scheduler}')\n", "\n", " print(f'{block_schedule[0].agent.scheduler} {nn_result} | {nn_time} ---- {ma_result} | {ma_time} ------------- {int(ma_time / nn_time * 100)}% time win | {int((1 - ma_result / nn_result) * 100)}% result loss')\n" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", "execution_count": null, - "outputs": [], - "source": [], "metadata": { - "collapsed": false - } + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 4 } diff --git a/experiments/stochastic_productivity.ipynb b/experiments/stochastic_productivity.ipynb index 74190047..2be97385 100644 --- a/experiments/stochastic_productivity.ipynb +++ b/experiments/stochastic_productivity.ipynb @@ -5,10 +5,13 @@ "execution_count": 7, "id": "initial_id", "metadata": { - "collapsed": true, "ExecuteTime": { "end_time": "2024-01-10T14:57:53.195805200Z", "start_time": "2024-01-10T14:57:53.021874400Z" + }, + "collapsed": true, + "jupyter": { + "outputs_hidden": true } }, "outputs": [ @@ -49,6 +52,17 @@ { "cell_type": "code", "execution_count": 8, + "id": "dc9efaa64c64805c", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T14:57:53.414491600Z", + "start_time": "2024-01-10T14:57:53.398842800Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "from sampo.schemas import WorkerProductivityMode, Contractor, IntervalGaussian\n", @@ -83,23 +97,28 @@ " # validate_block_schedule(bg, scheduled_blocks, agents)\n", " \n", " return finish_time(scheduled_blocks.values())" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T14:57:53.414491600Z", - "start_time": "2024-01-10T14:57:53.398842800Z" - } - }, - "id": "dc9efaa64c64805c" + ] }, { "cell_type": "code", "execution_count": 39, + "id": "892c5caca2db4070", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T13:50:18.412168100Z", + "start_time": "2024-01-10T13:50:07.170123400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { - "text/plain": "9633" + "text/plain": [ + "9633" + ] }, "execution_count": 39, "metadata": {}, @@ -109,23 +128,28 @@ "source": [ "time_static = test_with_manager(Manager, WorkerProductivityMode.Stochastic)\n", "time_static" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T13:50:18.412168100Z", - "start_time": "2024-01-10T13:50:07.170123400Z" - } - }, - "id": "892c5caca2db4070" + ] }, { "cell_type": "code", "execution_count": 40, + "id": "508802b6eeb1919f", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T13:50:29.334349700Z", + "start_time": "2024-01-10T13:50:18.396234400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { - "text/plain": "4531" + "text/plain": [ + "4531" + ] }, "execution_count": 40, "metadata": {}, @@ -135,19 +159,22 @@ "source": [ "time_stochastic = test_with_manager(StochasticManager, WorkerProductivityMode.Stochastic)\n", "time_stochastic" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T13:50:29.334349700Z", - "start_time": "2024-01-10T13:50:18.396234400Z" - } - }, - "id": "508802b6eeb1919f" + ] }, { "cell_type": "code", "execution_count": 41, + "id": "9f35554d8eadd2f5", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T13:54:17.130759300Z", + "start_time": "2024-01-10T13:50:36.091768900Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -179,33 +206,41 @@ " print(f'Success percentage: {int(100 * successes / iterations)}% on {iterations} iterations')\n", "\n", "run_comparison(10)" - ], + ] + }, + { + "cell_type": "markdown", + "id": "c02818c9a8da177f", "metadata": { "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T13:54:17.130759300Z", - "start_time": "2024-01-10T13:50:36.091768900Z" + "jupyter": { + "outputs_hidden": false } }, - "id": "9f35554d8eadd2f5" - }, - { - "cell_type": "markdown", "source": [ "# Mode 2" - ], - "metadata": { - "collapsed": false - }, - "id": "c02818c9a8da177f" + ] }, { "cell_type": "code", "execution_count": 15, + "id": "fe8132da983728a3", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T13:36:56.920531500Z", + "start_time": "2024-01-10T13:36:44.589117500Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "data": { - "text/plain": "2540" + "text/plain": [ + "2540" + ] }, "execution_count": 15, "metadata": {}, @@ -214,19 +249,22 @@ ], "source": [ "test_with_manager(Manager, WorkerProductivityMode.Stochastic)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T13:36:56.920531500Z", - "start_time": "2024-01-10T13:36:44.589117500Z" - } - }, - "id": "fe8132da983728a3" + ] }, { "cell_type": "code", "execution_count": 9, + "id": "86dc256854b80187", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T14:57:59.667013900Z", + "start_time": "2024-01-10T14:57:59.651362500Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [], "source": [ "def test_in_mode(mode: WorkerProductivityMode):\n", @@ -253,37 +291,43 @@ " conjuncted = bg.to_work_graph()\n", " print(f'Size: {conjuncted.vertex_count}')\n", " scheduler = HEFTScheduler(work_estimator=work_estimator)\n", - " conjuncted_time = scheduler.schedule(conjuncted, [contractors[-1]]).execution_time\n", + " conjuncted_time = scheduler.schedule(conjuncted, [contractors[-1]])[0].execution_time\n", " return ma_time, conjuncted_time" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T14:57:59.667013900Z", - "start_time": "2024-01-10T14:57:59.651362500Z" - } - }, - "id": "86dc256854b80187" + ] }, { "cell_type": "code", "execution_count": 4, - "outputs": [], - "source": [ - "# test_in_mode(WorkerProductivityMode.Static)" - ], + "id": "753ca71d12335121", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-01-10T14:18:27.516893100Z", "start_time": "2024-01-10T14:18:27.501242Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false } }, - "id": "753ca71d12335121" + "outputs": [], + "source": [ + "# test_in_mode(WorkerProductivityMode.Static)" + ] }, { "cell_type": "code", "execution_count": 10, + "id": "b511753dfcb6d6ae", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T14:58:33.720762500Z", + "start_time": "2024-01-10T14:58:01.966436Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -294,7 +338,9 @@ }, { "data": { - "text/plain": "(3662, 3610)" + "text/plain": [ + "(3662, 3610)" + ] }, "execution_count": 10, "metadata": {}, @@ -303,19 +349,22 @@ ], "source": [ "test_in_mode(WorkerProductivityMode.Stochastic)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T14:58:33.720762500Z", - "start_time": "2024-01-10T14:58:01.966436Z" - } - }, - "id": "b511753dfcb6d6ae" + ] }, { "cell_type": "code", "execution_count": 11, + "id": "25186a283ee93416", + "metadata": { + "ExecuteTime": { + "end_time": "2024-01-10T15:04:11.439850500Z", + "start_time": "2024-01-10T14:58:50.304622400Z" + }, + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, "outputs": [ { "name": "stdout", @@ -347,44 +396,39 @@ "source": [ "for _ in range(10):\n", " print(test_in_mode(WorkerProductivityMode.Stochastic))" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-10T15:04:11.439850500Z", - "start_time": "2024-01-10T14:58:50.304622400Z" - } - }, - "id": "25186a283ee93416" + ] }, { "cell_type": "code", "execution_count": null, - "outputs": [], - "source": [], + "id": "19fe5ec1ed605676", "metadata": { - "collapsed": false + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } }, - "id": "19fe5ec1ed605676" + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.12.2" } }, "nbformat": 4, From 8d04f7ea7a4b3a0a2233f6b1c17aebe7605670b6 Mon Sep 17 00:00:00 2001 From: Egor Date: Wed, 14 Feb 2024 16:21:15 +0300 Subject: [PATCH 31/31] fix notebooks --- examples/simple_generation.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/simple_generation.ipynb b/examples/simple_generation.ipynb index b547cd6d..8c311485 100644 --- a/examples/simple_generation.ipynb +++ b/examples/simple_generation.ipynb @@ -690,7 +690,7 @@ " .wg(simple_wg) \\\n", " .contractors(contractors) \\\n", " .schedule(scheduler) \\\n", - " .finish[0]\n", + " .finish()[0]\n", "\n", "project.schedule.execution_time" ]