diff --git a/constants.py b/constants.py index c71d895a..b6bb6f14 100644 --- a/constants.py +++ b/constants.py @@ -63,12 +63,12 @@ RIGHT_SIDE = SPACE_WIDTH*RIGHT # Change this to point to where you want # animation files to output MOVIE_DIR = os.path.join(os.path.expanduser('~'), "Dropbox/3b1b_videos/animations/") +STAGED_SCENES_DIR = os.path.join(MOVIE_DIR, "staged_scenes") ### THIS_DIR = os.path.dirname(os.path.realpath(__file__)) FILE_DIR = os.path.join(THIS_DIR, "files") IMAGE_DIR = os.path.join(FILE_DIR, "images") GIF_DIR = os.path.join(FILE_DIR, "gifs") -STAGED_SCENES_DIR = os.path.join(FILE_DIR, "staged_scenes") TEX_DIR = os.path.join(FILE_DIR, "Tex") TEX_IMAGE_DIR = os.path.join(IMAGE_DIR, "Tex") MOBJECT_DIR = os.path.join(FILE_DIR, "mobjects") diff --git a/nn/network.py b/nn/network.py index 2d3a3c74..24104141 100644 --- a/nn/network.py +++ b/nn/network.py @@ -21,13 +21,14 @@ import cPickle from nn.mnist_loader import load_data_wrapper NN_DIRECTORY = os.path.dirname(os.path.realpath(__file__)) +# PRETRAINED_DATA_FILE = os.path.join(NN_DIRECTORY, "pretrained_weights_and_biases_36") PRETRAINED_DATA_FILE = os.path.join(NN_DIRECTORY, "pretrained_weights_and_biases") IMAGE_MAP_DATA_FILE = os.path.join(NN_DIRECTORY, "image_map") # PRETRAINED_DATA_FILE = "/Users/grant/cs/manim/nn/pretrained_weights_and_biases_on_zero" +# DEFAULT_LAYER_SIZES = [28**2, 36, 10] DEFAULT_LAYER_SIZES = [28**2, 16, 16, 10] class Network(object): - def __init__(self, sizes): """The list ``sizes`` contains the number of neurons in the respective layers of the network. For example, if the list @@ -192,12 +193,12 @@ def test_network(): network = get_pretrained_network() training_data, validation_data, test_data = load_data_wrapper() n_right, n_wrong = 0, 0 - for test_in, test_out in test_data[:30]: + for test_in, test_out in test_data: if np.argmax(network.feedforward(test_in)) == test_out: n_right += 1 else: n_wrong += 1 - print float(n_right)/(n_right + n_wrong) + print n_right, n_wrong, float(n_right)/(n_right + n_wrong) def layer_to_image_array(layer): w = int(np.ceil(np.sqrt(len(layer)))) diff --git a/nn/part1.py b/nn/part1.py new file mode 100644 index 00000000..489a25a2 --- /dev/null +++ b/nn/part1.py @@ -0,0 +1,4248 @@ +import sys +import os.path +import cv2 + +sys.path.append(os.path.join(os.path.dirname(__file__), '..')) +from helpers import * + +from mobject.tex_mobject import TexMobject +from mobject import Mobject, Group +from mobject.image_mobject import ImageMobject +from mobject.vectorized_mobject import * + +from animation.animation import Animation +from animation.transform import * +from animation.simple_animations import * +from animation.playground import * +from animation.continual_animation import * +from topics.geometry import * +from topics.characters import * +from topics.functions import * +from topics.fractals import * +from topics.number_line import * +from topics.combinatorics import * +from topics.numerals import * +from topics.three_dimensions import * +from topics.objects import * +from topics.probability import * +from topics.complex_numbers import * +from topics.graph_scene import * +from topics.common_scenes import * +from scene import Scene +from scene.reconfigurable_scene import ReconfigurableScene +from scene.zoomed_scene import * +from camera import Camera +from mobject.svg_mobject import * +from mobject.tex_mobject import * + +from nn.network import * + +#force_skipping +#revert_to_original_skipping_status + + +DEFAULT_GAUSS_BLUR_CONFIG = { + "ksize" : (5, 5), + "sigmaX" : 10, + "sigmaY" : 10, +} + +DEFAULT_CANNY_CONFIG = { + "threshold1" : 100, + "threshold2" : 200, +} + + +def get_edges(image_array): + blurred = cv2.GaussianBlur( + image_array, + **DEFAULT_GAUSS_BLUR_CONFIG + ) + edges = cv2.Canny( + blurred, + **DEFAULT_CANNY_CONFIG + ) + return edges + +class WrappedImage(Group): + CONFIG = { + "rect_kwargs" : { + "color" : BLUE, + "buff" : SMALL_BUFF, + } + } + def __init__(self, image_mobject, **kwargs): + Group.__init__(self, **kwargs) + rect = SurroundingRectangle( + image_mobject, **self.rect_kwargs + ) + self.add(rect, image_mobject) + +class PixelsAsSquares(VGroup): + CONFIG = { + "height" : 2, + } + def __init__(self, image_mobject, **kwargs): + VGroup.__init__(self, **kwargs) + for row in image_mobject.pixel_array: + for rgba in row: + square = Square( + stroke_width = 0, + fill_opacity = rgba[3]/255.0, + fill_color = rgba_to_color(rgba/255.0), + ) + self.add(square) + self.arrange_submobjects_in_grid( + *image_mobject.pixel_array.shape[:2], + buff = 0 + ) + self.replace(image_mobject) + +class PixelsFromVect(PixelsAsSquares): + def __init__(self, vect, **kwargs): + PixelsAsSquares.__init__(self, + ImageMobject(layer_to_image_array(vect)), + **kwargs + ) + +class MNistMobject(WrappedImage): + def __init__(self, vect, **kwargs): + WrappedImage.__init__(self, + ImageMobject(layer_to_image_array(vect)), + **kwargs + ) + +class NetworkMobject(VGroup): + CONFIG = { + "neuron_radius" : 0.15, + "neuron_to_neuron_buff" : MED_SMALL_BUFF, + "layer_to_layer_buff" : LARGE_BUFF, + "neuron_stroke_color" : BLUE, + "neuron_stroke_width" : 3, + "neuron_fill_color" : GREEN, + "edge_color" : LIGHT_GREY, + "edge_stroke_width" : 2, + "edge_propogation_color" : GREEN, + "edge_propogation_time" : 1, + "max_shown_neurons" : 16, + "brace_for_large_layers" : True, + "average_shown_activation_of_large_layer" : True, + } + def __init__(self, neural_network, **kwargs): + VGroup.__init__(self, **kwargs) + self.neural_network = neural_network + self.layer_sizes = neural_network.sizes + self.add_neurons() + self.add_edges() + + def add_neurons(self): + layers = VGroup(*[ + self.get_layer(size) + for size in self.layer_sizes + ]) + layers.arrange_submobjects(RIGHT, buff = self.layer_to_layer_buff) + self.layers = layers + self.add(self.layers) + + def get_layer(self, size): + layer = VGroup() + n_neurons = size + if n_neurons > self.max_shown_neurons: + n_neurons = self.max_shown_neurons + neurons = VGroup(*[ + Circle( + radius = self.neuron_radius, + stroke_color = self.neuron_stroke_color, + stroke_width = self.neuron_stroke_width, + fill_color = self.neuron_fill_color, + fill_opacity = 0, + ) + for x in range(n_neurons) + ]) + neurons.arrange_submobjects( + DOWN, buff = self.neuron_to_neuron_buff + ) + for neuron in neurons: + neuron.edges_in = VGroup() + neuron.edges_out = VGroup() + layer.neurons = neurons + layer.add(neurons) + + if size > n_neurons: + dots = TexMobject("\\vdots") + dots.move_to(neurons) + VGroup(*neurons[:len(neurons)/2]).next_to( + dots, UP, MED_SMALL_BUFF + ) + VGroup(*neurons[len(neurons)/2:]).next_to( + dots, DOWN, MED_SMALL_BUFF + ) + layer.dots = dots + layer.add(dots) + if self.brace_for_large_layers: + brace = Brace(layer, LEFT) + brace_label = brace.get_tex(str(size)) + layer.brace = brace + layer.brace_label = brace_label + layer.add(brace, brace_label) + + return layer + + def add_edges(self): + self.edge_groups = VGroup() + for l1, l2 in zip(self.layers[:-1], self.layers[1:]): + edge_group = VGroup() + for n1, n2 in it.product(l1.neurons, l2.neurons): + edge = Line( + n1.get_center(), + n2.get_center(), + buff = self.neuron_radius, + stroke_color = self.edge_color, + stroke_width = self.edge_stroke_width, + ) + edge_group.add(edge) + n1.edges_out.add(edge) + n2.edges_in.add(edge) + self.edge_groups.add(edge_group) + self.add_to_back(self.edge_groups) + + def get_active_layer(self, layer_index, activation_vector): + layer = self.layers[layer_index].deepcopy() + n_neurons = len(layer.neurons) + av = activation_vector + def arr_to_num(arr): + return (np.sum(arr > 0.1) / float(len(arr)))**(1./3) + + if len(av) > n_neurons: + if self.average_shown_activation_of_large_layer: + indices = np.arange(n_neurons) + indices *= int(len(av)/n_neurons) + indices = list(indices) + indices.append(len(av)) + av = np.array([ + arr_to_num(av[i1:i2]) + for i1, i2 in zip(indices[:-1], indices[1:]) + ]) + else: + av = np.append( + av[:n_neurons/2], + av[-n_neurons/2:], + ) + for activation, neuron in zip(av, layer.neurons): + neuron.set_fill( + color = self.neuron_fill_color, + opacity = activation + ) + return layer + + def deactivate_layers(self): + all_neurons = VGroup(*it.chain(*[ + layer.neurons + for layer in self.layers + ])) + all_neurons.set_fill(opacity = 0) + return self + + def get_edge_propogation_animations(self, index): + edge_group_copy = self.edge_groups[index].copy() + edge_group_copy.set_stroke( + self.edge_propogation_color, + width = 1.5*self.edge_stroke_width + ) + return [ShowCreationThenDestruction( + edge_group_copy, + run_time = self.edge_propogation_time, + submobject_mode = "lagged_start" + )] + +class MNistNetworkMobject(NetworkMobject): + CONFIG = { + "neuron_to_neuron_buff" : SMALL_BUFF, + "layer_to_layer_buff" : 1.5, + "edge_stroke_width" : 1, + } + + def __init__(self, **kwargs): + network = get_pretrained_network() + NetworkMobject.__init__(self, network, **kwargs) + self.add_output_labels() + + def add_output_labels(self): + self.output_labels = VGroup() + for n, neuron in enumerate(self.layers[-1].neurons): + label = TexMobject(str(n)) + label.scale_to_fit_height(0.75*neuron.get_height()) + label.move_to(neuron) + label.shift(neuron.get_width()*RIGHT) + self.output_labels.add(label) + self.add(self.output_labels) + +class NetworkScene(Scene): + CONFIG = { + "layer_sizes" : [8, 6, 6, 4], + "network_mob_config" : {}, + } + def setup(self): + self.add_network() + + def add_network(self): + self.network = Network(sizes = self.layer_sizes) + self.network_mob = NetworkMobject( + self.network, + **self.network_mob_config + ) + self.add(self.network_mob) + + def feed_forward(self, input_vector, false_confidence = False, added_anims = None): + if added_anims is None: + added_anims = [] + activations = self.network.get_activation_of_all_layers( + input_vector + ) + if false_confidence: + i = np.argmax(activations[-1]) + activations[-1] *= 0 + activations[-1][i] = 1.0 + for i, activation in enumerate(activations): + self.show_activation_of_layer(i, activation, added_anims) + added_anims = [] + + def show_activation_of_layer(self, layer_index, activation_vector, added_anims = None): + if added_anims is None: + added_anims = [] + layer = self.network_mob.layers[layer_index] + active_layer = self.network_mob.get_active_layer( + layer_index, activation_vector + ) + anims = [Transform(layer, active_layer)] + if layer_index > 0: + anims += self.network_mob.get_edge_propogation_animations( + layer_index-1 + ) + anims += added_anims + self.play(*anims) + + def remove_random_edges(self, prop = 0.9): + for edge_group in self.network_mob.edge_groups: + for edge in list(edge_group): + if np.random.random() < prop: + edge_group.remove(edge) + +def make_transparent(image_mob): + alpha_vect = np.array( + image_mob.pixel_array[:,:,0], + dtype = 'uint8' + ) + image_mob.highlight(WHITE) + image_mob.pixel_array[:,:,3] = alpha_vect + return image_mob + +############################### + +class ExampleThrees(PiCreatureScene): + def construct(self): + self.show_initial_three() + self.show_alternate_threes() + self.resolve_remaining_threes() + self.show_alternate_digits() + + def show_initial_three(self): + randy = self.pi_creature + + self.three_mobs = self.get_three_mobs() + three_mob = self.three_mobs[0] + three_mob_copy = three_mob[1].copy() + three_mob_copy.sort_submobjects(lambda p : np.dot(p, DOWN+RIGHT)) + + braces = VGroup(*[Brace(three_mob, v) for v in LEFT, UP]) + brace_labels = VGroup(*[ + brace.get_text("28px") + for brace in braces + ]) + + bubble = randy.get_bubble(height = 4, width = 6) + three_mob.generate_target() + three_mob.target.scale_to_fit_height(1) + three_mob.target.next_to(bubble[-1].get_left(), RIGHT, LARGE_BUFF) + arrow = Arrow(LEFT, RIGHT, color = BLUE) + arrow.next_to(three_mob.target, RIGHT) + real_three = TexMobject("3") + real_three.scale_to_fit_height(0.8) + real_three.next_to(arrow, RIGHT) + + self.play( + FadeIn(three_mob[0]), + LaggedStart(FadeIn, three_mob[1]) + ) + self.dither() + self.play( + LaggedStart( + DrawBorderThenFill, three_mob_copy, + run_time = 3, + stroke_color = WHITE, + remover = True, + ), + randy.change, "sassy", + *it.chain( + map(GrowFromCenter, braces), + map(FadeIn, brace_labels) + ) + ) + self.dither() + self.play( + ShowCreation(bubble), + MoveToTarget(three_mob), + FadeOut(braces), + FadeOut(brace_labels), + randy.change, "pondering" + ) + self.play( + ShowCreation(arrow), + Write(real_three) + ) + self.dither() + + self.bubble = bubble + self.arrow = arrow + self.real_three = real_three + + def show_alternate_threes(self): + randy = self.pi_creature + + three = self.three_mobs[0] + three.generate_target() + three.target[0].set_fill(opacity = 0, family = False) + for square in three.target[1]: + yellow_rgb = color_to_rgb(YELLOW) + square_rgb = color_to_rgb(square.get_fill_color()) + square.set_fill( + rgba_to_color(yellow_rgb*square_rgb), + opacity = 0.5 + ) + + alt_threes = VGroup(*self.three_mobs[1:]) + alt_threes.arrange_submobjects(DOWN) + alt_threes.scale_to_fit_height(2*SPACE_HEIGHT - 2) + alt_threes.to_edge(RIGHT) + + for alt_three in alt_threes: + self.add(alt_three) + self.dither(0.5) + self.play( + randy.change, "plain", + *map(FadeOut, [ + self.bubble, self.arrow, self.real_three + ]) + [MoveToTarget(three)] + ) + for alt_three in alt_threes[:2]: + self.play(three.replace, alt_three) + self.dither() + for moving_three in three, alt_threes[1]: + moving_three.generate_target() + moving_three.target.next_to(alt_threes, LEFT, LARGE_BUFF) + moving_three.target[0].set_stroke(width = 0) + moving_three.target[1].space_out_submobjects(1.5) + self.play(MoveToTarget( + moving_three, submobject_mode = "lagged_start" + )) + self.play( + Animation(randy), + moving_three.replace, randy.eyes[1], + moving_three.scale_in_place, 0.7, + run_time = 2, + submobject_mode = "lagged_start", + ) + self.play( + Animation(randy), + FadeOut(moving_three) + ) + + self.remaining_threes = [alt_threes[0], alt_threes[2]] + + def resolve_remaining_threes(self): + randy = self.pi_creature + + left_three, right_three = self.remaining_threes + equals = TexMobject("=") + equals.move_to(self.arrow) + for three, vect in (left_three, LEFT), (right_three, RIGHT): + three.generate_target() + three.target.scale_to_fit_height(1) + three.target.next_to(equals, vect) + + self.play( + randy.change, "thinking", + ShowCreation(self.bubble), + MoveToTarget(left_three), + MoveToTarget(right_three), + Write(equals), + ) + self.dither() + + self.equals = equals + + def show_alternate_digits(self): + randy = self.pi_creature + cross = Cross(self.equals) + cross.stretch_to_fit_height(0.5) + three = self.remaining_threes[1] + + image_map = get_organized_images() + arrays = [image_map[k][0] for k in range(8, 4, -1)] + alt_mobs = [ + WrappedImage( + PixelsAsSquares(ImageMobject(layer_to_image_array(arr))), + color = LIGHT_GREY, + buff = 0 + ).replace(three) + for arr in arrays + ] + + self.play( + randy.change, "sassy", + Transform(three, alt_mobs[0]), + ShowCreation(cross) + ) + self.dither() + for mob in alt_mobs[1:]: + self.play(Transform(three, mob)) + self.dither() + + ###### + + def create_pi_creature(self): + return Randolph().to_corner(DOWN+LEFT) + + def get_three_mobs(self): + three_arrays = get_organized_images()[3][:4] + three_mobs = VGroup() + for three_array in three_arrays: + im_mob = ImageMobject( + layer_to_image_array(three_array), + height = 4, + ) + pixel_mob = PixelsAsSquares(im_mob) + three_mob = WrappedImage( + pixel_mob, + color = LIGHT_GREY, + buff = 0 + ) + three_mobs.add(three_mob) + return three_mobs + +class BrainAndHow(Scene): + def construct(self): + brain = SVGMobject(file_name = "brain") + brain.scale_to_fit_height(2) + brain.set_fill(LIGHT_GREY) + brain_outline = brain.copy() + brain_outline.set_fill(opacity = 0) + brain_outline.set_stroke(BLUE_B, 3) + + how = TextMobject("How?!?") + how.scale(2) + how.next_to(brain, UP) + + self.add(brain) + self.play(Write(how)) + for x in range(2): + self.play( + ShowPassingFlash( + brain_outline, + time_width = 0.5, + run_time = 2 + ) + ) + self.dither() + +class WriteAProgram(Scene): + def construct(self): + three_array = get_organized_images()[3][0] + im_mob = ImageMobject(layer_to_image_array(three_array)) + three = PixelsAsSquares(im_mob) + three.sort_submobjects(lambda p : np.dot(p, DOWN+RIGHT)) + three.scale_to_fit_height(6) + three.next_to(ORIGIN, LEFT) + three_rect = SurroundingRectangle( + three, + color = BLUE, + buff = SMALL_BUFF + ) + + numbers = VGroup() + for square in three: + rgb = square.fill_rgb + num = DecimalNumber( + square.fill_rgb[0], + num_decimal_points = 1 + ) + num.set_stroke(width = 1) + color = rgba_to_color(1 - (rgb + 0.2)/1.2) + num.highlight(color) + num.scale_to_fit_width(0.7*square.get_width()) + num.move_to(square) + numbers.add(num) + + arrow = Arrow(LEFT, RIGHT, color = BLUE) + arrow.next_to(three, RIGHT) + + choices = VGroup(*[TexMobject(str(n)) for n in range(10)]) + choices.arrange_submobjects(DOWN) + choices.scale_to_fit_height(2*SPACE_HEIGHT - 1) + choices.next_to(arrow, RIGHT) + + self.play( + LaggedStart(DrawBorderThenFill, three), + ShowCreation(three_rect) + ) + self.play(Write(numbers)) + self.play( + ShowCreation(arrow), + LaggedStart(FadeIn, choices), + ) + + rect = SurroundingRectangle(choices[0], buff = SMALL_BUFF) + q_mark = TexMobject("?") + q_mark.next_to(rect, RIGHT) + self.play(ShowCreation(rect)) + for n in 8, 1, 5, 3: + self.play( + rect.move_to, choices[n], + MaintainPositionRelativeTo(q_mark, rect) + ) + self.dither(1) + choice = choices[3] + choices.remove(choice) + choice.add(rect) + self.play( + choice.scale, 1.5, + choice.next_to, arrow, RIGHT, + FadeOut(choices), + FadeOut(q_mark), + ) + self.dither(2) + +class LayOutPlan(TeacherStudentsScene, NetworkScene): + def setup(self): + TeacherStudentsScene.setup(self) + NetworkScene.setup(self) + self.remove(self.network_mob) + + def construct(self): + self.show_words() + self.show_network() + self.show_math() + self.ask_about_layers() + self.show_learning() + self.show_videos() + + def show_words(self): + words = VGroup( + TextMobject("Machine", "learning").highlight(GREEN), + TextMobject("Neural network").highlight(BLUE), + ) + words.next_to(self.teacher.get_corner(UP+LEFT), UP) + words[0].save_state() + words[0].shift(DOWN) + words[0].fade(1) + + self.play( + words[0].restore, + self.teacher.change, "raise_right_hand", + self.get_student_changes("pondering", "erm", "sassy") + ) + self.play( + words[0].shift, MED_LARGE_BUFF*UP, + FadeIn(words[1]), + ) + self.change_student_modes( + *["pondering"]*3, + look_at_arg = words + ) + self.play(words.to_corner, UP+RIGHT) + + self.words = words + + def show_network(self): + network_mob = self.network_mob + network_mob.next_to(self.students, UP) + + self.play( + ReplacementTransform( + VGroup(self.words[1].copy()), + network_mob.layers + ), + self.get_student_changes( + *["confused"]*3, + submobject_mode = "all_at_once" + ), + self.teacher.change, "plain", + run_time = 1 + ) + self.play(ShowCreation( + network_mob.edge_groups, + submobject_mode = "lagged_start", + run_time = 2, + lag_factor = 8, + rate_func = None, + )) + in_vect = np.random.random(self.network.sizes[0]) + self.feed_forward(in_vect) + + def show_math(self): + equation = TexMobject( + "\\textbf{a}_{l+1}", "=", + "\\sigma(", + "W_l", "\\textbf{a}_l", "+", "b_l", + ")" + ) + equation.highlight_by_tex_to_color_map({ + "\\textbf{a}" : GREEN, + }) + equation.move_to(self.network_mob.get_corner(UP+RIGHT)) + equation.to_edge(UP) + + self.play(Write(equation, run_time = 2)) + self.dither() + + self.equation = equation + + def ask_about_layers(self): + self.student_says( + "Why the layers?", + student_index = 2, + bubble_kwargs = {"direction" : LEFT} + ) + self.dither() + self.play(RemovePiCreatureBubble(self.students[2])) + + def show_learning(self): + word = self.words[0][1].copy() + rect = SurroundingRectangle(word, color = YELLOW) + self.network_mob.neuron_fill_color = YELLOW + + layer = self.network_mob.layers[-1] + activation = np.zeros(len(layer.neurons)) + activation[1] = 1.0 + active_layer = self.network_mob.get_active_layer( + -1, activation + ) + word_group = VGroup(word, rect) + word_group.generate_target() + word_group.target.move_to(self.equation, LEFT) + word_group.target[0].highlight(YELLOW) + word_group.target[1].set_stroke(width = 0) + + self.play(ShowCreation(rect)) + self.play( + Transform(layer, active_layer), + FadeOut(self.equation), + MoveToTarget(word_group), + ) + for edge_group in reversed(self.network_mob.edge_groups): + edge_group.generate_target() + for edge in edge_group.target: + edge.set_stroke( + YELLOW, + width = 4*np.random.random()**2 + ) + self.play(MoveToTarget(edge_group)) + self.dither() + + self.learning_word = word + + def show_videos(self): + network_mob = self.network_mob + learning = self.learning_word + videos = VGroup(*[ + VideoIcon().set_fill(RED) + for x in range(2) + ]) + videos.scale_to_fit_height(1.5) + videos.arrange_submobjects(RIGHT, buff = LARGE_BUFF) + videos.next_to(self.students, UP, LARGE_BUFF) + + network_mob.generate_target() + network_mob.target.scale_to_fit_height(0.8*videos[0].get_height()) + network_mob.target.move_to(videos[0]) + learning.generate_target() + learning.target.next_to(videos[1], UP) + + self.play( + MoveToTarget(network_mob), + MoveToTarget(learning) + ) + self.play( + DrawBorderThenFill(videos[0]), + self.get_student_changes(*["pondering"]*3) + ) + self.dither() + self.play(DrawBorderThenFill(videos[1])) + self.dither() + +class PreviewMNistNetwork(NetworkScene): + CONFIG = { + "n_examples" : 15, + "network_mob_config" : {}, + } + def construct(self): + self.remove_random_edges(0.7) #Remove? + + training_data, validation_data, test_data = load_data_wrapper() + for data in test_data[:self.n_examples]: + self.feed_in_image(data[0]) + + def feed_in_image(self, in_vect): + image = PixelsFromVect(in_vect) + image.next_to(self.network_mob, LEFT, LARGE_BUFF, UP) + image.shift_onto_screen() + image_rect = SurroundingRectangle(image, color = BLUE) + start_neurons = self.network_mob.layers[0].neurons.copy() + start_neurons.set_stroke(WHITE, width = 0) + start_neurons.set_fill(WHITE, 0) + + self.play(FadeIn(image), FadeIn(image_rect)) + self.feed_forward(in_vect, added_anims = [ + self.get_image_to_layer_one_animation(image, start_neurons) + ]) + n = np.argmax([ + neuron.get_fill_opacity() + for neuron in self.network_mob.layers[-1].neurons + ]) + rect = SurroundingRectangle(VGroup( + self.network_mob.layers[-1].neurons[n], + self.network_mob.output_labels[n], + )) + self.play(ShowCreation(rect)) + self.reset_display(rect, image, image_rect) + + def reset_display(self, answer_rect, image, image_rect): + self.play(FadeOut(answer_rect)) + self.play( + FadeOut(image), + FadeOut(image_rect), + self.network_mob.deactivate_layers, + ) + + def get_image_to_layer_one_animation(self, image, start_neurons): + image_mover = VGroup(*[ + pixel.copy() + for pixel in image + if pixel.fill_rgb[0] > 0.1 + ]) + return Transform( + image_mover, start_neurons, + remover = True, + run_time = 1, + ) + + ### + + def add_network(self): + self.network_mob = MNistNetworkMobject(**self.network_mob_config) + self.network = self.network_mob.neural_network + self.add(self.network_mob) + +class AlternateNeuralNetworks(PiCreatureScene): + def construct(self): + morty = self.pi_creature + examples = VGroup( + VGroup( + TextMobject("Convolutional neural network"), + TextMobject("Good for image recognition"), + ), + VGroup( + TextMobject("Long short-term memory network"), + TextMobject("Good for speech recognition"), + ) + ) + for ex in examples: + arrow = Arrow(LEFT, RIGHT, color = BLUE) + ex[0].next_to(arrow, LEFT) + ex[1].next_to(arrow, RIGHT) + ex.submobjects.insert(1, arrow) + examples.scale_to_fit_width(2*SPACE_WIDTH - 1) + examples.next_to(morty, UP).to_edge(RIGHT) + + maybe_words = TextMobject("Maybe future videos?") + maybe_words.scale(0.8) + maybe_words.next_to(morty, UP) + maybe_words.to_edge(RIGHT) + maybe_words.highlight(YELLOW) + + self.play( + Write(examples[0], run_time = 2), + morty.change, "raise_right_hand" + ) + self.dither() + self.play( + examples[0].shift, MED_LARGE_BUFF*UP, + FadeIn(examples[1], submobject_mode = "lagged_start"), + ) + self.dither() + self.play( + examples.shift, UP, + FadeIn(maybe_words), + morty.change, "maybe" + ) + self.dither(2) + +class PlainVanillaWrapper(Scene): + def construct(self): + title = TextMobject("Plain vanilla") + subtitle = TextMobject("(aka ``multilayer perceptron'')") + title.scale(1.5) + title.to_edge(UP) + subtitle.next_to(title, DOWN) + + self.add(title) + self.dither(2) + self.play(Write(subtitle, run_time = 2)) + self.dither(2) + +class NotPerfectAddOn(Scene): + def construct(self): + words = TextMobject("Not perfect!") + words.scale(1.5) + arrow = Arrow(UP+RIGHT, DOWN+LEFT, color = RED) + words.highlight(RED) + arrow.to_corner(DOWN+LEFT) + words.next_to(arrow, UP+RIGHT) + + self.play( + Write(words), + ShowCreation(arrow), + run_time = 1 + ) + self.dither(2) + +class MoreAThanI(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "More \\\\ A than I", + target_mode = "hesitant" + ) + self.change_student_modes("sad", "erm", "tired") + self.dither(2) + +class BreakDownName(Scene): + def construct(self): + self.ask_questions() + self.show_neuron() + + def ask_questions(self): + name = TextMobject("Neural", "network") + name.to_edge(UP) + q1 = TextMobject( + "What are \\\\ the ", "neuron", "s?", + arg_separator = "" + ) + q2 = TextMobject("How are \\\\ they connected?") + q1.next_to(name[0].get_bottom(), DOWN, buff = LARGE_BUFF) + q2.next_to(name[1].get_bottom(), DOWN+RIGHT, buff = LARGE_BUFF) + a1 = Arrow(q1.get_top(), name[0].get_bottom()) + a2 = Arrow(q2.get_top(), name.get_corner(DOWN+RIGHT)) + VGroup(q1, a1).highlight(BLUE) + VGroup(q2, a2).highlight(YELLOW) + + randy = Randolph().to_corner(DOWN+LEFT) + brain = SVGMobject(file_name = "brain") + brain.set_fill(LIGHT_GREY, opacity = 0) + brain.replace(randy.eyes, dim_to_match = 1) + + self.add(name) + self.play(randy.change, "pondering") + self.play( + brain.scale_to_fit_height, 2, + brain.shift, 2*UP, + brain.set_fill, None, 1, + randy.look, UP + ) + brain_outline = brain.copy() + brain_outline.set_fill(opacity = 0) + brain_outline.set_stroke(BLUE_B, 3) + self.play( + ShowPassingFlash( + brain_outline, + time_width = 0.5, + run_time = 2 + ) + ) + self.play(Blink(randy)) + self.dither() + self.play( + Write(q1, run_time = 1), + ShowCreation(a1), + name[0].highlight, q1.get_color(), + ) + self.play( + Write(q2, run_time = 1), + ShowCreation(a2), + name[1].highlight, q2.get_color() + ) + self.dither(2) + + self.play(*map(FadeOut, [ + name, randy, brain, + q2, a1, a2, + q1[0], q1[2] + ])) + + self.neuron_word = q1[1] + + def show_neuron(self): + neuron_word = TextMobject("Neuron") + arrow = TexMobject("\\rightarrow") + arrow.shift(LEFT) + description = TextMobject("Thing that holds a number") + neuron_word.highlight(BLUE) + neuron_word.next_to(arrow, LEFT) + neuron_word.shift(0.5*SMALL_BUFF*UP) + description.next_to(arrow, RIGHT) + + neuron = Circle(radius = 0.35, color = BLUE) + neuron.next_to(neuron_word, UP, MED_LARGE_BUFF) + num = TexMobject("0.2") + num.scale_to_fit_width(0.7*neuron.get_width()) + num.move_to(neuron) + num.save_state() + num.move_to(description.get_right()) + num.set_fill(opacity = 1) + + self.play( + ReplacementTransform(self.neuron_word, neuron_word), + ShowCreation(neuron) + ) + self.play( + ShowCreation(arrow), + Write(description, run_time = 1) + ) + self.dither() + self.play( + neuron.set_fill, None, 0.2, + num.restore + ) + self.dither() + for value in 0.8, 0.4, 0.1, 0.5: + mob = TexMobject(str(value)) + mob.replace(num) + self.play( + neuron.set_fill, None, value, + Transform(num, mob) + ) + self.dither() + +class IntroduceEachLayer(PreviewMNistNetwork): + CONFIG = { + "network_mob_config" : { + "neuron_stroke_color" : WHITE, + "neuron_stroke_width" : 2, + "neuron_fill_color" : WHITE, + "average_shown_activation_of_large_layer" : False, + "edge_propogation_color" : YELLOW, + "edge_propogation_time" : 2, + } + } + def construct(self): + self.setup_network_mob() + self.break_up_image_as_neurons() + self.show_activation_of_one_neuron() + self.transform_into_full_network() + self.show_output_layer() + self.show_hidden_layers() + self.show_propogation() + + def setup_network_mob(self): + self.remove(self.network_mob) + + def break_up_image_as_neurons(self): + self.image_map = get_organized_images() + image = self.image_map[9][0] + image_mob = PixelsFromVect(image) + image_mob.scale_to_fit_height(4) + image_mob.next_to(ORIGIN, LEFT) + rect = SurroundingRectangle(image_mob, color = BLUE) + neurons = VGroup() + for pixel in image_mob: + pixel.set_fill(WHITE, opacity = pixel.fill_rgb[0]) + neuron = Circle( + color = WHITE, + stroke_width = 1, + radius = pixel.get_width()/2 + ) + neuron.move_to(pixel) + neuron.set_fill(WHITE, pixel.get_fill_opacity()) + neurons.add(neuron) + neurons.scale_in_place(1.2) + neurons.space_out_submobjects(1.3) + neurons.to_edge(DOWN) + + braces = VGroup(*[Brace(neurons, vect) for vect in LEFT, UP]) + labels = VGroup(*[ + brace.get_tex("28", buff = SMALL_BUFF) + for brace in braces + ]) + + equation = TexMobject("28", "\\times", "28", "=", "784") + equation.next_to(neurons, RIGHT, LARGE_BUFF, UP) + + self.corner_image = MNistMobject(image) + self.corner_image.to_corner(UP+LEFT) + + self.add(image_mob, rect) + self.dither() + self.play( + ReplacementTransform(image_mob, neurons), + FadeOut(rect), + FadeIn(braces), + FadeIn(labels), + ) + self.dither() + self.play( + ReplacementTransform(labels[0].copy(), equation[0]), + Write(equation[1]), + ReplacementTransform(labels[1].copy(), equation[2]), + Write(equation[3]), + Write(equation[4]), + ) + self.dither() + + self.neurons = neurons + self.braces = braces + self.brace_labels = labels + self.num_pixels_equation = equation + self.image_vect = image + + def show_activation_of_one_neuron(self): + neurons = self.neurons + numbers = VGroup() + example_neuron = None + example_num = None + for neuron in neurons: + o = neuron.get_fill_opacity() + num = DecimalNumber(o, num_decimal_points = 1) + num.scale_to_fit_width(0.7*neuron.get_width()) + num.move_to(neuron) + if o > 0.8: + num.set_fill(BLACK) + numbers.add(num) + if o > 0.25 and o < 0.75 and example_neuron is None: + example_neuron = neuron + example_num = num + example_neuron.save_state() + example_num.save_state() + example_neuron.generate_target() + example_neuron.target.scale_to_fit_height(1.5) + example_neuron.target.next_to(neurons, RIGHT) + example_num.target = DecimalNumber( + example_neuron.get_fill_opacity() + ) + example_num.target.move_to(example_neuron.target) + + def change_activation(num): + self.play( + example_neuron.set_fill, None, num, + ChangingDecimal( + example_num, + lambda a : example_neuron.get_fill_opacity(), + ), + UpdateFromFunc( + example_num, + lambda m : m.set_fill( + BLACK if example_neuron.get_fill_opacity() > 0.8 else WHITE + ) + ) + ) + + self.play(LaggedStart(FadeIn, numbers)) + self.play( + MoveToTarget(example_neuron), + MoveToTarget(example_num) + ) + self.dither() + curr_opacity = example_neuron.get_fill_opacity() + for num in 0.3, 0.01, 1.0, curr_opacity: + change_activation(num) + self.dither() + + rect = SurroundingRectangle(example_num, color = YELLOW) + activation = TextMobject("``Activation''") + activation.next_to(example_neuron, RIGHT) + activation.highlight(rect.get_color()) + self.play(ShowCreation(rect)) + self.play(Write(activation, run_time = 1)) + self.dither() + change_activation(1.0) + self.dither() + change_activation(0.2) + self.dither() + + self.play( + example_neuron.restore, + example_num.restore, + FadeOut(activation), + FadeOut(rect), + ) + self.play(FadeOut(numbers)) + + def transform_into_full_network(self): + network_mob = self.network_mob + neurons = self.neurons + layer = network_mob.layers[0] + n = network_mob.max_shown_neurons/2 + + self.play( + FadeOut(self.braces), + FadeOut(self.brace_labels), + FadeOut(VGroup(*self.num_pixels_equation[:-1])) + ) + self.play( + ReplacementTransform( + VGroup(*neurons[:n]), + VGroup(*layer.neurons[:n]), + ), + ReplacementTransform( + VGroup(*neurons[n:-n]), + layer.dots, + ), + ReplacementTransform( + VGroup(*neurons[-n:]), + VGroup(*layer.neurons[-n:]), + ), + FadeIn(self.corner_image) + ) + self.play( + ReplacementTransform( + self.num_pixels_equation[-1], + layer.brace_label + ), + FadeIn(layer.brace) + ) + self.dither() + for edge_group, layer in zip(network_mob.edge_groups, network_mob.layers[1:]): + self.play( + LaggedStart(FadeIn, layer, run_time = 1), + ShowCreation(edge_group), + ) + self.dither() + + def show_output_layer(self): + layer = self.network_mob.layers[-1] + labels = self.network_mob.output_labels + rect = SurroundingRectangle( + VGroup(layer, labels) + ) + neuron = layer.neurons[-1] + neuron.set_fill(WHITE, 0) + label = labels[-1] + for mob in neuron, label: + mob.save_state() + mob.generate_target() + neuron.target.scale_in_place(4) + neuron.target.shift(1.5*RIGHT) + label.target.scale(1.5) + label.target.next_to(neuron.target, RIGHT) + + activation = DecimalNumber(0) + activation.move_to(neuron.target) + + def change_activation(num): + self.play( + neuron.set_fill, None, num, + ChangingDecimal( + activation, + lambda a : neuron.get_fill_opacity(), + ), + UpdateFromFunc( + activation, + lambda m : m.set_fill( + BLACK if neuron.get_fill_opacity() > 0.8 else WHITE + ) + ) + ) + + self.play(ShowCreation(rect)) + self.play(LaggedStart(FadeIn, labels)) + self.dither() + self.play( + MoveToTarget(neuron), + MoveToTarget(label), + ) + self.play(FadeIn(activation)) + for num in 0.5, 0.38, 0.97: + change_activation(num) + self.dither() + self.play( + neuron.restore, + neuron.set_fill, None, 1, + label.restore, + FadeOut(activation), + FadeOut(rect), + ) + self.dither() + + def show_hidden_layers(self): + hidden_layers = VGroup(*self.network_mob.layers[1:3]) + rect = SurroundingRectangle(hidden_layers, color = YELLOW) + name = TextMobject("``Hidden layers''") + name.next_to(rect, UP, SMALL_BUFF) + name.highlight(YELLOW) + q_marks = VGroup() + for layer in hidden_layers: + for neuron in layer.neurons: + q_mark = TextMobject("?") + q_mark.scale_to_fit_height(0.8*neuron.get_height()) + q_mark.move_to(neuron) + q_marks.add(q_mark) + q_marks.gradient_highlight(BLUE, YELLOW) + q_mark = TextMobject("?").scale(4) + q_mark.move_to(hidden_layers) + q_mark.highlight(YELLOW) + q_marks.add(q_mark) + + self.play( + ShowCreation(rect), + Write(name) + ) + self.dither() + self.play(Write(q_marks)) + self.dither() + self.play( + FadeOut(q_marks), + Animation(q_marks[-1].copy()) + ) + + def show_propogation(self): + self.revert_to_original_skipping_status() + self.remove_random_edges(0.7) + self.feed_forward(self.image_vect) + +class MoreHonestMNistNetworkPreview(IntroduceEachLayer): + CONFIG = { + "network_mob_config" : { + "edge_propogation_time" : 1.5, + } + } + def construct(self): + PreviewMNistNetwork.construct(self) + + def get_image_to_layer_one_animation(self, image, start_neurons): + neurons = VGroup() + for pixel in image: + neuron = Circle( + radius = pixel.get_width()/2, + stroke_width = 1, + stroke_color = WHITE, + fill_color = WHITE, + fill_opacity = pixel.fill_rgb[0] + ) + neuron.move_to(pixel) + neurons.add(neuron) + neurons.scale(1.2) + neurons.next_to(image, DOWN) + n = len(start_neurons) + point = VectorizedPoint(start_neurons.get_center()) + target = VGroup(*it.chain( + start_neurons[:n/2], + [point.copy() for x in range(len(neurons)-n)], + start_neurons[n/2:], + )) + mover = image.copy() + self.play(Transform(mover, neurons)) + return Transform( + mover, target, + run_time = 2, + submobject_mode = "lagged_start", + remover = True + ) + +class AskAboutPropogationAndTraining(TeacherStudentsScene): + def construct(self): + self.student_says( + "How does one layer \\\\ influence the next?", + student_index = 0, + run_time = 1 + ) + self.dither() + self.student_says( + "How does \\\\ training work?", + student_index = 2, + run_time = 1 + ) + self.dither(3) + +class AskAboutLayers(PreviewMNistNetwork): + def construct(self): + self.play( + self.network_mob.scale, 0.8, + self.network_mob.to_edge, DOWN, + ) + + question = TextMobject("Why the", "layers?") + question.to_edge(UP) + neuron_groups = [ + layer.neurons + for layer in self.network_mob.layers + ] + arrows = VGroup(*[ + Arrow( + question[1].get_bottom(), + group.get_top() + ) + for group in neuron_groups + ]) + rects = map(SurroundingRectangle, neuron_groups[1:3]) + + self.play( + Write(question, run_time = 1), + LaggedStart( + GrowFromPoint, arrows, + lambda a : (a, a.get_start()), + run_time = 2 + ) + ) + self.dither() + self.play(*map(ShowCreation, rects)) + self.dither() + +class BreakUpMacroPatterns(IntroduceEachLayer): + CONFIG = { + "camera_config" : {"background_alpha" : 255}, + "prefixes" : [ + "nine", "eight", "four", + "upper_loop", "right_line", + "lower_loop", "horizontal_line", + "upper_left_line" + ] + } + def construct(self): + self.setup_network_mob() + self.setup_needed_patterns() + self.setup_added_patterns() + self.show_nine() + self.show_eight() + self.show_four() + self.show_second_to_last_layer() + self.show_upper_loop_activation() + self.show_what_learning_is_required() + + def setup_needed_patterns(self): + prefixes = self.prefixes + vects = [ + np.array(Image.open( + get_full_image_path("handwritten_" + p), + ))[:,:,0].flatten()/255.0 + for p in prefixes + ] + mobjects = map(MNistMobject, vects) + for mob in mobjects: + image = mob[1] + self.make_transparent(image) + for prefix, mob in zip(prefixes, mobjects): + setattr(self, prefix, mob) + + def setup_added_patterns(self): + image_map = get_organized_images() + two, three, five = mobs = [ + MNistMobject(image_map[n][0]) + for n in 2, 3, 5 + ] + self.added_patterns = VGroup() + for mob in mobs: + for i, j in it.product([0, 14], [0, 14]): + pattern = mob.deepcopy() + pa = pattern[1].pixel_array + temp = np.array(pa[i:i+14,j:j+14,:], dtype = 'uint8') + pa[:,:] = 0 + pa[i:i+14,j:j+14,:] = temp + self.make_transparent(pattern[1]) + pattern[1].highlight(random_bright_color()) + self.added_patterns.add(pattern) + self.image_map = image_map + + def show_nine(self): + nine = self.nine + upper_loop = self.upper_loop + right_line = self.right_line + equation = self.get_equation(nine, upper_loop, right_line) + equation.to_edge(UP) + equation.shift(LEFT) + + parts = [upper_loop[1], right_line[1]] + for mob, color in zip(parts, [YELLOW, RED]): + mob.highlight(color) + mob.save_state() + mob.move_to(nine) + right_line[1].pixel_array[:14,:,3] = 0 + + self.play(FadeIn(nine)) + self.dither() + self.play(*map(FadeIn, parts)) + self.dither() + self.play( + Write(equation[1]), + upper_loop[1].restore, + FadeIn(upper_loop[0]) + ) + self.dither() + self.play( + Write(equation[3]), + right_line[1].restore, + FadeIn(right_line[0]), + ) + self.dither() + + self.nine_equation = equation + + def show_eight(self): + eight = self.eight + upper_loop = self.upper_loop.deepcopy() + lower_loop = self.lower_loop + lower_loop[1].highlight(GREEN) + + equation = self.get_equation(eight, upper_loop, lower_loop) + equation.next_to(self.nine_equation, DOWN) + + lower_loop[1].save_state() + lower_loop[1].move_to(eight[1]) + + self.play( + FadeIn(eight), + Write(equation[1]), + ) + self.play(ReplacementTransform( + self.upper_loop.copy(), + upper_loop + )) + self.dither() + self.play(FadeIn(lower_loop[1])) + self.play( + Write(equation[3]), + lower_loop[1].restore, + FadeIn(lower_loop[0]), + ) + self.dither() + + self.eight_equation = equation + + def show_four(self): + four = self.four + upper_left_line = self.upper_left_line + upper_left_line[1].highlight(BLUE) + horizontal_line = self.horizontal_line + horizontal_line[1].highlight(MAROON_B) + right_line = self.right_line.deepcopy() + equation = self.get_equation(four, right_line, upper_left_line, horizontal_line) + equation.next_to( + self.eight_equation, DOWN, aligned_edge = LEFT + ) + + self.play( + FadeIn(four), + Write(equation[1]) + ) + self.play(ReplacementTransform( + self.right_line.copy(), right_line + )) + self.play(LaggedStart( + FadeIn, VGroup(*equation[3:]) + )) + self.dither(2) + + self.four_equation = equation + + def show_second_to_last_layer(self): + everything = VGroup(*it.chain( + self.nine_equation, + self.eight_equation, + self.four_equation, + )) + patterns = VGroup( + self.upper_loop, + self.lower_loop, + self.right_line, + self.upper_left_line, + self.horizontal_line, + *self.added_patterns[:11] + ) + for pattern in patterns: + pattern.add_to_back( + pattern[1].copy().highlight(BLACK, alpha = 1) + ) + everything.remove(*patterns) + network_mob = self.network_mob + layer = network_mob.layers[-2] + patterns.generate_target() + for pattern, neuron in zip(patterns.target, layer.neurons): + pattern.scale_to_fit_height(neuron.get_height()) + pattern.next_to(neuron, RIGHT, SMALL_BUFF) + for pattern in patterns[5:]: + pattern.fade(1) + + self.play(*map(FadeOut, everything)) + self.play( + FadeIn( + network_mob, + submobject_mode = "lagged_start", + run_time = 3, + ), + MoveToTarget(patterns) + ) + self.dither(2) + + self.patterns = patterns + + def show_upper_loop_activation(self): + neuron = self.network_mob.layers[-2].neurons[0] + words = TextMobject("Upper loop neuron...mabye...") + words.scale(0.8) + words.next_to(neuron, UP) + words.shift(RIGHT) + rect = SurroundingRectangle(VGroup( + neuron, self.patterns[0] + )) + nine = self.nine + upper_loop = self.upper_loop.copy() + upper_loop.remove(upper_loop[0]) + upper_loop.replace(nine) + nine.add(upper_loop) + nine.to_corner(UP+LEFT) + self.remove_random_edges(0.7) + self.network.get_activation_of_all_layers = lambda v : [ + np.zeros(784), + sigmoid(6*(np.random.random(16)-0.5)), + np.array([1, 0, 1] + 13*[0]), + np.array(9*[0] + [1]) + ] + + self.play(FadeIn(nine)) + self.add_foreground_mobject(self.patterns) + self.play( + ShowCreation(rect), + Write(words) + ) + self.feed_forward(np.random.random(784)) + self.dither(2) + + def show_what_learning_is_required(self): + edge_group = self.network_mob.edge_groups[-1].copy() + edge_group.set_stroke(YELLOW, 4) + for x in range(3): + self.play(LaggedStart( + ShowCreationThenDestruction, edge_group, + run_time = 3 + )) + self.dither() + + ###### + + def get_equation(self, *mobs): + equation = VGroup( + mobs[0], TexMobject("=").scale(2), + *list(it.chain(*[ + [m, TexMobject("+").scale(2)] + for m in mobs[1:-1] + ])) + [mobs[-1]] + ) + equation.arrange_submobjects(RIGHT) + return equation + + def make_transparent(self, image_mob): + return make_transparent(image_mob) + alpha_vect = np.array( + image_mob.pixel_array[:,:,0], + dtype = 'uint8' + ) + image_mob.highlight(WHITE) + image_mob.pixel_array[:,:,3] = alpha_vect + return image_mob + +class GenerallyLoopyPattern(Scene): + def construct(self): + image_map = get_organized_images() + images = map(MNistMobject, it.chain( + image_map[8], image_map[9], + )) + random.shuffle(images) + + for image in images: + image.to_corner(DOWN+RIGHT) + self.add(image) + self.dither(0.2) + self.remove(image) + +class HowWouldYouRecognizeSubcomponent(TeacherStudentsScene): + def construct(self): + self.student_says( + "Okay, but recognizing loops \\\\", + "is just as hard!", + target_mode = "sassy" + ) + self.play( + self.teacher.change, "guilty" + ) + self.dither() + +class BreakUpMicroPatterns(BreakUpMacroPatterns): + CONFIG = { + "prefixes" : [ + "loop", + "loop_edge1", + "loop_edge2", + "loop_edge3", + "loop_edge4", + "loop_edge5", + "right_line", + "right_line_edge1", + "right_line_edge2", + "right_line_edge3", + ] + } + def construct(self): + self.setup_network_mob() + self.setup_needed_patterns() + + self.break_down_loop() + self.break_down_long_line() + + def break_down_loop(self): + loop = self.loop + loop[0].highlight(WHITE) + edges = Group(*[ + getattr(self, "loop_edge%d"%d) + for d in range(1, 6) + ]) + colors = color_gradient([BLUE, YELLOW, RED], 5) + for edge, color in zip(edges, colors): + for mob in edge: + mob.highlight(color) + loop.generate_target() + edges.generate_target() + for edge in edges: + edge[0].set_stroke(width = 0) + edge.save_state() + edge[1].set_opacity(0) + equation = self.get_equation(loop.target, *edges.target) + equation.scale_to_fit_width(2*SPACE_WIDTH - 1) + equation.to_edge(UP) + symbols = VGroup(*equation[1::2]) + + randy = Randolph() + randy.to_corner(DOWN+LEFT) + + self.add(randy) + self.play( + FadeIn(loop), + randy.change, "pondering", loop + ) + self.play(Blink(randy)) + self.dither() + self.play(LaggedStart( + ApplyMethod, edges, + lambda e : (e.restore,), + run_time = 4 + )) + self.dither() + self.play( + MoveToTarget(loop, run_time = 2), + MoveToTarget(edges, run_time = 2), + Write(symbols), + randy.change, "happy", equation, + ) + self.dither() + + self.loop_equation = equation + self.randy = randy + + def break_down_long_line(self): + randy = self.randy + line = self.right_line + line[0].highlight(WHITE) + edges = Group(*[ + getattr(self, "right_line_edge%d"%d) + for d in range(1, 4) + ]) + colors = Color(MAROON_B).range_to(PURPLE, 3) + for edge, color in zip(edges, colors): + for mob in edge: + mob.highlight(color) + equation = self.get_equation(line, *edges) + equation.scale_to_fit_height(self.loop_equation.get_height()) + equation.next_to( + self.loop_equation, DOWN, MED_LARGE_BUFF, LEFT + ) + image_map = get_organized_images() + digits = VGroup(*[ + MNistMobject(image_map[n][1]) + for n in 1, 4, 7 + ]) + digits.arrange_submobjects(RIGHT) + digits.next_to(randy, RIGHT) + + self.revert_to_original_skipping_status() + self.play( + FadeIn(line), + randy.change, "hesitant", line + ) + self.play(Blink(randy)) + self.play(LaggedStart(FadeIn, digits)) + self.dither() + self.play( + LaggedStart(FadeIn, Group(*equation[1:])), + randy.change, "pondering", equation + ) + self.dither(3) + +class SecondLayerIsLittleEdgeLayer(IntroduceEachLayer): + CONFIG = { + "camera_config" : { + "background_alpha" : 255, + }, + "network_mob_config" : { + "layer_to_layer_buff" : 2, + "edge_propogation_color" : YELLOW, + } + } + def construct(self): + self.setup_network_mob() + self.setup_activations_and_nines() + + self.describe_second_layer() + self.show_propogation() + self.ask_question() + + def setup_network_mob(self): + self.network_mob.scale(0.7) + self.network_mob.to_edge(DOWN) + self.remove_random_edges(0.7) + + def setup_activations_and_nines(self): + layers = self.network_mob.layers + nine_im, loop_im, line_im = images = [ + Image.open(get_full_image_path("handwritten_%s"%s)) + for s in "nine", "upper_loop", "right_line" + ] + nine_array, loop_array, line_array = [ + np.array(im)[:,:,0]/255.0 + for im in images + ] + self.nine = MNistMobject(nine_array.flatten()) + self.nine.scale_to_fit_height(1.5) + self.nine[0].highlight(WHITE) + make_transparent(self.nine[1]) + self.nine.next_to(layers[0].neurons, UP) + + self.activations = self.network.get_activation_of_all_layers( + nine_array.flatten() + ) + self.activations[-2] = np.array([1, 0, 1] + 13*[0]) + + + self.edge_colored_nine = Group() + nine_pa = self.nine[1].pixel_array + n, k = 6, 4 + colors = color_gradient([BLUE, YELLOW, RED, MAROON_B, GREEN], 10) + for i, j in it.product(range(n), range(k)): + mob = ImageMobject(np.zeros((28, 28, 4), dtype = 'uint8')) + mob.replace(self.nine[1]) + pa = mob.pixel_array + color = colors[(k*i + j)%(len(colors))] + rgb = (255*color_to_rgb(color)).astype('uint8') + pa[:,:,:3] = rgb + i0, i1 = 1+(28/n)*i, 1+(28/n)*(i+1) + j0, j1 = (28/k)*j, (28/k)*(j+1) + pa[i0:i1,j0:j1,3] = nine_pa[i0:i1,j0:j1,3] + self.edge_colored_nine.add(mob) + self.edge_colored_nine.next_to(layers[1], UP) + + loop, line = [ + ImageMobject(layer_to_image_array(array.flatten())) + for array in loop_array, line_array + ] + for mob, color in (loop, YELLOW), (line, RED): + make_transparent(mob) + mob.highlight(color) + mob.replace(self.nine[1]) + line.pixel_array[:14,:,:] = 0 + + self.pattern_colored_nine = Group(loop, line) + self.pattern_colored_nine.next_to(layers[2], UP) + + for mob in self.edge_colored_nine, self.pattern_colored_nine: + mob.align_to(self.nine[1], UP) + + def describe_second_layer(self): + layer = self.network_mob.layers[1] + rect = SurroundingRectangle(layer) + words = TextMobject("``Little edge'' layer?") + words.next_to(rect, UP, MED_LARGE_BUFF) + words.highlight(YELLOW) + + self.play( + ShowCreation(rect), + Write(words, run_time = 2) + ) + self.dither() + self.play(*map(FadeOut, [rect, words])) + + def show_propogation(self): + nine = self.nine + edge_colored_nine = self.edge_colored_nine + pattern_colored_nine = self.pattern_colored_nine + activations = self.activations + network_mob = self.network_mob + layers = network_mob.layers + edge_groups = network_mob.edge_groups.copy() + edge_groups.set_stroke(YELLOW, 4) + + v_nine = PixelsAsSquares(nine[1]) + neurons = VGroup() + for pixel in v_nine: + neuron = Circle( + radius = pixel.get_width()/2, + stroke_color = WHITE, + stroke_width = 1, + fill_color = WHITE, + fill_opacity = pixel.get_fill_opacity(), + ) + neuron.rotate(3*np.pi/4) + neuron.move_to(pixel) + neurons.add(neuron) + neurons.scale_to_fit_height(2) + neurons.space_out_submobjects(1.2) + neurons.next_to(network_mob, LEFT) + self.set_neurons_target(neurons, layers[0]) + + pattern_colored_nine.save_state() + pattern_colored_nine.move_to(edge_colored_nine) + edge_colored_nine.save_state() + edge_colored_nine.move_to(nine[1]) + for mob in edge_colored_nine, pattern_colored_nine: + for submob in mob: + submob.set_opacity(0) + + active_layers = [ + network_mob.get_active_layer(i, a) + for i, a in enumerate(activations) + ] + + def activate_layer(i): + self.play( + ShowCreationThenDestruction( + edge_groups[i-1], + run_time = 2, + submobject_mode = "lagged_start" + ), + FadeIn(active_layers[i]) + ) + + + self.play(FadeIn(nine)) + self.play(ReplacementTransform(v_nine, neurons)) + self.play(MoveToTarget( + neurons, + remover = True, + submobject_mode = "lagged_start", + run_time = 2 + )) + + activate_layer(1) + self.play(edge_colored_nine.restore) + self.separate_parts(edge_colored_nine) + self.dither() + + activate_layer(2) + self.play(pattern_colored_nine.restore) + self.separate_parts(pattern_colored_nine) + + activate_layer(3) + self.dither(2) + + def ask_question(self): + question = TextMobject( + "Does the network \\\\ actually do this?" + ) + question.to_edge(LEFT) + later = TextMobject("We'll get back \\\\ to this") + later.to_corner(UP+LEFT) + later.highlight(BLUE) + arrow = Arrow(later.get_bottom(), question.get_top()) + arrow.highlight(BLUE) + + self.play(Write(question, run_time = 2)) + self.dither() + self.play( + FadeIn(later), + GrowFromPoint(arrow, arrow.get_start()) + ) + self.dither() + + ### + + def set_neurons_target(self, neurons, layer): + neurons.generate_target() + n = len(layer.neurons)/2 + Transform( + VGroup(*neurons.target[:n]), + VGroup(*layer.neurons[:n]), + ).update(1) + Transform( + VGroup(*neurons.target[-n:]), + VGroup(*layer.neurons[-n:]), + ).update(1) + Transform( + VGroup(*neurons.target[n:-n]), + VectorizedPoint(layer.get_center()) + ).update(1) + + def separate_parts(self, image_group): + vects = compass_directions(len(image_group), UP) + image_group.generate_target() + for im, vect in zip(image_group.target, vects): + im.shift(MED_SMALL_BUFF*vect) + self.play(MoveToTarget( + image_group, + rate_func = there_and_back, + submobject_mode = "lagged_start", + run_time = 2, + )) + +class EdgeDetection(Scene): + CONFIG = { + "camera_config" : {"background_alpha" : 255} + } + def construct(self): + lion = ImageMobject("Lion") + edges_array = get_edges(lion.pixel_array) + edges = ImageMobject(edges_array) + group = Group(lion, edges) + group.scale_to_fit_height(4) + group.arrange_submobjects(RIGHT) + lion_copy = lion.copy() + + self.play(FadeIn(lion)) + self.play(lion_copy.move_to, edges) + self.play(Transform(lion_copy, edges, run_time = 3)) + self.dither(2) + +class ManyTasksBreakDownLikeThis(TeacherStudentsScene): + def construct(self): + audio = self.get_wave_form() + audio_label = TextMobject("Raw audio") + letters = TextMobject(" ".join("recognition")) + syllables = TextMobject("$\\cdot$".join([ + "re", "cog", "ni", "tion" + ])) + word = TextMobject( + "re", "cognition", + arg_separator = "" + ) + word[1].highlight(BLUE) + arrows = VGroup() + def get_arrow(): + arrow = Arrow(ORIGIN, RIGHT, color = BLUE) + arrows.add(arrow) + return arrow + sequence = VGroup( + audio, get_arrow(), + letters, get_arrow(), + syllables, get_arrow(), + word + ) + sequence.arrange_submobjects(RIGHT) + sequence.scale_to_fit_width(2*SPACE_WIDTH - 1) + sequence.to_edge(UP) + + audio_label.next_to(audio, DOWN) + VGroup(audio, audio_label).highlight(YELLOW) + audio.save_state() + + self.teacher_says( + "Many", "recognition", "tasks\\\\", + "break down like this" + ) + self.change_student_modes(*["pondering"]*3) + self.dither() + content = self.teacher.bubble.content + pre_word = content[1] + content.remove(pre_word) + audio.move_to(pre_word) + self.play( + self.teacher.bubble.content.fade, 1, + ShowCreation(audio), + pre_word.shift, MED_SMALL_BUFF, DOWN + ) + self.dither(2) + self.play( + RemovePiCreatureBubble(self.teacher), + audio.restore, + FadeIn(audio_label), + *[ + ReplacementTransform( + m1, m2 + ) + for m1, m2 in zip(pre_word, letters) + ] + ) + self.play( + GrowFromPoint(arrows[0], arrows[0].get_start()), + ) + self.dither() + self.play( + GrowFromPoint(arrows[1], arrows[1].get_start()), + LaggedStart(FadeIn, syllables, run_time = 1) + ) + self.dither() + self.play( + GrowFromPoint(arrows[2], arrows[2].get_start()), + LaggedStart(FadeIn, word, run_time = 1) + ) + self.dither() + + def get_wave_form(self): + func = lambda x : abs(sum([ + (1./n)*np.sin((n+3)*x) + for n in range(1, 5) + ])) + result = VGroup(*[ + Line(func(x)*DOWN, func(x)*UP) + for x in np.arange(0, 4, 0.1) + ]) + result.set_stroke(width = 2) + result.arrange_submobjects(RIGHT, buff = MED_SMALL_BUFF) + result.scale_to_fit_height(1) + + return result + +class AskAboutWhatEdgesAreDoing(IntroduceEachLayer): + CONFIG = { + "network_mob_config" : { + "layer_to_layer_buff" : 2, + } + } + def construct(self): + self.add_question() + self.show_propogation() + + def add_question(self): + self.network_mob.scale(0.8) + self.network_mob.to_edge(DOWN) + edge_groups = self.network_mob.edge_groups + self.remove_random_edges(0.7) + + question = TextMobject( + "What are these connections actually doing?" + ) + question.to_edge(UP) + question.shift(RIGHT) + arrows = VGroup(*[ + Arrow( + question.get_bottom(), + edge_group.get_top() + ) + for edge_group in edge_groups + ]) + + self.add(question, arrows) + + def show_propogation(self): + in_vect = get_organized_images()[6][3] + image = MNistMobject(in_vect) + image.next_to(self.network_mob, LEFT, MED_SMALL_BUFF, UP) + + self.add(image) + self.feed_forward(in_vect) + self.dither() + +class IntroduceWeights(IntroduceEachLayer): + CONFIG = { + "weights_color" : GREEN, + "negative_weights_color" : RED, + } + def construct(self): + self.zoom_in_on_one_neuron() + self.show_desired_pixel_region() + self.ask_about_parameters() + self.show_weights() + self.show_weighted_sum() + self.organize_weights_as_grid() + self.make_most_weights_0() + self.add_negative_weights_around_the_edge() + + def zoom_in_on_one_neuron(self): + self.network_mob.to_edge(LEFT) + layers = self.network_mob.layers + edge_groups = self.network_mob.edge_groups + + neuron = layers[1].neurons[7].deepcopy() + + self.play( + FadeOut(edge_groups), + FadeOut(VGroup(*layers[1:])), + FadeOut(self.network_mob.output_labels), + Animation(neuron), + neuron.edges_in.set_stroke, None, 2, + submobject_mode = "lagged_start", + run_time = 2 + ) + + self.neuron = neuron + + def show_desired_pixel_region(self): + neuron = self.neuron + d = 28 + + pixels = PixelsAsSquares(ImageMobject( + np.zeros((d, d, 4)) + )) + pixels.set_stroke(width = 0.5) + pixels.set_fill(WHITE, 0) + pixels.scale_to_fit_height(4) + pixels.next_to(neuron, RIGHT, LARGE_BUFF) + rect = SurroundingRectangle(pixels, color = BLUE) + + pixels_to_detect = self.get_pixels_to_detect() + + self.play( + FadeIn(rect), + ShowCreation( + pixels, + submobject_mode = "lagged_start", + run_time = 2, + ) + ) + self.play( + pixels_to_detect.set_fill, WHITE, 1, + submobject_mode = "lagged_start", + run_time = 2 + ) + self.dither(2) + + self.pixels = pixels + self.pixels_to_detect = pixels_to_detect + self.pixels_group = VGroup(rect, pixels) + + def ask_about_parameters(self): + pixels = self.pixels + pixels_group = self.pixels_group + neuron = self.neuron + + question = TextMobject("What", "parameters", "should exist?") + parameter_word = question.get_part_by_tex("parameters") + parameter_word.highlight(self.weights_color) + question.move_to(neuron.edges_in.get_top(), LEFT) + arrow = Arrow( + parameter_word.get_bottom(), + neuron.edges_in[0].get_center(), + color = self.weights_color + ) + + p_labels = VGroup(*[ + TexMobject("p_%d\\!:"%(i+1)).highlight(self.weights_color) + for i in range(8) + ] + [TexMobject("\\vdots")]) + p_labels.arrange_submobjects(DOWN, aligned_edge = LEFT) + p_labels.next_to(parameter_word, DOWN, LARGE_BUFF) + p_labels[-1].shift(SMALL_BUFF*RIGHT) + + def get_alpha_func(i, start = 0): + m = int(5*np.sin(2*np.pi*i/128.)) + return lambda a : start + (1-2*start)*np.sin(np.pi*a*m)**2 + + decimals = VGroup() + changing_decimals = [] + for i, p_label in enumerate(p_labels[:-1]): + decimal = DecimalNumber(0) + decimal.next_to(p_label, RIGHT, MED_SMALL_BUFF) + decimals.add(decimal) + changing_decimals.append(ChangingDecimal( + decimal, get_alpha_func(i + 5) + )) + for i, pixel in enumerate(pixels): + pixel.func = get_alpha_func(i, pixel.get_fill_opacity()) + pixel_updates = [ + UpdateFromAlphaFunc( + pixel, + lambda p, a : p.set_fill(opacity = p.func(a)) + ) + for pixel in pixels + ] + + self.play( + Write(question, run_time = 2), + GrowFromPoint(arrow, arrow.get_start()), + pixels_group.scale_to_fit_height, 3, + pixels_group.to_edge, RIGHT, + LaggedStart(FadeIn, p_labels), + LaggedStart(FadeIn, decimals), + ) + self.dither() + self.play( + *changing_decimals + pixel_updates, + run_time = 5, + rate_func = None + ) + + self.question = question + self.weight_arrow = arrow + self.p_labels = p_labels + self.decimals = decimals + + def show_weights(self): + p_labels = self.p_labels + decimals = self.decimals + arrow = self.weight_arrow + question = self.question + neuron = self.neuron + edges = neuron.edges_in + + parameter_word = question.get_part_by_tex("parameters") + question.remove(parameter_word) + weights_word = TextMobject("Weights", "")[0] + weights_word.highlight(self.weights_color) + weights_word.move_to(parameter_word) + + w_labels = VGroup() + for p_label in p_labels: + w_label = TexMobject( + p_label.get_tex_string().replace("p", "w") + ) + w_label.highlight(self.weights_color) + w_label.move_to(p_label) + w_labels.add(w_label) + + edges.generate_target() + random_numbers = 1.5*np.random.random(len(edges))-0.5 + self.make_edges_weighted(edges.target, random_numbers) + def get_alpha_func(r): + return lambda a : (4*r)*a + + self.play( + FadeOut(question), + ReplacementTransform(parameter_word, weights_word), + ReplacementTransform(p_labels, w_labels) + ) + self.play( + MoveToTarget(edges), + *[ + ChangingDecimal( + decimal, + get_alpha_func(r) + ) + for decimal, r in zip(decimals, random_numbers) + ] + ) + self.play(LaggedStart( + ApplyMethod, edges, + lambda m : (m.rotate_in_place, np.pi/24), + rate_func = wiggle, + run_time = 2 + )) + self.dither() + + self.w_labels = w_labels + self.weights_word = weights_word + self.random_numbers = random_numbers + + def show_weighted_sum(self): + weights_word = self.weights_word + weight_arrow = self.weight_arrow + w_labels = VGroup(*[ + VGroup(*label[:-1]).copy() + for label in self.w_labels + ]) + layer = self.network_mob.layers[0] + + a_vect = np.random.random(16) + active_layer = self.network_mob.get_active_layer(0, a_vect) + + a_labels = VGroup(*[ + TexMobject("a_%d"%d) + for d in range(1, 5) + ]) + + weighted_sum = VGroup(*it.chain(*[ + [w, a, TexMobject("+")] + for w, a in zip(w_labels, a_labels) + ])) + weighted_sum.add( + TexMobject("\\cdots"), + TexMobject("+"), + TexMobject("w_n").highlight(self.weights_color), + TexMobject("a_n") + ) + weighted_sum.arrange_submobjects(RIGHT, buff = SMALL_BUFF) + weighted_sum.to_edge(UP) + + self.play(Transform(layer, active_layer)) + self.play( + FadeOut(weights_word), + FadeOut(weight_arrow), + *[ + ReplacementTransform(n.copy(), a) + for n, a in zip(layer.neurons, a_labels) + ] + [ + ReplacementTransform(n.copy(), weighted_sum[-4]) + for n in layer.neurons[4:-1] + ] + [ + ReplacementTransform( + layer.neurons[-1].copy(), + weighted_sum[-1] + ) + ] + [ + Write(weighted_sum[i]) + for i in range(2, 12, 3) + [-4, -3] + ], + run_time = 1.5 + ) + self.dither() + self.play(*[ + ReplacementTransform(w1.copy(), w2) + for w1, w2 in zip(self.w_labels, w_labels)[:4] + ]+[ + ReplacementTransform(w.copy(), weighted_sum[-4]) + for w in self.w_labels[4:-1] + ]+[ + ReplacementTransform( + self.w_labels[-1].copy(), weighted_sum[-2] + ) + ], run_time = 2) + self.dither(2) + + self.weighted_sum = weighted_sum + + def organize_weights_as_grid(self): + pixels = self.pixels + w_labels = self.w_labels + decimals = self.decimals + + weights = 2*np.sqrt(np.random.random(784))-1 + weights[:8] = self.random_numbers[:8] + weights[-8:] = self.random_numbers[-8:] + + weight_grid = PixelsFromVect(np.abs(weights)) + weight_grid.replace(pixels) + weight_grid.next_to(pixels, LEFT) + for weight, pixel in zip(weights, weight_grid): + if weight >= 0: + color = self.weights_color + else: + color = self.negative_weights_color + pixel.set_fill(color, opacity = abs(weight)) + + self.play(FadeOut(w_labels)) + self.play( + FadeIn( + VGroup(*weight_grid[len(decimals):]), + submobject_mode = "lagged_start", + run_time = 3 + ), + *[ + ReplacementTransform(decimal, pixel) + for decimal, pixel in zip(decimals, weight_grid) + ] + ) + self.dither() + + self.weight_grid = weight_grid + + def make_most_weights_0(self): + weight_grid = self.weight_grid + pixels = self.pixels + pixels_group = self.pixels_group + + weight_grid.generate_target() + for w, p in zip(weight_grid.target, pixels): + if p.get_fill_opacity() > 0.1: + w.set_fill(GREEN, 0.5) + else: + w.set_fill(BLACK, 0.5) + w.set_stroke(WHITE, 0.5) + + digit = self.get_digit() + digit.replace(pixels) + + self.play(MoveToTarget( + weight_grid, + run_time = 2, + submobject_mode = "lagged_start" + )) + self.dither() + self.play(Transform( + pixels, digit, + run_time = 2, + submobject_mode = "lagged_start" + )) + self.dither() + self.play(weight_grid.move_to, pixels) + self.dither() + self.play( + ReplacementTransform( + self.pixels_to_detect.copy(), + self.weighted_sum, + run_time = 3, + submobject_mode = "lagged_start" + ), + Animation(weight_grid), + ) + self.dither() + + def add_negative_weights_around_the_edge(self): + weight_grid = self.weight_grid + pixels = self.pixels + + self.play(weight_grid.next_to, pixels, LEFT) + self.play(*[ + ApplyMethod( + weight_grid[28*y + x].set_fill, + self.negative_weights_color, + 0.5 + ) + for y in 6, 10 + for x in range(14-4, 14+4) + ]) + self.dither(2) + self.play(weight_grid.move_to, pixels) + self.dither(2) + + #### + + def get_digit(self): + digit_vect = get_organized_images()[7][4] + digit = PixelsFromVect(digit_vect) + digit.set_stroke(width = 0.5) + return digit + + def get_pixels_to_detect(self, pixels): + d = int(np.sqrt(len(pixels))) + return VGroup(*it.chain(*[ + pixels[d*n + d/2 - 4 : d*n + d/2 + 4] + for n in range(7, 10) + ])) + + def get_surrounding_pixels_for_edge(self, pixels): + d = int(np.sqrt(len(pixels))) + return VGroup(*it.chain(*[ + pixels[d*n + d/2 - 4 : d*n + d/2 + 4] + for n in 6, 10 + ])) + + def make_edges_weighted(self, edges, weights): + for edge, r in zip(edges, weights): + if r > 0: + color = self.weights_color + else: + color = self.negative_weights_color + edge.set_stroke(color, 6*abs(r)) + +class MotivateSquishing(Scene): + def construct(self): + self.add_weighted_sum() + self.show_real_number_line() + self.show_interval() + self.squish_into_interval() + + def add_weighted_sum(self): + weighted_sum = TexMobject(*it.chain(*[ + ["w_%d"%d, "a_%d"%d, "+"] + for d in range(1, 5) + ] + [ + ["\\cdots", "+", "w_n", "a_n"] + ])) + weighted_sum.highlight_by_tex("w_", GREEN) + weighted_sum.to_edge(UP) + self.add(weighted_sum) + self.weighted_sum = weighted_sum + + def show_real_number_line(self): + weighted_sum = self.weighted_sum + number_line = NumberLine(unit_size = 1.5) + number_line.add_numbers() + number_line.shift(UP) + arrow1, arrow2 = [ + Arrow( + weighted_sum.get_bottom(), + number_line.number_to_point(n), + ) + for n in -3, 3 + ] + + self.play(Write(number_line)) + self.play(GrowFromPoint(arrow1, arrow1.get_start())) + self.play(Transform( + arrow1, arrow2, + run_time = 5, + rate_func = there_and_back + )) + self.play(FadeOut(arrow1)) + + self.number_line = number_line + + def show_interval(self): + lower_number_line = self.number_line.copy() + lower_number_line.shift(2*DOWN) + lower_number_line.highlight(LIGHT_GREY) + lower_number_line.numbers.highlight(WHITE) + interval = Line( + lower_number_line.number_to_point(0), + lower_number_line.number_to_point(1), + color = YELLOW, + stroke_width = 5 + ) + brace = Brace(interval, DOWN, buff = 0.7) + words = TextMobject("Activations should be in this range") + words.next_to(brace, DOWN, SMALL_BUFF) + + self.play(ReplacementTransform( + self.number_line.copy(), lower_number_line + )) + self.play( + GrowFromCenter(brace), + GrowFromCenter(interval), + ) + self.play(Write(words, run_time = 2)) + self.dither() + + self.lower_number_line = lower_number_line + + def squish_into_interval(self): + line = self.number_line + line.remove(*line.numbers) + ghost_line = line.copy() + ghost_line.fade(0.5) + ghost_line.highlight(BLUE_E) + self.add(ghost_line, line) + lower_line = self.lower_number_line + + line.generate_target() + u = line.unit_size + line.target.apply_function( + lambda p : np.array([u*sigmoid(p[0])]+list(p[1:])) + ) + line.target.move_to(lower_line.number_to_point(0.5)) + + arrow = Arrow( + line.numbers.get_bottom(), + line.target.get_top(), + color = YELLOW + ) + + self.play( + MoveToTarget(line), + GrowFromPoint(arrow, arrow.get_start()) + ) + self.dither(2) + +class IntroduceSigmoid(GraphScene): + CONFIG = { + "x_min" : -5, + "x_max" : 5, + "x_axis_width" : 12, + "y_min" : -1, + "y_max" : 2, + "y_axis_label" : "", + "graph_origin" : DOWN, + "x_labeled_nums" : range(-4, 5), + "y_labeled_nums" : range(-1, 3), + } + def construct(self): + self.setup_axes() + self.add_title() + self.add_graph() + self.show_part(-5, -2, RED) + self.show_part(2, 5, GREEN) + self.show_part(-2, 2, BLUE) + + def add_title(self): + name = TextMobject("Sigmoid") + name.next_to(ORIGIN, RIGHT, LARGE_BUFF) + name.to_edge(UP) + equation = TexMobject( + "\\sigma(x) = \\frac{1}{1+e^{-x}}" + ) + equation.next_to(name, DOWN) + self.add(equation, name) + + def add_graph(self): + graph = self.get_graph( + lambda x : 1./(1+np.exp(-x)), + color = YELLOW + ) + + self.play(ShowCreation(graph)) + self.dither() + + ### + + def show_part(self, x_min, x_max, color): + line, graph_part = [ + self.get_graph( + func, + x_min = x_min, + x_max = x_max, + color = color, + ).set_stroke(width = 4) + for func in lambda x : 0, sigmoid + ] + + self.play(ShowCreation(line)) + self.dither() + self.play(Transform(line, graph_part)) + self.dither() + +class IncludeBias(IntroduceWeights): + def construct(self): + self.force_skipping() + self.zoom_in_on_one_neuron() + self.setup_start() + self.revert_to_original_skipping_status() + + self.add_sigmoid_label() + self.words_on_activation() + self.comment_on_need_for_bias() + self.add_bias() + self.summarize_weights_and_biases() + + def setup_start(self): + self.weighted_sum = self.get_weighted_sum() + digit = self.get_digit() + rect = SurroundingRectangle(digit) + d_group = VGroup(digit, rect) + d_group.scale_to_fit_height(3) + d_group.to_edge(RIGHT) + weight_grid = digit.copy() + weight_grid.set_fill(BLACK, 0.5) + self.get_pixels_to_detect(weight_grid).set_fill( + GREEN, 0.5 + ) + self.get_surrounding_pixels_for_edge(weight_grid).set_fill( + RED, 0.5 + ) + weight_grid.move_to(digit) + + edges = self.neuron.edges_in + self.make_edges_weighted( + edges, 1.5*np.random.random(len(edges)) - 0.5 + ) + + Transform( + self.network_mob.layers[0], + self.network_mob.get_active_layer(0, np.random.random(16)) + ).update(1) + + self.add(self.weighted_sum, digit, weight_grid) + self.digit = digit + self.weight_grid = weight_grid + + def add_sigmoid_label(self): + name = TextMobject("Sigmoid") + sigma = self.weighted_sum[0][0] + name.next_to(sigma, UP) + name.to_edge(UP, SMALL_BUFF) + + arrow = Arrow( + name.get_bottom(), sigma.get_top(), + buff = SMALL_BUFF, + use_rectangular_stem = False, + max_tip_length_to_length_ratio = 0.3 + ) + + self.play( + Write(name), + ShowCreation(arrow), + ) + self.sigmoid_name = name + self.sigmoid_arrow = arrow + + def words_on_activation(self): + neuron = self.neuron + weighted_sum = self.weighted_sum + + activation_word = TextMobject("Activation") + activation_word.next_to(neuron, RIGHT) + arrow = Arrow(neuron, weighted_sum.get_bottom()) + arrow.highlight(WHITE) + words = TextMobject("How positive is this?") + words.next_to(self.weighted_sum, UP, SMALL_BUFF) + + self.play( + FadeIn(activation_word), + neuron.set_fill, WHITE, 0.8, + ) + self.dither() + self.play( + GrowArrow(arrow), + ReplacementTransform(activation_word, words), + ) + self.dither(2) + self.play(FadeOut(arrow)) + + self.how_positive_words = words + + def comment_on_need_for_bias(self): + neuron = self.neuron + weight_grid = self.weight_grid + colored_pixels = VGroup( + self.get_pixels_to_detect(weight_grid), + self.get_surrounding_pixels_for_edge(weight_grid), + ) + + words = TextMobject( + "Only activate meaningfully \\\\ when", + "weighted sum", "$> 10$" + ) + words.highlight_by_tex("weighted", GREEN) + words.next_to(neuron, RIGHT) + + self.play(Write(words, run_time = 2)) + self.play(ApplyMethod( + colored_pixels.shift, MED_LARGE_BUFF*UP, + rate_func = there_and_back, + run_time = 2, + submobject_mode = "lagged_start" + )) + self.dither() + + self.gt_ten = words[-1] + + def add_bias(self): + bias = TexMobject("-10") + wn, rp = self.weighted_sum[-2:] + bias.next_to(wn, RIGHT, SMALL_BUFF) + bias.shift(0.02*UP) + rp.generate_target() + rp.target.next_to(bias, RIGHT, SMALL_BUFF) + + rect = SurroundingRectangle(bias, buff = 0.5*SMALL_BUFF) + name = TextMobject("``bias''") + name.next_to(rect, DOWN) + VGroup(rect, name).highlight(BLUE) + + self.play( + ReplacementTransform( + self.gt_ten.copy(), bias, + run_time = 2 + ), + MoveToTarget(rp), + ) + self.dither(2) + self.play( + ShowCreation(rect), + Write(name) + ) + self.dither(2) + + self.bias_name = name + + def summarize_weights_and_biases(self): + weight_grid = self.weight_grid + bias_name = self.bias_name + + self.play(LaggedStart( + ApplyMethod, weight_grid, + lambda p : (p.set_fill, + random.choice([GREEN, GREEN, RED]), + random.random() + ), + rate_func = there_and_back, + lag_ratio = 0.4, + run_time = 4 + )) + self.dither() + self.play(Indicate(bias_name)) + self.dither(2) + + ### + + def get_weighted_sum(self): + args = ["\\sigma \\big("] + for d in range(1, 4): + args += ["w_%d"%d, "a_%d"%d, "+"] + args += ["\\cdots", "+", "w_n", "a_n"] + args += ["\\big)"] + weighted_sum = TexMobject(*args) + weighted_sum.highlight_by_tex("w_", GREEN) + weighted_sum.highlight_by_tex("\\big", YELLOW) + weighted_sum.to_edge(UP, LARGE_BUFF) + weighted_sum.shift(RIGHT) + + return weighted_sum + +class BiasForInactiviyWords(Scene): + def construct(self): + words = TextMobject("Bias for inactivity") + words.highlight(BLUE) + words.scale_to_fit_width(2*SPACE_WIDTH - 1) + words.to_edge(UP) + + self.play(Write(words)) + self.dither(3) + +class ContinualEdgeUpdate(ContinualAnimation): + CONFIG = { + "max_stroke_width" : 3, + "stroke_width_exp" : 7, + "n_cycles" : 5, + } + def __init__(self, network_mob, **kwargs): + digest_config(self, kwargs) + n_cycles = self.n_cycles + edges = VGroup(*it.chain(*network_mob.edge_groups)) + self.move_to_targets = [] + for edge in edges: + edge.colors = [ + random.choice([GREEN, GREEN, GREEN, RED]) + for x in range(n_cycles) + ] + msw = self.max_stroke_width + edge.widths = [ + msw*random.random()**self.stroke_width_exp + for x in range(n_cycles) + ] + edge.cycle_time = 1 + random.random() + + edge.generate_target() + edge.target.set_stroke(edge.colors[0], edge.widths[0]) + self.move_to_targets.append(MoveToTarget(edge)) + self.edges = edges + ContinualAnimation.__init__(self, edges, **kwargs) + + def update_mobject(self, dt): + if self.internal_time < 1: + alpha = smooth(self.internal_time) + for move_to_target in self.move_to_targets: + move_to_target.update(alpha) + return + for edge in self.edges: + t = (self.internal_time-1)/edge.cycle_time + alpha = ((self.internal_time-1)%edge.cycle_time)/edge.cycle_time + low_n = int(t)%len(edge.colors) + high_n = int(t+1)%len(edge.colors) + color = interpolate_color(edge.colors[low_n], edge.colors[high_n], alpha) + width = interpolate(edge.widths[low_n], edge.widths[high_n], alpha) + edge.set_stroke(color, width) + +class ShowRemainingNetwork(IntroduceWeights): + def construct(self): + self.force_skipping() + self.zoom_in_on_one_neuron() + self.revert_to_original_skipping_status() + + self.show_all_of_second_layer() + self.count_in_biases() + self.compute_layer_two_of_weights_and_biases_count() + self.show_remaining_layers() + self.show_final_number() + self.tweak_weights() + + def show_all_of_second_layer(self): + example_neuron = self.neuron + layer = self.network_mob.layers[1] + + neurons = VGroup(*layer.neurons) + neurons.remove(example_neuron) + + words = TextMobject("784", "weights", "per neuron") + words.next_to(layer.neurons[0], RIGHT) + words.to_edge(UP) + + self.play(FadeIn(words)) + last_edges = None + for neuron in neurons[:7]: + edges = neuron.edges_in + added_anims = [] + if last_edges is not None: + added_anims += [ + last_edges.set_stroke, None, 1 + ] + edges.set_stroke(width = 2) + self.play( + ShowCreation(edges, submobject_mode = "lagged_start"), + FadeIn(neuron), + *added_anims, + run_time = 1.5 + ) + last_edges = edges + self.play( + LaggedStart( + ShowCreation, VGroup(*[ + n.edges_in for n in neurons[7:] + ]), + run_time = 3, + ), + LaggedStart( + FadeIn, VGroup(*neurons[7:]), + run_time = 3, + ), + VGroup(*last_edges[1:]).set_stroke, None, 1 + ) + self.dither() + + self.weights_words = words + + def count_in_biases(self): + neurons = self.network_mob.layers[1].neurons + words = TextMobject("One", "bias","for each") + words.next_to(neurons, RIGHT, buff = 2) + arrows = VGroup(*[ + Arrow( + words.get_left(), + neuron.get_center(), + color = BLUE + ) + for neuron in neurons + ]) + + self.play( + FadeIn(words), + LaggedStart( + GrowArrow, arrows, + run_time = 3, + lag_ratio = 0.3, + ) + ) + self.dither() + + self.bias_words = words + self.bias_arrows = arrows + + def compute_layer_two_of_weights_and_biases_count(self): + ww1, ww2, ww3 = weights_words = self.weights_words + bb1, bb2, bb3 = bias_words = self.bias_words + bias_arrows = self.bias_arrows + + times_16 = TexMobject("\\times 16") + times_16.next_to(ww1, RIGHT, SMALL_BUFF) + ww2.generate_target() + ww2.target.next_to(times_16, RIGHT) + + bias_count = TextMobject("16", "biases") + bias_count.next_to(ww2.target, RIGHT, LARGE_BUFF) + + self.play( + Write(times_16), + MoveToTarget(ww2), + FadeOut(ww3) + ) + self.dither() + self.play( + ReplacementTransform(times_16.copy(), bias_count[0]), + FadeOut(bb1), + ReplacementTransform(bb2, bias_count[1]), + FadeOut(bb3), + LaggedStart(FadeOut, bias_arrows) + ) + self.dither() + + self.weights_count = VGroup(ww1, times_16, ww2) + self.bias_count = bias_count + + def show_remaining_layers(self): + weights_count = self.weights_count + bias_count = self.bias_count + for count in weights_count, bias_count: + count.generate_target() + count.prefix = VGroup(*count.target[:-1]) + + added_weights = TexMobject( + "+16\\!\\times\\! 16 + 16 \\!\\times\\! 10" + ) + added_weights.to_corner(UP+RIGHT) + weights_count.prefix.next_to(added_weights, LEFT, SMALL_BUFF) + weights_count.target[-1].next_to( + VGroup(weights_count.prefix, added_weights), + DOWN + ) + + added_biases = TexMobject("+ 16 + 10") + group = VGroup(bias_count.prefix, added_biases) + group.arrange_submobjects(RIGHT, SMALL_BUFF) + group.next_to(weights_count.target[-1], DOWN, LARGE_BUFF) + bias_count.target[-1].next_to(group, DOWN) + + network_mob = self.network_mob + edges = VGroup(*it.chain(*network_mob.edge_groups[1:])) + neurons = VGroup(*it.chain(*[ + layer.neurons for layer in network_mob.layers[2:] + ])) + + self.play( + MoveToTarget(weights_count), + MoveToTarget(bias_count), + Write(added_weights, run_time = 1), + Write(added_biases, run_time = 1), + LaggedStart( + ShowCreation, edges, + run_time = 4, + lag_ratio = 0.3, + ), + LaggedStart( + FadeIn, neurons, + run_time = 4, + lag_ratio = 0.3, + ) + ) + self.dither(2) + + weights_count.add(added_weights) + bias_count.add(added_biases) + + def show_final_number(self): + group = VGroup( + self.weights_count, + self.bias_count, + ) + group.generate_target() + group.target.scale_in_place(0.8) + rect = SurroundingRectangle(group.target, buff = MED_SMALL_BUFF) + num_mob = TexMobject("13{,}002") + num_mob.scale(1.5) + num_mob.next_to(rect, DOWN) + + self.play( + ShowCreation(rect), + MoveToTarget(group), + ) + self.play(Write(num_mob)) + self.dither() + + self.final_number = num_mob + + def tweak_weights(self): + learning = TextMobject("Learning $\\rightarrow$") + finding_words = TextMobject( + "Finding the right \\\\ weights and biases" + ) + group = VGroup(learning, finding_words) + group.arrange_submobjects(RIGHT) + group.scale(0.8) + group.next_to(self.final_number, DOWN, MED_LARGE_BUFF) + + self.add(ContinualEdgeUpdate(self.network_mob)) + self.dither(5) + self.play(Write(group)) + self.dither(10) + + ### + + def get_edge_weight_wandering_anim(self, edges): + for edge in edges: + edge.generate_target() + edge.target.set_stroke( + color = random.choice([GREEN, GREEN, GREEN, RED]), + width = 3*random.random()**7 + ) + self.play( + LaggedStart( + MoveToTarget, edges, + lag_ratio = 0.6, + run_time = 2, + ), + *added_anims + ) + +class ImagineSettingByHand(Scene): + def construct(self): + randy = Randolph() + randy.scale(0.7) + randy.to_corner(DOWN+LEFT) + + bubble = randy.get_bubble() + network_mob = NetworkMobject( + Network(sizes = [8, 6, 6, 4]), + neuron_stroke_color = WHITE + ) + network_mob.scale(0.7) + network_mob.move_to(bubble.get_bubble_center()) + network_mob.shift(MED_SMALL_BUFF*RIGHT + SMALL_BUFF*(UP+RIGHT)) + + self.add(randy, bubble, network_mob) + self.add(ContinualEdgeUpdate(network_mob)) + self.play(randy.change, "pondering") + self.dither() + self.play(Blink(randy)) + self.dither() + self.play(randy.change, "horrified", network_mob) + self.play(Blink(randy)) + self.dither(10) + +class WhenTheNetworkFails(MoreHonestMNistNetworkPreview): + CONFIG = { + "network_mob_config" : {"layer_to_layer_buff" : 2} + } + def construct(self): + self.setup_network_mob() + self.black_box() + self.incorrect_classification() + self.ask_about_weights() + + def setup_network_mob(self): + self.network_mob.scale(0.8) + self.network_mob.to_edge(DOWN) + + def black_box(self): + network_mob = self.network_mob + layers = VGroup(*network_mob.layers[1:3]) + box = SurroundingRectangle( + layers, + stroke_color = WHITE, + fill_color = BLACK, + fill_opacity = 0.8, + ) + words = TextMobject("...rather than treating this as a black box") + words.next_to(box, UP, LARGE_BUFF) + + self.play( + Write(words, run_time = 2), + DrawBorderThenFill(box) + ) + self.dither() + self.play(*map(FadeOut, [words, box])) + + def incorrect_classification(self): + network = self.network + training_data, validation_data, test_data = load_data_wrapper() + for in_vect, result in test_data[20:]: + network_answer = np.argmax(network.feedforward(in_vect)) + if network_answer != result: + break + self.feed_in_image(in_vect) + + wrong = TextMobject("Wrong!") + wrong.highlight(RED) + wrong.next_to(self.network_mob.layers[-1], UP+RIGHT) + self.play(Write(wrong, run_time = 1)) + + def ask_about_weights(self): + question = TextMobject( + "What weights are used here?\\\\", + "What are they doing?" + ) + question.next_to(self.network_mob, UP) + + self.add(ContinualEdgeUpdate(self.network_mob)) + self.play(Write(question)) + self.dither(10) + + + ### + + def reset_display(self, *args): + pass + +class EvenWhenItWorks(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "Even when it works,\\\\", + "dig into why." + ) + self.change_student_modes(*["pondering"]*3) + self.dither(7) + +class IntroduceWeightMatrix(NetworkScene): + CONFIG = { + "network_mob_config" : { + "neuron_stroke_color" : WHITE, + "neuron_fill_color" : WHITE, + "neuron_radius" : 0.35, + "layer_to_layer_buff" : 2, + }, + "layer_sizes" : [8, 6], + } + def construct(self): + self.setup_network_mob() + self.show_weighted_sum() + self.organize_activations_into_column() + self.organize_weights_as_matrix() + self.show_meaning_of_matrix_row() + self.connect_weighted_sum_to_matrix_multiplication() + self.add_bias_vector() + self.apply_sigmoid() + self.write_clean_final_expression() + + def setup_network_mob(self): + self.network_mob.to_edge(LEFT, buff = LARGE_BUFF) + self.network_mob.layers[1].neurons.shift(0.02*RIGHT) + + def show_weighted_sum(self): + self.fade_many_neurons() + self.activate_first_layer() + self.show_first_neuron_weighted_sum() + self.add_bias() + self.add_sigmoid() + ## + + def fade_many_neurons(self): + anims = [] + neurons = self.network_mob.layers[1].neurons + for neuron in neurons[1:]: + neuron.save_state() + neuron.edges_in.save_state() + anims += [ + neuron.fade, 0.8, + neuron.set_fill, None, 0, + neuron.edges_in.fade, 0.8, + ] + anims += [ + Animation(neurons[0]), + Animation(neurons[0].edges_in), + ] + self.play(*anims) + + def activate_first_layer(self): + layer = self.network_mob.layers[0] + activations = 0.7*np.random.random(len(layer.neurons)) + active_layer = self.network_mob.get_active_layer(0, activations) + a_labels = VGroup(*[ + TexMobject("a^{(0)}_%d"%d) + for d in range(len(layer.neurons)) + ]) + for label, neuron in zip(a_labels, layer.neurons): + label.scale(0.75) + label.move_to(neuron) + + self.play( + Transform(layer, active_layer), + Write(a_labels, run_time = 2) + ) + + self.a_labels = a_labels + + def show_first_neuron_weighted_sum(self): + neuron = self.network_mob.layers[1].neurons[0] + a_labels = VGroup(*self.a_labels[:2]).copy() + a_labels.generate_target() + w_labels = VGroup(*[ + TexMobject("w_{0, %d}"%d) + for d in range(len(a_labels)) + ]) + weighted_sum = VGroup() + symbols = VGroup() + for a_label, w_label in zip(a_labels.target, w_labels): + a_label.scale(1./0.75) + plus = TexMobject("+") + weighted_sum.add(w_label, a_label, plus) + symbols.add(plus) + weighted_sum.add( + TexMobject("\\cdots"), + TexMobject("+"), + TexMobject("w_{0, n}"), + TexMobject("a^{(0)}_n"), + ) + + weighted_sum.arrange_submobjects(RIGHT) + a1_label = TexMobject("a^{(1)}_0") + a1_label.next_to(neuron, RIGHT) + equals = TexMobject("=").next_to(a1_label, RIGHT) + weighted_sum.next_to(equals, RIGHT) + + symbols.add(*weighted_sum[-4:-2]) + w_labels.add(weighted_sum[-2]) + a_labels.add(self.a_labels[-1].copy()) + a_labels.target.add(weighted_sum[-1]) + a_labels.add(VGroup(*self.a_labels[2:-1]).copy()) + a_labels.target.add(VectorizedPoint(weighted_sum[-4].get_center())) + + VGroup(a1_label, equals, weighted_sum).scale( + 0.75, about_point = a1_label.get_left() + ) + + w_labels.highlight(GREEN) + w_labels.shift(0.6*SMALL_BUFF*DOWN) + a_labels.target.shift(0.5*SMALL_BUFF*UP) + + self.play( + Write(a1_label), + Write(equals), + neuron.set_fill, None, 0.3, + run_time = 1 + ) + self.play(MoveToTarget(a_labels, run_time = 1.5)) + self.play( + Write(w_labels), + Write(symbols), + ) + + self.a1_label = a1_label + self.a1_equals = equals + self.w_labels = w_labels + self.a_labels_in_sum = a_labels + self.symbols = symbols + self.weighted_sum = VGroup(w_labels, a_labels, symbols) + + def add_bias(self): + weighted_sum = self.weighted_sum + bias = TexMobject("+\\,", "b_0") + bias.scale(0.75) + bias.next_to(weighted_sum, RIGHT, SMALL_BUFF) + bias.shift(0.5*SMALL_BUFF*DOWN) + name = TextMobject("Bias") + name.scale(0.75) + name.next_to(bias, DOWN, MED_LARGE_BUFF) + arrow = Arrow(name, bias, buff = SMALL_BUFF) + VGroup(name, arrow, bias).highlight(BLUE) + + self.play( + FadeIn(name), + FadeIn(bias), + GrowArrow(arrow), + ) + + self.weighted_sum.add(bias) + + self.bias = bias + self.bias_name = VGroup(name, arrow) + + def add_sigmoid(self): + weighted_sum = self.weighted_sum + weighted_sum.generate_target() + sigma, lp, rp = mob = TexMobject("\\sigma\\big(\\big)") + # mob.scale(0.75) + sigma.move_to(weighted_sum.get_left()) + sigma.shift(0.5*SMALL_BUFF*(DOWN+RIGHT)) + lp.next_to(sigma, RIGHT, SMALL_BUFF) + weighted_sum.target.next_to(lp, RIGHT, SMALL_BUFF) + rp.next_to(weighted_sum.target, RIGHT, SMALL_BUFF) + + name = TextMobject("Sigmoid") + name.next_to(sigma, UP, MED_LARGE_BUFF) + arrow = Arrow(name, sigma, buff = SMALL_BUFF) + sigmoid_name = VGroup(name, arrow) + VGroup(sigmoid_name, mob).highlight(YELLOW) + + self.play( + FadeIn(mob), + MoveToTarget(weighted_sum), + MaintainPositionRelativeTo(self.bias_name, self.bias), + ) + self.play(FadeIn(sigmoid_name)) + + self.sigma = sigma + self.sigma_parens = VGroup(lp, rp) + self.sigmoid_name = sigmoid_name + + ## + + def organize_activations_into_column(self): + a_labels = self.a_labels.copy() + a_labels.generate_target() + column = a_labels.target + a_labels_in_sum = self.a_labels_in_sum + + dots = TexMobject("\\vdots") + mid_as = VGroup(*column[2:-1]) + Transform(mid_as, dots).update(1) + last_a = column[-1] + new_last_a = TexMobject( + last_a.get_tex_string().replace("7", "n") + ) + new_last_a.replace(last_a) + Transform(last_a, new_last_a).update(1) + + VGroup( + *column[:2] + [mid_as] + [column[-1]] + ).arrange_submobjects(DOWN) + column.shift(DOWN + 3.5*RIGHT) + + pre_brackets = self.get_brackets(a_labels) + post_bracketes = self.get_brackets(column) + pre_brackets.set_fill(opacity = 0) + + self.play(FocusOn(self.a_labels[0])) + self.play(LaggedStart( + Indicate, self.a_labels, + rate_func = there_and_back, + run_time = 1 + )) + self.play( + MoveToTarget(a_labels), + Transform(pre_brackets, post_bracketes), + run_time = 2 + ) + self.dither() + self.play(*[ + LaggedStart(Indicate, mob, rate_func = there_and_back) + for mob in a_labels, a_labels_in_sum + ]) + self.dither() + + self.a_column = a_labels + self.a_column_brackets = pre_brackets + + def organize_weights_as_matrix(self): + a_column = self.a_column + a_column_brackets = self.a_column_brackets + w_brackets = a_column_brackets.copy() + w_brackets.next_to(a_column_brackets, LEFT, SMALL_BUFF) + lwb, rwb = w_brackets + + w_labels = self.w_labels.copy() + w_labels.submobjects.insert( + 2, self.symbols[-2].copy() + ) + w_labels.generate_target() + w_labels.target.arrange_submobjects(RIGHT) + w_labels.target.next_to(a_column[0], LEFT, buff = 0.8) + lwb.next_to(w_labels.target, LEFT, SMALL_BUFF) + lwb.align_to(rwb, UP) + + row_1, row_k = [ + VGroup(*map(TexMobject, [ + "w_{%s, 0}"%i, + "w_{%s, 1}"%i, + "\\cdots", + "w_{%s, k}"%i, + ])) + for i in "1", "n" + ] + dots_row = VGroup(*map(TexMobject, [ + "\\vdots", "\\vdots", "\\ddots", "\\vdots" + ])) + + lower_rows = VGroup(row_1, dots_row, row_k) + lower_rows.scale(0.75) + last_row = w_labels.target + for row in lower_rows: + for target, mover in zip(last_row, row): + mover.move_to(target) + if "w" in mover.get_tex_string(): + mover.highlight(GREEN) + row.next_to(last_row, DOWN, buff = 0.45) + last_row = row + + self.play( + MoveToTarget(w_labels), + Write(w_brackets, run_time = 1) + ) + self.play(FadeIn( + lower_rows, + run_time = 3, + submobject_mode = "lagged_start", + )) + self.dither() + + self.top_matrix_row = w_labels + self.lower_matrix_rows = lower_rows + self.matrix_brackets = w_brackets + + def show_meaning_of_matrix_row(self): + row = self.top_matrix_row + edges = self.network_mob.layers[1].neurons[0].edges_in.copy() + edges.set_stroke(GREEN, 5) + rect = SurroundingRectangle(row, color = GREEN_B) + + self.play(ShowCreation(rect)) + for x in range(2): + self.play(LaggedStart( + ShowCreationThenDestruction, edges, + lag_ratio = 0.8 + )) + self.dither() + + self.top_row_rect = rect + + def connect_weighted_sum_to_matrix_multiplication(self): + a_column = self.a_column + a_brackets = self.a_column_brackets + top_row_rect = self.top_row_rect + + column_rect = SurroundingRectangle(a_column) + + equals = TexMobject("=") + equals.next_to(a_brackets, RIGHT) + result_brackets = a_brackets.copy() + result_terms = VGroup() + for i in 0, 1, 4, -1: + a = a_column[i] + if i == 4: + mob = TexMobject("\\vdots") + else: + # mob = Circle(radius = 0.2, color = YELLOW) + mob = TexMobject("?").scale(1.3).highlight(YELLOW) + result_terms.add(mob.move_to(a)) + VGroup(result_brackets, result_terms).next_to(equals, RIGHT) + + brace = Brace( + VGroup(self.w_labels, self.a_labels_in_sum), DOWN + ) + arrow = Arrow( + brace.get_bottom(), + result_terms[0].get_top(), + buff = SMALL_BUFF + ) + + self.play( + GrowArrow(arrow), + GrowFromCenter(brace), + ) + self.play( + Write(equals), + FadeIn(result_brackets), + ) + self.play(ShowCreation(column_rect)) + self.play(ReplacementTransform( + VGroup(top_row_rect, column_rect).copy(), + result_terms[0] + )) + self.play(LaggedStart( + FadeIn, VGroup(*result_terms[1:]) + )) + self.dither(2) + self.play(*map(FadeOut, [ + result_terms, result_brackets, equals, + arrow, brace, + top_row_rect, column_rect + ])) + + def add_bias_vector(self): + bias = self.bias + bias_name = self.bias_name + a_column_brackets = self.a_column_brackets + a_column = self.a_column + + plus = TexMobject("+") + b_brackets = a_column_brackets.copy() + b_column = VGroup(*map(TexMobject, [ + "b_0", "b_1", "\\vdots", "b_n", + ])) + b_column.scale(0.85) + b_column.arrange_submobjects(DOWN, buff = 0.35) + b_column.move_to(a_column) + b_column.highlight(BLUE) + plus.next_to(a_column_brackets, RIGHT) + VGroup(b_brackets, b_column).next_to(plus, RIGHT) + + bias_rect = SurroundingRectangle(bias) + + self.play(ShowCreation(bias_rect)) + self.play(FadeOut(bias_rect)) + self.play( + Write(plus), + Write(b_brackets), + Transform(self.bias[1].copy(), b_column[0]), + run_time = 1 + ) + self.play(LaggedStart( + FadeIn, VGroup(*b_column[1:]) + )) + self.dither() + + self.bias_plus = plus + self.b_brackets = b_brackets + self.b_column = b_column + + def apply_sigmoid(self): + expression_bounds = VGroup( + self.matrix_brackets[0], self.b_brackets[1] + ) + sigma = self.sigma.copy() + slp, srp = self.sigma_parens.copy() + + big_lp, big_rp = parens = TexMobject("()") + parens.scale(3) + parens.stretch_to_fit_height(expression_bounds.get_height()) + big_lp.next_to(expression_bounds, LEFT, SMALL_BUFF) + big_rp.next_to(expression_bounds, RIGHT, SMALL_BUFF) + parens.highlight(YELLOW) + + self.play( + sigma.scale, 2, + sigma.next_to, big_lp, LEFT, SMALL_BUFF, + Transform(slp, big_lp), + Transform(srp, big_rp), + ) + self.dither(2) + + self.big_sigma_group = VGroup(VGroup(sigma), slp, srp) + + def write_clean_final_expression(self): + self.fade_weighted_sum() + expression = TexMobject( + "\\textbf{a}^{(1)}", + "=", + "\\sigma", + "\\big(", + "\\textbf{W}", + "\\textbf{a}^{(0)}", + "+", + "\\textbf{b}", + "\\big)", + ) + expression.highlight_by_tex_to_color_map({ + "sigma" : YELLOW, + "big" : YELLOW, + "W" : GREEN, + "\\textbf{b}" : BLUE + }) + expression.next_to(self.big_sigma_group, UP, LARGE_BUFF) + a1, equals, sigma, lp, W, a0, plus, b, rp = expression + + neuron_anims = [] + neurons = VGroup(*self.network_mob.layers[1].neurons[1:]) + for neuron in neurons: + neuron_anims += [ + neuron.restore, + neuron.set_fill, None, random.random() + ] + neuron_anims += [ + neuron.edges_in.restore + ] + neurons.add_to_back(self.network_mob.layers[1].neurons[0]) + + self.play(ReplacementTransform( + VGroup( + self.top_matrix_row, self.lower_matrix_rows, + self.matrix_brackets + ).copy(), + VGroup(W), + )) + self.play(ReplacementTransform( + VGroup(self.a_column, self.a_column_brackets).copy(), + VGroup(VGroup(a0)), + )) + self.play( + ReplacementTransform( + VGroup(self.b_column, self.b_brackets).copy(), + VGroup(VGroup(b)) + ), + ReplacementTransform( + self.bias_plus.copy(), plus + ) + ) + self.play(ReplacementTransform( + self.big_sigma_group.copy(), + VGroup(sigma, lp, rp) + )) + self.dither() + self.play(*neuron_anims, run_time = 2) + self.play( + ReplacementTransform(neurons.copy(), a1), + FadeIn(equals) + ) + self.dither(2) + + def fade_weighted_sum(self): + self.play(*map(FadeOut, [ + self.a1_label, self.a1_equals, + self.sigma, self.sigma_parens, + self.weighted_sum, + self.bias_name, + self.sigmoid_name, + ])) + + + ### + + def get_brackets(self, mob): + lb, rb = both = TexMobject("\\big[\\big]") + both.scale_to_fit_width(mob.get_width()) + both.stretch_to_fit_height(1.2*mob.get_height()) + lb.next_to(mob, LEFT, SMALL_BUFF) + rb.next_to(mob, RIGHT, SMALL_BUFF) + return both + +class HorrifiedMorty(Scene): + def construct(self): + morty = Mortimer() + morty.flip() + morty.scale(2) + + for mode in "horrified", "hesitant": + self.play( + morty.change, mode, + morty.look, UP, + ) + self.play(Blink(morty)) + self.dither(2) + +class SigmoidAppliedToVector(Scene): + def construct(self): + tex = TexMobject(""" + \\sigma \\left( + \\left[\\begin{array}{c} + x \\\\ y \\\\ z + \\end{array}\\right] + \\right) = + \\left[\\begin{array}{c} + \\sigma(x) \\\\ \\sigma(y) \\\\ \\sigma(z) + \\end{array}\\right] + """) + tex.scale_to_fit_width(2*SPACE_WIDTH - 1) + tex.to_edge(DOWN) + indices = it.chain( + [0], range(1, 5), range(16, 16+4), + range(25, 25+2), [25+3], + range(29, 29+2), [29+3], + range(33, 33+2), [33+3], + ) + for i in indices: + tex[i].highlight(YELLOW) + self.add(tex) + self.dither() + +class EoLA3Wrapper(PiCreatureScene): + def construct(self): + morty = self.pi_creature + rect = ScreenRectangle(height = 5) + rect.next_to(morty, UP+LEFT) + rect.to_edge(UP, buff = LARGE_BUFF) + title = TextMobject("Essence of linear algebra") + title.next_to(rect, UP) + + self.play( + ShowCreation(rect), + FadeIn(title), + morty.change, "raise_right_hand", rect + ) + self.dither(4) + +class FeedForwardCode(ExternallyAnimatedScene): + pass + +class NeuronIsFunction(MoreHonestMNistNetworkPreview): + CONFIG = { + "network_mob_config" : { + "layer_to_layer_buff" : 2 + } + } + def construct(self): + self.setup_network_mob() + self.activate_network() + self.write_neuron_holds_a_number() + self.feed_in_new_image(8, 7) + self.neuron_is_function() + self.show_neuron_as_function() + self.fade_network_back_in() + self.network_is_a_function() + self.feed_in_new_image(9, 4) + self.dither(2) + + + def setup_network_mob(self): + self.network_mob.scale(0.7) + self.network_mob.to_edge(DOWN) + self.network_mob.shift(LEFT) + + def activate_network(self): + network_mob = self.network_mob + self.image_map = get_organized_images() + in_vect = self.image_map[3][0] + mnist_mob = MNistMobject(in_vect) + mnist_mob.next_to(network_mob, LEFT, MED_LARGE_BUFF, UP) + activations = self.network.get_activation_of_all_layers(in_vect) + for i, activation in enumerate(activations): + layer = self.network_mob.layers[i] + Transform( + layer, self.network_mob.get_active_layer(i, activation) + ).update(1) + self.add(mnist_mob) + + self.image_rect, self.curr_image = mnist_mob + + def write_neuron_holds_a_number(self): + neuron_word = TextMobject("Neuron") + arrow = Arrow(ORIGIN, DOWN, color = BLUE) + thing_words = TextMobject("Thing that holds \\\\ a number") + group = VGroup(neuron_word, arrow, thing_words) + group.arrange_submobjects(DOWN) + group.to_corner(UP+RIGHT, buff = LARGE_BUFF) + + neuron = self.network_mob.layers[2].neurons[2] + decimal = DecimalNumber(neuron.get_fill_opacity()) + decimal.scale_to_fit_width(0.7*neuron.get_width()) + decimal.move_to(neuron) + neuron_group = VGroup(neuron, decimal) + neuron_group.save_state() + decimal.set_fill(opacity = 0) + + self.play( + neuron_group.restore, + neuron_group.scale, 3, + neuron_group.next_to, neuron_word, LEFT, + FadeIn(neuron_word), + GrowArrow(arrow), + FadeIn( + thing_words, run_time = 2, + rate_func = squish_rate_func(smooth, 0.3, 1) + ) + ) + self.dither() + self.play(neuron_group.restore) + + self.neuron_word = neuron_word + self.neuron_word_arrow = arrow + self.thing_words = thing_words + self.neuron = neuron + self.decimal = decimal + + def feed_in_new_image(self, digit, choice): + in_vect = self.image_map[digit][choice] + + args = [] + for s in "answer_rect", "curr_image", "image_rect": + if hasattr(self, s): + args.append(getattr(self, s)) + else: + args.append(VectorizedPoint()) + MoreHonestMNistNetworkPreview.reset_display(self, *args) + self.feed_in_image(in_vect) + + def neuron_is_function(self): + thing_words = self.thing_words + cross = Cross(thing_words) + function_word = TextMobject("Function") + function_word.move_to(thing_words, UP) + + self.play( + thing_words.fade, + ShowCreation(cross) + ) + self.play( + FadeIn(function_word), + VGroup(thing_words, cross).to_edge, DOWN, + ) + self.dither() + + self.function_word = function_word + + def show_neuron_as_function(self): + neuron = self.neuron.copy() + edges = neuron.edges_in.copy() + prev_layer = self.network_mob.layers[1].copy() + + arrow = Arrow(ORIGIN, RIGHT, color = BLUE) + arrow.next_to(neuron, RIGHT, SMALL_BUFF) + decimal = DecimalNumber(neuron.get_fill_opacity()) + decimal.next_to(arrow, RIGHT) + + self.play( + FadeOut(self.network_mob), + *map(Animation, [neuron, edges, prev_layer]) + ) + self.play(LaggedStart( + ShowCreationThenDestruction, + edges.copy().set_stroke(YELLOW, 4), + )) + self.play( + GrowArrow(arrow), + Transform(self.decimal, decimal) + ) + self.dither(2) + + self.non_faded_network_parts = VGroup( + neuron, edges, prev_layer + ) + self.neuron_arrow = arrow + + def fade_network_back_in(self): + anims = [ + FadeIn( + mob, + run_time = 2, + submobject_mode = "lagged_start" + ) + for mob in self.network_mob.layers, self.network_mob.edge_groups + ] + anims += [ + FadeOut(self.neuron_arrow), + FadeOut(self.decimal), + ] + anims.append(Animation(self.non_faded_network_parts)) + + self.play(*anims) + self.remove(self.non_faded_network_parts) + + def network_is_a_function(self): + neuron_word = self.neuron_word + network_word = TextMobject("Network") + network_word.highlight(YELLOW) + network_word.move_to(neuron_word) + + func_tex = TexMobject( + "f(a_0, \\dots, a_{783}) = ", + """\\left[ + \\begin{array}{c} + y_0 \\\\ \\vdots \\\\ y_{9} + \\end{array} + \\right]""" + ) + func_tex.to_edge(UP) + func_tex.shift(MED_SMALL_BUFF*LEFT) + + self.play( + ReplacementTransform(neuron_word, network_word), + FadeIn(func_tex) + ) + + ### + + def reset_display(self, answer_rect, image, image_rect): + #Don't do anything, just record these args + self.answer_rect = answer_rect + self.curr_image = image + self.image_rect = image_rect + return + +class ComplicationIsReassuring(TeacherStudentsScene): + def construct(self): + self.student_says( + "It kind of has to \\\\ be complicated, right?", + target_mode = "speaking", + student_index = 0 + ) + self.play(self.teacher.change, "happy") + self.dither(4) + +class NextVideo(MoreHonestMNistNetworkPreview, PiCreatureScene): + CONFIG = { + "network_mob_config" : { + "neuron_stroke_color" : WHITE, + "layer_to_layer_buff" : 2.5, + "brace_for_large_layers" : False, + } + } + def setup(self): + MoreHonestMNistNetworkPreview.setup(self) + PiCreatureScene.setup(self) + + def construct(self): + self.network_and_data() + self.show_next_video() + self.talk_about_subscription() + self.show_video_neural_network() + + def network_and_data(self): + morty = self.pi_creature + network_mob = self.network_mob + network_mob.to_edge(LEFT) + for obj in network_mob, self: + obj.remove(network_mob.output_labels) + network_mob.scale(0.7) + network_mob.shift(RIGHT) + edge_update = ContinualEdgeUpdate(network_mob) + + training_data, validation_data, test_data = load_data_wrapper() + data_mobs = VGroup() + for vect, num in test_data[:30]: + image = MNistMobject(vect) + image.scale_to_fit_height(0.7) + arrow = Arrow(ORIGIN, RIGHT, color = BLUE) + num_mob = TexMobject(str(num)) + group = Group(image, arrow, num_mob) + group.arrange_submobjects(RIGHT, buff = SMALL_BUFF) + group.next_to(ORIGIN, RIGHT) + data_mobs.add(group) + + data_mobs.next_to(network_mob, UP) + + self.add(edge_update) + self.play(morty.change, "confused", network_mob) + self.dither(2) + for data_mob in data_mobs: + self.add(data_mob) + self.dither(0.2) + self.remove(data_mob) + + self.content = network_mob + self.edge_update = edge_update + + def show_next_video(self): + morty = self.pi_creature + content = self.content + + video = VideoIcon() + video.scale_to_fit_height(2) + video.set_fill(RED, 0.8) + video.next_to(morty, UP+LEFT) + + rect = SurroundingRectangle(video) + rect.set_stroke(width = 0) + rect.set_fill(BLACK, 0.5) + + words = TextMobject("On learning") + words.next_to(video, UP) + + if self.edge_update.internal_time < 1: + self.edge_update.internal_time = 2 + self.play( + content.scale_to_fit_height, 0.8*video.get_height(), + content.move_to, video, + morty.change, "raise_right_hand", + FadeIn(rect), + FadeIn(video), + ) + self.add_foreground_mobjects(rect, video) + self.dither(2) + self.play(Write(words)) + self.dither(2) + + self.video = Group(content, rect, video, words) + + def talk_about_subscription(self): + morty = self.pi_creature + morty.generate_target() + morty.target.change("hooray") + morty.target.rotate( + np.pi, axis = UP, about_point = morty.get_left() + ) + morty.target.shift(LEFT) + video = self.video + + + subscribe_word = TextMobject( + "Subscribe", "!", + arg_separator = "" + ) + bang = subscribe_word[1] + subscribe_word.to_corner(DOWN+RIGHT) + subscribe_word.shift(2*UP) + q_mark = TextMobject("?") + q_mark.move_to(bang, LEFT) + arrow = Arrow(ORIGIN, DOWN, color = RED, buff = 0) + arrow.next_to(subscribe_word, DOWN) + arrow.shift(RIGHT) + + self.play( + Write(subscribe_word), + self.video.shift, 3*LEFT, + MoveToTarget(morty), + ) + self.play(GrowArrow(arrow)) + self.dither(2) + self.play(morty.change, "maybe", arrow) + self.play(Transform(bang, q_mark)) + self.dither(3) + + def show_video_neural_network(self): + morty = self.pi_creature + + network_mob, rect, video, words = self.video + network_mob.generate_target() + network_mob.target.scale_to_fit_height(5) + network_mob.target.to_corner(UP+LEFT) + neurons = VGroup(*network_mob.target.layers[-1].neurons[:2]) + neurons.set_stroke(width = 0) + + video.generate_target() + video.target.set_fill(opacity = 1) + video.target.scale_to_fit_height(neurons.get_height()) + video.target.move_to(neurons, LEFT) + + self.play( + MoveToTarget(network_mob), + MoveToTarget(video), + FadeOut(words), + FadeOut(rect), + morty.change, "raise_left_hand" + ) + + neuron_pairs = VGroup(*[ + VGroup(*network_mob.layers[-1].neurons[2*i:2*i+2]) + for i in range(1, 5) + ]) + for pair in neuron_pairs: + video = video.copy() + video.move_to(pair, LEFT) + pair.target = video + + self.play(LaggedStart( + MoveToTarget, neuron_pairs, + run_time = 3 + )) + self.play(morty.change, "shruggie") + self.dither(10) + + ### + +class NNPatreonThanks(PatreonThanks): + CONFIG = { + "specific_patrons" : [ + "Desmos", + "Burt Humburg", + "CrypticSwarm", + "Juan Benet", + "Ali Yahya", + "William", + "Mayank M. Mehrotra", + "Lukas Biewald", + "Samantha D. Suplee", + "Yana Chernobilsky", + "Kaustuv DeBiswas", + "Kathryn Schmiedicke", + "Yu Jun", + "Dave Nicponski", + "Damion Kistler", + "Markus Persson", + "Yoni Nazarathy", + "Ed Kellett", + "Joseph John Cox", + "Luc Ritchie", + "Andy Nichols", + "Harsev Singh", + "Mads Elvheim", + "Erik Sundell", + "Xueqi Li", + "David G. Stork", + "Tianyu Ge", + "Ted Suzman", + "Linh Tran", + "Andrew Busey", + "Michael McGuffin", + "John Haley", + "Ankalagon", + "Eric Lavault", + "Boris Veselinovich", + "Julian Pulgarin", + "Jeff Linse", + "Cooper Jones", + "Ryan Dahl", + "Mark Govea", + "Robert Teed", + "Jason Hise", + "Meshal Alshammari", + "Bernd Sing", + "James Thornton", + "Mustafa Mahdi", + "Mathew Bramson", + "Jerry Ling", + "Vecht", + "Shimin Kuang", + "Rish Kundalia", + "Achille Brighton", + "Ripta Pasay", + ] + } + +class Thumbnail(NetworkScene): + CONFIG = { + "network_mob_config" : { + 'neuron_stroke_color' : WHITE + } + } + def construct(self): + network_mob = self.network_mob + network_mob.scale_to_fit_height(2*SPACE_HEIGHT - 1) + + edge_update = ContinualEdgeUpdate( + network_mob, + max_stroke_width = 10, + stroke_width_exp = 5, + ) + edge_update.internal_time = 3 + edge_update.update(0) + + self.add(network_mob) + + + + + + + + + + + + + + diff --git a/nn/pretrained_weights_and_biases_36 b/nn/pretrained_weights_and_biases_36 new file mode 100644 index 00000000..7c364af1 --- /dev/null +++ b/nn/pretrained_weights_and_biases_36 @@ -0,0 +1,63 @@ +((lp1 +cnumpy.core.multiarray +_reconstruct +p2 +(cnumpy +ndarray +p3 +(I0 +tS'b' +tRp4 +(I1 +(I36 +I784 +tcnumpy +dtype +p5 +(S'f8' +I0 +I1 +tRp6 +(I3 +S'<' +NNNI-1 +I-1 +I0 +tbI00 +S'e=\xe4\x9c\xa8\x83\xf1\xbf\xca\x17\xdef\x9a\xcd\xf1?\xd6\xd2\x93j\xb1\x0c\xd0\xbf\xe7\x87\xd1v\xd4\xf3\xf0?\xa0\x9bB\xf7\xcao\xf5?\x91\x92Z\xea%\xe0\xf0\xbfF\xd8\xd4X\x05O\xfa?\xb9+XY\to\xfc?.M\xd4|C3\xf6?\xde\x01\xe1h\xdf\xf0\xe3? -\x19\xd3\x05t\xba?2+\\\xc5x\xb6\xda?\x86i\xe7i(\xe8\xed?NC\xfbE>\x0c\xd2\xbf\xa0\x97_\x05\xb6p\xef\xbf\x1dN3\xe1P\x08\xc6?\xd8nH\xb9\xd8\x97\xcb\xbf\x00.\xd9\x16\xba\x05\xf4\xbf\xf1\x06s\xfaB-\xea\xbf\x8c=f]\xcb\xa9\xf7\xbf\xd6\xaajfgq\xea\xbf}\x0c![=\x0c\xf6\xbf\xf7JY\xf5Q\x86\xe6?/\x84\xe0F\xf6}\xe1\xbf\x9cX\xd1Cj\xc8\xdd?\xd90\xba\x9c\xce\xfd\xe3?\xfd\xf9\xf8\xe2\x92E\xf7?\x04\x96&\x05S\xf4\xc6?\x82-\xc2\x95\x1e\xca\xf1\xbf\xe4\x8d\xa7\xe8\x15\x1a\xc6?)\xf1\x1ag\x1cL\xea?\xc6\xd1\x99\x87\x01\xf4\x05@\x98v\xbfE\xc49\xfc\xbf\xcb\xe8\xa6r\xed\x88\xba\xbfP\x0eD*\xaeA\xcc?y\x92\xff\xc9\x88\xb5\xcf\xbfw\xd7\x98\x0cP\xe3\xa3\xbfZ\xfa\xc4y\x9c\xb0\xc1?w\xe7\\c\xd2\x94\xec?\xc3\x9b\xdc{\x94\xfa\xf1?U\xe8P\xd2\xc1\xbc\xf6\xbf\xd4\xbf$\x98\xd4\x94\xf0?s\xfb\x95\xdb%S\xd6?\xaf|(\xfc%\xa7\xdc\xbf\x15d\x19EX\n\xdd?\xc1^V5\x1e\xc9\xe8\xbf4\xf9\xbe5\xbd\x15\x82\xbfq6=1\x14\xa2\xf1?\x84(\x89\x1c(\x0f\xc2\xbf\xe4S\x02\xa6\x1c\xc7\xdd?\xf7\xe7=f\xd5\xfa\xd0?f\xa4[\xfe\x87H\xe8?\xd3\x12\xc9?\x8ef\xe4?\xaf[\x9e\xf6\xc5\xb9\xdb?\xa9\xa5\x95lw\xf5\xe7\xbf\xe8\x84A\xe1a\xc0\xf0?\x1cp\x87<\xe9\x9a\xf6?\xfd\xfbS\x99\xc1M\xd4?\xdc\xce\xcc\xb9:\t\xcc?b\x01_\xe2\xd3\xba\xe5?\xfaD%<\xffB\xeb\xbf\xd2\xfffc\x15(\xe9\xbf\xc1\x0b(Dz[\xe1?W\x1c\x9b\x06\x12\x9f\xfe\xbf\xe4V\xa0*\xfb0\xb1?\x1e\x04^\x9e\xc7C\xf2?&\xc1B\xc5\xb0\xdd\xcd\xbf.\xb3e\x8eS\x14\xe8\xbf1\xb5\x89N\xc7\xd4\xe6\xbf\xa6\xb6\x1f\x13\xc5\xdc\xf6\xbf/\x9f\x0eE\x97O\xdb?\xf5\xa0\xedw\xad\x0f\xf6\xbf\xe2 \xf2\x81\xb6\x85\xe5\xbf\xc0\x01WS$\xe2\xdb?\x80&\x91\xb1"\x9e\xf6\xbf\x94^\xa0\x99\x08\xf3\xed?\xe3\xe7\x8aA\xe7\xf4\xe4\xbf\xa1\xc5,y\x1d_\xd8?\t\xea\xd8X\xee\xb9\xd5\xbf\xd7)\xc2\xfc\'\xc5\xc7\xbf\t .[\x9f\xdd\xe3?\x8c\x87}\xb2Mh\xec\xbf*wF\x85\xca\xe3\xb5\xbf5`\x06wt\xefe?Z\xc5\xab\x88@\x07\xb4\xbf\r\xc0\x97\x8fbG\xe0\xbf\xc91P\x03\xfd~\xd4?\x9c@\xbd\xed\xf3\x06\xe9?q"\x89W\x9e\x14\xef\xbf\x84\xcb\xb1E\xe7\xcc\xea\xbf\x8f\xe3\x0f\x864\x84\xf1?\x946\xda\xa47\xb9\xd9?\x17lr\x8b\x08\xd6\xf9?\xdat\x80\xd6}^\xc9\xbfmAT\xfa\x84\x87\xf4?t\xf4\xec\n\xfb\x98\xf3\xbf\x04S\xe1e\x9e\x00\xcf\xbf}\xa8\xc6\x98\xb0\x10\xc4\xbf\x971\xe4wn\xbc\xa6\xbf0\x9f\x9e\xf7\xe9;\xcb?\xa7\x11:\x1c\xfa\xb6\xed?CbH,\x1d\x9e\xeb\xbf\xee\xe5N\x17\xfb\x9b\xf8?\x98s\x19\x98\xd4\x93\xf9\xbf\x0b\x0e\xe8\xc3\xef\x99\xfe?\xc8&\xf2.4\xc2\xc8\xbf*\x8et\xdb\xca\x97\xf0\xbf\xa4\xe1\x91\x90\x9c\x16\xd1?\x9f\x11?\xf4\x12\xd4\xc0?}oS\x82\x93\x1d\xf6?\xb8"\xa6\xbb|\xf1\xe1\xbf\xc8X\xd3,\xec,\xc3\xbf\x81W=g\xc9\xa9\xff?%\x10l\xd0\x01\xc2\xe4?\xe7\xcb|{0r\xf4?>1\xd0\x13|\x0f\x03@\x90)\xf9\xd5 R\xd2?\x97\x89y`\'W\xf2?\x0f[F\xc4[\xe8\xdc?\x1f\xd7[\xf4\xecU\xe2?f=x\x0e\r6\xf5?\xfbO\xa9G\xb4u\xc5?a\x8d\xa3]_\x96\xba?\xed\x108\xca8\xd3\xee?\xda\x81C\xa1\xb4s\xd8\xbf\x06\xec\x89\xd2_\x9f\xea\xbf\xb1\xe7\xd6\x0edx\xb4\xbfrB\xc6\x01\x9c>\xec?ZL\x8b\xb7yv\xe8\xbf\xb4+\xe2\x1f*\xae\xf3?\xbe\xc6BY\xe1i\xf1\xbfl\x12Z\x83lJ\xd9\xbf\xc8\xfc\x84\xb3\xf2\xe7\xea?vz\x1dG\x8b[\xe5\xbfSBY0Y\x0f\xe8\xbf\xc1\n\xf5w\x81%\xed\xbf6\t\x93\xce\x0f\xa5\xdd\xbf\xe9\xe9t\xa9\x1a\xde\xe3?7\x065\xe1!\xaa\xf6?\x18\x8f\x10\xa2\xda9\xfd\xbf\x17\xdf\x9d\x0b\x9c/\xea\xbf\xb7/\xfe\xf0\x93\xde\xb5\xbf\xed\x02\xaa\xf3\xf0>\xd4?\xcb:{\x10\xdb\x85\xdf\xbf\x97Z\xabV8\x1c\xe5\xbf`}I\r\xfb\xd6\xd7\xbf\x99\xe4\x8a\xac\x83i\xda?Y\xca\x1e\x01\x95\xd1\xe1?\xa0z\x91\xccI\xab\xa5?\xa5^\xf3h\xdas\xb7?\xa3\xee\xb15\xb0\t\xec?\xa5=\x13\x8c;<\xdd\xbfB+\x82\xf8\xea?\xc4\xbfC\xdco\xbf\xdb"\xed?\xaf\xf4\xe3\xcb\x1f\xda\xaa?g\x01\xffS,\x01\xeb?\xbe\xcb\xbfQ\xd8\x0b\xd8\xbfGM\xe3{x\xab\xea?\xbc\xda\xe9\x9f\xe4\xb1\xe5\xbf\r\x97ua\xd4\xbf\xe3\xbf\xaf\x1b-\x13\xd7O\x03\xc0\x07{\xc7\x84\x9b\xfa\xf3?\x04\xcf\x164\x1e\x0e\xa7\xbfv\xb3\xeb\x99P\x04\xff?E\xa3\x91\x83u\xae\x03@\xeba\xc0\xc3bJ\xf7?B\xeb\x8a\xf6S\xec\x02\xc0\xb3h\xa3\x07g^\xdb\xbf\x13\xa2(\xb2\x1c\x8c\xfb?g)\xc5\xce#B\xf7\xbfA\x14\xf0\xf0\x01\xe8\xd0\xbf\x82A\x19\x85$O\xd4?E\xb1\xc7H\xaeO\xdc?\x80 \xc5/\x0fY\xf5\xbf\xf1\x02B\x91%\xae\xcc\xbf=\x99\x0c\tt\xbb\xf2?\xb1\x01Ys\x026\xe9?I\xfd\xfbE\x90\x82\xe5?X\xe6{CXJ\xd5?\x90\xedk\x16j\xf1\xe0?|\x17\xaf\x82\xb8U\xdf?K*\x11\xd83~\xe8?\x85\x95\xe9\xf3JW\xf3\xbfM\xcc\x16G)U\xd9?\x93by\xc1\x06\xd9\xf1?\x9d&\x82\xa5X\xba\xa7?\nOf/%/\xcd?/\x12\xcf\x01x\xac\xc5\xbf.\xd7\xdf\xb3\xf6\x9c\xe5?\xc0e\xd0\x8c\xc0^\xd1\xbf\x0f\xeb\xd5\xd7\x16\xdf\xeb?\xa5\x0f\xd2\xba\xa7\x84\xe4?\xf5\xcd\xba\xe1\xe45\xb6?\xcc\x8b\xb8&\xf2A\xfe?&\xa2E\x8a\xd9\x0c\xf3\xbf\t\xda2;\x81\xca\xbe\xbf\x86\xb3\xaf\x9c\x04\x87\xd2?\x06C\x1bq\xe2\xd5\xf0\xbf\x1b@x;\x11\xf3\xe5\xbf=\x86\x0cg\xed\xb4\xc9\xbfl\x0cM\xb6\xcbS\xd2?\x98p+\xcd\x9e\xfc\xd6\xbf\xe7=\x01\xe1\x87\xa7\xed\xbf\xc5\xcf\xb3-\x7f\x1b\x81?_\xd4\xe2\xea\x08F\xf8?\xf6\x91\t\x1e\n\xc5\xf3?\x0c\xf28W\xcd\xcf\xee?\xbb\t\x19\x9cc\xe1\xd5\xbfz\xb3c\x7f\x17\xf4\xe0?\xfc&\xda\xca\xd8$v\xbf?\x99\xdd\x10\x08\xf7\xd1\xbf-B{\x9cr\xf8\xec\xbf\x0e\xba\xa4^\x14@\xdc?t\xc3m\x1d\xce\xd1\xef\xbf\x15Tv\x11~\x07\xe2\xbf\xf1\xf8)O\x99(\x01\xc0\xcdl\x1d\xe4\xc4\x93\xeb?I\xd6\xeaN\xd9\xb6\xdb\xbf\x1cv\x86\xef\xd0,\xe3\xbf-\xb5\x07\xdc\xd6z\x93?z#\xc3\x82\xe8\xb2\xf7?\xba\xbb\r\x89\xe4&\xea?\x89@*\xff\xa6n\xf6\xbf]&"\x08\xaf\xd9\xf4\xbf\xaf\xbc\xdb\x13\xfb\xcc\xf7\xbfSX\x07\xb60\xac\xe8\xbfZ\x0b"9x\xdb\xf5\xbf\xbdy\xbeC`\x05\xe8?\xe1\x9e$\xf8\xf0\xec\xe4\xbfR\x0c\xbe\xe9\xb0\x98\xde\xbf\xa2\xdf\x0b\xfb\xc2\xc5\xfc?\xb8\xc2\xd4\x8d\xbd|\xbf?\x04d\x99\xc0\xf8l\xd6\xbfu\xf9\x9aW\xe4\x04\xda\xbf\xd9\xbc\x81\x89"G\x93?\xee\xe8\xcer\x91"\xe9?}Y\xf2\xbe\x9d\x0c\xd4?-\x16P$\xa6\xac\xf9?\x7f\xa9\xc0o\xf8\x0e\xde?\xdd\x99\xa4*\xf0\x0e\xf1\xbf\x96/\x90\x8c\x17\xeb\xd9\xbf\x87>"k\xa3&\xe4\xbf\xcb5\x87\x9cRH\xd7?\xcd#z\xd4\xf3\xc2\xe4?Q\x99\xda\xc8\x91L\x03\xc0.\xe8y\xbb\xc6\x0e\xe3?\xeb\xe7%\x1c/\xf5\xd7?)\xa7\xf9\xf7B1\xcb\xbf\'\xc2\xe8\xd0\xb7\x17\xff?\x06\xdb\x18\xf0\xf7+\xf3?[\rki\'\xfd\xdb\xbf\x18\xef\xd5m\x1f\x8e\xcb\xbf\xafjU-\xdb5\xe7\xbf\xd8\xd5%\x04\x1b\xef\xc4\xbf\xa8\x156\xea\xa7\xf0\xe0\xbf\x9c\xf5[\xce\xa5\x01\xe1?\xf9\x97\xcb4\x89\xc4\xf5?\x00v\x14o\xe4A\x02\xc0\x19\r\xd4C~6\xed?N{\xd3\x19\xc1j\xc2\xbf\xea*\xceh\xea\xe8\x01\xc0\xc08\xa1,5\xa7\xb8\xbfq\x90+6eZ\xe1?\x0c\xacU\xa5\xe6Q\xa1?\x90|\x19f\x8e\xba\xc9\xbf4q\xffZ;\xbc\xfc?\xaa\x12_\xbf\x9bx\x03@\x11\x7f\xe6E\x06\xb3\xf6?\xe0$\xb2y\xda\\\xf9\xbf\xd5\x1f\xed\x9c\xa7\xa2\xe5\xbfz\xd4\xc3\xcds\x03\xe2\xbfn\xb1l\xe8\xba\xc0\xe1\xbf\x13g\xd4>Z\x85\xe9\xbf\xa9\xebM\x03I\xf4\xe9?\x99\x9f\x8d\xf4\x9f\xb1\xbb?\xb8 \xa9y0\xb5\x03@\x99\xc3\x89\xc3\xe5V\xf9?\x9b\x8f\xd6\x1d\xbf\xf3\xe2\xbf\xf0\xb0J\xad\x96\x08\xd1?\xf8\xf8K\x99C\x1a\xfb?\x97[\x14\xa0N\xf9\xf2?\x11\xbe\xe4:\xf0\xd9\xd8?F\x0f\xe0\xbe\xcb\x08\xfa\xbf\xe3\xb0\xb4y\x0c\x98\xf0?\x16\x01\x15\xae\xca\xf8\xe2?\xbb\xb9\xbf\x02Cj\xb3\xbf\xd9\xd2\xcc!\x0b\xd4\xf4\xbf\x9f_\x18\x81\xb3\x0c\xe9\xbf\xd3\xf4\xd6H\xce\xb2\xf3\xbf\x8f\x03\xad\n\xa2*\xdb?\xb8Y\x9a,\x83\xc0\xf3?\xf3qM\x01%\xfd\xeb?\xa6\xf5:\xf5\x02\xab\xeb?br9\x83\xd3k\xf3?g\'y.}C\xf1?\xa7\x1b\xeb\x93k\xca\xd3?6\x90\xac\xdb\xe0\x97\xf1\xbf{\x8c\x96\xd8x\x0b\xf5\xbf(\xf5\xb3i;\xa2\xed\xbft\xf5l\xe1\xf6\xf3?\x15\x03h\xd7\xb8 \xff?\x8e\xaf\xc5{\x7f\x1d\xc2?\xb8c)ab \xc1?\xdd\xea\x1d<\xa37\xf9?\xe2RV\x988\xeb\xc1\xbf\xea\xd9\xe2*6\xbb\xd4\xbf\x80$b\x97\x92u\xb6\xbf\x0e\x0b%\xa8dL\xe1\xbfS\xc5. C\x1c\xd5\xbf\xdb}\r\xa9\xe4\x96\xdb?\'\xe1\x16[C\x8f\x87\xbfc\x0b(^\xd8\x8d\xfb\xbf\x88\x82\xb6:\xe8=\x01\xc0\xfdl\xa7*J\x01\xf2\xbf\x0fp\xd4\x8c\xd6\xe2\xc0\xbfb\xf3\xd1,\xdf\x9c\xf4?\xa3A\x84\xb2\x8d\x9a\xc5\xbf=\xa9Y\x80i\x08\x07@\x81d\xf8\x0e\x99\xcf\xc8\xbf\xadY\xc4!1\xfa\xe2\xbf\xf2\x94\x18\xcf\x9e\xcb\xed\xbf^X\xa4\xdd\xa26\xf1\xbf\'\xcf\x12\xfe\xcbM\xd0\xbf\xbbCzT)\x02\xef?\xbej\xa5ao\x86\xf7?\r\xd00\xa1\x13D\xdf\xbf\x16LW\x96\x8b\x9d\x05@\x86\xfa\xcdn\x8f\x14\xc8\xbf~s\x8a\xf2\xcf\xd6\xf1\xbf\xfd\xed\x82c\x0e\xb3\xf3?\xeb\xa3\x91\x8a\x14#\xea\xbf2d\xda\x81#\x19\xf7?m\xf2x\x00I\x82\xd6\xbf\xc8\xaa\xf7\xfa1"\xd2?\xf6\xbb\xf1w\xceE\xce\xbf\xe1\x15\xc1\x91w\xdb\x87?\xe0\xf36Z\xf5\xbb\xb6\xbfT\x01\xcb\xbfE\x00\xc7\xbfv\xfa\x99|\x95\x0e\xcf?\x820\x93U4\xfc\xe3?\x15R\xfc\x86\xc2!\xc7?\x8cB\xf7\xf1\x1a@\xf8\xbfQ\xf0\x93G7\x7f\xf1\xbf\xf7U\x814n\xb3\xdf\xbf\xf5\x98\xc5\xe4\xa4\x07\xe5\xbf\xab\xc5\xe8\xad~\xd4\xd1\xbf\'h\xf2\x17\xb1\x19\xe1?\x0c\x8f\xd2\x97$\x9f\xf1?U\xdb\xb0\xd9\xbd\xfe\xdf?Kv=\xde\xbb\x90\xe1?@\x8aDx-m\xf3\xbf\xe7\xdf/\x8d\xd5L\xf0\xbf4d\x14\xb35\xd9\xf2?>\xcc\xc6\x86\xb5\\\x02@\x86\xa1\t\xd1;P\xba\xbf\xf9\xdf\xbb\t\xb6\xa1\xcb?\x968x`\xdc\x8e\xf6?\xc4\xb9A\xae\xe2\xf1\xf0?\x9f0\xaeG2\xef\xe1\xbf\x83\x1c(s\xeeL\x05@\x96{\x87\x0f\x06\x08\xc8?\x87\xf4\x9cO\x15\xfe\xd0?\xe6\xb7?\xa7\xe4\x8e\xc7\xbf\xbe\xf2\x97\x1f\x92\xa2\xf4\xbf\x9b\xd4\xc2\xc7\xe0\xe7\xb7\xbfrt\xbe\x0f\xa2\xbb\xdc?a-wR\xba?\xf5?p\xfb\x00i\xd8\x12\xfe?\x86\xfc\xfb\xef\x06\xe1\xc9\xbf\xdc\xd0\xf5\xcfA\xa0\xf3\xbf\xda\xe2\xc9\x1e\x19\x8b\xb7\xbf\xdcvAqN^\xf8\xbfa\xe5\x87\xbb}\xfa\xd5\xbf\x1bD\x05)\x92\xa7\xdd\xbf\x0c\xa1\n\x94\x12\x9e\x00\xc0(\xdc<\xd0\xa8\x7f\xdb?\xb8\x13dV\x00\x0c\xd6?\xd6]\xea^c\x9b\xe3\xbfx\x1b\xb7\xe7\xd0\x0c\x08\xc0\xc6g\xb4&5,\x06\xc0\xef#\xe0\xee\xf3\x11\xf3\xbf\xb0An@2\xb5\xe5\xbf\xe5\x05\xeb\'V\xff\xfd?8\xd9}7\x01\x9f\xd0?\xb9\x1f\xfe(\xd8\xde\xe5?\x0b\xe1tkK\x00\xf0?x\xa6<\xb9H\xa0\xf0?\xbe/\x1b,\x08\x9c\xf5?W\xb3\xe09\xd73\xce\xbf\x9c\x93\xba\x1e\xec\x05\x00@F\x82\x14\x83U\xcc\xfd\xbf\xe5\xb5\xa5\xf7\xf9L\xe8?\xd4TR\xddT\x16\xeb\xbf f\xca\x88n!\xc9?9\xa9\x86F\xf8\xdd\xe5\xbf]\x18<\xe6\xa0\xd2\xf0\xbf*\x14\xc0\xccNg\xef\xbfG\xb7Lg\xda\x0b\xc4\xbfE\x05\x1c\xc1\xce\x9a\xda\xbfl\xe1.\xcfC{\xc1?o{\xf0\xfa\xbd\t\xe7?;N\xb4\xc7]7\xf3?\xd3\xb2)\xef+Z\xf6\xbf\xae\x841\xf5\xd6s\xd0\xbf\x05{\xae\xa9\x8f\xd3\xf8?\xfa\xfedq\x11\xe2\xec\xbf\xcc\xac\xd1\xae_Q\xdd?\x13\xd5_=\x07\x0c\xe5?\x1c\xe0\xaao\x93\x9a\xce\xbfR\xacw_7\x90\xfb?\xe3\xf2\xeb\x05\xb40\x00\xc0\xf2G\x9e\xe8\x06\xcb\xe2\xbfM\xbes\xfd\'\x84\xf6\xbf\x86\xa10\xd4Q\xfd\xef?Z4\x19\x87\xcd\xaa\xe9\xbf\xb6m+\xcf\x8d&\xfd?a\x8by\xd68\xfb\xf9\xbf\xe3\xf3\xb2\xf8\x14e\xd2?\xe7\xb9&\xbf\xdf\xaf\xe4?\xe4\x81\xe4LU\xd2\x03\xc0\xd7\x0b+I\xbe\x00\xfe\xbfU\xd7]\xdd\x08e\x08\xc0\xfeJ\xd4\x9c*\x9b\x17\xc0\xbb\xb6\xaa\xead\xab\x16\xc0\xb67)t@\xed\x11\xc0\x0e\x95a\x8b\x0b\x04\x14\xc0\x9c\x9e\x03\xfe\x03\x95\x11\xc0\x0e\xee\x19\x9b\xf2\x1c\x02\xc0\xb6\xaf~o]\x7f\xe9\xbf\xf7e\xbfV\x13\'\xe8\xbf\x9f\x82V\x8a9\x1b\xa5\xbf\xab\xf9\x07]\x06\x95\xe7\xbf\xfei+\xf8\x8fL\xf8\xbf\xd0\x96\x0e\xa2\x9d\xaf\xc9\xbf\xc4\xa3\xe8\xa4\x90U\xae\xbf\xd7a\xb4{^r\xbf?O\xf5=\x91\x9d\x02\xe7\xbf-\x14aP\x99\xa4\xdb\xbf\x1c\xe6\xe2[5\x0c\xe9?C\xba\xa7vx\xba\xb9\xbf\xcf\xc96*\x80;\xf6?9q\xa7\xcd@\x9b\xc4\xbfB&;\xfd9\xb6\xd1?6\x9e \xe99b\xf8?IY\xcen\xa6\x95\xe3\xbf46\xad\x9a\xbf\xaa\xf9?\xb4\x9f\xc8\x19\x91\xa6\xe6?S\x0e\xd1V\xb2\x01\xf1\xbf\xea8nN\xdb\xd7\xe3\xbf_"\x17\x1bH\xd7\xe8\xbf\x1e\xa5\xe9\x0c/\xa1\xfb\xbf\x1f\x18\x99g\xdff\x03\xc0\xcd\xdf\xa4=\xf5$\x15\xc0E@zI\x95\xff\xfc\xbf\xc2\x04\xf5\t1w\x07\xc0\xaf\xe2\x06\x12\xf4\xa3\x81?*>\xff\xa0\xfa\xcb\xff\xbf\xf7\x1f\xb3ID\xf0\xf4\xbf\xf6t\xe8\x17\xd62\xcd\xbf\xfe\xc5\xdb\xe7\xf8\xbf\x00\xc0\xb5\xb5\xef\xb2\x08\xf4\xb4\xbf\xfd\x92p\xf3\xf6\xe4\xf0\xbf\xb5\xf4K\xb3\xd1w\xf1?\x9c\x82\xbfw\xdbs\xf2\xbf{\xd9\xea\xf6\xef\xf5\xd5?K\xd37\xecFg\xbe\xbft\xe46n\x8a^\xb4?\xc0w\x97\xb84w\xe9\xbf3\x00}A&%\xf3\xbf\x80\x05*wK[\xeb\xbfQ\xd3\x019\x13\xa1\xe2\xbfe-\xf1\xf9n|\xdb?*7\n\x1cz|\xb4\xbf\xf7-\xf8\xad\xe2h\xe9?\x0e/\xad\x08v3\xe3?n\x0c\x06\xb4T\xb2\xf8?u\x0c`\x1f1\xb7\xcf\xbf\xee\xeb{\xc5\xf02\xe6\xbf\xfa\x999\x02E\xf8\xe1\xbf\xe3\xe8\x0eH\xd8\x85\xd8?\xd6\x88y\xfaXa\xd9?\x0f\x8c\x1bd\xc3\xb3\xcd?\xa2\x8a\xc5Q\x18\xa5\xb4\xbfzK\xb5umD\xd9\xbf\x06j\x1bO4B\xf9?\xdd\xb53\t6\xe6\xf6\xbf\x05\x8e\xb6:\'\xe9\xe5?\xe3\xe20\xc7\xab\xf9\xe0\xbf\xf2\xa7\xfa\xba\x1b\xf8\xda\xbf\x0c\xe62L\x0f{\xb6?\x07\xe1\xa6\xca}\xf4\xeb\xbfREV\'\xaf\r\xf2\xbfc\xe9\xda,\xa5\x83\xda?\x14"qb\xc8\xe4\xd0\xbf\xb5\x17\xf5&\'w\xf9?\x90P\xc2\x86\x1f\x15\xeb\xbf\x05\xc8\x0e\x068;\xe5\xbfL\xe4\n\xaf\xc8\x81\xf6?!\x17\xb0\x85\xd6\x12\xa3\xbf\x0f>\xe0p\x14Q\xf7\xbf\'4\xeb\x12\xaa\xef\xe8?\r\xf6\x05;\x8cD\xe7\xbf*LXA\x85\x0b\xf2?\xa8L\t\xe1Y\x98\xe9\xbfXq\xe0\xcb\xa1\xf1\xd4?\xf0\xd8v0{<\xc0\xbf\x90RQc\xcb\xc6\xf2?\xdd\xa6\xf7\xfc9\x96\xf5?\x8a\xd4\x1d\xcaA\x14\xfc?:/\x1f\x1f\xd4@\xf2?\xf0\x8c6\xbbG\xed\xe5?5\xa7\xed~M\x87\xe9?\xbb(l\xd6:\xb6\xe4\xbfRr\xaa\x8d\xfa \xeb\xbf8\r<>\x93\xb8\xea?\xc5sv\x8e5\xa7\xe9\xbf\xa1\xae\x83\xfcW\xfc\xf4?\xc3\x8f\x8e\xf0=6\xef\xbf\xeaP\xfd\x8a\xffG\xd6?\x8e\\\x17\x9c\x97_\xe6?Z\x04\xb08\xd6\x1a\xd9?5%l\x8b\xf5\xbe\xda?C\xce0\xe3\xf4\x07\xf2?\xf7\x84\xb6\xa2\x89K\xef\xbf\x00U\x024\x06\x81\xb2?F\xb2\xa9W/H\xd3\xbf}\xbbO\xad\xf3\x13\x06@M\x10~l\xb7e\xd0?\xdbc6\x99\xa5\x07\xf1\xbf#\x0f`\x19\xc7\xca\xd4\xbf\xa0\x83\xf3\x8f\xd3\xd1\xa9\xbf\xd8\x90\xb5pF\xe4\xf1\xbf\xf1\xe3\xd5\xfb\x96\xb9\xd6?fQ\xab\xe3y(\xa0?\x14\xae\xd2e\xe9\xfd\xa4\xbfE\xcaa\xe5\x9dA\xec?\x11\x9b\x97\x01%\xb3\xeb?\xda\xd8]\xc7\x16\xdb\xed?\x00S5q\xed\x85\xd5\xbf\xd6P\x02U\xd4\xb1\xdf\xbf\x1f\xa2\xdf\xacc\x9d\x90?\x1cj\xdc\x18\x1eM\xd3?\x92\x881\x96\xc1\x8a\xf8\xbf\xf8\x97\xbc\xe3\x10\xa8\xee\xbfB\xd4\xc5\xd3g\x97\xed\xbf_X|w\xf2V\xd4?\xf5\x8a8\xc6\xdd\xd0\xec?\xeeU\x1e\xee\xa4[\xdd?\x92r:U\xb7\xe0\xf2\xbf\x1c]\xc6\x01K\x96\xd6\xbf\xdabW\x8d\r\xb8\xf1\xbf)\r\xcf\x17\xb2i\xee?\x0e\x88\xa1M\xbe\x13\xfe\xbf\x05\x95\xc5M\xdc\xe0\xbd?~\xb3u\xad\x9aG\xef?\x85\xf30\xac\xa4\x86\xb1?#\xf7\x8d\xa0\x0fV\xf0?\xc0\x1d\xde\r\x0e\xee\xf8?\xa5$\xe5\xfd\x84_\xe3?Q\xd2\xc7\xd2$\xb3\xfc\xbf\xca\xd0\xb0\x9c\xa6<\xc2?\xb2kt\x18B.\xd6\xbf\x9dg\xf0~*N\xe2?\xbf\xae1o\xe1\xfb\x00@;_+\x98\xf1\xfc\xed?\xa1,\xcc\x96\xdcm\xc0?\xbeG_\x99"\xc4\x03@\'PAn7\xc3\x92?(.\xeb\xd4\xa7\xdc\xe8?\x8f\xd6NdJ[\xf8?\xda<g\x90\x95\xa8\xc6\xc8\xbf\x11\xb1\x0f#\x15\xf3\xe9?03\x89\x19\xddf\xf8?\xe5\xed\xf4\xa9\xaa\x15\xbc\xbfU)\xa4\n\x18\x85\xf1?Q\xfb\xa4\xeboV\xde\xbf4\xda\xe25\x91\x89\xf0?\xa0\x06\xe0u\n\xc8\xf3?\x1e\xc1\xb5\x01\xd6\xaf\xf2?\xa3\xdc\'Z\xf4\xe4\xb2?\xe1\x0bd\xd4\xe3\xf3\xe1?YbS.:\xae\xd0\xbf\x84\xd8\x85o\x80\x00\xa9?\x1a\xf2\xc60\x84\x04\xee?\xb6\x97c3\x14g\x00\xc0\xa4\xe1\x08\x19\xdb\x99\xfc\xbf\xd3\xf9h\xdc\xd3\xd0\xab?\xbf:C\xb0;\xc3\xef?\xbc}\xd4=4+\xbe\xbfh\x1b\xdfz0\x90\xe1\xbfuy\xb4\xec@\xe3\xea\xbf\x95\x07M\xad\x06\xd7\x98?\xcad^\x04uY\xb1\xbf\xbd\xb2gcCO\xe8?\xcbp\x03E\xf0$\xd7?\x89\nA1\xf8n\xc7\xbf\xc9\xbbj\xac\xa4\xea\xfd\xbf:u\x8b\xd2/.\xe7?\x18\x0e$\x07Y\xc2\xdd?u\xaf\xb1[0\xb5\xdd\xbf\xda\x95\xb5f\x803\xc5?\xb6\xbe\'\xb9\xd4k\xe3?\x8fB\x01\xe3n\xcb\xdd?\x12DH\xa6?\xd3\x93?\xf0\xb7\xa2\xa8\xc5G\xf0?\xb7\xc13\r\x88c\xd5?\xc6\xce2~ct\xc7?}F\xbf\xbf\xba\n\xeb\xbf\x903\xea\xfc\x16\xb9\xc8?&\xd6\xc4\xfc{\xb9\xe9?\'W\xf4\x8fi\xa2\xe9?\x8e_84\x1a\xfb\xf0\xbfY\xbe\x15\xd0\xa2\xac\xdb\xbf\x15\x83\x9b\xad\xe2\x93\xe3\xbfN\x92\'\t\xf6\xc8\xdc?\x03C:t\'\xd9\xd2?\xdd\xf0VlP\xa9\xf0?\x9fU\xfa\xf0\xa6\x99\xf1?\x87\xe3&\xfc\xd4\xf0\xfa?\x95\x98\xe5~e\xb3\xeb?)<\xb1\x8bd;c?9\xadjBa\xd7\xd5\xbf4\xd3F\xf3x\xf9\xd9\xbf\xa8\xfaM\xf13\x8e\x06\xc0-X\x80\xa9\xc0\x8b\xe2?X\x1fLvm\x08g? \xf1\x9b\x08\xdeJ\xb5\xbf?x\xc9\x9d\xd6U\xf6\xbf\xa2\x81\xcc&\x9a\x18\xc5\xbf/\xa7\xcf\xf0\x1a\xd6\xfe\xbf\xb3L \xa1\xcd\x7f\xe8?\xdb\tiS@]\xd7\xbf0Z\x7f\xb4\xc0-\xc0\xbf\xf1\xa6\xdbtVF\xcd\xbf\x0b\xed\x062\xdcE\xe4?7\xf4a\xcb\xd8\x0f\xda\xbfl\x19\x175\xf9\xe6\xe9\xbfq\xa3z\xf7f\xea\xf6\xbfF\xc5\xe7\x16\x1b2\xc5?\x99\x8a\xb4\xdd\x08\x81\xee?4\x95\xdbw=\x0b\xd0?\xabE(\x88\xbdO\xee\xbf \x16\xe5;!\xc0\xa3\xbfjz\xee\x01\xa2X\xc1?B\x0c;\xe8\xc6\xba\xf1?t\xb7M\x83\xc6\r\xec\xbf\x96h\xb9\xee\xcf\xda\xe8?CC\xa4\x10\xaf,\x8e\xbf\xfb\xe9\xf7\x9b\x9b\xaf\xf2\xbf\xb0Lm\x11\xbap\xd1\xbf\xcd\xa1`\x9a\x18\x86\x01\xc0$E\xd8\x7fB\xb1\xfd?\xf9\xf5\xb3M\x93:\xeb\xbf\xb7Q\xc2NOU\xd8\xbf\xd7\x12m\x89\x8c\xfd\xdd?$hA\xae\xda\x7f\xd5\xbfbihG\xbfr\xc6?n\xb9\x8aB\x12\x0f\xed\xbf`\r\xedj\xb0\x95\xf2?\x00ye\x7fDK\xda?\xd1\n\xda)\xaf\xab\xef?\x96\xcd\x94F\x12"\xef\xbf;\xd9\x0cY\xb2\x83\xd2?]\xf2\xa0\x88,\xc0\xfa\xbfN\x93\x9a\xaf3\xcf\xc3?\x15\x01\xb3\xd6\xf6\x1d\xe1?;"_r\xf4\x1a\xfd\xbf\xb4\x06\xfb\xd8\x7f\x84\xf3?>\x97{\x1f\xbe\x8b\xdb\xbf\x89\x14\xdf=\x18\xef\xeb\xbf\xde\xe2\xceW2\x7f\xba?\x9e\x190c\xec\x0c\xf5\xbf\xf1\xd2\xbf\xf8.\x8c\xe3?\xf8kV\xb3\xa5\xee\xe1\xbfi\xfe\xe5\xf5\x17Z\xdb?\x1b\xf3O\xc7%b\xe5?U\xc0\xc8+\x80#\xc8?\xfd\xe8\xbd\xa4\x0ch\xe5\xbf\xc6\xc2\x92F7.\xd6\xbf\\\xe8\x96-h\xdf\xe4?\xe1q\x0en\xfa\x03\xde\xbf\xd4Cm\xdc\xdd\xa0\xf1?\x0c<\x15f\x8aY\xe3?\x8d\xbb\xfa\x16\xf7\x1e\xde\xbf\xc4\x88a\x16/\xb8\xe8\xbf[\xa7u\x8c\'A\xf9?\x15\xa8\x01\xa5\xde\xb9\xf2?\x80\x85\xbc\x8c,@\xb2\xbf\xf3\xc9\xc5\x12\x91\xb4\xe3?4\xe5\x1fC\xac\xc0\xe2?\xe5\xc4t2\xfc\x98\xf2\xbf\xe1\xdc\xe5\xc6\x03\xc9\x89?u\x95\x94\xb0\x9c`\xee\xbf\xbe\xcdU\xa5E@\xd7?\xf2Hd8\xa7T\xfa\xbf?/\xf4\x11\x82\x8b\xb8\xbf\xbc\xa5tp\xa5\xda\xd5?\x87\xcc7l\n\x88\xd8\xbf\xef\x11Ly\x01N\x00\xc0\xc8\xcb\xa9Q\x06D\xd0?\xd3B/\xb7\xaa\xa3\xc8?\xfb\xbf\xe6\x83C\xbc\x07@\x8a\xb9\xdf\x00\xe3\x17\xf1\xbf\xe6o\xcb\x1e\xf9\xb0\xd1\xbfz\xcf\x92$\xe72\xea\xbf\xc8\xf1\x8a\xa9\x02\xcc\xcb\xbf~\x10/\x14\x91\xa1\xf8?%\xed>\x1d\xb6\xc9\xf0\xbf\xb7m%\x8a\x15\xbd\xe7\xbf\xfb\xdb\x9d\xe3s\xed\xfa\xbf\x9a=\xfe\x02\xbf\x02\xc8?S\x80\xc0}\x05.\xe4?\x8b\xa6Pp\x1a\xb5\xea\xbfl\x04\xc0\xf88\xc6\xee?;\xd0x\x99\xf8\xa7\xf1\xbf\xae\xfb\xa5\x95\xdc\t\xfb?N\xbd\xbd[\x19\xd6\xd7?\x81\xa0t\x02\'\xff\xe6\xbf\xc5R\xff-N\xc7\xfb\xbf[\xfb\x99\xb1\xe9\t\xc7?S\xae\xa7vI\xd5\xf7\xbf\x1d\x9eN\xfe\xc4e\xf1\xbfNU\xb1\x18\x11\xb3\xf2?G\x83\x12\x0bC\x1f\xc5\xbf\xb6[\xd3\xbc\x87\xc5\xe9?\x8aI\x9b\x86\xa3\x00\xf6?\xdbs\xed\xab\x99\xcf\xf1?\xd5\x11V<\xc7\x94\xf2?\xd0\x1fgs\xb1\xe2\xd2\xbfU\x1b\xc2=V\xa8\xc1\xbf>\xa1\xca\xea\xc6\xc5\xf2?\tLo\x9d2\xfa\xd2\xbf\x1f\x01\xcf\x0e\xac\xc7\xd3?\x9bbY}s\xea\xf5?\xc4\xb5\xc7\x8e\xf7\xa7\xaf?\x9c\xc8Q\x99\xecL\xfd?\xf5\xc3iK\x18\xff\xf4\xbf:r+\xd8J^\xf7?\xe8\x8c\t\xbf\xd39\xc6\xbfS\x9a\xbc`\xaf\x06l?\xf66\xc1\xd6\xf5\xbc\xd5?\xf3\xd29m\x11S\xe4?_L\xa3\x16\nl\xe8\xbf\x97$\x1b\xc2?&\xfa\x06\'\xa3\xc6\xe0?\xa5SkR\n0\xdc?\x96x\xa2\x8f\xa5\xca\xee?r\xbed%l\x1c\xd4?\xac\xe8{\x99S\xe7\xbf\x10\t\x88\x8d\xc3!\xe0?\xf1\'\xc6\x7f\x10\xdb\xf2\xbf\x87Woi\x0b\xa6\xc4?\xd3\xc8j\x05\x8b+\xdd?}yx\x81bk\xe1\xbf\x8dF\x92B\xf2=\xd7?{x\xa9\x9a{\x9c\xf2\xbf\xb8\x91\xe7\x86\x95\xc6\xca?"W\xcfXi\xf0\xf2\xbf,\xf6uNY\n\xe6?\x04\x02\xb9\xae\xe7\xf4\xd8\xbfjc\x88 \xa1\xf9\xef\xbf\x9e\x15|\x89~\xcf\xc2?\x02\xb8\xf64Nt\xe8?\x04w\xd4\x97\xa1\n\xdc?4\xa2\xb6S\xe9{\xec\xbf\xaa\xb5\xca`C\xcct?\xa0\x17\xb0\xf0\'\xdc\xc5\xbf\xa8\x88\xb6\x9d@p\x04@\xcfw\xc6\x8c\xed=\xed\xbf\xd4\xc8\xee0\xf9*\xd8?KD\xc5\x17\x18\xcc\xfc\xbf\xf80\xfb\xa9\xff~\xe0\xbf\xb2a\xb1\x928w\xd0?\x19+\xb7.\xa3\xf8\xf9?(z}sw\xac\x00\xc0\x08h\x01\x92\xe0\x18\x00\xc09\xd5md\x1d\xb7\xf7?_\xc3\xf2\xb4H\x16\xf1?\xdf\xfe\x91\xa3Y/\xe0?\x8c\x95\x1e\x00.\xed\xe9\xbf\xf4\x89R\xec\x00\xb5\xd9\xbf\xae\xb9\xae>\xe9\x9e\xe8\xbf\x1a\xe3\xa2\xee"\xb3\xf1?-\x0b\xb4L\xe17\xd6?\x11\xc3\xe6hj\x93\xda?\x1f\xb9f\x96=\x9b\xde\xbf\x85\xa57\xa8B\xe1\xf6\xbf\xc71~\xbc}\xdf\xed?\x85\xed(\xa0\xf3\xae\xf1\xbfx\xb2\xb4G\xb2\xe4\xf0?,}]E>\x02\xf1\xbf\xa5|\xa3q\xce%\xd7?\xec\xe9\x99\xee\xfd(\xe9?\xc3\t\xba\xbe\x8d^\xe9?h\xcd\xe7\xe7\xb2C\xb4\xbf\x9eP\xefZd\x11\xf3\xbf/\xdd\nH&\x03\xe5\xbf\xd3\xf3I\x82\x1aT\xe3?I\xd8\xb9lVo\xe4\xbf\xfa\xc5n\x9d\n\xaa\xe7?\xf3\x95X\xe8s\x91\xf0?\x8b\x02\xa8\x92\xba\xbe\xd8?!\'\xdc\xf0\x17\xf5\xe6\xbf\xd9\xf61\nB\x8f\xf9\xbf}/\xa6\x8f\x8bM\xcc?{,\xde1T\x83\x00\xc0w\xeb\xd8\x06\x0f\x05\x00@\xec\x1c\x117&\r\xcc?\xd4\x00D\xa7(\xc6\x01@\t7\x9dL\x06\xb0\xe1\xbf\xc4O\x17Z\xb9\xbe\xa0\xbfUTJ\xacn\xb2\xe9\xbf\xc7\x02\xe8\x15\xee\xe3\xc2\xbf\xf7\xe4\xbb|\xff\xf3\xe3?\x81\x03+i\x13\xaa\x02\xc0\xae\x88\xebz\xe3}\xec\xbf\x08Y\xd6\xc2l\x1b\xd6\xbf+\x067\x06V\xb5\xfd\xbf\xb4U\xd3k\xea\xb7\xe8?(\x82\xd8Z\x17-\xf5\xbfV\xff"\xb0\x1e\x1f\xe0\xbf]*qy\x82\x0f\xe6\xbf\xa01\x035\xc1\x85\xcd?\xa2\x18\xa8\xc4\nf\xcb?\x1f\xbd\x9b\xbc}y\xf6\xbf\xffo\x16\x83\xa6V\xee?0*\x98\x11!s\xd3\xbfA7\xc6(\x91\xef\xf1?z"\xf4\x99[\x04\xe8\xbf\xf3\x91\xc0\x0e3\x1a\xd6?\x0c\x92\x99\xa6\x00r\xf0\xbf\x1e\xa6VK\x99\x9d\xf0?\x7f~N\x97\x8d.\xf1?\x93uq\xef{\x87\xb3\xbf\xa9!\xa6\xc4#\xeb\xcb?\x81\xde\x0c=?I\xcd?\xac3j\x90\xe3\xe4\xe5?\xdeioM\xb2\x15\xf4?\xcd\xa2\xdc\x987p\xa0\xbfTz+%\xca\xe0\xe2?\xba`\x0c4\x16\x84\xf0?\\\xc5\x84\x03\xdf\x12\xec?k\xca\x14\xac\x85q\xf2\xbf\xdb\x0e0\xce\xa9\xb0\xf5\xbf\xba\xb4P\xf7\xb9\x8a\xf1\xbf:\xc8\x1fD\xa1\xe6\xe8\xbf\xcc\xb6\xa7\x89M\xf3\xf2\xbfz\x1c\xe9\x16F\x82\xf0\xbf\x9d\xa8UO\xf1j\xd4\xbf\xb9\xc9@>\xad\x89\xf1\xbfi\xcf`\x1a\x03\x11\xe8\xbfl\xfeT.\xa3z\xf0\xbfl\xb8\xd3\x06\xfe\x89\xea\xbf\xcb!\xfa\xca\xf8\xec\xe1?\xb2p\xc7\x8a\xad\x83\xe1\xbf\xad,\x13\x02\xce\xe4\xbd\xbf\xf5+\xe7D\xee\x93\xeb\xbf{\x9a\x87\xbcV\xd2\xd7\xbf\xe7\xc2>\xd7xL\x01\xc0\x1f\x9e\x94O\'%\xfa\xbf%\xa9\xd3yB\x1f\x06\xc0\xb0T\xfe\x82\x01\xb0\xb3?&+\xc9mc=\xe9?!m\x87\xd6\x9a\xf7\xf3\xbfD*\x95qj#\xfd\xbf\x19\x93\xe6~@\x93\xe8\xbf\x84\x8f\xf1|\x8bc\xe7\xbf\xb8tu\x04\xd4\x96\x92\xbf\xde\xd52\'\n\x16\xf0\xbf\xdb9\xe1\x02\xfc!\xd2?\xff<\xab\xf9\r\x9a\xf3\xbf\x86\x12u\xb6\x89\x0e\xe5\xbf\x80\xaa\xd0\xfb\xf0\x10\xf6\xbf\xb4\xbd\xc7\x96y!\xf2\xbf\xa1w\\\x1aB\xb1\xa6\xbf\xad|\xa3\x87\xfa3\xee\xbf[\xd39\x0cf\x83\x00\xc0H\x7f\x91\x91\xb9?\xf4\xbf\x8e\x83\xde\xb2\xf5\xe0\xac\xbf\xf8\xb1\x97SB\xdb\x0b\xc0\x06\x98$\xf9\xb7\x15\xc0?\xaa\xbb\xd4\xa8Rn\xf2?\x9c\xe0\xf2\xd5-\x90\xed?I\x81\xd5\xbb\x024\xcc\xbfP\x01\xe0\x1d\x1d\x14\x01\xc0\x01c3\\\x12\x8e\xf2?\x03\xea%YP\xf3\xe1?\xd4v\x03\t\x0bd\xe4\xbf!\x89Q\xa4\xf4\xa7\xf6\xbf\xa8\xec\xb9@\xdc\x99\xf1\xbf\x14\xcd\x96\xb9\x9a\xe9\xa4\xbf\xe2\x14\xa5\x8c\xe0\x97\xf6\xbf/\xe9\x90\x18\xe3\xef\xe4\xbf\x0f\xaf\xa6\\\x18\xec\x01\xc0\xf3Iy\xad9\xa3\x00\xc0Tr\xe9\xf9;,\xe2\xbfR\x90\x83M\x08\xa6\xf2\xbf[wL\\\xe1>\x00\xc0\x0b\xa3\xee&w|\x08\xc0O\x16B\x979\xba\xcb\xbf4 \x11\xe3Yd\x01\xc0\xe7\xa3\xb1\x14;\xbc\xfe?\x9cji\xbe\xda\x10\xf7\xbfg!\x02\x96\x14\xdd\xf4\xbf\x9e\xeed\xa0\x9d\xc0\xc1?\x87#\xdd\t\xdf\xaa\xa0\xbf\xee\xa0{\xf5X\x94\xb6\xbf\x10\xafY\xfc>K\xa8\xbf\xf6\xd8n"D\x8d\xcf\xbf_\xf8-\xe4b\xfa\xd0?\xf9\xe9\xca\xfcg\xdd\xc6\xbfe&\x13^m]\xf7\xbfv\xd4R\xad\x863\xf3\xbf\xf1%\xaf\x07aQ\xd0\xbf\xf0GPA\xe6\xc5\xf2\xbf\xb3\xecN8n\xb2\xe1?\x94E\\\x1e^x\xf0\xbf\x8b\'Pb\x87\xf4\x04\xc0E\xce,\xbd\xed\x0b\xea\xbfUO\xc0&\xa9\xf4\xbc?\xde\xb7\xa0\x12\xf3\xcf\xfc\xbfKvQ\xfa?\rp\xbf\xba\t)\n!\xf0\xd3\xbft\xb4\x99\x07\x86X\xf5\xbf\xf5+\x00\x83\xfd\xad\x02\xc0\x15\x1d\xf2)\xce\x1e\xf3\xbf\xad\xfe\x00\xf4\xa7\x18\xdc\xbfi<\xcc\xd1p\xab\xb9?{B~\x1aM\t\xd0?\xd4\xb8\x8a\x90\xa5\x9d\xf5\xbf\xfe)X\x9f>\xc6\x00@\xff\xaa\xce\xd5\xd6q\xe8\xbf|\x0c\x8a\xb4\x0ba\xe5?\x03\x9d\x84\x1d\xb3\x07\xe1\xbfPZj)`\x02\xd4\xbfG\x00M\xe6|\xa7\xe6?\xf1X\xf7\x9c\x90\xe1\xf0?\xd5\x1f\r\xc5\x83\xd6\xea?\x93\xc4\x05\x10\x80(\xf1\xbff%\x1f\xddx\xd4\xf0\xbf5\x8a\xaa\xcb\xcf \xe7\xbf\xdcT\x15\xf5\xa4h\xd6?\x0c\x17^\xaa\xc1\xb9\xef?(F\'t\xd4\xea\xac\xbf\xe6\x86\xf1?\xd2*\xe2\xbfF\xf2\x17q\xfa\x0f\xe6\xbf\x1b\x7f~\xec\'\x18\xfc?th\xe5\xee\xa3\x96\xf9?d\xfdm5\x85\xb0\xf4?\xe5\x9d\xed(\x08\xef\xd0\xbf>\x1d\x189\xcc\x83\xff\xbf\x01\x87\x90\xe4\xf7\x97\xf2\xbf\xe2\x99\xb0\xe3\x98\xa7\x03@\xff\xf3\xf5\xfea,\x00@\x16\xee\xf4"\x04#\xfd?\xcc\xe5\xae\xff\xff\x82\xe3\xbf\xa9\x8fl\xfb\xe4\xf3\xbb\xbf\xc1\xdb\x1d\x83\xfa\xda\xfe\xbfmW[\xd2\x07\xd5\xdf?$\x84:\xf9\x11\xaa\xb7\xbf^\xa5kY\x155\xae\xbf\xe3\xa3\xe1U3\xeb\xb5\xbf\x04\r\xe5\xa6\x98\xbd\xf0\xbf\x0fe\x19\xff\xe1\xb0\x9f?\xea\x15\x05c\x857\xf0\xbf1:\xcd\xb1!\xf8\xa8?\x81\x8e\xd5\x89\xf4 \xf5\xbf8F*\x8e\x91\xa5\xc5\xbf\x95\xe8\\\x8f\x8cp\xea\xbf\x01\xab9\xbc\xadd\xf9?\x11U\x98\x82\x8e\xbe\xb9\xbf\xda\xbe\xe04\x0fn\xf4\xbf;\xbf\xa6O\x96\xf0\xe9\xbf\x9fH;\x0eJ\xeb\xe6\xbfE\x96M\xe2n\x7f\xcd\xbf\xa9\xc1\x88\xaf\xd1\x04\x04\xc02zT}Wa\xaa\xbfl\xf6\xb4(\x9c\xee\xf2\xbf\xb7\xd2\xe2\x8e\n\xca\xfc\xbf(s\xcc\xab\x97\xde\xc6\xbf\xa5\xbb]6H\x18\xfa?4\x0b\xaa4I\xe1\xb5\xbf\xe2\xedh{\x9cI\xe8\xbf\x17Ai\xd9\xa4\xa1\xb5?\x1f\x1d#lI\x9b\xec\xbf\x88C\xae;\xc8$\x91?\x1c\xa0\x86My\xc2\x81\xbf\x13\xad\xd2<~\x08\xbe?\x8d5\x94\xf3j\x0e\xe9\xbf\x19\n\xdb%OX\xd2?\x16\xd1\x8fDp\xb4\xe5\xbf(2\x07g\xf4\x95\xe1?\xce\xa5Bw\xf97\xe7?\x1d\xcd\x08c\xefF\x04@\xe6zu\xf1\x16\xa3\x93?[q\x19`\xf0\x9c\xf5\xbfU\x14S\xe0\x15\x18\xe0?\xd1\x82\xe5\xd0~>\xe0?\xb23\x0f\xf5[\xa1\xf3\xbf\xe0\xca\xb6w\xa9\xe1\xba?\xf9\xd7[\x05\xfe\x1a\xb1?\xd0\xb3\x17\xbe]?\xe1?\xd8\xc8"\x95\xcc\xb4\xea?_\xac\xd2&"v\xbc?{y\xfe6\x8er\x01\xc0X\xddK/\xab\x8d\xe3\xbfoMW>\x86x\xf3?\x17\xfa\x84"<{\x01@\x92\x1c-\xab\xf8\xb5\xd6?b\x179WJ\xab\xe7?\xc8;5d9\xcc\x03@\xe5\xbd\x1aD\xda\xe6\x0e@\xfa\xa5\xf4\xae\xaa\xd2\xe3\xbf\x9d\xbbp\t\xa8X\x02\xc0\xba\xa3\x82\xef\xcc\x8d\xe8\xbf\x918j.|\x9d\xf5\xbf\x87\xbaB\xd6\x86h\xe7\xbf\xf1\xff\xe8\xeb\xf96\xf1?\t\x0c\xfe\x01\xf5\xe5\xeb\xbf\x85\xdc\xfcm^\xca\xe9\xbf\xddQB\xed=K\xe9\xbf\xe6L\xaeV\x82R\xd9?\x9e\xed/\xbe\xfa\x9c\xea\xbf\xf93\xb9\xc3\x12\x07\xd5?\xb1\xc0\xee\xf9\xce\x0e\xaa?\xf3\x0f^\xa3\xb7\xac\xce?\x17\xb3\x95\x02e\xc5\xd6?\xa9]\xa4="\x01\xf1\xbf\x17\x02>\x15\xe6\x04\xcd?\xec\xfc{\'(\xca\xe5?\x1faI\xad\x83\xadX?\xd1\x18\xfeD\x9a\xe6\xd1\xbf\x1cqMxx\xfb\xf0?(\x823\xb2OF\x02@\xd7\x95\xe8]Xs\xd9?\x03\x04\x91p?"\xfd?\xf2\xcd@Q \x8d\xd6?\xe3\x0f\x19\xb9\x02&\xfc?\xab\x17\x86\xd8{P\x07@\x8e\x11\xf0\xc9k\x1a\xea?\xb4\xb2\xd6x\x15>\xeb?r\xf0\xb8t\xe7\xb9\xf3\xbfGi\x98\x84\x8d\x7f\xf2\xbfLvj\x1d\x03B\xe1\xbf\x1f\xc9?O\xb4\xbb\xf9\xbf\xda\x04E(\x0c\xa8\x00\xc0\x84\xa2\xc8\xd1&8\x00\xc0[\xf3\x91O\xa1\xe2\xe3?A\xea\xd8#4[\xe3?\x03\xbeG\xb9E\x01\xd7?A\x93\xbe\x9a+Q\xf1\xbfc\x99\xf2\xc9\x8c\x16\xe0\xbf!\xed\xa5O\xd7x\xf8?\xaa\xf0u$P\xaa\xf4\xbf\xff\xf1\xdd\xea\xde\x19\xeb\xbf\x7f\x90\xc5\x8d\x04S\xf6\xbf+~\x9b\x0fKX\xcb?s\xb1\x90\x0eW\xa1\xf6?H\xca\x82\x9f8u\xb2\xbfP\xecj\xbf\rD\xf1\xbf|=\x93Bb\x9e\xf0?\xe7Hk\xcc>\xf8\xf8?\x1a\x00.\x0fR\xba\x05@\xf2\xb33\x88m\xc6\x01@\x04I\'\xf5\x80\x8d\xf1?\xa4\x13bp;W\x06@>\xfa\xaf\x92\xcbl\t@\x12C\xef\x89\xe6?Qi\xb7l\xc8\xc6\x00@\xc4<\x12O\x8d\xe5\xf7?@\xaa\x15\x8a\x1f"\x05@\x17Q\xc4\xbaO\xf2\xe8?\xf3~\xc2\xac\xf6J\xcc\xbf\xa2>\xae\xf8\xd1\xd8\xe2?\xa7Xp\xcb\xe1\xb6\x05\xc0\xde\x8d\xd4\x1c\xdb\x18\xf1\xbfQ\xbf7I\xb3K\xd3\xbf\xe6,\xd8\x0f\xd4\xfc\xdd?\xe8S\x02\xb1\x8e@\xaa\xbf\xaf\xcf\xde5\xc2\xaa\xc4?@4\xed\xdf\xef\x08\xf1??\xab\xdd\x05\x9c\x93\xd7\xbf\xa0$\x18\xf4\xe8\xec\xf6\xbf\x00a{\x16\x8d8\xe5?E9\x19K_\xeb\xfb\xbfffm\xbc[\xab\xf2?R\xa6^\x93\x85\xfe\xf2\xbfv\xd7G\x16\xa2\x1d\xc0\xbf~\'u~]o\xed?M\x95\x9f5^\xfc\xf7\xbf\x9f\xa7\xfa\x17_\xb1\xb1\xbf\xbd\x1b\xfc\xa6\x15\xe2\xd2\xbf\xd3\'\x11\xac\xc0\xf0\xf4\xbff16(\xb9q\xb8?\xb8\x9d\xdbn\xbf)\xec?\xf2\xb6\xd7\x1e\xe8L\xdc?kK\x80?;\x87\xe1\xbf\x08\xca\x92\x9a\xde\xa4\xd6\xbf\x99\xda\x8e?\xac?\xfc?\xe7\x87\x89WJ\xd4\xf4?\x985##Yk\xe9?\x1dO}v\xbcI\xdf\xbf\xda\xfa\'\xd9\xa7`\xe4\xbf\xbecs\xcc\n\x97\xe8?\x06\xd51\xcb\xc0\xe8\xc5\xbf\x86%\xc9\xdfT\xb9\xd2\xbf\x8f\xdd|\x90\\\x8b\xd4?_\x9fh5\xbcD\xf1?\xb0\xa9\xb9\x90H\x10\xe4\xbf$\xb9\xa8^\x00\x11\xed?\xaa\xf4\xf0[a\x8a\xe8\xbf\xfd\x96\xd0@N\x0b\xe0\xbf8\xd1\x18\xe7\xb9\t\x01@\xa6LR\x0fD\x0b\xd5?q\x85\xf0\xa0r=\xe7?\xc3\xfa:M\x993\xe2\xbf\xbd\xd2\xb9\xefH\x14\xea?\x0cP\x0fU\x8e7\xeb\xbf\x7f\xd7\xad\x0f\xd7n\xd8?\xbd\x04s\x98\xe9G\xeb?\x96\xebxq\x98\xc0\xcd\xbf5\xfe%T\x89\xd9\xdd?\xea\x9b\x1c\xfd\x17\xb8\xeb?a\xda\x9b\x13i\x96\xea?r\xc6\xe2\xbeO8\xf2?bi\x96Z\xc8/\xe0?\x11\x97\x89\xbe\xd6\xad\xef?5\x87\xe5k\xa7\xc3\xff?\x92\xe2\xeftM\x92\xd4\xbf\x10\x1b\xf3\xa6 \x08\xcb?\x82\n\xbd\x07\x00\xd3\x06\xc0\x8c\xae\x12\n\x15\xfd\xbc\xbf\xc9"\x98#\x16\xa4\xec\xbfZ\xd43\xaa\x01\x02\xd0\xbfo}\x03"\xc4\x97\xdd?\x86\x1f \xfe\xae\x05\x01@?\xc9\x81#<\xc2\xd7?U\xea\\\xae\xe5\xbe\x00@3\xbc\x98l\x855\xf7\xbf\x0c\xf4\xf0S\xc9\xfd\xd4?\xf7c\xb2\xd0W \xa7?t$\xdc\x14\xfb\x12\xff?<\xbd)\xa1K5\xf1?\\\x1f}\xa2Y\x1b\xdd?\x08\xee=\xff\xb7\x88\xd1?\xac\x1f\xafP\x8f\xc6\xec\xbf\xc4\xf3*)\x7f\x92\xf9?\xe3\x18\xf0\xd0I\x14\xe2?\xb5\xb5\xe7:T\x97\xf6\xbf$\xa3$\xf0\xd6\xed\xf5?Qs\nWS\xe7\xf9?\x14\xad;\x17\xc2E\xfd?\xaa\xd8`\xa0\x81Y\xad\xbf\xbd\xc3\x08\xb6W=\x06@\xcfk\xc3Y\xf8\x98\xe0?E\x8b\xfb\xcey\xd1\xe3\xbf{0n#\x84"\xec\xbfn1\xb5\x0c\xcb\x14\xde\xbfJK\xe6y\x07\xe9\xeb?\x85D\xc7\xf6X\x85\xd0?\x03\x04\xc6DL\x0f\xf3\xbf\xb4\xc2A\x80\xab$\xe6?}\xa0$2\xe3\x1f\xef?\x1e\x94Fh\x8d|\xf9?\x85\x8a\x1a\xdb\x00O\x02@\x83\xab\xe1Z\xeaE\xf7?uA6\xe3\xd3\xcd\xf9?\xc0Oq\xa4\x11T\xea?\x0e\xa2\xc39\xf2\xa7\xe6\xbf\x10\xe61aC\x95\xeb\xbf\x8b>\x87\xfa\x98H\xd2?\xad8o\xbc\'7\xc1?\x92-`\xb7rX\xf6?\xd2&\x85"S\xfa\xdb?[1\x8a/\xbf^\xf3?\xf9Ri\xce\xd1U\xd5?\xc4\xf8\xc6\x02\n\xd9\xe8\xbf\xa9\xd1t\x8f\xb4\x0c\xf1\xbf\x13\xac\xad\xc6\xc8\x08\xe2\xbf\xbf\xdcUQ\x8cC\xf4?\xa22S\xf4\xc7g\xd6?k\xf9\xb1\\S{\xee\xbf:O\xd9pk\x9b\xea\xbf\xfc>\x0b\x0c6\xe3\xe9?c\xc9\x9eE\x8c\x06\xc9\xbf\xb4\x8e\x0c\xcd\xfc*\xf0\xbf#\x1d\x9a\xe7a\\\xe2\xbf\x8a\x94\'\x95\x9a\x81\xb3?8\xed?:L\xc8\xc1?R\x9e2\x06\xcc\xc1\xe8?]$\x80\xee\xa0E\xe1?\xc6.Q\xf4\x8f\xa7\xd0\xbf\x882\x87d\xb2l\xd9\xbf\xb3g\xe2}\xbb\xed\xf4?\xeb0\xa6\xb1\xc3k\xd6?\xbd\x1b\xde\xa5\xbe\x9c\xb3\xbfm\xaf\x96\xbco\x8e\x07\xc0\x85\x810\xf8\x8fp\xf8?[]\xdf\xa5\x89\x11\xf6\xbf[{\x07\xbc\x1f\xf1\xee?-`\x18Aa\xfc\x05\xc0\x04\xc5U\xf0\x14n\xe2?~w\x05\xebd\xbe\xdf?\x84\x8a\xb5i\xe4\xf0\xb0\xbf\xa4\x88\xcb\x81\x0bF\xf7?7\xec\x19\xf3"\xa3\xd2?M\xd0\xa4f\x8b\x1e\xf7?\r\xcc\xe5 \xedL\xf6\xbf]\x9e3\x89`\xe4\xe0?\xd0(\xf9\xbf\x0cd\xe0?Tgg\xb1h\xf9b\xbf\xc4\xd5oa\x84\xc5\xc2\xbf\xf7\xf9\x11+\x92\xbc\xe7\xbf\x92\x8a\xe2\xe77M\xf8\xbf\xe3\xf4ue\'\xd5\xed\xbf\xb4E\x0ca\xfb\x0c\xe9\xbf\x0e6 \xef\xc0M\xfc?\xaa{\x88~*\x9a\xeb\xbfk\xaa\xe9\xb5\x0b\xe7\xf3\xbf\xa0#\x8b\xfb\x1f\xb7\xdb\xbf\x9c\x18\xbe\x13\xf5>\xb1?\xf4\xe5\xc4\xfb\xee\xec\xd2?^T>\x1f\xac\xdf\xe4?\x99w/R*\t\xfc?\xd8\xfa\xe8\x89\x96\x91\xe8?\xfdke\xc3\x01z\xf3?,q\xf4(~)\xf4\xbf\x1e\x19\xd1#\xd6\xbf\xf1\xbf\xaf\\\x9eN\x01\x1c\xf1\xbf\x9d\xb1\x0e\x04\x1b\x97\xf0\xbf\xc8\xca\x18\xde\xc0t\xfa\xbf}\r#\xdcD\xef\xf6\xbf\xe8H\xfa\xb0by\xb6?n\xb4;`\x91\xfb\xdb?Y%+{\xcd\x8a\xc1\xbf\xb5\x7f\x8e\xean{\xd2?\xd1\xe9\xc8\xb1\x85r\xe4\xbf\x80!\xff\x0f\xa1q\xe1\xbf\x7f\x06\xd4\xb9\'\x18\xe1\xbf"\xde\x08\xd1\x96\x1f\xe9\xbf\xa3\xd3\xe2\xba\x8e?\xe1\xbf\xfdg\xb0B\xd3{\xd2\xbf\x8a\xd9\xd8)\xae\xe5\xdf?\x83\xb6\r\xb9\xb3Z\xe6?\xdb\xb6%W\xf9\xf4\xb6?\xbb\xa8\xdeGq\x1e\xe6?x4\xae3Fi\xf3?\x88\xb1\xde\x940\xef\x00\xc0\xd9\x84&\x89\x81?\x94?\xab\x9c;\xe8J\xfd\xe7\xbf\x9bM.\xaf5\xe5\xea?\xef\xf9D\x9e/\x05\xe6\xbf*q\x96\xa2\x14\x08\xca?5o\xdb2\xe4\x81\xee\xbfsRCf\x0c\xe4\xa7?ST_\x06\xf8I\xdf?=\xaf\xdd\'\xe3Q\xe4?\nE,BPy\xf3?\x8c{\xee-\xe3\x9b\xc6?\x1fqhY\x80\x04\xe4\xbf*\xd0\x9fX\x87\xa9\xd6?\x08*\xb4\xa8\x1ah\xe5?\x05\xc5r/\xf5\x8a\xc4\xbf\x13\xa8\x1fM\x1e\xe8\xfe\xbf\njS\x81@\xbc\xf0?\x00[\x19\xd6O\x92\xfe\xbfz\x8e\xb4\x9e2J\xf3\xbf\xc5\xcdFz\\K\xe9\xbf`\xee\xd4W\xa2\r\xed?\x9f\x81(b\xe7\xbf\xc3?\x8aO\xe5\x88\xd0\xc4\xef?\xc1\xb5\xd4\t\x93C\xe2?\xc6\x12\xa60{\xc6\xf2\xbf\xb7\xa2\xe6|.\x1f\xd5\xbf\x1a\x94n\xf0T9\xf0\xbf\\\xa8\xfd\x82\x15w\xf0\xbf\xeb\x01\xcd)\x99\xcc\xea?\x08\xf0\xc6\xc4\xa4D\xd2\xbf\xb3\x12\x1eR\xf2T\xf8?9\x01\x0bT\r\x03\x9a?\xeb\x94\x0e\xb8\xce\n\xb2?\xa4-e_\xbd\x80\xeb?\xddYp\xf6\x01\x89q?r\x91\x1e\xc5\n\xd7\xe6?\xf3\xea\xc9t\x91\x81\xe4?\xbf>\x01\xc3\xfe\x0c\xd8\xbf-\xe6\x8b\x81\xd6\x1a\xf3?\xa5\xe2\xf1;\xbc5\xce\xbf#d\xa0\xf3\xecR\xb3\xbf\x8f\xd6\xd2b\xf0N\xe7?\xbd\xaeg\x1a\x81\xae\xf8?\xd5\x0b`\x9d\x1b\xea\xc7\xbfiu\xce\x1e{\xec\x00@\x8f\xe4\x1f\x924\x10\xa4?\xe4\xa3\xff\xeba2\xf3?\x83V\xb3^|\x9c\xe1\xbf\xe9?\xc1\xf1?\xa7\xee\xbf\x9e\x8aR\xf4x\xfa\xc6?\x8c\xbc\x87\'\x07`\xef\xbf\xd9\xb8\x92\x9a?.\xf1\xbf2*j$\xf1\xab\xb7?\x88\xed?,\xf1\xac\xe2\xbf\xf43\xdd\x03\x86E\xef\xbf\xd1\xfcN4\xd3@\xd0\xbf\x0f{r\x93H\x81\xb8? \x1d1\xc0\xdc\x1c\xe1\xbf\xe7\xec\xc6\xadD"\xe6\xbf\x96S?Yt\xf9\xe8?\x16\xa12\x80\x11\xc6\xd9\xbf\xb9\x86\xae?2\x91^\xd3\xc4\x10\xf9?\x9e\x1d5\x9d\x8f\x8f\xfa\xbf\x87k\xa7\x11D{\xf1?\xf6\x1c\xca\x0e\x9f\x94\xe3?YW\xfa]\xe0\xb4\xf1?\xa6\x9b\x1cjL\xe6\xf6?%E$&\xec\xad\xa2?)\x83\x9f+Gi\xf1?\x07\xeb\xc4Ix\xd5\xd2?nDm\x0eI\x04\xc3\xbf\xfcGK;\xb9b\x04\xc0\xbd\x02\xa6\xdd>\xff\xca\xbf,\x80\x07\xcd\xa8\xf4\xf2\xbfw\xaeT\xd7\xc9\x8b\xf8?\xbc\xce6\x93p\xc6\xd5\xbfV\x90\x151\x85v\xbb?\x17\xab}/\xfal\xef?\xd7\xcc\xe3\x14P|\xc7\xbf\xa3\x8a`b\xe5I\xfe\xbf\xf5\xd1\'\xc9g \xe8?\xb4\xd4\x10\xe8q\xa8\xcf\xbf\x02\x8c\xc1\x8c\x8c\xc8\xf5?\x86z_|jU\xa6\xbff\xbe\xb0\x9e\xc9\xa4\xe1\xbf\xac\xc8\xabg?\xdf\xc5?)n\xf9\xeblM\xf0?\xbb\xd9=_\xd0\xf3?\xc7t\xf8\x962\xed\xf5?\x98s\xf5\x92\xf7n\xf5?\xb3\x9f\x87\xea\x92.\xf5?\xc3\xa5/O\xda\xe0\xe0\xbf\xcc\xc9\x07\x7f\x05\xb1\xd9\xbf\x9f\x16\xad\xf0\rY\xf1?jy\xc9\x9b\xe4\x8d\xcb\xbfe\x80\x9auj\xb3\xe4?"\xe4n\xd45\x84\xd2\xbfB.\xa1!\'\xd9\xe7\xbf\x86\x08\xda;\xf5\xdc\xaf?\x95\x18g\xe8k\xcd\xf1?\xf6|k\x9cP\xb0\xfc\xbf\xab\x85*9/\x92\xd5?\xcc\xb29\xfe^\xc2\xd9\xbfb\xae\x7f\x908\xd1\xe1?\xfaV\x93\'b\xe1\xc4\xbfYQ\xa1m\xcf\xd3\xf7\xbf\\\xcf\xc1\x16$\x1fe?\x9a\xf2\xc6\xaf\xfb4\xd0?\xf3&\xd9\x8f(z\xe1?\x17+\x1f+\x19\xac\xf3\xbfV\x9b\xee,\xe8\x18\xc8\xbf\x85e\x11\xaci\xf3\xf7?\xadxj\xa8\xc4\x1b\xdc?\xc8\xd6\x92\xe2H\n\xb0\xbf\x84\xaco\xaaY\xc2\xdc\xbf$8\x8e#\xad\x11\xe7\xbf\x08cn\xb7O*\xf3\xbf\xea\xba<\xffmt\xcf\xbf\xdb\xb8S\xeb-\xd2\xe0\xbf\xb0\xb7\xab\x9b\x93\xfc\xca\xbfKx\x93\xfd\xc6L\xdd?\x05~\xde\xa0\x91\xe9\xca?\xb5\xe6\x16\nb\xae\xf4\xbf+\xcb3d\x17\x0f\xf4?\x8f\x06\x83\xc6s\xf1\xe9\xbf_\xb3\xc7\xd4\x9fP\xe6?\x00\xfb\xb0\xe5r\xa8\xf7?\xef\xe8\xac\xd7$\xaf\xf1?:6\xf4\xce\xe6\xce\xe1?\x88\x0f \x98.\x1e\xcc?\x97\xdc\xc3w\xc5\x01\xea\xbf\xac\x15D\xa1\xff\x15\xf5\xbfXJC:\ts\xd5?\xe2~\xf7=+\xbb\xd3\xbf\x88O\xd1j\xba\xf2\xd6?\x94\x03\x82\x03\xad+\xe0?OFr\x92\xe0\xf9\xd2\xbf3*\x8et\x06\xe3\xd7\xbfJz\x04\xbb\xd5\xe8\xbe?\'R0\x06\x992\xbf?\xc4IY\xf3\xe6\xc3\xf3?\xd9\r\t\x8c\xa4\xdb\xa1?E\x9a\xd0\x081t\x00\xc0\x08\xe0\x05\xec\xc6\xc1\xfb\xbf\xef"\x98\xb8\x0f\\\xe6?:\xdc\xc9j\xad\xfc\xf0?m\x10fm#N\xeb?Yt\x00\x87\xeb\x94\xbc?\x0f\xe88\xa9\x07\x86\xe9\xbfVzy!X\xdc\xe1\xbf+u\x0f \x1e+\xd7?\x90\xaeP\x8dA%\xe0\xbf<&\xc5\x87HL\xf9?Y\xf2\x04z\xe9\xbd\xf1?I&\xd2\x07\xe7\xb2\xf4\xbfR\xa5\xc7\x11z\x0e\xf2?\rU\xd2CZ\x1d\xf6\xbfYFy\xbe&\x10\xeb\xbfe\xc5\x84i\x87\x14\xe0\xbfoz\xfbk\xc3(\xfe\xbf\xdbC\x10\xb2\x8a\x1d\x01\xc0\xacsU\xdf\xdc[\xeb?&l}h|v\xf5?\x0e\x01\xcb}\x1e.\xe3?B\xd2J\xaf\xbfb\xfc?\xce\x02#\x9f#\xf2\xc8?\xdf\xdct\xcb K\x00@\xe3zW\xbe\x89\xcc\xde\xbf\x00\xb2\xe2\xde\x8d)\xd5?\x88\x06\n\xc4\x17\xef\xd5?|;>\x0bC\xec\xed?\xd3\xa3?\xf76\xea\xcf\xbf\xba\x1dTr:\xf7\x92\xbf\xd0\xbdUb\xda\xc0\xc7\xbf\x81\xedS\xbc<%\xfb\xbf\xe48\xc5`\xbf\xba\xee?x\xf5\xa7\xe1\xe8~\xe7\xbf\xad\x1e\xbc!\xaa\x92\xf0?\x8f\xb1\xf2\x1b\xb5\xea\xe1\xbf\xa5\x9a\xb9\x8d\xea\x9d\xf0\xbfz\x07\x99\xf5o%\xe1?\xd3\xf5\xdb\x7f\xca}\xf0?\x85\x9e\t\x18\xc8\xd9\xfa?\x86\x15\x9c\x16S?\xef\xbfu\xa4 \xff\xc8\xa6\xd5\xbf\x1f\xb7\xc8\x9e\xd5"\xbe\xbf:\xf0\xc0rY\xac\xe5\xbf\xec\xa0\xc8\x19?\xb7\xf2\xbf\x88\x89\xa5\xbf\xb1\x92\xf7\xbf\xb5\xa3\x050\xc3\x8d\xd5\xbfM\x82\x80\x8f\xa4\xf6\xe8\xbfX\xd1%!\x19?\xcc\xbf\xc0u"}\xe6\xdb\xb9\xbfYM\x94pS\xa5\xdc?c\x04\\\x9a\x1f7\xeb?\xbd\xa7hX\xd5\xf3\xad?4\x88\x024Pn\xf2\xbf\x98\x16\x134\xf3\xe0\xae?$\x89\x14\x076\xfd\xe5\xbf\x83\xc6\xe9\x87\x17A\xfb\xbf\x9b.(CpH\x9f\xbf\x0c\xc8\xf5\xe7?\xb2\xc7\xe14|\xdf\xf3\xbf\xc9\x0f\xe0\xd0\xdfv\xef?\x11\x9c\xdb\x9d1\xef\x8b\xbf\x88\x04j\xd3\x16\xdc\xd8? [?\xce9n\x02@\xd3Y\xb4\x01\x05?\xb0? k.\x1d~\xda\xc4\xbf|c\xc2y\xee\xf5\xa1?\xacc\xd2\xe2\xca\x16\xdf\xbf\xff\xa9\xc7\xed\xf3M\xea\xbf\xd6\xf8\x7f\xb2O\x89\xda\xbfN\x04\xa1\x10I\x9a\xe7\xbf\xf7\xd1D\x12T\n\xf9\xbf\x1ftBO\xe3\xd6\xe8\xbf\x13\xdf\xfc,fm\xd1?\x8c\xf120_\xc5\xe1?8GD~\xd6\x88\xeb\xbf\\\x9d\xf1J\x9e\xdc\xff\xbf\xe4\x8a\xd9\xd9\x86_\x08@z5\xfc\x8fr\xaf\xfa?\xba\xe11}\xb2\xe2\xb5?\xd2\xfe\x86\xd3\xc8\xfb\xc9?\xdcW\xc0\x11\xa6>\xd9\xbf\xac_9-\xe69\x05\xc0*\x81A\x13\xaf\xfa\xa2?9\xc2f\xce\xb8\xb7\xf0?\x9bzL8\xae\x8a\xd0\xbf\xbc}\x0f\xcd\x86\xab\xcf?\xea\xcbDJ\x01o\xec?A\x9f\xcekdH\xe7\xbfr\x96\xf5\xce\xb6\\\xdb\xbf\x82\xcf\xcd\xdez~\xd8?\r\xf5L\xff\xad=\xe2?\'@\\=pS\xf0?m\xd5\xc9\x02\xa7\xae\xdf\xbf\xdcy\xdc\x83\x8c\r\xf9\xbfe\x11s\x90\xeb%\x83\xbfm\x13\x7f0\xac\x81\xf5\xbfY\xe7\xbdk\xc8\xe8\xe8\xbf\xe2v\x84\t\xb2\x1c\xc5\xbfT\xdd\xff\xa0W\xfc\xf2?\xf6WF\xb2c\x9a\xe1?\xa8\xe8eog\xec\xfb?\x0fG*\xae7P\xf8?\xfd\xbb\xf5:\xb6\xb3\xe6\xbf\xc3f\x9fXEH\x9f?\xf9_z\x1b}\x8d\xef?\x0c\xc0\xc1\xb79\x17\xf0?\xbb\x87\xaa\xf9\x9e\x91\xf3?AH(\xee\xe1\x8f\xd6?\xf0\xcb?\xea\xca\xe2y\xbf\x19\x88\x92\x1b\x98\x02\xa1\xbf\x9d\x829O\x82p\xf3\xbf\xd5\xd8A\x1e\xd8\x80\xf4\xbf.\'\x07\xe2n\xe4\x00\xc0d;\xc8\xca,\xf6\xff\xbfW\xf336\x94"\xf8\xbf\xfb\x00\x1b0X\x94\xf8\xbf\x92|XD\xcb\xb1\xf7?\xf3u\xefB"i\xdb?\xe1\xbcc\x7f\xce\xda\xe8\xbf"\xad\xd2\xc9\x94\x02\xf4?\x12\x1b\x90a\xc3t\xf3\xbf\x84\xd4\x93-\xb1<\xee\xbf\xa4 \xc8b-A\xfb\xbf\xfc\x0f~Kx\xcf\xea\xbfO|}\xfc\x14\\\xb9?\xb7\xf3\x00\x0c\x9a\x11\xf0\xbfgdx\xefA\x91\xd2?pF5"K\xc9\xff?\xa8*/\x96\xa4\x00\xa7\xbf\xbd\xec=}\x1bL\xe5\xbf\x7f\xd4\xc5Y6\x00\xe2?\xf1\x07@\xfc\n\xc8\x02\xc0\\\xce\xc2u\x16\xe6\xd3?\xedQ\xeb\x94u \xfc?x\xc2d\x98:^\xf1?U\xf0KZoM\xe7\xbf\x923\xbd\x87\x0b\xb4\xf8\xbfk\x01\xc5M\xe5Z\xea\xbf\xe23\xad|\xb7A\xe6?lI\xf0\xd7*F\xf6\xbf\xbb\xa0\x88i\xc6\xc5\xe2\xbf\x11,+\x14\x92\x89\xf8\xbf\xbf,\xc8\x0e\x10\xdd\xf0\xbf\xb6X\xad\xbd\x02\xbe\xf6?\x0cb\xe8\xca\x02)\xe3?\xca\xd0\xbe\xe9\xa8-\xe0?\x9f\x08\xea\x1b\xdeA\xdb\xbf\x9f\xa8\x15)!\x86\r\xc0\xe4\xd4\x9b\xd0\x85\xfb\xe6\xbf\xd7p\xc7u\x90R\xf7\xbf\xe0\xf57\xb4\xd0j\xf8\xbf\xa4x\xef!/7\xe9\xbf^\x00,\xba\xfd\x02\xf1\xbfp\xe5f\x13\x82;\xeb\xbf\xb8}\x0b\x88v\'\x05\xc0\xa9\x1d\xba\xed\xfb\xdf\x03\xc0ZQ+L\xfd\x1f\xfa\xbf\xc1\xfb@y\xf3v\xd5\xbf\x88\xa9\x08\xeb*\xc5\xed\xbf\x8b\x84\xa7\xbaU\'\xeb\xbf\xd3\x8cT\xd1\x86\xb9\xed?\xfa\xb5\xa5zt\x1f\xfd?\x96\xb7\xe3e\xbf\t\xf1?\xd8\xc5\x8f\xdeE\xcd\xfb\xbf\xb4\xa2&\xbfF\xa8\xd2\xbf\x02E\x1e\x1b\xf1\xa4\xe7\xbf$\x06\x01\xc8\xeb"\xcb?\x12`<\xb2\xe4)\xf7?\x07\xdb>B\xa9\x0f\xf3?\x8a\xdc\xe3>\xa7g\xe7?\xcd\xacT\x05\xdcu\xd2?\xc9o@\xb1\xad\xfa\xfe?\xa3\xbf\x96z\xc4V\xf0?\xeb\xdc\x808\xaaA\x95?I\xc8\xee\xc4\xad3\xf7\xbf\xb9F"\x11\xb6]\xfe\xbfa-\xe7\x97\xef:\x0c\xc0\xda\xc8S0\xec\xec\xff\xbf\xd1\'\xe3\xd3\xc2\x01\xfa\xbf5:H\xe5\xd4}\xfd\xbfs|\x98|?\xce\xff\xbf\x15\xadrd\x8ex\xd3\xbfz\xe3\xd8=\x99\x0f\x03\xc0D\xa6\x8cW\x1a%\xd8\xbf8\xc6\xe6\xe25v\xfd\xbf\x18\xf8\xc4\xbc\xca\xcc\xdc\xbf\xd1(\xd9\xc5QM\x00@\xad\x95\x1a\x1c\xafY\xe3?\x17P1\x073,\xf0?S\xec\xcac=\xa7\x07\xc0D\xd9\xf93\xad\x85\xf9\xbfk\xabh[L\xd1\xe8?\x19\x8a\xffw\xa0\xb9\xd1?\xeb4\x14X\xb6\xb9\xdf\xbf\xf3\xda\x00\x02s=\xf3\xbf\x9a\xf6\x9bN\x91\x1e\xe0\xbf\xe6\x03\xe4f\x80^\xdc?\x98<\xd3\xb4\x08\x01\xc1\xbf\xd8\xee\x870\xe7Z\x03@\xd3|\xd5\x0b\xbaT\xeb?\xb7z\xa7\x15\xbde\xed\xbfo\xda\xc21\xd2\xf1\xfb\xbf\x0e\x9d\x86\xef\xb5\t\xf3\xbf\xa8^\xe6\xcc\x05\xfe\xcb\xbfu(Wy\xfe \xe8\xbf\xb6\x82~\xa0=u\x00\xc01\xe9\xce\xa5O/\xec\xbfDc_k\x0ch\r\xc0\r\x9d\xa3\x05f\x03\xf0\xbf\xac\n\xe4\xedmU\xbc?\x0bt\xb9\xfa\xf0J\xee\xbf\xf26\xa5\xa0\x83\xbd\xf7\xbf\xdd!\x9e\xa2\xb1\x92\xdd?/"l\\\x94\x8f\xe2\xbf\xef\xda\x05fM\xea\xc0?\xe9_\xae\xbd%c\xed?\xef\xdaFP\xbf\xec\xee?J\xbd\xc1a\x05p\xfa\xbf\xa0\r}tm`\xfb?\rx\x9e!\x14\x05\xee?\n\xe6$\xbd,]\xd1\xbf\xcb\x8a9Uh\xde\xf2\xbf\xccZf,H\xe4\x02\xc0\x8c\xde\xbbb\x93\xe2\xf6?s`\xb6\x98{\xfd\xef?\r\xf8R\x1d\xc1\xf7\xf1?t\r\xb1\x9e\xef\xd0\xa0?|||*\xfa\xe5\xfb\xbf\xef\xd6\x11\xc6\x01d\xfd\xbf\x99\x88\x96o\x1c\xb9\t\xc0\xa8\xe5?d!I\xf2\xbf\xc8\x91\xc2\xcb\\\xac\xd2\xbf\x9c\xc3($JL\xf9\xbf3\x0bj\x1a\xea\x9f\xb1?F\xcd\xd1\xcb\x1b\xa9\xf0\xbf]{\xc9\xa8\x9e\xb5\xe0\xbfX\x9e\xf0\xf6\'\xa0\xe8?\xc1\x87\xc6WVL\xfe?M\x8b5\\\x18\xa4\xe5?$\xde+\x00\x05}\xf5?\xa5Bi\xa9\x19[\xdd?\xbc\xf7L\xc9m\xc2\xd1\xbf\xc3\xb1<\x84\x00S\xe5?@\x03O\x99\x10\xaf\x00@k\x1b\xe0\xe0\x06\xb6\xff\xbf4\xee8\xcf\x7fy\x00@{\x9e\x81\n\xd9)\x00@&\xed\xccb\xb4\x94\xb3\xbf\t\xb9\xc7\xcbo\x07\xe2?\xa1g\x8f\xb7\x7f\x9c\xe3?\xabp\xda\xbd\x86\x00\x01@\xf6?X/1|\xd6?\xe4\x8b\x10\xf9\xb0\x00\xbb?\xfeS\x80M(\x0b\xe7\xbf\xf3\x9aF\xb0gF\xc3?\x10bSHd$\xe5\xbf\x10C\x83\xcd#\x8e\xc9?\x12\xa6cv\x97\xd8\xf5\xbf\xbe\x89\x06,\rc\xa7\xbf\xc8\t0\xd7\xa9\xe8\x00\xc0I\x1c\x12z\xba\x99\x00\xc0\xc5l\xf6\xd8\xe6]\xe6\xbfg\xbdK\x08\x04\xb6\xf8\xbf\n\x87\x9e|\x90\x9d\xc3?\x8c\x99\x8d0\xe1\x18\xe2?c\x07\xb3F\x1c\x85\xf6?n\xe5nY\x0e\xb4\xf8?\xc09,\xfc\xba \xd1\xbf\x1b\x14\xe3,\x8am\xe3?6N\x9f\x84U\xa4\xd1?DD\xd2z\x17\xcf\xdc\xbf\xe8\x88E>-b\xe6?<\xb0\xdd*8\x03\xde?\xef\xcc\x1a,\xa0\xb0\xfa\xbfS\x04\xdc\t\xe3\xdf\xd8\xbf\x81,\x11yx\x7f\xf0?\x9c\xde\xbbHZ\xcb\xe9\xbf\x0b\x1e\xdaLRp\xe6?\xbe\r\x95\xfb\x90\x18\xd2\xbf)\x8c\xc9\xd8a \x02\xc0\xc4\x18\x85T\xd4\xb8\xf3?Y\xc0\xdfq\xcf\x10\xe0?\x8b\xdf[\x01F\xfb\xc1\xbf\x01\xcf\xc0\xaf\xd2\xc5\xe6\xbf1\xd8\xad#;\x15\x00\xc0K\xd5Y\xc8\xc2|\xe0\xbfl\xf1\xf6\x83\x9c\x0f\xd3?\xea\x92 s|\x92\xfe\xbf\xab\xca\xf6\xb7N\x89\xf1\xbf\xf5K\xbfs\xeaH\xe9\xbfc.\\f\xb5\xf2\xed\xbf\x81\x94\xf4\x8cI\x81\xf0\xbf&}m\xb8\xda\xb5\xe6?^\xcb\x0e\x03\xf8\xa4\xb7?Pz\x15O\xdb\xda\xd6\xbf\x01\xd7m\xcb\\\xf5\xdb?\xc4y\xa5\x90\x1f+\xfa?T\xddX\x8f\xc1\xc7\xd6?Z\x1d\x9f\xc2\x83\xf1\xcc\xbf\xed\x98\xfd\xb9=V\xd7\xbf\x131\xfdG+\xf5\xc4\xbf\x089D\x14R\x12\xde?\xb0\x02o\xef\x19T\xcb?\xa8C\xd4\x81k\xbe\xfb?P6Z\x19\xa7\n\xd3?\x1a0\x88\x8dY\xaf\xf6?\xcb \xd6R{\x8a\xf9\xbfo\x97:\xf1B"\xd0\xbfS\x87\x96\xe2<\xca\xe2\xbf]?\xb8\xc2\x0b\x92\xfc\xbf.(:j;\x1a\xcf\xbf\xf7\xf9\x1f\x8bBR\xc2\xbfD<\x11\x00p\x8b\xe6\xbf\x1a2}I\xb0\x9d\n\xc0Z\xe5>\xc8D\xea\xfc\xbf\x9b\xa2\x86\x01\xe2l\xf0\xbf\xeaD\xed\'S\x1a\xec\xbf?\xa2\xef9Q\x18\xbf?\x9f\xa3\xf4\xb2*I\xef?\xd0\xbaC3T_\xfb?\xe0\xf9nx\xf6\xcb\xf0?3QV;\xcf\x9a\xef?\x1ef\xfb\xf0\xcc\x8a\xd5?L\x803\x11\x88T\xf3\xbf\x83C\xc0k\x05\r\xd2?\xb9\xa7G\xadde\xe0?\x16\xef\x9a$\xb8<\xa8?\n\x08\x08:\xb5\xbd\xd0?\n\x89\xb9\x9d\x04\xc0\xfa?\x98p\x81\xee\x00\x87\xd1?:\xe6\x8e\xb1c>\xe4\xbf\x17\xe3WS\xe2\n\xff\xbf\xd5\xed%/q\x90\xf1\xbf\xca5\xb6\x1aZ~\xf3?mX\x12\x97B\xda\xe9?S\xd2\xcar\xe6\xff\xc6?G\xd9\xa4{%(\xe5\xbfpUQ\x118\x80\xd1\xbf\xa2z\xf6\xad\x17\x8f\xf4\xbf\x9d\xa7~\xe5E\xbb\xf3\xbf\xf6\xa6X\'\xd3z\xf5\xbf(\xfb\x82i\xa3\xff\xc2\xbf(\x9b\xb3\xd8\xa4k\xd2?\xc4|W\x9fW|\xc1\xbf\x82\x0e\xc5\xbb\xec\x93\xfa??\xbc\x8b>\'@\xe2?\x03D\xa9\xa9g\xef\xfb?\xaeI"\x12!\xfb\xfc?Ag\xeeh\xb5\xcc\x05@d\xbe\xa48T\xc3\xb9\xbf0\x08\x07\x88h7\xf4?\xdf\x7f\x96~\xd5\xbe\xe4?Wk\xbe;H\x8f\xcb?\xdf\x11\xd5\xfa\x8a\xfb\xd1\xbf\x87[\x96\xac\x10\xfd\xde?F\xe4\x02r9\xa3\xcf\xbf\x17\x12\x8b\x10\xcf\x81\xfd?Q1\x01Sqm\xc6\xbf"\xc3z/gd\xe8\xbf\xb8o\xe3\xe1\xeb\x88\xfd?\xe2\xe1AS]\x08\xfc\xbf\xa8\xc9X\xd5\xa6V\xdf?\xfd\x8ds\xdfB\xa9\xe2?Qc\xf7C\x86\x86\xfb?*\xd9@\xac\x00\x1f\xf4?\x85\xea\xd9U\xd5\x80\xd1\xbfx8\xa4\xe11\xd5\xdb\xbf\xf2b%\xa7\xf7/\xe0?\x0b\xb4\x15\x8dx\xb1\xd1\xbfm\xaa\xe2\x9a\xb4\x9f\xe7?\xe1R%\x808\xd2\xc5?S\x84\\\xc0\xf6\xef\xf8? \xa4\xd1\xdd\xcc\x94\xc8?\xe8\xcc\x14\xad\x94M\xf3?\xbcK\x0e\xe5\xdf\x94\xf4?\xdd\x95g#\xe5\xc9\xa0?}E\xf7x\x0c\x0c\xcc?5\x918$\xb5\xf0\xfe?\x10IA\x7f\xd5\xc4\xf3?\xc9p\x1d\xd2?\xdd\xfa?g\x80&$\xa2\xf0\xec?X@\xfb\xb3F\xef\x02@\x9c\xc3\xfe:\x1d`\xe8\xbfF\x83\x1a\x8c\xe4!\xd0?$m\x87\xff\x83\xfc\xb0\xbfF\xcd\xd0p(m\xfd?\xfd$\xd5\xadkD\xf0\xbf\xa3=b?t\xb6\xf2?\xf5d\x93J.\xb0\xe4?\x0c\xc9\xb9ZwL\x02@+\xaeu\xa5\xe1\xf3\xf3\xbf\xcb]\xd0\x92C]\xca\xbffr\xddD\xd9\x93\x00@\xe5`\x17\x0b\x85?\x00@e\x81\xc6\xf2\xa3\xc6\xf7?\x11\xd2\xcd2\xc4\x88\xff?\xb6\x1b\x9c\xfe\x98\x14\xd9?\xee3<\xea^\x1f\xd5?\xee\x05\xaf\xf1\xc7\xd0\x01@\xa12}\x99\x05\xd6\xfd?\xd8\xa6\xe02ld\xfb?\xf2\xf3\xbd\x1b\xde\x13\xf8?\xb7\x83\xa9\x93\x12\xd3\xff?R\xaaE\xfb_\xb1\x04@\x82\xf9h*\xc7\x11\x02@\xd8\x11\xe9`\xa3\xb0\xdf?s\xa8c\xad\xd0-\x01@\xae_0\xd6\xb6\x0b\xc7?\xe7\xca\xf5\x93\x87}\xe3?H\t\x89\xa8\xcd\xcd\xe2?\xe4H\x12\xb8\x97\x9a\xe1\xbf\xc0@\xbc\xb5,\x1a\xe4\xbf\xb1\x89\xe6\x93\xea\xa8\xb4\xbfO\x15\x17\xf4\x82f\xbc?\x1c\xbb\xf6m6\x0e\x02\xc0I!\x02`\xe45\xe1\xbfp_T\xe6\xafO\xf3?)[\xe4\xf0\x96\xed\xef?\xa0\xac$ l>\xe0\xbf\x97/\xae\xe4\x10M\xd3?k@L\x1f\xca\x88\xfe?\xf8,d\xd3\xd6\x1f\x01@\xdd\x14\xf1\xf1\xbb\x05\xf1?\xea\xae\xa7i1\xbc\t@\xf5\xea\xa7\xb4\x18S\xf1?\xc6oV\x9aLS\xff?0\xce\xaceX\x8b\xfa?\xea\t|D\xa0\xb5\xee\xbfOc\x8e\xfc\xfb~\xaf\xbf\xba\x100\x9d\x8f\xbd\xe3\xbf~\xcc2P\xee\xba\x00@~FL\t~\xf0\xdc?v\\B\xb2\xbc_\xe9\xbfk\x93~*\xd0\xdd\xc1?\xf5\x83\xdb\xdd\x94\xa6\xf1?\x05!7\xa5\xf7|\xf3?\xce\xf6\xc0\x83K^\xfd?3r\xe2\x1d\x810\xe8?\xa9\xbb\x17\x850\xa9\xed?\x7fL\xe5\xb0\x15\xd4\xdd?\xde\xeb*\x84=+\xf4?\xe8\xe48\xe4\x7fy\xf7?\xc2_\xeb#\xe8d\xfd?\xe17\x1d\x0fE\x8e\xd2?#\x162\xab\xf3\xc8\xfd?\xbd\x13-\x94\\\xf6\xf8??\\\xe2\xfe\x8a\xd0\xd2\xbf\xb9\xdf\xf5$\x1e\n\xe8?\x1f\x0eO\x8d5\xe2\xa3?+v^h\xdbz\xec?\x91?0\x17\x898\xd9?\xf3\xa7\xabn{\x1f\xcc?q\x97MD\xce\x82\xff?\xaf\x10I+\xc7\xd4\xfa?\xfc\xb5\x8f\x8d{\x10\xf0\xbf\n\xb0\xbc\x8bu\x17\x00@#\xb0\n\xea\xfd\x98\xf9?\xben"-\x93\'\x99?L%\x8f\n\x84\xdf\xe8?\x04\xee\xbbY\x16#\xf3?\x98\x1f\x88\x86U\x9b\xb9\xbfod\n\x0fVm\xf5?\xd4\xcc8_z~\xf6?\xf1\xd5\x01I\xc6\xed\x7f\xbf\xb4\x16\x86\x93$\xcc\xd5\xbf\xbb\xba\x92\x85\x17\x8b\xd1\xbf\xe17s\x18\xdf=\xd0?ZR\xa0\xf9\x04\x87\xce?C0\xd0\xfd\x86g\xc1\xbf\xf7\x0cP6\x11\xa7\xe3\xbfi\x19r\x86v;\x9e\xbf\x8b\xc6\x0c\xbb\xb6\xde\xe7?\xf3\xd5O\xb3\x0b\xa2\xd5?Ac\'\xa2\xa7{\xf9?\xd7>V\x9d\xfb\x83\xf1?\\\xd2~\x95\xe4\xa6\xf2?\rG\x84\x1f\x82\x84\xf9?k\x96\xbc1\xafY\xf8?k\x87\x8dp\xdc\x0e\xfb?QZ\xb9\x0b\xf2\xba\xf3?b\xa1\n]\xa7\xeb\xc0\xbfT\x9bl\xf6a\xf5\xed\xbf\xebh\xc6\xae\x0c\x8e\xe8\xbf2\xfc\xder\xcdw\xb5\xbf\xdb\x84\x86\xb6\xbf\xa8\xeb\xbfy7;\xdd\x0b\xcf\xc0\xbf\xeeV]\tV\xf7\xf1\xbf\'P\xab6\x1cu\xe9\xbfTO{\xdb)\x12\xf2?Z\xack`F\x14\xfa\xbf^\xffWb\xb4\xa5\xf5?\x12&}U\x110\xf1\xbf\xea\xfe4\xf8\xec\x02\x00@\xe9\x90\x82jD\xe0\xee\xbf\xc5\xc7Iy\x7f\x00\xee?\xb6\x96\xc9\xac\x07\xad\xce?\x8f\xd6"\xa7\x15Y\xd3\xbfy\xcfg\x02w\xc6\xf6\xbfdv|\x90\xcd\xc8\xf1\xbf_W\x8c\x89\x97\xce\xea\xbf\x18\xf5\x99\xe4\x0b\xc0\xe3\xbf\xad,\xd8\xcb\xe0\xfc\xfc?I\x92.\xea\x88\x96\xfc\xbf\xb9\x1f\xd8\xcd1*\xa8\xbf9S-\xba\x8a\xc7\xf4\xbf^\'\xf0B\xf7\x9c\xc6?\xba4\xd5\xe7\x94\xa2\xf4\xbf-\xe2b\xe1-\xdf\xd9?\x9b2t=4\x11\xe1\xbf\xcb\x8a\xfa\xf8Yv\xe8?\xbb?"\x0baD\xdd?;\xb1 f\xb8w\xfc?U\xdb#b\x06\x0e\xf5?\xb2\xd9\x1b\xc8 \x9e\xdb?\x0fk\xee\x96\x06\xbb\xed\xbfs\xb8K\x99\xbf\x01\xf7\xbf\xa7w\x00\xcb)\xe9\xcc?`d\x1d\xc4\xd5p\xea?^\xb5\x87\x18\xb32\xb8?\x82\xdaH\x93V,\xaa?\x9b\xaek\xbe\xffg\xdf\xbf\x0e\x0f\xbcku\x1c\xe3?\x95#\xd7\xcb\xe2g\xfb?\xa5\xe4\x9a\x10\x9f\x07\xad?gv"5\xd5\xb0\x00\xc0Za\xf1\xc1\xa1\xa6\xeb?\xce\x8b51*j\x8e\xbf\x85\xe7s\xdbu\x0b\xf6\xbf\xddy\x11\xae\xd6/\xf2?\xfa\x11\xcf[\xa4\t\x08\xc0\x85\xd9\x04\xc4\xbd3\xfd\xbf\x8aZs\x01\x0e-\xe7?T\x88T\xc2X\x94\xdc\xbf\x13\xcc7P\x9f\x87\xf6\xbf\xbd\x11\x15\x07\x08\xbc\xef\xbf\xb1\xa1\xe8\x13\x8aP\xea?\x19\xfe\'\x7f\xe0W\xc7?\x80\xc9Q\x9du\xe0\xef?g\x81f\x11\xb0\xd9\xeb?\xb3\xe9\x80\xf0c\x9a\xf1?\xc6\xb7\xac\xbd\xba\x89\xf7\xbf\xa9\x94\xe3b[w\xe9?\xaf\xe1\x16\x1fG\x84\xf5\xbf\xf2W\x92\x1fv7\xf7?r\xd9\xb4F\xd4\x82\xd6\xbf\x92il\xfb\xe9\xdf\xf3?\xe0\xd9$yk\x8c\xd7?!\x9eg}\x1bz\xc2\xbf\x8e\xe8\xa3F\xb1N\xf1?\xf7\x04\x89\xc2\x7f\xaa\xda\xbfA\xe8\xd8Z\xecf\x92?\xd9\xa7/U\x8c}\xf9?\x00R\xab(}\xfc\xf1\xbfVB\x17\x04\x83Y\xf1\xbf\xa7_\x14\xdeZ(\x04@\x7f\x07\xff/\xa1\x9e\x8c?\x11n\x8c8\xac\x14\xd4?NU9\x04\\\x1e\xf1\xbf\xb9\xba\xb8\xfdh\xdf\xf0\xbf5i%\x81\x04!\xcc\xbfP\xf1\xe4t\x90!\xda\xbf\xd6\x8ae\xc6Wh\xeb\xbfkH\x9a\xb5@\x0f\xd3\xbf\xbb\x16\x94,4\xe2\xb2?\t\xc2\xdeW\xc2\x8c\xc4?\xfay\xb2\xb7\xb4\xfc\xa7?\x15"\x87l\x02\xf9\xb9\xbf$\xde~\x84\x02\'\xd4\xbfuC\xf3}\n\x8d\xf6\xbfb\x872\xb1x\x92\xb4\xbfT\xa4K\x00L:\xfe\xbf\xf70)\xa0\x07\xb6\xe7\xbf\xa2\xa53\xcf*\xed\xec?+d\xcdi:.\xeb?_\xff\x03\xe3\xbf\xc2\xa4\xbf0\x8c;\x98"@\xf6\xbf\xf2\x8f\xf1\x01\xfb\xdf\xe0?\xfa\r\xdc\x10\xba\xb6\xe6\xbf\x14l\x82%\xee\xb3\xcf?\xc7R\xa0\x9c\xab\xfd\xee?\xd7B\x84/\xc2\xf0\xa9\xbf+J\xeb\xef\xf1n\xf7\xbf\xed\x89\xcf\xefuy\xe6?\xd2\xf6\xd7\xfa\xd4\xbd\xe3?\x8fm\xe3\x8d>i\xe8?\xc0\x07\x1e\xa3\xf6\xe7\x03@\xfa\xb5\x84\xa9g\xf6\xcb?\x8fp\x86e\x18i\xf5\xbfd3[\xd2\xf7\x89\xfa\xbf]\xeb\xe8\x97\xa5\xa9\xe2?\x81O\x1b\xf2\x86\x91\xe0?\x89\x1c\xb0\xf4<\x13\xf0?]\x06\xc2\xe5,\'\xe0\xbf\xfcd\x93"z\'\xe1\xbf\xf6\xbe6\x1e\xcc\x1e\xed\xbf\xcd\x88]\x10\xe5\x0c\xda?Kg\xdc\xa5"\xd3\xfe\xbf\x03\x9e\xbe\xfb{\xf7\xfc?\xd4\xbb\xfa:\xa0\x91\xf9\xbf\x871\xf9g;f\x08\xc0\xd9\xa5`AI\x11\xe1\xbf\xc3z\x8c\xdf\ti\xf3\xbf\xec\x8bIq\xd1D\xd1\xbf\xe5\nx\x89^\xde\xc9?4\n\x18>\x141\xf9\xbf\xadw\xf5\xbe\xceu\x82?\x99\xd2U\x06\x8f\xe8\xd0\xbf\x08v\x0b\xcd\x7f0\xf8\xbf9mv\x80\x10\n\xfb?3\xad\xabM\xe2\xf3\xfc?\x82\xaek\x9cL\xa1\xf8\xbf\xe3\xdb\\\x94\x851\xf4?\x81\xab\x05\x1biK\xea\xbf\xbc\xd4\x89\x81\x00\xf2\xef\xbf<\x1d\xe4\x1b\x1d\xbf\xf1?v\xc5\xcd\xb3z|\xdc\xbft\x9c\xb7\xd1\x04\xc2\xf1\xbf\xbc\x99\xbb3\xb3\xca\xf0?3=\xa0B\x0b1R?\xe08\x0f,N\x18\xf0\xbf}\xc9\xc7\xf6H\x92\xda\xbf\x95~\x07\xbe\xbc2\xf0?\xe1\xd2\xd0\x0b\xe0\xd8\xdb?\xf9\x8d \x1eY\x06\xc4\xbfGj\xd6\x85k&\xd9\xbf\x97\x99\xa3\x0c\xc5M\xf0\xbf\x06\t\xf3m!\xc1\xc4?[\x80`\x8cVY\xfc?c\xad\xa1\xea\xea\xeb\xf4?\x91G\x87\x91\xa4\xd4\xe9\xbf\xa2\xa8\xe0\xa9\xcb\xf6\xb7?\x91\x03\x99o\xbf\xe0\xb4\xbf5\x96\xdef\xac\xb2\xd1?\xb4\x1a\x1c\xb4\xfeB\xd9\xbf\xb0\xa0.\x9b\x05Y\xf2\xbf\nr\xf5\xfe\xaf\xe4\xce\xbf\xbc\t\xf5G;\xd9\x9e?\x06\x08\x8b\t\xb9\x04\xf2?\xca\x0e\xa7\xec;\x9e\xe3?\xb9\xd0G\x00\xc3;\xd3?!VV#\xbf\xa6\xee?K\x19\x0bC\x18M\xcb?H\xf3\x98"\x8a\xd5\xcd?i{Qp\x8f\xd1\xd9?qrII\x96\xa8\xe0\xbf\xd4\xc5\xebd\xedJ\xda\xbf\x03\x16Z\xe9\xb6\xa4\xff\xbfm0\xb0H\xb6\xa0\xd2?\xd8\x8aL\xa9\xbc\xf6\xd6\xbf\xb3-]\x1b,\xff\xec\xbf\x90A\x9b\x1b\x11\xa1\xfa\xbf\xd0\xa1,\xf1\xd3\xea\xf7\xbfs2/\x98]\xea\xfb\xbf:d\xe2r\xc0\x04\xde?\xf8|\xb8\xc8\x9d/\x01@\x87C}\xba\x0eb\xea\xbf\xb2\xd2\xd4\xe1\x04`\xfa\xbf\xdb\x85\x18\x8b\xbe\x1b\x00\xc0\x9d/\xbb\x97\x95{\xe1\xbf\xa6:\nM\xf1A\xb7\xbf\xa8\xaf:\xf8d<\x01\xc0i\xd0\x86u\xf1\xfd\xe0\xbf:\x88\xae+\xe7\x81\xf2?\xd1AdTX\xe1\xf4?R\x16\x0e\x90\xf7\xbc\xe9\xbf\xaa-R67"\xf7\xbf\x89<\xc0\x1c$\x85\xeb\xbff\xc4\xae\xcf\x9a\x0b\xe4\xbf\x06\xbe\x11\xe9B\x06\xf2\xbf\x16\xc7\xf58\x10\xe7\xd4\xbf\xfdH\x9f\x071\xb8\xf1?\xdb\xa4\xf5\x8d2\x81\xea?,*\xd7\x8e#z\xe9?%\x8a>\x81\xa4\xb0\xdf\xbfo\x84\xbav \xfb\xa5?<\xf2\xcakV\xab\xc8?\xcc\xd3\xa8\xbe\xfb\xab\xf0?\xce\x8c\x16\xb8\xfe\xe3\xf7?\xf4\xe3\x88\x14\xd8\xc7\xea?O6\xa3\x12v\xe2\xeb?\xa5\xdbi\xaf\x1c\xe0\x01\xc0\x9a\xc0\x01\xa7\xc1\xb9\xe2??\xfe\x93Sl\xef\xf3?sO`0\x08\t\xa1?\xf7\x1b\xad\xef\xe7\xf4\xae\xbf\xbd\xeb}\x07\x0f\x03\x03\xc0r\x94\xe1c\xe4\xfd\xfc?7\xe4\x92\xb3{\xfe\xd4\xbf\xed\x89\x81^\x19\xe3\xf2\xbf3-\xcb\x8b\x8c\xa5\xf5\xbf\xb4\xf0W0\xa1\x9a\xe4\xbf\ti\xc6\xd2\xbf\x11\x89\xde4an\xf1\xbf\x94\x19\xb4iL\xbf\xd7?\x99\xc9\x12\xd3\xbf9\xf2?\x1emW\xa9\xedE\xe6\xbf\x1b\xa8S:ji\xef\xbf\x8bx\x91\xef\xd8\xab\xf9\xbfo\xe1-S-\x10\xd3\xbf\xab`_L\x90\x19\xdb\xbf&\xaf\xe5\x84\x0f\xb1\xf9?Q\xc8V\xfd\xb3\xee\xfc\xbf\x0b\x84\xb1\xb6\x05X\xd6\xbf\t\x12\x19M\x93\x9d\xf2\xbf\xd0\th\x04\xab!\xe0\xbf\xb7\xd1^\xf9\x82\xb7\xd1?\x98\x96\xe2J\x94\x17\xd1?~\xc3\x8d<\xea\x8a\xfd\xbf\xd6\xf0\x99\xdb\xed\xed\xe0\xbf\xc0J!#W\xde\x05\xc0\xde8T\xfa\xd5\x9a\xf6?\xd1\x1cB\x81:\xd7\xe9?\t\xe6Y\n\x10p\xf1\xbf\x8a\xe5\x87N))\xe0?m\x80D\xef\xfb!\xc5?\x14\xa9\xa0\x8b\xfa\x81\x00\xc0\xf2\xbc->L\xac\xf5\xbf^\x0f!.fx\xe1\xbf\xf2\xd3\xf4\xadw\xf9\xc9?Rw\xf0\xd1\xa9\x94\xf4?i)\xed\xf7\xe7g\xc4?\xeb\xe77\xab\xbb\xe8\xf4\xbf\x08\xb9\xa6m\x1d\x0c\x00\xc0\xc4\xeaY\xe0SH\xd6\xbfR\xb3-R\x81\xb2\xf7\xbf\xa47\x17dj\xbd\xe9\xbf\xe4(\x9c\xe1\xe2\x81\xce?$\xba;8\xed6\x07\xc0\xae^EeX\x8d\x0e\xc0\xe6\x93v\x14\xc7z\x10\xc0\x83p\xc9=\xd0^\x03\xc09z\xb45\xbf\x1b\xfe\xbf\xaf\xb30z\xb3?\xf9\xbf\xcf\xbaACM\xf6\xeb?M\x14\x9ek\x1b3\xca\xbf\xd0!\xf2e\xe2-\xf7\xbfLN\xf3\x1a\x8f\xa7\xf8\xbf\x8b \xc2\xc0l\x9f\xf0\xbf\x03*\x05\xfahF\xe1\xbf\x0e\x81m\xef\xc3\xa0\xf7?OW\xf8x\x89\x98\xf6\xbfU\xb2\xf7 \x15\x94\x06@@\xa4~\x89\xc4\xc2\xd6?\x84`\xea\xba\x14\x95\xc9?Y^\'\x99\xbf}\xba\xbfS\x90B\x16.1\xaf\xbfCw\xd6\xf9\xe4\xf2\xd4\xbfD\xd4\x08hw\xca\xd2?\xfb\x13;\x89.\xe6\xdf\xbfx\xe6X\x1a\xaf\xb7\xfa\xbf\xc2A\x7fPV\xbd\xfb\xbf\x04\x80:hc\x99\xe9\xbfNr\xe5\x9f\xd6\xd7\xf2\xbf\xdc\xc0C*5w\xb4\xbf\x9a&^\\k\xa6\xf3\xbf\xc6\x80\x8c\x87\xd3\xcd\xcc\xbf\x1cz\xc5\xcc\xe9\xf7\xea?\x14\x04\x84\x93\xc8y\xda?\xfa\xf0\x04L\x92\'\xde?r\x11zl\x83J\xf0?\xc8\x84g\xd3\x16\x87\xf9?\x1b\xd6\xed\x8fCf\xe4\xbf\xfc\x88\x1f5\xdf\'\xdb?$zM\xb6\xfbe\xf6\xbf\x81\x08\xf5\x91H\x13\xfb\xbf\xfcb\xf2\xdf\xdc{\xf6\xbf\x13?\xea\x8e\x8d\x0f\xfa\xbf\x16\xca\xb1\xe8\xc6\x15\xed\xbf\x9c\xfe\xdc\x86+\xcc\xe3?\xc4\x08\xa1\xa1=\x05\xdd?\xa2\xde\x0c;[\xf8\xea\xbff*+c:q\xe7\xbf\x1bD\xa8\xf2\x10+\xac?V\xb3\x1d\xc6\x01\x80\xf8?\x1bZeP\xae\x87\xd3\xbf\xc6\'\xc5\xe9^u\xde\xbfI\xa2\xdf\x19O\x96\xe5\xbf\x88\xef\xea\x9ao\x04\xd5?xQ\xfa<\xd8~\xe3\xbf\x0b\xf8\xe52\xd2\x17\xd3?a\x80X\xe6#\xb0\xe0\xbf\xb7\x9a\n\x88\x19\xe0\xe8\xbf\x9f\xc2lr\xfd\xfa\xf7?\xbf+\x12\xe6\xda^\xec?\x00SdCn=\t@\xe3\x12\xfb\x86\xb9\xe4\xfe?\xb5f\xc2\x1d\xf0\xdb\xfa?o\xf7\x19\xd5\x05\xf7\xe2?4\x06\xb0c\xe7\xe1\xf7?\xf3jG\xea\x1d\x17\xfb?\xc9\xd5v\x1d\xbe\xd1\xe4?IK\xbc\x1d\xeb\xdf\xfd?\xd6\x1e\xea3\x83Q\xfe\xbf\xf1\xd0C\x90\xc0\xdd\x04\xc0\x03{N@a\t\x07\xc0\xb1"\xbfr?\x8e\xfa\xbf\xd00\xbbN\x85\xbf\xfc\xbf\xff\xc2\xdbQm\x1e\xf3?M\xfc\x12\x0f\xc8\xb7\xe7?]y\xc8\x96\xfbY\xf3\xbf\x91rB\x99\xbe5\xce?\xbdEn\xad\x939\xc2?A\xbfY\xcd\'\x14\xf0?\xb1\xb6\x9e\x84\xfc\xbf\xf7?\xa0\xc0\xf7\xd8\x9aL\x01@Y\x99\xc8]NN\xed\xbf\xb36\xa8l<2\xf0?\xa9mD\xee\x11\xd1\xe6\xbf\xdb \xa6\xb2\x87\x91\xff\xbf\xf8.\x05\x9c\x9c\x83\xe0?i\xa8l}6\xba\xea?\\M\xe9\xdbxd\xf1\xbf(\xfbv\xb1\xc3!\xfd?S\xca\xfc\xf9\x02\x0e\xc4?^\xb7n33S\xb3\xbf\x89\x11\xe9]\xff\xba\xf3?\xd7V\x97\xc4m\xb9\xf0?8;\x9c\xeb\xee?\xcc?\xe6\xb2\x9eX\xaax\xcb?\xb2\x81\x99;\xdbB\xe7\xbf\xad~b\xe4\x16\x93\xfa\xbfIhS0}&\xf4?\xe2\x13\\\xa5X\xde\x05\xc0+N\x10\x129\xdc\xb3?\xd4\x82\xaf\xbaI\xaf\xf6\xbf\xd6\xf7y\nqn\xe3?[\xf7i\xbe/q\xf3\xbf\x88\xfaHS04\xeb?b\xe1-A\xfb\xda\xe3?\xbc\xbd\xdc\x13@\xbf\xd5?\xc7\xd7\xd9;\xd8\xb3\xe9?P\x8e\x95\xf5\x96\x9b\xca?@\xd5\x8ej\xa4\xbb\xd8\xbf\xfd\x84\xe8\x85\xf1[\xe3?>\xb5\xd2\xeb\xba\x10\xa1\xbf\xec\xa0\xe3\x8e\x0c\x9b\xf4?\xf6G\xf2\r\x18\xef\xf2?\xd2q`\x95\xfe\x83\xfd?]\xaa#`\x01\xdf\xf3?C\xaf\xde\xbfk\x0b\x00@\xd6m\x04\x1c\xfc\xc0\xf5?\x92V\x8dE\x14\xeb\xea?DiT\xf0K\x1c\xda?\x1e5\t\xd1.\x80\xc0\xbf\x15Z\xc2e)\xd2\xde\xbfY\xec\x9c\xccI.\xda?\xf9Fl\xc1\xf7D\xa0\xbfwws\x89W\x9f\xc3?)\xa1\xc3\xf5\x9a\xdb\xdc?\\\x88\x91\xc8J%\xff\xbf\x83\x91\xdc*\x85L\xfd\xbfIU\xaar\xd2\xb7\x01\xc0\xba\xe4p\x0bW\xdc?\xd9\xd7g6{\xed\xe2\xbf\xaaf\x90\xd4\x1a\xdb\xd7\xbf7I_s\xc5P\xf2?\xe7m\\\x83\xfe\xc5\xea?\xbd\xf9t\xcc\xc0\xde\xc8\xbf\xc5B\xe4\x06\x96]s\xbf\xfa6\x93\xa7\xb8:\xf1?hZ\xa3\xdc\xaf\n\xda\xbfa\x1fJ\x04fC\xe0\xbf\xe6\xd4-77P\xdd?\x19\xaca\x96\xd4\xad\xf8?\x84+\x81)\xaf\xcf\x0f@%\xea\x07\xf6kv\xea?\xcf\x9f\xb59\x0f\xa1\xb2\xbf\xf6\xee\xeaG\xa2)\xc3\xbf\xa5\x08bN\xce\xd0\xdc\xbfnuMjc\xa9\xf9\xbf\x8b\x06\xfe\xf1\x95\x06\xc0\xbf\xc4\x89 W\xc0M\xf4?}\xc6@\xb2CL\xd1?\x878\x1b\x9b\xae\xe5\xe5\xbfqB\xaf\xcco\t\t\xc0io\x85\x19YP\xe1?M\xc4XCD\x02\xdd\xbf\xe4\x1a\x94\\cY\xb8?.\xf6T\xcch\xa4\xee\xbf\x8d\xf2\xad\xca\xab\x9f\xdd\xbf\xdfN\x84\xb6\x15[\xdc\xbf\xc3`\x14k\xd8n\xb9\xbf\x84\xbe\x90\xa0\xb5\x86\xe8?\x95`\x96V\x19\xff\xe4?\xcc\xd0\xce5?\x1e\xf7?6e\xa6\xc3\x88\x04\xf4?\xd9\x88\xc7\xb4m\xf1\xff?\xbb\xc8\xb0\x0b;\xc3\xcc\xbf\xd2X\xa5 Aa\xe0?7\x8a\x18\x18\x90c\xe5?\xb8\x0b\x9eH\x0c\xd6\xd6?\x93\x0fUX/\x97\x87?\x1b\xa8\xb11lq\x03@\xf9\xfcP\x95\xac\xe5\xe1?\xae\x01<\x03\x9d\xf8\xee?r{\x07.\x1b\xb3\xe9?\xd3C\x7f\xf9p\xde\xd7\xbf\x9d.E"\x13\x86\xf2?\x99\x9c\xff\xbc\x1fV\xf1?\x95\xde\x8cU\xe0c\xba\xbf\xa8\x81\x98\xba2M\xf2\xbf\xa8\xff\x8f!\x8f1\xf9?\x0c^\xc4\xc6\xa7\x8d\xcc\xbf\xf3:u*\xc6u\xe2\xbf\x07^\xf2o\xa3\xc1\xe9\xbf\xe08?Sc\xb6\xb7\xbfQ\xb9\xb7\x8a\xe0\xce\xdd?\x16\x06\x1e\xb9e\x11\xf4\xbf\x08L\x16EN\x9a\xef?\x9a\xb7\xe3t-F\xf2\xbf:v\xb4\xc5\xb6\xd3\x03@\xbe\x10*Z\x86X\x08@B_pr\x03\xc4\xbc?W\x08_\x0c\x90\xdd\xa5?Y\xbc\xb0 \xb4\x01\xe0?1yf\xb0\x11\x9e\xec?5\\\xa9^\xaf\x80\xf0\xbf\xbb%\xb7\xc2\x01\x1e\xf6\xbf;\xb0\x1d\xb5&\x01\x03\xc0\xb8J\x99i\xe3\xfd\xfa\xbf\xbd\xdd\xcfD\xf1\x08\xf6?\xe5d\xf3\xe8\xeb4\xcd\xbf\xca$j}\x99\xad\xc6\xbfk~\xd8\xdc\xb8\xa3\x0b@\t5\xec\te\xd8\xf0?\xbc\x9a\x9e\xc0\xa7e\xf9?\x93\xb4\xe6\x1aR&\x0c@O\x0e\xb3!P\x82\xeb?\xec\xf4O\x08\xf2\x0e\xee?\x05\x81\xe81`\x05\xf2\xbf^\xa5@\x81\x14\x7f\xf1?\x9f\xa9n,\t\xa8\xd4?`\x18\xb9\xb1/n\xe7\xbf-O\n\xb1\x8f\xd2\xe2\xbf\xdc\xfd\x06(\xb68\xf4?=9R>W\xba\xf1\xbf\x85Jt\x16\x13\xd4\xef\xbf\xd0\xc3m\x8b&\x87\xda?A=w\x9e\x03\x92\xe5?vs\xb0\xae\xfcz\xc7?\xd1\x1fl\xb3\xdd\xd9\xf6\xbf)\xa0D\xf9\xabz\xcf\xbf\x8b\x1bF\xe3\xb1O\x01\xc0\x98\xd1\x85\xab\xccZ\xdf\xbfvh\xb39;,\xe3\xbf\xe2\x95\xc2\xbc\xae\xb4\xf9\xbf\x94\xe3B\xef\xd8!\x03\xc0\x7fx\x8dQ4<\xca?\x85ea>\x1b\xe3\x00@\xc8:\xa7V\xba\x81\x03\xc0dvF\xc6tp\xd5\xbfz\xae\xde\xcd\xae\x08\xf4?Gqy\x9f\x89\x10\xf5?\xd8x\xfa\x06\xa0\xfc\xe0\xbfw\x9f\xd2\x9a\xe75\xfc?B\xb9uWg\xe4\xd3?\xf9\x1bUr#?\xd5\xbf\xe0\xab\x84\xf2\xd4\xfb\xee?Y=\xcfh\xce\xd9\x8a?\xba\x91\xf85\xd7\xed\xca\xbflsFt\xba\xa7\xe5?\xb9\x86~\x14o[\xee?\x1a\xd2u\x7fVe\xf7\xbf\xfa&\xdfz\xf2\xb6\xe3?\xfeb\xd9\x9d\xc5\x1d\xd2\xbf\xfc\x9e\xfbp\x0e\xb8\xf1\xbf5i)|f\x07\xde\xbf\x0e\xa1"\x95\xf5\xc3\xf9\xbf\xe64oFz\xf0\xe3\xbf\x00\xbc\xc1\xdfY\xe5\xd3\xbf\xa5\xf8\xa2\x1b\xddX\xef\xbf\x97\xfd]v\x1f\xa7\xd9\xbfe\xa3\xe6\xf7m)\xf8\xbf\xa4K\x1e\x9e\xa4\xd6\xe9\xbfV\xc1\xb4\x9d\x7f\xda\xfc\xbfMJZ\xf5\xa2W\xfb\xbfNc\x7f\x8f4\xf4\xf6?X:x\xe5>\xe2\xf1?|\x8e\x04\xfaYn\x03@\x1e\xab\xed\xe8\xa9-\xdd\xbf\x9eL1\n.\xd6\xe7?\x96\xbc\x9b\xda\x9ff\x02@\x90\xca\xf4\x85\xb2\x06\xe8?M\xe7qP\x191\xe4\xbf:V\x92\x83\xca\xd1\xfb\xbf\x7f\x07\xd7\xba\xc2\xbe\xf4\xbf\xf5/\x0e\x80W\x9d\xf4\xbfw\xcfZ\xed\xcaQ\xcc\xbf\xf7]\xc2\xcbz\xaf\x02@[\xe1\xab\xfe\xb1\x84\xe4\xbf\xca\xd3\xd4s\x18\xe6\xc3\xbfz\xf7Xd!\x90\x98?\xc7\xf2\xf9}{2\xf3?C\x90\xcb&GY\xf2\xbf\xfc\x84p\xd4\xa7f\xe2?\xfd1~\xf5\xcd\xb8\xfa\xbf\xae\xd6\x1c\xba\x83y\xf6\xbf\xe5U>\x7fv\xd7\xf5\xbf\x95}\xe4q\xc6Q\xf4\xbfu\x85\xa2z\xc1\x11\xc8\xbf\xdbv}5\xf8T\xb6\xbf\x1eSk"\xfd0\xe9\xbfQ\xee\x89\xb8m9\xe4\xbf\xff+\xfe\xe4\x1c\xe1\xf9\xbf\xc6(\xdd\xc26\\\xec\xbf\x17\xf4f\xc6:\x17\xf3?\xaf\x8c\xad\x94m\xd4\xc9\xbf\t\x8f\xf0\xf9\xfd\x80\xd9?\x00!\rX_\xd1\xdf?\xaf?\xe4N!&\xdc?qk\xe2\x9e4\xfb\xe6?i\x85G\x82S8\xd9\xbf\x16\xff%\xd9R\x03\xe7\xbf\x9cr \xb6\x9c$\xd1?\xcd\x95\x1e\\\xd3\n\xe3\xbf\x0fQ&\xbaA\xd3\xf4\xbf|\x9b\xa3\x91\x8d?\xea\xbfi\xb4\xaa\xc8\xd4\x9e\xec\xbfA\x15M\xda\xb3\x02\xf4?\xb5w+\xe3\xf1\xe1\xe2\xbf\xfc\xd7Y\xa8<\xf0\x01@\x0b\xda\xe0W\xcb\x99\xf6?\x99}\xb9=\x80\x13\xca\xbfF\xeb3\x94\x9f\xba\xf5\xbf\xbc\x7f,\x0b\xcb\xd5\xd2\xbf\xaf&1\x9b\r.\xb5?S\xa1C\xa4<\r\xea?W\xcd$\x99o\x1b\xef\xbf\x90\x8e\x80|1}\xe0?\nd\x0f\xfe\x19t\xe3?\xb0\x15a~\x164\xe1\xbf\xc6b\xa2r\r\xef\xe6\xbf0#\n6\xb3\x96\xf9\xbf\xe8`\xe1R$\xcc\xf6\xbf\xff\xa3\xb4\xc55\xe2\xd2\xbf\xa0\xfb"\xe3V2\x91?\xf1/\xdf\xc2\xfd\xa8\xe2\xbf\ro\xacZ\x8d\xc2\xe3\xbf\x8br\xb0\x85Jx\xd0?@\xaf":\x18r\xdd\xbfQ\x8f\xcek\xa5Q\xe0\xbf\x16\x17\xd5\xc1\x97\x01\x00\xc0\ry[\xf7\xdc\xa2\xf0\xbf\\\xf1m\xdfP\xda\xe0?\xfd<\x91\x13\xdd\x12\xdf\xbf\x92\xcb\x1c\xd2O\x1f\xd5?\xa1\x10\xc7F6\x9c\xf8\xbf\xe7\x8b^\x16\xca\xc3\xef?\xef\x15\xf3"\xf6R\xed?,\xe1\xab\xdf~\xc7\xe9?\x1f\r\xbb\x9a\xc4Y\xce?\n\x96\xf5\'\x11\xac\xdd\xbfz\x00=R\xffT\xdd\xbf\xc0&v_\xd9\x0b\xf6?\x03\xf9\x16\x88R\xdd\xf9\xbf\xe2/\xafG59\xf4\xbf~;\xdf\x10"_\xd4?\x96\xf6\xd2]\xcf\x89\xf0\xbf\xdcy\xff{/\xe8\xf5?{\x9d\xa4?\xcdp\xe2?N\xd8#\xb1\x8b\x91\xc7?\xd7\xaf18\x89\xcc\xcd?&\x1b\xda\x9cz\xbc\xea?e\xb4\x95|\x8c_\xdc\xbf\xd5\x17-\x00\xaa\xc6\xf8?i\xf8PO\xc0l\xd4\xbf\x90D\xfc\xe7?s\xe5\xbf\xf8\xf1\x99(d\xbe\x04\xc0\xec\xfd\xe4\xbe\x87-\xe8\xbf\x9d8\xc7&N\x1c\xd1\xbf\x9a\xfe}\xd7\xc2\xd2\xe4\xbf\x97\xd7k\xb6\x8bY\xd3?\xcd\xbb\xa8g-w\xb5\xbf\\\xf7S\xce^_\x00@^\x05c\x9co?\xed\xbf\xea\x95\x05\xa5\x1c\xff\xda\xbf\xaa\xc7\xeb\x7f\xbd\xf3\xe0?\xfde\x1a\x9b\x82\xb8\xea\xbf\xd1\xccw\xe3\x9a\t\xe2?$\xc3\xa2\x02h\x88\xda\xbfX\xb2\x9b\xce\xdfI\xe0\xbfuhfo/\xf8\xef\xbf?!\xfe\xaf\x89\x96\xe1\xbf\x903\xeeqF\xcf\xe9\xbf\xe0a\x12\xb0&\x7f\xe8\xbf\xb0\xf7\x89(\x1e\x9c\xe2\xbf\xa6\xa3\xc8yt\xb8\xed\xbf\x91\x9c\xdf<\xcc\xe0\xe5?B\x92\xe7\xa6\xb8\xa1\xd8?\xbb\xa9\xb4\x9f\x86Q\xbc\xbf\xb7\xcdrD\xa9\x01\xfb\xbf\xd5\xba)\xe3\xed\x1f\xf0\xbf.\xf88V\x1a\x1a\xe3?\x00_\xcc\x16\x11X\xe5\xbf\xf7{W8qy\x03\xc0\xfb\xd2\x0b\xd49\xb7\xc3\xbf\x0b\xcc\xbeVI\x04\xfb\xbf\x81u<\xd6*\xc3\xe5\xbfF[\xd5i>P\xb7\xbf\xe1U\x8b\xec$\xd7\xe2?\xa5\xb2\x878\xad\xad\xf6?\xa5\xe4y\x12\xbe\xd6\xee\xbf\x8b\x83O\xa3vx\xfa\xbf@\x87-\x8f\xce\x1d\xeb\xbf\xc8\x0e\x97Q\x8f\x0f\xef\xbfX\xc97\xb7>=\xf8\xbf\x17\x97u\xae@H\x96\xbfy\x00\xbb5\xd6\xb3\xfb\xbf\xfe\r7?\xfdq\n\xc0N2\xd5\x19\x8a}\xea\xbfg\xb4?K\xb6\xd3\xd6\xbf\x8c\x9d\xa62\xe3\x8f\x08\xc0\xed\x8b\xc4\xdd\xecg\x00\xc0\xbe\xee\'\x16\x18\xb1\xd8\xbf\xb3\x08\xc8\x8fZ\xc1\xe6?V\x94\xf9\xb3_\xef\xf0?\x00\x15\xd1\x87\xa1Q\xe2\xbf\xc1\x19\xf6\x9d$\x89\xeb\xbfrO\x0eb\xf6\xa9\xd7\xbf\xa3"\xed\xec\x13`\xce?\xc4\xd5\xd3^\xe3\xf2\xf1\xbf0\x88:\x87F\x00\n\xc0\xf0\xf9\x1bqN\x9d\xfc\xbf\xa7V\xf2\x80\x10\x16\xe8\xbf\xe3\xc1\x81\xf1\xedE\xec\xbf\xbc\xdb\x8a6E\x0c\xa8\xbf\x8e>\xafgD\x07\xcd?9\x03\x84\xcd\xf37\xd5?\xe5\x91\xc0~\xf8F\xd4?w\x1e\xa4GPb\xb1?KG\x02\x15%f\xc9\xbf \xeb\xc7i}\xc8\xf2\xbf|\x8a\x16\xcb\xc6\xaaz\xbf\xceg\xda\x80\xce>\xd7?\xf9\x82\xc6\xb1-\xfa\xe2\xbfY\x95\xe3\xa9\x13$\x04\xc0.=x\xdcP\xf6\xec\xbf\xc8\x16\xd4\x1c\xd7[\xfb\xbf+\xe6O6\x95g\xfe\xbf5`\x82Vj7\xfb\xbfy`\xd3Q\xe84\xf6\xbf\xe56\x06I\x04j\xf4\xbfIB\xf6G\xcf\xe7\xca?\xa6&\x93\xf9\xf5\xf5\xeb?=\xe7 7\x89\xe8\xfa?\xae6\x86\xd6\xd8\xf3\xfe\xbf\x03\xb8\x84\xb0d\x88\xe3?}T\xac\xa1\xa9,\xe8\xbf\x9b\xb4\x00,2\x1b\x04\xc0=\xa7}\t/\x8f\xf6?\x9f\x06\x97h\x97\xbb\xe6\xbf\x99\xd5p\x9d\x8c\xdd\xff\xbf\x0e\xd3\x8b\x95\x1a{\xf4\xbf\n\x1cBGL\xd7\xdc\xbfN\xdd\xfb\x16\xea\x1e\xfe\xbf\xd0\xda\xffFm/\xe9\xbf\x84\xf4\xf1\xf8k~\x02\xc0\xb8m\t\xdc\xf4\xef\xe5?\xc4"\xca9\xdd\xd5\xd5?\x19It\xddwP\xd3\xbf\x15\xfdI\xa4\x99W\xf9?)\xce\x05\xbf~Q\xe3\xbf\x9a*\x96\xec%\xd5\xf3\xbf\xce[\r\x03x\xea\xbd\xbfW\xa1\x1b\xab\x18~\xe1\xbf\x0e\x8c\xad\xef\x99_\xe3\xbf\xb3\x98*\x1fJ\x8d\x03\xc0 \x8f\xc8]L\x89\xd2\xbf\xaez1(\xaa\xba\xe2\xbf\xa2vwN\xaan\xf9?%\x16\xf6\xa7}\x04\xc9\xbf9\xa38.\x1b\xf2\xcc\xbf\x93\xb3$(\xe2\x1e\xd1\xbf\x1f:\x8d\n\x9d\xd9\xc7\xbf{V\xc0)\x82\x19\xe7\xbf\x1f\xfe\xe47l\xc9\x9a?\xbe\x84\xdf\xb6JZ\xf0?\xea\xfa\xef\xeb\x07M\xda?\x83\xef\xdb\x926&\x04\xc0\xbc\xf0\x0e\x82\x988\x02\xc0\xce5c\xf9@X\xa9\xbf\xd6x\x87ah\xbe\xce?\xb4\xbd\xd9y\xaf\x99\xe4\xbf\xde\x9b\x15\x0f\x0c\xbe\xf0\xbf\x19\xb9\xc7)\xd4\xa9\xfa\xbf\x8a\xd0&\nL\x8b\xe8\xbfK\xe0I\x16\x84\x13\xf9\xbf\x8c\xa9\xbe\xab\xbcq\xf7\xbf{GG\xca\x1f\x1a\xdf\xbf\xb7\xc5\xb2\xae\x08\x8f\xe4\xbf$\xd9?\xed\x1d\x15\xf2\xbf;\x0f6Z\xfe\x16\x04\xc0\xd4+@\xb7\xbe\xae\xfb\xbf\xce\xe9\xd0\xa5\xdf\x84\xdc?\x02\xe9\xb8\xff\x0f\xa7\xf0\xbf U\xff\xe2o\xb6\xf6\xbf\xea\x0fb/\xaf\xad\xf4\xbf\xb6U\xef\x96\xa9\xb8\xf5?T\x08&\x8d\x1f\xe1\xef\xbf\x8b\x9b:L\x91\r\x83\xbf1r\x11\xfc\xee[\xf4\xbf\x81\x90\xc6\x9f:\xcf\xd6?\xa8n\xd8\x95\xe5h\xef\xbf\xb2>a-2E\xf5\xbf\xbd\xdfF\xee\r\x14\x01@\x1f\xd7\xfa\xf7{\x8d\xf7\xbf\x95\x86"3\xe0}\xe0?\x9c1v\xdf\xc1\xea\xfb\xbfq\x18\xb5;\xb2\xc5\xc1?$\xe6\x05\xff\xe7e\xf2\xbf\x99\xde\xa0\xeb\x9aa\xfc\xbf\xe9\x18Q\xecJ\xdb\xe1\xbf\x93\xc25>\x16\xca\x01\xc0\x91\xe8B\x90T\xb3\xc2?\xb8\xaf!"\x1f\xb2\xd6?\x86%h\xa5\xb1J\xeb\xbf\x99\xefzv\x18<\xf5\xbfc\xa6\xc0z\x94\xc4\xf7\xbfV\xe4P\xafyg\xb6\xbf\xf3\xf7\xd6`\x85\xc8\xfc\xbfk\xc5a\x9b\x04\x03\xc4?\x03^\xcbW\xd1\xcb\xf1\xbf\x10\xff }5}\xc7\xbf\xe0,N\xf9r\xbe\xc3\xbf\xbb\x10Q"\xe5\xad\xf1?:\x8aA\x99\x92\xf4\xdb\xbfd-QY^}\x8b?7\x1e&U\xe5\xf9\xeb?\x16\xd2<\xd6\xca\x94\xdf?UC\xb9\x89\x06\x86\xe5?n\x00~\xec\xb6X\xe2\xbfl\x08\x04Xv\xf1\xc9?\x9d\xed\xc41d\x15\xf3\xbf\xf8\xe8\xe6\xe4V`\x00@\x0e\xafLV\xa7\xbd\xf1?C\xba?\xa1\xaa(\xf8?\xc1m\xad\xb8\xfd\xdf\xd2\xbf\x16\x1b\xabvu\xbb\xf4?5\x06\xd85P\x10\xf5\xbf\xde\xfe\xc9\xfe\xfa\xc8\xfd\xbf!+A!\x1e\xa8\xf7\xbf\x9e-\xf6\xde\xcf\xa5\xfd\xbf\xb0K\xb2V^\xe6\xfb\xbf\\\xc0?L\xc6/\x05\xc0\xbeb0\x9d\xb3X\xdf\xbf\x0c\xbe,k\xba$\xe7\xbf\xb4\xec\xcc\xc5\xbf\xc5\xe2\xbf\x0cv5HAY\xef\xbf\x92\xdd\'\x86\x98\x04\xf1\xbfe\x81\x96V\x80p\xd2?\x95Y\xe2v\xab\x1c\xfd?AzS\xf1\xe9\xbb\xf6?\x1b\xbe\x15p\x14\xc4\xde\xbf\xe1\x02\n\xa9\x81\x1e\xc9?\x93\xc8Db\xe5\x02\x01\xc0\xeb\x8e1\x17\x86\xaf\xdd\xbf\xb18\x9f=\xce\xb7\xed?~C\xb8\x89\xe1L\xfc?\xb9\x94$\xb4\x84\xf0\xc8?P\xe7X\xb3\x0eG\xe3?\xb0\x1c\xaeK\xd3\n\xea\xbf\x17HGx\x93\xdd\xe7?\xe1L\x82\xbe\x94\xd9\xeb?\xc8\x8b"\xac\x91x\xf3?\xa6\xce\xc5\xd9D\xb2\xc9\xbfO]4\\\xe6\xc6\xf2?\xd3\xb8$\x0b\xbcM\xda\xbf\x84\xa3\xa5He1\xc7\xbf7&\xca\xa5\xe6\x85\xe0?\xba\xbeW#\x1d\xed\xce?\xfdo/\xe2e\xe6\xd3\xbf\xee\x88\x7f\xe0\xb8\x1c\x00@h\n\x02&\xb8\xff\xf9?\xf1"\x7f\x11y\xb5\xf2?\xd6\x15\xd4\x03\x97N\x02@\xbb\xeb\xd3W\xc7\xda\x02@\xe9$3GB\xb3\x04@\x85y?\x00\x05\x08\xe2?\x12\xbf\x9b\xbcR\xcb\x00@\x9a\xda\x0c\\/\xf9\xff?\xfbdK\xb2z\x1f\xf4?\x9a\xba/\xa1\x81\xc0\xfd?\xda~_\'x{\x00\xc0\x18\x80\xf6\xea\xc7~\xf0?2 \x88\xe8\t\x82\xf3\xbf\x04\xcd\xdaj\x9f\x06\x01\xc0M\x8e\x11\xeb\x9e\xda\xf8?\xbf\xc5\xdc]S\x01\xfc?\xe8\xfb\xcf%\xfc\x87\xe6?m\x8e\x01\x82!T\xc3?(\':w\xb6O\xc9??\xadv\xa9\ni\xe8?0\xd3a\xc97t\xe7?\xf4M\x19\xbd4\x14\xf5?\x8eK\x9c\x95\xa8\xde\xf3?\xa6\xe8\x15\xf9E \xbb?.\x92\x01C\xcbT\xf5?\x82\x8aj\x90\'\xa7\xe0?:\xca\xee\x9dh{\xfb?\xf9uO\'\x99\xae\x03@\r\x04}\xd9\x0cL\x00@\xe1"\xc8-]k\xe2\xbf83Xil\x94\xfe?\xd2\xae\xe6\xd9\xef\xef\xd3\xbf\xcf\x02\x9bS\x1e\xbd\xf9?\xd7qqsq>\x82?c\xe0\xf7\xf4\xfdQ\xcc?\xfa\xd2\xc9\x98\xd5W\xeb?K\xb9\xb37\x90\xc7\x01\xc023#(C\x9c\xea?\xcd\xee\xb7\x98\xb4S\xe4?\x8c]\x8a\xd8\xca\x13\xeb?\xbb\x04\xb5\xea\xa6z\xe9?\xdc\t\xa6\xeb\x91\x93\xe6?\x9e\xdb\xd8\xd4\xa9\xba\xd0\xbf\x96\xba8\x9a)\xc9\xc2?\xc1\xbb\xf5E\xd3\x06\xf1\xbf\xf1R\xc5\x82\xff\xb6\xf4?L\x0e\xd3\x1bY:\xe4?\xd4Zp\x8a\xfe\x83\xe4?x5\xab:\xea\xd8\xfc\xbf\xdeH\xf71\xc2\x0c\xef?\x97\xf6\xb9\xfa\x9b(\xe9?\xda\xac\xdc~\xa8y\xdb\xbf\x17rL^\x88\n\xe6?9y\xde\x8a\t;\xe7?D\n\xb6\xcb\n_\xe9\xbf\x05\xd9\x90\xac\xd8\xfa\xf7?\xfd\xc5=\xc8\xb6\xed\xb7?\x16\x8985 \xe2\xfa\xbfZXFv\r\xc5\xa7?\xe6G\xb34\xa7\xe4\xe0?\xd0\xc9\x05`<\xc2\xd2\xbf\x93\xa5\xeb\xed:t\xd8\xbfD\x02C\xe0\x8eZ\xd1?\xfe\x8aG5O\x86\xc0?\xfdG4\xbd\xc5\x8b\xc7?\xa4\x0f;\xf0\x07\xd7\xd8\xbf\xe9[\xc05\x02C\xf4?\xc3\xdb\x91O>\xd4\xcc\xbf\xb1\xee\x94b\x1e\xe5\xe4\xbf\x01mC\xd2:\x95\xf8?\x9f2\xda\t\x0c0\x84\xbf\xd9\xf7\xc9i\x15\x91\xf7\xbf\x16\x8d\xeaQ\xb1\xaa\xad\xbf7P\xd2Ad\n\xe0?\x07\xf3\xbe\xd1\x97!\xe6\xbf\x81\xa4\xbc\xca\x10\x8c\xd4\xbf\xb5\x07VV|\xea\xce\xbf\xe6(\xc7\x86\xabH\xd1?=s\xfc\xf9\xcag\xe8?5\x8e\x84\xb9\xa2?\x00\xc0\xe9x\xcb\xe2\x0cs\xdf\xbf\x8e.\xe43\x12\xe1\xdf\xbf\x04\t\xb7\x97a\xb4\xd4?\xeaE+\xd9\xdb\x93\xe3?eIz\xf4\x16M\xea?\xe0z\xb4\xe1\r\x0c\xc1?\xac\x10\xfb\x919}\xeb\xbf\x1c,\xd2\xb0\x02b\xc9\xbfT\xd4vS\\\x0e\xd1?\xb9\x8a\xce\x8e\x89=\x07\xc06\xdb\x0e\x9f\xfcg\xfb?z\xab\xd9\x8b\x9b\x15\xe4\xbf\xb9\xect\xaah\xb9\xf6\xbf\x9a5\xb5\xee\x1b\xc3\x08@\'\xf3\x1bc\xb3\xdc\xbf\xc2T=\x14-\xa5\xfb\xbfx\xb0\x0b\xcb\xe4G\xb2\xbfA\r\xb9\xe5iU\xee?\xedi\xbaw2\x12\xf9\xbf\xedl\xe6J\xb1f\xe1\xbf\xd6\xc5\x97\xc4 \xfc\xd9\xbfg\xc1\xa8\x03.\xc4\xe3\xbf\xf4!\x9a\x079o\xef\xbf\xec\xb3a1\x91\x83\xc0\xbf\xb84\xfa\xfd\x06\x9d\xe4\xbf\xb9\x91\xa4\xee>\x94\xd3?\x8fu\x13\xc1\x0f\x13\xea\xbf\xecZ\xc7\xbd\xa0\xbb\xf9?\x9b\xf1Bi\r\x7f\xe6\xbf\xb2\xefF\xf367\xd1\xbf=\xda\xbc\x86k6\xd9?\xb0\xda\xea\xab;\xf9\xc1\xbf\x02pC\xf3\x0b\x83\xe6?j\xca\xb1\x1f\x81E\xfa?\xd6\xb2\xe2\x16\xde\xad\xd0\xbf\xb4\xba\xc0\xa3\xd3l\xc4?\x02\xe2\xc8\x12\xef<\xf3?/\xd09\x03\xc0i\xfd?\xb2\x19\xbd\xf7\xa8\xac\xea?0\xa5\r\xc1kF\x96\xbfx8\xa7\x82\xed\x9e\xf2\xbf\xb8S8rZ\xd9\xd9\xbf\xfe\xc8S\xfc\x16\xbe\xe1?5\x8e<[\x08\xd6\xe6?N\x9b\x17\x8f?j\xe8?nbq\xd5\xc2\xce\xf9? \x82\x94\xe9\x1c\xeb\xe6\xbf\xc8&\xfb\xdb\xb2\\\xd7?\x1e\xe6\xb90Ns\xdc?\x9d\x88\xce4\x00\xe8\xb1?\x0b|P\x07@J\xd8\xbf\xf9\xed9\xb9H\x04\xfb\xbf\xac\xd6e\xc1v\xb2\xf5\xbf\x07\xbe\x048\xd5\xbe\xf0\xbf7\x03\x85O8$\x06\xc0\x7f\x16\x1c\x8c\xceh\xd3?\xd9\xea\x0cb\xed\xb6\xe3?\x16\x01\x04\t\x06 \x01\xc0sjH\xad\xb3K\xdd?\xcb\xbb\xcf#\t\t\xf6\xbf\xf800\x90\xac5\xf6?\x8dM\x1f?MG\xc7\xbf\xc68\xe0\xb3\xfe\xd1\xc7\xbfl+\xb9\xd2t\x91\xfc\xbf\xc1\xe6\x00\xcc:\xd6\xb6\xbfc\xa9\xff^Bm\xef?\x12Zj\xe4.+\xf9\xbfsf\x95z\xd2j\x91?c\x91\xa8\x863\xa5\xdf?\x00\x08\xb9\xcf\x85i\xf3?=D\xe1G\x91P\x08@|\x106.\xbe\xbe\xe6?-\x97#\x95\x0b\xca\xed?\x17\x91\xb9\xff.\x89\xe0\xbf\xe3\xdb\x1f)>\xd2\xf4\xbfG\xc3\xef\xf5\x1a\x9a\xed\xbf\x85\x99\xa3-\xda\xa3\xe7\xbf\xaf\x9a\xd7\xa2\x01z\xcd?L\x87\x0c\xff\x83Y\xd3?z\x8c\x90\x08\x96\x7f\xf1?\xf8\x1a\x83_\x0b\x1b\xc3\xbf\xa7\x08\xd0\x04n\xba\xd4\xbf\xb9\n\xd71\x1d\x12\xb4?\xe1\x16\xb7\x8f\xbf(\xf2?\xc2\x1c\xfc\xb8\x8f?\xff\xbf\'\xfeg"\xa7\xf8\xf8\xbf\x05\xcd\xb3\xbdl1\xe0\xbf\xf4u,US\xae\xc4\xbf~\xc3\xcf\x90\xe7t\xf5?\x12\xab\xf5\xf5y*\xf1\xbf\xbf\xe1\x1e\xe8\x8c\x80\xf1\xbf\xcf\xe1\xb2&\x1a\xc5\xef?\x9bh`\xf9/\x9b\xeb\xbf\xd5?\xa4\xf3\xe5:\xb9?\xed|\x11[\x90`\xe7?\x0c\xc3Z\x9f\x12\xbc\xa6\xbf\xbfhx\xf5d\x95\xfc?\t\x02I;\x0e\xc6\x00@5\xad\xb3`\xb7\xa7\xe3?%\x85\x1c&Qu\xf8?\x8d\x03\xca{\x93\xd6\xd2?\xa3b\x9aU\x96\xd4\xc3\xbf\xab\xe3WK\xfd\x85\xf3\xbf\xf7O|\xdf\xdaS\xeb\xbfcR\xd2\xec\xf3\x9a\xef\xbf\xaa\x80\x1el\x12\xdc\xf5\xbf_Bi\xf8V\xe5\xfe\xbf\xd2\xe2\x97jYZ\x01\xc0&\xac\x7fw\xddA\xba\xbf\xe6\xf7\xe0\xd0\xebI\xf3\xbf0q\xbdY\xa0\xfd\xe3\xbf\x86+\x0e\xb1\xa46\xfa\xbfB\xa5\xedlS1\x99\xbfMD\xa7\x10\x9b(\xdd?\x1c\xef\r\xcb\xa3\xe9\xf0\xbf\x18Z4\xd4\xb1\xaa\xe0?\x0bi?\xc6d\xfc\xe7?\x14U\xfa\xb1,\xe7\xd8\xbf\x87\xa0F\x81~\xe2\xe9\xbf\'\xb2\x1b\x13f\xd4\xb5?G\x87\x1f\x192\xcc\xde\xbfg\x15"\xfb\x1e\xc1\xf1?%\xab\xdf\xaa)\xa4\xdb?"G\xaf\xd5\xbf\xc6\xff?q(\x92\x83Z\xd5\x02@\xed/\x9b\x82\xfe\xc2\xec?`o]\xedK\xe7\xc1?\xdf\x8dq\xa7M\xfc\xfb\xbf\xe5\xec\x9a\xb1\xf1\xb8\xd3\xbf\xfe\xf9*\n\xac\x0f\xf3\xbf%}\'/d\xbd\xe0?2\xc1Y\xe6\xa9\xb0\xe7?\x97\x8cm\xa8P\x14\xea\xbfc\x9b{\xa9.\x86\x9a\xbfC\xb1)_\xff\'\x03\xc0\x8aG \xfe\xd6\x82\xe4?\x86\xa4\xc2~\xba\xcc\xe7\xbf5\xbe\x07\x8d%\x0b\xf8\xbf\xa3\\\x9e\xf6D\xdd\xe9?u\tf\'F\x00\xf5\xbf\x07< \x95\xa4\x8c\xca?\xb0,\xb2\x16\xd3\x07\xe7\xbf\xaf`\x8b\xabG\x12\xe9?\xf7\x8d\x9d\xd5\x90^\xf6\xbf\xeb\x192-\xb0\xea\xf9?;\\"\xf8\xa3o\xdc\xbf\xbf\xean\x91\x90V\xf9\xbfm\x97\xa4b\x0b\xd9\xec?mI\x07\x0e\x94\x06\xd3\xbf\n\xffa\xb3>\xe5\xe0?\xf8\x0f\xfa\x9eh\x06\xd9?\x15N3\xdd\xeaG\xec?\x7fZ\xd8\x92H:\xea\xbf\xe7\x1e\\\x03\x02\x88\x96?\x08\x99\x1fx\x91*\xe4\xbf\xd8\xc2\xd9?\x0c?\x1b\xd0\xc98\x01@$< \xaa\x8e^\xe2?n\x80e\xa6m\xbf\xe8?\xab\x84L\xfd\xb9\x1b\xfa\xbf\xdf\x0c\x17hG\x0e\xb6\xbf\xcc\x1a\x1bo\xca\xc0\xf0?\xe9\x00\xfb=\x93H\xeb\xbf\xb9T\xc9\x1f\xd1%\xc0\xbfR\xf3\xd2\x9e\xd8\x85j\xbf\x81\xa0R>k\xd5\xee\xbf\xdc[U\xd6am\xec?\x9b\xd1Mz]\x98\xf1\xbf\xd9\x8d\x06\x0f}\xcb\xff\xbf{rn0PQ\xa6?\x0f2=\xecl\xd8\x07\xc0w\xadYf\x85\xd6\xd8\xbf\xceoRw\xe7u\xfa\xbf\xe5\'\x1e\xe7_f\xe5?8L1\xb2\xbd\x10\xd8?w\x06\x8ac\x0cW\xe6\xbf\xbc\xbd\xa1\xc5\x1cw\xec\xbfl\x9b\x80_\x80E\xea\xbf\xc5)\xd3(p\x9a\xf7\xbf#X\xd0\xce^\'\xca\xbf\x0e\xa1Z\xd15\x91\xc7\xbf26\xdb\x92\x1eA\xb5?\xb4\xfeO\x02o{\x01@Z>w\x97\x8c\xa8\xe3?vwuFOc\xe3\xbfQ\xf7\x00k\x0f9\xea?\x0c\xd8\xd4\x04\xc2\x18\xe5\xbfD\x80\x94\x8fP\xd0\xe6\xbf\xd8(t^\xa9x\xfb\xbf$2/"\xa9\xe9\x02\xc0\x8f/1\x1b\xf23\xbe?m\xd7\x94\xa4\x02\xbc\xea?\x89o\xd20\xb0\xce\xe5\xbf,\xe6\x893\x9d\x97\xdd\xbf\xa0X\xecN\xb7p\xe8\xbf\x05\x8a\x84\x04\xa7:\xa0?\n\xfa\x04ibU]\xbfS]\x94A\xa6g\xe7?\xd7\xfd\xdb+\xcd"\xef\xbfa<\xc1\xc84\xcf\xe2\xbf\x02\x8f\xb0\xb1*\x11\xe4?\xd0\x0c\xf7J\xc6\x8d\xda?1-\xa0\xd6\xcc)\xcf?^\x14\xdaGA\x07\xd5\xbf\x1a\x85\xb5w,z\xeb?/\xae*\x1c\x02\x97\xe7\xbf\xb7\xef\xc79\xed{\x04\xc0\xb5\xefm\xe3\xfav\xd2?w\x96.#\xaa\x0e\xfa\xbf\xe4\xd8\xc2\xeba\x9b\xc6?\x00:\xaf\xce\x00Z\xf7?=Z\x9b\xcb.>\xcf?\x95\x04l\xb4\x15\x02\xe4?\xac\xe8\xbd\xd6\x0c\x9a\xb8\xbf\xb5W\xd6V9f\xfe\xbf\xc6\xc4\x95\xc5\xcec\xec?\xc9\xb7\x03\xf9w\xe4\xc6\xbfRn\xf4J#\xe8\x05\xc0\r9\xf1\xc1\x82\xaa\xf2?\xcc\xc5\xda\x0c\r\xc3\xe6\xbf;\xca\xbd\x8c\xd0\xde\xe7\xbf\xaaB\xfc\x894\n\xff?\xddGE_?\x0e\xf6\xbf\x1b,\xa4\xe1\xa2\x0f\xf4\xbft\x83\\\xc6MD\xe2\xbfaA\x17\xd6J\xf9\xf1?=\x12\x13Jh\xc6\xc6\xbf\x1e\x8ed \xc4\x9d\xed?Xi8,\xc20\xb9\xbf6\x0bz \n\x8c\xfd?\xb1%4JM\xf8\xde?\x92\xae2\xd5\x80a\xce\xbf \xeag\x10\x19\xf4\xf1\xbf<1\x07d\xb9\x83\x00@\xfc\x10\xb8_Pz\xf8\xbfd\x1a\x02?\xeeI\xeb\xbf\xac<\xd9?_]\xcd?t\xf4\xc2\x07\x9e\x12\xf1?V\x08o\xfd\x13?\xb1?\xbbg\xca\xf6\xb2\x8a\xc2?z\x82\xe0\xcf\x7f\x13\xe4\xbf\xb9\\`c^\xe6\xd6\xbf\xa7\xdf\x9d\x07\xa7_\xf1\xbf\x92\xd0c2\x1c\xf0\xd5\xbf\xd5\x0f|\x07\x1b\x0f\x01@\xe7\xfa\x1c\x0f~\xfc\xfd\xbf\x00\x8c\xb3y\xacP\xd3?\xf16s/\xb4\xb3\xf1\xbf\xbe\xc0\x7f4\xf2\xce\x02\xc0\xcb\x83\xa8\x1bnB\xda?!s\xa2\x03b\xc3\xed?%\xe4\xb7\x80\xb0\xfa\x03@\x8e\xba\x9b\x92F\xb2\xd6?\xbe\xfc\xc1S\xdf\x98\xa0\xbf\xc6\xeeS\\\xc52\xd6?E\xcfNG\'\xf5\xcc?\xdf"K3\x99\xa0\xea?\xb3\xfe\t\x93\xb5\xaa\xb7\xbf\xc2\xcb\xb4&b \xd7\xbf\xaf\x1e\x0f\n\xc1\x9f\xf6?\x0b\xbe\xd4yc\x82\xf6?8\xe6\x85O]\xb2\xf8?a\x84\x03\xd2\xc6\xa3\xe5?\xc3(\xde\x8f\x82S\xe1\xbf\xd5\\\x12\xed,\x05\xb9?ma\xd0odY\xd8?\x8av\xed\xcc\xdc\x9d\xc5\xbfw\xc8\xe9/\\\xe6\xf1\xbf\xfb\x8e*3.\x06\xed?\x7f\x05\x1e\xd5Lb\xf7?9\xfe\xdf\xb3\xe7\xa3\xce\xbfXo\x1a\xd7\x80\xd2\xf9\xbf\xfd\x89\xd6o\x1d;\xb0?\t\xa9*\xa8\x9a]\xb7?\x85l\xcd\x13\xb0(\xef\xbf\xa2\x1b\x9a\xbfi\x14\xeb\xbf\x8a\xa1\x10mc.\xdf?^y0\xcb\xc4\xb6\xee\xbf\xf0L\xfa\xa8\xc8\xeb\xf1\xbfbga\xd3\xf9^\xc7\xbf\x80\x85=\xdenj\xed\xbfC\x89y\xc0\xbew\xc2?\xd4\x1dO1\x98{\xd3?\x9aG\xbc9\x11\xd5\xe6\xbf\x15\xde\xc9\xca7\x07\xad?u\x1eAS\xf5\xe0\xbe\xbffU\x12(\xa3\xe4\xd7?\x08\x8b\xa2dr\x18\xc8?\x18\x91\x85e\xb3o\x01\xc0\x13\xcf\x862\xa8\x15\xe3\xbf7\xf8\xe8,}\xfb\xf1?^8\x86\xa2\x06\xda\xe4\xbf\x92\x00b\xe2\xef\xb1\xbe?f\x8f\xc6\xab\tw\xf8?r\x88\xc82\xec\xef\xde\xbf\xb5\xe8E\x81\x12\xa0\xce\xbf\xac9W\x91;|\xf8\xbfbdX\'}\xca\xf5?\xb1s\x9b[\xfd8\xe5?\x1e\xa3\x98C\x187\xf2\xbf\xd7\x9d\x81\xa6\xc1\x9b\xeb\xbfE\x03\x16\xcdg\x18\xf2\xbf\xdd\xbc!\x0e\x99j\xc5\xbf\x80\x02Qov\xff\xec\xbf\x95.\x9dKlC\xf3?T\xbd\xc5B\xaew\xdc\xbf\x84\x08\x98\x93\xeeG\x05\xc0\xd6\xd9\x88(\x14\xfc\xf8?\x17\xa8\x9ea\xc6\xb1\xfd\xbf\x1b\xbfo\x9fU\x84\xa7?G\x1b\x8ex\xd3\xec\xa7\xbf\xe8\xba\x88\xbed{\xf0\xbf\x88\xd0%_\xcc\x91\xc0?\x8a^p*\x1d\xb1\x00\xc0?[\xf2\xa2\xe7\x88\xff?\x85\x12\x06b\x87N\xf5\xbf\t\xb5\x8ft\xd22\xfc?H\xf0\xca\x18\x03z\xf5\xbf\xb8h\xb0\x84-\xf2\xd8\xbf\x7fU\t\xf9\x81\'\xe8?8\x7f=\n\x98\xcb\xf8?8\r\x9c,\x1b\xb9\xf8?\xf1\xf9\xab\xce\xcf\x96\xd3?\x9e\xa0\xbcy\xed\xc3\xec?9H\xc9SI\xa8\xf1\xbf\x89$\xf41\xe2\xfd\xf2\xbf\xc9\x19o,2\xff\xf1\xbf\xddc\x1f\x93\x17\x0b\xea?\xb6\x02\x84\x85\x15}\xe3\xbf\xb9\x06\xd8KQY\xdd?\xe7\xaay\xc4\x90C\xcf?\xe57{\xec\x04\\\xb4\xbf\x81\xd0\xe2\x01\xf7s\xf9?B\x1e\xc3\x954\x87\xe1?\xe8\x00!\xcak(\xe3\xbf\x19\xa1ABw?\xdd?\xb2\x12i\xabB\x08\xcb?\xa7Y\xbcg\x9f\xe7\xe7\xbf\x07\xfb\xff\xc4}\x97\xe7\xbfn \x0cjm.\xf1\xbf\'\xc2\xf6b~\x10\xe3\xbf\xaf#7\x16\x0f\xb0\xf2?\xb5\x11AJ\x0c\xae\x00@d\xc6LGuv\xed?D\xe3\xa2\xf7v\x0f\xbb\xbf\xac\xba\xc4\xe6s\xfc\xfc\xbf\x8a=\x82\xe9\x1e_\xab?\x15\x9b\xfe\xfb7\xc8\xd9\xbf\x82\x92\xd7\xf6Q3\xea?89\xf3\xbfv\x14\xd9\xbf\x17\xf1\xa8l\x13/\xf3?w`6\xa1\xb1\x17\xe2?\xa2\xd2.\xb3\xa4k\xd4\xbf\x95\x04b\xb9p\x19\xbe?\xfc\x1b\xd0\xc5\xfd\xcd\xf7?~,%T\x8e;\xd9?\x03\r\xd5\r\xd1\xa1\xa0?W\xf1\xd4W,B\xbd\xbf\r\x82\x12/\x9d\xe0\xe6?\t\xf0\x12\x94\xea\x11\xea\xbf\x19:\xd7\x1a\xfdn\xd2\xbf\xc7\xeb\xe9\xb9\xe6z\xb2?-\xb1\x08\x9a\xac\xb4\xf9?\xb0\x13\x93J\xd4\xd3\xfd?\x0b\x91Ez!2\xf0\xbf,\x0e.\r\xbb\x98\xb5?\xddv\xf2o\x90r\xfd\xbf9\x85Y\xaa\xf5 \xc2?\xd6\xe7~\xe9\x04B\xd4?\xbc\xa8HR\xf4\xb7\xdb?\xd2\x9fh>\xa5\xaa\xf5?\xeeF]\x97\x088\xdf\xbf\xd5\xb8\xc8\x0c6\x14\x92?\xe3\xf3+\xa2\xc7\t\xeb?\xc0\x81\xde\x01\xbbN\xe3\xbfp\xb7u\x8d\xefZ\xde\xbf\xb1E\xaf\x1en\xbf\xd5?3\x800\xc2\x1c\xd9\x00\xc0\x83-\x83\xe5\xcaV\xf3?\x8d\x82\xf6{\x9b*\xdd\xbf\xa6?\x92\xdc\xa4<\xd6\xbf\x08_1\xadSY\xe1\xbf\xed\r\xc4 \x9a\xfe\xed\xbf\t{\x0e(\xde\'\xe4\xbff\xc1pq8\xa4\xf2?\xed\xa1!R\xa6W\xe3\xbf\xaf\x1b\xa7\xa8\xe0\xfd\xf6\xbf\xf2\\u\x17\x9a\x01\xa8\xbf\xe4\x91i0\xf93\xca?\xf4\x0be\xf7T\xfb\x01\xc0\xcc[\x13\x92\x8aI\xc6\xbf\xda\x82r\xbd\x08\xb9\xfd\xbfh\xac\x97_\x81\xa1\xe2?S\x1c\x91\xf7\xd7\x05\xeb?\xc8\xd8B^\x18\xe5\x88\xbf\xe2\x06\xd4\x13\xacW\xf4?\x01\x9f\x8c\xf9\x10\x88\xed?Y\xd9\xbeX\xaa\x8b\xfa?\xa6\xf0w\x81\xb4/\xf5?\x99\x14S\x96$\xb1\xf0\xbf\xa1\x0f\x7fUn\x8f\xf4\xbf)\x01\xc6O\xe7(\xcb\xbf\xbe\xe8\x02A?k\xd1?Wl\xadQ}g\xef\xbf\xa4s9\xc2\x15\x0c\xd9?";\xd2\xd1\xc2\xb4\xdb\xbf\x00O6\xf4\xa4\xbb\xfb\xbf\x03kj\x0b*\xf3\xcb\xbf\xb9\xb0\xb9\xaa\xc5\xff\xc6?\xbf\xae\xb0W\xf8u\xe5?\xf0D\xdap\x7f\xe4\xe4?\x9e\xbaO[\xe8\xee\xec\xbfI\xdd\xe92\xc2\r\xc9\xbfI\x90A\xb2\xce\t\xcc\xbfuP\xcb\x9d\xe5\x1b\xee\xbfc >H[\x10\xf6\xbf\x86X^gIZ\xd6\xbfX\x95\x98\xdf\x03\x9e\xd6\xbf\xa4\x83\x94B\xb9\xbf\x04\xc0\'>a\xc1T\xea\x03\xc0\xfb\x8a\xfa\xaf5}\xf7\xbf\xdc\xbeo\xa9\xc3\xcc\xf0\xbf%\xfe\xa9m\xfb\xc0\xcb\xbf$\xe5\xf09\xda\x14\xe5\xbf@9"O\x8b\x04\xf3?\xac\xe9\xaa\xe7a#\x07@\xc7\x87@\xea\xa3\xdf\xf8\xbf\x98\x8ed]\x12\xd5\xc8\xbf\x1f\x90\x9e\x8e\x0e\xd1\xfe?y\n3\xb0j\xb6\xcd?\x1a\xde\x16YJ\xf8\xb0\xbf\xb6M\xf9Ti\xc2\xcb\xbf\xc8\x93F\x87\xe8d\xac?\xf7\x9b\x1b{\xb8\xf9\xe8\xbfX\xda\'\xea\x98\x00\xf1\xbf\x844\xc4\xa1\xfc\xd9\xf7?-\xcd\xdfX\xac\xe8\xc7\xbf\xd2\xc5/\xfcl\xe1\xe9?\xdfC\x82\xeb!-\xf7\xbf\xfc\xca\x1e\x06!P\xf1?\xccr\xc7\x9f\x12\xad\xe2?\xde\xe6\x83\xbb\xe4\x88\xee?w\x8b\xe3/\xd4\x07\x0b\xbf\x83Ox\xde\x08\x8a\xe5\xbfuW\x91\x85\ta\xf3\xbf\xad\x8c\xae}g\xf3\xe6\xbf\xc6\x8b?8S\x8a\xde?\x0bsn\x18\x8d\x07\xd0?\xe0\xe5\x1ex\x80\xae\xfd?\xd0a\xce\xecO\x00\xec?>\x15\xc1*\xc0;\xe4\xbf\xc8\x03+uw\x96\x03@\xee\xde\x1dS\xed\x95\xf7\xbf\x02\x83\xc1l\xc06\xca?\x13\xd9\xf5B@G\xc2\xbf\x03\x1fV\xe5\xe4\xe2\xd5\xbf\x7f\x0f\xcd\xdb(\xa0\xd4?\x8f\xc2Q\xa7\xd9\xea\xf2?\xbe\xfa\xcfw~\xee\xc0?z\xfd\x10\x813\x12\xf4\xbfA\x03V\xf4\xee,\xde\xbf=\xe3t|\xc26\xd9?\x1cP\xdaz\x9az\xd0?N\x8a G\x82%\xf2\xbfV\x9e\xdan[^\xbc\xbf\xc4\xe2Y\xb9\x9b\xa1\xc0?\xd1\xbc\x93\x10\x1aN\xea\xbfW\x82\x8e\x9eX~\xba?\r\x80~\x9eN\x98\xe9?E}\xbe\xa3\xe3\xf1\xe3\xbf\x9d\xd0/0\xd6)\xeb\xbf(\xa6g\\`\x7f\xe8\xbf\x83\xdav4\xa8L\xe3\xbf\x81\xdb\xdc\x08\xbbx\xf1\xbf\xab8x\xdby7\xe9\xbf\xdc\x17\xb5\x0f@\xb8\xf1?\xfb\x07a\xdf\x02\xcb\xe1\xbf\xcb\xde\xdf2U\x97\xda?\xb5oOQu\x00\xee?\\\xe2<0Y`\xfb?\xe0\x00v\x0b+\xb2\xc6?\xc6\x12we\x9c\xa1\xf0?\x90<\xefR`$\xd9?\xd8\x10B\xe6x:\x03@e\xa63\x0e\x15g\xf5?\x00\x16\x16^\x84\x19\xe0\xbf\x91\'\x99M\xd1\xbc\xee\xbf*\xbf\xc2\xcd\xa3\x83\xe4\xbfxbc\xa6\xc2\x9d\xfa?\xc7\xc7E\tGA\xf2\xbf\x893\xffYzw\xee?\x96T\x00B\xfa\xbf\xeb?\xbf\x11\xda\x91\xc3\x02\x98?T\xa3\x12m?\x14\xec\xbf\x02\xe5/\xd4\xe0\x0f\xed\xbf\x93\xa9n\x1ck\x81\xfb\xbf\xa9\x03\xeb\x98L_\xeb\xbf\xa4\xd4\xbd\xc5\xc8\xc6\xd6\xbf\xf6c^}ND\xd0\xbf.\x06\x81\x80\xde\x15\xf8\xbf\xc5;\x90\xe1\xb4\xbe\xf3\xbf\x88\xf8\xef\xaa\x11l\x91?|~js\x9b\xe3\xf6?\xfc\x93\xc2\xfcfG\xe1?\xfa\xd0l\x93\xd6\x03\xfa?\xe8_\xee\xff\x92\x9e\xf1\xbf\xd7\xa9\r^%\xfa\x00@\x9e\xad\x87q\xc6w\xc7\xbf^\xaa\xfc\xbe\xc4[\xe5?\x9d\xb4\xa1\x04DI\xf3\xbf.\x1e\x9b/\x9b\x8c\xd5\xbf\x81\xe0\xba\x90M\x1b\xe9\xbf\xd9\x98(\x03\xc4\xa5\xd2\xbf\xed;|\n\xd3\xcd|\xbf\x19\x12\xc0\x95\xbb\xc6\xd3\xbf]k\xe3\xfc\xa9H\xee?\xdb?MbSD\xe4?f[\x15\xbb\xc1\xf3\xd3?\xe2i\xad\x94\xa0/\xe8\xbf\xfe\xd8\xd1\xe8\xa3\x8e\xdd\xbf#\x89\xb9l\x9e\x9c\xe9?\x13%\xd2\xdf\xa0[\xf4\xbf\xd8\xd5\xbdV\x1c\xf8\xf0\xbf\x978\xf7\xf8\x98\\\xec\xbf\x03\x1f\xbfb*\t\xd8?\xeeH]0\xe7q\xf6\xbfK\x13\x02\xdb|R\x06\xc0\x95\x1a\x1c\xc5\xda\xe2\xe6\xbf\x84\x9fi\xac\x0f,\xe9?\xef\xbd\xa7\xe6\xec\x8b\xf6\xbfZ\xbc\x94\x06\xf3X\xdc?\x94\xbd\x8b\x99\xa8\xa1\xe9\xbfR.rPg\xbd\xfb?\xfd\x18G.{1\xe1\xbf\xfd`\x1b\xcaiT\xaa?\x8e\x9d\t\xc0\xff\xfa\xd7?\x92\xab\xbbF\xfc\x87\xdb?\xeb\x94\x8f\x91\xb2\xad\xf5\xbf\x97\x9d\x0b\xdd\xa2j\xea?\xf5\xddC\x7f\x1c\xb2\xf3\xbf\x85\x02h\xa2\x8f\xf4\xd7?\xd1Y\xb85o2\xff?>\x8c\xab\x1f\xdc\xa1\xe3?I\x93\xa9\xd2\xfc\xc0\xa9?%\x9f\x03\x05\x1f\xdf\xcb\xbf\x1f\xfc\xf9\xa4\xd2t\x96\xbfS\xedM+\x1f|\xe4?\x1bw\xbc\xfb\x03m\xf3?\xd5\xb0.\xf2k\xcf\xf5?\xd0\xec\xa9R[\x95\xdb?\xbd\xb48\xa7\xa3\x1f\xf1\xbf\xfa\xc1(\x10\x90\t\xbc?\xe5\xad\xfe\xe1\xf6\x0c\xe2\xbf\xc9r"\x99\tV\xd0?\xb3q{\r\xa3\x96\xb0\xbf=vc\xfa\x06\xbb\xe2\xbf{!V\xa1\n\xb5\xe4\xbfMZ\xecR[>\xb2?o\xebd\xbf\x91\xbc\xf2\xbf\x1c\x15\xb5\xc7\x9a<\xef?\xe0\x8d\xa1\xdb\xbca\xf2?\x9a\xc19\xa95-\xd7?:\x13\x9f\xd7\xd9\n\xc2?\x16\xa9#\xda\x92\xb0\xe5\xbfK\xcc\xe1\x8b\xa8G\xe0?\xf1\xc5\x9b\xbc\xa7D\xfd?QG\x9bV\x9a\xcc\xc4?]\x12\xc2\xd6g\x99\xcd\xbf W\xbd\xb2\x0bG\x05\xc0W\xfe\xbc\x11\xcf\xc3\xf6\xbfG\xde\x87bf3\x90\xbfzW@\x91\xcd\xfc\x94?\xc5\xf3\xde\xc8\xfen\xe1\xbf\xf0\xd2\xaa\x9a\xd3\xc9\xc8\xbf2\x9eb\x93m\x16\xf2\xbf(_&|T\xc4\xe5?\x84\xb1\xf7Ghf\xda\xbf\xe5\x04\x80\x02\x8d\x1a\xec\xbfL\xeaX\xceA\xea\xb8?\x0cT\xa4\x95X\x96\xf4\xbfw#\xc7\xa8\xa7\x1d\xf5\xbf\x87xeL\xd1\xe7\xd1?\x8f\xcf\xa4\x04\x7fz\xdb\xbfae\xcf\xca\x02\xb4\x0c@v;\x1anAt\xf0\xbf\xc8\x1bi\xd7\x82\xc9\xf0?03V\xf8\xa0\x96\xde\xbf@\xcc>5\xa5\xeb\xe5\xbf@\x18\xccVm~\xbb\xbf\x8b\xf0W\xf9\xc3\x91\xd4?\n\x88\xf1\x90\x1be\xf3?\xb1\xb9\x86G;\xcc\xd9?\xa2\xb7\xec\xc8\xb3\x81\xdb?\xf0\x12v\xea\xfe\xd8\xee?\x94\x10\x11\x06q\x0f\xd6?\xb5DV\xf5\xa1\r\xd5\xbf2\xe2\xf3\xe9s\x86\xc2?\xc0X\xc2\xeb)\xee\xd2\xbfqk(Zr\xe5\xf7\xbf\x86g.\x06\xae\xd2\xb7\xbfUC"\xbf\x87_\xf3?\x7f\x197\x17^\x11\xac\xbf\xc8:\xf0\xed\x98!\xef?\x1f\x8f\xfa\x84F\x04\xe9\xbf\xf2\x86^\xa0\xff\xf7\xf6?\x8f\xd0_0\xa7Z\xd5?\x8cg6\x9d\xc1\x13\xe8\xbf\x7f\xc1\xdd\x9d\xbe\xad\xf0?\x16i&\xeb\xf8\xa5\xff?\xba\xe0\xe1/\x1d\xfb\xf2\xbf\xb4\xfc\xf6\x14(\x0c\xf0?\xb2\x9e\x91\x0fP\x03\xf0?\xac\xca*\x8d\xd9\xb4\xe1\xbfM\x8b,]VH\xc6?\xe5\x93\xab\xbb\xec\x0c\xe1?2\xcc\xd0\xb4U1\xe6\xbf\xcf&\xbb\xcf\x9e$\xab?3\x1cM\xc5\x9d\xe9\xea\xbfj\x9e\x10\x1a\x16|\xcf\xbfq,b]\xb8\xa2\xe5?\xb0Vp\xd1\x98p\xda?\xdf\x82\xdfu\xdb!\xf0\xbf\xd8.\xf6\xda$J\xdc?\xd8\x07 \x97d(\xf1?#\xc9\x9fp\\\xe2\xd5\xbf\xcb\xb7$\xa7\xbc\x08\xe9?0!\x817\x86\x08\xe8\xbf\xe3E\xdekU\x82\xd5\xbf\x8fEEyi\xe2\xe6\xbf\xf8c2\xfdy\x0b\xd0\xbffv\xd6\xfeU\x87\xea\xbf\xaf+\x81\xc7o/\xf9\xbf\xabh\x95"v\x13\xeb?5!\xf2%\'^\xfa?^\xef;\xa7\xde\xf2\xe7?\xb9\x14\xeb\x86\x8d\x1e\xd9\xbf\xe5\xcf\x95+\xdb>\xee\xbf\xe0v\x13\x8e_\x07\xc5?\xb2F+%\x9d\xa2\xf1\xbf\x0e\x01\xe3G\xf3\r\xfd?\xafT\xc5\xa9U\xa5\xe3\xbf\xce\xb86\xcd\xbe@\xdc\xbf\x015{\x948\xb9\xad?!\xce\x1ar\x9d\xf5\x92\xbf\x93\x93\x85v^t\xe4\xbf\x10\x81\x92Y\xb6A\xf5?\xe2eG\n\x7f\x8d?\xb1\x9995\xa9\xa1\x00\xc0\x91\xf6%3k\x07\xc2?\'F\xa4}K)\xf5\xbf\x04\x91\xfe\x92\xeb\x8e\xd9?\x8d\x10\xe1\xe8f2\xf2\xbf\x8a\xdcC\xcfg\x18\xe0?\r\x8ey\xfe\xef\x05\xd7?\xd9\x98xs\x96|\xd2\xbfeE\x0b\xb1\xcfH\xd7?\xedV\x90\x80\xceI\xf4\xbf$\xd6\xe4\xe7\x1d\xed\xd1\xbf\xecp\xdcai\x9e\xe6?\\\xdd\x0bR\xad%\xed?5:\xb6no\xb5\xf2?\'Ch\xed\x1a\xa3\xcc\xbf\xc4O\x83\x0c\x00\xa0\xe7\xbf\xdf/\xafR\xb7K\xdc?\xe5y\x10\xf5\xe25\xe7?\\4\xe3\xc8eX\xf3\xbfL\x10\x9f\xf7\xa6\x00\xec\xbf=\xe8\x07\xbb\xbb\x97\xc6\xbf{`s\xaaU\xe5\xe7\xbf\x0b\xee\xe1\xe4C#\xf7\xbf\x8f\xb0\xd4\xa6)\x98\xf5?\x85\xc5\xbf\x02\x1d\x94\xe9\xbf\x1dD&u\x92\x0e\xce?\x15\xc8D7?\xf2\x01\xc0\x8d\xf0\xb4\xdc\xdf\x94\x02\xc0\x1f\xfc\x87\xff\x03\x07\xea\xbf\xdb6\x89X\xf6\xbd\xeb?WMx\xcdL\xf7\xc3\xbf\xe1\xb6\x13\xe6\x14A\x03\xc0\xb3m\x0e\xa9\xddd\xf6\xbf\x8f\xb7D\xa0.\x82\xf2\xbf@*\xf7if}\xf8\xbf\x04\xd6\xdaF\xcfv\xf9\xbf\xbd\xd1\xab\xdbK!\xb9\xbf\x96\xed\xa0\xd8U\xa8\xee\xbf\x12\x13\x9d!)~\xe1\xbf3\x07\x86\x11\xabA\xfa?\x03`2;\xd6\xa4\x81?P\xa3\xba\x1a!\xef\x9c\xbf\xc1\xfd\x14\x067\t\x01\xc0\xdd\xba\xa7\x15=g\xf0?s\xd1\x12\xa4\x9e\x84\xfb?D@,\x00\x88=\xc6\xbfb\x91\xdaC:\xf2\xc6\xbf\x82\xb2#\xd8\xf0\x9c\xc1\xbf\x97\x9e"\xda/\xd2\xc7\xbfC88\xe9\x86b\xd5\xbf)\xaf"14\x12\xef\xbf+\x1b\xf9\x8cY\xa9\xf0\xbf\xccJ\xfe\n\x04a\xd1\xbf\xbeY\xfe\xf9\x80\x00\x00\xc0\x129\xc9\xf48\xac\xe2?\xe1a?\xf8\xc2\xd6\x04\xc0\xb2\x18p\xb5<\x0b\xf5\xbf\xc3~g\x0b\x8a\xf4\x01\xc0\x8f\xfd\xc6/\x16\xd6\x01@\xb0\xe6\x85s^\xbd\xed\xbfe\xd0U\xc8E\xa2\xf0\xbf\xf0Y\xe4\xc7~\xb3\xf0?\xc7\x88s\xc6\x01\xf2\xfa?\\\xffW \x13?\xf1?o\xcc\xe9\xe5\xedl\xc5\xbfP\xff\xe6y\xd8\x85\xd4?$aD\xea\n\x06\xc7?T\xeb\xa6\x18\xf7\xfb\xdf\xbf\xbd\xb6\x17\x16\xdb\xf1\xec?\x829H\xb3;\xda\xf9?5\xfb\xa1\xf9\xe6[\xfa?\xeab\x90\xd0\x85_\xf5\xbfo\x93\xa2\xfa-\xfa\xed?\xff\xf6$&\x9dg\xe3\xbfm93\xb0\x059\xd8\xbf>\xa1kZ\xf3\x8f\xd5\xbfp\xc3IZI\xea\xf0\xbfj\xec\xec0\x06\xe6\xf4\xbfw|\xac\xa5\xab\xf0\xd7\xbf\xa2\x87$\x01\xef\xf2\xf0\xbf\xc2c\xe4\xab\xee\xa2\xf5\xbf (\x15\xf3\x0b\x96\xf5?z\xd9\xf0\x03\xef\xe2\xb1?\xa8\x8c}z\xb8 \xf4\xbf\xaep\xe05\tJ\xe3\xbfw\'fXzY\xed\xbfr=v\xc1\tf\xea\xbf\xdb7\xfc\xe0\x11H\xdd\xbf\xc2\x97\x1f\n\x19\xf2\x03\xc0\xdaS\x95x\x1f\x03\x82?bN\x1dW3~\xc6?\xa2\x85\x0e\xf6\xc3d\xed?\xfeW\x0e\xf7:R\xe9\xbfH\xf8\x98\x0e\x88\xb3\xfc\xbf\x8b\xff\x0e\x1ea\xd4\xf5\xbf\xab\xb2\x9c\xeb\x12\x8b\xfd?\xdf%>\xb7\xd9A\xd9\xbf\xd7\xc1\x01w\xb9\x0c\xe4\xbf\xa5\x02\x90\xa7\xd8U\xda\xbfZ\xfc8\xcb\xad\x9f\xf3?\xcd\xcc\xac\xfdf\x94\xf7?\x04H\xfe#\xd0\xbb\xe0?g\x9aQ\x97V^\xfd?\x1erHq\x16a\xd9?\x00\xfc\xd7\xb5\xa1\xce\xe7?7\xe2\xa9\x11\xef\xfe\xf3\xbf\x87\x17)t\xa8\x9b\xf2\xbf\x19\xd59\'\xc5\x15\xdc\xbf\x9e=Y}\x1e\n\xe9\xbf\xb7\xc2\xb1.J\xe0\xec\xbf$^\\3\'o\xad\xbf\xb4Vq\\\\d\xe9?@\xf7\x0f\xc9w<\xf5\xbf`Css,\x9a\xf4?t\xde3\xaf\xaa3\xf5\xbf\xc9\xbd\xe0\xc9P\x17\xc4\xbf\'\x01\x81\xba\xb1\x89\xe5\xbfF\x08\xdd:\x82Z\x03\xc0\x1c5"e\x0cL\xe3?\x06\xa0\x18;\xa6G\xd7?\xd8\xa7\xd8\x1b\x01\x04\xc1?\x87\xe5<\xd5L\xe0\xe4\xbf,\xe1\x12\xdf\x98\xf4\xd5\xbf\xd8\xe2\xfa\x93-\x07\xf0?\x1c{\x9c\xb8\x89S\xd3\xbf2U\x1f\xec\x91\x04\xd5\xbfG\xc9G\x06\xb2\x19\x161[\xf3?[\xfa\xaf-A\xb0\xf1?\x13\x12\x13W\xcc\x80\xef\xbf\x90%BY\x1e\x1e\xe4\xbfs\x07\xf5\xc5}\x05\xda?\x1d\x0e\xfa+\xd9}\xef?\x871\xcb\xc3\xcae\xd9?3\x1f\xdd\xf8\xec\x9c\xc5\xbf\x1b\x01\xc8\xe1 \xcb\xff?\x050\x84\x99\x8b&\xf6?7\xe3\x876,\x1d\xf0?\x94\x97F\x99\x95\x06\xd3\xbf:\x94{\xa5\xdfP\xdc?\x1c\x882\xb4\xc5=\xf9?=\x9fx4D\xb2\xf3\xbf\xae\xb1\x08\xd3\x86h\xd0\xbf\xb4\x8d\xff4?\x15\xb0\xbf\x1etE\xe5\x1f\xb0\xe4\xbf\xbc\xa5\xe0\xa18\x10\xf6?\x8c\xf9e^m\xca\xe1\xbf\xb1\xc7\xc6\xa7\xd9-\xef\xbf\xd5\xb8\xf00\x8d\xa6\xe4?\xe6\x8e\xc0\x8e^\x97\xc4?\x03\xfb\x98\xf5+0\xed\xbf\xcf\x83\n=mH\xda\xbf\xe17-\x96\x976\xdf\xbf\xc2wPg\xa3G\xe3?\xb7\x17ZZ\x95\xea\xdc?\x11\xabF\xf4\xcbg\xe3?\x1a\x1d\xa7X\xf2X\xe7?5\xb2&5\x8c\x19\xb9?E\xb7\x8fMLt\xd0?;\x8fO\xb6\x0c\x12\xc7\xbf\xbac\x97\xe4i\x02\xf9?\xc3\x15\xe0\xbe}\xe1\x00@Oo\xe5\x8f~\x19\xf0?\x9a,\xc3\x81CF\xd2?\r\x9f\x87\x98\x8c\x96\xf0?"J\x1bq\x05\xec\xe1?\xff\xfe\x17\xd3MQ\xd7\xbf\xde\x92F{\xe9K\xc5?8\x08\x03\xc3-\xea\xe8\xbfOc\xf1\xe7EB\xdb\xbf}\xb8\x1f\x97\xbf\xb6\xb9?\xd5k\xa7S\x1a\xe8\xed?#\x140\x9c\xf0C\xe7?\x1ez\x90\xe4\x82+\xf2\xbf\x81\xed\x0b\xfa\x04\xab\xe3?\xfd\xa6\xcfI\xa5T\xaf\xbf\x88\xech.\xeb\x08\xca\xbf\xe7\xc0M\xe2"x\xe2\xbfLT\x80\x1f\x87\x83\xe9?#{4\x9dW$\xac?o\x1cs\xdd\xd9\xb2\xef\xbf\xb4\xa6\x8a \xa8\xea\xbc\xbfY\x8f\xa4\x8af\x99\xd0?{\xdbX\xc1}d\xd0?\x87Z\xa1\xf4e\x02\xe6?9\x8c~\xe2\x04>\x02@5\xb2\xfd\xddF\xa3\xc5?\xbcz\xd6\xcd_R\xf2\xbf]\x184\xa2\xf7\xf5\xec?\x8d\xbc\xf7\xe9f2\x0b@+x\x17\x17\xbea\xe6?[MKQU\x01\xf7?.\xbb\xddXXb\xf1?\xb3\xe5\xcf\xa8]\x16\xb9\xbf?\x0ch\x17\x16\xee\xe6?^\xaa\x86\xc3\x14\xf2\xfa\xbfU\xd7\xde\x1f\xfa\xec\xe8?|#u\xbd\x92\x06\xea?\xca\xe6\x9c\xba\x07\x83\xea?\x0cR\x13\x0c\x80\xc0\xe7\xbfe\x88B\xfa\xadG\xe4\xbfRM\xb0\xc8\x0b\x8b\xe2?\x803\xb6$\xf0\x87\xdf?*\xaf1\xfb\xd8\x93\xe7?\xac\xdc;\xaf\xf8\xef\x87?\xb7\xc1\x01h!\xaa\xda\xbf\xc6P\xd1\xd2\x14G\xe5\xbf\x87D\x9b\xb2\x03\x17\xd9?\xfd\x08u\xe2\xe5\x82\xee?{r\xbb\x92\xc6:\xf5?\xa5\xa22\xe1B \xfe?\xf4tw\x93(\xc2\xf0?\x91\x11)\x19\xa4\xa6\x01@\x1a\xdb\xb7mLy\xe1?\xb5\xdeD\x17\x86\xed\xd6\xbf\\\xbd\x9d\x04\x86l\xf0\xbf\xf7\xefT^\xb6\xc9\xf3?\xfc\xca\xb8\xe6cb\x02@\x7f\xf5*\x9a\x1d\x9e\x02@%o\xd97\x91g\xf2?a\x15\x12qn\xc8\xe3?\x0c\x13\xd0\x91\x15\xac\xd7?\xc6\xc6\xb5U\xe4o\xd3?+\x85\xb9#Pb\xfa\xbf\xdf\xf2\xc1\xa9;\x86\xf1\xbf\xf9\x9f\x0b\xa3\xa45\xd1\xbf\x83\'\xdd\x8e\xe3\xc6\xfa\xbf\x83\xb5$\x9d!\xb0\xcf?\xd6\xce\x01\x16#\x1c\xf4\xbf\x0c\xb8v\xa9"\x98\xe8\xbfo=W\xdfI\xac\xc8\xbf\x08\x84\xed:\xe2\xc2\xf1\xbf\xb0\x0b\\T\xbd#\xe8\xbfW\xdf\x81?\xd5\xff\x97\xbf\x02\xa0\xd8\xac\xdd~\xaa\xbf\x00th\x1e/\x9f\xf1?\xae\xe6|PV{\xfb?\xc2\xd1\xffi\xf8\x88\xd2?\xbc\x9dYF\x85\xdf\xf8?wB\x80>\xaa\xa0\xf7?\xbfEzlr\xfa\xc2\xbf\xbe\x93\x9e\x1c\xdd\xc0\xed?\xdd\x87\xe0\rP\xe6\xf6\xbfe\x8dL\xeb\x1f&\x02\xc0\xf0\'\xc7\xeaF\x8f\xe8\xbf\xc6Y"\x86\xf0w\xe8\xbf\x19\x90?S\x05[\xd9?\xe8j\xf1\xa8\x04*\xb3\xbfq`c2C\xec\xe3?\xb1gZ\xb5Z\xa2\xf9?M<\x13\x82\x9e\x07\xb1\xbf\xf4m\x87F\r\xd7\xe0\xbf\xeeo\xea\x97\x81\x07\xe8\xbf[\xbcCB\x8c`\xfd\xbf9\xadd>0+\xe0?C\x9a\xe0f\xa2v\x9f?\xc8\xbf;\xe0\xc9\xe9\xc7\xbf\x0e\xed\xf9V\xac(\xf4?E\xac\xc9\xc3\xec\xf1\xf0\xbf\xdc|hFl0\xe0?\x0bWId\x81\xf8\x96?O\xd60gS\'\xfc\xbfU\xc0\xfeVp\xce\xd5?\xaa\x10\x81\xe4\xac\xc5\xb3?\x8f\xca\xc5vN\xe8\xfa?\xe0}=\xa2z\xf3\xf0?\x00\x99\xf1(\x7f\x92\xde?\x18\x8d\xe0\x03\t\x89\x05@B\xd4W\xe0\xc6\xac\xf1?\xa6\xfbj\x90\xba\x96\xf3?UN\xe7.\xf7\xce\x08\xc0\xfa_\x9cI\xb3|\x02\xc0.\x9a,\x96\x98X\xdf\xbf_\xae\xf4M\xb3\xdc\xf6?\x98\xb2\x85\xca\xcb\xd1\xfa?\xc4:\xf6[\x04\xdf\xdd?]\xaeG=\x0c[\xf4?\xce\xf3\\\xa1\xa0\x94\xef?e\xb4\xcb]u{\xdd?1St"\x8b\xa3\xf4\xbfz\x0b\x97P\xd4@\xf5\xbfI\xf0\xae\xfbQG\xf3?\xa5\xe4\x8f\xb7\xd2\xd9\x04\xc0\xaa`\xa0\xaep\x9e\xaa?\x90fu[\x0ba\xe5\xbf\x92C\xf1]\x88\x05\xe0?\xd3n\xad\xd0h{\xd5?}eR\'|\x17\xf6?\x97\xd1\xc9K\t\x9d\xce\xbf\xb2M\xeb\x01\xabb\xd4?X\x18\xca\xdb\xca\xcc\xc1\xbf\x07\x9e\xd3\x90\xe4\x0e\x05@:G\xd8\xfb\x87\xd4\xe6?\xc0\xce\x12v\xb9j\xc3?\x85`\xe3`e\xc9\xeb?S\x90\xc7<`@\xde\xbfB\x0f\xb3-2\x99\xfa\xbf\x93\xd5\xc6\xc0\xc8y\xf3?\xad\x1bQ\xf0\x8c>\xf0\xbf\xda\xbe\xed\xb9\x10\x9e\xfa\xbf\x1a\xf0-\xf91\xbc\xf0\xbf\x0b\xeaH\rq\xd0\xd2\xbf\xf4\x18}\xbd2\xfb\xc1\xbf.\x18D\x86\xb5\xde\x01@\xe9\xdf\x1e<\xf3\x8d\xba?\xaaE\xf05\x82I\xf0?\x0f\xb5\x99N\xb57\xce\xbf8\xe8\xf0\xd3\xbb\x9c\xf0\xbf\xc9\xf7\xa7\xcep\xa9\xf1\xbf\x14\x83\xcb4\x13\xf4\xd3?\x8co\nV\x1d\x19\xe9?\x95\xac\x8c,\x19:\xfd\xbfD\xba\xc5u\xa8\xb9\xc7?\xca\xbf \x0e\xae\xa1\x00\xc0H\x13R\xef\xff4\xed?\xc0\xaa.!\xf3\x8d\xff\xbf\xc4\xb6\xd2\xc7wU\xdd?\x18\xfb\xaaM\x82\xc5\xc2?\xeaf\xb5\\NH\x05@\xba\xa8\xba\xc0\xe7\xeb\xf0?\xbd\xe8"\xaf\xdew\xfa?\xae\xc1G|<\x89\xd7?\x0e\xa3\x13\xa9\x9a\xa3\xc7\xbf\x97JU3\xad\xec\xfc?\x044\x05\xbf\xf3\x93_\xbf\xf1\x0b0,+\x0e\xe4\xbf\x11\xa8H,8\xdf\x0b\xc0\xf4\xf4H\xe2\xc2\xfd\xfb\xbf%\x88x\x87\x07|\xf9?\xfd\x91\x8a:\xc0\xa5\xee?\xe5#\x05\xa6\x9a\xa4\x02@C\xfd\xb0\xd4J\xb2\xe5\xbf\x80\x88u\xc6\x13\xae\xf1?+*HP\xf1\xfa\x00@ \xdd\x0fd?\x17\xd2?\xfc\xf3\xc4\xe1\xf1\xc9\xe0?\x8fc\xde\x06A\x93\xd5?b+\xb4\x8eK\xe5\xdf?\xce\xed\xb5v\xd4\xdb\xe1\xbf\x9b\x19\xf5\xd2\xc4\xdc\xf9\xbf\x81\x0c\xf2\xf2]\x83\xfa?\xaf\xb2D\x97\x19H\xe5?N\x0bq-\xfb\x8a\xe9?\x97\ni\xf33\xf1\xda\xbfW\xfe\x93\x19I \xf1\xbf\xd5\xb3\x7f\x17\x7fc\xf6\xbf\xdb\xcd\x7fT\xe41\xca\xbf"r\xc8\xc60]\xf8\xbf\x90\'\xb8"\x82\xcc\xfa?^\xf0~\xe4\x9bm\xf6??\x86\xc7\x9b\x8e\x9b\xee?1\x03\x18\x13V\xac\xe1\xbf\xc4\xf4\x15B\xae\x95\xc9?\xdc,\x87H\xec\xdc\x01\xc01\xd3+m\xe8\xbc\x11\xc0\x9d\x1f\x0f\xbf\xdf\xe8\x01\xc0\x0f\xe9\x18\xb6We\xe7?LOq\xd7D\xf3\xcc\xbf\\\xe7]\x07\xb7o\xfa?U%\xa7\xab\xb5\xa0\xd5?\xbaX\x93+\x16\n\xd8?:\xce\xc86\xb0o\xe3?w\x0e\x13\x1d\xff\xc7\x03\xc0\x99.\xe4\xd1\xc0:\xf2\xbf\xb1\x8f\xe8\xf5(3\xf8\xbf \x93\xe1\xb3?\xde\xc8?\xcb\xe2R-L\x02\xf1\xbf\'\xb1\xcbQ\xa7n\xd5\xbf\xaaP\xb3\x90\xa7\xca\xf2\xbf\xae\x99\xce\x1b\x8c\xf3\xf0\xbf\x12\xe6\xc5km\xa7\xe9\xbfV\xdcu\xa4\xe5\xab\xce?dnO\x9b#\xcb\xf5\xbf\xd9\xf7\xc1\xf2\x83X\x00\xc0\xa0\x08\xbc\xdfS\xd7\xdf?\xc5\t\xf1\xdc\xdf\xb0\xfb\xbf\x1a9\x15\x005M\xea?T\xb0&\xc5h\x19\xf7?O\x85E~\x98\xcd\xe5\xbfD\xe9\xd7g\x8a\x0f\xad\xbf\xd1g@\x86\x19\xc6\xe5\xbf\x06a\xd3\xcb&\n\xed\xbf\xf9\x82\xac\x1f\xf9\x03\xf9\xbf\x835\xf2\x83\x97\r\xf8\xbf\x02\xb0\xb7\xdc\x9b\xe8\xf2?\xf7\x0bG\x16\xb0!\xd5?\xce&\xd5\x8b\x89\xe1\xe1\xbf\x00\xb8\x9b\x0fl\xdf\xf6?\xca\xed\xae\xf9\x1c\xd3\xf5\xbf]\xec\x16\x02:W\xf9\xbf\xec\xa8,\x87\xdb\xe6\xbb\xbfi\x01c\x84K~\xf7\xbf?+\x19\rAv\xe4?\x05x\xa2\xc6SJ\xf2\xbf\xf6\x8fF\xadsx\xe5?\x02\xc3\xc9\xd6b\xa1\xc5?T\xa3R\xf3\x1fv\xc5?\xad\xd9\xe7\xc6\xe6n\xf7\xbf\xe9\'\x82U\xa4*\xec?E6\x04S\xab(\xea?0\x1bv6\x13\x14\xea\xbf\xf2 \xbb\xc8\x96\x9e\x01\xc0t\xf1+d0Y\xf4?(\x82{^\x0b\x9d\xc1\xbf"\x97\x83\x84\xff\xce\xfb\xbfMV\xf0W\xbd\x8c\xca\xbfT\xd0I\xfa\t8\xb1\xbf\xa0\x8e#\x1eZ\x9b\xef?\xf9$J\x11\x1bU\xf1?\xc7Sv\xf6\xa6\xb2\x9f?\xee\xc2=X\x1d\xa6\x02\xc0oyTR\xe7\xda\xf2\xbflt\x8c\x9a\x8d\xda\xe1\xbfd\xeb\xb8&\x94\x10\xe1?\xde\x06 \xabf\xa8\x98?\x04\xc0\\z^\xbc\xff\xbf\xbb\x1c\x15\xf7\xc1\x02\xff\xbf\xd8M\x07-`\xf4\xf5\xbf\xd1\xb8\xf9\xe8=\x1e\xe9\xbfp!\xa2\xef\xaa\'\xea\xbfk\xa9\x99i\x02u\xf6\xbf\xe3\x08G\xcd\xe5\xfc\xf7\xbf8\x10\x8fo\x7f\xfd\xf3\xbf\x82!\x1a\xe3\xcd\x14\xeb\xbf\xf1o\x81\x99w6\xf4\xbf\xfaGs\xdb\x96W\xe4\xbf\x0e\xe5\x00\xce\x89\xc8\x02\xc0\xf5\x19\x15\x1e\x88\x05\xc9\xbf\xdf\xc1\x86c\x97`\xfc\xbf\x02\x88$\xb9\xf9\xf6\xf0\xbf\r\xa2\xb3\xc1\xc6\x0e\xf3?E\xaa\xea\x88\xc2\x0e\xd1??\x8c\xf4\x8dh)\x00\xc0\x08\xebf1\n\x96\xff\xbf)\xf3\x1ce:a\xe8\xbf\xa6~t\xde`\xbd\xe5\xbf\x9d\xf4Q\x16\xa3\xdb\xf8\xbfJ5\x10_\xfe\'\xf9\xbf8\x996\x05\x004\xe6\xbf"\xc7\xd6\x93D\xb7\xeb?Sm>yi\x16\xdb\xbfeC}\xa7\xc7M\xe9\xbfJ9\xe2\xa9|V\xcd\xbf]3\xaeQ!\\\xe2?%<\xdf{\x92\xbf\xd2?\xa5\x1b\x94!\x82"\xf1\xbfI\xf4.\x00#,\xda\xbf\xe5=\x94:\xdf\xcb\x07\xc0\xba[\xa8\x99\xdcV\x03\xc0^3\xcc\xc7\x08\xe7\xd7\xbf$X\xd1\xac/\x88\xd8\xbf\xfb\xd8x`i\xdc\xdc?\xd4\xe04\x01\xef\xb3\xf5\xbfY\xc4a=\xfb\xbe\xf5\xbf\x9eCb.\xdf\x19\xdb\xbfAy};\x08-\xde\xbf\xf8s|jV\x8d\xd1\xbf\xf9\xdbm\xf1Uo\xba?L\x8a\xb2\x08u\xf0\xe5?\t\xc1i=\t\x88\xef?5\xcf\xb8\x12\x94\xb9\x01\xc0+ud\x96\xe1\xdb\xf6\xbf\n\x8f\xe7\xd9\x1e\xb4\xf0\xbf\x80\xeas\xaa\t\xca\x98?~\x98\x9b\xc7\xd5 \xec\xbf\xffv\xbdTD\xcc\xd1?&\xa9*\xdd_\x03\xea\xbf\x9a\t\x88\xf5\xe2\xe9\xe2?)\x9c\xb9\x0ct\x89\xfd\xbfP\xeek\x82\x88\xc1\xf6\xbf\x19u3\x9b\xc5\xd9\xf5\xbfmx;\xe1\xb2T\xe7\xbfr\xd6\x99\x1d\xc0O\xe6\xbf\xcd\xc3\x8e<\x95\xb4\xbb?\x0bo\xa2\x96}a\x0c\xc0A\xa9\xa8M\x82x\xd9\xbf\x0e\xa78\xfe<{\xf8\xbf\x9d{}\xaf*\x98\xe4\xbf\xca0\xb2\xba\xc9\xf1\xea?\xba\xf4%8A\xe7\xa1?\xedtB\x0c-\xd3\xd3?\xa1H\x14\xab\xac\xae\xbe\xbf\xf5?\xdb\'\x98\xef\xc2?\xe9\x1a\xe7\x9fx\xde\xe3\xbf\x9a\x04~\xa56\xa7\xf4\xbf\x8aD+A\xa4\xca\xf1?s\x9cC\xd45\x85\xf5\xbfz\x97\nA\xccZ\x00\xc0\nV\x94X\xbd<\x9b?\xa2f\xb2J\x99\x1e\xe8\xbf\x05\x813IJ\xe8\xf6\xbf3\xe8ix\xf4d\x01\xc0\xd0\xbf\xc8\xdbZ\xf7x?\xa3\xde\xcf\xaa\x9d8\xd8\xbf\x9e\xfa\xad\xef\x9b\xb7\xfc\xbf\xa9o\xa1\xbc\xa9\xfe\xf7\xbf*b\x9a(^S\xdc\xbf>\xfa\x15\xf2&9\xf6?\x87[\x80\x16\xe7\x9a\xfd\xbfcakD3\xfc\xfd\xbf\xcc\xca\x9c\x0b\xb6k\xe4?\xca\xf8\xb9c\xa5\x11\xe5\xbf\x81\xedT#\xca{\xfa\xbf\x8c\xbbs\xf5\xc9\xf2\xf1\xbf[&~\xa9\xdc\xf1\xef\xbf\xff\x0f%\xc7\x7f\xe5\xbe?\x9d\xfa)\xe1\x7f\xef\xb5?\xf7:\xac\xbc\xa0\t\xed\xbf\xf7\xadB\xc7\xa8#\x01\xc0\x11\xe6\xbb\xb0\x83\x1d\xf2\xbf\x12\x0b\x88\x19h\x97\xec\xbf\x030\x8e\x17\x88,\xee?\x9a&t\xb8E\x8d\xfc\xbfs\xcd\x1e\xea\x9e\x0e\xf5?\x84\xd7\x1f\xd3z\xec\xee\xbfL\x0cH\xda(h\xd4\xbfj\xb8g\x19^\xad\xf7\xbf\xca\x18\x84\xfb"\xbe\xcc?\x0fT*\x98R\x1f\xee\xbf\x1f\xc7\xe25\xb0"\xf2\xbf\xdd\xf2\'\x14\xae6\xf3\xbf]#0\xf8\xcc\x80\xdf?\xee\xf7\xd0\xb3\xbe#\xad?\x8b\xd2\x98\xcd\xe4\x01\xc1\xbf\x98>\xf3\x91\xc3\x1e\xe5\xbf\x1b\x12\x84g]\x99\xf9\xbf7\x1c\x17&\xab\xbf\xf1?A:)\x04\xad\x1b\xeb\xbf\xc1Y\x17\xa8\xde>\xeb\xbf\xd0oy\x982@\xdb?D3\xd9\x9b\x0f\xf0\xec\xbf\xa9Mo\x89\x13\xfb\xd4\xbf\xe5\x86%2\x1e+\xd0?*\x01\x13\xc9\xda\x9f\xf0?\xf7k\xa5\xef\xfb\x05\xe0\xbf\xfc\x19e\x1b\xf47\xe9\xbf\xb5P\xe42\x94E\xf4?\xd1\xad5\xea\x9b\x0f\xcb\xbf\xd1=\xcc$\x85r\xe1?"/\xc7z\xd0|\xf1\xbf\x9e\xadZs\x9e\xea\xe3?\xc8l\xb6w\x9c[\x03\xc0\xdc\xf0\x8a\xb3\xb9\xd1\xd6\xbfN\xea^GK\x98\xd4\xbf\x94\x14\x82\xcb6\xe4\xf5?h\xd67*U\xa4\xf1?+t*Ff\x19\xf4\xbf*\xeb\x05j"\x98\xcd?\xe4rbh\x9c\xa0\xdf\xbf\xa2\xe5&/TT\xc8?\x90\x0b\xdf\xcbi\xb1\x85\xbf\xd2Lp\xdc\x06\xdd\xcd\xbf\xa2\x7f\xdb\xde\xeb\xf7\xfc?:gQa\x08\xb9\xf1\xbf\xbdABd\x9f\xfb\xf0\xbf\xa9Or\xe4?\xfe\xdb?-\xb0\x80N\x9d\xc9\xf1\xbf\x16\x82)\x89Q\xba\x04\xc0\x9a:,\xb6\xd0i\xfb?^F\x92\xf0\xcc\x9e\xe5?\xcd\xc9\xdd,@\x19\xf1\xbf\xea3\xe4_\xc7 \xe0\xbf"\x96\xa9\x00\xfew\xe0\xbfQjS\xb0\x0f\xe9\xd6?6zI\xf5\xc6\x82\xd9\xbfY\xbd\x01\xc1H\xe8\xfa\xbf\x93\x1cd\x8b\x10J\xb1?h\xce\x91\x9d.\x1d\xbd\xbfi\xfbZ\x92\xfbx\xb4\xbfy\x93\xb0\x8ev\x8b\xf3\xbf\x1a}1\xe7cY\xd4\xbf/J\xf9\x8fa\xb9\xea?j4E&\xf1]\xf4?\x91\xe0\\\x94vV\xdd?\x8e3\xef\x1c4A\x04\xc08\x90\x96l\x99d\xa5?`\xb5\xa3\xb1~5\x04\xc0Lw\xba\x91\xb8\x92\xf9\xbf@\xf8+\xea2\xc0\xfb\xbf\x0f\xafF\xf9\xe4\xd7\xf9\xbfLY\x0c\x10\x15\x0f\xe8\xbf}}4p\xa3\xa5\xfd\xbf\xe8d1\xc1<\xe7\xf6\xbf\x9bg\xaf\xb7C\x89\xca?\xe7&\x90\xa3ce\xe8\xbf\xa8\xda\xde\xc9\x88\xeeT\xbfw\x90:g\xe1\xef\xd3\xbf\xaeU\x16\\\xa4\xb3\xfe?\xbe\xdc\x01\xab\x80\xa8\xc4?\xbaD\xadD>\xae\xf7\xbf\xd4Gt\x1b\xcbY\xf0\xbf\x19\x8e\'\xc7g\xd1\xef?\xffJf\xa4\r\xa7\xf9?nY\x01\x85\xbf\xeb\xe2?8\x9b\xacB*\x9a\xd6\xbf\xf5VA\xb45\x19\xe4\xbfl+j\x8eJ\xc8\xcf\xbfO\xbe"i&7\xa3?W/\x0b\xea\xd83\xf2?H\x9c\xd7w(\xdd\xd6?_\xb92\x84{\x96\xe0?,V/9@\xaf\xe1\xbf\xe1\xa3\xacW\x00\x8d\xc2?.\x08\xeb\x11\xd4\x82\xf1\xbfS\xd6\xe5\xf6\xd5\xa0\xf6\xbf\x07\xfa\x945PN\xe2?\x92\xa9\x1b7"\xfe\xcd\xbf(@:\xcb\'\xaf\xf2\xbf\xef\xd1\xbe\xbdks\xf8\xbf\xa1\xa9\xe7\x13\xa67\xd6?>V%_\x08\xcf\xeb\xbf\x1c\xefn\xcdv@\xc1\xbf\xe4!\xe88/^\xf7?L\xe1\xaa\xed\x11\x16\xb8\xbf\x8f\xcf&\xdd\xdf\x83\xd7\xbf\x15\t\xc0\xff\xe5\x12\xd5\xbf1\x83\xf7\xa3\x9fJ\xd6?\x93\xc7\xc3\x0c\xc9\x1d\xbc\xbf\x0b*\x06\xad\xa2\xdf\xf3?,\xc1!p\x83\xaf\xc7\xbf\x158\x92\x7f\x0b\x9c\xfd?\x91\x1co\xc6\xec\x05\xd3?\'\'\xe5\x97\x90\xc3\xe8\xbf\xee\x94F\xec\xc8>\xb5?\xd2\xa5Y\x93\n\x0c\xb6?}\x86,e\xba\x84\xe2? \x98\x8b\x0f2\xba\xdb?\n\x9d\xcegdA\xd6?\xf2\xfa;n\x18\xa9\xb7\xbf\xb3}>\xe9\xe2k\xf1\xbf\xcf\xa3\xa49Qh\xe5?\xa6\xf2\xc4\xd1\x8do\xe5?/\xf3\xe9/\x9c\x89\xda\xbf\xc4\xdd\xbb/\x1c\xa3\xb9\xbfd\x9aJ\x11\x94a\xd4?3\xf9]\xa6\xa6*\xd3?U\xd1}+\x08\xcd\xbd\xbfbt\xed\xde\xad!\xe9\xbf\xad\x9b.u\t\xad\xf2?i\xd0\xec,\x96b\xee\xbf\x8aH\xd9\x81f\x93\xc8?\xd9_\xc4\x04\xd9\x91\xd9\xbfO\x8a7\x98"V\xe1\xbfO\xdfR\xfb\x8a\x97\xdf\xbfF\xc0\x8a\x02\xfb\x94\xeb?2/\x10\x9c*\x97\x95?\x91(\r\x07\x9dx\xf2\xbf\x06\xa0\xf8t\x9ds\xed?\x86\x1e\xe9\xb5$T\xde\xbfdh&\xf6\xc9I\xe9?\xc1\xc4]/d\x1f\xf0\xbf\xcf\x85\xecv/\x9b\xfd\xbf\xb0\xac:\x85\r#\xf5??5\xf4\xb6dS\xa8?\xc8\xf7\x0c\xac\xb5Q\xed?b\xec\x91A\x9f\xea\xe1?x\xde\xf2\x99\xe1\x01\xf2?\xec\xa6P|V\x00\xfb\xbf>j\xddFF\xb7\xc0\xbf\xf1bQ\xa2\x84\xa4\xb6\xbf\\\\\xaf\x14\xd2\xe6\xd9\xbf\'5&\xc5\x8c\x17\xfa\xbfg\x8ep\xe9\x84\x11\xf2\xbf\xa0?\xe9\x02\xf4\x80\x03@\x8f$\x83\xf6\xe9\xf4\xd5?\xd6*\x08\x14\xeeE\xd7\xbf\x01x\xa7Z\xa2\xbd\xe8?nR\xde=/2\xda\xbf%\xe6%^cL\xf5\xbf\xfe\x00\x11\x80\xc4A\xd0?<\x8d{\x9c\xd2\xc7\xe9\xbfl%_\xdb\x7f:\xe2?\x10\xcb\x13\x8a\xbd\x02\xb2\xbf\xe6s\xb1\xec\xd6\xca\xc8\xbf\x81\r\xdb\x8dt\x9e\xe8?\x88_\xbb\xe2g\xad\xe5\xbf\xb5\x0e\x8c\x84\xa8a\xc6?\xaedr\xea1\xbb\xd1?\xfdj\xc0\x11 ^\xf2?\xe4h\xbf3\x8e\xfa\xcc?\x96\xb5w\xa4\x91\t\x97?OH\x80\x03~\x8e\xf2\xbf\xb7Dp\xc1\x1e\xddq?k}\x16\x90\xc4.\xdc\xbfl6?\xc4\x86\xb4v?\xad\x05\xd9.e_\xf5?E\x0c\xd0\xbe\xd3\xa2\xcb\xbf\x18\xb5\x8cQYo\xe2?\xa2\x08\xb2\x85#\x13\x85?\xf17\xe75!b\xd8?8\x9eXv\xf9\xe1\xd7\xbf\x82)\xd7\x167V\x9a\xbf\xe6$\\\x0fj\xdc\xe7\xbf\xf7_vvpt\xbd\xbf\xbf\xa47\xfc\xbd)\xf1?f\xbdH7\xa1\x82\xe8\xbfDl\xbeD\x00\xba\xff\xbf&\x18Wfp8\xf3\xbf\xca\xdf5\n\xf5\xd0\xf2\xbfL\x93h$n\x1a\xda\xbf.\xc3\x1e\xa9\x04z\xf3?\xd7DT\xdb \x91\x10\xc0\x969\xec\xa7\xd3\xab\xf1\xbfKG}\xb1\x85\xe2\xb4?\xc7\xd56\x9d\x19\x85\xf5?\xe5]\x0c\x049-\xe4?\xd0\x80$\xfb\xf6S\xc2?\t\x85T\xceX\xf4\xd0?\xae\x9b\xd8\x1f\x84v\xe0?\xbc\x89\x1cw|c\xf1\xbf\x8c\xba\x18\x9c\x12Q\xe6\xbfD\x80\xed\xb3\n\xf8\xf5\xbf\xa5\xaao{D\xcd\xe7?\xab\x8c\xde2\xb9J\xb1\xbfRt\xf5\xd7\x08\xcf\xf5?\xe5k\xb5\x1ai\xd2\xe1\xbf\x9a\x9d\x8a\x1e\x02n\x94\xbf\x9f\x06\xfek\xe6<\x05\xc0\x88\nc\x94B\x16\xe4?\x82O#`\xd0A\xcf\xbf\xe7\xcd\x88\x07\x83\xd0\x06\xc0-u\tYTz\xc4\xbfD_\x9en\xe3\xd6\xf3?=\x1dH\xa0Z\x19\xd4\xbfm\x8f\xeb\x7f\xd5+\xfb\xbf\x1eT\x8a\xeb6\xbf\xdf?\xa91\xab\x8e|\x06\xc5?z\xb8\xa6w\xd2}\xe3\xbfm^\x92\x0f<\xcc\xe1\xbfF9\x98\x9e\xd6\x84\xbf\xbf\x0c9G\xc05\\\xc7\xbf\'\xd6\x13AqI\xfc\xbf4F\x986\x00\xc4\xe4\xbf\x13\x04\xf0\x03\xd4/\xfe\xbf-\xad\x8d\x8cX\x9b\xee\xbf\xe7\xf6\x96\x16?\xa7\xa9\xbffJ"\xabe\xa2\xd6?b\xf0\xa2u \xd0\xf1?\xb8\xa1\x86\x96!\x80\xef\xbf\n\'\xfd\x85X;\xe5\xbf\xf0\xcc2*(*\xf1\xbfw#\xe9\xbc\x13Q\xf1\xbf\r\x17\x98\xc4/\xaf\xb6?m\xd2&*6\x1f\xdc\xbf\xa5\x00\xf4nP\xa4\xd9\xbf\xf9\x88\xcd,\x89\x9b\xcc\xbf*[\xef\xa6\xc8\xe3\xdc\xbf| \xa4>\xcb\xdb\xaa?\xe0\x86\xde\x8cy\xbf\xdf\xbf\xbdy\xa5\xa11\x8c\xf1\xbfW\xf6y\xf6-\xc7\xf4\xbf\xe3\xd4\x0cl\xe1\xca\xf5\xbfB\xfe9\xc4\x85h\xc7?\x06d\xb3\xdc\xac\xe0\xe3\xbfW\xec\x9f\xf5\x0e\xc3\xed\xbfN\x80*\x82\xc5Y\xf2\xbf\xe0w-R\xfau\xeb?\xe3Ot)v\x96\xd4\xbf\xedu\xa9\xd1r/\xeb\xbf\xd0G\xecPZ:\xc8?\x9b\xb9`\xd2\xd94\xf6?\xbb\xe2\xa1t|\xaf\xe2\xbf\xcb\xdd\'s~\xe3\xf3?`\xcc\xab\xdbs\x99\xe5?\xe4M7\x17G\x8a\xf1\xbf#\x1b\xec\xd6\xe2\xf5\xcb?\x03\x04\xa1\xa4;\x1f\x01\xc0\xdc\tj\x87+_\xf9?4%\xdd\t\x14y\xf2\xbfJg\xae]\x90\xd1\xf7?\x11h@\xfe\x8e2\xe5\xbf\x9f(\x87\xa2\x84\xba\xd7?\xeb\x97O\xc2\x10R\xfc?\xd7\x00l\xf0\xe8}\xd5\xbf\x06\x89M\xb8\xc3\xf4\xf7?<\xbe\xd5M\x00\xd8\xbe\xbfh\x94\x88u"\xa8\xfb?\n4ru\xe7v\xe0\xbfI\xd3#\x14LS\x9f\xbfs\xf5\xa1\xa43\xbc\xc5\xbf\xb0q\x11\xf4\x98O\x05\xc09l\xb3l\xe1\xb7\xf6\xbf\xb5-8\xf1\xd9\x19\x00\xc0\x1cI\xca\xa8\xde2\xf2\xbf\xb0(\xff\xc7\xd7\x10\x00\xc0w\xebbve\x95\xfa\xbf\xa5\x99\xce\xda\x92\xd0\xd0?0\x156+\xd7\xc2\xe5?\x99\xb8\xdc\x8e\x9e\x86\xe5?\x8bf\x05\xe8\x7f\xf4\xec?\xf9V\xe9\xe3c\xbd\xfe\xbf\x9e\x15\x10H\xf7\xb5\xf8?\x1c\xbb\x03b\xfa{\xf1\xbf\x90U\x1bc\xb2\x93i?\xdb\xc88(\x1cKx?\x95\x85Z\xfb\xc17\xdc\xbf\xe6\x85\xab;\xc6\xe8\xe7?\x9a\xda\xf1)\x9d\xfc\xfe?$Ah\xe6\xf2j\xd2?h\xc3\xa5|\xf2\xee\xa4?\xa5\xb8%f\xd0N\xe3?\xa5\x0e\xbd[\xa8W\xdb?@UO\xa71\x8b\xf0\xbfIB7\xa5\x87s\xeb?\x84\xdf}\x03#\xf0\xd2?Z\x97\x86\x10\x08\xff\xec?\xba \x13\t\xe9\x95\xe7?S\x99\xfd7\xb5\xa0\xe7\xbf\x10\xe0\x8f/\xf5\x9f\xe3?\xf5S\xe5YrR\xda\xbf\x8b\'?8\x0e\xb3\r\xc0\xa1\xe4\xe4\xfd\xcet\x0b\xc0=I\xa6\xe2\x08\xf1\xd5?\xf1\xdbt\xaaa\xa3\xe9?\x9a\x90\x1bu\xe9\x07\xda?\xf5v.]X\x1a\xc9?\xa3R\xa3[\x01\x1d\xc7?&\xefy\xc9\x82\xa1\xea\xbf\xd5\xb7\xea8%3\xf1?v\x1f{\xefY\xe1\xdf?\x0fB\x9ekb\xcb\xed?\'C/\xbd\xba\xf0\xf2?\xb2\x87\xe9\xd0o\xb1\xdb?\x92\n\xce\xd5\xf6m\xf0?\x94\xbe\xa7\xb9YH\xff?Q\x0eb\xddT\x19\xdf\xbf\x0e\x06:\xb3\x10c\x01@\xaf\r\x97\xef\xb5$\xef?\xeb\x83\xfd\x1b\xaeM\x05@^\x16L\x83\xe7\xb0\xcd?\xdf\xe8\xec\xc2\xed\x9e\xc2\xbf\x89\xee\xcd(x\x80\x92?\x9a\xad\xdc3\xef`\xf6\xbf\x1dZj\x96\xbc\xce\xe3\xbf\xe6\xdb\xf6\xebyW\xf4\xbf1_\xfb\x15\xeb\xe5\xf9\xbfv"\x18\xdd\xb3\x81\xec\xbfNs\x18\xc4u\xba\x02\xc0f\xf4\xc6\xfa-\xb7\x02\xc0S\x12\xfc\xe3\xe3\x83\x01\xc00\xbaA\xd8\x13\xad\xc5?\xf6N\x1bE\xaa\xa0\xa3?\xa6%eS\xa7\xb3\xd3\xbfX!A\xa1\xa5\x90\xbf?\xef\xce\x85\x8b\xfa\n\xd1?/\xb0\x0c\xf3\xd5\xb7\xbf\xbf\x8d\xad\x8dY\x9b\xfb\xd2\xbf&>\xed\xa5\x8e\x88\xce\xbf\x95\x11\xc4\x8b\xb5\xa5\xe9\xbf\xed\x88\xeb\xcb\x8cK\xd6?\x82m\x8aT\xbb\xbd\xfa?\xd0\xe4c\x93\x04P\xee?\xd8\x032\xcb\x00\xfa\xb9\xbf|\xc03qw\x18\xe9\xbf{a?\xacd@\xf9?4\xcb"U\xa39\xb7\xbf;\xb5\xa3\x7f\xeb\xc2\xf4?h\x19\x13$7>\xc3?\xef2\xa4\xbd\xca-\xe5?wV\x99+\x1c\xe0\xe1?\xb1\xfco\x0e\xa0\xc4\xf6\xbf\xb1\x1eDX\xa4+\xdf?N\x8e\xd0\xa6\xcd\xdbZ?\x1fZ\xac\x95\xd1\x0c\xf8\xbf\xbc\xce25\xc8\x06\xe5\xbfLrl\xfd\xb2\xd3\xee\xbf\x18BC:\xc6\xfb\xea?w\x18\xeaJw\xf1\xc8?*\xaf\xdd\xd9\xb6}\xb8\xbf\r\r\x8d\x9c\x85H\xe5\xbf-\xfc\x8aSxo\xce?\xd2r\xf0\x8f\x81\xb3\xe9?\xd3BUMj\xe8\xff?`D\xb7\xbb~\x82\xf5\xbf\x96\x08m\xe1\n;\xd8\xbf\xbdb\x82\xce\xeeU\x00\xc0\x9c&\x04\'\xe7H\x00@s\x9c\xd9d\x12"\x01@\xdd\xba\x10^\x94\x06\xfb?o\xc9 \x9c\x8eo\xf3?\x92}n\xa1!\xa3\xe9?9\xdcN\xaf0\x9c\x03@\x13\x10\'P\x1d\xa5\xe7\xbf\x154\xd8\xb4L\x1d\xca?\xb2\xa4\xd36\x9c\xcf\xb2\xbfc\x14]u\xc3\x1c\xf3\xbf\x9e\x86\xfc3\xab\xd7\xf4?!\x89\x18Yo\xcf\xf7\xbf\x14\xc0\x11+}q\xcf? W-\xf4\xae\xa0\xe9?\xb7\x9d\xfeC\x96\xef\xea\xbf\xaf\x9d\x7f&a%\xe6?\xa8(\xbf0E[\xb8?"\x93\x03\\X\xa1\xe8?\x8d,0{\xafo\xee?\x92\xb2+z\x94s\xf5?C\xd1ap\xf9h\xe2\xbf4\xbc\x82\xb2~\xa9\xbe?\xde>\x1fH"\x9d\xd7\xbf\t[\x1a\xe0\xcd\xcf\xf0\xbf\xb6\x9e\x7f\x1d\xc3\xd5\xe8?O!\xbc\xcb\x9b\x86\xd3?\xe4\xb9/\x86\xe1K\xf0?\x9c\x14-\xac\x8aF\xf9?R\x16\x9e\xcd\x18S\xa9?\x0c\r\x1d\xf2\xb1s\n@p!D\xa7)_\xfe?\xe4\t\xf6\xf1\xbd\xec\xfb?s%\xe3\xf1\xc8v\xf8?\xd0\xc2\xee\x17\xad \xc7\xbf\xc4\x15\xd9\xad\xa9g\xd0\xbf\xce{m,nu\xf2?\x19\xeaoia5\xdb?h\xc8\x04L\xc4\xc9\xe2?\x0by\xc9sU,\xc8\xbfc\xa1\x8f\x02JE\xbb?\x1b\x0f\xb4\\\x89\x12\xe9?,\xbax\x91\xd0\x7f\x06@\xf2\xaf$\x0c\xa8\x8e\xee?G+o&\x90\x80\x01@F\xe1h\x8e\x84\xb7\x10@\x8886$\xb4\xa5\x06@\x98;\xc6\xb0\x8b\xe5\xfd?\x00\xff!C\x7f\xe3\xf3?\xfd\xe3\xeb\xfc\xe3N\xf6?YH\xc3N_X\xa6\xbf\x8d0E\x95\x8b\x87\xc9\xbf\xf6s\x08\x10\xe0\x90\xf2?\xfdw6\xea\xb6\x9b\xfe?\x10\xbc\xdf\xa74\xd8\xc5?\x87L\x86\xf9}y\xe6\xbf\xbe\xe9\xbf\xf2\xe0\n\xd1?\xe2\xdaG\xe7Y\x8d\xef\xbf\r=g\xa4\x95\xa0\xf5?\xd2\xfa\xbd \xb6\xe4\xdf?1\tc\xe6lK\xee? bRS\xdex\xb6?/\xf1&R7v\xdc\xbf\xa7bVi\x13u\xe4\xbfp\xbb$\xaey\xa7\xdb?\x8ee\xed\xe7\x08\x97\xb5?\xd4\xfa?\xc0\x10\x8c\xd1\xbf\x8e\x17\xfb\xdb\xb0|\xe6?\xca\x91\xbf4P\xa8\xe1?\x03\xd4b\xf6D\xc7\x02@\x9a\xbb\x7f\xd7_\xa8\xeb?F\x7f\xf2v\xe5\x8f\x0e@z\xf2\xdf\x17\x05\x1f\x12@\x91\xbd\xc7\xc3S\xe2\x13@Yv\x0e\x8aw\xaa\x14@\xef\xbd+H\'\xcf\x0b@\x91\x11cEuo\x12@:\xdd7{\x1b\x17\x07@\xc3!yo\x92-\xf4?5\x15\x91\x9b\xdc\xf3\xf4\xbf\xb6\x003\xd4%1\xe6\xbf\x836\x82a9.\xbb\xbfxQD\x84s\x86\xfb\xbf_\r.\xdd\x8d)\xe1?,\xf7F\x0c&\x89\xe1\xbf\xfc\xfc=\x9c\x89j\xdc?\x04\x10J*\xe7\x1c\xdc\xbf}\xefrp\x11\xe7>?\x98\xa2\xfa\xa7\x0f\x0b\xa2\xbfpxJ\x1ay\xff\xe6?e\xa92\'2\x85\xef\xbfb \x8c\xa3\xc6\xc3\xda?\x90\xbfI\xe5a\x06\xca?\x8dVxu|I\xd1\xbfb\x99\xd9\x1bVZ\xfe?\xdd\x7f\xe3\xe9\xdf{\xf3\xbf*k\xba\x96`\xd9\xe1?\xde\xa7\xa1\xd3\xa6\xe7\xf5\xbf\xf4x\xc0d\xc9\x80\xf5?g\xff\xb4\x1d\x89\x05\x0b@\xcd\x16\x1d\xbe=F\x02@\xa5\xe3\xd0.YQ\xfd?\x08w\xa6\xc7~\x00\xfa?\xda%\xf1\x8dXp\x0f@D\x824h\x12q\xf1?Q.^\x9a\xdaG\xf1?\xfa3\xea\xb0V\xfe\x01@\xd7~w,\x9a\xcb\xc3?\x01\xed<\xbd\xce)\xe3\xbf_\x90\xe5\x00\xe2;\xc4?DLmOd\x90\x02\xc0\xfc\x14\xac\x8c\xeb\xe1\xfb\xbf\x0c\x97\x9d2w\x7f\xf6\xbf\xb3,\x062\xcff\x01\xc0\xb3\x92\xc7\x11`\x0f\x04@\x1d\x1e&\xbd,#\x01@`\xa8\xc6\xdeny\xf6?\x80W\x19S\x9d(\xda?.\xeb$r\xc7\x01\xe3?\xc5\x90"u\x1e\xaf\xdb\xbf\xa3\xe1{\xac\x9a\xef\xdd\xbf\xb6g\xc0z: \xe3?\xf5\xa1\xc8\x88\xc3\xee\xde\xbfT9\xdaW\xac\x91\xb3\xbf6<\x89\xeaNE\xd7\xbfd\x04\x02P\xfd\xca\xe8?7Cg!\xe9\xd0\xd1\xbf\xd9\x17\x17\xe00Z\xd5?z)\xa4n\xcc\xa3\xbb?\x85\x02\xb2d?\xf5\xd4?\xc4\xdcHK\xd1\x91\xd2?\xa4\x12,\t\xe5\x91\xcd?\xa8\'\x7fu{\xc9\x0b@\xff\xe84\xf0\x13\xa8\xfe?(y$\xccd\xc3\n@\r\xae\xb1R7\xb1\xcc\xbf!\xf4u\xaf}}\xee?\t>\xc5`E\xb3\xcb\xbf\xa6\xc8\xe2/\xfe\xe2\xda?\x8f\x91\xdf\xbc%o\xec?\xeb\n\xdc\xfae*\xee?]\'\x97c\xcbq\x01@\x16V\xa7v~\r\xc1?\xc2i(\xfe\xf2\x85\xf1?k\xd1\xa3\x9c\x7f)\xde\xbf\xdb\xba\xe4\xfdgF\xd9?\xf5\xe4\x8d\x8b\x97\xe0\xe1\xbf\xfd\xfa\xad\xba\xa5L\xf3?\xc7\xff\x88\xca*\xe1\xdb\xbfh\x84\xbb\x82\t\x8a\xd3\xbf\xef\x14\x06[{2\xe5?\xb5\xbe\x8e\x8a\xacW\xd1?\x9dB\xecb\xbc&\xf2?\x9b\xd4}k\xe2E\xdd\xbf\xb4\x11\x02\xbf*J\xf8\xbf\xf7\xb6q\xb7\x13f\xd3?\x9dJ\xf1\x1b]\xe0\xeb?vGEY\x8f\xc0\xdc\xbf\x7f\x9e\xac?G\xbc\xe4\xbf6\xd8\x98l\x17"u?\\\x19%\xe0\x94\xf3\xf2?\x90\xa2\xab\xa8d\xd6\xf1\xbf\xe5\x9e\xd3\xce\x1f\xdf\xee?/\xf1\xa0\x13\xe3k\xe5\xbf\x86#\x8b\xcf\x82\xa7\xe2?\x9a\xba\x91\xa8\x02\xd7\xec?9\xad\x06i\xf5\x0b\xf4\xbf\xb1\xb6\xdd\xdb\x0f\x06\xe4\xbf\xb4e\xbf\x08\xb9\x02\xf2?\x17M\xe4\xaaT?\xf2?\xff\x7f\xc1\xb0\xba\xc4\xd1\xbf\xd6\x08R\xebu\x8d\xe6?!\xa5V5L=\xd2?\xfd\x84\x83&\x94S{?\x89\x13\x14r\xd9\xe2\xdc?\xb4\xc8\xa4\x8e\x02B\xdc?\xcd7y\x03\xc4\xd4\xb3?\x0f\x8b+ \x05\x17\xd7\xbf@\xaaV.`J\xde?\x02\xd9\xe0\xe1\x05\xdf\xe1\xbf*\xc7B\x01/\x92\xc7?\xe9\x87h\xf9\x138\xcc?I\xa0\x00\x8a\xefG\xd6?,\x9e\x9aA\\J\xe7\xbf\xb0\x7f.\x03\xa8\xea\xc8\xbf\x15]\xdd\xec\xd4)\x86\xbf\xa8\x85\x19\xc4Pj\xf2?\x1ez\x0bt\x83\xf4\xe7?5\xb8sO\xcd\xf7\xf8\xbf3\xc5\xa99+\x9b\x05@?\xbb\x95\x94qZ\xf1?X\x93\xacDO\xb8\xfa?[\xec\x138\x07.\xfd?J\x08\xd6|z\xd3\xca\xbfx2\x1f4\xe7r\xdf?),\xb8\xcb\x13\x9b\xcb?\x0c\x8d\xc9\xb8\x14\xb5\xfb?\xc6P\x8f,\xe1\xb7\xe1\xbf\x19\xfa\xca2T\xfc\xf3?VJ\xfa\x17\xd3R\xf1?0{R(\x15s\xd8\xbf\xe0\x96\x96\x8f\xc4\n\xe1\xbfV&\xe4q\xb0\xcd\xe6\xbf\xa8\xc3Dj\xa7S\xd9?a-\xdb\x81\xe4\x86\xf1?\xd5\xeb\xd0S\x7fa\xe4\xbfx\xcbp\x10\n\x8a\xf3?n\x15Y\xc9)I\xd4?\xd4\xe1\x81\x18K\xc9\xd4\xbf\xa6?\x1b5\x01N\xe8\xbf\xbc\xd3\x0f\xb6:\x0f\xdb\xbf\x92\xdeF\x88\xf8\xb1\xc4?\xbc\x01\xec\xf8\x8f\xd5\xca\xbf\xca\xd9\xb2*}\xba\xf3?t\x92\xbeRd\xb7\x05\xc0\x15#\x8d\xfc-*\xe0\xbf\x97\xce\xac\xf8\xa6\xdc\xf7\xbf\t\xf5\xd7\x1f\x01\x0c\xc0?\x96\xff\xd8\x9b\x0e*\xeb\xbf\xd2\x87\x0c_\xc4\x8a\xf1\xbf\xeb%\xf9\xd7kZ\xc4?al\xec\x7f6p\xde\xbf\xa2\xa0_}\xf7k\xe5\xbf\x06\r\x91^\xa0\xec\xd7?\xb3\x7f\x1f\xd7E\xfd\xd5?M\xc2\xbeW\x84\x03\xc9\xbfo\x82\x81<\xcf\xb2\xc8?O\xfd>\x03C\x8b\xeb?\xc3<\x95\x07\xc2\x14\xc3\xbf\xf4\xce`\xb4_\x0b\x7f?\xd9\xb5\x9dG\xa4\x92\xf1\xbfQ\xeb\xfa3\x80\x92\xfc\xbf"j\x80\xad\xbdJ\x84?\xc0I3\xbaP\x8f\xf4\xbf\x07I\xb6\xde\xac~\xf0\xbf3d\xcd0\x99\x1e\xdd?\xb2\x95\xa8\xe0\xaa\xa0\xf1\xbf\x17\xbe\xcc\xd3\x15\xb0\xd9\xbf+c2\x8a\xbf\x8d\xe6?\xb7\xff\x99\xcd\x01\xd1\xdf?Oh\xcc\x155\x15\xfa\xbf\xa3\xca\xb6fQ4\xe6\xbf\xdd\x11J\xd5\x08!\xfe\xbf\xf0\xae\x15\x96\x9e\x99\xe5\xbf\xea\x7f\xa2~?|\xf6\xbf\xa7\xfeo\xbd\xb8f\xbb?\x90\xee\xcfy\xbc\xaa\xfa?\x92B\x94\xe9\xfe\x1e\xea\xbf\x93\xb8i\xcd\x17\xff\xef\xbf\xd3X\x04W\x0e>\xb2?\x9fBt\x92\x11\xbe\xf4\xbf\xd8\xca$\xf6b\xcc\xef\xbf\x7f\xd1I\x05\xd6\xfa\x01@$d\xc9j\xb9F\xcd\xbf\xfc\x92I\xbe\xf7\x91\xfa?|\n\xc6S\xcdH\xee?GRL+\x07\t\xe0?\xf1\xaa\x89\\J\x06\xaa\xbf\\{;\xa5\xfa\x88\xf3\xbf|".\x8d\x12v\xd5?]\x9f\xc5^\x83Z\xec\xbf\x0c_1\xb8\x01\x04\xcd\xbfe\xd1,\'\xcc<\xd2?\xdf\xc5\xb6\xb8\xe04\xea\xbf\xda\x0f\xaf(\xc5l\xd1\xbf\xfb\xde\xdb\x0f\xa1\x90\xa1?1F\x9d`^\xe8\xd4\xbf\xf3\xfe\xed\xb9B6\x82?t\xc4\x89a\x1c\x10\xdb\xbf\xc5\xcc\x91}\x7fq\xd6?h|\xd4\xd9Bq\xdd\xbf\xadLy\\.\xa6\xec?\xb6\xf6%|\x07(\xf1?\x0f\xb3U\x895\xe6\xd8?\x9a)J"\xa0S\xe7\xbf;\xe6\xcc\xadI4\xe1\xbf\x82_N\xf0j\xd6\xe7?\xd9\x95=_\xe1\x8e\xa3?S}2\xb5\xd4\x19\xf0?\xcf\x13\x9e\xbcu\xbd\xac?*\xb5\xd7M\x13\xe7\xb3?\xc0\x8c2\tR\x8d\xeb?*\xeb\xacHg@\xec?R\xb4\xd9\xa4\xe0\xdd\xac\xbfe\xbe\xea\xee\xc0\xea\xe3?\xe6\xe7\xee>\x04k\x04@\x0bm\xfd\xdd\x16\x11\xa4\xbft\xa4\xce{\xb2\xbf\xcc?\xac%\xbeM\xa5\xa8\xaa?i\x14\xcc=\x0fU\xe7\xbfE\x8bm\x13\x0c\\\xe0?\x00\xb0\r\x91\xc5\xff\xd8\xbf|\xd8\xe7\xbc\xf9)\xf2?\ng\xd4x\xc4(\xc6\xbf\x19\xa9b(\xd3k\xe5?L|\x97\x11\xdeb\xa7?\x9bF0\x9d;\x87\xab?\x19\xae1[\xdd2\xf8\xbf\x15*I\xa67;\xf3?\x89\xd6\x1aY\xc2R\x8cu\xc9\xbf\x16l\xe5\xeb\xe1\xdf\xef?\xb1\xda\xc8W\x13\xb8\xda\xbf\xa4\x88\x1fTH\xb3\x84?\x1fym\xc6C\xea\xe9\xbf\xb7\xd3\xa0\xf9\xa3\xd0\xf2?\xa0b$\xe7\x18\x8e\xe0\xbf\xf2\x80\xa6\xedMM\xc8\xbf#\xa4\x1d(\xef\xeb\xe6\xbfBS\xba\x8eDN\xf2\xbfR\x89\x90\x85k\xd6\xc7?S\xa0\x8ch\xbc\xd6\x03\xc0\xb6\x97>\x80\xea\xea\xfa\xbf\xf8\n\x9d\x99(\x0c\xfd\xbf\x87\xc9\x89\xe9]b\xf9?\x18\xa6\x14\xb2\xe9\x14\xee?\x8e\x1f\xfa/\xfaI\xe6\xbf\x06s^l\x1a\xac\xe4?\xfe\x9aH\x07?\xf6\xf1\xbf+\xb1\xdd\xe5*\xc1\xee\xbf\xe1\xff\xe2\x88\xfa\xbe\xe3?\x05\xb7\x82\x96\xdd\x12\xcf?\x8f\x1fYT\xca\xcc\xd4\xbf&1\xf3)U\xab\xd7?\xf1\x0bC\x9dV\\\xfa? nMk.\xf9\xe8\xbf.\xbaKM\x00\xdb\xe9\xbf&\xe3?\xc7\x8e8\xdd\xbf@\xce^/P\xb6\xde?\xfd;\x0c\xa1\x8eN\xd1?\xcd0\x8a,\x82\xf5\xbe\xbf\xd7;\x8b+\x0ep\xf2?"\x1b\xc4n:R\xd2?|o9\x9e\xd6C\xf9?\x0e\x11\x01I\x1aj\xc0\xbf\x9d_zB\xfe\xa0\xe8?\xc4*x\xef\xac!\xb7\xbf^\x05\xbf\xc5\x19X\xf9\xbf\xbf2\xbb*Z0\xc2?X\xf5\x18\x14Q\xca\xf3\xbf\x8bp\x96A\x8bu\xf8\xbf\x82\x7f\x1f39a\xc8?\x08qe\r\x14\'\xe7\xbfZ4\xba\xbb\xdeg\xeb\xbf|\xc9\xec\xcdC-\xf1\xbf\x95=+\xdb\x03\xb0\xd3\xbf\xf7\x0e\xd3\xb6\x93B\xee?X_\xb8\x18\xb2\xe0\xe1\xbf\x91\x05\x10\xfbM+\xd8?\x13\x0b$\xa9\x1b\xaf\xfe\xbfQ\xe9+=\x84U\xd3\xbf~Ii\xb05\xfe\xb5\xbfX\xbd\xed\x8d\xc5\xcc\xdf?\xd4\x84\xd0\x80\x8cw\xe1\xbf$\xd6\x9c|\x02\x08\xfc?\x97\xb5i\x87\x9b\xa0\xfb?9\x0e\xba:$\xe8\x8b\xbf0\xf90\x03\x8c.\xcb?\x9e^\xa1\x16\x96h\xd6?R\x14\xa3\xec.\x89\xdc\xbf#H\xb4\xac,D\xfe\xbfj\x87\xf7y\ng\xe9\xbf\x03S\xf6\'k\x13\xf1\xbf\xcc\xc6\xf3\xcb\x03s\xde\xbf\xdd\xfa\xf001\xdc\xe8?\xa0\xcb\xa262\xc2\xc2\xbfL\t\xaaW%\x8e\xd6\xbfA\x85;\xfa\xfdq\xd1\xbf\x84}\x1f\xce\x7fD\xf8\xbf\xbd\xe0\xddR\x95\x0c\xe0?\xb4KS,!$\xf3\xbfg\x9ep\xe7\xaa\x99\xde?wT\x94\xfc#\xae\xeb\xbf\xf8\x0c\x80\xf7z\xab\xe7\xbfe\x84~\xe3\xcd\x9c\xe6\xbf\x81\xe0 \t\xf7\xc5\xf5?E\xff\xf1\x17y\xfa\xe4\xbfp\xc9\xcd{\x87\x81\xdf\xbfW\x85\x1d\x97\x86\xec\xa2? (5\xe7]\x80\xd4\xbf\xe6J\x1f\x14\xfdK\xe0\xbf5h\xd9\x9c\x89\xd1\xda\xbfT:m\xae}\xe9\xdb?\\G\'\xa5\x0bd\xc3\xbf\x01\xb5}\x80\x87^\xd0?a\xd8\xbcK\xf6\x89\x01@\x8a\xc0\r\xba\xf3\xcf\xe3?\xc5\xca|?\xb4j\xf5\xbf\xfc*6\xe2)\xa8\x01@\x15\x86\x06\x80om\xd5\xbf\t\xa7\xc1\xd6\x88\xec\xea?l\xc7\xf4\x88\x9e\x95\xe3?p\xd4\xe3\xe5yY\xf6\xbf& \xf9\xc6\xa8\x06\xdf\xbf\xa8>-\x95\xa7[\xb4\xbfp\x03\x1c\xd5\xcf.\xe8\xbf\xad\xe6\xa4\x882\xc1\xf0\xbf\xf3&\xcaq|S\xf6\xbf\xc6B\x7f\x90{J\xf3\xbf\xa5\xed\xd4\xbdkE\xa1\xbf\xe0\x0f\xa8zy\xf3\xe3?\x92\xce\xf5c\xd6\x99\xf7\xbfF2G\xf9rl\xe2\xbft\x8as\x12K\xc0\xee?$\x0e\xc2\xe2\xbe)\xf9\xbf\x8a\xb2"\x97\x99R\xc9\xbf~\xd0vK\n\xf3\x02\xc0\r*a\xb4\x869\xd3\xbf\xab\x8b\xe6\x84\x06\xa3\xd3?C{\x05\xbb\xa6\x95\xe6?\x84Ai%{}\xf9\xbf^m\x15\x7fku\xd4\xbf\xd4\xd2\xf2\xfe\x14V\xf8?\x1bA\xc5\x1d\xed\xaa\xe1\xbfL\xb4p\xdbv\x81\xc8\xbf\x1do\t\x82\xb1\x9a\xe6\xbf\xd5\xdcF\x1b\x84\x8c\xe6?UM\xdd1\xfd-\xe5?h\xea\xc5\xd7\xd4\x92\xfd?\xf0bZ\x94,s\xd5?\xb0#\x16\x82\xb1y\xf6?\x88`\xe5\xc4<\x97\xdd?\xe9$\x17\x12\x8e\x1a\xdd\xbf\xf0\xa3\xe5\x13vF\xc5\xbf\xf8\xe2\x87x(\x8c\xdb\xbf\x8e\xc79\xb9d\xc5\xe0\xbf\xea\xcf\x9f\xa3\x8b\xb1\xc6?\xe5\xe9X\x1c?/\xd5\xbfu\x97((D\xa3\xed?\n\xc1\xd6z\xbd\x05\x06@\xa3\x11\x98I\x99\xfc\xc0\xbf\xcdt\xa8o\xcdp\xb1\xbfo\xf9\xfeL\x82\x0c\xe9?\xf8\xf1\xdf\xdd\x00\x04\xe4?\xe0)\xc4@\xc7j\xfc?\xc6\xea\xbfl8\x1a\xe2?\xa0U=J\xd3m\xd2\xbf48\x7f(*\xe7\xe5?\x9d\xb8\xe6\xaco"\xd5\xbf\xea\x1f\xc1\x13\xc0\x98\xe5?\xedJ\x14\xd7D\x89\xd6\xbf\x16\x15\xb2y\xdf\x02\x96\xbf6\xb8\xdc\xc4\x14\xdc\xe4\xbf\x892\xad\x93\xee-\xf1\xbfy\xff]T\xa4\xfd\xc4\xbfWTd\x1b\xa0\xaa\xc2?\x89\t\x1f.MP\xb9\xbf\xd1\x8d\x9e\xec\x99\xc5\xeb?}\xf7U\'\xe2%\xff?\xe6JA\xcc\xdc0\xea?8~|\xd1\xb7\'\xd3?\xf5\xf7V\xe1\xeb!\xf7?\x03\xb8\xe7=\x9bt\xf1\xbf\x8a\x1bR-\xd9\xeb\xd7?\xb1C7Pk\x98\xeb\xbf\xd5{\xdc\x00Tm\xe8?@B\x08\xd0z\xc8\xee?\xca\x01\xa5\xbemK\xac?\x8eD({i\x01\xd2\xbf\x01T\x9d\xe2\xd7u\xe2\xbfq\x8e\x8244\x8d\xd7?|\'C\x9e\nc\xd6?\xd5\x85\xc2\xe12\x0ct\xbf\x00\xd7d\xe2\x17J\xf2\xbf\x00\xbfH\xda\xb4G\xed\xbfn\xcf\nd\x00 \x02@)\xa5w>\xc0%\xc7?\xf0I\xce\xf1\xae\x16\x00@}\xfe\xb20\xf9\xaf\xf7?#&\x9eCl\xf1\x04@c\xd8@\x81\x9ao\xc7\xbf+\xd14\x9d\xcd\x92\xe8?\x06\x126\xf7\x03\xd0\xee\xbf\x057M\t\xdcM\xc7?\xca\xfb!\x14\x94\xc9\xf4?q\xa7:\x1ez\xca\xe3\xbf\xbf\xd6\xa2\xa4*\xd2\xb6\xbf\x82*t.\xf5\xb5\xb6?v/\x0c\xc4\xc1\xef\x06@\xe1\xf7\xdc\x8f\x9c\xca\xdc\xbfs\t\xc2\xc8\xa3\x99\xc0?s\x1ae\x1f]\xdb\x00@\xb9TF\n\x15\xa4\xd1\xbf\xe9\xb6\x1b$\xba\xc9\xd2\xbf\xfa\x96\x1eh\xac\xdf\xd2?\x83\x02\xd1\xe1u\xd8\xe1?\x98+\x9a0=\xdd\xed?\xf8\x95Yb\xd1\xd1\xff?\x98Z#\x80\x1a\x1d\xf2\xbf2DrNk\x9f\xdc?\x82\xbe+k\xf5G\xec\xbf\xba\xe7U?Fo\xdf?\x17\x80Jk\xbc\x06\xfe\xbf\x94j\xb7\xdc\x92\xa8\xf7?\xb2H\x91\r\xdf\x0f\xd6\xbf\xf0$\x97qWW\xe3\xbf\x03@\xb9`\xddR\xd7\xbf\xc6\x04\xaf\xa6q\xfb\xe4?\x92*[nt7\xe1\xbf\x83\x9b\xbc;\xc4\x18\xf0?q`\x1b\x14N"\xd2?4\xfd<\x9f0"\xe9\xbf\xbb\xa0\xa9\x82\xc2\x17\xf2?\xedK){p\x8c\xfa\xbf%_\n\xfd\x93H\xec\xbf\n\xfa\xa6\xc2\xc8a\xd0?j\xa6\x85\xc1\xba.\xf2?\xe8k\xb8"\xe7F\xf1?\x96\xf2U*\x92\x0f\xea?s\x80\xd5~H\t\xe1?\xeb\x97\x8cb\xf6\xda\xf6?\xc1c\xba\x89\x0f\xac\xe5?\xaf6\xfe\xd7z\xe8\xe3?\xd1\x8e\xe4 0x\xe0?$\xeaY\xb0\x9fW\xcb?\x90\xb8 h\x16\x96\xf1?\xb4\xb1q7\xe9X\xed\xbf\x98Gm\xea\xee\xb4\xf4\xbf~\xf7N\xb3\x1a\x91\xf9\xbf\xfb-\x0b(\x858\xe4?\xeaCc[\x8cy\xdf\xbf\x19\x9ek\xc96@\xd8\xbfr]\x91\xa0\x15\xe1\xeb?A]\x16Vi+\xcb\xbfG\xe6\xfcyT\x01\xe5\xbf\x90\xd3e\xd4u\x80\xd0\xbf\xc3a-H\xe4\x83\xef?\x12K\xb5^\x8fV\xf2\xbfy\xc1p\x13\xd6\xc2\xf7?i\xf0\xe1;\xa98\xed?)\xa3\x8d\x0bw\x88\xdd?\xb4\t\x1fj \x9d\xc6?m\xf9\xfb\x07\xf6B\xe5\xbfH\xaf\xb7.\x9f\x01\xf2\xbf\xad~$\x95\xbc}\xb5\xbf\x8dF\xd8@99\xe9?\xa2lD\xe7\xb3\x80\xe3\xbf\xd2o\xe0*\t\xfc\xd4?\xca\xed\xb7\n\x05\xd2\xbb\xbf\xbc\xac\xe3\x05\xe5\xe2\xb2?7\x98\x16\xeeK\x8d\xe0\xbfD\xab\xcb\xc33\xd8\xe0?\x93d\x0e\xd9\x9c\x06\xf0?\x9ce?f\x88A\xb6\xbf\xa7\t\xffOS\xc0\xdc\xbf\xd8\xf9\xb2\xe8G\x7f\xeb\xbf[%\x99Y\'\xc6\xf2\xbf\xf5\x0c\x92\x97\x81!\xe1\xbf\xddY\xa6\x91\xa7\x95\xf7\xbfk\x13:5R\xe9\xe0\xbf\x98.5?\x9be\xe1\xbf\x808<\x1bW\xb1\xdb?]\xf2\x17\x89j\x1f\xa1?\'\xbf\x98\xf8}.\x00\xc0\xa1"7\xcf\x98K\xe3?\x87\x9f%\x98\xef\x92\xd6\xbf\x81Ra\x9d}0\xf8\xbf`\xebXK\x12\xa5\xe0?\x87V\xc6\xbf\x81\xfb\x19Qw\x98\xf6?\xf6\x95\x8ef\xf7\x9f\xde\xbf\xb4S\n\x08d\x82\xf9\xbfs6\x0c\xd8\x06\xbf\xe3\xbf\xbdi\xef\xab\xaf\xb2\xdc?b@\x01\x04\x8a\xd5\xe1\xbf\xc0\xe8\r4\x92\xcc\xf1?\x910[\x8e_\xa6\xed\xbf\x1c^\xff\xa4~\xf7\xe8\xbf$\xef]\xa9+\xb7\xe7\xbf\xc6\x1f`7=V\x05\xc0,\xb8\x16-\xa5b\xd5\xbf\x17zY/A\x84\xcb\xbf\xfb\x05\x18\xe1\xac.\xc5\xbf\xc2\xd9z\x05DR\xd7?\xb9-\x93\x86C\x1f\xea\xbf\xaa\xff\x1b\x99Jt\xe3?;\xd4\xad\xf7R/\xd8?\x1ca\x1b\xb5X\xab\xe3?\xaft\xc2_a\xaa\xf7?\x0e\xd5\x0b\xbcT\x1f\xea?8I0.<\xa3\xf9\xbf\x04\xc7\x08\xf9\xac\\\xfe\xbfT\xbb\xc4\xec\xb9"\xf4?\xfdQ\x01\x88\xc0\x98\xfb\xbf\xde\xf7\x17\x9a$O\xf8\xbfb\xb2\xbd\x8f=o\xf0\xbf\xc7\x85\xe6A\xfe3\xad?P!\xb3F\xea\xcd\xdb\xbf\xe4\xe0\x1e\xc7\x19/\xd7\xbf\xfb\x83\x86)\xa4\xdc\xe8?\x11\xb28\xe9\xdd(\x00@\xa6\x13\xf3(\xe1\x13\x02\xc0;)\xb9v\x02\xda\xf7?\xf1\xed\xe1moq\xef?\xeb\xd9\xdf1+\xa4\xe3?\xf3\xdd\x14=\x99\xeb\x9d?\x08]\xbe\xa0\xd4\xb1\xa1\xbf\x96\xab\xf0\xbfpO\xb6\xbf\x03B\xc0\x94\xd7R\xd9?>\x07\x8e\x9d#\x9c\x01@\x84\x97\xbaX\xf5*\xd7?Q\xcc(\x00)h\xe2?\xc5Pw\x15\xd9\xe6\xe9?\x05\x0f\xa8dh(\xec\xbfE\x89\xf0\x9e\x9f\x10\xe2\xbfa\x0b\x11\xca\xb5d\xbd\xbfL\xc5Z\xd3\\\x89\x82\xbf\xd5\xe0\x94\x80\xc9\xc8\xf6?\x87C\x82C\xf3\xab\xef?L8\xe9_9m\xf0\xbfx(\xc5\xf8\xd0\xab\xd0\xbfH\xb8gc\x93\x04\xd3?\x81\xb9\xc4\xb2\xcd\xa8\xcd\xbf\xf5\x8aGNF\xd2\xed\xbf\x03\x18;\xec\xd3\x88\xf9?j\x1a\xcc\x04\xc3\xb6\xb4\xbfd\xb6\xd1\x06\xf5\x1f\xf1\xbf\xabD\x83\xae\xab>\x9d\xbfW\xa9\xd6\xd4\x7f\xe7\xf7?\xcd\xb4\x8c\xd4g\x12\xe7\xbf\xf2\x07\xd5\xd6\x7f\xc7\x99?\xea\xb73\xceH\x96\xf8?\x81M4\xc8\x91g\xf3?rxcR\xdcb\xfc?\xb3\x11D\xbc\x99\x07\x02@"\x90\xee[t;\xf2?\xc8Y\xf7\\\xef\r\xfc?m\xa3X\x85\x16\x80\xee?\xf7\xe8\x03\xd5\x84\xa2\xe0?Nv:\x13\xb5\xaf\xee?\x81\x06\xe3{\x88\x82\xf4?\x1d\xba\xd8s\xc6\x1d\xbd?\x85j\xbb(u9\xd9?e\xd7\x87\x9b\x82\xa9\xf4?\x1f+\xae\xe5\xb0\xaf\xdb\xbf\xf6\xf0\x9f\r\xd0\x90\xea\xbf\xc9\x1d\x05k~Y\xef?i|k\xe6y\x0f\xfc\xbf{\x83\x10\xe5Q\x80\xe5\xbf\xc2\x1c\xd0\x15D\t\xbd?\x86,C\x811\xff\x9c?]\x0cH\'\xad\xd0\xff\xbf\xda\x9f(\xa9\xc2\x13\xf9\xbfI\x95p\x02\xbd2\xb7?\x95\xe5L\x92&U\xe3?\xb14\x0f\xe25*\xf1\xbf.>\x85\xbd6\x89\xec?\xa7)\x9ep\xb3\xa2\xd6\xbf\xff#\x90\xe6a!\xf8?\xba\x98P^\x16\xc5\xe0\xbf\x16\x8a\x1ak\x82\x15\xf2?3\x93O\x94c|\xf5?\x13\xa5\x8b?7Q\x01@\xb0\xbcJ\t\x97i\x00@\x1f\tD\x81#\xf0\xe9?\xc0\xe6\xe7l\x03M\xf2?\x1fr\xcad\xd8\xdc\xe4?>\xb7\xcf\xc0\x947\xe6?\x0e\xae\x0eBC\x06\x06@\xb0\xbe\xddPj\x83\xe5\xbfe\xb6\xae\x1bk\xdf\xbd\xbf5\x8e\xde&c]\xfb?AS\x9a]\xf5\xaf\xe1\xbfV\xe8\xcf\x03\x07\xbf\xf9?3IE[\x16\xa4\x03\xc0\x9c\xcd:&\x8e\x10\xea?\x91G\x03\xf2\xc98\xf1?\x9cw6\xc4\xc2\x1b\xe6\xbfri4\x94m\xc0\xe4\xbf\x14W\xf2I \r\xe5\xbf\xac\n\xb8\xba\xa7N\xe9?!\x93\xea\x98\xe4\xe3\xe4\xbf\xd7\x9b\xa6N\xf1\x1c\xf4\xbf\x18.B{\xf3;\xde\xbf^D\xefA\xb2\xb4\xc1\xbfm2N>bK\xff?U\xf4 \xe3\xf9e\xa0?\xce\xeb\xe7!\xdc\xe9\xca?Dv\x0f\xc5W\x15\xc8?c|\xf5\x11D4\xe6?O37j\xd9\x9c\xf0\xbf\xa1\x12\x95UmH\xe3?\xe7\xaf<\xedu\xac\x01@\x0f\x02\xe2\xcd^\xa3\xc0\xbfI=Qh\xbf\xaf\xfa?\xd8E\x17\t\xeb[\xf0?\x87r[\x9e\xf4\t\xf4?nY.8B\xc8\xdd?Me\x91\xeb\x9f\x84\xcb\xbf,z\xaf\x19\x84\x14\xa0?\xe3\xc8\x7f.\x9d\x97\xf8\xbf\x1fM\x08\x81\xa3\x0e\x90?/\xa3\x15\xd5\x00h\xe3\xbf\x98\x04V,~`\xee?\x8e\xf3]\xb9\x1bA\x05\xc0"\xe2\xd9\x9d\xacW\xf0?6\xb3l_\x86\xb6\xef?\x81\x92\x9b\x95#\xbcw?\x14{\xa1\xc4`\x19\xea?\x0c\xc5\x05\xc7\xf0\xc3\xfa\xbf\xce$\xd9\x83#\x14\xef\xbf\xb9`\xb2bS\\\xa8?\xc1S\x0bt5\xb8\xd1\xbf$\xce\xe8uq;\xdf?I\x9c\xe9\x90\x0e\x8a\xfa?\xe9p`\xda\xbf\xd8\xf3?\x0f\xeb\xee]y \xf0?i!\x04f,\x18\xd1\xbfYo-\x1d"\xea\xb0?\xbeh!\xe4p9\xf1?E\xb3\x196\xf6\xf3\xf6\xbf\xd2\x9bp\xf3Y\xc9\xf1?3\xce}\xb75f\xee\xbf;/\x8d\x15! \xeb?B:\xc0\xda\xbc\xb0\x92\xbfZ\xedSw1\xfa\xf7?c\x02\x8e\x8a\x17\xde\xe7\xbf\x06\xea\xb1\xf0\xbf\xce\xb4\x80\xbc\'z\xd7?\xea\xe0\xbd\xc5MP\xd7?q\x02`\x0b{\xa5\xf1?\x84"\xff-\x97\x02\xf5\xbf(XC\xa1\xc2\xaa\xe9\xbf^\x05\xc2\xee\xd3\x81\xe4?\xfemO\xdb\xb9\x81\xf9?\xa9~\x02\xa6\xe5\xdb}?#\x0e#)\x85\xe3\xe6?i\xa9\x9b\xe0\xcc\xf2\xf7\xbfX\xe9\xe7U\x93]\xea\xbfg!\xdf\xd8Lj\xfa\xbf\xf0\xa6\x83\xb6C]\xd9\xbf\xbc\x9f\xb76\xddi\xf5\xbf\x95\xe0\x99\xa1\xe1~\xe6?\xd0j \xec\xd5\x00\xf6\xbf\xfe\x7f"S\x0cT\xe8?G&w1\x0f\x91\xf2\xbf\xea\x10t\xda2\xf3\xcf\xbf\x9c\x1cR/\t\xe8\xfa\xbf\x1e\xcc\x1b\x9d\xfeg\xf3?J\xd1\x0e\x93\x06\xf4\xe9\xbf\x08-\x88\x07\xe4/\xbe?\x03\x8b?\xdb\xf1?\xe2\xc3J\xbc\xa1\xf5\xfa\xbfQO\xb7\xd19\xf6\xe3?V\x8cM\xbc\t\xb3\xdd?E\x06n0\xec\x18\x03\xc0\xee-Z\xee\xf85\xed?n\xa5\x95\xc2\xa2\x8f\xfb\xbf\x19\x1b\xbe\xce>~\xe0\xbf\x81\xcaV\xa5\xbd\x00\xe3\xbf\xd1XF\xd5\xbc1\xdd\xbf\xbc\t\xda\xda\xed\xd7\xeb\xbf\x10>\xb5\xc0\xc7\xa7\xff\xbf\xd3\xd4\x0fAS1\xf3\xbfQ\xfa\xe5\xfd)\xf3\xc4?-1\xeep\xefQ\xd5?\xd2\xa4\x8d\x9c\xec\x9c\xfb?\xf20htC.\xc3\xbfp\x8b\x04\xd3\xf7\xe3\xef\xbf\x9e\x9a\xf4S^,\x04\xc0F\xccs\xe3\xea\x14\xf1\xbf\x81\x91\x02\xdbAU\xe9?\x94;\xdf\xf7\xb0\xc4\xf8?\xd3\xbb\xa7\x18\x1d\xf0\xda?\xa7.\xb7\x83\xdc\x80\xe1?\x13R\xcb\x0cL\x1e\xd0?9K\x98\x06"z\x00@X\xc24A\xcdK\xfb?\xc5\xebU\x9dWR\xf5\xbf\x81\xb2R\xe3\x841\xe8?\xf7:\xc8\x84\xd2\x01\xe7?]\x1aw\x84\xad\x03\xfe?\xa4f\x0bO\xc7}\xe3\xbf\x85\x96\xb2\x8fK\r\xf3\xbfV\xcc\x07\xec\xc6\xf6\xd1?\x91\xaa+\xf6k\xc2\xad?E9\xb1\x02\xdcr\xe1?W\x1fHd\xfc\x7f\xb2?\xc7\xa3\xce\x9coj\xf6\xbf\x82Y\x04\x08\xfdI\xec\xbf\xfb"\xd6Xo\xd5\xe6?\xde\xfa\xf2|l\xb6\xc0?\'v@\xc89\x8f\xe8\xbf9Z\xea\xeb\xea#\xf2?\x818\x12r*f\xa1?\xcb\xad=G\x04v\xda?l\xca\x90\x93/\xf9\xa2?\xf7\x1e\xf8\xaeDz\xec\xbf-\xe8\x104\xd4~\xf4\xbf\x05\xa9kX\x01D\xec\xbfG1\x88\xa9\xc8&\xd7?\xda!qk>\xa7\xfe?\xed\xbaB\x82A[\xe8?\x8d\x0f9\xc9\xde\xf9\xf1?_(\x9c\xc4\xaaw\xfc?+?j\xe0\x00\xe6\xeb\xbf\xe5P"9\x9d\x1b\xe2?B\xc2\xa9\xd8\xa5\x1b\xff?\xaao\x9c/\xeaw\xfa?\x9b]E\x0c\xe30\xca\xbfi\x9c*\xaa,\xf0\xd8?Z\xd1V`\xd4\xbd\xd0?\xf4e\xf9C\xc4\x12\xf0\xbf\r\xb5\xdf3/2\xf6?\x1f\xd7\xfa\xacA1\xf1\xbf\x8a\x9a-`\xb0\xde\xe2\xbfG\xbd\x98\x04\xd66\xf1\xbf\x9c\xf0h\xa2\xfe\x98\xe5\xbf\x95S\x85gQ\x89\x01@s\x12\xc4\x91\xd7r\xe2\xbf\x8b\x83\xb0\xa5Ob\xef?\x04\x81i\xb3W\xf5\xe8\xbff\xde\xe8\x81Q\xc4\xd1?[E\xaf\xe0)\xbc\xe1\xbf\r\x88\xb57\xce\x0c\xfb?\x1c \x12\xd8d\xe9\xd9\xbf\x98"\x95\xa1]\xec\xb5?\x0e\x94E\x02\x83\xa4\xfa?\x81>\xff\xb5\x06d\xe5\xbf\xddb\x14\xed\xca\x83\xe3\xbf\xa4s\x02\xf2\x03\xd7\xf1?\x85\xa2T\x14\xd3\xe8\x01@>0\xd0\x9b\xeb\x0e\x00@<\x0c\xdc\xb9q\xdd\xbe\xbf\xf8e\xe7B\x03\x9b\xeb\xbfkq\xbaEa\x9b\xf8\xbf\xcf]\x94\x9dz*\xe4\xbf\xdd\x0b\xdaI\x83\xf0\xd3?\xd90\x1a \x00}\xeb?B}\xfatM6\xf1\xbf\x9e\xa1<\x96\xb0\x82\x01\xc0a\x85\xb6\x17<\xcf\xf6\xbfKEhew\xc4\xf0\xbf\x0f(\xaf\xa1\x10w\xfa\xbf^\x90\x13\xe0\x12\x1f\xf3\xbf)/\xcd\rI\xad\xdb\xbf\xf1\xd0f\x8fzl\xe2\xbf\x08\xa2\x06\xa3\xaa\x80\x84?\x04\xdb\xce\n\xa5\x94\xea\xbfir4\x1b\xc6\x1b\xa0?\xdd\x15\x03 Ta\xfd?\x10\x8bT\x04\x94\xbe\xdb\xbf\x0b\x08\xff\xae\xd0\xa1\xfa\xbf\xd1\r\xe3\xbf\x88\xd6\xf6\xbfVVl\xcc6/\xe6\xbf\xafV\xd4\x9aR=\xd1\xbf\xb6`\x0b\xe3\x8e\xcc\xed\xbf\x92`\xe5\xba,\xaf\xa8\xbf\xb7\xd2\xed\x80b\xab\xed?\xd6\x8f\xdf\xa6b\x0f\x05@\xde\x8c\x94$"G\xf1?\xf0T\xabi\x15u\xf8?\xeb!\x817J\xf9\xe6\xbf\xa4\xce\xe9\xb7b\\\xe5?\xfax\x82b\x92\xe3\xed\xbf\x82\x1c5m\xeaB\xed?ZA\xa7\x1d/\x95\xe9?\x7f\xa1\xb8q\xce\xc9\xc1\xbfi\x92C\t\x02\x94\xdf\xbfy9w2\x89\x80\xe4\xbf-\xf3h\xae[D\xf3\xbf_\x1d9s\xea\xe9\xe6\xbf\x92\xb3V\xc9A\x99\xf0\xbf\xce\xbb\x92\xe9\xaf\xc2\xe8\xbf\x04\x07\x88F\x87\x9e\xeb\xbf\xb5L\x83\x9b\xb5\x17\x9a\xbfX\xde\x99\x1cS\xe1\xe9\xbf/\xf9\x94\xfb\x04\xf4\xd9?\xd4u\x94o\xce\xe7\xfb?\x1b\x87?\xe4xa\xe5?\xa7z\xdb/\x94\xef\xe3\xbff\xd0\xe3?^\xc1\xdc\xbfJm\xcf\xda\xb03\xd8\xbf\x11L\x92\xe6\xea:\xdd\xbf=\xe2B\xf2\x9fv\xfa?\xfc\x9fs\x85\x91\xf7\xc3\xbf\xbd\xcb\xaf\xb7Y\x0c\xc2?\xcd\xc7@O\x8dI\xf7?hj\x18\x15j\xe9\xd0?%\xb14\xbf\xd6\xbe\xed?\x94p\x1dg\xda\xd7\xe8\xbfH\xa7b\xc8WE\x82?Ri\xbc\xed\x94\xa1\xea\xbf\xae\x1dM\x0e\x1f\xaa\xf8?%[b\xb0\xeb\x12\xd8\xbf\x9b\x1f\xd4\xc6\xe9\x1f\xf9?C\xcc/-\x99N\xe4?\xc2\x1c\xebb2\x8c\xc6?\xcd\xe3\xdd#>\xe1\xd6\xbf\xf4 \xa6\xa6\xb7\x99\xb6\xbfE\xed4\xaa\x87\xf8\xfc\xbf\xbfTB\xb9\xd2E\xe3?\xb8;\xa3>N\x99\xda?Gf\xbb\xd7\x0e\x13\xf0\xbf\x1b\x7f\xd0\\\x1d\x90\xf3\xbf\xa0\xd4c\xc8\xcao\xbd?\xd9\xf7\xad\xc9\x1cI\xec?6\xc8\x1d\xd0\xbe\xe0\xec\xbf(\xce\\z\x9f\xa6\xe2\xbfe7\xef\xba\x9c\x95\x00\xc0\xf9Y\xa7\x1bd^\xd4\xbfzIhC\xe3\xed\xef?\x02D\x95AA\xc6\xdc?g,\xa5LN\xbb\xa5\xbf\xe3S\xeb\x8a\xa96\xf7?X\xd4\x9a<:!\xf0?\x8f.+D\xc6*\xd2?\x82o0\x8fW\xe9\xf3?\xf5\xf1\x12bi\xdc\xe5\xbf\xea\xda\xce\x128^\xe4?b\'\x8e\xaf\xea\x9d\xf3\xbf\x1f\xf7\xd2\xbf\xe1|\xb7\xbf\xd6!\t\xad\xc0\x90\xdd?\xf2h:)\x03V\xf3\xbf\x8bE\xa4\xd61:\xfd?\x04\x02\xfdh\xfc\xbf\xf9\xbfL%\x8b_\x04\xb2\xf9\xbf\xe1\xa1\xc3\xda\xc1\x02\xc1?K\x98)\xf5\x0b\xc2\xee\xbf\xcf&\xba\n/\x91\xff\xbf\xff\xdd\xbb\xc6\x0cp\xca?\x9b&\xbc\x0f\x90|\xf1?\xe7\x05\xc1o\xaf|\xe2?\xff\xe2N\xf2\xea\x1a\x06\xc0\x90iL\xed\x12"~\xbf\xfe?\xd1\x1c\xee@\xfc\xbf\x0c\xeb\xec\xdc}\xdc\xbf\nh\xba_\x9e\x98\xec?\xfc\x94\xf2\x1b\x7fu\xe5?\x1az?\xc4!\x1c\xcb?\xbc\xc3\xdd\xcc\rs\xe8?\x13\x1bB\x03j\x12\x8e\xbf\x14\xf4\xf51\x91\x16\xef?\xcf\xc2\x04\xf3lp\xd1?\xc6\xb1\x001\xf2\x02\xff?e\xca\x8d\x1f[V\xd0?@\xdc\x89\xe4\x04\xbe\xf3\xbf\xd82V\xd0\x15C\xda\xbf\xcay\x9cu\t\x81\xe7?\xf3\x03\x8a\x17\xb3\x1e\xf8?\xd3\x9f?\xd2s\xfc\xb4\xbf\x8c\x82\xb5m(_\xf3?\n\x1b\x94]4\x17\xe6\xbf\xeb\xda\xfa\xdd\xc36\xaf\xbf\xdeXU\xc6|\xee\xf4?\x00\xaeH\xafh\t\x00\xc0~\xdf3\xdc\xecD\xf0\xbf\x1c\xe4\xf1\xd0\xaf\x86\x01@0+\xcaD}\xe0\xfe?is\xc7\x1c!\x98\xec?\x1d\xa5+\x1e\xef\x88\xf6?\xf9\x05\x03\x95\x02!\n@\xee7\xca\xc1`\xc5\x05@reH\xae+\x9a\x04@Q,\x94l*i\x03@\xdas\xf91\tm\xff?\x97Kwc\xf2$\xfa?\x8aT\xbcE\x9b\xdf\xc5\xbf\xaa\xb1\x95\xb8b|\xed?\xc95\x00\xaaLd\xf5?a%\xec\xa6zs\xe9?E|\xbd\xady\x8a\xe5?\xfbz6\xdc\xb3\x1d\xf8?o\x95\xec\x98\xb7\xc3\xe7\xbf\xd3x\xa3\xbe\x0c!\xf7?\x1ck\x0c\xf3&\xd9\xf0?\xf0C\xbaG\xd2p\xfd?j\xcf\x84zD?\xf7?z\x14\x80\xc6!\x13\xf7?L\x95\x1b\xccW[\xe2\xbf\xdes\xa2{\xfbS\xd7\xbfO\xc4k\x17\xbf\'\xf1?Q\x9au\xa22-\xfb?\xd6\x16\x9aU\xcah\xe6?\xacd\xa8\xc9\x1a\x15\xb3\xbfO\xaf\xa5\xd4HK\xa9\xbf\xcaB\xc3\xf2\x91c\xf9?\x85\x88\x8325\xa7\xf3?\xb0B\xb7\xcee\xb7\x07@\xf4\xe6\xe5"\xf3v\x08@@\xfdE\xa0Gp\x10@F\xbas\xad\x93\x8e\x06@\xc0"\n\xd8\x8bS\xfd?\xf9\xee\xb7\xa4\x99\xa6\xf1?\xf8\xd3\x9b`3\x89\x0e@%X+\xfcK\x96\x05@!Y\xf5q\x7fI\x03@\xb4\x83\x95\x82\xf7^\xde?\xbf\x9d9aU\xc5\xa5\xbf\xf0\xc5#\xca0\x8c\xe1?\x9a4V\xf8\xf2\xec\x07@\x9bs<\xd75S\xeb?\xab^\xde\x8d\xe0\xec\xfe?a\x1a\n\xc6\x1c\x9e\xe9\xbf\n0o\xa4\xee\x89\xd9\xbf\xdbF\xe8\xcck\xb5\xa3\xbf\xb6=^\xc0\x17\xb7\xea?\xa6\xea;\xcd\xf1\x0f\xd9\xbfn\x93o\xc5\\N\xe4?R\x98?5\xa5c\xdc\xbf\x150\xb91\xfcT\xe6\xbf\x866\xd5\xb6J\xb9\xe7?\xd9\xba\xf3\x13*D\x02\xc0V\xf2\xad\xa8\xb1+\xe8\xbf\xb7\xfa\xe8\x04PT\xe3?Jt4\x8e\xeb\x97\xfe?\x94\xe0\xe6Thh\x03@\xab\x82\x0e\xbang\x01@w\xa0(\xa5\xce\xfc\x01@\xae\xebK>D\xed\xe3?w\xd2\x01\xc0\x14\x84\x08@.a7>\x90\x1c\x06@*\xc7\xf4l\x00-\xef?E\x01\x84\xbc;\xc3\xd9\xbf9\xb2pv9V\x00@l\xa4\x93\xef{3\xe1?\xffa\xf7\x83\x87o\x04\xc0|\xc5<\x00\xab\xd0\xfc?\xb5\xde\x1c\x97\xdf@\xf0\xbf\xe2\xb1c\x11*\x86\xe2\xbf\x82\xfaO\x98\xafz\xd5?L\xbd;\xec,\xae\xcb\xbf\xaf\x1e`\xa3r4\xe5?\x03\xee\x02\x0f\x07\xed\xb8?\xef\xf6\x9d\x0b\x05\x80\x02\xc0\xd5~\xb4\xb8\x85\xfe\xdc?\x11\xf74\x1d\xde\xa7\xda?\xbb\x98\x0b6T\x93\xf2\xbf)\xc6\xc0IT\x83\xcb\xbf\xd0\xe8tVg^\xfb\xbf\xe11\x8eo\xd2\xf2\xf2\xbf\x98\x9cC\x80/\xc8\xf2?C\xa8.q&*\xf2?G\x97\x8a\xcb\xc7}\xea?\xd19s\x83gr\xea?\xed\xa7m\xberl\x07@\xb7\xfc\xd8[Q:\xf0?\xfc6\xd2\xbb\xf5\xc9\xf2?\x01\x02\xee\xc0\xe40\xef?\xc3rX\x98\xaaS\xfb\xbf\xef\xbc\xc6\x87\r\x1a\xe3?~\xb6{\xc6H\x95\xbf?\xad\xcc\xb3P\xd2\xf1\xfa?\xa8\xa0KR\x1d\xbf\x07@\xb9\x89\xab\xa6n\xae\xa3?m\xad_"\xf7\xa9\xf8?\xe3\x0e\xb4@a3\xee?\xf2\xd03L\x9ew\xd4\xbf%\xff\x91\xe1\xd6S\xe7\xbfE\xbf\xf7:K:\xb9\xbf\x8f\x1aZP\xe2\xf7\xd1?\xc0f{SZ\x82\xfe\xbf\xfe\xeb\xef\xc0\xe3\xd9\xc3\xbfWy\xa9\x98\x9b\xc5\xe0?lb\xc2\xd4!\xe7\xe7?\x94/\x91q\xba\x96\xf3\xbfU\x9a\x169\xdev\xc5\xbf0\x13/X\xd4"\x03\xc0\xf1\xc3\xcd\xf7\x8a\x06\xfb?\x08xK\xeb/N\xb5\xbf\x9e\xaa\x85\xeee\xc2\x9f\xbfN\x8f\xfa$\xc8-\xe2\xbf]\x17Z\xc8\xa9\x81\x02\xc0\xc8\xb7\x81\x837\x15\xb2\xbf\xd4f\xc4N\xfc>\xf2\xbf\x8d\xb0\xc5\xcb\x1b8\xad\xbf\xa7\xd2\xd3V\x8a\xe1\xca?\x0ei\xc1\x9f\xde\x11\xc8?"o\xce\x8c\xfco\xf2?|\xcf\x99\\\x05]\xf6?0\xd9\x82\xb729\xf1\xbf\xb0\xf3\x8b\xe7s\xca\xf2?\x86\xc1(\xda\xf2~\x05@TR\xe3\xd3\xe8\xe7\xdb?\xb7\x0c\xda\x17\xfco\xd2?\xfd\xc1xk\x0f\x1d\x96\xbf\xc2\xfb\x9b\x87\xc0i\xf5?\xdda\xfa\rm\xa2\xe1\xbf\xce\xc0b\xe3a=\x90?\xbd)\x9a\xed\xf8\xa1\xc1?\x83b\xad5\xf5\xa9\xe7?\xe7{PZH\x18\xd0?t\xa1\x1e\x82H\xe7\t\xc0\xa3\x0e\xb49?8\xc2?\x81\xfa\xbf%\x94}\xa5?\x0e\xcb\x00\xd0^"\xf5?G\x02\xd9:\xf5\x91\xe8\xbf3w\x97\n\xa6\xa1\xe2\xbf\x10\x07\x8f|n\xbb\xf2\xbf\xe4\xd3\xfe?-\xc1j4\xdc@\xe6?x\xcf\\\xd5\x01\xf3\x03@\x97\xfcX\x9e\x10\xe7\xe3\xbf\xd7\xb9-k\xbd\xa1\xd2\xbf\x14\xab\x1e\x9eM`\xf1\xbfD\xb8\xf3\xad\x7f\x1a\xfa?\xb2G\x17\xe1/B\xcc\xbf\x1b\xee\xc9\xe8!\xa9\xbe?\x1d\x98\xa9\xf942\xca?\x12\xd6\x18\xf1\xda\xf0\xeb\xbf5\xfe\x98O\xd8:\x01\xc0\x90\xe8\xe4\x06\t\x99\xb9\xbf\xe0\xf6z\xf8\xd6\x93\xd1\xbf\xfb\xeb\x83\xb13\xb6\xed?s\xd6\xc8\xd7K\x17\xff?X\xdf \xe5\x9f\xd6\xf2?^/\xb0\xd2\xec\x9f\xe1?\xa2|\xec\x7f\x1f\x14\xed\xbf\x15\xd9\x13\xde\xa2C\xf3?\xfe\x96-\xeb\xf8\x95\xe9\xbf\xe1,\xceA6l\xf5\xbf\xc2\xe4\xcf\xc9\x80\xfc\xed\xbf\x18\xdd\xc21\x81#\xd7?\x8d\xd71\xc0\x90)\xf1\xbf0\xb4\xea\xfb\xa7\xb9\xb6?\xbbg7\xcf\\\x1d\xb2\xbf\xc2\x13\xdd\x138\xc2\xee\xbf\xf7\x92\x80\xfbH\xfd\xda\xbf\xc3G[\xbf\x10\xef\xe4?\x87\x8c\xf3\'\xb0\\\xb5\xbf\x1c[\xa0\xc6%\xf1\xe8?\xe6])PSh\xf4?\x1dPA\xbcdY\xd2\xbfn\xd5f\x06\xf2\'\xea?\xb1\xac\xa5\x8d;*\xab?0\x98\xf7\xee\xaes\xf1?\xd6^|\x07%h\xdd\xbfi\x00\xa5\x1e_\xda\xe8\xbf\xa3l\xdd\x17\n\xc1\xd5\xbf\xdd\x01\xc3T/s\x01@\xf9"\xc8\x1e\ns\xd8\xbfbD\xcaa"W\xee?L\xbd\x8e\xeb]\x85\xcb\xbf\t\xba26\x91\x8a\xe1?\x8d/\xe3r&\x08\xf2\xbf$\xdb\xddA\xc9\xa3\xa8\xbf\x95\x05\xda\xe6\xb7`\xbe\xbf\x83!$\x999\xfb\xf0?\x19\x95\';\x82+\xf3\xbf\xcf]\xac\xdeO\xa2\xf2?\x9f\xc0\x9b\x1a\x06\x94\xd8?\xde\xc9\xde\x16Qp\xea?\xbd\x80\xcb\xa9\x01e\xa0?\x1e*\xd8\xa4\xaf\xe5\xc6?m}\xc4<\x1fX\x0b@\x1b\xb9\xa8\xed\xec\xcf\xcb?\xbe\xdb\xe8\xee\'\x06\xc9\xbf\xfe\xaf\x88\'\x9e\xa5\x07\xc0B\x94\x19>d\x8e\xd5\xbf\x8b\x19\xdb\x1aV\x8e\xf2?\xaab\xb9\xdc\xcf\xcb\xf9?\x05nu\xd7\x11\xf8\xdb\xbf\x7f\x80\xbd\x04\xf3\xa7\xdc?|\x8f\xb5\xc2%\xd9\xc8?\x04K0{9\xaa\xe5\xbf".H\x13\xe5\xc2\xf2\xbf^\x1e(\x9e\t\xa6\xdb?O\x0e\xa5s\xb5\xbd\xe3\xbf\xd0\xf4\xf0\x05\xb7\x91\xf3?\x11m\x95L\xe1\xcd\xf3?\xbc\xf5\xb2\xd5\xac\x06\xe5\xbf3u\xa0B5\x08\xe2\xbf\xb1\xe4V\xb5\x1c\n\xe8?\x18\xc0\xdf;\x93\x99\xec\xbf7\n\x10\xcc..\xd6?\xf2\xb3"\x02m\xec\xe4?\xa5\x08\xac\xb7\x14\xe0\xd0\xbf\xc34`!\xd9\xa6~?\xb1\xab\x08\xb8\xc8J\xfd?\xd1/\xaf\xc4\x81w\xf0?m\r\x07q\x92\xb7\xd9?\xec\xb1iA\xa7n\x03\xc0\xe1\x12\xa1t\x94F\xcc?\x83\xe4\x8e\xfe h\x0b@\xc0v\xe0\x8e0\x8b\xdb?,\xb1\x11\xcel \xef\xbf\xf9\x99\x0c\xa3$f\xe7?\xf6\xacx\xfc\xed\xf0\xde\xbf_\x1c>\xcfe6\xd7?\xef\xb1$T\xa1\xb2\xba\xbf\xeb\xe6@t\xfa\xf5\xed?\xbaY\xbdur\x1b\xfe?Z\x9f\xc6\xa9B]\xe3\xbf\xc4\xc9Evr\x1ev\xbf_*\x02\xf1r\x13\xf2\xbf\xe3\xe7k\xdaK\x81\xd5\xbfG\x8c\xebqV\xe0\xe3?\xf9\x0f\xd1;\xd1\x83\x00\xc0Eo\xef(W\xcb\xf4?[#z<\x00s\xde?\x0fE0\xc2\xa6\xd7\xf7?\xecQ\xb1\xe5T(\xca?u\xe1\xf3\xd1GM\xfb\xbfzqy\x88\xceG\xd8?\x01T6\x81\xed\x19\xeb?\xec\xcdoJP\xeb\xc2?e\x9dz~\x18\xa1\xe1\xbfNx7\x9a\xb6W\xc8\xbf\xe3}4\xdee\x1a\xaf\xbf\xd6\xe6Z\t\xb9H\xd3?\xcc\x17eL\xf3\xf2\xf0?\xe6\xe0nP\xe1\x90\x03@\x97\xdf\x9dE\x85\x8d\xe7?\xefdpd6\xff\xd0?!_\xa8\xa3mU\xe8?}\xf4W##o\xce\xbf\xdc\xc6m\x9dK\xa1\xe0?\x1a\xdfI\x83\x87\xfd\x06@=k\xa5Y\xed\x1b\xee?\x0c\xad\xf2\xfe\xcd\xa6\xfe\xbf\x05\xa3\x14\xca\xcdh\xcd?f)\x9dB\xa0\r\xe4\xbf~.{\x16\x0f\x08y?\x08)\xb7\x8dOa\xe5?\xd2-\xe3f\xb6\x84\xf4?\xb8\xaa#\x103\xe0\xbf\xbf\xccTh\xf1]4\xc9\xbf;\x19XIK\xad\xb1?\x8b\x9dx`-9\x02\xc0r\x1f\x07\xa0\xd9T\xe9?a\x8b\xa7\xe1\x13\x15\xe8\xbf\xa2\xcd\xad-\xa2\xd9\xed?\xb2r)\xe0\x7f\x89\xde?\xe0-*\xd8\x80J\xc2?\x11\xf6\x13\xe6\xa2\x97\xc3\xbfh\xe5\x13\x8c\xe7k\xa0\xbf\xc5\x84#m\xe6)\xdc?\xb0W\x84\x9eM1\xf8\xbf\x99+\x87!\xd4\xdb\xe4\xbf\x0c\x91\xd4h\'G\xbd?\xf7]\xf5L\xf4\x9d\xe3\xbf\x94b\xcf\xceO\xd5\xe8\xbf\x025K;\xb1\xce\xde?\xdab\xd1N\xd7\x8f\xd4?\r\xed<\xd5\xb7\xfb\x02@\x8a\xc3b\xfegX\x00@%Hpp\x18\x12\xf8?+E\xb5\xd4\xdd;\xe2?i\x96\xd0\x7f\x9b\'\x81?`tx\x14\x08\xc4\xf5\xbf\xb1\xa9\x8c\xa2m\xff\xd2\xbf\x80\xba\xdb\xf3\r\xf1\xf5\xbfp\xd4\x87\xe1\x03\xc8\xe0\xbfR\xb8\xb4\x95\xc2\x0f\x01@\xe54H\x05\xbc)\xf3?2\x89\x80*\xe4\xbd\xe1\xbf\x9b5\x9ae\xf8\x90\xec\xbf\x97q\\\x1fd\xa2\xdf\xbf\xef\xbdM\x07V\xaa\xd0?\x8f\xc5;\xdb\x08\x9f\xe4\xbfiDq\\\x00\x08\xf5\xbf\xb0\x9c\x07+hA\xf0?\xeb4\x17\xf9\x91b\xea?\xc6\xf0\x0b\xfb?\xb1\xe1\xbflB!7\xc4}\xd5?\xb5\xcb\xaeM\x82\x1c\xbc\xbf1\xb7v,v\x03\xf9\xbf\xab\x14\xf2\xf9f\xf5\xdf?&\xa7\xe5L\xbfX\xe4?\xc0\xc0J!\xd2\xc2\xe9\xbf\xce\xee\xe7|\x82y\xf9\xbf\xec\x97\xc0g\x1e\x1a\xe9\xbf\xa9\xd0\xf0U\xff2\x01@\x17\x9e\x04\xd7\x80\x81\x05@\x00D\xfcT\xb64\x14@\xc5\n\xd1\x85\xdaj\xc4\xbf\xa4\x98\x93\xf9\xed\x1b\xe6\xbf\xe2?\xff\x1f\xd0\xd1\xf4?3^\x94\xa2\x052\x8c?\xd6\xd3\x87U&\xa0\xd8\xbf\x97>\x94\x07\x90\xcd\x8a\xbfv\x13\x11K\xc6\x14\xec\xbf\xb1\xb0\xd9\xde\xf7\xa2\xfa\xbf\x03\xaf\xcdx)J\xfc?\x95\xdd\xd7\xf1\x10\x01\xdb?\x13\x14\xea.\xcc\xcc\xe5\xbf}v\xd53+\xf0\xed?TR\xdcY\xab\xba\xda\xbf\x87\xe1\x1ba\x01\xa1\xd8\xbf\xa8\xa1M\xf0: \xd5?R\xf2\xc9\xe6\xed*\x00\xc0\xa1:\x99\xf9\xfe\r\xd8?\x1dY\x04\xe1\n\x9c\xdd?GJE\x8a#5\xa4?&\xa6\xdan\x02\x03\xe7?J+\xe5\x162\xd9\x93\xbf\x84tJ\xc2j\xdc\x9e\xbf\xc61,\xee\xb9\r\xed\xbf6\xb4\xe4\x06O\xd1\xf6\xbf\x08\xe6\xfb\xd6A\xcf\xb0?\xef\xac\x05$\xeb\xee\xe6?vhX\xb6B\x10\x14@X\xe2\x0b\xe5\\\xf0\x08@\xe6>\x0eH)]\xa9?\x90=N4\xeaw\xc4?]aJM\x8d7\xcb\xbf\x90\xdb\x11p\xffK\xdb\xbf\xd3c(t\xd5\x1a\xd5?\xd0w,@p\xd7\xc3?\x0e\x1c%\x96\xf7K\xe0\xbf\xd2\xfb\xad\x8e"q\xed?\xabV\x918\xf1\xbf\xe9\xbfH\xadK\xb3\r1\xb6?\x82A\xa4\xd0\x8a\x80\xdc\xbf\x84\x89zWT\x19\xf0\xbfs\xc7X\x19\xa1\xf0\xf6?a\xa4\xeb\x84\x19A\xbd?Qz0\xe3\xbe\x06\xdc?\xf2z\xd7\x00c\x1a\xe1\xbf\x8a\x19\x0b\xb0$=\xf1\xbf\xb0\xc4\xa4\xd0I\xac\xd9?$\x88\xdd\x91\xc6t\xe0?0\x8b\xa2\xda\x8a,\xe4\xbf\'w\xab\xc7Hi\xb2?\x18\xdf\x8f\x0bC\x84\xe0?U\x90\x9e\xab L\xf0\xbf%2\xc1\x10\x87\xce\xf5\xbf\xaaF&VJ\x9e\xe9\xbf\n\xd6\xadX\x9fc\xb6\xbf>\x08\xbcU\xec\xe9\x0e@Li\n\xd5O\xb8\xf4?W#4}\x90\x9a\xf0?<\x02\x1dD\x9b\xe1\xed\xbf\x89\xf2>\xd2\t\xdd\xe5\xbf[\xee\x0c\xe9\x06\x08\xf0?\x8e\xd5\x05\n1\x97\xf4?\xcf\xce\xf9\xed"\x8c\xea?\x05*\xa7.\xef5\xf4?p;\x96\x8a/\x9d\xb6?-\x0eMJL\t\x01@\xf7\xd0\x12\x1d\t\xa4\xc1\xbf\x04\xea\x0fc% \xde?>\xbb\xed\xf7\x9f\x95\xf0?Q#n\xb3}\xc4\x01@\x8d\x97\xfa\x872*\xe1?%\xf6\xbf\xefw\xf3\xc3?_\xc0\xc2\xef\xd9\x92\xea\xbfw\xe9{L\xc7\xf1\xfc\xbf\x8d\xfb-=9\x8e\xe2\xbf\xd1,y\xdc~\xdb\xfb\xbfb>\xf3Th\xec\x95?\x99\xce\xd3\xac\xe3\xad\xd2?iu\x81P\x18\x02\xee\xbf/\xea\xe5\xc2\xe7^\xde\xbf\xb5\x8b\xdf\x91\xad#\xd6\xbfe\x04NZq\xf9\xe8\xbf\xd6\xb9\x9e\x97G\x0c\t@\x9bX\xcb#\x94l\xfd?\xc6\xc5\x10\xa65\xb8\xfd?g\x06z\xdc\xe8\xba\xce\xbfav\x90/V\xdf\xdf\xbf\xab~\xf0\x1d\xa3!\xe6?\xb0f)\x92\xf6\xa8\xe8\xbf\xe1}(\xfa.\xc6\xf3\xbf\xfa\xcb\xcaf\xa1\xad\xd6?\xd2\xcc\xcbv\x9b\xc5\xcb\xbf\xa0\xc5\x19_^\xcf\xf7\xbf\xeb\x00K\xba\xad%\xd4\xbf1^\xd9D\x9a\xea\xe5?\xdf\xc7\xbfe\xfbb\xfd?\xb4\xf3>aQv\xa5\xbf\xd5\x8bI!l\xa9c?\'\xdc\r\xfa=,\xe5\xbf\x89\x13\xc8t\xad\x02\xd6?g\x1e\x1c\x8e\xddA\xd7?5\xb6m\x12#K\xf8\xbf\xc1W\xcf\xa1W\x8b\xcb\xbf\xdcY$\x0c\xf6\xc6\xf4\xbfI\x9e\xbc^Yo\xea?\x95\x93\xb5\xdb8\xd8\xd1?\xa0\x17q?\xfeY\xea\xbf\xf9Q\xa0\x8d\xab\x94\xee\xbf\x05V:\xf500\x06\xc0h\x10\x12\xde\xeaT\x00\xc0\xc2\x1c\xa2\x19\x8e\xf7\xe4?b\x1e\xf9\x997\x14\x01@\x9bO\xca\x01\xf8\xfa\xf3?\t\xd6L^\xb8\x8d\xe1\xbf\x05\xa7.6\xaa\x9c\xf0\xbf\x80\xbbBP\xa9\xf4\xf4?\xc1\x19mQs\xb8\xe2?\xa8\x19\xfe\x01\x0ct\xc0?\xd6\x19\x03\x7f\xd1\xfd\xd4\xbf\xea\x8f\xc9\x9e\xe10\xef?\xdb\x9c\xfc\xa5\x04\xd9\xf0\xbf\x06\xbb\x9d\x91\xbf\xcb\xf6?\xcb0g$Uj\xeb?\xc78\x7f\x99.4\xf6\xbf\xee\xab\x86\x18\xa9;\x01@\xc4n\xf7W\xa0\xd3\xdc\xbf\x0f\xfesx*\x91\xef?l\xc3^b\xe0`\xd0?p\xfa;\x12\xe4\xaf\xf1?<\xf3`\xe0Sg\xee\xbf\xb0\xdd\xb3*E\x82\xa3\xbf|\x03\x83\xba\xfb\xeb\xe7\xbf\x04\x8f\xa1\xc4%\x9c\xf4\xbf\x04\x06d\xb8{R\xe0?\x89\xcd&\x8b\x1e\xda\xf9\xbf\xc8\x83\x85\xed<\x80\xb9\xbf\xc5\x02+D_\x11\xfc\xbf\xce\x18\x06\xfaO:\xb1\xbfy\x829\x02\x0cj\xeb?\xdb=GP\xcd[\x0f@\x19\x0e\x10T{_\xf2?_\xb6i\x9c\x8e{\xe7\xbf\xf5\x9a\x87\xb9{*\xdf\xbf \xc0\xe3nP\x8a\xe0\xbfq\xb9\xb6C\xb0\xdf\xe5\xbf\x92T\x8a\xbe\x0e z\xbf\xc9:\xaf^\xee)\xfa?\x03\r\xa6\xb6|~\xd0\xbf\xb1\xfep>h\x87\xf5?\xae\xc0\x17T\x13\x83\xfa\xbfT\xfe\x8f\xf9\x0f\xb2\xba\xbf6\xb2F \x1bH\xed?\t\xb8\x00\xe9\x18\x19\xfd?r\x98\xfee\xbb\xd8\xd3\xbfLo\xc8,e<\xfd\xbf\x9d\xfc\xf8P:\x99\xee\xbf\xfb\x14)\x8a\xa0\xc1\xe3\xbfa\x86\x06\xb2d\xed\xd8\xbf/\xffqg8\xb0\xe4\xbfO\xda\xce\xf4\x88]\xd6\xbf\x1f\xc2?N\x8bY\xf9\xbfg?\xeb,+\x17\xe1\xbf\x992\xbe=\xeb\xaf\xe1\xbfz\x91\x93\xbd&\x06\xde\xbfR\x1dR\x9ds\xfc\x06\xc0\xf3\xce$\xc8\xda>\xe3\xbf\xb1\xca\x91\xca\x0eL\xff?U?\x15\xbe\xc80\x08@\x98\xfc\xd9a\xa4\x1d\xd4?\xb2>\x0bF\xecT\xfb\xbf\xe819p\xb2x\xdb?\xdd\x80\xb1e`\x02\xd3\xbf\xd3\x12c\x8f9\x85\xf1?M\xa9\x16we\xe03?\xfcvI:kh\xff\xbf]\x13\x9bz\xbe\x17\xe2?L\xf2\xff\xa9\x8a\xbc\xc8?\xdd\x14@"\xc4\xb6\xe4?\xdd\\\x13B\xe4J\xf1?$\x89To\xee\xbd\xbf?\x0c\x80\x91\xf0\xb7\xae\xd0\xbf\xdf\x9b\x99_\xc9M\xe3\xbf\xe0\xedJ\x86\x19u\xf3\xbf\x08\xfc__?\x0e\xe5\xbfS\x00\x10\x12*0\xeb?+\xe3\xc0\xf5l\xc8\xea?\xe1\xf0 \xfb\xff\xc5\xfa?\x92\xa7\x8b\x87\x9d\x08\x02\xc0\xc0\xec\xa7\xa4\x1c\xda\xf3\xbfu\x1d^\xf6Tq\xf3\xbf<\x8a\xc8\xa7\xcd\x90\xce?\x1e\xfc\xa6zf5\x01\xc0\x98\x8e\xdc\xf5\x8a\xd5\xd8\xbf3I\xa7.\xec\xd7\n@1\x93B\xc2{\xf8\x13@\xd8|T]\x04\xa2\xf9?f\xf5>4$\x98\xe9?\x9ei\x18^Y\x03\xef?w\x9a\xbb(v\xe2\xeb\xbf\xcbD,\x15\xc3\xc6\xd0\xbf/\xc6\x07V._\xe0?\xc0s\xe5\x81\xb2\xf2\xb0?\x1d\xbf\x1cF&f\xf2?6\xb2\x04P\xe6\xfc\xe8\xbf[\x9f\x93\xdf\xbb\x88\xf5\xbf\xf2\xafX7_S\xec\xbf\x14\x15@\x85\x04?\xef\xbfu\x8eC6P\xbf\xe3\xbf\x00U%T\xbb\xfcs?EY\xd6\xc5-\xff\xf1\xbf\xe6\x0b\xd4#\x0f\xcc\xd3\xbf\xd4c\xa4\x18"\x93\xea\xbf\x84\x1c\x83\xd6q\x0e\xdf?\x93\xff\xa5\xf5\x11\x0f\xc5?\x0f\xe7aH]F\x05\xc0Gn%\xfd0\xb6\xff?[\xa3\xec5\xaf\x99\xe4?x\xa6\xe3\x1ej\xd4\xdd?\xe6\x18\xc0L\xc2\x13\x06\xc0E\xd2D\x15m\xf0\xe4\xbf\n\xfe\x05\x00\xd4\xa9\xe6?\xb9\xe7\x11\xfd\x99\x05\x01@\xb6\xdb\xab\x82\xf8Z\x07@\x96|\xb9_!\xff\xe5?\xfb\x1bYPG\x83\xa0?\xf8t\xe4Sc\xfb\xd3?\xd6_\x07\x1f\x8f\xe7\xe2\xbf\x0f\x81\xb9\xec\xb5\xd5\xf2\xbf\x1fj\xd9*\x0b\x15\x01\xc0\xf4G\x91B\xf7\xb5\xea?\n\xeb]\x1d\xb0\x05\xd6\xbf\xb5o\xf2\x83&\x97\xf9?\x05\x84n\xac\xc1>\xda\xbf\x903\xde^t2\t\xc0\xbf\xa4\x81,\x85\x94\xd4\xbf\x8b+h\t_f\xe2?08\xa2L\x02\xd3\xf1?\xc3\xeb\xa2PL\x86\x96?R\x9b\xabY{\x07\xd7\xbf^\x98\x12\x89\x1f\x88\xb4?\xc3\xd9-\xad\xfd!\xd0\xbfX\x07l&\xcd\xa8\xee?\xae\xce\\\xcc\x03/\xe4\xbfp\x93\xd0\xaech\xe1?\xe1\xbaz\xbf\xa6\x87\x04\xc0\xfbH\xbf\x88\x16\xf6\xe1\xbf\xae\x06\x7f\x00M\xc2\xe6\xbf\x1b\x94\xa9v\x16\x8a\xd3\xbf\xc7\x7f\xd4\xcf\x8a\x98\x07@\xd9\xfd0\t\x1a\x16\xfa?\xb2m\xbb\xee\xea?\xfa?xK\xa3\x99\x94\x84\xaf?\xed\x96q\x0f\x061\xdf\xbf\xe3\x12\x81*\x8e\x9c\xf8?\x1a\xac\x9b,\xe2\x14\xd0\xbf\xec\x19\xa7(\x9d\xad\xcc?\xe2R0A\xfa\x9f\x02@\xef\xd9x_\xbb\x10\xd4?\xa5V\x8f\x04G&\xf3\xbf\xeax\xacT]\x9c\xff\xbfkh>\xe5\xf6\xef\xe3\xbf-F#\xcd\xb2\xc9\xc1?\xf9&#*\x13\x95\xf0?F\xce\xafH\xec\xff\xe5?a~\x98k+)\xab?\x9d{\xc3~5T\xeb\xbf\xe8\xc5I;\xb0\x87\xf4?=\xc0\xef.\xcb\xd3\xfe?h\xb9\x0e\xd6`%\xe2?\x929#o\xac\xcf\xb1?X\xc7\xd6-d\x0b\xf8?\x1e\xd4l3# \x03\xc0{\xc9\x02\xf7\xf3\x91\xd1\xbfQ\xd5\xa3\xb5\x17v\xeb\xbf\xcd\x12\xa3\xd4\xa8\xa5\xc4?\xe4,\x1e^\xcdE\xbc\xbf\xf6\xafb#WM\x07@\xdc\xc6\x1a\x06\xda\'\xff?\xfb\x0f\xa7\x81,|\x1c\x93\xdc\xbf\xe3K\xca\xabm\xbf\xf6\xbf\xe0\xab\x0b.\xf61\xb4?\xce\xd6\x1a\x9d\xee\x85\xc8\xbf(\x03!~\x9fR\xea?\x9f\x93\x04\x08\xa0\xc5\xd9?\x84\x11\xf3\x9dt\xc7\xeb\xbfQ\x1a~,\xc6\'\xd1?\xe1\x8bw5\xbd=\xf2\xbf\xc9\xbc\xc8(\x88w\xe7\xbfN\xf2\xc4\r\x17\xa3\xdd\xbfW[\xca\xc8\x90\xd2\xf0?+e\x8a$8\x0c\xd9\xbfP\x9e\x08\x133\xea\xe5?\x9e\xbe\xd1\x85\x8fM\xeb\xbfS_\x16\xb7\x81\xac\xdb\xbf\xe6\xb0\xbc\xa5\x06\x87\xea?D\xd0/\xb0\xf1\xf9\xb6\xbf\xcb\xcf\x0e\xb5\x91\xd2\xd6?\xab7\x1f\xcc\x8a\x86\x0e@>`\xd0\xc9\xa6\xfd\xfc?B\xa4\x9d\x00\x18\x93\xfd?\x06\xe3v\xb5\xca\xc3\xf4\xbfOqR\xf7\xf5\xe2\xe6\xbf\xac\x96\xdbgc\x8b\xea\xbf\xb6\x1a^\x17\xfdH\xd2\xbf\xa0\xc7\xa7%\xc5\xbe\xff\xbf\xe1\xabtY\x0f\x05\xcc?\xf2\x11\xe3m\xd8\x0b\xdd\xbfE\xcb\xec4\xa4\x05\xed?\xea\xf6\x19\xdb\xcc\x89\xd7?\x08\x1f\xa7_\x82\xa2\x01@FO\xb4@\xffz\xe6?\xbd\xef\xba\xb33\xda\xd5?\' Q&\x0f\xc3\xf8?\xdd>\xecA\xe9\xe4\xf1\xbfD@\xc0X\x15v\xd8\xbf\xa3\x01\xa0\xca\x8cY\xe8?\x93\xc2\x84\xef\xc9\xfd\xce\xbf\xce\x86\x97\x10\\\xd5\xdd?\xaf*\x00x\xbc\xe7\xf9?\xa5j\x04\xf1\\\xb7\xf0?\t&\xc9S\xb8\xe6\xd1?\x00\xb0\xca\xba\xb81\xda\xbf\x96vyv\xa0\xd1\xb4?\'\xea\xb3\xab\x87s\xed?\xe1\x89\x12\xe2o\xbb\x02@\'\x1b\x1a*\xe3>\x07@\x8c\xad\xed[\xd1\xe5\xae?\xd2\x8dI\r\x8a\xfa\xf3\xbf\x84a\xc4>\xec\x92\xcb\xbf\x13\xcc#\r\x14b\xe5\xbf\x84\xc3Z\x9b=\xc6\xe1?l\x9bk)N\x0e\x8f\xbf\xae\xd8\x11AY\xae\xf6?\xa0`\xa2\xa0\xea\xdf\xa7?\xacm \x97"\xc3\xd9?\xc5\xd8)\xa36)\xb1?\xaf\x12\x134\xb3\x92\xd1\xbf\x96v\xd5\xba\xdd\xea\xd9?\x1e\x83o\xa9\xc7\x99\xe5?h\x9c\xbc\xb0\xab9\xf4\xbfL.\x16j\xe2\x1b\xf9?\xa5\xdb\xe5\xc8\x869\xec?w\na[ .\xcd\xbf\xd9\xf0\x87\x0c|\\\xb8\xbfhA\\m[\xb9\xf9\xbf\x97\xe4~\x9fM\xa9\xf5?NA\xd9gq\xf6\xfc\xbf\x8d\x18n\\_\xeb\xf1\xbf>a\xc6\x00\xde\x0e\xc0?\xc8\x8c\x82\x9eW\xc9\xf5?\xbe\x0b\xd2\xb0\x89\x14\xfb?\xc2\x84k\xddJQ\xd5\xbf\xec\xa7\xe2?\xb8\xeb\xfc?+\x04\x1e\xfa\xbf\xfd\xdb?eK\x0f\xc01\xbd\xce\xbf\xd2\xd5n\x1b\x8f\xd6\xee\xbf\xdcn\xe8\xa2A\xd1\xe6\xbfV\xa0\x9c+\xb4\xed\xe8\xbf=\xd5\x96/\xa9\x1a\xd7\xbf\xa2\x84R`\x84i\xf8?\xf06\xb0g\r\xda\xe2\xbf#\x1b\xb0\x80\xf3\xe4\xc6?\xcd\xe5R\x8e\xdb\xcb\xd1\xbfW\xef5U\xe2\x00\xc8\xbf\x88fb\xf5\xb4\xf0\xc9\xbf\xbf\xd6E\x0eh9\xd6?\xde\xac\x90\xf1M\xbf\xe4\xbfV\xd4\xdb\xd0\xd0`\xe2\xbf\x14\xff\xd9\xf0\x8a\xa1\xe8?\x88\xeb\xfd\xb5@\xdd\xf7\xbf\xdd\xd3<\xc9\xe5\x92\xec?\xeb\xdcu\xf8n\xa0\xb5?\xb7\xdfl\xd1\x19\xa2\xcd?\x80\x10\xb6\xea\x16\xc3\xe8?F\x8c\x8bb\xdc\xcb\xcf?\xf1\xcb[\xaf\xdc}\xd3?\xc2\xbb^\xec\x90\xa2\xfb?\xf71C\x0eV\x81\xf0?)\xba?t\xbdh\xe5?\x9b\x13\x7f1\xbfi\xf1?\x1d-_+4O\xf2?\xb7g\xcf\xe8\x96\xcb\xef?\x8f\xd3\xbc\xa01\x83\xe9\xbf\xc3;\x19\x9b\x0e\xf6\xa0?\xdb\xab\x95\xf1a\xba\xde\xbf\xa4\xbd\xe0\xe3-\xb0\xe0?<\xc2\x1e-\xcf\t\xe0\xbf\xc7\xbe\xa4\x9f\x17\xf1\xbd?t\xad\xba\xeb+\xfc\xb3\xbf\xfc\xa3\xa0\'\xfes\xe3\xbf_\xbc\x11\r\x0c\x85\xd7?C\x83\x9e\xfb\xf9U\x05\xc0C\x7f\xa1u\xf0H\xef?[:\xa3Q\x94\x89\xed?\xf1,\xc7\x1b<\xe1\xea?\xd8\xcd\xc4\xa5d\xbb\xec?\x10\xc0&\xd1\x89\x99\xe0?]\x80\x8c\x00\x809\xf1?\xf8&\xf1q\xac\x0e\xf1?\xc0!\x9c\x87\xdf\xe0\xd5?\x11[\xa8\x7f\xfa\xc6\xee\xbf\x95\x86\t\x9b\x96\x1b\xe7?\x07\xe6\xc3GG\xef\xf0\xbfi\xc8\x86\xbf\x12O\xd2?\xda\x8d\x96,\xdd1\xd8?$m\x9c\x12\x90\xc0\xf8?\x9ay\x7f\x0bh\xc6\xf6?%r\x14\xf8\xc0\xb1\x02@;j\xa7\x15\xaf\x82\xf5?\x05I\x0fP\xb7\xde\xc6?P\xe2Xh\x8f\x1e\x03@\x9d\x80T\xcb:\xb6\xee?\xb7\xca5Wcd\xa3?\xa9\xf9\xe2s]D\xea\xbf\xf4\xcdv\xab\xf1\xdc\xc6?\x9d\x0c\xa1\x81\x9bm\xe6?3\xfb9\x8c\x88)\xc1?\xf6\x9e\xa1\x0b6D\xdc\xbf9F\x17\x83\xc2\x10\xf3?b`1\xd8z-\xef\xbf\xef\xe1w\xd1\xee\xbe\xe1\xbf\x8e\x95"\x15e[\xf9?\xc3L\x98\x033\xd6\xea?$\xf3\xb1\x8d\x8a}\xb6\xbf\xa8,y=\x1b0\xf8??\xce\xcc\xea\x96_\xd6?\xbb/\x00\x9c\xbb\x1b\xf1?\xe4r\x13\x0fy\xcd\xe9?\xd0\xfa\x1f\xbb\xfc\xa6\xf2\xbfPG\xed\xb3\xc1\xbf\x12\x8a6\x80\t\xb1\xf9?\xf7\x90@\xec\xb1t\xe6?\xadF\x84\x84\x11w\xcd?\xec\xe2\xd3\xc8X\x81\xc1\xbf@\xe8\xa6c#\x84\xf6\xbf\x1a\x02b\x9f\x7f\xe5\xf8?\xad\x9bDa\x00\xfc\xde\xbf\xabZ\xc8:\x18\xc6\xe6\xbfQl\xec\xc2\xf9\x92\xe4\xbf\xd1\xc3|0*\xdb\xef\xbf\xaa\xa9\x02Om\xf5\xed?\x1d\xd8\x87"f\xd9\xd9?\x0c1\xa4\x1a|2\xc1?@\xe0\xcbR\xc7\xd9\xfd\xbf\x9ev\xaa\x0eh\x90\xe4\xbf\xfc\x00\xc7\xe1_\x13\xea?\x83\xcd \xde7}\xa3?\xbdBg\xbf,\x11\xe8?f}\xb7M\x08\xc6\xb8\xbf\xa0\xca\xd0=\xb9<\xc3\xbf\xf9\xa9\x7fb\x18|\xdb?O\xbd_\xaf<\xd5\xf7\xbfA\\\xc3Z\xee}\xe5\xbf{\\\xe5\x0b\x0c\xfe\xc0\xbfvzs\xf0c\x04\xf0?\x8d\x950yZ\x1d\xcf?\x99\xb9^m+\xe5\xff?\xbbB7\xc5%\xff\xec?\xc0g\xc3\xc9\xcal\x03@\r\x07\x96A\xa8q\xf5?>w\xed\xd8\xa1c\xef?\x87\xa48(\xb1\x1c\xd9?"\xb4\x14\xa6\x9e\xd7\xda\xbf*Q\x9aB!\xa6\xfb\xbf\nB\x0f\x81\xf0\x0e\xf4\xbf\xf05\x9e\x17\xa4\x82\xeb?\xfe\xa6\xb5K\xad\xfe\xe6\xbfzy\n\xec\xc9y\xeb\xbf\x1fd`\xc2\x81V\xeb?\xd7\xbbn\xbb(\xc7\xf8??x"})L\xe0\xbf\xb5\t\x12\xd8\xd3$\xdf\xbfK\xca\x9e\x14\xa6\xcd\xed?\xc1\xeas\x8f\xee\x8f\xe0\xbfU\x90\xbe\xc5\xa7\xe7\xf4\xbf\r\x83\xe3\xce(\xf9\xf3?>)\xebNgm\xf4?\xb1\xe8\x81\x87\xe6\xbc\xd5\xbf\t\xb4u\xa6\xbd\x18\xf7?\x9d\xd72\xff\x92\xfc\x02@\x9b\xa2\xc3l\\\x1b\xe0\xbf\x89\x7f\xdb3\xdex\xef?\xe9a\xca\xf4\x84\x16\xe7?\xf4s\x1e\x90\xe7\xbb\xe2?G\x82\x91\xaf\x87\xc6\xb6?!o"\x8bD\x14\xf1?\xb5\rUem\x1f\xe5?\x0f\xe8\xd8\xc5M\xa2\xfb\xbfVoc\xc0\x8b\xff\xf1\xbf0\xb1\x1d\xc8\xf6x\xdc?b\x04l\x99\xef+\xe3?\xba\xb9\x81\x1a\x15\x08\xed?8d\x87\x93\xfb\x84\xeb\xbfU\x00\x93\x1c\xb2\xb3\xf0\xbf"\xcb\x15\x8fn%\xd6?7\xd5\xc3\x9d\xd1\xdb\xf2?k\xe2\xe1\xb6\x8ca\xfc\xbf\xe6\x88\x08\xae\x19\xe3\xe0\xbf\xfdo\xe2Ps\xd2\xde?W\xe5;/z\x83\xf2\xbfK\xe9`+gN\xeb?+Q\x1aV\x89x\xdb\xbfOI\xf9\xa6R7\xcd\xbfx9\xf7\xd1\xce \xc1\xbfp\x92\xc5\xa7z\xfe\xee\xbf)n\x86\xef\x0f\xa6\xe0?\xdbb\xf9<\xa3\x82\xfa\xbf\xdb\x8d\xa0k\x9c|\xfe?\xec\x99K\xf4\xc4\x85\x06\xc0\x92\xb3\xd5\xe2\x07z\xed?uq\x88\x1f\xa1\x08\xae\xbf\xcfe_\x80\xabJ\xdd\xbf\xc91\xe2\x95\xbaX\xdb?\x86Jl\x04\x88\x04\xa7\xbf\xe4\x82\x93YN]\x03@\xb3\xd8\x19\x1e}\x81\xfc?LB\x1d\x160{\xe0?\xb5cA\xa6dG\x85\xbf\xda\x99\xd9\xf2.X\xdd\xbf\x1a\xd7\xbc\xf2\x81\x85\xcc?\xce:#\xde\x91\x0c\xfc\xbf\xc1\xa9\xaa,\xbdu\xdb?\xad\xf4\xc6\x87\xacG\xdb?\xb1\x0f\xce\x12\xab\xb1\xfc?c\xdf\x99\xc1\x8a!\xf3?\x8d\xc5M* \xcf\xa4?\x18\xa2\x7f\xdb%}\xad?\x1bqs\xd45\xf6\xf9?\xc0\x0e6|6\xba\xf3\xbf\xfe\xdf\x18\xe2\x04\xa9\xb9\xbf\xc6^`a\xc2Y\xf0?\x9df9\xcf\xe5s\xd4\xbf\x1a\x1c\x9dq\xf0\xd7\xe0\xbfmO\xfa\x06\x81s\xea\xbf \x02\x0c\xab\xf6\x81\xed\xbf\x0b\xb7\\\xfdy\xcf\xee?S\x08^|D1\xe5\xbfAqJ_q\xcc\xf2\xbf\x9e\xb8\x1f\xa2\xe2j\xe1\xbf\xa5\x1a\xab\x1e\xf2&\xf5?b\x14V\xdc\xaeN\xef\xbf\x08h\xc9\xc0\x8cQ\xec\xbfH\x13\xec3g\xe2\xfd\xbf\xc6\x1e\x08\xc2\x01\xe7\xf5\xbf\xef\x9ab+\xba_\xb2\xbfL?xe\xd8\x85\xc3\xbf\x8dM\xe2\xb5Z\xe7\xf1\xbf\xa8\xd5Wk\x92\xf1\xcc?$\x11g\xe3.\x18\xd6\xbf\x13A\\\xc0\xf8\x97\xeb\xbfo\x94#\\\xa8\x80\xda?\xc16T\xab\x14\xb2\xdc\xbf\r^\x19Bq\xb1\xf5\xbf\xaf\x1e\x88\xde2@\xe7?\x8f\xb7\xa8.9\x83\xe1\xbf\xa7\xab\x8f\x8c*0\xf3?ckw\xe9\xc0$\xbb\xbf\xc91\x9b<\x9c\xb6\xf6?Xu\x94\xdd\xc1\xfe\xe0\xbf5\ng[\x907\xf7?DR\xb3\xfd\xb0&\xd8?\xbf\x8c!\xbb\x1a\x01\xd4?v!\xe6\xc9\x1d\xa2\xe2\xbf\xdd\x9c\x90\xbd>\xa3\xf4\xbf\xdd\xca\xeda\xd9\x9c\xfd?\xf4;8<\x1c\x8c\xfe?\x90\xb2\x93\x7fh\xfa\xd1\xbf!\x1d\x0fL\xc8Q\xe5?\x0e\x96\x85\x8fB\xa7\xe1\xbf\x80)\xbd\xb1\x98?\xfd\xbf\xae\x8c:\xf6r\x1d\xe7\xbf\x8f\xdf5rH\x81\x00@\xa9g\x1eH\x9f\xf5\xdd\xbf\x0cff-l\xda\xf1\xbf\x83^#L\x8cj\xe3?O\x87~\xb8\xd4\xbc\xe1\xbf\r\'\xca`\x8e\x1a\xd6\xbfM\xef\xc5\xcf\x80\x96\x00@!\xda\xc8zoa\xe3\xbfPq\xfe\x94\x17\x82\xa1\xbf\x9f\xa1\xbf\xdb\\o\xf0?\xe9S7\xfb\xc6C\xfe?\xcaC\xd3\x93R\x8b\xd8?\x87\xf3}\x00\xa2(\x02@p\xc2 \x9a\x97=\xce\xbf\xfe\xbb\x9f\xe9\xdd\x83\xc5?RVP\x91\x81\x82\xfd\xbf\x96Of\xd7\xa4\xff\xac?\x93S\xe6\x07\x8cN\xff\xbf#\xf7s\x9c~\xef\xfa?\xf9\xd1\x90\xb3\xa5\xd8\xee?\xda\xf0#\xf7\x16\x1d\xf7\xbf\xef\xa8[\x9c\xddq\xf3?\xcf\xeb>%+\xf1\x9c?\x82w1\n\x0c\xfb\xfc?9jI^a\xed\xf4?\xd5\r\x9a\x9a.\x83\xdc?Yu\xbf\x1e\xc8X\xd4\xbf\x8d\x06\x1c\xeaI\xea\xe9? \xec\x05G\xcfH\x86?\xa8\x18\x1f\x1c\xa5]\xc9?s\x0b\x8d\x0c\xb5\x0c\xed?\xf6*\x97\xa6$5\xd3\xbf\x96\x85j\xa1\xa9\x80\xda\xbfp\xdd3>\x08V\xe7?8\xeb\x16\x93,q\xf6?\x01\xfcO\x11"u\xcb?\xc831\xeb\xf0/\xf8\xbf8/\xb6\x16Q\xe4\xec?\x98\x8d\xc8\\\xd7\x9d\x06@\x9a\xe4O\xc8\xea\x01\xf3?U\xba[\xdf\xd7\xbb\xe5?\x81\x00.\x9c\x92\xab\xe7\xbf\xe1\xd2m\x12\x15\x0e\xf1\xbf\x0f\x9ewk\x16>\xe8?\x19e\xad\x18w|\xe9?\x93\xc5\xa7Be\xe1\xfe?\x84AN\x14\xa1\xef\xf7?\x89\xcc\x0b\x03\x87\xcf\xd5?\xc6\x9e7\x0f\xac\xa1\x05@|\xce\xbey \xcb\x08@\xe1rG\x06\x19\xe9\xd2?K\xf74\xa7\xb4\x04\xf9?\xa8\x1f\xa47]\x1e\xe8?\xa7\xe3\xdd1S\x7f\xd9\xbf\xc5\xd8r\xaf<\xc0\xb7\xbf\x10wi\xc07H\xb5\xbf\xe1\x17\xe3\xf6\xe8\xec\x97\xbf\x8an\xb9\x1b\xb2\xeb\xe4?\x95\xbe\x1a\x80\xf3\xd3\xee\xbf7\xb5\x0b\x87N8\xee?\x9d\xf2\n\xd7\xdcQ\xda\xbf\x96\x87}K\xda\xd0\xf0?\x1d\x06\xdcUg\x9a\xf5?\xe65\xa7Q\x0cL\xfc?@\xc8\x8crr\x81\x00@M\x8c\xbd\xaeP\xbc\xdc?3fAi\x0eg\xe8?\xcfqP\x9d\xb6H\xf1\xbf\xdd\xce H\x1c\xb9\xec\xbfw\x0f\x02H\x87b\xc8\xbf\x98\xf5\xd4\xa1\x86%\xdd?\xa1\xddO\xc5\xe8G\xf8?z\xc4\xdf\xf1E\xf3\xf5?\x08=\x10\xd3V\xec\xe4?\x84\xb0\xfa/3\t\xe4?%\xac*\xcd\xfdP\x0e@T\r\x19l\xcb\x9c\xc7?!\x07\x16\xd5\xf2K\xfd?\x82n\x00#\x94\x11\t@57\xdc\x9d\x8b\r\xeb\xbf-N)\xc82\xe0\xe5?\xd4e\xeeq\xb6\xd5\xe1?\x0e\xd6\xac0:s\xf1?\xf8\x9dE%\xe2\xda\xe3?\xf2B\x15\xcd\n_\xf5\xbf\x84:\x12:\xfb\xb2\x03\xc0\xf3\xb7!\xb4$\xe7\xbd\xbf\xca\x07:F\x04\x0b\xf1?\x97\x91\xe4\xc2\x04\x88\xdd\xbf\xa4\xec(\xb7F\xef\xd9\xbf[#\xc2i&\xf9\xfa\xbf\x9aQ&\xdb\t\xb0\xa7\xbf\xca\xc2\x91S9Z\xec\xbf\x1c\xab\xe8\xbd\x8f\x14\xb3?<\xf9\xebw\xad\x0e\xf0?"N\x8aJ\x1f\xaf\xf7?W\xdb\x8b$\xcan\xde\xbf\x173b\xcbF\xeb\x00@\xce`~\x92e\xd9\xa2\xbf\xddl\xcc99\xb9\xe5?\xc4\x90!w[\x8f\xec?\x9b+\xfbsm\xa1\xd1?\n\x16\xc4\xe1\x1a\xc9\xe5?F\xc1T\x0e\x9d\x15\x04@F\xc7\xd3\xf3\x08q\x01\xc0eZq\x1f\x95*\xf2?p\xe2e\xabo\x88\xd5\xbf|\x18\xe9Y\xber\xce\xbf6)\x1b6\x10u\xfa?[\xf3\xa5\x160{\xf8\xbfJj\x10T\x07\xde\xd9\xbf\xc3\xa3D\x1ea\xe1\xbe\xbfR\\\x96>\xb6s\xff\xbf\xe7\xc3NU0\x12\xcc?I\xda\x94\xc9\xe9\xfb\xf1?\xad\x18\xfa\xa1t\xf0\xf1\xbf\xd81\xdf\xcf\xca\xd2\xdc?\xa5id\x9a\xf3\xb9\xd5\xbf\x1f\r\x0b\xc1X\xe6\xeb?\xfb\x0b\xc2|\xc5\x9c\xfd\xbfDc\x1d(\x9c\x1d\xda\xbf\xaaW\x98@T\x90\xd9?\xe45J14\xc4\xf0?\xcf\x18:\xe5\xf8\xc7\xef?\xc4\x80R\xb5\x87l\xf8?\xb9\xe8BC\x87&\xeb?(\x99\x07\x8d\x14\xd3\xfa?Tw\x9d9\t\xf6\xfe?\x00o<\x03\x11\x04\xc9\xbf[kh\xc6\xa9W\xe7?i\xb8@\x85\xaa\xeb\xd4\xbf\xe9/\xc8\xcc\xc6h\xfd?\xac\xc4\\\x87\xc1\xc7\xd9\xbf\xe2H\x0f\x9f\x85U\xd3?\x97\xfa\xdf\x90\xeds\xf7?E\x85\x02$fo\xf1\xbf\xad\xe0\x88\xbf$-\x8d?\xb6\xbe\x13*T\xab\x02\xc0G\x89sS\xd1\x87\xda\xbfC\x0b\xbd\x85\x07G\xc1?\x98a\xba\xf1\x16>\xf3\xbf\xbf\x1c/\t\xcc\xa2\xf6\xbfL\\\xe1)\x95\xc5\xcd\xbf\xd23\xbft\xa8\x87\xd0?\xc1\xfd1\xe4\xc6W\xd8\xbf\x12{\xaba8a\xcd?Z&\xf4\xa4\xb2\xe3\xf6\xbfO\xbe\xb0\x86\xb3\xa5\xcf?\xc7\r\xb2\x84\xbe \x94?c\xfa\x05d\xda#\xdd\xbf/\xedg\xcb\xdc\xa8\xf7?\xa6\xc2\xfb\xf0\\\x05\x01@L]-\xf2\x81\xe3\xf5?\xd9I=-\xddg\xd4?o ;\xe3\xe5\x8d\xc1\xbf`S\x0fZ\xd9\x87\xd2?\x11\xbfv\x8d\xa9\x9e\xe9?\xfe\x8e\x89+\xf4:\xe0?\x9aQQLo*\xe9?\x1c}\xde\x10-\x01\xf2?\xf8\xc7D\xc3\xe6\xb0\xc2\xbf}.\xa2\x13)\xbf\xf7\xbf\xaa\xe7\xe4\x92\xbdC\xe1\xbf"N\xca\x0f|6\xc4?\xa1\xa0\xe77\x7f`\xc7?v\xdb\x9f\x86\x12\xe6\xc4?L\x1cN\xcb\xfc\xf2\xee?,\x03U\x88\xb8\xda\xe5\xbf\xec~\x85\xb1\xaa\xdd\xf0\xbfK\xe2\x14m\xee\xff\xdb\xbf\xc0`\x89\xd9\x15\xdb\xf2\xbf\xa5\x02f9\x15e\x07\xc0\xa8\x9a\xc3\x9c\x93Q\xcd?\x853\x1bgp%\xdf\xbf\xa5\x06sG\xeb.\xc3?-1w\xcb*m\xd6\xbf]\xeb\xb2`\x89x\xf4\xbf\x12\x12\xb7J\x12\xb6\xde?9\x92\xdf\xd6\x95\x99\x07@\xb5#a\xa5\x1f_\xdd?\xf0\xcc\x8c\xbePJ\xf1?\xbc%{\x15\xe5\xb8\xeb?U\xf1\x8bT\x9f&\xd2?\xa3\x93\xeb\x87dX\xfc?\xc2\x11I\xd8\xf3\x9e\xc2?\x94b6\x91\x91\x11\xeb?\x0cf\x98\xac\x1bj\xe0?\xaa\x05U\xe0\xefr\xe1?\xb2\x0f\xac1\xaeM\xeb\xbf/\xceH\x9d\x0fJ\xca\xbf\x02\xd7\xa2H,\xb4\xb0?Tm7\xc99<\xeb\xbf\xc0Ow\xcc\xafy\xe7?p\x84t\xee\x1f\xa6\xe4?\xc8\xe8\xcc\x85|\xcd\xe0\xbff\x86\x04g\xca9\xb8\xbf\x12\xf9+\x1c\xd3e\xc1\xbf\xfe\x88\x86\xcd5\xd6\t\xc0\x03{?\xd9|\x99\xf4\xbf\xdf-c\xe6\x13\xa3\xd9\xbf\xc0q\xe4\xc7D&\xb2\xbfOE\x9e\xd59\x08\xbc\xbf\xcac\xc6\xb7\xb8L\xf3\xbfu\x8f@\x07,\x8a\xcd\xbf\x90g\xd9R\x9b\xd7\xf1?\x9d\xe9V\x1d\xac\x0f\xf2?I\x05\xfb\xa6\x91\xab\x03@\xe9\xf9\x8aK}\xc9\xf1?\x14Z\xcc\xac\x8a[\xe6?\x04!\xd3/\xca\xe3\xe7?A\x82\x13\xc5e\xd2\xf0\xbfh\xfc\xefE\x1f\xc6\xe6?p\x8f\xdd\xa3\x18p\xe4?]&\x88\xa6\xb2\xc8\xe7?\x8d\xbf\x1e\xed7?\xd7?\xa9r\xb4\x06\xf2D\xf6?\xac\xc2\x08\x9e\xec\xb5\x05@\xdf2<\xfe\xfa\xd2\xf2?bSt\xe8CD\xeb\xbf\xc6\x81\xadZ\x1d\x80\xb5\xbf\xf0\xa2c\x00\xd7\x1c\xeb?\x06\xe4P\xbe\x7fO\xe5?\x04\xfb \xc1\xfb/\xf1?\xc5\xad\x96\xa6\xdf\x9d\xc7\xbf\xa7+\t*W\xf5\xef\xbf\xcb\xf5j\xe6.\xad\xec\xbf\x8a\xaf\xe3\xfe\xb6\xe5\xf2\xbf\x974D\xbb\xe5\xed\x00\xc0\x85$\xf3C\xeem\xe5\xbf|)\xf9\xf8\xf5\xbf\xf9?\xbe\x04@\x19\xbb|\xee\xbf6\xa9\xcf\xe2\xb9\x8a\xd8\xbf\xd0\x0c\x8bw\xc3\x9f\xe3?e\xb7\xa3,\x04\xfe\xda?\xac<\xc6"\xd3m\xea?\xad<\x13\xb9t8\xc3\xbf\xe6\x99\xd4\x9e\xbe\x0b\xea\xbfYcH\xb9\xdc\xf1\xdf\xbf\xb8w\x1e\x97\xa4\x87\xee\xbf\xb6\x05\x08\x81\xb8\xc2\x01\xc0\xf7\xe8`DD\x97\xef\xbf/m\xe9i\x18\xe4\xff\xbf8\xac^\xfa\xbdq\xff\xbf\xea\x00\xcd\xd88{\xf2?\x14\xe5\xba>\xaeV\xf5?XX\xd6\xcb\r\xbc\xf8?Z\x93u1\xe0\xc7\x04@\xc4\xd2m\xd9I\xce\xfe?8\x0c\x9e\xafP\x18\xd6?\xfa\xf4\x06\r>\xae\xe6\xbf!\xff\xb3h$L\xe3?\xaf,\xa0\xc29\xc3\xba?\x06{O\x8an\x9f\xed\xbf\xebh\xec{,\xba\xc1\xbf>\xe2\x19\x90\xe4w\x01\xc0\xfc\xaf\x85*[\xa6\n\xc0Y\x85a"M@\xdd?\x97\x81w\x8a\xaf\xd0\xf6?FgP\xc5\xf9\x83\xeb\xbf\x15\xdb\xea\x18\x9br\xfe?T\xc9\xf9\xd9o\xc8\xfe\xbf\x15\xb4\xd6\xe7.2\xed?\xef\xa2\xcf\xed\x8e\xa9\xc8\xbf\xe4\xb4\xbf\xd2\x96\xae\xe1\xbf\x05a\xe56\xe6\xfd\x08\xc0\xf4\x82\xaa\x17\xe6\x95\t\xc0\x80e\xb4\x05\xfc\xb2\x07\xc0\x9bx\xd1Sc\xd5\x03\xc0A@\xc2Ct\x1a\xf9\xbf\x93\x19\x15\x8a\x95\x02\t\xc0\xcawGW\xc8\xc9\xf2\xbf\xf9\xcc\tC\xfem\xf9\xbf\xd4)l<\xc7\x9a\xb8?\xb9c\xbd\x8d\xab\xa0\xee?Rtu$\xeb\x83\xd9\xbf^\x9a.b\xaax\x05@\xe1\x8a\x9fM\x0f\xde\x00@8\r\x85\x98\xfa\x83\xfd?\xcf\xed\xdf>\xf4\xcb\xfd?|DT"\xdeZ\xe1?\xb9\xfdx3\x18y\xb0\xbfH,\xdd\xed.G\xfb\xbf\x0f~\\\xe6\xc2\xdd\xfd\xbf\xf7\x19 w9\xf0\x06\xc0\xd4\x87C\x9d\xdc\x7f\xf5\xbfo*\x1e\xd8\xc4e\xdf\xbf\xfe\xf0\x90\xa6\xac;\xf5\xbf\xcfS\x0b\xc7\x11\xe9\xf0?y\x16fX\x17O\xe1?z\x8d\x00\xfd\x85`\xe9?0i\xa1_\x177\xf3\xbf\xdcB\x06\x89\x1b\xbc\xe9\xbf\x15\n\x19@\xa2\x19\xfa\xbf\xfe\xa5CM\x8c\xcd\xfa\xbf0O`\xea\xe6.\xfc\xbf\xae?Y\xa7\t4\xed\xbf\x0cy\xe4{\xee=\xf4\xbf\xd7z\xb0,\xe5f\xf4?\xe2s\xe8\x8b\x89\xd9\x02\xc0\x1f\xa38\xa1\xf97\xf8\xbf\xf4Bf,\xfe\xa8\xe1\xbf\x15\xc8E\x94K\x95\xf7\xbf\xa8\x82\xa4\xf8\xf7\x8c\xf1?\x1a\xa5\x0b\x19\xaf1\xf3\xbfR\xdf\xd1^\xb4\x96\xd4\xbf8\xb5\xeb\x90\xb2>\xf4?\\\x9e\xd9\x14\xf8\xc6\xdd?\xc6\x8fi\xa2\x9c\xa9\xbb\xbf\xf5\x19\xc5U$\x17\xf1?\xcb\xfbD\xa0\x9f\xd7\xc1\xbf/Aq\x9a\x84\xb8\xd2?\x98o\xedx\xd9Y\xc4?\x1a\x84\xce\xb9`c\xdc?\x9e?\xcd\x801F\x02@\xb0\x05\xddp\x8a:\xec\xbf\xef\xe2\xe8\xd88"\xdd?\x93\x8b iK\xc8\xfa\xbf*2, \xda#\xcb\xbf/X\xe6\x1e\x8d\'\xec\xbf\x94\xbd\x99P\x8d\x9b\xeb\xbf\x1fH8\x1f\x9c.\x00\xc0W\'Z\x81q7\x07\xc0\xa98\xf0\x8dl\xcb\xf4\xbf\xf9y\\\x1b%;\xbf\xbf\x92\xe9\x98\xf5\xca\x8c\xe9?\x8fR\xf3\xec\xd0m\x01\xc0>\x0c\xf4\x8bhx\xed\xbf\x064\x94\xe2)\xec\xe7\xbf(\xe9\x05,\x9fn\xf6\xbf\x8c@\x9b\xd3\xbf\x0f\x00\xc0\xefE\xaa\x1bb\xc0\xf4\xbfN\'\xa0a0~\xd7?\xb9\xe0\x0e\xb32\x06\xdf\xbf\xd6\x87?\xab\x8b4\t\xc0u\x9a\xe0\xcd@\xba\xf8\xbf!\x91\x0e\xd56\xb1\xc4\xbf\xb8G\xc0\x87H\xf8\xee?c\xf9\xeb\xca\xecp\xd1?\x14\xe0\x11\xff\xef\xfd\t@Q\xeb\x1cj\x9f1\xd4?\x1d\xf49 \xbb\\\xd9\xbf{\xf4\xf9\x89\x07%\xed\xbf\x1e\x9d#0%\xcd\xe0\xbfI7\tw\x8c\xd0\xec\xbf\x86\x11\x93\x933%\xb8?\xf4f0\xb5\xc0\xa3\xfd?\xb8\x12\xb5\x9b\\\xa2\xd1\xbf#\x0b;<\xe6\x9e\xdf\xbfG\\\xeb}\xae\x87\xd3\xbf\x8d\x1e\xf1\xbe\xf4\xd7\xce?\x03ccha\x14\xcb\xbfa\x9a*\xec\x8d\xa5\xe8? \xff\x04\xeb\xe2\xb9\xd5\xbf\x97\t\x17\xa8\xaa\xe8\xe5\xbf\xd9D\xfc\x98.\x9d\x02\xc0\xff\x9c1\x18\xdc\x1a\xf2\xbf7\xd2\xff\x19\xde\x88\xfc\xbf\xdf\xd6\x1b`\xcb\x15\xeb?"\x04\xe5\\\xb92\xe7\xbf\xa7\xb8\xd2MA\xfa\xf3\xbfo\xe3\xa5\x08\xde\x7f\xc1\xbfU\xe7c\x83\xe0\x98\xf5?\xce\x1es\xa9\x90)\xf0?\x1fO+\x90\\y\xe9\xbf\xf3d\x1d\x13|U\xe8?\x86?/e\xddJ\xf6?~\x9c\r\xbck\xdf\xfe?h7?\xa3K\xff\xf9?\xb0\xba\xa6K\xfb\x05\xdc\xbf,\x87\xf8\xcd\xcb\xe4\xf1\xbf\xc2\xc9Eg-\xff\xa9\xbf\x9b*\xab.\x16\xc9\xe6\xbf^\x95\x98L\x15l\xde\xbf\xbd\xd9Y\x17\x10o\xf4?\xab\xd9Z\'\xf1)\xe2?\x1fD\xab\xa0\xba\xc8\xd8\xbf\x0ch\xf6i\x80\xca\xf0?\x86\x8d\xbc[O\xcf\xe9?)?.\xe8\x93\xd3\xda?\xa6\x00\xffq\xe9\x0b\xe0\xbf\xc2\x87\xdf\xc4\x80\x08\x04\xc04a\x1f 9\xcc\xe2\xbf\xfbd\xfa\x82\xb1\xe2\xe1?t\xac\xbb\\\xc2\x9b\xf3\xbfg`0\x89\x83\xbd\xcd\xbf\xf9n\x16\xa4\x82L\xeb\xbfGc%\x15\xa2\xb8\xf3?\xc6\xe5\xb0\xc0\xe9\n\xfa\xbf\xab\xb5\xea\x1f\xc7\x05\xe0?\x0bP\xa6F\xba\xb8\xe8\xbfs\x8e\x83\xab~?\xf0?\x03\x81\xba\x1a8\xed\xf3?\xeb6e0\xc7\x9a\xf4?\x9a\xa2\xaeB\x81\xb5\xe9\xbf\xf4\xef_\x85\x8a\xec\x04@\x0e\xc5\x84\x1e\x9d\x93\xe9?\xfb3KWH\xad\xf1\xbf\xf85\x8e\x96\xaf\x96\xe1?\xc5\x8e\x07|\xf1\x12\x9f?\xc3Y\x94hT\xf3\xd2?\x9bG\xa4\\\xb3r\xf0?b1\xb2i\xac\xf4\xd6\xbf\xe9"\xaa\x89X\x07\xc2?\xcd\xd8Y\xd5Vc\xe5\xbf\xfd\xc6\x01\xca\xf1\xb4\xd0\xbf\xbfsV\x94,q\xf9?\x8f\x9bx\x8a+Z\xd6?\x15\xd4\x01\xc0\x18\xfe\xc0?\x11-\xfah\xcf\xcf\xc2?Z2*N\xa6%\xe4?9\xd7\x80\xa2y\xfc\xc1?\xfe\xe8#d\x1b\x90\xd6?\xb1 \xed>\x11/\xf1\xbf\xba\xcac}\x9du\xda\xbf\x98\xce!1\x18\xb3\xe0\xbfur@r\xf38\xe6?\xa2\xb5G\xe6\x01\xac\xde?\xda\xfdX\x10[P\xfa?\xb6\xbbi\xf6\xc5\x91\xed\xbf\xdc\xc9\xb4 \xa6\x1f\xa4?\x89t\xd4\x90\xce\xf7\xf4?\x84\x15\xa2\xadr\x12\xec?|\xc9\xfe\xab\x7f\xd0\xa8?\xa4\x8dU<\xa0\xb4\xbf?\xce\x1e\xa2\xab\x85\x0e\xf7\xbf\xca\xa1/\xc9!`\x02\xc0!\x06\xf5\x1d4\x14\xef?k\xc4\x89\xee\xc4\xc9\xab\xbf\x1a\x8bA\x9bM\xa0\xdd\xbf\xe9\xf4\xf4#9\xd8\x02@\x88\xf3\xdb\xbf\xc4\xd4\x02@\xa8B\xb1\x1c.\x94\xe0?\x8b\x1a\xed\xf0\xe2\x16\xfc\xbfx\x07\xf7\xa0\xc4-\xf6\xbf\xd2\xcd\x01h\xf3\r\xeb\xbf\xa0\xeaQq\xb9\xbf\xe8\xbfW\x89\xe1C%\xf1\xca\xbf\xb1\xfb\x08\xe1\ne\xf5\xbfR\x10\x10\x1b\xde\xd7\xee\xbf\xba6\xbd\xd3\xe9\xf7\xe9\xbf\xfe\xbb\xf5\n=\xd4\xe8\xbfUt\xb5\xa3u\xcb\xc1?\xb1\x07\x836}=\xf0?\xc7P\xb6\xed\x89B\xd4?\xe0W\xe5\x1c&\x9c\xd2\xbf\xa2\x1a.\x07;\xd8\xf4?\x7f\x82\xad\xa1\xb3\x7f\x01@;3\x0f\xe1:\x19\x03@J\x97\xdb\x8f+`\xbe\xbf\xe7\xac\x03L\x9du\x01@,\xf9\x85\xc1\xa8]\xdb?\xa0\xcdY\xfe\n\x19\xf3?gIq\xa2n\x99\xcf\xbf\x01Z17P\xad\xd4\xbf8\xafj\x9fo\x9f\xf9?\xfd]-\xb51z\xe5\xbf\xc6\x18\xf7\xac\x84\xdd\xcd\xbfv_}\x91t\x1a\xeb?MP\x86tG(\xde?XG\xb2\xb2\xb3L\xd2?\xef\xf0\'\x95\xcf`\xec?)m\xcdwo\xbb\xfc?\xab\xe7\xb9\xe3y_\x96?]\xe4?O\x85@\xb4\xbf\xc2\x89;&7L\xd8?r;0\xdf\xd3F\xe0?Z\r\x88f\x8e*\xeb\xbfS\x9ed\xa7\x0b\x0e\xd0\xbf?\x9f\xff\xa8\x86b\xdf?\x01\xf4Hq\xaf\x9c\xe1?\xd2\xfb\xb3\xeeQ\x8c\xe6?\x9c\xed\xcd\x1f\xf0\xec\xe9?\x1cfw\xc3\x99&\xf2?\xec%\xda\x05Z\xf0\xff?{\xd2c;\xcbo\xf8\xbf1\xfd\xf1\xe2\xcd8\xf8?F%U\xb3\x06%\xf6?#\xe5\x01\x1at)\xee\xbf\xf6\x08\xa3\xcb"\x83\xbf\xbf\xfa\x11\xcd\\5\x85\xe2?\xb9\xeb\x14S4\xf6\xf2\xbf\xf033-~\xbf\xec?\x9a \x1d\x99\x05l\xfc?R\xc6Y.\r\x9b\xf2?^\x9e\x8f\tb\x7f\xf8?.\xc8\xb6\xf5\xb56\xe1\xbf4(f\xfc\xd5P\xf6?\xff\xf2l7X\x93\xf2\xbfa\xb8c\xd8\xe9\xd4\xd5?_-92\xa5B\xed?\x93\x0ch\n\xb4\xb2\x02\xc0\xfc\xac\xdcEQ\xb1\xb5\xbf\xb2\x9cl\xd9\xe5o\xe7\xbf\x99]\xf4\x8b\xfbp\xdd?\xaf\xb6\xda\x9bN\x1a\xb5?\x9b\x14E \xd2/\xc0?b\r\x19|N\xd6f?T\xb8\x01o\xeb\x9a\xe7\xbf\xc6$\x1d\x13Z\xe0\xd3? \xa1\xb3r\x9e\x18\xf1?-G)%t\xa6\xed?\xc0\xf1{\xab\x1d\xfb\xcc?\xf2\xdd\xa8\xfbWK\x04@\xbeq\xad|}>\xfa?\x80\xaeU\xb6gQ\x01@\x1cy\xb3\x97\x96\xf2\xe7?\xe4\xc8\x8f"\x89\xbe\xf8?\n\xa6\xb7\xf12T\xdc?\xc6\xf4f}\x84\xbf\xf0\xbf\xd1(Pbw\xe9\xe9?E\xb63X\xf2y\xe3?\x84\xfd\xb0S\xb6h\xe0\xbfu\x98\xe3\xfa$Q\xf1\xbf\xee"[\xe3\xea~\xe7?Q\xa6\xff(\xa2\xd7\xf1?\xc9#\xb2CuD\xf8?\x83b \xe0\xa3O\x82\xbf\x7f,q\x94G\x80\xf6?U \xdb\xfbK3\xf8\xbf\xb6\x18O\xec\x16>\xb9\xbf\xe4y\xfb\xb3\xfd\x9a\xd8?\x9b\xdaH\xac\xe7\xcd\xe9?\xe4\x95G\xcd\xc7\x8e\xd2?\x18\xf3\x87\x8b\x90\x81\xef?ya\xe6\x95\x00\x86\xbf?\xe6)e\x9ez\xb2\xf5?\xb9Q9\x9b-\'\xe1\xbf\xdb\x85\x06\xc2\x7f^\xb8?\x12N\x84D8\xef\xf0\xbf2\xc6<\xaa\xbe+\x04@Y\xee\x01\xcf\x1b\xf9\xeb\xbfM\xf8\xb7f\xf6A\xf1?X\x1e\xa0I\x1b\x00\xee\xbfp\xef\xa5 \x1b\xde\xf7\xbf\x03\x0e\x96\xe7\xcf6\xf4\xbf\xc5\xe3BW\x9fF\xfd\xbf\xff\x8b\xbc\xd4+\x10\xd5\xbf\xe7Y,_\xf3\xaa\xeb?\x90\xa3\xe2\x8e\xc6v\xf8\xbf<9\x86B8\xfe\xf5?1z\x0c\x9f\x8a\xd8\xd2?hA\xeb\xbf\xf2\xbe\xe3?S\xda\xae\x11\x1d2\xea?\x88\xb8]\xf43c\xee?\xb2\xe5\x88y\x8c\xd6\xef?/\xfd\xedL\xf7T\xf6?\x9f\xdc\n\xaf\xf0\xba\xe7?\x7fe\xf5\x80\xaam\x9f\xbf`T\xd6Z\xc7\x8a\xf1?\xb8\x93\x86`q[\xc1\xbf|\x10\xb3\xc4c\xbd\xd2?\xbc\x8a\x81\xfe\x97\xb5\xb6?\xebw\xca\\\x95U\xc2\xbf\xfaw|\x90\x03\xd7\xf0\xbf\xcd\'\xd1\x9f\xcc\x87\xa9?\x00\x15\xd5\x82\xbb.\xc8\xbfFK_0\x88w\xf3\xbf\x07~\xee\xd0\x97\x80\xd8?\x99u\xfb\x0e\xc3b\xdb\xbf\xdcG\xf4\xd5\xa7\x7f\x00\xc0[P\x81\xf3\xa0\x9c\xe1\xbf&\xc0\x84\xf0\xdf\x93\xd2\xbf"\'\x97\xf7\xffU\xe4?\xf9L)\x0e\xd5c\xf9?xIE\xa9\xb5\x0c\xf5\xbf7q\xcc\xf4\xd7\x9a\xe0?\xf8\xb5\xcd0=j\xc1\xbf:N(9\xc5\x06\xe8?\xbd\xca\xb2\xe7\t\xf4\xc1\xbfs\x8d+Y\xf9\xe2\xed\xbf\xff\x04K\r_+\xd5?\x10\xd9\xe9\xfe\xdd\x9b\xfb?\xd7\xcc\xb5w\xb9\xf4\xeb\xbf\xf1T56A\x01\xf3\xbf\x88]\x06vB\xd1\xd5\xbf6\\\xd5|\x171\xe1?\xfd]\x04\x9af\xad\xf7\xbf\x9bW\xe8\xbeO)\xe1?\x1fd\xc9\xe8\xed\xd2\xc3\xbf\xe6\xad{\xe7X\x87\xd9\xbf[B\xcc\x8e\xdf\xbb\xde?\xb3\x9d\xeeZ\x10\xcb\xf3?\xaf,\xec1\xc2&\xd9?\xc0\xbd\xf7\xed\xbf\x85\xe7\xbf\x1e\x9f\x0c\x08G\xf2\xca?\xd1\x8a\x98^\xe9s\xf2\xbf\x83\xff\x8d#k`\xed\xbf\xa5D\xdf\xd4$\xc9\xcd?\xfd\xae\x9c\x94_/\x86\xbfb\xe4\xf8\tA\xdf\xf3\xbf\x85>P\x00S\xb3\x91\xbf\x98.\n$1\x8e\xe2?\xb8\xb3c\xca\x97\xd2\xe8?\x8b\x18\xb4%.\xc1\xae?S\xe8\x8c-\xd4\xd5\xe9\xbf\x1c\xbd\x0e\\T\x1d\xdd?c\x10R\xbe\xa9\xa6\xef?\x06T@\xf5\xf2\xd8\xd2?\xe3w\x10G\x82\x92\xd3?H5\x04\xdbR-\xc9?\xe5i\x8eG4\xf4\xfc?\\\x1d2\xca\xa6o\x95?\xdb!\x8c\xad\xdcU\x02@\x12\xca\xe4\x17\x87\xfb\xcc?2\xfb.\x04&M\xb3?j1\x82\xbbc\x92\xf2?A\xe7R=bH\xf8\xbf\x9f\x1bT\xd2P\x96\xdf\xbf\xbf\xc1\xe7j\xe7\xab\xf7?%\xc8"\xfe\x1cp\xf2?\x80\x15h\xa6\xd9\x98\xea?\x94\xf42\xf7\xda\t\xca?KF\xc26\xeb\xdb\xdb?@\xbd\x80\xde\xbe\xcd\xe8\xbfc1\xc6>\x18[\xdc?\xac\xef\xafsS6\xe1\xbfg\xe0\xc2\x9a&\xd4e\xbf\xf5\x13\x03\xbcKD\xae\xbfp\xe6\x92o\x11\xbf\xdf\xbf\xb3\x81\x93\x04\xf7\xd5\xd6?*\x8bmf\x88z\xe5\xbf\xa1\xca\x99\xbf\x1e\xf2\x81?\xf7\xc0\xde \x98\xcd\xdd?\xb3\xcb\xef\xb2f\x81\xdd?E-\xd1)\xe0\x97\xa2?e\x9d\xfd\xa5\x0b#\xf7\xbf\xfa\xd3\xed\x10i.\xb4\xbf\xa6e>\x1e\xa8/\xf2?+\x9a\xc5\xc7\xe1\xbfm\xba\xfa\xfb3J\xc8\xbf\xa4V-\xa6\xe5\x95\xf7?ar\xb7u\xae]\xf7?\xa7\x1c\xb1u5\xe0\xe1\xbfv\xa7\xde\xe7\xa8\xb7\xbd\xbf\x1c\x1e\xab\xccQ\x08\x02@\xea\x7f\x9b\xfd\xb2\xa6\xdf?\xa9\x8er\xaa\xeb2\xf1?\x1c\xefo*\xcfH\xb8\xbf2\x1f\xd0\xa5\xa3!\xcc\xbfYC\xf2\x0f;F\xe0?\x16\xba7\x9aU\x8e\xf4\xbf\xb1xn\xdaW\x84\xed\xbf0t\xfcK\xd4\x0e\xf1\xbf\xf6#\x05\x07V\xc8\xe6?W\x84\x06\xf8\xac\x98\xbe?\xf0=\xc4\xd5\x1a\n\xae?H\xc3\r\xdeI\xd7\xe1\xbf\xf7\xc2B\xb8\xd9j\xde?\xb33bF\x81\xb1\xf5\xbf5\xd0\xa2e\x9e\xfb\xd5?\xca3\x81t\xcf\xc8\xd6??t\x9e\xde\xb4\x08\xb9\xbf\xbaSm\xd3o<\xdb?U\xbb\x02C\xecK\xeb\xbf\x10\xe1\x0e\xf2\xf5\xea\xe6\xbf\xa9\x9f-\x99N4\xf4\xbf\x1b\nD\xe0\x0c\xa9\xec?\xacw\x89/:o\xf9\xbf\x13mU\x89\xd2\xa2\xd9?\nL(\xef\x8b\xb8\xed?\n\xc5\t\xb5\xd9p\xe2?\xb3I\xd7L8\xff\xff??\x11?\x15\x02\xa6\x04@>\x07\x84,G1\xe0?\xe5\xdb\x0e\xdd\xe9\xd0\xf3\xbf\x1b\xaa\x00\x8b#g\xf5\xbf/ \xfc.\xa4\xda\xfd?\x8c\xb1\xe2D!E\xf3\xbf\xbf\xe5\xb4\xac8|\xe6?\xef\xf2s\x0b\xa6J\xe7\xbf\x1d\xf11\xcd\x02\xa0\xd7?\xd2":\x03\xa7\xd6\xf9?O\x05\xf1\x1d\x00<\xbc\xbf\xbd\xc3\xc4\xf0\xc7?\xe0?\xf2\xf66\xe5\xd1\xd6\xf8?\x03\xc6\xab\xee\xd2\x1a\xf2?q\xffm\x0c\x12\x8b\xfb?\x9a}\xd0g/\xd4\xe3\xbfo\xbeRy\xfeO\xe7\xbf\xbf\x06\xffo\xcb\xa5\xe9?\x05_$\\I\xeb\x8f?\t\xb9\x7f\xd8I\n\xf9\xbf\x80\xf6=Up\xbb\xb9?\x12\xdb\xd6\xa0\xcd\xf8\x00@gL\xb9\xe2=\xe3\xd4?\xe0\x84d[A\xa2\xe8?1\x0c\xba\n\xea\x9c\xf6?\xc9\x03\x16\xf5\xd6%\xf1\xbf\x94\xd3Y\x0b\x13N\xb8?6\xb8\x94\xc4\xfc\xea\x00\xc0\xa6d\x9cO\x85p\xd2?\x9ao\xd2\xb0z\x0b\xe3\xbfrV"\x9e_\xd9\xf1?R\x12\xf8\xbbB\xc3\xe2\xbf-\xe1\xef\xd7\x97\xd6\xea\xbf\xc1a\xd97\x96\xd6\xe3?\xdd\xb1+Inb\x06\xc0\x86\x7f\xe3U\x9a\xad\xe1\xbf\xe4\xa0\xfb\xee64\xe4?Z\x14lx\x1c?\xe3\xbf\x1ag\xb3\xf2\x81\xc9\xf3\xbf#\xec\xe4q1\x04\xe6\xbf\xc9\xfd\x14\xb6\xf9\xbf\x02\xc0\x197\x91\x91\x9dU\xd6?B\xbcB`\xde\x92\xf2?\xb1\x00\xa2\xf7\xe8L\xb6?\xa9N\xc7\xa1d\x9a\x84?\xb8\x9b\x92Z\xf2\'\xe7?D\x164\xb9\xb5(\xbc\xbff1\xd8Q\xcb\xd5\xde?lj\x84e\x1d\xd9\xdf\xbf\xdbrA\xeeT\xf9\xa7\xbf\xf4Y\xb38\xe1L\xcc?\xca\x0b\xef!=\xd9\xc5?\xf34\x1d]\x84O\xf1\xbf8\x8b\r\x8d6l\xe5\xbf\x87\xa4\x08\xc3*\xda\xe4?\xe5\x002\xd4\xc0\x08\xf7?d\xb1\x9c\x83$\xf8\xf7?)+-\x07\x80N\xdd\xbf(\xa0:\xf3\x1c\x87\xea\xbfv7\xe7\n\xff\x01\xf1?\x06h\x8d\xb2\xa0\xfa\xe6\xbf\x91\xb4\xdf\x90\xb0\xad\xe1?\xc8\xab\x83k\x125\xfa?\x84\xff\xb0\xf7\xebB\xf1?\xc1\xf0\xa1\xb1t\x11\xc7\xbf#}\x1e"\xca\xf9\xe2??!\x18\xbb\x0b\xa3\xe1?4\n\x13\x9aN\xaa\xf5\xbfR\xfa^\xef@p\xa7?\x93\x0e\x83\xa9\x9e\xa4\xde?\x12*\xc1\xee\xaf\xbb\xe5?g\x8f\x88\xf4\xbb\xd4\xe6?\xfa\x8a|\xa9ia\xec?\x15\xfc{I\xa4\xfa\x80\xbfp\xce\xb6\x87&i\xc7?\x04\x1b4\x8fK\xd9\xeb\xbf\x01\x0eR\xd7\x8e~\xf9?\xd4\xa1\xf5\xe1\xdbM\xf9?\xb8\x1c\r\x11\x9e\xe1\xce?\x9e\xe7B"8\xba\xe2\xbf\xf7\xa0\xe2O\xa8M\xb2?C\xa4I\x94\x18m\xef\xbf\x06c\xdd\xae\x92}\xea?t\x16\xd9\xfb\x99\xb5\x00@\xae\x06\x9f\x11\xfae\xee?\xba\x82\x8e\xfdK\x1a\xd4?\x93\x82\xa0nLi\xb2\xbf\xc68\xe8S\x80\xca\xe5\xbf\x9a\x15\xa8\x19\xed\x8b\xe7\xbf\xed\xd4\x03\xcb>\xa1\xf2\xbf\xa3\xcc\xe7G&n\xfc?\t\x8aYV\xe0\xa9\xdb?\xff}_u\x8cp\xa6\xbf\x86Zv\x07Q)\xcd\xbfvo\xfah\xbd\xd5\x00@\xa5F\x8e\xd6\xe2\xf7\xe5\xbfxkh[\xa2w\xc1\xbfv=\xf8\x8dX>\xe6?\xf1\x90\xb2a\xec\xc5\xee?H\x95$\xe1\x89\x10\xd5\xbf)\x96\xdccm\xe3\xe3?\x19\x05pIi+\xa5\xbfp\xa4\xec\xe0S\xc9\xe6?D6$\x14,a\xf8\xbf\xdd[Ix\x9dp\xf1\xbf\x8d\xc3\xea\x1f\xd0\x97\xfe?w\xa6\xeb\xa8\'\xdb\xe5\xbf\xbcr7\x10\'\xdb\xf3?\x15\xd9\xfe3\x95\x05\xf0\xbf\xb1"\xb9#\xc1\xaf\xd1?h\xe7=>\xec\xa8\xdd?`\xb7\tA\xc8\x15\xee?\xc3s\x1e&m\xbf\xc9?\x96&&\x80{@\xe5?\xeb\x80\x06E\x8e{\xda\xbf"\x01\xdfU\xa5/\x04@\xe6B\x88\xb0q9\xfa?\x08\xcdU\x037\xd5\xe8?[W\x1e:E\r\xfe?+\xe8\xc8\xf4\xa3v\xe4\xbff\xb4Es\x0b\xe0\xfe?e\x96\x10\xa2\xb3\x17\xf1?\xb4J\xdfKF\x03\xf7\xbf\xdb\xcb\xc4\xff<)\xe0\xbf\xa9\\}qe)\xee?\x88\x0bw3\x07\x9d\xf5\xbfu\xb8\xc9\x12+\xfd\xe3?\xed\xbf\xcd\x1b\xb5D\xe2\xbf\xc9)\xf5\xc4rV\xe6?\xfe\x92\xd2<\xdc\x1a\xbe\xbf\xa3\xe0:9\x99\x8e\xc5?\xbc\x94=\xb9N\xb2\xec?\x19i\xfc\xab,\xe2\xd3?I\xb0\x80\x9bs%\xf2?\xd3\x161\x8b\x9e\xde\x05@\xdd\x8e18hj\xf6?EE\x87f?\xb8\xf5?]\xe7\x07Q\xc2\xb3\xe8?EN\xbfI~J\xf0\xbf\x1bfZ\x80\x06 \xc9\xbf\xf9\xbaBx\xdev\xe5\xbf\xf2W\x8d2\xc3\xa4\xc8\xbf\xc2\x07\xeb\xf6\x86\xbe\xde?\xcf_\x0b\x1bbW\x9f?\'\xda\x84w%W\xf3\xbf\xb7\xab8\x83w\x12\xf1\xbf\xb0\t\x7f\xbf@\x99\xf2?\x0cM\x11XZ}\x04@\xdd\xe2\xd5\x10\xa9c\xe4?\xf8\xdb\xde\xfc\xd5\x92\xab?\xc1\xa7D}x%\xf4\xbf\xfb\xdc\xd1BJ\x01\xd4\xbf\xcf\xd8\x139\x97\xcf\x06\xc0P\xac\x1f\xec\xe2H\xe1?Sy0\xdf\xdc\xdc\xeb?3\x0b\xda\x1a\x15\x0c\xef?\rVFA>M\xe1?\x92\xc7\x8f/\xa2h\xe8?\xe7\xc41\xbb\x06s\xe7?f5\x0e\xc7\x99\xb3\xfa?\xec\xd8\xf9\x95\xb3\x1c\x01@\xa0\xc5\x8c\xb34\x08\x04@\xb6\xf0\xf6\xc6\xef\xc6\xf5?E{\xe9\xb2\x96\xb8\xef?\xa3\xa0\x8b\x07G\xe5\xfb?D\xbe\xc40\xd9\xf4\xbe\xbfu/0ye\xc9\xe7?+n\xb4y\xb4n\xf5\xbf\xe0\x87\xebY8\x9f\xf5\xbfg\n\x82\xfe\xf9\x86\xf9\xbf\x08\x06\xa5g\x16\x04\xff?\xe5Cz\xccd@\xba\xbf\xb7\x15\xf9a\xabg\xc2\xbf{\xc0\xc4[{c\x00@h?\x86\xa9\xa2y\xfc?MZ\x02\x08\xfbl\x04@\xdcs\xc8s\xc9\x10\xd8\xbf \x0ff\xec\xa7\xd2\xe7?\x87e\xd1\x8ef\x8c\xf3\xbf\x84.\xa72<\x15\xf0\xbf\x81\x86\x17\x7f\xbc\xfe\x00@z\x01\xfc?\xf55\xf3?3\xe2#\x99\x93a\xd8?\x04\xe5\xb7\xbb\x94\x8a\xea\xbfn\x80]G\x86\xe7\xdb\xbf\xecZ\x10$\xbb9\xf3?\xd6\xf6pF\xef \xf2?\xe2\xb4t\xe2j\xe5\x02@(Y-\x8d\x9e\x08\xf2?Q^\xac[\xb2\x11\x02@CA\xdd\xed\x00\x05\xf8?\x8c\xe6q\xd1\x14w\xe4\xbf\xa5\xb0\xdb;z\xb4\xb4\xbf-C\x93F\xc5\xd2\xea?\xc7\x84\xbb\x02\xa3\xfd\xf8?\xbc\x91\xbe!\x81\x83\xcb\xbf\xa7\xf4V\x869Y\xf0\xbf\xa3\xddt\x87^P\xf3?\x80\x97;\x0b\xd2\x9f\xf2\xbf\xac+\xde\x1f\x1eH\xdf\xbfl\xde\xf8O\x8f\xd8\xec?\x9f\x0b3+I#\xb7\xbfXBJ\xae>\x8a\xf1\xbf\xdf\x16\xdc\x9f\x00\xe9\xcb\xbf\x08\x89\x97WU>\x05@\xb1\x8ed\xffOv\xfb?=\x88C\xf5T\x17\xfd\xbf1#\xba\xc4\xe19\xf1\xbfJ\x94\x0f\xa0\xa2\x95\xf3\xbf\xb7Vs\xda[\xf7\xb0?\x08\xfc\x9dX\xd0\xad\xd3\xbfF\x9ep\xfeL6\xb1\xbf\xd9D\x02\x0e\x8b\x15\xed?\xef\xbb\xf8\x91\xbe\xfa\xd4?\xddP\xff\xb0\xe00\xf6?||\xd5\x9d\x14F\xcb\xbf\xbe\xdc\xc6\x178\xf3\xfe?lr\xdbD\x8d\x1c\xd2\xbf\x0f\xc9\xf73)\xe2\xf1?\x12Vw=?.\xcd\xbfmGx\x9dW\xa6\xd1?>P\x1b\x1b\xd34\xdc\xbf)*\xc2\xd0\xbc:\xf0\xbf~\xcc&\x99/\x9d\xfd\xbf\xcf\xc2.\xd3\xfd\x97\xd1?\x96\x03k\x1bp\xb2\xf0\xbfc\x1ao\xd5W\xb2\xec?\x932\x85\xfe52\xfb?\xec\x81\x11\x1e\xd2R\xee\xbffv^*i\xf5\xd2\xbf\xb3\x9c\xe3\xf7\xcb\xbf\xf0?\xc6\xcb&\x06x\x01\xfd?\xd8pdO\xc89\xd4\xbf\x93+S\x95a\xaa\xe1?*e\xc4\x04K\xcb\xe4\xbf\xbd-\xa9\xf80\x7f\xc1?$\xeeTH\xab\xd9\xe2?\xb0\x99\xfe\xd3\xdaF\xc6\xbf\x9e\xba\n\xf2^F\xfb?vQDAlY\xe1?\xed\xd0\xb2\x06\n\xa9\xed?b?=\x94\x89\x14\t@\x0f\x95k\x03(]\xf6?\xea\xa5P4\xba\x99\xd7?\xde\x88\xc5\x1c.\xbe\xd2\xbf\xff6\x9b\x99\xfc\xf7\xf1\xbf\xecf\x1a\xd2>\xa6\xdb\xbf\xa0\xfd\xd9\x81E\x9d\xec?\x1f\xdb3\x9e\xbf\x9c\xd5?\x8f\xb9\x96K\x8e\xe8\xfa?\x8f>\xce\xcdp\x08\xd2?\x13\xec5E9\xdf\xea\xbf\xb4\x91\xea\xf8\x13v\xd2\xbf\xaf^\x83\xfd\x8c.\xe2\xbfK\xfc:y\xc4\x16\xe3?\x0f\x15\x0fQ\x9a\xc3\xca\xbf\x89[\n\xff3\xbe\xd7?\xaf\xcc\xb7\xeaw\xab\x05@\x9a\\:\x10\x9aj\x02@=n\xc3\xdc\x1f\xeb\xe5?R\x12N\t\xae\x86\xf5?:Cu\x1dxi\xfb\xbf\x1c\tJl\xaf>\xe8?\x0b-\x9a}\xa0)\xff?\x1c\x9ff\xba\xb8\x9d\xd7\xbf\xc3\xda\xa7\x19\x05\x95\xb2?\x97\x15\xd3D\xb00\xed\xbf\x1d\xcc\xbf\xccG\xe5\xf6?4\xc6\xe2Zc\xb4\xd5?\xbeq5\x16Pr\xfc\xbf\x9f\x97\xb1*\xf3\x0el?\xb8\xb1\xa0\xdd$\x14\xcd?\x85\xe0_k\xe8\xbd\xf9\xbf]K,c&\xdd\xd5\xbf\x00\xe4\x8cC.\xe8\xf5?\xaeW\x06k(\xc1\xf1\xbf1pK\x1c\x88\x86\xb8\xbf\xb8\x0fBu_\xea\xe1\xbf\xcas-\x02\xd8\x8e\xa1?M\x80\xa6\x8b\x1f\x19\xe4\xbf\xe5\x95&n\xce\t\xc7\xbf\x19\xc4\x89\x9bK%\xfd\xbf\x88\xc4\xca7\x9e\x03\xd9?jf\xba\xc1\xbe(\xd0\xbf\x81\xfe\x85\x91\xf6\x8c\xa6?\xd5\xb4\xe8Xj\x81\xe9?UPsckm\xf4?\x9f\xdd\x1fA\x80\x0c\xf8\xbfS\xd4.#\n\x92\xda\xbfY\xdaN\x9b5\xf5\xcd\xbfUJ\xf68\xcb\r\xb4?c\x90\xdd\xa4x\xb4\xb6?\xcd\x98\xe2\x1bN\x08\xec?\xeb\xf9o\xaa\xc8\xe4\xbf\xbfP\x173\xea\xf6c\xf2?\x95\x8b4\xbd\t\xbe\xe3\xbf\x9aH\xfc5\xbc\x1f\xc3\xbf\x04\x8f1e\xc80\xcb?\x05\xc6\xd8C\x0c\xe6\xf9?S\x84\xc4\x1c\x9b;\xc9\xbf\xee\xa0\xb27Kj\xa5?6O\xe1\x12\xc74\xd6\xbf\x9eG\xe8>\xa2R\x00@\xe8\xa5\x03x\x99\x8f\xf2?\xf4\xd3\xea\x17\x8d.\xe3\xbf\xebYp<\xda|\xe0\xbf\xde\x1c\x95\xf3j\xbe\xf3\xbfK\xde\xcc\xc5\x90x\xeb\xbf\xd9\xb4 =,\xb2\xdc?\xf4\xbe\xb8\xafW\x82\xdb\xbf\x81\x06\xa4\x04\xfeh\xc9\xbf:sMo1+\xf7\xbf*\xa6\xb1\x9a.\x85\xe7\xbf]\x07B\xec\xa0\xde\xc7?\x93S\x94\x9b*\x83\xe4\xbf\x1c\xfef\xc5\x96E\xf1\xbf\\\x80\xc3\x10\x1e#\xe2\xbfC\x7f\xa0~mM\xd3\xbfh\xa6\x0f\x90z\x03\xe4?\x99Z\xd0$aF\xf4?\x12O\xbb}OM\xde\xbfQ\xb6<\x8f\xa0\xa4\xed?6l\xc0?ja\xe4?\x05\xec_\xcfk\xe4\xab?\x98\x0e\xdd\xdb\x8f\xdc\xf3?PE\xd1\xfdk\x0b\xff?\x15[xA\xfc\x1b\xf0\xbf\xefy\xce\x0e\xa6t\xcc\xbf\xb0{WdF\x9c\xed?\r)\xa3o\xac\xc4\xf5?~\xc7\xb9_\xd1b\xd7?\xd5\x10\x97\xc3\x13\xf4\xf0?\x1e\xc0\xbdW\xc1?\xf0?}\xe5\x87J\xb4>\xe0?\xaa"DRC\xa1\xdd\xbfl\x1d\xb7l\xae\x90\xd2?\x91\xbakW\x95\x1c\xea\xbf\n\xe0^\xa3y]\xf7\xbfm\xd0s:\xab~\xf8\xbf\xb3\xb9I\xc0\xb6Z\xf1\xbf\xbd%\xf5\x9e\x01\x04\xe5?\x06\x1c\n\xb6\xc4\x17\x00\xc0\x02\x96z\xa3#\x91\x0c\xc03\xf8\xc6\xe6*\xaf\xe8\xbf\xd4HW\x0b\x12-\xe0\xbf\x84%}R\xb4F\xfb?\x07\x1a\x80z~5\xf0?LlO\xcc\xdd%\xd9\xbf[N.\xec\x9c+\xf8?\xa3\xf3\x1e\x94@\xa1\xf0?\xcc\xaf\x7fT\x0e7\xf7?B\x04@s\xd2\x99\xde?\xbb\xd5\x88vG/\xfe?2\xba\xe3\xa8\xfa7\xea\xbfRq6|4L\xf2\xbf\x13l*3\xea\xa2\xcd?/=\x9a\xff\x16\x84\xf3?\xa4\x9d\xa8^|\x18\xbe\xbf8\x848\xe4\x07\\\xf9\xbfD\x9fn\xc3\xb1\'\xe7?7\xbd!R}\x0e\xf0?\x84\xb5\x82\x07R\xd1\xe8\xbf:\xc4\x06\xd4V:\xf3?Vg\xad\x15\xd4\xaf\xde\xbf\xb5\xa0/\x8b\x04\x9b\xe1?\x99\x0b\xbc\x80\xf1k\xf8?k6G\x1f\xef)\xf9?\xe3\xdc\xab\xda\x03\xbe\xf6\xbf\xf7\xeaXh\xfb\r\xf9\xbf\x12P\xe9\xbb<\xe1\xf1\xbf\x18\xaep\xd8y]\xe8?\n\xc1\xa1\x8cb$\x9d?`\xa3\xf9\xd6\x0fT\xf7?o\xc57k\xe8X\xf6\xbf\xa4~%\x034\xe4\xdc?\x05\xa8F<\x1fG\xd5?\x1e\xf2\xf5!\\O\xf8?o]z.g"\xc1?;\xa2\xb1\xc2H>\xf1?\'v\xd9\xd2\x83\xe7\xe8?\xfe\xcfVm\xedp\xf0?\xc8)\x81w\x02\x1e\xe0?m\xa4\xe6\xbd0\x05\xbe?Teq:":\xca?xEF{\x13\xb2\xc9?\xf4\xd9\xef\xdeP\x85\xe9\xbf\x9d\xa6s\x8f\xce~\xd9\xbfmI0\x03u\xa6\xf6\xbf\x02\xeb\x8b\x8ff\x06\x01\xc0\xaf\xfb\xcf0\xd8\xea\xf2?\xaa9d\xef\xd9\xf3\xd3\xbf\x8eJt\xac\xae\xe2\xe4?>$k|\x9d\xf7\xec?\xdb\xfc0\r\x14c\xc4\xbf\xe3\x04L*\\L\xe5\xbf\xef\xdbb\x07vy\xe6?\xe2,\xa12\x043\xd0?sW\xd33\xffV\x06@\xa6K)n\xd7\x8e\xe0\xbf\xe53=\xc3\x7fR\xd6\xbfy\xbe\x9d"b\xe5\xe9?*\xfc\xbd\xef\x17\xed\xe4?\x13\xd7b\xf4\xb1\x1a\x02\xc0v\x98\xf0\x93\xa8\x12\xdf\xbf\xdb\x9ft\xbd;!\xf0\xbf,\xc8_:u\xfb\x04\xc0\x9d7l\x12w,\xf1?E78\x82\x97\xac\xc9\xbf\x82\xa7*M\x08\xb4\xf9?Y\t\x8bs\xe5\x13\xc0\xbf+\xb4\xd1U\x9b\x00\x00@\x97\x02\xe8\tm\x87\xd8\xbf-~\xe7\xa5Q\xd0\xbd\xbf`aG\xdf\xb2\xbe\xe2\xbf8F\x1c>\xc9t\xd5\xbfD\x87\\1\x0b#\xf2\xbf6\'j}\x814\xff\xbf\x1dw\xe9\x9f^l\xdc?\xfb\xcf9\xe3Jv\xff\xbfr&\xd6X\x02\'\x98\xbf\x10\x9fM\xb2h\x83\xe5?\x13\x1822Y)\xf5?\xbd\xc5\xebq\x9d\xcb\xfa?\xa0\x8a\xf0\xe4\xab\xec\xf2?\xe4\xa5\x99\xe1\xde\xda\xe0\xbf\xc3s6\x98b\xdf\xbe?\xe4~\xab\x83O\x01\xc7\xbf\xde\xfe\x0f\xb7\xb4\x94\xcd?\'\xdb`F\x88\x85\xe2?W\x0b\x9d\xc0\xc8&\xa5?\xd4\x15\x9b\xb1y\xa9\xe5\xbfql\xd2/\xe9\xf6\xdc?\x91\xdc0]\x83\xe2\x05@c\x83M\x9e\xab\xf8\xde?\x94h\xff\x9d\\\xea\x9a?\x02\x80\x81;\xb9\xa5\xd0\xbfA\xa6\x0b{~\x8c\xf1\xbfK\x0br\xaa1\x9f\xfc\xbfB\xb4\xdb-M\xea\xa6\xbf\x11\xbf\xa55\xf5z\xfc\xbf&{\xe8\xc7\xd6\x9f\xf2\xbf\x17\xa6\x19\x14\xc7W\xf8?,\xde\x04\x03H\x86\xd7\xbf\x81\x01C\xb2\x15\xa5\xe6?^\x82@\x88\x17\x05\xf9\xbf\x0eg\xd1\xf4u\x14\xee\xbf\xc65@\xe3\xad,\xd4?\xfc\xdeO\x08\xa6o\xf0\xbf\xe1\x1eUn\xf4\x97\xf3\xbf\xb2\x98\xa4\x82\xbe\xd0\xf7?S\xa8\xad\xe9\x83\xad\xe7?/\xd3\xd0*h\xc5\xf2?\x8a\x15\xc6;|\xc9\xd2\xbfubM\xc2\x08\x17\xdc?y\xe1\x12\xc3\xea\x81\xef\xbf\x9d\xfa~jW\xf1\xfc?DY\xafR2c\xfb\xbf\xc1\xfd\x94\x7f\xdcO\xf7?\x97\xdd\xb5j\xd4D\xe4\xbfGvMO\x00\x98\xd9\xbf\xc8\x99\xe7\x7fJ\xb6\xf5?9\xdcL\x8f\xcc\xa1\xb4\xbfF\xa8\x83\xb9\xf6\xe3\xdc?\x99\xf8\x01Evx\xea\xbf\x923\xf0R\x8fg\x00\xc0\x12d\x8a\x8c\x9b\xb0\xe2\xbf\xe0\\\x8eD\xe4\xe7\xf3\xbf\xb5\xd3\x8f\xabm\xee\xf2?\r\x8d\xbdIY\x14\xe7?\x95Q\x93\x14\x0b\x15\xf5\xbfe\x98?\x97\x81\xc3\xe0?\xec\xba\xe1U\xa8\xb2\xeb?k\x8ba\x9b\xfd\xc9\xd9?\x05\xb7\xcf\xab>9\xf3\xbf;\xe4\xbb\xcc,(\xdb?\xe6t\xab:\xcb0\xe5\xbf\xd9\xd0P\xb8\xf7\xef\xe9\xbf=-+GK\xd9\xf2\xbf{\x9d\xca<\x13\x00\xfa?\x01\xe4\xdd\xf8\x86\x06\xfb\xbf^\xbd+\xf3\xf8v\xf9?\xde\x9b\xdc\xc3\xf9\x85\xbc?\x1a\xd9d\x81\x95 \xba?\xd05\xcd\xa9\xa5\x94\xea\xbf\x86a\xd7D\xc8\x87\xec\xbf~\xd7\xc1$\x89g\xb1?\x9a\xfc\x8a\x12\xd9i\xef?!s\x97\xa0\x00\x93\xf2\xbf\x85q\x1c\x91\x02\xb4\xb6?\x07\x81\xf9{Nz\xe5\xbf\xe5"\x97\x158&\xe7\xbfP\x9dl\xd0e\x93\xd8\xbf6\x06\xfd\xd2\xef\x9d\xcf\xbf\x8a\xa0\xb1|\xefy\xf7?:\xff\x8dc\x862\xf8\xbf\x85\x7f;\xc7\xdc\xc6\xb3\xbf<\xf0\xb2u\xc8\xfd\xff?\x7f,\x01~\x92s\xee\xbf\xf9\xd7\xd4\xaa\xaf\x87\xb5?\xfa\xaf\xcf(\xc1\x19\xf1\xbfzt\xd0\xccP\xc7\xf3\xbf\xd7:\xb5\x0e3\xb7\xf5\xbf"\x0e]\xfa\xac\xc2\xf1\xbf5\xda\x0ew\x7f\x1a\xf9\xbfE\xb0\xa1A\xfa1\xf8\xbfa\xad\xc2Qz.\x01\xc0\xbe\xb8\xca\x83\x9c\x97\xe3\xbf\xe3E\x0b\xc1\xe9\xc0\xeb\xbf\x07\x01\x93\x1aPN\xfd?\xb5\xbbh\xedBa\xc7\xbf\xa7u\xc8}\xd7t\xa0\xbf\xd15\xca\xa4\xec\xfc\xda?n\xaa\x9d\xca\xe4\x9e\xf7?\xa6\xb3\x98\x87\t\x81\xe6?\xed\x88\xa3\xd5\xa3\x1b\x00\xc0\x8b\xa3\xf8\x83\xee\x17\xea?\\\xd1\xe6\xbd2\xed\xe1\xbfX%\x89\xf2UQ\xca?\rmOE\xd1\xe6\xe8?w\x0f\x07Y\x11\xec\xeb\xbfZ}\xff\x15F#\x8d?w\xab|\xed_\x1a\xdb?s\xa9\x98[\xdeD\x00@\x86\x8e\x90\xc3n\x82\xfd?\x9bm\xca\xcdeW\x8e\xbfF\xeb\x03?S+\xf0?)u\xd0\xd3\x90N\xf4\xbf\x96\xf3a\x9d\x93\xc0\xf1\xbf\xb9t\xd7R=\x0e\xe8\xbf\xac\xc5\xcfO\x19\'\xe3\xbfB\xb5\xa2)\xdc#\xf0?\xb4\x1e\xe9\xf8\x10\xa0\xe9?\xa9\xa7\xd5W\xd2\xb0\xe3\xbf\x1dD\x1d\xa3t}\xf1\xbf\t\xec\x18\xcfg\xf8\xf6\xbf\x9c\xfd\x04\x84\xf5e\x0c\xc0\xca[\xd3q\x93\xb6\xf5\xbf\xc3\xf5!\xddAp\xd0\xbf\x15\x8b4rX\x04\xd0\xbf\x05\xfdj\xe0~r\xe4?\x1f\xa1%|*,\x01@\xb3\xdaG\xed\x9d[\xcb\xbf\x84\xc3XQ\xa9\x91\x84\xbf\x95\xfb\xf6\xcd\xe9\x89\xe4\xbf84\xa4m\xfbl\xeb\xbf\xf2\tM\xd9.}\x90?\x8c\x025\x02\x81\xbb\xdc\xbf\x9f\x8a\x97\xedw\xd0\xe7\xbf\x80\xea\xd22C>\xf4?\x99\x12\xf8\xaf\x14\x05\xf3\xbflyZ4s\x7f\xf7?sn\xbf\xed\xa3b\xde\xbf_[d\x87\xf7]}\xbf~B2\xb6\xc0`\xf5?\xf8@\x9c\xf6\x00C\xeb\xbfMr3"\xd8\x80\xe6\xbf\x8a\xe3\xe1o\xbfo\xd7\xbf\x8d\xa7h>=\xfa\xec?yb\x94\x807g\xf7?\x95\xb4\r\x86\x84(\xd3\xbfA\x15\xd8\xa3=|\xfc\xbf\xb1\x99amqh\xfd\xbfY,#3\xe1\x18\xe4\xbf,8\x04P)\xa7\xf0?\x12\xe8\xa3\x9b1\xf9\xe2?<@$\t\x7f\xec\xfe?Z\x9b\x1cuT\x8d\xf4?\x9eN\x81 \xd7\xc2\xec\xbf\x9c\xdd#\xbf\xe8\x03\xde?\xde\xf2vG\x0bE\xc7?\xb2\x81n\x06\xca\xd0\xed\xbf\xcen\xe9\xa1\x12,\xcd\xbf\xb8A\xe0p-[\xfd?\xa3)\xfcjR\xce\xf3?\'\xb6R\x04P\x0c\xe1?=Xm\xc9Hs\x00\xc0\xd2\xa72\t\xfa1\xe4\xbf]\x0b\xbeA\xafG\xc5?\xa6\xe3\xf0(H\xaa\xf2?\xe1\xac|Y]\x91\xe3?\xdd[\xbf{)Y\xf0\xbf\xd7\x8d\x1d\xf8\x1f\xf7\xf8\xbf%\xa0c\x01\x8b\x8a\xfb\xbf\x0c\xa1u#\x1b!\xde?\xa0\xcd[\xf2\xb6\xcf\x05\xc0K?\xa4\x0f\x82\xa7\xd8\xbf\xfd\xea\xb6^\x1c\xdb\xe5\xbf\xad\x8c\x14\x8a\x8c<\xf4?\x1a\xaed\xa7\x8e\x01\xf8?\x8c\xc09\xd0\x85\xf9\xf2?a\x83)\nP\xa5\xce\xbfRA\xe7F\xf7\x84\x00@P\xc4\x93\xda\xa6\xf1\xfa?\x93\xa50\x12\x92\xb4\xf2?]\xa5\x1c\xd5\x88R\xf2?\xfcv*\x80\xd8\xb6\xe3?\xf8\x94Q\x9e\xd4\xf9\xf0?\xae\x9f\r&\x9f\x03\xee?\xce\xf4\x17\x89\xeeT\xc7?\xbf\x87\xc3\x85\x89\xf2\xf1?U\x9f\t\x87$N\xb2?\x1b\xa0i\xea\xa4\x91\x91\xbf\xe8F\xc8@\n\xc8\xdf?\xb4\xfa\t_\x9cY\xf0\xbf\xea;bP`\x83\xea?\x16\xe1\xbf=0v\xba?@|\xc1\x15\xf1\x1e\xf2?TS3\x14\xcbr\x02@\x90\x19\xf0\x94\xe7\xeb\xf4?Y\xd0\xad\xeb"\x82\xf2?\x04<\xca+)\x18\xe2?\x83F\xfd\xb3\xa3l\xc7\xbf\xbeb\x9c+\xa6{\x01@)j\x17\xe9;\xc5\xe7?\xd7f\x04vP\x84\xb2?\xefowN\xd5\xaf\xf2?\xe0\xa8X\x15h\x02\xc8?\xe1\x9e\xec\xf1\x14\xbf\xfe?\xab\xc7\xd6\x14\xd3-\x05@\xabj\x8d[\xa2\x9d\xf4?\x11$Z0F\xe2\xe3?Hma\xd3g\x85\xde?\'\xb9\xf80w\x0c\xd9?`\x11\xf5\x17!W\xfc?\xbb.\x95\x92\x07\xce\xc0?\xf6\x03^F\xf0*\xb8\xbf;\x1a\xee(WC\xb6?\xf0F\x929\x8a_\x8f\xbf\x0f\x1b6@?#\xb0?\xc4\x9f\x92e=f\xf5?\xcc\xf1\xdd\xb6\x0fd\xd2\xbf\n\xffyEC\x05\xe6\xbf\x88p*\xb0\x13\xae\xe2?\x07\x01wTW\x8c\xc6\xbfD\xd1\r\x84I>\xc4?\x074%\x10\x06\x0f\xcf?ei\x1e\x0c\x19\x9b\xd0?b\x00@4\xd9I\x03@\xf3\x19\x9a7\xdeU\x04\xc0\x04\x1c\xa5\xa23\xce\xd6\xbf0R\x18Gvr\xf0?-\x85\xe8\xae\xf7\xb9\xe9\xbf6\xfe\xda<\xe7\x94\xc6\xbf*?\x87\xc5F\x1a\xea\xbf\x0b:\x99\xfb\x9c\xee\xee?\xe6A\xae\x18Y1\xfe?\x91\xa6\xfc\xb3\'\x9c\xdd\xbf\x88\x84;\x1b\xfd\xe7\xe6?*A$\xa8?\xeb\x04@\xbe\xb9,\xe6(B\xf8?\xf3!\x1c\xa2t\xa9\xdd?\xf7\xaa\xe4\xa8v2\xc7?*RM\xab\x9a\x07\xe5\xbf\xf5\xdd\x1c)\x0b\xce\xdc\xbf\xed\xf0\x1d)\x19\x7f\xe2?\xd3O@?%\xe2\xe1?\x85\x89\xb8\xfa\n\x9c\xf1?\xcb|\xe1\x01\x7f\n\xe4\xbf\x05\x8f\xb2\xd0|\x1c\xe6?"\xcd\x8e\xdfd}\xd0\xbf\xc9\xff\x1f\x12\xa2\x95\xbe?\xbe?\xcf\xb6\xb4\xca\x98?\xd5Z\xa0R\xa70\xab?\xa0\xc6\xbe|\xe0\x93\xe4\xbf\xd9\n\xb6#\xb0?8\xbf\xa3f.-\xb7\xd5\xe2?\xe7\x05@0\xe7\t\xe2\xbf\x83\xc7\x87\x1a`L\xd7?\xbf\xf1\xcd\x12k\xd7\xd7?\x11\xddU\x96)\x94\xf3?\x1e\x84I\xe06\xb6\xf5?5 \xa5\xb0"\xee\xd3?\xf9R\xb5"\xb7Y\xec?\x94n\xac\xcb\x84\xf8\xde?J\x1a\x8e\xcb8K\xc3?"G\x06\xd30\xf4\xd6?\x89,"b\x08\xfe\xff?\xe4\x1aX\xfd\x89\x90\xa3?\xf7G\x85\xd9\xa3\xb8\xc7\xbfn\x03\xf8Dy\xb1\xf0?\x0ei\xd5M\xf9\x14\xa7\xbf\xd4lh9]J\xd4?U\xe7any\xf0\xec?\xbb\xb8$b\xbb\xc3\xdf\xbf\xa1\x85\xacw\x11\x02\xcf\xbf\xbe\x1e\xd6B\xdaJ\xf5\xbf\x81]\xc6\xad\x13\xb1\xcc\xbf\xf7\x927\xc1,\xac\xed?\xc0\x01.\x917"\xe6\xbf\x9f\xd2\xf4\xaa\x97\x95\xe1\xbf\xa5\x93\x01B*\xf7\xd0?\x114d\xcc\xf3=\x01@Y \xd9\xd3\xdbI\xfa?U\xc5\xe3p\xf1\x1d\xea?3\xbc\xdb`\xc9\x0c\xdf\xbf\xef\x1bl[\xba\x07\xc2?\x1a\x91E;\xd1(\xe1\xbf\x97!C\xb3\xc7e\xa4?\x14\xcc\xe5(P\x0f\xe7?\x8ag\x8a\x8b\xd1\xa3\xf3\xbf\xcb\xea^;\xef\x90\xf4?\xbcm!\xcd\xff\xfc\xf3?\xdb\xac\x99d\x90\xd4\xcb\xbf\xd5E\x7f\x1df\x8d\xf8\xbf\xe6\xb0\x17~\xd8\xa1\xd5?\xea\x88\x01\xa8\x15\xe7\xde\xbfR\xc4\x0f\xfe\xcc@\xfb?\'39\xa3\x18\xfa\xe4\xbf\xd6g\x81-\r\xd9\xef\xbf\xbf\xd9w/.\xd4\xe8\xbf\xafxc\xde\xdd\x86\xe7?\r\xca\tF\xb3\xcf\xf2\xbfA\xa3\xbf\xfa\x1c\xd6\xa2\xbf\xd5\xf4d;v\x85\xe7?J\xd8mv\xcd\x87\xf9\xbf8"EE\xfa\xae\xee?NT\x7f\xde6\x9b\xe2?hO\x1bE06J?\x02N\xe2/o\xb7\xf9\xbf\x13\x86o\x0b\xc3\x18\xd1?\xd0\x9f\xb5\xd6\xb6\xb4\x05@\xc8\x89NK\xb1\xf7\xdd?\x97\x05"\x07\xf9!\xeb\xbf\xad-\x01\xef\x1d\xd1\xb3\xbf\xf2\xf3\xd5\x04\x02\x8f\xc2?\xf1\xe5\xbd]L\x19\xd9?C>\x97\x02z\xa1\xd5?\xe0$\x96\x05.\xd1\xee\xbfz/.\xd0\xd3\xb1\xe8?\xfa&b\xf2jE\xbe?\xb4nzpU\xb0\xbe?4\x01\xf5\x93\xb1{\xd7?\xf6*0B\xb5\xb3\xf4\xbfX\xcb\xa1\x80\x87\'\x9c?5\xcf\xae\xb6\x88\x0e\xc2?O\x83"\xf7\xff\n\xfa\xbf\xeeItj\x80:\xf2\xbf;g\x1d\xe1\x15\xf2\xed?\xf8B[6\xd1\x18\x03@\x05\x98\x90\xfd\xaf\x9b\x00@|F$\xfd\xd2\xdd\xe6?\x1e\xc0\x86\x8bCy\xec?HiUW\x93\xd1\xd4?u\xab/<\xe8O\xa8?!\x14\x93\xb4\xf3\x8c\xf6\xbf_\xa0\xa9\xc7\xf7\x8c\xdc?\xf7\xe9D$\xa3\\\xca\xbf\x1f0V\xa3\xb3_\xe0\xbf\xf2\xb8\xa4?z\x08\x04\xc0._+\x10rX\xf1\xbf\x04H\xfe\xde\xf2\xdb\xe5\xbf\xd7;B\xf8\xd9o\xc6\xbf\xafL\x84,X\x9d\xe9?\xe0\xeb\xbe\xe1i\x9e\xe6?\xa8a\x90\xad\x1c\xc0\xb3??.(b\x86\xa0\xf4\xbf\x06\xa4m\x1c)\xb1\xb4?\xa6\xd4\xab\xf4O\'\xe1?:\xd2\xdb7\xebq\xef\xbf\x1c\x0b\xb1\xed\x95\xef\xf2?b\x102\x01\xe0d\xe2\xbf.\xce!\xb7\xcei\xd3\xbfo\xe2\xb9\xc1&\xd3\xc2\xbf\xdbk\xb7}\xd0D\xf1?\xaf\x1c\x9c\x98!$\xec\xbf\x85@D\x95\x03\xdd\xf5?\x1e}\x13\x0f\xf0\xbf\xfb\\\xab\xef\x85\xc8\xa0?J\xfd+,\x86\x1f\xeb\xbf\x13;&\x82\xa4\xe8\xe1\xbf=\x86h\x82\xd3<\xfc?\xac\xf9\xa4\xff\x9b\xa8\xe1?\xc9\x85\x1a\x7fsP\xd3?\xd4\xbd\xfd-\xf8\x17\xee?M\xbcC\xe9\xd4\x17\xfc\xbfrSCTU\x85\xed\xbf\xfaaO\xc3\xd8 \xf6\xbf\xbf4\xa6\xfe\x98\x93\xc6\xbf\xfaf\x9b\xac\x8f\\\xcc\xbf\xd7\x7f\xe5\x0c\x1e\xdb\xf7\xbf{\r\xd0SZ\xc6\xda?\xc4\xce\xe2$\x90\x15\xea\xbf\x89\xce\x14\xa1\xaa!\xf3\xbfZ|@r6>\xd1?\xc37\xfaY\xcf\x98\xfc?\x8c;\xbb\x02\x94\x8d\xf2?4\xaf\xc7\xdb\x05\xf0\xd4\xbf\'\x8b\xea\xca5\xc8\xf2?\xe6\xfb_\xc7\xfe\xbd\xe6\xbf\xd37z\xc3e\x9f\xe4\xbf\xbf\xcb\x80\xcbp\xa1\xea?\xcc\xc6\x88\xab\x10"\xfd\xbf!\xcc\xaa\xf6\xdc9\xf1?0_g\x01\xc7\xb0\xe3\xbf\x8b\xc8\x84\x02}\xe2\xff?\x1c\\\xa9\x02\xff\x84\xe9?e"\x8e\xbcq\xa3\xeb?\x19\xbc\xcb\n\xd2\xc9\xd1\xbfMkB\xf9i\xb7\xe6\xbf\x9e\t=\x9fD\xac\xe3\xbfC\xf7\xadY\x0c\xba\xf4\xbf\x074r\x83N\x89\xc3\xbf_g\xb8ie\x97\xdc?\x06\xd4\x0e\xae\xecV\xf2\xbf|-\xba\xc6\x90\xd8\xec\xbf&>\xf89\xf4\xf7\xef\xbf\'w\xb1|KJ\xf8\xbf8KK\xe0\xe8\x1d\x05\xc0?\x9d\x17\xf6\xb2=\xe6\xbf&\x06\xcc+y(\xdb\xbf\xfc\x86\x97\xd4/\xc9\xc6\xbf\x1fQN_\xe4\x9f\xeb\xbf!\xb5\xc7\x94\xdf\xad\xf3\xbf\xf4\xb3\xfb\xbd\xe2v\xe5\xbf{\xd0\x9a!\xb8\xf9\xf8\xbfv#\xfb?C\x06U\xce\x0cm\xec?+-w\xb7\rE\xf6\xbfl QFL\x0f\xf6?\xf1l\xba\xa4\xaa\xbc\xd4\xbf\n\x93\xa1`n\x1a\xe3?&HgA\xf9\xc9\xdc?\x04\xc8\x1fF\x85\xa4\xe9??\xa4\x1c\xdc\xcd\xc9\xa1?\x7f\xee\xe5gnM\xf4?\xa7\x8a\x99\x8a\xcdP\xb9\xbfd@\xb0\xf8K{\x08@g\n\xcc\x0fy-\xff?\x93\x13x~:\x90\xf1?\xd4l\xc9:W\x1b\xe8?{w\x9c\x07X\x87\xaf?\x92\xb4ys\tn\x9d\xbf\xdd\t\xad\xb3\xc6\xb2\xf6?\xc1G\x82\xc0\xb4H\xe2\xbf\r\xee\xccXRK\xb2?YTZ\x7f\x89\xe6\xec\xbf\x129\xd3\xf3\xca\xca\xfe?\xc3\x9d5\x82dS\xc0?5%\xd1\xa8\xe3\xee\x05\xc0\x15D\xad\xe9\xf9)\xdc?\x8cv#\xd8\xc4d\xd7\xbfV\xda\xd2\xe7v\x97\x02@\x96\xe4\xec\xb1\xbf\x0b\xd9\xbf\xf3\xd0\xd8\xd9\xdb\xf4\xf3\xbf\xb9d!\x98<\x13\x9d\xbf}0\x818\x8dT\xc1\xbf\xc2i\xaa\xec\x99^\xda\xbfr\xc3\xf7\xa6\xc1\xb8\xe4\xbf\xfc\xd3\x99w\x01\x96\xf9\xbf\x15\xe2$\xab\xbek\xab\xbf\xfc\xc5\xf0\xe9\x99\x94\xeb\xbfF\xae\x15\x1a|{\xff?z\x815\x1dO\x99\x10@\xf693\xc2\x08W\xfe?y\xfb\x1bG~z\x01@MU\xf7),|\xf7?\xa8\xed"E\t\x1b\xf4?\xa0k\xd2\xe2\x88\x1d\xf2?\xf7\xec\xc7\xfd\x0b\xae\x01@\xf6\x11\xddo\xf1L\x04@\x8eJ}\x0e\x95\xe0\n@h,\x9f\x835c\xf3?\xf9\xc8R\x8e\x103\r@\x08\x95\xc3\xe3d\xc1\xc6?J\xc8\xf5\xe8\xf5D\xf5\xbfqH<\x87Z\xa7\xdb?\xc0v7\xaf&\x8c\xf6?\x87\xfd\xb9@w\xc7\xb4\xbf\x91\xb7}\xca=\x84\xd7?!q\xe8\\6\xf3\xc8\xbfl9\xcf\xd3q\\\xbb\xbf$\xad\x8d\x8c\x8c\xb4\xd5\xbfg\xce\xaeTUY\xde?-\x85@\xdc_\xfc\xcd\xbf\x90\t\xb9\xc1@\x89\xf1\xbf\xbbU \x06\x041\xfe\xbf#c\x98\x03]\xba\xf2\xbfEd\xe9\x90\xcc{\xd6?}\xb6\xe3\x1d \xd7\xf8?\xe8\x91v\xafm|\x03@\\^\x03\xca\x17\x02\x02@\x9e%\xf8\\\xa9\xcd\x11@\x84\x1f\xb9\xbcU\xbd\xf9?\xffX\x11\xf2\xf2\xbe\x0c@U\x7f\x14\xf7\x81\x81\xfc?\xd4Cv4\x06\x90\x11@M\x98[a\xddy\x03@\xc3\xd3\x9eP\xbe\xbe\x06@65t\x82]\xfb\xf8?\x10\x05\x05X^O\x01@\x8d\x9boe;?\x81?\xe4a:\xa2\xd5N\xe2\xbf\xef\xd5-w\xaf2\xf1\xbf\xd0\xdbw\x9d\xed\xd4\xfa\xbf\xee\x90\xe96G\xa2\x92\xbf\x02K\xeb\xcbxc\x02\xc0y\x16\xd6!bV\xd7?\xa4S\x91*\xff\xa2\xec\xbfkTRfi=\xac?z\xb5\x10\x1a\xb7\x1d\xf0?6#V\x9c\xc2I\xdb\xbfC\x87\xc5\xfe\x8c\x9e\xeb\xbfE\x95f\xdbNG\xfa\xbf5\xf0\xa4\x1c\x19\x15\x00\xc0\xec\x93Z\x9a\xeen\xf3\xbfe\x99\x18u:\t\xbb\xbf^n\xbb\xef\xd5\x15\xd9?\xc2Y\xado\xea\x0b\xe3?\xbdN\xae\x7fv\x06\xfa?"/\xedh,\x8f\x03@\xf9\x8fx|?&\x11~\x80\x0bq\xd9\xbf\x05O\xf5x\xb0\x91\xf8?[L}l8\xa9\xfd?\xd3\xf0\xa5R\xf4J\x04@\xfe\xb7Hjf\xfa\xe8?\xa7\xb7\xb4/\x05\xec\x0f@\xf9\x00\x07\x18"\xa5\t@\x96d\xa5+mC\xfe?o\xe45\xdbLW\xe5?|\x19\xec<\xf1\x96\xf0?/>c\x80\x83\x8b\xce?\xf8\x96\x198\x81\xd9\xe3\xbfL\xc6.f\xff\x18\xf4\xbf\r\xe4j\x8c\x1b\x03\xd9?b\xced\xf1\xc5\x8f\xf3?\x14\xd7\xaf\x0f\x90\x00\xc8\xbf4\xe30+\xc5\xf1\xe0\xbf\x93w\x0cHkF\xec?\x07\x08\x90\xfe\x06\xac\xf4?\xf9\xf4\xc6\x0f\x99{\xf5\xbf?7+\xc4\x0c$\xf7\xbf\xdc\xe4\x04\xd2}!\xb3?\x83\n\x9c\xca\\\x0f\xea\xbf\x97O\xdf&e\xb1f?\x04,}\xcbOl\xe6?9h\xdaW?\n\xf7?\xd4\xdct7\xb7\x86\xf7?\xc6\n\x1d\x0c\xd6\x1b\xe0?\x1a(\x86_Y\x91\xdd?!8\x18>\x12\x90\xce\xbf\xa8-\xf2\x8b\xde\x92\xc1?\xb4\xbcb\t\xeco\xdc\xbf\xc8=:\x84\xa5\x14\xa0?\n\xc5U\x02\\\x86\x04@l\xe4\xf4\x82_\x18\xd7?tB\x0e\x9cC\xb5\xe1\xbf\x86\xa3\xda*+\x95\xc3?\x82\xd7`\x90t\x04\xf3\xbfcZ\xbf\xc2Rg\xc3\xbfe\xb3+=u:\xd8\xbf\xbb\xbb\x9b\x8e\x03l\xf3\xbf(\xce\x92eRE\xe9?\xfb\xd7\xab\xe2_|\xf7?B9\xf6\x054#\x01@fo\xe0\x13\x1d\xb1\xe3?7l\xe4\xf7\x93\xe1\xf9\xbf6w\xa3\'\xc6\xbf\xde?\x90U;;v\xa6\x05\xc0%/\xaeZ^\xe4\xd7\xbf\xa5\x0b\x83\xa3]\x9d\xe3?\xa2hVD\xf2>\xd4\xbf\x08\x8d]&/\xff\xe3\xbf"\x9d\x00\xbe\x0b6\xf6?\xe9\xe7\x0b\x01G\x05\xf3?#\xea\xf4`\xf5\xc5\xa2?\x99|\xa5\xfd\xbdc\xeb?\x8a\xad\x85\x18a\x9d\xe0\xbf\x8cD\x8ck\r\xea\xe1\xbf4XZ\xb3\xd3\xef\xef\xbf\xf36\xf8w\xb2`\xef?\x0b\xc8w\xdbR\xfd\xd9?\xe9\xe0\xa2\xe44\xfb\xcd\xbf\xbd5Al\xe7\x94\xfd\xbf\xb2\x91\xb3q\x13\xda\x01\xc0\x19iD#\x9d\x92\xeb?\x13\x1b\xdc\x9eAp\xf4?)N\x8f:\x97\xa6\xe1\xbf\xab\x04\x17\x90\xect\xd8?\xa3\xa5\x82\xecRA\xfb?\x92\x03\xe0\xbb~\xa4\xe1\xbf\xfevo\x11>\x87\xf9?\xfc\xb3\x1d\x00\xbc\xd0\x01@\xa2\x92\x9f\x97\xd7\x07\xe9?\xc5\xaa\xcdaVi\x02@\xcf\x90\x00\x17I]x\xbf\x8f\xd2\x0bP\xff@\xf0?Xe\x0f\'w\xbb\xe3?L\xc6\xa5>\xe2^\xf5?@G1\x13\t\x02\xc9?<\xa0v\xdey)\xbf\xbfZ\xcf\x8c\xae\'\xf3\xbf\xd4B)\xb6\xd8|\xf1?u\xa7\xcc\xac\x8e\xba\xe4\xbfL4\x03/\xf1\x82\xcb\xbfU]\xd5\xba\x9e\xd4\xf6?\xc4\x7f\x01\xfbgR\xf2\xbf\xdf\xa9MR}\x96\x14?\n\x8e\x7f\xe6\xb0o\xbb?\x07O\xe9S\x17\x1c\xf2?$j;\xbd\x11\xa6\xbd\xbfbb\xbfl\xa6I\xd3\xbf>\xc2\xde\xa5\x89\x95\xe7\xbfUOO\xbbv\x80\x90\xbf\x85?\xe8\xd8\x9d\xe9\xe8\xbf\x00\xd1TKy\x96\xda\xbf\xc7I2\xf9\xba6\xef\xbf\xfa\xbc\x97\x8a\x0e\xb0\x05\xc0\x9f\xect|sD\xf4\xbfg\x85M\xe2\x8ek\x0c\xc0\xf7Pu\xff\x97\xca\xd6?^%\t\x1d\x90\xf1\xfa?\xf9/\x03\xbd\r\xb8\xf1\xbf\xbe\xc4\xdf,\x08\xa5\xd0\xbf\xc2\x0cA\x91b\x0f\xe0\xbf\xb3\xa3\xcb\x93\x11a\xcb\xbfh\x9d\x0c\x89\x02\xbb\xc0?M\xab\xd1\x13\'\xea\xb8?Q\x08\x06\x92\x10<\xd5?\xbd}<[\xf9Z\xe7\xbfz\xeb\xb8>\xb3\xa2\xc8?\xd1\xcb\xb8\xb4\x94\x89\xe7\xbf/%\xdb\x89p\x0f\xf4\xbf\xd4\xfb\xbdsnU\xe6\xbf\xd3L?\x1bi\x99\xdd?\x0c\x81\xe4<\x12\x17\xfc\xbf\x1dC2\xae\t\x97\xfd\xbf\x18\x8e\xc9\x96\x14\xe7\xcc?\x8f\xd1{\x9f\x10{\x02@\x072\x83[\xa0\x80\xc3?9.\x8c\x12\x85\xf5\xfa\xbf\xa8\x1c\x8e\xb7\xf1n\xe9\xbf,6\xeev\x9b\xda\xfa\xbf\x82m\x8dh\xe7i\xf1\xbf\xed\x95\x0cJ\x8b\xe5\r\xc0\r\xdc#\xf3\x98\x82`\xbf\xbe\x07\xb9\x16\xb7\xb1\x0b\xc0\x11\x06\x13\xc6\x10\x8b\n\xc0o\x7fh;\xa6\xf4\xc9\xbf\x1fo\x82\x0fN:\xe2\xbf\x98\x93\r\xe6[\xdf\xc6\xbf\x8e\x15=\x8aF\xaa\xb6?\x17\xf4\x85\x1c\n\x7f\xec\xbf\x9d\x11\xb7n\xa0I\xd9?\x16\x86m\x03\xd1\xa8\xf0\xbf\x8e\xd8\xc1\xa2 w\xf0\xbfg\x11\xddo\xe5\x8f\xe5\xbfh\x08\xca\xa3\x12I\t\xc0h\xda\xd22\xf3\x8e\xf3\xbfe\xc3\xf9\xbe\xd0=\x08\xc0\xc2\xae\x82\x86\xe2R\xed?\xc3\xbe\xe1\xa0h\xfd\x08@6\xa2\x10\xf9J\x06\xd2?\xf4~\xdb\x95\xc8j\xd0\xbf\xe9%\x05\xb4"b\xd6?r\x89+G \xba\xf3?7?\xa1y\x88M\xe1?\x02\xbf\x8bf8F\xda?%5\x0c \xaa\xf9\xc1\xbf\x9f\xe4c\x18Zn\xf7\xbf\x95u\xfe\xeb_5\xcc\xbf\x06\x99\xb0\x9c\xbb\x97\xd8\xbf\xac\x07\x0b\x92\xf0M\x02\xc0\xf8\x9cZ\x16\x93\xa9\x01\xc0\x91$\xcd\xbc\xaad\xe1?\x02\xb8\x9c\xea\xa7W\xd8\xbf\rd\x8e\x97\xa0y\xea\xbf)\xef\xd6\xab\x00\xb5\xef\xbf\xb8\xe0\x87@\xf1\xe5\xd5?\xd4\xf0\x94O9=\x01\xc0-\xeft\x06\'\xa4\xe0\xbf\xb2\xd5\x94\xe9\xa0\xff\xfe\xbf3\xc3\x1b\x1f5?\xf4\xbf\xf4\x19\xc6\x9aE\x0c\xef?\x1e\xebuAL\x95\xf1\xbf\xab(\x88\xc3\xc2\xa8\xf5\xbfQ4A1}\xff\xfd\xbf\x95\x7f)\xd4\x8e\xf4\xbb?1_>\xb7\t\xff\xca\xbf^\x83\x17\x84\xd2\xd9\xec\xbfJE)%u.\xf1?\xda!BY\xbaB\x94?B\xce\xac\xaa\x05\xca\xb3?\xd6\xf5\x15\x17\xf8\xac\xf7?\xe6\x1e\xb39\x14W\xf1\xbfw\xfe\x0f\xaav\r\x02\xc0\x12T\xf4-\xf1e\xc4?\x7f\x0c\x8c\x00\xb3\xe0\xfa\xbf\x91{8\xf7\x84|\x05\xc00M\x10\x98\xdb\xe0\xfa\xbf=X\x80\x1b\x18\xc5\xdf?\xa5\xb5\x8c\xba0\xe9\xe4\xbf\xa9\x1cub\x8a\xb9\xf5\xbf\x81\x8e\x0c\x1f8\xdc\x00@\xc8\'000\x89\x02\xc0\xf8Ux!W\r\x05\xc0\x82S?\xeb\xf5\x98\x06\xc0\xa0\xb5\xdf\x17\xf3[\xf4\xbf\xefU\t(\xe1s\xfc\xbf\xe9\x93\xc0\xff\x850\x07\xc0\xebny\xb8h\x11\x08\xc0\xff\xcd\x93G\x1at\x05\xc0\x16\xd3\xce\xab\xc2\xa8\x05\xc0*\xca\x8e\x807\xbc\xf9\xbfa\xfd\xdb\x00`\xfa\xee\xbf\x1c\x18\x13m\xcf<\xff\xbf\xa6\n\xcaJ\x7f\xe2\xe4\xbf\xe2\x03\xb2\x04\x99\x87\x9b?F\xc2\x18{I\x9a\xf9\xbfZ\xae\xd6\xe0 \x86\xf0?\xf7\x18R\x80\xf7Z\xd2\xbf\xa0\x95\x80ow5\xc3\xbfgL\xb1}\xc2\x99\xd0?\xca\x82\xfb\xd6\xfd\xca\x00\xc0\xa8JJ\xc6\x7f\xf1\xfe\xbfB\x16\\\xbc\x1b\xeb\xe4\xbf1\xe5\xb4\xa7\x1b7\xe8\xbf\xd6\xcd\xad\xf6\x08\x8d\xc9?6\x8ar\x83\xcc\x8e\xf0\xbf\xc0\x82\xe9D\xf8\xd3\x94?h\x1a\xbb?\xb84\xe7?\x1a:\x9cQt\x15\xb8\xbf)\xd4\x90_\xc6t\xe3\xbfC\xc4\xe8^\xa2U\xf8\xbf{\xdc\xf8SM \x06\xc0\xcc[\xccw\xde3\xd1\xbfnA\x14\x04[\xcc\xcc?\'q\x19\xd3[\xc8\x02\xc0\xebZe\xffN\xa5\xd1\xbfs\xac\xbd}\xc5\xa0\xed\xbfm_\xea\xd8\xbd\x1e\xf1\xbfu\xeb\x18:\xb4\xf6\xe0?\xd1\x8b>wC\xfc\xf2\xbfIF\x8bU\x8a\xc1\xec\xbf3G\xb5a\x18!\x05@j\xa9Q%\xa4\x93\xe1\xbf\xd3\xdd\xa4%\xd2\xcf\xf3?t\x97\xed\xe0sv\xe4\xbf\x03\x1f\x0c6\x86\x18\xfe\xbf\x98\xc6_M\xe5\xa7\xd8?\xfa\xca\xeb\x82\xee\xc4\xf3?nxa=o(\x02\xc0`\x01/\x14F\x86\xea\xbf\xb2^\x8c8T\x07\xfa\xbf\xa0\xfe\xca\xe5\x16@\xd8\xbf\xaa\xc8\x17\xb7\xe8X\xe9?\xc0\xa1\x17\x92\'\x05\xe5\xbf]\xb5c\x83\xd2\xed\xd1\xbf\x0be\xf5\x8b\xd6\x07\xe5\xbf\\\xaa\x01\xda\x17\xc1\x02\xc0\xa0kCj\xd0\x95\xd8\xbf\xe1\xfd\x84\x1d\x92\xdb\xf0\xbf%\xab\xc1\x13\x8aq\xf3\xbf\x80\x8b\xd2@\xcc6\xf0\xbfV\xf7\x1d\xfd,6\xb8\xbf\x9f;\xf9\x9c7\x8a\xe5?\xdd\xc5\xdaS\xe9\x86\xe0?>\xfd?\xc8+L\xe1\xbf\xb1\x99\xeb\x97\xcd\xd0\xad?}h\xa6\xa0k9\xe1?\xe7\x82\xd7\x8e\x1c\xd8\xe5\xbf\xb5\xbd\x0fCE\xc6\xda\xbf\xa9\x92\x91\x14\x9c\xd1\x8d?y*XP\'\xca\x04\xc0\xa6\x15\xb1\xbf\xd6\xf0\xf0\xbf\xaa\x90;\x9b0|\xfd\xbfD\xf2\xe4\x06\xa2\x1e\xc1?~\xb6\xbb\x1a\xe9#\xb9\xbf\xe4G&\x03G.\xf5\xbf7\x06\xca\x83\xe1x\xf0\xbf18g?b\xa7\xf8\xbfg\x12RV\xbb!\xc2?J\xf8u_\xd0\xc7\x8e\xbfj\xa9\xb9\xa8#M\xc6\xbf\x8c\xeci\'aW\xe0?<\xbf\xee}\x80\xcf\xa6\xbfk\x81\xf6\xb1\x82\x8a\xcc\xbfu\xb6q\xc4j\xd7\xf7\xbf\xd6\x11\xf9\x0ey\t\xfa\xbf\xf5e\x84W\xe1\xde\xcb\xbf$\x1b\x10e\xf8\x85\xfa\xbf\xe2\xe6\xba\xf8Y\xdf\xe6\xbf\xd7\x17cS\xb05\xcb\xbfu\xc8p\x91c\xa5\xfa\xbf\xdf\xa5\xec\xb5\xa0\xbb\x01@\xbe\x99\xd1\xa8y!\xb4?z?\xc3nq\xc9\xd8\xbfO!/Z\xdd\x8b\xd0?\xe7_M\x17.k\xe5\xbf.\xe1U\']h\xc1?{\x18\xb7\x85[\x9c\xc3\xbff\x8e\x02\xc2\xf5g\xcd\xbfG\xfc\xbe!\xbb\x06\xb3?l\xdd%\x92\xce\x8a\xa3\xbf\xc9\x0c\xc6\xc9\x0b{\x01\xc0\x89\xc0!\x8a\x98|\xf0?\xa8\xd9\xc4L\x14\x12\x05\xc0\xe6\xe8\\f\xba\'\xe2\xbf\xbf\xc6\xad\x11\xa6\xa0\xd8?3\xd0\xcf\xdd+\xfd\xf4?\xde\xf0\xff\x15\x19\xcc\xf8?\xec\xe3\ng\xacj\xe5?\x1a\'\x14f%\x81\xee\xbf\x9f\x04\xf5y\xefI\xd4\xbf\x0c\xebv\ra\x17\xf9\xbfJ\x89\xe5 `m\xf0?\x90\x04I\xa4@\x8b\xc3\xbf\xa2u)SL\x7f\xf2\xbf\x80a\xd5\xa8\x83\xd0\xe3?\x94\xc8\xa9\xda\xd79\xf6\xbf\xd5\xf5C\xe01@\xbc?hg\xd5u\x03\xea\xf2\xbf\xeap\x83\xad-\xcc\x00@9M\xca\xe4\xe3\xa4\xf5?\x9ch\xa3\xe8\x88\x8f\xdf?\x0fM\xf1\x86\xc5#\xe7?\xef\xcbV$\xa67\xa1\xbf\x8f\x9c0\xab&[\xd0\xbf\xe1\x1bo\x96\xcb\xa9\x00@\x14\xbe\xfe B\xe4\xe3?+t\x7f\xdb\x1f\xb1\x90?\xb2Z\xbe\x94\n\xe3\xed?\xfa|\xb8L\xdb(\xfc\xbf\x19u6\xac\x87\xf4\xb5?\x81\x82\x9e\xb5j\x81\xa3?T\xe7d\x0fT\xff\xef\xbf\x18\xc5\x94\xd2\xd9>\xee?\x98\x10\xb1W2\xcf\x05@"9\x13\xd1\x98\'\xda\xbf\xda\xcd\t\x7f\x18\xc5\xe4\xbfs\x84\xce}\x1d>\xfc?\xa9\x99\xa1\xc4\xe8\xeb\xf0?v\xa9\x8c\xd0\xca\xe4\xf1\xbfvH\xc9\xc3[\xa1\xf0\xbf\xf8QCX\x81\x88\xc6?\xd7\xb9$u\xc5[\xed?\xe9\xbcZ\xbe\xa1&\xf0?d\xb4\xf5X\x82t\xe1?\x9d\xdc^pnO\xd4\xbf\x98\xfc\x12\x82)\x8d\xf0?-\xf5\xb0\x91\xb4h\xd8?\xaex?\x11\x86\x8a\xc1?\xce\xe2~<0\xed\xde\xbf\xf6v[\x8do\xc9\xfb?\xf0w\xc92\xd3`\xde?]\xbf\x80\r!\x87\xe2?8\x8b\xcc\xc7\x12\xa0\xef\xbf{D\x9cS*C\xc5\xbf\x06\x87[\xb1Be\xea\xbfI\xed\x92K\x83B\xdb?\x1bw\x1e\xe6\x11\x13\xd9?B\xcb\xb7g\x08\x0f\xb5?\x02u\x89\x9a\xa2`\xf5\xbfdd"-\xc5\xe6\xc4?@W\x93g(D\xe3?\xb9D\xa7\x19\xf8\'\xfa?\x9f\x14S/\xee\x92\xf1?\r*\xc5\xb9\xee\x06\x04@n\x04Z\xa5k\xff\xc9?2\xb4S>\xbe\xc6\xe7?\x8c\x9c\x123\xde\xee\xe4?\xadL\x05H\x1d\x15\xd4\xbf\xdd\xa1\r\xe7\xefx\xee?\x16kl\x9f~\xe3\xfc?\x98 \x9c\x10\xcc\x9a\xaf\xbf$TM\xc55]\xf3?\xab\x91\xb9\xea\xba\x94\xfb?|e\xd6\x9f\x01>\xfa?\xd16\xff\xa5\xcf<\x02@\x85\xe36#2\x17\xe6?\xf2d\xcf\xe2TF\xe1\xbfA\xaa\xca.<\xd2\x00@\xa8\x87\xf3\\\xd1\xad\xee?\x8aA\xc3\x12\x04\x90\xe0\xbf+3\x0e\x97A\xbe\xd6\xbf\xee\x008\x0e@\x14\xd8?\xe7\xc1\xf1\xee\x04\x8a\xf0\xbf,\x04Z\xa9\x95\xd6\xc4\xbf\r\x06\xee\x9fg\x02\xe4\xbf$&\xc40*\xfc\xeb\xbf\xb3\x02\x83X\n\xcf\xf7?4\x93\x99\xa2\xb7$\xef\xbf$\xa5\x19\x9a\xaa\x8c\xf1?\xe6\xc2Uk"q\xb3?&f\xb9W\xbf\x99\xdc?\x02\x0c:\x88\\\xad\xfb?O|\xaf$,\xd0\xf4?\xac.\r\xa3Sk\xe8?\xd9\xf5\xe11]\x9a\x99?.\xa8\xd3?\r\x96\x02@\xa8\x89J\x84\xf4\x00\xd5?\xd4\xd3\x91\xef$\x08\xfd?\x93i\x06V\xec\x87\x01@\xa1\x19.M\xc9\xdf\xe7?\x8a\x0cB\xa8@|\x91?\xc3b\xb4\xe2^\xb7\xdc?_\x84\xffy\xca\xcc\xeb\xbf7\xb3H\x04)\xc7\xf1\xbf\x1ef9G\x10\xb8\xf3\xbf\xe6[&\xd4\xbb\'\xf5?m\xef&/A\x1b\xfb?THL=Q>\xf3?k\x86\x8bt\'\x0f\x04\xc0\xd9\x87\xad\xab\xdf^\xd3\xbfx\x18a\xb7X\xb6\xdd?t\xe7\xb4\xd5\x96\xd3\xf5\xbf|\xa1\x16b\xec\xc1\xea?\xad\xeb\xfa]\xab\xf3\xf0\xbf\xea\xa4$\xdd\x1b\x17\xd3?\x07\xc8:\x9b\xe3j\xef\xbfi\xd6\x1d\xc5L\xd8\xda?\x00\x05\x021\xeb\xcd\xdd\xbf\x1e\x80\xe1+\xdb\r\xf4?\xd8\x10\x913\x11X\x00@\x85ef\xfb\x0b\xde\xfa?|\'>\xc7\xbe7\xf3?\x80N\x1c\x9b\xfak\xe8?&\x1e\xc8\x90i\x04\xd2?\xfa8f\xf8^a\xf1?(9\x8c\xd4\xba\t\xdb?\xfc{\x15\xb0Wm\xd2\xbf\xb1\xcd\x10\xe5/\xd7\xea?\'\xa9\xda{\xdd6\xe1?c\xcc\xbf`i@\xd0?\xc9\x85\xb5\x90*\xc8\xf1?\x84\xa2\x04\xef;\xed\xfa\xbf-dvU\xbf\x08\xd5?Xc\xf4NdJ\xd2\xbf\xd4\xcd\x9b5z\x86\x02@\xdfe\'\xf9sJ\xfc?g\x97\xa7\x0f\x84\x08\xd8\xbf\xd4\xc3d\x808\x96\xd7?\xc3\x89\x99\xfd\xe6\x06\xd3\xbf\x8a\xe8\x94\x9c6\xfd\xfa\xbf\x04\xacJ\x90\x82x\xf9\xbfe\x8a\xd7e\xc6\x8a\xe6?\xe7\xd0\xfa\xd2;\x83\xcf?+\x1dqV\xc3\t\xec?F\xba\xe4\x85O\xbf\xf5?\x0eb\xe1\x82\x9at\xd6?l\x02\xebh\x8a\xb9\xad\xbf\xe1-k\x0bN9\x08@Wk\x9e\xca8^\xfd?|\xae\xc4[.\x0b\xfa?C\x1b4\x1b\x85\xe6\x00@q\xbaK\xa6\xb9g\xf6?#\xa9\xcdX\xcf\x97\xff?\xd5$\xb8Y\xae\x87\xdc?5\t9\xbd\xd1\xd5\xe6?&\xb3\x86\x10\x1c\x06\xea?O\xb1\xe5]\xdd\x0e\xfb?\x1dz\xcd}\xa9\xc8\xe5?\xd7P\x02\xfe\xde3\x01@\x8a\x88\xad\xb2fP\xf5?I{\xbb\xd4ih\xd2\xbfY\xf6\xda\xda?\x0e\xf2\xbf\x11>\xc5\x99;r\xf7\xbf\xaa4\xc4x}\xb9\xe8\xbfy\x93\xc3N\x04B\xe4?W1UDs\xb5\xcb\xbf\xf9\xf1\x15k\xaf\xc8\xe7\xbf\xd4\x9a~\xb0\x80v\xed\xbf\x15\xd0\x88\xdf\x99\xbd\xee\xbfJ\xe0(\xe2\x9e\xe6\x04@\xd8\x05\x83\xbe\x8a\xd1\xf1?\xf6\x82\xdc\x11h0\xed\xbfK.ly7\xf4\xda\xbf\xcb\x0c\x98\xe3\x86\x82\xf0?jP 2\\\xb9\xd2\xbfZ\x97\xfcI3\x1a\xff?\xc9m\x04\xfd|\xc1\x90?\x98\x91\xdb]\x97\x14\x00@\xd2\x8cE\xf0a=\xea?\x1d\xfd\x85\xbfx\xc9\x83.\xcb\x13\xe7?\xf4To\xd1\xb3\xd0\xf0\xbfoJ\x8c\x89\xc2\xca\xee?*7J\xe1\xf9\xf6\xe6?\xdb\x17\xa7\x81*\x80\xe0?"\x81v \xfbq\xf6\xbf`}\xd5]\x87\x84\xbe\xbf\xef\x91\xb8}\x9c.\xe0?\xe6\xb5\xcag\x88&\xeb?\x15\x7f@\xa7F\xfd\xfc?E\xf7N`\xd4s\xda\xbf\x80\x18\xee\xd7G\x87\xdc\xbf\xf2\x87\x1b\xecDL\xf6?\x99&>\x0ch\xc8\xe7\xbf`\xf5\x7f\xc1,\x8b\xb6\xbf\x18Nucj\x1c\xf5?{\x04Q\x11\xeb\xdc\xfa\xbf%MP\x87\x01X\xc4?}>\x8c\xa8k\x8a\xf3\xbfaF\xf43q\xa1\x04@\xd5\xb4v?\x11\x9c\xd6\xbfEM\xbe\x96\xbcY\xdd?G\x85\xd8\x01\xe9*\xcc\xbf\xe3?\xe6\x12\xaa{\xd6?\xcd\xe8_6\xbe\x1c\xec?\x1f\xad7\xaa\xf7S\xed\xbf}\x89\xfas\xecn\x01\xc0\xd9\xe6\xc5\x17-^\xf1\xbf\xe4\xe9\xdb]J|\xda\xbf6\xc2\x8bo\xd2\x0b\xe7?&\x93\xbesp{\xf2?\xe0B\xf0\xf9\xec\xaa\xd6\xbf0?\xc3\xe3B\xb7\xe7?\xd4\xa4lV\x0ez\xec?2\x85\xbe\t\x81\xad\xd7\xbfj\xf1\n\xdb\x06C\xe2\xbf\xc6r_J\x01\xad\xe8?\xaaA|O\xab\xfb\xcc\xbf\xb8\x1e\xa4\xb4\xdf(\xe2?\x98H\x14\xb4Z\x81\xeb?\xd0\nu\xcf\xab\xbe\x95\xbf\xbfJ\\y\xee\x95\xf9?\xe9\x95\xa7\x1eMA\xbb?\x82\x96\x10\xba\x16#\xbd\xbf\x08\x1f\xfa$;\x11\xba\xbf\x82$\xeb\x13\xecv\xf3?\x89nb\xaa\xb5\xea\xd7?\xc104P\xcd\xda\xc4\xbfffCp\x13\xde\xe1\xbf\xc14\xb6\xca\xc9\x95\xd7?\x8a}34%~\xec\xbf""^\xaf\x16\xcd\xf5\xbf\xf3+*,\xfc)\xee\xbf\x86\'\x95\x81\x81\xe2\xf2?\xf6\xf63\x83\xddc\xca?S\xbe\x03z\x1c\n\xde?q\x95\xf8\x8d6u\xf0\xbf\x7f\xb9\xe7\x0c\x95\xc5\xeb\xbfC\x84\xd4\xbc\x83\xac\xf0\xbf[\xb3~7\x96\xc6\xf4?$3\xb3C\x13~\xc0?4\xe4\x88\xf0\xe9\xa2\xbf\xbf\x9c\x80\xc5n\xe2\x1c\xe5?\xd38e\xe5\xfcH\xf4?\x06F\x053\xe8\xd6\xdd?\xabv\xb4\xd9\xcfI\xd1?\x81\xc2E2\xf9\x17\x9d\xbf\xa7\x08\xdc\xf1\x98\x8b\xe9?gI\xcc?\xcb\xc7\x00\xc0h\x03L\x06\x1eD\xec\xbf\x01\xb0\x95p\x04I\xe7?\x86\x19\xbe\x9d?x\xec\xbf4\xca\xdd\t\xeao\xd3\xbf>`\x12m\x98\xd0\xf3\xbfS\xb0\xb0Ey\xbd\xe6\xbfF{qRt\\\xbd?\xca\xf3ZZ\xe1d\xec?\xfe`\xf6\x8f\xbc\xd0\xd0\xbf>5[W\x01\xf2\xcf\xbf\xd3\xa8M\xfc\x1e\xe9\xfc\xbfv\x9c\x99G@|\xd7\xbf\xeb\x18\x9eB\x7f\xa7\xce\xbf5\xe5\xbb,\xefr\xe5?\xc0\x9a\x16\xc7\x03\xdf\xd4\xbf\xc3,\xd7FkB\xe9?\xc9\xcd\xb4\r\xd9I\xc5\xbf\xd6\xcd\xdc3\xc2\xca\xc4?\xe6\x87Z7\xd9E\xca?oY\xfeO\xc9)\xdb\xbf>}V,\x82\xe9\xe7\xbf\xc0D\xe7\xde\xfcN\xd5?\xe4\xcc-=\xda\xac\xfa\xbfk\x8d\xa5\xeal \xe0?\x03\xdco\xc0E\x11\xca\xbf\x07\xc1\xbf.\xf5w\xff?\xfb\xd1\x894\x12G\xc2?DW\x83\xef\xfd\r\xe6?\x0c\xbeM\xe4\xd4-\x83\xbfVFh\xc6\xb6\xe8\xd8?\xc6\x8b\x11\x9bF\xea\xb6\xbfCOL?JO\x02\xc0\xe4\x04h`\x98\xdb\xf2\xbf\xda\x14\xff\x01\x06\xb1\xf1?\xe6\x1c]=\x1c^\xd4\xbf\xf4\x0f\t,\xb4v\xd3?\x7f\x1a\x11\x14dP\xac\xbf\xd1\xb5h\x82\xbd\x10\xe3?\xc7\xc9c\x05YR\xf0\xbf\x19iC\x11\x87\x0b\xf2?a\x7f\x9e\x03\xd6\xfd\xc2?/\xd1\xbd4"\x8f\xdd?\xdf\xc8\x8f\x15{\xab\xe1?\x04\x85\x16\x84b\xc8\xe8?m\x85@\x8d\xce\xaf\xea?\x02L\x92\xc2$\xe7\xf8\xbf\x7f3r8\xd4\xb4\xea\xbf\xb8\x03gi\xe6\x14\xd5\xbfZ\x9a\xbd\x16\x10G\xe0?\x96\xb7x\x8fD(\xd1?i\xb9\xee\xa6\x17\xac\xdd\xbfu\xb9\xa6\xcbS\xb2\xb0\xbf\xc2\x83"ou\x85\xdb\xbf\xbf\xbfK\xdfe,\xcf\xbf\xb8\x94\xd1N\x97\xf5\xf5?%h\x84\xc9\x0et\xdb\xbf\xb0m\x16\x9f\xd2\xb5\xaf\xbf,\xb8n-\x07m\xee\xbfw\x0c|\xa9\xa3\x01\xbc\xbf\xed\xf9w)y\x1b\xfd\xbf\x94\xbf\xf2\x91\xc8$\xdc\xbfPN\xfe\xc9\xe1\x9e\xe3?S\xfe\xad\x1fR\x1a\xec\xbf\xd3\xb1I\x0e\x95\xbd\xf4\xbf\x9a\x01\x18\x97d\xe6\xdb\xbf\xb5!W\xdbSO\xe7?`;d\x8fw\xcc\xdb\xbf\x1c\x92l\x8c!\xfd\xe3?|OL\xb2g\xedx\xbf\xe6\x02T\xba\xd7\xc0\xee?\xea\xc5\x95\xee\xeb\xc2\xde\xbfN\xe8\xb812\x94\xd2\xbf/\x13\xdd\xb65r\xe1?\x88\x9cNJC\xc6\xf1?7\x1b\xb9\x8a\xd3\x16\xd0?\xfc\\\xebd\t\xb0\xe1?^9h/0\\\xeb\xbf\x11\xb5\xf9\x11mS\xf4\xbf\xd4\x06\x8ey\xf4\x1f\xec\xbf\x91\xed\xbeA\x83k\xca\xbf\xc0\x8c%\x82\xbb\x8d\xe6?\xdd\xfc\x1c\xa8\xf6J\xe8?\xf6Ed\xc5v+\xfd?b\xcc.\x8f\xfe\xec\xd9\xbf\xdb\xd4\x89\rI\xb2\xef?\x07\xd6*\xe0=\xef\xf7?\x9bf\x9f\xf0\x98\x1e\x95?\xd8"\xd4\xdd)3\xf6\xbf\x9d\x0c%dN\xaa\xfd?\xd2]\x12\xd7D+\xd2\xbf\xa1p9\x06F@\xfb?\xa06\xe7oT\xc6\xe6\xbf\x83\x1d\xfd\x83\x9do\xc6\xbft7\xe6U\xd3\xf5\xde?\xb7\xa6\xc9,\x82\xf3\xe5\xbf\xa1%\x90R\x9e\x80\xfa?\x81\x80\xd3\'\xb4M\xf2?6\xc0\x8c\x7f\xbc\x9f\xe9\xbf|\x93[\x90\t*\x00\xc0*O\x05\x11\xceZ\xfa\xbf\x15\xc2\x9f\x101\xbd\xf5\xbf\xeejV\xcf\xfd\x11\xf9?}\x04\x14\xd3\xecY\xa4\xbf\xc4\xf35\xc4q\xd0\xe1?T\tu\xee\x13\xa0\xf3\xbf\x17\xa7\xee(\x16\xdb\xdc?\x8fY\xfb^\xbeT\xf5?\xf0\x91\x0c\xd6\xcbR\xd8?\x05\x08\x0e\x1b\x84\x84\xf0?F\xe9\xe6\x82~\x81\xfe\xbfe_C[_\x07\xeb\xbf\xcc\x18\xf1U\x91\x83\xe6?>\xb7\x03\xd6\xbc%\xcc?\xc2\xa2|-]\xc3\xee\xbf\x85\xacM\x9c>\xfa\xf0?\n\x06\xb5\x84A\xfa\xbd\xbf\x19J \xa9\x1a\x1a\xd3?\x97dic\xd0M\xd4?c\x1c8\xc5Da\xaa?\xcf\xa6\xfbB\x14\xb1\xe7?\x95\xc3C\x04\x8d\xa4\xc4\xbfJ\xf5J\x1ap$\xdc?\\\xb4i\xff\xf1\xd3\xbc\xbf\x9f\x8a\xfb7xG\x08\xc0\xf7\xc7\x15.\xa1\xfb\xf6\xbfF\xd7C\x1d\x98\x97\xd4?7H\xa7\xab/\xbf\xf7?\x96\x81w\x91\xc0\xb5\xee?\x96J\xbe\x06\xee&\xec?AO=3\x12\xc5\xe0?\xd0\xcb\xe0;e\x12\xde\xbf\xd9Y\xa0\x8b\x93\x16\xd2\xbf\xbc\xe1\xf1\xc4(\xb6\xf2\xbf=\x87\xbf\xb7W+\x01@@\xc35\xc1\xb7.\xdb?\xd6)\x1e\xdb1\t\xd7?\x913\xfd\xde\x87r\xdc\xbf\x90\xbd\x0e\xd5\xeb,\x00@\x7fp\x8b\xf5ek\xe7?\x1dg\xbd\x90\xfd!\xe8?2\x90\xc1\x98\x1b\x8e\xb6?\x00\xd0`\xb4\x15\xc0\xd3\xbf]\x04\xa9,tC\xcd\xbfA\xa6"\x12M\xfc\xf6\xbf\xe3?\x01\x86\xcbG\xcc\xbf\x91\x9f{\xf29\x9a\xe1\xbfb\xe1js\xde8\xe5\xbf\x10p\xcex\xc4h\xf1?#\xf54\xcf\xd5\xb4\xf1\xbfwG\x05\xaf\xa2P\xe9\xbf\xc0\xed\xdbMx8\xe4?\xd9N\xe9\x8a\xfb\xb3\xcd\xbf\xda\x18+e!\xdd\x07@W\xee\xba!\x93\xa6\xce?Z\xa6N\xbc:\x89\xc7?X\xe4\x80wj\xa1\xd0\xbf\xc6\x9dv\xa8\xca\xb0\xc9\xbf\xef\x19L\xd8}\x8e\xee\xbfR\xbd\x03\xfe\x03\x9b\xeb\xbfz\xae\x8d\xa4\xf5\x02\x02\xc0\xec\x91XF\x90\xf9\xda\xbfm\xac>G\t\x94\xd4?\x10\x19\x8cH\x80i\x01@\x8a2\xcf.\xee\x0c\xcc?\xe9\x87\x90\ne\xf9\xdd?\x8b\xef\xdb\xd4\xd4b\xc7?Y\x0e\xb8\xf7\x05p\xd5\xbf\xc7\xec\x12S\xab\x85\xc2?\x88\x83\xff4\xa0\xaf\xd3\xbf\xb7&\xd2\x84\x90^\xd0\xbf\xa9\xdcC(\x13\x1f\xe3?\xccG\x1f\x19\x87\xfc\x03\xc0\x04\x1f\x88wp\xcb\xe9\xbfD^-b<\xc1\xb6?m\x99\xc8VA\xef\xec\xbf\xb6\x8e\x0c}<\x9d\xc7\xbfj\xe4\x9a\xf7\x1c}\xe3\xbf#\xfb\x05|\xd9L\xe2?(xR=\x9f[\xe0\xbf\xe2\xeb\xefU\x9eU\xf1?\xb5\xa7%\xe0\x823\xc9?x\x17\x91\xbc\xc2\xc5\xf3?d\xbd\xf0\xa4e\n\xd7\xbf\xabd\xfb\xb1/B\xf9\xbf\xc6h\x94\xf9\xf1\xa5\xf0?\xd1\xbek\xd5\xbc\x17\xf7?\x98\x13\x99\x98L\xe6\xda\xbf\x9e\xce\x13G\x8aN\xe7\xbfR!#\xb0,I\xd2?Pw\x0b\x0c\xe5\xf1\xda\xbf\xd5\x95\xb7\xc118\xf5?\xa7\xc6\xb8\xa6\t\xa9\xda\xbf\x00\xbd\xa1L5\xc5\xf0?7\xaa7\xa1+\x83\xbd\xbfj\xf0\x89\xf5\xc5\xb1\xe1\xbfZ\xdb\x98\xf4U\x1a\xda\xbf1\xa2\xb6]!\x81\xfd\xbf(\xd8RC\xc7&\xc1?w\xa8\xb7\xdc\x14_\xe0?\xa7\\t\x16\x851\xe9?\x90\x91\x86\x8c\x96\x85\xc2\xbf\xe5\x16\x905\xddp\xd2\xbf#\x97\xd8ZA\xfa\xe1\xbf=\xca\xb3I\x0e\xe5\xf3\xbf\x83\xe7\x11\xf0rD\xc4\xbfg\xea\x11\xec\x8d\x98\n\xc0\xfaR\xdc\xd6\xd5\x7f\x05\xc0\x1bn\x00B\xe4\x02\xe3?NEK,q\x9a\xd1\xbfO\x9a7\x82\x95\xfb\xd0?\xbe\xafQ3\xde\xd8\xf8?\xdf\x03\x1dA\xb8\x85\xed\xbf$<\xbb\x89St\xe3?\xeep\xdfhf\xdc\xf3?\xb0~Y\x89\xe7\xc3\xd4?\xc1\x9f-\x98\x93I\xe0?\xe5\xd6\x82\xd17\x8f\xf9\xbfm\xf1\xc2:\xbb\xb4\xef?p\xc7\xb5K\x1d\x83\xd1?\xd4\xa5\xe7E\xb7\xc6\xf9?-O\x0e\xa9on\xca\xbf\x89A\xfdmzu\xf4?\x8a\x0e\xf6\x08\x97\x1b\x03@\x10\r\xbb\x08\x13\xee\x91\xbf\xfeg\xbe\xe7\'\xc8\xd2?\xb4\rK\x15F\xfd\xeb\xbfN\xf2M\x9d\x83"\x00@x\xb2-\xfd\xab\x9b\xbd\xbf\xbcx\xee!\xea\x1f\xf8\xbf0\x1a\x11V\x1cf\xf5\xbf\x81\xd3C\x0bM\x0c\xee\xbfX\x12[\x06\xf8\x7f\xe1\xbf\xae\x7f\xb7\xc3\xa2u\xf5\xbf\xf2\xd0{\xf1\xa0\xf8\xee\xbfi6\x13\xa4\xc7%\xde\xbft\xa7\x19\xfa\x9b\x94\xd0?\xa8\xcf)R\xe7\xd3\xf3?\xbd\x9c\x13\xab\xb9\t\xe1?\xaf\'\xba\xe0\x8f\x82\xdc?oD\x9a\x82"f\xe4\xbf\'d?\xc9\x98\xbc\xf0\xbf\xd3\xdaq\x07\xf5\x8d\xe9?\x7f,BMA\xc9\xd6\xbf\x9c\x17\xe5D\xc8N\xc3\xbf\xce\xc9\xee\x96\xf7\xd7\xe0?K\xd7\x9c\x96\x14\x96\xf3?\xd5\xcdA\xee\xd0\xbd\xcc?\xbfRO\x95\xd1 \xf2?\x0bBy\xb9\\%\xf4\xbfN\xac;\x17\xe06\xdb?O\x9a\x8f\xe5\x9c\xda\xb6?\x9eU\n\xcf\xd6s\xe1\xbf\xf6\xc8\xc7\x1dX\xa1\xa0?\xea\x8co\xe6\xffC\xf4\xbfs\x92o\xa8\xb5r\x07\xc0\x03\\\xf4D*%\x0e\xc0,rA\xf2\x10\x17\xfc\xbf.EF\xcb\xc2\xb5\x0b\xc0D\xa8\x152p\x0e\xf9\xbf!lv-\x08&\xf8\xbf\x17\x85\x1bxl\x1e\xe4\xbf!\xac\\\x0c)<\xd3?\xef\xf0\xc4\xfa\x1d\x85\xfa\xbf\x1f\xf0\x1b\x96\xef\xcf\xcc\xbfL<\xb3\xd6\x8f\xae\xd2?\xf0R\xeb\xb9u$\xeb?\x0eap\xec\xde\xc3\x06@U\x83\xd0w\xe5\xd5\xab\xbf\x04 @\x98"\xc9\xee\xbf\xe6\x81_D5\xb6\xf8\xbflj\x8b\xc5\xc9\xe9\xf1\xbf\xad\x9c\x14E{\r\xeb?K\x9dN\xd6W\x8b\xc4?\n\x10\xda\x1a\xab6\xec\xbf\x0f8Hdc\x10\xec?Y\x91\x86oR\xa4\xfc?:\xa0\x08%\xe3\xd5\xf2?\x98\xfbN\x82\xe6\xb7\xed?\x1f\xaa\x05\xeb\xec\x93\xfb?\x95y\xfb\xd0\xb2\x08\xe4?\x8f1eI&\xba\xf9\xbf>\x8cX\xbc\x98\xef\x00\xc0\x02_\xc9\x1b\xb6\xc1\t\xc0\xa9F\tI\x14\xfa\x00\xc0\x0e\xd8Y\xdc\x9f:\xfe\xbf\x18\xd3uq\xef\x88\xfb\xbf\xb4M\x16S\x83b\xdf\xbf.\xf3f/\xb7\x91\xf1\xbfd\xf0\xbd\x11m\x18\xd3?\xb1V4\x84\xa0\'\x9e?\xc2\xe7\xc1\x89\xb98\xe6\xbfaJ\xf5\x17\x9cd\xf2\xbf2r1\x8f\x14\xb7\xf2?j|\x13Wf)\xc6\xbfPy\xe2\xe41\xa0\xbf\xbf\x93}\x0e\xee\x97\x01\xcc\xbf\xdd\x064x\x83\xa8\xda\xbf\x83\xc6\xf1&\xd8\x95\xf5\xbf\xa8\xec\xb7>\xcd\x00\x03\xc0d\\\x03\xf1X\x87\xe4\xbff\x81\xed\xba\xa6(\xfb\xbfX\xed;\x80\xc9\x8c\xe7?{\x07x#b\x96\xfc?\x9e.\x1fa\xc0\x8fx\xbf\xc7M3(\xd6\xd6\xda?\x81\xf2\xa4$\x18\xbd\xdd?\x07m\xda@\x96\x17\x05@\x9f\xb6\'\x86\xa7\xb3\r@$]{:A\x97\xf3?\x8f\x9a\x13\x91F\x00\x8f?\xd5i\xd5\xbf~\xdd\xfc\xbf\xc0\xd1\xb0\x0b\x12\xf7\xdd\xbf\xb0\xb3\x18\xeb\x8f)\xb7?D\xfe\x08V\x91\x90\xb9?M\xa8U4\x9f1\xf0\xbf\r*N\x97\x98R\xf5\xbf\x12\xa69\x14Dy\x8f\xbfsp\xee\x1e\xc1\xf6\xde?0 \xbcd\xf3\x1c\xe3?m\xdb\xcfiu\xd3\xff?W\x0e\xb7\x14\xa88\xf1?\xbc?8<\xb8\xce\x9a\xe5?\xac-\xfd\xa1,q\xe7?\x1a\xc5\xd0\x95kU\xed\xbf\xaa\x0ecp%\x93\xdc\xbf\xbdS\xac\xb5,\xe4\xe9?\x82R\x81\xb2_\xe2\xf0\xbf\x87\xad\xaa\xbeb\xe0\xd3?$\xfe\x11\xd2\x02\xf2\xd8\xbfx1\xec\xbc\xa3\x9b\xf3\xbf\xe9\xe1\xb7U\x1f \xfa\xbf\x95o\xe4-\xfe\xfc\xa6?\x10g\xad\xc5A\xd4\xe7?I"\xe4\x16z\x8f\xaf\xbf\xff\x045L\x03\xaf\xe0?O\t\x14\xc2+\xb3\xda?\xd0v?\x99D]B\xbf\xdc\xb6O\xf9=\x8a\xfa?L6\xbe%\x152\xa0?\xa0K\xdc\xf9\xc6X\xc1\xbf~\xee\x9e\x84\xa0\x1f\xf4\xbf\xd50\x06z\xcc\xc9\xd3\xbf\xfa\t\xef\x03v\x8a\xb2\xbf2QK\x13\xe4\xa6\xf4\xbf\x8f\xe3\xb2\xb2\xae\x94\xf3?Y`\xa2\xbd9x\xe1\xbfZ\xc5\xf1\xc5\xb1S\xb6?}\x1cm=\x02\x84\xe5\xbfZ\xc1\x7f\xca\xff\x89\xd9?\xb45\xb3\x91\x1e}\x03@\x04\x13J6Y\xd0\xf2?\x0b9&\x7fP\xc3\xf0?\xd9YP\x18_\x05\x00@\x85H\xca\xe2\xf9D\xed?\x13\xe4\x18\x07\xea\x17\xde?;t\xf1C&%\xd0\xbf\x03v?\xd9\xbf%\xf6\xbf\x06\x88\xac!\xe9!\xc8\xbf*n\xd4\xa2L\xab\xce?0\xeb\x9d\xa2\x0c\xdf\xba\xbf\x99w\xc1\xa1\x8c\x99\xf0?\n\x82y\x94I\'\xcb\xbf~6`\x88V\xe7\xee?\xa2\x83\xc4\xdf\x7f\x92\xe6?\x19(t\xf5\x8e;\x00@rQ\xe7\xc4\xf2\xe1\x05@`\xb5zE\xda\x03J?<\xb2I\xd1\x90W\xfb\xbf\xf4\xfc\xd1\xcc\xcc\xf4\xf1?\xa26\x9e\x9b\xc4\x7f\xa6?&!\xa2\x94\xb93\xdb?\x80Q]\xaa\xfa \xe1\xbf\x8b9\xcdt\x1f1\xe0\xbft\x8a\xfa\x9a\xa8\xba\xe0?\xa1\xcf\x10B\xa6\xf7\xfc?M\xb4\x84U_[\xeb?\\\xd2\x06\xb3\xa5\x83\xdf?\xb4k\x01\xcf\xfd9\xfb?\xafn\x0e2\xba\xcd\xd1\xbf\xfc\xef\xd5}\xe8\xe7\xf2?\xb1"\xd9\xf8@\xac\xe9?q\xc2\xe6g.\x9a\xea\xbfc\xc1B\xa3\xd9?\xbe\xbf\xd1\x91s\x84s,\xeb?\xdbO\xc4B\x84N\x04@\xb2\r\xe9\xe54 \xe3?\x82\xae?=;;\xb6\xbf\x9a\xfeP\x99v\x03\xd5?\x86\xfa}\x11q\xef\xde?R\x9d\t\xc5*\xa9\x00@\xdad\x18\x87\xbc$\xe5?oZ\x95J\x9d\x9c\xf6?E\xbcGw\xf8\x9f\xe6\xbf\xd5r\xec\xef\xabX\x05@\x809COX\xb4\xe8\xbf\xeai\xf5K\xc6\\\xd7?0\xfd\x83\x00\x1e\xff\xe6\xbfN\xe4.\x11-O\xee?\x1a\xcb\x84\xf9\x15\x80\x01\xc0\xb6$\x02@\xe4\xd1\xc7\xbfj6q\xfe\x8f@\xe3?%3J~\x99\xb0\xaa\xbf\xe9P5\x15+\x83\xf7?$@v\xfaP\xcc\xfa?\x07\x1d\xc5\x05\xbe\xe7\xe0?\xf7U\xe7)\xa4\xca\xec?\xf5?J|0\x19\xd1\xbf\xb4\xdf\x9e\x03\xb5\xfb\xd0\xbfX\x9aB(\x05\x87\xf4\xbf.\xacYN)\xe0\xec\xbf\x1e\xeda\xa1\x8b\x18\xf6?|_8\xfb\xfe<\xec\xbf\x97\xbb\x0c2\x15:\xb1?\xd8\xfe$,\xce\xca\xbc\xbf\x06)\x17\xf0\xb2\xf8\xe9?r\x14*\xe1\xe8\x15\xeb?\x8d\x15\xdfgp\xf1\xec?;\x1b+\xb3\x9b\x90\xf3?Ww(\xaf\xb88\xff?OR\xdb\xc4\x85\xcf\xcd?\xcb\x15n\x9b\xcb\xba\xfd?\xec.\xb9o\x82:\x00@\x93\xd2\xb4}\xc3\xc1\xf6\xbf1\xa7M\xa1Ue\xda\xbf\xdc\xfb\x8c;\xb1I\xf5?}\x17\xb3,{\xd6\xff\xbfY\x147\xf9\xb0:\xff\xbf\x01\xf8j\xae\xf27\xf6\xbfu\xed:\x05O\\\xf8?>\xb8\x11\xa6\xd5b\xfb?\xdf\xf1\x13\x06\xa1l\x05@\xc2\xd7\xc6\x9c3\x04\xf7?\x8a\x81\xf5,\x91\xe8q\xbf\xd2\xe6\xfdzg\xb7\xfb?u\xe1i\xf9\x06\x93\xf4?\xcf\xa4\x90\xbc\xdb\xbe\xea\xbff\x97\x7f\xf5\xbb\x15\xfc\xbf\xb5\xe1\xe0\x83st\xed\xbf[\xc16m\x92\x9d\xd2?>\xfe\x96\xc7\xd5\xac\x00@\xd5\xc1\x8c\x1cpQ\xe3\xbf\xfc9\x0c\xe7\xd96\xf2?\x94\x19\xa5\xe8B\xb1\xf1?M\xbd\xe0#\x06\x1e\xf5?\x80>\x82\xb4\x9aE\xe7?\xa34\xa7W0\x83\xe5\xbf\xb3\xe1\x8a9\xaa2\xf0?!\xc1\x97\xbb\xab\xd3\xec?\xb0\xc1\x9a\xc2\xc5\xb2\t@\xa5\xf3\x10M\xc2e\x01@i6\xc3\xc2\x07\xd2\xef?QR\xd3\xbc9M\xd4\xbf\xf2\x1a}\x05\xba\x04\xf9\xbfGHq>\xe0h\xa8?e\xd4\xf0\xc0\xd1\xe1\xe1\xbf<\x01\n|\xf3\x82\xee?Z\xd4[\xaan\xf8\xda?\xc9M\xc4\xd5\xf9O\xe5?\x00\x0b\x84zh\xc9\xd8?\x96\x87\x117\xc2\xaa\xfc?\xab \xd2p\x18,\xe2?Q\xc1\xf7\x91\x17\xbc\xe2\xbf\xc3\xb8\x88\xaf\xc5\x15\xf5\xbf\x9c\t\x86\x9c\xb6\xed\xf7\xbf<\xfd\x1b\xa1@\xab\xf8\xbf\xb7\xbc\x83\xc3c#\xf1\xbf\x05\xd3\xc7\x91f\xa7\xb2\xbf<\x15\xc7\x9dh)\xd3?l\x18\xad\xbd\xb8\x9a\xef?\xd2\xfb\xb4]\x15\xd7z\xbfmQ\x1aS\xf7(\xe0\xbf\x11.\xee\xebn\xba\xe9\xbf\xe0\xcb \xbb\\U\xf2\xbf|\t\xe8Y\x88\xb3\xd5?\xc1\x16\xf7\xef\xc6\xb3\xe6?\xbd\xd1\x85\xeeP\x06\xf4\xbf\xc9\xf5L\xaeOt\xd0\xbf\x81\xa1G\xf1F\x11\xea?\xff]\xe8\x08\x11T\xf5?x)t\xde\xcc\x1b\x81\xbf\xd1\xab-\x15\xe5\xbd\xea?+\x90\xa2~\r\xe0\xdc?\xfc\xad\xde\xb0A\xa2\xe3\xbf\xea\x9f\x8c\xb2\xc7;\xed?\xe5]\xa4y\xc1\xa8\x0c@Tl\xe6\x00\x80\x0c\xfa?\x99\x17\x19\x08kg\xee\xbf\x87\x9f\x0e\x11\xd7%\xf8?\xe8\x87\x14d\xaf\xf5\xf8?\xc9\xadm]\t\xf8\xf2\xbf\x1c\x8ej\x03\x909\xdf?\x8a\xc4\xaaZEm\xd6?\x90z\nxl\x08\xec?3\x1eD\x89p\xd6\xf4?\x1d\xfd\x85\x1f\xe3\x9e\xc2\xbf\x1d\x8d.\x8c\x83|\xc9\xbfD=\xd5*\xc0\xda\xfd?\x11\xfd\xcc\x00Gv\xd3\xbf\xa0\x11*\x86\x9a5\xe7?\xca\xed\x83s0\x15\xdb?G\x1bp\xb0\x91\x00\xb7\xbf\xbe\x7f\x12\xcd\x96I\xcc\xbfy\xa8\xc2\x9f\xbd\x17\xe6?\x962R\x814\x8b\xed?OEX\x9e\x11\xef\xff?\r"\xc1|\x136\xf2?Kd\xad\x13\xdd(\xe0?/@\n\xb80\xb2\xf0\xbf$\xe9^\x08R\xb3\xd0?\x19\x03\x00\x8c\xc9\xd3\xfc?\x9a\xff\x89\xeb\xebM\xdc\xbf\no\x99t\x14\xaa\xf8?\x9f4\x83\xe3\xb09\xf2?D_\r#\x9d\x8e\xde\xbf\xa3h8w\x03\xc9\xf0?L\x1cM\xd5,\x16\xd9?Q\xe6\xe6DW\xea\xf8?~{\xd7u\x9a\xf6\xef??7z\x08s\xfc\xdf\xbfZh\x1c\x1bI0\xd1\xbf\xa5F\xc9\n\x0b\xf2\xe9\xbf\x04\x82\xe0\xda\xc3l\xcd\xbfH\x85~\xf7\xbdm\xf3?E\x19\xe1T\x97\xf3\xe3?j\x80\xa6\x16\x0e\x12\xf9\xbf \x88?\xd8\x08\xe8\xf5\xbfBl%\xd6\xcb\xde\xe2\xbf\x94\xabH\xdc\x84N\xb6\xbf\xaf\x96\x0f\xf2\xe7\x9f\xf4\xbf\xcb\xb0\xe3nsK\xd0\xbfv\x81\x1b\x05\xb3\xf2\xf2?=\xd2c\x04(\x83\xc3\xbf\xd6\xe2p\xa0\xa8\xde\xf6?X\xdf\xa6Q@\x88\xc8\xbfFpH\xe2x\x9c\xda?\xb3\x0e\xcb\x82\xdb@\xc3?vf\x05\xeb\xff\xc7\x9a\xbf\x86\x81\xcd\xb7\xb6"\xfc??\x1e\xe7\xf6o\xac\x05@\xc4\\\xba4u\xbe\x05@\x04y\t\\\x16\x81\xf5?ef\x12\x1e\x08\x83\xf5?\x07~\\\xe9q\x80\x06@\x12\x91\xa0\x9e\xd5\x1a\xdc?\xfdc\x8e\x91}\x13\xf7\xbf\xb3n\x1b\xc9\xb8\x88\xb7?"\x8eH\xc0\x05\xe5\xf6?=\x04\xab\xa0\x13\xbb\xfb?zv)R\xcd}\xc5?Q\xf36\x1f\xdd\xb9\xec\xbf\xca\x07K \x16s\xd6\xbf7\xd5\x88}\xbe\x93\x9d?\xf0\xca`^\xf0T\xf2?\x94\xaa\xd4\xd5t8\xdf\xbfI\xfaU\x0fn\x0b\xd8\xbf\xa1\x84{A^!\x01\xc0M\x91\xfcE\xa8q\xc6?\x15f\xd8\x0f >\xe6\xbf\xaf -\x91M\xa6\xee?\xd2\x8c\xba\xc5\x95\x01\xf9\xbf:\x9c\xdc \xca\xb9\xc7?\xd3\x02\x11\xf3\xa0\x93\xd6\xbf\xf6k\xd9\x15\x8du\xed?\x8f\xf6.\xd9\x10\x98\xeb?\xdc=y\xa9N\x85\xeb?\xe9!\xffc^\xc6\xf5?\xbd\x10-O`\xb5\xf3\xbf\x15\xf1\x84\x1cV6\xee?{a^\x03\xc7\xbe\xf3?\xe0\x94-\xd7\x86\r\x01@\xce\x17\xa0F\xb4\xb9\x02@\xb7\x89\xbd\xad\xf9r\xde?\'R\xe1\x84\xd4\n\xe6?\xd7w\xac\xeb\x94\x01\xf4?]\x0fv\x0f:f\xc1\xbf\x17U%\x1cb\xf1\xe6?<}(\x1c8\x87\xad\xbf\xeeC\x7f\xfa\x9d\xfd\xdb\xbfm\'\x13\xfc\xf3\xec\xf1\xbfR`\x1d\xdcKm\xc4\xbfTT\xac\xaa\xa8\x89\xc3\xbf\x1a\xe0\xa9\xf6v.\xf2\xbf^\xac|%\xe8G\xbe?\xe0\xa4\xe3;\xbc\x90\xcc\xbf\xe2}\xa32Q\xea\x00\xc0.\x1d\x84\x9e\xde\xed\xf0\xbfa\x9b\x9f\x1d\xe8\x1a\xfc\xbf\xad\xd8\xf1\x920\x14\x0f\xc0k?\xfe1\xc2\x8a\x06\xc0\x8e\xf3\xc2\xdf\xeb\x00\xf7\xbfk\tVMu\xba\xf8\xbfH\xdd\xee\xeb^y\xf0\xbfP\xb77\xdc\x08\xca\xf1?\xb2\xd5\xcd\x80\t\x1b\xeb\xbf\xb8\xfb\xa2\x86\x19-\xe9\xbf\xf5\xb0\x1b_;\x85\xfe?yo\xf2\xe0\xf6\x94\xef\xbf\xf0\xae\xf5N\x1c_\xe7?J\xa4,\xf4q\x8f\xd7\xbf\xb21T*\tl\xdc\xbfD\xd3Kg\xf2\x9b\xec?\xb5>i\x95\xd7v\xbf?S.\x97\x14\xb5\xb3\xd5\xbfi\xfb%\x8d\xe6\xdd\xef\xbf\x07\x87\xf4Kx\xe9\xf9\xbf\xc0\xd2\x06\x9c\x80\xa5\xc9?\xbd\xda\xe9]\x06)\xf0\xbf\x08\x12\xbaD\x9a\xf4\xe7\xbf\xf8I\xc4eZ\xce\x01\xc0R\xf0\x06\x86\xa8\x9f\xe8\xbf\xa9\x14\x06\xa0\x07\x99\xf2\xbf\xf6\x05\xcfE\xa7u\xc7\xbf\xc2\xfbsa\x89\x94\x02@[\x90u\xf8b\xc3\x02\xc0^~\x8bhy\xea\xf2\xbf\xcf/\x9eh\xee\'\xfe\xbf:\x1aEYH\x81\xf8\xbf<\xc7H}\xebl\xea\xbf\x91\xd2Ow\x9d\x17\xe1\xbf\xd9)\xb9\xc4Y\xd7\xe8\xbf\x9d\xea\xc4\x9b\xe4\x13\xfc\xbf\r\x89\xb2\x9a\x1d\x97\xee\xbfH\xe6~\xdd\xf8\xf1\xca?|A3\x8e\xa5\x0b\xe3\xbfL\xc4\xfd\xba\x19{\xdc\xbf\xbb\xd9\xebPC,\xa4?t\xaf\x12\xd3\xc7\xe5\xc6?\x08\x039\x08Lr\xf0\xbf\xa3\xaa\x0f\xcer\xac\xf0?3\xe9\x07s\xce\x1d\xf4\xbfd\xb8\xfcz\xae\xf8\xd9\xbf,\xd6\xf5A\xdd\xd3\xd4?n\xfa\x80l\xbcr\xe3\xbf\x90v\xf8\xbd+o\xf3\xbf*3j\x8fV\x17\xf5?\x92\xb8\x16\xdb\xf2\t\xa2\xbf\x9b\xe9\xd8\xbb\x8a\x89\xee\xbf\xc2\xef\xb1#\xd2\x08\xe3?\xa7\xa4u\xfc\xb3v\xf7?\x81\x1c\x88\xf37\xf3\xcc\xbf\xcal\xc9\xd7\xd2.\xd2\xbf\x95bZ\xfc3S\xff\xbf\xeb\xf6\xb3\xe4\x9e$\xdb\xbfl\xb8\x13\xb3\x0f\xc1\xe3\xbf\x9e\x93z&\xa9\xcb\xbd\xbfPi\xb9\xde\x84\x92\xc7?} \xfde\x9a!\xee?\xf7)\xae\t\xa2\xb7\xd5?\xa7.\x86\xeb0\xe4\xd7?\x8d\x9d\xcfk\x95\xe9\xf7\xbf\x06R\xca>\xf8i\xf5?;\xd4l\x0eC\xcd\xf7?\xd4\xb1\xbb\xd6Z\xcc\xfe?\xcf\x02\xc9\xdeg\x16\xd9?\x16\\\xa4lA\\\xf6?\x87/\xb4\xc0\xcb\xd6\xf5\xbfa\xe6\x05\xae\x1e\xb4\xe0\xbf\x05F\x1d\xf6\x8d\xf1\xa4\xbf(\xf8K\xd7\x07\xb2\xf6?\x0f(3\xea\xa02\xd5\xbfd\xb6S\xd9\xe6\xe4\xec?f\xfa\xdf/[}\xf1?\x17\x81\x0b \xbf\xa5\xed?!=\xc4,f\x90\xad?\x88l\xcb7\xe1\x0e\xdd\xbf\x97\xe8\x1dV\xbbm\xf5\xbf\x92]\x11\xb6\xf9\xe1\xf0\xbfI\xc7o/]\x9e\xdc?\xd0L\xee\xba\x95\xb3~\xbf\x12@0e\xe1\x00\xe3?%\xb6\xf5[S\x9f\xd6\xbf\x86o\xec71k\xef?\x04d7\xc0M\xc6\xcd\xbf1\x1b\xa7c8\xc3\xea\xbf\xed>h\x05\xf6\xb4\xca?T\x02\x19\x15\r-\xcc\xbfg\x8b_\xd1M\xae\xc7?\xcc\xc8\x12\x8e\xadI\xdd\xbf\xa4\xbcj\x99gp\xf5?\xf3\xbd\xa8\xfaI@\xdc\xbf\xa5\xf3\xe9\xe2[]\xfa\xbf\xbb\xcf\xc0\xef\xbd\t\xee\xbf\xc5\x05\xdb\xad\x9a\xfc\xd4?\xe5\x1a\xfc!\x02\x8f\xdb\xbfJ\x97yN,\x12\xf0?\x00W\x97\x80\xf9\xcb\xda\xbf\x03\x11{\xfc\x95z\xd8?\xe2;M\xe3&:\x91\xbf\xf3]D\x1b\x1e\xec\xf8\xbf\xdb5\x90\xb9`*\xe1?\xc9!T\xb5\xfa\xbf\xfa?\xdd+\x19\xc4\xd6(\xef?\xd7T\x1d\xed\xea\xbd\xb2\xbf\xf2\xab:\x10\xaaz\xbe\xbf\xa5\xe5\x97\x0f\xc4\xc5\x9e?\xe0-\xe4\x88I\xa5\xf1\xbf\x12\x94~C?d\xd4\xbf\xb6\xf0=v\xcc\x81\xee?\xcbX\x86\xb8\xa7\x04\xf3?\xfc\xa1,\xb9=\xcd\x00@H!_\xe4\xff\xb8\xe9\xbf\x0f\xb1\x96\x16\x16\xc0\xd0?\xef\xc4K\xda\xdfN\xd1?\x8d\xb3]u\x95\xc5\xfd?u\x88\xff~(\xf5\xfa\xbf\x1e\xdb\x94i\xa9\xa3\xea?\xdc\x12\x04I\x8d\xc1\xfd\xbf\xa2\x87\xa5?d\xa5\xda\xbf\xf4\x9eml\xdf\xb7\x01@\xf3e\x1b\xa6\xe1\xd7\xe4?\xf1\xce\xb4\xbcR#\xe2\xbf\x9co\x05-\x8a\xf3\xb2?\xf3>\xd5\xa5\xa9\xfc\xf3\xbft\xaa\x1e\xc4G\x1a\xe5\xbfX\x97\xa9}p$\xef\xbf.\xb3\xaaV\xbd\x1d\x02@8\x8bjvh\xe5\x89?\xa2B\x86M\xb7 \xf2?\x99]\xbd\xd4\xf1d\xec\xbfK\x84\xd0%^\xf3\xe2\xbf\xf7w]Q\n\x8a\xae?F\x1aSJ\xe7\x91\xcf?\x03\x7f\xe1\xbfI\xb6p\xc7\xbcH\xba?\xe1\xc5\n\xed\xf7\x8d\xc5?\xeb\x12\xee\xb9\xce\xe0\xf1\xbf\xfbB\x1ff\x8a\xc7\x04\xc0m\x96\xdd\x84D\xb8\xd4?\xe5\xee\xad\xd4\x11)\x96?$\xba\x01W\xa1\xe4\xe6\xbf\xf8b\x80\xda\n\'\xe4\xbf^S\x11\xac\x85G\xfc\xbf\xfda\xeb\xf5%\xd2\xfe?\xdd\x91\xa4\x1e_\xea\xb9?\xb5\x00\xdb\x95\xb5\x0c\xd6?\x8e\xb9\xabz\xf6l\xe5?Ei\xed\x98\x07(\xc3?\x81f\xd8\x99\xa4/\xe2?\xbf\xd9\xfd\xaf\xb7\xbc\xc4\xbf\x12\xfe\xf1\xfd\xcb;\xeb?\xdf"\xb7\xce\xe1\xd6\xf0\xbfj.\xb6\x107c\xec\xbff\xa1I#\xb9/\xe0?\xdf"\x83=\xbe\xee\xd0?\xf8\xa6\x1c\xfcEy\xee\xbf\x0f\xe3h\xc5\xa7b\xd5\xbfF\x06\xad\x96\xd6\x9d\xc7?\xc1\n\xc7)\x0c\xa3\xe8?\xc5\xc7rw\xe2T\xf5\xbfu>~<\xa1c\xd8?\xf1y\xc0\xa4o&\x02@\xd27n\x11\x139\xec?^\xfa\xd8\xd5\xba-\xef?\xf9Z\xafj\xba\t\xbb\xbf=lj|"f\xe9\xbf\xcd\xa8\xc2?\xf9D\xda?j\x02\x80\xd2!Q\xe3?\x0c\x9d\x08\x19\xe0`\xa7?\xdc\xfe\x15>\xeab\xd7\xbf/\x97@\xbd/\xf5\xd2\xbf\xb9\x0bo=9\x82\xd1?\x85A\xda;(I\xd3?\x12\xe5X2\x05x\xce\xbf\x9f\x96\x95_\xe7\x1f%\xf2\xbfW\x1b\xd96\xf4\x08\x06\xc0\x0c5\xa4\xa0\x07\x96\xf4?%c@\x13\x0f\xfe\xe2?\x0c\x8cC*\xa2,\xf9\xbf\x93\x8d\x07\x9b\xe3?\xec?\x1c\xb9\xe9\x87\x90\xd9\xf9\xbf\x89\xc84\x08\x1d\xf4\xd1\xbf\xdc\xa8,+\x8c\xba\xdc\xbf\xa3\x0f\xd3r\xa2\xf7\x03\xc0\x9e\xba\xa3\x15\x06\x1a\xec?\xbapS\xf4i\x13\xf5?3\xcd\xbe\xf8o\x1d\xa4\xbf\xdan<\x0f3\xff\xd6\xbfe\x97u\xa3\x8fd\xf5\xbf\xb5\x0f\xbd}r\xde\xd3\xbf\x0b\x90\xe1\xcd\x8fR\xf5? \xb0#\xc2H\xcf\xf6\xbf\x9f\x7fs\xbd\x9e\xbb\xe8\xbfS\x80EQ2P\xee\xbfBb\xb0\x1d=M\xca?H\x1e/\xaaT \xfd?\xbc\xec\xda\xb3_S\xdb?f\xdb\x86\xc2\x1e:\xf2?\x01\xfe\xbe\x1f\xc7\xb9\xf0\xbf\xb8\xdd#\xa00\xea\xf0\xbf\x96K\x9c.\xae\xc9\xdf\xbf\xcc\xa1\xf0\xb7K\n\xd3\xbf<\xa1|\xe09q\xea\xbf\x9a\x19x=\x9f\xb7\xfa?\xed+\xcdv\x8e\x89\xf5\xbfJ\xfb1$\x06\t\xeb\xbf\xdd\x83\x80\x8bs\xd7\xd1\xbf*\x08\xceFl%\xeb\xbf%|v\xdc\x8c1\xe2\xbf\xad\xc4\xb1\xcd1\xf8\xe8?i\xc5\x17\xb3y\xb6\xf8?\x81\xa9\x98\x9b\xd4\x8b\xe0\xbf\x91\x06W\xc3|\x87\xd8?\xfd\xc5\x91g\x16b\xe0\xbf\xc46\xc1m$\xfe\xf4\xbf\xa9\xfdy\xa6We\xf8\xbf\x07\x0b\xc7\xc1I}\xe0?s\xde\x992\xae\x81\xe6?}\xcf\x8c:\xe9\x8d\xbf?s\xda\x82\xb5\x8b\x06\xf9\xbf\xa0\xd1\xb8\x8e\x1c4\xca\xbf\\-\x8f#h\x80\xe0\xbf\x1a^X\xcb\xd9:\xf2\xbf@0;\xbf\xbc\xe3\xef?S\xd5\x93\xae\xe3\xa9\xf8?U\xc1]\xe4\xf9\xf4\xe7\xbf\xab\x05\x91!\xca\xbd\xfc\xbfdQ\xa1\x97\xe7\x86\xa3\xbf\xa7\xf3s@0\x02\xe8\xbf\xba\n\xd8\x17>t\xd5\xbf\xd4\x171\x15\xce\x93\xfd\xbf\x9b\xca\xae\x17Q\xd0\xd9?\x94l\xde\xc9\xcb\xd3\xe4?V\x03\x8c\xc5k\x92\xe5?$$\x1d\x8e@\x88\xd2?,eM\xbb\xda\x0f\xa7\xbf\x94\xc1\xbcn\xb3\xbc\x02\xc0\xce\xf1\xde_$\x1d\xe8?\x87\x85\x14\x88\x8b<\xf5?o\xc5\xbb\xc4\x05\xf1\xef\xbf33\xf3W\xc9\xe5\xe0?*L\xd8\x01\r\x8f\xd7?\xd9\xeeZ\xab-s\xe8\xbf\xe2\xf1~\xfaE\xa5\xed\xbfT\xcd0E\xb9\xba\xfc\xbf{\x0e.\xe3kS\xe6?\xfce\x9b\x859\xfb\xe7\xbf\x86wu=\xec2\xf0\xbf\x8f#8\xc0\x1fJ\xf1\xbfu!F\xecz\x90\x01\xc0\xec.\x90{\xb6\xe9\xf1\xbf\x82X;\xc5s\x88\xb8?,\xfb\x1f/Z\xac\xfd?\x87:\xc7\x86\xd0\xfb\xe8\xbf\xcf\xce\xf0\x0e\xd2\xc0\xea?d\xff>\xf1\xc3=\x05\xc0c\xce\x0f\x90R\xe9\xe1\xbf{\xecp\x98\x18\xfa\xf2?\xf0\xe4>\xc9R\xea\xc5\xbf\xf6\xd1\xcaw\xaa\x05\xd7?\xd6\x9b\xae\x1a\xcf\x10\xe2?B\\f\xb6\x8fJ\xd3?#\xa8t\x97/4\xde?\xc5\xff6\xd8\xab\x14\xb9\xbf\x90W\xed\x8fN\xfc\xe5?\t\xdb\x9a~Um\xd7?\xe3y\xb6\xf7\x15L\xf3\xbf6\xa4\xa4\xb0:\x89\xeb?\x96\x92\xbf\xd1\xbc\xbc\xe0\xbfUcI\xa5\x07G\xe1\xbf\xf6-!\x9b\x02\xf3\xd9\xbf\x88\xae\x9f\xa8\xd9\x01\xf6\xbf;o\x9e\x8ap,\xd6?\xd3\xdb\x8e\x10k"\xfb\xbf\x9d\xd7,\xf3\xe8\x0f\xf6\xbf\xb9\xc1go\xb6\x88\x03\xc0$9\x04TH\x1c\xe7\xbf\xab\x04H\xed\xf0\xda\xd4\xbf|\xf5\x8c\xd4\xc8\xf2\xf3\xbf\xf3\xd5`K\xc8\xbe\xc0\xbfg\xeb\x84\xeeC!\xef?\xf1\xcd\x8bE#\xee\xe1?[\x8b\xcf\xe5\xcb1\xf6\xbfN\\\x86_\x865\xd0?\x98a#\xffp\x7f\x01\xc0M\n1\x0f|/\xb3\xbf\xf5\xe1\xb6$\x01\x05\xec\xbf\x0b\x00\x18\x8a\x9d\x1d\xdc?#\xbb\xb6\x94\xf7,\xaa?2\x03\x17\xf1\xad\x07\xb6?*\xef\xc6L\xac\x7f\xea?\xd0v\x1d\xad\x15\x03\xe8\xbf\xb4t\x99\xe4>A\xc1?p\xc2A\xdf\x99\n\xd1?\xeeE/aD\xa1\xd9?\xd2\x0f\xf5\xca\x01\x88j?=-\xc6\xad\xac\xe5\xff?\xa7\x815\xb6P8\xb7\xbf\xc9\xe3o27=\xf0?\x1b\xad\x9fU\x84\x15\x02\xc0\x94\x9e\xc6\xcfD\x06\xe7\xbf\t\xee2N\xb5\xc5\x02\xc0\x9a\xa4\xa8\rM\x19\xea\xbf\xd9\t\xbc\x17$e\xa5\xbf\xc5c\x06\xd1\xfaf\xbc?\xed\x02A\x9e\x0cD\xf3\xbf\xd3\x97\x8d+\xfe\xbf\xde?\xdf\xe8<\xc4I\xac\xb9?\xb9\xb9\x8d\x03\xb8\x88\xdf\xbf\x91\xe2Y>9\x87\xe6?VP\xc5\x16*P\xfe\xbf \xcc\x88\x9b\xe7\x84\x02\xc0(\xd7F\xeb\xac\x8e\xf6\xbf\xbd\x1f+\x0b\xcfj\xe0?\xf3\xd9if\xb6\xc8\xe0\xbf\x00\x1d\xce\xd7\xe9\xda\xcb\xbf\xa2\xb08\xb4\\L\xb8?\x12\xac\xccs\x15{\xcb?9\x9f\xc2\xfe\xf2\x92\x86?1\xea\xbb\x0f\xdd\xf1\xee?\xbeJ)g\x8a\xe8\xd3\xbf\xc3\xdd\x86(L\xed\x08\xc0\xee\xa1 /\xe7\xc3\xe1\xbf\xb1dz\xfbO\xee\xeb\xbf?s\x08\xb3\xe8\x0b\xf0?\xb0cH\xc2Q\x87\xc2\xbf\xd4\xff\x97\xea\xfb5\xf5\xbf\x951\xefR\x07/\xf5\xbf\x18\x97\xd62\xd4@\xec\xbf\x9e\nc\xb9\xd39\xf0\xbfAr@\xefP+\xcd?\xa47}\xedih\xe3?uj\x91\x02\xb8\x8a\xd2\xbf\x11\x8dK\x95\x84\xca\xf5?\x975`.\x8b0\xdb\xbf\x1a\xb4\x9e\x9a\xff\xcd\xc5?\x1f\xae\x90\xc6=\x84\xf4?\xba\xc03\x8bFj\xe2\xbf\xc82C=\x80E\x06\xc00\x17\xcb\xce\xff\x19\x01\xc0/\x0b\xb9\xb6)\xcd\x00\xc0K\x88\x1f\x8f;B\xd8?\xaf\xb2\x91\x06\xb6\x8b\xf8\xbfUn\xd7\x87\x1f\xf2\xb6\xbf[kt\xbe\xc0A\x03\xc0V\x00]&:7\xe0?\xfb\x9d\x12\xcb:\xdb\xe2?\xd6\xd6\xb0\\EP\xc3?(\x8a:g\x9c\xa2\xe3?ww\x8a\xb4O\x8f\xd0?\xe8\xbe\x94\x90\xab_\x99?\x81\x1cC=\x05B\x01\xc0\xe77K\x10\x1a\xa6\xf5\xbfg\xb8\x17\xfe\xdd8\xf4\xbf\xdd.\xf8$\xf4t\xf0\xbf-\x1d\xca\xb4\x90=\xf2\xbf\xd3\xc5CHf)\xcd?\r\x8e\xe5\xf5\xc7\xb2\xf3?\xa9\xbd\x85\x13\r\x80\xe1\xbf\xd1\xbd-{\x1c\xce\xf1\xbf]?\xf6\xea\xe9U\xf0\xbf"$\xe3\xdc\x84\xb7\xea?D\xfd\x93\x072\xfc\xe0?\xf0Y]\xd3\t\xfb\xcd\xbf\xbbr\x85\x83nT\xcf\xbf\x9d\xca\x7fI^E\xff\xbfP\xb8\xf3\xe3\xa8\x0c\x11\xc0{\\\x8b\x93\xbf\xb4\xf7\xbf\x82\xbd\xef\x95X\xf5\xf8\xbf\xa1J\xd4\x14^\xee\xe4\xbf\xe3\x8c\x1f\xac\x1bY\xb6?(\xff\x1fr\x07\x82\xf6\xbf\xb8\x1c\x9d\xe7<4\t@\x1cS\xb8\x87\xb5\x1a\xa8?\x88\x18ri\xaf\x15\xd1?\xed\xcbW\xcd\x90\xf3\xf0?Z\xd0*\xd0\xeds\xf0?\'c\x87\xe0\x15\x98\xa8\xbf\x0cF\x82\xfe\xe8\x0b\xe7\xbf\x9a\xb0\tv\xdb\xfc\xe4?\xf3\xd7\xa6\x1d\xc6\x1a\xd1\xbf7\x9f\\i\x99\xc2\xe9?\xd2\xd13$\xea\xde\xec?\xbdF\xa6\xfe\x9cm\xe3?d\xb8\xafZn\x8c\xe0?\xb9\xa7\xe1w\xf3o\x04@\x91\xe7\x0c\xbd7\xcd\xf2?\xf8\xe6U(\x99;\xe0?\xd9t\x90\xc4\xbc\x91\xcb?n\x0c\xe5\xa8\x08;\xfe?\xe6\x7fx\xfbE\xec\x8f\xbf\x0c\x91?p\x16\xea\xfd\xbf\xc9X\xc4\xbf\xd9\xf9\xf9\xbf\x04}pV\xf9\xcc\x02\xc036t\xcf\xb1w\x06\xc0<\x9fq\x1a\xfb\x98\xff\xbf\x0c\xf5\xbd-\t\x1e\x95\xbf\xa4[\xbfk\xfc\x1f\xf4\xbff\xcfg\x9f\xc4)\xf5\xbf\x9a\x92\xda\xc2Ao\xc7\xbf\xe6Dd\xda\xb7\xe2\xb5?dT\x83\x12I\x84\x04@7\n\x99\xe3"\x92\xda?-\x14\xf3\xaeO\xe5\xd7\xbfm\xd0%^\xddl\xf6\xbf\xd9\xc9\xb1\xd3(b\xed\xbf\x87S\xb2fB\x83\xdc?\xd5\x97\x083\xb5L\xdf\xbf\x13YW\xc0\xc8\x9e\xd0?1\x11/\xf5\xdb9\xd8\xbf\x99\xd8\x9d\xe6s\xe2\x06\xc0\x15z\xb9\riv\xb0?\x94N\x11\xcc^D\xe6\xbf\xc7\n_\x86T\xff\x00@\xfc\xc2\x81\xdf\xa1\x04\xfb?\x0f;P+R\\\xe0\xbf\xca\xf6_\x01P\xf0\x02@\xa5V\xda\xc3\x90Z\xf2?\xad\xa2\xde\xda\xb8@\xc7\xbf(a\x1d\'te\x06\xc0\x1f\xa5\xc3\xefjC\x07\xc0\xda$\xf7\x97q\xa9\xfd\xbf\x9f\xa6\xae\x84\xa5e\xdc\xbf\n\xe7|W\t1\xfa?\x00\xc2\xa2\xaf\xc8\xc3\xf8\xbf}A\xd0\x18\xdb\xe6\xee??\xe1\xb9\x0f\x94\xda\xa8?d\x82\xf23\x8d\n\xf3\xbf\xbb\x87\x04\x8f\xd5"\xf3?\r\xb0e\x98\xcd\xf3\xb1\xbf\xc4W\xefKy\xa0\xd9?\x81\x8a\x15\'\x9a\r\xf1\xbf\xfe?\x9b\xae\xdbY\xd9?[\xc1\xe8\xaf\xfe\xf9\xf2\xbf\xf04\xd4\xad\x88\x8d\xf1\xbf\xe9\x86\x87r\x11\xd8\xc3\xbf\xb4\xff\xdaj\xfc\xd6\xf0\xbf"4\xd9W\xd2\x0f\xdb?\\\x99 \xae\xa6\xff\xe2\xbf\xdbDT\xec&\x15\x00\xc0\xb0\x86\x1c\xa6\x15C\xe0\xbf\xdf\t\xa8cYH\x00\xc0\x9c\x0bSl\x1c\xc4\xc8\xbf\x08\xeb\xdc\xec\xd2\xe2\xaa?\xe2\xc9-?\xaap\xb5?n\x8b\x92O|\xd1\xf8?\xc4\x85w\xd1\x9e\xf7\x9b\xbf\x1b\xed\xfdP\xc2\xdc\xee\xbf\x83q\x1c\xf1\xe9\xb6\xe3\xbfZS\xd6\xc0.\x1c\xf9\xbf6\xb0f\x82]\x07\xe1\xbfX\xab\x86.}\x87\x00@\x04\xe24A\x8e\xf3\xec?\xe0\xf8\x1a5\xd6L\xc1?\xeb\x9b\xf5\x06\xb8F\xcd?\xdc$P\x8bM\xb5\xbd\xbf\xd2\xe5\xa4M\xdfx\x01@\x8dn\xf7\x0c\x04\xa4\xeb\xbf\xf97\x80ub#\xe1?\xe6\xc3\xc7\xa8\x94\xf3\xd4\xbf\xf5\t9\xa5\x15\xf9\xec?\xae\x18w\xed\xf9\xba\xf3\xbfbY\xdb[\xc9{\xed\xbf\x89\xfd\xb2V\xae\x0c\xf7?w\xe4\x0c`U-\xd3?j\xa5\xdc\xef8 \xb1?\xd7h]\xc8\xdbD\xe7\xbf@\x1cgg\xeb\xe9\xe2?\x96\x0c}\xa7\xdcE\xf4\xbfikE\xe6I\x9a\xe4?^\x13\xc2:\x9b\xd2\xff\xbf\x04\xf2\x84\xcb}A\xea?jT\x87\xde\xa9\x89\xd5?dn\xc8\xf1\x83\x08\xe0?[\xd6\xbf\xeb\xf5Y\xd8?=\x9fO\xb9\xc8\xbe\xf5?\xd6g\xa3\xb8\xc6\xfd\xf0?\x82\x16\xa5\xe2\x84\x9f\xfb?m\'!Wt\x00\xe5?v\xf8d\xd9l\xf8\xd8?\x96\x98\x1fX1\x03\xea?\x1a\xcck4U\xb9\xe3?\xdf2Y\x9f\xd6`\xd7?4\xee\x8a|\x90\xc9\xc6?\x8b\xce,\xfb\xdc#\xd3?T\x0b\xcc/^\xd1\xf3?\x92t\xce>/\xf1\x9a\xbf\xc4b\x93\xa9!\xfb\xfa\xbf\x15\x14\xec\xb8\xdfm\xd0?\x8e\xbc\x91\x96\x19\xa4\xfd\xbf\xa2\x92\x84\xff)\x17\xe2?dx\xc6\xaa5\xaf\xdc\xbf1\xc8s\x9e\x82\x03\xf4?\x04\x9e\xba\xc1\t\x92\xc3?;nW\xf5\xa5\x0c\xc2?\x01l0\xc5=\xa4\xfc?\xabt@\xc2\xb0n\xfe?\xcbE]\xf7\x83\x8e\xe8?\xeak\xb8o\xf6y\xf8?.\x8e\x8d\xc2\xeb3\xf4?\x80\xf0\xa8Q,\xc3\xc6\xbf&F\xf2A)\xf5\xf9\xbfCENQ\xa8\xb4\xd3?E#\x12u\xdf\x03\xba?*\x9f\xf4{Hn\xc9\xbfd\xec~\x8c\xd8\xce\xd2\xbf\xc4J\x84A\x87%\xf9?\x81\x93umm\xb6\xd7?\x81\xa8\xb7=%\x08\x04@p\xab\xfe\x81\x11\x88\xf2?\xfcA\x9c\x96\xf5\xd0\xf4?;Kr\'\x85\x97\xd4?A\x02\xa8\xc4\xe8\xda\xdb?\xcc\x0e\x14\xc5\x11\x94\xcf?\xc1d\xd7\x0c\x1dy\xea\xbf\x82\xe0\xb6H\x03\xe9\x00@[w\xabH\x93\xb2\xd4\xbf\x89\xba5\x89\x1d2\xc6\xbf\xaf\x88k\xb93J\xec?\xef|\xdc\xf2\x82\xe7\xed?\xff\x15\x89\xfa\xc0u\xe3?c,C\x9bT\xf7\xd7\xbf\xfb\xa3\x06\x0b\x9f\xc5\xf0\xbf\xf7\x9c\xdb\x1a\x86=\xf3\xbf\xd0\xa5[\x1cKU\xe8\xbfCV\x92\xea5P\xe4?0\xe6\xe427\x02\xe8\xbf\xb3"\xe0\xf7\xa6\x10\xc3?\x14\x17\xf8\xae6\xf9\xdb\xbfv\xff\xfe2F\xa3\xe1?8\xbfk\xd2\xa1,\xf7?\xe1\x15 \x83\x99\xa7\xbd?%\xd0eV\x16d\xad\xbfR&I3km\xdd?\xdeU\xd5\x97\x96x\xf8?\xfc\xeb\xac\xd1\xd4f\x82?]\xa5a\xb2kA\xda?<\xe8\xeb\x0fZ\xc7\xd1\xbf\x97\t\x17\xff\x12K\x01@\x90\xf1aq\xe9\x8e\xff?\x85cm?\x0b\xc0\xe7\xbfA\xd0\rT\x04\x10\xd3\xbfTf\n\xe5h\xb6\xf3?\xd5\xf3\x91\xa2\xc1\xe0\xe8?+\x8f\xb9\x86\xc2Z\xeb\xbf\xd9(\x01v\xdcu\xaa?W\xf2r\xd0K\xdf\xd7?Y\xcf"\xe2\xaa\x85\xe6\xbf\x99\xcci\xb8\x19w\xea?\xee7\xcf\xf7U\x85\xf1?\x0e\x85\x07\xd2f\xa6\xea\xbfA\x96(\x9b-`\xd6\xbf\x9fNt\xbc+w\xf4\xbf\xe6Rk\xd7\xf5\x1e\xf2?\xa0\x1aS\x023\x19\xef?\xbb\x1aC\x1a\x87w\xe3\xbf\xdbk6\xf1\xa8B\xc9\xbf\x92\xaaB\xb1\xe4\x19\xda?\xc0\x9d\xea\x94\xd5\x8b\xc5?v$iu\x151\xd6\xbf\xd1#\x8d\xfb\xf5t\xb9?\x1e\x969\x0e\xc9\xc9\xf9?\x15\xe7\xda\x91=y\xf2\xbfkQ\xcf\x14\x151\xe6?\x01\xa2q\x03\xa0%\xe5?\xdcX\xb9\xea\xe84\xf0?~\xc5B\xcc\xbf]\xdb\xbf\xca\x06\xd0\x8ciW\xcc?\t e\xd5a\xd0\xdf?Jt\xdf*y\xc1\xf1?\xdbg\x7f*\xb0,\xf4\xbf\x05]-\x96I\xd8\xf0\xbf\x8f\xf9\xea\x9c,\xfd\xe6\xbf\xd3\xc7h\xff\xd7\x1b\x01@\x8bh\xca2\xfa\xba\xfc?\x83\xb3\x0b;)3\xde\xbf\x93\x1d\xa5\xd7+|\xe4\xbfg\x99\xe7\xda\xb6\xdb\xd2\xbf\xcf\xe4\xb1\x8cB\xd8\xcd\xbfsz\xa4\xda\xe6\x88\xdd?)L\xe73\xaa\xbc\xd7\xbf\xaf\xecL\xb0\xfd:\xfa\xbfnHzCIh\xde\xbfbH4B\xe1\xef\xba?\xdeO\xd0\xf4\xc1\xf2\xdd\xbf\xee\xc1Fq\xea\xf8\x00@\xd1k;S\xdd\xd4\xd9\xbf\x96\x18\xd0\xcd0\x87\xf0?\x8b\xdb\x96\xa5d\xb1\xf0\xbf\xe6\x10|Wc\xb5\xdd\xbf\x1d\x0b\x9e\xd7\x06w\xc1\xbf\xdbbS]\x98)\xbb\xbf\xc3[\xe3\xea\xac\x90\xea\xbf\x06\x1c\x95\xad=\x1e\xf8?\xea[\tAA#\xe3\xbf\xaa\xe7*\x13\x01\xfd\xd3\xbf\xe7\x9b\xe6j\x1b^\xe8\xbf\xf6X`\xd9E\xc6\xd4\xbf\x00\x89\x97\xe3\xda@\xe3?\xe7\x06\xbf\x04\x19\x86\xdf\xbf\x06\x10\xaf38u\xf6?\xff}\x8c\xb9\xa6u\x8e?\xcc\x06t\x939\xa3\xe4?\x07\x0fC\x8a\xb8r\xed?~j\xdb\xe7\xdc\xc6\xe6?z\xed}a\xb1\xd9\xd0?\x1d\x81\x066\xf2\x7f\xd4\xbf\x86|8+a\x14\xd1?\xa8Tm5=\x1a\xeb\xbf\xdcD\x8d\xa3)b\xf0\xbf\xbe\xc16\xc5F\xab\xdd\xbf\xfc+\x9b\x1d\xaf\xa70?\x8f("\xb2\xb0a\xfd\xbf\xcb\x07\x9f:u\x1a\xdd\xbf:\xc1\x8f?=\xe4\xee?\xd3=\xe8\xe4r\xc9\xf2\xbfY\x10c\xa8\xc9y\xf1\xbf\x18\xf8Q\xeaD\xde\xf5?\xd2;\xfb\x19C\xb2l\xbf\x8aF\x03\x19\xa7`\xe4\xbf$\xc3\x15X\xa6\xd2\xf8\xbfuq5\x04\xc9\x87\xf0\xbf\xdba\xf9K\x95\xe8\xf1\xbfe\xfe\xeb\xdb\xba\x04\xed?\xdd!\r\x05T\xb4\xf6\xbf6\x7f(\x80z\x10\xec\xbfO\x95m\x99\x9e\x88\xf0\xbf\x07\x9d\xdcpgY\xe7?\xd0\xa0\x18L\x18+\xf1?\xee\xc6N\xe8F\x01\xdc\xbf?B\x96v\xdeF\xce?w\xe7\x08\x82\x16\x86\xe9?tmn\t\xec\xd7\xd9?\xd1\xefrw\xd0\x83\xca\xbf\xa6\xa9\x9d\x1bk\xbb\xd3?\xddC`\xbc\x9f\x7f\xd7\xbfh\xf5\x10\xbd\x9a(\xfe?Qz\xde\xe6C\xa7\xbd\xbf6\xa4\xfd\x9a\x1fM\xcc?\x99x\xc9\x12\xde\xe9\xde\xbfb\xbbKU\xe3\x0f\xee\xbf\xd6\x18\xda\xc4\xe28\t\xc0\x15\xbf\x97\xef~(\xed\xbf\xaa\xc3\x05@\xf5\xc2\xd1\xbf\xe6\xde\x1dx\x19\xe3\xfe\xbf\x84\xabQ\x0f\xfe\xa3\xf3?q`\xc8r\xe3J\xfd\xbfy\x1d$G\x9aE\xf6?;\xc7\xef\x8e3\xa3\xd1?\xde\x1c0\xdc\xa3\xee\xcc?\x10C\xb5p6\xd6\xea\xbf\xf8\xca0\x8d\xc3\xba\x92\xbfR\xf9\x82\x03r\xf0\xbd\xbf\x16;\x16PC\x87\xda\xbf\xfd\x05_\x0f\x02\xc0\xd6\xbf\xd4\xf32\xb5\x0f\xc3\xe4?\x82\xf5\xaed\xc6p\xe9\xbf\xc7\xae\xaaZJR\xd7\xbfg\xc3.\xa8\x0b\xcf\xeb\xbfw<\xd0\x1cR6\xef\xbf\xe6\x05 NQ\xf5\xf3?\xc8\x89\xacI3\xbf\xab?\xf8P\x16\x87S\x19\xec?{j\x11w\xfd\xdc\xe2\xbf\xf4\xb2\x94\x1e\xd3\xda\xd3?\x80\xb4\xfd\xef\xca\x92\xcc?\xa7\xfb\xba\xed\x1f>\xef\xbf\xbf\x1d\xa0l\xa34\xdc\xbf\xa5\xad\xa4s\xce`\xe1\xbf\x95dp9\x99P\xe2?\xfd\xe0\xc3\x1d\xe7\x12\xec?\x94^\x86\xd2\xf3x\xe1\xbf\x8a;\xbb\xa7\xa1\xf2\xf8?\xd2\xe4\x91\x85\xbb\x85\xf1\xbf\xd1sN \xb5*\xd9\xbf/\x1d\xd1H\xbe\x15\xc8?\xb0_e\xa3\xb2\x03\xe9?\xe3?\x1c\xd5\xc3\xa1\xf5?4\xebE.\x8f \xfd\xbfaO~\xe4\x80\xc8\xa1?\xb3D\x8a4\xa6\xad\x94?\x8f\xf1\x9d\xd8cw\xd1?\xb9\x01\xb3\\\xe2\xba\xf4\xbf\xfaF@s\xc8\xa4\xf4?\xe3 .)\xc2Y\xed?#C&\xa7\xe5\x1c\xc7?\xd5\xcb)\xa2\'\xe1\xf2?\x80*9j\xce\xe0\xf3\xbf\x98\'<4<%\xd2\xbf\xd0\xfd\xb91\xe5\xda\xf6\xbf\xe3\x86&$V\xf3\xbf\xbfT\\\xcb\xac\xd36\x86?#{Qo\xf4L\xdf?I\xfa\x96\xdf\x8c\xa1\xe5?\\\xaePq\x05\x1b\xf7\xbf-c&\x9e\xa0\x1b\xee\xbfp\x04\xff#\x99\x18\xe4?}\\\x88w\x88\xfb\xdb?\xdc\xf7*O\xe6\xe6\xea\xbf>\x9e\x04\xfa\xc5O\xe1\xbf\xbf\xd4\x98L\x8e!\xea\xbf\xa7\xdb\xbd\xf0,\x13\xf1?\x07\xf2g\xd6GY\xcc?\x15S\xb9|\x00|\xd5?i\x94#\x04\x03X\xe4?M\x07<\xef\xdf\xbf\xe3?\xec\x83X\x0b\xc8\xba\xf3\xbf\xc5\xd3\x05NA%\xfb\xbf\x1f\x1cc_\x15\xba\xa5?\x10/qHQ\xb6\xcc\xbfQ\\l\x12q\xd5\xeb?V|L\xb2\xfb\xf4\xc0?\xa0j\xe1Y\xdc\x9d\xf0\xbf\x8c#`\xfa\x99"\xf7\xbf\xb5z\xfd$\x11\n\xff\xbf\x9d\x98J\x18\x8f}\xe7\xbf;N\x9e\x19\x9e\x08\xdf\xbf\xf8\xc5Y\xf1\xeb\x0b\xf0?\x9c\xaf\x860\x84\xf0\xd7?\xc6R\xc3\x87\xb0\x8f\xdd?\xc5\x98dQ-\xc7\xd8\xbf.\xfc\xf7"\xa8\xd0\xf2\xbf\xef,\xb4\x01\xda\xae\xd9?\x01\xe5<\xa3J0\x01@\xb4\xd2\x0b\xf3\xf4&\xee?c\x19 \xca7\n\xe0\xbf\x07r\x98{\xd0\xf1\xf2\xbf\xf7m\xfc\xb3\xea\x98\xb9?\xb0\x01R\xae\xe61\xe9\xbfNce\xe9\xae\x8d\xc3?\xc6a\x07\xe9p\xeb\xfa?\x9d"\x93\xf3Ei\xf9?\x8a\xee\xfc\xc5\xe5\xea\x0c\xc0\x11=\x8b\x95\x00\xbc\xe2?\xd9T1\xcc\xfel\xf3?\x8a\xa8\xcf}\xa1 \xd8\xbf\xe0\xda\x16\xb5>p\xbd\xbf\xe7\xeb\x96Q\x8b\xa2\xff\xbf\xf5\xbc\xee\xd9\xde\x9a\xe0?b\xb6\x9b}a\xbc\xe9\xbf\x7fz\xa7\x04g\xf5\xf0?)\'\xe4\xadN\xe1\xfb\xbfI\xbb\xf0\x94r\xcd\xbb?\x7fU\xe6\x01\x8b\x9e\xf3\xbf\x8dX\xa5\x97e\xb0\xf5?\x9b\xb9\x9e\xc5\x18)\xea\xbf\x14\x07\xd2\xbc\x91B\xfb?\xce\xeeU\x91<\xde\xf6\xbfk\xe9\xb7\x18\xda\xce~?\xf0\x9aRnH\xbe\xdd?\x1d\xee\x8d\xe2&\x17\xb7\xbf\x15\x9a\x02\xbd?\xf2\xe1\xbf\x0c\xf3g\xb9C\xac\xee\xbf\x85\xdf\x93\xe8\xb6\xab\xec?\x87\xd7\xf9t%\xa0\xdd?\xed\x9b\xf2\xce\x91\x80\xd9\xbf\xa9\x96\xf8\xefA\xcd\xf8\xbf+\x18\xb3\xb2\x95\xb6\xf1?Ca\x87I\x86\x7f\xe2\xbf\xa5\xcf\xe8\xc9Q\x94\xef?B\x98ezl\'\xc6\xbf\x9e\xd4\\\x837\xcb\xc5\xbf\xb3\xf2\x0b:\x97{\xda?\x823\xd4\xdfI\xeb\xf6?m\x85\x02,e\x1c\xf2?A\xee3\xaa\xbe\xcd\xe0\xbf\xfa#\x88\xc9v\x0b\xf3?\x06c]2\t(\xf3\xbf\t\x8a\x8cZ\xcdb\xe3?+B\xc7\xfe\xc8\xe5\xf0\xbf\xa7\xd2\xe8\x11\x01F\xc5?\xaf\x10c\xe5\xb7~\xe0?\xb9\x9d\xfeF91\xef?yA\xba\x86:O\xe7?\xa8lnh\xc0\x11\xca?P\x83\xf6\xe2\xd0\xbd\xe8\xbf\x86a*\xa6=\xd4\xaf?\xbaXg@\x8c\x81\xf8?\xd2\xaa+\x9fDr\xf2?$w\x01\x89@\x16\xfd\xbf\x8ci\xfc@\xf3\x1e\xf0\xbf\x9f\x90\xbc\xe4V<\xe8\xbf\xf1\xc1)V\xa1B\xce\xbfk\x9a \x97\xc9\xc8\xc1\xbf\x8f\x97\xe9xV4\xe7\xbf]Q\x05x;Z\xde\xbf)\xd9~U\xca\xaa\xef?\x0eG\xfb\x06=\xc2\xc8?OHA\xde\x0eH\xa8\xbf\xea\x8e\xbe\xa7\xba\xac\xdd\xbfu\x9c\x1d\xb8\x93\xb1\xc1?\xa0\xe7b\xda\x82Y\xf2\xbf\x13E\xb6T{\xee\xe3?7\x04\xdcU\xf0\xd5\xd8?v\xb3\xfa\x96\xfc0\xf6\xbf\x99\xd3a\xe6\x0c\xa0\xe4?\xca\x9d\x84\x0bF2\xb0?\x83\xab\x07\x02K\xce\xb7?\x1e\xcd?\t\x8e\xbd\xf9\xbf;\xf4\x93)\xb7\xf1\xcd\xbf\xe4\x0f\xc1n\xf0S\xea\xbfMx\xaaF\x05\x08\xf2\xbf\x05\x9e\xffS\xfd\xf9\xf4?\xf0\x0b\x0c\xf8\xa0\xb1\xc9\xbf<\\V\x15\xd6O\xfa\xbfZ\x01W\t!$\xf8\xbf\xdai\xd1\xfa/e\xdd\xbf\xa2\x07\xf9l\x95\xb9\xf5?yK\xdc\x9b\x12\xc6\x05\xc0\x8d\xfe\xe0-\xd1\xa6\xfa\xbf\xcb\xcd\xf7D\x9b\x93\xfd\xbf\xfbf)\x10|I\xc9?R\xbej]\xc60\xf6?\xe0]XY\xfc\xd7\xd7?\xdbio(R\x1c\xfd?\x9b\x9f\xad\'\xc0O\xe4\xbf/\x02-\x87\xb4\xea\xea\xbft\xa3\xc4\x07\x7f\x96\xd6\xbf1)a.Uq\x02@\x0e\x9c\x16&h~\xea?\x9f\xec\x9e,pX\xf3?6\xbeA\xf2\xb2\xc8\xf9\xbf\x16\xc2`\x03$\x14\xbe?\xa8\xde\x88\x96\xc4$\xdf?\x93\x8f\xd8\\\xe7\xf2\xe5\xbf\x8ex\t?\x0c\xa7\xb7?\x88GMY\x06\xd4\xe9?e\xb0\x81\x087\xf0\xd5\xbf\x12\xc3m\xaa\'_\xf7\xbf{\x80u\x0c\xae\x04\xe5\xbfx*Q\x16\xe6\xde\xed\xbf\xe09\xc3\xf7)\xab\x01\xc0\xcfmYL\xec\xc1\xf2\xbf`\x1f1\x8e0\x13\xc8\xbf\xe4\xb9F\x10\xb4\xa6\xb3\xbf[\xd5N\xfa\xe2$\xf3?\x1b<|\xed\x01X\xe4\xbfU\xdb\xc3J\xfd]\xdb?q\x82\xe6\xf9\xd6\x07\xe7\xbf\xd15\xa5\x84\xc5\x1a\xf9\xbf\x80\x98\xed\x13\xbd\x00\x00@P\xd6\x1c0b\x03\xdd\xbf%MLA=6\x04@\xfe\xd9\x82\xb8eJ\xe3?\x87\x97\xe4\x0c {\xf1?S.]\xaeaI\xdf\xbf\xc6\xadu`(\xfd\x03@<\xfb\xb9\xbb\x07\x97\xff?\xf3\x86\xd8%\xa6\xee\xc4\xbf\x07\xd3\xc9\xbb\x93\xb7\x9d\xbf~\xdbt3&\x0f\xe5?\xd7 \xa4\x0f\xc1N\xf4\xbf\xea|\xbc\x82\xed6\xef\xbf\xe1v\xd8O\x96`\xf3\xbf\xb6d\xdb\xbf\xc5\x1c\xb6?s\xc7l\x97\xb7\xba\xde\xbf\xeb\x1b\xbb\x93f\xf7\xe7\xbf\xc4\xabx}CB\x0f\xc0s\xacy\xae\x80\xbc\xdd\xbf\x7f*\x9a&\xe0\xd5\xc5\xbf\xf51\xa7\'z>\x99\xbf\x9d9\xea\x93\x98\x83\xe2?A?\xc6\x86&.}?\xb4f\xcf4v\xfe\xec?\x05\xebu_aO\xf4\xbf\xad \xfd\xe9K\xe2\xf3\xbf2\xae\x94\xa2I\xe0\xfb?o\xe5;\x836]\xf5\xbf\x91\x12N"U\xb1\xe1?\xfa9H\x02R\x01\xcf?\x8b\n\xa3\xac\xd7\x82\xd2\xbf4\xbe\xc2\xab\xfe\xb3\xd6?D9]\x87R7\x00@\xcf\xbaP8X\x9b\x00@\xe9\\\x04\xe5\ts\x00@m\t@\xa6\x84\x90\x07@\x04\xa8\xe9ZB\xd3\x0c@\x0f\xb8\xb4\x1a:9\xf2?\xb0\x0c\xa9(\x8b4\xf8\xbf\x16\x0c\xe5\xef\n\xd4\xf9?F\xff\x1c\x05\xcfu\xe2?\xd4\xd6A\xe3,z\xe7\xbfW\x0fl\x12p\x96\xfa?_\xed\x0e@96\xee?#b\x11\xb6\x9d\xa9\x08\xc0.A\x8c\xeb\xafk\xeb\xbf\xff\x97f\x99\x1b\x82\xfc\xbf\xd0\xddsnB\x95\xf4\xbfNB\x86`\x1f\xfb\xf2?XQ\xca\xe4\xfd\xdf\xc7?\x92\x81\xf5\xb5G\xe7\xf2?\x8f\x08\xd4\x11\xed*\xd7?\xf55\x9d\x8c\x8b\xb2\xe8?\xef\xc9\xf9\xe0\x8f\x82\xc0\xbfYm\xa0\x00\xba\xd1\xf2\xbf\xcf\xeb\x1a\x97\x99&\xe4?\xdb\xfeR$\xbf\xba\xf7?\xda\x1c~_\x07\xed\xf0?\xaf\xc6\xafg^\xa8\x01@-\xe2\xeb\xb7\x1b\xfc\xfd?\xe4~T\xdd\xa2$\x02@X\xd0\xdb74\x89\r@\xd2\x81e\x19bM\x07@\xe8\xce\x17VC\xe9\xf2?a\xa7$Q\x8d\x06\xe4?b\xb6\xf3}1\xda\xf4?\xb4\xa15`x\x17\xff\xbf2\xe5E\x9f\xd7\x08\xec?\xf4\x90?\xdb\x88=\xdb?\xf5\xb32\x7f\xe0\xd5\xfd\xbff\x08\xa2\x1b\xd6\xa0\xf5\xbf&\x93\x064=\x81\xf9\xbfT\xdd"\xd4\x02\xb3\x01\xc0\xed\'\xd3\xec)\xe6\xe4?\xd3\xa0w\x1a\xdb\xed\xca\xbf\'\xb6\x96\x11X\x1a\xd8\xbfX\\\x19\x92(c\xdb\xbf*\xf3o\xc3\xba/\xe7\xbf\x0cT\xaa(6d\xf5?\xf1\xb3\x9b\xd3\xd7G\x01@\xda\x99\x14<\xfa\x89\xfa?5\xbc\xff\xa42\x83\xfd\xbf@\xaf\xddJ\x07\xa0\xf1\xbf;\xbbj\xe3\x8e\xf7?\x10\x80\xfb\xa1\xc7\xd0\xbc?(\xbc\x18\xa9\xd8n\xa3\xbf\x14=\xdb\x8d\xf0\xcc\xd6\xbf]\xb7 \n\x9e\xdb\xe8\xbf\x96~\xab\x14\x84:\xdf?\xbf\xda\x81)Z\xb1l?\xed\xa9\x0cW1_\x07\xc0\xa9\xa0\xb6\x06\x94p\xf5?\xe0[Uo2O\xf9\xbf\xcb2]T\x93\xec\xd3\xbf\xc4\x9bw\xf8\x91|\x89?\x89{\xab\xcdU\\\xf8?\x04\xba\xa6\x87+\xf5\xbf\x04\xea\xc8\x8dq\x86\xf4?\x8e\x00,\x85\xe7!\xf0?V\x8c|\xb5\xdex\xff?pj\x15\xae\xe11\xf3?\x96\xfe\x90\x15]\xb5\xed?\xae\xeb\xdd\xc7\xe2\x86\xf3?\xec\x8b\xdb\xda3k\xef?\xd5D\t\xe7/\x86\xdf\xbf0C\xa9\xd8B\xe9\x04\xc0\xfb\x95wO\xd7\xe5\x0e\xc0\xf6\xbf!\xce\x19\xe7\x11\xc0\xbd\xc3u\x96\xfb\xd6\x0c\xc0ht\x8b\x15\x0cC\x15\xc0:\xd8\x91\xe1\xe6\x9e\x1a\xc0vTL\xf3y\xf9\x16\xc0\xd9\x0c\x9c\xfcq\xa3\x10\xc0\xa5\xf5\xbd\xa3\xec~\x07\xc0\xb6x\x85\xd5\xfa\x9c\x06\xc0\x01i\xd9\xcca\xae\xe3\xbf\x19\x04\xb0d)\x7f\xbb?k\xcb\x87:\x00\xc8\xfe\xbf?\x8c\'Muf\xfe\xbf\xf7\x85\xbe%\\K\xe4\xbf\xbfD4`\xa7\xd9\xeb?\x15_\xc9\x11\xa3\x14\xd7?e? Y8\x92\xe0\xbf\xf0\x00\xa2\x88\x86\x91\xb6\xbfH\xc3\xe5"\xde"\xf7?q\x7f1K\xc5X\xc8?\xd9\rX7\t\xf5\xde?e\xed\x95\xb2\x13\x97\xef?\xfd\xf3\xa7$v\xab\xec\xbf\x82\x18\xeb9A\x08\xd1?\xed\x1aK\x19\xb1o\xf9\xbf\x8d\x9f\xa7\xd7\x8dz\xe4?\x7f\x9cbB\xbdc\xe8\xbf[\x8a\xff\xb5\xe8\xf3\xef\xbf\xbb\x8dy\x80\xe4B\xf4?W\x82\xb2\x00\x7f]\xd6?\x17\xb68\xfa\xa0u\xf0?\x10S\xdf\xe8\x89\x01\xea?\x13\x16\x91\x83\xf7V\xf5?\xc1B\xf3\xed\xf2\xaf\xef\xbf\xef\xc0\xe4\xf7\x02\x87\x14\xc0\x8e\xb7\xcd\xb4I\xc2\t\xc0,\xfe\xcfu\xc07\xf1\xbf\xf4)\x0e\xc2\x15\xf3\xd1\xbf\xe5\xb1\xaf{\xf0\xb7\xdc?\xf1Q\x9f\xa3\xbdY\xa1\xbf?,i\xd7\xed\x1c\xc4?\xf4`\x8b\xb0\xdaD\xd2?M\xee\xc6\x08\x05m\xc4?\x06c7p[\xd7\xd5?=\xa97\x19\xb4[\xb2\xbfQ\x82[\xf5\xde\xfb\x82\xbf\xc8\xca!\xf2\xdd\xa6\xe3\xbf\'\x12\x94\xc3\xc9\xb2\x97?\x018\xd1\x0b%\xe8\xf6\xbf\x90\xe6y\xbeK{\xd5?\x00\xb1\xe2\xd4e\xed\xe1\xbf\xe4\xd3\x8c\xa5\xd7\x81\xfc?\xcaO\xed\xe9\x04"\xc5?D\xef\x87a\xef\xb8\xdf?4\xc1t\xf3\xfc\x99\xee\xbfw,n1i\xc5\xfe\xbf\n\x1bU#\x8b\xcd\xfc\xbf\xd6\xfc\x81GAm\xfb\xbf\xabN\xa3H;k\xf7\xbf>Q\xa9G\xba\x19\xf4\xbf\xd3~\xb2\xc9H\xafs\xbf_\xc5\x01\n\x94\x1e\xfb?\x10d\xe5\xe5\x8dW\x9f\xbf\xfc\x8a\x079^\xfb\xe7\xbf\x95\x05\xab^\xbcN\xed\xbfW\xa4ib\x13|\xf1\xbf\x8d\xd6\xbd\xf9`\x96\xf4\xbfE\xe8\x8c\xdfT\x96\xda\xbf\'\xa7\xaf\xbc\xf6\xa5\xe8\xbf\x85 \x06\xc2\x08\x1a\xe3?\xaf\x9cu\x88\xec\x00\xef\xbf\xee\xcf\x9f\\\x91\x7f\xd5?\xa2_S\\b\xe8\x93?\x04\xc0\xf5\x11\x93\x91\xf3?\xabc8\xa2\x14\'\xe7?\x97\x154\xec\xd7^\x02@6k\x97\\\xdd\x90\xe4?\xdbF\xabGO\x01\xe4\xbf-\x8f4\xf2v\xf8\xd4?\x07\xb1\x15a%\x87\xda\xbf\x11\x8d\xe1o\xa2Z\xd1\xbf\xe3\xab\xb6\xe5(^\xce\xbf\xd4\x84H\x87\x1di\xd2?y\xd4)\x0f)*\xf4\xbfB:\xe6\xf9\x9bf\x00\xc0\x80\x82\xc8Rwm\xfa\xbf\\\xf6\x94\xbf\x19\xa6\xf5\xbf(\x129\xb6O}\x01\xc0\x8f\x05\x95\xc7Md\xe1?\x9d\x07\xadMd\xe8\xee\xbfw\xe7\xef\x07\xef\xde\xf2\xbf\xa6\xe1\xd7\xf3a\xcd\xf7?c\xa5\xd5\x16\xe1\xe7\xeb\xbf=\x98c\xed\xc6\xa6\xf6?\xe0\xc4\x1f\x04/>\xe0\xbf\xaeG\xb8\x88CU\xf4?\xb8[vQK\x7f\xcb?\xb4\t\xf7?8\x15\xf1?}\x96 \x8b\xdd\x87\xee?i\xe3\xf6\xf0\xd5\xcc\xc6?\xacb}\xed\xba\x11\xf5\xbf\xc1\xc2e\tn\x1a\xe2?\xac\xda.\xc2\xae\t\xf8?\xd0\xf5\xa6IPf\xe7\xbfz\xb3\x8dJ\xa9G\xe0?\xa7\xf4\xec/\xa0\x1d\xfd?\xaf\x84\x04ae\x9d\xe3?\xfa\xde\xf4 nX\xf1?\xbeU\xe2\xb6\x10I\xda?\x01\x1a\x83\xd7pL\xe7?"9I\xc0\xb6\xbc\xea\xbfu\xbc\xe2\x92\xc7\xc5\xf3\xbf|\xe34\xa9\x8c\x99\xdc\xbf\xd7\xa10Nw;\xea\xbf;F88Y\x85\xfb\xbfW\x91,\x9c\xab\xf3\xf4\xbf\x1c\x0c\xa8\xe3\xf6\xa7\xb7?jcG5\xf5\n\xf0\xbf\xca\xf4%\xbf\xd6:\x03\xc04=\xad\xc6\x9f\x8c\xe7\xbf\xf7\x82\x05YI\xce\xf2\xbf\xbd\x0c\xdb\xeb\x7f\x82\xe1\xbf\xf3\x80\xd6\xf0\xf7c\x8d\xbf\x92};W\x9f\x03\xec?\x99\xc0\xda;\x01P\xbe\xbf\xd0\xf8h\xf7\x06\xdf\xdf\xbf\x01y\x85\x9f\xa1\x18\xcc\xbf\xc6u;\xdc\xe3\xcc\xf2\xbf\r\x8f\xf1\xd8\x93$\xe5\xbf$\x1fQ\xc9\xb9\xc3\xd4?\x16\xd9w\xf64v\xde?\x1an\xbc\xa4r\xcb\xf1?\x90o\x84\x10\x01S\xc0?\xedni\x1a\xb6y\xc9?\n]Z\xc4_h\xf8\xbf\xd2\x92\xb4\xad\xd3o\xb6\xbfv\xbf\x9e\x0c\xaf\xca\xd7\xbf\x9f\xb7B\xe7\xe1\xb2\xd2?\x97\x0cY\xa0\xa8\xe3\xc9?\xf3l2q\xd8N\x06\xc0\xf1\xccx\xbb\x17\xd4\x03\xc0\xcb\x81jC%>\xf6\xbfd\xbc\xf0\xc1Jl\xfb\xbf\x88\xda\xd0\x1b\x9b\x8b\xe8?W\xf4\x7f8\x0c\x89\xe5\xbf\xb2\xc7\x98\x1aOU\xd8?\xa7\x01\x15\xa3Z\xb2\xf0?\xe4\x91\x95\x88\xf3i\xf7?\xc8\x9fE6f\xc6\x02@$\xbb\'\xad\xaaP\xca?\x93\x0c\xe7m]\x1b\xf4\xbf6[:\x7f\xe8\xc7\xf5\xbfst\x17\xed4g\xf8\xbf\x1b\xef\xde*L\xc4\xf9\xbf/\x16\xe0\xce"\x99\xf9?\xcc\xbf\xcb\x05\x8f\x96\xec\xbfx7\x99\xc2\xe3t\xfa?CSq%\x92m\xc5\xbf\xc9S\xa8\x01a1\xe1\xbf\x03\xafR\x80\\\xde\xf5\xbf\x18\xb4(\xbdK\xfd\xd7?R\xa4/\xb57\xa2\xe4\xbf\x0e;\x94J\x8d\xa1\x00\xc0\x9e\xcb\xb0\xe8\xd6"\xf1\xbfY\x9c4\x8b\x89\xce\x87\xbfkF\xb8\xfa3\x8d\xc6\xbf\xd1=`Wz\x94\xff\xbf\x14\x03\xe7\x88\x1c\x19\xf7\xbf\xf1\xbcL\x93\xdb\x19\xd1\xbf\x82\xf7y\x8e%7\xf8\xbf}\xe3\xe1\xb2\xc21\xcc\xbf\xa6\\\xfbBA\x1f\xf8\xbf\x87\xb9\xd1\xb9\xc6\xb6\xf6?\xffA:\x99\xe2\xf0\xaa?Q\xee\x9bG\xc3\x17\xf8?\xce \xb7\nI\xf8\xa5\xbf6U\x9f\xb9\x8cx\xf4?q\xf6M-\xfe&\xb3?\xdd\x05\xe9\x01q\x18\xfd?\xba\xc8\'_-:\xb4?\xba&%b\xc8E\xe7?\xe3\x1bey\x8ee\xe1?\xca\x96\xb1?U\r\xf5?:a\xeb\\\x83\xfa\xe6\xbf\x8b-.?\x86\x05\xf8\xbf\xc3\xd8%\x81\xbe\xe2\xb5\xbf\xe9\xdc\xe0\x99B\x17\xef\xbfqm\xb3\x14\x9f\xf4\xd3\xbf\xdbLd=\xa0K\xf2\xbfMc\x00t8[\xf5\xbf\x04>\x1ao\xdc\xa8\xe9\xbf\x99\x1c<\xee\x9b\xc7\xd4\xbf\\h\xcc\xde\xe1E\xab\xbf\x03\xb0\xce\xde\xf1"\xfb\xbf.B\x08\xba\xcc\x1b\x01\xc0\xb8\xbcm\x88\x01\xd6\xd3?V\x00\x04R>\xdb\xe9\xbf\xb5 5\xb8\x133\xe4\xbf\xbe\x81kyJ<\xf8?\xee=\x91&\xed\xef\xf2?\x18\x9f\x92AFI\x05@\xee,\x94\x0e\x08\xe7\xf7?o\xa9\x81V\x9f\xc9\xf2?\xba}{\x8evJ\xf8\xbf?lB<\x80\xce\xf2\xbf\xc7\x1b\xd1$^\xf0\xe1?X\xf5\x8aS\xfeN\xd8?\xd6N\xcfF\xd0\xfc\xd6\xbf\xba9\xe3lI\x9f\xed?s\xc3\xc7\xc7\x99\xf3\xec\xbf\x0fS\x90\xdc\xb2 \x02@L0\xfe\xae\xdcz\xdf?\x17\x1f<\x80\x02\x8a\xc5?\xacm\x8e\xfe\xe2\xc7\xf1?\xffM\xbd6\xfe\x07\xc9?j4.\xf3\x10\x1f\xea\xbf\xfa%5$;\x1d\xf5?\xa7.\xa4\x08\xc5\xd2\xf0?\xffq\xeb\xa1&\xd2\x07\xc0\x04\xb9\xaa\xb4x\xa1\x04\xc0\x90\x83k\x03i\xdc\xf8\xbf\x9b\xc1zF$\x01\xea\xbfF\x0c\x91\xc1\xe7\xa0\xfc\xbfZ\xbb\x87[\xe8\x84\x0f\xc0\xd9\x91A\xc9\xfca\xe7\xbf\xed[\xf1\x05\xee\xf3\xfc?\xdf\xfb\xe2\xe2?A\xaf\xe7\xb7\x8f\x83\xe5?\xf1\xf3e.\xa4\xae\xfe\xbf\x8f\x8c\n\x96\xfe0\xdf\xbf8:,\x80\xf6\xd1\xc3\xbf\x9e!|\r]\xac\xed?1\xf1/M\xb3\xa7\xed\xbfmu\xb5\xc8\xb2\xc3\xe8?\x13Wx\x8f\x08\x15\xfd?9\xac\xd5\xd4\xe6\xdc\xf0\xbfv*\xd0\x0b\xe0h\xfb?]\xb2\x91f\xc3\xc6\xdc?*\xe9Dz\xffB\xed?\x10\xd9\xb7\xbb\xee\xdd\xb3\xbfk\xc61\x1d\x94:\xd1?\xda\x9e\xba\'\xc1f\xe2\xbf,\xaf\xba\x8f\x7f-\xf0?6\x8d\xb8\x06\xb0\x99\x02@7q\xe8\xca\xb6\xa5\xc1\xbf\xbdh3\xaa\x14\xde\xf1?\xb8\\\x07\x12a\xf3\xf0\xbf\xf9[`g\xc4\x9f\xe7\xbf<[P@\xcd\x8f\xe4\xbf^x[b\x89\xcc\xe4\xbf\xf6\x18\xeb\xbfL\xa0\x00@U\x82\xa0dK\x18\xd5?6\x11\x1aq\xee\xce\xf1\xbf_\x90\x91(\x0c\xc3\xc9\xbf\x85\xb8*\x89\x9c%\xea\xbf\xd8\x0f\x9c\x866\xd7\xf7\xbf\xdc\x82\xcc+lI\xf1\xbf\xa1)\xa2\x0c\xe9V\xd1\xbf{\x83\xc1\x80N \xe3\xbf\xa7f)\xef\xe9\xef\xe6?\xfb\xb6\xa3\x0c+\xc8\xf1\xbfX{9\xd2~\xb1\xf0?\x0c\xd4\x08\xbe(c\xe5?\xb1\x9c\xc4W4V\xd4\xbfT\x0e\xce\x8fqT\xef?FO\xa1\xd2\xc9O\xb5\xbf}S*\n\xa0h\xf2?\xb1]C\xfd\xb0\xad\xee?7x\xfe\xe9!B\xfe\xbf\xb7\xc3x\xfa\xa3m\xe2\xbf\x86\x82,=?0\xf0?Pa\xb28\xf4\xcc\xe3\xbf\xcf\x12L3\xd1C\x00@1K4/\x9a\xa7\xf1?(.%\xfel\xc4\xec\xbf\x91\x84P>:\x99\xc2\xbf\x90\x8b\xc7\xd1\xea{\xc0\xbf\xb1\x17\x0f\x94O\x13\xdc?6@\xba\xfcp1\xe5\xbf?b]K`\xe2\xd9?`Y9\x02\xd7_\xe2?\'\xd4\xfc6\xe4\xce\xe4?\xa9\xc6\xaf\xc1\x82=\xd6\xbfl\x17=~\xb7\xda\xd6\xbfqI\x0f\xa6\xd6\xfa\xee\xbf\xe2\x91\x99Yb\x8e\xdb\xbf\x99\xce\xa4\xcc\x80\xe3\xe4\xbf\x9a\xceay\xa0n\xea?\xb6\x1f\xff\x98}\xcc\xe6?\xecu\x84:\x88\x0b\xd8\xbf\xd5.R`\x88\xc7\xf5?\xfb\xb5D\x0f<\x0e\xe5?\x81m\xf7\xbc\xa2\x15\xda?\xe27\xb3\x85\r\xb3\xee?\x92\xd8\xab\x0c(b\xe8\xbf\x94d!\x93\xe8v\xfb?\x1a9\x92\xb6K\xbb\xba\xbf\xc79lG`\x05\xf4?\xcb\xc9\xeb\x13\x96\xdc\xfa?v\xb8=\xd3\xd0\x96\xe9?\x95\xd8\xab\xc5\xea2\xf3?\xaf\x17\xaa\xfd\x11\x90\xf7\xbf:$\x0b}\xec\xa7\xb2?\x98i\n\x05\x1c{\xc8\xbfo\xbe;\xfb|v\xd6\xbf\'\xa0\xaa\x02\x99P\xfe?\xf6\xb6\x81\x16/\xa9\xd2?)?\x97\xf2\x91\x08\xff?w-&\x85\x02\xb9\xbc?\x8b\xd1\x13\x17\xedb\xe8?\xb4b\xbf\xe1\xc8\x10\xf4\xbf\xe2o\xeb\xaa~h\xe4\xbf\x14(\xcb\x82\xce\x85\xe2?\xeb\xe2\x14@\xb7\xdb\x9a\xbf\x0f\xe5c\xd0Wq\xde?\xf5\xb3^\xd9\x1eb\xc7?6$9F\xbd\n\xd9?\\K\xf9\x8aQ\xcc\xc8?NA*\\79\xeb?\xff\xd5\x86\x10Kf\xf5?\xf9|\xd6/\x15A\xb2?\x18\xff\xeb\xca#\r\xe1?.\x0f+0\xe2\x16\xf8\xbf\x19\xfaYir{\xd1?*\x80UT\x91\x17\xef\xbf\x06\xaf\x18\xbao\x83\xd4?y\xdd\xdaT\x117\xe7?\x03\xa5t:\x95\x14\xf3?\xa5\xbd\x91\xdc\xd7\x90\xbe?\'\xf4\xe5\xa1Ax\xf3?\xa6<\xf8\xfa)\xcd\xd1?\xd7\xa08D.\t\xe4\xbf\xf3\xb56\x13$\xec\xe8?\xf7\xc7\xa8Hl\xac\xd4?\x96\x869\xc9\xec\x01\xd9\xbf[\x01\xa1g\xc4\xf1\xef\xbf\x1a"gN\\\x83\xd4?\xc1\xe3Q\x1f\xaa\x16\xc9\xbf"\x01\xfb\xcd\xa8\xb3\xd1?J\xe67\x88\xedO\xf5\xbf\xccL\xe3\xc0!G\xd2?\xe6\xcb\xbfU$\xc1\xf2?\x8fx\xfdn\r \xc7\xbf\xc6u\xc1}\x04o\xdf?\x1e\x86\xad\x18k\r\xd2?\xdf\xc6\x9dM"t\xc9?\x9f0V\x85\xf4J\xfd\xbf\xc9\x8e\xf0Nz\xd5\xee?\xd9\xb7g\xbc\xacp\xdf?St\xc1\x1a\xaa\x8c\x00\xc0\xdcu\x85l|1\x00\xc0\x98\xca\xe0\xb0,\x86\xe2\xbf$\x01\xe5r6\xf7\xd7\xbfkU\x9e\x8d\xc4\xc0\xc4\xbf\xa0\xf0\x8cb\xf9{\xec?\xcd\x07\xa8h\xd5\xde\xf4\xbf\x82}k+\xfa\xc8\xde\xbf\xc3\xfb\xbf\xb9\xba\x98\xe6?Ww\x9d_\x90E\x06@\xcb\x03\xc3\xc3\xdd@\xc1?\x99\xb7\xbeW\xcd\xd7\xe4\xbf\x01\x16&\x9a\xc5\xc5\t\xc0\xbf]O\xf9\xb9l\xd1\xbf\x1e\x8e\xe3\xa0j\x8f\x08@\xb0\xaf%\x86\xd4\x1a\x00@i\x91b\x05\x99\xaa\xb1?|v>`\x0f\xbe\xe6\xbf\x85\x82\x9e\xc8\xe4\xb4\xf5\xbf\xa9\xe6\x07\xc1^\xf0\xf7\xbf\x12\xb8\x91\x9e\xa9\xb6\xe5\xbf \xe6\x94>:2\xc5\xbfHJ8\xef1>\xc1?\xd9%y"\xfd\xbb\xef\xbf\xc2\xbaH\x90\xfeK\xe3?\xdb\xf7\xdc4\x94\x97\x9d?\xf5i\xe4.\xa8\xee\xcc\xbf\xa6Sc\x9c\xee\x07\xee?\xd7\x1av# \x81\xe8?\xd6\xd4P\xb7\x1a\xb7\xea\xbf\xae\x17\xb4\xe7\x04\x92\xf3?1]\xe2\xc1S\x9a\xf4\xbf+Z-\xa2 P\xfe\xbf\xfe2N\x87]\xb8\xeb?\xfeu\x08\xb0\xef\xd8\xd4?=V\xd0i\x82a\xf8\xbf\x16^\x8f\x0f\xf4\xf6\xf7\xbf\xd3\x0c\xb7E\x81\x8b\xd8?Y~\x800pm\xe8?\x83\x07\xe4D\xd5\xed\xfe\xbf4@L\xdf\x07\xe8\xe0?\x91\x08\xfaQ\x1e\xc5\xe6\xbf\xbf\xe8\x99@50\xea\xbfy\xd1\xd8\xcbJ\x9f\xe4?G\xddp\xe8\xd8\x18\xee\xbf\x99\xc1\xdc\xaa\xa7\x96\xe8?\xc0\x9b"Gz\xef\xf0\xbf~\xa94\x9f\xeeu\xe1\xbf\x9b*\x7f\xae\\R\xc8?\xec\xf4\xd4Af\x7f\xe9\xbf\x99\xd0\xf3\xbeI\xa3\xf1\xbf\x94\x8d\xf8|\xca\xc5\xf7\xbf\x98H8l\xe4?\x16V\x08\xa8`\xac\xef?W\xb5\xf2Ll\xbc\x04@9\xc4\xf6JJ\xb2\xd1?h$\x7f6B\x9c\xf6\xbf\xf53(K\t\x8f\xa8\xbf\xb0\xf8\x15\xb8\x96v\x9b\xbf\xf0\x8e\x8bz\x85\xde\xf2?9\xf0\xe1\x1c\xe3*\xee?\xde\x8c\x0c~\x9b\xf5\xee\xbf\xaeO\x0e\xce-f\xf6\xbf\xf8\x0c\x10\x8f\x9d\xe8\xf8\xbf\xe5e\xc51\xdd.\xea?\x8e\xa0\x05\x8f\xd9L\xee\xbf\xd0p5Z\x9cJ\xc0?\xbc\xcaY\xd4\xfc;\xcc?3Vlh\xa5q\xb1?\x91\x04\x14Ui\x86\xe6\xbf\x18#?\x04j\xcb\xa5?\xd0\xac\xa1\x0b\x10\xf0\xd5?\x83h\xe8a\xbf\xd6\xe3?\xfa\x08\xb7d\x8dL\xed?\x8cM\xe7\xa2/v\xf3\xbf\x1cf9\xc2\xd01\xfb?\xdfNt\n\xb7\xb3\xef\xbf\xfe\xe3\x8eBr\xc5\xff\xbf\xe8m1\xc8P\x86\xe1?@E\x01X9F\xf4\xbf\xe8\xcbw\xcf\x16\xf8\xff\xbf\x90c I\x0c\x9c\x00@\xf6w\x17x\xa4\x91\xe5\xbf\xbd\xb2M\x9c\xe6M\xf6\xbf\xa7q\x03\x90\xdf\xf6\xf6?\\J\x00\x1d\x01\x83\xee\xbf\xef\x89\xa9h\xfe\x9f\xd8?O\r]\x17\x1c\xf6\xe6\xbf\xc2A\xd3\xab\xffG\xe6\xbf\xaa9yczF\xec\xbf\xe5\xa5\xa0\x931\xa2\x9e\xbf\xa2\x9c\xf0\x9d\x87R\xf3?\x8d*\xad\xa0\xf8\xc1\xe4\xbf+\x83\xc5\x1eI\x1a\xd2\xbf\xcd;i\x11\xeb\x8f\xba?\x06\x11?\xbd*\xe7\xbc\xbf\x12\xe7\x8f`\x017\xb1?J\x8c\x9b\x05\xce\xd7\xca?G\x8b\xd1$\xbc\xbd\x03@\xd8B!\x8c\xac\x1c\xd5?\xc8\x8d\x8d\x1e\xba\xf6\xef\xbf&\xca\xd5F6d\xf0\xbfZGE>\x11\x18\xd0?]\xd5\x1e:^>\x08@\xf4s\xe1Dp\xc5\xec\xbf\x0c\xd3\xe3\xaat\x92\xed\xbf\xc2\x9d\x93\xa4P\xb8\xec\xbf|e\xf1\xc8\xcd$\xe9\xbf\xd34h9\x93{\xf2?\x83\x91Y\x99\xfa\x11\xd5\xbfH\xb0V\x9c\xec\xc9\xe5\xbf\xd3\x0b\x046Bt\xe0\xbf\x08\x18Sv\xa1,\xd6?wG\xc9\xb5\xaf&\xfa?\x82\x03\xf66`M\xee?\xcf\xe0\xa9\xf0\x1c,\xe1?\x95\xcc\x12\x18q\xac\xf6?\x0e\xb2{\xd4\xaf\xa8\xf5?KC\x00\xa8t\xc9\xf3?\xb3\xd9\xf4\x9d\xddV\xea?\x7fq\x7f\xa1\xd7J\xe1\xbf\x9aWU\x18\xf46\xef?)\xa1__\xb5\xea\xe3\xbf\x16\xf9\xce\xcb\x07\r\xf7\xbf\x15\xe6@p"%\xe1\xbf[\xd6\x9b\x1fD\x9c\xf0\xbfL\xbb\x81\xbd\xcf\xd7\xe1\xbfu\xe9\xc8M\x12J\xf1?V\xd5K65-\xeb\xbf\xbf\xbb\x91\xa5\x97[\xf3\xbf\t\xeb^e|\xee\xf1\xbf =U\xb0\x1e\xb8@\xa1\x93\xf3?^\xba\xa5\x9c\x9f\x92\x06@\xad\xad\x18\x1c,{\xd4?\x14S\xb0\x1b\x10\xbf\xf3?\x136V,\xac&\xe5?\x12N\xb1\xedfH\x01@\xdaW\xe9\xb5\xe1\xdc\xff?\xe2\x00k\xd7\xed\xd5\xa8?\n\x84+#\x90\xaa\xf3?v\xa4\x94\x862\x0f\x00@M\x9b\xcd0\xae\xfd\xed?\xdb\x8c\xce4\x1ez\xf2?*$M\x12j\x93\xc3?p\x11\x1bh\x83\xc8\xf5?\xb0V\xbe\x91\x96[\xf2?2\xdf&\x1c\xc7\x96\xd7\xbf \xfcw\xb5>\xde\xf8\xbf1\xe6\x05\x92\x7f\x9f\xf9?\x8d\xe4\xdb\xe4B3\x00@\xe50\x97\xb3\x06<\xf9?\xdd\x04W\x8e\xe0\n\xe0\xbf\n\xfd\xdd\x93:B\xe0\xbf5\xb1P\'\xc9d\xc9?\x80\x10\xc4s\x83?\xf4?\x81Ve\x9d\x1a\x16\xec?\xf6\n\xfa!\xb3t\xe5\xbf5@\x90e+g\xf2?B\xcb\xfb\xb0\xd1\xcd\xb3\xbf\xc4\xa1x3\x0cU\xf3\xbf\xd4\xc49`82\x03@\xda\xb5\xa8\xd5\x06\xad\x03@6\x1a\x029d\x9f\xe6?\x9e\x92\xc3]\x86\xd6\xaa?\x98\x12\xcf~\xf3\xbb\xc5\xbf\x91\xff\xc4\xc8{\xef\xe4?\xa7h\x979\xe8-\xc0\xbf\xf7XR\xc4@\x1d\xf5?\xec\xa4\x8a\xb7\x1aX\xe0\xbfV]1v+\x91\x9f\xbf\x9f$w\xef~E\xfd?\x91\xf0U%\x1a\xe3\xe7\xbf\xc2\xfc\xec\x91\xa2S\xfc?\x89\x10\xe2A\xe8\xb1\xd0\xbf\xed\x9e\xd0\x00#W\xea?b\xc58km\x9c\xd7?~z\nE&\xb7\xe8?\xca\xd2\xac\xd8-\xed\xfc\xbf\xcd\xbd`\xcc7\xf8\xdb?\xc7$\\e\xf4O\xcb?\xf3s\xd0\xb8(\x17\xdf\xbf\xd11%\x1b3\xf5\xd2?\x98",i\x19H\xdb\xbf<>\x0c~\xf6S\xd9\xbf\x06\'f\xd7\x96u\xf7?Xh\xc5\x936\xb7\xeb\xbf\x9c\xa7|\xb4\xb8\x9e\xde?\xfa\x8f\x14!\x152\x00@>)\xed\xea\xc9\xbf\xe2?\x98\xca\\q\xe0\xa2\xee?5\xac\xda\xf3g\x81\xf2?\x1d\xab(/B\xd7\xf6?\xdd\xbd\x1c\x13w\x80\xda?\xceN\t\x9c\x04"\xd3?\xdaRI\xe0?\xf1\xea\xbf>\xbf\xa9\x8b\xf54\xf3?\x11\x11\xb0|\x06\x11\xf1?\'e\xe5\xf2\xc9>\xeb\xbf\x04\x0f,I\xe8#\x97?a\xbf \x9eg\x12\xd6\xbf\x82\x0e\x7fx\x00A\x00@\xac\xeao\x9a\x8c^\xec\xbf\xfeWG\xe6\x0f4\x07@\xd9\xdc\xc8\xcc#\xbe\xde?D\xb1\xc3hi\xaa\xa3?\xd9d\x7f\x108\x8b\xd5\xbf%l\x90)\x14\'\xf3?\xbe\x17\xe3+0\xc8\xe1\xbf\xfc\x14^T\x85\x1d\xda?\xad\xda\x99G\xa2\x93\xdc\xbf\xa8S\xa8\xfc\n\x98\xe9\xbfoV\xdd\x85\x18\t\xf8?L[\xe8d\xf5Q\xe7?\xf0H\xcfej\xb0\xde\xbf\x07u\x8d_\xf0\x8e\xc6\xbf\x04\xb8\xa6^D\t\x01@\x1d\xc7\x08\xaf\x87\xfc\xf4?\x9d\xab\xb25\xc6l\xed\xbf\xb2 \xe0\xdf\x02e\xc5\xbf-\xfaXw\xdb\xb3\x82?\x19\xef\x94\xde\x8c)\xe2\xbf^\xbd\xad\xff&\x92\xe1?8r\xe8?V^\xf8?\xe5\xa0"\xf3\xad8\xef?`\x1e\xcbS\x11s\xe8?\xf0E\xd6^\xf2\xcd\xf8?\x19\x0b\xacI\xd2\xbe\xe3?\xe7\x9bA\x8c[r\xb1?\xa2B\x81p\x0f\n\xeb?\xbf\xdb\xeaR\xa9\xb9\x03@G\x929\xb0\x95\x98\xee?\x88\xc0\x99\xe2\xc3\x86\xe1?\xc1Lo\xc6\xfeJ\xa0?\xa8x+\x03\xfc\x96\xe5?\xb6\x05\x13\xea\xa1\xa4\xc3?\x8e\x17\x9c?\x81\x0e\xe2\xbf4E [<\xd7\xd7?\x8d\x12H\xb5\x15\xdc\xf3\xbf\xafqd)\xb7h\xc8\xbfQF\xdeT\x12z\xe8?V\x91V\x1c\x15\xce\xd9?\xfa\xf1\x9b\x92\xf7\x98\xe7?\x85\x8f\xec\x00]d\xf5?\xbc\xdc\xb0\x96\xa1\xcd\xfd?\xe1\xbb>\xc3\xea\x9f\xd0?\xc2\xd3\xb9.`\x7f\xb8?s\x06\xeb\xf7\x8fa\xdc?\xe8\t\x08\xc2`\xd8\xf1\xbf\xb1\xfe\xce\x12y\x96\xfd?\x19eA\x01\x0b8\xde\xbf\x88-\x81\xae\'\'\xc1\xbf\xf9g\xecH\xc8\xbe\xcb\xbf\x0e\x1b\xa0\x85E}\xd8?5\x96\x13(\xbb\xa8\xd8?\t\xc1\x91[\xa3}\xf0?;\xf2QM4*\xe0?\xd2\x01N>\xac\x82\xb8\xbf\xc2\x9e\x8c\xa9"\x08\xc8?\x00\xf7\xc5\xb1d\xdb\xf1?8\xdb\xec[\xaf\x97\xcc\xbf\xe5\x1b\x19\x10$f\xbc\xbf\x13\n\x8d\x137h\xf1\xbfW._\xc5\xb8#\xc1?\xd8m0\x00\xae\x17\xfb?s{\x01\x87\xcc,\xea?x\x0c5\xdd\xe6\x00\xe4\xbf\x03&\x04(\xdbP\xc9?1A4\xb5ru\xea\xbf\xe06\xac\x83\xc0v^?\x87\xaetB5\xac\xf8?\xb9\x97\xbe0<(\xf2?\xa0\xa3\xd0\x82\xfai\xf0?C\x8a\x8c\x9aZ\xf1\xf6\xbfg\x08\xcd6\xe2*\xe1?\xfb\x1e\xba\x99M\x04\xf0?\x91\x903\xb8hS\xfa?\xa7F\xf0\xc9g\x86\xf2\xbf0\xc9Zz\x15\xa2\xfb\xbfz\x0e\xf6s\xd6\xbb\xfa\xbfDCW\xf8\xb4x\xef\xbf\x16\x98>\xf9\x05E\xa6?8\x96\xb7S\xca*\xd0?$\x8b\x1bE\xa6\xfa\xe4\xbf\xa8\xe9\xa3Y+\x1f\xdd?\xcbX\x05\x0c~\x8d\xf6\xbfRG;Z\x96U\xce?\x94\x1f\x94\xca\xef\x8a\x06\xc0\x7f\xba\x06Y0W\xed\xbf\xa3\xe2\xab\xdc\xfd\r\xf8\xbf\xe4\xf2\x13\x9f[\x18\xf0\xbfB\x1e\x98{\x9f\xdb\xdd\xbfx\x1dKN\x19>\xe6?\xe3\x9e\xa4\xf0\xac\xda\xc4?\xca\x08q\x03}c\xa7\xbf\xe4\x18\x0e\x93\x00\xf9{\xbf\xcc\xf8\x11\xcdB\xac\xf0\xbf\xc7Y\xcbw\n\xc2\xe4?\xa8]~^\xbb\x8f\xcf?\x85\x0fw:\x1f\xb4\xdc?\xa2\xe2{\xcb)\x1a\xd4\xbf<\x99\xe0~\xb5\xf9\xc6?\x0c\x08L \xa2\xff\xe9\xbf#\xaf&;j\xa4\x01\xc0\xdf$\x0bt\'H\n\xc0\xf1\x1cz\xb3!\x9a\xf8\xbf\x93\xcd+\xf3\xdf#\x02\xc0~\r\x86r\xc6\xdf\xf6\xbf ^\x90\x02\x9bB\xfb\xbf\xdb\x00\xcb\xc4B2\xef\xbfFJ\x14\x8e\xdc\xaa\xd3\xbfa\x8e\xeaM\x8b\xa5\xf0\xbf\x80`i\x1e\xf0\xe6\xfb\xbfY9]<\x9b\x8e\xe8\xbf\x10[j\x0ch8\xf6\xbf\x97\xf6>\xe5\x13%\xf6\xbf\xc9\n<\xba\x11U\xeb?\x96\xa0\xabm\xf4\xda\xeb\xbf\x15E\x08\x9c~J\xe2\xbf\x90\xbf?d\x03\x03\xd4?>\xa9d\xc0m=\xbb?O\x92\xedAX\x83\xc0\xbf\x87\x05T\x0bM\x9e\xe9\xbf\x14\xec\x822\xack\xa8?P\x93&\xf3\xf2\xed\xcb?X\x97Tji\xab\x9f\xbf\x90\x93M*u\xd8\xef\xbf\x91\x18\xb1\xed\xfe\xb2\xca\xbf\x96x\t\xb6\xb6t\xfa\xbf\xe6.FE\xa7\xbb\xd8?\xdfK\xec\\\xa8\xa1\n\xc0\xa4\xf9b\xeb\xf6\xe4\x04\xc0\x01=\x81:O\xbd\xfd\xbf\x00\x0f\xc8\xb6\x98d\x02\xc0\xc8\xc7\\|#R\xf8\xbf\x19\xb0\xb3\x88\x918\xef\xbf\xb2\xac\t\x9b\xa7x\xe9\xbfW\x03[\xd0\xf5k\xf1\xbf{*\xb48\x9ad\xec\xbf1\xf3\xd4\xe3\x1f\xfa\xad\xbf\xcfH\x82\x08NT\xda\xbf\x0f\xe7nF\xc30\xd5?\x8fMA\x06\x90\xa2\xd7\xbfV\x07#z\xbfZ\xf2\xbf\xfb\xe5N\x12\x9d\xe2\x00\xc0\xf31\xf3\x82\xad\xbc\x03\xc0\x95\xf4\x0f{^\xe2\xf0\xbf``\xde/w\xf1\xc0?\x08 \x82\x92W\xac\xf5\xbf\xc1q\xc5\x8d\xca\xd3\xe4\xbf\xbb\xc0`&]s\xed\xbf\x17.\x95\t\x8az\xee?\x05\xad\xa7\x97\x00\xdc\xed?\xa8\xe4J\xd1\xc1\x7f\xda?[\xa5E\xea\x83%\xd8?_\x86\xf5\xd6z<\xf5\xbf\x14\xe3\xd2\x91\x83\xe2\x8c\xbf\x03\xf13 m:\xf8\xbf\x1bM\x8cK\xa9\x92\x03\xc0\xbc2\xb0\xea\xce\x9a\x04\xc0\xdf\xb8\x13J\xd5q\x05\xc0\x040\xa49\x8c\xa8\xfa?\xc5r\xe9\x0f\xe1\x9b\xc2?\xf6_\xe6\xdf\xc6\xf9\x9d\xbf\xdd$\x12@\xafB\xd4\xbf=j\xbc9\x13\x05\xf3\xbf\xc1\xe6\xfa\xaf\xc8\xb5\xb3\xbf\xc6\x1bM]^6\xc5?\xefx\xec\x9d\xf5|\xc4\xbfA\xc9\xa5-\x9d\xcf\xdc?{\xac\x99#L\x08\xe2\xbfJR\xfa\x02b\r\x01\xc0\x8a\xe4\x1b\xe1\xe4e\xfe\xbfg\xaf[\x15u\x06\xff\xbf\x7fS\xab\xd4ze\xdf\xbf\xbb\xe2\x17\x0c9\x92\xe4\xbfm\x8f\xa3\xb4\xb2\x0c\xbc\xbf\x18M\x82\x02\xa0-\xd6\xbf\xec\x1c\xd0f\xc7\x1e\xf4?\xd1\xf1{\xb1\x87\r\xec\xbf\xd0\x06>\xf4\xe8\xe8\xd5?\xae\xf3z\xc2D\x07\x00\xc0\xa9\x99\xbfvc\x9b\xd9?\x84\x17O\x92\xe2\xad\xdb?\'$\x15Fsx\xcd\xbf\x91\xfa\xd7\xe4\xe4\x8a\xe6?)\xc1N.X\x16\xea\xbfu\x91\n\xad\xccL\xe8?(F\xf3Q\x16\xbe\xea?\xaf}e(,/\xea? \xe2\xd0\x7f\xf6\xd0\xd1\xbf\xa3s\x80\x16D\xbd\xe3\xbf\xe2\xde\x12,\xac\xf0\xee?\x89\xaa\xb5\x1f*\x11\xec\xbf\xad\xc2\xde\xb6$$\xdb?\x98\x9d\x91P\xa1\xdc\x02\xc0\xcd1\xb3\nT|\xd9\xbf\x97GHO\x15\x92\xf3?< *J2N\xb4?\xdc7|\xea\\\x1c\xea?E\x13\x00\xee`.\xe0\xbfZo)\xe1\xa8Y\xde\xbf\xd8\xf6\xfb`\xf2\x81\xf5\xbf\xa0\xe8\x9c\xdd.\xd5\xf9\xbf\x88\x9a\xe7\xfe\x8fB\xec?\xecEw\xb9H\x1b\xf7?y 8:\xd3b\xf9\xbf\x040N\x97\x97"\xe5?h\x8f\x0e\xb1M\xc6\xf1?\xc7\xd1\x94\xc0\x1aL\xe1?{\x8bA\xbe\x17\x89\xef\xbf3\xb6\xf1\xef\x10-\xef?\xf7`mA\xf8/\x01@\xb4\xbd\x04\x18{+\x9d?\xa4W\x9c\xaf\xd3X\xf2\xbf\x13\xc5\xb1\xfbo\xba\xf6\xbf\x88\xa4\x96\xcb\x9c_\xe2\xbf\x9cu\rK\xa9$\xd1\xbf3p\x94\xe8\xdb\xa9\xf4\xbfP\xea\xa0\xfb\x86O\xc1\xbf\x9c_\xac\xe4+\xd9\xdb?9;\xe6\x0c\x89\x0f\xf1?A\x07\xd6*\xaf\xb6\xde\xbf;/\xd7\xb9IH\xf7\xbf\xfc\x04m\x91\x16\xa8\xfc\xbf\x16\xfae1K\xb6\xb5?\x1c\xe7^\x14aY\xef\xbf\xff\xebx\n\x9b\\\x00\xc0X\xe8"\xbf7K\xd0\xbfG&\xd7Oq\xb0\xf2\xbfM[\xd8\x9d\x03\x8c\xf2\xbfo%N:R2\xf3\xbf+\\\xec\xe4\x10\x87\xed\xbfau\rW4Z\xd1?\xbd<\r\x10\x92_\xc5?\xc1NQ\xb1\xda\xe2\xe7\xbf\xe4\xaa\x1bE\x95\xfe\xf5?7\x07F\x89\xa6\xd4\xdc\xbf\xb3\x10\xbf{E3\xee\xbf\xd4\x0c\x14\xea\xf5z\xf4\xbf\x10Z\x04^\x12\xbc\xeb\xbf\xb9\xa4{\x82\xf40\xf8\xbf\xfe\xd2\xe7dl\x92\xe7\xbfX\xd5\xed\xff\x16\xbc\x04\xc0\xe5\xe2\x00$}8\x05\xc0Y\xeb\xfe\x90\x1d\xca\xf4?\xd3\xb1o\xe9\xab\xee\xf4?n\xfa\x17\xec\xc5T\xdd\xbf$\xe5\n\x9c\xfe\xfd\xe1\xbfy\xaa~8\xe7R\xf9\xbfQ\xfe\x15\xe1\xe41\xd4\xbf\x82\x8d\x9e\xe6\xdb`\xf2\xbfB2\xaa\x91\xa5\xca\x01\xc0Y\xcb\x84\x9aif\xcd?{\x15l\xcb\xa4\xa6\xd7?\x8c\x90U!\xb9\xc6\xf3?\xde\x91{\xa9\xef\x1f\xb8\xbf\xcf{/\xb6\x11\xac\x06\xc0\xf3\xf5T\xaf\x06\x88\xd1?\xea."XW\xdf\xe5?\xf2\x1b\x81y;\xab\xe3?\x7f\x1c\xed,\x84\\\x02\xc0\x14\xd60x/\x92\xac?!\xa5\x9f\xa2\x9b\xcb\xb1\xbf\xb0\xeesd\xab\xd6\xf1?\x1f\xf5\xad\x9d\xfc\xc1\xe0\xbf\x12\x8e\x03\xbe\x17\x07\xdd\xbf\x9a>\x10\x92\xac\xc2\xd2\xbf\xbe\xf4d\xf0\xb9\x05\xe9\xbf\x1d\xfe\xa3\xf7\xfd\xdc\xe9\xbf\xc1\x0e/;\x9cl\n\xc0\x98:?\x82\xe8G\x15\xc0\xf7\x87\x16/j`\xfd\xbf\x87\\\xac\xb9\xde\xbd\xf6\xbf\x1bP:\xbd\x97=\x02\xc0w\xe5mB\xb6\xa1\xf2?m_\x03\x03\x05$\x94\xe5/\xd6?\xa0\xb4<\x9a\x10\x01\xd3?\xee:\xdf\xd3\x98\xb5\xf5\xbf\xa6W\xa6\xf9xn\xd0\xbf\xb2\x0f\xb6\x12<\xce\xf2\xbf\xd8\xd5\xb0\x9d<"\xf2\xbfq\x82Tc\x87\x1e\xff\xbfWn\xb13\x83\xf7\x06\xc0 \x1e\x14NS\xe5\x0c\xc0[\xc3\x8c\xda\x17\xe0\x05\xc0\x81g\xcc?\xa9\xba\x07\xc0F\x0cI\xf5\xe0\x99\xf1?\x1aQz8?!\xba?J\x1fyL\x0bA\xda\xbf\xe2\xbd\xa6|\x96\xfd\xfe?\x88\x94\xeb+\xbe\xea\xe1\xbfF\xef\x9em\xd5\xa0\xea?\x85\x06\x8eb.\x17\xe1?\x03\x11{Ql5\xff?\xce\x8e\xbeo\x80Z\xf5?\xb4\xba\xd4Z\x11\x97\xf1?\x8a\xbcB\x93m\xdc\xb0?/\xf5\x87\x13(\xca\xdc\xbfw\x1aW\xe9\x01\xdb\xdc?\xcb\x85\x9f\xc6\x97A\xdc?;&%\xe7\xa4\x7f\xd1\xbf\xfa\xf0Tf=\xec\xe0\xbf\xcd\xe6\x8b\xc8$T\xdf?k8\xef\x95\xc0\x87\xf2?\x18\xed\xbfc\xeaA\xd3?@1\xaa\xce\x11n\xfc\xbf\x12* f\xc3\x87\xf3\xbfP\x89wM\xda\xbd\xeb?Q\x07\xdc`\xe6\xf1\xac?(\x05\x7f&u\x9e\x94\xbf\xf9\xc5?\xa3\xd3\xcb\xc3`V\xf0\xbfww<\xbb\xaeO\xe4\xbfEi0\xa0\xcaz\xd0\xbfS(\xc9\xa6Q\xb7\x0c@w\xac\x17\x0c\xd0#\xf1?\xf7QEK\x9d\xf6\x01@\'O\x1f\x01\x11\xb2\xdc?\x1a\x82\x97\x13\xc1b\xfa?5\xff\xc7\x18\x9b\xe4\x04@\x01(\xaa<^\xa1\xe0\xbf<\x1e`\xea\xe1\xe2\xfc?Se\x1cA\x02\x1a\xf5?c\x10\x8f\x1f\x07o\xf0?\x99\x8c\x9d:\x0e6\xe4?\x7f\xdd\x86\x1c\xa1w\xe0\xbf\xbc\xd9\x84*k+\x03@\xca4"\xf2\xb6\x1c\xee?r\xd4xvH\xbf\xc6?\xa5\xda\xde\x91$\xed\xfc?\x12\x07;\xeaOa\xbd\xbf\xa36(\x8c\xe2V\xf1?\xc2\xd0`\xdd\xb1=\xf4\xbf\xf1XR%\xc7\xfb\xfc?\xadkq\x9a\xb8\xfb\xf6?\x85\xdd|Fx\xf0\xe7\xbfnI\x18\xc0Gq\xe6?\x86c&\xf6vo\xf0\xbf7\xa6\xb3\xbf\xd2\x86\xd3?L}\x9d\x8a\xd1\xba\xf0?\x9f\xde\xc3\xec\xaa\x95\xdc\xbf\x04\xf1\xe0Z\xa85\xca\xbf\x16\x89/\xdd\x82Q\xe4?q\xc0(\x8f\xc3x\xfe?\xa4\xe0N-\xd7\x9e\xf5?\xad\xebS\xefqk\xf1?~\xb4\xfc\x80v\xa5\xe7?\xffsNP\xcfi\x00@\xa0\x95\xc7\xd3\xc5\x1c\xfe?iI\x17\x8au\x9d\xc1?F\xd9\xe5 9\x9d\xf8?wrRf[\xfa\xc2\xbf\x1a\x9e\x84|\xfa\x7f\xe3?[uP\xe5\x90&\xdc?\x0e\xb4\xe9\xf0\x8d\xde\xce?W7\xa2Y$\xeb\xea?\xb4@\xee\x80\xceu\xe3?<\xe5}\x95\x07\xf3\xd7?p!\xfc\xb0\xe0\x91\x00@1M[\xf0\xa9\xbc\xf7?0\xe4\xedJY;\xfa\xbfT\x16w\xbf\xe2a\xe2?\x03\x14\xd2\xda\xbfA\x00@!Qn\x9e?$\xf3\xbf\x8e\x95}R;\xbc\xf4\xbf\xe3\xce\xa3\x8d03\xf9?\x8d"Z\xc99\xe6\xaf\xbfW\xbbrq`\xbb\xd8?j|\xaa\xd9uG\xfd?\x19\xe3\x11\x883u\xfb\xbf\xe2.Oz\xe5\xc3\xe4?\xde\xaa\x96\x80\xf2g\n@_\xdb\xe9|\xac\x00\xea?\x8a\xec\x83\xfba\xaa\x03@\x95\x191\x1cos\xed?\x8d6\xb1\xc3f\xc4\xf8?\xf3\x8d\xc0p\x94\n\xcc\xbf\xd4\xe2\x1a\xda\x7fd\xe6?\xc1d\xf5\x86\xfd\xdd\xe7?l\x04jbV\x1e\xc9?\xe1\xdd\x17\xba\x04\xf9\xa0?\xbd\xf8\xa4NN-\xfa?\xef\xa9\xf3\xf9M\'\x96?+\xdf\x86\x0f\x05\x0b\xca?a\xf6\xc9\xfa\xef\xfc\xd4?\xb9XG\xf1\x04\xbc\xe1?H\x949\x02N\xf0\xec\xbf,\n\xf6\xe0$\xa0\xbe\xbf\xc9\x0e\xf2\xae\x13q\xe7?\xdf\xf7Z\x96\xfa\xf5\xf4?\xb0\xfe{\xea\xe3\xa1\xed?\\[X*{\xca\xf3?\xcf\x04?|\x1eG\xf4?m\xf6\xb69\xff\xe0\xfa\xbf\x99MW\xd9\xc3\x89\xf9?\xf4\xd6p\xea\xa2\xf0\xdc?Cw\xee\xa4w\x82\x95\xbf\xcd\x92bZ\xfb\xf6\xbe?i\xdd\xca\xf7\xa5\xe1\xc5\xbf\x95}K\xf6P\x90\xe2\xbf\xad\xb6g\x94\xe9R\xf6?\xd1Z\x003&|\x04@x*qD=\xdf\xf1?\x12\xe2\xc7\xf6;\xf4\x06@\xc4)n\xe3x\xdb\x02@7,\xd5\xd5-\xe8\xfc??\x1e$\x9e\xc3\xf6\xfd?E4\xfc\xe1)\xbf\xf2\xbf\xcf\x06\xea\x86\x0f\xe0\xfd?}BI\xf9A\xc4\xf4?J\x12L\xaeh\xf5\xd4?0\xa7\xb8\xe6\xc3\x9b\xc7?\xa8\xdd<\x13^f\xfa?\xb6u\x02\x85\x94\xf6\xdf?\x15)2\x84}\xc6\x05\xc04\xba\xc6{\xb7\x8d\xfa?\xa0\xfaJ\xc7\x92\x9c\xe8?N\x7fN=\xa9\t\xf8?\xe0Y\x02\x01\x96k\xe9?\xb9\xfdIM]\x8d\xcc?\x18\xa1=c\x9f\x1a\t@a\xc1\x89Z\xd4\xfd\xebv\xf3\xbf{)\xc1\x86kA\xf4?\\\x99\xd6\'\xe7)\xf0?\xfd\xa5\x96\x1dUO\xe0?\x84\x12\x03\xd6x\xca\xe3?:\xe0\x11E\x15\xe1\xf8\xbf0.l\xc1R\xbd\xfc\xbf0\xeb\xca\x90\xd5\x1a\x01\xc0\xa19\x8d-\xab|\xed?\xe0"N\xb0\xb2\x0f\xdf\xbfE\xdfl\xf6\xeb\x83\xed\xbf\xac7\xd2u\t\x1c\xee\xbfVKR\x87uI\x87\xbf\x8f\x8bxju\xdf\xcb\xbf\xa5\xde\x13\xe8{7\xfb\xbf\x1aV\xd9c\xe7\xb5\xf4\xbf\xa2\x81\x98\xe6\xc6\xa2\xcf\xbf]S\xc9-\xa0\xef\xe6\xbf\xc0\xf1\xcay>0\x02\xc0B\x0fK\xbbMm\xea?\xd7\x87\xf8\xc3\xbf\xda\xf1?\xea\x18\x9b+\x8cD\xd2?[\xea%\xa7L\xba\xe6?\x97S\xf3FN\xc0\xef\xbf\xd2\x17\xa9\x7f\x1e\x88\xec?0U\xd1\x00\xde)\xe2\xbfO{\xbc\x8d\xbc\xc1\xc4?H\xe1}\x11\xdd\xe1\xef?<\xc2L8\x1f\x07\xf1\xbfGA\n#}\x8a\xf0\xbf\xaf\x87\xe7\xbefW\xd8\xbf\xb1\x0fnt\xac\x0b\xc1\xbfl\x88\x00Jb\xae\xea?\xe6u\xfb\x8eF\x0c\xd6?=z\xc1\xdb\xb2t\xfc\xbf\x1a\xf6G,1\x8b\xdd\xbf\x90\xf0k@\x83\x81\xe8?\xd7\x803A\xe0E\xe6\xbf\x91\xce\xba\x82\xf7A\xf2?\x94\xac\xa9\x10k\xcc\xe4\xbf\x9e\xd1\xee\x12WQ\xe9\xbfp{\xd3_N8\x02\xc0\x13\xcar\xf0\xc4\x99\xed\xbf\x96\xb5\xa4U\xd1\x1f\xd7?\xcb\x14z\xbb\xd5\x7f\xc4\xbf\xdc\xe4\xeb\xf6\x15\x82\xea\xbf\x813\xea\x02\xac\xfd\xd8\xbf\xf1(\xa3|\xc2\xd6\xea\xbf\x1c*y\x1a\xbaa\xf6\xbf\xdc\xa8\r\x92+\x15\xcb?\xc5\xb3\xea./l\xde\xbf\xf7\xda5\xa4Cq\x02\xc0\x16\xeb!\xc3\x1c\xbf\xf4\xbf\x0fc\xf6\xa9e\xf4\xe8\xbfe]\'\xe0uA\x02@\xee\x86$\x08O\xae\xf0\xbf\x9a31\xc1\x92d\xcd?\xb2r\x9c\xb9 \x01\xd8\xbfyWA\xdf[\x06\xf2?\xeb.\\y\xedf\xee\xbfp\x95\xbf\x04W\xa1\xd4?\x1d\x95}N\x0fO\xe8\xbf\x9ax\x89n\x10\x18\xc2?\t\xdb\xaf&1\xa6\xf8?\x8c\xb4\x9d\xf5,N\xf2\xbf\xc1L\xcd\xdb\x8fr\xde?\x1b\xa6\xa9\xfa\xdbn\xef\xbf\x07\xb9\xd6\x82v\xf1\xe3\xbf\xdeDp\xac(N\xc6\xbfY\xf8\xcf\xfeF\x85\x00\xc0\xc3\xf5C\x93\xd3J\xfa?\x91*\xe7\xe3\r\xf0\xa9\xbf/\xa3\x90\x02C\x97\xe6\xbfik\xe7\xe4\x8c\xdd\xf5\xbf\x9e\xc6s\x9b\xf5s\xfb?X\x1a\t\xc3\x9c.\xf3?\xbd\xb0E\xe3\xf2\xbb\xb0\xbf\x82|\xbe?W\xe6\xdb?\x1e\xaf\x88\x05\xad\xf2\xd9?\x8cn\xf3a9\x85\xa0\xbf:st\x18\xbbc\xd5\xbfo\x89\xd5y\xf6A\xf8\xbf\xaeqQ\x8ee3\xca\xbf\x9a\xbcM\xf3W\x90\xba?\xa7}B\xebm\x85\xd8\xbf\x0bW\xef\x9e\x94\x89\x02\xc04\x1f\x01H\xebj\xf9?\xa3\xb0\r1\x18i\xe9?\xdd\xf1\xa7\xae\xc5\xb2\xee?6T\x8b\xac@\x08\xd6\xbf\xef\xa0\xe4n\x0eR\xe6?V\x9dU\xc3\xa2\x94\xe6?F\x91\xc4`|x\xf3?\x0f$\x10\xac[\x8e\xe6\xbf\r\x8bVH\x93&\xf0?\xa5\x82orw\x97\xf8?\x15\xc4\xc3J,\x03\xf9?m\xd2\xb6\xdf\x1a:\xf5?\x8fONk\xbb \xfd\xbf\xa3GI\x18 \t\xd3?\xa9\xc3\x1c\xc0\x8a\x0c\xda?S\xaf\x8a!\xeeH\xf8?7q\x87=\xa3\xd8\xd9?NH\xb5n/N\xec?\x048z\x9e\x11g\xef\xbf$<\xb8\x96\xf8D\xf6?!\x9a\xa3\xc7K\x0c\xdd\xbf\xb9f\x88\x8f\x0e5\xb4\xbf\xccs\xc3\x8a4\xa8\x00@8\'\x92\xe4\x9d\xdc\xf4?dc\xe1\xab\xf0m\xf1?t&\x84\xb2 \x9f\xdc?N\x82\xb1l\xa2\xa9\xe7?\x9b\xa8#wC0\xd2\xbf\xa6\xf4]\x92\xaf\xc9\xb8?i\x9a\x8a\\\xe8\n\xbb\xbf\xec[\xc1*6\x0e\xa5?1h\x9a\x06\xa9\xbc\xbc?\xc2\xdb\x94\xe0KS\xb8\xbf\x7f\x94\xfc\xa5\xa7\x11\xe8\xbf\x8d\xb40M\x93\x9e\xe8\xbf\x05\xb1\xdd\xd18\xc3\xee?\x80\xfd\x9a\xe9\xbaf\xef\xbf*\xc6k\xf2\xc9\xca\xda\xbf\xaf\xf63"\xa5?\xe5\xbf1\xfb>\xe4\x16\xc4\xc6\xbf\x84wszb\\\xe5\xbf\xad\xaf\x9b\xa1\xacn\xf1?\xc08\xbfF\x12\xd7\xf3\xbf8jl\x8e:*\xe8?\x0e\xb6\x99!\xea\xad\xe2\xbf\xcd\x8f7B\xfdl\xff?\\\xab\xee\x10\xf9\n\xcb\xbfW^\x9b\xb4\x9e\xa7\xf7\xbf\x85\x90d\xcb\x03\xc5\xfc\xbf\xe1\x1d\x04\x1b+\xb4\xe9?\xd8V\xfazZ\x00\xf5\xbf\x91\x11N\x89?\x0c\xec\xbfH\x8cM/Q@\xfd\xbf\xc2\x1cF\xac\x17\xfe\xa0?\xe2\xb0;*S\xfa\xe3\xbf\x08\x84?\x9e\xf3v\xd6\xbf,P\xcedy\xf1\x03@\x18\x10\x81\xce\x14\x8b\xe5\xbf\xfa\xad4\x96\\\x1a\x01\xc0{\x1dh\x15\x12,\xe8?\x0e\xf0i7\x83\xe2\xd0\xbf\x98\xe9a}\xcf\xdc\xe2\xbf\xec\xfbj\xe7\x93/\xca\xbf\xf0r\xa0\x8a\xe1\xb5\xf1?\xd7\xa4\xdb\x85h\x8e\xf1\xbf\xd6\xaf\x0e\\+9\xff?JD\x81B\xf9\xd1\xfb?.\xe4\x91\x17\xbau\xd3?\xc1\x0c\x99\x0e\x8d:\xe7?&\xa4\x15\x05\x87f\xa1\xbf@\xb1[NG_\xc1\xbfc4\x14\x13\xb8%\xde\xbfJMc\xff\x9e\xdc\xf7?\xda1\x9ag\xdd8\xe5\xbf\x89\xd6O\xfb*\x95\xf2?\xfa\x8f\x83\'a\xae\xdf\xbf^\x9f\nu\x84`\xee\xbf,\xf9\x83\x15\x03d\xe7?l\x02o\x89\xc2y\xd9?\xb3\t\xe7\xa7\x8e\x95\xd3\xbf\x9d\x13\xb0\xe0\xa0]\xed?\x7fou1\x0c\x03\xf7?8\xc5\x88T\xc2Z\xf2\xbfqGr\xb1\xa4\xe1\xa0\xbfm\xa9\xfd\x04\x85&\xd4\xbf^\x08\x94\\\x92,\xe1?)g\xc5\xc5\x13\x99\xd2\xbf8\x98K\x88\xd3\xa9\xe4\xbfg\xd3\xa6FV\xc5\xe0?\x9cA\x1b\xec\xc0\xa7\xd2\xbf4l:\xbdk\x97\xd2\xbf\x1c\x84<\x05W\x0b\xd9\xbf\x1f\xe8\xcee\xdcq\xf7\xbf\xb7\xb9h\x85\x9c\x87\xc7\xbf \x92\xa2\xd9\xff&\x9c?\xee\x04TL\xc6\'\xd1\xbf%\x88\xc0\x1a\xc3\x86\xf1?D\xfa\np\x95G\xe9?\xc0\x82\xa4\xb4\xec\xf8\xec\xbf%\x08\xce\xd3\x1e \xe1?;W\x004\xd9\xf2\x00\xc0\xd2<\x86\xbf\xf01\xdf?\xbc\xa80O1J\xea?b,\xd6\xc1,,\xe7\xbf\x94\x0fQJ\x8b\x9d\xee\xbfA\xf1\xe6\xbb4_\xe9?\xce\xf1\xd9*h\xa2\xd1\xbf4\xf2\x8bP\xc7T\xff\xbf\x96\xa2T\xca\r\x86\xe1?<\xb49$@\xee\xf0\xbf\xbe\xdc\x96\xbd\xban\xf4?\x87\xda\xed\xdf\x9d\xd1\xed\xbf~\x17\xbf\xae\xb4\x82\xf4\xbf\xc4*K\xd5Y\'\xc0\xbf\x85A/\xd1\x9f\x89\xd5\xbf\xcb^\xd3\xa3u2\xe3\xbf\xa3=`\xe4\xef#\xe7\xbf\x85i\xd0\xda`\xe4\xc1?\x1d\xed\xf8I\xff\xe9\xe1?\xcc\xeb>\xe9\xfaO\xf0\xbfh!T8~\xdd\xf2\xbf*\xfcL\xe6\xf6\xc7\xf7\xbf\xbe\x01\x7fc\xee\xf8\xe0?\xa3\xa4\x0cA\xd7q\xeb?a)\xeb\xf5\xab\x91\xe0\xbf\x89V\xcdi\x05]\xdd\xbf\xb9v\xa3V\x16\x1b\xf2\xbf\xe4\x9b\xcco\x80\x9b\xd7?\x17_\xe6\x06_\xa4\xe3\xbf&R\xbf\xfes\x9f\xaf\xbf\xe0$\xbf\x9b\xb6\x7f\xf0\xbf\x05\x04\xbe>=\x8a\xf9?\xeb^S\xe2L\xfc\xbb\xbf\xcb\xe9\x19f$*\xeb?\xb2\x10\x10L8k\xe2?\x17\xb7;\xa4\xa7c\xe4\xbf,\x0e\x99\x13\xa5/\xfa\xbf\xef7\xdc\xd7\xa4\x8a\xda?\xfd|\xba\xc5:\x17\x01\xc0`C\xf5\x03\xea\xb5\xed\xbf\x1b\xeah\xad\xea\xff\xd5\xbf.\x9a7\xd3\x86\xb0\xe9?)\xad8D\x11\x8c\xcb\xbf\xeb_\xe8G\xf1\xcd\xfd?2j\x89)\xb3+\xdf?\x8b\xc2o\xbe\xdf\xaa\xe9?\x14\xe4y1\x1a/\xf5?\x9b\x9e\xa4\x9b\xad \x01\xc0\xb2\x13\xbf\x88nG\xdc\xbf\xa1{\xf07\xb7\xf2\xe9\xbf\xed\x95X\x1c \xc5\xcd?\xbc\x81\xe3\x88h\xdb\xe0?\xcd\xad`\xe7\x7f\x0f\xcd?/\x14\xd3\xfe\xbf;\xca?\xc5\xb3\xb4.\x11\xff\xdf?\x10\xf8\xbd\x13\x9f\x8b\xfe\xbf\x13\x12}\xf5\x16\xb6\xec\xbfz\xdc>J?\xd9\xc1?\xc0\xa0\rt\xe7I\xb2?2Y\xe5\x00\x0f\x05\xbc\xbf\xc3@\xb6\xb2\xe9\xc3\xf2\xbf_\x0e_>r\xeb\xf6\xbfJ\xb6GD\xdb+\xda\xbf\xec\xcc\x8f\xce\xda\xe7\xd0?\x17\x06!d\xc6Y\xf2?\x81\xbf\xa0P\xb1\x8e\xf4\xbf\xc7\xec\xbe\xc4zZ\xe1?Z\xd4\x86\xb94\xaf\xc7?\xdfrZ>i\xec\xd0\xbf\x03\xb0\xcb+\x8d\xee\xc7?\xad\x87\xcfp\xe9?-9\x82\x9f4\xbb\xda\xbf\x17(\xd6+\x9eE\xcd\xbf\xcb\xa6\xbep\xd6\xbb\xd6?\xb7\x86\x9d\x05\xb7\x85\xc9?\x1cT\x17\xed\xab\xac\xc7\xbf\x83\xa8\x91\xf9\xe2\x1b\xd3?l\x8a\x18\xcb\xc3\xea\xf3?1\x025$\xf3w\xf9?\x04\x94x~\xce\xf2\xe0?\x17\xfa^\xad\xbf\xfb\xd8?\xc4\xe3)\xb1\x87\xc7\xf0\xbf\xd5)\x0b\xe3U7\xe5?\x99/\xe2\xf0\xa4\x8b\xd6?zA\xd4\xd8\xbd=\xf8?\x14\xfd-J}\xcd\xf5\xbfvE\x06\xdeF\xd4\xd7\xbft\xe5\xda\xb7\x04\x89\xf0\xbf\xed\x08\xbc"\xcd\xee\xf1\xbf\xed\x0c\xf8\x836\xb5\xf1\xbf+35\xae\xbb\xd6\xc2\xbf\xcd\xc72\xfa\x1f\xd5\xf7\xbf\xc0\x00\x0f\xddA\xe8\xfa?,\x9c};<\xe8\xf3\xbf\x92\xcb\x02f><\xd0\xbf\xb6P\xfd}Q*\xd9\xbf\x01\xa6\x86c\xc3 \xea\xbfv\xaa\x13\xf5\xb2\xab\xe8?\x9f\xd0\xb5\r\x82\x99\xd1?\x1cTkV\x96j\xe7\xbf\xf47\xc0\xb1\xbb \x05@\xbfN\xd8\x8a\x9fZ\xee?\xe4\xbb\x14\x1b\'\'\xe7\xbf\x8fT\x85>\x97u\xc2?!\xd6\xf01|V\xed?\xd2\xfa\xb5\xfb\xcax\xe7\xbf\x1c\x08VB\xf7\xab\xf1\xbf\xdf\xd9?}\xf9C\xd8\xbf\xb2\x03\xe5*\xdeP\xf2?\xa8\xcd\xae\xb3\x87\xa5\xee\xbf;\xca0\x0e\x07\xf1\xf4\xbf\xa9\xafn,$\xce\xf2\xbfp\xfa\x1e\x14N\x1e\xe2?\x98\xd4\xd9\xb0\xbdd\xd1\xbfg\xe5\xf64\x91A\xce\xbf\xc7kLsZ\xc1\xf5\xbf\xf5\x8d\xfc~\xf9:\xab\xbfx\xeb\x13\x15\xc6\xda\xb8\xbf8#\x01)H\xe8\xdb\xbf\n\xa4B\xd6\x19\x10\xf4?C\xee\xe0v\x93\x83\xea\xbf\xe4\xb9\xf1\x9c4\x10\xf4?\xf1W\xa0\xf7Q\x8e\xf8?\xeb\xb8\x03-\x88]\xf6?,\xf3\x13\xea\xdc\xd2\xe0?\x8a\xc3z\xd6\xcby\xff\xbf\x8a\x95\x81\xd0\xf8v\xca??\xfa\x05\x10\xb5/\xe0?\x7f\xe8E\x17\x1a\xd2\xb0?\xd3\xa4 \x0b\xbaa\xed?\xea\xdc\xfeEXW\xfa?\xc8\x1c\xf1\xbf\xb3\xeb\xd6\xbf\x87\x90cwg\xf3\xf6\xbf\x18wZ\xeb\xde\xdb\xf8\xbf7J\xf0\x13\x9c}\xdc\xbf3\x97\xab\xb6\x1eG\x93\xbf\xac\xebm\xfd0q\xe7?-\xb8\x0bv\xb2\x87\xf1?\x07\xab!\xe1"\xdb\xec\xbf\xe7\xa5-f\x9d\x12\xcd\xbf/a\x87B\xfa\xe4\xef?\xf2\xbf\x95\x8f\x08\xf5\xf1?\xa0Of\x07p\x92\x90?\x06!\xfdf\xef\x91\xff\xbf\x86\xa5\x14\x96\tV\xef\xbf F\x1b/\x17\x1e\xe8\xbf\x14\xaa)G4>\xc9?\x14\x8e\x15\xde \xa6\xc4?{\xec3M\xaf\xf7\xe7\xbf\xeb\xcf4\xb1\xf5?\xe3?O\xf7\x13\xae\xd4\xe8\xcc\xbf\x89\xd3~\xe7\xfa\t\xbe?\xaa\xa0\xcb0\n\xcb\x00\xc0N\x11\xaf\xb1G\x88\xfa\xbfyZy;\x0c\xee\xbb\xbf\xcc.\xd3{\xf2\xcc\xfa\xbf\x7f\x83*\xc8\xde\xa8\xdf\xbfUZ\x0cG\xca \n\xc0\x92T0Xz\xdc\xef\xbf(\xed\x1d\xcd3\xdc\x04\xc0\xb9\xda\xd7\x89\x98\xf4\xfa\xbf\xa5\xb19?\xe1\xb6\x84\xbf\x18M\xa1\x1a\xd3\xc4\xfa\xbf\xfb\xe0\xaf\x89u\xf9\xf2?F\x03Z\xc2w\x82\xdf\xbfg\xecb\x1dw}\xe5\xbfS\xa6\xc0m\xda\xbf\xe2\xbf"N\x17d\xaa\x97\xc6?M1\xfe\xca6j\xe7?jNT,\x962\xe1\xbfN-\xefQ\x9d\xf0\xdc\xbf\xea\x81\x9d`a\xac\xf6\xbf\x04S\xb9m\x12\x10\xfb\xbfn4\xa6\x82D\xd8\xfd\xbf\xd2z\xa19\x1e\xce\xee?\xf2,\xe1X\xca\xf8\xe1\xbf\xa4\x07\x9f\x8f\xd3t\xe0?+\x82\xc4\x8c\x96=\xf2?\x90^\xe8\xefS\xcb\xf6?\xde?t\xff\x1f\xbb\xca\xbf\x06X\xfe\xe8\x12\t\xf6\xbfG\x99\x95Z\xa7\xa3\xb8\xbf\xad\x82\xd4\x84\xa96\xf2?\x9b\xec\xf1\xa5\x1aj\xf4\xbf\xc8\x9bL\x00\xce\x82\xf0\xbf\xf6\xackW\'/\x05\xc0\x10\xe6\xc7g\x15\x92\x01\xc0\x9e\xfb\xfd \xbd\x0b\xea\xbf\xb7\x1aT\xbaM}\xf1\xbfy@\xd5\xe9\x11\xf2\xd9\xbfAW\xc6\xf4[\x06\xc9\xbf*\xe3\x12#\x1a^\xe8?\xc5fp\x10\xc7\x1f\xea\xbf\x19wIdKy\xe6\xbf]\x0c#-oM\xf1\xbf\x18\xc9M\x85\xfb|\xf8?\xc4\x8b\xa7\x98d\xf5\xec?+\xf1\x1f\xec\x1bm\xf6\xbfv\xe2\xd9<\tc\xef\xbfR\x10E\xb4\xa7\x07\xff\xbf@\xee\xf5\x14\xadW\xc0\xbf\xcf\n\xf72\x1b\xa1\xfe\xbf\xdf-~\xf8\xe7\xcb\xe9?\x02_\r\x85\xa9J\xa9\xbf*\xcf\x04\x17\xc0]\xf6?\x17\xa7\xb8\xd5\x82\xd6\xb0\xbf\xf1\x10i\xdf\xf8\xf2\xe2?\xb7\xf2@\xca\xf7\xc3\xff\xbf\xdbj\xd4`\x15\x1a\xa0?qX\xf0I\xfe\xdd\xfd?\xcf\x81\xc2.d?\xe6?\xd6R\x85\xe8\x9f\xcf\xbd\xbf\xd2\nA\xcf\xb1z\xfd\xbf\xeb\x1c\xa3\x86\xdd\xb8\xf5\xbf\x1a\xf0X5\x05A\xf1\xbfb |\xe7nl\xe6?\xe6f+q\xb3h\xe6?\'\x93\xa97^\x12\xd3\xbffY`xK\x18\xf0?!C\x12\x84k\x97\xc5?Tr|\xb3\x97\x8b\xd4\xbf\x0f7\r2\xba\x00\xd9\xbf\x18\xe9R\x01r\x1c\xe3?\xd1\x04\x17\xef\xe3\n\x03\xc0(5\x1b1\xba\xa2\xdb\xbf@tm=%\x84\x03\xc0\xff\x97t0E \x08\xc09\'&7\x8f\xea\x04\xc0$\xd2{fz\x1a\xeb?\xca4\xc6W\t\xa3\xe7?\xac\xd3!3t\xfc\xff?\xf3\xb30\x038\xf7\xe0?\xc5s\xa7KC<\xe8\xbf\x13\x90\x83\xe9\xe3\xe1\xe9\xbf\x92\xf1\x19\x80\xe5W\xf4?$\x1a\x18\xcc\xef\x9d\xdd?\xaaG\x86{]\x90\x0b@\xb1\x89\x95-k6\xe2\xbf\xa0\xc7\xeca\x95O\xdf?&\xd4\xd9T\xb5\xb2\x00\xc0\xe7\xfcKv\xd5\x94\xf2\xbf2\xb0a?8\xef\xc6\xbf\xd4+\x9f\x08\xd8\xb7\xd2?\x0bf$b\xb5;\xd9?+\xafK\x9a\xbek\xda\xbf\xd4$R\x7fb\xcb\xf0\xbf\xf7,\x88\x1d\xc3\x12\x03\xc0k\x80*j\xc0\x97\xf6?\xe0%%\xb8\xaf\x14\xf0?\xd8#\x02/\x96\xd2\xe6?\xd0\x96\xfca\xeef\xc8\xbf\xc60\xc4\xc3lw\xe2\xbf\xdd\xe4\xeb^ &\xf0\xbfv\xa4".\xca4\xf1?=\x877D\x883\xf2?bS\x1b|dn\xf7?a\xa0\xf3\xf0\x114\x02@\xfds\xd6\xe0\x81\xd5\x01@Et\xa6U\xeex\xe8?+\x0c\xabO\\@\x04@\x9c\x9d\xe9\xa5\xab5\xe6?F\x95\xf6?\x1bg\xee\xbf\xe8\x07\x19\x92\xe3H\xf3\xbf\xda\xa4\x9d$\xa6\xb7\x00@\x83\xc2\x04\xf81i\xc6\xbf\xbd\xd5\x06\xd0d\xd0\xc5?\xae\x85\x90E\xb8v\xda?\xb1\x85\xd1\xaa^U\xe3?2\'f{\x12\x1e\xf1\xbf\xcfX\xffu\x10+\xdf?YS\x96*c\xaa\xe1?\xbe\xd3\x1e\x08~\x1f\xe1?\xec`Y\xecj\x1b\xd7?\xbb\xa3\x9fM\xdc\x9e\xec?`\xf9\x06\xf5\xeeT\xf3?\xf3\xdf\xbf\x01\xc6\xf4\xbb?\x7f$ \xcb\xbb<\xe5?\x97\xf9\x93\x8f\xa7w\xe8\xbf\xf0n\x9a9\xb5H\xf9?\x9b\xad@\xd3\xc0\x10\x00\xc0\x15U\xaf\x8c\x99\xf8\xf3\xbf\xa2\\\xff\x9e\x8a\x97\xec\xbf\xfd?l\xf44\x1a\xa3\x9d\xe2?\xd8\x84t\xfb\xdf\xd0\xeb\xbf\xe6\x9fY\x8d<\'\x00@\x89dj\xb6%\x16\xe0?\xf3]<\xa6\x85\x08\xe2\xbf\x03SL\xa0_\xc1\xd6\xbf!l DG\\\xb1?iH>f1\x00\xb9?M\xf9\xc5\x93>\xbb\xd1\xbfL2\'\xc0\x89\xd8\xd5\xbf\xe0\xad\xdfd\x9c\x13\xe5\xbf\xad\xdfE\x85\xa4\x08\xed\xbfX\x8b\xf1w\xdbd\xf4?l$\x13\xf4\x15\xe3\xc1?\x86\x7f\xa0:\xb7\x8d\xed\xbf\x11\xd2\x88\xa1\xe4C\xe4\xbf\x05\xb8\x04t\x8f\x81\xf1?\x88x4\x0cA\xec\xe0\xbf,7\xf7\xd2\x11\xc4\xe7\xbf_0eV\xd1K\xdd\xbfY9\xd1[\xa4\xf9\xd0?OXj\xfe\xff\x1e\xd5\xbf3\xbce\xa6\x89\xc8\xea\xbf\xe1\xe5\xb7\xa9b\x14\xc2\xbf\xc4\x01\xb2\xb1\x86\xef\xf0?ew:\x7f>w\xea?\xe3\xa2\xe8-\x06\xe1\xc8?\xc00\x06\xdcft\x85?\xc0\x1c,\xb0\xba\x19\xfc?\'\xe2\x17G~\x89\xfc?\xdcX9\x0f\x8a\t\xe0?J\x97\x8a=\x04\xfc\x9a?\x1d\x91\xa1\x0cq\xa9\x97\xbf_\xe5\x7f\x83G+\xc8\xbf\xed*\x07\xab\t\xd6\xd3?\xc4\x96%J\xfd\x8a\xdb?\x88\x91\x122\xba*\xe6?\xe4\xe6\xe9\x06&D\xf3\xbf\xb1\xf6 \xc9\xde\xab\xdd\xbf\x8awt>\xff\xdc\xd5\xbf\xdf<\xa7\x0c\x8b\xe0\xf3\xbf$\xcd\xf3/\xbe\xc8\xf5?\xba\x8d\x1b\xbc\xff{\xf9?)\xcb\\\xf8\xeb%\xfa?\xdbh\xa3\xe7\x1b\x85\xe5?a+Y/\xe7\x93\x01\xc0e\xf4+kR\xcc\xf0?\xb8\x86s\xda\xfe\x16\xf4\xbf\xbd\xd5;;\xe2\x8a\xee\xbf!\xb5k\xa3F`\xb5\xbf\x12\xf1|\x9c&\x18\xe5?*!\xb6\xfa\xed\x9d\xdd\xbf\xac\xed\xf0\xc8NH\xe5\xbf\xd6F0\x8a\x08C\xef\xbfp\xce\xb1c\x04\x17\xf4\xbf\xfb\xfc\xfd\xe6E\x99\xf5?\xd8\x82\xecV\x16I\xed\xbf1>\xacH\x96\xa0\xf0?\xdf[\xac\xaf\xba\xb5\xd8?\x05\x1c\xbd\xa4\xd0\xba\xe4?\xfad8;\x04\xc2\xf2?\xa8\x97\xef\xf3\xd6\x07\x90?\x00R\xa9r=\xc5\xe8\xbf \x84\xa2\xfd\xe8\xf2\xcc\xbf\xaaRR\xd0\xc1\xfc\xcd?\xcd\x1a\xbf\xd4$\xa7\xd3?*\xfdq\x15\xe0\x10\xfd\xbf\xce\xbc\xca(7;\xde?KQF\xfcB\xb0\xf7?z\xeb\xd3\xcd\x7fm\xe7?zL\xf89\xfb\x82\xa6?\n\xe7\xddW\x93n\xc4\xbfl<\x82\xd2l\x97\xda?@&\x00\xd2S\xf5\xd4?+\x01\x11\x13\xa8\xe2\xe2\xbf\xbf\xc2\x80\xe9(\xee\xdb\xbf \xd1??G!\xe11\x8e\xf2\xbf\xacZl\x82\\\n\xf6?\xac/\xfc\x99\xe0\xe5\x01@\x1bt\xe6\n\xf3\x90\xf2?Q\xf0KL\xe6\xe3\xd0\xbf\x85\x00\xe9\x1e(A\xfc\xbf\xfd@d\xa7R6\xe2?\x81i\xecuA\xc5\xfb\xbf"\x86+9q\xbc\xe6\xbf*\xf8\x8eq4\xea\xe6\xbf\xc0;\xfa\x8a\x91\xc2\xe9?\xb2\x91\xf9\xf2\xf9W\xf1\xbf\xddR\x12\xa2\xa9E\xd9\xbf=\xb3\x8c\x168\x05\xd1?\x933!$\xba\x08\xf7?]\x84\xe3\xa64\x17\x92?i6\xb2\x94\xf9\x1e\xd2\xbf\x0b\xbb9-\xa6\xbd\xf3?\xafB\xec\t\x92\xe2\xd5\xbf\xa3\xde\x13M\xf6W\xc0\xbf1\xfan\xb9\xe9D\xf0\xbf\xff\\x\xab\x14\xc0\xc4\xbf\x1c\x07p\x07\x8d1\xeb\xbfL\x14\xd5~\xe1\x88\xd0\xbf\xb7"\x13\xef:\xa4\xdb?\xf8\xef\xfd\xef\xf5s\xf9?\x87\xd7\xae\xe2\xedG\xb3\xbf6\xc4\'9\x14\xac\xe1\xbf\x14\ttDv\xcc\xf1\xbf\x0b.\xe4,\xbd@\xf5?K\x97\xeacO\xcb\xaf?o\xda\x8f\xee\xe1\xb0\xea?\xae\xd4\x08\x00\xab\xe0\xf0?\x97f\'T}\xc0\xe9?\x10m)!\xdd\xcf\xed\xbf\x7fZs\x1f\xf1\x06\xc8?\xee\x15K\x99IC\xd0?\xa3\xcb4\xcb\'\xfb\xf2\xbfO\xae\xba\x1f\xcf0\xf1\xbf\x13y\xbb.p\xb2\xd6?\x891\xd0U\xc0\xc8\x00@\xd9B\x98\x90\xb2\x1b\xf1?\xe5\xc6\xc5z\xdd\t\x01@\xab\xe9\x01b\xac\x16\xf5?yO\'\x96C#\xb6?(0\xb9\x89`\xde\xed?\xdc\x90\xea\xcc\xf9\x8c\xc4\xbf2\xc2\r9\xbbI\xda?~\x15\x00\xa2,\x14\xd9?\xd0\xcb\xbd\x1c\xf3p\xd0?\xc5\xa1z\n\xe7F\xdc?\xe6\x1d\x1a!A\x0b\xaa\xbf\xce\xed\xdf\x8e(\xb9\xe9?\x02\xb2q5\x02l\xf7\xbf>\xa3\x0e\xb2ue\xa4\xbf\x1e\xea/\xd5\xf2\xa7\xe6?\xb4\x07n\xea\xf9\xb6\xf5\xbfhd5{\xa3%\xe4\xbfh|Q\xe81\xc3\xcc?W\x93\xef!\xc2\xdc\xee?n\x86S/\xfa\x05\xe3\xbf\x15G$\x07s9\x00\xc0\x990\xdc\x10\x1e\'\xe9\xbf\x9a..\xd6h\xac\xe6\xbf\xaf\x87\xb2\xec\xe3\x1b\xeb\xbf\xb6OQ\nU\xd7\xe4\xbfO\xc4\xd7~\xa2\x98\xeb\xbf\xd4\xe9\x16!\x93\xe1\xcd\xbf\x0c\x1f\xccU\rx\xfa\xbf\xca\xc4\xb52\xab\x1e\xf0?\xa9\xe8\x9aUl\xa3\xe8\xbf\xa9\x85\xa8\x0c\x07O\x00@!\xa8\xdc\xe9_w\x00@}\xdep\xd1\x8e\xb5\xd9\xbf\xa5\x80,\xe2\xb9\xd1\xed?kE\xf7\xe4/\xe8\xe3?~b\xe2\x86[\xe2\xc4?\xb7(p<${\xf2?\xfcg\xfaS\x19\x87\xd9\xbf\xd7^\xd5\x83\x00\x82\xd8?\xe9Y@\xdf\xea\x93\xe1?*\xa9\xee\xdd\x02\x85\xf8\xbf\xda\x9eD,\xf4\x1b\xf2?\x0b)\xc3\xfc?\xfa\xe7\xbf\x85\xed\x84M\x03\xc5\xda\xbf$\x9a\xcd\xc7\xd5\xd9\x92\xbfb\xde\xfe\x180G\xaf\xbf2\xb7r\xf8j#\xc4\xbf\t\x9e\xea\xf7\xb1\xfe\xf2?\x0c\x11j[\xe0V\xb6?\xfb\xd5\xcb\x12\xe2h\xf9\xbfW1\xef\x92\x86a\xfa\xbf\xa3&y&\xf9\xb0\xf3\xbf\xef\xe7\xe9\xf4E\xee\xdb\xbf\xfc\xa8R2\xcd\xcc\xb3?\x9a\x97Xo\xb7\x96\xe0\xbf\xfd\xe5\xb4\xda\xf9\x94o\xbf\xf6\xbf\xe41\xd9\x85\xe2\xbf\xd8V\xdd8\xdf\x83\x9f\xbfj,c\xc6\xa0\xc6\xe5\xbf\x8f\xde\xeab\xdc\xef\xc9\xbf\x8c~\x1a-\xee\x08\xc3\xbfU\xdc\\[b\x91\xdb?~\x186\xb3\xab1\xed?!\xd9o\x14@\xa7\xf4\xbf\xf1Gk\tF\xb8\xd4?\xc3\xae\xf7_\x0c\n\xed?\x04M\xf3\xdd\x8f \xb8\xbff\xd1\n{v\x1c\xf9\xbf{*\xe8x!\xac\xf7\xbfM\xa4\xa5tI\xd4\xf4\xbf\x08\x16\x1c!\xd5\xd1\xf1?\x84K\x85Ml\xfd\x9f\xbf\xadi\xa4\xc9$A\xd7?\xd6\xebL\xd1\xb4\xba\xe9?yr=\n\x14\x91\xfa\xbf9\xa6\x03\x99\x8b9\xed?\x87p\x0f\xa8G\xee\xd7\xbf\xee \xaeU\xefG\xe9?\xe6\xa0!\xe5\x12\x9e\xcd\xbfX\xc2\xc6\xee\xfb \xd7?\x97\xd5y_i\x08\xcc\xbf\xa7OJl\xce\xf8\xf6\xbf\xa1\x02^\x0e\xed\x8e\xf6\xbf\x0f\xc3\xf3B\xe2\x04\xf3\xbf\x861\x13\xf9/c\xf1\xbf?_\xa3\xdc7.\xf9\xbf\xd8\xc4e-\xe4\x8d\xe1\xbf\x80e\xc4\x05\x0f\x8d\xe2\xbf\xe0\x8e\x9d\xe7\xffx\xe6\xbf\x9d\x82\xc5\xfe\xd8"\xcf?\x8dG\x06\x82\xea\xeb\xc9?A\xf7\x0e\xe8-\xa5\xf3?\x87Y\x94\x0b\xc0K\xa3\xbf\xa9\x19h2\t[\xdf?_\xe4<~\xc2I\xa8?\xcf\n\x13%\xeef\xe6?Z~\xe0\xd6\xcfB\xe9?\xab-\x8f\x91\x94\x19\x03@\xb7\x9f\xd1K\x90\xd6\xd5\xbfW\x00y\x8a\x01\x91\xc3?\xc7\'-N\x01\x82\xce\xbf\xdf3\xde\x1b|\xf9\xcf?\xb9\xa6\xe4h\x0b$\xf2\xbf\xa1ut\xc6\x0f!\xf1\xbf=\xbf\x8aE\x00z\xf9?\xbf\xcf\x95\xa1\xf7\xb3\xf3\xbfb\x0c\x1aw\x98g\xe2?\x87\xf2%\x88\x86\x0e\xed\xbf\xde\x01\x10r\x04\x1d\xee?\xce\\\x97t\xab[\xd8\xbf.)\x93\xaf>\x9e\xb6\xbf\xb32\x15\xac\x02y\xfc\r\xe5\xe9?\xa0&\x95\xfd\xcb\x93\xa6? \x8e\x97\xd7/B\xa6\xbf\x8cAr\xbfb\x13\xeb\xbf\xb2\xb4\xca\x85\xdc\x13\xd0\xbfJ\x02~)~\xfa\xf1\xbf\xa62\x8c\xb7\x9c\xdf\xda\xbf]\xb1\x13n\xd9;\xc9?NT\x81o\xa2\xcc\xfa\xbf\xb7\xb6|\x87\xf0\x1c\xe3?\x1d\x19\xf9\x8cQ\x07\xd3\xbf:\xc8\xfb\x96W\xe6\xf0?\xb0\xaf\x0c\x9f\xba\xc5\xca\xbf\xae\xef\xc6G\x02\x83\xe2\xbf\x92h(\xc2\xffB\xb2?\x1bo\xc4\x8ed9\xfb\xbf\x8eg\xa7C0k\xc0\xbfo\x16^\x10\xa8u\xf4?\xe2\xe1[}\xb8k\xf8\xbf\x14\xd0\x9c\xa4\x13k\xc8?\xa3piM&\xd2\xf2\xbf\x1d\xe5\xc8\xf9:\x1f^\xbf\xa5\xd5\xe8;bx\xf5\xbf4\xa1X\x99@\xe4\xe8?\xc4\xe83)\x84\r\x99?\x17\x86\xf7i\xb2p\xd4\xbf.\x0b\xe2\r\x9c\xf1\xf7\xbf\xf7\xdf\xe1\xac\xf0~\xfe\xbf\x10\xd7\xb6\x9e\xe8\xda\xeb\xbf\xc8\x85\xeb]\xbc\x87\xca\xbfe\xe9C\xb9T\xcb\xe6\xbf\x83\xfc\xafR!-\xe2?\x16T\xd9\xcc\x9a\xcd\xef\xbf\xf4\xcd\x86\x18\x03\x9a\xe0\xbf\xad\xeck}\xa8\xd8\xd5\xbf\x95T\x94K\nc\xf0?0\xd2Tw\x02\xdd?(zun\x95Y\xdb?\xb0\xf2T5-,\xe6\xbf\xd1\xf0\xb1\x15\xef\xde\xe2?U\x13~Zo\x05\xa4?\x12\xc3\x0f\xb5\xfc4\xf1?Y\xcd\x07rr\x86\xc3?\xee\x00C\x8a\x04\xb2\xef\xbf\xde9\x7f(\xed\x12\xce\xbf\xfeZ\xb8\xd7\x0cO\xe8\xbf\xaf#\x0f\n\x0c\x7f\xef?X\xd0\xdf,WQ\xe7\xbfgf\xc5t\xc0c\xe9?\x9c\x9d\xe2L\x1a/\xf8?\x1f\xf0\x00;Q\x1e\x00\xc0\xa8\x1e\xda\xfa\x11\xe4\xe9\xbf\x05\x90\x8a\xceU\xb3\xde\xbfY\xbdF\xc6\xc1\x82\xb3?+q_1\x02B\xca?y\xa0d\xde\x82\xda\xf0\xbfxsx\x94\x94\xeb\xe9\xbf\x07\xe3\x82=\xcdA\xe5\xbfC\xbaU\xa2\x03a\xf4\xbf U\x8b\x92\xaf\xb6\xec\xbf\xa7\x1e\x12<\x94\x8a\xf2\xbf\x0fP!\r\x0f5\xd5\xbf!_\xe4B\xdcH\xd6\xbf\xbc\xaa\xe5A\xed\xbe\xeb\xbf\\;\xf6Y\xbd\x92\xf0\xbfS\xc8\xad]\xac\xfa\xf1\xbf\x9d\xf6g\xc63\xca\xdf\xbf\xab0\x08tn\x8b\xd8\xbfEx\x0e]\x04\x88\xf4?\xee5v\xe97\x13\xb4?\x01:\xd8\xfaf[\xd3?\xe2\xb0\x1b\x18\x96\x14\xf5?z\xae\x0b/o\xcf\xe0\xbf\x1b\xd7\x10\x81\t\xbd\xf1?k\x9a0\x8d\xd0\xbf\xe6\xbf\xa9\xa4\')\xa6\xfa\xfd?h5\x92M-H\x00@%\x98T\xc7b\x80\xf8?\xd6\xa7dz\x9bP\xdc\xbf|/\xde\'\xe9\x04\xa5\xbf\xfb\x93\xcf\x13K\xd1\xf4?r\xbc\xe2\x90U\x97\xdf\xbf\x8f\x85\x1e\x9b\x14\xc4\xfd\xbf\x9e\xbcK\xf8\xa5\xbd\xc8?\xe9\x98\x81\x10y"\xc3\xbfu0\xfa\x062\x83\xb0\xbf\x0c2Ch\xc9\r\xd4?\xbc3l\xc6\ra\xd2\xbf\\\x11\xbf\xefR&\xe7\xbf#\x07\xcbJ\x18\x91\xd0?G\xba\x83\xbc\xe7\xbc\xdd\xbfH\x0b\x04\xf3\xf5P\xd5\xbf\x7f\xff>\xbb\xd4)\xe4?J\\\xd3\x16r\xcd\xbe\xbf\xd7\x95A4F\x1d\xe7\xbf\x9b5\xd3f\x1cO\xe7\xbf\x08\xd37A\x8d\x7f\xfc?bA(\xf2\xdeU\xf2?\xd0x[\x1d\x8a\x9f\xfe\xbf\xae[\xa7\x98Y\x8a\xcd\xbf\x83_\x85*\xc7\xe5\xe7?QL\x0fL(\x13\xdb?\xae\xee\xe0f\xf3y\xf0?\x9aT\xc2\xd0\xf2\xe3\xe3\xbf\xabv\x8f5\x06>\xe6\xbfWe\xf0\xa7Q\xa2\xa6?\x83\x9c\x8bd{t\xf3?)\x7f\x84\x86\x8e\x99\xd6\xbf\xde_y$@\x9b\xd7?\x81\xe3\xd58\xfb\xf2\xcb?4l\x8b\x11{\xba\xf0\xbf\xae\x0b\xc0\x1ff\xcf\xba?W\xd0\xd1\xb3\xbe\xd5\xeb?Co\x90\x81Fb\xbe\xbf\xa0\x9e\x0b/k\xd2\xed\xbf\xe5\xa1(\xf1\x86\xbc\xcf\xbf\xbe+\x9e\xeb|=\xf3?\x00\x06\xb2\x97\xa2y\xdd?\xe2G\xeb\x0e\xe9\x84\xe3\xbf\xc1\x0c\x99\x98\x95:\xe9\xbf\x0e\x8d\x90\x87Q\xa7\xf7\xbf\xf6@\xa7)\x88.\xf3? \x03\xdaJ\x89\xcd\xdd\xbfC7\x11\xc5\xbd\xc6\xe1?6\x1f\x0b\xde\x99\x18\xcc\xbfF\x94*\x1b\x9a\xfa\xdc?\xf5\x89g\x80\xeaa\xf3?U\xa3\xd5\xa6\xde\xf7\xd5?t\xa9\x19{\x00\xd9\xf4?K\xbf2\xef\x99\x92\xfd\xbf\xe6\xe0\xbf\xb5\x08\x1d\xe7?\xd9`\xef\x86b\xc5\xed?\xf9\x8b\xe3\xac\xcek\xfd\xbfr\xaeF\xb8\xa7\xbc\xf9\xbf\x17w\x9139\xd0\xf1?\x8a|\xe8kFA\xf5?f \xb7\xf2\xcb9\xed?\x85\n\xc3I\x86\xf6\xfb?N\xcb]\xdc\xa6\xec\x02\xc0\xdc\x9f\xb9x(\xd1\xed?\x89\xe8\xc2,3l\xdf\xbf\x8c>\x82W\xd5\xca\xe0\xbf\x01\xc9\xfc\x8a\x81\xf9\xeb\xbf@zvkp&\xf3\xbf\xbc$\xee\xe1J\x8c\x0b\xc0\xa1\xe1\xb4\xd3\xde\xf5\xe4?4\xb4\xd9d\x86C\xc1\xbf\xf9\xd1F\x9c@{\xe3?0\x00\x07\xa6v\x0f\xf8?\x16k\xdfI\x81B\xf0?\xb5F$\x801Y\xd8\xbf\xf8z\xfe-\xf0\x8d\xa7?K\xd6\xd7\x102\xc3\xd7?\xe3\xe6p\xe7\xbbT\xe3\xbfaT\xc1td\x9e\xeb\xbf\xfe\x9d\x9d\xf4\xf75\xe3?\xf5\xaex\x00\x9c\xe7\xd4\xbf\xda\x8a\xa7\xd6v5\xe5?\xcem}J\\e\xb0?\xad\x8f\xd2\xe6\xf3\xa2\x8a\xbfr\xf0\xfc:\xfeI\xd7\xbf\xf4>\xf9\xe9\x857\xa5?)\x04\xba\x9d3)\xf5\xbfEp\xd2\xc8F\x05\xa1?\xbdG\xd7\x87\x98R\xd6\xbf\xe7N\x82\xe5\x8fs\xf2\xbfW\tX\xf4\xf4P\xfa\xbfv\x16\x17\xff$\xe9\xec\xbf|UT>\x13i\xea?\x8b\xf3\x1bW\x90\xb3\xbc\xbf\x1cn\x9aosi\xf8\xbf<\x14kiwA\xcd?\xdb\x1bo\xa4\xc7\x92\xf5?\xe6\x17@\xbc\xe7:\xe6?\xdf\xdb#\xeaR\xa0\xd3\xbf>\xf0\x8a-\xed\x92\xeb\xbf!\x11\x1fG\xb9\xad\xf9?!jt\x82_3\xd8\xbf\x1b\x8d\xf6 n/\xe3\xbf\xa2\x87-\xc4\xf7\xff\xd5?=\r\xbd\xae\xe4V\xef?\xc74\xa2\xa7[\x0e\xe5\xbf\xcbzM\xa3;V\xeb\xbfOc<\x8cm\xa3\xf3\xbfw\x9f\xee\x1f\r\n\xb9?\x96\x1c\xf5\xd2\x04s\xe1\xbf\xfeuM}\x8d\x1a\xcd?\x8a\x0e\x1a7\xb2H\xc5\xbfBaF\xbf\x06G\xe5\xbf\x91\x8f\x05\xbc\x8eT\xd1\xbf\xef\xf4\x0cC\xb9c\xa3?b\x05\xa8\x98)\x99\xeb?b=2\xe4\x191\xf0\xbf\xfb\xd9\x8b[\x15\x06\xde?\xdeU\xc3$\xd6\x0b\xda?j\xbd9\xc2\x8dB\xf8\xbf\xac\x13W{x\xd0\xff\xbf\xf0\x10+\x9a\xebt\xe8?3?\xa0\xf0VF\xea\xbf\xfa\x05\xfa#\xdfw\xd3?\x069\xae-0\x9f\xac?Y\xff98~C\xca\xbf@m\x0b\xc4\x1c\xc4\xff?\xb3\xd6F\xc8\x11L\xd4\xbf]d~\xe1\x90\x92\xed\xbfnL\x7f\xd9%C\xfb?\xf9e\x1c\x97\x86\x89\xd1\xbf\xa0\x8e\xfd\x921\xde\xf2\xbf^\xfe\xd7\xa50\xbd\xf0\xbf}d\x0f\xe7\x17\xfc\xda?\xde\xcd5\xb0\x14\xe8\x08\xc0U\x01T\x9fg>\xea\xbfx$\xb3Wd\x03\x01\xc0\xa3G\x1b>\xd9\xf2\xe4?\x06\t@\xd1fC\xfc\xbf\xa0\x1b@4\xa0\xf3\xe0\xbf\x96\xc0\xf3\xf0.\xf2\xbe?\xbc\xe7\xb2\xe9\x90\xb4\xef\xbf%\xfa\xba\xf6U(\xa2\xbft\xa4\x0f3\x03\xfd\x94?\x8fu\x82q=t\xe3\xbfn\xb7\xa8\x0c\x1f7\xe9?m\xb4\xe4m\xe4\xf7\xdd\xbf\x90I\xa0\x03\xfd|\xd7\xbfO\xb4\xf24\xa9}\xf3\xbf\xa2\x80\xbb\xa5A\xb4\x01@\x8e\xd5\xfe9\xf4%\xe7\xbf\xdd\xfcSm\xec\x8a\xd7?\xe9U\x15\xbbBw\xe1?\xf5&\x11\xbb\xe8\xba\xd7\xbf~\n\xd0vi\xa7\x02\xc0\x84{\xbe\xb9\xec\x11\xd6?\xadM\xa0\x12@\x94\xe8\xbf\x90\xac\xb9\xf9XS\xee\xbf\xa3\xd5\xbe\x9b\xeci\xcf\xbfg\x89Y\xc8C\x13\xf0?j\xf6gI\x1f\x8b\x05@A)H)\xbd$\xaf?\x9c\x90\x07s\xc4T\xd8\xbf\x91\x19\xf8Y\xf6\xfe\x06\xc0\x99\xe0.\x17\xcc\r\x07\xc0\xdcm\x1e,\xc7\xe9\xe9\xbfp\xe5i\xb6\xfc\xd4\xe8\xbf3p\xc3\xc0&\x89\xa1\xbf\xb1T|)\xec\xd6\xe8\xbf$\xd7\xf8\x16}*\xd4\xbf\xd4\xb9\xbct\x9c\xa4\xf4?\xb2\x16xx\xda\xef\xc7\xbf\x99\x0f\xe5\xafH\xa1\xa5?.\xf0P\xbd\x89_\xe3\xbf\xd7\x7f&1\xb3\x84\xde\xbf4\x9e`\x17\x8d{\xe6\xbfY\xec\x19Q\x12\xe2\xd4\xbf\x101\x94\xa4>\x0b\xec?\xf3C\x06\xac\x10\xd2\xe7?\xb03\xe9\xbb\xaa4\xfa?,\xaf!G\xadk\xf0?\xc7\x8eNy\x9d\xde\xd5?\xb8\x9f\x8b\r\x86\x10\xe1\xbf+ZO\x10\xd0\xc8\xe3?j\x18@\x11=l\xd2?H>\xda_\x12\xc1\xe3\xbf\x8d\xde\xf9\xa9\xfc\xc7\xee?uW\xf2?\x84(\xc2?\xc2\xfb\x91\x00\x15\x1d\xdc\xbfG\xae\xd5\x98\x98\xd2\xb9\xbf=\xb1(o\xaf{\xff\xbf\xa3\xbe{0\xb1e\xbb?\xb6\xda\xf7\xb47\xd6\xe1\xbf\xee\xf9\x18O\x9cO\xf1?^\xda\xe84\x85\t\xe5?\x07!E}\xe8\x81\xf5?\x90[d\x87.`\xa1\xbf\xe5JG%\x9f7\xfb?\'\tt\x1e\xabV\xe8?\xe8e\xfcw5P\xaa\xbf\x8f8{\xc4c\x85\xbc?:C\xa1v(0\xe9?\x9d\xa8t\x1a\x8d\xa5\xef\xbfJ|\x96\x00[X\xec\xbf\xf8\xab\t\xe8l\x8a\xe2\xbfDi\x15!\xb0\xa6\xf3?\xbc\xfa\xa1-\xac\x1f\x06@\x8d\xb5\x14\x81#\xe7\xf5?\xf8ch\x99\xee\xdc\xf8\xbf\xe5\xdc\x7f\xe4\x1f\x1e\xfa\xbf\xf3_\xa7\xe5\x1df\xdc?\x86\xf8.\xf28\xce\xf2\xbf\x94\xfc\x8fA\xab\xa2\xe4?\xe54\xc3\xe79j\xfd\xbf\n\xae\xb2\xf51\xb0\xc8\xbf\x15;\x93\x86\x9d\x05\xfa?\xec!\xee1+Z\xe3\xbf\x02\xefHA!e\xf1\xbfh\xa3t,S\x07\xf2\xbf\xf8\x9ae\xdd\x1fF\x04\xc0\xb2\xf1\xf35\xb7\xd1\xf2?\xa9\xdd\xc8\xdc\x87\xb7\xf6\xbf6\xd1O\xbah\xa2\xce\xbf \xff\xe1T\xea(\xe1\xbfH\xf6\xb0\xfcYy\xd5\xbfB\xf7;\x0f")\xd3?\x18\xaf\xc8\xb4\xd8Y\x00\xc0\x07v\xba\xe4\x00\x0f\xf3\xbf\xa8N\x1db\x8a\x95\xf6\xbff\x95\x83\x13\x89b\xf4\xbf\nn\xcfY<\xdb\xab\xbf\x8a_\n\xdf\xd1\x8b\xd5\xbf\x80A\xd5\xe9\xca\x00\xf5?\xd6X\x059\x83]\xfb?)\xcb{Eb\x97\xef?\xce\'E\xfc\xcbG\xf4\xbf*\xd9\xb9\xe8;\x10\xdf\xbf7n\xf233d\xcc\xbf\x03\xd6\xf5\xa2\x95\x9c\xd7?\x85\x0b\xaf\x8ax[\xf2\xbfCE\xd6\xd8\x02v\xc3?j\x86Hg\xe3\x8f\xf6\xbfp\x8brBV\xeb\xf1?\xc5\xbd\xc1x6\x0c\x08@hz\x17\xf6z\xc3\x0b@\xd4;[g\xe5V\x07\xc0\xacJ\xe8\x04N\x96\x0b\xc0\xf4\xe9\x1f\t\x99]\xc3\xbf\x1d\xbb\xef\xdd}t\xc9\xbfE\xcc\xdcF\xe8\x1a\xd0\xbf\xa5\xcb\x08sOI\xe2?\xce_!d\xbdu\xea\xbfdt#\xbe\xfe\x9c\xe8\xbf\xfe\xd9U\x01\xa9\x82\xd0\xbfu[\xb4sF\xbf\xd3\xbf_M-\x03\x0f\x7f\xef\xbf{jZ\xa2\xbd\xde\xf0\xbfy*\xf9\x1eca\xd3\xbf\xa8\x90\xbcg\x98v\xe6\xbfiH^\xdf\xe75\xf4\xbfiB\xcbg>\x8d\xec?\\\x15q\x80\t\xdb\xee?\xcf\xaf7w\x8f*\xd1\xbf\xbc\xd19\xc0\xac\xdb\xed?\xc86\xa3vU\xec\xf7\xbf\xf6F\x06\x81\xbf\xf5\xf5\xbf\x8aq\xfc\xcf{7\xe0?\xf3%W\xf7\xb0\xa4\xdc?|vP\xebi\x98\xce\xbf?D\xc1li\x95\xec?\xe1C\x97\x95\xe6\xb7\xf9?+\x00\xef\xfe\x91m\xb5\xbf\xc3&!]\x1e\xc5\xfb\xbf\xce\xe1J\x86\xae\xf8r?\x07\xdf\xba\xbb^\xc1\x03\xc0\xa2\xb0Y\xbf\x87\x1e\x0f\xc0/-\xac\xd3k\x16\xe9\xbfk\xb6\xff*\xf3\xf4\xa4\xbf\xe4\x84\xc0\x97\xc9T\xc4?\x10d\x1b\x9b\x97:\xdf\xbfn\x17\xccO;\x9c\xde?u\xdb\xc0Y\xa5\x8e\xf0\xbf j\xeb*x\x1e\xe4?b\xb7\x9em\xa2{\xf3\xbf\xdfeM\x0b\xaa\x1eU?l`s\x1a\x0fe\xd4?b\xb0\xa2\x94_\xce\xf1\xbf#\xd6\x9e\x05\xcc\xc6\xf7?\xc4\x08\x18$\xb3\xc5\xf5?s\xb39\x92\x08\xd4\x03@\xa5\xfa0\x1d\xd7v\xf2\xbfx\xd0\xbcv\x9f\xa0\xfa\xbf\xbb\xd0U\x95b\x88\xf6\xbf\xf6!\x03^w3\xf9?\xac\xf8V\xae\xc1Q\xd2\xbf*\x8f\xd0x\x1dU\xfa?o7\xa8\x8eEn\xd4?\xd3\x91z>\xe9\xf4\xce\xbf\x1f\xaeF\xf3/\xf1\xf1\xbf9=\xaak\xda\xfb\xda\xbf\xa7\x8c/\x02\t>\xe4\xbf\x92g\xb2\x90U\x10\x06\xc0g\xb0\x8d-\xd2(\xc7\xbf[\xb2\nNk\xb5\xf7?\xd3\x1d\x13\xe1\x7fQ\xcf?V`\xd0\xe2]\xd8\xee?c\x8c\xcb\xde;N\xd0?\x97)\xbeHGx\xd8\xbfAw\xe9\xd0\xd8\xac\xdd\xbf\xbd\xe7?\x88OS\xd1?\xf9\xeb\x8e,\xf6\x84\xdb\xbf\xfbV\xefEt4\xdc\xbf\xe1\xe4\xb4\x04\xc1}\xf7\xbf\xc8]e\xfa\xf3\xe1\x04\xc0\xd0\x7f+-\'\xff\xe7?%a\x9c\x13\xec-\xf5?\xb5\t\xf3\x99\xcb\xe0\xeb?\x07\xc4)\x84\x88r\xf6?\x80R+;u\xa2\x03@\x0e\xf5\xe8\xc3\xb0M\xfc\xbf\x9c\xbe\xd8H\xeb4\xeb\xbfW\x17;\xb0!e\xcc\xbfd\x04\x82\x07\xe1\x9e\xa1\xbf\x8a\xa6\xe6\x8a\xf7>\xe1?M\xd5Ie\xdbf\xdc\xbf\x17\x13\xa7&8?\xfd\xbf\x93-4\xd3\xdcU\xed\xbf(z[4N\xd8\xeb\xbf4\xf8X\x1a\xcfj\xf2\xbf\x99&s\xfd\xb4\xd5\xd0\xbfg\x1c\xbe1{p\x99?\xeb\xdep,d\xea\x9e?\x86\x056\xf5\x94\xb5\xbf?\x1a\xeb-\x9aOk\xef?\xc0x}\xae9\xa6\xe1?v/\x9c\xf0\x85\xe9\xc6\xbfl\x00\xe4vy\xc2\xfb\xbf\x03\x04%i5\xce\xf6\xbf\xec\xad\xb2.\xd4{\xeb\xbf\xddk\x05\x9b0\x0e\r\xc0\x81\xb8\xa7M\x8c"\xe2\xbf\x1fDb\xe7\x83\xd3\xe0?\x9e\x1a\x17xsx\xc2?T\xadfN(\xc6\xe4\xbf\xba\xd4WU\xc0\xf5\xfb?n\xc8\xc9\xa3\x14c\r@\x97\x99\xb8\xa3%v\xeb?j\x8d\x82\xf9Z1\xfe\xbf\x8c\xc4-\xc7\xa4\x94\xfc\xbf\xee\x92\xee\xc8b\x13\x00\xc0\xf3=#\xdd\xa7\x8e\xd7\xbf\x8d\x9e\xf6\xc8\xe0\x96\xfb\xbf\x13b\xd5\xdc\x80\xb6\xde\xbf|V` \xf5f\xe9\xbf|s\x07R8~\xea\xbf\x9d\x96<|\xe8\xd9\xf3\xbf\x1d\xf6\x9eh\xbd\x07\xb1\xbf\x99\x90<\xe8^\xb2\xe7\xbfP\x97\x9c\xab3\x02\xce\xbf<\xb0\xd2\xda\xf4\xe8\xd3?k88\xd4\x95\x93\xe9?L\x9aq\xee/u\xe0?\xde\x92\xa8\x88-\xb1\xdb?K\xad\xec\x81e?\xed\xbf=n\xf1\x04\x86\xec\xe7?\x95\xf1\x14\xa6z\x1f\xed\xbf\xdf5\x87N\xf5\x1e\x02\xc0\x15\xdf\xa1\x88:\x93\xf7\xbf=\xf4\xa2\x81\x17l\xef\xbfEv\x93\'QV\xe4\xbf\xc0\x18\xda\xae\xf7\xca\xf0\xbf\xe0\xc8\xb6\xa2\x07\x9b\xf0?-\x83\x9e\x95\xc2\xb9\xf2?gY\x98\xb3g>\xf8?\x8c\x81\x98\xc5\xb9f\xf9?\xa0\xfde!q\x10t?\xe5q\xda\x8cB\xfa\xe9\xbf\xc3NG\n\x07\x99\xf5\xbf\x9b3\xcc\xec\x06R\xf6\xbf\x9c\xe1\xb2\x08T\x9e\xb2\xbf64\xa2\xd5\x91\x86\xbd\xbfvr+\xf5@\xfb\xf7\xbf\t\xc91\x0e+\xbc\xe9?)\xb7\x0e\x16\rK\xf6\xbfMM\x06\xaab\xfe\xe6\xbf A\xf0\xc4\xb2I\xd0\xbfy\x97m\x8d\x9b\xf8\xa3?\xc4F\xe7\xd3\xbe%\xf3\xbf\x1bQ\x94\xac\xe3\x12\xf2?\x04\xc0\x9e\xcb\xfc\xe0\xd3\xbfAb\xef\xafz!\xeb\xbf?\xaa\x93\x1fr{\xed\xbf\x9a\x1f\xff\xc3\x1fc\xd6\xbfM\\L\x98\x9e^\x03\xc0\x8fs\xdd\xd1\x8fo\xe6?\xb7\xeb\xd4\xfe\x8a\x84\xff\xbffJ9\xb1\xda\xcd\xbc?\xa1\xb4\xe9\x84\xf0\xc4\xe7\xbf\xf3\x9a4V;]\xd7?\x03\xa6\x99\x9e\xb9D\xce?X\x96\xb8dg\xf9\xd3\xbf\xe1K\x87\xed\xa0\x85\xe3?\x05\xa8\xd4\xb7@\xe0\xf9?0\t\xe1#\x83\x1d\xd5\xbf\xd26H+&L\xe7\xbf-?\x1b\xe8}U\xd7\xbf\xff\xd0+\xe5Q\x17\xf4\xbfg\x7f\xb55y\xa2\xe4\xbfZZ0\x07\xac\xab\xeb\xbf+\x99\xe7sp\xfc\xf3\xbf\xd2\xb4RI4\xbd\xea?n&0S\xdeg\xe8\xbf\xcf\xd3\x1f\xc3\xc5\x95\xe7\xbf\x1a\xf4h\xf5\xee\xf1\x93\xbf*\x1bZ\xdd\xaa\x0f\xe5?j\xb9I\xdf-N\xeb\xbfG\xbf\xd4\xec\xb9\x9b\xec\xbf1\xcc\xb9\x98\xc4f\xec?6\xdb\xf9\x0f\x84A\xff\xbf\xbes[\xbd1q\xea?\x07\xebP0\x8f\xc9\xe3\xbf\xcd\x115\x18\x0c\xd0\xec\xbf!\xe4<\xeb\xe6l\xcf\xbf?a<\xfa\x03\xbd\xd4?\x0f\\b8f[\xd3?\x17b\xd8IGw\xe1?\xa9|(\x0f\xee/\xf7\xbf\xe5\x10\xc4\x0eQD\xe9?\t\x93\x91\x0c\x1dK\xf5\xbf\x81\xea\x1c\x8d\x8c\xc7\xe7?\x08_\xc8\xc3\xcbC\xfa?0R%\x85\xf3E\xb4?}B\xaf\x1bl\x9f\xf9\xbf\xc2\xf8Q\xd8\xf5y\xf2\xbf\xb8`\xf7\xf82\xd0\xea\xbfs\xb3\xc2\xf4M\xe6\x8e\xbf\xe9i\x1e\xf9\xf8\x19\xf7\xbf\x14\xa5k,\x94=\xcf\xbfYfz_m\x8a\xe4\xbf\xd6\xcaSE|\x88\xe1?V\xb6\x13\xf6\xce\t\xf9?\xc4\x1ck\xafe\x90\xe0\xbf\xb4\xb1:*\xd5\xe7\xfd\xbf#J\xc5A\xea\x00\xd9\xbfHj\xfa\xbb\xd5l\xe9\xbf\xa5\xca@m\xd2L\xc3?\xfc\x912\xadx\xad\xf3\xbf\xafKu\xa7\xdd\xe3\xee\xbf\x91y\xafoW\x88\xd7\xbf\xa2\x9b\xa3nw\xb0\xd8\xbf\xe007#\xabv\xe0?\xe7\x19\xec\x84\x0e\x10\xef?\xf2n\x08\x8bV\xfc\xfa?\xd7{\x171\xd2u\xdb?\x01\x9f\xc7\x08\x9a\x13\xdd?\xf3{\xeai\xb4X\xe4\xbf\xe0F\x12\xc2\x12\xa0\xf5?v\x1e\xc1\t^\xfb\xf7\xbf\xc2\xc8V^\xcab\xe1?0;\xf2x;\x08\xf0?\x9f\x05<\xce9\xbe\xf3\xbfQ=\xe7\x90\xdb\xd5\xfd\xbf\xca\x01\xb0i\x06\xb1\xf6\xbfD\x1a\x11\x02\xe9%\xcd\xbf;\xa7$\x1e\xf7Y\xdd\xbf{I\xc4\xfck\xa3\xf5?q\xaci\xe0\x9dk\xe8\xbf`8\xf5\x13FG\xb9?\xfd\xb6\xef\xf2\xc1\xfd\xd2\xbf\xb0&\xb9\x0b\x13\xab\xdd?G?\'M{\x0f\xf9?Y\xd6Dm\x13\x0b\xf2?s\x1bt\xd2\\\xfd\xb1\xbf\xe5\r\xee\x11!\x8d\xfe\xbf\xde\x8a\xe3m\xcdf\xe2\xbf\x13\x9aW\xac\x8f\x14\xc2?\x90ANQ\x84]\xf4?\x9a$\xb6p2\xf4\xf7\xbf\xfd\xe5\x9f\xafKK\x04@\x91\xdb\xb2&\xcb\x95\xf6?\x06\x18\x99\x0b\xea2\xdc\xbf\xc1w\xe0\xf3\x8aG\xa4\xbfl@p5\x9e\x19\xf8?\x84\xac\x00\xb0Hm\xff?\xec\x9a\xc6\x80O6\xf2\xbf\x11$\x18r\x86Y\xea\xbf\x15\x8c\x06\xabL\x13\xd6?\x1f^QFi\xab\xf1\xbf\xd5\x04\x8a\xb9\x11\xc9\xfc\xbff\xa5\x98\x18\xeb=\xf6\xbf.\xc5\x01+\x16\xa5\xeb\xbf\xf8&\xaa\x8b\xb1\t\xe4\xbf\n\x06Jz\xab!\xf2\xbf\'\xa1ZF\xee\xe2\xc3\xbfm\x8c\x89c\xf8$\xce\xbf\xdc\xda\xe1D\x1b\x19\xbb\xbf\xc4\x92\x90,\xaf\xe9\xd9?\r\xf0J\xe4?\xda\xd5?\xa3\x00\x0f\xb4@\xc4\xe5\xbf\xfb.F\x929\xaf\xd2\xbf\xeb\xb9\xf0\x9a\x85\xf4\xd0\xbfm%\xe3\xc4\x87\xaf\xe6\xbf\x87\x17-{as\xf3\xbf^\xf8?"J\xe3\xa6\xbf\xb7\\Z\xf5\xce\xcc\xf0?\xa6\x0c\xc4:\x12\x8f\xd2?\x19F\xbdmb\x85\xd5\xbf6:-%\x7f\x87\xb8?\xe9\x0b\xb4dM&\xf5?\x85F\xdf\xa4%\x0c\xf6?ii\x98MnE\xf1?M\xf1\xc2Z\x84X\xe0?g\x19\x9b}\xc0\x87\xef?6\xecZ\xd2@\x8c\xe0?\xf5\xa7\x87ho\x07\xd4\xbf\x83\xacwl\x88G\xe6\xbf\xe6\xfd\x11\x0c\xe6\xc1\xc0?rn\x15\xa75\xf6\xed\xbfA\xc7\xc8ya\x1a\xe1\xbf\xb7\xf9-\x1b\xf6$\xe6?\xc6\xb7K\xb1\x8c\xe4\xe8?\xb5\xdf\xa8\xf3\x02\x97\xed?:\xb4=\x87\xdc:\xf5?v\x1e\x9a\x87\xab\x03\xff?\xb0$\x10\xa0\xdc\x91\xd2?{\x82=~\xf98\xdb?3\x86\x81\xdfW7\xed\xbf6\xe8kw\xec;\xfc\xbf\x9b\r\xf0\xc9$\x16\xb2\xbf1\xfe\xce\xbaz`\xc7?\x13sq\x80A\x13\xd2?6\x83q@{\x0c\xf1?\xa6\xd4\xa1\xff`\xe2\xf7?\xee5\xe9\xff\xab[\xbb?\xdb\xcfYP\xc0x\x00@\x16[TU\xb9\xd1\xe0\xbf\x8fT\x19Rw\n\xab\xbfh\x9d"\xc8\xfa\x0e\xb6\xbf\x9c\x9a\\\x16\xfb\xb1\xc9?\xc2\x9a\xa7-G\xcf\xec\xbf\x16/s]\x8e\xeb\xd6\xbf\xde\xe5\x0c\r_\xa9\xf3\xbf6\x94\xb8\x9d@a\xb0\xbf\x89\xe5\x18\xff\xc6/\xc7\xbf\x1d\x98u^\xb2\xf5\xe6?\xf7\xdb\x88\'\xcc\xe3\xc8?"\xd7z+J[\xe9\xbf\x9c\x95\\N\x11\'\xf4?d\xc1u\xa4;\xa0\xfb?\xcdzzl\xe0$\xc6\xbf]\xf2\x16\x86\x85\x9f\xf9?\xcf9\xb1\xe9\xd4\xef\xaa\xbf\x87\xfc,\x8d\xf8H\xe8\xbf.By 3\xfd\xed\xbf\x85\xfa\xf5r\x94X\xe9?\xb0\xd0\x86\xa0/,\xad\xbfik\xfb\x01\x97]\xc4?\xc0F\xda`\xd0\xaa\xd3\xbf\xb2\x80\xb7`\xfd\x86\xdf\xbf\x98"\x19\x1f\x0bt\xd3?LX7\x1f%\x10\xfe?;yI\xb9\xab\x91\xef\xbf\x15.\x85\x1d\xfb\xcf\xe3\xbf\xe8\xdb\xb2\x96F\xa0\xc7\xbf\xab\x1eb\xdf}D\xcd?6|\xea\xb8\x05k\xf5\xbf\x89\x82@\xd1\x93\x82\xb7?\x9e\xad,__\x15\xfd?\xd0\xea\x12_\x1d\xb7\xa2?Z\x99\xa2\x08\x8d2\xb7\xbfu:\xae4T\x9c\xd8?\xf3?\x8a\x9b\x1a\x9b\xe0?\xea\x8d\xcfl\x9b\x11\xda?\xe9\xe5L\xf0\xb0\x05\xc7?Ej\x81\xc9\xca\xdc\xe8?\x9e\xc5\x96\xb7\xca(\xd1?\xbd\x85\xa1l\xed\x12\xe9?y6#~=\t\xc3\xbff\x1c}d\xeed\xe1\xbf-\xcc\xca\x80W\x12\xc4?t$\xb66\xff-\xe5?\xa6\xb8\n \xbf\xb9\xe6?\xfdk}C\xeb\x1b\xb9?Y\xb9\n\x9a\x9d7\xd9?A<\xaaca!\xf3\xbf\xa0\xe6\x15\xc8/<\xf2\xbf\x86\x82\x94\xbf5X\xf2?\xd0\x15\xc1\x82%\x87\xd1?Q=\xdd\n\r\xf9\xc0\xbf$\x88\xb3x\xa4\xa6\xf1\xbf\xf8\xb6I\x9d\xa0\x85\xde\xbf\x1e%8O\xa9\x14\x91?\xed\xcb\xb7d\x94\x80\xda?\xec\x81\x04\x0e\x83F\xe0?s\xecc\x93Z\x9c\xd5?\xb0\xe1U\xd27\x9b\xe1?I\xfe\xcc\xca6J\xf1\xbf0)\x1a\x00r\xea\xe3?\xfe)M:\xfc\n\xf2?T\xac*\x944\x02\xd4\xbf\x9a\xb4qp6,\xac\xbf#\x7f\xf4\xa4\xa8\x7f\xf5?\x9d\x97\x93,\x93f\xdd\xbf{\t1\xc4F\xfd\xfe?he\xf2\xb4\x81@\xd3?\xdf2\x89z\xfb\x06\xf4?\x11:ln\xbee\xe4\xbf\x01g\xc9\x9c\x86\xae\xce\xbf\x1f~ui\x00\xfa\xe0?\xf0:\xe6\xb7\xc2[\xf9?\xb0\x108>\x85&\xb3?\xbb\x90\xbbN\x96\xce\xf7\xbfN\xc3\xd1\xcak>\xe4\xbf\xa9t\xe0l;7\xd6?wi\x1d\x80\x0b\xb6\xa2?\xaeh\x16A\xbbe\xe6?t\x1f\x98T[\xce\xfb?;R\x7f\xf9\xf5P\xcc\xbf\xcc\t\x8c\xc2\xb2\x02\xf0\xbf\x93\x8c\xe89\xa59\xe5?\xb0\x0e\xf1fe\x93\xc9?\x8b3V\xbf\xecu\xee?$\x87\xb2\xf2O\xc6\xf2\xbfW\xef-q\x18/\xee?5\xdb\n\x06\xa8\xb3\x00\xc0^\xae\x87\xf5&\xd3\xd9\xbf\x88\x9c\xddk\xd1\xa8\xe0\xbf\xfd\xa7\xf5a]\x04\xdb\xbf\xa4"\xbd\xa8\xb1\x8c\xf8?\xe8\xe1\xda\x96\xb77\xf2\xbf\xb8\x94\xe1\xcc\x1ac\xd5\xbf\xac\xfe\xe2\x16<\xcb\xe5?\xf1\xc0#\xe3\x809\xd2\xbf\xa6\x82\xebw\xab!m?\x9f\xa6\x0fn\x91\xa4\xed?\xfc\xee\x86\x1b\x12\x99\xd1?\x93_\x0eu\xcc\xfb\xba?\\\xa3\xa8+\x96e\xf1?SkZ\x1a\xfa\x02\xf9\xbf\xd4\x9c/t\xda\t\xcd?U\xd8\x0b\x83&\xb6\xf9?\xdfH\xc5\n\x8c&\xe2\xbf\xc9\xa5R,\x94o\xb8\xbf\xbd\xe3\xe7\\\x85j\xfe?r\xde~\xda\x8d\x92\xd3\xbf\\D\xee\r\xd7#\xe4?\xe7\x19]Bv\xbf\xea\xbf\r\xd0\xc7E\xc9@\xec?\xf3\xa8\x0e\xa1\x0b\xfe\xc3\xbfx\x8b\x02\x14v\xa7\xf1\xbf\xc2\x1e,<_\xc4\xe8?\x03\xc7\rx\x08\xc4\xc0\xbf\xff\x8br8\x9c\xf6\xe0\xbf\x926h\x8bN\x89\xb9?\x19E\xee\x17\xb9\x10\xe2?\xd3E\xc4\xee\x95<\xfb\xbf\xcb\xe2\xfe\xe4\x07\x8e\xf6\xbf\xcf\x94\xba\'uk\xeb\xbf\xe8\xbe\xcc\xd3D_\xe8\xbfv\x9d\xdf\xe5\x02\xed\xe1\xbfk\xdd\x85\xc7\x8b\xae\xcc\xbfA\x8a\xa1\r\xec\xa8\xc0?m\xf7)\xf0\x1b\xe4\xeb?[\xe5+2q\xcc\xdc\xbf\xa4\xad\x85\xd4\x1c\x03\xf7?2\x1d\x15\xf0\xc9\x0bs?qQ3)o{\xe0?\'-]\x07@\x91\xf3?\x83e\x13\x8ew\x1d\x87\xbf.\x0f\x0cn\xd1\xfb\xf5?\x93{\x1e\xb0\xd2\xec\xfd\xbfn\xed\xf4\xa1\xc9\xf6\xed?\x07\x96\xbf\x19\t9\xc8?2\xe0\xc5f{>\x06@\xbc\xc3D]\xbaG\xe4\xbf\x19;=\xfd\x1a\x04\xec?\xc3\xeem\x98\x8e_\xd0?\x0f\x0b\xda=\xab\xdd\xff?\x8b6R\xf3\x99\xcb\xd5?\xa9?@\xaf\x11\x17\xf1\xbf\xf1~\x86\xaa\xd5\x0e\xe4\xbf\xb9\xb6\xd5\xc5\xa2V\x91?\xe7\xa5\x04^\xc6\xe0\xea?\x9a\xe4\x1fX]\xff\xe4?\xc1\xd2\x8cy\xe78\xb8?\xc9z\x1d%\xa2\xd2\x00\xc0\xe8\xffoc}\xe7\xd0\xbf"\x8c\xe6\x95\xcd\xe4\xf4\xbf,\xb8\xd6\xa9\xef\xe3\xf1\xbfB\xf0\xceA\xc0\x11\xdf?\x15*\xff~D\xf3\xf1?\xb7\xd8\xc8\xcc\x8a\xe7\xe8?\xf2k^\xfa\xeeL\xe2?\xa1s\x9a\x01_\xde\xf4?f\x15\xc0\xd0y\xf1\xe1?2\x9e\x864\xc3\x1c\xe2?+[\xf3z\xe5d\xf1\xbf9\xf2{\xd2\xad\x1e\xe1\xbf\xd8s"??\xf6\xd4\xbf\x00\x8f~8\xce\xf2\xf9\xbf\xab\xab\x16X y\x90\xbf\xda\x1b\xe0\xf1\xb6\xe5\xed?\xa9\xcaK\xf9E\xcd\xea?\xeaK-\x15\x87\x17\xe7\xbf\xf3\x00j@\xa0!\xf8\xbf}\x03\xd26\n\x07\xf7\xbf\xdf\x98\xe9\xe9\xa8\xe9\xa0\xbf^>\xb95\x14\t\xf8?\xae\xa6\x8c\x0e\xebJ\xdc\xbf\xb1[2\xb5\x81\x01\xf1?\xc6\xd7\x01\x86\x02w\xf6\xbfC\xe2U\x86\x0e\x07\x03\xc0\xc9\x1cHb\x1f\x10\xe5\xbfM\xe7>\xa5\xd40\xc2\xbf[g\xd9\xeeu7\xf4\xbf\x95\xaa\xd3\xb8\xd0^\xf2\xbf\xa7H4\xb3g)\xdb?y\xad`\xc7\xb1\x10\xe3?\x12\xe9\x15\xa7\x837\xe9?\xba;U\xb6FS\xbc\xbf\xde\xfd\x1aFno\xe0?\x8da\xa4o\xe3\xf8\xfe?9\x9b\x8a<\xa1>\xea\xbf"\xc8\xbdaz\x0b\xee\xbf\x9b\xda\xa5w\xbb\xfe\x01@\xab\xc4?\x82\x19\xe6\xef?BL\xa80q?\xeb?X}E\xa1\xc9\r\xe8\xbf\x04+Xi\x1a\xb8\xd5?kG\x0f\x91\xc5\xc5\xe9?\xef\xb3\x99\x8e\x8f\xc5\xe7\xbf\xedq~s`N\xf0?\x93\x83p\xeb\x8d/\xed\xbf\n\x15\x14P\x89\x03\xec\xbfn\x9e\xee\x87\xc9\xb7\xc4\xbfI\xa1(\x05\x82j\xdf?\xf0%\xea\xac\xafv\xf0?\xa0p\x08\xd6\xe18\xd7\xbf\xc0WE8\x9d\xb1\x02\xc0T\xbd?z\x13\x95\x9f?\x0e%(\x00\xf9\xc1\x8d?)\x91"\xf1Z\xa1\xec?H\x13D\xcd3\x1d\xf1?T\xaf\xe9\x9a\nx\xf9?w\x17,I1\xcd\xf4\xbf\xd4\xda\x89\x1c\xd5:\xd3\xbf\xcfi\xa5>\xf9\x84\xe1?i\xa5cKR\xbd\xf1?\xc0q%\xabx\x9a\xe0?\xca\xd2\x97\xd9\r\x10\x00\xc0\nb\x86\x9e#\xb6\xd1\xbf\xab\xb6(_Q\x9d\xf0\xbfVt\xa0\x9b\xc9\x90\xeb\xbf\xb9\xe3<\xfbv\xc6\xf1\xbf/\xed\xc3\xe6,\x8b\x03\xc0\x9e\x81Q\n\x82\n\xda?\xa6_\xeaS\xc4H\xc3?\xf6\xfa\x05,"\x91\xf0\xbf,\xfb\x91\x8e\xece\xf4?\xc3\x93\xfdK\xfd\x8f\xcb\xbf \x8fh\xb0\xa2y\xe4?\x03\x1b\xa6sL\x8e\x03\xc0_\xac1tsQ\xf1\xbf\x0b(\x16`\x90\xe6\xf8\xbf\x84T[)\x8a\x8e\xfe\xbf\xe6q\xa2,\xe5e\xf3?)\xec7\x9bA\xe8\xd9?f\x91\xef\xe4\x155\xe7?\xa3\x8b\xf2\xad\x8d\xb3\xe1?\xad\xa6\xd9\xde\xed\x8a\xb3?\x17\xf8\\s9i\xe1\xbf\x13\xbe]\x04\xa9\xb2\xe3?<\xed\xd1\x85\x89(\x02@G\xea\xa5K\x1f\xd0\xeb?\xadrM\xdfX`\xd8?\xa6\x8cc\xacm!\x9e?!\x1eR\x9e`p\xf7?[\xcd\x96\x00\xe3\x83\xfc?\x96\xde.%>\x8c\xe5\xbf)\xa0R\xc6\xef\xaf\xde\xbf\x94;\xefB\xee\xf6\xd7\xbf+?K\nB\x16\xf9\xbf\xa6w\xef\x8a\x933\xe4\xbfy\x19\xc2e\xac\xf2\x9c?;-D\xee\xf2\xa8\xea?\xb7?G#k\xea\xfb\xbfg\xaa\x87\x13\xd7\xa9\xdd\xbfH]2\xa2\xe7\xfe\xf2?\x92~5\xf9C\xa7\xea\xbf\xadc\xba\xef\xfb\xda\xdb?\xb4i\t\xef\xd1x\x9f?\x1c\x7f\xf1\xd4v\x83\xea?`w\xbc\xf0\xceT\xf4?\x0b\x9ey\x1dSN\xf2?\'\x9c\xe8\xa3\r\xc0\xfe?\xe2b\xfb\x10\x03\x19\xe1\xbfg\xef2\x8d\xb0\xc8\xe1?\x98\xea\x02\xa1M\xbd\xdf? \xd7J"{\x19\xee?\x15\xe4\x9a\x14}\xee\xec?I\x00\xf5\xca:8\xf0\xbfM\x07\xc3G\xa5\x85\xef\xbf\xfc\x9f!k\xb1`\xc4\xbf\n\xa6\xe2\xfe\xb9\xd8\xe4\xbf0\x99\xb3\xb2|\xe8\xe3\xbf\xfb\xb3E\x9cL9\xfc?y\xe6\xe3\xb5#\x0f\x08\xc0\x01\x84VA\x86\x81\xe5\xbf\xd4\xd0:\x1c\x1e\x04\xbe\xbfl\xc5\xe1b\xe3\x02\xe7\xbf\xd3\xbek{\x88G\xf8?\xf6\xf0\xb5\xea]$\xc7?\x18\x07\n\xa8n\x8a\xcd?\x9e\x16it\xd4D\xd3\xbf\xe3d\x0f\x9b\xe3!\xec?\xb9\x0e\x94\x93\x0e\xc7\xc5\xbftO=[q\x08\xe5?\x1f\xc1\xe8\xcb\xa7X\xd9\xbf\x97+t\x04\xac\x80\xf9?y!\x92\xbb\xd4S\xdd?\xeb\xc1\xcb\xff\xc8\x99\xf4?\xf6\xfa\xebb\x827\xae\xbf\xcc\xe7B\x8c\x85]\x03@"\xe5m&\xdcI\x00@`\xd3\xe1\x14\xf6:\xfd\xbf_\xd8\xb5\x17^\x84\xe4\xbfl\xa7\xabuT\xb9\x01\xc0eA\x07\xc8\xf0\x7f\xfc\xbf:\xf9\xca\xbb\xc7\xae\xd1?\xb3%\x83QT{\xe0\xbf\x1dc\xdf\xbe\xdc\x1d\xf0?\x9djo\xc6\xf4]\xf6?l\xe0\x98i\xe7\xc4\xe9\xbf\x0b&\xd6Y9\x8a\xd8\xbf\x05Bw\xf1N\xef\xd1?2\xbak\x9e\xdcG\xc4?\xe4[3\xbc0\xfc\xc2\xbfP\x9dzC\xfc\'\xe0\xbfI\x16;\xdaJ\xc9\xb0\xbfc\x13f\xa2ei\xd3\xbf\xf7\x9ev\xeb\xd7\xec\xfb?\xf9\x97u\xe7mA\xf9\xbf\xe3\x1aF?#\x1b\xf5\xbfn\xcb ,\xa6\x85\xf1?\xbd\xfcal\x0c\x06\xff?E\xe9\xb1\x19!S\xe7?m\xb5Q\x95\xd8\xbe\xe3\xbf\xe3\xc9\x97\xd3\xab\xec\xe5?\x04K%\xaa*\xf5\xfa\xbf\x1a\xfb\x83d\x1bc\x95\xbf\xd6/\xd2\xdc5)\xd5\xbfW\xb5\xff\x13\x88\x81\xde?K\xe9\xe4\x00,Q\x00\xc0[\xf5\xbc=F\xcd\x00\xc0\xdd/"Ed\xba\xeb\xbf\x8a\x8bqnD\xe2\xe7\xbf \xf70r\x97\xa4\xd3?~\x8b\xfa\xbc\xe1\xc4\xf6\xbf\xc6\x8cN\xb8\x06R\xfb\xbf\xaa"\xb5\x9b\x0f/\xb0\xbf)\xed\x01>\x16\x1f\xef\xbf\x90\xbe\xdb\t\x02\xae\xd9?\x08Y\xf1O!U\xcd?\xefExJ\xd4\xa9\xa5\xbf(B\xe6\xe79\x1e\xb6?0zx\xe1#\x15\xdd?\x873\xf7\x97\xdf#\xf3?\x94\xf3\xc5\x1f\xf9\xdc\xfa?<\xd03\xfa\xack\xf8\xbf[\xfe\xf9\xfc\xc2\xbf\xd6?S\x1cL\x9br#\xe7?\x12\xc5r\tS\xdc\xe8\xbfd\x08\xcah\xd1t\xf0\xbfO\xf2E2s7\xce?w\x05\xebT\xf4w\xc0\xbf\xe2V&\xc2X\xb9\xf6\xbf\xdd|\xa0\xf7*\xf0\xf9\xbf>\xca\x9f|\xd7>\t\xc0Tb\xf2N\x88^\x04\xc0\'\x84\xb4\xa47\xf4\x01\xc0\x14l\xc3\x02\xfak\xf5\xbf\x92\xff\xde\x1c\xedP\xf1\xbfCi\x06\xc8\xe9A\xc1?\xd2\r\xd8\x9dP\xcd\xf0?\x9c;][\xc8\xed\xe6\xbf1\xf9\xd6;~P\xda?m\x89\xe3\x9e\xbbA\xed\xbf\xd46\xdcc\xb0\xf6\xe6\xbf\x94\xa6f\x83c\xb7\xee\xbf9\x8b\x15<\xd6\xf0\xf2\xbfl\x0f\xb0\x99\xef\xed\xd4?g\x1d\x10\x99`H\xd8?\x8c\xc5d\xd5\x11\x1b\xf8?\x0c\\\xd5]\xb93\x00@\xbej\xee\xc5\xfd\xab\xf0?\xa3\xd1\xb8\xaf\x8c\x93\x8d\xbfL\x8ba\xda\x01c\x02\xc0HK\x88*M\xac\xf1\xbfg\x9a\x91\x1a\xda\x9c\xe5?\x02\x9d\xf5\xf7\xd3\xdb\xd0?\x99~+\x17%\x8e\xf2\xbf\xa5-\x1f/\xbc"\xe3\xbf\xff\x8b\xca\x92\xae\x1b\xf0?\xe4\xf5IgB\xd4\xf0\xbf\xa98\xdd9\xa0;\xf5\xbf\x8f!\x9a\xe6-l\t\xc0\x87-\xd1o\xaa\xe2\x0c\xc0\xef\x8f\xd4H#\xd5\x00\xc0)\x18\xfd\xa7\x10,\xdb\xbfiA)Dkh\xea?\x8d\x7fXS\xce\xa7\xee?\x10M\x8b\x0f\xa7\xae\xe7\xbf\xd5\x86\xa5\xfd\xd7\x80\xd4\xbf\x1d\x93\xeaaS\xb0\xd0?fo\xb8\\;\xf6\xd5\xbf\xfd3\x11\xc4\x05|\xe9\xbf?Ati\xa1\xfe\xe9\xbfi(\xb5{9\x1b\xf5\xbf\x8b\xfb\xa5\x8b+T\xd9\xbf\x0f\xab\xbd\xf8.\xb6\xa4?\x88|,\x82GL\xfe\xbf1\xb3\x90\xe4!:\xf2\xbf\xd7%\x80\xfeP\xc1\xe6?\xb0_>\xfb\x9e\x08\xcb\xbfbC\x9b\x0c\xb7\xc5\xc1?\xc9\x02\x9dJxd\xce?\xc1\r\xa4\t\xd2i\xe7\xbf]\xe2\x0e\xaalr\xf0\xbf\x8a\x96\x83\xc39\x05\xed\xbf\x86\x8b\x92(\xb9\xd5x\xbf\'\x93L)~\x18\xcb\xbf\xe8M\xf0\x81hz\x00@h\x7f\x91\x08%\xe5\xac?2\xa0x\xa0\x86z\xeb\xbf\\\xd4\t1\x99\x87\xfb\xbf\x8bu\xba\x80X:\xe5\xbf\x9a\x8b3ce2\xa9\xbf#\xa5\xf5\xa3\x12\x10\xd2\xbf\xdc?\xc9\x13\x05\x0b\xd3?\xf7\xea\xb8\x85\xc9\x1c\xd6?\xa5\xe82\xf7v\xb4\xf1?\xf4\xd3\x11\xaf\x9b\x03\xe4?\x06V\xcb\xd2\xf0\x03\xf4\xbff+C\x00\xf6\xe9\x01\xc0A\xe3\xd3\xa6\xba\x12\xf7\xbf\x966\xd3\x10\x87\xa6\xc3\xbf\xef\xab\xee{;%\x9e\xbfV\xc9\xdd\x12\x86\x1d\xc9?\x99\x05A-\x0c\xf2\xc2\xbfG\x06\x10n\x93\xcf\xd2?e\xb3\xaet\xd6;\xe0?=\xa4a\xa6\xe4\xfa\xe9?\x0c3\xaaW\x91K\xb6\xbf\x89\x85\xdd\x05$\xbb\xf5?\xd2\xack\xde\x7fK\xf3\xbfg\x13\xe7\xc7\xbe\x00\xf8\xbf\x8c\x98\x9cr\xc2\xb3\xe5?y\x1d\x86U\x8f+\xf3\xbf\x91_\x99 9%\xf1?3\xd7\xe2\xe8\xb8x\xde\xbf\xb0\xa2\x0e\xbc\x06\x10\xfc?\xb9^@\x0f\xd5K\xe9?\xc7FV\x18y\xad\xc3\xbf\xae\xf4L~TJ\xe5?c+#\xcaU\x12\xcc?vU\n\xc8<\x1b\xbd?\x97gw\xfc;Y\xea?\xc7\xfdf\x18\x14\xe0\xd1\xbf\x8f\xdec\xb0\xd8\xe1\xe9?\xe8\x8b\xcf\x10`\xa1\x8c?\xb4\xa2\xf2\xde\x98\xb9\xed?\x97\xd6F\xda\xac\xa2\xdd\xbf\xba\xb4\xb8m\x97\x05\xfd\xbf:\x8f\x88\xae\x84\x83\xed\xbf$\x87I\x990\xe2\xe1\xbf\x90\x9b1\x9e\xf4\xef\xaa?K\xac\xf3\x1f\xf3\xb6\xef\xbf\xe3\x14TP\x9c\'\xd8\xbfv\xbbt\x1f\x0c}\xe7?\xb2&\xa1\xb5\xce\xad\xe0?\x8b\xfb\x9fV\x87*\xef?\xdbP\x0c,5D\xf0?\xbb5c\x8e\xf1\x08\xf6\xbf}\x7f\xd9A\xe4r\x85\xbf\x90\x124\'\xdc\xd5\xdb?\xa5U\xfb\n<\xd8\xd9?\x1fC\x82\xfb\x1c\x02\xd4\xbfU=\xee\xfa\x91\x17\xeb\xbf}\xfa\xc2\xe09\xa5\xfd?t\xb9[W\xfa\xd1\xd5\xbf\xf7\x01\x89YH\x9e\xe4?\x14\x12}\xb78\xc4\xe4?\xa5\x9fP\xa0\x05t\xfb?\xa6=\x98\xba\xbd\xd6\xcb\xbf_\xbc\xd7\xb7\x15\xed\xfc?\x8f%x]\x18\xdc\xec?b\xe4\xa6\xcda\\\xea?\x85\x03mU \x93\xce?r\x1b\x0b\xda\x00\x9c\xf2\xbf\xeb\x84f\x11\x95\x11\xe0\xbf\x05eu\xf9\xe5\xff\xe4\xbf\x06\r\x90\xfcO\xcb\xd6\xbf!!{\xa0\xae\xcd\xbe\xbf\xc9\x94r/\x1a\t\xfe\xbf\xf0o\xc9\xe2m\xd4\xe1?\xa1\x8f0\xea\n\xdb\xde\xbf\xb1\x7f\xa8\xe9\x9f\xcd\xfc\xbf\xbd\x02\x89\xc6\x18\x12\xc3?K+Q\xde2Q\xfa?V\xac\xda\xdd\x05\xaa\xd3\xbf\x8f\xceM\x95F\x19\xe0?\x01\xd5(\xec\xcaL\xea?\x95d\x97\xe6\xde\xf1\xd2?\x89*R\xa8\xdc.\xea?\xb7\xcfO\x86\x9b\x17\xbb\xbf\xfc\xeaHMy\xe2\xba\xbf\x8fuJ\xbf\xb6\xa6\xe6?\x83@\xb6\xf3>\xd7\xb3?#~\xcc\xd2\xf1\xdc\xe7\xbf`\x9dX\xb7\xc0\xe2\xf8?\x0c+\x89\xbe\xc8\x95\xf6?\xc9\x1c\x0c\xb7\x85\xb8\xfd?xb\x17p8\x02\x00@\x15\x15\xb1#\xc2\x1f\xd3?j\xf6\xeaJ\x14\xa7\xf9?\x08\x17\xed\xd0\xef\xfa\xaa\xbf7\xf1\x80\x8d\xd0\xfe\xfc\xbfB\xe0).\xb5\x91{\xbf\xe1H\x05x\x98w\xaa?\xd9N\xcb~\xb1\'\xf7?\xd8@\x9fz\xda\x8c\xe5?\x1c\xc3\x1a4\xf6\x98\xd0\xbf\xf0\xcd\xab\xd1+W\xed?)\x1d"\xc3\xd1\x95\x81?\x95\x07]\xeasN\xbc\xbfZ\xe8\xbb\xc4\x96\xd8\x99\xbf\xc0\x99\x8fw\xcb\x14\xc3\xbf\xaa\xcd\x9a\x9d\x15^\xef?\xc1\xc7\x18\xd6L\xcd\xe2\xbfm\x99u\x80;a\xe4?\xda\x19V\x1b\xc5\xc9\xe3?d0\xca\x1bm\xb2\xd2\xbf?\xab\xcc\xc5\xab\xff\xc3?4\xa4j\xb3\x91\x9d\xe7?&\x8d\x14\x7f\xbe\xb5\xd7\xbf7[\xf3oP\xe4\x01@\xe96`G8u\xea?\'\xde$\xd0\x07Y\xdc?\x9b\xb5\xb8S]\xd3\x00@\xad\x8b\x1a\x8f\x92_\xfb?\x111\xd7\xc2g\xcd\xf7?KF\xc6\x01\x06\x86\xdf\xbflIE\xba\xe5\xd3\xf3?=\x96:\xc64\xe1\xf1\xbfnPGA~;\xfa\xbfG\xdd\xfcE\xd3\x87\xcd\xbf0\x91\x95E\xe8\x02\xf6\xbfj>"\x14\xf1\xee\x95\xbf\xfbB}\x1d9]\xd5\xbf\xa5\xd8w\xd6\xc2W\xac?]\xc0.q\xbd\x95\xc7\xbf\xd7\xde\x98\x92\xab\x8f\xf4\xbft\xae\x02\x1fk9\xe1?\xa64\xce.\x92m\xfa?\x1e\xa8\xedTT\x1e\xde\xbf\xa9\x7fa\x8c-A\xd5?<>\xd3\n\xf8\x0c\xdf\xbf\x08\xfbq\xe4\xe7\x96\xfc?\xc4\xc4\xa1Bo\x8f\xe6\xbf\xd6\xe2\xef\x844I\xd3?.^d\x8e\x89\xbd\xc5\xbf\x13+\x83\xbf\xde\xba\xfb\xbfv\xc1\xdfw~5\xfe?\t!\xf52\xb5\xf2\xfe?uw9#=|\xe2?\xfd\xaa\x963\x0cj\xff?\xcd+\x8c\xb2)\xce\xd8?\xfc\xa4\xb6K\x18\xcc\xf2?\x19\x87\xff"\x8f\xd1\xd6?\xb9,GCi\xca\xe9?l\x1c\xd2\xe6\xbc8\xfe\xbf\x19\xa8o\x88)\x0e\x00@\x04!\xee\xd5\xa9>\xed?\x0e\x8f\xab#\x85k\xea\xbfyP\xff\xc2\xc6\x98\xee\xbfQy\xee\xda\xe6,\xfe\xbf}D_fJ\x0f\xf3\xbf\xb7e\x1co\xf8~\xe2\xbf:\x94\xf5#\xa1r\xdb\xbf\x18\x99\x1cx\xa6\x8a\xed?G\r7\xe4Z\x11\xd0\xbf\xc1&b\xf2\x0e\xd2\xd7\xbfEa\xd3.\x1d[\xb9?\xb0D\x90\xcc\x86~\xf4?\x14s\xac\x13\x07\xcb\xdd\xbf\xa2Wv/\xb49\xd3?\xf2HT\xe4v\x14\xf5\xbf\xab\x0f\xfd\xcf\xec\xdd\xb4?0\x02\x95!`O\xb3\xbf\xd3:j\xff\xd9\xe3\xf9?\x8c\x95\xee\xa7\xe4&\xde?#\xd2%\x9fB*\xec?\xc4\x14[\xf1\x1c\xad\xba?\x9e\xa0\x86\xe7\xc9\xb4\xe6?\xa6\xed}\x1av\xb3\xe2?\xc5\xfa>\xc3u\xb5\xd0\xbf\x06\xd4\xc0W\xb9\xbf\xc4\xbf\xdc\xa1\x0c\x8d\x1bq\xe9\xbfT\x85H\xdc\xbbR\xf3?\xce\xd9QRQ\xc1\xfe?t\xc3su\xe1#\xec?\xca\x1f\xff\xb5\x0ez\xab?\x86\t{\x1e\xba\r\x03\xc0y\xd0\xb1\xc0\xb2]\xca?~\xaf\x12@P\xed\xe6\xbf|Y\xf6\xfcR\xfa\xce?\x8a\xee\xde\x8e\x9fu\xf2?H\xf8\x8a\xc6\xd5?\xf3?\x121\xc6\xa6\x8db\xc0?\xfbVi\x96\x18\xd0\xfb\xbf\xd5Pv_\xdd/\xf3?\xb7\xb2S\xd3\x0c\x8b\xe5?\x9c]\x08B\x1eC\xf8?[\xfct*\xb2\n\xef?\xfe.\xf2\xc2\x18\x1c\xe0?FQ\x19\xf8\xfc\x8c\xe2?\xb7\n\xf2\xd2\x12\x81\x00\xc0\x9c\xd6J#\x93H\xe4\xbf\xebgo\x99+\x83\xd2\xbf0`\xac\xff\xdc\x08\xd6?\xf6\xe2\xf8\xf7\x97\xdf\xd3?\x03<\x18\xfa7K\xcf?\xd1\xa1\xb5\xb2M\xec\xe5?\x11\x9a\xc1g\x0f\xa8\xc5\xbf\xc6\\&\xd2Q_\xa3?Hz\x9b\x9e\xdf{\xc3\xbf\xc8\xa0\x82n\xfa"\xda\xbf\x00\xc3y\x9d\x97 \xf1?<,\xa4\xb2j\xcb\xe4\xbf\x1c\x85\xcb\xfe\xd0\xf2\xf6?\x92M\xbb\xbf\x89\x0b\xf4?xDO4:\x1a\xd9?\x7f\xff\xc5UaK\xfa?e\xa8\xe7\xbb\xe8\xe4\xbb?\xb2+DP\xabl\xcc\xbf\x9b\x0e\xa5\x12\x88\x97\xe3\xbf\x10\x15{hW\xeb\xea?\xa8\'V\xdf\xbc\xe6\xdc?6h\xce\x16\xa5|\xe0?\xbe9\xb8\x13\xbe\x83\xda?\xe3r\x92E\xc8\xe2\xe2?FW\xf4h\xda`\xef?\xf1!\xf4\x92\xf7\x18\xd2\xbf\xe0\x1b\xb1\x9a\x03\xd7\xf0\xbflzh`\xcd\x83\xf8\xbf\xfcE\xd8\x87W\xd8\x03\xc0\xf2\'\x05\xcf\x99(\xe2\xbf\xe9\xa0\xbf\x9e\xcd\x0c\xd4\xbf\x05r\x85xAk\xe0?\xaf\x1d\xab\x05\xcc]\xc1?5wC\xb7\x91h\xdb\xbf\x00\x89\xe8j$\x91\xdf\xbf\xf8cA8\x9d\xc0\xf6\xbf*\xd3\xc4\xaa\xe7\x95\xe7?\x01"V\x0f\x8eM\xed\xbfR\x12\xfe\xd2}\x1e\xe0?\xd9D6W$\xf3\xe6?a\xde2\xe4%H\x03@\x04\xc41W`\xa9\xdd\xbf\xdb\x99\xdf0c\xc0\xbe\xbf\xd5\x1e\xc15\xfa\xc6\xcb\xbfBjC\xe3\xd0\xe4\xf3\xbf\x16\x15p\x02S\x1e\xe5?\xa4\x0b\x84\x84xu\x89\xbfXD\xe9\xc3\x0b]\xc0?\x05\r\xe6Mby\xbc?o\x06\xa8\xc9\xd4\xa2\xef?j_\xc5\x9d\xe4\x85\xa7\xbf\xa2\xf9>gQ\xee\xc8\xbf\xacK@X\xfc>\xe3?\xfd{\x0cm\xbd\xfe\xa8\xbf\x8d\x06\x99\xf7\x84M\xd2?\'\xce\x04\xfb\x14\xd1\xc1?\xa5\x8d\x97\'\xc1g\xe9\xbfz\x14\xd5!\x9cU\xf6\xbfB@1!b\x7f\xf4\xbf\x15@\t\x11|\xf4\xfa\xbfP\xa9\xe1\xdb\xfc\xc7V\xeb?~\xdb\xea\x0bd\\\xd6\xbf\x8b\xc0\xd2\x0b|\x95\xf5\xbf\xa5\x88\xfa\xd6\x84Q\xd7?\xf1g(\xda5G\xd5?\x10\xea\xf9\xa8\xe0\xee\xc1\xbf\xd9f+\xfac\x19\x7f?\xe9\xdb\xdb\xf6\xdb\xbd\xe5\xbf\xdc\x9e\x99;k\x19\xe3?<\x98\xdb6&\x08\xda\xbf\x82\x85J\x17\x00\x00\xa7?\xc1\\\xfb-\xbb\x91\xf0?\xf0\xda\x87\t\xe6l\x01@2^\xfc4j\x85\xf3?\x0f\x95\xdb\x1c\x9b\xf5\xe2?K+C\xaf\xeb,\xd2\xbf\xc9\xd4\xbf\x82\x85\x11\xf6?\x86\xc6.r=\xa0\x00\xc0\n,\xd8\xf1A3\xee?|\x009t\x9cy\xe4?\xf4\x95\xf5\xb8)K\xf5?1\xdbw\xf7\xe3\xfc\x00\xc0\x96\xd2\x82\xcd5\xcc\xee\xbfN\tx\xd3]o\xe7\xbf\x98(\xe5o\xb4\xc2\xde\xbf\xcbL\xfb\x94\x14\x7f\xe6\xbf\xaf\xc2\xd5c\x7f\xf9\xd7\xbf\x03c\xd5\x9d-\x1e\xe7\xbf\x8c\x06\x14\x8d\xaa\x08\xc6?\x13\x81\x1fX\xfe\x0e\xe3\xbf-B\xc5m\xef\x82\xb8\xbf\x91\xa9\xf0F\xe6\xd8\xd4\xbfH\xa8\xf2`\xe1\xbd\xff?\xaa%m\x1c\xd7\xd1\xe4\xbfP\xf7\xe1\xc2xS\xf8\xbf2\xd1\xf2O|\xf3\xd4\xbf\xdcI=\xa0qi\xe5\xbf\x9e\xee\xc5\xad\xa9(\xe1?p\xc0\xf7\xf4L`\xf1?\x8d\x8f\xbdQ\xaf\x05\xf4\xbf\x7fnT\x90n:\xf5\xbft3\x11ry\x8b\xda\xbf\xe5oqb\x98\x99\xf6?\x93W\xec\xc9\xf5\xa0\xf9?\xafq\xf6\xc8$\xc1\xf0?\xd7\x01)sC\r\xff\xbfH\xa3\xcf\x91\xea\xa6\xe5?\x81J\x8a\x1b-u\xde\xbf5\x83\xbb3\x06i\xf4\xbf\xac\xe1a\x13_,\xfe?\x82@\x93\xeftu\xf1?\x16\xd7\x17Z\xe0l\xc3?\x0fd;\xa3\x0e.\xe8?B\x83\xb2DN\x1e\xf7?\xbeK\x12Tn\x98\xcf\xbf\xfe\xf3\x9aTz\xd2\xc4?k\xa8\xab\xb1og\xf9\xbf\x8aq\xfc\x17\x96b\xf9\xbf\x1d\xce\x15=,\t\xc6\xbfp[\xc3\'\x9c\'\xf0?E+\xeb\xd3 \x19\xc3?\xb9\xddB\xd8vT\xfe?*\x8f\x7fd \xa0\xfc\xbf\xf4N[\x8b\xd3l\xd3?\xbe\xd7\x86E\x9f\n\xf6?O6q\xc4\x1f\xd7\xe9\xbf\x8e9\x11`\x90\x13\xde\xbf\xdd?\xcb\xae\xfa\xc6\xa7\xbf\xe6\xc4j\x91Ko\xeb?\x8c\\2\xca\xddY\xb1?>\xc2s\x92\x14?\xe1\xbfZ\xdb\x8f\x95\xaa4\xe8\xbfQ\xa1J\xc3\xa4\xfd\xf2?\xe4\r\t\x93\xa5\xab\xd2?ZV/\x18N\x07\xc8\xbf\xa8`\xd8\xec\x16\xc0\xf6?\x86\xdd[R\xf6\x85\x81\xbf#\xa1\xd5,j\xf6\x01@\xa7\x98\x01\xbe[\xb6\xf1?\x15\x15\xb2\xf0\xbb\xaa\xfe\xbfP\x8c\xa7n_\x9c\xb5?L\xf16\xada@\xe7\xbf\xd5\xf3jd\x02v\xe0?X\xcb0{\x04.\xf3?)\x8f\x87\xf2\x1et\xc9\xbf\tw\'\x08}\xdf\xec\xbff\xa9\xa8\x107\x95\xd5\xbf8\xec^\x19)\xb5\xd1\xbf\xa1\x00HH\xac\xfd\xe3\xbf\xb5\x07}\x1a\x8c\xb0\xec\xbf&\x1e\xfc/\xd5\x16\xda\xbf|H~\x9a8\x9c\xfb\xbf\x18dn\x9fM\xe5\xf3?\xd5vj\xe6\x0b?\xf6\xbf\xcd\xc6/\xc7f^\xfd?\xff\x91g\xc1\x8f\xcc\xd1?\xf8^\xf0\xc0\xb1`\xda?\xfc\xd2Y\xcarU\xcb\xbfM\xa1\xf5L\xc9\xe9\xef\xbf\x8d8\x99\xc1\xeau\xfd?\x05lc\xbd\x05\xf6\x99?E\xfc\x80Ze#\xef?%\xcd\x12\xc3+\xe1\xe9?+xo_(\r\xf7\xbfE\xbaR\x19\xf3\xae\xcb\xbf\xeaD\xef!n\xb8\xe6?\x85v\x02j}}\xed\xbf:\xc2:\xa5`\x10\xf1?3Y\\A\x84o\xf7?iH\xfa4\x0b}\x00\xc0^\xee\xd7;[\r\xe6?\xb4\x8eU\x17\x80/\xd4?4\xb4\xb4\x97\x0c\xd3\xcc?@\xf8S9\x1b\x1f\xc8?In-\x86\x88\xcf\xd6\xbf\xf0\x7f7\x101\xcd\xf0\xbf\x9d\xbd\xde\xe9\xfb\xd8\xf7?t\x03\xe7\x93?0\xf6\xbf\xe1\x92cV\xfc\xe0\xe0\xbf\xa2\xb9D\x10t,\xe9\xbfq\xbc\x83x/]\xe0\xbf\xedl\xb0\xfc\xacS\xe6?xB\x9d\xc1\x1c[\xd3\xbf"\xb3\xcf\xd1\xe6\x1d\xf0\xbf\xa0?d9V\x94\xf0?\xc2\xe0\xd5?\x86|\xca?cx\x8c?D7\xee\xbfT\x17\xa0\x98\xea#\xf0?J\x96b\xc6XB\xfd\xbf\r\x0c~\xac\xa4\x97\xeb?\xec\xe6\xbeh\xb0\x96\xf4?\x96^C-n\xeb\xf1?!~v\x00\xc7\x1e\xf0\xbf\xd9\xe9\xdb\x0f\xdcP\xce\xbf\xc6\x97\x1f\x8ecm\xee?\xd9\xf0&\x99\'\x94\x03@\x100k\xcd\x93\x87\xec\xbf\r\xe7\xd5\xc5\xf7\xa1\xe9?5\x12p\x8b@\n\xf2\xbf\xb6\xe2\x80\xa2r\x88\xd8?~\x8cw\x8a\x13\x8a\xfa?\x8d\xfd\t\x84;\xed\xe3\xbf\x94\x05\x10\r\x9a\xe8\xf3\xbf\x18\xdf\x98$\xf6{\xd6?\xdf<\x94\xbe\x15[\xf5?f\x93\x1aT\'~\xf6?J\xb7\xd8\xca\xd3h\xf1\xbf\x8e\xd8zP\xf9\xe1\xf1?\xc2\x846\xf3{\x8d\xcf\xbfn\x91:r8\x9a\xd3?\x07\xe2\xe9kJ^\xfc?\xea3dO&|\xce?r\x9a\x15\xa1\x9d\xc7\xbd?F\xa5\x84Pz\xa3\xe7\xbf\x80\xd9\x9c\x80_\x18\xc2?8\x08\xb9\xebq@\xe4?F\r3\xd5\x0e\xf6\xf0?M8\xd7[\xc5\xa9\xd5\xbf\x91E\x9e>\x90\xc9\xe4\xbf\xff\xc7\xe8q\xceC\xc6\xbf\xc40\x17e\xf0C\xe8\xbf:\xa7/f/\xbc\xa4\xbf\xd3YC\x8d\xea\xa7\xe1\xbf\xfa\x8eA\x8dv\t\xf3\xbf\xf0\x0bj,\xd5j\xa0?a}{\xc2\x81\x8c\xf4?\x8a\xbf\xd7\x8c\xa6\'\xd2\xbf\x83>\x05\xe0\x08Q\xe3\xbf\x9c\xe8\xbe\x03\xf3X\xee\xbf\x1aUo\t&\xcd\xe6\xbfw[tP4\x8d\x8e?\x8d\x1cyD\x0e\x02\xe7\xbf\x93\xf6\x8b\xe0#B\xda\xbf\xba\xa9{\xdd/\xdd\xe1\xbf\x08\xa5\r\x93\xc80\xb8\xbf\xb1\x7f+zG\xf2\xf6\xbf\xff\x0f1\x8b\xe5Q\x05\xc0\xdbCRe#\x89\xfb?\xf5\xe0\xe9\x1eD\x8e\xf1\xbf\xf1|\x81>\xfb\xf7\xd1\xbf\x01\x9f,\xc4\xe6n\xe8?j\xc3\x1f\xbdP\x0e\xe5?K1\xc0\xfd\rL\xb0\xbf\x95\xf4\x80[]\x8c\xe6?})\xe4\xbcZ\xe5\xf9?\xdbQ\x95\x9fs\xd2\xe9?5\\\xc1\x1c\xacb\xe4\xbfN6\xe5\xbd\xe7X\xe6?t\x0e\x1a\x11\xebl\xd0?\xdc(J\x97\xa4\xa1\xfc\xbf\x7f\x05\xe6\xa2\xb2\xfa\xd6?\x81\xaa@\x92\x8cO\xa4\xbf\xab\x1f\x86\xeaXl\xda\xbf|\x00`\x99\x98\xdb\xd6?\xa5ad<\xa9R\xb5\xbf\x0b\x08\xe9~\xd9\xe3\xe7?\x17].\xe1\xab\x11\xd7?cP0\x03\x07\xe9\xf3\xbf\x0f}\xfb\xb4\x91\xf0\xff?\x03:V\xe4L2\xef?)\n(P>U\xf2?xt\x83\x8c\x08\xe3\xf2?\x0fr\xefP\xe7\x15\xf1?\xb1\x0f\xa8\xa7\xc2\r\xd4\xbf\x86\xe5\xc5\xf5\xf9V\xcc?\x89uXF\x1cR\xe4\xbf\xecsq\xc0\xf0\xf6\xf1?\xf5(\x890\xff\xe0\xec\xbfV\xd8\xb7_r\x14\xd3?\xf7Bt?w\xae\x04\xc0\xe9\xfd\xeb\xf1\x8e|\xc5?6\xdf`2\xd9 \xf5?\xa4o\xd2\x8d\xb6\r\xf0\xbfd\x95i\xfa\xe7\xe9\xe7\xbf\xcb}\x0f\xfd\xc2\xe1\xdd\xbf\x8a?\xd3`\x12\x1c\xef\xbf\x11!\x86\x84\x81;\xd3\xbf\xfe\xfc\x961\xf6\xba\xeb?e\x94c\x81\xaaF\xc8?\x16\x8e\x9ejN\x9d\xf8\xbf\xc4A\xc4\xf8\x90r\xd4?\xec\x9a\xb4\xfa\x81\xde\xe5\xbf4\x9cb\x96\x0fQr\xbf\xbdO#\x00\xa8H\xe7?\xa4\xe2:\x86j\xe1\xef?\x84\xe2\x9f\xfd\xd3\xe4\xf4?\xbd\x013\xc7\xc5a\x08@\t\xed\xa0\x1c#\x8e\xea?:\xcb\xa0\xba2Z\xc5?\x10\xf1\x95)T\x82\xe4\xbf9\n\x81q\x07"\xed\xbf\xd5s\xb1\xaa\xc7\x1e\xe6\xbfk\xcaE\xa0b\x80\xe3?\xc2nw\xca\x9fY\xdf\xbf&\x122\x99G\x1d\xed?\xdb~\x04pL\xb6\xdc\xbf\xb7\xc5\xa0\x0e\x0c\x05\xd3\xbf\x19\xe8\xdb\xbdA\x08\xe0\xbfD\x96\x81\xc9|\xda\xe0?\x1f\xfb\xf4\xb6\xdb\x14\xe5\xbf^\xa4\xf4\xb5\xe1g\xf7?\x97\x18[\xadt\xe0\xe5\xbf\xd8\x93r\xb5\x92\xcb\xe5\xbfg\x8f\n\x0c\xa8\xac\xe8\xbf\x05L\\\x84\rD\xe3?62\xf7\xff\xac\xf3\xc3\xbf\x83\x0fNu\xd8\x16\xdf?\xc6\x1c\x1c\x03\xc6\x06\xd7\xbf\xae.\xa0\x8dw\x1e\xe3?\x87\xd2\xce\x95\xdbS\xee?\x16z\x1b~\x9d~\xf7?\xcf\xe8\xed\xc93\xe5\x93?\xa2\xde\xc5\xb3\x08/\xd1?\x15R\xa2}f\xcd\x9f\xbf\x8d\xa4\xc6E\xb2\xd2\xd5?\x1cB\xb7\x8e%`\xc9?\xa8\x17G\xf0\x12\x9b\xd9?\xdbT\x98\xf6\xc2\xe8\xe1\xbf5`GC\xac\xf6\xb3\xbf\x1a\xff\x0e\xa4\x1d\xad\xfe\xbf\x12)\xdd\x8c\xcc\x82\x96\xbf\xb1\xc62\'\x07\xbc\xf2\xbf\x8f\nIen6\xfe?p\x11-f%1\xfa?\x92\xf6\xa7\xdaT4\xe6\xbf\xbd^\x89\x9a\x1f\xc8\xd6?7\xd3\xca\xc6\xe1-\xec?\xd2\x9f\x19\x05\xc3\\\x00@\xee\xa5\xd9`\xa7\x16\xbc\xbfL\x01\x84\xbeN\xec\xd8?\\\xc6\x92\xbc\x8d\x0f\xf2?\xf4K\x08\x115\xea\xd0\xbf\xe4&\xddc.\xd5\x98?R\x9e<\xb8A\xb4\xb4?\x8b\x0bHE\x89\xa2\xe6\xbf\xa5\xf7\x9e"\xec\x86V?\xa2\x02\xc0j\xee\xc3\xd6?\xd9\x08\x19\x9fj\x03\xd7\xbf&\x86O\xd9\xab\xce\x00\xc0\xed\xca\xe5\xe2\x98\x94\xf4\xbf\xeb\xcc\x16\x0bFk\xd2\xbf\x98\x06\x18\xe5/\xa6\xd7\xbf\xcf\x0c\xb2A%R\xe7?\xbe\xaf{q\xb0v\xf3\xbf\x8dJ\x11C[3\xf4?\xebZ\x0e\xed\xd7$\xd2?}\x82\xf7ye\x92\xfa\xbfJ\xed\x8d\x7fg\xfe\xca?[O:V\xe1Z\xf7?\x91\xd4n\x1c\x95*\xb4\xbf\xa8\xcf"ph\x89\xdb?\xd9\x12\xd2\xdb\x8c\x0f\xd2\xbf\x9f\xff\xa5/\x98 \xf3? \xe5b\xe3\xef\xc6\xf8?\xeb\xb0e\x89h\x14\xfb?\x8c\xe4"f\xb9j\xd5?iP\xcbX\xf8\xcd\x06@C^\x1b\xcd\xb8U\xea\xbf\x8d\xe6\xe2V\xad\xe3\xb8?s\xba\xe1?\x99g\xaf\xbf\x8e\xa8_%\x85#\xf7?/\x9fyh\xfd\xc7\xd3?~\xb0^\xaa\x9a\x0b\xf2?\xb4E\xf3o\xfe\x13\xf1?\x99`\xd1\x84s\xac\xf1?\xdc<\x03S\xf7e\xe8\xbf\xde)Rc\x13\xf7\xd3?\x0e\xca\xf5\x04\xa5\x8a\xd7\xbf;<($)\x0b\xf5?}\xb1\'\xde@C\xd4\xbf\x9c\xf4r<\x80\xe1\xdb\xbf\x88b%\x01\xb6\x8b\xfd\xbfmg\x9b\xd3c\x90\xfb\xbf\xef\xde\xe5\x0b\x8e\xd3\xf8?}\xfbx\x9a1Q\xf0\xbf\xc1\xd5\xca\xe3<\x1e\xd9\xbf\xc1\xd5\x13\x82\x1f6\xdb\xbf\xc3v\x95<\xe3\xcc\xd0\xbf\xd6\xe5\xc8!\xa78\xe8?\x10\xf7\xf7\x8a\xb9\x1f\xb5\xbfW\xc8\xcd\xd0\xcf)\xf0\xbf\xa4\xe4(\xd6=\xfd\xeb?\x17\xce\x85"a\x18\xb6?h\xa0\t\xf0\x83f\xb5?\xaa\xea_I\x8bU\xa1\xbfH6z9=v\xd5? \x8eI[\x8d\xa1\xe0?\xf1\xcf4\x92\xc6\x95\xea??\x11\xe9A\x18T\xc2?\x0c\x12\xbd\xa7\x80<\xff?3!k9!\xe0\xdf\xbf\xda\x94\xfdv\xc1\x81\xb3\xbfi\x80\x1fF\xd9\x87\xf5\xbf\n\x95u\x8b\x08,\xd3?\xfd8\xbc\x89\x91z\xdc?h\xa6v\x0b\x83\xaf\xe7\xbfse_\xe4\x7f\xd4\xce?/j\xd0U\xdb\xac\x9d\xbf\xa3T)\xa9\xee6\xf5?ETi`\xeaW\xfc\xbf\x12\xcd7w\x84U\xdc\xbf\xcb\xe0\xd8/.\x82\xe4\xbf\x99\x98\xfcL\x9b4\xeb?]\xf1\x9bT\x07\xe8\xe0\xbfQ\xab\x81\xb9\x8c\x1c\xfa?K{=\x85\xf5E\xa7?\x16\x86\x15\x8bU\xef\xc3?)@\x12\x0c-\xf6\xf9\xbf\xaf\x13\xa4\xb5\xaa\xe0\xde?\xa7\x1b"[=\x96\xe1\xbf6\x82:\x9bg\xd8\xf6?B\x93\x95\x00\xb64\xdc?\x06mm\xe5\xeb]\xeb\xbf\x9d\xa9\x94F\x86\x05\xe2??d:\xc3\n\xb3\xcf\xbf\xdd\x8f\x97\xf7\x87\x0f\x08@\xacQ\x1el\xd4\xd3\xed?\x1f\xc3gv\x0c\xe2\xe6?\xc8\x00\x01\xb3\xb3T\xf1\xbfu\xe5\x0b\xa8 \x16\xfb?B\xaeE\xc8\xeb\x96\xdc?\xcfJ\x97\xaeC\xe9\xbe\xbf\x95\x00,\x13\x8dJ\xdd\xbf=\xee\x8b\xc3\x87\xcf\xe0?\xbf\xd9\xe3<\x87b\xe9\xbf\xb29~\xbd\x86a\xf1?\x98\xf8\'\xca\xb5\x0b\xf1\xbfh6\x98QX\xec\xe9\xbf\x07\x0f4\xde\xea\x95\xe8?\xb8\xd2\x86Kc\x07\xbc?Hw[\x83\xa7"\xea\xbf\xdd\x11\xf60\x10 \x9e\xbf\x8a\xe1\rg5.\xcd?Hp\x98\xb4"\x0b\xd1\xbf\xe7\xb9|Z\xc2\x1d\xd3?\x83:=\xef\xb1\xb4j?$\xf5\x9dAL\x8c\xfb?\xb5G\xfd\xec_w\xa9?\xe9\xc8\xa1\xa7\x11\x95\x00@\xb5\xeb\xf5\x1e\x16X\xb1\xbf\xd9\xee&\xd3\xb7\xad\xd9\xbf\x0f7\x95]\xd8\x81\xee?twT\xdc)\x86\xe6\xbf3\xd8\xa45\xdc\xe3\xdf\xbf#\xa4\xddN\xa2\\\xd4?>$\xbc!(2\xe2\xbf\xab\xf5\x00\x16\xe5g\xf1?\xb7i\xc4b\x8b\xa2\xdb\xbfh*g\xbd;\xe1\xf5?\xa5\xd4\xe6\xf3\x83"\xef\xbf\xa3\xeb>\x07\xca$\xd6\xbfxb\x06\xd6\xf9:\xd2\xbf\xb339d\x84\x97\xe1\xbf^\xcf!"\x0f\x02\xeb?\xa6\xa1\xd4}\xd9.\xd4\xbf\xca\xd3\x941\xd2\xae\xd6\xbf\xa8\x99W\x8c7\xd4\xff\xbf\x0c\x89a>a\xee\xf7\xbf\x08B,\x99\x0e(\xa1\xbf0\xeb\x83\x1f\xf7\xc5\x02\xc0|\xb3\xc2\x93\xd8M\xe4?\xe6a\x1a_\x8aR\x01@\xc9c\x0eeB\xf3\xd6\xbfV\xd5F\x8e\xfcg\xd5?\xd6z^t\xf8\xef\xee\xbf=\x14K=\xb3}\xeb?>\x02N\xd6\xd2\x8e\xe4\xbfw\xe0\xe2Q\xd8\xd7\xda?;\xf3|\xa2\x96\xcf\xcf\xbf\xeeb}\xb6\xb1=\xe6?1z\x94\xa9\xb8L\xb1\xbf\xf0\x1e\xa0K1\xb8h?f\xd4\xf3Z\x14{\xf8?\xc3\xcf\x14\xa0\xa7-\xfa?N\x15\xcfiW\xbe\xd0\xbf\xc1/\x7f\xc6\xbf\xce\'\xee\xb3\xe6\xf6\xdf?p\xbc\xa8\xd5\x03\x12\xe3?jQ`\xc2n^\xf1?\x13\xb5\x98\xfb+\xb9\x04@bl\x85\xe8s.\xfe?\xc5_\'\x84)\xa4\xf5?w\xd4JVf\x12\xe3?\t\x9b\xb5E$\x1a\xda\xbf\x8c7\xddxt\xde\xed\xbf\xce\xdb\t3*:\xb1\xbf\x92\x7f\xfb\xd9q\x07\xa8\xbf\xae\x8a]&\r\xd6\xbe?X\xb0\xea\x0b\xa7\xc8\xe7\xbf2\x87\x92\x9b\xf1\x97\xf1?\\\xf5\x03\x93\xf3\r\xef\xbf3@\xc6\x06\x13\x9b\xd6?\xd3&\x01\xc4!J\xe9?\xb1P\x93\xa9\rt\xef?\x87~\x8f\xaf\x07s\xf4\xbf\x0f\xe5W\x0c\x06\x1a\xf1\xbf\xc2\xd2\x8b\x18\x90o\xda\xbfO.rG\x176\xe6\xbf\x85@\r\x1f\xda\x0f\x05\xc0\xb2/{\xb3\xc1\xac\xf1\xbf\xd4Bu\xfasR\xc9?\xfd\x8a\x14\x93\xb2#\xf6\xbf\xec\xa8p\x87\xbaP\xe4?\xacw\x93\xf3a\x96\xe9?u\xbf3\xcc\x05\xb5\x02@\xdc\xd2\xdb\'\xe1\xf1\xc4\xbf]\xca\xf9\xc3\x9e-\x06@T\xe8U{\x04\x99\x0b@o\xbc\n\x8f\x10\xc1\t@Ej9~\x83F\xdc?q8\x07\'6\xd1\xdd\xbf$\xb3rZ\x15{\xe0?\x1b\xa13\x99\xfc\xa6\xf7\xbf\xad\x04\xeb&i\xe7\xed\xbf\xae\xa8\xaa\xe3\xecm\xd7\xbf\xaf\x9a\x19\x0b\x14\xde\xc3\xbfqq\x11z=\xfd\xe4?f\xd2"\xb9\xd3\x1a\x05@\xd2\xf5\xa0\xf7>?\xe5\xbf\x0f\xdbl<\xb1\xbe\xe7?4e\xedM\xa6?\xd3?\xbd\xbcKMM@\xe8?>\x11\xfc#W\xe9\xdf\xbfZ\xd1\x82\xdbs~\xed?\xdb\xa2F\xf5\xa3\xf1\xea\xbf\xb3?cGA\xe3\xed\xbfd\xcc\x91\xa7\x8fq\xd0?\x8dSlO\\E\xf1\xbf\xfd\xffZ\x01\xce\x05\xe4\xbfSYr.8{\xda?\xa7n\xb6\xae\x0f\xb6\xe0?\x8f\x9a\xd1\x89\t8\xf7?\x8d\xa8Y\xefy\x8a\xfe?\x87\xe1\x13\xa5\xfb/\x03@\x0e?\x98YQR\xe7\xbf#\xa3\x1d\xd0/\xfc\xf9?4\x9ac\xcb\xab!\xc9?j\xaa\xa8,q.\xf1?\x01A\xae\x1e\x06\xa5\xf6\xbf\xf8\xfd\xa2?\xd6\xc6\xd8\xbfn\xd3\xe4\x80\x1cI\xf5\xbfC\xa0\x9c\xea\xa9\xd5\xd6\xbf7\xb2!\x81\x00?\xca?\xf0B\xb8\xcer\xd8\xd1?\xc01\x1a\xd7\xe7\x97\xf4?4\x19\xb9\x03\x0e\x0b\xc5\xbf\xa9\n\xd6\xc7\xf7\xad\xf6\xbfg\xf4\x83\x8dz\xa8\xe2?\xa0\xfb\xb1z\x0b|\xd3?f\xe8X\x1d!\xa2\xfa\xbf\xdb\xe9\x90\xb3\xf5-\xe6\xbf\x89?\xad\x13\x83\xc3\xfe\xbf\x99b\x97\xfaS\x00\xd1\xbf\x0e\xa1c\xeakk\xfc\xbfm\xa3\x18\x1dG-\xdf\xbf\x8es\xb5\xe5>\x1f\xfc\xbf\xe3\x91\xb3B\xd4d\xef\xbf\x92\x1fV\x81\r\xfb\xe5\xbf\x9d\\\x80\xbaA\xbe\xa1\xbf\x9d0o\x83\x98V\xf1?\x8f\xc6\xb5\xf1\x88\xf4\x02@N\xd8<\xe8u\x0c\xe2?j\x02Hq\xadB\xd2?\x8f\x99\x19\x8fZ \xf4?m\x11\x99\x13\xd3|\xa6?\xe1\x8dj\x9b\x87<\xe4\xbfi<\xdb\x1d\xbe`\xf3\xbf\x14\xdb\xdf\xfdg\\\xe1?\x81\x1e\x8c\x87\xa9\x1d\xda?\xd2]hc\xec\xbf\xf6\xbf\xe7\xa6<\x1fJ}\xf0\xbf\xe7)\x01\x04l\xb9\xe3\xbfaf\x9f\x86\xbd\xc0\xe3\xbfD\xc8\x94\x90 \'\xd8?\xb2\xd5\x99\x1f.\xc7\xeb?/\xe9i1H\xe9\xd5\xbf\xec\xee]\xe4\xda2\xf4?\xf27z\x06\xdf\x0b\xcb?p\x8b\x15\x8d\xd7u\xf2?\x1d\xe3\x9b^\xe2\x03\xf3?@\xadA\x86s\xd2\xf6?\xd5\x85\x82\x9d\xdb\x88\xf2\xbf\'f\xc9\x81\xc8\xb4\x02\xc0\x08\xa7\xd7\xa94!\xf6\xbf\x92qI[:H\xff\xbf\xd6~\xe8\xc5\xc6`\xe8?}\xeb\x0ebP\xa2\xe2?\xaeZ)\x12\x05\xd5\xf8?y\x18u\xceE\xbf\xf0?\xfdD\x87v\xbe\xf9\xe0?v\x1d\xbfW\xd5s\xe2?*\xfc\x82v6\x15\xf7?\xf3\xb8\xb7\x0f7\xab\xb8\xbf\x86\xe8%\x97o\xc7\xf1?\xf4\x14Eht\xd3\xec\xbf\xfe\xa8\x86\xbb\xd0s\xe6\xbf\x0b\nG\x14\x01\x05\xe1\xbf^\x86\x13\xc1|C\xfd?\xf8B5\xb2\x15\xd5\x00@\xaa\xb4\xacl\x008\xcf\xbf#\t\x8b`_\x14\xdc?5\xdfK\xcdw\xb4\xf4\xbf\x02\xaf\xb5\x05@\xae\xfa?\xediy\x1do6\xf7?T8QW}\x11\xca?\x086%\xc5-o\xea?vd\xc9\x88\x06\xe7\xdb?H\x0e\xb54S\xb9\xc5?\x1a\xc0\xa4f\xec\xd6\xf6\xbf\t\x0cp_\xc1\x89\x92?%Y\xe0\x8d\xc0\xd6\xb6?{\x99*\x91d(\xa8?_N\x07\xa4\xb1\xce\xe3\xbf\xb4?6\x10\xe8|\xe0?<\xcaT\tM\xed\xd6?\'I4\r\xd6\x02\xac\xbf\x1a\x96(GII\xda\xbf\x18\\1\xae9\xb1\xfc?\xceu\xe6\xec\x88a\xeb\xbf\x082p\x8a\x02K\xe5\xbfr2%k\x9e\x87\xdd?\x1d\x1b\xc8\x87\x99\x90\xdc?\x9ahj?\x9ay\xe3\xbf\xbcH\xb4I\xc96\xdf\xbf\xd0&9U/\x1a\xeb\xbf\xebM\xb3_\xe77\x00\xc0\xcf\xa2\xc9\xe6\x91/\xef\xbf1\nFk\xe7&\xe8?\x9d\x07\x8d|\x17R\xce?\xb6\x1e\xaa\xecD\x98\xa7?\x07\xb2jQ\\R\xfb?wSE\xdc\x15\x16\xbc?\xbaz\xdb\x9a\x04\xeb\xeb\xbf\x88q\xfft\xb8q\xd7?\xb3"I\xd3_X\xe6\xbf\xa0d\xf9\xa2\xbd\xde\xde?\xda\x13\x82\xa0\xf4\x0f\xf8? \x1f#T:\x08\xe9\xbf\xae\x80\xa8\x9e\x8e\x1b\xc6\xbf|\xe4\xf5\x99\xf9:\xe4\xbf\x0f\xf5\xbd\xab\xbd\x8e\xa2\xbfB]N\xba\x99\xfc\xf1\xbf\xb8\\\x16=\x93\xa3\xe0?\xdb\x87\xaa\xe4?\xe0\xe9\xbf\x18\xe7\r\xf6@j\xe9\xbf4\x1e\x8aoW\x05\xd3\xbf\x9e%m\x809\xff\xd7\xbf\xfe\x86\xc8\x13\x9fM\xf6?\x94\x81!VX\x11\xf9?^\x7f4\x17=,\xda\xbf$\x03S\xee~}\xd1?E\xd1+jG\xe9\xf0?\xcc\x18\xc2\xd6\x11\x97\xc2\xbf6\xf5\xb3\x88\xe9\x89\xec\xbf\xd0\x94\xed=\x14\xf8\xd8?jn\xd6\xf4\xf2\x03\xd7?:\x91\x7f\x90t\x85\xfa?\x98\x9d\xc8\xd7\x1b\x1e\xe3?o\xd3\xb9Gu1\xe5?Tg\n\xc8\xd7P\xfd?\xf8N\x12*\xc18\xf1?L.C_\x06\xfb\xd3\xbf@\xad\x06\xb7\xd9\xb7\xce?\t\xd9\xcdh\xed\x19\xed\xbf\xb7\xd6!\x99\x1el\xf9?\xe6\x02n\x97\xfeq\xf0\xbf\xb6`\x18\xd4\x8d\\\xeb\xbf\xaf9]R\xdd\xd4\xc4?\x02\xb3\xe6\xa4\xbcQ\xe1?Z\xc3\x86K\xadU\xf6?\xc5\xe1\x9a\xb7\x84\xa9\xfe\xbf\xde\x85\xe9\xe8aZ\xd4\xbfiNO\xbd\xb0\x84\xe1\xbf\xb8a\xc3\xderK\xf8?\xea\xb8\xb9G\xfa\x87\xea?\x0e\x81\xfdY\x06\xc5\xf9?\xf8SC\x8e\xd1"\xff\xbf\x0c\xc9j\\\xac\xbc\x03@\xb2bg\xa1jA\xe2?\xfa\xf4&\x1c\xc7\x14\xf1\xbf\x8e\x8f\xdb\xab\x89\xb4\xc9\xbf\x853\x07/\xab\xaf\xd3\xbf\x87\xb6\xd9\xfa\xc2\xe7\xed\xbf\xe0\xe7A\xb4\x8e\x93\xd8?AKO5\xb2!\x98?\xdda"uZ\xa3\xcb?\xdcl=\xce\x1b\xf7\xc1\xbf\x14\x148\x07\xaa\xf4\xc6\xbf(\x1f\xe3\x8e1\x0b\xfc?\xcf\x7f\xae\x9f\x80\x12\xd2?\xdd]\xe9-\xe4xx\xbf\xdcH\xdc\x95\xacX\xd7\xbfO\xfaF\x91q/\xfa\xbf\x8f\x01\x19\xd4\xce\xf5\xfc\xbf2\xf0R^\xe5#\xe3\xbf\x1b`\x12\xab\t\xd7\xe0\xbf\xe5\xd3zt\xec\x06\xd0\xbfG\x8b,\xadT\xaa\xf1?\xc1\xbd\x07\xb0\x8ag\xdb?6\x01\x05\x07\x1e\xb2\xee?\xd6\x8b\x17x]\x7f\xf4?\xd5\x96\x9cE\x13\xa4\xea\xbf\x04\x95\x1e\xf0\xe4z\xdb?\xe5 l\xa9\x82-\xd9\xbf\xbeq\xca\xf6|a\xd7\xbf\x8bB`\xb5R\t\xf6\xbf\xc1\x12x\xdc\xe7\xcc\xf6?\x95\xf3hzDh\xd9\xbfx)\xfa\x10\x07\xcb\xf0\xbf \x08\xb9\x1bs\x03\xf1?\xfe\xb2\x82\r=o\xd2\xbf[H\xe3\xa1\x94?\xf5\xbf\x14\x9f\xf7\x13I\xd1\xf7?B\x19Lt\xb7\xbc\xe1\xbf\x83\xb5cg\x87\x19\x85\xbf\x84?\xa7L\x0b\x98\xf2?\x86Y\x84\xfe\xc1\x9d\xc1?\xabV\x01qGw\xb7\xbf\xfeg\x1f\x14\xeb\xaf\xd7?\x8b\xbc]-\xa8\xc8\xf6?\xed\x03r\x94;\x93\x02@s0D\x06\xa9\xc1\xe1?\xec\x9f\x8dg\x9ca\xa0\xbfH\xad\xebF\x1e\xbb\xc9\xbf\x93B3\r\xa6%\xe3\xbfy;J:\n8\x00\xc08\x92\x0c\x15y\xaa\xfb\xbf$\x13{E\xb6U\xe5\xbf\xe5\x05\xdc\xd8\x98\x9b\xe0\xbf-VY\xf7;x\xe7\xbf\x07\xf6P2\xf2\x07\xf5?\xa7\xd0\xfb\x9ca\xd9\xd1\xbf\xfa#\xe1Y\x90\xb6\xe3\xbf\x85\xd0c9\xc0\xc8\xdc\xbf\x04|\xa3\x0f"x\xee?\xc0{\xdb\x02>R\xd6?\xc9\xab\xe6\xael\x8c\xa9?\xf3_0\xf9\xaa\x95\xd1\xbfh\xe0\xd4Ra=\xb2?\xcc\x90|\xa0\xc1m\xbf?:&\x9f\xbdH\x1a\xfd?\x93F\xa3+\x94G\x06@\xfdg\xd9vMV\xdf?\x00mn\xf6\xe5\x94\xe5\xbf\xd4T\xb9?\xf0S\xe2?\x86\xa7\x87\xe9\'h\xf0?\xf1e:\xd5]\xf9\xe4?\x8bb\xcdD\xef\xd6\xf2?\x97\xe6\xab\xe3a\xa9\xeb\xbf\x865\xe4\xf9\x89\x81\x81\xbf\xa0Db\x0b\xa2\x13\xbe\xbf\x80\xc3;\xbeo\x97\xe6?*`\xd1\x9a\xab\xfa\xf5\xbf\xd7\xdf\x0b\xf8\x18\xea\xca\xbfO:vMa\x86\xc9\xbf\x0b\xdc\x9454\x1d\xf3?g\xdeO\xc0pO\x00@[D\x98E\xf4\xf3\xed\xbf\x9d\xe1\x1f\xe6\\h\xe4?:\r\xd6\x98\xa42\xea\xbf\xc5N\x84(qc\xfe?\x93c0\x81oZ\xdd\xbf2^\xbc\xe8\xb5c\xe7\xbf\x1b\xd8\xebG\x18\x10\xee?\xca}\x7f\xa7\xc6"\xf7\xbfM\xc4\x08~\x82t\xef?\xbc\x0c\xcd\xc4\xbf\xe2\xea\xbf\xd8\xe57\x81\xf9\xfb\xe4?\x85\ni.\xe1\x81\xf4\xbf.0Ss\x9b\xbd\xdf?Ot\t3s\xc3\xf2\xbf\xc6[2\xd8\xbb\xac\xf7\xbf\x03\xa0\xeb\x8a\x8e\xcb\xf1?\xb3\xb7\x1a_\x8a-\xe9?\xd8!m\xd4f\x86\xf2?\x90\xdax\x96{\xaf\xaf?r\xf2\x91FW\xb0\xa8\xbf\x1d\xa3\xa1\xc3\x96\xe3\xef?uS\xe17\xd9\xaa\xe2\xbf(M\x05\xab=\x1e\xca?\xad\xe4\xf6\x03\xc2*\xf6?`F\x17x09\x00@\xed\x9f\xc4\x89\x9e\xa1\xc2?\xca6\xe8\xedl5\xe4\xbf\x16\xef\xed\xb4\xd3\x08\xef?y\xeb\xe5tj\xdb\xf0?\x88\xfd)n+\xe7\xf6?{\x86\x8dC\x93+\xf5?jv9\xeb\xd3\xaf\xfb?\x97\xedm\x13\x93\x9f\xc2?c,\xe5\xf4\xb54\xef?d\x99\x1b\xb7G\x98\xda\xbfx\xda\xc3\xbb\nP\xd8\xbfn\xc9d\xdd\xb7f\xdf\xbfj`@iO\x96\xe9\xbf+\xca\xa5pRp\x01\xc0\x81\xa4p\xaf\xfc\x82\xde\xbf\xd0\xd9\x07 w\xb1\xf0?~\x93;\\tY\xf3\xbfh\xed*R\xbc"\xa9?\x1c\x00\xe8\xdd\xdd\x1d\xeb\xbf\x8f\x00\xbe\xdb\x99Y\xd3?\x7fIP\xbf>,\xf0\xbf(\xc7\xf1CJ\xe6\xf8?\x9b\x1d\xb6\xb2\xdc\xa0\xf9?\xe2e\xfb<\xec\x98\xdd?\xd5\xd4\x96\xfb^\x99\xf1\xbf\x19C}\xd3W\xcc\xd3?q\xc5\xbed5\xc9\xe7?\\X\xd7\xaa\x0f\xc4\x00\xc0\xfe-\xccH_5\xc6?U\xb4$vG:\xc5\xbf\x02\xa7,\xc4\xf4\xbd\xd6\xbf]#\xed\x8a\xa4\x82\xb1?\xdf\xe5\xc7a\x85m\xe0?\xd8{\xd0"\xa4\x1e\xf7?\x9a.(\x16\x1e\x1c\xc0?\xad\xb9@\x7f\xb6\xfa\xd4\xbf:\x10Y\xdcfi\xf2\xbfk\x00b\x04,\xf0\xf4?\x1b\xb1.\x06[h\xe5?]\xbbu\x1c\xd0_\xf9\xbf+6\xfd5I\xe9\xf7\xbfH\x06\x9b`o\xc9\xfb\xbf\xc551\x16\xbb2\xed\xbf\xd3\xd7\x82U\xbdd\xf7\xbf\x7f)D\xaf\x13\xb8\xc9?vIuu,\xf4\xb5??\x80%\xbf\xc6\xe7\xd3\xbf\xae\xc3\xf1\xf7q\x8d\xfa\xbf\xdb\x98{w\xec`\xd0?y\x90\xb0\xf3\'^\xe5?\xa1(\x807\x04\xbc\xf6?\xbc\x83P\'\x98\x93\xe2?\xda\x1d\x89<\x12g\xc7?\x9a)\x9bH\xaa\x04\xd1?\x18\xbd%\xab8\xe0\xb4\xbf-Nu\xb5\xc2\x17\xf9?\xf2T\xf8x_2\xd5\xbf\x11\x8e\x1c\x94U\x85\xe3?\xd6M\xce~\'$\xf6?1C\xfb\x9b\x13I\xe5\xbf\xe7\xf4b\xb0\xbcC\xf0?\xe6\xb3\xb7\xdb\xa7\x9e\xf8\xbf\xc4"H\x8ck{\xec?\xa9\x8f\x16\xf4\xaeI\xdf\xbf.b;\x18,\xaa\xf1?\xe4\x05s;\xa8\x89\xe6\xbf\xfbb\xb0\xd3\x1e[\xf4?s\xa4\\\x9f}\xe1\xd4?\xda6\nCI\x1f\xe6?l\x115\xdct\xcd\xf6?uV\xe2\x8c\xbe\xe3\xdd\xbfX\xf5\xa0\x1ca\xb8|\xbf\xd7I\x01S\xd8\x91\xfc\xbf\xc6\xb8\xd1\xac\xa6>\xd2?0\x87\x03\xa3Y\x93\xfb?\xae\x8e\xd8$\x995\xe5\xbf\xae,\xb4\xe3O=\xf2\xbf\x13\xdf\xba\x1b}3\xda\xbf\x96N\xf9\x84W\x83\xfa?\x98\x14\x03\xc3\xe6&\x08@\x81\xcf\xe4\x99B\xa1\xe9?\xe4\x07\x08\xa9\xa0\x0b\xf3\xbf\xe4\xf1\x0f\x1eT\xc4\xf7\xbf#\x1f\xc0o|6\xd5\xbfa\xa4\tZ"e\xdc?\x96\xdag\xa6@o\xef?2\x07i\x05\xb5\xed\xfc\xbfH\xba\xc3l\xad\xbe\xe5\xbf\x8cX\xfa\xf6\xa6\xeb\xee?-{\xef\x8dY\x86\xd9?\x8e\xf1!#\xd8\x93\xdd\xbf\x8b\xd3x?2\xe2\xf3\xbf\x88#\xe5\xb4\xff+\xf2\xbf\x9c0\xec\x17\x1b\x0f\xd7\xbfe\x86\xd2\xe1*V\xf4\xbf\x07\x80\xdc\xd5\xb6\x00\xc2?U\x89`\x8b\xb7\xe7\xf1?\xc1\xe1\xf3nP\x89\xe1\xbf\xc7d+\xbd\xa7\xa8\xdf?\xe7\xca\x04I\n\x1e\xef\xbfg\xac\xbe\x1e>5\xcc\xbf\x1e\'\n\x8c\xb4\xf9\x06@*\x14b\xe2C\xe8\xfc?\xff\xc26\x96\xecE\xe5?\xc5\x9f&5\xef\r\xd1?\xf1\xfbm\xb2\xd8)\xe0?\x19b\x11\x94)\xa2\xf2?\xd1~\x90\xf0{\xe0\xef?f\x99\x03\x7f\x8eI\xfc?\x84\xe4<\xd7\xe3\x8e\x01\xc0\xa9\x1fy\x94`q\xdc\xbfb\x06\xbdc\xd8\x07\xe7\xbf\xca\xafy\xeb\xceI\xe3\xbfg\x9b\xa9\xf8s\x9a\xf5?_\xe2\x8d\xd9\xbe\xa7\xe7\xbf!Zp\xbc=@\x00@\xcb\x06\xe1\x91\x0c\x92\xf4?\xd4q\xc3\x1eu[\xce\xbf\x0eyH\x96\x04:\xf3?\x16P\x01\xd4\xbb\x99\xe1?\xc5*\xe1\r9{\xfb\xbf\x89;Q\x18\xde\x15\xf7?\\\xa8^!\x99J\xc8\xbf\xb8\xda3\xa1*\x91\xe3?t=\x84\xeeC\xf2\xd8?9j\x8b\x81\xf3\x8f\xe3\xbf\xd0\x04+\xcfcv\xf5?\x12\xd2\xd6\xb8\xfb\x12\xf4\xbf@\x97\xfe\x10\xf4\xf1\xd1?\xd5\xdc\xe9h\x86i\xeb\xbf:\xff\xd0\xec\xcd\xb8\xdc?\x04\xbcBivl\xb2\xbf\xe1\x15\xf5\xdf\xc7\xe1\xe4\xbf\x02\x90g\xf9\xab=\xf1?\xb5\x8cj\xe9\x10\xb1\xe1?\xbe\xdd\x8a\x8eJ\xfd\xfd\xbf\x90*\xa3\x13\xd4\xe0\xd8?\x84AE\x7f\xf3G\x96\xbf\x8b\xa9d\x86Z3\xe7?X\r\x01\xae\x01\xbf\xf1?\xb0\xefD\x8a\xe9.\xb2\xbf\x836!M\x7f\x8d\xdf?\xd0\x8b\xad\xb6\x91\x1a\xde\xbf\x94xy\xc7=<\xe3\xbf\xa5\r\xec\xea\x13\xb1\xf4?|\xec2\x1all\xc7\xbfo!\xa2C?c\xf1\xbf9\x82`\xc0vW\xd1?:\\\x99j5\xb9\xf2?\tScmL\x06\xf8?\x05\xc5\x1f\x0e\xed\xdf\xce\xbf\xcd\x17\xb0\x9c\xa4k\xe4\xbf\x08\xd3\xe4q\x16c\xee?\xbb\xd9;\x02\xae.\x90?\x8b\xa9^\xb9\x8c\xd4\xf3\xbf\xe0\xe5\xc4\xeeY\xbb\xe3\xbf/\x84N\xba\xdb\xa2\x00\xc0Q\xa8\xf6\xc5&\x80\x8c\xbfc\xd5:&LP\xee\xbf`\xf2\x88\x18B8\xdc?\xfc\xc1P\xae5\xbf\xe0\xbf\xffR\xc5M\xd9i\x94\xbf\x92\x1bs\x9bb,\xe9?\xa1\xc0\x11\xf7\xd4\x1c\xe7?M\xfe\x98\xdd3\xb3\xee\xbf5.\x91|!\xc4\xc8?,<]\x9e\x04K\xe6\xbf\xacI\x997\n\x8e\xf2\xbf\x17\xcd\xb33\x9e\x9b\xd9\xbfo\x1e\xfd\xa9r\xf1\xf7\xbf\xe5\x9a\x17{\x87\x1b\xf0\xbf9:\xf7u\x92\x87\x00@\xd7\x87=\x0b\x87\x08\xef?\xe0\r^O\r\x8f\xf0\xbf\xb6\xb2\xa6$G`\xd4?\xbd\x85\x11^x2\xcc?\xb1$\x1c\xfd\x14\x8f\xf0\xbfPq\xe9\xb8\x84t\xf7?x\xb4\x10\xde\x82\r\xe6\xbf\xc6\\I\xe0,\x01\xf3?\x0bJ\x0c\xb3Ln\xdf\xbff\xd0\xdb\x0c\xceo\xf6\xbf\x06;\xdfO%\xcd\xf6\xbfE4\x1d*\xce\x9d\xeb?\xe8\xff\x97\xb6\xe2\x18\xd6\xbf\xd9\xdd\xa7Z~z\xd5\xbf\x01_\xa7)\x1a!\xcf\xbf\xa2]X6\xb7\x8d\xdb\xbf;\x97\xdf\x9e,#\x02@\x89\x9cF9\xed5\xed\xbfkO\xcf\x88\xbee\xef?\x06(\xba\x17\x90*\xef\xbfLI%\xa5\xbaj\xd4?\xc3\xea\xa0\xb6\x8b\xa8\xf2\xbf\xe9\xaf+A\xbel\x87?\xb2\xdb\x8f\r\x9b\xb1\xf9\xbf\x97xH\x88\x8eW\xc5?l&\xae\xbfL\xa6\x03\xc0"}\x9e\xc4\xa0\xd2\xf4\xbf\xcc\x193,\x08^\xe7?\xea\xa8\xcc\xdb\xd3\xd9\xe8\xbfG.6\xcei\x01\xd1?p\xf8E\x02\x07c\xea?\x16\xf2\x1dr\xbaE\xf6?\xba\xfc\x03$$\xf8\xe1?7\xcf\x93\xcc\xe8\xa4\xe7?\xb4\xcd\x98l\xb9 \xd4?\x10\x07Q[>\x98\xf5?\xa2\xed\x93\x05\xed\xad\xf3?Z\x91a\xba\x80\x80\xed?\xa6K\xac#50\xea?\xc7nMB\xc6\xe0\xe9\xbf\x9dL\xe1\xa8\xeb\xd3\xe6\xbf\x05\x8dx\r\xe8<\xf3?u\x84@\x1c\xa1\xdc\xf2?KW\xa0\xe1e@\xf9\xbf\xb1Rp\xf0\xef\x0f\xe9\xbf\rP\x8bq\x14\x81\xdb?\xfb<\x1e\xe3\tG\xb0\xbf\x1cIN\x19\xf5\x9f\xf9\xbfRI\x8aO\x91\\\xf7?\x87z\xc8\x12\x1f\xe8\xea?\xee|\x03\xf6\xf9\xa6\xf5\xbfR\xa3\xc6u\x8a\xd0\xd3?\xd3ma\xd4K\x90\xf1\xbfbK"\xd4\xa6\xeb\xd6\xbf\xab\xf4\x7f\xb1@\xd1\xd8\xbf\x84\xa5O!\xd8\x9b\xe2?h \x8c\xd7B\n\xd8?&\xdfp\xcb\xda)\xe6\xbf\xc6\x00\xb6\xf3\xde\xce\xc7?\x11\xd1\xbf\xee\x1au\xed?} \xb7\xdc\xf3h\xf0?\xd4$\x0c8\x0b\xf7\xf1?v\xe8\t\x15w\xef\xe4\xbf\xc7\x10bX*\xfc\xf4\xbfE\xf9\xae\xcd\xae\x9c\x93?\x15\xf7\x1b\xed\xd5\x05\xc8?\xf1\xc3\x00\xbf\xf3\xed\xf2?ddc@!s\xf4?\xef\xac\xa9T\xe1\x9f\xe5\xbf\xcf\xe9.\xf8\x81F\xe6\xbf\x06\x11N\x03l\x06\xf0?.p\xcb\xf7\xbc\xaf\xfe\xbf\xb2\xfaB\x8f\x8e\x8f\xce?az\xce\xfb\x80\xe5\xef\xbf\x11l\xf8\x1b\xf8&\xc2\xbf\xfa\xa5V\xe9\xee\x17\xc5?\xece\x163\x07\xbf\xf8?\xd0\x1c-\xadP\xaf\xec?Q\x85\xe5\xc4\xd0\x97\xf4?\xf2)H\x8e[\xf9\xf1\xbf\xe8j\xf3\xa3O\x07\xd2\xbf\x87\x05\xa8\xcfD\xfc\xf9?\xe6\xa8:\x90/\xbb\xf8\xbf]6\xb7;\xef\xc7\xe7?\x04\xd8P:\xaas\xed?\x8e\x0f\x99<\x94\xc7\xda?W\xcf\xca\x81\x97\x0c\xe4?\x1fq\xea\x17\xba6\xef\xbf/\xfa\xa9\xe5\xe5+\x00@T\x9a*\xf5\xee\x7f\xcf?\x10\xc7(\x17\x8b\xdf\xb5?\xc4\x9e\x84\x83Q\x98\x98\xbf8\x15%\x84\xf9\x1a\xb6\xbfI\xc7\taj\xe0\xf2\xbfGA\x92\xa9\x8eu\xf1\xbf\xd5\x00\xad=!W\xd9\xbf`\x8d\x99\x0c\x00>\xe3\xbfJ\x9a#\x83\xf2[\xf5\xbf\xa3\x14\x13\xfd\x05\xc0\xfa?\xbc\xb1$4\x81\x13\xf8?\xa53\x8d\x91\x81\x8e\xbb?\xbc\x03\xdaq%m\xf8\xbf!=\xa2\xfe\xf2/\xe1\xbf\xc2\x0b\xbc\xd3\r\x13\xf9\xbf!2\x03\xe4\xea\xd7\xf1?2\xc2k\xc3Y\x86\xfc?\xf5\x08;\xe1ZL\xea?\xb0\x8f\'h\x92\x8a\xf9?\xe2\xec\xd0\xba\xb7\xc7\xf0\xbf\xbb\xe6Z\t\xe3\'\x03@n\xe7BWn\xf0\xfd?\x13\x0b\xab?\xe8\x8a\xe4?\xe4\xe0\x14\xcd~\xc3\xf5?\x84\xe9\x9e\x1a\xc7\xe1\xfb?%H\xb9j\x0e?\xc8?ac7\xf1\x89\x93\xf6?P\xdc3u\x15\xd5\xe5?\xbe\xa4\xe6w\x90\xdc\xf4\xbf\x8e\xe1\x9dQ\x18d\xd8\xbf\xfa\x8c/\x97~1\xf5\xbf^\x9c\xf9\xee\xc5\x07\xe3\xbf\xc8\xbbRMZY\xdd\xbf\xd5\xeax\xdb\xaf\x0b\xeb\xbfrp0\x07[\x0e\xd3\xbfw\xf67\xf9\x18\x05\xf9\xbfN\xaeQN\x1f:\xf2\xbf\xe8\xcay)x\x91\xf9\xbf\xc5b\xb1im\x1d\xf6?\xf4\x05B\x9f,\x08\xd6?\x07F?\xf3\x1e=\xe5\xbf\xba\xfa 3\xbf\xb4\xf7\xbf7\xa75\x17\xb1\x9b\xfa?Z\xa0\xd6\xe5\x00\xeb\xf0?q\x84\xf8u\x03\x8d\x03@|\x1b\xa4\xc0\'\xba\xf6?\xdc\xc4\xf0\xf7"\xd3\x04@I\x87\r\xa5\x8cp\xe3\xbf\xf6\x99\xe3\r\xe0{\xe6?\x87M\x8ci\x13Z\xdd?\x8f4\xea\x1c7\xcb\xf0?\x91\x1b\xeb\xcd\t\xd7\xeb?BZ\x1cxV\x96\xf7?\x85\xdc\xfd\xd1r\x9a\xf4\xbf\x9e\xed\xcc5sA\xf5?\x88\x97\\\xee\x0f\xe6\x00@\xb4\xd9\xbe\xd6\r\xd6\xb0?0\x81\xfc\x8a\xf7\xbc\xf7?r\xa2\n|\xe1\xde\x00@L\xf3\xb5y\t\x84\xf1?h\xd2\xed3\xfc9\xea\xbf\xee\xff\xce\x0e\x93\x11\xd1?\xa7*\xb7\xc2~a\xe1\xbfH(\t\xa5!\xcb\xd9\xbfh\x1dlF8\xd1\xe1\xbf\xd4_g\xdaw\xa0\xe2?\x1az}M\xe1*\xe6\xbf\xd9yx\xe7\xe6\x9b\xd6\xbf)\xa1\xcc\xbc\x9f2\xb9?B\xa7\x17\xe2\'?\xb8\xbf9\xb6\xab\xe4\\;\xe6?/\x84\x1e8\x07\xbc\xe5\xbf\x9d\xfc}\x9d\xb5\x8f\xf7?x\xa4E\xef"\x12\xea\xbf\xc3\xc6\xe3\xf3\xe3\xad\xe8?~5<\x9b \xa4\xe3?\x10,\xa3\xcf\xfa\x1d\x00@\xf2\x1eNq U\xe3?"v\x99\xa3\xd1\xc9\x9d?\x1b\x94^\xb4\xda\\\xa5\xbf\x15\x0b\x9fNE7\x97?\xe1K\x99\'\xc6@\xea?\x08n\xf32\xd8\x0c\xef\xbfV\xab\xde)\x80Y\xf2?s\r\xc4\x1e\xf3\xbc\xde\xbf\x9d\xb3\xd5d\xd7\xf8\xe0?\x1eQ8V\xa3\x1d\xef?S8\xe7\x83\xfc\xc6\xf1?\xd0\xf0\xc8\xb6\xf6N\xef?\xef\x90\xf2b\xd7~\xfa\xbf\x890\x17\xe9\x9fx\xed?~Pu\xa6)\\\x07\xc0\xccF\xbe\x9e\xfc)\xda\xbf\xc1\xd0\xd5s{\xf7\xe5?\xb4\x83\xf1h\xd8+\xf0\xbf\xdf\xd9I\tM\x0f\xcb?.L\xacq\x87\xa9\xcc?\x0b\x08\x0b\x8c\xf3|\xda\xbf\xf7\xfa\xa89c\x99\xf7?\xfc\xb9?\xd8\xd3\x11\xf8\xbf\xe6\x0f`\xf0\xfbh\xe3?7h\xe6\xdd\xf0H\xe6?\xc2\xc2\xc1\xf3\xa5\xe5\xf7?\xa8\x9b\xa1\xb5\xe7B\xc9\xbf\xcem\n\xb8\xa1)\xd3\xbf\x85Y\xdce\x81P\xcf\xbf\x91\xc7\n7\x16W\xd9\xbf\xd9\xdd\xc23\xb4\xde\xfc\xbf\xca\xc6\xcc\xf3 L\xf5\xbf\xb5\xaf\xbf\xef\x8b\xef\x96\xbf\xd1\xa9\xef\xb6\xb6\x05\xc6?61\x7fF>\xac\xe3?r(\x9a\xbeC\xc2\xf0\xbf\x9f5\xfe\x93\x04\xb1\xe5\xbf\x0e\xce\xd9\x9c\x1c\x85\x04@.\xa5y\xb3W\x88\xf7\xbfz\xdf\xa5\xef\x1e%\xea\xbf\xdf\x9d\x9d\x97!a\xc3\xbf\xc7C\x98\xfb\xbd\xa3\xc3\xbf2\xc7\xf5X\x9a\xd8\xe1\xbf\x07\x04\x94#\n\x06\xd8\xbf\x13V_\xb6\xe0\xc4\xef?f\x17N\x1e\xc9x\xd9\xbf\x87\x18\xc8\xe3W\x03\xde\xbf\xbbm\xc2\xae\x9a>\xea\xbfO\x97|\xfa\xa7\x06\xd5?\x03[\xbc\xe3\xa1]\xad\xbf\xe3\x16\x90\xa6\xe3\xa2\xfd?\xe9\xb90n\xcb\r\xb1\xbf\xf2\xe1\xfdA\xd4B\xf9?4X\xb9.\xef\xc2\xe3?\xab\xaa}S\xb9\xde\xf7?\xfd\xef9\xb7ip\xe7?F\xb6W\xf3\x847\xa3\xbfM\xd5o\x81\r\xdd\xff\xbf\x91\x1c\x95\xdbe\xa8\xe2\xbf\xd4\'(\x1ab\xbd\xfb\xbfk\x8bN$#0\xee?*\xc1\x7f\x94\x04\x01\xfb?\xc2\xb8\xf4\x01L\xf0\x06@1\x89\xe6#\xc7\xb1\xf7?x\x12`\x15\n\x19\xca?\xcbn\x9e\xf0 \x98\xc4?r\xab\xfc6\xaf\xa8\xf4\xbfBD/\xe1&K\x9f?\x84\x87"\xacA\x9e\xdf?\xfe\xe4\x97\x88\x0fp\xea?\xb2+<\x0f\xb3\xa4\xf4\xbf\xb1\xba*\x8c\xba\x1b\xf2?\n\xe5\xb9,\x87k\xea?\x8e\xfd\x9d\x87\xca:\xf2?C\xce\x86\xab\xcc\xa0\xf5?:\x967\xb0\x02\x1a\xe6\xbf(\x89p\x12\xfc\x1e\xb3\xbf\x04\xe0\xfe\xa4#\xdc\xcd\xbf\xbf\xaa\x10\xf5\xcd\xc4\xe4?*$\x89\t:R\xfa?\x02\xe2\x9c\xbd\x96,\x00@\x07\x7f\xc6)i\xd9\xac\xbf\x0c\x01\xac\x0f\xdf\x8b\x00@ZJ(\x90\xa0\xd5\xd1\xbf\xfe$\xfela[\xcc?\xcc\xeb\x93\x14\xdau\xea\xbf\x19\xd6F\x06\xd2\x00\xdd?\xf0B\xbdgX)\xc5\xbfw\x82c\xe5.`\xd0\xbfU\xfb$cy\xea\xdc?,\x8a(LX[\xb1?6\xea<-\x1d\xf3\x00@\xe9\xcb`R+\xa1\xe0?\xaa\xa0jE\x85o\xf3?z\x18`\xa7L\x84\xf8?\x7fb\xe8\x1d\xe4\x97\xf1\xbf\xb3\x8f\xb2\x04\xef\x96\xc6?>o\x1a\xfey|\xec\xbf\xae\x84m2\xfd\xa2\xc6\xbfg\xdc\xe7\x11\x7f"\xdc?\xf9\x1a\xf3\xafmw\xf2?\n!c\x03}\xe7\xf5? ]\xde\x8a\x98H\xf0\xbf\xcf\xffi\x88\x95\xa1\xef?Y#\xd0i\x856\xe0\xbf\x01\xa4\x914\xda\xe2\xe8?\xa4|\xd9&J~\xfd?\xcc\xc9\xf0d>\xce\xe9?\xc3l\xc1g\xb40\xee?\xb4\xfb\xbdI\xfe>\xf3?\xea?=\xf9\xa3\x11\xc0?N`v\xb4\x93\x9c\xd8\xbfL5\xd0\xce\x88\xdd\x10\xc0\xac\x98A\xe4S\x90\xe6?\xa1io;uM\xe7?\x8b\xd8\x95X\x9bu\xfa?`\x9a^\\\xc3\xf7\xc6\xbfa[\x9a\xad\x12.\xd3?,G\x8de\xa9\xf8\xfa?VawM0\x04\xe5?`\x08a\xbeM\xd8\xfe?\x0f\x9fI\x07y\x08\xe8?5r\xd6;66\xf9?\xa1\r\xa5\x1a-B\xdd\xbf\x10N\x98\xaf\x80\xd7\xe5\xbf\xf0\xa6\xee\xd2I\xde\xcc\xbf9\x054\x18\xe6\xbe\xf4?\x8d\xd4\xec\xc77h\xc9\xbf\xf5\x1f\x1e_\xef$\xa8?\xef\xa4\xf0;\x04\xf3\xf1\xbfu\xec\xb3^R\x90\xf0\xbf\xfdK\x88\xd0\xfa\x14\x08@\x19\xddq\xc1P\xb5\xed?\x93\xa1\\\xd2\x17g\xb3?\xa6\xc2\x16\xeasp\xee?\x95Tn\xd2\xd0|\xef\xbf\xe8\xeb\xc9u\xf2\xb0\xe4?\xa8\xeb\xd0\xc0\xbd"\xfa?\x17b,bgR\xed\xbfE\xcfPz\xf8\xc1\xe1\xbf?\xffK\xf2\xba\x95\xd7?<\x89\xda|\x0f\xa5\xe7\xbf\x94\x87\x8e\xb8.L\xf2?\xdc\xdd,\xf7\xd4\xdd\xbe\xbf\xed\x9a\xc5M{F\xe0\xbfj\x98\xde\xe9V\xf7\xc2?\x17}\x19\xdf\xb0t\xc3?N\x9fV:\xf8\xf0\xed?\x03\x90\xae\x97\x12M\xef\xbf\xcd\x8e\x80\xb9\xa3\x1c\xf2?}\x19&8\xc6\xf8\x00@9|#\xf9\xa7\xc9\xf0\xbf\t\xdd<\xe1\xb5\x86\xf9\xbf\xb1\xdfv+\x08\xfe\xfe\xbf\xb6\\\xec\x92\x07h\xd4\xbfF%\x95\xe5K\xf3\xd5\xbf\x18L\x05\xb1\xf3\x8d\xf4\xbfwA\xfb\xb9\xb4\x82\xa4?\x81Bx\x9bYx\xf2?n\x80\x92lV\xa3\xe1\xbfQ\x97\xac\xc4\x98&\xe7\xbf\xea}rg\xd3\xee\xe4\xbf\xb2\x91\xd84\xa2,\xfa\xbf\xb8\xf0X\x03Oi\xbf?\x8e/\x8f\xe7\x00\xf8\xe6?rt\xf6^\xe4\x02\xfd\xbfk\x9d\x9b\x7f?\x95\xd4\xbf\x1aw=\xa9ze\xe5\xbf\x92\xf5\xce\\C\xbe\xd5\xbfW\xafA\x9d\x8d_\xf9?\x028\xc8\xe6\xaa\x08\xc5?b/,M\xdc\xc7\x86\xbf\x1at?j\xa0\xaa\xf4\xbf)\xa2\xb3,r\xaa\xf1\xbf\xd9\xd3#\xae\xdd\xb7\xe1?\xcd"eF7x\xf0\xbfY\x84\xd2\x04\x8e\xb2\xea\xbf\x08\x16\x16\xe3\x0e\x04\x01@3\xd1\xeaA~\xf5\xf3?I\x81\x01\x84\xc3\xf2\xf0?\xfc|\xc2\x90:\xa4\xb8?\xa6B\x1d\xfa\xbf\xeb\xd4\xbf\xeazH\xa4W\xbc\xe6\xbf\xd0\x16DZ\x89S\xa9?\xe4\x8e\xcb\xea\x13\x10\x99?k\x9c\xdc\x10"T\xea\xbfV3D\xc2\xc6\xdb\xf2\xbf\x11\x17\x0cL\xb3\xff\xf2\xbf\x19\x94\xc0b\x0c\x87\xe8\xbfY\xa0%lm\xfc\xd8\xbfp\xb9(\xd6\x17.\x02@b\xaa\xa3\xd4\x1c5\x00@lC\xd4\x04QA\xef?\xca\x85\x00f\xf51\xef?T\x0b^!Gc\xf8?G\xaa\x08/G\x88\xe7\xbf\x0f\x7fK\xff\x93\xfb\xc9?2\xd3\x02\xf4[\xd4\xd3\xbf>\xed\xa07\x8c\xcd\xfa?\x12}\xc8@\xfa\xd5\xfa?\xcc\'\xa1C\x90WX?$\x03\x8c\xab\xdf\xe0\xe6\xbf\x83\xe7N\xe4\x93\x14\xfd\xbf<~;\xf3\xb0K\x01@\x93\xed\xbe\xdb\x16\x90\xe8\xbf\x1e\xed\x0c;>\'\xed\xbf\x04\x1dr\x03\xcc\xc4\xe9?\x18)\xa8I\xa74\xef?w\x83\x84\x1dgP\xc5\xbfc;v\xfd\x9e\xd4\xd2?g\xe4mq[\x8e\xf0?\xf1Di\xa0\xd6J\xe6?\xbd\x9c\xb2\x81\x8b\xeb\xa0?\xb2\xc5^\xc2Dw\xce\xbf\x0b\xdb\xc8\xb6\xeb\r\x03\xc0\xd9Kr\xc19\x8a\xf9\xbf|\x95\x1c{\x1d\xc9\xfa\xbfG3\xff$\xc5\xbc\xf8\xbf\x8b\xaf\xba\xf7\xf5\xe8\xff?4\x93\xe4\x10?+\xd8\xbf\xa5e:W\x93\xa5\xc5?\xd0D\xa8BJ_\x98?x\xe7\xeb\x86\x18R\xf0\xbfk\xd7\x0e\x9f\xcf\xcd\xdb?\x9a\x83\xceM\xc7-\xf3\xbfl\x7f\xd3$)\x83\x02\xc0Q\x1a\xde]q\x07\xad\xbfw\x00=\xc4\x838\xf8\xbfkpo/\n\xbc\xd3\xbf&\xc5\x85\x128\x18\xd3?u\x19[\t\xa13\xf7?E\x80Oi\xd3[\xf2\xbf\xa7\xbb\x8d\xcc\x1c\x1d\xd9??B71T\x9d\xdd\xbf(\x84\x9b\xef:\xa1\xce\xbf\'?\xb9\xaf\xf7\x8e\xd4\xbf)\xb6\xf6zgb\xfd\xbf\xbe\xbfk\x13+\xd9\xdb\xbfe\xb6]\xab\xe6\x92\xd9?\x07\xc4\xbe6Y)\xd8?\x1c>9\x80\xaf\'\xd4?b2J\xec\xe9&\xed\xbf\xe4\x99\xb0$~\x9d\xd5?M\xee\x84\x9dC\x80\xda\xbf\xed=\x1d\x01\xd9\xe5\xce\xbf\x0e:\x1a\x82\x1b\x86\xd4\xbf\xd7=\xde\tz\xff\xc7?U]\x8c\x1e \xc1\xe5\xbf\xdb1\xcc\xf3\xdfu\xd5?\x86\x84\xa8\x1a/d\xbc\xbf\xa33-\xb0\x90\xaa\xe3\xbf7\xcfb\x85e1\xf2\xbf\xf0\xca\xbd$?\xaa\xf6\xbf8\x03\x0eG\x05\x13\xe8\xbf\xb6\xf0\xe7\x98m\xde\xfd\xbf\xcf\x10WY\xf8\xec\xf7\xbf\xb4\x97e\xa8Kb\xf5\xbf?I=\xb4~\xc4\x00@\xb7\x1e\xa5\x12\xd1\x02\xdc\xbfff\xbcQ\xccO\xe2\xbf0\x8e\xa9\x04D\xe7\xdd\xbf\\\x8b\xd7p\x856\xf3?f\x80u\x00\n~\xfb\xbf\x83\xe2\x1c\xd3S\xfe\xf0\xbf\x94"\x97\xa4\x8e;\xff\xbf8K\xc4\xeb\xd3S\xde?\x91\xe1\xe3\xff\xc9R\xf7?\x9c\xba]\x13"\xe7\xd1?\x9b\x16`\xe3\xb4c\x01@\x98\xc1rK\xc2|\x9a?\x9f\xb6\x99I\xbd\xc8\xdc\xbfA\xc0\x98\x92.|\xe2\xbf),\x8b\xca$\xd7\xe5\xbf8\xe2\xba\xab\x13\xc9\xea\xbf\xd7\x1eM\xc8 \n\xf1\xbf\xad\xfd!w I\xea\xbf\x91rH\x99\x12\xa2\xe5\xbfg\x820\x8c\xeb\xc8\xec?\xb0f S\xe8\x98\xf3\xbf\xf4\x93\x15Y\xa3\xf7\xc5\xbf\xe2\xa3\xa4\x9f\xbb$\x01\xc03\x04&\x0f7\x1e\xf6\xbf\xe8\xddN\xba\xe3\xb4\xf1\xbf\x00`\x01-5\xe0\xd2\xbf\x1a\xa9\x16\x04b\x94\xd9\xbf\xa5\xf7\xbf\xee`e\xf6\xbf\r\xd3\xbb2~\x8a\xef?\x0f\xd7\xd9\x9c\xe4\xd3\xec?\xe3\x7f\x0e\xc1\x0bD\xf5\xbfg^\x15-\x81w\xf4\xbfl\xea$\x9e\xf7\xc8\xf7\xbf\xc5p\xc2\xe8\x85\xde\xf3\xbf\xf4!\xeaN\xc0\xeb\xdd\xbf\xfcGO\x96.*\xd4?A\x8f\xf6\x12\x1d\x1e\xe3\xbf\xb0\xd7\x1e\xc0os\xd6?\xef\ntp\xe5\xee\xc9\xbf\xe7E\xb84\x98\x10\xf6?\x0f\x86\x0f\x8f\xb2\x91\xe3?\xc1\x07\xc2\xc2H\xbf\xde?\xf55\x01\x92\x17K\xe8?\x8b[\x02\x1c\xb6[\xdb\xbf\xb1T\xdb\x009y\xca?\xe9\xc9\x97\x0e\x01\xf5\xfc\xbf<\xc2\xe7\t\x0e\xd7\xea?\x86.Ed\x10Q\xec\xbf?\x15\x86f\x18\x9a\x07\xc0\xde4\x9c\x1b$\xeb\xf8\xbfLX\x0c\xdd\x8b\x07\xa9\xbf\xae\xd9H\xf3\x8d\x0c\x05\xc05`\xc1\x00\x0c\xc0\x02\xc0\xd4&\xc0\x8a.\xcc\xc1\xbf\xc4S\xb9\xfcN\xea\xd8?<\xd4\xf9r\x07\xf0\xeb?bF\xc7u{\xf4\xd1?W\xabU\xf8\xf7E\xe2?:#\n<\xb6\x1b\xeb\xbfhK\xc7\x00\x8c\xc0\xe0?\x13\xe6\xa6\x13$\x8c\xf1\xbf\xff\x15NDA~\xec\xbf\xe2\x82,\x9b\xaf\x01\xd0\xbf\x90\xe1\x99\x87\x0f\xcb\xf7\xbf\xed\xfa\xa1\xfa\x13\xae\x01\xc0]5\rJ\x04D\xa5?\x8b[eR\xa8\xb5\x84\xbf#{\x033\xd4\xa0\xb6\xbf4\x88\xa2\x0bg\xbd\xf9?U\xeb\x01c\xf9\xe0\xd4\xbf@7tmXK\x04@"6\xc9\xf1I\xfe\xdc\xbf\xb4\x04\xb8\xf3\x9d\x92\xed\xbf\r\x88v>\xb3/\xba?\x86\xf0\xca\xc8q8\xae\xbf%\x80\xa6\xc0\t^\x02\xc0!\x05\x0fm\xc6\x8a\xf6\xbf\x05\xd4\x9a`R!\xc4?\xdf5\x9d\x85\x84l\xf4\xbf\xbf\xbd\xe5L\x15\xc1\xdf?q\xc4o\x1cpk\xed\xbf>\xebP\x8e\x92\xd2\xa9?e1\xa5\xe0\x19\xad\xca?\xe1l\xe6}\xb8\x0c\xd1?\xd1e/tK\xc2\xf0\xbf\x8e}$\xac6\xa1\xda?d\x18\x84\xa6\xd4\\\xc0\xbf\x1f\x9bz\xf3\xe4\x96\xac?\xeb9\xbe\x1c\xc8\x82\xee\xbf\x8b\x18\xbau<\xbc\xd7?\x95_v\x1d\x83\xd3\xbc\xbf\xf6\xe6%+\x88\x07\xb0?\xb0\x92)\xa6S\xea\xbb?\xa3i\xa7\r\xb0\xa0\xeb?!\xbd\xb7\x00\xe8\x85\xd4?1\xed\x9e\xb7p\xb0\xb0\xbf)W"\xa7NR\xf1?\xd6\xbb~m\xc8\xa4\xe2\xbf\xb7h\xe9\xe9\x88\x9e\xc6\xbf]\xca\xfbp4w\xb6?\x179\xe4\x00%r\xd6\xbf\x84\xa9\x9f\x8d\xde\x03\xf1?\xd2\xd9\xf0\xb2#\xd1\xb9? \x0eu*\xd2\xba\x02@j!q(\x84\xc7\xf1?\x8f.]\xd1({\xba?\x1a\';{W\xe4\xd0?\xbb\xe4\xaf*\xa7\xd8\xec?y\x92\xb6\xdf\t\xd4\xf5??\xa6\xa9\xa0 F\xc6?o\xe1\xfe\xd7\x95%\xf7?\xc4\xc5\xbe\xd6\xa4\xd1\xba\xbf\x89\xe2\x7f\xd3\xaa\xcc\xf7\xbf9\x06]\xe5\xd4\x9d\xd0\xbf\x12\xcdM\xf9\x9a5\xf2\xbf\xbcL\x94"\xca\x89\xb1?\x9b\x95\xdaV\xbc\xea\xb4?W\x9e\xdf\xc6\xa1\xf6\xbb\xbfV_i\x1c\xd4\x8d\xc7?\xb3UtlTM\xdc\xbf:9\x84\xb2Cb\xf1?\xee\xd2\x01I1\x8e\xe2?f\x95|A\'\xe0\xcd\xbf\x0b \x02\x03"\xc3\xfa\xbf\x83\xa3\xefc\x80P\xe8?D\xc7\xb3\x7f\xcc\x15\xec?\xc4\xfewr\x05T\xe0\xbf\xc6Y\x94\xab \xe2\xe7?\x91\xaa\xaa\xa5\xa7\xd2\xe6?\x99\x84\xfe\x92X\xf8\xb2?\xefn\x92\x1b\x835\xe0\xbfhP\xe0/\xc57\xf3?U\xa2\xa0V0:\xf3?\xe1A \xb1.\xa1\x03@^\x1d\xd0P\xf0\x1e\xe3?f\xa2\xeck\xbf\xe6\x04@\x1f\xce\x12t\xcb\xfb\xf8?R\xcb\x9c)\xa1>\xec?\x87\xab\x10\x8d*\xe0\xe4\xbf\x1c\xc6\xc3\xcf\xa1\x87\xc0\xbf\xe1\xeay\x15\xa4\xd9\xe8\xbf\x0fe:\xf2\xd7\xff\xf2?\x1e5\x1fu\x00\xdb\xd3?\x1edn\x8f\xb6]\xe7\xbf\xff\x91T\xef{\x12\xe9?\xdb@\x84\x7f\x90}\xf1\xbf\x0f)\xe5\x10\xe8\xb2\xff?\xee*F\x84\xdc\x1a\xd8\xbf\x9c\xb7l>\xcb,\xcc?\x80\x9bX6\xe7\x89\xd1?\x0b\x8f\xb0k\x9d\x0f\xef\xbf\x04de\x0f^\x05\xc7?\x1e\xbeyVc\xdd\xea\xbf\xbf\xc1\x9f\xb9W\xe5\xe4\xbf\x1e\xdfy\xb2\xd0\x08\xd9?\xcf\xfb\xe0\x04\xa5\xfc\xd1?\xf9\xbf\xe0\xdae&\xaf?#\x90\xdb\xc1\xad\x02\xe8?x:<\xe6JV\xd9\xbf\xbc\x1a0\x1bi\xcf\xd6\xbf\xc1}\t\xdd\x9e\xd6\xf1?"\x07\x00m\xb5\xa4\xa0?\x86J[\xc2\xf9\x98\xf4?F|\xa0\x83J#\x8c?\x82M&\xfdc\xb8\xe8\xbf7l\xe3\x1eH(\xf2?~\'V\xa3\x97\xac\xc0\xbfi;\x97*\xb8\xca\xc8?!\xf6E\xef\t\xb1\xed?(\xcdz=`\x9e\xe4\xbf\xfa\x05\'H2\x1a\xf0\xbf\xfd\x98H\x87\xa9D\x03@\xc2\xf9i\x1f/\xa5\xe1?n\xcf*\xf321\xf3\xbf\xe4\xb2\xdd\xb5h\xb5\xf4\xbf\x15\xc0\xe9$\xe6\xd7\xd2\xbf\xe1\xf3\xae\xd32\xad\xf9?\xeb\x1a\x13\xef\xcf5\xc0\xbfD\x0b\x00\x15\x07\x8e\xe0?\xac+\xab6m\x89\xdf\xbf]|\xdcg\xceC\xac\xbf\x08O\x18\x85\xa2\xb0\xf9?\xde\xcc\x18&\xf7\xe4\xe6\xbf\xaao$\xe9\x1bt\xc5\xbf\x1aou\xacE\x0c\xf0\xbfX\xe7\xf3\xda\x1d\xca\xe6?\xab\xad!^\xfc\\\xc6\xbf\x88%\x84\xec\xe9\x08\xfb?\xff\n5\xd8\xbf\xca\xcf\xbf\x89G\x18\xd4\x9bg\xb7\xbf\xc4\x1bz\xbe\xadD\xe5?rWK,Vl\xf9?1\xe3~9~\x91\xed?\xed\xc0f\x03\xf3\xa9\xf4?\x03\x14g\x9bU/\xde?{\x93\xbbA>\xd8\xde?\xea\x14\xf9\x96\xafd\x00\xc0\x83\xf5\x07\xbc9(\xf4?\x83=\xf4\xc1P\x01\xd3?\xa4\x17\x12\xa0y>\xf3\xbf\x7f\xdf|\xde\x83h\xf2\xbf\xf9:e\xe4\xe3r\xeb?\xec\'\xf5m\x85;\xe3\xbf\x1c2h\x8b\xdfR\xe4?8\xddd\xd7\x1e\x80\xd6\xbf$3\x17\xa4\xf7\x0f\xd2?:\x85\xc4\x07\x98a\xd1?\'\xa4V\x8a#\xff\xdb\xbf\xc1)!\xf7\x02\xaf\xea?\x0b\xcf\x04\x88;\xa9\xf2?U\x12\x97\xe8\xfa\xbc\xd5?f.@h\x15\x13\xee?\x8eZ\xdc"\x880\xa9?[\xfb\x11\xb4\xa8\x84\xf7\xbf\x9a\t\xe4*\xe8v\xcc?t\xd1TN\xd9a\xd8?\xacj\xff\xd7\x98M\xf4?\xc5r-"M\xf4\x07@;&&\xdb\xec\x1e\xf4?x\xffx$\x11\xb6\xd8?\xff\x88\xeb+\xea\xbf\xe1\xbf3\xcd\xaa?\xd3\xe4\x84?PV\x97\t@\xd6\xfe\xbf\xa2\xe4 &\xa7\xc4\xe6\xbf#\xab\x1c\xf5\x1e\xd2\x01\xc0\x95\x9b\x9e\xfa\xbc\x0e\xfe\xbf\xa2\xee\xaa\xe7\x9b\xf0\xd2?\x02,z\xe9\x9a\x8b\xf9?W\x96\xc8|\x87h\xd0\xbf\x04I\xed\xf4\xe7\xc0\xd3?\x10|\x12\xadk\xb8\xcb?\x0f\x14&c\xe3\xde\xf2\xbf\xd6\xd0\xe1V\xedP\xcc\xbfO\xde\xe5\x7f\x10\x87\xe6?^\x8f\r\xb5\x8d\xba\xd9?\x17*\xfd\xedzn\xfe?\x96\r|\xe2\xe3\xc6\xee\xbf\xde\x9a\xb2\x03X\xb0\xfb\xbf\x1b\xb0\x04\x84\xaa\x8f\xe4\xbf\xb9\xe5\xbe1\xf7\xca\xfa\xbf\xdb\x02c\x81\xe3\x99\xcb?\xf4u\xb6!U[\xce?\xa4x\x88#\xea,\xdd?5W\x07\xb8S\xf4\xec\xbf\x8d\xc9Q+\x9b\t\xe9?\x8ac0\x01G\xc2\xd5\xbf\xcd\xa2\x91\xa6\x97\xd5\xf7?[y)\xd8A%\xfa?,*T\x0b\x1b\n\xf1?\x88\xe8l\x81b9\xf9\xbf\rOi\x14\x8er\xf2\xbf\xe3\xb5\xfc\x17\xbb\x9c\xf1?\xe6\xd6b\xc2P\xb0\xdb\xbf\xca\x00\xd0\xb3|\xf2\xf6?\xa3\xca}w\xb8r\xc0\xbff\xa3\xca\xc76\x9a\xe9\xbf\xbc\xaa6\xfe#X\xd4?\xa9\x07\xb4\xb7\xa8\t\xda?*\x98\x18\x92\x9b\n\xe8?\xbf%\x0b\x87\xb4z\xd4\xbf3\x89\x8e\x1fk\x18\xfc?\xce\xaf\xac!\x9ae\xd8\xbf\xe9\xfc\x97\x85\xbeM\xb1?\xa5\xaf\xa1\r\xb00\xd6?\x1e\xdb\x9b\x90\xfb\xe5\xc3\xbf\xd0\x98\xb9\xae&\xbc\xe1\xbf\x1c\xd6;\xf8\xd3l\xa7\xbfk!\x90vNb\xf4?\x0f\x12\xc4\x14\xcd\xe1\xfa\xbf!\xe2\xa0b2~\x05\xc0\xb2i\xac\x9e-\xac\xe0?s\xe2g\xed\x9a\x9e\xf7?\xdd&\xf4\xfcs^\xf4?\xdbY(>\x13\xa0\xf6?\x0c\xa4\xfe \x00\xd2\xa8\xbf4ng\x03\xa2\t\xd8?\xab\x1dGr\xb1\x04\xd8?<\x07\xab\x90\x8dr\xed?\xa9\xba\xf6\xd2\xb5f\xf1\xbf\xf3\x93xQ\x8d\x00\xd7?-kg\xe2\xae\x99\xc2\xbf\xe2\xc1\xe5X\xa8u\x00@\xfa\x9e\xa8\x10\xafy\xcf\xbf\x97\xee}!n\x8b\xe9\xbf\xd9\x15\x13D\x9ad\xd7?\xeb\xfd\x91\xf4\x9a\xdb\xc0?f\xaezH\xf04\xe8\xbf\xb5\xf8\x1d\x0f\xf8\xa1\x90?y\xd7\xc0\x99N\xb3\xf2?y\xcf\x977\\\x84\xb6\xbfJ\xb6"\xf2\xde\x89\x04@\xce\xedX\xff9o\xe3?be0\xf6%f\xfc\xbf\xd8\xe7\x93\xd9\xd7\xcd\xe3\xbfU\x16\xe0\xc7^!\xf5?\xc7F\xe1%\x88\xbc\xd1? (\xb0\xe7"h\xba\xbf\x84"P\r\x93\x89\xf3?\xcdae\xff\xb5\xfe\xe4\xbf\xc8\xe6\xeb"\x9d\xa1\xb3\xbf\x1a\xe1\r\xdc\x96^\xd5?\xee/\xb0\xa5=\x0e\xee?F\xceM\x98\xb8\x10\xf8?\xaat\x0c\x97\xc4e\xcc?\x82O\xe58\xda\x83\xe9\xbf\xc5\xc5\xdfs\xb3\xab\xd2?/\x88\x8e/V\x0b\xe4??\xc4\xd4i\xab\xef\xf8?I_\xf2\x10{\x04\xe3?L:&\x15\xf3\x17\xf1?\x9f%f\x07\xb5\xb0\xe5\xbf\x8e\xfd&\x80]M\xf0?o]\x11\xb8"\x07\xf5?)D\xa2\xbf\xbd\xd2\xf0\xbfw\xb0\x8f\xf0\xe0\x18\xef\xbf\xce\xd0\x81\x7f\xf7\x91\xd0?2\xa0q\x175\xc8\xfb\xbf\x00\xb5^z\xcbb\x07@:\x02\x7f}h\x9e\xe2\xbf\xfc\xb7\x8a\xd8\xf8\xe6\xde?~\xc4\x05kB$\xf8?\x12\xd6\xf5\xb4/\xfb\xe1\xbf\xab\xca\x0e\xea\xeb&\xd5?\x04P=\x10\x1b\xdc\xc4\xbf\xa6\x90j\x86L\x16\xd0\xbf\x1az\xb8\xcbSH\xc6?\xd8X\xde3\n\x18\xf7\xbfq\x80\xcd\x96\x1a\xa3\xc0\xbfcPI\xab\x93\xc7\xe2\xbfF\xed.AG;\xea\xbf\xb3\xfc\x8e\xdc{\xd2\xd7?c\xa6\xe0g\xa4\x02\xe4\xbf7\xfd\x8b\xc0\xe6\xd3\xc4\xbfi\xf4\xe2\x1c\x8f\xf0\xe7\xbf\xbcOL{t\xf3\xe1\xbf9\x9dp\xe9H\xd0\xf4?\x15w\xb6D\xef\xd9\xee\xbf\xd6K\x96\x10\x19\x9c\xc6\x96\xec?W\xd3\xc9\xb0C~\xe9?W\x81\xfe\x05\xac:\xe6?\xc9\xf6\x8a\xe7Y\xa0\xdc\xbf\x00L\x93\x17a\xda\xf7\xbf\xbb\xd0\x1e\xe1\xa8\xb3\xed\xbf\xc30\x1al\x8b\xe0\xf0\xbfox\xfb,Z\xf3\xf1\xbf\xa9\x07o\xad\xebY\xee\xbf\xb7@\xcb\xeb\xa5T\xb0?\xff\xd3i\xc1\x1f\xea\xe9?_c\xd2\xeb\xc7\x8d\xc0?\x84\xb4"X0\x16\xf7?\'?\xb8D\x06P\x01\xc0\x0f\xa9\xc6\xb8\x95x\xf9\xbfa`l\x01\xa1c\xd9\xbf\xd3\x0b\xf6\xfb\x90t\xd1?\x07\x05\xfdj\x84\xd2\xd1?\x82\xfb\x16h\xd9\x07\xd4\xbf\xb7\x06\x06\xc5\xb3\x8c\xee?\xc0\xb55\xa1\x19\xe8\xf1?\xc2\x88\x96\xaait\xd5?\xe7\xaf@\x9dz\x11\xf6?D \x888m\x9c\xf3\xbf\x04*\xce\x16Z\xd7\xce?\xcf\x16\xacE\x0c\x83\xf8\xbf\xb0LP\x12\xa2\x12\xf5?\xc8P^\x8d\x9e\x16\xcb\xbf\x9bI,`\xff{\xf5?a\x11!\xdc1(\xe4\xbf\xf2\xee\xaf\x12\xe0\x17\xdf?\xa1\x18\x82\xc1\xef\x90\xdb?\xe0\xd0\xa0\xb5g\xb2\xd6\xbf_\x11\xe6q\x1e:\xf0\xbf\'\xb4\xc3\x97\xab-\x01\xc09\xcc\xa4\xb8I\xc7\xf7?Vy\xe5\x86A\xfc\xe3\xbf\xfe\xe6\xc5\xc8\xff\x06q\xbf,\xf4*\xb5\x12\x11\x01@\x8d:\x8ai\xc9\x8b\xbe\xbfSIn\xb4\xef\xc1\xf5\xbfxH`\t\x01R\xea\xbfd\x89\xb5@\x91h\xfb\xbf\xa5\x04j\xae\xd0\xe7\x08\xc0S2\xbeG\xac"\xf2?\xf5\xda\x1c\xea\'\n\xcd\xbf\x83\xc3\xd3v\xf8l\xef?{\xa4\xd9|L\x93\xf0?\x18\xe7\x9bM\xa6c\xf4?R\x10\xc7k\x94L\xfd?\xb3\xc8o\xc2\xb4\xac\xc6?\x81\xe5\xf5et\x90\xea\xbf}\x19\x1e\x1cn\xae\xd9?4+\xbc\xe1C\xc8\xa1\xbf\xb4(\xd0o\xd0\x98\xdc?\xf30Ts\x058\xfd?\'\xf5^\x9crU\xf1?v\xa8\xe9\xb0\xda\xff?$c\x9dF\xef\x05\xdd\xbfI\xab\x93\x0f\x02l\xcf?\xe7k\x83?\x9d\xc9\xce?\xb4\xab\xa81\xea\xbf\xee\xbf\xcdDu\x01\xef\xf7\xce?>B\x06\xe9\xb5\xeb\xfa\xbf\xd4\xcbI\x94\x17a\xef\xbf\xf6}k\x9d\xbaq\xe2\xbf\xb3Z\x7f\x07^\x03\xe0?gW\x05\x02y\x8f\xda?\x14va\xb4I\xa9\xd4\xbf\xe2\xc2^\x90\x84\xd9\x10\xc0\x15\xf4n\xfe\x86\xb7\r\xc0\xf4\xca\xb9U\xb1\x1d\xfa\xbf\xd9\x8e\xa4\xd4D\x1a\x06@8\xd8\x1cd\x16\x8d\xef?\xa5S\xa9\xce:*\xc8\xbf3\x9eW\xe5\xd7\x06\xed?\xce0:\x82\x86\x92\xdd\xbf\xa8\x1e\xe2\x8d>w\xed\xbf\x88\x1f\xa6\xdc\xb1\x15\xc4?D\xe0\x1c\xef\xb6\x00\xf3\xbf\xd9i5\x96\xfb \xf3?\xdd\x90Z`\xf35\xc4?\x84{C\xc2\xec\xa4\xed?\xe0\xcd\xf2\x01\xfb5\xda?\xc1\x7f\xc3\xb1\x0b\x99\xe1?\xa4\xfc}\xe0\x98E\xc4\xbfkje!#H\xf7?\xf0\x1b\x8f\x80k\xd0\xc2?D4\xa4\x14$\xe5\xf4\xbfiT\xc8\xef\xd4)\xfd\xbf\x81\x033\xda.z\xf3?\x1b\xb5\xda\xfd\x8aN\xeb\xbfM\xcd\xd8~zw\xd5\xbf\x7f\x84e\xd8\x80\x11\xe9\xbf\xfc\n\xda\xcc\x13+\xf1?\x8d\x9c\x913\xee\xd9\xf1?\xbe\x00d\xd2Y\xf7\xef\xbf(\xb2X"1\x17\n\xc0\xa8u)\x14\x98\x80p\xfc\x01\xc0\x91{\xf3\x19\x84\xa3\x07\xc0\xda\x82)\xf3\xe9\xe0\xf9?\x02&t\x8f$\xc4\xe0?\xb6\xadwD0\xb4\xd2\xbfD\xac\xf6R(\xea\xea?\xf8\xd7\x86\xade\xca\xe1?\x03;\xadt\x8f\xae\xf2\xbf\xa3r\x98\x98\x90\x9c\xc5?5\xbc\xf2\x1f\x1a\x99\xf0?\xba\xbf\x99x\xdb\'\xe0\xbf\xbb\x95\x89\xe8\t\xdb\xe3\xbfW\xee\x144\xa2\r\xdb?ZT4M\xa0t\xf3\xbf\xcb\xb6\x07-\x95O\xfa\xbfj\x00,k)`\xf4\xbf\xb6\xe8&\x11\xc7\xca\xe2?\xaboe\xbd\xb5\xbf\xec\xbf\xaaS\x12R\xf7\x0b\xe6?\x1b)%\xd3\x94Z\n\xc09\x95>\t\xa8m\xf3\xbf#\xfa\xbe+\xbb=\xef\xbf\x89\xe9<\xb8\x14.\x98?\xbcA\x0e\x17\xee\xb9\x01@e\xeb\x85\xcc\xdf@\xdd\xbf\xac\xb0\x07w\\\x18\xf0\xbf\x1d\x93\x9a\xe3\x7fl\xe4\xbf\xbd\x10uU\x0c\xf4\xf2\xbf}x(\xa9pi\xf4\xbfi\xbaNc\x02l\xf1\xbf\x0b\xfc5\x11\x05\xf2\xd6\xbf\x0b2\xd1X\xae#\xea?|\xc8\x00\x1a\xce\x82\xe9?[\x85\x99&\x0b\xcb\xf1?l\xb1\x1f\xc8\xe3P\x7f\xbf\x01dK1\x99\xdb\xe8\xbflH\xb1|\x9d\'\xc4?\xd6Y\x13f\x06\xd9\xfc\xbf\x1a\xc8=e=\xa0\xea\xbfO\x16z\xdb\x91W\x06\xc0Q\x94H\x14\x83C)\xf6?\x83i\x02S=\xa8\xc3?\x84\r:.\xcez\xeb?(\xe3\xf0uj{\xee\xbf%\x04\x07\x94\xfbf\xe5\xbf\xc2\x08-\x0e\xb9\xbe\x03\xc0\x92\xe2\xb4P\xb2\xbc\xe8\xbf\xcc\x17l\xdc\x7f\xdc\xf3\xbf\xc17\xca\xcf\xb68\xe3?M~\x14>\xbb\xdd\xea?5\'\xc5r\x19\x99\xf4\xbfi?M\xb7\x9c.\xd1\xbf;\xe8j^$\xb8\xe1\xbfn\xd6\xbc\xd2o8\xee\xbf@\xc1\xb2\x9c\x93\x9c\xb2?\xf5\x87\x9d\x1e\x1a5\xe7\xbf\xda\xde\x9c\xb4g,\xe0\xbfZ\xd4>\x00+>\xd1?\x91K[\x05\xba\xf7\xf0\xbf\x10\x04\x88\xa0E\x02\xf7?\xc5\xb5@y4\x00\xd1\xbf\xae\x06\xe56E\xb1\xec?\xed"\xfe\x05M\x10\xe0\xbfK\x9b\xa5\x10*\xd0\xeb?\xc4\xd76\xa7\xa3\xea\xe6\xbf\xe6\x97,"\xfb\x9b\xf2\xbf\xc2F\xac\x81\xb6\x9d\xd0\xbfa>\x03wg\x1e\xf3?\xba}t\x17k(\xe5\xbf\xddf\xb5\xe4\'*\x9c?p\x8b]e\x9f\x16\xd8\xbf\xaf\x9b\xda\x12\xa9t\x08\xc0\xf7\xdd\xfdmF)\xe0\xbf\x1b\xe7k\x0fm6\x01\xc0\xe2\xeaf\xdb\xf2\xf6\xc2?o\xd3\x91m \xf8\xfb?\xd5\xd2\x0e\x8f\xce\xf5\xfa\xbf\xcd+\xab]w\xd7\xf3\xbf\xcf\xe3D\xca9-\xfc\xbf\xff1S\xe3;c\xe0\xbfj\xc5\xdc\xfef\x86\xf7\xbf\x8bbBB\x9al\xf0\xbf\x7f\x1exb\x9db\x02\xc0;y\xde#\x10\xbe\xdb\xbf\x1c\xfa:\x9b\xdd\x83\xed\xbf\xa1\xe1L\xdc\xa9#\xd6\xbf\xa6\xcbDj\xcaM\xef?A\x00\\\x12\x1a\x91\xf6\xbf-S\xbc\xb6\x9cR\xe6\xbf\xb5\x08X\xc7U_\xd2\xbf\xab\xfb\xc6\x19\x9b\xe4\xee\xbf@\xd5\xe1!\x7fZ\x03@~\n\x0e\xd5\x9e\xad\xb9\xbf\xc8\xe6\x04\xa7R\xff\xfd\xbfHu\x84\x18\x93\x01\x82\xbf\xcb\xe2\xa1\x1c\xea\xb1\xd0?\x8ft,\x82\xfce\xf0?\xb35&\xd6\t\x16\xd8?\x89\x8ct/9[\xf1\xbf\xf1\n&*\xe4\xb9\xd4\xbf\'CQm\xab\xc3\xc6?\x8e\x82\t>C\xef\xdb\xbf\x92|jf\x98\xa8\xd4\xbf\x06\xbeiJ\\\x98\xfe\xbf^\x9e\x8aYJ\xa4\xf3\xbf\x91\xcb\x12$\x95G\xc3\xbf\xceB\xcb\xe3Sw\xc3\xbf\x9c\x82\xcb<\x9d.\xe0?r\x18cM\x84U\xd6\xbf\xd1N\x92z\x08N\xda\xbf\xc6,B$og\xe3?\xf2>\xb7\xb9\xce\x8c\xb3\xbf\x05C\x9bO\xb6\x9a\xdf?\x94\x8d\xf2d3\xa0\xf0\xbf\xbfZ,\xce\xf4\x15\xfc\xbf\x01\x1c\xc0Q5T\xd6?\xc2\xba\xde1.\xb6\xce?\x91\x18\xc3\xd4\xf3\xe6\xe0\xbf\r(M\x93\xffP\xe5?\x00\xc6\x1c \x975\xf1?\xf0\x0co\xcb^6\xb6?\xd8\xb3\tKK\xc8\xec\xbf\xc6\xc1F\x81U\xdf\xfd\xbf\xc0\x92\xaf\xc0\x8f/\xe6\xbf_\x93\x93\x84]\x10\xdb?\x1d\xc5i\xa7<\xbf\xf2?/\xbf\x00W\x82V\xe8\xbfOk"\x98V\n\xe5\xbfl\xf9c,Y\x08\xf2?\x10\x9e\xd5\xf9\xf9\x93\xf4\xbf+\x93\x97\x98]\xce\x9d?\xa0\xa8\xa8v\x12x\xe8\xbfT[A&\xdd\x06\xdf?\xe0\xea\x93|R\xd3\xfe\xbf \xf8A\xf4\x97]\xcb?\x07zmM\xc0\x1d\xd6\xbf\xdc<$\x0f|?\xb8\xbf\xa7\x80\xcd\x1c\xbd\xc9\xf2\xbfJ\xec\t\xe55\x9a\xe1?\xb3\xcb\xc3\xf7ge\xde?\xb9\x92uL\xd8\xeb\xd0\xbf\x0bh!\xde\x97\x92\xe5\xbfYE\xf0\xb1Rk\xf7\xbfc6\xebJ\x19x\xd3?\xe4\xc5\xd2\xf3\xaa\x8b\xf3\xbfr\xc9<\x11=\xc5\xeb?a\xa4\xfe\xb4\x1e\xe8\xeb\xbf\xa0\xff\xa4\x8e5\xcb\xf7?\x05JP`\\\xeb\xf9\xbfk)\x868\x98\xd0\x97?Jh\x17Ze\xab\xf7\xbf\xa5\x988\x97\xd7e\xf5?\x0cn\x15\x11}<\xff?7\xacx\x80\x80\x01\xe5?\x15\xe7\xd6\xc01\xd1\xd9?\xfeSQ\xc8So\xeb\xbf\x8f4\xa5\x918\x93\xe4\xbf!\xf1\xc1\x1e\\\xec\xe0\xbf\xa8\xb2]N\xf6t\xd2?&\xa4q\xb8\xd1\x92\xd2\xbfX\xff\x03}p\x91\xe1\xbfPu\xc8\x9a\xee.\xd0?\xbdc_\xc0\x89\x08\xe9\xbf\xd1mdH\xcc\x89\xf9\xbfc\xe6\xd3\xfdw(\xe7?vWVv\xf5\x04\xe4\xbf,Gs_ n\xf7\xbf)\xf1e\xf1Y\x82\xf3\xbf?hfLvq\xc8\xbf\xf1\x8f\xa2\xd0-\xf4\xd8?\x02\xe0C\xdc\x85\xa3\xa4?\xfb`\x9b\xed\xf6\x8e\xe1\xbf@)o\xba~\x9a\xd9\xbf\xb0q\x0e{Ak\xf8?\x93\xce\x85cr\x9a\xf9?\xef\xc9\xda\xad^\t\xf2\xbf\xc8^\xa1\xb3^[\xe2?W\xad\xfc\xb1\x8e3\xd7?\x04,\xb3\x1f\x91\xe7\xe7\xbf\x93\x19w\xf4\xb4R\xbf?2\r\xb2\x95\xefX\xc3\xbfb\xa7\x87\x01w]\xd5\xbf\xca&\xd3o\xdfo\xe5?\xeb\xc5\xd7\xf1\x17\xbf\xc7?(\xc5wn\x15}\xc1\xbf?p\xf4`?\xec\xe6?\x94u\xdf\x16m\x8c\x00\xc0s\xe6\xa6\x9bZ\r\xe6\xbf{\x98/\xfa\xa1\xda\xda?\xfd\xce\xb0\xe8\x96\xdd\xf3\xbfLF\x80W\xa4\xc1\xba?\xf0!\x1f/@\xa6\xea?\xe8\xf9V\x81?a\xe9\xbf\xe3\xc0O5\x87\t\x00@\xfb\xa0Q\x04BE\xd8?!]\xf5Q\x1e\xf6\xf6\xbf\x1a4V\xaf\x8a\x8e\xca?\xc9\x86\x8e\r\xf4\x16\xc8?\xbf\xce\x80\x1f\xf6N\xf5?\xd7"\xb5\x80\x83X\xdc?\xea+\x87\x9a\xb0e\xf1?\xa5\x0e\xec\xb9@\xf9\xe9?\x13\x84U\x92\x96\xd3\xee\xbf\xc6\x17y8p\x98\xf3?w\x01\xbe\t\xb4\x17\xeb?\xbf\x06\xa1~#Q\xae\xbf~\xa8a\x93\xa65\xd6\xbf\xdf\xbe\x01\xc4\xc4\x8e\xe8\xbf0\x9d\x12\x8e\xa5\xf5\xfe?\x8d\xfe+{\xe97\xc2?z\xf9\x9d\xb3\xdb\x8b\xe2?\xfd:\xfb\xf3i\x9c\xfa?^\\p$R)\xd5?\x9c=&]\x9cg\xe2\xbfX\x90\x9f\xceb"\xf5\xbfkY\xae\xff\xcb,\xf3\xbf\xf7g\xcb|\xb8W\xf8\xbf\xc0\x0e\xd9\x13+\xce\xe4? R\x8eaD\xc8\xee\xbf9$\x18\x02!\x9e\xec\xbfN\x81\xf9\xe0{^\xdf\xbf&\x8f\xce7\xba\xfb\xee?\xa8*\xb5\xef\xfad\xde?!\xf6\xc0\x95\xcav\xc4\xbf\x0b\xdc\xb4\xc5\xd9\xf8\xf3?\x04\x18\xaf\xb8\x14\x88\xe6?#\x1bj\xd2\x82E\xe3\xbf\xd5B\xf6\x94\x0c\xa3\xef\xbf\x99\x9bD\xc4\xee^\xf1?=&\x96S\x91\xd3\xe4\xbfGJ\xce\xab]\xba\xd5?\xae\xeb\x7f\xd0\x1e\x16\xea?\x160\xb0\x97y\x05\xe5\xbf5\xf1y\x8e\xe9\x7f\xe5?J\rk\x89\xb8:\xb3\xbf\x125\xd3c\x01\xf0\xe6\xbf\x1f\x0f2yG\xf8\xdf\xbf\xe1\x8c\xc7\xef+\x01\xe5?\xe1\x1d\r\xda\x8b\x02\xee?\xe3\x9e\x87\x98D\x82\xa5?\x80V\xc8\x91\xa2\x84\x95\xbf\xf0\xe1]J;@z\xbf\xbe\xa8\xe7)\xd8\xeb\xe6\xbf\xc5\xe8Ob\xe3\xf7\xd6\xbf\xdb\xa0\x93\x03v\xd5\xc4?\xb8\x1f}|\x80\x89\xce\xbf\xb9\x89\xabmm\xc5\xe4\xbfu\xdf\x06\xccHz\xe1\xbfZ\xb7W\xe21\xb2\xb9?\x8c\xe4\x04\r\x9b\xb2\xea\xbf\xbaJX\xads\t\xe2?a\x19k!\x1d\x10\xf6?\x10\xac\x98\x95\x87\xbd\x96\xbf\xc8Jh+Yh\xee\xbf\xd6I\x9b\x9c_o\xde\xbf\x166u\xef\xa4z\xd0?\xbf\x93&\\-\xc4\x00\xc0\xd7\xb8\xb4\x07jo\xe5\xbf\x8d\x89\xed\x04\xa2s\xbd?\x8c\x8a\x81\xfbU\xbf\xe1?"\xca\xeea\x02!\xb6?\x05\xbb;H\xc2\n\xcf?\xc6\xf1#,\xdf\xd1\xf3\xbf\x0e\xf7\x9c\xb1\x9e2\xfa?\xb7L\x0e\xa4\xc5S\xce\xbf\xde\x07J"\x8aT\xd2?[\xec\x03U\xe9\xf6\xe2\xbf~y\xf2\xbf\x14\xc4\xf1?\x07\x1f\xc6\xf9a\'\xea?\x1dW\x88~{\xe2\xe9?\xcf\x9b0j/\xe4\xf8\xbf\xed\xa2#\xdf\x99\x95\xe6?\x9a\xde)\xf6\x8d\r\xf7?\xe3=\x85X"\x01\xc0?J\xd6x\x0c\x8b\xea\xd6?#t$+\xf7\t\xd9?\'\x92\xdf\x83\xce\xc0\xe6\xbf\xefM\x97\xda\xcfc\xed?\xc2\xf4\x1f\x8e0\x83\xf6?\xa5\xbf\xda\x1b\xe1j\xd3\xbf\x1c\xbe\x99*\x9e2\xcb\xbf\xa9{\x19^\xd5\xd2\xec?\xd0\x96R\xd1\xcei\xd7?\xefA\x85\xed\x96b\xcf\xbf\xb2\xd2\xe1B\xf7\x9d\xb7\xbf\x13\x80o\x00\xa7:\xf2?"\xff\x0b\x06\x95T\xe2\xbf/\x88\xb5\x02\x0c4\xef\xbf\rI\xf2\x9eb\xd9\xd7\xbfHz`\xcc\x00\xa2\xe2?|\x7fn\xe0\x13\xbf\xf9?\x90\xc9\xc7\xea\x03\xbb\xff\xbfm<\xe5dL\xbb\xc6\xbf}E\xb5@\xab\xfc\xf4\xbf\x17]\x01/\x06\x05\xf9?\x80\xc0\xa8;x\xd5\xf1\xbf\x1al*\xed\xbfe\xf0\xbf\xcd\x1a\x0e\xa9\xd7\xb8\xf4\xbfR\xd8E\xb4\xdc\x90\xe9?\x93\x19\x8a\xef\x9bl\xe7\xbf\xc7\xdf\xee\x0f\x9e\xb3\xf4\xbf\xe0~s\xa8\xb6\xf6\xe0?\xa2\xac\x8f\x82\n\xaa\x84\xbf\x99^\xf7\xae\xfe\x02\x92?\xa0\x17\x80\'\xaai\xed?N\x97C\x1c\x7f\xa1\xcb\xbf\xd2*\xd4\xb0r\xf9\x91\xbf\xda/\xf9\x17\x8d=\xda?\xf1\xd0\x0fY+h\xf3?\x82\xbeQ)\x9d\x12\xb8\xbf\xe2\xf8\xdc"\xaa[\xff\xbf:\x87$\xceb\xaa\xfa?\x03p~VR\x98\xd6?\xb3\xbb|\xde\xaa\xe1\xe6\xbf\x95\x08\xf9#j\xe5\xe6?\xdf~\xd3#\x1c\x87\xf6?\x95\xa3\xf3\xa3\xd7_\xa7\xbf\x90/iHY\xef\xf2\xbf\xdb\xc9a\x18>\x13\xf7\xbf\x10Y\x99\x19s\xd0\xd6?\x8f\xc6\xec\xd0\x80\xd5\xff\xbfF\xeat\xcc\x8a\xa0\xe3\xbf?A\xedm\x16\xeb\xe2\xbf`\x89\xac\xe6]\xa2\xf5?U~$\x89`\xf6\xdd\xbf\xe8?+<\xcb\xbc\xc9\xbf\xae\xa2\xe1\x06)\x89\xd0\xbfZ\xd3C\xc6(\xdd\x01\xc0\x9fr\x99X\xe9\x1f\xf4\xbf\x0b\xa9s \xe1D\x01\xc0\xa5\xaf\xda\xa1f\x07\xfd?\xaa\x08\x8eB@\xee\xfd\xbf\xdf\xba\x9bIY,\xf5?\t\xb5\x1b\x1f\xfd\x03\xd0\xbf2\xe5\xe4\xad\x1fm\xe2?R\xa3\x8c2\t\x03\xdf?\xef\x9a\x02\x02\xca\xe8\xb1\xbf|@\xe1\xf2\x9b\xd3\xd5?\xc8\xc7\xb7\xf1\xbf\x12\x83W\xa5R\xb8\xea?\x97\xdb\xb6\xd21\xfe\xed\xbf\xf4\x94\x07\x1a\x9f\xe8\xe5?!S\xc9\x07\xcd\x9b\xfc\xbf\xfc\xf5\xd6\xeb\xe2\xbe\xf3?\xe5[1NG\x89\xe0?\xaf\xe1\'\xd3\xd0\x1f\xae\xbf\xdb\xce~\xf1l/\xe5\xbftMbE\xc6r\xd0?\x9dU/\x8dP\x83\xf0?\x9e\xb3\x85\xc8S\x9a\xed\xbf\x8d\xafA\x8c\xfa\x8f\xde?\xab-\x05\xcb\x00\xb7\xe8?M\xa9YkkX\xdd\xbf\x93\xb4\xc5\x03\x15g\x06\xc0\x1c\x95\xa1\x1c\xd0\x8f\xf4?\x9a\x901nx\x1b\xe7\xbf\xe2\xf4\x04\xcdl\x81\x1e\x8a?Q\xbb\x96FE\xa8\xe9\xbf\xed\x9f\xec\xdc\xac\x02\xe7\xbf\xae\r\x82\xc8.N\xf4?\xc1\xdd\x0b\xa3}\xe9\xc1?\x13)\xf9t`\xec\xdb?\x80\xf9\x8f\xb32\xe7\xf4?\xea\n:\x04)\x01\xeb?\x91\x7f\xf8\x16\x17\xd4\xb9?\xd5y\xd5[\xedb\x95\xbf\x01O%<\xc7~\xd2?K\xd1\x11\xaf\xe9\xdf\xf3?\x02\x9emq\x89l\x05@p\xe3qt\x9e\xa4\xe2\xbfl\n\xe3:\xf9\x94\xe3\xbfm\x9e\x8d_wg\x01@\x03\xa7Lp\xb7\x8d\xd8\xbf\xd6\xee=\xee\xd6\xef\x9e?\xd0\xf8\xe3\xf7\xda4\xf1?O\x7f\x90\xff\xc9i\xf0\xbf\x0b\xfc(YF\xa7\xed\xbf\xfc\xcd\x89\n\x97(\xe7\xbfz\xaa\x8a\x08\xe0J\xdc\xbf\x03.\xbc\xdf4a\xfe?.35 \x90\x85\xf1\xbf\x16\n\xd6\x95\xb8\xcf\xd7?.\xb5\xfdN\x82R\xeb\xbf\xd0\x1bH\x1f\xee:\xeb\xbf\xdc\xech\xb8\x0eG\xe2\xbf\x08e\x7f\n\xf7\x02\xf1?\x8b;\x19\xaf#\xd9\n@\rh\xfb\xb8*U\xdc?b[\xb4\x05?\xd6\xd1?kj\xd2\xe2M\x80}\xbf\x9d?\xc1f\x8c"\xe6?sY\x16[\x97<\xfa\xbf_\xfb\xc2NI\xcf\xc5\xbf\xfc\xe5A}e\xd8\xe7?\xa7kv\xf0\x8c\xe0\xdc?>\x8a{\x8d%\xac\xe8?\x17S8W\x9a\xf6\xbc?N!\x7f\x84\xa4\x04\xe8\xbf\xbb\xd1\xe3\xd2\xf0\xa5\xf4?\x85\x07Ty\xa6\x87\xf5?qb#\xb1M\n\xeb?#\x0fA\x07\x8fd\xe0\xbf\xee\xe1{\xed\x8f\xa4\xe8\xbf?\x9aYG{\xb2\xe1?\x00\xb3=\x03o\xd8\xe6?\xfe\x16\xd2\xe1\xaef\xe6\xbf\x84a\x0b\xb0#\x86\xe0?P\xe0\xbd,)\xf7\xe5?\x95\x08\xdc?\x03\x96\xfc?\xc0\xc9\xb8\xf3+\xf7\xd0\xbf\x99x\xd4\x01\x17\x88\xf1?\xc9\xd2\xe5r8\xef\xf6\xbf\xd1\xeb\xf5,\x05t\xee\xbf\x90\xf2\x8a\xe7\xabe\xf2?jI\xe7\x125\xc7\xe2?\xa0.F\xe1\xe3_\x02@\xfeRHr\x7fi\xea\xbft\x9e\x7fJ\xaf\xfe\xb5?\xda\xf3\xa0q\xce\xa3\xc0?\xdb\xfb\xf3\xb5:\xe4\xce?\xf7\xb9\x81cv|\xec?\xd9\xe9\xf9\x1d]\xd9\xe7?\x9c/,\xcaF\xef\xf0?\xb6\xb4\x9e\x1b`\xec\xc6\xbf\xe6\xed\x1bx\xef\x86\xc1?\x19\xca\xace\x7f\xf6\xed?\xfb}v\x95\xff\xcd\xdb?\x19B\x05\xd8\xad/\xd2?\x18\xba\r`T\x05\xd1\xbf\xc0\x119+/\xfe\xfc?#,w\xcc\xb4\xcf\xe5?S\xf9\x06\xbd\xef_\xb5?Z\xd9\x14=\x117\xdb\xbf\x14\x858\xa2\x8c_\xf9\xbf\x14\x0e\xbc\xb8\x17\x05\xf2\xbfL2\xfeCt\x10\xe7?\xbal<9\xfcj\xc9\xbf\xbc\xe3\x08\xa0Z\x95z?\xc8\x03JN\x8a\x0c\xdd\xbfiK\x91\xa2@v\xe7?k\x82Ab\xbdd\xe1?\x94yQ\x9f\x1cZ\xc2\xbf\x14y\xc1d3\xbf\xd5\xbf\x03v1\xd2\x99\xbf\xf7\xbfa_\r\x9f\xd8k\xd5?,\xd0\x92x\x01g\xe9\xbf\xa2\xc8m\xbd\xc9\xce\xb8\xbf\x13\xd1\' \x94z\x04\xc0\xbaC\x01NH\xb8\xbb?\xab\r\x05\r\xf1R\xe6?\xa5\xd8\xd7\x9e^c\xe9?\xcc;\x8c\x19_\xb0\xde?\xb9q\x19)u\xfd\xf0?\x7f\xb6\xbf\xb6\xda\xdb\xd2\xbf~\xa4xux\xbf\xf2\xbf\xa8%\xa5(\x16\x89\xf2\xbf\x82\x8dE\x96%\xf0\xed?\xf7\x14\x8c9\x02t\xeb?{4\xd9\x11H\xd4\xf0?\xc6\xb6\xfdR\xa1\x87\xdb\xbf\xab-VD7A\xd1\xbf\x05\x1f\xdfmw\xf7\xe8?\xcc&\xcf\xc6\x17\x95\xe8?ge>\xc9\x8e\x1b\xe9\xbf\x85\xfcg\n\xa5\xff\xef?\x7f@*J\xfd\x9a\xd3?=\x1f\xa5.\x94|\xee\xbf\x82^\x81\x0f\xa8\xdf\xf2?\xe5\x86\x90\xf0\xb9\xb5\xf1?w\xa2\xa1\xb7\xb0\x8e\xcf\xbfx\xb3D\x08\xae\xef\xe2?\xad\xf3z\xd0{-\x00@7>\xed\x84\xbd\xd3\xf3?\x8a\xc22\n(C\xfa?\xcc\xb5.\x97\xa7\xcc\xe9\xbf\xe3\xf6\x92U X\xe0\xbf\xca\x88\x1a\x123>\x08\xc0\xc9q\xe0\x13H\xa6\xf3?\xb0\x19\xb1\xa2\'4\xfe?\xae\x94*\xdeC\x98\xef?V\xff\xd1\x9dIb\xd1?\x904C\x819\xf8\xc7\xbf\xe2\xc4\x8f\xb7\x94z\xd9?\xe6o\xe0\xe9\x82\x16\xc5?!<\xb9%\xeb\xb5\xf8?\x07\xa2I\xf8\x1c\x83\xa6?c\xc5\x06p|\xf8\xd0\xbf\x1c\x16ur\xe1\xbc\xfa?\xfc\xdd\xbet\x8c\xa0\xb1?\xcb\xdc\x94@[\xb8\xee?H\xd4}\x99\xec\xa1\xf1?\x81h0c\x95`\x01@\xadzFK\xb4\xac\xf1?*%\xfc\xb4bI\x02@4\x13\xc8\xe88+\xdd?\xef\xde\xc5\xa9\x974\xf8?uZ\xf4g\xb8J\xd1?\xa0\xb4^s\xd5I\xbb?\xfe\x10\xfd\xf1\xa8S\xe6\xbfz\x91\x98vhp\xeb\xbf+MFa}\xf4\xf8\xbfj\xdf\xb0\x99oy\xd5?\xed\x98\xa1\xaf\xdf\x0f\xe4\xbfI\xbc\xa5w\xe6\xc9\xad?\x10Z\x8d\xca\x96\x0c\xf1\xbf\xaf\xa8\xa8\x7fC\x1c\xdc\xbf\x93Za\xab3`\xf5?\xaa\x92ri]1\xf6\xbf\xeckV\xf36\x0b\xe5?\xe0u\xab\xbbE\x18\xd2?B\xd5\x18\xc6\xdct\xb8?\x8dLh\x06\xb6?\xfb?V\xe4\xc4\xf2m\xb6\xdc\xbf(\xaf\x8e\x1b\x8d\xb5\x02@\x89\xec\x87%j\xee\x02@c\x87\xc0E\xff\xf1\x04@b\x14\xdd\xcb\xfd\xb7\xc9\xbf\xab\xda\x00\xb8\x8a-\xd3?\xf5\xc71tC\x9a\x08@\xf2\x0b\xbaS\xab\x85\xe1?3\x84\xd0\xbd\xa3\xbf\x02@8j[\xb5x\x84\xf4?\x00Q\xbcq\xbe\xa6\xe3?c\x80\xb3W\xa5\x9c\xf9\xbf\xbb0\xb4\xaa\x14\xc9\xf6?\xecC\xb8f\x9ez\xf1\xbf\x03\xf8\xa9hm\x93\x95?\x87\x03\x1e\x1a\x013\xc8\xbfT3\xe8\xe7\xca\xd6\xc8\xbf\x94\xd5q\xda\xa6\xf1\xec?\x9aT\x1c\xfdjb\xe6?af\xd5\x821\xa3\xd7\xbfG<\x0f\x18\x11\xe2\xee?\xae_(\x85|L\xe5?\x11\n\xdb\nYY\xc3\xbfo\xe8\xea\xaf\xa5\xa8\xd3?v\x87\x11Ej\xd7\xec?\xf6\xb5\xcc\x8d[<\xda?xZ\xff\x0c\x9d\x7f\xf5?Xy\x95\x10\xf1Q\xd1?\xf2\xd24\xc6 \xcc\t@\xe9\xb3u\x96\xb3\x06\xe6\xbf\x92QN\xac\x94\xc0\xe6?\x9af\xd6A\xc9\xa2\xef\xbf\xbc\xef\x8d\xc8\x1b)\xf3?9\x96i\xf8\x9c\xcf\xf0?\x9a\xe3\x19\xfa\xa7D\xf0?\xb5\xde\xe3\x9c\x98\xc2\xe0?w\x19\x00B\xb6\x12\xe0?O\x17\xa0\xd0?kov\xbd\x08?\xd2\xbf\xa0Z\x02d?\x10\x00\xc0lL\x19\x9cxC\x00@[5\x8fn=;\xfe\xbf\xe8|\xe0\xa8 \x1d\xf1?\x18\x87e\x0b\xa7v\xc2\xbf\x17\xe4_\x9a\xff\x0e\xf5?\x8d\xd2\xef/!y\xe4\xbf\\t\x84\xa8V#\xd6?\xe9\x9e\xf7\xff\xfc\xb8\xf7?;\x1fR\xe1\x9e\x15\xe4?R\xa9t\xf59\xbd\xf1?U\x8b\x124\xc8f\xd1?\xa6\xcf\xf8eq\xa0\xec?\xd3\x95\xf5D\x9c\n\xc3\xbf\x08\xa9\x9b\x0f}4\xd3?\x87\x0b\xcclEN\xbe?i\x92\x7f\xe1\x97R\x05@\x9e\x83\xea+\xdeZ\xc0?\x10\xeb\xfcB\xdb\x91\xcf?\x04k\xe4C\xe7\x18\xeb?\xc1\xec\xb4\x9e\xd7\xa6\xe6?\xaa\x18\x01$I\r\xe3\xbfC\x81\xc0q\xd7\xab\xe2\xbf\x08\xbdeD\xca\x82\xf4?\xf95\x8ej\xb6\'\xe3\xbfn%_\x13\x83\x1f\xec\xbfr;\x0c\xf8R\xc6\xe5\xbfp\x9c\xadT\xd4\xed\xec\xbfx\x149\xd2\xa2\xfc\xde?\xa8\xbb\xeb\xbf\xe1\xaa\xb9\xbf\xe9\x08\xc1\xa0\xd28\xd8?7\x91\x93P\xb4\xd0\x00@\xdf\x7f\xbfE\xb4\xef\xe8?lfc\xc5}\x83\xd2\xbf\x1d\xd2b\xc6\x81\xde\xf1\xbf\x9f\xd6\x7f<\x02\x01\xf6\xbfq\'\xef\x97\xeaC\xff\xbfrYj\xa7p\xa1\xcf?\x0f@d#|\xe8\xe6\xbf}-\xbf\x1cT\xf9\xf4?\xe5"\x1a\xdd\xd7v\xf2?\xc4\x91\xff@\xac\x92\xe5\xbf\xe5\x8f\x1bu\r\xa3\xfb?ZT\xdb\x87!<\xf0?\x92\x15-\xf6\xbb\xcb\xe6\xbf\x83\xf2X\xbf\xf4?\x07\x87Co\xd9\x93\xd6\xbf~\xcd\xfd\xc4\x0ek\xf4\xbf<\x19\xcaJc\xc6\xd4?\x8b\xb4/#\xc4R\xd4?\xcc\x91\xb5P\x9f9\xdb\xbf\xe1\xfe\xa9k#\x03\x05@2$_\x05\xb3\x88\xdf?\xfao\x81\xca\x03\x11\xf0?\x92=\x9dC\x1d\xf5\xd4?\xab\xd5L\xfe\xcf\x8c\xf5\xbfR>\xd7\xc7\x82\x87\xf5\xbf\xbev+\x7f;\xf1\xe0?V4\x7f\x87\xc6\x16\xf1\xbfB$\x065\xcc\xe4\xab\xbfMu\x13\x8fA\x85\xb4\xbfl.\xce\x0ed1\xd9?k.\xaap\x9d?\xe6?`)s\x9a\xaf+\xd9?\x0e\xa2\x05\xa6\xcb<\xce\xbf\xf86\xbe\xe5&\x8e\xe5?\xc2\x8f\xaf\x16z6\xcf?\xb1\x9fC\x99\xf6\xbd\xd8\xbf\xa0\x90\xaf\\\x88s\xd5\xbf\xfc\xc3\xea\x15\xc2\xd9\n\xc0\xb5\x82\x91+jM\xf2\xbfD\xb0yt\xa6\xb5\xf3\xbf\xf9\xcb\x16_t\xd5\xc4\xbfN\xef!T\xdd3\xde?\x12n\xe7\x96?\x85\xcf\xbf\xa8\x99!\xe6\xe1\xf9\xd3\xbfS\xb3e3uF\xe6?/?u\x8c\xbdy\xed?\xe6\xd7\xb2\x86\xba\xdb\x00@F$U\x87R\xc7\xc6\xbf\xc0i\xb2\xf4JQ\xec?\xf4\xe5b\xb27T\xb3?.\xb6\xf1\xd0\x0f\x85\xf6?\x8c\xf7\x06-\x07\xc9\xca\xbf6\xc9sM\x83V\xf4?\xae"\x81\xd23\xa1\xa3?%~!8\x86M\xcc?:I\xa9\x16\x10\xf7\xce?U\xc3\x0f\xb7\xe3\xc3\xf3\xbfb\xfeN\xb1\x03\x03\xb4?\x016<\x87\x85\xf7\xe2\xbf\xcd\x9d\x066\x19D\xf3?t"`\x15`P\xc0?\nB\xac\x00\xe5\x82\xea?\x99/8x\x84$\xfe\xbf+\xc3e\xc4\x98b\xfd\xbf\x8c\x02\xa3\x04\xdd,\x00\xc0\xaa\x97\x86\xe0\x00\xe9\x03\xc0\xc8I\x892\x88\xa7\xf4\xbf\xe8`S\x03\xe1+\xf0\xbfk\xd9>\xadz\xa8\xc4?\xe6\xc5\xfdW\x11\x99\x03\xc0\xd3\x85\xebda_\xf6\xbf\xe0\n\xbc[d\x16\xfd?I\xd5\x8e\x98g7\xf4\xbf\xeb`}\xb9\x10\xfc\xda\xbf9\xa1\x1c*\xd4\xd6\xf5?\xd55\x1b\x05L\xb4\xfb?\xaf\xf8\xd7\xf0\xca\xed\xc3\xbf\xe93\xc1Y\xa3~\xba?\xa12{\xc4L\xcf\xf6\xbf\xac\xbe~\x11F[\xac?K\xd0\x9d\x15\xf5\r\xd8?\xa5\xa3,\xc3\xcb\xc9\xd4\xbf\xa2\xc3\xbfw!\x05\xf6\xbfq\x96\xd9\x9fJ\xa8\xf3\xbfI\x1cr\xa7R\x85\xe1?\x9f>\x8d\xda#=\xf4?a[\xfd\xa8\x15\xca\x08@\xd4\xec]m\x11\x86\xf4?\x8b\xf7GQ=\x02\t@\xec\x7fB\xff\xb7s\xe1?\x9d9\xe3\x99\x87\x88\xe6?\x1b\xc4\x1e\xe6\x92\x8e\xf8?k\xbb\x8b\xed\xaeS\xf5?\xbb\xb2\xce\x9a\xc6\x1b\x00\xc0\x18\xc6\x04\xd5\x9e\xc6\xf2\xbf\xbf\xd2\xfa\xaf\xb4\xbf\x8e\xbf\xb73\xf4`\x13H\xda?,\xfa\x13km\x83\xbd?\xefj\xf6g\xe2\xa0\xea?@j\x0f\x9c\x82_\xee\xbf\x03t\x06\xee]\xbe\xc5\xbf\xb2q\xf6\xb0g\xb1\xcd\xbf\xbff\xe8\xfd\x81B\xf3?/)\xbb\xa2g\xca\xe4?\x1d\x879\x86e\xc7\xbe?\x93\x0fN\x0f\x83\xb2\xe2?\xe2\xfd\xb0\xb8L\x85\xd5?\x8a\x1fI\x19k\xf2\xf8\xbf\xef{\x80\x0f\xdf}\xe1\xbf\x08\x9e\x8e\x06\x90\x85\xeb\xbf\\4un|\xde\xe2?\x91I\xbaL(\xd9\xf9?\xa48\x10\x05$\n\x01@\xb7\xc60&u\'\xe3\xbf|\xeb\x14\rv\xf0\xf7?\xbd=\xba\x13\xe0\x1b\x00@M\xc2\xec\x1b\xd3i\x05@\xbd\x16\xc9\xb1\x9a>\x01@\xcaytA\x86M\xfd?4\x12\xf4\x89g\x8e\x02@\'!\xf8C\xa5}\xfb?\xec\xc3\xebL\xde\xd5\xec?\x85\x01\x9f\xf6z0\x01\xc0\xb9Yr\xb6s\xa2\xfa?B\xcb\xc6#\xc3\xc0\xde?\xeb+q\x04?\xde\xd2?\x91\x16\x8c\xe2PD\x02\xc0\xa7\x94#\xc9\xc1\x87\x00\xc0\xf19\x90Jg]\xf0\xbf\xf1\xc8\xe8OTn\xe7?oi\x03\xd3\x9c\xbc\xf3?\xdao\x91\t|\x0f\xd8?\xde \x84\xb5\x96_\xbd\xbf6\x99\x81o:\xa1\xd2\xbfO#\xdb\xcc\xde\xdf\xf1\xbfT\xf5\xd1\xa66\x0f\xd3\xbf\xd3\xa4\x90\xe6\x12\x94\xf9\xbf6\x16\x89k\xc7E\xef\xbf\xc6\x1b\x9e\xa0S\xaf\xe2\xbfY0o{\xa1\xe6\xd9?\xf7\x87\xfap\x9d>\xf8?\xa2H\xaf\xe2X\x00\xd6?\xd6W\x8b\xe7\xca\x90\xf9?\'\x8d\x82\x8c3\xf6\xeb?~|b\xd0i\xa8\x05@H\xde\x1a\x15\xd0\x10\xce?\x1e\xce>\x03y"\xf9?q\x0cc\xf5w\x1c\xe1?U\x1aIJ\x1cj\xc3?k\xc1\xda\x0bn\xc4\xd2?`p<_\x9c\x15\xae?\xa5\x1e\xf6n.\x0e\xe2\xbf\xe1\xe9\xe1<\xee_\xfa\xbf\x7f\x14|\x886\xd9\xe9\xbf.\xce|\xfeA1\xe8?r\x9d\xe9n\xf1\xa2\xe4\xbfw\xd9\xf4\xd6\xb1+\xe1\xbff\xdd\t\xea\x8bW\xe4\xbfaD\x83\x0e\x19(\x02@M\xce\xa3\xe5\xfc)\xd2\xbfL-+\xc9Y\x01\xf3?\x96/\xd9(=\x8b\xd8\xbf\x96\n.\xe3&\xcf\xe1\xbfM\xad\xd0\xd2N\xcd\xb6?\xb5\xc6\x7f\xf8\x95\x97\xfb?\xd2\xe9b\x08e:\xf7\xbfp\xa5\x0eH"\xcf\xf1?q.\x07b\xb9\xd0\xe2?\xd8\x80\xfaZ\xa7\x1b\x02@\x1e\x98\xea\xd2\xda\xed\xd4?y\xfa\xd8\x11\x9a\xab\xf2\xbf\x0b\xcf\xb7\xe6+\xf5\xf4?:\xaf\x8d?$n\xfd?\xf78\x10\xd0@(\xb3\xbf\xad\xeb^T\xce\x05\xc8?k\rnw\x87\xf1\x04@\x99\xa8}\x0e\x14p\xef\xbf S\xbbs\xf0\x10\xd9?J\x8a\xe2ri\xeb\xea\xbf\xf1\xc7\n\xf6\x07\x01\xe0?b\xb0\xb8\xbf\x1e>\xe8?f\xb9\xbf^\x840\xfa?\xaf\x91\xef|\xfa\xea\xdd?+\x91\xed5\xed\x0b\xf2?\xec\x18\x88\xcd\xef?\x00\xc0\xb7\x07\xa5Od\xec\xd3\xbfS>\x8a\xc0\x0f\xd2\xe6?\xee!\x91\xc5 $\xca?\xe0\xd4\xd08F\x12\xb3?\xb9\x88\x05\xd6Q\xbb\xdb?\x1a\x17\\\xf3\xb7r\xf0?5\xfd\xef\x81\x85\xbb\xfd?\x16\x80,\x1dtL\xd9\xbf\x1f\xb5db\xd7|\xce?\xe6\xbf\x13\x08TP\xf2?\xa8\xad\xd4R\xcb\xdb\xc9?\xfe9\xf37\xfd\xb0\xe5?\x93\x00\xb3\xf9\x9e\n\xe7?2h\xe1\xc8\\\x7f\xec?\xe9\'\xea\x1d\xbe9\xff\xbf\x9c\xe1\xfb\x06\xe4\xb0\xdd\xbf2k\xf6\xedK\xcf\xd8?\x99jd\x11\x07\x9e\xe2?\xe9w?\xf1\xd8\x8e\xab\xbf\x95\xb0\x8f)\xdd\x14\xf4?+y0\xb7o\xdc\xd9?\xcc\x06\xef\xf1\x91]\xf3?\xe0\xa3T\xe7.\xc3\xe4\xbf|i=\x18\x96\x8a\xe6?!P|\xf4\x14\x02\x9e\xbfh\xdbG\x04_\xb3\xf9?\xde^\xbe\x92\xe8\x83\xf1?\xe7\xbd:^\xac/\xd8?(\xfd+Cca\xde?\xcc\xb4\xc7h\xfa\xa7\xf0\xbf\'_K\xe8Yc\xea?\x0b6\n\x8b\xd2\x83\xeb\xbfP|HJ\x1em\xf0?a\xddc\t\xe94\xca\xbf\xf2b\xd0\x08>\xcd\xcd\xbf?\xfe\xbc\xd6&J\xd6\xbfa\x83\xb9\x8aiu\xdf?\xc8nYgP\xb4\xf2?\x9f\xfdq\x11\x96M\xa1?.\xce\x0eh\n\xf8\xe2\xbfh\xac\xf2!\x84+\xd3?E\x80V`\x8d\x92\xbb\xbf\xea/\x8a\\X\x16\xe7\xbf\xaa\xf7\xcf\xb7g\x89\xf7?\xfa\x1ft\xf9V6\xdc\xbf\xe6Q\xc6\x0e\r\xad\xe0?\xff\x8b\xad\x06S\xde\xcf?s\x02\xfc\xda\xc2\x0b\xeb\xbf\xbb%s\'\x7f\xe5\xc3\xbf\x17\x9a\xf0\xda\xe9j\xfe?\xfe\x13\xd4\x9b<\xb0\xfc?\x98\xe4;\xcb<%\xd3\xbf\x82\xb68%\xc2G\xb9\xbf\xc6\xcb\xd4u6\xe5\xcc?\x82"\x01\xbb\xd4;\xcd\xbf\xa1\x99]\x9d(\x1a\xe5\xbfA\x0eC\xd2\x8c=\xdd\xbf\x88\xfa7BUD\xfe\xbf\x96W\x8b=m1\xe7\xbf+\xd1"\xa3\x0f\xf2\xf2\xbfb\'6%\xb5;\xea?\xd4}\xae\x8b\xbb3\xd6?\x1f\xb6\x00\xb4\x15\x03\xda\xbf\xb2p\xb3oU\xe4\xe4?\xd64\x1e\x9b\xf8H\xe7\xbf\xd9m\xafh\xe5\xd3\xd7?\x92\xd3E"\xc0\x9b\xb1?\x9c\xfa\x1c\x0e\xde\xdc\xd0?-7\xace\xdf\x8e\xeb\xbf\x9e\xb8"\nWu\xbb?\xe0o\xf2\x02\xf4\xfb\xfc\xbfV\xf55=\x1a\x9e\xd3?\xb0\x15\xe3\xf54\'\xfb?\xb2\xdeC\x8d\x01g\xd3?\x11\xf2\x02\x9bG\x86\xe0\xbf\xb4\xdb\x9c>_\xfb\xdf?P\xf87\xba\x8d\xff\xdf?H\xc12\x00~\xe5\xcd?\x17\xb4\x0c\x1c\xab\xee\xf2?}\x08\x9d\x05\xa0\x90\xf0\xbf\xa7\xc7\xd39\xa30\xe8\xbf"\xe83\xd6D%\xf6\xbf\xc6\xa1N\x1c\xd0W\xc2?f0~\xeb\x04\xae\xf1?\xe1\xfe\xa6\x06z\xa8\xd3\xbfe}\x00I\xc5R\xe5?\xf7\xb8\xd1H\x0f\xfc\xe2\xbf\x82I\x9f\x9c=\x90\xb6?\xb7\xd0\xe1@\x86\x80\xd4?\xa7\x135\xcf&\x10\xf5\xbf\xe8\xb6C\xc9<\xf7\xd2?\xaf\xe4\xfe+Vr\xed?\xb7\xb3\x9c\xd3s\x01\xb5?\xf2\xdce\r\xf4\xba\xef?\x90#(\xd2\xed\x10\xd4\xbf\xb6A\x80\xa7\xf5\xcb\xc7\xbf\x049\x02\x8f\x9fd\xfd\xbf\x86\xf7\xd9\xd0\x1aJ\xa0?F\\\x99K\x8a\\\xf7\xbf+\xe3\x9e@\xec|\xed\xbfZf\x95t\xb6f\xe3\xbf\xcb\x15[\xdat!\xe5\xbf\xbd\xcf\xccA\x05o\xfe?\x81\xde\xf9*\xe5`\xb0?D\xe0g\xa1\xe1\xbe\xd6\xbf<\x8a\xf1R\x19\x1c\xec?p\xad\xf7\xec\xe2\xdc\xe2\xbf/\xc2A\xd3Bl\xf3?\xb6[\x8d?\xcaU\xfb\xbf=\x83\xe1\x17\x8d2\xd9?\xb1\xb4\xbaEsM\xf2?\xdc\x8eM\x13\xfdo\xe4\xbf\xd9\xa8\xe9k\x00S\xfe?{\xa8vY\xae@\xed?\xc5\x00x\x81-;\xd3?1s\x8a\xef\xa4\xc6\xdd?d\xbeT\x85\x068\xbb?\x90\xbb\xa2\xf1\x0e3\xd0\xbf\xb9\xa7\x06\xbf``\xe6\xbf\xb6\xa1\xba\x17\x15c\xf6\xbf\xa5O\x98\xd9\xc5@\xdd?\xf7\x85\x8d\x0e\x83\xd6\xe4\xbfA\x08t\t\xef\x19\xe3?\xe2=g\xe0[\xbe\xf2?\xe0z\xc6\xcc\xe4\xb8\xce?\xec\xb6\x81\x0b\xac\xba\xe4?o\xea$\xf0\x10\x87\xee\xbf\x94>\xa8\x16\xc2\xff\xe3\xbfV*R\xdb67\xe5?\xf3\xc5^\xcb\xa2\xc2\xbd?\x96f\xbd\xd2S\x18\xf1?\xb7n3\xa8Bz\xde?\x06\xbb.\x17\x99\xb8\xff?z\x81\xbf\xce\xf7\x84\x81\xbf\xb5t\xd6\xd2,2\xbd?\xe4\t\x91\x93\xa9\x9e\xe6\xbf\x89\xd7\n~\xbe\xaa\xf0?\xf0\x87\x18\xb2\x98\xb5\xd0\xbfJ\xa7\x05\x88\xe2\xf2\x00\xc0\xbe\x86\xf4Loe\xec?N\xae\xff\x1ci\x91\xc4\xbf\x07\xe7p\x93\x10\x0e\x02@\xe4\xe6\x1ay\x1b\xc3\x02@\x0c;nH59\xc3\xbf|k\xa9\xa0\xdb\x8b\xdb\xbf\xd3\xa8ji#\xf6\xdb\xbf\x0e\xa4\x89%u\xd5\xea?\xb6\xc0\xe7\x0c?\xc8\x00@\x88\xfd\n\xb75K\xc2\xbfK.\xf5\x0e\xdb\x8c\xe5?\xf8\x1b!\x8dHb\xef\xbfo\xb5\t\xe6\xa3\x93\xe9\xbf\x1e5\xefxh\xa5\xda\xbfg\xae\xa2\'\x11\xde\xd3?w>\xff\x98\x89\r\xde?\x88\x0c&9\xfd\x04\xee\xbf\xc7o\x1a\xbb\x0c\xed\xe9\xbf\x1b\xe5\x7f\xc6\xd7\xe4\xf6\xbf\xa3\xf3\xf1z\xae\xc3\xe4\xbf\x1c\xa5m\xd7\xb1>\xf0?q\xc9eu\xe0\xae\xde?\x82\x81^\xe3\x7f\x7f\xf8\xbfm\xdf-z\x8c\xa6\xd6\xbfC0b\xbf\r0\xeb\xbfW|\xa6q*3\xea?\xe6`b\xd5\xefB\xdf?\x9d\xc5N\x89\x9b\x0e\xf4\xbf\x8f\xd0!\xa4\xad\xb5\xd8\xbfq\x03\xd7m{\x82\xf3?\xb5U\xa9\xe3|x\xec?\tM\xd5\xa5"$\xe0?\xd6\xfb\xe6\x00\xd1?O\x9e\xcb\x1d\x1c\xf4\xf2?5\x1f2#_\xb2\xc4\xbf\xc8H/T\x9c\x05\xff\xbfm\xeeJe\x15\x94\xe6?2g\x00\x89\xde\xfb\xc5?\x8a\x1aZlDU\xda?\xb6\xb4V\xc2!\xad\xf8?\r4I\x1f\xd0K\xfd?\xab_-Xcm\xc7?\xa7\x96_f04\xf9\xbf(/\xb1\xf0\xaf\x1a\xec\xbf\x0b^\xcf\xea"\xc0\xe5?\xc6\x90\x96{\xbfu\xf9?\xab\xd7cG\x1b\xe6\xd5?\x8b\x7f\t\x18-c\xdd\xbf\x95\xd7\xc3\'f#\xff\xbf\xd5F\xae\xe0\xde\x19\xf2?\x17\xb1\xf9\x92\xc1\xe4\xf6?\xa6\xa1\xad\xc2U\x9b\xd0?[,\x8en\x0f\xb4\xe6?\x05&UY\xf4Wd\xbf:+e[\x0c\x8b\xe9?\xe5@he\x03\xcd\xdc?#><\xea\xb9\x81\xf3\xbf=\xcd\xc8h\x13\xdb\xc6\xbf\xe2r\x13\x89\x0c\xbd\xf9\xbfq\xb7S)\xb7\x17\xfb?\x13\x02\xd0{\xc80\xb1?Z\xc4\xfbj$\xd1\xe4?\xfc\xa2Oe\xef\xf1\xc1\xbf\xd3\x1e\xda^F\x8c\xf0?Uk!ol\xb2\xcf?\xcb\rF\'\xe0I\xe9?\xda\x13|\xef\xcd\xca\xc8?\xfcn\x07Z\xdfp\xd0?\xa995\xe6\xce\x06\xe9\xbf\x11;\x15\xbc.M\xd0\xbf\xdc\xb3Z\xb9\xc5\x89\xd0\xbflIC\xa3\x0f\xe3\xf7\xbf\xdb\xbe\xdd\xd3_\xce\xbb?\xe9\xbbP\xf3No\xd6?\xa3\xa2\'\xde\xc4\xff\xb8\xbf\r\x9c\xd9i`E\xe9\xbf#\xdd\xd8\n\xa5\x1f\xfb\xbf>\x99\xdf\x9eN\x96\xd5\xbfo?\x05fGV\xea?\xb1\x1a\xba\xd0\xc6\xdc\xd0\xbf\xc6\xe1\x07\xac\x04#\xf3?\xef#h\r*_\xdf?z\xd1\xa3\\\x9c\xe0\xe3?+\x0b\xd2S?\xf1\xef?\xd0e\x89\x18\xbd\x8e\xa9\xbf\xfc\xa3\x19\xb5\xa2:\xff?\xbf\xfdp\xbb\xaa\xaa\xdf\xbf\x16\xc1`\x8f\xe7S\xfe\xbf\xa7\xd3\xc6i5\xca\xc8?v\xf0V\xe7\xa5M\xfe?\xba\x97K\x81\xb2\xed\xd0?\xc8\xf4\x90\xdf\xcc\xeb\xd2?\xe7A\x84\xc6\xeb\xb6\xe3\xbf\x15 \x1b\xe9\x83\xe1\xdc?8\xe7\xf2\xfc%\xcf\xf6?\xfd2\x0e\x90\xb0\xa8\xd8\xbf\x13Q=\xe5]\xff\xdf\xbf\x08;\x8a\xba#\xec\x86?+(^\x1d[\x85\xc4?\xb4\xd6\xea\x90%\xf8\xf1?\x18\xd4\xcdYm\x04\xe7?\xf7U\xcf\xbe\xe9\xcb\xd5\xbf\x9d\x1b\xfeM\x84\x88\xfe\xbf\xc2I\xf81\xb6\xc8\xea\xbf5\xf3\xd1\xd8#\x87\xfe?\x80\xd0\xa8\x00\x80\xc2\xcc?y\xfeO\xcb\xdf\x96\x9a\xbf\x86\xc7LN\xc4\xaf\xce\xbf\x94\r\x1b\x7f\xb4\x13\xe6\xbf\xa9&\xd5\x15MP\xcc?\xa4\xe5\x9c\xc2B\xcd\xf4?~Dn\x84tC\xf1?\x97\xaf\x03y\x07\x0c\xf3\xbf\x85\xbb:\xfb\xe2\xd0\xd0?eK\xb5_\xc1%\xda\xbf\x7f\x0fXB\xf7\x8c\xd9\xbf|,\xdc\xb7uJ\xe4?\xb6\xbe\xfd\x1b\xa7\xea\xd9\xbfD\xedUNp\xca\xd3\xbf~\x99\x00\xbcO\x0b\xe7?O]\x85\xf0e8\xf1\xbf\xaaL\xb5\xae\x84\x88\xf5\xbf\xacL\xe2\xf1\xf97\xf0?`I\nq\x08R\xed?\xd2\n\x11G|\xbc\xe6\xbf\x8f\x12\xd5\xfb\x0e\x8b\xe0?!\xa4\xf9\x9f\x99\x90\xe7?\xbdC\x81\xf5\x9f\x98\xe2?\xab\x86\xe37\xff\xe8\xe6?(\x03\xac\x0bH\x1b\xd4\xbfY\x18\x17\xa8*w\xc8?\x83\x11\x83\xb2\x9c\xe9\xeb\xbf\xa2\xe1\xbd&7\x96\xf8\xbf\x01g\x81\x84\x1a\x86\xec?\xbbl\xe9\xae\xe9\xc7\xfc\xbf{\xa2\xa4G\x7f\xe3\xa0?o\\\x9bg\xc2\x94\xd2\xbf\xca\x141i\x92\x98\x01@y\xd1\xf9\xd9Y\x00\x06@$pC\xeb\xcc\x80\xf1?\xf7\xb1\xce\x08K\xc4\xf4\xbf\x06\x16\x9b\xd2\x97\xd6\xe4?v\x11d\xdc\xb6\xa0\xec\xbfj\xbc\xb1\x81L\xd3\xd9\xbf\xb6\x97\x8e\x84M\xe6\xcb?\x89\xf1l\x82\x8f\x90\xe2?\x85\xa0\xee\xad\x18n\xdc\xbf\x0b)I\xb2\x17C\xca\xbf\xcf\xc1\xc9}\xfd\xb8\xde\xbf\xd4\xb5+4?l\xae?n\xdf\xfe\xc1Q\xee\xf2?\xaf\xbeY\xde6a\xf2?\xc2\x17\x1e\xcb\xe5\xe2\xde?\xad\xf0j}\xb3\x95\xe8?\x8f\xba\xfe1\xcbR\xfc?\xa7\xf5\xba\xb2\x84\xd8\xee?\x13\xa3\x8b\xa4\xc6\xf5\xda\xbf\xb6\x89\xd6\x90\x16\xd2\xec\xbf\xd1%w!\n\xdf\xdf\xbf\xf3<\xca\x1bB\xfe\xe5?\xcb\xe2\x8e\x8e\x8eA\xef?V\x19S\x04[\x17\xdc?&\x19]\xf9\xe5.\xd8?\x16\x98b\x82i\xb2\xd9?~\xb6\n\x9b\xe2\xc5\xc5\xbf\xda\x96\xdb\xcb2\xbb\xe7?\x11`\xd6\xae\x1f\x85\xf1?\xd9-/\xea\x03`\xe3?tr+\xed\x95\xa7\xda?#\\\xdf\xb3\x1f?\xe7?\x80\x97v\x91%\x19\xe2?\xb5\xfa\x14\xb4\xaaP\xd9?\x90Se\xf6\xf3\x19\xee?y#L\xc7\xe8\xb0\xde?\x1f!\xa9\xfc\x92B\xf8\xbfw\x00\x1b\xf7\x03d\xe8\xbfcB\xf6!\xfd\xe1\xe8?L0\xfbT\x8f\r\xd9\xbf\x92\xe2;\xdf\xdcm\xf1\xbf\xf9\xba\xd9\x0bAZ\xf1?-\xd2\xdb,\x0e\xbe\xb5?m\xf2\xa71\xe3\xca\xd3\xbf\xe3\xc00\xe7I\x95\xdd\xbf\x83S\x9c4\xf2u\xf3\xbf\x96f\x98\xff4\xa0\xe2\xbf\xe2\xfe\xa0oa\xfd\xeb\xbf\x8a]\xb8\r\xcc\x19\xeb?\xb5b\x8e>\x06=\xda\xbfo\xc2\x8dK\xde\x11\xf5\xbf\x85\x8b\x04k\xc1\x03\xc0\xbf\x95\xa7\x14}D\x92\xf3\xbfd\xc5u\x00/\xb7\xe5\xbf\xbb\xba\x92\xd5\xe3K\xf3\xbf\x7f\xdc\xc3J\x08\xbe\xe2?\x9b\xfd\x1a\xab\xe9&\xe3?\xbf\x06)\xb5\x84V]?\x93\xe2\x857\\\x9e\xc0?\x19EUci\xcb\xc3\xbf\xdbXX3\xe3$\xea?\xe1\x90\xed\xc9\xc6\xc3\x97? \xedE\xbb\xefO\xf5\xbf\xe5P\xadD\x16%\xc7\xbf\xe9\xd6EY\xf6\xab\xf2\xbfA\xb0\x93-Mx\xf5\xbf\xa6\xb92\x84E\x84\x08@\xea5\x93\x87\xd5g\xbe\xbf\rl\x9b\xa5YT\xf1\xbf }\xad\x1f\xa84\xc7\xbf\xc34CmL\xf1\x82?\xe7Tv\x1e\x8c\x8a\xc0?\xbd\xe32\xa1j6\xe1\xbft\xc3\xc5\x01\x13\xbf\xe8?L6\x19Y\xf3\x03\xed?\xdc\xa9(\xd4\xabH\xc0?"\x11\x812\x8c\xba\xed\xbf\xc2O\xec)M\xcf\xe9?\x82\xb5#\x1b8(\xa3?\xb8&\xa5\xa1O\xbf\xf6\xbf6\xfc-f?\xc6\xe3\xbf\x05\xb3t\xb4\xbd\xba\xd7\xbf-\xd2\x12z\r\xa9\xf5\xbf1\x122\xad\x00\xbe\xd2?5\xb7\x82\\\x1d\xbe\x9f?\x08\xa3,.\xf5B\xc7\xbf\xd1,\xf9^\xc9\xa5\xe7?\xee\xa5\x82\xb1.\x1b\xf3\xbfZE\xe4\x055t\xf7\xbf\xcf\xbb\xb6\x1c]j\xc3?,\xaf\xf8\x97\xa7\xbe\xea\xbf~\xdb\x1b\xbeq;\x00@1\x01\'\xc5\xe4\x8f\xb0?\xa5?\xb7\x15\xa5\xee\xd2\xbf\x9ar\xda"cx\xf0?\xfa\xd3\xd1%r\xd3\xfc\xbf\x86\x9209\x0f\xf4\xed\xbfB3\xc6\x16\x9bx\x93?T\x9e\x9f\xeap\xe8\xe0\xbf\xca\xbfG\xcb\x81\xbf\xf0\xbf\x83\x96\xfb\xeb\xd7f\xe8\xbf\xa0\x8e\x98\xf0I\x10\xf8?\xca\xa7(eMn\xac?\xdd|\xec\xedp\x8b\xb2\xbf\x93\xc4c\xbe\xe7\xc1\xbc?\xf4\x0b]\x16\xba@\xb5?R\xf8\xde5\xc7m\xcf\xbf=b\xed\xaf\x99l\xb8\xbfe8\xd2\x0fF\x83\xe9\xbfX\x07\xda\x0e\x91\xd8\xf4?]\xa7\xd6\x9a.\xf5\xf9?\xbf\x9bP\xb6bF\xf7\xbfVJ\x9f\xd3\x00\x05\xf4\xbf\xbd\x03\xd5U\xaa\xd0\xb5?\x17\xc6\x07\xf9(1\xe4?\xa1\x9c.\x11"/\xf0?N\x1c\xf5\x92\x8a\x8b\xd3?\x15\xfc(>\x08=\xdb?V\x19O\x84[\xdd\xe5\xbfM\xf10\xfd9!\x06@A\xe6\r\x1f#J\x0b@\x9cZ.\xbd|J\xdd?\xe4j\xec\x9c}\xdb\xbf?\xcf\x8c:\xd1\x1a\xb7\xe1?\x03\x8e_\x91=+\xcd?x\x101\x83\xf9"\xf4\xbf\x82X\x83\x12!\x95\xec?\xcd\x8b\xc82\x04F\x03@\xc0\x90F\xd6\xaf\xdd\xd0?e@=x\x9dm\xd0?\xdb\xebp\xff\xe4\x8a\xd0\xbf%\x12\x10\x071\xa2\xbe\xbfQ\xf3\xf8\x93n\x1f\xed\xbf\x8a\xee\xe2\x80\x95L\xf0?ds\x84\xea@}\xf8\xbfB\x9d\x1d\xd8\xfbQ\xf8?\xa4\xf1v\xc8\x83\xee\xcb\xbf\xae\x82\xd3\xecQ\xc1\xdb?\x0c\x9eLz\x1b\x94\xa9?1\x14G\xe0\x1b\x15\xe7\xbf>\xaf\xc5\x88\xb6\xd2\xa8\xbf\xdb>\x11\xd3%]\xd9?\x03\xee\xa6M\xd5\xff\xcb?\x7f\x08p\x93\xfb\xe0\xe1\xbf|9\x0e6\xb0I\xee\xbf"EhJ\xf8\x8a\xe3?\xe3\x9b\x14>\xa5\xea\xc6\xbf=\xe2E\x7f%\xc3\xbc?\xc4cW\xaf4\x85\x05@P\xad\xf9\x8a\xfc\xf8\xca\xbf{\x91\x1b\n\x07n\xf0?\xb0\xbe\x0b\xd6\x16\xf5\xcd?\xc4b\x86F\xe1\r\xfb?\xbb<4\xa1\xa7%\xeb?\xd2\xb6\xa8\xb5CU\xcb?T\x07$Hi\xba\xe5?\x86\xd3\xb3\x14s\x88\xf4?!\x82AT\x12\xff\xbf\xbf\xe0\x02\x0b\xcbEn\xd5\xbf\xe0u\x16 w\x86\xb3?\x807\xc3O\xa7R\xf5?\x19\xd2\xa7`v\x08\xd7\xbfw\x10U\x0b\xa9\xa3\xf5?O\xfac\x96|I\xe5\xbf\xa4\x98\xe0c\xe7\x90\xd5?\xc6\xce\xba\x19kh\xe4?\xb0BZ\xee\xdfN\xf1\xbf\x12t\\\xc2\xed\x1e\xfb?\xa3\xbf\xe8Drx\xfe?Q%\xfc\x87U\x1a\x06\xc0\xc4{\xef\xd2\x98\x91\xdc\xbf\xf0K\xd9\x8fxz\x00\xc0k\x93P-O]\xf3\xbfl#\x92\xdb\x86\xb1\xd2\xbf\xc4*m\xdeR\xed\xf5\xbf[9\xa8\xa5\xbet\xe5\xbf\xb0)9L\xeb\xbc\xf6\xbfy\x17\x92\x92+>\xc7?\x7f\xa8\xcc\xf8\xcd\x8c\x04@}L\xf0\x9286\xf4?\xb0\n\xb4\x94\x1a\xea\xfe?{\xab\x19>Sa\xd1\xbf\x1c\xc5N\xbe\xafn\xe3\xbf\xed\x9ai\x9d\xf2\xdb\xda?\x84IaMp\xb4\x00\xc0\xef\x1c\r\xd5h\xbc\xf5\xbf\xb8\x01k\xc1\x84\x02\xf2\xbf\xf9\xed\xc7%T\x8d\xc8?\xf8N\x0e-\x97\xea\xef?\xf6\x00:\xe3\xca:\xfe\xbf\x8c\xbb\xa7\xb6|\xbf\xd8\xbf\xb0\x11K\xef{\xb5\xfb\xbf#\xbcma\n^\xf9\xbf\x9ez\x7f\xeb\x08\xc5\xf1?H\x9f\x97\xb3\xeep\xef\xbf\xbe$pT\xa2"\xd8?\xc6\x8e\x9fy\xefI\xda?I\xcb\x80\xf3H\x7f\xf3\xbf_Q\xe1\x8b\xa5"\xcb?\'\xd34\x11H\xfb\xe5?7\xc7\x17\x93\xf0\x1e\xfd\xbf\x06X\xe9\xd4\x98.\xe1\xbf47\xea_ )\xf1\xbf\xcc\x8c\x81\xf2#\xe6\xde\xbf:\xd1\xb4\x16>\xb0\xc6\xbf\xcbi\xd6@\x1c6\x05\xc0 \xec\x8bW|\xb3\xec?-7\xa7y\xf6|\xca\xbf\x8d\xfa\xa1\xa7\x8c\x94\xe0\xbf&Cc\xdf\x01z\xfc?\x10\xd9\xb2R\x1f<\x03@g\x89\xcan\xfd\xe3\xeb?\xe31\xc4\xf4\xa2`\xd9\xbf\x94uu_\xe7#\xea?\x94\xff\xd7\x15\xeeY\xed?\xf1\x88\xa7\n\xc2i\xc9?\xe4\xa7\xaa\xf7\xc8\x06\xee\xbf\x00\xdd\xbad\x7f\xbf\xc7?Y\xc1\\\xa1\xf3\xc0\xf0\xbf\xf5\xbb\x80V\xe3\xdd\xfa?\xe4\xd1\xd0\xa2X\xfd\xe2\xbf\xf1\xdd\xa4\x0b\x92\xf2\xc8?\x93\x90@C\xd4t\n@\x11\xde9\x97o\xba\xf7?Y\x1f\x84\xd6Hk\xe1?\xce\xa8\x8a\xa6\xf4m\xeb\xbf\xf4\x90=\xcb\x91\x80\xb8\xbf.e\x96m\xf2|\xf0\xbf:\x1a\xa6<\x12\xe4\xd2\xbfc\x06CE\xb0h\xc4?\xe0\xb4\xdfh\xbb.\xed\xbftt\x12\x80}\xd9\xd6\xbf\xda\x93p\xb2?\xba\xf8?$\xe5h\xfc%\xe3\xe2?\xe6\x89X#/\xed\xe2?t\x1d,$m\x9c\xd3\xbf\x18\x8b\xeaY\x9a\xc4\xd1\xbf\xa8V\xf5\x85\xc2\x08\xf8\xbf\x90\xbeZT\xb3\x81\xa6\xbf"\xcc~_f\xc8\xf0\xbfv)\xd6\xcb\xfd\xd5\xd8\xbf\x1c\x07\x1e;i\xba\xcf\xbfF=\x16\x00x\xee\xe8\xbf\xe1\xbd\xc7\xd6O\xa7\xfa?\xe3\x89\xe8\xf0\xef\x0b\xf0?\x83+3\x10\x87 \xe4\xbf>\xb3\x08\x1b\x03o\xb5\xbf\x8e)\xb4\xf3\x822\xf9?M\x8e\x040\x1a`\xfa?\xc6\x1b\xb7si(\xbf\xbf\x1dh\xe4\xd1\xb2\x85\xca?n\xa5\xc2\xc7\xc1\xa5\xed?H_\xc7\r\x96\xf7\x03\xc0P\x07\x16\x0e\x00\\\xfb\xbfiDt\xda\xfc\xf1\xd7\xbf7\x83M\x86\xa5\x00\xf1\xbf\x06H\x9a\xa3uD\xbd\xbfA\xb96g\xd7s\xcc?s\xa1\xaf\xf3\xd2=\xf5?\xa4\xdeqg\xfd\x0e\xed?k\xdb\x19w\xc3n\xe5\xbf\xb0\x04\xb2\x8d\x9b\xc8\xfd\xbf6xjpQ\xd7\xf5\xbf\x89\x91P\x865\xfa\xa4\xbf\x0b\xb6\xa6\x9c\xaf\x12\x94?\x19z\xf7X\x8e0\xe0\xbf]\xe3\xce\x8f\x1aR\xb9\xbf\xe2\x18B/\x80V\xf0\xbf[\x10\x90\x12\x06/\xdb?\x7f\x13\xa49+\xab\xb3\xbf\xae\xc6\xca2\x0f\x82\xf8?\xe7\x1e\xf6\xc1v\x8b\xea\xbf\xc3\xd3T\x94\x06\x00\xe9\xbf\x99\x03L]\xaf\xcf\xcb\xbf\xcbY\xc6iQ\xc1\xc8?\x9ab\x08\xcb~\xe7\xe1?\xed\xf9l\xcd\xc5\xdb\xdc?*6\xa5\xaeV#\xc7?\x92\x04\x0c\x80\x1f\xa1\xd8\xbf\xa7l<\x81[\x0c\xd3\xbf\xde\xb7A\x0b\xc7}\x0f\xc0\rU:\x1f\x97\x97\x03\xc0C!2\x8e\xf1\x15\xd5\xbff\x17\xc8I\xd6\x85\xce\xbfjZc\x08\x99\x1b\x00\xc0E\xfd\xb2}V\xd9\x00\xc0\x80\xd7\x1ae\x8c\x16\xe5\xbf\xf0\x1f\xad$c`\xcc\xbf\x03}s\x8bB\x0b\xcc\xbfsr\x02\x82\xb3\x00\xf2\xbf\xa2\x85s\xb7\x05\x03\xf8\xbf\xeaC\x01c\x7f\x9e\xea\xbf\x16\x95\x84y\x1a\x80\xc0\xbf\x95o\xa0\xce\x15:\xec\xbf\x07\x88RE[\x82\xcc\xbf.\x9f\xd0\xfb\xa7\xf3\x05\xc0\x82vM\x1c?\x10\xe5\xbf\xb3G+w\xc7\xbd\xf2\xbf\xeaOp\xfd\xf6B\xf6\xbfG\xf0\x01B\xb9n\xf1?_\xa9\xbe\\|\xa6\xd7\xbf<\xef\x89\xf6\x15\xa7\xdc?\x9c\x8a\x02f\x7f\xad\xf1\xbf\xa4u\x17n\x08\x93\x05\xc0PB+`~!\xf5?AJc\x90>\x10\xc0\xbf@\xf2\xa5*=+\xe0?\x83;i\x17:,\xe4\xbf\xf9\xdadJ\xda\xd2\x90\xbf\x8d\xe5\xaa\x1a\x96\x04\xfe\xbf\xcd\x07\x9ce\x1c\xf5\xf6\xbf&\xf8Z%\x87`\xf1\xbf\xfa\t\xfa`\xafS\xe3?\xbeL\x12\n\x05a\xe8\xbf\xbcK\x85\xabQ\xbe\xef\xbfw|\xf9,;I\x04\xc0\n\xeeQ\'\xd1Z\xf4\xbfa\xc3Y|j\xaa\xc2\xbfn7kv\xa3L\xd6\xbf\x8d3\\\x1a\xe2\xbf\xdb?w\xc3\x1cs\xbaw\xb9?R\xcd\x8c\xc8Y\xe1\xfc\xbf\xdah\x14\xd4/\xc3\xd2\xbf\xee\x08\x00\xc5\x0f\x16\t\xc0x\x91n\x1d\n\x8a\xf4\xbf\x9d\x08\xf8X\xb00\xd2\xbf\xec4\x9c\xf5\xa2\'\xe1\xbfFs%\xbf3\xd0\xb7\xbf\xed\x96\x93\xbe\x97\xe2\xf8\xbf\xff\x8d\xf1\xa6\xc3M\xba?:N\x8c1S\xdf\xdf?\xafN\xce55\xc3\xe4\xbfr C\xba"\xe7\xeb?\xdf\xd8\'\xfe\x8f\xcf\xff\xbf8\x10#V\n\x8c\xc3\xbf;\r\xa4\xdb\x07\xd9\xd1\xbf\x13>\xd9\x83@\xa3\xfb?W\xc8m\xa3\xbb\xe8\xcf\xbf\x07c-ct\xb8\xd8\xbf\xba\xf6a$0\xde\x01\xc0\xeb\xd6>\xb0\x91\xb1\x04\xc0\xd5T\nE\xab\x90\x06\xc0K\x19\xd2L3\x11\xfa\xbf\x97,t\x90M\x80\xf0\xbf\x9c\x99\xe6\xb32M\xa2\xbf\x84\x1b>\x84\x06\xfe\xf6\xbf\x1b\x1d\\\xaf"\xec\xf4\xbf\xc8\xb2\xf1\x17\x95\xf2\xfd\xbfC\xa2\x02\x8f\xe71\xf3\xbf\xb4+\x85\xb7?\x9b\xff\xbf\x9dm\xa2\xcb\x13\xb8\xe9\xbfR\xe5\x02#2F\xc0?\xcdQW\x88\xca\xb4\xe1?G\xd8\xb7\x91v\x9f\xff?+\x1f0\xa9/\xbb\xe9\xbf\xcc\x15m\x82\xc7\r\xf2\xbf\xb1\xc71\xeb\x88\xc9\xe3?/\x91,+\x12\xea\xeb\xbf\xcd\x87D\xbf\xd4\xca\xd1?#\xcb\x9c\xb1>\xfd\xc5?2v\xc2\x103\x8b\xfe?\xd9z\xb7W\xa9\xfc\xfc?\x03\xe3\x8d\xcf\xf8\x83\xe0\xbfv0\xf2\x8a\xdd_\x82\xbf\xe6\x1dy\x12\x92\xd0\xd4?\xf4\x87Z-\xf6\xa2\xf1\xbfD\xfa\xdf\xe2H\x87\xef\xbf\xfa\x1bY\xb9\xbf\xc9\x9f\xbf0x\x17\x97\xa3f\xc3?\xfa\xd2\xc43\xe0\xf1\xfb\xbf\xb0\x05r\xb9*\'\xee?\x13b\xf7\x01\xb5\xdd\xf6?\xea\x866\xca\x9b?\xd7?\x8b\xd1r\xbb\x17\xf7\xdd?q\xc3d\xdd$5\xc7\xbf\x03\x94\xc9\xb8\x99$\xd4?`R\xf7\xaa\x92\x1c\x00@\x8f\x97r^}M\xe6?\xa9\x83|\xffi^\x02@\xaa\x7f\x10\x86\xa5\x90\xe5?\xba\xbc5\xcd\xd7H\xc6\xbf\xc7\xeb\xdf\xbe\x90&\xcb?\xf2x\x1e\xb7\x04\xd6\xe7\xbfH\xa4\xc4\xa1\xd0\x94\xf3?\xbd\x07\xe4\xb8k\xd7\xc2\xbf\xc8\xb1m0\xda8\xdf\xbf\xc4\x1cOX\x8f\xb8\xe5\xbf\xe9\xb9\xdd\xb0y\xb5\xc4?\x05\xc3\x0e\x1e\x01m\xec?4r\xb4C\xb7b\x03@\x14\xcc\xe06\x02\x97\xf8?\x9b\xb4\x94\xef.\x89\xd8\xbf\\\xa7\xec=\xd0\xa0\x84?\x8d.\xb2W\xe6\t\x04@\x1f\x18\x86??\xad\xe7?\xe3\xaf\r\x83\xff\xd0\xf6?\'\xdb\x00I\x83b\xc7\xbf\x17R\xaeJ"2\xf4?\xa9\xbcn\xf9"\xa5\x02@\xcc\x86F\x06\xb4\xb6\xdc\xbf\xd0!\x02GE\xf3\xe6?@\xd9\x8d\xbf5\xba\xd6?\xa9p(@I\x1d\xea?S\x8aU\\\xaeJ\xb5\xbf\x03\x93R\xf3\x89\x9f\xe1\xbf\xd1\xb9\x82\xd2\xf4p\xf2?q\xa8\xc0}\xeec\xc4?\x10\xe6tP\xd6O\xf3?3\xb4\xb6\xb6\xc4\x9a\xe8?\xbd,\x1bg7\xb4\xdf\xbf\x83\x80\x04\xe3\xdd\x00\x00\xc0\x92\x05gV\xd8\x98\xf5\xbfh\x17\xcf\x07\r\xd1\xf9\xbf\xc8\xcd\xe6!B\xed\xcc\xbf0"\xb3b!\xe2\xa6?\xe4E\x8c.\xfa\xb0\x04@\xad\xd6\xd2\x90\xa6&\xff?K\xef[Qs\xcb\xde?\xe2\xa7\xeb\xcf\xceg\xf5?e\x9a\xff\x86\x8dF\xfd?\x14G\x8f\xf7~\xe4\xd5?\xc4\xa5\xc8\\\x03%\xf1?\xa9<\x9f\x1a\x05=\xff?\xb9\xa5\xf5\x11\xf2\xa9\xb5\xbf\x84\xdd\x90\x10\xd79\xf2?\xb90\x9aS\\\x10\xca?$\xc1\xb1\x05-\xba\x02@\xf1\xea5\xd29\xf6\x01@\xb1\x82|\xddp\xf2\xc0\xbf\xd2\xb2\xca\xf1\x80\xe8\xc9\xbf\x8f\xf5\xdcH\xf7\x87\xe1?\xb3\x04j\xe9=Z\xfc?\x1a\xc0\xce\x02\xf2\x00\xff?\x94M\x01\x1eE.\xe8?m\x17\x9f\xb9\x80\xcf\x02@\x07b\xa8\xca\x19\x85\xd7?\x8f\xa0\xec7uj\xfc\xbfY\xeaz-\xd3\xc9\xe6\xbfk#\xba\x04\x9c@\xd3\xbfS\x9d\\\xbb\x88\x0b\xf7\xbf\x04\x96$u\xc9_\xcb?\xb7\xddg\x18\xa5\x96\xce\xbf\x9cu\xfa\t\x1f \xf2\xbfXp\x186l\x08\xe5\xbf\xe5lU\x19\xcd\xfa\xf1?&\x06V\x90Q\x16\xda?N\xf3\xda\x10\x92\x98\x01@\x17)\xd4\xc2\xbb6\xc1?\xefU+\x1bLB\xfb?phFa\xab\xfa\x00@08{\x0b\xfeC\xf5?yD\x15\xe2\x1e~\xf9?J\x1eY\x96Hr\x01@\xacsU\xe6\x01\xbe\xfc?\xe27\x1ffzM\xf0?9>P#m\xcb\xfe?U\x97\xca\xcd\x9e\xbb\xf6?B\x17@$\xe1\x93\xe8?~\'\x86mq\x05\xcd?i\xc2\x99\x0beW\xe4?Y\xfc\x8b\x8c\xd7\xef\xf3?\x81\xfc\x01\x8b>7\xed?\x0fXu6z\x80\xdf?\xb6\xb0\x1aMu\x04\xe6\xbf\xb9\x14 n~\x02\x02\xc0\xb3\xccj\x81\x93\xe3\xef\xbf{\x8aZ\x15\xb4N\xe0?\\ \xe3\x96D\xd1\xb7\xbf\x85\xf6\xabD\x8c4\xf4?D+S\xd3\xa0\xe3\x85?\xe8\xde\xeavwS\xdc\xbf\xf4\x06\x02P\x98N\xd6?\xd5\x03\x9c_\x86\x84\xd8\xbf\xb4\xd5\xbf\xcb\x9e\xc2\xd4?C\x9f\x0b\xd2+N\xdb?\x11b\xdb#\\1\xf1?\xab\x9b\xc2Q\x02H\xeb?h1\xe4\xab\x1d\xce\xa3\xbf\xa1\xb2D\xeb1\xa4\xa5\xbff~y\xc8/\xb1\xf3?|\xec1\xa0\xafG\x03@\x11K\xd4"\x7fk\xe7?\x12\xbe\x99\xc8H\xb6\xf7?\xdc4\x91\xf6\xe9\x89\x00@\xc4}d\x8c\x12v\x03@;\xeck\xb2\xe2\xce\x01@1O\xff\xad\xdc#\xe8?`4Y\xd8\'\x91\xe2?2\xe3\x8c\xdf+1\xf5\xbf\xd7\r\xd7~\nN\xf8?\xd9\x8d\xe6\x132F\xfa\xbf\t,\xcf\x97\xc0]\xfe\xbf\x8f\x82\x06k\xcdj\xdf\xbf\xde\x8b\xe13a\x10\x02\xc0:d\x0e\xd1\xa2\x89\xfe?\xeevv\x81\x9a\xf7\xa2?\x1e\xa1\xe7\xa1RW\xd3?>W\xd9\x84;3\xbd?y\xc7\xda\x0f\xf0\xc3\xca\xbf\xf8\xb6M`\xc4I\xe9?R\x94\xdbP\xcc\xe5\xf8?\xce\xe4\xad\xe2\x14\xec\xdf\xbfp#mZ\xf71\xc5\xbf\x17^+\xa56l\x05@e\x10\xb8\xe7_\xa9\xd6\xbf4\xa0y-\x8e(\xd4?*\xce\xa5Y\x98\xc1\xd9?\xbb\xff6M\x87,\xe2?m\x9c\x13\xea\xd9~\xe6?\xd0\xc3`\x93\xf5\xc4\xe8?\xfc\xadXN/\x94\xd3?\xcf\xf2\x99\xfa[ \xd7?|\xc3\xb5z\x92\xd2\xe9?Z\xaa\xc3\xecq\xfd\xd6\xbf\xf3g\xdd\xd7Lq\xeb\xbfb\xa4m\x1b\x19\xcd\xde\xbf\x83\x955 \xb5\xfb\xf9\xbf\xe2\xf8sO\xf0\x7f\xdc?\x91\xb7\xad\xf2?\xb3z\xbb"WE\xe8\xbf\xe4\x8d^{zY\xee\xbf\xeb\x1e\xe6\xff\'\xf9\xdd\xbf\x1b\xb5\xa2\xf04\x85\xe7\xbf\xe3\x89V\x89\x14\xbd\xe7\xbf\xac\xb5\xe1HI\x9c\xf4\xbfN\x13\xdeI\x1a\xc5\xa1\xbf&Ig\xd9\xc3f\x03@\x99\x9f~\xa7R\x0f\xf3?\x99I:\xb21\x80\xe1?\xd3(>\x84\x90z\xde\xbf{3\x1b\x1e\x98V\xb0\xbf\x13p\x07\xa1\xe4\t\xfa?\x9b]\x82\xc5\x01\x13\xf5?\xd9C \xa3p\xe3\xf8?\xfa\xb4\x12\xd5\xbf\xa7\xe4\xbf\x16/\xcb\r\n\xad\xf4?\xb3H\xef\xb8\xee\xdb\xe4\xbfn_\xe3\xab\x88|\xe4\xbf8\x1e\xc1\xca\xaa\xf4\xe3\xbf[\xb0\xb6\xd2q\x16\xb0\xbfG`\xed\xa5\x02\xd9\xd8\xbf,\x00\x86\xb5\t\xce\xcb\xbf\xbb\\\xe5\xff\xa1\xad\xf6\xbf\x9c\xbe\xe6\xda\xa3\n\xf5\xbff\x13\x05\x8due\xe2?\x06\xed\xe5\x07\xa2\xa3\xb6\xbf\xd0\x03c%w$\xc1?\x1b\x7f\xfb^\x03\xb9\x03@\x01\xd1D\x8e\x147\xc7\xbf\x1d\x15\xd0\xe2\xa9\xbd\xb8?\x8aCj\x92\x8c7\xdd\xbf\xf5\xccod\x18}\xe6?8\xf1\xc5\t\xbb`\x02\xc0\x8c\xfe\xe1\xb6~\xf5\x06\xc0\x127\xcb\x19\x1f\x8d\xf2?\xb5\xc4\x87\x91D\xac\xc8\xbf\xbe\x1b\xee\xc5AB\xf1?\xec\x03\xfbE\xc4\x7f\xfc?r[d\x03\xc7\xec\xed\xbf\\\xbd7\x7f\xad\x17\xb7?\xa2\xd6\xab\x03~\xb8\xcf\xbf\xc2\xf62b"\xc9\xfa?!\x8ci\xccw\x1e\xc4\xbfAi\x96\xee\x01\x81\xfb\xbf)\x05\x92}\xad\xd5\xe8?I\xb9\x9bs\xe5J\xf9\xbf\xfc\xf3v\xa9\xba\xb1\xb9?\xa9\x90v\x90\x13\xc6\xf2?%d\xed\xfd&\x8b\xf8\xbf\x05:y\xfe#&\xda?\xbduH\xe1\'\xc6\xe7\xbf\x10\xe0b\xa0\x12o\x02\xc0\xcd\x93\x94\'*{\xdc\xbfK;\xa3\x05\xbd\xa7\xbc\xbf/\xdd\x9d\xed=\xda\xbb\xbf\x8e\xcfa\x1d\x14\xd1\xef\xbf\xa3(:\xb1\xc7\x13\xf0?\x96\xc5|\x9b\xe51\xd9?C\x92\x84\xef.m\xf6?\x15%\x93L\xa3\xf9j\xbf\x16\xed\xfc\xf9\x03\x80\xfb\xbf]3\x94D(D\x06\xc0\x9b\x87\xc8\x9d\xcf\x88\xd7?~\xa6\x0b\xaa!D\xe1?V\xaa\x05+\xd6\xd2\xcf?\xb8q\x8c\x8f\xf2\xb9\xee?!\xd9-\xc5\xabV\xe7?\x96"\xd1\xe7\xf6\xae\xd1\xbfB\x1c\x8c\x9b\x16>\xe7\xbf\xc4\x8aX\x0b#\xb4\xe9\xbf\xc4\xa0\x80|s\x97\xc6?\xae\x9a\xbb\xd8\xf1M\xe6?\x00\r3\xef\xe2\xce\xe7?\xcb\xa3\x8cz|\xa4\xda?\x00\x8f\x7f\'g[\xf3?X\xee\x9d/\x1eX\xe7\xbfG\xf8+\r\x86\xad\xd3?\x81H\x9a[A#\xb0\xbfz\x97+\xach\xf1\x01\xc0\xa4\x91\xc5\x17\xe1[\xce\xbf\x1dS`#a\xe9\xdd\xbf\x1dZ\xcf\xc0\xe6\x88\xe8?\xd5\x80\x8dn\xe1\\\xe5\xbf~&\xb3Q?H\xe5\xbf\xd5T\xd83@\x83\xc7?\x8e\xf1\xbd"t\x15\xf2\xbf\x07\x84n\xe1L\xdd\xe0?\rB\xaaM)\xab\xc7\xbf\x95{\x9c\x7f\xe3\xed\xe6\xbf\xe4\x1cB?\xb1?\xf5\xbf\x92j\xb4U\x86\xe4\x04\xc0\x89\x8be\xf4\\k\xf9\xbf\x1e\x1c\xb4D\xd1\xe6\xf7\xbf\x05\xa4\xef4\x12\x88\xf4\xbf\\\xcb\xa9.\xd7m\xf0\xbf\xa8d,\xde\xf5\x0c\xa9?\x11\x1di\x1d\x05=\x04\xc0\xd1?\xfe?\x19L\xd6?\x9e\x14\xc2\xed\x10\x0c\xd8?.\x96V\xfc{^\xf4?\x1fz#\xb12/\xb0\xbf3UY\xa7\x17:\xf9\xbf\xb6\x8e\xaf\x97.\xbc\xfb?A\xe9\x00H\xd7o\xaf\xbf3\xf00\t\xcb:\xe1\xbf\x8d\x04=gM-\xe7\xbf$^^\x0e4U\xd6?\xb5\x16\x12\xa7\xbd\x1c\xe8?\xbb\xa4\xfd\xac\xa8s\x8f?\xd0s\xa3BO\xa4\xf3\xbf]z3\xc6\xe7\xa6\xe6?\x88\xb5\xf4X\x0bj\xdc?\xc0\xf2\xdf\t[\xda\xcb?\xe1\x91M\x16\xb2\xd4\xd2?\xf14\xb32\xaa"\xec\xbf\xa0AOd\x98\xc4\x82?\xec\x9f6d?i\x02@\x12$\xf3\x9f\x8bg\xe8\xbf\xb4\x0c\xfa\xe3\x02W\r\xc0\xcaZ\xc1}\x9cm\xd0\xbf\xf6n\x1b\xd3,1\xf1\xbf\xa2,\xb4\x16`\xa9\xe6\xbf\xb1\x02\x10}|*\xc0\xbf\x9c\xa5\x8576\xf2\xf4?\xe8\x82k\xf8\xe8\x0e\xdd\xbf\xd91r\xe2\xf4\xcf\xd8?\x9a\x07\xf6~A\x1d\xe7?\x07\xdd\xd6L\x00X\xfd?\xbfw\x05.\x1eA\xed\xbf\xc0Z\x0b\x14k.\xf3?TA\xba\xc0\xfc\x08\x04@3\xcf\xf8\xf7\xfc\xea\xa6?\xfc\xffw!\xde+\xf5\xbf\xddzB*\x9b\xbf\xd9\xbf9\xbb\x02p0\x97\x04\xc0PB\xd0lZ\xc6\xd4?wv\xd9\xfe\x1f\xe3\xed\xbf\xafo\x95\xd6\xee@\xcb\xbf\xda\x04h\xf3\x1fn\xed\xbfAk\xdd\xc4\x81\x87\xfb?\xbdc\x14"\xf28\xe1?\xd5\xb8s\x84\xe1A\xf7?_\xb9\x1e\x94o\x8b\xe3\xbf|]?\x17<\xac\xdc?\xcf\xfa\x10a\xb0;\xc6\xbf\x84\xf5\xbco1V\xfc\xbfS\xa4\xd1\xe7\xbd\xff\xd2\xbf\xd0\xa2\x9bT*q\x08\xc0\x17\x8b\xaa\x9d\xe0\x07\xe0\xbf\x10\x03\xd8\ns\xbe\x06\xc0\x16\x85\x17\xe2\xbfZ\xaf3\\\xa9\x90\xf0?\xfb\xa3g\x96\xde\xe5\xed\xbf`\x8a\x82i\x9eG\xe8?V\x89\x7f\x06\xf1\xb1\xc2\xbf\xd7\x8aD\xd3\x03\x88\xf7?\xaa\xf32\x8c5^\xe7\xbf\x97\x85\xa4\xf9\xb7\x97\xf7?\xce\xfd_Z\x896\xfb\xbf\xa7\xf1TGpZ\x94?\xf7\xec\xd2x\x13h\xda\xbf5\x83\\\xc0\x03\xa2\xb6\xbf$BD]\xbbT\xee\xbf\xf3_R\x8d\xdf\xf0\xe8?\xb8\xb0\x15\xc0\xe0\x13\xdc\xbf\x8f\xa2\xfa\xdc\x11\xe7\xc7\xbfPi\x91\x01y\xb4\xe6?B\xaa\xd7\xcc\xb0\xab\xf5\xbft\xf5\xa5\\\xef\xba\xb5?\xa324\xe1\x97\xe7\xea\xbfx4\xf51\x81\xd6\xcb?C\xa4oE>\x9f\xf0\xbf\xe9UfN\xc1\x06\xf3\xbf\r\x8c7\xce\xc0f\xf4?\x97\x9c4(\x81\r\xdb\xbf\xacy\x92\x9208\xf4?\xf7\xd7\x97\xa4\x94\xce\xda?z\xe8U\xff\xf3\x0c\xd4?\x9d\n\x1c\xe34\'\xef?\x9f&\xdam\xbel\xf7?z\xe1\x8c\x8bb\x11\xc8?D\xba\x1bV(\x13\xd2\xbf\x1f\xfakV\xa2\x15\xa9?yap\x9f\x19l\xc2?g[y\x8fC\x9e\xe3\xbf\xd2\xf7\xe5\xc4\xd4u\xc0\xbff\x01\x102t\xdd\x03\xc0\x06A\xa2\x98\xb04\xf0\xbf\xa6\x14+\x9dj{\xf3\xbfo\x94\xb2\x8e5p\xfd\xbf\x8aSE\x1a\ng\x0c\xc0\xe7\xd9\xe3\xc9\x1d\xee\xf6\xbf\xa9\x15z\xba\x12\x86\xda?\xea}\x8e\xef2\xa9\xff?%\xa9\x02s\x1e\x11\x04@_\xdcNGD\xbe\x00@\xa3\x81\xda\x836\xe7\xeb?M\xdb\xd7\x81\xc0\xa7\xec\xbf7*dV\xc2\xee\xf6?\xe2\x97,\x05B\xd8\xe0?5\x0c0l\xb2\x01\x04@\xe3qi\xa3\xc2\xa4\xf3\xbf\x83\x88\x07\xc1\xc5\x1d\xe2?b\xcf\x0f4\x0bl\xda?\xa4\xc4\xbf\x12\x13_\xfa?\xd3\x1d\xae\x90\xce7\xd8?~ZC\xd8\xff4\xea?3=M|\xd2\x8c\xe8?9\xd4\xed\x8f\n\x93\x01@\xbf\xcc\xc8\x1f~\xce\xed?\xf8C\xb8\xc3F4\xca?\xadu\xd8Y\x10:\xe1\xbf\x02\x95\xc9\xd5\xb7\xe6\xd0\xbf\x00\xfe\xf7l\\\xa2\xe3?\x99\xfa\xbf\xc4\xec.\xd8\xbf\x9fy\xd7vv{\xec?D\xb3\x18\x04*~\xe7\xbfV|\xf1\xef\x17X\xe2\xbf\xb536M\x8f\xce\xd3?\x89"+e1t\xf0\xbf\xb7\xe9\xb0\xe6\xed\xae\xf1?\x18\xf6\x9a\x007\x16\xf2\xbfw\xcc\xd3}\x8cE\xe9?\xcb\xa9E:\xf7\xef\xe6?\xa4\xef\xa8rU\xd0\xfc?\x905\x11b@\xc5\x04@\x1fk\xb0\xc2i\x08\xfe\xbf\xdf\xe7\x89\x0b\x87~\x01\xc0\xe5\xcd^\xecv\x13\xa5?Z\x8de\x812`\xcc\xbfuH\xc5\x11>\x86\xff?<\x11\xfc\xa6\xbf}\xe7\xbfbg\xf0\xadvH\xdf\xbf\x96*\xf7\xda=\xd1\xff?\xd4ST\xd5\xe4{\xc3\xbf\x85\xd3?\x06\x84\xdf\xc1\xbf\xc5\xd3\xc7?pM\xde\xbfPSyt\xcdH\xf9?\xfc\xdai\x98\n\x15\xde?\xc5\xcf\xd4fM=\xf9?\xe0\xe0\xebG\xe2\xf4\xc0?\xc6{\xc9e5C\x00@\x89;\x82\x19\x15\xb8\xcf?\xbe8\x98\xef\xb2J\xe5?\x8fE*\x93$]\xd6?T\x10p\x1c\tN\xb5\xbf#u\xd6)/4\xe5\xbfn^J\xc99\xd8\xf5\xbf\x13\xd0j\xab\t\x90\xc0\xbf\xea\x17;%\x06\xfb\xec\xbf\x91s:"u0\xc4?\xa2\xfbw\x8f\x81\x93\xe4?\xb9\xe6\xa1\x06\xd1\xbd\xe6?"&\xf9%\xba\xe3\xbb\xbfF\x81q\xc3mT\xd2\xbf\\]\x08\xa4\x85@\xee\xbf\xbe\xadl\x1a~\xa1\xf2?v\xc6WA\x97\xd5\xe1\xbf\x0b\x9c\x89\xf7\x06]\xff\xbfj\xe9K\xf2o\xd8\xe5?*\xb9X\xe1\x1dc\xf6\xbf\x93$b\xeaQ\xe2\xf5\xbfq\t\x1c0\x01\x7f\xf2\xbf\xc2\x90\xf5\xc5z\xf1\xfb?\x12\t\x00\xf9\x90\xa0\xd8\xbf\xfc\xb0Ez\xac\xfc\xcc?:\xfc8\xbf\xeao\xef?\xce\x0f\x96\xa7\xbe`\xff\xbf\xc4\xf9\xfc\xd7\xf6\xa3\xc3\xbf\xd3\xf0*\xbdU\xbb\xd1?\xac\xd9l\xff\x9a\xed\xe4\xbf\xcdE\x8fK \x9b\xef\xbf(\x96Z\x16\xebD\xf2?\xba 1\x9c!\x17\xc6?\xfb}\x1b\x14`9\xe6\xbf\xaf}M.\xa2\xdd\xd6\xbf\xd7\x82\x899\xbbP\xe4\xbf\x1f\xe6\xa3\xa9\xd9L\xca\xbfP\x8dFBEr\xf2?\xd544\xb0u\x07\xd2\xbf\x1fx;R\xb7}\xd9\xbf3q\xdf\xfbk\xba\xe4?z\xf8\x9a.\xf8\xb2\xdd\xbf\xfc\x05\x1bP\xfe\xc2\xe3?\xf4D@\x91\xc4T\xf4?\t\xcbYM\n\xd6\xec\xbf\xf6X_\x9b-\xc8\xf1?9\xb1N\xeb\x8cw\xc0\xbf\xc2\xf4\x86\x18\t\x89\x08\xc01\xc8\xfbC_\xe1\xf3\xbf\xbe\xcf\xd4l\x92\x98\xef\xbf\x17"\xf6B\x08\xce\xf3?\x11\x1dF#\xf3\xcf\xe5\xbf\xc5\x01\xc9[=\xa1\xd1?w\xd2\x91\xbag\xfa\xe6?\xfa\x0e&$\x01b\xec\xbf\xc0a\xc8\x87M\xf6\xdf?\xa4; \x1fB\t\xc0\xbdn\xe8J\xce\x92\xc2\xbf\x0cS;\xe4\xb8y\x02@\x93\xd9v\xd7\xa7\x1a\xf1?\xbc\xaa\xe7W\xb0\x93\xf4\xbf\xa4P&\xa1r\xf9\xe5\xbf\xf6\xdb\x05r(\xe8\xd9\xbfd\xba)#I\x10\xf4?\xa6\x0b!\xa2g\x85\xec\xbfk~\x18ug(\xe2?n\xb7O\xc5\xfe\x0c\xf6\xbf\x9bc\x97\xb0\xbc\x14\x02\xc0*D\x9e\xb5/\xeb\xc1\xbf\x80F\xc70\x9d\xbc\xe0?\xf5\xb2gdOc\x04@^\xa0l\n\xebY\xc2?\xa7\xa9\xe4\x08{\xae\xe2\xbf"R\xab\xc6\x9c\x98\xf0\xbf\xab\x96\xae\x91\xf0\xaf\xf3\xbf\x1f\x11\xb7\xd2\xf5\xac\xf9?\xb8\x03)m\xe1y\xe4\xbf\xa7\xf7\x91\x7f@\x80\xee\xbf\x96Z@\x85\x1e\t\xe5?%0K\xd5\xd0\x87\xda?H\xd5j\xb2\x95\x9c\x05@?\xa10\\\x1fs\xc3\xbf\xf5\xf6tcv\x11\xed\xbf\x84"o\xe5\n\x9a\xbd\xbf\x1c\xe8\x86^\xfb\xa7\xf0?Vm\x9acA\xa5\xbc\xbf\xe4&\xd8R\xbe\xd2\xf2?g-+\xe1\xcb\x17\xf2?b\xd4\xb9G/@\xf7?k!\xae\x04\xe3\x95\xf0?R9G\xfa\xff\xf4\xbb?\xb3\xd6\xfa\x97P\xc0\xd4?\xea\x85%S\xfb\xff\xd7?n\x94J\xca\xe8\xbb\xe5\xbfn\x93\x7fa<6\xd9?t\xc2Q\xf2\xb2\x97\xeb\xbf\r\x9e^\x92\xa6\xc7\xda\xbf\xf0\xa1\x01Z^\x87\xe6?\x1f\xd6y\x13\x1cv\xc5?\xff\x12\x17G\xe3\x9f\xf6?\tt?\xb9V\n\xeb\xbf\xf9\xd0.{\xbb\xfd\xc1?\xe7\x88\xe921\x8b\xe6\xbfF\xd1\xc4\x88\xce \xf6\xbf\xe3\x81\xf1UH\xe7\xf8?\x9e\x98\xc9+E\xe2\xd4?\xc8\x9d\xed\x9c\xc5\xb3\x01@qv\xfbz\xac\x1b\xec\xbf\x83\xcf\xb1\xf4R\xdd\xf9\xbf\x88cz\xd1j1\xbe?\x0e{\xed\xc8\x04<\xef?\xb3e\xd5*\xf4\xe8\xd1?S\xd0U3\xd6K\xe6?\xe7\xa3\xc2B&[\xdc?\x901[\xa75)\xf1?\xd10Z\xba\xcc\'\xda?\xcbx\xf9\xa4\xc8\x08\xe0\xbf\x8d\xd8:\xc6\xfa\x90\xd7\xbf\xfd\xca`\xbbf\xb4\xea?\x02\x89D~j\xc2\xc5\xbf\x0f\x8b)\xbeg\xdc\xdc\xbf\xe0\xa00uPE\xce\xbf\xbbR!\x8b\x1e\xd8\xe3?\xf2\xeb\xdaC\xbc)\xfc\xbf\xda?W\xfa\x11m\xd6\xbf\x88a\x15D\x08V\xfe?\xfb\x8c\x8f\xae\x98O\xe7\xbf\xa9\x17\xd4\xd83\x8e\xe0\xbf\x1c Bp\x82\xf2\xcb\xbf|\xa3U\x81\xd4\xf2\xf0?X[\x15\x8c\x05\x80\xec?\xfa\xc0\x95\xf8\xe0U\xe3\xbfQ\xa92|\xfd\x1f\xf5?\x9e\xe1\xf1Z\x85\x86\xf0?\x8a\x1c\x84\xd5\xb3\xde\xdc\xbf\x0ff\xf9!M\xa3\xcc\xbfX\xe7o\x1e\xd4/\xcd?A\xb8\xb7\x10\x10\xeb\xf8?\x12\x99@\xda7\x8e\xee?un\xc4i#\xf3\xeb\xbf5\x8b\xa7\xa3\x99\xa3\xe0?o-q\xa8\xef\xc7\xf7\xbf\xdf\x01\xe2\xc6\x88\x98\xc6?8+@\xa0\x0ba\xdc\xbf\x1e\xb3\x9b\xedV\r\xdb?\x03\nT\xf2L\xa9\xe3?\xb0\xa7j\x85\xfdC\xd6?\xaf-\xc4\x9c\xe3\x91\xc8?\x8d\xab\x11&\xf1\xbb\xeb?\xd7\xd3D\xf2\xf5)\xfa?\x02U\x99\xf1\xdb\x11\xdc\xbf\xda)\xc7r\xde\xe3\xe8\xbfo\x1d\xaa\xa7\xf2X\x01@I\xab\xbcW\xbb\xd8\xee\xbf2\xdc\xd5\x0b\x80\xe8\xcb\xbf\xc2{\xe7\xfc\xe3\xfb\xfd\xbfcw\x18\x80\xcd\x86\xe6?\xd5\x90S\x1e\xe0[\xf5?\xe0r\xc3\x8d\xa01\xb2\xbfg\xfeE\x1b\\\x04\xea?\xbc\xc1\t\x84J\xc2\xc3\xbf\xbf\x91o\xa1\xe8\xf6\xec\xbf\xee\xecJ+Z\x07\xbf\xbf\x9b\x92\xdb\xb6\xd3Z\xf4?J\x8cv\xb2\xd1\xc2\xf3\xbfF7\xd0\x08@\xe7\xde\xbfk\x13\x08\xf3\xf6\x8d\xb5?\xf7S\x9b\xacV\xcd\xb1\xbf\x17p\x8e\x9d\xde(\xeb?|\r\xc9\xd6vU\xf3\xbf\x04M\xbb\xcd@\x04\xf1\xbf\x16/\xa2I\r\x98\xd1\xbf\xc5\xd5k\xaf\xc4\x10\xe2?1um\xc3\xe3\xdb\xe8\xbf{#\x03F\xe2\xa7\xe8?\xf4\x83\xecM3$\xe9?\x8c\xe6F\xdfi\xbf\xeb\xbf?\x99G\xc4E\xa1\xc6\xbf\x0c\xb7\n\xeb\xfc\x1a\xaf\xbf\xd0(\x18\xd2\xabx\xfa\xbf\x92\xb9j`cd\xd6\xbfk|\xf3\xacR\x81\xfa\xbf`\xb3\x94\x8cAN\xe1?C\xc8q\t\xc3#\xc7\xbf\xc4\xde\xd3\x8b\xe6j\xde\xbf\xc4P\x1a\xb1\xe0\xa7\xfd\xbf\xe1V\xda\xfe\xd5A\xe7\xbfgN\x05\x8f\xa1\xaf\xf9??`\xa3\x82\x15I\xe0\xbf\x1e-l\xa0\x90\x13\xd3?\x04Q\xa5\xf1\xca\x8a\xe2?\xe6\xd0(k\x1c\xb8\xf9\xbf\x17\xd9\xf6\x0e\xeb\x02\x00@\x17\xa5\xab\x9c\x88\xf4\xd0\xbf\xfc\x9d_f\xc4\x8a\xf5?\xe9\xd6Z\xf0\x14&\xe4\xbf)\xe4&\x9a\x91]\x04\xc0\x97j\x07n\xca\xeb\xe8?~t\xcaX\'\x06\x00\xc0gO6\xc4\x9d\xe4\xeb\xbf\xd6\xd8\x9fP\xb7\xc7\xb0?0\x8a\x03JAG\xea\xbf\n\x03e\xb3\xbdn\xf5\xbf^h}(\xed\xa0\xe1\xbf\x89D\x87\x1aR\xfe\xdb?f\x83\x8e\x93\x886\xe1\xbf\xff\xd7^\x9e\t\x83\xe3?\x8f\xd9\xdc\xc8\xbe\x9c\xf1?\x94\xb24b~\xb5\xd9?\x91\xed\x80C\xd0\x99\xf4\xbf/Pb|\x93\xfa\xd2?O\x03\xd7\xb3>\x13\xe3\xbf\x11\xc6D\xbd:\x07\xe7?\xb0!LY\t\t\xfa?\xa3A%V\x04~\x06\xc0{\xf3\xaa\xdd|#\x04@\xc4\xce\xffm\xab\xe4\xe0\xbf\x86\x1d\xdf5:\xbc\xe4?.\xf7\xcc\x90\xa8\xaa\xcd\xbf\x87\x97\x96\xb1\x1b\xb5\xb6\xbf\xc38\xdc!y\'\xeb?\xacS\xdd\x93\x02\x89\xbf\xbf\x8d,\x85\xbe\x91\xe3\xcf\xbf9\x84\xd3\xca\x8fi\xd3?\xc9\xf4-\xcaX(\x00\xc0\x8f\xfdD\xf9\x9cM\x95?\x7f1nt\x91z\xe7?Y\xa6\xa3\xcb\xeb\xa0\xd6?\xfb[S]\x87\xc8\xeb\xbf0p\xf5\x1cPt\xd3\xbf\x922 \xf4\x17c\x97?\x01]U\xe5\xe9}\xe4\xbf\x15\xa3\x91\x8b\r\t\xe9\xbf\xed\xbb\xa5+\r\x9d\xef?\x02\xbdT\xbd\xd9m\xf2\xbf\x8cv\xf0Q\xe6-\xf4\xbf\r\x9f\xa5\xa6\x92R\xea?u[U\xf5\x80\xbf\xfd\xbf3\xca\xe1\xb9\xaa\xe2\xed?\xa5m}\xe1\xa5z\xe3?\xfe\xcb\x82\xe1\xb5@\xbf\xbf\x894\x08\x05\xcb\xb1\xd2?\x08\xebd\xca\x90u\x02@\x05u\x15|hW\xb4\xbf\xa8T\xef\xdd\xf0\x07\xcc\xbfx\x9d\x9f\x8fI\x8d\xf9?Zn\xa6\x17i[\xde?\xe7\x9d\xecN\xf8-\xd1?L&\x96\xb4\xe6\x1a\xea?\xcb\x10\xd97"\x95\x02@\xf0W&`\xe3\xa6\xc4\xbf\x11\x03m&\xde\x16\xfb?\xfc\xb1\xf3\x05\x08\x97\xef\xbf\x08\xda\xd7M\xc2\xfd\xed?N\xe9%O\xe8\xb9\xd3\xbfz\x08+\xbbk\xe9\xe0? \x0e\x1c\x06[,\xf2?\xee\xad\x12\xe4x{\x9f?\x83\xbe\x0bQ\xcf\x81\xe5?\xf1\x7fv&\x11P\x82?\xcaJ\xeex}s\xf4\xbf\x1e\xcc\xc7Q\xbe\x92\xa9\xbf\x97\x05\x7f\xfeX"\xc7?\xfa\xf57\xca\xc9W\xf2?\xf4\xf6|\xb5\xb3\xa3\xe0\xbf\x94\xdd\xa3T\xef\xf9\xf6?\xd9Ac\x170\xc9\xf5?\xc1p\x96\xb7V[\xda\xbf\x970\xdb]\xd4\xef\xe8\xbf\xa4\xc9\xc4:O|\xf3?\xbb\xf4k*\xde0\xc7?\x92\x97\xb0\xfb\x0f\xb7\xb5\xbf\xad\xdc\xaeJz\xbb\xa6?\x8b-\x9b8n%\xe1\xbf(K\xfd\xf4\x9c\xde\xd0?\\\xec5\xad\xc1\'\xca?#\xba\x0f\xd9\xebX\x00\xc0\x19$\x00\x1d\xe5Q\xe1\xbf,\xf2\t\n\xd9\x16\xec\xbf\x0b\xe8\xf4\xa9\x86/\xfa\xbf8\x0c%\x90\xc0\xd5\xc3\xbf\xb1>\xfc\xe4\x8br\xd6?\xd8Y\x974!\x90\xe7\xbfcL\x87M\x0f\x14\xf5?\xd3{\xe0@q\x8b\xe6\xbf"\x1f\xe0\x86\x9a_\xf8?\t\x01\xcf~\x15\xc7\xf8\xbfh\xf6or\xedm\xf1?\xfe\x9a\xaa\x19\xac\x12\xe4?#\x1a\x15\x89\xfc\xc9\xd7?\x8e\xdb\xc8\xd4.\xe1\xda?1\x90a\x8b\x0c\x88\xfc?_\x14U\xc5\x0ee\xd0\xbfII\xeeS-\x8b\xf2\xbf+}\xec\xca**\xca?\xfcUi\xdcn0\xb5\xbf\x810\x01@\xc3\x13\xfc\xbf\xbe\x9e\x84"\x91+\x00\xc0\x0b/\xf4|\xb8f\xe1?\x93\xac\xae`\xf7.\xe2\xbf0v\xc1\xda\xaf\xc4\xd3?\x0f9\x94\xc2\x02\xdb\xed?\xc1\x92\xf0\x01\x85a\xc2?\xe9?\'#y<\xef\xbf\x14\x00F\xc9L<\xef\xbf\xc5\t\xf4\x97K\xf7\xee\xbfo\x98{\x0e\xd8\xa3\xae\xbf\xb6u\xd3\x07\xfek\xf5\xbf\xddE"\x86\xb7\xcb\xd7\xbf?\xdb\xf7r\xcb\xd1\xed\xbf\x96p \xc2\x161\xf4\xbf\xb3aF\xb7\xc6\xa2\xf1\xbf\xeew%\xf6\xb6\xf4\xfb\xbf\xf3\xd1\xf6\x94<"\xa3?\xe2\xb5\x11IX\xae\xc4\xbf~\x81\xbb\xea\x8b\xdc\xfb?j\x95\xa8\xceS\xe1\xe4\xbf\xab1\xb2?\xe7\x99\xda?\xfc]\xee\x9cb\x19\xdf?\xadC\xf9\x8f\xc7\xd2\xed\xbf{\xc0H\t7k\x02\xc0)\x08\n\xc2\xae\x88\xf2\xbf\x94\x977:\xea\x0c\xf0\xbf14\xe1\xf1)t\xf3\xbf\xbbj,\xfb<\xf7\xf6\xbfz6i\xdc\x1a\xf0\xe8\xbf\x9f\x8c\xd2+\xd7\x9f\xe1\xbf%\xe6?z\x7f\r\xe6\xbf_\x83F*F6\xe6?\xc3\x82r&\xeei\xea?&\xfe\x03}\xecI\xf2?\xed\xf0\xc4SmK\xd4?#H\xe4\xfd\xb42\xd3\xbf\xed\xab\x16\xca\x10\xbb\xd6\xbf25\x98AZ\xe4\xe0\xbf8\n3\t{{\xf3\xbf/\xc6\x1dwQ\xec\xf8\xbf\x8d\xe3\xd5\xad\xc7w\xf3\xbf\xa4\x80\xadj\xf3X\xf6\xbfhB\x13\x98\xfb\x95\xfb\xbf\xd9\xdf-\xc3\xe2]\xeb?\xeeM\'\xa3\xee\x08\xf1?\xd3V\x8f\xc9,\xb0\xb9\xbfYL5\x05P6\xe4\xbf\xd5`\xddk\x08\x1a\xd3?\xb3<\x87\xb3(9\xaf?\xc5\x1c2=\x96\xde\xd6?\xaf\x95P\xd2F<\xe8\xbf\xe8\x90\xc2i\xff\xf6\xc8\xbf\x96\xc3\x11\xd0\xf0&\xfc\xbf;\xdb\x19"\xe74\xe8\xbf\xda\xa8\xf4,\xf1\xa6\xd4\xbf\x1eV\xf5\x8a\xb3\x16\xe2\xbf\xed\xf8\xaf\x04"\xe7\xcc?;\xef\xee\x10\t\x14\xd7?\xc9\xbc^$Yu\xe5\xbf\xdb8\xc4\x8bL`\xc3\xbf\xac\xd1*\x07\xbd\xc8\x00@b\xe2"\xe2\x9a\xb3\xe6?L\x8f\xadQ\x15\x00\xe5?\xe4z\xd8\x1e$L\t@<\x87\t\x94rZ\xcc?s\xaa9\x8f\xba\xf2\xdd\xbf\xf2\x9cL\xd1\xc7\xa8\xf8\xbfA\xc7\x87\x8f\xd0\xc8\xf0\xbf\xddO[H\xc4^\xaf\xbfl\x90\x9bE28\xf4\xbfs\xf5\xfcd\xa6>\x01\xc0\'G\xe6$\xfb\xc0\xd0\xbfE\xf0\x89\x01p\xa9\xee\xbfX?\xdf\x1d\xe0\x0e\xf8?8\xab\xfd.\x1e\x8b\xf8?\xbd\xf3u\xb9\xa7\xff\xe6\xbfg\x84{A\\{\xd4\xbf\x0b7^$\x19\xd6\xc6\xbf\xae\x8c\x8e\x9f\xbdX\xdc\xbf$\xe2\x1a\x0f9\x8f\xea\xbf\xe1\xe2\x9f\xd3\x93w\xea?\xed\xb0#\x9f@\xe7\xd7?v;\xb2\xeeZ\xda\xf0\xbf\x82\x96:!uS\xe6?\xe9s\xb4\x17|\xb7\xc8\xbf\xf2\xbd\xcd\x0ct~\xfb?\x18\x1e\x1b\xd4\x0c\xb9\xe8?\xc5L\x05\x9f\x93k1\xd1?\xd1\x989\x99\xb4H\x02@\x1d_\xf6\xb9\xf8\xe7\xe5\xbfC\x96\x14\xd8Y\xa9\xe1\xbf[\xba\xd4\xf0P\xf7\xfe?\x7f\xf5\xc5Y\xb9\xd3\xf3\xbf(\xc8\xf3D\xc45\xb4\xbf\x04\x19\xef\x9c\xf0\x8f\xd6\xbf\xe9\x84\xc0\x0fM\xf6\xe8?\x93bb\xda_O\xe9\xbf\x1a\xbbk\xd5w\x0b\xf5\xbfjM\xd8\x1b7\xd1\xe3\xbf\xb7s\x9a\xc9\xb0\xce\xc8?\xa5\x9dw\x8cT\x03\x93?\xee\xd9\x9b7\xf7\x16\xf1\xbf\xd2t\x04G\xdd#\xef?\xd8\x13\x1av\xa7\xdf\xef?\xcb\x9d\x9c\xe0\x11\xb2\xa1?\x94z\x7fF\x19\xd3\xfd?kf\x81x\xc4,\xf1?\xcc\xc9A\x93\x8c\x1d\x00@\xda*\x9b\xc1\xe0\xfa\xe2?\xa5-)\x8aI\xe7\xf5?\t\xa1x\xd2\x02<\xdd?;\x0b\r\xb3\x853\xe6\xbf\xdeGjst\x8b\xfb\xbfG\x86%\'\xed\xc6\xfb\xbft!\xd3\x0c\xb8\xd8\x02@\xccZh\xc5\xde\x00\xf7?\x90\xdf\xa3\x8c\xa7\xf4\xfc?\x18\x05\x99\xdf\xda\n\xc6?7\xaf\x9f\x91"l\xc3?\xe9p\xad\x1bD\xa5\xe3\xbf!8J\xc8\xb3\x98\xff?\xc6K\x9a\x1d\xbcc\xe0\xbf\xce\xdd\xa4\xde\x06s\xa8?\xba\xfe&\xe3\xc5\xf8\xdb\xbf\xf8\xaeu\xb9\x01<\xe8\xbf\x03\x9a\xe9\x02\xb4W\x00@Y\xb7j2\xf8R\xfe?Lf\xdb\x9b\x90\xd6\xc0\xbf2\xe9\xa4\xd7B\x03\x04\xc0\x1f\xf8\x84\xf4\xdb\x19\xd2\xbf\x17\x1b\x8b\t\xe9\xfd\xb4\xbfo\x87\xa0\x08H\x98\xe1?\x17T\xde\x17\x7f\xe0\xe1?\x98\xc1HH\xf7\x8b\xeb?\xdcX\x9c\xfe\xb9!\xf4?\x13\xea?\xbb\xac\xe4\x00@v\xf8-{H\x88\xec?EM|\x9d\n\xb2\xfa?v\xaaN\x8e\xad1\xee\xbfVJ`\xf9\xa2\x8d\xed\xbfqk\x89\xc8]W\xfa\xbf&\\\xc2u"\x90\xe7?\x14\xd1\r\xac\x8b}\xd3\xbfL\xda\x04a_\x08\xe7\xbf\xb8=\x0e6H\x8a\x00@#\xdb\xd9I\xa1\x8f\x02@X-\xd1bS\xef\xd8?\xa4QBK\xe4o\xf1?*q\x1c\xb2s\xaf\x07@-\x00\xc3s\xf0\xd4\xbe?\xc7UG\xa7\xef6\xc5\xbf\xd6\x96\xdf\x0f\r-\xa4?P\xb6sdu\xfe\xf4?\x9f\x1f\x07H`\x96\xe3\xbf\x88\x95EJ\x9f#\xeb?\xb1\\\xa5\xadX\x0e\xd5?\x0eo\xe2\x13\x07\xb8\xea?}\xe1\xa8\xa0\xd5\n\x01\xc0\x14L\xc0DYM\xd8\xbf\xf80\xd8\x82\xe7C\xd1?\xdfl\x99U\x1a\x8b\xfc\xbf\x8b6\xbf\x9a\xef\xae\xed\xbfL4r\xa8[\x9c\xeb?\x17\xccR\x9f\xa0\x8a\xd1\xbf\x93\xf5M\xf1\x1b\x9a\xe4\xbfp\xe6\xd0n\x97\xaa\xd2\xbf\xda\xcfY\xfe\xef\xd6\xf7\xbff\xdeE\xb8\xb2\xde\xec\xbf?\xcb.t}\x01\xf5\xbfzu\x0b\x1bCn\xc8?\xc6\xb7o,\x17\xcf\xc5?Z\x84\x0e7`\x99\xf0?h\n4"\x8a;\x08@\x82/5i\xfb`\xff?I\xfb\x87W\xc4A\t@\xef(\xb5\xd5\xa1\x8b\x02@\xd9\xff-\xc9b&\x00@d\x94\x91u\x90@\xf9\xbf\xd4\x97\x8c\x8e\xee\x1d\xd3?%\x18\x07\x9aw\x9b\xcb?\x85Y\xa2\xec\xc0\xbd\xd0\xbf%\xf4o\xbd\x921\xb0?\xba\xf7\x11\xa3b]\xfa?\xff\xb7\x13\x838\xad\xcc?\x98@B\x1d\\a\xe5?\xbf\xff.<`w\xfa?\xfd3\x84v\x87i\xe6?\x8e\xa9\x1e\tb\'\xf6\xbf\xd0V\x19Y[\x0b\xfa\xbf\x8aM\x17\xa2\xe8z\xe1\xbf\xc9\xdbTt\x9d*\xc4?`\x8dx\x10\xdb\xf6\xf2\xbf\x8dc\x9e$ W\xfb\xbf0b\xbdmW\x93\xe9?\xae\x15%\xde\xc3\xc3\xc8?\x98\xd6\xe7\xc4\xf8m\xf5\xbf\xdc\x85\xc5\x188\x86\xe6\xbf\xc9\xd3\xd4\xa2\xc2\x1e\xc3?\xc6\xb2\xfa\xfe\x00p\xee?C\xbf\xf7\x83Zh\xdb?%K\x9e\x92\x1do\xf2?\x8f\xdc\xe7\x03\xb7\xb9\x02@Od\x08\x90 Z\xd7\xbfwY\xc2\x8b\x066\xf8?\xa8\xac[Pi\xb5\xec?\xbcw\r\x9bq\xb2\x02\xc0s\xfe\xa7.*\x08\xe0\xbf\xbd\xa3\x1b\x84\x85c\xef\xbf\x13\xfdf\x7fn\x96\xe9\xbf\x16oV\xbf\xa24\xe7\xbf\xa6\'\x04\xea6-\xf0\xbfC\xac\xa6\x1b\xdc\xea\xc6?\x0b\xd7+\xcd9G\xf2?\x1dg\xa8k$\xb6\xf0?Upx\xb0\xd3\xab\x04@d\x06(F\x8a_\xe8?#\xa7\x0c`e\x8a\xfc\xbf\xa39}\xa7\x94\xa0\xe9\xbf\x82\xb2\x1f)\t\xe7\xf0\xbf\xcc:\x84\xeb\xce\xa1\xf7\xbf\x91=g\xd9\x98I\x05\xc0\xe6\xf0\x85\xa2\xed\xea\xf4\xbfW\x87\x88B\xf0\x0f\xca\xbf\xeb\x92\xf6\xeb\x15\x11\xe9\xbf\xd7\x1b)\xc4ed\xb5?\xb8\xcb\xa3Ho\xf1\xf3?X>\x16T\xa0e\x06@5?\xe8\xb2s\x9a\x00@\x87\xf99\xe2\x03\xe7\xff?\x9d\xb8\xeb\x17\x19\x86\xe6?\xad\xf2D1\xf24\x05\xc0\x8a\x87=\xf2M\x86\xe1\xbfS\xa2\xed\xc4\x1f\xe6\xf0\xbf\x99\xdc\xf7\x10\xd5\xe0\x01\xc0\xfa\xf0(\xd8\xdc\xbd\xdf\xbfq(Kb0\x13\xce\xbfbU\x99 \xcah\xd8?@\xf5\xce\x9f\xb8\xb5\xdd?*\x12#\xec\xff{\xe0?\x83\xfe9D\x8a\x00\xd5?t<\x96\xb9\xc0\x83\xe6\xbf\x0f\xb6\x9b\x11\xb7\xc3\xf6?\x99\xcb\x02\x84y[\xfa?\x86]\x8a9\x05-\t@\xf3\xa7\xa1p\xc0\xf9\xdc?\'\x9eD\xa0\x07\xe0\xe3?^\xdfA\xd4\xa2\x9a\x07\xc0\xbd\xe7\xa5M3k\xf6\xbf\xd8\x17A\xc1\x13u\xe1\xbft\x8d\x04\x8d\xcc\x1b\xdc?\xc1y\xd4Z\x14\x8b\xe6\xbf{\xd5}\xe0R\xc1\xf9\xbf\xcb\x8b}\xd9a\xde\xef?Q\x04\xbc\xf0\xb1\x9e\xbc?\xec\xe2*6\xbf\xae\xf4?6\x81\t\xc0\x86\x12\xf9\xbfqU\xbd\x0c}\r\xf1?G\xdb\x15!\xc3\xc2\xfd\xbf\nEd\xad\xaf=\xfc?I\xf7\x82vT[\xd6?\xf6\x84\xb4J~}\xe0?OT\xa1v[\xe3\x03\xc09\xf6\x9e\xc5\x10\xc7\x05\xc0\xe9\x0cJ\xe8\x9dxQ\xbf\xaa\xbc\x1f\xb5\xb4\xc8\xf1\xbf=\xf5\x1dC+;\xe1\xbf\x83\xb8\xd2;[\r\xc3?k-c\x1f\xe1z\xe1\xbf\x05\x04\xaf\x90\x16\xb0\xe8\xbf\xae5\xf5)b\xf8\xf5?\x15\x9e\xd1\xb211\xea?\xecv\xb6cS\xb1\xf1?\xc6\xdc\x15U\xc8\xf0\xc0\xbf\xb9Bkr)\x9d\xe7\xbf\xd5j\xf1\x02\xc1>\xe3\xbf\xa1?^\xddrnS?\x9f\xa9P\xa9\r^\xf0\xbf\x84MH\x9aL"\xd8\xbf\x9b(\xbf\xcb\t5\xf5\xbf.6\xa9\x02.\x93\xe7?\xfe\xf1\x83j\x10\xa6\xe7?\xcaLm\x91i\xec\xc2\xbfe\x0b\x9b\x84`\x7f\x02@\x03\xd4\x9c\x98\xff\x99\xe9\xbf\xe1r\x9f\xa7\xdf\xaa\xe4?\xd3^wj\x8d\xb9\xfc\xbft\x92^o0\x08\xc2\xbf\xba\xc2\xa0\x89B\xa0\xf4\xbf\xd2\xd9\xe1\xcceA\xfd\xbf"\xe0\xb9F\x18\x1c\xe6?&b\xe8`D:\xaf?_o\xf0x\xc6?\xf1?\x90\x87\xe4\xf5\xc7,\xa0?/\xa4\x997P\xd4\xfc?\x17\r\xb5!\x9e\x8c\xf4?8\xfd\x80$\x0en\xe4?H\x0cbd\xe1\xaa\xeb\xbf@\xcc\x0bJB\x1c\xc5?\xabiF\xe5\x9f\x8f\xe0?%\xabR\x93Ph\xfd\xbf\x06O\xca\xfc\xfcN\xcf\xbf\xd97\xf3\xa31>\xf3\xbfu\x13^\xde\x10n\xe0?\xa9o\xe4\x9a\xd0\x86\xee\xbf\xb61p\xe7\x07\xce\xc8\xbf\xc3_?4\x9b\xe8?\xd0\xd4)\xf0\xac\xfe\xeb?a\x8f\xab\xfeK0\xbb?\xd0\xc3a\x01\xb8R\xda\xbf\x12\x07\xf0\x07\x99\xa3\xf4?\x88=\xeab\x1fo\xcc\xbf\xd0\x1e\xa7\xac\'\xcb\xf5\xbf\x91\xeec\xc8}\xe1\xf4\xbf\xcei\xca\x93\x83\x93\xb6\xbf\xe7^\xc7\x83\t\xfd\xe5\xbf\xda\xe4V\x18\xdf\x83\xf5\xbf?\x91\x98\xc5\xa8\xc4\xfb\xbf.ZF<\x92N\xf5\xbfS\xd6\x9c\xb3\xc9>\xf6\xbf>\xa9\x04~\xda\xe1\xef\xbfK\xf7\x04\xe1\xc2\xd1\xe3\xbf\x04U+\xa7\x95\x8a\xe7\xbf\xfemb\x86\x80\x99\xff\xbf\xe9j\xb4\x18\x9d\xbf\x92\xbf\x1a\xb5\xc6\x13\xa9\t\xd8?sE\x11\xc1\xe2<\xd1\xbf<\xc1\x803o\x06\x83?`\x16\x9b \x19\xa8\xb6?"\xbc\xbc\x9c\x98\x0b\xb3\xbf\xa6\x9al\x8d-\xe5\xe8\xbfNY\x87{p!\xf7?&N\xef\xee\x9c\xb6\xef\xbf\x9awX.\x9e=\xf8?\xda6\x94\xd6\x1f\x18\xdf?,\xe0\xf5\x98\xe4\x86\xfb?\x01\x1d\x10\x98\x813\xef?\x9b5\xb2\x0e!/\xfe?u\x1f\x0e\x96\x1f\xeb\x06@\x8b\xf7\xf4\x0e\x1f\xbc\xc6\xbfx{\xbaf\x01\x80\xa6\xbf9\xa2\xbe\xc8P*\xe5?\xe0C\x1a\x1b\xcb\xd0\xe7?\xfd\xc5\x0e\xb7\xb6A\x01\xc0\xf9\x14\x85^\x1cu\xf8\xbfp$\x08S$(\xfc?>a!>u\xcc\xd6?\t\xeeiHz\xb0\xf3?\xcb\xc4\xc0\x84\x98`\xe1\xbf\x7f\r\x1b\xa4\x05\x18\xd1\xbfaqX\x9c\xd8\xfe\xe6\xbf\x02\xa64\xe5\xf3\xcb\xe8?\xbb\xd6\xf0\xc3\xdbJ\xc9\xbf\x15@\xceO\x96\xdd\xf0\xbf=\xf2\xb6\x18\xc7\x81\xdb?\xb9\xa1m\xab\x08\x1b\xf8\xbfi\xf2\r\xca\xaae\xc9?W\xe4\x99\x9a\xb8\x88\xd4\xbf$\x0f\xff\xd6\xae3\xed\xbf\xc9E\'\x89Y\x85\xe9?\x11\x1d\xb6G+R\xb9?\xe6\xc5\xa9J\x84\x96\xe6?P\xf4\x98v\x17i\xd9?*2\xd4{\x02\x18\xc6\xbf\xab\xa6\xd3\xc7\xa3\xff\xf3?\x05\xcd\x81?\x0c~\xf5\xbfeoR\xd0\xb2 \xe8?\xffi\xb3\x98\x04C\xf1?e\x1f^3,\xd4\xf3\xbf\x8d\xc5\x92b\x01\xc0)\x14bNdk\xdc\xbf)\xe7\xfdD\xe8k\xe7?\xe5l)\xcd\xa0\x17\xe6\xbf3\x05;\x8e\xda\x8e\xf4?b\xd1\xf9\x929#\xe1?\x84W\xadmc\xeb\xe8?\xc2\xa0v\x7fkp\xf9?n\xd3\x9b/\xcc\x80\xfb\xbf\xf4\x1a\t\x0c\x81\xfb\xf4\xbfH\xc6\x0c2\xc8\x19\xe7\xbf\xa4#\xbf\x8c\x83\x99\xff\xbf\xa68]\xbc;>\xda?\n\xe0V\xad\xc7\x8d\xc6?6\x8e\x12\xc0M\x1b\xfb\xbf\xfc\xe8\xcaD\xfb\xbd\xda\xbf;\xa2\x03SD\xef\xc8\xbf\xf6\xf0\xfe\xd0\x83*\x01@\xacn\xe9iy=\xe0?\x13\x06?The\xd0?\xa5\x9bTErx\xf0?_\r\xb5\xb7e\x15\xcc\xbf\x84\x84\x13w\xf9O\xfa?\n\xd7\xc7bL(\xf3\xbfL\xca\xb3{\xaaw\xe8\xbf\x0c7\x167\xc6\xf0\xd5\xbf!jh\xb0\xf93\xfd?\x0c\x92\xb4\x85*\xd6\xda\xbf\x13\xc4>W\xa2\xd6\xd1\xbf\xb2\xacT\x86\xc8\x89\xf3?\x04\xbf\x96\xf9\x94V\xf9\xbf\xdf\xab\x00\xa8\x97\xb8\xb9\xbf\x85[\x87\x90\xe9\x0f\xe6?rn\x80\xd9c\xd6\xf7\xbf\xc9\x0c\xe6\x83\xb3\xe6\xe0?I\x13C\xc2$>\xf1?4b\xa7:\xc1/\xd2\xbf\x15z\xad\xac!F\xf4?\x8a_\xd4{\xd0\xe0\xcd?\xeeF\xc2\xa9#\xa1\xee\xbf\xb7G\xa7\xb9o`\xb2\xbf5\xbdu\xa1\xe8\xe5\xe6?.\xfa\xb9\xd5\x96\x99\x08@\x86\xf6\x0c\xae\xb6;\xf0?\xc1\xe7~p\xe3\x9c\x01\xc0\x01\xe2\xa2\x8e\x9b\xe5\xf5?\x1c\'\xa7\xd5\xa6\xf3\x83\xbf\x84\x04.\xef\x87D\xe1?\xe5>\xa9\xdfk\xae\xe9?H\xff*\xf0\xdca\xb8\xbf\x90Q\x96Xu\xfa\xf6?\xc8L\xe6\xea\xf4s\xdf?k=d`\x1e\x1c\xde?\xc1\x98\xe4\xdc\x1aa\xcd?\xf9\xee\xa8\x96y\x07\x91\xbf\xbb\x84z\xee\t$\x02@\x95\x8a\x88\xaa\xbb"\x02\xc0\xe2\xca\xb9\xfc\xcc\xf9\xf6\xbf\xba\xdb\x9c*\x84\xc5\xec?q5\x95\xc2/?\x03@\x16t\xe5\x93\xf6\xbd\xe2\xbf\xdf}\xe0\xc4`7\xe7\xbfU\x16{\xf6\xb3#\xf4\xbf\x7f\xfb\xa3\x99\x1b2\xf1?\xb2_P7o?\xe7\xbf\x0fK\xd8\xcd\xa5\xd4\xe7?\xeb\x10Z*\xe2\xe0\xec\xbf\xda\xa2#\r\x00E\xf9?q\xea\xad\x84!j\xd9\xbf\xe1.l\x15\xa7\x8e\xd5?\xbc\x15u~\xc2\x19\xfa?\xact\xc9\x95\xeb\x92\xe7?\xf3lS-+\x95\xea?OsU\x99\xa0\xd1\xe7\xbfJ\xb6\xee\x85!z\xee\xbf\tW\xde\xc2\x8c9\xf8\xbf\x90\x01\xe7\xfd\xc8(\xf0\xbfY\x8d\x88\xba\xe2\xaf\xee\xbf\x82tQ\xf6\\(\xf3\xbf\xc2\xbf\xe4\xc5l3\xf1?\xf8 \xe7,n>\xfc\xbf\x86\xd7f\x95\x94X\xd5\xbfx\xf7\xce"\xf5+\xe8?\xf2\xc3\xa4\'\x1d\x1e\xcc?\xc0\x1e\xb7s\x0cE\xe0\xbf\x9c)\x92\xb7\x9ef\xcf\xbf\x91WQ\x0e1j\xbf?\xaalN\x90\n\x85\xd7\xbfz2\xf7\xc4B\x87\xf0?m9\x95w\x12\x90\xad?\x9bn\xdf@\xdd\x06\xa1?V\xff\xb7\xd1\t\x00\xd9\xbfE\xf7\x9f\x15qH\xe0?y\xe1\xfb\x02\x08\xd9\xe0\xbf\xb4I\xa4}T\xd1\x8e?\xb6\x96\xf0n\xd8\xf2\xfc\xbf\x11r\x92\x87\x00\xd3\xea?\xef\xa4.,\xf5\xb1\xb2?|\xda%\xd6\xb2m\x00\xc0\x8a\x848\xadCI\xd9\xbf$\xb1y\x82\xdd\xb4\xfa?\xf9HL\xc9\xea\xf3\xee?\x81o\xb8v\x0b\x16\xcb\xbfp\xc5\xcfi\xa6q\xda\xbf\x97\xd0\xb3$\xcb\x8c\xc6?\x16\x11\xfe\xab\xeb\x0b\xe5\xbf\xbc\xa6gG\xc0\x87\xd6?|\x99\xb7B\x1c\xc7\xf6\xbfD\xbf\xf9m:>\xeb\xbf\x9f\x98\xf9\xe0R\x19\xee?\xb5i\xb6L>\x06\xc6\xbf\x0b\x1cT{>/\xea\xbf\xb2[\xa5\x12&I\xfa\xbf\xe6\x1c.\x8ex\xc3\xc9?\xcbn\xcd\xccj\x0f\xe4?\xd1\xb9d$W`\xce\xbf\xfa\x1b\xac}hA\xf4\xbf6\'\xd6\x11\x99\xdf\xe2\xbf\xec\x896^M1\x96?\xde\x8b9\x11S\x17\xc0\xbf\xfc\x17\xce\x0eC\x87\xb9\xbfq\x1f"VZK\xef\xbfut>\x97\x14$\xed?\x16\x7f4\x8f\xf2\xe6\xf1?\xfbX\x0b\x0e\nW\xc7\xbf{,\x0e\xef]\x9a\x02@\xaa\xaa\x83ZwH\xf0\xbf\xd7\xd1\xf6T{\xbf\xda\xbf\xe8g\xc4,z\x94\xe3?\xaa?.\xe3F{\xc9\x11\xe0\xbf\x86wH\xbeT\x10\xf5\xbf[\xb2\x8dEd,\x9d\xbf\x8fO\x93\xa3\xf4\xc6\xf6?\xf9\xfa\xe1Glt\xad?\xcb\x97^\xab\xec@\xd6?\xc9\x8c4W6\xb2\xde\xbfs\xcc\xa7<\xaa\xd8\xe3?\xb3\xd6!\x8d\x04\x0b\xf3\xbf\xfe\xa2`\x01\x9fd\xe2?\x9c\xd0\x8b2\xf5l\xf0\xbf>\xc7x\xaeA+\xe8?,\x8bQT\xc6\xed\xf4?\x84a\xcckK[\xec\xbf*f\xb1\xde\x18\xf4\xba?u\x12\rw\x8f\x1e\xeb?o\xa2XY\xc1\x06\x06@Awj \x9f\xf5\xd6\xbf\xf2\xa6)\x95\xc5|\xcc?\x9a\xee{\x06\x1b\xa7\xed?\xc9\xa1\xc5\xff\xcf\xaf\xe3\xbf*u\x14m.4\xca\xbf3\xab@\xf5J&\xf8\xbfO\xf9\xea\xff\\\x95\xe6\xbf\xc7\xe8\xf5&W0\xe0?\xcc\xf5\xfbH^\xcf\xa8\xbf\xf0\x9e\xc7OK\xca\xf7\xbfWl\xae\xae#{\xe2\xbf+f\x96\xa9\x950\xe7\xbfG`\xfe\xdf\x16\x0b\xe0\xbf\xce\xae,.\x98\x01\x02\xc0\xb2TDDKe\xcf\xbf\xe0@\x96\xaft\x08\xbc?\x99\x85\x14\xd1\xe1\xfa\xf0?\xd5\xa3=GQ\x00\xf9\xbfR\xa1RD\xce\xb4\xf6?|\\\xad\xea(\x86\xe4?\xde\xac\x81dnA\x02@\xc4n[\xd8\xed=\xe2\xbf\xe7\x1dLh\x92\x1e\xfb?\xa8\x9e\xb9Mo9\xf2\xbf\x11\xb0q\xa6z\x1f\xe2?\xbfcHY\x83\x90\xe3?\xa7i\x84.U\xf1\xef?\xe6\x00\xc3\xcau7\xc7\xbf\xd0\xc7%\xa2\xe7z\xe1?\x89\x14A\xe4\xf9h\xe3\xbf\xadF\x93H\x94\xb1\xea\xbf\xe8\xda\x8bo\x87\x96\xf4?\xb5Q\x01jj*\xd7?j\x86\xfb\xdc%G\xef\xbf\x0e\xe22\x8c\x83s\xe7\xbf\x01\x11\xed\xc1\xee{\xf8?DF\x11\xaa\xc0\xd5\xf4\xbf!\xbd3\xc43\xbe\xe0?H\xec\x0cc\xf2T\xf8\xbf\x9c\xcc\x0c\xcf\x02\xbd\xcd\xbf\xc5\xe8\xcc\x11\xeat\xfc\xbf\xaf\xb6\xb8\x15~K\xa2\xbf2n\xcf\'\xa3\x7f\xfd\xbf\xc5\x1a\xe1\x92a\x01\xec\xbf|\'\\U\x9ad\xda\xbf\xafeF*o\xb2\x02\xc0X\xf8\\\xcfQ)\xfb\xbf\xa0H\xba\xcc\xad\xe8\xc8?K5\x9dC\xccF\xe0?g\t5\x90>3\xec\xbf\xe4\xc2X8\xa9\xfc\xfd?.*zB>\x07\xf6\xbfD\xb6\xf9\x91\xd0\x1f\xe7?\x14\xaed\xbfd`\xe7?\x1a\xbbg\x1e\x1cJ\xdc\xbfL\x19j\x1e\x7fj\xeb?\x88\xed\x1d\xd5\xf3\x85\xe7?`\n\xee5u\x19\x9d\xbf\x8an3"\x8d\x12\xf5\xbfCF\xc8\xf6\xbc\xa8\xd3\xbf\xad\x11\xa7\xa0A\xbc\xf0?\x18\x1at\x11\xcb$\xe8\xbf]\xac\xca\x14\xdfu\xe9?\xa9\x07\x18s\xc8\xb4\xf4\xbf=?=\x03k{\xd4\xbfM\xca\xc1\r\n|\x08@\x12=r.\xcfl\xf1\xbf\xb2\x89d\xe5h\xc9\xeb?\x04\xab\x06\x99)\xa9\xfd\xbf\x12/\xee\x1dcP\xe9\xbfM\xda\xfa#"\xdb\xda?do\xaaN\xfbp\xcf\xbf6\xdf\xaa\x1b\xe2\xa4\xea?\xc1\x97\x06z\xedz\x03\xc0\xab\xaf\x86\xcd%\xd9\xf0\xbfc\x1ad\xbb\xb5\x8e\xf0\xbfT\xe1\xfb\xf0\xed?\xff\xb6\x7f\xb9\xb3\xaf\xdd\xbf!\xeb6\xfd\xa5\xee\xef?\xa1\xa2T.\'\xe0\xf2?l\xf0\xe5Y\xe68\xec?\xbb\xa4\x13>\xd5\xcb\x02\xc0\xf3\xc9\xedi\xe5+\xf4?\x7f7+\xb5\x81:\xe4?\xeaE~x*2\xc2?cIx\xce\x15\xdf\x85\xbf\xa5\x9e\'\x1c\x12M\x05@j\xfb\xbf\x92\xdf\xb6\xe8?\x9aJO+\xe9\xdc\xd4\xbfO"\xd4\x10\xee\x8a\xd2\xbf\x99\xcd\x0b]\x8a\xfd\xf6?\xd9\xb8\x84gF\\\xd2\xbf\xf0\xa9w\xc2RP\x03@8\xb2\xa0\x145\xee\xf1?/C\xf8Bu\x9c\xeb?\xb9\x16rg\xe4G\xe1?\x93\'\xec\xf7\xe6\x9b\xf6?\xcb\xd5\xca\x17\x93\xaf\xf1?\xa4-\x94\xaf\xb4\xca\xdb?\xbf\xf9=\xf6\xa2"\xe1?UF:\xb2[\x90\xa8?/nE\xdb\xe7\xe0\xea?\xa6\xe0\x007\xe7\xbb\xf0\xbf\xeeRA\'\xdd2\xf2\xbf\xd36\x16\xf0\xbf\xd4\xf1?\x06{\x03?\x1cz\xfb?\x16\xfd\x10P\x1e]\xf9?\x13&j\x9c\x9b\xb4\xe9\xbf\x94\xb2\x06\xe1\x08\xe0\xc8\xbf\x96\x15i:\x13`\xf9?\xdf\x12\x84\xbe\xa1b\xe1\xbf\xd8\xa1!I%\x98\xef?\xf0\xe5\xc7m\xaa\x9b\x88\xbfg\xcdk\xa3\xd5+\xf7?\xf5\xffx\xd3\xbd\xa9\xfd?H\x0f\xf1\'\x02\xf1\xe2\xbf\xb2\xe5\xb2\xad{\x93\xec?\x08\x9f\x99r$A\xf4\xbfm\x8e\x8f\xd6wo\xe3?\xf6\x1b\xc1\x8e\xa1\xd9\xd4\xbfR\xa6<5L\\\xd6\xbf\x8d\xcb\xcde\xc4Y\xfd?\x10QE)\xdf\xb9\xe8\xbf\xce\x12\x12\xcb\xeaf\xf1?\xf7\xb9t\xb0\x17+\t@\xc9\x04\xd2\xbf\x11\xc7\xef?\rr\x86@\xa3\xbc\xf1\xbfj\xe9o\xc8e5\xf2?\x18$\x1e\x11\x99,\xee\xbfr\n\x84GQ%\xf5?*\x147Y\xf8\xb0\xd2\xbfW\x9es,\x18c\xf7?m@\xd4\x17\x9ci\xd3\xbfJ\x04\xa7\x04\xbe\xfa\xf4?\xd8Ac\xc4\xe3n\xbd\xbf{\x84\x14a\xd9\xea\xce\xbf\x1b\x82\xad\xffD\xf9\xec?*\xef\xa1\x9ch\xc4\xd0?\xf9\xf9\x00\x85[\x8f\xb8?\x1b\xa9_\xbe\x9b\x05\xf0\xbf\x8b\xcf\x14\xcc^\xf3\xd0\xbf%5M\xcd\xb2q\xfd?@\x15\xd8\x83=\xfa\xef?\xf9M\x8e~\x0b\xbb\xfe?B]\xd7\xe0\xcfh\xe2?o\xc3A\xb4\x81F\xf8?a\x80\xea~\xbb/\xf0?,bzB\x8b\xb8\x9a\xbf\xb4\x83\xf9\x1f\xfb\xd3\x07@\r\x81+nX\xf3\x04@g\x10\x0f\x16\xfd\xf7\xea?B\x8a\xc7\xbb\x94\xea\xfb?\xd0\x0b\xff$\xc3\x08\xfd?\x02\x92\x8c\x16v\xd6\xfb?\xd4\xe5\xf0\xd5\xe9v\xd5?\xc2\xbd\x99\x97(h\x9b?}\xb2\ty\xaa%\xba\xbf\x97\xfb?\xaa\xbc\xee\xf5?\xe2\x15\x8e\x8c\xe3\xd6\xec?\xc4\x03\x99|\xef[\xd0\xbf&\xeeK\x86\'\xa0\xf1?\x12\xa8\xb8ZAP\xf5\xbf\x05\x0e\xa8\x9e\x8a\xa9\xf8\xbf\x972\x1ck\x8b\xab\xff?\x19V\xe5\x91\xc1k\xe4\xbf$J\xefi0\x1d\x96?^;I\x9a\xaa\xbb\xd4\xbf\xef\xbaL\xa96=\xdc\xbf\xd3.\xec\xe4\x1e\x0e\xd0?\xb2\x8b\x81\r\xea\x1a\xe3?V\xf0\xb1@k9\xf5?M\xa4\xac\x9a:\xc3\xd5\xbf\x8dS=\r-t\xcd?\xd3\xd1$\x80>\xf5\xce\xbf]\xba\xb93$9\xe9\xbf\xbb\x8d\x89j\xa3\xd7\xf7?\xe4\xc4^\xf1"\x08\xe0\xbf\xf0\xcf\xba\xa1\xee\xc6\xea?(M\xfb\x0ck\xe3\xc6?\xc8\xb6\xc2\xcb\xd2\x90\xe7?M\xef\x1b\xfdj<\xeb\xbf\x97\xb8\xf4tX\xd0\xfa\xbfb\x90s\x1aG\x03\xfd\xbf\xcb!\x05\x0cE\xfe\xf6\xbf\x96\x04\xb9\x9b\xe0\xb9\xd2\xbf\x8b\\\x93O\x03\r\xe2\xbf[\xd4\x11\xd0\xbf4\xf9\xbf=df\xe1\xc6s\x01\xc0\xfc\xac\xd0\xfev\xee\xe7\xbf\xe7/\x8bK\xcbO\xfb?\xd3qqS\x1d\xb3\xd8\xbfo%\x1a}\x11\n\xf6\xbf\n:\t\xbfc2\x93\xbf\xae\' \x13\x07\xd1\xb1?\x03s1\xf4\xdfv\xf8\xbf\xb3F\xab(Hm\xbc?\xd3\xd8\x93\xb4\x8e"\xfb?e\x01\x84%\xc2\xbb\xed\xbfO0\x85o"\xb8\xf3?\xc9Uu-\xeb\xe6\xd5?\xcae\xad\x82eP\xce\xbf\xd5\xf4\xefn\xc0\xd0\xfe?y\x94\x9d\x9bf\xc8\xc8\xbf\xfa\x83\x1f\x19G$\xfb\xbf\xce\xf2=\xec\xb9\xc7\xd8?\x80Gs\xe5\xc4\x17\xeb\xbf\xdf\xa5\xa6\xba\xe8\x02\xca?O\x88\xa0\xb3aR\xfd\xbf\x9a\x13\xf9!\x9f\xb0\x0f\xc0,\xc5\xa7\x80\xff\x8a\x04\xc0\xee\x04\xb0AS\x83\x02\xc0$\xd6\xe6\x10\x02\x13\xf9\xbf\x9aD\x0e*kV\xf9\xbf\x07\x17-\x1a}H\xca?\x8c\x82\x96J\x05\xe0\xd0\xbf5\xa5\r\xa0D`\xec\xbf\xd3\xd4\x9e]C\x96\xf4\xbf,\xf7ZMn\xf0\xf2?\xfc\xf3PJ\x97r\xe4?\xf4\xc3\xa2\xa4\x88\xe0\xf5?\x93>+\x8b\xdd\xd7\xd3\xbf/I\xb7q\xd0\xd9\xe8?\xf3DE\xa6\xe6.\xd7\xbf@\xd8\x88a\x04\xe0\xd2?\x17\x8b\x06\xadB\xf0\xf9\xbf\xd6\xaa\xde\r j\xbd?\xa7\xfd\x8a\xba\xe4T\xf0\xbf\x125\xc9|\x18\xc2\xe9\xbf\x06C\x1a\xdc\x9a)\xe0?\x05\xaf\xa2f\xe1\xa4\xf1\xbf\xf39;\xde\xaa/\xd2\xbfk)N;w\x82\xe6?A\x1d6R\xb5\xbe\xff\xbf\xe50|\x97\xbe\x0b\xc4\xbf\xdd\x9a[\x93\x1dz\xf5\xbf\xd3\xe6\x13\x92\xcd{\xff\xbf\xc5A\x8b\xe1\xf9\x1d\x0c\xc0\xa03\xafy\xa0\x86\xe0?\x1f\x04\xf5\xba)\x07\x00\xc0\x9d\x94\xb1\r\xea\x1c\xe1\xbfO\x04\xb1\n\xb1@\x06\xc0K#\x06\xac\x18]\xeb\xbfT\xe1?a/\x88\xe4+5\xce?}\x07<\xd1\x92\n\xed?\x0f\x85l\xb11j\xd0?\xef\xe8\xc5\xf1\xdd\x92\xe4\xbfa\x93\x1d\x1b\xab/\xf1?\xf2\xc7\xf5m\x81y\xd2?\xbf\xfcp\xa8\x06W\xde\xbf\x80\xd6whR\x06\xc5?F}\xacl\xe0;\xe0\xbf{\x17\x9a#\xe1R\xd0?\x80\x81\xc79\xa8\xc1\xf2\xbfK1\xba\xa0`\xb1\xdd\xbf\x98O=\xc1\xe1\xdd\xd0\xbf"\xda\x86\x96\xdd\x91\x00@x\xcf\x1b\x98\xe9+\xf8\xbf\xa4\x9c\xbb\x89\xa9\xdc\xd6\xbf\xd6y`\xb3\x8b\xad\xfa\xbf|O\x05\x9b7\xdd\t\xc0\x87M\xec\xb8\x0f\xb8\xf7\xbfZ_c\xb1\xban\x01\xc0m\xd8\xe5\r\xc7!\xef?U\xba\x81\xe5uT\x03@\x81\xa7\xfb\xb7[\x92\xf2?\xa5"4\x84\xa9#\xf3?h\x17c\x92\xc9H\xf2?c\xadr\xac\x93\x1e\xd1?\xf6ZU\xfat\x7f\xd9\xbf\x90\x89#\xf9^\xaf\xe3?\x0c\x1ckg\xde\x8f\xeb\xbf\xce.\x9a5~5\xf0?}\x0f\xdf\x11\xa3G\xd2?\xf4=\xb6a\x8bs\xbc\xbf\xba\x16\xc1\x8e1L\xc8?\xbeAi\x88`\xee\xba?a]\x84z\xa1\xb6\xa4?\x99\x12\x02<@N\xf3\xbf\xd6\xce\x10\x7f\xa2\xfa\xdb\xbf\xb2AO\xa6\xf3\xf1\xfa?\x87\x17v\x8e\x8b\xab\xed\xbf\xca\x8d\xa6c\x10\xce\xb4\xbf\xbb\xfe\xf6\x95#M\xfa?2\x0cT\xcc\xfbX\x06@.\xe8\'`,^\xeb?Zh\xd4\x14\x9e\xfb\xf9\xbfN\xecGx%\xd0\xf1\xbf\xaa4\xe8^\xb8\xae\xed\xbf\x16\xf2\xd4\xcb\xfe\xb0\xd9\xbfts\xa2\xa6\x11y\xdf?/^e\x99\xe84\xda?Ir\xc0"\xe6\xc4\xd5?\x95\x04\xd9R;*\xb9\xbf\x86gK\xf9\x135\xd4\xbf9\xbf\xd2\xba\xec\xd0\x03@6\xcf\xdcp\xce\xc0\xe9?\x01\xf3\xdc\x8d\xe2`\xe7\xbf\xda\xac\xd2\xd3z2\xd7\xbf\x94A\x0c*\xd3\xe6\xec?\x8crKR"\xbc\xea?\xb3\xe2\x8776\x8b\xf2?\xb1\xa3Y\xf6v\xbf\xe1\xbfO\xba\xa8,`\xe7\xd3?\r\x8d\xa9\xc1,\xb5\xbe?W\xa3\x1e\xc3\xa8\xdd\xf9\xbf\\\x1c\xc7\x01\x0b;\xe6\xbf\xe3K<\xc3\xa8\x8e\xd3\xbf"\xa3\xc3(\xb3*\x05\xc0H\x03\x86\xc3q\xd4\xcc?\x99\xa1Dk\r\x14\xea?\xf1\xb0\xa9\x0bQ\x02\xf1?k\xce\x81\xf2\x00\x8f\xf8?>5H`\xf6\x01\xf4? \xefk\xe1bo\xfd?\xa9RO\xab\xbe\xc3\x00@[\xad\x8b\xec\x1b\x7f\xd7?\xc0V\xf1s\xb46\xd6\xbf)S`\xf2\xb4&\xf0?\xac\xe4\x18\xbe\xd1\xb8\xcb?\r\x18OyF\xe4\xd9?\x14\xfa\x10\'\x069\xf4?zKEw\x1a\xdb\xc5?\xb3\x10\x88\xeb?\xd7\xe3\xbf\xf9\x91Bh\xdb]\xf2?\x8e\xe6\x0ca\xaa\xbe\xf8\xbf|\x96X\x1d\xc7\xca\xd4?\xa6]\xcf\xa1\xb4\xce\xea\xbf9\xe6\x15\xb9\xff\xea\xd7\xbf\xda\xb7y\xf0\xdaX\xa6\xbf\xe1D\x1c\xda\xf5\xaf\xe6\xbf\x9a\\\xdd\xd3~\x8f\xbf\xbf\x88\x80\x9e\x88@\xe3\xe5?M\xe4g>v\xbe\xd1?*\xfe\x1a\xd3\xa1/\xf2\xbf\xe5\xd4\xd6\xfd\xf5\x18\xe2?s&x\x08\x9d5\xf7\xbf\x81^\x01\xa0Yp\xe6?\x0e\x10\xa3\x15\'\xf6\xef\xbfg+@\xaf.~\xcb?Z\xdeP\xfa\xe5\xa2\xbe?\x94\xb7\x0c\xc2\xdf)\x00@!Uy\xb6\xdf\xd5\xa4?\x99`\x9cyx\x07\xe0?\x08J.\xc1+\xf8\xbf?dD\x18\xef\xcd*\xdc\xbfks\'\xd8`,\xc1\xbf\x7fMX\nZ\xc6\xff\xbf\x99:lQ\xd2\x86\xed?>B=\xe2\x838\xe6?j\xb1\xb5\xa7R\x96\xd4?\xe8\xe1\xbd\x91P\xe5\xe2\xbf_\xefrd\x9b.\xf0\xbf\xbb_\xe1}\r\x07\xe6\xbf\xc6\xc1ZU\xbb\x18\xea\xbf\x05\x8b\x0e\xd5\xf4S\xea\xbf\xebh\xe2\x9f\xc5T\xc0?\xe8w\x8bq\xbb\xec\xc1\xbf\x16#\x0b\xfd[ \xdf\xbf#^\x0c\x138s\x8a\xbf\xe3\x98\xcd\xc1\xf5\xc8\xf2\xbf\xcc\xaeG\xb1-\xd9\xe0\xbf\xd2L\x9bL\xe0\x86\xde\xbf\xe1\xcc<6\x9f@\xd6\xbf&B\xd0%\x8c\x1f\xf1?6\x81=\xaa[-\xe9?R56\x1cN\x9e\x99?N\xf6\xfd \xbfU\xef\xbf\xa8\x1ca\x1b\x19\xcf\xd1?\xab\xbb\xd3^"\xad\xee?\x03\x98\xab+\xe0\xfa\xf5?\xe2\xe9\xdf\xdc\x95\xd6\xcb?\xd2\xaa[\xed\xb0\x18\xf5?{\x1a|\x1c+x\xcb?\xd8\xd6\xeb\x98h\x93\xf1?J\xb0T\x01\x97\x9b\xeb?\xf3[\xd9\xaf\xb3\x1e\xb0\xbf\xfa+<\xd7 \x9b\xc1?u\x92\xc8\x02<\x11\xf0?\xb6o\x9a\xa4\xc0y\xa1?F\xfa\x0c\x1f>\xc8\xf0\xbf\xcb\x1a\x1f~\x10\xb8\x03\xc0\xf9\x9b\x01\x16\xfca\xe6?\x96\xc0\xba\x10\xc0\xd4\xdb\xbfz\x1f\xd2{\r\xab\xea\xbfE\xff|\x17\xbcK\xdf\xbfcZ\xa2\x93\xb4\xc2\x8a\xbf\x9f9\x98 \x84\xc7\xdb\xbfrj\xba.2_\xe3\xbf\xc8\'W\x13\x17|\xe4?\x15\x83\xf8\xf4k\xde\xd2\xbfU\xebv\xd3\xda\xf7\xbc?\xc6\xde\x8e0=\x9e\xd3\xbf\xde|\x8b\xc5\x95\\\xda\xbfq\xc1 \xd3\xa5\x8e\xea?\x1d\xd1{M\xa1\x17\xd4?%\xb1\xd5\xad|\t\xb0\xbf$s\x8f4_\x07\xf8\xbf\x1c\xe5\xd3\xc0\x1a\xd2\xed?\xa8\xf4\xeb\x8a\xeb\x89\xe0?B\xaf\xfd\xae\xc0~\xee\xbf\xd4\x8b\x1e\x19#]\xcd?\xd6\xe9\x8a\x18^\xc0\xfa\xbf\x83\xed\x1dt\xb1W\xd6?\x9aB\xfe(~\xb7\xa0\xbf^&Yr\x82\xa4\x90?v\x0c&\x89K\\\xe7?)\x1e\xf9B\xd54\xd3?\x1e\x81\xa1\x164:\xd3\xbf\xe2\xe8\xfb3g\x93\xbd?\x9e\x9e\xa9\xd3\xc2{\xf0\xbft\x9fkc\xf2S\xe5?\xa2\x17\xde\x13\xaa=\xf7?\xbb\x08\xad\xde\x80\xc9\xcd?\x8c\xc9H\xb5\xd7\x16\xfd\xbf\xc2hTh\x93\x8b\xef?e\xe3\xdc\x9a\xfb\xcd\xbd?)\x93\x1c\xa1G\r\x01@\x9a\xf8\x08x\xbd>\xf7\xbf\xd0\\X\x9dJ)\xe9?=\xa6]\xf3pr\xf8\xbf\x8d\x8b\n\xac\xc9\x93\xcc\xbf\xa4\x8c\xa5TN\xc3\xe6?4\xf0\xcf+F!\xf0?d\xb2$\x9a\xd7f\xd8\xbfB\x8d$\xac\x9e\x1d\xb0?^0EK\x04\x87\xe9\xbf\xe9)\xfesx/\xcb\xbf\x18\xe6TV=9\xf1?(\xc8\xe9\x8d\x1a\xcc\xe5?\xe6\x97l\x9b\xbf^\xf2\xbf_\xf7;\xe2\xb4\\\xea?\xbd\'[\xe80$\xf7?m\x06\x1f\xb0-\xf3\xa5\xbf\x95\xef\xa7\xbf3\x7f\xd5?\xdca\x1cz\x81\xd0\xee?\x95\xc7\x0b\xdf\xd8\xa7\xbc?\x19\x8d\x87F\xe1|\xde\xbf\xbf\xb8\'\x95(\xe7\xf0?_i\xc0`\xa8K\xb5\xbfE\x06\xd8\xf6\xf3\x82\x00@\x16gIzs\xf2\xea\xbfk\xd9\xbb\x0e\x94\xe8\xf4\xbfU\x96\xf6\x0bW1\xd0\xbf\t\x14\xe9\x06yi\xd2?\n2\x1c\x03\x02|\xd9?\x8b\x1dg\x06\xe56\xd2?N\xa1\xb0\xa1\x1aO\xd0\xbf\xe3#V\x00\xaf\x90\xa4?ng8~\x15\x9e\xee?,\xceC\xb9\x009\xe5\xbfb\xe1\x97)r\t\xfd?R\xf0\xd0\xfb\x818\xf9?\x96\n#-Tq\xf2?\x04nc\x00\xc7\x82\xfa?{%\xce\x95\xe9\xd1\xf0?\x93\x12\xe1\xc0\xe2\x8b\xf4?4\xac@xL+\x01@\xa0\x86\xc2\xf6\xcb\x06\xf3?\xdacqZzw\xe8?\x98\x8d\x9fj\x97d\xfe?\xb4\x1e\xfc\xa5lU\x00@.= $&j\xd5?\xc1_\x19\x92\x04\x8c\x9f\xbf9\xf2\x96\r0\xf0\xf3?oys\x8b\xc2\xdc\xe0\xbfao\xfb\xcb\xc7y\xdd?\xee\x97n\xfb\x02\x8e\xf2?\xf5\xe7\xd6U\xfcD\xea?\xea\x15\xd3@\xda\xac\xc9\xbf\xa2\x80xG\xd6\x0f\x07\xc0+\xde\xee6\xe5n\xfe\xbfd\xfc\x94\xd0\x06o\xd9\xbf\xdaB6,\xfak\x05\xc0|B\xcbrId\xeb\xbfC\xf2j\xbbZ\xbb\xbb?0\xd4\xc4\x1c\x1b\x15\xe3?\x98L\xf06;\xc0\xfb?#\x11\xe7\xe0-\xf4\xf7\xbfkg}\xa7q\x94\xf6\xbf\xa8\xf9F\x1a\x11\xae\xcb\xbf\xd8\x01\xf3,\x8f\x1b\xeb\xbf\xf8\x80.6\xd5\x8c\xf7\xbf\n\xf15\xac%\r\xc7?h%\xeb\xef\xe65\xca?\xaemw<\x835\xaa\xbf\x03\x04,\x8e,\xfe\xe9?0f{\xc1A\xd7\xe0?\x12\xb7\xca\x11/\x8d\xc2\xbf\x8373\xa0\x18<\xe4\xbf\x8b\r\xa0\x1a\x0f\xf6\xf0?\x9bS\xd9L\xac|\xe3\xbf\xb5\xbc\x81\x97\xd6^\xf5?#\xb7B\xf0\xed\xf0\xb2\xbf{\xf6R\x98c\xb3\xda?g/\x10Z\xf2y\xe2?B\xd4u\xf2ZW\xe9?g\xc8\x82\xa5X\x94\xcb\xbf\x17\x8d\x82\x9c\xf2\x89\xf7\xbfsM%\xc2Z\xda\xf3\xbf\xa8(\x82R\xd3\xfc\xef\xbf}\x92%\x10\x1eW\xce?\xb9+&X\xc6\x82\xe6\xbf\x8e\x81/\x93@\xc0\xe9?\xa5\xf5w\x80\xa2L\xf9\xbf|\xb9\x9cL\xaeM\xb7\xbf\xe8O\xa3\x1c;\xdd\xe4\xbf\x1c\xdd+;\xd6\x19\xdf\xbf\x82w\xaa}@\xeb\xd3\xbf(W\xe8\xbd>\x18\xea?\xd9\x83\xdb\xf6.L\xd4\xbf\x89\xe6\x83\xbf\x99\xba\xea\xbfp6s\x9d6Q\xe4?\xafn\xc5\x9a\x87\xef\xba\xbf\xf9\xd1\xee\xf7\x8dP\xe1\xbf\xe4f!\xb0\xf8\x10\xf9?d\xe3\xfe\xa4\x0e\xce\xc1?\xe6\xb0\xf5\x0b\x9e\xfe\xea\xbf\xc1\xa2\x83ki\xea\xec\xbf*\xcb\xdf(\xfa\x12\xfc\xbff\xde\x9f\xdc\x1e\xe2\xf2\xbf\x81\xf2\xf4\xcaQ\xb8\xde\xbf\xc8\x1d\xf4\x19E\x1a\xdd\xbf\xaa[\xfa\xf8U\xfd\xd8?j\xd8\xe9z\x19\xdd\xde\xbf\x9fj\xaa\x89\xb9\x92\xfa\xbf\x0b\xfaY_\xf4\x81\xf7\xbfQ|hM\xc1\xc4\xea?\x96\x9e\xf5\xad\t\x80\xc7?\xb6I\xf7\x183\xf2\xa8?\xba%\x15\xebP\x07\xc0?\x17\x93\xdc\xd1\xab-\xb6?\xe7%-#\xfd\xbc\xdd\xbfV\x9b\x02\xe7\xdc2\xbb\xbf\x9f.\xfe\x91r\xca\xe2?\x87.(\xa0\xb3\x15\xd8\xbf\x08\xa6_\x8a5E\xf6?\x9c\xc2\xf9\tEB\xf4\xbfY\x0f&\xdd\xbd\xdd\xd3\xbf&w\xbdG6\xe3\xf0\xbf\xae\xc2\x12K\xd4\xd3\x00\xc0n\x12\x86\xdf7;\xd0?\xe4\x86\xaf\xd6\x0f\x8b\xdb\xbf\xfa\x9ag\xc6\xd85\x99\xbf<\'\x1dJ\x95\xe2\x05\xc0\x9bP\x92o \xee\xde\xbf\xa1\x04\xcf\x076f\xf5\xbfx\x86\xfdq\xda\xe0\xf2?\x1b\xc3V\xd3fE\xf1\xbf\x90l\x18\x88\x8e\xaa\xd1?\xc6\xb34[\xef\xbf\xf9\xbf\x826\xb2f\xf8\x7f\xb2?\x95Uw\xae\xeb\xc1\xf1?\x08\xa7\xdf\x16c\xc5\xf5\xbf7\xda\xd8\x006u\xf0?5\xee-\x93\xb8\r\xd8?\xf7\xa7\xd3\xf7\x97\xa1\xfb\xbf\xfa\x8f\xcc\xcd\x06g\xfc\xbf.)\xfd\xf4\x07$\xdc\xbf\x8d\x02\xce\xdd`-\xf8?\x10n\xaa\xea\xb5\xc2\xf3\xbf\xef\xab\x8a\xc2,\xd9\xf5\xbf`\x93?\xc3%\xe9\xe8\xbf\xe2d\xbf\x0c\r\xb1\xf3?\x9bE\xfe9\x8a\xf3\xf3\xbf^\xb8\x19\x18\xc3\xc8\xd9\xbf\xa6\xd1\x06\xfa\x03\x06\xe5?}K\'\xea\xe6L\xf7\xbf~\xc5\xef#\r\x05\xd1\xbf&t\x08}S\xc2\xd0?AUA\xbbj4\xf1\xbf\xab3\x90\xf6}F\xe4?>\x0c\xb4\xcb\xf0I\xe1?\x9b\xd7QQ\x0ce\xfb?\x8ev\x04\xaa\'i\xbc\xbf^\x83\x13F\xd0z\xca?p\xfd\x8c\x04\xa6B\xfc\xbf\xa4\x11k\x1eI/\xfe\xbf\x15IX\xf6{\x14\xf7?\xec\xd5\n\xf3\x917\xe1\xbf*ac\xc92\t\xfb?\xe9\xbb\x18\xb3\xdd\xcc\xf8\xbf\x08hG\xcf\x9aB\xe9\xbf\x1c\x06\x8d\xc0\x0ej\x01@\x90\x80\x05\xe1\xaa@\xfa?\xf1\xf1\x8b\xe9\x1c9\xd8\xbf\x87\xd9G\xc7n+\xf0?\xefI\x98\x95\xf2\xeb\xe5?8e\xaf \xc3!\xcc\xbf\x83 \x9e\x99\xd3\x91\xff\xbf\x1f\xb5\xd7}OP\xee?\x19\x13\x87<\xbdB\xe2\xbfG\x89\xb5\xa4\xb8;\xc2\xbf\x9a\xea\xc9\x80?\x99\xd8\xbf\xf68/ }\x1e\xce\xbf\x93o\x05\x9a\xb24\xc0?\xee\x02\xb64.\x0f\xf6?\x04\xd7~\xf6\x8c\xfb\xdb\xbf\x8ck\xfa\xb1\xb1y\xe1\xbf\xd6S\xa8\xab\n,\xc1\xbf\xd4\xcb\x9e\xa6\x7f\xf9\xd3\xbf;\xc8\xaa\xac\x89\xf8\xf3?\r\xe0>\x8dMl\xfa\xbfw\xb5\x91\x93A\x9e\xdf?\xf8\x1e\x7fWE\xd3\x01@+\xa8;\x82\xcc\n\xfc\xbf\xf3N\xe6\t\xcdq\xe1?/\xbc\xdf\x81*@\xfd?\xda\xa4\xa6\xdf\x1b\x88\x03@\xb9\x9c\xff\xe1\xf5m{?sr\xc6L\xd9!\xb7\xbf\x1c\xabj)e\x1e\xc0?\'\x98\xc5\xc9\x1bY\xe1\xbf\xe5\xf1U>4\t\xce?\x1d\xeb\x9e\xeal\xf6\xe6\xbf\x03\x9b(*\xda\xea\xf1\xbf4W{#\xb2\xca\xfe\xbf\x84\xe7c\x81\x9b\xc0\xf3\xbf_z\x07q\x1et\xe3?\xbc\x9c\xc7\xab\xea\x82\xba\xbf\x7f\x8d\xc5\xd8\xdf&\x02\xc0\x85\xb7.d\xfc\x91\xb6?\xe4\x0e\xc2GH\xf9\xd0?\x90\xaf\x90\x0e\xc6R\xee\xbfYyi\x1d\xf6\xd4\xfd\xbfa\xe3t\xb3\x92\xa6\xe6\xbf\xc7K+9\xda1\xc3\xbf\x8d\xd10\xac_\xb8\xf5?yT\xf8\xe32\x01\xf7\xbfx\xaf\xe1\xf8\xf22\xe5\xbf a&y\x1e\xad\xbd?\xef\x82^u\xbc\xaf\xed?\xaf)\x93_\xda\xc6\xe0\xbf\xf5\x8fV\xe8J\xb7\xfb?\x0b\x83\xdb\xda\x13\xc8\xf8?q}\x86\x84\xcc\x93\xdd\xbf\xf5{%5\xfb\'\x05@oF\xc4\x93\xde\xda\x03@\xdaV\xac\x0e\xf8\xf9\xf1\xbf\x05\x04l\x91\xaf\xaf\xe8\xbf:x7x\x96\x92\xbd\xbf\x84\x1b{\x8a\xe4U\xf6?\xa8\xfd\xe0G\xafN\xc6?\x8b5\n\x16\xb2\x97\xd1\xbf\x84X\x13\x803\xbc\xf2\xbf\x1b\x02\x10\xc4\x9d\xac\xf5?}{\xb8Y\xce\xfb\xa8\xbf\x0ek\xa9\x02\xe8\xfc\xc1?\xa2\xd3\xd9Ri\x1b\xd9?@M\xe6\x1c1L\x87\xbfd\xde\xd7\x03\x94q\xd7?\xcd\xc8\xbe\x83O\xda\x03\xc0\x84$\xd8\xf3\x0f\xf8\xd8?\xa8\xf5\xae\xb7:\xd1\x04@\xa5\x15\\\\\x0b\'\xf5\xbfxtt\x81\xdd.\xd4?8iQKn\xbb\xee\xbf\xc63\x1dt\xb2\x8e\x00@<6\x95Y\x01T\xf0\xbf4\xa7\x8f\x98\xd9\xe4\xd4?\xcd\xb4#\x1f\xa26\xea?]3\xf8\x86]p\xe6\xbf\x16m\x95\xb2\x9c\x1e\xa0\xbf\x9c=!\xa5\xb7>\xd9?)\xda\x00\x86\xbb\xa3\xe9?\xbb\x8cF\xd8\xf5\x87\xe6?\x06\xd7\xa0F\x94m\xb7?\x08\xd5\x87\x19\xdcX\xf3\xbf\xe0\xf9q\'\xb4\xfa\xed\xbf\x81\xdd\xb5\x1189\xf3?\xe8\xd6\x8fHy\xb4\xd0?\t\x9c\xebn\xb1?\xe8\xbf\xbb\xa2J\x83\x1c\xed\xea?\x1f\xf2\xeeO{@\xb4\xbf\xd5:\x03\xb3\x15\x0b\xe8?S*\xfcW\xe25\xfa?\xact\xa9_\x06:\x02\xc0o\xc9ft\xc4\xf7\xdb?\x87Pl\xb4_+\xd2?#\xe1\xad\xcd\xf6\xf5\xe1\xbf-\xcf\xa10<&\xed?`e\xdc\xff\x9d\xa8\xef\xbf"D\xa1g2q\xe8?\x81\x9b;c$\xa8\xe5?\xa2u\x95\x02v\xab\xe6?t\x14H\xeb[\'\xe4?\nW\x02W\x91\xdc\xd4\xbfL\xfa\xd3\x9exD\xe5\xbf\x9b`5\xe0\xb9\x80\xed?3FK\x07\x17\x85\xd2\xbf|\xe0\x81L\xb3\xdb\xfa\xbf\x95\xe1\xc2F}L\xbe?\x7f\x1eI\xdf{\xf9\xe0\xbf\xe0\xeb\xa8\x89\x96\x8b\xda?\x82\x11\x8f\xff#/\x9e?\xef\xc2\xf6\x84\x9b\x9a\xf6\xbf\x17\xfcE\x03\xb8\xb1\xeb?h\xac\x9av\xcbW\xdb\xbf/\xa2\x9ew\xf3\x98\xe8?xD\xa1%\x86>\xed?[]z\x86\x05\xa4\xb2?\xa2"c\xce-\x9e\xe4\xbfi\xe27\xec\x96\x80\xd0?8\xb1\xb7\xdf\x00\xf3\xd7\xbf\x83&\xa7\xf5\xe7\xa4\xf2\xbf5RC\x97\xd4\xdb\xf3\xbf4@yD\xda\t\xc2?\xe1\xfa\xe7$\xdeW\xdb\xbf\xa0\x1fo|\xd8\x80\xfc?t6\x91\n\xc0>\xbe?\xfb6\x18.\x80\x0c\xc1\xbf\xd1\x08:\xc5\x01\x03\xf3\xbf\xf4\x1dBHM\xe5\xe0\xbf\xad\xb2\x16b\xc3\xdc\xe7\xbf\xe7^n0?\x99\xea\xbf\xc2G5\x94[\x86\xfa\xbf+.\xba\x10rC\xfb\xbf)d&PU$\xc8\xbf2H\x04\xcb-\xf9\xf0?\xdf\x82\x916\xef\xf4\xe6?\xbd\x9d\xc5\x15\xa6\x8b\xf6\xbf\xb0\x92\xf33(\xbb\xf5\xbf\xd6\xc2.\x04q\xd7\xf5\xbf\x99a0\x04\xc2\xab\x00\xc0\xe5-=j \xca\xea\xbf\x13\xbf\xbc\xeb[\xaa\xc8\xbf\xd935=)U\xa7?\xd7\x97\x1f\xf0S\xf7\xea\xbf\xd5\x99<\x12[b\xf2\xbf0\x03\xfc\x05!\xa9\xd4?\x8a\xf3-\xfa\xfc\x91\xe0\xbfc\x83\xe7w %\xcd\xbff\xf9L\xf4E\xda\xd7\xbf\x83\xdf\x94\x82?\xd8\xc4?aq\xbf\xef\xb5\xdb\xc3\xbf\xf5X\xfc\xbd[\x9f\xee\xbf\xa2\xf6u\xd1K\x0f\xf6\xbf\xfb\xcd\x8f\xc2\xb4\x86\xe6?dh3\x8d\xe2\xd5\xf3?\x1a\xf31\xbd\x90\'\xc8?\x89\xff!\x84\xd2\xf4\xee?!\xf8\xf8\xf2\x9dL\xd9\xbft\x99\x8d\xdb19\xf2\xbf\xb3\xf3\x8eS\xe7\x07\xf5\xbf\xfb{\xdb\'\xd7\xee\xe8\xbfE\xc4\xf4\xbc\x14Y\x04\xc0\xc1\x03\xed\xe0b\xe8\xf4\xbf\x08\x196O\x7f\xe5Y?\xdc\xcfyd\x12\x08\xe6\xbf\xbao\xb25c\xf7w\xbf;Z7f\xa0z\x00\xc0\xa4\xfe\x97UJV\x00\xc0\xd4\xa4T"\xa6\xef\xcb\xbf\xbd\xa2p\\\xe8\x88\xa0?3\xde\x92NB\x8f\xe5\xbf\xc0=\x81\xedi\x15\xda?\xdd\xf1o\xa7*\xd3\xd0?\x03\x08\xad\xeb%\x7f\xe3\xbf[\xdf\x92\x96\xd8\x82\xb2\xbfM\x1a\xca"\xb3\xb0\xec\xbf\xf5\xbf;W\xd1\xc1\xed?\xbb\xe1\xc4P\xe3k\xed?i\xa7\xfa\xadI\xe8\xe9?\xf6\x10\xa9:\xfa\x90\xec\xbfg\xcb\xb2\x0c\x9d{\xda?\x88\xadA\xd7\x8b\xc4\xee\xbf\x04Q\xcf\x88\xda\x15\xfa?\x92\xce\x88\xd0\xa8/\xdc\xbf6L\x9b\xe5\xfc\xaa\xe6\xbf\xe1\xda\xcd\x9a\xe4;\xf0\xbf5\x84\xa9e4\xa8\xde\xbf\x9b.\x02\xce\xf5\x99\xfa\xbft\xd2\xd1+8\xb6\xd9\xbf\xfey\xc8\x0b\x8e\xec\x02\xc0\xea\xd6)n\x83\'\xbe\xbf\x08j\x10>$\x91\xd1\xbf\x16\x1b\r9\x10$\x8d\xbf\xb6x\'\x14+;\xf2?\xe2\x04\x07\x1aq\x0e\xf4\xbf\xc6\xcf\xa4x\xea%\xac?\x1a\xcdAE\x16\x1d\xea\xbfq\xa1\xd5\x86\xe3=\xdd\xbf\xa3.}\x1cbt\xf3\xbf\xd2Y=\x84\xfba\xf3\xbf\xae \xb4\xf4\xe9\xe9\xe6\xbfkcU\xb2\x0c\xce\xd5\xbf\xda\x05\x9f\x17z5\xf4\xbfz-d\x89C}\xf1\xbf&u1](L\x03\xc0].\xd1\xf9^\xc9\xdd\xbft\x17\xf9\x87\x8e\xd1\xe5\xbf\xa7&\xc5M\x9d\xed\xb4\xbf\xdc\xd0\x9c\xcfN\x10\xeb\xbf\x88O\xf7\x9fa\xad\xf2?dk\xb1\xa5i\x13\xd6\xbf\xe4\xde\x1d\xc0\xa8\xd8\xd2?\x9e\x8bZ\xbcd\xb2\xd7?d\x1a\xad"\x11\xdb\xe8?@\x9az\x0c,\xc5\x10\xc0E\xc4\xf44\xe6?\xd9\t\xcb\xeb@\x05\xf3\xbf\x81sTEPU\xd4\xbf\xcf\x0f\xb7\x0c\xbdp\xbc?\xa04\x02\xb0\xd3\x8d\xe7?\x8a\x11\xde\x1dZc\xea\xbf\xaa\xe2\xc4\x8dP\xd8\xf5\xbf\xd6\x120V\xc8@\x01\xc0\x8f\xb2\x96<\x17\x0f\xe4\xbf\x18\x9c\x84]\x9f\xf4\xf0\xbf\xcfg\xa7\xc6\t\xc8\xd7\xbf\x88()V]i9?\xe3o\xf7\x86\xe6\xdb\xf2\xbfT\xc5\x1a\x03;\x15\xf1\xbf\xd3S\xb9/\xc4Z\xe8\xbf\xfa\x17\xee\x8ab\xfa\xf2\xbf/?\x17\x9d\xbc\x87\xc1\xbfd,\xfd\xc6\x8b\xbb\xd5?}^\n\xd1n\xdc\x03\xc0=\x046|*\x1d\xd9\xbfPxi\xd6\xaf\xb1\xe8\xbf\x83\x92\xd5G\xcc\x8b\xd1\xbf\xf3\xda\x8d?g#\xb7?f\x9f\xc0N\x8d\x91\xf2?\xba\x1d\x1e\x98\xdd\x99\xe1\xbf\xdbI\xb5q\x0e\xdb\xbf?\xa8\x81\xd1\xfe\x91\xd6\xea?\x80\xaer\xf9+o\xd5?\xd4d_\xfc\xe3j\xab?\x1a\xcc\x82`\xdd\x88\xe7?#\x92\xcf,\xbbD\xe3?-\x11[\x00%\xbbs\xbf, 0\x13\xc5\xe8\xbe\xbf\xaeK\xce\xe3l\xfc\xfd\xbfU\xe7\xdb9M\x83\xd8\xbfr\x1c\xb6<+y\xf3\xbf\xb7\x12\x16\xfe\xf4\xa1\xe7?\xb0\xb3\xf3\x86<\x7f\xd3?z\x8c\xberJW\xf5\xbf\xe8\xed\xbb0\xa0\xce\xf0\xbf\xc1\xfc\x14\xdf/T\xf7?\x9d=C\xffo\xd6\xda\xbf`\xa2\x05\xf6\xc1\xf5\x06\xc0\x03~l7\xa6d\x04\xc0\x93D\xda\xdf\xd2\xeb\xf7\xbf\xe9\rM4\x16\x14\xed\xbf6\xf6\xe4\xd7\xfaI\xfd\xbfeP\x99\xd3\xc7<\xe7\xbfd\x15T/\x8c\x1b\xb8?\x10\x82\xda\x87G\xdb\xe0\xbf-\xf1\x89\x17\xae\x8d\xcf?\xb2Fo\xc6\xc8?\xf0?\x93\xb7$\xdd\xb0\xcb\xd3\xbf\x0c\xb3\xf2\xa1\xff\xb3\xcb\xbfI\xd5\x015M\xd9\xeb?e\x955\xae\xb0\x01\xcd?\x05\xcf\x16\xc9\xe3\xc8\xf1?\xa6\xd5\xc3\xffX\xf7\xf2\xbf\xc6\x18r\xa4\x1a\x92\x01@\x0b\xe4\x913j-\xe4\xbf\xe7YF\xb6\x1a\xd0\xfd\xbfg\xce\x17[\xcd\xe7\xcf?PX\x7f\x06n\xb9\n\xc0\x93\xbb.x\x9b\xf4\xf9\xbf\xaazEzB\xfa\xf2\xbf\x9a\xf3K\x07!\xb4\xda\xbf\xe1\xbc\x90(\xe6d\xff\xbfU\x02\xab9a\xe5\xe3?,@\xdb\xf9\xd6\x13\xe1?\x95\x89\xe9\x94z\x8f\xbf?\xb18\xe5\xc8\x03\x9f\xf6\xbfL\xb0\xfc\xc7\xe2\xd8\x06\xc0\x85_mm\xd1\x93\xf8\xbf\x17\xb0\xaa\x02\x85\xd5\xa1?\xab\x9c\xc3C\x86\n\xd0\xbf\xef\xee\x06\x1b\xff.\xd5\xbf\x8b\x97\x150%.\xef?\xaa\x1a\x85\xd6\xb0\xaf\xf0?\xadE\xa7\xadD\x90\xe1\xbf\xbb\xed\xf0\xc1\x18\xd8\xe8\xbf<\x11\x98J^\xa1\xfc\xbf\xc4\xbc9y\x05\xfc\xe3\xbfwF2jf\x9e\xe8?ic\xa7\x18\xca\xb3\xf1?\xfd\x90\xbf\xc3T9\xd5?\\\xce\xfd\\\xd7\xe0\xf3?\x11f\xa7/g\xa7\xc9\xbf\x9f\xefz,\xfc\x97\xde\xbfw\xb4X\xa1O\xbe\xc4\xbf\xf2g\x10$l\xb6\xf1\xbf\x03gb\x90\xde\x84\xd7?2\xe8m\x02\xe7\x05\xf3?\xe5\xab\xa9q\xa9l\xed\xbf\xea\x10\xaa\xbb\xf0\x8a\x00@\xf0\xd4\x8f\'\x03\xf1\xf6?\xf8\xb2\x81eA\xa7\xcb?\x90Hz\x96r\x8c\x02@\xc4\xe4\'\x10*\x92\xdb?\x1c\xd4\x18M\x91\xad\xec\xbf\n\xea\xab\x9fG\xbd\xf4?\xbb+{\x8c\xea\x93\xd9?\xc3\xc1|\x14y@\xe7?\xb4\xe6\xfb\xe5\xc1K\xf4\xbf5\xa0\x9a\n\x19\x82\xf4\xbf\xbef\xe7oH\x18\xf2?\n\xe0\xd6\xc0\x90\x1c\xe7?\xcb\x1f\xb2Q\xb4\xc5\xf1?\xea\xe1\xca\x84\xcf\xae\xf0?N\x93\xb7\xf6q\x88\xde?\x93\xa5(\xb8\xcf\t\xf7?\x8e\xfciq\xc1\xcd\xb5?\xe3T\x9b\xc7\xd7\xd5\xb3?\xfc\x8e\x85\xa35\xc0\xe9?\x88\x88\xbdUEU\x00@cda\xcc\xce\x87\xcc\xbf_\xa6/\x08\xdb\x9a\xfe?b\xa9\xfd\x17\xbd\xea\xe5\xbf\xa0b\xa4\x87\xd1S\xdc\xbf\xe4Y3\x97\xd6R\xe6?0\x930\xe5-\xb1\xf2?\x00\x9fC\xfc\xfc\xe0\xfe?1\xe9*\xe6\xf4\xae\xe6?\xbe\xdf!)\xf5B\xe7?\x02\xd2\x87\xe6eM\xed?\x17\xa6\\PA\x0f\xf0\xbf\xe8d&^\x1f\xd5\xe8?\x8f\xcf\x0cP\x95\x8c\xf8\xbf9d(\xdav=\xe2\xbf6R\x07\xbd\xea&\xe5\xbf\x98G\xb5\xd3\xb4\x1a\xfb?\x825\x9eC\xc4\xf0\xc1\xbf\xcc\x95\xf3uK\x88\xe4\xbf\xe6\x90\x08l]\xed\xe3\xbf\x14\x99\x18]\xc6\xd9\x85?\x1c#i\xe1\x86\x7f\xe7\xbf\x82\x97\xdb+\x16\x04\xd8\xbf\x7f\x14\xa5\xf3\xc8\x94\xf5?y\t\xcd\xb4Cp\xcf?\xf9\x05y\xe9\t\xb6\xee?\x1e\x9ah\xbf\x99\xfc\xdb?t\xb7\xb5]\xd2\xfd\xf4?\x119\x8b\xd935\xfa?*\xdd\x0b\xc7u\x03\xef?u\x8b\x7f\x17\x7f0\xec?\xda\x13\x12k\xdd\x08\xf9?\xff\xed\x82\xe8YE\xed?m\x90\x84<\x8a\x88\xf2?#\xde\x9d\x84\x86\xfe\xea?\xd5\xed\x8a2}\t\x02@\t\xab3\x9d.I\xe8?>\x92\xa2\xbb\x19^\xe3\xbf.\xa9\x7f\x84:\x02\xfb\xbf\x89\xadH\rr\x89\xe0\xbf\xb7\xe9\xcb\xa5IO\xf9\xbf\xa9\xb6\xac$_\'\xed\xbf]\xdcY7\xe4\x9c\xeb\xbf\xdc\x8a\xa8njR\xad?\t\xf3\x18>&\x0c\xf4?\xc2\xd4[l\xed\xa3\xf3?\x8fw\x04A\x95-\xf2\xbf\xc2Gm\x83\x9a]\xe5?\x85YR\xd6R\x96\xd3?z\x8fG\xc8]\xbd\xeb?\x8f\xb0c\x17D\xd3\xbc?\x06\xa1\xb0\n^u\xd0?\x17\xae\x12\xff\xcd\xf1\xb0\xbf\xcap\xe3\x1c\xa2\x99\xf2?\xe21\x95I:\xe0\xb8?R>\xb1.\x8b2\xf2?\x04\x8b,\xcbU\xbd\xb3?\x84!^.8\xa8\xf4?\r\x98g\xa7\xa5\xde\xf8?\xf2\xf4\xbb\x87[\xf7\xea?\xb3\xe9\x01k\x1eB\xff?\xf6\xd3\xabW\xa0\xbc\xda?\x1d=\xd03\xb4\x80\xf6?if\xda\xe1\x1bd\xd2?\x1f\xbdQox\xf4\xfc?\xd4z`\xe6\x94\x9f\xdd?0\xb7\x8a\xac\t\xf1\xca?\xa7\xe0\xb3\xe6Qp\xb3\xbfg\x95<\x96\xfe=\xf8?\xa0\xb08\x05\xd9\'\xdb\xbf&\xfe\xaa\xea\xdb\x83\xdc?\xff\x8f\xa4\xd6\xab\x82\xf5\xbf\xe0CD\xaa\x04\x1d\xf6?vjc-\xcf\x1a\xf4?SF \x0f3\xa5\xd2\xbf\x83\xffs\x8bh\xf1\xd2\xbf\xae\x81J&P\x7f\xda?9&\xd4\x8f\xe8f\xc4\xbf\x82\x1e}\xf0\xf0y\xdf?\x0e\x94\x07\xd7\xfaU\xde?>\xca\x18u\x8f\xf1\xcb?\x06\xee\xfd\xb7\xbbi\xf0?o\xd6\x93\xe8\xeb=\xd5?\xd8\xff\xecD\xde\xcf\xf7?\xd5{\xd2\x13\xbd\xd7\xf8?\xac\xdcY\xd8\xf7\xe3\xb6\xbf\x8f[\xe3&OO\xde?\xf5\xc4\xed\n\\\xa5\xd0\xbf\xa7\xd4=\xb3p2\xf6\xbf\x1d\xe6\xa1\xe2\x11\x9f\xf8?\x0f\r\xc5\x9a\xff=\xfb?3\x89(W\xec\x91\xd1?1?7.\x17\x84\xce?\x8d\xd5\r\xb6\t\x91\xd3?+\xd9\x06\xe5n\x8f\xd4?\xe4\xa23\n\xad\xc6\xc1?L\xdc\xdbs\xa5\x8e\xd3?\xafp\xaa\x91\x11q\xb6?\x17r\x91\xb9b\xe8\x00@\xa2c\xbf\x81\x8c\xfc\xf0\xbf^\xba\x0f\xef\t\xbc\xd5?\x1c\x96Cg;T\xf4?\xe5i\x13\xee\x944\xe8?\x7f8\xb5\xb7\xe4y\xfb?<\xd9V\xaf\xbe\xf0\xf3\xbf\x90\xdfy\xfd\x16\xb5\xcb?)\xc7\xa8`_\xfd\xea?RXjW\xd1S\xc9\xbf\r\x07b&\x0et\xe3?3\xc2\xef\xc3\xdb\x85\xf9?\xa8u,E\x93B\xea\xbfg<\x80\xb5D\xfd\xeb\xbf\x97\xf8\x90\xf8\xcf\xce\xe6?\xe9J]<\xdf\x98\xf9?\xe3D\r\xf2\xa2%\x8a\xbf{\xa2\xd9|\xc8\x03\xea?\xf1\x08b\xcf\x1d\xac\xc6?\xaaO\xa8%\x9b\xcf\xee\xbf\xc2\x89\x85c\xfb\xc9\xff?\xc4\x10\x8a\xfb\x1e \xe8?O\x1f\x95U\xc9{\xf5?\x85&O\x82\xaa\x0e\xf7?\xa0p\xe1nX\xf2\xff?f\xec\x82\x07\xb5\x80\xf4?\x9e\x8c\x9c\xa4-\xd9\xff?\xf9\xa3\x00\x10\xe5\xe3\xb4?\xbe\xaf\x92\x89\x80\xe3\xd4?^\x01e\x87\x8b\r\xf4?Q\x01\x1f\xbc\x84Z\xd7?\x13\x93c\xe1Tw\xd1\xbf\xb7a\x00\xc4\xc2I\xe5?\xe4\x1ef\xd9\x1et\xd9?d\xa5LM\x8b\xdf\xd4\xbf\r!\x01)%z\xb5\xbf\xe1P\x15\xd6u\xbd\xfa\xbf\x96\xf4\xc9\xd40\x1e\xf6\xbf3\xa5\xf4q(\xda\xde\xbf\x87N\xeb\xbd\x1a\x12\xe3\xbfv\xfa\xa2\x9e\x9fb\xf4?\xe2\x08\x17\xccTw\xd0?\x06\xcaee\x99\xa4\xe2\xbfKR\xbe\xab\x81\xbc\xe6\xbf\x15w\xfd&\xcc@\xe9?\xe8\x1f\xb2\x14N\xd8\xe4\xbf\xa8\xf9\x1a\xd6\x04\xf5\x00@O\xcb\xa2|\xca\x8c\xb4?\xe9%\xb3\x98\x96\xd4\xf9?Z\x19\xd1\x9a\xa6\x0f\xcd?2f\xa9G\x17\x04\xdc?\xfc\xc9\xb5\x8bhr\xda?\xb9jf\r\x1c9\x04@\\\xe6h\xa5\x14$\xf1?\x06\xaf\xfb\xb9c#\xdf\xbf;?\xeac\xac\xb4\xf2?\xfb\xf3Ph$\x16\xfc?\x1c\xf6\xfcK\xf3N\xc9?\xc3D\x05cZs\xe1\xbf\x07w\xab\xc1\n\x16\xbd?\xce\xd9\xb7\x87J\x86\xd3?\xdd\xcbt>iX\xeb\xbf\x92\xb1\x18\x9f\x7f\x0b\xe2\xbf\xf0M\x08\xc6\x87\xc5\xeb?\x86\xf4\xb0b\x8d4\xe2?\xdb\xf0_\xd6\xaad\xc4\xbf\xf3\x9c\x0f\x13\x8f\xd1\xe3?y\x1a\x1e\x98\x00N\xe8?\x93"\xcbD\x84\r\xda?\x1e\xbd\xdbH\x84\xd0\xf2\xbf\xfb\xe7\xc4\'\xf4\xc5\xf9\xbfE\xe1a,F\xd0\xf7\xbf!As)\xeb\xcd\xb1?\x04\x9e\xc1/]a\xf0\xbf\xe8t\x93\x94d*!\x8d\xbf31^\x17|\xb5\xee?\x94\xcc\xbarxH\xd9\xbf\xb9d\xb1_\xb4\xbb\x01\xc0\\\xdf\x0f\xa4Z\x1e\xe7\xbf\x13\xefr\xc7;\xc6\xd4\xbfz\xd2*\xf8\xc9+\xf9\xbf8\xea\x9e7\x7fT\xf3\xbf\x8dz\xf3\x10\x1c9\x06\xc0,\x9d\x818\n\xbe\xd9\xbf{\xac\xdc\xffT\xde\xe8\xbf\xa5d%7\xbex\xfc\xbf\xdd\xd3}\x0c\xe9y\xf4\xbf\xf5\xb1\xb9\x0c\xbaZ\xee\xbf\xec\xbc$qQ\xa7\xd4\xbf1<\xf2_U\xd6\xfd\xbf_\x08d|\xda\xa8\xe3?P\xc7\xcf\xdcb7\xe8\xbf\x8c\x8e\xa4\x80\xd3\n\xdb\xbf\x15\xdf\x8e\x82B:\xd4?\xfc\xf5\x17\x0c|\x98\xd1?\xcc\x9a\xed\r\xe3\x92\xe2?mr=X\xc5\xe3\xf3\xbf\x1e\xc3\x99\xadT,\x02@\x93\x96\x8c\x00 \x85\xeb\xbf\xe5G4\xef\xf8\x02\xf8\xbf\'\xa5\x95\xd3\xd1,\xf9?/\xf0\xfbRJ\t\xf2?\x00^\xb6\x94\xc1k\xfb?}\x81\xdf\xc7\xc8\xbf\xe6\xbfS\xc1\xdf^u\xc9\xe0\xbf\x1a=?\xf3\xb2\x92\xea\xbf\x97\xba6:\x15\x14\xd1?\x94\xfa\xb1\x05\x1db\xf8\xbf\x80\xa7\x89.\xdb\xce\xf5\xbf\xa5\xcaI\xf6Lg\xd4\xbf\xfe8=j/2\xf4\xbf\xb7J3\x8e\xaa\x00\xfb\xbf\x0f\xaf\xa9\xb7\x11\x88\x06\xc0\x19\xab\xd2\x9d\xb2/\xff\xbf\xd70E\xebw\xd6\x06\xc0\xe4\xdb\xfe{\x01\xe3\xf9\xbf\xd0k\x02C\xef\xc5\xe0\xbfa\xcc\xdb\x14\x1fT\xe0?t\xec\xb7\x06\x00\xac\x01@\x1eA\xb8\xd8Y;\xcf?\xebi\x9b\x9d\x81\x8a\xbc?\xdc\xdbxq\xc5\xa6\xe6?\x91\x94\xfc\x7f\xb0\xf5\xe3\xbf\x1cm[\xd7>;\xc8?+\xb5P1\xb6\xef\xa0?tOK\xba\xeah\xc7?2u2\x7fhc\xc1?\x8b\x9d\x9c\x9c\xa7&\xd3?\xe1\xcc\xb4C\xe8\xc0\xf2?H@\x1d\x9d\xb9\x14\xf4?e\xff\x0b\xeeb\xaf\xe5\xbf\xbfx\x8cT\xf5\xf5\xf1\xbf\xb2\xcdRre\t\x03\xc0\x86\xac\xda\xc0\x14:\xe5\xbf5\xbb\xb4)U(\xe7\xbf\xab\xf8\xf8\xc2P-\xd9?\xbd\xb8a\x08\x17q\xde\xbf\x99\x9b\xf8\x11_\x1d\xf8\xbf\xcc\x10K\x88\xec\xdb\xf1\xbf\xe6t\x1b\x0bz\\\xd7\xbft\x02G\xc8\x9a\x8c\xb4\xbf\x81\xbdx\xf8\xc9"\xff\xbf\xa8\xda;\t*h\xd1\xbf\xa4\x91\x96\xf42\x19\x07\xc0rP\x0f\x1b\xcf\x80\xf8\xbf\xc5B\xce\x90\xe5E\xe5\xbf>\x02\xbf\x81VB\xe1?\xf0\xba\xcf\x99\x8ev\xe4?\xc9\x01p`\xd82r\xbf\xe1\x98l\xab\x8c\x05\xe4\xbf\x93\xe38\xf4\x978\xe2?w\xe5\xdcTU\xc2\xb4?\xf7\x8a\x1b\x8b\xbf\xc1\xd4?\xc1u\x13\xdb\x8c0\xa2\xbf\xab\x01\xf4\x99;\xa7\xe9\xbf\xe6\xc0\xc1k\xd4\xaa\xd2\xbf\xda\xbe\xf8\xf9B\x9f\xe6?Z\x9a\x04\xa0\x98\x0c\xb4\xbf\x96\xdaM\x8c\xc6\x83\xf9\xbf>*-\x8a\x84\xe2\xc5\xbfhD\xf6[\xd5\x8d\xf0\xbf\x0f\x1a\xbe\xa7UI\xe8\xbf\x8d5\xe9\xf4S\xf3\xdf\xbf\x88\x07\xac;\xc0\\\xf0\xbf\xd2$;\xc2\x90\xc6\xea\xbfwG\r\x8c\x1b\x85\xc2?D\xc1\xda\xecr;\xe5\xbf\xd0\x84\xde,\xe5\x82\x03\xc0\x12\xd3\xa69\x8c\n\xcd\xbf\xca\xfb\x8a^\x06\xe8\xf5\xbf\x1a \xa6K,\x91\xa6\xbfK\xe4l\xec6)\xf2?\xf1\xe5\xbb\xf6r\xd3\xfa\xbf\xa6\xb2\x1b\xd15T\xea\xbfTO\x95]\xfe\x96\xf6?\x93H\xac^\xf1\xee\xe8\xbfl\x84\xaey|\xb8\xd1?\x9di\xeezr\xaf\xeb?"\x10o\xa8\xcf\x12\xa4?\x16\x86\xe4\xa75\xf3\xe8\xbfO\x0f\x9d\xacvv\xd2\xbf\xaf|m\x99z\x8e\x01@\xe3\x02l\x980\x1f\xd3\xbfm\xf06\xeb\xef\xe2\xf5\xbf\x85\xa2<\x16n\xb9\xd2?\x8f\x8d\xd5:\x14V\xfb\xbf5S\x12\x8eV\xa6\xb3?\xd6q\xd7E\x80+\xf4?w\xfaI4V\xea\xd3\xbfq\xacNyZ\xae\xf9?\xe4\xc0\xd8!\x84\xcb\xf8?\x802!J\x95\xa5\xb1?A\x12\xe8\xaa\xf1\x15\xfb?\x1a\xb1\xf9\x17\xbf\x05\xed?\x19\xb1\xa6@\x07\x8d\xf8?\xf8\x01m\xb9\xdet\xde?bZ%\xb3\x96\xdd\xf9?\x0c\xa9\xcd\x14\xa8H\xea?\x96^\xb3\xe5\x19\xa3\xe8\xbf\xe1\xc9\x10\xe0Nc\xde\xbfV(\xf0U\xae+\xf6?\x10O\'\xbd\x04\x0b\xec?\xa8\xc9\x10\x1a\xb9\xa6\xed?\x13en)%\x11\xcb?q\xc3QOu\xb4\xf9\xbf\x024."\xb3$\xf3\xbf\x92tl;\x9c\x08\xf1?Q\xf2k%\xb4J\xe8\xbf\xf6\x89W\xe1\xc51\xf2?\x93o\xa0\xd2"\x0f\xf2\xbfO\x1e\x89p\xff\x92\xf8?\x1bgV\xa5%9\xe4\xbf\xaf\xdb\xae\x97[{\xc3\xbfy\xccCd\x0e\xe0\xe0\xbf\x8f\xf0h|\xb7\x0b\xcb\xbfd\xfa\x85\xfa\xff\x9c\xb1\xbfz\xce\xe2\x9b\xe1w\xf6?\xc5)\xda\n\xa0\xe3\xf7?^\x1a\xbe\xba\x85\x8c\xd3?\x9d\x85\x91\xc6\x03-\xec?N\xbb[\x06e\x86\xe4?\xf4\xac\xae\xcd\x18\xa2\xdf\xbfL\xb50\x8e\xcfX\xe0\xbfj\x0e\xb79\xf5\x03\xfe?\xd5\x0b\x05\x85\xdc\xd1\xb1?\x92J\xdf\x89>[\xef?E\xc4\xfd\x8c\x8c\xd3\xde\xbf!\xfa*f\xaac\xf3?\x97\xe2R\x0b\x0ck\xe8\xbf\xfb+a\xb0\xd2\xbe\xf1?~<\x1a_\x96\xe2\xe1\xbf\n\xf7w\x08\x92\xbc\xe2\xbf\x7f!\x1a\xc2\t\x9f\xf1?\x86\xec\xda\x1fd^\xe4\xbfsD\x86\\)\xb2\xe0\xbfB:\xaaRRF\xf2?\xbb\x14\x93\x9f\xd0x\xe6?Y\t\xc8\xe5\xc0\xa5\xf4\xbf\xae\xa2\xcf\x86\xd4\x16\xff?\xa5f\xd7\xaaO\x07\xc6\xbff \xb0u\x06\xb3\xf8?\xd3}=\xd9\x18\xbe\xed?\x19(\x031\xc43\xd0\xbf"\xc4\xcd\xb5\x84/\x00@\x1d\x92`@\xf1\xf8\xe3\xbf\xf7%\x1b\xf7\x1e\xe6\xba?\xd3\x9aAe8\xbc\xe3?\x0b\xcbK\x9f@I\xeb\xbfZ\xd8\x14\xd3\\pq\xbfkh<\x0e\n\x00\xef?\x92@\x1e\x84\xfc\xd6\xe7\xbf\xf1h=\xc5\x86\x12\xd0\xbfC\x82"\x0e\xe3\xab\xc1\xbfPD\xa1ggt\xe8?\xa5\xc9#~\x8a>\x00@\x18\x1f]\x89sb\xfe?\x89\x8e\xf2\x0e\xd9#\xea\xbf\x1b\xb5\xf47+\xce\xf1?mi\xad\xbd\xed\xdb\x01@i\xbe\xad\xc7\x8a\x81\xca\xbf\xc7\x01<\x10\x1d\x16\xec?\xe6@j*\xa5d\xe1?\xd6E\xeb\x96\xc1\xab\xe2\xbfN\xe7\x18~\x08\x83\xd0?\xc3\xe0_\xa7,\x1c\xfb?:\xa4\x19:\xfa\xe4\xf4?\x08]b<\x0b\x7f\xee?\x1b\x92\x10]\xcf.\xb1?\x19\xb28\x91<\x87\xdd?\x14\xa5i\xa2\xb30\xce\xbfB\xbe\xd5\x84g\xf1\xe4?A\xce\xcb\xb8\x1bO\xe3?!\xb1\xc7/\x18o\xc3\xbf\xcb\xbd)\xd7\xcf\'\xf1\xbf\xf00E\xe0<\xe7\xe9?\x1btu\x81X\x10\x00@\xf6)\xf8\xea\xba\xdc\xfc\xbf\xeb\xfe(P\xc3\r\xd1\xd5R\xc4\xbf +"\xb2w\xb9\xd7\xbf\x99\xda\xe5\xdbm\x04\xdd\xbf|@\x1d\xcb5\xcd\xfa\xbf\x8a\x81\x92W\x18\x95\xe4\xbf1v\xcb\xa4F\x9c\xed?\xd8\x99\xf7\xbb$\x7f\xf2\xbf\xbe\x97\xee\xc8z\x00\xd2?\xfdY\xd2\x1d\xf3m\xe8\xbf:Z2\xa1\xe2\x89\xda?\xa75\x91}%\xc8\xe5?P\xcb+.Gg\xd1?\x7f\x80*\xfe /\xd5?\x969-\xca*\xf6\xec\xbf\xa6y~\x1f)\xa3\xeb\xbf\xafK\xd6)Y5\xf5?\xb2\xaf+\x10\xa1\x14\xd4?\xf9\xa4\xfb6\x96\x97\xda\xbf\x0c\xbc\xcc\\oS\xe5?\x91V<3\xcd\xfd\xd2?`\xf5W-V\xec\xd7\xbfH6S{Y\xaf\xff\xbf\xb6K\xa2\x07\xc2;\xc2?\xce4\x8a0\xa1\n\xd6\xbfy\x0c\xd8V\xa2"\xd4\xbf\xb7-\xcdP\xbf\x88\xe6?\x83\x1e\xad\xb8E\xa4\xef?\xf9\xff\x97\xf9\xfaT\xeb\xbf>P\xea\x18T\x03\xcb\xbf\xe6\xa7\xa5\xe6\xe0\xba\xff\xbf\x98\xa7X\x9a\xd2\x99\xf8\xbf\xf8\xc5\x1a\xad\x91\x1a\xc4\xbf\x07\xa15\xb3[\xcb\xd8\xbf\x08\x9b+@\xcf~\xf1? \x8d9\x84\xc7w\xe1\xbf\xb8\x1b\xfdo\xc7\xcf\xca?\xe1\x0f/}:\r\xe5\xbf\x10 A\xa4\xca~\xe3?\xe2\xf1z\x87\xb8\x8b\xc0?5U\x0c\xdc\xd8\x91\xcd?Ou\xb8\x83}N\x06@+\x9c6h-\xd4\xf9\xbf\x0f\x1e\xbd\x0e\x9b\x91\xc5\xbf\xcb@\x90\x85R\xbf\xe0\xbf\x19N\xc0\xa4\x03\x14\x95?VU\xd9\x96g\x1f\xd8?\xc63F\xdb\x06\xb1\xf5?\x03\r\xc2\x18\xccs\xf1\xbfr\xf5\x80j\x9c\x1e\xf3\xbf\xdd\xa7f\xd8\xbc\xe8\xe7\xbfBt@\xb6 <\xf2?\x96\xc1\xc1s\xf8u\xf5\xbf\x98\xb3`\xdbh\xa05?;p\xa9\xec\xfe\x98\xe0?\xc4/\x00\x0b\xc7@\xd1\xbf0\'\xc6\x82G[\xfa?\xdd\x08Q\x92\xe1\xe9\xc8\xbf\xa4@\xb3\xca\x11\xd6\xcc?\xd9\xb8\xd7\xb5\xb0\x9e~?\x9d\x97e \xaf\xdf\xdc?Uw\x9c\x95T3\x05\xc0\xb4<\xec\x1f\xa3H\xe3?\xeb\xbf]\xa2\xd6B\xe2\xbf\xf3\x03:f\xe7|\xb6\xbf\xc7u\xd5o\xb3H\xf3?\x17q\xef\xc7\xae\xf7\xda\xbfs\n\x90Be\xbd\xeb\xbf\xc04\xab\x02o\xe2\xdc?&\x8f6\xe4\xe1\x1e\xdc?2\x14\x9f5\xebJ\xfa\xbfr4\xb9_\xa2>\xec\xbf\x0c\xea\xbck\x06\xd6\x02@w1&ry0\xbf?U\x83\x0cr\x7f\xc6\xd8?\xe6\xd7 \xc2\xdd\xf9\xe6\xbf\xa5\xc5\xf5Nqc\xe9\xbfc4\xfc&\x7f\x06\xb4\xbf\xf7\n\xf5\xec\xa3\xb5\xe3\xbf\xea\xf9e_\xd4\xb3\xcb?Rb\xbf\xba\xc7\xcb\xfe?\x16\xd8\xa8J5\xca\xe0\xbfZ\x95\xa4\x00\xca\x9d\xeb\xbf\t\xef\xaa\xc3\xed\x83\xfb?\xb6[/<4/\xe7?9\x1c\xe1\xd50\xe5\xf2?\xe1y\xd14\x11\xe6\xec\xbf\x12\xb2\nN\xc5\xcc\xe5?\xf0\xe3\x85\xa3`\x9d\xe2\xbf\x10w\x0e\xa4\x7f(\xf7\xbf\xe4k\xd0\xab\x00\xee\xc1?9\xae$\xf9\xe50\xf6\xbf\xcc\xc6\x10\x95\x12\xa1\xaa?\xe1\xb1\xc7\xff\xd7\x8f\xef?\xed\xd5\xf5CN\xb8\xc3\xbf\t\xb3\xae\xf3\xc1f\xd8\xbf30mc\x14w\xf9?\x98a\x9fs\xf3\t\xf4\xbf\x8c\xc7\x9b\x12\xfce\xc0\xbf\x90Olq\xde0\xd6?\xf7\xf2\x9c\x16\xc4\x96\xec?\x05/\xaa\xb2t1\xe8?IY\x9cQ\x1d\xb8\xd1\xbf\x8a\x89\xf9\t\xa9\x8d\xd9\xbf#]\xe2\x01\x12\xc8\xde?5\x0f\x8d#\x90\xe3\xb6\xbf\xf8\xa0\xcd@\xaf\x06\xed?[\xf2\x13\xf9\x0ep\xf7?\xe7\x02\xcfQB\x83\x02@?C\t\xaaQ\x93\xfb?x\x91LB\x1a\x83\xd5?\xfb\x99!w\x87F\xda?\xb2\x10i\xdbm\xf9\xf4?\x81\x12\xea\xb7r\x8b\xed\xbf(\xcc\x89\xd6<\x9f\xe2\xbf\xba\xa5l2\xa1\x19\xe5?p\x9bH \xca\x9e\xfb\xbf\xacb\xcb\x11J5\xe2?\xe6\xbe\xd9\x86\x90\xd7\xd8?dX\xc3j\x83\x8f\xe8?\x1dj~`\x9a@\xe2?,\x07"A\x90\xfb\xe3\xbf%\xfeJ\n\x0b\x05\xe3?\x99\xd59\x1f=\xec\xfd?\xb4\x0b\xdf0(\xac\xf8?\xc4\xfa\xd9\xeb\xd0G\xf7?p\xa4\x12U\x80\x7f\xfd?\x82\x8b\x9b\x89)\xf3\xe5?\xa3@\xb1\xa7\xad\xfa\x02@\xd7\xeeO\x85H\x05\xe5\xbf\x8a\xbf\xbb\x19\x13\x99\xda\xbfs\xc48\x8910\xf3\xbf\xf7\xbf\xb8\xe7\x12\x1f\xf2?d\\\xca\x84&\x1c\xe1?n\xae\x19\x02\xa6 \xef?t[\x86b\xe6\x92\x8b?\x8c:{\xc8\x03\x94\xb0?N\xa4\xa7\x8b\xd5\xe7\xed?}UY\xc5S\xe2\xf0?\xdaK\xed\x81\x92n\xf9?\xd7\x8c\xb0\x90\xec\xd2\xcb?W\xfe\xd7UK\xf9\xe1?2\xf6\x1c\xfd\r\xee\xe3\xbf\x9b\xf9\xc7\xe7\xde\x1e\xf6\xbf\x96!\xcc\xad\xf9=\xef?\x03\xfc\xfa4\x89\'\xf3\xbf\xec\xf3\xe9\x93\xb1\xb1\xd9\xbf\xe7\x81r\x9e\x94J\xe4\xbf\xb3,\x9b\xbdT\xfb\xcf?\xcc\x833u,e\xd8?\xd45k\xd5\xa6\xfe\xd6\xbf\x93~\xa2\xadV\xbf\x03@^_t\x18n0\x13\xe4?\xa2j\x06\x92t`\xeb?1\x1b\xe6\x05da\xf7?6+\xb5\x80\xb5\xec\xfe?\x8aw\xd6T\x9e\x8d\xc1?m\xda\xe8\xf4\x9c\x84\xec?\xad_\x19\x18z\x86\xed\xbf\xd8}b\x16\\<\xe0?wl\xa5dv!\xd3\xbf\xc7\x0c\xc9n\xde\xb4\xfc\xbf\xf0\xe0\xb0\xf8\'3\xf9?\x1f\xe7\xaf*\xc7c\xde\xbf\x8cG\x9d\x82 \xf8\xf7?=\xf9\xe3L\x02q\xd3\xbfL\xc9\'~I~\xc9?\x08?\xe4\xae&\x08\xf3?\xdeB\xf5\xf3D \xf0?\x08i.\xf0\x91{\xc7\xbf\xa7\xdbQy\xfe\x0b\xe8?\xb5\x1eZO\x05\xcc\xf6\xbf$J_\xad\xaf1\xe6?\x07\xcf\xc64\xf3)\xf1?\xe8W\xd6\x84H3\xf5?\x89\xe7i\xcf \xd6\xda\xbf4\x16C\xfe\xee\xf2\xe2\xbf\x859$Y\xc7\x9c\xeb?\x0f\xa6\xcc}\x05P\xfc?\xe0\x8d\xa5h\xd1|\x04@b\x84\xac\xb6\x9a\xba\x01@x\x1c\xfc\xc7\x89\xe6\xc9\xbf\xc7)\xa9\x07\xef\x9d\xf5\xbf\xf5NB<\xd8\xf5\xe3\xbf\xf4\xb7\xe3\x8d^\xc8\xf7?f\x1e\xfd\x87\xc3U\xf2\xbf\xed~\xb5\xb6]\x9f\xf6\xbfh\xc0\xfb\x80J,\xe0?\xf1P\x072\xd5\x16\xe1\xbf;\x89\x07\xee\xe9\xff\xb2\xbfoc\xed(\xd6{\x08@80\x94\xdeN\xf0\x01@\xac\x17W\x17\xe3,\xef?\xea\xa6\x90_x:\xea\xbfa\xcc\xaf\xc0\x0bF\x02@\xd7>x\xf7\xa8\x88\xb5\xbf\xef\x01\xff\xd5l\xce\xf7?\xf25\xec< \x0f\x83\xbf\xdb\x99\x1b:\x85\xc3\xc7\xbfu\xdf*{\xbd5\xc5\xbfM\xa4\xed\x8e\xc8\xf0\xee\xbf\x114X\xf1\xc6\xef\xfa\xbf\x1aA\xdfm\xe1F\xec\xbf\xe6)\x97\xa4\x85\x82\xff?\x9c,yw]Y\xbb\xbf\xb5q\xa81\xe2\x89\xe7?\x02\x90\x03ns\xce\xfe?\xa0\xec\xba\xbc\x97\x8c\xf0?n\x9f\xc4s\xcd\x83\x02@-\xa07k\xe2\x89\xfd\xbf\xbf\x89\xeb\x8cfw\xfe\xbf\x1a[G\xadq2\xf2\xbf\xc2\x9b\xad\xdc\xa7\xc2\xe6\xbf\\i\xe4\xec\x85\x11\xe3?\xb6\xc9\xd6\xcd\x836\xfd?\xbfL\xd5\xc5\x1c\xd3\xf3?g\x80\xb3\x00{~\xfb\xbf\xd8^\xab\xa4\x87\xe3\xf8?\x93\x8dh\xdbC \xe3\xbf\xee7\xd1;\xd6%\xd5?.\'\x81\xb0yZ\xed\xbf<\xe9oG\xe2@\xfc?Qw\x1f\xfaw\xb1\xd6?\x9d\'\xb0\xf2\xac\x11\xd8\xbf+\x11 \xa6\xca\xf3\xcf?\xb8\xff\x83~Bd\xf4?k\x80\x03\xab\xb84\xfd?\x04\x9f\xc9}A\x8a\xde?\x1a\x9c\x16\xe3F\xbd\x01\xc0\xb9&\xabm\x12\xb6\x01\xc0\x08\x84*\x9e\xb1\x8b\xf3\xbf`\xfa\x18\xce\xd6V\xe5?3\xa6&\x02p\xe2\xd8\xbf\xbfa\x95!\xb7~\xfb?\x08a\xed-!\x17\xd0\xbf\xc2Mp\x01c\xe0\x03@%,\xd6@hO\x07@C\xdag=\x01\x93\xec?\x84cS\xd7\x1eF\xcf\xbf\x13\xfc\x99\xe1\xb8b\xd4?o\x7f\x08\xd2~~\xed?!\x13\xd1\x14k<\xe0\xbft>(\x98\xb6{\xe4?\xf5\xc3*\x03\xdb\xa3\xe0\xbf\xbba\x14\x19j\x0b\xf8\xbf\xd8O\xfcG2\x8c\xed\xbf9!\xf1\xff\xfc]\x03@\rN\xa6\xd3:\x97\xdb\xbf\x0b\x81\xfc8\xe2|\xc6?\x02\xfcI\xf2\x8a\x15\xe0\xbf\xb8\x1e\x1c\x7f\xc9B\xd2?"\x81o\xa5\x0f\x8b\x06@\xec\xa2\x051\xe1\xc0\xee?\xdd84\xed/\x99\x03@\x1aGv\xee]L\x0b@\xa0\xf0\xdc/\xfc\xab\n@/\x9b\x889M}\xff?A\xeb$\xed]\x15\xd2?\x0eP\x8a?\xd5\x83\xe7?\xb4}$\xe1\xb7f\x92\xbf\x8e\xef\x8c\xc13\xe6\xfc\xbf\x0b\xe4\xea/\x0e\x9d\xf4\xbfV\xfd\xf0\xab\xcfy\xe6\xbf\x89G\x86\xc6\xcc\x85\xe9?1)Y\x93\x1c\x84\x0c@jjQol"\xd7\xbf:\xcfQ}\xcdf\xf6\xbfN=\xdfA\tU\xc5\xbf+\x00\xdc\xec\x1e\x1b\xd3?\xb5\xd7\xe7^\xe5\xba\xc2\xbfn\xe2\xe0\x1cZh\xd6\xbf3\xd8\\\x12\x13\xe6\xf6\xbf;h^_su\xdc?\xe8\xbb\x8co\x06\xba\xd0\xbf\xcd\x93\'\xbc\xbb\xc5\xdf?g\xbe,[\x10\r\xfd?\x18\x13\xb2aqK\xf0?,\xe0\x1d\xd6\xdc\xb0\xf8?\xef\xd3\xf2\x82\x80\xb7\xe5?E\xb4\x1fJU2\xea?\x8e\xd7=\t\xde"\xd4\xbf2-\xf5\xb6\xb8\xf3\xf5?\xa2\x89Xw#\xc4\xed?\xb2\x1a\xb5\x1dF\xf7\x07@\xd1\xe7\xa8\xa46\x07\xed?\x87\x18i\xd3\xa6\xc8\xf8\xbf\xa8\xb1O\xc7wF\xe4\xbf2%>j!\x01\xd0\xbf\x8f\xa0\x98\xd4z\x1a\xd3\xbfsb?\x0e\xb2\x0c\x01\xc0\xb2Y\xde&\xbf\xf0\x04\xc0A\xcd\x0b\x82i\xcf\xf0\xbf\x1b~\x82t\x82G\xb1\xbf\x03\x10\xad\x03]W\xe1\xbf(\xe1L@\xa3\xd8\xf6\xbf)\x9b\x9f\xe3\x1e\x98\xd2\xbf\x83\n\x98\x94\xd1\r\x05@\xe7\x92o\xe9<\xd5\xe3?$=2\xcep>\xbc?\x15\x8b\xda\xa5\x15P\xe7?\x00\x93\xfb>^\xb9\xf9\xbf\xbdh\xe3u\x9e\x83\xea?\x86\xc59\x151\xb4r\xbf\xf2s\x17E\x9d\xad\xf6\xbf\xd7\xf8\x80\xd4\xd8\xcb\xe0?K\xd9OW\xf7\x1f\xfb?v\x8a\xad}\xd5\xfc\x01@\x00\xc6\xd8\r\xe6\x15\xd9?;,\xc8S,\xbc\xe5?\xa5\x06\x96\x039a\xec?edy@C\x9a\x04@q\xcfIL\x9a9\x00@\xcf#\xb8%\xc4\x8b\x00@\xf9\x96\x00vVY\xe4?\x8f^\x8aL\x05>\xd2?3\xc4\x83\x84\xc4\x0b\xee?\x92\xdf-\x92U\xa6\xac\xbf4i\x91\xe7\xd1\xb6\xb4\xbf\xeaq\xa2X\x7f\x8a\x0c\xc0\x89\xe1$D\x97\xaa\xf0\xbf\xdao:\x01\xcc\x82\xdd\xbf\xc82\xeaW\x13\xb7\xf4\xbf\xd7!\x05O|I\xe6?cN\xc9E>\x0e\xfd?1O\xb9\xa9I\xb8\xc4?\x19\xa5W\xf8%\x91\xd9?8L\xf7\x0f\xcaA\xe0?\xcf\x06\x9a\xf7jh\xf4\xbfE\x01\xc2\x00\x8c\x10\x01\xc0\x9cPrzw2\x0b\xc0*\xce\xa4~\xc4\\\x01\xc0wA=\x0c\x0f?\x07\xc0\'\xb1\xd6f6}\xe7?\x05\xa0~\xf2\xf3Q\xf5?\xfe\xd8p\xb2\xd7\x82\xf0\xbf\xd4\n\xd0\xf9d\x19\xc4\xbf\xe1\x02\xb64t\xf8\xc2?\xac\tZAV\xbb\x03@/\xf7\xd0\x7f\xc0\xcc\xfc?e\xc7<\xb9{~\xe8?\xd9(D8ry\x06@\x83\xe6Xb2\xa1\xd0\xbf\xb0\xad\xefF\x90\xa0\xfb?2\x83&3\xe9-\xee\xbfJ\xb0\xd3\xe9\xae\xb0\xcd\xbf\x88\xfb\x9bz\x00\xf9\xe1\xbf\xbc\x00\xfcY~w\xd1?\x93\'E\xf1\xeb\xb2\xdc?R`R|\xcb\x04\xf5\xbf\xe7P3&\xef\xe6\xf2?w l\x19\x8f\xb9\xf2\xbf\x051d\x88\xf0\xa9\x9a?\x83nx\xe0s\x96\xff?ua*\x00\x97T\xcf?\xca\'\xc1\xdf\x8e\x84\xe9\xbf\x7f\xd1_H\x13a\xbb?\x19\xc5Z\xc5\x1a\xc6\xfd\xbfO\x93](p{\x04\xc0\xee\xec\x98\xbd\x013\xf4\xbf\x17\xf1\xd9\xc5\xd46\x05\xc0\x83g\xb8\xbee\x8e\xfb\xbf\x88o\xb6P~\x16\xef?\x98\xbd\xeb\x7f\xf0\xf6\xe1\xbf\xd2?C\xeb3\x97\xf8\xbf\xe5\x06\r\xd8\xf7Z\xf2?\r\x19\xe5$SZ\xef?.\x82\xdf\xbb\x18v\x02@$B\x8a L\xd8\xe3?.\xe9=\xed1\xf4\xfe\xbfO\x9f\xc2n/\x0e\xb4\xbfd\xc0\xee]\xf3;\xd8?UE\xcd\xf3\xaag\xfe\xbf\xb8l\x90\x87\x93h\xe9\xbf\x07<\xd3\xd7\'\x01\xc1?\xe2\x85\xd5\xd2\x16\xbd\xec\xbf\x99Uq>\xeb\xd0\xe4?\xf4\x12<\x7fb\xb3\xc0?\x89\r\x1e.\x8d|\xe3\xbf\xf1\xbc\x92+\xc4\xbe\xe4?\'\x90\xd6]\x88\xef\xa4\xbfn\xad\t\x05Pm\xed\xbf\xe4\x83\x94\xcf\xedq\xcc\xbf\xc7\xfe\x1b\xc3\xa6Y\xdb?\xa79:\xa7\xf0\xa7\xd9?\xb5P%\xcd\xe6G\xf4\xbf@\x1e ~\xacY\xe3\xbf\xf69\xb0&\x8c\xd3\x02\xc0\x11\x89\xa3\xb1\xe4\xf6\xff\xbfe\xec\x1d\xb01\xe2\x07\xc0\x8bj\xd6|@\x13\xd6\xbf\x11\xce\xbeJ\xbe\x15\xb1\xbf\xaf\xdcaW\xed\x84\xfa\xbf\t\xd4\xe9\x88\xd3\xb7\xf1?\xf1\xc6H\xc0\x97\xab\xea?|\x02\xe9g\x10\xb0\xfa?\xc8\xb6hIz\xbd\x01@\xc2\xc8}\xa7\xc6\xe3\x02\xc0\xa2_f$\xd4\x7f\xee\xbf,\x8d\x8c\xe3q\xac\xa2\xbf\x0b\x9e\xb31\xf4I\xd7\xbf\x155\xf8\xe1\xdaj\xf7\xbf\xa6\xc8^\xa2\xe59\xdc?!@[m\x0e\x7f\xf3\xbf\x05\x97\xe5\x1fc\xb5\xe4\xbf\xa0\\\xf9\xd9\x92\xf2\xf3\xbf\x82\x94\xe01\xe3\xc1\xc0\xbf[\x08\xe3\xde\xa3w\xe2?\xafk\xc5\xe7\xbb`\xc9\xbf8\xef\xc7\x86\xb5 \xf9?\x8b\x87bd\xee\x13\xf7?\xec\xba\xfe\xa4\xfe\xac\xc0?\x1e,F\x06r\xcb\xe1?9\x00B\xd1\x0c&\xae\xbf\xb2H\xe7^#\x0c\xaf\xbf\xab;\x06\xa8\x82\xe4\xf1\xbf\x1c3\x014h\xb3\x00\xc0\xb0\x98H?\x89;\xdf\xbf:\xeb\x17\x8b%_\n\xc0\xde$\x8a?3\x87\xfa\xbf\xfb\xda\x12\x8b\xa4\xea\xd2\xbf\xca\xc0\xb0\x12\xe5\xd9\xdd?\x90\xe1\xf4\xef\x17\xaa\xe9?\xfd\xbaYj\x08}\x01\xc0\x99\xb8\xb7\t\xa0\xc8\xf1\xbf\xff4\x02\xc5\xe8)\xea?\xfa80N\x03\x13\xb5\xbf7t\x93\xea)\x93\xea\xbfq\xbfll,\xb1\xf5\xbf)\x18\xce\\b6\x02\xc0\x10|\xc7\xaf\xf1\x7f\xcb\xbfx*\xa1:8\xcc\xe9\xbf2\xc1<\x0cM\xb9\xe3?\xa3\xc8H\xa4\tA\xf9\xbf\x89\x8c\xdf\xb5\xf5\x82\xd7\xbf\x8c\t\xdf\xdd\x844\xc3?\xd8\xbb\xeez\x15\x01\xf1?A\x0c\xdb\x9e\xf7\x81\xea?.\xf0;\xf3\x1f\xf3\xe7?\x82R\x9b\xf7T\xde\x9d\xbf\xfe\x05 \xa9\x80}\xeb?\xf2?\x11\x03\xd8\xa9\xce\x1e\xd8?\x11:\xf8Y\xdbU\xe5\xbf\x8b\xb4\x89t[{\xde?L\x07U\xfb\x01[\xe6\xbf\r\\\x93\xb6*\xa4\xf1\xbf\x0fu\x9c\xa2\xafq\xce\xbf\xc3\x84\xd3^\xf8\x87\xc9\xbf\xbfd\x8b(\xb1>\x03\xc0\x8cN\rVzI\x07\xc0y\x12$\xaa\x981\xbf\xbf\xb5\x86\xce\x17\xaf\xf2\xe9?\x91\xe1\x87e|\x14\xcc\xbf\xb0\xa2\xd5\xa3\xe6z\xba\xbfxb\xdf9:h\xbc?#e\xde\xc4\x84\xc0\xd9\xbf\xb6\xf6\x04\xb9\xb0\x9c\xf9\xbf\xa9s\xe2B\x0c\x96\xef\xbf\x06\t\x0c\x01\x95T\xe0\xbf\xe1\xb5\x93\x83\x96z\xf7\xbf*\xd2X\x87\x03\xc0s?\xef4\xc4\xaf\x15\xc5\xec?f\x0c\xa8\xc2\x11\x03\x96\xbf\xf0\x8c\x96\x16\xf8\xe1\x01\xc0\xb5=\xfa\x08\xa4\xcd\xe5\xbf\xe6\\B<\x0e\x0c\xfd?\x90\xf1@\xa2\x8c`\xf6?V\xc6m\xe2}\xfd\xc7?k\x0c\r\xdbT\xa5\xf9\xbfP\xff"\xe8\x1e\x80\xeb\xbf]n\xc2\x99\xf1\xa2\xc7?\x03\t0i\\\x8a\xac\xbfz\xea\xf1\xa6\x96=\xd4?P \xb8\xfc\x04(J?\x9c\x11\xfb\xf1\xef\xc9\xd3?\r\x97\x86\xa3_\xfa\xee\xbf=E6\xe2\n\x7f\xf7\xbf\x17\xec#\xab\x19\x97\xe5\xbfDK*\xcc\xdfu\xfb\xbf\x96\x99\xfd\xef\xdb\xd4\xf3?\xa6]\x9e:\xe9{\xf9?m\xa8\x95\xd2\x8b\xef\xf0\xbf\xd7\x99\xfa\xa1U\xc2\xde\xbf\x1e\xf9\xd2\x9f\xa5g\xa2?\xc2\xb8.\x8aT\xc6\xec\xbf0\xe1\xd1\xaeB\xcd\xd3?\xb6\x06\xab\x1b"o\xe7\xbf/\x9a\xe2\xcf\x05>\xdc\xbf\x9a\x14\xd7\xa1\xe5+\xfc\xbf\xa2\xc9\xa8\xfc\xdc\xa5\xec\xbf\xea\x0f\x12x^\xb6\xf2\xbf\x82\xf2\xa5\x92V\xe0\xf6?\x97;\x1b\x7f\x01\xaa\xe9?\xb5.X\x83\x1b\x05\xfa?J\xa3\xb2\xce\xc8Y\xe3?\x8a\x8e\xc6\x86ln\xc0\xbf\xcd\xe8\xe6:\x93\x8e\xf1?\x8e\xee\x94\xdf/2\xe1?=0t\xc3#\x00\xd8\xbf\xfe|\x87\x08)J\xde\xbf\x93d\xcb\xdd\xd8\x97\xf9\xbfZ\xe0|\xb5T\x01\xe1\xbf\x9b\xe8\x8a\xe5\xeb*\xe6?`\xba\xef\xa7\x90\xf2\xf0\xbf:\xac/\x05r\x04\xf6\xbfd\x05\xc6Bt\x0c\xd0?\xdbcFXV\x91\xf0\xbf\xff\xed\xac\xe5\xf9n\x89?\x13T\x18V\xb5\x87\xdb\xbf@\x07\xde\x9f\xbb\r_?\x97A\xfb\xc4\x97[\xde\xbfz6\xab\xd5J\r\xe8?\x19\xe7\xef\xd7^.\xd0?\x12\x1b\xe2>\xf5\xc1\xe8?V^u\xca\xa9A\xfd\xbf\x1c=\xc1\x16\x0f\xcc\xcf\xbf\x0c!J\xdd.?\xcd\xbf\xc2]zq`8\x04\xc0S\xc0\x9a\xc8\xb8<\xf5\xbf\xad*f\xde[\x80\xef\xbf\xb4.PG<\x1c\xd0?\xd7\xb1\xf5\xbd\nC\xdf?\x0e\x8e\xf2\x0fK_\xf4\xbf\xe5\x92\x8b\'>s\xf0?\xa5\xca\xd1/Q\x0f\xf0\xbfBq\xe4\x97\xdc\xab\xeb\xbf\xdeS\xc3C\xc0]\xd2\xbf\xa9\x05F\x1c;\x96\xe6\xbf\xdbp\x0f\xf2{1\xb6\xbfT7Uno\xc5\xd8?\xdc\x87\xf3\x80~D\xe0?\xffg\x06\r\x0e\x98\xfa\xbf4\x92\xb6\xe4\xfa\x83\xf0?>M\xdf"ge\xda\xbf\x9d]\x93\x8e\x8d\xd6\xf0\xbf\xb5\x08\x1f\xd4\xfc\x9c\xd8?\xe1\xf2\xc5\xfc\xb9\x91\xec?\x8e\xd8R\x82Z(\xf8?/\x89v\xd4\xf5\xf3\xe1\xbf\x02ch\xc2\xef!\xee?\x04\xb6\x90\x9b\xf4}\xdd\xbfm\xb2\xd2s6\x03\xde?\xb4B\xf3n\xcd\t\x8e\xbf\x80J\xad\x95]\xcf\x01\xc0v\xb9^;\xa9\x9e\xf1\xbf<\xd3\xc48f~\xf4\xbfKf\x04\x1d\xbb\x1b\xd2\xbf4 g\xc1\xb7\xd4\xfd\xbfn\xa3\xb0\xe0/\xf7\xca\xbf\x0f\xc8\xf3\xecU\xd9\xf4\xbf\x1d\xcd\xec/\xf0\xd3\xdd?\xc4B\x17\x03\x12\x1d\xca\xbf\x08,\x12\xf4}\xea\x01\xc0\xc6\xe0\x9c\xcc@\xff\xf4?\xc6p\xe5_\x0c\x17\xe4\xbf\x91\x15\xff\xef\xc5\xf5\xd3?\xe2\x94kP\xc4\xde\xd0\xbf\xde11`\xa3\xbb\xe2?\xbc\xb2Kec\x12\xd2\xbf\x81\x88\xc1\xce\xf1\x02\xeb\xbf\xb9\xa9\x1f\xac9>\xdf\xbf\xe6v@\xab\xf8\x85\xf5?\xbd\xb9\x11\xda\xd5;\xe4\xbf\x010\xf0\x08\xee\xb4\xee\xbfq\xd4VC\x977\xb2\xbf\x8c"\x12\x8evW\xe8?\xaf\x15\x16\xc6\x87\x00\xb5\xbf\xd4E\xa5E\xd3;\xde\xbf\\$\xf3\x01\x1f\xaa\xf4?2m\xb4\xee\xd7\x01\xe5?\xfe:\xe8\xa4]s\xfc?\xe3K\x10\x883e\xd3\xbfD\xe3z\xc1T\xc4\xeb?"\xd4\xed\x8e\x95\xe0\xc3?\x14:\x80\xe7~y\xf4\xbf\xd2\xb1S\x88\xf0\x80\xdb\xbf8\x1c\xc7f\xed\x90\xe7?1\x96r\xd0\xf8*\xeb?\xa3\x8b\xb5\xaf\xb25\xeb\xbf\x9d\x1es5\x15\x0f\xd4\xbf\x0bJ\xc3r\x7fc\xf4\xbf\xdb\xf5\xf7\xe3M\xea\xf5\xbf\xa9k\x08\x120{\xf2?&\xa3\xb3\x17\xbf\xbc\xc8\xbfH&GS\xd7\xf2\x9e\xbf\xe5\xe1\x98\x85\xb2\xf3\xe7?\rX\xd7\xa6\x14\xe9\xe4?\xf5\xa4\x1d\xb10(\xe4?\xf8x\xd5Z{|\xf4?\x8e.(\xf2\xd3@\xe1\xbf\n\x08\x8e\xfb~\xcd\xf2\xbf\x91>\xbf\x92\xaa\xfa\xe8?\x85E\xb8\xe2~\x04\xf2? i|\x0b\xaf\xa0\xd9\xbf\x8c\x8a\xcc\xf7\xf14\xc3\xbfy\xd2\xabR\x8c\xe3\xfa?/\xee\xac\x99\xab\xc1\xe5?\xcf\xcd\x860Y\xc8\xe3\xbf\x9bd\x01k4\xe7\xca\xbf\x8c\x04\x06\x19\xa6P\xd3?\xfc\xb7\xfd\x1e\xe2\xad\xcc\xbfr)\x15\xcf\xa0\xcc\xd9?\xf0"\xf5\xb6|\xa8\xe1?\xf47\xb4\x9eza\xe9\xbfc\xf7\xde\xb2c/\xd6?\xd25!x\xf2\x83\xf7?\x1c\xd8l\xd0j\x07\xf2\xbf\xd37c\x9a\x06\xda\xce\xbf4]#b\xc5\xa4\xf6?<\xd4\xac8\xd1s\xfe\xbfO\xc0\xd7\x06\x95\x9a\xda\xbf\x07\xe0\x9a\r\xe7?\xf8?/\x02O\x87\xd7W\xe9\xbf\xeci\xda]\xcd\xe6\xd1\xbf\xa6Q\x18\x18\x871\x04@\xb5sy,4\xac\xd7?\x07\'d9\x8d\xa5\x02@o1\xeax\rD\x04@\xde\xe7\xbaj]\x19\xf7?\x98\x87\xae\x94w.\x05@\xeb\x8e\xab\xec\xf4V\xec\xbf\x85\xf9\xf1C`<\xf7?\x9e>2\xb8\xfb!\xf5?iw\xe1p\xc4\xc0\xf9?@\xf0jk\xb2\xbb\xe7?\x0cE\xc1\xca&\xf9\xe8\xbf\x1e\x93\xcc\x83H\xa6\xb7\xbf;\x8aS&a\xba\xf6\xbf\xe0\x10\x7f\xb3\x06\xfb\xeb\xbf\xfa9\x02\xef\xed\xba\xea\xbfRLyM\x19\x08\xe0?2\xd5\x8d\x80\xaaE\xdd?\xff\n\x92\xff]5\xef?mH"e\x96\xa7\xc8?\xe1\x1b\xcfY\xc6\xb9\x04\xc0\xfd\xa3&&0\x1a\xcc\xbf\xab\xf3H\xce[\x03\x02@\xd2-Z\xb1\x08\xa2\xf4?\x078\xc3;\xb5\xba\xf8\xbf\xe5u=\xf4W\x85\xf4\xbfO.\x12\x80U&\xeb?C\x022\xb4\xa0\xa2\xe2?\xc3\xa6\xb2/\\\x14\xe8\xbf\td\xac\xc7\xd9=\xcf?%T,\xe8\x8d\xda\xfc?-\xab\xbe21\xbf\xdb\xbfa\x86\xe2N\x0b\xc1\x02\xc0kX&\xee\x10\x1c\xf0?\xca\xf3z/2\xe8\xeb\xbf\xf9\x8f\xe4X\xea@\xe9?\xc5\xe5\x07\xa2aH\xe3\xbfl\x12\t\x897\x92\xe0?\xeaM\xe8\x9a\xdb\x92\x02@L!\x9cD\xa2h\xe6?,0g\x83\xcf]\xf9\xbf\xb7\x82^\xc1\xce\xca\xce?{\x8c/(\\\xc2\xe0\xbf\xef\'\x14\\r\x8d\xf5?\xcfav\xa9.\x15\xe4?\x85\xbax\xb5\x1a\t\xfb?\xb6\x18\xd6\xa5\x9a\xb9\xbf\xe4\xe9\'I\xa9\r\x89\xbfF&\x9f\x8d\xdb2\xea\xbf\x8a\x85\xf8\xbb\xbb)\xd1?F:\xc2\xd9\x86_\xf0?\xc0y\xd6C\x89\xea\xf8?\xdf\xbeU\x91hV\xce\xbf\x1cb\x93\xd2\x92\xc4\xe8?\x9c\xac\xdc\xef\xb3$\x97?\xaa38\x83\xc0\x12\xf4\xbf\x9e3@\x8at\x13\xe3?\xcd\xdf3f\xb5\xe9\xf8\xbf\xf4\x0e\x9a\xfa\xadO\xd8\xbf\xf7\xc5\xcb\xf2\xa5\xf6\xed?\x91$\xf3\\\xf4\xcd\xf1\xbf\n\xda\x00<\x8f\r\xfa?4\xd0H\x1a\x8d\x12\xf3?\xf2Sz\xe7\xfe\x85\xf4\xbf\xe4\xb3\nq\xb0"\xd6\xbf\xe7m\xdb7\x1e\xe6\x00@c\x8e\x08\xc2:8\xca?\xa1k\x03]\xebY\xef\xbf5\xbeMD\x1c\x9f\xfc\xbf\xf0+\xb4\xda^\xf8\xe0\xbf\x85q\x8d\xe0\x0e\x81\xf4?\xb6:\x19dNm\xf6?&\x13\xf8\xfb\xaf\xa8\xf5?\x92\x81W1\xf2\xb5\xd5\xbf\x86B\xfb\x99=n\xf3\xbf\x8bK\t\xbd5\xf2\xb8?J*\xa7\xd1\xc6\x1f\xdb?\xc8^e\x9f\xbd7\xf0?G\xb91\xb4\xb3\xe7\xdc\xbfc\xcc\xee>\x14I\xf1\xbf\x99\x13\xb77\x83T\xe0\xbf\xa6M\xab\x96b\xf3\x04@v\xb4\x93\x92p~\xf1\xbfXY\x96\xde$H\xf3?\x01\xdfl\x9a\x0f$\xf6\xbfm\x00\x04\xe9O4\xff\xbf\x1c\xc3\x9c\xfb\x84\xc5\xf9?\xd0|\x9c\xf2^A\xe8?E^\xe3\xe8i\xfd\x93?g\x9ez\x13\xe1h\xbb?2\xa5x}\x8e\xa4\xdb?\xd7$\xff\x06\xbal\xec\xbfU\xff_\x95\x12\xf4\xe6?\x14\x03\xa2\xc5\x19\x95\xe8?\x0f\x92\xb5\xf8\xe6\xdb\xa9?\x14`\xf4\x02k\x13\xe1\xbf\xc5\xa0\\,\x1a\xe3\xb2?\x17z\xec\xdb\xc4\xfe\xe4\xbf\xe8Z\xed\x8bl3\xe0\xbfB\x7f\xd3l\xad9\xfa?\xa4\xe5\x00,\x1f\x10\xf1?2\xae\r\xf5}\x9d\xe5?\xcaJ\x96\x01\xbfz\xbf?\xbe\xc4\xc57\xd5\xc6\xe8\xbf|z\x81\xa0\xd4\x92\xe8\xbf\xd2\xdd\x91\xeb\xc2\xe3\xd5?\xaa0\x04\x1a\x0b\xe6\xfb?A`\xec<\xc7O\xf5?\x11\xa0\xb2x\x89\x80\xdb?}(\x96y\xfc\xd3\xe1?0\xad\'@\xed\xe4\xe1?\x05\xb5\x11\xa2K\xb5\xb4?A\x1f\x1b\x84\xb1w\xf2\xbf\xe0\xfdUE\xc0\xdd\xdb?-\x15\x86u\xd5\xe1\xc8\xbf\xd1\xffe\xa3\x97\x7f\xe0?x\xe1 \xec\xd8\xec\xd4?\xe9\xb4\x01M\x83\xc6\xda\xbf\xb9hB\xd6\xcb\x94\xc3?\x84\xe7\xcc|\xc9\xaa\xda\xbf\xf3\xf7\xa1;\x8d2\xf7\xbf\xd4z\xd8\xdc\xf6U\xd5?\x00\xa6z?\xeb\x0b\xf0\xbf\xd0&\xbd\x8c\xad\x13\xe3?\x9d\x18\xe9B%-\xf6?\xc6\xa5S\x13\xf9\xa3\xf1\xbf\xfc\x16\x99K\xeal\xe1?\xd6\x95 \xa8\xa8\x8c\xc6\xbf\xb9\xcf\xff0SA\xe5\xbfBKh\x86:\xbf\xcc\xbf&V\xe9Y\xb7q\xf3?\x10SNf\xfd\x14\xf1?\xdd\xe6k\xc7\xc0\x1c\x01@cji3\x86s\xe3?\x19":B\xc3\x1d\xab?\xfeM\xf4\x00f\t\xe5?\xb4H\x81j=\xcc\xfe?\xd2\xcb\xa7\xae\x04\x1e\xf8\xbf\x92\xca\x000\x92D\xd4\xbf\xdbQD\x80[\xb9\xd1\xbfT\xae\xcci\x1e,\x94?z1\x812\xb5I\xf0\xbf\xa0O\xb6\'V\x9b\xe1\xbf%A\xd1\x9f\x9f\xcc\xe3?\xa8R\t\xb6g\xec\'\xbfiJ \x87}\x90\xe7\xbf\xc4\x95\x1c\x15pc\xb4\xbfr\xcb\xefo\x85\x92\xfb?4\xaa\xcf]78\xf8\xbf\xb3l\xf1\r\xb1@\xf0?B\xfd\x04\xc3K\xc4\xf0\xbfIq\xff\x905=\xec?\x11\xd26\xd3\xbb\xf6\xd2?\x9f\xb3\xaf]\xddJ\xf9?\xa1\'4\xc99F\xe6\xbf\x10"\xb2.\xa3\xc5\xe5?y\x98\x87\xa2jC\xdb\xbf\xc05s\x1f\t\xea\xf4?\xec\xa0\xd3#\xd8\xcc\xe0?\xec$c\xe440\xe2\xbf\xeeO\xe6xf\xa6\xfa?E\n\x1d\x83\xbb\xeb\xb8?O\x92j\xa6i4\xfd?\x14\x8b\x01\xca_N\xb5?\xec\x11xx\xe3<\xe0\xbf\x9e\x12J\xca\x1e\xbc\xe4\xbf\xa1\x9cwO\xb7\xe1\xec\xbf\xb7%\xd0\xb5\x9c#\xe7?\xeb\x87\xcfro(\xa0?\x1f9\xb5\xc8\x11k\xe6?1\xd6\xf7\x00\x18\x9a\xe1?\xb75\xf2\x93=\xbb\xe9?\x9fz\xe9\xa1\x17\xc3\xa3?\x1f~\xa1RK\x1d\xe3?\xc4\x07\x92d\xbe\x07\xb0\xbf\x18k\x82\xe5\xbd*\xf6\xbfy*N\xd6`i\x01\xc0\xf0_\x97\xc3\x97\xab\xc0\xbf5\xd13V\x98K\xe9?s\xa0\x031\xdf\xa0\xf2?!%\xe4\xefG;\xdd\xbf\xc2\xefz\x9fJ\x1d\xc8?_m\x92s\xb5\x0f\xe4?\xc1(\xd3\xe1\t\x01\xf0?\xf4\x898\x88nj\xe4?0Yx}\xd7\x87\xcf\xbf\xa2\x9f\xdfM\xca[\xe7?\xe2\t\'\x02\x07\xf9\xe1?\x83\xc9\xe1\xc4\x84\xf9\xee\xbfx# \xddMH\xd7?B\x02\xcf\x1b3q\xf3\xbf\xb01\x9a\x01$\xa2\xe1?\xe3\xb2\x8d3\xe2\xa1\xd4\xbfx\xae\xcf8^#\xf8\xbf\xd6\x8b\x1e\x18wt\xd9?\xab\x16I\\\xfd\x1d\xe2?\xe2\xd5\x1a\xdf;{\xeb\xbfzC\x0e5V\x84\xf6\xbf\xd2\x91D\xabz=\xb3?\x03\xbd\x7f\xd8\x11Z\xb8?\xdc\xceKt?\xe6\xf8?\x0b\xbe-h-|\xd6?\x05\x8c\xa6\x92\xed\xa0\xb0?\xc1l\x05\x07\x04)\xf8\xbf\x00\xcc\xd33~\x82\xf6?mb\xd6 \x95I\xe5\xbf\x89\xda\xbb\xf4\x9a\xff\xe1\xbf\xe4\x81\xdal\xa8\x15\x99?\xde\xe6\xada\x12\'\xeb\xbfn\xe2\xa7\xec\xe6\x0f\xe5?\xaa\xcf\x90\x06*\x02\xec?\x96\xe1\xc8\x0b\'\xed\xd1\xbf\xfd|\xd8$\x9a\x18\xc5\xbfV\xe8\x1e~!\x04\xeb\xbf\t\x11\xe0\xf1+\x02\xe4?^\xfe\xbc\xb38\x7f\xf4\xbfZ4\xf7<8\x19\xe7\xbf\xa0\xc6\x89\x87\xfa\xea\xfd\xbf"B\xf55/\xc7\xe6\xbf\xcc\xe3LB\x07\x86\xf4?R;\x88\x07\xae^\xe6\xbf\xbfH\xb6\x11^\xb2\xe8?\xe2\xafDL\x8f8\xf6\xbf\xa6\xbd\xeb\x9c\x19\x18\xbc\xbf)\x97)y\x9d\xed\xcd\xbf\xacz\xb8\xc9\x9c\xc8\xf7?to8/\xb1\x08\xed\xbf02\x96\x9e\x93\xee\xcc\xbf\x04\x06\xa5\x9b\xf6\xcb\xe4?\xca\x9a\x8cRC%\xc4\xbf\x90\xf2\x02\x97\xab\x8e\xe5\xbf0\\k\x8b.r\x03@;H\x89\x15\x04\xc6\xce?\x8a\xb7\xe8\\\xce\x93\xec\xbf\xc3_\xdenj\x9d\xd0\xbfa\xf2\xafTP\x05\xc5?\xe1\x1f\x8c\xae\xbf\x92\xf2?\xecL\xb8e\x84]\xf6?\x90\x19\xf6Ag/\xf4?\xd32\xb5\xb5\\\xcb\xdd?ET\xd0\x9c\xe0\xd1\xd6?\x1d\xa8\xda\xcbj\xfc\xf0?\xaf\x9d\x9b\x852\xe3\xee\xbf\xa9\xae\xdf\x99\x02\x0b\xd1\xbf\x91\xf5\xd0[_\x19\xf1\xbf\r\x87Kk\xb3A\xdb?\xde\xe1\x85\xb9O[\xf0?Ie\x9f\'\xeb\xdb\xea\xbf\xaa\xab\xc9\xadLe\xfb\xbf\xd1>\xa8\x06Ak\xec\xbf\x11\xa9B\xeb%\x81\xd7\xbf\xa2\xc5\xe7\x133a\xe8\xbf\x93\xff\xf2\x19\xb2n\xb4?V\xac\xdf\xc1\xf4\xea\xe9\xbft\x83\x88\x83\xac\x19\xf7\xbfa\xfa[}\xbe\x91\xfc\xbf\t\xcb\x02\x03E;\xd8?q\x10\xd4&\x16V\xab\xbf\x1b\xd4\xf3\xd5\xa8Q\xff\xbf\x97\x05\xf3\x80\xf6b\xe1\xbf*]\x8f\\$\xb0\xf3?\x82VJ\x7fC2\xe6\xbf\x97D[[\xd2u\x03\xc0I\xe7j\x8c\xc3\xe5\xa9?h)Q?\'Q\xe6\xbf\x86A\xb1\x12\x04\x82\xa0\xbf\xd1E$\x96\x8eF\xf2?\x8f\xc7\xa4Z\xfc\xed\xea?\x8b\x04S\xcd\xc4I\xd7?\xda\xb5\x0b\x97 \x00\xc2\xbfd\x8biJ\xb4C\xc4?\xafl\xb4r\xfeM\xfb?G\xe1\x1fo[[\xd7\xbf^is\xe4\x9c\xc3\xdd\xbf\xc2\\+\xeb\x12W\xf9\xbf\xa0B71\xd2\xd5\xe4\xbf \xbb\x1a\xaa\x80\x93\xea\xbf\xfa\xe0\xcb\x00\xad\x8b\xf0?\x12\x91\xec\xc3\x8e\xad\xe0\xbf\xceo\xd4\xf0\x92\xd2\xfa\xbf\xe7\xb6w\x90\xde\xe3\xf0?\xa6\x84p\xa6\xf62\xdc?\xb7\x8a}l\xf0[\xb1\xbf@\x15\xda\xf0V\xdc\xd4\xbf\xff\xd8\xba\xc1\xea\x11\xf8\xbf\x1eR\x90[\xe8\xa3\xd4\xbf3\x10o\xfdv\x83\xab\xbf\x02\xa5\xae\x0c\xf6\xbd\xbd?\x03f\xfex\xd4\xf9\xed\xbf\x0b\xa4\xed\xc2O\xf8\xcf?\x10\xd4\x99\x8e\xdd\xcb\xec?\x9eT*\x10\\)\xef?m\n\xa3\x91V\x9b\xa9?d\xdf/{*;\x06@0\xc5\x8f\xc4\xf6T\xee?\t\x93\x01\xfam\x88\xe8?]\xf7\x0ch\xbf\xb7\xe0?\xe1\x0c\x90Ts\xb2\xf4?_PD3$\xf6\x01\xc0\x01\xca\xf9\xa2\x94\x82\xf6\xbf\xf6\xca\x98`\x1a\xf7\xf2\xbfQ\xcd\xa3|*\x81\xfb\xbfX,G\xc0e\xbe\x01\xc0?\xfan\x03\xca\xe1\xcb?\xea\x82\x97\x1eL3\xf1\xbf\x9f]\x98C]\xb0\xe1\xbfm\xf7O\x97\x93\xee\xef?\ty\x93\xbbP\xd2\xfe?\xbd.;\xec2P\xfd\xbfr\x84|\xfc4\x13\xd8?\x07\x8d\x8d\x10\x7f\xfa\xe3?\'\xf8\xf8\x97\xa5\x8c\xd8\xbf\x02N:\xdb\xd2?\x08@\xc8\xd3a\x9b\xa6\xfd\xf6?\x04n\xf4g\x8d\xa6\xfe?_a\x9d{\xd7\x9d\xd7\xbfK\xa5\x83=G\xf0\xe0\xbf\xe6\xe2Er\x98\xcd\xeb?>TS\'#\x9a\xbd?\x84\xb9@J\x8cn\xa0?\xdf\xfc\xad\xd1\x90\x8e\xe0?!iW\xaaA\x11\xc5\xbf\xf9\xb3ET\x02t\x00@\xb8\x1b\xdbI\xc2}\xff?_\xcaK\xe4P\x18\x02@\x0f\xe6\xf5\x05:G\x02@\xce\x1c\x91\xf2\xff\xe7?Kma~\xc8v\xf7?\x82\x07\xb6\xe0\x81P\xe8\xbf\x16\xc6\\\x1cC\r\xf5\xbf\x03\xea\xb3\x11$\xb6\xf0?\x01hM\x8e\x00\'\xfd\xbfo+\x05$m\xb9\xcd?\x9a\xdb<*\x9e)\xea\xbf.\xa5\xf2\xb9qw\xf1\xbf\x0b\x1a)P\t\x1a\xe0\xbf*\x98\x024\xcc\x83\xde\xbfP\x00M\x8fV\x9d\xc9?8#\xe1}(7\xd6?,\x81ql\xfb\t\xf1\xbfd\\_nj\x0b\xd3?\x8b7N\x81\x07\xe0\xc3\xbf\x03\x9d\xa4\x99l\xec\xee\xbfa\x9d\xdfS\xee\xf4\xf2?\x8f?\t\xa0\x80%\xf9?\xf3\x14\x99}\xe7\x8d\xf4\xbf\xde\x07\xde<\xdf*\xfb\xbf\x12\xfb\xdd\xb4\xa7\x05\xe7\xbfUPb\xd6\xc2\xea\xcd\xbf\x99\xa8HphM\xec?r48\x05\xe5\x1c\xf4?\xecb\xa4\xc5\x10\xf9\xe0?\xb6RW\xe0\xb8\xd5\xf0?`\xe8\x16\xae)A\x9e\xbfqj\xdco:\xbd\xea?\xf9\x0e.H\xce#\xf5?\x14\xeby\x16U\xea\xf9?\xa2\xd4\x97.UY\xd2\xbf\xf1\xe3\xb9\xaf\xf7B\xbe?\xcdQ\x8b\x08\x00Q\xe4\xbf\xed\xc2&\xa4:\xa6\xed?\xb3\xcbA\x141\x14\xef\xbf\xd5\x8b\xfc\xa8\x83\x03\xe4\xbf\xdee\xf1\xba\x90\r\x03@\x04og\xbam\t\xf2?\xa9\xf6?a\xbc\x1b\xf6?s\xd3\x9b\x0e\xcf*\xf2?\xf8^x\xa9n\x02\xf5?$\xb6b\xc80M\xfb?~ocM\xc9\x08\xf3?\xdfa\x1f\x0fqf\xe8?\xe3\xb1\x81\xf9\xf3:\x08@o\xe7\xc9*\xc86\xe5?\x8b>K\xf6O\x87\xf5\xbf\x82\x89v\x03E\xe7\xff\xbf\xdf\x92\x92K\x8e9\x01\xc0&\x03\xdf9hI\xe7\xbf\xd6\xa0O\x96U\xc1\xd2?\xd8\x90\xa0\xbc\x13=\xf5?\xf6\x0eG\xdf*\x02\xf6\xbf\xf5\xf7\xef\xc0\xfat\xe3?\xb4O\x08L_L\xd9\xbf>)\xb9\x8b\xcf\xa5\xb9?\x05\xc3/\x08?3\xf6\xbfp\x99\x90\x8c\x9a\x95\x05@\x8b\xc7\x95j\xc0A\xfa?h\xf2hpT\xb8\xb7\xbf\x9aI\x1d\xdbF\x18\xe7\xbf\xaaWo\xc5#M\xdd?\xca\xf5\x91\x1b\x00\x08\xd3\xbfL+^z\xf6V\xec?_f\x17\xd7x\x1d\xe7?\xe7\xde\xd1\x8b9{\xee\xbf\xb4\x01\xbdP\x0e\x16\xef\xbf~\x18LV\'\xf1\xe7\xbfx\xf1\xe0J\xa8m\xe7?<\xfcw\xffk\xf9\xc9?KW\x9d#\x88l\x01@6\xbd\n5\xd37\xfb?9\xbf\xc4YB\xa8\xfa?S\x7f\xee\x85\xfb-\xe4?\x9cY\x95\xbb\xfd\xc1\xee\xbf2\x7f\xb9\xbaj\xd9\x06\xc0\nKl\x8e=\xb0\xf8\xbf_w#\xc9\xb0\r\xf4\xbf\xd0\xdc\xc4\x0c\xd6\x1a\xe2\xbf\xb1\x13rp\xe1\xcd\xe9\xbf\xc1dS\xd5\xf0\xdc\xbe\xbf\xeb\x10\xf7\x0f#\xba\xe0?\x9av\x03\x1e!\x82\x8c\xbf\xd1\xb2\x1cJ\xff\x07\xb4\xbf|\xb4\x8f\xdf-\x9c\x83\xe9\xbf\x00\x1b\xa7t\x17\xd2\xff\xbf\x80&E\x9e\xc8]\x06@\xe0\x1dhu?w\xb2?vET\xd4\xc7\xc8\xf9\xbf\xf3Sb\x89\x0c0\xe7\xbf\xff\xabEC\x87\x89\xa7?\xdbK\xc1\xcdE\xda\xf9?\xefw?\x1d\xcc\xe2\xf2?\xf9\xfc\x1f\x80m\xdb\xd4\xbf\xdb"hH<\x1f\xe1\xbf\xc0\xd0\xfd\xe5\xfca\xf6?\xc4\xfb\xa5S\xfe\xa2\x02\xc0r\xa6J\xa7qd\xe5\xbf}^l\x00\x08X\xeb?\x84B\xd7;\x1f\x95\xb7?\t\xa5\r\x80\x83\x0c\xc8\xbf\xbc\x99\xdc\x9b\xad\xff\xbb?\x1f,\x06\xefbf\xcd?\xce\xf2\x90\x7f\xdd\xa0\xe1?\x08 \x9b.\xe6\x08\xfa?8d\x84\xc3\x15\xbb\xf1?\xf3\x9f\x8dE\x84\xe7\xa8?`A[\xb2j\xa8\xe1\xbf2\x81b\xd7\xbe\xc6\xff\xbfZ\x8c\xf2>g\n\xdb?\xbe\xda\xbfs\x94\xec\x01\xc0>\xf2\xa9\xbf\xe9A\xd3\xbf:\xc5j3\xd7e\xf9\xbf\xad\xbck\xd9\xf5&\xf4\xbf4\x00L\\\x8c\xd6\xe6?\xc9\xd3|\x1c\xa7\x19\xe1\xbf\x8a\xd1pUY\\\xc3?l~\x98\x16UD\xdc? mN\xfd\x99\xa4\xf2?\xd8\xd5\xd1.dN\xfc?%\xa7ij\x8aR\xdf?\xc3\x91\x16\xde\xdc\\f\xbf\xbb\\\x02\tx\xfc\xf5\xbf:T\xd8t\xb1\xb6\xe6\xbf{H~\xefF\x0f\xe1\xbf\x14Q\x99\xa9k}\xea\xbf\x82=u<\xc1\'\xa7?\x18\x83EF\xcej\xea\xbf\x8f_7N0\x12\xd8\xbf\x903Z*\xbd\xec\xd1?K\xc4\xf7\x92\xe3\xab\xbd\xbf\xbbU\x00\x1dK\x11\x04@\xd4AQ\x8e\x0f]\xf7?O\x06\xa2\xbb\xad\xb6\xed?T-\xec\x8a\xb4\x17\x00@\x07\x99\xaaj\xddI\xe0?|\xb4j:9\x8c\x00\xc0}\x81\xca\t\xd3m\xea\xbf\x04\tp\x1c\xd1\xc2\xfd\xbf\xa6\xcb\xd1\xea\xd2\xb9\xd6\xbf*h\xba\x11\xd3q\xdb?\xb6\xaf@\x08\n\x89\xfa\xbfK\x0e\x15\x04\xb4\x85\xea\xbf\xa0#\xbe\x16\xc5\xf8\xf2\xbfO\xa2g\x8bq\x1e\xd3\xbfW\x9cK\xfe\x87P\xc0?\x9dR\xf3\xc4\x19k\xfa?\xb4X\x84\xe7\x1d\xb0\xb6?\xba\x0cv1=\xd8\xee?\xbbA\xd5b\x94\xcf\xf7\xbfn)\x08R\xf7\xf7\xc8\xbf%\xf3\xd0\x0e\x82^\xe6\xbf\xcb\x8dz2?d\xf1\xbf\x91\xa7\x16\xe2\xb0\xe9\xb0?`\x88\xd5\xae\xf2_\xfa\xbf\x8chl\x0b\xf4T\xda\xbfB\xd3W;\x18\xbb\xf5\xbf\xa3\\%\x10\xb1?\xe2\xbfD\x8b9\xd2I\xcf\xc4\xbfM \xf6S\xb0T\xd8\xbf}\xd6_\xc1\\\x1d\xe6\xbf\x8b\xfdK\xc2\x12/\xed?\xf4\xa8h\x8a\xe9\xbd\xe7?{\xa0\xe4\xf2\x01\xfd\xb1\xbfn\xa6\x84\r]\xae\xca\xbf\xd4A\x96\xe5\x0e\xc2\xe0?\x7f\xc3"\xce]\xc7\x00\xc0\xb8U\xf2\xe5W!\xec\xbf\xcb9J\x18\xc5\x1b\xfc\xbf=,\x9ex*\xaa\xdc?\x87\xba\x8c\xfa\xab\xec\xbc?+\x92\xacEG\x9f\xaa\xbf\xb0\xf5e/\xd7\x16\xee? \xa5e,\xa0\xfe\xdc\xbf\x82*\xf9\xa38\x9e\xc8?\xe5\xe3)\xa3j\xc8\xf4?\xb3\x8fu\xf1s\xc9\xd7?\xbaM\xa1\xb1+\xd2\xe7\xbf\x08\xf9\x06\xdbw<\xe7\xbf\xf2j\xa7 \xdcM\xeb?\xd6r\x9f\xc9\xf27\x91\xbf\xe1\x85\xaa\xdb\x9fD\xd3\xbf\xd9\xf7\x05\xcf\x02\xb6\xf8?\n}\x04B=t\xf6?S\xff\xea\xd8\xbb\x99\xd3?ao\xf7\xd4\xf4G\xef\xbf\xfd\xd3e\xe7my\xc2?\xf0~K3\xdd\xc7\xec?u#X\xb1\x93\x02\xfa\xbf\x8d\xb7?|\xd4<\xe6?,\xb4y\x08\xfd\x8c\xf4?\x9dTY\xaf\xfd\x01\xff?j\'\x9d#\x00m\xf8?V\x9b\x0e\x13V\xa7\xd9?\xf7=\x1aS\xd5\x1f\xf0\xbf>\x9a\x15\xd4\x1es\xc4?\xd0\xf3:\xd4\x903\xf1\xbf4\xbd\x06\x04\x0c{\xf9?\x9b\xa2&:\xbb\x1a\xf7\xbf\x89\x07AT\xf5\x85\xe1?\xef\xf4@\xadl#\xf3?\xb5\xe3\x11\x1c\xe2#\x06@6\xc9\xb2\x1eD\x13\xda?\xf7\x8f\xbd\xbf\xb0\x84\xf8\xbfu\x10=\x89\x97\xf6\xf0\xbf\x94\xdb\xb9\xd7h\xdd\xce?\x9fP!\xd7@\xbe\xae\xbfE\xdc\xcbu\x05d\xd0?\x9a\xfd\xd5\xa5\xbf\xa9\xef\xbfh\x7fSC\x9e\xa5\xef\xbf0Nk\xdb&B\xf3\xbf\x10\x83\xbc\x8b\xf7\x8c\xf3?C\xa2\x15ly\xc4\xea\xbf\xf4\x82G\xb8\x96l\xd3?\xb4\x0c\x8d\x9f\xb0\xa9\xfa\xbflf\x8f\xd3\x96S\xf9\xbf\xa5\x07\xed\x83Up\xd4?I\xb8\n\xa8\r\x88\xf2\xbfg\xf2\xf7\x97\xbe\xdb\xe6?}\x13\xe5G\x03\xbf\xf9\xbfI\xdf2Va\x99\xf7?~\xd7]\xc4\x00 \xdd\xbf\xb8\xb5l\xce\x87W\x06\xc0\xad\x8b\x9c\xc9*\x90\xd5\xbfGRbZYi\xed\xbfO@\xb8\xf4\r\xa4\xb5\xbf\xcc\xe2\xeb\xec\xb6\x8e\xd9\xbf\x98\x16\x82\x80C\x13\xeb\xbf\xd0/\xd5\xb4O\xe4\xe1\xbf\x10\x9e\x94C%.\xee?\xae@|\xcd\xc1\xa5\xf3\xbf\xa6\x0f\xa3@\xb4H\xcf\xbf\xca\x8cm4\xf1E\xcf?\x9fv\x0f\x03EF\xd8\xbfZ\xab\xf4`\x00\xc9\xe7\xbf\xd75\xb3\xd0\xd2\xb2\xef?\xbb\x19\x93\x8f\x84\x06\xe8\xbfF\xe0\xaa\xd7~<\xe2\xbf\xb2\x82z\xc4\xe4 \xce?\xd7\x8b\x8cOp\x10\xf1?Z\x9b\x90T\xa4\x05\xcb?;j\xf5\x97\xa5\x06\xda\xbf\x15\xe4\x8a\x81g\x08\xe7?^\xaf\x95:T\xda\xd4?g_"C\xdf\xf6\xc2?\x0fB;W\xdb\x8a\xf4\xbf\x18A \xbcC\n\xd8?\x84\x9d\xee\xf0\'\x06\xf2\xbfn\xe9)\xbb\x13\x1d\xdd\xbf\xbbj\xf9\x919\xec\xe5\xbfh\xba\x15\x90\xabz\x02\xc0R\x9f\xcb2\r\x0c\xf0?\x00\x93\xff\xfb5\xb1\xff?\xb2\x00 \xef\x04\xa5\xf9?\x86\xfb\xd3 7\x0b\xe5\xbf\xb5RJ^\x0b\xa9\xfc\xbf\xb0I-\x13\x93g\xc1\xbf\xf3\xad/\tb\xb3\xb1\xbf\x7f\xca\x9b\x80B\xf8\xee\xbfpf\xf0j2\x84\xe3?Z\xf5o>9u\xc9\xbft\xe0\xba\x18\xe9M\xee\xbf{0\x17\x0cj\xde\xfb\xbf\xfcQ\xea&!\x14\xdb?\x85iby\xdfQ\xca?\x84cK\xdd`O\xed\xbfn\\o\x1c\xf4\x1d\xf7?\x9d$k\x12 \xf9\xe0\xbf\x14r\xb9\x15\xd0\x87\xcc?g8\xf7wP\xa8\xe4\xbft\xe0\x1cB*\r\x01\xc0\xd2S\xbb\x9d\xdc1\xe4\xbfo\xd0\xd4\xd9g\xe8\xd0?i\x8d\xa89(\xa6\xff\xbfJ\x97\x0e\xda\xa9\\\xee\xbfNd\xb0=\xed3\xbe\xbf\xa6\xb8\x04g\xfc\xc6\xf2\xbf\x8c\xfcB&x\x14\xe8\xbf\x82Q>\x17\xa0\xe1\xee\xbf\x1c+M\xd6Y\x88\xfd\xbf\xfa\xbf\xee@?\xa3\x0b@\xceW\xbf\x1d\xcbO\xeb?\xc4\xbe\xff\xe5z\xc7\xed\xbf4\x08\x82\xca\x0f4\xf5\xbf\xb2\x8f\x1d|\xb1\xd2\xb8??\xbbS\xf3\xb5\xec\xe3?R\xcd\x82\x94\xbda\xe4\xbf\xf6\\\xe1K\x14;\xdc?\xab8\xb7+|\xef\xe2\xbf\xaf\xe1\xe78\x17\xe6\xf5\xbf\xb1\xd7\xbeH\xdc\xc7\xee\xbf\xc0lN\xe3]c\xd3\xbf\x10\x08\x86\xc3\tL\x8e\xbfh\xc2E\xaa\xda\xcc\xf5\xbf-\xef\xd7n\xebm\xe4?\x8d\xc38]\xffC\xda\xbfn\xc7y\xd1\x19L\xdc?\x90\xbe\xde\x89;\xd8\xb6?"\x80\xf7V!\x1d\xff\xbfG\xd8\xc6\x95\x04]\xa9?\xd8\xd6\xfeS\xa9\xac\xd0?(\x0e\xe2YK&\xf2\xbf+\xfcB\xd2\xa0\xa4\xe5\xbf\xa9)\xa1v\x1c\x07\x00\xc0\x9a\xf4\x84\xa2\xadw\xf1\xbf\x9c\xefw\x922V\xf4\xbf\xc2,\x97\x96\xaf\xe7\xf9\xbfs\xc74\xfe\x94_\xe7?\x0b\xe3[6\x1c:\xec?\xdbza\xf5\xd5.\xf3?\x86o\xfb\x84\xec\xc5\xbd?\x92Z\xec{\xf9\x17\xf0?\xdc\r\x93\x15\xda\x85\xdc\xbf\xdf\x1f7\xf1{\x91\xf4\xbf9/(`\x10-\xf9\xbf\xb7,r\x15\xd8\xe8\xf3?\x03\x8ap\xd9]\x9f\xf0\xbfc\x95\x1d\xde\xc9\x16\xe2\xbf\xfd.\xa0\t&\xef\xdd?g850\x88F\xf8\xbf\x8b/\x02Z\xbbp\xee?\x9bbk\x14\xefX\xdc?=g(\xc4\xd6*\xee?\xd7\xb3\xc0\x7f\xbb\'\xd4?\xd2\xbd\x06\x05\x1es\xf8\xbf\xbd\xb5j\x97\xd1!\xd8\xbf\xe8\xf5nW\xe6\xc2\xf6\xbfI\xc6y\xb4\x1e\x90\xf3\xbf\xc7\xe6\x9fMS\xa0\xf4\xbf\x81\xf3\x7f\xde\xb1?\xdb?\x17\x8a\x9f\x88\xbd\x01\xb5\xbf1L\xc3\xef\x87\xf8\xf6\xbfvE\x8c\x1f\xfb2\xe3\xbf\xce\xc5\xb2\xb7\xfe\xf1\xd3\xbf\xbcon\xd1^\xa4\xfd\xbf\xd6v\x9d\xc7\x89\x84\xf5\xbf\xae\x1c\xb4!\x9aN\xf3?\x02\xecfjRH\x00@\xa8\xda\xc5{9\xdb\xe1?\xca\xfd!\x99:\x12\xf9\xbf.\xbb\xa5\xdc"\x89\xf4?\xbf\x03\x05>h\x1b\xed?\xcd|\x8d\x82\x19\x11\xe2?\x9a\x82\xbe\xd8\x9d\x8a\xe4\xbf\x07\xe5\xb8S\xf0\x1c\xf3?k\xeb\xe0P\xcf\xb7\xcc?\x18\x1bglG\x06\xf5?\x12JN=\x94\xc2\xf1?i*I\xf1g\x1b\xe5\xbf\xbal\x8f\x1af`\xfd?\x1f_Lq%\xb6\xd9\xbf\xcb\xff\x17)\xfa\xe6\x01\xc0j\x90i\xa6\xbdm\xf1?:c\x98\x04s\xe4\xc3?A?\x1bC\x9d\r\xf0\xbfR\xb7\xd5\xea\x96,\xe1\xbfz.r\\\xd5\x01\xe7?\xa7Z\xb5F6t\xe9?\x82h\x157\xd0)\xd2?i\x9e\xb9:\xc8\xf4\xca\xbf*\x89\xa1n\xb2\x15\xdc??\x11a\xcfk\x99\xdc\xbfs\xfc3\x8d\xf5\x1b\xf2?\x06\x9d\xaa\xad|\xc2\xf1?<\x00\xbe.D\xdc\t@5>Xy\xa4\xe2\xcb?5\xb4o\x04e\xc5\xc2\xbfpf\xe8.\xb3\x84\xe1\xbf\xb2NT*\x94n\xe1\xbfe\xd32`\x0fS\xf0?\xb1l{!\xaf\x83n\xbf\xf9\xb6\x08*\x8e\xab\xec?,\xc08?\xe0{\x03\xc0f\x8d\x8e\xc8Y%\xde?\xfe|TXp"\xd9\xbf9\xf9\xed\x00\xc3B\xd4\xbf\x94\xba\xa1\x1a\x84\xb5\xee?u\x9b\xd0X\x03O\xc4?\xdd\xe7e\x15\xb9\xb7\xd4?\x92\x95\xa6"r5\xc3?W\xfa\xe2\xc4\x93O\xbb\xbf\xb0\x84\xee\xf25\xe8\xf2\xbf\xf5\xb9i#\x0es\xe0?!=\xfbK%\xde\xd9\xbfq\xb3\x1e\x81\x81\x0c\xed?;\xd2o_Yr\xeb\xbf\xa5a\x94>#\xcd\x8a?\x0c1\x07?-\x97\xd5\xbf\xa7\x99d@\x8c\x1b\xf1\xbf\x96{&sa/\xf0?\x97\xbaS=\x12k\xfb\xbf\xd2n\xbb\xe9\x9e\x91\xe1?\x13*%\xd7\xd0\x88\xd8?\x90\xf8\xd8BOY\x02@\x83\xe8F\xd5WC\x04@\xca0\xb01FP\xd3\xbf\x82QM\xff\x88\x17\x01@e\x19?U\x85\xe4\xc4\xbf\xd2\xe9\xc1\xeb*\xa8\xfe?\n\xc9\x91\xff\x14\xd9\xe0\xbf\xab\x13Z\xd9-?\xe5\xbf\xc9\xa3o[Je\xe6\xbf\xfcTB\xe0\xdf\xe6\xf1?\xd7\xb6\xfd\xba\xe1\xe2\xf3?\xc9\x191\xc4\x91\xaa\xc6\xbfB*\xba\r\xa6\xf7\xdb?;\x91\xbctV\x98\xfe\xbf6\xa3\x16\xbbK\xdf\x93\xbf\xdb\x9f\xb0\xb5*x\xc9\xbfL\'\xecW\x17*\xfc?\xd5\x81\xfe\xb2\x9e\x8f\xce\xbf\xa2\xf0\x8d\x14\xa5\x94\xd7\xbf\xd5\xf2\x8f\xedJ\'\xec?\xb4\xf9\xb9v\xb2\x00\xf8\xbfC9\x167} \xf6\xbf\xb8%\xcdG[P\xc7?\x85!\xd04E\x1c\xc1\xbfH\x14q\xfa\xdd\xec\x01@\x91\x88\xdc\xb31\xba\xf2\xbf\xa7\xa6\xf8%\xb4\xa9\xdb?Ri\xbd\xc3\xe4q\xc0\xbf`\xcb\xe6\xdd8\x7f\xb6?\x17?\x96_\x8ap\x03@\x06\x13\xc7A^\x04\xd9\xbf\x1a\xf4\xf9\xb6\x8a\xc5\xef\xbf{5^\xa6\xfa\xb6\xee\xbf\xf2u,X\x94X\xdc?\x08\x88\x99\xa5\x11\x98\xf0?\xd7(y\x02\x80\xd6\xfa?\xbc\x92%JV5\xf5\xbf\xa9\xdb\xf7dC3\xfc?\xc6\xe7\x17\x1d\x15\xab\xd3?\xc0\xda\xb4\\>\xc9\xf8?\xfb\xebf ^\xc9\xe0?@@\x03of\xbb\xcd?\x04l\\\xab\xdb\x08\xea?\xafS-N\xbaP\xe8\xbf\x1aNY\xdd\xe9\x05\xd1?\xf5sL\xcbi\x12\xec?\xd4w@"\x89\xd6\xf4?m\xbad\x1d/\xa5\xa8\xbf\xe7(\x146r\xd4\xf5?\xdd\x8c?\x9b\x8f\xa4\xf2\xbf\x8f\x170\x05\\U\xf2\xbfq03;\x82\xac\xe3\xbf\xec\xe2\xe0\x8aUa\xec\xbf\x02\xb0>fu\x8d\xd8?Pf\x0c\xfe\x11r\xb3?\xb1\xec\xdd\xb0\xdc\x8d\xfa?lg\xf0c\x06\xbd\xd9\xbf\xcc%m\xea\xd1\xa4\xec\xbfCo\xee]\xfc\x8e\xe1?cg\xd2J\xef(\xc5?Q\xfepQ\xd7\x11\x00\xc0J}\xab\xe3\x0e\xdf\xf7?\x8d\xaa\x1dG\x81e\xd5\xbf\x14\xf5\x00\xb6lB\xa1\xbf3p\x08\xcf\xedG\xe8?A\xfa\x7f\xc7\xda\xe2\xef?\xc6z\x19+\x91Q\xf3\xbf\xcd"\xbcZ#\xaa\xdb?\xc6k\x9b\x84\x01\xd6\xc3?\x88\x055\x83\xa7\xf1\xe7?\x0b\xb6d\xd2\xf95\xfa\xbf\x9c\xa9<\x81\x9c\x89\x03@\x94\x19k\x94\xc4\xc9\xef\xbf\x06\xf8\xda\xa4F\xd9\xd6\xbf\xb4\x80\x17\xd7\xac\xc5\xf4\xbf\x94\xb8x\xeb\xc8`\xcc\xbf\x13?5\xd3\xb4\xbb\xe3?x\xc9\x84\xfa\xb4X\xe9\xbf\xda\xdf\x01\x9f\x13\xad\xe8?\xf0\x8f\xa8\xdc\x94f\xe1?\x15\xc5R\x14\xb1O\xad?)\xf0\x02\\\x99\xbc\xd2\xbfMt\x15|\x1e\x15\xc0?v{\x1c+\xa0-\xff\xbf\x86\x16\x83\xf7\xd0\x05\xed?\xe4\x1f\x15\x14M\x8a\xe1?\x16\xc82\x0f\xbb\x0f\x01\xc0\xa9\x02.\x10A\x15\xe6?\xbbk8\xe1"D\xe4?\xf1$3\'\xac\xcf\xe9\xbf\x8bw\xb9yn9\xd0\xbfZ\x0e\xaf3\xc6\xe7\xe1\xbf\x11\xcb\xc0U\x82N\xe0?,\xfd\x1d`\xd4:\xf4?\x92~L\xa5\x9a\xaa\xea\xbf&\xc6\xdf7\x84\xac\xb6?\xd2\xbc.\x0e\x1e\xf6\xdf?z\x93|\x03!:\xdc?\xe4\x8a-f!o\x06@hQ\t\xd3\x94\xcf\xe9\xbf\x0c\x81\xe8L{\x1a\xed??\x02\xa1\xc5)\x87\xe2\xbf\x04i\xf2!\xa6\x02\xe5\xbf\xc4\xb2r8)X\xf0?[\x17\xba\xcaPm\xca\xbfV\x0e\x0c\xe6@\x0e\xed?)\x16\xb06b&\xf6?\xc34\x1d\xaf\xa9b\xf9?\xca\xce\xdf\xe1\xe6\xc7\xf3?\x84\xc2\x1eV]\x04\xc4?\x1e\xafX(*j\xf7\xbf\xaaM\xf8\x1eb\xba\x03@c&\x9fl\xe8b\xf1\xbf\xf1\xcd\xbbg\x1b!\xbf?\xc6\xbd\xa5\x7f\xa7\x9a\xf9?/\xa2\xa3\xee0E\xe9\xbf\xad&\xd9Jh\xe4\xf6?W\xe5`\xfaW\xa1\xb3?\xb4\x00#\xac\x1fK\xfa?X^\xf3\x88m<\xcf\xbf\x16\xf0\xa4\xe0\x12c\xd4\xbfG-\x0ba4\x8d\xe8?\xcd\xe1\xf1XG\xfb\xa9\xbf\xff\x1a\x94\x0cd\x88\xdd?\xee?:\xf6\x80\x13\xd8?\xce\xf2\x8d\xd7\x1a\xc1\xe4?%\x05\xac\xdc\x85s\xf6?\xc7B\x18\xf4}\x18\xe3\xbfc\x1f9\x878\xf2\xed\xbf\xb3y\x8b~\xfcl\xb7\xbf\xfa\xfc\xf8\x19\xf1\x17\xff\xbf\x9d\xa4\xbf\xe5\x17q\xfb\xbf\xe5\xf1\xa0\x9d\xf1\xd0\xca\xbf\x9f\x8dT\xc8\x94\x9e\xf6\xbf\xaa\xe7fI\xb8]\xef\xbf"\xb1\x95\xce1}\x05\xc0\x90\x03\xa8\xab\x93p\xf7?_a\xa2\x82\xba\xfa\xc6\xbf\x0e\xc9\xb9\xd7\xd4\xf4\xf1?\x0eG\x10mIe\xec\xbf\x7fp\xeb\xcc\xcbF\xe1?\x02m\xb5\x06\xe6\xab\xc7?\xec\xf0\xdd\xc3;\x99\xd2?\xff\x18\xcb\x92J7\xe1\xbf\xf7\x970\x06t\x95\xcc\xbf\xc2\x10|\xb0N\x16\xd6\xbfC\x81&\xd0"G\xd0\xbf\xd7\x01\x01(\r\xa2\xe0?\xda\x17\xfeU\xf9\x04\xe8\xbfW\x1d%\x06\xb5\xfc\xd3\xbf\xb0\xe0\x0c\xdftg\xee?\x8f\x08\xe1\xa4\x06\x8e\xeb\xbf)\xf9(pf\xdd\xd5?{9\\X\x1f\x8br\xbf\xe3\xf09\xd6z\xd4\xc7\xbf{\x00\xec\xf5U\xee\xed?\xa1\xeb\xbb\x872U\xfc?Z\xbe\x8cb\xb3\xf7\xfd\xbfS/\xe6?f\xdd\xd4\xbf\xe3\xc9\x12\x86IB\xe0\xbfk[ws\x0c5\xd7\xbf\xb2\xe2I\xb3\x8e!\x07\xc0\xaa\x9b\xc1\x8c\x95\xb4\xf3\xbf\xa4\xbe5n\x95\x07\xf1\xbf\xde\x8e\x05\xd7\xda\xa9\xbe\xbf/QLN\xc9p\xf8\xbf\x04\xc1O\x00F2\xe0?\t\x8c\xe3\xe0\xe2\xe2\xbb?\xc0\x7f\x17\xcf\x88\xb2\xe7\xbf\x9f\xf7\xbd\xdd\xa5\x10\xf7\xbf\x8e\xc2\xf3b\xee|\xc6?\x16\x01Y\xd5\x86\x98\xda\xbffSG\xf8\xd0\xbd\xc2\xbf\x0c\x853@f\xcc\xe9?\x82=K\xbb\xc3\x9d\xe7?\xa3\x8b\xdc*\x88\xec\xbe?9\x13\x11\x9c\xacq\xe6\xbf$\xbc\xed\xd7WW\x95?0\xbc\xa6\xf8\t\xf4\xf4?\x83W\x8c\x1e\xe0\xf7\xf6?\x8e""PV\x8b\xdb\xbf\x95\xba\x9f\x12\xd9\x9e\xda\xbf\xab-\xe6\xc3\xf9\xda\xf1?\xa7/S\x11M]\xcc?\xdb\xe1\x8b"\x99\xaa\xd1?1|\x9d\xf9\x93\xc3\xf3?\xd7q\xf1\x9et}\xe1\xbf\xd3\x1aF\xc9LY\xe7?Z\xc7\x8f\xc6\xdf\x02\xfd\xbf\r\xd7\x13lhv\xf0?TP\xde\xd2M4\xea\xbfK\x11i&\t=\xb0?wn\xa4\xa3D\xad\xe2?`\xa9U;\xc9\x8c\xc6\xbf\x12C\xb6\xdf\x9d\xa9\xf0?8*\x84N\xa7w\xeb?"\x1e[9\xb9\x89\xed?x!\xab\x80\x08\xbc\x95\xbf\xce4\xaaK\xd2\xe7\xc1?\x9e\xcd\x01\xe9\x01+\xff?(\xf0c\xf2;p\xef\xbf\x90\x93\xb8\xfd\x9b\xb6\xfd\xbf\x97\x19\xbd\x16\x94\x8c\x00@\xf4x\xae\xf8\xff\x93\xf3?m]\xa4m\xa1\xc7\xeb\xbf\x86\x99\xcc\xe8\xbd!\xf1\xbf\x08.\x1e\xe0\x1f\xf4\x93\xbf\xeb\x01{m\x11\xa5\xcc\xbf9\x80\xe9\xa3\xcf>\xe9?7D\xae+$\xf4\xde?\x0e\xf6\xfa\xb8\x85C\xf9\xbf\x80\x06my\xec\x7f\xd1?@r\x9eJer\xfc?\xf63D\xd0D\x03\xef?S\x8b\t\x96\xac\xfa\xf3?\x13\xc6m\x8a\xef\x86\xf7?OE\x08~8\xcf\xd8?\xce\xae\xef\xdbv^\xe0\xbf\xa5\x90?v\xfe\xc3\xf1\xbf(%\nt)\xcb\xeb\xbf\'\x11\xd4\xc4s\x86\xb5\xbfC\xb1\xb9\xe2\xaf\xf0\xe1?.\xf7\xc8\x90$6\xe4\xbf\x0f\x0f.}\xb1\xc0\xfb?\x18\x11\x0e\x92\x85\x16\xc7\xbf\x1f\x9b\x0b \x94\xae\xef?d(\x02\x0fW\x95\xca\xbf\xa1\xee\x80$I\xe2\xf8?j\x0e\x93U\x9f\x03\xe6?\x82 J?\xc0\xc7\xfc\xbf\xc2\xb11\x11B\xd4\xe7?gF:#9y\x06\xc0m*\xca\xd3\x88\xeb\x04\xc0*\x88m\xfb\xc6\x92\xea\xbf\x88\xfd\x9a\x1f\xb6\x10\xf3?C\x1e\xb6\xa6q9\xe0?\xd4\x9b\xcf\xb9\x9e0\xe6\xbf^\xa9V\xc9\xb1\xab\xa6?\x11\xa3"\n\nK\xe1?\x97\x00\x9ca\xb3\xc4\xdc?\x05\xc9\x07\xed+:\xea?\'\xaa\xf4\xd4G\xed\xf0?t\xc6WaI\'\xce?D4\x81\x1e\x03o\xd0?O+O$\xeea\xe4\xbf\x9f\x16\x8a\xb2\x81\x84\xf2\xbfD\xb9\xec7\x92\xca\xe1\xbf\xc3\x90hz6\xb1\xe0\xbf\x19\x17\x00\xfaL\xb4\xd0\xbf\xa1\xa9^\x15\t\xb0\xd6?C\x83\xac\xf9\x00\'\xe8\xbf@\xe5\xcfc\\\x0c\x00@\xc9\xd8t\x9d\xf2\xbc\xd6\xbfE\x860G\rl\xbc\xbf\x16\xe5xK\x92\xa9\xbe?\x07Q\xd1!y\xb6\xd2\xbfUH\xb4$:E\xe5?\xa9\x00\xb5\t2\xd9\xf2\xbf\xbd\xc3\x87\xfb9\x02\xba?\x879\x9e\x0e\xf2i\x84?\xac\xd2C\x91\x1bJ\xda\xbfxT\x01\x15/\t\xe2\xbf\x03J\x06\xe6&H\xeb?\xde+\x11%\x1fE\xde\xbf\x83\xde\x98\x7f\xe5\xdc\xed\xbf\x12\x80\'\x10)|\xd7?\xcb\x17\xd4j\x8a\xfc\xdb?2\xa0#\x18\xc5R\xa7?\x14\xed\x9a\x9exs\xe2?\x1d\xc0\x0fl\x87R\xb1?l\xe3\x82,\x1cV\xfe\xbf-"\x13\xc1\xcb\xc7\xe5\xbff\xf6\xebn\x8c\xdf\xbf\xbf;\xc9*\xfd\xed\xaf\xfe\xbfZ\xb5\x9c\x8d\x0f\x1e\xb9\xbf\x05\xf2\x16\x01qD\x02\xc0MI\xa1U\x92\xcc\xe7?\xb7\x0cK\xf0\x96v\xb4\xbf2\x0c\xc3\xd7\xee\xf2\xdb\xbf\x91\r0\xd0q\x03\xd0\xbf\xb4\x076\xaa\xee\\\x97?F\x0c\xe5\xa4\xe3\xa9\xe1\xbfY\xe0\xdc\x08\x86\xec\x03\xc0\x8a\x1f)\xb8\x962\xfc?`\xe2\xad\xc6e\xe2\xfe\xbf\xf8\xc9\x10\xb3c4\xd4?\xa0\x16\x9a\x98\xfcS\xeb?\xb7\x19\x9a\xb6zC\xd1?\xd8\xd5]\xec\x85\xe4\xdb\xbf\t\xc6u\x07\x90\xb1\x01@\xa6\xd7\xd0&\x07\x9b\xfb?\xb3\xc2\xbf1y\xf4\xf9\xbf\x03\x1bo\xa1O#\xd1\xbf\xd8\xeeU\xb6\x80\xd8\xd3\xbf\x9e\xfb\x89=\x17y\xd1\xbf\xa7\x8aqv1 \xa6\xbf\xe1@)\xb4\xdd\xf5\xf2?N\x99p\xb2\x03\x8a\xf4\xbf\xbe\x8d\xc9)\xd0*\xd2?\xc7\xfd\x12VS\x0f\xee\xbf\x02\xe7\x164\xe0\xd5\xe3\xbf\x04\x15M\x00`\xaf\xf0?vQE\xe0a\xa8\xee\xbfRV])y\xf0\xc9\xbf9\t\xf3\x0c\xef`\xe8\xbf.$\x1a)\xcdg\xf0?%W9f\xa3\x98\xee\xbf\x1a\x85\xf9\\\'\x00\xeb\xbffO\x81MC\xe8\xc6\xbf\xfdX\x9f\xbac#\xf7?\xa2\xb3\xa8\xd3\x02"\xca\xbf3\x9eI\xb3\xab\xa2\xf6?N#&vt\x1e\xf3?\x8a\xa70\xd2\xae\x9f\x0c@\xed\xf2\n\xa9\x8bK\xe6?\xa1bXNzy\xef\xbf\x8a)\xd7$\xadg\xef?c2b/gt\xe5?\xc2c\xb4\xde\x8c\xc4\xf1?\x15\xd66\xcd\x9a\x1f\xee?\xb1c\xe3\xc1\x14\x8d\xda\xbf\x9b\xc3\xa1\x8ea[\x01\xc0p\x84\x9e$\x08\xcf\xfd\xbf\x93$\x10\xd8\xc33\xe6?i\x91\xe25\xb8\xee\xda?+u\xc4\x94)v\xeb?\x1bP\xccr\xf4W\xd8?->u\xbb\x06X\xff?y\xba\x8c*;.\xef?\xcb\xb4vi\x8f\xc3\xe6?d\x84\x90\xc9\x9d\xdf\xc7?\xf1\x88\x9b\xdc*\x00\xd7?DX\x86K\xa9\x9a\xf0\xbf`\xc03\xf8\x97\xec\xec\xbf\xa3\xbe\xa0\x04d\x11\xe1\xbfN!\x01\x93\xa9\xc4\xd8\xbf\xbc\x1a\x08,T&\xf9\xbf\\j\x05:\xdf\xa3\xf0\xbf\x91\x98D\x8d\x04q\xeb\xbf\r\x90\x04\xf9\'\xdd\xeb\xbf\xba6\x7f[\x04\x06\xf5\xbf\x7f\x12\xed\xde\x8bs\xeb\xbf\xac\x7f\xa1p\xa0$\xb1?\xcd\xcb`7ou\x00\xc0\x8b\xe6)\x81\x0fm\xad?R\xe2\xd8O\xd7H\xfc?\xf5\x12\xab\xb3\xe9\xa4\x8a?\x85h\x15\x84\xb5I\xf7\xbfc\xbf\x9c\xa8\xfaZ\xf4\xbft\x1bcN\x7f!\xd0?\xfd\xde\xce3\x93n\xfe\xbf1\xbf\xdc\x1a\x11#\xe8\xbf\x05\xcc\x19\xd1&\xae\xf9\xbf\xd8V\xae]\xa4]\xd9?f\xe0O\x01\xc4i\xe8\xbfB\x192\x02\xf7E\xea\xbf\xe4\xc7\xda\x87b\xf7\xf2\xbf\x1d\xc4\x1d@\xf4\x0f\xde?\xe1K\xe2g"F\xdd\xbf5\x9b\x9fF\x81F\xbb\xbf\x82\xed\xb7V\xe8\x85\xb4?\x9d\x9e\xd9\xb5\x96{\xf7\xbf.\x8dH!\x8a\xb3\xee?\xa0iG\x04\xed\x15\xb7?\xd1\x91y&\x0f\n\x01@z\xacX\xc6\xf0I\xd8?\xc5q4\xf8\xe0P\xf4\xbf\xde\xc37\xdb1\x8f\xf5?\x83hHr\x158\xf6?\xd0\xdeI\xda\x82\\\xdc?\x9f(\x06\xc0e\xa0\xcf?Q\xf0(}\xc4u\xc0\xbf\xc6\xf9\xd5/e,\xc4\xbf\xfe\xbc\xae\x95\xfe\xaa\xf3\xbfw\x05\xe8\x7fKz\xed\xbf\x1e\x95\xcf!vB\xe6?@\xcf\x97\xde\xdbT\xe3\xbf&\xb6\xc3aD\x1c\xbd\xbf\x1d\x14\xb9ur-\xe9?\x1b\xed)\xd0a9\xdd\xbf\x8dM\xda_T\xd3\x00\xc0\xc4\xf7}\x96\xb48\xf6\xbf>\xdb\xd8Y6x\x07\xc0\x13+\xc3\x9b.\xff\xad\xbf|*\xb0\xfc\xcd\xa1\xca\xbfz\x85\xe3\xbbV\xf5\x10\xc0\xdeE\xfb\x04\xf7\xe1\xfa\xbfZ9(\x0b\xa4\xab\xf1\xbf[\xe8\x86P\xb7]\x02@\xa8\xf0\x1a@\xebG\xee?\xc6%\xaa\x9c\x1e\xa2\x03@\x9b\x9fzp\xfb\xa2\xe3?\x16\x1f\x8a\xab\x16e\xe3?O\x86_\xa1\xb1\xec\xe0?\x14\x00\x87\xe5\xe5\x94\x07@8\x997\xa4\xa4\x02\xac\xbf7g\x07\xec\xfd\xc1\xf2?`\xccWp\xe8[\x08\xc0\xaf3\x11\xbc\x9c1\xce\xbf\xf9\xcb\xd9\xb4\xc6N\xc9\xbfoyQ\xfe.F\xd2\xbf\x03\x14>u\xdd\x91\x07\xc0\x8c\x0b\xab\xbb"f\xe4\xbf\x1e\xc3&\x0c@>\xf5?\xc6\xa0\xccb\xde/\x8e\xbf\n\xf6::\t\xcc\xbc\xbfcWf\x92\x9b\xba\xf2\xbf\xfdPo\xff\xfdK\xd9?\xee\x98|\x16\xdcA\xf4\xbfn4\x88\nCq\xf4\xbf\x81nbn\xca{\xf7\xbf\xda^\xe4/\xf2l\xf4\xbfB\x91\xd5\'\xfeC\x01\xc07.\x07\xfb\x86\x9f\xe2\xbf\xe9M,\x0e\x06V\xe9?X\xed"\xf3\x92\xf1\xe5?\xc0\xb1\x10\xda0}\x00@H\xa7\xd3u\x8e\x8c\xf7?S}r\xeb\t\x1d\x00@*\xb2\x00\xe0.d\xf4?\x81\xdd\x94=\x87\xa4\xf6?\x9b"57\xd2\xb7\xe6?Q\r\x99\xa5\xa3N\x06@\xbe/b/\x11e\xe1?RK\xcf\x17S\xd0\xec?\xa7u\xd4\x19\xe9\x8b\x90?\x8b\xb2\x80.\x10\x83\xe5\xbf\x10\xc7N\x05\xdf`\xe4\xbf\xd2\x9eY\x14o\xff\xe3\xbf\xfb\xd2\x14J8\x07\xf1\xbfC\x14\x94\t\x87#\xfa?\xd4\x95/\x82}\xb4w\xbf\x87\xb1%s\xd3\xac\xea\xbf\x07\x85\xe9-2-\xcb\xbfg$swU0\xd3?\xe7\x1ar-2)\xd7?\x1e\x8d\xac\xc8\xf9U\xeb\xbf\x80E\xaa\x1c\x051\xc9\xbf\xa1o7\xa6.x\xfe\xbf\x9f\xc6m\xbb06\xd8\xbf\xeb\x15\x1d\x00i\x1c\xfc?\t\xd21_8/\x83?\xe27\xd5\xcb\xcfK\xd0\xbf!*\xd9\xb3Q\xf2\xdf?\x9c\x83\xf7\xdf\xd5\xc1\xc0?\x7fI6h\xb7\xfb\x05@\xbd\x0b-\xea\xa2*\x07@\xb8\xcel\xed\xadB\x02@\xef\xda\xb1\xd1\x1dg\xf4?\x8a\xdd\xadsG\x19\xe9\xbf\xffl\x92\xa3s\x92\xb9\xbf\xe5\x11\xfd\x14\x0b\xdb\xf1\xbf\xd5\x9c\x0f\x9f\\\x11\xe6\xbf{8\xd1\xbf\xe1\xa2\x05\xc0\x9f\n\x1b\'b#\xf2\xbfL\x9b\x0b\xa0\x01\xb7\xf7\xbf\xbe\xa8.\xd8\xe8\x83\xc7\xbf\xb37\n\x19\xfb\xdb\xf2?\x16p\xeb\xa1P\xf7\xfe?\x82\xd5\xde\xadx^\xf7?\x97\x92\x15\xd3\xb4\x07\x04\xc0o}\xd5&-\xc5\xf9?\x1ac\xef1\x80\x90\xe8?(\x99`h\xffC\xe8\xbf\xa4\x96\xf0\xdbR\xcb\xef\xbf,j5>\xf7\x8b\xfa\xbf\xf4\xed\x13\xa0^4\x00\xc0\xa6\xabD\x14\x93\x15\xe3\xbf\x8e\xe8\x93\xbf\x17\'\xe6\xbf\xa9yy\xaa\xc8\xbe\xda\xbf\x1a:3\x05X\xcf\xb9\xbfD\xbfb\xa1Y;\xf2\xbf\xde\x97\x89u\x00p\xf2?\xfe\xf0\xd6\x84\xec4\x01@\x8d\xf9\xcf\xa1X7\xc7?`6\x8c\xc1\n\xf1\xf5?\xca\x18\x9aJ\x11\xa5\xc7\xbf@\x89J\xc7\xcf\xc3\xdb\xbf\xf4W\xc8\xdb\xee\xce\xfd\xbf\xf2\xee\xb7\xa0\xa5\xaf\xeb\xbfygdu\xa4\x05\xd4\xbf\xfa\xb7\xa5\xb0s\xa3\xc0\xbfd\xc0\xf3&\x15\x1a\xfb\xbf\nJVlF\x92\x01\xc0J\xfa\xdf=\xa05\xef?\xc7\xa3pP\x7f\x85\xe0?\x01\x078\xa6\xebq\xe7?g\x87\xf5\x1f\xe1$\xf5?\x93\x9eL\xe4O\x91o?G\x7f\xdf\xa7\xdbM\xb5?\xcb\xd4\xd6\x19\xd0\x9a\xf0?\xe0\xd0\x1f]\xa4\x9d\xdd\xbf\xd6\xc3C\x1e\r2\x05\xc05\xb5L\xb3\x84z\xee\xbf\xe9J\xea\xc5_E\xeb\xbf\xe3[\x05\xb63\xe5\xfd\xbf\xad\x85\xd0\xf6\xe3\xf0\xf5\xbf\x8a\xce\x9b\xbf\x1f\x93\xf1\xbf\xfe\xce+\xab\xa7\xec\xfd\xbf(\x02\x9d\xe9\x94g\xf1\xbf\xbf.\xff\xbdw\xb8\xfa?6\x0e\x85\x9c\xa8\xcf\xeb?\xdf\x90\x86h\xcd\x13\xdc\xbf\x04\x7f\x1a\x0eb\x17\xd9\xbf\xdfR.lb\xb7\xb2\xbf\xc6\xbd\x95\xad\x17\x83\x00\xc0\x87f\x98\xd4\xce\x1d\xf0\xbf\x8d\rT\xee\xfd\xf5\xed\xbf\xae\xd6\xd3\xa9{\x00\x03\xc0<~\x0eS\xff\xae\xf9?\x8b\xc8\x16\xc1\x1b\x06\xee\xbf\xa6\xe1\xf6Q\xf6a\xe4?\x8f\xe8Z\xbcj=\xea?\xbd\xbd_\x0b\xc7\xc2\xeb?;\xd83^\xca\xa6\xf2?b\x02\x98\xc0\x8d\x17\xf2\xbf1\xdc\x10\xa5\x1d\x0e\xf6?Z\xcf\xe2\xe2\xb4J\xbd?`F\x1fk\xd8k\xde?\xc6\xd86\xd3\xcc\'\xf4\xbf\xdf\xbbM\xc3\x81\x8d\xd4?\xf2e\xe4\xdb\x88\x9f\xe7\xbf\xfd mu\xd3\x9e\xe8?\xfbc\x86=\x04\xb7\xea\xbf\x80Y\xb7}\xf8\xcc\xf5\xbfsGVdT\xcf\xd9?(\xb4[\x1ez\x84\xdf\xbf^\xd9\xeaU\xfa7\xde\xbf\xa4F\xdb7\xb9\xb2\xf4?\xa8/u\xdare\xd5\xbf\xe1\x87tB\x03B\xf4\xbf\x12\xe96\xab\xa1K\xf0\xbf\xe8\xfc\x9f\xa1"\t\xed\xbf\xc2r\xd8V\xe8\x92\xf3\xbf<\xf3%\xfa\r!|?\xd7\x89\xd8\xec\xab\x12\xeb?\x18kl&Pu\x93?\x81g\xf3\x92\xb6\x08\xfc?i\x0e@L\x8c\xcc\r\xc0V\xf0fqqP\xc9?\xbd\xc3e\xcc\xa2\xf0\xc1\xbf\xe7\xe9\x1cw8\xec\xff\xbf\xc23@3\x83\x98\xe4\xbf\xeb\xb4ioO\xec\xd4?\xbb_T\xe0\x8f\xab\xfd?\xe7\x81\xb7\xd0)\x96\xde\xbfo\xb4\x8d\t\x80@\xdf\xbf\x1fa\xe8\x8e\xaeS\xee\xbfws\xc6\xd0\'\x0b\xd2?\xf4R\xce\xaeW\xf4\xea?R\xc1c\xa5\xb7\xa2\xf2\xbf\xda\rH\x0c\xb8\xfe\xf8\xbf\xa0\x8b\xe3\xbd\x1e\x91\xf0\xbfV\xcd\x03\x07m\xbe\x02\xc0-\x9c\x8c\x9e\x14{\x00\xc0\xcck\x95\x8fo\xa8\xd3?8\x1a \xc9i\xdc\x02\xc0\xd5\x9f\xec\r8\xbb\xb3\xbf2LW^\xa5\xf8\xc9?\xfej\x9fU\'\xb3\xfa?4\xa3\xb6\xd5\x1a\xcf\xef\xbf8V\xdd\x9e\xa9\xd6\xe1\xbf\x8c\x92qey\x1d\xf2\xbf\xad\xddg\x013\x1b\xdf\xbf\x0fnd\xa0\x01p\xf9\xbf\x9dD\xb3^\xe5\xc7\xd1\xbf\xc3f\x90\xe8VL\x97?Ds#\x92\xde\x10\xcc?\xe5>dn\x12n\xf1\xbf\xb7\xb8\xa9\xd5A\xd9\x02\xc0w\x02\x85\xa9\xfa\x1f\xd9?\x9b\xd2\xa4\x19\xf2\xf8\xf2?\xf9\xb3l\xcb}5\x9b\xbf\xaa\x00-\x7f\xe2>\xca?\x114&\xcc.\x19\xe8?\x0b\xe1\x89\xb3\xdc\xa2\xfe?\xed\xe2\x14ue>\xf1?\x1d\x17\xa9\x96\xd9\x9f\xc0\xbf\n\xe0\xc0L\xd9\xec\xf3?\xb4\x19\xad\x85\x8c]\x04\xc0:L.V#F\xd3\xbf\xf3\xb3\x8b\x9b\x04a\xc7?\xae\x93\xf5M\xe2l\t\xc0\xa76\xa4W\x0ek\x06\xc03)\x8d\x1fGO\xff\xbf>i\xe9\x07\x1e\xe3\xf0\xbf\x7f\x0eL\xb5\x89\xc4\xf1\xbf6\xeb\n\xcc\x88\x85\xd1?\xa3\xd0\xdf\x9f\x9a\xf3\xe1?\xcc\xa83\x85\xa6w\xc8?\x89\x82\xc0\xe8\x95\xd0\xf7?\x90\x1e)=%\x92\xea?y\x8f\x96\xb6e\x9b\xf2?\x1aNq\xd5\x82\xa8\xf2\xbfBi\xacM\xb4\x1a\xe0\xbf\x83\xf4\xce\xfe\xfb\xee\xe4\xbf3A\xafS9\x80\xf3\xbff\xfb\xdc$!\xd4\xc4?L\x8c\xd8\xf1\xbbe\xbc?)sC\x0b\xf3\xde\xa7\xbf\xa8\x02/\xdf\x86\xea\xe6\xbf\xc9G\x16szE\xfa\xbf!\xec\xb6\x9f\xd9\x9c\xf0\xbfkHVc\xbc\xa1\xf1\xbfH\xfa\x9a:\x89\x05\xf0?\xcb\x0e\xc3\x81\xbe<\xe7\xbfE\x1a<\x96(\xed\xeb?S\xaa\x15\x88\x99\x16\xe7?R\xff6E\x8b\x97\xe5\xbf\x9ea\x1e\xe8]$\xda?\x84\x8eC8\x8d\x00\xd8\xbf\xa4]\x8a\x9bB,\xf5\xbf;\x90Rn\xbal\x0e\xc0\x1dd\xbc\xa3\xc7\xca\x0b\xc0\t\xb2\x12\r\x81\xe5\x08\xc05SY7\x13\x95\xe0\xbf\xc1g\xa2\x9c\xb3}\xfc?\x81\x16\xaa\x92\xff\xf9\xf2?c\x89\xae\x85\x86\x92\xdd\xbfj\x9a\xdfT\x94\xb9\xaa?\x1e\x0b\xb1\x19\x19\xc2\xe4\xbf\xa4\x921\x82d\x1e\xf4?\x10X\xd2\t\x8e\xdf\xe4?aVb!\xa9\xa6\xd8\xbf7\x96\x07^N\xb7\xcb?E\xb8\x0e\x9c\xf3\xbf\x00\xad\xc8J\x15\x9e\xa4?\xbd\x04\xff\x89zc\xe7\xbf\xb2\x92\xca\x85\xd4\xba\xfa\xbf\xa5\xf3ch|\x13\xf5?\xff\xec\x12\x9cn\xb0\xfb?\xf83\xcd\xb8\xa2r\xd8?\xa7\xfc=^\xe5\xdd\xef?\x9c\xef\xa0I\x82\x97\xe8\xbf\x0cL\xd9\x86\xad\x07\xfe\xbf\xc9a\xb4C\x97\x11\x9e\xbf\x8a\xe0Y>\x1b\xea\xf1?\\\x0b\xb8\xb6Tg\xd1?\xbb\xf0\xf2!\x9a\xf9\xe7\xbf\xb6\xa8\x97AB.\xe2\xbf\xd4\xdb\x01\x7f\xe10\xf2\xbf\xd4\xbe\x0b\xed\x11\xa5\xe7?\x01\xe4\x97+~d\xd5\xbf\xf4\x9cyR\xda%\xe4\xbf\xda\x8b\xe8\x85\xb8\x8c\xfa?\x97\xfb\x89I\x02\xe9\xdc\xbf\xc9\x93\x89:/\x12\xf7\xbff\xe5\xe0\x85C~\xe5\xbf\\13\xbb\x86q\xc9\xbf|\x17\xb8\xa8~\xfe\xed?\xd1J\xc2\xc1\xfdT\xf7?[\xdd\xff\xa3(>\xe3\xbf\xf4"m\xce\xfc\xca\xee?\x10\x88q3 o\xa6?\xdc\xa4\xe7\xf5\x13\x0f\x81?M\xa4V\xdb\x8f\xb5\xe1\xbf\x9eM\x97\x11\xa5\xad\xe0\xbfU\xfc\xcd\x0e\x19x\xd5\xbfI\xd0\x17\xf0G\x14\xc0\xbf\xc2\x89\x8c\x92\xf9k\xc5?\x7f3V\x0b\x84\xdf\x01\xc0x\xa7\x82\xfc\x9f\xe9\xf7\xbf.Oz\xf1\xf8\xb6\x9e\xbf\xbe\xb5u\xf4\x01$\xfe\xbfU\xe6\xa5\x9b\xf28\xfe\xbf\xae\xb6\x11a\xecB\xd0?\x96}F6~\xa5\xec\xbfP\xe3A\xf2\x98\xaa\xd2\xbf\x9d\xcfn\xc6\xa3W\xf5?\x91\x91\xcb\x02\x955\xd4?\xa5\xe00A\x80^\xe6?\x94\x86gG\x8c\x81\xf3?\xb6_W5)A\xd2\xbf\xd7\xb0\xad\x07\xc4\xcf\xe3\xbfxrf^#\'\xf1\xbf\xa3+\xb7\xfd\xbb\xd9\x00@pR\x10~H \xf7\xbf]O\\\x0e\x14\xbe\xe6?\xe0\xe4\x86\xdf\xd5V\xf1?\r\xee\xcb\x80\xb5\x0e\xf0?\x01\xeb4\x0e \xbe\xe4?\xc0\xe7\x95\xd6f\xd6\xf4\xbf\xac2og\x97Y\xf1?\x1e\xd0I:\xa0h\xf1?\x1c\xa3\xf3\xcaP\x0c\xd3?V\xb5\xdd\xbfBm\x03@\xae\xa3*\x12\x9eY\xed\xbf\xadT\xdc)\xdf\xcb\xd2\xbf\x85\xe33[\x07\xd1\xfa\xbfm\xb3\xb6\x10#\x96\xbe?\'\xf7i\xde \xc9\xc8\xbf\xb7\xc5\x8a\xd0^4\xf0?\xe7b\x1f9:n\xdd\xbf\x03CP\x8e0\x89\xa1?\xe6\xfas)R\xb3\xda?\xf5(\xbd\x99\x14P\x07@\x94\xe1\x1f\xa6\x00\xc9\xe1\xbf\xe3m\r\x1f\xa4\x0c\xbd\xbf\x0b!\t\xb5(\x9a\x06@\xber\xa1{P\xd3\xcc?\xf8\x14\xa7$\xcc\x14\xc7\xbfB\xce\xc2\x08\xcf6\xa9?|\x81K\xc0\xfb\xa8\xff?\x1b\x9cq`\xdd\xc7\xf1?\xb9"\x1d\xd0\x11\x1f\x01@\xc1n\xe7\xfe\x0b\xdf\xf8?\xbbM\xeea\x9dg\xd3\xbf\xba\x00P\xd7\x8fH\xd7?\x1ay\xf8\xba\xcc\xca\xf1?\xd8sA\xe4I\xc0\xc3?\x1c\x08Z\xf1\xbd\x82\xe1?f\xb89\x80m2\xfb?c\x1f\xe9\x07&\x91\x04\xc0:\r\x97\xe8\xb37\xee?G@\xa9\x02\x08<\xd6?1\x15V\x9a\xb4\xa4\xe3\xbf\x81\xff\x8cp\xd3V\xf1?UF)\r\xd0l\xd1?[B\'\x82\xb0\x14\xe1\xbfr4\xe93!d\xc5?^\xa1+\xb4K~\xf3?\xfb\xb2\xb7i\xb8\xc8\xf5?\x86\xdf.bra\xdd\xbf\xc0C\xf9\x7fc\xc4\x97\xbf\x04\x03\r\x18c\xb5\xe4?\xa3\x95\x9f\xc7\xeeu\xf9?j\x97\xd9\xc9?\xf6\xef\xbf\xc2\x97+\xe7\xf2\xb1\xe3?3>U\xc8F\xe8\xf5?\xb3is\xd7\x17\x05\xf0\xbf2\xe1\x0c\x1c\xc4\x0e\xdf?l\x9es\xd4\xfe\xd4\xd8?a\x8dt\xb9o\xdc\xef?\xd0;\xc4f\x94!\xea?}H\x1b\x82\x9f^\xfd?h|\xcc\x1a\xb6\xfc\xbf\xbf*\xa5F\xc8~\xe5\xd6?\xe8d\x86\x14\xb0\xa9\xef?Q\xf4\xe1Rx\xd7\xc1\xbf_z\x95\x91h=\xf0\xbfr\xe1\xe7\xcaV\xf8\xb8\xbf40Q\x15\xd1u\xdc\xbf\xcb\x96\xe7\xb3\x10\xfb\xdf?\xfc\xfcJ\x87\xce\xe0\xf9?\xc2\x8e\xa4\x05\x1b\x1a\x94?\xb0?2\xd4\xf1\x8b\xf5\xbf\xef\xb7\xe3[\x7fR\xd2\xbf\xb2\x84B#8\xf3\xf9\xbf\xff\xbc\xbam;V\xf2?\x84\xb6\xfb\xaa\xb9\xc0\xf0\xbf\xb2\xb0\xec\x95OD\xf1?\'\xd8\x17Y\xb9\xb8\xf5\xbf\x89\x14\x04\x8d\xc0\x97\xd1\xbf\x82\x12\xa1\xfa7\xe9\xca?\xf5\x97\t\xf6\x0b[\xe2?\xaaW\xea\x1f\xe9\x80\xd7\xbf\xa6\xf0\x82I&\xfe\xe9\xbf\r\x1d\x90=\xb5B\xd8?\xcb\xb5\x85\xaa\xdeC\xdc?F\xb6\xc88\xfco\xee?\xde\xaa\xa2k\xfa2\xc3?\x80jj2|\xb8\xd0\xbf\x08\x1b\xfc\xe4<\x17\xe0\xbf\x0f}\xa4V\x10\xd1\xd7\xbf\xdf\xec\x19\xa71\xbd\xf6\xbfq%!w\xf0v\xea?\xb0z\\\xe4I\x93\xf4?H\x1a\\\xf7\xc4;\xdf?_TRw\xbaP\xf1?\x85\xa4%!\xe2t\xe7?\xb2\xbe\x11bgx\xe4\xbf\x8b\'q\xd2Nc\xef\xbfh"`Ch%\xda\xbf\xa7p\xd4\xff\x0bk\xea\xbf\xd8\xce\xf5g\xc6\xa9\xc1\xbf\x18\x0e\xeb\x13T\x92\xd8?\x98\xde\x0b\xa3$\xb5\xfb?\xfe\x11t\xa3\xdf`\xe6?\x13 \xfa\x05+\xe9\xf3?\x12\xe1F\x80\xe5\xde\xf0?\xe4\xd6\xcf}\xeb\xe2\xf4?\xce\xbe\xafB\xaey\xe5?\x8b\xd8&\x8a\x02\xaa\xed\xbfE\x8eK\xc8+\xe5\xb6?O.\xa1ltt\xf7?\x0e\x9arA>L\xc6\xbf\\\xf9\xc8!)\xa1\xf9\xbf\xab\xe5\x1c\x85p\xdf\xe6\xbf\x86\xcdr\\:\xc6\xe1\xbf\x8c\x98/g\xc7 \xc2\xbf(\xd1\xfa%\xfdG\xdd\xbfV7z\x8d\x0e\x8b\xc2\xbfE\x08{\xb5n\n\xd8\xbf\x86$\xb2\xd1u\xc9\xca?\xf1\xb4\xcf\xd9\x91\xa4\xd3?\x00\xd2\x9a\xce\x04\xc8\x00\xc0s_\xf1\xf5\x16X\xe0?G\xa3\x10q\x8c\x92\xf0\xbf\x83(4\xae\xccB\x0c\xc0\\\x86)\x15\xe0\xae\xe1?M\x0f\xd0\x94\x19\x9f\xea?k\x9b\x8c\x1fq\xd7\xd3\xbf~\x87\xc2\\(\xfe\xf3?\x05\xd8\xech.<\xb5\xbf\xa2\xa5\xc0hi\xc8\xec?P|\x1f\x85a8\xe7?\xe0\xc67\xf5\xab-\xe5?ou\xc7\x8e\x16I\xf0?:v7@\xdf\x81\xec\xbf4G6#\xd5\xf5\xd0?\xd0\xbe\rT\x12\xd6\xe3\xbf\x0f\xb7\x12\x98U\xdb\x0c\xc01?\xa8\x84x\xb3\xff?\x05w\x11\x17pq\xb0\xbf\x12\xf8 \xcb~\xaa\xf3?l9\x90!RZ\xd5?\x97]\x00E\xd4\xbd\xb9?\x86\xe9\x00\x13\xa1\xf8\xd0\xbf\x9e\xec@X\xbe\x9b\xf1?x\xce\xf9\x07\x10\x1c\xce?m\x03\x9c#,\xb7\xec\xbf\xa8\xb0C\xa1\xac{\x00@\xd1\xb3\xe7\xe8@\xcb\xa9?\xc2~y"\xb2"\xdd\xbf\xf4\xa8<%\x0fR\xeb\xbfPD2A\xe2\xd5\xd6?"JZ\xc5\x14\xa8\xd9\xbf\x8c^\xd5\x06\xdd\xdd\x05\xc00\xebT*/\xe6\xed?\xfc8\xccb\x17X\xa9\xbf\xc2\xebC\x15\xf2\xa2\xe1\xbfX\xf6\x9f\xfd`\x1e\x00@\x9a\x96\xe9\xef\xc8H\xba?\xf9\x06\xe9\xec\xa4:\xe0?]\xf1\xe0\xbcQ\xe9\xfb\xbf\xeb\xc3\xdf\xd8n\x80\xe6?1\x97\x12\xda\x83x\xf5\xbf#(bWK\x7f\xf3?\x96\xa4\'\xe4\xc3`\xe6?L>U3\x1dn\xe4?\x1d\x82\xbe\xed\x0b\x1e\xb0?\xca\x95Y+\x18\xe0\xea\xbf\x04\xdc\xe7\x8en5\xd7?\xc8?\x93\xe5e\xec\xe4\xbf\xb8^\x16\xcb\x83\xd9\xe8?\x8a\xb5\x16\x07\xa5\xb5\xbd?\x04\xfd]@\xd0V\xdb\xbf\xac\x88*\xf5Z\x86\xc5\xbf\xb3\x1b\xe8g\x03\xd3\xc0\xbf\x10\xafZ\xf5`f\xf9?(+i\xf7\xdc\x86\xe0?Mx<\xa9\x05x\xc9\xbfY\xd8\x05\x9cTd\xe8?&\x95\xf7\x04^4\xfd?\xb1\xc7,O$\x94\xc7\xbf\x19\x1a\xc5\x1eg*\xe8\xbf\x05w\xd4\xe2\xe1\xb1\xda\xbf\x9b\r\x8f,\xab\x7f\xf6?Q\xcd\x13y!%\xe7?\x8f/\x1bQ\xce\x16\x03@T\x08\x93\xfc\x9b\'\xe1?\x92\xaa0\x81\x8e,\xe3?yb\xe2\xb2\xdbU\xf0?\xc5bY\xc6\x1bN\xee\xbfm\xd7\xb18Y\xec\xe8\xbfY\xa9?q(\x89\xe8?\xe0~\xe2\xa0\xcf\xd5\xe7\xbfX\xd7\x98eU\x92\xdd?\xf6\'\x0f0\xeeM\xd2\xbf!`F\xe5j\x81\xe5?R\x96\xc4\xb5\x94T\xdb?\x02\x0e\xe5C\xc7\xa0\xf3\xbf@*&a*$\xb0?_h\x9cq,\xe2\xf1?a\x8d\x8c\xcb\xb7\xab\xd2?\xb9=\xe78\xf0\x14\xea\xbf\x11\xfe\xbd>g\xf8\xf0?\r\x0e\xf7%T&\xc7?\x1euD\x9b\xaf\xab\xd1?\x01\x7f\xb6W\x06\xaf\xd8\xbf\xe3c\xc0\xe9\x049\xf8\xbft\x16\xe5a\x14\xae\xd7?\xc1\x14c\xda\x8c\xaf\xdd\xbf\xe7\x9d\x17\xab\x07\xa4\xec?X7c\x7f%\xb5\xee\xbfSV\xee\xcc\xf1\x04\xdf?\xaa\xd3\xaa\x18\xa3\x96\xd7\xbfN\x82\xda\xbd\xcc\xbe\xe9\xbf`9\xc7\xecO\x95\xb1?\xecf{*\x14\xb6\xdc?\xd2\x9b\xfc \x97\xb2\xdf?J\t"\xb0\x93\xcd\xf5\xbf|\xc8K)w\x80\xf1\xbf\x1f\xb7\x00i\xf0p\x05@`(\x14=VX\xd3\xbf\xaf\xaa\xfdP\xa2\x8a\xc2\xbf\x9e\xe4\x8a\xf6\xbbK\xe4\xbf\r\xd8R&-\xbf\xf7\xbf\x84A\'a\x94\xe9\xd0\xbf\xa6A\xe9_t\xdb\xf4?`\x07\x1aj\x0e\xd3\xea?\xdeU\xaeI\x96\xc8\xe0\xbf\x8ff2\x99\xfd\xd8\xc2?\x92\xa7\x16\x03P\xd8\xdf\xbf\x87\xe3\x14\xbf\xbc\xf2\x02@\x9c\xe5\xc32\xa6X\xea\xbf\xd6\xef\xc6S\x1b\xb3\xd4\xbf,\xc7O~\x8a\xff\xff?\xc4\xe9\xbd\xc7CB\xd3?\xbd\x19\x1b\x93\xa3\x16\xe7?\xe7#-\xe96P\xe6\xbfs\xd4IZ\x8b\xf6\xd3?\x85\xf3isk\x8f\xe7\xbf\x06b\xbd5T\x07\xe7\xbf\xceL\xa7\xd9x\xa5\xde?`\xba\xc7\r\xe5\x87\xd9?\x96%P\xdd\xaaD\xe4?@\xbc\xd6H\xb3l\xe6\xbf^>K\xd9\t\x0c\xe7\xbf\xc4\x8bz9\x9c\x1c\xf4?K]K\xc4\x84\xe3\xf5?\xbf\x85\xc6K\xfe9\xe3?SDM\x1a)\xe9\xce?XV=L-\xc6\xf9\xbf\x99\x84\x8cc\xbbz\xf0?6\xa2\x1c\x98\xd8\x9e\xec?\xdf\x9c\xc2\xcbZ;\xe3?\xa3;\x9f\x987\xc0\xf7\xbf\xac\x01\x1b\xeb9\x9a\xe4?\t\xdce\x9f\xe1\xff\xc5?D\xdb\xe2\xfc\xe3<\xe5?\xd7\xbb_i\x9b+\xb4?a\xee\xf6\xb9pr\xe0?\x83\xfa\x9d9\xd1\x17\xd4\xbf,\x0b\xe57\x8d3\xd8\xbf\xa3Tc\x921\x0e\xf6\xbfN\'\xe1.\xd0\xdc\xdf?)\x98\x85\x0e\x1b\'\xe3\xbf+ \x873\x8d\xee\xe1\xbf\xb1f\x8a\xb8f\x06\xe8?\x9c\x0b\xce\x83\xd6\xa8\x9e?\xbd\xb6a\x90I1\xff\xbf\xb7h\x9b~\xf4\xe1\xcb?oQ\xae\xac\x17\x85\xda\xbfe_\xe3b\xd9\x8f\xf2?\xdd\x14F-M\xf3\xd0?\xcb\x80\xb2\xcb\x9f*\x02\xc0 \xc3\xabx\xdc\xf4\xc2\xbf\xc9\xb7\xb6\xc0\xcc\xc2\xe1\xbf\xfax\xac a\x8b\xf2?\xd4\x9a\xeb\xec\x02p\xb6?\x8cz\xc4\xf6\xdf+\xef\xbf\x9f\x8c\xecE\x0b\n\xfd?+"\xc8c(s\xf9?\x88\xae\t\x925\x0b\xe1\xbf\xce"\xbdZ\xe2\xc9\xf2?\xdeg5\xb2+\xd3\xfa\xbf\x9e\xf5\xf5\xba\xb6\xed\xbe?\xedg\xb2\xf3\xad\xad\xd6\xbf\x8d\xa6\x87\xc3Wy\xcf?b\xfaCZj\xca\xb7?\r\xd0\x81\xae\xb3\x9c\xe1?-\xf4\xd2\xda\xcb\x1b\xe4\xbf\xbbU\xdf\xe5\xd9\x12\xfd?8\xc4\x8e\x819\xe5\xde\xbfka\x94\xddO\xf4\xe1\xbf`\x02N\xb2E \xe4?\x7f/Nt\x96\x9e\xa0?\'\xb9\xe3w\xe7\x1f\xc3\xbf\xa4F\xd6*\x0e\xba\xe1\xbf\x9f\xbc\xc4\x86/\xcd\xed\xbf(17\xf3\x04t\xf1\xbfm.\xbaL\x95\xff\xf9\xbf]\xe6_\x04\x82\x84\xe0\xbf\xec\r\xb2\xf5\xc7\xaa\xfc?\x0c\xe8\xc9p\x16m\xbf?\xc4\xcf|h:\x04\xfb?<\xa1\x98\xac\xc7d\xe5\xbf\xf2\xd6\x9ep\x92V\xeb\xbf\x18!\xce8\xcby\xd7?\xdfL\xe3\x02D\x8f\xe0\xbfd\xb6\x87\x9c(\x98\xc8\xbf\xabf\xc4\xbd\xe3\x89\xdb?E\x1b\x10_4\xb1\xfb?b\x95\xcc\xb1)d\xfb?\xc0\x12G\xb3^0\x04@\x8f\xd0U`\x04\x9d\xb1?I\xc5\xc7zt\x17`?A\xe8\x1d~.\x97\xf8?\x83\xfb\xdc\xecRX\xb7\xbf\x07\x1c,\r\x17\xb4\xe2\xbf\x9f\xee\xe7\xbf\t\xb2\t\x9c\xb9\xa0\xc9\xbf\xbd\xc0:\xffk^\xeb?:\x07\xe6\x0b\xe4\x05\xb1\xbf`\x13\xd4x]\xc0\xf8\xbf)\xa6\xfa\x89\xa8e\xf8?z]\\\xa5\xec\xb6\xf1?\xc0\x9d\xd0z"j\xdd\xbf\xe6\xe9:f\xdbw\xc0?\xdf\xa8\x8eh\x89\x9f\xed?\xd6C\xe7aO\x07\xea\xbf\xb0\x99Ju\x1f\x96\xe7\xbf/\xae\x9fc\xd5\x86\xef?\x96p\xe0\xe9\xa1\x0e\xfc?\xa6\x96\xac\xb7=\xa1\xe7\xbf\x0es\xa2^rs\xfd?\xf5\x8e\xc3\xbcB\xbd\xef?~h\xc2i\xaew\xc4?3\xb8:vF+\xe0?\x96\xc8\xb2\x0e\x90\x99\xe8\xbf\xa7\xac9\x0f\xb4>\xd4?t\xa7\xedU\x93t\xb5?\xed\xd5rlkN\xe3?\xbe\x13U1\x9d8\xdb?\xde\xb9h\x8e\xc2\t\xe7?\x14fzXs{\xb7\xbfA\xb4\x16\xfc\xd2\x98\xd1\xbf\x8c\xdc \x03R\x0e\xb9?\xda\xee?\x86\xc7\x9b\xe5?\x11m\xfd\xe1\xda\x8c\xf0?\xdc\n\xd1\x841,\xe2\xbf[2\xa7Psh\xdb\xbf\x04?\xfb;!\xc8\xd5\xbf\x91\x99\x83\xa5\xe9i\xc0\xbf\xec\x048\xd5a\x17\xd8?\xbes\xd0X\xce\x91\xe7\xbf\xa4\xc6L\x01\x99~\xfa\xbflb\x16\xe3b\x1d\xd9\xbf\xd4\xf9\x84\x8f]\x9d\xf6?\x1d\xf2\n\xd3K\x91\xf1\xbf\xe7\xe1Z\xe9\xd6m\x00@/\x95\x84\x1a\x93M\xe9?\xa9\xb1\xc1=\xa5\x84\x05\xc0\xe7.\xc6Z\xb9\xac\xc4?=\x9c\x00U\x80\x19\xe4?q\xedx\x9e\x06P\xda\xbf\xb7Z\x07\xf0\xe5+\xc4\xbf\xd2\xc7\xef\x1a\xech\xf4?\x97\x82\xd5\n\x143\xf8?pb\xa4\xc8\xa3\xa9\xe7?\xf8\x7f\xbc|\x88\xd9\xf4?\xa0h\xa7\xca\xf0\t\x03@\x84\xf23\xa4\x0e\xae\xd0?\xbbO-W\xffG\xdf\xbfw!l\x17\x95\x16\xe3?\xac\xad\x82+z4\xe8?n8\xd7\xf8u\x08\xe3\xbf\x05\x0c\xa6kq\n\xf9?\xe6\xfb\xde\xdc^\x93\xc1?,N\x85\xc8\x8c\xd9\xe2?R\x94sJ\xcaF\xe1?\x86\r\xa3\xee\x97\x9d\xfa\xbf\xb9\x9d\xf9\xdfX\x02\x00\xc0@\xff\x9f\xa7;\xa5\xfc?\xe7d\xc1\xb3y\xf3\xf1?\xd1\xfc6A\xcc\'\xec?\x08\x12\xbfK\x80.\xdd?\x87y\xddOJ\xe8\x01@L\n\xa0V1a\xcf?\r\x9f\xa1\xb5Qw\xd4?\x9c4\xeb\xe7G\xe1\xf0?\x0c\x92\xf3\t\x922\xe2?]j\xb0*D\x98\xf6?\xb8\xdd\xce\x92:\x82\xfb?\x92\xf3K\x84\r\x9c\x01@\xf7L\x0b\x85\xff\x88\xcf?\n\xc4\xfb\xda>(\x00@XD\xd2\xf7\xd9\xe4\xc0?\xa8S\xdc{w\xaa\xbd?\x8c\xe9\xbf\xf6\xa1\xc0\xa3\xbf>\xd7\xde\x95\xb8\x1c\xd3?\x11es\x02&\xbe\xf0?\xa2\xa0\x97\xe2\xa0\xd3\xd0?\x04\x11\xd1\xdd\x9c \xec?\xb3\xc5\xd4\xc9~L\xd6\xbf\x19Ex\xfcT\xa3\xf1\xbf\x96\x81\xb0{\xf20\xd3\xbf0\x9a\xc3Q\x85F\xef?\x80ev[\xf6\x9f\xe4?\rU\x98[\xfa\x08\xdd\xbfoN&x\xe0\xca\x0e\xc0.\xc4P*H[\xda\xbf\xdd\xb9?\xbc\x7f4\xaa\xbf\xae\x07\xb2<\xa0\xdb\xa4\xbf\x136\xf4\x07\xea2\xb7\xbf)\xb7\xb7\xd5\xe0C\xee\xbf\xa8\x9d\xa5Up\x04\xf8?\xac\xdf?k\xd6\xab\xe8\xbf\x033l\xc1>\x05\xc4?\xb7w\xabW\xc3}\xe6\xbfb\xfc\xee\x02\xa6\x85\xf7?\xb3\xf1A\x0c\xcd\xc5\xe7?^\xb8\x9f\xf5\xae-\xbf\xbf\rG\x8d\x91\xe9\xfa\xe2?\x0e\xf9\r\xef\xa6\xb1\x04\xc0~\xa6\x12XO\xcb\x0c\xc0\x8brb\xee\xc7V\x07\xc0\xfcbhE\xc4~\x01\xc0\xc7uO\xec\xc8V\xf8\xbf\x06\xe3\xaa\\\xce\t\xee?_Q\x8fm\xbb.\xf1\xbf\xb7\x7f\x07w\xdf\x80\xeb?c)\xb8\xbe\xf8\x16\xb2\xbf&|\xb3\x81\xfa[\xdb?\xf5\xbe<\x86\xfcb\xf4?"\x18\x93W\x01\xdc\xfb\xbf\xb0\x98\xb6\xf9\xc8\xc8\xf3\xbf\xf5$y\x90D(\xfe\xbf\xa0GU_\xdd\xba\xed?\xc7\xf2\xd2)\x04Z\xd8?1\x16\xe7\xa0\xccE\xf5\xbf\xe7K8\xff\xdc^\xe7?6P\xe4g\x07E\xdb\xbf\xe3\x99\x9c\x87\xd4[\xfd?\n\xf0\xe1\x9ea\xc3\xe3\xbf\xc9\x90\xfa\xa9\xa9\xd9\xf4\xbf\xc1\x8c\n\xbf\xd63\x03\xc0\x9e\x06 `\xb4\xd4\x06\xc0\x87.K\xe8C\x1a\x03\xc0\xb4\x7f_\xf0\x14\x8c\x06\xc0+hP\xc2r\t\x15\xc0\x05\x0eJ\x82n\x80\x13\xc0\xee\xce/)\xb5\xf5\x0c\xc0\xf4\x8f\xec\xb7\xbfA\x0c\xc0.\xd2B\x8a\xf0g\x13\xc0\xe1\xf6\xec\x8f\x8d=\xfe\xbf\xbb\xc0>A\xef\xbc\xf2\xbf\xe3\x08/\x06\xe9n\xeb?I\xa9\x8eh\xe3\xc3\xe8?\xe7tyS\x89\x0b\xe7?c\x03\xb2\xbc\xff\x84\xe1?z\xd4\xae\xf6N\x8f\xf1?i\xddm9.T\xfc\xbf\xf5\xb8\xf84\xf0*\xf3\xbf\xe0\xc7\xc0\x03\xe6z\xc5\xbf!\xd1\x85\xa0~\x10\xee\xbf\xd4\xe5\x17\xb3\xce\x14\xf3\xbfs\x0f\x9d\x8f\x17H\xc8?\x9fMrx\xe1Z\xf7\xbf+\xa69\x1fS\xe4\xed\xbfA\xdeg\xb5\xcd\x8d\xd7\xbf\x95u\n\xa9\x93\xdb\xdb\xbf\x81 \x04\xb3\xb7\xd4\xbfE7J\x95\t,\xfb\xbfn\x91\xdd\xfa5\x87\r\xc0(\x1b\xa8M\xca\x92\x06\xc0\x11e\xc3D\x0cP\x17\xc0\xb8\xf5~b\xefj\x15\xc0\x86\xfd\xcd\x9e\x1f\xb7\x1e\xc0\x7f\x02\x889=\xfa\x14\xc0O\xb0\xafM\xc7\x1b\x15\xc0\x8c1\xd5\xd2*\xbb\x02\xc0\x01\x0c\rWO&\xdd\xbf\xd5\xf6!\xa1P\x15\xe9\xbf\x93_\xbcx&\x18\xc0\xbf\xab3\x18@\xdcg\xe6\xbfu\xe6\xc3"\xf2\x8e\xe1\xbf\xbb\x12\xb6.\xc5\xcc\xd7?@=O\xd2\xb2\xac\xf4\xbf\x8bOq\xd8\x1e1\xf1\xbf\x19\xef]\xf1\x18Y\xd1\xbfc\\\xb4*\xa2\xaa\xe5?\x15\xf7r\x8e\x93\xfd\xbf?\xd4%\xcf\x05\x8c\x90\xc6\xbf\xe1Z\x8f\xd5N\x95\xf5?j\xf1\x8b\x18k0\xc9\xbf\x81\xf4\xdf\xbf\xe6\xa5\xe0\xbf9\xa28{\x0c\x05\xf9?\xd0\x8e\xbf\x8a\x17\x14\xde?\t\xd9\x01\x8e*\x82\xee?n\xe2\x80\xc1\x9fQ\xe0\xbf1\xae\xb0\x14n%\t\xc0\x86\x86\'->Z\x16\xc0\xbf\xa4\xa4^w\xe7\x13\xc0s\xa7YJ\x8ew\x16\xc0\n\xa8\x99\xc99\x0c\t\xc0\xba\xa7\x97\xb2O\xdf\xea\xbf.LP\x8b\xc8"\xd1\xbfan/\x99&\x0b\xf4?\x88\xc6\xc0_\xc2l\xf4?5X\xaf\x14\xcfB\xf6?\xb69\xf5\xbc6\xaa\xad?~\xb9\xcfL\xc3g\xae\xbf\x1d\x9d(s\xfe\x96\xcf?n\xbc\xfa\x97n\x12\xe2\xbf\xce\xe6\x9c\x07\x89\xaa\xf1?\x84\xf8\x14\xe1\xc2\x0e\xc5?\xde\xaay`\xa93\xed?\xc1\xd3>g\xaf`\xbe?\xf0\x8dF\xc6+\xcb\xee\xbf7a\xb1\x99\x04|\x04\xc0B\xbf\xafU\xbf\'\xe7?\xdf\x85\x05\x9c\n\xd3\xd1?\t\n\xf3E\x94\xa6\xe4?\x8b\xdch\xfb\xa9\x07\xf8?\x9f\xcbh\x92*#\xf0\xbfN\x95H$\x85\xda\xe4\xbf\xff\x11^\xb4E0\xcf\xbf\x0f\x81\xdb\x99O\xd0\xc0\xbfL\x17\xbd\x18o\x91\x0f\xc0\x99L\x03*;\x8e\xfc\xbf\x84\xea\xf2\x95\xf0\x91\xff\xbf\x1a\\\x04\'\xf8\xc7\xe2?}\x01\xb9\xa1\x90\xa2\x01\xc0a\xce\xf3b\xd9G\xfe?)\xd1\xbf\x18\x14\x1f\xdf?b\xb3S\x04^0\xc6?\xe3\x84[\n\xf0\xbb\xdc\xbf1\x15\x82\xc1\xc4Q\xf7?:\x00\xba\x1d\x11\x0b\xed\xbf\x04\xd7\xa8\xb7fY\xc3?\xd8Ihm\xdd\xe5\xa5?\xae6\xeb\xac\xc7W\xa6?\x1bJ\x05\xf0\xea\x8c\x9d?\xf3\x80H\xc6\x00\x8d\xf0\xbf\xf4\x87\x85\x92\x0c\xd1\xe4?$\xddW_\x15\xf7\xdd?\x990\x93y\x89\xce\xd2?w= m\x89c\xca\xbf4\xc9N\x8b\xeel\x03@#<\xff\x04N\'\xf8?\xba\x18\xbe\x19\x95\xf3\xf6?[V\xcc|@M\xeb?[\x9ct\x93N\xde\xb2\xbf\x01\xdd\xf3\xdc\xd8I\xd5\xbf\x9f\xfbe\xe2z\x8e\xe3\xbf\xddRw\xf2\x16\x81\xcb\xbf\xfd\xdc\xf1\xfb\x94\x1e\xe0\xbf{9\x8d\xf6@{\xe8\xbf\x93\x07\xad\xf7v\x10\xf4?a\x1a\xe2\xbfN\x8d\xe2|\x16\x04\xf4?kt\xc6\xac\xf7\xf0\xf2\xbf\xb4\xf8\x8e\x04\xef\xed\xe3\xbfc\x8cg\xc2\x04;\xee\xbf\xa8\xda\x9c\x1d\xca\xe5\xe0?\x0b^w\xc6&\x11\xd9?v\x01\xdf\xac(v\xc9?*\x94\x05M\x95\x9c\xd0?\x16\xd13P\x80,\xb4?Gjq\xb7S\x7f\xd0?\xee7\x90\xdc\xce)\xe8?>\xd4\x0eO\x02]\xf2?l\xcbV\x03\xf9\xe0\xd9?\x99)Y\x9a4\xf1\xf3\xbflKt.\xebF\xf7\xbfb\\\xde\xba2\xbc\xef?L6\x0b\xf9\xaao\xe5\xbfx\x0e\xda\x92\xef\x9f\xf9?\x8e\x00\xc6\xe0~\xbc\xf4?*\xcflRL\n\xe6\xbf\x93\xf5&\x97#\xa7\xf6?\xa2k\\\xe8\x1a\x0f\xe6?\t\xa1\xe7\x86j\xbf\xe6?\x08\xe9\x89\xf73\xe2\xe0?\xd6\x8f\x15\xee\xb5X\xf0\xbfy\xf1\x97:\xfbT\xe5\xbfy\xc3\x97\x8e|\xd1\xe2?U\xe4-v\xf5=\xf4?-\xff\xe05\xeb\xb2\xf4?H\xf1\xf7\x10T\xd6\xe1\xbfW\x1a\xf0\xbf\xf5\xcb\xcf?T\xc7d\xbf\x02y\xdc?\x1f,\xa8%\x08\x19\xda?\x1cF3F\xbbJ\xec\xbf>\x17\x18p\x85\x8a\xe4?\x10,"*s\x91\xcc\xbf\x99.~tQ5\xe4?\xa2\x9b\xea7\xca\xb9\xf1?\xddz-\xac\xafi\xe4\xbf\xe98\xf7r7\xc9\xe2\xbf\xb4\x1b\x1a\xf5\xea\xce\xae\xbf\x0f7\xc2\x9d\xd4y\xf1?\x88\xa9{\xbc\x05\x9f\xb3\xbf\xdc\xad5\xd2\x01\x15\xd4?\xab\xa9K\xb6\xb3\xe4\x8e\xbf$)f\xeb\x89\xd8\xf6\xbf1>@\'\xf0\x84\x02@\xdf<"4\xf5\xd2\x06@)\xbb\xbe\x18\x93M\xf4?WR\x15\xc5\xa9(\xc2?x\xbf\r\xb3\x16\xc1\xbc\xbf\x9b\x05a\x83k\xf7\xd0?\xfb\xc4,\xac\x8d\xd7\xe5?\xd6f\x954\xb8\x19\xe4\xbf\x16@\x87o\x8b\xf6\xd8?\xae\xe8dP\x82\xc5\xf3?\xd1\x9b\xa2\xa6B)\xdb\xbfN\x1bM\xac\x1f\x03\xf6\xbf\x13r\xcba`z\xe2?\xfb\x1c\x03\x7f8\xc9\xcc\xbf\xe1/\xe7\'3\xc05?"\r\x9a\x01a\xc6\xee?\xb4\xd1\xb3\xf8r#\xc5\xbf\xb0n\xce\xbe\xd2\x97\xd0?d\x10\xaa\xcc\xc7\xec\xe3\xbf\xda*\xa7\xe1Q\x9c\xd0?\xc1\xa9m}\xab\xc6\xe9\xbf\xaeo^\xf7\xc0\x8c\xe8?\xda\xa0\xc2\x1f\xb4\xc4r\xbfJ\xca=YS\xa3\xc7?\xe2\x94\xe4\xc1\xcf\x1c\xc9\xbf\xfb\xf4\xa1\xcdL\x90\xc3\xbfv\xc1\xcf\x08\xb4\xe2\xea\xbf\x1cu5L\xba0\xe9\xbf\xa75\xaf\xf9\x08\x1e\xd2\xbf\xd2\xe1%\xb1\xcd4\xf1?Q\x8cF\x02B\xb8\xfb\xbf\x02\x19|9z\x8a\xd9\xbf\x80\x92\xaaEq\xaa\xc7?.\x9c\xd8\xbd\x8f\x02\xd3\xbf\xf7\x82\x8fg\x82V\xe5\xbf\x9fU\x0eU9\x83\xe9\xbf-\x08$\x8b\x89\x1e\xfb?\x9a\x01-\x03/\x84\x07@\x87\xcd\xcfm\x19\xc4\xf2\xbf\x19\x01N&\x15\x84\xe4?=R\xfb1p\xef\xe1?;2\xccgU>\xe3?\xacu\x89\xdcA7\xeb\xbf\x99P,k\xbe\x86\xd7?\xf4\xc8R\tr0\xe6\xbf\xb8\xb3\xdc\xd9f\xb9\xe4\xbf\r\xbc\xa68\xfd\xc0\xde\xbf\xec2i\x0bHX\xe1?%\xde\xb2A\x98\x9a\xe1\xbf\x0f\xc80\xa0\x00\xaa\xc0?\xbd\xbaZYF}\xbd\xbf\xe5TK\x04\x89`\xb1\xbf\x97\x89\xc5!&[\xf0?\xca\xd4\x89\x1a\xe0\xff\xd7\xbf\xc7\'\x9f\xc6z\x7f\xe0\xbf\x0b\xeb\x8a\x0c\x0f\xbb\xf4?ll\x03\xdc\x02\x8c\xf5?\xa7\xa8\xcd\x8d\x93\xd7\xef?\x9d\'Y\xbc\xcd\xce\xd7\xbf\n\xd0!\x02\xad\xfd\xe5\xbfK\xab\r\xc0D\xd9\xbe?\xf8,\x0e\xe5\x89e\xe1?]"<\x8c\n\xfe\xe1\xbfnz\xd4\xab\rJ\xf4?\xd0\xdb\xc0\x10\xd8\x1d\xce\xbfY\xfe*\xcd\xa2\xb5\xe9?\xbc2\xa7\x022j\xfa?\xc0{e\xe8YX\xa5?AF>h]\x85\xf6?\x81y\xce\x89av\xee\xbf\x7f\xaa\x0e\xbd\x0b\x8a\xf2\xbf^\xce\r\x82X2\xdd\xbfN\xf2\xda\\[3\xe1?\xf7tf\xa9\xb4\x1e\xcd\xbfm\x96\x07\x04\xf0\x80\xab\xbf&>\xff2\x1b\xc0\xdc\xbfR*\xaf\x8dH\xcc\xce?\xa5\t\x13\t@\xaa\xb2?2v\xec\x16?\xb7\xa7?\x17\x8c\x87\xfa)/\xf0?V\x1b\xcbr|\xa5\x87?\xf3\xbc\xd0?r\xbc\xb0\xbf\xab\xc6\x0ca\x7f\xa3\xe1?\xf3\xafj\'\x9e\x13\xc9\xbf\xff\xd5\xfc\xe8\x03u\xeb?U\x121\xdd\x95#\xec?\xb9\xb0C\xf1\x08(\xeb?.\x90\xc4r\xd1o\xe8\xbf\xe6\x07\xd5^\x91A\xc7\xbf\xa5\x7f\xe0\x86\xb0\x7f\xd2\xbf\xee\xe9\xfb1s\x84\xf4?Jk\x1ak#\x16\xbe\xbf\xc7\xd1F_\xde\xa6\xc9?\xcaRs;\x1f \x84\xbf\xfcS9=\xd8\xa2\xf7?\xab5`\x86\xe6\xee\xeb\xbf`\xd4nfw\x87\xf1?\xca\x9a\xdc\xe9\xd6\xe7\xe3?O\x8d\xa8;\xf4)\xf2\xbf\x9a\x10\xea\xe0R\xe7\xf0\xbf7EpG8\xe1\xde?\xc3\xfdX\xd1\xdem\xe5\xbf\xa0\xdcwBc\x98\xea\xbf\xe7\xc3\x02\x1b\xdd\xf7\xcf?xO2\xcc\xee#\xb4?]Z\x12\xb0Q_\xea\xbf\xa5\x9e\xf5D1\xff\xf7\xbfLU\xb0\xe9=X\xe1\xbf&\xda\x95\x81*6\xf5\xbf\xfd\x0f\x14}\xf0\xca\xf6?\xd7\\\xe7>\x95\xca\xcd\xbf9d\xff\xe3c\xc8\xed\xbf\x02#\x9d\x17\xa2\xec\xe3\xbf\xb0h<\xf5\xde\xc5\xe0?\xcbc\x12\xa4\xceH\xeb\xbf\x11P\x12A\x0c2\xec?\x07\xc3\xd9+\x809\x02@s\x02E5\xf5C\xc9\xbf\xd8S\x16f\x92{\xf1?\xb69\x99\xbb\xe5V\xd8\xbf\xaf\xce\x92\xe2\r\xdb\xe3\xbf&V;\xc4\x04\x0b\xd6\xbf\xf8*\x83\x82l\xd6\xf8?\xdfcp\x82\xad\x18\xe1\xbf\xba\xe6%\x0fH\xd2\xd4?\x00\xa0\xadi\xed\x13\xb9?z\xc7a\x9eWT\xf4?\x8fzp\xf01t\xde?B}\xae\xd4\xbd=\xdd\xbfVZ\xaaU\xf1B\xda?\xc7V\xb8mk\xee\xc7?\xff\xf6\t\x17\x91\xa9\x82?\xc0\xc9\xfc\xda\xe9;\xdf?H\xb0\xeeimM\xf4\xbf[\xfcw\xa8\x90\xf9\xd6?\x88\x90\xb3\x10\x9b\x81\xe1\xbf\xa8[\xd1\xeb\x94l\xf4\xbf[\xac\xc3P\xf9\xe6\xe3?\xd8\xbb\xdc[\x82\x9b\xcd\xbf\x0e=.\xf8\xaf\x85\xf1?\xc3\x89\xf6\xea1#\xb2\xbf\x82\xedD\xb1\xac\xe9\xc2?\xd6\x9e\x88\x9f\x16\xf6\xe1?.\x99\nG\xc45\xff?\x16uGMWu\xd6?\x86\xbe\x01U\x8c\xcf\xb5?e!k\'\x1c\x00\xe5?t%p\x92\x06\xbe\xe1?1\x121\xbd\xcf3\xea?\xad\xe0\xfb\xcd\xc9U\xea?\x99\xffF9\xd1p\xe3\xbfv\x96\x1b\xb8\xaas\xcf?<\xe4-\xee\x8f:\xf1\xbf\xb9q\x8fFN\x8e\x01@n\xdeP\x8a\x9b\xae\xce\xbfoG\xb4\xf8}/\xf1\xbf\x8a;\x8b+\x9e\xe2\xac\xbf\x86\x1cB\x90\xa8\xc3\xcc?\x96\x1c\xe5\xa9\xe0\xd5\xd9\xbf\x9d\xfb\x9eV\x0e\t\xf1\xbf\x8e\x1a\xe4x\xc23\xc5\xbf\xd0F\x14\x87\xcb/\xfd?Mu-\xd7\xcb\x85\x01\xc01Nh\x8be\xe4\x04@O\xf6&\x18\xa3\x1e\xf8?\x1eu3\xc5k|\xe0\xbf>S%\xc3[\x1e\xb1?\x01{C\x0cM\x04\xe6\xbf\xe7\x1e\x1c\x1c{0\xe3?s\xff%\xc9\xb3\r\xef\xbf\x9c\x13(\xeb\xedD\xde?CX\xbc\xeb\xf7?\xed\xbf\xbd_\x0b\xba\xa5{\xbb?\xd9\xca\x97\xac6\xf4\xed\xbfqZ\xc7\xfe,\xe2\xf7\xbf\xb9\xb8\x9c\x1b0\xe4\xe4\xbf\r \x12\xb2=\xa5\xbf?\x08N\x93~\xa5<\xfa?\xb8\xd0!\x1dU\x05\xf8\xbf\t\x08O\x95\xa6\x17\xdb\xbf\xa7\xb8\xd2\xed\xa9\xbe\xe2?\x93\xa2\xe9\xfa\xa8w\xd9\xbf\x93\x1bt\xab\xe3F\xf8\xbfOQ^\xfb\x18|\xe2\xbf8\x85\x7f\xef\xb8\x0e\xe5\xbfg\x86a\xa8n\x08\xf1?\x0f\xc4\x9b\x900K\xf7\xbf\xb3\x03\x7f\xd1\x95;\xfa?\xac\xa5\xa68\x0f\x95\xf1?u\x951\xd6\xbfX\xe5?\xb6\x13\xeel9\xae\xf0?Ra\xc2h\xb7\x16\xe8?)]\x10\x87\xe8\xbe\xfc?\x87\xcd\t\xc9m\x0e\xf5?)\x9c\x04\xc5\xd1\x96\xf6?\x84$HVD\xc5\xc3?M\xcc3\xb9\xdc\x0c\xd5\xbf\xe1\xb8\x12\xfa0\xe4\xda?\x1a\x17\x81}\x96-\xec\xbfs\xd2~\x93\x8cF\xfa\xbf\x03\xb3w\x07\x14N\xef?;\xe2|#+\x86\xe2?\xdb\xde;\xa6\xf8Y\xd7?\x93h\xd4L[\xd0\xf2?\xbbT\n\xd1\xdb\xc8\xcc?\x18\xec\xe6\xaa\xd5l\xf3?m5]VC\x8b\xdb\xbf\x16\xec\xf9\xba\xbf\xd3\xf2?\xbd\xfe\x8c\x03\x85_\xf1\xbf\xa2\x82\xf5-\xf0\xd1\xea\xbf\ri\xbd\x03\x90C\xe3?\xcd\x01\x9d\x80`e\xd2\xbf\x88G\x0c\xfa\xd9g\xde?\xa2O\xa3a]\xdb\xba\xbfDD\xa3\xd4\x17)\xc3?\x08\r\xfb\x15\xe7\xe3\xdb\xbf\xf0\xa3\x1e\xbc\xc7\xbb_\xbf\xf0\xe8\xe3\x1d\xa3\x97\xb8?\xe2y\xd8\xe7\xdf=\xe4\xbfS\xca\x91\xc9\xa0W\xd5?\xc6"RV\x8bu\xed?\xc5\xbch-\x10*\xc9\xbf\xd9\x92\xb8C!\xb6\xe8\xbf\x13\x92sl\xda\xab\xf1\xbf\xa0\x1e\t\xf5\xeb\xbe\xe8\xbf\x83\x87\x15iR\x7f\xcb?x\xec\xd0\xd2\xc3\xe8\xc3?\xa2K{\x94\x81;\xe7?\x1f\x15}6\xf2O\xec?\x12\xa2F\xd6\x89k\xf2\xbfAmB\xa3\x14\xed\xdd\xbf\xcfV\x87\xb7Q|\xe6?\x9e\x1d\xbfv\xa0\x04\xe2?\xe2 \xe4\xff\xea3\xf4?\xf7M\xd4X8\xca\xdc\xbf\x8d\xf9\x84\xa1z\xe4\xe6?\x0f\x04\xaaO\xb1I\xe6\xbf\xc2\xd2\xc8\xc9p\xfd\xe5?\x896\x8c`\xe0z\x02@\x8a\x03p!0\xaa\xee\xbfl\xb5\x17*2\'\xd8?o\xfd\x9fBD_p\xbf\x8au\xe2\xc1\xc7M\x99\xbf\xa4\xab\x19\xbd\x03\xe2\xd4\xbf\x03\xb4H\xf2i\x7f\xcb\xbfJ#0z\x0ci\xf3?\x81a6\xf4\xb3%\xe9\xbfK\x0f\x82\x17p\x8e\xe1?\t\x1f3\x14s\xc4\x00\xc0\xe9V\x00j\x9f\xf3\x97\xbf]Gd\x10h\xeb\xe8?\xc1)k\xf2?\xd1\xea?8\xb6\xe7\xc9\xe2\xf7\xe1\xbf\xc8,5\xd4\xa0?\xf3?\xbahc~\xe0\x9e\xd3?TP; \xf4\x92\xd8\xbf\x84`\xc7\xb5\x1b6\xa1?f\xc4\xf5%\x91\xd8\xf3?X\xeeW&\xbb\xe9\xdb?CYh\xdb\xe5(\xe0\xbf\xfd1\x1f7\xdd@\xeb\xbf\xfd\x9d\x15=\xa6\xd2\xd9?&\x99\xc4Rm`\xe2\xbf\xa6\xc87@\xb5\x92\xf0?\x14\xa1\xe1n~\x1d\xfa\xbf\xd9".\xab\xa3\xea\xb5?%\x14K\'T{\xd9\xbf\xe6Pz\xd4\x8b\x14\x8e?\x12\xae\x81=M\xe9\xc0\xbf\xa8\xab-\xb7\xdbE\xf5\xbf\xa7C=\x8a\xaaU\xc5\xbf\x19Y\x93\x9a\xc4B\xc7\xbf\x97\xb5\xd85G\x18\x04@|\xa9N\xa5\xaa\x83\xdd\xbf\xaas\xfb\x88=\xaa\x86?\xfeP\xd7z\xa2\xc8\x02@\xa0\xbd7&\x7f\xef\xde?\xdapRO<\xaf\xf2?\xfc,\xd9\xd8\xa9r\xaa\xbfq\x85f6\x89\xb0\xa0?$\xe1\xe2\xac\xc5:\xe8??\x83\x02\xbbt@\xe9?\x8e\xa4\x1e\xd7\x0f\xe3\xdd\xbf-_\xa6MfU\xf0\xbf\x85_X\x8e?\x1e\xd9?\x15\xa6t\xc5\xa5\xf7\xe5\xbfCT\x8fge\x00\xe2?\x14\x14\x89\x94va\xcd?H^eS8\xab\xd3\xbf\x98~_\xe9>8\xdb?q\xf0\xe4\x9f\xb8\xb3\xce\xbf\x082\x87\xb1\xe6\x1f\xed?\x18\t\x8a?\x8f\t\xe4?\xde]i\xf6\xd3\xcf\xd7?\xa1\xb9m\r\x91\xb1\xec\xbf\xd4\\\xb9#m\xac\xf7?\x15\tg$_<\xf6\xbfus+f\x00\xa6\xe8?\x9e{2\xd3P\x0f\x81?\x0c\x12z\x0b\x11\x02\xd5\xbf\xa5\xa0\x06]\x0c\x81\xf3\xbf}\xc11\xcc\x88\xea\xef\xbfm\xc1\xcdQ\xfb\x04\xf2\xbf6\xedu\x1f\xed\xa3\xf3?}\x90\xc5\xccK\x11\xb9?\x1a\xe2_}\xa13\xdf\xbf\x932\xb1X\r\xa7\xe5\xbf\xbf\x01\xe1\xcde\xce\xe1?\xdejfk\xba\t\xfc\xbf\x18P\x97\xf5U5\xe5\xbf2Bz\x04Ba\xc3\xbf\xc5\xbcS\xac\xab\x87\xf6\xbf\xb2\xa3\x96\x01\xfe\xb3\xfe\xbf{\xf0\x89\x0fo\xe0\xdd?\x1b\xc9\xb3\xed}\xca\xf1\xbf\xc7X7=e\x11\x00@\x15\xb5RcX~\xfc\xbf\xa1\x10Zo\x9a4\xc4?\xaa+\xe7\x81\x9e\x94\xe4\xbf\x12\x83\x91+`@\xe2?\x93!\x9c\x8f\x04\xa4\xdb?\xda\xc0\xaaP\x1c\xfa\xe6?\x07\xd5\xfe\x06\xad \xd0?\xbfqW\xbd\x83\x02\xea?n\xd4tt\x8d~\xde?\x80\x0e\xa3U.\xaa\xf5\xbfF\x04t\x86\xd78\xd7\xbf\x16\xa5\r\xba\x0f\xdd\xfe\xbf&\x9au\x18\x8fv\xea\xbfd\x1f\xef2=\x9a\xea\xbf\t\x89\xa5{3\x8d\xfd\xbf\x009m\x17hi\xea\xbf\x15\xd0\x0f\xba\xa3@\xdb?Y\xa4\x0c\xfd\xd5\xc1\xed\xbf\xf2\xb0\x99\xb2M\xf1\xdd?Zl\xaeg\xb6(\xe0\xbf\xc6t\xbb:\xe1\xdc\xfb?\xadV\x9ekb\xe6\xe5?\x89\xc9\xc4\x14\xd8\xff\xf5\xbf\x93mn\x0b\x0c\xf9\xf7\xbf\xf5\xcb0\xac?\xb6\xdb\xbf\xd9h\n\xe0@\xad\xd5\xbf\xe15t\xc0]\x12\xeb\xbf\xa2}hK}\xfb\xd1\xbf\xd4\x9c\x07\xa8\xbf\x9b\xd7\xbf\x99@\n\xcbH\xd0\xcf\xbf\xc7V\x13\xeelN\xf5\xbfm[q\x15\xf5n\xcc?Id\xa00\x99\xa5\xd2?\x98\x1f\xd1\xd3\xf8>\xf8?\xab_\xca\x02\xa3\x0b\xdc\xbf\x10W\xcb2\xea\x93\xce?\xab9\xdcF\xef\xa9\xd3?\x1fY\xaf\xfd\xf4\xf2\xfb\xbf\xb1\xd2\x84\xa6DL\xfe\xbfD\x1c\xff"\xe8\xad\xfe\xbf\xac!\xd2g~\xe7\xf8?\xf0\x85\xfb\xa8\xaer\xea\xbf=\xda\x01\xd7\xa0}\xfe\xbf1:\xbe{\xf5+\xea\xbf\xc6\x9c\xc5\x81\xf2\xbe\x08\xc0\xf4\xda-wi\x10\x01\xc0\xf5\xd9`.\xb0^\xc0\xbf\x18\x8b\xbe\x82\x0c\xcb\xf7?\xddY\x01\xe4\xc5\xa6\x91\xbf\xdc\xef\xdc\x89\xef\x81\xec\xbf\x13\x1e a\xe7\x8e\xd9\xbf\x16\x8c\xcf\xf8S\xb3\xd6\xbf\xb1\xe2\xa83\xa0n\xe4?\xbfw\x03\x8d\xa1\x0e\xf9?\x93\xf0\xad\x14I\xf0\xe4?\x01:\xffL\xb3\xf5\x8f\xbf .\x00\xa2\xf6f\xcf?\x10\xa6i\xe9\xa2\x0c\xdb?N\xe8\x93=:\xfa\xf0?\xc3J\x06\x91\x8fF\xd5\xbfE\xc3J\x14m\xd3\xe6?e[b\xb8\xe6\xe4\xf1\xbf5\xa0&,\xb36\xe0?\x04\xc1V\xc01\x1c\xe8\xbf\x1c5\xac/q\x85\xf2??\xd0~\xf5\x82\x7f\xd8?\xfa\xee;/w\x8a\xee?\x96\x89\xe5\x87ns\xf0?D\x8b\xae\xe0D\xf0\xe4?\x82S\x10\x02p\xcd\xe0\xbf\xadz\xe05\x0f(\xd9?!;\xb3\xcb\xe8\x9e\xba\xbfV\x12\xbd\xdf\xaaW\x94\xbf\x10R(\x17)(\xf6\xbf\xf2\xff\xbd\x18\\\xe0\xa6?\x18\x0e\x88\xef\xbe\xc4\xd2?\xa8/?V8\xf5\xec\xbf\xb9\x12\x1et\xaf\x82\xf5?\tNj\xc6Z^\x03@5\x80\xd5\x9c\xd2k\xc1\xbf\x8a\xb93\xa1\xcb\x88\xeb??@\x8b\nNO\xd1\xbf\xee\xef?\x0cL\x9b\xf1\xbf<\x9e\x94\x0f\x96\xb4\xf2\xbf:wlL`\xe4\xfb\xbf\xf4\xd0\x00\x1d\x8d\x12\xf2\xbfV\x94v\xa7\x8e\xec\xe8?Rlc\xc6M\x86\xe5?r\x87B\xed\x1e\x1a\x9f\xbf\xc1\xc2\nU2\xef\xf0?|*\xd9S#i\xd2\xbf\xc3\x86\x8cM0\x0c\xd4?8ZF\x0f]\x80\xf4?\x94 I[\x89\x8b\x00@\xa3\xf4\x04\x95P\x82\xd3\xbfl\x9e\x86\x8fkQ\xd3\xbf\xe6\xc2\x13\xc9.#\xe1?\xd7\'\x90\xe2\xff\xd6\xbe?\xbe\x0f\xde\xd3\x18\xc6\xfb?\x03m;g\x16\xc2\xd9\xbf\xe4&\xb7\xc0|\x91\xdb\xbfX\xca\xbe\x8da\x8d\xe4\xbf\x1e\xfdT\x88\xc7\x93\xf4?9\x16\x05\x83\x8fE\xc6?\xdd\x92\x15\xbbX%\xf2\xbf\xf0\x17\xc2\x06\xce\xa0\xa4?\xb4\xa0\xe9\x85\xf3\xd0\xfe\xbfK3\xcb\xa3\xbb]\xf9?"\xfe\xa7\x16|\x04\xf0?R\xfe\x1b|\'u\xd1\xbf\'\x8e?u\xde\xfa\xdc?q:]\xc1\x14\xf0\xeb\xbf8\x9e\x04\x1e\xfc\xe6\xf0?Y\xe7\x86\xd3\xa0\xa1\xed\xbf\xc2Z\xb0\x1c\xde\xb8\xe7?\xb3J\xb2\xd8\xe6w\xee?\x93\xe1\xd2#\x83\xc0\x04@_\x81K\x11\xab\xd3\xd7?\xa2\xf9G%\x14\x9d\xd9\xbfw\xc87_D\xe0\xe4?\xad\xaa\x93(ZT\xe0\xbf\xdb\xe5\xf9\xeb@\xb1\xe5\xbf\xca\xed\xdf \x80e\xde?pj\xba\xda@Y\xe4?F\x9d\xe2\x86\xad\xca\xcc?\x1e\xda\x99\xee\x15*\xf6\xbf\x92Z\x03axu\xed?\xb7EX\xef\xa7|\xe2?8\xaa\xb4\x8a\xc6V\xe8\xbf\xf2S>z\x80J\xea?"t\x8a\xd3\'B\xe4?\xd1T[\x8d\xa2\x8c\xda\xbf\x9f\xbfr\x0c=\x96\xea\xbf9\x0e\x87\xd4\xc3\xde\xf7\xbf\x17\x1brwoM\xc9?OnV\xde\xcbR\xd0\xbf\xaf\xb8\xa57>\x1e\xe7\xbfO\xb9-\x95.Z\x83\xbf60\xdc\x87\xd4\xff\x03@v\xb5\xf62\xdfw\xe2\xbf\xb4CL\x14f\x05\xcf?\xbc,\x9f\xf1\xb6\x95\xd7\xbfo\x8f\xfeyE\xe1\xf7?t\x19P\xf2\xaf\xf3\xe3\xbf\xd2\xe4\x1c3?/\xf5\xbft\x0f\x18\xe0\xf9\t\xf0?\xa0\xff\xedk\xe4\x82\xf1?\xc8\xe7\x83U\xd2\xa8\xbb?\xc9\xc3;W\xd3e\xe4\xbf\x82\xf2(\x87F\x88\xd0\xbfH\xfc\x92%Z=\xd6\xbf\x8a.p]\x93\x92\xef?\xce\xcc\xd9\x01\x83\x18\xf6?\x17\xd6\xaf\x9f"\xb2\xf0?\x7f\xc0\xe05R\xb1\xd2?\xd3Vl\xc0\xa7\xa0\xf3?D\xa3a\xe0\x84\xe7\xeb?4\xdb&\x1e\xe5%\xeb\xbfw\x1d\xf7Qw\x11\xe6\xbf\xbb\x85\xb9\xbc\xdcO\xe9\xbf\x1akX\xb56\x05\xf9?\x95\x1a3\xca\x93=\xec\xbfLg\xd2\x13\xd9M\xe5\xbf\x16\xe5P\xdeT4\xb5\xbfE\x83T\xe4\xab1\xe8\xbf\xc1\x94\xba\x89\x91\xf5\xbd?\x87\x1f\xe5\x1a{\'\xe3\xbf\xd9\xd2\x0cp\xcdD\xfe\xbf\x8d\x82\xe8H;\xac\xfa?)\xf3\x8b\xc9\xfe\xf6\xe2?\xac^\xee\xfew\xd0\xe2?u[\xd2\xd3\xfbJ\xec\xbf\xe5\xf3\x04\xc3\r%\xb6?1.\x9fe\x04\x83\xdb? k\xa3N\x87\xa0\xf4\xbf\xcb\x15_T\x86\xd3\xdb\xbf\x18\xd3\xb4\x97\x931\xf8?\xf1rb\xb7\rW\xc0\xbfse\xdf\xf84/\xeb?\x02\xc95\xc0S\xe9\xc2\xbf\xb8W\xc9\xd2\xa8\xcd\xe2?_h\xb3\xf5\xc0U\xbf\xbf*M\xf7R5\x93\xde?\x99\x0f\xda\xaeX\xd9\xdf\xbf-`k1\xbd4\xef?\xa1\xc3\xa4\xe3\x1cw\xe4?`\x86\x11l;~\xf2?\xd1\xa0\x17y\x80\x0c\xeb?\xac\xbf+\xa4\'T\xcf?\x95\xa7\x90cW\xa5\xc0\xbf\x00*\xf0\xceT\xb5\xb4?\x02\xb8$a\xde/\xff?ahI\xd7\xb1\xf4\xf1?\xe7b=\xe2\xfa!\xfd?7\xdd\x16\xba\xf36\xf5\xbf\xa4\x1e\x0b\xb9\xd97\xdd?\xaa\xda\x8b(#\x8d\xd9\xbf8\xf3Y4F7\xc7?\xdbGI~\xe8\xf4\xf1?\x97\xca\x90R\x14z\xc0\xbf\xdc\xb2\xe8\xab\xe2?\x86\xc5N"\xd2\x1c\xf0?\xe7\x98\xc3\xd5t\xe0\xde\xbf\x18\r\xb2i\xbdJ\x01@\xad\xbf\xb7\xb9l\xca\xe8\xbf\x17\x19\xa1\xbc\xdb\x1a\xf6?v\xe0@4d\xd6\xec?$\x11\xce93\xa0\xde\xbf\xb5=\xfcu\xfbS\xe7\xbf"\x14\x18\x8d\x1f-\xd9\xbf \xd6\x0fm\xa2(\xe4\xbf\t\\\x10\xdbPt\xc5\xbfiN\x05\x14\xfa\xbd\xed?\xe9\x8fY\xa3rE\xd4\xbf\xb5\xddc\x96\x87[\x04@L{\xd5?x\x8a\xf7\xbf\x84\r\x89#}U\xe5?\xe1\x93\xbd\xe8}\xea\xdd\xbf\xa5\xaf^\x0e\x90%\xe0\xbf\xc6\xf7\xef\x8e\x87I\xe3?XE\x1f\xe2\xd7"\xc4?\xa7\x04\x15\x96\x8fz\x9f?\xbeh\xaf\xdf\xdb\xa7\xf3\xbf\xcbN\x91\x9c6<\xe4?\x8a\xca\x0fv\xda\x92\xe0\xbf\xcf\xd4_\xb0\x9e\xcb\xdc?\x02E\x12\x16\x97i\xf0\xbf\xfa\x89qt\xc4\x06\xf4?pDaW\x8ac\xd5?Gp\xcc\x18\xa7\x05\xf0?\xaaR\xa9\x06[\xd9\xdd??a\x1f\xbbS\x92\xf9\xbf\xc0pr\x046.\xff?\xdd\n\xde\xc7u \xc8?Wb\xa5\xbbr\xed\xee\xbf\xc6RI\x1d\x8f\xea\xf3?{s\xc5\x1aM\n\xea\xbf\xb2\xe7n\x17\x05\xd3\xf1\xbf_\xe5~\xa8 X\xea?\xd7\xe4\x19\xf1\xc1\xd8\xe4\xbf\xa0\x97\x97\xa7_\xdf\xca?@\xaf\xa8p!\xd7\xf0\xbf\xf8\x81#\xa9\x98\x1b\xd6?\xa1\xc5\xaa\xc7\x9b~\xe4\xbf\r56C\xe6\xba\xe5?P\xc1\xe9\x96Z\x9d\xe7\xbf\xd9\x12\xee\x172\xf7\xe1\xbf>\xe2\xb0L\xea\x9d\xe3?\\\xbe\x88(L&\x07\xc0\x11OE\x92\x81?o\xa1\x85x\xde\xa0\xd0\xbfp\t\xf9\x1at\xa2a\xbf\xd52\xd1Cp\xc6\xe4?c\x87D,\x06\xb1\xed?\xde`\x8f\x8a\xbc\xbd\xfe\xbfkR\xb0\x1e]\xd4\xdf?Q*\x98\xc2\xf2^\xdb\xbf8\x0e #\xd9D\xf2?\xb1\x05H\xe3\xb9\x8e\xd7\xbfH7\xc2\xf7\x8f\x8a\xce\xbf\x10\xdf\xaf2\xa2\xb7\xe1?\x18\xeb2\xd25\xb6\xda?\xfblwn\x98\xb3\xe9?\x91\xc0b\xd6\xc9\xa0\xe0\xbf\x8b\x7fh6=\xcf\xb1?/\x8b\xec\xdf\xbf\xe5\x04\xc0\xc0\xce{\x8e\xaa\xd1\xca?\x96r\xc9\xae\xbc\xd1\xc3?\x86b?\x99/\xc1\x11\xc0\x06J\xf9\xba<\xe5\xec\xbf\xd8O\x05D\xde\t\xea\xbf\x0b\xd2q\xde=\xb7\xe3?\xa5\x7f\x05_\x98<\x07\xc0i\x07\x1b]qZ\xee?\xfbw\xdd\xd4\xc0\xe0\xf7?\x10G\xed\x84\xd9\xf9\xbc?.\xc3\xc4\xaa\xd7P\x02@\xd0\xee\xfafDy\xe6??\xe4R\xf1L\xe8\xe0\xbfl\xbb\xe6K\xb3\xe4\xc3\xbf\xf2\xfc-E\xd1~\xe4?\x07\xb9\x9a\xe0\xa2\xe2\xd7\xbf/c\xf2)`a\xe0?\xc2\xbctK9O\xd4\xbfezI\x85\xf4/\xef?3\x87\xa0\xc3\x16\xa7\xe6?\x83\xc22b\xc1\xb5\xe4\xbf#\x87\xcd\x10aw\xec?\x1a\t\xe1T0\xfa\x04\xc06p\x11\xdc\n\xa1\xe2?,#\xb8\xde\xa9J\xd2?\x97\x01\xdf\xb3F\xdd\xf6?,tk\xb5\x83V\x00\xc0+\xda\x92\xfb`\xf8\xdb\xbfk(\xe6\xcc\x0e*\xf1\xbf$\xbfE7\xe7\xab\xef\xbf1x~D|\xec\xfc\xbf\xd7\xdaU\x11\xf2\x8b\xf1\xbf\x0c6P7H\x81\xcc\xbfg\xa0M\xb2\xa4\x1f\xf1\xbf\x1b\xc8\x9e\xb29\x00\xf2\xbf?\x95\xbd\xbd\xf7\xd2\xde\xbf\xc8\xde\x03\xa7m*\xf1\xbf7\xc6V\x14\xeax\xe9\xbf\xd8)y\xd54\xae\xf2\xbf\xad\r\x19\r\xfa\xee\xc5\xbfk\xa7\x0c(\x8f\x89\xfc?\xfd\xaf\xc8\x0f\xaa\xbd\xfa?z]\x7fo8\xeb\xb7?\xab\x95\xc5\x82\xae.\xf3\xbf\xd1\xbf\xf4\xb4\xb8\xf8\xec\xbf\x0ed\x86\x9b\x85\x87\xe0?\xbf\x0f %\x94\x0e\xee?\xe9~\x05\x98l\n\xd9?\xb7\xd6\x15\x868.\xca?\tT:\x97\rQ\xc9?\x8d\x02\x03l\x12\xa1\xf1\xbf\t\x0bL\xb8w\xcd\xea\xbf\xd0#N"\xdcZ\xe3?\xc0\xd4\x07\x08\xc4g\xb1?\xac\xaa\xa4\x9b\xfd\x99\xc6\xbf\x8f\xac\x15\xc1d4\xdb?\xea\xcaX\x8fs\xcd\xd5\xbfL\xc8\xd0\x0bxv\xff?\x972\xa9l$\xfa\xe4\xbfC\xf7\xd0e\x11\x92\xe0\xbf\x04\x0cN\xa7\xd8(\xfb\xbf\xaf\x9f}&?\xb6\xdf\xbf\xb9J\xa7\x13\xd8A\xf8\xbf\x1e\x88\x81_\xa0\xfd\xe2\xbfd\xc2\xb1Z\xefQ\x01\xc0\xeb\xc1\xd6m\xfe:\xe7\xbf]\xd2\xf7\xe9\xf5.\xf5\xbf\x887o\x01z\xee\xf6\xbf"\xd7+\x95\x11\xde\xcf\xbf\xc3\xaf\xb3\'\xc4\x04\xf3\xbf\xa3bb\x9e\xc3_\xe2\xbf(\x1d3\xe7\x19\x8c\xda\xbf\xbag|\x91\xf5\xae\xe4?s\x1e\xb2\x86\x9d&\xf4\xbfo\x1d\xa4\xf0\xb1\xf4\xba\xbf\xae\x00\x06f\t\x88\xff\xbf\x0b;\xf6X\x10"r\xbf\x89b\xc1\x96l\xc6\xe1?\x17\x8e\xc4\xc5\xd6\xf7\xe7\xbf\x17\x1f\x7f\x95\nb\xe0\xbf"\xa5\x9f\xcc\xd7\xbb\xe4\xbf\xa1\xfc\xdb\x1a;\xc0\xa7\xbf=\xe5\x97\xb1\xe8\xc6\xec\xbf\xda#\x84$\xdc\xb1\x03\xc0]\xf9\x9c\xbb\t\xf4\x00\xc0\xb2\xd17=\xdb\xa1\xcb?w\xfae\xd6\x94\xfc\xd5?L\x1a\xb4\xd9\x8eE\xf7\xbf+\xe5\x01\x9b\x87y\xe9?\x8f\xa2\xab\x9e\xae!\xf5?\x86\xc5uf\x0fC\xfe\xbf\x97\xe165B\x8d\xaa\xbf\xee\xa7f\x1c;\xa5\xe4\xbfAHF\x9a\xb7\x1b\xf3\xbf\xe4i\x80xf\xba\xf5\xbf\x97j\xb6\x83\xb6U\xe4?f\xb1_Y\xc38\xe6\xbf/J\xcc\xd8\x9d\xfc\x01\xc0\x15\xee.\xc5,\x9a\x00\xc0\xcc\x91\xf8\xabR\xd8\xf5\xbf\xffR\x17\xe8\x99 \xe4?\xec\xe8\xa1\x15+\r\xa3?k\xe6\xb9\x14sc\xf4?\x86\xa1F\xe2\xc9\x19\xba\xbf\xd9\xdaq?6\xf7\x00@\x04\x12-D/0\xa7\xbf~p\xa0\r\xb6n\xcb\xbf\xb4d\xc0\xa3\xa3v\xe0?\rJ\x89\n;\xc6\xc7\xbf\x94\'?E\x00\xb4\xc8?B\x0f\x9e\xbd\xcd\xda\xeb\xbf\x18Am}\t\x19\xf8?\x9f\xaa\x84\x17qw\xe8?\xdbk@\xcf\x81\x9c\xef\xbf\xbd\xb6\x14>De\xeb?\xea\xb2\xfc\xdbl-\xe6?\n\xcc&\xb2\xf9\x15\xfd\xbfB\x94\x05(\xed\xcd\xc7?\x07_\xf7\x9e\xb4_\xf8\xbf\xe3\x99\xb2Al\xa5\xfa\xbf\xe2\x8ds\r\xd8e\xf9\xbf\\O\x89\xfc\x88\xa5\t\xc0gB\xa5U9\xa9\xff?\xb2OY\xf8\x01H\xf7?\x91\x9c\xea\xa6\xefW\xec?\xe5\xe6\xae\xea\xfcz\xd4\xbf*\x88\xfd\x1d\x1fJ\xfe\xbf~\xe9E\x88\x18\x01\xe9\xbf\x9d\xdf\x1c\x85\xbc\xec\xc9\xbf^RI\t!f\xf4?\xc5\x8eg\x90\x94~\xd6\xbf?>aU\xcf\x9c\xde?\xe2ju\\\xae\xd5\xd0?\x01\xbd\xc1\x05\xff\xe0\xe9?\x07\xec\x9619\x9d\xf6\xbfbx\x9e@Z5\xe4?\x8b\x0cW=\x13\xbe\xec\xbfR,H\xcf\x9f\x89\xfe?)j\xda\xaaR`\xf9\xbff\xc9\x84\x81\xa6\x99\xe8?\n\xfb\xd7\x97\xa1.\xc8\xbf\xad\xeas!L\x10\xe2?\x8b\x80\xdb\'\xfaJ\xec\xbf\xa3]\xc11\xd3\xbd\xf7\xbf\xee\xc6\x82\xaa4\xa0\xeb\xbf\x17[\xa4\x7f\xfbu\xf2\xbf\\\x18!vPo\xe2?\x17\xf63Q\xedr\xf0\xbfQ!NE\rK\xde\xbf\x02~dF~\xa1\xc0?\x12Gn\xc3\xac\xd0\x03\xc0\xc6\xcd\x95< [\xec\xbf\'\xb6D\x9b\x08p\xff\xbf\xa4(\x903k\xba\xc0\xbfgvo\xa5\xa9\x07\xfa\xbf\xf2^\xb6=\x92\x1b\xc0?\x15\xdd\xe5\x9d\x83\xbe\xf5\xbf\xe2\x96\x12\xb4\'Y\xd8?\xe3w\xec\xcd\xd5\x92\xe7?\x19VZ7e\xaf\xb9\xbf\x88\xf0\x9c\x91\xe2\xd8\xf9\xbf\xdc\xcc\xb9V\x19\xf0\xd7?Z\x04rR\xd4\x83\xf1?,\x93\'I\xe7\x91\xdc?\x8b\'k\x81\xd5\xb4\xe1?\xf1\xd8\x03\xe6<\x1e\xcc?\xa3m\x01\xcc\xe4d\xfa?\x0b_\x96\xf8\x0b5\xf1?\xd5H\xb7\x14+\xc6\xf2?B\\\xa95\xd3\x9a\x90\xbf\x9b\x90\xdc~fV\xf6\xbf\x8dKP\xb2,t\xf9?J\xecT\x82\xfa\x93\xe3\xbfi\x7f\x92\xdcX\xae\xf3\xbf>\x0b\xd8\xa7\x19\xb2\xe2?\x02@i\x0f\xe5\x03\xdf?\x1ev\xdb\x0f\x0b\xa4\xe3\xbf\x7f\x9b\xb8\xb4\xc5\xb4\x06@o\x03o$\x02\xa3\xfe\xbfm\xf5\xe1\x00\xdfQ\xf1\xbffi\x07@\xee8\xf9\xbf\x03\\\xe4\x17\xef\x1d\xf9?\x83\xc6\xe7~\xfb\xba\xfd?\x0e\xa3X\xc8\nx\xec?=\x0e\xec\x05\xe9\xf5\xdd\xbf\x8a\xb6\xc9\xca\xfd)\xfe\xbf\x9d\x1fq\xde\xa1h\xf4?\xafF"\xf7\x81\x01\xe8?\xe4\x84\x96T>E\xd4?Ps\xc8\x0c0\xe6\xf0?\xda[6\\\xef\xe4\xe3?r=;\x90hh\xef?\x06h(V%Y\xe0?hi#D\x9eE\xe6\xbf2>F\x82;\xcf\xcd\xbf\xd8\xbe\x84\xb0\x91<\xbb\xbf\x05\x1dtV*\x03\xee?\xf8\xe4\x86h \x05\xe9\xbf\xaa3\xa1.\xde9\xfb?\x0e\xbb\xb0MxI\xee\xbfg\xaeT\xfd\xcb\xb5\xd9\xbf~y?5\xa8\xf6\xe5?\xf2\xb0\x92\x8eN\xb4\xf2?\x01y\x8c\xb4\x94\x90\xf7?\n\x91\xd1\x9a\xa7\xa3\xb9?5?\x14\x06)\x97\xf0\xbfp\xbc\xaf\x95\xf8\x7f\xf2\xbf\x18\x13\t\xbceB\xd0\xbfi\xda\xfeO\xca \xf7?d{\xba\xdb\x8ej\xec?\x00+\xb7\xb4\x9b\xf5\xf2?\xc9d\xa9?v\x87\xd3?\xd0f\x81\xdd\xee\xa4\xf3\xbf\x13\x89po>\xc5\x0e\xc0\xe6\xb1*\x82\xa1\xf6\xe0?\x14\x17\xd0\xbdN\xcb\x00@\xa2\xa0\xd4\xe5i\x81\xe5\xbf\xac\x9bx\x80\xaf\xcf\xf4?\xd7\x8b\xacV\xfc\x82\xf2?\xb8\xe4m\n^\xa4\xf1?\xbb\xca\x02A\xf1\xe6\xd2\xbfe\xa4\x80\xbdf4\xe6?\t\xd7C\xacK\xdb\xdd\xbfr\xd2\xa5p\xd0\xe0\xa0\xbf\xc6/\xdf\xac\x84/\xe9\xbf\xcd\x18$Q\x87\xd4\xe0?\xc3\xa1aPM\xf6\xd7\xbf\x80\x9c\x1a\xaa])\xf8?\xce\x1b^vB4\xb7\xbf\xcc\xd94}SL\xdf\xbf\x19\xa1\xd3^;\x85\xdb\xbf\xa5g\xee\x88\x95\xfa\xe5?\xb0y\xcd\xe5?n\xe5?~\x91b\xa7\x94[\xe9?\xa2\xdf\x9e\xba%\xc6\xfe\xbfU\xd6\xe6\rED\xf4?\xea\xa4\x18\x03\x07\xc1\xf5\xbf\x8c\xb2\x11\x98\xcam\xf0\xbf\xa2\x87\xb2dpK\xf0?@k\x11K\xbf\x1b\xee\xbf\xde\xe5g$m9\xf0?\xd1\xb43\xcfA"\xcf?\xae\x06.\xaf\x98\xe7\xe0?~S\xec\xb9\xab\x9d\xf2?\x96%\xcf\t\xfc\x99\xee\xbf!\x14\x80\xca4\xfd\xd4\xbf\xb0"&\xbe|\xd8\xd3\xbf\xe7r_K\xe63\x01@\x06\xa5\xff+\x14\x03v\xbf\x05\xe1\xed2jf\xed\xbf\xeb\xdd\x1e$\xe1\x06\xe2?\x88\x84\xd4G\x9a\xe5\xc5?\x08\xb9H\x13ZW\xe2?2\xc6I\x9du\xc8\xd6?3\xa1\xe6\xb5\x95\x82\xf5?\x0c\xce\x81+\xf0\x80\xa7?\xfd\xd0\x93\xc0\xb6]\xeb?\xb6,\xc7\xac>\xee\xe8\xbf\xa3*\xd7O\xda\xc8\xdb\xbf\xb9\xbeJ\xee\xa4Z\x00\xc0k\xbc"\xbdb)\xf0?l \xfd/\xe2\x8b\xc6\xbf\x85x\xe1\x96g\xf3t?>\xbdFu\x96\xd2\xe7\xbf\x97\xf7\xa9\xc6\xfe\x16\xf8?t\xb7\xe3\x8a\x07*\xf7?m\x88a34-\xe7?\xe1\xb0l)%\xa5\xe3?\x07\xbf\x97\xf1\x88p\xe5?G\x1fq\xe3>\x01\xf5\xbf\x03\xfc\x8eJ2Z\xd8\xbf\x06\xe8\xc9\x04\xe2@\xf4?\t\x1e\xda\xbc\xf6\x86\xea\xbf\x813\xdf3E\x01\xfd?=\x87\x84\t\x977\xc1\xbfh_\xa2\xbd\xd8N\xf2\xbf\xfd\xb4g/\xc7a\x05@\x07pN\x80&\xbc\x00@\xe3M%\x1c\x81|\xfe\xbfB\xd8\x16\x0f_\xa7\xdf\xbf\x04\r+\xf0/T\xe0\xbf\xff\xfb6\xae\x1b\x11\xc2?\xfd\xea=\x93%\x94\xdc\xbf\x08\x9a\x96n\x93\xaf\xe8\xbf\x1f\xb4Y\xa5\x08I\xd9?\xbe\x8dp"\x94 \xba\xbf%LB\x18\xae\x0b\xd5?V\xbc\x1f2+h\xd2?\xfbb\xdcb|@\xd6\xbfU\x1e\x0fq\'\xea\xf5?\xd2\xc5m\xc0\xb2 \xe9?C\x017\x9f\xc8e\xea\xbfMQ+\x14B\xa4\xf2?\x92@\xde"\xe0 \x00@\xaae\xa2}\x1a\xb0\xe4?ch\x90FN\xa9\xbd\xbf\x0b\x98\xd0\xa1\x96\'\xb8?\xe0\x1b\x07H\x990\xd0?\xf2\xbaT\xc3\xe3\xe8\xdf?e\xd2\xd9xZ\x8f\xf2\xbfz\xf7\x0f\x00\x8d\xf6\xdd?\xa0\xf3\x12\x07\xe6\x90\xf4\xbfW\xdclm\xd4m\xc3\xbf\xcc\r\x98\xdaN[\xd7?\x94\xd6\x85B\x0b\xc9\xd5?\x11\xdc|\xc87\xb0\xe9\xbf\x81W\x90\x8d7\xe9\xf3?\xab\x1b?/>\x9d\xed\xbf\x10\x8d\r\xaf\x7f\xb9\xd3\xbf-\xed\x05F*\x14\xcb?\x9f\x04x\xb7\xfb\xe1\xe7?,\r\x1f\xda\x90m\xe3?e\x1f\xf0&*4\xe1\xbf\xa6\xaf\xd5:\xe53\xc8\xbf\xf3\xda\nK#\x9c\xf6\xbf\x91]c\xca\x00\x94\xd0\xbf\xfb\xe6\xd1lm2\xfe\xbf$R\x95~\xf8\xbc\x92?\xed\\\xeb\xddD\x95\xd0?\xdc\x97\x18\xf7`\xfc\xf5\xbfk\xe8s\x07V"\xbc\xbf_<\xef\x0e.#\xe9?\xbb\xf0\xe4k\x06+\xe1\xbfk\x0fV\xb3\x93&\xc5\xbfu\x80\xdf9 \x9b\xe0\xbf-[\xe1\xb3\x81\xeb\x05@Kuu\x87j\xb4\xf0?O\xc5)eO\x9e\x01\xc0L\xdcM\x12\xf3\x1e\xff\xbf\xecW\x87^%\xf5\xfb?CN\x1aV\xcd\xd8\xec\xbfJ\x1a\x97\xd5C/\xf5?S\x95\x82\x99\xbf\x04\xee?\x8c,\xec\x17\xf1o\xdf?\x94\xcb\x02Ady\xf5?\xcd\x9a,\xfabk\xd1\xbf\xa0"\\\xf4\x80\x96\xea\xbfn/\x96P;A\xc9\xbff\x99\xe0\x90\x01E\x01\xc0p\xce}\xb2@\x02\xf3\xbf\xec\xff\\\r\xa5<\xe3\xbf\xb9\x93\x82dJ\x8f\xcd?\x18\x8e$\xa5\x99\xec\xef\xbf\xa3\xa2BA\xa3Z\xd4\xbf\xfc\xee5\x06L\xcc\xe6?cZ\x07\xfcz\x90\xed\xbf\xf0^\xd6\x83\xe6\x06\xf9?&\x0f\xd6\xbd\xae\xa0\xf7\xbfL5\xaa \xe9w\xdd?\x18S\xb1#\x9cJ\xf3\xbf\xa1\xa7;3\x95\xf3\xef?\x0eq\xb0\xc1(\xbc\xe1??\xde\xe8\xc89\xec\xb4?N\xe4v?\xd3\xda\xda\xbf\x90p\xd3\xad\xcc\x8d\xeb?\x8e\x1eL`\x0e\xad\xe5\xbfh|=\x15\xa2\x88\xd6\xbf\x96\xa5(\x03hW\xc3?r\xe1\xe0(\x01{\xdd\xbf\x022\x01X\x0e\xa3\xdf?C\x06\xaf\xf4>r\xe7?\x00\xce\x8f\x80\xa8\xfb\xe4?\x95\n\x01{}~\xef\xbfN\xc7\xfa\x89|N\xf6?\xe8\x91\x04\xcd\x191\xc5\xbf4\x8a\x0bV\xa9\xe9\xf7\xbf)\xfa\xdd\xd3[\xf9\xe3\xbf\xba\x86\xeeV\xdbJ\xf6\xbf\n\xba\xf59\x1c\xc1\xfd\xbfq>\x01cr\xdf\x00\xc0\xda\x1c==\xcei\xfc\xbf}\xd0G\xb6Z\x1c\xf6\xbf\xcb\x81>\xcf\xe01\x05\xc0\x0c~\xc6\xb08\xb6\xe7\xbfg\xdd\xf9\x85\xaa\xe0\xe2?4`\xf6\x82\x03y\xd2\xbf\x0b\x9e\x83~\xc6\x9a\xfb?7\xe401\x9e8\xa4?s\x05\x14j\x10\xc4\xda\xbfo?\xe9\xd3\x08\xda\xf2?\x18\xcb\xd4\xc2\xef`\xf2\xbf.t\xeaFT\xcd\xe9\xbf\xecC\x9c+\xfdP\xac?\xc1\x1fq\x9a\xe6V\xfb\xbf"\xde\x82<\xe3\xbe\xfa?\xd3RI\x050s\xdb?W\x0b\x8a\xdd]\xf0\xf8? g\xec\x86!T\xc1?\x8d\xbe\xb0\x7f\xe0\xf5\xca\xbf\xe0G4t\x7fg\xdb\xbf[.\x0b\xd5Uw\xf1?6\xe36\x9c\\\x16\x89\xbf5\x9a\xec\xd3\x17\x81\xbb\xbf\xd3F\xd5\x8de4\xdd\xbfo\xa4\xea\x93\xba\xd3\xca?\xe91\xee\xc5\xaa\x9b\xe2\xbf\xbd\x91\xa9\xe3\xa4\xd3\xf4?!\xcb\xea.\xf2a\xea\xbf:A\x9f\x0f\x05\xb4\xd2\xbf\x12\x03"X\xc2k\xf0\xbfK\xd5\x0e\xc7M\xef\xe4\xbfy\xe8#\xbb\xbb"\xd0?\x01\xab\xee\xe5\xc6?\xe2\xbf\x9d\xd1$\x07L,\xf1\xbfE\xb5\x11p\xa8u\xee?L\x95\x99\x9b\x10}\xfe?x\xef\xc0>\x99&\xa2\xbf\x9aF\xad\xfa!\xe6\x07@G\xc3\xe4\xf8\x1d\x05\xfe?Li\xfc\xb6)\xe5\xe0\xbf\xbd\xedg3w\xa6\xac?\xd9\x1f\xb2\xc4\xaf}\x01\xc0\xca6\xed\xfc=\xf9\xba?\xe8\xfb!4\xc6\xf6\xea\xbf\x7f \x0b\xe0\xbaE\xe4\xbf\xc5\x17\x07Y\xdb\x84\xd2\xbf\xd2\xc1\xbd\xedgE\xe4?\xef\xc5\xcb\xab\xb5c\xd8\xbf\xff\xc2\xaa\x14#\xd9\xcd\xbf~\xf6\xa4\xda\x8f\x8d\xf9\xbf+l\x95\x80i\xed\xe6\xbf\xdc\xa1\xe3\xf7\xceH\xe0\xbf\xfdH\xf46\xf6o\xed?%\x84\xc1\xa3\x1b\x0f\xe2?\xae~\xfe\x9e-A\xe6\xbf?(\xf0\xbf)\xb9N\xf7a\xfb\xe7?\xf2\xf3\x08\x85G\xcd\xf4?=#:P\x93\'\x06@_\x99|H>X\x08@\x85\x11\xddzh\x04\xf4?_b\xa7\xc2>\xb5\xf6?O;[b]h\xf5?\xbf\xdb\xe5v\x9a\xeb\xf3?\x9c\xb0\x926\xa5\x15\xe1\xbf^6\xe5i\xa9\x83\xf1\xbf\xdc\x14\xd3C\xe3$\xf5?\x9d\xe8t2\xbc\xc3\xd0?\x16:L \xa9G\xbe\xbf>\x06og\xd7*\xe4?\xb1\x84\xc67|D\xc0\xbfj\x98y>v\xe7\xdd?Tp\x1a~\xaa\xec\xec?!\xd5>\xd6]\x15\xf1?A\xcf:\x8bR\xa6\xb7\xbf\xc8\xf8\xa2d\xdf\xc6\xe3\xbf\xca\x94\xb26r|\x8e?\xb7\xbb\xb7\xbd\x0b\x9a\xed\xbf\xa5l2;\x8b\t\xe3?\xd9"Pz\x9dF\x05\xc0\xcd\x15?\xa2\x96)\xea\xbf\x13\x04\xa4R\xefk\x01\xc0\xcb\x12cP\x9f\x05\xa9\xbfB\xa2\xaa\xefl\xfc\xad\xbf\x81i\xa7o\xeb\xa0\xff?\x05+1\x03A\xc1\x0b@\xa0\xda\x1e~\x1b\xa8\x00@\xc8\x17\x9b{,`\x12@\xcb\xa7\x99\xca\x03^\xff?\xee\xf3\xc5D\x0e\x82\xff?4\xad7\xfa\xdb\xb2\x08@\xfb\xe6\xe8\xbf.<\xeeM\xce)\xe8?Q\x9d\xa9}\x8b\xe0\xfa\xbf\x12T\xea0\xdd\x97\xce?=\xbc]\xf5\xfaW\xe3?\x04>g\x97\n\x08\xf1\xbfT\xe8PK\x0f\xda\xe4?\xce\xc6\xddu\x8e\'\xe1?\x0e\xb8f\xebY\x88\xe0?9\xe7o\xf7\xef_\xeb?\x8f\x9d\t\xcbzI\xf8?P\xd1\x8e\x07\xb08\xc1?\x80\xe6}\x95*\xcc\xdc\xbf\xce \xed\xaa\r\x0f\xf5?Hl9\xc2\xee\xbf\xf0?\xab\xc1\xba_y~\xec?tP\xddj\xd4\xbf\xec\xbf*M\xc5\x19<~\xd6\xbf\xcb\x17\xc4\x16q\x8d\xe7?\x8f\xf9\x9b\x0b\x143\xc7?\xdeg\xe5\xfa\r)\xe8\xbf\x11\x91$\xe5\xceR\xe8?\x93a\x9b\x18\xc2\x8d\xf0\xbfJT\x86HN \xec\xbf!B-\x02\xdd9\xf8?\x04QYQ0\xf6\xc0?\x9f\xab\xd52x^\xda?\xc4\xb61Iy\x87\xfc?\xf7\x82\x87\x1d";\xfe?\xd7@p\x9f\x85@\xd3\xbfw:\x98e\x84\r\xf6?\xbb\xc8k\x89j]\xd3?\xde\x01\xe4\x9c\xa9\x9e\x90?\x85\xfa\x8e\xd8\x1d4\xe6\xbf\t\xbc\x8c\xbf\xb9\xa5\xbd\xbf\xad\xa7Pq\x04\x0f\xf0?ql\x89G\xc43\xf1\xbf\x03\x1a\xb7\x938\x15\xf7\xbfY\xc1D^\x1brq?\xac\x1f\x118\x0b\x1e\xe5?\xc0#\xe6\xf6&\xe3\x00@L\xca\x9c-5;\xf2\xbfq\x1b\x19\x99\xfb\xdb\xfb?\x85`&\x82M\xad\xf2\xbf\x8b\x06\xe9q\x7f\x89\xcd?f\x8c\x19\xa7\xd7\xf2\x87?\x1a\'\xff*h\xc2\xde\xbfi\xe6\x9a\xee\xe9\x92\xd4?\x073>+!\x94\xc0\xbfR\x85\x13\xe0\r\x04\xdf?F\x07.\x9a\x1c\xef\xc3\xbfm"\'=\xe1F\xe4\xbf\x878\xa4R\x1f\xc7\xe3\xbf\xf8\x82\xdd\x9d\xb0\xaa\x9d\xbfg%\xaa\xfeu\x1b\xef\xbf\xa7p\xc3\xa2\x19\xad\xfc\xbfQEU,\xe4\x8f\xdd\xbfHQ\x95\xa8\x99\'\xde\xbf\xc9\xe9o\xee\x0fx\xd9?e\x14ec\x9aP\xe6?e.\x18.\xf8\xc0\xf3\xbf\x84sr}\x1e\xc1\xee\xbf%\xe4\x9c:\xe4\xbd\xb2?\nC}\xfb\xef\xef\xee\xbf\xe2\xa4u\xbd.L\xf4\xbf.\xdc\x0bvZ\x89\xd2\xbf\xde\x05\xb4\xb5L\xfa\xd7\xbf\xae\xd5I^\xfa\x07\xe4?\xbdB\x98\xd8\x0b\xa9\xd4\xbf\x1d\xc7/ \x81\x14\xc2?[\xf9\xf0\xa4\xcc\x04\xc9?\xa2\xd42\xb1A\xf1\xfe?\x1b)\xac\xab\x07\xb2\x85?\xfd\xcc\x84\x11+\xd7\xf9\xbf\x8d\xf1\xdfT\xfe\xea\xfd?\xed\xda!uz\xad\xf1?"\x89z\x9e\xb4\xec\xe2?\x1f\x1a\xeao\x144\xe8\xbfr\xf6\x88\x04\xc40\xea\xbfoQlB\xa0\xd3\xd6?7\xf6Z\x93\x1a5\xf4\xbf\xbe\r\x7fV,%\xed\xbf\xc5a\x0f5\xec\x81\xd8\xbf\xe6\xf1\xa8|\xbd\xca\xd8?\x11\xc8L}\x07s\xf4?O\x17\xa6T\xb2\x0f\xf8?\x18W\x89&\xa6^\xe7?\xf7\t\xd6s&\x8e\xd9?;z]\xdeu/\xf0?^ _$\x86\x19\xe1?\x8d\xe7dC\x8c\\\xda\xbf\x13\xeb\xc1\x1e\xa8\xe1\x81\xbf\x00"?\xfa\xd1e\xc6?_\xb1\x19\xe6\x81\xbc\xd6\xbfb\xe3r\xef2\x9a\xe5?C\x9c\x07Q\x07\xbd\x0c@\x15\xa2m\xec\xb4x\xf8?=^\x0b\xf8:q\xe1?\x8e\xc3G\x1e\x90\x8f\xee\xbf[\xd9\x13\xd2\xb8\xb4\xf2\xbfDx\x1fj\xd6R\xd8?\xd3\t+\x12y\xd7\xdc?\xb9~a\x91\xc1\xe6\xe3\xbfQ?\xab\x14\xfc\xe8\xea?\x0c\\f\xac\x97L\xe3\xbf8\x9e\x9b\x10\x08\xa9\xba\xbf.\xfa\xce\xa2V\xca\xe4?4\x90R17\n\xde\xbfb\x83\xa2\x8a\xcfU\xdd?\xb5\xcck\x94\x04O\xd5\xbfz\xc2\xee\t\xa8b\xeb?\xdf\xd7\xee\xfe\xa9l\xe0?\xa5\xffw\x10[i\xc8\xbf\xc8Y\x11\x94\xaes\xf3?l\x16T\x11@:\xfc\xbf\xa2C\x04\xd1\xb91\xfe?\x12Nix\xb0\x8e\xd5\xbf\xe3\r\x06\x0e%\xb7\xfa\xbf+\xa2\tJi\x0b\xf5\xbf\xaci}\xd4\xbew\xff?\xb0\x9b\xe0\xc2\xc0\x90\xd0\xbf\xea\xa85\x1a\xed+\xcf?\x19\xb7\xb3-)\xe9\xe0\xbf\xf4|\x18\xa6\xeeP\x07@\x1d\xbc\xc8Z\x97[\xe6\xbf\xa8\xab\x82\x92YM\xeb?\x16\xaf;2\x8c\x91\xc3?\xd8\xef\'\x9fz$\xf3?\xbb\xe2\x82\xeb\x96\xd9\xf1?\xaej\xd1"\x08\xa1\xd1?M\x16XJ\xcc\x96\xe3?C\xbb\xf8NWQ\xf5\xbf\x08\xe1{\xeaN\x03\xf1?\xe9{B\xf9\xe6\x07\xbd\xbf\xc1d\xac\xce&\x99\xdf\xbf13a"t\xc5\xf9?k\xb4\xe6\x7ft\xb4\xe5\xbfl\xf5x\xa0\xb7\xbb\xfa\xbf@8Cm\x87\xc1m\xbfj#\xbd\xe1\xef\xcb\xe3?h<\xbb:\x03@\xd6?\xaf\xb4m\x8f\xabP\xd9\xbf\xd1<7\x19x\xac\xf8\xbf\x0eS\xaa\xfe\xd5\xc1\xc8\xbf\xad\x86U>\x86+\xf9?\xe9K,\xf1\xba\x04\xc1?\x1dM\xc1\xb58\xf2\xf9\xbf\xc8a\xfc.\xa8\xea\xfc?\x83\x8b\x9a\xf0\xc2\xb1\xef\xbf\xd9&\xa8@\x03\x8c\xd2\xbf[N"\tE\xc1\xd2\xbf3n\x8eo\xd4\xda\xd5?@\xbd\xd8\x04\x0e\xeb\xec?f\xdc\x08\xfeh\xb9\xf4?V\xd2\xde\xe6\xcf>\xcf\xbfH}Hb6:\xd3\xbf.Z\'\xa9\xc1\xa6\xf6?(!1\xf5\x08i\xe0?t\xb57\xaf\xb8\xf0\xd8?\xcd@\xfc\xc1O\xc9\xf5?\x13\x0e]\x80\xdf(\xe7?\x96\x1dd$\xb6\xb9\xeb?n\xbc\tE\xb70\xf6\xbf\x89\x08\x95\xe3__\xe1\xbf\x80\x13\xdb\x1e\x8eu\xf5\xbf.XN\nt/\xeb?\x04\xd7J\xb7\xfdT\xd1\xbf\xfeK\xf7\xe3\xed\n\xf4\xbf\xa1b\x11n\x07\xe8\xed?E3\x14\xdcR\xe6\xed?o\xd0\xa2\xc6\xa5\xad\xe1?\xef3\xb6\x863\x05\xee?W\xac\x96\x83\x8fk\xfa?2QzS>Z\xda\xbfa^\xf9\x94\xdd \x01@\xd99\xff\x91[}\xf5?\x84\xf1\xd5\x00\x91\'\xee?\x14/g\xf8\x85\xc7\xe4\xbf\x1d\xc2b\xf1vC\xf0\xbfp=\xd7\x13d\xc8\xf0\xbfD\xb95\x94Oc\xed?\xa7\xbb4\xdfZ\xe5\xe6\xbfV\x80\x87\xbdW)\xed\xbf\x85\x0eAg\x1b\xae\xe7\xbf\xe9\xd4\xa0\xd4\xa1\xda\xb2\xbfXP\xba\x91T\x95\xfc\xbfi\x94\xbbr\xe7\xf5\xc5\xbf\xed\xc8\xbe\x1f{2\xe8?\xc9\xaaw\x01\xf2\xe6\xed?g\xfa\x98\xdb\x93\x8f\xdc?z%>)g\x03\xfe\xbf\xfa\x878\xa8\xf4\x80\xcb?\x128\x8f9H0\xf3\xbf\xc8\x8f9f\xa6E\xe2?\x0fq\xc6@\xaaW\xd8\xbf\xb8\xd0voyJ\xfc\xbfL\xaf\xe5\x80\x88\x1c\x96?e\xd3<\xaa\xc0\xde\xeb\xbf\x92u\xcf&\xe2\x02\xb3\xbfW\x1f(\x8c\xef\xf7\xdd?E\x1e\xcd\xbb\xbf\n\xad?\xc7\x13!\xe6\x06~~?m\xb7f\x8duN\xd2?\xee\xc8~-\xa4m\xe1?\x10\x02@\x9e\xc8\xda\xd9?\x12\x9b\xe8j\xa1T\xe8\xbf\r\x03d:\x87\xe9\xf1\xbf\xf3\t\xfb\x80\xeer\xd0?J\xd8:\xffD\xb3\xf7\xbf\xd4G\xfb\xf6\x04\x15\xf4\xbf\x95N\xc4\xb3|\x9d\xea\xbf\x96\x9e\xd9\xa8\xdd\xbf\xf3\xbf\x8a5\xecjc.k?g\xc4\xd9\x14%\xd3\xe3\xbfuqAe"\xa2\xc9?\x0bK\x83\xd1 6\xc6?\xd2\xd6\r\xbeH\xde\xe7?=\x9d\xe7\xccxW\xcf?n\xd3\x87L\x8b\x1c\xd7\xbfEhv4\xd5q\xf1\xbfX\xe3b$\x1c\xcd\xeb?\xb4x*h\xb2\xbb\xf1?\x138\r\x98o\xd8\xef?;\xe0\xee\x9dG\x0c\xf4\xbf\xe1\x1b \xbe\x8f\xd2\xf1\xbf\xca\x1fbgQ@\xd7\xbf\xa9\x9f-\xe0\xfe\xb9\xf6?}\xf7C\xd8\xd8\xbd\xe7?\xf5\xad\xe7\x00\xbb\x98\xf5\xbf\x11\x80\x81sG\xe4\xf5?\x89\xe3\x89\x8e\xfb4\xf8?\x0cS{\xf6g\x90\xc3?l\x91\xd3$\xfdq\x02@\xf8\xcb\xb1=o?\xf4?c>\x10\x18\x08\x01\xa1?\r|y\x1c\x18$\xec?\xa0\xa0\xe6\xf3\xea\xc9\xfa\xbf\x9b\xddv\x14 >\xe1?\x8d\x8b\xc6\xa8Y\r\xe1\xbf\xec\xd9\xc0\x08\x10o\xec\xbfO}\x1f=\x8a&\xe2\xbf\xed\xe3\xa7L%\x97\xbf\xbf\x94\x8d\x08I\xea\x98\xf4\xbfn\xad\xa1\x9d>\x1c\xf7?\xefT\xc5\xac\x11\x96\xf1\xbf\xfa\x0eF#@\x0b\xf4?\x1aV\x0f\xecg\x99\xee?_A[\x91\xa6\xbd\xe1?U\xb7\xfb\nR\xad\xf7\xbf\x06\xf8~\xc6\x9e\xae\xc3\xbf\x1d\x81\x90\xa65\xf0\xb3?\xe8\x13\x96\x8a\xaet\xe9\xbf\xc5\xeb\xcd\xc5\xd1&\xf9?\x91\x120\xbb\x94\x8a\xbc?G7\xf3*\x9b\x95\xfa\xbf?\xb9\x137\xd2.\xf1?\x9d\x1e\xec\x19\xa9\xb7\xc2?\xadwo}\xe8\x12\xd4\xbf\xe5T\xa4\xa9\x99\x17\xf8\xbfi\xeb"\x15*\x02\xfd\xbf&\xb7\xc8=es\xbb\xbf\xfb\xc7\xe7\xa9\x95\xc0\xdf\xbf\xd2\xb2\xc5\x1d\xb0l\xcc\xbf-\x02yud\x81\xa2\xbfP&\xb1T\xc2\xbc\xce\xbf\xe1\x93\xfe\x1cb\x1f\xc5\xbf`\x0e\xe2\x90\xf6)\xed?\xf4;\xa0\xbex\xd3\xf1?+ \xbf\x03\xd1\x00\xda\xbfB\x03\xc2V\xfb\x1d\x9b\xbfR\xd6>\xde\xda\xcf\xd9\xbf\x93\xc8\xb9\xab .\xd8\xbf\x87\xd9\x83A\x13\xbe\xc2?\xccT\xce\x0e7\xca\x04\xc0\xe9\n\x80\xd1\x9cl\xce\xbf\xb4\xf2\t\xd7\x16\xd3\xb0\xbfa\xa6]4l\xa2\xf0\xbf\x9f\xbe\x9b\x06"\xb0\xe5\xbf\x8cP{\xeax\xa5\xef\xbf\xecE^W\x80\xe3\xf3\xbfuy\xb0(\x0fF\xd9\xbf\xa3\x19\xec\xc1IL\xe3\xbf\xe9b\xe3\x98\x16\xc3\xdc\xbf-m\xe7o\x16\x0c\xcd??03_\x92\xd6\xe4?\x94\x1d\x7fQLI\xbb?\x9du\xde"U\xb6\xaf\xbfm\x80\x8a\xc8+;\xe4\xbf\x93D\xc2V\xd7\x1c\xda?\x8c\xa9?\xe3\x8e\xb5\xec\xbf\xc5\xff\xaa\x13\x1aW\xe3\xbf\xae\xfe\xa2>p\xa5\xf0?c\xb2\xc6(7/\xf3?d\xf4R\x8dO\x1e\xb6?\xd4\xc4\x10u\xa6\x9f\xdd?\x8a\xdb+\xf2J\xd5\xd4\xbf\xa6\x0e\xcd9\xe8\x03\xd4\xbf\x8f\xebL\x97\xc2\x03\xd3?\xe0\x15\x0b$\x05\xca\xf9?_\x1d\xf4=\xac\xd9\xf7?\xd7\x80\xf0\xd3\xcc\xd8\xef?\xb3\x99\xd4\x8cD\x1a\xe4\xbf\xa6N\x804y\xe4\xf9\xbf\x03PG\x1d6\xae\xa0?\x82&\xc1\xdf\xb4\x15\xc8?H\xd3\x82\x1f\x9c]\xc0?\xd3=\xbf\xf0\xe6\xb9\xe0?\xee\xca\xd8\x8fM\xb2\xe9\xbf"\xfaV\xd8\xbc\xec\xd9? \x9e\xb5l\xca7\xe8?7\xce\x0b\x0c/\xa6\xc0\xbf\xfe"\xcbm\xe85\x01@\x9e\x81zWx\x16\xf9\xbf(\xeb\xa04\xfc\xe8\xf7?5\xc8\x89451\xa7?\xd4\xe5\xfc\x93\x91^\xd9?\x1aj\xbex^\x7f\xf2\xbf@*\',\xcd\xe8\xf0?/S\x18\xc9\xb1[\xec?\xaa\x18\x99\xe6\x01:\xe4?\x02\xf0\x18U\xde#\xf2?2\x83\xdc\x08\xd6\xb3\xa4\xbf\xba+\x01\x93U\xf4\xd3?\x89\xb1\xc8\xd4{\xc3\xd1\xbf\xd9s\xd1x\xf5\x0b\xe7?RR\xe8L.u\x8c\xbfAth\xe9\xd6\xc7\xea?\xea\xa8i\xf1\xb4\x8a\xfa\xbf\xb7I,\x15\xbea\xee\xbfI]\n\xbf;\xc3\xf2?Fv\xa6\xfc[H\xd0\xbf{\xcfj\xdd`\x86\x03@eO\x0b~\x98\xc4\xfb\xbf\x95\x14\xdd\xae\xc2u\x01\xc0\x14\x04\xff\r\xea\xe2\xf5?-\x16\xa3\x94\xde\x04\xf8\xbf{p\x9d\x94\xa1m\xdc\xbf\x06\x1f\x04\\\xf1\xa4\xd1\xbf\x81\xe3\xddG<\xa7\xe3\xbf\xfcT\x1fp!\xd4\xd9\xbfzZ\xecV\x84\xe5\xbb\xbf\xd4\'\x1c\x10\x17\xa3\xf2\xbf\xa0#\xc0\x04\xfdP\xe2?P-\xc5\xcd\xe1\x1a\xc4\xbf;\x0c&\x8b2\xf6\xe6?`\xd9\xf4\xc6\xa8\x91\xb1\xbf\x19\xff\xb4\x96\xdbC\xd8?\x8b}\xbc\xd5O\x91\xae?Ho\xb98=\xf1\xe4?\xd8\x9fQ\xfa\x01\xd3\xbf\x80TR\x05\x90\xc2\xfe\xbf\xc1\x8a\xc9\xc1\x9dO\xb4\xbf\xce\x15v\xcf\t\x1f\xf0?!)\xda\x04\xc0>\xd3\xbf\x96\'\xab\xf3\x8a\x13\xfa?\xfdx\x173\xc0\xf7\xd9? \x98\xc6\xfd\x8c\x84\xdd?\xeb;\x19s\x18O\xef\xbf\x1cA\x0e\x99\xe6\xcc\xe0?\x13L\xc0C\x03\x8e\xe7?5#\xe1\x0e$\xf2\xf1\xbf\xc0+2\xb7\x00\x13\xc4?\xcf:\xa180T\xf6?\x98\n&\xb1)_\xc0\xbf\xcb[#<\xd5\xbf\x00\xc0\x9b\xb9R\xe4\xbar\xe2\xbf.\xfb\x81\x04Tx\xd8\xbf\xff\x19r\xcfa\xde\xff\xbf\x03\x8a\xe1~b\x8a\xf5?\xcen\x9c\x94\xb4|\xf2\xbf\xb4\xca\x18j\x96i\xdc?\xac\x80\xd6n\xd4`\xe6\xbf\xe7H\xd4q\x0c\x99\xea?\xc6\x85\x94J\xc3\xe0\xd2?\xd3\x8a\xd2J\xa0\x92\xf1?\xc1kP\x8ap\x03\x02\xc0t\xef\xe8\xbf\x8e\xe8\xb2\xc6F\xac\xf0?\x90\x1a\xcbc\xd5"\xd4?&W\x90\xc0\xcb\xfd\xf8\xbf\xcf\xbeU\x8d\xdb.\xe9\xbf\xb1\xa9p\x84w\xe2\xe0?.\x93\xc81\xe2X\xf1\xbfY\x19/\r\xdeu\xe8?\xad\xed6D\x93\x1d\xe2?\xd1\xcf\rR\x08\xdf\xe9?\xe5\x15\x8bl%\xb3\x00@*\xe2\xd0\xc0V#\xb2?\xfb4u\x08*\xba\xe7?a\x8b\xe01\xfd\x90\xb9?\x12<\xeaj;\xaa\xf2\xbfu\x05a\x84\xcd\xa1\xe9\xbf\xedJtJb\x15\xd1\xbfVIm\x91\xcd\xbc\xd8\xbf\x9e\xdd\xba&\x88;\xf3\xbf~\xcd\xa8\x92Yd\xd8\xbf\x06\x19\xf9\nlX\xcb?\x9ad\x024\x13\x04\xe4?\xc5sJ\x87^<\x00@\xcbA\x87\x13\xce\xd5\xc7\xbf\xaf\xc1\x97\x82\xf9C\xe2\xbf\xae\x01\x8a1DG\xd5\xbf\xb3,\xf1\xd8\xbcA\xe2\xbf\x9cb\x05@l\xa2\xbe?\xa6\x95=\xb6\xd2\xc2\xf0\xbf|\x1c\xa5\x91b\xac\xe0\xbf\xa2\xc7+\x8f\xdf]\xe5?j\xc3\xadJ\xd7t\xc5\xbf\xd2\x0b&\xac-V\xe5\xbfL\x1e\xef\x12\xde\xfd\xf3\xbf\x06\x9f\x0c\xa8\xdd<\xe1\xbf\x8d\xa2\x9c6\xc9f\xe1?\x9c\xd8t\x88\xa4\xbd\xe3\xbf.c\xed\x14\x94w\x04\xc0\n\x16\x16\xfc\xddo\xf4\xbfGs\xc4\xe5\x91y\xf7\xbf?$u\x18}\xe3\xdb?\x02\xb1\xd1\xf0\x8d\xb9\xed?\x88n\xcc\x9f4}\xf7?\xb5U\xf0\xb3\xae\xe2\xf4\xbf_\x16\xf6\xf7\xce\x8a\xe5?x\xb8\x9c\x94\xc86\xa2\xbf9&\x08\xc7z\xed\xd6\xbf\xa0\xb8j|\xdf9\xf0?\xa2Ft;Q3\xe8\xbf8\xd2|+$#\x00\xc0\xae=M\x10\xfc\x8e\xb1?\x8c}m\x82\xe9\xa5\xf3?\xaf;M\x95T\x8a\xf6\xbf\x7f\xfb\xf324&\xf3\xbf:J\xa3\x14\xb1,\xe4?\xe1l#VV*\xee?z%\x9f\x86\xc2\xfa\xeb?\xe0\xb7&\xb5^+\xd9\xbf\xbd\x13r\x97\xa3\x9a\xbf?\xac\xa4\x8e;G\xb9\xc6\xbf\xb8\xc4}Y\xa6K\xdc\xbf:\x0c\xed!\xd9\xd7\xe3?k\x10m6\xc8^\xd2\xbf\x1a1\xce\xc3\x1c\x87\xcc?\xd8\xa8Eg\xadN\x05@\xa4\xe7\x99{\xd9F\xf0\xbf\xfd\xe2\x13e\x07\xfd\xd5\xbfg(\xab\n\xc1\x90\xf5\xbf\xa7v\xa5\xeb\x81\x95\xfc\xbf\x9a\x00\xea\x18\xbc\xd9\xc7?\xd5\x94\x1f$\x9aw\xef\xbf\xd6\xf8;\xda\xf2\x88z?\xa6\xd6A\xe3\x8e\xda\xf4\xbf\x83\x9f\xc7\xdf/\xe7\xd9\xbf\xeb\xc8\xd0\x80m(\xdd\xbf8\xbd\xf0\xf1\xc2\xc8\xe3\xbfx=\xefD\xfeU\xd6?\n\xdfC\xf5\xce\x81\xdb?\xa0\x9c\x13\x94\xf2Y\xb9\xbf\x87~\x14|\xda\xc6\xd7\xbf\xf9\xe5;\xa3*6\xf6?6Z\x96[\xf62\xfa?\xbcjb;\x06\xb3\x99?\xb4.\xab\xc6\x14\x8d\x8e\xbf.\xaf`njF\xcf\xbf\xb31$=:\xb5\xd1?l7\xf8j\xc0\xd7\xf1\xbf,lc\xbabg\xf1?]T\x1dw\xe6:\xe5\xbf\xa9@\x9d\xc6\x14%\xe7?6\x98 R\x1cw\xd4\xbf\x9e\xc6\xa0\xa2\xfe\xb0\xc3\xbfJ\xfa\xee\x17\x06M\xf2?\x91-\xca\xe1\x80\xb5\xd0\xbf\xf5v\xa7V\xec\x08\xf4\xbfV\xcf;\xd8\xab\x8f\xf5?\x0b-\x90\xc2\x04\xc2\xf1\xbf\xde\xc0\xc2\xc28r\xfa?\x84*\x9bO\xd2\xf8\x95\xbf\xa8\xa7\x97\xba\xa6s\xed\xbfi1\xd8C\x18\x1c\xf1?\x90\x94Hb\x8f\xe8\xed?\xb4\x08r\xe5\xd3\x0b\x01\xc0\xff\xbf\x89\xec\x97(\xe8?\xd0\xc8\xd4\xd1\xc3\x9f\xf1?4\x16x\x90\xf9A\x00\xc07"\x9fl\xd7_\xde\xbf\xcclW\xacN\xdd\xfe?\x88;\x1a\xb8k\t\xe4?\xc7\x8d\x98\x13}\xc6\xe2\xbfN}*\xf2W[\xd2?S\xc9\xf1\xb0]8\xfd\xbf`\x8c\xdcS\xd5d\xe0\xbf\x01\xf3\xc3?\\\xaa\xf1\xbf\x8d6Fr\x9aN\xb0?O\xa5\\\x99}6\x00\xc0q\xca\xbf\x96E\x0f\xf9?h\x13%\xb4H}\xdf\xbfJ\xb0\x10\xee\xbb\xa7\xeb\xbfL2\xed\xb8\xbdv\xf6\xbf\xe3\x9fW\x01\x12\x17\xce?\xd8\xadR\x80:\x85\xeb?y\xe5\x9a^\xc4\x03\x01@\xbc\xf6\x1c\xf7Kv\xeb\xbfq>\xd2*\xba\xcc\xc5?\x98<>\x11\x04P\xe8?\x17\x80\xb91D@\xd8\xbf-q\xe8\x91\xb9\x88\xf8\xbf\xa6\xc83\x9f\x9d\xe7\xe8\xbf\x8b\xb63=L\xe9\xc4\xbf2+.\xde\xb1\xc7\xdc\xbf\xe3\xd82\'S\xa1\xf0?\xd38\xa8\xdc\xefU\xcd?:\xe1\xcc\x0e$\x1d\xdd?\xc51\xe1\xd2\xd3\x1d\xf0?\x07V\xe6\xb48\xf8\xd3\xbf\x8e\x16\x96^\xacd\xef\xbf-5\xc4\xb6>W\xdd?\x05h\xbf\ry\x1f\xdf?Dq\xad3\xf5\x14\xcf?J\xb7\xab\xa7\xc1\x11\xda?\x16v)O\x96\x88\xd7?\x00\xef~\xc0\x8f\xf3\xf1\xbfk\x866\xdf\x04)\xd0?$\xaf\xfdkK\x86\xde?\xc0B\xe5)v\xf4\xfb\xbf\xe9s\xcd\xe9\xc4\x81\xd7\xbf\xfc[C\xd1\xbc\xc2\xe6?\x05>od\xb3,\xb1?\xd9\xa7t\x17\na\xf0\xbf\x97F\xe1\xb0D4\xe3?\xa5\xe7\xcb\xf3\x1b\x8a\xde?s\xd0+\xb8\xfbd\xc7?C\xb5\r\x1e\'\xd4\xe4?=\xeb 4l\x9b\xc1?\xea\xbcH\xa9\xa3\x9d\xf3\xbf\xe8-\xc5\xeb\x90/\xe3?7Hk\xf3\xef\xdd\xea?K\x807\xc1/\x94\xf9?J[\x06p`\xdb\xde?\xd1J1\xf3\xe5\xa5\xe4?1?\xd6W%,\xec\xbft\x13!WI\xfa\x04\xc0\x97L\x15\xd0\xc2\x00\xf3?\xdd\x14%\xca\x97[\xd9\xbfH\xd7!\xf0F\x15\xf4?\xbb\x96\xe8\xa7\xbe\xd2\xf5?\x8a\xe8\x8f\x9a\xde0\xea?gf#\x83J\xc6\xf7?\n?\\\x88\xd5\xb9\xe1?\x8cF\xd4\xd6"\xc8?sF\xd1\xa1a\xf1\xe5\xbf\x8c}L\x96p\xf3\xf8?1?\x12\x17\xe7\xf3\xdc?~*((\xb4\xeb\xe2\xbfnUW\x9c\xab\xca\xe5\xbfZ\xbf\xbb\xcc\xa07\xe0?@\xde\xd3\x94\x80Z\xf6?\x01?(\xb6\xd4\xfa\xe1?2\x14\x0e(\x16\x18\xc9?\xae\xb9\xd1\xc6\xf1a\xe3\xbf\xbb!\xfa\xa3\x19\xc0+\xbf\x10J\x00n\xefB\x08@G7\xae\xc7\xd0k\xef\xbf\x99\xbc\x7f\x07J]\xee?Qw\xc8\xca\xd9\x06\xbb\xbf\xc2U\xaf\x98\x87\x15\xe9\xbf\xfd.\xda\xa0\x0c\xd9\xee\xbf\xd5\xeays\xf7G\xbf\xbf&\x95\xee8\xd9\xd0\xf0?#9\xaeR%H\xed\xbf\x91\xa2"\x07\x04Y\xe8\xbf}\xf1\xe4Z\'/\xfc\xbf\xadm\x12\x06\xd6\xc2\xe5?\xae\x9cN\xa9l\x9f\xe5?a\xc8"T\xb5\x1c\xcc\xbf\xa6\xfc\x0cZB\xbb\xd9\xbfm\xa9\xe0G`\xb9\xf8?\xa1\x0f\xcf0a8\xde\xbfX\x86\xbdy\x9e\x15\xea\xbfY\xa9\xc9\x07@\xa1\xf0\xbf\x1b\x02/\x84O\x95\xe7?Bi\x90\xa9\x1c\xa3\xb0\xbf3\xear|\xaf\xe9\xd1\xbfFjd\xdb\x9fN\xa4?~G\x15\xb2\x86\xda\xf6?\xf7pq\x87\x8dk\xf8\xbf0\x19\x04\xd0\x9a\x15\xfd?.y\xd5\xf9\x0c#\xd9?\x94\xc0\xb1\xcf\xba\x8a\xe0?f7\xa7\r\xbb\xe0\xf1?H\xc3\xe3/\xe7\xb8\xf4?\xb0]\xdeh\xca\xee\xca?V\xb9\x8eS\xdb\x1e\xf3?\xdcd\xac\x96\xe4\xe7\xd3?\xf4w\x80/\x07R\xd1?x\xed\xaf\xea6\xb5\xb7\xbf?\xba}\xb0\\\xa1\xe0?UHv\xba\xc7\xba\xff\xbf\xd1|\x9eW\xb7v\xc9\xbfE\xab\x0f\t5\xac\xd4?\xb9Z\xe2\x0e\x9e\xb8\xea?U&\x14\r\x17f\xbe?\xb9\xffgs\x96\x87\xf4?\xbd\x9b$\xdd\x16\xc6\xed\xbf\x92\x83\xc8\n\xf9B\xe8?ZK?-^\x00\xf9?\x9f\x9a\xabo\xd7`\xed?\xa4LS9\x8e_\xcf?\x1a\x0b\xbc\xec5\x04\xcc\xbf\xe1\x84\xc8\xb8H\x9a\xc7?z\xd3\xe9@\x80\x8b\xf4?\xdc\xf4r\xac\xe5x\xfb?\xe4Y|\xf7\x03|\xdc?\xa9\xd4x\xf7\xd0s\xca??`\xec\xf7\xd8\xbc\xda?\x00\x1c]PP\xfc\xf4?\xd4\x8a\xd0\xa7\xdd2\xf4?\xc1\xba\xac\xc7\x8a}\xda\xbfe\x03\xbe\xcdw\xb3\xf7\xbf*\xa3\xff\xaa\x8b\x03\xde\xbfHYM\xcef\xe7\xf0?\x0e\xed\x7fM\x8b\xd3\xe0\xbf\n\x03Q\\\xba\\\xe5?Lb\n\xc7\x11\x82\x07\xc0.|P\xad\xb4\x82\xda\xbf\xd7\xbb(}\xd2\xda\xe5\xbf\xbcU 31\xa3\xf1\xbf}\xdb\xb0\x9b\xa7\xed\xbc\xbf\x0b\x86\x81R\x80G\xf0\xbf\x9c|)Z\x0b,\xc5?\xca\xfa\x92\xb9\xe4\xf4\xf3?^\x9b\x85\xf7\xd6\n\xeb?\xbc\x0bl\n\xabd\xf2\xbf\x9b\x9d\xf0\xe1\x92S\xc7?9M\x0c\xb4[i\xe6\xbfu\xa8\xddQA \xef?\xefhc)4u\xfa?\xcb\xcfT4AU\xc5\xbf>\x97\xaaZLq\xfd\xbf\xd4\x06:\xc6\xb8\xb8\xf4?\x88\x03\x0bIT\xc2\xe1?\xe1UJ^\x01]\xfa\xbfLMSwG\x03\xea\xbf\x82H\xbc\xd4\x9d\'\xdf?\xd6(O\xa0~\x8a\xf3?\xf1$\xa1\x9d2\x07\xe6?K\xc6\x9d\x0cb\xd1\xe7\xbft\xbd\x05\x8b\x08v\xde?_1_\xdb\x01\x1a\xf0\xbf\x19\xdde\x82\xcbm\xe7?.(z\x98]g\xdc\xbf\x9a\'\xbc\x7fks\xe6?\x06\x11L\xbc\x80\x90\xf0\xbf\xb4\xd0\xcd?\x92Q\xf0\xbfR\x80&\x06\xdeU\xf7?\xd4\xbfq\xf7\xe7\xb5\xfe\xbf\xef\x1a\xf5VE\xdd\x03@$p\xdf\x9c\x83\x9e\xe8?8\xfd\xa2y\x95\x8c\xe7\xbf\x0c<\x1bwkA\xe6?\x9d\xdfH\xa7\xffA\xfc?\xc8\xba\xa7t\x7f\xac\xe3\xbf\x98\x85\x8d\xb0\x80\x0b\xe8\xbf\nJ\xf3\xe4\xd4\xe0\xca\xbf\xb7\xa3\xd2\xb1\x0fA\xe2\xbf~r\x85\xd5\xac\x95\xf3\xbf\xb2L\x18\x9f\x87\t\xa2\xbf\x00\x87z*d\x9b\xe6?\xfeE\xab\xe2aO\xe9\xbf\xd9XTW\xd4\xe0\xeb?\xaat:\x80\x8b\xf9\x04@\x0f\xc0\xfb^h~\xc5\xbfw\xcf*\xa5"\x0e\xbe\xbf\t\xa7\x06\xce\xa7\x8d\xe8\xbf\xd2mF\x1a?\xa8\xe7?\x96\x9c;\x9e\xb4\\\x9f\xbf\x87\xd68\x86\x03\xfc\xf9\xbf\xcb*k<\xb3~\xd7?RbH\x947\x1b\xe5\xbf\x84J\x9ep\t\x11\xcc?\xf4e\xa6\xbb\xae\xe2\xf0\xbfF5\xa4C\x0e/\xdf?\xe8+\xd5\xabm\x0f\xdb\xbf\x99`6\xb7\xd1\x98\xb7?\x0b\xaa\x80\xbe$\x0b\xce?\xaf\x0c\xe6l\x80\x81\xa1?\x93\x08~-\xe7r\xd2?\x100\x03L\xfe\xf0\xf5\xbf\xd2\xdc\xe0L\xf3\xe9\xe5\xbfUZBq"L\xe2?a\x0f\x05z\xa0\xb0\xf7?\xab\xf0\x89\x81>z\xf9\xbf\xfb\xc9*L6\x80\xf9?.\xb2yMuD\xc4?\x84\xfd\xc8\xcfhU\x00@\xf3<\xdd\x91\xd9F\xe8\xbf"\x14\xfd\xb0\xf5\xac\xf2?\xf4\xe1\xc3\x80\x83\x1e\xeb\xbf\xa9\xd7\t+\x8f\xb5\xf1\xbf;=\'f\x1b\x0b\xf2?f\x0c8\xf2\xd6\xd1\xf1?~\xe6\x07\x84\x99I\xe5?q\x80(\xefi\x1c\xfa\xbf\x1d\xa2\x1cf\x9a[\xf1\xbf\xa0x\xb6\x14f\xe6\xf6\xbf\xf7\x86\xa8\xda\x83x\xe3?R\x89\x1a\xd0\xef8\xeb?\xe0J\xc1\xe1\xf9\x86\xf4?\xf9\xe1s\xb1\x15`\xd8\xbf\xae?L{\xb8N\xd9\xbf\xa9\xd0-\x93\x11Y\xe4?H^\xe5\xfa\xccE\xfb?\xe3\xe1^y\xf9\xd7\xea?\xbd\x87&\xbdT|\xe0\xbfdc\xa6f\xe8B\xe6?\xf5\xfb?\xefh\xba\xf4?\xfd9$\x07\xc9s\xe5?\x88\xc2\xbbn\x87\xdc\xe2\xbfW\xaa\x99\xc5h\x08\xe1?)?\x8a\xa2\xe8\xf2\xb5?\x8bqn$U\x83\xf5?\x91\xe6\xd0Y\x0e\xfb\xe2?\xce\xb8\xb8\'\xc4A\xe5\xbf\x9aZ\xee\xca\x0f\x06\xde?\xad\xe9\x98C\xf2\xf3\xe9?x\nM\x9d\x9dK\xed?\xe4\xb6\xf5\xb6Y\xee\xe2?\xc5O{+Tp\xdc?\x89\xc0\x91o&\xd2\xf4?\x03\xc8o\xb7\xa6\xe6\xe8\xbf!\xf2\xc3\xf9Q\x9b\xfc?\xa5g\x9e]\x0b\xb8\xdf\xbf\xadGe\x12k\xdb\xf7?\xf17\x9fd<\x0e\xff?a9|G\x1d\x1d\xf2?\xbb\x11\xf9\xb1&\xfa\xf1?&\x80\xa8\xae\xa6\xfa\xf7?\xab\xb1,\x18>\x80\xe8?\xd7\xfa\xfeE=\x1f\xd1\xbf\x8c>\x91\xa2=x\xee\xbf+nJfA\x01\xe1?\xe9\xf9\xc5\x9fx\xcc\xc8?\xb0|\xf863\x9e\xdc?\\\xcb\xaeR\x0c\x92\xe2?qh\xb5.+\x91\xe6?\xaf\x07\x17\xa5\x1e\xfe\xd7\xbf,\x98\xa5\xf8?\xb3\xeb\x06\x87\xf0\x8e\xdf\xbf\xe3\x02\xf3i\xbaP\xdd?\x8f\xc4\xcd\x04\\<\xf1\xbf\x03\x02t\xfa\xbe$\x08@\xd1w?\xf6BU\xe7\xbfE\xf7sU\xd5s\xeb\xbf\xaa\xd3\xce\xff^\xb6\xeb\xbf\x0f\xf9\x9a<\xdf0\xfe?\xce\x8cE\xbd\xfc\x0c\xf8\xbf\x0f\x0c#/\x9b]\xe4\xbf{\xa5\x81\x14ND\xf0\xbf6\xeaghg\xce\xf5?m\x88\xf4\xa06\xcf\xf1?\x10 JO\x17\\\xd6?\x89O\'cV{\xd1?\x8b\x98\xeb)n\xf2\xdd?]\x90\xbf\xc8\xeey\xef\xbf\xf1o\x9a\x19\xb8q\xfc\xbfg\x1c\xfe\xed\x14s\xec\xbfs%z\xcf\xf5\x97\xd4?\x88\xcaJ\xe5C\xfc\xe4\xbf\xb0\xd0.\xb1\xb3 \xd4\xbf\x89\xad\x02\xaa\x8d\x86\x03@\xfeo\x8biB\xfd\xc0\xbfF\xda\x0e\x9e\xce\xa7\xf5\xbf\xe3\xf9\x1f\xe6\xab\xc4\xe6?\x81M\xa3\xf8*\x1b\xd0?\t0~\xb3G\t\xbe?.<+S=\xe9\xf8?N\x1f\x10\xd7\x9e\xdd\xe1?B\xf2\xaf{4(\xf2?UEq\nO(\xef\xbf\x16\x07\xb3\xf2\x10\x90\xaa\xbf\x1c\xdb\xa5V\xe1\xd7\xf4\xbff\x17\x13\x9a\x96O\xf6?\x88\x02\xc2\x13V\x05\x02\xc0<7\xc5\xd3\xe2\xb2\xf2\xbfg\xe2\x8cLBT\xf8?*\xa2NW\x12\xda\x03@\x80W\xd7\r\x90\xed\xc8?\x9a<\x97\x02\x14p\xe1\xbf\x94\x02\x9c;\r\x18\xe8\xbf\x8f\xb6\x11ST<\xd0\xbf%\x04L\xf0\x81\x15\xbd\xbf}\\\xad\xd8\xe3b\xe8\xbf0\xdd\xfe{\xde\x88\xc8\xbf\xa9\xae>\x90\xe1\xc6\xec\xbfh*\x94\xa3\xe6f\xf1?\xd0F\xb6Mn\t\x01\xc0\x19\x06\xd0Y\xcf\x99\xfc?\xe7e\xbe\x83\x88#\xed?\xfd\xc6^)y\x17\x05@\xd2\x1a\x9e{\xd7\x93\xe8\xbf^\xd1\x99\xdb\xb4\xce\xf0\xbf\xf5\xcetq,\xad\xe4?$>\xc1\x80\xc7N\xf2?r*`\x0e\x89\xf3\xc8?\x06w\xd1E\xd4\xe9\xc7\xbf\xff[\xd3I\xb9R\xd6\xbf\xdd:\xadq\xd7s\xf4\xbf\xacTw\x18&y\xb3?$\xf9\xf4\xf1\'\xba\xe4?\xae\x81\xdd\xfb\xae\xef\xf0?|\xa2\x05\xd0hE\xf3?\xcc\x88Y\xfb\x9f\xd0\xd4\xbf;\xe3&\xd7!\xd2\xbe?\xce\x1c\xf3&\xe8v\xe3\xbfK\xf2\xd7\xe6\xca)\xf0?0\xa1\xb1\x8c\x15!\xec\xbf\xd0\xcf{\xd4\x01\x9d\xe1\xbf!2\xc9\xd9\x1f\x85\xf1?g\x12\x16\t\xacn\xfa?\xd9\x90\xb0\x1b/\x00\xf6?e,Gt\xc7m\xcf\xbf\x19\x03@^\x196\xf6?\xb8\xdfjI\xc8\xa7\xf4?\x8a\xbcP2l\x87\xfb\xbff\x12\x8e\x1d{r\xe6\xbf\xe5x"\xac3\xc7\xac\xbf\xeb\xab\x7f\xb3\xdc\x86\x97\xbfv\xf2<\xecu3\xf7?\xe4\xd8\xbb\x03\x90~\xdb\xbfT\xe7\xcf\xd6\x04\xea\xf0?H\x8c\x90&Z\x87\xf0\xbf\x9b\xb3\r\xc3\xa0\x9d\xa5?\xe8;=(\x05\xb4\xb1?\xb9\x0c\xaf\x02\x13\x96\xd6?r\xbav\xdd\xeb\x9e\xf7?)x)we\x16\xc0?\x91_\x01\xb4\x987\xd8?\xd1S\xc2@\x85T\xd8\xbf\xa3\xf1\xbf\xd5R\xde\x04"\x88\xdd\xbf\x04ec\xf07\xed\xea\xbf\x80\x93B\xb2hx\xdb\xbf\xc0\xe9{\xbd1\xae\xc2\xbf\x00\xdb;\xe8%\xe1\xdc?G=\x1b8\xed\xbe\xf1\xbf\xeb\xe4q\xdf\xfa$\xdd\xbf\x19\x0e6\x93\xe0\x8b\xe4\xbf@|\xf4\xe1\xcd\xfc\xf8?\xaf\xe2\xba{\xb1\xd9\xe2?\xac\n\x90\x88\x12X\xac?\xb98\x03 \x88\x1d\xf6\xbf\x95\t\x95\xa7\xc98\xe7?\xd9\xb4\x10~oO\xcd\xbf\xb0_\xf4\x02\x1b\x85\xed?\xfdvn\x7fm\x06\xe0?\xce\x1a+\x8b\xcb\xc6\xf1?\xce\xcbi\xd5W^\xea\xbf`\x11\xfa\x0bl\xbb\xcf\xbf\x89\xdd\xf3\xa4\xb6,\xea?o\xbe\x1d\x94{\xcc\xdc?\xc40\xe7ty&\xc2?u;\xa1O\xe7<\xcd?XX\xf8\x00Z\xd0\xce?\x8f\x1en,E\xcf\xd9?\xd7s27\xf8Ru?Z\xbe\xed\x0f\xbec\xc8?\x8e\xd0\x0e\xd9|m\x9b\xbf\x1c\xd6m\xde0\x0b\xe3?\x13Nv\xd4Pa\xb8?)g9}#\xfd\xf4\xbf\xbf\r-\xe6\x84\x8f\xd0?du\xbd\xe0;@\xf4?^\xe0uK\xba\x00\xf5\xbf\xac~N\r\r`\xd1\xbf\xa2\x9e\xe6m\xdbR\xa5?Q\xc1E\xcc\x8c0\xec?\xc4\x84M\xcf\x98Z\xf2\xbf\xf9\xe6\xd3o\xbbw\xc5?8\x0fjy\xd7\xbd\x87?hMM\xb1I\xc9\xf8\xbf\xa7%8\xdc\xa6\xb0\xd7\xbf\x05\xc4\xc6\xf3\xb3\xe7\xef\xbf\xb2\xd8\xd56\xf7\xe2\xf4?\xbd\xb5Y\x02\r\xae\xd1?R,\x0fz\xfd\x07\xd8?\xb4\xa7;\x0f\x02\xee\xdd?\xc6\xe3"W\xddX\xdf?\xd2\xbc\x07\x03(\xe1\xd2?{\x7f\x02\xcf\xec\x8c\xcf\xbf6U\xaa\x03\x13\xde\xf8\xbf6\x87\xcf\x17\xfdf\xe6?<\x91\xf8\x8c\xd7\xb8\xfb?1\x8d\xcb&Q5\xf5?/\xcd\xf8\x1d[L\xd0\xbf\x11\x92\xbb\xb2\x8c\xdf\xf8\xbfUp\x06\xf7G\x9c\xc2?R\xabX\xd4\x82\x15\xe3\xbf\x7f\xa6\x1d\x06\x9e\x9b\xf4?\x89\x8b\xbcq{4\xdd\xbf\xf5\xdd8a]F\xf5\xbf\xa1\xb0t6\xea\xeb\xf1\xbf8/\x12;\xb2\xf1\xf9?\xc2\xee\x8b\r7\x12\xe3\xbf,>\xf5\xf6\x9c\xe1\xd8\xbf\xae\xe2\xf2W\xc1\xab\xe6\xbf\xdb\x8c\xdb\x9f\xe6\x94z\xbf04\x88\xabJ\x01\xc5?\xb0\xb4\xf7\xc0\xdbQ\xd5\xbf\xa8\xdd\x07\xca\x902\x99\xbf\xad\xed\xad-\xbc\xa6\xf4\xbf\x8d\xc0\xbb\x89\x830\xdb?C\x17s\x88\xcbD\xe1?\xaay"`JD\xd8?\xc1\xe7\xf0z\t\x02\xeb\xbf\xc6\x7f\xb5\x93=\xd5\x00@\x8c\x08~\xbaR%\xf1\xbf\xee\x8cs)\xbb\xfb\xd6?\x9b0\x12l\xd7\x06\xe1\xbfT\xcem)\xc0a\xf9\xbfA\x0b#\xa4\xe8e\xaf?\x97\xbe\xfc\x97\xaf\xa8\xf2?\x9b\xad\x8e-\x9c)\n\xc0\xdew\r\x9e\x83%\xf6\xbf\x90\x91\xfb\x8cm\xf5\xd9?\x9f\xee;\xe6\x9c2\xf6\xbfx\xdd\x91\xf1\xa3N\xbe\xbf\x91\xeeV\x16\x01\xdd\xed\xbf@\x88\xd1\x11\x9c\xc8\xe7\xbf?o\xc6>\x04=\x01@\x08\xe1\x97\x90\xc3Y\xe7?\xa1\xee\x85\xfd\xd2\x88\xe3\xbf\xe1bt\x1fj\xa0\xf5\xbf\x90Y\\\xaf\xb9\x16\xe5?gjq\xaf&\'\xc2?\x1fa\xc5\x1e\xaa\xc2\xef\xbf\x01\xa7\xdd\xc235\xf7?\x1f;\'\x10\x12(\xf0?\xe8\x94V\x92\xf9\xef\xdd?X\rP\x91\xac.\x00@\x0ffE\xf3\xba}\xc3\xbf\xb4\xfd|\xb9g\x86\xd0?\xcc\xe3\xa3\xe6c;\xf5\xbf\xff\xe4\x81\x95\x17\x13\xfc\xbf\xfcm\xb2\xeb\xfd\x0b\xc0\xbf\x99\x96\x10D\xa2\xe3\xdd\xbf;\x90IGB\x03\xdf?\\\xed\xde]\xf9\x8b\xfc\xbf\xc7/1u\xf0\x83\xc3?\xe4N\xe1R\xba\xdf\xc3\xbf\xf3B\\#\x18\x1e\xeb?m\xe85\x1d\xf5\x9b\xc5\xbf_\xc9\xf4\xa2@r\xdf?\xfcj\xc8\xe7\xf8U\xf2\xbf\xa8\xf3\x8d\x10\xca\xc6\xf4\xbfD\x0c0\x8e\xad?\xa8?;-,\x9fg\xff\xea\xbf\xbeG\xb3\xd8\xbf\xa1\xe5?\x8f]\xb7\x88\x83"\xdb?;\xe1?C\'}\xed\xbf\x1a\xcd\xcc\xfa.c\x02@\x97\xcd\x05\xa3s\x05\xd8??\x06\xf7\xd4\xbe\n\xa3?\xcd\xb9\xdf\x05\x83\xf6\xc8\xbf\x95\x112%\xd9d\xff\xbf\x92\xc3O7\xdd\xf6\x98\xbf\x06&rb\xa3\xb1\xda\xbf\xfa\xdb5\xf4\x9e\x86\xdf?\xe0\xe5Z\x9d\xde\xf4\xd0?r+\xdao`Z\xe2?\xdbe\x042\x11\n\xd6?\x7f\xc1M\xa9\xb6\x8f\xda?P\xed\x08m\x07\x9d\xf7?\xdf\xb6@M&\xbf\xef\xbf\x07\x8f2\xff\x8c\x9a\xb7\xbf(\xd4T\xb3\xc9Q\xf7?\x9c\x89\xa3RR\x11\xe9\xbf7Ll2\xa1\x96\xf4?,\xa6g\'A\xe2\xd8?\xe8\xa3K\xefu\xe2\xdc?\x88f\xa4;\x8a\xb9\xf4\xbf\xc8\xd9\xcc\xdd\xf5\xd1\xf0\xbf\xa5\xcaY\x87\xcd\x0c\xc8\xbf\xec,\xa9\x97%\x8d\xf1\xbf\x03\x86(\x8f\x9br\xe6\xbfa\xfd\xf1=$\xa3\xd4\xbfu\xff\xc2\x1b\x7f5\xd9?\xbc!\x98B\n\xe0\xe7?\x9de,\x93\x08\x00\xd5\xbf\xa1S\xea\xe4\x00X\xfb\xbf\n1\xe6);C\xd6\xbf\xcd\x92.\xb0t\xf4\x9b?\xf0\xbf\xa2Q,\x7f\xf1?\xfch\xea\xfep\x99\xe5\xbf,\xd0\x0b.\x03\xe8\xe2?`\x87\xe6=n\xee\xd6?6\x9b\xfd`\xa2\n\xf1?5\xeeq\xebW\xbe\xd6\xbfu\xa9\xef\xa9\xd7\x0e\xc7?\xc9\xa3\xd3I\x9de\xe4?\xf5\x8d\x88I%\xd3\xd5\xbf3\x10eI\xd4\x06\xf4\xbfZ?\x9evc_\xd8?\r\xde\xf0\xdd\xe2\xa0\xf3?\xabe\xa0o\xe4\x9b\xf0\xbf\xfbb\xef\x9d\xef\xd7\xe9?$\xd7\x01w\xeaJ\x00@(\x13\x8b4lB\xd7?\xdd\xc8]\xf8\xa0\x15\xc3\xbf\x95\xa9\x06g\x1d\x12\xdb?a\xb4xI\xe2\xea\x00@\x1a\xa3\x03\xa2W\xbb\xff?\xc7\xf2\xebv\xb9\xf1\xb1?\x8f&O\x02\xc6\x85\xdf\xbf\x1e\x8d\xb2\xf6\x0fl\xf6?\x82#IZDH\xfb?\xbbH\x90xt\xfd\xa0?D7\xe4\xb1\xe4c\xd7\xbf.\xea\x18b\xd9 \xe9?\x1d|6\x87Ny\x00@\xc3\xe5(\xd5\xe8\xa4\xd5?\x83\xbb\xe4\x01\x95 \xe1\xbfaX\x95\xe2\x11\xab\xe1\xbf\x9a-h\xa8?K\xd6?\x05\x9b\xbe\x9f\xa4_\xd2\xbf\xe9\xc2\xda\x7f\xcb\t\xe0?\xc1\x91m\x048\xd3\xee?\xdb\xda\xf22\xad\xc6\xf7?\xd5U\xd1\xcb\xa8\xd6\xe3\xbfJ\x8dF\x9b\xd2\xe8\xcf?\xe8\xea\xb2Jy\xff\xe2\xbf\xe0\x0e\xbf\xd8\xbc\t\xef?\xfc]\xe5(\xb3\xb0\xe6?\xa6M\xf5\xb2\xfe\xee\xd3?\xfc\x10.\xcc\x12\xbd\xf7\xbfp\xeb\xd1\xb9\xdb\xfb\xfa\xbf\x04\x8c\x1eH\xaf\x0c\xda\xbfa\xe6\x80\x95\x06\xc2\x01@7\x8e\x86\x03\x90/\xf0?\\mM\xa8a\x04\xc3\xbf[I0\x11)\xc8\xc4?\xe7\t-\xa9k\x84\xeb\xbf\xcdl\x9bS}\x88\xc4\xbf\xc3\xc3A<\xf1|\x01@\xc9gO\xa1\xa2\x0b\xa4\xbf\xde\x8f\x1d/\x8d\xc0\xb6?P\x16\xe3zG\xce\xd9?I5\xe7w[b\x00\xc0\x98\x9f\x08x\xa5\xc9\xcc\xbf\xc0\x86\xde\xc4\x97k\xdd?\x17\xc0\xb05\xc5\x18\xd7\xbf\x8b\xa0\xb4\xef0\xd2\xe1\xbf\xa7\x80\xab\rV\x9d\xf0\xbf\xd3!\xb5\xdc\xf1\xca\x03@\xd5 \xce\xbdK\xf2\xef?\xe0\xa8\xe2\xca\x94\x03\xe9?\x86n\x07r\xc8\xbf\xeb\xbf\x1fyzh&k\xe3?\xe9p\xdcT5\x12\x00@K\x9ds\x12eU\xe8?P\xd1U[\xec\x9e\xf2?\xb6\x12%$\xf2B\xf6?m}\x01\xcd\xe4\xd9\xf8\xbf\x9c\xeb\xb9\x8c:5\xdd\xbfcS#\x0f#\xf1\x01@:\xfaR\xfa\xb7)\x07@\'m\xe3wS\xd7\x05@\xf5\x15B\xedU&\xf1?\xd2P\\o\xd5\xa8\xe5\xbf\xfb\xd8u\xa3\xc6\x92\xe4?\xb3\x06,T-\x9c\xe3\xbf\xc0c=\xcb\x8d\xb2\xcd\xbf\x13b\r\xf5@\xd9\xf2?\x11\xb8\x1b\x12\xa9\xda\xd3?\xbb\xfa\xe0I\xce\xc5\xf4\xbf\xc3\x85\xc1\x1d\x18>\xec\xbf\x05nL`;\xf0\xf8?\r\x88\x80V\xdb\x94\xc2?\x9f\x89\x1c$\xb0\xae\xd4?~\xd1\x8c_\x82\x98\xc7?3t\x84\xd9z\xd4\xfa\xbf)%\x1a\n`\xff\xf1?\xb8\x157\x03\x99\x9f\xff?\xb6\xe6^F5\t\xe1\xbf\xf38\xe3G\xfc"\xd0\xbf\xca\xba\xdc\xad\xd0 \xb2\xbf\xf3\xd8\n\xf9\xa4\x99\xf2?\xec\x81v\xb0\xce\x95\xd9?\x93\r\x97\x9b \t\xf0\xbf\x183A?\xa7n\xe0?\xb0o\x07\x90\x83\xf9\xee?\xd5pR^`\x15\xef?\xf8i"\xccn\xfa\xfa?\x93\x07\x9a\x1f\x1f\xc3\xca?.\x80\xf5\x86l\xba\xaf\xbf\xd41\xc3Q\xc6S\xee?\x1e\xe6\xd53\xb4\xb6\xb9?\xcao\x05+\xb1\'\xe7\xbf\x84F\x0b\x80\xcc\xe9\xf0\xbfN70\x9e=1\xf6\xbf7\xb9;\x0b\x00\x97\xa7\xbf_^k\xf5\xc8\xb6\xcd?\x0f\x1f\xe4\xc2\n\x8c\xda\xbfL0\xd0\x89v\x0b\xd4\xbfq#\x91\x19\xe5\xe1\xe3?d\x1c\xcfw\x87\xe2\xcb?\xbbT\x12\xd4D\xc9\xe6?b\xd3#\xc9U~\xc2?\xbd \x89\x86\xe2\x1a\xd0\xbf\x1d2=\xddk\xf3\xf4\xbfv\xd7!g\xac\xb1\xe8?\xc1\x14!\x8b\x06!\xec\xbf\xeb\x9e\\b5\xa6\xde\xbfwv\xca\xbf\xe1T\xc6\xbf\xabb\xcehW\x16\xdf\xbf\x02\x8e\xea\xae\xd6|\xc4\xbf\x05\x8d\x10\xacL\x07s?+\xa7\xdf\x16\xab\xf3\xad??\x12k\xf5\x05\xca\xed?\x0b\xcf\x9a\x98\xda\xa9\x01@\xf0\xb4?\x12\x1f\xe1\xea\xbf\xdas\x0fe\xe3\x1c\xc8?\xf7\xb4q\xa9\xed\xcb\xbd?\x9a>\x9c\xa5\xc8\x00\xe5?O:\xe1\xd6\xcc\x15\xb9\xbf\x10\xc2\x11\x0e8\xd6\xdc\xbf\x0e\xe7\xfc|\x85\x01\xe3\xbf\x13\x92\xa7\xbc\x14l\xfb\xbfs\x03\n\x1e\x82p\xf9?\xe3\x05\xdf|\xe3\xfe\xde\xbf\xc1\xd4\xa0"\x07s\xf1\xbf\x02^T\xf8\xb57\xe5?\xc5g$\xc5 \xfe\xbf\x87\x12\xcf \x0c\x98\xf4?\x97\xfb\xbbK\xc7\xa6\xc9\xbf\xa0q=\x08\xbcK\xeb\xbf\xc785\xbd\xd7\x8e\xdf?`\xfe\xa9m\t\x06\x05@\xddHA\xc8\x08\xdc\xd1?\x0b7\xb3e\xf9a\xd8\xbf[\x92\x08\x83\xa1\xde\xed?)+~\xb6\x99N\xf7?&\xf6#Y"\x98\xfc\xbf\xbb\x89\x0f!L\x92\xe0\xbf\\\xf8\xda3\x0f\xdb\xe7?\xf2u\xb9fSH\xdb\xbf\xc2Ik\xf1\x0cO\xf9?N\xb1\x8b\x93^\x86\xf0\xbf\xa2\x1c \xb6\xbd\xd9\xcd?W\xb1\x85>*\xf2\xdd?x\x90\x03\x02|\xaf\x89?PW\xf2"-8\x00\xc0~\x9b_n\x06\x1a\xf8\xbf\xe0\xe3q\xe0l\xd3\xf3\xbf\xebY\x04\x82\x11B\x00\xc0\xc6\x00\xc4\x8d\x85]\xd8?v{\xcd\x12\xb1!\xe1\xbfK\x9c\xffzR\x01\xfe\xbfT\n\xbd\xf0i\xe9\xe8\xbf\x1f\xf8^\xf8v\x8a\xf8\xbf\xf6I\xe6\xdd\xd4\xda\xe1?~-\xfav\xda\xa4\xdf\xbf\x16\x8d\x1f\xea\xc5\n\xcc\xbf\x0b>\xf27\xf8n\xa8?n\xee\xa9!q\xdf\xf5?t\'\x99\x8b\x05\x1c\xfa\xbf\xc7O6\xd0\xf9\xa7\xfe\xbf9\xc7\xd5\xd4\x15\xb4\xc2?~\x00:\xfa\xb4\xed\x00\xc0T\x04\xbcCv\xa3\xce?-K\x91@)\xa0\xf1\xbfh\xf7%_\xdb\xa2\xb6\xbf5B\x0b\xd9)\xd9\xdb\xbf2|\xff\xbb1,\xe6\xbf\xeb\xb1\x80\xe3\x84)\xd4\xbf\x10\x9514\xb3\xf8\xf9?Ux\x1d\xef<\x9d\xcd\xbf\xbc^\x80\xa3\xac\'\xbb?)RG\xc7\xd1W\xf2\xbf\x13d\x97\xdc\x99\xb0\xe5\xbf\xa2\x12\x07`C\xb3\xe5?\xe5\xf5\xf9O\xc8\xd9\xf2\xbf\xdf\xfd\xbbZ\x01\x83\xea?\xcaay\xdf- \xf0?\x00\xbaQ\\nf\xdf?\t\x9e\x1c\x90\xe3\x18\xde\xbf|E\xc9\xe3x\xb9\xc6\xbf\xde\xb8\x90l\xbc\xe9\xdc??\xb2\r\xc5l\x91\xe8\xbfF\x1a\xa70\xf5\xac\xdb\xbf\r\xd6L\x88\xaf\xb6\xb4\xbf\xa9\xbe\r)\x92\x9a\xe9\xbf\x05u\x15\x8eeU\xf2?*w\xb5c-\x10\xf2?\x1f\xd6W\x95\x13%\xe9\xbf\xf3\xdb\xae\xb9\xe1l\xd8\xbf\xf7\xe4\xa2\xc7\x80\x84\xeb?\xa9\xe8\xf2\xde9/\xa0?\xbc:\x10\x90\x82\xaf\xf2\xbf\xa2\xdb\x92\xd1\x10\xc2\xf8\xbf\x18\xcd\'\xcf\xed\xc8\xf2\xbfV\xa6)h,\xd8\xfa?\xdeOpn\x11\x1c\xf1?\xed\xfag\xdf\xd3n\xee?\x0b6\x16\xfff\x88\xd2\xbfN\x9c\xad\xdd\xc6\x01\xe4\xbf[c\x8e\xff\x02\xde\xcc?H0\x7f\xaer$\xdc?S\xea\xa63\xa8\xd0\xf0\xbf\xbb\x84\xa0\x15\xd9\x94\xe9\xbfn9\xa0\x1f\xc8\x89\xf5?Car\xa5>d\xdf?rt\xea\xf2\r\xac\xaf\xbf\xf1\x8c\xd4+q\x8e\xe3\xbfvR\xf3\xb5j#\xe8\xbf\xbf\xcfB\xeb-3\xed?2\'\xa9\xd4\xbd\x04\xe7?\xcb=\xb6\xfa\x05K\xf1\xbf\xc57\xe2\xeb\xecI\xf2?\xaa\xaf\xfc\x11\x8d\x87\xb1\xbf\xde!\x9a\x83\x15}\xe3\xbf\x1e,\x7f-\x19\xd5\xee\xbf*p\xfc\xecbG\xdf\xbf?\xe7#\xb2\x06\xd7\xff?\xd1\xf52]\x0f\xb9\xc6\xbf\xc4BZxg\xa9\xe9?\xc8\x97\x1a\xea\xbb^\xe8?e\x13\xd7\\J\x9d\xd3\xbf\xf9\x83l\xbc\xe9\x90\xf9?\x17\x12\xb5A\xafF\xce?\x16.a\xd9i.\xed?\xcf\xe0I/\x13&\xea?\xe0Zu\xfc\xe3\x1b\xfa?#\xf1Y\xe4\xaf\xd5\xeb\xbf\xaf\xe01\'y\x17\xca\xbf\x00{\xa3nq\x1e\xc8?\xf3\xdd<\x18\x93\x96\xec\xbf\x85\xce\xfb\x9b\xc7n\xf6?\xfb{\xea\xba\xe1\xad\xfd?\x81diU$\xa0\xb4?=\xb2\x92\xaf\xf8\x87\xe0\xbfme\xa6\xcbc\x04\xe5?\x03*0\xaa\x9a\xfc\xc4?\xc6^r\x03\x12\xf9\xe7?\x16\xae\x9e\t\xe2\x02\xed?\xd3\xb2tX\xeaF\xdd?<\xf1\xad\xdf\x8e\x13\xe0\xbf\x00\x9at\xe8\xc6\xcb\x00@ \x02\xa2\xee\x8aZ\xdf?\xf8\x04\x97q\xed\xf2\xf2\xbf\x1e\r\x08h\xcf\x03\xdc?#2\xcaV]\x1b\xe4\xbf\xbcsblX\x88\xbb?\x84\xc8\xe6\x87\xbdF\xb5?/\x1a\x82w\x95b\xf2?G\xba\xe3\xc4\xebK\xea\xbf\xe4\x88\x94\x16\x9b\x17\xfa?\xceK\xc2\xee\x84&\xfd?=\xaa{\x93\xe8O\xf8?\xc1\x89"\x1c.E\xc1\xbf\xd6\\\x07\x03\x7f\xc5\xf2?\x11HA\xd9\xbbL\xe8?\xc2\xd1h*\xe8M\xf3\xbf9\xbd:\xe9\xe7q\xc8\xbf\t=\xea\xbao\x82\xd6?\xbe\x0e\x1byT\xc5\xe9\xbf\x97C\x12^L^\xf1?A9\x8e;\xc8\x87\xf9\xbf\x00d\x84\xa4&\xf8\xe0?e\t\x03fe\x82\x8e\xbf\xeeY\x80\x8f\xb2\x94\xf0?\\\xac(\xe4\xb0\xdb\xd3\xbfk,6\x8e\x99\xdb\xe7?6\r"\xaf{\x0b\xc4?\x00s-\x13/)\xf2\xbf\xef\xaa\x94\x8d\xb0[\xb3\xbfA?\xa8\x04\xa5\xdd\xf2?Ife\x8d\x86s\xf6\xbf\xcb\x14\xc9\x9ai\x18\xdb?\xb9\xc9\xbe\xf0\xe0:\xe0?R\x9a\x87\xd7$?\xa1?-\xd5XE\x7f\xf5\xd7?\x94l\xf6S\xb1\xbd\xf4?w\xe1-"\xc0R\xd8?L\x8aF\xab\xec\x8e\xc6?\xde\xa14 !7\xd3?\x97\x07\xa8\xa0\xffO\xeb?\x03JK\xfca?\xc9?\xcf\xe0\xfc\xc0\xca\x0b\x12@|\x00\x99k\x96\x1a\xeb\xbf\xa91\xde\x8b5{\xd9\xbfw`6p\xb8\xa7\xf1\xbf\xf2\x1f\x0fM/\x8f\xe2?\xa0S\x1d\x0e\xd3\x88\x00@%/3\x08\xc8Q\xf5?6Y4\x86x\xcd\xf6?S\x05\x91\xaa\xc6(\xf2?7\x81\x13\xcbL\xfd\xd5\xbf\xfeM9\x88\x95\xb1\xe2?\xe7q\xc1\x8cm\x90\xec?0\xc29\xb1w\x97\xe5\xbfs\xfa\xc7N\xac\t\xf4\xbf\xc6W\x03{\x10\t\xf1\xbf\x01Q\xf4\x8f\x1c\x82\xe8\xbfa/E\x19\xbag\xf5\xbf\xb8\xfdG\xdb\x14\x9e\xd6?zrWRW\\\t@b\\\x938\xf7\xe7\xc9?\xae\xc0\xcdW3\x95\xfa?\x1f\xaf"\xf3\xa4\x87\xd0\xbf\xc1E\xb3y2\xf2\xf1?j&|\xd1p\xc9\xd5\xbf\xb7\x9b\xbfX\x0fc\xe0?\xf8\x03$\xbe\xb6\xea\xe5?\x1e\x15O\x0bJ\x14\xc8?\xcf\xf3\xbdqOx\xe4?\xa4~\x129\xffx\xc2?\x8fu\xc0\xae\xbb\xf7\xdd\xbfp\xa4p\xc8\x8b\\\xe7\xbfZ+\x1e,\xc6\xc6\xfb\xbf\xcd\xa1\xda\x1f\xa7i\xe4?k\xaa.iI\xe1\xff?\xa01\xdd\xca\xe2\xa4\x00@\x17\x03\xc6\x10q;\xfc?\x93[\xc8Xk\x97\xd7?\x98\x91(<\x8b&\xd0\xbf1][[\xb0\x01\xfe\xbfb\x93\x9f@\x04\x9e\xf7?A\xd2?`f\xba\xf5\xbf(z\xf9MI\n\xfc\xbf\x95\xe8\xb61\xae\x08\xe3\xbf\x8b3\x1d\xf7X\x04\xea?\\4\x05]p+\x02\xc0\x00\x13\xbb1\xe2\x8e\xda\xbff;\x9f\xa3#\xfd\xeb?\x14e\x1dW\x9e\xcd\xf5?\xda\xd2&\xfd\ro\xd4?O\xa7c\xed\xaf\xc1\xc4?\xa3\xad\xf8C\x1e\xf5\xbb?\x14i>!M\\\xe0?\x7f\xee\x0e\x153\xfa\xb8\xbfj\xac\x8b\xc7\xb3H\xec?\xc9t\xc5\x01\x15\xb0\xfc?/>\x148\xcc\xcf\xd9?\x12\xbd\x1c\xea\xbc\xdb\xf0?r\x141\xe71\xc7\xe8\xbf\x80\x81\xa4Cw\xba\xc6\xbfh6T\xb7\x8c\x0c\xfe\xbf\xdf\x03n\x19\xe9\x1e\xd4?7\x86\x03\xb0#\xd3\xfd?vA\xae\xfdQ\xad\xfe?\xe1\xcf\xc9Or\x1c\xf9?\xa6\xab\xc0\xd0\xf6\xca\xfe?Q\xde\x91\x92\xfd\x95\xd8?\xc8\xf6\xc2J\xb7\xdd\xe0?\xe7=\x81\x1ce\x15\xe1?x\xdb\x86\x86\x9c/\xdf\xbf\x00\xd0\xd2\x15\xc8\xaf\x04\xc0,\xb4\xe7\xce*u\xd0\xbf\x0c\xfe\xaf\x01\xcf\x11\xf2?\x1e \x95\x0bt\'\x01\xc0\xc9UN\x02\xa7\xf2\x02@i\xb7\xf3\x8b\xc3p\x9b\xbf.*\x91ck\xa3\xd6\xbf\x18\x13\x86\x92)\xbb\xd6?\xd1\x0b7\xfb\x92,\xc2?%Q\xf0:ht\x04\xc0"Do\xe1\x19\xbf\xed?\xf9a\x93\xa7\xed\x88\xd0?\x86\xe4\xa7(\x98:\xea\xbf\xafj\x1c\xdeD\x88\xbb\xbf\xce\x07\x01\xc9\xfc\xd5\xe4?\x00?\x02\xba2\xf2\xed\xbf\n\xf6\x17q\x07\xbd\xf1?\x0bi\x91n\xbb]\xf5\xbf3\xda\x95\xbd\x9b\xd0\xfe\xbf\xb90\xae\xfdf\\\xdf\xbf\xd9(\xb7Z\xf60\xb6\xbf\xfd\xa2\x1e>\xeeE\xf1\xbf\xc1\xc4A\x8d$~\xce?\xce\x83\xf0\x99\xf3\x8e\xe9\xbf8j\x99>K\xb3\xd2\xbf\xc1\xf2\xbb\x8c\x81\xf6\xe8?\xc1+\xd27\xc0n\xf8? \x04\xc5\xfbE\xc8\xd4?\xf4\x95g\xc7\x1e\x01\xdb?\xd8\x7fNL\x82\xa5\xdf\xbf\x00\xb1h\x07\xbbt\xfd\xbf\xaa\xab\xba\xa4\x8e~\xd1\xbfu\x83\xdbd\tV\xf3\xbffHW\xe5(o\xd1?\x88\x9f\xcd\xfdv7\xd9?\xf04D\xb6\x88e\xf2\xbf1-d\x91O\xad\xd2\xbf\xd1(\xbc\xac\xa1y\xd2\xbf8[_\xf2\xfc\xf7\xd2?\x9c\x8dT:!\x8b\xdf?\xc2.q\xf5N\x82\xd9\xbf\xe02\xc1\xa2\x83\xd3\xaeO!\xe8\xbf|\xa0\x02\x05!G\xf1?`v\xd9\xbfQU2\x07\xf1\xab\x03\xc0\xd8\xa3\xb5\x8c\xbc\x8c\x0b\xc0\xd0lgZ\x0cL\t\xc0v\xdd\xea\x1a\xf8N\x06\xc0\x85\xc6:Nk\xf8\n\xc0\xa6\xfa=o\xf0\xc1\xe9\xbfP\xea\xde\xf6M-\x01\xc0\xda\xfc`\x9c\xb4\xaa\xe1?\xeb6\x13k\x06,\xf5\xbf\xb5Wj\xb3\x0e\xf9\xce?\xe8\x85\x03S\xeb\xed\xf1\xbf_\xa2\xf9b\x02\xd0\xb4?\xe0!t\x1e\t\xb2\xe2?ag\xcdR\xf1G\xf8?\xa8\x91\xf7\xa8Q\xcd\xce\xbf\xa9\xfa\xf0\x04\xae?\xc0\xd9\xd9~U/~\xbfP3e\x04\x01J\xf2?\xa54\x06\x92\xb3W\xf2\xbf\x1c\xb6\x9f,&:\xbd?wI\x87qY\x9b\x00@<\xa2\xef\x89_\xf7\xe9?\xa1\xe6\x13\xd4~"\xe5?\x88\x1bZ+\xa9\xf8\xc4?\x0b\xe1\xb0\x9e\xb6\xdd\xfe?\xc2\x10\x9e\x0c\x12\xd4\xe6?A\xb4-Ay\xe9\xf6?\xd4\xbbP\x81\xb5\x17\xb9?\xbfUg\x86\xfa$\xf5?\xf4\xd5a\'\x1c?\xec?\xf2\x11Y\x94\x8b\xb0\xc7?\x9ds\xbd8z=\x04\xc0\x086\xf0g \xd8\xbc?\xa9\xf4\xf2@\xcbs\x00@FT\xa00\xaa\xc3\xfd?\xc67\xcf9/\xd0\xb1?\xad_\xaak\xb6\xa7\xfa?R9\x91y\xffv\xd3\xbf\x87\x9a\x1e="~\xe2\xbf\x1d\x96\xdc^\xd3Z\xf5\xbf\xb8\xd5$t\x17B\xde?5\xb0\xeb\xcf\xd1\xa3\xf3?N\x9b\x0b\xf3[o\xbe\xbf\xf0Kw\xfd_\xd7\xaa?\xc0\xa3\xc8{\x01\xb0\xce\xbfl\x8f\xe4H\xb0\x9d\xe9?3\xc1n\xe3W\xae\xfa\xbfy\x98\x9ah\xa3\xf2\xf1?Z/\xf1\x0b\x81z\xed\xbf\x9d\x8fyg\xe1\xfe\xf3\xbf}p\x8a\xef\xc5\x86\xd0?\xd4I\xb7\xbdx\x16\xe7?/\rS\x98l\xd1\x00@\xfeM\xb5\xce\xe4\xeb\xea?(\xad\xa2\tW\x8e\xde\xbf\x9dQQ\xb1 \xd3\xd4?V\x06\xf2\x8b\x81\xe4\xec?\xd8\xbc=5\xa7\x81\xc7?\xfa\nf\xa9$W\xe6\xbf)\x82\xf2k\xc0:\xd1\xbf\x07\xe6ea\xa7\xd1\xf6\xbf\xf2\xcc\x84\xa28\xf7\xd0\xbfuy\x80\xc8\xb6\x8f\xf1?\xd6$,\x9b\x1b\x0f\x00@\x81\x0c\x1e\x14\xf88\xd6?\x93a\x10\xea\xf4\xf2\x05@r\x12c\x0c\x9c5\xf5?\x0c\xa1\xb4\xeb\x02+\xe6?\x01\xd4^\xab\xf9m\xe7??\xb0\x1aHH\x1d\xdd?\xec\x9aJ\t\x87\x18\xe1?Fp\xad1\xc7\xf6\xe5\xbf\r\xdb\x14\xeb\x97\xac\xe4?\x03\xa3a\xe7\xf2c\xe4?g\xf7\x92o#\x13\xd4?}\xd0v:\xbe^\xf8\xbf\xa2\xbaN\xe8\xaa\x80\xf8?\x98=^\x8b\xeb\x96\xf6\xbf\xa9\xd4\n\rL\x80\xf2?Xt\t\x82\xea\x05\xde?\x0c\xdf\x86W\x0c\xa4\xfa?\xd1+l\xb4\x90\xd4P\xbf\xb9\xf6$}\xe1\x1e\xef?\x83\xeb\\\x84\xa5\xee\xcb\xbf\xff&\x10\xcb\xb4!\xfd\xbf\x1f\xf4\x97\xe2\x97\x13\xbf?u[E58\xc4\xec\xbfWu\xfcC\xaf\xac\xfa\xbf\xc9C\xdcx\xbfO\xf3\xbfMz\x1e]\xc7w\xdb\xbfx\xfapH\xa5\x9d\xc3\xbf\x97\xf7\x95\x91K\xf3\xd7\xbf\xb3"\xbc\x17h\x1b\x01@\x85\xec\xd2dG\x9d\xea??\xa2\xc2\xc5\x1c\xe8\r@\xeegc\nA\xd5\xf4?\xf9\x00>ny\'\xea?\x8a\xa7\xb9/s\xba\xec?k^\xcd@-\x9e\xb8\xbf\x12x\x14\x1eu\x85\xf5\xbf9,lQG\x8a\xbb\xbf\x8d\xf8\x8a\x11\xeb\x99\xee\xbf\xc9\x05;\xf6Nq\xf4\xbf?K\x1f\xf3ii\xe9\xbf\xaa|z\xf2\xfd{\x01\xc0\x86\x10W\x02\xdcF\xe7?\xbc3\xaf\x92\xca\xc2\x02@\xe3./\x01s\x04\x07@%\x0f5S\x1bg\xf8?mH\x0e\xa3Ix\xb5\xbf\x13%m\'\xe6\xcf\xf1?\xee\xe5D\x0e\xd0v\xe6\xbf\xcf\x91\xa8>z\xc7\xba?\x1e` \x96\x8d\xe3\xef\xbf\xed|\x9ce\x0f\xae\xe9\xbf\xa5\x81\x1en\xf2\xff\xf4?\x01]\xf6\xb2(O\xd4?\xbc\x02h\x16\x0b\xe6\xf2\xbfG\x9d\x8bZ \\\xec\xbf\x97\x965\xcb\x1c\xba\xf5\xbfy\xb8\xba\x05\x12\xae\x81?\x9e\xba^\x05\xdb\xd1\xd6\xbf\x16D\xe5\xa7-Q\xd4?\n:\x1b\x88\xe0\x0f\xc8?\xe5\xe6I\xb8\xa7w\xd1\xbfO![\xfa\x10\x16\xd6?\xd9\x1a\x9e\x1393\xe5\xbf_yK"W\xab\xf2?]\xcbV\x8e\x84\x17\xea\xbf\x9do[\x9b,\xc9\xfa\xbf\xee\xf7]\x85\xdab\xd0?/&\xd1\x84\x7f\xfc\xf5\xbf"\x95<\xaeO\x0b\xf5?\xe7P\x18\x9b\x83\r\xd6\xbfE\xb9\xb5\x1d\xf20\xff?i\xecl/g1\xef\xbf\x13\x9c\xd0?\xae\xb7\xe1\xbf\xdc\x15\xfbO=\xe6\xe4\xbf:\x8fv\x04\x9d\xe9\xd6?n\x03\x8f\xc9\xd9\xb5\xf0\xbff\x9dG\xf5\x9cA\xdf?\xc4F\xe88\xf9\xb2\xab?\x8d\x10\x1d\x86\xe3\x9f\xb2?\xdc\xd4\x03c\x1d\xd5\xf1\xbf\x0bQ\xa2Pj\xc5\xd1\xbf\x91\x89\xe1\xbb\x16\xf2\xf1\xbf]\x1f\xe4w\x81\xe7\xfc\xbf\xd3c\x82s\xd2^\xf0\xbf\x9e\x9f\x174\xb4\r\xb4\xbf\xef\xc3*9~\x87\xf1?y.\xd2\x85Wp\xe2?\x9f\x84\x80j\xa1\xb3\xf3?\x1eXyJ\xb3\x13\xb0\xbf\xc8\xd8\xf8\xa0\xa8\xc9\xda\xbf2\x91\x02\x15\x81\xdf\xf4\xbf"C9\xed?}\x03\xc0\xfd\xc7G\xb5\x0e\xbc\xea\xbf\xaf\x0c\x82\x18\xebr\xcf?pS02\xa0\x99\xe7\xbf\xcb\x8f\xf1\x8d\xb8\xcf\xf9?\x1f3\x0f0\x16\n\xed\xbfy\xc5\x1d\x1a\x1d\xe5\xd0?\xdf\xc9b\xf4\xe6\x19\xd7?\xb1\\\xb9\xfd2\xc3\xb7?\xd3.\xe0\xd8$\xc6\xec\xbf\xf5]\x8f(X\x05\xe4\xbf,\xa9\xdf\xf8\x9cW\xe1?\xaa:#\x18t\x0b\xfc?\xe9\x80\xff\x9d\x83\xe9\xe4?\x8b\xa2\xf9~\xbb3\xde\xbf)\xe1\xbc\xd9K\x10\xc7\xbf\xcf\x81\n$\xbb\xc0\xd9\xbf\xcc\x96\xe5\x98o@\xd5\xbf}\x0cI\xb1\x7fS\xd3\xbf\xad\t82\r\n\xef\xbf\xff\xdc\xcb\x9d\x05\\y?\x01$\x07\t\x106\xc4\xbf\xd9\x7f]C\xc0\x94\xb6? e\xba\x9a\x83\xb9\xe2\xbf\x04\xe2\xd6\x95\xcd\xce\xe4?y7\x02\x87\xa2O\xee\xbf\x90w\xa7k\xf1\x96\xc0?p\x90\x03G\xcc\x0e\xb2?\xc7\x85#\xaa\x01t\x93?`\xd6\x1eI\xec\xb5\xd0?\x05(2B\x8f\x96\xd7\xbf\x1e2c\t\xf6\x8c\xa3\xbfAd\t\x15\xcfz\xc0?2\xe4@\xc7_i\xd1\xbf@\xb5\xc3\xf5\x9a\xc5\xe8?T\xaeh\x9a=/\xf0?\xa2\xcf\x1d\x05\xf5-\xf5?\xa8.\xcdi\xa9\xab\x84\xbf$\x94t\x88n\x1e\xfa\xbf:\rL_\xe3\xbe\xf1?\x06\x0boo-\xd6\xff?\xee\xfd\t\xc3Q\xc5\xdb?\xbd\xc5\xc2B\xa7k\xf5\xbf3G7\xf5\x0f\xd8\xf1\xbf\x02\xa1S\xbb\xdb\x11\xd3\xbf\xb1\x0b\xfb\xdcQ\xe1\xed?\x8d\xb5^\xcdUT\xe8\xbf}\x15\xa7\xec\x0f\xeb\xc4?\xc1\xb7\x8f\xf0\x1e\x8f\xe3\xbf\xf5\xca5n\x80\xdd\xee\xbf\xf0\xb9\x01\xb3\xdbQ\xd3\xbfsA\x0fS\xff\xcb\xe6\xbf\xb0\xa4\xba\xaa\xees\xe7\xbf\x01\x0c\x07\xd2\x07P\xf7\xbfU\xd8\xab\xeb\xf9Z\xc9?:e\xea\xc6\xdb?\xd6\xbf|\xb6\x8a46\xae\xf6\xbf\xdd\x9d8\xc9\\\xc1\x02\xc0\\o\x02\x82\x99\xb6\xc1\xbf\xd6\x0b(\xaa\xc6\xf7\xe5?0j\xcd6\xe0\xf8\xea?\x82p.\xf2_w\xf1\xbf\xe7X^\xbfW\xa8\xe7?\xac\x15\x13~\x0cs\xe3?*^\x1ce\x02\xc6\xb1?\xa3\x0e $5\xfa\xf1?\x0c\x19wJ\xd5\x88\xe0\xbf\x86\xf9\xe7\x1f\x82\xdf\xf5\xbfW\xd7b^\xc1;\xb2\xbf\x81\xa3\xb8\x80\xe5\x82\xe2?\x8f4\xe97\xe5\x00\x00@\xc6\xf4|/}n\xd4?\x96\xb1\x88D\x8be\x86\xbf\x83\x01OI\x01v\xc2?_3\xdc\x0bU\x88\xcc?I}\xb8\xbc\xb0>\xe1??\xd7]y\x8f\x0f\xe7\xbfc\x1c=\x1cF\xb1\xc3?\x95a\xfd$U\t\xed?\xb8.\xde\xbf.\xf8\xe1?d\xfc\xfa.\xa3\xb5\xf0\xbf\xcf\xba\xa5\x1a\xcew\xf2\xbf\x00\x12<#\x90_\x89\xbf\xcb3\xe4\x97A\xc4\xf4\xbf\xacw\xc3\xd1/\xa8\xcf\xbf\x10\x8a\xd5\x197\xa2\x00\xc0\x95\xcclC\xb5E\xd8?o\x9b\xb0]\xf0t\xc9?E\xfaBfzC\xde?+\xf3\xbd&K\xa3\x08@\x9c\x1bR\xd4\x07\xe9\xf6?\xd4\x95\x0b\xb2\x92\xac\xe2\xbf\x9drq\xea\xa35\xe6\xbf\xc7\x909\x97\x17\xbd\xf1?\xa2|)Q5\x97\xee\xbf\x1esK\xa0\x1a<\xf6?\xa2\xec\xba\xe8QO\xe8?\xadU\xf1U\xf5\xdf\xe5\xbf\x07\xd7!\xa0\xa4\xc8\xed\xbf\xe7gx\xa2c\x7f\xf3\xbf\xe3\x95\xff\xa8\xe5\xb7\xfd\xbf\x90X\xe8" \xa0\xdb?\xdd\x03\xa2\xdc\x916\xe0\xbf\x8fcr\xc4\x13\x9d\xdb\xbf\xee\x17\xd1\xe7\xb3\xcc\x01\xc0\xeb\x07\xc5B\x16\xea\x06\xc0U\xd6\xe6-\xcc\xd4\x00\xc0z\xba!e\xd9\x91\xec\xbf5\x1bh\xa7\x1b\xf3\xec\xbfAW\xe0\xb2\x04\xda\x02\xc0\xfc\xa7\ni\x0bx\xf8\xbfm\xe8\x84\x88\x96\xa4\xe0\xbf\xac\xaa\xc3\xee&\x9e\xf8\xbfm\x807\xcc_s\xd6\xbfRl\xb7\xea\x88O\x00@\xca\xea\xaaBt\xb7\xef?6|\xa8\xed\x9e{\xef?!\xdd\xd5B\xe7\xc9\xe5?\xddN\xe0\x03\xc3\xbb\xb0\xbf\x1c\xa6~\xe7\xbb\xc9\x84\xbf\xb3|\xa5\xff\x84g\xd0?!K[\x08\xd5b\xeb?\xb6\x90\xdf4\xacf\xe8?\xc64\xca\xff\xe2I\xfb?\x18\x1c2\r\xcd\x1d\xdc\xbf\x07sM\xfb\r\x14\xa7\xbf\xc5\x07\x8c\x14f-\xed?\xbd\x87KU\x94\xa5\xf8?\xab\x11IU\x89\xa9\xea\xbfi4\x10V7M\xeb??\xa8\x81\xcd\xb5 \xec?\x0f8\x0f\xbf\xa1\xfb\xe5\xbf\x84\n\xd9*\x1aJU"\x05@\xe5\xbf\x96:\xfal\xd1?\x06Y!\xe3\x9b\xf4\xe2?\xe4\xe3,\xbc\xc9f\xd4?\x840K0|\x12\x98\xbf_\xf4\x8b\x8d|\xaf\xdf\xbfY=R:\x92I\xa2\xbf\xffM4\x97}\x0b\xf5?\x88|mmF\x1a\xdd\xbf\xb9\x05\xbbtWM\xff?G\xfc\xa8\xa6\xfb\x9a\x00@\xfb\xecM\xe4\xaf\xf2\xbb?\xe2\xb0\x96\x0f^\x94\xdc\xbfFC\x06\xc4.\x8c\xdd?8q\x1d^\x96\xb7\xf7\xbf\xbcEtm8\x9e\xe8?[Z2\x01#-\xb5?x\x07\xees\xeb\xe8\xd3?\xc8\xab\x98\x02\xc2\xf0\xf2\xbf\xe7\x82\x0c\xd6\x8af\xe3?\xd7\x07\xd5\n\x9d\xe0\xc7\xbfl\xdf\x0e_\xeba\xaf?\xef\xd5\xf8&d\xbd\xe5?\x9a8\xc8\xba\xdc\xa4\xd3?\xfc\xe0\x89\x80\xd7\t\xf1?\xa3a\xbd\xf1\xeaq\xcf?\xb9\xdf!\xb0@\xdd\xb6\xbf{\xae\x05\xef\x87\xc5\xb8?m\x96>Wf\xb3\xd6?\t\x0cx\xbew{\xeb?\xc2]\xebw\x83(\xf0?EfS\x14\xc0\xdf\xd1?r\xcf`\xe9\'o\xf2?\xbc#\xbe\x0c\x9a\xa3\xda?\x87\xb5a\x92\xf1\xfa\xf8?\t\xf1\x1e@n\x18\xe5?\x15\xc1\xd1\x0c\xef\xaa\x02\xc0\xaaZ\xe4\xad$y\xfe?\xbe~\x19\x10\xa3\x0e\xfd?\xe8\x15\xcd\x8f\xce\xa0\xea\xbf\x0f\xd6\x8d\x0b\x92c\xdf\xbf\xf2\xd72|o\xa8\xee\xbf{\x91\x99n8\xba\xf8?\xb6&\xa5\xe0,O\xec\xbf\xefw\x9e\xef\xc3\xa9\xe7\xbf\xd2\xae\xfawe\x7f\xb8\xbf\x13\xb2\x8a\xe9\xe9\x01\x00@x\xd3\ra\xe1\xd0\xd0?\xf9+v\xd5?\x91\xd3?\xea.\x83\xa4\xdf(\x02\xc0\x1cAw\xc7`\x83\xe1\xbf\xb2\xf79rx\xbf\xf0\xbf\xb4\\\x98\\{/\xd7?\x80y\x16d\x0e\xbe\xca?\x1b\x14\x96\xa4\xfdj\xcb?$Onp\r\xd7\xc4\xbfAz\x82d[\n\xd4\xbf\x81\xbce\x96\xbat\xef\xbfm\xd5\xd8\xed\xa4e\xdd\xbf2\xcc\r\xea8J\xf1\xbf\xef\xa3.4\xa0\xe9\xd2\xbf\xd4mv\xd9\x89&\xf5?]\x87\x99\xce\x17\xf3\xed\xbfSp\xe6-\xb0\xd9\xe1\xbf?\xc5\xf1j>\x0b\xcc\xbf\xa4?\xba\x12\xb6\xdf\xf7\xbf\x94\xf4hL\x17\xfa\xe6?\x01dcD\x95\xeb\xd4\xbf\xf8\xf8\xdfe\xccF\xee\xbfB\xdd\x8b\xbe\xa9.\xe7?pK\xa2\xde\x15\x9f\xee\xbfx\x85\xe3h\x9c\x0b\xd3\xbfe~\xff\xbbL;\xf4\xbf\xc9\x83JX\x0e\xe8\xd2?\xc3\xd9\x12\n;\x14\xe6\xbf@\xc5\xc3\x8d\xe0)\xca\xbf2\x9dF\xfd\xb0\x1a\xf5?g]\x8a\xc7p\xdd\xdc?y\xc0]\xb9\x8b\xca\xfa\xbf\xc0\xa5\xbbx\xc2\x19\xe7?]\x9e*\x1c"\xb3\x00\xc0\xb4\xa2\x8f\xac\xf2\x08\xeb?\xf3\xd5\xda\xdb\xca\\\xe0?\x19\xaf\xb0\xd5\xe2\xbe\xe6\xbfL\xa2#lS\x07\xf0\xbf\xadz\xaf\x03O\x13\xf4?B\x05\xc6j\xd3\x81\xe6?yq\xe0:\xdc\x9a\xcc?\xc5|g\xe3\xdbN\xf5\xbf\xbd\x0c\xfa\xbf<\xc5\xea?\xf5\xfe\x02\xde8a\xd7\xbf\xbd\x14o\x9eu\x9a\xe4?\xcc\xe5;\x8bGQ\xb8?\xfeV\x8a\xee#\xcb\xea\xbf5\x96U/&\xa0\xf5?H\xc6\xcf\xb1s\x85\xe5?\xf0\x10\xdb\x1f\xc8\x03\xf7\xbf\xda_\xd6\xce"\xa9\xe6\xbf\x1f+\x95\'\x03Y\xfa\xbf\x8d\xa2u26\x86\xc5\xbfv\xbe3\xa8\xd1\x16\xf7?\x8a\t\\\xa2\x14-\xf3?%\xf3\xf6\xc8WX\xa9?\x0f\x19P\xe1\xd3\xf5\xe5?\xba\xde\x11\xb9&`\xf7\xbf\xc9Kz\x12\x05i\xd2\xbf\x11\xd3\xb8\x92\xb4\xbc\xd9\xbf\n\xee\xe0\x08\x98%\x06\xc0Z\xec\xaa\xd4\x1fg\xdd\xbf/\xdbGl8\xf5\xf4\xbf4\xcc\xf5_\x92i\xc8\xbf\x19\xfb\x06p\xf6\x84\xb7\xbf\x8a\x16\x98\xc0\xeb\x05\xcc?\xa4\xa5\xc1J\xdcR\xe5?\xed\x9a\x15e;\xc4\xdd?\x12\xe7]\x81\xe9\xba\xf3?\t~\xca\x87\x1f\x94\xdd\xbf\xe63\x8aU\xea$\xf8?w\xd4F\x83\x07\xe4\xc7?\x08q\xc6\x1e\xb7&\x05@\xb4\xcb\xc4\xc7\x1fu\xea?mu\xbea\xc9\xae\x9c\xbf\xdb\x99\x9d\xbb\xe38\xe4?\x99(\xe8\xa7\x12\x97\xce?\xc10)\xfa3\xab\xfe\xbf(\x7f0\xc4\xba\xf4\xc2\xbf+\xcb\xce\xcb\xd4"\xf4\xbf\xb8?\xb2\x00\xd3V\xe1?\x0f\\\xf4\xb5\xce\t\x9a?p\x81!\x13u\xa7\xd8\xbfS\xcb*[An\xf6?\x07\xfb\xcf \x91\xf8\xee?1\x1d}\x18\x08\xee\x01@J;\xf5\x122I\xc1?K\xa2\xd5[\xda\x14\xfe?\xe0~\x89$m\x8a\xf5\xbfY]\x1e\x86\xc6E\xd8?\xda\xc4^oa\xa8\xe3?f7\xac\x92?%\xba\xbf\xea\x80\x94\xa9\xfa\xad\xb1?\xc3\xe9\xfd3\x0bF\xf1?*\x93Mw<\x83\xe8\xbfu\xe9\xcasim\xfd\xbf\xe0\xe3#\x07n\xa8\xc3\xbf\xed\x9e\xaa\x05uq\xeb\xbf@\n\x0e\x06\xd7F\xfe\xbf\x11\xb9\x07B\x83e\xf1?\xc9\x0b#\xa0\xc5\xc2\xe7\xbf\'!\xc5s-\x87\xc9?\x11 \x92\x9d\xe5\x1e\xf6\xbf\xa3\xc0\x8a\xe1z9\xf9\xbf&\xac4\xa2N\x0c\xf5\xbf\x96\xb8\xdb\x19\x07\x98\xb1?>\xca\x90\xae\xfeF\x01\xc0$\xbf\xb3)s\x0e\xe4\xbfg\xd2\x89\x97Q\xf0\xa5?\xda\xc1\x97\xd9*\xf4\xcc\xbfM\x96\xb7\x08\xa5E\xda\xbfx\x1f1\xa4\xa8-\xe8?@6b\xe2eH\xf6?\xe9s\xae\xe1ii\x03@\x92}\xe1\x01h\xed\xf7?\x98\x9d\t/Q\x8f\xf6?\x7f\\z\xdcA\x11\xe7?\x80\x98e\x80\xef\xb7\xeb?\xe7\xb8\x0e\x04%`\xe2?\x0f4r\xcb\x90\xed\xe1?zc\x8bpBe\xd3? \xa2\x82m\xcec\xeb?GR`\x8b\x8c<\xfd?m \xb8\xa6\xb1\x94\xe3?\xb7\x03\x0f\xdd\xa3\xf5\xd5\xbf~.P\x87\x92L\xe2\xbf\xdb\x84\xbb\x84\nG\xf4?/\xf5\xb8\\k\x07\xf6?\x9c\xc4N\xa3lg\xfe\xbfH\x05\x95-\xbdv\x00\xc0\xb4\x904\x02W\xd5\xe3\xbf\xa2\xbe\xae\x1c^\x0c\xfb\xbf\xa0\x9d\xf5\x1e+y\xc3?\xb4\xf1\xd9|\xd6y\xba?\xfc\x98%\xbc*N\xd7?X0\x00e\xb2"\xf9\xbf[Tp\x1c\xa7\xc3\xf6\xbf\xf3\xed\x99\x148\xb2\xd8?\xbf\xcbI\xe4\x96\x91\xfc\xbf\x7f\x15\xcd\x93L\x87\xfc\xbf+\x03\xd8\xaf}n\xe8\xbf\x0fD\x90\x07\x19&\xfa?\xd1\xf3\xc1\x97-\'\n@\xa2\x88Z\r\x8d\xa5\x01@5\t\x00&\x809\x00@\x8e\xee\xc5\xbat\x1f\xbc?K\xd1S\x80\x92\xee\xfc\xbf\xe7S\x94\xca\xf2\xe1\xfe?\x0bh\x16a3\xad\xc1?\xb6m\xc5=\x1d5\xeb?\xcb\xe8\xbelX\x00\xef\xbfJ8\xed(\xe4\x89\xa0?\x10H\xac\xaa\xa1\xc0\xfe?\xfd\x0c\x06\x93\x88\xc3\xec\xbf\xd6!\x82\x9e\xc2)\xe5?\xc4+\xd9!\xf1\x82\xe6\xbf&\xa4\xc4\xf0\x06\xf5\xa3\xbf\xack\xca\xd0\xd1\xa1\xe5?\xfe~\xad4~P\xe1?CB\x81\xa4j\xa4\xec?\t\x1f\r\x9c6\xb1\xe0\xbf\xe5\x18VZ<%\x01\xc0\xec\x03\xfbx\xfa\x19\xed\xbf\xc9\x831c\xec\x19\xe5?zny\xc23\xa4\xd6\xbf\xea\xcbh\x96\xe1\x84\xf2\xbf\x9d\x06\xad(|\xe3\x9e?\x0cX\xcd\xaav\x01\xc4\xbfU\xaf$\x17\xe8\x98\xd7??\xd4\x07.\xe2\x91\xe3?\x80\xbc@f\x8d\x9e\xf4?I\x10\x17o\xef\xe6\xf9?\x8cX(,j|\xfc?S\x82L N\xc5\xf3?\xf3N\x82T\x81f\xed?"\xa5\xaa\x1b|k\xdf?\xea{\xb3\xb3G\xdd\x05\xc0\xaeX\n\xdbY\xdf\xeb?\x16\x8a\x15\xfa\xacU\xe6?\x08\xb7\xa1e\x97L\xec\xbf\x1b\xe1\x94\x81p\xae\xf2?!\xc4s\x95\x0fz\xb2\xbfN}\x7f\xe7M\x1b\xbf?\xc6A\x03\x96\xb4\x89\xfb\xbf\x87\x123\r\xdf\x03\xde\xbf\xa9pU\x01\xe0\x14\xb4?J\xed\x98\xa1\x16O\xe7?\xc1\'3v\x0cU\x88?\x05\x8cW\xfaT\x19\x00@\xeb\xbdwL\xbc<\xca\xbfI\xa5o\x82\xb6\x90\xf6\xbf;a\x8fkh\x0c\xbc\xbf?(\xba\x88\x1a\x11\xec\xbf\xd3\xb8\xa8\\\xb96\xe0\xbf\'r\xd1S3\xa8\xee\xbf\xe8\x91\xb3\x1c\xd9F\xba\xbf\x01\x97\x99\xee\xde\x00\xd6\xbf\xab\xf9\x0c\xf9F`\xf8?\t\xfc\xf9\x86\xc0h\x0e@\x83\xda\x1d\x980\xa7\x01@\x8f\xd8"\xa6\x84-\xe0\xbf\xca\xb3\x1c\x87\xc5W\xde?\xee\x08d\xbf\x06J\xf7?w\x92\xabxw\x80\xeb\xbf\xf7\xb9W\xfa\x91k\xf1\xbf\xd1\xb2\x82z\xf9\xe5\xe2\xbf.\x92-\x7f\x85\xa3\xdd\xbf\x9d\xa7\xf2\x91\xf8\x12\xe9?\xa9\xf9\x98\xfc\'\xf8\xf0?\xfa\xc5\xfb\x86\xb6\xa0\xd0?\x8etd\x18t\x83\xf0?F\x9e\xb2\xe4\x03r\xec\xbf\xecJ\x0f\xa1\xdbE\xf2?^G\t\x9b\x87\xa3\xed?G\x17\xb0d\xa3$\x05@\\>5\x13vh\xcf?\r\xd8o\xe0\xf2\xce\xc8?\xf2A\x90\xb7\xb4+\x00@\xb3\xb0\xfb\xc3\x94p\x04@\xae!\xad\xdc\x1d:\xd3?\xe9\xc6\x14\x1fe\x97\xeb\xbfBz\xec\xce\xf6\xb7\xe2\xbf\xb1\xdd\xf98\xa4\xb7\xec\xbf\x9c\x86\xb1\'\x02\xaa\xfd\xbf\x02{\xfa\xe6.\xcb\xfd\xbfS\x02\xb3\xdf\x84\x9a\xf7?\x98K\xaa\xad\xb5\xd0\x03@\x85\x8f\x02 r%\xf8?\x8c\xbe\xee\xbd^I\x01@\xcb\xb5\x1d\xe1\xcd9\xd1\xbf\xca\xb8.\xc8\xf8\xd6\xe8?Pz\x92\xf3\x8f\x81\xf7\xbf\xb5\x80@\xe0D:\xe9?\xd0\x81\xb2U9|\xec?\xe7\xbb\x17\x12+$\xf0?\xec\x81\x9bbXI\xf3\xbf1\x1dC\xb8\xbd\xd0\xdf?Ue\x81\xa1~\x84\x00\xc0e4q\t)\x96\xf5?\xfa\x81o\xf2\xde(\xe8?\x11\xf3\xb9\x87`g\xf0?x\xb0n\xf1X\xdf\xee?\xe3\xab\xf2b1:\xee\xbf\x84\x15QEC\xe5\xef?^\xd2\xd1\x13\xad\xd4\xf1?!\xd9q\x97#\xd0\xfa?\xf7\xf0\xda?d\xac\xf9?\xc2T\x01\x00za\xeb?\x0f\x16r\x80\xe3f\xfc\xbf~\xf7\x07\x1c\x1aj\x07\xc08\x9eP_\xad;\x05\xc0W+\xce1\xcau\xf7\xbf\x1d\x8b\x82~\x7fC\xee?-\xc8\xcfM\xcd%\x00@\xec\x04\xf5\xa9J\xf1\xfb?v\xac\x84K\xd9\x8f\x02@\x9eh\xa7\x93\xf1\xb2\xe2?\'\xf2_\xfe`D\xd3?]\'D\x88\x10\xca\xf3?\xf1f\xf3\xf2\x94 \xe2?\xdc\xd1\x12}Q\xdc\xdf\xbf)\xe3\xa5\xba\xc8\x83\xf2?\xf5\x18b\xeb\xc3l\xc7?\\q1S1\xb2\xf1?*)Y\xc8\x1d:\xd7?S\x19\x17\xf6\x19\xdc\xfd?\xacR\x8b\x12\x1e\x8e\xe1\xbfa\x02\xe4\xa6\xde!\xe7\xbf\x8c\x11\xca\x13\xb2I\xbf\xbf\xbd\x84\xf3\x90\xd0\xe5\xda?\x81\x9bL,\x92S\xfa?\xdf\x1b\xdd!m\t\xfe?\xb3BS\x06\xef\x81\xe8?i\xc7\xca\xd2\xbdV\xdc?z\x03by_\xdd\xde?n_\xf1\xdc\x17\x07\xca\xbf\xb8\x1b\xbc/f\xd4\xd8\xbf_\xa51m\x0c\xaa\x05\xc0\xe5\xdf\xa8\xf7\x0e\x8e\xf2\xbfx\x91u\xb8\x00\xd7\x9d\xbf\tr|\xd7jv\xef\xbf\x1b\xa55\xc5\xbb.\xed?\\\x18v\x15\x91\xff\x10@i\xb4V$\x0fr\x02@}\xc5\xd1PnO\xfe?\xd2\xd1\xe6\x98(\xae\xbf?s\x01\x843\xf6y\xf2\xbf\x18wa*\xf5\xf8\xc5?\xf1Y\xb8\xf4\xaf]\xef?&1\xb8\xc5}\'\xfb\xbff\xe0VN,\x91\xc5\xbfV\xcdv~-D\xae?M\r`\x91\x010\xce\xbfH\x9dP\x0c\xc0~\xf7?\xe8\xc03:v<\xa5?\xb0\xa1\x8b4\xa1>\xd5?\x86p\xd8J\x9b\x1e\xe6?\x12\xf0\x942%\x97\xfb?\x0bH\xd0\xd8\x83J\xbe?\x89\xfd\xd3\xa6\xef\x1b\xe2?\x0e@N\xfa%\xd8\x84?\x0b\xef\xf6a\xebf\xd5?\x02\xbf"7;\xe9\xf3\xbf\x05\x10?\x1c\x90\x91\xf2\xbfC\x8eJ\xe2\'S\xf6\xbfUek\xf6\xa4\xc9\xe6\xbfn\xb6\xc2\xecD*\xbe?\x95J\xcdp\xd4\xf8\xfa?\x18\xccX1\x8e\xfa\xf4?\xa99v\xe2J\xb1\x03@!\xb6\xf3\xb7\x8b\x9b\xf3?"\xab\xc0\x11\xf7\xf8\xe2\xbf1\xd6p\xfa/\x19\x01@\x8b\xfa`\r\x07]\xd1?\x00~\xdbw\xff \xda?\x9b\r\x10\xec\xa5\x08\xc3\xbf%\xa8\xd1\xb3\xc9\xd3\xe5\xbf=\xa6M\xabP\xb9\xe4?pE\xff^O\xcf\xb9\xbf\xcaO\xc77\xcf\xf5\xf1\xbfZ\x8a\xe8o\x1a\xe3\xe9\xbf4|\x9d\x955\xba\xdd?\x0c\xe9\xf8\xcd!N\xf3?\xe2B\xc3\x03\x0e\xc7\xe1\xbf\x00\x9f\x1eX\xb6W\xd4?\x82\x19\x1ez\xe1\x9d\xd8?#\xa1-\xaf\xb7\x02\xd6?\x97@\x14\xfa\xaf\xe8\xd5\xbff\xa1X\xda\x0e\xed\xec\xbf\x99i}Z!\xf8\xc1\xbf\xf7|\xe1ne\xdd\xaa?Xh\xfcb?\xa0\xb7?\xd9\x9dr\x92\xd8\x90\x01\xc0\x9d\xf8@6\xec\xb4\x95\xbfU\rhu\x1d\x14\xe3?e\x7f\x025E\x9f\xed?\x99\xaa\x14\xaa\xcc\x1e\xe1?\rt\xfc\x9d\x122\xfd?\xe8k\xcf\x11\xd7\xae\xdb\xbf\xdf\xc0h\x98\xe4o\xd6?i\xc2\x14IW#\xf0?;\xb6&F."\xee?=I\x13M\x9e\x0e\xd8?Rq\x8d\xefLB\xf0?\x08\xea\xc2\x1f6\x88\xf3?\x06\x9f\xdf\x82\xe3N\xb0?\xaaI\xe2w\xdb\xbe\xe2\xbf\x137\xb4KP\x7f\xd9?\xe6\x8bp$2K\xe1?\xa2\xc8G~b\xda\xf3?0`1\x1f\xa5X\xdd\xbf\x02M\xa4\xffne\xe9?\xff\xba\x1a\x1a\x04\xb6\xd1?)\xfbt\xaa\xccP\xf0\xbf\x16M\xd7\xed1\xcd\xff?\xe1\x12\xa2\xc2\xa7\xba\xf7?\xac\xc8#\x10\xb8\xf1\xf2?\xd0rs2\x95\\\xf4?\xc7\xd4\xadn\x96\xe5\xe6?\xed\x8fs}dz\xf6?hO\xae\x10\xc5\xe5\xf0\xbf\x08\r\xf9V\x00w\xb8?-5\x00"\xd2\xdc\xda?\xdc@\x1d\x03\xcc\x1b\xf5?\xce\xc86\xac\xa6x\xfd\xbf\xd6B\x82F\x85\x97\xf3?\xc6;}\xfc^\x18\xe7\xbfU\x1d\x9a7\x06\x07\xde\xbf\xf5\x1d\x148\xd7\x13\x04\xc0/\x0f\x00f\xc7\x80\xc8\xbf\xc61.\x9cea\xd5?5\xcb\t\xd5=/\xc2\xbf\x94\xea\x12 \xdc\x95\xf2?o\x9b\x1cs\x9e;\xd6?h\x88\xe6\xb6\x86^\x00@\x19\xfb\x0es\xe7x\xd0\xbf\x0b\xad]\xe3a.\xe8?\xfb\x95\xb1$\xdc\xda\xf5?M\xe6\xf3>\xa5\x9b4?\xd1\xfbWS\xa0 \xcb?@\xffb\xfaV\xc1\xcf?J\x13\x9bJ\xc2\x98\xd7\xbfW\xc0s\x9d\x8e\xfa\xd1\xbft;|\xd7\xab\x99\xe9\xbf\xf8pQe\x10\x9a\xfb?*\xe9bx\x9ap\xec?\xef?\t\xcc\xf7\xd5\x91\xb3\xd0?\x08x\x7f\xb5\xd2$L\xf6\x8b\xd4?\x01\xf9\x08\xb6\xb1v\xd3?\x00\xdb$\xc8&\xbe\xe9\xbf\x9e\x8a\xa7{\x16\xd9\xf3\xbfv[9\xdc%\x18\xf0\xbf\x9a\xf7\x83&\xd6o\xb7\xbf\xce\xdd\x17s\x06\x0f\xf8\xbfy\x8f\xb9\x18\x0f\'\xa0?\x0b\x0cD\xc0\x81!\xc3? \r\xf5\x00\x06\xa6\xc7\xbf\xb8v\x9c7\xf7\x7f\xe8\xbf\xb7?\xa4\xdf\xc4!\xf8?\xfb\xe8\xf7\xb2\xbav\xd2\xbf\xe3\x06\xf4 \x1e\xac\xf7\xbf\x95\x9c|\xfd$\x0c\xf3?1Z\x83\xe4&\x08\xea?\x1cG\x0e\xc8<\x14\xd3\xbf\xd1\x8b\xdc\xd3\xd5\x8a\xda?\xb7\xf3\x0c\xac\xc3:\xff?\x11,kurJ\xb9\xbfT\x16\xdb\xd5,t\xbb\xbf\xae\xc6\t7\x19`\x00@\xc2\xe2\xe7\xb0\x0c\xb9\x02@\xd4-`\xf6&-\xe6\xbf>\xa7\x1eY\xbc\x9d\xdd\xbf\x05\xbb\xf0\xf4!\x00\xce\xbf\xa4\xce4\x1c\xcd3\xcc\xbf/\x15\x8b\x11B\xdc\xdc\xbf\x0b\xe7~\xfbY8\xe7?\x08\xd9\xc0\xb4\xd5a\xdd\xbf-\xdb\x1a\xd55r\xde\xbf\xe8 \x078\xb5\xdb\xa1\xbf\xb70uG\xccA\xe5\xbf\xed\x8b\x8dl\x8e[\xf7?%\xa3N\xc3?G\xdd?\x8cY\x03\xebz\x98\xf1\xbf\xf9\xa7v\xf4\xdd]\xfe\xbf\xfe\xb7\x81\xaa\xfa \x00@\x9dJ\x89V\xec\xeb\xc6\xbf\xdc\x04\xf8\xe3pJ\xf5\xbf\x9c\x1fK\x9f\xb7\x07\xe2\xbf\x8c\xa7qJs\xb3\xe4?\xc8\xd4\xf4/\xdf\xc7\xfa?g\xfa\xbc\x1f\\\xa6\xe8\xbfo\x01&\xf8\xdb\xd6\xe9\xbf?\xee\x8a\xd2\x85\xc2\xf5?b\xb2\xc3\xff\x02y\xe3?\x85l\x1e \x043\xfc?\\\x8aa\x99\xc4\x00\xf6?9\x7f\xff\xc2\xbbx\xbd?"\xed\xca\x89\xc6\xa2\xe4?\x11S\x8f\xdf\xd4\xe0\xf4?\xa0p\xad\xa4\xf7D\xf1\xbf\xa6l\xb4Kd\x11\xbf\xbf\x9c\x12\n\xcd\x83\x1c\xaa?5\xdaxPM\xdb\xc4?S\xd5e\xf4\xb3\xc0\xe7?\x9c~\xc7$\x16\xf7\xcf\xbf/\xd3\x1dbm\xdc\xf2?\x86\xe7no\xd3\xe6\xe3\xbf\x11\xfaN\x89!\xeb\xd2?k\x05P\xbb^w\xcb?A]M\x85\xe8b\xe3\xbf\xaf\xe7\x1d\xc4\x80\xe1\xf2?S\xb7\xf3\xe1\xce\xfe\xf5?`\x9d\x7f\xc2*>\x9f?\xfa%\x9d>\xef\x1b\xbd\xbf\x12@\xa6?g\x08C\xbf5t\xbc\xf8n9\xf6\xbfB<\x15\x1d\x13\xff\xce?\xacB\x1c4\xd0g\xc1?x\x92e\xbe\xa9\x04\x02@\xac\xc7\xed\x85&\x1a\xd0\xbfLi\xfb\x918\xc5\xdf?}\x8dl\x9c\xfbq\xd4?\xdd\xbe\x86\x1b\xf6\x86\xe3?\x80\xe5\xe4$\xba\x1f\xd8?\x1dy+!\xc7\x19\xed?n4HL\xbd\x1a\xfc?\xa5n}i\xd4\xe3\xf0?\xb0\xa4!\xd0\xd1r\xee\xbf\x1a\xb6\xf5\xb1\r~\xe6?#\xe6U\x0e\x9d\xac\x00\xc0\xa9"\xd1\x8cm\x0c\xb1?\xe5\xb0P9\xe8\x08\xc7?\xd1oDi\xc0y\xf4\xbf\xca9]\xd53@\xed\xbf!l\x06\x19\x81x\xd5\xbf]VG\xf9\xc0\x88\xe2?\xed\xb9oj\x8aB\xda?\xb2i\xba\x86\xf0K\xfa?4\xb9x\xba\x00Q\xf9?\x12\x82\xe5\xaawu\x00@\x9d\xfc$\xc5U\xa6\xe3?\xfa#\x02!\xb0h\xd8?\x03^\xbd\x80\xa1\x06\xe4\xbf\xa8\x8e\xac\xa9\x81\x98\xe8?\xfa\x80\x1e\xa0c\xe3\xf0?D\x90S]\xebY\xe1\xbf_T\xc2@\x84\xc7\xff?\x1f|(u\x1e/\xf0?\xbbF\xed\x07.\xfe\xe1\xbf\xc5?\x9d\xdbg\xc7\xf3\xbf\x04\xff\xafg$P\xfa?\xfak};\xceY\xf0\xbf7\xe3\x15\xc8o\x95\xfb?\xdd\xd6pAG4\xf1?\t\xef$d\x83f\xe3\xbf\xfa\xaa\xacY\x10\xfd\xe7\xbf\xf9\xb2\xb8Q\x8c\xe8\xdc\xbf\x90-\xa1\xe0\xf87\x9c?\x00\xcaR\\D}\xf6\xbf\x84x\t\x88\xfdm\xb2\xbfB\xc4\x94\x13ZQ\xf3\xbf\xff\xed\xab\x8b\xc1\xc7\x9f?H\x16\x05\xc9\xa1\xc7\xda\xbf|;%\xf3\xa7\xae\xf7\xbf\x1c\xf4\x87o\x84\xe4\xe2\xbf\x93\xf2_\xd6F \xe2?\xf3\xbd\xe8h\x9d\xdf\xf9\xbf\xf2}\xbe\xe9\x8c>\xea?t\xaa\xa4F\xb8\xdb\xf4\xbf%\x8eW\xad\xb3\x9c\xf3?/\xe7\xd5\xf3\xbd`\xd1\xbf\x84\x16?#e\x9d\xf2?\xbb\xf1\xda\xb6\xe7\xcb\xf1?I\x94S\xd1\xd6\x94\xd0\xbf\x93\x8a\x12\'\xb9\xc0\x9d?\xbf\x10)\x98\xabA\xe6\xbfaZ\x16\xb0\x02Y\xea\xbf\x11\xf9\x88Q\x7f(\xf7?\x80\xabEgn\xd1\xf5?S\xa7\x9dl\x90|\xeb\xbf\x11:\x1e\xdf\xd6\x06\xe2\xbf\x82\x8f\x11\xbd\xf3Z\xf4?\x10\x9be\xe84\xfc\xf2?4#\x02d\x0eX\xf1?CY\xcd6\x8e\x86\xec\xbf;\x08\xf8H9K\xea?~\xa9Q\x06L\xc7\xe8\xbf\x0f\xf7\xb8\xe8q>\xe3\xbf\n8\xe85\xc1;\xf1\xbf*\xa8l\xa1\xb5\xb2\xea\xbf& \xbf\x9az>\xfa?\x82\xe1\xab*\xbd\xcb\xc9?\xb48\r\xccK\x95\xe2?]t\x81o\xd3\xa9\xe9\xbf\xc4\x92\'\xe2~\xf9\xc2?L\x93\xcf\x07K2\xf1\xbf\xf2\xcb;K-n\xf6?\xbb\x9a\x91\x864\xe3\xfa\xbf\xf2>e\xfbXK\xf8\xbfo\xc4A\xda-,\xe1\xbf\xf2SA\x92\xa6\x0e\xe4\xbf\x0c\x04\x87\xd0\xa2\r\xfe\xbf\x99\x88\xe7\xceI\x1e\xe8\xbf\xe8o\xf6.\xb2\xa9\xf2?\xc0K\x92\x92\x17o\xec?\xf5\x81\xca\xff\xccd\xbd\xbfP\x8e\x81\x86\xcf\x1e\xe1?\xc6|\xc3\x7f0\x0e\xe1\xbf0\xc0N\xde$\xea\xe8\xbf\xcb\xdbC\x01Q)\xf0?\'&\xdc\xcf\xa8\xf1\xf8?\xb3e.\xac\xe5\x02\xf9?\x182\x8b\x8e&\xc5\xc0?\x82\xc9p\xdb!v\xe3\xbf,\xa8\x06\x81s\x8d\xf0?i\x1c\x10\xb1\x1a\'\xed\xbf\xec\x9d\xf6\x1b\xa3\xf9\xaa\xbf\x9bn\x88\x7f~\xca\xe1\xbfK\xe5\\;\x9e\xb1\xf1\xbf\xb6z\xd6z\x17\xd9\xf8\xbf\xb3\xcfp\xc7\x9f\x1d\xc4\xbf[\x89\x86\xcc\xbb\xd0\xe5\xbf^\x97\x91w\xd5\x1a\xdb\xbf\xe0\xde\x15\x03mS\xb9?\x9f\x1f=\xa6\x96\xa9\xd7?\xa9n\xa3\xb4\xfcx\xe0\xbf\xb2u0\x9b;\xee\xe2\xbf\xadm\x9e\xb4\x03\xd0\xe6?2\x02J\x9a\x946\xf1\xbff\xf0\x9b\x86\xac\x92\xe5?,0\x99m\xf2\x87\xcc?\xaa|*\xf7\xfa\xde\xf0?\xb4\xd3Z(_\xfa\xe4\xbf\xdd\x9c\xda\x9eX\x0c\xb8?.\xb2\xe4\xdbdI\xef\xbfU \x1b\xcf])\xe8\xbfZ\xcc\xd0} \x03\xf0\xbf\x1e\xaa\xb3a]6\xf1?E\x8c\xa7rs\xdb\xc1\xbf\xcf\xed\xc1\x0b\xb1\xa8\xfb?\x9a\x94\x16\xacP\x00\xe7?8\x13M\x17\xe39\xe2?7\xa0\xf9\xa9\xdc\xaf\xeb?3\x87\xe7\xfb\xef\x04\xf3\xbf\x9fY\xe6\xafh\x8c\xf4\xbf9\xc2\x18\xaak\xf4\xe1\xbf\xe0\xeeF\x1d\xf2\x86\xdb\xbf\xa1\xf6\xe7Z\x98s\xb3?=\xcb\x89 ",\xbb?\x8a@:\x17^u\xa2\xbf\xf00\x15zZ\x1b\x03\xc01\x89d\xbcw&\xf7\xbf\x01\xfb\x92D\x89\x08\xcd?\x94Np1\xff%\xc4?\x84e)\xb6\xcd#\xd2?y\xf4\x82x\xe8L\xf3\xbf\x17\xa1\xda\xca\x19\xb6\xe2?z\xf0\xed\x9d\x0c\xab\xcc?\xa5\x91\xa5y\xc43\x06@\x81\xac\xe6h\x99W\xc1\xbf\x0e>\x7f\xa4y\x99\xd9?a\xf6\x90\xc0\x80\x1f\xe2?\xa1\x1e\x94\x92\xfc\x1b\xd0\xbf0\x86\xdf\x95+v\xf8?j\xe0X/D5\xdb\xbfr#7\x8d\xc8\x8c\xd1?\x88\x97\xb5RY\x82\xfd?P\x8e[\xcfL\xd1\xfb?\xb7\x15\xad\x89c\xce\xd3?\xc1v\x02\x93U\x01\xcf?W \xc3\xd4\x1f6\xce\xbf\xe8i\xb6\xc3W\r\xe5?\x95\x91\x96\xb1K\xcd\xc6?r6Z\x115\x15\xe2\xbfO\xbcaEh\xc1\xea\xbfL\x1e\x03A\xf8!\xf3\xbfomV=a\xf3\xc1\xbf\x0c\x890n\xa6`\xe9\xbf\x19{Z\x1b9-\xe8?\xf3\xcf\xfbP\xf4\x8d\xfa\xbf\x93KQ\xce\x13\\\xe4?-F\xb4\xc1J\xf4\xd6\xbf\xe3I\xad\xea\xc2,\xcd\xbfhM\xe4S\'b\xf6?\xd3\xe6\xa4\xb1V\xea\xd5?\xde\xd1<\x1ed\xc8\xf2?\x8e\xea\x18X\xfa\x9d\xd5\xbf\x11\xee\x1a\x0b\x95\x86\xf6?\xeb\xfc\\\xc9\x0f\x0b\xe7\xbf,-\x99\xc4\x94\x81\xf9\xbf\xc1\xcd\xc9`\xb3\xeb\xec?\xfc\xf3D\xcbH\xb6\xd0?\xc5f\xc8\xbfP@\x00@(\xdd\xd0v\xc0\x1a\xfb?k\x8f\xd0a\xbf\xd2\xd0?R01\xf9%8\xe5\xbfE\xe6r\xfc.\xda\xda\xbfO\xc0\x02I\xda\xee\xde?\xc0%l\'\xa0\x8c\xde?1\x81l\x12\xca3\xe3?\xf6d\xdf\x07\xeen\xf9?\xeb@\xa4\xae!\xc6\x00@)bU\x9f\xad]\xeb\xbfF\x8d(}z\xbf\xe0\xbf)"\x03\xe4\x99\x1f\xe0?(\xaa|\xb0K\x80\x8f?\xe8\x91\xad\x1a4\xcd\xe7\xbf-TE\xda\xca\xfb\xdb??q\xcf \xcda\xd7?,4\xa2\x1e\x8a\x00\xe2?;\xa5\xac\t~\xd7\xe1\xbf:K\xed?J\xd8\xf6\xbf\xa9\x93,\x14(O\xca\xbf\x1b\xae\x95u\x1b\xb8\xf0?\xca\xce\x1a?\x8c\xc2\xdd?\x9fz#\x05\x16\x92\xf3?l\xce\x19\x8f\xcc\x84\xa8?\xec\x16a\xa1\xd8\x91\xef?p_\tG\xa8\xdc\xf4?%;,\\\xc9R\xe8\xbf\x9e@\xcd\x12a\x9c\xd1?\xba\x16~"~Q\xf2\xbf\xab\xa6\xfb\xe7\xe6n\xff?\x93s\xa8\xf6\xc1\xd7\xe7?\xeb\xeb#7\x14\x93\x02@\xc6\xfd\xac`\xc6b\x01@\xa8\x00;\xdb\xe1\x98\xd8?\x0e\xf9\xfa\x85v\xc7\xf1?\x08kO\x80\x1c\xc7\xf4?&\xca\x93\x02\x960\xf6?\x8b\xac\xbd\xd8Ft\xf1?O\xa6x\x19|\xac\xb9\xbfJ\x01?e\x86c\xf3\xbf\xed\xe6B\xbe\x00\x8b\xd0?\xb886\x91\x9d\x08\xcc?~^c>\xf9\xc6\xd1?@p\x81\xe5U\xd3\xb4?\xc9\xb5Y\xd3;\xc5\xca?$o\xf1\x8c\xc2h\xe3?\x03\x12ND\xc2\x8a\xfe?\x7fO@8#/\xf4?=\x86\xd61 ,\x80\xbf\x1d\xa4v\x10\x80\x0e\xfb?\xa7\xae\xf1@\xb8`\x01\xc0\x8e22B>\xcc\xdd?\xc4O\xd2\xdd\x83W\x01\xc0\x910Z\xd7Y\x85\x8f\xbf:\xab\xa8KR2\xe1?G\xfb\xff\xa9\xcf\xe4\xed?lL\x0bOi/\xd1\xbf!H\xe9)I=\xad?3PH\xef\x0c\x97\xe0\xbfA`\xd7\xa9Z\xf8\xf1?\rC\xd6\xdd\xcf\x82\xeb??*\xa3x\x84\xf6\xf5\xbfG\x9d^|9@\xda?\x9e\xc9gr\xb6@\xf6\xbf*\xcf>\xe8\xda\x87\xfb\xbf5\xf1\xe08\x0c\x13\xed\xbfB\x9e\xcbG>\x06\xe9\xbf\xaa$j\xd2\xee\x06\xe7?\x8b\xe2\xffCM\xb0\xc9\xbf\xc4V\xd6\x97\xa3K\xe4\xbf\x18\xc4\xcd;";\xf2?7\xb51HH2\x91\xbf\x0ba\xea\xb2\xa1A\xc5\xbf' +tbag2 +(g3 +(I0 +tS'b' +tRp7 +(I1 +(I10 +I36 +tg6 +I00 +S'\x9b\x0c\xbd\xa0\xd5\xc7\x08\xc0\x85X\xfd\x05\x90P\x02\xc0~\x88\xd9\x10\xac3\x8e\xbf\xf2Ui\xba=\x1f\x18\xc0\xc6\xb3\xd7N\xcb\x8b\xe7?\x00w\xe2\xff\xdc\xe4\x05@H"\xf8\xa6\xce\x1e\x0c@\xf4r\x1d\xc0y\x95\xfd?\x93/|\xc3\xfe\x92\xf1?\x19;>7\xc0\x17\xf2?\xe7\xdb9\x84\x14\x9e\xf9\xbf\x97\xec\xee\xa2q?\x02@N\xebB\x1e\x116\xf6?\xc6\xa77\xb4\x05\xcc\xc3\xbf\xa4C\xdc\xf8\xa9\xc7\xd6?uH\xa1@\x16\xb1\xf5\xbf\xd9\xa9AC\xba\x7f\xf1\xbf\xd4\x96M\x19\xf9\xfd\x04@\xe0\xbb\xbf\x95T8\x11\xc0+xkLA&\x16\xc0\x7fN\xa3\x02\xa1\x0e\x00@\x8dBN\xb4V,\xfc\xbf\x0b\xe3\xb0\xba\xb9u\xfa?\x1c?\xa6\x17\xecx\x0c\xc0U\xdf\xb0\xd6\x01\xcb\x01@\x15\xd1\xf3Z\xbe\xa0\xe0\xbf3=,`\x18\x80\x06\xc0\x80\\*\x9f[1\x10\xc0\x1c\x15Y\xff\x94g\xf0?y\xd1\x14F\x94=\xfe\xbf\x94\xa5\xe9\xd0\xd4\x8c\x10\xc0\x8c\x9c3\x12\xdb\xa0\t\xc0[\xcbj%\xf6^\xd9?\xe8\xabMcG\xdd\x10\xc0\x82l>\xcc^v\xf5\xbf@\x8f{\xb1\x01A\xf9?fLU\xa4|)\x0c@"\xdd\xa4G!\x1b\xf3?r\xe7\xde\xf6\x05!\xfd?\x08\xee\x92\xccs|\xe7?\r\x08\xec\xef\x8aR\xf3?\t\xd6\xf4\x15@,\xd2\x95Zdy\xc7\xbf\xe7G\xc5\xff,\xd0\t\xc0\xccuPW\x87\x8e\r@\xbe~H\x1f$\xb5\x08@\x00\x1b\x0c#N\xb7\xef\xbf0\x85\xcd\x9b\xd3\xf3\xf8\xbf\x02\xb1\xdc\x00\xe5`\x01\xc0}\xab\xc6\xd9=\x90\x0f@#\xcc>\x91o\x9e\xfc?\xbc&\xc6\xf6b6\t@\xa1\xf3!\xa5\xb3\xff\xf1\xbf\xbf\xf7Z\xa4\xe3C\x00@\x1b\x1e<\x98A\t\xfb\xbf\xe6 F4c\xa5\x06@\x1f\xf8\xb0\xd7\xba\x04\xe5\xbf\xef\xc5D\x91[\xf6\x13@r\x0f\t\\\x9c]\x02\xc0\x05\x8c)uc\x13\xf3\xbfU\x07:z\xdd\xf4\xfd\xbfO\xbe\xf0\xd1\xcd\xcf\x00\xc0\x84\x01h\xc2J\xf0\x01@6\xcdo\xeb\x97\xa9\x13\xc0v<\xe3\x7f\x9d\x16\x0e\xc0\x1a\n\x90`\xa6_\x0e@k\xfb\x1d\x7f\x02\xb5\xe8?v@\xffl\'\xb4\xd4\xbf\x80%\xbal\x9c\xf8\x07\xc0\xab<\x8f\xaeR!\xf5\xbfJ)/\'YX\x15@@\xc6#\x90d+\xfb?\xc3ik\x0e\x01\xe8\xef?l\xbe\xaaj\xcc\x08\xe8?,\xb0\x15\x94\xc1\xb6\xf8\xbf\xb4\x9by\xe0l\x03\xfd\xbf\xdcr\x0c\x89\xa3\xab\x18@\xf6\xaabG\xb5\x9a\x10@D\xa0\x08\xc8\xf6\xc1\xf3\xbf\xc85\x7fM\xc9!\x03@a\x81\x8cH\xcf\xbf\x14@\xa8d\r\xffx\xc9\x13\xc0[\xb6\xbb\xb9n\xc6\xaf?\xcc\x9a?Q_L\xdf\xbf\xe3W6%\xe7\x16\xf3\xbf\x8c\xf6\xe6\xe6F\n\x0b\xc0\x0b\xf4\xb2\x11\x9e\x8e\xba?0,\xf9\x8d\xc1\x8d\x03\xc0p\xb5\xf9n\xa8\x87\xf7\xbf\xd1\xa1\x9b\x96~\x08\xe6\xbf\xf6w\x85\x92s\xd4\x0e@G\x91\xa3|8l\x0e\xc0\xb9\xf6\xb6<\xb8. \xc03\'\xb6\xe3y\xa2\x01\xc0\x16\x025pJu\x11@5\xb4x@gp\xf0?O`\xc9\x97U\x00\xf5\xbf\x19\xed\x90\x8b}\x9d\x19\xc0\x9ct+=}\xad\x04@\x02\x16\xe4\x0c\xad^\xdd\xbf\xdd\xc3\x86z\xf1\x1b\xf9?\x8e\x9a:\xfa3\x12\x0c\xc0\x83\xd8\xfb\x1d\x06L\xf0?fI\xa0&\xfa\xa8\xf2\xbf|\xaa\xf0\xdaMg\n@KN\xd1\xd0\x9aj\x11\xc0\xf8\xed=\x80\xeb@\x0e@\x9b\xb9iY\x0e\x1a\xf5\xbf\x92\x9aP\xf5>\x97\xc1\xbf\x8a\x9cD\x1bY\x9e\x0e@;J\xd2d\x9c?\x12\xc0t\xbb\x18(\x00^\xc2\xbf/@G>[n\x00\xc0\xcdr\xbd\xa1\xaf\xf9\x17\xc0\xef\xa8\x8e\\m\xd8\x1b\xc0\xf3\xea\x15}\\\xe2\x11@O\x92\x9a[rD\x0c\xc0X4\x84\xdbEV\x04\xc0yL\x86dN\x08\xf0?\x8a\xfe\xaa\xf2\xe9\x00\xf2?\xb5\xfc`#\xd8\xcd\xe5\xbf`?\x00\x18$b\xfb?~\xa0\xdc4\xac\x1a\x0f@\xb6\xa4\x11\xc6\xfe\x1f\xf5?\x9aG\xc6e9\x9a\xf0?vsR\xde\x08_\xc2\xbfe\xda\xad[i\xbb\x10\xc0*\xd8O[:\xc6\x10@Q\x82\xa3\x97\xc8\x86\x11\xc0\x8f\xff^\x9fd\xb6\x03@\xf8T#\xc7U$\x0f@\x0f\x06\x1a\x07\xabv\xab?\x92\x8c\x01\xf8e\xbc\x0b@\xdc)\xac\xdc\xd3\xf0\x12\xc0\x95=\x88\x1c\x1c\x8f\x04\xc0\x1c\x18p\xf3\xe4>\xcc?\xe0B\xb6\xa1\xfc\xc3\n\xc0\xdf\xealfg\xfa\x01@\xb4\xb4\xc4\xd5\xd08\xf7?\x92\xad\x08q\xd6Q\xe7?\xf1\xf1\x071L\xf0\xf3\xbfNC\xc8\xae\xa9\xb2\x0e@\xd0\xed\xa2k\xd7Y\x01@h\'\xfb\xd9"*\xc5\xbf\x87\xb2\x9d \xb3\x8e\x12\xc0j\xc7\xb0\xe8:q\x14\xc0\x10\x8c\x19F\xfcW\x1d\xc0|B\x92#9\xd8\x11\xc0l\xe2X\xe3\xc4\x7f\x07\xc08\xa9[).\xa1\xc9?\xecKX\n}\xb6\xe2?\xf6`Ce\xad\xe4\r@\x13\xa7X\x93\x0e\xeb\xf5\xbf\xf2R\xca\xd7T\xd9\t@\xa6U%\xce\x98\xd5\xf6\xbf\x84\xf4w9y\x99\x0e\xc0\xb8\xf0\xd6\x12\x08$\x11\xc0G\xc6\xde (\x87\n\xc0\x90\xe6|\x14\xa2\xcf\x10@\xf7Th\\\xe8\x04\x0f\xc0\xff\x1c.}6\xfa\x83\xbf5e\xf5I\xaaI\x1c\xc0R\x81\xf4\x16\xd7\xb7\x07\xc0\x05_\xaf!\xd1\x1c\xe7?\xf0\xb8($ x\x16\xc0\x9c2\xbc\xb5\x16\xcf\x03\xc0\xe6\x9d\x1d\xd4\x03\xde\xd3?\x15\xfc\xd5\x96\x87\xa3\xfa?3\xe0\xc3\\Ns\xcc\xbf\n\x88\xd4xgi\x0c\xc09\xd2\xa9\xde\x02\x0f\x10@\xb5m]\xee\xe6\x92\n@\x96\xcc\x87\xff\x188\x08@\x8f:\x9b\xf3\x1c\xd3\xf1?2~_\xcdk\xce\x03\xc0,M\xdc\x13\xd4k\x18@MA\xea\xd8\x9b\xe6\xff\xbfM\xf0\n\xd1\xdf\x8f\x08\xc0\xd9\xe9\xf2\x8c\xa7\x15\x1f@\x04\xdfY\rG\xeb\xd6\xbf\xa3\x90h\xa0v\x9a\xfc\xbf\xbb\xefr\x85\xacH\t\xc0\xce\xbcq\xee\x16@\xf5\xbf\xaa>\x0b\xf2*\xcc\x07\xc0\x13\x88\xc9Ia\xfe\xd7\xbf\xdb\xeb\xd8\x93\xcc(\xf5\xbfrCh\xb1\x1d\x10\x11\xc0\x9ct.w\x15\xd6\xfc?7\x029T\xf0U\x1a\xc0o\xca\xef\x04@n\xca\xbf\xed\x07\xeb\xb2Z\xc9\x06@\x1a\x87\xfa\x98\xb6\xd5\xff?\xfe\xca\x9b\x98\x04\xa4\x12\xc0\xb2\x18\xf6\xbfu\xc2\x8c\xc2d\x83\x00\xc0$\xc7\x02\xc12\xf2\xfd?\xd5\xbfH\xb7EY\x12@7d\xd6J\xc1\xe0\x12\xc0\x88\xf4\xad\x85\x9d\t\xe3\xbf\xde\xdf\xce\x1b\xb6\x81\xe8\xbfk^\x81&\xba\xfa\xf0?%\x16\x06\xea\x02!\xf6\xbf\xe6\xf7\n\x00#\xed\xfe?\x81\xec\x87~{n\x10\xc0\x1cv9\x17m\xaf\xbc\xbf\xed\x99=\x03]\x9a\xeb\xbf\x91\x06zR\xb5\x7f\x04\xc0\x1b\x07\xd1\x8e\xf9\xbd\x04\xc0\x91\xc1\x84\xb2\x18\x1f\x02\xc0\xcdF\xb3_\x08\xb0\x0c@\xc0\xf5\x1dI\x85\x9b\xc9\xbf=)\xf1\x13\xae\xb0\xf7\xbfq|\xeaZ:\x14\xe8\xbf\xac\x7fT\xcd\x93\x92\xec?\xd7\x82\x1a\xdc\x81\xba\xe9\xbfv8\xd2D\xcf\xca\x06@Ju~\x9c\xdf\xaf\xe7\xbf2\x1afn\x0e \x0b@\xeb\xf1\xf7\x92i|\x04\xc0^<\x02\x82;(\xf8\xbf\x11\x00\x19\xc1\xda\xa1\x00\xc0l\xcfCf\x08z\xf5?\xd9H\xd9lD\xd2\t@1\xf6\xcb\xe98\xfd\x02@P"\xcd\x91\x8f\x05\xfb?Oi6N\xf3\xdf\x11@' +tbag2 +(g3 +(I0 +tS'b' +tRp10 +(I1 +(I10 +I1 +tg6 +I00 +S'\xe4\xf0\xfeF\xc5\xaf\x10\xc0\xdfI0\x14\x82\xc1\x04\xc0\xb1\xf0D