From fd59591000f0d7d38c96fb3e1aa7d4692f73930f Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 10 Oct 2017 13:48:13 -0700 Subject: [PATCH 01/43] SingleVariableCostFunction in nn/part2 --- animation/transform.py | 3 +- nn/part2.py | 1021 +++++++++- nn/scenes.py | 4248 ---------------------------------------- scene/scene.py | 6 +- 4 files changed, 964 insertions(+), 4314 deletions(-) delete mode 100644 nn/scenes.py diff --git a/animation/transform.py b/animation/transform.py index d51755a1..9a033746 100644 --- a/animation/transform.py +++ b/animation/transform.py @@ -59,7 +59,8 @@ class Transform(Animation): Animation.clean_up(self, surrounding_scene) if self.replace_mobject_with_target_in_scene and surrounding_scene is not None: surrounding_scene.remove(self.mobject) - surrounding_scene.add(self.original_target_mobject) + if not self.remover: + surrounding_scene.add(self.original_target_mobject) class ReplacementTransform(Transform): CONFIG = { diff --git a/nn/part2.py b/nn/part2.py index 1e729264..b9d962b3 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -103,8 +103,11 @@ class PreviewLearning(NetworkScene): "max_stroke_width" : 3, "stroke_width_exp" : 3, "eta" : 3.0, - "positive_change_color" : average_color(*2*[GREEN] + [YELLOW]), + "positive_edge_color" : BLUE, + "negative_edge_color" : RED, + "positive_change_color" : average_color(*2*[BLUE] + [YELLOW]), "negative_change_color" : average_color(*2*[RED] + [YELLOW]), + "default_activate_run_time" : 1.5, } def construct(self): self.initialize_network() @@ -133,7 +136,7 @@ class PreviewLearning(NetworkScene): FadeOut(image), self.network_mob.layers.restore ) - def activate_network(self, train_in, *added_anims): + def activate_network(self, train_in, *added_anims, **kwargs): network_mob = self.network_mob layers = network_mob.layers layers.save_state() @@ -143,16 +146,17 @@ class PreviewLearning(NetworkScene): for i, vect in enumerate(activations) ] all_edges = VGroup(*it.chain(*network_mob.edge_groups)) + run_time = kwargs.get("run_time", self.default_activate_run_time) edge_animation = LaggedStart( ShowCreationThenDestruction, all_edges.copy().set_fill(YELLOW), - run_time = 1.5, + run_time = run_time, lag_ratio = 0.3, remover = True, ) layer_animation = Transform( VGroup(*layers), VGroup(*active_layers), - run_time = 1.5, + run_time = run_time, submobject_mode = "lagged_start", rate_func = None, ) @@ -240,13 +244,27 @@ class PreviewLearning(NetworkScene): matrix_max = np.max(matrix) for neuron, row in zip(layer.neurons, matrix): for edge, w in zip(neuron.edges_in, row): - color = GREEN if w > 0 else RED + if w > 0: + color = self.positive_edge_color + else: + color = self.negative_edge_color msw = self.max_stroke_width swe = self.stroke_width_exp sw = msw*(abs(w)/matrix_max)**swe sw = min(sw, msw) edge.set_stroke(color, sw) + def get_edge_animation(self): + edges = VGroup(*it.chain(*self.network_mob.edge_groups)) + return LaggedStart( + ApplyFunction, edges, + lambda mob : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + mob + ), + rate_func = wiggle + ) + class TrainingVsTestData(Scene): CONFIG = { "n_examples" : 10, @@ -414,39 +432,45 @@ class FunctionMinmization(GraphScene): self.dither(10) class IntroduceCostFunction(PreviewLearning): + CONFIG = { + "max_stroke_width" : 2, + "full_edges_exp" : 5, + "n_training_examples" : 100, + } def construct(self): - self.force_skipping() - + self.network_mob.shift(LEFT) self.isolate_one_neuron() self.reminder_of_weights_and_bias() - self.initialize_randomly() + self.bring_back_rest_of_network() self.feed_in_example() self.make_fun_of_output() self.need_a_cost_function() - self.show_cost_function() + self.fade_all_but_last_layer() + self.break_down_cost_function() + self.average_over_all_training_data() def isolate_one_neuron(self): network_mob = self.network_mob - network_mob.shift(LEFT) - neuron_groups = VGroup(*[ + neurons = VGroup(*it.chain(*[ layer.neurons for layer in network_mob.layers[1:] - ]) - edge_groups = network_mob.edge_groups - neuron = neuron_groups[0][7].deepcopy() + ])) + edges = VGroup(*it.chain(*network_mob.edge_groups)) + neuron = network_mob.layers[1].neurons[7] + neurons.remove(neuron) + edges.remove(*neuron.edges_in) output_labels = network_mob.output_labels kwargs = { "submobject_mode" : "lagged_start", "run_time" : 2, } self.play( - FadeOut(edge_groups, **kwargs), - FadeOut(neuron_groups, **kwargs), + FadeOut(edges, **kwargs), + FadeOut(neurons, **kwargs), FadeOut(output_labels, **kwargs), Animation(neuron), neuron.edges_in.set_stroke, None, 2, ) - self.dither() self.neuron = neuron @@ -458,13 +482,9 @@ class IntroduceCostFunction(PreviewLearning): ) prev_neurons = layer0.neurons - weights = 4*(np.random.random(len(neuron.edges_in))-0.5) weighted_edges = VGroup(*[ - edge.copy().set_stroke( - color = GREEN if w > 0 else RED, - width = abs(w) - ) - for w, edge in zip(weights, neuron.edges_in) + self.color_edge_randomly(edge.copy(), exp = 1) + for edge in neuron.edges_in ]) formula = TexMobject( @@ -495,13 +515,13 @@ class IntroduceCostFunction(PreviewLearning): weights_word = TextMobject("Weights") weights_word.next_to(neuron.edges_in, RIGHT, aligned_edge = UP) weights_word.highlight(GREEN) - weights_arrow = Arrow( + weights_arrow_to_edges = Arrow( weights_word.get_bottom(), neuron.edges_in[0].get_center(), color = GREEN ) - alt_weights_arrows = VGroup(*[ + weights_arrow_to_syms = VGroup(*[ Arrow( weights_word.get_bottom(), w_label.get_top(), @@ -516,77 +536,954 @@ class IntroduceCostFunction(PreviewLearning): bias_word.next_to(bias_arrow, UP, SMALL_BUFF) bias_word.highlight(BLUE) - self.revert_to_original_skipping_status() self.play( Transform(layer0, active_layer0), - FadeIn(a_labels), - FadeIn(symbols), + neuron.set_fill, None, 0.5, + FadeIn(formula), run_time = 2, submobject_mode = "lagged_start" ) + self.play(LaggedStart( + ShowCreationThenDestruction, + neuron.edges_in.copy().set_stroke(YELLOW, 3), + run_time = 1.5, + lag_ratio = 0.7, + remover = True + )) self.play( Write(weights_word), - GrowArrow(weights_arrow), - Transform(neuron.edges_in, weighted_edges), - run_time = 1, + *map(GrowArrow, weights_arrow_to_syms), + run_time = 1 ) self.dither() self.play( ReplacementTransform( - weighted_edges.copy(), w_labels, + w_labels.copy(), weighted_edges, + remover = True ), + Transform(neuron.edges_in, weighted_edges), ReplacementTransform( - VGroup(weights_arrow), - alt_weights_arrows + weights_arrow_to_syms, + VGroup(weights_arrow_to_edges), ) ) self.dither() self.play( - Write(b), Write(bias_word), GrowArrow(bias_arrow), run_time = 1 ) - self.play(Write(sigma)) self.dither(2) - def initialize_randomly(self): - pass + ## Initialize randomly + w_random = TextMobject("Initialize randomly") + w_random.move_to(weights_word, LEFT) + b_random = w_random.copy() + b_random.move_to(bias_word, RIGHT) + + self.play( + Transform(weights_word, w_random), + Transform(bias_word, b_random), + *[ + ApplyFunction(self.color_edge_randomly, edge) + for edge in neuron.edges_in + ] + ) + self.play(LaggedStart( + ApplyMethod, neuron.edges_in, + lambda m : (m.rotate_in_place, np.pi/12), + rate_func = wiggle, + run_time = 2 + )) + self.play(*map(FadeOut, [ + weights_word, weights_arrow_to_edges, + bias_word, bias_arrow, + formula + ])) + + def bring_back_rest_of_network(self): + network_mob = self.network_mob + neurons = VGroup(*network_mob.layers[1].neurons) + neurons.remove(self.neuron) + for layer in network_mob.layers[2:]: + neurons.add(*layer.neurons) + neurons.add(*network_mob.output_labels) + + edges = VGroup(*network_mob.edge_groups[0]) + edges.remove(*self.neuron.edges_in) + for edge_group in network_mob.edge_groups[1:]: + edges.add(*edge_group) + + for edge in edges: + self.color_edge_randomly(edge, exp = self.full_edges_exp) + + self.play(*[ + LaggedStart( + FadeIn, group, + run_time = 3, + ) + for group in neurons, edges + ]) def feed_in_example(self): - pass + vect = get_organized_images()[3][5] + image = PixelsFromVect(vect) + image.to_corner(UP+LEFT) + rect = SurroundingRectangle(image, color = BLUE) + neurons = VGroup(*[ + Circle( + stroke_width = 1, + stroke_color = WHITE, + fill_opacity = pixel.fill_rgb[0], + fill_color = WHITE, + radius = pixel.get_height()/2 + ).move_to(pixel) + for pixel in image + ]) + layer0= self.network_mob.layers[0] + n = self.network_mob.max_shown_neurons + neurons.target = VGroup(*it.chain( + layer0.neurons[:n/2], + [ + VectorizedPoint(layer0.dots.get_center()) + for x in xrange(len(neurons)-n) + ], + layer0.neurons[-n/2:] + )) + + self.play( + self.network_mob.shift, 0.5*RIGHT, + ShowCreation(rect), + LaggedStart(DrawBorderThenFill, image), + LaggedStart(DrawBorderThenFill, neurons), + run_time = 1 + ) + self.play(MoveToTarget( + neurons, submobject_mode = "lagged_start", + remover = True + )) + self.activate_network(vect, run_time = 2) + + self.image = image + self.image_rect = rect def make_fun_of_output(self): - pass + last_layer = self.network_mob.layers[-1].neurons + last_layer.add(self.network_mob.output_labels) + rect = SurroundingRectangle(last_layer) + words = TextMobject("Utter trash") + words.next_to(rect, DOWN, aligned_edge = LEFT) + VGroup(rect, words).highlight(YELLOW) + + self.play( + ShowCreation(rect), + Write(words, run_time = 2) + ) + self.dither() + + self.trash_rect = rect + self.trash_words = words def need_a_cost_function(self): - pass + vect = np.zeros(10) + vect[3] = 1 + output_labels = self.network_mob.output_labels + desired_layer = self.network_mob.get_active_layer(-1, vect) + layer = self.network_mob.layers[-1] + layer.add(output_labels) + desired_layer.add(output_labels.copy()) + desired_layer.shift(2*RIGHT) + layers = VGroup(layer, desired_layer) - def show_cost_function(self): - pass + words = TextMobject( + "What's the", "``cost''\\\\", "of this difference?", + ) + words.highlight_by_tex("cost", RED) + words.next_to(layers, UP) + words.to_edge(UP) + words.shift_onto_screen() + double_arrow = DoubleArrow( + layer.get_right(), + desired_layer.get_left(), + color = RED + ) + self.play(FadeIn(words)) + self.play(ReplacementTransform(layer.copy(), desired_layer)) + self.play(GrowFromCenter(double_arrow)) + self.dither(2) + + self.desired_last_layer = desired_layer + self.diff_arrow = double_arrow + + def fade_all_but_last_layer(self): + network_mob = self.network_mob + to_fade = VGroup(*it.chain(*zip( + network_mob.layers[:-1], + network_mob.edge_groups + ))) + + self.play(LaggedStart(FadeOut, to_fade, run_time = 1)) + + def break_down_cost_function(self): + layer = self.network_mob.layers[-1] + desired_layer = self.desired_last_layer + decimal_groups = VGroup(*[ + self.num_vect_to_decimals(self.layer_to_num_vect(l)) + for l in layer, desired_layer + ]) + + terms = VGroup() + symbols = VGroup() + for d1, d2 in zip(*decimal_groups): + term = TexMobject( + "(", "0.00", "-", "0.00", ")^2", "+", + ) + term.scale(d1.get_height()/term[1].get_height()) + for d, i in (d1, 1), (d2, 3): + term.submobjects[i] = d.move_to(term[i]) + terms.add(term) + symbols.add(*term) + symbols.remove(d1, d2) + last_plus = term[-1] + for mob in terms[-1], symbols: + mob.remove(last_plus) + terms.arrange_submobjects( + DOWN, buff = SMALL_BUFF, + aligned_edge = LEFT + ) + terms.scale_to_fit_height(1.5*layer.get_height()) + terms.next_to(layer, LEFT, buff = 2) + + image_group = Group(self.image, self.image_rect) + image_group.generate_target() + image_group.target.scale(0.5) + cost_of = TextMobject("Cost of").highlight(RED) + cost_group = VGroup(cost_of, image_group.target) + cost_group.arrange_submobjects(RIGHT) + brace = Brace(terms, LEFT) + cost_group.next_to(brace, LEFT) + + self.revert_to_original_skipping_status() + self.play(*[ + ReplacementTransform( + VGroup(*l.neurons[:10]).copy(), dg + ) + for l, dg in zip([layer, desired_layer], decimal_groups) + ]) + self.play( + FadeIn(symbols), + MoveToTarget(image_group), + FadeIn(cost_of), + GrowFromCenter(brace), + ) + self.dither() + + self.decimal_groups = decimal_groups + self.image_group = image_group + self.cost_group = VGroup(cost_of, image_group) + + def average_over_all_training_data(self): + image_group = self.image_group + decimal_groups = self.decimal_groups + + random_neurons = self.network_mob.layers[-1].neurons + desired_neurons = self.desired_last_layer.neurons + + dither_times = iter(it.chain( + 4*[0.5], + 4*[0.25], + 8*[0.125], + it.repeat(0.1) + )) + + words = TextMobject("Average cost of \\\\ all training data...") + words.highlight(BLUE) + words.to_corner(UP+LEFT) + + self.play( + Write(words, run_time = 1), + ) + + training_data, validation_data, test_data = load_data_wrapper() + for in_vect, out_vect in training_data[:self.n_training_examples]: + random_v = np.random.random(10) + new_decimal_groups = VGroup(*[ + self.num_vect_to_decimals(v) + for v in random_v, out_vect + ]) + for ds, nds in zip(decimal_groups, new_decimal_groups): + for old_d, new_d in zip(ds, nds): + new_d.replace(old_d) + self.remove(decimal_groups) + self.add(new_decimal_groups) + decimal_groups = new_decimal_groups + for pair in (random_v, random_neurons), (out_vect, desired_neurons): + for n, neuron in zip(*pair): + neuron.set_fill(opacity = n) + new_image_group = MNistMobject(in_vect) + new_image_group.replace(image_group) + self.remove(image_group) + self.add(new_image_group) + image_group = new_image_group + + self.dither(dither_times.next()) #### - def activate_network(self, train_in, *added_anims): - ##TODO - PreviewLearning.activate_network(self, train_in, *added_anims) - - - - - - - - - - - - - - - - + def color_edge_randomly(self, edge, exp = 1): + r = (2*np.random.random()-1)**exp + r *= self.max_stroke_width + pc, nc = self.positive_edge_color, self.negative_edge_color + edge.set_stroke( + color = pc if r > 0 else nc, + width = abs(r), + ) + return edge + + def layer_to_num_vect(self, layer, n_terms = 10): + return [ + n.get_fill_opacity() + for n in layer.neurons + ][:n_terms] + + def num_vect_to_decimals(self, num_vect): + return VGroup(*[ + DecimalNumber(n).set_fill(opacity = 0.5*n + 0.5) + for n in num_vect + ]) + + def num_vect_to_column_vector(self, num_vect, height): + decimals = VGroup(*[ + DecimalNumber(n).set_fill(opacity = 0.5*n + 0.5) + for n in num_vect + ]) + decimals.arrange_submobjects(DOWN) + decimals.scale_to_fit_height(height) + lb, rb = brackets = TexMobject("[]") + brackets.scale(2) + brackets.stretch_to_fit_height(height + SMALL_BUFF) + lb.next_to(decimals, LEFT) + rb.next_to(decimals, RIGHT) + result = VGroup(brackets, decimals) + result.brackets = brackets + result.decimals = decimals + return result + +class ThisIsVeryComplicated(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "Very complicated!", + target_mode = "surprised", + run_time = 1, + ) + self.change_student_modes(*3*["guilty"]) + self.dither(2) + +class EmphasizeComplexityOfCostFunction(IntroduceCostFunction): + CONFIG = { + "stroke_width_exp" : 3, + "n_examples" : 32, + } + def construct(self): + self.setup_sides() + self.show_network_as_a_function() + self.show_cost_function() + + def setup_sides(self): + v_line = Line(UP, DOWN).scale(SPACE_HEIGHT) + network_mob = self.network_mob + network_mob.scale_to_fit_width(SPACE_WIDTH - 1) + network_mob.to_corner(DOWN+LEFT) + + self.add(v_line) + self.color_network_edges() + + def show_network_as_a_function(self): + title = TextMobject("Neural network function") + title.shift(SPACE_WIDTH*RIGHT/2) + title.to_edge(UP) + underline = Line(LEFT, RIGHT) + underline.stretch_to_fit_width(title.get_width()) + underline.next_to(title, DOWN, SMALL_BUFF) + self.add(title, underline) + + words = self.get_function_description_words( + "784 numbers (pixels)", + "10 numbers", + "13{,}002 weights/biases", + ) + input_words, output_words, parameter_words = words + for word in words: + self.add(word[0]) + + in_vect = get_organized_images()[7][8] + activations = self.network.get_activation_of_all_layers(in_vect) + image = MNistMobject(in_vect) + image.scale_to_fit_height(1.5) + image_label = TextMobject("Input") + image_label.highlight(input_words[0].get_color()) + image_label.next_to(image, UP, SMALL_BUFF) + + arrow = Arrow(LEFT, RIGHT, color = WHITE) + arrow.next_to(image, RIGHT) + output = self.num_vect_to_column_vector(activations[-1], 2) + output.next_to(arrow, RIGHT) + + group = Group(image, image_label, arrow, output) + group.next_to(self.network_mob, UP, 0, RIGHT) + + dot = Dot() + dot.move_to(input_words.get_right()) + dot.set_fill(opacity = 0.5) + + self.play(FadeIn(input_words[1], submobject_mode = "lagged_start")) + self.play( + dot.move_to, image, + dot.set_fill, None, 0, + FadeIn(image), + FadeIn(image_label), + ) + self.activate_network(in_vect, + GrowArrow(arrow), + FadeIn(output), + FadeIn(output_words[1]) + ) + self.dither() + self.play( + FadeIn(parameter_words[1]), + self.get_edge_animation() + ) + self.dither(2) + + self.to_fade = group + self.curr_words = words + self.title = title + self.underline = underline + + def show_cost_function(self): + network_mob = self.network_mob + to_fade = self.to_fade + input_words, output_words, parameter_words = self.curr_words + + network_mob.generate_target() + network_mob.target.scale_in_place(0.7) + network_mob.target.to_edge(UP, buff = LARGE_BUFF) + rect = SurroundingRectangle(network_mob.target, color = BLUE) + network_label = TextMobject("Input") + network_label.highlight(input_words[0].get_color()) + network_label.next_to(rect, UP, SMALL_BUFF) + + new_output_word = TextMobject("1 number", "(the cost)") + new_output_word[1].highlight(RED).scale(0.9) + new_output_word.move_to(output_words[1], LEFT) + new_output_word.shift(0.5*SMALL_BUFF*DOWN) + new_parameter_word = TextMobject(""" + \\begin{flushleft} + Many, many, many \\\\ training examples + \\end{flushleft} + """).scale(0.9) + new_parameter_word.move_to(parameter_words[1], UP+LEFT) + + new_title = TextMobject("Cost function") + new_title.highlight(RED) + new_title.move_to(self.title) + + arrow = Arrow(UP, DOWN, color = WHITE) + arrow.next_to(rect, DOWN) + cost = TextMobject("Cost: 5.4") + cost.highlight(RED) + cost.next_to(arrow, DOWN) + + training_data, validation_data, test_data = load_data_wrapper() + training_examples = Group(*map( + self.get_training_pair_mob, + training_data[:self.n_examples] + )) + training_examples.next_to(parameter_words, DOWN, buff = LARGE_BUFF) + + self.play( + FadeOut(to_fade), + FadeOut(input_words[1]), + FadeOut(output_words[1]), + MoveToTarget(network_mob), + FadeIn(rect), + FadeIn(network_label), + Transform(self.title, new_title), + self.underline.stretch_to_fit_width, new_title.get_width() + ) + self.play( + ApplyMethod( + parameter_words[1].move_to, input_words[1], LEFT, + path_arc = np.pi, + ), + self.get_edge_animation() + ) + self.dither() + self.play( + GrowArrow(arrow), + Write(cost, run_time = 1) + ) + self.play(Write(new_output_word, run_time = 1)) + self.dither() + self.play( + FadeIn(new_parameter_word), + FadeIn(training_examples[0]) + ) + self.dither(0.5) + for last_ex, ex in zip(training_examples, training_examples[1:]): + activations = self.network.get_activation_of_all_layers( + ex.in_vect + ) + for i, a in enumerate(activations): + layer = self.network_mob.layers[i] + active_layer = self.network_mob.get_active_layer(i, a) + Transform(layer, active_layer).update(1) + self.remove(last_ex) + self.add(ex) + self.dither(0.25) + + #### + + def get_function_description_words(self, w1, w2, w3): + input_words = TextMobject("Input:", w1) + input_words[0].highlight(BLUE) + output_words = TextMobject("Output:", w2) + output_words[0].highlight(YELLOW) + parameter_words = TextMobject("Parameters:", w3) + parameter_words[0].highlight(GREEN) + words = VGroup(input_words, output_words, parameter_words) + words.arrange_submobjects(DOWN, aligned_edge = LEFT) + words.scale(0.9) + words.next_to(ORIGIN, RIGHT) + words.shift(UP) + return words + + def get_training_pair_mob(self, data): + in_vect, out_vect = data + image = MNistMobject(in_vect) + image.scale_to_fit_height(1) + comma = TextMobject(",") + comma.next_to(image, RIGHT, SMALL_BUFF, DOWN) + output = TexMobject(str(np.argmax(out_vect))) + output.scale_to_fit_height(0.75) + output.next_to(image, RIGHT, MED_SMALL_BUFF) + lp, rp = parens = TextMobject("()") + parens.scale(2) + parens.stretch_to_fit_height(1.2*image.get_height()) + lp.next_to(image, LEFT, SMALL_BUFF) + rp.next_to(lp, RIGHT, buff = 2) + + result = Group(lp, image, comma, output, rp) + result.in_vect = in_vect + return result + + +class YellAtNetwork(PiCreatureScene, PreviewLearning): + def setup(self): + PiCreatureScene.setup(self) + PreviewLearning.setup(self) + + def construct(self): + randy = self.randy + + network_mob = self.network_mob + network_mob.scale(0.5) + network_mob.next_to(randy, RIGHT, LARGE_BUFF) + self.color_network_edges() + eyes = Eyes(network_mob.edge_groups[1]) + + self.play( + PiCreatureBubbleIntroduction( + randy, "Horrible!", + target_mode = "angry", + look_at_arg = eyes, + run_time = 1, + ), + eyes.look_at_anim(randy.eyes) + ) + self.play(eyes.change_mode_anim("sad")) + self.play(eyes.look_at_anim(3*DOWN + 3*RIGHT)) + self.dither() + self.play(eyes.blink_anim()) + self.dither() + + #### + + def create_pi_creature(self): + randy = self.randy = Randolph() + randy.shift(3*LEFT + DOWN) + return randy + +class SingleVariableCostFunction(GraphScene): + CONFIG = { + "x_axis_label" : "$w$", + "y_axis_label" : "", + "x_min" : -5, + "x_max" : 7, + "x_axis_width" : 12, + "graph_origin" : 2.5*DOWN + LEFT, + "tangent_line_color" : YELLOW, + } + def construct(self): + self.reduce_full_function_to_single_variable() + self.show_graph() + self.find_exact_solution() + self.make_function_more_complicated() + self.take_steps() + self.take_steps_based_on_slope() + self.ball_rolling_down_hill() + self.note_step_sizes() + + def reduce_full_function_to_single_variable(self): + name = TextMobject("Cost function") + cf1 = TexMobject("C(", "w_1, w_2, \\dots, w_{13{,}002}", ")") + cf2 = TexMobject("C(", "w", ")") + for cf in cf1, cf2: + VGroup(cf[0], cf[2]).highlight(RED) + big_brace, lil_brace = [ + Brace(cf[1], DOWN) + for cf in cf1, cf2 + ] + big_brace_text = big_brace.get_text("Weights and biases") + lil_brace_text = lil_brace.get_text("Single input") + + name.next_to(cf1, UP, LARGE_BUFF) + name.highlight(RED) + + self.add(name, cf1) + self.play( + GrowFromCenter(big_brace), + FadeIn(big_brace_text) + ) + self.dither() + self.play( + ReplacementTransform(big_brace, lil_brace), + ReplacementTransform(big_brace_text, lil_brace_text), + ReplacementTransform(cf1, cf2), + ) + + # cf2.add_background_rectangle() + lil_brace_text.add_background_rectangle() + self.brace_group = VGroup(lil_brace, lil_brace_text) + cf2.add(self.brace_group) + self.function_label = cf2 + self.to_fade = name + + def show_graph(self): + function_label = self.function_label + self.setup_axes() + graph = self.get_graph( + lambda x : 0.5*(x - 3)**2 + 2, + color = RED + ) + + self.play( + FadeOut(self.to_fade), + Write(self.axes), + Animation(function_label), + run_time = 1, + ) + self.play( + function_label.next_to, + self.input_to_graph_point(5, graph), RIGHT, + ShowCreation(graph) + ) + self.dither() + + self.graph = graph + + def find_exact_solution(self): + function_label = self.function_label + graph = self.graph + + w_min = TexMobject("w", "_{\\text{min}}", arg_separator = "") + w_min.move_to(function_label[1], UP+LEFT) + w_min[1].fade(1) + x = 3 + dot = Dot( + self.input_to_graph_point(x, graph), + color = YELLOW + ) + line = self.get_vertical_line_to_graph( + x, graph, + line_class = DashedLine, + color = YELLOW + ) + formula = TexMobject("\\frac{dC}{dw}(w) = 0") + formula.next_to(dot, UP, buff = 2) + formula.shift(LEFT) + arrow = Arrow(formula.get_bottom(), dot.get_center()) + + self.play( + w_min.shift, + line.get_bottom() - w_min[0].get_top(), + MED_SMALL_BUFF*DOWN, + w_min.set_fill, WHITE, 1, + ) + self.play(ShowCreation(line)) + self.play(DrawBorderThenFill(dot, run_time = 1)) + self.dither() + self.play(Write(formula, run_time = 2)) + self.play(GrowArrow(arrow)) + self.dither() + + self.dot = dot + self.line = line + self.w_min = w_min + self.deriv_group = VGroup(formula, arrow) + + def make_function_more_complicated(self): + dot = self.dot + line = self.line + w_min = self.w_min + deriv_group = self.deriv_group + function_label = self.function_label + brace_group = function_label[-1] + function_label.remove(brace_group) + + brace = Brace(deriv_group, UP) + words = TextMobject("Sometimes \\\\ infeasible") + words.next_to(deriv_group, UP) + words.highlight(BLUE) + words.next_to(brace, UP) + + graph = self.get_graph( + lambda x : 0.05*((x+2)*(x-1)*(x-3))**2 + 2 + 0.3*(x-3), + color = RED + ) + + self.play( + ReplacementTransform(self.graph, graph), + function_label.shift, 2*UP+1.9*LEFT, + FadeOut(brace_group), + Animation(dot) + ) + self.graph = graph + self.play( + Write(words, run_time = 1), + GrowFromCenter(brace) + ) + self.dither(2) + self.play(FadeOut(VGroup(words, brace, deriv_group))) + + def take_steps(self): + dot = self.dot + line = self.line + w_mob, min_mob = self.w_min + graph = self.graph + + def update_line(line): + x = self.x_axis.point_to_number(w_mob.get_center()) + line.put_start_and_end_on_with_projection( + self.coords_to_point(x, 0), + self.input_to_graph_point(x, graph) + ) + return line + line_update_anim = UpdateFromFunc(line, update_line) + + def update_dot(dot): + dot.move_to(line.get_end()) + return dot + dot_update_anim = UpdateFromFunc(dot, update_dot) + + point = self.coords_to_point(2, 0) + arrows = VGroup() + q_marks = VGroup() + for vect, color in (LEFT, BLUE), (RIGHT, GREEN): + arrow = Arrow(ORIGIN, vect, buff = SMALL_BUFF) + arrow.shift(point + SMALL_BUFF*UP) + arrow.highlight(color) + arrows.add(arrow) + q_mark = TextMobject("?") + q_mark.next_to(arrow, UP, buff = 0) + q_mark.add_background_rectangle() + q_marks.add(q_mark) + + self.play( + w_mob.next_to, point, DOWN, + FadeOut(min_mob), + line_update_anim, + dot_update_anim, + ) + self.dither() + self.play(*it.chain( + map(GrowArrow, arrows), + map(FadeIn, q_marks), + )) + self.dither() + + self.arrow_group = VGroup(arrows, q_marks) + self.line_update_anim = line_update_anim + self.dot_update_anim = dot_update_anim + self.w_mob = w_mob + + def take_steps_based_on_slope(self): + arrows, q_marks = arrow_group = self.arrow_group + line_update_anim = self.line_update_anim + dot_update_anim = self.dot_update_anim + dot = self.dot + w_mob = self.w_mob + graph = self.graph + + x = self.x_axis.point_to_number(w_mob.get_center()) + tangent_line = self.get_tangent_line(x, arrows[0].get_color()) + + self.play( + ShowCreation(tangent_line), + Animation(dot), + ) + self.play(VGroup(arrows[1], q_marks).set_fill, None, 0) + self.play( + w_mob.shift, MED_SMALL_BUFF*LEFT, + MaintainPositionRelativeTo(arrow_group, w_mob), + line_update_anim, dot_update_anim, + ) + self.dither() + + new_x = 0.3 + new_point = self.coords_to_point(new_x, 0) + new_tangent_line = self.get_tangent_line( + new_x, arrows[1].get_color() + ) + self.play( + FadeOut(tangent_line), + w_mob.next_to, new_point, DOWN, + arrow_group.next_to, new_point, UP, SMALL_BUFF, + arrow_group.set_fill, None, 1, + dot_update_anim, + line_update_anim, + ) + self.play( + ShowCreation(new_tangent_line), + Animation(dot), + Animation(arrow_group), + ) + self.dither() + self.play(VGroup(arrows[0], q_marks).set_fill, None, 0) + self.play( + w_mob.shift, MED_SMALL_BUFF*RIGHT, + MaintainPositionRelativeTo(arrow_group, w_mob), + line_update_anim, dot_update_anim, + ) + self.play( + FadeOut(VGroup(new_tangent_line, arrow_group)), + Animation(dot), + ) + self.dither() + for x in 0.8, 1.1, 0.95: + self.play( + w_mob.next_to, self.coords_to_point(x, 0), DOWN, + line_update_anim, + dot_update_anim, + ) + self.dither() + + def ball_rolling_down_hill(self): + ball = self.dot + graph = self.graph + point = VectorizedPoint(self.coords_to_point(-0.5, 0)) + w_mob = self.w_mob + + def update_ball(ball): + x = self.x_axis.point_to_number(ball.point.get_center()) + graph_point = self.input_to_graph_point(x, graph) + vect = rotate_vector(UP, self.angle_of_tangent(x, graph)) + radius = ball.get_width()/2 + ball.move_to(graph_point + radius*vect) + return ball + + def update_point(point, dt): + x = self.x_axis.point_to_number(point.get_center()) + slope = self.slope_of_tangent(x, graph) + if abs(slope) > 0.5: + slope = 0.5 * slope / abs(slope) + x -= slope*dt + point.move_to(self.coords_to_point(x, 0)) + + + ball.generate_target() + ball.target.scale(2) + ball.target.set_fill(opacity = 0) + ball.target.set_stroke(BLUE, 3) + ball.point = point + ball.target.point = point + update_ball(ball.target) + + self.play(MoveToTarget(ball)) + self.play( + point.move_to, w_mob, + UpdateFromFunc(ball, update_ball), + run_time = 3, + ) + self.dither(2) + + points = [ + VectorizedPoint(self.coords_to_point(x, 0)) + for x in np.linspace(-2.7, 3.7, 11) + ] + balls = VGroup() + updates = [] + for point in points: + new_ball = ball.copy() + new_ball.point = point + balls.add(new_ball) + updates += [ + ContinualUpdateFromFunc(point, update_point), + ContinualUpdateFromFunc(new_ball, update_ball) + ] + balls.gradient_highlight(BLUE, GREEN) + + self.play(ReplacementTransform(ball, balls)) + self.add(*updates) + self.dither(5) + self.remove(*updates) + self.remove(*points) + self.play(FadeOut(balls)) + + def note_step_sizes(self): + w_mob = self.w_mob + line_update_anim = self.line_update_anim + + x = -0.5 + target_x = 0.94 + point = VectorizedPoint(self.coords_to_point(x, 0)) + line = self.get_tangent_line(x) + line.scale_in_place(0.5) + def update_line(line): + x = self.x_axis.point_to_number(point.get_center()) + self.make_line_tangent(line, x) + return line + + self.play( + ShowCreation(line), + w_mob.next_to, point, DOWN, + line_update_anim, + ) + for n in range(6): + x = self.x_axis.point_to_number(point.get_center()) + new_x = interpolate(x, target_x, 0.5) + self.play( + point.move_to, self.coords_to_point(new_x, 0), + MaintainPositionRelativeTo(w_mob, point), + line_update_anim, + UpdateFromFunc(line, update_line), + ) + self.dither(0.5) + self.dither() + + ### + + def get_tangent_line(self, x, color = YELLOW): + tangent_line = Line(LEFT, RIGHT).scale(3) + tangent_line.highlight(color) + self.make_line_tangent(tangent_line, x) + return tangent_line + + def make_line_tangent(self, line, x): + graph = self.graph + line.rotate(self.angle_of_tangent(x, graph) - line.get_angle()) + line.move_to(self.input_to_graph_point(x, graph)) diff --git a/nn/scenes.py b/nn/scenes.py deleted file mode 100644 index 489a25a2..00000000 --- a/nn/scenes.py +++ /dev/null @@ -1,4248 +0,0 @@ -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/scene/scene.py b/scene/scene.py index 1c43d3a4..8b78db06 100644 --- a/scene/scene.py +++ b/scene/scene.py @@ -479,14 +479,14 @@ class Scene(object): command = [ FFMPEG_BIN, - '-y', # overwrite output file if it exists + '-y', # overwrite output file if it exists '-f', 'rawvideo', '-vcodec','rawvideo', '-s', '%dx%d'%(width, height), # size of one frame '-pix_fmt', 'rgba', '-r', str(fps), # frames per second - '-i', '-', # The imput comes from a pipe - '-an', # Tells FFMPEG not to expect any audio + '-i', '-', # The imput comes from a pipe + '-an', # Tells FFMPEG not to expect any audio '-vcodec', 'mpeg', '-c:v', 'libx264', '-pix_fmt', 'yuv420p', From d138ffd353d8fea23feadb65e4b52f45be5f12a5 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 12 Oct 2017 17:38:25 -0700 Subject: [PATCH 02/43] Up to InterpretFirstWeightMatrixRows in NN part 2 --- mobject/mobject.py | 7 +- nn/network.py | 4 +- nn/part1.py | 20 +- nn/part2.py | 1184 +++++++++++++++++++++++++++++++++++++++++++- topics/geometry.py | 23 +- topics/numerals.py | 13 +- 6 files changed, 1210 insertions(+), 41 deletions(-) diff --git a/mobject/mobject.py b/mobject/mobject.py index d2b3265c..bec10171 100644 --- a/mobject/mobject.py +++ b/mobject/mobject.py @@ -446,11 +446,14 @@ class Mobject(object): return self.color ## - def save_state(self): + def save_state(self, use_deepcopy = False): if hasattr(self, "saved_state"): #Prevent exponential growth of data self.saved_state = None - self.saved_state = self.copy() + if use_deepcopy: + self.saved_state = self.deepcopy() + else: + self.saved_state = self.copy() return self def restore(self): diff --git a/nn/network.py b/nn/network.py index 14e4e666..be6daf3b 100644 --- a/nn/network.py +++ b/nn/network.py @@ -21,12 +21,12 @@ 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_80") # PRETRAINED_DATA_FILE = os.path.join(NN_DIRECTORY, "pretrained_weights_and_biases_ReLU") 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, 80, 10] DEFAULT_LAYER_SIZES = [28**2, 16, 16, 10] class Network(object): diff --git a/nn/part1.py b/nn/part1.py index ccacea64..1e311db4 100644 --- a/nn/part1.py +++ b/nn/part1.py @@ -196,19 +196,22 @@ class NetworkMobject(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 = self.get_edge(n1, n2) 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_edge(self, neuron1, neuron2): + return Line( + neuron1.get_center(), + neuron2.get_center(), + buff = self.neuron_radius, + stroke_color = self.edge_color, + stroke_width = self.edge_stroke_width, + ) + def get_active_layer(self, layer_index, activation_vector): layer = self.layers[layer_index].deepcopy() n_neurons = len(layer.neurons) @@ -2980,6 +2983,7 @@ class ContinualEdgeUpdate(ContinualAnimation): "max_stroke_width" : 3, "stroke_width_exp" : 7, "n_cycles" : 5, + "colors" : [GREEN, GREEN, GREEN, RED], } def __init__(self, network_mob, **kwargs): digest_config(self, kwargs) @@ -2988,7 +2992,7 @@ class ContinualEdgeUpdate(ContinualAnimation): self.move_to_targets = [] for edge in edges: edge.colors = [ - random.choice([GREEN, GREEN, GREEN, RED]) + random.choice(self.colors) for x in range(n_cycles) ] msw = self.max_stroke_width diff --git a/nn/part2.py b/nn/part2.py index b9d962b3..508d10af 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -37,6 +37,9 @@ from mobject.tex_mobject import * from nn.network import * from nn.part1 import * +POSITIVE_COLOR = BLUE +NEGATIVE_COLOR = RED + def get_training_image_group(train_in, train_out): image = MNistMobject(train_in) image.scale_to_fit_height(1) @@ -48,6 +51,35 @@ def get_training_image_group(train_in, train_out): result.to_edge(UP) return result +def get_decimal_vector(nums, with_dots = True): + decimals = VGroup() + for num in nums: + decimal = DecimalNumber(num) + if num > 0: + decimal.highlight(POSITIVE_COLOR) + else: + decimal.highlight(NEGATIVE_COLOR) + decimals.add(decimal) + contents = VGroup(*decimals) + if with_dots: + dots = TexMobject("\\vdots") + contents.submobjects.insert(len(decimals)/2, dots) + contents.arrange_submobjects(DOWN) + lb, rb = brackets = TexMobject("\\big[", "\\big]") + brackets.scale(2) + brackets.stretch_to_fit_height(1.2*contents.get_height()) + lb.next_to(contents, LEFT, SMALL_BUFF) + rb.next_to(contents, RIGHT, SMALL_BUFF) + + result = VGroup(lb, contents, brackets) + result.lb = lb + result.rb = rb + result.brackets = brackets + result.decimals = decimals + result.contents = contents + return result + + ######## class ShowLastVideo(TeacherStudentsScene): @@ -436,6 +468,7 @@ class IntroduceCostFunction(PreviewLearning): "max_stroke_width" : 2, "full_edges_exp" : 5, "n_training_examples" : 100, + "bias_color" : MAROON_B } def construct(self): self.network_mob.shift(LEFT) @@ -506,35 +539,34 @@ class IntroduceCostFunction(PreviewLearning): for tex in "=", "+", "dots" ]) - w_labels.highlight(GREEN) - b.highlight(BLUE) + w_labels.highlight(self.positive_edge_color) + b.highlight(self.bias_color) sigma.highlight(YELLOW) - # formula.to_edge(UP) formula.next_to(neuron, RIGHT) weights_word = TextMobject("Weights") weights_word.next_to(neuron.edges_in, RIGHT, aligned_edge = UP) - weights_word.highlight(GREEN) + weights_word.highlight(self.positive_edge_color) weights_arrow_to_edges = Arrow( weights_word.get_bottom(), neuron.edges_in[0].get_center(), - color = GREEN + color = self.positive_edge_color ) weights_arrow_to_syms = VGroup(*[ Arrow( weights_word.get_bottom(), w_label.get_top(), - color = GREEN + color = self.positive_edge_color ) for w_label in w_labels ]) bias_word = TextMobject("Bias") - bias_arrow = Vector(DOWN, color = BLUE) + bias_arrow = Vector(DOWN, color = self.bias_color) bias_arrow.next_to(b, UP, SMALL_BUFF) bias_word.next_to(bias_arrow, UP, SMALL_BUFF) - bias_word.highlight(BLUE) + bias_word.highlight(self.bias_color) self.play( Transform(layer0, active_layer0), @@ -643,12 +675,12 @@ class IntroduceCostFunction(PreviewLearning): layer0= self.network_mob.layers[0] n = self.network_mob.max_shown_neurons neurons.target = VGroup(*it.chain( - layer0.neurons[:n/2], + VGroup(*layer0.neurons[:n/2]).set_fill(opacity = 0), [ VectorizedPoint(layer0.dots.get_center()) for x in xrange(len(neurons)-n) ], - layer0.neurons[-n/2:] + VGroup(*layer0.neurons[-n/2:]).set_fill(opacity = 0), )) self.play( @@ -658,10 +690,13 @@ class IntroduceCostFunction(PreviewLearning): LaggedStart(DrawBorderThenFill, neurons), run_time = 1 ) - self.play(MoveToTarget( - neurons, submobject_mode = "lagged_start", - remover = True - )) + self.play( + MoveToTarget( + neurons, submobject_mode = "lagged_start", + remover = True + ), + layer0.neurons.set_fill, None, 0, + ) self.activate_network(vect, run_time = 2) self.image = image @@ -1078,7 +1113,6 @@ class EmphasizeComplexityOfCostFunction(IntroduceCostFunction): result.in_vect = in_vect return result - class YellAtNetwork(PiCreatureScene, PreviewLearning): def setup(self): PiCreatureScene.setup(self) @@ -1485,6 +1519,1126 @@ class SingleVariableCostFunction(GraphScene): line.rotate(self.angle_of_tangent(x, graph) - line.get_angle()) line.move_to(self.input_to_graph_point(x, graph)) +class TwoVariableInputSpace(Scene): + def construct(self): + self.add_plane() + self.ask_about_direction() + self.show_gradient() + + def add_plane(self): + plane = NumberPlane( + x_radius = SPACE_WIDTH/2 + ) + plane.add_coordinates() + name = TextMobject("Input space") + name.add_background_rectangle() + name.next_to(plane.get_corner(UP+LEFT), DOWN+RIGHT) + x, y = map(TexMobject, ["x", "y"]) + x.next_to(plane.coords_to_point(3.25, 0), UP, SMALL_BUFF) + y.next_to(plane.coords_to_point(0, 3.6), RIGHT, SMALL_BUFF) + + self.play( + *map(Write, [plane, name, x, y]), + run_time = 1 + ) + self.dither() + + self.plane = plane + + def ask_about_direction(self): + point = self.plane.coords_to_point(2, 1) + dot = Dot(point, color = YELLOW) + dot.save_state() + dot.move_to(SPACE_HEIGHT*UP + SPACE_WIDTH*RIGHT/2) + dot.fade(1) + arrows = VGroup(*[ + Arrow(ORIGIN, vect).shift(point) + for vect in compass_directions(8) + ]) + arrows.highlight(WHITE) + question = TextMobject( + "Which direction decreases \\\\", + "$C(x, y)$", "most quickly?" + ) + question.scale(0.7) + question.highlight(YELLOW) + question.highlight_by_tex("C(x, y)", RED) + question.add_background_rectangle() + question.next_to(arrows, LEFT) + + self.play(dot.restore) + self.play( + FadeIn(question), + LaggedStart(GrowArrow, arrows) + ) + self.dither() + + self.arrows = arrows + self.dot = dot + self.question = question + + def show_gradient(self): + arrows = self.arrows + dot = self.dot + question = self.question + + arrow = arrows[3] + new_arrow = Arrow( + dot.get_center(), arrow.get_end(), + buff = 0, + color = GREEN + ) + new_arrow.highlight(GREEN) + arrow.save_state() + + gradient = TexMobject("\\nabla C(x, y)") + gradient.add_background_rectangle() + gradient.next_to(arrow.get_end(), UP, SMALL_BUFF) + + gradient_words = TextMobject( + "``Gradient'', the direction\\\\ of", + "steepest increase" + ) + gradient_words.scale(0.7) + gradient_words[-1].highlight(GREEN) + gradient_words.next_to(gradient, UP, SMALL_BUFF) + gradient_words.add_background_rectangle(opacity = 1) + gradient_words.shift(LEFT) + + anti_arrow = new_arrow.copy() + anti_arrow.rotate(np.pi, about_point = dot.get_center()) + anti_arrow.highlight(RED) + + self.play( + Transform(arrow, new_arrow), + Animation(dot), + *[FadeOut(a) for a in arrows if a is not arrow] + ) + self.play(FadeIn(gradient)) + self.play(Write(gradient_words, run_time = 2)) + self.dither(2) + self.play( + arrow.fade, + ReplacementTransform( + arrow.copy(), + anti_arrow + ) + ) + self.dither(2) + +class CostSurface(ExternallyAnimatedScene): + pass + +class KhanAcademyMVCWrapper(PiCreatureScene): + def construct(self): + screen = ScreenRectangle(height = 5) + screen.to_corner(UP+LEFT) + morty = self.pi_creature + + self.play( + ShowCreation(screen), + morty.change, "raise_right_hand", + ) + self.dither(3) + self.play(morty.change, "happy", screen) + self.dither(5) + +class ShowFullCostFunctionGradient(PreviewLearning): + def construct(self): + self.organize_weights_as_column_vector() + self.show_gradient() + + def organize_weights_as_column_vector(self): + network_mob = self.network_mob + edges = VGroup(*it.chain(*network_mob.edge_groups)) + layers = VGroup(*network_mob.layers) + layers.add(network_mob.output_labels) + self.color_network_edges() + + nums = [2.25, -1.57, 1.98, -1.16, 3.82, 1.21] + decimals = VGroup(*[ + DecimalNumber(num).highlight( + BLUE_D if num > 0 else RED + ) + for num in nums + ]) + dots = TexMobject("\\vdots") + decimals.submobjects.insert(3, dots) + decimals.arrange_submobjects(DOWN) + decimals.shift(2*LEFT + 0.5*DOWN) + lb, rb = brackets = TexMobject("\\big[", "\\big]") + brackets.scale(2) + brackets.stretch_to_fit_height(1.2*decimals.get_height()) + lb.next_to(decimals, LEFT, SMALL_BUFF) + rb.next_to(decimals, RIGHT, SMALL_BUFF) + column_vect = VGroup(lb, decimals, rb) + + edges_target = VGroup(*it.chain( + decimals[:3], + [dots]*(len(edges) - 6), + decimals[-3:] + )) + + words = TextMobject("$13{,}002$ weights and biases") + words.next_to(column_vect, UP) + + lhs = TexMobject("\\vec{\\textbf{W}}", "=") + lhs[0].highlight(YELLOW) + lhs.next_to(column_vect, LEFT) + + self.play( + FadeOut(layers), + edges.space_out_submobjects, 1.2, + ) + self.play( + ReplacementTransform( + edges, edges_target, + run_time = 2, + submobject_mode = "lagged_start" + ), + LaggedStart(FadeIn, words), + ) + self.play(*map(Write, [lb, rb, lhs]), run_time = 1) + self.dither() + + self.column_vect = column_vect + + def show_gradient(self): + column_vect = self.column_vect + + lhs = TexMobject( + "-", "\\nabla", "C(", "\\vec{\\textbf{W}}", ")", "=" + ) + lhs.shift(2*RIGHT) + lhs.highlight_by_tex("W", YELLOW) + old_decimals = VGroup(*filter( + lambda m : isinstance(m, DecimalNumber), + column_vect[1] + )) + new_decimals = VGroup() + new_nums = [0.18, 0.45, -0.51, 0.4, -0.32, 0.82] + for decimal, new_num in zip(old_decimals, new_nums): + new_decimal = DecimalNumber(new_num) + new_decimal.highlight(BLUE if new_num > 0 else RED_B) + new_decimal.move_to(decimal) + new_decimals.add(new_decimal) + rhs = VGroup( + column_vect[0].copy(), + new_decimals, + column_vect[2].copy(), + ) + rhs.to_edge(RIGHT, buff = 1.75) + lhs.next_to(rhs, LEFT) + + words = TextMobject("How to nudge all \\\\ weights and biases") + words.next_to(rhs, UP) + + self.play(Write(VGroup(lhs, rhs))) + self.play(FadeIn(words)) + for od, nd in zip(old_decimals, new_decimals): + nd = nd.deepcopy() + od_num = od.number + nd_num = nd.number + self.play( + nd.move_to, od, + nd.shift, 1.5*RIGHT + ) + self.play( + Transform( + nd, VectorizedPoint(od.get_center()), + submobject_mode = "lagged_start", + remover = True + ), + ChangingDecimal( + od, + lambda a : interpolate(od_num, od_num+nd_num, a) + ) + ) + self.dither() + +class HowMinimizingCostMeansBetterTrainingPerformance(IntroduceCostFunction): + def construct(self): + IntroduceCostFunction.construct(self) + self.improve_last_layer() + + def improve_last_layer(self): + decimals = self.decimal_groups[0] + neurons = self.network_mob.layers[-1].neurons + + values = [d.number for d in decimals] + target_values = 0.1*np.random.random(10) + target_values[3] = 0.98 + + words = TextMobject("Minimize cost $\\dots$") + words.next_to(decimals, UP, MED_LARGE_BUFF) + words.highlight(YELLOW) + # words.shift(LEFT) + + def generate_update(n1, n2): + return lambda a : interpolate(n1, n2, a) + updates = [ + generate_update(n1, n2) + for n1, n2 in zip(values, target_values) + ] + + self.play(LaggedStart(FadeIn, words, run_time = 1)) + self.play(*[ + ChangingDecimal(d, update) + for d, update in zip(decimals, updates) + ] + [ + UpdateFromFunc( + d, + lambda mob: mob.set_fill( + interpolate_color(BLACK, WHITE, 0.5+0.5*mob.number), + opacity = 1 + ) + ) + for d in decimals + ] + [ + ApplyMethod(neuron.set_fill, WHITE, target_value) + for neuron, target_value in zip(neurons, target_values) + ], run_time = 3) + self.dither() + + ### + + def average_over_all_training_data(self): + pass #So that IntroduceCostFunction.construct doesn't do this + +class CostSurfaceSteps(ExternallyAnimatedScene): + pass + +class ConfusedAboutHighDimension(TeacherStudentsScene): + def construct(self): + self.student_says( + "13{,}002-dimensional \\\\ nudge?", + target_mode = "confused" + ) + self.change_student_modes(*["confused"]*3) + self.dither(2) + self.teacher_thinks( + "", + bubble_kwargs = {"width" : 6, "height" : 4}, + added_anims = [self.get_student_changes(*["plain"]*3)] + ) + self.zoom_in_on_thought_bubble() + +class NonSpatialGradientIntuition(Scene): + CONFIG = { + "w_color" : YELLOW, + "positive_color" : BLUE, + "negative_color" : RED, + "vect_height" : SPACE_HEIGHT - MED_LARGE_BUFF, + "text_scale_value" : 0.7, + } + def construct(self): + self.add_vector() + self.add_gradient() + self.show_sign_interpretation() + self.show_magnitude_interpretation() + + def add_vector(self): + lhs = TexMobject("\\vec{\\textbf{W}}", "=") + lhs[0].highlight(self.w_color) + lhs.to_edge(LEFT) + + ws = VGroup(*[ + VGroup(TexMobject(tex)) + for tex in it.chain( + ["w_%d"%d for d in range(3)], + ["\\vdots"], + ["w_{13{,}00%d}"%d for d in range(3)] + ) + ]) + ws.highlight(self.w_color) + ws.arrange_submobjects(DOWN) + lb, rb = brackets = TexMobject("\\big[", "\\big]").scale(2) + brackets.stretch_to_fit_height(1.2*ws.get_height()) + lb.next_to(ws, LEFT) + rb.next_to(ws, RIGHT) + vect = VGroup(lb, ws, rb) + + vect.scale_to_fit_height(self.vect_height) + vect.to_edge(UP).shift(2*LEFT) + lhs.next_to(vect, LEFT) + + self.add(lhs, vect) + self.vect = vect + self.top_lhs = lhs + + def add_gradient(self): + lb, ws, rb = vect = self.vect + ws = VGroup(*ws) + dots = ws[len(ws)/2] + ws.remove(dots) + + lhs = TexMobject( + "-\\nabla", "C(", "\\vec{\\textbf{W}}", ")", "=" + ) + lhs.next_to(vect, RIGHT, LARGE_BUFF) + lhs.highlight_by_tex("W", self.w_color) + + decimals = VGroup() + nums = [0.31, 0.03, -1.25, 0.78, -0.37, 0.16] + for num, w in zip(nums, ws): + decimal = DecimalNumber(num) + decimal.scale(self.text_scale_value) + if num > 0: + decimal.highlight(self.positive_color) + else: + decimal.highlight(self.negative_color) + decimal.move_to(w) + decimals.add(decimal) + new_dots = dots.copy() + + grad_content = VGroup(*it.chain( + decimals[:3], new_dots, decimals[3:] + )) + grad_vect = VGroup(lb.copy(), grad_content, rb.copy()) + VGroup(grad_vect[0], grad_vect[-1]).space_out_submobjects(0.8) + grad_vect.scale_to_fit_height(self.vect_height) + grad_vect.next_to(self.vect, DOWN) + lhs.next_to(grad_vect, LEFT) + + brace = Brace(grad_vect, RIGHT) + words = brace.get_text("Example gradient") + + self.dither() + self.play( + ReplacementTransform(self.top_lhs.copy(), lhs), + ReplacementTransform(self.vect.copy(), grad_vect), + GrowFromCenter(brace), + FadeIn(words) + ) + self.dither() + self.play(FadeOut(VGroup(brace, words))) + + self.ws = ws + self.grad_lhs = lhs + self.grad_vect = grad_vect + self.decimals = decimals + + def show_sign_interpretation(self): + ws = self.ws.copy() + decimals = self.decimals + + direction_phrases = VGroup() + for w, decimal in zip(ws, decimals): + if decimal.number > 0: + verb = "increase" + color = self.positive_color + else: + verb = "decrease" + color = self.negative_color + phrase = TextMobject("should", verb) + phrase.scale(self.text_scale_value) + phrase.highlight_by_tex(verb, color) + w.generate_target() + group = VGroup(w.target, phrase) + group.arrange_submobjects(RIGHT) + w.target.shift(0.7*SMALL_BUFF*DOWN) + group.move_to(decimal.get_center() + RIGHT, LEFT) + direction_phrases.add(phrase) + + self.play( + LaggedStart(MoveToTarget, ws), + LaggedStart(FadeIn, direction_phrases) + ) + self.dither(2) + + self.direction_phrases = direction_phrases + self.ws = ws + + def show_magnitude_interpretation(self): + direction_phrases = self.direction_phrases + ws = self.ws + decimals = self.decimals + + magnitude_words = VGroup() + rects = VGroup() + for phrase, decimal in zip(direction_phrases, decimals): + if abs(decimal.number) < 0.2: + adj = "a little" + color = interpolate_color(BLACK, WHITE, 0.5) + elif abs(decimal.number) < 0.5: + adj = "somewhat" + color = LIGHT_GREY + else: + adj = "a lot" + color = WHITE + words = TextMobject(adj) + words.scale(self.text_scale_value) + words.highlight(color) + words.next_to(phrase, RIGHT, SMALL_BUFF) + magnitude_words.add(words) + + rect = SurroundingRectangle( + VGroup(*decimal[-4:]), + buff = SMALL_BUFF, + color = LIGHT_GREY + ) + rect.target = words + rects.add(rect) + + self.play(LaggedStart(ShowCreation, rects)) + self.play(LaggedStart(MoveToTarget, rects)) + self.dither(2) + +class SomeConnectionsMatterMoreThanOthers(PreviewLearning): + def setup(self): + np.random.seed(1) + PreviewLearning.setup(self) + self.color_network_edges() + + ex_in = get_organized_images()[3][4] + image = MNistMobject(ex_in) + image.to_corner(UP+LEFT) + self.add(image) + self.ex_in = ex_in + + def construct(self): + self.activate_network(self.ex_in) + self.fade_edges() + self.show_important_connection() + self.show_unimportant_connection() + + def fade_edges(self): + edges = VGroup(*it.chain(*self.network_mob.edge_groups)) + self.play(*[ + ApplyMethod( + edge.set_stroke, BLACK, 0, + rate_func = lambda a : 0.5*smooth(a) + ) + for edge in edges + ]) + + def show_important_connection(self): + layers = self.network_mob.layers + edge = self.get_edge(2, 3) + edge.set_stroke(YELLOW, 4) + words = TextMobject("This weight \\\\ matters a lot") + words.next_to(layers[-1], UP).to_edge(UP) + words.highlight(YELLOW) + arrow = Arrow(words.get_bottom(), edge.get_center()) + + self.play( + ShowCreation(edge), + GrowArrow(arrow), + FadeIn(words) + ) + self.dither() + + def show_unimportant_connection(self): + color = TEAL + edge = self.get_edge(11, 6) + edge.set_stroke(color, 5) + words = TextMobject("Who even cares \\\\ about this weight?") + words.next_to(self.network_mob.layers[-1], DOWN) + words.to_edge(DOWN) + words.highlight(color) + arrow = Arrow(words.get_top(), edge.get_center(), buff = SMALL_BUFF) + arrow.highlight(color) + + self.play( + ShowCreation(edge), + GrowArrow(arrow), + FadeIn(words) + ) + self.dither() + ### + + def get_edge(self, i1, i2): + layers = self.network_mob.layers + n1 = layers[-2].neurons[i1] + n2 = layers[-1].neurons[i2] + return self.network_mob.get_edge(n1, n2) + +class TwoGradientInterpretationsIn2D(Scene): + def construct(self): + self.setup_plane() + self.add_function_definitions() + self.point_out_direction() + self.point_out_relative_importance() + + def setup_plane(self): + plane = NumberPlane() + plane.add_coordinates() + self.add(plane) + self.plane = plane + + def add_function_definitions(self): + func = TexMobject( + "C(", "x, y", ")", "=", + "\\frac{3}{2}x^2", "+", "\\frac{1}{2}y^2", + ) + func.shift(SPACE_WIDTH*LEFT/2).to_edge(UP) + + grad = TexMobject("\\nabla", "C(", "1, 1", ")", "=") + vect = TexMobject( + "\\left[\\begin{array}{c} 3 \\\\ 1 \\end{array}\\right]" + ) + vect.next_to(grad, RIGHT, SMALL_BUFF) + grad_group = VGroup(grad, vect) + grad_group.next_to(ORIGIN, RIGHT).to_edge(UP, buff = MED_SMALL_BUFF) + # grad_group.next_to(func, DOWN) + # for mob in grad, func: + # mob.highlight_by_tex("C(", RED) + # mob.highlight_by_tex(")", RED) + for mob in grad, vect, func: + mob.add_background_rectangle() + mob.background_rectangle.scale_in_place(1.1) + + self.play(Write(func, run_time = 1)) + self.play(Write(grad_group, run_time = 2)) + self.dither() + + self.func = func + self.grad = grad + self.vect = vect + + def point_out_direction(self): + coords = self.grad.get_part_by_tex("1, 1").copy() + vect = self.vect[1].copy() + coords.highlight(YELLOW) + vect.highlight(GREEN) + + dot = Dot(self.plane.coords_to_point(1, 1)) + dot.highlight(coords.get_color()) + arrow = Arrow( + self.plane.coords_to_point(1, 1), + self.plane.coords_to_point(4, 2), + buff = 0, + color = vect.get_color() + ) + words = TextMobject("Direction of \\\\ steepest ascent") + words.add_background_rectangle() + words.next_to(ORIGIN, DOWN) + words.rotate(arrow.get_angle()) + words.shift(arrow.get_center()) + + self.play(DrawBorderThenFill(coords, run_time = 1)) + self.play(ReplacementTransform(coords.copy(), dot)) + self.play(DrawBorderThenFill(vect, run_time = 1)) + self.play( + ReplacementTransform(vect.copy(), arrow), + Animation(dot) + ) + self.play(Write(words)) + self.dither() + + self.remove(vect) + self.vect[1].highlight(vect.get_color()) + self.remove(coords) + self.grad.get_part_by_tex("1, 1").highlight(coords.get_color()) + + def point_out_relative_importance(self): + func = self.func + grad_group = VGroup(self.grad, self.vect) + x_part = func.get_part_by_tex("x^2") + y_part = func.get_part_by_tex("y^2") + + self.play(func.shift, 1.5*DOWN) + + x_rect = SurroundingRectangle(x_part, color = YELLOW) + y_rect = SurroundingRectangle(y_part, color = TEAL) + x_words = TextMobject("$x$ has 3 times \\\\ the impact...") + x_words.highlight(x_rect.get_color()) + x_words.add_background_rectangle() + x_words.next_to(x_rect, UP) + # x_words.to_edge(LEFT) + y_words = TextMobject("...as $y$") + y_words.highlight(y_rect.get_color()) + y_words.add_background_rectangle() + y_words.next_to(y_rect, DOWN) + + self.play( + Write(x_words, run_time = 2), + ShowCreation(x_rect) + ) + self.dither() + self.play( + Write(y_words, run_time = 1), + ShowCreation(y_rect) + ) + self.dither(2) + +class ParaboloidGraph(ExternallyAnimatedScene): + pass + +class TODOInsertEmphasizeComplexityOfCostFunctionCopy(TODOStub): + CONFIG = { + "message" : "Insert EmphasizeComplexityOfCostFunction copy" + } + +class GradientNudging(PreviewLearning): + CONFIG = { + "n_steps" : 10 + } + def construct(self): + self.setup_network_mob() + self.add_gradient() + self.change_weights_repeatedly() + + def setup_network_mob(self): + network_mob = self.network_mob + self.color_network_edges() + network_mob.scale(0.7) + network_mob.to_corner(DOWN+RIGHT) + + def add_gradient(self): + lhs = TexMobject( + "-", "\\nabla", "C(", "\\dots", ")", "=" + ) + lhs.to_edge(LEFT) + brace = Brace(lhs.get_part_by_tex("dots"), DOWN) + words = brace.get_text("All weights \\\\ and biases") + words.scale(0.8, about_point = words.get_top()) + np.random.seed(3) + nums = 4*(np.random.random(8)-0.5) + vect = get_decimal_vector(nums) + vect.next_to(lhs, RIGHT) + + self.add(lhs, brace, words, vect) + + self.grad_vect = vect + + def change_weights_repeatedly(self): + network_mob = self.network_mob + edges = VGroup(*reversed(list( + it.chain(*network_mob.edge_groups) + ))) + + decimals = self.grad_vect.decimals + + words = TextMobject( + "Change by some small\\\\", + "multiple of $-\\nabla C(\\dots)$" + ) + words.next_to(network_mob, UP).to_edge(UP) + arrows = VGroup(*[ + Arrow( + words.get_bottom(), + edge_group.get_top(), + color = WHITE + ) + for edge_group in network_mob.edge_groups + ]) + + self.play( + ReplacementTransform( + decimals.copy().set_fill(opacity = 0).set_stroke(width = 1), + self.network_mob.edge_groups + ), + FadeIn(words), + LaggedStart(GrowArrow, arrows, run_time = 1) + ) + self.play(self.get_edge_change_anim(edges)) + self.play(*self.get_decimal_change_anims(decimals)) + for x in range(self.n_steps): + self.play(self.get_edge_change_anim(edges)) + self.play(*self.get_decimal_change_anims(decimals)) + self.dither() + + ### + + def get_edge_change_anim(self, edges): + target_nums = 6*(np.random.random(len(edges))-0.5) + edges.generate_target() + for edge, target_num in zip(edges.target, target_nums): + curr_num = edge.get_stroke_width() + if Color(edge.get_stroke_color()) == Color(self.negative_edge_color): + curr_num *= -1 + new_num = interpolate(curr_num, target_num, 0.2) + if new_num > 0: + new_color = self.positive_edge_color + else: + new_color = self.negative_edge_color + edge.set_stroke(new_color, abs(new_num)) + edge.rotate_in_place(np.pi) + return MoveToTarget( + edges, + submobject_mode = "lagged_start", + lag_factor = 8, + run_time = 1.5 + ) + + def get_decimal_change_anims(self, decimals): + changes = 0.2*(np.random.random(len(decimals))-0.5) + def generate_change_func(x, dx): + return lambda a : interpolate(x, x+dx, a) + return [ + ChangingDecimal( + decimal, + generate_change_func(decimal.number, change) + ) + for decimal, change in zip(decimals, changes) + ] + +class BackPropWrapper(PiCreatureScene): + def construct(self): + morty = self.pi_creature + screen = ScreenRectangle(height = 5) + screen.to_corner(UP+LEFT) + screen.shift(MED_LARGE_BUFF*DOWN) + + title = TextMobject("Backpropagation", "(next video)") + title.next_to(screen, UP) + + self.play( + morty.change, "raise_right_hand", screen, + ShowCreation(screen) + ) + self.play(Write(title[0], run_time = 1)) + self.dither() + self.play(Write(title[1], run_time = 1)) + self.play(morty.change, "happy", screen) + self.dither(5) + +class TODOInsertCostSurfaceSteps(TODOStub): + CONFIG = { + "message" : "Insert CostSurfaceSteps" + } + +class ContinuouslyRangingNeuron(PreviewLearning): + def construct(self): + self.color_network_edges() + network_mob = self.network_mob + network_mob.scale(0.8) + network_mob.to_edge(DOWN) + neuron = self.network_mob.layers[2].neurons[6] + decimal = DecimalNumber(0) + decimal.scale_to_fit_width(0.8*neuron.get_width()) + decimal.move_to(neuron) + + decimal.generate_target() + neuron.generate_target() + group = VGroup(neuron.target, decimal.target) + group.scale_to_fit_height(1) + group.next_to(network_mob, UP) + decimal.set_fill(opacity = 0) + + def update_decimal_color(decimal): + if neuron.get_fill_opacity() > 0.8: + decimal.highlight(BLACK) + else: + decimal.highlight(WHITE) + decimal_color_anim = UpdateFromFunc(decimal, update_decimal_color) + + self.play(*map(MoveToTarget, [neuron, decimal])) + for x in 0.7, 0.35, 0.97, 0.23, 0.54: + curr_num = neuron.get_fill_opacity() + self.play( + neuron.set_fill, None, x, + ChangingDecimal( + decimal, lambda a : interpolate(curr_num, x, a) + ), + decimal_color_anim + ) + self.dither() + +class AskHowItDoes(TeacherStudentsScene): + def construct(self): + self.student_says( + "How well \\\\ does it do?", + student_index = 0 + ) + self.dither(5) + +class TestPerformance(PreviewLearning): + CONFIG = { + "n_examples" : 200, + "time_per_example" : 0.1, + "wrong_dither_time" : 0.5 + } + def construct(self): + self.init_testing_data() + self.add_title() + self.add_fraction() + self.run_through_examples() + + def init_testing_data(self): + training_data, validation_data, test_data = load_data_wrapper() + self.test_data = iter(test_data[:self.n_examples]) + + def add_title(self): + title = TextMobject("Testing data") + title.to_corner(UP+LEFT) + self.add(title) + + def add_fraction(self): + self.n_correct = 0 + self.total = 0 + self.decimal = DecimalNumber(0) + word_frac = TexMobject( + "{\\text{Number correct}", "\\over", + "\\text{total}}", "=", + ) + word_frac[0].highlight(GREEN) + self.frac = self.get_frac() + self.equals = TexMobject("=") + fracs = VGroup( + word_frac, self.frac, + self.equals, self.decimal + ) + fracs.arrange_submobjects(RIGHT) + fracs.to_edge(UP) + self.add(fracs) + + def run_through_examples(self): + rects = [ + SurroundingRectangle(VGroup(neuron, label)) + for neuron, label in zip( + self.network_mob.layers[-1].neurons, + self.network_mob.output_labels + ) + ] + wrong = TextMobject("Wrong!") + wrong.highlight(RED) + + + for test_in, test_out in self.test_data: + self.total += 1 + image = MNistMobject(test_in) + image.to_edge(LEFT) + image.shift(UP) + self.add(image) + + activations = self.activate_layers(test_in) + choice = np.argmax(activations[-1]) + rect = rects[choice] + self.add(rect) + + correct = (choice == test_out) + if correct: + self.n_correct += 1 + else: + wrong.next_to(rect, RIGHT) + self.add(wrong) + new_frac = self.get_frac() + new_frac.shift( + self.frac[1].get_left() - \ + new_frac[1].get_left() + ) + self.remove(self.frac) + self.add(new_frac) + self.frac = new_frac + self.equals.next_to(new_frac, RIGHT) + + new_decimal = DecimalNumber(float(self.n_correct)/self.total) + new_decimal.next_to(self.equals, RIGHT) + self.remove(self.decimal) + self.add(new_decimal) + self.decimal = new_decimal + + self.dither(self.time_per_example) + if not correct: + self.dither(self.wrong_dither_time) + + self.remove(rect, wrong, image) + + self.add(rect, image) + + ### + def add_network(self): + self.network_mob = MNistNetworkMobject(**self.network_mob_config) + self.network_mob.scale(0.8) + self.network_mob.to_edge(DOWN) + self.network = self.network_mob.neural_network + self.add(self.network_mob) + self.color_network_edges() + + def get_frac(self): + frac = TexMobject("{%d"%self.n_correct, "\\over", "%d}"%self.total) + frac[0].highlight(GREEN) + return frac + + def activate_layers(self, test_in): + activations = self.network.get_activation_of_all_layers(test_in) + layers = self.network_mob.layers + for layer, activation in zip(layers, activations)[1:]: + for neuron, a in zip(layer.neurons, activation): + neuron.set_fill(opacity = a) + return activations + +class ReactToPerformance(TeacherStudentsScene): + def construct(self): + title = VGroup( + TextMobject("Play with network structure"), + Arrow(LEFT, RIGHT, color = WHITE), + TextMobject("98\\%", "testing accuracy") + ) + title.arrange_submobjects(RIGHT) + title.to_edge(UP) + title[-1][0].highlight(GREEN) + self.play(Write(title, run_time = 2)) + + last_words = TextMobject( + "State of the art \\\\ is", + "99.79\\%" + ) + last_words[-1].highlight(GREEN) + + self.teacher_says( + "That's pretty", "good!", + target_mode = "surprised", + run_time = 1 + ) + self.change_student_modes(*["hooray"]*3) + self.dither() + self.teacher_says(last_words, target_mode = "hesitant") + self.change_student_modes( + *["pondering"]*3, + look_at_arg = self.teacher.bubble + ) + self.dither() + +class WrongExamples(TestPerformance): + CONFIG = { + "time_per_example" : 0 + } + +class TODOBreakUpNineByPatterns(TODOStub): + CONFIG = { + "message" : "Insert the scene with 9 \\\\ broken up by patterns" + } + +class NotAtAll(TeacherStudentsScene, PreviewLearning): + def setup(self): + TeacherStudentsScene.setup(self) + PreviewLearning.setup(self) + + def construct(self): + words = TextMobject("Well...\\\\", "not at all!") + words[1].highlight(BLACK) + network_mob = self.network_mob + network_mob.scale_to_fit_height(4) + network_mob.to_corner(UP+LEFT) + self.add(network_mob) + self.color_network_edges() + + self.teacher_says( + words, target_mode = "guilty", + run_time = 1 + ) + self.change_student_modes(*["sassy"]*3) + self.play( + self.teacher.change, "concerned_musician", + words[1].highlight, WHITE + ) + self.dither(2) + +class InterpretFirstWeightMatrixRows(TestPerformance): + CONFIG = { + "stroke_width_exp" : 1, + } + def construct(self): + self.slide_network_to_side() + self.prepare_pixel_arrays() + self.show_all_pixel_array() + + def slide_network_to_side(self): + network_mob = self.network_mob + network_mob.generate_target() + to_fade = VGroup(*it.chain( + network_mob.edge_groups[1:], + network_mob.layers[2:], + network_mob.output_labels + )) + to_keep = VGroup(*it.chain( + network_mob.edge_groups[0], + network_mob.layers[:2] + )) + shift_val = SPACE_WIDTH*LEFT + MED_LARGE_BUFF*RIGHT - \ + to_keep.get_left() + self.play( + to_fade.shift, shift_val, + to_fade.fade, 1, + to_keep.shift, shift_val + ) + self.remove(to_fade) + + def prepare_pixel_arrays(self): + pixel_arrays = VGroup() + w_matrix = self.network.weights[0] + for row in w_matrix: + max_val = np.max(np.abs(row)) + shades = np.array(row)/max_val + pixel_array = PixelsFromVect(np.zeros(row.size)) + for pixel, shade in zip(pixel_array, shades): + if shade > 0: + color = self.positive_edge_color + else: + color = self.negative_edge_color + pixel.set_fill(color, opacity = abs(shade)) + pixel_arrays.add(pixel_array) + pixel_arrays.arrange_submobjects_in_grid(buff = MED_LARGE_BUFF) + pixel_arrays.scale_to_fit_height(2*SPACE_HEIGHT - 2.5) + pixel_arrays.to_corner(DOWN+RIGHT) + + for pixel_array in pixel_arrays: + rect = SurroundingRectangle(pixel_array) + rect.highlight(WHITE) + pixel_array.rect = rect + + words = TextMobject("What second layer \\\\ neurons look for") + words.next_to(pixel_arrays, UP).to_edge(UP) + + self.pixel_arrays = pixel_arrays + self.words = words + + def show_all_pixel_array(self): + edges = self.network_mob.edge_groups[0] + neurons = self.network_mob.layers[1].neurons + edges.remove(neurons[0].edges_in) + + self.play( + VGroup(*neurons[1:]).set_stroke, None, 0.5, + FadeIn(self.words), + neurons[0].set_stroke, None, 2, + *[ + ApplyMethod(edge.set_stroke, None, 0.25) + for edge in edges + if edge not in neurons[0].edges_in + ] + ) + self.dither() + last_neuron = None + + for neuron, pixel_array in zip(neurons, self.pixel_arrays): + if last_neuron: + self.play( + last_neuron.edges_in.set_stroke, None, 0.25, + last_neuron.set_stroke, None, 0.5, + neuron.set_stroke, None, 3, + neuron.edges_in.set_stroke, None, 2, + ) + self.play(ReplacementTransform( + neuron.edges_in.copy().set_fill(opacity = 0), + pixel_array, + )) + self.play(ShowCreation(pixel_array.rect)) + last_neuron = neuron + + + + + + + + + + + + + + + + + + + + + diff --git a/topics/geometry.py b/topics/geometry.py index 8ebd587e..03da0c3e 100644 --- a/topics/geometry.py +++ b/topics/geometry.py @@ -242,9 +242,13 @@ class Arrow(Line): if len(args) == 1: args = (points[0]+UP+LEFT, points[0]) Line.__init__(self, *args, **kwargs) - self.add_tip() + self.init_tip() if self.use_rectangular_stem and not hasattr(self, "rect"): self.add_rectangular_stem() + self.init_colors() + + def init_tip(self): + self.tip = self.add_tip() def add_tip(self, add_at_end = True): tip = VMobject( @@ -253,11 +257,11 @@ class Arrow(Line): fill_color = self.color, fill_opacity = 1, stroke_color = self.color, + stroke_width = 0, ) self.set_tip_points(tip, add_at_end, preserve_normal = False) - self.tip = tip - self.add(self.tip) - self.init_colors() + self.add(tip) + return tip def add_rectangular_stem(self): self.rect = Rectangle( @@ -283,6 +287,10 @@ class Arrow(Line): self.rectangular_stem_width, self.max_stem_width_to_tip_width_ratio*tip_base_width, ) + if hasattr(self, "second_tip"): + start = center_of_mass( + self.second_tip.get_anchors()[1:] + ) self.rect.set_points_as_corners([ tip_base + perp_vect*width/2, start + perp_vect*width/2, @@ -319,7 +327,6 @@ class Arrow(Line): if np.linalg.norm(v) == 0: v[0] = 1 v *= tip_length/np.linalg.norm(v) - ratio = self.tip_width_to_length_ratio tip.set_points_as_corners([ end_point, @@ -374,9 +381,9 @@ class Vector(Arrow): Arrow.__init__(self, ORIGIN, direction, **kwargs) class DoubleArrow(Arrow): - def __init__(self, *args, **kwargs): - Arrow.__init__(self, *args, **kwargs) - self.add_tip(add_at_end = False) + def init_tip(self): + self.tip = self.add_tip() + self.second_tip = self.add_tip(add_at_end = False) class CubicBezier(VMobject): def __init__(self, points, **kwargs): diff --git a/topics/numerals.py b/topics/numerals.py index 6db7754e..6564a994 100644 --- a/topics/numerals.py +++ b/topics/numerals.py @@ -11,9 +11,9 @@ class DecimalNumber(VMobject): "num_decimal_points" : 2, "digit_to_digit_buff" : 0.05 } - def __init__(self, float_num, **kwargs): - digest_config(self, kwargs) - num_string = '%.*f'%(self.num_decimal_points, float_num) + def __init__(self, number, **kwargs): + digest_config(self, kwargs, locals()) + num_string = '%.*f'%(self.num_decimal_points, number) VMobject.__init__(self, *[ TexMobject(char) for char in num_string @@ -22,7 +22,7 @@ class DecimalNumber(VMobject): buff = self.digit_to_digit_buff, aligned_edge = DOWN ) - if float_num < 0: + if number < 0: minus = self.submobjects[0] minus.next_to( self.submobjects[1], LEFT, @@ -65,9 +65,9 @@ class ChangingDecimal(Animation): def update_number(self, alpha): decimal = self.decimal_number + new_number = self.number_update_func(alpha) new_decimal = DecimalNumber( - self.number_update_func(alpha), - num_decimal_points = self.num_decimal_points + new_number, num_decimal_points = self.num_decimal_points ) new_decimal.replace(decimal, dim_to_match = 1) new_decimal.highlight(decimal.get_color()) @@ -78,6 +78,7 @@ class ChangingDecimal(Animation): ] for sm1, sm2 in zip(*families): sm1.interpolate(sm1, sm2, 1) + self.mobject.number = new_number def update_position(self): if self.position_update_func is not None: From ff207a4688d172c93c24c56152b540b0a454dff6 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 12 Oct 2017 19:44:32 -0700 Subject: [PATCH 03/43] self.revert_to_original_skipping_status() --- nn/part2.py | 149 ++++++++++++++++++++++++++++++- nn/pretrained_weights_and_biases | 12 +-- topics/characters.py | 2 +- 3 files changed, 152 insertions(+), 11 deletions(-) diff --git a/nn/part2.py b/nn/part2.py index 508d10af..3be268f4 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -2569,7 +2569,7 @@ class InterpretFirstWeightMatrixRows(TestPerformance): color = self.positive_edge_color else: color = self.negative_edge_color - pixel.set_fill(color, opacity = abs(shade)) + pixel.set_fill(color, opacity = abs(shade)**(0.3)) pixel_arrays.add(pixel_array) pixel_arrays.arrange_submobjects_in_grid(buff = MED_LARGE_BUFF) pixel_arrays.scale_to_fit_height(2*SPACE_HEIGHT - 2.5) @@ -2594,7 +2594,7 @@ class InterpretFirstWeightMatrixRows(TestPerformance): self.play( VGroup(*neurons[1:]).set_stroke, None, 0.5, FadeIn(self.words), - neurons[0].set_stroke, None, 2, + neurons[0].edges_in.set_stroke, None, 2, *[ ApplyMethod(edge.set_stroke, None, 0.25) for edge in edges @@ -2619,8 +2619,149 @@ class InterpretFirstWeightMatrixRows(TestPerformance): self.play(ShowCreation(pixel_array.rect)) last_neuron = neuron - - +class InputRandomData(TestPerformance): + def construct(self): + self.color_network_edges() + self.show_random_image() + self.show_expected_outcomes() + self.feed_in_random_data() + self.network_speaks() + + def show_random_image(self): + np.random.seed(4) + rand_vect = np.random.random(28*28) + image = PixelsFromVect(rand_vect) + image.to_edge(LEFT) + image.shift(UP) + rect = SurroundingRectangle(image) + + arrow = Arrow( + rect.get_top(), + self.network_mob.layers[0].neurons.get_top(), + path_arc = -2*np.pi/3, + use_rectangular_stem = False, + ) + arrow.tip.set_stroke(width = 3) + + self.play( + ShowCreation(rect), + LaggedStart( + DrawBorderThenFill, image, + stroke_width = 0.5 + ) + ) + self.play(ShowCreation(arrow)) + self.dither() + + self.image = image + self.rand_vect = rand_vect + self.image_rect = rect + self.arrow = arrow + + def show_expected_outcomes(self): + neurons = self.network_mob.layers[-1].neurons + + words = TextMobject("What might you expect?") + words.to_corner(UP+RIGHT) + arrow = Arrow( + words.get_bottom(), neurons.get_top(), + color = WHITE + ) + + self.play( + Write(words, run_time = 1), + GrowArrow(arrow) + ) + vects = [np.random.random(10) for x in range(2)] + vects += [np.zeros(10), 0.4*np.ones(10)] + for vect in vects: + neurons.generate_target() + for neuron, o in zip(neurons, vect): + neuron.generate_target() + neuron.target.set_fill(WHITE, opacity = o) + self.play(LaggedStart( + MoveToTarget, neurons, + run_time = 1 + )) + self.dither() + self.play(FadeOut(VGroup(words, arrow))) + + def feed_in_random_data(self): + neurons = self.network_mob.layers[0].neurons + rand_vect = self.rand_vect + image = self.image.copy() + output_labels = self.network_mob.output_labels + + opacities = it.chain(rand_vect[:8], rand_vect[-8:]) + target_neurons = neurons.copy() + for n, o in zip(target_neurons, opacities): + n.set_fill(WHITE, opacity = o) + + point = VectorizedPoint(neurons.get_center()) + image.target = VGroup(*it.chain( + target_neurons[:len(neurons)/2], + [point]*(len(image) - len(neurons)), + target_neurons[-len(neurons)/2:] + )) + + self.play(MoveToTarget( + image, + run_time = 2, + submobject_mode = "lagged_start" + )) + self.activate_network(rand_vect, FadeOut(image)) + + ### React ### + neurons = self.network_mob.layers[-1].neurons + choice = np.argmax([n.get_fill_opacity() for n in neurons]) + rect = SurroundingRectangle(VGroup( + neurons[choice], output_labels[choice] + )) + word = TextMobject("What?!?") + word.highlight(YELLOW) + word.next_to(rect, RIGHT) + + self.play(ShowCreation(rect)) + self.play(Write(word, run_time = 1)) + self.dither() + + self.network_mob.add(rect, word) + self.choice = choice + + def network_speaks(self): + network_mob = self.network_mob + network_mob.generate_target(use_deepcopy = True) + network_mob.target.scale(0.7) + network_mob.target.to_edge(DOWN) + eyes = Eyes( + network_mob.target.edge_groups[1], + height = 0.45, + ) + eyes.shift(0.5*SMALL_BUFF*UP) + + bubble = SpeechBubble( + height = 3, width = 5, + direction = LEFT + ) + bubble.pin_to(network_mob.target.edge_groups[-1]) + bubble.write("Looks like a \\\\ %d to me!"%self.choice) + + self.play( + MoveToTarget(network_mob), + FadeIn(eyes) + ) + self.play(eyes.look_at_anim(self.image)) + self.play( + ShowCreation(bubble), + Write(bubble.content, run_time = 1) + ) + self.play(eyes.blink_anim()) + self.dither() + +class TODOShowCostFunctionDef(TODOStub): + CONFIG = { + "message" : "Insert cost function averaging portion" + } diff --git a/nn/pretrained_weights_and_biases b/nn/pretrained_weights_and_biases index 4b7be442..7293b04b 100644 --- a/nn/pretrained_weights_and_biases +++ b/nn/pretrained_weights_and_biases @@ -24,7 +24,7 @@ NNNI-1 I-1 I0 tbI00 -S'\xcf\x05\x828\xe5\x1b\x01@\x9f\xbb\xac=\x81\xb5\xda?\x08U\xac\xd8,\xbb\xce?\x8ew\xe4\xcf\xd1\xa3\xeb?i<\x80\xc0[\x08\xe4?\x9d\x96\xa2\xe1\x1d\n\xe7? _\n\xad\xcd\xeb\xf4?\xa6\x7f\x8c\xa2\xae\xbf\xf2\xbfM\xcc\x08+\xda?\xf1\xbf\xcciz\xfazC\xf0\xbf\x06e\x05\xd2_\xae\xe2\xbff\xc42\xa1\xd2\xbc\xf7\xbfY\xb2E\xc3\xf1A\xf2?\xa2.\xec"\xa7\xab\xc6\xbf\xee2\xd6\x9b*G\xe1\xbf\xfa\xf6P\x1a\xd9Z\xe0\xbf&\xee^\xe6\'.\xdc\xbfC\xc6q\x08\xe1b\xf9\xbf\xf9)\xb4\x92\xeb\xff\xe8?\xe1\x87\x1f\x99\xa1[\xf1?]\x83\xe6\x0f\x0fo\xcc?G9et\x90\x0c\xd0\xbf\x8dC%\x14\xb4$\xfe\xbf\xf6S\xaek\xeb\x8c\xd7\xbf\x99\x1a\x0c<\xe6\x96\xec\xbf\xbb\x14\xf4\xb2\xa0}\xc7\xbfD\xa2\xd8P\x0f?\xee\xbfH5\xb2G\xa3\xaa\xcd\xbf\x16r`\xf1\xacn\xe3\xbfTv\x91\xcc\xf5>\xfa?^\xecc\xf5\xd9U\xe0?\x96\xab\x18\x1a\x1eU\xe0\xbf\xb0\xf3}\xd9\xec\x08\x03\xc0\xe6\x92"/\xab_\xef\xbf\x9f\x06\xa2\xb3\xd2\x12\xf6\xbfb\xe97\r\xa0&\xe0\xbf75\x1e\xa0\x8dZ\x03\xc0\x98I\x07\x00\x07\xff\xd5?\xce\x13\xa4\xcfx=\xb8?\x83\x19=\x98\xdd\x8a\xf2\xbf\xa9\x88"M\x13\x0e\x02\xc0\xe6\xcd\xcd\xf6\x96}\xc3\xbf\x0f\xde\x1d\x82\xe8\xe6\xf8?{;z^\xdc\x9b\xe6\xbf2R\x1ae\xc2@\xe3?\xa0(j\xab\xa0\xe3\xaf?\x0c>g+gI\xd8?V\x80\x82\x84\n^\xd6?:\x98M\xca\xdf9\xd0?r\xf3xC\x99S\xf0\xbf\xf6d\xb3\xe9\x10V\xec?\xbdz\x92\xb9\x8d\xe6\xd1\xbf\x96\x03\xb1?\x89\xc1\xd5?\x1d\xd1\xd7O\xe5l\xd9\xbf\x97K\xae}\x13]\xf5\xbf\xe3\'T\xa74\x10\xb3?\xeb\xed\xda\x0c7$\xbb\xbf\x01\xb1\xf7\xe9\xb1\xc2\xec?\xfc\xe5\x0eR[\x04\xc5?)b\xd0\xdc%z\xef?S\n&\xedL\x95\xe2\xbf$c2\x03u\xda\xe3\xbf(W\xfe\x8a\xbf\xdc\xde?\x8a\xb4\x81%>\xec\xe6\xbf8\x89(Ac\x99\xe3\xbf\x00\x7f&tz\xd9\xc7\xbf!q\x0e\x07\xcbT\xa7\xbf\x0cuH\x0f\x0fY\xf2\xbf{87\n\x82\xbe\xea\xbfd\xd1\x04m\xc2w\x04\xc0C\x9e\xd7\x84\x04\x16\xf3\xbfs\t{\xe6\t+\xf1\xbf\x15JwX\xe4\xe2\xdf\xbf\xcaY\xfe\xd1\x01\xf0\xd6\xbf>\x81&\xd1\xc7\x9b\xef\xbf\xe9>GI\xf5#\xf1\xbf=R|\xd5`W\xd3?\x00r\x9a\x8dc\xf0\xea?\x1e\xae\x0fp\xb7M\xfa\xbf\xaf\x84E\xaa\r\xd3\xde?\x86\xc2/uQ\xdf\xd6?\xbf\xd2\xf0\xbfL{\xdf\xb2u\xdf\x06\xc0x\xd9Y\x9c\x8f\xd7\x11\xc0\xdb\x94\xc9 \x97H\xfb\xbf\x1b\xa4\x86aG%\x0c\xc0\x10\x08{eS8\x06\xc0\xf3\xc1\xbd\x96\x80|\xc4\xbf^\x91hG\x1d\xa3\xed\xbfM\xf7\x04\x85\xc4m\xec\xbf>\xa2_\xdb\xf6\xdf\xc5?7\xa4:Cq\xb6\xb7?\xdd\xde\x98W\xa2.\x9a\xbf\xa5\xbdQM|4\xf3\xbf\xc9\xef\x8c\x04\x8eh\xf9\xbfF:*\xd0k\xbe\xe0\xbfaEB\x8dOF\xd8\xbf\xdav.\x83\xa3\xe2\xe2\xbfx\xa5\x0f\x08>\xd6\xc4\xbf\xec:\xfc\xf6!\xd3\xfb\xbf\x18\xfb\xc6\xcek\xc8\xfa\xbfb\x08\xb3\x8e\xea\xa5\xfb\xbf\x19\xdd\xf8\'"\xb7\xfb?\xde\xb1T\xe0\xc8\xb1\xb3\xbf>\xf3\xb0Z\x13\x15\xf9\xbfM\x03\x81\xb2]S\xe9\xbf0dlH\xd0}\x00\xc01\x0c\x1ee\xa6`\xf2\xbf\x0e\x0b\x15\xf0-\xc6\x03\xc0\x83\xc7s\x06\xe9C\xfb\xbf\xef \xb5H>q\x04\xc0?\xe4\xad\x8e!}\xeb\xbf>\x10\r\xf4\x14\xf2\xf6\xbf\x94\xef\xffb3\x0f\xd0\xbf\xccW\x9c\x19n\xa4\xea\xbf\x92\xaaog\xb1\xd6\xff\xbfI9\x10cG>\xe5?\xa4P\xbc\xed\x18\xe1\xef\xbfsm\xd0\xc7\xac\x8f\xe9?8\xd9nq\x18\xc8\xe8\xbf\x82\xa61\x8b\n\r\xe7\xbf\xa8\xb3\x8f2\xbf\xd6\xd7?\x00\xe2M\xd5\xae}\xcc?\xebzs*\x1cg\xea\xbf\x15\xd7\x99zI\x9e\xcc\xbf\t\x14\xee\xc80Y\xe8?\x00/\x8b^\xa8\x81\xe4?\x06\xc8\x1b\x03L\t\xcf?\xaa\xfb\x1chq\xe7\xe3\xbf\x87\xb6\x17Gb\xf6\xe0?\x9f\xa5\x94\xdc\xdc\x86\xf9\xbf\xa9V\xd3\\\x87C\xf0\xbf\x89(w\x97\xc8\xbb\xef\xbf\xff*\xd4\xc9\x1b\x11\x98?ES\xed\xd0\xc6%\xe8\xbfzPf\xa2q\x1f\xc5\xbf+\x1e0\xc8\xcd\x18\xbe?\x8f\xf9\xa5Z\xde\x81\xd2\xbf\xf7\x0b\xdc\xfa\xb1#\x02\xc0\x92\x92\xf7|\xf3\xb4\xde\xbf=\x1b\x9b\x8f)\xa3\xe7\xbf#+)\x0b\xa7\x91\xdf\xbf\x1b\xf0\xfa[\xce\xb6\xc3\xbf\x18\xe6rs\x08\xa5\xe8\xbf\xb3hn\xfbF\xd1\xd3?J\r\x0c\x08H\xc4\x04@\xa3\x7fcf\xf3U\x02@i\xa7\x8b\xa9\xf5\xdc\xdc?i\x02\xfa\xec\x9a\x83\xce?\xa7\xf36\x93/H\xe3?\xa1\xd93_G\xd4\xf5\xbf\xb4J\xfd\xd5@\r\xdb\xbf\xf6[\xdf\x0c$\xd3\xf1\xbfXEP\xc4=\x80\xc3\xbfx\xd2\x89\xb1\xd7\xca\xb6?\xa6\x98\x0b\xef\xb9"\xc4\xbf\x03\xfaJ\xa0\xb7K\xd8\xbf\xa8\xd9\xb6\xbe\xd0\xfd\xfa?C\xf6\x13\xde\xcb=\xf1\xbf\x9e\x81\x1dY\xd0\xab\xea\xbf\xbb\xa4 \x03\x8f\xcf\xf1\xbfun\x9f\x13\xc9#\xf7\xbf\x81\x9fP\xe8\xf7A\xe0\xbf\x00\xfc\x80\xae\xcbF\x07\xc0\xfc\x83\x0fOc\xfd\xc2\xbf\xcb\x94\x8d\x15.9\xf5\xbf\xef\xb7\xe8\x06\xc4S\xd4?LX \x1c\xb7t\xb1\xbf\xc5\x7f\x99\xd0\xb0s\xdb?A`\xa0\xc4%+\xfb\xbfU\x9al\xc3\xfe[\xe7?\x8c\xce\'5\x19\xef\xa1?\xf0\x99\xdfx2r\xd7\xbf\xb1\xf98\xf7`\xfewAE\x01\xe8?B8+x\xba(\xd1?\x87@\xcf\xba),\xff?\xe1\x18&\xc2\xaa\xfc\xe8?\xd0L\xd8%\xd4\xe7\xcc?c\x8e9uW`\xe5\xbfR\xc7\x0c0\xc0\xca\xea?\xbagSA:\r\xec\xbf\x97I\xc2\xc8\x99\xb9\xc1?\xaa\x8a\x00)\xb1U\xe7?\x02\xb8H\x8e(\x17\xf6\xbf\x16\xc0\xf8\xc9T\x0b\xd9\xbfY\x08\xaf\xfboE\xdd?|\x96\xc2>\xb76\xd6\xbf\xaa\xb9\x8cK\x9d\x87\xf3?\xa6\xf6\xf2h\x90\x9c\xfe?\x94t\xfa\xc8>\xb7\xc6\xbf}\xf6\x18?\x81\x81\xfe?\xb3q\n\xcc\xa55\xd0\xbf-\xf9\xa9!R\t\xe7?\xe7\xc6\xda\x8a\x9b~\xe1\xbf\x95d\xe3\xde\x13%\xc4?\xa9k\xd2\xfa\xa2\xa6\xf3\xbf(,\x1d\xd9\x03\x04\x9d\xbfow\xfa\xd5a/\xeb?\xe4[A\xfa\x17\x14\xf0\xbf\xe9\xce8\xc0EO\xf5\xbf\x84\xda\xeaT#\xcc\xf4?\n\xea\xf6\xdd\rg\x00\xc0\xb5Lu\x1a\x9e\xca\xf4\xbf\xa7O\xd67\xc3\r\xfa\xbff)\xc2D/Z\xd6?\xa6\xf4\xf0\x86z\xa0\xf2?\xd7\xe4\x9f\x9f\xa4\xa0\xfd\xbfY{\xed\x88A\x8a\xf7\xbf\x15\xff\xc9e\']\xbf?\xbf\xc6\x84I\xc1\x15\xe2\xbf\x8c\t\xc3\xba\x8a3\x05@\x08\xab\xfa\xa8\x18\x12\xea?\xc3\xe2\\7/\xc6\xf3?\x15\xdei\x9f?\xb8\xf0?\x8e\xb1\xe7\xb7P\x8b\xed?$\x01K\xc8\xd9\x17\xd8\xbfp\x83X,\xbf`\xf3?o\xaaU\x8d\xc8\xf5\xce\xbf\xc0F\xce\x85cF\xf9\xbf2W\xaeb/>\xf1?\x9b\xe2\xf2\x1a_\xa4\xed\xbf\xc3z\x9b!1\xa0\xf0?2;[\x1f\xac\x87\xf0\xbf_x%\xde\x1e\x97\xc3\xbf\xad\xd8E\x0bD\x8b\xf1\xbf\xc2\x99\x97\x8c\xacV\xf3?\x11\xb4\x15\x9e@\x07\xd2\xbf\xb2\xd1G"\xa0\xc5\xb7\xbf_!\x12\xdd\x15\xf8\xb8\xbf:\x86\x86\xf8\x8e\xd9\xfb?. \n~\x10\x12\xe4\xbf\xcc\xe5M\xfek\x19\xef\xbf\x9a\xc0$\xa1\x05\xa9\xfb\xbf\xf0H\xb3\xe0\x08\xb0\xea\xbf\xe9\x1d\xa9\xa9\x9f\x0b\xfa?\x0b\x87\x82\xe0\xe6\xf9\xb5\xbf\xa8\xc0\xb6\x05\x98|\x04@\xa4\xaa\x819\xa0\xad\xf9?\xa9\xe2\xec^/\x8a\xd6\xbf\xa7T\x8f\xca}/\xe5?&\xa7$\xdc\x83A\xe8?\xb3.\xe5{\xd9\xa8\xf4?\xeef\xc0d\xbe\xde\xf1?)\xd5\x03Z\xbe-\x02@U\x80\x12\xcb\x03\x82\xf5\xbf\x8a\xf6\xbe\xe0\x91\x03\xe8\xbf\x99EF6\x9f\x12\xc6\xbf\xf5\xd8*\xd8\x98!\xcd\xbf\x08\xe1\xc5\xe0[&\xdd\xbf(\xb3q1\x85I\x9f\xbf\x11\xac\x91\xd9X\xa5\xdd\xbfk%\xdd\x13q\x1c\xf3?\xa0\xaa\xd5\xd7e\xd9\xdb?,HR\xb4\x14s\xfb?:#\xb3\x97[\xb4\xe2?t\xe8\xf7D\xaf\xe1\xeb?\xf1\xe6\xe8%\xb1\x8e\xf5?\xa9\xbd(\x0b\xe8\xc8\xf8\xbf\x07!0\xde\xe2S\xf6?M[\x99E\x92\x1e\xf1?y\xe6\x02\x90\xd5N\xdc\xbfR\x8d\x92\xc5\x84\x99\xd6?\xde\x12\x9c\x14$\xb6\xf6\xbf\x91t\x96R&\xb0\x02@\xe1\xddE\x07\xbb6\xe3??\x08o\x8e\x91?\xd7?9\xff\xc0>\x16\xb4\xe2\xbf\xa6X<\x8f\xcb\x8f\xcf\xbf\xe2\xdf~7\xbb\x01\xe0\xbf;\xeb\x18\xb1\x13\xf0\xc8?\x88\x8b%\xe5\xae\xf0\xd5?T\x81\xa9\xa1\xe69\xe7\xbfA>\xf8[\xfa\xba\xf2?\x9f?\x0f\xea&:\x02@\xb6n\x8a\\n\x13\xf1?\xc2\xc8\xe8\xe6\x11d\x04\xc0}\xca\xc4\xe7\x94m\xf3\xbf\xe2\x9e\xd1\xf36\x02\xf3\xbf\x98q\xc4\x03\x18\xa5\xb2?=(\x10\xc3\x8f\xb2\xed\xbf(\x9c?l\x9e\xb6\xd3?G\xb6K:2m\xf5\xbf\n\xd5\xcfK\xab\xb6\xa3\xbfY\x04\xf7\xec\xe6\x93\xfc?\xdd~K a\xf9\xf2?h\x86i\xd7P\x87\xec?c\x1d\xaf \xe8F\xf2?\xc1Yex\xfe\xdc\xe0?\x1b\xb8x\x80\xc5g\xb1?f\xef\xedZ\xccy\xe4\xbf\r\xa5\xa6\x8f\xa0\x17\xf5?\x99\x9a\xee\xe9e\x1a\xd9?\xfeo`\xf9\x0f\xb8\xe0\xbfr9Z\xd8^\x14\xee\xbf\x08\x02\xab\xa1t\xb9\t\xc0\xa5\xdf\xfbo\x8a\x81\x0b\xc0^5\x7f\xc0J\xdb\x02\xc0\xf3\xcc\xa0\xa1pD\xe6?\x8cC\xa3;]\xb8\xfe?<7\xd5\x89\xfa\xdb\xc1\xbfZf\xe5<\xab\xd5\xe8\xbf\xcdv9uli\xea?\xd5NF\x1a\x99\xd2\xf8?\'Q\xac\xca3\x8d\xe1\xbfs\x14\x99\x88\xc1\x82\x02\xc0\xf7\x07-wi\xba\xef\xbfw\xe73\x94n\xfb\xc2?|\xbd\xefKQ\xb7\xfd?0<\xe6w~\\\xd4?]\xf9\xe5\x86Y\xa1\xd7\xbf\xb0\x9c.V*S\xc4?\xe0\xab\x08?\xc8M\xf8??\r-\x97\x05D\xf3?N\x81)\xee\xe1\xc0\xe7\xbf\xc9\xd1\x90\xa1\xc4\x80\xf3?D\xd0\xde4u\xc5\xc1\xbf\xc7:\xed\x8b\xa7N\xe7?\x0b\xc3\x8d\x00\x02e\xfa?\xa5o\xec\xbb\x1a\xb6\xf2\xbf5\xc5jc\xbf\xfa\xec\xbf\xc1w\xda\xe9\xfb;\xf2?\xc9\xdb\x8a\xff\xc6#\x00\xc0\x18\xdc\x85\xf3\xff\xeb\x0e\xc0fQ\xc9\xd6\xc8}\x08\xc0\x88\x84\x98M\xd9-\r\xc0In\xd4\x11\x82\x11\xf0\xbf\x19,\x1e#\x7f\x11\xeb?\x0e\xecf;\xcf\xa0\xca\xbf\xbc\x90\x18\x10t\x90\xf2\xbf(\xc9V2Zx\xf5\xbf~\xd2kHR\xfa\xd6\xbf\xea2\x08\x17\xb4\'\xef?h\x95\xb2\x12\xd0\xcd\xf2?U\xc0y\x00\x9b\xb5\xc1?\x86\x14QT\xbe\x17\xe4?s\xeaR\xd6\x17j\xea\xbf\xf1\x0b\xe1"\xbf\xe5\xfc?\xdb\x82/x\xe2\xf6\xf5?2W\xe7s\xbd\xeb\xcb\xbf\xe7\xaf\x7f\x12\xea>\xf1?\xd6\xff\x156\x06\xae\xe9?7:\x04LW]\xee?\x19\xd0\x85\xe1 \x00\x02@\xf3W\x04\x00\x16$\xf4?\xec\xe4\xcf\xda\xd3\xc9\xd5\xbf\xed&\xae\xc4\x12 \x9f?\xbbp"\xcd>\x7f\xdb\xbf\xafnd\xc7\xaf\xcd\x03@\xbb\xc1\xec\'\x7f\x86\xb4\xbf\xd3%\xc5\xf1\x13n\xf2\xbf\x7f\x0cn\xed\xd0o\x06\xc0\xe7\xf9?z`\x14\x11\xc0\x06\xe2Lx0x\xfb\xbf\xeb\x876\xe8\xa3\xda\xfa\xbf\xedosE\x18 \x00\xc0\x89\x0c\x1a\xb1\x90v\xe3\xbf26\xc0\x95\x15\x7f\xed?\xe3CK\xbb>\r\xd4?\xe89dp\xe9\x89\xef?lb|\xb0\xfa\x1b\xed?I\xec\xfa1\x1f\x89\xd8?\xa0s\xd2\xd6>?\xe2?4\x02\xe1\xd6W\x12\xdf\xbf\x86\xc0\xdc\xd5\xdd!\xe8?\xa6;\xa9\xcdp\x99\xe2?\x8d\xc7\x9b^\xc6y\xf4\xbfP\x0b\xf2\xba\x07\x9a\xfa\xbfD\xb4\x85~\xf1\x13\xc7?\xcc\xd1\x86\xfc\xbd5\xf8\xbf\xafn\x98e@^\x05@7\xf7\n\xb4\xca\x04\xf1?]\x1d^\xcf\x12}\xe7?\xee/?IA\xdd\x00@\xd5[w\xb8$?\xb2\xbf\xd5\x16\x93\x9ff>\xda?/\xef\xe7\xe5\xf4\xd6\xf1?\xbd\x98\xda\xf5L\xf7\xd2\xbfA\x9e\xce\x02\x8f>\xf9\xbfo\xa6\xe4\xe5zc\x11\xc0\xea\x10\x1d\x18\xb4\xc7\xfb\xbfVHE\x1b\x0c\xe9\x00\xc0\x16x\xb7\x90I\xc8\xf6?\x893\x08\xd4;\xd0\xf7\xbf\x91DRO\xc7:\xeb\xbf9\xe7t\x14}\x96\xa6\xbfr\xed\x05\xc73\xe5\xf7?\x89\xf1q)\x17D\x05@$\xa1\x85\xd7@\x15\xee?\x9a\x1e~ RfY?\xfe\xaekmEn\xe4?\xe7\xbd\xfcQ\x1b0\xfa\xbf\xd5\xd8\x0c8\xd8:\xc2\xbfa\x02\xfd\x8b\xbb\xb8\xdc\xbf\x0e2l\x12\xca\xfa\xe6?\xdd\xe5\xf2v\xd5h\xb4\xbf\x9c\xf0\xa7\x9e\x15\xde\xd3\xbf\xda\x81\x10Q[\xaa\xe7\xbf\xbdj\xdc8\xf9t\xf0?\xb3\t-\xcfK\xeb\xd4?8\x94Dk\xd5\xc5\x07@\xa4Z>?B\r\x01@v[\xa6\xf6\xfa5\xdc?\xc01\x1dI\xd1\xea\xee?\xee;\x9b\x04\xbfs\xd8\xbf\xa5\xfc\xd2\xf6?F\xe6?\xba\xfe\xb34\xe3\xcd\t\xc0\xae\xf1\x9b{\xbcZ\x14\xc0\xe8\xa6!\xf5\xc8\xd6\xfb\xbfa\x1e\x91ubB\xe8?\x9d\xd1h\x17\xa2\x91\xf5\xbf\xd3\x97\xc2\xc1}\xea\xdd?F\xe9N\x07a\xf7\xf6?q\xdf\x93\xa1\x91\x0e\x03@\xef\xc4\x1f&\x8ak\xfc?\xb9\xd1\xdc7{\xb8\xb7?9\xd6tV\xac\x9f\xfa?\xf8\xc5\xf5\xd3\xf1~\xf3?\xcb\x8d\xbb\xf2\xec\xd0\xef\xbf\xbb=\xb8\x1ez\x8d\xf1?\xben\x9c\x8a&\xdb\xd3?\xe482W\x92\xba\xf8\xbf\xdde.\xc0\xf1;\xec\xbf\xa2N3\x1f\x1e\x0f\xe5?Mk\xb1\xbbBp\xf3\xbf \x83\x8b\x8ewC\xee\xbfcC:\x0c\x87\xf3\xe6\xbf}\xc9\xc5\xd6\xd7T\xfd?\xb4\xe3\xc9"B(\x02@\x92}\x1d\x17\xa6r\xf8?x\xa4\xaf w\x82\x00@}\xe2`\xddr\xf1\xfe?\x03\xdd\x1f\xeaP\x04\xd0\xbf\xf2\xbeR\xfd\xb9\x96\x00\xc0\x00F`-zd\x01\xc0\x9az\xf4m\x98/\r\xc0i\xa4\xb0z-U\xde\xbf\x1eX\x9fl\x18r\xe5?\xb0\xac\xaa\xf8\xa6\x0f\x00@\x10 )\x9e\ta\xfb?\x11\x90\x8b*\x11\xba\x07@Gj\xba^ X\xe8?H\x8a\x80\x10\x07\xfa\xbc?@ZR\xf0$^\xf9?\xde\xfb\xa2\xb8\xc4{\xeb?<\xeb\x88\x0b\xc2!\xbf\xbf\xd6US\x9f\xb5\x9e\xf9\xbf\xa2\xed4\xf7\x97\xde\xe3\xbfK4#\r\x1b\xf1\xd8?\x12\xfc\xd5\xe2E.\xee?-\xf2\x84\xc0Pi\xb9?J\'\x01\xab2\xf9\xe8?\xb5L\xaa\x90\x0f2\xec\xbfj\xb0\xfd?\xf7\n\xdc\xbf\xe3Sb\xad\xdb\xb9\xd8?/\xc6I\x8f\x0b\xf3\xff?`=\x9e\xac\x13\xb5\xf6?;\xf4\xa4\xdc\x94c\xdb?\x01\xe8\xbd6\xd7\x8c\xf5?\xf9w\xa6\xe6\xe8\x9a\x03@\x81\xa2\xe1\xdf/r\xec\xbf\xaa\x1b\x0e\xc7\xfeu\xfc\xbfT\\\x91\xf4\xa1\xe5\x00\xc0\xdb\xbbd\x85\x1bu\xef\xbf\xdc\x17\x83\x88\xcb\x96\xfa?\x85\x8f+\x16\xe1w\x02@\xcbemH\x9a\x1a\xfb?u\x14\xfah\x1b\x9d\xf4?Ww\xc1\xd6z\xe3\xfb\xbf\x17h,\x95\xa3\x88\xde\xbf\x85(\t\xa1\x04\xd4\xf9\xbf\xfe\x1b\xa9l\xbc\x87\xd0?\xd3\x07\x13\xa6i\xaa\xe7\xbf\r\n\xff\x92\xba\x9e\x0b\xc0\x9d\xa9\xfbK\xb2\x8a\xfa\xbff\xe1x\xaa\xde\xbf\xe8\xbf\xf50,]:\x1c\xf0?\xba\x0f\xeb^o\x8b\xb1?\x9a\x1d\xbbjF5\xf6\xbfU\xe4(5\xcel\xe2\xbf\x8b\x95x\xadH\x08\x03\xc0\x9f\x024\x9ar\xdfj?rF\xaf\xcf\x86B\xf5\xbf%+\x97L\n\x1b\x7f\xbf\xf4\xac\xba\xed\x07\x00\xb3\xbft\x14?\xca(\xea\xf0?C52d\xc6\x89\xb8\xbf\xf9A\x97\'\x1b\x1f\xe4??S\xeb\x92\xc1d\xe6\xbf\x93\xb4\x98\xf3a\xe1\x00\xc0\x8c\xf3\x0b\xd5\x94h\xfb\xbf\x87\xd9\x85vx\xdd\xf5\xbf>1\xde\xe9\x16\xb8\xf7?\xff[\xdb\xd0A\xe6\xfc?\x0fR\xfe\xc5\x0c\xfa\x89\xbfg\xf4c\x9c+\xfe\xec\xbfJ\xf1\xcf\xa6s\xba\xdf?/*\x10}\xfa_\xd8\xbf\xc9r\x97\x98\x03r\xf5?\x8f\x11\x89\x04\x12`\x89?\x11J\x92_\x8f\t\xf7\xbf\xb1\x18\xf1\x85.d\xec\xbf\x94}\x87\xd0\xd9e\x01\xc0\xde\xd6\xd7\xec1j\xcf\xbfxJV\x8c\x1e$\xf6?\x8es}\x82\x83\xe9\xf1?\r@,[\xcf\xa1\xda\xbf\xf4qE\xc4(\x8a\xd6\xbfT\x1d\xae\xfby\xce\xdf?\x16\x1a\'H\x05R\xd6\xbf\xd6\xdeA\xb1+\x9a\xf4\xbf\x9f\x0e\xa4\x85\x1cM\xe0\xbf\x02\x89\x92)\x80 \xef?fj\x1a\xd5"\x1b\xef\xbf;Y.eX\xf0\xd4\xbfu\x0f\xb9\xa3\xa3\x83\x05\xc0n\x87A\xa2b\x90\xe3\xbf\nkg\x0b\xb2\x84\t\xc0\xa8\xfd#9:\\\xae?\xa9\x12Q\xaa\xed\xa9\xf1?\xd3\xce\x8b\x84\x1f~\xf7?0\xcb\x06\xe5\xb5Q\xd3?}\xc8\x07\x9bm\x0f\xf1\xbf\xd7\x89\x11\xf5UA\xf7\xbf.\xf6K\xd0\xadC\xda?\xc3\x01\x1e_s*\xef\xbfA~\x15\xee\xd3\xdf\xed\xbfT\xaa*OMV\xe5\xbf\xa5\xec\xfdH|{\xc7\xbf\xfa)\xf9\xbe\xf0\xbc\xfe\xbf\xa2\x9a\x04\xe21\xde\xeb?\x85{1\x19\x93\x85\xc1?\xc7o\x83\xf0\xc4\x0b\xf4?\x17\xcb\x9d\xaf\xdf\x95\xe7?\x05\x05\x99\x02\x07\xff\xef?^\x1f\xc2\x129\xfc\xe4\xbf\xaf3%\xac\xb3\xd6\xdd\xbf\xa0\x00\x99g\xed\x1c\xe0?\xd7\xf1\xb7\xb1\x10\x98\xb5?7\xda\xe9H\xb6j\xe2?\x84d\x99\x9c\xe7j\xbc\xbf\x86DU\xf2\xee\xce\xf9\xbfE\x0f\xb95\x85\xb4\xd1?V\xd1\xd1gy\xe8\x00\xc0\xa4\xb6\xb2\x027\xd2\xdb?\x91v\xb4}6%\xe1?\xef\x9f\xf1\n\xe7.\xf6?\xf5|\x13\x85#\x97\xed?/\xa6=\xf2CR\x01@r\x99<\x81@\xb6\xde?\xb1\xf0|\xa4\xc6\x19\xc9?\x9b\xb9\xc6\xc5\xe1\xc4\xcc?\xfc-\x02H\xae\x8d\xff\xbf)ud\x8f\xec\xd6\xef\xbf\xb5\xffr\x97Q\\\xf9\xbf\xb7\xd9\x9e\xbd\xfb\x81\xfb\xbf\x96f\'\x9a\xb6,\xf6\xbf\xd7\xba\xe9R\x11h\xf6\xbfU_;p\xd9\x7f\xf6?\xc9\x9a\x0c\\\xcb9\xd3?G\x8c\x8fn0\xb0\xdb\xbf\x12\xed[\x8b\xe7\xa3\xea\xbf\x1e{3X\xb1\xb5\xce?\x1d\xa8\x94c\xddy\xc1\xbfoZ\x81\xe4\x99\xbd\xf0\xbfE\x12Y#\x99\xac\x05\xc0PMEU\x81\xec\xee\xbfZ\x81\xaem\x9e\x7f\xc4\xbf\x8d\x9c\x00\rx\xa5\xd9?5@q\xee\x03U\x03\xc0\x16\xef\xa9+CE\x06\xc0\xe9\xfa+\x00\xaf\x86\xe5\xbfRR\x99\xb4\x8c\x1e\xf1?\xa2b|<\x92\xf3\xf1?<\x8e\xae\xe4\xb5\xe2\xaa?\x92tK\xcb\xe5\x0b\xc9\xbf?\x1d\xb9\xf9\xea\xbc\xea?\x05\xc5\x15\x80\x05\xec\xf6?\xf3]\x9ec\x1a\x1a\xbb?%2\x8bS8\x18\xdf?\x10\x9f\xaa\xc7T\x1b\xfa\xbfZmx\xe6 5\xe3\xbf\xae\xe9WI2\x87\xd9\xbf=K\xb1\x11\x99\xd7\xfa\xbf\x8e\x9e\x80\x9e[E\xe4\xbf\xa4\x88M\xa3\x95\xd6\xdd\xbf\x01b\xf0\xb4\x8dT\xce\xbf~\x85C\xce?3\xf6\xbf\xe7\xa4\r\x02\xcdh\xe8?\xce\xda\x04v8\x15\xe7\xbfE\xa3\x07\xaaY\x95\xe2?\x85\x15\x80S)Q\xfe?\xbd\xb1\x0f\x9f\xc5\xf0\xec\xbf\x84;+\xcbx\xd5\xe9\xbfK\t-\xc5\xfd\xae\xab\xbf\xaf\xec\xec\xb8\xe5S\xd3\xbfV@\'\xefQI\xed\xbf?\xd1\x95\xa9)j\xd3\xbf\x9d\xd4`\x12+\x91\xf5?\xb0\xc2\xf6\xfa\xbd\xa3\xe8\xbf;RK\xa5=\xc4\xd5\xbf\x8e\xd2\xf4\x8e\xb7f\xe3?\x817\x1d\xc2\xa2\x8a\xe9?7\xcco\xa7\x90\x1e\xfd?\r\xdfx\xc0\xcc\xdb\xd0\xbf\xe0p\xe9/\xe1\x7f\xf1?\xa6\xd7\xca\xe5k\x1d\x07@\xdd)\xf1M(\x82\xf8?\x9atG7\xa0\xc1\xfb?\xc8\x00h_\xc3s\xe1?\x8d\xcb\xf9tH\x9c\xf0\xbfk\x89\x80Pe/\xd0\xbf\xa6\xc4\xb2\x17\x16\x1f\xc0\xbf\xcf,|\x13\t\x87\x02\xc0\x14\xf0MD!\xd0\xf0\xbf\xcdoT\xc0\xcc\xd6\x07\xc0\x8c\xddFW\xbe\\\xce?\xe0\xdb\x87\xb2\xc5\xc5\xa5\xbf\xb7\x87\xf8\xf0P=\xf7?\x9e\xef\x8b\x97\xcb\t\xf5?6\xbd\x0b\xf9\x86\xa1\xef\xbf\x19T\xb0"\x14\xb3\xf1\xbf\xca\xe1X\x9c\x95\xc0\xef\xbfc{j\xcc\x82\x02\xe0\xbf\xa2\xfdBB\xaa\xca\xbb\xbf\xee4\xab0\xe4f\xf2\xbf*\x8b\xb2\xef\xb2\x86\xea\xbf\xd2*\xb0\xbeF3\xd2\xbft\xb4\x11\xa1\x9a\xce\xea?@\x87mO\x81\x9f\xa5??\xfc\xaeH\x06H\xe9?,\xfd^\x14\x9f\xf9\xd4?o\x0b\xbf\xeb}\x00\xf3?\xcfj_\x12\xc3&\xf1?\x83\x8a\xfb8\x8f\x88\xf2\xbf\xae_:\xd5\xdb\xfd\xd8?\xac\x03\xf9\xcf>\xdb\xfa?x\xc4\x8f\xbcY\xba\xed?\x04W\xfd\x02\xe9J\xe7\xbf\xff\xe6\x7f\xf3t\xe1\xfc?o\xf6\x10\xc9\t\x9c\xad?\xdc/m\x15c\x10\xf1?\x8a+Ra\x07q\xe6\xbf\xe4\xc7\x13\xa9z\xa6\xf1?D\r(O\xf3\x03\x03\xc0\xb7\xc52\xf4A\xdc\xcf\xbf\xd7N\xdcI\xca\x13\xf1\xbf\xc5\xef\xa8\xe3\xf2B\xef?r\xd0\x03\x19\x815\xfd?\xad\x1d3\xc5\x9d\r\xe9\xbf\xf9\xf9r2\x1e\x13\x03\xc0\xbe\xee\xc0,\xd9\x93\xf4?\xbc?\x9b\x8d\x8d\xb1\x00\xc0\xa7\x7f\x02\x08\x97\xf8\xee\xbf\xed8\x8c\xd9p\xa8\xfa\xbf\x8e\xa6o\xd7\x85\x90\xe3\xbf\xberp1H5\x01\xc0\x1d\x7f\xed\xf5?\xed\xf2\xbft\\\xbe\x93^{\xd6\xbf\xd2lH\x13{k\xff\xbf\x17UOYK\x89\xe7?T\n\xd6N\xc0\xcb\xc4\xbf\xf6PA6\x97\xfa\xdc\xbf\xfe8\x0e?d\x14\xc8\xbfK\xc6\xf4\xd2\xa0\xf5\xa3\xbf\'\xd0\x03\xd3I\x95\xc7?\xac\xcc$\xd7\xa8\xa9\xfc?\x1c\x83\xd0[\xda\xf5\xec\xbf\xf8\xfa\x80{A\x9c\xf6\xbf\xe7U/\xb4U\xd6\xbe\xbf\x99DR[\xb50\xd5\xbf\'\xee\xb9\x1d|o\xce\xbf\xc8\xf0\x7f(B\x17\xf1\xbf\x93k\x82\x0cQ?\xc5\xbf\x08z8c\xf7o\xde?\xack\xf8\xd4\xb2\x0b\xed?A\x0fx\xf0~F\xf2?5\xda\xa6\xd1\x16\xe0\xe3\xbfA\x0b\x05\x96\xf9\xb8\xea\xbf\xad\xbd\x06\x7fb\xd4\xfa\xbf(\xe7\x1f\xf5m\x83\xf7\xbfP\xea\n\x10\x1eO\x02\xc0\xee%\x17a\x9e\x90\xf3\xbf\x05B$\x85}\xb0\xf3\xbf97i\x1eui\x04\xc0\xbd\x8b%%\r\xc8\xc8?\xe1\x9dtN2\x88\xf9\xbf\xb0\xa0C\x94\xe9P\xe0\xbf i\xb8\\/\xbd\xfa\xbf\r\xc3\xa4\xeb\xd32\xf7?\xa3kD\xbf\xe5\x8a\xf0?c\xac\xf0\xb9\x8d\x89\xf1?\xe4\xee\x19`\xcb7\xc1?\xa9\xae\xad\xf6\x9e\xb3\xf6?\xc3fyl\x04\xb8\xec?_+-\xc7\x08\x03\xde\xbf\x98\x04[-t\xbe\xef\xbf\xbc=`\xc3Aj\xea\xbf\x98\x9f\x80\xe8* \xa7?S\x82\x9c=d\xff\xd5\xbfz\xde:P\xd5\xdc\xef\xbf"\xe0\xbac\x85\x88\xd6?\x13\xed4j\xb0\xfd\x99\xbf\x8a\xcbk#00\xf5\xbf\x8bf\x03a\xfc9\xd6?\x1c\x9a\xc0\x086B\xde\xbf\x1e\x8753\x1b@\xc5\xbf\x90\x04\xfb;\x9c\x92\xa6\xbfe\xda\xc7\xee\xbej\xdc?\xaa\x8f\xa6\x16\t\xdd\xfa?\xaa\x1e\xf4\x17\x0c\x86\xc2\xbf\xf6\r\xb2\xfb\xc9\x1f\xd7?Y\x04h\x17\xe5v\xf1?Y\xc6\xeb\xce\xf1}\xd0\xbf\xfd\xc6\xa8\x8c$\xdf\xf3?\xed)\x07\xca6\xaa\xd0?\xb0\xcf\x0f"|7\xb1\xbf\'\x05=\xe9$\x05\xda?}\x1dYW+\x99\xe3\xbf\xf2\xe4\xf5V,\x8b\xe5\xbf\xe3\x17\xf2\xc4\xb2C\xb7\xbf\xf3\xc7GP\x8cR\xe2?YE\x1eT7\xe0\xf6?\xe5\xe3 \x12T\xeb\xc0?\xec[\x0b\xbc\x11\xef\xf9\xbf\x08\x0b\xbe\xfbl\xa0\xe1?\xb1X7\x81\x86\xe8\xfa\xbf\xf5S\xb8\x8bX&\xda?\xdeZ\xa4c\xdc-\xff\xbf\x87L\x0b@\x87\xd7\xdf?\xf5\xd6\x9e;^;\xb4\xbf\xcd\x7f\xff?\xaa\xe8\xe1?g\x11\x12\xe4\x05\xf1\xc9\xbfO\xc6\xf8j\xcc\xb1\xf2\xbf\xf0>\x10\xb7\xe6^\xc8\xbf\xb8\xf2\xd1\x80>C\xb8\xbfw\x91OU\xcb\xb7\xe2\xbf\xb6@\x8d`\xcf#\xed?\rI\xf8F\xd4\xe0\xe3\xbf\xfc\x92\x13j.\x98\xd4?`\xceb\xb8\xa2\xeb\xc4?|\x88AR\x192\xce\xbfV\x11\x8e[\xba\xba\xf0?\xcd\x98\xf0\xe4\x81g\xf2\xbf\xf9\xf9\xa8\xbc\xf3\xc9\xd7?\xa5\x1f\xe9vA7\xd0\xbf0?\xb7\xde\xbd\xa5\xe7\xbf\xb52;Y\xe5\xc9\xd9\xbf\xbf\xb2|\x91\x9dK\xd3?0\x1f\x8c\x8b+\xb6\xe5\xbf\x83\xce\xa7=fE\xf7?:\x1e.\x9d\xa1\xdd\xe0?2\xd3\xecI\x9a\n\xf3?\x18r\x14\n\x15\xf9\xfe?\x1a\x012@\xdc\xcc\xed\xbf\xb0\x08\xde\xf3r\xe6\xda\xbf\xd1\xd8H\x9d\x87\xad\xf2\xbf\xf5JP\xf2\x07\x1b\xf1?I\x06L.\xfbB\xc6?\xfad\xba;"l\xd1?\'\x99\xec\x94\xcd\xaf\xe4\xbf\xa8iuB \'\x89?\x85\x1d\xc6\x18\nt\xf5\xbf[&\xb0\xba\x92 \xc6\xbfF\x8b\xaa\xa1\x07\x1b\xdf\xbf\xb1\xaf\xbd\xd2DK\xe4\xbf\xda\xf1]\xcc\xe3C\xd0?e\xff\xd4`%\xf2\x02\xc0\xf3\xead8\xd5\xb2\xfb\xbfS&6I\xd2S\xe3?]q\xcf\xb2\xa0\x08\xf7\xbf\x8a\x05\x87&XJ\x93\xbf\x1a!\xf9[\xbe\x92\xe6\xbf\xce\xe7{\x88\x961\xe8\xbfE4\x81\xae\xd7\xf8\xf7\xbf\xba\x0fXn\xd3M\xf0\xbf\xeb\xdf\x0bO\xdf\xc9\xd2\xbfh\x9b\x889\x914\xd9?\xf3\x0cC\x9eG\xab\xec?]\x82\x00\x87?}\xec?\x9e\x850\xe5\xcc\xf7\xeb\xbf;\x9c`n\x9c\xa7\xd4?\x88\xc3\xd6\x1f\x9d\x16\xf1\xbf\xa2\xda\xe3\xa23?\xb0\xbfL\x8a_\x14\x1f\x80\xfc?J\x81\xb0\x92\xd2\xbd\xee?\x98R\xcfp\xf4\xc3\xf3?\x7f\xbd\x19\x1b\x00;\xef?\xeb\xb9\xb7\x1f\x11U\xbe?-\xc9\x88\x17%\xe2\xc1\xbf\x91@\x8fhG\xff\xd9?\x8d\xbc5\x96L\r\x84?#o\x15\x1e\x0b\xcb\xed\xbfe,:\xc3\x91\x82\xf3\xbf\xa3\xc1\xb2M\x1dT\xda\xbf\xc0)\r\xda#\'\xd5\xbf\xee\x00\xe0\x9a\xb4\xa4\xfa?T&\x7f8\xba\x94\xe8?b\x8aeL\xe9\xd2\xa1\xbf\x0f?t\x1a\xf5E\xee?\xe9\xd0\x8a]\x19\x83\x02\xc0\xbd\x90r\xb0\xf8\x01\xf2\xbf,\xdfyg\xb8*\xfe\xbf\x8dxy>dv\xc3\xbf\x83e\xe2u\xe7-\xf2?\xb0m\x9b\xc5\x96\x13\xe6?4"L<\xfb\x85\xd4\xbf\xdcT\x1c`b\xa9\xeb?\x9f\xfb\xd0;\x92\xbf\xde?8PL\xc3\xfc\xce\xf4\xbf\x85&\x82\xeb\xb6\xa6\xfd\xbf\xd7\xda\x13*\xf0\xf2\xf8\xbf\xc9\xf8Y\xf5\xe6\xa7\xf8\xbfXWR\x1a\x82\x02\xeb?e\xdfF\xe6!\x04\xc0\xbfo\x85b\xa5\xd4\xbc\xf6?\xbaC\x1b\xcf\x1c\xaa\xcc\xbf\x02\x99\xb1\x88\xd0A\xd5?UQ\x95n\xf1\x1f\xea?\xd9a\x9a4\xd0\x89\xd1?\r\x1d\xcblQ5\xfd?\xc0\x89\\##Z\xb3?\xc1yb\xa0\xd5\x81\xc8?\xda^\xcf\xd9\x07\x07\xec?#\xb1\xfcM\xf6&\xf3?\x9e\x13E*\xc5\x04\xe9?#\xc0?nEW\xe4\xbf\x91gt!\x9d[\xf4?3|\xa0\xf4\xc5\xd1\xee?\x93n\x01\xb9\x135\x9f?\xa7o/I()\xf1?,\x14?\x93\xf8\x1d\x01@_\x00\xc1\xed\xaa\x8c\xf4?\x8d9\xa5,t\x9e\xee?\xb2S;\xdd\n\x0e\xf6\xbf\x0c4\xda\x93G\x9e\x04@\xdd\x93\xd7"g\'\x0b\xc0\xbe\xbc"\xf8\xa5\xb7\xf3\xbf\xe1\xc9fy\xcb\x98\xf2?\xfa\xf0\xd1\xa2}\x11\xf5\xbf\x94?2K\x88\xad\xd0\xbf\xc2\xcb\xe8\xa8\xdc\x86\xf4\xbf\x808\xa0\xad\x9c\x03\xd4?\\\x03\x02\x8f\xce\xd4\xf0?\x1f8$\x16\x15\xa5\xe4\xbf{\xf5\xe6\xef\xd1\xd8\xf3\xbf\xf9\xfb\xfd\xd1\x16E\x00\xc0\x0b"B\x1e\x19\x1e\xd3\xbfLS\x99Z\xe6\xb2\xe6\xbfz\x9a\xa4K\xca\xf2\xdb?pU\x9d\xd4\xb95\x02@|Gm\xff\xdfZ\xe9?\xb2=o\xc5\x00\'\xf4s\xd6?\xb4\x83Pk8%\xf5?4b~\n\x9d\x9f\xc9?\xc6\x98\xcf\xba:\x92\xe6\xbf\xbb\x86P\xf2\x00J\xf4\xbfu\xe2\x11.\x93#\xea\xbf\xd8\xf0\x88\x1b\x1c\x04\xe6\xbf/vj\xd7C\x04\xf0?\x96\xf0\\-\xe8\xc9\xef?7Hw\xd3<\x8b\xf0\xbf\xd6\x9b\xf3\xe3\x1b\x08\xeb?V\x02*(;\x98\xf8\xbf\x8e\xaf\x91d<\x0c\xfa\xbf\x18WQ\x8d"B\xf7\xbf#\x13\x02\xca|\xbe\xf7?\xdb\xfa\xdd\xe5\xc6\x83\xd4\xbf\xa1/\xca\xc9fk\xfd?1\xf4C\xf9\xe3>\n@\xba\xfd[\x9c\xa19\x0e@1x\xa4\xb5/\xc0\xf8?\x12d\xd4\x8b*\x14\x0b@\xbc\xcd\x8e<\xa7\x9a\r@\xe0f\x95cqG\n@Fv\r\xf8\x87\xd5\xfc?\x7f\r\xa4:\x81\xbb\xf2\xbf\xec\xf2\x84\xe2e\xa8\xfd?f1H\x8c,\x92\xa6?f\xb6h%sJ\xeb\xbf\xf8\xd2\x87\x1cU\x9a\xe4?\xfb`\x86\xc5\xd1\xa1\xe6\xbf\xd5Z\xb0W\xcc\xac\xa5\xbf\xa4\x07\x03\xf0q\x9a\xe3\xbf%\x850\xf5}|\xdb?\xddT1LfG\xef\xbf\xa8\xfd\xebR\x01\xbb\xeb\xbf\xdb\xa0X\x92\xdc$\xf7\xbf\xe0\x98\xf0\x18J\x80\xbb\xbf\x89\xb5m\xece\x1a\xeb?\x95)\xf5\xc2O9\xef\xbf\x99\xd4\xddY9>\xdd\xbf\xac\x83Q\xcf\xd1\xf4\xe6\xbf\x9b\x99_\x026\xf4\xf0?^i&\x88\xa4\xbd\xeb?\x99\xaav\x14\xc1\x87\xf9\xbf\x0faK#\x0c\xa6\x01@\x1b\x13\x15\xe2\xfb0\xf9?\xf4i\xeb@\x16\x12\x00@\x7f\xbfu\x10\xb8\xf2\n@\x05\xf9w\xa7_\x1b\xf8?k}-\xc0\x13\x94\xfc?\xe1W\xfa3\xbd\xd7\x0e@\n\xa8\x00\x87\x12\xd9\xfb?\x89\xc1\x96\x14o\xc5\x08@\x000\x99\xfbiD\x00@\xd3\xd2\x88\x1f\xf1\xb9\xd5?\x86\xf2\xfd\xfb\x9c8\x00@\xf7r\x94\x8b\x01\x90\xde\xbff`i\xc8\xb3\xc4\xee\xbf\'\xbe<[\xee\xe0\xe7\xbfI;`E\xda`\xe5?\xeco^\x08\xe0,\xe5?X\x1a%@\x9fx\xd1?\x82\x03s\xc1.\xd6\xe2?\x8bs\x1fJ\x04\x89\xfa?\xb5\x08\xb7Q)\xce\xc1?9UMM|x\xea\xbf(!\x89e\x123\xce?\xd5\xdaL\xa8,Y\xf8?\xf0H\xae\x104\xb2\x01\xc0\xbc@\x84\xe5/\xfd\xf9\xbf\xbc\xa8\x97\x7f9U\xe9\xbf7c\xaf\xa3\xc3\xaa\xd4\xbfV\xe4\xed0\x9as\xdd?W\x07\x1c\x1d|A\xf2?8\xaa&\xd4;3\xf3\xbf\x93w\x00\x9d\xb54\xf6?\xcb\xb4\x8e\x80\x0b\x18\xd5?\x87\xf3-Rf\xdc\xdf\xbf\x12{K\xc2x\xcd\xf6\xbf\xacS\xb4[M\xd1\xd2\xbf\xc9\x11\xf9C\x87\r\xf2?_\x8co\x86\xca\xd7\xee?\x84\xf3t\xf3#J\xeb?\x9d}#\xe0\xe5m\xf7\xbf\x81k\xf1\xfdL\xde\xf0?3\xe1\xce"\x97\x91\x00@\x18l2\xef\xf3 \xd2\xbfP\x93\x91\xa8\xfb\x8c\xf8?\x01\x14\x98\x0c\x95D\xe6\xbf\x11\xear+\x15_\xf9\xbf9\x15\x15z\x1d\xf2\xf5\xbf#\xb1\x8d"\xa6P\xf0?\x032d\x99\x94A\xc1?\xf2\x03\xcb\x9c\x07\x82\xee?\x10,\x90\xf5\xb8\xd8\xed\xbf\xb2s\xf4$\xe7\x85\xcd\xbf\xcef\xb2z F\xf3?\xdcnmY\x87\x8b\xcb?\xcd\x119\x14\xd2\x9a\xd8\xbfTs2C\xe6\xd3\xf1\xbf\x9e@-\x99A\xed\xf0\xbf\xc7\x04\r\xc9\x8b_\xc3?\xf2\xd7S\xd9\xac\xf0\xe7\xbf\x81T\xdd>4Z\xf2\xbf\x1a\xb4\xe9M\xfc\x1e\xd2\xbfL\xff\xbb\x9d\x85t\xce\xbf^\x15\x1c\xae\x954{\xbf\xb3oQ\xfe\xb2\x07\x00\xc0zT\x00"p7\xf7\xbf\x1d\x8cn\x1d$\xde\xd5\xbf.z\x90\xcd9#\xdc\xbf\xdeN\xc7t\x92g\x00@\xe8~1JG\xa5\x00@\x93\x1e\xa1\xd1\x8e]\xc3?6\xea\xd1\xdf\x0c\x0f\xb9?\xe8\x03p\xc6(\xb9\xe5?\x85\xa6j\xd9k\x12\xe5\xbf\xa7\xb0}\\\x18\xdc\xaa\xbf\x0en\xe5\x99^\x1e\xd4?\x90\xe7\x00\x85+I\xed?\xb7\xa5C\xfc]z\xf8\xbf\x121R\t\xfa\\\xd9?\x0cI\xcd\xf4\x99n\x04\xc0l\x8b\x8d\xe8Xc\xf2?}\xbcE\xa1\x8a\xa9\xe3\xbf[\xa1\x7fc7\x17\x01\xc0\xb6\x111%r\xa2\xbe\xbfj\x870\xca\xf5\xfb\xe3\xbf0s\'\xee!"\xe4?\x88\x19j9\xd4\r\xfe\xbf^ \x13T\xd5\x95\xf3\xbf\xea$\x0e,\\\r\xf5?\x8c\x12\xea\xbd\x03\xde\xf5\xbf\x0f@\xf6\x03\xaf\x01\xf5\xbfx1\xfd\xc8\x1b\xcd\xfe?!i\x98\xfb\xe8\xf6\xc5?\xc2D{\x1e.;\xd9\xbf\x98M\x1d1\xa2\x99\xf0?\xb2Z\x12m\x88\xfa\xe6\xbf\x0f} \x86\xc2\x11\xc7?u06\x1bQW\xda?\xa5p\x9c%b\x1e\xc9?\xe9\x80\x867~\xa4\xd7?\x89>\xa4\xe0\x19\x1a\xf5?\x92`\x81j\x03\xd4\xc3\xbf\x91\xbb\x16\x85\xb9\xba\xf4?x\n\xaeM\xa8\x8e\xd5\xbfi^\x15z+\xa1\xea?|\x80fE&T\xeb?\xb2!\xc7j\x87\xcc\xe4\xbf\xf9\x9a@\x07=\x08\xee\xbfR\x1cx\xce\xda\x95\xfd\xbf\xba\xa2H\xbf\xe4\xa2\xe0\xbf\xa6\x97*y"\xf5\xed?\x14\xf6\x9d\xbe\xca]\xf9\xbf(U-s\xb6\xc5\x02\xc0R\xfa\xc7J\xc3^\xd0\xbf:\xe9\xc1O\x1e\x1d\xc7\xbf\xbfR\xd3\x92\xc1\x97\xee\xbf6\x9b\xa8\x0e\xd3F\xee\xbf\xcf\xf9\x05\x1a~>\xd0?S\xc08vi\x8d\xef\xbf\xecn\xc6\xe49\x04\xde\xbf\xc3\xfa\xe3\xe8#d\xf0\xbf\xe7\x94\xbc\xbb\xa7\x11\xe9\xbf5/^u\xbec\xec\xbf\xd5\x16\x14s\\g\xe9\xbf\xb9\x14\x1d4\t\xc5\xe3?\x0c\xec\x18n\xbf\xd5\xf9?W\xa5\t\x0e\xfc@\n@\xccG\x7f\xdf\x1b\xd0\xf6?\x95\xf5\xc9g\xc8\xdb\x00@rL)"\xdb\xaa\xeb?Fg\x9b8p\x1f\xf9?\xe7\xcc\xb0o\xc2\xcf\xd9\xbfL\x0bF\xfa\x13S\xd2?d\xb0\xc4\xf1\xb1\x1b\xfb\xbf\x03\xbcB\xd8\xa0:\x02\xc0N5#s\xebH\x03\xc0\x90\xaa:\x8fn!\xe3?\xfb\xad\xe0Kkk\xe3?\xf2\xb0P\x16$b\xdf?\xa6FO\x92c\xc6\xe0?\xccAY./\x10\xeb\xbf\x0c\x18\x01\xe0b\t\xbc\xbf?\xe1\xc3\x89\x84\xb1\xf6\xbfU\'\xaa\xaf,M\x01\xc0N\xbd\x9e{\xb7s\x8d?\x05\xf4\xb9\xf6y\xa6\xf9?!\xb4(Y\\!\xfe\xbf&\x8f\xec\xfb\xa6t\xf7\xbf\xf0\xb3\xa2L\xb3\x12\xfe\xbf\x1a\x81\x91\xf9Th\xea\xbf\t\x91\x805\xc2,\xed\xbf\xe3\x1f\x16\xb3]\x15\xea?\xac\xed\xb4Q\xca\x95\xff\xbf\xfa\x7f\x9b\r2\x8c\xc7\xbf}\xc4\x02\x8cFs\xfa?MsbD\xb8\xa4\x07@\xd8\x84\x95s\x9e\x07\xf3?Z\xab\x82\xd5\xa0\x16\xf5?\x84\x045/F_\xe6??mA\x8bt\x12\xd7\xbfqe\xf4\x8co\x97\xf1?\xcdM\xa4\x10\xaa\xd0\xf2\xbfuZ\xc0i\x86P\xf9\xbf8\xa2\xb5&\'0\xfb\xbf\x11\xb6F\xa4\xf6q\xeb?\x99\xca=!\xf1\x9e\xd2?N\xaf\x1d\xbd\x1d\xa9\xf4\xbf\xcf\x05Q\x08zQ\xf6?\xebl\x95\x17\x87\x95\xea\xbf\n\xfb^t\xf2\xb6\xe6\xbf\xe7R\xf7\x96\xd37\n\xc0=V\x81\x8a\xd4\xde\xf8\xbfN\xba\x06Z\x85l\xea?\xd6\x0c#r\x14\xa0\xe3?\xc4n\xd8\x1c\xbe\x8d\x08\xc0X\xc7\xe5K\xf9\x8e\x06\xc0\xbd\x1b\xda\xbd\xc8k\x08\xc0\'\xa4\x93E\x06\xe0\xf7\xbf\xe6\xe1\x8b\xd7\xe1=\xd1\xbfX\xcfw\xf6#S\xc8\xbf\x88\xc0\x15\x0e1\xd8\xef?\x11\x92V\xce\xcbv\xf4?\xf8{\x0e\xfa\x9ff\xea?\xdb\xedC\xdbG.\x00@\xc2\x9f\xa3\x17d\xf2\xfd?O\xda\xfaH\xd6\xb1\xfe?\x86\xf0\xbc\xabzz\xfd?\x9d\xb4[e\xa9\'\xf3\xbf\x9b\x99\xd7d\xc9\x8d\xd8?j[!\xff\xa0\xf3\xf8\xbf\xb9ygM\xe8\xa6\xe5?T\xcf\xb6\xb8\xcb%\xe1\xbf\xc4\x1e-6*\xc4\xfc?r\x9353\x7fD\x00\xc04\xaa%\xe87\x91\xaa?6\x99%\xf9Q\xa4\x01\xc0\xf9%\xc0`4\x0f\xdc?t\x89w\xc9:\xb7\xe0\xbfR\xe6\x1ch;\xda\xf8\xbf6\x97\xb0\xb2\xab\xdc\xe5\xbfM\xeb\n\xb8\x12\x07\xf9?\xa2R\xc0\x92\xea\xba\xec?&[\x88\x91&B\xff\xbf\xd4\xedh?gk\x03\xc0tu\xa1\xbb][\x03\xc0\xd6\xec%\xd0\xbb<\xfe\xbf\xc3_\xdf~N\x8b\xf2\xbf\xb0\xd9\nVm\xe0\xfe\xbf\xcd\x98\xb5\x925\x99\xd1\xbf\xb7, \x81\x8dh\xe6\xbf\xac&R\xd2\xe7\x1c\xfb?oO\xaf\xf8GY\x06@AnJ\xb03\x12\x00@\xa9\xa4\x1f\x7fG\xc3\xe5?k\x13\xb9\xcd\xac-\xec?\xf1\xd7\x1aOH!\xd8?\xb93\xc1\xd4H\xb4\xe0?\xb5\xf5\xa1\x81\xd8\x85\xbf?\xdb\xbat\x9e\xdb\x0f\xbd\xbfz\x08d\xd9\xd2Q\x01\xc0P\xd1\xb3\xef\x8eP\xfd\xbf\xac\xbef\xe5|\x06\xd3\xbf\xfe\xd7k\xa9\xd4\x0b\xfc\xbf\xa3\x1a\xd8\x83XJ\xd0\xbfs\x0f(\xc6w\xf1\xe1?<\x1dq\xa5^!\xfa\xbf\xd2\x88h\x9a\xdc>\xe3?B\x8a\xd4\x7f\xbc\xe0\xec?W\x02\xcc\xea:\xbb\xf1?\xb4\x81\x97\x89\x1e\xbc\xe2\xbf\xc7\x94P\xfflC\x07\xc0\xc0\xf3H\xe961\x0c\xc0\x02\xa8\xf6\x99A\xf6\x11\xc0\xbc\xc2e\xae\x15\x85\t\xc0\xcd\xc1\xd3\x1f\x1e\xf1\xf2\xbf"\xd9[(\x14\x04\x07\xc0L\xd9\xf1\x08I\x9b\xe5\xbf\xc6\x924\xff\x18\xf3\xe8?\x8f\x977|\xf5M\x01@8\x96T\x9bK\xf9\xf6?\x16z\x8b\x037>\xf7?\xe3\xaa\x81\x9dv\xd9\xe2\xbfZ|px\xfc.\xc0?_\xd4\xfe/\xb8\x16\xf2?\xe2\x11\xf4\x94\x1f\xbf\xc3\xbf\tH\x949\xedu\xfd?\xd2\x8f\x00\xe3\xb9\xd9\x84\xbfWrb\xd0dX\xe8\xbfRK\xe9G\x1f\xd5\xb8\xbfr/C\xb0_\xf1\xf8\xbf\xc0\x12J\x94\xe1\xaa\xed\xbf\xa8\x15\xd3\x80\x89=\xf4\xbfE!\xba\x1cEq\xeb\xbf\x12\xb4Im\xe4#\xff\xbf\xcc\xb6\xe9\xa2?\xd8\xe2\xbf\x89\xc3*`\x0b\x98\xce\xbf\x8f\xbb!\npA\x05@=\xd4<\x18*\x94{\xbfUh\xf7\xef_\x83\xf8\xbf\xd8\xa0\xa15\x01(\x0b\xc0^5H\xb1\n\xb4\x0f\xc0\x1cz\x1f\xcf\xec\xb0\x05\xc0Y\x8a\x89\xee\xdcU\x05\xc0\xd3\x9e\x9d\xe5\x8b\x05\t\xc0\xc9\xcf?\xb5\x1c\xe3\xf6\xbf\xf0g\x83D\x18\xb7\xed\xbf\xad\xf5\x88\x9bf^\xee?\xee\xcda\xc4\xfe\x81\xed?\xe3\x12l\xaf\\\xc5\xe3?\x10k\xe1\x9d\x85$\xd8\xbfj\xe1\x14\'\x80\x08\xf6\xbf\xf6Nz/B\xbf\xce?h\xd8\x03c\xa7\xe6\xcf\xbf\xdd\xa7\xf2C>\xf7\x02\xc0H\xb0\xe6\x068U\xee\xbfY4~\xa2y\xff\x06\xc0\xcb\xb5\xf3\x11\x0c\x98\xf0\xbf\xd6\xde\x95yQ\xf7\x04\xc0g\xd2Pl\xf7\xae\xf2?\x98\xe0zD0\xaf\xf4\xbf\xf2F\xa2p\x9ai\xea\xbf\xd7I2\xff\x99U\xe7\xbf\x88/A\xdc&\x1a\xda?\x95\x84\x83\x02\xf5U\xf5?\xc2\x04\xfe\x00\x16C\xf7?1\xe4\xae\xe2\x7f^\xe1?ds\xe5\x06n\x18\x04\xc0\xf4\x04\x9d\xa5\xc7\xec\xff\xbf\x0e\xa3Mo6\x80\x01\xc0U\xf4K\xc2P*\xf9\xbf\xfe1\x80\xc4\x15$\x0e\xc0#\xe2\xa4\xae&\x18\x03\xc0\xcc\x8f=\xf4R3\x0f\xc0sj(\x85\xc36\xb6?&\xde\xd5"\xe5q\xfc\xbf\xc1\x9b\x94\xe0\x8d\x1e\xf6?\xda\xfa\xbb\xb3\x13\xd8\xf2?\x13\x87\xc3\xcc\xcd\xae\xef\xbf\xbc=\x91w\x07\x02\x00@\xb2E\x8d\x95\x0ct\xcc\xbf\xcd\x01T\x7f\xe7\xc0\xe1?Y7\xb0\xe5\x8d\xec\xeb\xbf\r\xad\xf3/;\x05\xed?\xbag\x8dQ.\x83\xf6\xbf\xcb\x13\x1b(Y\xcc\xe8\xbf\xa3\x14\xb6\x1d+\x1f\xc3\xbf [\xd4I\xcfK\xed\xbf\xe5\xfb\xa2\xfe4\x88\x00\xc0\xff\x8a\xaf\xc9\x88\xda\x01@\x9f\xc5\x19?\xf2\xa2\xbb?o9h(\x8d\x0c\xe6\xbfy\x9a,\xf00\xd3\xd5?\x19u\xcdL \x12\xf6?\xa9u\xaf\xd8:e\xf1\xbf\x0c\xdb\xa4\xe7+\xfb\x08\xc0\xc9\x80\x80>\nd\xfe\xbf\xca\x0fu\xd3\x85\xfc\x06\xc0\x14\x1e\x17\x1f\xfb\x1f\x07\xc0\xc7\x00\xb9G\xb0\x1e\xff\xbf\xb8\x0c[\xaaj\'\xe0\xbf:\xb3t*YC\xfd\xbf\x91 \xc4KwW\xcf?LcR0\xed\xf6\xe8?\xb1\xad{\x03\x03\x02\xdc?w\x9c\x97N\x15\xa7\xda?\x15\x90{\x97K\xa4\xf1?\xc4\xe6\xfe\xaa,\x14\xfb\xbf\x80\xfe6\xefGp\xeb?&\xf0\\Z\x00\xa3\xe6\xbfg[(\xd3\x82\xd5\xb2\xbfe\x0e\x16\xe0\x9e\xfd\xf3?\x86\xa1\xb7\x1d\xfc7\xda\xbf\x02\x1b\xe5\x00b\x9d\xf0\xbf\x18\xb2\xba\xcf\xa86\xf1?\xef\xae\xa2\xa5\x9eb\xc1\xbf\x9c\xef\xd7\xadW\x89\xd8\xbf\xdd\xa7\xba\x14\xbaZ\xdc?\xac\x18\x9cfW\x8c\x00@\xd39$u\x8f\x15\xf9\xbf\x94y\x06\xa5\x93A\xed\xbf\x9c\x1e\xfcM\xdd|\xd9\xbf\xe0\xc7\xc0\x0fyM\xe3?\x02\xfb\xbff\xf2\xea(\x10\x0b\xd9\xbf\x1b\x13\xfa\x8f(M\xca\xbf\xbdK\xae\xc0?\x84\xd4\x83\x90e\xe7\xf0\xbf\\\xd9Ae\xe6\x18\xcb\xbf\x90w\x8c\x889m\x05@\xe8$\xad@\xb1\t\xf0?\x8c0x\x14nR\xe6?-\x90E-\xee\xfd\xd6\xbfZ\xc0\x94\xf2\n\xe0\xdb\xbf\\\xbb\x86\xbfd\x1f\xf1\xbf[*\x11NAB\xfa\xbfl\x05\xf3\xab\xa0\xfe\xe7\xbf\x9f\xb2\xc55\xf9\xe1\xe8?\x87b\xa7\xa4R1\xe6\xbfk\xa8q\xday\'\xf7?j\x0e\xb0\xa1\xe9\x14\xfa?\x17\x96\xe27\x1dQ\xd8?}\xcen\xf5\rU\xe8\xbf~\x17;\xa9_X\xfd?\x01\xaeN3\xcb\xe3\xf9\xbf\x82Z|\xd0\x93\x8e\xd2\xbf\x0f\x19\x19"\x88\x9a\xe1\xbf\x15A\xffj[\xde\xf3\xbf\xd6Cf\x07\xa5\xf5\xdf\xbf\x19\xb4\xd8\xa1\xe1\xe2\xce\xbfN\xd5J\x1d8\xa2\xd0\xbf\x19\xaa\xbd1\xbb\x8f\xf1?\x8f\xd3\xc03\xe2<\xf0\xbfQ7M\xe1\x1f_\x07\xc0Qc\x8e\xc8\xef\x8e\xf9\xbf\xe6\x97\x94\x8f\xb36\x06\xc0\xfc?i\x13^\x8b\xd6\xbf\xae\x99\xf2\xfe\xeb\x94\xed?\xe8:"\xd19\x19\xe0?\x8ar\x94\xba\xf4\xd9\xb3?\x11\xb8\xc8\xac\xee\x02\xfd?\xf2\x98\xe4\r\xc3\xf2\xe8?\xa1\x99]\x164\xcf\xec?Z\xad\xd6R\xe3T\xf9?\xc2zG\xc7C\x1a\xd6\xbf\'\x0c\x95|\x9f\xa3\xfc\xbf\xdd@\xebM\xbf\x98\xc6?\x95r\xba\x90x\xfb\xea?#\x04z>\xaa\xa9\xf8\xbf\x85\xad5?\x8b\xfe\xde?&\xed$\x00\x84P\xb3?\x04\x83*\xe3\x83\x97\xf1\xbf\xac\x00G5lV\xa8?\x01\xca:\x8b\xb5V\xd7?d.jl\x04\xfb\xeb?_\xb2\x93\xfa\x12"\xf1?\xec\x13W\x85\x7f\xed\xf1\xbfYo\xe7\xb1\xd4d\xbd?O\xbee\xda\xc6\x80\xd6\xbf\xf1(\xab\x99\xc9\x03\xe7\xbf\xe3\xcc}+\xb7\x06\xf6?\xc41X\xf8\xb1\x0c\xcf\xbf\xf0\x0b\x19\x18\x99\xe7\xda\xbf\xf6\x81}\x1e\x04\xba\xf1?\xcfK\x19\xd2\xc7k\xeb?9JpZ\x91\xc8\xf0\xbfn\xe3\xa1\xc4j:\xeb?\xbe\xcb="\xb0\x10\xc6?\xcf[/v\xb3\x14\xb9\xbf3\xbb\xc7l\xb5u\xf9\xbf;\xa9\xadv\xe2\x02\xf4\xbf\xc2_\xb3\xbb\xcaQ\xd8\xbf\xaa\xaa\x82\x9a\x19\x1c\xd1?|O\xb9\x800K\xcf?\x14\xb5=2\xb5\x0e\xe1?\xef\x86\x81\x973\x84\xe8?\xa9o\xa7zx\x07\xf6\xbfcd\\\xf0y\x89\xd4?\xfe%\xf7\x1c\x9f\x1d\xf2?s\x94h|z\xe9\xc8\xbf(\x0er\xb2\xfe?\xad\xbf\xd1\n\x97\xdf\r\x98\xc1\xbf\xcc\xceFz6M\x87\xbf\x05\x0c\x1b\x1d\x03o\xdf?\xe8*\xa8\x90\xb4\xdc\xf7?X\x0f\xbc\xa7h\xc3\xe8?3V\x0f\xc2w\x94\xea\xbf\x13\x19\xcc\xa5\xbeL\x00@{\x02\x8e6\xcc\xfc\xd2\xbfN\xe0i3\xfeB\xef\xbf\xeba\x96\xe71\xa7\xed?\xdc\x06\xf3\x83\xc9\xbc\xbd\xbf15I\x92L3\xf2?Y1"f\xdd+\xe9\xbf:^\xb2>;\xe2\xf9?\xc70\xb3\x16\x1d_\xc2\xbf\xdc\x9b\xf7\x9en\xb8\xfa\xbff\xb0m38&\xc6\xbf/7PP\xba\x10\xf2?n\xa7=\xacS\xfd\xc1?\x11\xbc^\x1a;\xf2\xd4?\x144\xces\x83:\xf6?\xc4H\x98\xbe\xca\x96\xcc?\x8aO\xf4\x16\xd6F\xea\xbf\xe2iA\xa6\x84\xfb\xd6?^\xb8\xb9\x1c=\xdc\xe9?Z\xec\xd4\x8d\x07\x89\x8c?\xf9\xa7 \xcdIa\xe9\xbf\x0f\x0b\x03\x1e\x92m\xec\xbf5\xd4\x83~\xd6\xa7\xe0?\xaf!\xc6\xef\xf2R\xdf\xbf1\n\xc7\x93]\x8d\xe1\xbf\x8c|\x95#!"s\xbf\xccg\x89f\xfbK\xe0\xbf\x89pd\xee>\xa4\xea?\xdd{\xbf\x04\x01\x8a\xd1?\x87\x9dd\x94\x93\x13\xfb?\x9aKq~&,\xe4\xbf\'Zar\xca\xcf\xf7\xbf\xa8\x7f\xf81--\xdb?\xa3\xecT\xc8\xcb\x84\xff?Q\xfap\n\x06:\xe7\xbfBZj\xb6_\xdf\xf4?vZ\xb7P,~\xe2?5\xf62SCa\xe4?\r\xce\xa8\x01\xf1u\xf8\xbfQd\x0f\x04I+\xf4\xbf\xfa\xad\xbb\xd6\xca\t\xf2?\x1e\x8e\x83\x047"\xda\xbfG\xb4\xd1\x7f\xb0w\xff\xbf\xa4\xeb\xa3\xad\xad?\xca?\xa1U\xa0C\xf0\xb3\xff?0\xf3\xe0\x81\xa5\x06\xe9?\xee\x95\xedknl\xb3\xbf\xf1\xe4*mW,\xe3?\xce\x0f\x9f"\xea\x9d\xef?\x80\xb7^\xf31I\xdc?m\x81\xf0wV\xaf\xe7?\x8d\xa5\x0f\xa3C\x15\xfa?\xe0^\xc5Vx\x15\x02@\x1a -\xff\xb4\xf9\xea?\xf3\xc3\x84\x8e\xc3;\xf1?\xcb\xd0JB\x9dp\xe0?\xcf2\xbc\xf15\xa9\xfe?J\x16\xb7\xd0J\xad\xf6?K\xab\x94\xc3@\xb0\xe8?\xbd(\xec\x11\x0b\xea\xf6?\x8b\xec\xa6\xca\xf1\xe5\xea?\xdfR\xb7\xb8z\xb2\xf6?j\xd6`\x87GM\xb5?\t\xc5\xfa\xc3\xd0\xa2\xdb\xbf#\xf8\xef\x91,\xa4\xf5\xbf\x1e\xecY!\xd3u\xd1\xbf(\xe6\nc\x96\xbd\xf1\xbf\xc6\xa9\xe4\x89T\xb7\xbe\xbfN\xe0c\xd2\xb33\xea\xbf8\\\x11\x03<0\xb0\xbf}\xd4\x1b\x81H\xc1\xd0\xbf0\xd4\xb7\xf2\x1c0\x06\xc0.\xc5\x0bX?\n\xf7\xbf\xc9\xf5\xb9\xdd%\t\xd2\xbf\x1d)S\xffb\xcc\x00@\xb6`\xc6\x0f\xa8J\xe1\xbf\x02\xa3\xd4\xe1\xbd\xf9\xcc\xbf\xbdV\xe7\xf2`\xcd\xf5?\xbf9\xec7\x04\xab\xe2?Y\xd3\xed\xfc}\x88\xd7?`E\xdeL\x99V\xe8\xbf!\x95\xa5\x89"\'\xe7\xbf\x85\xda\x04\xb1\x00\xb9\xf0?\xf3b\xfa\x00\xedz\x06\xc0\x825\x8e\r6\x94\x01\xc0v\x80\x99z\x84\x13\xaf\xbf8\xab\xb1\x8eC\xec\xb1\xbf\\N\xf9%\x15\xb4\xe9\xbf\xdf\xc2\x9e\x8f\x9b\x08\xbe\xbf`\xc3\xf6l\xee\xa6\xf7?\x0eC\xbf\xfe\x1e\xd3\xe4\xbf@\xebe\x05\xd2\xc7\xe9\xbf\xdbN\x8f\xb8!\xbc\xec\xbf\xf5\xc5\xffkZ\xd1\xe5?\xfb\xbet\x88\xa7\xe5\xe9\xbf*=(\xbf\xa0\x97\x94\xbf_\x12s\x13pT\x91?;\xada\xb6h\x9b\xbf?\xa9`|\x1d\xe6\xe5\xe0\xbfK]\x07\xe8\xbb\x85\xce?\xc1=\x9d\xb1\xbfG\xf5?Q\x89\xe6I\x11k\xe6?3\xe4\x10$\'\x10\xf8?\x92\xa8\xea\x1f\xe1F\xd6?\xfd\xfc\x19\xd7\xef\x8d\xf6?\x08u\xc0\x05\xc7\x1d\xdd?\xb4\x8a,N\xe0\x98\x02\xc0\xf6\xed.\xd5\xce\xb2\xda\xbfO,\xa6\\\x9b\xda\xf7\xbf\xb1rk_\xc6\xbe\xce\xbf\x05>v\\\x01\xca\xb6?J\x9fz\xb7\xea\x02\xf1\xbfq\x0fL\xd3Fi\x98\xbf\xf4h\x0eHWF\xfe\xbf\xaa\xd0q\x1f\xa6S\xd7\xbf\x83\x8e\xd5\x8aR\x01\xd6\xbf\x9a\xc0Z\xfd\x0cY\xcb?)[\xc0\x16\x13.\xb4\xbf\xbc\xa1\t\x8fP\xdc\xd0?\xf0RpN\x9f\x94\xeb?\x9a\x8dE\xce\x92l\xe2?ki\xd6\x9a=:\xc7\xbfABbtQ\xba\xe0?\x00\'\xe7\x95\xc2\x7f\xc4?\x1aD\xe3\xc5B\xef\xc5\xbf\xdf\x1d\xa9\x0e\t\x8e\xf8?kBlc\xb3\x13\xd3?\xd7\x06\xf6\r\xba\xc8\xb0\xbf\x147\xe2bR,\xe1?a\x0c%\x8b\x9d\x0c\xd8?\xf0>E\xb01\x17\xe5?\xcf\x83\x19\xb0\x05(\xf1?y"\xf73\x8c\xd3\xbf?`\x98iw\xdd6\xe5\xbf\x96+,\x1f"#\x01\xc0y\xd3\xb0&s>\xb4?S1\x88&\x95|\x00\xc0\xb4(\xef\x80\xa9\x11\xd2\xbf\xb6ucU\xd1\x81\xdd\xbf\x16\xafc\x9b\xccV\xfa\xbfuL\xbe>\xc2n\xd5\xbf{\xa5\xf7\x1e\xe4\xae\xf1?\x9a\x82$\xc9\xf0_\x03\xc0\xc8A\xeb\xf8\x0f\x01\xd7?\xaa\xfa\xee\xb3\xebz\xcd?\xb1\xc8\xad\x99T\x1e\xef\xbf+\x19z\x9b\xdf3\xe7?\xe9\xa0\xfa6\xb6\xea\xda?#7\x89\x94o[\xe2\xbf?\xb0\xdc=\x14\xec\xe2?\xe5\x11\x93K\xfc\xd4\xe4?F,[\xa1\x90\x94\t\xc0\xc3;\xe2\x8d\xa5x\x10\xc0\xe5\x8bo-{u\xf6?g2X$9L\x11@\\@x\xf74J\x12@g\x1a\xa1\xf7*\xfc\x0f@;\xe9%\x7f[\t\x0e@\x10(\x04\xedE!\x16@z\xd7\xb0\xc6\xf3q\x0f@\xc8M\xc9\xdew\xe6\x11@\xf1\x95K\x8b\xa4a\xfd?\xbb\x17}\xd8\xe4\xcb\t@\t|\xf5\x1eX\xbb\xe6?\xe9CT|\x0b"\xbe\xbf^\xb9\xf5M\xaf\xee\xf1\xbf\xa4\x0c\xba\xf6\x8d\xba\xeb?\xde\x15\x0b\x16\xac\r\xd9\xbf\xdf\xbds\xc0\xf7\xe5\xe8\xbf\xe8\x1a\x0e\x95\xd7\xd7\x07\xc0\xcdN\x82\xbb\x86]\xec?:\xbb\xae[\xf4\x9b\xe8\xbf% \xda\xb3\x1e9\xd3\xbf\xbfXr\xd7e\x8b\xf0\xbf\xc5\x83\t\xba\x85E\xed\xbf\x01\xc51\x1c\xba\x85\xf2\xbf\xaeoy\xb5\xe3n\xe2\xbf\x8aB\xaf\xdd}\x7f\xf3\xbfh\xc5f\x92\xd1\x8e\x0b\xc0\xa7\xf1R\xd2\xad\xa4\x00\xc0\xaf\x87.\x95A\xc1\xe9\xbf7\x02\xc8G\xb0\x1b\x10@.7\t\xba\xa9p\x10@q\xa7@h\x8e\x8b\x06@\x19\xb2\xaeG@\xcd\xfd?YQbDR&\xfc?lm\x03\xf0\x07(\x10@A\xd5\xbb\xc4\xf1\xd3\x04@\xd6\xcc\xe5\x95\x80\x1c\x05@=\xb7\x83\x03\x918\x00@\xb48\xb0k^x\x00@^&\xe7$2\xe4\xce\xbf\xc1*\x80b\xca\x9e\xf2?\xb3k*\xe9\xec\x00\xe0?\x1e\xa1z\xec\x91\x13\xe8?W\xc4K)u\xe7\xb8?\x06\xcfo\x1d\x90\xf1\xf6\xbfq\xd1L\x9b\xd7\xa5\xd1\xbfmj\x93\x00\x85\xb6\xe0?\xd8\x97\xfe\xb3b\x18\xc3\xbf>\x915\xe7\x85E\xf6?#\xb9&\xf8\xbb9\xd4?\xab\xa8\xaa \x1c\xf1\xee\xbf7j\xc4\xffp"\xe8\xbf\xa5\xee\x9b_\xf2\xe5\xf9\xbf\x80\x97\xce\xec\xffT\x07\xc0\xcb|\x0fl\x1c\xd4\x04\xc0-\x06\x13\x83\xe9\x11\xcd?\xb2D\t\xfe.9\x03@1\xdf\x17\x0b\x8eb\x10@\x93\xd2\xcfD\x8a~\x06@\xc61\xd5\x06C\xdb\x05@\xb6\x83\x82\xc9\xb0j\xff?\xc5\xef\x1d\x8e\x87\xeb\xe9?\x13\xc2\xbc\x00M\xf1\xfd?\x17Y\x92\tt~\xdc?}\x95\xfa\x9c\xa1E\xbe\xbf#\x04n\xf08!\x00\xc0\x8a\x9f\xb2\xadk\xd7\xe7\xbf\x9e\x87\x83\x1bw"\x02\xc0\xd9\xfe`\x1c\x14\xcb\xe2?\n\x048@<9\xe0\xbf&:\xd5\x18\xd1\x06\xe9?D\xcaD\xcfD\xde\xee?%"\x18\x97\xdd\xd9\xf2\xbf5\xeaW\xad\x1b\x91\xda\xbf\x8cz\xc2Q\xba\xd7\xf2?\xefx\xba\xed\xaaE\xf3\xbf\xe8\x0c\xa3\xd4\x85\x14\xe5?\x80\xf7\x03ED\x86\xd4?"\x044\xde\xa7F\xf0\xbf\x98\xcb\xdb\xf9O~\xcf\xbf\xfd\x1b\xaf\'!\x16\xf8\xbf\x8bb\xe7\xe5\x03\xb5\x0b\xc0\xdf%G\xa7\xe7\xc6\xf8\xbfc\x80\x10\x82\xfd\x1f\xf9?\xadM\x93\xbf\xd7\x92\x12@[\x0f[Q\xd52\x06@\x94v\x07\x97\xb9v\xbb?\xbc\xae\xad\xfaM\xeb\x02@\xcb\x04!\xc7\xa2\xb0\xf6?\xfd!d1YG\xf0\xbf\xce\xe2\xd821\x0c\xcb\xbf\xf1V\x18\x88C\xe6\xf5\xbf\xc8:\x85\x91,\xf0\xd1\xbfG\x84\xa0\x05\x079\xe8\xbf\x02\xc9\xac\x00\xad\x82\xe8\xbfx\xf1Q\xca\xbfi\x0b\xc0\xdf\xee\xa8\xf9\x06a\xe0\xbf\xb8\xa8\x84\x91_\xfa\xe6?\x18\x9b\xe9\x14\xb5r\xf2?9\x10\x82\xa7\xef\xb5\xf5\xbf\xc6\x8a}\xb1\xec\xd3\xff?hXJ\x10gq\xe4?k6;K7\xca\xd8?y\xba \xe1\x11h\xc2?$m\xe3"\x90\xe5\xd5?E\n\xb1`0\xcc\xf4\xbf0\xba?\xbd\x86\x87\x01@\xaf\xcaF\xcc \x88\x05@\xb1\xb6j\xdc\xbf\x84\x00\xc0\xe1\x86\xb6\x94\x89v\xea\xbfd\xaa$\xf3\xc0P\xce\xbf\x1c\xa4\x14?\xba\xe0\xf9?[\x9eA\xc1\x80{\t@\x14\x84\xd5)\xa2\xa7\x07@\x11u\xf3}/\xfe\xe9?\xb0\x15\xce=E\xa5\x01@\x86,Gw\x906\xe8?\x9bA\x06\xe58\x08\xe7?\x07\xe0kF\xf3t\xaa\xbf\xfa\x9dHt\x07;\xe9\xbft^\xff\xb8\x1e\'\xf5\xbf\xa2\x8c\x9c}p\xeb\xeb?=\xc7\xc0\x1c\xdf.\xe4\xbf!I\xf0\xcb\xed\x00\xfd\xbf\xba\xd0\x9e\x1e;H\xf5?\xb6\xee\x15f:\xfa\xf0? Eq[\xc4k\xe5?\xe4\x98\x91\xee(\xe4\xe3\xbfw\x87YGc\xcf\xf6\xbf\x8f\xcd3\xd5\xbe\xd6\xd0\xbf\xee\xaf\x8e\x8d\x1e\xca\xee\xbf\xbbw\xcf\xcd\x83]\xf6?\xe7\x12\x0e>\x97)\xca?~\x98\xb7\xe6:\xdf\xeb?\x16*du\x8d\xfc\xec\xbf4w\x1b\xe2\x93p\xea?\xec\xa3\xc2\xf74\x8b\xeb?\x0eL\x01\xee\xdf3\xe7\xbf=\xe5\xca\xcc\xd0\xef\xdf?L\x0f\\\x00\xa9\xa2\x12@\x95\xc0\xe4\x8a\xfe\x99\x15@\x0bj\xd6\x8f\x03\xa0\x07@\x90S\xbe\xd9\xf3\xb1\xd7?\x00b\x8d\xa6\r\x7f\xf0?T-\x1cj\xf7\x13\xf5\xbf*(PT9\xc2\xe2\xbf)\xa4\xd8b\xd6\xd7\xd0?\xd8\xbf\xbcD\xd2\xda\xfa\xbf\xbc\xeb;\xaf\x19\xe0\xed\xbf\x8e\x89\x19t\xc2\x00\xff\xbf/\x04$l\xe3\xa6\xd9\xbfu\xa8\x08e\xfbH\xf5\xbf\xb1O\x8c\xa9q\x0c\x01\xc0b\xd5\xeb\x93c\r\xc7\xbf\xfc0\xa7^Z*\xef\xbf3H\xf0\xd1\xc6\xd8\xfa\xbf\x83\xc0e\xc4\xb1!\xf4\xbf\x94\x0b\x08rl\xc9\xeb\xbf\x1c\xe5\x98\xfb\xe2\x15\xe1?kU\x85\xf0c\x88\xc1?\x1bi\x8e\x01\xa0m\xf0\xbfx\xc2\x8e(E%\x07\xc0\x8b\xc2LF]\xf3\xf3\xbf;\xdbmE\xcf\xb7\xfb?oM\x04\xf6]z\xdb\xbf[\xf7$h\xc0\x17\xe8?\xfa_-h\xfcp\xf5?\x1e\x15\x11}\xab\xe0\xe2?\xd9\xb5UR\x90!\xa5\xbf\xd0\xd4\n3\x95\xaa\xb8?\xe3hxX|8\xf8?V\xb3\xdaT\x93h\xf0?J\xa6u\xa6\xda\xd4\xc2?VY\xd1\xff\x11\xd1\xfa\xbf\xf0\x1d\xdbf;\x92\x06\xc0\xe2\x94\x94\xef\x0f\x9f\x05\xc0{v\xf7x\x9fq\xf2\xbf\r\xa8\xea\xd6o\xce\x08\xc0GD\xb0\xbf7\xad\xff\xbfs\xde\xcc\x95\x0fR\xb8\xbf\xba=\x96\xaf\xf9\x08\xe1\xbf(\x85\xd6B\xa5\x90\x02\xc0\xac\x03\xc0\x05\x0b\x9d\xe6?l\x98\xff\xee\xc9&\xd6\xbf\xe2\xe6/B\t6\xf6\xbfU?u!\t\xc0\xf2?\xce;\xe8\xa8X{\xf8?p\xce\xea\nA5\xf4\xbf\xc8|\xd1\x18qI\xe3\xbf~h\xa4\x80\x1c~\x01\xc0K~\xf83\x88\xe1\xe1?\x81c8\xca\x01\x1c\xd2\xbf#\nv\x90Z\x94\xf4\xbf\xeb8~S9\xf3\xd1\xbf\xedY\xcc\xce\xe7{\x0e\xc0\x03h\x8b)\xdb\x0c\xf1\xbf+N\x96\xab\xc8\xc9\xf0\xbf\xf56\xd9\x0b\xa96\xd1\xbf.\xba\x85\xc7\xec\x1b\xef?\xe8H\x1e\xb8M\xc5\xca?\xc3\x17.\xce\x1b\x0f\xe3\xbfM\xdb\xcb3\xb14\xf4\xbf\x15x\xaf\x1a\\D\xf6\xbfd\xcc\xc9\xa6\xa5}\xf2\xbf\x99G\xae\xf5\xf94\x07\xc0\x9a`\xde\xbaNr\x02\xc0\xdc\xee9\xe75\xa8\xe1\xbf1\x92\x89fN\xfc\xe0\xbfIE\x1f\x19!A\xe8\xbf4\xf6n\x05m\xcc\xfc\xbf\xcb\x93=Y\x14\x1b\xe3\xbf]\xf7jC\\\xba\xe8\xbf\xb2\xdb4\r\x1b\x16\xc7\xbf\xbe\xa2k\xe3\xa8\xd7\xe3\xbf\x8b\xd0\xf5\xff\x99\xb3\xd7?~\xc4\x9d\x93\xc0\xfc\xf3\xbfB\xa85\r\xd67\xed\xbf\xeb\xe6\x94\xc9dZ\xe8?q\xac\xbd\x9c\x08\x16\xaf\xbf\xb9\xd1\xf7\xc5\xb5\xad\x05\xc0\xa5\xf4\x16\xa3\x03T\x02\xc0T \xf2\xb6>-\x0b\xc0\xe1\xc5@\xbee\xbb\r\xc0B\xb73\x14\xfa\xa6\x04\xc0\xff2hA\xcd\xe8\xd2\xbf\xc8\xea\x84\x8d\xdc\x8b\xd3\xbf<\x9c\xb7z\xd2f\xd9?\xae5\'\xf4\xf9k\xf3?\x98!dd\xba\xe6\xd8\xbfh\xa6x\xcf\x9c\xf9\xf1?\xd5\x17\xa6#\x16\x9c\xf7\xbf7Z\x1c\xb2\x10\xa2\xe2\xbf 1<\xa6\xbd-\xdb\xbf\x83\xb6\xbcKt\xba\xef?\xe9\xff\xc2\xf5p\xa3\xfe\xbff\\\xad\x89\x85\xf3\xd8?\x94\x06\xf0\x1c\x07;\xa8?\x10\xb7\xd2\x81~6\xfa?\x0e\xd2\xed\xe6"\xb5\xe3\xbf\xa0\x17\t%\xc5\n\xcc\xbf\xec\x92J0v\x14\xf7?m\xfd\x94\xf0\xb7\xf9\xec\xbfa\x9e\x14=\x99v\xee\xbf\xe3-\xbe\xed\x0c\xda\xcd\xbfc[\x95\x82\xe8\xc5\xd7\xbf\xcc|\x19Z\xa54\xf3\xbf\x1c\x04\xb1}\xcf\xf2\xf9\xbf\rpm\xe5\x10\x08\xdc?)\xe4Z\xad\xc8\xa7\xe7?\x038L\xcc\xfd\xe7\xf3?\xa7\xf54\x98.\xcd\xcc\xbf\xff\xe7<\x8dh\x93\xea\xbf\xa0\xa6\xea\xe3\'[\xfa?\x9a\x83~\x12\xdf\xbb\xd6\xbfi\x1d&~\x98E\xa4\xbf\x18(<\xb9n\x99\x00@h{\xf0\xa9\x19\x13\xe4\xbfu\x84\xe0\xe9\xd9\xda\xb3\xbf\x99oa\xca\x9d.\xe7?\xc6\xbap\tB\xde\xe8\xbf\xe4\x8fC%\x18\xb1\xfb\xbf\xd7\xe8\xc4k\\_\xef\xbf\xb9A\t\x84"\x10\xef\xbf!a2\xca\x93L\xfa\xbf\xf5\x9b\xa7\xd9Do\xe6?\xe3\xaaYf\xc69\xe7\xbf,\xbc|\x17\xa6w\xe6?\x12\x01D\x08d\x88\xef?\x1c\x85\x93\xa8q\x9f\xc9?S\x87\xf8\xb3\xd2#\xbd?\x15b\x10\x90\xc63\xf1\xbf\x1c\xff\x89\xfeL\x80\xca\xbfY\xdaa=\x92\x87\xf9\xbf\xa6\xf9\xf1\x15\xd4\xf9\x03@\xaf*%\xb6.n\xf0?Y\x9f\xda\xc4\xf5\xe9\xbf\xac\xf7\xab\xb7o\x88\xbe\xbfT\x9f\xcd#\xc1p\xa5?\x07\xac5\xd2\x15w\xaf?\xdf\xa0t\xb8(K\xfb?\xac\xce2X9\xcd\xfd?O\x14\x9a\xf60\xbe\xfc?\xdb\xc4\xa9\x06\xdd\xdc\xfb?DC1\xe4w\xe7\xec?\xb6\x90\x15\x85\xef\xab\x00@SE/\xacZ\xe1\xd6\xbf\x85\xe4\x9b;GG\xe7?H\xaaY\xe1\x8e\xa2\x03\xc0u\x8a(D|8\xe7?\xd9i\x1e\xbf*\xd2\xed?\xbeU\xa4\xa9!]\x02\xc0\x89\xe7Z\xba\x9a\xf7\xe6?\x96s\x07"\x81\xee\xe5\xbf\xb6^\x82w\xb0\x82\xe9\xbf\x17eJL^\x8f\xd5?8\x99\xe1S*\x0b\x04\xc0\xdb\r\xc8\x14K\x94\xc1?\x04\x1e\x05G\xc60\xe6?+\x80=\\\xe7B\x93\xbf\x1co\xf0m\x96\r\xf6\xbf\x96x\xd2\x9ak\x81\xde?M\xc2\x7f\xc7\x96\xf3\xf6\xbf1\x8f\xe4sw-\xf8\xbf\x89\xd2\x16{\r\xca\xe0?\x8b\xc83\xfc-\xa5\xbf\xbf\xfa\x19\xc0\xb2\x18\xb7\xef\xbf\xfe\x15\xf3x\x13\x9f\xf4?\t[\x11\xe9EX\xd5?\x84\xf0L\x19\x84\x0b\xf0?\x0e^"\x1cB\xb5\xd8\xbf\x94\xd0L \xa3T\xea?\xf5\xcf\xc5\x84\xc4\xe5\xf4?\xea\xe3>\xe0.\x1b\xe7?]E\x8f\x82BH\xe5\xbfW\xd6/\x18\xad\'\xf7?\xb7\xec\xf2\xf4\xf7\xcb\xc4?\xf9S\xaa\xe0\xba<\xd0?4\xef\xd2UT=\xb7?\x11\xd8\x82\xd6\x86\xff\xf1?\x19\xb0\x16H\xa9\xe0\xf6\xbf\xaf3\xd3\x17\x14\xb6\x9f?\x82\xac\xc3\x8e\xbb\xc2\xf0\xbf\x8d\x1c\x90\xf1 \xc9\xee\xbf\x12\x96H\xd2\xc2\xa4\xd0\xbf?"\x9f\xe2\xaf\xc0\xea?&\xbej\xc2\xca\xe4\xd6\xbf.\x83\xc0\x94{\x8b\xf3\xbf_\x069\\j\x13\x01\xc0 \xc5\xa3inX\xf0\xbfd\xe8_\x1f`\xf0\xf2\xbf\x95\xc4\x8c/i\x1f\n\xc0\xe0\xac\xce\xc8\r\x02\xd2?Cm\x95\xd3\x9aU\xf9\xbf\x83Y*\xdc2\xb9\xe3\xbf;\xb1s\x8b,w\xf1?qh@\xfao\x13\xd7\xbfx\xf1\x19"\x90;\xf0?\xb4\xa3\xa8\xbaz\x0e\x05@\xd1\xd8\x9a,$2\xea?%S_\x83\xc6(\xa0\xbf\xdf\xa1\xf1 \xd4\x1e\xd2?\xbfN\xbe\xd8\x04\xde\xa3\xbf<^\x16m\x8e\x07\xa4\xbf\x03\t\xe9\x82d\xa8\xf2\xbf\x9dg\xdb\n+&\xf8?\x12x\x8f\xf9g]\xd8\xbfA3\x9c\xda*\x8e\xf5?\x03\x06\x0f\xe5?\xa1\x9b\xf0\xcbw\xa8\x08\xc04\xbf\x14\xac\xbdU\xf3?9z\xed\x8c\xedh\xc3?Jw\xfdp;B\xd4\xbf,d\xcc\xe2\x9b]\xc2?U\xba\x1f\xb9\x85\xa4\xea\xbf\x90\xd3{\xd3\xeb\xbb\xe2\xbf\xa7\x8bY\xe8\x0bx\xed\xbf\xa7(I\xc2\xfc\xe7\xdb?9wX\x19\xa0\x95\xf1?\xa8f\xc3\xfb\xa0\xc2\xbb?\'\x9a]?k@\xff\xbf\xda\xfe\x03\xa7<$\xec\xbf\xaa\x01\xcb\xca\xbf0\xf0?\x08\xc4\xe7N\x00\xa7\xdb\xbf#\xd1V\x12@,\xf6?\xb2\xe6\x16\x9f\x12\x92\xfb?j\xd2\x88\x88s5\xe1?\xf5]\x1a\x85\x16\xa2\x00\xc0_L\xd5{\xee5\x8d\xbf\x178\x1a{\xdf%\xd1\xbf\x82\xfc\xc8W\xf4~\xd2?\xb6:\xc6*\x1e\xd7\x8a?;\x04\xbd\xe8\x89\xe7\xb3\xbf\xad\x9a\x93\x06\x08\x98\xd0?4\xfc\xce\x84\xc5m\xe9?\xa9v\xc8\'\\)\xd7\xbf\xdc\xee\xce\xb2\x19\r\xb6?Z\xfa\xe6\x12\x9eI\xd8?a\xefr\xc5#7\xe6?DE\xa7C\x8cT\xb8?o\xfd\xf1`\xbf>\xcb?\xc1\x82\xc6\xddG\xa6\xe2?\xfa\xf2MQ\xa8\xf2\xbc?\xe37Z\x07FI\xa9\xbf\x9a\xcc\x81\xe6k\xe1\xdc\xbf,\xb2\xb6\xee\xfd\r\xf2?\x14\x8dD}\xc4\xc3\xdd?\xde\x95?K\xa6\xf2\xd7?\x96\xf6\x85$\x9eZ\xe2?\xb9\xb3y.~\xea\xf2?\xed\x19\x7f\x1d\xce\x8f\xe0?eh\xf0W\xc6\x0e\xad?\xa6V2^\xc2\xbe\xf3?\xa2\xb7\x91o\xdb\x00\xe6?\xa7\xfcB\xee\x81\xdd\x00@!\xadI\xce%\xa2\xfc?\xf2\x84\\\x9a\xc9\xe6\xe3\xbf\xe7\xe3\x07\x8cw\xd8\xef\xbf\xb2t\x8c\xdd\xa2\x06\xf9\xbfK/\x01\xb0\x87r\xf4\xbfh+4\xf2\xe3\x9f\xc3\xbfU1\x00\xd44\x03\xe0\xbfH\x16A(-C\xf6?\xec\xec\x85\x9a\x87W\xe6\xbf\xb3\xc6m\xef\xad>\xe5\xbf\x17\x8c\xb2C\xbb\xfd\xe4\xbf\xd7\xd0\xce-\x9d\xfd\xe2\xbfb!\x04?Fn\xbb?\x9co\x00\xb5\xf6c\xd8\xbf\xe2\xf0\xc8\xa7\xdc\x12\xfb\xbf^\xf3\xbcd\xa5|\xf3\xbf<1$\x82\x14F\xef\xbfY\xa4\xa0\ndX\xd3\xbf\xb6\x8f_\xc9\xcb\xe5\xd0\xbf\xd6\x81\xa5\xde6h\xb9\xbf\x8db\x8eb\xcc\xaa\xff\xbf[\xf7I\xfe\xf9M\xe5?Un\x84\x8d\ni\xea\xbf\xf8\x86\xa03\xcc\xf6\xf4\xbf\xb0\xe0\xf4m\xe5E\xd0\xbf@\xaa\xdf#\x9b-\xd0\xbf\x18\x07\xaaT\xa2p\xfd\xbfi\xf4S\x97\x9f\x9e\xf0?\xeb"b\xfe\x16\xf9\xce?4\\>\xb1\x7f6\xf6\xbf0s\xac\x83a\x9c\xf6\xbf\xf5D\x1eot\xf4\xfa\xbf\xe2\xa0\xfb\xb9Z\x16\xcf?7\x90r\xe6\x1ew\x00\xc0\'\x8d\xea1\x8c\xc1\xde\xbff\xd7g\xfd\xc0\xe8\xde?\xd7B&\xeeL/\xf1\xbf\xbev\xf1\xd9\xd5\xbd\xfb\xbf\xc8\xcc[\xb7\xf7\x1d\xf8\xbf\x89\x8e\xbc~b\xa6\x04\xc0\xa7{\xea\xbe\xe33\x04\xc0\xc8\xc5\xfe\xd6[\xbc\xf3\xbf\xb3\x1f\xc7~k\x14\xe9\xbf\xa2\xfe\xeb\xdf\x84\xbc\xe3\xbf\x177\xc59aD\xe1?\x076\xe3\x00\x80\xfc\x00\xc0%\x11\x7fh%\xee\x00\xc06G\xfd\x0e\xa3\xdb\xe4\xbf\xe2\x1b\xe9\x92\xc1_\xd0?\xf8G\xae\x82\xe4*\xe2?j\r\xf1L_D\xee\xbf\xa3\xda\x93\xf6\x15\xb8\xe7\xbf\x1a\x86\x8b\x061\xae\xd3\xbf\xdc\x91\xf1}\xdd\xe6\xd3\xbf\x8a*\xe3\xbe\xf1$\xf6\xbf\tfZ\x1f\xf7p\xf7\xbfE\x9c;\x85\xc76\xdf\xbf\x0c\x0c\xed\xdcZ\xc5\xf7\xbfC\xcf\t\xe5\x9b\xb6\xd5?\x84R\x93|v\xcf\xd2\xbf/\x00g\xb03\x1e\xbf\xbfv+\x98\xc23\xc0\xc1?G\xe17\xb6h\xdd\xd5\xbfp]\xd3e\x89\xcd\xe3\xbf\x99+m\xe9l\x0e\xd0\xbf\x99\xc9\xf8\xe9)\x99\xf3\xbf\xac\xb1\x8fx\xb7r\xda\xbf\xbe\x08\x90\xfc\xe3\x93\xe2\xbfo\x04 \xcd`7\xec?\xd8c\xc7\x90\x803\xf8?\xb2\x04\xd6\xecg\x87\xf1?\x9cXw\xe4?m\xb8\xeed\xc9\xe8\xf5?\xf79\xe7$\xa2\x97\xfb?\xc3\xf9\xeao\xb4\r\xc2\xbfG\xdbS\xc4\x8e+\xc4\xbf$\'\xb6\xfc\xfd\xbd\xd1?\xe9p\xe3\xc7p\xea\x02\xc0gG\x9f\x12\xacn\xea\xbf^\x18\xc3\xfa\x9a!\xe9\xbf\xeb\xf0QEA3\xe6\xbf2\xaa\x82@p\x1c\xcb\xbf\xfe\x83~[\x7f\xf0\xf0\xbfp[Yq\xd7\xf5\xf8?\xcfp\x99\xef\xa4\xf7\xcb\xbf\x9b\x19XDkX\xf2?#\xcb\xd4^\'\xa5\xf4\xbf\xfe\xe8\x13\rG\xeb\xfa?\x14b\t\xa2>p\xf2?>\xc3\x8c\xf3uE\x05@\x1c\xe0d\xfd^\x01\xf7?F-\x07\x87\x12/\xfd?\xd26\xce\xd9\xcb\xbb\xd3\xbf\x9aH)\xb5S\x1b\xe2?\x18\x85m\xd3\xfb\xd0\xf3?M\xfa;G*o\xe4\xbf\xb0\x9b\xfc(\x96\x8f\xf1?xP\x84\x17\xfc\xc0\x02@#\x91\'\xbf\x06.\t@,\xe7\x00\x97\x85\x86\x04@\xe1cY\xe5\x9ex\t@u\x1bP\x7f\xac\x16\xd1?^j\xbf\x07\xf4\xcb\xe9?/\xda;\xf0\x89\xaf\x01@2hV\x0f\x95!\xe7\xbf\xe7|S\x89\xbbr\xd6\xbf\x90\xb4XW\xf2\xdc\xe5?V\x06]\xab\x86|\xe3\xbf\xb3_T\x8c\xc9\xe4\xe2\xbf\xe7\xef\x89\xd2\x00\x91\xec?i\xdc`\x15\xc6\xa1\xe6?^\x11<\xce\x98\xf4\xfa?\x99\x98E\x07\x85\x7f\xfc\xbf\x87\x87GX\xfd\xc3\xe4\xbfc\xecbrg\x87b?\x1b\xafG\xbe\x8c\xbc\xe6?,\xb2Ir=\x86\xfd?\xb2=\xa8\xb4o\xc3\xff?a\xa5^b\xda#\xf0?\xe4u\xec\xbev\x8f\x06@\n\xf5\x93\xea]\x92\x01@\xe9\xd9\x03\xe5y\xfd\xed?\x17\xa6\xdbR3\n\xec?\x0e\xb1X\xb19\x1c\x04@\xec\xcd\x7f\x98A5\t@]\xa6\xe87\x05%\x0b@\xb4E2\xe7\xbc\xb9\x0b@>\x0fI\x0c\x01\x91\x00@\xa9..\xd21\x12\x11@f^3\xde\xed\xb8\xfb?\xc6\x92*_\xef`\xdc?\x83PP\xc7\x17?\xcf\xbf*bc\xf0\xcc\x8c\xd0?1z\xc6\xd1\xf9{\x9d\xbf,\x96\x98\xce2\xe9\xf1?\x81rjw\xeb\x1e\xea\xbf R\xef\x93\xfc\xa0\xe1?\x17k\xaa\x0b\x02\r\xf1?\xc0\xdf\t[\xbc\x7f\xe6\xbf\xe8\x94B\\\x05\x82\xee\xbf&\x94\x85\n\xc7\xfc\xd1\xbf\xf1-\xfc\xe2/\xda\xfd\xbf\x07\xbfn\x81\x93\xbc\xc6\xbfG\xfa\x82 @~\xf4? \xb5\xca[4\xa9\xe4?<;_\x98\x8cf\x03@v\x95\x17\x87\xac\x1b\t@\xd4u\xeaW\xe2\r\xfb?\xd1\xe7\x8d\t\x94o\x14@\x9b\x93\x9a}\xd03\xf8?,\x0c\xb9tiF\t@z\x82V\xcbj\xad\x11@\t\x19\xe4\xee\x91t\x10@\x80\xeb\x0e)O4\xfc?Djx\x98\xa8\xaf\t@0+_k\x10K\xde\xbf$:\xbb\xf5\xbfac\xf8&8\x95\xdb\xbf\xba\xbf\x08M[)\xed\xbf\x8c\x8e|\xf8\xf5\xe7\xdd?F\xc1\x15\xb2\x00\xe5\xca\xbf\x1a\xce"n\xec5\x04@\xbeK\xf7\x17"\x87\xd2?z\xb1\x8cMAV\xe5?1H\xcf\xfc\xc1\xc9\x00@\xf5.}\x01\x87\\\xf0\xbf-\xa3\x81\xb2N\xa3\xe3?>\x9b\x14\x1b\xd2B\xe7?J\x11\x97\x9b\xe1\xd0\xe3\xbf\xf7!*T+\xd3\xc1?\x17T\x8b#u\xfe\xca\xbf\x8c\x18(\xbf\xe48\xc1\xbf\xbdMy\xb3\xc4\xb2\xde\xbfV!)\xe2\x8a\xee\xd2\xbf\xd9o\x00\xea\x06\xd4\xbc?{*\x8a\x96\xf2\n\x03\xc0\xbc\x8d\x16\xb0d\x0f\xef\xbfJ\xe3/8\xa91\xb4?\x88\x12\x04\xf4C\x17\xc3\xbf\xb5\x8e\xf9\x81\xb7r\xe6\xbf\xacG;k\xa8\xa4\xb6?.z\xf7\x16P>\xef?\xd3\x821\xc1\xb0\x00\xe5\xbfLH\x99\xcd\xda\xe3\x01\xc0\xa8\x8c\\dO\xd5\xcf\xbf\xc3L\xf1\xb3^e\xf1\xbfu\x07\xdd8\x17\xf4\xd2\xbf\xf7#MF\x7fT\xe9\xbf\x85A\x967\xc7d\x93\xbfWV |@h\xfa\xbf\x97\xd0\x85\x9c\xd5+\xf4\xbf\xcbo\xfd7\nY\xb5\xbf\xbax\xe4z\x93T\x10\xc0;\n\xd9\\1\x94\x01\xc0\xc9\x056x\x14\xb1\x02\xc0|s\x90^\xa5n\xf4\xbf/\xc0(\x87\xe4$\xfb\xbf\xb8\x16V{!\x0e\xf8?\xc1\x83\xbb\xf3\x9eY\xe1?\x95\x88\xb3`Y\xed\xe5?\xfd#\xa68\xa5\xd6\xe6?0\x02\xd8D\xd0N\xd4??T\x15y\x04\xa0\xc0?.\xf7\x87\xabN\xda\xe8\xbfo\xfbl`\xca\xb4\xe3?\x8e\x06\x04\xc9\xeft\xcc?\xf3a\xd1\xb0}\x87\xd7\xbfxU\xf9a\x05\x98\xd0?{x\xda\xeb\xd24\xf1\xbf\x907\xe0\xad\xd1\xd4\xf8?RL!\xdb\x161\xd0?\x898\x85L\xef\xc0\x00\xc0:\x0448\xe3\x85\xd6?$S\xd3\xbc@\x04\xd4\xbfR\xb7T\x95\xb7\xe4\xf2\xbfc\xbe\xa0\xd3!h\xec\xbf\x9c\xe6Z\xbb\xf2\xea\xf2\xbfL\xfe\x13\xb3\x0e\x90\xc6?/Z$\xe2\xc5\x91\xe5\xbf\x96"\xb7\xd6Xf\x05\xc0\xee\x9b\xd1W\xab\xcb\x0f\xc0<\xc8\xa8}\xd10\xfd\xbf\xf8\xf1l\xcaB\x7f\x07\xc0\x89\xe2\xbc&\x94G\xf8\xbf3e\xa6\xf7\n\xcb\xa4?+\x82\xa1\x08\xfa4\xd4?\x1a\x8e\xf1\x90\xb9K\xa8\xbfyrv\xfc\xff\x8e\xcc\xbf\xc09(\xb1"|\xe8\xbf\xa1uA\xe9\xac\x05\xf2\xbfBX\xb7\xc2\xfa\xed\xf2\xbfx\xae\x02\xeen\x1d\xdb\xbfy9\xd0[\xb9%\xee?\xbf\xec\xad\xf1\xb6J\xd8\xbf\xb2Am\x14\x88\x92\x04@\xfdM\x85\xe3@+\xe8?.\x85\xbd\xa4\xf9@\xed\xbf\xff_Cj\xf4x\xe5?g\x86\x9exAm\xde?\xdf\x9b\x8a\n\xbc)\xf0?\x11S"\x93 b\xed\xbf\xc0\x92\x9e\x84\x97\x89\xce\xbfV\xa8\xc2\x8d<\x13\xf3\xbfp\x82^\x19\x12\xcb\xe6\xbf\xd42\xb8\xb9\xd9\xd1\xe3\xbf;\xc0QC:\x86\xe5?\xa6\xcb\xb6<\xafh\x05\xc0o0\xa9\x1a\x89\xb8\xde\xbf\xd0\x7f\xeb\xda\x95\xf3\xe9\xbfG]O\xe8q\xaa\xe7\xbf\xb4.N+\x18,\xd0\xbf\xbec\xb7\xcd\xb5\xed\x01\xc0!\xb2\x9f#\x9d\xd4\xd1?\xba\x07\xa3a\xf3\xa9\xf5\xbf\x82\x07\xe7\xe8\x93}\xf6\xbf\xf7;jud\xdb\xd4\xbf\x18\xbe\x0e\x10i\x08\xf1?S+\x0b\xca6+\xec\xbf5\xf8\xe9Y3P\n\xc0\xf9\x1a.\xbb\xee\xac\xf3\xbf(Ak\xe2\x1dY\xfa\xbf\xec\x04\x19\xd4f\xe2\x81\xbfk\t\xa1\x18A\xce\xfd\xbf\x08e\x08\xb9:\xe0\xca\xbf\xc3\xb8\xae\xe5\xce\xe2\xbd?\x88\n\x0b\xb2\x06\xba\xda\xbfL\xba\x11@qF\xf7?\xeeqA\xb7-\xb6\xe2\xbf\xa5(\x94\xb7u\x00\xe1\xbf}\xb9\xd0i\x9e\x01\xf7?Sc\xb1\x8ce\xb6\xf7?\x8c\x8e\x1bu:5\xc5\xbf\xd2\x9c4\xe3\xb5\x9c\xf2?\xb7\xc6\'N\x99C\xb7?\x8c\x9cx\xd1\xc6\x8f\xdd?\x12v\xa9X\xd0L\xda?;p\xc1\xf2Y1\xf3?\xa5s\xa7\xd0{\xa1\xe5?\xa1Y].\x1d\xc2\xfa\xbfH\x94F]:\x98\xf2\xbf\xc0_\xa4\x048\xe7\xea\xbf\xec\xa91\xc4\xb5\xea\xf1\xbfH`L\xe8\x11D\xe1\xbf\\Q1!\xf4\x11\xe1\xbf\xbd\xfd\xe8p 1\xfe\xbf%=$\xe2\n\x17\xdc\xbfk<\x12\x9c\xcb\xb3\xf0\xbf\x0bo\xb8\x8d\xa9\xf7\x8d\xbf\xd84\x16\xcf%9\x02@\xa2\x8a4\xa2\xb6\x93\xe7\xbf}\xc8\xb7|\xcb\x01\xe5?\xabjS\xe2\xf6\'\xcc?\x96\xdf\xab\x9c_\xbf\xf9?2\xd1g\xcb7`\xd1\xbf\x96d.3\xa8\xc8\xd0?\x8bu\x06"\x0eJ\xef?\xfe\xd9w\xda\xac\xdc\xca?\x87\xa9\x85\xfc\x84\'\xb0\xbf 8\xb2\xbd\xc4\x91\x05@\xba\xf4{dm\xf9\x03@\x02\xd8\xd9\xef\xa8\xf8\xbf?\xe5\xdb\xe1\xb7\x1fx\xf1?\xa1\xa2\xb8\x8a\x8b\x10\xf4?X1\xb6\xd0\xc8a\t@\xf0\x1b\x94\x83\xab\xa8\xf5?J\xfa\xd5\x0e\xbf=\xd4?6\xd8\xae^a\xac\xe7\xbfC\xed\x00\xb6\xcca\xf4\xbf&\xf1\xde\xca\x14\xbd\xd6\xbf\rd\xf2\xb5Y\t\xf0\xbf\xec\xc3\xf7[\x94_\xf8\xbf\x19\xee\xc7sf\xb5\xfe\xbf3br\xc6\xa9\x7f\xfd\xbf"\x1b:+Z\xfd\xe9\xbf\xff*\x7f\xb4\xd1`\x08\xc0\xc9\x7f\xbba>\x80\xd2\xbf\x99\x9d\xa9\x92\xbb\x10\xf1?9C\x803\x10\xce\x03\xc0\x87:\x9b\xb3+;\xd9?\x9d\xc8\x1a\x95\xed\xfd\xe5\xbfg\xf2\xbb\xc4-\xee\xcf?\xf8\xc7\xff\x96W\x85\xe3\xbf\x06\x80\x1a\\\x80\xa4\xeb?\xc4\xca\xb2!\xec\xe0\xfd?Q\xff)f\\\xcb\xe8?#\xa6\xcd\xf0>\x91\xf0?\xae,\xba\x1c\xa0|\xfc?\xb9\\\x04A\xfdz\xfd?C\xc3\xb1\x17\x1b2\xf8?An\xfc\x04\x06s\xb3?NE\xb1\xe2\x04\x8a\xe0?\xe5\x03E\x13\r\x86\x00@\xce\xe5\xdeW\x8eX\x00@\x93\x13\xb0X\x19\xaf\xaf\xbf\x16\x0c\x94\x81\x8d\x05\x01@\xdc\xfb\xa2\xe4\xb5!\xdc?\x99\xcf\x19[)\xe4\xde?\xa2\xd4X\x98\xdd?\xf6\xbf\xc6\x1d\x9e\x02\xbf\x9a\xf9\xbf\xc2\xda\xc6w6\xee\xfb\xbf\x84Q3\x00\x94\xf1\xff\xbfFU\x9e\x95|\xfa\xf5\xbfn!\xe4\xbd\xf5+\xf8\xbf\xb9\xce\x08\t/-\x05\xc0J\xa1\xe7\xef\n\x12\xe7\xbf\xf2\xfc\xb3\x95\x1b,\xdf?c\xed\x86\xf4\xad\xd2\xd4\xbf\x9b3\'\x19\xcaN\xbb?\xb6\xf5R\xb7\xe7\x14\xe3\xbf\xb5T\xd4O\xc7\xdb\xd3?\x7fh\'\xbd\x04w\x8c?}\xa8\xf5Y\xc1\x17\xea?\x0c\x17J\xe2\xf5k\xf7?\xf9\x01.\x0eI\xe6\xfb?J\x1d;\xcc\xff\xa2\xd8?\x89\x9d|\xee\xe4[\x04@\xfb\xc2R\xfb\xef\xba\x04@\'B>\x87\xae\x1d\xc2\xbf\xf9L\xef\xb0\xd8\x08\xf7?#\xbb\x8d\xc4\xb9X\xf7?/9L\xa0u\xfc\xff?\xeb\xde_\x80\xee\xa1\xec?\x18\x12P\x81\x0f\x0b\xf8?\rs\xbf\xe1li\xfb?\xdb\x1a\x82\xd5\xf7S\x00@i6\xad\xf9\x17\x03\xac?h\\\x1f\xd8\xbb\xba\xe3\xbf\xf0JL\x9b\xa8\xa8\xfc\xbf\xe6\x95\xb0\x1aK\xbf\xdc\xbf\x9d\xb0y/S;\xf9\xbf\x05\xd2\x94\xe2mB\xf0\xbf\x0f\xb7\x90\'CS\xeb?\xb4\xb7\xf0E2\xc0\xe4?4.E\xb6[*\xe6?3\xbcS\x08\xac\xf7\xe3\xbf.\xca\x9b\xd2\x9a^\xf6\xbf\xc6\xe4\xe2\x93\xdf\xa8\xf0?\x17\xe4\xd2@\x1f\x08\xf1?\xae\x05\xbdR\xce\xec\xf6\xbf>\xe6A\x07\xe0\xa7\xcf?\xf6&1\xb3\xf6\xf7\xf4?%\xed\xcb\x8fUh\xe6?C\x00o\xd9\xea\xde\xc2?\xae\xbf\xa6B\xbf\xcb\xdb?/\xfa\xd2X#L\xd2?\x89D\xbb\xad=\xc8\xdd\xbf\xe3\xd8\x8b\xd4\xc0\x1a\xf5\xbf\xf6a\xce_x\xa2\xfa?\x84\x14\xe6)]9\xd9?\xc9\x14/\xdd\xa2\x17\xe6?,\x9b"yY\xcf\x02@\xd43L\xa4\xe9\xd3\xec?\xec\x1a\x05\xfck\xe4\xf5\xbfDZHoq\xed\xd7\xbfd\xcb}\x14\x05\t\xf6?3]\xda\x13\x1f\x03\xe5\xbf\xf5\xd4\'\xce\xa6\x92\xf1\xbf*\x06;s*X\xd4?2\xd1\x10\xa9\xb9.\x00\xc0\x18l)\xdfD\xe7\xe8\xbf\x90\xc5\xa7\x07\x19\xc6\xe5\xbf\xc0\x1b\xf0d4\xee\xc5\xbf#\xe6%b\x80\x7f\xe2?H\x8dj\xd7/\xf2\xc1?QA\xf6\x7f\x88\xd6\xfb\xbf<\xaa\x8a;g\xb4\xdf?\x0e\xbck\xd0lU\xe8\xbf\x96\x1b\xfc]\xa2g\xe1?k\x15(I\xbc*\xb4?\x14\xc2\x1fc\x1a*\xf4\xbf\x8c\xeb\x91C\xdb\xa2\xe5\xbf\x17=/p`;\xe0\xbfMl\x18r\xf4/\xe8?\xb5O\x18\x9b\xe6\xde\xed\xbf\xa0\x8e\xa2\x07P\xb5\xf2\xbf\xcad\xcb\xfe\x95\xb0\xe8\xbfFH\xb9S\x9b\x06\xd5?\xbe\xc5\xf7qG\x1e\xe5\xbf\xfa\xe8Y\xdf\x11\xa3\xc0\xbf\x9e\xc6\x8f\x02\xcc_\xc1?/j\x04\xc2+\x11\xf9\xbf3pm\xac\xb4\xd0\t\xc0\'\xcf\xb3\xaaj\xb5\xa9\xbf\xe1\x8f\xfap\x8e\x86\xf7?\xc6\xdaj\x0c|\\\xe5?I\xc3\x18\x90\xbd0\xd2\xbf\xa5?d\xc5\x04\x03\xc7?\x12\xb4\x11\xdf\x95\xec\x05@\x97\xf0"y\x17\xe1\xe8\xbf\x02\xbe\xc5.\xad9\x00@\xd8\xd8\xabL\x9f\x88\xe4?\x04\x14\x11`\x07\xeb\xd4?\xa6\xa1\x10\xdb\xf7\xfa\xc3\xbf\xbfuW}\xa7\x1c\xd7?\x12>HYL\xcc\xed?\xf5{\xe79O\xbf\xc3?iK=g\xf4\xb1\xe8?\xea\x8a\xb2N\xcbj\xcb\xbfv\xb2\xc4YH6\xdd\xbf\xfe\xeb\x13\x11\x1f\x99\xf6\xbfN\x9c\x1c\xc0P\x81\xfe\xbf\x7f\xb3\x9e\xaa\xd7c\xf2\xbf\xda`\x1e\xfa\x17r\x02\xc0\xc0\x7f\x8d\x9fs\x85\r\xc0U\xf46C\xf0\x8c\x01\xc0\x1a\x8a\xa7\x9d\x80@\xf7\xbf\x9d\xf8\x9cW\x08\x92\xf1\xbfe\xdb\xb8\\\x0en\xed\xbf_\x1e\x1d\xd4S\xd3\xd4\xbf\x10Z\xcd\x14\xf9O\xe3\xbf\x8d/C\xc6=\x13\xfa\xbf?\xc1\xd4B\xc2^\xe5?r\xce1\x1f\x14f\xe3?\x13m\xbb&Oq\xe1?\x9eQ\x05\xce\xbc\x07\xee?\x0fb?\x1b\xec\xd3\x00@\xd8b\xb4]\x94J\xdb?0\x8ee\x10h5\xd2\xbfIc\xa9\x99P\xad\xb6?\xd6\x86N\xf8!a\xe7?\xe8-\'\xdd\xd1P\xe9\xbfj\xaf\xe1^+\xbf\xd8\xbf\x01\x012\x91T\x8e\xe2\xbf\x0c \xcd\xf8\xfb\xe6\xf1\xbf\x13B\xfe\xd1?\xb1\xdd\xbf\xcc\xf8\t\xf9\xd6\'\xf1\xbfS\xa1\x1f 1-\xf5\xbf\xae%A\xfe\x81\x1b\xfa\xbf\xca\x89\x1b\xb58\xbf\xfb\xbf\xe8\x98\x80\x11\x9c\xf5\xe6?[\xdb\xb3D[\xd4\xf5\xbf\x08\x87\x86\xa3\xa4\xe8\xf9\xbf\xa5\xed=\x17\x85\x8c\xf5\xbf\xecm\xd5h\x1a\xa3\x04\xc0\xff\xc4,\x92\x16\xf2\xeb\xbf^\xbb\xbe\xa4\xe4\xf9\xe8\xbfS\xe5\x06\xc1\xfb\xae\xff\xbf\x07\x0c\x95$\xf5y\xd3\xbf\x8a(Z\x9e\xe7\xd9\xef?ju]:\x9e\xbc\x02\xc0\x89\r\x07z!\xe8\xc2?\xc2\xb1\xee\x91\x85\xc0\xfa?\xe8\xb8>\xd5J\xa5\x00@\xbebM\xbbM\x89\xa3\xbf\x12\xa97\x86\xd0E\xfe?O\xdb]\x0e\xfc\xfd\xe7\xbf\xc51\xad-\xb3\x0c\xf4?\x8f\x1b\xc31/\x9c\xfc?P3\xa0\xae?{\xc0\xbf\'\x1d\xe5\xd8r\xfe\xf1?\x13\xaa\xd4\x0bu\x1c\xc7\xbf\x90\x8a.3\r\xc1\xf8?\x8c0$\\\x0e\x1f\xf1?\xcc\xd7\\>\xdb\x9d\xe0\xbf\xf7\xf0\xfe\xd3O\x86\xec\xbf\x0c\xbd\xf7\xcbQ\'\xe7\xbf\x91\xd1\xd6\xc9\xc0\xc2\xdd?3\xaei7\x8ct\xcb?T\xf6x>s \xe9\xbf\xff\x8c\xa7Ff+\xd9?\xd4\x86\x11\xa6\xb2\xe5\xc6\xbf\xf5\x1d#\xecf\xa5\xd2?]\x88\xbbC\t\x0b\xf5?*\xa8\xa8\x83#f\xd8?\x9f\xd6\xa6\x07b7\xf2?M\xe6\xf6]~\xf5\xf0?r\x8eZ\x8e^l\xb5?\xd60|\xe8w\xb5\x03@\xcd/\x1d\xef\x88u\x12@\xa0\xc8\x9a\xab\xeey\r@\xeaA\x00m\x174\xfc?\xddy)\xde\x01\x88\x06@\xcb\xea\x97y\x0c\\\xf3?3\x9fb\xb9Q\x98\r@\xb4\xe1\x8e\xdfp\x10\xf2?\xd3\xcem\x96k\x83\xf9?\xdf\xce\xa9\x8c\x1a[\xd3\xbfj\x1b(\xb9\x81B\xfe?[Q\xfd\xe3_q\xe0\xbfrh\x07\x9a\xef\x08\xe2\xbf\x9f_\xa9\xdf\xb7\xeb\xd9\xbfls\x9f\x13.d\x02\xc0\xc5\xd3\x1d9\xc5E\xfe\xbf\xc7\x86\xa0\x90\xfe\xbb\xad\xbf\x15\x13\x12\xe5N\x96\xf3\xbf\x81g\xcb@\x0f\xd5\xdc?\xe9\xf1R\xa4i\xee\xf4?\x1c\x99\xbc\xc6\xc9\xd4\xeb?\xf76\xb2\x9c\x1d\x07\xd8\xbf6\xb7\x06\xf90\xb0\x03@0+\tz\r\xfa\xf0?\x81\x8a\xbc\x1b,\x89\x06@\xc4\x8e\xf7\xef\x0f\x02\x0b@\x9bF\xf4g\xf3N\x01@~\x91\xac\xbb\xf4r\x05@.KO$u}\xfc?\xdc\xa4\x06\xd7y\xe6\xef?\xf6=\xe5\xe8~\xfe\xef?\x1b\xa8\x12DG\xdd\xe1?\xa0\xc0\xe2*\xe5Y\xd9?\x9f\x11\xb7f\x86s\xf2?\xb9\xa6\xcd\xe8[\xf1\xa0\xbf\x8bj\x1bI+\x87\xd3\xbf\x1duR\x11CZ\xfe?n\xa7\xaa\xbc\x91\xae\xfe?\x87\x91X}j\x8b\xfa\xbf\x02C@\xc9)U\xe6\xbf\x12\xd9,\x94[l\xdb?\xc3\xeb\xebC\x83}\xdb?p|\xe1\xed|\x85\xe5\xbfz\x90\x15[\x9e\xe2\xe9\xbf\xabbu2\xc4A\xd6\xbf\xef\xa2\x97\xbbi\x93\xfe?D\xc6#\x88|x\xd1?\xbbD+y=\xef\xee?\xe9b4\xe7\x84M\xff?\xbf\xe5\xd9\xca\xe5\xf5\xe5?"R\xd8\x04c\xe2\xe0\xbf\xed|3L~I\xd7\xbf"^\xca\xaf\xf9\x8a\xea?\xb9D)\xbf\xbf\x8e\xf3?\x8c\xd3\x8f\xad_+\xf0\xbf]Uk\x01\x80\x8f\xd7?b\xc0T \xd2I\x02@x\x07\x82\xe8\xb6\xbe\xe6?\xa9D\xa5r\xf8\xad\xc4\xbf\x8ft\x10\xed\xbd\\\xd5\xbf\xb1\xfd\xa0}3\xe8\xe4?\x16{\xec\r/\x89\xe8\xbff\x0c\x8c\x13\xa1\xb2\xf0\xbf\xc19NH\x18\xf2\xd7\xbff\x0fh\x19\x04q\xf6?\x1b\x07\x8eu\x19\x8c\xd1?8\x98Sc\xea\x07\xf0\xbfZ\xca,\xea\xad\x84\xdd?kT]2\xa0\xc0\t\xc0Q\xd97/\xf5&\xf1?1{\xb0.\\\x96\xf3?\xa4\xa0\xa2\xba\xdf|\xd3\xbf\x85o\xce\xd7\x11\xb5\xfb\xbf\x12\xfc\xd4-|a\xec?\xdb#!\xec\x11\x96\xf1?\x03/Mi\xa4#\xdd?\xcc\xf8c~\x7f\x8e\xd1\xbfj\xa9bI\x99|\xec\xbf\xb6\xc6:B3A\xd7?\xa4\x17\xfc\xcc\xc2\x18\xec\xbf\xb4+\xe6\x1f\xec\xd6\xe9\xbf.\xe2%\x9e.q\xf6\xbfm\xa8\xf9\x08Bf\xf2\xbf\x14@\xb8\xe9\x7fi\xb1?\xbe<2\x18\xd5\xdf\x0c\xc0\xa1\x16\xff\xaa\xdd\xf8\xda?\x8d1U\xd9@\xb9\xea\xbf\xd8\xf1\x07\xe4\x139\xf2\xbf\xe3\xe6d\xde\x94\xf3\xe9\xbf\xc1M\xbc\xc0\xb1G\xf7?\xf0\xca\xd3f\x9c\xab\xd8\xbf\xa9\xec\xf03\x8d\xb7\xe6?`\xc4\xc5E\x91n\xe8\xbf\x95\xf7\xba-~\xf9\xec\xbfs\xcat\x05/S\xd5?\x9fM\xec\xbd\xa2\x80\xf8\xbfh\rS\x86_T\xea?\xf3LP8\xa5\xc8\xf0\xbf\xba\x07>\xdb\xf04\xd2\xbffFHx$-\xe8\xbf\xc4\xa4\xe5\xab\x1d2\xee?#\x88\x8c\xf2\n\x1e\xe7\xbft\xb9\xd1F\x83^\xd3\xbf\xcaX\x88,\x897\xeb?9\xdf\xe4\xcf\x0e\xc9\x04\xc0\xad\xbe7\xb2\x84\x80\xc2?\xec\x97^g8\xf9\xf6?\x84\x90bf\x8cG\xe0\xbfL\xcc\x18\x97\xc69\xf4?\xaa=\xfeq\xcc\xe9\xf0?j\xd0\x8a\xbc\x86\x89\xc4\xbf\xf2\xb9\x18\x1a\x7f\x1f\xd6?h=\xa3\xca$z\xe3\xbf\xe7\x89\x9a\xe6\x9fu\xf2\xbf\xd3\xa0\x18\xfb\x95\xc7\xe8\xbff[&>oc\xf3?\x04Ym\xc0\\\xe0\xf5\xbfD~I\xa5\xd8\x1c\xdb?\xa7j\xf1\x19$\x9e\xf7?I"\xf5\xc2\xac\x12\xc7?\x88*\xa4\x07SU\xe6\xbfV\x9c\xd3[;o\xd3?\xb4V\xafO9f\xe1?\x8b\xb9\xd5\xad\x9a@\xf0?\x9a$\xad\xa5\x92\x9c\xfb\xbf5\xbe\xcb\xf7\x95\x84\x01\xc0\x8a\xa7a\xce\x02.\xdb\xbf\xdb2Mwd\xc6\xf7?\x87\xed\xe5))|\xe8?\x95\x19\xe7\xb6\xbf$\xef\xbf\xc5\xcf\xc2\x17?\x18\xd9\xbf\xd4\t\x16\xc8N\x7f\xd6?\x9d\xa4\x05O\x05\xfd\xf4\xbf\xde\xf58VE\xe1\xf9?D\xa1\x19\xb4O\xa4\x02\xc0\x95&3\x97h\xca\xf3\xbf\xc3.\x13~\xaa\xef\xc0?\x01\xecU\x9f-\xb9\xf1?\x1d\xb1*\xdc\x024\xf1?\x84\xf9\xed4\x83N\xf2\xbf\x8b\xfd\xf9\xfbw\x06\xbd?\x951,\x16\xb8\x94\xea\xbf\xe04\xd7JY\xe0\xcf\xbf\xb6\x18\xef\x92\x0c\xdd\xfa\xbf\x804\xa1\xe13\x02\xe1\xbf|\xc8\x02\xf0\x8e{\xe7\xbf\x82\xb7\xcd\xf9G\xf6\xfa\xbfnu\x99Mb\x7f\x03\xc0\x1a\x07\xca\x01\xe9"\xc1\xbf\xd3\xb94\xd5\xe9\x14\xf4?.\xf8\'qT\x7f\xe4\xbf+\x8aKf~\x92\xfa\xbf\xca\xdd=\xd7h\xe9\xc1\xbf\x14!\x13\xdf\xe9\x80\xf1?E\xed\x92~\xdf\xb1\xec\xbf(\x12\xfe\x16M\x82\xd0\xbf\x15q\xc0xY\x83\xd3?\x93y\xd4\xda\xfa!\xdf\xbf\xfa\xe7\x16#\xc4\xc5\xf2\xbf\x05\x1b\x1cx\x8c\xa8\xd8?\xdce?\xb1\xbfe\xc7?\x90\x18\x88z;\xce\xf3\xbf/\xd7\xd38\xdf\xd5\xf3\xbf\xef\x90_\x19*\xb2\xe3?\x10\x82R1\xd9\x1e\xaa\xbf\xde\xcb\xb7=\x11\x81\xe1?\xf36\xc1LP\x8f\xec?\xf3\x13\xf5\'\xd6\xb7\xd2\xbfx\x9c3H\xb3|\xcd?f\xd3\x82\x91\x90\xd3\xdb?\x89\xf2\xe4\x97B\xe0\xe7\xbf\xf2\x7f\xa9P\x13;\xea\xbf\x88\x1b\xe9z\xa6\xa4\xeb?}\xed\xf2D6\x99\xef?2\x84\x9e\xa5)\x9a\xd0\xbf\xf9U\xe8*\'2\xca\xbf\xf0\x0b\x87\x99\x01^\xf2\xbf\xfd?\x17\x14\xb7\x94\xf1\xbfs\x18mU\x01-\xca\xbf\xd3\x8f}\r\x96\xb9\xda\xbf\x07\xf3\x13P\x8c\xf8\xef\xbf\xff\x82\xe9O\x19|\xe7?{\xd1\xc1A\xea\xb2\xd7?\xb2\x1a\x9c\x0e\xbb3\xd4\xbfF\xb5\xffk4~\xe6?s\x16\'_\x10\xf4\xd8\xbf\xf4\xef\xfa\xfb\x83\xdb\xf0\xbf]zt:\x10\xfb\xe1\xbf\xd8\x9a\xc3\xd7\x93\xab\xd2?.\xe7\xc6zs\t\xe2?x\x86\xfbc\xf9\xd5\xef\xbf-\xae\xf4\xbe\xdf\x8d\xb1?\xb5\xd1\xf4\x1b\xc5\xfe\xcd\xbf\xa0\xa0\xd4CS\xa6\xe0\xbf\xe3J&\xee\xf9\xe8\xe2? ^\x8b`\xb7\xb6\xe1?\xa7\x8f\xaf~\xc2\xde\xe8?eCpeLL\xf0\xbf7\xe6\xb5\xc7Fo\xe5?\xdb\n.\xa7\x99s\xa0?\xb7u\x90\x19#\xb6\xf2\xbf\xbe$\xef;\xcf\xdd\xd9\xbfO_W\x9a\x0ft\xfc\xbf\x1cMc\xbf\xc1\x03\xd0\xbf\xc4L(\xf5\x16y\xa1?L\xd5\xd0\xa1\x1c\xa8\xc3?\x03\xab\xaf\xf5\xee}\xe9\xbf\xf9t\x1fF\x94\xd1\xf3\xbfZ\x1d\x08\xe3$\x9d\xe9\xbf\tp\x0b1\x16\x0c\xe5\xbf\x9e\xdf\x08%~\xcf\xd4?\'-S\xe5\xb0\xa9\xc1\xbf\xfet5\xf0\xe6\xc3\xe1?\xae\xa9\xae\xaa]\xb4\xc2?\xe1\xf6\xd1\xf5\xb4\xfb\xe9?\xf8\xa4\x91+fe\xd6\xbf_\xac\xd0)=\x91\xf0?\xaf\x88`\xa7-\xfa\xb7?9\x8c[`\x87\x17\xf1?8\xb3\xe2xCf\xe5?\xae\xed-3\'\x87\xd3\xbf\xed\r\xa4\xfc\xcd\x7f\xee\xbfNN4&\xd0\x99\xeb?\xdbod\xc0\x1dv\xea?\x1a\xba>\x88E\xac\xe1?_F\xa0v\x1f\x91\xd2?\xad\x08\x90\x02])\xeb?xMY\x8b\xfdp\xf5?\xc5b\xce5f\xb8\x8d?\\N\xc6\x1e\xa2`\xe4?\xdf\xfb7\x9f\xa6\xd2\xec?\x90\x91\x90|\xdeH\xde?L\xfd\xb5<\x10\xaf\x05\xc0d\xa0\x95\xd8pn\xc7\xbfD9\x16{\xccJ\xe7\xbf\x15N\xc9\xdb\xcaT\xee?\xf4!!\x82&V\xdf?8\xf6\x9e\xd5vB\xe9?\xbc*/\x12\xb2\x04\xff?\x1a\xc4\xe1\x81oI\xef\xbff\xe9\xbfC\xe2[\xe5?\x0f87\xc3\x9e\x06\xdc?\x1eV\xdd\x9e\x9d\xcd\xf1\xbf*5\x9f\xe4s\xa6\xc4\xbf\x82\xd8ez\x11\r\x9b?\xf6\xeaDmx*\xc7\xbf\xb0\xd6\xf8\xbfn0\xe6?\xde\xb5\xfe3\n\xc6\xe8\xbf\xb77Ll\xde\xa1\xbf?lW\x88\xf1p\x9a\xc0\xbf\xe2u\xbb\x9c\xe9\x9c\x99?"\xd9\x0e\xd2.)\xd9?K\xfb\xec\xfd\x9b\x1d\xc3\xbf\x91\x1e\xa0\xd9\xc7W\xe6?\xb8U\x0b"\xda"\xf8\xbf\xd6g\x12f|^\xed\xbf\x1b\x92\x8eW\x8fx\xe2?\xdbq\xbaes\xc4\xc6?\x13g\xdfP\x9c\\\xe9?|\x05_\xa2\xb9\x01\xf4?\xc5k\x91\xb8\xd3\xa4\xf3?\x99\x11\x84$\xff/\xc1\xbf\xf9\x02\xe2\xbe\xa3G\xe3\xbf\xae}\xce;\x8a\xb1\xd8?\xdc\x83\xf5\xfe\xaf\x9e\xd5\xbf\\n\xe4YRY\xe6?L1;[\xe8\xab\xda?\xa3I\x00\xcc\xc7\x05\xe0\xbf\x0c]\x03\xa8\x94\t\xed?\x11\x91Q\x15\x9b\xed\xe8\xbf\x1c\xde\x84,\xe4\xf4\xa6\xbf\xab\xb5\xcd\xd5\xf8\x80\xeb?\x92\x18\xfa\xf0\x87R\xf2?\xcf.4\xf4B|\xe2\xbf16\xa3\xfc\x96\xc4\xdd?\xf9A}\r\xa2\xa4\xf1?6s\xfb\xbf\x86\x84\xc1?L(\xb1\xecw\t\xe5\xbf\xb4\xc6]=Z\x1a\xf6?\xb6\xc4tY\xf8h\xe8?\xa0#\x9a\xcd\xdfd\xff\xbf\xa6\xf3\xb8z\x14\xd1\xf3?\xd77\xf9G\x19|\xf6\xbf\xb7\xce\x8d \xfe\x8c\x04\xc0\xa2\xd0zK\x87\xc8\xda\xbf\x02\xfb\x0fi!\x9f\xe4?\xb33[$\xbc2\xfb?\xb9\xd3\x1a%\xa1\x9d\xb4\xbfE9\r\x8aK\xa2\xff?q\xea\xde\x17\xc4g\xe7?&\xcd\xdb\x8f=\xa0\xc9?u\x0f\xa3\xd5\xd3\x0f\xed\xbf\xa2\x8c\x13~\xb9\xc3\x00\xc0k\xbd\xfcJ\x11\xa1\xe7?\xfd\xd5\xc3\xab\xd9J\xc8\xbf\x8e\x9f\x15\x17\x04\t\xe8? \xbd\xa6\x92\xaa+\xe9?)\xc4\x9a\n\r\xbe\xb5?\x1d\xdf\x8dl\xa7\xd2\xf2\xbf\x89\xf6x\x81\xa0\xd7\xd8?\xed4\xaf\xbf\xc9v\xfd?\x85t\xa1\x86y\xa5\xf3?\xf17\xfd\xd85%\xfe?\x10oJ\xb0\x0e\xe6\x00@\x1c\x9d\xab\xc1\xde\xc8\xee?\x98\x9d\x083\xb8\xb1\xe0?\x97A,H\xfb\xf1\x95?\x17\xdd\xdf\x11\x04\x12\xc3?\xa0\x14\xaetl\x06\xf4\xbfk@\x8bH\xecS\xea\xbf\x9f\x86M\xdb\x05\x02\xf6?\xc1\x08\xe2\x97=(\xf4\xbf5\xc4T=\xc3\xfc\xdf\xbf\x00\x87pk_\x02\xf6\xbfA\xd1n\xec\xfc\x98\xe3?\xb0a\xa3\x1b\xfb\xc9\x9d?\x97:\x03\x01P\x8e\xe0\xbf\x87!\xe7\xea|\xcd\xd9?\xb3\x84R\xaeE\x97\xf0?\xbe\x83\x0fp\xf7P\xe9?\xf1\xff{}\xfd\xf7\xed\xbfIC\x1a\x96\x98\xd5\xd2\xbf\xc7\xb86\xb2M\x8c\xdc\xbfz\xf4\xaeS\x14\x8a\xf3\xbf\x89\xf7c^\x88\x8e\xe3\xbf\x8c9Y\x9d\xdb\x9c\xf6\xbf?h\x1a\xd3\x06\xf1\xf0\xbf\xa4\xe7P@\x1b\xca\xd5\xbf\xa7\xb7a\xa0\xc9*\xe4\xbf\xc6:\xc6\x8d\tB\xe0\xbf\x0e\xfc\x88\x8d\xdat\x03\xc0\x93\xda\x1b\'\r\xc1\xf8\xbf\x8bi4\xb7*%\xb6\xbf\xb0\xc8\xf5Nxt\xf6\xbf\xef\x99_\x10\xe3-\xee?\'\xfe\xd7\x9b2\xe0\xcc?\xb7\x17\xb8\x87~\xb3\xf1?\x04\x00N\xed\x08\xd7\xd4?2\xa9\n\nvA\xef\xbf\x1e\x92\xeb\xeb\xe9\x95\xf5\xbfV\x1eQ+\x04\xc7\xd0?k*\xf7}\xb0\x12\xb7\xbf\xd1\xdc\x8b\xe2\xa1\xe8\xf1\xbf\xb57]\xc0#\x88\xf7\xbf\xd4\x9d\x1bo1\x88\xf4\xbfa\xe0\x17\x18nO\xdc\xbf\xe48Rx\x889\xe4?\x90l!\xd0\x04P\xa5?.E}\xceN\x05\xea\xbfN\xd7\x83F:;\xd0?\xef\x8f,\xd8\xf3p\x05@g\x1bql\xf8q\xea\xbf\x89K\xbd\x1c\xbe\xa6\xf5\xbf+\xba\x93+Pi\xe9\xbfk\xdf\xff\xd6\x82\xda\xdc\xbf\x99.\x80\x83\x0b_\xdd?\xa2p\xda\x9e\xc3\x86\xe5\xbf\x00\xb61\xaa\x1a\xc7\xc7\xbf\x12y\x9c\x19K\xdb\xed\xbf\xae8s\x04Q\x91\xe6\xbf\x05\xaeI\'\x94q\xf6\xbf^\x10\xe5#\xf61\xf2\xbf\x80\x18ni\xba\xef\xe7\xbf\x81\x8fe\xb7\x01<\xf5\xbf2\x13P\x82\xe9\xcc\xee\xbfe\x8f\x15DB8\xfe\xbf\xda3\x03\xeaqG\x01\xc0\x94Io>o\x9a\x03\xc0psM\xb1\x83\n\xfa\xbf{;\x1f 00\xe7\xbf\xef\xa2QV\xac\xb0\xb2\xbf\r\x8c\t\x0eU\xc7\xfd\xbf\n\xcf\x8e\xbf\xbc\xf4\xe1\xbf\xca\xb1/\xc06=\xf2?\xf0]Q\x81"\xda\xd3\xbfh\xa3\x13j\xdb\xf1\xe2\xbf\x1eb\x19\x9e<\xac\xe9?@\xf5y\xb1\x99\xb4\xf9?\x9e\x13i\x17\xd5\x8f\xe0\xbf\xc7a\x06\xc8\x8f\xec\x00\xc0\xff\x03\xaa\xb2\x1a\xed\xfb\xbf\xd4J\xbfu!\xa0\x06\xc0\t\xc89l@R\xfc\xbf"\x9b\x9b\x0f4\x19\xdd\xbfq4"\n\xccW\xe5\xbf\x9d\xda\xf1\xd9\x13\xcd\x03\xc0O\x1a\xa0\x11\xd6\x06\xaa\xbf\x1a\xb2\x02\xec\tE\xfb\xbf\xea=\xa1\xaf;t\xe0\xbf\x83<\xb7\xa0\xa3\xf3\xee?m+\xf4\xd3\x0b\x86\xec\xbfd\xe5ij\xbb\xf6\xe9\xbf\xb3cz\xdd\xfbU\x06\xc0\xcd\x1b\xec#\xfaM\xfa?\xb5l\xb5\xd8\xe7>\xe8\xbf\xb3/\x96\xb0\xc8S\xff\xbf\x81)\x06\x14\x945\xf1\xbfE\n\xbe\xb5\xd5\xdc\xd7\xbf\xd1\xcb\x8b\x06(\t\xf6\xbf\xc4\nVP\xe2\x9a\x04\xc0ve\x1f\x10\x85\t\x03\xc0\xbb\x129\x89\xac\x9c\xf0\xbfG&\xdfV$F\xae?\x9c\x04\x93\xb4\xd8m\xdb?\x15N\x88\xf9y\x0c\xf2?\xb283\x89Vv\xf4\xbfN\xdbC\x9a}\xd9\xf7\xbfi-\xe5\xf0\x0b\xd9\xe9?\x7f}\xe1\xe3\x9f\xa5\x05\xc0v\xb0\xb9\x9e\xf1\xad\xcd?M\xb8\x17\xd1B9\xbf\xbf\x94\x9a\xed\xd8\xb2\xed\x04\xc0\x7f6m\xdaYd\x0c\xc0\x05\x0b\xeb\xf4\x85\x99\xe0\xbf\xdd\xe1\xea?\x1d\x85\xe9?\xa8\x16\xd2\xe9\xfcQ\xfa?\xebB|\x8e}\xa1\xeb\xbfup\xfd\xabl\x05\xa9\xbf\x12\x98\xdf\x9c\xd4\xb3\xe8\xbf,\xc5\xd3\x15\xb0\xad\xf5?\x1f\xac\xbeH\xa8\xc6\x02\xc0\xfcJ\x81T~\x01\xf4\xbf\xf0&\x91\x8e\xa5\xd4\x01\xc0\r\x83\x9aP\x08\xed\xfc\xbf\xb4\x15#\xae\x99\xa8\xf7\xbf\x10\xa5\xd4\xeb{\x0f\x07\xc0j\xc0\xc4=\xc1e\xfe\xbfe\xccO\x19\xef\xb9\x00\xc0\'\xbb|r\xf7\xfd\x05\xc0\xc6\x16<\x93e:\x07\xc0\xf1\xbc\xfc\xa5\xea\xc3\xb4?\xe6\xbaU1\xeb\x95\xdf\xbf\x99w\xa4\x0eC\xf0\xfe?\x96\x06\xfc\n\x9d\x00\x07\xc0\xb0I`\xb1\xafq\xe9?&q\xb6\xa1y*\xb1?\x9cf\x0b\xf2\xfd\x07\xea?]|\xdd\xb3\x1f5\xce?d}\xa1\x8a\x94s\xa7?\xd3U\xc6#\xb4\x15\xf6?\x93\t\x02\x87\xf5\x11\xce?\xdcI\x18\xee\x17\xca\xe1?wK\nv\xb7\xf8\xe0\xbf\xb2\xfb\x96\xd2\xc5\x86\xd9\xbf\x83\xc7\x8d\xe57\x80\x0b\xc0\x87X\xd4\x04\x18\xea\n\xc0\xc7\xdb\xfbz\n\x89\xd3?\xbe!\xf5\x9c\\\xc4\x08\xc0\xb6\x11b~M\xf3\x02\xc0Z6c\x10\n\x0e\xed\xbf\x0c\xbc\x18\xea\x8c+\x02\xc0\x1b\x06\x06$H\xed\xfa\xbf\xfc\x80\xe8\xf1v\x8a\xe3\xbf\xbd\x92\xf0\xe3\x89}\xf1\xbfm\x94CQs\x98\xf7\xbf(\\2o\xcb\xfb\x00\xc0W\x93\t\xe1\xc0\x1e\xfd\xbf\xe2&f\xd7*q\xec\xbfW\xabl\x84\xd8\xc9\xb7\xbf\xd2\x95{*\x1c\xef\xc2\xbf\xb82\xaf\x12\xefC\xe3?\xe4\xfe\x10?\x93\x03\xfb\xbf\t\xe3xWJ\x8e\xec?w\xf6\x8az\xa0\xd9\x00\xc0\xaf\xf2\x9b\xe3N\x18\xd0?Z\xce%\x98\x98\xd0\xcf?\x92Z&\xc5\xd1y\xe7?\xf8\xbf\x96\xc7\xfb\xde\xf5?9\x18\x9c\r\x07\xc7\xe5\xbf\xf7\xbb0a\x90\xc5\xf6\xbf\xbf\x9c\xdd\x84\x1c|\xcc?0\xe7OI\x9et\x08\xc00Db%\x1d\xe3\n\xc05\xf8\xc1\xeb\x87\xb0\x13\xc0\'\xa9\x19\x8f\xdd\xf3\x0e\xc08:\xea\xbd_\xc6\x12\xc0\x9f\xd2p1}\x0f\x10\xc0\x8c\x8cI2\x8bQ\x02\xc0\x04y\xa7,\x12f\xfe\xbf\xc8\xac\xeb4Z\xf3\xde?\xa1\x0cn\x13x\xb7\xd5\xbf\x9eX\xf0k\xb4\xfe\xd6?&\x15\xcf\xd8\x96J\xd1\xbf\x19\x9a\xbf\xab\x94\x08\xe8? \x06g\xff\x91w\xe2\xbfK\xe6fm\xb7#\xfe\xbf\x99=\xe1)\xae\xaf\xe1\xbfC(\x13\xdc\xdaB\xbc?\xd4\xe8QXY\x95\xbb?\xd1\x89\x03\xf1\x89{\x00\xc0\xa6\x9c\x0b\xd5\xf1\xd4\xd6?\xa9\x95)\xbf\x86\x8e\xd3\xbf\x15\xdc\xcd?L.\x9a\x10\xa9\x8e\xbb\xbfex[\xf6\xb9g\xfb?NET\x82U\x8e\xfa\xbf\xe8>\xdd\x94\xbf!\xf1\xbf\x1d\xe8\xb0H\x95\xf5\xf1\xbft\xc9\xbc\x1a \xa5\xf9\xbf\x19\xd3\xd9\xad\rd\x03\xc0\xac\xc3\xb5+\xc7B\x07\xc0;\xa8p\xfc\x85\x1a\x13\xc0\x18G*\x04\x88\\\x0e\xc0&\x95\x07D\x078\x01\xc0,\x10\x1c(A\xd1\x07\xc0x\x85\x89y\x10\xbf\x0b\xc0\xba:\xd0\xbcJ\x1e\xff\xbf%\x18\x0eo\xb3\xae\xea?\xfd1\x8aHtS\x01\xc0x6\xee\x12a\xa1\xdf?\xb8F\x0e\xa1\x80\xee\xd5\xbf\x8a\xe0\x9b\x1eT\x0e\xe6?\x8c\xb0\xc2]\xdet\xf5\xbf~\xc2\xb9\x9cj\xce\x05@\x06\xe4\xb6\x93kh\xed?N-\xc4\xdb\xefO\xf1\xbf\x0b)|\xf6\x83\xcf\xfa\xbf\x19\x05A\xb0[t\xff?\xae1\x828\x93|\xa2?:O\x99\xff\xc7\xfd\xe2?\x19;\x1aD2k\xf7\xbf*\x95)\xb7\xd7G\xe6\xbf\xb6\x81\xa5U\x8f"\xf5?/=S\x08@]\xf4?\xa4\xd5\xec\xc4\x98;\xec\xbf\r\xd9m\xec\xff\xbe\x03\xc0\xf8\xad\xa1\xb7\x9c~\xf1\xbf\x88\x8c\x97\xc6~\xd1\xd5\xbf]\xf5\x11\x033\x9d\xee?!\xba\x91@\x8e\xe4\xec?q\x88\x96B\x155\xed?J D\x98\xb4\x14\xee?\xd8\x158\xfaa\x89\xf0\xbf\xad\xf5^\x8cL\x05\xe1\xbf%G\xfd\xdf\x94\xaf\x02\xc0]\x9fb\xa8\xafr\xe4\xbfV\x18>\\0\x00\xf1\xbf\xfb\xce\xd7\x85\xab\x86\xe2?~\xf5\x1aueU\xfa?\xeb%Qs\xa3\x8c\xf2?\xd0\x85\x8aj\xc4\xb6\t@\x14Q\xf6\xed\x8c\xc9\xe4\xbf8Pj\xce\xa1{\xf9?\xfbHeA\xa2\x16\xf2?#k\x95\xb4z!\x93?2\xa7*/^-\xe1?\xdb\xa6J\xa4f\xf5\xf0\xbf\xfaW\xb6\x93\x83\\\xf9\xbfI\x9b2B\xec\xfe\xc0\xbf\x89\x1b\xac\x8dN\xd2\xf6?\xc9\xb4\xed\x90\x8cC\x03@&\xc9\x18\xe4w\xda\xdc?\xb6&\x00\xfb\xcdB\xf4?2\xd2 \x16\x9a\xc7\xd0?b\xf2\x01>\xedV\xef?5\x94\xf3;w\x03\xe1?s\'_G\xb0_\xd2?\xcd\xc5\xc9V\x1f\xef\xb8\xbf\r\r5H\x99\xe3\xca?\xcc\x1d\x17pt\xba\xf5\xbf\x10.>+\xaa\xb7\xe4?\xcc\xe8r\xdd\xde\x84\xa6?\xbb\xb4)_J<\xe3\xbf]\xb2\xaad\x8c1\xe1\xbf\x0e\xe9\xc8:p\xa9\xc0\xbf\xf0B\x9c\xa6\xc6\xda\xf4\xbf+\x1awY\xa6\xc6\xc0\xbf35o\xb5\xc4\x8b\xf3?8\xfd\xbf\x01n.\xfd?p\xfd\x1eA\x14\xff\xfd?lov\xbb\x89\\\xf3\xbf\xea\x96\x93\xd6-O\xef?\xe2\xb4\xc2\xbc0\xc6\xe0?\x13B1ns\x86\x07\xc0k\xe0\xb5\xe2!\xe6\xf4\xbfS\xc7\\fe\x03\xdb\xbf)\xcd\xea6\xa6\x8c\xb0\xbfe ]\xa8\xf9]\xed?\x03\x8f=\x81\xcc\x08\x00@\xbd\x9a\x8e\x85\xe3\x16\xf5?CU\x1f\xaeL\xcc\x00@\xa4Y\x99\xda8\x1b\xce?\xdf@\xab\xb5\x90\xa2\x00@\x11\xad\x82\xeb\x98\x11\xc4?\xa7\x91\xb4\x99#\xda\xe1?F\xc7\xd4CWy\xd1?\x96\x01Z\xdav\xef\xf3\xbf\xf6\x0b~\x8e|\x16\xd7\xbf\xa4<_v\x0f\xde\xf6?\x9a\xc0\xd0\xa9\x81g\xc4?\xdft\x82j\xec\x8c\xff\xbf\x1bT\x14\xf4\x83P\xf0\xbf\xa8\xc6\xd1\xa7\xf8\xdb\xe4\xbfL\x8a\x93=\xa6\x8c\xf3\xbf\xda\x97cr/\x14\x05\xc0\xfb\x8cA\x19\xb5\x06\xc9\xbfZ\xb7\x12\x1e\x1b\x8f\xef?\x93\xf3pC9\x02\xf8?\x82o\xde\x1b\x0b5\xee\xbfT=\xf5\xbd\xea\x9f\xe9\xbf>R\xf7\xf8\x83^\xc4\xbf\xe6\xcd\t\xc6o\xbd\xe9?\xd0\xeb@Cf\xb1\xc3\xbf,\t+\x0fPV\xd1?\xa0\xf6\xdcarg\xe6?\x14^{\xe7\xb47\xe4?2\xfe&,\xed|\x05@\x13\x8d\x95\x9d\xf42\xd1?\xa5\xb3\xa2\x18\x10\xe7\xb6\xbf\xcd:\x0b\xba\xe6\xc6\xf3?\xb4\x95\xf7\xc4\xf64\x12@\xcb\x0f\xd8\xe94\xa4\xf4?\xfa\x8dN\xef\xf9V\xf4?{\x89M"\x81\xf1\x04@\x90\x13\xa9D\xeb\x9a\xf4\xbfj\xddf\x822\x89\xe2\xbfv\xd3N\xfb\x93K\xff?o\x8d\xf0?\'b~\x9a$\xf9\xda?\xaf^\xa3\xa7\x92\xa4\xe9\xbfyu\r\xf6\xba\xfe\xf5\xbf\x84\xb3\xce\x99\x917\xd7\xbf\xad\x00jZ\xd3\xfd\xf1\xbf\x1f\xd8u\n\x9b\x8e\xde\xbf\x16[Pp\x12n\n\xc0\x91>\x05\xca)<\xe3\xbf\xfd\x90\xaa\x14\xb1,\x86\xbf\xbaF\xd3\x9d\xd3 \x05@\xf0\x7f|)G\xd7\xfb?\xbd\x99T\xb6\x9aH\x02@<\xca\xfe\xa1\xc4`\x08@\xb5\xc1LoQ\xbd\x0c@\xd5\xaa\x03\xc9^\x98\xe2?#J\xae7UK\x0c@\x88\xa6\xbd\x82\x1a\xcf\xe3?\xd1"\x01\xa6\x03S\n@\xc5\xac\xca\x84 \xcb\xe0?\xb8\x9eby\x00\x96\x00@\x01\xc7\x9aS\xac\xec\xf1?V\x93\x108z\x0e\xef?\x92\x0c\xad\xfda-\xf8?\xaa\x8aB_|I\x07@\x9a\x1ed\xba-\xe7\x0b@\xe8\x8e\x93p\x08B\r@\x03\x99?\x0e\xca\xbb\xb9\xbf]Kb#`Q\x8e?\x04S\xf3\x88\xdd{\xce?\x98\xdb\x1a-\x98\xeb\xd5\xbfvRK\x94\x11\xa5\xd0\xbf8\xc4\x07\xf8\xfa0\xea\xbf\xf7s\r\xd1\x93\xaa\xe2\xbf5IW\xe3-A\xe6?\xe8\xdd\t\x02\x8f\xaf\xe4?\x19\x01\xa77\x03\x14\x03\xc0w=\xa5y\xdf\x99\xd6?)>]\xfeD=\x01@~\xed\xaf,\x1e|\xeb?=I\xb6C\x8d\x9f\xa3?\r\x92\x8e\xa0\x10\x92\x04@\x7f\x9dK\xea\n\xd0\xe5?M2\xf0x\xfa\x08\xf1?\xcaam\xce/)\xc7?7\x9b0\x00\x08\x8b\xfc?-\xf1>\x06\xad\xe6\xfc?\xd5\x1cw\xb8\x91X\xd7?v+S\t<:\xec?u\x06\x9d\xaeb"\xfb?\x94\xcc\x7f\x92\x13\x0f\x01@p\x87\xc3\xa0\xaa\x83\xe3?\xc4m\x02<~0\x0e@q4\r\xf1\x1ex\n@(?\xd3\x98\x1e{\x02@\x9b\xa8\x01\x05\x8c\xdd\xd2?\xce\xa1\n\xb7HG\xb2\xbf\xeb\'\x14!\xc5\xb4\xf5?I.\xd0\xa7\xad\x8e\xfd?\x85h\xf2\xa9p\x19\xe1\xbf-)\xc0f\xa7\x81\xe3?\t\xb3f\xc28\x90\xe2?\x18\xaf\x0c[i\x14\xf1?u\x90I\xca|/\x05@(QV\x88+\xb0\x9f?\x19Zp\x96b$\xe0?Z\xa1\xcf\x81\xca\xeb\xc5?=\xe9\x06\xfd:\xb9\xd3?.\xa3\x13\xa3\xa0\xb9\xf7?\xdb?[\xb4\xd21\xe2\xbf2\xb6\xd2\xf6m.\xd7\xbf\\lu\xd9ab\xcf?\xf6j_&\x8bm\xf1?+\xe1\x11\xd9\x82\x1c\xd9\xbf\xaa\x8d\xec\x87?\xe1\xef?V{\x97,\xa5\x08\xf2?\x00\xb3\x1eun:\n@\xa2\x9de\xe6\x8e\xf8\x05@\xfb53\xaa\x00f\xf3?\xecYT\xe4\x0b\xc1\x03@\x05#1/\x13,\x08@\xad\xba9\xba\x98#\x0b@r\xc9b\xc8h\xc0\xff?s\xd5\xdb\xc6\\\xe4\xf7?\x88\xa94a\\\x98\xc2?\xe8m+\x95\xba\xfe\x95?\xab\x1f\x9f]\xf7\x1a\xf4\xbf\x9c\xc6\x8a\xae\xec\xfc\xda\xbf\xef\xf6\x99Q\x16\x0c\xf2?\xeb\t\x02\x89\xd6\xd2\x02@>\xb7\xd2@E\xf3\xe5\xbf\xb6\x91\xc5{\x9dn\xe7?\xf3\rO\xe5\xe8\x0c\xee\xbf\x0bA\x93H\xb3\xd8\xe1\xbf\x8bikg\x89\xdf\xcd\xbf\xf2\xd2\xf0\xa4\x93\t\xdb\xbf\x00\x9b\x15/\xd8\xb7\xcd\xbf\x0b\x93\x07\xa3\xe2\x80\xe8\xbfY\xb4!\xb3\xec\x8e\xc3\xbf\x8f\xcd\xc6A\x02\x85\xd4\xbf\xd6\xc3\xd00\xf1\xb1\xf0\xbf\xc0_,\xaaR\xff\xf8\xbf\x15\xcf\xcc\x93J\xb5\xe9\xbf\xd4k\x8b\x84\xfb\xfc\xdb\xbf\x06\x1c\x8eN}\xd1\xfe\xbf\x1c\xad\xfbh\xb2x\x0b@wi\xc2\xc3\x9c\x16\xfc?\x0czB\xa1\xea@\x08@iJ@\xd1\x8ch\x0f@\x16$\xb5>\n\xaf\xd3\xbf\xc8\xebSm\x91:\xbc\xbf\x84\xe7\x89u\xb0\xa8\xf1?\x05O\x1d\xf5\x1c\x0e\xf3?\xb9\x193y\x04y\xe7?\x99\x83\xc4\xd1\x17\x04\xa6\xbf\xb6\xdf\x89\xfe\x14R\xdb\xbf\xb5\xdd\xe3O\xa0\xbd\xa5\xbf\xea\xc3\xa0\xa3\x81\x18\xf8\xbf\xdbqK`\xd0\x04\xe5?\xf4}P\xc6\x18\xbe\xf7?\xb7\xdf[I8y\xf3\xbf\xb2\xa3`\xea\xc0{\x04\xc0\xd4z\x98\xeex\xce\xef\xbf"\xa6\xd3\xf7"A\xe7\xbf\xafd\xe4\xbbD\x89\xd2\xbf\x00\xa4\xec\xdeFf\xe5\xbfs3<\xbd\x1bB\x02\xc0\x97=k \x05=\x06\xc0\xc6\x91\xe5FE\xbc\xe7\xbfo\xaa_\xc0\xb7\x8f\r\xc0\xc8\xccMA\xfd\xa6\n\xc0\xc0\\W\xbe\xfbe\x10\xc0\xfe\xc0-\x8f\x99,\xea\xbf\xd5\x86\x02\x05\xef\xa7\xf4\xbfP\x07\x81x=e\xf0?/\xd0\xe3\xc2\xe7\xbe\x00@\xf6\xc3\x17Q\xca\x1c\xf7?\xb4\x1a\xae\x05\xcf\xf0\xf1?\xd4\x9bd\x8f$\xe7\xe7?\xcfj\xaa#\xfb\xaa\xef\xbf\xc4\xe8\xcf\xe3\xf2\xc6\xee?\xd8?\x8c\x94fn\xb9?u} ;+\xdf\x07@\x8a\xfay\xf45\xed\x00@\xa7g\xb7\xf4\x917\xba\xbf\x02\xec\x8a\x99\xa2\xac\xf3\xbf\xdc\x80\xae\x9cb%\xfb?vRE\xb5\x1a\x08p\xbf\x8b\xfc\xab\x18\xb7\x83\xf7\xbf?\xd9wG8\xf2\x00\xc0\xc1\x1eu\xc7n;\x00\xc0\xecX4\xc4\x1b\xbd\x02\xc0\x05\xd6\x97\xdc\x98\xb8\x0b\xc0\xecg\x19\xe9Q\x18\x01\xc0\xd5\xf1o\x96"\xb8\x04\xc0R\xb5W\x91g\xc8\x14\xc0\xa3\xd4\xd1\xd3\xdc\xc7\x06\xc0\xd4d\x91\xaai\x10\x05\xc0\x88k^F#P\x0e\xc0S\x8aI]\x0ea\x0f\xc0\xd3\x0c\xad\xa1\xc6y\x01\xc0\xeeW\xdd\xf4\xb8h\xf7\xbf\xeb\x84\xedX\xee}\xdd?wO\xdd\xd0\xc7\xb4\xeb\xbf\x80\xbdO\xdd \x9c\xf9\xbfj\x1e\xfd\xea[%\xf7\xbf\x16K\x9d\xff\t\xfb\xd1?04\x86\xef\'0\xf9?\xf8\xbe*\x07\n\x10\xca?\x8d\x1fc\xf4\xd4K\xfd\xbf\xea\xaf+\xfb"\xc1\xf1?\xe8N/W|v\xfd\xbf\x04(m\x90f\x9d\x02\xc0U\xa0\x02\xc9\xe7\xb6\xb3?\x8f\x9d\xd4\t*I\xf9\xbf\xeb\xc2)\xac\xb7{\xb5?\xd1\xdb\xc9\xe9cj\xf0?\xa9\xf0m\xc4\xb7\x0e\xe6\xbf\x98\xbd\x9a#\x89\x84\xfb\xbf\xb2x\x0b\xc0\x9f1\x08\xc0a9\xc0\xef\xf7\x18\xf0\xbf\xad\x04\xb1T\xa4!\xa1?q\x8a\x06\x9a\xee\xd6\x04\xc01X\x9b\xa7\xe5>\xf0?\x16G\xf2\xd7\x04\xa2\x01\xc0aX\x91|]V\xd7\xbf\x1d\xcb\xd6\xebzx\xac\xbf0\xe3\xf4\x0b\xf15\x93?\xfdE\x95\x06]\x1d\xf5\xbf\xdbh\tw\xe9\x96\n\xc0-T\xf2,3B\xce?-\xbb\xd5\x19e,\xe9?\xed)\xd5X\xef\xbd\xd5\xbf\xac{ \xc5h\xbb\xec?0E\x80f\xc7\x0f\xf0\xbf\xd38\xd9.D\xca\xd3\xbf\x0b\xd8\xc9\xf8]\xea\xc7\xbfz\xf1m8\xdd\r\xf5?\xdb\x82Q\x98^\x1c\xef?+\xb7D~i\xba\xe1?\x89\x8f\xcb{l\t\xea\xbf\xa1\xbfP.=\xbf\xf2\xbf#fE\xd4\xc15\xe5\xbf\xd8\xfb\x80\xa2e\xf4\xca?\xfe\xb6V\xf3\x1a\x16\xd6?V\x8a\x14\xccmQ\xf3\xbfu\xe6N;\x1d\xf1\xdc?\xa5+\xd3K\xcb\n\xe6?\x0e\x89m\xfcu\xba\xd2?\xd3\xecW$\x95;\xe2?\xcbb8\x05\x15\xa6\xea\xbf?\xf6\xc1y\xb8\xf1\xdd?5ch\x0c\x08\xac\xe2\xbf\x85\xd1\xcf\xcd\xa2\xc8\x01\xc0E\x9d\xf7\x90X\xed\xe4\xbf\xf0H\xa2*ux\xaf\xbf\xaf\xae\xf7n\x1f\x9b\xe3\xbf\xc6\x87\xdb\xeb\xe4c\xf0?f\x92<\x95\x06\x05\xc9\xbf\x0fJ\xa7>4\xc4\xe4\xbfo\xc9\x9e\xc6h\xbd\xa6\xbfK:\x99\x17\x00C\xdc?4\xb9D\xee\x8e{\xe6?B\x99b\x85\x9d\xd1\xcc?\x1a\x83\xd9\xd2\x82=\xc2?\xf0\xf6\x14\x9a\xe8\x14\xef\xbfJ\xdf\x9b\xb5\xf0\xce\xc6\xbfT"\xfa^\x19K\xf9?\xfdB\x05\xcb\xb6\xcb\xe5\xbf@B\x8d\xe1v/\xe0\xbf\xf8\x00#\xd8\x93\xe4\xe5?^\xe1\xa1\xb1\xe3;\xda?\xa3b\xe0I0h\xc6\xbf\x1a\x1c\x8b\xf5\xe4\\\xf5\xbf%\x9d0tor\xee\xbf\x07\xe7\xdc\xd7_\x84\xc5\xbf\xb4\xd5\xa4G\x85\x88\xf0\xbfk\xa2\xf3x\xf2l\xf5?\xbb\rG\xd0K\xa3\xec?r\xb3YM\r\xc3\xd3?mO\x87\x04\xb7\xe7\xf1\xbf\xc50\x1a\xf2\xcb\xc9\xe1\xbf\x8bL\x1b\xc1\xf5\x1c\xe5?\xef\xcdal\x18\x9e\xcb\xbf\x0b\xcf\xc5\xe5B8\xee\xbf\xb6\xd3\xc4\xc1%?\xee\xbf\x82\xafn\x10\xd0\xc8\xc2\xbf\xe2T\xdb\xeas\xec\xcd\xbf\xdb\xdcc\xbd\x01p\xdd\xbf.\x1b.\xe29o\xb7?\xa4\xf5u\x92\x15\xc6\xe5?\xa0\xec\x8b\xe2V\xc2\xf9\xbf\xae\x80:|\xc7&\xd8\xbf\x06\xdd\x86\x13%\x98\xee?\xcfK\xfe\xb1\xd9J\xda?\xc0\x87tq_\xc6\xe8\xbf\xe5J\xf4\xd1\x9cm\xeb?,\x13w\xa7,\xc6\xe4\xbfn\xa9\x91\xbe\x10\x90\xe1?\xf8\xcf\x95\xa7\\\x9a\xf0?B\xf3\xf0\x0eh\x92\xee?\xaa\x08\x12\x86\xdam\xde?\x982\x06\xdd\x8fg\xe7?\xb0\nFQ^\xf0\xd6\xbf<\xcb\xe6J\xd3\xe9\xb9?\x8d\xc8#\xbf\xaf\xbb\xdc\xbf\x89\x8d\x15&\xb8\x1a\xe5\xbf\xed~re@\xb6\xe8\xbf-\xc1\x82Lu\xb3\xef?#\x91\xdeN\xaf\x99\xdc?N\xdd\xef\xa6\xb8\x8f\xee?\xb2\xbe\xb8Z4\x90\x00\xc0C*{\x08\xd3\x8b\xec?\x18\xd7R#\x17\x8f\xf2?Kx.\x92\x87\x83\xfd\xbfI_\xeb\x9a\x06 \xd0?f\x987Gx\x83\xf0\xbf\xa2\x9bS(O\x8f\xb5?\x90\xbaB\x05\xdeT\x99\xbfI\n\xc6lF\x0b\xd0?\x8b\\\xe2\xe3dE\xf1?\xd5\xc8`*\xe7\x0e\xc3\xbf!!\x92D\xf7v\xf1\xbf$\xcbylM,\x05@\xe9\'\x9d\xc9\x81~\xe6\xbf\xdb\t\x1d\xb8(8\xe7?6\xdf\x82b\xa4"\x86?U\xf0b\xe0\x9c\x90\xeb\xbf\x13n\xba\xff\x12j\xeb?l*\x0f\x91\x11\xfe\x01@Sp`\x0f\x1eE\xf4?.\x05"\x94|\x8d\x01@`\xe2*\xda9C\x00\xc0x]\x0fG\xf5\xfd\xe3\xbf\xb1gO\xcc\xb1f\xfe\xbf=\x04\xcf]\x00_\xe1?-\xa4\x8b\x90%\x8b\xf4\xbf\xb5\xe32W\x85*\xc3\xbf\x81\x18X\x8b-\xda\xf7\xbf\xf0v\xee@\x8c/\xf1\xbfs\x8b\xb9\xf1^\'\xe5\xbfG\x1dg\xed\x95\x9d\xf5\xbf2\xb4vV\xf4X\x03\xc0\x81\xa9(\x1d\x8e\x84\xc0?q\xd1\xffF\x84\x82\xe0\xbf-\x1a\x15\xf9\xcb\xfc\xce\xbf\xe2\x95\xb1 \xe7a\xf2?\xa6\x14zj\x1b5\xec?.\xc0\x90s\x0c\xf8\x04\xc0/\xca\xe9\x83\xec\xb6\xf4\xbf\x84T\xc2\x99\x17\xd0\xc9?\x1c\x8f\xf6=F}\xf3?\x037\xb1\xc8x\xde\xe4\xbfz\x92\xee8\xf1C\xfe?\xf7(\xb8@\xdb\x15\xc6?\xcd\x0f\x84\x19vf\xe0?\xadN\x16\x9ci\xeb\xfb?<@A\xa4\xc6\xb4\xe7\xbf\xc9\x9b\xcb\xee4\xe6\xcf?\ndY\xa7\xdd\xbb\xf9\xbf\xdd\xce\xa7~Z\x83\xda\xbf\xda\xc3\x85\x80\xd1\x17\xe7\xbf\xe4\xf2f\x1c\xa4M\xdd?\xb4\xd6\x8c5#\x9f\xf2\xbf\xa0\xfb\x9fN\x16{\xe9?\x7f\xc9=\x8e\xdb\xba\xbf?\xda=\x1e\xa0\xa6\x85\xe8?\xb0\x8d\x05h\xc9(\xeb\xbf\xb5\xe2\xcb\xefH\xea\xdc\xbf\xa6\xe9\x9d\x9d(\xa5\xd7?C\x99\xe3\xa6T\x13\xf3?7~3w$z\xe6\xbf\xcb\xder!)\x02\xea?\xc5CZ\xe2\xce\xca\xfb?"\x91\xe0\xad\xc5+\xd1\xbf\x95\x15\x04\xd6\xda~\xed\xbf\\\xa1?1\xab\x1a\xe3\xbfH\xa5\xe2\xbc4Q\x02\xc0:\rs\xa1"\xc2\xe3?K}G\x1e\x96T\xeb?\x7f\xa4Ja:X\xb1\xbf\x19m\xf9=6w\xb1?/\xcd\xdd\xed\x1a\xb2\xc3\xbf(\t\x98F\xed\x0c\xf7\xbf\xad\xa7\x81\xcb\xf3,\xf7\xbfA\x07\xae\x84Ot\x00\xc0\xbd\x81\x924\xb0\xfd\xf1\xbf\xb13?\xe3\x06\x9a\xf5\xbf\xab\xa3\x9c\x14\xd7p\x04\xc0@\x01P\x8b\x8f\xb7\xb9?\xb5\xf8\xc4\xc5\xea\x1c\xa7\xbf\x1d*\xdbhCx\xf3?\xfar4\xac\x84\xd9\xd5?M\x90\xde\x81g%\xf5\xbf\xab=\x80,n=\xb9?\x9e\x9a\x0b\xe7\xed\x8d\xd2\xbf\xcfb\t\x92F\x1e\xcc\xbf\xc7\x89LPu\xf6\xda\xbfnN\x94\xbaF\xeb\xd5?hV\xbc\xf8N\xce\xc6\xbf\xf6\x0f/a\xc7\x88\xe4?FQ\x89\x0b\xb8w\xeb?\x12S\x87\xc4s,\xf0?O-\xbe\xbaX\x9b\xf4\xbf\x14,\xb4p\xa2B\x03@v\xe7h\xaa\xff\x7f\xe9?\xaf\r\t\x04\xd1\xf1\xe6?\xc1J3\xba\xcb!\x06@K\x05\xaf\x02\xa0\xac\xf8?2BVo\xb1W\xbf\xbf_\x13\x13\xe6V\x7f\xfa\xbf+"\xc5R69\xe1?\xc3\r\x93\xf7\xf1V\xf2?wN\x00\xfd\x19\xdb\xee\xbfF\xdf\xcfRTs\xe1\xbf\xe7.p\xd1\xe8\xad\xec?\x0f\x80\x13\xf3\xfd\x11\xce?\xb9\xbd\x9a\xee\xd5\x80\xe9?\xc1\xdb\xd8F\xfd<\xe2?&\xeeco\xbd\xcf\xf4\xbf2\x7f\x0e\xc26M\xd8?\xcb\xe0\xae\x0b\xe3\x1e\xe8\xbf\xf3F\x89>\xa2\xa2\x01@\x89@\xc5\xb9u\xa5\xda?C\xed}\x88f\x8f\xfc?\xa1\x9e\xb2S\xb63\xf8?\xa4\xd8.\x05<\x1d\xe9?\xe8\x98\x17\x84\xc6v\xfb\xbf\xab\xd2\xf6k\xf4]\xf1\xbf\xb6\xff\x80\'\'N\xb4?\x87\xdf\x97\x98t\x98\xe9?k\r\xe29\x91\xfa\xe1?\x0e}/\xed\xd0d\xd1\xbf\xe4`\xe4_\'\xbd\xec?\xa3\xc2@\x95<}\xf6?6\x9a[\xa0T]\xf3\xbf\x11\xf2\x9bg@\xee\xf2?g\xeed\xa3_\xde\xea\xbf\xc5\xda-\xffa0\xfc?3\xb1\x80\x07\x1d1\xc3\xbf\xe3\x0f\xcb\r~J\xe7\xbf\xf2\xc5\x12\xda*\x1d\xd4\xbf\xaa\x99\xcb&\xe4>\xf7?\xd8[\xde\xfd\xd5\xdf\x9c\xbf\xab\xd4\xe6\x8c\xa6\x8d\xe3?d]\x867\xc7\xae\xde?\xe5\xd9~\xe3h\xc3\xfc?\x00\xd4\xa8\xebX\xeb\xdc\xbf\x84.U\xbc\xe4\xca\xfc\xbfl\xe8\x92\xbb\xb4}\xf7?\xbc\xec\\\x85a\xb8\xdd?~\xd1\x17\x7f/]\xc2?\x85\xafA\xc4.5\xe2?\xef\xbd\xf6\xf8C\xcb\xf5?\'\x0e\xa7\t\xff\xd8\xf1?\x94V\x80\x89\x9e\r\xf4?\xb5h\x81\xb3,Q\xb5?m\xbe\xc6~\xb8\x90\xca?\xb5\xb9\x8dNt\xde\xcf\xbf\xdf\xba\x0f\xbfd|\xd4?\x8a\xca\xbf\xb1\xffW\xec?\x88\x85\xbd>UV\xcb?\xf5\x82\x82\xd2\x9a\x93\xf6?\xfd\xdc\x90^\x93m\xed?\x16M\xd2\xe6\x8cs\xd2?}e\x8e\xd4Dh\xd2\xbfl\x13v\x03K\x14\xf7?-\xf9C\xb1z\\\xa0?\xec\xe0k\x8d1\x18\xee?\xbc\\\xdb\xe7\xeby\xd3\xbf\xbd\x06R\xac\x87\xd0\xfc?\xe3dY\xa6CK\xd4?\xe4\x01\x02\xf5l\xc1\xd2?I\xbf\xde\xe8\x8c6\xe7?\x03\xab\xa8\x81\xb6\xf9\xfb?\xe4\x10\x87\x17`\xae\xfe?\x9c\x0c].\xff\xf8\xef?\x07\x9d\xc52(O\xfc\xbf\xbdid>\x9f!\xf6?G\x1b\xc4\x18H\x1e\xbf\xbf!g\xf6&Wv\xf0?\xb2v=\x05\xa2}\xfd\xbf\x15B\xe1\xf9\xcc\xd7\xbd\xbfV\x94\xc4\x80\x02\x07\xd9\xbfv\x9d\x01\xb4\xaf\x1a\xc2?A\xcc\x8aaHR\xf4\xbfJ\xe5\xc8w\xa6\x86\xfa\xbf\xa5\xadE\t\xb6\x1a\xeb\xbfU\xd6\x11L\xba\xa0\xa2\xbfi\x1a#n\xe9\x12\xf7?\xe7gg\x8by\xf0\xf8?\x82\xa4!2\x95\x89\xc5\xbf\\\x06 f[\xf6?j\xa6\xe2/D\xee\xde\xbf\xc1\xf5^X\xbe\x06\xf1\xbf\xa5\xd1r\x92\xa5J\x94?\x84\xb0\x8f\xab{J\xb6?\xfe-1\x9c\x11\x87\xd9?\xe37\x15\x18\xdd\x9d\xe5?%\x84\xfd\xc1UB\xf3?\xa0\x86Sp(\xef\xef\xbf[\xfa\xd0\x8c\x96\xbf\xd0?|\xc6\xef\xc3\xf4\x8a\x08@\xda\x85@\xa4j\xad\x06@7\x01\x9b\x12t\xf1\xc9?\xb3!<\xaf\x07!\xf1\xbfw\x04T\xd42\xe6\x00\xc0\xe4bu\xf6\xb8\xf4\xe6\xbf\xbf\x19\xe0\x85Z\x84\xd1\xbf\x86\xab\xf2sYt\xe8\xbf\x1f]XLas\xea\xbf\x8d)\xa8\'{{\xd3\xbf\x85 \xe8\x91\xe4|\xe9\xbf\x07\x84L\x99\xf73\xfa\xbf\x1a\xff\xd556\r\xdf\xbf9\xd2\xd5\xe8\xd3h\xcc\xbf4\x1b\xb7\xc9\x15a\xf6\xbf\x97\xef\x16d\x9a\xc1\xf7?*\xf7\xd4\x11\xf0\xc6\xcc?\x90\x12\xd1\x1fd\xa6\xf7?\xf5\x93\x0e\xd0H\x18\xf1?\xc2\xb1\xe6\xf1tp\x8c\xbf\x19~\xeb\x17\xde$\xf1?vL4"#\xb6\xf2?\xee\xd5\xab\xd48X\x9b?\x19\x88\xcb\x13(\xb5\xc2?2u5\xd2\x07\xb5\xbb?\xcc\x10\x84\xf8\x86\xb2\xe7?r~J\x04\xcb\xbd\xcb\xbf\xc0P\xa0\xf7\x80j\xee\xbfa\x1dTt6\x02\xf0?\x0c\xa3\xb9\x04\xd6\xce\xed??\xd7w!\xcd\xb8\xe1\xbfF\xcc\xa7\x0f2k\xdb\xbf\xa8\x1f\xb1\xf5+\xa4\xf0\xbf\xbbx\xe4\x99\xff\x8a\xf1?$\xeer\xc5E\x03\xf7\xbf44\xeba\xf38\xe3?-:\x0fP\x99\x1e\x02@\xc6Y)\x12Pf\xc3?\xdcY\xe5\x8f\xf0$\xdb?\xe8\\\xa0\xc3%\xf7\xd7\xbf\x0e)Mo\xa0~\xe6?\x15p\xd7t\x87j\xb9\xbf\xb7d\xb6\xad1\xbb\xf1\xbf\xe98\xba\xe2=U\xf5?\x87\x05K&m\x86\xf7?S\xc4\xba\x12\x08\x8d\xf8?\xab\xe8\xf9\xe2+\xc0\xd6?1\r4v\x87B\xc2?l>\x94\xe7K\xb3\xec\xbfq-\x06\xbctO\xf6\xbf\xa6<\x15\xb9v\xa1\xf8\xbf\xc0?\xfd\xd8\xfe\x08\xd0\xbfYm\xd0\xd2Dw\xe6\xbff\x03\xf5\xb2\x01\x8b\xf7?\xdb\xa3G\xc5\x1a\t\xc3\xbf\x01"%\xb0\x92u\xf4?\xd0\x87\xe7\xc41Y\xe8?e\xe8\xdb\x87or\xf2?\xa3L\xcd\xe3=V\xd4?\xe0s\xbc\x03zY\xe0?=\xf5\xab\x9fc6\xf3?\xd8\t\xc2!\xd6\xe5\xd3?[\xf3M\xc1N?\xe3\xbf@;C\xe3\x7fh\xe6?;]\xf3z`\xef\xbb\xbf\xe3\xfc\xdf\x0f\x16\x17\xf5\xbf\x92\x99\xb0+\x7ft\xd0\xbfG\xa2C\xd3\x12\x88\xf7\xbf\x9e\x9b\x8e\x14\x8d \xea?\x94=\x1f\x19i\xbd\xf6\xbfpS\xce\x86\xb3\xb9\xdf\xbf\xea\xa6z]1\x16\x00\xc0U\xe9\x05\x04\x14\xcd\xec\xbf\x87\x83=\x049\xe9\xcb?\x03\x81X\x93c\xfb\xc9\xbf\xf6\x17~\xe47\xce\x07\xc0n\xca/%d\x02\x01\xc0\x7f)\xfdsC}\xf5\xbfC\x13\xda\xb1oz\x01\xc0\x94\x96\xb3\x0f\x8a\xec\x06\xc0w%\x16\xf5\xf7(\x02\xc0\xac\xd7\x17\xe3?\x80\x8a\xa6\xa4b\xeb\xfd?o\xbb\xcb\x02\xf1\xba\xdd\xbf`y\xf0\x05C\xe0\xfb?T\xaa\x04\xc8\xfec\xde?\xe2I01\x14!\xdd\xbf\xdc\xe5\xac\xbdf\xbb\xa3\xbf;\x8cI\x7f\xf4\x9b\xee\xbf\x99\x96Q\xe4\xeb\x13\xf6\xbf\xa2x\x10\xe7}w\xaf?\x9f`\x1d\xed\x17o\xd3\xbf6\x0cm\x1b\xc0\x88\xdd?nH<\n\xc6\xc6\xe7\xbfw\xa5\xf8\n@k\xf8?(\xea;\xd2\xd2=\xd3?\xb1f\xe3V\x91\xa6\xe3?\x8e\xdc[L/N\xc0?\x14\x8f<\xf5\xae\x00\xee?O\xfb\xc0\xf4;\x8d\xed\xbf~\x0f\xd7{F\x9b\xe5\xbfo\xd9\x8d\xe0\xe3>\xdc\xbf\x97\xaa\x96QC@\xea?\x03\xc7&-\x89\x82\xfd\xbf\xea\x88\xd2\xa0;\x94\x04\xc0\x1ck\xc9\x88&\x88\x0b\xc0\xc9m\xe6*\xbf\xe3\x04\xc0\xd3\xfd>5\x91S\xc5?\x10%e\x96\xc4i\xe0\xbf\x93\xcf\xc1\xe7n\xdf\xf7?E/\xc0\xfd\x91\xf3\xf4\xbf\x1bM\xf4\x13\x84\x1b\xe0\xbf\x92*B\xfb\xfa\xaf\xe0?#Af0\xabJ\xf1\xbfR\xfb\tK\x06\x10\xe0\xbf\\\xa1\xb1D?\x91\xc5\xbfA\xb2V\x1cb}\xea?\xd0\x9f\x83\xb1t\xbb\xec?\xddd\xed(\x0e8\xdb\xbf\xf5"\x13v\n\x9f\xf3?\x8a\xd1\xe5\x0c\x8fh\xf2?\xcf\xccP\x1eN\x9c\xee\xbf\xac\x9b3\x83b\xa6\xe9?\xdcE\x99[SG\xf7?\xdfb}\xb6\xd4\x92\x03@M\xda!\x19\xdd\x91\xc6?\x0c\xaa\xb3\x95\x03\x1a\xf7?XyDY\xef\x1b\x00\xc0>+\x0c\xb1\xfe\x87\xf5\xbf\x9b\xd9Q\x0e\x1b\xf4\xff\xbf\xf0\xc7\xe8\x87 b\xe8\xbf\x8c\xd6\xdd\t\xf3\xc0\xf2\xbf\xed^\xc0\xb2\x88\\\xfa\xbf\xb9"iO\xd2\xcf\x06\xc0\xb0\x1a\x93\x91\xb1X\x07\xc0q\xe0\xdc\x9d\xabH\xe8?\xd5\xc1W\x05\x12\x12\xe6?\xef\x9dXl\x83:\xe0?\xdc\xee-\xb2\xcdK\xdf?\'u\xf5\xc9\xf6\xf3\xe2\xbf\x19\xe4x9\xfc\xd5\xdb?\xef\x06\x9d\xac\xff\xc9\xc0?\xb3\xcc\xae7\xb6\xcc\x07\xc0\xd5\x83\x81N\xf94\xd1?\xccd\xc5#\x9f"\xec?+k\xb2\x9bh\x08\xe6\xbf\x139\x95\xd2\xc2\xf2\xed?\xf8\xa3\xab\xdfo/\xf7\xbf^\xbf\xf4\xfa\x0c\xc5\xe3\xbf\xdd\xc9\x9c`\x8d\x91\xf3\xbf\xediT\xd3\xec\xd1\xd6\xbf\xe8\xaf\xa7r\xedI\xef?\xa0\xd9\xd0\xdc\xd1;\xf3?\x97\xd3\xd2\x9a\xf2\x04\xf6?r\xf3\xce\xb7\x80\xd4\xed\xbfw&1\xf9\x96^\xac\xbf\xbc&\xf0\xd3\xf2e\xbc\xbf8\xd4\x8b\xf4\xe8\x9c\x02\xc0\xe2J&\xd6\xe3}\xd2\xbf\'/\x1f\xe1\xdbE\xf2\xbfXe\x0bk\x8d`\x03\xc0\x13\xc2\xb5N\x05\xc3\xe6\xbfB-Wy\xed\xe0\xd5\xbf{\xb5@\xd7\x89\xf1\xdc?\x03^\x93\xcc>\x9a\xe2?\xcb\x0f\xb27\xa8U\xa2\xbf\xd9\xfc0"\x12\xcb\xd7?\xab\xdb\xb0\x1fc)\xc3\xbfid\xd1D\xee\xdb\xf1\xbf\xa4\x19q9\xd6\x87\xd1\xbf*\xf8\xd2c\x0c\x05\xf9\xbf[V(o\xc0\x93\xe4\xbfm$Ae\xbd\x1c\xe8\xbfy\x8eq\x84>\x95\xf5\xbf\x81^\xef\xd3\xdc\xb6\xef\xbf0f*l\x18O\xc4?\x8e\xdd\xf6\xb0\xa9]\xca\xbfu\x1a|\xc0\xd9\xaa\xe1?Y[^\x7f\x8cO\xf3?Y\xcc\xf4s\xe2\x87\xee?s\x9as\xde\x97\x9e\xdc?\x1c\x1c\xef\xe8\x04\xaf\xb5?n1\xb1\x94\xda>\xdc\xbfT?u\x8e\xd4\xfa\x01\xc0vD\x92B\x1c\x9b\xd4?\xb2\x1e<\x99\x93X\x00@q\xc1y\x842\xf7\xe3?\x03z\x99\xf2:5\xea?\x81\xc7\xd5\xa5\x7f\xee\xe1\xbfV\'y\xae\xa6\xfd\xe3?\xdb\xf91h\x07\xfd\xf4?\x88\xb3\x9c4lO\xe0\xbf\xe9\x9d3V\xe9\xb8\xfd?u\\\xb8\x9a\x1e!\xea?\x1d\x03\xfb\xb6\xea\xcb\xdb?\x16\x94\xa6;+\x1d\xe1?V\xb2\xe9t"\xcb\xe2?\x1f\x92\xecf\xf8\xa7\xd4?\xfe\xfaX\xf6\xfc\x03\xbe?\xa93BQ\xe3K\x03\xc0N\x1e\xe8-\xaeQ\x01\xc0\xa9\x0b\x9d\x88\xc4\xa7\n\xc01\xb5W(c0\x0f\xc0\t\x9bL\xf5\xc3\r\x0f\xc0\xe5R\xf3x\x19\x04\xe5\xbfv\x98#/;\xc6\xf8?7@fv]N\xfe?7\xf5Mf\xde\xb4\x05@G\x97\xfd\xc1\xe4C\xfd?\x7f\x92\xabW \xc0\x06\xc0?\xc1\x9a\x8fR\xd6\xfc\xbf5)\x90\x9e\xdd\x81\xf6\xbf\xd8\x0c\x88\xa6\xf7r\xf2?1L\x168?\xf9\xf3?\x1c\xd7G?7d\xf4\xbfez\x9b\x13\xbd,\xf2\xbf\x80S\xe5\x13\xd9O\xfd?0\xd9\x86\xc6\x80\xf3\xe6?\xdc\xab\xde\xae$\xf6\xd6\xbf\x8f\xa2\x8f\x842\xed\xf6\xbf\x9fMD\xaf\xd3k\xe8?\xaa\xf4H\xe1\x03\xb9\xf1?\x8bq\xd2}5\x00\xc4?\xd6\xa2\xf0\xee,\xfb\xf6?\x7f\xf3\x07J\x07\x1c\xd0\xbf\xbd2Kh\'\xa0\xfb?\x06^\xb2\\\xbc\x98\xe6?/\x8360N\xa0\xee\xbf\xc9$\x01%\r\xb9\r\xc0\x80A{\xe9\'\x81\x18\xc0\xe1\x8cf\xb46\xb4\x1b\xc0\xf7*\xda[\x96\xb7#\xc0\x11\xcb\xa1\xdb\x0fo\x1c\xc0\xc1\x17\x82\xed E\x1d\xc0\xeb\x14=-R\\\x12\xc0\x05g\xd9\x81\x10\xd9\x03\xc0?P\x02\xc0\xbcW\x08\xc0\xaf\xe0\xc7\x13yL\x01\xc0\xb9\x98\x98\xc5U\xa7\xfe\xbfp\xb9\xb8l\xe6\xb6\xe3\xbf>M\x84\x1e\x15\x83\xe6?\x85F:\xfd\xbc\xcc\xf9?\xa9\x11\xff_\xe9\x1b\x00@\x16\xd6\xc6\x1a\x1f\xa9\xf4?}|\xdaM\x0c\x04\x00@\x9d\x03\x8a\xb0\xc8\x02\xb6\xbf\xb4\xcdc\xeb\xa8\xcf\xf6\xbf\x87W\xda\t\xa5#\xd2\xbf}\x86D6\x9co\xaa\xbf,x1E\x17\xe6\xf7\xbf\xc8\xd6\xeaB\x004\xf0\xbf\xfd\xc7E\\J\xde\xd1\xbf{\xef\xeb\x86\x0eN\xd9\xbf)\x1cr\xdf"4\xe0?\xa0\xe0$W\x90\x0b\xff?\xc8\xdb\xca\xf2\xbd_\xe8\xbf\xc25i\xde\x96\x08\x01\xc0\x9d\xb0\xf0\x04\x07\xea\t\xc0JI\xcd\xf0vp\x08\xc0ZI\xff\x8dM\xff\x1e\xc0\xb8\xe2\xf3\x98\x1d7 \xc0\xc8\xd4\x12\xad\xac\xf7\'\xc0^\x0f\n\xe6\xc1\x05%\xc0\x08\xd5\xb2\x8b\x0fj\x1a\xc0&\xd7\xe5\xcd\x08\x17\x06\xc0n\xd3\x16\t-\x9b\xe1?k\x8f3\x7f\x91K\xfc?\xfeQw\xbe<\xcf\xff?\xca\xe4\xa6\xdc\x0ce\xff?\xc6k\x8aN\xc0~\xf7?vE[\x06\'\xe2\xf5?\x83\xa3\x9f\xdcu\xcf\xdc?1\xfcc*9e\xf2?K\x94\xa7\xf9\x03\x8c\xe5?F\x10\xda\\\x9b\xd8\xdb?\xf9\xae\xd8 g\xab\xe0?O,\xf1\xbb\x1dx\xc9\xbf]\x92\xfaLyS\xda\xbf{G2\xb4:\x94\xe0?b\xc8\xb7\x86-\x17\xf7?\xb9)1}]Q\xc3?\xb2\xd5~\xbf\x02d\xe6??\x08\xb7\x97\xf2\xe9\xee?K\x9e\xe5\xc9f7\xfb?\x14\x8c-M\x00\xac\xe5\xbf%\x98\xb9\x9f\xff\xe8\xf0?\x9e\x12V\x98)\x89\xe8\xbf\x8dW\xb4\xa8r\x1e\xf0?\xba6pi\x15\x19\xf3\xbfo\xd6\xcf \xc4V\xf1\xbf\xe2\x8e\xed\x9e\xef\x8d\x0e\xc0\x0es\xaa\xc6_\xa0\x0f\xc0`/uF\x19\xd5\xf9\xbf\xb6 \xf1\xf5X\x80\xfd?\x00\n\x14^|\xe4\x07@7\x87\xf2W\xba\r\xcb?W\x15\xb1\xbe6G\xf2\xbf\xe0/\x86<\xd6\x15\xf0?e\xe2\xc0\xdbfo\xf1?\x11B\xf7=\xddS\xef?\x9d.\xad\xf5)z\xc4?\xf7\x92\x0e=\xf3c\xd7?W\xf0\x01\'\xf4~\xfe\xbf\x93\x0eL9\'\x81\xf2?s\x94\xa0\xe4\xe7\xd4\xb6\xbf\xb2\x02@:@\xab\xe4?\x94\x02\'\xa7\xd1\x01\xd1?\xf7\xeb\xed\x1c\xc1\x92\xf0\xbfaP\xb2~\xa4\xdf\xcd\xbfVs\x04R\x1a\x7f\xf6?\x1c\xf9~9\x15\xea\xd7?\x1c\x12\xd4)\x89\x81\t@\x99G$K\xba}\xe2?dbM\xf3\x1f\x18\xf1?\x1d\xe9\xf8\xbe\xf6\xe5\x00@O\xd7k\x81(\xeb\xe2?\x83M\xe4\xccD\xcf\xfa?\xf1\xbaD3\x89\xe9\xf4?\xd8\xde\xa7jW\x0e\xf6?G\xdb\xf7+\x8d\xfa\xc8?*S\x7f\\\xd4\x06\xc9\xbf\x03\xd3\x07\x1e\x00\xec\xcd?\xb3\xb3D\xd7\xba\xcc\xc3\xbf\x9cnw\xd0\xb0\xd6\xc2?z\xf2\x06\xae\x99\xc3\xe1?\xe6\x1b\xcd}\x18\x0c\x03\xc0|\x14$o\xc3\xadh\xbf\x0e\xf5\xdcP\xa3Y\xfb\xbf\xfd\x05\xff,\'\x01\xf1?\x1f\x14\xde-\xab\x07\xa4\xbf\x06T\xc4:\x17I\xe8\xbf\x1c\xcf=\xa9\x8e\xe1\xeb\xbf\xde\xae1\xd1\xe4\\\xc0?\xbd\xf2W\xaa\xc1#\xe4\xbfs\x97\xe7\xa5\x8f\x14\xf3?\xc88b+*\x83\xb8\xbf\x19\xca]\x9e\x1e\xd3\x01\xc0;\tg\xbd|i\xde\xbf\xac\xe2\xeb%\xfbk\xff?h:M\x85\xb0\xe5\x00@\xe2Bx\x93:\xe3\xf4?RD\x08\xd4\xba\x92\xfc?\x99\xa6\x036"\x0e\xfc?a\xb4@\x96\xcf\xdd\xe3?4Y-\xf1\xa3 \xcb\xbf\'\xd2\x18+\xd9\x9a\xfb?\xc5\xc0\x03\xc8vS\xfc?\xf3\x81\x8aB\xfc\x1d\xed?\xa5L\x99\xa1\x8bQ\xe1\xbf![%\xa9\xdaS\xf5?\x02\xd3\xcbcr\x8d\xe6?#:@\xa0\x9e\x0e\xe4\xbf\x89\xf6CZ\xaco\xe8?\xba\\\x08\xaa&u\xb7?r\xca\xb4`\x9a\x04\xf3?\x81i\x08\xf6\xe0\xc2\xf9?\xd3R\x1f\xd1\xe5\xab\xf8\xbf\xe4\x97\xe5\xd5\x94\x9d\xf2\xbfSw\x9d\x16\\u\x03\xc0\x93h\xa1]\x10\xd0\xf2\xbf\xe8$Y\xa0od\xf2?\xa8\x0b=\xd4>\x8a\xc3?\x11+\rW3\xc6\xe2?\x82AZ\xc2\xd4\xdb\xe6\xbf\xdb\x93\x1f*J;\xed\xbfC|\xaf\xfe\xba\xd9\xf0?\xc4\x99C\xd3\x00\x8c\xc1\xbfM\x84\x95\x7fF\xd8\xf7?\xa4\xbd\x12{\xb5\x1b\xc5?\xe8g\xc8m\xf8\x1c\xe0?\x9aj\x82\xfc\xd5\xae\xb3\xbf1\x98K\xbe6\xb4\xfb?\xfe\xbe\x8e\xc3\xa1U\x05@@\xdc\x87\x8c\xc33\xff?\x0e~8\xe3[\xed\xe9?p\nK\x9e\x87\x04\xf9?\xd1\x9f\x19G\xfa\x87\x86\xbf\xbd@\xbaY\x9cs\xf6?p\xebgx\xc3{\xd7?\xe1E\xb5m\xbd\xb3\xfe?\xef\x10s\xc3\xae\x03\xe3?\x0b\xff\x82\xc3\xcf\xf8\xc0?R\xb1\xf01\xc7B\xb9?[\xcc\xbc\x04\xf3\xc3\xe1?Q\x87Gfa\x11\xcc\xbfq\x93u=\x9f\xf6\xd1\xbfS\xe0 \xbcYV\xec\xbf]\x0c\xc7\x9c\xb4\xb2\xc3?\xdb&h\xf5\xe5\r\xf9\xbf\x13:\x07\xea1o\xf7?Z\xe7\x1ec+f\xc7?\xbd\xdb\x10\xfc\x0b\xd7\xe2?-\xb5\x12\x86\xed1\xde?\xf12\x07\xb9\xe4\xc7\xe0\xbf#}\xf4\xcd\xe0\xcd\xe6?\x01\xe8x\xba\x0f$\x01@\xfa.\x95\x05If\xc0\xbf\t=\x0c\x88m\xfe\xe3??\xefU\xca\t\xbc\xf3?\xcb\xfe\xbb\x97\x14r\xd9?\x99\x8er\xb2\xf9\x0c\xbd?\xe6\x8e\x87\x0f\x0b\xbc\xc5\xbfq\xc9+/\x94\'\xea\xbf\x08W\xb2\\t\x8f\xec\xbfM\xb8\xe5\xf6b\xab\xda?}-z=I\xb9\xf0\xbf\xd5\x99\x83\x01\xc5\x83\xf7?\xca}Q\xa4\x1a\xb9\xc3?\xef\x16@\x10\x12\x03\xe2?1#\xd8,w\xaf\xee?\xafA9C\xeb\xfb\xdc?\x885\xdfX\xb6v\xf6?\xe5\xad\xdd\xf8\x1a\xc2\xf6\xbf\xc5\xcfG\x96`G\xfd?R\xed\xf3G\x93\x8a\xf0?>\xb2`\xb2S\xc7\xf7\xbf]\xcc\xf9u\xefd\xe0\xbfb/\x1fxc\xe1\xd0\xbf\xe6\xff\xb0\x8b\xd6\x84\xf9\xbfP\xf1P\xd8Cf\xc1\xbf\x90\x8ai\x02\xab\x07\xb0?+\xfd\xa3\xef{N\xe4?T\xe19\xa4\xf5\xbc\xf0?Lj\xb4\x0b\xa0O\x0b@\x0b\xda\x94\xe3\xc1\x0c\xf3?\xc5\x17\xf5\xc3\xc8\xee\xf4?K\x8a\xe9\x99&f\xf1?*y\x89\xf8\xadF\xf2?W}E[\x88\x04\xeb?\xc9\xc4\xb9\x81\x1aL\xf4?\x83k}\x1f\\"X\xbf\xc5z#?\x10\xe6\xb5\xbf\\[\x03\xc4\x0f\xad\xff?\x01\xa3\x8f9\x9c\x8f\xe6\xbf{\xb8\xbd]\xc6\x93\xd4?\xd1\xe8\x9a{\xac\x9b\xf9?\xfa\xdc`?@\xd2\xdb?\xd0\xabM\xd5\xa5\xd1\xfb\xbf\x06\xd83\\\xccH\xe4?\x19#\xebm\xe5\x9a\xe4?\xd1\x13Q\xdd\x01l\xee\xbf\x876\x13\x08o\xbe\xf0?\xb2{\x9cqnJ\xe9\xbfTa%\xc7\x8c\x9e\xf1?\xec\x13\x84Qj\x9c\xec\xbf(\x04\xc6a\xd5U\xea?D\xb1\x0bb|\xdf\xcb?Q\xcf\xa2\xae\xc3o\xe0?"\x85^\xd9\xaa\'\xe6\xbf\xad\\\xe7\xb0\x88\xb8\xde\xbf6\x84\xf7#\xe3\xe3\xd0\xbf\x02!a;\xad\x80\xf2?\x90\xe6\xeb\xa7\x12\x94\xfa?\x02\x83\x11\xa7U\xf2\x00@\xe8\x80\x96\xb8(\xc7\xeb?\xccO<\x0f\xdf \xe6?\xeaU\x9ep\x83\x0e\x00@\xe4\xed\xad\x14\x19\x15\n@=\x8b\xac<_\xeb\xf5?\x90$}\n\xffe\xf1?\xbc\xc2\xa6%FU\xb2?I\xdf\xeb?e-\xe1\xbf\xd9\x06p\x90\x8d,\xf3\xbf\xd5\x9e\x01\x8b,\x0c\xef\xbf\xc3\x12\xe8\x1a\x908\x08\xc0\xfd;\xa1\xd1\xa5L\xd6?\xda\xf2#8_,\xc1?d~\x8a\xb9J\xb7\xdf\xbf\xc0\xab\xd0\xc5\x1e\xfe\xf7?\x01\x86+\x1bgL\xcc?\x84\x8c]\xadcz\xd9\xbf^\x8d\xb3[\xae\x92\xba\xbf\xb28\x9d\x8a\x11\xcf\xe4?n(\xe6"\xed\x93\xf0\xbfH\x0c\x8e\xba\xeb\xa7\xe5?\x8b6u\xfa\xbc\x1a\xc9?e\x94,\x9fz\xcf\xda?\x0b(\xa37\xabs\xc2?d\xa7\xa1\x88\xd8H\xdf\xbf\x99y\xd0_\xb9\x80\xe1\xbf\xd4\xdc\xc9\x14\xdfC\xf4\xbf\xd9\xbeR\xd65L\xeb\xbf\x9b<\xbcA\xe6>\x01\xc0K0\xec\\\x8ak\xf6?\x9d\xcdW\xfa\xcf\xb4\xa5\xbf\xdel\xc0\xb2\xadj\xf8\xbf_t4Y\xef0\x01\xc0|\xf3]\xbdvx\xd1\xbf4\x9a\xdc\xad\xec\xb6\xe0?\xba\x02\x1a\xd0~\x07\xe0\xbfr\xfc\xf4q\x80\xf1\xce\xbf\xa2^\xfc>\xae\x9a\xdb\xbf\xfcU5OG\xff\xe4?\x13\x8e\xc9\xe4\xd97\xe2\xbf9\r\x9a\xa4\xe9A\xe8\xbf\xf7\xb4\xd6\xbc\x9e6\xec\xbf\x9c\x84I\x9a\xb1\x9e\xee?Jb\xb0O\xec\xdc\xcc\xbf\xee;\xbd(6\xab\xe4?\xcbAoy3(\xfc?\xce?\xbe\x93,1\xf4\xbf\xb5\xcc\xaf\x11\xc6\x89\xf1?Y\xceE\twt\xe6\xbf\xd1|@\x0ce6\xcb?\xc8\xe6\xcb\xca\x0c\x82\xfa?=6c;\x8f\xee\xfb\xbf\xa8\xa5\x02\xed\x86\xda\xf2\xbfw\xae-E\x04\\\xf6\xbf\xbb\x1a,s\xea\xe4\xe6?]\x8f\xae\rlH\n\xc0\xf4uBO\xb6F\xec?\x9f\xcbA\x1e\xb4\xc6\xef\xbf\x08v\xe3\xa3\xc3\x19\xf1?\xc5OU\xae\x1f\x94\xe6?Cs\xb8\x86=\xb1\xab\xbf[~{R}\x85\xef\xbfK\x06\xa2?`\xf3\xea?X\x15\xb9\xf7\xfc\xaa\xf3\xbf\xb2q\xd0\xa7\x13]\xed?\x7f\xe2\x15:O\x90\xee?\x8b\xb1\x93\xab\x06b\xe9\xbf\xcd\xd1\x10",K\xf0?$\xdf\x81"\x1d\xd8\xca\xbf\xc4\xaemG\x80\xcb\xed\xbf\x0f\x98\xc0\xcd\t\xd3\xfc\xbfO\xc2\xf6\xea\x1d\xb4\xdc?\x8e\x8e\x88\xeb\xbfG\xe6\xbf\x02\xb6k64b\xe4\xbf\x81\t\xb1-z\xe7\xeb\xbf\xe61~\xae\xf2\xd2\xfb?\xb0\x9eTgJ\xcd\xf8?=\xaa\xf5\xce\xb28\xc0\xbf\xddS\x03\x11SA\xfc?\xbc-\xb880/\xf4\xbf\xb6\x1bN~\xbe]\xc4?\xd4\xa3\x06\xb4\xbd;\xe5?\xf1kTS$\xa3\xe0?"\xc4\xe6&v\r\xf1?C\x1c\xa9\x05\x1d\xb5\xf4\xbfSChTF\xd7\xf1\xbf\x95\xf0F\xf6%\n\xc1\xbf\x95\xaa\xc0B\x94\xc2\xe4\xbf\'\xbb;\xcc^\t\xd6?\x98@6\xf3\xf4\x9a\xc8\xbf\x12\xdeb\x1c&\x84\xf1?\xda\xdc\x88\x9d\x04F\xdb\xbf\xa8\xb6qt[\x0c\xf6\xbf\xe6\xc9qd\xcc\x07\xec\xbfu\xeaO\xde8C\xe4\xbf\x04\x8a[\xbez\x8f\xf9\xbf\x19I\xda \xff\xcc\xe1\xbf\xa2\xf9\xfb!\xcbV\xde?\xecl\xe4\x9b^z\xf1?R\xe8/\xe8\xff\xdc\x00@\xe3\rt\x15\x97\x14\xed?@\xee7\\\xf8\xf0\xf0?\xb85]O\xa9m\xe2?\xe5\xfa0\xcd\xf2\xaa\xcc?\xf7\x87\x1b\xa9\x04\xb3\xe7\xbf\x15\xf1\xa4MKD\xd7\xbf$.<\xda\xe7P\x0b\xc0\xab\xd81Ld9\x03\xc0\x88\x88\x9c\r\xef\'\xc6?\xf2.{UV\xee\xf8?\xffb\xc5h\xcc\xc1\xf7?\xf2\xc5\xbb\x97\x04\xb8\xe1?\xf0`tG\x98\xe4\xf0?5\xdb\xf3\x0f\t\xd8\xc8?\xe0\xf6\xe2\x95\xc3{\xdb\xbf\t-\xf3\x1d\xd0\xa6\xd9?\x99\x99\x82\xffxL\xe4\xbf\xaa\x9d\xabb6\xd4\xed\xbf"\x0f\x93i\xcfS\xf1?\n\x15\xde\xe1\x04T\xd0\xbf\xad\x8e\x15W##\xfc\xbf\xa8EjX\xfb\xf6\xdd?\xd04\xd8\xbd\xa4y\xf3?\xa1VS\x06\x8fB\xf5\xbf\x8c\xf5\xc3\xbaH3\xd0?s\xd2)\xeb\x01\xe2\xd5?K\'\xda\x04\xf6\x0e\xf5?\x99l4\x1a\xb5X\xad\xbfC\x19_\xc7\x8e\x10\xdb?:\xf2$\x1a\x05\x89\xf2?\x9c\xaa\xd5\xbf?\xf5\xd7?\xdeQb\x91O\xf3\xc2\xbft\x88\x01\xd0\xd4\xae\xc0\xbf\xda\x08xV:xo?T6\xa8IT\x8e\xbf\xbf8\xb5\xb6=m@\xe4\xbf\x86?\xa1J>\x17\xc8?\xa6-1\xdf\x04z\xf3\xbf\x91*\xe4\xd5c\xa0\xef?s)\xa7N\xe2\'\xd4\xbf\x1aS>\xcb\x92\x13\xd9\xbf\xe0 \xb9\x0b\xaba\xf1?\\}\xf4_\xa2\xc1\xe3?\x1f:\x93\xaf\x1c\xfe\xe2\xbfr\x9f\xfcf\x02\xd2\x02\xc0\x08\x16p\x98!H\x9a\xbf\xfd/\xd1\x13\x04\x80\xdf\xbfG\xfb\x11t?\x0f\x03\xc0RF\xbd\xd1i\xcb\xec?\n_\xa8\x13\x87\xc8\xfd\xbfSEV\x01?C\xc6\xbf\xa9O\xd1\xf3SV\xca\xbf\xc5\xdb\xc4\x97t\x9a\xe0\xbf\'G\xb2\xc0\xf5u\xe7\xbf\xe3\xc0E\xfa\x9c\x1c\xf0?o\x02\xe4\xac!\x12\xea?\x1a\xa2\xe2\x16\xcd=\x92?\xa0\xa50\x90o\xe1\xd9?\x00\x7f2\x97n\xe0\xed?\xf09o \x9c\xcf\xd5?\x8c\x0f\xca\xb8\xe8\x07\xf1?\xf4\xd4wJ\xc92\xe0?!\x8c\x8d\xcf\x92\xdd\xe5?\xb1<\xea?f\x15\xd6\xbf\xa2\xb5o\xcc\xbe\xc8\xfa?/\x8d\xea\xd7J\x05\xf6?\x9f\xa7@\x92r\xb3\xe1?\xb2\xfaK\x12\x03o\xe7\xbf-\xd5\x86\xed\x05\x02\xf3\xbf\xc8\xffk\x91\xb6\xc8\xee\xbf\x19U\x9b\xf4\x0bK\xef?\x83$D\xc9^\x10\xc9?\xb9"s|D3\xf8\xbf/\x81\xb7\xa1\x1c(\x01\xc0\xbay1\xc3o\xd0\xfd\xbfP\x88\xeeP\x1f\xdc\xe4\xbf\xa8g\xd0\xe8\xa7\x07\xe5\xbfu\xe1\x01KT\xcf\xe0?X\x7f\x1c7\xb5\xdb\xae\xbf|\xb8>rW\xe4\xf4\xbf\xa4y\xd2L`\xf2\xdb?\xab\xf7\xe8|>9\xd0\xbf\xdd\x1bo\xe3Z@\xdc\xbf!%\xa6Z\x9d\xec\xfb\xbfEtc8\xaec\t\xc0\'\x04\xa9\xd1\x14-\xe0\xbf\x16\xbe\x0f\x0e-\xc5\xca\xbf\x16YO\xcdI\xee\xdd\xbfQ\x8epdQ\x98\xb6?\x11\xda\xdf\r\xc0\xe7\xf5?\xb3\x9b\x85)\xe5y\xea?rG\x82^\x9e\xf6\xed? +\x972_\x9b\xd2\xbf\xe4r\x03\xd4\x8f6\xf5\xbf\x08\x00\xe5k\xcaJ\xb4?W2\xdb\'\x15S\xd4?\x7f\x83`\xcb ~\xd4\xbf)\xbcP\xde\xf3\xa9\xe6?\x92m"\x0f\xd8\xe6\xca\xbf\xa9\xa9\xa5\xff\xb9\x8f\x03@\x91\xd0T?\xe1\xd9\xe9?\xc5Zu/r\xda\xc6?\x05\x98\x93\xe5W\x0f\xc6?E\x8e\xb0\x03\xe4\xe9\xf6?\xf7\xc9\xaa\x87\xf1\xdf\x01\xc0H\xb8\x0e\xd2?\xe2\xe4?\'\x84p\xf8\xa6\xb3\xe4?6%\xb2t\x90\x01\xe7\xbf\xa5\xe9X\xa0x\xf2\x03\xc0\xc3\x08*\xb9\xf4\xe5\xaa\xbf\xa8\xc5=\x15\xb2\xd0\n\xc0`\xbf\x12\xa1)\x1c\xf5?k\xef\xe2\xaa\xe4A\n@\x18\xe6\xd6\x0f=\x8c\xda\xbf\x84\xb2s\x04\x18g\xc9\xbf\x89\x17\xc2\x07\x92\x14\xe0?xy\x80uDo\xd5?\xc1\xf2\xf5\x8dOs\xd6?\xfa;\xcb8\xc7\xd1\xe5?m\xc6\x86A\xff\xa8\xd9\xbf,\xa4\x9a\xfb\xa1\x04\xff?\xeb\xd6^\x9f\xbeL\xe8?p?\x85\xac\xfb\xff\xf7?C\x875tU\xce\xf3?\xb0!\x0b\xa4\x85:\xee\xbf\xa2\x1b\x96\xf14:\xe2?\tr\x1a\xae9\xe0\xe7?\xe4P\xdbz\x18w\x03@\xe3\xb2\xd0S\x07%\x04@\xe2m\x11:9\xb5\xfe? \xa31\xdcD?\xca?\xf5\xc1\xf6\x00\xc3-\x96?y\x94\x91\xcb\xb7\xf8\xe4?o\x10\xc7D\x92W\xe5?\xceQ\x83{\x8f\x13\xfd??a\xa0\xd9U\x7f\xfd\xbf?\xef\x83\xa0<"\xf9\xbf\xcc\xa7\xc1\xa7v\xfe\xe9?\x97\x9c\xb4\xbb\x91\xf8\xe4?\x9fI\xf7\xd1+\x8f\xe1?[\'\xd9\xa4x\x0e\xf0?\x08/qD\xbaa\x05@\x88\x88L1\xf3\xa5\xde?\xdb\xf7tt#\x8d\xea\xbf\xa8\xcbMbS\x17\xf7\xbf\x084\xb9N\x00\x12\xfa?~pL\x9bX\x10\xfb\xbf\x92\xc7}n*"\x04@\xe4\xdbf y\xe0?p\x9d\x0f\xffiK\xdc?\x1d;\xa3\x9b*#\xd5?UI)\x0b\xbc\xf8\xf4?\xfc\xdcM~a\x7f\xed?YFD\xae\x15@\xef?\xb4\xb8/\xe5pL\x0b@7\xd5\x1e\xfa\xd7\xb4\x01@F\xd7\xd0\xe6\xab\xd2\xa8\xbf\xe4\xf3\xed\xea\x9b\xf3\x00@\xc0\xba\xacI,\xf8\xf4?A\xf8r\xb0WR\xef\xbfJt\xba\xe2F\xe6\x00@/\x03[\xa0Y}\x07@Z?\xdb ]\x9c\xc1?R\xd3E\xd2}\x91\xf1?\x9c\x9d\x06wBN\xf9?UE\x04\xbb\xa4\xf0\xf3?\x86q\xb7\xbdwi\xfb?\xbf\xa7\x16x[\xe9\t@\xd1\x0f\xd3\x19\xf6?\rA\xb2q\x04\x97\xeb\xbf?H\xf5\n\x1b\x91\x89\xef\xbfX\xd7m\xd5\xa4\xd7\x04@w\x07\xc7\x81V8\x01@n}\x92\xaf\xbfZ\r@f\xa6\x80\x90k\xf0\x0b@\x89a\x9a\x17\xb5L\r@\x86#\xb3\x83\xfa(\x0e@\xf9zVaK\xb1\x10@\xaa\x15\x8a\r\xa5\xdd\x05@M<\x0c[\x0c\xaf\xf7?\xdc\xa7sH\xf6:\xf0?\xed\x08\x85zu\xeb\xf3?j,\x0f1\xf3\x9d\xb3\xbf]\xb1\\H\x8dl\xc7?\xf7\xa5LxG\x90\xf1\xbf|\x07\x10c\xb8\x1a\xcf?\xc1\x16\xac\xb6 #\xf3?\x0c\xd11\xff\x1bo\x03@\x93}\xbb\xd5hh\xf9?|\x0c\xd1;\xd9\x14\x05@\xe3\xc5je\x02\x8e_?M\xb8F\x9a\xb4!\xe9\xbf\xd5T\x04\x1d\x1e\x86\xfb?\x95\\`#\x10_\xf0?\xe50k\x9b@\x96\xda?e\x84~\xc83\x8b\xf7?\x1f\xa7\xd1~\xfdk\xff\xbf`[\xd5\xd3TY\x06\xc0\xaf\xbc*\xea\xd6\r\r\xc0,\xe7\xc4D?/\xf2?\xf7\x0e}i)V\x00@\xf8\x1f\xff\x98(\xd2\xf3?\xd4s-\xacK\xd0\x01@W,\x88L:{\x0f@\xe93\xd4gjt\n@\xd9\x97\xd6\xa1\xb9G\x02@\x8e\xd5~_5\x88\x08@\x0c\x8b\xeaR\xff\x91\x07@tfk#=\xcf\t@\xb1\xbdb\x0c=I\xb0\xbf\xe7\x13\x95X\x18\xa8\xec\xbf\x05d\xdf\xac\xf8p\xed\xbf\xbc\t\x13.\xe5^\xd9?\xc5I\xe4R\re\xda?PP+]u:\xbd?\n\xb9\x9cex\xfb\xf5?;\xfa\x03\xafH\x8a\xcc?\x88\xcc1?u\x91\x12@\xd3\x12\xb5\xfb\xbe\x9a\xff?\xb2\x19\x86I\xae\xd1\xf0?"]8\xb7Z7\xeb?\xddXd\xce\'\xb5\xf9?|\xb5~\xb5Jc\x11@1\x8e [>\xc5\xf3?\x1bI%\xa3\x8c\xb3\xdf\xbfy\xc2\xa5X\xe4\xf8\xee\xbfI\x9f6eP\x94\xe1?\xc0\xc2a\xa4\xa4\x94\xe3\xbfN\x11\xb8T\x137\xf1?[\xdcB\xb2\xcf\xb3\xfe?\x8a\x1eU\x8a\x1d\x9d\n@\xa8\xcc*WdU\x0b@ \xad\xc2U\xcc\xd3\xc1\xbf\x92u\xa4O\xf61\xde?\xbe/\x0c}\xe8"\t@\xf7\xc9\x8f\x9e\x11\x8a\t@d\xfdrEv\xa8\xef?\xfeP\x1d+\x04j\xb3\xbf\xcd\xca\x96\xb6]g\xea?;\x0f\xecg\xe8\xb3\xcb?Y5\x1b}\x88\xb0\xf8?J\x95\x13\x9c\xf6,\xf5\xbf\xda\xd8Jk\xbb\xb5\xe9?\xf4\xd9\x12y\xf3\x95\xde\xbf\xa2\xe7(\xcac4\n@ 3=\x06\x84-\xdf?=\xbc.\x00d\x8e\x00@\xd2\x88\xa6\xf1\xcbU\xfa?&\xeb\xaf\xe4.\xa4\xdf\xbf!E\x18M\xb8\xfb\xf2?u\x96\x8f\xb8I\x0f\xe7\xbf``\xd13\xa4G\xd2\xbf[\xcf9U\xa8\xc9\xef?S<\x8e\x95bV\xf4\xbfE\xb9\x18\xf0\x80K\xd8?\xae\xedv\x10ya\xf6\xbf\xff=\xc3\xf4\x86\xc7\xe1\xbf)n"\\\x13\xe0\xfd?\x02\xa9\xffm$l\xf6?\xe17\x01\xb9A]\xe4\xbf9\x83H\xaag\x12\xe8\xbf\x1c\xdf%\xfd\x04>\xa7?\xa9\x96\xea\xc8\xb1w\xf6?\xbc\xf5\xfe\x8d .\x01\xc0or\xd9.\xc4C\xfc?\x96m\xa1&K\xfd\xd3\xbfR#\xb0\xa4\xceb\xfd\xbf\x92\xaa\xc3\x15\xcbT\xe8?\x14\x9b\x81\xcc\xd9d\xf6?\x16\xdd\xacU\x16Q\xd1\xbf\xbc\xcc\xdc\xf9C\x02\xf6\xbf\xb4\x17\x9d\x99\x99\xe4\xe0?ve\xd5B\xb4d\xfc?\x9f\xa0/\x86\x8bH\xb0?"\x8e\xa5v\x00\xaf\xb4?-\xf56\xed\xf60\xfd?\xfa\xf5+\xd7\xce!\xd1?\xc6n\xbe\x85\x12w\xfb\xbf\x16\xb3}\x99\xc9\x8d\xf9\xbf\xd2\x86\x19V\x84\x15\xe6\xbf\xaac\xc8\xb0ki\xfe?\xb2\xacl@\xd1\xeb\xf3\xbf\xd6\xa4\x82\x16\xb2\x1b\xf8\xbfV-\xab\x89\xfa\x0e\xe3\xbf}\xa9\x9ab\xd1\xe1\xef\xbf1\xa5\xd2\xcb\xbd\x98\xf6?\xc2\xd0\xf4\xab\xbc\x8a\x03@\xf2\x08\xa2\xf2C\x18\xd3\xbfE\xf1-\x16\xdb\xc6\xf5\xbf\xf1\x91\xc9]\xee\xe5\xce\xbfV\t\x8b\xcd\xa2\x8c\t\xc0\xaa\x1e\xd2C7U\xd8?-W\x1fyn\xd3\xd7\xbf\xd8X\xab4\xba\xe9\xc7?\xc8\xb4\xa4\xed\x9eb\xf1?P\xa8\xa0\xbb\x1f\x1a\xef?~\xfd\x17\x1f\x05\xe7\xf6\xbf\x981_\x9d\xc6t\xfd?z\xa9i\xcd\xe4\xe1\xf1\xbf8\x16\x10\xf39\xba\xdf?\x1e?\x08_\xa69\xfb?\xc38F\xf9\x8d\xa2\xd4?\xcd">\xddz\xaf\xe5\xbf\xaaT3\x04\xa3\x18\x02\xc0\x84C\x81@\x89\xc2\xfb\xbfR[\xec\t:\xbf\xf3\xbf\xd3\xdbX\xe3\xb9\x1b\xd2?\x91\xdc\xd8M\xea\xaa\xda\xbf\x01T\xfe0\x9b\x11\xd8?\xf9\xdcV\xc2\xe0\xfa\xd0\xbf*5a^\x01\xe8\xe8\xbf\xc9s5B\x9c\xfb\xf8\xbf\xc0\x89YP\xd2\xfb\xf5?\xb8\x17`\x97\x8c7\x01@)\xaf\x15Xfy\xfe?7\xff\xcfM\xf3\xc6\xcd\xbfS\x08\x18\xa2{\xb5\xc4\xbfh\xb6\xca6\x000\x0b\xc0`\x1b\x12\x15\x10Z\xfa\xbfJ\xb1\nz\xb6\xf5\xe0\xbfN\xa1NK\xa1\xba\xe8\xbf~]0};\xf8\xc3?\x1d\xde\xabHdj\xcb?\x12\x8c\xbe*\x87}\xb0\xbf\xa5\xdd\xd7|V\xfe\xc8\xbf\x03\xf8xD\x03\x15\xef\xbf\xad|\xed\xe1\xde\xa7\xd6\xbfO=\xc7r\xba`\xe6?4O\xbb\x86a\xce\xfa\xbf\xbep\xbbd@:\xf1\xbf\x00\x18!\x7fv\x81\x02\xc0\xc6T\xd5YG\x01\x05\xc0f\xc3\xc2*\xf6\x04\x0f\xc0|\xbaY\xba6\xf2\xf3\xbf\xa6`z;$\x8e\xf0\xbfc\xfdE@\xc2t\xf6\xbfZ(\xe6\x9fN$\x01\xc0\xd6\xb3\xb8Qg\xba\x01\xc0H\xd0\xdc\xff\xc7\x83\xf4\xbf\x1a\xd2S\xd5\xf4]\xf6\xbfd\x072{\xe2\xc8\xed?\x08\xca\xcb\xb3\x12\x1f\xf8?\x86\x85\xd8\xb1\x87k\xf7\xbfwH\x19\x92\x87>\xf2\xbf[\xb7v&\x93R\x01\xc0\x99\xa7\xa4\xed\x94\xe6\x07\xc0R\xb6R\xd2\x0b\xe9\xe9\xbf\xd8\x9e\x11~\xddT\xfb\xbf&\xcf\x10\x91\xf1\xdd\xa1?w\xd5\xfe\xa5\xcd\xa7\xd7\xbf\x01\xf1\xc4\x7f\xf0\xbd\xc9\xbfB\xb4\x1b\x06\xc9(\xdc\xbfo\x9b\xe3\xcdaQ\x03@n\xec\x90\xcc\xfd\xcb\xd4?\xb1\xa1\xf4\xa0\x85P\xf4?\xad\x93\xfa\x1f\te\xcc?\x9a\xd3\xaf[j\xf6\xeb\xbf\x95Y\x06\x03b\xc3\xc5?h\xcc0l9\x13\x08\xc0\x17-\x1a\xd9\xdb\xf7\xfe\xbf\x8f\x85\x82g\xf3:\xfb\xbf\x91\x80\xf2\x91/\xa9\xea\xbf\xce#\x0f\xac\xd5X\x04\xc0[K\xc6\n\x82X\xd3?acsg\xe7\x9e\xe5\xbf\xa3\xfc]\xb9\x9d1\x03\xc0J;\xa2\xa8\xe3f\xd5?\n.\xf6UD|\xe7\xbf\xdb,\x12\xbc\x14\xb7\xf5\xbf\xaa\x0b\x12\xc5\xde\x13\xe6\xbf\xabCJ\x9f\x91x\x05\xc0\x15\x1c\xa7e\x1cs\xfe\xbfU\r\xc1\x8f&\t\t\xc0\xa14})\xffw\xf9\xbfr\x86\xd8[F\xda\x0c\xc0k==\xd6\xf0\x9f\xd9\xbf\xa0&\xb0\xfd,\xea\xf1\xbf^\xd2\xbb\xea]\xc2\xad?\xc4\x9b\xe4\xa6>\xe1\xd8?kt\xe0\xfcb6\xd0?/\x1f7M\xcao\xe3\xbf\xf6\xd4E}ZS\xf1?\xa9\xe1x\x0f\x95\xbe\xd2?\xc7]\x1b\xf0\xd5\x8e\xd8?\x99\x97\xc6\xf8\x0c&\xf5\xbf\xd9\x93i\xc6\xb8\xd9\xd5\xbf\xbctQ\x8a\xa5\x80\xfa\xbf\x02\xf9\xe3Cn\x8a\xf6\xbf\xc1S_V\xe0\r\xf0\xbf\xd3\x83\xab\xf6AM\x00\xc0\xb1\x18\x99\xfd\x8d\xb1\xde\xbf\xe1!\xfdw\xa5 \xc6\xbf\xf9\'\xdf\x16\x86\xfe\xe9\xbfJ\x96\x01sea\xfe\xbf\xe2!\x1c\x06\xa8\x98\xe1\xbf\xb2+\xf1\xc9D\xcf\xf9?\x8e\xa4\x01q\xb4\xad\xfb?pS\xbb\x85\xfc\xf2\xe0\xbf\x9f\xbfv\'\xe2O\xf4\xbf\xc1u\xa5h\x0f#\xe7\xbf\xbf\xb9\x81\xd5\xc2*\xa0?tn\x98y\xa86\xf1\xbf)\xc0\xf8\xb5Z\x84\xd8\xbfiB\xcc\xa3\\\xb9\xe5\xbf4\xa1mV&\x1d\xdd?\xbc\xe5\xb9\x15 \xa4\xe3?\xa7\xd1}\xa6WQ\xf5?\xce\xc0u\xc7\xcd%\xc5?)f6\x01z\xba\xf0?\xad\\\x89?\xc2e\x85\xbf\xf6\xa5Yf\xcd\x1d\xfc?.\xcf\xb7\xe7\x11q\xc0?\xe6Xg\x84"4\xfa?\x18\xde\xfe\x0b|\xa6\x02@\x0ccl\x97\xfa!\xfc?\xf36}|\x8fF\xea\xbf/w\xbc\xeb\xbd\xc0\xee\xbf\xd8\xcf\xf8\x9b\'\t\xfa\xbf\x82-\x99\xb0\x8a(\xe3\xbf\xae\x1f\xf8\xd6\xae\xa8\xf5\xbf\x9f\xbeD\x9f1\x99\x0e\xc0\xc6\xb8\xd6<\x06\xdf\t\xc0g\x13\x86X\x9c\xa4\xf6\xbf\x08.\x97\xff\xbb\xd3\xcf?\'\'$\x7f\x132\xf3?\x94\x17D3\xaa\x16\xf3\xbf\x08\xbeDKH\xb6\xe0?"\xbf\x10dO\xf1\xd2\xbf\xb0=\xb4\x07Al\xe5?\x9e\x08uiW\x7f\xf0?\x00\xa6\xdc\xc5\xa0>\xea?2\xa6\xfa\x19p\x08\xd7\xbf\xfc@\x96\xf8\xe1k\xe6\xbf\xbd\xe3{\x1c\x16\x1b\xe2?\xa6\x99`\xd1\xa9\x93\xf2\xbf\xf8\xa0 .t\xe7\xe4?\x02\x12\x15].7\x00@\xc5v\xab\xd38\r\xff?\xee\xef\xab\xad\xdbT\xfd?\xdf\x8et\xd1\xa6\xe2\xd7?\xc2\xbe\x9d\x10\x05\x83\xea?\n\x8bm\xa4\xcf%\x05@,\x88\x90\xdbv\x13\xf9?H\xf5=!\tL\x00@\xd8\xa6\xd9\xfdA\x8a\xe4?\xd8\xec#\t\xeen\xf4\xbf\xd0^\xe3\xdaX\xd9\xe2\xbf\xf1\x04D\xca\xbf8\xe7\xbf`U\xee[\x94N\xd0\xbf\x80\x99\xed[\xb9\xa9\xf4?s\xf6\x05\xcf\xe4\x01\xec\xbf\x18f\x89\xc0(\xfc\xe2?\xa4\xe0\x98\xd6:\x94\xd6?\x85\x17@\x8b\xed\xc9\x01@W\xc0\xd1\xd6\xd4\xb2\xe4?\xbc\x89\x9ax\xd4\x13\xf5?\x105.\xaf\x9b6\xd5\xbf*\xf1lI\x06\n\xbb?D\xdb\xf2\xe6\xda\xe3\xa9?Z\x93MD5\xee\xec\xbf\xaf\xa6m,\x02\x00\xe7\xbfn\xe8W\x8d\xf0\x1d\xd4\xbf\xf4\xc0V\xd7Tf\xc6?\xa9^H\xd0\xfc\xbb\xcf?xH\x17P\xbb[\xfa?2\x01\xd4\xa2\xf6V\xb0\xbfu\x97F_\x86\x19\xc9\xbf~\xab\xe1\xe5\x08e\xae\xbf\x0c\x91T\xac\xfaB\xf8?\xb1,s\xca\x17\xce\x01@}\x8co\x8c\xbb\xb2\x03@\xcfhq\x9a\xc0X\x06@\xa0\x04L]\xc1W\xe5?\xa1Ip\xdaZ\x13\xf6?\xe2\xacph\x8a\xe1\x04\xc0\xfc\xfb _\xc2\xbb\xeb\xbfs\t[\x0c\xf7\xd9\xf7\xbf\xa0w\x08\xe5O\xae\x08\xc0\xa0\xc04b|\xd2\xea\xbfK\xb3\x00/&\x1e\xe7\xbf\xefz\x9a\xcdI\x1a\xed\xbf\x11\x05\xc22O\x9b\x00\xc0\x10\xa1\xe5\xae\xf7$\xf7?p\xca\xe0\x81p\x1c\xe6?t\x99\x9a\xda\xd3\x9f\x04@\xb9\xc9(\x08\xfd\x9a\xfa?\x1cCrP\xe4\xa2\xe7?^\xd6C\xba\x8e\xba\xe0\xbf/nU\x18\n\xcf\xd9\xbf\xd6#\xe7\xf1\xe6\xb7\xd9?\xd6\x93\xdf\'\xa3\xd5\xef?\x84\x03\x809x\x9e\xeb?7-\xed<\x86\xdc\xe7\xbf\xef=\xc2\x8d=\xe6\xe2\xbf@R\xbf\xd1X\xfc\xe0?/\xc1!\x8d\xfc\xa1\xf0?\xee\x16\xcd\x08=Z\xdc?\xbc1\x8a\x17!%\xed?\xab\x19#\x8b\xa0\x0f\xd5\xbf3\xd6,A\xf6t\xe3?\x12\xa1\xb0Q\x19\xba\xd8\xbfV\x81\x05(\x9d\xc1\xf1\xbf_\xf7\rp[V\xbb?GY\xc6\xa9e\xce\x01\xc0\x07\xbf\x10\xe0um\xea\xbf-\xe6\xa1m>6\xea\xbf\x03\xd5\xc79\xe5\x90\xf4\xbfA7\xd3\xb2S\x94\xe6\xbf\xe4\xb8\xe9#\xe9\x9b\xe3\xbf\x15\x0f/\'~\x19\x02\xc0\xdem\x89A\xc7\xe1\xde?\xc4\xb2\xb3\x15\x80\xae\x00@\x1f\x04dz\xf1h\xff?[\xf91\xcc6q\xe0?\\\x16\xf5\x95\x88\xff\xd8?\x1df\x94v\xc9\x1b\x04@g\xe2Nq\xdb\xe6\xd4?\x86\xd7\xb1o\xd5\xe4\xd2\xbf^1\x0bG\x1f%\xd1\xbfm\xf5P\x11e\x14\xc0?\'\xb7\xc0\xadQ\xa3\xe2\xbf\xc7\xcbu\x9d\xc8\x9a\x00\xc0X\xcf\x9e\x06\xef\xda\xe2\xbf\xfc{\xf5\xfa\x19\xda\xd4?\t\xd4\xec\x18\tW\x02@\\\xa9\xbf\x81Vs\xfd?(\xd0|\xa1\xea\xcb\xfd?\x8a\xd7f0\xde\x9c\x00@\x08\xc35\xcf4\x02\xfc\xbf\x9b\x8d\xe4%\x1bZ\x07\xc053\x06\xcdG\x88\xc2\xbf}\xf9.\xa9z\x97\xd4\xbf,\xae\x85\x8e\x9ce\xf5?\xb7\x0b\xce\x16\x9d\xe6\xb0\xbfbI1\xa4\x84\xdc\xf8\xbf\xc2\xdf\xf0E\xda\x81\xe8\xbf\no\xdd\x9f\x0f\xe5~?\xa2R#\xca\xbeX\xff\xbf\x93\x14\xd9P\x18\xfc\xc3?\xa6\x94\x84\x14\xa9\xcb\xe0?\x19s\x91\xa3\x1e\xbd\x06@o[X\xfd\x93V\xf0?\x94\xc3*\x04)g\x02@\xfd"\xe2\x1a|\xf5\xf6\xbf\xf4^\x87p%\xd5\xe1?\x81\x93\x9dJ\x98D\xd0?\xbe\xc2&\xdag!\xe1?\'\x05\xf1|hz\xe2\xbf\xf5cm\xcef\xcf\xf0?H\xc7\x1d\xe6\xdb\x7f\xea\xbf(\xe1\x08\xb2X\xdf\xfe\xbf\x91\xba%\xca.\x00\xdc?\xb9?\r1?S\xf1?\xa4\x8b\xff%\xb8\x1a\xd4?\xe1\x97\x94\x1d\x12\x0c\xea\xbf:\x02=t\x81\xb6\xde?\x0f\x0fp\x99-h\xf6?\xcc\xb9\x0f\xd9$|\xcc\xbf\xa0\x14\xd2\xa38\x9c\xe7?O\x84L\x08\xb0\xfb\xe0\xbfjZ\x8eGl)\xfc?\x1cu\xdb\xaf\x8e\x04\xd7?\xa4%\x12\xd6\xc5\x11\xf6?WD\xc5\'\xb4>\xe1\xbf\x96,\x9e\xd8\xba~\x07\xc0\xa9\xbc\xa7\x9ek\xc9\xf9\xbf\x8e\x06G\xca\x82m\xef\xbf\xb0\xb5\xee\xb4\x98\xf0\xec\xbf\xa8\x94\xd8o\'\xc0\xb9?)\x0fh\x01\x87s\xbc?\x99\xce\xa9\xa2\xfc\xd6\xe4?\x18\xc6\x92a\x1a\x0e\xee\xbf\x90p@\xb4ic\xf9?\xd9\xbe\xb3\xfdWR\xec\xbfA`dS\x17\x12\xe5\xbf\xec~\x1d\x9b\xc1\x82\xd1\xbf\xc1\x13\x08*\xa5n\xd7?\xc8\xd8ox\xb2\x95\xab\xbfi\xd1f\xc2\xacL\x01\xc0\x8cp|\xcb\x08\xab\xf6\xbf\x80\xa3E<\xf5\xb5\xe2?=\\\x03\x86\xdf\x00\xee?c\x9dO\xc6\xceJ\xe0\xbf\x12\xc6@\x13$\x82\x06@8\xc2jX\x95\x9a\xf2?\x1bc\x01x\xdb\xb7\xcb\xbf\x82z\xdc]a_\xf2?\x8bS\x8e>\tr\xff?"6(\xd4\xab\x8f\xe9\xd1?D4\x8d\xabcm\xf6?\x11\xb6\xba\xc4\xe3\xe5\n@\xeci\xfb\xb6D*\xfa?\xd0\xa4\x8f\xaf\x83l\x05@\xc05\xc1\x8d\x83Z\xf0?"\x0f/\xd2v\x05\x00@\xf2T\xedP\xae\xb6\x0c@\xd4\x96:\x1c\xce2\x05@\xcd\x91\xe7id*\x03@\x94\x1d\xf0\xc4\x8c\xe1\xe1?\xc6\xa8\xfb\xc3K\xbd\xff?\xc8s`\xb5\xe9\x14\xf4?\xf0\xe2\x08\'\xdf`\x02\xc0qU\xee\xd3\x82|\xea\xbf\xc7]\xa2,\xa44\xe5\xbf\x1f\xe5go\x88\xcf\xf6?k"\x12\x9e=\xf0\xe7\xbf\\8#\xce\xd6P\xf8\xbf&\xec\x90\xd5\xd2>\xf7?W@\x96u2\xf1\xdd\xbf_\xec\xeeF\xc8\xf3\xe4\xbf\xa7\x89\x88\xf8e\xda\xc7\xbf\tn\xef\x85kk\xf6?\xc0>\xacu\x9c\x97\xad?\xcc\xee<\xa0\xc5\xc1\xee\xbfn^\xf5fT\xeb\xe0\xbf@\x8fU\xe5\xb6`\xc3\xbf\xf7\x01\x8a\xe42\xcd\xa8\xbf\xc9\xb2\x1c\x13u\xdd\xb4\xbf\x82x#\xc7?\xf1\xd5?W\x89\x05\xff\xf8\x07\x01@\x1b|A\xd4\xf0\xd9\xee?\xe2\xa8\xf2L\x7fk\x08@\xfa\x12-\xdb\x17>\xcb\xbf\x1f\xcfL\x9c?!\xff?>\xabv\xb3$O\xf0?$l\xa5XZ\x89\xea?1Hf\x10\xbd^\xbf\xbf\x1f\xb6\x1e@\x80q\xc6?\xb6{O\xb7xv\xe1\xbf\xeb2\xbbX\xdas\xeb\xbf\x1c\x8f\xe7\x18j\xac\xdd?\xbd\x98\x97\xb1\xbd\x19\xe5?\x81\xe1?b3\xef\xe8\xbf\xaf\xbfF\xf6\n(\xf0?X\x8d\x16c\xf0\x15\xc5?\xd2X\xbd\xd2\xa2W\xe8\xbf\x85n:n\xf1\xf3\xf7?\xb8\xf3\xc5*d\xd0\x01\xc0\xd7J\x061uC\xc8\xbfH\xcb\xd0\xe5\xc1\xf5\xd7\xbf\xd2\xd1\xc1\xfc5\xbe\xe5\xbf\x97FG\xd7\x04D\xf8\xbf\x00\xb6\xfb\xec\x85%\xf4?\xe3\xfbm\x10\x08\xd1\xe5?\xbahY\xd4\x91\xb4\xf3?Y\xfb\xea\xcf\x93k\xee?\x1a\x9c\xac|9\xfc\xdf?\xd5\x04\xa0j$F\xb3\xbf\x0c\xf8\x1bJ\xda\xd0\xfa\xbf\x02\x07\x94\x1e\xf9\xd1\xfe?\x0b\x11A\xe9\x14\xde\xf1?JK?m\xed\x80\xf5\xbf\x80\xedS|\xba\x13\xe4\xbf?\xf6\xa1I?\x82\xda\xbf\xd9\xf7\x10\x92\xdb\xfa\xe0\xbfA\x9d\x95\xbd\x1f\xe0\xe9?\xc9\x9c\xa0\xb1S\xc7\xe0\xbfP\xa9|\xfa\xad\xbd\xe8\xbf|\xb4V\\\x04W\xe4\xbf\xad\x9cs&\xf2\xfe\xd2\xbf)nX\'\xf5v\xd0\xbf\xab\x91\xceFJ(\xf9?0\x05v\r\xfe/\xf1??|\xc4\xaa\x12\xdb\xe7\xbf5\xcb\xbd\\\x1b\xbc\xcd\xbfW\x04\xaf\x94.S\xe2\xbf\xc6E\x16v\xb6q\xf3\xbfa\xbc\xee\xc8\xfem\xf8?G\n\nP+a\xb2?B\xb2\x9c\x1a\x13\xa5\xf6\xbfqZu\x8b\xfa\xe2\xfb\xbf\x0cQ_\xc3\xd0F\xd1?S\xf6\xb4\xb8"\xbc\xf6\xbf\x9aE\xce\xf1U\xf8\xef\xbf+0p\xeb\x9c\x1c\xd1\xbf\xcd{.\xc6\xe9\xa5\xd9\xbf\x8f\x81\xd7W\xdd\x9c\xe2\xbf\xc6\xfb\xdc\x8av\x9b\xcc?\x94\xfa\xbc\x05@\xa5\xcf?\xd4\x93\x16;M\x9a\xe3\xbf\x9b!\x1d\xf30\x90\xc3?\xefY\xbc\xf2R\xb6\xe2?\xcc\x1e\x11J\x14\xc9\x00\xc0j\xe4^\x13\xf63\xf0?,\x95\xdcB:|\xe0?Q\x07}\xd8NU\xe2\xbfm\xf5\x8a\x02\n\xa0\xfd?`\x11\x03NSm\xd2\xbf\x1d\xa7\xaeZQ\xf0\xb5\xbf\xc8\xfb\xd6\t\x0b\xe6\xf2?\x98\xea\xfe)\xda*\x01\xc0\xc1\xe2@\xf3\xf0\xaf\xdf?9\xbf\xec\xd6\xbf\x01w?7\xe8i\xd9\x168\xe0?\xcb\x80]Jj<\xbb?\x90[\x9a\xb0}f\xa9\xbf9\xcf\xe7\x8e\x00\xeb\xc6\xbf0\xabz\x10\x0ct\xe6\xbfbvEO@4\xf0?z\xee\x1a\x7f\xe7\xf9\xfd?\xe2\xfc\n\xdf\xdf\x96\xf2?u\xffb\x9e4B\xe9\xbfU\xcd\xc0\xa0\x9e.\xc9?=\xc07/N\xce\xd8\xbf\xf9?\xc9\x8d\xbd\xf7\xdb?$\xf0\x14R\xc9\x88h?\xdf\x10\x99\x07\x9fn\xd7\xbfl\x9aZ"\xc4\xdf\x02\xc0\x81\xdf\x9aD\t}\xf0\xbf\xf0\xb2\xba;\x1c\x00\xd8?\x00H\x86\x7f\x9b\xed\xf7?\x06\x15\x8c\xd22=\xd9?\x7f)\xe3/9\x9f\xa2?S\xdd\xc9K\xa3\x98\xf8\xbf\x88\xd2\xcd$i\x04\xe0\xbf\rhN\x96\x8d\xa5\xee?g\x024\x1f\xd6\x81\xe1?,\xd7\xbd\xbf0\x00\xe0\xbf\xb3\x0f\xa9\x87\x17\x19\xe1?@e\x89N\x8c\xb1\xd6?\x9e(O>!\xee\xdd?+\t\xde\x99\x12h\xe5\xbf\x9d!\xac\xebDY\xe3\xbf_\xdf\x8fS\xae\xfa\xef\xbf>]_H^\xc2\xfa\xbf\x03>\xc7\xce \xc6\xe8?\x03.\xe2\x91\xe2\xec\xd3?\x0f\xef\x82Z\x8c\x81\xc2\xbf\xaey\xf0^1\xa9\xc7\xbf0\xb3b\x952\xe8\x00\xc0\x1a\x1d\xbe\x10\xdd\xb1\xd4?_\xd6\x99\xd5\x8a\xf1\xda\xbf\xd50\xc5W\x94^\xbf\xbf?n\xf2,_\x00\xde\xbf\x87\xb5\xf5>\xaf\r\xe6\xbf\xbc\xea\xc1\x82\x8c@\xcb?"\xd8<\xcad\xae\xd9\xbf#O3.\x1a_\xf0?\xcb[\xa8\xb95\x9b\xe6\xbf\x86Tr\x9b\x19\x8e\x01\xc0\xab\xa2\x81\x08\x03\xbe\xdc?Nq>c\xf3\xbf\xf4?\x7fZ\xde&\xbec\xf7?\xe6\xf9\x98\xe9\r\xd1\xf9?\xde\x9bFx\xec\x9c\xf3\xbfg\x9c\xe3\xf4)\xb4\xec?\xec\x8a\xa7\x01\xaf\x82\xed\xbf\x85\xb75\x06\x91\x95\xd2\xbfq\xd2\x8b\xa5\xe4\xc4\xf3\xbf.GG\r\xaer\xea?J/\xa1\x1c\x88q\xe0?\xe4a\xa2\xb3\x97\x7f\xf7?\xa1`\x803D\x90\xe8\xbfM\xf8I\xdb\x04*\xf3\xbf\x84\xb9U\xfe\xf3\xcd\xf9\xbf\xe7\x92\xbf)p\xb1\xac?\x1fnn|\x0b\x80\x05\xc0\xca.O\xa6&\x10\xd2\xbf9y\xb1\xd4\xb2>\xf0\xbf\xc5\xe9\xe0E\x1e\xef\xc1\xbf\xbe\x9c\x16\xee3\x1c\xe4\xbf\xde\x89q\x08_\xf0\xf0\xbf\xc0bt\xc5\x90A\xf8?*\xd0\xa5\x0fK\xb0\xf7\xbf\x1f\x93\xe3Lt\x94\xd7?\xbb(\xd3\xfc\xe4\xcc\xf1?K\x93\xf5{t\x1c\xf5\xbf\x01\xeeg\xf2!7\xf8\xbf`\xe6\xfeb,\x05\x01@\xfb]L\xf5A\x15\xe5\xbf0\x9a\xac\xf5?\xa5\xe2?\x88\x92h\xb1\x9d\x92\xaa?Y\x15$[<\x18\xfe?1\xe6\xee\xa0\\z\xa6?\x99-\'\xe8\x01d\xa8\xbf\xb0\xbd\xb6V\xffA\xf3?\x16\x85\x9ei]\xa1\xe7\xbfO\xe4\x89\x8b\x9d{\xed?\xfa\x86iJ\xf1\xd8\xf5\xbf3\xdc\xe8`q\xd8\xc7\xbf\x92\xe5\x1c\x7fGh\xf4?\xc9u\x84\x7f\x9d\xe7\xd9?o\n=h\x82>\xf3?x\xfax\xc4\xe4?\xe8\xbf\xed+p\xe3\xacX\xf7\xbf\x1d\x9e\xa9\xeb\xdf\xea\xdd?\x0b\xcd\x82\xc7\xc8 \xf0?\xa1&@\xce\x13\x8a\xf3\xbf\x90\xd7\xc4H\xd5\x03\xf0\xbf9:\xca\xb5\x16\xf3\xb6?=e\\\x07V\xf1\xee?f^\xc6\rM\x8f\xe2?\xe7\x04\xb6\xb8M:\xe3?\x96\xd9\x92%\xe1\x92\xe5\xbf\\o +\xa0\xa9\xf4\xbf\xa0\x1f\xc5\x0c\xfb\xf7\xe0\xbf.N\x92\x10\xc5\xdc\xf0?\xcc\x11\xfc\x07d;\xe8?\x91\xd0\x82\xb3\x05K\xe0?\x88\xe7\xae\xd53X\xf6?nb \x1c\xebu\xf9\xbf\x0b\xdc"\x9e\x8f\xd9\xe9\xbf\xe8\xb2\xea\x18\x993\xe6?\xa1\x1c\xb5\x11\xb1{\xdf?h\x00\x11\xe0\x05\xe8\xd5?\xd5\x8a\xc1F\x0e$\xed?\xd0\xf0o\xfdD<\xe5\xbf\x87z\xf5:\x95S\xfb\xbf\x8cwg\xfb\x96S\xb1\xbfg\x97\xde\xfb0\x11\xea?\x08\x07F\xe2\xb1_\xf5\xbfRD\xb4\xf9]_\x08\xc0\x85+\x87L\xd7\x19\xf9\xbf\xea\x93R\xab\xce\xeb\x04\xc0\xba\xe8\xbb\xd9\xa8\x1f\xfc\xbf\xd3\xb5\xd8\xe4)\x99\xd1?\xb1\xea\xc4\x12\xbd\x85\xca?1:\xa4\xb4\xbc\x90\x8a\xbf\xab\x9eI!\x1d\n\xf5?\x02\xb4\xecx\xd5\n\x01\xc0;#\xd6$]\x8b\t\xc0\x94\xab\xfb\x04@K;\xa2 A\x1e\xd5?\xee@">\x03\xba\xe9?\x1ax\x9d\x0f]\x99\xf6?f\xe7M\xb6\xc97\xe1?J\xfd\x94P\xbch\xe5\xbf6\x01\xc3\xf5\xfeV\xb7\xbf\x03\xbcK\xdf\x0cy\xf2?W\xe3\xd3\x03m\x10\xe1?<&\xf0\xc6\x16\xef\xe4?\x91\nW\xeb\xb6\x0e\xd7?6\x99\x982m\xc1\xe2?]p\xeaC\x0c\xb3\xd9\xbf\xea\x8e&\x05\xd5\x1b\xe8?K\xddxX\x15\xe6\xd1?\x9a\x15,\xc5\xf4\x84\xab?RO\xed\x1b\xe1\x12\xfe\xbf\x82r\xf2\x06&c\xee\xbf,\x82*\xd8\xb7H\xe6\xbfs\xa0%\xdeh\x89\xed\xbfc\xb4@5\xc7\x80\x02\xc0w\xcb\xbc/VU\xd8\xbf\xdd\x8d\xd4iZ\x7f\xbe\xbf}mo\xc1)Y\xf1\xbf\x0e\xb9n\xe2\xff`\xc7\xbf\xa5\xba&\xdf\xcf\x9e\xf5?\xc9O\x1et\x05\x8b\t@q\xa3\xa3\x00\xbf%\xf8?\x9eL%bT\x8c\xf9?\xae\xeb\x99[\xb8\x90\x0c@\xb9kkI)\x03\x10@>\x15\x05\xabt\x01\xfc?\xd7\xb6DX"}\xf3?&\xb8\xc7\x8a:\xec\xe2?\tW \x8dc\x1b\xb0?\xdd\xa2\xff\x909p\x02@V\rz3\x84\xe8\xf7?\\\xe3T\xcb\xd8\t\xf6\xbf\x80 !K\x93\xa2\xf7?N\xc36\xa4\xb8\xb9\x90?n\x89Z4\x079\xe3\xbfz[\x7f\xab$:\xee\xbf\x9e\x9f\xdc\x7f\xb8\x9b\xdb?R|\x0e\xb2\xc7\xe7\xd8\xbfT\xb2\xeb\xe8\x94\xd2\xf5\xbf\xd2ds\xd5\xd8\xee\xdd?\xf6r\x94\xbb\xa1\x9b\xe1\xbfMr\xad7)[\xee\xbf*\x19\xf0\xff\x1c\x9e\xdf?c#N9\xce\xdc\xe3\xbf?\x8d\xff"o\xac\xfb\xbfX\xe36\xf6w4\x08@X"\xc5E\xca\xb8\x02@|\xb3\xd6}\xe1v\x08@^\r\x9a\xe2\x0fT\xe9?\xa8\xcc+\x8f?\x0c\xe0\xbf\xa8&Qy\x92\xf3\xdf?\x009t\x1e|5\xf4?.\xae\xe5\x1eT\xa0\x04@\x7f\x1d\x1b=\xc2P\xd0?\xaf\xb4Fp\xf4(\xe2?F\x99vr\xf9\xdb\xe9\xbf/#\xbf\xffq\x80\xc9\xbf\xa6W`\x02\xa2U\x07@\xa8\x072\xd9\xe7B\xea?$\x07\xda\xff\x86\xef\xe3?\xf1T\xf0SC)\xfa\xbf2\x9aT^\xa4o\xae\xbfP\rek\r\x06\xea?\xb8\x8eo\xee\xa7\xc2\xcf\xbf\xebp\xf1\x92\x15@\xe8?\t\x02!^vv\xdc\xbfh\xd3\xb6D\x1a8\xdd?\xefK\xde\xd6\xba\xce\xd3\xbf\x1a\x85K\xe5\xc6\x1e\xd5?;\xbb\x17\xa6\xa9\xec\xf8\xbf\x11\xa5h\xd3\x88\xcb\xe5\xbf\x81\x93_)\x03\xf1\xdd\xbf\xc6@)\x91\xfa\xdc\xd6\xbf\xbc\x10#\xa9\x808\xeb?\xc8>\xdb\xca\x9dZ\n@n\xb2jRq\\\x10@;\xff\xa5\xdd\xf5\xab\xf7?o\xbb\xd5\x11\xb0\xc8\xfe?J\x0f=\xac\xbf\x87\xef\xbf\x8cd\xcfC6T\xf9\xbf&\xfaI\xfa\xad\xb2\xef?\xd5\x89\x1b\xa6d:\x04@\x04\x05\xab\xcdd \x10@\t\xb8\xefh\x94\xb9\x01@\x96\xd92m\x12K\xf8?\x82<\xd8)ei\x0f@\xea\x05z\xde\x95y\x05@V=\xfc\x9e\xb4\xa9\xc9?\x94F\x00$h\x1a\xef?\xb7v@\'!;\xf1\xbfG\xb4Y\xabW&\xd8?~\x8e\xc8\xa5\xb9\xd5\xe3\xbfVHc>t\xb0\x99?\xcbd\xa4p5\xd9\xd8\xbf\xe6\x10\xd8\xa6\x84\xa9\xd2?\x04\xf0\xf5m\x1b\xdb\xf4\xbf\x0c:US\xf9,\xf2\xbf\x1d}t\xb7\xbb\xf2\xf0?5\x03\xa9\x8e\xd5\x85\xa2?\x92\xc96Z9\xf9\xf1\xbf\xa8\x01\xd1We\xe8\x05\xc0\x04]\xc0h\x90\x9c\xf3\xbf(\xc5s\x9a\xf6\xf0\xf4?B\x009\x8e\xe0\n\xd1?\x8c\xf9HJ\'\x9e\x07@n\rv7f\xd5\xe0\xbf7\xd8h\x1c.\x07\xf4\xbfgO;Y"\xd1\xf0\xbfS\xa7\xe4-\xc2C\xd4\xbf(Yb\xf2\xbc\x1d\xed\xbfc\xb8O\xc5\x82r\xfd?Z\xe6\xc9\xd0\xe5:\xfd?\x00v\t\xf6\'g\xf7?\x88$\x0c\x1b\x02k\xe3?\x05$\x14\xf3H\xe8\xf4?q\x89!b\xa3c\xe2\xbf\xdd\x13\xf2P\x14\x02\xd1\xbfqT\x14Y\xf1\xfa\x01\xc0\xb4\x9b\xcdX\x0eb\xbc?\xb8\x00kwfb\xfe\xbf\x99\x98\xac\xc3\x9e4\xdc?A|]\x16\x02Y\xe5\xbff\x86\xccO\x03\x1a\xbc?\x13\xa1\x03\x1a\xba\x93\xe4\xbf;(\xed\x8c|\xd3\xd4\xbf\xb3\x15VnN\xb3\xe7\xbfl3\xd1\xa8x(\xe0?\x96:\x19r\xe30\xea\xbf\xab\xf3\xb2\xbb\xcad\x08\xc0:`\x836[c\xcd\xbf\xae.\x08\xb1n\xef\xef?p?\x85|Z,\x02@\x02\x9fe\xb3\x81\x89\xf4?\x98\xe7N\x93\xf6\x00\xf6\xbf\x19\x91`\x130\xef\xf8\xbf\x9a\x98\xfa\x9cC\x80\x03\xc0Ql\x94\x02\x15\x17\xfc\xbf \x7f"\x92\x95V\xdd\xbf~\x19$\xd3\x16\x1c\x08\xc0;\xb1ik1\xf3\x15\xc0\xf3\x80p\xaa\xa4\x92\xfa\xbf\x9efU\xf6\xceB\xfb\xbf\xa7\xbdK\xe9\x19$\xf9\xbf\x15D\xa1\xb3{\x0b\xe7\xbf@\xe1f\x1du\xca\x9d\xbf4\x07\xbd\xac\x001\xe0\xbf\xc4\xbb\x8eyT\x90\xdb\xbf\\i\x8d\x16<3\xda?\xeb\x06U>\xd6X\xe3?\xb2.\x06\xe2O\xec\xe4\xbf\xc7k\xbf\xbf\xe0\xd9\xd6\xbf\xb7p3\xa3\xdd\x02\xff\xbfz%+\x05\xb8\xab\x02\xc0\x878\xc8\x84\xab\xde\xd5\xbfa\xc4f\xfdz\xf0\xe1\xbfz\x81\xae.\xf8x\x00\xc0\x0b\x87\xde\xae\xac\x12\x0c\xc0\xd4\x9f\x0ff\xec\xb3\xe4\xbf\xe87t.\x8c~\xe6\xbf\xe7\x1a\x01\xa6<\x9e\xed\xbfh\x95\xd5\xf7xL\xf3?\xf1\xeb\'Z?]\xbc?\xb4bPs&\x06\xdb\xbf\x8bR*\xc9A\'\xfe\xbf\xfc\x80\x93\xd2r\x07\xe3?\x9b\xb5#|\xc3\x07\xf6\xbfx(\x1dO3\x89\xf0\xbf\xda\x00\x1c9\x0f\xa9\xfa\xbf`\xcf\xd9\x07k\x8f\xfd\xbf\xf3\xcc.\x8a,\xb1\xf9\xbf\xb2\xb9\x0e\x9ei\xeb\xf0?\xed\xb9"w[\x03\xde?\xcc\xf9\xfd\xe9\xe6U\xc4?)\xd8\x1dA\xc5\xbf\xb3?\x8f(M\xb7\x198\xca\xbf\xfc\xe8\xc5a\xe1D\xe2\xbf\xd2;\xa7\xa1%\t\xe7?\xca\xfe\xc1\xbf\x14?\xf0?\xd5\xb2\xf5\x0b\xbc\xec\xf9\xbfN\xb5\xbb\xfdZR\xf1\xbf\x15`\xa7\xe1\xfdI\x81?\x82oY\xb4\xda\x83\xe1?/_\xf6K|\x00\xfd\xbf\xc3R\xebT\xa2M\x01\xc0\x87\xe4Z\xc8p\x9e\x0c\xc0Co\x19\xc35\xb2\xea\xbfL)|\xe5\x8c\xa2\xf7?\xe7\xdf\xd8\x89\xd9n\xeb?\xb9\xca\x05\x00\xea\x8e\xf9?v\xe8\xa26#\xee\xf4\xbf"\xe0pN:\x86\x04\xc0\xb6-\x88X\x02\xe5\xd3\xbf\x05\xb4\xba\xf2\xab3\xec\xbf\x03\xfb\xf3({m\x01\xc0\x9aS\xc8\xa7\xaf\xcd\x00\xc0\xaf\xc0\xe9uU\xf7\xec\xbf\x1d|cX\x1d\x81\x00\xc0\xdf\xd3r\xca\xc1\xeb\xd5?\x02\x10~\xd2x/\xf7\xbf\xdfm\t\xa8\xb7\x9f\xe0\xbfa\xc0\xd2\x03Z\xfb\xe2?\xaf\x02\xdfr\x98]\x02@\xd5BD\xe5\xccX\xc8\xbf7\x16ij\x82\xff\xf4\xbf\xe0\x8f\x04qYL\xd0?ct}\x1d\x99\x0c\xf7\xbft\xee\xd2_j\xd3\xf5\xbf\xb5\x98T\xf0=\xee\x00\xc0\x9d\xc4t\xb6X\xf8\xe3\xbf\x7f\xd5vk\xf2\xb5\xfc\xbf1?\x12\xb5\xf5\xe3\xe6\xbfB\x06\xee\xa9b\xe9\x03\xc0\x80WU\x9f%\xeb\xfa\xbf\x92\xdc#\x08{p\xa5?B\x95\x15\xea\xe5-\xf5\xbf\x91\xd7\xe9\xdc$\x1d\x01@\xe2Iq\x96JP\xf8\xbf\xb4i\x14\x97\x88\xaa\xd4\xbfF\x9a\xcc\xc9\x1a\x86\xdb\xbf\xf3\x887\xdc._\xe1\xbf\x02T\xa5\x0fc\xba\xf7\xbf\x9a!\xdai\x1eO\xff\xbfG\x1c\xfe\xcekq\r\xc0\xbe\xc8+\xf7\x04\xb6\xf9\xbf[\xc9n\xaaD\x01\x08\xc0\x89 \xe8/PB\xd9\xbfxq\x92w4x\xe2\xbf0\x8an\xea\r\x82\xe5\xbf\xb1\xb1\xb0\xa6~\x16\xdf\xbf\xed\x81\xa1nl\xa0\xf4\xbf\x88\xf1\xd6p\r\xd4\xa5?\xc41S\x94\x122\xf1?}\xb7S\x00\xc1Q\xf3?\xf2\xe6[s\x83\xb8\xb0?\xee\x910\xd4\xc5\xf9\xee\xbf\xa00\x9eat\xf3\x06\xc0\x91\xe6B\xef\xeb\x96\x05\xc0>\x98\xf1J}]\xb0\xbf\xc0\x9fY%\x80\x88\xf3\xbfb\xdd\xf0\xdd\xf9\xee\xc0\xbf\x82\x89\xe3o\xe8\xa8\xbc?\xc4/\xf3\x9a\xcd\x9f\xe9\xbfz\xb3\xccV\x9dN\xdd?\xba\xbe\xf5\xb6\x14\xaf\xe5?\xa2\xe0/\xf7\xb9*\xf4\xbf"d\x1e\x01\x1d\x02\xf6?\x14\x87\xa5\x7f\x1d\x99\xf8\xbf\x1a\x1b\x0c\xbf\x906\x03\xc0\x94k\xcd2`\x9f\x03\xc0\xf1]\xdb\x8a\x8a\xba\n\xc0\xf4t\x8c&\xccY\x06\xc0D^#5\n\xe2\x07\xc05\xf0^\x9a\xf1\x7f\x01\xc0}\xa6&\xb2\xd8\xf0\xda?u\xf3BOw\x0f\xf4\xbf\x99\x9d\xf1@\xec\x8f\xf3\xbf\xdb\xb9u\x14vG\xf6\xbf\xbd\xb9;\x8a\xe4\xb3\xda\xbfDg\xbf\xea\x101\xbc\xbfFp\x9e\xbd\xab\x19\xd7?]L%\xa24\x0c\xf7\xbf~\xbd-X{\x1f\xcf?-\xbd\xcc\x1c\xb5\x8e\xde?\x04:\x05C\xa8S\xd6?\xc6,_\xd9nN\xeb\xbfU&\xd4\xba\xddq\xe9\xbfB\x11\xd6~\xd6K\xf6?\x19\x82S\xc53\x07\xf4?K\xa5\xa8\xcd@r\xfd\xbf\x95o?p\xd9\x8e\xe4\xbf\x997Z\x8e\xa0\x88\xfc?\xf9\xeb\xa3\x0e\xfd\xe4\xf4?\xb1\xf51\x13\x1b\xff\xd0?7McL\x0e\x94\xe8?\n\xc7N]\xfd2\xde?2\xb0\x9f\x11o\xb6\xf9\xbf\xd0\xf1\xcc\x9f\xe8/\x03\xc0Y\x12\xb6\xc2\xc8V\x04\xc0X\xc6\xe6\x1a\xa1\x88\xfe\xbf\xe0c?\xb8\x1f\xef\x00\xc0\xd1\xadNeX\xd5\xe9\xbf:L\xa4\x0c\x9a\xd8\x01\xc0\xcf\xd7\xd2\xb4AD\xb6??\x04inF\x08\xc4?\xa6\xa6S\x16W\x1f\xd9?I\xa5_!IK\xec?\xde\xf6\x92\xa0\xd3A\xf0?]\x87\xa1\xd9N\xc4\xd7?\xe5\x9ew\xdd\xdfS\xec\xbf\x1bi\x13\xea\xa6E\x00\xc0\x00j\x9d\xa2\xfa\xbf\xd0?(!b\x91\xb8\x97\xf9?\xcdY\x87\x19\xf8\xed\xe5?\xc7;X\xfc\xcc\x18\xba?\x91\xb8\xb4\xc7\x03\xc4\xc7\xbf3\x04\xc3\x7fB\x90\xfe\xbf\x1b\x9bX\x9a\x9cE\xfd\xbf50\x8bGQ\x8d\x05@\xba\x12\xd1>\x19d\xc5?n\x17p\xbc\xeb\x86\xfe?\x9d,\x9c\xe5\x1fb\xf0\xbfw\x8e\xd2\x83\x14\'\xf4\xbf\xa1\xd5\xea\xf3\x1b\x05\xd7?\xc7\xb0\x98\xdc\xc8\x1f\xd2?\xf5\x07\xe7\x1e\t\x01\xe7\xbf)\xa3\xb9:\xder\x07\xc0\xf8\x1c\xb7\x93\x91\xb4\xf8\xbf|\xdf\xbd\x93,\xcc\xf4\xbf\xdd\x8b\x03M\xa7T\xe4\xbf\xe4\'\x8e,\x96\x84\xb2\xbf\xe2y\xe6\x0fB\xd1\xe6\xbf\xef\xe5u\xae<*\xc2\xbfhH\xacR\xc4\xe4h?k\xbd\x93\xb8UG\xe0?9\xde\xe4\x95\xd3\x97\xca\xbf\xc9\x14s\x18+\xdc\x01\xc0\xf8ln\x16@\x8b\xee?\tv\xe2\xff\xa6\x8e\x03\xc0)\xb4D\t\xb6o\xf0\xbfa\x9a\xdc59g\x07\xc0/\xd9\x0e\xc6\xdb\xca\xf1?V[?\xa3\x8d\x19\xe0?\x81\xfbu\x82!\xc2\xfd?\xa7\x93\xf5\xd4\xb6*\xd3?\xc3\x8a(\x1d\x9d\xb0\xb1\xbf\x01\xa4\xed\x19\x9e\x8e\x9a?\x84\xf3\xbah\xe8\xca\xe6?\x99Z\xa2\x84\x05\x87\xf8?\x94\x15>\x80I\xda\xf8\xbfS\x03Z\xc7\x7f\xca\xea\xbf\x92 kU1\xf0\xfb\xbf2\x18-\xa2(\x9e\xea\xbfI\xebF\xb4\xa6T\xc3?\xc5\xdef\xbb`\xa6\xfb\xbf\xa9\x8b\xa1\xb6Gb\x02\xc0x\xef\xbf\xca\xb2\x94\xf5\xbf\xaf4.\n\x81\xc6\xea\xbf\\\xdb\xa6:\xed\x1b\xe8\xbf}\xc2]\x9c\xd8P\xf5\xbf=%\xc7\x0f\x88\x9f\xdf\xbf&\x81\x9f\xad\xb35\xe1\xbf\xd5\xc9\x08\xa3a^\xd3\xbfU\x0f\xcb\x19\xb7e\xf0?\x80\xbe6\xbe\xbc\xfc\xda\xbf\xeb~M\x1b\x08\xc8\xf2\xbfq\xa0+D\xc0T\xe8\xbf\x12\x19;O\xf1%\xf1\xbf4\x14`\x83\x03x\xf8\xbf?7\x18\xbdR^\xc1?\xbd\xed:\x154\x18\xee?\x9eh\x94\x89ES\xeb\xbf|Q\xf5w\x14\xc9\xbb\xbf\x03\x8b%/\x8d\xe4\xdf\xbf\xb8[}G\xb6\x96\xc8\xbfF\xb9A\xa3nP\xea?\xae\xa9+f\xaaq\t@\xf5\xfe\x95\xa4\x87\x88\xf3\xbf\x03n=h\xd0W\xe8?\xf9\x9d\xf4\x03\x8ce\xc7\xbfi\xaf\xd5"\xe0H\xde\xbf\xa8\xea\xd6\xdf\xc9\x15\xc2?\xb8\xfd\xff\xeda\xb2\x01\xc06\xdc}n\x02H\xf4\xbf\x99\xa8a(\xf5e\xb1\xbf\x0bn0\xe86(\xdc\xbfb\x0b\xb1Xb\xca\xf7?\x19\x08\xa7\xa7qf\xf7\xbf.K\x145\xe9\xec\xed?rF\x10d\xa1\xd3\xff\xbf\xcf\xf4b\x97z\x91\xe2\xbf\xef\xbfX\\\xfe\x17\xcf\xbf\xcdXi\xbd \xe9\xf7?]L\xf6\x9a\xd3R\xf9\xbfm :\xac\x9f\xc1\x03\xc0l\xda1bRP\xff\xbfWE\xd8\xf79\xd4\xf3\xbf\xad\x14\x8a\xcf\xeeI\xfe\xbf\xa2\xae\'(\x80\x06\xf5?\x90v\x83\x8e(\xe6\xfd\xbf\xae\xdb\xa7F\x04\xe7\xe5\xbf\xb96\xf1\xc6\x9bm\xce?\xc5\x82\x96_\r\xc9\xfa\xbf\x9e\x82\x01\x93\x92\x9b\xe5\xbf!\xfe\xc3\xfdd\xf3\x00@c0rE\xc2\x95\x01\xc0A\xe5l\xb5\x96\x1e\xbe\xbf\xd3\xd6\xd9\xd3:\x00\xdc?\xfc\xf8\x94I\xa48\xe7?\x82\x12\xc4\xb0\xcfX\x02\xc0\xa5\x1ei\xd9\xda\xdd\xde\xbf*MW\xd8\\\r\xfe\xbf&\xbcR\xf1@`\r\xc0\x0c\xcfN0<\x1e\xd9?\x1c\x94\xd4{\xe8$\x08@Z\xf7\xa8o\x1d\xa8\xf2\xbf\xb8?#w F\xcd\xbf\xb1\xb3\x91Xsf\xc9\xbf\x80\x9d\x8dXX.\xec\xbf\xcc\xee\xfc\x7f\xc3#\xf1\xbf;\x9b\x9d\x92\x18J\xfa\xbf\x8a\x15(D\xe52\xf0\xbf\xbc\x1c\x86\x04hK\xd3\xbf\xb7U\xc17\x04\xfe\xf3\xbf\xe3m\xa3\xd0\xf0#\xe1\xbf%\xfb\xc5\xd1Kb\xf6?\xae\xfe\x11\xe5\x05,\xa8\xbfI\xd6j\xf0?\xc4\xdf\xe5\xb4mh\xe8\xbf\x828\xe8\xf9\x97\xc7\xd6?\x86\r\xb7\x7f\x93E\xe5?\x83pD)\x86\x95\xe0?\x91B\xfcBD\x98\x01\xc05\xc4Ni\xdb\xb7\xc6\xbf\x11m\xf1\xa5\x81P\xf2\xbfw\xaa\x85_4\xb7\xd1\xbf\xb1g\xf1\xb56%\xd4\xbfu\t\x16\x02\xf7\x0c\xfc\xbf\xd0\xae}\xf8\x0c1\x05\xc0\x18\x9e\x98\x06F\xf0\xda\xbf#\xca\x95j\x95;\xe9\xbfX\x92t\xd3\xdc\x83\xeb\xbf-0\x9c:\x14\x1c\xda?-%8\xa5W5\xf3\xbf\xa7\x00P\xdd\x1b9\xf0\xbf\xf1\x87\xe7\xe6!\xd6\xc7\xbf\xde(\xe3\xe7\xbfB\x05\xc0\x90\x16\xc9:74\xc2?\x9d\'\xcb\x88\xf8x\xe1?\xffTb\xe0\x08a\xf1?\x85Uc\xfa\xd6\x8e\xe3?\xd6a\xbe\x11F)\xc0\xbf\x1cEUF\x82`\xec?\xe3\t86\x94\xb0\xea\xbf\x89\xe9\xb9\xad \x9c\x01@\x8b\x05~,Q\xc6\xd0?b\xb0\x15\x90\xf3V\xf1\xbf\xb7\x89\x08}\xc6\x8b\xf9?\x07\xd0\xdd\xc1\xbeU\xd0\xbf\xda\t\xf3S\xb0\xeb\xf4\xbf\x12\xd4L\xffc\xbb\xb8?\x98P\x94}\x84\xe5\xdb\xbf,\x1f2xq\xdd\xf2?\xdf"\x04h!8\xec\xbf\xbe\x1f\xbc\xe5\xb3F\xe8\xbfu\x97\xa3\xf3q\x98\x01\xc06\nN\xac\xd4\x97\xda\xbfus\x818\x9c\xc5\xd3\xbf\x1e\xb83\xb22h\xcd\xbf\xee\xdb\x80J\x89~\x08\xc0\x0c\xc0r\x0bZ\x02\xf6\xbf\x04\xd0\x17Z=@\xf3\xbf\xb6\xcckt\xf1W\xd6\xbfV\xfa\x08\xe0\xa9\x97\xd0?\x92-;%Ej\xf3?\xa4\x03\x9d\xb1\xb1\xce\xa8\xbf\x1e\xa0\x90B\xd6j\xf4?\x05D\xd8\x0f@c\xa5?\xf0oX\xe1\x90\x92\xd6\xbff-\x0e\xfb\xb2{\xef?S\x8aC\x14\x0b\xf1\xe0\xbf\xca\xf5\xab\'s\xad\xef?\xcf\x06\x91\x9b_\xbc\xd9\xbf\xa4p\x19j-\x06\xd3?\x00\xf1\x15H\xd4\x95\xe1?V\x87\x82\x04wA\xfd?\x86\x9em\xcc\x1a]\x02@{\x8b\x9dZ\xfe^\xcb\xbf\xd3\xdb\x97C2\x06\x05@\x13\xc9\x18\xbc^\xe5\xdc?P>\xbe1\xfbM\xed?\xbcG\xda\xe1\x06\xb9\xdf?7\x9d\xd0SI/\x07@\x07\ts\xe7\xae;\xe0?ml\xf62\xc1\xdc\xfe?a\x9a;\xfbK\xc7\xcb?g\xf7\xc1/\xf4\xdb\xfc\xbf%\x10\xdb\x80\x11\xe3\xe4?#!U\xeaPl\xc9\xbf\x9c\x0b\x8bZ\xfb\xb9\xf6\xbf\xf2\x9eF\xc0\xb1\x11\xf3\xbf\xb8\x06\xa3U\xf7s\xfc\xbf\xbaS]d/\x99\xe8?G\xd9\x1b\x0bG\xf3\x12\xbf>\xf4M#7V\xe5\xbfb\x18z\xf7\xef]\xd3?\x9a\xe6n\x1fG\xdd\xf5?\xd1\x16\xc6\xfe*\xaa\xb5\xbf>Y\xa6\xd7\xa4\xc3\xb5?Q\xc8\xff\xbfl\xda\xef?\xcd\xe4$\xdb\x14\xee\xd4?\xd7\xc4@\xa5\xea\x97\xfb?\x9e\x7f\xd6\xb0K\xeb\xe4\xbfMf\xbe\xe9V\x91\xf2?\xeb{\xf1`\xe2X\x02@\x88\xdes\x9e\xae\xb6\xe9?\x94w!_V\xb2\xc2\xbf<\xddd\x1a\xc9=\x02@t\xa92(d\x9f\x02@\x12J\xe4\xc5v\xf7\x0f@O\x1a\nx\xbf\xd3\xf3?\xd2\xed\x00(\xb2\xa9\xf6?\x002\xae\x80L\xdb\x01@\xa3Pn\xc3o\x0c\xcd\xbf+@H`rV\xe2?l\x15\xf0\xa9\xb48\xdd\xbf\xc9\x10\xe0"\xcc\x9d\xc7?\xf7\x07(\xae\x98T\xd2?\xe7\x98\xea\xcc\xf9\xb8\xf6\xbfK\xf0\xf1f\xc8D\xea\xbf\xcbi\xd2\xd3v\x9a\xe0?T\xfd\x1d\x0e\xcf\xc5\xa0?\xc2\x00<"\x19\xce\xe4\xbf`\x96\xae3x\xec\xb7?7\xcdZ\x97\xe5W\xff?\x94\xc2\x13\x1a\x89\xb1\x86?xm\xbfv,\xa6\x02@\x98F4^\xb0O\xfe\xbfc\xe4\xbeJ\xd9C\xe6\xbfv\x00\x93\xd0\x93\xd6\xe1\xbf\x9d\xb2\xd3\xd2\x8ck\xa8?\xbfy\xffv\x01\xe2\xdc\xbfC\xea6(\xe1\xd6\x06@E>\xd7\xe8\x12&\xf0?\xbe\x18\x11ZL`\xcc?(\x80\xc9b\x81\xb6\x8e\xbf\x06\x872\x14P\xc0\xd8?7\xe2\x1d\x80\x164\xe3\xbf\x9e\xa5r\xae\xb1\xe0\xfd?R1n]\xfaZ\xf0?\x05m\x91?\x1e\xe9\xef?z\xfc7\x80\xd6\xf2\xd4?\x0b\xe9\xdc\x00\x8ec\xde?\xa9\xa1\xd5\x8f<\xc2\xea\xbf\x0f\x8fO\x9e\tY\xcc?\xa0a\xc0:\xb6z\xcb?I,\x9f\x11\xbd\x13\xf7\xbf\x19\x96en\xa3\xec\xba\xbf\xce\xa0R\x8cZ[\xe6\xbf-\xac\xd9\x17\x8e\xe8\xcb?\xe2w\xd76\x13\xbf\xe4?\xadj\xe6\xbb\xac\xcf\xcb\xbf\x1c\xe3\xa4\xc7P\xac\xd5?#q\xcb\x07\x90\x00\xd5?\xc8\xfe\x87N\xf38\xb8\xbf\xf5[\xd6T8\xa4\xfb?\xa8J\x08\x87.i\xed?0!t*\xa0\xc0\xe3\xbf\x8a\x95t\x0b\xb9N\xe9\xbfL\xfc\x065I;\xe8?\xa9\xca\x02MN\xc3\xcf\xbf\x1dN\xc6H\x9b\x0f\xdb\xbf\x1b\xcf\xe3S\xc8\xe4\xfc?\xe0n\x03\xb0R\xa5\xe6?}\xd2\xcb\x8alW\xb7\xbfXr1[w\xe4\xad?N\xad\t\x80!L\xef?f\xc8\xe1\x1c\x84\xa6\xd0\xbf}\xb5B\xc5\x93\x97\xe3\xbf\xae)\xcbtMB\x00\xc0\x11T+\xa4\xc0*\x9f?5\x00|\xe9|!\xcb?\xd4f\xc8\xe0t,\xf1\xbf\xb9\xa6\xa4\x83Z\x16\xe6\xbfl\xbf\x86\xe7bn\xf3?N2NLX\t\xf6?rb\x0f+\xa0\xda\xf4\xbfi\xdf\xdb\x87\xbb>\xe9?\xe2U\xc1\xb3\xed~\xe2?ck\xc5oR\x8b\xc0?\xdbpH{\xdb\'\xd8?\x95I2\x07\xfb\xd3\xe6\xbf\xc6<\xa8\xa7\x88\xc5\xd6?v\x12\x17\xf1@\xac\xc2\xbf&\xd7\x17\x96`\xdb\xda?\xa2\xb8\xeb\x9f\x11\xe4\xb6?\xe9\xe7\xf8<\xf2}\xde\xbf*u\xae\x04\xb8i\xeb?\xde\xa6\\y\x7f\x1c\xe4\xbfPJc#\xfd|\x94?\xb2\xd8\x81g\xb3S\xf4?xD\x16\t\x16\xc8\xe8\xbf\xd4\x81\xcd\xe6\xa6\xa9\xdd\xbf\x838s\xce\xac\xa3\xb0\xbf\xed\xd9\xa4\x19\xb7q\xe7?=7\x9f,\xd3\x80\xfa?`\xe0W\xdbBh\xf1?t\xdeV.8\x0f\xaa\xbfG\x08\x9f\x03y\xf7\xf5?[\x86\xb9\xbe\x89\x8c\xe2?N\x82[\xcde\xc3\xd1?*\x01\x9f\xa3`\xb7\xb5?\xf7\'Q\x18\xc6\x01\xa0\xbf\x9cI\x98/\x907\xe9?\xc3\x17\x19\xc7\xe8\x90\xab\xbf\xecD\xc6&\xf0/\xf3\xbf\xe8F\x9e:\xe9"\xd4?\x91\xeb\x06Iv\xe2\x98?P.q*\xe7\x9d\xdb?\xd6\xd6@v\x82\xae\xd4\xbf\x11?\t\xcc\xb90\xd1\xbf\xa9\xff`\xe0M7\xe0\xbf\x1b\xd4P\n\xfd\x87\xc9?*-5k)v\xcd\xbfI-\x1d \xc0\xb8\xb4\xbf5!\xef\xd2%\xcc\xe4?-UR\xd1)\xc9\xcc\xbf \xfe8\x1fV\xb7\xd5\xbf2\x89\x91NR\x14\xe6?\xc5H\xdf\x04[\xbf\xf7?^rD\xfb\x9e\x93\xec?\x9b\xab*\x995\x8d\xd7?\x90\x8b\xd0s\xb7\x16\xf3\xbf\xb7\x80O\xcb\xa9\xc2\xc9?\xa4ba\x193N\xf0\xbfg\xf1Q\x12\xa1]\xc6?\xf0Ph\xac\x01\xf7\xd9\xbf#\x97 \xfdY\x1c\xf2\xbf\xa0\x8d\xa1\x85Z\x19\xf4\xbf\xdf\x9dZ\x1e\x9c\xde\xca\xbf\xa7\xdf\xfa\x86\xf5e\xd0?N\x8a\xe6E\x1d\xbd\xe6\xbffyZa\xc9\xbe\xf1\xbf\xd0\xd7&\xea\\\xbc\xed?\xd3p>\x8e\x97\xf4\xec?\xab\x139\xbe\xd7\x9b\xdd\xbf\xe3\x85_\xa7H\x00\xe5\xbf6\xd1\x1f(\xe8k\xf0?\xba\xd4q\xca\x84\x0b\xd2\xbf\x91\xa7\xddt\xe4\xdc\xf6?]B\xf9"0c\xcb\xbf\x87\x04V\xab_\\\xf3?@\x81\xc6w\x0fW\xdf?U\xa1M\x1aK\x7f\xe2\xbf\x820\xa7\xb0\xa6,\xf0?%\xe3\x8e\xc4}l\xbb?\xa9\xa5\x14\x17aa\xe5?\t\xc5Y\xb8\xbf\xa9\xe1?2[.\r\xbd1\xfa?t\xdf\x9a\x1c\x18\x9e\xa4\xbf\xa6r\xc5\xcb^\x7f\x08@\xf6\r/\x9e\x17\xd8\x03@#\x8b"\x0e\x8e/\xc5?\xc8tQ\xce>k\xf1\xbf[\x8e*.3\xe6\xea\xbfuN\xee\xaf\'\xcb\x00\xc0\xbbp\xd0\xfa\xf1i\x01\xc0\xa3\xcc\xbe\xb6\x1f\xba\xf0\xbf\x11\x92O\xbc\xc0 \xf7\xbf\xdb\xa6\xc0XmT\xfd\xbf\xe4\x94\x84\x8fF\xef\xed?\xc3\x81{W\xe4\xb2\xe1\xbfw\xa0\x1f1\x1e\xd4\xaf?\x05\xa1\xfa\x0bB\xdc\xec\xbf\xc3\xf3\xbb\xa5\xe4H\xf4\xbf\xf5\xc6\'\xc3\x10\xa6\xc7?\xe1\x94\x1d\n\xe7o\x9c\xbfCf>\xdf|u\xd4?d\xcb{\xee\xb1\xc0\x00@\xd5\xb8Y\x8c\xa4J\xe1\xbf\x88M\x83\xb0Y\x98\xec\xbf\'\x927)KO\x02@/I\xa8T\x17\xcb\xc4?\xf9\x9e\xbd\xd4\x0b\x03\xf2?L\xae\xd4F\x83\xba\xfa?\xf89\x80\xc0\xc4!\xdc\xbf\x18\xba\x12\xe7\xfe\x9b\xf5?\xbe0Y\xdd\xeb\xca\n@\xfc\xd3|\xba\xeev\x02@\'\xc6\xb22\x91.\xdc?\xf1\\yA\xb66\xf3?\r\xa2\x905\x93\xe0\xfb?\x9f\x0f\xb9c\xfb\xfe\xe9\xbf\xbf@<\xcfy\xba\x05\xc0\x08A\x84\xe0\x06\x1c\xf0\xbfyR\x01xP\xc6\x04\xc0\x85\x19\xc6\x93\x7f\xb5\xc9?\x040\xd0\xe4\xa7\xab\xfd\xbfXj\xc6\x849\xa9\xf1?\x15\x12\xf6\x12O\xbc\xf5\xbf\xa6\xcb6\x07\x07:\xd4\xbf\xae\x95\x81\xe9h@\xe5\xbfH\xb2,\xee\xc1\xbc\xdc?h\x06\xaf\'\x1f\x89\xfa\xbf\xab\r\xac\x9c\x99\xa4\xe5\xbf\xec\xa2\x11\xbd\x01\xdb\xc7?\x84\xae\xecO\x8d\x8f\x8a?\xd8E5\x0f\xe2\x1f\xd8?\x80\xf0\x91d\xd5&\xe1?\xa6G#<\xf3^Z\xbf\xea\x02\x17#\xf5\x1e\xe3\xbf,g\x8f\xef\xd5X\xff?\xf7J+\x89\xbam\xe0?4j\xb5"r\xdc\xf0?P)^\x8dO+\xc6\xbf\x150\xe5\xf4\xa9.\xb3\xbf\x15\x0b\rO\x0cc\xe3?\x06\xd9\x7f\xc7s\xe2\xf3\xbf\xc3\x1cK(%\x97\xf0\xbf\xa1\xf5\xa8N2\x95\xf9?\xcf\x1atg\x9eU\xe4?\x87\x85\xcf\\2\xf7\x03\xc0\x07\xe5P?\x1d\xcf\xf7\xbf-^\x95\xf9\xae\x00\x06\xc0\xe4\xb1.\xca7c\x03\xc0iH\xf7\xfb@K\x07\xc0DMrj\xb3\x97\x07\xc0r\xd9\xdc\xf5\xb7a\xf4\xbfdt\xd9\xdal\x81\xba?\xe0\xabpR\xdf\t\xea?\xd9}16\xa9:p?8\x95\x97\x8cn/\xf2?\x8bs\xb18y\x19\xe0?\xfb\xba\x9a\x1a\xa9q\xdd\xbfn\x16\xe4\x07\x06\xcf\xec\xbf\\\x08\x0ek\x1c~\xe1?\xe6\x81\x88\x04~x\xe9\xbf\x94\x1e\xf76Jg\xf9?\x8ft>\x8f^\x03\x0e@\xfb\xbf\x90\xf5\xba=\xdc?U\ttq\xd1\xda\xf0?E\xde\xdex\xe5I\xe9?\xe7M\x88\xcda\xb9\xf2?0Q\xbd\x9fCE\xb6?\x13\xf2\xe7\xa3\x0e\xc5\x00@M\x05\xe4\xd7.\x18\xfb?!\x05\t\xfe\r\x12\xef\xbf_z\xdbZ\xc1\xd4\xd5\xbf\xa6\xb5S\x9e\t\xbc\xf0?\x8a\x02j\xed\xb9\xa6\xfc\xbf\xd9\xd1\xdf\xb3\xfew\x00@\x11s-g\xa0)\xfe\xbf1\x02\xfd\xf7R\x88\xfe\xbf\xf7\xa8!\xc2"\xa9\x03\xc0\x0f\xaa\xaf\xb7\x84\xd7\xfd\xbf\xa4\xf7\xa1\xef\xc0D\xe8\xbfv\xa5\xc2\xe4h#\xf7\xbf\xfev>\xa2\x82W\xdf\xbf[\xf0\x0b\x97g\x91\xdd\xbf\xc5\xb3\xf1\x12\xbbw\xe2\xbf\xa48\xc0\x97\xd3M\xd8\xbfs\xed@7\x06\xfc\x04@\xaaE\xed5\xba\x90\xe9?\xa1\xb6\x8c\x8c;\xed\xd6?\x04\x88K\xd2\xd2\x96\x04@L\xe2,1\xf3\xa6\xee?\x9ck\x1dC\xd4\xbd\xf0?!\xd5\x17^\x85B\xb2?\x80\xf6\xb2\xc4\x0bf\xea\xbf\x0fv\xe8\xce\xb4\xea\xe2?^\x91\xea\xde\xb5t\xd6\xbf"{5{\xcb\x18\xfb?t\x9f\xee\xc2\xf7#\xe5\xbf/\x8b\xed\xae\xbfN\xec?\x83\xb3\xa3N\xe5\xa4\xc6\xbf\xbe\x9a\x90\x0b!\x85\xe1?\x8bW\xb6J\x03\x13\xa7\xbf\xcf\x1a\xcb\x9f\x08\x18\xe8\xbfKx|u\xb6M\xf8\xbf|\x1e\xeb+8\xab\xe4\xbf\x8d\x82\xd7\xc6\xa4i\x00\xc0Q=\xdc\xd9\xc8\x86\x10\xc0h\x9d\x00\xbb\xbb\xe0\x05\xc0\xfbQS\xa3\xdaO\x07\xc0\xf6\x9b\xeeY\xf6d\xfb\xbf\xa9c\x80\xd54\x86\xf5\xbf\x81\xaa\x86SpY\xe9?\x84e\xa7\x99\xbb\r\xe4?\xe8\xe7\n\xcd\x9a\x9d\xe3\xbfb\x9ft\xfaj\x90\xe2\xbf"j\xad\xd2b\x1f\xa4\xbfL\x86\x93\xe3\xfa\xc5\xe6?o\xfe\xf5r\xd2\xb9\xda?@\x9f,\xeb\xc8\t\n@\xaez)d\x1fe\x89?* <8\x8eq\xb8?m4(\x7f\x7f\x9e\xf2?\xb6]\x05\x1b\x06S\xed\xbf*\xf6\xc1Fs\xc7\xf5?\x8a\xf8\xc2\xdb=?\xe6\xbf\x10\x94\xb8\xefZc\xf3\xbf\x07m\xb75\x90\xdb\xfa?\xda\x11F\x1a\tb\xee?\xce\xff\xf5?3\xc3\xfc?\xbc\xa15\xf4\xd3\xb5\xc1\xbf\xab\x81\xf9z\xa9\\\xe3?w\xeb\xaf\xcabw\xe7?,\xf1h\xbc\xc0\x7f\xf7\xbf*\xd5\xcc\r\xb0c\x16\xc0\xd8UX\xda"4\x10\xc0\x8bs\x02\xae\x1e\xc3\x10\xc0bz\x11\x8c\x86\xa3\x07\xc0\xfay\xa0y\x1f\x89\xf8\xbf4n\xff\x1e\x07.\xd8\xbf\x11\x88s\xc1\x9c\x02\xd8\xbf\x88l\x05K\xb2\xf6\xcf?\xb3\xe6\xcb\x8f\x1f\x86\xfc?\xeef.\xfb\xaf\xa0\xb8?\xfaeS\xc3N3\xb0\xbf\xf1-\x89a\xb2;\x08@L_;\xc3/\xa0\x08@\x02\xf6\xf3\x1b\xfc}\xea?\x18Y\x05\xdcL\xa7\x9a?\xb0Ni\xa7\x8f\xf6\xf1?\x05\xbbn\xbed\xe9\xfa\xbf\x1bI\x95\xe6\t\xf3\x00\xc0c\xec\r\x02\xf4\xf3\xf4\xbf\x19\t!#\xe4\x05\x03\xc0\n/\xfa\xb7\xbb\x12\xdb?\xa9\xfc\x974\x12U\xf9?z\xa1\xa0\xa3\x01\x7f\x10@\xb6\x18\x01\xc1t\xe1\x03@\xa7lxo\xd5\x04\x0f@\xf4\x1f\xd6\xed\xf3.\x05@wWL\x8at\x0c\x02@\xd1\x90\x0b\x88\xe2\xe9\xf0?\xd1On\x1a.B\r\xc0\xb9\xb9\x08\xa4\x97Q\x14\xc0 \x03\xa1D\xc6\x9c\x13\xc0 *\x8d\x8e\xd6P\n\xc0\xe3!0\xea\\\x18\x0b\xc0\x04\xf0\xf3\x1a\xacv\x00\xc0}X\xc7\xef\xbe\xb2\xdf?\x88\xd4.\xb1\x18\xf0\xba?H\x92\xc3\xa5\xd0\x04\xd3?:\xe5[uP\xfe\xca?\xd7\xa0waz\xe6\xe6?\xf9t\xd5|w\t\xf5?\xccO{\x04\xdd\xec\xd8?\xd9;\x83\x07\xa8\xc2\xe9\xbf\xb5`\x9d\xf5)}\xd9\xbfEv\xb3()\xad\xc2\xbf\x02F\x1b\xdc\xcb\xca\xfe\xbf\x89\xa2Z\x91\xf6\xd2\xbf\xdf\xa2\xf6\xfc_%\xe1\xbf\xc4:\x92e\x9eT\xf3\xbf\x87\x8f/=Xk\xe0?\xc7\x84\xcd\x91\xd1\xa8\xb6\xbf\xe5N\x1b\xb3R\x04\xe0\xbf&\xc2\x9c\xbb\x94\x16\xe1?3L\x96M\x02\x1a\xf0\xbf\xfc\x8c]0<`\xc1?\xce\x01T\xfd\x85\xdf\xe3?\xbe\x84\xa7\x1cYR\xf3\xbf\xe5WorM\xde\xc1?\x07\x84K\xb6\x8a\xe7\x02\xc0\x7f\x7f\xaa\x95\x00q\xef\xbf\xfd/=%r\xc1\xb2\xbf\xc9\x02-N\xd4\r\xe1?K\xff\xf9\xf2\xe7\x10\xfd\xbfW6Y\xcesB\xea\xbf\xb1\x89\xcee|\xe7\xe2?\xa7\xbe*\x1e\xaf\xf1\xe3?\xfa@8\xac:f\xc7\xbfw}b\x98\xe5\x8a\xe6?\xc2\x8c\xfa*\xe4b\xcd\xbfF9\x02\xe5\xd1R\xe9?{;;h\x9b\xee\xf6\xbfz6\xf6"\x13\xc7\xf3?\xedx\xa6\xd3`\x18\xe7?D\xcf\x98zR\xf9\xcf\xbf\x9bz\xb3\x82\x9ai\xcb?\xec\xe4)\xf0\xb4h\xfd?\xd1\xaa\x15\x90N\xab\xc2\xbf\xda\x15\xd4\xbe\xd4\x01\xeb?\xc1\x11/\xe5\xbe\xa2\xf2\xbf\x93\x1c\xdb\xb2\xc3\xd0\xe4\xbf\xa4\xefx\xc0s/\xd7\xbfb0\xd2F\xf0C\xf8?\xed\x0f\x90\x86\xf6V\xa6?~\xe4\xae~Sd\xf4\xbf<\xca\xab\x1c+\xeb\xe6\xbfhuGU\x00N\xd6?\xb8\xa6\xde\x02K~\xc8\xbf\xf937\x15\x04d\x89?\xf0yT[q\xab\xf4?B\x97pQ\x8b\x8f\x01\xc0=\xe7:,\x8e>\xe8?\xdf\x17i_V\xed\xc0?7\xeb-\r\n\xbc\xe6\xbf&\xcf\xd2\xcf\xae\x17\xd5\xbf\x1eUe`\xf4\xcb\xc1\xbfwOW\xdc\xa6t\xed\xbf\x98|\xac\x03u;\xdd\xbf\xeb\xc3\x00Oy\x9b\xff\xbf$\xb0\xcaU\xb9\xf9\xda\xbf\x08\xcd\xa4\x8bSu\xef?\x9c\x0eO\xbb\xc6<\xf1?@cn\x95\xca7\x00@\x99\xfa\xce\xbc\xc0E\x00@f\xc2\xbf5\xdfu\xf1?\x9f\xc0\xf5\x94\xc5\xa8\x07@\xd1#?\xa1\x7f\x19\xec?\x11\x83\xd1?eK\xf7?\xdb]j&\x8dB\xe0\xbfy\x98\x93X\xae\xeb\xfc\xbfQ\x14:\xbe\xb2B\xec?8P\x80\xd5-\xb2\xf4\xbf\x8d\tD\xf0!\xcb\xea?\x13\xe0\xae\xa0\x0f@\x00\xc0q\xf4Khpp\xd7\xbf<\xdd\x8e\xd0\xae\x07\xc4\xbfJw0E\xbd\x85\xe7\xbf%\xa9\x0c\x97!N\xf2\xbf\xbf\xf9>\x0ebQ\xd7\xbf\x0c\n\'\'\xc4\xf0\xf3\xbf\xa2"\x80\xa7\xe9\x8e\xe9\xbfI\x15\x82J\x88\xfb\xf0\xbf\xd5\x93\xfa\xd5\xdcL\xde\xbf\xa8\r>B\x03\xe8\xa3?_E\xaa\xae\x8d\x83\x00\xc0PQK];\xa2\xf2?\x16"\xd2\xcc4\x0b\xc5\xbf\xd2t\xe0\x00\xe5%\x02@!\xbe\x02;\x92j\xde?\x18\xa6Cb\x96\x92\xf8?[\x14\x0f\x9e:<\x02@s\xf9\x15\x0e\x91.\xf9?dL~p\xca\x1a\xf7?\xf0\x81A~\xcd\xba\xec?S\x8b\xc8CI\xa3\x03@\x9b\x03\x15\xc9\xa8"\xf8\xbf\'Lp4\x92\xd8\xfc\xbf\xed\xf8\xcf\xa7RX\xf1?\xd5\x10\xb3@\xdeV\xf3?\xd9*\x02\x94\x00\xed\xc7?+\xdc\xea\xf8\xcc\xf9\xe7\xbf\xd7\xf3\xb90\xda\x8a\xe1?\xf2w|]K\xcb\x00\xc0\xdckT\x1af7\xf7\xbf\x93\xfe\x8c\x8e\xad4\x02\xc0\xd0\xae\xe1\x8e,\xb4\xf1?\xbd\xb0\xe1d\xeb)\xc8?\x8f\xc9P\xd3\xc7Y\xf0?\xf6O\xaf\xef\x10w\xf1\xbfS\x83\x0bC\x80k\xcb\xbf\x8b\x93R\xad\x1d\x90\x8e\xbf\xec\xf1\xcf\x8e}x\xf5\xbf\xe6"~Vjp\xfe\xbf8\x1d\xc0fl\xb6\xd2?\x9c\x9b\x8f\xdc\xa7\x99\xe5?=\xc1\x86l\xea\xb5\xd8?Q3U\xca\x82\x1b\xde?\x0f\x07\xb5\xbd\x95\x14\xe0\xbf\xfb}\x12\xbd>\x0f\xc3?\xef=R\xc2\xd5\x9c\x0e@lGLp\xe5 \xe9?\x08\t_[\xe53\xe9\xbf\x87\xcc\x08\xe5\xd8`\xf9?\xa6\xcf\x02\xd8\xd2\x92\xf7?\x9a\xb8\x0f\x12\xe3%\xf0?0\xe8\x0f!\x14\xac\xfc\xbf\x9d\x01\xbd\xdd@\xef\xee\xbfE\x9eaq\x0fw\xe3\xbf\x05\xb4-\xe05l\xe4\xbf\xcb`\xe10\x82\xbc\xbf?^\xcdO\xdaR\xe6\xe4?\xf9\xa9\xafq5\xd5\xf1\xbf\x93\x08\xe1\xe6\xb6+\x89?\x98 (\x02\x1c\x0b\xed\xbf\x9b\xc4A\x8e\xd0\xff\xed\xbf\xa6]\xfb\xecpN\xed\xbfX\x1d\x9d\x16\xe4\xf3\x03\xc0|]J!\x89\xb8\xf4\xbf\xb5T\x98T\xcf@\xf1\xbf\xe1\x7f\x13d9}\xd0?\x8d\xa2\xac\x8b`N\xfc\xbf\xe1\x83\xcf\xc9A\x18\xff\xbfeng!\x7f\x11\xd6?8Q\xec\xc5\xf8m\xd1\xbf:\xae\x11t\x7f\xdb\xfe?:\xfa\x18v\'h\x05@\xb5^\xd3\x13\xd7\x9e\xb3?q\xfb\xce\x1c\x97x\xcc?\xa9\x11\x03\xeb\x0eA\x00@\x91\x94\xa1\xaal>\xe9\xbf\x8f \xd2\\pv\xd3?\xd9\\\xc1n\xc8\xac\xa6\xbf\xbe\xfal\xd5\xca\x98\xeb\xbf\x964o\x03\xb8G\xb7?\xf9\xa6;\xdbi\xae\xea?_\xc3\t\x7fuI\xd3\xbf\xfd#mCl\xdb\xd0??5,\xbf[4\xe7\xbfXr\xca\xc5\xb4\xc7\xf6\xbfc\xc0\xb9\xee\x99z\xe1?\xe2\x18V\x8b+/\x05@\x98qq\xde\x8e\x0c\xf1\xbf\xfa\xbfI\xb8\xe9\x94\xeb\xbf\x86:mtE\x94\xe8\xbf\xd3\xde=O\xc5\'\xc5\xbfoX\xd2\n=~\xae\xbf\xf4`\xa1\xad\x04\x16\xde\xbf\xb56)\x7f\xb60\xe3\xbfG\x11\x19%\x195\xf2\xbf\x1a\xd2\n\xbez\xcc\xf4\xbf\x0e\x9b\xfd\x01\x1b\xbd\xd5\xbf\x83\xcd<\x82\xa4H\xe4\xbf\xe4\xd0\xb9_\xc0\x14\xf9\xbf\xc5\xf4&\x80\xc3a\xfc?O\x98\x80.\xf4\x19\xf5\xbf\x93[\xd4\xea\x80\x95\xd0\xbf\xa6\xc2Wi[f\xc2?V\xaf\xa2\xa0t\xf0\xd3\xbf\xa1>\xda\x18@\n\xdc?\x05\x01\x9c\x10\xec\xbd\xea?\x0es\xfe%\t\x93\xd8?\x8f\xb6:;\t\xab\xef\xbfF\xd5,Y\x9et\xf4\xbf\xbf\xf9&\x89W\xfb\xea?\xc9\xb8\xe2t.\x8f\xf5?\xa8\x87\x8e\xf2\xd8\xd7\xf9?\x14W\x8f\x86D*\xf0\xbf\xa2\xc7C`(\x02\xe8\xbf\xf32\x94<\xbaU\xf3\xbf\x8e\x95\x98Ik|\xf3\xbf\x10\xb2\'\xfa\xf3\x1b\xe8\xbf\x17\xc5N\x99\x9e0\xcd\xbfA\xf9q\xedy\x9a\xea\xbf\x03N\xf1\x0c\xdb\xfd\xe6\xbf\'\xe7\xac0S_\x07\xc0\x94J"q\xbf\xe4\xec\xbf\x19v\xa5\xf4\xcfS\xea\xbfFG\x03s\xbe^\xea\xbf{\x85*\xdf\xeb\\\xee\xbf\xf1U\xe4\xde\x0f|\xda\xbf`:\x04>\xd4\xa4\xec\xbf\x8a\x1b\xeeO\x91\x90\x01\xc0\xe6\xb6\xfe\x8e\xf3\x0f\xf7\xbf\x97\xe01\x84Y\x85\xee?\xa2\r\xbd-UM\xd1\xbfB^j\xe0`&\xe0?\t\x08\x96;\xa4\x7f\xb5?\x16\x1f\xb5\x98\x19\xbe\xe3\xbf\xc9VF\x88\xcd,\xfb\xbf\xa4\x02\x15a\xbc\x1e\xab?\xb3\x1b\xf8\xd9\x93\xf9\xe0\xbfV\xe1\xd9\xe6\xa0\xe3\xf6?-\xbf\xc7\xae\x0cl\xfa?\xe0\xbf\x8e\x88\xfb\xda\xd6?\xd5~\xdd\xb01c\xe8?2\xa2\x8c\xe0\xabY\xd0?42|\xcc*\x84\xf4\xbf\xce~\xb7\xaa\x8f\x06\xe4?\t\xe3\n"\xed\x12\xe6?/R!\x8c4A\xfc\xbfU\n!\xba\x16E\xfa\xbf\xf4\x10FM\x16=\x07\xc0\xec\xc0\x87\xaa\x93\xe1\xcb?,\x03r?u=\xc2\xbfb5\x8c\xcbQ\xe6\xd2\xbfs\xec*\xa65\xbd\xe3\xbf\xe5,Wb:\x06\xf8\xbf\x00\x98z\x08t\x1b\xfe\xbf\x94xT|I-\xf8\xbf1&\xc1\x95\xc9\x04\xf0\xbfp\x1e\xc3\xaaM\xa1\xc5\xbfX;\xe7\x16U\xa5\x04\xc0\t\xb3y\x8a\x06\xfa\xf5\xbfH\x1d\xd2o+\xb4\xc2?\x8d&\x11\x8b\x99\x82\xb4?`\x90\xce\xb16G\xfa?\xce\xfec\xc5A\xbf\xdd?t\n2\xb3\xd9\x13\xf8?p\xc2\x9a\x9f\xd3\x81\xea\xbf\xe3\x8b\xa2{\x1a#\xd9\xbf\xd7\xb2\xe9\x0ca\xd3\xf8\xbf\xfdd\xc7h\\\n\xeb\xbfrm4\xce\xbf\x94\xf4\xbf\xd6\xf6\xda\x0bI\xe7\xcc\xbf_\x89\xf0q\xd8d\xe6\xbf@z\x90\xee*\xaa\x01\xc0\xd75\xbe\xd7?|\xf1\xbfd\xf1\xe1c\x1d\xfd\xfd\xbf\x08\xd3\xf9\xc6\xcbz\xe3\xbf\x0c\xc8]r\x8a\xb4\x02\xc0*J@P\xect\xf3\xbfSY$c\xe1!\xe6?\xb6\xb7\x00,-\'\xcc?%\x06h9|a\xf1?f\xe5i\xa8\x84\xcf\xb3\xbf\xa4\x96\x16\xa5\n?\xe9\xbf\xe0\xd0XuNG\xed?\xca\xe7\x1e\x83\xfc\xf6\xe3?\xb5\x1cF\x86\x9f\x07\xf1\xbf2\xe6?;\x9d\xb4\xd8\xe5v\x95?\xb8x\xf9\xbcA\x11\xf1?\xaa\xeb=\xe0:+\xc2\xbf\xbf!\xdb!\xd6O\xfb\xbf!|=7\xb4\x80\xec?\xcb\xf3*\x8fZR\xdd\xbf\x0b\xc4\xdc\x9b\xb0Q\xd6?9s\x85#V~\xe5\xbf\xde\xc1\xcf\xa8H\x9f\xcc?\xa9\x95=&G^\x03@N-\xb3\x12\xb2h\xf6?\x01\xcb\xf7\xaek\x1a\xe2?E\xc7\x04:`\t\xd7?O\x07\xa5\x11\x89\xd8\x05\xc0e\x08\x92\x8b\xa43\xe5\xbf\xb6>\x1e\xe9\xc6\x87\xf1\xbf\xd0hK;\xb5j\xe3\xbf\xdf\x19t\xb2\xbf\xd5\xf1\xbf\x9e~\xfa\r9\xa7\xe3\xbf\x96\xf9p\xc7Fc\xbc?\xa8\xf0KTtG\xe9?3A)\x94\xb2\xd9\x01\xc0\xc5\xc9\x1c\xe7\x99\xeb\xfd?\xf8\x15\xda\xdaM*\xf5?\xd3\\:\xbe0\x81\xf0?\xd6t\x99^+\x1b\xd6?\xf4\n\x1dyy^\xfc?\xc1\x9e\x1f\xb6\x8e\x12\xea?\xc3\xc6\n\xbe\xfax\xeb?\xe9!W\x93q\x1a\xf9?Bm#\xc8st\xc7?u.4<\x0f\x82\xd7\xbf\xac\x06O1\x0c\x9d\xea?;\xa6\xf4\xfe\xce\x1c\xe0\xbf\xf1X\xd2\x17b\x1a\xf2\xbf~\xcb\x8cw&\xf2\xed?\xe4\xfd\x8f\xbdk\x94\xf9?\x05\xae)\x9d\x0f\xb7\x9e?{\xac\xc4\xf7\x06\x10\xf5?\xdc\x14\xd7\xa3\xd8\x11\xb3?\x86%5\xfe\xb6\xe5\xdf?j\xf8E\xec\x15\xa7\xf0?:\xf3\xccW\xe6\x8d\x01@u\x18\xaa\x11\x1b?\xed\xbf\xe2\xf2\xba\xb9\xa8r\xfc?\x10\n&\xff\xf0)\xc6?z\x0c9.\x08\x10\xe6?\xb5\x93\x88?\xafo\xe9\xbfvd\x9c\xf84m\xe0\xbf\xcb\xbc\xf9\xc7\xc6^\xf2?\x83\xc2\x82\xbce\xb9\xec\xbf_\x1e\xac\xb3Oi\xf3?\xc3\'\xde\'\x8fY\xd8\xbfcj\x93\x19o\x16\xf3?g.k\xeagM\xe7\xbfk\x1f\xc8\x1b\x11(\xd8?\x1a\x9b\xb3\xc6\xfa\xe1\xf8\xbf\xa2\x1f\x98\xbf\xa9\x0b\xfa\xbf\xbb\xef\x82\x85\xc6\xad\xfa?\xf1jm\t\xe4\'\xda\xbfF\xcb\xb4\x1cz\xa3\xe3\xbf\x9f\x95&\xfb;\xa1\xe0\xbf\xc8\xe0\x0e\x18\x98\xab\xdd?b\x9b;j\xafZ\xf4?\xb8\xa8\x9b\t\x18\xdc\xf7\xbf\\\xad\x98R\xaf\xde\xcd\xbf\x8e5\x047\x0c\x0b\xfe?\xe2\x10X?\x96\xa2\xe6\xbf\x95K\x08^\xd17\xf6?\x96b\x9a\x04^\xc0\x01\xc0\x02\xa1\xe3:\x87T\xda\xbf\xe2\x93\xba\xe7\x82\x87\xf0\xbf\x1f7]q6m\xf4?Y\x1b\x17\xa0\xc5o\xda\xbf\xb6\x85w9k9\xef\xbf\x86\xcd8\x94\xb6Q\xb0\xbf\x95\xbcTd\x1c\x8c\xd8\xbf\xf7\xeb\x04`\xc4\xaf\xc6?\x9d\xd9\x9fw\x1d\xce\xc9\xbf\xde\x00\x0e\xcc\xd1\x93\xc4?F\x8c}\x88\xcd\x15\xf3\xbf\x00\xaf\xdf\xfe\xc6\x86\xaf\xbf\t\xf2K\x8a\xca\xe9\xdd\xbf]\x9de\x1e\xea\x0f\xfc\xbf\xefp\xd5\xf2\xd0\xe1\x02@\x98mI\xed\xf3\xf1\xe9?\xfck\x91Q \xcf\xe0\xbf\x1c\xc0%\xae\xc8a\xe8\xbf\xfb\x08h\x96pz\xea\xbf\xbb\xf1\x1aI\xd6e\xee\xbf\xb5\x18\xcf\xa4\xcc\xd3\xc7?\xeaJf\xb7\x1c\xd2\xe7\xbf3\xdeh\xc4\xb1"\x02@;\x9c\xa5\x02\xe5N\xee\xbf\xad\xa6\xc9\x19\x8c\xd1\xfc?9\xcfV^\xe7Z\xcb?+\xf1\xfa~\x988\x7f?\x17\x85\nZ\x86\xc8\xf1?\r\x12\xbaFw\xf3\xfe\xbf\xdd\xd7h\x1e#\x90\xce\xbf\xf2\xd9I}\xbd\x86\xbe?\xdb"`\xc43\xda\xe4?\x1b\xaf-;\xfd\x15\xfd\xbf\xdfhFx\x8e\xe9\xb3\xbfJ\x08\xe8\xee\x8d\xbf\x13\xbfP\xa3\xc4{\xe7\\\xd6?\xad\xf6\'\xdc\xba\x82\xd1\xbfzb\xa1,\tI\xd7?\xa7*\xe2C\xbd\xe4\xbc?\xa1\xe9S\xfc7H\xa1?\x9fl\x8c\x11r\x86\xe3\xbf\'\xa1\x8e\x7f\xcd\xd6\xec?\x0b\xf8p\x12\r\xbd\xdd\xbf\xb1\x01\xe7\x0b\xaa\x8a\xf4?\t(\xdfO\x1dl\xb7\xbf\x8cC8\xc7\x1c`\xd5?\xe9*\x12%\xa3\x93\xf0\xbf\x0f\xc2\x14\x19\xd93\xc2?U\x8d\xe6\xa2"+\xd6\xbf\xebc\xa58\xa8s\xe3?w<\xb31\xe4\xe9\xd2?\xa4\x97\x1a\xfb\t\xf0\xf9\xbf7\x19%\xb0r=f?\x1fX\x12K\x9dv\xe0?F\x00\x8a]\xd4\xcd\xd9?\xfe\x8c\xa17\x8bS\xd5\xbf\xdb\xe5\x8fd\x9fo\xf3\xbf\x8e\xf0W\xba\x9c}\xf2\xbfw\x85\x11\xa3\xc2\xc2\xa7?%\xb2 \x0c$2\xd3?,h\r\x8c$9\xb3\xbf\x80\ty\xba}\xaa\xf4?\xf8KJ\xd7\x07\xfd\x9b\xbf?\xd2\x10Ja\x15\xe3\xbf\x80\x05[\x15\x9c\xc0\xc4\xbf5\x96\xebcY\xc9\xe3?\xff9o`\xb5\xf6\xe4?\x9eV\xe9\xcc\xf9;\xee?\xcf\x1c87\x183\xfd?r1.+\xd5\x8b\xf6?\xba\xdb\xc1T3H\xc3\xbfl\x06\xff\x97u\xf8\xf4? N\xef\x84\x0f\xb7\xf5?&i\xc9om\x8f\x00@X\xfe\x05!\x8e\xb3\xef\xbf\x1b\xaa\xe1\x9e\x98\xd3\x01\xc0$^LH(\xb2\xed?\xa4\x92k\xa3\x11\xc5\xf1\xbf\x1bF\xf1u\xd0\xdc\xee\xbfZ\x7f\xf7\xd3\x13\x99\xd0\xbf\xad\xb4\xa2\xce)\xac\xd9\xbf\x9c\x0c\xd4\xe0\x05e\xdf\xbf\xd8 \\T\xe3\xa3\xcd?\x9dE\xd1\x1f\xfc\x1f\xf3?\x85 B\xd0UR\xed?\x91{T%\x12n\x03\xc00\xf1\xa77\xfc\x16\xf8\xbf7}O\xc5\x96\xd0\xe3?\xba\x1c\x94\xa7n\xcc\xf8?\xe5\x02$?\xd1\xeb\xe0?\x7fe\x16\x88\xbcL\x03@;3-\xb0\xd1r\xd8?\x8exU\xac\xe0:\x00@\xfb\xd3(\xd3\xe3\xc6\xfa?\x90\x14L\xe01Z\xd6\xbfj\x16\xe7\xdbJ\xfc\xf0?\x01\xe6p,I\x1e\xe8?\x1f]^\xe0\xddL\xfc?\xb2I\xce\xb0j+\xe0\xbf,\x01\x90\xdc\x83*\xe2?j\xc5\xa91\x96\xa1\xdf\xbf\x92\xba\x1a\xce\xfeh\xff?I\xcf\xaf>~\x85\xf2?Fw(N\xe7\xbb\xd5\xbf\xa8.\x9e\xaf\x9b\xef\xe1?\x0b\xe5\x9d\x97\xb5|\xe2\xbf\x0c\x88\x0bR\x17^\xd3?\xa5/\xadZ\x88o\xf8\xd3\xbf\x1c\xde\xd50\x14I\xfd\xbf\xbb\xbd#W\x03E\xf9?\x99\x81\x84\xca\xb7q\xe5?\x05y\x98\x06~^\xf6?C9\xbd\xd2G[\xe4\xbf^\xa8\xdc\'\xb7\xb1\xee\xbf\xee\xac\x0f%\x02\xdf\xe0\xbf1\xe0q(\xd0\x10\xc1\xbf\xed\x16\xc5)2\x96\xeb?2\xef\xaa\xdb\xae`\xf3\xbfr\x1bT\xd0\xeaF\xfb\xbf[\xf1\xf7\x1e\xb2\xbe\xcf\xbf`xy&\xe5Z\x04\xc0gb\xba\xbf\xbe\xdc\xf6?\xeb$\xa34\x0b\xd7\xed\xbf\x8c\xb2\x12j\xfc]\xf0?\xbc\x99\x1d\xd1\x94\x8b\xb0?m\xb6=\x8c\xbc\xea\xe7\xbf\xea?>A\xdf\x8a\xd9\xbfg]~be*\xde?\xff\x10\x7f5\t\x0b\xe2?7G\xdb\x98DE\xf8?pb\xe2o\x99\xb7\xe1\xbfp\t\xc6n\x90\x89\xad\xbf\x1bSa\x19\xd3S\x00\xc0\x8f\xb4p\xdeg\x9c\xc4\xbf\xb6m\xf9\x17\xae\xa4\xc9?\xb8\x959D\xf8V\xf3\xbf#\x13\xea=\xa8\x0e\xdc?K8\xf4\xf7eO\xc8?\xb8\r,v\x01\xf4\xf1\xbf\x90\x032\xacE\xb1\xea\xbfs_F\xaa\xd7\xb9\xf0\xbf8\xb1\x07\x97\xcc\xaa\xc0?\xf6\x90\xdf7\xcb\x9f\x02@(\x1e\x89)B\xfd\xd5?\x0e*c:Z"\xe0?_\x19\xb1s\xda\x85\xe0?\x91\xaa\xbc\xcf\t\x15\x00\xc0\xb1j\x95\xba\xba\xc1\xfb\xbf\xca:\x13\x84\x1d\xd4\x07\xc0\x08et\xf7\x1c\xc6\xc5?\x1a)\x19\xb1v\xc4\xdf?Y|O\x1e?\x07\xf7?\xa7\xe1\x9b\xd7"$\xbf?r\xf3\xf0\x19\xd3\x88\xd0\xbf\xf1\xf9]\xabK\x82\x02@\xcf\x0e\x8d\x06\xb1\x01\xec\xbfdUw\x1d\xb3+\xe6?%l\x7f\xff\xd6\xe3\xee?\xe6\xb2=\xea\x18\xeb\xd9?\xc0I\x82\x82\xee\x8b\xe9?\xec\xc4\x0c\xa6\x1a\xff\xe0?\xf7jn\xf4\xf60\xed\xbf\x80\xc4\x13\xe8\xfe\x06\xe1?PX=\xe9\xb4\xdc\xea\xbf\x90\x89\x010\xc9\x8e\xe5?\xe6\xec\x9f\x16\x95\xa0\xd4?\xe4\x8e\xdfr\xc8\x0f\xe6?\xe1\x87\x00\xc5\xd8\xdb\xec\xbf\x1d\x14\x16\xa2\x01\xaf\xf4?=\x07\xb1tL\xc9\xf3?\xb0\xec%\xbc\xddx\xf0?\xfb\xd4\x90k\xd6\xb0\xee?f\xb2tI\x86\x85\xe6?\xf6$\x19\x1a\x8d\x12\xed\xbf\x19\xea\xe9""t\x0c\xc0\x86\x01\xf3\xe4@1\x0e\xc0\x8d\xaa\x8f.\xc4S\x03\xc0)Mq=\x8ar\xf2\xbf?\\\xc3\x07\x83`\xff\xbf\n\x99\xf27\xd68\xf0?V\x8f|#\x08\xd3\xf5\xbf@A\x85\xde\xed\x89\xe1\xbf\xae\x12\xf4\xd3\x139\xe2?\x83\xbc\xe4\xd9M!\x07@\xb8\xbc\xfc_\xec\x0c\xe9?\xcc\x16\xd1\xe8\xfe\xf2\xfa?N\xe4\xa1\xf8A\xe3\xe0\xbf\xa5^\r\x0bel\xf7?\xc4\x12\xb9\xb5u\x18\xe3?\xe4\x87x\x19\x95b\xd0?\x96\xfa\xaa\xc9\xa4\xf3\xf0?\xe4\xc4\xaa\xef6\xeb\xe7?WF\xa6\xd9\xd9a\xe2\xbf.\x8a\x93\x82\xee\x85\x00\xc0\xbbD\xd6Z\x93=\xe2?:n\xf7K0}\xe0\xbf$\xd4\xda\xcf$\x08\xc6?\x02\xb3s\xe8\xab\x12\xdc?\x8f\xc9\xd2\xae\xd5\x12\x08@\x1cn\x9f\xfe\xa2\x8b\x0b@7}I\xdd\xe11\x04@o\xd9\xad\xce\x03\xfc\xd0\xbf\xe1\xd7\x13\xd5\x80\x99\x01\xc0\r\xf7o\r\x9aD\x03\xc0\x0e\x01p\xd3\x0f4\x11\xc0\xa2\xd5\xe0b\xa1\xfc\xdc\xbf+\x8a\xa7\xdey\xfc\xe0\xbf{\xa7\x90l\xf3s\xaa?\xafP\x93\x84\xa0\xcc\xfb\xbf\xb9\xbc\x05\x90\x82/\xe1?\xea\x81\xa3\xca"\xa1\xe1\xbf\xfb\x04|\xc91\xff\xf1?I[=)\x01\xac\xf3?\xb1\xbb\xdd\x92\xe9\xd5\xdb?>:\xddY\xbd\xe7\xf7\xbfI\x00_\x19^\t\xe2\xbf^\xcd\xa8=\xf0\xb7\xea\xbfT\xbd\xcf\xbc\x90\x07\x08@Y\xd5\x01\x06\x0f1\xe1\xbf\xb5|\x0e\xc8T\x86\xdf?\x1d{@\n\xd1\xbb\xe8?\x82d\x1cC\xb6h\xf1\xbf \xc9\xa4\xea\xf2\xec\xf0\xbfZ\xd2\xfa)\xa8[\xd1?\x81\x08w!\xe4\xa3\xff\xbf\xfbQ&\xf1\xb7\xd4\xfd?\xc4\xa2h\xd9l\x9bj\xbf\xdaz\x7fi\xcf\xe6\x00@\xf1\xaa\xa51y\xde\x02@\xaeHzv+c\xf4\xbf\x0b\xe1}\x9b\xa9\x1b\xf7\xbf\x9c \x05\x0e\xb5\xf7\x0f\xc0\x14\x9f\xa5\x98\x08\xd4\x01\xc0g8\x13z\x91\x1c\x02\xc0\xff\r.\x15\x19\xaa\xda\xbf\xd2\xd7\xbe\xdeg\x1c\xee\xbf*\xc8+\x9f\xc2\xb4\xfe\xbfsy\xae\xf2Y:\x99?\xe6\xa2CF\xe2\x1a\xf2\xbfug\xdd\xf8tD\xfc?ap6\xba\xc1\xed\xf5\xbf]\xe9\x9d\xdb\x80\x0f\xfd?9\x19\x8a\x18\x8a\x84\xe1?\xbd\xaf@jH]\xe1?\xb0\x13\xf5\x13\xe3\xd0\xd0?\xdf\x06\x03\xb4\x1b\x8c\xef\xbf\x7f\x87\xac\xd4\xe1>\xd5\xbf\xbd\x10\xf1\x83\xda\xbd\xd5?\x12\x86Ye\x9cf\xf6\xbf$\x00"\xae\xe9\xc4\xf1\xbf\x06\x88\xc7x\xd2\xf7\xe4\xbf\xbbW*\xd8\xa6\xa3\xc3?\xe600w\x0f(\xcf?\xdd\x9d\xbee\xf4\xfez\xbf\xe3\xf3,\xef\xcd\x10\xfa?J:\xcd\xe9M8\x04@4{\xe8\x04\x88\xe6\x02@Lv\xb0\x02]\xdd\xd0?\xb9\xce\xf9\xf7K\x1e\x11\xc0-z\xd1\xdb9B\n\xc0\x18\xe7(\x0b\xef\xee\xd3?C\xf1\xf7\xcb\x0f\x16\xe2?H\x0f\xd6\xaf<)\xdc\xbf\xb1\xf5\xb8\x92\xce\xba\xc7\xbfn\t\xa2e}\xe9\xeb\xbf\xf00.*\xbb\xa0\xc6\xbf\x01\x1f\xb6So\x8c\xe7?"\n\xf1\xbd\xc3b\xf9\xbfb\t|\xf9\xd6\xfc\xe9?\xccy\xe0\xa2\xdc\x1c\xc1?\x87 \xd7\x11\xf3\x0e\xee?\x1c\xc0\xb4\xbcQ\xbf\xb4?\x0e#\xec\x08\xeb\xf0\xfa?\xfdu\x03\xd8\x0f\x17\x97?:8\xb7\x83I\xa4\xf2?\xf4\x90o(+D\xfc?\xf8\x0e23Y\xcf\xe4?\n\x12\xfc(\xc2N\xf9?1\x96\x17\x02_\xb4\x00@>\x0c\x9c\x1c\xda\x06\xfd?iEO\xf4\x91\xbe\xf2?\xdcR\xe7j\x89\x9c\xfd?\xd3\xa2\xb4T.\x9b\xfc?g\xde3~\xd9\xe7\r@\xf3{\xfa\x98\xf8,\x15@e\xdc\xf4E6y\xd1?K\x04\xc1\xdc1i\x03\xc0\x19\xa2\xe9#\xb5J\x08\xc0\xcdi\x11\xd9\x17\xcf\xea?\xd9\xc0`\xe3\xe7\x9e\xbb\xbf\xb6*\x1e)\xe2g\xed\xbf\x07\x08\xc4d0\xc2\xfc\xbfA\xf8\x17M.O\xf8\xbf>U\xf0"\x06x\xda?\\\xfe\xd9\x92\xe1^\xe6\xbf\xd1\xe1\'\xd3uK\xce?\xe0lb\xe7\xfb7\xf5\xbfd\x8c\x86\x1btJ\xe8\xbf\xb1;\xa2\xa1=\x11\xd1\xbf~\xe8\x1fA\xc8\x9c\xd1?\xcb`5.n\xa1\xc5?\x1e\xba\xdbRN\xd9\xf2?\xe7\xd6\x99c\xef\xc9\xd4\xbf1iowf\xf2\xdd?\xb6b\x15\xf7\x9b\x98\x07@\xb7\x19\xce\xba\xd5\x0c\xe8?\xd7\xba\xb7\x89~"\xf5?\xda\x88\x7f\x0f\xf8P\x03@\xb2\xe4\x9ax]\'\xb5?EC\x94{\xbf\xe7\xe2?n\x9b\x11\xbd\xd0D\x00@\x95^,\xdbM\xa2\x11@(9\xbd+\xafd\x15@\xf0\x85\xdeZ\xb8\x01\xd6?B\xe1\x8b\x10N+\x11\xc0\xe0\xc1S@\x8b\x19\x13\xc0\x83q\x10\xc5\xa7\x9a\xba\xbf\xbeb\xad\xaa\xfc\xb4\xfc?\xbd\xc9D\xdc\xa6\x1f\xf1?[\xb46\xac\x01\x0c\x81?\xa2D\x89\x1c\x1bUt\xbfL3\x05\xdfZV\xba?[\x15*\xd7\xae\xf9\xf6\xbf\x9eV\xc1\x86?]\xe0\xbf"\xa2\xaa\xe5j9\xc0?\x9f/\xe7a9w\xeb\xbf0\x87\xad)\xd7\xc9\xdb?\xb7\xb8\xa5\xa3#\x15\xde?R}\xb4\x1a\xaf\x89\xd9?\x7f\xa0\xb3\xdb\xb5\\\xd2\xbfy/6\xae\xf4\x16\xb3?\xf1\xbb\x08g\x16@\xf9\xbfz\xa9\xb3\x99\xe9[\xdc?\xfe\x19Y\xa1M\xbb\xce\xbf\x99y\xcf\xeapB\xf0?\xddl\x83J\xada\xe8\xbf\xbfB"\x8f\xecL\xfd?\nH\xcf0\xe0b\xe5?\xd8\x969\x95b\xd3\xef?C\xf9\xc4\x96AD\x13@}\xc0\xc6;\xfc\xf6\x12@l\xb8C\\jC\x03\xc0\xcc=\x1er\x91`\x12\xc0\xf7jqO\x11?\n\xc0\x98\xc0\r\xc5c^\xed\xbfR\xfc&R\x9f#\xdc\xbf\xdb\x84\xa5\xa9}\x01\xcf?\xc3`\xe9\r\xfb@\xf7?\xf1\x11\xad\xde\xbe\xd8\xe0\xbf@0\xb1\x9e"\xa9\xd0?\x89\xa3\xfb\xa6\xd1\x0f\xe4\xbf\xeb\xbcc\xfd\x95z\xb4\xbfn\x0f8J\x91\xbe\xe9?;\x0e\x88y\x87\x1a\xde\xbf;\xcen\xf1\x00\xc9\xf2?\xf4\xba\x92\xcc\xc5\xfc\x85\xbf\x13\x94\xb6\xe2\xad5\xfd\xbf\x118\xd7\xb9\xa4\xac\xf2\xbf\xd2\r;_b\xcb\xf7\xbfw\xd2\x12i\x02\xec\xd4\xbf\xd5\xa6}.^\xbd\xc7?\xff\x83Bg\xc3!\xd1\xbf^$\xa3O\xac&\x01@\xed<\x7f/\x85\x8b\x04@\xf0\x84+\xd5\xde\n\xeb?@&v\xd2\'\x80\x05@\xf8\x8fE\xa6\xcc\xfb\n@\x9a2o:t=\x10@\x03\xb9C\xa78M\xad?i\xa6-\xed\x9eI\x14\xc0Xr\x99\xd2\xec\x11\x12\xc0\x97\xb5<\x07c\n\xfa\xbf\xe0q\x04\x9f\x14Y\xf4\xbfh!\xfaraQ\xfa\xbf6e\x13kI?\xf2\xbf/V\xa5\xdeZ\x94\xf3\xbfD\xb3@\x13\x82b\x01\xc0\xed\xf4]\x04\x89j\xf4\xbf\xdb\xe7\x90C\xa2"\xe9\xbf9\x85J\xa9\t\x19\xf0?l+\x87\xad\xfd)\n@\xb2B\x12\xfb\xb9p\xf0?\'#\xf6\xb3\xec\xd6\xf5?\xd8\x8f)\xebt\xa1\xe6?\xae\x87h\xd9\x13w\xf0?\x17\x01 1\x07\x9a\xe9?\xc3\x1a\xcd\xf9\xc5\xf9\x00@\xab\x12\xc0\xf9\xd5%\xf0\xbf*\xc0\xf7\xa5:\xb0\xc4\xbf\xe9\xca\x18\xe0I\x00\xe9?\x98\xb64\x87(\xbc\x08@\x9a\x0c\xaf\xbd\x92\x07\xf9?,pO&\x00b\xe9?\x14\x06x\xa2C|\x06@\x8b\xe5\xa4:\x87\x0e\xf1?A\x1f\xafmR(\x04@\x95\x9fI\x8d\x00\xda\xf1\xbfh\xe7\x85\x81\xbe*\x06\xc0\x07\x98C\x93\x18\xa2\r\xc0\xad\x9b\xed\x01qc\xfe\xbf\x88\x00\xe2R\xa7^\xee\xbf\xe7\xc4\x1b!\xd9s\xbe?\xe20\x02\x91\xd6\xda\xe4\xbfL\xf1*\x0e\x83\x1b\xf1?"\xfb\xb7\xf9\x8c\xe9\xe3\xbf\x8c\xdb\x08\xc6{\xd4\x04\xc0\x87!\xf0\xe68<\xf2\xbfZ\x97@\xaf\xd9G\x06@\x0b\xd3\x0c\x0f\x93\x11\x08@\xa0GK\xbc\xba\x9a\xfc?\xa1\x05\x87B\x87X\xef?dx\x93\xa27\x14\xeb\xbf\xe1\x0e\xd8$4|\xf1\xbf\x9d\x8c5\x9a\x00\xae\xf0?\xbe\xab.\xacD~\x8d?&\x88\x16)\x16\x1e\xbe?e\xc1\xa8\xa4\xb8\xa3\xeb?\xd6\x1b\x88+\tN\xc0?O\x8c\xe2\xf5\xf2\xa4\xe8?\n1~\xb0\x04\xe0\x00@*\xc8`Q\xb2\xfc\xfc?9\xcb_qFG\xf9?\xf2\x8b\x89d\\p\xf9?\xe5\'M\xc5\x07\xa4\xfd\xbf\xe2\xa7\x08\x9e[o\xfd\xbfq\xe4\xe2\t\xe3a\x04\xc0\xc0\xa4\xa2cc\xda\x04\xc0p\xf5\x96\x16\xda\xf7\xe5\xbf3\r\xdc\\\xe6\x9a\xf9\xbf\x04u\xc7Uvc\xe8\xbf\x9d-o30\x96\x00\xc0\xce\xe9Nk:^\xf8\xbfd\xb6Z;KB\xfd\xbf@\x16\xce\xc1q\x0c\xdc?\xc3*6RQ\xed\xf0\xbfe[\xf4\xe8w\x14\xfc?\xa0m\xe0\xf0L\xee\x05@\x19\xd4\x07\x12\x18{\xeb?0\xf5\xeb\x15\x90\x94\x03\xc0\xfc\xb5\x1fI\xa0\xf9\xda?Y\xc1.-J^\xf0\xbf\x88\xfaJ\x8dXf\xb8?=\x95\xed\xb68\xd7\xf6\xbfV\x90\xa7M\xea\xf0\xf3?l\xd3\x04\x90\x15!\xf9?{y\x8d\x92gp\xdd?\xd4~\xcb\xf5gp\xe0?\xef"]\xdb88\xf1\xbf\xc7 \x87n\xc5\x92\xe7?a\x99P/\xdb\xe9\xd6?\x9f2Yi=j\xc2?\x0c\xe7\xeb\xe5\x84\xb7\xf5\xbfu\xc9\xc3\xf0\n@\xff\xbf\xe5\xda\xc3\x0bEz\xfc\xbf\xd8X\xcbpj\xe6\x0c\xc0\x9b_\xce\x9a\x89\x94\xe4\xbfJ\x04\t\x8d\x06\x91\xcf?\x99I\x0f\xf7cp\xf9\xbf\xb9zRb\x0fW\xf2\xbf\xa5\xc13\xfb:\xf2\xd1?\xcc\x15\x81/\t\xfd\xf4?@ <\xc6ua\xc4\xbf{\x8dr\xc7\x14,\xf3?O}\x99\x00\xff\xa4\xec?\x05\x1aM>\xa1=\n@\xf6\xd0!V\xd6)\x05@x\x95k\xb9\xcd\x82\xe0\xbf\t{\xceA\xc9\x16\xe8\xbf\xf4\xd8\x1b\\b6\xb7?A\x19\x98\xbe0k\xf5?X\xbfw*\xabN\xd2?r\x0c\xc8\x84P{\xb3?^*\xc5\xf4\xfc\x14\xf0\xbf(\xb2f\x8a\xdd:\xae?5\xed\xea\xfb\x101\xe6\xbf\xc9\xf2LK\xb1l\xf0?\xac\x98a\xf0B\x00\x84\xbf\xe7\x07\x80j c\x00\xc0w\x14V\xd7\xda\xfc\xd2?\x03\x03\xb9\xd1\xb9\xc6\xee\xbf\x19\'}\xfa\xe5\xa5\xf1?9\t`\x10jF\x05\xc0\xf4mHi\xbb^\x04\xc0b\x80\x18\x8bs\xb7\xd7?\xf5i_\xd6f\xa4\xf6\xbf\xfb\xbc;\xd5\xd3\xbe\xf3\xbf\xd0\x18\xf4K\x8d\xea\xf5\xbf\xa4\xa6\'\x8c"\xe8\xf3\xbf\xa7L\x85>\x90\x11\xe1?b90\xbe|\xda\x02@\x1b\xbdY\x98Q~\xfe?{[\x00\xae\x11\xee\xf5\xbf\x00\xa3U\xcf.\xb7\xf7?\x00\xca\xa0p\x9a\xac\xe4?y\xdaI9~\xe3\xf3\xbfh\xdb\x19\x87\xb3\xe8\xdd\xbf\xfb\xfd]\xbd\x12\xf2\xf0\xbf\x89\x94\xe7eXH\xf3\xbf\x00\x1c\x98P\xcd\'\xe8?\xff\x9c\xd6\x88\xc4\xef\xc4?\xeb\xe3\xe5\xd9l\x89\xf9\xbf\x8c^\x9b\xbc+\x98\xe4\xbfj\xbe\xf1K\xb7Z\xf2\xbfj\x84>\x16z\x1c\xf5\xbf\'\x06s\x02\x97Vu\xbf\xd8\x84\xbe\xebb\x13\xa5?0\xf4\xdbQ;@\xe8?\xe8\x0e\xde\xef\x97\x90\xfa\xbf\xd2!7\x92\xd6U\x01\xc0,\xddtt\xbdI\x02\xc0\xfa\x8c\xafJ\x8e\xac\xeb\xbf\xb6eH\xf2\xf2\x9f\xe0\xbf\xf6.*L\x8f(\x00\xc0\xf4\xeap\xbf\xd9\xc1\xf1\xbf\x90\xf9\xf1\x91K\xd2\xdd?q"71nX\xdb?9\x06\xf5\xb5\xe7J\xf8?\xd0\x08\x93\x1b\xa1\xec\xf0?P\x9c\x9c\x1f\xb6\xeb\x9d?KnL\xbe\x0c5\xcf?0\x02I\xc5\xab\x93\xec?\x11\xdf\xc5\x96T\x88\xd2\xbf*\xd1\x12\x93\x8cw\xb5?\x04[\x859\x08K\xcb?\xf7\xe0r\xd7\x96\xfe\xde?\x94\xee\xc7\xb8\x03\x9f\xe8?WJ\xae>c7\xe8\xbf\x02_\x81{\xfbF\xfc?=\xe8\x96\xa4\x9a\xb1\xf2?\xc1c\xedR\x94\x0c\xe7\xbf\xc1Fq\xdf\x10\xfb\xc0?\x02\xea/\x06\x90\xa0\xd1?\xe9\xd6\xa4Q\xff!\xf8\xbf\x85X0t?[\xe4\xbfH\xd2\xf90\xaa\x0f\xe4\xbf6\x06\xbc\x85\n\xfd\x00\xc0\xde8\xa1D\xb3\xef\xe0?\x11f\xe4\xeba\xea\x01\xc0\x96v \xa2\x0bN\xe1\xbf\xba\x14\xa9\xa1r\x98\xcc\xbf\x1e\xa0\xaa^\x9dn\xdf\xbf{V\x00\xf3i\xaa\xe8\xbf\x1f\xd8\x0fM\xa6\xdd\xb8?\xffy\x92|\xb2\x0b\x01@\x18\xc0\xf6~\xfc\x9a\xe3?\xb8`\xbc\xa2E\t\xe5?d:\xdc\xa3*\xc1\xd9\xbf\x86\xa2\xca\x1f\x08\xc1\x01\xc0N\x06x\x80\x93\xba\xef?\'\xa5hN\r\xaf\xde\xbf\xf7|\xbc &?\xfa\xbf\xaf\xbc\xd6\xa8\x82\x9c\xe5?\xe6[A\x8c\xfd\xc0\xe9?\xe5)c;\xbd\xbf\xf4\xbf\xdeB\xf5D\xbfo\xe3?\xc1\xde\xa7Y\x95d\xff\xbf\xa5\xebN\xa5,#\xab?\x96p\x832co\xdd?I\x97t\x94\xec\xf2\xf4?,|\xfa\x0f\xec\xd0\xf6\xbf\xcb=K|\xd4\x84\xec\xbff\x16\x13\xd6\x91\x86\xf8\xbf\xf2\xa9aTEr\xe8?\xad\xf1K\xce\x83\x9a\xde\xbf\x88\x00\x1f\xa2\xa1G\xc4?\\b_\xdc(\x99\x06@\xbb*\xe7\xd8k\xf3\xf0?\xdak\x96bT\n\xe1?H07O\x0b\xe0\xf3?\x99\xe8\x02<\xe0r\xee?\xbaY\xad\x936\xd3\xb4\xbf\x17\xfa\x9alH\x12\xf1?\r\xf0\x0e<+[\xf0\xbf\xd6\xfe\xeb&\xc2l\xed\xbfQG\xbd\x0fr\xa1\xf8\xbfw~\xe6S\x00J\xcb\xbf\xdb\xb1\xf8\xf4\xf8\xc8\xf8\xbf=Y\xec\xb3r\xef\xfd?[J\xbc\n\xefp\xec\xbf\x14\xe7\xa6-Y\x14\xee?0\xef\xde"\x83\xd5\xc5?2\xc1\x92k\xf8Z\xf4?;\x932\x8d\xa5\xd3\xd0?h0\xfe_T\xc6\xe7?\x91\x0f\xb5\xc4\x10\x9c\xeb?\xd3F\x8c\x0fpq\xb1?)\xdb\xd5\x0bR\xa0\xe2\xbf\xaaY\xc9\x02\x01\x9c\xc2?\x83B\xbc\xb0En\xfc\xbf\x964\x0f\xc3\xe9\xb7\xcc?\xff#\xbdV\xde^\xf2\xbf\xdc_\x06o\x9d\x0b\xee?Ps@\xe5`\x15\xff??\xa4\xbb\x15x\xcd\x02@d\xd9\x91@\xc6\x1b\xf9?\x88FS5\x8ft\xe1?\xb0\xa5p\x1b5\xb5\xcb?\x99R:M\xeb\x80\x02@\xe2)\x98\xc4\x13\xa5\xe0\xbf\xa4|0*+F\xf1\xbf\x8f\xa7\xf8P\x00\x03\xd0\xbf\xf6\xbc\xca\xbe\xac\xc2\xf8\xbf\xd2\xc7\xeaY\x8eR\xe3\xbf\xd8C\x90\xf4\x8e%\xe7\xbf\xb0\xf8@40\xfd\xd6\xbf\xd0\x8d\xd4i-\x93\xf3?\x87 \x18\xec\x8f\r\xba?+\xc8\xe8\xbc0\x95\xe8?\xdc\xc9\xde\xa8\x8e\xa9\xf8?\x99C\xfd\xea\x83\xc1\xf2?\xf0\\\nU\x81\xb9\xf4\xbf\xde\r\xcb\x08\xe2\xee\xe7\xbf\xea\xd1\xafG\x93{\xca\xbf\xb4\xbf\xbf\x1d\xd2=\xd8\xbf%\xd03\xb5D\x07\xc5?D\xb5\xc8N\x0b\x86\xe4\xbf\x01nWl\xff+\xf4\xbf\xbd\x18\x87\xc6\xbc(\xf2\xbfXz#\xa9z\x1e\xa5?\xdb\xa3\xc3\\\x0fh\xe3?\xefs\x86!YO\xb8\xbftB\x99\xe0\xae\xab\xda\xbf"\xd2\xb9\x05\xa3\xf5\xe8?yy\xc9\x03\x06\x1e\xf6?K\xf1\xf1\x12\x83\x06\xbc\xbf\xe0\x91\xac\xf27\xd0\xd0\xbf\x04y\xb3v\xf6\x01\x02@\xd8G\xbcR\xbeM\xe2?qk[\x98\xf6r\xba?\xd8p\x90\x1d7\xaa\xbb?\xaa\xbb\x10\xb7\xb9\xab\x00\xc0<\xb8\x19\xb6T\xa3\xf3\xbf: \x82\x91N\xd2\xfb\xbf7\xa4\x91\xd7V\xe5\xee\xbf\x00\x15\xda\xb0\xd5\xfa\xe8?`u\x16\x90oU\x06\xc0\x82\x8c\x92\x87c+\xba\xbfL\x950\x82$8\xec?\x1c\xb0\x97\xb4\xf5\x18\xf8\xbf1\xb7Jd\xa7S\xc5?\xab\x1b!\xa7_\t\xcd?\xc8\xa0\xf0\x84\xcdG\xe2\xbf\xfc\xd8\x95\xacTC\xfa?\xcc\xa7\x9c\x8a\xc4\xc3\xec\xbfMq\x81\xc1Pw\xe8\xbf>^\xde\xe7H\xbd\xe5?\x0e\xa8\xae\xf5?o\xf1\xbfK\x01\xd7\x9a\xf8\t\xef?1x@\xa9N\x9b\xf8\xbf>\xb7\xa9\xa5*\xa7\xd8\xbf\xf1\xa0\x8d\x9e\xe4*v\xbf-\x9b\xe9g\x83!\xee?5%j\x9c\\\xc0\xf9?B0\x1c\xdd\xea\x93\xe5?\xd5\x8frtt7\xcb?tr.G\xdc\x8e\xea?v\x87\x81N\x1a\xa7\xf3\xbf\xae\xa2nbD\x98\xdd?\xb8\xfde\xf7\xd4h\xc5\xbf\xd5\x05\xcbD.>\xf7\xbf\x17W\x16\x9c\xaec\xda\xbfm\x05\x06\xa2\xf3}\x04\xc0\x13?hS\xf1&\xee?\xe7A\xe1?\x81\xcb9\x11\xaee\xe6?\\4\xcd\xc1.1\xcc\xbf\xb4\x1f\xb4M\x8cF\xf3\xbf\x9a\xbd\x8d\xf3\xec\x8b\xfb?\xac\x82\xd2\xd2%\xc6\xe7\xbf\xfeU\xe2_\x1bi\xc3\xbf=M\x9d\xba@7\xf2\xbf"\xe7\xad\x0e\x1a\xb7\xf4\xbf\xd8\x8e\x9fw}.\xec?\x0c*\x17;\xa20\xd6\xbf\xb6\xfa\x98\xf8C\xba\xf2\xbf7\xff;\xc1i\xbc\xe8\xbft(>5Jv\xbe?\xee#,h?\xbe\xe3\xbf\x18\x0e\x9fF\xab\xd1\xdf?\xb0l\x98\xb5M\xe7\xe4\xbfF\xa5S\xdb\xe1K\xdf\xbf`x5\xfc\x045\xf8?qY`sv\xc6\xfe\xbf\xe9\x8a\x14\xc8\xe5\x00\xda\xbf\x8e\x93j\xd0\xb3\x12\xce?Y\xbf\xbf\xd7\t\x8c\xda?\xe8\xb7\x92\x13\xb7\x8e\xbc\xbf\x03\xed"\xd7\r\xbe\xef\xbf27\x0e\xa89\xf2\xd6?*\xd6G\x02\xfd\xf9\xf3?!r\x8e\xfap\xa3\xde?\xa9\x841\xd3\xb0N\xdd\xbf\xe5\r\x99$H\x86\xf7?d\xa9u1\x0b;\xc1\xbf+\x11\x1dS\xa40\xf5\xbf\x08KT#\xcdA\x03\xc0u!+\xa7\x04F\xae?\xad\xa5\x1a\xcb\x91\x01\xdd\xbf\x9f/\xafq\xe3\xa8\xc9\xbf\xc6$\xbd\xfc\x14\xfa\xf6\xbf\'\xd7#\xa7=\\\xf4\xbf x\xe4\xae&\xf1\xd9\xbf\xbb\x85\x92\xdb\xf7\xc5\xbf?\xa2\xc5\xe1\xa8\x11\xcb\xf2\xbf\x85C\xad\x9d!\xf3\xef?\xa8\xbd8\x04h\xc6\xd2?\x1b|\x1c\x05\xe7a\xcb\xbf\x0c\xd4\xe0Y=\xf7\xcd?\n\x8bv(B\xcb\xfd\xbf\x19\xc8\xaf\x9f\xf7\xec\xc4\xbf\xbf\xbd\x84\xd8\x94u\xf9?\x18\x81\xc7g\xd3\xae\xca\xbf~\x8b\x9eR\xa0\xfb\xfd\xbf\x93\x1d/\'\xf6\xdc\x0c@\xe8W!\xe5\x85X\xef\xbfy=\x0b?+\xc5\xec\xbf\xd6\xe1\xf7|\x08\x9a\xe9\xbf\x8e\xd2\n\'\xcbc\xa4\xbfcW\xe34\xb6_\xfc\xbf\xec*&\xbf\xaeW\xd9\xbf\x1cx\xd0\xe3\xe3\xee\xea\xbf2\xc7\\9<\xfd\xec?\xb4y\x88\xf8\xcc\x01\xe7\xbf\xf2f\x89\xe53\x87\xdc\xbf\x8a\xaf%\xf6\xad?\xdc\xbf\xef\x86\xa8\xfb\xa7\xd0\xe7\xbf\xc4\x97\x10\x05\x90X\xd4?\xeb8\xb1\xafT\x86\xd1\xbf\x86\x80\x05G\xb6\xcc\xeb?\x16\xcf\x9a2k\x87\xe5\xbfC\xe8[\xc6#\xbbw\xbf\xaf\x17"\x0f\x917\xf2?Pl\xcc\xba\xbeJ\xdb\xbf\x93\x13sw0+\xc9\xbf\xbc\xf3r\x19b\xa7\xe1?\xc1\x1c\xfa\xb3\x86\xeb\xd5?jza\x8e\xb4\xc2\xe3\xbfn\xe2)k\xfd\xb0\x04@\x12C\xe4\xe0pp\xd5?3\xb3=M\x16~\x01\xc0\x1aFC\t\x80a\xf8\xbf\xab\xb5v\x11\x9b\xa2\xea?\xd8\xdf\xfe\xb6EL\xe8\xbf\xeeF\x8f\xef\xe2\xa7\x04\xc0\x80`\xaf\x03\xbd\xbd\xef?\xe0\xb8vU\xb4\xf8\xf0\xbf\xad\xae7d\x10\xa3\xa8?7\x9d\x17$ \xdb\xca?\xf8\x19\xb8\xaa\x9a\xdf\xf0\xbfnac\xcd\x07E\xf9\xbf4\xc6\xe4I\x8c0\xe3?\xf0\xfbB\x08\xcf\xb5\xea\xbfmq\xc2\xba\n*\xe6?\xcf*\xcd\x85\x13N\xe9?\x8c\x15X\xac\x06?\xf8?;\xd6n\xe5\tu\xf7\xbf\x94\xc4\xf2\x08A\xc1\xe9?\xbd7_\x0c\x83B\xfc?\'\x89\xcb\xc1o\n\xdd\xbf!a\x94\x05<[\xd4?n\xfb\x8b\x0c\xfe\x0f\xcd?\xf37\xe8\xe0\xcbK\xe6?\x13lx\x1c\xddJ\xd2\xbf\xd9a\xcc\x9b\xc4+\xa6?BPf\x80\t\x04\xca?\xbe\x85w\xf82\xb8\xf1\xbf\xdc\x14\xeb\xb4\xf7v\xc5?!\xd2\xda\x14\x08\xd8\xd4\xbf\xe2k\xeb\xfd\x01\x93\xe8?Yn\xa9\xf4\xca\x81\xd4\xbf\xc2\xb0\xe6\xcd\x13{\xf3\xbf\xa3\x89L?\xc5\r\xe1?\xed\x88Lz!\xd5\xf3\xbf-\xa2`\x03\x15N\xba?\x83\xb5\xce(\x13\x18\xe2?\xbd(Z\xfd\x94\xc1\xb7\xbfr\x02X\xdcJr\xc9?\n\xc0\xf1H\xae\xab\xf0\xbf~\x81\x95\xca;T\xf5\xbfn\xe0\x99\xc8\x9cx\xe4?\xd0\xdaF\x0e\xa1E\xdf\xbf\xc7^\xfbD_m\x00\xc0m\xd0\xa1}?`\x02\xc0\x8b\xad\x98rjN\xf6\xbf\xd8\x80x\x8e1\x01\xce?\xf6\xaf7\x83$\xd2\xe2\xbf\x8f\x96\xc5\xd4\x05\xa6\xe0?]|\xf7\xcb\x0e\x88\xef?p\x11\xed\xc3\x95\xfb\xca\xbf\xa7\xd0q`8\xcf\x05\xc0L\x08\x94\xf4hk\xf6?r\x08\xf7\xdf\xf6`\xc7?\xce&\xd8e8A\xfe?,RN\x9ch\x99\xe7?\xfc\xac\xae\xba8b\xe0?\xe8\x92S\x05\x9d\xad\xad\xbf\xe7\rA\xf2\x17\xc7\xe3?U\x8b\x80}]\xad\xf5?\x13W<\xc1VQ\xaa?/^\xad\xcbI\xe2\xe2?\n\xd99o\x8c\xcb\xf7?\xec\xd9\xaf\x02\xaa\xcb\xd7?\xf6\x12\xd4Q\x84\xb0\xf4?\xb0`P\x93\x02\x1f\xd2?3\x0f\xd5\xfe\xc0R\xee\xbf#W$%\x8c\xb9\x90?\xf3Sp\x86c%\xea\xbfQ\xa1\x96\xcbvh\xdd\xbf\x91~\xca\x90\x8bA\xf6?m\x1d\x96E\x19\x11\xca?\x014\xb46 \x12\xa6\xbf%\x97\xd4\xbf\xc3\\\xf2\xbf\x7f\x96\r\x03\x9d\xb7\xf8?\xb7\xb7\xcb\x1a\xce\xda\xf4\xbfAO\xf5\x9c!\x1a\xe2\xbf"R\xd2b\xff\xd9\xe4\xbf\xbd0\x88\x9dp0\xe1\xbfj\xbc\xbam\x1e}\xc3?4\xb6\xe2\x17\xc0\x7f\x03\xc0>\xf0\xf1\xfa\xfc\xd1\xe4\xbf%\x8c\xcd\x0e\xff)\xec\xbf}\xa4>M\xaf\xa1\xf3\xbf]\x8d<\xac\x19k\xc1?3h\xa2F\xe1\x91\xc5?\x03\xfe\x9e\xce\xd7\x8c\xd9\xbfKG\xb6%\x8e,\xb7\xbfMe7\xdbt?\xfb?\x07\x0e\xde\xc14\xe1\xe3?m>\xe0\x88\xf9\x15\xf4?<\xd0d\xb6\x1a\x1c\xd8\xbft\xd7\xec\xf5\xd6\xb7\xa7\xbf\x9c\xa7_\xfb\r\xe2\xf1?\xec\xd3\xb2\xa9\x82J\xe9\xbfN\xa8j#\xd64\xe2\xbfP\xcek\xd3\x12\xc7\xfd?\xc7=@oJ\xb3\xdd?_|\x81\x05d\xb6\xe2?\xf6\xb5\xfe\xf7\x12\x9b\xe4\xbf\xafe\x93j\xe2E\xe6?\xad\xdcX\x89$9\xd6?\xb5\xb4\xf0\x9b9\xb0\xce?\x0et2\xb5]\xcd\xee\xbf\xdeb\x90O\x9cv\xf1\xbfT\xf2\xee\xe5\x11e\xf3\xbf\xbeZ6\xe5\xc6]\xf8\xbf\xdd+\xd6\x9b\x8c\x00\xe3\xbfj\xd0|\x07\x993\xfa\xbf-\xba\xb06\x97L\xf9\xbfE\xbf@3r\x15\x01\xc0\x0c\x087\xd1\x0b=\xef\xbfAM\xd7\xda\xf3\xd0\xe1\xbf\x83\xc2z\xe8\xd0\xbe\xe7\xbf\x8e\xc5\xc2\xf0G\x12\xe4?\xc4\xda\x128\xc1C\x02@\x07\xfdv\xa5\xdaa\xb8\xbf\xc5R\xc5)\x9a\xf7\xfa?\xf5\xb3\x89\xe0\x9a\x89\xea?\xf8n\xc1\xf5Yj\x10@u\xb5\xb7\xb6"\x9a\xfc\xbf\xb4!%\x92\x01\xdd\xba\xbf\x97\xbf\xeb\xa1\xfb\xfay?_\xac\x127Iq\xd6?(}*\x1b\xaaD\xf8?\xa0\xbf\xbe\xc7\x17\xb3\xe1\xbf\xf2\x87/\xe8\xb8.\xec\xbf\xe0\xaa\xa8\xcdE\xc4\xd3?\xb9.\x85\xf8\xc1\x10\xce?\x93\x8d\xf3\x0f.\xb2\xf0?s\xfc\x9d\x0ec\xe4\xe1\xbf\x83P_\xb3P\x83\xe1\xbf\xf8\x1f\xf9\x0cR\xab\x05\xc0\xb5L\x92P<\x92\xfb\xbf\xeb\xf9D\xbfi\x89\xc4\xbf\xe4m\xdb\xc1\xcd\xf4\xef?\x89\xb7-\xef\x8dS\xf1?6\x896\xb0h\xbf\xfd\xbf\xfbp\x1e\xa0\xc8"\x01\xc0<\xd3q\x8d\xf5\xc9\xdc\xbfs\xed\x15.&\x9b\xdd\xbf\xb3\xdfM\xfb\x0f`\xd1\xbfI\n\xb1+h\xdd\xfc\xbfz\xa5\xd1\xacS#\xdf?G\xc4F\x00\x13\x1a\xe0?z\x05\xdf\xcb\x1d\xe9\xc6\xbfq0\x95a\x0b\xcc\x04@\xe5\xe1v\xf7\x18\x8d\x00@:\xb0\xd6\x1f[S\xfd?t\xe9I\xabD\x17\xfb?\x13R\x1bp\x08\x85\xe0\xbfE\x17\xe7\xe85\xd4\xfc?(\x03IV\xc1\x8e\xf4?\xa5\xa6\xcca\xd5\n\xf7\xbf\xd4\x0e\'\xcd|j\xa0?S\x8e\xfb\xcb\xd1\x9c\x02\xc0\xae\x7f\xb3$h\xda\xee\xbft\x89h\\z4\xf5?\xc2AajQy\x13\xc0&Cg\xff\xc0\x10\xe7\xbf\xdc\xadn/\xc2M\xd8\xbf!%\tK\xe4\t\xbd\xbfT.&\xa2\x17:\x05\xc0\x18}\xa5\xe1\xd8\xbb\xf9\xbf.}\xd4\x14%\xb5\xee?\xe1\x1c^\xbd\xcd#\xc8\xbf\x1e\x05\xd3\xc6_G\xbe\xbf"\xbc\x9b\xa1\xfa\xef\xe9?\x88?\xd4O\x00\xda\xf7\xbfO\xd6\x01\xac\x05\r\xcc\xbfX\xe9|%\xf3\xf3\xfc\xbfT\xdb|\xb8@\xf0\xce\xbf&\xe3Y\xbf\xf5A\xcf?+-\x11\xdco\xc6\xe1\xbf\x8bAN\x9c\x82x\xca\xbfkrim\xddF\xfc?\xa2\xa9\xef\xff\'@\x06@\x04zys\x12\x80\xfe?o\x93\xbb\xbc\xac\xcb\xf0?\xaee\x943\x19\xd9\xee?\xc1\x88\x06\xf7\xb7\t\xd9?\x9f\xa9\xfel\xc9~\xf1?\xa2\x01\x06\x87+\xab\xe8\xbf\xcdd2 \x1e\xd7\xc7\xbfq\xa4|#\x05Q\xfb\xbf\xa2_\x1c\xc7\xb3T\xf9\xbfK\xfac\xe2\xc8\t\xf8\xbf\x16\x1f\xdb_l\x98\xf7\xbf$\x90\xf6\xbf\xc8\xfa\xec?\xc2\x19\x91L\x80P\xd0\xbf\xc4F\xa7\x82\xad\xf8\xfe?-\x8c\x92\x9d\x8e\xa7\xb4?Q\xcf#\x95\xd77\xfe\xbf\xd5R\x8e=\r\x91\xe0\xbf\x1d>\x97\x89\xde+\xf0\xbf[/4\xb4M\xd3\xb3\xbf\xa7\xe4(\xde\x19\x8c\xe4\xbf\x17\r\xf8\xfc\xf2\xb1\xf2\xbfC\x82.D\xd3\xdd\xf3\xbf\x88\x88wg\x06\x10\xf4\xbf#\xd3\xe7\x9c#\x08\xd7\xbf\xacb\xaf\xa6\xb3I\xdb?\xec\x8a+\xbc\xda)\xf7?\xe9\xc8\x8fg\xfd\x0c\xff?\xf7r\xc7Y\xd32\xfe?\xc8\x0ep\x0e\xa2\xa2\xf6?\x82!\xfa\xebh\xe4\xc4\xbf\xedgy\xfb\x1e=\xfd?\xf7f\x97\x8d\xc7\x98\xf8?-{N^/T\xe4\xbf,\xc9\x83\x1c\x80\x90\xf0\xbf^\x82\xf8\x10\x17\x81\xc4?\x84\xac$\xea\x0f5\xc9\xbf\x99Z\xfb\xcbG\x1c\xf0?\x88\xa9\x98\xd0\xf8\xe8\xd5?DA|D\xa7\xa6\xec\xbfbU\x16.\x16\xe9\xe1?36^\xa1\xc2\xd6\x06@\xe7\xbf\x13\xce.#\xed\xbf\x08_\x8bL\x0e\x0b\xf7?\x81\xa7\x80\xb4K^\xc8\xbfst~!\xaaD\xfa??i\x7f\x10b\xa9\xea\xbfi\x97\xa8LI\xd0\xfa\xbf\xce\x19yJ\xfb\xfa\x08\xc0\xa9\xcf\x05\xbbt\xe4\xfa\xbfQ\x8a\\C\x8c\x03\xe5\xbf3f\x17B\xa2\x05\xea\xbf\x1a\xae,\xcfOk\xf4\xbfL\x95\xccr\xee\x1f\xd9? %~\xc8\xb6\xee\xdf\xbf\xbe\xdfo\xa8\xd9\x83\xfc?\x804\xf1\x03e\xc7\x08@(3\x92\xa3\x9eq\x01@\x87\xbf\x7f\xda+\x9a\xdb?\x1d\x90\xb9@i\x0f\xd0?\xe2\xdc\xc4~\xfc\xf6\xf7\xbf\x19\xa3\x96\xa2su\xf6\xbf\x18\xbcYz\x10\x10\xd3\xbf\x88(\xf275m\xec\xbf0\xf0\x88\x12\xe1\xcf\xe6\xbf\x19<\xde\x85`!\xf5\xbf\xc8\xc7\xf2\xfe\xf9\x9d\xb6?]\xa0G\xac\x1bB\x11@9\xdd\xea\x10\xed\x8c\xd0?O\xb3=Q}r\xc2\xbfch^\x8a\\\xae\xf9?F-\xb2&4\xff\xff?c\xe4\xd7\x84\xb5\x11\xf3?4\x08X1&k\xe8?\xfd\xaa\xa1:@\x8c\xed?)\x0b\x1aI\xc7\xea\xfd?\xed\x9f\xd5q\x14\xb7\xd7?\xc9\xe3]D\xbd\xca\xdb\xbfH\x9b\xb7\xce4Q\xf6\xbf\x0b\x84b\x880\x80\xe9\xbf\xdc\x84H\xcb\xde\x19\xfe?U\xfaaz\xf9\xf0\x01@\xf6Y\xf8R,\x8b\x00@\xc0\xef\xb1Q\x0eR\x03@5\x15;Y\xe5?\xf9?\xf0\x9a\xa1\xc9\x86\xdf\x10@&\xfa\xe2\xaeL\x83\xf9?Y\x91\xc0\xf8s\x9c\xa5\xbf+@T\xcd\x9e\x8f\x07@\xbcBm\xd6W\xbe\x0b@\x8av\x9f\xdaLR\xf8?\x03O\xac\xfc\xf1\xf4\xc4\xbf\xbfp\x00\xc0C\x00\x00\xc0\xf2\x91\x8e\x112\xc6\x12\xc0\x99+\xad12>\x0b\xc0z\x03\xae\x00:P\x14\xc0.i;g&J\x0b\xc0\xb7\x0e\x1dY1&\n\xc0A\xc2u\xf7d\xab\x06\xc0\xfcb\x1a\n{T\x03\xc0\x00\x0f\xc0\xa3\xe4\xc9\xf9?\xe7]<\x9f\xcb\x9a\xf6?\xc3]\xddj\x95\xa7\xd9?\xba\x0enT\x12\xa3\xe3\xbf\x02L%?b\xfd\x00\xc0\xcaD\xfe\x10\xed)\xfe\xbf\xca\xdez\x03K\xad\xe3?\xa2\xbdE\xd3\xa8C\xc7?\x9e\xd9\x19:|\xf2\xb6?eH\xa0_\xccS\xfb?\x9daa\xbd\x8d\xed\xd2?`\x9c]u|/\xc5\xbf\x1as\x8f\'\xe8\xa4\xf6\xbf\x0c\x89\x02i-\xb3\x01\xc0\x88p\x9f\xe3\x9c}\xc8\xbf\xc3\x87\xbf\xbc\x85\x05\xf4\xbf\xf0\'\xc6\x82\xab\x12\xd8?-Di\xf4eR\x13@\x04\x91\'\x02\xbek\r@\xb4\xda;\xdc\xfa\xbb\xe3\xbf\xa7\xdd\xdb\xd8:\xbe\x06@\xf2;\xab\xe4\xa7\xb0\xe4?/\x88\xa7Y\xe0\xfd\xe8?\\\x8b\xf0\xbexB\x00\xc0\xda\x87\xe5\xb8\xf3\x08\xee\xbf\xc6\xc4\x0cV\x81c\x0c\xc0\xdb\x07\x97\xba\xc9\x98\x02\xc0\x16\x10\xfc+C\x84\xf8\xbfe\xb0\xad)\xd3m\xf0?I\xff\xc4:\x94\x81\xef\xbfi\x9e<1z\xab\xd3?\xf6q\xceQ\xa6@\xe3\xbf2 \xe1\xef\x10\xb7\xc3?\xff\x13\x0bI\xa0\x85\xc6?K6\xc1\x0bJ\xe9\xeb?T\x87z\xdd\xcek\xd4\xbf\xbe\ty\xca\xb0U\xf9\xbf\xf8U\x94\xf2\x0ef\x99?\x12u$_\xa0}\xc5\xbf\xeeN\xf3\xe8\xfb\xfa\xe9\xbf\xb1\x1f\x94O\xd5\xa0\xfa\xbf\xd7N\x8d;\xc9X\xeb?0\xd0\x94\xf5\xd0\x04\x01@d\xb0\x15\xaf\xd1\x88\x00@;d\xc3\x06\x19\xf9\x03@\xbd\xd5\\d\xacj\x03@\xab\xc8\x94\xafV\xa1\x0f@0\x84\xfe\xa6\x1c \xe8?\xf4|\xc9\xac]m\xb3?\xee\x05\xe0(b\xa8\xf1?\x0c\xa7\xf5\xb3\x07\xff\xfc?\xf8\x96W|t\xb1\xf4?\xaa|b\x0be\x9c\xe3?\xb7\x91\\\xd2\x96+\xf3\xbf\xf9\x9ac\x0b\xffW\t\xc0\xf5b\x9b?0\xf0\x06\xc0}\x10W>\x13a\xf8\xbf]\xec\xc8\xc7d\r\xcf\xbf\x04p\x01\xf6\xc7\\\xf9\xbf8\xb6\x95XQ\x14\x00\xc0\x82\xc2\xe8\xe6\x15\x99\xed\xbfx\x8a\xab\x7f9,\x01\xc0y\xaa*\x98X\xfb\xd7?\xf0\xfc3!\xe1<\xed?\xfb\xb9\xcc\xd0WU\xca\xbfR\xbf\xda\x8a\xcb\xf2\xfb\xbf\x15u\xc1\xa9\x0fJ\x02\xc0\xf5\xb2\xdc\xedL\x03\xdc?\xf3\xdeP\xee\x19\xb5\xd8??\xdcd<\x97\x1c\xfb?~8\x90\xca\tP\xe4?\x8f~?\x07\xa7:\x00@\x90\x08]\xa3\xf0e\t@\xe0\xf321\x83\xf5\x11@\xbdL\xb7\xa2$\xf1\xe7?q\x08j\xceBf\n@\x0f\xf5\x95\xb0x1\xf9?4\x15i\x94D\x1c\xe0?\xfb\xe3{|\x93\xd4\xee?Yob,\x8f\xa8\xfc?\xa0\x82\x98\x1dA\x08\xd0?\xd8\xb7\xb5b\xd8\xe6\xf1\xbf\xae\xf2\rd\'7\x01\xc0v\xde?\xd0\xdf\x80\x05\xc0}\xf2\x8b\xa8\x04\x8a\xf0\xbf\xe8\x84\xadK\x16!\xe9\xbfkb\x91\x05B\x8d\xe8\xbf\x05\nf\x9c\xa1\x8a\xe3?-\x9a\xe9\xd7\x037\xd2?e\xdc\xab\xd1\xf6{\xee?m\x0e\xd2\xfd\xc1\x7f\x05\xc0\x8cM\x871\\\xf9\xea\xbf0\xdc\xbe,\xa6,\xd4?\xf2LI\x01)\x06\xf4?\xbdR\xecm\x95;\xf1\xbf\x99\xae\xa1wky\xf2?_\xf6\xd6z\x05\x03\xf7?\x81\x8a\xb7\x98\x06\xbd\xef?\xf6\xe6\xb7\xa9E\xef\x08@z6N\xd1\xf4]\xf6?;\t\x8e\x89\xdbO\x11@\xca\xbc\x8bD\x04+\x06@\xb8\xe1\xafKm\x95\xea?\xe2x\xc4n\xff@\xe9?\xee\x19=\xd6x\x81\xe9\xbf\xeb\x1ct\xd6v\n\xeb?TV\x8e~F\x8d\xde\xbf\xea\x9b;\xa5I\xc2\xf7\xbf\xc8\xc9A\xbbC\xb0\xd4\xbf<\x92\xcc\xb5no\xef?!\xec\x86\xefLs\xb8?\xc0\xafF\xce\xcf\x89\xef\xbfZ@\xb9uo\xf5\xf2\xbf4\x05;\xef\xe5\xdc\xb0?\xf0\x08\x9e\x00\'\xee\xe3\xbfLg]{v\t\xf7?\x1fP\xda\xce\xa7:\xe5\xbf#\xfc3$\xd32\x86?\x06\xef\xf3\x88:\x8d\xfc?~\xd7U\x05\xba\x14\xe8\xbfT\xbf#B\xed\xb7\xf9\xbfq\x96)s?\xfd\xc0\xbf\x8cIWO<\xa4\xe9\xbf%\x02\xa3<\xbbK\xc6?fn\xe6\xbc\xbb@\xe4?9\xb1\xa8\x11\xec\xc8\xf6?p\xe6e\x18x\x93\x06@i\xe2\x81lS\\\xdd?;\xcc\x88>\xfd\xe1\x13@\xd2\xd9\x9b\xe7\x8f\xcc\x05@\x91\xbaUWG\xe2\xe3?}\x15\x1bW,\xf7\xe1?\xcd\xcc\xeb\'\xbai\xf2\xbfn_\x08\x80K\xb3\xcf?"\xdd\x98\xb4\xb5Q\xe7\xbf\x85\xb7p\x8a\x16\xf4\xda?b\x89b\xe8\xddK\xe9\xbf;5d+\xf3\xc3\xe4\xbf\xf3\xa3\xe7\xd2;\xe1\xe5\xbfw\xa6\xcc\xe1,\x88\xf6?\xbfgK\x03\x8aQ\xf4\xbf\x9cbLx2q\xd3?\x9c\x0b"hp\x99\xce\xbf\xd8.L\x9cA\xcf\xf6? \xde\xfa\x12?\xb5\xe4?Y,\x95g\x86?\x02\xc0\xce\xf5\n\xc1\x83\xf3\xf2\xbfM\x0bu-\xcd5\xe1\xbfa\xf8\xe5\x17\x12\x90\xf6\xbf\xf1\xbd\x83\xb8{X\xcd?\xa3\xe3\xb6\x03\xd4\x9d\xf0\xbfq\xacz\xc9D\x95\xfa\xbf\x92\xb5\x95\xbc>)\xf7?\xf7\x81&\x86\xe7\x1f\xf6?P\x86\xcd\xbboX\x06@\xe6\xd56\xe9\x80\x80\x08@E\x84\x90\x9c~\xc4\x13@\x82\xa2]bM8\xf9?Yi\xc4\x19T\xc8\xc5?\x01X\x1fIR\xb2\xf5\xbfg\xe2F\x16e\xbf\xf5\xbf\x85\xbcgx\x8e\xb3\xfd\xbfh[\x85S\x13\xc7\xe8\xbf#\x8b\xb1\xb4\xabg\xfa?\xbe;\xc1\xa3\xd6a\xb9?~\x9b=y\xdd\x92\xc1?yqJ\'\xf6\x17\xf4?\xfa%%\xfe\xf9H\xea?\xa5J\x8b\xb0\xef\xb8\xee\xbfJ\x02`\x94J\xa0\xf6\xbf\xeb\xcf\x1e.\xcev\xde?\x81\xef\xa6f";\xe4?E\xa4\x08\x17\xb4\xe1\xcc\xbf\x9e\xc5u+\x05\xd8\xe3\xbf\xb5\x14\x80\x95e)\xea\xbf\xca1\x04H\x12\x9e\xf9\xbf6\x88 L\xd2\x9b\xc5?sn\x0f"z\x81\xbd?\xdf\xccK\x0fR\xc3\xc1?\xfa\x05\x87\xad\x85\xb5\xd8\xbf\xb3>Q\xe9\x82B\x03@\xf0\xe9\x1b.\xfb\xef\xfa\xbf7#\xed\xc6\x1e\x1c\xbc\xbf\x0e0\x17"\xc7A\xc3?\x1d\xef\x0e\xb05\x04\xfa?\x14\xcb)/\xd9\x19\xd4?\xfe\xacg,\x91R\xeb\xbf\x00(\x0c\xdc~\x0b\xdd\xbf&o\x97G\xe6s\xc1\xbf\xc1\x92h@L&\xe0\xbf\xca\xa3Ru\xa6\xb3\xe2\xbf\xc3v\x81\xaa\xa5\x02\xc9\xbf=\x06\xf0K0Z\xe2\xbf\x8f\xda\xd3\xea\x19\xff\xfc\xbf\n\x17\x0cI\x80\xa9\xb9\xbf\x16\xeeNP\n\xce\xc0\xbf&\xf6D\xd1B\x16\xfa\xbf\xb0\xb2a6\x8d\x0c\xec?\r\xc2\x8f\xb5b\xb7\xf3\xbf?9m&~\x9f\xbc\xbf\xf8I\xd0~)\xbe\xa1\xbf\xf3\x91\xd3\x9e\xe1m\x90?5\x1e\x01E\xca\xb3\xfe\xbf\xb7S\x94(\x969\xed?\'\x16E$\x1b\x80\x01@@\xaa>lu\xb8\xe4?\xf2\x96\xc3\x905*\xf4?\x0e\xd5\x91\xe0\xadl\xd5?;&\xaf\xb3~h\xd5?\x7f_\xf0\xc4B_\r\xc0\xf0\xb03\x92`\x1f\x08\xc0\\\xfb\xb2\xc1\x89\xf3\x06\xc0\xdc\xc9\x1e;\x19&\xe0\xbfJ\x85k\xf20\x94\xe2\xbf\x06\x13\x93nP\xc6\xc4\xbf\xa8@\xd7\t[\xc2\xfa\xbf\xees1\xa0(p\xef\xbf\xdc\x01\x0c\\r\xf6\xed\xbf\x1dm*\x1ac\x82\xe2\xbf\x1c\xb8\xc2I`\xa5\xf7\xbf\x1e.gf\x14\x95\xea\xbf\x11V(\x13\xc1y\xd2\xbf\xc5\xc9\xfe\xaa\x86\x16\xdd\xbf\xf7\xa1\xfb\x9d`\xe1\xe7?\xeb_6\x16\x7f<\xf2\xbfd\x8b\xfe\x7f\xecz\xf3\xbf\xe7\xd0\x92zl\\\xa2\xbf\xf9\x00\xc4\xe5i\xb5\xf2?\xd2Gd\xbf-\xc1\xf9\xbf\x17\xe6V\xec\x1c\x8a\xf1?\x15\x81$\xc6\x86!\xcd\xbf\xa4\x1eBhA\xf3\xfb\xbf\xd9\xccrJ2-\xe7\xbf\xde\xbd\x1fF\xd1Q\xee\xbf\x86dL\xe7_\x8d\xd7\xbfHM\x8c\x91\xa7\x8d\xe5\xbfC\x16P\xfcnb\xea\xbf\xbeZ\x0c\x14U\xe1\xff\xbfctX\xfc\xba\xb8\xf8\xbf\xc4\x18\xb81\xb6F\x01\xc0[w\xd8\xd2\xc6\xd7\xd1\xbf\xf1@\xc96\x87\x12\x00\xc0{l\x14v\x90\xac\xfc\xbf\xb9\xf7\x16i\t\\\xf9\xbf\x88\x93\x0f/&\x07\xd8\xbf\xce\x13g\x8a\x9d\xf3\xc8?+\x88k\xd7G\xd2\xdf\xbfK^\x8f\xfbu\x18\xec\xbf\x0b\xbf\x17.<\\\xe7\xbf^lgD1]\xe8?p\xb1\xd5\x009\x98\x9b?\xbb\xb7A\r\x1c\xb2\xc2\xbf\xf0\x1f\xbf%O\xf0\x06\xc0k\x1e\x18%+\x8b\xfb?a\x07\xeaZ\x82\xca\xe8?\xcb\xfd\xf8y\x9a\n\x01\xc0\xad\x96\xb0\xc4\xc1\xc1\xef?\xacj\x95\xbb%\xae\xe5?K0\xc2v\x8cq\xe0\xbf\x139[>Ee\xf4\xbf\xaf\x81\x99\x80j\xf1\xe8\xbf\xff(O\x815\xe5\xec\xbf(\xc2\xf0I\xcea\xc2?,\xe4\xb4:\xbfm\xe0\xbfZ\xf4\x81\xf3\xd7g\xe8?Xl;Uc0\xd3\xbfT\xe5\xa1\xf5R-\xe8\xbf\xd4(\x0f \xec5\xd2\xbfG\xd0\xa4\x84`y\xe2?Li\x08XZ)\xe3\xbf&\x80mR9\x10\xf2\xbf}.\xff\xb0a\x8a\xe6\xbf\xfb\x19\x92\x0f\x19l\x02\xc0N;[\x7f\xbd\xd0\xd3\xbf\xe1\x0e\xea\r\x02w\xfe\xbfBo\xd6\x92\xa6\x10\xff\xbf\x9bhZ\xdf\xe0\r\xe5\xbf\x1b}\xae\xd9\xe5\xf0\xd0?\xd8\x89\xc3\xe6,\xcb\xfb\xbfq\xda\xcaA\x15\xa9\x00\xc0\xc6\xdc\xfc\x0e\xd5\xdd\xf7\xbf\x95\xb6\xcbk\x17q\xfb?\xa3\x04\xd1\x10\xf5\xcf\xe7\xbflA4\xe2U\x97\xbe?t\xe0D\xa8X\xf2\xe2?\xa9\xdbWrz\x97\xfa\xbfh\x12d\xd1\xe5L\xc6\xbfC\x17w\xeaU\x04\xd9?\x04\xc4\x8c\x15e\x1a\xc8\xbfJ4\xe8W\xb9\xea\x02\xc0\xe1\x14\x91\xe7\x86\\\xdb\xbfz\xff\xa7;\xf7\xff\xec\xbf\xc8`@\xbd\xdc%\xf0\xbf\x85\xdc\xde\xba\x1d\x9f\xf3\xbf\xde\'@\xec\x8b\xac\xef\xbf\xd5\xc7t\xe6>\xac\xef?\xb49K\x80r\x93\xe9\xbf\xf0\x9fC\xb6\x80\xdf\xc6?+)\x1b\xceH{\xec?\xb5HT\x94L\xe1\xef?\x9a\x84\x05q\xf7\x12\xd2?\xf7\x80\xde|L~\xf1\xbf\xbf\xc7gM\xcd\x0c\xec?k.\xca\xd6G\xa6\xf4?\xfa\xd3\xb6\xfd\xbc\xd8\xe9\xbf\xea\xff\r\x15\x97{\xac?\xa5\xceM\xb8\xd3\xad\xf2\xbf\x13\xa8\\\xe3\xab\xf3\x93\xbf\x85\xce\xbdc\xfb7\xde\xbft\xb4\xeab\xfa\xcc\xe0\xbfxq\x16@\xa6f\xf0\xbf\xd5\x1d\x14!r\x9c\xb6\xbfO=\x7f\x1f\x19\xe2\xed\xbfJeo1\xa9\xf7\xed?\xa9\xf3|\xd6.\x8b\xf4\xbfB\xecs%t*\xfe\xbf\xb4$\xe9\xd5\x04q\t\xc0Sp]\xc5\xf4\xa8\xcc\xbf\xfde7\x07\r \xee\xbf\xad\xf38\x0c\xce\xb3\xd5?\xbc*w!=\x16\xe5?\x0f\xe8z\x8a\xa4"\xad?\x94\xfc\xd7\xeb\xa51\xfb\xbf+\xb6&\x81\x93Y\xf3\xbfV}\xde\xb7\xf0\xa4\xef?\x14\xb1\xfd3xD\xf3\xbfg\r\x1bx\xdf\xc7\xa9?\xe3\x8e8\xdb\xcb\x1a\xee?\xb0b\x9dy1\x07\xb2\xbf@\x0fu\x8e\x06\\\xf4\xbf\x7f\x90\xd1B\x80\x82\x07@ML8%\xe9?r\'\xb0J?\xd4\xe9?\xecg\xa7`{\x19\xf4?0W,\x98\xc1\x95\xf4\xbf\xd6=\xfa\x93\xd4\x1a\xd4?\x19\xfb\xb6\xefx\xf9\xfb?\xd8\x8b\xe9\x8d\x0e\xe6\xfb?=WC\xb4N\xef\x00@\x1c\xd4\x03lZ\xba\xd9?\xf5\xe49\x8a\xf1\x07\xdf?\xe3p\xd0\x00\xbc\xf4\xe6\xbf\xca\x11X~\xc5\xa4\xe3?O\xaa\x83\xcc\xf4d\xd4?\xb5\x03\x93\xa1\x88\xbe\xe6\xbf\x83\xa26r}4\xb4\xbf\x07\t\x8d\xa6Nv\xe9?\xeei>\x8a\x99;\xc5?4\x06(j\xa3\xf4\xf8?\xb8y\'(u!\xdf\xbfj\xc6\xcd\x14\xb8\xce\x9a?\xe6k\xfb\x08\xa1\xbe\xe2?\xd7\x17\xf8\xbc\x1a\x96\xec\xbfd\x15~\xe2\x1e\x1e\xeb\xbfo{\xb8-&\xa0\xeb\xbf\x8d\x86u06\x18\x01\xc0\x17\x1b[\'\xa7\xc4\xe5?]\xady\x1a4v\xfd?Ik\xc5y\xec\x02\xe7?.\xf4h\xb1-\x02\xdc\xbfvVH\xbe\x92=\xcb?\x97\x1f\xfb\x92\x89\xf3\xfe?\x9d\xf6.,D)\xdc\xbf\x9d\x96\xf4\xd0\xa3\xb0\xd3?k\x18\xaa\xb4\xe3\x17\xf8\xbf\x80t\x9fF\xcd\x19\xf0\xbf\x8f[\xdd\xfb\xf4\x81\xeb\xbf\x15l\x86\xb6\x8d\xcf\xf1\xbf\x1d\x8ar{\xb2`\xf9\xbf\xb3f\xb0\x1b^S\xd7?\x9c\x93c\x13%a\xd3\xbf\xcb\xb7\xab"\xa9\xa0\xa9\xbf`\xab\xd3\x8e\x85\xde\xeb?\xc6\x92A6\x1a\x02\xdd?\x14@I\x83\x12\x19\xed\xbfm\xf2\'\xcb\xa04\xc6\xbf\x05L\x00\x07\xca)\xf4\xbf<)8\xed8\xe7\xc0?\x0fA\xe1\xbc\xa8\xbb\xee\xbf\x8b*@\x13\x15\xac\xe2\xbf\xb4\xf86s\x05\x01\xe3\xbf\xd7[\xf7;\x1e\xfa\xed?W{\x88Q!G\xdb\xbf\xd6a)J\x0b2\x94\xbf\x8e_\xa4\xa6\xf46\xfe\xbf\xbde\x86\xff]\xba\xeb?J\xb3\x0e-\xdf\x81\xe5\xbf\xb4%\xe8\xa4\x9a\xef\xf0\xbfD\x87P\x9f\x9b.\xfe?\xee\xac\xd3\xfd\xac\xe4\xdf\xbf\xdd_\xe4\xde\x98\xf5\xe1?\xef\x868T\xc1R\xec?bS\x8cb\x1a\xd1\xd0?\xf2\xcf\xa9\x7f&\xbd\xdd?\xff\x9b\x0by\xfa\xe5\xf0?14\xf0ysy\xec\xbfiPZ\x8a]\xf2\xfd?E\xebI@t~\xe9\xbf\x0ct\x12\xc9\x18\x15\xf7?\xd139C\xd2c\xe2\xbf\xa3\xc3\xf43\xdbj\xbb\xbf\xb0%\xc6A\x15\x8f\xdd?\x1fC\x86\x8a\xaf\xf5\xf7?i\xda\xf3\x895N\xcc?\xbf\xcc\x85\xd1G\xc7\xf0?\x19g\x152\xc6\x1f\xef?\x9f\xf0\x01\x96\xad\xf1\x00@6\x04\x80\x00\xfb\xb6\xcd\xbf1{r\xe9\x8f\x1d\xec\xbfh2X\xb4\xa5\x83\xeb?O\x0e\xac\xca\xda\x04\xd6\xbf\x90\x8c\xe9h4\x95\x01@\x9b&\xca\x8b"]\xd6\xbf\x06\xe6\x8fBA\xfd\xc6?d\x8c\x9dg\xf57\xf6\xbf\xdd\xc6\xb0,\xc0z\xf4\xbf\xc6\x8d\xba\xf8\xed\x97\xf3?\x06]#^P\xa5\xf5\xbf\xce\xd2g\x16*?\xb2?G\xe8)d\xb8\xe1\xec\xbf\xf0\x1f\x85\x0c\xca\x0c\xe7?\xc3\x97a\xc2\xfc\xb0\xe2?\x94\xb4J`\xb3\xff\xf2\xbf\xfb\xefa\x0fNT\xed\xbf\xc4\xad\x97~\x1b\xac\xbc\xbfO\xe5\x05\xa4\xef\xb4\xd9\xbf\xc9\x1f+r\xf3\xd3\xff\xbf\x1dp\x06\x07hK\x00\xc0g:\x8c\xeb\xcf\xab\xe4?[/H5\x9c"\xf4\xbf\xc5\x7f\xa6\x93\x98\x95\xbe\xbfN&\xa1\xef\xc5I\xdf\xbf\xaa\xbb)\xbe\xc7\xea\xdb\xbf\xc4h\xf2\xc2]\xce\xdd\xbfd\x06\x08|kH\xdd\xbfR\xed6\xa1\x92\xea\xf1\xbf\xc5\x12\xf6\xc8I\xfd\xf2?4G\'\xcb\xf5\xf1\xe3\xbf\x82\x103\xb7)\x88\xf3\xbf\xad\x05\xfc\xd9\xfa\xce\xb5?\xb0\xe7\xd4\x82\xa4:\xdf\xbf"\x1cf\xcbf\x1d\xe9\xbfa\x18\xec\xc8\xd4\x97\xe0\xbf\xa5\x11RL\xad\x7f\xd8?\x03x9\x04q\xf4\xe6\xbf\xbd+\xce\x08\xcfm\xf0?\x03\'\xcd\xaa\xd2<\xcb?B\xb7|\xe5\xa5\xc1\xd9\xbfL\x92\x99;i\\\xf2\xbf\xb9\xf1\x9a\xb5\xe4_\xf1?54\x97\xc9\xc8\x11\xaa\xbfg\xd4G\xe5(\xf4\xf0?\xc6|-\xfc6Z\xe3?@\xa9\xf0\xa4\xb3&\xc2?\xeeu\x84\x04\x96\x9f\x9f\xbf!\xacc\xfaI\xb9\xed\xbfp\x1a@f\x17o\xdb?\xc4\x03\x1a/\x8d\xbf\xe7\xbf\xe2\r\xdc\xc5\x17Q\xc3?\x1b\xd0\xa9\x8b\xb73\xf5?\xe9\xe4\xc7\xcd\x07\xe2\xe9\xbfxv\x9f\xce\xeb\x8e\xde?C\x01}UO\xde\xdd\xbfB\'>\xe7\x94`\xe6?\x8a\x9a\xd6\xd8\xb2\xc6\xd4\xbf \x81\xef2\xb1\x0e\xd3?\xfc7U*\x15\xe4\xe2?W\x94\xb8\xbc\xd8,\xd8?\xba\xd7[?\xbdJ\xf9?\xb8\xae\xf9.\x15+\xd9\xbf\xfc\x92\x87[5+\xa2?\xe8\x19h\xa9]\xe1\xfc?\xbd\xdbx0S\xf5\xd2\xbf\x9f\x8b\xc6\xbc\xaaT\xdf\xbf\xa2a\xc6\xca\x94z\xfe\xbf7Qi\x0cE5\xf0?U2Vf\xdcW\xfd\xbf\'\x8d\x0b\x88\xae\x1b\xf7\xbf{\x01B\xfd\x11$\xfa?\xef.\x93\xb4\xee\xfa\xde?\xa88+\x032\xf1\xea?\xaf\xae_z\xf0^\xae\xbf\\8\xd6\x8b\xb2\xc7\xe7\xbf{\xd7\x82fX\xc9\xf0?\x84\xc8\xbd\x12\x98\xba\xe9\xbf\x1b\x9c\x17Q\xe6r\xe5?\x16c\x08@|\x11\xfc?\x89\x11\x834\xb1\xb0\xe1\xbf\x9fU\xed\xefaJ\xd4?\xdf^\x1d8&6\xdd?\xcd\xceX\xcf\x02\x9d\xf0?T,\xe7H\xae\xc7\xf6?\x826\xaa\xfb\xcaW\xc8?b~\x8f4(^\xf8\xbf\xd7yA-\xee\xdf\xe8\xbf\x8a\xc5Pk\x86\x98\x02@wt\x83\xb2\r7\xd2\xbf\x87~\x10\x17`\x7f\x04@W\x12u\x13\xe97\xe7?1\x00Kq\xd0\xb0\t@C\xd5\xa0\x85\tE\xd5\xbfA\x9c\xb8-+\x93\xd6\xbfU\x9d\x87\xcd\xf97\xe1\xbf\xaa\xab\xee\xf7:\xb2\xfa\xbf\xc7\xc2\xfa\xa6\x16\x97\xef?\xd5\x11dS+\xff\xdc?r\xc9\xe8EG\'\xed?\xe8f\xa1\x9d\x8b%\x95\xbf6\xf9\x8c\xfe\x0b\xaf\xf2?\xca\x11\x0b%\xc8`\xd4?ff\x16\xdc\xa6{\xb2\xbf^\x0b\x1f?Qg\xe2?\xc1\xa1\x8a8\xee\x1f\xf3?*\xb8\x11>\xa5/\x9d?\xb90\xf9\xdc\xb3\x84\xcf\xbfkE\x14\x16#\x1f\xcb\xbf\xa1M{\xc0\xecB\xec?\xee\xe5\x16=\xcc\xeb\xcd?,\xd4\x03\xe5\x1a\xf3\xcc?i\xfd\xe0\x0cuZ\xd9\xbf*\xf8G=\xa7k\xf0\xbf4\xfbN\xea\xda\xf3\xe3?Uw}\xcd\x8bn\xba\xbf5\x8b\xdd\x009\x19\x00\xc0\xc5\xb0\x17T?\xe3\xf6?\xd7+\x9d\x9e:\x10\xd8?~Q\xb3\x86\x8c\xa1\xe5\xbf\x82\xdcsjl_\xfd?,\xd1\x19S$7\x02@\xf5\x85S\xcf\xf6\x0b\xe7?\xba\xb9,\x138\xf6\xec\xbf\xd7\xaf\x7ff\xb0\xb3\xef?\x18\xe1X~\'\x9c\xe0?0\xf8\xa2\xc7L\xac\xf5?\x93]\xd6\x15Z`\xe6?\xb3\xec\xb7=\x0c\x97\x01@q#8\xf5\x9c\x90\xd9\xbf\xeec\xe8\x0b\x9e\xf3\xeb?\xfb\xa3\xb5\xdd`\xb2\xce\xbf\x96\x14\x83\xf6\x1a\xef\xca\xbf\x89\x10o\xa3{I~?\x0f\x8f\x82M\xa7\x08\xbc?]\xeeHX\xe3\x93\xf3?\xf2\xe0\xe4\xbac"\xf2\xbfj<\xff\x9e\xe9\x86\xf2\xbf"if\xcd\xc0\t\xc1?^\x14\xab\xd0e\xb5\xec\xbfc\x83\x16\x91e\x92\xf3\xbf\xc9\x8cZ,sM\x00\xc0h;\xa1N\xbf\x9d\x00\xc0\xc3j\xa0\xf6\xf4\x85\xf5\xbf\xb0\xf5R\xbc\x84\xd2\xe1\xbfK\x8a\xdc%C\x98\xd5?L^\x11)\xff\x85\xd8?\xfb\xddgd\x1a\xfb\xdf?M6\xfc\xaa\x07\xda\xea?"D\xf1\xeaT\xa1\x0c@\x84\xb0\xfb\x9a\x94\x8e\xbf?\xb4\xf6~\xda\xef\xff\xdb?\xa3\xff#\xa3\x1f|\x00@W\x7f\x1b\xd6\x1d\x1f\xf2\xbf\xcb\xd99\xf5\x9eS\xe4?I\xb6\xc4G\xb1:\x00\xc0\xea$\xcd\xd0\xaf\xab\xf1?l,\x07:+\xa3\xe6?\xe5\xb5\xa0\x9e\xb9*\xf1\xbf\xb0\xa6\xf3\xa3\xff\x8c\xd8?F\xfd\xf0F\x16M\xef\xbf\xe8\x9c\xcf\xe8\xe1\xde\xf6?\xab\x86[\xc1\x0c\x11\xeb\xbf\xbc\xae\x0c\xfc\xeb\xf2\xd0?jq\xa9N\xf00\xe6\xbfm\x9a\xfc\x15\x12\xfe\xed?\x00\'\x07r\x86\xcf\xc3\xbf\xfb\xb9\xe2\x05\xd5\x03\xe2?\x918\x8f\xe3\x13k\xe7?\x19\xfb3D\xc8\x9d\xd9\xbf\xe8?c\xe6\xc9n\xf3\xbf\xa3\x184a\xbc\x83\x00\xc0E\x13\xe9\xdb%\xf8\xf9\xbf\xb3\xaa\x11\xef\xa6K\xfd\xbf\x82\xc5\x853\x1cv\xf7\xbf\xdaE\xa6\xedCu\x01\xc0\x17\x98\x81;\xec}\xf2?@c\x9aP\xed\xa6\xfe?\x1a\x0f\xb2C\xa0U\x00@ \x08\x8d\x13\xba\xf5?\xe1lm\x96\x87>\xe9?\xc7\x81(^\xdd\xd1\xfd?\xb5X^\x0eM\xcf\xf6?8\x95\x82;\xc5/\xc4?\x89qu\xb8\xf5P\xd1\xbfl\xe1V\x0cg\xf8\xdf?\xa6!6z\xcc \xec\xbf\xe85\x89\x82\xdc\xc0\xf6?\xb6N+\x88"G\xde\xbff\xaa\x9fDT\xa1\xe3?%P\xcb\xf6`\xf4\xf6?\xbd\x10h\x81\xf5\xec\x00@l\x84\x99C~\xd0\xf7\xbf\xdf2\x16\xeb\xea\xc7\xeb\xbfn\x8d\x0f<\x19\xbf\xe6?\xa7t\x16\x13\xa9\x80\xd8?H\xfb7\x0cb\x06\xf1?\xc8\xec\x0f\x86P\xe0\xd0\xbfC\x1d\xba:\xf7\x9f\xfb?f\xff\xbd\x11mY\xe7\xbf\x94lJ$\xb4E\x01\xc0a\xf1\xd3H\x9b\x9e\x94\xbf\x0f1.(Rn\xd0?\n\xb19\xf2-\xfa\xed?3\xe6\xf2\xe6#\x1f\xd1?Z\xb1=Be\x8d\xf4?H\xbe\xdeX:\xaa\xea?;;B\xd5\xb0\xa4\xe6?\xb5W~6&\xc4\xe4?\xf1\xed\x8f\xae\xbag\xc1?=\xce\x8c\xc6C\x01\xe4\xbf\xa2\x8c$p\xb7\xf1\xe9\xbf.N/9\x85\x99\xde?\xc8\xb2\x05N\xd3\x8f\xe9?\xbaZXv4Oq?S\x0f\xcbK6\xd3\xf4?\xb5\xce\xa0]\xa1\x1c\xd1?\x08I\x9eg\xd5\r\x96\xbft\xdc\x84\x02\xe4G\xf2?g\x02\'\xee\xa1\xa0\xeb\xbf\xff;?\x16\xf3\xe5\xf2?\xe1\x86hj\x15;\xf4\xbf\x13\xbf\xe1\x97\x97\x04`?\x96rP\x91\x94\xcb\xd3\xbf\xce\x19M\xd9I\xd2\xe7?]\x96\xf7\xcdtd\xe3\xbf\xfc}0\x0c\xee\xc1\xec\xbf;r\x0f\xc3\x84\xb0\x04\xc00\x85\x90\xab\x03\x80\xfd\xbf;w\xb6G\x90\xac\xdb\xbf\x80pB\xb0U\x87\xe3?\xd0\xfa\xce\xf3\n\xd9\xc0?\xd8\xb5\xd2)\x1f\x1a\xf7?\xfe\xcd\xf7\xdc\x82\n\xf9\xbf\xfcS\xa8-.3\x04@\x1b\x83V\xde9\x14\xf6?\t\x94\xb2\xb7\xe9*\xe7?Lw\xf4\xd5x\r\x02@H\n<\xfe\xb1\xb1\xe3?0\xee\xaa\xd4\xf4\x9e\xf8\xbfk=\xa0\xb8\xe1\x86\xf2\xbf\x12S\xd2\x08\xe6\x82\xd4\xbf\xe0=\x04\x9fX\xb6\xc1\xbf\x11I&\xbdG\xfa\xea?+\x8b\x1bC\xe1 \xb0?\xefXU\xe6l\x9f\xe6?\x93Z\xb3\xa0>\x89\xe1?\x90\xd2\x9a\xccd]\x07@\x9a\x02\x1d\xc7\xba>\xe2\xbfA\xbd!=\n\xd6\xeb?\xe57\xc4E\x17\x8e\xec??\xeb9\x85\xa4\x15\xfa\xbfb\x19L\xec\x88W\xcc\xbf\xe0\xcb\xca\xfb\xb42\xe4?\x0eG\xb4\xba\xef\x01\xe1\xbf32\xca\xcc\xfe\xec\xf3\xbf\x0coz\x8ek\x83\x00\xc0\xda\x89\xbc\x1f\xf7l\x0f\xc0\x9b@\xb6\x04+\x02\xda\xbf\xc7#\x0b\xf2\x1f\x0f\xe2?(C \xf5\x8c\xff\xe7?\xba\xbd\xc1\x99\x93;\x02\xc0S-S\xbcb\x8e\xf1?\xbceH;\xd6Z\xe2?mYN\xbd\xc7\x08\xe1\xbf\xf3\'\xbb\xaa\xfa\xe7\xf6\xbfo0\x96\x13b\xa5\xb0\xbf\xe1\xe5\x13/\x00!\xe8?.7! .\xac\xe2?\xf1\xba\x848G\x9b\xef?F\x85\xafT\xa9Q\xfc?\x89,\xa1L0\x9d\xfc?/\x83\x08\xcc\x1b\xa7\xbd\xbfM%iI\xba\x81\x01@a\xa5V%\x95j\xb7?n\xfc\x83\x84\xcay\xd8?\x156F\xe2\xca\x1a\xde?\xdb\xb4-\xf1\x1f\xa5\xe8\xbfp\x8e?+\x99\x0c\xea\xbf\xda\xb4\x12\xb9\xc8\xce\xe3\xbf\xfbO\x08\n=D\xd4?+\x1f\xac\xc5\xd7^\xf8?P\x89\x06\xb0\xb6\xec\xd7?\xda\x94F\xf4D\xff\xeb?\\\x8e\x8e\x02\xec\xd6\xeb\xbf\x93*\xaf\xa9kY\xfb\xbf:\xbb\t\x8e\xebB\xe6?\x9f\x1eQ\x83\xc9\xe9\xd5?v\x83ng\xc2\xaa\xf0\xbf\x1ca\xee\x1a\xd4Q\x0b\xc0\x93\x18\xdd\xfe\xb4\xe5\xd2?\x1b\xf4\xaa\x12\xc5V\xf1?}\xd4/\xbe >\xd2?\xbd\x1c#\x02\xb8\xf2\xe3?!\xb4C\x89-w\xf1?2\x9d\xe2l\xd3s\xe8\xbf\x9e\x11\x93?\xecA\xfa?\xc2\x16\x1d\xfd\xaf*\xf3?3K\xda\xd6\xc5\x18\xf3\xbf\xa0\x03\x97\x01\xed\xb1\x00@\x1d=0+X\xea\xf2?-m\xe2\x04\xc9*\xb9?\xedu\'\x14E\x97\xf8?\x821\xe5O\xa0D\xfb?\x9594\xd3\x89\xd8\xc4??H`k\x91\xc6\xcb\xbf\xec\xffk\xcb\xc9P\xf1?\x8e\xf5\xe9@/s\xef?b\xb7M\xd15\xdd\x02@_\x89\xd2E\xc62\xf6?\x19p\xd9\x14 \xab\x01@\x88\'j\xf5\xa7g\x11@L\x11\xb3\x98>F\xe8?\x14NRR\xdc\xb4\xe8\xbf\xf3Uy8C\xaf\x01\xc0\xa1\x1c\xa2\xa8P\xaf\x04\xc0O[\r\xe9\x85>\xf9\xbf=\x9f\xc2\xf6\xe6\xbb\xd8\xbf\x8b\xad#\x94\xe8V\xea\xbf\xdb\x03OXk\x0f\xed\xbf\xff\x8f\xb3i\x18\xa9\xe6?h\xa9\xa3!\x0bT\xee\xbf\x0e\xbb3\x9b\x8a\xf5\xed?\xbf\x84\x93\x8b3\\\xe5\xbf\xcc\r\xfcs\xb7}\xe8\xbf\x9dU\x966\xf4\x1f\xbc\xbf\xf1\x0e\x13d\xc9\xd1\xdf?\x15|\xe6\x94\x9fp\xe7?\xbe}j\x19\xf0\xe8\xa7\xbf\x96\x08{\xd3^`\xfe?^[\x93\xa92\x14\xe5?\x00+\xefU\x1b\xc3\xad?\xd29\xcc\xf3aX\xf3?\xe1\xe8\xa9` ;\xe7?Nv:$\x07*\xfd?\xd2\xc8`aX\xca\xe6?\x93:\xe0?\x9fs\xf4?X\x98\xca\n#\x82\xe9?\x1e\xf7\x9d\x98 0\x01@\\\x92vwZ,\x01@\xae\xf2\x1bz\x0fp\xc6\xbf\x10\xdc\t2;\t\xfb\xbf\x91\x8eCO\x9f\xd4\x03\xc0\xd2n\x00\x0e\xdd0\xc9?\xb3\x9d\xd1\xa6hZ\xfc\xbf\x9f\x0c\x82\xf8K\xd7\x03\xc0}\x96I\xaae:\xf7\xbf\xbf\xdc\xfa\xa5"\xd7\xe7\xbf\xf6e\xac\xdcN\xb7\xe3\xbfk\xea q\xce+\xc9\xbf\x7f2\xd6\x02\xfa_\xdf?\x95\x07p\x0fY<\xbc\xbfE&\x1f d[\xf0?\xe5\x9f-\xd0`\xce\xf4?\xed\xfc\xe4\xd6\xd1k\xfc?\xab\xab\xba\x1d\xa1\x12\xd1?\x182\x83e\xb58\xe7\xbf\xa8\xc3 D^\xd0\xf8\xbfr\xd9W\xbbUB\xf2\xbf\xc1\x83\xb1\r]\xb1\xda?\x15\xa3\x13\xfd\x83\xc2\xe4\xbf\x80\x1d\x17s\x7f\x16\xf0?F\x84H\xd8n\xcc\xe1?\xb2\xfe\xd91%\x19\xe3?L\x7f\x86\xdaGW\xf0\xbf\xa2\xd2\x85^6\xdf\t@]YLP\x0c\x8c\xf9?ie\xd8"\xb7\x8a\xfc?Q\x8cc\xa0\x06\x84\x04@\xdc\x9ea@<\xd5\xd7?T\x1cX(\x99\xeb\xd2\xbf\x81\x83d\xf2D\x0f\xfd\xbf\xc5`U \xd3\xf6\xdc\xbf\xae\x07e\x86\x83 \xd7\xbf\x81+J]`%\xe0\xbfQ\xf0\x97P\xe1u\xf5?\xa1\xe3\x05>/\xc9\xe1?\x13\x9au~\x15\xfa\xfd?\xf8^X\xefX2\xfc?\xe3\xf4?xc8\xaf?\xfcp\xa7\x86\xb1\x81\xe7\xbf\x1a\x07t\xbb\x9a\x04\x01@/u;\xe1\xf2\x1b\xe7?Y<\x0f\x92U\x88\xfa\xbf\xbc\x05|\x00\x9fd\xeb\xbf6`\xfe\xae\xcc\xeb\xf9\xbf\x9c[\xd2\xbf\xec\xd1\xf0\xbf\xdbo\x19\xa5\xab-\xce\xbf\x1aJ\x99?fY\xea\xbf\xfe\xf6\xd7\x85\xba\xca\xe2\xbf\xcb[\x06\xbbB%\xee\xbfhJ\x18G\x13O\x00\xc0\xd1\xf5,\xa8k\x8a\xec?#F0\x11\xdc\xda\x00@A\r;\xfepG\xfb?\xf7\'.\x9fu\x9f\xfb?%\x9a\xcc"\xac\xd6\xb1?V\x87\xa7,"W\xe1?\x0ey-\xf3\x93>\xff\xbfz\xc7R\xd1zy\xe8\xbf\x08\xf5\x00\xaeOG\xf2\xbf\x1eL{\xd8\x16\x03\xe0\xbf\x92\x82\xd1\xfa\xfb\x8c\xf7?\xa34zG\xcd\x0f\xf0?\x81OK\x01\xba\xc2\xbf?\xfb\x06!RT\x08\xf7?\x96\xba\x8a/\xff\xca\xd2?\x8a%\x9b\xdc$l\xf7?\xda\xd5|\x85\xdc\x8b\xee?\xcb\xb5\xce\xa5-\x81\xdd?\xfe\x8e8v\xcb\xe6\xdb\xbfqV\xc3\x88#\x12\x00\xc0\x0b\xa1\xcd\x00\x90:\xfe\xbfvXH\x9bn\xd1\xed\xbfm\xab4\xb5Qm\xe0?\x8e\x12\x01\x96e\xb8\xe7\xbfcR\xa3z><\xef\xbf]\xec\x8e\xb6KJ\xd1\xbfX5\xbe\xeb\x0e\xc2\xf0\xbf\x15\xe9G\\#\x80\xd7?\x87:\xdf A\xee\t@I\x90\xa4\xcf\'+\xf5?\xdb\x96\x8f\xb2c\x1b\xfe?\xfc+HK_v\xeb?~u\x87\xbdm\x80\xf5?G\xdf\xd4\x18\x8c;\xff?\x1d\x8cq\xd6\x03\xf1\xad?\xe8\xc8c\xe6\xaf\x9d\xfb\xbf,U\xa5\x0f\xa5\x92\xf0?\xa7z\x1e\x16\x12\xa2\xdc\xbf\xdf\xf6X\xc4\xfb\x10\xde\xbf\xb8u\x91bs\x02\xed?Q\x90\xf9\x8c"\xb3\xeb\xbfQ]\xc7\xffP\x8a\xdf?!|\xd5\xb3\x81\xc3\xf4?\xdc\x97\x95\x9e\x11\x8a\xc3\xbf\x14\xd8\xedI\x9c\xdb\xe9\xbf\xb1y\t\x14\xe1$\xed\xbf`\x00\xb5\xae\xf3\x83\xfa?%\x14\xbbl\xbf\x04\xe1\xbf\xa4\r\x88x5\x9b\xfa\xbf\xe8#\x986!x\xc0\xbf\x90&\xd3\xff\xcf\xba\x0c\xc0\x81\x80\xaf[\x14r\xef\xbf\x16\xf3i\xd7V:\n\xc0O,\x84\xc8\xa5?\r\xc0\x8f\x83B\xd1X\xab\xf0\xbf\xf9.\xed\x0b\x17\xc9\t@\x8e\x05=\x9d\xd7\x01\x00@\xedb\x99k\xec,\x01@\xc3\xc9\xa5;Fp\xe1?\x90\xc0\x03\x92\xb8J\xef?\xd0\xb6\xd4!%D\x00@\xce\xc8\x0f{\xcbj\xed\xbf\xb2\xd5\x01\xd1\\q\xdd?*\xe8\xe9\x15\xb7s\xd3\xbf1#\x92d\xca\xde\xed\xbf\xdc\x17\xf7c\xf4K\xda?\x81\xc4\x0c~\x12-\x00@%5\xd16\x14\xc1\xe1?\x03v\xe2\x8e\xee\x1f\xff\xbf\xc3\x81\x80\x00a\xcf\xe4\xbf"k\x894\x19\xec\xd8\xbf\xeb\xdf\xcd\xfb\xbe\x94\xc4?\xf0A\xed\x9cp\xb4\xa6\xbf\x0b\xac\x81\x93\xa3!\xeb?\x90\nQ3@\xc5\x00\xc0\x199\x15\xf5E\xca\x00\xc0\xe6|\xd3\xf4\xb4\xbe\xeb\xbf\xb5XMX\xf3\xff\xf4\xbf\x19g\x08[\xe6\xcd\xe4\xbf\xdb\x15\xec,\xb5\x1e\x05\xc0\t\xf0\xa6\xd9\xeb\xe4\x10\xc09\xd3\xc1<\xc6\x8b\xef?\x84\xc1S\xb4uq\xf0?t\x1c\xd3\xa9t\xe7\xdc?\x00\x1d\n*\xe3d\x03@\xe2\xba%\xf2\xfd\xf6\xbe\xbf\x0e\x87\xdf0S\x91\x00@\x9aY\x8b\x9a\x90/\xc3\xbf\x19J\xb8R\xbd\x12\xde?\xdd\xad\xaa\x8f\xb4\'\xe0?\xa3o\xf1\x80\x10\n\xd0?\xf8b_\x0c\xb2X\xc1?k\xca\xd48I\xbf\xd9\xbf_H\xf1\x0eL\xf4\xa6?Ur?\xe1>g\xf2?\xe4\xf8\xcc1\xce#\xeb?\xae\xa8\xf0\xd3\x9f\x90\xb0?\xe0\xa8\x1e\xe8b%P?;\x81WmI\x0f\xd3\xbf\xecUj\x07b7\xf4?\x14\x9f\x85\xa7\xc98\xbb?\xca\xc5XR\xb8\xc3\xc9?^\xa5\x84\xc15\x90\xe5?\x11\x89\x81=j \xea\xbf5\xf7X\xb6\x03\xf2\xdd\xbf\xb5\x02\xf9S/B\xf1\xbf\x98R\xe9\xaaRd\xf6\xbf\xa3z\'\x10\xfa\xee\x01\xc0~\rg\xc8\xa5\xf5\x05\xc0\xb6\xfd\x12\xfc\x8d\xc8\xfb?\x9c\xddC\xe6<^\x0f@#\x95G{R\xa2\xed?\xd1\x9c6\'\x94(\xed?\x8c\x12\xfa\x05\x1c\x91\xf0?j&[8\xedT\x01@w\xe1wJ\x15\x9f\xf0?\x01\xdc$6T\xdf\xed\xbf\xb5\xc7\x81\x1a+\xad\xfb?{\xd2\xaa\xee=\x98\xec?\x07\x8c?.f\x19\xec??\xe1\x83\xd9\xe8\x18\xf6\xbf\x80S\x81\x9b\x8d~\xdd?d\xe5}\xe6\x8fi\xff\xbf\xe2|\xd7\xbe\x95\xd9\xf5\xbf\xdbVJ\xf4!R\xe0?\xaa\'h\x14`u\xe9\xbf\xe6\xa4\xf7\xeb\xa7\x9f\xf7?\xa5\xa2Gy\xb3q\x9b?\xaa\xf6]\xffYN\xf1?\xdb\xb2\n\n\xcb\x17\xeb?\r0d\xf5\\\xad\xb4\xbfU\xe3\x97\xf5\xc1\xc4\xe9?\xdc\xe3\xb4ZH\xc6\xcc?\xbd0q\xe9B\x1a\xfa\xbf\xaf\xb7 S\xa5\x94\xfd\xbf\x96N\xf5H2<\x03\xc0\x0fNp\xd5[\x88\x08\xc0\x0c\x1c\xeb]\xbb+\xf5?\x8f\xccr7\x91P\xf2?\x13X\xa5\xcd\xc5\xa7\xac\xbf}\xb5\xc8\xc4|4\xfb?(\xc2y77=\xec?\xb6\xc2 \xd6\x8d\xbb\xf5?\x15\xf9\x1dm\x7f\x96\xed? (\xa7\xc4\x07\xb1\xd7?\x81\xab9+\x99\x8d\xf5?&R\\\x15K\x87\xd4\xbf\xe3\xe1\x87T\xba-\xeb?\xa3\xfe^`\x9a\xdf\xf5\xbf\xb3\xc2\xe36\x0c\x18\xfb\xbfj\x8e\xbf\xb6\x99\x07\xed\xbf\xab\xffD\xa4\x1d\x0b\xe1?`\xe3N\xea\x9d\x05\xf4?\xb0\x0f\x02x\xd2\x93\xd4?#\xa6\\\xcdG\xa2\xd5?\xcb\xea\xfa\xa5\xb9K\xe2?\xef`\x83/F\xd3\xe1?\xc5k\xac!M\xad\xe2\xbf\xd8\x98\xdb7FN\xf2\xbf\x14\x04\xc0\xaf\xf4H\xfb\xbf\xc5\x7fw\xac\xceI\x00\xc0\xc9\xe1}\xb4\xb4\xe2\x08\xc0Y\xb8\xb4\xbc`*\x07\xc0ug\x9c\xe4\xd0\xc9\xcb?\x8b5s\xbcm\x8f\xff\xbfE\x02\x9f)\x00\x9e\xd0\xbfAOvf\xa4M\xe1?\x06\xe3\xb0\xd6\x8e5\xba\xbf\xfe#\xd50\xfd\x0b\xf7?\xb0\x06*\xaa\'y\xe2?\xbbN\x92\xc2J\x8b\xed?\xcb\x97O:\xb6\'\xde?\x08^\x1dg\xda\xc3\xb3\xbf\xab}L\x82\x0c\x9b\xe7?\x1a\x9a{\x0c\x91\x8e\xaf?\xefz\xba\x9c\xa0\xc4\xcb\xbfSt\x8c/\x83\x89\x00\xc0\x91\x82\xadv\xa1\xcc\xf6\xbf(\xc8\x81\xe5ip\xf6\xbf=\xc3\x053l\xe9\xe5\xbf\x93]\x0b\xac\xd9\xe9\xdb?\xab`\xa2\x07\x17\x88\xed?\xa8(\xd4;R\x8dw\xbf\x7f;\xb8\xda\x8d\xb7\xf9?\xa0\x9f\xc5s/*\xe5?\x85\xf8\xfb\xf1\xdf\xf3\xfd\xbf\xc6\xa41\r\x0f\xd7\xf2?\x02Zj\x8a\x8f[\xd4\xbf\xd3f\x06T\x0c\xea\xf7\xbf\xc4[\xa0\xce\x04g\xea\xbf,9Ig\xa89\x00\xc0;\x17\x13\xe4\x98\x8d\xdd\xbf\xd5\xc0fo\xa0\x13\xf1?\xc5\x11\x0e\x95\xfd}\xaa\xbf.\xe8\x95[5a\xdd\xbf\x1b\x83\xb7\xc0\xad\x1d\xd4?\xe6\xae\xba\xf2\xedS\xec?\x169\xe2#\xd0\x04\xda?\x1b\x93\xd5\x97lY\xfa?\xe9##\xbcg\xda\xfb?\xb7\xfe\xb7,\xb0\xdf\xa7?\x9fU\xa6\xf6\xe1\xd2\xb6\xbf4\xb1\xed\xb9\xf2#\xdd\xbf\xc4\x0c\xb5\x9cU\xd0\xd8\xbf\xaf\x93(g\x86\xad\x00\xc0\x83\x9fn\xc7\xce\xe1\x00\xc0\xe3\xc4\xf4\x0bjS\xd9?\xb6{\x98\\xb\xc8\xbfW\xe1\x8e4S\xc6\xf9\xbf\x88\x93p\x92\x04Y\xcc?I6\x11\x12\x88\xfd\xd4\xbf\xfa\xa4&\x93>e\xf8?h\x9c\x8a\x7f\xef\x07\xf1\xbf\xac\xcft\xce\xd3K\xfd?\x81j\x9c\x85=\xf4\xe6\xbf\x04\xea\x8cbM\x10\xf0\xbf\x17\x16\x04\x00~_\xde\xbfj\x0c\xcbD\x9d\xb2\xf0\xbfD\xea\xac\xcfL\x06\x0c\xc0\xe1G5Z|\xc5\xee\xbf9\x06\xd0\x96\xf1-\xf4\xbf\xcc\xb1\x8f\xe2\xce\x91\xd0\xbfya\xfc\x82C\xfb\xf0?\x0b\xb1CW\x08\xa1\xc4?\xc5\x85\x94h\r\x98\xdf?/\x81X\xf9\xc2\xc1\x02@\xb1\x1c\xa4\xe5\xfbm\xe6?\xe6\x8e\xb5\xfe\x1ep\xe3?T\xdd\xccA\x99\x05\xed?\xc0\x83\x13\x88\xa0H\xf7?\xf5~\x99\x02\x05\xa5\xec?vq\xb7r\x8fM\xf8\xbfj\xbd\x15\x1c\x8fu\xd4\xbf\xa5R9\x0f\xb0\xdb\xd3\xbf\xbe\xa7\xb8w\xd7E\x92?\xaa$\xfe\x04\xe5p\xcf\xbfK\xc9P\xc7;\xfe\xa4?jU\xf6m\x8a\xe4\xd8?\'\r\x16\x07\xd4\xc3\xfe?\x96\xcb|\x9f\xe2`\xd5\xbf\xaa\x08\xd1\x1e\xf9m\xe4?\xd8v:A\xc3W\xf1? \x95\xd7\x8d\xf3\x0f\xf3?\x97p\x01-\x92,\xdd?"z\xa3\x91tI\xe3\xbf\x08\xa7F\xf5\xe6\'\xd2\xbf\xccU\xbc>\xb9&\xd3\xbf\'O\xb2u\xa7\x08\xe6\xbf>g\xc4tl&\xf1\xbfI[k6\r_\xeb\xbf\xa6\xde\xa9\xf1}w\xe1?(\xc6\x86W\xa3\x9f\xec\xbfS\xa21\xa6\xa1\x10\x07@h\xe4\x0b\xcd\x01N\xe5?\x03\x1a\xed\x18\xf9\x80\xa7?S\xb9\xda\xfa\xbc\x1b\xc6\xbf\xfc\xc6\xaa\xf5\x07\x1c\xfc?k\x17b\x0f\xe3\xea\x02@j\xd6C(\x163\xf5?\x9c\xec\x9a\xb0By\x08@\xce\x01\xc4\xa8\xc0G\xc9\xbf|\x87\x85\x86MU\x01\xc0\xb8\x11\x02k\\\xdf\xf3\xbf\xb3U\xd2m\xeaT\xf0\xbfS\xc3D\x05oc\xf1?]\xdb\x8d\x11\xa3\xc1\xe0\xbfVp\xf3E\xb9p\xe1\xbf\xd7\xd6\xe8w\x1b9\xec\xbf*\x82\\7v\xbd\x01\xc0\x02\xc8\xd7\x1f\xe0\x99\xd8?\x95\x06i `\x13\x08\xc0\x00\x11{\xb98\t\xda?\x9a\xfc2\xff\xa4>\xf4?\xdci\x17\x1ci\x8a\xf4?TJ\xc6\xea`\xa2\xe1?\xbf\xe1\x1e\xba\x8a\x1a\xf8\xbf\x11>\xdc\xdf\xc0\xd6\xe5?\xc9\\\xfdi\x86\t\xc0?L\x81\xb7z\xf7\xcc\xf0?i\x11\xba\x0c\x1c\xee\xd4?u\x83%\x83l\xd6\xe1\xbf[*q\x02\xc6\xc3\x00@\x06\xed:\x8f\xb7{\x06@\x148DB\xd7&\xff?\xee\'\xf7\xab\xef\xd4\xd7?\xeb\x0e\xff\xa4\xab\x9e\xf3?\xf7w\xc2^\xe2\xbb\xf3?\xcc\xd4\xc4\xe3\xb4\x1c\xe4?k\x92\x8a\x105\xbf\xdf?}\xff?>\x91k\xee\xbf\xfeE\x8b\x86\xe9\x8d\x03@\xc7L\x80U\xdd_\xd1?\x12La\x04\xef\x14\xb0?\xa5(\xcb\x0eA\x1f\xf6?\x8a\x94\x83\xa3\x89\xed\xe1\xbf\xe8M\xe0\x9d\x9f\x14\xd9\xbf\x14:+\xb20\x85\xe2\xbf\xec\x9a\xdaf(^\xf9\xbf\x97t\x81\x08\xa6\xe1\xe3\xbfI-\xbc\xe4-\xfa\xfa?\x9d\xe4\x06\xe8b\xe3\xba\xbf\xf5)\xbd\xe2\xf5\'\xf5?]\xba\x05\r\x9f\\\xef?\xe6N\xd2\x12~ \xdb?k\xeb\xaf\xc6\x98\x07\xe8\xbf\x04s8E\x1c\x0b\xf6?\xc1\xdb\x9f\xf3\x9d2\xe6\xbf\x12\xc0\x03\xcb\x06a\xc5?\x07\\\x1d:\x18\xca\xf1?\xc5^@\x99\xd3p\xf4?%\xa1\x1c\xe3\xe2\xf6\xe2?\x16\xa7\xae0N\x1d\xf1?\x10\xbdA\x02\xa5\xa4\xe1\xbf\x84Y\x90\xa3\xd2"\xdd?V\xe0l\x9b\xe7\xd4\xaa\xbfu>\x98w1@\xfb?\xec\xbc\xa9\x90ev\xea\xbf\xee\xc7Z\xfa\xec\n\xfc?\xd1\x95\x9d\x8bo\xf1\xb6\xbf\xa3\x03B\xb2Dl\xec?(\x919\x88[\xa7\xc6\xbf\x06\x02\x8c\xbd\n\x9e\xde\xbf\x83,\xf5\x07s1\xe9\xbf\xa9c\t\xa0\xb5y\xf1?7f\xaa\xeaF\xe2\xd3\xbf:\xbb\x96\xef\x0e\xbf\xe1\xbf\xb9\xf9\xf7\x15\xb6}\x04@\x19\x8f\x17 K\xc1\xba\xbf;L\xc7\xd6u\x84\xcb\xbfS2FN#\x0e\xef?\x97T\xe6\xaf\x1a\x15\xdd\xbf*\x86{Z\xe6G\x07@\xb3\x83B\x85BH\x05@\xf9\xbd\x8c\xfe\xb4\x01\xdc\xbf\xcf\xea\xe8\x96\xc5\xa9\xea\xbf\x11K\x8e\xbc\x18\xbe\xd4?0\x90,\x80\n,\xc4\xbf\xb8F\xb2\x04\x89\xa3\x05@\xa9\xb8\x7fB;\x9b\xe3?\x06X\xf6b\xa2\xd3\xed\xbf\xe6\xc1\xeara\xca\xe2?#\xd5zdF\x0b\xec?\xaeCY\x9c\x15\xf9\xe6?3\r\x93YgD\xf0?\xf4d\xc3F&\xfa\xe7\xbfKg\xad\xc9\xa8 \xd7\xbf\x9d\x1b\x04\x8eL\xed\xe2\xbf\xda\xa1\x18\n\x80*\xd1?\xdb\x00\xeb\xdf\xf4\'\xfd?\xf3\xbb\x8eFws\xc1?\x96\xe1H\xba:h\xd4\xbfEz\x0bM\xc7\xe6\xeb?\xef5\x01=\xb6\xe7\xe5?\x16\x9fw\xc1\x16\xad\xfa\xbf\x87\x14\xd4z\xd6\x95\xbe\xbf\xde\xf9\xbb\xaf\xe5\xe2\xe9?\x10\xac\xb8\x8a\x85\xb5\xda?4\x048D9\x01\xd0\xbf1\x15\xea\x9c\xff\xb0\xdb\xbfO\xe6>\x89\xa7F\xbe?\xa2\xd5\xe9\xc7a\xd0\xad?\xdf\x9feF\x8c\x01\x05@"\x08\x96\xfe\xfde\xc5\xbf\xd11\xdfr]\xd6\xeb\xbf\t\xeeN\x9e\xce\x01\x05\xc0\xf6\n\x10` \x02\xd2\xbf%ff]\xf3D\xe7\xbf\xb4\xc2(\xf7\\\x1e\xd9?\x8a\x0br\xf1\xc7\xd9\xe8\xbf\xa2\xd3\xcat\x0c\xe7\xd9\xbf\xa5\xe6\x89_5\xd5\xc5?\xea\x97\x93\xa4\r\x81\xc5?<>J\xc5\x97\xb4\xe9\xbf#\x0e-\xf0\xf8\x86\xc3?\x85\x93\x14\x8c\xef\x15\xdf?\\Y\x9e\x81\x87y\xb1\xbfa\xffk\xf2\x15\xe6\xc0\xbf\x15\xb8q{mL\xd4\xbft\x11\x9b4\xc4\xc2\xde?:F\xed=\x9cp\xe3\xbf\x88Y\x8eZ\x17f\xc8?\x0c\x10\xb9\x06\x88~\xb7?f\xc8\xa5G\x83\x96\xde\xbfK47\x87\x7f.\xf3?\xba\xac\xc8\xe7\xd4\xf6\xd2?Bw\xef\x11\xf1\xf5\xbb?g"\xe9\xeai\x93\xc5\xbf/\xf1l\x0f\x08x\x99?7\x119\x17\xe8\xc4\xb3?\xd0\x95\xe5\x9f\x1d\x80\xf0?]\x1a\x02\x07{\x1c\xe5\xbf\xbb\x9cS\xb6\xc5\x98\xdf\xbf\x88RU\xdb\xd6\xb0\xc1?P\x16\xb1\x19F\xc4\xe5?\xe3\xfc\xb5\xf3{\x88\xe7\xbf\xbe\x0f\x16\xa7\xae\xe8\xf0?m\x84;x\xd4\xa4\xe5?M\xdb\xfc-\xe4\x1a\xd9\xbf\xb8\xb5\xadyR\x00\xee?N \xd9\x1f\xf8D\xf7?\xd3L\xc0\xac!\x8f\xfc?\xec\x94\xa7=P2\x01\xc0\xf9\x841H\xb2n\xd5?\xa8\xb5\xb9\x83}G\xd4?\x1b\xa7\xf5\x1f\xe1\x01\xb8\xbf\xca\x17\xe8\x95`\xbb\xdf\xbfQ\x08\x1b\xdf\x19a\xe6?K\xdd\x8b\xbf\x9e\x11\xe6\xbf\xe9\x1d\r\x8b6S\xb7?\xef\\)\xb8\xe9\xbb\xe9?V\xa1\x94\xc2\xc5Z\x04\xc0g\xfd\x85\x00\x1c"\xe5?\x00\x0f+\xabZn\xfe?\xeb\x10b\xbc\x07i\xd0?\x08\xed\xc2\x9d>v\xe7?\x03\xd8[\xbd#,\xfd?lN{\x00\x98\x91\xf0\xbf\xc4\t\xbe\x95\x85\x9a\xd0?\x88q\xd0\x9d\x1f\xb9\xee?aW=\xbe(\xaf\xe3\xbf\xaf\x8f-\x0e&\xd8\xf1\xbf+\x12+\xb5\x05&\xf2?\x953\xee\xa4\xef\xe4\xf8\xbf\x16O\x93\xf8\xe2\xde\xd9\xbf\xec\xf6\xff\x94\xa2\x1f\xcf?\xc6\x94\xef\x02\xddO\xe7?3{t\xc0\xb24\xf1\xbf\x87\x88\x1a\xfd\xb5\xe0\xf2\xbf\x84\xf4\xc0\xac\xc1Q\x87\xbf\xb7\xe8\xadD<~\xe8\xbf\xcf\xb58;\xb2S\xf6\xbf\xef\x93\x16&\xf5\x1b\xf5\xbf\xd3\x170\x81\xc7\xd9\xe3\xbf^\xd0N\xe1\x896\xd3?\x96\xa8!;\xf9X\xe8?\xee\x10\x87\x9b\x89{\xf5\xbfT\xb2\xb5\x0b\xa11\xd2?\xbf8\xd7\xd0\x01\x9e\xee?s\x13pr\xe1\x9f\xee?UZ\x8d\xfb\xcf\xc5\x01@\xc6)\xad\x18t\xc7\xcc\xbfP\xc8\xa4\x7f\xa7:\xd0\xbf\xd7\xe5\xcd\xa6\xcf\xa9\xe2\xbf$\x0b\x9d\xbf|\xf7\xaf\xbfg\xec\x94\xbf\xa9\xa6\xd1?\xe9h*h\x00\xc6\xd1?]&tP\xf8\x11\xe0\xbf^\xc3\x1bAj\xe3\xe8?\x067\x91\xb2.7\xe9\xbfTew;,;\xdc?\xb4\x82\xb0\x95\x7f\xcc\xe2?v\xa4\xe9\xbb\xc9;\xd0\xbfub\xa9\xb65\xf1\xf2?\x98\xc7t\xff\xc8^\xd0?\xf5&\x03\xa0\x94(\xfb\xbf\x1b\xf5\x94@N\x9e\xfa?\x84\xd5\xbd\xd0\xc5\xc6\xf2?\x86\x98\x19\x8e\xd1\xb0\xd5?\xa7;\x894\xb9k\xdd?\xeeC\xfd_\x82\xcf\xe2?\xbc,\x80h(>\xf9\xbf$\xbc\xcf\xb0\x85\x04\xeb\xbf\x8c\xd1\xfbY\xfd6\xe1\xbfx10?\xfc_\xd8\xbf\xd5}Q\xe8\xadM\xe6?s\xed\x9d\x9f\x8a\x0e\xde\xbf\xd1M[\xf9\x85\x8f\xe7?\xf6q*\x07\xa1\xf8\xf1\xbf\xe7|\x8f\xfe\xd0K\xea\xbf\xb91&\x91\x1c\xf6\xf6\xbf[\x8e\xd5z\x14u\xcf\xbf\x85\xe1\xeb\xf7\xd0\x19\x00@\xb03\xc0/\xd1Y\x02\xc0\xf7|O\x15\xf0\x93\xf9?\x17C\x98\xf2\x8a\x05\xa9\xbf\x17i\x91\x84j\xa2\xc0\xbf1hZrn\xf8\xbf?]P=Ag\x1f\xda\xbf"h\x1b\x07=4\xf0\xbf\x9b\xd3%d\x17\xe9\xe2?SR2\x9d >\xc8\xbf>K\x17\x03\xf3\n\xcc\xbf2:\x05\x156\r\xf6?\xadPp\x19x\x84\xc5?t/uu\xd4C\xe7?\xc2\x15\xcd\xf5?\x8c\xf1\xbf\xfb\xa7\x94\x9a\x8a\xf2\xe9?@\xa5\xa2;\xf6\xa5\xdf?\x95\xf3\xf8\rMb\xce\xbflar\xe5\xab\x03\xde\xbf\x1f\x8d\x1a\xec\r\xc4\xc2?\x97N\xd6\x89\xcc9\xf2?\x01E\xfd\xa6mm\xe0?\xb8\xaa9\x02\xec\x00\xf5\xbf\xfa5mmIT\xbb?\x99\x08&\x1e\xa6\xeb\xf2\xbf}\x83\xdd(\xb12\xc0\xbf\xfb\x94Mm\xc4\xc8\xd1\xbfq\x06\xb8\\td\xf7?)6J\xd3\xcc\xeb\xf2\xbfF\x16\xd6\x82\xe5\x83\xf1?Xp\xf9l\xaa\x04\xf1?\xc2\xaf\xb1\xeb\x8f\x9f\t@\x9f\xf5%D\xb3\xd1\xf3?\x0e\xb8\xc8\xf4g-\xf8?yu\xf2[\x1e\x9c\xef?\x9d\xb1U\xa7\xd3\xa8\xfd?P\xcb\x1a-6\x11\x08@"\x18\xb4\x0f\x15>\xe7?\x9e\xb0\xff\x07\xf5\xac\xf6?\xda\x84\x89\x97\xd0\xe1\x00@X\xfd7(\xb2=\xc0\xbf\xed\x9aS3\xbf\xe5\xd9?5\xb2\x10\'\x84_\xd6\xbf\xc2\x8e8v\x0cm\x03\xc0\xb6\x90\xd2\xb8p\x83\xfb?\xa0\x9bd`\xc1\xb1\xea\xbfR\xfdi.t\x01\x01@\xc7\xd5[\x1b\xdf\x10\xc5?\xb2\xe7\xa1\xec}\xbc\xf5\xbfX\x80K\xa9\xc6\x9d\xf0?:FV\xaa#\x0c\xb4\xbf\xdd\xb1Z\xef\xa1\xd5\xe9?7Zi\x83U3\xc5\xbf\x83\x07WK=\xb2\xc4?\x84\x98\xbc\xb4\xd1\xac\xf1?\x96\xac\x9c\xe8\x01\x83\xe1?\xff\x8a\xe88\x83`\xf7?\xcc\x95\x0cL\x9e\x8a\xeb?J!\xb2\x8b\xa3\xd1\xe0?\xbe#>\xf5\xde\x92\xfd?\xd8\xed\x85\xcbbr\x07\xc0\x10B`!\xdc?\xf6\xbfN\x9a%\xb7\x82\xfd\xb1\xbf\xdc-\xeb\xceI\xb3\xf3?o\x16\x1e\x94\xb4\x97\x06@\xea]a\x97\xe9t\xe8?\xffu\x88\x1c\xf0!\xec\xbf\x8b\x12\x84ei\xd8\xfc?\x81\xf6K\xf1x\xb1\x84\xbfI\x87\xf7V\x1b\xa6\xff?W\'\xb6\xd3\x85\xe8\xe7?\x8e>w\xa6N\x8d\xe4?p%\x8a\xdaI\xf4\xee\xbf^\x9aOl\xfeV\xe1?\xebi\xeb\xac\\\x91\x02@a\x83\x87g\x05@\x88?\xce8\x857-\xb0\xb3?\x1d\xcd&\xb2\xbd\xda\xdd?\x13\x01\x88Ji\x93\xe4\xbf\xdb5\\\x99\xa6\xa7\xed?\x9a\xbb\xc3\xc8{@\xd9?\\\xab\x9e\xe8\x14\xb0\xf4\xbf\n\xf4\xc2/-\xdb\xfa?\x14L\xd0s\xa7q\xfe?>"cn\xf3[\xe1\xbfG\xa0\xb5\xe77B\n\xc0u\xe1\xaf\x14\xbb\x03\x10\xc0$E\x06\xc7\xac\x96\xf1\xbf\xa3\xc3\x88\xe2\xd7,\n\xc0\xc8\xb5eZZN\x11\xc0\xac\x80\xfd\x8b\r\xc2\t\xc0\xa2$\x1f\x03\xc7o\x18\xc0\x99\xb9\xc9g\xba\x8a\x14\xc0\x15*\x8b>\xb5\xd2\n\xc0K\x02*\x04\xceX\t\xc0\xd3\x12_\xb4)\x90\xfa?\xf2]\xa5\xdf\t\x87\xf3\xbf-R\xce\xba*j\xf4?\x7f\x12\xe3\xde\x9aa\xef?\xcf\xcevs\xa6X\x08@"\x1b\xe0\xc7P\x95\xe1?\xad{\xa2\xd3\xdbr\x00@3\x88zI\xbb\\\xf6\xbf: \x9f5!r\xe5?H\xe4\x1cw\xfd\xdc\xe6?\xc5\xd9\x8d\x9e\x03h\x01@\xf8\xd5\xde\xbd-f\x02@OqK6k\xcb\xe2?\xc83I4\x1a\xc8\xe5?p\x8e\x1bc\rT\xf4?\x03\x03\x96\x1d\x82K\xd3\xbf\xb1\x01\x9d\x01\x85]\xe8\xbf\xd8\xc8\x1b\xda\x9f\x95\x05\xc0$\xc5^\xde\xc2o\x0b\xc06\x16S\xe6\x91\xc1\n\xc0\x897\x14L\xd7\xd0\t\xc0\xe5V\x1fR%Z\x01\xc0\x826\xa5\xc6lQ\x11\xc0(_n\xab\xb1a\x19\xc0\xa9\xaa\x07\x8f\xc2\x05\x14\xc0\xcf\x98\x08\x11EZ\x12\xc0\x10\xfe\xc5Y\xc9s\t\xc0\xb9\x95=>S\xf9\xee?\x92\x814{\x12\xcf\x04\xc0\xdaq\x9b\xb5\xccZ\xd3\xbfq\xac\x95\xd0?B\xc0?\x0b$\xe9/\x89\xb9\xfc?\x86\xb6\xfe\x1d\x90\x87\x0b@\x08\x01G\x05\x9d\xe8\xf0\xbf\xcdG\x88u,\x12\xe0?\x04\xb6\x9ey<\xfa\xc7?u\xd8\x9e\xc7\x90\xc1\xf6?\xdc\xe5\xd5\xa52`\xd2?>.+\xbf\xeb\\\xdc?\xdd\x1f\xe7C7\xdc\xe1\xbfS\xb6Z\x92\x03\x86\xfd?\xbd\xc7\xdc\x07\xa8\x01\xed?g\x12\x8dpb-\xd1?./yV~X\xef\xbf\xd2\x8e\xb1\x9e\x10\x99\n\xc0\x9bjt\x94ik\xf4\xbf9s\x08\x08\xc3)\x03\xc0\xb8\x02"\xc0\x19\xd3\x04\xc0\xeb\xacj%!\x1b\x11\xc0GQ\xae\xea\x98\xf4\x0c\xc0\xf0\xfd\xe5z\xde\x1c\x16\xc0m\xac\x9e\x06{\x0b\t\xc0gYn\xe4\x15\xf4\x0e\xc0\x98\xa3\x12\xd3\xd5\xed\x06\xc0K\n\x9b\x93w\xcd\xed\xbf\xce\x8cf7f\xd9\xe1\xbfc\x86\xbeNL\xbc\xf5?\x8d\xe6g\xe9^-\xdf\xbf\xaa\xac\x90Q\x81\xc9\xfe?\x0b\x8d9\xcbs\x9a\x04@<\xff\xbc\x19\'6\xed?\xa1\x17\xfc-\t$\xe2?\x9c\xb7)\xf2\x85Q\x9d?\xe9\x89\x8f\t\xac\xfa\xeb\xbf\xbd\xda\x12\xc5\xb7\x85\xbd\xbf\xef\xbd\xab\xc2\xfai\xc4?\x16|\xfcNF\xa4\xf4\xbf\xadP\xef\xf1\x82\x95\xf4\xbft\xda\'$\x9a\x87\xf2?\x88\x057(\x92\x9c\xda?\x93,H\x8c2\xd2\xe5\xbf\xf2\x04(\xca\xb3\x96\xfd\xbfn(\xac\x92\xd2K\xc5\xbf\x8b\x8e\xe8\xea,`\xeb\xbf\x9b\xd5n\xeaIi\x11\xc0p\xb5\xbb\x84\x13\xa4\x0f\xc0\xb1\xb6\x95\xf3\xfe\xe1\xfc\xbf\x9c\x88\xcd\xf6\xf4\xe3\x11\xc0\xed\x859-\xfdt\x18\xc0\xd0(\xe5\x1bI\xf8\x18\xc0\xfc\xc1\x10\x14\xac\xa8\xeb\xbf\x9a*\x8a\xdaH\xd3\xe2\xbf\xa3\x05\xf7\x9d\xd6@\xf3?H\xec\x84}a"\xcc?l\xa6\x14\xb55\xbdu\xbf\xb5(\xdbH\x86\xcb\xf0?vP\x80\xf7\xe8`\xf2\xbf\x15\x1a\xd3 U\xf4\x05@\x97\x85\xe9R\xa7\x93\x04@\x0e\xc0[f\xbe\x94\xff?\xa0\x98\x08\x0354\xc0\xbf\t\xad\x1d\xb6\xa0\xba\xb5?\xcc\x11\xcd\xfb\x1b\xa8\xe5\xbfI\xa4\xf0\xe4\x0bc\xd6\xbf\xef\xa8\xdd\xdf\x1a\x9d\xce\xbf\xb1\x8e]b\xfc\x1a\xf1\xbf3y/\xa3 \xd1\xee\xbf\xb2\x8f\x8ew\xb4\xbc\x06\xc0\x1a8z`f\xdc\x0e\xc0;\t\xa3\x1c\n\x16\xf4\xbf\xed\rv4\x84W\xff\xbf%\x03\xf1?\x17s\xe4\xbf_`G\xae\xa0]\x02\xc01\x9dC.\rL\x03\xc0\x96\xd0\xcb\xf8%+\xd1\xbf\x1b\x04\x92\x99\xdd\xf1\x11\xc0}\xbd\xe5*&\xa2\x16\xc0$\xb1A\x92\x92\xa8\xe3\xbf\x18\nH\x17&\x07\x95\xbf\xfc\x92\xa8\x86S\xce\xfa?k\x93\xf5?\x81)\xe9\xbf\xc8m\'\xcd\xbf.\xd6?\xf8(\xf2b\xe9\x06\xdc\xbf\xf0\xaf\x9f\x12;9\xd6\xbf\x89\xd6\xd3v\x07f\xe4?a\xab\xde\xb6\xbcA\xf2\xbf\x0fP+E@\x92\x03@\xfal]\x7f\x127\xe2\xbf\x87\x82\xf3o\x15\x87\xf4?\x14\xe5\x9d\xc2\x06\xb9\xbf\xbfz\xaf\xaf{y]\xd7?\xe2.g\\\r\xde\xd7\xbf\xab\xa5C\xdd%\x07\xe8?\x1c\xdc\xe4\x10kh\xf2\xbf\xd7\x93\x07b\xc0\xb9\xf8\xbff`\x85^\x1f\x07\x03\xc0\xde\xdbL&W\xcb\xf8\xbf\x8cFv\xe8\x08V\x02\xc0\xa5\x03\x83,\xe2(\xfa\xbf\xd5\'\xba\xbf\xe5\x01\xf3?\xc6ku( \x0f\xe5?\xd3\xa1jV\xf8d\xd9?\x81j\xa0\x14*g\x00@\xa1e1\xff_\xd8\xf9\xbf\xdc\x03)\x1b\xe5k\xf0\xbf\x8f>\x12.\x9c\xca\xa3?_\xc0\xb8\xf1&\xb2\xe9?\',M@\xf05\x06\xc0\xfc\x94\x04\xcc\xf3\xc6\x01\xc0\xa4\x9a$\x93P\x0e\xec\xbf\xfe\xb4\xb5)S\x85\xe4\xbfmc\x95\x16\xe6\xe4\x0c\xc0u:\xc8\x93\xc6\xa1\x01\xc0,\xd9k\x85\xbf\x10\x01\xc0*\xfa~\xc3\x1f\xb2\xd9?\x08\xa5G\x10\xf2\xab\xd4?\x0e\x7f\xca\xc2\x96\x02\xe9\xbf\xf3\x05\xbe\x8a)Y\xf2\xbf\x8b\x00]\x0b=F\xf4\xbfWs\x9c\x95Bn\x03@\x86\xe4 \xc1\x10\x13\xcf\xbf\x0f\xb5;\x19\x9b\x99\x02@i&\xc0\xd6\x00V\x01\xc0s\xb4V\x9f\xdc\xbe\xf6\xbfg\xc0\xc2)\x8at\xe5\xbf\x16\xbf\x17M\x1b\xd3\xe8\xbfk\xd2\xfcJ50\x00@\x82\xca\xfc\xd4\x9f\xf4\xf0?\xf5\xd98\xa8#K\x07@\xba\x1c\x81\xb3\x8c\xa2\x01@\xa4\xfa\xab\xb5\x1f\xf3\x1c@\x07\xfb\x12U\xb3\x9b\x13@G\x16\x1c\xe1s\xf9\xe8\xbf\x9b\x89\xaf\xa8\x81\x9e\xe7\xbf\x9e\xfdh\xf6m\xe2\x04\xc0@h+\xc2\xfa\xee\x05\xc0K\xc1&5\xd9_\x05\xc0a\xeeW;d\xfe\x0c\xc0x\x8e.\t\xc3\xb2\x01\xc0\x1c\xc9e\xb8D\xc6\xfb\xbfvj\x84\xa8\x9b\xab\xe8\xbf\x8a\xde#\xea>\x99\xea\xbf|f\x83\xc8(\xe2\xf2\xbfD|\x04a\xd1\xd2\xf3?\x8d\x8a\xe6M5\x85\xfb?\xc5\x94\x10k\xdec\xd5?q\xd1W\xbb\xdb\x90\x04@B\x83\xf4I\xb1\xf7\xef?\x05\xd5\xe6\x06P\xb0\xd3?\x9a\xf0\x7f\xb2\x7f\xbd\xe0\xbf\x9es\xa8\xdde\xa8\xff\xbfNs\xa2>\xa6\x8a\xe8?\xa8\x04$\x92\x82\x12\x08@)c\xee#\xec&\xf3?L\x94\x0eR\x8b\xb7\xfe?;\xdd5:Ws\x03@\xa1X7\x7f\x8cJ\xf9?\xd1$\xb6\x9d\xb2\x9a\x08@f\x11\x06\x1f\xdeK\x13@\x96C\r\xc1\xce!\xf0?\xc0!R\x8e\xc4W\r\xc0\x7f\xcdo\xc0>\x0f\x01@\xd8\x9d\x9c\x8e\xc8\x1d\xe1?\x04\xf8\xdfI\xe5\x0f\xce?\t#\xc7\xeb\x8dy\xf4\xbf\xa6\x04\xbce\x96k\xe7\xbfcZz;I\x15\xf8\xbf\xb1\xc2\x7f\xa9\xd5l\xf3?\xbb\xc5 \xb1\xde\xcd\xc9\xbf\xca\x0b\xc5\x9bT\xd0\xe9?\x13\xe0K\xad\xa4\x96\xf6?\xd5\xf2?\xe5`\xd8\xe8?7\x92z\xea7\x9b\xea?\x1e\xc89$\x1dJ\xe7?Q:I\xd9\xc2p\xdf\xbf\xa9Q\x91P\x8fA\xf3\xbf0\xf2\x94\xbdZ\xf3\xd5\xbf\xec,2\xc1\t\'\xea\xbf\xfa\xa5\x87Kx\xa3\xea?Q]\xa0"\x1d\t\x05@\xac\x1b\xcfk\x80|\xf7?\x0fKOAK/\xf5?\xd0n\xc9\x95\x0e\xff\xf5?FT\x16Xd{\x07@)Iv<\xfb\x1f\x00@\x9d\x8f\xeeX%\xb1\x11@\x96\x87\xf0q\x02\x1b\x10@Vn\xb0x\xf39\xf2?\x91\x873\xb1\x13-\xe8?\x8e\xe1\xef\x17\xca\xee\xbc\xbf\x14\xbc\x82\x92\xee<\xdf?\x9fF\xba\x8d\x8c\x1c\xf2?\x9a\'5^\xf8\xc9\x02@\x04\x04\xe2_\nE\xed?g\xe8\xd5\x94[A\xe9\xbf\xf71c]\x01w\xb9?H$\xf5\x91\xbf\xe8\xf2?\x1fz\x97\x11`\xee\x07@y}\xbd \xdc\xa3\xf4?Q\xd6\xfa\xc0\xe0\xf0\xf9\xbf\x02\x07\x01\xe5\x95\x1d\xe2\xbf\xaf\xd6S\x1b\xd2\xa8\xf3?Ykr\xad\xfar\xf3?\x11\x8fl\x01v:\xe7?\xd8P\xbe\xf2\xf2\xd0\xd9?\x9e7\xbaX2c\xd9?\xcaW\xc3\xb9\x1f\x94\x04@\xbeE\xd6R\xda8\xf4?\xe6`\x03.\nh\xf9?\x1a?\xbe\xd1\x85Q\xf8?\xa2w\xae\x9fn|\xf5?\x1c\xe6o\xfe\xf7\xf1\x03@M\xad\xe5\xe8\xa0h\xf7?v\xac6K&\x01\xeb?\xe7\x11\xb9<:\x01\n@p\xcek\x1a\x87\xce\x0c@\xcb\x98\xba_Y1\x06@\xe4#\xdf\xf7\xd04\x9a\xbfm\x8a,\xcc~e\xf4?\x9c\xf6\xdb\x8e\xdb\xe5\xe8?%9\xd6\xa7G\xec\xe7?+\xbd60\xff~\xe1\xbf`\x90@\xc6\x8ci\xd4\xbf\xc2\xe9\xcf\n\xa9&\xf0?\x061\x90h\x8d\x15\xfa?\xf9\x1d\x87\xca\xa4"\xea\xbf\x91\xbe\xbd`\xb8v\xe5\xbfy\xe17\xe6\xff\xfe\x02@]\xd9^*\x924\xd9?\x17=E\xf77\x11\xeb\xbf*\x9af\x10w1\xfa?\x8f\x95A\x8e\xf2\xc5\x02@\x12\xcc\x93\x97\xa3&\x92\xbfV\xb7\x16\xcf\xfb\x13\xb7?\xeb\x06\x81A?\x9e\xb6?\x98(\xec\xdd\xde;\xf4?&\x08BA\xa0d\xf4\xbf\x99\x93p\x83!\xfa\xf4?\xc0B\x0f\xae\xaa\xa0\xf2?t\xf4\x1e\x92\xb2:\xe7?\xfa\x86\xc4\x95\xe8\x1e\xf1\xbf\x8c\xbb \xa1e\xa8\xd5?\x82\xd1\xc2\xd2x|\xfa?\xb8T\xb3R-R\x03@\n7GRkr\x13@\xb9\x9a\x0f:\xf0\xcf\x10@}r\xbe;\xa2\x9b\xff?\xab7*\xbcF6\x01@\xc4\xdf\x86}\xd46\xf6??\xec:VZ\xa8\xfb?\xe7\xcd\x92\x0e,\x15\xff??\n\x03\n\xb2\xf4\xff?\xd9\x0c\x02]\xf3\x1c\xde?\x93\xff\xbb\xeaDP\xc6\xbf[\xfa\xb2Ci\xe1\xd6\xbf\x97}"\xce\xb0"\xe6\xbf\xdd6\xbf\xc8O7\xe3\xbf\x13B\xf3C"\x84\xf6?x\rT>Z\xf3\xf3\xbf\xe4\xc0\x05RB\xee\xdf?\xe1Y\x07\xf7;\xe3\xec\xbf\x9b\x1f\xb6!m\xf8\xfc?\xfb\x00L<\xa2!\xf4?:\xe6`e\x19\xad\xca?\xe6$[\xcd\x18>\xd8\xbf\x8am$`\xfax\xfe?\xf2\x1e|j\x1b\x13\xf3?\x83\xa1\x84\x8c\xca^\x08@\xa0]\xf7\x86\xf5\xbb\xe8\xbf8\xc14\xc0&\xb0\xae\xbf\x07@\x1fH\x01T\xe3?o\x7f\xd7?\x983\x04@\xab\xb0A\xee\x9bx\x05@m\xca.2\xdc\xe5\x11@\t\xc4kn\xfd\xf0\xfe?b\xed\xf5r\xcb\x0e\xfd?\xab[\x13\xc0xh\xfb?H\xd1_\x90\xc9`\xf0?f\x18\xa2J\x11\xca\xdd?~q\x82\xaa\xca\x84\xf4?-\x05B\x13 \xc9\xf3?\xc47V\x18\xad\x84\xb5?\x07\x1e\xaf\x92\x9a~\xe0?ps\x05~\xbbK\xb2?\xbb\xfd\x8c\xde\x1f\x1f\xd9?\xbc}\xfc\x0f\xf8}\xef?\x8f\xdd\xfbg\xec:\xdb\xbfHVbSI\x08\xd0?\xd5\x1ds\x13?\xe5\xeb\xbf\x0c6#\xb2,\x7f\xfe\xbf o\xe6\xf3\xb2o\xf4?\xc5\xe0U\xb0-\x99\x00@\xe1\xe8\xba\xf3\xd5\xa4\xf0?G\xab\xd3S\x1e\\\xe3?o\xec\xa6\xb3)r\xf1?\x0e\xd8V\xa8f\xdc\xd2\xbf\x17\xcd"2\xb3\xd7\xfc\xbf\xf2\xc6\xe3\xc78L\xe6\xbf\xf7:\xe9\xb7\xc5\xad\xe7?\xc1\xcf\x944\xe3\xe4\xf9?\x81\xc4\x13\xa3 \x0e\x00@\x85\xaf\xddh|\x1f\xf5?\x7f\x05\xd6F\x07\xb3\x0b@tU`$Q\x82\xca?\xbbg\xb5i\xa1\xa8\x00@\xdb\x85\xb6\xaa\x13J\x06\xc0\xfd\xbd$)q"\xfc?(eL\xc5T\xfa\xf1?k1\x1d\xc1!\x9c\xf9?O\x16+(6\xc4\xff?\xec\x83M\xa0\x840\xf3\xbf\x80_R*\x87I\xed?\xfc\x86\x17\x04\x9f\xa7\xe0?\xaf5-\x96\xc4\x84\xd7\xbf\xd6\xe9\'c\xb3\xa1\xd7\xbf)\xac\n\xb9\x93!t\xbf\xc2\x0b\xb8\x10\xceF\xd9\xbf\xe9D\x11\xae>\x11\xd6\xbf\xae\xaf\xa9x\xa6l\xc4?\xc0r\xb0\x94yK\xf0?\x95o\x19d3\xd6\xe4?\xdf\x91\xc7\x97%\x1b\xf9?\x00\x08DH\x9c\xf9\xe2\xbf\xa5\x88\xc8\x9b>L\xe7?\xd0\x1d\xa4\xd2\x11\x8d\xc2\xbf\t\xb1\xef\xec!\x8d\xfd?\xf6\xc3\xd1\xd4\xbc\xda\x01@"\x98\xbf\xe1\x96\xfb\xdc?l5\x12z#B\xe0\xbf`\xd3\xc4E/d\xfe?\xcad\xecu"\x8b\xf2?\x87x\xb6cl\xc9\xd7\xbf\xdb\x0f\xa8{L]\xe4?\x89\x03"8\xe7f\xe9\xbf\xab]H\xb4&A\xde\xbf\xa2\x82=a\xd8:\xff\xbf\x8ff|\xa6\xd2}\xf5\xbf\xc2M\xc5\xbea\x87\xed\xbf.}x\xbeRx\xd9\xbf\x0e\xea\x06\xb0\xa4;\xe7\xbfT\x81\xf4 \xbaH\xdb\xbf\xa4;\x1b3\xc2\xeb\xe9\xbf\xa3\xa4\x80\x07\x8d\xcc\xd2\xbf\xc4\xb8DL\xa0\x1f\xf5\xbf\xdf\xd9\x94\t][\xf3\xbfI\xe4\xf7\xb4:\x88\xf0?\xc1\xbcI~\x06Z\xfa\xbf\xdc\xb0\xbb\xfc.\x96\xfc?:\x9c{N\x10j\xe2?CV\xe3\'\xc0\xa7\xe8\xbfD3s1\x1fX\x01@H\x96)\xb2\x88\x9d\r@\xadMs\xc9\xf5\xe5\x07@\x82\xc4\xe2\xaaD\x10\xff?Y\x81R\xc4\x8ce\xfd?*[\x99o\xbfQ\xf9\xbfW\xf7Vw\x88\x7f\xd9\xbf4\x86\xf8\x10\x1e}\xff\xbf\xb3r\xaa\xb6\xbf\xf0\xe5?\x00\xa0\x8a\xcfw2\xe0?\x8a\xa4W\xc3T\x07\xde\xbf:\xdc\xbd\x82\xb5y\x02\xc0\x0f\xefR\x90\xc0\xcd\xf4?\x95\xf0\x82\t\x9c\xe4\xe9?\x13;.\xf7\xe3\x9b\xf9\xbf\xcdN\xfd\x86\xfb\x8a\xf0\xbfff\x91\x90j:\xce\xbfs\x1c\xf8\xa9\x14\xab\xc1?\xde\xbe%_e\xd9\xfa\xbf\xee\xff\xd5\x94\xd3B\xee\xbf\x8f\xb2\xa2\xae\xf7\xf9\x05@\xc8\xd0\x97\xf3\xa2\xbe\xf4?\x9dvZ\x01\x86\x12\xb2\xbf.\x8a\xc8\xdd\xa3\xf8\xd4\xbf\xc9\xe7\xc3X\xff\xc6\xf0?\x8f|\x19\xb4r\xfd\x81?\xcb\x13\xe1\xd38\x12\x93?f\xd2\xfeQ\x16\xf0\xf1?le\xda\rqd\xee\xbf\x8fO\x83f\x8e\xd8\xf9?\x83"\xe3\xeb\x8d\xf2\xd5?3\xfa\x95KP\x02\x08@\x0e&K0)s\xcc?\xdax\x1a\xc2\xc1"\xee?r\xc5\x80\x8c\x8fL\xe9\xbf;\x84\xa0\xd2T\xe2\xe0\xbf\xc5\x14\xf4\x19\x81\xe6\xe3\xbfVa]_\xc3\x83\x03@\xe9Ei86\xa0\xe6?\x7f\x01K_\xba\xcd\xde?\x80\x18g\x0c\x12\x0b\xef\xbf\x00_\x99\x19\x14\xa3\xf5\xbf\xc0 \xe8\xa7}\xbe\xe2?\x82>\xc1\xfa\x9c\xa0\xd5?\xc0\x1e\xb5\xc2q,\xe7\xbfP\xe5\x85\xea\xb5\xf3\xe1\xbf\xfe\x15\xc1\x94\x8d\x0e\xf2?\x03[\xbf\xcesx\xf3\xbf\x98\xf9$n\xca\xab\xc3?\x9e$\x84z\xd6R\xc1?\xd7m~u\xc5.\x9f?iX4k\x9a\xd9\xf9\xbf\xd8\x14\x01yS\x15\xf4?\xb5\xbcq\x90\xe5\xd3\xf3?\x8d\x94\x9e\xaa\x02t\xd8?\xee^y\xce,\x81\xf1?\xc3\xb7\x82sFf\xec?]\xf5r\x9ad\x06\xdd\xbf\xb7\'\x8dE\xea\x98\xcc?%\x9eU\xf8\xdaj\xd6?3s\xab\xb1\x8c\x94\xfb\xbf2\xe6tY\x13b\xc5\xbf\xa9\x01\xff}\x0f\xbf\xe4?\'\xc5\xcc\xe8\x8e\xa8\xbf\xbf&\x7f\xadu\xb2\xd5\xea?\xe3\x82a\x1b\xf4\xd5\xf2?KP\xd7\x16M\x0b\xe0?\xa9\xbcH\xbal{\n@MKM^Z\xb5\xfb?E\xfe^\x07\x1e2\xed\xbfe=\x11_\xc3\xb9\xf6?\x95M\x8dc\x0b\xab\xd1\xbfXq\xc4\xe4\x8f+\xe1?\x04\xd2\xe1\x95Px\xd1\xbf\x9b\xa9\x0fi\x15\x12\xca?\x1c!\xea\xec<\xe5\xd4\xbf\xbf+\'AM\xe2\xf0?\xda\xaa<\xa8\xd13\xf3\xbf\xbd\x7f=\x88\xc7\x86\x02@k9\x83\x07N\x9c\xfd?\xce\x8d\xb4y\x1f\x1e\xd4?\xaa9E:S\x11\xcf\xbf\x9aU\x95\x02\r\x98\xf5\xbf\x1c`0\xf3!3\xf9\xbfxe\xe4x\xc8\x16\r\xc0\xb87PF\xa8\xa7\xf3\xbf\xb6x\x0b\xb3\xa4\xf6\xf3\xbf\x0b\xf44W\x88\xb1\xe0\xbfX^Z\xcc\xda\x0c\xb7?\xf3m\x9f\xf7\x1f\xb1\xe6\xbfU/\x1c\x9b\x81m\xb1\xbff5\xa50\x10\x08\xf8?\xce:1&\xdc\xb1\xba?@\xec/\x18\xcaC\xdc?\x8b\xe4\x0b\xf3\xf4?\xfe?)b$\x17\xe7I\xb7?\x8c\xcaP\x06\r\x8d\xe4\xbf^\xe2\xd6#v\xfe\xc1\xbf#\x92\x9b\xf5%\x1b\x08\xc0Y|\xd11D\x0b\xe6\xbfJ\xbfuj\x05^\xe1?8\xb4\x1e\xdd\x10\x94\xd5\xbfw\xe6\x03U\xae%\xff?\'\xf6\x06-\xa2\xb7\xe3?\xbf\xfd\xbb\'2\x03\xe5\xbf*00\xe1\xe7\xcd\xb7?\xd9\xc5CU\xf4\xd6\x02\xc0o\xfd\xfe\xea\xf5\x18\xca\xbf\x158k\xc9\x81>\xf1?\xed\x0cp"\xcd\x97\xe4\xbfn\x1e\x97\xae\xbe\xf7\xf5\xbf\x92\x00\xa3=\x94\xfe\xf6\xbf\xad>\xdb\xabc\xb0\xfc\xbf\xca\xea\xab\x1c\xc0\xac\x08\xc0\xbe\xceu]_\xe9\xfa\xbf\x01\x88\x19\x82\xde\xc0\x03\xc0\xf5\x16H\x8fM/\xe7\xbfb?B\x88\xfc\x1c\xfd\xbfzp~z\xfdq\xc4?D\x1e\xc6\xc1\xdaG\xf0\xbf\xd9\x10w5\xff\x12\xc5\xbfK\x93\x1f4\x12\xfc\xfb\xbf\xdb\x02\xf0\x90"V\xf9\xbf\x07`\xe5\xb8e\xcd\xf2\xbf\xa7\xef8\x95\xc9\x1d\xd2\xbf\x0c\x02\xfb\xb0\x91\x87\xe1\xbf\xc6T\xe6\x0c\xb3\xb9\xcf\xbfM\x11O\x87\xd8p\xec\xbf\x1cH\xb0-g\x86\xb9\xbf\xdd;\xe9\xfb\x83\x04\xf7\xbfyk)\xf7|\x10\xe1?a\xd2\xd9\x8d$\xec\x82\xbf\xb8\xc0\xf1\xe90C\xdf?nC*P\xe2\xba\xed?\xb8\xcb\xf6;\x1b\xa3\xe6?%u-\xf3\xcfs\xda?\xc2"k\x1c\xe4\xaf\xe0\xbf\xbc\xd6\xd6^a\xb0\xb1\xbf1\xf1\xf3\x80\xaa\xf2\xf6\xbf\x1c }-g\x0c\xf8\xbf:\xf4q\x1ea\xc3\x02\xc0\xe8t\xec\xe4e\x1d\x02\xc0R\xde\xdc\xda\x04\x96\x0b\xc0\xe1\x86GX\x1d\xe8\x0f\xc0\x17^\xb5C\x03x\xe4\xbf\x91\xba:rk\xbe\x03\xc0\nS\x84\xea\'"\xf6\xbf/2\n\x95~X\x04\xc0(u\x8b\x1a!1\x07\xc0b\xbb\xa1\xe1\xad\xce\xf2\xbf\xabu=\xf7\x87\x84\x04\xc0\xf6\x8c\xc5*\x1d\x0f\x06\xc0Bv\xd6\xdf\xa8t\xf5\xbf|\x84\xc5[Ap\x02\xc0\xee\xc8\x94A\x9aX\xf6\xbf\xd6Id\xb0\xb9\xb1\xec\xbf\xf8\n\xe6\xb2\xbfe\xe1?\xd9\x06\x15\xae\xa8\xbe\xd7?a\xe7\xcf\x8e\xf3p\xf0?k\x8f\xd47\xf3\xc9\xe3\xbf\xcfMo\x8b\xf6\x90\xf0?=\x0b\xb4Wn\x85\x01\xc0\x8bx\'\xdc\x06T\xda?\x91}\x08\xff\xceS\xf1?\x9e\xca\xe7s\xb2n\xe4\xbfre\xf3:\x80\x10\xd5\xbf\xb1\x89G\x10\x9do\xf2\xbfr\x14%&\x10\xd4\x01\xc0\'\x7fF+k\xcb\xeb\xbf\xcc\x8eJv\xf2x\xe1\xbf\x15\xb95\xc8\x96\xb4\x00\xc0\x82\xce\x19\xa3\x92o\t\xc0B#\xd5\xb5+\xc4\xf4\xbf%\x9a2YiU\x11\xc0\xc7\x90\xaa\xfcl\x80\x0e\xc0\xdd\x82;(\xccE\x06\xc0 g\xed\x8f\xd5\x83\x0c\xc04m]\x86\x8d\x0c\x01\xc0~\x88\x90\x02C\xb5\x0f\xc0\xf6\x1e\x910\x1fC\x00\xc0,\xf9\xf7\x13\xfd\x08\xf3\xbf!q\xed\x84\xaf`\xc9?\r\xf1\xf6\xc2\x16\xb8\xd0?\xf6\xbd\x0b[\x10\x96\xcd\xbf-N\x01\x0c\xc3\xd4\xe2\xbf\xb0\xf6\xfa\xb8\x9a)\xd3?E\xe6\x9c\x97\xf4\xc0\xf5\xbf\xf4\x0c\xa8\xc6\xdd\x81\xf9\xbf\xe0)\xc7*#\xad\xd1\xbf2\xd7\x95\x04T@\xe3\xbfn\r\xc7\x9a#\xbf\xfb?2\xb3Q\xa7\xa0\x18\xf4\xbf\xa6p5~C\xf1\xf1\xbf1\x11\x8d\xed\x83\xf5\xe9\xbf\x082Q\xc6Jl\xc3\xbf{\x93\x04\xe7\xb5\xf7\xf2\xbf8\xc8\xd0MY\t\xf2\xbf\xff4\xad\xd6\xa0\xd0\xd4\xbf<~p\x91\xb2\t\x00\xc0g\xbb\x99\xc7\x8b\xd4\xe1?!\t\x11L\xe7<\x02\xc0\xdb\xa3\'a\xd6}\xe7?$\xb6\x12\x95M\x13\xe1?\xee\x06\xcf\xda\xb8Q\xec\xbf\xdf\x15\x11\x85\x95b\xf2?\xc1\xf6\xb3`\xbe\xb6\xf0?\xd4\xddw9\x06\x93\xfa\xbfe\x84\xea+\xcc\x84\xa9?\xdc^@\xe4\x98\xd7\xe5?\xcb\xb6\xb6\xec\x0c\xca\xde\xbf\xcc\xc7\x7f!8\xb0\xf2\xbfTz\xd8\x05\xaa\xc3\xed\xbf,%\xc11a@\x03\xc0\xef\x8d\x9b\xb3\xf4\xcd\x03@\x9c%\x86\xde\r\xfb\xa4?J\x8f\xaa?\x82\xcc\xf1?Dk\xe6-j\xc4\xf1\xbf\x87\xaexcro\xe3\xbfe\xf2\xe0\xe0\x018\xf4?m\xefi\x9e\xc0.\xe2?\x9d\x97\xbc\xd0\x97H\xd7\xbfq\x9c\x02$\xab\xb9\xef?"F=&\xa7\xc6\xcc\xbf47\x98\xe6#r\xf0\xbf\xcc\xfdV Wl\xda\xbf|v\xba\x1f\x12\xc5\xdb?\x0e\xbaW\x0e\x98\xd6\xae?\x9c\xe6\xfa\xf9\x00\x0b\xc4\xbf\x03\x80\x02\xb2;\xaf\xe0?\xe2i,\xf8\xe0\xe3\x98\xbfF\xb5\xe15\xd4>\xf1?Rj\xa0%gD\x01@\rY\x19\xe2\xcc\x86\xf3\xbfZ\x9e\xee\xcb\x8d^\xde\xbfFA\xfb\xd5\x842\xf4\xbf\xf7\xc3\x9c\xd5\\\xe2\xdb?u\xbaH~\x97\x86\xd6?\xd3\xbc\x95t\x98F\xc5?\xac\xfcI\x8d3\xe6\xeb?DYM\xb3\x93 \xb5\xbf]wP\x92\xae9\xea?\xb4p\x8b\x9aX\xb7\xce?B\xb9\'\xfc\xf8\xfd\xf3?\xbb\xbfW\x93;\xad\xb5\xbf\xca\xd8G \xbf5\xe4?:$M\xdd\x1b8\xeb\xbf\x0eh\x010\xd8\x8d\xd5\xbf\xf8\xf8n\xe2\xca8\xe2\xbf\x0b\x9d\xcb\x1dw\xdb\x06\xc0\x87\xff\xb9^V\xe3\xda\xbf\x02j\x7f\xdfV\xc0\xe1\xbf\xba\xd0zM\x9f\xb0\xfc\xbf\xed\xba\x0c\xa4\x99\xcc\xd2\xbfe\xf9k%"\xb4\xf6\xbf\xa2\xbb*\xe7\xfa \xe9\xbf\xec1\xe2`C\x9f\xf3?\x13G\xfc\xe7\xa4\x00\xe7?3\xaa\xac\x8d\xf4\xd1\xdb?\\\xbb\x83dza\xf3\xbfQ5f\x15\xcf\x03\xed?\x88^\x14\x94r\xa9\x9c?q&\x0f\xe6\xf1"\xcb\xbf\x9c\x16|\x08\xe3%\xe4\xbf\xc8\x06\xbf\xf6\ne\xd6\xbfa\xbb\xab\xe7e\xbf\xe1?\xd9\x07\x01\xeb\xfb\xcb\xdc\xbf{\x87\x84\\\xf8\xbfI3\x1aW)\x90\xf8\xbfT\xc4\x98\xeejU\xf0\xbf\x1a(\t;\x8c\xa2\x05\xc07\xaa3N(\x8f\xf7\xbftb\xaaf\xac\xcb\xf6\xbf\x83\\4\xe8\xd3\x1d\xe7?#\xe7P)\x9c\xb4\xf5?v\\%)X\xc5\xcc\xbf\xebn%h\x9e\x0f\xfc?\xe6_\xdaU\x9e\xac\xef?\x95B\xab?\xcc\xc0\xf4\xbfyW\xd0\'\x0fN\xf6?\xc9\x0er\x86\xb6!\xdb?@\xb4\x19\x99\xff\xbf\xfc?\x94@{W\xec\xb5\xf8?\xc5\xb6\xb4\x81\xd6%\xf0?\x0f\x1cn\x9b\xa7\x8e\xe2\xbf\xbct\xb9\x1a\x84\xce\x02@\x11\x1a\xdc\xbb\x99\x9d\xda?\x86r6q\x84]\x02@\x8a:\xb4#_\x89\xd9\xbf,+\xae\xa5\xc6(\xef\xbf\xa4\x0c\x15{\xea4\xf1\xbf/\x8ek\x89r\x87\xe4\xbf\x83\xbdq>I\xa8\xf9?\xd0t\x01~ `\xf1?\x00\x98f\x0bw\x0b\xee?\xe1_\x10\x89\xf5H\xa0?\x94\xe2R^_\x83\xf2?bbS\x17\xe0\x0e\xb1?(WWB\x97\xa1\xd7?T\x95!JMc\xfe\xbf~\xf19\x1dfi\xf8\xbf\xe5C\xb5U\x1c\xe2\xdb?0\xe0\xb8\xc9\x0b\x1f\xcc?\xa7\x96\xdfh\xb3\x95\xe8?\xf0\x05\xe1\x13\x1c\x99\xfb?E\x8c\x00\xb3\xc0\xc1\xa7\xbf\n\x81UJ\x0b"\xfa\xbf\x9fr!\x08\xaf\xab\xf2\xbf\n\x86\xaf\xad\xab\xcb\xed\xbf\xc1z\\\xdf\xd72\xeb\xbf\xe0r\x84\xda\x9dv\xf1?\xce\x95\x95\xd8\xe7\x88\xa5?\x97 u\xa0\x94]\xed\xbf%\xb7\x07`\x98\x08\xec?\xa6\x85\xae\x00\xbaO\xf4\xbf-\x15\xc4\x01\xf8\xf5\xfa?G\x89{V\xb8:\xd0?\x97\xd0\xb6 f\n\xd0\xbf\xdfZ\x9b\x86\xce\xca\xe3?\x08\x8a\x91W}i\xe0?\xb7\xd9\xf7\xacK\xc8\xf2\xbf\x13\xf3\xf3P\xac-\xd0\xbf\xfcE\x8f\x04\xc8 \xc9?\xf7\xb3\x8e\xb0\x8d|\xd1\xbfi\xbaB~\x99\xc2\xf7?56\xa7\x11\x00\xf3\xc2\xbf\xf2#\x07\x95_\xa9\xb1\xbf\xf9hgX\xa8w\xd0?\xde\xa2\x0f\x8b5\x84\x08\xc0\x8e\xf1\xe8\xbdR\xb3\xfb\xbfK\xbb\x1f\x9d\xe5\xa4\xdd\xbfz4\xd3f\x1cs\xea?J\xdfRu#/\xe4?(\xbelj0\xac\xc2?\xef\xb9\xac\xd11\xf8\xdf?\xe3\x04\xa0\x8c\xdf2\xe0?\x11\xe6d\x14QI\xd4\xbf\x91\x9e\xe3\xc5\x08w|\xbfB8B\xb2\xaa\xef\xa5\xbf\xd7xx/L\x1e\x01@\xe3\xf1\xe4\x83\x0b"\xd9\xbf\xd8\xca\x8ez\x9d\x9c\xc1\xbfd\xfb\xf1\x87\xe1\x10\xf2?OI\x8a\x15\xa6\x8d\xc6?\x86/t\x03Vd\xda?Q\x02\xfe\x1f\x7f\xd6\xce\xbf1\xe1\xe4\x92{\x15\xfb\xbf\xe1\xdf\xad\xe5[0\xe2?\xa4D\x1a\xdc;r\xec?\x13\xad&\xb9\xee\x0b\xe2\xbf\xc3~h\xde\x92\x7f\xe6\xbf\xf9\x9c\xf7\xe0R\xd9\xc6\xbf"\'\xea\xc4\x8a&\xfd\xbf\x12\x1d_\x1d\xf2\xe7\xc8\xbf\x14}[\x1b#\xbe\xe4\xbf\xd2\x0c3>\xdd\xaf\xe9\xbf9\xae5\xea\xba\xb1\x01\xc0<\xf3\x8bW\xa6\xcc\x01\xc0D\\\x01\xa6a\xa4\xeb?\x02\x9b\x17\xf6\x84c\xe1\xbf\x812=\xaf\x15\r\xf2\xbfb\x14k\xb2\x12o\xd8\xbf\xea\x8e\xd2\x9c2:\xd7?Y\xbaI\x88\xf0\x99\xe7?.\xdf?\x9e\xacC\xf6\xbfv\x02\x07\x97\x03\x9d\xe9\xbf\xa0\xc6\xfao\xd4\xd8\xf8\xbfi;\xa3\xc0\xc8r\xdb\xbf\x9eC\x8b\xbc\xfd\xf3\xab?\xf8\x81\\\xa8#\x9a\xf7?\']=\n\xb9\xa6\xd3\xbfp\xc60j\xf8\xdd\xf0?\x8f\x99\xfdyLi\xe6?B\xf9\xcftm\xff\xfe?\x99\x92I\x1c\x15x\x05@Z\x8f\x83\xea\xe7\x11\xe3\xbf\xact\t\x7f\x9fN\xee?N\xedR\xaa\xd8h\xee?\xaexN*\xc4=\xdd?\xdb \x93c\x19\xde\xf3?\x98>\x01B\xbe\xcf\xfc?\xab\xc8qi\xd6\xac\xd3?\xc7Ki.jo\xf8\xbf\xde\xc2D _\xe5\xd6?\xb6\xaf\xb3.\x06Q\xfd\xbf\x93(\xcfEP>\x00\xc0>Y\x14\xe4R\xbf\xe0\xbf\x8f\xef\xceo\rh\xbc?N\xc8P\xbf\x02U\xd6?v\xad\xce\xd9G\xa8\xdf?\xc5\xc2/\x9ezs\xf0\xbf\\\x1d\xf6\x170S\xb6\xbf\xc9\xf0$\xea\xd1\x8e\xfa?r;\x91vwr\x01@4=\xc0\x827\xe4\xf9?6\xfdKx\x04&\xea?\xdc\xb6Z\x05\xf6\xe9\x07@\xd7\x00\xd3\xee]\x9c\xe4?\xabW\xac\x92@\xcd\xf8?\xf6\x86c\xfb\xd6\x0b\x00@&\xcb\x1e 6G\xce?|c\x97\xc1\xf1\x0b\xeb?\xe2\x0f\xfd\xcd\xbe\x92\xdd?\xd5F&W>\xc5\x01@\x13\xe9!WZ\x85\xe0?\xa7\\0\xc5"\\\xc9\xbf\xc8\xf8\xb7\xb5\xe4\x95\xe8?\x16\xc7\xd0_/=\xea?Vo\x95b3\xd7\xf2\xbf\x8f-\xff\x9e\x89\x04\xf0?\x18\xee\x8bb\xb2\x19\xf9?\xf5\xa9\xfe\x00\x9e\x1e\xb9\xbf\x8a\xe8\xc3\x9cT\xe3\xf5\xbfZ\x8aZ\xa9\xfc\x82\xf0\xbf\xa8\xf1\xc2\x8e\nJ\xe9\xbf.\xfe\xe1\xb8P(\xd1?\x11\x98\xc7s"\xd6\xeb?\xe0s\xf6\xe5\xe0\x83\xe5\xbf(1\x12\x8d@\xd8\xdb?%\x8b3\xfe\xa0\xa6\xca?_%\xb0\xf9\xccK\xd2?c\x9f]m\x8c5\x04@\xa1\xd3\xdd"\xc7Q\xf8?\xb7l\xc3YB%\xe6?\xaf\t\xb1\x9a\'R\x02@\x06\x95\xda\xc6L#\x01@#It\xc7\xe9G{\xbfz\xd7E\x83\xe3p\x01@[p\x10\x7f\xbb\xb0\xeb?U\xaf`\xba\x8a\xc3\xfb?\xda\xa6Y*\x82\xf5\xc4\xbf\x13\x1e\xc1-\xf6\xeb\xd5\xbf\xefNrZ#\xc6\x01@x\xb71\xd9C\xaf\xfb?c\xd4\xa8P\xfd\x93\xe7?(\xaf\x15fI\xd5\xe4?\x8f\xd42"\xe1\xa1\xe2?A\xfa\x0f\xca\xfe%\xb7\xbfDjy\xc6,\xce\xe4\xbf\xa2\x01\xf4\x9f\xf3\x82\xc6\xbf\x04<\xe1.\xa0{\x06\xc0\xe2,\xe1\n\xc4\x82\xfb\xbf`\x07\n.\x8be\xf4\xbf\xfdRK\xfa"\x03\xd6\xbfV\x12=\xb3\xfdx\xb4?{\xe75t\xfe~\xf0\xbf\xeb\xe9\xae\xc14\x9d\xb1?\xc2\xf02U\x9e\xb6\xf2\xbf\xcc\xa9\xda\xe5x\xa6\xf4\xbf\xfbW\xf6\x86Z\xdb\xde?\x97\xbb\x8cA\x8a\xcc\xd7\xbfL\x9c<\x08Eg\xf3\xbfT\'\xf6RJ\xb9\xee?\x9c\x89\x88^2\xcf\xf6?\xccV\xb89\xee\x07\xda\xbf\x0b\xdf\xd9\x98\x03\xd2\xe6\xbfC\xb4\x01\x8av\x96\r\xc0]\x91F\rE6\x12\xc0"\xa8\xcb\x8d<\xc4\x12\xc0\xea$\xbb\x94\x93|\x00\xc0\xca \xdeV\xd2\xe2\xc4\xbf\x93#Q/\x1d\x15\xac\xbf\r\xcc\x0f\x06)\x83\xdf\xbf\xa1*c\xa4\x8c=\xf1?\xf0\xf2\x9c\xb27~\x00\xc0i\x9f#\xd6\x96D\xd6\xbf\x18\xf0\xa27\x02\x8e\xde\xbf\xd6\xc5\xd8\xc3\xa3.\x02\xc0\x95*G6\x15\xa7\xf5\xbfn\xfa\xe7\xa2P_\xf4\xbf\x1cg\x84\t\xc0\xbf\xf1?\xcb\xf3\xe2~"G\xdf?\xbc`R\xbcd\xb7\xcc?\x8a;uW;\xba\xe2\xbf\xdb\x9b\xf9\x86\xff}\xc2\xbf\xbf/vj\xcfx\x06@\x81\xcax\xd0\xe2\xfb\xd8\xbf\xc3\xd8\xe9\xc3\xfa\xa4\x08\xc0\xc1T\x04\xf0\x1f\x9c\n\xc0\x93\xd4\xc5VF\xbc\x06\xc0\x13\x93\x01\xb7\xe5C\x14\xc0\x94\xd8\xb3\xb3!i\x15\xc0|4\xe5~\xbb\xc8\x19\xc0>+\xe2`\x00o\x1f\xc0\xa6\x1dR\x1dk,\x1c\xc0\x94\x8d\x9b=\xcd\xf6\x18\xc00\x84d\x9a\xd8\xd2\x13\xc0\xa7=l\xa987\x06\xc0ls\xec\xa7\x9a\x86\xea?\x7f\x9d\xb4\x072L\xfe?f\x18\x11%\x9be\xd0?{0Z\x8a\xf9\xb5\xc1\xbf\xbey\x97!\xf7\xff\xe3?\xb2\xee#\xfc.=\xc8?c\x98\xe5\xbf\xf8I\x01\xc0\x7f\x98\x12\x06c\xee\x01\xc0\xf5\xc5\xff\x1b\x03\xa1\xb6\xbf\x8d\x83\x98(P\xed\xe0\xbf\x02\xe5\x13]\xa9d\xe8\xbf\x17\xaa\xda\xc5\xbeh\xc7\xbf\xf1l{\xcc*r\xe3\xbf2d\xdd[\xadc\xef\xbf^%/\xc1r>\xf5?\xf6\xe3\xd8\x9c\x0e\x9d\xe2?,\\v\r\xdb\xa0\x00\xc0.\xad 0\x82\xad\x11\xc0u?8\xcf\xa4\xba\x18\xc0\xe6\xb5\x93\xc3\x01\x14\x18\xc0\x022\x9dC\x11\xc2!\xc0{.\xdb5Iz"\xc0I?\x99\x1e\xde\x16 \xc0J^\xa0\x9e\xd0\xea\x15\xc0_(\xf2\x9b\xf4\x12\x0c\xc0\xca\xc3\x13\xf8o\xfc\xfc\xbf\xad\x04\xea\xab\x9b\x90\xd1?\xc4\\\xbf8\x1a\x80\xe1\xbf\xb1\xa6\xc6Yr\xdf\xb2\xbf\xdbc\x1a\x04\x8b\xf5\xe3?\xdc\x02\xd5\xd2p*\xdb?\xc1\x98>\xc2\x11\xe1\xf8?\x06.\x9b\x92\x18\x90\xe2\xbf\xbd\xf2\xd1m\x10\xab\xe7\xbf\xc9!V\x87`\xd3\xf6\xbfL\xb7\x7f\x1c\xb6\r\xf8\xbf\x8fKT\n\xee/\xf5\xbf$Mj3\x90\xba\xd0?\r\xf7\x02\x13\x18I\x04@\x16\x0e\x93\xa7\xad\xd8\xff?\x9b\xce\nQ\x06#\xf4\xbfP\xd7\xac\',\xc5\xe9\xbf\x03\xb2\xd9R\x86\x85\xfc?k\xdd%\x15\x86\x94\xe0\xbf\xc9\xe5\xb2\xc72\xf3\xfc\xbf\x1ci\x12`\xcfW\x11\xc0\x9e\xae}41\xf7\x14\xc0uG\t\x12\xde^\x1d\xc0e\xbb\xe7\xd7:O\x1c\xc0\xae\xd4\xcc\xfac\xba\x06\xc0\xfc>I\x95=y\x08\xc0q\xe4\xfc M\x86\xef?\xc32\xdb\x96\xfci\xba\xbf\x0f\x1cAkOW\xc5?l\x92\xa8*\xd1\xcc\xd3\xbf\xd9\xf6\x8b\xe6\x89,\xca?%j\x8f^\xeaZ\xc2\xbf\x9f\xcba\xb9z\xf7\xf1?\x94oK\x1a\xbe\x19\xf9\xbfXX\xaaP\xe5\\\xc4\xbf\xe8\x1b\tO\xe5\xe3\xf5\xbf!F\x8crL\xf1\xf0\xbf`\xd3\x19\xcch\xc5\xec?\x0b\xc1\xc3\xd8\x89\xec\xf1\xbf\xf3(E\xb3\x80A\xa7\xbf\xf5\xee\x13\x9d|m\xf4?\xd0F@\xc6r\x86\x05@\xf6:\x05q\xee\x01\xec?\xb4\x93p\xc4B\xf9\xc3\xbf(\xf52\xa4\xdf\x1e\xdc?\xa1\xd8\xc3\x1b\xa2\x12\xb3\xbf\xfd\x80\x06\xcb\xcf\xbf\xd9\xbf\xf2\x8c\x14\x16\xfa\xbb\xf3\xbfv\x17g+\xf6z\xec\xbfF\xbd=\x86}\x14\x14\xc04\xd7\x80k[\x9b\x07\xc0\xaaqT\x81G\x1c\xec\xbf\x82\xf9\xeb\x86#F\xdc?L$\xf8%\x03\xf3\xf8?<.\xa7\xbbB\xd2\xd8?\xb1\x1d\t\xfe1\xd4\xa8?Z\xd1\x8d+\xa3\xe9\xf0?\xe9b\xe7paJ\xf5?\xec\x11,\x01m1\xf6?r\xa9\x8d\xb5\xd7\x92\xfa\xbfgXh?~R\xb8\xbf\x12A\x9d\xd5\xa37\xaa\xbf\x17\xd8W1\xfc\xf4\xe7?t\x9a\x04`\xecX\xf3?\xb5\xbdt\x00\xde\xe5\xe0?\xb6\xdc\xadz=\xaf\xe5?\xa4\xbf\xab\xec\xde\xf3\xf9\xbf\x00U\xcf\xba9B\xee?b\x15\x96\x85\x9c\xbb\xfa?\x9d\xb0\xd0oPR\xf1?\xc9\xd2\xb9\xbf\x96i\xe7\xbf\xbc\x91\xc4\x1bm\x82\x01@\xde\xf4RWk:\xc2?\xac\x85\xf6\x95o\xea\xe9?\x91h\xbb=\xe5\xea\xe4\xbf\x15X\x7f-R\xbb\xed\xbf\x1b\xdf\xa9!\xd2\x17\xf7\xbf\xaf\xcc\x0eRD\x1a\xe0?\xd3\xd1\x9dp_D\xfa?Q\x84{\xfe\xdd\xdd\x03@g\x95q\xf4\xff\xad\xf1?\x16L}\x9b\xa6\x87\xf0?\x91m\xf9\\\xf2\xf3\xd6\xbf62\xd8C\xab\xe1\xf6?]D\xaf\xa3"\xb4\xcb\xbf9"\x0c\xdd\xcfB\xdd?7\x8d\xe1\xe9\xaf\\\xe2\xbf\xf7k\x95"\x07@\xeb?e\xe8\x9f\xca]\x10\xea\xbf\x8e\xec\xbb\xe9\x9aM\xf3\xbf\x95Y\xd9}\xb8\xac\xed\xbf\x99\x16\xe3\x8a\xfd\xfb\xc6?\xc4\xc7\xb3\x95J\x90\x03\xc0G\xdd\x86\x12\x8a\x88\xf2?\x81\xfc\xae\'\xc3E\xe2?\xcb\x80\x06$\xb2\x02\xe8?\xa0qP\x19\x8f&\x03@\xc2%\xbf^\xc9!\xfb?\xe1I\xda\xc7\xba{\xf1?N\xd9L\xd8/l\xf5?%p&\xd6dw\xea\xbfy;\xd8\xd4S\x80\xf0?\xd7^\xf52\xcc\xba\xde?\xc1Tkx\xac\xe2\xee?n\xdaI\x0f\xfb\x08\xe4\xbf\x80\x92\x1b]F\n\xf3?]\x05:-Uz\x01@\xf2u\xcf+\xf6\xb0\x9b\xbf]\x1c`m:\x08\xfa\xbf|\xb9D3\x16y\xe5\xbfvA\\J\xba\x92\xc5\xbf\xe7E)\xc7\x87\xd7\xea\xbfL{\xe1\x99\xf0\x8e\xfa?\xfd\x94On(D\xe9?\x8fF\xcf\xa53\x89\xd3\xbf\x19xN\x9e\xec\x1c\xd7\xbfY\xd5S\xea\xc2y\xba\xbf~\x07\xad\xfa@\x97\xff?]s97\xe2\x8c\x93?l\xeb\xbd\x8cw\xc0\x01@kk\x81\xc6c\x0b\xe8?\x1eV|\xcc?\xe5\xee?\x9d\xe8\x1bC\x16\xd7\xf2?\xe3z\xa6\x99\x15\xf1\xf5?\x8ay,\x19:\xbb\x04@\xb5\xe0\x8aZ\x80\x18\x08@r\x8f\xd6\\~:\x08@\xe5\x1c\x02NP\x91\xdd?eV\xa3\xe5\xb3&\xf3?\x1d\xf3\xad3\xb9;\xf4\xbfe\n\xbcMv\x84\xf5?u\xa7\x8c_\xad\x0b\xf2?y\x9d\xdf\xc1A~\xee?`\xa8*O\xa1$\xcc?\x9cq\xe0\x9dr7\xef\xbfiL\x9fw\xe2\x97\xf4\xbf\xa3K\xdc\x95;X\xd6\xbf\xd3\x93\x15\xbf\x84L\xed\xbf\xf9\xf2\xcb\xdf\x93N\xf7\xbf\x0f\x049\xf6\xe8E\xea\xbf#\xc8\xe1\xc8d0\xd5?\x1b\x94\xfe\xa7\xd9C\xe5?\xd3\xac\x82\x17\xf4\xc3\xff?e\xe2\xa7bW\xe1\xd4?\x00\x85\x7f\x14O\xe3\xe3?1\xfa \xf7}~\xda\xbf\x19O\xa6\xbb\\\xfc\xe7?\x0e\x0c\x92\x07f\xa7\xd6\xbf\x19\x96t\x1eC.\xeb?\x03\xeawi\x84\x8f\xec?\x8a\x9d\xf0f\xf1\x8f\xd5?@|c\xd3\xec\xc5\x00@\xb8\x06\x9a7\xff\xec\xdb?6\xc9_\xce\xb4\x80\xf3?\xdf(\xd8\xf1\x990\xfe?\x10\xd7H\xfbX2\xf8\xbf\xb7\xb9\x91\xd3\x90,\xd6\xbf\xfdr+\xcb\x81\x8a\xd8\xbf\xc4!;g\xd0\x8f\xf8\xbf\x8dJR]\x89\x87\xfe?J\xac\xa708\x8c\x11@\x83\x8cw\x96\xdf:\xfb?fx$\x0c\xe9\xd0\xb3\xbf\xf7\x1e\x89f\xa2\xb3\xf9?&\xe1Z\xff\xcd\xee\xe8\xbf\x98\xado\xa7\x9bk\xe9?-2\xed\x87\x1f\r\xb5\xbf&]\xa5\xc4\xd3\x17\xf8\xbf\x89\x1f\x05\x15\xd8/\x93?|\xc2e\xeeDQ\xfa?*\xc6\x8c\xcc\x16\xe0\xe4?i\x05\xd4\x7f\x04\'\xe7?\x80z\xd6\x1a\xfe\xbd\xd8?L\xf5H\x0b\x18h\xd1?\x8f?gp\x91\xfb\xf5?\xce\x1a\xf7\xf0\x10X\xf5?\xcbP\xc5\n{\x91\xd1?~\x12]\x13\xae\xb2\xfc?\x97^\x88\xb4*\xae\xe8?v3\x02o\xed\xcf\xeb?\x1a\xd6^\xf9\xc3\xe5\xf8?n2|7\x01\x17\x02@$\xe5\xfeL\x88b\xc3?\xad`\x13\x1c+\x10\xee?@\x04\x10\x03\x10\x7f\xe1\xbf\xedq\x8f\x89\x8e(\xdf\xbf\xc0\x817/\x1a\xb3\xdd?\xe7\x12\x05\x0c\xe6\x7f\x07@\x88k\x83\xaf\xbb\x13\xfc?4\x04\x86k\xa1\x16\xea?\xe0\x05\x02\x9d\x8a|\xec\xbf\x84;\x19S)~\x02@\xa8\xa2\xd8-\xd0.\xee\xbf,\xbd\xc1\x19\x97\xb5\xd7?\xc7\xe4\x85\x83!\xc6\xe5\xbf\x08\x84\x82\x9fO\xa4\xc2?\xdd\xf0\xd6\xe3\x8a\x84\xeb\xbf~\\\xda|)\xb1\xd4?\x8d\xa8\xb5\xba\x89\xf9\xd3?\xa8\x12\xcd\x1f\xda\xda\xa8?\xcaj<\xbaj\xe6\xe9?\x8d\xeb\xef\xe7a-\xf0?\xec\xd5\xbb\xb2\x94>\xf6?\xb2p\xdf\x00\xdc\xc7\xca?-V\xfeR\xf3s\xe6\xbf9\xc3\x89\xbbc\xc4\xf4?\xdf\xaa\xd7p\x81\xd0\xd3\xbf`w\xd0O\xf4c\xf0?,\x0fLZ\x1f\xab\x06@\xf3\xb3\x9a\xb2b\x15\xc9?\xba>\x16\xda\xc6B\xed?@\xfb\x0f\xe9c\xad\xb2\xbf@D\'\xaa\xa6\x8e\xf0\xbf\x02[\xa8\xbd,\xec\xf0\xbfd\x8c\x06\x81\x8c\xdb\xd2?=P\xc2\x01\xe2L\xdd?\x88\xbbuA\xc4P\x05@\x8b\xda\x89\x14\x1b\x1c\xcc\xbfGO\x9a#\xadQ\xf1?q{\'B#\x04\xee?\xfa_<\r\xff\xce\xee\xbf\xcd{\xe3\xb1\xb2\xd8\xe9?!\xcd+e\xfc/\xe6?\xd8\xf2\xbb\xa8\x97\xfd\xe8?\x08\xfe[\t\xbf\x1c\xdc\xbf\xce\xde\x89[K\xe2\xf7\xbfkCaiv\xc1\xd5\xbf\x06\xd0\x93\xd2\xf8\x18\xf6\xbf5\x11-\x04\x1c\xca\xf6?%\xb6\xa2\n\x8cA\xd8\xbf s\x95\x91+$\xea?\xd0\xae5\x04\\\xb8\xbf\xbf\xe11\xa9B%\xe8\xb6?\xfcJ\xf8)\xd7\xbf\xc0\xbf{\xd8\xad\x0b\xe1\xbc\xf7\xbf\xcd\xb9\xa1\x1f\x11\xed\xdc?\x06\xeb\xb9\x7f\xefb\xe2?\xb43"\x84rz\xe0?\xc5\x01v\xbeG&\xa0?\xb0\x9f\xe5j]\xbd\xe0?\x11\xa6\x86akR\xc6?mg1\xa0\t\xad\xd7\xbf\xedN\x89\\\x15\xc2\xb4?/z\xba\xa4.J\xfd?d\xcc\x11\xdb\xcb|\xff?#\x14J|Sl\xe0?=1\xa9\xa0\xb7\xda\xf9?aphna\x0b\xc4?\xd9R\xdb\xbdt\x19\xfa?\xe2C`\t3\x06\xec\xbf\xe3\xa1\xb5\x87\xf1\xb5\xdf\xbf\xe7\xbe\x18,c\x8d\xf1\xbf\xb1$<\xae\x06W\xf2\xbf\xf5\x0etSt0\xec?\xeb\x1c\xafi\xe1\xc1\xf1\xbfF=4\xfc\xbe\x88\xe8\xbf\xfc7\xe8\t\x93H\xd8?\xcb\xe3\xd4\x8d\x1b=\xdf\xbfSR\xcaI\xb9H\xf4?!}Q\x19\x18z\xf6?\x8ea.\xdb\xfa6\xef\xbf\x90\xd0"Q\x08\x1f\xe0?\x12N\xa8\x14\xf6\x9e\xfe?$\xb9\x92*\xa7/\xba?\xa7\xb2\x07\x01q!\xf3?\xbe\x97j\'\xeci\xf2?\xaeu+\xe9\xcf\x88\xf2\xbf\xe1\r\xf7\xa1\xe5\x1c\xf5?8O\x850\xe4\x8a\xd4\xbf\xd0@9\x08|\x91\xd4?\xe2F\x84\x88|\xb5\xf6?K,;rp}\xf0?J,\x86\x89vj\x01@\x86\xbc\x97\xee\xb2\x06\x0f@-t\xec\n\xdfq\x94?\x8d\xe5\x821/\xeb\xe1\xbf\xb4\xc0\xcayX\xae\xf5?6\xfc~,\x80\xeb\xf2?\x0e\xa1[\xf8\xc6\xdb\xca?\x12^m\xcf.\xff\xe6\xbf\x03\xdd`\xd5\xdf\x88\xfd\xbf\xb2\x9er\xc7\xf0\xbf\xe7\xbfn\xa48\xfc\xd5\x18\xcf\xbf\xd8V\x10"S\x90\xf0?\x80\xc1\x8b\xf0\xe2\xfd\xb7\xbf\xb4\x07Ep\xb5 \xe7?G\x91\x03\x94)I\xe7\xbf\xe4/\x8b\xfc\xaf \x03@\xc8\xd1\xe9;\t\x95\xf6?\x1e\xa1\xc53\xbc\x88\x9b\xbf\xef\x05+m\x9d\xa8\xf8?lIL\xfd\x05\x89\xe4?\x95\x97fW\x12\xb8\xc5?P:\xd3u\xcc[\xf9?\xec\x9dQ\x85\x8dM\xe4\xbf\xc8B\x0f\x9c\x9eF\xc1\xbf\xa9\xbf\r\x0e"Z\xe0?{\x94\xfc\x96\x13o\xd5?Qy\xa89\t8\xf5\xbf~\x7f\x98\xea\xfaL\xb3\xbf\xd7;Z\x8c\xa3t\x03@l)\xfa\xe3\x10G\xf1?j\x08\xb1\xeb\x82j\xfe?u\xfa\xf8\xb80|\t@\xc1,\x81\xb7\x19Y\xde\xbf\x1e\xd0\xd4\x89\xfc=\xe3\xbfM\xca}#\x8b\xd7\x02\xc0Ew\x1d\x9fy\xf3\xd0\xbfYO\x9d\xd28q\xed\xbf1\x8bZ\xdd\xe8\x9b\xc2\xbf\xc9\x01\x0b\x80\x83\xa9\xd4\xbf\t7I\xa3\x95\xac\xfd\xbf\x9f\x94\x9bZ\x08\xaf\xed\xbf\x89\xa6\x95\xcb\xf5M\xf0\xbfX\x90X\xd2Y\x06\xc3\xbf\x86\x08\xd91\x9e\xf2\xfc?\xdaT\x1c\x19O\x08\xfb\xbf\xa9\xe6\x86\x7f\xd0\t\xf6\xbfg\xffn\x13\xd5\xcb\xe7?&\xe9\xa5q\xb15\xff?\xb77v\x9ez\x18\xea?v\x93\xd5\xda\x06\x95\xd3?\xf0\xd71\x18S\x19\xbc\xbfKUA8\x82D\xfe\xbf"WC\xb9\x0bZ\xf5?\x9f\xae\x93[Q<\xd4\xbf\xa0\x08\xbd\x13|N\xd7\xbf\xdc2\x11\xee\xa0\x12\xc5\xbf\xbe`\xd1\xab\xdf\x15\xdd?\xd2\xf5\xebh\x8dD\xb2?h\xb6s\x11\x0e\xf6\xe5?M\xbd\xd6\x08\xcfn\xfe?\x83\nU\xd1\x02\xb1\xf6?\x16\xf2\xb2\x98\x06`\xec?\xad\xe3{\x82\xd2\xb6\xf6?7\x18\xb6t\xfeo\xdc\xbfe\x8cG\xea\xa1\xf2\xe1\xbfm\x8e\xe7\xc1\x14\xd5\xd8\xbf\xc5\xb3\x08\xd6\xc7\x1b\xe3?\xb6,L/\x9e"\xe8?\xa5\xc4\x0c\x91P\xed\xcf\xbf\x89h\xc0\xd80-\xac\xbf\x1f\x17\x8c\xbc\xe7\xb7\xf3\xbft\xa8\xc5$\xcdX\xfa\xbfRv.\xe8Aw\xfe\xbf\x873\xe8\x9d\xcc/\x10\xc0\x08\xe9\xa4\xa8Z\xb7\xf5\xbf[i&\xd7RD\xf4\xbfR\xd8\xff5\x95@\xe0?\xf7\xfb6<\x8eR\xec\xbf\x1e\x93P\xad\r[\xd7\xbft\xd6\xf2\xd9d\x0f\xae\xbf\x94A\x9a\xe7\xdbU\xd2?\xf9qI>P\x17\xfe\xbf\xf4\xcf\xfa\xbfP$\xfb?\\\x0f\x84\x13\x9fK\xac\xbfF\x19`|\xeb\x97\xe9?_\xc3\xf9\xce|\xd0\xfc?\xc3\xf5w\xc0 \xe7\xed?\x1e\xcc\x99\x94Q\xb4\xee?\xbd;2C\x8b\xd3\xee?I\xa6\x97u\x9ai\xf3\xbf\x0b\xe7Y\x1d^\xb7\xe4?\xbes\xdc`i\x87\xd7\xbf\x10q\xb0l>\x8b\xdc?\xab\xba!)\x8d\x96\xe3?^M\x1e\xb6I\x98\xf0?\x07\xdf\x83\x83\xe4+\xef?\t\x84\xca9\x9b\xad\xdb?\xd3sI@\xc3Q~\xbf\xbe~@4\xefN\xbc?_\xae\\\xbd\x1c\xc2\xe0\xbf\xfbo\x06\xf4\xd5)\xe9?=O\x0b\x87D\xdd\xd9?M\x84\xae\x88$\xe8\xdb?\x1d\x97\xc8\xfew\xc4\xac\xbf\xf2\x94\xae\xfb8}\xb4?\x84\xd2\x14\x86\x98\x08\xd1\xbfD\x14\xc0\xcc\x9c?\xe8?\xe3\xce%\xe5x\x95\xf8\xbf\xf2\xfc\xf2^>\x12\xf3?\xd3\x9a\xb5\x89JR\xed\xbf\xbbTZ\x1a\x88\xc5\xef\xbfg~\xc8\xdf\xfb#\x9e\xbf\xf2\xee\xa8\xf7\x7f\xb3\xf0\xbf\xa1\x91\xb8Z9\xad\xde\xbfJ&n1\xa0\xaf\xde\xbf\xec[\x9b\xda)\x98\xaa?P\x9f\x12u\xf3\xf9\xdf?\x80\x86{\x01\x0fP\xf0?\x08*\xd9\x83%f\xc1\xbf\xd1\xdd4]\x95\xb5\xd5??\x8e2>\xa7r\x9e?\xcf\xf3\xb5b\xbf\x17\xba?\x07\x8a\x05I\xf3$\xc4\xbf\xc1\x02\x9d\xd0\xc69\xc1?\x04\x12\xc3\xdf\x8d\xcb\xf6?\t\xe9\xb8\x88\xf1\xc9\xe6\xbf>\xa0\xc2\xed\x14\xf7\xf5\xbfr\x1e\xb9{\x02\xef\xb9\xbf \x0e\xdc\'\xa0%\xe1?\x9a\xc9\xa5`\xd9/\xe7?\xd7\xecJ\x08\xb6\xc8\xcc?\x9f\xd8s}\xcd\xc5\xfb?\xa6\x7f\x18\xa5A{\xef?o\x0c\xfb\xa2`D\xf6\xbfF`\tp\x92^\xe4?J\t\xa9;\x11\xe2\xf1?\xf9\xb8\xa5d2>\xfa\xbf_\xc0\xee0{\x12\xee?#\x8e\x88\xf4S\x8f\xb2\xbf x\xbb\x00cB\xd4?\xb0\x18lq\xc3z\xfb?\xe2{.\xa4\xb6;\xf1?p\xef\xc6\x19{K\xfa\xbf\x0c\xd06\xa2\xd6Y\xd8?\xf0v\xbb\xc3<:\xd7?:g\xd1\x0b8\xff\x00@z\x83\xda\xc0\x1e\xce\xd6?\xbd2\xfd\xb0\xc6\xc1\xe4?\x16\xe4\xb7\x82k\xc4\xe5\xbf\xaaK$\xb1\xd8\xb5\xd7\xbfj\x92\x8e\x9fJ\xbc\xf1?!v\xc9\x8b?\xaf\xd9?\xc2\xdfv\xe2\x8d\xe6\xc6?!\\E\xe3w^\xf8?\x12V\x15\x05O?\xe0\xbf\xb12\xd9\\7\xa1\xed?\xea\x90%\xc7\x0b\xe6\xa1?i\xaa/\xa7V"\xdd\xbfR\xa0\x1e|\xd2\x1d\xe8\xbf\xb3\xaaeJ\xc0\xf3\x02\xc0g\x18\x1a\xcep*\xd1?N\xb7\x1fe!G\xe0\xbfS\xd9\x87\xf0R\xc4\xec?V\xc4\xdb\xa1\x97\x1d\xd2?Am[/B<\xaa\xbf_RN\xc7\x94X\xda?\xb7\xc5aSAx\xf3\xbf]B$x\x0e\x0f\xf4?b6\x02=VV\x00\xc0\x85\xb1\xfd5\xfb\xb4\xeb?d\xe014<\x8f\xee?\x85L`p\xaf\xf2\xd3?$\xf1\xff\xeb\x1a@\xf0?\x16\x8c\x84op\xd1\xcb\xbfX\xda\xa1\xe4\x9dY\xd9?\x82B\xd0\x12\xcc\x8f\xc8\xbf\xe2\xfc\t_?\x91\xfe\xbf&\x1d\x1fY\x03&\xd8\xbf\x90)\x93~\x10\x19\xe2\xbf\x9c\x11\t\xde\x88B\xba?\xed#\x19\xff\x03S\xdf?N\x10z\xbd\x9e\x99\xf4\xbf\x8a\xf0\xba\xca\xbcp\xca?\x13\x02\xe7\xfe\x9f\x8a\xee\xbf\xb4\x81PK\xa7\xd8\xe9\xbfD,\xfe=\xb9\xfe\xf0\xbf\x84\xc0\x83(rA\x02\xc0\xe5\x04\x19\xcb~\x02\xdf\xbf\x04\xce\x04A\xce\xe9\xd1\xbfP\xa3UQ\xd4\xf9\xe0?8\x0f\x03m"1\xf1\xbf\x18\x88\xdf\xf6\xd2\x8e\xf9\xbf\xd3\x809Bq\x10\xe5\xbf\'}\x07\xef\xc6;\xfe\xbf\xd4Z\x88z\x8a\xc8\xb9\xbfu\xf8Q\xae\xb39\xdc?\xbd\x8b{f\x14\xcb\xef?\xe6\x84\xfc_\xff\xa1\xf5\xbf{=A\x1f\x0b\x1b\xf2?c\xa0\xb1\xb2\xf4\x00\xea\xbf\x90M\x15Z}F\xef?\xe5CW\x9f\xecP\x03@ESP\xd6\xae\n\xeb?\xf7S<.u\xb7\xe4?/\x10\x860U\xa1\xe2\xbf\x9f\x81w\x7f\xd1(\xd1?\x82\xa7\xbd\xc0\xc7\xd3\xd6\xbf\x86\xe4\x88\x15\xde\xec\xe4?r\xd7\xf3\x1c\xcd\xa0\xc7?l\x00O.\xf7?\xe0?\x83p<\xbf\xcbI\xe7?\xfa\xc2\xde\xc2\x90\xba\n\xc0\xf6\x01\xbd\x9f8\x1a\x03\xc0\xae\xf6\xaa\x17&R\xf5\xbfAp9\x00S\x03\xe8?\x8c\xf7+"h\x1f\xcc\xbf\xcf\xdbq\xd5b\xd7\xe8\xbf\x8f\xad\x94\xcfgj\xf6?\r\x9f%\xc3=\x90\xf8?\xf7[\x85%\x84\xea\xff\xbfdoSe1:\x00@\xfa\xa9~\x93c\x96\xe6\xbf\xef\xcf\xb3\xf8\xb5T\xf1\xbf6\xc8\x9f\x9c\tz\x00\xc0\xd8\xc7L\xda\xc2\xd3\xed?\xeb\xbb\xf0\xa71\xec\xb3\xbf\xceK\xde\xbe\x81\xcc\xce?\x05\xb7@g\x9a\xf5\xb0?\xff\x00\xe1\xc9\x8aJ\x06\xc0\xe0[\xd6Q-\xb9\xef\xbfr\\u>\xd6\x1d\x04\xc0wqq\xd9O\xa6\xcd?\x81p\xa5 \x14\x93\x9c\xbf:4\xad\xb3\x95O\xab?\x8b\x1d\xc4\xe6\xe7\xe5\xca\xbfY\x8d\x89\x9a\xe3\x89\xda\xbf\x8b\xf0\xf0\xc70R\xf2\xbfzC\x9bE\xfb\xd1\xf5\xbf\x8d\xdbM8\x90B\xdf\xbf\xf5\xd1\xdd\xb8D\xbe\xf5\xbf\xb6\x03\xa3V\x0e.\x08\xc0\xcdY\xc6\xde\xbf\xe6\xd3)y\x7f<\xe0\xbf\xf9\x11\xe4\xd4!$\xb5?NnM\xe5c\xd9\xf3\xbf\x01\xa2\x08.\x14\xee\xcf?\x12\xe7@D|\xf8\xd6?\xc1io\xdaI!\x04\xc0\xda4\xe9\x19\xae\xb0\xfe\xbf\x95g9\x0c\x03\x17\xfd\xbfE#T\xc1\xeck\x06\xc0\x17\x03\xd4\xdf\xb2\x03\xf4\xbfT\xde\x99\xa0"\x87\x01\xc0EK\xd1\x87\xe0\x14\xfc?\xd4I\xb9\x89\t]\xec?\xf4q&\xbb\tK\xf4?K\xaf\x9d\xe0\xb7\x01\xb8?\xc8\xfezy\x19\xb1\xb1\xbf#\x86\xb0\xed\xe9\x8f\xc5?x8\xdf\xce\xe7n\xe0?9\x82\x84\xf9\xa0\xd5\xcd\xbf\x00\xcd4\xd6I\xc2\xf5?\xf0\x9foI\xc9\x9a\xf7?\xb3Zg>\xc3\xca\x99?\'Q\x0b.qu\xe3\xbf\xb2\xee|\xb4\x9b \xf2?F\x8c\x8f\xfb\xd1\x93\xf8?7\x8cK\x10\x93U\x00\xc0gU\x18\x8e\xe5d\xe2?7\xaf\x12M\x14\x86\xf8?\x14\x93Je\xa4\x1c\xf3?\xfa\x1d\x8c\x94/\xa5\xe3?\xdb}\x1c\xb3\xcaf\xec?\xb3DM\\\xcf\xda\xff?\xe9\xad\x80]J\xac\xc7?(M\xbb8wR\xf3\xbf\x0b\x0c\xe5\xc9\x0e\x9d\x06\xc0\xd4\x1a4t\x8a*\x02\xc0\x81$T\x1dl\x85\x0e\xc0l\xec\xd7\xfdE.\x06\xc0\xee\x18\xa3\x8d\xca7\xf7\xbfa=\xa6\xe3W\x9e\xf9?\xbd\xfeP\xe9\xea\xf9\x00@\xc6!a\x82\x85\xe8\xd5\xbfr\xfbV\x13\xdb\xef\xfa\xbf\xff\xa2\xfd\xde\xd7o\xf3?\xe3<\xa6\x96\x8d\xb2\xd8?7\xd1\x9f\xfa\xf6=\xce?\xca\x1b\xd9\x04is\xe5?\xe8\xcd/6R\xeb\xe6?\xddnfW\x0e\xcd\xf1?\xd7>\xf8=L\xe5\xef\xbf\x89\x00z.H\xed\xf1?\\\xf1eO\xdf\xde\xec\xbf\x1c\xe9\xd03\xd8o\xb7\xbfB\xdbI\xb3\xac4\xca?+u\x85\xc0\x02\xd7\xe3\xbf\xfd\xed\x164\r\xe6\x00@\\\xbdZ\xa9\x19\x96\xb6\xbf\xc2\xdd2y\x16\x84\xf4?\xacH\xb3\xb8\xeb\xcf\xf4\xbf\x98\x05\xe7\x86>F\xe4?\x92\x8f\xda)q\xd9\x01@\xa7\x06|\xa1\xf5\xe2\xc0\xbf\x14\xc7\x8b,\xd3\xa7\x08\xc0\xda\x98\xcb\xfb\xd4\xf6\n\xc09\x11\xa1\x92c\xc4\x06\xc0\xe2\xb8\xb5aF\xbd\xfd\xbf\x91\xda\x7f\xed\xba\xe1\xa9?\xd6\xbcP\xd5\xe3\xc1\xa1?\xa9_\xdfT\xb9\xba\xd6?\xa8\xcad\xaf\xbb\x0e\xed?\xb8\x84\xec\xae\x8dY\xf0\xbf\xfe\xf87\xa9\'\xb1\xe3?\xcd2\x87d\xbd|\xf4\xbf\x11\xf7\x05\x15jO\xd4\xbf\xe3\x0e@\xf0\xadw\xfa\xbf\xf0+\x0c\x97y\x05\xf3\xbf\xc2\xe3\x89\x1e\xf3\xb5\xf3?)yN\xb7\x84\xcc}\xbf\xc8\xcd\x0b\x9d\xec\'\xfd\xbf\xb8w\xd6\x0f\x13MK?&QN6I\xd9\xc6\xbf8Y\x85\xa6\x82\xec\xc4\xbf\xda)\xd5\xbb\xeb\x84\xa9\xbf\x99\xf2w\xdc\x0c\xdb\xe9?\xfb\xaaZG\x0f\x04\xe3\xbf\x14e\xa4M\x10;\xf2?\xa9{\x1aJfc\xe3?\x99\xdf\r\xad*aM\xbfK\x1a\x96u\xf6/\xbf\xbfM\x92E\x83\x895\xc3?J\xd7:c\x92\x1f\x0b\xc0\x08\xc0\xcaw^\r\xe8\xbfb\x01m\xd7\x16/\n\xc0\xe8\x96<\x99\xfd&\xfe\xbf\xe8\xb2n\xcd\x9dl\xfc?-j[\xe6\x84\x9a\xfb?YE\xd0\xb8\xe3\x95\xfb?\x1d\xa1\xd2[5F\xe0?Z}\xda\xd8\xcb\xaf\xf4\xbf\xe9\x9e\xea\x84b\xaf\xe2\xbf\x1bg\x83a\x9bO\xe8\xbf\x05:\xf3\xbfI\xfa\xc0?\x96\xb1\xc5\xf1\x9e\xc1\x03\xc0,\x0b\xbek\x8a\n\xe7\xbf\xaf\x93)\xe8\xe2\x1b\x00\xc0\x9b\x14\xb7\xffx\xbc\xf1?>\xb8b\xee\xdfH\xfe\xbf\xd9\xbf\xa72\xa2\xd5\t@t\xeb\x87\xb1bH\xdd\xbf\xd5\xa7\xda\x80\xf0(\xe5?Jt\xde\xcf\x9cg\xc8?x\xb3Du\xed3\xe5?\xec\x05\x95\xfe\x12\x08\xc4\xbf\x9b0\x80@^\xa0\xe6\xbf\xf2\xde\x03kl)\xd1?\xbf\x89\x00\x7f56\xe2?$pp\xb2\xff\x1b\xf0?\xafp\x0cU\x1d\xea\xe7?\xf3\xc1\x9a\xb4\x13\xc0\xda?\xf8]\xefU\xd9\x8a\xf2\xbfK\xca\x92\xe3\x9f\xfa\xe4\xbf\x1f/kehX\x04\xc0\xe1|\nG\'\x1f\xf4?O=8+@\xfd\xef?\xc1ua\xc3\xb4x\xff?\xa8\xe3\x85\xc1\x99\xef\x02@U\x9f\xb3\x9c\x90\xf3\xe4?\x91\x1f\x7fT\xcd\xde\xf3\xbfb\xb84\xd6O\x15\xb8\xbf}\x13\xa2\x06\xbaz\xc1\xbf\xba\x1c\x8c_\xc8\xc9\xee?\xd83\xea\xdf<9\xe0\xbf_y1\x9c\xe2\xf8\xe0?X\xf3\xdd\x16\xe6\xd3\xfb?h\xc6\xb1\x8b\x15\xa9\xd5\xbf\x8e.T\xe5\x88&\xc9\xbfC\xfb&\x11\xee\x06\xea?m\x1e\xab\x8f\x1d\xcb\xea?$\x90C\x8av\xcc\xbf\xbf\xa4\xea\x9f\xc2Vq\xef?\xc0\x88\xd23\x0f\xee\xe3\xbf#\x17\xf4\xf5\xb7\xae\xe1?\xaf\x9e\xd6E2"\xf1?\xd5/\xb0\xe0Xx\xfd?\x1cj#n\xff`\xd2?B\x15\x8aX7\xae\xf0\xbf\xf4\xbe\xac\x84\xb8\x19\t\xc0w*\xfc~\x10\x15\xf9\xbf\x1b+;>\xb2\xdc\xf2\xbf6`P_\x15f\xa6?\xc3\xdd,\xa4?$\x0e@\xd0\x9d\xe0\x9e\xca\xa4\x03@>\\\xb00z\xcb\xf9?m\xe8\xa6\xccz\xd0\xf2\xbft\x80\x80\xa7\x13\xa7\xfc\xbf\xd1\xbe-v\xb8\xaa\x99?\xea\x8c\xfe\xcc\x92\xe7\xf5?\xd2\x8b-\xf5f\x94\xd1?\x82\x8f+\xcc\xa7\x17\xdc\xbf\xda\xf6f\xc4~&\xef?\x82\xf0\'9\x84\xe1\xe8?\x9c#\x0eO\x84\xf0\xf7\xbfo\x9d8\xf7y3\xce?EKp<\x11\x9e\xd4?\xeff1\x16.\xc5\xf2?*\x8a\xd6\xbe\xebz\xdc\xbf\x81 \xc6\x90\xd6\xfa\xef\xbf\x1dJ\xd0\x92\x8a\xa3\xe3\xbfSp\xa5^\xb3B\xec?Si*nJ*\xd4\xbf\xf9j\xac?\x05)\xf4?\xfc\x9d\xab\x08\x9c5\xe3\xbf TH\xbe@2\xea?)\xa7\xc0&\xcd\x16\xe3\xbfc\xa8k\xd4C\xb1\xe1\xbf&\xb6m\xfa[\x95\xad\xbf\n7\x80Ff\x8c\xbd\xbf=q\x86\xc9\xdd\x9b\xf0?~\xfa+\xdc\xc1E\xdf\xbf\x98\xe7e\xe4\xb8\xd7\xf3?\x9a\x0e\x97\x1c\x18\x01\xe4?\xd1T\xe3\xa5\x8c\xf5\xf3?\x08\x03\x12\x1a\xeb8\xee?G\xc2\x80\'\xc3\xaa\x00\xc0\xda\x03\xb4\x02\xbf-\xef\xbf\xd1\xaa\xaf;S\x0e\xe2?\xa8T\xe1\x00a\\\xf1\xbfb\x8dfB\xfb\x9c\xcd?\xa3H\x06\xc0\xb6h\xdb\xbf\xf1\x88?\xc2\xf5/\xe1\xbf\xe7\xac\x1e\x01)}\xdf?\xc2<\xf8\x9f\xedC\xe5?\ntT^\x0c\x03\xe5\xbf\x83\x97\xbe\xff\xaf\xa2\x03@9{v\xb4O?\xd9\xbfy7\xff\xfe$|\xeb\xbf|c\xd1\x193S\x90\xbf\x85\xeeRQ\xabz\xe5?\xd4\xfb\xa6GDG\xe5\xbfg\x15\xb9R\x04\x8f\x9a\xbf\xc2N\xda~\x81\xbe\xe5\xbf\xe9\xe1\xc7\x1a\xea\x8f\xe0\xbf,\xab4<;\xc5\xbc?\x99+u\xab\xf8\xf9\xf0?*\xf1~\xe41\xbb\xdb?&\xdeW\xbb\x1fz\xf6?\xb4\xf8\x967\x97\x87\xe3?\x91\xaf\xea\x80\x93\xc0\x05@d\x80\xda[\xb5\xdd\xd3\xbf\xa3\xb0\x8c-\x10\x93\x00@f\xe0\x00[\xa1\xb1\x85\xbf\x84\xcf\'n\x1d\x15\xea?8|-\xf8p\xac\xea?\xa6\xc3y\xf8\xdd\xbd\xf5?*\x14\xdc:#\xc7\xdc\xbf:\xb1\xe9\x13\xcf\x14\xf9?v\xecF\x89\'F\xce?)\x84\xa2\x1e\xdf\xb7\xcb?MXD\x91Z\x80\x02\xc0\x08\xe6\t\xe7\x98W\xd3?2\x99-\xb2\x0eA\xcb\xbfl/\xc8\xb0\x7f\xb1\xfe?\xee\xb2\x1b\xd8"\x8e\xe9\xbf\t\x9c\xa9\x89\xb3\xb3\xa1\xbf\xae\x16Y\x82P\xc4\xbe\xbf\xb1\t\xa9\xdcS\xa3\xf4\xbfC@\xd7i6\xda\xea\xbf\xb5\xeb\x03$\xe8H\xf6?\x102\x9b\xaab\xb6\xcf\xbf:\xe1\xa6\x99\xbe\x10\xfc?\x0b\xfa\x03\x1a\x106\xf7?wC\'`\xa5\xa8\xe9\xbf\xcd}Pn;\xf3\xd8\xbf\x97\x1bO\x1f\xf9\xec\xf5\xbf\xfd\x07\xf7&\xb4g\xd8?\xc3d\xd7\xddr\x1f\xf6?\x87\xa0\x11%B\xbd\xff\xbf.A{\xaf+|\xf9\xbfM\x04U\x80*X\xa6\xbf\x87f\xf5p\n\x16\xe9\xbf\xc3\xf4\xde\x05\xa7m\x05\xc09\n\x9d\x9f\x07\x18\xf1\xbf\xdd\x11\xfd\xd3\x08\x12\xa2?\xef\xe1\x04\xf1\xeda\xee\xbf\xfdo\xf1\xa5\xdd!\xf0\xbf.\xb0Z\xc0\xd5\x94\xf8\xbf\xc5T+\xa5\x9dU\xf3\xbf?\xc3\x11\xde\xdd\xaf\xf5\xbf3\xf5\x9e@\x93G\xde\xbf\x10DQ\xa5*b\xe1\xbftg>\x05!\xf6\xc6\xbf\xb1\xaa\x0b\xd4\x0eH\xa1?\xce\x7fd\xaf1+\xbc\xbf<\x19\x85\xc1\x94\xca\xea\xbf\xf8\xb5\xca\x9b\x00&\xf2?\xc9\xdb\xa8x\xa8\xf1\xb1?\x9e\xf7\xe7\x91\'a\xf8\xbf\xdaO\xd00\xa1\xfe\x01@\x90P\xfd\xf3^\xa5\xc0\xbf\r\xc8`\x065\r\xe4?\x1f\x9b\xba\xc4\x93\r\xd2?\xb16gj]\xb3\xfb\xbf5\xd9@\x14\xd8\x8e\xe7?[S\xeb4\xa1\xc6\xc9?\xa4\xf5k;\x81\xd7\xca\xbfL\xc9\x96,V\x1e\x01\xc0\x94\x92\xb1\xf3G\x90\xf1\xbf\xd8\xa9\xb7!\x98\x83\xfa\xbfi\xb5+\xfb\xec\x87\xe8\xbf\x04\x06\xa4~\xceB\x05\xc0\xef\x98\x90zaO\xb8?\xcf\xe6\xe3,\x01^\xe5\xbf{u\xae\xd0F\x03\xd9?\x07[\xd9\xce\x1e\x12\xc5\xbf\xe1\xd6K\xcb\x00}\xe2?\x14\xab\xb2\x88\xf4 \xfb?\xfa\xd7\x07\xb7\x02t\xe6?\x17\n\xac\xe0\x8f\xb2\xf0\xbf}q\xf97\xb4\xd9\xf6\xbf\x87L\xa2<\n\n\xd5?@\x0e\xfe\xa8(\x8f\xe6?\xf8\x1f\xa3\xcd\xec\x05\xf3\xbfU\xc7\xd9\xd1R\xe0\xfa\xbf\r\xa6\x05y4\x1f\x03\xc0\xbbve\xcfJ\x14\xb8\xbfc\xcb\xa9\xbdj6\xe8\xbf\x80~\xa4\x90\x89<\xe1?\xd1\xeaG\x99\x90O\xf3?m\xfb\xe7[\x87\xb0\xed\xbf\xa3\xb5\xba\xc3\xac\x7f\xc2?\x16\xcfG\xddOu\xe7?CJbsM\x86\xbb?\xbb\x8e*_\x9b@\x8e?\xc8\x10\x90\x1a\x0e\xeb\xf3\xbf\xed\xd4\x89D\x14\xb6\xf7\xbf\xd2\xc1\xf2\x80F\xf1\xfd\xbf\x1e[\x01#\xe8\x99\xcf?\xd8\xe1\xe9\x13\x89\xf6\xdf?#^2\xbb{\x81\xd6?\xa4\x16\x9d\xcd\xf5\x0e\xe0\xbfKP\x93?\xb1%\xd4?\xbe\xd7O\x97\\\x1a\xd2\xbf\x91\x8e\x10\x00d\xcd\xa6\xbfS\xa5\xe7i\xbfp\xcb\xbfx\x8eeL\r\xec\xd2\xbf\xf9\xd3\xb3\x8f\xdcJ\xd0\xbf+4\xac\x05\x1e\xe9\xd6?P\xca\xb3!\xae8\xdc\xbfn\xf6A\x19\xdf\n\xf1\xbf\xb0\x8fMQ\x0eh\xe1\xbf\x07\xa7\xb2?\xa2j\x01\xc0F&\x03\x1c\xd6A\xf9\xbf}\xb9^\x02a\x82\xf9\xbf\x05+\x96\x18\xdc\xc1\xe7\xbf\xe1l\xe4\x8a?+\xba?u\x8cc\x8eZ_\x07@\xe0\xc2\x18F\xb46\xf8\xbf\xf0\xdds\x87n\xcf\xf7?\xf9\\\x06.2\xdb\xe0\xbf\xfbCM\x8f\xb4\xb9\xe5\xbf\xea\xfc6\x16\xd0\x9c\xfe\xbf\x16\x9c\x819"\x11\xef\xbf`5\x07Sk%\xf2?:+\xe9:\x94\x8a\xd3\xbf\xe2b\x13\x8eCI\x94?\x12\xa2X\x0b\x05\x8a\xff\xbf\xa4\x1e\xaf\xb8\xee\xc1\xd0?\xe8\xacD9\xfd\xe4\xed?\xbf\xdc\xc26PM\xf8\xbf0\xa6\xc0\xfbzH\xce\xbfA\xdc\xf7#\x0e\x14\xe5\xbf\xe6\x9eA\xe8,-\xe0?\xbf\xf8P2\x17\x89\xce\xbfK\xa9x\xc5ms\xad\xbfQPan!\xfc\xf3\xbf\xa1\x9eG\x9e\xb6\x12\xc2?\xc0\x83dC\x99\x89\xd7\xbf\x81\xc5\'\xe0\x18\x1c\xd9?\xd3}-=\x0bA\xfa\xbf \x19\xf1#y\x9b\xfb\xbf\xa1\x8a\x1a\x8f\xea\xb8\xf6\xbf\x82\xa2\x11\x15\x92\xf4\xf2?\xa9\xcfV\xe6V#\xe8?p\xad\xe4\xfb\xa3\xcc\xf2?_\x1c\xb3\x1c\xaf[\xf0\xbf\xd8W\x91\xc5Z\xfd\xf3\xbf\xcb\xe0\xac\xe8\x175\x05\xc0\xdciN\xcce\xdb\xc7?\xf9\xd5N!\xf9C\xe8?\x8bn\xb4}\xe2+\xe3?#\xb6Y7\xfe\x85\xc8\xbf2I\xf36\x06\x06\xf0\xbf\x0b\x1db\xbfUu\x06\xc0\x15YF:\x16\xc9\xed?w\xc7+\'\xc4\xb4\x01\xc03\x9f\xb5\xfc\x9d\xbe\xe1\xbf\x80V\xdb\x9c\xab\xeb\xd9\xbf^+\xb6\x1b]\xd6\xf1?b\xa6\xecB\xc7\x88\xf3?\x1e\xa6J#:\xc9\xf2?\xe5\xfay3XM\xf7\xbf\x96\xab\xdb/Ei\xe0?\x07R\x19\x90xj\xfa?\xa0\x19BP&\x11\xea?>P\xb0[vv\xe7\xbfO\xf8Yj)1\xf6\xbf\xea"R\xc3s\xbe\xd5\xbf\x82b\xad\xc0\x98_\x07\xc0\x0eD\x02Q@\xf3\x01\xc0R\x10\xed\xf4\xef1\xf5?\x8e\x867\x0c\xee\xf7\xf8?\xc3\t\xea\xc5c8\xe7?\'\xb2\xe4\xedA\x08\xfd\xbf\x88\x14_\\\xa2\xd0\xc5\xbfje\xb5+\xe8\xc1\xeb\xbf\x9fmAP\xd3\x80\xd5\xbf\xbd\x9cB\x01\x17*\xda\xbf\xf6\x8e\xc4\x9e\xcd\xb4\xd7\xbf\x9f\xc3\x90\xa6n@\xf2\xbf\xffQ\xe6\xd8\x95\xd6\xe6\xbf\xban`\x82\xfc\x9e\xf0\xbf\xc2\x15\xeb\xc0\xa7K\xd7\xbf\x98Q\x82\xad\x15\x8f\xc4?\xde\x90\xba\xb1\xf2\xf1\xf8\xbfX?@\xdf\xd1X\xe8?\xcd\xb0J\xe4\xba6\xe9\xbf\xcb\xa9(1\xe3A\xf1?\xc24h\x8d\xa9\xb5\xfa\xbf\xa0\xde\xf0Z\xa3\x95\xee?\x02\xb4\xcb\xcf\xf7\xf8\xd2\xbf\xccE*\x9d\xf3-\xdc?v\x98\xa1\xa6\xe0\x93\xee\xbf+\x91w\xb6\x7f\x8d\xc6\xbfm\xb0\xc2\x84\xf5\xe3\xd9\xbf\xdd\x16\x8et\xa4\xf3\xed\xbfI\xba\xb5b\xf4\x1e\xbf?K=)8\xd4\xc9\xf1\xbf\xf2\x149\xe1\xcb\xec\xde?\x99\xa5I\xb4\x8f\xa8\xe6\xbf\xbc\xf1\xf3\xbfb\xdc\xf1?\xa2\xe4\xe0\x00?\xb6\xfb\xbft\xc6\x17\xech\x05\xff\xbfM\x11-C\xfd\xa5\xe8\xbf]W\x92\x87\x87\xc4\xf4\xbf_\x06\xf0xLE\xf4\xbf9e=\xe20\x8a\xc0\xbf\xf7k\xbc\x80h\xc7\xd5\xbf\xe1E\xcc\xa1\xf1\x98\xd0?\x9d\x07\x8a\x19\xfd\xf2\x03\xc0\x93cI\x05\xbbF\xe6?\t\x99\x82X\xaf\xdd\x91?\x89\xe8\xbbO\xad\xe3\xe2?U\xa4\xf91\x06,\xf2\xbf_\xcf\xb7\xc9\x1fa\xc4?H\xdeK\x10\xee\xac\xd7\xbf\x8d\x1cM\xe3\x89\xf9\xf2?\xf29=\xe6\xd9v\xdd?\xd2\x83\xdc\xf6_\xba\xec\xbfw\xfc\xb0\x8e\x1a\x04\x02@\xae\xa43I\x05\xd9\xe6\xbf\x04\xd1i1~,\xb4\xbf\xd9\xd5\xc2G\xb6\x84\xe0\xbf\xcf\x84$S\xf6\x8a\xe2?1R\x01\x168\x90\xbb?\x7fo(\x0f\x0c\x1e\xd2\xbfe\xfc\xe4%%\x11\xd3?\xcd`\xbe\xe6E\xff\xd5?\xbf\xaa\xca\xca\x13\xcf\xed\xbf\xecUU\x1f:\xf1\xe5\xbf\xd1vII\x17\x0b\xf6\xbf\xbaN\xc2(8\xb7\xf9\xbf\xfc4\x00X=\xf6\xdc?\x9da\x82\xfa\xfb\xb5\xe5\xbf\xe3\x925\x18\x91\xef\xe7\xbf\xdd\x18\x84\xb2\xaf\xc8\xcc\xbfE\xea r\xf5)\xf5\xbf\x84\xe5$\x9ee\xe1\xd6?\x87\x05k\xa1\xd6U\xd4?\x03nU\xc3\x87j\xdd?X\x1cx:\xa6v`\xbf\x8cTm18\\\xcc?\x18\x13t\xe0\xc3\x08\xe5\xbf\x97\xf1R\xe8P\x89\xf1\xbf\x90JMQ\xce\xaa\xe8?\xf1Y\x8b\xc8\x99\xaf\xb5?\xc6\xe5\x1aj\n\x1c\xf3?\xe4\x84\x1c\xeaz\xac\xd8?p\x0e\xa6\x90\xcfV\xe6?\xa7U\x0e\xa1\xd1\xc3\xf4?z{L\xc4\xf8\xf3\xcd\xbf\xa5GU.I\xeb\xdb\xbfa\xfb\x0cm_V\xf0?\x11]N\x8a\x83\x84\xf0\xbf}\xba;\xc3W\xf0\xb2?t\x8d),i\xd7\xf7\xbf\xfb\x10\xcf6y\x85\xeb\xbf\xd9!G\xd1\xf2\xdb\x01\xc0=^J\x96m\xf3\xd6\xbfQ\x0f\x17\xce[\xbd\xf9\xbfT\xfb\xd5\xb4$\xaf\xf8\xbfx\x9e\xbb\x1e\xe7\xf1\xfb\xbf\xe4\xd6\x8c\xd4Bw\xe8\xbfK\x84\x9c\x82\xee\x1c\x00@(\x11\xc70\x83+\xd7?\xfe\xb5\xdd*\x8d\t\xf7\xbf\\\xec\x1b\x08e\x12\xf9\xbf\xfctz\xfe\xf0\x84\x00@~,\x91Q~u\xe9\xbf\xc7t\xd8\xd1\xae$\xe3\xbfl\xe5S}e\x7f\xee\xbf\x85\x19\xebl*\xf5\xf5?\x8c\r\xf5M\xe0\xb8\xca?\xcb:\x99\r\x9by\xf8\xbfH\xd5d\x03ym\xe6?\x14f.j\x17\xd5\x9a\xbfovF\xaf{\xad\xdd?\xf4\xe53\x89\r\x9c\xf3?\x83\x18\xde\xf0a\x1d\xeb\xbf\x00i\x80\x0e\xc4\xdf\xe7?\x18U9\xc2P\xae\xe8\xbf\xea\x9e\xf9\xa0\xbfl\xf5I\xcd\x0b\xcf\xe7\xbf\xfd\xb0U\xb21\x9d\xdd?\xe0\x87L\xdcT\x80\xc2\xbf\xba\x101\x1e\xdd\x83\xeb?d\xa2Q\n\x12\xb7\xf0\xbf\x00\xed\xc4\xa9\xb73\xe6?\x15C\xc2u\xae*\xdf\xbf\x12\xce\x9d<_U\xf0\xbf\x86\x17\xa1#]\r\xf2\xbf\x11H\xa8\x96\x87\xc1\xea?baBC\xa0\xc5\xf3\xbflBi\x8c\xc0q\xd4\xbf\xc6[\x07\xd55\x80\xf0?>\xb2N\xca\xb4w\xe2?\xa7\xbbJ<\xf4\x1b\xfc\xbfK\xc2\xf0?\xde\xad\xfc?\xfc\xfa\x7f?p\xdf\xee\xbf\xa3\xde\xd9\xdc\xd3\xd5\xdc\xbfy\x9a\x00\xe9;\xc0\xec\xbf\x9c\xea\xf9[\xd7\xcf\xd1\xbflf-E\x89g\x00\xc0"\x0c\xd9\xa7\xe0H\xeb\xbf\x1c{\x81f$\x8a\xbd\xbf\xe2WZ]\xbf#\xdc\xbf\x86\xb4\x9am\x89`\xe3?\x00.\xda\xc8r\xa5\x02\xc0\xb5\r\xb7\xe6\x94e\xdb?&\x98\x04Of\x13\xe4\xbf\x81[\x85\xb9\xc2\xf6\xe4?dc\xd1m\x89\x95\xe8?\x00\x11^c\x9a+\xe6?e;\xd4@\xb4\xa4\xca\xbf`@5t\x05\xfd\xf8\xbf\x88\xc0\x97\x8ck\xfb\xcc\xbf\xd1e\xc4\x03\xdd\xab\xf6\xbf\x1fQ\xbaX\x17\xbb\xdb?F\xfcI5Ey\xf9?\xd7\xb6!#\xdcN\xf9?\xb9l=\xca| \xf1\xbf\xb1H\xd95\xfc5\xde?\t\xad\xe9\x19F\x1f\xe7?1\xd6V\xb19M\xf0?\x96\xbb4a\xef\xe1\xfc\xbf\xd4\xf3\xa4q\x04K\xeb\xbf\x1c=\x05\x8a\xdav\xee\xbf\xde\x92U\x01O^\xd9?\x19\x1b\x87\xc4\xeeS\xcd\xbf\x8c\xef\r\xc9\xfd4\xe3\xbf\x89\xd9Ln\xb4\xba\xf2\xbf;*a\x10?U\xe3\xbf\x8ft\x8b\xcb\xf0\xde\xee?l\xc6\x7f\x08\xc4\xcd\xfb\xbf,\x98\x9d:\x88b\xd8?t=\xe9\xa1k\xdb\xe9?\xf7>\xc4\x9c\xbd\xaa\xdc\xbf;\x1d\x9d|]M\xc0\xbf\xa19N\x86!\x88n\xbf\xfd(6a\xeb\xa6\xcc\xbfr\xa2\xefy\x03\x90\xe0?:\x06]\x9e\xed\xcc\xea\xbf\x89\x08\xc8q\xb2\x8c\xf1\xbfiT89Qs\xfd\xbf\xce\x8e\xc1\xc4\xa1\xcd\xb5?\x00\x0fF\x00\xd9\x12\xcc?\xc7$H\x0fU\xc4\xd2?\x05L\x03\xb1\x8c\x9d\xcc?2\xac\xcaJ\x9b\xd0\xdf\xbf\x8cj\xf2s\x91\x15\xe5?p\xcc\x9e\xac$\x9b\xb0?\xa4\xd5\x12\x9d\x11\x13\xe5?W[!c\x00C\xe4\xbf\xfdi\x99\x1a/\xe9\x04@`\x19\x18;"\x05\xf7?\x1b\x19\x93\xa8\xb4\x0c\xe0?\x95\x9e\x10k\x95\n\xca?\xbe\xf5\x9a%\xe0\xe9\xf3\xbf\x8f\xf5\xf1\xda\x88\xdc\xf9?\x04\x89\x9d\xbb\xdb\xb7\xf3?+\xf8A\xf8\x9c\xb4\xb2\xbf\xb5)L\x95\xf9\x1d\xb9\xbf\x10n\x85\t\xb6~\xe5\xbf\x91\x8d\x04\xe87l\xe4\xbf\xb5\xe2\xe7P\xce|\xe6?y\x97)bs\xcf\x83\xbf,yH\x0bX\xca\xd9\xbfj\xd4\xd1 \x88h\xf2\xbf\x96\xecF\xdc\xf5\x88\xf1\xbf^ t\xad\xeb}\xef?m\x00\xe9`5\xd1\xf5?\xa3@d?\x95\xaa\xf6\xbfR\x12 tkf\xff?\x96\x16\xa3\x88\x9c\xfe\xdc\xbf\x11\x90\x12n\xd9\xde\xdd\xbf\xcc\xc8\x11t\x03\x8d\xe7\xbf`\xcb\xe4\xda$_\xb8?\xb0\xc2:\xc3\xfe8\xf6?\x9cWn\xba:_\xe5?\xd5,\xb7\xc7\xb7>\xf1?\xf10\x94K|\xfe\xfa\xbf\xbb\xb0\x9d\xc2\xa4\x92\xe5?\x9b1a\x91\x1d\xa0\xed\xbf\xb1\x80;\xc3mm\xf0\xbf\xeb\xa1\xcf\xd4\x03\x1b\xdf?\xd5\xde\xaeEhs\xe2?\x84\xf5$p\x17\xad\xcd?\xba\xe1\xf6!\x10G\xd3?\x7f\x1f\x08\xc4\xaf\x1d\xd1?\x1aJ;\xcc\x8f\x7f\xe3?A\x9e\xf1\xa3\x11\xeb\xd6?mS\xef\xb8wv\xf6?\xdb\xb7PO\xb7Q\xe7?\xb6\x84\xd4\xe0\xf0\xf9\xfa\xbfr\xc2\xc4\x99.B\x03\xc0&\xd4\x83\x08:\x91\xd9?DS\xc2J\x82\xfa\xfa?\xe875\x9d\x86\x99\x91\xbf\x03F\x81e\x1f\xdf\xe6?\x0b\xa1\xb0\xa9 \x96\xe8?\xfd+rYX\xbc\xed?\x14\xc1\x9f\xc2\xb1\xcb\xf9\xbf\xfa\x15L\xccT;\xfc?\x07\xf6\xcf\x1fi,\xf1?so\xd3\xb8\x8c\x07\xb2\xbf>X\xa1\x973\x84\xca\xbf\xed$\x96\xc9;_\x01\xc0\xd39\xbbo\xb2\xc4\xf0\xbf\xcd\xc0$\xe5r\x85\xe4?2Z|2\xc7\xbb\x01@\x05h\x8b\x89\xf4\xa3\xd0?;\x87w\x06\x9b-\xe6\xbf\x04\x7f,\xa2\xf3\xca\xe1?\x0f\xfb\x04\xa3\xbcN\xec?+\x1c\x1ap7E\xdd\xbfg\x8dl")4\xfa?\xd2\xb8:\xd1\x08\x7f\x00@\xc2\xf9\xfd \xf8*\xeb?\xc2=A\x01O]\xc6?\xb2\xdd\x8a\xc7\x99\xb3\xd5?\xb9\xfa\xb4X\xf5[\xd7\xbfFf\x82\xdfe\x1a\xe8\xbf\x1d\xcc\x01\xa0\x90E\xff\xbf>\xd5\xbe;0B\xf3?\xe6/\x89CL\x1a\xde\xbfW\xb0\x7f\x82\\r\xdf?\xf7\x86\xcbA\xf4\x80\xcc\xbfS\xa9\xef\xcf \xc8\xf4\xbf\x93\xef\xe0H`n\x02\xc0.6\x19$\xbb\x9a\xea\xbf\xfe\\5\xbcf\xe2\xc8?0\xeeP\xe8\xd9h\xb8\xbf\xe0\xab*\xac3\xd2\xf4?Q\xd0\xe2_\x80\xcf\xe1\xbfU1\xc1\xd2\xeeI\xe3?\x85\xe4\xd3\x9d\x95Y\xcd?\x84\xc87\x01`\x93\xf5\xbf\x8a\xdc}D\xbbN\xf0\xbf\'\xa1:\xca\xfaz\xf5\xbf9\x0b\xce\xa7v\x90\xd4\xbf\xe9u\x99\xc8l\x87\xfa\xbf\x8ah\xcf\xfc\x1cU\xd0?U\xdcw\xa1\x97\x08\xd8?\x17K\x0c\xd3c\xa8\xde?\xba\xd4k\xb6\x9f\xfb\xe4?\xad8\xd5\x04M\xd1\xe3?\x89\x9f~(\x82x\xf9?\x82\xf4\xd8\xcd.5\xd9?,{\x1a\xac"\x8d\xe9\xbf^\xf9\x11LD\xff\xeb\xbfw(\xd2\x0f\x87\xfc\xe6?qs\xf1\xff"\xcd\xdd?g\xdf\xca\xb7xU\xfc?\x98\xc2>\x85\xc1\xbf\xe1\xbf\xcc\xf7(\xf9=\x15\xf2?i\x80\xf2\x12\x01\x02\xe6\xbf\xa8\x0eCg>\xbb\xbb?\x14\x951\xde\xaf\xf5\xe6?\x91\xe67}\x12\xa4\x95\xbf\x8f\xed\x89\xd7\xec/\xf7?\xa4\xa4\xe9\x1d\x98r\xca\xbf=T\xbf\xfb\x7f\xc5w\xbf\xac\x17`\xb1?N\xd6\xbf\x8a"\xf4\x05\x10\x02\xfa\xbf\x9c\xfb\xd4\xc0H\xb6\xd0\xbf;\xa2t\x8d\x85A\xa3\xbf\xcf m\x0f\xb61\x8a\xbfSiV\xca\x11\xd6\xd1?\xc7\x0c\xf5\xa5\xce)\xf1\xbf\xc1\x85\xa5\x0e\xe2\x82\xf7\xbf\x99j\xe3I\xed\xb5\xd6\xbf\xca\r-\xd7\x88$\xf2\xbf\x82\xfa\xf6\xe4\x07\x8a\xdf?K\xee\xb5<\x9e\xbb\xf1??\x18e\xa2\x81>\xdc?\x0boM\xb9\xf7\xd9\xe0\xbf\xdc\xa5\xeb\xceQ\x98\xef\xbf!z0\x16\x04\xae\xe8\xbf\x88\x88\x88\xdb\x1a\x06\xf9\xbf\x00-9\xd9\xa0\x84\xff\xbf\x0fg\xcf5=\x81\xf7\xbf\xac\xc1\xda\x9c\x9f]\xf3?\xb4V\x9b-W\xd6\x04\xc0\xea\x12\xcd\xff\xf7~\xbc?\xf2\xc3\xf1^\xce{\xc1?\x8b\xccz\xa4\'\x8d\xf7?\xeb\xd48@~\x02\xe2\xbf\xf5\x84N\x90\xbe*\xf7\xbf\xba\xf5\xd1\t\xc0\x8f\x8f?\x1e\x8f\x10r!I\xe2?"\xf0K\x0e\xfa\xc2\xf2?\\\t$\x8e\xaeb\xae?\xb5\xd4\x1a?\x01\x83\xa9\xbf\xa3\xba\xef]:h\xec?\x82c\xc2N(\xaa\xdc?\x9aN\xb9\x1ch\xd0\xf0\xbf\x138r{k\'\xff?G\xf3\xf0(F\xc1\xf4?\x90\xa0\xfb\\8F\xdc\xbfT\x15\xd3s\re\xd1\xbf\x1d6\x8d\xcf\x07\xb0\xfd\xbf\xd6\xb1\xe9\x85GaF?\x86\xe788L\xf7\xe5\xbf\xfe\x1d-\xe6\xbby\xda?f\x11\xe0\xdd\xad\x9c\xe4?\xdf\xdbT\x1a\xc2\xf1\xdb?\x19l-\xeb\xee)\t@\xa2-E4\xde\xb8\x02@\x08$w\xecj\xba\xd6?/\x92\xa8\xbd\xb4\xfa\xe0?<=\xa6\xed\xb4\xa9\xee\xbfs\'\x816Y\xa6\xe7\xbfzQ:\t\x9e>\xe0\xbf\xa7L\xd6\r\x92O\x07\xc0\r\xfbd\x1b\xe6\xa5\xce?^\xcd\xfc1\xab\x89\xd9\xbf\xb1\xb5\x04P\x1bV\xb2\xbfA\xa4\x17Go\x03\xd5\xbfzo9\x1bU\xea\xe6\xbf\xdf\xd3\xaa\xcd\xce=\xdf\xbfZ\x1e\xab\x96\xe1\x1a\n\xc0/}\xa9\xc4\xe6\xf2\xe4?$P\xafY\xf1 \xea\xbf\xe4w\x14\xf98\xf2\x02@4\xdcr\xaa\xc2\x03\xe1?f\xc6\x0f(I`\xf3\xbf\xfa[::\x05J\xdb?\xa1\xfb6$n\x85\xf1\xbf\xc8%\xe3\xc9\x16\x17\xdc?q\x0c\xc1\'6\x86\xf2\xbf\xa1\x14\xcd\x8eG\xf4\xdf?\\\xbd\x8c\xd2\xc2u\xf6?\x9ei\xd6X\xd7]\xc4?Djv\xad\x16n\xf1\xbf\xf0n\xb4\xc5@\xad\xb0\xbf\x02c\x1b\xba.\x12\xc4?K\xc5f\x81\x83j\xfd\xbfC8\x07\xd32\xa7\xea\xbfu*\xda\xa7Qo\xe5\xbfC2\xb0RdT\xb0\xbf\x9f\xdc*\xb7du\xde?@\xb5q\xecz\xd2\xe6?\x86y\xc8\xce\xec\xe0\xf3\xbf\xc1\xb1WX]\xed\xe2?\n\xd8,\x83@\x04\xf5?\xe8l\xaf\xf4a\x84\xb9\xbf.\x88X%\xac*\xc1\xbf8\xa8\x81\x03\xcd\xd4\xd1\xbf\x04\x96\xe7\xf3z|\xdd?\xff\xa6w\xb3Y\xd8\xf8?\x90\x93\x94\x98H\xa2\xe9?\x993,\x0c\x9c\xed\xcc\xbf\xad\xea\xf9v$\x83\xde?\xb0Q\xec \x12\xd0\xdc\xbfK\x1bG\x96K\x86\xdf\xbf\x1cX\xf2\x80Ka\xee\xbf\x8c\tP2\\r\xd2?\x93\x12\x8b%q~\xed?\xe7Y\x81-os\xc4?\xf99,\xa1@"\xef\xbfE\xe9\xf8\xf1M\xf5\xe1?\x1d\xdb\x18I\xda\xcd\xf8\xbf\x8c\n(\xc5\xf5\x14\xe9\xbfp\xe3F\xa2\xe7\x9d\xd0\xbf\xe45\x95 `\x1c\xe9\xbf\xaa+\tr\xb7\x18\xc9?\xaa\xb7\x84\xd8m\xb7\xe1\xbf\xbf\x80Y=\xd3\x01\xf0\xbf\x01/\rd>e\xd1\xbfK\x18\x13Rk_\xf1?8\xbe\xa0\xba9\xb6\xf9?]vT\xdbw\xe6\xef?Zi\xd7*\xbf\xf1\xe0\xbf\xe1\xac\x18\xfb\xa45\xd4?\xef\xf1%\x98\x15H\xfa?\x1c,-C\xe1\xd6\xdd\xbf\xabv0\x08+Y\xed?{Lvx\xe1;\xfe?\x00\xbd:h\x0e:\xe5?v\xa5\x02y\xf1\x8b\xf8?\x84=\xd4\xeb\xc2\x95\xc9\xbf\xc0\x16\xcbV`\x02\x02\xc0\xa1\xd2\x84\r\x05\x8f\xf2?uu[\x16\xb3z\xf1\xbf\xaa\x95\x14\xb8\xad\x91\xf0\xbf\xe5p\xc8\xe1\xef\xab\xbe\xbf\xb1\xc7\xf2\x05\xb4\x0c\xfb\xbf\xdcU>=\x91\xe8\xf7?\x90y\x10\xc4\x9dL\xe0?O\xcf\x1f\x86\xfcY\xe8?\x98\xe6GN\xc7\xde\xe5?\x10\x1e\xd0\xf9R\x92\xe1\xbfP\xf4\xaf\x8f\xed\x89\xff?\xc3+\x80;\xc7$\xd2\xbf\x81k\xaf\xd0\xd0\xa8\xf1?n\xd5;n\xf6\xd0\xac\xbf,\xb8\xacl\xe9E\xcd\xbf\xfe6H\xc7\x9e\xc7\xf0\xbf$\x84]\x0e\xd5\x92\xe2?k)\xb2\x00P\xa0\xf1\xbf\'\x17)UiQ\xee\xbf\x94C\x9d\x07CG\xe0?\xb6\xf4\xef3;]\xfb\xbf\xde\xbf\xbeE\xa0H\xe7?+\xe4\xd6\xf4\x0f\x8d\xe0?\xa8k\x01\xb3\xa9\xf8\xeb\xbf\xd8c/\xe1\xbb\xe2\xa1\xbf6gjX8\x9e\xf3?\r\xc8\x8c\x8a\x0c\x03\xeb\xbf\x1c\xfe4?\xd6\x07\xe9\xbf\xb2\x18\x03\xbeq\x08\x02\xc0f\xc9\xf9\x84\xd05\xf3\xbf\xb3\x81\xb6\xfb\xc9\xe2\x00\xc0\x9f}\xa9\x82\xae\xac\xd1\xbf\xd8\xe4\xdd\xdd\xc2\xc8\xfd?\x82\x1e\x98\xe2\x04\xc1\xf1\xbf\xa2\xb5J\x8d\x99\xb1\xe5?\x86\xf1\xaf\x96e\xee\x00@\\\xcc\x8e\xd7\xd8b\xf1\xbf\xf0)\x9c!\x17\xfe\xd4\xbf\x97\x92\xab\x0cU6\xb6?\x7fS\x07\xc4\t\'\xb3\xbf\xd7\xb5\xc4\xc5D\x7f\xff\xbf7\xc5F\x85\xb9\xd4\xe8\xbf\xe2\x9eV`y\x07\xea\xbf\x11\xa3B\xfb/\xc5\xde?\xf0\xc2\xc1\xf4\x986\xf9? 8\xa6\x86\xfd\xdf\xea?0\xcda\xe0\x9a\x16\xf2?\xb3\xb2\x10\x80Z\xfd\xe5\xbf\x1b\x87W^\xad\x9c\xe2?\xcc>\x08[\xefq\xb2\xbf\x97x\xf2\xfb\x1c\x02\x00@{\x8b\xc9\xb2\xcf,\xf4?#<\x82\x9c H\xec\xbf\xa12ly\x9c\x9c\x00\xc0\xf1uA\xbe!\x83\xed\xbf\xe3\xd2\xe7\xafIv\xff\xbf\xd3:\xd9\xf1\xbf\x13\x00\xc0k\xaes\xaa\x05\xfa\xfb\xbfB|\xc0\n\x15T\x02\xc0\xd6c1\x1d\xf2\xe1\xe3\xbf\xd2v\xf8w\xd48\xfe\xbf\x80\xa0\x11\x08\xb2\x83\xbc\xbf\x05fS\xb1>C\xe9\xbf\x1a\x15!\xfa\x8a\\\xde\xbf\xed\xf3\xc1\xa7KT\xf2?\x8f\r$/&/\xfc\xbf\xe6llE\x9du\xe4?\xb0k\xc3\xa8\xce\xfd\xf4\xbf\xe1\t#\x8f\xd4\xc6\xeb\xbfN\xb0\xef\x99\xcd\xed\x00\xc0j\'V\xa1\xba\x96\x02\xc0~\x18\xd34\x84\xc8\xf0\xbf\xd7\x8eD6R\r\xe0?,#\xd2\xbc\x8d\xcc\xd2?4Q\xc1\xbd*=\xe5?\xc85\x0cE\xc9:\xa6?\x13\xb7\xbdD+Z\xeb?\x8dk\xfb\x93\xc8\x88\xe9?x\xd1\xd1\xf1`_\xdb?l\xa6\x90\x91=\x1c\xff\xbf\x92By\xca\xe5\xb6\xdf\xbf\xdcB\xf5\x825X\x01\xc0-\xcd\xfcs\xeeK\xe2\xbf\x16\x13\x00\xbbd@\x03\xc0]\xd3\x0c\xe8\x83$\xa8?\xf3\xa3\x81\r\xd9<\xc8\xbf\xbck\x91\xb5^\xe4\xde?h\x96\x01F@\xf2\x01\xc0\x81W/\x83;?\x07\xc0\x9e\xb8\xfd&\xc6(\xfc\xbfB\xf5%\xa0t\xd2\x04\xc0kV\xe5K\x1eq\xe9?\xd2\x81ZG\x9b\x0e\xf4?0}\xc5\x0cT\xc2\xd9?\xea\xce\xd9"\xe6v\xf1\xbfi]\xb6\x9b\xd4.\xc2?\xf3\xba1\xc17Q\xdd?v\x8f4,:c\xe4?$.)\xff\x05\xf4\xea\xbfTZ7`\xc4.\xe2?2yu\x93\xac\xe3\xc1?7\x1e\x00\xca\xec\xfd\xf1?5\xb9d/_5\x03@\xe3\'\xb8\xffr\xe4\xd6\xbf\x8a\x89\xadO\x1b\xb8\xe1?Hi\x95\xbb1p\xc2\xbfG<\x92\x91L\xdc\xe4\xbfm\xd5\x1a}C\xec\xe5?\x19\xddouWj\xac\xbf\x03hq\x80\xac\n\xd5\xbf5\x1aS\xfc<\x06\xbf\xbf\x92\x00Gk\xa5\x14\xe2?\xdby\xd6\x02\x81"\xf9\xbf\x846U\x14\x06\xd2\x02\xc0\x1b\x8a\xed\xe8j^\xed\xbf\xfbuE\xcc\x8do\xdd\xbf\xb5\xed\xbar u\xfa\xbf\xcc\x88\x9f>\xbd\xb2\x10\xc0\xad\xb5\x18;\x8f@\x10\xc0_\x98\xcf\xc9\xf9,\x01\xc0GG\x9d\x8d\xfe\x87\xf7\xbfq\x8a\x1c\x84\rE\xf3\xbfM@\x83\xe7\xd2A\xf6?8\xa3\x01#\x11\xb0\x9d\xbf\xbe\x87\x8f_@\xc1\xe7\xbfc:\xcb\x9e\x11v\xb1\xbf;\xef\xb8@>s\xcc\xbf\xca3n\x0e\x14\xff\xfe?\xac\xfd]\xe0]\xca\xed?\x0c\xc0\x9b\xf7\xe9\x17\xc6?\xcf\xfd\xe6*\xcf\x14\xe8?<\xb5\x9fO\x81\xe8\xfb\xbf%#?v\x876\xdd?\x8a\xd4\'!N\x1f\xd7\xbf\xd7\xdf\xc6\xa2\xfe\xd1\xb0\xbf/E\x0bF=6\xfd?=b\xd6;L\xac\x00@:i\x90\x17\x12\xdc\xb6\xbf/;fv\xf4\xd6\xe5\xbf\xf0*\xd5\x10\x82\xa8\xf3\xbf\xce\x05\x82\xd0\xbc\x8f\xfa?k\xeae\xd5\xc3S\xf7\xbf*({k\xa6\xa0\xf7\xbf8p\xdcaO\x7f\xfe\xbf\x80\xaf\xfcL"\xd6\xe6?;J\xc1\xbaK\xc3\n@\x90\xb1\xbeb\xb0\xc9\x12@j\xbfb\xa5],\xee?7&\xa6A\xc3!\xd8\xbf\x1d&X\r\xe7j\xb1\xbf`\xe69e\x1cM\xdb?\xec\xc8F\xd1\x87.\xbd\xbf\x0b\x15\xd1\x80\xb7\xe1\xf7\xbfV\xfdE\x0f\xb2V\x8d\xbfd\x1d\x0f(\xf2\xab\x00@\xa6\xa1yd\xfd\xe0\x06@G~\xad\x9cc\xe0\xe3\xbfn\x87e\x04v\x99\xf5\xbfs\xeb\xa6n\x8c\xbb\xfc\xbf\x1f\xa6\xe6~\xb9F\xf0?\xbe!F\xc5a\xda\xf1\xbf\xf2t{\x86\x10\xdb\xed?\xea\x1b\xff\xd6y-\xe4?(P=\xcf~\r\xcc?f\xaf\xab\xdfQ\xfa\xc4\xbf\xc5\xbc\x11(w\'\xea?JW9\xfd\x9d\x1e\xdf?\xf0\xdd\x91\xc4\x89\x17\xf7\xbfq\x9c\x0c\n\xab\x8e\x01\xc0\xde{\xb5\x83\xf6\xb0\xe3?w\xf1\x8d\x9d3C\x08@\x88T\xd6e\xdcD\x00@\x016\xcbiX\xdc\x0b@\xaa\xbf:\xf80&#@Oc\xd1\xac\xa81\x12@1\x1a\xd8\xd9\xf9\x95\xa6?\x0e\xe6(\xae\xcd_\xee?[v\xf6t\xf5\xc1\xd5\xbf^\xb4\xc7\x9b\xcc\xe7\xd8?\xc0\xd0\xa8\xe4Z\xbc\x02@!\xcb&\xd69/\xfa?\xbd\xbf\x16\x89\r\xc3\x01@\x9fA\x96\xbd\xe0\xad\x02@Z\xa9\t\xb9~"\xe6?\xac#b\x91sF\x00@\xe6\x00\x17\x8cxU\xfb\xbf\xaaf\xf8\xe1\x00\x05\xf3?\x91\x04\xa4\xe8\x1c\xb4\xbd\xbfcqF\x0f\xdfj\xb9?.\x85,/\xee"\xe6?5z\x19l\xd8\xca\xf6\xbf\xf3\x06U#\xa0\x1e\xd5?\xd5nt_\x07\xcc\xc6\xbf\x03a6:\x10\xf4\xbe\xbf2\x12\xa1\xf4\x92\xe3\xf3?\n8\xe1\x9cM\x9e\xe9?\xbf\xda_\xbb~\x0c\x03@\xf9\x83\xde\xe0yl\xdd?A\xe0\xe3\xda\x13\xaf\x05@\x0c\x83e\xb7\xd07\x12@1\x86{=k\xa9\x1a@\xf7\x14\xf2\xf7\x8c\x91\x1b@\xccx\x93\n\xc4\x9e\xc9\xbf\x15\x88\xae\xe9u\xf0\xf9?8/\x9a\x92\x82\xa0\xf6?h#\xda\x93\xf2\xc8\xdf\xbf!\xa14\x92\x98\xdc\x01@<\xf6\x04Y\xb4\xe2\xef?x/\x9b\xb7oe\x08@e.6\x95\xb1,\xfa?\xef1\xea\xfcG,\xf5?ed\xfc\xfaJ\xce\xdd?9\t\xb6v\xf1\x0c\xc6\xbf9\xc4+\xd2\xcd\x16\x00\xc0\xba\xa3\xd5\xae\xc9\xe5\xdd\xbf<\x86\x03\xc5?\xdc\xf2\xbf:\xf2\x9a\xc4\x99a\xd3\xbf\x84!\xbe\xa0\xdaN\xd0?\xab\xbbG\xec\x11]\xee\xbf7\xf0\xbc\xe8X\xd3\xdd?\xa9\xa8\xe7\xe6\xb0\xd7v?\xe9\xb6\xc9\x0b\x04\x9b\xf2?\xd3ur\xe7\xfa]\x06@\x8c\x10\x99\xfe\xaa\xdd\x10@\n\xe1|\xd5\x98\xed\n@5\x8e\xf5\x91\x7f\x8f\x1a@\xa4\x90i\x96\x03P\x12@}\'\xe7V\xca\x03\x14@Y\'\xd0\xc7\xe4\x94\x10@:1\xc4c\xf4\xc5\x08@\x17\xf1&\xb3\x1c\xd8\xbd\xbf\xb8\xae1G\x85\xc0\xfd?\x13\x16\xc0j+\xbe\xd1?\x96*\xcb\x08o\xf6\xcc\xbf\x9f\xc0*\x80k\xe5\xd2?=\xa4\xa6\xeep;\xf9\xbfi\x1f<\x1d \x89\xf5\xbf\xd4\nu\x06\xc8\x83\xf4?\xcc\xd2\x1b\xdaS\x10\xd8\xbfw\xb4\xcf\xab$m\xe1?\xbf\xeb:l\xb2\x00\xd6\xbf\xe9\xb6\xa6\xba\xda\x95\xf8\xbf\xb7\x01\xfc}\xee\x89\xc9?4\xcf\x16\xc7\x11\x0e\xeb\xbf?\xdbmb\xc41\xe3?\xae\xe9LY\x1c`\xbd\xbfI\xe0[\xc2g[\xf1\xbfvS\x03{\xc7R\xc6?G\x0e\xa1\x0e\x8b\xd4\x00@\x90F\xcd\xe5+e\x05@\xecoQ\xb8K$\x07@\x0b\xbacB~\xce\x01@\xc5\x9f\xcbF\x02\x93\x1a@\xa5\xdc\xcart\xdb\x16@\xccn*\xffZ%\t@\xcf\xed\xb8VG\xd0\x01@\xd0\x81\x86j\x18\xf8\xc0?\xe3\xb6\xce7\xc8\x8a\xf3\xbfj\xf4\xceh\xc2U\xdc\xbf\x8e\xebE\xb5J\\\xf8\xbfw\xb5\xbem\xc0\x07\xfc?Wmy\x96C!\xf9\xbf\xe9Z?\xfb~Z\xe4\xbf\xe1\x8f\xab\'\x13C\xf0\xbf\xac9\xa8\xbejR\xf4\xbf\x1f\xaeK\xf1\xcd7\xf1\xbfaH!{\x9f\xfb\xa1?#a\xc1%i\x1c\xd1?<\xdf\x11\xdei \xd7\xbf\xf3(p~\x0b+\xe2?v9\x15\xee@\x0c\xe2?\xec\x0e\x1c\xc0\x8d\xff\xfa?[\xc5`\x01\x86a\xf0\xbf\x95\xb79!\x89H\xfa?s~\xf1\xe2B`\x03\xc0\xb7\xe9wF\x19\xff\xf2?\x8bp\xfc\xb83\xe8\xf7?\xcf\xce(C\xb2\xdb\x0f@\x1d\xf4-\x15\x08\xcb\x06@\xafs\xff\xcc\xbcW\x01@V\x87\x03\xfb\xa3\xa4\x0f@\x8e\xad\xebv[\xd2\xfe?\xd5\x97\xb9\x0f\x95\x96\xc1\xbf\xb6H\xa8\xd9y\x1d\xd3?\xd7\x92\xa1\xaaO\x0c\xda\xbf\x005K\xda{\x8d\xd6\xbf&~\x1e\xfd\x9e\x0e\xe7\xbf\xed\xceK\xb9\x08\xb2\xd7\xbf\xb6\x00h\x9a\x93\x14\xfb\xbf\\-hq\xc7\x12_\xbf\xdc$\x03)\x9a\x1d\xf7\xbf\x98\xe4F_.W\xe9\xbf\xe9-:<\xa2\x1a\xf0\xbf\xb6\xd4\xe7\xe0\xae\x9b\xf3\xbf\xfb\xbaG\xd3\xc97s?\x82\xaeu#\x0f_\xe2?ob\x02\xe8\x02|\x02\xc0S\xc1h3"\xd4\xdf?\xdf\xe5U\x93`\x89\xf0\xbf{\x96\xdd\xe5\x00\xad\xf8\xbfvH\xe8;\xa9p\xe1\xbf\r\xd8\xe8@\x8d\x06\xd4\xbf?\xd9\xf9\'7^\xe3?\x10r\xc2./S\xb5\xbf\xbf3\x98\xb0\xbf\x8f\xfc?\xc5\x8e\x90\x85\xa7\x06\x14@"X\x8bn\xcc\r\x05@\xe2X#a\xef\xe8\x01@\x02\x92\x9fzg\xea\xe2?,\x8a{:a\xc7\xfa\xbfE\xcak~\xe53\xeb\xbf\xfd|\xdb\x18Gs\xd2?M\xa7\x10\x12\x80\xab\xd4?w\xef\xbdw\xd7\xe1\xd8\xbf\xd3\xdb.v&)\xf1?\xa5i\xf8\xd9\x04\xe8\xf3\xbf\xca\xd7\xfa\xbdH\x0e\xdf\xbf\xd4\xb5\xd1\xdc\xc1)\xe6\xbf\x1a\xbf2}YY\xe8\xbfm\xc8P\xbf\xaf\xb1\xe8\xbf\xd9f\x84\x8e\xc4\x8d\xf3\xbf\xdc2\xc8%\xedA\xeb\xbf*\x80\xaa\xf6\xa2\x9e\xe0?/\n\xd6{\xd3v\xd2\xbf+\xae\x01\xc1\x99\xe4\xf7\xbf\xfd\xf0Ww8(\xfb\xbf\x8b\x05V5\xf7X\xee?7M\\\x8ah\'\xca\xbf\x04\xfdN\xb1(D\xf7\xbf\xc5c\xcc\xa2\x1f\x91\xe9\xbf\xde\x04a~K\xec\xd9?\x1e\x9bY\x18I\xc1\xd5?+\x84\x8f[\xb4#\xfc?I\xb2\xc3\xa9\xfcP\x00@\xc9\xa3\x12\xd9\x94\xcd\x05@u\xf7\x04\xca\x88)\xd4?r\x89\xbaRl\x9d\x06@\x0b\xa7\xff;gC\xbf?\x02;8\xc3\xbc\xd5\xf3?9\xa9\xbb\r\xce\x8c\xf0?\x08.}\xed\x0by\xf8\xbfa\x8e\xb4\x1c\x84\xd0\xe4\xbfc\xd2\xbe\xc5T\xd7\xb9\xbfe\x08\xd42\x82\xa7\xf0?1\xdd\xc3\xdf`\xc0\xe7?\xd18K\xcc,\xf7\xfd?xf\xfcq\xee\x8b\xf4?t\xe9\x9d\x1c\xbd\xdd\xe7?\xf5~E\x93\x84\x1d\xe0?y\xa7\x99g\xe02\xf2?\x95.\x1e\xbfd\xd3\xde?\x94]\xe5\x81C\xd9\x03\xc0\xcb\x89\x05\xf39C\xf4\xbf\xd0\x05\x85\x9f\xca9\xec?\xf2\x9ez\x0c\xa0j\xe6?\xb3\x9c\x05f\xaa\x99\xe6\xbfwa\x1e]~\xbc\xcf\xbf!\x9cJ\xf3\xa4\x08\x01\xc0\xa6\x88!7z\x8d\x04@\xe6\\\xad\xda\xa8$\xef?@+\xbd\x86\x1b\xb2\xc1?%\xcbTc\xc7\x06\xfb?n\xc2\x99~\x91\x01\xc3\xbf\xce}\xb2\xf3\xe3K\x04@\t@\xab\xd5~e\xeb?[U\xb0=\xab\xbd\xfb\xbfY\xd4hqZ\xec\xf9\xbfl\x9eq>\xe9*\xf2\xbfI\xc5c\tX\xf7\xc3\xbf\xd4\xc6z\xa9ja\xf9\xbf9\x8e<\n"\x8f\xec\xbf}-U\x171\x92\xd5?\xd31+\x9d>\x13\xe7?o\x98\x9cJ\xe8\xcf\xf9?\x84\xb5\x02u\x96\x15\x05@\xc6p.\xd7\'t\x07@J\x9e|\xa3$\x18\xf3?\x01\xb2\xa6\xfb6\xa1\xee?\x8e\xce\xbb\x0f\xd2%\xc7\xbfw\x86\xb9\xbd,J\xd6?\xdd)\x93\x01\x96\xdf\x02\xc0t\xad\xdd\xdb\x00\x9b\xe9?EN?~\xea\xd4\xc9\xbf\x02\xd9\x17\xa0\xb4\xf3\xef?o+\x1c \xfe\x9c\xfd\xbf\xa0\xdez\x0b\xe7\xbd\xfb\xbf\xe7/\xe6F\xeb+\xee\xbf@\x17\x9d:\xe9[\xf4\xbfJ\xed\xc2\xea\xac\xf4\xf8?\\\xd6\x14A\xb8C\xd2\xbf\xf9}\x92\x18P5\xe4?\xac\xfd0J\xcd\x1d\xdd\xbf\xb6\x18\xf6*\x18$\xda?\xc8bj\x7f&\x00\xe8\xbf\xc6\x88\xfc\x0e\xc8V\xe0\xbf\xde\xa5*\x9d\xcb^\x05\xc0\xd1\xf4\xb6\x8bw&\xf8\xbf\xd9\x02\xd0\xd9\xc9\x06\xf3\xbfp\x0e\x1e\x1c\x83\x9d\xec\xbf\x0f\x95H\x062\xd5\xc4?\xb2|\xc5q\x87\xe8\xce\xbff\xae\xe8r\xf5\x1a\xf0?k\xdf\x90\x7f\x9a\x10\xf5?4\xda\xa2\x10\xbf\xe1\xfd?\xc5\x88\x02\xfc\xcfC\xf3?d\xc8\xaa\xac\xce\xbc\xd1\xbf\xe1\xe4\x0e\xfd\xaf<\xf2?\x9d\x1cIo\x97\xf4\xd7\xbf\xe9\xceNhx\x16\xd3\xbf\xf5\xbc\xc4\xe3\x87\x8d\xf3?\xc6\xe9\xf8\x19\x03\xb9\xf4\xbf\x89\x9b!\x1d\xfd\x92\xd0\xbf\x8b-\xae\x19J\xb4\x00\xc06\x8b\xf2\xe44\xcb\xea\xbf\xcb\xe8\xce\x90\xf1\xc9\xee\xbfW\xcc\xf6t\xa0\xf2\xe8?\x82\xbc\x8du\x1d\xd4\xe4\xbf\xcf\x11\x9c\x94WR\xf7\xbf*\x18\xbc`>]\xc2\xbfV\x13\x01x\xbcL\xda?\xbe\xaa\xdc\x1f\x10\x08\xd7\xbf\x8b\x1f0&]\x83\xfe\xbf\xd5L\xe6\xf0F^\xcb\xbf\xa2!\x1c\xb3p\x81\xf6\xbf\xcf\x81H&\xb4\xc2\xe7\xbf\xbeE\xb7\x81V\xa8\xf7\xbfq\x86n-S\xa1\xf2\xbfK\x12\x7f&\xdd\r\xb6?z\xd8\xf1\x02\xd4\xef\xe0\xbf\x0e\x1d8\x9e\x03\x80\xbd?\x86\x1bc\xa2\xb2\xf0\xd3\xbfT\xc8\x83\x08pA\xe5?\xa9\x92\xf3\xb0\xfc&\xfd?\xdd\x80q\xc5\xd0\xe2\xd1\xbf\xd1\x93\x9b#\xb0P\xee?a\x10\x8e\x15\xa4-\xdf\xbfU\xf0\x03\xab~q\xc5\xbf\xe0\xcb\xa2\xec\xbe\xe1\xeb?R\x8a\x8c\xbb\xc0\x9f\xdc?\'\xce\xfcQ\x03\xb6\xdd\xbf\x84\x81$\xb3\x0e\x7f\xf2?\xd0\x08\t\xcec\x1a\xfd\xbf\xaa\x8e\xcf\x15\x15\x13\xee?\xc3z7\xf7\xe83\xd1?~\x87\x9b\x992n\\?w\x02ZE\xb9J\xf8\xbfO\x86R\xbe6D\x03@\xabz\x80\x91\xcf\xd7\xd6?\xa7\xf7\xa50~@\xf7\xbf\x1f\xc5\xfe\\\xc3:\xf1\xbf%\xe6\xc11n\x97\xf2\xbf\xeb@\x18\xbb\tj\xd9?C\x96Bj\xd2s\x05\xc0g\xc5\xce3r\xd4\xe5?8\x9b\xc9\x87i<\xca?\xc17\x13\xae\x9b\xfb\xf5\xbf\xf5\xa7\x15\xa1\xc5>\xf3\xbf\x8d\xed\t-v\xb9\x02@\x1f\xb8\x03\xc0\xfe\xb3\xc1\x04j\xb9\xbb?\xe2\r\xa7I\\\xc9\xc7?\x96n<\xc5hi\xb1\xbf\\\xe8\x81[\xde@\xfc\xbf\x94\xe1\xcb\xe4\xa2H\xe1?\x13\xb0\xfd\x16HU\xd8\xbf\xd0\xad\x88h\x81A\xec\xbf\xc9I\xacnX\x08\xdd\xbf\x98a\x8e\xd3\xaa\xcd\x06\xc0\'\x81\xb5\xb1Y\'\xd3\xbf\xb5\x93\xf7\x10\xe1k\xe0?1l\x97\xae]C\xff?t\x06U\xbfG\x9a\xd9\xbfJs[G\x0e\xf8\xdb\xbf\x81\xa2\xd2\xeb=\x0b\xf0\xbf\xfa\x01\x1c\xad\xf4\xeb\xf2?\xe1\x05|\xb7\xfa\x96\xe1?\x1f\x01{\x1c\xcc\xd1\xfa\xbf\x92X\\3,\x9d\x8a\xbf7\xb6S\xe2\xe4\xf1\xf6\xbf\xbd\xc2\x1bf\xca\xcf\xf2\xbf\xa0\x93Q\xb0\xd4\xb6\xe9?|<\xa5=\x87\xdb\xfc\xbf1F\xac\xe4\xf1\xf7\xe6?\n\x99y\x0c2\x1a\xe4\xbf{\xee\xb1\xe73S\xa0?\xaa\x04f\xcc\xea\xa7\xe0\xbfF>/W\x9e\xb3\xf9\xbfvZ\x0e6-1\xe2\xbf\xc1\xf6`P5\x82\xe8\xbf\x94\xc6\xb8\xbfm\xab\xdc\xbf\x01J\xea\xeb%\xe0\xd8\xbf\xce\xfb\xc3\x13m\xaf\xea?l\x8c\x11\x994i\xee\xbf\xaf\xb8\xd6\xf8\x01X\xe4?ah,\xe6W\x83\xe3?\xccA;rd\xfb\xf1?\x11P\x9f\x06\xa0\xbf\x01\xc0\xa3\xe1\xbe\r\xa0\xb9\xa2\xbf\xf6\x88>,o\x96\xc6?\xec\xed\x0egEA\n@Wf\xef\x93\x1c\xe9\xe4?\xb3J\xeb\xc092\x00@Jv\x86\x0f^n\xda\xbf\xf1C\xa0\xcd\xd8\xf4\xf7?^\xacz\xecp\x84\xfa\xbf\x86\x02\xf7l\xc5\xcb\xe6?#\x9ea\xb2\x9bY\xf1?iJ\xf4\xd5V\x9b\xec\xbf\x13\xb3r%\x07\xbc\xe1?\xffF.\xcf\x037\x96?l\xd3\x14\xcf\xb5\xcf?+\\k\xb5\xaf\xc2\xf5\xbf\x0cl\xeb\x1bIw\xf8?Z\xec\xa6zR\xccY\xbf\xe3Qn\x01\xb2~\xbc\xbfo\x0b<\x11.L\xd4?\x80\x17t\xd6\x91\xdf\xcb\xbf\xc19%\xa7@ \xdb?FUO\xfdm>\xda\xbf\xb8\xd2\x89\xaf\xf9\x1f\xed\xbf\x8d\xe3\x9c\x88\x86\x05\x00@\x16\xf6f\x9eI\xa8\x00\xc0c\xb2\x0c\xf7\x1d\xf0\x01@\xd6\xee\xd95)E\xf2\xbfr\x1e\nztZ\xa6\xbfk:\xb0^\xd5>\xe9?.\x0c\xbd\x87\xcc*\xf8?v\x12DF\xec\xf5\xdc?\xc0\xb0b+\x8f\xee\xd5?n\xb6\x06Ra\xd1\xfb\xbf\x96\xcb\xd0W\x1f\xe0\xe1?\xb3\xf7\xed\xb5\x92\xbf\x93\xbf4\xfc\xd3&\x9d\x0f\xe2\xbf\x80-\x12\xe7\x8eJ\xe0?\xa8\xdd\xae\x81\x80<\xe7?\xd4L)\xa2\xa0x\xc7?t8\xce\xf9w&\xe3?:\xf1\x14<\x8a\x16\xdf?\n\xfe\xaa\xf77\xf8\xe3?\x7f\xe3\x1d\xed\xc2q\xf4\xbf\x1c\x01\xa4\xc9=\xc2\xd9?)$$\x83}\xc5\xac\xbf\x0f\x90Q\xac\xe3\xf6\xd9?\xc3\xa2\xa2\xb1\x9e\xae\xcd\xbf\xe0\x19\xb3\xe50\x1a\xf8?\x17\x86@\x14\xf6k\xff\xbf\xaeOM\xa1\x97\xdf\xed??u\xe8\xe8!\x19\xc8?_\xd0,\x8bV\x94\xcb\xbf\x17\x0b\x806\xc1\x88\xd4?\xfb\xf1&\x83|\xda\xfe\xbf\xcc\xe5\xc3\x11\xb2\n\xb2?4X\x08\xb0\xb9\x91\xbb?\xe3\xb4r\x8b\n\x8e\xe1?\xc1\xad\xc5o\xef\x1d\xd9?\xc5\x065;5\xf8\xcd?\xad\xbddr\xdd.\xf1?\xb3\x89I\xe1\x86O\xd7?-6Z\xa8\xc2\x08\xeb\xbf\xcb\x93o\t\xf1\xab\xd7?\xf2\xd3\x83\xbe\xc0 \xdb\xbf"\x85J\xd9\x90\xea\xda\xbf\x16J\xc6f"\x1b\xfc\xbfS@\xdb\xd2\x162\xee?\xc4<\xdf%\xb6\xc7\xb4\xbf' +S'd\xd4\x17\xc3\xfc\xfe\xe8?\x9f\x17\xe8\xbe\xdeB\xf7?"i\x15`\xfbh\xc7\xbfQ\n\x92\x9a\xc1\xb6\xee\xbf\xd7\xa1\xd8p\xe8\x06\xe4?\x92\x9d\xa70X\xcf\xf1\xbf\x00V\xb7]\\\x1b\xc0?\xd5$n\x16\x0e\x17\xff?\xf9\xa6\xb8\xfcE\xab\xfb?8\xfe\xac\x98\x0b\x02\xd0?\tz\xa8!\xe8e\xdd\xbf\xea\xd1\x95$\xd0J\xa3?b\xe2\xaf\x11\xb7\xa1\xef?\xaa\x0c\x9d\xc0\x8d.\xad?\xc1\xa9\x8e\x07V\xe7\x01@\xde]\x81\xbc^\xec\xfd\xbf<\xdc\x9f\xde\xfc|\xf0\xbf\xe7\xe2\xf4\xb3\x18F\xdd?\xd7\x96\t\xd4\x07\xad\xd0?\xf3\xb9\r\xff\xef\xfb\xc4\xbf\x9c\x11k\xfd\x0cO\xbf?<\x120\xdb;\xcf\xb5\xbf\x1c\x81\x8bgxb\xfb?L\rhr`\x84\xe8?\t\xe27A\x19\x9e\xe3?\x18\x8e=>o"\xd7?\xd2\xc2iB\xdd\x08\xe8?(\x04W\xf8\xaa\x16\xcc\xbf\xf3\xbe\xe9+\xb1\x99\xae?\xe9\xbf\x98L\xc4N\x03\xc0\xb8\x9eQ\x9a[\x8a\xc7\xbf\xa4\xd1\x02\x06\xd3\xad\xe2?i[X\xa0\x8c\r\xe3?V\x84\x08(\xff\x83\xec\xbf^j\xc1\x87``\xd5?\xba\xb1\x02\xbe\x8f\xa9\xe5?\x1eB\xe74=D\xf0\xbfN\x8f{j\xed\xac\xe5?(>)\x1a\x85o\xee\xbf\x8fvr[\x06\xc4\xd3?\x9eQ\xb3!\xd2c\xf3?\x8a\xc9\xc4\xc2W\xa1\xfe\xbf6v\xb2\x1e.W\xf2\xbf\xe7\x90\xbc\x1d\rh\x00@\xb3\xec)\x9c`O\xfd?\xaf \x80#\xf1\xc6\xeb?\xf18y\x19\xbfj\xe2\xbf\xec0\xe7w\xd7\xf5\xd5\xbf\x95a\n#A\xe8\xf5\xbf\x05,C\x14\x85\xd2\xac\xbf\x9b\x03y\xfd\\E\xa1\xbf\xf1Qn\xfb\xbe\x04\xab?\x87\\\xe2ak\x07\xe5?\xabp\xee\x96\xfa\xe8\xbfW\xfd\xefJB\x08\xdc?L"X\xafqa\xc1\xbf\xbf\xc5@\x00Q\xf9\xf1\xbfv\xe6\xb1SlS\xfa\xbf\x96\xf7\xff\xe6u\xbb\xb2\xbf\xdbgyG\xce\x08\xc0?\xeb-\xd06\xd1h\xd2\xbfXw%e\x19\x1b\xe6?[\x9d[\xfe\xa7L\xe3\xbfhT\xd7\x11\xc8N\xf0\xbf\x02\xbb\xa5\xc8\x8b,\xf0\xbf3\xa4F\xda\xd7\x9f\xb0\xbf\xc7\x0e\x01Q\x89!\xe2\xbf\xed\xa7\xba\xfcx4\xf5?\xdb\x11\xd4\xc4\xa5\xd2\xef\xbf\xc0\x03\x02\xf9x\x19\xea\xbfX*\t\x89\xe8f\xf1\xbf\x8b\x89\xf9F\xdfT\x85?\xe0\x04\xf8$\xbf\xf7\xd8\xbf\xdb\xd5\xda\x1aH\x99\xc1?M\x8d\xa3_\x94U\xee\xbf\x1f\xdfw\xb6\xae\xa9\xe2?\x1f8\xec\xfc*\x19\xf1\xbfv\xdc\x17\xf4^\xd7\xee?\x06\xb8$\x91\x04\xc1\xd7\xbf"`:\xdd\xf5\xb9\xc9?7\xe5n\xd6\x8a8\xe1?\x92"\xf8\xa8\x98\x13\xee\xbf\xfe\xb6Su\xbdy\xf0\xbf\x81\xd4>VTY\xd5?.R\xdb\xc6\x8ab\xf1\xbf\xa2Z\x19\xcam-\xd2?\x18!\x1f\xa9:\xc1\xd9?\xa1l\x98+\x83_\xec\xbf\xae\xfe\x1c\x07\xe9\xe4\xc3?\xff\xe4\xb7O\xaf\x97\xf3?6\x848x\xe2\xe3\xec\xbf\xa4\xe3\xa0i\xd8\xd8\xcb\xbf{\x94\x90\xa2%\xa0\xee?\x08U`B\xf5\xa4\xd8\xbf=\xae]N\xd6&\xcd\xbf\xd0lu\xbc\xca%\xd7\xbf\xaeKt\x8f\r\xd3\xf7\xbf*\xb5\xc3V\xdb\xa9\xf6\xbf}<\x02\xc1\xfc\xe1\xc5?C\x18\xe0\x83a\xec\xc6\xbf\x88g\xea\x9d\x1e8\xeb?c>U\x83\xfb\x04\xfc\xbf\x1f\xd8l\x9a\xfe\x17\xbc\xbf\'\xe9\xb6\x1e\xdf\x00\xc9?;\xd5\x8f\xebu\x96\xf2\xbf!\xda\xf6\x8c\x0e\x01\xf1?\xc2\xf4\x80\x84o\x93\xd5\xbfF\xc9\x1c\xa1\xee2\xeb?\xb0Ks$\xd0\x87\xe0?^\x00N\x10\xad\xba\xe1\xbfn~\x90B\xe4O\xf5\xbfY\x9eLL\n\x98\xeb?*\xfe\xe9\xd5\xe1A\xf5\xbf\x15\x8d\x95\xb3\xeb}\xc7\xbf1\x96c\xeb\xf6i\xea\xbf\x1f3\xbc*\\\xaa\xca\xbf\xfb\xc9\x8e\x85\xbb\xf0\xdf?\x96\xeea\xad\xec\xa5\xe2?\xfc\xa04\xde,qu\xbf\x11\xed.__F\xd4\xbf\xa4M>\xe8\xdf\x01\xf3\xbf\x9e\xfe\xc7c)\xe1\xea?\xf3\x1cj$\xe3\x7f\xc0\xbf\xdaLE\x897\x8f\xf5?\xb8\xb4\x05\xcc\x8b#\xe1?\x10\xc3[\x05!\x1d\x00\xc0\xc5\x0b8\xaa\xff\xdc\x07\xc0\x7f \xf1\x97\x10\x01\x07\xc0\x9db2\x9a\xce \xfd\xbf\xfb\x03\x1a\x06[\xc6\xe7\xbfN\xc3\xb4\x91\xd6\xdb\xe3\xbf_\xca\xd1\xa6q\x9f\xd2\xbf\xd3\x8fA]\x00V\xe1\xbf|\xd8\x858\x81;\xf7\xbf\xb3\xbfX2\xd8,\xd6\xbf\x9cH\xbc\x93\xd2\xcd\xe4\xbf\x1c\x07\xf1\x8fN3\xf5\xbf\xd8&S\x9c\xa8j\xe8\xbf\xe8;v"\xcc\x9c\xe7?\x03\t\x97\xec\xfd\xf4\xd8?6Q\xc3P+\xce\xf1?\x82QsGC\x94\xfc\xbf\xc9\xab@\xca>}\xfb?P\xee\x08\xfb\x06\xe5\xe1\xbf\xb2\xba\x10\xdc\xa1b\xcc?\x0cX\x15\xc5\xd2 \xf2\xbf\xe1P\xfc\xc9\x13\x94\x07\xc0\xf5\x81C\xeb?\xc4\xd8\xbf\xda\xffz\xb4\xcd\x0e\xe6?\xfa\xd9\xacxO?\xc4\xbf\xc7\x18j\xa9\xe8]\xe3?\xb8\x9d\x0b\xfd\xb9\x05\xf4?\x88\x18%IL\xeb\xb6?\xd7jN\x14\xf2\x93\xf2\xbf/\x9a|\x93\x1b\xbd\xf4\xbf\x8e\xbel\xf77\xab\x10\xc0\xc8d\xf7E\xbbA\xf1\xbf @F\xc3^\xbf\xe3\xbf\x99\xdf\xebr\x9c&\xe8\xbfi\xf0\x97\xf8\xa9\xe1\xfb\xbf\xed\xa6V\xff[\t\xcf\xbf\xb40\xa5\xf5\xbbv\xee\xbf\x17\xb4\x080\xf8Y\xf1\xbf\xf4\xc9\xad\xfa\xe75\xdf?\xde{\xdf\x02vS\xf2\xbfY\xfe~\x86\x94\x00\xfe\xbf\xc6\xfc\xcc\xfc\xe6\x83\xf8\xbf\xc7\x87\x90\xff\xc66\xe2?\xad/j\x19\xf7>\xc1\xbf\xf7\xa0\x84\xf2sf\xef\xbf\xe5lpO}6\xd9\xbf\xd4g\xdf\x83\xd8K\xf1\xbf%Qi\xe6\x85c\xdc\xbfo\xe9\xaa\xa4c7\xf5\xbf\x81\xedb\x86\x0bu\xed\xbfF\xa9%\x1f\xfeE\xe0\xbf\xbdK\xb4W\xcb\xf4\x08@\xb5H\x86-\xe81\x03@\x8bp\x8bb\xd8\xd2\r@r\xe6\x85\x93\xfc\xc4\x15@\x1b\x93usi\xbe\x18@\xe5\xa1\xe7\xa5cd\x13@\x97B\xfaa\xec\xeb\r@BgiB\x90\xe7\x0f@\xe0#\xe7qGP\x06@\xdb\xa1 \x13\x8f\x1b\x03@\xc4\xafa\xa7G\xe5\xcb?\xd9\xb1\xd0l\x1d\x19\xc2\xbf\x87v\x82\xbe\x82\xcc\x0b\xc05\xe4\xbfk6\x89\x00\xc0\xed\xb9\xb0\x1dx\xd8\xf0\xbf\xfc\x15\xeaTO\xc8\xe4\xbf\xfbn60PD\xed\xbf\xa3\xdf\x83\xe1\xec\x83\xc5?)\xc9\xd87\x03y\xe3\xbfV\x8cx6LT\xee?\x91\x15c\xc3\x04$\xed?\xad\xa2e\xcc\xdf&\xe4?\x16\xcd\xb1\xa92l\xf2\xbf\xb0\x1a\xe3\xdb\xce\xbd\x07\xc0\x8a\xfd\x8c\xe0\x18\xce\xfc\xbf/\xc7m\xec\n\xe8\xf3\xbf7\xb9\x02\xaa\xd4\xe4\xb1?<\xad\xb5\xa6\xeb\x89\x06@\xe9\xb3D\x04\xc5%\x02@\x80x\xc2\t\xc8\xb1\x10@h\x1d\x9c\x12\xfe\x0e\x14@O\r\x8a\x9b@\xda\x0f@p\xec\x83F\xdb\x19\x1a@9\xcf\xc6y\xebg\x13@\xb0V_WrF @RF\xb8\xb9YI\x14@x}\x8b4M\xb1\x11@\x94E\xefs\t\xbb\xe0?\xc4]\xe1/\xcf\xe9\x07@\xb8j\x02Fd\xfd\x08@\xb3\xf0\x8e\xe9\xd1\r\x03\xc06g%\xaf\xb9\xf7\x02\xc0)Q\xf8^\x1dZ\t\xc0=\xb2\xbd*\xe7\x94\xe0\xbf\xc9\x90\x85\xe4\xa2|\x8b\xbf\x8dG$\xf1\xd2&\xf4?\xc7W}\xb0!\xba\xef? h\xd0\x97\xa1\x1a\xd7?O\xa0\x182\x82\x12\xe0?WuJm.\x90\xf7\xbf\xb8\xa6\xbfl\x1b\x85\x95\xbf\x8d>%+\x1fh\xd4\xbf\xdd\xc5\x91\xc2g\x19\xed\xbf\xbf\xa9\x10\xbf\x17[\xce\xbf\x9b\x1f\xeb\xeb \x91\xdb?\x96\xd7\x8b\xce\xd9E\xda?\xde:\x1b{\x9e\xf6\xf4?T\xb0\xf6\xe3-/\x0f@\xc8\xa3\xd9\x9d\xd4I\x14@\xcf\xcf\xa2i\xc4z\x17@\x86N\x0f\xb5\xe8\x14\x1d@\xff\xc2\xbd\xb9a\xd6\x15@\xd7\xd9z\x88\xa8\xc1\x19@\xe1b\xf2\xdd\x01\xc0\x0e@\x90\xa0//\x1a\xdc\x01@\xa83\x9b\x1b9\xc7\xf6?\xca\n`\xe7\xae\x94\xb4?\x9d\x8cj\x8e\xdd\xb3\xf0\xbfOm3\x1da\xb4\xb6\xbf\xe8H\x95\xae`\xc4\xf2\xbf\xfa\xc1Y\x8c\x91\xa0\x02\xc0K\xbe\xd9\xf61\x14\xb1\xbf\x98Q\x93\xaf\xcb^\xd2?\xbd\xa4Y\x0bm+\xe0?\xd1E\xd6tG\xa0\xf0\xbf\x95:eBN=\xe1?aW\x87\x83\r\n\xf9?:\x90A\xe0I\x10\xe8?f|\xea\xab\xe7\x19\xf3\xbf\x88\xc6\x95\x8bp9\x03\xc0D@\x9b\xc0O\x06\xf8?\x88\xa7xX\xac\xa6\xf6?I~a\xf2\x1f\xf7\x0b@\x83,\xcer\x9d\xb5\xfb?\xa3h\xd4\xe9Q\x8c\t@\x98\x07\xa8\x10\x1f\xfb\x05@\xeabA\x1aJ\xe1\x08@E\x1d\x07\xfd\xa0\x9d\x13@\xbf\x94P\xe0N\n!@.!\x87}\xfb\xde\x1f@b\x88O\x81T=\xfd?\x9c\x97\xf4\xdf\x8e\xe5\xf0?\xa2\xe5Sy\xec\xb0\xca\xbfis]B\xdc\x18\xf6?\xd6\xdb\xaf\x1b\x95\xfe\xf2?[O=fA#\xf4\xbf9\xb6\xf1{\xd9\x7f\xfa\xbfYY\x0e=\x83\xf8\xe9\xbf\xe8\x82V\x95\xf5\x8e\xf2\xbf\xed\xba\x81{vC\xf4\xbf\xc8\\\xf9\x01\nF\xed?\xf1Kw\xfb\xb1U\xfb?\x8a\'\xd0\xd1\xeb!\xeb?e.N\xc4/\x1e\xe3\xbf\x03\xa8\\\xb9%1\xd8\xbf\x11\x0b=+\xb2\x1b\xef?\xc7\xd36o\xde\xd6\xf8\xbf\xff\x1e3<\xee8\xe6?\xbb\xf1c\xdfPm\x01@\xa3\x91i\xec~~\xed?\x8e\x05\xb1$\x9b:\xd2\xbf\xbc\x02\x93\xc9pF\xec\xbfi\xb3\xa1\x17\x0c\xef\xfa?1\xadi-\x02\xe6\xc7?\x08\x9a\x0f\x80\xeb\x9a\xc6\xbf\x7f\x9dE\xd4-\xce\x11@\xa0\xfa\xdb\x7f\x1a\xc3\x1b@z"\xce\xf9w\xd7\xf7?\xd1\x02{\nA\xba\xfc\xbf\xc4\xcc\x0e(;\xe7\xfe\xbf\xcb\xedh`~\x85\xcc?J\x8b:\xce\x82\xed\xfa\xbf\xf7\xb3\xa2\xae\xf8\xbc\xdb?\x08[C\xb8}\xdf\x04@\xa3b#\xae\x13v\xde\xbfW\xf5\x80\x93\xbew\xfc\xbf\xb8\x9a\xff\xb5P\xb6\xdf\xbf<\x1e\x99\x92\x8e\xdd\xd9\xbfG\x92(E]$\xdb\xbf\x9e\x0e\xd3\x8b]\xda\xf2\xbfnq9P\x7f\x82\xf4?H\xbe\xef\xff\x86I\xcc\xbf\xb0\xeb\x96\x08\xb3\xca\x00\xc0k\xd2\xd6\xe2B\x81\xd3\xbf\r\xe4m\x93\xf9\x08\xed?U\xaa\x87\x8a\x1b\xb2\x02@\xc3\x1c\xbd\xa8q\x8c\x04@\x15\xbe\x8e\x0b\n#\xf0?p\xabd\x17\x17\xa8\xf3?%J\x81\x0f\xf0\x0e\x07\xc0\x8d`i\x9c)S\xf8\xbf\xa9s2\x88\x89\x9e\xfb\xbf\xe4e\xbe\xa0\x8cC\x03\xc0\xe1@sn\xb57\xf5?Wz\xc4\xe4\x02\xbd\xf7?\x8d\xaf\xf4E\xf3p\xe7\xbf\x848\x84\xccV \xfa\xbf\xcc`\x80\xb7\xa3^\x05@\xcd[`U\xb2\x8b\xfd?\x17\xc2\xd4\x1f\xd6\xad\x03@\x7fj\x00 o \x11@\xa8\x1f\x19\xdd\xe0\xf0\r@\xfc\xa8\x86\x94\xee_\x07@\xe1\x00sUc\xda\xe1?l\xf3\xd4\xef\xb5\xa0\xe1?+\xc0\xfeI\xa3\x08\xff?\x8b\xc4\x13\xcfa7\xd7\xbf|>\xbb\xf4\xf1T\xe3?\xd2\x08\x8c51\xf6\xe5?`\x88\xeeq\xb4\x93\xb6\xbf\xd9\x1b2X\xc96\x01@ \x9f#\xe4l+\xf2?\x88\xc56\xc0\x89\xb9\x05@0\x028\xdf\x0b>\xfd?ve\x08\xe0:\xbd\xef?\xb8\xc9\x0eG\xc1\x9b\xe2\xbf\xf3r\x85_\xa3\xf8\xcb\xbf\xc0\x87\xe8\xe3\xaa\x97\xdc\xbf\xeb)\xe3\xd8\xf9X\x04\xc0\xb1\x83L\x85Zj\x12\xc0d\x05Vs\x1d\xb3\x1c\xc0\x9a\x8a{\x8d%"\x15\xc0\x03\xa1i\xd5\xf8~\x02@ r\x99\x0b\xeb?\xee\xbf\xfc_\x19\x94\x076\x01\xc0i\x8aYu\x16\x19\x14@\x12\x1cL\x16\xd9m\t@\xf2\x1d\xc7\xf5\x93\x83\xfe?\xde\xc3\x14D\x17\r\xfd?i\x10\xc2\x1d=\x05\xf3?\x83=\xe2\x11\x8f8\xf3?zn\xf8\xd2V\xa1\x00@\x01p{\xf0\xe3\x85\xd5\xbftjpC\xa4c\xeb\xbf\xa1\xbbq\'\xe3\xd9\xd7\xbf\x06O\xb0p\x8c\xce\x95?\xb4\xa7L\x96\xf7\xe2\xe2?,g8\xb7}\xc8\xda\xbf\x1b5\xb7\xf1\x98Q\xeb?\xd1\xe5\x8c\xd2\xa7\x02\xe0?\x03\x7fks{&\xf8?\x03\xc8\xb4\xdf\xaa\x1c\xe5\xbf\xac\xd8=\xed\x9d.\xf5\xbf>3pn\xbe\xd3\x8d?W\x97\x1b\xc9\xc6+\xf1\xbfCY\xaa\xdf\x88\x8b\x05\xc0\x03jXRv\xff\x0f\xc0\x1a\x93\rPxG\x14\xc0\xbfI\xe9e,\xd0\x14\xc0\xe9<%\x9e\'\\\xca\xbf\xabIF\xf7\xb0\xca\x11@[o\x0c\x92\xab\x02\xe0\xbf^\xdd\xc4\xb3\xf0\x13\xf4\xbf\xba\xbe\xe6\xc0\x93m\xe5\xbfl5\x93\\)-\xff?@\xba\xac\xc6\xe3\xcc\xd2?\xc3q\xbe\xe6\x08\x94\xf9?\xb4\xe5\xe1\xed\xba\xbb\xe2\xbf\xcb\xdd\x0fZ@\xb0\x03\xc0\xe3P\xae\xf6\xba\x1e\xf2\xbf\x17\xe1\xcb\xd43\xbd\xf4\xbf\x95\xdb\xc3\xb7\xb3\xaf\xf3\xbfg\xec\x8db<\xf1\xca\xbf\xba\xad.Cf]\xa5?y\xed\xbb)\xb2\x0c\xf9?\x87\xc6\x97\x07\x05~\xf0\xbf\xbd0\xa8R\x89\x1d\xda?#g\xe3\x02\x9a\r\xed\xbfk\x107\xc2\xa0W\xf1\xbfr%/\xee\x8c_\xd4\xbfw\xdaY\xe2\x1a7\xde\xbf\x8d<\xb2\xfeH\xb5\xed\xbfk\xf0\x12\x80\x8b\xc1\x06\xc0\xb2\x10\xd8;\x98 \x13\xc0\xcb_\xf7\x84~\x89\xf1\xbf\xcc\x81\xb9YHI\r\xc0\xab\xa1\xc8\xe0\x01\xec\x04\xc0\xca\xa3Gm\xc1\xec\xfd\xbfM\xed\x7f\xa3\x0e7\x08@J6\xab\x98W\xc2\xe1?\x9a\\>\xa8\xaa\xc6\x05\xc0\xcf\xf3r\x18\xf4\x18\x01\xc0\x92\xf4\x15\xac)g\x02\xc0.\x9a\x89N\xc3\x05X?Ao\xe9s\xd6{\xf7\xbf\xb9A\x1c\xcdi\xc9\xf0\xbf\xa2\x04\x1a\xd7\xdd8\xe9?J\x88\x9d\xa42\xbe\t\xc0\xf8e\xa9\xb2\x81a\xfd\xbf#y\x15\x90O\x1c\xda?\x8a\xf7\x17\x1bBq\xdc?\x94\x80\x8cV5\x05\xe9?\xf4u\x0c\x84\xbb\xda\xf1?LKdt\xe5\x9b\xeb\xbfSe\xedTI\x9c\xf2\xbf\x08\x97\xf7\xb7#\xc7\xf2\xbf\x02\xc2#29\x99\xea\xbfj\xfbf\x87\xa1\x00\xec\xbf\xd9\xd1\xe5\xebI\xeb\xca\xbf\x9d\xb5\xda|<\xea\x07\xc0\x19qS\xdb\x11S\x12\xc0\xd7\xad\x12\xc6\xa6\xa2\x04\xc08\xa7\nV\xceS\xfe\xbf\xf2N\x91\x87\x9b,\x04\xc0\xfb\xc4\xbdD\xe2\x1f\x07\xc0d\xdb\xb6\xbdV0\xf9\xbfi\x8c\x05\xdd\xcc\x92\x10\xc0G\x16\x8d\xc2\xb9\x8f\xd0?\xce\x92\xa0\xc1Y\xbe\n\xc0\xd7RU\xa1\xcf\xc8\xfa\xbf\xff\x92\x85a\x86<\xce\xbf\xffN\xf0\x8b\x02\xde\x08\xc0\x1a\xcc\x11\xdb\t\xf9\xd7?l\x15p\xe0\xbe\xb2\x00\xc0\xb5i\xeb\xc2\xc2\xba\t\xc0\x1e\xa5T\x0f<\x15\t\xc0&7%\x07\xf30\x05\xc0\xa1\x96\x1cmo\x1e\xd1\xbfx\xce\xf3X\x8a\xd2\xf1?\xc0\xe9]\xe71\xe7\xe0?\xf3\xf4\xbe\xacm\x19\xf6?\x8f3v\x15\xcan\xe2\xbf\xc0\xd2K\x8c{\xb1\xef\xbf;\xd3\x81\xaf\x1f\xf2\xb6\xbf\xde\x95`*=\x03\xfc\xbf}]\xe8\xb9T[\xf4\xbf\xd9\x97\xe3\xbbN8\xfd\xbf\xa4(\xfa\x85$L\xf5\xbf\x7f\xf4Li\x8c,\x00\xc0\xd1\xcbl\xdb\x18|\xca\xbf\xe9{\xa5\xbb\x04\xac\xf6?\xb8\xe3\xb6v\x99G\xec?sG\xcct\x1d<\xdf?\x84]\xf6o\x02\xb8\x0f\xc0\\\xbcE\xd7\xeaW\x13\xc0\xed\xef\x15\xde\x8f\xf7\x19\xc0{\xcaO9\xa1\x10\n\xc063\xf6m\x1c\xd6\x01\xc0\x9a\xe1\xf1\x0b\x05+\x05\xc0d\xe7\x18\xbd\x1d\xf5\x03\xc0F\x987\x92&\x89\x05\xc0\x81.\xe3\x8a?\x13\x10\xc0\xed\x0c\x08y\xf9k\r\xc0&|>\x02\xef\x89\x06\xc0\xc0\xa2\x01\xe0^\n\t\xc0X}n9\xdd\xa9\x00\xc03\xf4\xc5\x9f]Y\xe0\xbf\x0f\xd9\\j\xdf.w?\x82\x15\xdaRw[\xe4?f\xe7\xa7\xbe\x91\x95\xd0\xbfG\xd7bY >\xec?\x7fz\xe4#\xf4C\xe5\xbf\tba\x91\xcb=\xf5\xbf\xb0\x05\xddQo \xf3\xbfw\xe4\xbf>Gg\x9c\xdf\x91\xe1?\xd4\x10f\x15\xb5)\xe2\xbfy\xae~\xd0\x92\xf2\xf1\xbfT\x07fC\xcf\xbe\xe6?ro\xfb\xa3\\\x16\xfc?\xf7\xe4\xab\xc2,\xf3\xc0\xbf\xa4W\xe8\xf0\xca\xc2\xd1\xbf\x81\xd97\x92\x06C\xf3\xbf\xef\\\xdd\xc3\xdd-\xf3\xbfXgR\xbfk[\xf3?V\xe8\xe7\xc3j\xb9\x05@\'\xd3P~`\x1c\xf1\xbf\x16\x92\x11{q\x0c\xf0\xbf\xb9/\xf6\xben\xe7\xe9\xbf\xfb5\x8d\x7f\xc8/\xf9\xbf7\xcchD\xbb2\xe9?\x8a\x94&\r\x8c\x8a\xd6\xbf\x9d\xdc\xcf\xbd\xb9\x13\xf5\xbf\x18\x8fE\x8f9G\xd6\xbf\xb9\xcb\x9b0\xd4\xcc\xf9\xbf@;\xb9\x1a \x03\xf8\xbf\xdd\xc2\x1a\xd0\x00\xe7\xe2\xbfy\xc7\xdd\xcaA\xb8\xe6\xbf\xc2\xf8\x8d\x182\xed\x00\xc0c\xcd\xe1\x9d$\xd2\xf5?Dx\x0b\xf8\x1aV\xee?\xbe\x8d\x0b\x7f\xdd\xc2\xe8\xbf\x00\x0c2h\xdd\xa8\xdc?\xbd\xdf4\x7f$\xfe\xf4?\xa9\xd2\x7fM\xc3#\xf7\xbf\xfb+\xda\xcf\xe5\xe1\xe8?\x0fV38\xee\xd6\xde\xbfs\xd4\x13\xbex|\x00\xc0P2\x85W\xde\xa2\xfe\xbf\xdc\xfd\xab\x7f$\x80\xfb\xbf\xf5p\xb0l\xf4\x04\xe5?\xc0,gRtt\xdc\xbf\xb0O\xc7\x02\xea\x88\xf7?@\x7f\xe8\xbf\xd1\x95\x04@$\xaa\xe7\xe1\x85\xec\xfa?/\xbb[\xa8!\\\xdb\xbf\xbd\x95\x97U\xc9q\xff\xbf\x93\xcb$;SF\xe2\xbf:\xbdl/\xdb\x0e\xef\xbf\xfe\x89_\x83]z\x98?\xd9\x8a/7\x12>\xa6?\xc3\xab/\xde\xc8\x05\xe3\xe5\xbf\xd2<\xf0\xff\x94W\xe0\xbfC\x93\x0b\xe9\xfe[\xee?"?)_;\xab\xe1?\x1d]\xbc\x08\x00\xa6\xfa?t\xdb\xe8\xb9\xf1<\xfb?\x91m+:C\x04\xea?\x94\x9cw\xbe\xca\xde\xfe?\xa4\x10\xc0\xa6\xc3e\xa4?\x08-\x9f\x96L"\xdd?\x0f\x03\x15\t\x80\x8d\xf4?Pd\xe3\x9f\x06\xbb\xd5\xbf^\x99\x08nTB\xdb\xbfoS\xd5\x8b\xda\xb5\xf8\xbf\x1c\xba\x89x=E\xfe\xbf%6\r\x16\x03\x88\x02\xc0\xd9\xcdHH\xc53\xc2?J\xe4b\xab\x9dB\xd7\xbf\xa7\xf0\xe6\x8f(\x0f\xf9?l\xe4\xa3\xec\x01\x07\x07@y\xb1X \x0c\xdc\xce?\xd2\t\x0f)\x05\x82\xce?"\xfb\xfe\xef\xbd\x00\xf3?\xc80Wk\xe7b\xc5\xbf\xf9\x86I\x98\xfb)\xf3\xbf\'\x8a#5\x00f\xe5?\xf1\xa4\xbc6@\x14\xe6\xbf\x04H\x98\xa5j\x16\xe7?Po67K?\xe7?\xd4\x11\xb82\xdb\x12\xe6\xbfd\xa6Ga\x009\xe7\xbf\xda\xbd\xf0gJ\x0e\xeb?\xa6\xdb\x16?\xcb[\xfe?\xdc\xd0\xceA\xc4_\x0e@\xf1\x9a\xac\x19\x84Y\x06@\x15\x8a\xe3\xee\x1e\xa7\xe8?\xa1\xc0\xf8\x88[\x1c\x05@\xb3\x97\x91\x82|\xfd\xec?\x10\x8f\xcd\xf7d[\x05@\x1cj\xc1\xc4\xcf\xc8\xd3?& \x1e\x10\xb4\xc7\xe9\xbf\xf6Y Z>\x16\xe7?\xc8(0\xd8\xf9\x8c\xd3\xbf\xd6\xcf\x12n\x9d(\xc8?\x1d\x01\x87\x83\xd0\x9d\xea?\x1c\xac\x9d\xd5\x936\xe6?\x8a\x18\xac\x9c\xd1t\x02@^\xfc\xd6\x1b\xe4\xf5\xb4?\xafj\xe2R\xaf\xf0\xba\xbf\xb1:\x9f#OL\xac?\x02\x17\xdc\x13\xb2q\xec?\x00\xaa\xb4\xd2d\xd1\xf1\xbf\x8dN6\x82\xe3\xfe\xcb\xbfy\xaf\xc2\x1f\xae\xd2\xdb?!\xf6\xb7\xdf^\xb3\xef\xbfXc\xff\xc8&\x1b\xf0\xbf\xbd}\xb9\xb0\xa5\x05\xb6\xbf\xc1\xcd\xc1\'\x92A\xe9\xbfT?\x95\xd3\x8a\x82\xf2?Cs\xdb-bB\x03@P\x13\x83\r\x86\xaa\x04@\x8d\x97SF\xb6\xc1\x14@S\xc0qH&I\x10@\xdcC$\x11[/\x0b@\x8e\xf6\xf5\x96\x11\xdf\x00@\x98\x01Y\x8e\xff\x91\n@\xfd\x91,a\x97\xc1\x04@e\x9c\xfc\t\xc5\x95\x04@\xcd\x0e\xe4c\x7f\x1b\xef?\xd9\x17\x9b\x15\x17\xc2\x02@\x1ei\x90\x0bi\'\xfc?A\xfep[\xfa\x95\x15@t\xda\xb3\xb6\x11\x99\x05@\xe3 l\xed\xb9\x8b\x06@{\x88\x8e\x99\xc07\xfe?\x12T\xea\x01\x1c\xdd\xf8?\xc5\xfb\xc5\x12&\x88\xf5?;t\xd1E\xccD\xf6?\xcdbn \xae\xfe\xd3\xbf\xc5\x8e\xa8U\x90\xc3\xe0\xbf00y\xe2\x1e\x98\xca\xbf\xddYg\xa3\x15\xd5\xe0\xbf!\xcb.\x80K\xd1\xd3?b\x8e\xdf\xf4W\xcb\xac?\x98\x8dn\x94F\xfe\xe1?\xee?;\x94\x90_\x8b?)f\xca\x80\xec\x11\xd0\xbf\x06\xd6\\^\xe9K\xb9?c\xa6\xb4\xc4]\xd3\xbe\xbf\x10\xe3V\xb92D\x01@|\x83\x061\x824\xf0?\x1c\xedE\x99\x1e\xf5\x07@\x7f\xa0\x88\xe9\x80\x02\xfa?\xe2!\xbaE/j\x0c@"\xf9\xae\x80\xb9\xe0\x03@cRG\x11\xd6\xef\x11@H\xbd\xb0"K\xd9\x13@\x97\xa4\xb2v \x90\x10@\xba\xa2U]V6\x0b@\xbb\x9f\'N\xc5\x86\t@W=b\x87\xa6\xdc\xe5?z\xb2\x8a\x9c4\xc4\xea?Sw\x80\xa8oY\x02@\x8d\x8f\x1b\x13\xa1\x1f\xdb\xbf\xcd\xf0\x917\x19\xbe\x00\xc0Ej\x95?\xf4w\xd9\xbfh\xb94\xac<\xee\xe3\xbf\xe4\xe0\x87\x82\xddP\xd3\xbf\xda9\x1aI\xef\xbe\xe6\xbf\'\x1f\xe21\xe1\xfd\xfd\xbf\xc6\x15\xd4\xd0\xd3\xee\xe5?\xf7R\x18\x82\xac\xd2\xf8?\xfdC\xb5=\xb9\xcc\xfe?2(\x80\x84\xd0G\xe0\xbf6\x80\x0c\x18\xae(\xdb\xbf*\xe5\xf3\xa7\xc2t\xc7?>\xdf\xda\xb2(Y\xc9\xbf\xd9|8x}\x00\xf2?\x1a\xa0\xa2\xe7\xb7I\xe2?\xa9\xc9\x16\xc7\x10\x13\xde\xbf\x03n\xfa\xf2*\xe8\xb8\xbfK\x90\xb3 \x11\xd5\xe7\xbf\x97\xac\xdf\xb6\xce\xc8\xf0\xbf\xd0)L\xb9\x88$\xec\xbf\x1a\x97\xa7T\x86\x93\xb0?\x1f\x8a\xb7\xc3W\xb3\xde?\x9c\xa6\xdc\xed\x0cI\xfc\xbf\xb3b\xa3\xf5\x91\xc1\xc1?\xd9w"t\xfd\xba\xd4?\x07\xde\xd4)\x82\xa2\xe7\xbf\xb4\x86\x9f\xba[\xa4\x04\xc0\xb9,\xfb\x8c\x94[\xf6\xbfbt\x0e\xb2\x02N\xe5\xbfD<~U\xf6\x8e\xf5\xbf\xcd\xd2\x9cw\xac\x81\xef?\'\x8b|\x99\xe5\x17\xdc?\x99\xbb\xfe\xdb\x00\xb3\xe7?\xc3\xd1r;\x03\x0f\xea?F\xfe\xed\x02\xff\xa7\xe7\xbf\xde\xd4%F\xc9@\xe7\xbf(\\\xe9\xf78\x12\xd6\xbf}\x82BN\xba\x1c\xd4?\xb9\r\xdc\xedS=\xd5?\xdcob\xeb\x14X\xdf?\x94|\x80\xb3H\xf9\xe1\xbf\xeb\x03jF1\x02\xf2?l\x0bB"\xe3\xdf\xcc\xbf\xed\x0f\xbb\xee\re\xe4?ps\x91\xb2yr\xe8?kXK\xa7\x93-\xd7\xbfD\x80\xc0\xf1\xa7\xcb\xf2?\xfbQ1\xf8\xdf\xf4\xcc\xbf/\x88~}\x11"\xbc\xbf\xdb\x8c\xe1\xf3\xc2\x01\xe6?0\x940F\x0bV\xfe?\xa1&\xb9\x9f\xf77\xde\xbf7U\xa3\x89\x11\x8e\xf2?\xf0\xb5l\xe3\x8b\xf4\xd0\xbf\x0ci\xa6\xd7l+\xde\xbf\xddK(\x1e\t\xbb\x04@<\x1d\xbe9\n\xa2\xfd?F^\xe9\xd3|\xd4\x03\xc0\xa0\xd8\xd8HaY\xdb\xbf4{!\xa1\xe8\x91\xef\xbf\x11\x93\xa2b\x97J\xe0?C\xfb\xb0\xbd;\xdc\xe7?\x8d\r\xbc\xe3\xa8\xe2\x03\xc0uv\xc1]\x1a#\xf3?L5mm#\xaa\xdf\xbf\xa3H\xd5a\x1e\xe2\xdd\xbf)\xea\xd9\x18Wa\xe4\xbf\xb8\x00\xab\xc7Eg\xed?;\x1em\xac\xfdU\xd4?\x16"\xfb\x99\xfb4\xe5?\x15\x17\xe7%\x84\xc5\xcd\xbf\\;\xfe\xfe\x10+\xd2?\xda1\xff\xdcZ\x94\xe0?7aRuE\xf6\xc6?\xa7\x001\xaa\x8bK\xd0\xbfj\xb5\x992p\x01\xff?\xb7\xf5\xc2c\t\x10\xe7\xbf\x0e\xf2\xcf\xf4y\x82\xd0\xbf\x94\x19\x9e7\xab\x9f\xf4\xbf\xe8F?;\x1b\x94\xf4?\xcb(\n\xb6\xf0W\xda\xbf\x1e$\xab\xd4\xf4h\xcf?\xa5r\xe5\x02\x84\x0e\xc0?z\xe3\x1b\xfaY[\xe7?\xed\x10\xe8TI\xf2\xd2?9:\xf9nW\xab\xfb\xbf\x80\xfc\xdc\xe4\xaaN\xd4?q*\x82p\x19.\xd5\xbf\'\xa84n\xa0\xc2\xf7?\x00\x1c\xd6\x0f(J\xbe\xbf\xaf\xfa\x1em\xe9\x17\xe7\xbf\x02\x0f\x9c\x9f\xa5z\xe0\xbf\x8b\xba\x9c\xe6\x00W\xb6\xbf\xd3\xbf\x9f\xf3\x98\xca\xd3?\xc0\x0f\x10\xb1dV\xc5\xbfe\x13\x12\xa4\xbc\xf5\xd9\xbf\xbeK\xf3h\xd3\xc2\xf3\xbf\'\x05E\xd84I\xe2\xbf\xb0J\xdf\xce2\xde\x03@\xed0\xb3sf\x1c\xc9\xbf\x8cl$\x0e\x0bb\xf5?n\x8a\xf7\t\xe4\x84\xd4?\xdc\xe2\xc3\xaa\x03\xe0\xee?\x11O\xa0!\xdf\x1d\xd5\xbfV\xa3;\x11\xae\x1f\xf2?[\xcd\x90\xb7\x1e2\xdc?L\xa6\xd6~\xf7/\xe5\xbf\x17\xa1\x07\x02\x9f\xa2\xd3\xbf>\r\'g\xd3}\xfb\xbf\xc2qUz[\x1d\xe3\xbf\xa7\xda \xd0?E\xdb?\xd1\x83YW\x84{\xf2\xbf\xb7F\x15\xae\xe1\xdf\xcd?\x9dG\x07ASg\xe8?_%FEf\x97\xd6?\xeb=\xbe\xe2\xe4\xd3\xe2?\x10\xe9Y\xddd\xe2\xa9\xbf\xbc\x11\x92X\x9d&\xe6\xbf\xe0\xb8I\x1c\xfd\xech\xbf!\xd7\x88Hu\x95\xe9?g\x8d\x18\xe27\x82\xde\xbf\x06@\x9f\xd2\xe1G\xe4\xbf;\xa65\xd6\x0e\xec\xe2\xbf\x94\xe6v-@O\xdd\xbfC\xb3\x16D\xc6\xbe\xe3?&\x00I\xe7\xab\xac\xf3\xbf\x1a\xb6\x14\xc49\xaa\xef?\xda%Fy|\xbf\xea\xbf\x0b$\x8e+\xb2\xb1\xc1\xbf\xe0\xc2h\x9aW\x0e\xd0\xbf\xa9Y\xb8\xc5\x18@\xe1?\x92\xe1B\xe5\xd5\xdc\xf6\xbf\xfe\x12 \xa2\xc1}\xc2?x\x8f\x9a\xc75\x13\xf8?|h\x98,\x15\xc3\xea\xbf\xe8\x0c`\x08\xa4Q\xf0?\xc5\xc5\xa3m\x00\xf0\xf4\xbf\xcfQ\x81X"\x91\x0b\xc0 \xb2\xd6\xe9\x85\xf7\xe7\xbf\xbbD\xea\x16\xcc\xd7\xe6\xbf\xe7\xc4\xd1k%)\xf7\xbf\x07\xae\xb6(\xf62\x02@\xf3\xb2\x1eu\xff.\xd4\xbf\x8d/\xed_\xc2\x94\xec\xbfq \x83\\4\xa1\xe4?\x8a\xafA\xa7\xd3\xcf\xd6\xbf\xc0m\xe8\x8b9\x86\xd7?\xfa^\x0e\xf5\xa5\x97\xc8?\x06J\x00j(\xc0\xf1\xbf\x07\xc2\x02u\xb2\xc0\xf2\xbf\x94\x97\xd0,2\x8b\xfb\xbf\x0f\xaf{\xdbFg\xdb?`$\xf9\'\xc4]\xf4\xbf\x8c)\x9bg\xba\x00\n\xc0\xf2\xbe\xec\x1e]\xb1\xef?[\xa0\x80U|e\xc5\xbf\xed\xd2H\x14\xd7\x89\xf2\xbf\\.x%\xa5f\xe9?\xdf\xc3\xd6%k\x1b\xfb\xbf\xf9\xa7Kj\xaa)\xd0\xbfQT0v\xd1\xdd\xef\xbf\x17S\x81\xae\xb7K\xde?\x01\x18Qp\xb3\x8e\x00@\xe9\x81\x9f\x8c\x8fG\x83?4\xbc\nnG\xbc\xee\xbfG\xcc\xe4\x86u\x8b\xf7?\xc9l)\x0bD\xd4\xe9\xbf\xf1rhF\xff\xad\xf5\xbf5S\xac\xde\xd0\x1d\xee\xbf\x80\x7f\xfa\xdeW\xb2\xea\xbf\x16!\t\xfa\x0b\x1d\xe7\xbfF%Ea\xaf\\\xc3\xbf\xd8\x8d\xb0\xe0J\xd2\xb0\xbf\xebl\xc7\\\xcd\xb4\xf0\xbf\x96*\xea\xa8\xc3\xbe\xf8\xbfj|w\x8c\xe7\x90\xf7?\xce\x88\xab\xf0\xf1\xe9\xe1\xbf\x82U\xb5\xacc\xfa\xd9?|HZ\xb21g\xd9\xbf3Z\xa4\x00\xb9\x98\xca?\xed\xa8\xc5\xcc@;\xfd\xbf\xe4Y\xaa\xd4G\xec\xf0?\t8-\x16e\r\xd0\xbfFx\xe7*\xff\x85\xf9\xbfZ\x9eH\x98\xba(\xcb\xbfw<\xc5}I8\xe8?+H\xed\xf4\xc7\xd7\xe6?\xe9z \x1f\xb0\xe5\xe6?\x00\xb6x49\xf8\x03\xbf:\xbd\x8c\xb3^\xdc\xe7?;\xaa$*\x13i\xf4?\t\xa5\xc8$\x87\x94\xb3?a\xbb\x03\x9f\xddn\xc7?B\xa6\xd8j\xd8<\xea?0\xca\xd9\xde0\xeb\xe7?\xc8\xc7\x13\xe6\x16\xf3\xa7\xbf\xc0\x15\x90\x16#N\xed?\xa8\x16rZ\xb2\x86\xc2?J%i\x8d\x93\x90\xd7\xbfRE$LV7\xf4\xbfN\xc3G\xe9:\x04\xf7?\x9f\xaf\xd4\xce\xe6F\xe9\xbfq\x8a\x0fF\x85_\xec?\xc3\xb6\xf1\x9e\x1fV\xf2?\x00\x0f\xff{\xf2\xa8\xff\xbf\xb8_\xc2\x9b\xfa>\xf4?\x0e\xdbjm\x03\xd4\xe2\xbfr\x98\x1d\xc4\x17:\xd2\xbf\xc9U$\xe2$\x0f\xe1?\x83\xb7J\x8b\xcb \xf0\xbfS$\xf3\x1f\x15"\xec\xbfy\xe1\x91\xfb\xfd/\xbb\xbfbWl\x0f\xb1\x96\xee?\x96o\xb7L\x12n\xcd\xbf\x0b>\xef\x10\x14\x82\xe6\xbf\xb0Wy\x861\x8c\xfd?\xc4\\\x0b\x0b\x0e\xd9\x02@\x8c/\nM\xab4\xf0?3\xadg*\xb8\xe8\xf2\xbfC\x7f\xb0\x9a\x01\x82\xd9\xbf\x14Z\xcb\xe8\x02\x8e\xa2?\xaa\x86\x00N\xbd\x02\xd3\xbfB\xf1\xd0P7\x04\xe3\xbf\xf5N0\x9e\xa6\xcd\xd0?\xf3\x90\xa9\x82\x90\xc6\x08\xc0f\xe2B\xff\xd1C\x01\xc0\xbf\xda\x15t5P\x07\xc0\x8d\x9dg\xe9\xbdZ\xfb\xbfMCN\x17\xf6\xd2\xf7?B\xf2e\xe7\\\x13\xad\xbf\xc3\x05=\x05\x99\\\xe4\xbf\x82\xae\xb1\xcc\xd1\x9c\xe6\xbf\xa3-\x07/\xfc\x11\xf9?\xcf8\xf1v\x91X\xf7\xbfU^^\xe3\x04s\x07\xc0\xb0\x87\x13u\xcc)\xdf\xbf\xbc\xb2(\x7fi\x9e\xf1\xbf\x88>?\x89h\xda\xf1\xbf{jZ\x9f\xe9s\xca?\xc5\xb5\xdb\xca\x80\xfd\xd7?\xa4}Z\xa7+~\xf2\xbf\\X\xf4\x8c%]\xb3\xbf\xa9i\x8b\xf3\x87t\xeb?\x8e\xc9}ms\x9e\x06\xc0\x0cxj\x8fK\xf4\x03\xc0f\xb3\x80\x9d\x9b\xce\xdf\xbf\xc12o\xf8e\xd4\xf0?dX\xfa\x1fzE\xf5\xbf!\x10%\xb3\xce\xa9\xf9\xbfXa\xdb\xf0!O\xda?\xe3\x18\x95\xe5\x96\x87\xd1?\x0c\xeeR|b\xcc\xe2\xbf\xb6\x9c\xe1\xd12\xbc\xe8\xbf\xf5\x84\x9f\x9a\xe6\xa7\n\xc0bX\xd4\xc3Ah\x00\xc0\xdd\n\xc2C\x8ay\xe0\xbf9\xc8\xa9\xbd8~\xde?\xc2\x01\xdd\x05\x0e\xbf\xe9?\x9b\xa6\x88\x98K\xca\xf0?1\xa7U\xc9\x0ej\xe1\xbf\x8b\xafz}#Z\xcd\xbfd~c\xec\xbf\xd2\xf4\xbf\xac\x94\x10Y\xc5\x95\xf0\xbfV\x10[\x00FV\xe3\xbf\xa5\xd5w\x14\x148\xfb\xbf\xce\xe7j\xb0Uh\xf2\xbf\x02\x8b\xe45\xcc\x9c\xf2\xbf\x0b\xb0\x931\x05\xb8\xd1?V\xdf\xeb\xc3^\xea\x9a?\xe5e\xecjTV\xfd?0\x15,\xe1\x89I\xe8?+$\x03t\\1\xdf\xbf\xb9\x17~\xfa\xdf\r\xc3\xbfF\x99\xc7\x00\xa6\t\xc7?\xa9oq\xe5)?\xbc\xbfC*\x9c\xb2\xc3\x99\xe8\xbf\xd5\x98\xd8\x98\x7f\xb2\xbe?\x93\xe3\x89\x96B\xd4\xef?\xae\x13\xaf\x0ee$\xfe?\xa0\xed\x95\xf8\x8aW\xf2?S\xb02B`\x98\xea\xbfru\xe1ut\t\xaf\xbf\xa3\xd0\xca\xb0\xbb\xec\xfb\xbf\xc4\x9a\xa3N\xfcl\xd4\xbf\xbf!\x7f\xe9\x05+\xd2\xbf\xc8\xa0\xed\x9aZ6\xf3\xbf\xe5_\xbcS\xea+\xc7\xbf\x1epq\x14\xf3\xd1\xd5?o\xe3?\xf7j\xe9\xea\xbfUQ\xee\x1a\x9a\x04\xd5?\xe8<,\xef\x86\\\xfa?F\x06%\xdbO\x00\xfb\xbf\x83G\x01\xff\x9f\x8b\xf9\xbf\xaf\xb0\xbaq\x01\xde\xd0\xbf\xfc[\xda\xcb\x8e\xa2\xd7?\xbc|\x06\x0c\'\xcf\xf7?\\\x12\xc9Z_\xad\x02@\xbaG\xc2[\xce\x81\t@\xf4\x9a\x06\x0b+\xaa\x06@\x16\xc0\x03\xc6V\xac\x01@\xde3^hz\xc4\xfc?#\x93\xc2\xe0^#\xf2\xbf*S\xb5\xae\xb4\xd3\xc2\xbf\xa4`\x9c\x1a\xfc\xbb\xb5?x\xbe\x9d\x18\x19\xf1\xec\xbf\xabu\xce\xde\x8e\x08\xf7\xbf0%\xb1\xb3/\x13\xfd\xbf\xff\x85X\x97U\x17\xfc?\xe2\xa9\x06p\xd4\xa1\x9c?KI\x04\xa5\xf8\xce\xf8\xbf{\xfb\xdb\x19gV\xeb?\xf1\x8e\xcbp\xee \xf0?\xb4\xf4a?>Z\xa7?\xc3N\xdd\x9b\xdb\xe8\xea\xbf\xbd]3H\xd1\xbe\xbe?\xaa\x86\x83\xa6F\xb6\xe1\xbf\xc5\xba\xc6\xfeuG\xca\xbfQqQ\xc1\\y\xef?p\xd5l_\xe0J\xe6?\x92a\xc76\xc0\x99\xf4?\x7f\xa8\x00\xc0w\xae\x12<7\x1e\xc6\xbf\xb9(QO\xf9E\xc3?\x94\x06Q{\xe6Y\xe4\xbf\xabb\xad\xec\xae\x07\xf7\xbfd\xc5\xecH\xa9%\xdb\xbf\xc7\xac9\xf5\x81^\x04\xc0\xcas\xe8=\x80\x91\n\xc0AT\xd8\x8c\xb6$\xe5\xbft\xfa\xbb\xe9Xl\xda?h\xbd\xf2\xcb\x89\xb8\xf4??(\x13Y\xcf\x93\xf0?\xe9\x87\xbd\xf1F\x11\xf2?\x0c\xd6o3)\x84\xf2?\xb4\xa0Sm\xd3Q\xc7\xbfa\xa5\xacN\xdft\xd8\xbf\xd0!*\xebz\x90\xe8\xbf\xad\xae\x0b\xcf\xdb\xf6\x00\xc0\xdd_z\xd2\xba\xf7\xe4?\x13\xfd1\xd0\x83i\xbc?\x82\x86{C\xa8\xf6\xb0?vZ\xb2\xb9\xb6\x89\xf0\xbf\x91\x81\xdd\x94%\xe6\xd2?\x98\x9d\x16\x8a\xb7\x9e\xed\xbf\x03\n\xbf\xb8\x94\xab\x01\xc0\xce\xf1*\xb3Q1\xe4\xbf\x91!.\xe3\xde\xd1\xfd\xbfe\xd3\x99\xf7\\u\x06\xc0\xdcDh"\x02\xdd\x13\xc0\xd4Ea3\x175\xfb\xbf\x8e\xf0\x9b\x11\x0b:\xf1\xbf\xeen\xe0LeW\xbd\xbf"\x88\x14c\xdc\x1d\xef?\x9a\t\xd9W(\x9f\xfb\xbf \xc3@\x9b>\x89\xea\xbf\xf6\xa5\x86\xdfZ\xf8\xf2\xbf}J\xb4\xe8\x88:\xf5\xbf\xc6g\x8f\x12\xe0@\xfc\xbf\x92\x17p\x9d\xb3\xac\xd0?\x05\xdd\xe5\xdf4\xb7\xd6?\x8eV-\xcd\xd9\x00\x93?\xe2G\x04\x0f\x07\xde\xe6\xbf\x1bj\xaf\xfb\x8b\x8b\xd4\xbf\xcf\r\x9f8\xc0:\xf3\xbf\xf1\xaax\x18\xf5\xfe\xdd?\xa20vT+\xb8\xf4\xbf\xe5c,\x98\x03\x19\xc9\xbf!\xa8\xe2\x8d\xf2\x0e\xb5\xbf\xd6\x95T\xb2\xa1\\\x01\xc0\x00r\xd1\xcft\x18\xf8\xbf. I\xe2i\x9a\x07\xc0\xe9}\xcf\xb3\x0bW\x00\xc0\x1f\x93>>12\x10\xc0\x92@\x93\x9b\x1a\x9d\x0b\xc0\xa4\xc4\r\xab\x9a\xf5\n\xc0\xbd\xb2\xd9\x1bLl\x1a\xc0\x9f\xf5\xaf,F0\x04\xc0\xe4\xbc}\xd68\x98\x00\xc0]\x18>\xb4}\xd1\x01\xc0\xad\xd9\xfd\x85\xf2\x0f\xed?\xc8F\x83\x8b\x1a%\xf1?\xd3\x85\xc3\xd2:.\xe4?\xd9\xcb\xf6\x05\x86\x08\xdf\xbf"\x88\xd6O\x00/\x01\xc0\xf8a\xcc\x0e%\xa4\xf2\xbf\'\xf44\x8d\x9b\xdd\xd7\xbf-FQ\xf86\x9e\x01\xc0\x19\xeb\x1c\x1f\x9a\xde\xe5\xbf-c\xc7o\x0e\xca\x05\xc0|\xc5\x9a\xab\x9du\xea\xbf\xc7\xd9W\x8d}\x8e\xf8?b]\\\xdf\xbd\xef\xf5\xbf9\xa0\x0b\x8cl\xc4\xef?\xc2f\xf8\x00\x1c/\xeb?\xe3<\xb8N\xe7M\xb9\xbf\x9dM\xb9\x9dn\xc6\xef\xbfN\x04\x12\x91\xc9m\xb5?\xce\xc9\xa9\x11\xd8O\xf8\xbf\x83\xc1\xb3v\x13M\xe3\xbfO\x8f}/\xd1\xba\t\xc0\xa0r\n\xb3\xa0f\x0c\xc0J\xe5\xecWg\xb8\xfa\xbf-:o\xf4Y\xe0\x0f\xc0.\x95!\xdf\xe9\xc4\t\xc0\x9f\xf0\xcb\x99fu\xf9\xbfD\xc5\xd0\xd9F\x11\xe0\xbf\'\x918\x92\x17#\xa1\xbf\xdd\xef\xdc\xa5o\x85\xe3?\xa0\xde\xb2(+$\xfc?\xee\xbci|\x9c\x1c\xde\xbfnC\xc2k\x9bw\x0e\xc0A\x8b.\x0b\ns\xfc\xbf\xd5\x8b8\x16\xe3e\x07\xc0L\xa6\xd5[@\xcc\xe5\xbfaaq.4\xdc\xf7\xbf.\r2\xf4\x0e9\x03\xc0a\x9dv0\x84\x03\xe4\xbf\xa7\x01\x81&`\xe1\xfc\xbf\xe9t$\xb3,\x16\xf3\xbf\xa1\x04\x1e!\x9d\x81\xda?p\x9a$\x9f7\xc1\xf0\xbf\xb6\xd8a/\xc1\xfd\xeb?B\x99pV\x8c\xa6\xee?\xb7\x8d\x86\xbf\xf2\xcc\xed?zX\x1f\x93C\x1b\xf3\xbf\xea\x82\xe7\x9cq\xc1\xe9\xbf\x06\xea\xdeA\x8a\xf4\xd6\xbfM\xba\x9e+\x910\xf5\xbfy\xd5\xb7\xde\x01 \xf6\xbf\xbf-\xdd/k\xaa\xfc\xbf\xa4\x02\x7f\xbb\xf5t\xf4?\x19M\x0em\x12\xa0\x07@\x91\x02\x04\x82\xc1y\xfc?|\xb4\xca\xae\xf6P\xb8\xbf\xe7\xf5\x1f.B\xbc\xd0\xbf\xd7*\xca\xe8\x07\x88\x02@\x18\x07\x8b\x14S$\xcd\xbf\x08\xfd\x1f\xc4]\x94\xc9?x\xa0\\ie\xc1\xae?\xfa\x93\xacx\xe6o\xf7\xbf\x11m\x9f\xdbiA\xf4\xbf\xb2A\x13\xd8\xf1\x12\x10\xc0\xf58\\\xea^\x9f\xfc\xbf\xb5\xa2\xa6\xcbk\xf6\xff\xbf\xd78T\x98\xc1)\x02\xc0t\xeb\xaf\xe3\xee\xf8\x01\xc0\xd5\x17\xfc0\xe2\xce\xfc?\xc4g\xe2\x02\x0f\xa9\xdc?T\xa3\xae\xc6\xbf_\xf1\xbf~\xa5\xa5-\x19\x96\xe8\xbf\\\xcf\x04\x11.\x8a\xc4?l"\x89\x02\xd3\x89\xea\xbf\xfaQ\xfa\x98\xe2\x9d\xf4\xbf F?\xe8\x19\x13\xdb?zM82C\x81\xfa\xbf\xb3\xc8[7a\xc7\xc2?\x1cLR\xbc\x8a\xee\xfa\xbfH|\x8d1\xe2\xc2\xe4?lnH\xf3\x16\xf8\xee?\xf9\xaaJ\xd7\xc5\xa2\x07@:\xd7\xc97{p\x01@\xa3uY\xe0\x08\xea\xf8\xbf-U4\x1d\x9f\xc1\xe7?\x01\xff\xc4\xa0\x043\x11@AU\xe9\xcb\xd0\xca\xfe?\x8c`\x06\xdd\\\xbe\xbd\xbf\xce\x0f\xd3\xb8\xc5\xb0\xfc\xbf\n\x0eM\xcdHH\xfe\xbf\x9c\xeeY\xf8\xda\xcc\xf6\xbf\x17\xd3\xc8\x1ah\xb3\xf5\xbf\x1cpH2\xe1\xb1\xe4\xbfO\xc0/\x9c\x13\xf0\xe2?\xf0\xac\xcaD\xf6\xf2\xe9\xbf\xa0\xdb0Oy\xca\xf6\xbfn\xf2\x1a\x81^=\x01@\xc2\xe2,-\xbc\x1e\xde\xbf\x8a\x89\xf7\xb7e{\xdd\xbf7H\x97\x1c\xc67\xf0?&\x1b(\xa7ul\xe0\xbfb\x19%\x96-<\xec\xbf}W\xbd\x0c\x8e\x7f\xf6\xbf3\x8bPm\x97\x1f\xf6?\x0b$\xd9\x1a\x9c\x91\xfa?9H\x996\x8a\xf0\xd5\xbfv\xa8o\xf1\xc9\x05\xc4\xbftR\xbe\x18\xdb\xc8\xfb?N2\xd6\x11\xf5\x9a\x06@\xe1\xf9\xe3\x08c\x0f\x0f@3\xd5\\lp\xab\xff?F\xa5]\xcb\xa4\xd2\xec?\x0b\xb2\x8f\xd28l\xf0?\xc56\xddL\xad\xd5\x06@\x19\xb3\x98ev\xea\xeb?\xb6\xf6\xb93[:\xef\xbf\xcb\x14&Ip;\xf7\xbf\xfdj\xe2*B\x95\x01\xc0d\x99L|\xbb6\xf9\xbf\xae\x93s\xa4j7\xf4\xbf8\xb7\xe2\xd7\x8e\xed\xfb\xbf\x1fH\x0e\x03\xa8\n\xe8?\xa5\xfb\x96\xe7\x02\xa8\x02@\x85\x84\x84\xd2)K\xd8?k\x89\x19F\x1f]\xf6?~uiKB\xb0\x06@[\xdc\xb3A\x80*\xf8\xbfB\xf4\xb0\x01k\x89\xe0?\x8d\xd4\x18\x1eq\x8d\xd2\xbf\x96!\x98H\x06c\xee?\x1f\xf5R\\ @\xe8\xbf\xabk\x96\xf4Os\x04\xc0\xb8\x040u\xbf\xc9\xf4?\xe9\xb3\x04zu"\x00@\xfa\x8a\xf0\xd7\xacU\xf9?1\xd8\xb1\xd3\x91\x93\xef?\x8a&/2%\x7f\x07@\x0c\xa6PX\xe9\x01\xec?\xa7\xe4M\x12\x7fb\x06@\xbe\xe9\xe0\xd8\xe5\xf3\x03@\xb3IH\xd4\x06\x99\xf0?C\t\x89\xae\xd53\xb3\xbfX\xf4\xc9\x8d\x94\xf4\xdb\xbf\xb14\xd6\t\x19\xe4\x04\xc0\x100\xc3-\xb73\xeb?@\xf3\x89\xd7\xd0l\xa6?\x0e\xef\x95\xa3\xf1~\xff\xbf\xd4}B\x1b\xdaF\xdd\xbf\x87\xe6\xb5KMU\xed\xbf"0f\xc3\xb4I\xee?\xc3t\xe1WW\xe2\x03@\xd6W\x13\xdf\xa13\xf0?z\x1c\x01\xa2C\xe2\xe0?\x8f\xf7WZ\x0e{\x07@\xfc\xa2\x82U\x85\xa5\xbf?0\x07\xad\xb7\xf7\xf7\xf3?i\t\xfa\xd7\xd1\x0f\xe3?fb/X\x8b\xa6\xb7\xbfX|\xc3i\xb7\x86\xef\xbf\xa4\xf7W\xfa\xa9\x1a\xf2\xbf\xc0\x00k\xdf\xf6\x12\xe5\xbf\x98\xb0\xd6\xb7\xb2\x87\xf4?\x83\'\xdd\x99_\x9f\xc7\xbf\xa0\xd8\x84\xa3\x7f6\xdc?\xe6\xaa\xa9\xb7\xa8\xd9\x00@\xed\x1e\xbbs\x96\xe1\x12@M/\x88\x0c\x87\x9c\x0c@\xe3\xe0\x1a\xfb{\xda\x00@\xca\x0cs\xdc#+\xb2\xbf\x90SL\xc7]\xae\xef?\x0eS\x04\x10k\xc7\xf3\xbff\xeb\x01\xbf\xdb\xdb\xf1?\xec\x9e\x0f\xdc\xe2d\xfc\xbfZ\x8c@}ki\xd8?\xec|\xf3\xb6\xbf\x1b\xe6?i\xac\xe69""\xcb\xbf\xfa\x019\xfa\xe5\x1f\xf4\xbf\xea\xbbW=\xf9)\xf7?\x81z\xe9\xb8\x11\x1c\xf3?C\x8b\xa8\xc1\x17\x87\xfd?,\x89\xcf\xea\xe7\x18\xfc?E\xe2\xfb\xf7\xe4\x08\xe9?\xdd\x17S\xfbsH\xa5\xbf\xd6\x18kL\x00\x9c\xfd\xbf\xd1 \xb8v>\x8b\xe4?\xcb\xc0\xc1\xcd\xf0\x0c\xb9\xbf_\x1b;\x96\xdc\x15\xf5\xbf>T\x9d\x14\xad\xd0\xb6?\xf0\xefIQ\xe3\xd7\xbfMIZ\xc5<\x11\xd5?\xce=\x1a\xd6\xe3P\xfc\xbf\xdc6T\x88\xc2\x1a\xa7\xbf \xdb\x8dL\x9b\xc0\xe0\xbf\xfd\xee\xe9\x94n\xb4\xff\xbf\xf2t\t{lp\xe3?\xba\x1a\xa9\x82\xfd\xe6\x00@\x8f6#\x8e\xc4$\xe9\xbft\xbc\xbc\x90C\xf3\xe0?S[\xae\xc7mJ\xeb\xbfzwC\x0c\xe8\x9d\xf9?B4V\xe1jq\xeb?u\xeeM\xb8u\xc1\xdd\xbf\xe7]F\x89\x8f\x8f\xe4\xbf\xce\xed(\x19\xbc\xe4\xe1?\x80}\x89\\\xd4\xf9\xe8\xbf\xe5\xce\x00\xf7L}\xd1\xbf\x8af\xd1%\x8fl\xbe?\xf7\x1d\xeb\xd4\xa2\x12\xf0?j\xbc\x0f\xc7H\xcf\xf1\xbf\x04\xfe\xdeU\x8c$\xf1\xbf\x11\x97\xc6\xd8\xfe\xf6\xde\xbf"^\xc0\xf0\xe3\x14\xc0\xbf\x84\\Pt\x95\xce\xdb\xbf\xe5\x9a\xd1\x11-\xa6\xec\xbf\xc8\x9d\xd9\x1cC\x17\xeb\xbf\x1fa\xb1onz\xb1?\x11\xc9\x0cABG\xf8?r\xcd*E\x81\xeb\xd8?[\xee\xbd\xe3\xe5\x93\xf1\xbfZ)\xb7\t\xdd\xeb\xe2\xbf\x13\x87\xcbA/L\x05@%n~\x97"\x94\xde\xbf\x8c\x86WH\xb7A\x9d?=\x1e?\\hd\x00@r\x1a\xe2#?\xf9\xf7\xbf#\xearaRj\xf0?\xb7\xb2 5\x9dN\x01@m*\x99\x02H\xe2\xf3?(\x98\x07\xdb\x9c\xc8\xe0?#i\x17#0\x82\xc6\xbf\xd7I%\xac\x81\xf5}\xbf|\xcc\xbf\xda\xea\x10\xff\xbf\xf9\xc9\xb5\x11aH\xcc\xbfPG\xb4\xf5\xb3\t\xef\xbfhA]\xe8RY\xf1\xbf\xd4~x\xa2\x96[\xcb\xbf6\xe1\xbe`\xd2w\xe7\xbf\x0bX\xd9\xca\xb8o\x01@h\x8e\xee\x8e4z\xf8?\xb1-\x86\r\x93\xf7\xfc?g\xa8!\x82\x9b\xf1\xf6?IS\xef\xdd\x8b=\xb0\xbf\xf5b\xcdJ~8\xd8?\\\x13"\xaf\xf8\xb1\xf1\xbf\x06e;\xd1\x1e\xc8\xe8?\x10Y\x0e\xc9\xf3o\xf7\xbf\x7f`\x98)A\xde\xf9?Wb\x8bH\xdc\x95\xf6?"\xa6\xbd\xb0G\x10\xd0\xbfH\xf9=\x18;\x16\xf4?\xde\xdbw\x9f\xf8]\xf7?\x9c\x10\xf2L\xe3w\xe9?\x02?\xce\xe1\xc9\x04\x00@\xc33%n\xe1/\x01@K\xe6\xe83\x82\x05\xe6?\xd2\xaa\x82;\xc2x\xee?\x8ae Z:\x0e\xcb?\xfeik\x08%>\xc2\xbf\t\x8f\xbap\xe7\xee\xf1?\xc5<5}\x13\xe4\xe0\xbfY\xa8qe{\x81\xcd\xbf\x0e\xb4\xd3\xb4\xcb\xe8\xd5?4\x10\x04q\x8b\xa9\xc9?\xc3\xe9W\t\xdb#\x86\xbf\x14\xf8\x81@\x8f\xec\xba\xbf\x87Y\x8c\xa0\xce`\xe3?\x9d\xc2|\xe2\xc2\x1f\xce?;\xaf\xcc\xaf\x15\xd7\xbc\xbf\xcb7\xaf\x19k$\x02\xc0\x82\xb8\xcb\xb9\xdao\xed?\x86\x98W}\xc8q\xe2\xbf\xf5_\xfe\x14\xb8\x19\xe1\xbf\xfe\xb2\x90\x8d\xd9\x00\xd4?\x07[\xd0\xd8\xeaS\xe3?\xae\x1e\x9eD\xc5\x83\xe8?\xf5a"`\xc5}\x03\xc0\xae\xfe\xdd\xffm\xc5\xe2??\xc1\x13G\xc6\x8b\xe4\xbf\xdfs\x87\x81K\xa6\xee?I\x1ee\xf6D\xb7\xff?\xcc_\xea\xb7\x84\xdd|?\x95\x9f\x8dw\xf0c\xf4?o*+\x08G&\xc9?\x84B9\x1f,\xc9\xce\xbf\x95u\xd4\xb8)?\xe9\xbf\xdcB\'\x9c\xe0#\xfb?M\x04\x16=/\x9d\xec?\nZ7\xff\xd7+\xe1?f\nr\xf1\x87\x18\xfa\xbfP\xf5cu \x86\xe6\xbf\xc4\x13,\xd8\xa6\x18\xb0\xbf\xa0\xa6\x15\xc5\x05v\xf6\xbf[\xa4\x02\\\xa6\xed\xf6\xbf\xf2\x0fe\xed\xb9\x8c\xfd\xbf\x00\x07\x05\xa9\xce\xd1\t\xc0\xd4\x0en\xe7\xe1\xfe\xee\xbfC6c\x12\x05\x95\xf6\xbf\x02\xc8Qcn\x93\xd5\xbfb\xf3;qH\xe3\xf3\xbf\xab7EFMQ\xfd\xbf\x94\x887\xd9Y*z\xbfg\x9bh\x83M\x94\xd5?\x8b\xdf\xd5\xf9\xe5\'\xfd?#\xb0\rv\x86\x9d\xed\xbf\x85\xb1\\|\xfa\xf8\xd3\xbf\xcf\xe9s\xee\xe8,\xef\xbf\x8f.\xd69wx\x00\xc0\xef\xcb \xcf\x04\xb6\xdf?\xb3u,\x194\x86\xe7\xbfDw\xe4?t\xef\xd4?6\xca\x0e\xcd_\x14\xf4\xbf?T<\x16F,\xfc?\x12\x06\x8e\xafR.h?\x18\x9c+-\xf2\xa1\xdf\xbf\x94\xe5+\x11"*\x01@7\xdd\xd3Y\x99S\xfd?\x91\x19-"\t\x0f\xe6\xbf\xf7\x04o\xb4[\x16\xc5?N\x88j\xa3\xd0\xe7\xe3?\xf6\x84\x17"\xe3|\xab?\x80\xd0c\xf3;\xc5\xfe\xbf\x88"\x82N\xca\x0b\xf6\xbf\xa4\x17}\x01\xccy\xf9\xbf\xa3\x04\xea\x1aV\xae\xdd\xbf\xaa\xb6\xf3.\x1e\r\xe4\xbf\x9fFT\xe1\xf7\xbf\xaf?\xd8YQ\xae\xb3\xa7\xf2?\'\xd9d\xda{~\t\xc0\x9cW\xa0z\xa1\x7f\xca?\xa9\x00=\xdd\x06\xf4\xf1\xbfwG\xef+M\x92\xfc\xbf 1WJdZ\xea\xbfX\x8c\x966=\x0c\x01\xc0\xbf\xc4m\xfd\xd77\x11\xc0\x9e#"\xba\xa2#\xec\xbfMu#=ns\x04\xc0D\x07\x9c2\x7fo\xe5\xbf\xcf\xc8\xff\xf5\x98\xf6\x00\xc0\xe6e<\xab\x0b\xf1\xe0\xbf0\x92\x8d3\x16\x0b\x92\xbf\xb6\xda\xed<\xe1B\xde\xbf\x10H\xa5\xc1\xb7\x83\xd7?H\xd9L\r\xbfN\xd1\xbfv\xf9c\xc3\x19\x1e\xf4\xbf\x10\xf6\x9b\xd5\xac\xb8\xca\xbf\x07\x80\xddb\x1a_\xdb\xbf\x8aD\x05\xe22\xf3\xef?p[\xfcvs\xa8\xe3\xbf\xe6CY\xa5\xb1]\xf5\xbf\xbdW\xba\r\x94Y\xd6?7\x8a\xb6;\xaai\xf9?\xe9g\x9f\xcf\x80\xdf\xe0\xbf\x04r\xab3\xd7@\xdc\xbf\x8b\x9a\x8e\xb9\x8b\x9f\xf0?\xa1\xd1X\xc4\xe0\xf1\xec?}\x0f\xea\x87\x15\xa6\xcf\xbf@\n\x81\xce\x19\xa8\xd3?\xcd\xcb1\xe6\x0c\xf6\xe8?9\xde\x82"8\xd8\xe5\xbf"!l\x99v\xa5\xe5?\x07I\x9a\x89|\xc4\xe9\xbf\x8d\x9aq\x88\x8a\x1a\xf8?\xd9_\xe5\x11\r\x01\xf3?\xa9\x9f\xf5^\t_\xdf\xbf\xeb\xd6\xd00y&\xb1?d`k\xa7$\xbb\xe6\xbf\xc1=A\xbd\xf83\xe7\xbf\xc1=\x91\x84\x95\x86\xe3\xbf\xb0\x94\xc0\x10\xf6\xa6\xf1\xbf}\xb9Td8\xae\xf6?\xe7\xcb\xa4\x8c\xce\x86\xa9\xbf\x03\x92\x7f\xec\xdft\xf2?9\x1f\x8cLs\x1a\xc0\xbf\x85\xcbab\xa3\x8d\xdc?ME\x8f\xa4\xaf\x82\xf6?V\xe2\xb7:\x8a\x1f\xe7?/)\x93?\xff\xdb\xec?`\xee\x9a\xf9>\x84\xf5?\xe0&[\xfe8\xcd\xef?4O\x9e4\xd6i\xdc?!\x03\xc7\x88(\xd1\xd1\xbf\x06\x1ezy\xa39\xe7?g\x9d\xfe|\xac\x8f\xd0?1O&7\xe6\xe4\xfc\xbf\x02F\x8a1lT\xa9?4\x80WR-g\xe9?\xe8\xd8\xab\xf0\xfa\xf6\xbf\xbf\x9ek\x08\xf7\xd3\x0f\xdf\xbf\xd1CI\xa78z\xd5?\x14\xd8\xbb\xb2v\x9a\xec\xbfF\x8ae\xe7\x86G\xfc\xbf\xd6\x82BP\x8d\x9c\xe2\xbf\xfe\xbb}\x8bw\r\xe2\xbf3\x96\x18\x83\xf6|\x06@\x07\x97\xcbz\xe1\x8d\xf0?7\xb1K\xe55s\xfe\xbf3,\xd2\xc8\xce\xf6\xdf\xbf\x96P\x8d\xb3X\xc3\xf9?4[\xccO\xed8\xd7?LL\xd6\x92X O\xbf\xd0\xe5\'\xc0\xae\x7f\xdc\xbf\x90p\xaa\xa6\xe5*\xe3\xbfl\x9c3\xc8|U\xef?\xd7\xad?\xc7\xef3\xc3?\xf1z99v\x12\xe3?\\\x9d\tP8-\xbb\xbf\xc2\x01\x07\xd2f\xf2\xfb\xbfa\xe6\xb4\x9d\x90m\xc0?j\x9a\xa9\rU\xa0\xc9?%r\xfc\xbd\xa6t\xdd\xbfF$\x88\xbd@\x1d\xc1?p \x9c\xfc\xafs\xf8?\x8f\x94\x18\x16\x01i\xb7\xbf\xf4\xb5\xedd\xa6\x98\xe9?d\xdc\xd8\x161m\x92\xbf\xf6d!Xx\x0c\xec?\xca\xf7\x8e\x93\xbcG\xe8?)\x7f\xc2\x1a\xe6\x9e\xd1?w\xe4\x9b\xee7\x92\xd3\xbfx\x14W\x07\x1b\x0c\xe2\xbf\xe8\x8d\xed\x84z\x0f\xe7\xbf@K\x92\x85\x14\x87\xcc\xbf\x8e\'\xaf\x906%\xe9?8\xa2\r\xf9_U\x80\xbf\xc7\x08@\xb0-\xa9\xa5?\xa1)\xd4\xf0\xe2\xb9\xe4?\xc2\r\x9d\xa4P\xe8\xfd\xbfM\x92\xdf\r\x99M\xf6?#\xe8\x04\xf87\xf6\x82\xbf\x10\xb3 oi\xd2\xf6?\xc2\xe3\ny\x16\xd6\xe6?\xca\x8a\xe4\x9a\xfd\xb6\xec\xbfA\xdf&u\xabq\xf3?/\xe5\xbde\xf5\xa0\xf1?\xab\xcfR=\x84c\xdf\xbfv\xb7o\xb4\xb0\xcb\xbd?\x19\xe6\xfd+3\x03\xc2?\xf4"@\x7f\x0e\x84\xfd?\xf5\x1f5\xcf\xd5\x04\xeb\xbf\x90n#\xa1\xef\x8f\xe5\xbf\xbb\x1c\x83\xbc\xf6D\xd6\xbf3w\x1b4\xb1\x11\xf0\xbf02\x82x\x0c\xd5\xeb?|,2\x1a+N\xeb?\x95\xecf\x8fJF\xc3??Hs\xd6P\xa5\xd2??\x03\xc6c\xe8\xfc\xe3?\x02\xc2T7J:\x00\xc0>\xd15\xca\xcd\xd7\xef?\xc6\xf7\xbc\xb5\xe7\xca\xe5\xbf\xe9g\xaf\x1b\xbc\xd3\xfa\xbf\xbc\x1by\xb2Y8\xf1?t\x00\xd6\xbfR&\xfd\xbf\xf25\xe8\xc3\x0fA\x03\xc0\xc2\xc0\x8csh\xde\xec\xbf7"\xfbg\x00\xc1\x87\xbf\xd4L\xe6A\\\xde\x05\xc0\x9c\xbc\xf6\xf7\xbf\xbd\xf1?m\x1f\x12\xf7\xf2T\xe0?vG\xda4\xd1\xc1\xe2?\t\x06\xac06I\xe8?{\x83\xe0\xba\xa8\xa8\xf5\xbf\x9371W\xfe\xeb\xfd\xbf\n\xb5\t\xd1r\x04\xc4?\xb4^\xdb\x12i@\xf9\xbfV;\n\xd6h\xdb\x04@\x97^\xb46\xd0\xda\xf7?\xf1#\xf0z\xb2\xeb\xd4?\x06\x1c\xb2\xb0s\x93\xd7\xbf\xfd@\xaa\xe3ty\xdd\xbf\xa5\xaf\x08\xbb\xee\xe4\xdb\xbf\x8dB\xd9\x87\xf1\xda\xcb?\xa0\xe4\xe0\x0bU\xc3\xab\xbf\xc4\x83\xc5\xe4\xac\x83\x01@\x89\xbex!\xc3H\xb2?d\xd0>\x0e({\xcc\xbfP\xc2yU\x9b\xfa\xee\xbf\xa8\xd6\xe0^5\xf8\xf2?G7\xa6R\x8ak\xdb\xbf\x9b\xff\xdd\xcd\\\xc0\xe2?T\xf3D\xb40\xba\xdf\xbf\xee\x1a\xe3\x06y\x18\xf3\xbf\xe2\xc63\x1b\xe0\x80\xf0?\x89+Ux\xc6\xb2\xf1\xbf\r@\xd0\xc6V\xf9\xef\xbf11\xc1\x04\xd4\xcd\xee\xbf|\xf3\x96&\xbb\x11\xee\xbf\xf2\x9a\xb7\x06A\x05\xf7\xbf\xf3!\x84\xc0\x17\xc1\xc5\xbf"\x89\xf3\xaf\x85\xf8\xeb?\xca1#\xfa\xdc\x8c\xe1\xbf\x06\xb3=\x93\xf5\xa8\x04\xc0x,>\')=\xc2\xbf\xf1\xae\xed\x13\x88\x81\xf0\xbfX-\xf1a\xd2)\xe8?S\xac\xfb\x0f\xcfx\xf0\xbfr\xed\xb4pS\x00\xda\xbf\xfaY;\xfd\xce\t\xdc?\xa3b\xad)\x18\xdd\xd1?\x88$b\x93?{\xf3?\x85\xa9\x08Q\x8d\xe4\xb4?\xb3k\x85\x90\x8e\x0b\xca?\x05sKG"\xba\xd0?\xbc\xe4#\x04i\xac\xfd?P\xcc2}\xd1[\xb8\xbfvJo\xcb@.\xf1\xbf\xad\xf7K\x91{\xc9\xb3?\xa6O\xb5\xb2\xf9A\xdd\xbf\x87th]\xba\xad\xdb\xbf\xd4\xb0n\xf6\xc9Y\xd8\xbf\xef\x08\xe2J+\x82\xe3\xbf\xcc\xaf\xa4#\x1dx\xdf?j\xea\xcas5\xc5\xf3?;\x7f\xba\xa6\xb3s\xe4?\xea\xa5g\xbb\xcbn\xc8\xbf=\xfcS~\xa1\xa3\xb1\xbfF\x86\xee\xf6\x81@\xf4\xbf\xb6=>o\xfba\xf5\xbf\x14 X6\xe2\x90\xef\xbf\xf9\x87\xd8(Ag\xe2?\xc5\xb3\x11:\xfc\xcf\xf3\xbf`\xc4\x9b\xcc\xfe\xf3\xe5?0`\xf3>%\\\xc1?8Gp\x82\x03[\xf0\xbf\xd0\x0bv\xe4}\x87\xe0\xbfx\xed\xf5I\xf0\x0f\xe5\xbf\xf1\xa2\xf4\x8c\xf3C\xf1?\xb0\xb7\x82Xs\x8c\xe5?\xb6k~\xc9\xb2j\x04@\x03\xde\r\xac\x01\xf2\xf4\xbf\x07\xba{\x16\x98W\xed?K^\xee\x97\xa7g\xe6?\xef\x90\xe4\x83Lv\xe7\xbf\xf7t\x19\xd7\xaa\x9c\xd3\xbf8\xa9\xef\xd6nZ\xd4?\x93\xed8><\x98\xd0\xbf\x8b\xbb.E\x1c/\xd4\xbf\xf8\'/\xb3\xb3D\xec?(}Pu\xd1!\xf2\xbfV\xdcc\xbe\xa7\xe4\xf0?x\xa24\xb7\x8d\x16\xe2?(\xc5\xfb\xa0\x9b\x80\xe7\xbf\xe1\xc2\xc2\xe8\xb1\xa6\xfd\xbf\xb9D\x80p\xebk\xeb?"\xbd\xe99\x8eb\xe8?v\x8df\x08EN\xf0?YnC\xcc\x83\xe3\xf0\xbf\x8a\xea\xfb>\xc22\xea\xbf\xa0\xf0a;P\x86\xff\xbf+\x8e2_\x96\x9b\xee\xbf_S\x1ap\xad\xb5\xdc?Bw\x1bw3\xc1\xfa\xbf\xb2E\xa4\x98.M\xd2\xbfB\xbb\t\xc7-)\xde\xbf\x92I\xc5\x90\xad\xa7\xf2?\xfb0(H\xcd\x9a\xf5?_\xb4AI\x92O\x04@\x9a\xeb\xbb\xd9\xf9\xa6\xe4?R/\x03<#\x1f\xf5?\xb9\xa0u;\x80C\xe5\xbf\x80\xce\xa7O\xec\xe0\xf1?.*\t0\xe2\xd0\xbd?\xa7\xd8\x89Ign\xf3\xbf\xa9/\x81\x01-\x96\xe5\xbfO\x85-m\xad^\xd8\xbfzQ\x1c\xa1a\xf7\xc4?#\x06\xf8An\x80\xe4?\xad\xf4\xaf\xac\x17I\xb2?B\x0e\x18K\x9b%\xa3?n\xd3\x8c\x80\xc9s\xf1?\xa3\xcek\xc3\xd2/\xf5?[\xe5\xa3S\xa3\xcc\xf3\xbf\xe5\x04G\xc2\xc9\xe1\xef?PA\x98\xb0\xb44\xef?\x94?\x85\xd4`\xa3\xdf\xbf\x0f\xca\x11w43\xf6?\xcf\xf5Ew\xeb\xae\xe4\xbfL\x12\xd9\x01\xcch\xca\xee?\x87K\xb4\xa0\t\xad\xe0?9\x90\xe8kD\xe2\xf0?u\x83\xc8#\xfc\xdc\xd0\xbfF\x1b\xf9\x90\xc8\xc8\xb8?)o\xe4y\x90\x11\xf1?+>\x9f\xe9\xc6\x92\xf3?\x9c\xef\xa7\x97\xbfc\xf4?A\xc9x\\\xa4\xf0\xb2\xbf\x0e\xe6\x1dh)\xdc\x03@h\xf7\x85\xf0\xf9\x1d\xe5?(!\xb5\xa0\xf1\xcb\xe4\xbf[N\xb2[\x0f\n\xd0?\x84+\xee\x07j8\xd3\xbf\xcd\xd9\x8fC\x15&\xb4\xbf\x02_\xd8\xbd\x86\x0c\xe0\xbf\x05\xcb\xd1\x91\x11\xa3\xe4?\xf2*S\xc8\x01\x08\xa2\xbf*N\xf3b\xa4y\xe6?0\xf9\x85\xc7b\\\xf4\xbf\xcc\xf9\xf4@4\xf1\xfe\xbf\x07\x99\x89\x02\x86\x88\xf1\xbf\xb0\xdb\xd61\x1ew\xe9?\xc7\t\x89?V\xe4\xf1?E\xe6\x8cz/<\xed\xbf\x0f\xd4\xb1\xc4\xe2\xd6\xda\xbf\x0f\xc3xz\x1d\xdc\xfa\xbf\xe4}!\x87\x8fZ\xfb?\x82J\n\x9c\xb1\xc9\xfb?\xd0\xac\x131TW\xbb?\xb4!\xd20z\xba\xfa?,\xfd\xc5\x86\xae\xa7\xeb?\xe5^\xef\xa0\xbbe\xe8?_\x87\x11\xb0\xdb\xa0\xba?\xd8\xc1\x01\x10[\x1b\xd6\xbf\r\xbe\xd7\xf3\xf9\x9e\xf2?\xad \x92\'\xec\xfb\x00@j\x81\xb4\x80\xdf\xbb\xe6?\xb9Z\xfem\xf3\xf2\xf0?r\x8a\xa5\xbaC\x86\xde?\xe5*\x19A\xb2\x11\xc0\xbf\xb0"\x1d\x13\xa1+\xf2?v\xfc\xc8\xcb\xa6\xe5\xe7?3\xcf\x0e)\x16\x8e\xf0\xbf\xddC\xae\x8b\xc2\x84\xe8?\xffk\xe3\n\x15V\xeb\xbf<\xd9\xd0D\xb5\x8f\xe4\xbfQ\x8c\xfa\xbe\xc9\xf2\xd8?&\x15\x8a\xd5\x9bA\xfc\xbf]\xfd\x9d\xa6g\x00\xea\xbflU\x90Z\x0cl\xf2?\x13\x1f\xecxH\x89\xf2?\x00\xe7OO\x89\x18\xfb?\x859\xdaj\xdaN\x00@\xd0\xb2Lrq\x11\xd7?ts\x8b\xb9\xbb\x1a\xe9\xbf\x1b\xc0\xb4f\xcfl\x04@S\xb2CK\xc1,\x02@?L%\xb5\x12)\x01@\xb5\x8b\xaf\x83\x01\x96\x06@J\xeb\xcd;\xdf\x0c\xc6?!g6\xceX\x13\xe3\xbf\xa8\x7f\x9c\xab\x076\xd2\xbf\xd9Zpl\x01\xd1\xf9?\xd7uR\xb8\xb7\xf5\xf6?$\x8b\xe3\xc7\x80\x0e\r@\xc8p\xa9X\xee\xde\xf4?\x8bO*\xcb\x01$\xec?F\x1e\xdf\xeaI\x1e\xf1\xbfl`9\x98\xf5P\xe6?\xfb\xa8i\x1d\xc0&\xde?\x9d\xac\xce8\x106\xa6\xbf\xe4\xf5(\xe4\xbf\x07\x02\xc0\xa1\x81\xf1\xce\xccR\xf6\xbf\xae\xcb\xb7\x9d\xab\xe7\xf3\xbf\x8a \xf5n\xd2t\xc7?\xd3\xf4\x86[2$\xa1\xbf\x86\xa0Q!vc\xb5?K\xd1\xe7\x9f\\\x1d\xdb\xbf|x\xbb\x8b\xc2\t\xd5?FC"\rW\x8b\xdd\xbf\xaa\xf4\xbd\xcfx\xf2\xde\xbf\xac\xde\x15"bA\xd2?\xc8E\xbb\xdc\x19\x87\xfa?n\x01|`sI\xf2?Q\x03\xfc\xb9\xea\xfb\xf1?\x83\xe4\xdaj?\xcd\xe5\xbfX\t$\x82\x08\x1c\xe2\xbf\xb9Q\x0c\xf5\xf3\xc1\xec?\xe87\xe5\xe89.\xf4?\x94\x17\xd5,\xa2\xbd\xe4?\x11!.\x1f\x95V\xf0?\xff\x882{\xc7\x99\xfd?d1\xcc\xe4\x89\x01\x05@w\xd92\xfc\x82\xf2\xd8?v\xbc\xa1%\x927\xdc?\xe4\xe8\xc1\xd6j\xdf\xed\xbf\xeb\x19\\.g\xa9\xe3\xbf*\xdd\xb5:\'\x1f\xd7?\x00\xd7%\xa9~9\xe5?~\x04Bj\xd5w\x00\xc0\x13;\x85\xf2\x18\xc0\xf4\xbf\xbb\x8f\xaa)\xb31\xe3\xbf\x87m\x0e+\xc6c\xc6?\xde"\x153*\xd5\xf0\xbf\x7f\xe3\x80\xdd\xf6_\xe0\xbfp\xbb\xb8\x02\xa3P\xbe?U\xce|w\xb1\xea\xd3\xbf\xf6\x9ey;h\\\xc0\xbf"\x19\x1a} \\\xfa\xbf\x7fd\xd44\xab\x88\xeb\xbf&\x8a\xb3g\xba\xff\xf8?%\x88r\x08\x11&\t@\x14\xcdc1\xaeM\xe6\xbf\xab\x84\xb8\xfc\xd8\x1f\xe1?h\x1a\xc4X\xaf&\x03\xc0\xf0#\x81\xde\x89\xf0\xd4\xbf\x13h>\n\xe7\x8e\xcc?ZY\x19\xf9\'m\xed\xbfE\xafwg\xb3\xa6\xf5?\x97XX \xfd?\xf0?r\xd0:\x8d\xe4o\x03@\x04\x15\x05\x06\xd6\xa0\xd8\xbf.\xc6"\\\x13c\xe9?\x9f8L\xdd\x03q\xf2\xbfw\xc9+\xbd\xbf\xf3\xed?O\xfa\xd0\x8atm\xda?\xba\x1e\xe7\xa9\x0f\xdd\xcf\xbf\x8a)\x1eT.\xaf\xc0\xbfB\x83\x19\xf4\xdf(\xf9\xbf\x97o\xe1\xff\x92C\xe1?\xc1JE=\xbf\xad\xf3\xbf\x87\xe0+\td\xfb\xf6\xbfS\x8f\xb2\x8a\xa5j\xf0\xbfT\xa0*\xe9$M\xb4?\xcaH\xa8\xa7\xb1\xfa\xde\xbf\x9aT\xf68w,\xdc?\x9b\x1a\xfb\xe5\x18\x13\xfc?\x15\xb6\x91\x0bZ\x06\x11@.\x81\x03\xc0\r/\x16@<\x1d\xfbL\xb9\x1e\x13@\xb7\xae\x16\xeb\x04\xb4\xe9?K\xb3\x07\xdcH\x80\xd7\xbfB\xc1\x08H\xa57\x04\xc0s\x8c\x90\xde\xbd\xcb\xef\xbf\xe4\xb1g\xa6\xb08\x0c\xc0\xe5vPN\xfeR\xd9\xbf\xf3G*\x11\x1cT\xec\xbf\xcf\xde\x9c;\xe4C\xf6?%\x99E\x00\xb7\xf6\xc4?\xdc\x9d\xc5}\xd0\x10\xf3?\xcb2\xb2O\x0b\x98\xe4?z\x89\xa2\xef\xbe\xe4\x00@\x11O\x15\x8d^}\xe9?|\x8c\xb5\xecP\xbd\xfb?\x90+{)\x9f1\xc2?H\x85|)\x12u\xd7?\x95O\xb7\xa7ex\xfb\xbf\xeb\x9e(\xf5)\xd6\xe7?\x7f9\x07\xf9\x90,\xfb?|\xdbv0ef\xf5?Y\xab\x15\x84q0\xeb?N\r\xf7<\xad$\xda?\x8de\x91zT\r\xf2?\xed\xb8\\\xa5\xdf\xaa\xf0?~\xa9H\xe3\xc8?\x07@\x95b;\x01\xb5p\x10@0\x0c\xc5\xe2!\xcb\x05@\xc1\xe34\x87H\xdf\xeb?\xba\xaa\xcfh\xe0\xbd\xb7?\x02\x1d\x12\x87m\xe5\xb4\xbf\x8aQ\xbclh/\n\xc0\xd9&,n\xd6\x8d\x02\xc0!\xa8\x02\xddw\xea\xd9\xbf\x7f\xc4\xee\xe5\xdc\x1b\xf8\xbf6\x8b\xa3\xb8b\xec\xf9?T\xea\\W\xd2\x1c\xc5\xbf\xaf\xbe\xf3\x0f\xdd\xae\xe1\xbf\xa7\x88\xf6^\x8b\xab\xde?du\x19\xb9\x06q\xe3\xbfj\xe8\x8d\x9c\x84B\xe5?\x8b\xd4\x85\xf6\xce\xda\xef\xbf\xfe]\\\xc5\xa3y\xca\xbf\x8b\xe1sA\xbb\xb4\xe5\xbf\xbaK\x8d\xaaz\x9b\xf8?+\xe7B\xb5\x97\xa1\xea\xbfc\x9dErrN\xe6\xbf\xa1f\x86\x9c{g\xd5?y\x8b\xee|\xf76\xec?\x84q\xd1\xda\xa2{\xcc\xbfHahn\x9e\x9d\xfb?\xc5O,\xb9\xad\x10\xf8?\x86\xbe{v\xc0!\xf1?za{\xc0b\x05\x0f@q\x17\\\xd3\x10\x0c\xf5?F\xfc\xe8\x12\x98\x97\x02@\x1e\xf9\x1dY7@\xd0?\thl\xd6\xa0\x90\x06\xc0\x02\xb7\\W2\xc1\x03\xc0\xd5\xb8T-\xc4s\xe6\xbf8\xad\xa8\xbeG\xd7\xc2\xbf\xe3\x1f\xdb%\x0f\x1c\xff\xbf\xce\xfd\xc5\xca\xec\x05\xee\xbf"\xc2\xc3*(4\xf1?\tA5B\xb6*\xf1?m"\xde:\x96\xa2\xb0\xbfW\xe9_\xcc\xa61\xc7\xbfW4PlC\xed\xbf\xce.\xed\x19M\x07\xfd\xbf~(\xf9Z\x19\xf4\xe3?\xf0.\xfe\x9c\x03B\x00\xc0\xb6\xc7B\x7f\xa1\'\xf5\xbf8\xdb\x82(\xb5\xe4\xb9?\xa9\xe0\rLvR\xe7?oLY#ek\xe5\xbfSKX\xd6\xa1\xa8\xe0?d\xcc^\x19\x0b\x93\x02@\x98\xac\xe9\xdf\xf4\xde\xd5?\xd0\xe1\xf3\xd6\xc9\x9f\xed\xbf0\x7f<\x82\x19.\xe0\xbf0)QX\x05\xd7\xf4?Km\xd0\x9e\xb3%\xd8\xbf\x884\xc8\x87\xc6g\xf0?(\xf1Y\xe3\xa9\xce\x01@g\xcc\x88\xcf1\xed\xb5?z\x95\x96\t\xef&\xd8\xbfMSH]x\xf2\xf8\xbf\xfa>M\x10$/\x01\xc0\x97;:\x8f\x85z\x05\xc0\xba$\x8d\x19\xc6\xd0\xf6\xbf<\xe2\x1a\x7f\xec\xab\x01\xc0`\xa54M{\x06\xeb\xbf\xb6\x0b\x06\'\x0fj\xfc\xbf]\xf0\xae\xb3P\xa3\xd2\xbf5\x9c\xcb\xff\x8d"\xf3?\xf4\'\x16=\xafi\x01\xc0)\xe4\x11o\x13\x97\xf4\xbfiE\xbcr\x95\xb3\xf5\xbf\xa2\xa6O\xa7[\xa6\xc7\xbf\xac\xa4\x0c\xd9\n\x0f\xe1?\x7f\xe3:\xc8x\x89\xe2?\x1d\xffdJ@\\\xd7?\xeeK\xfft\xe9S\xf5?\xd8\xc7\x95\xd1R\xd7\xdc\xbf\xb0Hq\xa5o}\xd6\xbf01I\xd3\x8ci\xfa\xbf\x9f\x15/\x01\x9eB\xf9\xbf{m\x9d0"\xd7\xc7\xbf_KG\xe6\x97\xf7\xff\xbfl\xbeY\xa0U\x0e\xea\xbf\xed\xd6\xa6\xa8\xcd\xc8\x03@\xf6R:\xcad\xf2\x02@\xbf\xd7\x9d\x197\xad\xe6?r\x19y4\x90\xdc\xd2?\x93A\x02~Ic\x07\xc0l\x0c\xeaB\xf6\x1c\x01\xc03\xcc\x11\xa0\x0e\x7f\x10\xc0^3\xf9\x81\x94*\xef\xbf2\xac\xd0w\x80\x1a\r\xc0\xb9\x86\xe5\xfa\xb4\xbd\x07\xc0\xe4K\xbf.\xd2\x13\x03\xc0\x96]\xb9Dr\x95\xd3?\x9b\xbf\x99\xc5\x83\xb1\xe9?\xef\xb4\xe6\xd1\xa7\x95\xe2\xbf\x8a\xbcvL\x0b\xf3\x03\xc0\x8dQe\x88lg\xee\xbf\x80\xcc\xe5%R\x9d\xe0?\xa7Q\xc2\xa2\xdf\xc6\xd8\xbf\xaa\xfc\xa1\x13\r\xb5\xf7?B\xba\xff\x02l\x8f\xe0?f\x8d\xef\xa6\xa6\xc7\xea?\x9c\xbf\xb4+*6\xfd?\xa3\xf1\x1cR\xf9\xcb\xef\xbf\x82\xec\xd0\xbeq\xbf\xc6?\xb4\xfa\xbb\xa0F+\x03\xc0{\x13\xfd{\x07_\xfc\xbf\xa0W%\xe0\xa35\xf0?j\xe2x3\x01?\xcb\xbf\xd5i\x8a=\x84"\xbb?R\x1f|\xff\xfd\xee\xf2?\xe7\xb5\xa0\xd1Dn\xfa\xbfZ\x8e^\x9c[;\x11\xc0)\xfb\xff\xf8;\xbe\x15\xc0|\x93\\\xab\xb7\x07\x04\xc0f\xee\x97\xc6\x96\xd3\t\xc0\xc8u\x97y\xd3\x01\xc1\xbf\xaeN\x0c\xdd\x8du\xe1\xbf\xb3gH+\xb2\x03\xfc\xbf\x9f\x00(\xb7\x07\xf6\xc1\xbf\x81\x8c ;\x83\xc7\xa3?\xefx\x14f\xe2x\xd2?\x9c\xa4\x1et\xeaM\xdd\xbfLj\xadf\x081\xfc\xbf\xe0\x12?\x86`\xd2\x01\xc0\x82\xd4\x8c\xce\xe6(\xc8?\x9c\xe1DG\xef\x03\xfc?\xba\n\x98\x01\xd6\x07\xe4\xbfd>H\x9b\xcf\xb7\xcc\xbf\xc4\xba\xfa8\x17\xd8\xed?\x81\xa4\xfd\xea\xd9\xbe\xf3\xbf\xdb\xc7\x9a\x0eX\x89\xde\xbf\xfd\xf3\x8e\xd2a\xe7\x03@]\x9a\xb5\x96\x89\xc7\xc5\xbf,\x8e\x1b\xc9\xff\xaf\xe9\xbf\x1d\x8a\x81\xb1\x08O\xfd?`$J(6\xa9\xe0?\x80\xd0u[z\xe3\xe1?\x92~\xe4R\x02h\xf0\xbf\xb7\xb4d4\xd3a\x01\xc0\xb5G\x8d1\xbdY\x16\xc0\x14\x14\x8c\x0b\x81\x98\t\xc0*I\xc6P\\\x98\xf7\xbf\x94R\xe1t\x14\xbe\xf3\xbf\xf8\xd8-d\x98\x00\xf3\xbf\xa3|\xc0\xcd\xbe&\xfd\xbf\x9aw\x1e7\xa2\xb7\xa1\xbf\xad@\x0f\xa5\x96\xdb\xd8\xbf\xd2\x1dPO\x17\x9d\xdd\xbf\xa39\x9a\xe9\xc0r\x03\xc0\x8a9^\xdc\xb9S\x05\xc0-\xa9}\x05Z!\x07\xc0\x01[\xefGq\x87\xbf?\xd5\x89C\x8b\xd7\x9c\x00@\xbdEX\x13\x13\x94\xbd?}\xa6y2OF\xcc?\x1e\x8b\x93\xf7\xc7\xe5\xa0\x98\xbc\xbf\x1a\xba\x8cf\x1c\xf5\xef\xbf.b\xeb\x1ch4\xf9\xbf\xb7/n\xdd\x01I\xf4?\xcd\xfc\xa0+\xffN\xf0\xbf\\=\xfa\xa5\xef\x95\xf4\xbf\xa0\xb2\xd7||\xdb\xde?#y(\x1a\x9ci\xf5?\xeb\x9er\x8a\xb0\xcf\xeb\xbf\xd5\xcd:\xd0\x9f:\xd2?\xeb\x01\x8a\x9cr\x7f\x07@\x16\xa8\xdd&j\xb3\x01@\xee(\xd0\x86\x9e\x15\t@M\xa6\xa9\x11\xcd\xc7\x00@Q\xe8\x8c\x03\xa7#\xf5?`\xfd\x10A\x93\x85\x00\xc0{?==?y\xfe\xbf\r\xc7\xd7\xce\x9f/\xd2\xbf\xf7&\\\x17fY\xd5\xbfS\xda\xc4!mR\xc4\xbf\x07\xe6\x0b0\xe6v\xeb?\x04\xfcI\x9c\x05\xa8\xe1?\xc5\x97\x97\xf8\xaa\xe1\xf4?\xf7\xfc\x01\x06T\xd6\xf1?%t8\xa9\xa2\xd2\xff\xbf\x14\x91b\xbb\x1f;\xf2\xbf\xb2\x8a\xd4t \x8a\xaa?\xf2\xd5Z*\xb8\x95\xe3\xbf\xa0n\x1e\xc6\x82\xd7\xfb\xbf\xac\xd6*\'6\x9c\xf2?\xe8\tJ:\xf2\x16\xf3?w\xb9\xc7\t\xf7i\xf3?\xe7m\x8d\xab\xb3\xb1\xb8\xbf\xb4\xc0\xf7\x9f5\xde\xe7?\x87\xf9\xa9\xff\x13\x0c\x01@S\xf9\xe3\x9f\xe5\x1a\x06@\x85\x7f\xae8[v\x02@\xe5\xb4\xf4\xa2F\xca\xa8?tso\x03b\xb3\x00@\xdf\xdd\xc3\xa8\xdf\xee\xe1\xbfkMa\xb8\xb4\x89\x0c@j\x98h4\xc0\x03\x01@\x9b!\x97-\x7ft9?\x91-\x1089\x12\x05@\xec\xbc\xa0\x88\xf5\x94\xaf?\xcfx\x8f\t\x13L\xef\xbf|\x9b\x9f\x1ec\x98\xf5\xbf\x97\x1dgz\x1f\x83\xf4\xbf\xdeR:\xe3\xbb\xed\xe2\xbfH\xb8-\x95W}\xe2?lI\x8d\xf5\xc7\x94\xf1?\x7f\xa3w\x9d\xe6\x82\xfe\xbf\x0f;=96L\xb2?+\xd1#2\xbel\xee\xbfy\xb0\x07\xf1w\xdd\xcd\xbfT\x1bO\xc9\xef\xc7\xf0\xbfn\xdbV\x0c8\xdd\xed\xbf\x95\x9cd\xb3<6\xc4?w\x88\xa5\x15K9\x03@\x03\x0c\x1c\xd5d8\xf2?\r\xd7\xcf~\\\x94\xa6\xbf\xf8\x87\xae\xf03\x8b\xec?(j&a\x84\x95\xde?\xed.\x0c\x8f+\xab\xe7?\xf7jt-?\xd0\x00@\'\xba\xef\xed\x82\r\xf6?\xdb\x1fD\\I\xa4\xf5\xbf9\xc9\x8d\x96\xd94\xe7?\x1e\x97E\xb7\xb2\xa0\xf5?\x9c@\xbd;Ts\xf1?\xd6A\xa9\xbc\xa8\xca\xfd?\xec4\xe3Zc1\xfc?\r\xcc,\x17;\xa9\xf1?9\xf7p\x1fq\xa5\xf5?\xd0\xe1\x87{.l\xd1\xbf\xa5\x0e<8\'2\xe4?\xc7\xd6\xc3\xabN\xc9\xc9\xbfk6\x9c4\xef:\xf0?\'\xeb\xcdQ\xf1\xeb\xe0?#f\x96`g8\x04\xc0\xb0\xce\xdd!t\xa5\xe1\xbf\x97\xd4\x05\xa3\xd8\xa3\xe7\xbf\x1b\'\xf1\xd4\xb9\t\xdd\xbf\xe0\xe3\xd1pz\xd5\xd9\xbfT\x02G\x90\x17\x01\xdb?<\xff\xe1\xedU*\xb2\xbf$;u\'s\xb5\xeb?\xd5\xcf\xdc\x1e\xd6M\xff?;W\xef\xd4\x82+\xeb?\xaah\xe7\xdcSB\x99\xbfT^\xf0\xfb\xac\xbf\xf0?3\x16\x01\xf4 \x03\xfb\xbfi5\xa84}R\xb9?\x1e\xc9\x99\xce\xb7\xb6\xf7?\xda\xa9?\x07\xfd\t\xcf?\xa3\x17\xaa\xcev\xeb\xef?\xf5?\xaf\xa9\xf7\x04\xc2?\xf8u\xcb\xba\x1c\xbc\xf5?\xa8g\x91\xd1\xe1\x1d\t@.C\xb9\xfd\xc1|\xfc?\xfe\xe6\xb3\x0f\xb0\x0c\xff?\xdf_x\x14\\7\x06@\r\xef!\xd4i\xb7\x04@\xcdr\xf7\xa9v\x8b\xd8?B\xec\x85\x93\x97A\xf0?\xc0\xba\xb1o\xaa\x9c\xd8?8 \x12\x05)L\xaa\xbf\xd9\x11\x82\nI\xa1\xc9\xbf\xc7\x1d\xb9\xf5\x07\xd7\xf0?P\xbfy?\xd5\xb1\xb0?\xc3\xbc\x9bd\x99\xc9\xde\xbf&\xab\xd0\x98\xbag\xf1\xbf-\x05T\x053\xee\xca?\xc1\xa5\x19\xd9\xab\xc5\xe0?d\xde4\x9fsE\xdc\xbf\xdbS\xcc\xf3\xa3\xb1\x05@\xee\x03\x97\xaf\x9d\xdb\xdf?\x1e\x96}"\xccl\xf4?\x05S\xec\x81pS\x00@\xa2Q\x85\xfd\xcb7\xe9?\x89?\xfe\x10\x97\xcc\xf5?\x92:\x8f\xca\xba\x01\xd4?:\x19\xd5\x0c\xd6\xdb\xc0\xbf\x8c\xa8\xaeE.\xc2\xd1?\x97\xb9\xfc\xc8\xa1\x80\xe0?\xc1\x0e\x18O\xa5^\xf3?\x82SM\xaa`_\xe0?]\xcc\xe5LhL\xe8?\xa3\xb3\xc8}\x81t\xd7?\xbe\xd5\x8bi\x02\xb5\xf8?\x8e\xa1n6\x8f\xf8\xed\xbf:-\xfc\xcaJ\xfe\xed\xbf\x8bB\xd4\xe6\xdc)\xe6?\x92O\xdf\xe3\x8fo\xc8\xbfmr\xea\x16\x81\x86\xf0?\xf9?O\x907l\xd0?Qd\xcbT\xfdb\xf1\xbf;.\xe2\x04\n\x05\xe6?Y\x1b\r1\xc1\xd0\xe2\xbf\xfc(x\x0eQP\x00@J\xb8\xa5\xdf\xf3\x15\xf9?Tf"\xbc\x89\x86\xea?\xed\x01\x13\xbb\xd2\xd7\xea\xbfL>\n\xcb\xa1R\xf2?\x91\x06\xf8\x8brv\xb9\xbf%8\xcb\xb0\xb5x\xf7\xbfdM\x8f\xfa\xecv\xbe\xbf\x89ZX\x90h\xf7\xec\xbf\x85B\x85o\x80q\xc7\xbf\xc4\x03\x19\x17\xc0w\xc4?\xac\x12\x06\xdcV\xee\xe8\xbf\xb8.\xd54\x03B\xd1?\xe1N\xec\x15\xc6\xf8\xf1\xbf7\xa9\xb78\x9f\xd6\xdb\xbf\xf0\xdd\xcfj\x7fy\xf6\xbf\xcc\xad(\x86\x035\r\xc0+\x96\xa8\x91|\xe0\xb3\xbf\xf4\xe0\xe6H\xcf\x10\xdb\xbf\x88,\xb8<\xbe\xb0\xfd?0ko\xac\x0c\x04\xd4\xbf\xde\xe8b\xc4H#\xf1?\xff\xe5?\xa7\xcd\xcb\xe6\xbf\x1cS~\x91o\xea\xd8\xbf\xb7\xae\xb3G\xa8\'\xa0\xbf\xda\x02-\xd8\x11\xf6\xd7\xbfY\x82\x91lY\x0e\xd7?\xbc\x02{\x01\xa0\xfd\xd8?e\xe5n\xa5\x89!\xee\xbf\xf8\x05J\xc1\xe1S\xe2\xbfB\x1b\xd1\x04\x84\xd4\xf1\xbf\xc1\xc1\xf5\xb4\xe3\xe7\xf1?@\xd2\xf9K\xb5\xed\xfb?]\xe9\n\xcc\x97\x17\xde?\xb8\x86\x04\xd9\xa4\xf9\xd3?\x9fR\xfa\x96\x1e\xb8\xe5\xbf C\xa7K|\x14\xcd\xbf+%\x949\x99\x02\x9e?\xbf\xc4\xcb\xb1T\x8c\xf8?\xf7E\xc8\xcd\x95\xf0\x01\xc0\xbb\x93C\x1d\x7f\xbb\xdf\xbfC\xcckd\xbb\xe2\xf3\xbf\x1e\xdc\xfe\xa7\xf7/\xe5?T\xc4\xac\xdd[\x91\x01\xc0\x9e!\x91~\xf8r\x01@\nCY\xc7\xd7\xc2\xf2\xbf\xe7w\x9fQ\x9a\x85\xdb?0\xeb)0V~\xd4?\r\xb7\xb7\xbd\xe2,\x04\xc0\xbaC\x04\xa9\x97X\xfd?d\x9e\xd5\xf0/o\xf5\xbft\xfd\xd1\xe3\xdf\xaf\xb7?\xbcL\xc8\x04\x05\x07\xf1?\xc7\xdds4\xd35\xfc\xbf\xb5A\x08/\xab=\xb0?h\x1c\x03&\xbb\xf3\xdc\xbf\xe2\xbe\xa8\xa8\xa7u\xf5\xbf#v\x007\x12\xae\xdf?\x16\x9c\xcd\xe1\x7f1\xfa\xbf\x92-7e\x80\xaa\xed?D\x82\x01\xcbp\x94\x00\xc0\xc0\xc9\x99\xef\xffp\xdd?\xa6\x98\xf6AJ\xc7\xd0?\xf9\xc3H\x93\xb1~\xfa?\x80 \xacr{d\xd0\xbf\xf3}\xf1mK\xad\xc4?\xe9\xb6\xad\x06\x1b\x97\xe4?\xe8\x1f\x11\xe7\xdd\x1a\xdd\xbf\x82W\xf4\x19J\xd9\xfa\xbf7\x92\xab_\xcag\xf4?\x08\xdc2\xa9\xc1\xfb\xed\xbf\x06\xf0\x9e\xf3\xa1\xba\x01@\xa2\xbd\x1a%u\x18\xce\xbf\x1c\xf0\x94\x82vj\xe6?\xe4\xbf\xe3M\x8b\xa8\xd2?\xe0\xd7\x8e\xbfw\xd3\xe1\xbf~V\xec\x1e\x87\xab\xf0\xbf:>\x9f\xdc\xdc,\xcc\xbf\x01\xff9{\xea\xc1\xff?x\x1d\x92\xcfpj\xd4?n\xa8\xf9@9t\x03\xc0\xf9\x96#kOF\xba?\x87\x8d)t@\x99\x8a\xbf3\xbe4.\x1b\xf0\xf2?\xab\x9c\xcbD\xe4\x10\xd4\xbf\xc5\x91\xfc\xe0h\xc3\xc3\xbf7\xef\xd35Ym\xc4\xbf\x8e\xfe\x95\xed\x84\xd8\xf4?\xba\xfe\xd5)\xe2\xf8\xbd\xbf\x88\xcf\xae\xde\x14o\xe6\xbf\xfb\xfe+\xa3\xe1t\xfc\xbfB\x9d\x88\x9eq\xf2\xf2\xbfT\x17A\xc0\xa8\xe2\xf9?7%\x93\xe3\xb7,\x95\xbf\x83\x8bopfl\x06\xc0\x86\x05\xce|(\x0e\xe4\xbfpnW\x15}[\xf2?S\xca\xeala\xd6\xd5\xbf\xb1\xc3*\xc8\xd2\x86\xd4?\xd3\xa2\x03Y\xc5Um\xbf\xcc\xabX\x9e\x82\xbe\xdd\xbf\x0f%~\xd0Z\xdd\xf2\xbf\x9aZ+\xb0nd\xcf?-\xa9\x89\x1c\xc2\xeb\xe6?\x06\xa0\xef\xd1\xe0\xf7\xf4\xbf\xd9\x10x\xb1\x81u\xfb\xbf\x84X\xa06\xfe\xe3\xf6?B\xd2\x80\xe3\xea-\xf7\xbfL#\xe5\xa8\xfc\x19\xdd\xbfx+\xd5H+!\xcf\xbf\xa9\xc4\xc0|\x85?\xe2?\x92`3\xd9\n!\x00\xc0\xeeDh\xc5\xa6\x93\xf0\xbf\t\r ;\xfc\r\x01\xc0\x1f@\xb8\xda\xec\x02\xe1\xbfm\xb7bA\xba\xc5\xe1\xbf\x90\xbb\x85+\xfa$\xe2\xbf\x94i6\xb0\xa4X\xce?XUfN\xed\xba\xea\xbf\x7f\x81v0\xb0\xf9\xc3?\n7g\xb5(E\xd7?\xb0:\xab\xb56\xfb\xfb?\xdd\xf28\xdf\xa8\xd4\xe3?\t\xc7\x93Go\x81\xee\xbf\x935P\xb0\xd9\x9e\xf0\xbfM\xc9+\x91\xb7\xf5\xdd?\x9e\xf0H{\xdf\xc7\xbc\xbf\x19o\xb0\xf5A\x8b\xf0?\xf4\xaf\xf2\x0b"\xff\xd1\xbf\xb3\xb7/L\xd0\xac\xf5?\x89Q\x90\xc2\x1b\x07\xdb\xbf@\xe3~\xfc7x\xb0\xbf\xe0$\x90\xb4L^\xf2?\x1e\x19t|\xab\x93\xf1\xbf\xf3\xd0y\x9d\x9b\x18\xf1?\x1e\xcb\xd9\x9b\xfd\x07\x02@^\x84\xeb\x9f\x92\xf2\x8b\xbfd\xacda\xd7\xd1\xf3\xbf\x0e_\xa1\xbfE>\xf3?|\xb0\xdcKk\x00\xdc?\x0b2\x0b\x9bm<\xd3\xbf\x85\xd3\xa2\x9c[\xa5\xe0\xbf\xb7/\xa8\x16a\x8e\xfa\xbf\x92P\xf5v\xd7\xbf\x01@,\xcc\xb3\x9dE{\xfa?\x1e\x99#\xfc;\x05\x00@\x19\x066\xb5[x\xe5?bT\x15\x99A\xb9\xeb?\xe3\xdf=\xa8-\xf1\xd9\xbf\xc6\x83\x14\x8b\x90\xe6\xe1?\xf8{\xbal\x8f(\xca?9hm\xb15&\xe0\xbfK\n\xe0\x10{\xf6\xe6\xbf\xdbS\xa4\x99\xf94\xf2?\xcb,\x8c=)\x9b\xf5?\xca\xb0@\x81`X\xe8?\x0eE\xbc\x13\x16J\xd8\xbf/)\x05\xf4|`\xf7?b\x92\xdaVZC\xf9?\xee \x82\x0c\x95\x11\xcf?E\xaeM\x92\xdf\xfb\xf7?y\xea\xbe}\xf6\x1d\xe5?\xd7\xe3\'\x96el\xe9?w>\xf0\x92X\x04\xee\xbf\xc7\xd0\xb7\x9e\xd8\x83\xfe?\xbbTT\xcb!\xe3\xd3?7\x9d\xe2\\\xb26\xc0?k\x99|\x13l\xe2\xde?\tk\x9b\x9b\xaef\xc4\xbf\x9dM\xb1\xb7I"\xf5?\x9e\xd5i#\x00K\xf0?\xcf\xfc\x87\xd2\xf8\x89\xe6?Dy\x8b/\x07{\xba\xbf\xc4\xb2\x94#\x93u\xd1?\xfet\x8d\xd9\x954\xfe?\x8b\x0b\x97\xc5\x90i\xdb\xbf"\xfd;S4\xb9\xa7\xbf[j\xab\xcc\x07\x1c\xf7?\xc8\x803[\x08\x83\xd6?Hq\x1f\xc0\xb8\x8e\xeb?\x98\xf2>\x17\xc6\xf0\xf2?P\xa3T\x93H\xe8\xf5?*\x0e\x91\xce\xe0\x03\xf1?\xd2\xfa\x0b\xcc\x8c%\xfa?Zf\xe8\xaa\x0f\x97\xb0\xbfo\xc1\xb2\x9f\x05\xc8\xee?w\x80\xa0\x1a|J\xf9?\x05\xad{\x06\x01X\xfb?D9\x9c\x16\xbb\xf4\x0e@\xbf\xbfs\xd2\xcaO\xf9?y\xa8\x17\x11\xfd\\\x07@\xa9\x1f\x136w\x8c\xda\xbf\x1b\x16\xc6\xe0\x16\x0e\xe8?;\x9b\x18\xdb.\xb8\xd1?x\xb1\xb1F\xe4\xd0\xde\xbfB\xe7\x16\x1d\x98\xa5\xe4\xbfU\x9f\x9az3\xee\xc2\xbf\x06\xa09Tj:\xf8\xbft\xabN#l\xfa\xdc\xbf\xc6\xec\xda^\x14\x9c\xfe\xbf\xc1mZ\x0b\xd2\xaf\xf4\xbfD\x0f\x8e\xcb\x86\xda\xd8\xbfq\xa7\xba>&\xcb\xc6\xbf\x1b\xdb\xadcH\xb3\xf7\xbfFl\xf8\xc6&\xbf\xaa?z\x17\xfd\x94bN\xe2\xbfc\xc4m\xed\xeb4\xfc?\xcd\xbdV]_e\xf3?f\x7f\xa2\xe8\x0f\x13\xda?V^.\xb9\x9c\x10\xf0\xbf~1\xac\xd4m@\xeb\xbf)\xdf\x98\x11\xc2\xa6\xf6\xbf\x97\x1c({q\xfe\xfa\xbfn\x94\xedF\x8e\'\xf5\xbf1\nM\x0cl5\x84\xbf\xc2\xfcJ\x85\xd9\x02\xc4?\xd40\x9d\x08\xd3\'\xbd?\xeb\xbd\x05k\xb7\xa9\xd6?x\xbf\xac.\x87\xe9\xf5?\x1f\x04\x1eU\xdf\xee\xe3?!*[;\x16a\xf3?0\xd2\xab\xe1,]\xd5\xbf\xddz\x9d\xb4&\xaf\xe2\xbf}\xaf~\x17\xee\xea\xf7\xbf]X\xf0#X\xcf\xfd\xbf+*\xca\x1e\xfb\xe9\xdb?\x82\x8f\x07\xa6\\Q\xe5\xbf\xff`\xd8[\xa8\xdc\xb3?{;,[\xba\xe1\xeb\xbf\x93\'NN\x97\xf2\xf5?\xbb\xeb\xdbC\xac\xf8\xa2?\xf8\x0fS\x94\xad\r\xf3\xbf\xc4g\xdde\x80\xcb\xfc\xbf\x1e\xf3\xb8\x92\xf7\x91\xd7?]\x1c\x17\x19\xa2\xb8\xa2?\xac\xdf\xf0`\xe1\xbb\xe1?\xb8\x94V\x0c\xc6g\xf1?\x19\x15\x7f\x13\x8d\xb5\x08\xc0_\x0c\xd2\xf8"|\xf2\xbfEQ\xf6\x1b\x1a3\n\xc0 \xb4\xf9\xb2\xaa\x8a\xfb\xbf&\xdc6.\x0e\x81\xfb\xbf\xc8Q\x8a\xbc\x81!\r\xc05\x19=\xef\x8f>\x11\xc0\x80su\x87\xa3\x8d\x02\xc0m\xc7$%\xa7\xef\xec\xbf/M\xfa\xdcv^\xf0\xbf\x94\xe6\x93;#\x11\xdf?^\xc7\xd4\xb5-B\xe8?\xd8\x86m\xcawQ\xfb?J\xcf\xcc\xab\x0b\xc6\xe4\xbf~\x9eB\xa4\xcc\xa2\xf5\xbf.$)_8\x15\xcf?b\xb8[j\xbac\xc8\xbf\x1c):&\x90t\xdd?-\xfa\xb8t\xc1\x9a\xfd?\x02\xc2?D\xac\xf2\xea?\xd8\xcef\xb5m_\xf5\xbf\x8e>\r]J\xdc\xd5\xbf\xba\xcd\xa8%(\x92\xf6\xbfS\x88\x11\x9f\x0e\x1f\xc9\xbfc\xe2\xba\xb2n>\x05\xc0\xee\xc7_\x99\xa9D\xf4\xbf\xfd\xf7P \xea\xe1\xef\xbf\x8c\xfe\xf2\\5\xbf\xf8\xbf\x81\xc1\x9a\xa4\xdb\xc5\xfb\xbf\x184\x19\xa3\x19K\x04\xc0\x07\x89\xbc<\\\xee\xfd\xbf%\xe6D\x00\xa9\xf1\xf4\xbfF,\xa5\xbfl\\\x05\xc0\xc7\xd4O\xaf\xa2_\xf4\xbf\xd6qW\xff\x9f#\xfd\xbf\xf3\x0ck\x16ul\xfb\xbf\xe4\xef\xc6\xbd\t\xfc\x0f\xc0\x8a\xad\xf1<\r\xae\x0f\xc0\x03\xb5p\xce\xedY\xeb\xbfk|\xcc\xa0f\xdd\xd1?;P\x1f\xed`\x0e\xcb?\xcdo\xa9~\xeb\xa0\xee\xbf:\xe5\xc6\x8c\xd5\x13\x03\xc0\x14\x10\xdb\xe0\x89h\xf3\xbf\xf1\xa1Q\x8d\xffz\xea\xbf?\x07\xc5\x9d\xf02\x02\xc0%\x7f\xbc\x9cy\xf2\xe3\xbf\x88\xabW\x10<\x04\xb1?\xce\xa5\xea\xbea!\xf0\xbf\xe0\xf6Y\x99\xed\xb3\xd4\xbfy\xe5L\x89\xcbg\xf5\xbf\xe2\xbc\xf8\x07Zn\xff\xbf\x0f]\xc6F\x08\x91\x0e\xc0~\xbd.V\x89\xd7\xf8\xbf@\xb3\xf3\xb2\xa5\x0c\xf9\xbf\x17\xd2\xa0\xfb\xc8\xda\xd9\xbfA\x05+a\x01\xf0\xe3\xbf\x14x\xec\x95Y\x8d\xf2\xbf\xe8\x9a\xf5 \xe3\xe7\xf7\xbf\xe8\t\xda\xda\xbd\x05\x00@Y~$\xa3\x9b\xad\xe4\xbfp1\xcdO\x7fR\xf1\xbf\t\x10\x98~`\xc1\xe6\xbf\x15\xf9+\x9ce8\xb4?\xf6K\xa6>iW\xf7\xbf\xe2\x89\x1e\x81C-\xe4?\xf3z\xa0!D9\xf1\xbfm\xc9\x0e$\xa2\xf4\xe2\xbf\xbc\xdbnv\xeb\xc6\t\xc0\x8e\x08\xdb\xe9\x19\xb1\xf9\xbf\xff\xed\x13D=7\xf0\xbf\\\xbe0\x93\xa8|\xe0?1\x17\xbc\x11\x96\xbc\xf8\xbf\xe6f2\xfb\x7f\xe9\xeb\xbf*\xf2~k\x9b\x99\xf0?\xca\x18\x128tV\xee?]\xf5\xb2\xde7\xc6\xdb\xbf\xa4\x15/Vv\xa7\xf9\xbf\x16S\x81\xd1b1\x08\xc07f\x8d\x94\xc0/\xe6\xbf\xef\xce\xd0\xb3\xc3\xc0\x0c\xc0\x90up\x8c\xd5\xb1\t\xc0\x0e4G\xc9\xe9\xa2\xf2\xbfK\x04\x10\x89e\xd3\xf3\xbfWS\x86\xa8\xcc$\xf1\xbf\xb2r$\x89\xae\x01\xd2\xbf\xcc`\xc3\x01\xf9\xce\xff\xbf\x7f"\x05\\\xeb\xaa\xef\xbfR\xd5\t\x07#\x90\xfa\xbf\x1b\xf8\x7f\x902\x19\xfc\xbf\xa4c\x15\xd9\xff\xd4\xf0\xbf\xa8\xba\x01\x1f\xecG\xff\xbf\xc2=\x18\xc9V1\r\xc0U\x85\xc5K\xcc\x8b\xf1\xbf\x86\xa1P8wJ\xf9\xbfu\xb8\xa3\xe24H\xfe\xbf\x07\xa1\xde\xc6W\xe0\x04\xc0t7\xf0\x85\xd9\xe9\x11\xc0\x93*\xd2\x03\xa0\xc2\xff\xbf\xf8O\xb3\x7f\xe9\xc2\xd6\xbf.\xa9\xf6\x022\x02\xf1\xbf\xc0\xf0F\xfb\xb2\xd6\xf3\xbf\xd9\x03Mbj\xcf\xc6?1)_*\xf2$\xf0\xbf\x0b\x90\xc52S5\xf2\xbfgY}\xd9\x13\\\xff\xbf\x04\x89b\x9e9e\xf9\xbf/<\xd5\x1ae\xe8\x00\xc0\xac\xa0\x16\xd3\x138\t\xc0\xd2W\x00\xcf?\xe6\xfe\xbfD\x8b\xd6p\x0c?\xff\xbf\xed\xed\xdd#.\x97\xc6\xbf\xa3r\x19l\xeb\xb2\xf4\xbf|\xdb\xb4R\xe3\x86\xfe\xbf\xbf\x05L\xed\xf8A\xc6\xbf\xc1\x08\xaf\xa2d\x11e\xbf\xe7`\x10\xa6\r\x0e\x01@Q3*\xf8\xe2\xc1\xf4\xbfIa\xc2\x1dm\xcf\x10\xc0\xa4h^\xach\xc6\xea\xbf\xd2&\x88\xd4`\r\x03\xc0\x1d88\x88ab\x05\xc0\x88^#\x0c\x80C\xfb\xbf\xf4\x1b\xbb\x99\x81+\x01\xc0\\2\xed4m\x1b\x0f\xc0\x81\xcfx6,\xc3\x01\xc0\xf1\xc2\xcf6\x82h\xf9\xbf\xe9;C\xf0\xea\xc8\xff\xbfih#\x1cA/\xce\xbf\xcf{!\x82\xb7\xd7\xf7?\x91\x17\xbdb\x96\x8d\xff\xbf\xe5\xea\x1dT\x13s\x04\xc0\xd6?\xbe0\xff\xea\xe4\xbf1A\x12>\x98\\\xef\xbf\xd3\xea\x00\x87\\H\xd5\xbf\xb2\xf8\xde\xc1\xee\x1c\xff\xbfVs\xe6b\x0cr\x00\xc0\xa9-\xd6\x9f\xc4\xd6\xe7\xbf\x08\xfd\xd5\xd8d\xc0\xf7\xbfl^\xd8o9\xfd\x0e\xc0Mq\xceRb\x92\x00\xc0\x93\xd7\xff\x05\x1e\xfa\xf2\xbfS\x1f\x0b\xe9\\\xf5\xfb\xbf{\x168\x94=e\xee?\xad}N\x8d8Z\x06@\xca\x05\xfbp\xab\x13\xf5?0\xff\x10V\x028\xfd\xbf\x9e*\xfa\xc0E=\xfb\xbf\x9c=\x95\x0e\xf6\xc8\xf2\xbf\x1d\x94\xa7\xbc\xf9\x85\x0e\xc0\x074}^\xb1\x97\x01\xc0:!\x03\x93f\x1a\n\xc0,\x14\x86z\xe64\t\xc0`j\xe9\xa9k\xca\xfd\xbf\xc3\x98\xa8\x8aI\x1b\xf3\xbf\xfd7\x9e\x92x\xa1\xd2?\xa0\x8f\x85\xcd\xf8&\xc0\xbf\x9f\x0ctOb\xb4\x85?\xca\xf3F\x7fa\x95\xe6?#\xf3\xf3,\xadL\xcf\xbf\xb2\x08\x18x\x1f\xbb\xf6\xbf7\xc2)GF\xf9\xf1\xbf9=cc`>\x02\xc0\xd3\xae\t}\xe4\xaf\xfc\xbf8\xb7\x85\xd5*p\xee?\xb5\xfd\xed\xf7\xe6\n\x02\xc0\xff. +\xb6z\xe4\xbf\xcc3\xf0a\xc7U\xee\xbf\xcdK\xfc\xdaxI\x00\xc0\x0e\xd9g\xb0\xc5\xd1\xe7\xbf\xf5\x9e4\xe2\x1dY\x00\xc0\xd0=\xee\xd6\x19\x1d\x03@\xf9\x9a\x1a\xbfZ\x9d\x14@5\xb0o\x92\x15\xb7\t@\xf5jD\x81\xd0\xf3\xbf\t\x80\xcc\xc5\x13\x9e\xf4?\x9a\x8c\xda%\x06\xcf\xda?g\xf00\xcbcM\xb4\xbf\xeb\x8c\x8b\x12[\xc5\xdd?9%sZ\x81n\xa5\xbf\xe4=\xc4\xdc+\xd6\xed\xbf.\xc6\xfa\xe4\x81\xcf\xd3\xbfb\xa9\x8dB\x9b\xb2\xef?\x01\xf9\xec\xa7S\x03\xe3\xbf\xad[9Zh\xd1\xd5?\xde5\xb1:\xd5\xc8\xd1\xbfS\x8d\xd3\x0b9\xc4\t@\xb8\xae\xce\xe5\xdaC\xf8?}\x00\xa8\xf7\xabl\x06\xc0h:\x07wX\x03\xf3?\xda\xbe\x17\xc0:\xd9\xe1\xbf\xad\n\xb3\xca\x83\x86\xfe\xbf\x8b\x8c\xfd,YA\xec\xbf\x9d\x9a-\xef\x1du\xfa\xbf\xebu\x06\x7f,\x0e\xff\xbf\xb1h2\x1c\x1b3\x01\xc0\xf5\xbc\x96\x91\xf0\xd2\xb2?4\x00\xbaa\x16\xd3\xe8\xbf\x04_\xa2\xb8$\x85\xd5\xbf\xdbg^H\x0c\x91\x02\xc0\xfc\xaf,\x90\x9c\x0e\xe3?\xdb8*\xe4\xd6f\xfe?\xf9\xc3@ \x82\xbd\xe8\xbfX\xc7\xeb\xfa\xff\x04\xad?J\xcc\x0f\xb7hH\xe0\xbf\xcb\xc6+\x1c\xbf-\xee?\xdf\xbe\xda\xd8\x85[\xe9?\x82\xcb\xb3lU\xfa\xf2?\xca\x83\xb2\xfaUd\xf6?q\xe3\xc7x\x8c\x98\xf7?[l<\x02!\xf9\xfb?kY5/\x92\x03\xee?\x1bzR\x10\x7fe\xee?\x84\xa1t\x8b \x95\xff?\x0c]\xdd\x9c\xf6\xc9\xf3?\xb3(\x1b4m\xb8\xe4?\xb7\xa0\xbea\xcf\xa6\xe5?\t\x06~\x93:r\xe7\xbf\x18F\xd9PQ\x02\xe9\xbf4uw\x86\xe42\x01\xc0\xc8h\xe9&\xb1\x8c\xde?\x91\x8f":\xa4A\xf9?\xdf\xa7\x89\xa2&\xd5\xf3?\x91*\xdcx#\xca\xf5?\xf9\xe3\xa1w\xcc\xea\xe2\xbfD:\x0c\xd6qz\xf0?\x88ax\xa8\x82,\xe3?.w\xb4\x11\x10\xbf\xeb?_9\x0b\xee\xcb\xdf\xef?(F\x18\xf8\x93h\xf2\xbf\xf6\x1ag\xabtV\xc3\xbf3\xd8x\xb1\x84E\xf1?9\xb9\xb9\xe8\xe7s\x04@n\r/\x08Rg\xfe?\x0c\x15\x8d\x00u\xee\x10@\x83\xcf\xb7\x16\xe5\xa7\xf9?\x07\x0b\xed\xf0\xb1\xeb\x02@\x19\x9b\xe6\x0f<\x1d\x01@\xda\xf3/|\xf2\xa6\xd1?9WQ\xde\xa2N\x04@\xe7\x8f\xcf\x12o\xff\xfb?|\xd26\xf9\xa2\x9b\xf8\xbf\xc1\xee\x08\x9d\x1f\xdf\xcb?\xd3\xd3\x93\xfe\xcec\xdd?\x94\xd0k@UX\xf0\xbf\xa3kO\xc3$\xf6\xd0\xbft)\xf9t\xc7[\xc3?\x86+~\xec\xb4X\xe0\xbf\xe4\xa9U\xb17\xbb\xdc?\xdeD\xd5b2\x8d\x07@\xfe\xd9\xdc)\\\x0e\x01@$1\xe3\xe7\x1b\xf8\xfb?\xbe\xd0\xd3\xa5\x82o\xd2\xbf\xba\xb57\xb3~\xf7\xdf\xbfjL\xb6E\xb0\xac\xf3?^\xa8\xe4!)U\xe0?F)\x07\x1d\x94\x9b\xca?Q\xa24\xe5\x81\x80\xe8\xbf\x01K\xa3/\x8c\xe1\xf0\xbf\xc8Z\xa0\xb5\x95\xd1\xdd\xbf\xcd\x0e\xe2\xe4\x16@\x04@SZF\xb1S\xe7\t@S\x9a\xf5\xb8I\x14\x0c@\xea\x00LuO\xcd\r@\x1a3`\xe9\xbc:\x03@\'/.8\xee \xfd?:\xe6\xf5\x99\xff!\xd2?47\xb0*\xcd\xf6\xd8?\x16\x1b\xab\xff+o\xf6?;]\x95[d\xdf\x05@\x97\xb6\xeb\x136\x9e\xff?\x97J\x0b<\x837\x03@\xe0\x1d\xc3\x16{\x14\xf5?\x08\t\xaaP%\x91\xdd\xbfJ-I{7\x96\xdd\xbf\x86\x95X\xd0F\x07\xed?\xa2\xda\x12\xa2E\x08\xed?\xd6|\x86{z\x1f\x04@\x1c*\xff\x1d\x8bn\x05@B\xe29\x83\xc1~\xeb?\xedu\x9f\xc0\x8a\x9d\xd7?f\t\x91\x0f\xddt\xdb?\xaeU2\x1c\xce\xd7\x99?\x9f\xb0\xf4B\x82i\xe3\xbf\xf2R\x0bY\xc1T\xea\xbf\x1f\x95\xe4\xb7\xbb#\xa1?S\x1b\xc9x\xddR\xec\xbf+\x9emo\xb6K\xdc?\xce?\xf7\xb8\xa9\x12\xf6\xbf\x01\xc4Q+\xfd\xe9\x11@\xf4\xdb\xa6!\xb5\xcf\x16@\xa95\x7f4W\x8b\x02@\xc9\x1d\xa2\xa8x\xa2\xf7?rw\xf8\x12\xa9\xa5\xfb?\xa3\xdf\x93\xab\xaa\xb5\x00@w\xa1UC\x03\x8f\xf0?q\xe5bNe\x0f\x04@\xc0)\xa7#eW\xf6?\x04\xe4\x0e\xd0hN\x00@\xa7\xf1ncG\xa2\xf2?\xef\x99g\xb1/\x00\xe2\xbfz\xf8\xb6\xc0\xfek\xb9\xbf\xc0PoC\x1a&\xe8?\xa8\x92I\xb6-\xf0\x01@u\x8a\xe3\x7f\xa5\xea\x08@~\x0e\xf2*%\xab\x02@#;\xe1R\xd1\xea\xf2?\xb7mz\xb9\xf1?u\xa46\x913T\xf7?g\x13\xf6\xab\x7f\xe4\xf1?V`]X\xf8\x0b\xfc?\x10<\xe8\xbc\xe0\xe6\x07@g\xd2\xad\tCe\x02@o\x1a\x0e\x80\x9ao\xf2\xbf\xec\xc4 \xa1\x03\xae\x0c\xc0\xb9\x03d\xe3\x19q\xf2\xbf\xb1\x80\x06\xc9\xfa\x03\xe7\xbf\x80v\xd75\x86\x86\xe0?y\x98\xba\xc0\xd2\xf8\xd9\xbf\x81^\xc0=\xd4\xe1~\xbf\xab\x0fj|\x83\xe4\xe8\xbf\x85\xfeF\xe7\xd5\xde\xce?O\xa4&\xc4\t\xf5\xe8?\x8a,o& \x08\xb0?\xefC\xbcy\xa55\xf1\xbf\xc97t\x1f\xadv\xf1?\xcbi\xf9\x99\xe8\x11\xce\xbf\xc3\xa3\x8c\xa3<\xee\xf5?Mn\xd2!\xe5\x9c\xb5\xbfyn}\x8b\xd4\xb7\xd6?\x80\xdcQY\xe1\xd7\xf4\xbf\xe40\x02\x9eP\xe9\x0b\xc0\x83\xa7\x00}}\xab\x0c\xc0O\xbd\xf4\xcc\x1cw\xf2\xbf\xe1\xe6Snw\xe4\xfc\xbf\xf4\xc3\x8d\xc3\xeb\x12\xf4?h3\x1bb\xc1W\xb0?\xa6\xb6d\xf2Z\x1d\t@\x18\r\xff\xfe\x8a\xa5\xfd?\x84\x15QJ;j\x03@\xc3*\x07\xe2\xd7K\xb7?gc Z%1\xc0?\xbf\x87aR\xc0U\xd8?q1\xc1\xc9\xd4\x9c\xf4\xbf\xcd\xc2\xdap-\xb2\x84?L\x9fRDo\xb0\xc2\xbfLh\xf4\xdc\xc4\x03\xd5?\xd7\x0f\xbd@9\r\x03\xc0@\xf6\xcf\xd0zE\xe0\xbf\x8d!\xcegbv\xdc\xbf\x1b\xcc\xbb\xf27\x89\xea\xbf[(\x8d\xb5{\x1c\xe2\xbf\xc9>\x0e\x8d\x00?\x9e?@\xbf\xbb\x9b@\x01\xe0?Fe!%H\x8b\xf6\xbf\xf8\x19\xe1j]l\xfe?\xf3\x15x<\x11\xa5\xbf?F#\xbc\xce\xcb\r\xef?\x1d\x12\xcc\x92|\x15\x06\xc0\xf7f\xac\xbb\xce9\x05\xc0\xef?\xae\x08\xfd\xcc\x08\xc0\xee\xd0\xc6\x14\xc1b\x05\xc0\xdeA\n\x13\xc9+\xdc?\xcdT\x9e\x93Y\xe6\xef\xbf[\x13\x9d\x11\xa4\xbb\xee\xbf\xa5\xf4\xca\xa1\x81\x1c\xe6?\xd3\xe8\xbc\xcc\x1b\xbd\xe5\xbf1\xd6qBf\x90\xf4\xbfa\xba\xd2\x898T\x07@!\xb4\xb9\xba\x13\xe2\xd9?&2\xc6\xce0\xc8\xa1?/\x15\xd5\xe1\\n\x04\xc0\xbc\xaa\x18\x9c@.\xf1\xbf\x80<\xbf\xca\xa2k\x06\xc0\x03v\x0e=\x87\x81\xf5\xbf<\xc6\xec\x1f\x9bi\xe3\xbfF\xdb\xf0\x1e!>\xc5\xbf\xf1\xc1\xb6nJ\xf4\x01\xc0;\xc7\x8b\xac[\x11\xdc?\xed\x8d\x8d\xbcbe\xf2?\x95pc\xd2s\xe8\x9a\xbf\xb45\xf0\x84\x87k\xd9?\xe0\x14\xa0\x17\x97\n\xe5?\xb0q\xf1I>\xc5\xf3\xbf\xc5&d[\xa1\xde\xdf?\x86Q\x1a\xb9#A\xfb\xbfe\x97`1|\x81\xf0\xbf\xd7\xb1F0\xdf\xb0\xf4\xbf\xff\xf6\x189\xc0*\xf4\xbfTgve\x0fR\xf1\xbf\x1b\xe4m\x84\xb7t\x01\xc0+_,\xbe\xed3\xda\xbfT\x8e\xb1\xd1\xb8#\xdb?m XV9.\x06@\x87\xb6\xc9\x82\x1cv\xc8?f\x8e\x9aXtE\xf4?\xb0\xb9o\x7f\x878\xfd\xbf\xc7\xaa4\xc5\xf0\x8d\xd6?N V\x90\xdc\x05\xfd\xbf\xe2,9\t\xb6f\x0c\xc0\xe1\xdc\xb4\x88\xe6\xf6\x03\xc0N\xc0\xc5\x14\'\'\xba\xbf^\x128z\xe2\xe7\xef\xbf\x1e\xfa\xd6\xdc\x9c\x90\xb9?\xb0\xc1\x01\xf6\xa3d\x08@~;\x14\x0c\x17{\xe4\xbfKge\x02\xcd\xcb\xf5\xbf\x8a\xb6u\x15\x03\x1d\xf0\xbfE\xe7pp\x8c\xe0\xef?g\x1b\xfe\xfa\xffO\xd3\xbf~\xbe\xa09e\xab\xbc\xbf\x02q\x91\xb0Q\x87\xaa\xbf\xc4E\x10=\xc5\xce\x04@GU\xa7\xf1\x94\xfc\x98?\x17\xa7\x0c\x167 \xf4\xbf\x1b\x87<_&\xe0\x03\xc0\xd4\xde\xc1DDi\x06\xc0\xb5\xec\xf29\xae\xae\xfb\xbf\xe6\xcfV\xaa\x8a2\xf8\xbf\x14}\x00\x9f1o\x01\xc0\xdcC\x0f\xb7\x8e\xa9\x0e\xc0\x85\x04\x18L\xcc\xa6\xd9\xbf\xa4\x07\xa9\x90U\xf5\xf0\xbf\x845\xb7I&\x7f\xd6\xbf\xaeD\x93W\x0c\r\xe4\xbf\x19\x1e\x885e\x1b\xef\xbf\xa53\xc5\x8b>\xc1\xff\xbf\xd0F\xb6\x83\x96\xe0\xfc\xbf{Sr/T1\xfc\xbf\xb8\xe3\x89\xa3P\x99\x01\xc0\xfd\xac\xd4,2a\xca\xbf\x8f\xf4S\xd9\x8cQ\xe8\xbf\x88\x97\xc8H\x96\x87\xfb\xbf\xe8\xf8\xfeE@\xb2\xd8\xbf\xea\xc8\x87\xc6\x16\xc7\xeb\xbfOb2\xe5,H\xf7\xbf\x0f\x05z>\x1cT\xe3\xbf\xeb\xf01*X\xa0\xf3\xbfCn#?\xe3\xfa\xf8?^\xa3:\x14\xef\x08\xe7?\x9b\xe2\xcek\xc1\x05\xfc?\x90\xa2\xd1\x9a\xd5\xa9\xe5?\xf6\xc8\xfc\xd2\xd7\x1f\xe8\xbf5D\xcd\xce\xad&\xd0\xbf\x124\x84Bi\x94\xfa\xbf\xe6uY$\xd4m\r\xc0\x0f\xb3\xbf\x1a\xbb?\x11\xc0\x8dZM\x8d=\xd0\x07\xc0\x1c\xedb\xdd\xec!\xfc\xbf\xa2\xd8\xfd\x9aO-\x15\xc0&\x88\x82\xd2\x90\x98\t\xc0\xa0\xcf\xf8*/\xba\xd5\xbfQ\xfe=\\\'\xda\xc8?\x03\xa1V5HM\xe1\xbfA\xe1\xfd\xde\x0f\xdd\xde?\x17p\xadH\x81\x1e\xf2?\xe3V\x0fj\xb3F\xf2?1\xcbW>\x96\xea\xe9\xbf\x86\xa5\xf5s\x14\xaa\xe5?\xb0\x1c\xc5\xb5k\x98\xc1?\x94\xf6\x90\x83\xe9S\xcb\xbf\x99\xa7\x8f2\x9d\xe5\xf5?ex}\xcd\x91*\xf6?\x00t\xb5\xc7o\xe9\xe9?\x9c\xd8\xc2\xdb\xd6\x13\xa1\xbf\xc0\xaf\xd9\x95\xa4\xc5\xd8\xbf\x87^\x84\xcd.V\xe8\xbf\x92\xfc$J-9\xd0?Q\x8at-b\\\xb2?v\x7f\xb03"\x99\xf5?\x92;\xb2w\xbef\xe2?W\xd1>p\xc6\xea\xc7\xbfh\xadm\xd1\x13\xc4\xc0?\xb6\xd4\xedX\xcb\x07\x07@\x02\xf0Ly\x0e\xb0\xee\xbf\xa9\x8dA$\x15\xb8\x05\xc0C\x85W+E\xd3\xeb\xbf/h\xd5#\xbdW\xf6\xbf\xcc\x90\x06\xa9u\xff\x07\xc0\x08\x80\xa1k\x89;\xe3\xbfW`)|B\xbb\xc6\xbf\xbb\xfdX(B>\xe3?o=\x9d\x81\\\x8d\xe3?DfT\x86\xa7r\xd8?x"l\xfa\x83j\xd3?d\xe1\xcf\'\xca \xe8\xbf\xdc\x9f\xafk\xd7\xbf\xb0?\'\x07\x7f{NM\xf7?\x8d{\xa2\x1f\xc0\xe1\xe6?eb\x05\xaa\x1a\xa2\xe2?\xdar\xcc&\xa9\xfb\xd2\xbf\'\xd5,\xe8J?\xe9?.\xc15\x1e\x9e\xdd\xed\xbf\x9c\x15O`\x9c9\xca?_\xb99o\x82\xd2\xa0\xbf\xfb\tA\xb0|\x15\xe9\xbf;\x83\xa8\xf5}\xdc\xb2\xbf\x89\xab\xe7}J\xc9\xfd?&\x0f\xf2\x80C\x82\xfc\xbf\xb9\x1d\xba\xeb\xcd4\xef?\xce\xb60?+\x9a\xd7?$\x85\xa9\xb5\x8cj\xd1\xbf*\xb3x:\x8c\xd9\xb1?T\xa2\x9f\x8e\x00\xb1\xb9?A\x93\xbb\x99\x1e\x9a\xee?\xb12\xce\xe9*V\xd8\xbf\xc8\xa1\x1e\x90\x0fT\xe4\xbf\x02{B%\xe94\xe1?i\xa0x"\xea/\xe0\xbf&\xf7\x83\xd3F\xde\xb7?\x12\xc8?\xb54\n\xa8?H\xd7E\x14\xbdv\xcb\xbfM\xc4\x1d\xfd8\xc0\xe5?2+\xbaR\x0bA\xe0?\x81\xc3\xa7\x93n\xeb\xfb\xbfb\xb7u4\x8be\xee?\x9a\x1e\xde\'bb\xf4\xbf/\xf8\x0b!+\xa5\x02@*J\xb3\xdc\xab\xeb\xe6?k]\xe8D\xa7\xef\xe3?\xe6!E\x99\xa5{\xf3?\xd4\x88)\xd4*U\xe9\xbf-\x0b\xc7a3\x80\xdc?\xc2\xfb\x17\r\x84/\xd3?\xc4\xa3>\xc3\xf3y\xe4?8T\xa5puC\xa3?K\xd1d\xc1\xc7\xe8\xc1\xbf\x01\xbaV\x04%\xb1\xcb\xbf\xc7\n\x96`\xed\xbf\xac\xc1T1\xdc\x05\xe1?\xa9\x99z\xec\xa4\xa0\xeb\xbf\xb7\xbf\xc7\xba\xbc\x11\xf8\xbf\xb5\xb5\xcb\xbd\xda{\xfe?\xceji!\x00\xa8\xe0\xbf<`\x94\xe4\n\xa4\xd3\xbf\x1fu\xac/\x8e>\x02@\x1by\xdc\xe0)z\xd7\xbf![\x14\x85>b\xad?\xe4A\xf6\xcdi\x91\xf0\xbfg\x01\x83\xa2@\x88\xe3\xbf\xb4\xa4\xf0\xc6\xfdx\xe9\xbf\xa7z\x87/\xb3W\xf7\xbfEx\xfciW*\xdb\xbf\xa9y\xdaA\xee\xc3\xf7\xbf\xd0\x00\x0f86p\xa9\xbf~9\x03\x95\xf3\x04\xc2\xbf^z\xbb\tR?\xe3?\xd5\xce#w\xfb\x81\xe1\xbf\xbf\xb9\x888@\xb1\xdd?\tv\x93\x800|\xf0?\xe5\xf3\x1frF\xb6\xf0\xbf%\xa6\xc3\xe2\x9d|\xe8\xbf/\xd6i\x1a\xc9\xed\xc3?\'\xa7\xa9/\xf4\xbc\xf8?\xa2N\x8f\x9a{\xb8\xc6\xbf\x93\x0e\xa8\xca\xcb\xc0\x06@\xdd\x14\x89\x9c7w\xf9?\xf97\x15\xec\\I\x96?\xda\nc\xca\x86\x0f\xf2?\xca\x82c\xcfA\x05\xf9\xbf=#\x0bk6\xf4\xe4\xbf\xa7\xae\x08\x9b\xd6\x1c\xc3\xbf\x89\x9c?_\xb8)\xb9\xbf\x8cw\xe5j\x1aF\x02@P\x82\xd9J\xb7e\x00@\xa9\xed\x84\xbb\x8b\x7f\xd2?\xf7\x96-\xc9A%\xf8\xbfP\xbczFb\xdb\xc8?\x87\xc7#n\x1e\xe5\xd8?\xab\xfc\xe8[\xe3\xd2\xd3\xbfe\xa1\xa9\xe0\xf8#\x05@\x15-\x8e1\xc4\xfd\xe0?2P\x19\xc8\xb1\xd1\xfc\xbf\xe9m\xaa\xf1\xf6\xd0\xe3?\x96\xef\x1b\x9c\x05\x86\xe2?\xdf&\x8c\x11U/\xed\xbf5\x81\xb3\x0e\x809\xdd\xbfA>;\xa8e\xd4\xf1?.(t\x87\xb0\xee\x00\xc0\xbb\x02\x8e\xca\x8f\x16\xe3?\x99\xab\xf3\xf8\xf9\x86\xe5?\x0e\x18v\t!\xed\xe8\xbfi{\xef\xec\xe7\x9a\xf2\xbffE\xee0f\xd3\xd4?Z\xe6\xb4[\\L\xf0\xbf$\xe5\xd25\x13\t\xea?L|\xd0\x9c\xf8\x0c\xb2\xbf\x86\xc0\xa56\xc0<\xf8\xbf\x84\xab\xee\xe4\xa7\x15\xee?0\x86\xb2\xfa\x97>\xf1\xbf$\xd2\x83\x01u\x13\xe0?)\xdeVp\x9b\xb7\x01@\xa9\x96\x87\x10"E\xf5?;7\xe7\xb4\x7fd\xf7\xbf\xbe\xfb\xf1\xf5\xe2G\xfe??9\xd7\xa1T\xad\xe3\xbf\x1e\xea\xf0\x08L\xc9\xc6\xbf\xc2#N\xce\x9f\xdd\xd6\xbf\xc0ABP\x86s\xe6\xbf\xbd\xf4\x8b\x19Om\xe4\xbf\x1b\x1fh22^\xda\xbf\xe4#\xcb\x8e\xd5_\xc9\xbf\xdf\xdd\t\x95\x8a\xcc\xf1?\x108Z\xe3\x02\x05\xb0\xbf\x1a~\x8ag\x9b\xc2\xee\xbf\xef\xf41\x06\x19\x16\xef\xbf\x8e)\xd3\xfc\xba\xaa\xe1?\xc3\x0e\xben\xcc\xa8\xd1?VH\xf4\x05\xb7|\xeb\xbf#\t_\xa7@\xc5\xe1?g\\\xb8\xa9\xe1\x06\xe2?\xd9\x1d\x15\x87]\xc6\xc3\xbf}\x82\x13\x1a\xba\xbc\xdb?=\xd0\x1b\xa38\xe7\xa3?a\xd4E_%7\xef\xbf\xfec\xbf\x10\x08\xc8\xde\xbf\xf5\x0f\xa8y\xfe?\xb0?z\xf3\xa20\nq\xea\xbf\xb0\xa8\x0c\x19~)\xe6?\x98\xbe\xed*\xed\x1d\xe9?o\xd88\xa0\x04\x1f\xa1?\x0749\xc3\xda\xb8\xe4?h2\xed\x0e:\x80\xe6\xbf\xb8/N\xeeT\xb2\xe9\xbf\xd2>\xa7jZh\xec\xbf\xc8\xfb\xf8)\xe7\x1d\xe9?\xd7{l\x95w\xd1\xf8?\xbf\x96\xae[\xf3\xfe\xe6?\xdc+\x1bC\x0e\xd4\xce\xbf\xa7\xa5+\xa9\xac\xe2\xfa\xbf\xee6\xc0\xb5e\xfb\xf7\xbf\xb55(\xbf\xa8\xbd\xf5?\x8ex<*\x13\x96\xd4?\x0ej\xa95\xc0\xc6\xd7\xbfIe\xa9+\xe8\xb6\xe3\xbfD\x82Yc\\\xa4\xea\xbf\x04\x93\x81\x14\xcd\xa8\xf4\xbf\x183\xbe\x9c\xcd8\xd8?s\xf0"\x867R\xe0?Z0\xf3\xc3\xec\x8e\xc0?8Hgj\x9d|\xc3\xbf\xc1 ,\xb3\xf0W\xe2?\xcd\xd8\xf6>\x0c]\xd3??\xe6\x01\xfa\x91/\xf2?\xde\xe7\xc1\xb4hq\xe7?\xf6\x89\x97\x94\x7f\xb0\xf8?\xd80>*\x17\x83\xb2\xbf\xcd\xe9\x16\xa9\xec#\xe7\xbf\x98\xf8\x83\x00\xf6\x95\xc3?m\xee\x07j\xf16\xd9?\x9d}%\x06\xfa\x8d\xe0?C\x81\xa2\xe6\xd2d\xcb\xbf@\xb8\xb9\x87\x01~\xe8?\x97/\xb5\xa0i\x10\xd1\xbf\x0c\xda\xe9g@)\xf6?+\xc9\x90~Y\x91\xf9?\xab\x80\xb6\t\xb6Y\x03@!\x03\xd5\xebi\x93\x01@\xd53C\x97\x8a\xab\xfd?\x9c\xbe\x94\xe6\x8c\xc4\xfa?F\xd8\x9a\xee\xd6\x88\xd3\xbf.H\x08\xd8g\xca\xd5\xbfz\\-\xe1M\x8f\x08\xc0\xddA\xad\x8e(\xbf\xe0\xbf\xdcK\xe0~"\x19\xf5\xbf\xd4\x9d\x94\xb0\x0e\xfd\xea\xbfi\x1a\xef\x98@\xbf\xc3?\r\xd0(\xdaB!\x05\xc0\xbd|\xcesn\x06\xf2\xbfJ\x02[\xf6iA\xd8\xbf\xf4#\x9f$J\xbb\xe1\xbf;j%\xb4\x07\x12\xbd?\xad\x84\x8d\x1e6\xfd\xa8\xbf=K\xca\xce\xd8\xea\xf7\xbf\xdc\xa98iO{\xc7?\x12\xaa\x99\x14\x84n\xe3\xbfP\x13\x8a\xfc\x12\xad\xd5\xbf\xb1l\xd5\xf1\xc1\xca\xc1?\xb8\xe8R\n\xf4\xc6\xf3?#\x07\x87\xad\th\xdd\xbf5+\xa14W\xad\x0c@\x84\xd6\xfa\xfd9\x1e\xf4?)\x1c)\x01}\xd3\x04@\xd9\xa9\xbbJzw\x03@\xd8Yo\xa28\xf0\r@=\xe7\xd0[\xe2\x05\x00@\xb9J\x88w\xce\x11\x02@9\xae!\x0bX\xf3\xfd?%\xc1`\x85t\xe3\xe2\xbf\xc7o\x1c\xc3\xdd\x07\xee\xbfHN%\xcb#\xde\xc6?6\x17q\x13\xa8s\xe5?\xbd/\x0e&\x97\x99\xfd\xbf\xe1&Bx&\xf7\xc1?P\x16\x95\xc6\xd8R\xc1?Xx8d+\xc3\x06\xc0\x96\xf8\x1a\xec\x12\xef\xfe\xbf+\xd3\xd3\xdf\xc8\xf4\xfd?\x9b\xaaPjP\x19\xed\xbf\x8eL\x04\xd4I\x8b\xfb\xbf9?\x0f\xb2s\x9d\xd1?O\xb5\xfb\xe1\xc3f\xf1\xbfax\xef\xc4\xa8h\xe5?/D\xb7K\xd3\xff\xf0\xbf}\x92R\xf9!`\xee?0\xafq\xab\x7f\xe1\xf2?!\x7f\x8e5\xd1\x05\r@^3\xba\xa9\xddC\xfc?\r_`\x0c3\x9f\x00@\x0cG\xd4\x0c\xad\x81\x0e@\x8d4\xcf\xb4\xd1\xc4\x0b@hlHw\xac\xff\x01@(H6\x06\xa0\xd2\x00@\x9f9\x80\xb9U\xc0\xf4?\x04\xa9\xebI\x01\xd5\xfe?|\x9e\xfc\xbac\xd6\x00@A\x12X\x00\x9d\x1f\xfa?B#\xf5\xb5\xf5\x8b\xe7?P\xf9B,\xeeY\xcd\xbf6\x1e\x00v\x93+\xf3?\xa3w:m\x03\x17\xd1\xbf\x84\xcai\xcb(\xeb\xd7?\xdaK\x1d\xb6\xd3\x18\xc2?\x91X\xbca\xeb\xc2\xf4?e7\xca\xf8\x1d\xb1\xe8\xbf\xe8ZG\xe7\xab<\xd7?\x93\xc4\x18N\xe3\\\xda?.\x8a\x96\x7f*\x8c\xe4\xbfg\xc0\xd4\x17d\xed\xf3\xbf\t3R^\xf2\x9e\xf5\xbf\x9a\xf7\xb4\xb8\x9a\x82\xe4\xbf\xffqD\xdf-\x1d\xdc\xbf&\xadb\xb4\xf3P\xdb\xbf9\x9b\xfa\xf9\xbf\xf0\xe4?\xdf\x04\xfa!\xe8e\xe8?\x14k\xda\xdfh\xaa\xd0?\xa9\xfbCD\xf9\xbb\xfe?o"\xaf*\xbd\x89\x0c@\xcb#\x83\x9c$\x80\r@\xd6\x86\xedw\xa4\xf9\x01@\xe1\xa2\xf4t~:\x01@o\xf7\\Ow\xda\xf7?\x85d\x87\x01T\xdf\xe1?\xad\x1e\xfc\x07V\x9b\xe6?@\xfa\xf6\x87\xc6\xbe\xed?b"\xf4\x93x{\xc6?\x917JW\xd4<\xf4?\xfe\xed\xf7F\x9bY\xea\xbfZi\xbcv\'\xfc\xbd\xbf\x00\xfe\xda\xd7\xd1\x91\xf6\xbf\x00\x9cPr!\x15\xf3\xbfo\xa0wkL~\xe5\xbfG\x99=~9;\xf3?\xc7\x19\xc0\xbf\xf6a\xd2\xbf\xe3\xf2\x12\x8eI{\x00\xc0\x13t\xbf0\x9d\x15\xe6\xbfk\xd3\xe6\xe8Qg\xf6\xbf\x98\x0c)\x8b5\x98\xf3\xbf\xd0}\xf0\x02\xa7U\xa9?uk\xe5$\xc9\x83\x11@\xcc\x08\xe8\x88"\xe3\xeb?mx\xec\xd7{\xa7\xc6?\x9b\x0c:\x9f:4\xf2\xbf\xa3\x13\xd5\x1b\xe1\x94\xf4?^\xfa\x11\x87[t\x01@\xbd\xdco\xe4^\t\xf0?\x02i\xefdW\xf5\xfe?\xee\xca\x0b\xc7Vw\xfe?9\x12\xba{\x08[\x08@\x88\xa6m\xd6\x00\xc5\xc5\xbf{\xdcv\x7f\x94<\xd3?\x84\xf8S\xc4D\x12\xed\xbf\xf2\xf9\xea\x8f\xb7\xcd\xed\xbf8\xa4\x1d\x00\xb9\x9c\xe0\xbf\x8ce\x8d\\\xc9\xa6\xea?%\x83\x08[Q\xbd\xc9\xbf=,l\xe6\xfae\xd1?\x19\'?\xb6\xc8Q\xe0\xbf\x87`\xb0\xedF\xfa\xe8\xbf#\xff\xb9s\xb0\x10\x01\xc0!\x03+\x10{\x89\xdf?:n\x9f\xa3\xfb\xb3\xc4?Z\xf5\xb0k\xe7E\xf4\xbf\xfaq\xe4\x11\xdf"\xfa\xbf\xae?8\xfe\xbd]\xec\xbf\x85\xd3\xb5{\xf6\x10\xce?(O\xdd\\\x94f\xec\xbfp\x93\xa3Z\'f\xe5\xbf\xbf\xe7\x05X\x02\x00\xf7?\xda\r\x92\xd87g\xca?\xa7\x0e\x15\x97\xf4\xa3\xde?\r\x1a\xa0\x14Y3\xed\xbf%d4\xd9\x03\xd1\xc5\xbf\xb0\x1c\x8d\xbeb\xf4\t@fk\x88\xf6{\xa0\r@`@\xaa\xc5\xe6\xec\xf6?\xa6\xb9X~\xea\xcb\x02@x\x8e=\x80e\x1b\xe8?33\xcf\xf1iB\x93?\x1e\x9ef\xd8\x93\'\x00\xc0\xbbU\xbf\x9cr\x07\x08\xc0\xc2I0\xda\x8a\xdf\xe8\xbfP\xdb\x1b \xbe\xfd\x00@.\xa8\x04\xad\x06\xee\xd4?\x8e,Q\xbbV/\xaf?\xe2\xedc`NL\xff?\x12\xff\x8a\x1dC\xe5\xd2\xbf\x13yQ\xdc\xc0U\xf0\xbf\xcc\xb0\x17\xe3i\xd0\xe3\xbf\x13\xd9\xd8P\x01\xe5\xe1?m\x8dstx\x86\xde\xbf\x05\xa2Y0\xf8 \t\xc0\x05[\x0c\xf7b_\xff\xbf\xea\x87\xaf8\xa0^\xf0\xbf}\xc8g\x187\xa2\xda?vil\x7f\x049\xd7?4\xc9\xa3\xe5L\xe6\xc8\xbfi\xa0f\xd8t\x9d\xe5\xbf\xef\xc4\x1d\xdbG\xc1\xe5?+`\xee\xbf\\\x8a\xed?\xbbB\x9d\x9e\xc2\xb7\xe1\xbf0}\xf6\x18\xd7n\xe6\xbfh\xfd0\x88L\x15\xd6\xbf6\xff\x82:\x91w\xfd?\x14\xb0(\xcd\x06-\xf2?\xfb\xaf\xf8)\x80\xdd\xda?[\x0f\xf7\x169\xcb\x03\xc0\xc31i\xa6\x87e\xf9\xbf\xefYd\xba\xfd\x88\xec\xbf\x95(z\xf14\xd4\t\xc0\x80\xacfa\xe3\xae\xc1\xbf\x86\x1cB\x93\xf9\xa6\xf0?\xe1\xe8-:(\x92\x00@\xde4\x99\x8f\xe3.\xff?\xe1\x80\xf66\xa12\xde?-Z2h\xf4T\xf2?\t\t\x7f&#\x9e\xf8?\x18\xde\x04+R\xa7\xfa\xbf\xa0\x17k\xa1k}\xf5\xbfvP\xff\xdbg\x9f\t\xc0\xd7\xde\xc1x\x8b\x15\x0e\xc0\xc1%O6\x02\x04\x03\xc08\xd0\x16\xd7k\n\xc2\xbfo\xffl\xdad\x8e\xf5?\x10?\xfba\xb7\xb0\xcb\xbfxN\xc7\x0c\xa0\xeb\xe0\xbf~D0\xad\xd9\xb8\xa2\xbf_o;\xcc\x14\xb8\xe8\xbf\x1e\xf2\x81\xb4\x04\xce\xe9?\xc8\xc2m\x1bn\xa0\xc0\xbfw\x04S\x91\xee\x01\x02@\x05}\xe6\x12\x8en\xd4?\xfa^I\x81\xcbC\xf8?1nE\x7f\xa8\xae\xf6?\x0cU_\x10|I\x05@\xb4\xb0F\n\x90\x85\xfa?\x14\x0f\xab!\x8c\xe2\xff\xbf<\x99\xea\xf0\xd4\x9b\xef\xbfZ\xef\xef(\xe5u\xfc?j\xf7\x02\x1f1\xc1\xf4?\x88\xc2Z\nh|\x11@C\xbb\xfe{\x0bR\x0b@<\xc9\x16\xc64\\\xfb?\xda\xcep\xebc\xe7\r@\xdb\xac\x82zJ\xfd\x07@\xea\xccy\xbf\xbfv\xf3?\x93^D\x85\xa8M\xe0?\xfe\xb8\x13\xfe\xe2\xb6\xed\xbfZ\xdeDF\xc8\x98\xd1\xbf\\\xac6\x19!q\xef\xbf\xf5\xa5\tZ`\x9e\xf5\xbf\xf9\xdf\xd7\x06\xa9\x00\xe2?y6\xf5z_\xf5\xe8?\x08\xe6\x86O\xdb\x13\xbf?\x17c\x9f}--\xec\xbf\xc7S\xd4G\x93\x13\xc6\xbf\xae[\xb1$\xabM\xd4?8Y\x07\x11\xfb|\xf4?\x9c\xa4\xa4\xb9\x08\xc0\xfb\xbfi0\xa9\xcd\xc0\x16\xd8\xbfH\xb8\xf5\xa7p\x12\xe3?\xed\xeb]\xa8;O\xf0\xbf\xa0\xcb\x08n\xc0\x03\xd0?\x84O\xff%\x8b\xa6\xe7\xbf\xa0\xcfhJA=\xf3\xbfF\xd9\xe1\xe8Oy\xeb?\xad\xc6\xaf\x81\xfdx\xfa?\xc0\xbb&\xa7\xab\x8f\x0b@)*mv\xb9\x02\x01@\xe5\xf0[\x8az\xe8\n@/\xe7\xb9\xa2\xc7J\x00@{\x1d\xdb\xa0E\x03\x08@\xc5\xa8^\xff\xa2\xaa\x10@\t\xc9-\xfd4j\x11@\xc8\x02h\x06\x1d]\x0b@\xbc3\xbb\xdfl>\xed?Z\xf7i=\xca\x02\xdf?]\xbd\x89\x89P\x17\xdc?\xe8[\xde\xd0\x9e\xce\xd2\xbfk?\xbe\xfe\xd6\xc9\xe0\xbfO/\x03\xdaX8\xd0\xbfS\x1e\t>\x9a\x11\xff?A?^b\x10\xd0\xf8\xbf!H\x1a\xe6\xca\xbe\xdf?\xa99S\xf6D\xff\xc0?\x03\xf2\x8a\xab\x13\xb4\xe0?\xedR\xb5\x9d\xab2\xda\xbf\xef\\\x8b\xc7=,\xf9\xbfO\xc6y\xeb7>\xdb\xbfQ]\xd9\x1a\xcd\xd7\xd6\xbf\xd9\xd6<]Zm\xa9?6Dz\x9a\x03q\xf3\xbfd\xb9\x81\xacIw\xe3\xbf_\x11\xbe\x90\xd6\x8f\xed?\xfa\x85\xe7y\xa7\xac\x04@\xaf\xd3\x90\x97%\xea\x02@\xc9\xdf\xcf\xec\xceF\xf5?\x9a_\xbf|\xc5\xde\x01@\x9b\xc9v\x11\xee\x8b\x08@w\x92\xdeh\x15|\xd6\xbfS\xd8M\x13\xfb\x81\xe8?\xc6\xf5\xc5\xde~-\x05@U\x83\xab\xc8\x7fr\x0b@s:\x8f\x86\xaf\x9a\x04@\xc2\x03R\xb1}\xd6\xde?\xc8PA\xf5Z*\xf9\xbf\xc6\xfc\xd7\x93\xc10\xad\xbfSJ\x18\x15\x07\xe1\xc5?\xfe\x83\x83\xdd8j\xd6\xbf\xa7\xd1\x9dv\x87G\x00@|f\x05\x1fAn\xf8\xbf\xb9\x95\x8ciJJ\xd6?\xe5\xdf\x1b\xfa\x87\xda\xe1?\x8eg\xd0B\xaf\xd0\x05@\xbb\xd2c\xcfn\x8d\xd6\xbf\nMM\xd4\x11\xfd\xf8\xbfRY\xb2L{\xbe\x02\xc0\x85\x1drl\x90\x1f\xcd\xbfSEA}\x1f\xe3\xfd\xbf\xf5\xfeF\xc6=\xe5\x0e\xc0<"4(R&\xf0?\xb9\xba\xe4\x14a\xeb\x04@^\xcc\'\xac\xff\xf1\xf8?\xab\xe0\x1d\xcdS\x90\xc0?*\xdb\xca\xde8]\xe9?\x95\x9c\xcb\x9e-*\xd2?\xca\x0b\xe9\xc3O\xfe\xd6\xbf\xcd\xfc\x95L\xb3f\x0f\xc0H\xe6@\xed\xbaK\xf4\xbf\x0e\xc6\x0b\x19\xbb\xd2\xf0?\x94\x04\'\xdd\xaa\xd5\xf1?\xe1\xda\xbe\xf2\xb4\xcd\xf9?,\x19~g\xd8\xde\xf7?\xd5\x84\xb1\x89\xfb\x82\xe0?\xdd(\x1e\xae\xd22\xda?\xf6gd\\\x9d\x98\x9b\xbfbNfKC2\x02@\xbf\x8d"%|\xd7\x02\xc0\x11n\x99L\xe6\xe1\xec\xbf\x81\xa4h(\xb4G\xed?\xe0\xcf\xdf\x0bqg\xff?\x84\xbf\x00EZ\x13\xf8\xbf\xe32\xeb7\xcc7\xc5?\\\x1e/\xca\xfdr\xda\xbf\xaf$\tp[\xe4\xf5\xbf\x91J\xd3\xa5\'\xea\xea\xbf\xbf\xd7\xfb\x01\x81\xdb\xf9\xbf*\xcb5\x13\xfc?_&\x8c\x06\x1c\xfd\xf5?%b\x08\x1cP\x8a\xdd?\x82o\xa7\xb73\n\xd2\xbfA*t\xbc\t\xc5\xb4?\xc9.\xcb\xe4\x11\xb8\xda\xbfM\xcd\xee\x1d\xd3C\xed?\x1d#\xd9\xc2\xcd\x0b\xb3?A\x13a \x15\x9c\x04@/\xe8\xe4\x9c\x03~\xad?B\xf0\xf7\xc7\xbe\xcc\xe9?\xdaD\x969\'\x96\xfa\xbf\xd0vs.R\x8a\xec\xbf\xad\x96\x8a\x1cK\xde\x10\xc0C\xc0\xf9cYr\xea?\xbf\xa4e(.9\xc8\xbfv\xedj\x06\xe5\xaf\xf4\xbf\x89\xfa\xd9_\xa1\x8a\xf8\xbf\x167\x88\xfc\xcd\t\xdc?\xd8\xc4\xa2\xe5\x90\xd1\xcd?\xe4\x92\xeb\x97\x19\x9d\xed?\xdeL\x80R\x89\xe3\xf7\xbf\x04\x9d\x1e\xe9\xbb\xe4\xdb?\x0bP\xa5\xafsk\xb1\xbf\x1c\x85\x9a\xb97\x0e\x00\xc0\x82\x03\xaa\x11\xa7N\xe0?~\x9c\xf8\x11\x957\xfc?\x02\xe4S\xd3+\x87\xfe?\x9b\x02\x0b\x7f\xa1\xd1\xfe?\xe9\xeb\xec!\x91\n\x01@\xfd\x84H\x10&=\x0b@\x18\xa52\xc8\xca\x06\xfe?\xa6\x07\xf9I}Z\xac\xbf\xd5\x81\xbc\x9b\xf6\xd5\xf4?Q\x13\xa5\x02\xcb\xd7\xf1\xbf\xa7\x02DW\x9d\xe6\xe3\xbf\x15 \xb6\x8b\x1b\xa0\xfd?\xc9\x05"\x01\xd5\x8d\xf3\xbf\xcb\xfdA\x92\xe8\x8a\xf8\xbf\xe2!6\xa6)f\xe2?\x8a\xac\xabR\x12\xc5\xd7?k\x05\x97\x15\xbb\xcb\xe3?\xcb4:\x91-\xcf\xfe\xbfU\x08\xa5pz\xf1\xfe\xbf|x\xd4\xbdR\x9a\t\xc0KX\xcc\t~?\xaf?,)+\xa9B\x08\xef\xbfx\x08\xb8,ij\xc2\xbfz\xb8\xa2D\xcc\xe7\xc4\xbf\xe4\x96\xbb\xd2\x13\xd7\xea\xbf\xfb\x01\xc3s\x96\xbe\xf2\xbf q\xa0\xb0\x0cu\xf4\xbfi&c\xc8\x8d\xab\xca?\x1d\x98\xd1l\x1e\xdb\xe8?\xfe\x11\xc2:\x87\x1e\xf2?\x04\xdd\x9a\x9f?\x08\xf1?\x90\xc7\xbe|\x03(\xda?0\xe1\x9eA0\xeb\xf3?\xd8\xa6\xe5\xe1\x004\xee?\x9f\x13\xfb\xeeEd\xf1?N\xb4\xe8 \x97U\x00\xc0\xccN?J\x81\xd2\xf1\xbf\x16\xd3\xa5pEm\xd9?\xc3\x9c1d\xde\xbb\xee?a\x1de\x0f\xda}\xde\xbf\x9d&l\x16|V\xd9?\x0bI\x18X\xda\xaa\xe2\xbf(\xa4\xe2(\x12\x83\xd3?\xd3\xc4>\x03\x0e\x8d\xf2?\x0e\x8c#\xe1R\x9b\xe4\xbf|\xc6H"\xa5\xec\xc2?\x97\x16g\xefk\xd4\xf7\xbf\xd9|\xbf\xbc\xa9\x19\x02\xc0\x08\x03\x0eF"2\xd5\xbf\x87\x97X\x18\x01\xcc\xe8?\xa9\xde\x97\x82Z#\xd0\xbf<\x85\xc2\x06N\x01\xd9\xbf\x8cY\xdd\xa8\xa2qf?\x9b\xa1\xc4\xc4\x11\xff\xcc?\x8cy\x8d\x94\x0e\x0e\xe9\xbf>9v\xf5\xa2S\xb2\xfc\xbf~\x06\t\xab\xf0\xaf\xf5\xbf\xa6K\xfba\xb5(\xe9?\x884h{\xaf\xdb\xbd\xbfRrhm\xe3\x03\xe0\xbf\x89:\xc3\xc4\x86\'\xca?\xe9\xf5\xc3\xa4\xce,\xfb?^\xb3}\xa9u#\xe0?8:\xea\xa6<\x84\xc5\xbf\x04\x1b{\xaf\xd5T\xde?\xe2\xac\xa1\xfap|\xdc?\xd2\xf87\x95h\xe1\xdc?FA"\n\xfe8\xe4\xbf\x8b\x0e\x90\xab\xea\xeb\x00@Sf\x8f\xd5\x0c\x9d\xe6?\xf1\xb8\x85{A\xba\xd1\xbf\xf4"Z\x1agi\xf3?\x1bm\xb7\xa7g\xa9\xce?\xa1@D\x0b\xd1\xc6\xd4?\x1a30\x97\xb6\xf1\xf6\xbf\xa0,\xfec\x10\x9c\xf5?5\x1eJ\x97\xbdA\xd8?$q`\x04\xdd\x91\xf3?\xc33\xe0iV(\xe5\xbf\xdd1\xe4\xc1\xcc\xa9\x02\xc0\xdd\xe7\xfc\x0etj\xd6\xbf\x173\x1f"\x9e3\xec\xbf|\x12\x16\x83e!\xe0\xbf\x1b\x88}p\xa8g\xf6\xbf\xf9H\x83\x11\xfaY\xbb\xbf\x82\x1a!\xdb\xf5\x1d\xf5\xbf\x89\xd9\xbb\x98D\x08\xcf?\xec\xa4Z!\xb6\x97\xd7?c\xb4`z\xb2\x9e\xea?nd\x1d\xe4\x8f\xea\xdd\xbf\xcf\xf7\xbdJA\x93\xf2\xbfW\xcf\xc4v\xb2#\xfd?b7\xda\xb5\x88\xb1r\xbf\xd9<\xb6\xbd\xea\xb6\xdd?s\x93\xdb\x82\xc2k\xf0?\xd3\xa5\x1aj\xa4V\xec\xbfl\x84\x16>I\xc7\xd4?\xff\x00\x0c\x08\xfc\xaa\xe5\xbf\x9c,\x0c\x16\xf9\xbc\xec?"8qe\xf2\x1c\xd0\xbf\x08\xca=[\x9f\x80\xd9\xbf@w/BK\xd2\xef?\xb5\xd6K\x1f\xc7\r\xb8\xbf*rv\x0c\xfdk\xe4?\xf4\x98\x8f\xf6!\xe0\xe8?\x9e3\x99\xbau5\xe0?\x19o\xb6\xa0\xa8\xd9\xf3?\xf6\x8d\xbc\x0eZ\xe7\xef\xbf94\xa7\x04\x83\x1c\xe9?\x90\xf9\xea\xa9W\x0c\xfb\xbf\x92\x88\x0b\xba\x8f\xcf\xf2\xbf\xe7\xae\x9e\xd5L\x82\xd7?\x0b"\n\xf6A\xea\xda?\xf2v\xbe\xbd\x9aV\xfa\xbf\x10m\x05\x9a\xd1\xf0\xc1\xbfl1\x13\xe0\xdbR\xfb?\xb7"\x8b\xb0K\xf2\xd0?\xb8\xcb\x15\xad\x87I\xf9\xbf\xdb\x10\x85(Y?\xfb?\xc5O\xccl\x08`\xe0\xbf\xf7H\x19\xc4:\xd3\xd3?q\xbeQ\xad1\xe3\x84?\xe0\x15\x0bW\xf5@\xf6\xbfF\x91Eo\xb1\xa6\xe9?7~\x08p\x1a\xee\xfc\xbf\xfd\xbb4\x8b\xe5\xce\xc5\xbf\x9a\xccn \xf9n\xfb?5\xd1{\xf8\x00\xc6\xe6?&b_u\xcfl\xa9?c\x87\xb63M"\xa7?\xa6\xe4\xf9\xf3\xe3\x1b\x01\xc0\xd6\x04\x90$k\xab\xd7?\xba\xb3&ie\xae\xdf?\xb4\xe4\x88Y\x9d\x17\xf0?\xa8N\r&\xa9\r\xc4\xbf\xac\x02/\xecf\xd1\x04@\x04\x1e^\xb7\x9d\xb0\xdb?\xd5\x1c<5\x07\xbb\xf0?r\xf3\x01"=S\x01\xc0V\xaa\xdc\xabD\xd9\xe5?\x0fKi\xd0j\x92\xe6?%Px\x94\xae\xe2\xee?\x9d@(=\xe6\xda\xec?\x00\xc259\x8f?\xf5?\x80\xae\xf7e\x93L\xc4?\x0ea\xce\t\xba\xe0\xb7\xbf\xe1\xdbr|\x88\xb8\xdc\xbf\x14\xc5&7\xdcI\xe0?U\x83\x96\xd6\x05\xc8\xed\xbfM\xd0X\xf8\xd7\x17\xe7?T\xe9\xa7\x8f\x01\xae\xf3\xbf_\xfe=k:\x8d\xd3?\xedQ\x96Ag\x92\xd7\xbf\x9c\x8d?p\xcf\x10\xee\xbfWf[\xbf\xed \xf3?\xe3:iv\xab\xd3\xb8\xbfI\xb5?\xae\x19\x9e\xc6\xbf\x0c\x82A\xb4\t\xf7\xc0?-\xb8\xce\x99$\x86\xac?l\xcae\xdf\xd2\xec?B\xe5\x87,9\xa4\x00@\xff\x08\x12\xb7\x1dP\xee\xbf\x04CeB\xb6Z\x03@\x0b\x91z\xcf\xcd\xf1\xe5?\xd3\xbf\x96\xe9\x91\xa0\xe9\xbf\xd7r\x9f~`\xc3\xdb\xbfivD\xfavD\x02\xc04\xfci\xc0\xe2j\xcb\xbf\xf9\x1d\xef\xfa\x85\xad\xfa\xbfJ\x8a\x9f\x02\xfc\x03\xbb?7_\xb0\x9fF\xbb\xc0?\x90\xca\xa4\x08\xb6\xca\xf5\xbf2a\x01qK\x1a\xf7\xbf\x92+.\xd3<\xfb\xf6?x\xb4)\xe6R\x19\x9f\xbf\xc6\x97\x85\x0f\xb3#~?VF\xc5\xa7jw\xe1?@\xd6F\xcd\x93\x1a\x82?\'\xc5z\x94N\xbd\xc4?\x8cB\xbeqe\r\xe4?\xdf\\\x89\xc7\x9d\xed\xf1?3\x1f\xfbz#\xdc\xd3\xbf\x03\xe2\x95\xc6\x04!\xbb?Oy\x7fD\xe0\x84\xe4\xbf\x8b\xa6(IwI\xe7\xbf\x00Wk1aN\xe3?\xf9"\xb9UZ\x87\xdd\xbf\xc9\xa8\xd7\xbe\x96\xf2\x00\xc0-\xa8\xc6>#\xe6\xfc?(3\xd5\xc0e\x06\xe5\xbf4\x14\xa5\xbc\x12\x9e\xe4?&\x8e\xf8\xd1t\xdb\xea\xbf8\xfe\xda\x92VW\xe6?\xdc9\xd6\x91u\xd8\xee\xbf\x8f}a~2/\xd1?tSE\xb0\xf8q\xe8\xbf\x89\x1d#7v\x8a\xd2?\x13-\xaez\x11F\xbb\xbf\x07]\x94?$\n\xce\xbf\xd8\xc5m\xb6x*\xf3?V\xda\xd6\x86%\xe5\xf5?*\x1c\xa6\x81\xb4%\xee\xbf\xd3\xc7d\x8c\x8d$\xf3\xbfO\x0c!:R\xdd\xc1\xbf\xd6\x1f<\x01\t\x0e\xc2?\xf5\x86\xc1\xaf\x17\xe3\x06@\xce"H/%\x17\xfe?\xffd}\x83\x9f*\xb4\xbf\xc9d\xca(\xf7\x98\xd9\xbf\x14\xa7g/\xf3\xa7\xd2?YP\xb5:Ge\xe1?\x04\x03AT\xf40\xce?\xcd\x92\x8a`/\xd8\xea\xbf\x96Zt\xc5\x14\xdd\xd7?\xfd\xd8\xa2$^\\\xf4?\xe4\xc9\xa3\x14\x15\x12\xe8\xbf\\R\xb82\x1b\xcc\xec?\xf8\x94\xe6,I\xca\xc6?\xc9\xdeM\xbf\x92\x13\xf9?e\xfc\xa8\xa9\xeb\xbd\xfb\xbf\xe3\xb4\x14\xaf\x0b\xb9\xd4\xbf\xa27#P\x1dt\xd3?${\x8f\xb8\x85\xb7\xf5\xbf\x1d\x16\xff\xda\xe4\xcb\xcb\xbf%b\xc2~\x12\xaa\xef?\x19\x13v\x9by|\xd4\xbf4\x15&o\x7f\x18\xe3\xbfz\x01\xb3q\xfd\xc7\xcb\xbfa\x08;\x1e\xca\x02\xbe\xbf\xd9\xb9\x15\xf5^\t\xdf?\x0e\xd0E\xe6\xd8H\xf1\xbf\x8a\xd5\xb8\xb6\x1e\xcc\xe3?k\xd1h\x0f_7\xdf\xbf\xac\xee.\xad\xddt\xf7\xbf\tr\xcbA\x000\xf7\xbf\n\x99\xcd\x1de\xb4\xe1?\x1f\xab\xfe\x1e\xaf\x97\xf4?\xa6g\xbf\xf1\xd12\xf1\xbf\xbf#-\xce\xed\xdd\xec\xbf(e\x82\xfbMs\xf5?y\xc6\xbeSw\x8c\xf2?\x94\xc5\x86\x84\xa4\x10\xf3\xbf<\x1c1Y\xb3\x88\xd3\xe9?\x99\xba\xc1\x1f5m\xe5\xbf\x86\x0e#\x87\x89D\xfa?\x93\xcdW\xfdu\xe4\xbf\xbf\x08K\xe7_H\xbd\xf0?vS8\x0f.b\xd4?M\xcfg\x10\xe8\xc7\xd0\xbf\x15\x89BZ\x06\xe4\xc1?Z\xd0\xb5\xc6\x91\xdd\xe7?\xba\x90S\xc4&-\xe0?i\xf9P\xec\xfbn\xf4?\xb7\x9cF\xc5\xc9M\xf5?\x1d\xb4:)\x9f\x03\x8e\xbfPo\x9eP\xff\xbe\xea?\xc5\xe4\xb2\xf7oI\xad\xbf&f:\xefH\xaa\xe3?!\xad\xc8\x9fF)\xfe\xbfkmM\xf1wW\xc0\xbfRL>=\xb1m\xe2?L\x9f\r{(t\x99?h\x0e\x92\x05\xc9|\xc0?N\x91\xf1\x8f\\h\xf8\xbf<\xa2\x83\xb8A\xd1\xea\xbf\x90R%\x05Al\xeb\xbfm\xd2Z\xfe\xdb\xbd\xf7\xbf\x01o\xff\xc3Zq\xf5\xbfj\xb1\xde5xg\xe3\xbf\xb8\xbb\xda\x95a~\xd8\xbf\xa2+\xd5<\x15\xc9\xf6\xbf&\x14\x1e\x83\'P\x01\xc0\xf8\x9e\xb9j\x1bA\xe6\xbf\x04\x0fb\xf4\xef\xcb\xd2\xbfo\xae=\xcd$d\xbb\xbf\x95\xc2\xfa\x8f\xf9\xbc\xf5?em\x03\x97\x95\x80\xdf\xbf\xb3\x15\xfb(\xe7:\xd6\xbf8\xdcb\xe9\xa2P\xcf?\xc2\xd5V\x9f\xfb;\xf7?\xfa]\x06R\x99\x90\xf5\xbfA\r}\xa5\x04\xde\xf7?\x00\x0f\xa5\x1c\xfa\xf2\xf7\xbf\x0b\xc5\xbe\x18\xb0?\xee\xbf\xdc\x05`\xd2\x07\x80\xc3\xbf\x12\xfd\n\x80\xb4\xd1\xf9?.\xfb\xdeR_\xe3\xf3\xbf\t\xd7\x1cq\xf1M\x06@\x81\x8e\xc5#V\x04\x00@\x04o\x8f\xc1M\xdc\xd4\xbf\xf8\x86\xd6\xe9r\xbb\xcc\xbf\x88kV|\xa11\x01\xc0\x11M\xfb\xb7\xb0\xb0\x00\xc0\xfe\x80\xd6A\xfbm\xba\xbf\xd1)q\x88\xf5\xfd\xf9\xbf\x1bS\xfbLI\xfc\xa1\xbf\xd6\xb9\xa3\xbd\xd0!\xff\xbf\xd22\xc2\xb9\xfc\xc5\xed\xbf\x1b\xfbP\x1b\xa4N\x00\xc0X\xfc"?a\x11\xf5\xbf\xdc)\x90\x7f\x1d\xac\xaa?\xfd\x12b\xe0\x14j\xf6\xbfYD\x10\x15\xdb\x03\xf0?\xe9\xc59\x07\x99\xe6\xf0\xbf\xa5\xbd\xfa\x03\xdc1\xc4\xbf\x16\x1c6\xc8\x8dC\xe0\xbf=\xbaW7\x17f\x02@I\x0c,yP]\xc0?\x8d\x9f\xf9F_\x06\x00\xc0\x07\x9d\xf8\xfa\xd1i\xe3?\xa7\t\n\xaf\xc50\x03@\xa6>\xa8\x16k\xa7\xe1?\xef*T\xbb\xdf\x16\xf4?\xcc(\r\x89#I\xd4\xbf\xddO\xbd\xa2\x91\xb9\xe5?\x95\xdbHh_R\xf0\xbf\xa4\xd3\xdc?l\x11\xa4?\x99\xf2#\xaf\x03\xc3\xcf\xbfN\xe2\xad\xb9\xa4m\xd3?p\xfb)s\x95\xbd\xd8?\xfd\x9b\xa7m\xe0\xf3\xe6\xbf\xca\xbd\x8d\x1e\x8e\xe9\xe6\xbf\x92p\xd0m\x1b\x07\xb8?x3\xb5\x80\x7fV\xf0\xbf\x19\xe3\x98\xc9\xd7$\xfa\xbf\xf7\x91\x03<\x9a\xb7\xd0?\xa6i\xcf\xa4\t\xff\xf5\xbf\x96\xbbjJ\xbbI\xde\xbf\x07a/6X\xd2\xe6\xbf\x10i\x99\xe9=}\xfe\xbf;\xd5\x94\x80\xa0\x19\xc7?\xee\x1c\xc6\xcd\xcfc\xf2\xbft*\xef4\x0f\x9e\xf4?b\xbd\x90CY\xe8\xd4?\x82\x06\xd0\x90\xd8\xca\xf9\xbf\x19e\\\xa3;\xf4\xde?e\xa5\xce\xf5^\x8e\xd3\xbf\x8d,\xe8\x0b\xeb\x93\x03@\xae\xab\xc3\xe4\xca\xba\xe9?\xe6v/?\xfc\xbd\xcb\xbf\x1b\xe3\xf3\xa5j\x17\xff?8p\x85\x1b\x8d\x9f\xf9?\x11\x8f]6%@\xf6\xbf\xbd\xe9.\x95km\xd9\xbfJ@=9`\xe3\xb5?F\xcbS_\xfa\x1b\xee?\xfdh\x85P\x81q\xf6\xbffX\x0czY\x18\xfa\xbfrAl\x1aq;\xe3\xbf\xa8\xd3A\xf9\xa9\xa6\xee\xbf=\xa0\xa5\xa4?\x12\xef\xbf{\x82\xfd#\xdb\xbf\xfe\xbfWo\xcd\xe1Pt\x05\xc00[\xf40\x9d\xdc\xe3\xbf]E\x81\xb1\x86\x18\x00\xc0\xca|`&)\xf9\xf1?\x14o\t\x95\xd15\xef?\x16O\xf8f\x9c\x99\xc1?\xa3_\xb1 \xaaF\xc2\xbf\xd8\x06Z\xcdY\t\xf0?\xa9kf\x1bs\x0b\xda\xbf\xf4\x80(\xe4\xde\x1a\xe6?/Q\xad\x14\xb8E\xa1\xbff\x7f1\xd8\xdd\xf4\xe1?\xae\xc1d+\xf0Q\xc5?\x90\x9b{\x81\x81+\xe7?\xbcY\xa93\x86\x7f\x08@q\x07J\x0b\xc0\xc6\xfa?\xc5\x96\x1a\x98a\xdb\xf3\xbf\xb1j[\xadW\xfb\xe3?\xd9\x9e\xb4\xabo\x7f\xf6?\xbd\xbe\xdb\x8f\x98}\xed\xbfK\xf7q\xfdZd\xfa\xbf,\x8f0\r\xa5\xff\xf7\xbfS\x99\xc8"c \x00\xc0\xbb\x11\xeeO\xad\x90\t\xc0\x96\xb44\xe3"\xbc\x03\xc0\xe5\xfd\xc0$\xf5E\x06\xc0\x18d\x94\\DT\x04\xc0>>\xf9\xdf\xa3O\xef\xbf\xa2\tS)ej\xc1?z\xabh\xb4p\x1f\x0b\xc0+\x02]\x16)!\xf5\xbf\xdd\x83/d`~\xdd?V?\x94\x8c+\xcd\xed\xbf\xcc\r\x0c\xdc\x14\xc3\xd9?\xee\xc9\x92\x94\xfd\xf8\xe7\xbf\xd5\xd6\xe5J7Y\xf1?\xea\xdd\x97\x93\x07\x87\x9a?3\xa6\xd2?f\x1a\xda\xbf1\xdf\xc3C%x\xf0\xbf\xbe\x9eM\xf1\xfd\xb9\xd4\xbf\xae\x8dkd\x04r\xda\xbfv\x9a\xbb6\xd1\xa5\xfd?\xa9\x95\'\xa7)v\xe4?1\x83\xb5\xd1z:\xf4\xbf\xf9[\xfb2~\xbc\xf9?9\x0c\xbf\xb0\x10m\xec?\xf0\x9a\x8c\xf2\x95\xe3\xe7\xbf^\xc9\x19\x03-|\xc0?:_l\xd0\xb9\xa9\xe6\xbfg\xe5\xa0\xe2\xbe\x98\x05\xc0\x0b\r\xfb\x8c\xf7\x88\xdb\xbf\xed\x15\xd1\xdf\x94\xab\xf1\xbf\x97\xb6\xa1\xad\xe8zUzQ\xef\xbf\xd9\x1a\x9d\xe4\xa9\xda\xae\xbf{\x96\x95\xe6!\xd0\x8c\xbf\xaf2q\xb3\xdc\xa6\xe7\xbf)d\xb1*\x88\xaa\xe7\xbf\x0b3T*nL\xf5\xbf%w\xfc\x8fB>\xe4?Q\xf5g\xbd\xaf\xd4\x04@V\x86\xe5\x14\xf1\xdb\xfa? e\xa5R)q\xef?\xe0\x9d\xc2\xf4\xf9|\xeb?\x12\x12B\x16\xda\xfe\xef?\xa1\xa3\x12\xfb\x9d.\xb1\xbf\x12\xd4\x87\xff\xfe\xa5\xe2\xbf\x0b\xa8\xf6\x9a1\x89\xdc?\xd0\xd8\xf1p\x16`\xec\xbff\xf2\xea\xffH\xeb\xb0?z6c\xdf\x0f*\x06@q\x19r\xc4\xfd\xfd\xfb\xbf\x90\xacA\x04\x17\xd8\x89\xbf\x8d\xd7\xb8\xc0\xc6\xf1\xfc\xbfJ"\xf6\xea\x08~\xf2\xbfC\x8a\x81Or\x92\xe4\xbf\x8c(\xb0"\x9d\xe1\xef\xbf\x9aG\x96\xda,\xcc\xc1?i\xcb:\x8av\x91\xe8\xbf\xd9\x18\xd9\xcc\xb5n\xdf?\x0f\xfa\xc6! +\xfc\xbf\x06\x9bcyi\xf1\xf9?\xa3\x81\xa1\x80\x11\x7f\xf5?\x12\xb5\xeac\x99\x86\xdd?\x81e\xb2&I\x16\xcd\xbf\xbb*\xf9\xe3S\xe8\xe5?\x16"#\xa9`\x1a\xf8?\x9b\x967\n6\xc2\xf7?\xa8\xc0Mf\xf7\xcd\xeb?&F&C\x0f\xe4\xd3\xbf|\x99^#\xaa\xbb\xf5?\x01Q\xd4\\\xab\x89\x00@}\xdb\x15\xcaV\xb7\xe0\xbf\xf3z\x12\xb9\x0f8\xa5?a"96\xf3\xe2\xf6\xbf\x02\x84XC\xa2\xc7\xe0?\xae\xa8.V\xa2\xf8\xa3\xbfL\x85z\xfbN\x9c\xe8?\x0ba\xf0t\xc6-\xfc?\xb5\xc4Up\xa9\xd4\xfa?\xc5\r\xc3"Z\xa3\xfb\xbf\xfd_\x1c\xd9\x06\xa0\xcf?\xb1\x9a\xca%\x86\xf7\xe4\xbf\xb8Juz&\xe5\xe2\xbf\x9d\x00\'V\xf3\x8b\xf8?\xf7\x8b\xc5\xed\xc4\xd4\xd2?D\x91\xe27\x15\xb1\xff?\xe2\xf4}\x01\xc1+\xf0?\xef7\x88L\t\xe3\xe5\xbf\x80I\xe4\x0c\xdc\xc7\xce?\xe0\x9c:\xf7\x1a7\xe9?I\xcf\xc5\x00N)\xf7\xbf\xbe\x1fO `\xc2\xe7?/\x16(\xaf\x99\x01\xea?no\xb8F\xa1}\xe5\xbf\x100_Q\x1c*\xd0\xbf\xeb\xfaV\x9b\xdeA\xe9?>Y3\xf9\xe5\x87\xdf?\xd2{J_2\xa4\xe8\xbf\x96_t\xc5\\\x92\xe8?(\x02\xae\x82\xb8e\xe6\xbfb|G\xa2\xba\x87\xec?\xa3\xb9\x14^S\x96\xf2\xbf\x11\x0e6\xff\x19!\xfe\xbf\xa8/\xa5U\x00\xf5\x00\xc0T\x0b0\x91G*\xf0?|\x87m\xbc\xfa\x05\xe5?@n\xbf\xae1\xf2\xf0?s4\x9bQ<\x1e\xfb?\xd3\xdf]\xab\xe6\xb6\xca\xbf\xf4\xb7`%\xe79\xd8\xbf\x80\xf2\xff\xc7p\xe9\xcb\xbf\r4\xd6\x0cyo\xe4?7\x8d\x94\xd4\xfe\xdb\xf2?\xfaN\\f\xb7J\xfe?Y\x91gQkU\xf3?\xcb\x8f\xa7H\\\x1f\xb2\xbf\xd3?\xc3\x8a1\x7f\xd5?4B\xd5{ Q\xe8?D\xd9o{o\x82\xdf?>\xa6\xee3\x99\xc8\xd0\xbf\xa3~\xa6*y\xe1\xc9\xbf\xc4.\x92\xebn\x06\xf4?Z5\xb4\x0b\x90\xff\xe9?\xa6\xc6\xe9\x90S\xf4\xf8?T\x1d\xa0\xa3\xb7g\xfb\xbf|\xf1\xd3\x18\x86\xfc\xe6?.\xad#\t\x99\\\xe6\xbf\x1e\xce\x16\x174\x94\xf7?\xeb\x04\x86\xd4b\x19\xd6\xbf\xb1J\x1e.\xc7\x9c\xee?9\x1f\xc5\xc0||\xc9\xbfq=\xf2}t\xdc\xb3?\xb6\x1b\xe2l\xfb\xb1\xc4\xbf\xb0t\xb6K\xc1s\xf9\xbfk\xb4IR\xe1\xbc\xf2?F\x05\x99\xd4\xfc2\xe8?\xc3?\x8d\xab\xa5\xf1\xd5b\xdd\xbf\\O(\\\xe6\x11\xf4?\xa2\\\x80~\xf9\xe1\xeb?5\x1b\xd0\xc6J\x9f\xa8\xbf\xcf\xb4C\xb5i\xff\xb4\xbfRx\xb2\xd3\x7fw\xe1?\x1a\x1e\xe60\xd7\t\xe1\xbf\xb2\x15\xe88&\xb2\xd8?\xcb\xb6\x98\xdd\x90h\xe8?1\x7f)4\xd8W\xe9? I\x08\x1c\x92\xa6\xf1?\xd8\xb8|-\xb5\x9b\xd2\xbf\xc8#.\xf6;{\xf0?4C\x00c\x07\x15\xe7?c\xc0\x9f\xd4R5\xd5\xbf\xb8\xf8\xec\x1f\xa3\x08\xed?=\x17v\r\xd1\r\xf7?\xfcH\xc7\x8f\x01\xfb\xf1\xbf\x996`F\x13\xf8\xe6\xbf:J~\xfd\x14%\xe9?\xec\x8f\xcd\x03\xc28\xdc\xbf"\xa3\x8b\x19\xd1\xe1\xe2\xbf\xe3G\xd9\x12$\xdc\xeb\xbfs\\\xac\x1c\x83W\xe6?mP\xa64\rO\x9b\xbf +\x82@\xaf\xd0\xe6\xbf\xb8}\xd5`@o\xf3?A\x9c\xee~\x82\xf9\xf3\xbfL\xfd,\x95I\x91\xfd?\xef;\xcdx\xb09\xe7\xbf\'\xac\xb4\xc3Yr\xe7?\xc9\xa9\x04\x99\x8b\xa5\xe7?\xe6\x92\xd1\x96\xb0\xd0\xd7\xbf\xe94\xfc\xc3\x12\xfe\xf2\xbf\x0b\xc1&\x94[A\x02@U\xaa\x96\xc4\x8c^\xe9?\xd14\xb0T\x86<\xd2\xbf\x85\xfft\xe5\x8b$\xf0?\xa2T\xbf^(3\xdb\xbf:\xfa\x9f\xa3\xa4,\xf8\xbfz\xdbU\xf9\x1a\xd6\xd0\xbf\x08\x92\xb3\x8f&\xdf\xf9?\xff\xf77\xcd\xfc\xda\x01@\xba\x7f^\x064}\x07@\xd2s[=\xa9O\xfb?\x1dv\xf4\x83\x86\xa0\xd8\xbfX\xab\xcdD\xd9)\xfb\xbfr\xf0\xc6\xe3j\x0c\xe2?\xb4;X?Qe\xcd\xbfx\x0f\x01CT\xd3\xda?\x19\xabc\xdduX\xe5\xbfG\xb5\xab\xdbta\xf6\xbfV\xf3\x8c\xa1*"\xcc?\xccw5\xcf\xe5@\xa1\xbf(\x04\xf5N\xde\x99\xe9?\xd3\x1c\xa7s.\x9d\xee\xbf\x8fW#\xc6FG\xf1?\xfd\x17\xf7{\x81\xcb\xf1?\xa2\x1c\xc6\xd0\xfa\x82\xed\xbf\xe0\x96>zLf\xa6\xbf\xe6\xd1\x10c(\xf5\xd0?Q\x1cs\x1f\x83\x0b\xf1\xbf\r]\xbd6\xdc.\xf7\xbf\xe9\x9e\xbe\x94\xfa0\x02\xc0\x91\xc9\xaa\xe4L\x08\xe5?l\x91\x1a\x81{\xbe\xfe?0\x14\xe4\x89{\xda\xf1\xbf\xfc\xb1\xb4\x00B\xe6\xcd\xbfV*\x03iZ\xbc\xa7\xbf\x87\x93,[\xb8H\xc4\xbf\x80\xf0M\x9d\xe0^\xe0\xbfq\x04\xf5\x83\xb3m\x01@\x8b\x1c\xb8\xf7\xbf\x97\x03\xa6\x155\xd7\xf6\xbf\xd5\x9f\xe7n\xe3;\xd5?\xd2U\xa0M\x03\x96\xc4\xbfv\x86zm\xad\x8d\xff?\xc1\xad\xd6\xf9K\xfe\xfe\xbf\xb9\r\x83\xc0\x7f\xcd\xf2?b$\xd3r\x01\x84\xd3\xbf\xe5\xd3\x11J\x80C\xfc\xbf\xbe\x06\x19\xed\xf6?\x88D>P\xd2\xcc\xff?\xfb\x99\xea\x8b.$\xf1\xbf#\x1aev\x07\x1f\x02@\xb2\x028(\x17\x83\xf9?,\xfa3\xf8\xeb*\x02@S\xcf.i\xe1z\xe9?"\xb6\x9e\xbb\xe1\xf0\xd4\xbf\xae\xced\x97\x18Y\xd5?{\x1fj\x8a9\xff\xf1\xbf\x07\xa5K\xb6\xa5\t\xfc?E]\x8d\x88\xc6\x02\xbc?\xb2\xb2\x81\xa52h\xe2?\xe8)\x16\x0e\x02\xdb\xe4\xbfz]k\xc8X\x8a\xe3\xbf>|\x99\x80.\xc5\xea?~\xe0\xf1\xe5\x9f\x19\xf0?@Sm5\xe4\xf2\xd6?A\x15\x82)d1\xd4?\xc5\x97D\xbcj\x8e\xf0\xbf\x17P\x14\x0f\x00\xf7\xfa\xbf6!\xaeFhC\xf2\xbf\x96lQo7\x05\xe5\xbf\x1a\xda\x03\xdb\xd22\xdb?\x91w\xf0\x0c\xafA\xe3?\xf7\xe8\xcbU\xb9-\xf0?\xe4UM\xe5\xbdv\xc3?\xb3!\xba\x97T\xed\xe5?\xb7\xeb\xeda\x04\x13\xef?\x8b\xc1\x9d\x97D\x19\xe9\xbfm~\x88\xb1\x1a\xb6\xe2\xbf\xf3\x00\xeePh\xe2\xea?\x14;\xfd3`\xc2\x94\xbf\xc4\xf7\xecO\xf5d\x00@C\x0c)\x89\n\x10\xda\xbf\xa7\xce\x10|\x90\xaa\xc6\xbf!\xc9\xc0`8\xab\xab\xbf\xc9\xfcR\x84\xe6I\xe8\xbf\x8a_\x1d\xd1\xbe\xf1\xf8\xbfu\xab\x12\x93\xd3\x0b\xce\xbf\x06\x82\x07\x05(D\xa2?$\xfc\xde\xac\xad\xcb\xba?9Gy(\xf1I\xee?\xdfg\'o\x82]\xd0?\'\xd3H\x15J\xd9\x8c\xbf\x9e}%L\xb5\xb9\xe5\xbf_g\xe4TK\x8e\x08\xc0\xcb\xe3\xe0\xae3\xa7\xee\xbfa\x0b\xab\xda\xd2Z\xd9?\x8f\xb4r]\xa1\xa2\x97?\xdf\xbf;\xcd\x13\x9a\xee?\xa9\x968\x94\x9cY\xe3\xbfd+#\xe4v\xc4\xe1?\xf4\x97\xe7k\x01\xab\xd0?\\\xe9\xc1\xcc\xd8\x96\xeb?\xa5\xa8\xf5E\xa2L\xea?\xbc\xb5\xc3\xb3I\xde\xee\xbf4\x1d+\x9f\xb6\xbd\x06\xc0K\xcc\xf9\x8f\x9ep\xf0\xbf\xcf\x0c\x8aN\x952\xe5?\x91\xce\xb1( \x90\xc9?\x94N\xb3\xe0"\xef\xfb?\xe0~\n,\xaa\xa1\xfe?x\xcb%\xe8}>\xaf?\xe9\x19\x8e\xb6\xfb\xe2\x08\xc0\xde\xef\xaf\x0b\xa7;\xfb\xbf \x82\xfe]\x95\x03\xcb?cH\x80\x08\x1c\x88\xd2\xbf\xff7\xbb*\xdbm\xeb\xbf\xd9\x92\x8f\x92\x0b\x8c\xec\xbf\xae`\xd5\xae\x037\xd9\xbfQ\x17\xfd\xc0\xe6\xf3\xcc\xbfl\xd3^\xbcE\xfe\xd8?#\xf0\xc8\xdc{b\xd5?\xef<\xafu\xcd\x17\xe4?\xa6\x1a\xb3\xca\x19\xc5\xb8\xbf\x15\xc2\x8c\x15%K\x02@\xe7\xbaD\x9a\xf4\xd4\xde\xbfco\x17\xe5,\xa9\x8e\xbf\xf8p\xe8m,\xfa\x07\xc0Fs\x81h\xeb\x07\xd8?\xf9\xad\xc8\xcc4c\xd7\xbf\x0c\xfb\x91\x19 \xa7\xf1\xbf\xd7\xe7\xc6\xddX\xd2\xf4\xbf\x1b\xa1\xa2sO>\xda\xbf|\'\x19\xff\xdc\xf6\xfe?\xc9wO\xa6U\x98\xf7\xbf\xd2T\xd1Y\xdb\x9a\x02@\x1b\x188\xc1\x07\xf7\xdd?\xf8i\xc3\xff\xd2\x9b\xba?\xc8\xbc\x02~[\xd5\xd2?t\xaaP\xc4>\xe1\xa5?!\xbcjo\xc78\xf2?\x97f`\xa0\xc6\xbf\xd0\xbf\xb5\x0c\x1e\xa2:\xa5\xf2?\x1ax\x99r\xecp\xca\xbf>\xc3w\x0c\xfd\x06\x00@@\x9e\xa1\xec\xb0Z\xc5\xbf\nc\x1dF\xafH\xbc\xbf\xea\xa26U\xadI\xe7\xbf\x95\xd3\xe1I\x82a\xfd\xbf\xefP\\{\xf5\xd3\xe6?\xc6\x91\xc5\xc8\x80\x11\x05\xc0r\xcb\x0cj:j\xa3?C\x83\xde\xf5:1\xe4\xbf\x80 \x8f\x96\xa7\x19k?t\xc9\xe67\xd2\xe5\xc7\xbfe\xcaMP\xbd\xc4\xd9?\xf1\x1e\xa7f\xeb\xba\xdf\xbf\xe7\n2k\x8a\xee\xdf?w\xed\xd8\xaf\xf11\xac\xbf%16\x98i\xb4\xf2?\xe1\x10\x15B6\xff\xf8\xbf\x1d[\x8e\x0ed\xb8\xf1\xbfZ\xa3W\xa5\xc9\x16\xc7\xbf\xff\xcb\x0c\x06=s\xe9\xbf_IbB\x13n\xdd\xbf\x81OlY?\xb2\xd1?\xcb\xda\xff\xa8\x1e\x91\xb4\xbf\x1cH\x8b\xe0n\x12\x00\xc0_\x07\xd4\x86\xaa\xfb\xef\xbf\x95~\'\xe5\xbd>\xc4?\xc9\x89\xc2\xf6<7\xf2?oU\xf5\xc6\xfd\x8b\xec?\xb6[\xc5\x0eAO\xf5?\xabr\x1e\x1e[\x0c\x00\xc0\xe1P6?\xc9}\xf0?\xc4S\xa6\x9a\xf4q\xe0\xbfC\x17Cp\x85Y\xee\xbf\x8c\xb1\x13\x1a2<\xc8\xbfQb-\x16\xc9\xb7\xf2\xbf\xac\x8c\xbc\xe1|%\xea\xbf<\x19h5Y/\xe8?4\x06\xb0\x99\x18\xb0\xd5?\xb93\xa4\x83\xf9c\xe2?\xdc3\xaex\x81\xe9\xc7\xbf\xa0\xae\x05\xff\x17\xbd\xd9?\xb3[L\x95H<\xd7?zs\x98R\xe5K\xa9?\xa3\xd9W\xd3\xb1\x0c\xd8?\xb1\r\xef\x87T\x90\xb7?DR\n\xa0\xb9i\xe7?\xba\x1f\\w\x02~\xfd?q\\(uM\xd0\xa9?\x88\xdelz\x1a\xcc\xf4?\xee:1D\xf4;\xf3\xbf?l\xf3\xe5\x19U\x01@\xc3\xac\x8ej\xa0/\xf3\xbf\x12x\xbb>\xd7\xf5\xea\xbf\xd7\xf0\xc5\xbc;\x85\xf4?\x82\xdc\xa4\xe8g\xc0\xe9\xbf\x90\x17\xa5\x90\x9c\xd3\xf9?NJ\x112\x1c\xe1\xd4?C\xebm_\xab/\xd8\xbf$\xca\xa8\xee\x9d)\xec?\xe9\xb6u\xd0\x17=\xd0\xbf\x96\xdfq\x17\x03-\x8c\xbfy\xd9\x0bP\xf04\xa3?\xb2\xe2\xfb\xc2dW\xf3\xbf#\x84"\x11\xc9"\xd4?\xee\x8a3p\x92\xd9\xb2\xbf\x9d\x98}\xf6\x99\xca\xd2\xbfs4\xd9\x83\xc2\x9c\xe2?\xa1_m\x07\xd7\xae\xf2\xbf\xd8\x17\x95I\x0b\xf1\x99?\x81)T\x03\xf2\x00\n@\x03L/\xfd\xa2\xd1\xcb?k\xc5;\x1b\xcc\x96\xc8\xbfv\xc4\xd8\x02\x8d\xc3\xf8\xbf&\x01\xe5\x87\x93\x0f\xc3\xbf\xa8\xb9\x9d\x90\xc3\x1a\xe7\xbf\x84\x81J%\'\xa0\xee\xbfK\x82\xd7\x1f\xc1\x1c\xf2\xbf\x9f\xf0\x95\xcc\xb4\x87\xd0\xbfep\xdb\xb1!\n\xfd?\x07\xd7\xa4\xfa5h\xd8\xbf\x9bI\xb51\xa0z\xe7\xbf\xc88\xc6\xe3\x9a\x07@{M\xdd\xbb\xfa0\x97?\xbeR\xe9\xf6\xd6f\x01@\x13\xe8\x98\x8f\x06O\xe9\xbf\xbe \x18b\x82\xaa\xe2\xbfx\xb8\x7f\x84\xdcW\xf9\xbfv\x14\xf2\x02\xa1J\xe7\xbf\x1e\xc9\x83\xb9\xe9s\xf6\xbf-}\xdf\xb2\xad\xab\xef\xbf\x81\xe7\xf1H\xb9\xb4\xfb?\xa0\xdfj\x1c\xd0\xd8\xf0\xbfHj\x82\x8e\x10\x1f\xef\xbf\xdc\xed<\xee/\xf0\xe6?\xf1Q\xe3\xb4\x10\xd7\x08\xc0\xb5\xfb\xe3\xf8R\xb8\xea?\'\xd6\x17\xc07\t\xe2?9\xe4\xd2X\xb6u\xe4\xbf\xf5i\xbb\x8fs\xb8\xf8\xbf\xeenO \x1e\xc3\xeb\xbf\xcfS\xd7\x19\xd9\x91\xe0\xbf\xf5\xa6o\x00\x86\xfb\xed\xbf:\xfe\xa0\x040\xa1\xeb\xbfO\xe4R\x8e%s\xf6\xbf\xe7\xbb\xc9\xe0\xf5x\xc4\xbf\x00\x13\x816.\x82\xfe\xbf\xe6\x89.h\x13<\x00\xc0\xbb\xedY*E\xc3\xe6\xbfF-X\xd7Z.\xfb?y\x1a`g,2\xfc?I^\x92s\x13{\xf0?\xc5H\xef&\xdf\x82\xfd?]\xd1u\x18\xbeo\xb1\xbf\x1c\x123\xb6 \xbd\xdd\xbf\xa3\xa2\xd9\xb8\xd6\xfb\xc6\xbfHd\x18\xde\x07\xfb\xdd?\xe46\x92\x12\xc6\xb5\xd1?\x81\xb8\x89\xc7\x01\xc1\xe0?\x8f\xa22$\xd1\xf7\xf7?Z^?\x9b\x80\xef\xf4\xbfy\xd5`y\xe4\x86\x89\xbfS\xa82\xe9\xce\x9d\xf7?F\x93\xd8\x14\x16\xb0\xde\xbf&\xe3\xe2w\x13\xb2\xc8?8\xaaCI&\xa8\xef?\x1b\xa9w\xad}Y\xc4\xbf\xe2\xdc2\x89\xaf\xe8\xf3\xbf\xc9\xd4\x9f\xd4p\xc2\xe1?J\xcd\xb6\xbf<\xc1\xf0\xbf\xee7\x1e}\x8f\x83\x0c\xc0\xab\xf3\xed\x19\xa9Y\xc3?\xa0\x08\xd6\xd5\xc7\x9b\xf1\xbf\xf7\xac\xc5:E\x05\xec\xbf\xe2\xdb\x11"\xe2\xc7\x0e\xc0H\x18x\xac6\xb2\x00\xc0Rr\x11o\x8f\xde\xad?YF\xee(\x8cu\xe2\xbfY\xb7\x9a\x1b\xd8\xac\xf3?%\x03\x84B>W\xf2\xbf\xc9\x8c\xf7\x92\xc0\x18\xd8?\xb9kbN7V\xe2?\xcf\xe7\xad;\x0e[\xe6?\x18\x94X\x9b\xea\xab\xb7?\xaa\x88\xbdf.\xa4\xe4?.\xc6\xc81\x91(\xe3\xbf\x03\xcb4?UN\xf3\xbf\xf2j\xa2\x007\x01\xe8\xbfM\x89j{\xd8\xc6\xe3\xbf\xcc\xe7\xf5\x9dtE\x03@\xf1\x15a\xdb3\x82\xe3?Ny\xbb\xaeG\xda\xef\xbf\x9cx\xbfVY\x8e\xfe?\xdf\x8d_<\xd9\xc8\xed?\x8d\x98\xb1\xb1-\xf9\xe4?\x08\xe5`\xdd\xd4<\xdd?\xe5_\xacu\xfdq\x01@,\xdf\xb5\x18\xe2"\xf2?\xdb\xea>\xe8\x99W\xe9?}\xf7\x1d\x17t5\xe2\xbfF>\x18\xefP\xb3\xfa\xbf\xfd^\xf9\x83\x80p\x06\xc0_\xcdcK\xb5\x9e\xf6\xbf\x94\x95#\xb5H\\\xfc\xbf\xe8|\xfd\xf2\x86o\xe0??\xa7J\xcby\x8c\xd0?\x1a\x9b\x926\xa0T\xc4?\xd4\x83\xbd\xe4\xb6\x83\xad?\xfb\xc9\xba\x05\x8d\x85\xf5\xbfk\x15\xabvq\xc1\xec?\xbb\xa3\xc5\xb8[D\xa6\xbfT\xe2\xd4\xff\x99\x8e\xe2\xbf\xbe|UPH-\xf6?\x04d\xf88\xcf\x14\xd8\xbfu\xf6\\;\x1a\xac\xd1\xbfU\xe4O\x9f[\xdf\xf1?d\x92\xb9\x96d&\xf2?"l\xa8ci\x19\xc6?e\x04i\xc1\xaa&\xe6\xbf\x06\xdf\xbc]\x1f7\xef?)7T\x9f\xd3k\xff?\xbf\xcc\xb8\x02n\x95\xe0\xbf\xec\xd6\xd3\xb7\x81p\xb6?\xd4\xbd\xbc\x90c\xfd\xf5?n\xf6\t\\\x1c\x97\xf6?kx\xa9\xe4vw\xf3?5rJ\x95#\x87\xc7?\x96\x8f\xee\x8c\xf57\xf2?\xf4\x01\x1b\xf4:F\x01@V\r\xbd\xc8[\xbb\xe9?\xd6\xc9\xaf\xfd\x82\x9d\xd2?EF\xb5\x11 e\xf7?G\xdcy\x0f\xce\xbb\x01@\xcf;D\xe6\x01\x0e\xe9?\x0c\x94${\xf0f\xf8?\xfa\x92\t\xdc8\xc1\xe9?F\x02\x84a[\xcf\xcd\xbf\xc1\x84\xbc\xaftV\xd1\xbf0\xf0F*\xd6P\xe7\xbf&Dm\xb5\xe3O\xd3?\x80yl\xc2*\xe7\xee?\xc1\xdf\xa7\x90\x84\xc0\xc6\xbfa\xf0\x19\x9b\xb5\x9f\xe9?\x1d\xc0Sw\x1am\xf7?S\xb4\x13\xcbCG\xd7\xbf\xcc\x91\xb3\xeb\x04l\x01@>\xf4w\xeb3\x8f\xff?\xe3\xd4\xca0\xa6\x92\xd1?i"\xdd|\x15^\xc2\xbf\xd1\xc9t\xa8u\xc0\x00@\x0c\x05\xc7\x90m\xf2\xfa?\x93\x8d\x97\n:\x1f\xc2\xbf\xa9X\x9a\x178\xb2\xdf\xbf\xff\xaf\xedr\x99s\xe7\xbf\xc9Wa\xf8:]\xf2?\xd8\xa8\xe4\x0e\x84\x98\xdc?}\xf2\x81De\x16\x0e@Ci\xf2\xa4s\x85\x06@\xfb\xd1\xe1i\xdbU\x0f@\x86g[\xe8`\xb7\x14@#Bm\xf1\x04\xf6\xf3?\x05\xa1\x16\xef\x06W\xd4?n\xd7\x91\xf2\x02;\xf5\xbf\x9bG\xae\xc0\xed\xba\xdf?.\x01\xaa\x94\xd1\x05\xe6\xbf\x9eQ\xe5\xe1\xd9"\xd3?b\x8c\x00\x91\xfb\xf5\xb4?"\x80l\xb4\xd0\xfe\xf0?\xa6\xd7\xf7\x94g\xb9\xe3?7\x17\x93\x02@d\x1e\x1c\xe8\xcdM\xf0?\xf9T\xfa\xbfHo\xe0?\xa4\xcb\xbf\x00\xd3\xfe\xd0\xbf\xfd~l\xfa\t\xde\xf4\xbfg=\x9b\xe9\xa0e\xec?\xe96\xe65-\x95\xaf\xbf\xea\x84\n\x9f\xb0{\xb2\xbf\x15\xd9P\x0c\xdd\x84\xf8?\x1e\xec\x0f\x9d\xe7\x9b\xf2?hNf\xcb\xe1)\xee?`\xb2l\xc8\xe2\x95\xd0\xbf\x12\xe8\xb5\x9a~w\xf4\xbf\xc0\x12\xd2\nH\x15\x03@\x0c\xd16\n_\xe2\x10@%\x8dm\xe7aR\x05@>Uq\xf5w\xb2\xf6?\xf8c\xca\xc3\xa3\x99\xf9?\xcd\xe8\x90\xfd(\xb0\xdb\xbf\r\xdd\x04C\xe2\xec\xec\xbfU\xa9\xf0/C\x1a\xe9?G\xd2.y\x15\x80\xf7?\xe8#O\xd6\x95\x89\xdf\xbf\x02\xb6\xd3.`\xde\xfd?\xf9iCF\xa6?\xf2\xbf,n\xccj\xab\xe4\xea\xbf+\xac\xb9\x84y\xd7\xe4?\xd9\x12\xe5`\x11 \xef?sH\xd1\x17\xb6\xf5\xe3?\xf0h\x16\xbb\x96\xce\xf5?\xe1G[$\\\xd6\xda?\xef\xb8Z\xb9\xcaE\xfb\xbf\xed\xf3\x1d|v\xa2\xf3?\x15Ws\xca\xc5\x10\xf6?\xa6\xe8^\xa8\xed\x1b\xf0?Q1\xf2\xb99c\xde?\xab2\x11\x82a\x92\xdf\xbf\xf5\x8fT\x92>"\xfc?\xca]\xa6aL\xcd\x04@\xc8\x83&\xbcB~\xe8? \xdfaFYw\xcc\xbfw<\x8b\xb8\xce\xb3\x05@6\xa6\xb4\xb2\x93\xfe\xeb?k!\xe9\xcb\xc3~\xee?b\x0e\xee^\x1c\xba\xd4\xbf\x81\x97\xf6\xd0\x8b\xb4\xf0\xbf\x90B+q\xd2.\xe2\xbf\xf2\x82\x82h\xdd8\xea\xbf\x19]\xfa\x92I)\xeb\xbf\xf1\x06\x9b\xb4\xd0\xb3\xce\xbf\x9fa@Lw\x02\xd3?\xe4\xe7\xc7\x1b\xea\xc8\x07@se\xe7\x13\xef\xa4\xe3?\x08K\xe4\xb2`!\xd9?\x92\x9c\xffJ\xc4\xae\xe8?\xf7\xf7\x9c\xbbJ\x9c\x04@\xd7D\xb2+w\xd5\xe6?\xea\x07+\x8f\xb2x\xe3?\x8fF\xc3=\x84\xc3\xe0\xbf{\x8a\xba\\L\x14\x01\xc0E\'_\xaa\xff\xc2\x02\xc0+\xf9.\xc9\xf5\xdc\xcf\xbf\xab\xda\xaae\xfbl\xa6?\xc8\xb1Q \x82\x9c\xc6\xbf\xee\xb6\xd7Vh\r\x01@N\x01\xbb\xc8\x8ey\xf9?\xcdQ\xac\x83t\xe8\xd3\xbf\x92t\xabzL\x03\xc9?\xc8\xa2\xc9[\x08r\xe2?r\x12\x1fQ3\xa9\xdc?\x1cM\x86\x198\x1a\xd2\xbf \xd5Q\xc4\xb4*\xf7\xbf\x07\x05\xc0H}\x14\xe3\xbf\xb2,c\xe2EK\xcb\xbf5\xfa\xed\xbb\xb2\xfb\xf0\xbf\xdc.\xd1\x8con\xe4\xbf*\x96{Pi\xea\xe7\xbf1s|F\xe8N\xfd\xbfc\'S\x8d\xa2\xe2\xe5\xbf\x0f%+\xa4(\xa6\xeb?\x12\xe9wZv\xd9\xe2\xbf\xac\xd3\xd3\xbe;\xe3\xdf\xbfS\xbd\xa9\x18\xb4\x02\xf4\xbf\xab\xc1\xc5;\x86\xb2\xe0\xbf@A\x91 Du\xa0?\xce\x17/\x92\xb5\x9f\xdd?\xa5[hB\xf41\x94?\x1fc\xcc\x96n\xe6\xe6\xbf\xc6\xf5\xbb\x92sY\xf4?#\x93\x89\xaa\x9f\xbe\xc2\xbf\xf8\xa3\xdbQ\x84/\xf4?\xc7\xd4\x9f\xbe\xf29\xee??\xcf\x01\xb3\x0f\xf2\xf8\xbf\xe9\xa3\xbdt\xceS\xea\xbf\xbe\xe6\xd1\xf9r\x05\xf6?m\xe9\xae>Je\xe7?"F\xc9\x9aS\x1b\xfa\xbfG\xbcGi\x9a\xf3\xed\xbfi\xd5\xe0\x90\x8a#\x03\xc0\xe9p\xf0 AQ\xe5?\xd2\xe1S\xe8\t~\xd6?A\xa7\x88\xd7\xcfU\xe8?\xe4J\x0c\xa9\x8fo\xec?\xa7Xt\x19\xdb\x11\xff\xbf\xa1NO\x97\xc1G\xf1\xbfD\\\x02\xc8q\x95\x03\xc0\x80dM\xbbO\xdb\xf4\xbf\xf4\xe4\rW\xee\xb6\xf8?3k\xc7\xadT\x08\xf3\xbfF\xd2\xd3\x83_\xb1\xd8?\xfb\xe5\x87?\xe5A\xd9\xbf\xf9\x8e\xe5\x0e\xec|\xf9\xbf\xb9\xc7\xb3\r\xc6\x94\xe7?R@\xe4\xed\xaei\xdc\xbfG\x1f\x82\x80*l\xe7\xbf r\x19X\xe3\xf5\xf4?\xd7\x85C\xa0i\xc9\xd0\xbf\x98\xdbS\x97\xa8\x8b\xb4?\xc4]\xee\xd7&\xb5\xf9?\xa2\xcc\x94\x11;\xc3\xe0?\xb43\xc4\xb2\xcf\xc6\xf4\xbf\x8d\xaf\x1f0\x94\xc0\xee\xbf{\x0e\x19\xff.G\xee\xbf!\xf3\xc3-\xce\xfa\xe4\xbf\x8aD\x1cD\xf1\x0b\xf2\xbf\xc0j\xd38\x01U\xe1\xbf\x039\xcbw`\xcb\xe4\xbf\x88\xc3p|\xbal\xfb?\xcd\xe3\xea\x8b\xd8,\xe3\xbf\xe3\x80\xf9L;~\xf6?\x88mr\xb0I\xd6\x97?\x8d\n\xb4\xbe\xe9\x1d\xf4\xbf+\xda\xe0\xb3\xdf\x9b\xf0\xbf\xd7\x81\x96C/\xcd\t\xc0\xd4s@\x96\x96\xd6\x98?\x99\xab\xd5\xc0\x1b\x9e\xe2?2^\x0e{\xa1\\\xf7\xbf2\xf4_\x7fge\xca\xbf\xf8\x85\x83\x9b\xddg\xec\xbf5\xfd\x1au\xa5\x8c\xfa\xbf\x00O\xc1\x191\x05\xf3\xbf\x1d/\x9bb\x07V\xfc\xbf\x17\xd0F-\xf4y\xfd?\xc2\xc1nj\x88\x08\xfb?\x97\xf0r\xea\xe4\x8b\xd2\xbf\xe5\xcd\xfd\x924\xda\xfe\xbf_dMQN\x86\xf1?\x8dH\x17\x17\xc1\x13\xb5\xbf\xb3|\xb37\x0f]\xdc\xbf}\x1bbN\xe7\t\x04\xc0\xf7k\x1fN\xe2<\xcb\xbf\x16,k\xd4\xbfg\x00@`$\x8bL\xc6\xbb\xe7?[e\x0e\x1cq\xe0\xc4\xbf\x82?\x843\xc2v\xe0?\xee# \xc8ae\xcc?\xbfT\xe5\xec\xcb\x93\xb6\xbfa\xfcf\x07\xff\x0e\xe9\xbff\xd72\xb3\xd9\xdf\xe9\xbf\xab3^\x87zK\x01\xc0\xa6\xd5G\xf2e\xbf\x06\xc0\xea\x17\xc3(\xf6\x11\xfa\xbf\xcd\x8f\x95\x04\xe7\x87\xf5?.\xce\xdd\xe4q\xa1\xf6\xbf6\x95\x08\x08\xcc\xe5\xe2\xbf\x9d\xa0\x84w\xcd\x93\xed\xbf\xc2\x01\xe8Ak[\xd0\xbf\xd6\xb2N:o>\xf2?!\xf3\x08F\xb1t\xe7\xbf_?r\x8a\xb2\x1f\xd7\xbf\x93\x8ao\x80\x83B\xd7?Bw)i`4\xdb?q\xda\xff\xdfG\x17\xe8?\xb5\\\xea\xba\xccV\xd0\xbfWc\x90\xf5\xcb\x85\xdc?\xca\xa4\xeei\xba\xa3\xb4\xbf\xb1\xf9\x0b\xbat\xac\x03\xc0\xe8CfOJ\xd4\xee\xbf\x12\x97!+\xcd\xf4\xd0\xbf\xedo.\xf5\xa7\xf4\xc8\xbf\x03\xd2~\xb0\x0eC\xf2\xbf~\x86\x9a\x8dPm\xe2?m/c\'\xd3\x80\xd2?\xb7\xce\x84\x1c\xd6\xaf\xf5\xbfw\xcdK\x9c"\x94\xd3?\xd5\xc4T=\x8c\x15\xf1\xbf\xf6]{\xa7\'\x85\xf1\xbf*\xcd!?]M\xf0?\x9b\x9d\xee\x867\xab\xec?*z\x17/\x97\x11\xe4?9\xa4\x16\xf7\xc4$\xd3?>t\xe0\x00\xb9V\xfe?g\xa4\xbeO\xf2\x99\xcf?\x86y\xf7>\x0c\xce\xe0?\xad\x81W\xef\x84\x96\xf0?\xc3It\xbd\xee\xb6\xac\xbf\xcd\x83m9\ne\xd0\xbf\n\xdbN+S\xaa\xe9?\xe5[\xb0\x94\xe64\xcf\xbf{\xaf\xc7\x14LT\xad\xbf\x90\x03 \x13\xee+\xdf\xbfS\xfe\x93Nx\xa1\xf0\xbf\xf5\x07A7\x11\xf3\xe6\xbf\x80T\xe7\xc8\xd8$\xd3\xbf\xb2|fBR>\xf7\xbf2\xe95\x14n\xbd\xfb\xbf\x87\xa2X\x18\x19\xd0\xe0?\x81\xff\xef\xdaH\xa0\xe6?\xf1]lY\xad\x8a\xf4?\xdb\xc9\xc1}\xe2\xde\xe7\xbf\xc7\xce\x80\xdfR-\xf4?\xb09\xc8\xb0\xab\xbb\xe4\xbf\x9e\xbc\x9bwj\x9e\xf2\xbf$y^tr\xb6\xbf\xaa\xeaY\x03\x80\x07\xd6?{$\x14\xbc\xa4U\xea?2V\x86z!\x90\xd0\xbfW\x1d!\xc59\xea\xdd?\xc8x\n\xe5([\xe6\xbf7\x85\xda\xa6\x11\x81\xe3?\x84l\xc9\xfa\xe8\x17\x07@\r\xd7r\x0c\x9e\xaa\xe4\xbf/\xf9A\xb8\x08q\x03\xc0o\x91\xcb\xf2\x94\x7f\xf5\xbf\xdeqo\x84g\x94\xdd\xbf\x0f\x14&\xa9\x1f\xfb\xfd\xbf1\xa8\xf9\xac\xf0X\xe3\xbfE\xba\xd0\x06\x0b\xb9\x02\xc0m\x8c3\xc4\xa6\xc5\xed\xbf?\x0c\x92c@q\xd6?:\xb3\xe3\x13P\x05\xc8?\x9d\xd3\x07ly\n\x01\xc0y@@\xa1!\xdf\xb5\xbfVq\xb2\x01\x86\x88\xee?\x9ck\xc7$\x84/\xf4?7\x16\\\tH\x93\xf6?\x9e4\x13h\xc4\xe2\xe0?:\x1cR\xbb\xf4\x9c\xea?t\x81\xb3\xf4$s\xf8?\xb8\x15l\xee\xca\xb7\xe3?(\xf3\x05\x12Aq\xea?\x86+\xbb5\xd9\xf3\xee\xbf\xedc;\xc0\xe3\x0b\xe1\xbf\xf6\xef@v\xb6\xe8\xe5?\x8fT\x8f\xd0\x08\x89\xe7?\x9d\x91\nm\x035\xd2\xbf\xdcM\x15\x94\xd9\xd1\xe2\xbf8\x87@`\x91l\xe8?\xcc\x1f\x9a\xae\x82\x98\xf7?\x10\\\x9f:\x88\xa0\xf3\xbf\\\x01x:\x99\xf6\xf9\xbfG\x01\x0eXU$\xd8?\xec\xee\x8cdN\xd8\xf2\xbf)\x937c\xcf\xd8\x00\xc0?\xf9^\xb1Hn\xf2\xbf\x99\xa5\x14g5\x00\xf4\xbf\xddk\xa7\xd2We\xf0\xbfc\xab\xdd\x89\x96\r\xf4\xbf\xcb\xde\xf5NW\x89\xf4\xbf\x12\xed\xab\xbc\x16\xd1\xee\xbf\xde\x02w\xab\n\xc7\xea?\x08\xe9+$e\x90\xe2\xbf\xceSH\xf3\xc4c\xe1?\x1d\x12\xe0\xc1\xa8\x11\xe9?\xee\x07z\x8f\xfcF\x00@\x8d8\x02\xf3\x9c\r\xe5?\xe9\x1egL\x83\x85\xef\xbf\xe7\xd0\x00t\x90\x07\xec?j\x1d}4\x84\x1e\xf7?\x8df\x0c\x1fm\x18\xcf\xbf\x0b\x02\xed\x84i2\xe8\xbfi\xd0%\x14.\xb0\xe3\xbfi\xed\xed\xf5\xa8\xd2\xf9?\x8f\x8b&\xe3OC\xe4\xbf\x99T\xfc\xc60\xf3\xa7\xbf+\xb2\xe2P_\xce\x02@\x94&\xdd\xf0\x88]\xe8?,\x0f\xe4\xe2\x12m\xea?\xf8\xbc&K\xb3\x83\xeb\xbfn\xec\x8a"\x0f\x8e\x89\xbfa\x92I\xf7\x0b/\xfd?|\xc9B\xb5c\x04\xe4?~57\xcc95\xee\xbf\x15\xb4c\xa4\x07~\xe6?R\xba\x7f\x84b\x80\xed\xbf\xe9\xc6&reZ\xcb\xbf$\x1c(\xfb\xe6\xe4\xf8?\xeb#E\xa6Oz\x08@+\xfe\x0b\x84Z\xec\xcb?4\xbfD\xe7\x99\x98\xd4?\xe6(\x99\x0b)\xa4\xf2?\xca\xf7\x07*\x8f\x11\xfb?^F\xc4\xd5\xa5\xf2\x96?\x08\x02\xbb.@\x0c\xc7?b\x82\xc9\x93`\x85\x02@\n\xbe^\xf6f\x91\xfe?G\xec1N\xeb\xf9\xf1\xbf`\xec`\xac\xbb\xbc\xfd?)\xc9\xf1\x17H\x05\xe3\xbf\xea\x8ax\xdc\xb2\x14\xee?\xd2\xdb\xdb\xe3dq\xf3\xbf\xe6I\x96W^6\xf8?\xe7R\xe2\x82"\xbe\xeb?\x85\xbb[\xb1\xf0+\xeb?@\xfb\x87q$F\xcc?\xc8\xe1a\x06\xac\x80\xdc?\xea\xa1\xef\x00d\x9c\xe1\xbf\x9aI\x88\xea\xa1P\xc3?\xe4\xb3\xfa\x1aZ\x05\xc0?\x8e{\xa5z\x81\x85\xc1?\x1eZ\xe7\xf6p\xb8\xc3?\xe9\x1e\x0e\x12:S\xc4\xbf\x84\xde\x8d\xc8\x00\xe8\xc2?V\xee\xbcr\xbbV\x00@\xf8UJn\xa7\xb8\xf8?-\r\xc4\xe0k<\xeb?5\x96\x158\xc0g\xf5?\xb1\xed\xd2\xa2\xbd\xf8\xe3?\xf6\x8cS\x7f\xbe\xac\xf2?\x93\xbdN\xbb|\x10\xc9\xbf\xd8\xae\x81\xfc\\e\xf8?^\x992\x96\x87\xe5\xbf\xde;\xf8\xed?\xe5\xa4\xbf\x8b\xbe\xce\x03\x1eT\xc6?[\n=\x86\xc3\xfd\xec?\xc7L\xcd=M\xfc\xca?\x1bn\x192\x82\xc4\xe2\xbfD\x82H\xc2?\xa5\xfc\xbf\x9b\x92IO"m\xec?2\xce\x11\xf2\xec\xe1\xe2?\xe8\x89%\x1d\x0cV\xa8\xbf\x7fN\x1a\xc6\xda\r\xca?\xcb!\x1bJ\xba\xf8\xe1\xbf+\x1b}\x82H\x87\xe1?%7\x1d\x1e\xc3\x7f\xd7?V\xf8\x97\xeeN\x16\xc7\xbf\xba\xeb\xd2\xfa}5\xe6\xbf\x1e\xd1\x1a5*E\xf0?\x05\xba\xefj\xe4x\xc0?O\xc9q\xf6\x8e\xd6\xc7\xbfn\xa3(\xcb9W\xe6?\xbe\xcb\x1c\xc2\xaf?\xe6?\xcc\xc8:Ud\xe7\xb8\xbf\x8d\x96\xa3\x10Yj\xe7?\x16\x9c\x11Bd\x19\xed?\t\xbc\xff\xdc=t\xd5?\x87S\xc8\x07U\xdd\xe0\xbfB]\xec\xd9\x19-\xea\xbf\xa1#UJ\xd4\xfa\x02@l\xe0\xd9\xed\x95\xd4\xd0?\xd2\x03\xc6\xbc\xb0\xda\xf0\xbf\xd8\x8f\xee\xf4\x9c\xbe\xdf?\xdf\xfa\xd2W\xb3\xde\xdb\xbfH\xcf#\x8d\x91\xb7\xdf\xbf\xbf\xec\xab\xfdT\xe8\xdb?\xf1bZ\x1a\xecg\x0c\xc0\xb2M\x1a\x8d*!\xea\xbf\xee([CFH\xeb\xbf\xb3O\xe0s\xb2\xdb\xf3\xbf\xbd\xbf\xd9\xd9M\x19\xff?)[\n\xdd\x86;\xe7\xbf\xd9\xc7\xf0\xb3`t\xe0\xbf\x91\x99\xeb\xab\x8e\x03\xb5\xbf[\tL4\xe29\xf0?\xdbLc\xc0z\xce\x06@\xb1R\x1f\x93Q\xa7\xf5\xbf\xdb\xb6\x9a\x86\x16\x14\xea\xbf<\x97C\xf8\x1b\x89\xca?n\x89\x0b0\xe3#\xa2\xbf\xcb\xa2k\xfdHr\xf5?\xea\x93HE\xf7\xc8\xf0?\xb0\x1f]\xda\xf5D\xd6\xbf\x1dW\x01Jr/\xe2\xbf\xcda\xc2\x89\xb1\x94\xb8?\x85"n3N\xd4\xf3?;A\xe7\xbf\x12L\xcc\xec\x02\x90\xdf\xbf\x02\x03\tt\xad\\\xe9?M\x0e\xa8\x12\xfc\x84\xdd\xbf\x86\xba\x07r@\xd1\xfc?\x96\xc8l\xc7h\x10\xd9?lb-\xf9\xbe\xbe\xed?\xa7I\xf1\x0bZ\x9a\xeb?\xd0\x99#\x12\x85\xdf\xda\xbfr\xdb \x1c\xa8;\xe0\xbf\xa7\x85\xd6\xee_\x1e\xf3?\x8a];\xda\x8f\xd9\xe9\xbf\xaa\xea\xa3\xec\xf6@\xe3?k\xd1\xe68\xa0\xc9\xc2?O\xe5\\\xcb\x9e\x1c\xf6?\xe5\xeb|r\x8d\xce\xa8?\xa6\x81\xc1\x96\x88\t\xb8\xbf\x07\xe7\xc4n\x11\xed\xa5?C\xec4\xe1\xed\xf0\xd4?Kwg\xbf\xa5\xbf\x9f?\xa6fV\xf0D\x0f\xdb?\x0f\xe3\xcd\xa6\xc8\x12\xf6\xbf!t|\xf8\\\xfa\xeb\xbf\xcc4Y\xcbS\xed\xf1\xbf\x1a\xd9K\xb7\xea,\xcf?\x94\x07\xa8!F\xfe\xd9?\xa4\xca\xe0\xaaA\xc2\xff?/"\x170=\x0c\xf9?\xd7\x7f=\xa1\x1aP\xe1\xbf\xa8\x01\x07g\x17j\xfa?\x03\x87\xc2\xb0\xa8\xb1\xf8\xbf\x87\x11\x85\xa7EX\xcd?\x8a\x8d\xc0\x86\x89\xd8\xdc\xbf\xcb!\xcf\xd4\x17\x16\xe5?\xac\xde\x17~f\xd6\x00\xc0#sFX\xb1\x12\xee?C\xc6u\xb7\x1fE\xfb?\xb7IUo}\xb8\xf8?\xef\xea,Bhe\xfb?\xb5.mZp\xec\x84\xbf\xb3\x8dM\xbd(\x15\xea?$\x16\xac$\xa11\xa4?$\xeb\t\x157l\xd1\xbf\x16_\xc9\xff\x0b\xb6\xd6\xbf\x92%\r\x9a"\x84\xf7\xbf\xb6\x1a|0-P\xea?\xd6\xfc\x8e\xe0\t\xaa\x9f?\xbc\x80\xf1\x9d\x1e%\xf8?\n\x9d~4\xd6\xc7\xd5?\x8aeV\xc2Ib\xe6?\x97\xda\x08m=\xe7\xf7\xbf\xbf\x0e\x96Q\xdf\x1a\xdf?\x911\xd1\xcdw5\xe2\xbfF\x7f\xadf\xe7%\xfa\xbf\x936\x8e\xb8|{\xd1?ky\x0bX\xf5\xf4\xc0\xbf\xbe\x1fP\x99\xe5r\xd4\xbf\x95\x8a\xf2\xee\xea2\xe4\xbf#\xfd\x86g\xd5\'\xa0\xbff\xb5\x0c\x04\x12\x89\xc9?\xc1\x84\xbd6\x17\x04\xe6?!\xf7\xa5\xa3\xad\xf4\xcb\xbf\xed8\x7f^\xa22\xcf\xbf\xf9\xee)\xc7\x9cG\xf3?_\xef\x90U\xa3\x93\xe0?\xbf`\xea\x84\xf4\xbb\xb2?q\x97F\xe9\x033\xce?\x19\x7f\xbb~\xa6\xee\xdf?4\x12y\xa9k\xa9\xf0\xbf\xd8\\\xbd\x8b\xd1y\xcb?\xea\xfe\xce\xea\xec\x18\xda\xbf \xa4\x88\xe1\xa7l\xdf?x\x81Z\x99)E\xc9\xbf\xb7\xc9\xf3\xf3\xac\xba\xd0\xbf(\xdf\xcb\xfc\xeb\xaa\xfa\xbf\xfa\xa2\x1e\xb0\xea\x9f\xf2?#&3\x87|s\xdc?K\xeaE\xf8>\n\xd0\xbf\xb3\x13\t^=T\xd0?\xc7\x06\xdam*m\x01@nt.S\x0b\xf8\xcb?\x02$\x15\xc2\x87\xf4\xf3?\'F\xbc\xc2\xcb\xc4\xde\xbf\xae\xea\x9d]1!\xff?9H\xf4\xa5\xbcA\xf6?\x91\xb0-\xeb\xa3s\xfe?\xc2\xd7:w\xc9\xc9\xdb?:\x156m.&\xd4\xbf\x16\x81\xec\xbfNK\x89<\x8e4\xf7\xbf7\xfbh_ld\xcb?nvO\xea9\x83\xfc?^\xf0\xc4.\x1cm\xe3\xbfU\xa5\xae\xb3U\xe4\xb4\xbf\x041\x8c\\-\x90\xe7?\x97\xec\xd4\xf1g\xcd\xf4\xbf\x1dz\x18\xd8y\x13\xb9\xbf\xc2\x166\xc7\xec\xf3\xf2?\xb5\xa0\xc3\x04n.\xf4\xbf\xd0\xf01y\x9f\xab\xe0\xbfa\x96\xec\xf4\xb1\xcf\xca?\xad1R\xbb\xd0}\xda\xbf\x8a\x8e\xc5_\x89.\xb7\xbf\xc9\xec\x17h\x01B\xd2?\x87\x14\xa7`\x143\xd6\xbf\xbf\xec\x8c\n\t\x89\xf8\xbf\x8d\r\xc9i\x17B\xe2\xbf|\xf0\xb2I \xff\xd6\xbft\xa8D\x89\x07\xab\xf6\xbf\xf3\x18[\x83\xac<\xc7?\xd3oM\xae\x08\xe7\xb1?g\xb3\xda+\xbc\x04\xe1\xbf\x85\x14\xf7\xa77g\xfd\xbf\xae\xab\xa3\xd9\xea\xe4\xcc\xbfg\xf5\xcd\x1a\xb06\xf8\xbf\xfc\xbd\x820\x81i\xed\xbf\\\xda\x97zE\x04\xef?\xe1\x0b"\xe8%\x81\xd8\xbf\x03\x9c!\xd1^\x7f\xb7\xbf\xe3E\x91\\\x98\xc4\xe3\xbfm\xbf0v;\x12\x05@}\'\x16\x11\x9aa\xf7\xbf\x8b\xe7xHE\x15\xe4?\xbepO~\xe9\xa9\xd9?O\xb1\xd2D\xd2\xcc\xd4\xbf\xc8\'Bz\xa2\xd7\xe1\xbf9\xceN\xb7\xdd{\xf3?/\x8c\xfd\xb6)\x8c\x01\xc0\xe3\xaf!\xcaV\x0c\xfa\xbf\x1a\x8dz\xf9\x91\xb1\xf7\xbf\xec\xe8\xca8u\xb0\xc0?\xa35\xfa\xe1\xbc\xf3\x00@wZV\xb2\xeb\xf2\xe0\xbf\xf6X\x98\xd0\'\x89\x98?\xba\xc9\x10~\x80!\xdd?\x05\x15\x03\xed\xcfN\xf1\xbfd\xcd\x96\xc6R_\xce\xbf\xa6\x9fQe6h\xfb\xbfj\x07\x85\xd51\xb3\xe8\xbf0\xf3.V\x7f$\xf4\xbfF\xc1\x9b\x13T\x90\xf2\xbf\xa33}\nzz\xe9\xbf\x13Y\x831\xbd\x82\x04\xc0\x99e\xb728\xed\xed\xbf\xc5T\xfe\xe6\x86\xc3\xca\xbfx\xfdZ7\xd5\xd7\xe1\xbf\xd6\x98$\x94 U\x04\xc0{b\xf6\\\xa9\xa0\xf0?\xd6\xa2 \xe8\x84\xe0\xfd?\t\xc6o\xfb\x0b\x7f\xe4\xbf2+ 7z(\xd6\xbfB\xeb\x93|ou\xf3\xbf\xb5\x9a2\x8380\xfa?zWs\x9b\xb3G\x06\xc0\x87\x88s\xf66\xb2\xf3\xbfg\xb5\xed\xe6\xe1\x8d\xec\xbf\xf8\x868U\x1e\x95\xdb\xf8\xbfu\xb3\xe4(Q\xaa\x01\xc0w\xba\x19Q\xf9|\xf0\xbf\xef?\x9a\xa2`*\xce?\xe9\x98o)\xbc\x90\xee\xbf\xad\x16\x92T\x8d,\xf2\xbf\x1a~\xab\xce\x9c\xb2\xf0\xbf\xb1#61qU\xea\xbf\xa4LA-\xd8\xc3\xee\xbf\x06U\x06_\x8f\xdb\xfa\xbff\x07\x9f\xebv8\xa3?\xa09\xcc\xe8\xf7\xe6\xfb\xbf\x889\xa5t\x8d\x97\xf4\xbf\x0c\xe1,\xd0o\xf4\x04\xc0\xdc\x08\x10\x81\x9d\xdd\xd3\xbf{p\xa6\xe1\xf1\xe3\xb0\xbfV\x046\x97\xd0\xe3\xd2?\xac\xaah\xef]\xaa\xdf\xbf\xba\x13\x12\xfd\x0f\x16\xf1\xbfr\x1d\xe4z\x96\x9e\xb2\xbf\xbe\x0b\xfa\x12Ld\xf7\xbf\x90\x98Ir\xfa\xa7\xf8\xbf\x81@\xa9\x05U\x1b\xff\xbf\xa1\xc1H\x96\x97\x12\xb8\xbfg?\xe7\xfb\x9e\xb0\xae\xbf{\x18\xc4\xf7\xeb\xbf\x08\xc0\x85\xb6e\xe7\x9dF\t\xc0\xa8Y\xe7\xc5[J\xcf\xbfxu\x1d\xaa\x93i\xce?\x87\xb5\xabD\x85\xe9\xf2?\x97\xd3\x1dC%\xc0\xd1?\xd2\xfbB\xd4\xc2|\x00\xc0\xd9\x86\xf7a\xf4rm\xbf\xd9\xc2\xd8\x9be$\xef\xbfP\xa7:\x10,A\xf5\xbfa\xac5+\x15O\xd6?\x91\xd7Gt\x92\xd0u?\xd1R\xbccq\x97\xeb?$\xcel\xc3\x95\x8d\xda?\xba\xeb/:(6\xf3\xbfY@\x9fGS\x87\xf2\xbfe\xeel\xc2^\x81\xf2?\x1d\xbcx\xae\xcf\xff\xd8\xbf\x84\xeb\xc4*\xe58\xf2\xbfy\xcfu\xeaV\xa2\xf0\xbfX\x05\x81\xb0\xbb{\xf9\xbf35\xc7\x83\nA\xd1\xbf\x03s\xf2\x98\xff\xd0\xf3\xbfA\x8c1\xed\x99.\xf8\xbf\xd7=\xac\xfa\xf4\x1b\xee\xbf&\xe9;\xcc\x86@\xf0?S\x80\xa6?\x92d\xc9?U\xf0\xd7\xd9\xe8w\x03\xc0[,\x99ak\x87\x0b\xc0l#\xb0CO]\xc4?\x16\xc5\x8e\xdf\\\x10\xf8\xbf{}\xce\xe1K\xce\xf1\xbf,\xfd\xa6j\x89\xe1\xee?w\'\xa3|\xb8:\xf8\xbfME\x7f\xd3\xfd\xa8\xfd\xbf\xfbZ\xef\n\x06v\xe5\xbfj\x03g}?\x87\xee\xbf7\x17\xeaa\xc0\t\x01@\x9d\xfd\x1c$S\xdb\xde?\xd7Q\xe2\x10(t\xe0?\xde\x16\x0c\x01=^\xab\xbf\xb5\xbf\xa1\xe4ZD\xa7?\xae\xdeu\xca\xee:\xef\xbf\x90\xfa\xfc~\xf09\xf8\xbfy;\xfe\xae\x92\xe8\xf8\xbf\xc8_r@\x90H\xf5\xbf\x99$h\xb6\xf3\x02\xf2\xbfx!\x18?\x05J\xb0??\x04\x8e\x02\xa6\x02\xe3?Ik:\xf1\x06M\xdc?w\x02\xe7\x96\xaf#\xd4\xbf\xae\x1c\xe1\x8f\x1ew\xf3?@\xb1s$Y4\xca\xbf\x12\x82\x87\x05\xd3\xf0\xcb?\xc8\x99T\xd0\x00h\x84?l\xce\xd3n\xd7]\xd2?\x9d%4H\xc8L\xfe\xbfWJ\xb8\r\xa1U\x07\xc0\x8f\xa0Le\xd6z\xf4\xbf\xc1%Z\r\xc0\x95\xd6?\xea>\x9am \x9b\xe8?\x05\x08\xb2Y%\xa4\xfd?_\xdc\x00a5$\xe9\xbf\x15\x15\x16X-e\xd0?p\xfa\xfd_x1\xc5\xbf\xc4\xe2\x83\x16W\x99\xe5\xbf\x90\xc4\xf7/d\xed\xf3?\xc7ORiab\xe0?]\x87u\xf7\x97\x0e\xec?\xfb=0w\x0fV\xc1?\xa7\xe9\xa6\xc6\xb7\xf6\xd3?\xcc\xe1{\xe3\xc1\x02\xfe\xbf\xc36\xad\xc8\xf7\xbf\xff\xbf\xaf\x07#\xad\xb1s\xe7?\xa9M\x82y\xe6\r\x00@v\x9b\x9b3nm\xf6?\x0f\xec\xde\xd3\xbc\xd1\xde?\x9aa\x97\xf0\x84\x1b\x01@\xc6\xb4\xc8\xef#w\xf5?4<\xe2\xcd\'\xc3\xe5?\x17|\xa0y\xca,\xe3\xbf\xa9L\x82\xc3-\x00\xc9?\xf4\x87\xd1\x92-W\xe9?8e]4\x1bC\xe7?c3\xd6a\xcc\t\xf9\xbfSV\x1eyZ\xc5\xde\xbfH~\x9eK\xab\x05\xf0\xbf\xd9v\xc667\xdb\x01\xc0FUj\xadQ\x07\xec\xbf\x06\xb5A\x9f\x9e\xaa\xef\xbf\x92\xbc\xa3\xfa\x18=\xf1\xbf\xbe+>ec\x8c\xdd?\x13@\xe6\xd6\x1d\xac\xf3\xbf\x175h\xad|\xb6\x07@e\xd7\xfd\x018=\xfd?\x85\xb0\x1a \xc3\r\xf1?\x90\x0c\xfdr\xbb~\x93?\xc4\rU\xdf\xe7\x16\xfa?.!\xb0\x89wY\xe3?\xfbX\x8aS\xee8\xd3?\xa7\xe3LVL\x12\xeb\xbf\xc1H\xfd\x08\xc3\xef\x07@1\xe7\x81tg\xc4\x08@B\xf4wp<\x9a\xf2?QB\xe3,\xa4\x8b\xdb?{\xe3.\xfa2\\\xed?\xb9\xb3\x04V\x93\xbb\xd5\xbf\x92D%\xef\x1f\xa7\x04@\xdd\xcd\xefn\xd0v\xf8?.h\x86N\xb3e\xe8?\x1e"_dkN\xe1?\xd3\xb6\x8b\xd5\x80\x89\xe3\xbf\xadiaX\xed\x8f\xf1?z\xda\xc2\xef\x0b\xd1\xf4?\xb2\xfd\xb0\xb3\x0b\xaf\xe2\xbf\x7f\x0f\x80\t\'\xe7\xd1?\x81\xc2\x93\xfcAD\xfc?\x97*\xf7\xa6pZ\xf2\xbf[\xa7\xf8\xe5\xd0j\xbd?\x1e\xb9T\xb23\xde\xe3?T_g\x80m\xb0\xd7\xbf;>10\xbd\xb4\xeb?\xa3U\xfc\xb8\x13\x8a\xf8?\xf9T\xfc^\xab3\xf9?\'\x07E\x91\xba\xc2\xec\xbfnL\xddX\xb3_\xf8?\x1bRQ\x9b\x1d\x84\xeb\xbf\x04\n"\xbe^H\xc5?\xdcl\xa1\xa1,N\xdf?\xc1\x8c\xc4\xc9\xd3+\xfc?e\xfc\xdaF\xdc\xcd\xfa?\xd2\xf29v\x01\xc9\n@yo^/\xd5\xf2\xe6?/\xa7\xb5\xdc\xdfN\xfe?\xd1\xdf?\x90\xde.\xc8?\xf1\x9fF(:\xaa\xf5?\xc4w\x05\xde\xb9\xe5\x05@\xbe\x9e)\xcfFa\xf2?mWGa\xe2\xa2\xfe?\x01\x93X\x80\xa7\xf5\xca\xbf\xd4\x8d\xa4T{.\xe1\xbf\xa4\x05=A\xfd\x18\xb8\xbfZtM\x141\xe7\xb5\xbf\xf1\xd2\x07\xe8\x9e\xf7\xf1?\x14\xf9\x88\x1c-\x1d\xe6\xbf\x1e\x8c\xaf\xf2\x80\n\xe2\xbf\xba\x9d\x17\xf5\x03C\xe6\xbf\xae\x17\xb3\xb0\x8e$\xf7\xbf\x8b\xd8n\xe0R\xca\xf7\xbfS/\x9c\xe1\x11r\xf6\xbf\xfcC\x92.\x9dd\xd3\xbf\xecem\x84\xe3\xb2\x01\xc0\x88\nv\xfa\xa7\xfa\xd6\xbf\x0f\xa1~8\xb3\xc6\xd1?F\'\xa0l\x90k\x8b?\'\x82\x93q\r~\xd1?\x89\xc7\x92l\x1c-\xfb?\x97W\xf6v\x0e\xd3\xd0\xbfC*\xa1\x9b]\x98\xf2?\x01\xf0\xa2!XB\r@V\x9d\x10\xe2\x1b\xc2\xf8?V\x94\xc7\xec#5\xa9\xbf\x94^\xc3\x03\xeem\xcf\xbf\x15R\x08\xa5r\x85\xd2?e\x7f\xa3n\x18\xf8\x04@\xc9\xe4\x8cg\nI\xf1?\\\x00a\xeb\x03a\xc6\xbf\xa6\xad\xd8J\xe9#\xeb\xbfO\xb2#\xb1\xa8\xe8\xf0?\x8e4\xdd\xbf\x07\xbe\xf4?\xd2\xd9J\xf4\xfb[\xfb?\xd0\x0b\xdfH\xea-\xf1\xbfRP\xcf{B\xfd\x9f?6N\x92\x15\x19\x0c\xd4?4V\xdfa{/\xc7?\xd9\xda\xfc\xb6!K\xdd\xbf\xd9\xf8e\xa5\xa5\xbf\x05\xc0OB\xb9\x91\xedm\x01\xc0\t\xf4^\x08\x14@\xf0\xbfcc\xa3/\xcff\xee\xbfFj\xe4\x02\xa1\xd1\xdf?/\x80\x948h|\xcc\xbf\xf9\x85\x9bU\x04\xd6\xb9\xbf\xba\xf2\xd5*\xd3`\xff?\x13d\x96\x920(\xec?a\xf6\xeb\x15r\xff\xdb?\x05\xbf\xe4\x05\xe0\x13\xc5\xbf\xf3\x18U\x90H\x1f\xf6?U\xd3DA%g\xf7?\x90\xe6\x06%Nh\xf7?\x1b!\x1e=\xb6~\xec?\x96\xbce\xe9\xe6\r\xf7?^.\xc2\x01h\x1d\xd1?\xdc\xeb\xb4 A\x94\xf4\xbf\x12F\x9ch\xf8%\xf2\xbf\xd6#\xe5\xa9\xc3z\xf6\xbf\x0bBv\x80\x7f\x1e\xf2\xbf\xb8\x87\xce\xd4\xf6Y\xe1\xbf\xa4a\xed\xe3\x87\xa6\xf6\xbfV\xbc~B\xdb\xcb\xd9?\x94\x85rfa\x0c\xc7\xbf\xf0\xbb\xba\xa4^>\x84?\x8d6V\xf3T\xed\xd1?\xad7\xcb\x9b\xfa\xd6\xd0\xbf9\x9d\xeda\xa0B\xe1?,\x98\x0c\xa9\x91v\xf8\xbf\xa1\xdb\x80\xfdy\xeb\xf8\xbf\xf7\xc0\xff\x9cQ\xc1\xa1\xbf\xee\xb9\xfc\x0e\x06\x16\xef?9\xa0x\xd1\x8f\xdf\xe0\xbfi;!\xf8\xa0\x1c\xf0\xbf\x99K\xc4\xcdt\xf3\xf2\xbf\x0b\x7f\x13\x96\xbb\xf7\xd7\xbf# \x9c\xd8\x80\xe0\xd9\xbf\t\xdb3k\xec\x1d\xfc?l1\xd3\x12\xc8t\x06@\xf8\xd2#\xcf\x0c\x19\x01@\x05O5o{\x92\n@\xd7\xc3\xa3\xd51\xbe\xe3?\x02\xcc\xec\xfay\xc5\xf2\xbf\xf1}1S\x05\xaa\xe4\xbfp\x13\x1d\xed\xdb6\xe2\xbf\x07\x9e\xf9\x9f:\x83\xf0\xbf\xe6\xae\x97\xa1\xee\xac\x94?3\xd6mXBPY\xbf\xd4\x94\xd3+V\xeb\xbb?\xa4\xd71+\xdf\xfa\xf0\xbfHp\x916\x95[\xf1\xbf\x9d\x1c!5uy\xa0?\x8c\x88 \xa5\x99\xe4\xc3\xbf\xa17\x1c\x97\x1b%\xd9\xbfk\x86\xcf\'\x12\xad\xab?N\x9c\x9c.d\xdf\x02@2`\xb7\x96S\x16\x02\xc0\x1fO\xa6K\xce\\\x02@\xb9\x8aW\xd4\x1cf\xf9?\xa5\xab\x7f<\x01|\xfe?\xbf\xbc\x14d\xcaW\xf2?%\x00\x7fT\r \xf2\xbf\xdd`$\x05\xb9\xe0\xd3\xbf\x16\x97\xa2\xab+\xc2\xe2\xbf\xec\x99\xcd\xee\xd6\xbe\xf1?\x17\xc1\xc6*i\x89\xef?\xa1\n}\x83\x9f\xca\x04@\xech\xdb\x8eD\x9a\xfc?\xd2\xd2\xbfY\xd9\xab\xf2\xbf\x81E\xb4\x86js\xe9\xbf!y\xf34[%\xd2?1\xb8~\xcb\x13\n\xf1\xbf,\xf2\xcd\xe4\x86\xcf\xf5\xbf\xba\x13*\x89\xe4\x81\xe9\xbfa\xbc\xf52!I\xdf?h\xfa\xc46\xd3k\xd9?,\x11y\xd8\x03l\xa4?\x82%z\xc6\xeaV\xe9\xbf] \xca\xf1\xf32\xdd\xbf\x1e\xf6\x1d\x8bp3\xe3?w\xc5#\xd7O\x82\x84\xbf~A\xe6\xd0?\x19\xe8?\x80\x07\xab\xc0=\xba\xd4\xbf\xd8\xb7L\x94M\x92\xe6?f\xb1EC4\xca\xe4\xbf\xdc\xa4\xbf\x18\x011\x0b@\x0c9\xd8\xb3\x15\xc1\x05@\xbf3B\x92_\xf5\x12@\xdfn\x13\xdc\x1c\xde\x13@\x9f\xd5\x94N\x85Y\x08@\xc6>sSq\x90\x03@K\x88%\xd0\xd1\xbe\x01@O\xa6\xe2\x90\xf6\xdc\xf6?\x81<\xed\x1f?\x0e\x12@\xf9\xf1\x1c\x9bTE\x0e@\xf9\xb3\x90\x88\x03\xef\xf7?\xc2\xa3\xcf\n\x9b\xd4\xe3\xbfV\x11m^\xb8\x87\xfd\xbf6\xf8\xfe\xa2\xe2\x87\xf4\xbf\x8e\xc7\x95\xa6\x15\x1f\x04\xc0A\xfa\xee\x1f\xcb\xac\xf4\xbfA\xe9\xc2f\xf6\x1a\xf2\xbf\xbb\x82\x8a&\xf9\xc4~\xbf\xd2er\xdbKv\xf6\xbf\xe3\x94\xc3\xdcI}\xce?\xf7\xfb\xf4\xfc\xb2\x02\xe1?\xc6?\xd7\xae\xee\xbd\xdc\xbfS\x9e\xb0\xae\xff\x8a\xd7\xbf\xd5M\xc6\xa6`^\xdf?;\xff\xac\xc1#\xfe\xf0\xbf\x88\xf7\x1a\xafa\x0b\xf0\xbfF\xc8\x92B\xea\xf2\x02\xc0\x1aX\x01I\xac\x80\xe5\xbfK\x89\x0e\xb69\x94\xea?\x8e\x91\t\x03~[\xee?\xa90\x08\xb3\xa6?\x0c@\xbe\xc7\xd4\x93\xbd\xc9\x15@\xedtXs\rC\x1d@\xb8\xc4\xb1~WH\x1b@\xbe\x9e\x94\x82\x00#\x15@\xf0\x0e\x8el(<\x14@3\x7f\x0b\xbc\xbfj\x19@@\x8f[A5\t\xd4?|G\'\xdby\xc1\xf9\xbf\x7f\x1fTE\xbd\xc7\xfe\xbf8\xedi\x1aj\xc3\xdc\xbfc\xecW=\xc7\xdc\xe8\xbfp_\xcd\xf1\xba\xfb\xd5\xbf\xaf\x97\xb7\xb0\x17C\xf1\xbf_f.W\xf8\xaa\xf9\xbf\x00\x0c\xcb\xfcv\xb3\xf7\xbf\xe2\x9a\xb9\x0f\\\xb6\xd3\xbf\xfd\xec\x97e\x1c\x8e\xe2?\xebZ_D\x06\x91\x01\xc0\x88#\x00\x0c\xb1%\xe5\xbfx\x91M\xd8\xea\xe3\xc8\xbf\xd2\x8bj\xcd\xf9\xd2\xed\xbf\x18%P\'\x1c#\xe2?\xb0f\x0f\xffYS\xd3\xbf\x08\xed\x1a\xc6\xc6\xe6\xe9\xbf\x142\xd5\xc5\x1bq\xf7?\xcbH\xa5\x8a\xc4\xc5\x04@\xf3s\x0c\x85\x1bU\x00@\xee\x8f\x8c\x14w\xf7\xed?\x8e\xd7\x0b\xc3T\xed\x07@\xa3\x0cI\xadJ\x0f\n@]\xdf\x1eY\x95j\x12@(Z\xb3\n\xc5\xa9\x13@\x02|\xe5\xcf\xa0h\x12@\xced\x0e\xbe^\x99\xf6?#\xc7\x0c\xea\xbf4\xf0\xbf\xd8P$\xe7#\xff\x04\xc0\xf8\x83g@>\x89\xfd\xbf\xa2\xe2\x7f\xe3/\xaf\xe2\xbf\xdd\x9eZ\xd0\xf4\xad\xf7\xbf\xffN\xce\x88\xa9\xcf\xd4\xbf9{jw\xc8p\xea\xbf\x8b9\x9cQ\xa1\xbd\xdd\xbfj\x82\xa5\x80\xa5)\xe1?\xac\xb7\xcf#\xe0\xa6\xe1?\xc7\xb4\xba\x0b\xd5\xd1\xe0\xbf\x0b?\xfb\xd9\x82j\xc6\xbfd\xe6\xc1\xc8\x03\xed\xda?dv!\x04\xe8 \xde?@\xa0\x93\xab\x89!\xf2?\x95\x92\xb9\x18\xea\x88\xf0?\xdaa\xc9e\xcfH\xe0\xbf\x15_\x1b)3\x7f\xdb\xbf2\x95\x7f\xa8\x8f\n\xc9\xbf\xae\x14A\xd5\xbb\x19\xda\xbf\x9f6+GT&\xed?@\xa0_S\xa8$\xd6?2\xcbA\x8am\xe8\xd7?\xe0\x9e\xaf\x00\x0e0\xfd?\xe0\xa9^\x1a~\xb3\xf1\xbfT\xd6\xe6\xf0\xc2+\x02@qP\x1f1\xf1{\xe8\xbfa\xff\xc0;8\x1d\x01\xc0\x8c8\xf0z\x073\xf8\xbf\xf3\xa3\x13[\xe5\x18\xe9\xbfw\xf7\xf7A\x9b\xf9\xc8?k\xd8\xbb\xa5#J\xec\xbf\x95\xb9\x19\x8f\x11r\xe2\xbf\'n\x9aeA\xf7\xaa?EB\xdb\x1dc_\xe1?])\xd9\x10c0\xdc?\xc6X\xb2s\xe5\x9b\xd8?\x83]\xc8\x03x\x0f\xff?j\x1f\xfbjIv\xd2\xbf[\x82\xd8\x1d\xa5\x83\xf8\xbf\x00_\xc9\x0e\xb1\x1d\xe6\xbf]\xa6\xbb\xa9\x86\xab\xd7?\xb6\xec\x0e\xbfS;\xf2?\x9d\x13 \xd7\xc9\x8f\xd9\xbf\x835h\xbf\xcc\x9b\xfb?\xb8\xf5\xefQ\x10:\xd1?\x19>\xf6=,\xbe\xf1\xbf\xe7\xca\xa9\x80`\x03\x02@\x17\x92\x12\xe6\x1e\x9d\xf0?\xb3.\xd7J\x99\xa3\xde\xbf\x04=\x0bG\x94\xf6\xfe?\x06\xb6\xe4U*\xf6\xe2?\x96\xdc\xba\t\x9f\x8d\xe7\xbf\xee&R\x07\x10e\xbd\xbf\x98\x00\xf9\xebRy\x02\xc0\xa3\x07\xbbv\xa2z\xf8\xbf\x11\xbf\xc5<\x9d\xeb\xf5\xbf\xa2\xef\x8d\x8fKT\xf2\xbf)\'\x89\xdb\xdeu\xe1\xbf\xca\xa2\xd4\xf4\xbf\xf5\xed\xa9\xd5\xc3\xa7\xf3\xbf\x1d\xd16\xcb\xab]\x03@\xa0K\x0f\x97\x1c-\xd0\xbf\xad\x18\xc5\xa4\xad\x16\xf4\xbf\n{/\x15\x95\x05\xee\xbfr<\x19\xac\xc8{\xf6\xbf\xfb\x07C\xa5Bc\xf0\xbfJ\x91\x87v@\xcc\x07\xc0\xa5ax\x06\xb0+\xf7\xbf\xf0\xe8\x10yO\xf2\xe5\xbf\xedA\x9fQ\xb9\x91\xd3\xbf\xf5\xb5{\xb0q\x8b\xe2\xbf\x9cG\x12\x8d\x17\xc0\xfb\xbf\xf5\xc8\xfc\x0cm.\xdf\xbf{\x1c\xc8U\xe0E\xea\xbf@\xd6\xdf%\xecd\xfc?\xb2V\x82\xf7g\x85\xd7?\x0c\xc1\x8a\xe6?jG\xb3\x96\xad\xf2\xeb\xbf\x8a#\xc9\x11\xa4\x9b\xe8\xbf\xb5B\xd1\x96D\x8e\xb8?\x08MQ\x1dv\xba\xfb\xbf\xfd/\xacO\x85\xd7\xfa\xbf\x84\xb3\xdbTL\xbd\xd6?\x15\x92\xcb\x8c\xaad\xe3\xbf\x8e\x06\x8e^&O\xa9?\xdb"5+\xb9\xe8\xbb\xbf:]\xe0\x15\xd2M\xf9\xbf,\xe9\xf6\xcc)\xe9\xf1\xbf^\xc8:MW\'\xf1\xbf\xf3\xf8a\xfd_H\xc2?\xc9\xaap\x96\x82^\xff?n-}\x9bb\x11\xa5\xbf\xfa6;\xbc&3\xe3\xbf9\x87H0\x8a`\xd5\xbf\xe6\xbf\xa6\xbf\xb4\x1b\xec\xbfz\xb8\x80\xc5\x8fb\xc1\xbfu\x8e\xcb\xfa\xea\xa5\xed\xbf\xe9\x8fc)\\H\xec\xbfc\x84\xfa \xac\x88\x01@\x06-\xec8\xac\xb8\xe8\xbf\xe9\x95\x8b\xad\xf9{\xe6?\xef0\x92sg\xf2\xbc\xbf\x82\xc3\xb2\x85X\x14\xb2\xbf\xae\xdcK\xae\x13;\xf1\xbfB{N\xe6\x1b=\xf9?\xe8;%\x98\xca\xd4\xf1?!\x80\xaa\x17\xcb\xff\xe6\xbfH\xca\x03\x80\xa4\xe4\xf5\xbf<#\xdf:6\xf3\xf6\xbf\x12\n\xd7\x89\xd0F\xd9\xbf6\x8a\xad\x8f\xbd\xcd\xec\xbf\x97\xd3\xc6is,\x03\xc0\x17v\x01\xdd\x1f\xd7\xf7\xbf\xca\x88&\xd2\x84\xdc\xf3\xbf\xc1G\xe1\xfd\x96\x87\xc9?\xdd\xccq\x14K\x15\x00\xc0\xa6\xbb\xe2-zf\xb9?\xb7]\xcd\xcf\xe2\x8a\x03\xc0m\xe9\x13\x9b\x87\xee\xd7?)#q\xb4hW\xba?$\xdc\xfd\xad\xe1\xa1\xcd?jU~\x87\x1f}\xe8?\xf3\xd3\xf8\xdd\xcb]\xe1?U\xcc\x8b}\xa5\xb5\xe1\xbfH5\xc5&\x13\xd0\xf5?\xbf\x9fg\xef\xe4SD\xa2\xd7\xbf\xef\xfe \x1b\xcf\x1d\xe2\xbf{\x03\xba<\xe8\'\xcf\xbf\xc1\xe6$\x8d\xf0\'\xef?:e\xb4D2\xbc\xdc\xbf\xd0F\xf7pBf\xec\xbf/XE\xa2\xa3\xf9\xed?\x00\xd4\xd1\xfa\xd3\xbb\xf0\xbf\xa4\xb9\r\xa7\xe2\xeb\xcc\xbf\x84.\xb1V\x0f\xf0\x01\xc0\xa6\xc2\xfd\x89Hk\xf5\xbf\x9c]U\xe4\xd4\xe7\xd2?\xe3T\x9a\xd1\xa4P\xd5?*\x80r\xc0\x95\x03\x01\xc0E\xae\x88b\xc6(\xf7\xbf2\xeeK\xf4\xd81\xe0\xbf-t\t\xff\xe5\xa2\xf1\xbf\x16\xf2\xd1\xb9r\xa6\xea\xbf)\xef"r\xcfq\xf0?\xeb\xb0\xf6\x8f7\xac\xd3\xbf\xde\x0b\x0e-\rt\xc6\xbfvf\x13\xda\x1b\x86\xfa\xbf\xd8LJ\xb7\x8d\xd9\xe6\xbf>\xbe\x0f\\g\xe6\xf9\xbf\xfc\x12\xaei\t\xa3\xe3?Za0\xaa\x14C\xf3\xbf\x8e\xd1/\xac\xdc\xc6\xee?!\x17\xa5,c\x00\xe8?\xe36\x82\x0c\xe1\x0f\x04@-\x13\xc5=\x8bq\xe6\xbf\x00\x1fM\x0e\xed\x04\xe3\xbf\x99w\x82\xfa\x8dQ\xef?\r*F)X\x99\xf1\xbf\xc4\x93;\x19\xc6\x87\xd7\xbf\x95\xf2\x7f2\x96\xd4\xf2?\x93\xa7\x1bo\xa9\xd1\xec?\xe9{\xbbb\x8a\xca\xeb?\x04\xbaPJ\xba?\xc5?\x0by\xeb\x93\xcez\xb4?\x0bN\xb9:3\xb4\xe5\xbf\xcc\x8e\xfb\xd4\x0f\xc0\xeb\xbf\xd8\xa6B5\xda<\xe6\xbff\xd1\xc5Y\x86\x17\xf6\xbf0\x83\x1c\'Q\x03\xc2?{\xc5?i\x9e?\xd8\xbf\x89]\x98\x7f-\xd0\xeb?]Y[\xbc\x92\xd6\xe2\xbf#!\xb0\xb3\xfcm\xe1\xbf\xcd\xf2\xac\xec|?\xf0\xbf\xa0\xb1@v\xafI\xf7\xbf\xa3V\xe2\x04V(\xe4\xbfy>\x03\x96\xf6\x00\xdd\xbf]\x90\xb2\xc6^\x14\xea?#\xe3\xd7l\x90\xc0\xdb?\x8d\xfe\xef\x98\x06"\x03\xc0Fa3(\xa7\xcb\xe9\xbf{C\xd35\xd0k\xf5?D\xa7\xafL\xc7\x06\x01@\x19\x13\x94\xf6 \xd4\x03@\x86\x7f\xa2\xa4\xb5\xcd\xe9?\xc8\xbf\xa7\xe3\x1aw\xf5\xbf\xf6_2\xfd\x7fH\xb6?;\x8c\xe9\xfc\x03q\xee?\xf3a\xa0\xdd\x85\xd6\xd5?\xd7\xb25{{\x1b\xe4\xbf\x96x\x920\x073\xf4?b\xec\xf6\x15A4\xeb?\xef\xfds\x13\xbdr\x03\xc0u\x10\xe1\xac\xf5\xe8\x08\xc0\x99\xbf)\xa5y\xc3\xfb??\x8c\xe2\xceT\xd7\xf3?\xb8&,\x04HV\xe0?\xc1\x18\xc5f\xeej\xee?\x14\xc8\xc8\x932\xf9\xf2?\xc92\xef\xb2\x07\xd6\x03\xc0\xc0\x0cE\x01\xec\xa1\x03\xc0\x05\xf5\xab\x8e\r\xfe\xef\xbf@\xf3Y\x15?\x07\xd4?Mg\xd1GcC\xf3\xbf\xfc\xa6S\xc6\xa2j\xed?\\\x87\xeap(h\x01@\xb4d\xb0\x7f\x11H\xf1\xbff\xb2\r\x85\xd8&\xf4\xbf\xa7\x0c\xe1\x8c_}\xf8?1/\x00+\xb6\xc8\x00@\xf6\xd2\xa0\xc7mF\xe1?\xa8\xc0\x15\xc7g\x9d\xda?\x14\xec\xea\x851X\xf0\xbfg\x8ew\x9d\xe70\xfa\xbf\x0c\xeaf\x07vo\xed\xbf\xc4\x06\xc9\x07\x0c\xbc\xdf?\xc7b\xbcZ3Q\xeb?y\x19\x00\x8c\x07\xef\x04\xc0V\x8c\xd3%\xb0\x01\xe7\xbf\xc5]\xdd\xbc\xddW\xf5\xbf\x9f\xf1\x89\xf40\xda\xcb\xbf\x86G^Z\\\xa2\xc0?i\xa8\x16\xe8\xea\xe5\xf4\xbf\x82\xbf\x8ai%\xae\x87\xbf\x939\xb8\x08\xd5\xcd\xbe\xbf\xcd\xf0\xfa\xacyX\xce?\x94\xda\xaa;)\xc7\xce\xbf/\x98\x99\xd8\xd0\x02\xc8?\xf1M\xfd\xf67\x02\xd2?\x9a\xb8Xj\xd4&\xe9\xbf\xe5[a\xe6\x99\xcc\xf5\xbf\xdd\x15S\x19,r\xdc?\x91\x1dU\xca\xec\xc0\xf8?\xf9\xc9\x8e\x0f=M\xd2?\xd3k\xc8\x17G\xa0|?\x12\x08W?\x8c,\x94?\x08\xf3t\x90\xc6\xf1\xe3\xbf\xef\xc8T\xf2\'\xca\xf0\xbf\x19\x11\xd8\xedH \xf0\xbf\xea\xa3\xdd\x90E\x12\xf5\xbf\xc7\xba\xdb\xc6k?\xfa?\xdeB[\xb6\x85g\xc8\xbf-gmF\xb6\x13\xde\xbf\xbf\xfa\'\xe9Z>\xd0?\xc858\xa9\xd5|\xf2?\x85\xcf\xdc(\xa1 \xeb?k\x93\x15xf\xf4\xf1?b\xa8\x08|N\xa0\xf0\xbf\x92M\xf3\xb6\x00\xa1\xb9\xbf\xa3H\xe93$\xbd\xde\xbf[\x1b\xfb\xf4\xf8\x0c\xf6?\xa3_>\xd0\x8a?\xfe?\xf4\x90\xf4F"\xa9\x04\xc0\x02\x84G\x07\xc0\xdd\xe9?\x18E\xd3V!\xd2\xdd\xbf\xf3\x98\xbb\x1c=K\xb7\xbfSE\xdf\xf3\xc0\xc7\xc9?R0{\xbb\xc0\xba\xec\xbfH09C_\xc6\xd2?)A\xd4l\x95\xce\xd8?o\x1dKa\xae\xb7\xf4?\xf5\xd3\t\xfex\xc9\xe3\xbf\x8e\x8a\xa7\xe8\xeb\xd0\xa5?\xb5\xb2\xeb\xb0)\x11\xfc?\xef\xe7\xdc\x96I\xad\xec?}\xbe\x14\x9e|\x8c\xfd?\x1a\x10\xc1])\x8d\xe4?\xf4M\x02xrk\xf0\xbf\x1a\xf73\xbd\x02H\xc7\xbf\xc6U\x01\x88P\x82\xc1?\x0f\x90\x8dS&\xed\xf4\xbf-\xcf\xc7=Ju\xf5?\xe3f\xffV ,\xf9\xbf\x8bE6\xd7\x80\x8a\xf1\xbf\x8c\xa3\xbe\xb8fm\xf0\xbf\x14\x01KR\x86 \xf1\xbf\xf4<\xc2\xe7\x7f\xbb\xe5\xbf}\t\xdd\xed\xdd\x00\xfc\xbf\x11|\xf2\x05:^\xb8?\x10zo\x1f/@\xff\xbf\xb9\xd3\xe8$\xf0\xdd\xe8?\t\x91\xf7=8\xcc\xf1?\xe0Z\xf1lY\x87\xf4\xbf\x8d\xbbN?\xba\xcd\xfc\xbf\'D\xb0Hv\x92\xfa?f\xd4<\xefU\x00\xf5\xbf\n\x14.\xf55d\xac?#\xfd\xa2\x12r\x82\xe5?\x0c\xb7\xf4\xc2\x9b]\x00@\xd1\x9e\x1dQ+\xff\xe9?\xa5-z5N^\xf5\xbf\xf6\xb4#\xd8R<\xd9\xbf\x14\xce\xb9\x92&\xe1\xd2?\xa4\x1c\xd5\x9f\xb0\xc3\x00@\xc2\xff\nDM;\xca?\xd1N\xbc\xb9\xe9Z\xee?\x91?Zr\xc5\xcb\xe7?\x15C\xd7:[G\xb8\xbf\r1\xff\xfeY\xcd\xd6\xbf\xa6\xb0Uq5\x99\xee?\xf8\xbc\r(\x08\xfc\xd6?\xb6\nXh-A\xf0?R\xe7\x7f\x9b\x03\xfe\xff\xbf\x12\xef!\x8d\x93\xd1\xff\xbf\xbaG\x05>\x9a\x82\xf1\xbf\xb6`\xa6\xa8>\xaa\x04\xc0#\\\xc0\xa6w\x10\x03\xc0\x96\xf0;\xdab\x16\x0c\xc0p\x07@3\xb6?\x00\xc04M\xcf\xf6F\xfb\x04\xc08s\x96\x10P\xd4\xfd\xbf\x19?\xc1\x0fpM\xea\xbf\xe2>\x99\x8d\xa5-\xeb\xbf\x02M\xa6\\R&\xe7\xbf\xcc\x9f\x0e\xcdJ\xd5\xea?,\xb7\x9cxb3\xbf\xbf\xde\x025[\xb6\xd2\xd8?\xfa\x8d\x0eq1\xfd\xd9\xbf\xeaW\x9cd\xfbf\x04\xc0\x86\xd2\x0f\xef?a\xf8\xbf\x1c9\x84/\x00\xcd\xd1\xbf #g\x96\x0b\xb9\xf1?.\xa8\x8c\xfd\xa79\xb3?\xe1?UY\xba\x12\xd0?@\xd5\x857\xed\x1b\xd4?Gqo\xaf\xedj\xe8\xbf\xd3\xf8\xd8\x8f\xda<\xee?\xba\t\xc0r\xedT>\xd5\xde\xf1\xbf\xeb\x8a\xcf\xfa\xadz\xe1\xbfAxzAU[\xfa\xbf\x96Tm\x90f\xa1\xda\xbf\xe3\xe2\x97\xe8\xe5N\xed\xbf\xcd\x1c\xef@U\xdf\xf0?\xedh\xf1\xb9\xd8_\xa6?U\xb9XV\x9a\x94\xf0\xbf\x81(\x9b\xce\x92\x17\xe4?\xc5B\xc8?\xae\x1d\xc9\xbf\xd56\xadJH\x95\xf9?zr\xa5\xec\xc4p\xdd\xbf\x13I 7\xed\xb8\xd9?\x8f\xf5\xbakB\x1a\xb1?N\xac\xd9\t\xf9\x97\xd5?\x1a\x8b\xfe1\xe5\x0f\xd0?\x0fWv>5\xa8\xfd\xbf\xb5b2\xe8\xe1\n\x0c\xc0\x0eH\xdc+\x0c\x8d\xb1\xbf]\xc3\x1b\x0fp\xa5\xc5\xbf\xc4\xb9\xf4\\\xb2"\xec\xbf\xe2\x89\xe7\xe8\x0c\x8f\xef\xbf\xb7\xe3$\x99\xaf\x10\xb4?8\\\xf5t\x9bJ\xb5\xbf\xf1Y\x9d)\xa0\xb9\xfd\xbfV\xe3\x84,Q\xe8\x0b\xc0z\x82\t\xa8\xf7\xd1\x08\xc0\xd5\x12\x93F&\xb9\x00\xc0\x91\x97\x1f\xe0\xf2J\xf0\xbf\x04\x13\xc8\xff\xffY\xe0\xbf\xd7H\xc6,\xc9\xd0\xea?\x15\x0b\xaa\x85\x08\xfb\xb0?O\x00\xb6\\G!\xf2\xbf$\x95\xcf\xf0\xef\xc5\xd3?\x9acw\xf1\x9dg\xf9?\xfcz;^\xa5M\xf2\xbf\xcbL\xd6\x1a\xf1H\xf0\xbf\x17\x00\xe7h\xb4K\xc1\xbf\xff\xdd\xb0~\xf5c\xfb?\\\x99O\x02\xa00\xd7\xbf\x9d$\x93\xc973\xeb\xbf\xbci\xc2+.\x1e\xd0\xbf\\\x01\xcb3\xbc\xd4\xbc\xbf\\\xf7;`%\x08\x05@\xedW\xb0F\xf7g\xd6??\xe5\xdfqN\xc1\xae\xbf\x98\x92\xa06\x99\xdb\xd2?Wj\x1eB\xbc8\xd6\xbf\xb3\xf4\xec\x06&G\xfd?\x1b\x92C\x17\x13\x03\xfb\xbfJ\x87L\x9a\xecH\xee\xbf\x0c\x83<\xfe\x00\xf5\x04\xc0/.T\xb9\x81\x19\x07\xc0\xdbO\xc6@\xb04\xb1\xbf\xa0\xe2{\xa7r\xb3\x02@\xb0\xfbhP\xd1\xd1\x0e@_\xac\xee(\xc5\x9b\xf3?\xad\xdaf2\xad\x08\xa9\xbf\xa5\x86\x1c\xfe{\x95\x9a\xbf\xd4\xd5\xc6;\x1c\x9a\xe8?\xa2R\xa8+%I\xef?V\x1e{\x93\xe4Q\xe5?\x08j\xa1w\xb0s\xe5?C3SF\xd2D\xf4?\xa9#;\x0c\x16\xb8\xf5?\xeb\xa2\xf1\xf87\xc4\xdc\xbf+v\xfbJ\x9ce\xe3\xbf\xcb\x12 \x97\x96\xe0\xa9?<\xec\xb8\x052\xd8\xf5?o\xe7L\xe9>\xa6\xda\xbf\x9fR\xcd\xf6\xa3\xf3\xdb?D\x95\x0f\xecu\xae\xe5?\xecZ\xcc\xc7>\x01\xc3?\xa2\xd2\xb1\xd37%\xe9\xbf\xd2\xce\x15\xd96%\xf2?\x98E\xb1%\xd8V\xdc?\x91$\x1d\xfe7\xa9\x05\xc0.\xf7\x0f\xe1\xbb\xfe\xd6?)\x0f\xd4\xcaK\xd1\xd5?\x02\xb7\xf8X\xbc\xa8\xff\xbf\xbcS\xadh\x98\x08\xeb\xbf/\x0f[d\xc3\x1e\x03@z@\x04\xa9\x94\xd7\x16@\xb3\x1b\x99\nH\xf8\xf8?\xa4><\x17\x8b\xb4\xfc?\x98\xb1\x87\x01\xd0\xc3\xfe?\xd3_\xe1p\xd6y\xd6?\xabbW\x88Q\xae\xfe?\x8eE\xcb\xf6\x96\x97\x0b@\xfc\xdb}\xcbq\xc9\x07@G7\x13b\xa1\xa9\xf2?h\xe5\xb3\xedO\x11\x02@W\xb7NB\xad9\xe5?F\xb5\xb1\xd7%\x04\xeb\xbf_\xca\xa2J\xe1E\xe7?\x8e\x83\xed\xbe\x13\x97\xf1\xbf\x02\x8d\x86\xfe\x9d\xc3\xd5?|\x9b\xcd\x17\xc0\x10\xfd?G#\xe9O\x1b\x94\xf0\xbf\xde\xdb/\xd2S\xcb\xd6?\xe1\x19\x1dQ\x95\xcc\xb4?\x99\x1b\x18\x8b\xb6\xb5\xf7?\xda_\xa4Z\xf0\x19\xf0\xbf\xc0\xd1GJ\xf6j\xf1?5\'\xea"\x1d\xe5\xdc?v\xbcC\x8e\x9b\xd4\xfe\xbf`\x8f\xaf\x92\xa4S\xf4\xbf\xf0\xd1\xebT\x13\x04\xf6\xbf\x8a\xe5\x83\xc31\xc4\xfa?\x02S+\xf4\x827\x14@\xa1.\x8d\x94\x04\x1d\xee?/|k\xeb\x06\x1e\x10@3\xde\xab\xd6\x05W\x01@D\xc2B~\xfc`\x02@\'\xc4\xc1*\xae\xd6\x00@\xc8\xc7\xfd\x89\x19w\xfa?R\x7f`\x07}\xc1\x12@*B:\xf8\x8f\xf5\x0c@b,\xaa\xbc\xd7\t\xca\xbfM\'\x88]\x9a\x9c\xe5?\x94\xc3\x82r\xb6\x9a\xe2\xbf\xe2\x06l\xcc\xac\xe9\xd7\xbf\xa0\xea\xc5\xb5{%\xfc\xbf\xe5\xa1\xbem\xd8\xd5\xfb?\x9e`-\xd2\xa0\x15\xec\xbf\xb4\xe1!m\x0e\xf2\xf7\xbf#N\x00\xfc\x89J\xcb\xbf\xd92\x8b\x93\xce\xb3\xe0?\x0b\xab\xcc1.p\xd6\xbfj8\x88\x08\xbb\xfd\xa0?MV_\xb8\x83\xb9\xd2\xbf\xce\xcc\xbaa&\xd0\xf7?_\x99\x9e\xf38\xb2\xe5\xbf\xe5\x9ay\xf17\x15\xbb?\xa9\xb09\xbe\xbfn\x02\xc0.\x1c\x0f^\xad\x81\x06@\xb2\xd6\xb6deH\x18@o\xa5\xd7\xad\xb9\xdb\x10@\x1bF\x97c@\x1e\x04@\x93\xbcx|\xe7\xc0\xed??\xdf&\x02\x9a\xfb\xff?\xff\x06{\x11\x99\x00\x01@5\xad\xa25\x0f$\xd9?W\x90\xdfVn\x1f\xe7?\xbc7\xac>\x8ae\xf6?\x10\x06\xf0,\x8e\x88\xf9?\xf3\xa6\xc6[\x92\xe5\xc7?\xa6\xe3?\x8c\xb8\xc8\n\xc0\xf2t\xaaSX\x17\n\xc0\x1c\xc7\xe6\x98j\xbe\xad\xbf\x7f\xf3\xac\xf7(\xe8\xec\xbf\x11C2\x99\x18K\xed?NZ\xe4p\x9d\x1c\xd5?\x9d\xc0\xa0\xb0\xf6\x1f\xa9?\xc2\xb7\xcd\xc1\xf4@\xcd?\xaa\'EoY\x17\xf1?;\xf9&h`\'\xf4?\xc39\xc8\x00\x8a\xe9\xc8\xbf\xfc\xae\xc2\xa6\x1b\x19\xef?\x89\xc1`\xca\xd5\xd6\xe0?k\xdfG\x8a\x9f\x7f\xf7?\x85/\x7f`M\xf1\xf6?\xebq[\xc1w\x96\xb2?\x01\x90\xfds\xdc\xed\x11@\xf9\xcd!5l\x14\x12@\xca\xa8\xf4\x02\x91{\r@\xfc\x11\xf2\xcd\xab\x8d\xe0?\r\x8f\x909b\x8a\xed?\x13/\xb9\xb5\x1ef\x03@\xeaw\xf0\xc1\xf6\x86\n@4\xf2\xebvp0\x01@%m\xf0\x9c_\xcb\xf5\xbf/\xd8\xf6\x00\xa2\x1c\xfd\xbf\x94\xdc\x8ccvj\xb0?T\x02IN\xc3\x08\xdb\xbf\x1bC\xdf\xad^\xab\xf7\xbf\xe3\x19\xf2[^\xad\xf2\xbf\xc9;\xb5\xe6\n\x9a\xb5\xbf@\x95\xf9#\xc7\xb3\xf6\xbf\xb0\xd2y~\x98\xfd\xce\xbf\x8e1\'w_\x0c\xe1\xbf\xb4\xd0,\xcc\xb6e\xc7\xbfw\x83-\x16\xda\xf4\x9a?\xbc\xc7\x1a\xbb\r7\xc1\xbf\xcd\r\x98A\x9e\xf7\xda\xbf\x86jke\xc0\xa7\xd1?]\xe6\x8d\xc1\x1c^\xfb?\xa6\xed\xfet\x00/\xee\xbf@\x01\xa6\xca\r\x06\x04@\xf8\x84\xd7\xb5\x08*\xda\xbf_\xdc\n\x0b\x97\x1c\x01@.P\xe4\x99*\xb1\x0e@\x19*t\xf3~\x8c\x16@\x11\x1aSy\xc4\xd5\x0c@\x96\x1cK\x0b\xf5\xed\xfd?\x0c\x04\xf4\xf4\xfe\xa7\xf0?\x8a\xab\xa8\x85x\xeb\x01@\xe8\x0f\x06\x1a\x9a\xd6\xfb?\xcd\xa30\t\xe5\xdf\xf5?\x8f\xa6\xf5\xee\x8d\x16\x03@\xfbrDg\xce2\xee\xbftI\x82\xec\x90\xf7\x01\xc0\x05\xa5E\'\xdeA\xda\xbf\xb8\xb4\xb5^\tv\xf8\xbfL\xd8\xa9l\xa4\xad\xec\xbf\xd8\xb6\x93(\x1b\x19\xe8\xbf\xa8\xa0"\x1a\xfc\xbe\xd6?\x1b1\xafJ\xff\x17\xa6\xbf\x1e\xad@t\x80z\xe1?A\xcc\xf7\xcf\xa9\xaf\xdb?FSDS[\x15\xa7?9-rG\xe7\n\xfb?\xab\x9b\x063\xd3\xae\xba\xbfLWo&]S\xea\xbf\xb2S\xf7\x90\x13\xbd\xf6\xbf\x82q\x91\xfaV\xd4\xf2?#\xcay\xdb\xda\x91\xe0?\x9e\xb4\x9e \xfdM\xed?+D\x82\xedx\x02\xd0?kCo.\xbdk\xeb?N\xeei~g|\t@\x0e\xbe<1\x02\x05\x07@5\x97\x8e\xf84#\xcf\xbf\xd2\xb4<\xf0?\xd9\xfd?w[!\xeb\x9f?\xfc?\x9a?\x8b\x94\x9f\r\xe6\xbf\x16\xfd\xa4\xa2\x19\xed\xf0\xbf\xb7\xdc\x93\xe1\x07\xe1\xc6\xbf\xf4\xc2\x9b\x8a\xd4\x00\xe8\xbf$\xc2\xd68w \xe8\xbf\xf7\x96\xb8\xb8\x1ar\xcb?p7\x8fb\x01)\xe9\xbf$\xcd\xa8U\xa3\xca\xf3\xbf\x05Z\xc31\x03s\xff\xbf\x10\xe3\x87l\xc1\x8d\x00\xc0<\xb0G\xc3\x92\xf0\xcd?\xac_G\x0eB\x1c\xf4\xbf\xeb"\x9c\xcb\x08\xad\xdd\xbf\xf5\x19\x15f&y\xe3?\x17\xec\x1a\x97]\xf7\xd5?\xfa\xa2\x99\x94\x08\xb1\x97?\x91w+\x85\x1d\x00\xf1?\xc8z\xc8V\x7fO\xdd?C\xab\xb8\xa2\xe4\xe1\xd5?\x0cV\xe1GK\xd0\xee?\xcc\t\x11Nd\x93\x0f@/\x19\xf3\xbeW\xd4\x12@"P3\xc0\xa4h\x01@3Y0\xf2\t\x9e\r@\xe6s\xedp\xea\x98\x06@\x93\xeb\xd4\xd7\xdf\xa9\x00@\xc8;\xfa\x014k\xe5\xbfb\xa1\x9cQ\xb1\xb7\xfe?\xc2\xf4c\x85l\x00\xec\xbf\xf3u\xb7\xa0\xadt\xed\xbf\xc10P\x14\t,\xec\xbf\x92\xd5\x14\xeb&l\xea\xbfH\x8c5w\xb5T\x08\xc0@\xd3:\x14g\xb4\xec?\xc6y0\xc2\ny\xe4\xbf\xb0T(\xd4y\x9c\xdf?\x928\x98Y\x16\xbf\xdd?75\xe3E\xcd\'\xfb\xbf\xab\x8d\xf2\xb16\xc9\xe8\xbf\x81\xc8\x850+\xfe\xec?t\xba\x8a\x1e\xbcC\xf2?\x85.\xd5\xf6\xacN\xba\xbf\xf7\x9dKq\x84L\xf2?\x1a_\xf3\x1cy\xdc\x00\xc0\x8c\xb7\xcc=\xb0w\x08\xc0\xb3.\x88\x87\xaf\x10\t\xc0\xfbT\x1e=\x8bJ\xc7?\x14\x06;\xac \xbd\xc7\xbf\xf7K\x84d\xcc\xc3\xed\xbf\x81$.\xbd\x9a\xa8\xe3?\x9b\xf2\xb3\'p\xec\xed\xbf\xf3\x02\xf1\x06\x7f\xe2\xe1\xbfz\x19][\xdd\xeb\xbf?\xd2tR\xbb\t\xe8\xdf?\xbb\xa9\x9f\x8ddW\xfa\xbfq\x82\tn\xd5t\xf9\xbfq\xba\xf1\xeezG\x05\xc0\x85%\xd1\xa4@\xdc\xdb?\xe0\x0fJ\x92\xe7\xf2\xf5\xbf\xeb:\xcb^\xc2w\x05\xc0\xcd\x9c\xf1#\xad\xb0\xd4\xbf\xd8(\x1f\x9b\xb9\\\x01\xc0\x06\xc1\xd4?v0\xe4?\xbf\x10\x01\xa8n\xd5\xa8?}\x8f\x0fp\xb3\xdb\xda\xbft\x9d\xcd\xd3\xd51\xfd\xbf\x9dy\xfa""_\xf6\xbf\xf7\x8a\xd0G>\xca\x01@\xc1b\xfa1W\xfd\x02\xc0\xd0\x88X\xee\xb5\r\xf2?\xf7\xa2\xb9y~k\xe8?d\xc6\x84Y\xef%\x04\xc0\x18{Z\xcf\xd6\x98\x07\xc0\xeb\xcc\xaa\xfb\x9d\x9d\x07\xc0\xf5\xf0v\xdbF\x95\x07\xc0\x88sDS\n\xc5\x14\xc0\xfe\x84\xfc\x97"v\xff\xbf\xaf\x14\xfe#\x1f\xd4\x12\xc0aVh\x84\x15N\x0f\xc0\xb0\xa3n\x0e;\xe7\x1b\xc0\x0b8\xd7\xaa\x1cA\r\xc0\xc3SH\xf6\xb2\x1a\x0e\xc0~\xd2\xaf\rk{\xf7\xbfVW\xf6\x87\x81\x1a\xfc\xbf\xc5U{\x0e\x96\x99\xde\xbf\x83\xa7\xe0\xf7\x04\xfd\xf8\xbf\xcd\xa9\xbd\x9b\x0fO\xa7?\xba\xd7a+K\xfd\xc9?\xa0\x1f\x94\xe9S\x12\xf4\xbf\x8b\x8845\x81Y\xc8\xbfY\x14\x18\xbc5s\xf2\xbf\x9a\xbc\xf7=j\xd6\xe5\xbf\xda\xd5\xd3\xad6@\xf0?\xf6\xa6\xa2cs\x86\xf4\xbfK\xd9\xef\x1e+\x8a\xcd\xbf\xaf\xf8\xbc\xc0=\x90\xf7\xbfm\xd2\x84vV\x12\xfc\xbf\xc5`\xab-\xe0V\xd0?\xba1\x16tIs\xd4\xbfP\xc2I\xd9\xb2\xf7\x06\xc0\x12C\xa0i\x99b\xf3\xbf\xd3\x1f\xfa\xf7\xa8H\xfe\xbf.\x03\x0bNX\xed\x02\xc0\xadN\xfb*|\xf8\n\xc0\xdb\x99\xc1\xb6\xaeE\x07\xc0\xcc;m\x02\x96\'\x01\xc0\xdc\x97\x82Q\x1ea\x10\xc0\xa6\r*\x82\x9b7\x01\xc0\xb4^\x156?\xb5\x08\xc0\'\x12FR,J\xe1?\xf4-\xd5\xa4~\xbe\xf2\xbf\x07\x8e>=/\xce\xcb\xbfJ\x8f\x88\x08C\x9a\x08\xc0e\xc8\x98\xd4M\xfc\xe3?\x85\xcc\xe5\xa3\\\x94\xf8\xbf\xf8>/\xd8\x0e\xe1\xaa\xbfI\xb0\'8\xc4&\xdd?/\x0fZ\xc8\xeb\'\xc6\xbf\x80\x80V;k\x87\xff\xbf\xb2\x06\x92\xd4\xd43\xc4?\xf1\xf7b"4\xcd\xeb\xbfy\x9fF\x07\xc1V\xef\xbf\xccq\x06\x91|\x0b\xe3?]\x19D\xb7\x00\xb9\x02\xc0\xb5\xb9\xc6\xa6I\xc5\xe9?R\xe2\x80\x93\xfa\xf9\xe5?G\x91\xf0=0K\xd3\xbf1\xf7\\\xf8\x8e\xf6\xd7\xbf\x97\x08\xa3\x0e\xb7}\x02\xc0\xd9\xdc\xbe\xe7\x9f\x86\xf0\xbf,"\xc9C\x8db\xff\xbfU\x86\xd6\xdcf\xab\x00\xc0\x06;\xbe}f\xd4\xe7\xbf\xdc,\xd1\xbd\xbcB\xd9?\t\xe9V\xc0I\x7f\xf4\xbf\x885\xca\xd3\x0ef\xea\xbf\x19\xbf\xb1\xb0g\x87\xeb?P3\xa4o?\xc1\xcc\xbf\xcar\x13v\x8d\xe8\x02\xc0\xb6|\xda\xc6*_\xe0?\x08D;\xaa+\xda\xfd\xbfjO\x87\xa7\xd5.\xf9\xbf\xfcy\xf5\xe2\x12\xe2\xd2?4\xed%,\xdaY\xee?$aF=\xbb\xa7\xe0\xbf\x87\xff\x8c\x90+\xd6\xa9?Z8\x86\xf6P\n\xc1\xbf\xd7z\xc6\xfa=\xa1\xdc?A\xb7\xc9\x8ao\xd8\xf2?\x17,\x19\xed>\x1a\xf4?i\xbbHm\xee\xfe\xc9\xbft\xa1\x9dzM\x1b\xd4?*+Z\x90\x0e,\xf2\xbfs\xa8ZQ\x1d\xe2\xc6?\xd1b\xf60\xfd\xd3\xdf?\xfe\xbc\xc0\xed\xc9\x15\x03\xc0\x8dV\xf8\xa0\x98&\xf2\xbf\x04\x98\xb4\xe4i\x0c\xf2\xbf\xc0/1\x92\\\x81\xea\xbf\xe6\xdd\x96\xd9\xa7D\xfb?\x0cP\xef\xe0\x04\xb9\xe9\xbf\xb5\x04\x925\x91\xd6\xe6?\xd5\xeb82X\xd6\xa1?\xc4\x8b~0G\x1b\xd2?\xd20\x83\xb6\x00\xa4\xf6?\x17\x99\xd8$\xe7\xe4\xc4?}\xb5\x04\x9f\xb0\xde\xe6\xbf/Q\x9ff$K\xd6?\xa9\xcb\xe5\x815T\xfa\xbfC\xaf\xdefaR\xbf\xbf!i:Y\xe4\xc3\xf3\xbfH!\xb3\xad\xbd\xb1\xe5?t\x1b\x87\xfd\n\x94\xcf?&p\xc6b\xab\x8f\xe9\xbfxjq\x94\rM\xf4?=\xbf\n\xc8\x16\x08\xd0\xbf\xec\xc0\x97\x8c\x98\xa2\xd1?e\xee\x96\xe4\x94A\xf7\xbf\xca\xae\xdba\x13\xf5\xfe?Ujd\x1d\x9e\xdd\xde?\xde\xc4\x91\xa6&L\xea\xbf\xbe\xd6\xff\xd9\x9d\x8a\xc3?\x99\xdb\xdf\x1f\xbde\xe7?jF\x1a0W\xfe\xe0?\x83.\xc7;\x8f\x95\xf4\xbf[\xb7\xbc\xa2\xf1\xad\xe0\xbfUG8\x1e\x94\xce\xed\xbf\xbbd\xf51\x14]\xca?\xda1\xbe\t\xafy\xe3\xbf\xfal\x94\x16\xc1\xa9\xa8?\xac[(\x81\x02>\xac?\xa9\xc51\t\xca\xf4\xf0\xbf;\xba\xb6\xf4\x02\xa5\xf2\xbfv\xbe\x91\x06w\xd5\xf7\xbf\xf8>\x13\tT\xd8\xf0\xbfl\xf2\x82\x19s5\xf3?\xa9\x9a\xa4\x9bxk\xcc\xbf\x84fE\xf5\xc3\x8f\xfd?\x12il{!\x8f\xee\xbfo\xb5\x99\x08 F\x02@\x12vNRr\n\xca?\x0c\xb4{D\xfb\xa5\xe4?\x1f\x96\xdd\xc4\xd93\xf6?C\x91\x13\xa6\xff\xc5\xf4\xbf\x07i\x91e\x7f\\\xf5\xbf\xdbW\x1c\x0c\x1c\xfa\xd5\xbfZ\xd0A\x90\x10\xc7\xea\xbf\xec\x04\x90\'\x89\x1e\xe3?!\xe2V\x97\x07\x1f\xf9\xbf\xbf\x8bl\xd0\xa4\xd9\xc0\xbf\x1fS\xc01\x81T\xf0?\xf1\xb5\x03s\x13\x8c\xc5?S\x1a5{=\xe0\x0b\x04\xc0\xb8\xea\x8ao6\xc4\xf8\xbf~z\x99\xffh\x17\xf1\xbfN\xd4\xee\xda\\\xee\xf7\xbf\x1b1I\xb3\xca\xf1\x07\xc0\xf8\x14\r6\xdd\x1c\xf9\xbf\x0b\tB\x96t\xe4\t\xc0\xb5\x89\x98\x87\x96\x12\xf7\xbfHH"\xc8\x0ct\xf3\xbf\r\xcc\x05\xcd\xabp\xfa\xbf\xc7eK&h\x85\x01\xc0\xd1\xcaY\x86\xd7)\xf7\xbf\x0f\xdbt\x00\xca)\xd6\xbfz\x00\',\xba\xd8\x02@\x14\x03e\x87*\x96\xe3\xbf\xf7\xff\x1e\xa2Dr\xf4?9\xbf\xb8\x80j\x16\xd6?*\xedK\xb8.\xcc\xfb?!\xfa\x00AUl\xed\xbf\xceQMy\xca`\x00@x,B$\x08x\xf0?\xd3\x00\xf1$\xc1y\xe6?\xd3\xbb|\xe45\xb7\xed?k\x08y\r\xc9/\xf1?Jh\x9f\xb1\xb8\xfc\xc8?\xf6p\x98lb\xa4\xd4\xbf\xfc\x80w\x82E.y?\xfcO\x84F\x16\xd9\xf1\xbf\x1bR\xcda%\xfb\xd3\xbf+7\x02)l(\xfc\xbf|\xb6\xd5\xd9\xbdV\xf4\xbfa\xca\xc1\x86C\xde\xef?\x8c\x88\x9b\xd5fm\x90?\xb4#\xd6\x95U\x8a\xf0?\xa6\x93\xc4\xbb\xe8\x16\xf2?\xe2\x93\x0b\xb4v3\xc4\xbf\xa6\xee-._X\xe3?>Bh\x85MR\xe8?\xbbY\xaag\xa6\xe4\x03\xc0S\x98\xba\xd1\x9a*\xe3?\xa1 \x14\x8e<\xbf\xc0\xbf\r`\xc6\xf5\xe3u\xe1\xbf\xcd\x9c\xce\x81\\\xe0\xe6\xbf\x9e,x\xa5p\xfc\xe0?\xa6\xc5\xd2\xd4s\xac\xca?O\x8cB\x82\xca\x9b\xce?#\x81V\xcdbk\x91\xbf\xe01\xd33\xf2\xf7\xfa\xbf\xd0\x08\xf4\x9b\\\xba\xd5?Rfk\xe1\x9c\xc8\xbb?-\x87k\x95\xef\x13\xc8\xbf\xabr\xc1\xb9M\xd0\xf1\xbf\xac(\x1e\x94\x89_\xa9\xbf\x1b\x04C\xac\x87=\xa1\xbf\xe5\x82+:\xd9\xf6\xf6\xbf\x1a\xe9\xf1s(T\xd2\xbf\xc0Q\xbaFe\xd0\xe6\xbf\x91\xb2\xe2\xc0w\x0c\xca?\x876\xdd\xa1(\xe9\xae?g\x04\xcd\x15Tj\xc4?QX\x80\xd2p\xa5\xee\xbf\xdc\x155\xc7\x80\x8a\xf4\xbfK[\xe5\x00U\xf2\xcd\xbfb?[-\xc7\xa9\xee?\xf3%\xaf\xe4\xc7[\xf0?4\xf9\x15F\x16\x85\xf9\xbf\x8f\x11=\x80p\xac\xe3?jbNd\xa4\xad\xee\xbf\xb7\x9a\x92\xa3\xec\x0e\xf3\xbf*L\xd1\x11\xf5i\xf4\xbf~&\xc0\xab%\x9d\xc4?!,j"\xe7\x08\xf3\xbf\x12;\xba\xa8#-\xf8\xbf\x8bs%\xc4\xa9]\xe4?\xa3\x9f\x01\x94\xc3&\xf5\xbfA\xd8\xb6G\x98\xef\xfa?\x10\x9cx\tT \xef?\xd6\xf3\xf1\xd7\xe16\xc8?\xfb\xefw?\x84q\xf2\xbf\xc8l\x18\xfes4\xe6?\x04\xcd\x92\xa9C\x7f\xc7?\xd9\xbf\xc6\xafp7\xda?3\x8d\xcc$\x967\xbd?\xdb\xd2\xf8\x96\xc9\xb0\xe6?\x8crWw\x00G\xd6?\x14\x91\xda\xb3\xdb\xb0\xc1\xbf8k\xdaor\xdf\xe7\xbf\x8a\xd3"\xa3\x9b}\xf0?\xa0\x15\xd7\xb7Dj\xeb?*\x7fy\xca\xc6\x9f\xe7?\xd3;ddM\xa2\xd6?\x98\xfe\x8e71$\xeb\xbfM\x86\xf9G\x98\xa6\xdc\xbf\xd3\xab#7\xf8\xd9\xd8\xbf\xd3 \xdc\xd8x"\xf1\xbf\x17a\xac\x9d"\xa8\xe8?\xf1@\xeaR\xb7\xf0\xed?\x0f\xaf\x8f\xc2\x8b?\xe0?\xae\x88r\x07|@\xeb?ktVX\xdd\x8e\xe9?\x03\x1e\x8f\xa7\xa0\x81\x02\xc0#\xc6\x11\xef\xb5\xa6\xf3\xbf\x83\xf5\xa5\xa3NE\xb0\xbff\xd1\xeb\x8b\xb2r\xe4?\x8c\xc5v\xf8\x0e\xa5\x01@Pf\xf3\xbej+\xf6\xbfG|xF\xee<\xd6\xbfA\x93S\xbd\xc9r\xe8?\xa5\x8c\xa1h\xb74\xe8\xbf\xbaH<\x95M\x90\xe9\xbftt\x03\xe9\x077\x96\xbf\xe6\xf0\x97%\xf7\xb0\xff?\xa1\xb2:;\xd3\x86\xef\xbfHg\xabV\xa87\xd5\xbf\x9d}-\x1dI\x1b\xe4\xbf\x14\xc4\xd8\x91D\x18\x02\xc02\xfa\x85\x9fl\xa0\xe9\xbf\xb4@\x1e\x81\xee\xc7\xf7\xbf\x90%\xf7\xae\xd6\x98\xf3?\x93P\xb8\xc1J\xe0\xe6?\x90\xb9\x99*\xcd\x8a\xe8?\x8cz\x9b9a#\xe8\xbfR\xe7\xff\xbaPU\xe9?\xa5[c\x8cO*\xf3?t\xaa\xb5\x04o\x93\xf0\xbf\xb6\xb1\xf77h\xff\xd2\xbf%6\xd5\xa2:\xc2\xe1?\x8b\x90%\xf2g\xe6\xe8?\x1b=\xc8\xd0Y\x84\xf0?\xe1\t\x9d>\x92\xa7\xf6?\xe9\xb52M\xb7\xc1\xf0?\xdc\xd5\xd4\x8e"q\xd6\xbf\xa3j/\x0e\xc9\x15\xd0\xbf\xfa\xb8\x03XJ?\xea?\xa1\x9dq>\xfe*\xf5?Qm\xa0\x89\x05\xc1\xe4\xbf\xa9\n\x08r\x06\xfd\xf4?m\xdc\xa2\xa5:\xe5\xcc\xbfiU\xf0\xf4\x8fY\xfa?\xaaU\xa2\'\x84\xc1\xcc?\xd3O\x1a9\x1a\x8d\xd7?\xa5c\xbc459\xda?\x1aL\x93\xbe\xcbb\xe5?\xfa\xe2~\xdb\x04;\xf3?\xef3\xc5\x16\xec&\xd9\xbfU\x923\xb0\x15_\xe0?\r\x81\xd5b\xc3F\xdd\xbf\xf1\x80\x16\xd7\x11\x13\xfb?\'=\x9b\xbd%\xe0\xf9?ng\x91\xaaU\xda\xca?0\x9e\xd2$\xf6\x84\xf0??"\x03\x98\x8f \xcc?\xf5\xfb\x1d\xc7x\xab\xe4?W\xa2"ut\xdf\xfb?\xfcW\xea\xaf\x0b\xfb\xe2?&\x8f$N\xe8V\x05@5Eb\xb1\x93C\xc8\xbf\x0f\x8d\xafY\xb8\x1f\xf3?\x91\xf4\xf7\xf7\x00\x83\xfe?\x8b\xb0\xc2\'\xc9\x95\xe3?0\x98\xd2>b\xf0\xf1?\n\xf3/\xd1:X\xff?\x04GX\xf1\xac@\xf0?V\x13\x86\xaa\xd5\xaf\xc8?7\x14\xd0\xf8\xe0n\xe4\xbf\xc4\xd3\x9d-`b\x03@1\xbfs\x8c\xf6\xc1\xd0?a1\x97u\x07\xbb\xe3\xbfI\x12t\xac\x9b4\xf0?\x83\xdb\xe1\x1d\xf1\xbf\xdc+\xea\x92q\x8f\xbf?\xd16\x89\x87\t\xa1\xf1?Q\\\xf7\xa1\xb8\xaa\xd2?\xb7e5I\xbd\xbf\xc2\xbfoO\xa6\xee\x92\xad\xf7\xbf+\xf3s\xd0\x07o\xb9?M\xc7\x9eP\xf6\xdc\x00\xc0\xfe$K`X*\x08\xc0F\x14\xd0K>\xba\xf8?\x12\x95\xa4_\x8f\x92\xa7\xbfh\xf8\xa6O\xa7"\xf9?\xa7\x0b`{\xc1q\xf9?\xe7\xd7\xeb\x1b\xa9\x10\xe6?\xf2\xd2\xb5P\xa53\xce?5[\xa5\xfavL\x03@.\xb6\x14-B\x96\xdf?\xaf\xce\xf5\xeb\xd1+\x04\xc0C{\x18\xee<\xd8\xa3\xbf\x1a\xc7}1\x01\x1f\xf9?J\xc6O\xa4S-\xb4\xbf\x04V\x99\xa0\x05+\xf3\xbf^\xbfq\xe2#\x08G?\xde;\xf9\xb0\xb8\xfe\xea?\xaf\xbc\xae\x93\x123\xe4\xbfHL4\xd7U\xc3\n@`)\xc5\x9d}\x05\xdf?""\x87py\xca\x07@&\xf3\x9c,\xdd\xd1\xc8\xbfH\x15z\x90v\xc4\xd5\xbf\xa8\xfc\x1c\xc0V\xb9\xe7\xbf\x800\x9b.\x11\x8e\xde?bs\r\x14\x93\xa5\xe5?>\xaec\xa7\x91\x97\xed\xbf\xb5t\xdd \x15]\x05\xc0,PY\x1e\xbfY\xf1\xbf\t6\x10\'m\x1f\xd2\xbf\xbe\x95C**\xbb\x07\xc0D\xab\x99\x0f\xf3\xdf\xe3\xbf\x03\xf5\x19Nm\xd2\xd6\xbfc\x8ern\x93!\xf1?\xb5\xdf#\xd9\xb8\xfb\xd6?\xdd\xba\x9c\x1d\x12\xf1\xee?\xb1\x8eG\xb6\xba~\xf2?\x9a\xa4c\xa07\xf0\x01@\xf7E}id\xe3\xf5?\x85\x88^E;B\xf4\xbfsp\x98\xcd\xa9Z\xb2?XT\x0b+-\x11\xf5?\xdc\x1f\xea,EC\xe4?f\xb3}\x1e\xf1\xa4\xb9?\xb4\x90\xfd\xe9\xde\xf9\xcb\xbf@L\x05T\xbb{\xe1?1LP\x90\xb5Q\xb8\xbf\x7f\xf3\xc9ls\x93\xfb?[\xb0\xddq\xcb\x97\xed?J\x9e\xf9\xd3\x89\t\x02@\x0f(\xf1\x0e\xe5%\xed?\xf1\r)\xd1\xcd5\xf3\xbf\xac\xaa\\\xab\x93\xf4\xff\xbf\xeb\xf2\xc0-\xbb\xef\xf4\xbf\x99\xa5]\xa1\xa1\xb8\xe5\xbfu\x97\xcc\xb4\xf8\xaf\xe7\xbf\x84^.\x10dM\xd0?"#\x99M\xaeb\x01\xc0F\xd2\x8bm\xeb\xba\xf6\xbf\xc7\xd2\xf9xl?\x04\xc0\x1f\x89\x94\x94tx\x01\xc0g!\xf9x\x0cu\xe3?K\x83<>\x95\x80\xf0?W\xc9\x05\xeb\x8d\xb1\xfa?\xaf\xc8T\x1f\x88\x97\x07@\xe8\xd0\xe2\x94>\x02\xfe?"_\xd0\xeb+C\xfd?\x14\xe5\xf1\xbb\xc3\xda\xe6\xbfA\x17/s:\xae\xe7\xbf\xc4y\xb1\xbb \x1b\xb8?\xe1\xa9\x14\xb4\x91\x84\xe8?\xfb\x9d\xbf\x8d\x06\xb7\xd3\xbfD\xf1e=T\xdb\xf4?\x12\xd7\xdc\x1bo\xf9\xec?\x7f\x13\xc8\x82\x14\xe5\xe4?\xea|\x8c\xae\xa6\x82\xb8\xbf\x8b\x0e\x98\xa0\x0c\xcb\x01@?k\xcd\x9b\x1e\x13\xe7?2\xe1\xfaOl\xa2\xb6\xbf\xa9\xc2\xe2\xb8\x15\xc1\xc9?\x0c\x87\x14r\xde!\x00@s\xe0p\xfe\'\x8e\xd2?\x04\xb0\xb1!\x16\xc5\xec\xbf\xaezNgm\x99\xe8\xbf\xc5\x86|7\x13\x94\x03\xc0\xd5\x98\x96\xab\xd8W\xfd\xbf\xffjx\xd5\x0bp\xf8\xbf>Yn\xbf\x02\xa2\xf9?s\x91\x0cw6\x8d\xfc?\xe8\xf8[\rT\x8a\xea?\xde\x88#\x17\x91\xe3\xee?\xcd\xf7\x08\xd5i#\xea?hxk\x04]<\t@\xc4h\xda=\x91C\xfd?8\xb0I\xd5\\\xf3\x05@\xfcO\x1d\x10\x84\xe1\x9e?4._nia\xe7\xbf@\x8e}\x8d\x15\x01\xf9?=\xc2Z\xa4\'f\xe1\xbf\xed\xbb\xf6\xee\xceo\xd5\xbf\xad\x11\x84Y\xe5?wj\x9f=\x16t\xf9?A\xf8N\xb8\x03}\xc4\xbff\xe9\x7f\xaf\x92\xbb\xd1?#`>\xd7\x82\x0b\xe9?H\x8b\xa5\xa8\xfb\x19\xe1\xbf>\xd1\xa6\x8e\xcd\xfa\xaa?\xf5\xe4OS\xc1x\xb7\xbf\xc4xV,\x1a\x03\xc0A\x9c\xabaYO\xeb?\xb7\xa9\x82\x89 \x90\xfc\xbf[\x0fF\xda\x18P\x0c\xc0\xa4\xa0\xa8J6m\x00\xc0\x94%;J\x80n\x04\xc0\xd8:A\x0cH9\x0e\xc0o\xefJp\x0c\xda\xf3\xbf\x00\xdaZ*\xaf\xd4\x07\xc0\xfd!A\x01{\xa8\xe4\xbf;\xcd\x9d\x9a\x85k\xe2?\x90\xcaq\xfdb\x18\x13@\x13\x05\x07B\x84\x15\x14@9\x17\xe2\x9c.p\x02@\x99,D\xa6\x06\x87\xea\xbf\x12]UR\x86\xcb\t\xc0\xce\xc2\xb7%\x14\xf2\x06\xc0\\S\xe62\xe2\xed\xf9\xbf\xfe\xe1&\rm\xfd\xfa\xbf\xfeE\xaa%X\xe3\x02\xc0\x08\xcc6\xe1b\xe0\x08\xc0\xac\xc8\xca4\xcf\xb3\xed\xbf\x8b\xa2o\x7f\xa7w\xda\xbf3\xf8\xd6\xb35\xd1\xce\xbf\x1ay\xb5d[`\xed\xbf\xf7W2\xfc\xadK\xd8\xbf\x19;_\x9dq\xc6\xe2\xbfC\xeb\xb7\xa8~R\xce\xbf\x81\xb8b\x0c\xd5\xf0\xed\xbf@\x98\xfbX" \xc4?U\xa08\xe6\x03!\xe9\xbf\x07T\x9bp\x11\x15\xf7\xbf\xf8\x06(\x823\xbb\xc6\xbfb!\xcdu\xcc\x12\xff\xbf\x16\xc0"J\xden\x00\xc0W\xce\xbf\x13{\x87\xad\xbf\x93\x85\n\xe5\x84t\x03\xc0\x10\x16\xcb\xf3\x80w\x91\xbf\x95\xd8\xb2\xa4\xbf\xfc\xe9?\xf9\x91\x1e\xe5\xf4u\n@\x1d\x17\xc9\x08\xc0\xa4\x0f@\x18\x99\'\xe2\xbbh\xf6\xbf\x1c\x8e*HW\x00\xf7\xbf\xd6i\xb2<,(\x04\xc0\x1drHQ\x8d\x13\xfe\xbf\xbe\xe0\x15w6\xe7\xd6\xbf\x03\x1c\xc7\x19s\x80\xd4?\x15\xdceC\x1e\xed\xdb\xbf\xcf[(\xab\x1a\xe2\xf6\xbf;\xd8\xf1\x18*\x9e\xe9\xbf\x9a^\x0e\xd5\xff\x02\x01@2b\xa6L\x04\x95\xef?\xfa:z$J\xbe\xef\xbf!\xd5\xf6\x88t\x88\xe5?\xee\xb7"oNe\xcd?\x18&\xbc\xcd\x0c\xd4\xb5\xbfp\xf3:l\xbb\x97\xf6?|}\xb1\xdb\x1d\x9f\xd8\xbf\'n\x9e\xfd\xfdz\xb8\xbf\xb6\xe0w\xb2e&\xfb\xbf\x87\xcfs\r\x9a\xf3\xe8\xbf\x0f\x8c$\xc7K\xe0\xf2\xbf\xae\x01\x8b\xe1\x06\xe6\xff\xbft\xf9m\xabm\x8f\x03\xc0\xba\x1d\xa8\xa4\xa4D\x15\xc0\x8a}\x96dA\xdc\xf2\xbf\x15\xec\xe2Vv\xb5\x04@\x8c\x08\x9d%|\x06\x07@\x15n#\x81\x03H\x03@5\xba@\xc5\x03\xfa\xf4\xbf\xa2\xe2\x00\x8e\x10\x01\xfe\xbf\xff\xd7F\xc7\xb8\xc2\xf3\xbf\xac\xa8\xcb~\xb7\x0e\xbe\xbf\xea=\xa5J\x18\x85\xfa\xbf/\xe0.\xc8pL\xe3\xbfF\xb1[F6\x18\xd8\xbf\x8a\xd2\xbaow\xd2\xe7?\xc0\xca\x18\x1a\xcc\x16W\xbf\x93\xf0\xd6\xe4\xc0?\x08@\xd7\xe7\x1f\xd2\x04M\xfc\xbf\xad_\xa5\xb5"-\xad?\x1aq\x1c\xa0\xe9h\xd0\xbf+)\x8b\xa7H<\xee\xbfc\x91\xf8 \x0c\x92\xce?\x9e\x9e\xfaOm\xdf\xdf\xbf\xac\x8c\xdf\x90\xb1\x9e\xff?\xdd\xc7\x88\x8e\xab\x1b\xc1\xbfl\xfb\xbe\x13~X\xe4?x\x1b\xcd]\x91E\xd5?W\x94\xb4\xa4\x99\xed\xe6\xbf\xb4\xb6\x00_\xa7\xdf\x00\xc0\xee\xab\x13\xceH\x02\xeb\xbf\xf68\x9f\xc6\xbf0\xef\xbf|\xb4j\x9d\xd3\xa8\xee\xbf\xbf\x8bL5O\x91\xf1?v>/\xca\xbbu\x02@{\xaa\xa7kze\xef?\x052)/\x83\xc5\xfa?\xd4\xd3\x1e\xdc1\xd9\x02@\'\xfb1\xc3\xbb\xbb\xdc?\xdeHE\xa2\t\xc8\xe7?\xea2Z\xa5\x8b\xa8\xb4?}\xa8\x86-\xab\x04\xef?\xd9R\x93\xb8;M\xea?\xe3\x99\xe6`W\xf1\xf3?\x06\x1d\xa2\xe9\xeag\x03@\x96\xef\xd4\x97d\xd4\xce?\xeez\xf9\x8e\x9a\xe6\xd9?\t\xda\x0f\x0e\x92\xdc\xda?\xf32\xd3\x06BK\x01\xc0\xab\x0c:\xa6\xd9\xa6\xbd\xbf\xdd\xb8\xf1\xb1E\r\xd0\xbf\xc2(\xfcE\x8b\x08\xef?\x8e\xaaUjCW\xe8?=\xf7Q{2\xa9\xea?z\x1d\x1b\xc0\xe8\x14\xf0\xbf_\xa0U\xed#r\xb7\xbf\x8c\xe4\xe7\x05\xe2n\xf2?_\xeb\xc2\xca[\xb3\xd2\xbf\x90\xe1x\xf5\xdb\x9f\xcf?\xe9\x96\x0c\xd7\xa2\xa3\xd7\xbf\xa8\xfb3\xa6\xac\xb4\xed?\x04\xb9\xce\xae\x88\x05\xc1\xbf\xb8Y\xe2\xf6\xa6>\xe1\xbf\x9b\xa3{La;\x0b@^.\xeeU\xc2\xcb\xd2\xbf\xd2\xf2c\x89\x06\xda\xf4?\x1b\xcc\xe4,\x19W\xf9?+\xa0k\xfc$\x9a\xf2?\xff\xf36\xb6A\x80\x02@aB]\x16\xbd=\x92\xbf\x0e\xed\x1b_E\xfa\xd4?\xada\xdd [m\xe4?\x0c\t\x86\xc2c\xb5\xb8\xbf\x84iz\xe5\xd4\xdf\xd2\xbf\x19\xe4\xf3\xaa{\xc4\xee\xbf9\xe4[|\xbb@{?R\x89\xbbQ.j\xdd\xbf\x1e\xf6\x95\xe1\x9b\xf5\xe9\xbf\x13z\x08\xfeD\x8f\xe3?\xb9\x1b\xa4K\t\xb1\xee\xbfW\xd3i\xeb"\x93\xe1?@\x17\x83\x94G\xbf\x00\xc0\x07\xbe\xe9\xfb\x15\x12\xfe\xbf\x12\xd3\\\x93\xff\x00@!zj!\xb8\xab\xa1?\xb6\xe1\xcd\x95>\x91\x02@\xb23\xa3\xbf+\x14\xcc\xbfc\xab\xa0\x08\xb3\xa9\xb6?\xcfWT\tB\xaf\xf0\xbf\x1dz_\xef\x18\xfc\xd5\xbfU~?\xff\xca"\xe8\xbf\xd6\x87\xd8\xb5\xf0o\xf2\xbf\xcf\x04\xd1J\x99\xd0\xe2?f\x8d\xc2\x9e\xfb\x8d\xef?\x1ce\xd1\xc15\xd6\x03@ap\r"zS\x08@H::5\\\x9c\xf3?\xdfp\xc2\xb5x\x10\xf7?0~\x86\'\xeb]\xf9?1\xd3\x0bv\ro\xf6?f.\xe1Q\xe9\xad\xcd\xbf18\x0b\x98\xdbp\xd9\xbf\xd5\xda\x02B\xc5Q\xe7?\xfe\xd7l\x1f\r\xf5\xc8\xbf\xfe\xfa\xbe\xae\xc3\xc0\xe4?\x04[\xc5I|\x16\xda?\xacP\xfd\ta\xf0\xb4\xbf\x8f\x7f\x98\xba\xf6k\xe3?\xbaw\x8d\x9a\xb7\xab\x01@;9&\xd1\xb6\xfe\xbc\xbf\xfc(\xac\xcd\xd2\xc0\xcb\xbf\xb6\xb3}\xc0\xa0\x18\xe2?23\xde Q\xe4\xe4?\x9cQ\x89\xf9\xff\x88\xd1\xbf\xd4K}HnM\xef?\xc2\xd1\xb1\xd6\xce\xff\xf3\xbf"\x9bX\xcfj\xdb\xbc\xbf\x89zM\xab\xb5\xbe\xe3\xbf\xfa\x18\x9a(\x8c-\xc1?F\x86v1\x95\xae\xf9?\x92\x18DH\xb6}\xe5?\xd1\x1a\xe7\xd8\xba\x8b\xdd\xbfU*\x0bE\x05G\xd6?4\x8f\xac\xb7\xf6\xd4\x04@\x0b4@<\xe2\xc9\x02@&\x9e\x12\xa6b\x9f\xed?\xa3\\\xcd\x0c\x06/\xe4\xbfh\x1f\xe3\xe7\xfaX\xe0?\xa4\x9f\xb6\n\x89\x81\xf5?N\x15\x8e\xf6\xa8d\x03@\xa1\xba\xb8X\x06\x06\xe2\xbf\x88\xf6\xae\x10\xbe\x8f\xe2\xbf\xb2\xe0\xc7w5\xf3\xc6\xbf/\xb2{P\x82\xce\xe5?V\x82\x155\x10\x99\xe1\xbf(\xfc\x18N\xd7\x81\xb2?i\x0e\xb1\xfd\xd1\xd3\xde?\xc1r\x8d\x05+}\xa1?\xc6\xfa\xfc\xef\xa3<\xf4\xbfrQv=X\xf6\x81\xbf\x01-9z\xee\xfa\xf5\xbf\xe6\x19i\xaf\x88\xd7\xd9\xbf\xdf\x18\r0\xcc\xd7\xe7\xbf0\xb5Gp\xc9V\x01\xc0\xb5\x87p\xbb\x03\x1d\xc1\xbf\x9c\x82\xbe\x06\x82\xf7\xba?n\xdbWrVp\xf6?\x104)\xe3d\xda\xe9?\x8d\xe8e#\x0b\xe2\xc4\xbf\xf0\xa9\xac\x87\xc4\xee\xf6?\xe3+\x8ah\xf0\xc7\xf6?\x9dk`^\xc5/\xe8\xbfZ\xdd{U\x90\x05\xf6\xbf\x15\xbaa\x05\xd2\xc1\xd8\xbf\xab\xae)\x06ox\xfb?\xf1\x9f\xf6\x9f\xf2\xa7\xe8\xbf\xab\xc9\x1f;\x9e\x97\xfa\xbfP\xef\xd3|\xa1\xc0\r@\xf7\xc3\x99\\W\xef\xf2?\x02\xf5;S0\xe8\xf1?\xe2Lq\xce\x8eI\xe8\xbfU\xa7\xd1%\xfa\xd9\xe6\xbfQ\xc3\x10HG\xb1\xc5\xbfO\x17\xe7\xfe\xca;\xb1?\x9f\x06yV\xa2\x10\xf5?a\xd5_\xbbp}\xe7?\xb4\xeb?/u\x16\xd5\xbf9\xc0y\x89B\x93\xed\xbf\xf5\xb0[s\xe2;\xfd?\xbf\x1f\xfa\x05\xe9\xae\xfc?\xf8\xd3\xc7\xa1\xe0\x19\xd7?/H\xc5\xd5\xfb\xd2\xf1?:\xf3)\n\xbc\xf3\xaa?\x96\xa2\xd5\x90x\xa8\xaf\xbfu\xfdw\xbd\xe95\x07@\x02 \xf9\x15U\x1f\xd2\xbf\xbe\xb5\xab\x15\xd1\x05\xfe?$\xb1\x03\xb7R\xcc\xe3?\x95\xc5\x0cWf\x81\xe2\xbf\x00\xe6\\\xb7B\xc3\xe8?b\r_q\x19\xbe\xc5\xbf{\xeb\xb35\xd9N\xd3\xbf\xd0\x86\xbaf(\xf2\xf7?T^\xaa\xec\x9b?\xf5\xbf\xfa\xa1\x0b\xc0\x87\xbb\xe1\xbf\x94\xd3}r\x03\xe8\xf9?G\xb8kr\x88\xc8\xcd? \xd2j\x9e]\xda\xf8?qhP\xf3\x00\x1e\xf7\xbf\xaeN\xc0E\xcc\x8b\xc1?\xa8\x1a\x9fp\t\x90\xe1\xbf\xa8\xda9H1\xdc\xec\xbfC1\xd8)9\xf7\xee\xbfQ\xa8\x90D\xfc\x04\xf4\xbf:{\xd8\xd9o\x9c\xe9\xbfK\xdf\xa1\xd1"/\xdf?#p\xf1x\xe3\x9f\xe9\xbf\xd3\xe4\xd7\x93^>\xab?\x14\x81d!\x00\x12\x0b@V\xfd;\xa8U\x0b\xf6?\xac\xf8\xff\xed\xa3\x8a\xe3?2&\xa3}@\xf7\xe2?\xc4/\xbaq$\x8b\x03@\xc9Ne\x7f\x89\xd1\xf4?\xdd\xa0\x07\xf681\xea?\x15\xa6\x88\x80I\xc2\xd2\xbf\xbf^\xa3Y\x89i\xf9?\x1b\xd1M\xe3\xb7\xae\xf1\xbf\xe6bi\xd25X\xc5\xbf\xff\x14\xea\x14\x06\xbd\xf6\xbf\xa1K`\xe9\x8f\xe2\xe9\xbf\x97pY\xd0\xedR\xa1??\xfa5L\xb3\xec\xe4?Y~\xdc\xdd\x1b\x17\xeb\xbf\x0fi\x8fC\xd7#\xec\xbfxN\xe9\xaa\x94\xec\xec\xbf4\x95\xf0\x0e\xd8-\x00\xc0\xa0\xd9\xeb5\xe2\x9e\x00\xc0\xc7a\x12\x80K\xe6\xc5\xbfyA-=\xb5\\\xde\xbf\xdc\x81\xc0\x8f\n\x1a\xe4?\x8e\x9ej\xf8Y\xd8\xdd?\xd23wV\x89\xe7\xfa\xbf,n\x10\xb3\xba\xb9\xc5?\xf0\xd2\xa2T\xd1q\xe1?\xa2\xbck]\x96\xe9\xfd?5\x14\x8e\xfd\xec\x81\xff?H\x19X\xe8\xcbN\xe0\xbf\xad\xf7\xf6!\xde\r\xfe?\x80\xe6\xdd\x17\xb9\xa0\xb0?G\x08\xb0\x93\\\x1d\xb8\xbf\x14P b\xc0t\xfd?@\xd89\x1c\xbb\x18\xae\xbf\x9e&\x05\x93J\x8b\xf4?\xc4S\xec\xd1\xf8\x8d\xe1?\\\x8cI\x18\xedj\xd4?\xc4{\xf0\xd3g\x93\xe5\xbfq\x0c>\x1c\xb53\xc4?\xadzZQ\xe5\xb9\xf1\xbf6\x12\xf3\xa1\x7f\x98\xd5?$p\xfaSb\xd6\xdb\xbf\x16\xfd\x0ez5r\xcf?\xa4U\x10\xb8\xe2\t\xb7?g\x10r\xb8 \xb3\xc2?\xa7Sb\x92b\xb4\xdc?j\xe9R#a\xa4\xd9?Q\x19\x18U}\xd2\xc2\xbf\xaf\xda}W\xfb\x0f\xd5\xbf7?v\r\xf2\xf9\xb8?\xea\xb88\xe1\x9a\xe8\xcc?)\x7fD\xfcj\x86\xc2\xbf\xa2#\xbdL\xc2\xee\xfd\xbf\x8b-\x03\xfcuQ\xfc?\xae\n\xd0\xc1\xc5\xc6\xe7\xbf0q3s\xa0\x91\xff\xbf\xc8\xa7\xd4\x05rf\xe3\xbfx\xb8c=\x7f\xab\xed\xbfPu\xd6\t\n\x83\xc3??\x88j\xcf\xb3;\xdc\xbf\xa2\xda\xb7F\xf8\xd1\xf2?\xa4\xc7\xfd\xbd3\x88\xf9?\xcb\r\xa7\xa8L\\\xd7\xbfC\xad>\xbb\xb2\xf8\xd1\xbf\x0e\xf6/\x100n\xfc?t\xc2\x97\xed\x082\xf2?>\x18b\xc9\xb1;\xcc?2\xe0}3 \x9c\xce\xbf\x9e>\xc31k\xb9\xf8?\xa4!\xbcb\xd7\xbc\xd4?\x88I\x08[\xc8\xc0\xeb?>\xcf\xf6\xa1eE\xd7\xbff\x10\xef7\xe3\x06\xb1\xbf\xc2\x16~,\xb4\xf6\xd7?\xc8\xfc\xf2\x15c\xd0\xdd?G0w\xf1\x17\xee\xd8?\xbe\xfbG\xd9\x10\xac\x01\xc0\xd4\xc5\\\x8a\xdc\x1d\xe6\xbf%\x03\xb8\x18\xcbs\x03\xc0>I[%\xea\xaf\xf0\xbf\xfaV)<\x17\xb1\xb9\xbf+\x84H\xba%F\xdd?\xc9`\x9bN\x95-\xcd\xbf\x10n\xc4\x08\xa9\x10\xaa?u\xc2\x11\xd7\x88\r\x03\xc0\\\xc5\xd8ul\x90\xf7?o\xb9\x14&\x83\xb7\xeb?7e\xeb\x1a\x1f<\xb4\xbf\xf8\xad:aK)\xd4?/p\xb9\x8ew\x82\xe9\xbf\xfd`\xa3\xd1[\x92\xe1\xbf\x8f\xdfz\xb3\x9bV\xea?Z \xc1\x82\x9cv\x00\xc0\xf3\xaf\x98\xca\xeb\xad\x00\xc0\xde&\x80\xe5\xaf\xf0\xf3?\xf7\r\xeb\x7f7e\xc8\xbf\xc3\x862\xec1\x9e\xc7?\x0e\x10O\xe5\xef\xab\xd9?\xeb\xf5\xfa#(\xdd\xf1\xbf7C\tU.\xa0\xe9?/\xc3\x0b?\x99i\xfb\xbf\xd7\n\xee\xab\x9fn\xa5\xbf-\xb8P\xe7\n-\xf8\xbf!j}A\xefv\xb0\xbf\xfa\x88\xdf\xdb\xcf\xb2\xf2?0ifc\x82\xb3\xdf\xbf\x17\x9dy\xeb\x93\x7fy\xbf\x15\xc8\xfds\xd7\x1e\xf6?\x81\xdb\xc6\x90\x11\xa7\xe2?\xdc\x9e\x97,`@\xc5?\xc2\xc8D\xeb\x88h\xc4?\x83\x1dw\x90(+\xe6?B\xb5\xc6~\x00\xa2\xf2\xbf\xdb\xe8\xfc\xe1\xe5\xbb\xf3?\x81\t\xdb\x93vU\xef\xbf\xd5\xd6\xbf^\x83\xe9\xf1\xbf\x8a\xcb\xf7PJ\xb8\xdf\xbf\xf2)L5\xc4\xd9\xe8\xbf\xd5^!\xe8S\x10\xe1\xbf\xbaK\x9a\xac\xbf:\xc1\xbf\x9a\x19\xf15\x8e\x88\xf5\xbf\xb7\xf4\x80\xdf\xccy\xe6?xWD\xd7\x86\x8e\xd6\xbf2\xcep;M\x9e\xf6?\xcfQ}\xcf\xc1\x06\xd0\xbfV%7\xc8]\x84\xfa?\xa0\x96d\x19\xddY\xfb?\x94J\xa88\xb7\x1e\xf1?\xed@\x16\x00D\x81\xad\xbfoo>\xd8\x96\xee\xe7\xbf\x03k\x8dH\xe7_\xfd\xbf\xe2\x84\xa5c\xc6\x07\xd6\xbfh\xbc\xeb\x88\x8f\xfb\x08\xc0O\x98\xa9\x82\xa76\xe6?L\x8d\xf6a\n\xeb\xed\xbfz\xce\x9e\x16\x1a\xbd\xe2?2\x95O\xa0\\O\xe0?SB\x1a<\xf5H\xe3\xbfDo\x1d\xb5\xb1b\xed\xbf\xfe\x98(\xa0\x90j\xb1\xbf6 W@0\x85\xee?\xa2\x98=\xadz+\xee\xbf\xac k\x18\xfb\xd8\xe0\xbfG\x92\xcf\xfc\xd8-\xbe\xbfO\x99\x96\x0b\xbc\xfb\xd6?\x8c\xa5V\x8d\xd7\x82\x94\xbf\x9c\xb6\xa5\xdd\xe9,\xff?.\xb5\x83\x96P!\xfb\xbf}\xec\x8e \xe8\x9b\xde\xbfm\xcb}8\x01\xb6\xfa?9\xa76\xef\xc9\xc5\xee\xbfF\xd6\xa1\x83\xeeJ\xee?\x1bb\xaava\x1f\xb0\xbfh\x92\x10\xf6\xf3\xcb\xf0\xbf~\x90{\x03\xe6\xf2\xe0?\xc2\x86XTi/\xf0\xbf\xa0B\xaeVa\xfc\xfa\xbf\x01\x0e\x993\x8at\xd7?<\xca\x84o.v\xf2?{\xd6{\xb3\xf4\x99\xc9?.I%\x8c\x7fu\x00@\\Q\t\xedS\x15\xef?\xe1@\x9dc\x8c\xfd\xd6?r\\\x1b+\x1dc\xb8\xbf\xbc\x991T\xd1\xc9\x9e\xbfy\xa7\xda1\xb4>\xd5? \xfa\xa6\xa3/\x84\x00\xc0?ir\xd0{E\xf3\xbf\'\xe7_\x8b\xa1\x0e\xb7?\xc7^OKS\x1b\xfc?\x9c\x01\x95!\xa6\xde\xeb?\xc5\xc2R\x8f\xe5/\xf0?e\xb94&Of\xe4?:\x16\x1d(\xa6\xda\xe5?\x02\xfd\x9ak\x191\xb5?h\xdd\xea<\xc3g\xea?\xe8.\xf8\\\xd4E\xf0\xbf\xb9\x12\xbf\xbf\xc8}\xd2\xbf\xa9\x1a\xf9ZR\xe5\xfa\xbf\xe8=\xedm@\xe2\xd3\xbf\x1f\xcd\xeac\xb6h\xe5\xbf\x8e<,*@l\xe8\xbf\xc8\x84\x9a4\xcd*\xef?\xa4w\xd7|\n\xab\xe0?\x94\xe33\x99*{\xdf?\x05\xf1\x93\x810}\xf3\xbf\x89%\xfdD\xd1\x90\xd6?\x81\xda#\x14U-\xbf?6\x1bY\x92\xd4X\xcb?\xc7\xb7C>\xf0\x12\xec\xbf\xf4\xb8\x1a\xd3\x0b\xf5\xed?\x02\xca\x00\xddu\x89\xd8?:\xe3\x88\x13l\xb9\xf1?|\xac\x82\x84hB\x84\xbfB\xd1\xe8\t\x15\xd8\xd5?mM\xb1_\xf6\xee\xed?\x17\xbc\xb7}}\x19\x04@@x;\xcfw1\xda\xbf\xe66\xab\r\xa9\x01\x00@\xa6KH\xba\xc33\xf6?uE_C=0\xf1\xbfT@m\xd5\x94\x12\xe8?\x04M\xaf\xae\xec\x0b\x00\xc0\x1a\xdfg\n\x05\x9c\xe2?\x95\xa0-\x0c{]\xe6?\xa6)\xc1\xf1Y\xb4\xc9\xbf\xe5\xedM\xb6i~\xfb\xbf\xc9M\x82\xa6\xdef\xef\xbf|\x16\xad\xdd\x14\x85\xfd\xbf\x85\x97\xd1k.n\xaa\xbf\x81\xc9\xe2\xdb\x10\x81\xf6?\x18\xb9\xb1^\xbf\xdc\xe4\xbfl\nEm|\xe6~\xbfZ\'\x8d\xa8\xf6Q\xf7?\xe6*\xfdo\x1e\x0b\xee?\xe9\xc80J\xdf\xc8\xf4?3\xbc\xf8\x8bz.\xe1??\xa0u@\x9f\xfa\x00@\xaa\x06\xb1\x1cJo\x01@.\x8f\xd5\xae\x0f\xe5\x00@\xf5BP\x98"\x82\x0c@!\x97\x04\xd8Z\xfb\x02@\xd5\xfc>\xf8\x90R\xe8?\xb1\x9b\x05\xc5h0\xdd?\xbf)$ \x1c?\xeb?v\xa0\xb3{\xa3\xdb\xf3\xbf\xb3\xbb\xfc[\x96`\xe0?>\xcf\xbdU\x18\x08\xe8\xbfoU\xf2\xbeF\xed\xfb?\x14>\xe8V%\xf1\xf2\xbfd\x8c\xb5V\xd0\x83\xf1\xbf4H\x87\x82\x17\x85\xfc\xbff\xb6\x8d\xea\x9eM\xb2\xbfO"n]\x8f\xdb\xe7\xbf\x83\x01\x1aec\xb5\x0f\xc0e\x92/\xc1\xc8S\x07\xc0\xe7\x90Nc\x15M\x03\xc0\x0b\x9a\xe5\xe1\xa0\xcd\xb7\xbf\xa5O)a\x17\xf5\xe7\xbf\x86\xd8+\xd3\x80\xa3\xf4?\\\xd0zl\xc8\xd3\xf6\xbf\xf6\x9c\x84\xc81A\xe5?\x0eG\xc2\xee4\x1e\x00\xc0K\xd7B\xa8_\x9e\xe6\xbf\xd9\xbe-\x81\x06{\x07\xc0\xa7\xc2\xc6\xf5\xb4\x03\x11\xc0\xb9\xea\xa8\xc3N\x90\xf8\xbf\x0e\xee4O\x83\x19\x00\xc0\xbc\xd7)\xc6\x1e^\xfb\xbf\xa0S\x8c\xc1\x15\xfc\xeb\xbf\xe6\xfd\xc3\xf9\x8c\x85\xfb?U\xfa\xd2\xdf\x91\xb3\x04@\\ \xc73\xb4\x0c\x0e@\x84\xc67\xf5\xbdT\xf8?tv\x07\xcf\xad\x97\x03@\xdd"R\x7f\xbfH\xdf?\xf3\xf4XgiT\xb5?:?[\xdd\xfd\xa4\xbc?\x02\x83c\xfd\x18\x04\x0b\xc0e\x02\xff\x92m+\x0b\xc0\xf6\x12/k+\xcc\xfd\xbfm\x10Z\n\x04\xe5\xd9\xbfr\nr\x9f\xf0)\xf0\xbf\xa0\xae\xf6]\xebH\xb2?F\xd2\xab\xfd\x8f\x8e\xe3\xbf\xe2\x94\x86\x1az\x1c\xd2\xbf\xef\xb2w\xe9G\xb1\xf5\xbfz&\xb13$l\xd9?r@\xcf7\xf6\xcb\xe4?\xf9tm\x1e\'\xdd\xf9\xbfJA\x83q\x13\xff\xf1\xbf\x19)0\x94\x94R\xf4\xbf.\xeb\x1c\x11\xe2\xdf\x01\xc0\xaer7\xe9\xd01\xc5\xbf\x0b:\x7f\xfe\xcf\xc9\x04\xc0\xc1<1\x82%\xdf\xe0\xbf\xbb\xd6\xa9\xc7?\xc3\xfd?\xaf4\x1aPQ\xc7\xa1\xbf\xc6\x04\x19\xa9\x89\x1f\xf5?D\xa5V\\5D\xf5?\x8f\xc6=\xa6\xb3v\xef?C&V\x80~\x0f\xd1?\x87\x17Xxa$\xf8?\x1b\xe3f\xba\xa0O\xf5?\x159\xaa\x95OX\xe8\xbf\x8b\xab]\xf7\xe3E\x03\xc0p\x1d.\xd2\xea\xef\x03\xc0o\xc1 \xb5\xb1\xb2\x04\xc0j\xe4jtou\xea?=\x06~\xfa\x85z\xfc?7\tb\xe4\x8c\x19\xf0\xbf0b\xdb\xc0\xc2\xef\xe1?T3\xba$G\x11\xcb?\xaa\xd7TT3F\xf2\xbf7X\xc4\xe0\x86\x9a\xb8?\x89\xa9.\x82{\x99\xeb\xbf\xb2\x9c\x9a\xfb8\x85\xf1?\xd6\xb64}\xa8G\xc2\xbf\xe0\n\xd9\xab\xcc\xe6\xa6?-\x93o\x9a\xe4\x82\xe8\xbfg\xf9\x87BS\xc0\xec\xbfn-\xc2\x95\xe3\x01\xfd?g\xe5*l\xdb\x19\xf8?\xfc\xc7;f\xd2\xa8\xf3\xbfk\xcf]V\x89\xf0\xec?\xdfV/\xb0|\x90\xce?1`7\xfd\x16\xc3e\xfd\xbf\x04G\xc4\xf6r\xec\x02\xc0\xe1q\x0c\xc9Z\x9b\x05\xc0\x08\x19\xc1i\xc5\x01\xfa\xbfo\'\x12YM\xd9\xd6\xbf\x15\x85\x9b\x97L\x1e\xd5\xbf\xeb4\xeb7W)\xf1?"+\'\xa2\xb1#\xf3\xbft\xc5\x0c)l\'\xd3?\x04-\x8c9\xc3\xbe\x05@\x17\xb0\x96%\x89\x1c\xd2?x\xf1\xac\xe4*W\xf6?\xa76\xb8\xe3\xc9w\xef?v\xf1\x891\xba\x9d\xe0\xbf\x9b\x8f\xef\xa8\xf4[\xec\xbf\xa7\\\xadqZc\xe7?3\xc8v\xbd\x88\xb6\xe1?\xcfbi\x92\xaa\n\xe7?\\k\xe5 \x15|\xe7\xbf>\x1es\x14\xdd\xd6\xc3?/IE\xe7\rZ\xbf\xbf\xdb\x8d\xb8\xc8\xcd\xfd\xe3\xbf\xcb?Ms?\xe3\xe3?\xa8\xc3\xce\x85\xc4I\xf6?Ey)X\x7fV\xce\xbfK~\x9b\xbc\x83\t\x06@GO\x9a\xce\x07\x11\xd1?\x1b<\xbf\xd5\'\x01\x02@\x9d\xbe\xdbT\xa2\x10\xcd\xbfX\xcb\xbc\xe2\xc9\xb1\x02\xc0RfG\xb1/o\x02\xc0\xc1\x7f\xf5\x9d\x0b\xf9\x08\xc0\xc5\xdbV\xa4\x1c\xd5\x05\xc0A\x9c\x08\x9f\xf9-\xf1\xbf\x8f\xe2\x96\xe2\x98\xa1\xff\xbf\xc2\x8103c\xcb\xff\xbf\xb3a\xc7\x8f\x8b\xce\xc5?\xeb\xc9\xf2\xb9C\xd8\xff?\xe6\xb7\x87~^r\xf2\xbf\x822\xf3\x0c\xd4I\xd9\xbf~\xb5\xe5\x040k\xcd?\x1b\xb6\x0f\xe4C%\xe2?\xd6\xb5m\xa3,\xd6\xe7?\x8d]\xeb\xea\x00G\xe5?\x804\xb9\xd5i\xe6\xec\xbf=\xfd\xa8\x9c\x97A\xbd?t\x1a\x1dO\xd9\x04\x9b?\xf4\xc52G\xe0\x85\xe2?\xcb\x8d\xa1\xdeEm\xe0??\x98\xd8\x9a\xec\xd9\xb9?\x87\x8a\xdfo\x12\x89\xf4?\xe7\x1a;\xc7c\xad\xfd\xbf\x19d\x99\x834\x92\xf0\xbfM\x94\xf8\x1e\xce\xe9\xe3?\x80\x0b\xec\x9f\x8a\\\x00@\x8dr:\x06}\xa5\xfa?]2\x94\xf2J\x9a\xde\xbf\x1b\x15y\x0e&\xff\xfd\xbf\xccN\xbeuV\x9b\xf3\xbf\x8c\x9cH$O\xf1\x03\xc0yOjt\xcab\x14\xc0E\x7f\x94tr\xf8\x15\xc0\xd5\xa7\x11\xc7\xba\x83\x16\xc0\x01\xb6^\x17\xe1|\x15\xc0\xf25\'\xb7j\x1c\x08\xc0\x82\xb9J\x03^\x80\xeb\xfc?~\xf3\xc1Y\x06\x12\xf3?\xccZ}f/\xbd\xc6?\x15\xdec~\x8d\x85\xc0?u\xfeO\x9b76\xea?\xf5b\x8e\xf88*\xf3?\x19\xb6\x16| \x03\xd8?\xef\xfcI\xd7\xcaM\xe9?\x96\xebpF\x9fM\x02\xc0,\xfbje\xd2\xe7\xc2\xbf\xd95\xd2\xed \xdd\xe7?=\xf6\xf9\xbb\xcc\x9e\xf3?\x80\xdc~\xb8\xaa\x81\xe1\xbf\xae\xa47m\xbf\x9a\xe0\xbf\xcf\x80A%\xa6\xf3\xef?:\x83:\xd3\xa8m\xec\xbf)\xfe\xad\x94H\xeb\x00\xc0\xcdf"\xf78\xdb\x13\xc01\x86v\xef\xa7^\x18\xc0\xaf\xad\xa1\x0fhT\x14\xc0\x06\xa9\x980\x06\x8b\t\xc0\xa0\'2\x89\xe4_\xd7?c\xd5\xade\xf6P\x07@je\x1e\xb8K2\xe3?a\x0c\x999\xb1\x98\xe5?PT\xc2\x17\xb2\xdf\xe0?\xec\x93\\?1\xf8\xf1?]de\t\x96\x97\xe7?\xda\t#A\'L\xe7?\x99\xf07\xbcn?\xe7?\xe8\xd3%\x1fa\x86\xcc?\xdb\x03#\xfb&\x03\xd1\xbfo\x90\xe1_\xc5\x80\xf1?\xa0\xa3~}sh\xf6\xbf\x13\x82\x04\x1c\x9f\x9e\xcf\xbfT;?\xe8\x7f\xc0\xef?\x08j\x98t\x80\x13\xf7?\xf4\x1fX\x9b\xfb\x90\xe1\xbf\xe9\xb8\xb0\xb2\x1e%\t@q\xba\x8e\xa1{g\xf8?rL\xd1\xd6\x87\x85\xd6\xbf\xc3\xf8-n\x05\x18\xf1\xbf@\xe3D\xdd\x0e\xc7\xb7?\xdb7\xe5K8\xa9\xe4\xbfT\x99\xa7[\xac\xa5\xe8??R\x06\x98)\\\xcc?\x83\x81\x81*\x92\x13\xf3\xbf\xc5\xb8\x82\x8a\xb5\x08\xf2\xbf\x17\xc7\xa6+\xa3\xd3\xf5\xbfm/\xf8\xe7A\xea\xd8?\xf6\x12\x9d\x01\xda\r\xd9?\x85E\x02k\xef\xf0\xdb?\x81\xe9{\x82\x98\xd4\xe8\xbf\x11\xc1A[\xc0x\xc5\xbf8\xaf\xc5\xbe\x96z\xf0\xbfCa\x10XD\x1b\xe2?\xc9%\xca\xeal\xb0\xf4?$\x0fB\'\xcb\x01\x9f?9\x1a\x14\xa7\x12B\xc3\xbf,s\x19\x81\x81\x04\xeb\xbf\xbc\xaf\xa3\rt\xeb\xf1?\x9e\xbf\x97)\x00\xec\xe9?\x9a\x15}Q\xf8\xdf\xbb\xbfe\xc46y\xc4i\xd8?\x1f@s\xc5dO\xb0?[\xc7G\xed\x0cz\xdd?\xed\xc6\x81\xfa\x05\x87\xf4??nwY\x11\x80\xfc?\xcd&\xbfx\x8d9\xe7\xbf\xfe\xe4\x8d\xab\xa66\xa2?O\\\xf3\xa6H:\xf1?i_"s\xec\xe7\xeb\xbf\xd4\xf7\xda^8\xe9\xef?\ryW|nB\xec?\x9e;f(\x7f\x80\xb6?\xab]t/P\x9f\xb7?[ \xae\xfclL\xe3\xbf\xb7Y\xf9\x1c\xd7\xe3\xd7?\xd41\xe2\xf7t`\xe2?7\x7f\x00\x9a\xd3-\xed?\x0b\xdev\xe9\xae\xf0\xd7\xbfb\xbe;\xa9\x00{\xe8\xbf7\xeeS\x05\xb4\xd9\xf2\xbf\x95\x99Fq\\\x02\xe4\xbfh\xf9\x7fgv0\x8d?\xbd\x85c|\xee\x15\xaf\xbf\'\x83\xfa\xbe\xe1\xf4\xe5?,\x88\xa5h\xdbt\xf1\xbf\xd9Z\xc7k<}\xe3\xbf\x06\x0cz\nd\x08\xe6?\x94\xc9\x8c\x03\x0e\xa7\xe3?\xa0b\x81#(\xfd\xfb?\xace\xf2e\x0e\xcd\xf0?\xa9\xcc\xadi\xce)\xe4?<\x90\x0b\x11\x10\xa7\xf7?\xc9\x07\x15\xf1\x83\xa9\xe1?\xcf\xdc\xdb\x9e\x18\x8b\xe3\xbf\x00\xb3A\x12R\xb4\xf4\xbf\xef\x0b\xf8\xa3\xd9\x94\xfb?-\xab]T\xbb_\xd9?mR\xdd\xc1=Q\xea\xbf\xce\x0c\x0e\x1dS\x04\xc6\xbf\x19K\xae\xa1\xf5\xae\x05\xc0\xcb8\xaa\xdf\xae\xc9\xf9\xbfh\x03K\xfcG\xc0\xe0\xbf\xb0\xf1\x83>G\x8b\x00\xc0\x8eF\x12\xcaa)\xf4?\x83\x9c\xc72B\xb5\xcc\xbfe\x046@\xb4\xd3\xf4?\t\x02\x88\x19M\x93\xc3?m\xfa]\xcc\x1c,\xdb\xbf;J\xdd\x8f\x052\xe8\xbf\xf5\xe0\xf0\xf5\xc8\x9a\xfe\xbf\x1f\x06\xdaX2\x11\xe0\xbf=m\x87Q\xfa\x07\xf6\xbf\xfa4\x8a\xe7\x120\xe4\xbf\x08%\xb9\xa6\xee\x80\xd9?\xca\xad%\xca\xc6u\xbf?*\xb3\xb9AO\xb8\xc7?\xf3\x89\xe6\xddT\x82\xfe?+n\xd2=\xcb\x8a\xd3?\xf4=\x05!\x99S\x00@GoR\x8bqc\xf0?6H\x18l6^\xf9\xbf\x9f\x8d\xc1\xd7\xacq\xf8?\xcc\xab^\xc4x\t\xd5?W\x98\xb3\x13\x17+\x02@\xe5\xd6\xf7u\xe9\\\xe0?{\t\xea>\xb8\x96\xe2\xbf\x16\x97\xe0\x1d\xae&\xd2\xbf\\\xbe\xba`P\xab\x01\xc0J\xc1\xb3\x9fld\xee\xbf\xfd\xd9\xf7\xc4\xc5?\xf0\xbf_Q_\x80\xfaZ\xab\xbf\xc8r\xd0\xa7/$\xe3\xbf}u\x07I\xa5Y\xe7?\x8c\xb9<\xeb\xf0\x8a\xe5?H\xb2Y\x93\x1b\xda\xe1\xbf\xf3\x96\xec\xcd\x8c\x9e\xe9\xbfZ\xf3\x1eJ5y\xed\xbf\x9e\xab\xb9\xea\xf9\x1b\xeb?\xfb\x1b\xad\x13_W\xf5?c\xad\x0f\xceq4\xdf?\xde\xb7G\xea\'D\xf6?\xca<\x11\xf0\xb8\xe5\xd2?nM>v\xad\xd5\xf5\xbf-F\xee\xfb\x99\xb1\xf2\xbf\x9e\xf3*N\x0b\x9a\xce\xbf\x16\xcb\xab\x92\x07b\xf6\xbf\xf1\xd5\x99\xf6C*\xfb?l(\x12J\\\xc8\xf2?G\xa0\xf5\xdd\xadW\xd7?\xaa\x05\xa4\x1e\n\x0f\xf4?\xcc\x12\x93\xa5g!\xd3\xbf.\xbd\xfd\x9f\xd7<\xed\xbf\xcfX<\xba\xc6U\x00@V\x04!\xa9\xd7,\x05\xc0\xb5h\xb3{AK\xf8\xbf\xee\n5a:\xe4\xed?\x99\xd5.\x96]\'\xb8?\xb2C\xa8\x8a\x8eP\xc4\xbfk\xd7Q\xf00\r\xe5\xbf6\t\xd0`\xe1\xb8\xb0\xbf\xe2\xf0\xb84\xac,\xeb\xbf\x8f\x97\xeddFq\xea\xbf+\xd3\x93\xf2\x94\x16\xf2\xbf\x97-\xea\xe3u\xc8\xd5\xbf#\xed\xe1\x7f\xaf\xe4\xd4?\xc8\xfe\xf4\xedf\x1b\xdc?\xea\t\xdc\xef\xd65\xf4?\xe4l8@\xaa\xa6\xf5\xbf\x14\xbe+\x8b]\x8c\xe0?\xa8\xee\xf5\xd7\xdd\xed\xdb?\x85\x93\\\xd9\xb4_\xe4\xbf\xe8\xa2\xa0\x84,\xd7\x06@=\xec\x80\xb8\x0f\x9a\xed?\xd7\xed\xfcmPm\xcf\xbf\x12\xf4\x1c{\xe5\x9d\xd2?\xae,\xf4L\x08\xdb\xec\xbf\xd3\x0e\xc3\xf1\xbb\x97\xcd?Ih\xce\xcc\xa6\xc1\xd3?\xf8}Lk_\xbb\x10@(\t\xbax\xc3\xd2\xf5?\xfcse>\xb5:\xfd?\xc9\xb9\x7f1\xc3\x07\xd2\xbf\xf5\xe8\x10\xa9\xd3\xa5\xc3?\x8c]\xe4\xe9\xcf\xaf\xc9\xbfH\x06\x04\x96y3\xec?j^2z\x87\x95\xf1\xbf\x8c\x04t\xfcN\xd3\xef?\x01\xc3JF\x87f\xe3?Y\xa4\x04\xc0\x15H\xef\xbf\xd4o\xba\xba\x12\x9e\xe4?\xaeG\xaeT\xe4R\xf6?\x00&\xbf\x8b\xc3\xad\xe2?\x82\xdb\xfa\x0bb\x91\xe7\xbf=\\\xdd_\x81p\xc2?\x13\x82~z\xfc\'\xd8?\x05l|\tY\x03\xee?\x0fJ\x12\x073U\xea?B;V\xd9\xf5v\xcd?\x1b\x8eC\x92V\n\xdb?-Z\x1b\xbes\xd7\xc3?\x97\xaf\x85\x0bM\xf3\xcd?\x14\xefi\x8e\xb6}\xe1?\x97\xdd\xab\n\x1f\x8f\xc9\xbf\x0c\xba\x918<\xdd\xd4?\x83\x9fQ\xd7\xc8\xb4\xe6?\ny\xd1#C|\xf9?M\xa5\xc7~\xe8\xef\xf1?\xc0\t\x06\x973\x17\xe0\xbfY3F\xe2:\xa6\xe0\xbf\x0c\t|yG\'\xf0\xbfn\x89\x0f\xef{\x0c\xe3?\xac\xd0\xc3J\xe8/\xd8?R\\pe\xa0\xa0\xdd\xbf@|\xff+\xe1\xd8\xe6\xbf\xeco\x8d{\xef\x84\xeb?\x1b\x8e\xd9\x90\xd2\xec\xe1?\xd1\x9a+8\xaf\x0f\xa1\xbf\xc7_z\x87\x07\xbd\xfc?3\xf6CC\x88\x95\xae?7\xd5j\xaf;\xdd\xe5\xbf\x16(\xb9\x8a6\x15\xaf?\xe6\xa7\xb4\xe582\xf2\xbf\x12\x9c\xe8L\x84\xe5\xf2\xbfL\xa7*3\x9a"\xd1\xbf\x0c\x14\x89i\x0e\xad\xcf\xbf\x14u\xb6E\xa6\x8a\xca?o\xe1d\xbf\x04\x19\xf0\xbf\xee\xf5:\xecWr\xe5?\xa6\xe69a\xdbB\x03\xc0u\xeaH1\x0cL\xe4?\x8f\xca\xdf\xb7\x08\x1d\xc5?C\r\xde\x05\x0f\xb8\xd9?X\xc8\t\x10\x17\x06\xf7?\xbbd\xd3\xe8\xebs\x9f?]\xe8\xd6+t\x13\xb4?\xcd\n\xa7\x19\xe7\xbe\xee?\x08X\xb6\x1c\x91\x8c\xf0\xbf\xdaF\xd2\xd7\xf4\xb2\xe4\xbf89\x18\xabR\x8b\x00\xc0K\xc5\x15_t\x8b\xf5?\xb9\xde\xd4)\x06o\xf2?):EC\xed\'\xc9\xbf\x9d\xd5|\x95\xc0\xdf\xf5\xbf\xbc\n\x80 V{\xce?B\xef\x8dba[\xf5\xbf\xaa\xbfd\xda\x00\xba\xf8?\x84\xe4=z\xaa^\xd9\xbf\xf6\x07Fu\x91\x02\xed\xbf\xbb<\x13\xc7\x91\x9f\xd0?\xdf\xa2e\xc3G\x15\xe9?1\xee\xc1\x19\x9c\xd3\xf3?\x95\x82\xe8\x04\xa9\xe7\xe7?\x9c/\x99w\xbb\xa3\x00\xc0\\\xf4\xbfaq\xd0\xf6?\xfa\x84 \x8d\xe3\xd1\xe0?\xa7\xd4{\x17M\\\xc0?\xe5\xb9\xaa\x0c\xf3\xe9\xfd?o\xcbC\xd0.3\xfc?4)\x1f\xb4\x92\x97\xe0?\xcb5\xb5\x17\xc4\n\xe2\xbfUaNy\xda\xac\xf9\xbf\x02\xf1\xff\n\xf3\xb0\xe1?l)\x01y\xe6\x9b\xe1\xbfs\xe3\nZ^\xa8\xf2?\xe9\x02\xdd\xa3\x90\x86\xd4\xbf\xaf{\xf9g\rT\x97\xbf\xa9\xfb\x85n\x08|\xf5\xbf\x93\xaa~+\xb6U\xd4?m\xf3,\xe0*z\xfe?E\xdd:\x0b\x99\xa9\xe1?=Y\xd9\xfa\xb6\x81\xd9?D\xb3\xab\x0cI\xf4\xeb\xbf\x9ax> \xf4\xb4\xe9?\x1eA\x07\xd1\xde\xe3\xfc?|\t\x84\x98\x9d4\xf0?\xc8\xc7\xd3\x84*>\xe6\xbf\xce\x08\xcf\xad\x14\xb3\xde?\x1f\x03\x17\x1ed\xc3\xbc?\xe16\x1c\x9ak5\xf8\xbfi\x16\xc0\xcbe\xa8\xf1?\r\x1f\xb6Kj8\xc5?\xcb\xeb\x19\xa8=\xcd\xef?\x7f\xb3\xbe\xae\x9a\xee\xef\xbfeM\\\x19\xd9*\x01@w\xbe\xb1\xae\x98Z\xa1?\x147)\xca\xc2\xe9\xe1\xbf\xeb\xea\x80\xba\x99\xfd\xfa\xbf\xbc\xbb\xb9\xa9\x880\xd7\xbf\xb0\x16@\x14;\xc3\xac\xbf\xc2\x9c-\t\x83g\xf4?/\x07\xa8N\xfc\x96\xd5?sJ=?\xd4\n\xc3?/\x18"\xfe2%\xe3\xbf\xd4G\x07\xe6\x7f\x8f\xf6?\x87+\x85\x9d\xcc\xaf\xf3\xbf\xb4!\xc2\xb1pJ\xf4\xbfI\xaer\xb2\xc5K\xca\xbfS\xe8Ll\xd9\x90\xe1\xbf\x9eq\t`\x91R\xd5\xbf\xb1\x12\x18\xb20\xb4\xde\xbf\\\xc3\xf0<\xb2\x10\xd2\xbfP\xc4\xd2\x85\xb90\xd5?lC\xb0\x10^\x9d\xcc?\x16\xbb\x98S\x81]\x01@2\x8c\x15b\xc8\xf5\xd2?3\x95j\xfe\xee\xec\xd3\xbft\xc2\xd0\xd6E=\xac\xbf[9\x06\xf9\x85\x1d\xff?\x17s\x00\xb7t\x19\xc0\xbfd\xd8$ZW2\xc6\xbf\xae\xbd\xb25\xed\xf6\xf6\xbf\xd6\xf9y\xfa\x90\xdc\xd3\xbfY\xa2J\x17\xb0I\xcb\xbf\n0H<\xd1\xad\xe2?\x1a\xf4\x10\x1f\x89 \xcc?$u\xc26\x13j\xe2?\xc9\xc5\x02Vz\x0e\xe0?\xfa"\xa5\x15\xda\xe3\xd8\xbfOf\x8b\xf4\xe9\x1a\xec?d\xb4\x9a\x88go\xea?\xcb+\x11\x1a\xd29\xe9?i\x94\x11R\xa7D\xf0\xbfi\xa0tz\x18\x9a\xf5?_gP\x8aA@\xd9\xbf\xd7\xaf\xe2\xd8\xdb4\xfa?\xfda\x9f\r\x99\x10\xe9?\xf1\xa1\xd1uK\x06\xe6\xbf\xaa\x83\xb4``\xb3\xf1?\x8cr]8\x0c2\xfa?\xc5\n*\xd7\xc5`\xea?6t\x88\x97c\x02\xf5\xbfaX\xc9\xf9;u\xf4?\xe9\x1a\x8b\xc9\xebj\xc2?\xb6\x89J\x86\x8e\x17\xf5?KF\x89H\x96\xe6\xb9?\xd3\xb5\x86\xee\xb7\xeb\xea\xbf+\xb7\xb2\xa6\xac6\xd4?\x17)\x13\xf6\xb1\x8f\xd9?\xf9ib\x15h-\xb0\xbf_\xdb\xfc$\x95\xa4\xd7?\xe5\xa9\xc2\xef\x053\xa0\xbfYC\xd4:\x95\xff\xea?\x80y\x07Ux\xb0\xdd\xbf\x136\xdb\'\xf8\t\x03@NN\xaf\x87\xc1\x06\xe1\xbf/\xb7\x8c\xcf\xcf\xf3\xf2\xbf\x83 \xbbc \x1f\xb4?\xe8\xc4\xd8\xb5\xce\xe4\xd8\xbf\xc5\x14i\xf4\x1d0\xd8\xbf\xdcn\x9e\xcc\xf1\xca\xf5\xbf\xed\xa3X\xa7\x00P\xf3\xbf8\\\x98\x8aS\xd1\xfb\xbf3\xe0\x84\xe0\xde\x7f\xe7\xbf\xca\xba\xe6C-\x99\x04\xc06\x01\xea\xcd^\x91\xfa\xbf6K\x021=\xe4\xb0\xbfY\xf7\x1c\xc1\n!\xe2\xbf\xb2U\xa2c\x86\xf1\xfb?\n\x8e\\Q\xde9\xfe?\xcf2\xa7\x81\xd7g\xe7\xbf\xd8\xf7\xf17\xd2H\x0b@\xeai\xa3EP\xb5\xf7?~\xf3\xcf\t/\x0c\xf5?G\x05;\xfd\xe5\xf0\xfa?\x83\x07\xb3\xf2\xe1\xe3\xe6\xbf\x9c\x87{=Y\x01\xf2\xbf\x07\x87\xd9\xb7\xde\x96\xfa?\xd6\xe51b\xeb4\xd3\xbf\x89\xfc\x05w\xcc\xc0\xd9?\xd0\x07\xd3\xb9a\x05\xc8?j{O%K\xa9\xf6?\xef{\xf3Z\x92\x07\xb6?\xb5j\xd7sB\xc0\xf0?\x1b~\xf6\xc7\xa5&\xdc\xbf\xcd]\xf0\xa3y\xae\xee\xbfG\xf6\xc0\xbf\x8ep\xd3\xbfV3\x84\xa7\x8d|\xf1\xbfv\xda\xe7\xf9\xcd\x7f\xf5\xbf\x13\x102\x82\x8d\x88\x05\xc0\xd2{\x7fi\x0e\x08\xae?\xe4"\xe5Hv\x0e\x02\xc0\x1c\xbfv3\x01%\xe1\xbfP\xf1\x1e`\x1d(\xfb\xbf\x9d\xc9\'\xee\x93\x05\xe6\xbf\x05\x1d5\x17go\xf2\xbf\xc1\xd6t\x1djj\xf4\xbf\x0cUX\xfb\xb7H\xbb\xbf\x8c}\x93\x18\x89\x16\xf3?\xe5\xef\xc6\xf6\xe1L\xf9?}\xdb>\x01\xf4\xd6\x05@#T\n"0|\xf8?\x85n\x85\x13\x13\xfe\xf0?\xbb\xc6\xa7L\xea\xf0\xd5?3\xe8\xf8y\xc6\xfc\xbd?\xb4\xe44\xd5\xdbO\xf9?\xcb\xb8\x9bL\xa6\xdb\xbb\xbfD\x03\xda$\xb5\x1b\xd6\xbfC\xa7\xabY:\x1d\xf2\xbf\xf0;|1S\x9b\xfe?\x9d\x95D2\xc6\x13\xe5\xbf\x97G\x7f\x94{V\x01@\xc7\xc6t\xcc\x07\xd4\xf1\xbf\xab\x05\xe3s\xab(\xe7\xbf\xac\xea\xdc\xa94\x14\xef\xbf\x81`:\xf3\x82\xa9\xf0\xbf^\x01\xbcT\xf2.\xfa\xbfu,\xa0\xa7\xc8\xc1\xcb?6\xe5\\0\xcfL\xf8\xbf\xca\xb6G\xdb\xb2\x9f\xd6?\xc3\xbd6\xe4\xb1\xa8\xd4\xbfG\xf1\x85C\x02a\xfe\xbf1~\xfa\xaa\xd6\xff\xe1\xbf\\\xe3\x95\xddkZ\xeb\xbfz\x1a\x9c\x88\xa2\xd4\xf1?\xd2\xa6\xbeI\xc8\xf5\xe7?y\xc3\xed>p\x05\xf5?\xb0\x8dR\x924T\x00@V\x07\xba\xb8\x01\x1c\xff?K\xcc1\xbc{d\x02@C,2R\x05c\xfb?\xc1d^\x89\xaa\xbc\xed\xbf\x15\xcd\x854\x06O\xe7\xbf\xbb\xc0\xd4\xd2\x92\x0f\xe2\xbfZF\xa4\x87\xb66\xeb?8\\\xdb\x17\xc7g\xe2\xbf~\x8a\xb0\x99\xca\xf2\xeb?\x02{\xb5f\x198\xe5?I\xb9\x08\xd9\x90+\xfc\xbf\xe8\x1fA}\xebQ\xfa\xbf\xfee7{\xee4\xf2?e\xaeQ\x1c\xb3\x9b\xf1\xbfA\xd6\xa9\x8e\x90\xb4\xd1\xbf\xd0\x88\x12\x7fR\x9d\xe1\xbf\x93\xe16b\xd9\xb8\xf0\xbfd+.\x83\x86u\xe2\xbfu\xdf\xcc\xd8\x1f\x91\xd0\xbf\xe1\xf6w\x01\xb2*\xe6\xbf\xd7\x10\xbb\xb1\x9e\xb9\xf7\xbffl_\x19?\xb9\x07\xc0YHz7\x96\xcd\xf0?0\x02\xe2\xe2c\x81\xeb\xbf=\t\x1f\xfdI\xf6\xdb\xbf_\xdd\x9b\x811-\xcd?v\xbb\xce\xa1vw\xf3\xbf!\xcf\x9b"\xd4\xcf\xda?\xabY#\xcdd2\xde?v7\xb2\xfa\xfb\xbc\xee?m\x15\xa2e\xfd\t\xfc?\xb2\x81\xbc\xc7\xaag\xf5?\x1b\xcdW\xaa\xddv\x97\xbf\x12\xfe\xde\x90\x8d\xd1\xe2??\xa0"\r\xa2\xbd\xf9\xbf\xdb\xb5+\xd8\xb8\x8c\xe2\xbf\x976q\xe2K\xae\xff\xbf\'1\xa2\x05\xfb\xfc\xfc\xbf\x91\x99.\xa3\xfc\x88\xf1\xbf/\x93A\x194L\xd4\xbf\x89\x7f\x1a\x9a\x9f\xfa\xe2?\r\xbd\\\\\xea\xfe\xe6?\xfd\xd7\xe0q\xb1\x90\xfb\xbf\x1b\xfa\xeenT2\xf3\xbfa\xeb:\x00K\xac\xe8?\x01F\x15Q\x91\xa3\x00\xc0;<\xa6\x12P\x18\xc7\xbfY\xa0\xfet|d\x02\xc0]\xcf\xdd5o"\xe8?\x9bb\x03\xb0\xbd\xe3\xe5?8m\xe0\xbb\xe22\xff\xbf\x97\x16\x87\x95X|\xe6?0\x8b\xf7\x89\xd2\x1d\x01\xc0\xec]\xe6\x9b\r\xee\xee?\x07\x9d\xca\xe1\x13\xb2\xf4\xbf\xf3\xb9\x98\x96\xbb@\xf0\xbf\xad\xd8IR{\xbc\xf5?3\xf6\xeb\x0f\x07v\xfa?\xe7`,\x15G\x07\x01@R\xc8\xf9\xcb\xc9\xe0\x05\xc0\xaa\xf1;\xcb;\xf0\xd6\xbf\x90b\'\x87M\xde\xf8?\xf9\x0b6\x8f\xb9\xfc\xd1\xbf%\xc79\x85\xc7d\xe1\xbf\x00%\n\xe0%\xc2\xe1\xbf\xbcB)x\xc4\xe9\xf9\xbfe\xbcy=q\x1e\xf8\xbf\xbe/\xad\xf1\xa1}\xfa\xbf\xc1\xd8>\x84\xb6 \xf1\xbf\xdd\xa5*$\x93\x99\xd3\xbf|e\x07\xc9\xa6\xb3\xd7\xbf\xf8\x07\xcdS\'\xf3\xe3\xbf\xd8\xd3e\xc0\xf9\xa0\x03\xc0@\xd8(\xec\xfb\xaf\x07\xc0\x9d\xf6\xff=?\x7f\xea?\xe6\xb5\x98\r\x06{\x02\xc0\x98V]>V\x89\xea\xbf\xba\x95\xd3>uo\xe1\xbf:\xb3\x7f\x91\x19\x1f\xeb\xbf\xcd\xe5\xd1$k\x84\xe4\xbf\xb5\xfb\xf1\xaf~\x07\xb3?Ir\xfe\x0f\xd8\xf0\xe8\xbf\xac\xed\x13|\xf3\x15\xf3\xbf\x98\xf2\x14d\xcd\x8e\xd0?\xc2\xc1\xf6\x80n)\n@\xd8\xe7\xf0^I\t\x05@\xdbor\xe5\x99T\x98\xbf,\x81\xcbIu\x81\xfb\xbf\x89\xfd\xda\xd76b\xdd\xbf\x80\xef\xf5wt\x99\xda?\xd6\x99\xd2\xdd!w\xcb?\x16gqt6S\x02\xc00\xc9\xbb\x84\xb1i\xf4\xbfl\xe2wg\xe6\xab\xfb\xbf\x8b\xb5\xf2\xb9\\4\x03\xc0\xa0\x16B\xdceT\xef\xbfW\xc7"p\x93W\xfb\xbf\xe9\xa6\xc1\t\xf94\xb4?q\xf1T\x19hM\xf3\xbfU\xf1\xc2\x14\x82\x91\xfe?\xcd\xd9:LE\xd6\xe1?M\xf5\xe9t\xa5\xd9\xc7?\x93\x00\x8e\xb4N\xba\t\xc0\xa3]\x9db&}\x04\xc0x\xcf~4\xf3?\x99\x0c\xac\x87\xad\xca\xfc\xbf~GW\x18k.\xdb? \xb5\xa3\xae\x15\xff\xee\xbf\xf0\xcc\xaff\xcc\x08\x00\xc0J\xb6\x05o\x80\xb9\xd3\xbf4`\x12|\xbb\r\xd7\xbf\x8c\n\xc9\xc0\x7f\r\x06@\x95\xa0\x99g5\xb3\x08@\x83\xe7p\xb4w\xc7\xf3?\xaa1|\xd1\xd8\x03\n@\xca\x1e(\xab\x05\x96\x18@\xba\xf2B\xf2[\x84\x1e@\xdb>\x1c\xce\x0e4!@\xed\xd5\x99\xe4\x827!@\xdb\xbe\x95YWD @\xfb\xdd0d\x89\xd4\x1b@\xa0\xd4S?\x8e\xed\x04@\xef/\x02x\'`\x0b\xc0\xe1!\xc0\xff\x06\xeb\xe6\xbfSPI\xe7h\xba\xf4\xbf\xd8\xa1\xa9[\x0f\xa5\xf3?\xbe\x14[bk\x95\xf8\xbf\xd4\xaa\xd0\xa5=\r\xd6\xbf\xe8\x9ar!!F\xe2\xbf\xd9su\x81\xf3\x9a\xf9?\xcc\xab\x02\x0c\xdf\x11\x07@\x18%*\xc5\xcc\xc0\xee?\xd0\xae\x84\x8d\xf7\xd3\xbf?c)\xb8*\xe8\x0f\x00\xc0?p\xc0\xdb3-\xdc?\xb8\xf8<\x0e\xfa\x1a\xa8\xbf\xc3\x92-\x97\xf9\x0f\xea\xbf\xbb\xa3\xca\x17\xdb&\xed?\x1b\xe4\x03/p\xbc\xdd\xbflNx\x81\xb6\xfb\xff?\xee<\xaf\xc3\x1b\xdc\xf7?\x12\xef\xc0\x89\x107\x18@h\x95\x88\x8cj\xbd\x19@=\xa0\xde\x9e\x15X!@9\xd3%\xcfb\n\x1b@\xcf\x05\xb8\xb5R\xb3\x1b@\xaa)@F\xbe\xc2\x05@\x8b\xc0*\xffm\x13\x04@@\xf0\xb7\x11;g\x0f@h\xc8:\xf1&J\x01@\x85\x9a\x82p\x14\xa7\xee\xbf\xe1\xe5\x84\xc8$E\xec\xbf\xe2\xb9\xc6|Q}\xf5\xbfF\xfeA\xd9\xfe\t\xcf?\xd3\xc0H.\xfa\xb6\xfe\xbf{\xeai\xb4\x10S\xf5?\x14\xb0R&z\r\xf5?\x8b\x84\x0e(\xb6{\r@\xcc@\xceU5\x80\r@Z<\xba\xf7\x808\x0c@w\x82\xa3\xda\xb4\xd0\xb1?\xa2\xabz\xe1\xff\xe5\xf1\xbf\xd5m&\x87\xed\x83\xe4?\xce\xb8\xd3yo\xbb\xe4\xbf\xb6\xb2\xc9sv\x17\xdd\xbf\x85\xe6M\xc4.\xf5\xd4?\xeb\xae\x11=<\xe1\xf2?\x96X\xbf\xfe[\xb0\x00@%J/D#\x9d\xfb?\xc790\xb5-\xa7\x13@r\x0c \xdd\x00\xfa\x1d@9?\xe1\xa0\x9b\xd4\x0e@p\'\xdfA\xdc\x95\x04@!\xedH/\x9a\xf3\xca\xbf\xef\xfau\x10\x17Q\xe2\xbf1\xddy=\xdbq\x05@m96\xa83\xfc\xfc?\xebx%l.\x81\x96\xbf(\x87\xa2\xea^,\xfe\xbf\xec\xbdz\xfb\x05\x01\x06@\xdf/\x86\x16\xbc\x02\xd7\xbf\xdb\x93\x02\x02\xd4\xf7\xe9?\x05+g\xbb\xff\x95\xdb?9\x16q\x90\xf1\x1e\x9a\xbfm\x93-@\xb4\xd8\xae\xbf\x82\x8e\xa3\x15x\r\xfe?~\x8ce}s0\xfe?\x9c\xaa9\x8e\xadS\xdd?\x0e\x90\xd3\xda\xcd\xcf\x9e\xbfJ\xb3\xb6?v\x18\xf5?Nz\xd8S8\xaa\xef\xbf\xe9\xdeXH\xfd\x9e\xe2\xbf\xd6\x85N\xa97\xb1\xe0\xbf\r*@\xcfW\x83\xf7?\xcf\xc1\xdc\xac\x81a\xda\xbf\xb4\x87\xc2\xb4\xbb\xf7\xe7?G\x007M\xc0W\x0b@\xadZ\xae\xc9\xb0\xa6\x15@nN\x1d.\xae\xb2\xf5?\xa3\x18\x10\xcc\xba\xa3\xf0\xbf\x05\xbf\x83\xbc\xf7\x84\xe2?\xcd\r\x9b\xe7G\xfc\xf1\xbfT\xf6\r\xb8+\x0e\xe9?f!\xb6\xef\xabb\x03@\r\x89/tx\xb7\xea?\xfc!\xc8\x9bf\xd5\xb3?e\xf2\x05m\\\xa6\x08\xc0\xc5\x8e\x8d\xe75z\xd8?W<\x8ffiB\x01\xc0\x01\x82\xd0\xaa\x8eY\xd1\xbf{\xc6$Y\xb24\xa3\xbf\xcc\xa4\xdd\xa8\xce\xa4\xeb\xbfkC\x1eP\x82\x19\xf0\xbf\xb8\xba\x1bb\x13\x84\xc3?Gv\x7fO\x11~\xfd?\xe5h\xd89\xc8\x7f\xe0?G\xde\xb7\xbb\x01\x9c\xbb\xbfS\x10\x16\xe8\xc1\xa4\xe4\xbf?\x11\\\x93\xec\'\x07\xc0\xc50\x9a3\x1a\xbe\xc7\xbf\xd96\x9a\xf2+\xa6\xc9?\x05\x92\xb4GZ&\x00\xc0\x8f\xec}\x9f\xef \x04@\xf6)l`_i\xf3\xbf\xe5\xfc\x94\x99\xb0&\xb9\xbf\x8c*\xa5sg\xc2\xb4?\xe9\xb3\x0b\xcc\xe2\x04\xe9\xbf\xbe\xbcX\xf6\xb7|\xe7\xbfH\x1b\xd7\xf1\xd9\xe4\xf1?\xe2\x06\x07=2\x86\xe1?\x07\x89\xa8h\xe6I\xf2?W_oX\x1f/\xc9?b\x89KBM\x9c\xed?9\xa4\xc6\xd9BZ\xfd\xbf\xba\xb2\x16\xd5\xb7b\xe5\xbfF\xa8|\xb57\x0e\xe1\xbf\x02\x03\xbf\xe7:J\xf0?\x9e\xebU\x0e\xd3m\xed?\x91\xf7|\xed{\x83h\xbfP\xba9\x86\x87\xc9\xe6\xbf\xf6S\x00\xf1f3\x00@\x12\x80U\xdf\x08\x83\xf1?`\x1e6\xde\xcf\x18\xf9?t\xdb&\xb0{O\xed?P\x9c\x16J\xf5v\xfc\xbf\xdc\xd9+\x85g>\x03\xc0\xc8\tO\x82\x032\xf5\xbfJ[L\xc9]#\xe4?\xca\x9cd\x90\xaa\xcc\xda?\xfd\x16I\xdd\x18\xb5\x01@\xc7\xfe-\xc4\x14\xda\xf5\xbfx\x9e\x1a\xad\x18\xa4\xe8\xbf\xae\xc2\x93p<\t\xe2\xbfh\x95B\xed\x1f\x19\xd3?71i\x1b\x82>\xf4\xbf\x8c\xcc\xe1\x00\x8d\x1f\xf3?\x82\x8c\xb7\x16\xa6\xa5\xff?B\xccc9\xc2\xf1\xe0?\xe1"&\xea\xb3\xd9\x03@HPCN\xb4\xde\xdb\xbfU\xde\xa2E\x10<\xed\xbf\xe7*W\xa5\xd2\xd6\xe6\xbfW\x0e\x1f\xcf\xfc\xa7\xe1\xbfQ,\x8d\x16\x03\xe7\xdb?\xc3a\xab{p\x81\x98\xbf\xba\xcb"7\xfav\xf2\xbf\x85P\x1c\xee\xe9\x1c\xf1\xbf\x85G\xc7\xads\x9d\xd6?\xf2\xe3Ki\xd7K\xe2\xbf\x90\xa2\xc6\xb5\xff`\xf8\xbfpT\xcbk\x89\xdd\x08\xc0\x07\x9aM\x80\xd4\x83\x01\xc0\xa1\xf4\xcd\xc2\x12t\x07\xc0}\xcc\x89wl\x9c\x00\xc0\xf1\xe7\x8cW\x8d\xec\xed?\x0b\xf0i\x91nM\xf7\xbf\xe7gmd\xbd[\xab\xbf\xab\x1b\x8b=\xc5?\xf1\xbf%\xf7\x8d\x95n%\xd5?\xc9\xe4\x84P\xd3`\xe0?;\x88\x06\x1d\xfe\x1d\xdf\xbfg)\xee\x7f\xcb"\xf8\xbf\xc9\x03\xbb/\xd0\x8f\xd1\xbf \x1a\x0cD\xd7O\xd0?\x19\xc97\x03=\x88\xbc\xbf\xcf\xc4a\x06\t\x15\xf4?\xafo\x14\xbc\xfea\xf6?\xd4\xb3k\xfb\x96\xf5\xd7?\xcfcl\xbe\x93\xbf\xfb\xbf\xa8\x90\xe3\x82\xbf(\xf6\xbf\x02\xe2+g6_\xe4?\x9fx*\x11t\x86\xf6\xbf\xded\xc5\x17%\x02\xe7\xbf\xd8l\xaf\xf1Ey\xd0\xbf\x86//i\xa9\xc5\xfe?\xf7>=\x93\xd2\xf2\xca?b\x9c\xda\n1\xcc\xfd\xbf\xd8\xd0\xfc\n\xf2\x00\xea\xbf\xe2\xa1\xa3A9\xf2\x02\xc0\xa2\xa1\xda\xad6\x9d\x03\xc0\x08\xbe\x9f\xaeRb\xfc?A\xe7\\\xa7\t\xb5\xc8?\xa9\xeb\x94fW\x98\xf3?\x01\x85CW\xbb&\xf2\xbf\x1b\x1d\x86\xd7Y4\xec?\xeb;\xa4\x89\x15\x8a\xec\xbf\x8a[\xf9\xf7\xe3\x91\x05\xc0\x9a.QM\x82b\x01\xc06\x0c\x0c\xff\xeeZ\xec\xbf\xa9\x0eP\x93\xed\xc2\xe3\xbf+\x89\xbaP(\x04\xfe?\xf5\xaa\xfe\xf5|\x9d\xf9?\x82\xa8S\xb8\x13u\xe8\xbf\xd96|U\xb5\xa5\xd2?3\x02\xeb\x87\x83\xa1\xcf\xbf\xd0\xe4\x9a\xea\xe0\xb8\xf5\xbf\xceS\xdaC\x7f\xa8\xe5\xbf\x8f\x97\xe1\x90\x1a\xc2\xee\xbf\xae\xfaG\xbdpa\xd5\xbf]h\xb6l$\x9e\xf3\xbf\x1b\x8c\xd5\x14\xbcn\xf6\xbfE\x0cK\xa6Z\xb8\xfe\xbf\xd4\x9b\x14@]\x80\xc7?\xcc\xd3\x0e\xd6\xa3\xb5\x00\xc0\xc4\xbdy\xb4>6\x95\xbf3\xf9\x85\xa1\xf2\x1c\xfd\xbfd\x86\x1f\xbbz\xf7\x00\xc0\xc6\xc8\xb9\x8f\x9c\x8d\x0b\xc0\x80\x87}l\xee\xeb\xff\xbfo\xf1\\tM\xab\xd4\xbf\xeby\xaep|\x80\xf9?7e\xb7\xc7i+\xf9?\x85\x8cFy\xc3\x04\xf6?\x90\xe4\x1e\xe0d\xf8\xf2\xbf\xe2Y;\x15\x82\xf9\x06\xc0l\xa55\x04x&\xe0\xbf|\xd6\x84u\xc9\x98\xe1\xbf\xaf\xd7G\x06\xd8=\xe6\xbf\xac\x83\x01[L\xc8\x00\xc0\x89\xdd\xbf\xd1\x90\xd0\x07\xc0\xc4D\xb0\xf92T\xe1\xbf\xae\xe9\xee\x85\xd0\xfc\xfa?v2\'\xc0\xd3B\xf3?6\x1a`O8\x01\x02\xc0\xa5\x1d8\xa3\x14/\xe2?\x02\x94\xe3\xb1\x18\xea\xcd?U\xdd\xa9\x16s\x02\xf8\xbf\xc6#\x01o^F\xe1\xbf\xa4\xdb\xbbmD\x07\xcb\xbf5i\xadl\xce\xb8\xf0\xbfgwd\xee\x8a\x15\xce\xbf\xc8P\xa2\xf9)n\xf8\xbf.\x06{9\xf45\xf2\xbf\xa7\xa8\xf4\xf7\xe6\x82\x06\xc0\xe18g\x9ft\x86\x00\xc0\xfeN%\'\x12\xf1\x02\xc0:T5\xff\xd7_\xd0?\x1c\xd1J$\x8b3\xd2?\xe7d\xb0\xba\xfc\x1f\xf3\xbf\xdf\xbeh\xce\xf3\x85\xfd\xbfly\xecsdp\xff\xbf\x04\xd1\xba7~s\x05\xc0 \x16\xa7\xb9\xcf\xb5\x00\xc0\x9f\xf7\xed\xd1\n\x82\xf4\xbf\x92IEZ\xb4\xfb\x02\xc0jG\x17\xe0"/\xfa\xbf\x8f\x8f\x91\xd7Nw\xfe\xbf\x19\xabh\xfc\xe7\x18\xe5\xbf\x08f\xbdZ\x858\xe5\xbf\xb0)\xb9\x1e\xc3$\x04\xc0\x85w?\x8a\xa3\xa7\xf4?]2\xfa?Ti\xfc?\xa5\x069$\xb6\xf5\xdf\xbf*\xc8\x8a\xb2\xcc7\xe3\xbf-\x9e\x7f\x8c\xc3r\xd8\xbf\xdc\xa1A\x19_\xcf\xd5?\xc1MV\x9f\x00\xef\xfc\xbf\x07\xd88\x80\xdb\x9a\xf2\xbfFf\x85\xce\xd6\xf6\xe9?Vt\xdf\xb9T\xbd\xd4?\x1c\xba\xa9X\xc8\xdd\xd4?\xe5\xfc\xcdqLD\xfe\xbf<(|\xa9u\x01\xc0\xda\x91\xc9H\x8d\x12\xea\xbf\x99\x8a\xbfg\xf8\xea\xc1?\xa4\xc7F\xf9\x9a|\xc6?I\xaa~\xaa^\x9d\x03@f\xfe*iD/\x00@\x84\xd6\x86\xce\x02\x89\xf6?7D\xbb\x1d\xe6E\xf9\xbf\x03i\xd0\xc4\xcfo\xb6\xbf\x80\x0bfz\xd0\xa8\xe1?"7\x8fZ\xd6\xe1\xb5\xbf\xa0O\xb2z/9\xd5\xbf\xab\x07\xc4[\xd5\xae\xbb\xbfBK\xef\xfe)-\xe2?rmKrM\xe1\xd6\xbf\x0fH\xf8\xd0\xd4\x96\x05\xc0V\x97\xab\xc4\x1ak\xf5\xbf\x143\xb2\xf1.\xe2\xf0\xbf\x04y\xf1\xf4\x97n\xd2?\x8a\t\xc2\xca\xfd;\xdc\xbf \x02\x8d9\xc0\x17\xda\xbf\xf1\n4\xd14Z\xd8\xbf\x07\xcf\xc4&I\t\xaf?\xe4\x0f\x8ay\xc8u\xbf?\xcb\x8d\t\xfdG:\xcb?t?Y\xef<\x8e\x03\xc0\x13\xa5\x18c=#\xf7\xbfD\x8d\t\xe8\x97\x12\x0e\xc0\xc2@\x00\xa9\xca\x1d\x01\xc0\xa8\xf5\x8f\'\xf5\xfb\xeb\xbft\xee\xc1X\xe6\xa3\xc5\xbf3?\x1e\xfb\xacc\xd0?\xb9u\x07\xe0\x00$\xe1?\xf9\x95\xc1\xa7\xe4 \xee?\xff\x05\x0c\x0eq\xb1\xbc\xbfO70\x07Fk\xe4\xbf\xb2\'\x05a\xad^\xf5??\x16\xe8g2C\xf0?|\xbceex}\xf2?T\x9c\xabI\x82D\xfc\xbfq}\xb1\xef\xdb\x8e\xfe\xbfe\r;i\xae\xac\xd6?\xb6\xf7\xfa~\x10\x1d\xdc\xbf\x18\x18\x83\x89\x02\xdf\xf1\xbf)\xc2\x81t\x97Y\xb1?\xd4\x88\x96\xc2\x88\xf6\xba?i\x15l\x9eJ\xe5\xeb\xbf\xef\xc0ry/\xbe\xb9\xbfW\x87\xf5\x7f\x07F\xef\xbf\xca\x7f7\xb2@\x7f\xf6?X\x16\x95\x9c\x8e\xa3\xf1?_\x1a\xecL\xe2a\xb4\xbf\xf1E/\x15_b\xe8?\x8d\xba\x1f\xb9\xe5\xa0\x01\xc0-5\x17\xc5\xf7\x15\x01\xc0;F\xaa/w\x00\xf0\xbf\x9e\xb8\xc2\x99\x05\xc3\xe9\xbf\x85\xee\xf5\xae*0\xe7?g\xcd\xd2\xe8&j\xc5?@\xc8=\xc2|O\xdf?&\xdewg5G\xe0?\xed\xf7\x93\xc3\xa5\xea\xf6?\'l\xdd\x92\xf3\xed\xda?{\xa5\xaa\xb8\x01/\x06@\\\xa4\xdfU\xc8\xbe\xf0\xbf]=\x10+\xc6\x83\xc1?,\x14\x19wv\xda\xf8?*k\xb0\x93\xe1\xf3\xd9\xbffA1\xee\xc1\xef\xeb?\x1d\xb7tg\x14\x14\xe2\xbf;\x16\x0c\x1b\x95\xcc\xfb\xbf\x1c\xd4\xe7\xa7\xc7\xe6\xe2?q\xe1qb\x91 \xca?\xf8[\xf2\x07Ip\x9a?\xa63\x9e\x13\xad4\xe5\xbf\xe1\x89\xf2e\x0b0\xd3?\xbaR\x8d4\x03=\xfd\xbf\x9d\xc6\x1e\xaf\xf7\x94\xf2\xbf\xc7X1\x87R\x9c\xeb\xbfK-/\x00Tf\xf1?\xb0\x84\x8b(u\x10\xc9\xbf0\xcdV0\xac\x14\xf8\xbf\x1a\x0c|\x8d\xe1\xae\xf0\xbfwJ\\\xcbfd\xfd\xbf`\xed\xd3iF\x08\x06\xc0jd\xd1=\x02\n\xf5\xbf\xc0\xffR\xdc\n\xcf\xe8\xbf\xd4H\x80BHG\xa1\xbf\xed\xc6\xf4\xbdwx\xf3\xbf\x8a\xe3\xbdcT)\xab?\xad\xa3\xc7/\x08\x96\xf2\xbfK]\xe1\xfc\x8c\xfa\xe6\xbf\xbe\xd1\xd4<\xf1d\xdc?\x9e\xd1\xe8\x8f\x91\xe9\xc1?\xd9\x0e\x18\xbeZv\xfc?\x83\x8e\xa4\xae\xfc\x08\x08@\xd5\x99\x92\xc4\xe1\xf5\x07@d\x1d\xe4\x81\xf7\x97\x02@\x05\xab0\xbe#\x1f\x00@\x1d\xa5Q\xe6\xc6\xcd\xde?\xbe\x02k\xfa\xcc\xda\x81?\xedGP\x17\xe6Q\xe5\xbf^\xdeL\x18\xac\xff\xe5?\xe2YC\xc3\xf4\xe0\xf7\xbf\xda>P\xe3q\'\xe7\xbf\x12b\xc0~\x8f\xec\xeb\xbf\x8a\x9fK\xc2BS\xec\xbf\xdc\xc0:h\xad\x03\xcb?\xfdT3\x19\xc1<\xeb?\x18f"\xd1j\xcc\xed\xbf\x04\xdb\xb4\xee\x84\x86\xf9?\x96\x06q\x96|j\x81?C[~D]5\xed\xbf\xef\xae,)\x16\x14\xd0\xbf\x88\x9a\xa4\x11\x8f\xa1\xfa\xbf\x1a\t\'\xa8\xb9r\xf6\xbfC\x16\x1aM\x81l\xc6?\xf5\xd5\xc1\x19}\xf4\xf9\xbf)O\x19\x83\x18\x0c\xd6\xbf\x8a\xcb\x8a\t\x92\x1d\xd6?\xf6d\x04\xa4\xb0B\xd9\xbfQ-\x95\x01\x00Y\xa0?\x99\xb9\x1d\x81v\xca\xac\xbf\x83\x93~\x11\xae;\xf5?z,\x86X\x87m\xf0?\xa2)Miz\xbd\xf2?\x8cU\xffS\xbc&\x08@\xfe\x89eu\xf6\x07\x02@@\x1a\x1d\x05\x82\x11\xde\xbf\x84\x96l\xb2E\x0c\xcd\xbfttlmP\xde\xed?\xf6\xd6\x833\xc8\xe3\xe4?$\xeb\xa6o\xf9\x87\xe4\xbf\x83\xd0\xe8\x11+\x1d\x00\xc0\x06t\xd9\xcd\xcc{\xc3\xbf\xc4\x14\xc8\xfe\xb6\xeb\xf9?\xd8\x7fLD,d\xca?\x01V\x107\xe7/\xdb?\xcb\xf7uP\xb1\xe1\xce\xbfT(\xcf\x15\xae\x1b\xe4\xbfg=\xbb\xb9\x18n\xe5?\x8fj\xf0\xc9\xaa\x9a\xe3\xbf\xc2PE= \xc0\x02\xc0\x97\xa6\xb2\xe1\x8a\xc8\xf6\xbf\x83\x1bvC}R\xdd\xbf0\x940\x04\x8c\x1b\xfb\xbf5\xe5$?\xc4\xf8\xea?\xf9\xdc\xba:\xb5\x10\xe2\xbf\xdbm\xa8S\xac\x0e\xfd\xbf\xfb\xe7v\x9bw\x89\xb7\xbf\x8bL\xd6]\x9f4\xff?\xef8\x16\r\x8fS\xe0?\xcdul\x16\x19\x1d\xfc?=\x1fz\xd4\x85\xb0\xd9\xbfN\x00\x1dLA]\xc5?\x17\x0frhR\xf7\xdc\xbf\x9c\x9a\x8e\xe5\xf5\x01\xd5\xbfN\x0b]\x89\x06\n\x02@\xf4T\x91\xf3\x8dS\xe7?\x83\xd2<\x82<\xbb\xf0\xbfZJ4\x7f-\x7f\xb1\xbf\x93\x92h\xbeq\xd1\xe5\xbf\x86\xe3\xa9H0\x90\xe6?\x01o~\x9a\xe2\x04\xe4?\x9eB\x0fu\x03\x98\xd3\xbf\xd0\xdc+S\xab\xd3\xc2\xbf\xad\x84\xcd\\|\xcf\xd9?\xad\xb9\xef\xcb\xe1`\xef?\'%\x90\xc2\x02\x12\xed\xbf\xa2e\xf8;\x80\xcf\xe0?\xaeA\xfb\x06\r\x19\xe2\xbf\xb5\xc4\x11\x92\x87\x11\xf4\xbf\x89\xef\x8e3\xa1\xc6\xcb?\x9ed\xb5rG|\xd8?\x90\x14K]\xe6\x01\xf9?Nj \x18\xff\xf6\xe8?\xc0\x8d>\xfd[\xbb\xed\xbf,\xeb\xb2\xbd\x99A\xd4?\xb7\xa6\x81\xff\x9f,\xf2?\xf1\x10\xeb\xd0\xf1\xdb\xd5?[\x9b\xad\x0f\x18J\xe1?e\xbd&\xa5\x13a\xfd\xbf\x90\xe1V\x85\x1eT\xd4?\xc6R\xd9\xae\x9c=\xaa\xbfg\xaaK\xd5k\x1c\xed?\x91TJ9\x84\x94\xa7\xbf\x88\xd8\x9a\xb3i\xaaz?\x9d)\x05\xbb\xae_\xe1\xbfO\x8c\xcal\xce;\xd8\xbf\x1a\xfcB\xbc\x94\xd6\xfb?HD\xb6\x16]\xd2\xd1?\xe7W\x03\\\xba\x8d\xeb?\xccQ\xee\xb6\xda\xcf\xef\xbf1\x1f\xb81\xd61\xf8\xbf\xba\xdd\xc1\xf1\x93u\xf1\xbf\xc6\x96+\xfc\xef\xf0\xd6\xbfv\x07\x03\x9b"]\xf2\xbf\xe2}\x9a9GQ\xe2?\xce\xa1\'\xff\xa8>q?x\x81\xbdb\xe4\x91\xf3\xbf\xb20\xc8\xb1\x19\xd6\xb1\xbfb\x02\xe9\xbeA\xe3\xe1\xbf_\x95\xda\xfc\x84Y\xeb?4\xf5\xba\r}\x06\xf1?\x95\x01\x98s(\x1a\xf0\xbfP\x1e\xc6\xf0 ~\xf2\xbf\xd8S|\xcd\x94\x06\xd8?:Y\xc5\xc0\x00\x18\xe4\xbf\x14\x1f\xf1\xda7*\xd8?W\x86U\xd9S\xa5\xd0\xbf\xf8\xfb\x0c\xdc\xa4\xf9\xa3?eAt\xda\xd4*\xf1\xbf\x02Z\xfa\xef\xed&\xfc\xbf\xf6l|\xfc^*\xf0?\xed\xa5\xd0\\\xc8&\xad\xbf\xb3i\xc0\xa4\xca\xf9\xee\xbfR\xf9\x87p\xc2J\xe7\xbf\x14N\xebm,n\xbf\xbf\x1c[\xe5[p@\xe3?j\xbbZj\xaf\xad\x9a?\xd7\xa1\xdaU\x8cf\xe3\xbf\xcd,J%k\xa6\xe2\xbf\xc6L\x1f\xaf}\x82\xe6\xbfx\xcd\xe6\x8fk@\xe0?\xae\xf3\x14\xcd\x9b3\xf8\xbf\xba\xe1\xcen_m\xfd?\x8a\xc5\xe5\x86#0\xde?}kD\x1eq\xde\xf7\xbf2G2s\x17\xe6\xc8?h\xb6\xf8\x15\'\x07\xe5?DX\xe2\xcf\x85+\xf2?V\'cUQ\x10Q?\xf3\xe5\xb1S(\xdc\xe4?-V\xa8\x81\x19\xa9\xa7\xbf\xeb\xe0F\x83\xc3\xce\xe2?5\x13\x01.\x99\'\xdb\xbf\x9c\xef\x11D\xa4\xd0\xdf?\xc8J\xe9f\x8b\xac\xe5?)\xa6\xbc\x96\xd3f\xf5\xbf\xe6o\x14#>\xa2\xe0\xbf\x83k\x12\xd0?g\xaaV\xf9\xb3X\xe9\xbfrS$\xaee\xac\xba\xbf\xbf\xb6x\x9aqo\xf0\xbfx\x0f\xd93\xf1\xc3}?\xa7\x18Q\xa5\xe8\r\xc6\xbf\xdd8\xd3\x96\x98\x93\xe5?\xe8\xb7CR\x13\x9e\x00\xc0\x8a\xcb\n\xaa\x18\x02\xa4?\x15\xb7\\/\x8c\xbb\xf5\xbfji,wo\xb8\xd6\xbfv\x1d\xdc\r\x128\x04\xc0\xef\n\xce\x81\xca\\\xde\xbfp\xbd\xc7&\x8a\x96\xf2\xbf\x1e\xb6\xdbco3\xdc\xbfb;\xc4\xb5\'\xeb\xb1?c\xb0\xab%>\xe4\xd9?\xd5D\x98H\x04J\xce\xbf(\nb\x97`\x15\xc2?\xc3N\xe4\x10F\x16\xf0\xbfH\x1d#Z\xf29\xe0?\xa6\xa4p\x9f\xcf\xb6\xd1\xbf\xbb\xf7Y\x85i\x9f\xd5\xbf\xef\xb8\xcch\x10\xce\xf7\xbfJ\xf4\xb1\xc7Y\xbd\xca\xbf{)f\x95k\xaa\xb8?4\xf6\xe2w\x92w\xe0\xbf\x1a\xf0\x8b\x17~\x06\xf8?\\g\xe4S&\t\x02\xc0%\xd5\x0f\x04\xe1~\xc1\xbf<\nxB\x0b\xc0\xfc\xbf0\x12x\xcbcW\x9b?f\x87zjU\xbf\xd8\xbf\xe28\xc7"B\xe8\xe2\xbf\xd1\xedt\xe0\x86\xf3\xe6\xbf4u\xd1\xf3\'5\xd6\xbf\x19S{\xc7\xa8.\xf8\xbf\x89Y`y\x14\xc8\xa2?\xcd\xd3\xbe\xa3\xb1\xb6\x01@>aO\xa6%W\xeb?\x0e\x98#\xd2\x10\xac\xf4\xbf\xfd+\x7f\xa9\x9dd\xe6?\xda@w\xd2\x08+\xe5?\xd0j\xcf\xbf\xa4\x98\x02@\xe1\x81\xf1\x99/\xc1\t@\xa9:H\x0b\x8a\x87\xe4\xbfw\xa8\xa2`\xf1\n\xe9\xbf\x8d\x95-A\x16R\xf1?\x18\xeb\xddX\xa7\x88\xe0\xbft\x10\xf9u j\xa9?\xa2\x81\xf4\x05x\xfb\xf6\xbfO\x06\x96\xc4\xa4\xe1\x88\xbfR\xbbJ3\x8d\xc9\xde?\xd4\xe2\xc0a[\xc3\xd1?\x86\xf25lQ\xf0\xd5\xbfA_\x97\xffn\xd9\x00\xc0\xc9\x1f`X?\xeb\xf2\xbf\xb0\xc2F\xf7v\x93\xf5?1\x17\xe0\xb9A\xba\xce\xbf\xaa\x0b\x11\xa9\x8d\xd3\x05@\xf8L\xb0\x19\xbe\xa6\xdb?P2\xbb\xb5CU\xec\xbf\x9e\xfd\xbbB-\x98\xee\xbf_\xf2(^\x05\xdd\xee\xbf\x7fz9\xdbo\xd3\x00\xc0\x9e\xff\x0f\xf1\x17F\x01\xc0n\x1b\x9f\xd4\xbe\xd0\xfd\xbfm\xbd\x17[F1\xe0?\x9c\xac\xdd\xd6+\x00\xfd\xbf\x94\xa6\xa2oX\xaa\xfa\xbf\x83\x9f{or\x8e\xf9\xbfV\xe6\xda\xc7c\xdf\xe9\xbf\xf3_\x8a\xe1\xd43\xe2?V\xe7\xf0\x9f\x11\x01\xb5?\x19QF\xdb\x1ay\xfd\xbf!\x80g%#C\xf1\xbf\x81\x04\xce\xc7\xcd\x00\xb3\xbf\xec\x0f\x1a\x13g}\xb1\xbf\x85\x00\x9cJ\xe6\xd5\xf7\xbf<3\xfd\nX&\xee?a\x9c\xb4\x0b)\xbc\xb8\xbfu\xe90\x03Ad\x90\xbfs(\n}\xb1\x19\xd5\xbf\x02\xc8\xcd\x8c\xf0\xf3\xfa?aX&|,\xd4\xbd\xbf\xee\x07I\n\xef\xeb\xea?\xa2\xec\x0c\xbc\x1f\xd9\xf9?\xe6\xa5\xbd\x1cW\x11\xc7\xbf\xdc\x1b\xdf\xae\xe6\xd1\xd6\xbf\xac\xc23\xb4~\x83\xde\xbf\xff!\xaf\x1e}\xd3\xe4\xbf\xdf/3\x872$\x93?\x89\xc1\xb2\xe3\xbcC\xfc\xbf\x81~\xc501)\xf1?\xae\xc6\x8f\x19\x92!\xf7?h\xf7+\x0b\xa6\x82\x03\xc0\x1b>\xcb\x8f\x14!\xf8\xbf\xb4\xbf\xf4y@\xd7\xf2?m\x89u\xbd\xd5\x96\xfa?\xfb\xbd\xa9e\x9b\xb6\xc0??\xfc\n\x02\x9e\xa8\xe1\xbf\x93\xe2%\x90o\xbd\xcd\xbf\xf5\x1f\x80-f\xf8\xe0?x\x94\xa2\x8a:\xd2\x91?\x94\x1a\xd9\xc7\xa0\xe8\xf2?\xdak\x9d\x07:O\xc8?\xab\xe5\x8au\xba\xf9\xe7\xbf\x08q\xf5\x91\x02\xa2\x02@\x95\xf0\xb1`\x07\xf2\xf5?Z7\xe1\x8c\xa6H\xdb?\xda\x08\xcb\x1f\xb3\xef\xe5?\x82\xb3\n\x9fxl\xc8?{\xdd\xdd\xaa\x85\xb4\xfe\xbf\x01\x9e\x914\xbf\xc0\xd7?\xd1\xd6\xc1\x1b\x15\x10\xeb?\xb6i8\xb4@\x9a\xd4\xbf\xe5\xf8\x84\xf3\xf9\r\xf7\xbf\xcf\xc5\xa1\xe6p~\xf7?/\xb4\x92~\xdf\x03\xe9?\x0c\xc4\xd2\x9420\xe5\xbft^\xe8\xb6\x94\xcb\xe5\xbf\xea\x8f=\xf9p\xe8\x01\xc06\xea\x9c\xab\xb4W\x01@\xb4`E2e\xf8\xf9?\xda^b@\x1aA\xff\xbf~\n\xc4\xc0\r\xdb\xd2?\xa6\x96iPE\x19\xf5?9b\x9b[\xa5\xae\xc6?\xd1(y\xb2\x98\x9d\xdf\xbf\xbdC\x94\x12Zn\xea?\x90\x15#^\x00v\x00@\xcec\x06#)\xd6\xf3\xbf,l1:#\\\xf2?B\xe9\xf9\xf6\xe9t\x06@"\xfd\xeav\xdf~\xea?-])\xd6H\xa4\x86\xbfG#9\x8b1\xb9\xb1?\x02\x1e\xd3\x1b\x18\xd6\xfe?\xff`\x84\x81\xae9\xf7?\xbf\x8c\x0b\xcf\xd4\xd2\xbc?\x05\x9b\x1fp8\xca\x97\xbf\xba(\xd5S<\x9f\xd8?\xe5f\x93M\xff\xb1\xea?\xba\xddy=\xdc\xbf\xf3?\xcc\xa6,w\xd2\x13\xf0\xbf\xda\xf0\x99\x0cj\xfd\xe2?{\xb7\x96\x01\xfb\xc0\xcb\xbf\xa8|\x98\xd1\xddk\xb5\xbf\xb5\xe5\xd7\xe6O\xf1\xd8\xbf\x0f\x0f\x8atm\xc5\xc7\xbf\xf1\xed\xde\\\x08\xa9\xed\xbfH\xdf\xe1\xba\x9c[\xe8?\n\x0f\x04i\xb0\xb4\xea\xbf\x13\xbf%\xd0\x11x\xf4?\xb5P4\x18i\x14\xef?\x16\xd9\x0c\xbeG4\xfc?\xed\xed\n\x17\xa7\xf4\xf8?{\x0c>\x8e\x87q\x04@\xba\xb9\x0f\xb4\xc3\xcb\xf1?\xa4R\xa6L\x1a\xdc\xe4\xbf\x85\x83u\xe76\x1c\x01@\x83wZ\xfdv\x16\xd7\xbf\x9e\x8f\r\xd1\xe2\xd3\xb8\xbfO\xe8Zl4\x7f\xf3?!\xb6\xd8I\x18\xa1\xef\xbf98\x80J\xc8\x90\xed\xbf\xcf3\xb2\x18\x81$\xe1\xbf`H\x84\x95\xba\xd4\xc7?^\xcd\xa0)\xdd\xb2\xd0?#7a\x9d\xc4\xaa\xed?\xb6\xa1*;/}\xf5?\xaa\x141\xe9L\xa9\xe0\xbf\xe1-#)58\xc6\xbfX\xfb\xf5\xeb\x92m\xf1?j\xcf\xf8\xa2\x1dQ\xc4\xbfm\x84\x95\xd3N\'\xf4?\x1c\xb6~\xf1\x15K\xdc\xbf\xe8\xf8\xf6\xec@\xd6\xe6\xbf\xe2\xc5\xf7\xb1\xf9\x1c\xed\xbfa\xe8\x959\xb3\x1b\x06@,\n\xcc\xdd\xf8\x84\xb9\xbfT\xbcbh\xe3t\xe1\xbf\x836]\xe1\xd3\xa8\xc9?`\x1c\xf1\xd1\xb3\xc1\xdf?\xdeR\xcd\xb1\x18\xa7\xe7?)\'\xc8w\x19\xe9\xf5?\x81\xc6\xa9\xb2\x95.\xd7?m\xe6%m1\xb3\xe6?\xaf\x8bJ\xe9\xc3\xaa\x03@\xbepH\x1f\x85\x02\xf0?\x95J\xa5\x9cX\n\xf9?B}jCj\xdf\xee?\x99\xce[\xef^\x19\xc4?\\\x9fm\x8cGf\x03@<[\xe4\x0e-\xf1\xf7\xbf\xd6\x1bYSm\xd9\xd1?R\xba\xe7z\n\xc0\xc8?|\xe9\x06\x86`\xd5\xf9?]\x86_&\rC\xf3?\xc5\x1fo\xe5\xaa\\\xc1\xbf\x07\xfb:\x02\xdb`\xee?\x85\xf3\xb1&\x1e\x8a\xd5?\xcfi\xe8\xf0\xea\xf1\xda\xbf\x107\xdev\xde\x87\xfd\xbf\x05\xf2Y\xe0\xa6n\xf4\xbft\xb4\x0b\x0e\xfb\x08\xe2?\xa1=\xfd\xba\x86\xc4\xf1?\x10\xd4\x87\x0e\x9b\xf7\xfe?\x91\xc3\xdaf\xb0\x0e\xfa?\xe6\x8cI`o\xbb\xcf?\x06\xd6\x08CT\x94\xc6\xbf\xc1\x1fV\x9d\x0f\x04\xee\xbf\xee\xbc9=\x97B\xf2\xbf\xcc&*\x99{*\xcc?\xf5l\xe6P^\xc7\xeb?m\xfe\xe5\x18\xb2\xb3\x00@6J\xe8^3\xb0\xfb?\xd6\xdc\xa1:q\xdb\x05@\xc1\xb0\xbb?\xee\xef\xc6\xbf;\x9e\xcd\x07\xa2\xc0\xdf?\xa4\xc9\xdc\xa7\x11^\xd8?s\'j)\x88Y\xd6\xbf\xa1\xa1\xc2\x05|_\xf2?\x84\x98X\x1f0\x8b\xcb?\x1b+\xefF\t\x9e\xf6?\xadB\xcf\xa9\x05\xcb\xe1\xbf\xe7\x19!\x07\x1e\xeb\xdb?\xa9\xa1\x99Ey\xd2\xdf\xbf\x90\x83\xe82\xbc2\xf0\xbff\xc6Nf\xc3\\\xf3\xbf-\xadp\xa2\xb0V\xf1\xbf\x15[R\x11\x99\x0e\xf2\xbf\x03\xae7p\xeb\xef\xf3\xbf1\x93\\\x85v\x01\xcc\xbf\x8d\xf95L%\xd2\xfc?3\x8c\xb6+\x90$\x15@\xed \x87R\x1d\x90\x08@\xf8\xc9}\x1f/\xf0\xfb?;OEL\xa3a\xf9?\x14^v$\xff"\xfc\xbf\n\x84\x03^\x80\x13\xd2?\x90\xc9\xe7q\x88\xb5\xd9\xbf\x04\xe7\x99\x7f\xecn\xeb?\x9b+_\x060\x93\xe1\xbf\xda\xfa,\xdc+\xa5\xe5?MH\xb2C\xe4\xfb\xd4\xbf\xf1\xb7P\xb6o\xc0\xea\xbf\xfdD\x01\x04\xdd\xbd\xef\xbfW)D\x9a\x97\xf4\xde\xbf!\xaf\xb4dY%\xef?\xee\x88\x1ca\x1b`\xf9\xbfW\xa6F\x0c\x0fl\xf4?\xe6^\xfa\x15U)\xe0\xbf\xfd\xb4U\x9e\xf9\xbf\xfb\xbf3{\x7f\xb9`\x14\xde?\x90\x97cm\xcc\x9c\xf7\xbf\x85y\xa5;\xaa\xc9\xe8\xbf\x042G\xc3\xc6z\x02@<3\x945\xb4\x02\xf6?\xa0\x15{!\xa6u\xd7?\x8f\xb9nY\xc7\x1f\xf1\xbf\xce9\x1f\xc8\xbd\x9c\xf9?\x05\x7f\xd6L\xb8\xbd\n@\x86\xa2\x05\xe8\x8c\x05\x13@m\xec\x8aWR\xa4\x18@\x19\x04a\x08\x84I\x00@\x96\xe5.\xbc\xb0\xbb\t@C2f\xac\x04\xdc\x03@\xf0\xf4\xf9\x1f\x95\x7f\x8e\xbf7Pij\x04\x99\xd3? \x01q\x8e\x95W\xe2?\x92}W\x93\x9ew\xf5\xbf\xe6\xac.\xfc2\xbc\xf6\xbfY\xca\x047y,\xe4\xbf\xe4\xd5\xfb\xe1}\xbe\xf2\xbf#\xf6\x14@\xb4\xa2\xf7\xbf\xd9^\x8b \xe00\xe9\xbf\xb4\xbc\xe5\x1d\xfb\x89\xe5?\xbe\x9d\xf1?\r \x03\xc0\x90cq\xf2{n\xcd?\xbf\xa7\xc5\x0c\x11I\xe2?\x998\x03@\xdbL\xce?\xf1\xb8\x1a\x06 \xab\xd6?\xf9\x81`uCA\x03\xc0s\x16]U\xe6\xc6\xe6\xbf\xcd\xd5B\x92{\xb9\xde?\xba\xdfq\xba\xc1\x11\xe6?\x01!\xa7\x89_\xda\xe8\xbf\xe4H\xffE\'\xbe\xe0\xbf[\xf5\x08tS\xe5\xdd?+\x1c\xdd\x86s\n\xfe?\x14\x9c\\w\xbe\x8f\xed?U\x89\xde\xf8\xe0\xb4\xf9?\x1b\xa1\x7f\x0c-\xd7\xfd?\x97d\xa2\xdc\xber\x13@\xd9<[\xb1Df\xf3?&\x0b\x18\xda\x88k\x02@\xb1\x1dd\xfd3{\xc7?\xb4\xdd\xee"\xe4\xb3\xdb\xbf\xbcz\x8cz\x1c=\xe1\xbf\x19\xfb\xf8\x8a\x1f\xd7\xe5?i\xe5\xed\xa7\xb5j\xf6\xbfF\x0f\xa9n)\xd6\xe3\xbfW\xff@W\x19\xc2\xd6?\x15\xee&1\x0e\xbc\xb0\xbf,"\xfc\xb7A\x85\xfa?\x83\xa4\xb8\xd8\xfcv\xd5\xbfa\xacf\xb6\x07i\xde?\x9b\'>6\xe3*\xf6?\xa0#\x1d\xfa\xd1\xda\x93?!!\xa3)\xd7\x91\xe1\xbf\xcb\xe3\xba\x8c\xc9\xa7\xc2\xbfsU\x91\x1a\xa3\x1d\x04\xc0\xe2ni&\xde\xf8\n\xc0\n\x12\xee/.5\xf4\xbf\xbd\x9c\x0eS\x85\x1f\x07\xc0\r\xe4\x1b\n\xe5\xf6\xf6\xbf\x98\t\xc3\xff\xf1\xa2\xbb\xbfZ:$\x92\x88\xcc\xe2\xbf\xc2\xb4\xe2"\x91K\xe3?:\xc0\x07\x1bKe\xe6?\xc84\xb3\x95\xd9\r\xf3?S\x1f\x0e\xc7\rt\xd1?\xabE\xc8\xcd\xfe\xe9\x01@\xca\x8cQU/\xc9\x95\xbf\xac\xb019s\xce\xc1\xbf\xb9\x7f\xfae\xd7\xff\xe6?\xc5|\xe7\xfa\xff\xb4\xf1?U\x89\x8c\x89\xaa\xe1\xfc\xbf\r\xfd\xe3~\xcc\xef\x01\xc0\x05\x18\x1f@\xecW\xdb\xbf\xca}\x94/f\xbc\xce?\xc0\x83\xfa\xa6r \xdc\xbf&\xcb.\xf9\xb3d\xd3\xbf\x18\x88\xad\xbf\xb4\xa6\xf0??\xa8\x1eMV\x1b\xf1?\xeb\xb36\r\xfeS\xf0\xbf\xda\x069\x0fuH\xd1?\\D\xbf\x01\xa5\x8d\xf6\xbf\xf6\xd6\x91\xa2\xbdU\xac?\xc2\x86.-lU\x0c\xc0\xe5-\xbf\xe1E}\xf8\xbf\xdd\x85\xa0\x07N\x93\x15\xc0\xabB*\xe9\x91\xc0\x07\xc0\x8c\x9b@\xd2wa\xf1\xbf;\x18\x8a\xaf\xcd\x85\xf5?.\xe6Bcq\xae\xe7\xbfb4\x1cNH\xd0\x02\xc0Ql\x9b\x1b%.\x07@~\xbe\x0e\xa4u3\xb0?k\xc9o\x02\x1e\x84\xd2\xbf\xe7\x97\xbe\x13\xa2S\xf8?V\xf8\xe37\xf2\x8e\x06@\xaf\xa9\xe4Jr\xb3\xc2?\xe2\x9fmZ\xda)\x01@\x13\xd8\x9c}\x9dj\x05@\x81l\xe6\xbaH7\xf3\xbf \xc5\r\xde\x8bp\xf4\xbfD/\to\xc6\xca\x03\xc0b,d\xb8\x9d\xf1\xa7?j\xa7?\xc2.]\xee?\x95Nde\xbel\xd6?\xae(\\\xf5\x89\x05\xf4\xbf\xf4\x94\x9e\xac,\xad\xeb\xbfwg\t\xb0C\xdb\xe8?6e~\x16\xeb\x83\xd0?\xe0\x17\xf17HR\xa2?T\x1c\x8d\x9b&A\xf0\xbf\x9b\x12\x17\xf4ij\x08\xc0I\x8f\xebdB\xb3\xf7\xbfH3\xafEF\x9b\xfc\xbfh&\xce\x9e\x87\x1b\x07\xc0\xb7q4\x8e&y\x0c\xc0-\xdd>\x192\xe4\xe1?\x12\x08\xff\xb0{v\xf2\xbfy`\xda\xb3\xa5\xae\xf9\xbf\xa6y\xd5\x8b\xfc\r\xe2\xbf\xe6\x8e\xcf{ja\xc9?A\xdf\xdc\r\xe7\x92\xc2?\xa5N\xccj\x19\xac\xe3?L\xc6#\x9f\xf9\x9c\xe1?\x89\x9b\xc8-T\x9a\xc2?\xddu\xc1\xcc]\xdb\xd4\xbf9$\xa5\x96\xe6\x8e\xd0\xbf\x89\x80\x96\x10P\xf8\x00\xc0f\xa9i\x17\xa5\x94\xf2\xbf\xed\xbc\x99\xf5k\x9a\x05\xc0\x01\r\x96UV^\xf7\xbf\x9b\x8co\xfc\xef@\xfd\xbf\xf9\x95\xd7C\xa9\xd7\xd2?( \xcf\xc3?\x98\xd8?Li?\xc6\x1af\xe5?\xb4\x1d5bk6\xdb?\xb5\xc0\x14\xbf\xeb%\xe8?\xa3\xb0\xa7\x1c\x93\xe1\xb2?\xc6\x01N\xc1k\x7f\xda\xbf]\x85{N\x06\xaa\xf1\xbf\n\xe5;.X|\xfe\xbf\xbf\x8b\xc7\xeb\xbe=\xfe\xbf\xc6\x8f\xdc\x8bU\xc4\xef\xbf\x9aV\x11\xf1\xf7D\xf9\xbf\x1e^\x06lK\xd2\x03\xc0K\xe9_(\t\xd6\x01\xc0\x87\x02\xe1A\xf3\x84\x95?h\x81B\x04b\x1d\xec?[\x12\x1a]v\x9f\xff?\xf1\xb4\xc5\xfd\xf1\x06\xd8?iP/\xe3!\\\xf0?>7hN\xb4\xf2\xf0?\xc68T\xb2J\x9d\xd1?z\xc0\xe1\x9b\xd0\\\x00@\x0cAp\xcc\x02S\xeb\xbf\x9b\xc9\x9e\xef\xb1\x02\xdc\xbf7\xd9\xa7\x92\xfe\x96\r\xc0\x02H\x81\x0f\xeba\x06\xc0\xca\xa9\x95\r\xbc\xc1\xfa\xbf\x16\x03o\x16\x12t\xdd?e\xec\xcc\xd2\x03\xd2\xe6\xbf\xca\xbd\x12\x0fCg\xb4?(\xec\xbc&\x91\'\xea?\x82\xea6\xe7\xb9\x80\xed?:\x18p5\x0b\x14\xf5\xbf\xce \xff\xfe@e\xd8?\xc7o\x99y\xef\x92\xe9\xbf\xcc\xbev\xa2\x9d*\xf0?\t\x0f\x12\xa6\x1dv\xf3\xbf\n\xdf\xe3\x0b\x1a\r\xfe\xbf\xe6cq\xef\xf4z\x03\xc0\xf1\xc1-\xbe\x84\xf9\x02\xc0\xd8\x91<6B\\\x04\xc0B\x02\xd8i\xb9A\t\xc0\x86r\xe2\x05\xf2\x81\xfe\xbfn\x0f\xfa\x81SS\xf6\xbf\xa4]\xb9dN\t\xed?1AA8\x96\xe0\xd0?\xf8\xde\xe1w\x1a\xf0\xc2\xbf\x96\xaf\xde\xc3\xcf\xe6\xfd?\x1e\xf9\xe0\xfd\x90o\x03\xc0%\xf2\xf8nC\xbd\x04\xc06\xc3:\x8f\x0fd\xd5?\xc3\x0e\xe4\xcf\x92C\xe9?\x15\x9a\xf8\xf1?J\r@\xbb\x9c1\xfc\xb0\x9f\xdd?\xda\x8cO\xe8\x143\xef?\x03\x96V\xcb\xa5\xff\xd7?\xba\x98\x82+\x97\xe7\xde?\xa3\xfe\x91\xfa)\xf7\xf5\xbf\xe3]\x96j\xea\xf9\xf4?\xff\xbfw\xfeY\xb0\xe3\xd6\xdc\xbf2\x03^\xde\xc3%\x10\xc0\x13\xdc4\xdd\xc1g\xfe\xbf7 \x08\xa9aO\n\xc0\x02\x80\x97\x17\xc8\xcc\xe8\xbf\x9a5\xf6\xe7"\x93\xe7\xbf\xf8.\xd4vV\x0b\xdd\xbf#\xe7c\x80O\x1a\xe1\xbf\xcb7\xf8\xb0\x1f\xb7\xf4?R\x06\xe6\x8e\x19\x15\xfe?A\xf2\x05\x0c\xd3\xf5\xec\xbf\xe1\x0e\xd4\xad\xac\xca\xff\xbf5\xc6Z\x82*f\x14\xc0\xdej\x16\x0e\xba\x95\xf4\xbfiy:\xe4\x9d\xf3\xf6\xbfdT\xab:0\xca\xf4\xbf\xc7g\xcd|g\xd9\xc3?,\x04Wv]\x83\x00\xc0\xd1\xf2:\xfbz\xfe\xe2?\xb0\xa6\xaf\xa9\xcc\x00\xeb\xbf\xbb\x96-<\xbe"\xf2\xbf\x95\xa5\xb1\xd8l\xdf\xe4\xbfk\xeb\x91\x95,\x04\xc09\x033Li\x92\x03\xc0;{\x94h\x8c\xc0\xc4\xbf\x1c\x11\xd5\x14,\xe0\xe2\xbf\xa4\x84h\xf2\xa0\xe2\xfd\xbf\xf0\x87\xd5%\x10\xa0\xe8?\x18\xa2\xb0D\xd6O\xd4\xbf\xae\xec\xb0\xfb\x1aa\x90?\xaaG\x8f\x0b\xe7\xd1\x06\xc0~z|2\xee\xa0\xf5\xbf\x97\x9a\xd2\xb1\x03\xb4\xeb\xbf\xd5\xed\xd6\x88\xab\xaa\x04\xc0\x86\x8d\xbb\x9dz\xef\x0e\xc0V\x151P\xcfT\xfe\xbf\xa3("\x80\xa0\x99\xe4\xbf\xc88\xbcU\x9b\xe6\xee?\xe7\x11\xf2\xca\xe0\x19\xf8?s)C\xe3*B\xdd\xbf\x83R\x98\xb3\xe2X\xda?\xf4R6\xb5\x027\xe4\xbf\xe8\x15\x9fH\x13o\xf8\xbf\x18B\x1do\xffO\xec\xbf\x0e\x1b\x18\x89\xfe\xfe\xf2\xbf\xf4\xef\xe55u\x82\xed\xbfcp^\x02\xda\xc4\xe0\xbf\xf5\x99\x99\xfb<\xef\xe4?\xd5\xf5\xab"\x92,\x02\xc0\xd0\xf2\x1f\x12K\xbb\xba\xbf\xed\x82\x88\x1b\xbd\xe5\xd3\xbf\xad\xf4\xa9?\x10\x8c\xf0\xbf\x00\x1f\xed.\x9eb\xdb\xbfa\xad\xe4\xe8\x1f\xde\xe3\xbf\xaf\xe78 7\xc8\xc7?J\xb5\xed\xee\xde4\xf1?/^\x0f\x96\xd3\x97\xdd\xbf\x1f\xc9\xcd\xe7h+\xe7\xbfG\x89\xa3\xe7\x04=\xed?\xa9\x90\x8a\x8f\x87O\xfb\xbf\xacbu\xd5\x92<\x05\xc02\xa6\xe3\x94\x8c\xc2\x03\xc0td\x0e\xf7\\8\xfd\xbf\xe6\xfe\xf1\x8b\x14\xc9\xff\xbf\x0c:R\x8d\x81\xaf\xf7\xbf.\xf7\x17\x82\x1b\x82\xe0\xbfOPh\xcd*\xec\xe1\xbf\x92\xbc\xb7\xfetF\xf6\xbf\xa3\xea>-\xfa;\xf7\xbf\xc3G\xe7\x82\x0fI\xc4\xbf\xca+\'N\xf0\x85\xe1\xbfJ\xaf=O\xd5\x00\xc5\xbfS\xc2\x08\xe5-\xe6\xe8\xbfW\xa6\xae\xa5}\xda\xf2?\x9e\x06\xa1\xd9\r\x86\xd3\xbf\xe5\x13\xff\x0c\xec\x82\xd8?\x10\x9a:X\xb9\xaf\xae\xbf\xa9\x04u\x01\xffM\xfb\xbf\x1f\x92\xc2W|\xb2\xd3?Oq\x9d\xb34\xe1\xf4\xbf\xddg\x17\xd2z\x12\xed\xbf\x83\x17\xe0=\xd9\t\xfb?\xef\xf4W\xabV\xaf\xb9\xbf\xf2\xfe\x1b\xaeV\xcd\xd9\xbf\x0b\xb0@]\xfc\xc6\xe6\xbf` \x18\x1b)U\xe6?\x8a[\x08\xb6vI\xfe\xbf\x12\xe3\x19\xb7\xb5\x92\x08\xc0a\xd5N\xbb\xfb\x97\x0f\xc0\xf9yY\x99M\xf7\x00\xc0\xba^\x8c\x9f\x06/\xe4\xbf\xea\x0e\xfa\xc6,\x8c\xf2\xbf\xa5\x1d\xc9\x90\x91-\xe5\xbf\xc0aJ\xde\xeaN\x02@\n\x0c\xe9\xc9\xd9m\xd0\xbf\x01bJW\xbc\xf2\xe7\xbfLe\xd2\xfd\x02\xf9\xf3\xbf2\xd6\xd6;\x95;\xe6\xbfb\xec\xfd\x00GR\x01@\xaaS\xa2>p\x0b\xfe?\xd6\x80;\xf78A\xff\xbf0/\xc7\x98qj\x0b@\xe9\xd4\xf3\x9ejm\x05@?\x00\xb9 [\xce\xf9?\x83.{=\x97\xa4\xd0?\xa4\xd3\xea\xa6\xd4\x82\x0b@J7[\xd1O\xa7\xec?\x97\r\xb0\xad\xb3M\xf3?3\x11\x0f>$2\xde\xbf-\x9a8s\xd8!\xcd?\\\xbab\xbb\xbaS\xe2?\xa0\xc5h;\x81\x7f\xde?E#\x7f>\xd7G\xe0?G\x03W&\x08\x06\xfa?\x98\xe1\xd9I(\xa0\xef\xbf\xa7\xae\\.>\xec\xca?)\xae\xbb\xf1\xe4x\xef\xbf\xe6\xdfu\x18\xa7&\xc5?J\'\xe0y\xc09\xf4\xbf\xc81\x1a\xbe\xc8\x7f\x02\xc0\xe4\x91\xe8\xc1ye\xf8\xbf\xf8\x80U\xcb\x11\xb2\xff\xbfh\xd2\xdcKT\x90\xf3?\x89\xe5\x02\xc5\xf5Q\xe3\xbf\x83:c\x964?\xeb?\x19\x8c\xb5\x99\xe0\t\xd0?S\xa6\xfe\xbe\xaf\xa4\xea?\xed\x14k\x936\xa8\xeb\xbfd\x10\xe9\xf6\x8e\x05\xca\xbf\xb4\x83\xf4?\xcd\xea\x07\xcf\x9f\'\x00\xc06L\\i\xaf\x06\xd5?\xf8\xaa\x8f\xf1\x8d\x10\xf1?v\xc7\xbd\x93\x1eW\xf4?\xad0ov\x04\x8f\xc4\xbfy\x99\x0c\xcf\x0b:\xe4?\x18q\xc6#\x11\x7f\xeb\xbf\x8dr\x9ep)^\xbb?\xcc!\x07\xfa\xee\xc6\xa0\xbf%>\x1e\xc2\xee\xb5\xf3?\xed\x8bH\xed\xcf\xee\xeb\xbf\x08\xeb\x01\xea\x8c\xa7\xf9?\xfb\xd7}\x9f\x98\x7f\xe3?N\xc4\xef\xe9\xb1J\xa8\xbf\xe08\xcc[\x8f\'\xe1?\x19\x05E\xb5\xaer\xfa\xbfa\xded:\xfbv\xe3?\x89\x97#\xeb\x90\xb7\xf2\xbf\xeb\x06\xce\xb4\xf4s\xe7?\rK\xe9\x88\x8c;\xf7?Jz\xe3\\\x98\xe0\xc3?v\xe6\x0e\xe3S\x8d\xe7\xbf\x9cV\xc1\xb6a?\xf0?\x99\x07\xba\xf1\x93k\xf1\xbf\xf6\xde\x13\x10\x915\xc0\xbf=">\\~L\xf2\xbfR\x0c\xe3LV\xd2\xd0\xbf\x97(\xd6d\x1a\xd3\xc8? K\x92WH\xfa\xfd\xbf\x8e\x07\xc4f\xbe\xc5\xf3\xbf9]N\xba\x8b\xb9\xc9\xbf#k\xec\xe0\xa2\x91\xcf?R\xe6\x7f\x8e=\xd8\xea\xbf\xb9H\x16\xa1\xfeK\xfd?[\xfe\xd8\xacdN\xeb\xbf\xf9?\xcc\xb5\xf2a\xd3\xbf\xabE\xd0\x1d\x83\xbf\xfa\xbf\x00\x8e\xd2\x8b\'+\xdd?\x1b\xe8\x1e\x1c\x82\xb1\xe5?%^\n\x80\x1e\x1c\xf1?v \xe4B\xcb\xea\xd8?q\xa3\xe8\xd8_\xf2\xc2?\xcdceQ\xfa\xbd\xdb?\x07\xaay\x9f\x00V\x98?\x8b\xc7\x84U\x1a&\xd6\xbfW[\xaat\xb0\xaf\xef?\x1dc {u*\xc2\xbf\x19"a\xd7\xb6\xac\xe0\xbf\xcd\x11\xde\xc1\x1bd\xe1\xbf\xb3\x8eN(!\x8b\xe6?\xe0x\xa1Px\xaf\xdb?\xf7H\xb5 37\xd6\xbf\x86\xf8m\xf7Q\x86\xee\xbf\x81\xe4\x11\x82\x80/\xaf\xbf"\x834\xf6\xa9l\xd1\xbf\x7f\x1e\xe8\xedS\x87\x05\xc0\xd9\xcb\x14r`\x84\xed\xbfQ,(\\\x17\x88\x9e?\xeaW\xa9#\x88l\xe3\xbf\x87$E\x9esA\xf9\xbf,\x83\xb3\x14q\xb0\xdd?A\x0c@\xb9&-\xf2\xbf(N\x9dD\xe9\xa1\xf7?l\x14\x86\x8e\xf8o\xd4?W\\\xa9Se \xb8\xbf\x92\xd7J\xc3fd\xf9?E^\xf7Db\xfa\xe8?\x9eM\x9f\x16\xa7\x00\xe2\xbf\x8c\xb6\x18.\xbe\xe5\xc6?\x1d\xff\x16:\xc6\x82\xd6?\xde8\xdf(Z\xe0\xcf\xbf\xfa\x1b\xc5\xd0\x0f:\xe8\xbf\xed1\xca\x1fK0\x02\xc0\xce\x93\x03\xa2|\xb2\x81\xbf\xd2\x82\xe8\x8c\x8e.\xf6?^\xd2K@\xca\xe8\xe4?\t\x02N\xfe\xc0L\xaf?h\x98\x8f7\xf87\xfa\xbfR9\xff\xf6\x7fe\xe4\xbf\x117\xca2\xfc\xe1\xf1?\xaf\x14\xcdw\xc3\x8a\xf0\xbf\xd7\xb6\xbd\xa2\xe8|\xc1\xbf\xd6\xaa\xc8\x1c\x80\xe5\xdd\xbf\x9d\xb6\r\x16\xbb\xa9\xe1\xbfA\x19e\xc8\x90t\xe9\xbf\x81\x81W\x9f\xc4 \xff\xbfF4\xc7\xf01\xed\xd9?\xe84\xad\xc6\xb7\x86\xfb\xbf\x02\xb2\x95\xc5\\V\xf1\xbf\x8a\xde,)\x84\x0c\xed?\xa1{\xb2^\x88\xc1\xbb?\xf34$@7\x97\xdb?hI>\xcd\x8a \xeb\xbf8\\U=\xb1\xfa\xcd\xbf\x18$A\xf5\xc3C\xd5?|\xad\xc0-b\xfc\xbb?,\xaa.\xd35,\x90?A6\x9b\xaa0\'\xda\xbfh\xd6\xff\n\'C\xd0\xbf\xce>}\xb7CM\xfc\xbf\xa1\nk\xaa\t\xe5\xcf?\xb4j\x04\x96\x11\x0b\xf5?\xa0\x96\x8c\xdb\x01o\x07@\x8a\x01c"\x06\xbd\xb9\xbftP\x8a\xb4\xcfC\xd1\xbf\x9e\x9c\xf4\t>\x1er?a\x1b\x07\x15u\xf8\xee\xbf\xd0M\x87\x9b\x99\x18\xf4?\xa9\xc1\x12\x7f\xe8\x0c\xd0\xbfV\xad[K\x9b\x82\xd3\xbf\xa4w\xfcW\xb7,\xaf\xbfZ\xce\xbec\xc3\x92\xe8?\x90\xad\xc1\x11\x1cE\xfd?\x8b\x84\x8f\xaf6\xfb\xef?)\xc6\xe9\xd6*\x1a\xf2?=,\xad\xfe*\xc5\xe1?f\xfc=\xeb\xb4?\xd9\xbf\xa5|a\x00\xf8\'\xec?\xa7ML5/x\xc7?{\xcciHZ\xf8\xe5\xbf\x83u\x95\x10\xb2\xf0\xd1?\xfcL[I\xac\xf9\xd9?zmlJ\x1en\xf0\xbf\x883\xfd\x1b$,\xdb\xbf\xb8X\x7f\xe7o\xeb\x00\xc0\xa6Zt\xc4\x0f\xd2\xf4?d\xe8\xdd\xb3h\xd0\x96\xbf\x83\xb8D\xd2\xd9\xd8\xe8?\x1d\xf89\x00C\xb3\xc0\xbf\x9a\xb1\x07\xac\x8e\xf3\xcc\xbf\xed\xcfE?u\x07\xd9?=6\xed\x12g&\xd4?S\xb7\x7f!\xc8}\xe5\xbf\x06\xfda\x12b\xc3\xda?\xfc\xfd\xaad\x0bJ\xe2?f\xfe~\xe8\x08\xaf\xbb?\x8a\x97\xc4\xfb\xdbO\xf3\xbf8R\xbb3\xec\xae\xd9\xbf\xe6o6\x8b\x8a\xf8\xeb\xbfE\xc48%\xf1\xaf\xed\xbf\x8a\x00T\x95\xdbS\xf7\xbf\xba\x8eL\xf8\xd5\x89\xe6\xbf\xa9\x90\x8d\xb1\x86\xde\xfc\xbf\xc3\xf1\xec{2\x95\xd4\xbf\xe6\x83\xaf:\xe5\xc2\xcf?\x82\x9e\xa6_\xcdY\xf6\xbfe\x10:O\nS\xd1\xbfv\xe3\xf5&\xd4\x8f\xe0\xbf\xe56!\xd5\xbe\x17\xd5\xbf\xcfLY\xe6H\x9d\xdc?r\x01\x111\x9e\x03\xa6\xbf\xf6[u]JD\xf3\xbf\xfe*l\x136\xa9\xe7?}!\xa2\x92J\xcf\xeb?\x1c!\x82!,\x18\xf4\xbf*\xc0\xe0\x88y\x02{?A\x1a=C\xd1|\xc0\xbf\x9d\x11\x0e\xb4\\S\xfa\xbf\x9f\x99\xa3w9@\xe9\xbf\xea\xab\xa3/n\xad\xa3\xbf\xbe\xe2\xeaI\x1b\xd7\xbc\xbf\xacDR\x81\x93\x99\xe2\xbf_W\xc8V\x92\xd4\xdf\xbf\xb2H\x85/\xec\xf7\xe7\xbf\xbad!W\xa5\x10\x07\xc0\xf21^!=\x86\xee\xbf\r5u]\x9dL\xfa\xbfDi2\x06\xc7\x8f\xf3\xbf7qBY\x81\xc7\xb5?~\xc8\xe0\x17\xfbD\xfa\xbfg\xb6~A\xa0\xac\xfc\xbf\xe4fv\xe6\xeeN\xe9\xbf\xef+O{\xacE\x04\xc0\xd3\xc3V\xbb\xb8\xa5\xda?\xfb\x98\xe7r\x12\\\xea\xbf\x87e\xad\xf4\x0e\xb3\xf8\xbf\xe6\xd2\x16N1\x06\xb2\xbf&\x00\xb1^\xf0\xd9\xb5\xbf\xc6\xdd\x08O\x8aw\xcb\xbf;X\x12N\xd4X\xb0\xbf}\xffh\xa3&\xe6\xe5\xbf\x03Z2\xe5\xc0n\xf2?\xf5\x9e\x15\x86Md\x01\xc0\xbc\xc4\x80#S\x91\xa9\xbf\xad\x91?\xad\x0bs\x05\xc0\xcf\x152\x9a\xcf\x1b\x02@\xbf\xadqF\xff\xd4\xe1?\xef\x8d\xdbE\x80\x1e\xcf\xbf\x01x\x8euLt\xf5?9\xfcO\xab\x83\x82\xea\xbf,\x13\x0bo\x81\x8a\xdc?s\x1f%\xc9\xd5x\xde\xbf@\xd9\xe3\\<\xd0\xe1\xbf%\xac\xa8\x87\x99\n\x07\xc0\x9e*\xa1N\xce\x1f\xf3\xbfk:\x85?c;\x01\xc0\r\xa7H\xb7\x90\xc9\x04\xc0\x101\xceq\xd9U\x03\xc0\x9e\xcd]t\xdeZ\x0e\xc0\xfc8\xd6\xaf\x82x\n\xc0\x83\xc5R\xaaDf\x10\xc0E\xb0P\xe2\xe0$\x03\xc0(\xf6G;\xe2j\x13\xc0\x06\xd1\xd2\xf2\xd8\xa0\xfb\xbf\xd2\x14\xa1\x8d_R\n\xc0\xde\x15\xb6\xf9\xa7\xe1\xfd\xbf\x7fg\xb8\xb2Pz\xfb\xbf\xac\x0e\xd4\x01N*\xf3\xbf;\xe0\xf57\xee\x17\xfc\xbf\x86\'\xc5-\xdf\x18\xdf?#P\x93\xf6\x9d\xcd\xba\xbfpJ$m\xf3w\xba\xbfu\xc3r8\xffw\xea?\xc5[\x9b\xa5C:\xcb?+X\x85\x8cls\xda?\x13\xe7{E~\xe9\xf7\xbf\x86&\xcdN+C\xed?j\x16\x1e\x8c\xe4\xf2\xd7?oy\x88$w\xf7\xe7\xbf\\\x19\x83\xffx6\xd4?O\x91=n4\xc5\xc8\xbf\xf7\xe2\xb6^\xf8\xa5\xc4?;\xb0b\xa3T@\xdb?LH\x82\xd2\x97\x97\xfd?\xac$D\x11\xedo\xc1\xbf*\x1e\r\x19\xaa\xd7\xfd\xbf\xcb\x1a\xa5\x10j\x8c\xc1?\xe1MB\x06\xbe\xe1\xf1?\x89M+\xd2\xee9\xeb?\x11"w3+7\xf1\xbfb\x843\x87b\xe7\x01\xc0\xbe\x83\xf9\x96\xf3\xe2\x05\xc0w\xe2\xba5\xa4\x9a\xfc\xbf\xfaV\xa5\xb7\x8d8\xf3\xbf\xfe\xd9\xaa\xf6\xca)\x02\xc0\x8a\xf0\x1aBf)\xef?\xcb\xa3@1\x166\xde\xbf\x84\x12\xaf\xba\xcbB\xd1\xbf\xee\xe4\xc1\nm\x9b\xde?\x9b\xcd\x1ad\x91G\xf4\xbf\x0c\x81\x1cm\x9f\x87\xe0\xbf\xde^\xe5\x1f\x07\x88\xfc\xbf\x93\xd1K\x99\xb9"\xe9?\xd08K\xfa\xf4\x0c\xec?\x19\x88}\x1bz\xb6\xfd?\xddJ\x00\x1f\x141\x01@M\x01\x9b\x06\xd9c\xfa?\xf7i\x10\r\xea\xab\xd5?\xb8}\xf8z\xb0\x12\xf5?[\x8d\x14!\x1b\xbc\xfd?\x82\x0b\xb0\x89\xa6\x96\x00@\x9f\xe9\x973e\xd7\xd7?\xaa\xf3\x1f\x92$U\x03@\x15\x15\xdf\'\x1f8\xe5\xbfA\xbdN\x92h\xc3\xf1\xbf|\xa6.\xa5|\t\xee?/:\xdfL< \xee?\x07\x9e\x88\xf5\x08Y\xdf?\xe5\x06\xf7\xa1\xef\xbd\xe5?\xde\x04\xc4pr\xb0\x04@\xa3\x96\xc1\xb8jW\xfb?\xd7\xc5\xdej?\xd0\xd4?\xe8\x06N\x8f^_\xea?\x16\xb3\x98\xbe?h\xd6\xbfs\x9ai\x08|\xb6\xdf\xbf&Z\xbe\xd6I\x95\xd6?\xbb\x0e\xcd \x14\xd2\xf8\xbfhl\x84\xae,c\xe8\xbf+\xda\xeb\x97} \xed\xbf\xdbU\x13F\x8d\xc5\xd5\xbfP\xbc\xa6RK\x8a\x04@\x0b2\x80\xea\x9cm\xe5?\x11\xad\xe6\xf5\xccK\xc1\xbf:\x19o\xf1?\xc4>\x00\xf8\xacT\x07@v\xc3f\x067\xe7\xec?I\xc4\x11\xcc\x90\x9f\xfa?d\xc8\xda4v\xa2\x03@\xd0\x9fj\xc7\x9ec\xdd?Y\x95\xde\xba8:\x02@D\x05i\xf8F~\x06@\x8a\xcd_\x80\xde\x87\x01@\xbf\xaas\x17\nw\xf9\xbf*\xccr\xf8*\xc4\xea\xbf\x94\xf1Q%k\t\xe0\xbf\x00\x06\r\x85\x93\xd7\x02\xc0\xb2\x0cvV\xe3m\x9c\xbf6mjy\xf0\xcf\xed?~\xdd\xacO\x9d0\xf5?\x86g\xe7\xc6RB\xf8?\n\x93*\xfbV\xa5\xff?\x88 \xc1\xf3i\xbe\xb5\xbf/<\x9b\xe5{b\xfa?\x055c\xc7\xa4G\xe7?\x05-7]C\x05\xfc?h&*X\x85\x13\xdd\xbf\xe2\xc1\x94\x8d\x89\xbc\x06@\xa9f\rYb\xfe\xfc?dt\xdd\x99\xaa-\xf6?B\xaczq3Z\xec?>\x8b4\x82U}\xe9?M\x99s\xaeEN\xa0\xbfn\xf0[\xdf\x91S\xe6?r\xb9\x91\xac\xbb\x97\x03@`>\x81\xf2U\x9a\xd3\xbf\x90\xe1D\x96\x7f>\xe7?\x02n`\xf4\xab\r\xfa?\x86\xed\x92,x\xfa\x01@\x174Pf\x89/\xf7?\xf1\xd4zZ\xf0z\x0c@a\x1b.p;H\xc3?\x90y\x81R\xbfp\xd3\xbf\xd3\xb7\x94\x1a\xedv\xf2\xbf\x7f\xde\xb9\xa1q\x19\xf0\xbfO\x94\xcc\xee*\xcf\xf1?\xb2\xaaJ\xe3k\x1b\xe9?\x08c\xf4\x89\\B\x01@\x17\xa6\xcc\xc2,\xf6\xd6?\xc4\x97,\x84\xb18\xc1\xbf\x93\xc9\xf3\x82\x7f\x87\xe7?!w\x923\xe1\xbf\xd4\xbf\xb3\x94I$\xd8\x84\xa8\xbfD\xe4\xea\x89L\xc9\x03@\xd4Lw\xe5\xe4\xbd\xa8\xbf\xa4J\xaco\x81\x99\x92\xbf\xe6b9\xee\xbe\x1b\x06@I\x95w\xf0\x02\xb7\t@E\xa9\xde\x13\xdc\x89\r@/\xc7i\x1a\x8a\xd8\x13@\x81\x03n\n\xe2\xb2\x11@u>\xa3p\x87N\n@R\xc5\x8e\xbe\x82c\xfa?\xf9\xd8e\x10a&\x05@\xfdVV\xc0s\xc8\xfa?q\xa5i;GL\xf5?f\x82\xf8\xaa\x11\x83\x04@\xcelz\xd2Q\x10\xff?\xe4Y\xc6F\xd3\xea\xfe?\x9e]:\xc5L\xfb\xbc?\\\xc0\xf8Z\xf8\xab\xe7?\xebB\x90\xbd\xdc\xe3\xfb?~)n`\x8e+\xcb\xbf\x87\x94\x11\x1a\xea\xd7\xd3?\xf2\x99\xe6\xd6[\xb7\xf8?j\xa4$\xde\xe7\xc5\xca\xbf\xde\xc8H_E\xb4\xcc?\xa9\xd7\xb0g\xb6i\x00@d\x8cj\xec\xfc\xb0\xe7?\x97\xd47a\xfbK\xe8\xbf;(\x05\xc4\x14p\xfb?\xba\xd4ZX\x89\x8e\xf0?\xdd\xa7\xea\xed1q\xf5?\xb9P\x8fH\xaa\xbf\x00@\xfa\x05C\xd4h\xda\x10@\xac\x1cL^\xbb~\x07@y\xb9\xfb-i\xa6\r@o\x0c\xfd\x8bJ\x19\x07@z\xeaPrv\xf0\x01@S\x99\xbc\\\x9d\xa8\xf8?vzPP\x11i\xf3?@\\\x02\xc2\xba\xb4\xe2?\xbc\xdf\x8bB\x80\x94\xf4?\x10\xb8\xf92}P\xe1?U\xaa-q\xffe\xe0\xbf\xec\x93^\x14\xd4j\xd6\xbfo\xf2\xc3\n\xda\x94\xb2\xbf1\xd3\x8eS\xde\xa3\xe4?K3/\xb2l\xda\xf5?x)B,m\xb3\xf8?mV\x9f\xb4\n\xa4\xf3?6Hj\x8e-\x8a\xce\xbf\xd2\xb3\xb2\x87\x81.\xf8?fQl\xd8l:\xe4?\xe3\xf7\x8d!\x04\xcc\xe3\xbf0\xd1I\xado\xdd\xce?\xdc\x9b\xcf\xe4\xb3\xd3\xf5?\x8a\xfb\x1a\x1f\x19\xf2\xf0\xbfI\xe3 \xa4\xbc\x10\xf5?G\xd0\x91e\x85\x8c\x00\xc0\xc9X4X\x02k\x03\xc0w\xb5)\x12\xa3<\xf2\xbfL1\xd3\xf9V\x03\xea?\xd6 \xb0U\xcb\xeb\x06\xc05\x9bwx\x1f\\\xe2\xbfFa\x9c8"\xed\x00\xc0\xf5\x93\xd8e\x07U\xe5?E\xda4g\xc0\xef\xf6\xbfhD\x03>\x80\x06\x00\xc0\x1a\xe0\xa4]\xb6v\xef\xbf\x86x\xf2\xd4\x7f\xde\xf0?J\xf6\xbb\x1c\x7f\x1b\xcc\xbf\xf7\xc0\x81\xa0E\xcc\xd5\xbf\xe3\x02\xf0\xe6+\xed\x06\xc0}\x0b{cX\x91\xf8?\x7f\xc28\xb1\x00\x03\xeb?\xc0\xf4=\xb7\x0bw\xd2?f\xc4Z\xa2\x7f3\xb0\xbfv\xe7\xcfH1\x03\xf9?\xdd\xee\x85}(\x9a\x00\xc0\x06\x177\'\xbf6\xe6\xbfW}\x13\x16T\x04\xef?\xd7+\x89\xfd\xcf\xc1\xad?\xfe\x88\x83\xc4j\x14\xd2\xbf\xbeRtHD^\xfd\xbfDb@\x16DC\xd1\xbf\xcetD\x9f\xc3\x8f\x0c\xc0\xad;R\xc9A\xaf\xed\xbf\xfe~^\xaa\xedQ\r\xc0t\x8e\xdd\x96\x92\x94\x0b\xc0a\x85\x95j\x82\x8d\x13\xc0\xf2\xaa3b/o\x18\xc0z\xd6N\xb7\xf3\x8c\x07\xc0\x92niG\xf6\x05\xfb\xbf\xa6\x02+\xcchW\x00\xc0I\xa3\xab\x1e\xaa/\n\xc0y\x8d_S\xbf\xc5\x00\xc0\xc9\x8a\xdf\xab\xc1\x16\xf9\xbfE\x0f\xb7m50\xe6?\xb4\xb0\xee\xb6C\xbc\xfa?\x0c\xfe$\xfa\xa0Q\xe6?\x8cO\xcf\x03.@\xf5\xbf\x04\xd0\x85\xed\x12\xd9\x02\xc0/\xc4\xc9\x1e6/\xf6?\x011\x03r\x80U\xec?\xa2\x13\xd7o\x0b-\xec\xbf\xb7\xc8\x9cP\xd4"\xf3?\xcf7!\xd0vx\xd4?\xb2%\x06\xf7\x99\x93\xeb?\x92!z\xefa\xb8\xe3?S ^\xe7\x03d\xde?\xe8\x8a\xa8\xbb\xe8>\xf4\xbf\xcd\xde\x03\x1c\xec2\xeb\xbfl\x13]:\xe8x\x08\xc0\xb9\xde\x91f\xb54\t\xc0j\x08qO\x92\x8b\xf9\xbf\xc1\x81\xd8\xf1\xfe\xe4\xd1\xbf\xa3e\xdc\xca\x18\x04\xf3\xbf\xa7Xi\xe9\xd0\xc1\x02\xc0>\x11\xd4C\x04Y\x02\xc0\x8f\x8b\x02\xeb\xa9\x1a\xfa\xbf\x06\xa8k\x1ad\x12\x01\xc0\xcc\xe5\xbe(\x8e\xbf\xeb\xbf\x8ce5\xf4x\x0e\xfe?\xe3\x14:y~\x19\xf7?\xeb\x9c\x90T\xfa\xbd\xfd?/\xab[}R\x12\x04\xc0\xb0<\xb1\xbcw2\xf3?\x80,\xc1\\\xc3\x8b\x01@\x06Q\x8b\xdc\xf5\x0e\xd6?\xe0z\xbd,\x9e\xb5\xf3?\xafO\xf5mZX\xf1\xbf\x03SWZ6\xf3\xd1?c\xf8\xfe\x1c\x9e\x9c\xe3\xbf\xe1B\x9a"\xa9\x99\xe8? \xd9Fp\xee\xa2\x00@\xe9\x05\xf9H\xcd;\xd9\xbf\x0e\xf1[\xd2\xb3h\xf8?\xbe\x8d\xa71z\xd2\xfb\xbf\xf1\xacu\x14\x0f\xcc\xf5\xbf;\x8c\xeb\xd05\x88\xe4\xbf\xf6\xa8\xdf\xa9@\xf2\xf3\xbf&\x96V\xbf\xed\xbf\xcf\xbfk\x8c_\xc6Vt\xf9\xbf\xcf\xa0_CH\xee\xfa\xbf@\xcdB!+\xa4\x0c\xc0J\xb3*\xb1\x0f\x02\x05\xc0\xa0\xbd}\xf8\xe5+\xef\xbf4\xf1\xb3^\x1e\x11\xe5?\xcf\x13\x10\xc9\xf2c\xeb\xbf\xf4-K\xd4\r\xa3\xf1?\xccU\xbf\xa1Q\x12\xc8\xbf\xaf\xd7b\xe9\xc6\xca\xd6?\xe9\x13\x84\x86\'\xdb\xe6?<\xe5\x85\x10\x1e4\xf5?SL{\xab\x18\xa9\xf9?\x81\xd5\xd5L\xd8!\xd1\xbf\xa4\xdf\x85\xdcn\xc7\xd9?\xfb)\xb4W\xc4*\xf8? fs\x11A\xa2\xf4?\xb3~6\xf9\x0f"\xf2\xbf\x03kv\r\xfe\x0b\xe0?\'\xb3\x80\xf3y\xe2\xd2?\xf3\xb7\x1d%A\xed\xe4\xbf\xc2\xf9\xa9\xda?/\xe5\xf8\x93\'\xfc\xbe\xbfmK\xe1\x1ac\x0c\xdb?\x19\x92\xaa\x89\x18\xf8\xd9?)\x00\x8d\x96j\xa3\xe2?\x14\xdc4h\xd9\xe7\xd5\xbf;[X;\xe5\x16\xb5?\xb8\xfa>\x84\xaa(\xd6?\xad\xb5+\x17\xaaP\xdc\xbf\x1dUD\x13\xff\xc4\xc8?\x04\x83\xc9\xdc>h\xfc\xbf=\xd4\\U\x9bk\x03\xc0\x00\xd1\xdc\xc0.X\xf9\xbfE\xa3\x0cg\x9d\x0b\xf5\xbfl\xe1\x10\xfc\x9c\x07\xdb?e\xfb\xf2\xa6\x8bg\xf5\xbf\xa7\x138"u\xe0\xd5\xbf%\x1c\xffhY\xf9\xe4?\xaf\xe6y\x8c\x83\x06\xb5?l\xe7\x11\xb9\\r\xd3\xbf%\x13j\xf7\xcd\xe1\xd7\xbf\xd7\xba\x8e~\x8b\x04\xf4\xbf\x84\xc4\x90\xbc\x92\x80\xf4\xbft\xb9\xa0dp\x14\xde?\xd2l\x19mV\'\xf0\xbf\xdc\xd9\x7f\x01\x1c\xdf\xa1\xb9\xeb\xbf\xe9\xbd\x01o\xde\xa5\xf2\xbf6\xa0[5Vw\xf3\xbfG\xdc\xe1\x16\x1dd\r\xc0\x1f\xd6\xb1\x9f7U\xf6\xbf\xde\xf2J$\x9dP\xf0\xbf*\xa0OS\xbc\xfd\xe7?F\xdf\xe7c\x82\x05\xa2?\xea\xf4L\x8a\x836\xd3?\x8a\xabc\xde\x88\xd2\xe4\xbf\xd3\x08\xcf\x08\x0c\x0c\xf9?\xf7\x8b:\x8d\xc6\xea\xe8?\xa1\xf4OqO\x9d\xf2?\xda]\xc5\x7f\xcc\x1f\xd9\xbf\xbb\xa2\xebF\x94\x98\xf2\xbf\x92\xc5\xf9n\x7f\xc4\x00@\x9bNgv-\xca\x06@\x02\x07\xaa;\xa9y\xf6?\x9a\x1eJ\xba\xfas\xce\xbf*\x02\n\x08&\x83\xcb?8\x8fGi\x03X\xfa\xbf\x17Vakt\xfa\xf3\xbf\x98\xbfU\x1a\xc6\xa8\xce\xbfAa\xfe\x0bck\xf8\xbf\x04z\x1e\x1dV\x13\xf0\xbf\x1d\xd6\xa3\xdd\xf2\x0c\xf1\xbf\x9b\x9ez\x1f\x9aR\xdf?\x12h\x84\xeb\x81\xdd\xed?\xeeH\xc4J\xb8\x87\xeb?J\x13\x838F4\xe7?]W0e\xf6\x80\xe2?2\xcf\xa0\x8f\xa0>\xed?r\xdbP\xfa\xcd\xd4\xea\xbf5)\xfa|\x80\x03\xe1\xbfd\xab\xae<\xf0\xae\xf3\xbf4^\xaa\xba\t\xf3\xf2?\xf1k\xdd\x8a|\'\xf0\xbf\x8b\x05C\x83\xb9S\xf3?\xff25\x7f\x06\xd0\xb9?\x04"\x91M\xfd\t\xf3\xbf\xa9\x83\x04\x86^\xad\xe3?\xe7\x97\xff\xe1Qr\xd8?^\xcec\x06\xc2M\xd0?|\xbbq\xcd\x1b\x83\xd3\xbft\xb2\xbf\x03C\xc9\xa1?\x0f\xb7\xef\xb3*X\xf3?\x12\xf8\xf1P\x84\xdd\xdd\xbf\x96\x14\x82aO\x1b\xd2?\xcb\xaa\xe4jV\xeb\xd9\xbfZF\x860\xde5\xe8\xbf7\xfa\x19\xfe\xc6\x9a\xfa\xbfx\xebr\x05\x98<\xfd?\xbb1w\xa2\xf0,\xc9\xbf\xe8\x817|\x7fq\xee\xbf\xff%\xdc\x8f\x13\x80\xc1?\x17\xf3\xae\x85r\xed\xda\xbfa~\xfa\xe0\xab\xdf\xd4?\x7f\xc1\xce\x9eQ\xd8\xeb?\x04V\xc8B,\x0b\xe9?\x0e\xb4\xbc\xbd\xbbG\xe9\xbf\x94\xcb\x9az\xdd\xca\xf7?\xc6iZ\x0f\xbb\xf9\xb0?&V\x93\xa5\x90A\xbb?\xa1\x891\x12\xed\x10\xe6?\x88;\x90)V\xd3\xf4?\x18\xa7c=\xf9\xdd\xf3?\xd9\x85\xc0\xe9`\x1d\xef\xbf\x81\xa9t3\x9d\xf6\xe3?{\x19q\x9f\xbch\xea\xbf\xd6|\x05h\xfb.\xd2\xbfw.\x8b\x04|+\xf7?\xa4\xcd!d\xef[\xd2\xbf"\x0e\xf2\x93\x10c\xe3?\xefw\xf7\xcc\xc25\xfc\xbf\xf0,\xc1\xa1\xa4\x17\xe3\xbf\x15{\xc6\'\xec4\xf1\xbf_\x15$bG<\xae\xbf\xa9\x02\xadZ\xb5]\xf4\xbf\xc0\xe1\x98\x16[@\xf5\xbfA\xbcw,\x06?\xc6\xbf\xbb\xe6\x9d\xd8\x9f\xa2\xf4\xbf\xb3b\xa6\xbd17\xe6\xbf\xdb!:P!\x02\xb9\xbf\x99\xcf\xf46\x1c>\xe6\xbf\x0f\x91M\xe4\x8a\xf3\xd0?\xd96dz\xce\x99\xfe?\x17\xaeRb\xa7\x0c\xda\xbf/\xf0\x8a\xb0^\xbe\xd1\xbf\x8d\x85;\xf8\xc9Y\x07@\xc9-\x0b\x84I\xd5\xff\xbf!%wB\x80\xb8\xe3\xbf\xc7\x13\xec\xae\xa9;\xff\xbf\x0f\xd12\x17!P\xd0\xbf\x8c\'\xa1\xd7\xcf\xea\xaa\xbf\xdd\x80\xda\x7f\xbb\x9d\xaf?>L\xd37j\x87\xa5?\r\xd7f\xd5\xd1\x07\xb4?\xe0q\x0b\x8dHw\xed?\x16\x8e\n\x8e\xf0\x89\xf8?\x19)\x93\xee7B\xfe\xbf\x80*\xf3r9\xa3\xd0\xbf\xcf\xf5\xc17U\x10\xc2?;\xa42\xad\x9c\x0e\xe9?\x05\x1f\x15\xd9\x14\xeb\xff?\x06\x13\xb5g\x029\xe3\xbf\xd5CY)-,\x07@\x9d[\xe6Bp\x12\xf4\xbf\x98\x9c\xc2\xc3#M\xf1\xbf\xf3g\x917_?\xe4?U\x9as\x9d3d\xe4\xbf\x86A%N:}\xda?K\xe7\xe6n;\xed\xbe\xbf\x0c\x84p\x06\xc5\xef\xd9\xbf\xc8W\xeaE\xf1\'\xf4\xbfF|\x98\xd6\x9b\xbc\xce?\x1b\x85\xbb=\xfaj\xe3?D[k^e\xbd\xe3?#\xc1/\x91\\i\xd3\xbfS\xb7LGT\x9d\xe9\xbfa\xd7I\xca]\xae\xf1\xbfR\xcf\x9dpoH\xf1\xbf\xd7\xea\x85\xd3\xc88\xf2?@`t\n\x11\xb7\xde?|\xa8U\xce\xe1\x04\xf1?\xdd>\xabd\x81D\xee\xbf\xf0\x98\x1b\x894V\xeb?\xb7l\x99Y\xf9\x16\xd8?e J|\xc2\xb1\xf4?\xd1\x19\xaa\x97\xc7@\xec\xbf6\x99s\xc7\xbet\xf3\xbf\xda\xa3\xe3h{D\xd8?\xbd\x1dU\x88&\xcc\xe2\xbf\xb6\x9d\x9d\xb9s{\xf4?\xa9\xb9b1P\xc5\xf9?\xd9u\xc3\xde\x152\xd1\xbf2\xf6\xe9\xfa\xe1\x9f\xca\xbfx?\xf8\xe8\xa6\x8b\xb1\xbfDY5\xb7\xbeV\x00\xc0\x14oo \xf8\xd0\xfc\xbf\x072\xf4\xf45W\xdd\xbf1+\xa6\xc0\xfc\xb1\xe2\xbf\x05vnDpg\xfa?\xf4\x8e\xee\x08o{\xd0?\xd6\x1c\x83\x0e\xbc\xda\xf0?\xac\xb5{)\xdd%\xd1\xbf\x90\x86\xeeD\xb7\xe2\xed?\xe3\x98>\xdf)\xb2\xf2?\'\xb0\x9c\xa5u\xd2\xce?J\x03\x13~\xd4\x99\xd4?\x1d\x98\xe7"9\x9b\x96?u\xce\xee\x98\x05\xd5\xd6?\x81\xdc\xa7\xca\xea\xa9\xe2?\xb5G\xfb\x81\x0e<\xec?>\xd4[/1i\xf5?\xf3\x1e\xdd\xc7\x95\x08\xfc?\xd9\x82\xc3\x02\x8f\x08\xf5?\x06\xe4\xac?y\xa7\xdf\xbf\xb5X\xa7QeY\xe9\xbf2\x1b\xafm\x01w\xf1\xbf\xc5V\xdc\xb2\xa0\xde\xe1\xbf\x02^n\x80!`\xd7?\xfbS\x00\xadag\xc8?\xcf\xa5U\xdd\x1a\xfb\xee?\xf1 \xbe\xdc\x00l\xbf?\x85\xee\x0f\x94C\x01\xc2\xbf\xae@@\xed\x08\x1c\xe8\xbf\t\x0e\xcf\xf4rP\xdd?\xfb\xe8\x9a\xe2Z\xe1\xe6\xbf\xb1\xc0\xc9LHX\xed\xbf\x9dL\xa2XN\xca\xe5?R:B$\x05\xaa\xa0\xbf&\':\ty\x9c\x07\xc0\x7f\x93\xca\xb3\xd1A\xd1\xbf\x85\x04Jl\x99\xa1\xf4?\xd5\xf2\x9c\xa8\x145\xcb\xbf\x1f\xd5x\xd9g/\xe5?OU\xb5\xac\xd9I\xde\xbf\xf7\x91\x02)\x1cO\xfd?\xd5\xf5\xca5\xa1\x9b\xb4\xbf\x04\xe6\x88\xfc\x84\x8d\xf5?|m\x81\xf9\xbeL\xfc\xbf[\xa1\x15\x1d\x13\xb2\xe2\xbf\x85\x94\x10\xec\xcaF\xc9?d\x9c\xc5\xab\xa7*\xa7?*\x0c\x83\xd3Vu\xd7?\xc2=\x1c\xcc\xe3\xb0\xe7?\xd1\x17\x88hl\x81\xd7?\xe9\xaf\xecu\x8f`\xea\xbf\x05\xf5]\xe1\x1a\x07\xdb\xbfn\xa8\x19M\xc3L\xcf\xbf|\xee\x90\xcfM*\xdf\xbf\xdfB\xa8\x93\xf8\xe0\xdc\xbf\xf7=;\x17\xe1:\xad\xbf\xc2\x0e&I\xd3\x96\xe1?\xe0`\xab\x9bS\x8f\xfe?\x81\x97\xb6ZP\xbb\xf4?c\xd8\xa4ca_\x05@\x81\xcb\xe8{+\xa5\xff?\x1e\x06\x05K\xf8\xa4\x00@\xed\xc3^\xe8\x19(\xf1?\r\x14\n\xb9\xf7\xb9\xa5\xbf\x054`\x9c\xe9\x13\xdf?*\xbfk\x0ch\xe4\xe6?\xfa\xc4:\x95lu\xe1?\xb8\xfa%\xd5\x90\x82\xf0\xbfZ+\xaa9\t`\x00@\xdc>v\xd0^\x11\xfa?\x1b\x0e\xa2\x03\x93\x13\xfe?e5\xb0\x006\x15\xf3?d-\xa1\xe3\xf0\x0c\xb9\xbf)\xf9\xd9<\x04\x04\x02\xc0d0m\xa0\xaa\x01\xb1?q\xb7\xca\x9b=\x9e\xe6?a1\x19?\xea\xb4\xed?\x1e\xa0\x06\x00C\xea\xf2\xbft\xec\xe0\x82e=\xcc?\x82g\xa1S\xdf\x1f\xd2\xbfS\x8e%8\xc2\\\xf6\xbf\xbb\r\x1a\x04\xde\xd9\xf4\xbf\x1b\t\xe5\xd4\xab\x1d\xe5?*\xfaI\xcabg\xc7\xbf\xf4\xb7\x90\x7f\x18\xfe\xfa?\x91b\xc1\x04\xb8\xe1\x95\xbf\xb1(\x1b\x9c\xa93\x07@\xe7\xad\xe3\t\x17e\xfc?QT)\x040\x8a\xfa?\x89C\xb1\x10Z\xb1\xea?Y\xd5J\xee\xd1\xa4\xe7?h\n\xfdIm\xfb\xe7?\x08\x12\x91i(`\xe9\xbf\xc0\x96\xa1G\xb4)\xc3?\xef\r\xc9\x9f\x8d-\xf2?\xce>\'\xadg\x0b\xfe\xbfvK\xf4\x7f\x04\x13\x05@b\x1d\x80y~b\xc7\xbfP\x99\xee\xf3\x01\x95\xd4\xbf\xba\x82\xda\x16\xc0\x13\xa8?.\x14\x82q\x1b\x0b\xab\xbfQ\x02r\xfayV\xf1\xbf\x7f\x90\x0f\x98\xf0\x91\xe2\xbf:\x1d\xb7\xa1\xd2f\xe5\xbfp\xf9G\x83\xcbO\xed?\xe8\xd7!\x8c\xbc\x9e\xe1?\xc2_o\x16\xbe\xab\xf2\xbf{\xc1\xf2T,h\xe9?d\x01bx\xdc<\xf0?\x9fl_\x90\x89\xdc\xe0\xbf\xc8&\x88\xd2s\x95\xf7?b\xfc\xebubN\xde?b\xd3\x8e\x96\xff\xc7\xe3?h\xe1|\x11{\xeb\x03@\x9en\x94\t\x81\xfd\x03@\x11\xc2\r\x1d\xcf[\x03@\x87\x976\xea\xce\xf6\xeb?d"=\xcfk\x9f\xdc\xbf\xe6\x005\xa2\x02\x9f\xe5\xbf#V\xb6\x9d\x86\x12\xf2?\xe8\xb6\xa8\xc6\xf8\xbc\xe0?\xa1\xe0\xec\xbc\xd4p\xe6\xbfxM\xcd\x9d\x0e\x0f\xd7?@d\xce;\xab]\xf2\xbf\xfa\xae\x04;\x0cX\xf3\xbf\x15\xe9\x9a\x9b\xfa)\xf2\xbf/\x82<\x98\xc3\xe8\xf2\xbf\xf4f\xb0\x92\x99\x9d\xf7?\xdc-\xe17\xc7<\xdd\xbf@\xdbM\xce\xc9\x8a\xfc\xbf\xb9R\nr\xcd\xc9\xe2?C\x0c\x91\\Ef\xf9\xbf\x83\xb9q\xf2\xfb\x18\xf2\xbf\x03^\x87\\\xdcf\xf7\xbf\x1d[\x03\xea\x17\x8b\xfa?O"\x02\xc5\x85w\xd1?2\xab\x1aI\x1bu\xe0\xbfW\x05\xca\xa2\x1d\xb3\xed?\x06Z\xb5\xfb\x9e\xa7\xfd?l\xd8\x9ek\xe15\xf5?a\x93\x8bf\xfbA\x05@\xa9\x92\xd3\x9c\xe8\xa0\xfb?\xc3`YO_\'\xe9?\x05j\xb1\',\x7f\xfe?\xda\x0f\x87XG\x87\xe1?\xb3\x8f\x88p\x13\xbe\xf4?\xfc\x8fB]\x01\xab\xb6?\xe3\x9b<\x0e\xbc\xd7\xf3? A\xf0Y\xe4\xca\xf1\xbf\x93nQaS\xdb\xef?\xf5h\x85\xd4\xe2\xac\xec?[\xf9S\xebH3\xde\xbf\x93.4\xc7\xe4\x00\xff?\xd6i\xe2\xff\xdc,\xf3\xbf\x11\xa0(H\xdau\xec\xbf\xf1\xef\xe8P\x0bC\xfd\xbf[\xb5\xec\xfc\xa0A\t\xc0\xf2\xd7_^q\x02\xfe\xbf\x06\x81\xc03\x93\x1f\xeb\xbfoF\xc4\x99R\xf0\xf2?\xb2o6.\x85\xbe\xd0\xbfX\xd8\xdc`\xfb5\xbb?=\x8ch[j\x02\xa2?\x8dH\xf551\x17\xeb?\x11\x1e\xcdq\x9b\xb5\xfb?\x96\x0cn\xbd/\xe0\xfc?u5><\xdcb\xd4?\x1e]\xfa\xb5]\r\t@/\xbb\xb4\xd3\xba\xaa\xf5?\xb5\xbc\xb4\x1a\\`\xfe?y\xbd\x8b\xb2C\xec\xf9?\xf9\\\xfe\xbf\x917\xd0?\xa1[n\x1f\xbd;\xff?-\x9d\xa9\xfeSJ\x9b?\x84\xa2_\xd58p\xba?S\xe2\xfd\xc2\x88*\xea?\xce\x7f`\xf7\x8d\xe3\xf9?L(wE\x12{\xcf\xbf\xd9\x8a\x03Y\xe8\x9b\xed?\xe8Z<,\xa8\xbb\xdf\xbf\xd8\x89^\x1c\x1e\xaf\xe6\xbf\xf4\xd3\xd5\xce\xedM\xf2?\xd6\xbaO!p\n\xf9\xbf\xb0\xcdG\x8a\xa1\xe3\x00\xc0\xc4\xdc[\x84\xe6\xf6\xed\xbf\x97\xb0?\x91\xa3\x80\xee?E5\x06>[\xa7\xb6?\xf6l\x12\x99\xc4$\xc9\xbf^MY\x19PG\xf2?k\x1f \x83D\x89\xe6\xbfe\xf9\xa6\x10\xf2\t\xe9?\xa3\xa4\xba\xd9\xa8\xb6\xfc\xbf\x18Q\x9d\x9a\xbf\xdc\xfa?\xc6_?\x11./\xf5\xbfN(,ek\xaf\xca?\xc9N\xd3(Ps\x06@\xddAh.$\x94\xfe?\xec{\xcc,q\xb9\xe0?t\x8b\xde\x085\x19\x06@.\xcb]\xef\xdfD\xd2\xbf\x94\xae\xd9do\\\xf0?\x0b\x14~\xa5\xbb\xd2\xe1\xbf\xdfD/3^\'\x96?:\xae\xd2z{\x13\xfa?\x11\x90\xf9\x9a\x9d\xf3\xe0?\xbd\x89\xde:_A\xdf?d\x06\xd1\xc0\xe4\xbf\xc4\xbf\xfd\xb1m)\xcd\x11\xdb\xbf\xa2s\xba9\xd3\x1d\xe3?:;\xa5D\xe2\x15\x06\xc0\x98|\xad\xae\x1f\xfc\xe8\xbf\xa7;V\xb1\xea\x8c\xfe\xbf\xefd\x98\xe3\x87}\xe3?\n)\x01"w\x8d\xa4?8\xac\xfa\x0b\xd8\xa9\xee?0\x9d\xe8\xb8Y\t\xfc\xbf\x1e?g\xc2\xf2\x9f\xa5?#\xc0\xed\x87I\x05\xf8?s]\xaew\x8a\xbe\xc2\xbf\xf7;\x87\xd8l\xd0\xe3?\xfd\xd2\rW\xb4\xf1\x00@\xe5\xd4\xa4\xc1\x15\r\xf0?;#k\x9d\xe2\x03\xfd?\x0f\x96\xfd)\xc9\x87\x00@\xd3K2\xe7\xa2\xac\xfb?\xbfp\xe6\x92\x95\xec\xf1?\x0e\nn\x89;\x87\xee\xbf\xddt\x9e\xf7\xab\x84\xed?\xb7_-_\xae\x18\xe3\xbf%Q\x0b\xa2\xdbC\xdd\xbf\x88g[jj\xb3\xe0\xbfh\x0b\x86Cc_\xda\xbft\xad\xf9\xb1\xf2\x85\xdf?gR\x9d\x04\xf2o\xa3\xbf\x08\xae\xf6]\x81\x0c\xda?$\xc1\xbdfdn\xf0?V`|:^\x92\xc9?\x9c\xc3\xa177h\xb0\xbf0\x847\xf3\x02\xcd\xf4\xbf\x87\xf2%\xa1\xbd\xd0\xf7\xbfo\x16V\xb4\x08z\xf2\xbf\x8f\x0b\x13%\xfdC\xf1\xbf\x13u\xf5|\xe3\xae\xe5\xbfk\xd0Uc\xfc<\xe6?\x84\x06k\xc6f:\x04\xc0a \xcd\xb1\x86\n\xd5?\xc2\n+;\xcd)\xec?\x9b\x97\xa2\xa7P(\xfe?\xedI4\x8f\xd8\xdb\xf5?\xd6\x01\x91ux8\xf4?\xb2\xd3q\xb4no\n@\xfewr`\xc3(\xd4?\xc8\x8f\xa2\'\xd8\xec\xf4?\xa6\xe3\x97\x7f\xf2r\xe8\xbfG-(B\x9d\xc3\xde\xbf\xe4\xfe\xb9v3|\xfa\xbf\xfd\xa5\xf9\xa8\x08E\xfc\xbfB\xae<\xc3\xf7K\xff\xbf\xad0z2\xc7@\xf4?\xaf\x7f2(z\xa4\xcb?X\x85\xa2\x89\xe5\xf0\x02@\xec\xaa\xe75\xdc1\xc2\xbf\x8eZk\xdd\x1d\xce\xd7?h\xf7@/|\x1f\xea?M\xbb1\xf3\xc4[\xf5?fR\nH\xe4 \x01\xc0\x8a\x1e+Z\x9d\x9e\x02\xc0j`\xa2!=\x94\xf8\xbf"0~\xdd\xe4\xc9\xf1\xbfcxt\xb7\xa7"\xd4\xbf\xed\xc1\xf5\x10\x0b\xdb\xb5?\xb5\x85\x9b\xd19?\xf9\xbfq\x17\x96\xeb\x84u\xf6\xbf\xfa3\xf4\xe8\xc3\x8b\xdd\xbf\x1b\xe4\xc5\x07\xc7$\x03@\xc8\x0b\xae\xf5\xa8}\xf8?\xdaqD\x9cVP\xe8?\xc0^\x00\xf0\xb9\xcd\xfd?\xf9\xc8kx\xe2\xd7\xf8?wN\x07\x14\x03X\xf3?\x03\x1dD\xc5\x7f\x0b\xe4\xbf\xfc\xec\xc8\x1cL\xfe\xd2\xbf\x96\x8a\x11g\xb2\xec\xff\xbf\xdf\x12b\x96\x80\x07\n\xc0s\x8f\xb4\xb2\x81\xdc\x0c\xc0\x8b\xc2L\xda\xa8\xc4\x0f\xc0\xb7\xf6\xe28\x02\xfa\x01\xc0\x9c\xf1\r&\t\n\xe3?6\xff\x08\xb7v\xe3\xf0?\xde\xc4d5k\xa5\xf9?\x17\x85\xa8_y\xaa\xee?J\x96U\xb0\xd6X\xf6?\x08\xf4\x1a\xf4\xa8\xa2\xf2\xbf\xdf\xa4\xa5\'\x1b\xcd\xf1\xbf\xea\'1\xb9Gn\xf0\xbf\xd4|eL\x7f.\xf9\xbfPz\xaapM\xdf\xf9\xbfr\xa8J\xf8\x89\x0c\xc1?\xea^\na\xf6Z\xf8\xbf\x8a\x05\xf2\xcd\x0e\x0f\xe0?\x9a,\xb4\xd1o\xe9\xea?\x9b\x96\xachsh\xe7\xbf\r\xfb\xdc\x07\xa0\x80\xf3?\x0c\x9d\x97A\xe0T\xe7?\x1d\xf5\xce4\xe8F\xd2?O.\xba\xbbH\xe0\xfd?\xea7=\x84\xc4\xb1\x03@\xa6\xd4\xfaF\xf1\xc8\n@\x89\x00\x176\xb5\x83\x00@7\xa3 \x94\xb7\xc5\xf1\xbf\x01>\xd2\xa6\x0e]\xf5\xbf\xceQ\xef\x89\xbe\xb8\x01\xc0\x94k1=\xeb8\x0e\xc0\xe9\x84/\xea\xbf\x9f\xf0\xbf@\xf8\x06\xde|\xb5\x0b\xc0\xef\xcc\xc2\xaa\x12\r\xee\xbf\xb3\xc9\xfb\xda\xe2\xd0\xef\xbf\x83\xab\xa2Q&\x9d\xf0\xbf\xe1\x83\xd7K\x8a\xd0\xf5?c\xfa_?\xa3Y\xfe?\xe0n\xd5\xd0\x8cv\xb8\xbf8e\xaer\xeaN\xe4?\'F\x95U\xd9k\xe6\xbf\r\x14!\xfa\xa1\xd0\xf1?\xea\x9b\xce\xa7\xf91\xe3\xbf\xa1]\x96B{a\xfb?\x06)\x15\xda\xe5\xf1\xea?Q\xf5-5iq\xe6?H\x9cI\x8fb\xe2\xe1?\xd6a0\xb9\xfe\x0b\xf6?\xf4\x87\xf8\xef\xde>\xf0?)\x93\xe3"\x11\xf3\xda\xbf\\\xb2\xea\xbb\xdd\xd3\xdd?=0\x05X\xd8S\xcb\xbf|e\xe7\x13\x1a\xff\x03@\xa1\xfe\t\x9a\x9b\x19\x01@3\xe8\xc5\'I2\xfb?\x98\xe3\xd8\xa5\x9cP\xe2\xbf\x80=(\x18+\xf8\xbc?i\x0b\xf4}\xc7\xff\xd5?\xf2\xef\x82\xec\x92n\xf5\xbf\x9a\x023\xc5\xd7G\x06\xc0I\n\xce\x90^\x15\xed\xbf\xc4\xd7\xa6l\xb29\x03\xc0\xd6\x93Sb\xbd\x8a\xfb\xbf>BA\xcf,\xe0\xe8\xbf\xbcM{\xce!\x81\x06@2\x01Um?\xc0\xe4\xbf\xce\x07Y9\xd1\x18\xf4?\x80\xcd8\xb4\x92m\xc7\xbfJ\xf8I)\xb4\x1d\xfd?H\xab?\xcb_\xb5\xc2?\x18\xafz\xca\x9b\xce\xe9\xbf\xd8\xa5x\x1b\x89\x93\xcb?\xffm:\xd6\xa0\xfc\xea\xbf$r\n\xbe\xf3<\xe2?&\xc3\x19\xcf\x8c\x86\xf8?\x8e\xe7\x16,\t>\xeb?0\xb5\xe6\x12\xb2p\xe1\xbf\x18\x16\xe2\xcf\xb0\x0e\xf4?\x81h\x85h@_\xf2?p#\x02\xd6\xb7A\xfd?\xd8\x91\x97\xf0\x8fA\xec?\xf8E\x83\xd6\x81\xe4\x01@\xc1\xd8\xfb\xe4\xf7\x8a\xf4?g\xd9^\x0e\x1c6\xe9?,\xaa\xa7\xfab<\x00@B\x83\xe2\xfc\xfe\x06\xe2?-\x87\xb1\xf6R\x17\xe3\xbf\xa0j\xdc\x12\x06\xf2\xf0\xbf\x8fN\xb8\x0f\xa0\x85\xd6\xbf\x9a5\xd0\xb6\xc9G\xe8\xbfw\xd7\x92\x85n^\xda?\xe7\x8fV5\x1f\xf9\xf5?\x0f\xb8f\xdf\x03\x1a\xfa?\x0f\xdf\x9d\x16bB\x05@*\xcb\x84\x89\x8b\xe6\xee?\xc0\xb8 \xbdr\x8a\xea?\xfd\x1dn\xf4\xd9\x9e\xe9\xbf\xa3\x9foF\xfcS\xee?3)O}\xe5\t\xc6\xbf\xa9\xaa\xf7n\x7f\xd5\xbe\xbfB\x9c\xa0\x8cAZ\xd2\xbf0\xaaS\x06PV\xed\xbf\xe4\xa4I\xa20\x00\xb1\xbfhu[\xb5\x99\x01\xd9\xbfD\xa2\x9b\xd6\x10v\xe2\xbfv\x04-\xe0\xc3\xb5\xf8\xbf\xc0[0F\x80\x04\xc4\xbfu\xe4hA\x1d\xa9\x99\xbf*\x00_\xaa\xdd\xce\xcb?\x07\x8b\xec\x07\xf0\xe8\xf2?\xf5W\xa4\xe2 \xb4\xf7?Z\x8e>\xda\xa4\xea\xfe?\x08Vz\x9bb[\xfc?\xdcJ\x8fo\xd6\xfd\xf4\xbf9\x8e\xa3\xa2\x1b\x88\xfc\xbf\x9a$L\x9e\xee\xe6\xf3\xbf\xe5,3\xc3\xdf\x04\xe9\xbf\\\x16\xbd;\x86/\xbb?\x02\x98Lb\x1b%\xe6?\x97\xb6\xaby\xd8\x83\x0e@\xc8<\xcfD\xbd\xf2\x0c@\x15\x81b\x9d\xdb\x00\xf0?\xc7G\xd0|\xc7\x0c\xe0?M@\x9dU\xa6R\xe7\xbf\xcc\xb3\x0eC\x16F\xe8?\xe04\xf7\rP.\xe1?\x97\x0e\n\xe4\x150\xd3\xbf\x87\xd9[1\n\xbf\xa1\xbf\xe82\x06\xa3P\xad\xfb?\x00\x97H\xe9\xb1#\xc0\xbf\x06zD\x90\xc2a\xe7\xbf\xc5^?\xdc\x07\x9e\xe4\xbf\x17\x94\xf6y\xf1\x1c\x9b?O\x0b\xe7I\xe6\x13\xd5\xbf\x90\x00E\x114\xd9\xba?\xb1\xb7)N\xa5\x1a\x8d\xbf\xc8\x9c)\x13`{\xfe?\xd8y\xf90\x0fX\x03@\xc4*`!#j\xf4?A\x97\xe1\x80\xab\x13\xeb?\xac\xbb\x80\x80<\xf2\xf8?\xf3\x82\xf5\x87\xcb\x0f\xb2?wj\xe3\x8c\xfe\xf6\xd7\xbf\xc1\x08U\xc9(\xe5\xed\xbf\x8b/\x1e<\xd3\x95\xfc\xbfT\x80D\xd2#w\xf1?\xa2\xdcZ`\xe3\x8a\x05@Z"\xe2\xb3sa\x08@\xad\xe3\xfat\x87\xfd\xf9?\xd4\x12\x08\xa5F \x06@/\xa8\xc8\x1a\x15\xa2\xb3\xbf\t/Y\xb00G\xdc\xbf\xc4\xd95u\xba\x0c\x04@-\x9e{\x9b\x14?\xf0?\x05S\x91\t\x7f\xc6\xfe?\xb2\xc7\xf2Q\xa8\xcf\xdc?\xb3<\xa4D#\xb8\xd6\xbf$c\xb1*\x19\x7f\xe8\xbf\x91\xf7\x0f\x16\xbaM\xfe?\x08\x18\x7f\xf7o&\xf4?\xfd\x96;\x8e\x1b8\xec?}\xda\xe1\xe5\x05\xaa\xe7?\r\xa4V0\xe72\xf0?\x95!\xe2k\x8b\xe2\xf1?\xf8\xcb\xf6\x93)3\xf3?\xdd\xc9X=\xe3\xcf\xf6?\x05\xae\x97\xa2\xeet\xf8?WNe\x88\xc8C\xee?\xa9Vy\x91\xba\x84\xe3?&/\r\x83h2\x01@\x08U\xf4\x14H\xfe\xf1?\xdfQ?\xc4\x91\x03\xdd?C\xd4@\xd0)8\xcf?T\x81\xe8\xb5L#\xca\xbf\xa9wB\x9d\x9bi\xfb?\xfe\xe3I\'\xd5[\x06@\xf5\xe66j\xad*\xf1?\x80\xfe\x90!\x9c\xf7\xf1?f=fb\x8b\xba\x00@\xb1\x1d\x94\x7f\x9a\x10\xe8?\x9f\xcf\xff\x9d\xf3\xef\xd6\xbf\xc3\\\xee1\x92\xde\xb6?\xe8Q\xe7\x8d\xbe\x8a\x05\xc0\x80\xacC"\x08\xc7\xfd\xbff\xb2\xfe\x88f\x13\xf3?\x01;\xf9\xb9W\x17\xf8\xbf_\xa4\x99\x97\x95\xff\xd1?<\x88\x0ffm\x01\xf2?_\xf2\xa5\x08\x96\x07\x00@Y\xf3\xd5;x\x0b\xc5?C\x95\xfb\xd21\xaf\xe0\xbf\x15\xd5\x12|\xf4t\xde?\xee"\xc9\x12\x8a\x08\xc1?\xc3\xc9\x80\x9dZ\xcf\xf3\xbff\x08l[r\x9e\xa7?\x0f\x08o\x11\xb5\x1f\xf8?!\x04\x16u\xc3\x1b\x02@\xbe\xb0\xfeS\xa6\xe4\xe9\xbfR\x80]\xd2\xba\xbd\xb2?\xa9\xb1\x89\x14\x9c6\xf3\xbf$\x8b\xcdLO\xac\xe0?\x19\xb0\xdaj\x0f\xcd\xf3?\xdeCd\x958\x82\xdd\xbf\xc7\\\xb4\xb6\xb2!\xe0?2\xe0\x7fy\xf5\xab\xed?U\x82\x03 \xe3:\xbf?\xea\r\xa6*\xf1\xbb\xe2?\x93t\xd2\x85X\xef\xcf?F\x1d\xf5a\xca\xe2\xa9\xbf\xae\xaa\xb6\xc0z\xbe\xf4\xbfd\x1b\xea_1\xac\xf4\xbf\xa7s\xba\x82p\x03\xeb\xbf\xf5\xbc\x0bWv\xf0\xd0?\xaf\xbc8Z\xe3\xe9\xd9\xbf95[r\xa5\x89\xdb?4\xc9m\xdb\xc6\xf5\xf0?V\xf6\x15\xca\xffv\xdc\xbf\x9f\x1fs\x9d\x88\xb6\xd4?\x9d\xdb\xec\x82\xa70\x03\xc0e=\xed\xb8 G\xc4?\xf0\x83\x9aP\xc6#\xc9\xbf\xe68\xda\x86>=\xd2\xbf\xb5F\x7f$1Y\x05\xc0tg\xc2\xe5\xca\xdd\xe5\xbf\xe3\x0f\x16\x01\x9fX\xe0?\x16\x964\x8d\xe8\xd2\xd3?\xea\x85F\xd9\xf8&\x01\xc0\xb2\xf3\x81\xd3i}\xda\xbf\xa9\x9eys\xe8,\x9f?\xed\x96\x06X\x13\xd2\xc2?\xcb\xd0O4(\x9f\xda?u\xe0\xb3J\x13.\xd3?\x90F#@\xc4e\xfc?\r?J-\xaa\x0b\xdc?I|\xd2cNy\xfb?w\xd0\xc7\x0e\x1f,\x02@=u\xb61Z\xef\xf6?\xa9}~?\x859\xf9\xbf\xd2XV\x81\x1f\x8f\x02@\x87zz\xfc\xb3\x02\xd7\xbf2n!+E\xc3\xc2?,<\xcat]"\xe9\xbf\x82?\xfa\xfb\xd3f\xf2\xbf\xdcJ\xf4zh\x8a\xed\xbf/]\xbc.\xe7\x1c\xff?\xf1\x9cI\xee\x1cF\xf4\xbfe=\xcb\x08\xb2s\xf7?\xac&\x96\x06\x1e\x9d\xf8\xbfH\x10\x9fqcD\xe2?pQ\x8f\xd3\xbfV\xfa\xbf\xa3F;\x7f\xcb/\xf0\xbf\xeb\x83\x94\x86l\xe9\xe3\xbf\x0cO\xba\x81\x01e\xe8\xbf\nJb\xea\x07*\xd6?H;\xb8\r\x0f(\xe6?\xb1d\x81z\xc3\x9d\xe4\xbfNU\x84|\xcbR\xd9??&\x0e\xa1W`\xe5?i\xf2\xef\xb5D \xe5?\xf2\x1cg1q\xef\xed\xbf|k.u\xedy\xec\xbf\x88@|4\x03{\xf8?\xda\x16~\xbd\x99\x02\xf6?{\xf0\xd1\xe4\xcc\n\xda?\x1as,\xdb\xe3j\xf1?|#\xb8c\x01R\xe4?\x8c\xd29\x08\xc9%\xed?\xd3T\x89U\xc2\xfb\xfc\xbfJ\xd9u\xf5\xe3e\xc3\xbfE\xbf\x98\x93\xd6F\xd8\xbf\xab~\x8d1\t\xfc\xcc\xbfa\x17\x9e\x97\x9e\x9f\xd9\xbf\x9c\xc8\xcd\x0f\xe5m\xf4?\x89\xfdE\xb2\xe2O\xcf\xbfu\xfe\x87~\x9d\x88\xf1?b\xf4\xa4;*\xd3\xf3?\x16\x88\xff\xe9\xc8\xb1\xe3\xbf\x99\xed\xbb\xf9\xfb\x8f\xde?\x0b\xf1\xcamGa\xe4\xbf\x10U\xc1\xb9\x91e\xf3\xbf\x7f\x10\x03\xcaz\xba\xeb\xbfs\xf6\x10\x087V\x03@\xaffr\xd9\xfa\xc2\xe4\xbf\x11\x04Z\xc3\xddr\xee?\xd5\t\xb9\xad\x93\x01\xc8?:\xe4\x1cd\xba\xcb\x03@\xe0\x035\xfa\x83]\xd3\xbfd@\x07\x9c\xae`\xed?*\x91\x9c\xac\xe4\x04\xdb?\x08\xa8\x988:\x8e\xf2?\xe8\xcf\x9e4\xc5?\xf4?\xdd\xd6\xf1\x98\x1c\xd8\xb6?\xa6\xe5@\xb6f\xa9\x07@ff"\xc9\xe6\x92\xb7\xbfi\x0b\xff8!\xfa\xfc\xbfA\xe6\xcc3T\x88\xe3?\xc0UO\\\xd3\xc6\xc9\xbf\xf4\x89\x9cQ\xf3<\xb8?\xd3\x03\xd4\x0bb\x80\xed\xbf~\xb3\xdf\x81\x89\x00\xd3?\x93To\x18\xc7S\xec\xbf4@\x96\xfca\xa5\xf6?\xc7\xfb\x9a-\x9f\xdc\xe2?b\xa2X\x05!/\xf0\xbf\x08\xa3y]\xaa\x03\xd3?m"]\xdf\xa4\x07\xeb\xbfE"\x90\xb3\x16E\xb6\xbf`\xc1\xfd.t\xd2\xc7\xbf\xaf\xf9\xb0\xffV\x0c\xf7?\xd2\t\nT{\x08\xee\xbf\xbd\x9f\x13\x93H\xba\xd6? \xd2\x88\x82\x14\xaa\xf1?\x88\xab\xc0Z\xdbY\x01@\xbd\xb4.\x82\xa87\xe0?\xb7\xec[\xbd06\xe0\xbf\xbe\xff\x03\xb4\x1fM\x00\xc05\xdf!\xc4G\xe2\xe5?6h\xe3\xc6\xbf;\xb0\xbfY\xd9\xcf\xe4\x82\x98\xec?"\xa2\x03b\xaf\xc1\xe0\xbf\xd7;\x9b\x1auZ\xe7\xbf\x90!\xa7\x8c\x8c\xa3\xe2?\xdc\xb0\x95\xfc\xfb\x1c\xdc?\xfd\xaf\xf9W\x89\x0e\xfb?\xaa\x1d\xdb\xa4vF\x96\xbf-\xd7^\xcdKj\xe7?\xd8\x00U~\xf2\xd3L\xdc\xbf\xe6M\x1b\xd8\x0b\x1a\xec?\xe7*\xee\x81\x91\xf4\xf1?\xcc\xeaZ\xe2\x9e\xda\xbf?\xaav\xbc\x1eJ8\xca\xbf\x97\xe9\xcd\xe3\xaaS[\xbf\xb6\xb5\xa4\x003)\xd8?\xe7\xc4\xc3\xc2\xfd*\xe6?U_\x93_Z\x9b\x01@x\xab\xa2\x94\x93W\xf7?\x8c\x9f\x07\xc8j\xb0\xf9?\x8f\x9b\xd1( \xe4\x02@\xaaJ\x91\xb1`\xba\xc5?u\x84!C\xe4*\xf1?\xce4\x9e\xd0\x91E\xa6?MWv\xc2\xe8\r\xe9\xbf\x8e\xbf\x00\xf4R\xe6\t@\x07\xd7\xbf\xa5\x98\xcb\xd1?\'[\xf6\x15B\x88\xef\xbf\x8a\x7fUi\xa0\x9f\xdd\xbfM\xe2\x1f\x80\x91\x0f\xf7?\xa0\xfa\xcbOy\xc0\xf1\xbf>\x12}\x00\xc9\xa0\xce?~7\x1d\x7f\xc9<\xee\xbf\xdd\x15\xf2\x0f~\xa7\xef\xbft\x91.\xfb\xba\x83\xc8\xbf\xf3\x07/\x02Qd\xdc?\xca4\xe8i\x08[\xbd?S\x8fX\xeb"A\xea?\x8f#G\x19w\xfc\xf0\xbf\x00\xa0J\xa3\x92\xa2\xe4?o\xac\xa9\nx\xd7\xf9?\xe8y\'\xbdz`\x01@\xeb\x039\xd9\x80`\xf0?\x81\xe7\x92\x07\xfc\x86\x06@J\xee\xc0Zc\xbc\x08@\xd97<\xf2\xb9\xb3\xe5?\xf4\xbbQ\x16+\xbd\xf9?\xb8j5\xcf\x07\x10\xf1?\x17\xfb\x8e\x92*\xe6\xd4?\x9c\xb8\xe0\xd3o<\xe9?{\'b\x86\x1b\x1b\x90?\x15\xfck\xe8\xea\xac\xf0\xbfj\x1d\xb2\xceT\x95\x01\xc0\xad\xbcU\x01\xbb\xce\xb3?\xf78$\xf5\xed\x8f\xe9\xbf\x0bA\xf6V\xdc?\xb8\x97\x0ep\x83U\xec\xbf\xf4\xe6\xc0\xbdH\xb9\xcd\xbfO;\x98m\xfb\x89\x93\xbf3\xe2\x84\xe0\x0b}\xf8?\x9e\xfc\xedT\x17\xbc\xb4\xbf}\xb0\xe4_\xa9*\xee?"\x88\xb1\xa7\xf7\x1d\xc5?JiO\xb2\xb0d\xf0\xbfE$`N\\\x95\xe0\xbf\xad\x9d\x01P\x80\xb2\xb9?\xb2Fa\x8b2\x85\xd3\xbf\xcb\xa2\x80<\x86\xc8\xf0?\x84\xbcmF\x7f\x11\xd3?\x87zl&\x18\xb7\xb5\xbf\xfe\xce6\xf0l<\xe2?\xc9&.HV7\xd3?\x8a8\x9b\x0e\xfc\x90\xa9?\xe7\xd6\xab\x8f\x84\xc4\xbc\xbf\xfe\x17\xbf\x13\x15q\xed?\x03J+fWC\xcc?\x1a4\xc1\x07\xb5\xa1\xf6\xbf\x7f:\xb9\x8d\xf2\xd3\xd8?\x17\xd9R\xe3\xf1E\xda\xbfi\xd2\xf4\x8c\xcf\xa5\xf5?\x88\xc8\xb2\xe5\x12\xf8\xf5\xbf\x8ei_W\x17w\xe7\xbfm\xfct\x90I\xf6\xee\xbfJ\xab\xd2Y\x18\xf3\xd8\xbf\xa5q\x03\xc0#R\xce\xbf\x0f\r 0\x9eD\xed\xbf\x98\xfcl\x04oT\xa6?So\xd2\xd4\xa1\xaa\xcc\xbf\xc92\x08A\xe3\x0b\xd3\xbf\xe4\xa9\xc5)\x90t\xd2?\x92\x04zP\x9e:\xd9?\x8b\xe2\xee\xd8\xb7\xc1\x00@N\xa4\xb3{\x89\xb0\xae?/\xa6\xd39],\xe6?\xe3x\xf0\xc4\xdb\xc1\xeb?\xe7\x85\x94\xda]\xd9\xda\xbf\x17\x88=\xc6\xe2\x84\xee?m\x0c\xe8\x8e\x1d\x83\xce?*-\xd0\xd1\x07\x86\xfd\xbf\x06#\x04*\xf6\xe9\xc1?\x8dV\x01\x15+\x07\xf8\xbf\x17\xfd\xa0:#\x82\xe0\xbfd\xf9\x8ev\xde*\xf5?\xa6\xf4\xe0\x8f\xd1\x81\xf0\xbf\x15\xdf\x9e\xf4\x8b\x96\xd9\xbfpJe\xc1\x1fk\xe8?y\x06\xfe\xaa\xd6\xea\xe0\xbf\xfdf\xb8\xde\xd4\x00\xf7\xbf\xd2\xe4\xb9\x08\xb6r\xe7\xbf6?\xe7\x14\xbdT\xd4\xbf\xf3\x8az\xec\xf0\x04\xf5\xbf\'\x9bB\xb3\x19\xdd\xf4?\x19n\xdf|\xfe/\xd4?\xdd_\x83\xde\xb3\xa7\xf6\xbfj*]Z\xe1\xe6\xdb\xbfgy\x0f\xd6[\xf5\xe3\xbf`\x88\xd9\x81\x19\xdd\x02\xc0[R\xb2\x04LG\xe6\xbf:%d\xf0\xcb\x02\xde\xbf\xcf50~\xc5:\xcf?+\xb63\x1cz+\xe7\xbf\xd4\x86]\xf9\xd5\xa6\xf1?\xb1\xf9\x1bp\xb7x\xb8\xbf\xc6\x8d\x82\x0e\xda\x86\xf8?Q\xae\xf7\x10\x17j\x00@N\x05\x99\xa1-\x87\xf2?\x99\xaf\xf8\x15\xae4\xf7\xbf\xfa\x9eW\x05>\xbc\xe7?\xb0\xa3\xac\x8b\rQ\xcd\xbf\xff[Q"\x05\x8e\xd2\xbfK\xf5$\x10\r5\xe2\xbf~\x16\xddI\x00\xf6\xea?\xe1\xc6\xbb:\xaa\xcb\xdd?\x057\x9f\xaex\xd4\xc7?\xdc\x8d/\xd4\\\x82\xe4?\xfc\xa7\xab\x85fm\xfb?m\xe8\xc1\x1c\xc4L\xf2\xbf\x9c\xf42\xa2\\\xa7\xf0\xbfF\xf2\xc3\x07\'\xfap\xbf>\xe0\x11O]`\xc5?@\xe6\x00\xcc\xaa<\xda?\x14of\x84\x11\x8a\xb6?\x99H\x92\xb1W\x8f\xda?\x1d\xa7")\xbe\\\xeb\xbfu\x99h\x08\x81m\xe2?\xf6+%8\x87\x0f\xca?\x82\xd6NA\xb3l\xd8\xbf\xe2A\x8e:.\xfb\xd1\xbf\xc9\xeck\xe5+;\xef?\xfc\xdcL\xc7x\xbf\xf7?\x94\x93.x~\xc6\xd8\xbf\xe0\x84\xee\xcf\xafe\xf7\xbfNl\xa4C\xec\xe9\xd3?/e\xd2\x84\xa4\xfa\xf6?\xd8\t\xb9\x1f\xff\xb8\xf6?\xdb\xde\t(\xb2\xcb\xd8?rA\x01\xd0\xab\x01\xd6?\xb8^\xa4C\x8e\xba\x00\xc0\xbco\xbf\xf8\xd5&\xfe\xbf\xc3\xb3\xe0&\xf3\xb5\xb1\xbf\xce\x17U\xabL\x10\x06@\xfb\xc2\xd6q\xa4-\x00@p\xb2Y\xf7\x88\x99\xf2?\xd6R\xc98\xbbT\xeb\xbf\xe2yH1l\xfa\n\x9c\xf3?\xdc@S\n\xfc\x12\x00@\xb4X?\x82\xbd\x91\xec?S%\xbb\x9bC\xea\xfd?\t\xea\xb0\x97\xd8\xaf\xe5?>[\xdb\x8f4\xa8\x05@\xa65\\/\xb3t\xf1?C\xc3D\xea\x80\xeb\xd6?\x0e1{]\x10\xff\xe1?\x9e\xf5l)\xbe\xe7\xfc\xbf \xdb*\xa2\xd4\xf6\xf6\xbf\xb3\x87\x85\xa4w\x89\xe5?\x1d\xb9\xfc\xa3\xdc\x01\xf0?\xf0\xfa\xd9zYd\xe7?\x0f\xb8de\xe1\x06\xf8\xbf~\xfa9\x89\x16;p?c8-?\xb4{\xea\xbf\xff\xb4ls:\x0c\xd0?|+\x1e\xbdQ\xce\xe5?\xb9\x1ef\xfa\xa1\r\xf2?5M\x93P\xa7e\xec\xbf"\x8efP\xed/\xf5\xbf\xc3\xa8\xfb\xad\x87\x9f\xfa\xbf\xa2T\x8a\xf9\x885\xcd? \xe0,#\xba\x84\xfc?\x18\xbd\x02~\x87\x9f\xa1\xbf5-d\xa1\xef\xb4\xb6\xbf\xf6/\xe5\xb1Bo\xfb?\x81B\xf78\x08;\xec?.\x9c4\xaeXc\xe2\xbf\x95\xd0Jk\xaf-\xe4?\xb0\x9a\x9765\xc4\xa0?\xdaD\xd7\xdf\x91\x12\xd8?\x92\xe3\x81\x10\xeet\xf5?\xac\xf3"\xa9\x9d\xc9\xe8?\xd7\xc2-rs\x8b\xe9?A\xf1\x06\x96O;\xe6\xbff\x06)\x15\x15\xfe\xd5?\x95\'\x96s,|\xa5?\x88\x97\x1ex`\\\xbb\xbf\xeb\xd6\xedp\x9b\xcc\xca\xbf\x89h\x17\x1d"\xa2\xf4\xbf\x81\xf9(\x89_\x19\xd4?_N\xad\xd0vO\xd6?\xbf\x91\x13\x87q\xc5\xf2\xbf\xbd\'epS9\xc8?\x8f\xb6F\xf7\x05t\x00\xc02\x0e)\xd9\xc5\xa2\xf4?\xf9<\xc3\x13n\x9e\xf4?W\xe0a\x81\xff\xf5\xf0\xbfo\xa0\x80\xee\'S\xf9?@\xf1\xc42\xc6o\xf0\xbfg.\x14\xfc\x0fh\xd0\xbfI\x9aR\x12.\x0c\xd7\xbf\xc4B\x1c\xf5\xd6`\xea\xbf#\xac\x0e\x9b\xb0\xbf\xea\xbf\xa10Eq6\xfc\xf8?\x12Y\x0e\x17\\\r\xf0?<\xa1P\x94\xdd\xa7\xe8\xbf\xfd\rl_q\'\xf4\xbf7!1\x1f\x08\x9b\xed?D\xd8\x1e3\x11j\xe7?\x0c\x18\xab;\x8a(\xcc\xbfPA\x9760\xb7\xf5?\x82\x11\xf2P\x081\xdb\xbf\x03\x8d\xea\xe0\x83\xba\xe1\xbf|\xfd\xca\xc1O\x8b\xf7?\xb8\xf6p`\x94x\xda\xbf\xb6\xe5f]\x07\xd3\xfa\xbf\x9e\xd8\x01\xafsJ\xf3\xbf2S\xaa\x95|Ia?i\x15$\x92\xf1\xf7\xe1\xbfdW!\xef\x83\xec\xef?\x9e\xdb3\x8e\x02e\xcf?\x05\x9f|\t\x0f\xf2\xf4\xbf-\xa6qd\x8e\x04\xe2?Z\xcfj\x17p<\xdf?b\xcd\x7f\x9bnY\xe1\xbfQ\x16j\x9eG^\xc4?L\xe2\xcf\x15\xe9P\x9a\xbf\xfay\xb4\xfa\xc2:\xca\xbf?\x04\x1bK\xa4\xba\xd4? \x1cY\x1bS\x92\xfc?TfD\xfde\xcc\xf2?\xf2\xd0\x04p\xb0\x95\xd1?n\x13:?%>\xf9\xbf\x11\xf9\x84\x99\xe3h\xf0?\xa2\x96\xa9\xb7da\xf5?(\xf9\xf1\xbb\x9aw\x00\xc0x/\x1a\xfb\xe0t\xfc?T\xddg\x82\x99\xac\xec?\'\xed94\xf3<\xe4\xbf\xc6\xbf\xf8:\'\xf5\x00@\xa3jy+\x9fw\xd3?W\xf9\xe6\x9c#\xe0\xe3?\x97\n\xa0\x839A\x9d\xbf\x84H\xc0\xab\x05\x1d\xe6\xbf\xf8\xfe\x85\xaa\xae\xa8\xd9\xbf\xca,\xe6\xab\t\x95\xe2\xbf\xfb\x8c\x8f\xa8\xb7\x91\xdd\xbf\x98\x1c#\xe6\xb8\xa3\xf6?S\xfeqVt\x07\x07\xc0+\x0eO\x8b\xaf\xac\x00\xc0x\xfe+\x89\tS\xe0?FD\x10\xa7\xaf&\xde?u\xd9\x17,]U\xde?yB\xcc\x8d\xc35\xde?*e\xc8\xc8\x9b\x84\xfa\xbf}\xef\xe9\x18\x18\xed\xe3\xbf\x8e\xad=\xa4\x17\xda\xc1?\xf5\xbam\xa8\x02\xc0\xe7\xbf\xd1\x15\xf0\xcaQ:\xe1?w~\xba\x97\x85\xfd\xeb\xbf`\x99:;TK\xdb\xbf\xa6\x98\xd7P\x05\x05\xe6?\xd3n/\x92~\x03\xf3\xbf\xebYs\xc0\x812\xd3\xbfo?\xf1\x93I\x08\xc5?\xcf&u8\xd5\xa5\xef\xbf\x05\x89\xa5X\xdez\xf1?\xa2f\xba\xe3k\xae\xed?x\xafAg\x81U\xe8?,\xcbT\xab\xda\xdd\xeb?\\\xcf\x87\xacIE\n@P\xa8\xaf\xf0\xf6t\x00@\x1b\xe0\xf9\xa6(\x0c\xf1?6\xf7R\xc9\tG\xe2\xbfg\xd9\x0b \xda\x0f\xdb?\x19.\xbe\xbf\xd6a\x00\xc0k\xbe\x9e\xa3\xb9\x8a\xf2?\x01\xf3sA_\xb4\xe7\xbf\xa4\x16\xa1\xc0\xb8\xc1\xf0?\xfc\x99f\x01\x13\xf4\xeb?VgQ@L3\xfa?uB\xa8\x85\xe6\x10\xda?i4\xca8\x1d\xab\xe4\xbfh\xbf\xd9\xbb\x86^\xdb\xbf\x05]!v\xb3\x1b\xfc\xbf\xfcZ*\xe9\x12\x8f\xee\xbf\x00\x1cvNI_\xf6\xbf\xc5\xef\xf1\xed\x843\xe4?z\xee\xd4\xa9H\xdf\xe8?\xd6\xc2\x90}\xc4i\xe4\xbf\x14.G\xc5 \x98\xd0\xbf`\x15\xbb\xcc!\x08\xe2\xbft\x04\x85\xa7`\x07\x02\xc0\xf2\xa9pv\xb2\xb6\xf3?\x05\xf4\x95\x19\x87\x9f\xe6?\xc9\x80`\xaf\x17#\xd1\xbf\x1c\x04\x03f\xb0=\x03@\x07\xf0\\\x90\x0e\xfb\r@\xb3k\x972\x96%\xfa?\xb1\xde\x021?\xae\xf2?\x83B2K\xbe$\x96\xbf#\x18\xf1^\xef\xe7\xe6\xbf\xfe\x96\xf9\xf8\xbf\x05\xf0?\x8c\xca\xd9-\xbcs\xe9\xbf\xd9\xfa\x16\xa92]\xd9?\xfc\x8b\xbb\x8bS\x0fz?\x99\xd9e\xc5\xee \xf7\xbfJ\xe6\xeeb9\x1f\xf0\xbfL\x89J\x19[\x00\xe8\xbfHk!(\xc3\x19\xf6\xbf]&9Qh\xa5\xfc\xbf\xd0\xben\x80\xcbm\x00\xc0\xc9`\xa1\xec{\xee\xe8\xbfJz\xa6\x95|\x05\xf5\xbfY;y\x1f$\xc1\xf6?\xb8[\x1bYC\xc4\x06@\xf7\xc2\xda\xb3\x98H\x01\xc0-w\xd1\x87.T\x0f\xc0\xbf\x0b\x8c\x18\xf1F\xf8\xbf\xb6\x00\x9c:\x92V\xf4\xbf\xe3\xec\x86\xa5p#\xe1\xbf0\xb0\xdd|d1\xce\xbfo\xc4\xce]\xe0\xe7\xe8?\xf8\x86\xcb~6\xf2\xd6\xbf !\xff\xe3&l\xf2?\xac\x8c\xcd\xe30\xca\x05@\x00\x97\xbd\xfa#\xb7\xfc?\xc6uR\x90;k\x02@\x01M\xd1\xde\xce3\xdf\xbf\x9fQ=C\xc4&\xd2\xbf\x1c\xf5+\xee\xbd\x8a\xe3\xbf\x17M\xde\xc1t\xee\xc8?Y+\x06\x8d\xde\xf0\xe0\xbf&\xaclRs\xec\xec\xbfQ\x9b\x99k\xe5\xbb\xd9?\xa1\xa3b\xdb\xc6\x99\xea\xbfz\xf5\xf8d\x98\x9e\x01\xc0$\n\xc6\n$\'\xf4\xbf\x07\x94B\x04\xe4\x94\xee\xbf\x9d\xe6\xc7\xd2\xdd\x9e\x91?\xad\xb0:\xa5\x1d\x08\xe6\xbf\xe9|\xdc\x98\xe7\x0e\xed?\x00\r\xbe\x96\xa5q\x05@\xdf\\\xda/\xaeT\xf2?@\xebf=\x03\xb6\xfd\xbfc\x94\xa1\x0f!\x0c\x07\xc0F\xf2%V\xad\xfd\x0b\xc0\xb7\'vi\x05\x8a\x00\xc0\xb0&^:Z\xba\xea\xbf\x99 \x8f\x99h#\xf0\xbf\xceg\x04\xa5\xd4\xb7\xed?\x02\xd4\x96\xe7\xce\x8f\xd2?z%\x03\x88\xd8\xbd\x06@n}\x0b\x81\x83\xac\x10@e$\xcb\xbf\xea\x7f\xf6?\xa8\xfb\xfe\x96\x94L\xe4?\x97\xe3\xe2\xab\'\x84\xe4\xbf\x97\xabF*\xe1=\xdb?\x92\x1d\xb6\xaa4P\xe4?\xad\xba\x04\xd5\xc4\x04\xa7\xbf\x97\x1b~\xf1\xc6\x9f\xf3?:\xaf\xfe{\xe0\x7f\x03\xc0\x84\\\t\x9e=\xc7\xf1\xbfw\xceM\n\x95Y\x00\xc0\x07+\xa7\x9ew\xd8\xf8\xbf\xbc\x90X\xa8\xb2\xda\xe0\xbf\n)\x82\xa3\xd2\xf3\xe2?\x8dF\x8f\xd6^\xb0\xf3\xbf\xe4c,>Z\x01\xde\xbf(\x1b-\x8b\xd4\x04\xf0\xbf\x13n\xc8\xa6\xba\xa2\x0e@&\xbb\xf0\xef\xf6j\xfa\xbf\x9a\xbe\xb6\x99\xb4\xfb\x01\xc0UQX<\xef\x01\xe9\xbf\xfa\x7f\xe4\n\x0c\xe2\x0e\xc0\x0f\xec\xea\xe6I\xb3\xf2\xbf6\xd9\xaaou\x89\x05\xc0X\x80\x9b7WG\x07\xc0yk\r6\xc6g\xea\xbf\x96\x15\x9b\x9e\xe5\xaf\xe2\xbf\xd3\x12\xb0\xb0\xfdm\xfc?\xed\x8e^\x8fs\xd9\x04@\xe82\xcbv\\\x89\xe0\xbfm\xb7(^\xda\x0e\xf6?\x8f\x1dr\xfb)\xbd\x04\xc0\x9bs\x90l,\xc6\xf7?\x93\x02s-\xa1S\xe0?\x97]\x10\x91\xd0\xcd\xd6\xbfd\xae\x92\xe1\xc7b\xe8?N\x9f\xbe\xab\xc4\xc7\xbe?\x80\xe4\xa3(J\x1d\xe6\xbf\xe2\x1b9(/\x08\xdd?\xd0\xbac\x94\xdb\x9b\xc7\xbf\xea\xa7*\xc2\xb0]\xfd\xbf\xc28\\<_\xb7\xe6\xbf:\x90\\9\x96f\xd7\xbfw\'L\xb9/_\xde?\x87\xf76\xca\xca\xb2\xbb?\x1c4\x8c\xc0tm\xf5?\xb5\xd6\x04?\xc9\xbb\xe5?\x9b\xe6\xe7\xba\xdd\xc3\xfa\xbf\xc4\x07\xc9+\xddQ\x0e\xc0\xc8\x00l(\xd7\x8f\xfd\xbfX\xc6\xca4\xfc\xc3\x07\xc0-\xdb9\xe8\xbf\x8a\x08\xc0\x8b\xf3o\xf2\x92\xc9\x08\xc0\xb1\x96`\x11*e\x06\xc0\xd5\xb4~\x915D\xfb\xbf\xec.A,\x99\xbe\xf1?Y/\x87\x8d\x13\xa4\x05@[\xdf]\xce%\x11\xf2\xbf\n\xa7\x84c\x13\xd6\xe3?^\xd8F\x91\x07h\xdb?M\xbaE\xbb\xafo\xf1?|!&=\x9dU\xf7?\x13a\xf8\xe7\x8f\xbf\xf1\xbf\xc1\xd2\xd1o\x14\x10\xf8\xbf\xfc\xe4\x97O\x99\x90\xc2?\xb6u\xc1\xb7\\6\x95?W\x00^\x03\x8d\x86\x02\xc0\xb0VQ36f\xd3\xbf\xd9\xe92\xb1\xd2\xe1\xe3?c7\x90\x13\xa1\xde\xf1?\xae\x19\x9f\x02\xa4\xbb\xfa\xbf\xa2T\x80\xf6\xf8\x02\xdb\xbf\xf8\xdb\xfd\x85\x10\'\x05@\xc0\x8b\x9e\x14\xea\xd2\t@f=\xbd\xe2\x8aG\xee?(M\xa2,5\xbe\xd5\xbf+\xaeG\x87>"\x05\xc0\xf7\x82\x80c\x0f\xc9\x0f\xc0okFf\xdd\xd1\x02\xc0R c\x01Y\x1d\xf6\xbf\x87\xb5j\x9b\x92\xf9\x07\xc0a\xbb7\x17\xdbl\xf2\xbf\x02q%\xdc\xc4/\xf1?\x9aGgRy\n\xe5?\xa0h0\xbc\x08\x1f\xf2?\x19\xd9\xf2\xd4\xa4R\x03@\xd2\xd8\x1cR\xe9g\xd9\xbf\xe91-\xbb\x85\x85\xe2\xbf5\xfa\x9ek\x18T\xf8\xbfK\x875_\xaf\xa2\x00@\x9a\x04\xf7\xdd\xc3\x0c\xe6?*\xfbe?\x85`\xae\xbf\xca\x7fi\xf0\x19\xa2\xd9\xbf\x01\xec\xbf\xe2T\x0f\xf7?\xa3\xa8h\xffL\xec\xc8?T\x95\xe3To\x06\xf6\xbf\x8dq\xf1(Ou\xe0\xbf6\xa1,\xc6\x8b\x7f\xd2\xbf1\xb3\x0c\x12K\xd3\xf2\xbf\xf1\xf8({\xcc)\xce?p\xff\x8e-:\x1c\xf4?\xe1\\\x9a\x10hG\xfc?&\x83J\x18PU\xeb\xbf%%\xe2\xc3\x04\xdc\x02\xc0\xa4\xd8\x16\xd1\x80\x03\xfe\xbf`\xb2e\xb18\xe9\x0b\xc07\x8d{\x0e\xb0\xa3\x04\xc0\x9e5W\xdf~\x8a\xc2\xbfQ\xbb\xdd"\x1dU\xe4?\xb1\xa9~\xe2\xbf2\xe0\xbfRn\x10\xef\x0e\xff\xe3\xbf\xd3\x0f\xf8Sx]\x05@:t5\xa4\xdb\x1c\x08@\xab(Sy\xfa\x0e\x04@Lq\x0c\x8ei\xc6\x06@\xf5\xa2.\x82q\xc3\xde?\x94\xc9\xc8[2?\xd1?\xce\xb5z\xb3\xe5\x9d\xe9\xbf\x8a\x00\xcc\x1a7B\xb1?o\xb0\xfe\xdb\x13E\xf4?\xb4\x02BGH=\x00@o\x87\x04\xdaP%\xef\xbf\x94\xa6\x1879\t\xec\xbfu\x02\x7f\xe6\x8c\x8b\xed\xbf\x16\xc4\xa4\x85Gh\xeb\xbf\x87\xca\xcf\x98mH\xf0\xbf\xe2\xd1\x19\xb1@\xda\xc0\xbf\xeaN\xe5\xf1\x13[\xf4\xbf\x01\x982\xde3\x8b\xef\xbf\xae&z\xc6\xb3\x95\xb6\xbf\xef\x04m\x9f. \xf3\xbf\x8e~|\x16\xf6:\t\xc0m\x0b\x043a\x86\xe4\xbf\x08\x07}\xc9}\xcd\xc4\xbf{\xf6\x07?\xaf\xe5\xdc\xbf\xee\xa7fs&\x9d\x01@\\XCI\xe1\x0c\xe6?\xca\xda\x0e\x197\xfa\xf2?\xd5N\xc3rD[\r@"C\xb1\xa2\xc9\xa9\x08@9z\x80\x14q\xa1\x04@\x080VN\r\xe5\xe4?\x1c\xaeB\xf5\x9d\x93\xfb?eeu\xb6\x8f{\xa1\xbf\x88\xbb\x8f\rE\xd0\xbb?\x8ab\x1ajX\x01\xf0\xbf\x9bV=xF@\xf3\xbfl\xd1Sk\r\x00\xf1?MU\x9e\xab\x8d\xe5\xb0?N=\x15]t$\xff?\x1c\xb6\x81\xe3\xe0 \x00@\xc8\x88\xf4z\xdb\xc9\xf3?\x87\x8d[iY\x1d\xfd\xbfN\xe8\x19Fo\x9f\xc3\xbfr-\xf8\xe1\xb3C\xf1?\x00\xac=G\xa2\xd1\xf6\xbf\xa7\xe1h\x97\x93\x03\xe6?yw\x90\xb6\xadNc\xbf\\Hl\x04L\x8b\xf4\xbf3\x9a\x0f\x82\xeb\xde\xd3\xbf-\xfb\x89\xbe|\xf3\xd1\xbfJ\xd6\x84\xfb\x11O\xdd?\x80\xb4\xcc\x03\xcc\x0f\xf6?\x06ZF\x1b\\\x06\xec?\xfe\x16\xd9\xf4f \xd2?\x9eT\x98\xe2\xf3i\xc8?B\xb98\x88\x10\xa1\x0c@\x1e\xf0\x97:S\xe2\t@\x95\x11\x94\xe3|\xfc\xf3?\xcf\xd5\xda<9\\\xe4\xbf\x03\x15\xaa\x1c*\xe7\x01@0\xf7\x84R\xa5\xc0\xd6?\x17\x0f\x8cb\xe1\xfd\xb2\xbf:\x92\x1b"\xe2\x8a\xe0?\x8c\x13/\x88\x8c=\xf7?\xe85\x7f\\R\xcf\xd2\xbfA\xc0B\xb6T!\x00@\xe8\xd1I\xd5n\xb9\x00@\x1e\xaa3\x8d\xe5V\x01@\x1f\x99\x9b\xcb\xae\x8a\xfc?g\x13D\xf5\xf6\x9f\x13@(\xef\xe0\x89\x89\xa9\x0b@Hm\xbc~\xc7X\x13@\x18\x0c\xa0\x8c|\xa9\x01@\xaf3\xc2\x15\xd0;\x04@\x8a\xc5\x12Z:\xdf\xf1?"\x84\x02`\xfa\xa1\xe4?\xe2\x18\x0bo\xf8\xc4\xf5?\x04\x1d\xb3\xc1\xa2\xb4\x03@(L\x99!\xf9\xa8\xf8?y\x05]\xb8\x15\x0f\xfc?\x9d0a\xc5|\xad\xe7?\xd38\xad\x8c3\x03\x08@C\x9e\xa8\xe9J6\x08@D\x02\x06\x05\xd2\xac\x0e@\xe1A\xf4\xa54~\t@$\x8c\xaa\'\rw\x02@p.\xa7fVx\xdd\xbf1\xe1\rA\x1f\x94\xea?t\xf4l\x02Yq\xfe\xbf\xe3\xacK\xe7\x85?\xcc?tY\xcc_OK\xf5?\x9c\xcc\xed\x19\x94\x98\xca\xbfZ\xc8\xba\\[J\x93?E!\xae-M}\xf0?V\'\x83>nI\x07@\xef\xe9\x10u\xf9\x02\x07@=\xf6\x92&\x1b\x19\x14@\xd8\x05\xcc\xe3\xe0\x16\x16@|\xc5\xe6\xa3\x84\xe2\x11@1\x06\nmh\xc6\x13@\xdf`<\x9aew\x0b@\x97\xdf\\\xcaX\xf7\x06@U\xbdi\xd0\xb8M\xfc?\x9dQ\xa5\xe4.\xad\xf3?Kh\x85`\xea\xe8\x07@\xde@\xb7\xe9\xb9\xed\xf9?X\xde\xa5r\xae\xfd\xfe?p\xbb\x8f\x9b\xd3@\n@Q\x8a*7\x82\x96\x07@\x9co\xf0\x02\xc0*\x01@\xd1/7\xff\xd8\xa1\xfc?\xe7+\x1c\xdb)\xd4\x06@\xdd\x1ah\xf0\xbef\xe5?\xf7u\x94\xa3\xcfD\xf4?\xa6j\x02\xd7\x02]\xba\xbfx\xcd\xe7I\x15i}?\xf8\xc6\xcb\xcc\xa4\xeb\xfd?\xc7_G\x01\x1do\xe4?\xa3\xfd\x85\x8dMF\xe8?\xde\xfc/\x88\xa9%\xee?o\x9a*\xd4\x0b{\xec?[\x9f\xefc\x00=\x03@\x0ej\xc4\x99\xab\x87\xf8?:\xef\x9d\xa3\x84\xe5\x0b@\x9b\x0e\xd0^Z\t\x0b@a\xb1B \x1a\x06\xfd?0\x9e\xd0\x8e\\z\xe4\xbf\xa0\xba\xb2\x0c1\x9e\xfc?\xa4\x1f\x8d<\xaa\xac\xf3?\xadC\x05p0\xd0\xe3?\xe1\x90\x12\x084\x19\x08@\xd4\xb3\xb0\xee{\xae\xfd?2\x06}\xbe\x91\xb4\n@<\x90D\xc3\x0b\x81\xf2?\xa1\xeaua\xf5{\x04@\x82\xa0\x88\xe3Z\xeb\x07@\x13P\x990S,\xf5?\x9a%\xcd!p\xb3\xf1?\xb5\xf6\xb3!\x934\x00@\xc1!\xcd\x83ZK\xf9?p\xbd\xe7\xc8\xb4\x81\x00@\xd7\xdb\'yav\xc0?\x82\xe8`\xc9\x15t\xf5?\xe3\xe2\xb5g\xf6\t\xd4?\x1de\xc9\x87\xb2\x06\xec?B\xfd \xcd\xd0g\xf0?\xc1m_{\xe5\xae\x02@\x8cUi\x1c&1\xf3?"\x85\xbb\xe9\xd6\xe2\xfd?\xa3\xbb\x9d\xfap\xbe\xd4\xbf\xe8]\xe9L\x81\xb3\x03@h\xef\x1d\x04\xc1\xf2\xfc?\x12\x14\x07$\n\x80\xf5?\xaa\xde\x8a{\xac\x8f\xcd\xbf!\xc1\x8af\xc3B\xc9\xbf\x15fd7C\xbc\xe5?Z2\xcdE\xe3\x8c\xc9\xbf\x05\x84\x15N\te\xf3?,\xcb\x80&R-\xf4?\xe8\xe7\x05uox\x02@G\xec\xde\x13M\xe2\xbd?l^\x0e@\xbd\xd8\xe7?\xa9\xef\xa9U&\r\xfb?\xa3\x1c\x84Qgl\x02@\x02\xb8\x04\x1e\x1c"\xf4?\xc6j\x8d\x12\xc1x\xe6?\xb8XC\xdfb\xb6\xdb?\xf77\xeb\xe6\xc5\xb5\xdd?\x86V\xbf\xa0\xa4s\xfb?\x0b\xc1J1\xd7\x8d\xec?\x93\xa0F\xfb.\x1a\xa1?K\xe5\xe3\xba\xc0\xa6\xe1\xbf\x00\x90zh\xf5\xd2\xf4\xbf\n8Ck\x0e\xef\xc7\xbf\xde\xf93B\xe80\xdf\xbfR\xbeN\\\xed\x1a\xf1\xbf\xdf=\xad\x97\x02#\xce\xbf\x19\xe0\x91\x01v\xfc\xe1?\x0c\xd6\xda\xd6\x1e\x05\xf1?\x01\x12\xc6\xc3\xaf\x07\xe2\xbf\xb8\xecv\xdb\xd4\x83\xac\xbfp\x83i\xf3i[\xf3\xbf\xcb\x00\xde\x86\xc0n\x07@\xa6\xf8\xfb\x9d\xaaj\xfd?\xf5\xf7\xc6s\x90!\xf4?\xccc\x03V\xbc\xce\xf1?\xe8\x81\xd7F,\xad\xed\xbf\xb2p\x12\xe2\xd4\x9b\x03@\xd2\x1c\xc9\xab\x94L\xfe?\xf6\xd9\xc7\xd78\x95\xfc?9\xfd[2]\xf9\xec?\xab\xbf\xcct;B\xe2?\xd2\xa2E\xda\x8f\xf9\xfd?\x94\x89\xe9SK\xc4\x86?R\x84\xca!=\xf5\xeb?\n\n1\xb9\x7f\xed\xf0?1\xfc\xce\xe56\xdf\x07@\xd7as\xb4b\x9c\xdd\xbfybP \x98Y\xfa\xbff\xc2_\x18\xf1^\xd8\xbf\xf3\x18\xffm\xca\xfb\xe4?\xae\xfa\xc1V\x07\xec\xdf?\xcd\x1e\xb8O-\xb1\xc8\xbfI\xacv\xe4\x17e\xdf?<\x11\xc5\xa2I\xb3\xf6?\xec\x1b\xb3=\x17s\xc4?\xa1\x14K\xcd\xa9\xa6\xdc\xbf\x82\x8d\xfd\xc22\xd4\xf6\xbf\xab\xd2}4O\x1d\xda\xbf\xc10\xf4\xb40\xf0\xb4?\xed^k\xb8[\x00\xee?6.\x07\xbfsN\xf2\xbf\xe6\xec\xe5\xd8\xd4K\xf2? \xa1\x94-\x06;\x04@\xef\xba\x01\xb4\x126\xfa?\xd1\xb4U\xe4`\xae\r@\xf4dSC\xfc6\n@\x84\x7f\x10\'\xc5?\x07@!\xd0\xbc\xa9\x16\xa0\xe6?\xe6t\xf2s\xb7\xe1\xfb?\xe7\xae\x87\xe2\x9dD\xfb?\xe3\x1b\xd8$\xc4\xab\xc5\xbf#t\x8fF!\x87\xf7\xbf\xd9Z\x9b\x87W(\xfe\xbf\x93\xc3\x8e?\xcd\r\xe1?\xa5Va\xacC#\xed?\xad\x1fJ\x9c\x90\xc8\xf0\xbf\xd5=q_\n^\xe4\xbfRuR\xfb\xce\x1c\xf0?M\xc7%\xde\xef\xde\xaa\xbf)\njy\xfae\xc9?\xfc%\t\xbc\x02\xd9\xf5\xbf\xe3\xbd\xa1<\x02v\xd6?\xac\xaa\xfe\xf2\xc8\xd7\xd8?f\xcd\xf6\xdd\xb6:\xf7\xbf\xb7]\xb5\xc6\xdc\xc2\xfa\xbf\x19H\xb7a\xa8\xd0\x02\xc0HrwI\xd4\xc6\xe0\xbf\xd9A\xf9\x1e\xe3\xb1\xf2?\x9av\x0f\x1f\xbe\x08\xe3?\x90\xcf+\x16P\x7f\xeb\xbfB\x98f\xf0j7\xd5?\xa5k\xa7Z\x94\x90\x90?\xe4|P1\xc8W\xde?g`\xafH\xda\x16\xe1?\xe4{\xe4\xc0\xa6:\xf4\xbf\x06\xd5I \xc9\x03\x00@\xbe6S\xf8}\xd9\x91?\x0bA\xe4O\x89\x02\xfb\xbf\xf8\xfc)?\x9fo\xdf?\x1a<\xf8\xdb=\x0c\xe6?\x9f\xf2\xec*\xc9\x85\xe4\xbf\xa0\xe7\xb2\xa9[\x87\xd8?&\x8e\xdf\xd4\xd3\x18\xe6\xbf6\xe8\x05Jny\xcd\xbfA\xb3\xb0\x82OU\xb7?y\x8a+\xf6\x93{\xfb?Xy\x1c1.s\xe8?[\xe8f\xae.-\xb4?F\xa0\xf4\xa3i\xfd\xf2?\xb7\x10\x8d\xec\x7f2\xb7\xbf\x03fr\x805\x01\xe4?\xa60\xc2\x9e\xc0F\xfe\xbfi\xbe\xa4\xfe\x95\x90\x03\xc0\xdd\x14\xa4\xa2\xf9\x92\xe3?$\xcb\xf9\x9b\x1b\xcc\x06\xc0G\xc4\x06\xa8D\xd7\xbd?\r#\xd9\x82\x7f%\xe1\xbf\xae\xd7\x92\x8d\x83a\xf5\xbf/>\xe8;\xc1\xf6\xca?\xd0B/\x94\xa8\x90\xf0\xbfyr\x12\xa2\xbf\xf0\xfe\xbfb\x82\xbbf\xaaZ\xf5\xbf2\x82&g/\x07\xed?\x85\xf1\xedJ\xdf6\xf5?\x14\xa2\xab\x11Y(\xe5\xbf\xb1\x93\x95-a\xc5\xea\xbfX\xd1P\xe0\x06C\xf3?e\x952\'\xf9\xac\xce\xbfj\x1f\xfd\xe8G\xd6\xf5\xbf\xc0k]U\xcb\xd5\xe5\xbf\xa42rdm\x8e\xf2\xbf\x10W\x1c\xc9\xe8\xee\xf2?\xe9\x14>\xf7\x1a\x80\xf5\xbf\xdc\r\xb9\x01\xf5Q\xde\xbf\xca\xfbs\x84\x0b\x19\xe4?\xbe\x8e\x173\x1aA\xf2?\xba\x924\xe8\xb29\x00@\x13\xe2O`g\xb3\xbc?\xdbL\xd8X\xe3\xea\xd1?\x1d\xb2\x9e\xa6O\x0b\xdd?\xad@\r\xb4\xbbS\xe4\xbf\x12\x05\xe3\x8e3W\xf4\xbf\x87v\x99\xbc\xf0\xbf\xe0\xbf\xe4\xa7\x91\xeeLD\xf5\xbf\xde!\x8aP\xa9\x8e\xe5\xbf\xd2\xa9-r\x1a\xad\xef\xbfA%_H\t\xf5\xcd?\x1f\xb8\xbc\x15\xd30\xc1?\x11~\xf0\xf6V\x86\x00@i`%\x1aMB\xc7?g\xfe;\x08\x166\xc3\xbf\xec)\t4\x1f@\xe2\xbfHcZ\xdb(\x06\xdc?!\x17\x8065\xcc\xd8?\x82\xcab6\xc8\xe9\xf8\xbf\x01\x9f\x0c\xc3\x10\xe8\xec\xbfNO\x92&nm\xf5?\x14\xa8m\xe7\xcf\x81\xf6?\xe4\x82\x81\xf2\x99~\xf1\xbf\x9f\x94\xc6YO\xf4\xcb?!\xd8\r\x88\xa1\x9a\xe9?M\x0f=\'\xe5\xdd\xcf\xbf' tbag2 (g3 (I0 @@ -35,7 +35,7 @@ tRp7 I16 tg6 I00 -S'V\x049\xb5]\xfd\xf2\xbf\xd2\x97\xe7>46\x07@\xa6\xde%\x84f\xe0\x16@\x83~\x9bG\x96i\x12@3\xff\x81\x16t\xae\xe4\xbfr\x02n\xf1\xea\xcb\xfd?8\xd4\xe3\xc1\xbe\xc4\x00@\x19\x8c\x94\xef43\x08@\xe5E\x8cxM\x10\x00@9p\xd1\xfa\x99\x00\x17\xc0Z\x9al}KA\xeb\xbf\xc1\x88RD\x15\x0b\x0f\xc0\xbe\x05f\xa6\n\x0c\x19\xc0@\x8c^\x80mz\x1b@\x05\xff\xdb\xc1\x01\x1e\x08\xc0\xd6\x8d\xf2\x13\x08\x19\xfc\xbf\xe5\xf3xq\x85G\xf0\xbf\xe5\x88\xed\xb5,\x99\xdf\xbf*Bc\nI\x0e\r\xc0iix%\xe2\x1d\xc0?)j\xfd\xac\xd2\x8f\xfd?\x9e\xea\xca\xc4?#\x1a@\x1f\xaeq\x9e\x03\xc2\x03@\xc8\xec\x89>(1\x17\xc0\xbe.\xeb-\xe0\x17\xe7?\xd4\x86\x7fU\x8f\xbc\xf1\xbfz]\xb5w\x99Q\x02\xc0\x96\x08s\x98(-\xaa?Zf9\xd4\xfe\xb3\x08\xc0\xc7\xc1X\xd7i\x86\xf3?\xc7\xc9\x14KBY\x01\xc0Hq\xe1\xc9\xcb\xd5\xec?\xd9d\xc5\x95g\xf4\xff\xbf8\x8eF(%\x89\x0e\xc0(r\xe4+\xc5\x9c\x08@\xbcV\x0e\x88\xfb\x89\x01@/M\x9c\xaaZ\x82\x17@\xfat\n\xf1\xb1!\x04@:\xa3\t\xcc\x14c\x15\xc0\x17S\xad$>/\x01\xc0\xef\xb6!\xf3\xd7\xc6\xd7\xbf\xd2,\x7f/R\x00\x10\xc04R\xeeSm\xaa\x04@\xdb(\xab\xbc\xb0\x19\x03@\xd2\xf6\x16e!K\x05@\x17)\xd3\xe9\xe9\x1f\xb9\xbf\xdf\x9aZ\x8c\xd2h\x00@~Og\x98\x8a\x80\x10@n\x8f\xd4\xf0UT\xed\xbf|\x9a?\xe0\xdc\xb4\x00\xc0N:&#\x92F\xe6\xbf\x8bv\xffp#(\x12\xc0\xfd/\xa3\xc6\xd5\x9e\xf8?\xb5\x9e\xc1\xb2\xf7\xc6\xf7?\xde\x90\x86\xa0\x91\x1e\xff?5\xdaH\x1asI\xea\xbf\xb0\x94\xba\xa6\xfe\xb7\xd3?\xd7M\xd4\xd9\xb1A\xf9?\xfa\xde\xc8\xf6\xd3\xc2\t\xc0A\xe6\xaf+"P\xef?N\x19y\xce$j\xe0?\xec\xc9&\x7fUI\x1d@\xab7\x1f\x03\x8c\x8b\xe0\xbfbI\xaa\x96\xbaT\x19\xc0\xfd\xdc\x97\xd2\x87\x14\x01\xc0\xf6\xf2\xb3\x08\x965!@\x83\x15#U\xa7\xae\x16\xc0\xf2\xa6.\xa4\x96\xe2\xe4\xbf\xb4T\xe8\x89I\xb2\xc2?0\x19o\xc2~\x7f\x00@9]p%\x8bI\x06@}?\xf3\x16\xc08\xe6\xbf\xe1\x1d\xab\x94\xa8\xe0\t\xc0\xcf\x9e\x81f\x14\xa5\x00\xc0Gb\xadW>f\x0b@\x1fg\xbd\xcc\xe1\x0c\x07\xc0IjC\\\xf0?\x82m+\x14\x87\xce\xf0\xbf-U\x18D\x94\x1e\x11\xc0B\xf7qu\xce\x9a\xfa\xbf%\x8f\xc8~d\x8e\xf3?\xf6!\xc2\xd4\x8bV\x05\xc02\x9a\x92\x1b\xf6<\xd0?\x90Hf\xece\xc6\n\xc0O\xabc\x1cpm\x17\xc0\x87\x87*\x15Y\xd9\x02\xc0\xac\xc9\xde\xb9\'Z\x12@\x15\xd5\x8d\xf4T\xd2\xd8?\xe9k\xaf\xe9dn\x12@a\xd8\\\xcd\xd3;\x01@\x10\xb7\xdc\xd1\xec\xec\xee?\xe2\xfc\xfc\xe1\xb1]\x15@\x03\x9ad\xcf\xc4w \xc0\x180\x96NN\n\xf4\xbf\xce\x08\xba0\xa5\xd1\x12\xc0&d\xe06g\xf2\xeb\xbf7s\x0b>\xfe\xc8\xf9\xbf`\xedj\x87\xbb\xf0\xb1?\x04&\x08c}J\x14\xc0\xa7\x98\xecz\xc1:\xe4?v\xd8\x9d\xb0.\'\x04\xc0j\x85bJ\xa9\x06\x1d\xc0j`\xa5Z\xaeE\xea?F\xa7a9|\xcf\x0b@-\x90\x17\x1a\xaf`\xe7\xbf\xd3\xe7\xd0\xd0?\x04\x07@i\xd9\x1dR\xb3@\x06@W\x1d\xe8C\xe6i\xd0?,+~\xc3\xb1h\x02@\xff\x83\x07\xe9\xa7w\x08\xc0cU\xaf\xb2n\xa7\xf4\xbf\xad^"\x0f\xc7o\xfc?\xf2=\x13\x15&\xa6\xf2?2\x1a\xca\x8f\x8fj\xf2\xbf\x8f\xb0s\x95\x14\xf3\x16\xc0\xd2w\n\x89\x9e8\xfc?.8O\xa7\xea\xfb\xc8?/\x1fGV\x03\xc7\x1a@\xc2.\xeb\x18\x12u\xdf?\xcb\xb28m@\x8b\xe1?\xb1\x87j\x01\x82~\xed?&\xf6i-\x91\x8e\xeb?/40]\x82$\xd4\xbf\x85\x98J\xb5\x8c\x84\x07@*\xe36U\x95\x94\x0f\xc0\xd2\x85\x16\x91o\xb6\x1a\xc0\x9e\xe5z\xd3vU\xe3?\x1d\xa8e\xc2\xb5{\xd7?x\r\xbej!\xa8\xe1\xbfNg4x\t\xcf\xa0?t^\xae\x046\xc9\xf8\xbfs`\xcf\xe3\xa8\x98\xf1\xbf\x1dn\xcfi\xb7\xfc\x0b@(\x95\x9a\x14l\xef\x0b@\x9d8\xcc/\xa1u\x14\xc0V\xeeV]g\x1b\xc8\xbf\xc8[\x983\xd9a\xb9\xbf\x94\x9e\xb25!\xaf\xee?K\x0c\xfd\xd7\xa7\xbc\xfd?\xc0\xcdV\x8f\xefW\xe1?\xad\x87M!\xd04\xf3?\xcd\xf8.\x98\xf5x\xe5\xbf\x03\xa4=p\x17\xae\xe6?\xdb\xb9\x11\x88\x93:\xe4?\xbf\xd4\xd1O\x8f\xce\xd8?gdY\xd77\x9a\x00@[\x9f0\x84p\xd3\xe2?6O\xb5k\x8c\xf9\xd4?\xfa\xf7\xdf>\x80\x1b\x08@\x87\xa6z\xaa\x84\x14\xef?\xab\xcaY\x1d\xe5\xf8\xcf\xbfYa\xbf+>\xc5\r@\xd3n\xdf\xe0zL\x1c\xc0`Z^\xa0cH\x05@y\x12r-\xcf\x14\x03@\xd5\xda\xaaN\x8d\x83\x07\xc0\xf7DEh\t\xee\n\xc0]\xda\xf5\x93xM\xd7\xbf8"``\xee\xb6\x03\xc08\xc3\xcc\x81l\xb3\xe5?!\x13\xa4L\x8e\x9d\x08@\xe7Ubr\x00\xf2\x03\xc0\r\x1f4\x93\x84\xfb\t\xc0\x97#\xf6\xcb\x8c}\xe8\xbfm\x00\xe0\xb7&\n\x02\xc0\xccb@\xda\x93\xf8\xf4?\xe5\x97\x1b\x8f\xdcC\xf2?\x95W\xb9&\xa2\xc5\x03@$K\x85D\xa9W\xf4?\x94\x15\x87\xb8H\xe6\xd1\xbf\x97n\xb9S#\xb6\xd6\xbf\xa5D\xd6\xbe?F\xe8?\x05\x0cj4\xa1\xc5\xff?\xac\xfb&\x89\x04\x9f\x01@\xc7 J\x87\x10\xe7\x19\xc0\xc4\xb1\'\x8d\x81\xfb\x0b@fZ\x81\xaco=\x07\xc0a\xb0j\xe5\xaf\xbe\x17\xc0@u\xdf\xb8\xf8\x07\xf9\xbf\x9e\x14\x19\x88d\xce\xdb\xbf\xb6\x07\x99\xe4\x84\xf5\x1b@\xe0\x93~\xa9\xc2\xeb\x12\xc0\x04^r\xf2#\xb2\xf0\xbf4\xf4[7\xb3_\xc7?\xb9\xf5\xb3\x9c\xe9l\x0e@{\xe2_\x9b\xbd\xfe\x0f\xc0\xcc\xd9\xb2Q@n\x13\xc0\xb29\xef\x00\x1c\xea\xf7?P\xb5\x83\xd4\x0bc\x19@9\x1b\xd8?\xe7,\x12\xc0V\xec\xc9zB5\n@LZ\x19UF\x88\xdd?z{\x0f\xe4r\xfc\x03@\x8b\xbd\xc0\x8d\xc4\x1e\x03\xc0\x9b\xf4X+\x9a\xcc\xaa\xbfx\'!\x1b\xbbe\xee?\xb19\x97\x96\xb55\xff?C\xe2\xe5\xe4A\xdd\x1d@9\xb3\x9d\xafxD\xfa?{\xefIW\xc5*\r\xc0\xd2.\xfaW\x83\xe9\xf9\xbf\x80Y\x13\x8d9*\x07@:k(\xfd\xd3L\x04\xc0\x02c\xa9\xe2\xd4\x87"\xc0n\xa7\xec\x01_\xa0\xf8?:\xda|S\xf6\'\xe1?\x03\xd0\xd7\xbc\xc8\x06\xfd?>\xb66\x99\x99\xe4\xfe?\xba\xe3UV\x8c\xd3\xfb\xbf\x1e\x14\xec\x913?\xb3?kx8\xa7\x91\x8c\x07@V2\xfd]\x97\x0c\xc9?1_K%\xe4H\xe1\xbf\xeex\xb1[\xc1w\x01@\xe8\x07\xad7\xfaP\x11@:\xa10YcM\x04@\xbby(\x1e$\xdb\x04\xc0\xf1>\xc3,\xab\x85\x13\xc0\xa5\xc1\xb1\xb1|^\t\xc0d\xa8h\xbe=\xc7\x01\xc0\xc7#\xc1FL\x0f\xe6\xbf\xb6\xb2q\x03\xff\x93\x17@\x13Q6\x1bS"\x17@\x97\xe5\xcb\x06\x91\x86\x07\xc0rN*\xf8\xfa\xa1\xc8\xbf\x83\xe7\xf8@\xde\x8a\xfd?\xdfA\xfd\x8d\x94\x1a\xf0\xbf\xe6\x10d\x93b\\\x12\xc0\xc8\x15\xdf\x0e\x82\x0b\xc5?\xfe\xb3Yt\'?\x0c\xc0A\x9b\xcb\rt\xa5\xf2\xbf' +S'\xe5,\xa3Eb@\xe9\xbfR\x9a&\xf8\xf4,\xef\xbf\xbb\xe8zyy\xfa\xd6?\x7f(|\x1e\x01\x9b\xfa?R9\xbc\xb7;\xa4\xd3??\xed\xd9\xc9>\x0c\xf1\xbf\x0bpk"\x9ek\x1d@\xfcR\x0f\xb2u\xb3\x00\xc0\x85\xdb\xef"9\xd5\x16@\xed_\xbc\x89\xe4L\xf8\xbf 4\xeb\xa7}\xfd\xf2?\xf8\t\xfa\xa2\xd1\xe1\x1b@\xf5\x90\x9b\x08\x1f\x11\xf5\xbf]`=\xc7V\x90\x05\xc0\x9ba\xe4\xea\xbb\xa4#\xc0\x046\x1b\xcc\xaa\x13\x0c\xc0H\x01\x84\xb9\xe0+\xed\xbf\x1a,>\xded<\xf4\xbf\xd3\x83T\xb1Hq\xfc\xbf\xe1\x81\xdc\x99\xc8\x80\x0f@\x94@.\xb5Zr\t\xc0\x8b\x8a\x8f\xb2\xe9\xf8\xe2\xbf$\x03"5,\xce\x12\xc0Wf\x19\\r\x06\xf1?iV\x9c`\xa9\xf2\xfa?\xda\xf26\xe6\x9c\x01\xdd?\'`\x03\xae\t\xe4\xdf\xbfr!\xd3\xe4\xe3b\x0f@\xec\x8d\x8b~\x80\xcf\xfd?\x08\x11I\xe7U\x0e \xc0:<\x05\xc3\xb6$\xba?,\x84\xaa\xec\xdc7\x15\xc0\x85\xa55\xf2C6\xf1\xbf\xecbM&\xae\xd1\xf9\xbf\x82\xbb\xda}\xf7\x91\xf5?D\xc2\x12\xdc/\xbf\x03@\xf2`\x90%\x86b\x1b\xc0\xf9}\x8d\xa9\x9f\x9f\x13\xc0\x0c\x1e\xd10e\xf1\x02\xc0\xc3P\x8ff0c\n\xc0\x8cO\x03\x05\x14\x1d\n\xc0\x18@Q\x0c\xde\x8d\xec\xbf\xd7]w}\x97\xe7\x15\xc0<\xf5\x048\xc9&\x04@+\x1b\xb3\xeb\x87\xc9\xe2\xbf\x07JI\x16%0\x0e@\t\x15\x01f\x15$\xb5\xbf\x7f\xc5\xd3\xb8Y\xc4\x07@\x1e\xe8\xf6\xa7+\x03\xfc?\n\x8f\x1e$\r\x19\xed\xbf\xae\xbe\x93>p\xa2\xc3\xbf\x0bd\xd2\xdc9\x7f\x06@\xcb\x8f&\xd8\xb1\xbe\xf2\xbfs,\xf68\xc1\xf5\x05\xc0\xf0\x12\xda\xd0\x97\x83\x11@9\xe1\x83\xf87k\x1b\xc0\xf1,\xaf\xea\xe6-\x03\xc0\x84u~,6\x0c#@q\xc1B\xee\xb86\x01@[\xec\xf3\x18\xb68\xf7\xbf\xb0<\xd2\x0e\xbaR\xdd?%\xa8m\x83y\x81\x15@\xae-\x0f\xad\xc1\x85\x0b\xc0\x90l\x9a\x0ba\xfd\x18\xc0\x17H\x1d4\xd3-\x1f@q\x02P\x1c\x9c\x95\xf0?GU\xc4\xb9I\xa2\x03\xc0+\xd2\x01\r\x11\x97\xc6\xbf\xd3Q\xd1Szg\x00@s\x97fE\x892\x19\xc0(S`\xdb\xe6\x16\xbf?\x86\x95N6\xcd\xe2\xda\xbf\xd8\r\x91\\\r\xfc\x12@\x97\xc3\xb1\xef\xc3|\x02\xc0\xb5\x1e\x8d\xbf>d\xfc?\xa8\xfc\xc0y\xdd\x9c\xd5?\xd4\xc9lO\t"\xf1?PL\xa1\xc8Q\xdf\xf9?3\x85,\xa529\x05\xc0\xfdE\xd9\xfcL\x94\xf1\xbf>\xc3\x1e\xdb1\xcb\xe6?\x98\xa7c\xd0\x19\xad\x00\xc0$\xc1\xfc`i\x9b\xe5\xbf\xcd\xb1\xcb\x03\xab\x9c\xf1\xbf\x1a{\xc4\xe3"q\xf8?\xf5B\xa7Ix\xf0\x11@\xdd\x84K\xb6U\xe4\xf1\xbf\x01n\x01\x82\x00\x8d\x01\xc0\xe3G\x82@\x8e\x9d\xc3\xbf_M\xed~\x92\t\x0e\xc0\x02#\x18\xfc\xe55\xfa\xbf\xe2\x90ED1\x81\x0c@\x1e\x80d\xd8\xf7y\t\xc0\xe6\xd9M\xf4\xd9q\x01\xc0\xa6p\x19" \xf1\x13@\x95\xf4\xc6\x1b\xfa%\x04@F\xb4\xac#\xd7i\xf8?\x9bZ\x1d\x1b\'\xa2\x11@\x7fS\xcd\xd6\xdf\x9c\x13\xc0\xbf\xbd\x98\xb4\xaa\xcf\xd8\xbf\r`P\xc5\x97\xa7\xf0\xbf\x95\x9caM\x03\x1e\xf1?: \xa0\x0fYF\xfc?\x124\x16b\xfa\xd7\xf7?\x8be\x88\x1f\x87\xc2\xf7\xbf#-\x0fh\tq\xae\xbfgn]\xf4{^\xf5\xbf#\x92\xc9^\xa4\xa4\x1b\xc0\x95=\xb0\x8bl\x02\x1d\xc0&\xf4\xccL\xcd\x90\x07@\t\xc5\xffq\x85E\x11@_\xf8\xae3\xb2\x19\xfb\xbf+\xc9wx\x92#\xdb\xbf\xd4\xf0\xe0\x07\xa2N\xfe\xbfI/\x9b\xfb|\x9a\xe9?\xb6%\tp\xa5.\xc2\xbfU\x03y\'q\xac\x00\xc0\x979\x0fur\xab\x10\xc0\xbav{\x8b^R\x10\xc0oi\x16\xff\x9eS\xea?)\x93\x96\x1b\xfc\xd4\x05@\x17mK\xaf\x00Y#@T~\xe6O\xde\x9c\x10\xc0\xb1\xaa\xf0p\xab\xb6\x17@\x85\xe2\x1d\xf2\x00\x99\xd5\xbf\x809\xe9g\xdd\x88\x12@X39(:\xa1\x97?\xef>2}\xc1\xa3\x10\xc0Y\x9d\xee\xe1j\x04\xdb?Ma\xdf\xd3\xa2"\x15@\xabn\xc5gp?\x1a@\xee\x17\x9e:\x96\xef\xfc\xbf\xc4\xe8\xcf yR\x1a\xc0;3\xeb&\xc4\x8e\x14\xc08\x9c\x15\xa6%r\xd6\xbf\xdc\xf7\xf77;\xb4\xc1?\xde\xa2\xfd\xa7\x8f\x0b\xd5?\xa3\x9b\xe4\xa03\x1f\x04@\xbb\x89\xa1\xa6\xf9\xdb\x11\xc08>a\xc4\x85\xae\xff?\x9b\x08\x06\xb3\xcd\xc5\x08\xc0cw\xff\x16v\xd1\xea?\x90\x9ck\r:/\x01\xc0}[\xd67X\xf5\x13@\x14=\xcd\x86\x08\xb8\xc3?\x81\xa8\x90h\xabl\x14\xc0\xd7\xb2\xb8\xc9\x18\x7f%@U\xda*\x8d\x8f\x1b\x10\xc0\x93\xb3J\x99\xb8G\xe0\xbfq\xa1\xc5L9\x02\x0c\xc0\xe0\x96\x00\xaei\xbc\x94?xx\x7f\xd9\xcd\xa2\x18\xc0\x83Gq\xac\xec(\x06\xc0\xf6\xef\xc8:{\xa8\xaf\xbf\x7f\x13G\xe2\xae\x99\x03@\x85\xf8,\xdeo\x9b\t\xc0\x11\xe1\xd4\x06\x03d\xf4?8y\x9ez9\xb3\x0c\xc0H\xee\x9a7\x18\x19\xf5\xbf2\xf57\xd8\x1b\x9f\xf8?\xa57\xfeoY\xbc\x16@\xbe"m\xf0$\x0c\xf5\xbf\xe9=\x94G3e\xfd?I\x805#\x10Z\xe9\xbf\xe0\x8b\x8c\xe8.\x03\xb4\xbfu\x94\xc6\xbcL*\xf0?k\x82Y\xf6\xaa\x93\x03@\x8aN6D\xdf\x8b\xb5\xbf&\t\x07Jm`\xdd\xbfY\x14\x964\xd7\x0c\x1c\xc0\xd1B\x88\x8a\xf5\x8a\xbd\xbf\x1a\x7f\x94\x03\xcd\x0e\xf2?\xd6\xb5\xc4\xc0X\xea\xfc?\xad\xc1g\x9b\xa72\x14@4\x94\xce2\xb2+\xfc?\x8a\x8b\x9a\x8a\xfa\xcb\x15\xc0\x95\x81\xe7K"\x1f\xed\xbf\x15\xbf\n\xd8\xc2\xd9\x13\xc0\xfb\xae\r\x85\x81m\r@\xfc\xda\x84\x82\xefI"\xc0\xdc\xf2`O\xa2\xa2\xf9\xbf\xdfo\x1f\xf3\xeb\x19\x01@Yi\xfc?/x\x00@y\xddc\x1ao\x92\xcd\xbfTn\xc8W3\x8e\x11@Yi\xb9\x9c\xd2m\xfd?k\xeeLm\xf5\x95\xdb\xbf\x13P\xb4v\x1c\x10\xe2?\xe0\x01;Z~\xcb\x16@\xfc\xf1\xbd\x97\x84\xfb\x00@\x86Y\xfe\x0e\xc1-\xfd?\xfc\xd6\xb5\xf9\xfcZ\r\xc07\\\x1ai\xc5A\x15\xc04\x91j\xa2\tZ\xfd?\x90D\x7f\xbb{\x1e\xfa\xbf\n\xd8\xfe\xa3\xcd \xf1?uF\xc6@\xbb\xeb\x0c@\xccrI\x90\xa7\x19\x0f@yq\x89\xcb\x93*\x0e@g\x8f\xb7\xe9\x16\n\xf1\xbf\xdd\x19N\x1b)W\xf4\xbf\xe8P\xe5\xdcK\xd6\xe5\xbf/8\xa4\xf3\xd30\xdc\xbf\xe2P>\x1e\xebs#\xc0\xc3\x84}\x01\xbf\xea\xe5?\xec\xbbm\xb3j}\xe8?\x18\xc1\xc4ZM\x83\x11@\tg\xfc\x15\xd1)\x14\xc0\x85^\xd6\xea\x97U\xbb\xbf\x90U&\x9a1x\xd3\xbf\xbb\x82c+\xf2y\xf9\xbf\x8f\xa8\xda\x9e9x\x03@\x00F8\x03\xb1\xd1\xcb\xbfc\xc6\xc4\xd8\x83@\xfa?\x94gKb\xb0f\xfc?\x84\xef\xd6\xeb\xc8\x14\xe8\xbfy\xf9rz\x1a\xf1\xf5?\xe55\xd7\x9f\xe8\xbc\xf1\xbf\x93\xb7\xafx\x86p\xfc?"\xe7\x7fp\xbe\xb0\xff?\x85\xbb@\x9dq\x99\xd8\xbfQ\xf4\x13\xa6\x9aw\xda?\x05>\x0c\xa0d\x06\xf5?\xb6\x19\xf8t\xf0\xa8\xb7?\xbf[,\x8a\x98\xc0\xdf?2G\x16\x84\xbb\x02\x18@\xa5H>\x87\xdf\x19\xe7?\x82\xc7\x18\x99\x1eo\xfb?\xe6[3_\'4\xf1?\x94<\x04N\xed\x1e\xf9\xbf\xddfp*\x8f\xea\x05\xc0K\x9e7\xce2K\xb7?P\xf0b\xd9\x94R\xc9?<\xbfk\x94\xd3\xd3\x13@\xe4\x17\x8f\xcb!C\xff?\xc3\x80\x0e\xfe6\xcb\x0b\xc0W\xcb\xfec\xe7\xc6\xe5?L\xa3#V\xf3$\xda\xbf\x81\xe0("mp\xc2\xbf\xed\xdf\xaa\xaci\xb1\xf2?\x19\x97\xba\xaa\x1e\xaf\xe1\xbfe\x8c\x9a!4s\xd4\xbf\xf1\x17\xc5\x14\xdc\xd9\x11\xc0\xb2\xe1\x90\x08\x11"\x04\xc0\x9d\x04\x83\xe4SQ\xff?\xc2\xc9\x91\xf2Y\xaa\xe2\xbfd\xbd\x8c \xd6i\xc2\xbf#\xac\x8a\x7f\xb0\x17\x01\xc04\xae\x11\xbd_\x0f\x1e\xc0)\xd3iHY\xfc\xd4\xbf\'o\xdf\x07\xe2\x16\x01\xc0\xcf\xd8/l\x13\x97\xff?\x98\x16\\\x19i\xfd\x0f@\x99kOE\x14\xe8\x19@\xaf\x80OV\x93\xee\xe1\xbf\xe1l\xfa\xeaX\xdc\x1e\xc0' tbag2 (g3 (I0 @@ -46,7 +46,7 @@ tRp8 I16 tg6 I00 -S'k5\xf2W\xb2\x07\xd7\xbf#\x94P1E2\xfa?\xfe.\xd9\x8a>\xd6\x0c\xc0\xa3\x13\xab\xde{t\t\xc0\t\xf1\x14Wf\xd4\xff?\x81a!\x97\x02Z\x01@NNa\xd77Y\xce\xbf$\x8b\xdd\r\xe1\x06\x11@@\xf5\x1d-\xfb\xde\x01@sjW\x02]\xb5\x04\xc0\xb4\xc5\x81\x97L\x82\x17\xc0\xe2\x7f\no\xf7z\x07@$\x99\xd39RM\x10@x\x19\x89y\xa1%\xf6?\x8e\x8e\xe30tx\x0b\xc0\xe7\x04*\\zW\xf1?\xc8\xca\x86\x98 \xce\x14@bC\xe9!\xb1\xc6\x04\xc0\xde\xf0\xd8\xef\x7f\x80\xd7?\x88\xe3\xc7\xff\x0bn\x03\xc0\x1eT\xeb\xf2\xce\t\xd0\xbfE\xdf\x7fK\xd1\x19\x05\xc0X\x1f\xe2\xa4\xacy\n\xc0@Cx\xf0\x82&\x11\xc0\x14\xe4O\xca\xe2\x14\x01@M\xcf\xa4T\x85\xf3\x0c@z\xc0\xfa\xc0\'\xb1\x0b\xc0&)\xebp\xe3Q\x15\xc0\xa2\xda\xc5\rz]\x10\xc0\x95\x0bF\xe7\n\xe0\x0f@X\x8b\xb3tT\\\xf6?)\x00\x12:M\x93\t\xc0\x84\xb1\xc8Vq\t\xef?(b\x08\xd8\xd0\x90\xe3?4\xcd\xe1\xa6=\xcf\xc8\xbf\x1f\x93J\x07\xb2\xbc\x05@\xf2\x037\x13\xd3\xf4\xef\xbfG8\xef\x8eN\xe4\x07\xc0c\x04c*\x05\xbd\x11\xc0\x854\xcf\xaa\xcf\xa4\x11@\'i\xfb\xbfy\x81\xf9?+>1\r_2\xfc?\x8dS\x0e\xa8P\xc1\x05\xc0\x95\xbdgM\x86\xac\x12\xc0\xef;\x18\xbf\xfa=\x05@\x9d~\xd3\xf8!}\xf4\xbfnzR"\xdfm\x13\xc0\xd8\x1b\x9c\xf0\xee\xb9\xfd\xbf\xfe\xe3\x07\xef\xda\xb2\xf2\xbf \xefT{\x81\xfd\x00@\x8d\xdaG\x8c@\xce\xcc?\xc9\xa4\x99\x89\x1d\x84\x07@0\xf7,\xbcnA\xf5?\x98\x0fdh\x9d\x8a\x19\xc0\xf4sBf\xfa7\x01\xc0\xb4\xc1\xa9\x1aP\x89\x01\xc0\x10@\xc8\xe1-\xcb\x01\xc0\xb0\xfe\xb1G\xfd\xb3\x10\xc0\xa0\xa2>Wv\x9f\x14\xc0.Cs\xf4\xe4a\x07\xc0{F\xcac\xa7\xb4\x10@\xf0\xf4\x134\xde\x94\xec?\xebA\xf2&m\x8d\x16@*\xc5)iG\xac\xd2\xbf\xa87P\xe1\xd9f\x14\xc0\xd3\x85S@\x179\xdd\xbfd\xf3T\n>y\x15@\xe3\xf4\x15R\xcd\xd0\x00\xc0\xee>k\xee\x81\x91\x0c\xc0\x83d\xa37!\x12\xe7?\x7f\x10x\xa0\x9e\xd9\x04\xc0\x86\xf5\xec\xa6\xef\xe7\xef\xbfK\x93;$\x1f\r\x08@\x00\x17\xa18\x17\xbe\xfe\xbf\xb5\x13\xb3\xc4\x1a\xc3\xf2\xbf\xd0m\xdf\x94Iq\xff?\xa7\xbfI\xd6Y\r\xf0\xbf\xee\x83q\xfd*\xdf\x0b\xc0\xab\x8d\x89\xdc\x814\xe8\xbfL\xa3\xdf\xc2 C\x10\xc00k;\xddJF\xfc\xbf\xee\xe1vuN\x15\xfc?\xe7[W\x90\xff1\xc6\xbf+\x089\xb0+\x8b\xd4\xbf\xcc\xbe\x8e\xdc7\xd6\x08@\xd4\xefc\x9e\x0f\xbb\x12@\r\xf2\xf5\x854\x8c\x04\xc0d$f\xc0\x19q\x13\xc0\x9d:&\x10*F\r\xc0%\xc4-b}\xb2\x11\xc0:\xbd\xedd\x15\xf5\xff\xbf\xf8N\xb0\xd5?\xec\x14\xc0y\xcb\x97\xd8\xed\xa5\x10\xc0\x075\xcds,|\xf2?\x8bS\xf2\x15\xacP\x02\xc0\x12s\xb1\x07\x97\xc9\t@\xba\x17\x18\x04\x05Y\n\xc0\x17\x82\x99\xd0\x81\xa0\x15\xc0\x7f\xc8\xb7\xf6\xa7\xca\xec?\x0c\xd55\xb1\x9b\xc2\x02\xc0q@\xd49\\8\xdb\xbf\xf5\r\x03$C\xdb\x07@\x90\xa6\xf0\xe8\xae\x98\x13@\xba3Y_\x9d_\x06@\x93\x836P\xa4v\t\xc0\x11\xa6\x1c\xf2\t\xf8\xe9?%K\x14\xd5\x8c\xd6\n\xc0\xad2\xef?\x90\xb4\x07\xc0|\xa3\xb0@\x04\xcd\xef\xbf\xa0\r\xbaH\xae\x96\r@;\xb0\x1a\xe2\x1f\xe6\xfc\xbf:\x92@\xd63\xea\x16\xc0\xe5\xbdTL\x98\r\xf2\xbf\x7f\xb6\t\xce\xbb\xd0\x01\xc0o\x88\x07\xa1\xa2\xf2\x11\xc0\xd5\x84\x196\xc1\xd1\x15@D\x90\xc0\x16~\xde\x16\xc0?=\\d\n\xaa\xdf\xbf4\xc1\x03I\xe1%\xe9?\x81\xd0\x1d\xe3*\xc1\x14\xc0L\xac{\xabi\x1e\xf6\xbf[K\x07\xd9\x88M\x08@\x93O\x9e=pb\xf6\xbf\xba\x95\xbc5\x81`\xff?\xf5\x8c]SD\t\xe6?\x0f\x1d\xa4\x88M\x85\x12\xc0]\x84g^\xb1~\xd0\xbf\x11D\xd2\x16\x04\xc2\x02@\x9b9M\x05\x92\x10\xad?%g\x84n\xb0\xcc\xfb\xbfD\xd8\xe6\x18)\x08\xe0\xbf\xe4lN\xca\x07\x95\x07\xc0\x94|\x0f\x89G\xb6\x14@\x9b\x1c\x0f(r\xf7\x0b\xc0l\xb4\x86l\xe4\x1b\xb6\xbf\x80\x0fg\x91\xd7\x1a\n@\x9d{CJA\x99\xd2\xbf>\xbe[\x1b\x006\xed\xbf\x17$\xe8\x90\xce2\x08\xc0\'\xd7\xc8\x8c\xbd\xc5\x01\xc0\xb3K\x08]\xf0\xfd\x08\xc0\xc4?\x04\xcb\xa3\xf0\x10\xc0a\xe1\xf2W\xa4\x8f\x06@\xaa\x10\x85\'\xc0\xba\xb3?\xa7\x98\x87\xa4m\x05\x11@\xb26\xa6z\x0b\xc4\x05@s\xc9\xbf\xdc\xd0\x07\x12@\xb3\xadmM%\n\x1a\xc0C\x1e[\xec\xbd\xde\x15\xc0\xee\x06\xb2%\xf6Z\xe6\xbf\xcb\x02\x86\xf4\xa7\x89\x0f@U\x96\xacl\xba\xad\xf7\xbfi\xf1\xb1\xa4\xa0\x9b\x02\xc0t\xd7p5\x19G\xf7\xbf\xae\xc6v\x08eC\x05\xc0\\\xe7M\xaa\xd2\xb7\xf4?\x8e\x8e\xc2\xc2\x02r\xe7\xbfT?\x18\xb4\xe9O\x11\xc0\x10\x15\xc4\xda\xb4[\xfa\xbf\x89\xc4\x1br(\xb9\x01@' +S'\xb8\xaf\xe9\xd8\x1f\xc9\x10\xc0\x11L\x94S\x03\xcd\x0f\xc04\xb4\xe9\xa0\x06\xce\x01@\xa5E\xf4@\xe1\xfe\x13\xc0\xbd\x8b\x86I\x8f\x18\x05\xc0Dh\xd2\xf2\xd9o\xf5?#\xacv\xd6\xc3J\x01\xc0\xfca\xcf.I\x93\x07\xc07A\x1b}t\xfc\xfb?}\xc4$\xff\x1b\xac\xfe?\xf2\xdf\x90\x184\x8b\x07@I\xd0;\xdb\xd4\xca\xd1\xbf\xd4HK\xec\xb5\xf2\xf7\xbf\xfb\xb0~V\xdc\xdc\xeb\xbf\\\xac\x0e\x9a\xab\xb5\x12\xc0\x1ehK\xba\xae\xe8\xfa\xbf\x0f)3%\xfb~\x15@H\xfb\x0b{\xfc)\xd2\xbf\xd5\x10\x85\xdd\xbe\x9f\x04\xc0\t\xda\xb4\xee \x94\x02@\x8dC(\x19\xba*\xfc?\xa3\xaf\xe4\x1b"\xdd\x12\xc0WH0[\x95\x17\xdd\xbf\x13\xb7\x03\xebr\x15\x13\xc0O;\xa9@R\xd7\xfe?\xcb\n\xbf\xd0Sl\xd9?\xab(\x16\xb3\xc4\xff\x03\xc0\xdc\xa0\xf97\xfe|\x1c\xc0\xd2I\xd9\x19\x90\xe7\xe1?p\x07V\xef \xfa\xed\xbfK\r\xca\xab\xa7r\xf5\xbf+\xe2\x14\x0c\n\xa6\xf6\xbf\xb1N+0\xd61\xff\xbfQ\x1b\x97\xc0J\x0f\x05\xc0\xb5\xa9m[\x95,\n\xc0)\xab\xc9N4\x06\xfd\xbf!\xe5\xde\x9a\x08\xbb\x00\xc0\x85\xbe\x8e\xdaX\xe1\x0b@z\x87\xf3\x94\x0f\xca\x14@\xde\x82\x05\x85\x84b\xf4\xbf:D\xf0WD\xfe\xc5\xbfT\xe9\xa2\xfc\x93\x15\x03\xc0{H\xa8f\x8f\xa8\xf3\xbfQ\x10\x9d\x82\xecN\x08\xc0\xc8\xaf\x05$j\xe1\xef?z\x84\x1d\xaa\xb5d\xff\xbf\xab\x1b\xf0\xdd4\xb0\x02@\xaac|\xee{B\x02\xc0W\x9a\xf0\xab;\xc9\x04\xc0/\xa5\xaaFq\xa8\t\xc0y\xde\xdc\x82s\xbc\x0f\xc0\x96\xd4"\x1f%m\xf2?2\x86e\xcd~\xdd\xa2?\x81\xf7O\x0b#$\xfb?G\xad(\xfe\xaa\xe4\x11\xc0z\x9d*\x06JR\x00\xc0m\x0e\xc7H\n\xed\x07\xc0\x03)\x0fG\x99\x8a\t@\xefp\xfa\x9a\x17\xd6\x02\xc0\x1c\xcfR\t%,\x01@\x83Wa\xef\x0f\xb5\xfa?\x83\xc5\xe5\x12^4\x05\xc0\xd1\x1f\x81\x86}$\x01@\xe0d\xb2\xc7Q\xb7\r\xc0\xc0\xf0Onz\x8e\x10@\xdb\x8f\x1f\xf4\xbb%\t@\xb6KojU\x95\xfc\xbf\xfd\x8e$\r\xe6\x9f\xf7?o\xe5\xb4\xed\x08\xff\x11\xc0Y\xc5\xd7VZ|\xee?\x98#K\x94\x16\xbf\xf8\xbf\x18\xb2\xdf\xa9\x9bc\xf0?\t\x02\x1c\xb7\xb1\xaa\x04\xc0\xcb@0\x11qE\x02\xc0\xa9n\xcf\xbe\x88\x89\x08\xc0\xa4I\t\xd91\\\xec?J\xca\xe9s\x1e\xe7\xfa?%S*V\x0b.\xfa\xbf8F\xeeL\'\x1a\x14\xc0\x82\x10t\xa5\xe1\x90\x01\xc0-\xd9\xf9\x83\xa9\x8b\xd5?\xe6\x15\x8a\xf0\xc6\xff\t\xc0Y\xffk\xaa\xfa\xf1\x0e@\xb0\x0cw\xe4\xfe\xd8\x14@\xe0\x9c\x87\xf9\xdb\x12\x03\xc0\xa7\x15_t\xd3\x94\xfe\xbfi\xfd\xf1\xcb\xd1\x85\xe9?\xcc7\x17 \xf1\n\x13@\'\x02V(\xf5\xae\x05@A\x91\xcb#ax\t@s(\x94ZHe\xf9\xbf[T\xb1\x83\x11\xdd\xf7?\x1a\x9d\xb8L\xe0\x9f\xfa\xbf\xd5\xcb\xe8\xca\xa1\xdd\x16\xc0\x12\xbc\x8d\x9a\x85j\xf9?\x8c\xf8\xe0e*J\r\xc0Q_HA\xdc\xbc\x10\xc0F9\x97\x86\xfe`\x0b@\xef\xd7(\xd9}J\x0c@\xd6tc:$\x84\x13\xc0{\xb9-\x99\x8d\x95\xf9\xbf\x14O\x80\xa0\xad3\xfe\xbf\xb6sc\x0c\x97\xe1\x11\xc0\x8aEi\x7f\xa5%\xfe?\x9f\x0e-\xe9i\xec\xf3\xbf\x8e\x9a\xba\xc7oH\x10\xc0\x9e\r\xc6\x9f\xa8\xa8\x07\xc0\x8c\x17\x1aM}M\x07\xc0\xa8}\xe7\x1d\xb3\xc1\xeb\xbf\r\x1a:^\x1a=\xec?\xa3\x0e\x89\x9f\x9f:\xf6?XU\xaa\xc1\xa4\xb6\xea\xbf\xde\x02\x91\rD\xc9\x11\xc0\xb1\xa5\xe5\xee\x97\xfc\xdf?o-9\xc3c\xeb\xf7\xbf\xd3EAqdk\x06@>\xf4\xb9\xb0\x86\xae\xf1?\xa90\xdf\xd0{/\x05\xc0=6\xcd\x07\x93\x1b\xbd\xbf\xcd\xba9\xb7;p\xee?\xe0\x7f{\xf1\x8c\xd4\xd7?\xb4\xeb{\xef\xa3\xc8\x12\xc0\xb7\xa2\xae\xf25\xb5\x05@\xf7\xf3\nd\xa5\x93\xf5?s,9M\xee\xee\x07@\xe4\xffG}\xfc\xd8\xf2\xbf\x88hb\x91\x8c\xef\x01\xc0\x04\xe9\x89\x00\x86\t\x18@/\xfb\xa9\xe7\x93\xd9\x8c\xbf?\xd3\xc0L\xaa\xe5\x0b\xc0\x86\x12\xc2s\xa8z\x13\xc0\xd3\x13\xd5\xdd\xde\xd6\x13\xc0\x10p\xc2\x92\x1f\xe1\xf2?\xc7\xd4\x0b\x89\xe4,\xd1?\x8e\xec\'\x80e\xc0\x16\xc0iI \xa7\xea\x1a\xf1?\xbb\x00,\xa4\x94\x95\x02@\x1e\\\x15:\xc9T\x0b\xc0\x83\xaa\xc7>r\x11\xef\xbf*\x18\xdbqJ\xbe\x10@\xa6\x11\\\xccw\xaa\x04\xc0\x0c\x11\x95\xe1\x1f\x03\x08\xc0\xdf/\xddf!\xe9\x04@\xdf\xbbi{\xa1q\x03\xc0\xc6\x9e\xdbO\x8e.\x04@r\xd6\'Z\xbc-\xf2?\xfc\xbdB\xf0{\xf5\xf9\xbf\xe94\x83\xac\xeb\xa5\xfc?KZ\x0f\x1b\xb0\xad\x07@H\x0eB{\xbb\xff\xf6?\xb0\x9f0\xa5{g\xee?\xde!\x02\x97\xe4^\xfa?\xf5\x96U}\xaaX\x0f\xc0"\x0c\x91\x8fq\xa2\xaa?\x14\x8d\x00\xa7\xa2\xfc\x04@\x1d\xf3\xa2L\xc5\xb7\xd8?i\'\xc3e\x1cN\x10\xc0\xc8.7\xb3\x82\x13\x0e\xc0\x13\t\xee\x19\xb8\xc1\x04\xc0\x8av\x03{\xc4\x03\x13\xc0' tba(lp9 g2 (g3 @@ -58,7 +58,7 @@ tRp10 I1 tg6 I00 -S'\x1e\x92\xd1\xb8It\xe5?\xe3\x1a\xe1\x10\xc3\xce\x1b\xc0\xe9\x7f{#@\xe8\x06\xc0\x1d\xd3\x91\xa9\xcc\xe2\x00@\x9a\xbc\xae\xe0L-\xca?\x89\x03\xb7\x00t\xd2\x0b\xc0\xfcDeh\x0f\x14\x02@\x19\xab\xdf5V\x80\xf4\xbfJ\xd8\xd4\xad\xc3\x7f\x17\xc08fpL\xf0\x89\xf5\xbf:\xf8-\x83j?\x0f@C \xf20\rR!@i\x8c?b\xe8\xa6\x07@\xfdS6\xad\r\xd9\x08\xc0\x9f\xf3\xcd\xa3\xa86\x01\xc0\xe3\xef\xf2\xea\x1bl\x01@' +S'\x02[\xa3\x81f\xc7\x17\xc0/!\x9c\x0bAv\x14\xc0&l\x19vp\xed\xf7\xbf\xec|\xc6\xa0\xde\x81\x10@c"\x17=\x0e\x0e\x07@\xa3\xe8\xb2\xb7\xb0t\xf5?p\xfb\x08?\xe0S\x1d@P4\x9a\x94D\x94\x18\xc0P\x1c\xc4\x0bGB\x0e\xc0V\x7fG\xdf\x96\xdd#@\\B\xf4\xb2\x8d\x05\x03\xc0\x08\xe11JM\xf7\x05@\x9d\x98\xf1|\x1e\xcc\x00\xc0p\xd5gl\xd7\xcc\xfa?\xfbS\x1b\xbdvj\xdf?\x04\xa1\xe6yu\x83\x01\xc0' tbag2 (g3 (I0 @@ -69,7 +69,7 @@ tRp11 I1 tg6 I00 -S'N;\x99\x99\x1f\xb6\xfb\xbf\xef^\xbd\xf4\xefS\xdd?\x0b\xe5\xb4\x97\x0b\xc9\x02\xc0Pt\xf2f7~ @\xb0\x1a\x13\x87`\xca\xf1?\xd5\xae\xb9\xaa\xa6\xc4\xf5\xbf\xbf\x106\x08u}\xa5\xbf\x96%0\xd7\xf15\xf5?\xd0\xd8\x08\x96\xbd\xc3\x02\xc0\x93)/\xcc\xafJ\x19@ \xeb|\x1a\x8d\xe5\xf0?\x17S\xe7\xcc\x1c\x89\x08@\x00:Q3\xed\n\x02@\xbeR\xc5\xe2\x086\xfb?H\xa1,\x8b\xdf\xc3\x07\xc0\xdbI\xc8\xf4\xeb\xcb\x07@' +S"\x93 \xc6S\x152\n\xc0\x9f\xb1\x8ez\x19`\x03@\x1e\xdb\xdc\x1d\xe2\xbc%@\x8d\x8bTf\x98k\x03@\x04K\xe8b\x879\x01\xc0\x81\x88\xdea\xadI\xd5\xbf\x8f\x98\xee\xaa\xd8\xef\xf9\xbf\xab\xa6\xae\x08\xae\xf7\xf8\xbf\n\xc5'NqQ\xdf?yEk\xd7\xbf\xfe\xf3?<|\x14\x93\xfae\x08\xc0\xe8\xeb\x1f%\x96\xb8\x05\xc0\x11@\x8e\xf0|1\xf0\xbf0\xc0\xae\xd2\x87B\xf7?$\x9e\x17\xc8\xe8M\x04@\x0b\xd70\xf2&d\xe9\xbf" tbag2 (g3 (I0 @@ -80,6 +80,6 @@ tRp12 I1 tg6 I00 -S'D\xe1\xefO_\xce\x17\xc0\xbb\xc4H\x99OY\n\xc0\xa3\xbd\xd0s\x9b\xb9\x0c\xc0\xc1u\xf2k\xe7\xd0\x0e\xc0\x1elP\x9e#\xbe\xf9\xbfY\x8d\xd7\xa0sH\x00\xc0\xefj\xa3|\x88\x1e\x08\xc0w\xc4\x98x\x96;\xf1\xbf\\\x95\xbbJH\xda\x06\xc0o\xea\xb3\xe5H\xf5\x07\xc0' +S'\xe0\xef4 Date: Mon, 16 Oct 2017 19:21:07 -0700 Subject: [PATCH 04/43] Error message for finding image paths --- helpers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/helpers.py b/helpers.py index 3486906e..0a645928 100644 --- a/helpers.py +++ b/helpers.py @@ -422,7 +422,7 @@ def get_full_image_path(image_file_name): for path in possible_paths: if os.path.exists(path): return path - raise IOError("File not Found") + raise IOError("File %s not Found"%image_file_name) def drag_pixels(frames): curr = frames[0] From 15e5969eed6429562739d574c473e152ab1ad240 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 16 Oct 2017 19:21:42 -0700 Subject: [PATCH 05/43] setup_bases for scenes that subclass multiple other scenes --- scene/scene.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/scene/scene.py b/scene/scene.py index 8b78db06..46f7cdbd 100644 --- a/scene/scene.py +++ b/scene/scene.py @@ -61,6 +61,10 @@ class Scene(object): """ pass + def setup_bases(self): + for base in self.__class__.__bases__: + base.setup(self) + def construct(self): pass #To be implemented in subclasses From 4089a5a949ea65bd540f79bf346cf9a229fd159e Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 16 Oct 2017 19:22:25 -0700 Subject: [PATCH 06/43] Slightly cleaner treatment of pi creature automatically tracking animations --- topics/characters.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/topics/characters.py b/topics/characters.py index a7645787..432c30e5 100644 --- a/topics/characters.py +++ b/topics/characters.py @@ -526,18 +526,17 @@ class PiCreatureScene(Scene): lambda anim : pi_creature in anim.mobject.submobject_family(), animations ) - if anims_with_pi_creature: - for anim in anims_with_pi_creature: - if isinstance(anim, Transform): - index = anim.mobject.submobject_family().index(pi_creature) - target_family = anim.target_mobject.submobject_family() - target = target_family[index] - if isinstance(target, PiCreature): - target.look_at(point_of_interest) - continue - animations.append( - ApplyMethod(pi_creature.look_at, point_of_interest) - ) + for anim in anims_with_pi_creature: + if isinstance(anim, Transform): + index = anim.mobject.submobject_family().index(pi_creature) + target_family = anim.target_mobject.submobject_family() + target = target_family[index] + if isinstance(target, PiCreature): + target.look_at(point_of_interest) + if not anims_with_pi_creature: + animations.append( + ApplyMethod(pi_creature.look_at, point_of_interest) + ) return animations def blink(self): From 134aad76094891b2d4c5120d8db793cf0715c02a Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 16 Oct 2017 19:22:38 -0700 Subject: [PATCH 07/43] part2 video published --- nn/part2.py | 1115 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 1057 insertions(+), 58 deletions(-) diff --git a/nn/part2.py b/nn/part2.py index 3be268f4..e4825d69 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -116,6 +116,57 @@ class ShowLastVideo(TeacherStudentsScene): ) self.dither(5) +class ShowPlan(Scene): + def construct(self): + title = TextMobject("Plan").scale(1.5) + title.to_edge(UP) + h_line = Line(LEFT, RIGHT).scale(SPACE_WIDTH) + h_line.highlight(WHITE) + h_line.next_to(title, DOWN) + self.add(title, h_line) + + items = VGroup(*[ + TextMobject("$\\cdot$ %s"%s) + for s in [ + "Recap", + "Gradient descent", + "Analyze this network", + "Where to learn more", + "Research corner", + ] + ]) + items.arrange_submobjects(DOWN, buff = MED_LARGE_BUFF, aligned_edge = LEFT) + items.to_edge(LEFT, buff = LARGE_BUFF) + + rect = SurroundingRectangle(VGroup(*items[1:3])) + + self.add(items) + self.dither() + self.play(ShowCreation(rect)) + self.play(FadeOut(rect)) + for item in items[1:]: + to_fade = VGroup(*[i for i in items if i is not item]) + self.play( + to_fade.set_fill, None, 0.5, + item.set_fill, None, 1, + ) + self.dither() + +class BeginAndEndRecap(Scene): + def construct(self): + recap = TexMobject( + "\\langle", "\\text{Recap}", "\\rangle" + ) + new_langle = TexMobject("\\langle/") + new_langle.scale(2) + recap.scale(2) + new_langle.move_to(recap[0], RIGHT) + + self.add(recap) + self.dither(2) + self.play(Transform(recap[0], new_langle)) + self.dither(2) + class PreviewLearning(NetworkScene): CONFIG = { "layer_sizes" : DEFAULT_LAYER_SIZES, @@ -137,7 +188,7 @@ class PreviewLearning(NetworkScene): "eta" : 3.0, "positive_edge_color" : BLUE, "negative_edge_color" : RED, - "positive_change_color" : average_color(*2*[BLUE] + [YELLOW]), + "positive_change_color" : BLUE_C, "negative_change_color" : average_color(*2*[RED] + [YELLOW]), "default_activate_run_time" : 1.5, } @@ -297,6 +348,13 @@ class PreviewLearning(NetworkScene): rate_func = wiggle ) +class BackpropComingLaterWords(Scene): + def construct(self): + words = TextMobject("(Backpropagation be \\\\ the next video)") + words.scale_to_fit_width(2*SPACE_WIDTH-1) + words.to_edge(DOWN) + self.add(words) + class TrainingVsTestData(Scene): CONFIG = { "n_examples" : 10, @@ -392,6 +450,86 @@ class TrainingVsTestData(Scene): self.dither(1./30) training_examples = new_examples +class MNistDescription(Scene): + CONFIG = { + "n_grids" : 5, + "n_rows_per_grid" : 10, + "n_cols_per_grid" : 8, + "time_per_example" : 1./120, + } + def construct(self): + title = TextMobject("MNIST Database") + title.scale(1.5) + title.highlight(BLUE) + authors = TextMobject("LeCun, Cortes and Burges") + authors.next_to(title, DOWN) + link_words = TextMobject("(links in the description)") + link_words.next_to(authors, DOWN, MED_LARGE_BUFF) + arrows = VGroup(*[Vector(DOWN) for x in range(4)]) + arrows.arrange_submobjects(RIGHT, buff = LARGE_BUFF) + arrows.next_to(link_words, DOWN) + arrows.highlight(BLUE) + + word_group = VGroup(title, authors, link_words, arrows) + word_group.center() + + self.add(title, authors) + self.play( + Write(link_words, run_time = 2), + LaggedStart(GrowArrow, arrows), + ) + self.dither() + + training_data, validation_data, test_data = load_data_wrapper() + epc = self.n_rows_per_grid*self.n_cols_per_grid + training_data_groups = [ + training_data[i*epc:(i+1)*epc] + for i in range(self.n_grids) + ] + + for i, td_group in enumerate(training_data_groups): + print i + group = Group(*[ + self.get_digit_pair(v_in, v_out) + for v_in, v_out in td_group + ]) + group.arrange_submobjects_in_grid( + n_rows = self.n_rows_per_grid, + ) + group.scale_to_fit_height(2*SPACE_HEIGHT - 1) + if i == 0: + self.play( + LaggedStart(FadeIn, group), + FadeOut(word_group), + ) + else: + pairs = zip(last_group, group) + random.shuffle(pairs) + time = 0 + for t1, t2 in pairs: + time += self.time_per_example + self.remove(t1) + self.add(t2) + if time > self.frame_duration: + self.dither(self.frame_duration) + time = 0 + last_group = group + + + def get_digit_pair(self, v_in, v_out): + tup = Group(*TexMobject("(", "00", ",", "0", ")")) + tup.scale(2) + # image = PixelsFromVect(v_in) + # image.add(SurroundingRectangle(image, color = BLUE, buff = SMALL_BUFF)) + image = MNistMobject(v_in) + label = TexMobject(str(np.argmax(v_out))) + image.replace(tup[1]) + tup.submobjects[1] = image + label.replace(tup[3], dim_to_match = 1) + tup.submobjects[3] = label + + return tup + class NotSciFi(TeacherStudentsScene): def construct(self): students = self.students @@ -463,6 +601,15 @@ class FunctionMinmization(GraphScene): ]) self.dither(10) +class ChangingDecimalWithColor(ChangingDecimal): + def update_mobject(self, alpha): + ChangingDecimal.update_mobject(self, alpha) + num = self.number_update_func(alpha) + self.decimal_number.set_fill( + interpolate_color(BLACK, WHITE, 0.5+num*0.5), + opacity = 1 + ) + class IntroduceCostFunction(PreviewLearning): CONFIG = { "max_stroke_width" : 2, @@ -480,6 +627,7 @@ class IntroduceCostFunction(PreviewLearning): self.need_a_cost_function() self.fade_all_but_last_layer() self.break_down_cost_function() + self.show_small_cost_output() self.average_over_all_training_data() def isolate_one_neuron(self): @@ -817,6 +965,101 @@ class IntroduceCostFunction(PreviewLearning): self.decimal_groups = decimal_groups self.image_group = image_group self.cost_group = VGroup(cost_of, image_group) + self.brace = brace + + def show_small_cost_output(self): + decimals, desired_decimals = self.decimal_groups + neurons = self.network_mob.layers[-1].neurons + brace = self.brace + cost_group = self.cost_group + + neurons.save_state() + cost_group.save_state() + brace.save_state() + brace.generate_target() + + arrows = VGroup(*[ + Arrow(ORIGIN, LEFT).next_to(d, LEFT, MED_LARGE_BUFF) + for d in decimals + ]) + arrows.highlight(WHITE) + + def generate_term_update_func(decimal, desired_decimal): + return lambda a : (decimal.number - desired_decimal.number)**2 + + terms = VGroup() + term_updates = [] + for arrow, d1, d2 in zip(arrows, *self.decimal_groups): + term = DecimalNumber(0, num_decimal_points = 4) + term.scale_to_fit_height(d1.get_height()) + term.next_to(arrow, LEFT) + term.num_update_func = generate_term_update_func(d1, d2) + terms.add(term) + term_updates.append(ChangingDecimalWithColor( + term, term.num_update_func, + num_decimal_points = 4 + )) + brace.target.next_to(terms, LEFT) + + sum_term = DecimalNumber(0) + sum_term.next_to(brace.target, LEFT) + sum_term.highlight(RED) + def sum_update(alpha): + return sum([ + (d1.number - d2.number)**2 + for d1, d2 in zip(*self.decimal_groups) + ]) + term_updates.append(ChangingDecimal(sum_term, sum_update)) + for update in term_updates: + update.update_mobject(0) + + target_vect = 0.1*np.random.random(10) + target_vect[3] = 0.97 + + def generate_decimal_update_func(start, target): + return lambda a : interpolate(start, target, a) + + update_decimals = [ + ChangingDecimalWithColor( + decimal, + generate_decimal_update_func(decimal.number, t) + ) + for decimal, t in zip(decimals, target_vect) + ] + + self.play( + cost_group.scale, 0.5, + cost_group.to_corner, UP+LEFT, + MoveToTarget(brace), + LaggedStart(GrowArrow, arrows), + LaggedStart(FadeIn, terms), + FadeIn(sum_term), + Animation(decimals) + ) + self.play(*it.chain( + update_decimals, + term_updates, + [ + ApplyMethod(neuron.set_fill, None, t) + for neuron, t in zip(neurons, target_vect) + ] + )) + self.dither() + self.play(LaggedStart(Indicate, decimals, rate_func = there_and_back)) + self.dither() + for update in update_decimals: + update.rate_func = lambda a : smooth(1-a) + self.play(*it.chain( + update_decimals, + term_updates, + [neurons.restore] + ), run_time = 2) + self.dither() + self.play( + cost_group.restore, + brace.restore, + FadeOut(VGroup(terms, sum_term, arrows)), + ) def average_over_all_training_data(self): image_group = self.image_group @@ -905,6 +1148,87 @@ class IntroduceCostFunction(PreviewLearning): result.decimals = decimals return result +class YellAtNetwork(PiCreatureScene, PreviewLearning): + def setup(self): + PiCreatureScene.setup(self) + PreviewLearning.setup(self) + + def construct(self): + randy = self.randy + network_mob, eyes = self.get_network_and_eyes() + + three_vect = get_organized_images()[3][5] + self.activate_network(three_vect) + + image = PixelsFromVect(three_vect) + image.add(SurroundingRectangle(image, color = BLUE)) + arrow = Arrow(LEFT, RIGHT, color = WHITE) + + layer = network_mob.layers[-1] + layer.add(network_mob.output_labels) + layer_copy = layer.deepcopy() + for neuron in layer_copy.neurons: + neuron.set_fill(WHITE, opacity = 0) + layer_copy.neurons[3].set_fill(WHITE, 1) + layer_copy.scale(1.5) + desired = Group(image, arrow, layer_copy) + desired.arrange_submobjects(RIGHT) + desired.to_edge(UP) + + q_marks = TexMobject("???").highlight(RED) + q_marks.next_to(arrow, UP, SMALL_BUFF) + + self.play( + PiCreatureBubbleIntroduction( + randy, "Bad network!", + target_mode = "angry", + look_at_arg = eyes, + run_time = 1, + ), + eyes.look_at_anim(randy.eyes) + ) + self.play(eyes.change_mode_anim("sad")) + self.play(eyes.look_at_anim(3*DOWN + 3*RIGHT)) + self.play( + FadeIn(desired), + RemovePiCreatureBubble( + randy, target_mode = "sassy", + look_at_arg = desired + ), + eyes.look_at_anim(desired) + ) + self.play(eyes.blink_anim()) + rect = SurroundingRectangle( + VGroup(layer_copy.neurons[3], layer_copy[-1][3]), + ) + self.play(ShowCreation(rect)) + layer_copy.add(rect) + self.dither() + self.play( + layer.copy().replace, layer_copy, 1, + Write(q_marks, run_time = 1), + layer_copy.shift, 1.5*RIGHT, + randy.change, "angry", eyes, + ) + self.play(eyes.look_at_anim(3*RIGHT + 3*RIGHT)) + self.dither() + + #### + + def get_network_and_eyes(self): + randy = self.randy + network_mob = self.network_mob + network_mob.scale(0.5) + network_mob.next_to(randy, RIGHT, LARGE_BUFF) + self.color_network_edges() + eyes = Eyes(network_mob.edge_groups[1]) + return network_mob, eyes + + def create_pi_creature(self): + randy = self.randy = Randolph() + randy.shift(3*LEFT).to_edge(DOWN) + return randy + class ThisIsVeryComplicated(TeacherStudentsScene): def construct(self): self.teacher_says( @@ -1113,41 +1437,33 @@ class EmphasizeComplexityOfCostFunction(IntroduceCostFunction): result.in_vect = in_vect return result -class YellAtNetwork(PiCreatureScene, PreviewLearning): - def setup(self): - PiCreatureScene.setup(self) - PreviewLearning.setup(self) - +class NetworkGrowthMindset(YellAtNetwork): def construct(self): - randy = self.randy - - network_mob = self.network_mob - network_mob.scale(0.5) - network_mob.next_to(randy, RIGHT, LARGE_BUFF) - self.color_network_edges() - eyes = Eyes(network_mob.edge_groups[1]) + randy = self.pi_creature + network_mob, eyes = self.get_network_and_eyes() + eyes.look_at_anim(randy.eyes).update(1) + edge_update = ContinualEdgeUpdate( + network_mob, + colors = [BLUE, RED] + ) self.play( - PiCreatureBubbleIntroduction( - randy, "Horrible!", - target_mode = "angry", + PiCreatureSays( + randy, "Awful, just awful!", + target_mode = "angry", look_at_arg = eyes, run_time = 1, ), - eyes.look_at_anim(randy.eyes) + eyes.change_mode_anim("concerned_musician") ) - self.play(eyes.change_mode_anim("sad")) - self.play(eyes.look_at_anim(3*DOWN + 3*RIGHT)) self.dither() - self.play(eyes.blink_anim()) - self.dither() - - #### - - def create_pi_creature(self): - randy = self.randy = Randolph() - randy.shift(3*LEFT + DOWN) - return randy + self.add(edge_update) + self.pi_creature_says( + "But we can do better! \\\\ Growth mindset!", + target_mode = "hooray" + ) + self.play(eyes.change_mode_anim("happy")) + self.dither(3) class SingleVariableCostFunction(GraphScene): CONFIG = { @@ -1519,6 +1835,15 @@ class SingleVariableCostFunction(GraphScene): line.rotate(self.angle_of_tangent(x, graph) - line.get_angle()) line.move_to(self.input_to_graph_point(x, graph)) +class LocalVsGlobal(TeacherStudentsScene): + def construct(self): + self.teacher_says(""" + Local minimum = Doable \\\\ + Global minimum = Crazy hard + """) + self.change_student_modes(*["pondering"]*3) + self.dither(2) + class TwoVariableInputSpace(Scene): def construct(self): self.add_plane() @@ -1643,6 +1968,37 @@ class KhanAcademyMVCWrapper(PiCreatureScene): self.play(morty.change, "happy", screen) self.dither(5) +class KAGradientPreview(ExternallyAnimatedScene): + pass + +class GradientDescentAlgorithm(Scene): + def construct(self): + words = VGroup( + TextMobject("Compute", "$\\nabla C$"), + TextMobject("Small step in", "$-\\nabla C$", "direction"), + TextMobject("Repeat."), + ) + words.arrange_submobjects(DOWN, aligned_edge = LEFT) + words.scale_to_fit_width(2*SPACE_WIDTH - 1) + words.to_corner(DOWN+LEFT) + + for word in words[:2]: + word[1].highlight(RED) + + for word in words: + self.play(Write(word, run_time = 1)) + self.dither() + +class GradientDescentName(Scene): + def construct(self): + words = TextMobject("Gradient descent") + words.highlight(BLUE) + words.scale_to_fit_width(2*SPACE_WIDTH - 1) + words.to_edge(DOWN) + + self.play(Write(words, run_time = 2)) + self.dither() + class ShowFullCostFunctionGradient(PreviewLearning): def construct(self): self.organize_weights_as_column_vector() @@ -1756,6 +2112,12 @@ class ShowFullCostFunctionGradient(PreviewLearning): ) self.dither() +class DotsInsert(Scene): + def construct(self): + dots = TexMobject("\\vdots") + dots.scale_to_fit_height(2*SPACE_HEIGHT - 1) + self.add(dots) + class HowMinimizingCostMeansBetterTrainingPerformance(IntroduceCostFunction): def construct(self): IntroduceCostFunction.construct(self) @@ -2053,12 +2415,59 @@ class SomeConnectionsMatterMoreThanOthers(PreviewLearning): n2 = layers[-1].neurons[i2] return self.network_mob.get_edge(n1, n2) +class SpinningVectorWithLabel(Scene): + def construct(self): + plane = NumberPlane( + x_unit_size = 2, + y_unit_size = 2, + ) + plane.add_coordinates() + self.add(plane) + + vector = Vector(2*RIGHT) + label = get_decimal_vector([-1, -1], with_dots = False) + label.add_to_back(BackgroundRectangle(label)) + label.next_to(vector.get_end(), UP+RIGHT) + label.decimals.set_fill(opacity = 0) + decimals = label.decimals.copy() + decimals.set_fill(WHITE, 1) + + cd1 = ChangingDecimal( + decimals[0], + lambda a : np.cos(vector.get_angle()), + tracked_mobject = label.decimals[0], + ) + cd2 = ChangingDecimal( + decimals[1], + lambda a : np.sin(vector.get_angle()), + tracked_mobject = label.decimals[1], + ) + + self.play( + Rotate( + vector, + 0.999*np.pi, + in_place = False, + run_time = 8, + rate_func = there_and_back + ), + UpdateFromFunc( + label, + lambda m : m.next_to(vector.get_end(), UP+RIGHT) + ), + cd1, cd2, + ) + self.dither() + class TwoGradientInterpretationsIn2D(Scene): def construct(self): + self.force_skipping() + self.setup_plane() self.add_function_definitions() self.point_out_direction() self.point_out_relative_importance() + self.wiggle_in_neighborhood() def setup_plane(self): plane = NumberPlane() @@ -2080,10 +2489,6 @@ class TwoGradientInterpretationsIn2D(Scene): vect.next_to(grad, RIGHT, SMALL_BUFF) grad_group = VGroup(grad, vect) grad_group.next_to(ORIGIN, RIGHT).to_edge(UP, buff = MED_SMALL_BUFF) - # grad_group.next_to(func, DOWN) - # for mob in grad, func: - # mob.highlight_by_tex("C(", RED) - # mob.highlight_by_tex(")", RED) for mob in grad, vect, func: mob.add_background_rectangle() mob.background_rectangle.scale_in_place(1.1) @@ -2131,6 +2536,9 @@ class TwoGradientInterpretationsIn2D(Scene): self.remove(coords) self.grad.get_part_by_tex("1, 1").highlight(coords.get_color()) + self.steepest_words = words + self.dot = dot + def point_out_relative_importance(self): func = self.func grad_group = VGroup(self.grad, self.vect) @@ -2162,6 +2570,32 @@ class TwoGradientInterpretationsIn2D(Scene): ) self.dither(2) + def wiggle_in_neighborhood(self): + dot = self.dot + steepest_words = self.steepest_words + + neighborhood = Circle( + fill_color = BLUE, + fill_opacity = 0.25, + stroke_width = 0, + radius = 0.5, + ) + neighborhood.move_to(dot) + + self.revert_to_original_skipping_status() + self.play( + FadeOut(steepest_words), + GrowFromCenter(neighborhood) + ) + self.dither() + for vect in RIGHT, UP, 0.3*(3*RIGHT + UP): + self.play( + dot.shift, 0.5*vect, + rate_func = lambda t : wiggle(t, 4), + run_time = 3, + ) + self.dither() + class ParaboloidGraph(ExternallyAnimatedScene): pass @@ -2346,29 +2780,41 @@ class AskHowItDoes(TeacherStudentsScene): class TestPerformance(PreviewLearning): CONFIG = { - "n_examples" : 200, + "n_examples" : 300, "time_per_example" : 0.1, - "wrong_dither_time" : 0.5 + "wrong_dither_time" : 0.5, + "stroke_width_exp" : 2, + "decimal_kwargs" : { + "num_decimal_points" : 3, + } } def construct(self): + self.setup_network_mob() self.init_testing_data() self.add_title() self.add_fraction() self.run_through_examples() + def setup_network_mob(self): + self.network_mob.scale_to_fit_height(5) + self.network_mob.to_corner(DOWN+LEFT) + self.network_mob.to_edge(DOWN, buff = MED_SMALL_BUFF) + def init_testing_data(self): training_data, validation_data, test_data = load_data_wrapper() self.test_data = iter(test_data[:self.n_examples]) def add_title(self): title = TextMobject("Testing data") - title.to_corner(UP+LEFT) + title.to_edge(UP, buff = MED_SMALL_BUFF) + title.to_edge(LEFT, buff = LARGE_BUFF) self.add(title) + self.title = title def add_fraction(self): self.n_correct = 0 self.total = 0 - self.decimal = DecimalNumber(0) + self.decimal = DecimalNumber(0, **self.decimal_kwargs) word_frac = TexMobject( "{\\text{Number correct}", "\\over", "\\text{total}}", "=", @@ -2381,30 +2827,49 @@ class TestPerformance(PreviewLearning): self.equals, self.decimal ) fracs.arrange_submobjects(RIGHT) - fracs.to_edge(UP) + fracs.to_corner(UP+RIGHT, buff = LARGE_BUFF) self.add(fracs) def run_through_examples(self): + title = self.title rects = [ - SurroundingRectangle(VGroup(neuron, label)) + SurroundingRectangle( + VGroup(neuron, label), + buff = 0.5*SMALL_BUFF + ) for neuron, label in zip( self.network_mob.layers[-1].neurons, self.network_mob.output_labels ) ] - wrong = TextMobject("Wrong!") - wrong.highlight(RED) + rect_wrong = TextMobject("Wrong!") + rect_wrong.highlight(RED) + num_wrong = rect_wrong.copy() + arrow = Arrow(LEFT, RIGHT, color = WHITE) + guess_word = TextMobject("Guess") + self.add(arrow, guess_word) - for test_in, test_out in self.test_data: + from tqdm import tqdm as ProgressDisplay + for test_in, test_out in ProgressDisplay(list(self.test_data)): self.total += 1 - image = MNistMobject(test_in) - image.to_edge(LEFT) - image.shift(UP) - self.add(image) activations = self.activate_layers(test_in) choice = np.argmax(activations[-1]) + + image = MNistMobject(test_in) + image.scale_to_fit_height(1.5) + choice_mob = TexMobject(str(choice)) + choice_mob.scale(1.5) + group = VGroup(image, arrow, choice_mob) + group.arrange_submobjects(RIGHT) + group.shift( + self.title.get_bottom()+MED_SMALL_BUFF*DOWN -\ + image.get_top() + ) + self.add(image, choice_mob) + guess_word.next_to(arrow, UP, SMALL_BUFF) + rect = rects[choice] self.add(rect) @@ -2412,8 +2877,9 @@ class TestPerformance(PreviewLearning): if correct: self.n_correct += 1 else: - wrong.next_to(rect, RIGHT) - self.add(wrong) + rect_wrong.next_to(rect, RIGHT) + num_wrong.next_to(choice_mob, DOWN) + self.add(rect_wrong, num_wrong) new_frac = self.get_frac() new_frac.shift( self.frac[1].get_left() - \ @@ -2424,7 +2890,10 @@ class TestPerformance(PreviewLearning): self.frac = new_frac self.equals.next_to(new_frac, RIGHT) - new_decimal = DecimalNumber(float(self.n_correct)/self.total) + new_decimal = DecimalNumber( + float(self.n_correct)/self.total, + **self.decimal_kwargs + ) new_decimal.next_to(self.equals, RIGHT) self.remove(self.decimal) self.add(new_decimal) @@ -2434,9 +2903,9 @@ class TestPerformance(PreviewLearning): if not correct: self.dither(self.wrong_dither_time) - self.remove(rect, wrong, image) + self.remove(rect, rect_wrong, num_wrong, image, choice_mob) - self.add(rect, image) + self.add(rect, image, choice_mob) ### def add_network(self): @@ -2492,6 +2961,14 @@ class ReactToPerformance(TeacherStudentsScene): ) self.dither() +class NoticeWhereItMessesUp(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "Look where it \\\\ messes up", + run_time = 1 + ) + self.dither(2) + class WrongExamples(TestPerformance): CONFIG = { "time_per_example" : 0 @@ -2758,11 +3235,541 @@ class InputRandomData(TestPerformance): self.play(eyes.blink_anim()) self.dither() +class CannotDraw(PreviewLearning): + def construct(self): + network_mob = self.network_mob + self.color_network_edges() + network_mob.scale(0.5) + network_mob.to_corner(DOWN+RIGHT) + eyes = Eyes(network_mob.edge_groups[1]) + eyes.shift(SMALL_BUFF*UP) + self.add(eyes) + + bubble = SpeechBubble( + height = 3, width = 4, + direction = RIGHT + ) + bubble.pin_to(network_mob.edge_groups[0]) + bubble.write("Uh...I'm really \\\\ more of a multiple \\\\ choice guy") + + randy = Randolph() + randy.to_corner(DOWN+LEFT) + eyes.look_at_anim(randy.eyes).update(1) + + self.play(PiCreatureSays( + randy, "Draw a \\\\ 5 for me", + look_at_arg = eyes, + run_time = 1 + )) + self.play(eyes.change_mode_anim("concerned_musician")) + self.play( + ShowCreation(bubble), + Write(bubble.content), + eyes.look_at_anim(network_mob.get_corner(DOWN+RIGHT)) + ) + self.play(eyes.blink_anim()) + self.play(Blink(randy)) + self.dither() + class TODOShowCostFunctionDef(TODOStub): CONFIG = { "message" : "Insert cost function averaging portion" } +class TODOBreakUpNineByPatterns2(TODOBreakUpNineByPatterns): + pass + +class SomethingToImproveUpon(PiCreatureScene, TestPerformance): + CONFIG = { + "n_examples" : 15, + "time_per_example" : 0.15, + } + def setup(self): + self.setup_bases() + self.color_network_edges() + self.network_mob.to_edge(LEFT) + edge_update = ContinualEdgeUpdate( + self.network_mob, + colors = [BLUE, BLUE, RED] + ) + edge_update.internal_time = 1 + self.add(edge_update) + + def construct(self): + self.show_path() + self.old_news() + self.recognizing_digits() + self.hidden_layers() + + def show_path(self): + network_mob = self.network_mob + morty = self.pi_creature + + line = Line(LEFT, RIGHT).scale(5) + line.shift(UP) + dots = VGroup(*[ + Dot(line.point_from_proportion(a)) + for a in np.linspace(0, 1, 5) + ]) + dots.gradient_highlight(BLUE, YELLOW) + path = VGroup(line, dots) + words = TextMobject("This series") + words.next_to(line, DOWN) + + self.play( + network_mob.scale, 0.25, + network_mob.next_to, path.get_right(), UP, + ShowCreation(path), + Write(words, run_time = 1), + morty.change, "sassy", + ) + self.dither(2) + self.play( + ApplyMethod( + network_mob.next_to, path.get_left(), UP, + path_arc = np.pi/2, + ), + Rotate(path, np.pi, in_place = True), + morty.change, "raise_right_hand" + ) + self.dither(3) + + self.line = line + self.path = path + self.this_series = words + + def old_news(self): + network_mob = self.network_mob + morty = self.pi_creature + line = self.line + + words = TextMobject("Old technology!") + words.to_edge(UP) + arrow = Arrow(words.get_left(), network_mob.get_right()) + + name = TextMobject("``Multilayer perceptron''") + name.next_to(words, DOWN) + + cnn = TextMobject("Convolutional NN") + lstm = TextMobject("LSTM") + cnn.next_to(line.get_center(), UP) + lstm.next_to(line.get_right(), UP) + + modern_variants = VGroup(cnn, lstm) + modern_variants.highlight(YELLOW) + + self.play( + Write(words, run_time = 1), + GrowArrow(arrow), + morty.change_mode, "hesitant" + ) + self.play(Write(name)) + self.dither() + self.play( + FadeIn(modern_variants), + FadeOut(VGroup(words, arrow, name)), + morty.change, "thinking" + ) + self.dither(2) + + self.modern_variants = modern_variants + + def recognizing_digits(self): + training_data, validation_data, test_data = load_data_wrapper() + + for v_in, choice in validation_data[:self.n_examples]: + image = MNistMobject(v_in) + image.scale_to_fit_height(1) + choice = TexMobject(str(choice)) + choice.scale(2) + arrow = Vector(RIGHT, color = WHITE) + group = Group(image, arrow, choice) + group.arrange_submobjects(RIGHT) + group.next_to(self.line, DOWN, LARGE_BUFF) + group.to_edge(LEFT, buff = LARGE_BUFF) + + self.add(group) + self.dither(self.time_per_example) + self.remove(group) + + def hidden_layers(self): + morty = self.pi_creature + network_mob = self.network_mob + + self.play( + network_mob.scale, 4, + network_mob.center, + network_mob.to_edge, LEFT, + FadeOut(VGroup(self.path, self.modern_variants, self.this_series)), + morty.change, "confused", + ) + + hidden_layers = network_mob.layers[1:3] + rects = VGroup(*map(SurroundingRectangle, hidden_layers)) + np.random.seed(0) + + self.play(ShowCreation(rects)) + self.activate_network(np.random.random(28*28)) + self.dither(3) + +class ShiftingFocus(Scene): + def construct(self): + how, do, networks, learn = words = TextMobject( + "How", "do", "neural networks", "learn?" + ) + networks.highlight(BLUE) + cross = Cross(networks) + viewers = TextMobject("video viewers") + viewers.move_to(networks) + viewers.highlight(YELLOW) + cap_do = TextMobject("Do") + cap_do.move_to(do, DOWN+LEFT) + + self.play(Write(words, run_time = 1)) + self.dither() + self.play(ShowCreation(cross)) + self.play( + VGroup(networks, cross).shift, DOWN, + Write(viewers, run_time = 1) + ) + self.dither(2) + self.play( + FadeOut(how), + Transform(do, cap_do) + ) + self.dither(2) + +class PauseAndPonder(TeacherStudentsScene): + def construct(self): + screen = ScreenRectangle(height = 3.5) + screen.to_edge(UP+LEFT) + + self.teacher_says( + "Pause and \\\\ ponder!", + target_mode = "hooray", + run_time = 1 + ) + self.play( + ShowCreation(screen), + self.get_student_changes(*["pondering"]*3), + ) + self.dither(6) + +class ConvolutionalNetworkPreview(Scene): + def construct(self): + vect = get_organized_images()[9][0] + image = PixelsFromVect(vect) + image.set_stroke(width = 1) + image.scale_to_fit_height(2*SPACE_HEIGHT - 1) + self.add(image) + + kernels = [ + PixelsFromVect(np.zeros(16)) + for x in range(2) + ] + for i, pixel in enumerate(kernels[0]): + x = i%4 + y = i//4 + if x == y: + pixel.set_fill(BLUE, 1) + elif abs(x - y) == 1: + pixel.set_fill(BLUE, 0.5) + for i, pixel in enumerate(kernels[1]): + x = i%4 + if x == 1: + pixel.set_fill(BLUE, 1) + elif x == 2: + pixel.set_fill(RED, 1) + for kernel in kernels: + kernel.set_stroke(width = 1) + kernel.scale(image[0].get_height()/kernel[0].get_height()) + kernel.add(SurroundingRectangle( + kernel, color = YELLOW, buff = 0 + )) + self.add(kernel) + for i, pixel in enumerate(image): + x = i%28 + y = i//28 + if x > 24 or y > 24: + continue + kernel.move_to(pixel, UP+LEFT) + self.dither(self.frame_duration) + self.remove(kernel) + +class RandomlyLabeledImageData(Scene): + CONFIG = { + "image_label_pairs" : [ + ("lion", "Lion"), + ("Newton", "Genius"), + ("Fork", "Fork"), + ("Trilobite", "Trilobite"), + ("Puppy", "Puppy"), + ("Astrolabe", "Astrolabe"), + ("Adele", "Songbird of \\\\ our generation"), + ("Cow", "Cow"), + ("Sculling", "Sculling"), + ("Pierre_de_Fermat", "Tease"), + ] + } + def construct(self): + groups = Group() + labels = VGroup() + for i, (image_name, label_name) in enumerate(self.image_label_pairs): + x = i//5 + y = i%5 + group = self.get_training_group(image_name, label_name) + group.shift(4.5*LEFT + x*SPACE_WIDTH*RIGHT) + group.shift(3*UP + 1.5*y*DOWN) + groups.add(group) + labels.add(group[-1]) + permutation = range(len(labels)) + while any(np.arange(len(labels)) == permutation): + random.shuffle(permutation) + for label, i in zip(labels, permutation): + label.generate_target() + label.target.move_to(labels[i], LEFT) + label.target.highlight(YELLOW) + + self.play(LaggedStart( + FadeIn, groups, + run_time = 3, + lag_ratio = 0.3, + )) + self.dither() + self.play(LaggedStart( + MoveToTarget, labels, + run_time = 4, + lag_ratio = 0.5, + path_arc = np.pi/3, + )) + self.dither() + + def get_training_group(self, image_name, label_name): + arrow = Vector(RIGHT, color = WHITE) + image = ImageMobject(image_name) + image.scale_to_fit_height(1.3) + image.next_to(arrow, LEFT) + label = TextMobject(label_name) + label.next_to(arrow, RIGHT) + group = Group(image, arrow, label) + return group + +class TrainOnImages(PreviewLearning, RandomlyLabeledImageData): + CONFIG = { + "layer_sizes" : [17, 17, 17, 17, 17, 17], + "network_mob_config" : { + "brace_for_large_layers" : False, + "include_output_labels" : False, + }, + } + def construct(self): + self.setup_network_mob() + + image_names, label_names = zip(*self.image_label_pairs) + label_names = list(label_names) + random.shuffle(label_names) + groups = [ + self.get_training_group(image_name, label_name) + for image_name, label_name in zip(image_names, label_names) + ] + + + edges = VGroup(*reversed(list( + it.chain(*self.network_mob.edge_groups) + ))) + + for group in groups: + for edge in edges: + edge.generate_target() + edge.target.rotate_in_place(np.pi) + alt_edge = random.choice(edges) + color = alt_edge.get_stroke_color() + width = alt_edge.get_stroke_width() + edge.target.set_stroke(color, width) + + group.to_edge(UP) + self.add(group) + self.play(LaggedStart( + MoveToTarget, edges, + lag_ratio = 0.4, + run_time = 2, + )) + self.remove(group) + + def setup_network_mob(self): + self.network_mob.scale_to_fit_height(5) + self.network_mob.to_edge(DOWN) + self.color_network_edges() + +class IntroduceDeepNetwork(Scene): + def construct(self): + pass + +class AskNetworkAboutMemorizing(YellAtNetwork): + def construct(self): + randy = self.pi_creature + network_mob, eyes = self.get_network_and_eyes() + eyes.look_at_anim(randy.eyes).update(1) + self.add(eyes) + + self.pi_creature_says( + "Are you just \\\\ memorizing?", + target_mode = "sassy", + look_at_arg = eyes, + run_time = 2 + ) + self.dither() + self.play(eyes.change_mode_anim("sad")) + self.play(eyes.blink_anim()) + self.dither() + +class CompareLearningCurves(GraphScene): + CONFIG = { + "x_min" : 0, + "y_axis_label" : "Value of \\\\ cost function", + "x_axis_label" : "Number of gradient \\\\ descent steps", + "graph_origin" : 2*DOWN + 3.5*LEFT, + } + def construct(self): + self.setup_axes() + self.x_axis_label_mob.to_edge(DOWN) + self.y_axis_label_mob.to_edge(LEFT) + self.y_axis_label_mob.highlight(RED) + + slow_decrease = self.get_graph( + lambda x : 9 - 0.25*x + ) + faster_decrease = self.get_graph( + lambda x : 4.3*sigmoid(5*(2-x)) + 3 + 0.5*ReLU(3-x) + ) + for decrease, p in (slow_decrease, 0.2), (faster_decrease, 0.07): + y_vals = decrease.get_anchors()[:,1] + y_vals -= np.cumsum(p*np.random.random(len(y_vals))) + decrease.make_jagged() + faster_decrease.move_to(slow_decrease, UP+LEFT) + + slow_label = TextMobject("Randomly-labeled data") + slow_label.highlight(slow_decrease.get_color()) + slow_label.to_corner(UP+RIGHT) + slow_line = Line(ORIGIN, RIGHT) + slow_line.set_stroke(slow_decrease.get_color(), 5) + slow_line.next_to(slow_label, LEFT) + + fast_label = TextMobject("Properly-labeled data") + fast_label.highlight(faster_decrease.get_color()) + fast_label.next_to(slow_label, DOWN) + fast_line = slow_line.copy() + fast_line.highlight(faster_decrease.get_color()) + fast_line.next_to(fast_label, LEFT) + + self.play(FadeIn(slow_label), ShowCreation(slow_line)) + self.play(ShowCreation( + slow_decrease, + run_time = 12, + rate_func = None, + )) + self.play(FadeIn(fast_label), ShowCreation(fast_line)) + self.play(ShowCreation( + faster_decrease, + run_time = 12, + rate_func = None, + )) + self.dither() + + #### + + line = Line( + self.coords_to_point(1, 2), + self.coords_to_point(3, 9), + ) + rect = Rectangle() + rect.set_fill(YELLOW, 0.3) + rect.set_stroke(width = 0) + rect.replace(line, stretch = True) + + words = TextMobject("Learns structured data more quickly") + words.highlight(YELLOW) + words.next_to(rect, DOWN) + words.add_background_rectangle() + + self.play(DrawBorderThenFill(rect)) + self.play(Write(words)) + self.dither() + +class ManyMinimaWords(Scene): + def construct(self): + words = TextMobject( + "Many local minima,\\\\", + "roughly equal quality" + ) + words.scale_to_fit_width(2*SPACE_WIDTH - 1) + words.to_edge(UP) + self.play(Write(words)) + self.dither() + + +class NNPart2PatreonThanks(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", + "Eric Chow", + "Mathias Jansson", + "Pedro Perez Sanchez", + "David Clark", + "Michael Gardner", + "Harsev Singh", + "Mads Elvheim", + "Erik Sundell", + "Xueqi Li", + "David G. Stork", + "Tianyu Ge", + "Ted Suzman", + "Linh Tran", + "Andrew Busey", + "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", + ] + } + @@ -2783,14 +3790,6 @@ class TODOShowCostFunctionDef(TODOStub): - - - - - - - - From 67cc62a623a8d9a03345e552f27f9e00d754b2b4 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 19 Oct 2017 14:31:55 -0700 Subject: [PATCH 08/43] Introduced BulletedList --- mobject/tex_mobject.py | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/mobject/tex_mobject.py b/mobject/tex_mobject.py index 3dc4842a..edf106c7 100644 --- a/mobject/tex_mobject.py +++ b/mobject/tex_mobject.py @@ -26,7 +26,6 @@ class TexSymbol(VMobjectFromSVGPathstring): self.set_stroke(width = added_width + mobject.get_stroke_width()) self.set_fill(opacity = opacity) - class TexMobject(SVGMobject): CONFIG = { "template_tex_file" : TEMPLATE_TEX_FILE, @@ -264,6 +263,43 @@ class Brace(TexMobject): vect = self.get_tip() - self.get_center() return vect/np.linalg.norm(vect) +class BulletedList(TextMobject): + CONFIG = { + "buff" : MED_LARGE_BUFF, + "dot_scale_factor" : 2, + #Have to include because of handle_multiple_args implementation + "template_tex_file" : TEMPLATE_TEXT_FILE, + "alignment" : "", + } + def __init__(self, *items, **kwargs): + line_separated_items = [s + "\\\\" for s in items] + TextMobject.__init__(self, *line_separated_items, **kwargs) + for part in self: + dot = TexMobject("\\cdot").scale(self.dot_scale_factor) + dot.next_to(part[0], LEFT, SMALL_BUFF) + part.add_to_back(dot) + self.arrange_submobjects( + DOWN, + aligned_edge = LEFT, + buff = self.buff + ) + + def fade_all_but(self, index_or_string, opacity = 0.5): + arg = index_or_string + if isinstance(arg, str): + part = self.get_part_by_tex(arg) + elif isinstance(arg, int): + part = self.submobjects[arg] + else: + raise Exception("Expected int or string, got {0}".format(arg)) + for other_part in self.submobjects: + if other_part is part: + other_part.set_fill(opacity = 1) + else: + other_part.set_fill(opacity = opacity) + +########## + def tex_hash(expression, template_tex_file): return str(hash(expression + template_tex_file)) From cb1dd8a6c136d2bfc72ed8b36bd2d0510533da30 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 19 Oct 2017 14:32:12 -0700 Subject: [PATCH 09/43] Make initial animation of GradientNudging a bit cleaner --- nn/part2.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/nn/part2.py b/nn/part2.py index e4825d69..350675b7 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -2658,11 +2658,12 @@ class GradientNudging(PreviewLearning): for edge_group in network_mob.edge_groups ]) + mover = VGroup(*decimals.family_members_with_points()).copy() + mover.set_fill(opacity = 0) + mover.set_stroke(width = 1) + target = VGroup(*self.network_mob.edge_groups.family_members_with_points()) self.play( - ReplacementTransform( - decimals.copy().set_fill(opacity = 0).set_stroke(width = 1), - self.network_mob.edge_groups - ), + ReplacementTransform(mover, target), FadeIn(words), LaggedStart(GrowArrow, arrows, run_time = 1) ) From b8e5578ab07dd95dfcc3d8f96d0a4e78cba4c300 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 19 Oct 2017 14:32:26 -0700 Subject: [PATCH 10/43] Beginning backpropagation animations --- nn/part3.py | 103 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 nn/part3.py diff --git a/nn/part3.py b/nn/part3.py new file mode 100644 index 00000000..5b683763 --- /dev/null +++ b/nn/part3.py @@ -0,0 +1,103 @@ +from nn.network import * +from nn.part1 import * +from nn.part2 import * + +class LayOutPlan(Scene): + def construct(self): + title = TextMobject("Plan") + title.scale(1.5) + title.to_edge(UP) + h_line = Line(LEFT, RIGHT).scale(SPACE_WIDTH - 1) + h_line.next_to(title, DOWN) + + items = BulletedList( + "Recap", + "Intuitive walkthrough", + "Derivatives in \\\\ computational graphs", + ) + items.to_edge(LEFT, buff = LARGE_BUFF) + self.add(items) + + rect = ScreenRectangle() + rect.scale_to_fit_width(2*SPACE_WIDTH - items.get_width() - 2) + rect.next_to(items, RIGHT, MED_LARGE_BUFF) + + self.play( + Write(title), + ShowCreation(h_line), + ShowCreation(rect), + run_time = 2 + ) + for i in range(len(items)): + self.play(items.fade_all_but, i) + self.dither(2) + +class TODOInsertFeedForwardAnimations(TODOStub): + CONFIG = { + "message" : "Insert Feed Forward Animations" + } + +class TODOInsertStepsDownCostSurface(TODOStub): + CONFIG = { + "message" : "Insert Steps Down Cost Surface" + } + +class TODOInsertDefinitionOfCostFunction(TODOStub): + CONFIG = { + "message" : "Insert Definition of cost function" + } + + +class TODOInsertGradientNudging(TODOStub): + CONFIG = { + "message" : "Insert GradientNudging" + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 065a34fb51611c84a93a78f9cff0d7fab8b4de45 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 20 Oct 2017 16:29:00 -0700 Subject: [PATCH 11/43] Change default frame rate back to 60fps --- constants.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/constants.py b/constants.py index b6bb6f14..cfd1acca 100644 --- a/constants.py +++ b/constants.py @@ -6,8 +6,7 @@ DEFAULT_WIDTH = 1920 LOW_QUALITY_FRAME_DURATION = 1./15 MEDIUM_QUALITY_FRAME_DURATION = 1./30 -# PRODUCTION_QUALITY_FRAME_DURATION = 1./60 -PRODUCTION_QUALITY_FRAME_DURATION = 1./30 +PRODUCTION_QUALITY_FRAME_DURATION = 1./60 #There might be other configuration than pixel_shape later... PRODUCTION_QUALITY_CAMERA_CONFIG = { From 666fe16e8cf1f6c412ae92d3ee9a3d9a964a8a7b Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 20 Oct 2017 16:29:30 -0700 Subject: [PATCH 12/43] set_variables_as_attrs method on Scene --- scene/scene.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/scene/scene.py b/scene/scene.py index 46f7cdbd..c5c66d9e 100644 --- a/scene/scene.py +++ b/scene/scene.py @@ -75,20 +75,23 @@ class Scene(object): self.name = name return self - def update_shared_locals(self, *keys): + def set_variables_as_attrs(self, *objects, **newly_named_objects): """ - Often in constructing a scene, it's nice to refer to - what was a local variable from a previous subroutine, - so a dict of shared_locals is recorded, and it can be updated - by passing in the objects directly. + This method is slightly hacky, making it a little easier + for certain methods (typically subroutines of construct) + to share local variables. """ caller_locals = inspect.currentframe().f_back.f_locals - self.shared_locals.update(dict([ - (key, caller_locals[key]) - for key in keys - ])) + for key, value in caller_locals.items(): + if value in objects: + setattr(self, key, value) + for key, value in newly_named_objects.items(): + setattr(self, key, value) return self + def get_attrs(self, *keys): + return [getattr(self, key) for key in keys] + ### Only these methods should touch the camera def set_camera(self, camera): From c5891ce25e26777c7fdb0e75b227c0b405ae1e15 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 20 Oct 2017 16:29:58 -0700 Subject: [PATCH 13/43] Tweaks to GradientNudging in nn/part2 --- nn/part2.py | 40 ++++++++++++++++++++++++++++++++-------- 1 file changed, 32 insertions(+), 8 deletions(-) diff --git a/nn/part2.py b/nn/part2.py index 350675b7..c6f75105 100644 --- a/nn/part2.py +++ b/nn/part2.py @@ -77,6 +77,8 @@ def get_decimal_vector(nums, with_dots = True): result.brackets = brackets result.decimals = decimals result.contents = contents + if with_dots: + result.dots = dots return result @@ -2606,7 +2608,8 @@ class TODOInsertEmphasizeComplexityOfCostFunctionCopy(TODOStub): class GradientNudging(PreviewLearning): CONFIG = { - "n_steps" : 10 + "n_steps" : 10, + "n_decimals" : 8, } def construct(self): self.setup_network_mob() @@ -2623,18 +2626,24 @@ class GradientNudging(PreviewLearning): lhs = TexMobject( "-", "\\nabla", "C(", "\\dots", ")", "=" ) - lhs.to_edge(LEFT) brace = Brace(lhs.get_part_by_tex("dots"), DOWN) words = brace.get_text("All weights \\\\ and biases") words.scale(0.8, about_point = words.get_top()) np.random.seed(3) - nums = 4*(np.random.random(8)-0.5) + nums = 4*(np.random.random(self.n_decimals)-0.5) vect = get_decimal_vector(nums) vect.next_to(lhs, RIGHT) + group = VGroup(lhs, brace, words, vect) + group.to_corner(UP+LEFT) - self.add(lhs, brace, words, vect) + self.add(*group) - self.grad_vect = vect + self.set_variables_as_attrs( + grad_lhs = lhs, + grad_vect = vect, + grad_arg_words = words, + grad_arg_brace = brace + ) def change_weights_repeatedly(self): network_mob = self.network_mob @@ -2659,14 +2668,17 @@ class GradientNudging(PreviewLearning): ]) mover = VGroup(*decimals.family_members_with_points()).copy() - mover.set_fill(opacity = 0) - mover.set_stroke(width = 1) - target = VGroup(*self.network_mob.edge_groups.family_members_with_points()) + # mover.set_fill(opacity = 0) + mover.set_stroke(width = 0) + target = VGroup(*self.network_mob.edge_groups.family_members_with_points()).copy() + target.set_fill(opacity = 0) + ApplyMethod(target.set_stroke, YELLOW, 2).update(0.3) self.play( ReplacementTransform(mover, target), FadeIn(words), LaggedStart(GrowArrow, arrows, run_time = 1) ) + self.play(FadeOut(target)) self.play(self.get_edge_change_anim(edges)) self.play(*self.get_decimal_change_anims(decimals)) for x in range(self.n_steps): @@ -2698,6 +2710,16 @@ class GradientNudging(PreviewLearning): ) def get_decimal_change_anims(self, decimals): + words = TextMobject("Recompute \\\\ gradient") + words.next_to(decimals, DOWN, MED_LARGE_BUFF) + def wrf(t): + if t < 1./3: + return smooth(3*t) + elif t < 2./3: + return 1 + else: + return smooth(3 - 3*t) + changes = 0.2*(np.random.random(len(decimals))-0.5) def generate_change_func(x, dx): return lambda a : interpolate(x, x+dx, a) @@ -2707,6 +2729,8 @@ class GradientNudging(PreviewLearning): generate_change_func(decimal.number, change) ) for decimal, change in zip(decimals, changes) + ] + [ + FadeIn(words, rate_func = wrf, run_time = 1.5, remover = True) ] class BackPropWrapper(PiCreatureScene): From 1db52f7e6d4197d368dece48500afaf9c0a43bba Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 20 Oct 2017 16:30:33 -0700 Subject: [PATCH 14/43] InterpretGradientComponents in nn/part3 --- nn/part3.py | 287 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 285 insertions(+), 2 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 5b683763..43c0f7e7 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -47,13 +47,296 @@ class TODOInsertDefinitionOfCostFunction(TODOStub): "message" : "Insert Definition of cost function" } - class TODOInsertGradientNudging(TODOStub): CONFIG = { "message" : "Insert GradientNudging" } - +class InterpretGradientComponents(GradientNudging): + CONFIG = { + "network_mob_config" : { + "layer_to_layer_buff" : 3, + }, + "stroke_width_exp" : 2, + "n_decimals" : 6, + "n_steps" : 3, + "start_cost" : 3.48, + "delta_cost" : -0.21, + } + def construct(self): + self.setup_network() + self.add_cost() + self.add_gradient() + self.change_weights_repeatedly() + self.ask_about_high_dimensions() + self.circle_magnitudes() + self.isolate_particular_weights() + self.shift_cost_expression() + self.tweak_individual_weights() + + def setup_network(self): + self.network_mob.scale(0.55) + self.network_mob.to_corner(UP+RIGHT) + self.color_network_edges() + + def add_cost(self): + rect = SurroundingRectangle(self.network_mob) + rect.highlight(RED) + arrow = Vector(DOWN, color = RED) + arrow.shift(rect.get_bottom()) + cost = DecimalNumber(self.start_cost) + cost.highlight(RED) + cost.next_to(arrow, DOWN) + + cost_expression = TexMobject( + "C(", "w_0, w_1, \\dots, w_{13{,}001}", ")", "=" + ) + for tex in "()": + cost_expression.highlight_by_tex(tex, RED) + cost_expression.next_to(cost, DOWN) + cost_group = VGroup(cost_expression, cost) + cost_group.arrange_submobjects(RIGHT) + cost_group.next_to(arrow, DOWN) + + self.add(rect, arrow, cost_group) + + self.set_variables_as_attrs( + cost, cost_expression, cost_group, + network_rect = rect + ) + + def change_weights_repeatedly(self): + decimals = self.grad_vect.decimals + grad_terms = self.grad_vect.contents + edges = VGroup(*reversed(list( + it.chain(*self.network_mob.edge_groups) + ))) + cost = self.cost + + for x in range(self.n_steps): + self.move_grad_terms_into_position(grad_terms.copy()) + self.play(*self.get_weight_adjustment_anims(edges, cost)) + self.play(*self.get_decimal_change_anims(decimals)) + + def ask_about_high_dimensions(self): + grad_vect = self.grad_vect + + words = TextMobject( + "Direction in \\\\ ${13{,}002}$ dimensions?!?") + words.highlight(YELLOW) + words.move_to(grad_vect).to_edge(DOWN) + arrow = Arrow( + words.get_top(), + grad_vect.get_bottom(), + buff = SMALL_BUFF + ) + + randy = Randolph() + randy.scale(0.6) + randy.next_to(words, LEFT) + randy.shift_onto_screen() + + self.play( + Write(words, run_time = 2), + GrowArrow(arrow), + ) + self.play(FadeIn(randy)) + self.play(randy.change, "confused", words) + self.play(Blink(randy)) + self.dither() + self.play(*map(FadeOut, [randy, words, arrow])) + + def circle_magnitudes(self): + rects = VGroup() + for decimal in self.grad_vect.decimals: + rects.add(SurroundingRectangle(VGroup(*decimal[-4:]))) + rects.highlight(WHITE) + + self.play(LaggedStart(ShowCreation, rects)) + self.play(FadeOut(rects)) + + def isolate_particular_weights(self): + vect_contents = self.grad_vect.contents + w_terms = self.cost_expression[1] + + edges = self.network_mob.edge_groups + edge1 = self.network_mob.layers[1].neurons[3].edges_in[0].copy() + edge2 = self.network_mob.layers[1].neurons[9].edges_in[15].copy() + VGroup(edge1, edge2).set_stroke(width = 4) + d1 = DecimalNumber(3.2) + d2 = DecimalNumber(0.1) + VGroup(edge1, d1).highlight(YELLOW) + VGroup(edge2, d2).highlight(MAROON_B) + new_vect_contents = VGroup( + TexMobject("\\vdots"), + d1, TexMobject("\\vdots"), + d2, TexMobject("\\vdots"), + ) + new_vect_contents.arrange_submobjects(DOWN) + new_vect_contents.move_to(vect_contents) + + new_w_terms = TexMobject( + "\\dots", "w_n", "\\dots", "w_k", "\\dots" + ) + new_w_terms.move_to(w_terms, DOWN) + new_w_terms[1].highlight(d1.get_color()) + new_w_terms[3].highlight(d2.get_color()) + + for d, edge in (d1, edge1), (d2, edge2): + d.arrow = Arrow( + d.get_right(), edge.get_center(), + color = d.get_color() + ) + + self.play( + FadeOut(vect_contents), + FadeIn(new_vect_contents), + FadeOut(w_terms), + FadeIn(new_w_terms), + edges.set_stroke, LIGHT_GREY, 0.35, + ) + self.play(GrowArrow(d1.arrow)) + self.play(ShowCreation(edge1)) + self.dither() + self.play(GrowArrow(d2.arrow)) + self.play(ShowCreation(edge2)) + self.dither(2) + + self.cost_expression.remove(w_terms) + self.cost_expression.add(new_w_terms) + self.set_variables_as_attrs( + edge1, edge2, new_w_terms, + new_decimals = VGroup(d1, d2) + ) + + def shift_cost_expression(self): + self.play(self.cost_group.shift, DOWN+0.5*LEFT) + + def tweak_individual_weights(self): + cost = self.cost + cost_num = cost.number + edges = VGroup(self.edge1, self.edge2) + decimals = self.new_decimals + changes = (1.0, 1./32) + wn = self.new_w_terms[1] + wk = self.new_w_terms[3] + + number_line_template = NumberLine( + x_min = -1, + x_max = 1, + tick_frequency = 0.25, + numbers_with_elongated_ticks = [], + color = WHITE + ) + for term in wn, wk, cost: + term.number_line = number_line_template.copy() + term.brace = Brace(term.number_line, DOWN, buff = SMALL_BUFF) + group = VGroup(term.number_line, term.brace) + group.next_to(term, UP) + term.dot = Dot() + term.dot.highlight(term.get_color()) + term.dot.move_to(term.number_line.get_center()) + term.dot.save_state() + term.dot.move_to(term) + term.dot.set_fill(opacity = 0) + + groups = [ + VGroup(d, d.arrow, edge, w) + for d, edge, w in zip(decimals, edges, [wn, wk]) + ] + for group in groups: + group.save_state() + + for i in range(2): + group1, group2 = groups[i], groups[1-i] + change = changes[i] + edge = edges[i] + w = group1[-1] + added_anims = [] + if i == 0: + added_anims = [ + GrowFromCenter(cost.brace), + ShowCreation(cost.number_line), + cost.dot.restore + ] + self.play( + group1.restore, + group2.fade, 0.7, + GrowFromCenter(w.brace), + ShowCreation(w.number_line), + w.dot.restore, + *added_anims + ) + for x in range(2): + func = lambda a : interpolate( + cost_num, cost_num-change, a + ) + self.play( + ChangingDecimal(cost, func), + cost.dot.shift, change*RIGHT, + w.dot.shift, 0.25*RIGHT, + edge.set_stroke, None, 8, + rate_func = lambda t : wiggle(t, 4), + run_time = 2, + ) + self.dither() + self.play(*map(FadeOut, [w.dot, w.brace, w.number_line])) + + + ###### + + def move_grad_terms_into_position(self, grad_terms): + cost_expression = self.cost_expression + w_terms = self.cost_expression[1] + points = VGroup(*[ + VectorizedPoint() + for term in grad_terms + ]) + points.arrange_submobjects(RIGHT) + points.replace(w_terms, dim_to_match = 0) + + grad_terms.generate_target() + grad_terms.target[len(grad_terms)/2].rotate(np.pi/2) + grad_terms.target.arrange_submobjects(RIGHT) + grad_terms.target.scale_to_fit_width(cost_expression.get_width()) + grad_terms.target.next_to(cost_expression, DOWN) + + words = TextMobject("Nudge weights") + words.scale(0.8) + words.next_to(grad_terms.target, DOWN) + + self.play( + MoveToTarget(grad_terms), + FadeIn(words) + ) + self.play( + Transform( + grad_terms, points, + remover = True, + submobject_mode = "lagged_start", + run_time = 1 + ), + FadeOut(words) + ) + + def get_weight_adjustment_anims(self, edges, cost): + start_cost = cost.number + target_cost = start_cost + self.delta_cost + w_terms = self.cost_expression[1] + + return [ + self.get_edge_change_anim(edges), + LaggedStart( + Indicate, w_terms, + rate_func = there_and_back, + run_time = 1.5, + ), + ChangingDecimal( + cost, + lambda a : interpolate(start_cost, target_cost, a), + run_time = 1.5 + ) + ] From 80eae6223276c9dc5502df83cd8a796259e1d224 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 20 Oct 2017 17:10:47 -0700 Subject: [PATCH 15/43] GetLostInNotation in nn/part3 --- nn/part3.py | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 73 insertions(+), 4 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 43c0f7e7..ba4ca842 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -338,10 +338,79 @@ class InterpretGradientComponents(GradientNudging): ) ] - - - - +class GetLostInNotation(PiCreatureScene): + def construct(self): + morty = self.pi_creature + equations = VGroup( + TexMobject( + "\\delta", "^L", "=", "\\nabla_a", "C", + "\\odot \\sigma'(", "z", "^L)" + ), + TexMobject( + "\\delta", "^l = ((", "w", "^{l+1})^T", + "\\delta", "^{l+1}) \\odot \\sigma'(", "z", "^l)" + ), + TexMobject( + "{\\partial", "C", "\\over \\partial", "b", + "_j^l} =", "\\delta", "_j^l" + ), + TexMobject( + "{\\partial", "C", " \\over \\partial", + "w", "_{jk}^l} = ", "a", "_k^{l-1}", "\\delta", "_j^l" + ), + ) + for equation in equations: + equation.highlight_by_tex_to_color_map({ + "\\delta" : YELLOW, + "C" : RED, + "b" : MAROON_B, + "w" : BLUE, + "z" : TEAL, + }) + equation.highlight_by_tex("nabla", WHITE) + equations.arrange_submobjects( + DOWN, buff = MED_LARGE_BUFF, aligned_edge = LEFT + ) + + circle = Circle(radius = 3*SPACE_WIDTH) + circle.set_fill(WHITE, 0) + circle.set_stroke(WHITE, 0) + + self.play( + Write(equations), + morty.change, "confused", equations + ) + self.dither() + self.play(morty.change, "pleading") + self.dither(2) + + ## + movers = VGroup(*equations.family_members_with_points()) + random.shuffle(movers.submobjects) + for mover in list(movers): + if mover.is_subpath: + movers.remove(mover) + continue + mover.set_stroke(WHITE, width = 0) + mover.target = Circle() + mover.target.scale(0.5) + mover.target.set_fill(mover.get_color(), opacity = 0) + mover.target.set_stroke(BLACK, width = 1) + mover.target.move_to(mover) + self.play( + LaggedStart( + MoveToTarget, movers, + run_time = 2, + ), + morty.change, "pondering", + ) + self.dither() + + +class TODOInsertPreviewLearning(TODOStub): + CONFIG = { + "message" : "Insert PreviewLearning" + } From 8a5d63917f106300b105c5b9fababa8d3c8c4b29 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 23 Oct 2017 15:47:50 -0700 Subject: [PATCH 16/43] Refactor of layer activations in nn --- nn/part1.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/nn/part1.py b/nn/part1.py index 1e311db4..c187115e 100644 --- a/nn/part1.py +++ b/nn/part1.py @@ -214,6 +214,10 @@ class NetworkMobject(VGroup): def get_active_layer(self, layer_index, activation_vector): layer = self.layers[layer_index].deepcopy() + self.activate_layer(layer) + return layer + + def activate_layer(self, layer, activation_vector): n_neurons = len(layer.neurons) av = activation_vector def arr_to_num(arr): @@ -241,6 +245,11 @@ class NetworkMobject(VGroup): ) return layer + def activate_layers(self, input_vector): + activations = self.neural_network.get_activation_of_all_layers(input_vector) + for activation, layer in zip(activations, self.layers): + self.activate_layer(layer, activation) + def deactivate_layers(self): all_neurons = VGroup(*it.chain(*[ layer.neurons From 20318cb9d2d9f32b4483442cb477653379d874d5 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 23 Oct 2017 15:48:05 -0700 Subject: [PATCH 17/43] ShowAveragingCost of nn/part3 --- nn/part3.py | 192 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 180 insertions(+), 12 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index ba4ca842..2ab5a008 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -114,8 +114,10 @@ class InterpretGradientComponents(GradientNudging): cost = self.cost for x in range(self.n_steps): - self.move_grad_terms_into_position(grad_terms.copy()) - self.play(*self.get_weight_adjustment_anims(edges, cost)) + self.move_grad_terms_into_position( + grad_terms.copy(), + *self.get_weight_adjustment_anims(edges, cost) + ) self.play(*self.get_decimal_change_anims(decimals)) def ask_about_high_dimensions(self): @@ -149,7 +151,7 @@ class InterpretGradientComponents(GradientNudging): def circle_magnitudes(self): rects = VGroup() for decimal in self.grad_vect.decimals: - rects.add(SurroundingRectangle(VGroup(*decimal[-4:]))) + rects.add(SurroundingRectangle(VGroup(*decimal[-5:]))) rects.highlight(WHITE) self.play(LaggedStart(ShowCreation, rects)) @@ -239,6 +241,9 @@ class InterpretGradientComponents(GradientNudging): term.dot.save_state() term.dot.move_to(term) term.dot.set_fill(opacity = 0) + term.words = TextMobject("Nudge this weight") + term.words.scale(0.7) + term.words.next_to(term.number_line, UP, MED_SMALL_BUFF) groups = [ VGroup(d, d.arrow, edge, w) @@ -265,6 +270,7 @@ class InterpretGradientComponents(GradientNudging): GrowFromCenter(w.brace), ShowCreation(w.number_line), w.dot.restore, + Write(w.words, run_time = 1), *added_anims ) for x in range(2): @@ -280,12 +286,14 @@ class InterpretGradientComponents(GradientNudging): run_time = 2, ) self.dither() - self.play(*map(FadeOut, [w.dot, w.brace, w.number_line])) + self.play(*map(FadeOut, [ + w.dot, w.brace, w.number_line, w.words + ])) ###### - def move_grad_terms_into_position(self, grad_terms): + def move_grad_terms_into_position(self, grad_terms, *added_anims): cost_expression = self.cost_expression w_terms = self.cost_expression[1] points = VGroup(*[ @@ -316,7 +324,8 @@ class InterpretGradientComponents(GradientNudging): submobject_mode = "lagged_start", run_time = 1 ), - FadeOut(words) + FadeOut(words), + *added_anims ) def get_weight_adjustment_anims(self, edges, cost): @@ -406,17 +415,176 @@ class GetLostInNotation(PiCreatureScene): ) self.dither() - class TODOInsertPreviewLearning(TODOStub): CONFIG = { "message" : "Insert PreviewLearning" } - - - - - +class ShowAveragingCost(PreviewLearning): + CONFIG = { + "network_scale_val" : 0.8, + "stroke_width_exp" : 1, + "start_examples_time" : 5, + "examples_per_adjustment_time" : 2, + "n_adjustments" : 5, + "time_per_example" : 1./15, + "image_height" : 1.2, + } + def construct(self): + self.setup_network() + self.setup_diff_words() + self.show_many_examples() + + def setup_network(self): + self.network_mob.scale(self.network_scale_val) + self.network_mob.to_edge(DOWN) + self.network_mob.shift(LEFT) + self.color_network_edges() + + def setup_diff_words(self): + last_layer_copy = self.network_mob.layers[-1].deepcopy() + last_layer_copy.add(self.network_mob.output_labels.copy()) + last_layer_copy.shift(1.5*RIGHT) + + double_arrow = DoubleArrow( + self.network_mob.output_labels, + last_layer_copy, + color = RED + ) + brace = Brace( + VGroup(self.network_mob.layers[-1], last_layer_copy), + UP + ) + cost_words = brace.get_text("Cost of \\\\ one example") + cost_words.highlight(RED) + + self.add(last_layer_copy, double_arrow, brace, cost_words) + self.set_variables_as_attrs( + last_layer_copy, double_arrow, brace, cost_words + ) + self.last_layer_copy = last_layer_copy + + def show_many_examples(self): + training_data, validation_data, test_data = load_data_wrapper() + training_data_iter = iter(training_data) + + average_words = TextMobject("Average over all training examples") + average_words.next_to(LEFT, RIGHT) + average_words.to_edge(UP) + self.add(average_words) + + for x in xrange(int(self.start_examples_time/self.time_per_example)): + train_in, train_out = training_data_iter.next() + self.show_one_example(train_in, train_out) + self.dither(self.time_per_example) + + #Wiggle all edges + edges = VGroup(*it.chain(*self.network_mob.edge_groups)) + reversed_edges = VGroup(*reversed(edges)) + self.play(LaggedStart( + ApplyFunction, edges, + lambda edge : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + edge, + ), + rate_func = lambda t : wiggle(t, 4), + run_time = 3, + )) + + #Show all, then adjust + words = TextMobject( + "Each step \\\\ uses every \\\\ example\\\\", + "$\\dots$theoretically", + alignment = "" + ) + words.highlight(YELLOW) + words.scale(0.8) + words.to_corner(UP+LEFT) + + for x in xrange(self.n_adjustments): + for y in xrange(int(self.examples_per_adjustment_time/self.time_per_example)): + train_in, train_out = training_data_iter.next() + self.show_one_example(train_in, train_out) + self.dither(self.time_per_example) + self.play(LaggedStart( + ApplyMethod, reversed_edges, + lambda m : (m.rotate_in_place, np.pi), + run_time = 1, + lag_ratio = 0.2, + )) + if x < 2: + self.play(FadeIn(words[x])) + else: + self.dither() + + #### + + def show_one_example(self, train_in, train_out): + if hasattr(self, "curr_image"): + self.remove(self.curr_image) + image = MNistMobject(train_in) + image.scale_to_fit_height(self.image_height) + image.next_to( + self.network_mob.layers[0].neurons, UP, + aligned_edge = LEFT + ) + self.add(image) + self.network_mob.activate_layers(train_in) + + index = np.argmax(train_out) + self.last_layer_copy.neurons.set_fill(opacity = 0) + self.last_layer_copy.neurons[index].set_fill(WHITE, opacity = 1) + self.add(self.last_layer_copy) + + self.curr_iamge = image + + +class WalkThroughTwoExample(ShowAveragingCost): + def construct(self): + self.force_skipping() + + self.setup_network() + self.setup_diff_words() + self.show_single_example() + self.expand_last_layer() + self.cannot_directly_affect_activations() + self.show_desired_activation_nudges() + self.focus_on_one_neuron() + self.show_activation_formula() + self.three_ways_to_increase() + self.note_connections_to_brightest_neurons() + + def show_single_example(self): + two_vect = get_organized_images()[2][0] + two_out = np.zeroes(10) + two_out[2] = 1.0 + self.show_one_example(two_vect, two_out) + for layer in self.network_mob.layers: + layer.neurons.set_fill(opacity = 0) + + self.revert_to_original_skipping_status() + self.feed_forward(two_vect) + + def expand_last_layer(self): + pass + + def cannot_directly_affect_activations(self): + pass + + def show_desired_activation_nudges(self): + pass + + def focus_on_one_neuron(self): + pass + + def show_activation_formula(self): + pass + + def three_ways_to_increase(self): + pass + + def note_connections_to_brightest_neurons(self): + pass From 0ba007bf21867f2bfc63352470196de39f95da80 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 13:27:37 -0700 Subject: [PATCH 18/43] added cleanup to ShowCreationThenDestruction --- animation/simple_animations.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/animation/simple_animations.py b/animation/simple_animations.py index 7bdf054b..2aef84dc 100644 --- a/animation/simple_animations.py +++ b/animation/simple_animations.py @@ -152,6 +152,11 @@ class ShowCreationThenDestruction(ShowPassingFlash): "run_time" : 1, } + def clean_up(self, *args, **kwargs): + ShowPassingFlash.clean_up(self, *args, **kwargs) + for submob, start_submob in self.get_all_families_zipped(): + submob.pointwise_become_partial(start_submob, 0, 1) + class MoveAlongPath(Animation): def __init__(self, mobject, vmobject, **kwargs): digest_config(self, kwargs, locals()) From de0e156444f3a102801682ae2d13ed4a4f1d71a5 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 13:41:04 -0700 Subject: [PATCH 19/43] Slight alterations and bug fixes --- nn/part1.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/nn/part1.py b/nn/part1.py index c187115e..12540128 100644 --- a/nn/part1.py +++ b/nn/part1.py @@ -122,7 +122,7 @@ class NetworkMobject(VGroup): "neuron_fill_color" : GREEN, "edge_color" : LIGHT_GREY, "edge_stroke_width" : 2, - "edge_propogation_color" : GREEN, + "edge_propogation_color" : YELLOW, "edge_propogation_time" : 1, "max_shown_neurons" : 16, "brace_for_large_layers" : True, @@ -214,7 +214,7 @@ class NetworkMobject(VGroup): def get_active_layer(self, layer_index, activation_vector): layer = self.layers[layer_index].deepcopy() - self.activate_layer(layer) + self.activate_layer(layer, activation_vector) return layer def activate_layer(self, layer, activation_vector): From 3d9d3be1425b98dd943bea8b49f5f6a4f8af21a3 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 13:41:28 -0700 Subject: [PATCH 20/43] A few scene bug fixes --- scene/scene.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/scene/scene.py b/scene/scene.py index c5c66d9e..0238f1e9 100644 --- a/scene/scene.py +++ b/scene/scene.py @@ -83,8 +83,9 @@ class Scene(object): """ caller_locals = inspect.currentframe().f_back.f_locals for key, value in caller_locals.items(): - if value in objects: - setattr(self, key, value) + for o in objects: + if value is o: + setattr(self, key, value) for key, value in newly_named_objects.items(): setattr(self, key, value) return self @@ -348,7 +349,7 @@ class Scene(object): animations.pop() #method should already have target then. else: - mobject.target = mobject.deepcopy() + mobject.target = mobject.copy() state["curr_method"].im_func( mobject.target, *state["method_args"] ) From 7f14e9b8447ba65fb9002fc3a12b004f67968c45 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 13:42:11 -0700 Subject: [PATCH 21/43] Partial progress through long WalkThroughTwoExample scene in nn/part3 --- helpers.py | 1 - nn/part3.py | 507 ++++++++++++++++++++++++++++++++++++++++++--- topics/geometry.py | 1 + 3 files changed, 483 insertions(+), 26 deletions(-) diff --git a/helpers.py b/helpers.py index 0a645928..dbfd5d49 100644 --- a/helpers.py +++ b/helpers.py @@ -37,7 +37,6 @@ def play_chord(*nums): def play_error_sound(): play_chord(11, 8, 6, 1) - def play_finish_sound(): play_chord(12, 9, 5, 2) diff --git a/nn/part3.py b/nn/part3.py index 2ab5a008..8704625f 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -466,15 +466,15 @@ class ShowAveragingCost(PreviewLearning): def show_many_examples(self): training_data, validation_data, test_data = load_data_wrapper() - training_data_iter = iter(training_data) average_words = TextMobject("Average over all training examples") average_words.next_to(LEFT, RIGHT) average_words.to_edge(UP) self.add(average_words) - for x in xrange(int(self.start_examples_time/self.time_per_example)): - train_in, train_out = training_data_iter.next() + n_start_examples = int(self.start_examples_time/self.time_per_example) + n_examples_per_adjustment = int(self.examples_per_adjustment_time/self.time_per_example) + for train_in, train_out in training_data[:n_start_examples]: self.show_one_example(train_in, train_out) self.dither(self.time_per_example) @@ -502,8 +502,9 @@ class ShowAveragingCost(PreviewLearning): words.to_corner(UP+LEFT) for x in xrange(self.n_adjustments): - for y in xrange(int(self.examples_per_adjustment_time/self.time_per_example)): - train_in, train_out = training_data_iter.next() + if x < 2: + self.play(FadeIn(words[x])) + for train_in, train_out in training_data[:n_examples_per_adjustment]: self.show_one_example(train_in, train_out) self.dither(self.time_per_example) self.play(LaggedStart( @@ -512,9 +513,7 @@ class ShowAveragingCost(PreviewLearning): run_time = 1, lag_ratio = 0.2, )) - if x < 2: - self.play(FadeIn(words[x])) - else: + if x >= 2: self.dither() #### @@ -536,56 +535,514 @@ class ShowAveragingCost(PreviewLearning): self.last_layer_copy.neurons[index].set_fill(WHITE, opacity = 1) self.add(self.last_layer_copy) - self.curr_iamge = image + self.curr_image = image class WalkThroughTwoExample(ShowAveragingCost): + CONFIG = { + "random_seed" : 0, + } + def setup(self): + np.random.seed(self.random_seed) + random.seed(self.random_seed) + self.setup_bases() + def construct(self): self.force_skipping() self.setup_network() self.setup_diff_words() self.show_single_example() + # self.single_example_influencing_weights() self.expand_last_layer() - self.cannot_directly_affect_activations() - self.show_desired_activation_nudges() - self.focus_on_one_neuron() self.show_activation_formula() self.three_ways_to_increase() self.note_connections_to_brightest_neurons() + self.fire_together_wire_together() def show_single_example(self): two_vect = get_organized_images()[2][0] - two_out = np.zeroes(10) + two_out = np.zeros(10) two_out[2] = 1.0 self.show_one_example(two_vect, two_out) for layer in self.network_mob.layers: layer.neurons.set_fill(opacity = 0) - self.revert_to_original_skipping_status() - self.feed_forward(two_vect) + self.activate_network(two_vect) + self.dither() + + def single_example_influencing_weights(self): + two = self.curr_image + two.save_state() + + edge_groups = self.network_mob.edge_groups + def adjust_edge_group_anim(edge_group): + return LaggedStart( + ApplyFunction, edge_group, + lambda edge : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + edge + ), + rate_func = wiggle, + run_time = 1, + ) + + + self.play( + two.next_to, edge_groups[0].get_corner(DOWN+RIGHT), DOWN, + adjust_edge_group_anim(edge_groups[0]) + ) + self.play( + ApplyMethod( + two.next_to, edge_groups[1].get_corner(UP+RIGHT), UP, + path_arc = np.pi/6, + ), + adjust_edge_group_anim(VGroup(*reversed(edge_groups[1]))) + ) + self.play( + ApplyMethod( + two.next_to, edge_groups[2].get_corner(DOWN+RIGHT), DOWN, + path_arc = -np.pi/6, + ), + adjust_edge_group_anim(edge_groups[2]) + ) + self.play(two.restore) + self.dither() def expand_last_layer(self): - pass + neurons = self.network_mob.layers[-1].neurons + alt_neurons = self.last_layer_copy.neurons + output_labels = self.network_mob.output_labels + alt_output_labels = self.last_layer_copy[-1] + edges = self.network_mob.edge_groups[-1] + + movers = VGroup( + neurons, alt_neurons, + output_labels, alt_output_labels, + *edges + ) + to_fade = VGroup(self.brace, self.cost_words, self.double_arrow) + for mover in movers: + mover.save_state() + mover.generate_target() + mover.target.scale_in_place(2) + + neurons.target.to_edge(DOWN, MED_LARGE_BUFF) + output_labels.target.next_to(neurons.target, RIGHT, MED_SMALL_BUFF) + alt_neurons.target.next_to(neurons.target, RIGHT, buff = 2) + alt_output_labels.target.next_to(alt_neurons.target, RIGHT, MED_SMALL_BUFF) + + n_pairs = it.product( + self.network_mob.layers[-2].neurons, + neurons.target + ) + for edge, (n1, n2) in zip(edges, n_pairs): + r1 = n1.get_width()/2.0 + r2 = n2.get_width()/2.0 + c1 = n1.get_center() + c2 = n2.get_center() + vect = c2 - c1 + norm = np.linalg.norm(vect) + unit_vect = vect / norm + + edge.target.put_start_and_end_on( + c1 + unit_vect*r1, + c2 - unit_vect*r2 + ) + + self.play( + FadeOut(to_fade), + *map(MoveToTarget, movers) + ) + self.show_decimals(neurons) + self.cannot_directly_affect_activations() + self.show_desired_activation_nudges(neurons, output_labels, alt_output_labels) + self.focus_on_one_neuron(movers) + + def show_decimals(self, neurons): + decimals = VGroup() + for neuron in neurons: + activation = neuron.get_fill_opacity() + decimal = DecimalNumber(activation, num_decimal_points = 1) + decimal.scale_to_fit_width(0.7*neuron.get_width()) + decimal.move_to(neuron) + if activation > 0.8: + decimal.highlight(BLACK) + decimals.add(decimal) + + self.play(Write(decimals, run_time = 2)) + self.dither() + self.decimals = decimals def cannot_directly_affect_activations(self): - pass + words = TextMobject("You can only adjust weights and biases") + words.next_to(self.curr_image, RIGHT, MED_SMALL_BUFF, UP) - def show_desired_activation_nudges(self): - pass + edges = VGroup(*self.network_mob.edge_groups.family_members_with_points()) + random.shuffle(edges.submobjects) + for edge in edges: + edge.generate_target() + edge.target.set_stroke( + random.choice([BLUE, RED]), + 2*random.random()**2, + ) - def focus_on_one_neuron(self): - pass + self.play( + LaggedStart( + Transform, edges, + lambda e : (e, e.target), + run_time = 4, + rate_func = there_and_back, + ), + Write(words, run_time = 2) + ) + self.play(FadeOut(words)) + + def show_desired_activation_nudges(self, neurons, output_labels, alt_output_labels): + arrows = VGroup() + rects = VGroup() + for i, neuron, label in zip(it.count(), neurons, alt_output_labels): + activation = neuron.get_fill_opacity() + target_val = 1 if i == 2 else 0 + diff = abs(activation - target_val) + arrow = Arrow( + ORIGIN, diff*neuron.get_height()*DOWN, + color = RED, + ) + arrow.move_to(neuron.get_right()) + arrow.shift(0.175*RIGHT) + if i == 2: + arrow.highlight(BLUE) + arrow.rotate_in_place(np.pi) + arrows.add(arrow) + + rect = SurroundingRectangle(VGroup(neuron, label)) + if i == 2: + rect.highlight(BLUE) + else: + rect.highlight(RED) + rects.add(rect) + + self.play( + output_labels.shift, SMALL_BUFF*RIGHT, + LaggedStart(GrowArrow, arrows, run_time = 1) + ) + self.dither() + + two_rect = rects[2] + eight_rect = rects[8].copy() + non_two_rects = VGroup(*[r for r in rects if r is not two_rect]) + self.play(ShowCreation(two_rect)) + self.dither() + self.remove(two_rect) + self.play(ReplacementTransform(two_rect.copy(), non_two_rects)) + self.dither() + self.play(LaggedStart(FadeOut, non_two_rects, run_time = 1)) + self.play(LaggedStart( + ApplyFunction, arrows, + lambda arrow : ( + lambda m : m.scale_in_place(0.5).highlight(YELLOW), + arrow, + ), + rate_func = wiggle + )) + self.play(ShowCreation(two_rect)) + self.dither() + self.play(ReplacementTransform(two_rect, eight_rect)) + self.dither() + self.play(FadeOut(eight_rect)) + + self.arrows = arrows + + def focus_on_one_neuron(self, expanded_mobjects): + network_mob = self.network_mob + neurons = network_mob.layers[-1].neurons + labels = network_mob.output_labels + two_neuron = neurons[2] + neurons.remove(two_neuron) + two_label = labels[2] + labels.remove(two_label) + expanded_mobjects.remove(*two_neuron.edges_in) + two_decimal = self.decimals[2] + self.decimals.remove(two_decimal) + two_arrow = self.arrows[2] + self.arrows.remove(two_arrow) + + to_fade = VGroup(*it.chain( + network_mob.layers[:2], + network_mob.edge_groups[:2], + expanded_mobjects, + self.decimals, + self.arrows + )) + + self.play(FadeOut(to_fade)) + self.dither() + for mob in expanded_mobjects: + if mob in [neurons, labels]: + mob.scale(0.5) + mob.move_to(mob.saved_state) + else: + mob.restore() + for d, a, n in zip(self.decimals, self.arrows, neurons): + d.scale(0.5) + d.move_to(n) + a.scale(0.5) + a.move_to(n.get_right()) + a.shift(SMALL_BUFF*RIGHT) + labels.shift(SMALL_BUFF*RIGHT) + + self.set_variables_as_attrs( + two_neuron, two_label, two_arrow, two_decimal, + ) def show_activation_formula(self): - pass + rhs = TexMobject( + "=", "\\sigma(", + "w_0", "a_0", "+", + "w_1", "a_1", "+", + "\\cdots", "+", + "w_{n-1}", "a_{n-1}", "+", + "b", ")" + ) + equals = rhs[0] + sigma = VGroup(rhs[1], rhs[-1]) + w_terms = rhs.get_parts_by_tex("w_") + a_terms = rhs.get_parts_by_tex("a_") + plus_terms = rhs.get_parts_by_tex("+") + b = rhs.get_part_by_tex("b", substring = False) + dots = rhs.get_part_by_tex("dots") + + w_terms.highlight(BLUE) + b.highlight(MAROON_B) + sigma.highlight(YELLOW) + + rhs.to_corner(UP+RIGHT) + sigma.save_state() + sigma.shift(DOWN) + sigma.set_fill(opacity = 0) + + prev_neurons = self.network_mob.layers[-2].neurons + edges = self.two_neuron.edges_in + + neuron_copy = VGroup( + self.two_neuron.copy(), + self.two_decimal.copy(), + ) + + self.play( + neuron_copy.next_to, equals.get_left(), LEFT, + self.curr_image.to_corner, UP+LEFT, + Write(equals) + ) + self.play( + ReplacementTransform(edges.copy(), w_terms), + Write(VGroup(*plus_terms[:-1])), + Write(dots), + run_time = 1.5 + ) + self.dither() + self.play(ReplacementTransform( + prev_neurons.copy(), a_terms, + path_arc = np.pi/2 + )) + self.dither() + self.play( + Write(plus_terms[-1]), + Write(b) + ) + self.dither() + self.play(sigma.restore) + self.dither(2) + + self.set_variables_as_attrs( + rhs, w_terms, a_terms, b, + lhs = neuron_copy + ) def three_ways_to_increase(self): - pass + w_terms = self.w_terms + a_terms = self.a_terms + b = self.b + increase_words = VGroup( + TextMobject("Increase", "$b$"), + TextMobject("Increase", "$w_i$"), + TextMobject("Increase", "$a_i$"), + ) + for words in increase_words: + words.highlight_by_tex_to_color_map({ + "b" : b.get_color(), + "w_" : w_terms.get_color(), + "a_" : a_terms.get_color(), + }) + increase_words.arrange_submobjects( + DOWN, aligned_edge = LEFT, + buff = LARGE_BUFF + ) + increase_words.to_edge(LEFT) + + mobs = [b, w_terms[0], a_terms[0]] + for words, mob in zip(increase_words, mobs): + self.play( + Write(words[0], run_time = 1), + ReplacementTransform(mob.copy(), words[1]) + ) + self.dither() + + self.increase_words = increase_words def note_connections_to_brightest_neurons(self): - pass - + w_terms = self.w_terms + a_terms = self.a_terms + increase_words = self.increase_words + prev_neurons = self.network_mob.layers[-2].neurons + edges = self.two_neuron.edges_in + + prev_activations = np.array([n.get_fill_opacity() for n in prev_neurons]) + sorted_indices = np.argsort(prev_activations.flatten()) + bright_neurons = VGroup() + edges_to_bright_neurons = VGroup() + for i in sorted_indices[-4:]: + bright_neurons.add(prev_neurons[i].copy()) + bright_neurons.set_stroke(YELLOW, 3) + edges_to_bright_neurons.add(edges[i]) + bright_edges = edges_to_bright_neurons.copy() + bright_edges.set_stroke(YELLOW, 4) + + added_words = TextMobject("in proportion to $a_i$") + added_words.next_to( + increase_words[1], DOWN, + 1.5*SMALL_BUFF, LEFT + ) + added_words.highlight(YELLOW) + + terms_rect = SurroundingRectangle( + VGroup(w_terms[0], a_terms[0]), + color = WHITE + ) + + self.play(LaggedStart( + ApplyFunction, edges, + lambda edge : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + edge + ), + rate_func = wiggle + )) + self.dither() + self.play( + ShowCreation(bright_edges), + ShowCreation(bright_neurons) + ) + self.dither() + self.play( + ReplacementTransform(bright_edges[0].copy(), w_terms[0]), + ReplacementTransform(bright_neurons[0].copy(), a_terms[0]), + ShowCreation(terms_rect) + ) + self.play(FadeOut(terms_rect)) + self.dither() + self.play( + self.curr_image.shift, MED_LARGE_BUFF*RIGHT, + rate_func = wiggle + ) + self.dither() + self.play(Write(added_words)) + self.dither() + + self.set_variables_as_attrs( + bright_neurons, bright_edges, + in_proportion_to_a = added_words + ) + + def fire_together_wire_together(self): + bright_neurons = self.bright_neurons + bright_edges = self.bright_edges + two_neuron = self.two_neuron + two_decimal = self.two_decimal + two_activation = two_decimal.number + + edge_animation = LaggedStart( + ShowCreationThenDestruction, bright_edges, + lag_ratio = 0.7 + ) + neuron_arrows = VGroup(*[ + Vector(MED_LARGE_BUFF*RIGHT).next_to(n, LEFT) + for n in bright_neurons + ]) + two_neuron_arrow = Vector(MED_LARGE_BUFF*DOWN) + two_neuron_arrow.next_to(two_neuron, UP) + VGroup(neuron_arrows, two_neuron_arrow).highlight(YELLOW) + + neuron_rects = VGroup(*map( + SurroundingRectangle, bright_neurons + )) + two_neuron_rect = SurroundingRectangle(two_neuron) + seeing_words = TextMobject("Seeing a 2") + thinking_words = TextMobject("Thinking about a 2") + seeing_words.next_to(neuron_rects, UP) + thinking_words.next_to(two_neuron_rect, UP, aligned_edge = LEFT) + + morty = Mortimer() + morty.scale(0.8) + morty.to_corner(DOWN+RIGHT) + words = TextMobject(""" + ``Neurons that \\\\ + fire together \\\\ + wire together'' + """) + words.to_edge(RIGHT) + + self.revert_to_original_skipping_status() + self.play(FadeIn(morty)) + self.play( + Write(words), + morty.change, "speaking", words + ) + self.play(Blink(morty)) + self.play( + edge_animation, + morty.change, "pondering", bright_edges + ) + self.play(edge_animation) + self.play( + LaggedStart(GrowArrow, neuron_arrows), + edge_animation, + ) + self.play( + GrowArrow(two_neuron_arrow), + morty.change, "raise_right_hand", two_neuron + ) + self.play( + ApplyMethod(two_neuron.set_fill, WHITE, 1, **kwargs), + ChangingDecimal( + two_decimal, + lambda a : interpolate(two_activation, 1, a), + num_decimal_points = 1, + ), + UpdateFromFunc( + two_decimal, + lambda m : m.highlight(WHITE if m.number < 0.8 else BLACK), + ), + ShowCreation(bright_edges), + ) + self.dither() + self.play( + LaggedStart(ShowCreation, neuron_rects), + Write(seeing_words, run_time = 2), + morty.change, "thinking", seeing_words + ) + self.play( + ShowCreation(two_neuron_rect), + Write(thinking_words, run_time = 2), + morty.look_at, thinking_words + ) + self.dither() + self.play(LaggedStart(FadeOut, VGroup( + neuron_rects, two_neuron_rect, + seeing_words, thinking_words, + words, morty + ))) diff --git a/topics/geometry.py b/topics/geometry.py index 03da0c3e..1c867777 100644 --- a/topics/geometry.py +++ b/topics/geometry.py @@ -155,6 +155,7 @@ class Line(VMobject): def put_start_and_end_on(self, new_start, new_end): self.start = new_start self.end = new_end + self.buff = 0 self.generate_points() return From f15f5d153e38c6ea76f48b8c462044176d53c900 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 20:16:16 -0700 Subject: [PATCH 22/43] Remove cleanup redundancy --- animation/simple_animations.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/animation/simple_animations.py b/animation/simple_animations.py index 2aef84dc..0f7a9299 100644 --- a/animation/simple_animations.py +++ b/animation/simple_animations.py @@ -152,11 +152,6 @@ class ShowCreationThenDestruction(ShowPassingFlash): "run_time" : 1, } - def clean_up(self, *args, **kwargs): - ShowPassingFlash.clean_up(self, *args, **kwargs) - for submob, start_submob in self.get_all_families_zipped(): - submob.pointwise_become_partial(start_submob, 0, 1) - class MoveAlongPath(Animation): def __init__(self, mobject, vmobject, **kwargs): digest_config(self, kwargs, locals()) @@ -335,9 +330,9 @@ class LaggedStart(Animation): anim.update(alpha) return self - # def clean_up(self, *args, **kwargs): - # for anim in self.subanimations: - # anim.clean_up(*args, **kwargs) + def clean_up(self, *args, **kwargs): + for anim in self.subanimations: + anim.clean_up(*args, **kwargs) class DelayByOrder(Animation): """ From 24d6c7bbef76131dc5cf5a85a6b1624447ccfcbc Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 24 Oct 2017 20:16:25 -0700 Subject: [PATCH 23/43] More WalkThroughTwoExample progress in nn/part3 --- nn/part3.py | 159 +++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 146 insertions(+), 13 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 8704625f..aec51355 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -559,6 +559,10 @@ class WalkThroughTwoExample(ShowAveragingCost): self.three_ways_to_increase() self.note_connections_to_brightest_neurons() self.fire_together_wire_together() + self.show_desired_increase_to_previous_neurons() + self.only_keeping_track_of_changes() + self.show_other_output_neurons() + self.show_recursion() def show_single_example(self): two_vect = get_organized_images()[2][0] @@ -867,7 +871,7 @@ class WalkThroughTwoExample(ShowAveragingCost): increase_words = VGroup( TextMobject("Increase", "$b$"), TextMobject("Increase", "$w_i$"), - TextMobject("Increase", "$a_i$"), + TextMobject("Change", "$a_i$"), ) for words in increase_words: words.highlight_by_tex_to_color_map({ @@ -962,10 +966,11 @@ class WalkThroughTwoExample(ShowAveragingCost): two_decimal = self.two_decimal two_activation = two_decimal.number - edge_animation = LaggedStart( - ShowCreationThenDestruction, bright_edges, - lag_ratio = 0.7 - ) + def get_edge_animation(): + return LaggedStart( + ShowCreationThenDestruction, bright_edges, + lag_ratio = 0.7 + ) neuron_arrows = VGroup(*[ Vector(MED_LARGE_BUFF*RIGHT).next_to(n, LEFT) for n in bright_neurons @@ -979,9 +984,11 @@ class WalkThroughTwoExample(ShowAveragingCost): )) two_neuron_rect = SurroundingRectangle(two_neuron) seeing_words = TextMobject("Seeing a 2") + seeing_words.scale(0.8) thinking_words = TextMobject("Thinking about a 2") + thinking_words.scale(0.8) seeing_words.next_to(neuron_rects, UP) - thinking_words.next_to(two_neuron_rect, UP, aligned_edge = LEFT) + thinking_words.next_to(two_neuron_arrow, RIGHT) morty = Mortimer() morty.scale(0.8) @@ -993,7 +1000,6 @@ class WalkThroughTwoExample(ShowAveragingCost): """) words.to_edge(RIGHT) - self.revert_to_original_skipping_status() self.play(FadeIn(morty)) self.play( Write(words), @@ -1001,20 +1007,20 @@ class WalkThroughTwoExample(ShowAveragingCost): ) self.play(Blink(morty)) self.play( - edge_animation, + get_edge_animation(), morty.change, "pondering", bright_edges ) - self.play(edge_animation) + self.play(get_edge_animation()) self.play( LaggedStart(GrowArrow, neuron_arrows), - edge_animation, + get_edge_animation(), ) self.play( GrowArrow(two_neuron_arrow), morty.change, "raise_right_hand", two_neuron ) self.play( - ApplyMethod(two_neuron.set_fill, WHITE, 1, **kwargs), + ApplyMethod(two_neuron.set_fill, WHITE, 1), ChangingDecimal( two_decimal, lambda a : interpolate(two_activation, 1, a), @@ -1024,7 +1030,8 @@ class WalkThroughTwoExample(ShowAveragingCost): two_decimal, lambda m : m.highlight(WHITE if m.number < 0.8 else BLACK), ), - ShowCreation(bright_edges), + LaggedStart(ShowCreation, bright_edges), + run_time = 2, ) self.dither() self.play( @@ -1032,6 +1039,7 @@ class WalkThroughTwoExample(ShowAveragingCost): Write(seeing_words, run_time = 2), morty.change, "thinking", seeing_words ) + self.dither() self.play( ShowCreation(two_neuron_rect), Write(thinking_words, run_time = 2), @@ -1041,8 +1049,133 @@ class WalkThroughTwoExample(ShowAveragingCost): self.play(LaggedStart(FadeOut, VGroup( neuron_rects, two_neuron_rect, seeing_words, thinking_words, - words, morty + words, morty, + neuron_arrows, two_neuron_arrow, + bright_edges, bright_neurons, ))) + self.play( + ApplyMethod(two_neuron.set_fill, WHITE, two_activation), + ChangingDecimal( + two_decimal, + lambda a : interpolate(1, two_activation, a), + num_decimal_points = 1, + ), + UpdateFromFunc( + two_decimal, + lambda m : m.highlight(WHITE if m.number < 0.8 else BLACK), + ), + ) + + def show_desired_increase_to_previous_neurons(self): + increase_words = self.increase_words + two_neuron = self.two_neuron + edges = two_neuron.edges_in + prev_neurons = self.network_mob.layers[-2].neurons + + positive_arrows = VGroup() + negative_arrows = VGroup() + positive_edges = VGroup() + negative_edges = VGroup() + positive_neurons = VGroup() + negative_neurons = VGroup() + for neuron, edge in zip(prev_neurons, edges): + value = edge.get_stroke_width() + if Color(edge.get_stroke_color()) == Color(self.negative_edge_color): + value *= -1 + arrow = Vector(0.25*value*UP, color = edge.get_color()) + arrow.stretch_to_fit_height(neuron.get_height()) + arrow.move_to(neuron.get_left()) + arrow.shift(SMALL_BUFF*LEFT) + if value > 0: + positive_arrows.add(arrow) + positive_edges.add(edge) + positive_neurons.add(neuron) + else: + negative_arrows.add(arrow) + negative_edges.add(edge) + negative_neurons.add(neuron) + + added_words = TextMobject("in proportion to $w_i$") + added_words.highlight(self.w_terms.get_color()) + added_words.next_to( + increase_words[-1], DOWN, + SMALL_BUFF, aligned_edge = LEFT + ) + + self.play(LaggedStart( + ApplyFunction, prev_neurons, + lambda neuron : ( + lambda m : m.scale_in_place(0.5).highlight(YELLOW), + neuron + ), + rate_func = wiggle + )) + self.dither() + for positive in [True, False]: + if positive: + arrows = positive_arrows + edges = positive_edges + neurons = positive_neurons + color = self.positive_edge_color + else: + arrows = negative_arrows + edges = negative_edges + neurons = negative_neurons + color = self.negative_edge_color + self.play( + LaggedStart( + Transform, edges, + lambda mob : ( + mob, + Dot( + mob.get_center(), + stroke_color = edges[0].get_color(), + stroke_width = 1, + radius = 0.25*SMALL_BUFF, + fill_opacity = 0 + ) + ), + rate_func = there_and_back + ), + neurons.set_stroke, color, 3, + ) + self.play( + LaggedStart(GrowArrow, arrows), + ApplyMethod( + neurons.set_fill, color, 1, + rate_func = there_and_back, + ) + ) + self.dither() + self.play(Write(added_words, run_time = 1)) + + self.set_variables_as_attrs( + in_proportion_to_w = added_words, + prev_neuron_arrows = VGroup(positive_arrows, negative_arrows), + ) + + def only_keeping_track_of_changes(self): + arrows = self.prev_neuron_arrows + prev_neurons = self.network_mob.layers[-2].neurons + rect = SurroundingRectangle(VGroup(arrows, prev_neurons)) + + words = TextMobject("No direct influence") + words.next_to(rect, UP) + + self.revert_to_original_skipping_status() + self.play(ShowCreation(rect)) + self.play(Write(words)) + self.dither() + self.play(FadeOut(VGroup(words, rect))) + + def show_other_output_neurons(self): + two_neuron = self.two_neuron + two_decimal = self.two_decimal + two_edges = two_neuron.edges_in + + + def show_recursion(self): + pass From fae819695a80888b9c06b42ec3cae5b77155d6e3 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Wed, 25 Oct 2017 14:20:45 -0700 Subject: [PATCH 24/43] There's some (as of yet unresolved) bug associated with fill colors when they become negative during an animation --- camera.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/camera.py b/camera.py index ba67dd50..b298ae33 100644 --- a/camera.py +++ b/camera.py @@ -141,15 +141,21 @@ class Camera(object): def get_pen_and_fill(self, vmobject): pen = aggdraw.Pen( - self.get_stroke_color(vmobject).get_hex_l(), + self.color_to_hex_l(self.get_stroke_color(vmobject)), max(vmobject.stroke_width, 0) ) fill = aggdraw.Brush( - self.get_fill_color(vmobject).get_hex_l(), + self.color_to_hex_l(self.get_fill_color(vmobject)), opacity = int(255*vmobject.get_fill_opacity()) ) return (pen, fill) + def color_to_hex_l(self, color): + try: + return color.get_hex_l() + except: + return Color(BLACK).get_hex_l() + def get_stroke_color(self, vmobject): return vmobject.get_stroke_color() From 4ea7a29628495ea7e4719952b1b88c299eded780 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Wed, 25 Oct 2017 14:21:12 -0700 Subject: [PATCH 25/43] Finished WalkThroughTwoExample in nn/part3 --- mobject/vectorized_mobject.py | 6 +- nn/part3.py | 233 +++++++++++++++++++++++++++++++--- 2 files changed, 216 insertions(+), 23 deletions(-) diff --git a/mobject/vectorized_mobject.py b/mobject/vectorized_mobject.py index 87f8205a..fcaa5a30 100644 --- a/mobject/vectorized_mobject.py +++ b/mobject/vectorized_mobject.py @@ -97,13 +97,13 @@ class VMobject(Mobject): def get_fill_color(self): try: - self.fill_rgb = np.clip(self.fill_rgb, 0, 1) + self.fill_rgb = np.clip(self.fill_rgb, 0.0, 1.0) return Color(rgb = self.fill_rgb) except: return Color(WHITE) def get_fill_opacity(self): - return self.fill_opacity + return np.clip(self.fill_opacity, 0, 1) def get_stroke_color(self): try: @@ -113,7 +113,7 @@ class VMobject(Mobject): return Color(WHITE) def get_stroke_width(self): - return self.stroke_width + return max(0, self.stroke_width) def get_color(self): if self.fill_opacity == 0: diff --git a/nn/part3.py b/nn/part3.py index aec51355..47ffdd3c 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -537,7 +537,6 @@ class ShowAveragingCost(PreviewLearning): self.curr_image = image - class WalkThroughTwoExample(ShowAveragingCost): CONFIG = { "random_seed" : 0, @@ -548,12 +547,10 @@ class WalkThroughTwoExample(ShowAveragingCost): self.setup_bases() def construct(self): - self.force_skipping() - self.setup_network() self.setup_diff_words() self.show_single_example() - # self.single_example_influencing_weights() + self.single_example_influencing_weights() self.expand_last_layer() self.show_activation_formula() self.three_ways_to_increase() @@ -591,7 +588,6 @@ class WalkThroughTwoExample(ShowAveragingCost): run_time = 1, ) - self.play( two.next_to, edge_groups[0].get_corner(DOWN+RIGHT), DOWN, adjust_edge_group_anim(edge_groups[0]) @@ -630,6 +626,7 @@ class WalkThroughTwoExample(ShowAveragingCost): mover.save_state() mover.generate_target() mover.target.scale_in_place(2) + neurons[2].save_state() neurons.target.to_edge(DOWN, MED_LARGE_BUFF) output_labels.target.next_to(neurons.target, RIGHT, MED_SMALL_BUFF) @@ -733,6 +730,30 @@ class WalkThroughTwoExample(ShowAveragingCost): ) self.dither() + #Show changing activations + anims = [] + def get_decimal_update(start, end): + return lambda a : interpolate(start, end, a) + for i in range(10): + target = 1.0 if i == 2 else 0.01 + anims += [neurons[i].set_fill, WHITE, target] + decimal = self.decimals[i] + anims.append(ChangingDecimal( + decimal, + get_decimal_update(decimal.number, target), + num_decimal_points = 1 + )) + anims.append(UpdateFromFunc( + self.decimals[i], + lambda m : m.set_fill(WHITE if m.number < 0.8 else BLACK) + )) + + self.play( + *anims, + run_time = 3, + rate_func = there_and_back + ) + two_rect = rects[2] eight_rect = rects[8].copy() non_two_rects = VGroup(*[r for r in rects if r is not two_rect]) @@ -928,7 +949,7 @@ class WalkThroughTwoExample(ShowAveragingCost): self.play(LaggedStart( ApplyFunction, edges, lambda edge : ( - lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + lambda m : m.rotate_in_place(np.pi/12).set_stroke(YELLOW), edge ), rate_func = wiggle @@ -944,6 +965,10 @@ class WalkThroughTwoExample(ShowAveragingCost): ReplacementTransform(bright_neurons[0].copy(), a_terms[0]), ShowCreation(terms_rect) ) + self.dither() + for x in range(2): + self.play(LaggedStart(ShowCreationThenDestruction, bright_edges)) + self.play(LaggedStart(ShowCreation, bright_edges)) self.play(FadeOut(terms_rect)) self.dither() self.play( @@ -1074,18 +1099,17 @@ class WalkThroughTwoExample(ShowAveragingCost): positive_arrows = VGroup() negative_arrows = VGroup() + all_arrows = VGroup() positive_edges = VGroup() negative_edges = VGroup() positive_neurons = VGroup() negative_neurons = VGroup() for neuron, edge in zip(prev_neurons, edges): - value = edge.get_stroke_width() - if Color(edge.get_stroke_color()) == Color(self.negative_edge_color): - value *= -1 - arrow = Vector(0.25*value*UP, color = edge.get_color()) - arrow.stretch_to_fit_height(neuron.get_height()) + value = self.get_edge_value(edge) + arrow = self.get_neuron_nudge_arrow(edge) arrow.move_to(neuron.get_left()) arrow.shift(SMALL_BUFF*LEFT) + all_arrows.add(arrow) if value > 0: positive_arrows.add(arrow) positive_edges.add(edge) @@ -1148,10 +1172,11 @@ class WalkThroughTwoExample(ShowAveragingCost): ) self.dither() self.play(Write(added_words, run_time = 1)) + self.play(prev_neurons.set_stroke, WHITE, 2) self.set_variables_as_attrs( in_proportion_to_w = added_words, - prev_neuron_arrows = VGroup(positive_arrows, negative_arrows), + prev_neuron_arrows = all_arrows, ) def only_keeping_track_of_changes(self): @@ -1162,7 +1187,6 @@ class WalkThroughTwoExample(ShowAveragingCost): words = TextMobject("No direct influence") words.next_to(rect, UP) - self.revert_to_original_skipping_status() self.play(ShowCreation(rect)) self.play(Write(words)) self.dither() @@ -1171,16 +1195,185 @@ class WalkThroughTwoExample(ShowAveragingCost): def show_other_output_neurons(self): two_neuron = self.two_neuron two_decimal = self.two_decimal + two_arrow = self.two_arrow + two_label = self.two_label two_edges = two_neuron.edges_in - + + prev_neurons = self.network_mob.layers[-2].neurons + neurons = self.network_mob.layers[-1].neurons + prev_neuron_arrows = self.prev_neuron_arrows + arrows_to_fade = VGroup(prev_neuron_arrows) + + output_labels = self.network_mob.output_labels + quads = zip(neurons, self.decimals, self.arrows, output_labels) + + self.play( + two_neuron.restore, + two_decimal.scale, 0.5, + two_decimal.move_to, two_neuron.saved_state, + two_arrow.scale, 0.5, + two_arrow.next_to, two_neuron.saved_state, RIGHT, 0.5*SMALL_BUFF, + two_label.scale, 0.5, + two_label.next_to, two_neuron.saved_state, RIGHT, 1.5*SMALL_BUFF, + FadeOut(VGroup(self.lhs, self.rhs)), + *[e.restore for e in two_edges] + ) + for neuron, decimal, arrow, label in quads[:2]: + plusses = VGroup() + new_arrows = VGroup() + for edge, prev_arrow in zip(neuron.edges_in, prev_neuron_arrows): + plus = TexMobject("+").scale(0.5) + plus.move_to(prev_arrow) + plus.shift(2*SMALL_BUFF*LEFT) + new_arrow = self.get_neuron_nudge_arrow(edge) + new_arrow.move_to(plus) + new_arrow.shift(2*SMALL_BUFF*LEFT) + plusses.add(plus) + new_arrows.add(new_arrow) + + self.play( + FadeIn(VGroup(neuron, decimal, arrow, label)), + LaggedStart(ShowCreation, neuron.edges_in), + ) + self.play( + ReplacementTransform(neuron.edges_in.copy(), new_arrows), + Write(plusses, run_time = 2) + ) + + arrows_to_fade.add(new_arrows, plusses) + prev_neuron_arrows = new_arrows + + all_dots_plus = VGroup() + for arrow in prev_neuron_arrows: + dots_plus = TexMobject("\\cdots +") + dots_plus.scale(0.5) + dots_plus.move_to(arrow.get_center(), RIGHT) + dots_plus.shift(2*SMALL_BUFF*LEFT) + all_dots_plus.add(dots_plus) + arrows_to_fade.add(all_dots_plus) + + self.play( + LaggedStart( + FadeIn, VGroup(*it.starmap(VGroup, quads[-7:])), + ), + LaggedStart( + FadeIn, VGroup(*[n.edges_in for n in neurons[-7:]]) + ), + Write(all_dots_plus), + run_time = 3, + ) + self.dither(2) + + def squish(p): + return p[1]*UP + self.play( + arrows_to_fade.apply_function, squish, + arrows_to_fade.move_to, prev_neurons, + ) def show_recursion(self): - pass - - - - - + network_start = VGroup(*it.chain( + self.network_mob.edge_groups[1], + self.network_mob.layers[1], + self.network_mob.edge_groups[0], + self.network_mob.layers[0], + )) + words_to_fade = VGroup( + self.increase_words, + self.in_proportion_to_w, + self.in_proportion_to_a, + ) + + self.play( + FadeOut(words_to_fade), + LaggedStart(FadeIn, network_start, run_time = 3) + ) + self.dither() + for i in 1, 0: + edges = self.network_mob.edge_groups[i] + self.play(LaggedStart( + ApplyFunction, edges, + lambda edge : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + edge + ), + rate_func = wiggle + )) + self.dither() + + #### + + def get_neuron_nudge_arrow(self, edge): + value = self.get_edge_value(edge) + height = np.sign(value)*0.1 + 0.1*value + arrow = Vector(height*UP, color = edge.get_color()) + return arrow + + def get_edge_value(self, edge): + value = edge.get_stroke_width() + if Color(edge.get_stroke_color()) == Color(self.negative_edge_color): + value *= -1 + return value + +class NotANeuroScientist(TeacherStudentsScene): + def construct(self): + quote = TextMobject("``Neurons that fire together wire together''") + quote.to_edge(UP) + self.add(quote) + asterisks = TextMobject("***") + asterisks.next_to(quote.get_corner(UP+RIGHT), RIGHT, SMALL_BUFF) + asterisks.highlight(BLUE) + + brain = SVGMobject(file_name = "brain") + brain.scale_to_fit_height(1.5) + self.add(brain) + double_arrow = DoubleArrow(LEFT, RIGHT) + double_arrow.next_to(brain, RIGHT) + q_marks = TextMobject("???") + q_marks.next_to(double_arrow, UP) + + network = NetworkMobject(Network(sizes = [6, 4, 4, 5])) + network.scale_to_fit_height(1.5) + network.next_to(double_arrow, RIGHT) + + group = VGroup(brain, double_arrow, q_marks, network) + group.next_to(self.students, UP, buff = 1.5) + self.add(group) + self.add(ContinualEdgeUpdate(network)) + + rect = SurroundingRectangle(group) + no_claim_words = TextMobject("No claims here...") + no_claim_words.next_to(rect, UP) + no_claim_words.highlight(YELLOW) + + brain_outline = brain.copy() + brain_outline.set_fill(opacity = 0) + brain_outline.set_stroke(BLUE, 3) + brain_anim = ShowCreationThenDestruction(brain_outline) + + words = TextMobject("Definitely not \\\\ a neuroscientist") + words.next_to(self.teacher, UP, buff = 1.5) + words.shift_onto_screen() + arrow = Arrow(words.get_bottom(), self.teacher.get_top()) + + self.play( + Write(words), + GrowArrow(arrow), + self.teacher.change, "guilty", words, + run_time = 1, + ) + self.change_student_modes(*3*["sassy"]) + self.play( + ShowCreation(rect), + Write(no_claim_words, run_time = 1), + brain_anim + ) + self.dither() + self.play(brain_anim) + self.play(Write(asterisks, run_time = 1)) + for x in range(2): + self.play(brain_anim) + self.dither() From 4442acd3c94b6d885e28bdfe339d493b0d8798f9 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 12:29:52 -0700 Subject: [PATCH 26/43] OrganizeDataIntoMiniBatches in nn/part3 --- nn/part3.py | 550 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 531 insertions(+), 19 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 47ffdd3c..8f1fbe5c 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -1339,7 +1339,11 @@ class NotANeuroScientist(TeacherStudentsScene): group = VGroup(brain, double_arrow, q_marks, network) group.next_to(self.students, UP, buff = 1.5) self.add(group) - self.add(ContinualEdgeUpdate(network)) + self.add(ContinualEdgeUpdate( + network, + stroke_width_exp = 0.5, + color = [BLUE, RED], + )) rect = SurroundingRectangle(group) no_claim_words = TextMobject("No claims here...") @@ -1370,29 +1374,537 @@ class NotANeuroScientist(TeacherStudentsScene): ) self.dither() self.play(brain_anim) + self.play(FocusOn(asterisks)) self.play(Write(asterisks, run_time = 1)) for x in range(2): self.play(brain_anim) self.dither() - - - - - - - - - - - - - - - - - - +class ConstructGradientFromAllTrainingExamples(Scene): + CONFIG = { + "image_height" : 0.9, + "eyes_height" : 0.25, + "n_examples" : 6, + "change_scale_val" : 0.8, + } + def construct(self): + self.setup_grid() + self.setup_weights() + self.show_two_requesting_changes() + self.show_all_examples_requesting_changes() + self.average_together() + self.collapse_into_gradient_vector() + + def setup_grid(self): + h_lines = VGroup(*[ + Line(LEFT, RIGHT).scale(0.85*SPACE_WIDTH) + for x in range(6) + ]) + h_lines.arrange_submobjects(DOWN, buff = 1) + h_lines.set_stroke(LIGHT_GREY, 2) + h_lines.to_edge(DOWN, buff = MED_LARGE_BUFF) + h_lines.to_edge(LEFT, buff = 0) + + v_lines = VGroup(*[ + Line(UP, DOWN).scale(SPACE_HEIGHT - MED_LARGE_BUFF) + for x in range(self.n_examples + 1) + ]) + v_lines.arrange_submobjects(RIGHT, buff = 1.4) + v_lines.set_stroke(LIGHT_GREY, 2) + v_lines.to_edge(LEFT, buff = 2) + + # self.add(h_lines, v_lines) + self.h_lines = h_lines + self.v_lines = v_lines + + def setup_weights(self): + weights = VGroup(*map(TexMobject, [ + "w_0", "w_1", "w_2", "\\vdots", "w_{13{,}001}" + ])) + for i, weight in enumerate(weights): + weight.move_to(self.get_grid_position(i, 0)) + weights.to_edge(LEFT, buff = MED_SMALL_BUFF) + + brace = Brace(weights, RIGHT) + weights_words = brace.get_text("All weights and biases") + + self.add(weights, brace, weights_words) + self.set_variables_as_attrs( + weights, brace, weights_words, + dots = weights[-2] + ) + + def show_two_requesting_changes(self): + two = self.get_example(get_organized_images()[2][0], 0) + self.two = two + self.add(two) + + self.two_changes = VGroup() + for i in range(3) + [4]: + weight = self.weights[i] + bubble, change = self.get_requested_change_bubble(two) + weight.save_state() + weight.generate_target() + weight.target.next_to(two, RIGHT, aligned_edge = DOWN) + + self.play( + MoveToTarget(weight), + two.eyes.look_at_anim(weight.target), + FadeIn(bubble), + Write(change, run_time = 1), + ) + if random.random() < 0.5: + self.play(two.eyes.blink_anim()) + else: + self.dither() + if i == 0: + added_anims = [ + FadeOut(self.brace), + FadeOut(self.weights_words), + ] + elif i == 4: + dots_copy = self.dots.copy() + added_anims = [ + dots_copy.move_to, + self.get_grid_position(3, 0) + ] + self.first_column_dots = dots_copy + else: + added_anims = [] + self.play( + FadeOut(bubble), + weight.restore, + two.eyes.look_at_anim(weight.saved_state), + change.restore, + change.scale, self.change_scale_val, + change.move_to, self.get_grid_position(i, 0), + *added_anims + ) + self.two_changes.add(change) + self.dither() + + def show_all_examples_requesting_changes(self): + training_data, validation_data, test_data = load_data_wrapper() + data = training_data[:self.n_examples-1] + examples = VGroup(*[ + self.get_example(t[0], j) + for t, j in zip(data, it.count(1)) + ]) + h_dots = TexMobject("\\dots") + h_dots.next_to(examples, RIGHT, MED_LARGE_BUFF) + more_h_dots = VGroup(*[ + TexMobject("\\dots").move_to( + self.get_grid_position(i, self.n_examples) + ) + for i in range(5) + ]) + more_h_dots.shift(MED_LARGE_BUFF*RIGHT) + more_h_dots[-2].rotate_in_place(-np.pi/4) + more_v_dots = VGroup(*[ + self.dots.copy().move_to( + self.get_grid_position(3, j) + ) + for j in range(1, self.n_examples) + ]) + + changes = VGroup(*[ + self.get_random_decimal().move_to( + self.get_grid_position(i, j) + ) + for i in range(3) + [4] + for j in range(1, self.n_examples) + ]) + for change in changes: + change.scale_in_place(self.change_scale_val) + + self.play( + LaggedStart(FadeIn, examples), + LaggedStart(ShowCreation, self.h_lines), + LaggedStart(ShowCreation, self.v_lines), + Write( + h_dots, + run_time = 2, + rate_func = squish_rate_func(smooth, 0.7, 1) + ) + ) + self.play( + Write(changes), + Write(more_v_dots), + Write(more_h_dots), + *[ + example.eyes.look_at_anim(random.choice(changes)) + for example in examples + ] + ) + for x in range(2): + self.play(random.choice(examples).eyes.blink_anim()) + + k = self.n_examples - 1 + self.change_rows = VGroup(*[ + VGroup(two_change, *changes[k*i:k*(i+1)]) + for i, two_change in enumerate(self.two_changes) + ]) + for i in range(3) + [-1]: + self.change_rows[i].add(more_h_dots[i]) + + self.all_eyes = VGroup(*[ + m.eyes for m in [self.two] + list(examples) + ]) + + self.set_variables_as_attrs( + more_h_dots, more_v_dots, + h_dots, changes, + ) + + def average_together(self): + rects = VGroup() + arrows = VGroup() + averages = VGroup() + for row in self.change_rows: + rect = SurroundingRectangle(row) + arrow = Arrow(ORIGIN, RIGHT) + arrow.next_to(rect, RIGHT) + rect.arrow = arrow + average = self.get_colored_decimal(3*np.mean([ + m.number for m in row + if isinstance(m, DecimalNumber) + ])) + average.scale(self.change_scale_val) + average.next_to(arrow, RIGHT) + row.target = VGroup(average) + + rects.add(rect) + arrows.add(arrow) + averages.add(average) + + words = TextMobject("Average over \\\\ all training data") + words.scale(0.8) + words.to_corner(UP+RIGHT) + arrow_to_averages = Arrow( + words.get_bottom(), averages.get_top(), + color = WHITE + ) + + dots = self.dots.copy() + dots.move_to(VGroup(*averages[-2:])) + + look_at_anims = self.get_look_at_anims + + self.play(Write(words, run_time = 1), *look_at_anims(words)) + self.play(ShowCreation(rects[0]), *look_at_anims(rects[0])) + self.play( + ReplacementTransform(rects[0].copy(), arrows[0]), + rects[0].set_stroke, WHITE, 1, + ReplacementTransform( + self.change_rows[0].copy(), + self.change_rows[0].target + ), + *look_at_anims(averages[0]) + ) + self.play(GrowArrow(arrow_to_averages)) + self.play( + LaggedStart(ShowCreation, VGroup(*rects[1:])), + *look_at_anims(rects[1]) + ) + self.play( + LaggedStart( + ReplacementTransform, VGroup(*rects[1:]).copy(), + lambda m : (m, m.arrow), + lag_ratio = 0.7, + ), + VGroup(*rects[1:]).set_stroke, WHITE, 1, + LaggedStart( + ReplacementTransform, VGroup(*self.change_rows[1:]).copy(), + lambda m : (m, m.target), + lag_ratio = 0.7, + ), + Write(dots), + *look_at_anims(averages[1]) + ) + self.blink(3) + self.dither() + + averages.add(dots) + self.set_variables_as_attrs( + rects, arrows, averages, + arrow_to_averages + ) + + def collapse_into_gradient_vector(self): + averages = self.averages + lb, rb = brackets = TexMobject("[]") + brackets.scale(2) + brackets.stretch_to_fit_height(1.2*averages.get_height()) + lb.next_to(averages, LEFT, SMALL_BUFF) + rb.next_to(averages, RIGHT, SMALL_BUFF) + brackets.set_fill(opacity = 0) + + shift_vect = 2*LEFT + + lhs = TexMobject( + "-", "\\nabla", "C(", + "w_1,", "w_2,", "\\dots", "w_{13{,}001}", + ")", "=" + ) + lhs.next_to(lb, LEFT) + lhs.shift(shift_vect) + minus = lhs[0] + w_terms = lhs.get_parts_by_tex("w_") + dots_term = lhs.get_part_by_tex("dots") + eta = TexMobject("\\eta") + eta.move_to(minus, RIGHT) + eta.highlight(MAROON_B) + + to_fade = VGroup(*it.chain( + self.h_lines, self.v_lines, + self.more_h_dots, self.more_v_dots, + self.change_rows, + self.first_column_dots, + self.rects, + self.arrows, + )) + arrow = self.arrow_to_averages + + self.play(LaggedStart(FadeOut, to_fade)) + self.play( + brackets.shift, shift_vect, + brackets.set_fill, WHITE, 1, + averages.shift, shift_vect, + Transform(arrow, Arrow( + arrow.get_start(), + arrow.get_end() + shift_vect, + buff = 0, + color = arrow.get_color(), + )), + FadeIn(VGroup(*lhs[:3])), + FadeIn(VGroup(*lhs[-2:])), + *self.get_look_at_anims(lhs) + ) + self.play( + ReplacementTransform(self.weights, w_terms), + ReplacementTransform(self.dots, dots_term), + *self.get_look_at_anims(w_terms) + ) + self.blink(2) + self.play( + GrowFromCenter(eta), + minus.shift, MED_SMALL_BUFF*LEFT + ) + self.dither() + + #### + + def get_example(self, in_vect, index): + result = MNistMobject(in_vect) + result.scale_to_fit_height(self.image_height) + + eyes = Eyes(result, height = self.eyes_height) + result.eyes = eyes + result.add(eyes) + result.move_to(self.get_grid_position(0, index)) + result.to_edge(UP, buff = LARGE_BUFF) + return result + + def get_grid_position(self, i, j): + x = VGroup(*self.v_lines[j:j+2]).get_center()[0] + y = VGroup(*self.h_lines[i:i+2]).get_center()[1] + return x*RIGHT + y*UP + + def get_requested_change_bubble(self, example_mob): + change = self.get_random_decimal() + words = TextMobject("Change by") + change.next_to(words, RIGHT) + change.save_state() + content = VGroup(words, change) + + bubble = SpeechBubble(height = 1.5, width = 3) + bubble.add_content(content) + group = VGroup(bubble, content) + group.shift( + example_mob.get_right() + SMALL_BUFF*RIGHT \ + -bubble.get_corner(DOWN+LEFT) + ) + + return VGroup(bubble, words), change + + def get_random_decimal(self): + return self.get_colored_decimal( + 0.3*(random.random() - 0.5) + ) + + def get_colored_decimal(self, number): + result = DecimalNumber(number) + if result.number > 0: + plus = TexMobject("+") + plus.next_to(result, LEFT, SMALL_BUFF) + result.add_to_back(plus) + result.highlight(BLUE) + else: + result.highlight(RED) + return result + + def get_look_at_anims(self, mob): + return [eyes.look_at_anim(mob) for eyes in self.all_eyes] + + def blink(self, n): + for x in range(n): + self.play(random.choice(self.all_eyes).blink_anim()) + +class OpenCloseSGD(Scene): + def construct(self): + term = TexMobject( + "\\langle", "\\text{Stochastic gradient descent}", + "\\rangle" + ) + alt_term0 = TexMobject("\\langle /") + alt_term0.move_to(term[0], RIGHT) + + term.save_state() + center = term.get_center() + term[0].move_to(center, RIGHT) + term[2].move_to(center, LEFT) + term[1].scale(0.0001).move_to(center) + + self.play(term.restore) + self.dither(2) + self.play(Transform(term[0], alt_term0)) + self.dither(2) + +class OrganizeDataIntoMiniBatches(Scene): + CONFIG = { + "n_rows" : 5, + "n_cols" : 12, + "example_height" : 1, + } + def construct(self): + self.add_examples() + self.shuffle_examples() + self.divide_into_minibatches() + self.one_step_per_batch() + + def add_examples(self): + examples = self.get_examples() + self.arrange_examples_in_grid(examples) + for example in examples: + example.save_state() + random.shuffle(examples.submobjects) + self.arrange_examples_in_grid(examples) + + self.play(LaggedStart( + FadeIn, examples, + lag_ratio = 0.2, + run_time = 4 + )) + self.dither() + + self.examples = examples + + def shuffle_examples(self): + self.play(LaggedStart( + ApplyMethod, self.examples, + lambda m : (m.restore,), + lag_ratio = 0.3, + run_time = 3, + path_arc = np.pi/3, + )) + self.dither() + + def divide_into_minibatches(self): + examples = self.examples + examples.sort_submobjects(lambda p : -p[1]) + rows = Group(*[ + Group(*examples[i*self.n_cols:(i+1)*self.n_cols]) + for i in range(self.n_rows) + ]) + + mini_batches_words = TextMobject("``Mini-batches''") + mini_batches_words.to_edge(UP) + mini_batches_words.highlight(YELLOW) + + self.play( + rows.space_out_submobjects, 1.5, + rows.to_edge, UP, 1.5, + Write(mini_batches_words, run_time = 1) + ) + + rects = VGroup(*[ + SurroundingRectangle( + row, + stroke_width = 0, + fill_color = YELLOW, + fill_opacity = 0.25, + ) + for row in rows + ]) + self.play(LaggedStart( + FadeIn, rects, + lag_ratio = 0.7, + rate_func = there_and_back + )) + self.dither() + + self.set_variables_as_attrs(rows, rects, mini_batches_words) + + def one_step_per_batch(self): + rows = self.rows + brace = Brace(rows[0], UP, buff = SMALL_BUFF) + text = brace.get_text( + "Compute gradient descent step (using backprop)", + buff = SMALL_BUFF + ) + def indicate_row(row): + row.sort_submobjects(lambda p : p[0]) + return LaggedStart( + ApplyFunction, row, + lambda row : ( + lambda m : m.scale_in_place(0.75).highlight(YELLOW), + row + ), + rate_func = wiggle + ) + + self.play( + FadeOut(self.mini_batches_words), + GrowFromCenter(brace), + Write(text, run_time = 2), + ) + self.play(indicate_row(rows[0])) + brace.add(text) + for last_row, row in zip(rows, rows[1:-1]): + self.play( + last_row.shift, UP, + brace.next_to, row, UP, SMALL_BUFF + ) + self.play(indicate_row(row)) + self.dither() + + + ### + + def get_examples(self): + n_examples = self.n_rows*self.n_cols + height = self.example_height + training_data, validation_data, test_data = load_data_wrapper() + return Group(*[ + MNistMobject( + t[0], + rect_kwargs = {"stroke_width" : 2} + ).scale_to_fit_height(height) + for t in training_data[:n_examples] + ]) + # return Group(*[ + # Square( + # color = BLUE, + # stroke_width = 2 + # ).scale_to_fit_height(height) + # for x in range(n_examples) + # ]) + + def arrange_examples_in_grid(self, examples): + examples.arrange_submobjects_in_grid( + n_rows = self.n_rows, + buff = SMALL_BUFF + ) From f95e9c2a17cd56013943800cdaaa3a4affe6c138 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 16:30:54 -0700 Subject: [PATCH 27/43] Just setting up the long SimplestNetworkExample --- nn/part3.py | 170 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 168 insertions(+), 2 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 8f1fbe5c..ff2b20f3 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -1787,11 +1787,13 @@ class OrganizeDataIntoMiniBatches(Scene): self.arrange_examples_in_grid(examples) for example in examples: example.save_state() - random.shuffle(examples.submobjects) + alt_order_examples = VGroup(*examples) + for mob in examples, alt_order_examples: + random.shuffle(mob.submobjects) self.arrange_examples_in_grid(examples) self.play(LaggedStart( - FadeIn, examples, + FadeIn, alt_order_examples, lag_ratio = 0.2, run_time = 4 )) @@ -1906,6 +1908,170 @@ class OrganizeDataIntoMiniBatches(Scene): buff = SMALL_BUFF ) +class SGDSteps(ExternallyAnimatedScene): + pass + +class GradientDescentSteps(ExternallyAnimatedScene): + pass + +class SwimmingInTerms(TeacherStudentsScene): + def construct(self): + terms = VGroup( + TextMobject("Cost surface"), + TextMobject("Stochastic gradient descent"), + TextMobject("Mini-batches"), + TextMobject("Backpropagation"), + ) + terms.arrange_submobjects(DOWN) + terms.to_edge(UP) + self.play( + LaggedStart(FadeIn, terms), + self.get_student_changes(*["horrified"]*3) + ) + self.dither() + self.play( + terms[-1].next_to, self.teacher.get_corner(UP+LEFT), UP, + FadeOut(VGroup(*terms[:-1])), + self.teacher.change, "raise_right_hand", + self.get_student_changes(*["pondering"]*3) + ) + self.dither() + +class BackpropCode(ExternallyAnimatedScene): + pass + +class BackpropCodeAddOn(PiCreatureScene): + def construct(self): + words = TextMobject( + "The code you'd find \\\\ in Nielsen's book" + ) + words.to_corner(DOWN+LEFT) + morty = self.pi_creature + morty.next_to(words, UP) + self.add(words) + for mode in ["pondering", "thinking", "happy"]: + self.play( + morty.change, "pondering", + morty.look, UP+LEFT + ) + self.play(morty.look, DOWN+LEFT) + self.dither(2) + +class CannotFollowCode(TeacherStudentsScene): + def construct(self): + self.student_says( + "I...er...can't follow\\\\ that code at all.", + target_mode = "confused", + student_index = 1 + ) + self.play(self.students[1].change, "sad") + self.change_student_modes( + "angry", "sad", "angry", + look_at_arg = self.teacher.eyes + ) + self.play(self.teacher.change, "hesitant") + self.dither(2) + self.teacher_says( + "Let's get to the \\\\ calculus then", + target_mode = "hooray", + added_anims = [self.get_student_changes(*3*["plain"])], + run_time = 1 + ) + self.dither(2) + +class EOCWrapper(Scene): + def construct(self): + title = TextMobject("Essence of calculus") + title.to_edge(UP) + screen = ScreenRectangle(height = 6) + screen.next_to(title, DOWN) + + self.add(title) + self.play(ShowCreation(screen)) + self.dither() + +class SimplestNetworkExample(Scene): + def construct(self): + self.collapse_ordinary_network() + self.focus_just_on_last_two_layers() + self.label_neurons() + self.show_desired_output() + self.show_cost() + self.show_activation_formula() + self.introduce_z() + self.break_into_computational_graph() + self.show_preceding_layer_in_computational_graph() + self.show_number_lines() + self.ask_about_w_sensitivity() + self.show_derivative_wrt_w() + self.show_chain_of_events() + self.show_chain_rule() + self.compute_derivatives() + self.fire_together_wire_together() + self.show_derivative_wrt_b() + self.show_derivative_wrt_a() + self.show_previous_weight_and_bias() + + def collapse_ordinary_network(self): + pass + + def focus_just_on_last_two_layers(self): + pass + + def label_neurons(self): + pass + + def show_desired_output(self): + pass + + def show_cost(self): + pass + + def show_activation_formula(self): + pass + + def introduce_z(self): + pass + + def break_into_computational_graph(self): + pass + + def show_preceding_layer_in_computational_graph(self): + pass + + def show_number_lines(self): + pass + + def ask_about_w_sensitivity(self): + pass + + def show_derivative_wrt_w(self): + pass + + def show_chain_of_events(self): + pass + + def show_chain_rule(self): + pass + + def compute_derivatives(self): + pass + + def fire_together_wire_together(self): + pass + + def show_derivative_wrt_b(self): + pass + + def show_derivative_wrt_a(self): + pass + + def show_previous_weight_and_bias(self): + pass + + + + From 0d8a713950399895e23516c9597facac99bd1011 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 21:30:24 -0700 Subject: [PATCH 28/43] ChangingDecimal should default to its mobjects number of decimal points --- topics/numerals.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/topics/numerals.py b/topics/numerals.py index 6564a994..87e4ec64 100644 --- a/topics/numerals.py +++ b/topics/numerals.py @@ -46,13 +46,15 @@ class Integer(VGroup): class ChangingDecimal(Animation): CONFIG = { - "num_decimal_points" : 2, + "num_decimal_points" : None, "spare_parts" : 2, "position_update_func" : None, "tracked_mobject" : None, } def __init__(self, decimal_number, number_update_func, **kwargs): digest_config(self, kwargs, locals()) + if self.num_decimal_points is None: + self.num_decimal_points = decimal_number.num_decimal_points decimal_number.add(*[ VectorizedPoint(decimal_number.get_corner(DOWN+LEFT)) for x in range(self.spare_parts)] From b9aec1e907aa68f164507b0d6635ddc6a93604ae Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 21:30:59 -0700 Subject: [PATCH 29/43] Removed condition from Mobject.highlight --- mobject/mobject.py | 10 ++++++++-- mobject/point_cloud_mobject.py | 8 ++------ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/mobject/mobject.py b/mobject/mobject.py index bec10171..6129017e 100644 --- a/mobject/mobject.py +++ b/mobject/mobject.py @@ -399,11 +399,17 @@ class Mobject(object): ## Color functions - def highlight(self, color = YELLOW_C, family = True, condition = None): + def highlight(self, color = YELLOW_C, family = True): """ Condition is function which takes in one arguments, (x, y, z). + Here it just recurses to submobjects, but in subclasses this + should be further implemented based on the the inner workings + of color """ - raise Exception("Not implemented") + if family: + for submob in self.submobjects: + submob.highlight(color, family = family) + return self def gradient_highlight(self, *colors): self.submobject_gradient_highlight(*colors) diff --git a/mobject/point_cloud_mobject.py b/mobject/point_cloud_mobject.py index 1bd855ca..78707575 100644 --- a/mobject/point_cloud_mobject.py +++ b/mobject/point_cloud_mobject.py @@ -30,15 +30,11 @@ class PMobject(Mobject): self.rgbas = np.append(self.rgbas, rgbas, axis = 0) return self - def highlight(self, color = YELLOW_C, family = True, condition = None): + def highlight(self, color = YELLOW_C, family = True): rgba = color_to_rgba(color) mobs = self.family_members_with_points() if family else [self] for mob in mobs: - if condition: - to_change = np.apply_along_axis(condition, 1, mob.points) - mob.rgbas[to_change, :] = rgba - else: - mob.rgbas[:,:] = rgba + mob.rgbas[:,:] = rgba return self def gradient_highlight(self, start_color, end_color): From a92e03a9b891477658aa28204bfab8574c460512 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 21:31:11 -0700 Subject: [PATCH 30/43] First few methods of SimplestNetworkExample --- nn/part3.py | 240 ++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 216 insertions(+), 24 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index ff2b20f3..5e84660d 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -1775,13 +1775,20 @@ class OrganizeDataIntoMiniBatches(Scene): "n_rows" : 5, "n_cols" : 12, "example_height" : 1, + "random_seed" : 0, } def construct(self): + self.frame_duration = 1./24 + self.seed_random_libraries() self.add_examples() self.shuffle_examples() self.divide_into_minibatches() self.one_step_per_batch() + def seed_random_libraries(self): + random.seed(self.random_seed) + np.random.seed(self.random_seed) + def add_examples(self): examples = self.get_examples() self.arrange_examples_in_grid(examples) @@ -1990,8 +1997,11 @@ class EOCWrapper(Scene): self.play(ShowCreation(screen)) self.dither() -class SimplestNetworkExample(Scene): +class SimplestNetworkExample(PreviewLearning): def construct(self): + self.force_skipping() + + self.seed_random_libraries() self.collapse_ordinary_network() self.focus_just_on_last_two_layers() self.label_neurons() @@ -2012,63 +2022,245 @@ class SimplestNetworkExample(Scene): self.show_derivative_wrt_a() self.show_previous_weight_and_bias() + def seed_random_libraries(self): + np.random.seed(0) + random.seed(0) + def collapse_ordinary_network(self): - pass - + network_mob = self.network_mob + config = dict(self.network_mob_config) + config.pop("include_output_labels") + config.update({ + "edge_stroke_width" : 3, + "edge_propogation_color" : YELLOW, + "edge_propogation_time" : 1, + "neuron_radius" : 0.3, + }) + simple_network = Network(sizes = [1, 1, 1, 1]) + simple_network_mob = NetworkMobject(simple_network, **config) + self.color_network_edges() + s_edges = simple_network_mob.edge_groups + for edge, weight_matrix in zip(s_edges, simple_network.weights): + weight = weight_matrix[0][0] + width = 2*abs(weight) + color = BLUE if weight > 0 else RED + edge.set_stroke(color, width) + + def edge_collapse_anims(edges, left_attachment_target): + return [ + ApplyMethod( + e.put_start_and_end_on_with_projection, + left_attachment_target.get_right(), + e.get_end() + ) + for e in edges + ] + + neuron = simple_network_mob.layers[0].neurons[0] + self.play( + ReplacementTransform(network_mob.layers[0], neuron), + *edge_collapse_anims(network_mob.edge_groups[0], neuron) + ) + for i, layer in enumerate(network_mob.layers[1:]): + neuron = simple_network_mob.layers[i+1].neurons[0] + prev_edges = network_mob.edge_groups[i] + prev_edge_target = simple_network_mob.edge_groups[i] + if i+1 < len(network_mob.edge_groups): + edges = network_mob.edge_groups[i+1] + added_anims = edge_collapse_anims(edges, neuron) + else: + added_anims = [FadeOut(network_mob.output_labels)] + self.play( + ReplacementTransform(layer, neuron), + ReplacementTransform(prev_edges, prev_edge_target), + *added_anims + ) + self.remove(network_mob) + self.add(simple_network_mob) + self.network_mob = simple_network_mob + self.network = self.network_mob.neural_network + self.feed_forward(np.array([0.5])) + self.dither() + def focus_just_on_last_two_layers(self): - pass - + to_fade = VGroup(*it.chain(*zip( + self.network_mob.layers[:2], + self.network_mob.edge_groups[:2], + ))) + for mob in to_fade: + mob.save_state() + self.play(LaggedStart( + ApplyMethod, to_fade, + lambda m : (m.fade, 0.9) + )) + self.dither() + def label_neurons(self): - pass - + neurons = [ + self.network_mob.layers[i].neurons[0] + for i in -1, -2 + ] + decimals = VGroup() + a_labels = VGroup() + a_label_arrows = VGroup() + superscripts = ["L", "L-1"] + superscript_rects = VGroup() + for neuron, superscript in zip(neurons, superscripts): + decimal = self.get_neuron_activation_decimal(neuron) + label = TexMobject("a^{(%s)}"%superscript) + label.next_to(neuron, DOWN, buff = LARGE_BUFF) + superscript_rect = SurroundingRectangle(VGroup(*label[1:])) + arrow = Arrow( + label[0].get_top(), + neuron.get_bottom(), + buff = SMALL_BUFF, + color = WHITE + ) + + decimal.save_state() + decimal.set_fill(opacity = 0) + decimal.move_to(label) + + decimals.add(decimal) + a_labels.add(label) + a_label_arrows.add(arrow) + superscript_rects.add(superscript_rect) + + self.play( + Write(label, run_time = 1), + GrowArrow(arrow), + ) + self.play(decimal.restore) + opacity = neuron.get_fill_opacity() + self.play( + neuron.set_fill, None, 0, + ChangingDecimal( + decimal, + lambda a : interpolate(opacity, 0.01, a) + ), + UpdateFromFunc( + decimal, + lambda d : d.set_fill(WHITE if d.number < 0.8 else BLACK) + ), + run_time = 2, + rate_func = there_and_back, + ) + self.dither() + + not_exponents = TextMobject("Not exponents") + not_exponents.next_to(superscript_rects, DOWN, MED_LARGE_BUFF) + not_exponents.highlight(YELLOW) + + self.play( + LaggedStart( + ShowCreation, superscript_rects, + lag_ratio = 0.8, run_time = 1.5 + ), + Write(not_exponents, run_time = 2) + ) + self.dither() + self.play(*map(FadeOut, [not_exponents, superscript_rects])) + + self.set_variables_as_attrs( + a_labels, a_label_arrows, decimals + ) + def show_desired_output(self): - pass - + neuron = self.network_mob.layers[-1].neurons[0].copy() + neuron.shift(2*RIGHT) + neuron.set_fill(opacity = 1) + decimal = self.get_neuron_activation_decimal(neuron) + + rect = SurroundingRectangle(neuron) + words = TextMobject("Desired \\\\ output") + words.next_to(rect, UP) + VGroup(words, rect).highlight(YELLOW) + + y_label = TexMobject("y") + y_label.next_to(neuron, DOWN, LARGE_BUFF) + y_label.align_to(self.a_labels, DOWN) + y_label_arrow = Arrow( + y_label, neuron, + color = WHITE, + buff = SMALL_BUFF + ) + + self.play(*map(FadeIn, [neuron, decimal])) + self.play( + ShowCreation(rect), + Write(words, run_time = 1) + ) + self.dither() + self.play( + Write(y_label, run_time = 1), + GrowArrow(y_label_arrow) + ) + self.dither() + + self.set_variables_as_attrs( + y_label, y_label_arrow, + desired_output_neuron = neuron, + desired_output_decimal = decimal, + desired_output_rect = rect, + desired_output_words = words, + ) + def show_cost(self): pass - + def show_activation_formula(self): pass - + def introduce_z(self): pass - + def break_into_computational_graph(self): pass - + def show_preceding_layer_in_computational_graph(self): pass - + def show_number_lines(self): pass - + def ask_about_w_sensitivity(self): pass - + def show_derivative_wrt_w(self): pass - + def show_chain_of_events(self): pass - + def show_chain_rule(self): pass - + def compute_derivatives(self): pass - + def fire_together_wire_together(self): pass - + def show_derivative_wrt_b(self): pass - + def show_derivative_wrt_a(self): pass - + def show_previous_weight_and_bias(self): pass - + + ### + + def get_neuron_activation_decimal(self, neuron): + opacity = neuron.get_fill_opacity() + decimal = DecimalNumber(opacity, num_decimal_points = 2) + decimal.scale_to_fit_width(0.85*neuron.get_width()) + if decimal.number > 0.8: + decimal.set_fill(BLACK) + decimal.move_to(neuron) + return decimal + From e5490913a8469739db7e6bfc7cb02f95ded32191 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 26 Oct 2017 23:26:12 -0700 Subject: [PATCH 31/43] Further SimplestNetworkExample practice --- nn/part3.py | 114 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 107 insertions(+), 7 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 5e84660d..ae4d5c35 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -1778,7 +1778,6 @@ class OrganizeDataIntoMiniBatches(Scene): "random_seed" : 0, } def construct(self): - self.frame_duration = 1./24 self.seed_random_libraries() self.add_examples() self.shuffle_examples() @@ -1998,6 +1997,12 @@ class EOCWrapper(Scene): self.dither() class SimplestNetworkExample(PreviewLearning): + CONFIG = { + "random_seed" : 6, + "z_color" : GREEN, + "cost_color" : RED, + "desired_output_color" : YELLOW, + } def construct(self): self.force_skipping() @@ -2023,8 +2028,8 @@ class SimplestNetworkExample(PreviewLearning): self.show_previous_weight_and_bias() def seed_random_libraries(self): - np.random.seed(0) - random.seed(0) + np.random.seed(self.random_seed) + random.seed(self.random_seed) def collapse_ordinary_network(self): network_mob = self.network_mob @@ -2174,7 +2179,6 @@ class SimplestNetworkExample(PreviewLearning): rect = SurroundingRectangle(neuron) words = TextMobject("Desired \\\\ output") words.next_to(rect, UP) - VGroup(words, rect).highlight(YELLOW) y_label = TexMobject("y") y_label.next_to(neuron, DOWN, LARGE_BUFF) @@ -2184,6 +2188,7 @@ class SimplestNetworkExample(PreviewLearning): color = WHITE, buff = SMALL_BUFF ) + VGroup(words, rect, y_label).highlight(self.desired_output_color) self.play(*map(FadeIn, [neuron, decimal])) self.play( @@ -2206,13 +2211,108 @@ class SimplestNetworkExample(PreviewLearning): ) def show_cost(self): - pass + pre_a = self.a_labels[0].copy() + pre_y = self.y_label.copy() + + cost_equation = TexMobject( + "C_0", "(", "\\dots", ")", "=", + "(", "a^{(L)}", "-", "y", ")", "^2" + ) + cost_equation.to_corner(UP+RIGHT) + C0, a, y = [ + cost_equation.get_part_by_tex(tex) + for tex in "C_0", "a^{(L)}", "y" + ] + y.highlight(YELLOW) + + cost_word = TextMobject("Cost") + cost_word.next_to(C0[0], LEFT, LARGE_BUFF) + cost_arrow = Arrow( + cost_word, C0, + buff = SMALL_BUFF + ) + VGroup(C0, cost_word, cost_arrow).highlight(self.cost_color) + + self.play( + ReplacementTransform(pre_a, a), + ReplacementTransform(pre_y, y), + ) + self.play(LaggedStart( + FadeIn, VGroup(*filter( + lambda m : m not in [a, y], + cost_equation + )) + )) + self.dither() + self.play( + Write(cost_word, run_time = 1), + GrowArrow(cost_arrow) + ) + self.play(C0.shift, MED_SMALL_BUFF*UP, rate_func = wiggle) + self.dither() + + self.set_variables_as_attrs( + cost_equation, cost_word, cost_arrow + ) def show_activation_formula(self): - pass + neuron = self.network_mob.layers[-1].neurons[0] + edge = self.network_mob.edge_groups[-1][0] + pre_aL, pre_aLm1 = self.a_labels.copy() + + formula = TexMobject( + "a^{(L)}", "=", "\\sigma", "(", + "w^{(L)}", "a^{(L-1)}", "+", "b^{(L)}", ")" + ) + formula.next_to(neuron, UP, MED_LARGE_BUFF, RIGHT) + aL, equals, sigma, lp, wL, aLm1, plus, bL, rp = formula + wL.highlight(edge.get_color()) + weight_label = wL.copy() + bL.highlight(MAROON_B) + bias_label = bL.copy() + sigma_group = VGroup(sigma, lp, rp) + sigma_group.save_state() + sigma_group.set_fill(opacity = 0) + sigma_group.shift(DOWN) + + self.play( + ReplacementTransform(pre_aL, aL), + Write(equals) + ) + self.play(ReplacementTransform( + edge.copy(), wL + )) + self.dither() + self.play(ReplacementTransform(pre_aLm1, aLm1)) + self.dither() + self.play(Write(VGroup(plus, bL), run_time = 1)) + self.dither() + self.play(sigma_group.restore) + self.dither() + + weighted_sum_terms = VGroup(wL, aLm1, bL) + self.set_variables_as_attrs( + formula, weighted_sum_terms + ) def introduce_z(self): - pass + terms = self.weighted_sum_terms + brace = Brace(terms, UP, buff = SMALL_BUFF) + z_label = TexMobject("z^{(L)}") + z_label.next_to(brace, UP, buff = SMALL_BUFF) + z_label.highlight(self.z_color) + rect = SurroundingRectangle(terms) + rect.highlight(GREEN) + + self.play(ShowCreation(rect)) + self.play( + GrowFromCenter(brace), + Write(z_label), + ) + self.play(FadeOut(rect)) + self.dither() + + self.set_variables_as_attrs(z_label, z_brace = brace) def break_into_computational_graph(self): pass From 589fd5e0281a09d4f13f2466d44990fd61b6c285 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 27 Oct 2017 12:59:38 -0700 Subject: [PATCH 32/43] Small fix so curved arrows look better --- topics/geometry.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/topics/geometry.py b/topics/geometry.py index 1c867777..b74fcb5d 100644 --- a/topics/geometry.py +++ b/topics/geometry.py @@ -319,7 +319,7 @@ class Arrow(Line): indices = (-2, -1) if add_at_end else (1, 0) pre_end_point, end_point = [ - self.points[index] + self.get_anchors()[index] for index in indices ] vect = end_point - pre_end_point From 34b4ea089c266d8e5de2fd20983ea538be654b61 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 27 Oct 2017 12:59:54 -0700 Subject: [PATCH 33/43] Up to derivatives in self.revert_to_original_skipping_status() --- nn/part3.py | 304 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 283 insertions(+), 21 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index ae4d5c35..cea4dff3 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -2002,6 +2002,7 @@ class SimplestNetworkExample(PreviewLearning): "z_color" : GREEN, "cost_color" : RED, "desired_output_color" : YELLOW, + "derivative_scale_vale" : 0.7, } def construct(self): self.force_skipping() @@ -2101,10 +2102,10 @@ class SimplestNetworkExample(PreviewLearning): self.dither() def label_neurons(self): - neurons = [ + neurons = VGroup(*[ self.network_mob.layers[i].neurons[0] for i in -1, -2 - ] + ]) decimals = VGroup() a_labels = VGroup() a_label_arrows = VGroup() @@ -2167,7 +2168,8 @@ class SimplestNetworkExample(PreviewLearning): self.play(*map(FadeOut, [not_exponents, superscript_rects])) self.set_variables_as_attrs( - a_labels, a_label_arrows, decimals + a_labels, a_label_arrows, decimals, + last_neurons = neurons ) def show_desired_output(self): @@ -2290,41 +2292,301 @@ class SimplestNetworkExample(PreviewLearning): self.play(sigma_group.restore) self.dither() - weighted_sum_terms = VGroup(wL, aLm1, bL) + weighted_sum_terms = VGroup(wL, aLm1, plus, bL) self.set_variables_as_attrs( formula, weighted_sum_terms ) def introduce_z(self): terms = self.weighted_sum_terms - brace = Brace(terms, UP, buff = SMALL_BUFF) + terms.generate_target() + terms.target.next_to(self.formula, UP, aligned_edge = RIGHT) + equals = TexMobject("=") + equals.next_to(terms.target[0][0], LEFT) + z_label = TexMobject("z^{(L)}") - z_label.next_to(brace, UP, buff = SMALL_BUFF) + z_label.next_to(equals, LEFT) + z_label.align_to(terms.target, DOWN) z_label.highlight(self.z_color) - rect = SurroundingRectangle(terms) - rect.highlight(GREEN) + z_label2 = z_label.copy() + + aL_start = VGroup(*self.formula[:4]) + aL_start.generate_target() + aL_start.target.align_to(z_label, LEFT) + z_label2.next_to(aL_start.target, RIGHT, SMALL_BUFF) + z_label2.align_to(aL_start.target[0], DOWN) + rp = self.formula[-1] + rp.generate_target() + rp.target.next_to(z_label2, RIGHT, SMALL_BUFF) + rp.target.align_to(aL_start.target, DOWN) + + self.play(MoveToTarget(terms)) + self.play(Write(z_label), Write(equals)) + self.play( + ReplacementTransform(z_label.copy(), z_label2), + MoveToTarget(aL_start), + MoveToTarget(rp), + ) + self.dither() + + zL_formula = VGroup(z_label, equals, terms) + aL_formula = VGroup(aL_start, z_label2, rp) + self.set_variables_as_attrs(z_label, zL_formula, aL_formula) + + def break_into_computational_graph(self): + network_early_layers = VGroup(*it.chain( + self.network_mob.layers[:2], + self.network_mob.edge_groups[:2] + )) + + wL, aL, plus, bL = self.weighted_sum_terms + top_terms = VGroup(wL, aL, bL).copy() + zL = self.z_label.copy() + aL = self.formula[0].copy() + y = self.y_label.copy() + C0 = self.cost_equation[0].copy() + targets = VGroup() + for mob in top_terms, zL, aL, C0: + mob.generate_target() + targets.add(mob.target) + y.generate_target() + top_terms.target.arrange_submobjects(RIGHT, buff = MED_LARGE_BUFF) + targets.arrange_submobjects(DOWN, buff = LARGE_BUFF) + targets.center().to_corner(DOWN+LEFT) + y.target.next_to(aL.target, LEFT, LARGE_BUFF, DOWN) + + top_lines = VGroup(*[ + Line( + term.get_bottom(), + zL.target.get_top(), + buff = SMALL_BUFF + ) + for term in top_terms.target + ]) + z_to_a_line, a_to_c_line, y_to_c_line = all_lines = [ + Line( + m1.target.get_bottom(), + m2.target.get_top(), + buff = SMALL_BUFF + ) + for m1, m2 in [ + (zL, aL), + (aL, C0), + (y, C0) + ] + ] + for mob in [top_lines] + all_lines: + yellow_copy = mob.copy().highlight(YELLOW) + mob.flash = ShowCreationThenDestruction(yellow_copy) + + self.play(MoveToTarget(top_terms)) + self.dither() + self.play(MoveToTarget(zL)) + self.play( + ShowCreation(top_lines, submobject_mode = "all_at_once"), + top_lines.flash + ) + self.dither() + self.play(MoveToTarget(aL)) + self.play( + FadeOut(network_early_layers), + ShowCreation(z_to_a_line), + z_to_a_line.flash + ) + self.dither() + self.play(MoveToTarget(y)) + self.play(MoveToTarget(C0)) + self.play(*it.chain(*[ + [ShowCreation(line), line.flash] + for line in a_to_c_line, y_to_c_line + ])) + self.dither(2) + + comp_graph = VGroup() + comp_graph.wL, comp_graph.aLm1, comp_graph.bL = top_terms + comp_graph.top_lines = top_lines + comp_graph.zL = zL + comp_graph.z_to_a_line = z_to_a_line + comp_graph.aL = aL + comp_graph.y = y + comp_graph.a_to_c_line = a_to_c_line + comp_graph.y_to_c_line = y_to_c_line + comp_graph.C0 = C0 + comp_graph.digest_mobject_attrs() + self.comp_graph = comp_graph + + def show_preceding_layer_in_computational_graph(self): + shift_vect = DOWN + comp_graph = self.comp_graph + comp_graph.save_state() + comp_graph.generate_target() + comp_graph.target.shift(shift_vect) + rect = SurroundingRectangle(comp_graph.aLm1) + + attrs = ["wL", "aLm1", "bL", "zL"] + new_terms = VGroup() + for attr in attrs: + term = getattr(comp_graph, attr) + tex = term.get_tex_string() + if "L-1" in tex: + tex = tex.replace("L-1", "L-2") + else: + tex = tex.replace("L", "L-1") + new_term = TexMobject(tex) + new_term.highlight(term.get_color()) + new_term.move_to(term) + new_terms.add(new_term) + new_edges = VGroup( + comp_graph.top_lines.copy(), + comp_graph.z_to_a_line.copy(), + ) + new_subgraph = VGroup(new_terms, new_edges) self.play(ShowCreation(rect)) self.play( - GrowFromCenter(brace), - Write(z_label), + new_subgraph.next_to, comp_graph.target, UP, SMALL_BUFF, + UpdateFromAlphaFunc( + new_terms, + lambda m, a : m.set_fill(opacity = a) + ), + MoveToTarget(comp_graph), + rect.shift, shift_vect ) - self.play(FadeOut(rect)) + self.dither(2) + self.play( + FadeOut(new_subgraph), + comp_graph.restore, + rect.shift, -shift_vect, + rect.set_stroke, BLACK, 0 + ) + self.remove(rect) self.dither() - self.set_variables_as_attrs(z_label, z_brace = brace) - - def break_into_computational_graph(self): - pass - - def show_preceding_layer_in_computational_graph(self): - pass - def show_number_lines(self): - pass + comp_graph = self.comp_graph + wL, aLm1, bL, zL, aL, C0 = [ + getattr(comp_graph, attr) + for attr in ["wL", "aLm1", "bL", "zL", "aL", "C0"] + ] + wL.val = self.network.weights[-1][0][0] + aL.val = self.decimals[0].number + zL.val = sigmoid_inverse(aL.val) + C0.val = (aL.val - 1)**2 + + number_line = UnitInterval( + unit_size = 2, + stroke_width = 2, + tick_size = 0.075, + color = LIGHT_GREY, + ) + + for mob in wL, zL, aL, C0: + mob.number_line = number_line.deepcopy() + if mob is wL: + mob.number_line.next_to(mob, UP, MED_LARGE_BUFF, LEFT) + else: + mob.number_line.next_to(mob, RIGHT) + mob.dot = Dot(color = mob.get_color()) + mob.dot.move_to( + mob.number_line.number_to_point(mob.val) + ) + if mob is wL: + path_arc = 0 + dot_spot = mob.dot.get_bottom() + else: + path_arc = -0.8*np.pi + dot_spot = mob.dot.get_top() + if mob is C0: + mob_spot = mob[0].get_corner(UP+RIGHT) + tip_length = 0.15 + else: + mob_spot = mob.get_corner(UP+RIGHT) + tip_length = 0.2 + mob.arrow = Arrow( + mob_spot, dot_spot, + use_rectangular_stem = False, + path_arc = path_arc, + tip_length = tip_length, + buff = SMALL_BUFF, + ) + mob.arrow.highlight(mob.get_color()) + mob.arrow.set_stroke(width = 5) + + self.play(ShowCreation( + mob.number_line, + submobject_mode = "lagged_start" + )) + self.play( + ShowCreation(mob.arrow), + ReplacementTransform( + mob.copy(), mob.dot, + path_arc = path_arc + ) + ) + self.dither() def ask_about_w_sensitivity(self): - pass + wL, aLm1, bL, zL, aL, C0 = [ + getattr(self.comp_graph, attr) + for attr in ["wL", "aLm1", "bL", "zL", "aL", "C0"] + ] + aLm1_val = self.last_neurons[1].get_fill_opacity() + bL_val = self.network.biases[-1][0] + + get_wL_val = lambda : wL.number_line.point_to_number( + wL.dot.get_center() + ) + get_zL_val = lambda : get_wL_val()*aLm1_val+bL_val + get_aL_val = lambda : sigmoid(get_zL_val()) + get_C0_val = lambda : (get_aL_val() - 1)**2 + + def generate_dot_update(term, val_func): + def update_dot(dot): + dot.move_to(term.number_line.number_to_point(val_func())) + return dot + return update_dot + + dot_update_anims = [ + UpdateFromFunc(term.dot, generate_dot_update(term, val_func)) + for term, val_func in [ + (zL, get_zL_val), + (aL, get_aL_val), + (C0, get_C0_val), + ] + ] + + wL_line = Line(wL.dot.get_center(), wL.dot.get_center()+LEFT) + del_wL = TexMobject("\\partial w^{(L)}") + del_wL.scale(self.derivative_scale_vale) + del_wL.brace = Brace(wL_line, UP) + del_wL.highlight(wL.get_color()) + del_wL.next_to(del_wL.brace, UP, SMALL_BUFF) + + C0_line = Line(C0.dot.get_center(), C0.dot.get_center()+MED_SMALL_BUFF*RIGHT) + del_C0 = TexMobject("\\partial C_0") + del_C0.scale(self.derivative_scale_vale) + del_C0.brace = Brace(C0_line, UP) + del_C0.highlight(C0.get_color()) + del_C0.next_to(del_C0.brace, UP, SMALL_BUFF) + + for sym in del_wL, del_C0: + self.play( + GrowFromCenter(sym.brace), + Write(sym, run_time = 1) + ) + self.play( + ApplyMethod( + wL.dot.shift, LEFT, + run_time = 2, + rate_func = there_and_back + ), + *dot_update_anims + ) + self.dither() + + self.set_variables_as_attrs( + dot_update_anims, del_wL, del_C0, + ) def show_derivative_wrt_w(self): pass From 6625e4ee16784d199df2c42a6d89e060a7ccb18a Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 27 Oct 2017 13:00:28 -0700 Subject: [PATCH 34/43] Up to derivatives in SimplestNetworkExample of nn/part3 --- nn/part3.py | 1 + 1 file changed, 1 insertion(+) diff --git a/nn/part3.py b/nn/part3.py index cea4dff3..67188de8 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -2590,6 +2590,7 @@ class SimplestNetworkExample(PreviewLearning): def show_derivative_wrt_w(self): pass + def show_chain_of_events(self): pass From 76ea80230d6137e4fe0852eda0e83b5489c7af84 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 27 Oct 2017 15:12:11 -0700 Subject: [PATCH 35/43] Arrow bug fix --- topics/geometry.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/topics/geometry.py b/topics/geometry.py index b74fcb5d..70f5ff7a 100644 --- a/topics/geometry.py +++ b/topics/geometry.py @@ -368,7 +368,8 @@ class Arrow(Line): Line.scale(self, scale_factor, **kwargs) if self.preserve_tip_size_when_scaling: self.set_tip_points(self.tip) - self.set_rectangular_stem_points() + if self.use_rectangular_stem: + self.set_rectangular_stem_points() return self class Vector(Arrow): From ac079f182a977bf0d830ab7647971b67cf9e5160 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Fri, 27 Oct 2017 15:12:29 -0700 Subject: [PATCH 36/43] Up through chain rule in SimplestNetworkExample of nn/part3 --- nn/part3.py | 248 +++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 228 insertions(+), 20 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 67188de8..c35c4e91 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -2002,7 +2002,7 @@ class SimplestNetworkExample(PreviewLearning): "z_color" : GREEN, "cost_color" : RED, "desired_output_color" : YELLOW, - "derivative_scale_vale" : 0.7, + "derivative_scale_val" : 0.85, } def construct(self): self.force_skipping() @@ -2022,6 +2022,8 @@ class SimplestNetworkExample(PreviewLearning): self.show_derivative_wrt_w() self.show_chain_of_events() self.show_chain_rule() + self.name_chain_rule() + self.indicate_everything_on_screen() self.compute_derivatives() self.fire_together_wire_together() self.show_derivative_wrt_b() @@ -2301,6 +2303,7 @@ class SimplestNetworkExample(PreviewLearning): terms = self.weighted_sum_terms terms.generate_target() terms.target.next_to(self.formula, UP, aligned_edge = RIGHT) + terms.target.shift(MED_LARGE_BUFF*RIGHT) equals = TexMobject("=") equals.next_to(terms.target[0][0], LEFT) @@ -2486,6 +2489,10 @@ class SimplestNetworkExample(PreviewLearning): mob.number_line.next_to(mob, UP, MED_LARGE_BUFF, LEFT) else: mob.number_line.next_to(mob, RIGHT) + if mob is C0: + mob.number_line.x_max = 0.5 + for tick_mark in mob.number_line.tick_marks[1::2]: + mob.number_line.tick_marks.remove(tick_mark) mob.dot = Dot(color = mob.get_color()) mob.dot.move_to( mob.number_line.number_to_point(mob.val) @@ -2494,7 +2501,7 @@ class SimplestNetworkExample(PreviewLearning): path_arc = 0 dot_spot = mob.dot.get_bottom() else: - path_arc = -0.8*np.pi + path_arc = -0.7*np.pi dot_spot = mob.dot.get_top() if mob is C0: mob_spot = mob[0].get_corner(UP+RIGHT) @@ -2555,17 +2562,27 @@ class SimplestNetworkExample(PreviewLearning): ] ] + def shake_dot(run_time = 2, rate_func = there_and_back): + self.play( + ApplyMethod( + wL.dot.shift, LEFT, + rate_func = rate_func, + run_time = run_time + ), + *dot_update_anims + ) + wL_line = Line(wL.dot.get_center(), wL.dot.get_center()+LEFT) del_wL = TexMobject("\\partial w^{(L)}") - del_wL.scale(self.derivative_scale_vale) - del_wL.brace = Brace(wL_line, UP) + del_wL.scale(self.derivative_scale_val) + del_wL.brace = Brace(wL_line, UP, buff = SMALL_BUFF) del_wL.highlight(wL.get_color()) del_wL.next_to(del_wL.brace, UP, SMALL_BUFF) C0_line = Line(C0.dot.get_center(), C0.dot.get_center()+MED_SMALL_BUFF*RIGHT) del_C0 = TexMobject("\\partial C_0") - del_C0.scale(self.derivative_scale_vale) - del_C0.brace = Brace(C0_line, UP) + del_C0.scale(self.derivative_scale_val) + del_C0.brace = Brace(C0_line, UP, buff = SMALL_BUFF) del_C0.highlight(C0.get_color()) del_C0.next_to(del_C0.brace, UP, SMALL_BUFF) @@ -2574,32 +2591,189 @@ class SimplestNetworkExample(PreviewLearning): GrowFromCenter(sym.brace), Write(sym, run_time = 1) ) - self.play( - ApplyMethod( - wL.dot.shift, LEFT, - run_time = 2, - rate_func = there_and_back - ), - *dot_update_anims - ) + shake_dot() self.dither() self.set_variables_as_attrs( - dot_update_anims, del_wL, del_C0, + shake_dot, del_wL, del_C0, ) def show_derivative_wrt_w(self): - pass - + del_wL = self.del_wL + del_C0 = self.del_C0 + cost_word = self.cost_word + cost_arrow = self.cost_arrow + shake_dot = self.shake_dot + wL = self.comp_graph.wL + + dC_dw = TexMobject( + "{\\partial C_0", "\\over", "\\partial w^{(L)} }" + ) + dC_dw[0].highlight(del_C0.get_color()) + dC_dw[2].highlight(del_wL.get_color()) + dC_dw.scale(self.derivative_scale_val) + dC_dw.to_edge(UP, buff = MED_SMALL_BUFF) + dC_dw.shift(3.5*LEFT) + + full_rect = SurroundingRectangle(dC_dw) + full_rect_copy = full_rect.copy() + words = TextMobject("What we want") + words.next_to(full_rect, RIGHT) + words.highlight(YELLOW) + + denom_rect = SurroundingRectangle(dC_dw[2]) + numer_rect = SurroundingRectangle(dC_dw[0]) + + self.play( + ReplacementTransform(del_C0.copy(), dC_dw[0]), + ReplacementTransform(del_wL.copy(), dC_dw[2]), + Write(dC_dw[1], run_time = 1) + ) + self.play( + FadeOut(cost_word), + FadeOut(cost_arrow), + ShowCreation(full_rect), + Write(words, run_time = 1), + ) + self.dither(2) + self.play( + FadeOut(words), + ReplacementTransform(full_rect, denom_rect) + ) + self.play(Transform(dC_dw[2].copy(), del_wL, remover = True)) + shake_dot() + self.play(ReplacementTransform(denom_rect, numer_rect)) + self.play(Transform(dC_dw[0].copy(), del_C0, remover = True)) + shake_dot() + self.dither() + self.play(ReplacementTransform(numer_rect, full_rect_copy)) + self.play(FadeOut(full_rect_copy)) + self.dither() + + self.dC_dw = dC_dw def show_chain_of_events(self): - pass + comp_graph = self.comp_graph + wL, zL, aL, C0 = [ + getattr(comp_graph, attr) + for attr in ["wL", "zL", "aL", "C0"] + ] + del_wL = self.del_wL + del_C0 = self.del_C0 + + zL_line = Line(ORIGIN, MED_LARGE_BUFF*LEFT) + zL_line.shift(zL.dot.get_center()) + del_zL = TexMobject("\\partial z^{(L)}") + del_zL.highlight(zL.get_color()) + del_zL.brace = Brace(zL_line, DOWN, buff = SMALL_BUFF) + + aL_line = Line(ORIGIN, MED_SMALL_BUFF*LEFT) + aL_line.shift(aL.dot.get_center()) + del_aL = TexMobject("\\partial a^{(L)}") + del_aL.highlight(aL.get_color()) + del_aL.brace = Brace(aL_line, DOWN, buff = SMALL_BUFF) + + for sym in del_zL, del_aL: + sym.scale(self.derivative_scale_val) + sym.brace.stretch_about_point( + 0.5, 1, sym.brace.get_top(), + ) + sym.shift( + sym.brace.get_bottom()+SMALL_BUFF*DOWN \ + -sym[0].get_corner(UP+RIGHT) + ) + + syms = [del_wL, del_zL, del_aL, del_C0] + for s1, s2 in zip(syms, syms[1:]): + self.play( + ReplacementTransform(s1.copy(), s2), + ReplacementTransform(s1.brace.copy(), s2.brace), + ) + self.shake_dot(run_time = 1.5) + self.dither(0.5) + self.dither() + + self.set_variables_as_attrs(del_zL, del_aL) def show_chain_rule(self): - pass + dC_dw = self.dC_dw + dz_dw = TexMobject( + "{\\partial z^{(L)}", "\\over", "\\partial w^{(L)}}" + ) + da_dz = TexMobject( + "{\\partial a^{(L)}", "\\over", "\\partial z^{(L)}}" + ) + dC_da = TexMobject( + "{\\partial C0}", "\\over", "\\partial a^{(L)}}" + ) + dz_dw[2].highlight(self.del_wL.get_color()) + VGroup(dz_dw[0], da_dz[2]).highlight(self.z_color) + dC_da[0].highlight(self.cost_color) + equals = TexMobject("=") + group = VGroup(equals, dz_dw, da_dz, dC_da) + group.arrange_submobjects(RIGHT, SMALL_BUFF) + group.scale(self.derivative_scale_val) + group.next_to(dC_dw, RIGHT) + for mob in group[1:]: + target_y = equals.get_center()[1] + y = mob[1].get_center()[1] + mob.shift((target_y - y)*UP) + + last_sym = dC_dw[2] + self.play(Write(equals, run_time = 1)) + for fraction in group[1:]: + self.play(LaggedStart( + FadeIn, VGroup(*fraction[:2]), + lag_ratio = 0.75, + run_time = 1 + )) + self.play(ReplacementTransform( + last_sym.copy(), fraction[2] + )) + self.dither() + last_sym = fraction[0] + self.shake_dot() + self.dither() + + self.chain_rule_equation = VGroup(dC_dw, *group) + + def name_chain_rule(self): + graph_parts = self.get_all_comp_graph_parts() + equation = self.chain_rule_equation + rect = SurroundingRectangle(equation) + group = VGroup(equation, rect) + group.generate_target() + group.target.to_corner(UP+LEFT) + words = TextMobject("Chain rule") + words.highlight(YELLOW) + words.next_to(group.target, DOWN) + + self.play(ShowCreation(rect)) + self.play( + MoveToTarget(group), + Write(words, run_time = 1), + graph_parts.scale, 0.7, graph_parts.get_bottom() + ) + self.dither(2) + self.play(*map(FadeOut, [rect, words])) + + def indicate_everything_on_screen(self): + everything = VGroup(*self.get_top_level_mobjects()) + everything = VGroup(*filter( + lambda m : not m.is_subpath, + everything.family_members_with_points() + )) + self.play(LaggedStart( + Indicate, everything, + rate_func = wiggle, + lag_ratio = 0.2, + run_time = 5 + )) + self.dither() def compute_derivatives(self): - pass + + self.play(FadeOut(self.all_comp_graph_parts)) def fire_together_wire_together(self): pass @@ -2623,6 +2797,40 @@ class SimplestNetworkExample(PreviewLearning): decimal.set_fill(BLACK) decimal.move_to(neuron) return decimal + + def get_all_comp_graph_parts(self): + comp_graph = self.comp_graph + result = VGroup(comp_graph) + for attr in "wL", "zL", "aL", "C0": + sym = getattr(comp_graph, attr) + comp_graph.add( + sym.arrow, sym.number_line, sym.dot + ) + del_sym = getattr(self, "del_" + attr) + comp_graph.add(del_sym, del_sym.brace) + + self.all_comp_graph_parts = result + return result + + + + + + + + + + + + + + + + + + + + From 065de1af0c525c2931a50dab4f1ff43fdaf90511 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Mon, 30 Oct 2017 15:28:48 -0700 Subject: [PATCH 37/43] Finished SimplestNetworkExample in nn/part3 --- nn/part3.py | 603 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 589 insertions(+), 14 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index c35c4e91..154f5063 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -2005,8 +2005,6 @@ class SimplestNetworkExample(PreviewLearning): "derivative_scale_val" : 0.85, } def construct(self): - self.force_skipping() - self.seed_random_libraries() self.collapse_ordinary_network() self.focus_just_on_last_two_layers() @@ -2024,11 +2022,18 @@ class SimplestNetworkExample(PreviewLearning): self.show_chain_rule() self.name_chain_rule() self.indicate_everything_on_screen() + self.prepare_for_derivatives() self.compute_derivatives() + self.get_lost_in_formulas() self.fire_together_wire_together() + self.organize_chain_rule_rhs() + self.show_average_derivative() + self.show_gradient() + self.transition_to_derivative_wrt_b() self.show_derivative_wrt_b() self.show_derivative_wrt_a() self.show_previous_weight_and_bias() + self.animate_long_path() def seed_random_libraries(self): np.random.seed(self.random_seed) @@ -2103,6 +2108,8 @@ class SimplestNetworkExample(PreviewLearning): )) self.dither() + self.prev_layers = to_fade + def label_neurons(self): neurons = VGroup(*[ self.network_mob.layers[i].neurons[0] @@ -2302,7 +2309,11 @@ class SimplestNetworkExample(PreviewLearning): def introduce_z(self): terms = self.weighted_sum_terms terms.generate_target() - terms.target.next_to(self.formula, UP, aligned_edge = RIGHT) + terms.target.next_to( + self.formula, UP, + buff = MED_LARGE_BUFF, + aligned_edge = RIGHT + ) terms.target.shift(MED_LARGE_BUFF*RIGHT) equals = TexMobject("=") equals.next_to(terms.target[0][0], LEFT) @@ -2332,8 +2343,8 @@ class SimplestNetworkExample(PreviewLearning): ) self.dither() - zL_formula = VGroup(z_label, equals, terms) - aL_formula = VGroup(aL_start, z_label2, rp) + zL_formula = VGroup(z_label, equals, *terms) + aL_formula = VGroup(*list(aL_start) + [z_label2, rp]) self.set_variables_as_attrs(z_label, zL_formula, aL_formula) def break_into_computational_graph(self): @@ -2392,7 +2403,7 @@ class SimplestNetworkExample(PreviewLearning): self.dither() self.play(MoveToTarget(aL)) self.play( - FadeOut(network_early_layers), + network_early_layers.fade, 1, ShowCreation(z_to_a_line), z_to_a_line.flash ) @@ -2444,6 +2455,8 @@ class SimplestNetworkExample(PreviewLearning): comp_graph.z_to_a_line.copy(), ) new_subgraph = VGroup(new_terms, new_edges) + self.wLm1 = new_terms[0] + self.zLm1 = new_terms[-1] self.play(ShowCreation(rect)) self.play( @@ -2465,6 +2478,8 @@ class SimplestNetworkExample(PreviewLearning): self.remove(rect) self.dither() + self.prev_comp_subgraph = new_subgraph + def show_number_lines(self): comp_graph = self.comp_graph wL, aLm1, bL, zL, aL, C0 = [ @@ -2771,21 +2786,581 @@ class SimplestNetworkExample(PreviewLearning): )) self.dither() + def prepare_for_derivatives(self): + zL_formula = self.zL_formula + aL_formula = self.aL_formula + az_formulas = VGroup(zL_formula, aL_formula) + cost_equation = self.cost_equation + desired_output_words = self.desired_output_words + + az_formulas.generate_target() + az_formulas.target.to_edge(RIGHT) + + index = 4 + cost_eq = cost_equation[index] + z_eq = az_formulas.target[0][1] + x_shift = (z_eq.get_center() - cost_eq.get_center())[0]*RIGHT + cost_equation.generate_target() + Transform( + VGroup(*cost_equation.target[1:index]), + VectorizedPoint(cost_eq.get_left()) + ).update(1) + cost_equation.target[0].next_to(cost_eq, LEFT, SMALL_BUFF) + cost_equation.target.shift(x_shift) + cost_equation.shift(MED_SMALL_BUFF*DOWN) + + self.play( + FadeOut(self.all_comp_graph_parts), + FadeOut(self.desired_output_words), + MoveToTarget(az_formulas), + MoveToTarget(cost_equation) + ) + def compute_derivatives(self): - - self.play(FadeOut(self.all_comp_graph_parts)) + cost_equation = self.cost_equation + zL_formula = self.zL_formula + aL_formula = self.aL_formula + chain_rule_equation = self.chain_rule_equation.copy() + dC_dw, equals, dz_dw, da_dz, dC_da = chain_rule_equation + + derivs = VGroup(dC_da, da_dz, dz_dw) + deriv_targets = VGroup() + for deriv in derivs: + deriv.generate_target() + deriv_targets.add(deriv.target) + deriv_targets.arrange_submobjects(DOWN, buff = MED_LARGE_BUFF) + deriv_targets.next_to(dC_dw, DOWN, LARGE_BUFF) + for deriv in derivs: + deriv.equals = TexMobject("=") + deriv.equals.next_to(deriv.target, RIGHT) + + #dC_da + self.play( + MoveToTarget(dC_da), + Write(dC_da.equals,) + ) + index = 4 + cost_rhs = VGroup(*cost_equation[index+1:]) + dC_da.rhs = cost_rhs.copy() + two = dC_da.rhs[-1] + two.scale(1.5) + two.next_to(dC_da.rhs[0], LEFT, SMALL_BUFF) + dC_da.rhs.next_to(dC_da.equals, RIGHT) + dC_da.rhs.shift(0.7*SMALL_BUFF*UP) + cost_equation.save_state() + self.play( + cost_equation.next_to, dC_da.rhs, + DOWN, MED_LARGE_BUFF, LEFT + ) + self.dither() + self.play(ReplacementTransform( + cost_rhs.copy(), dC_da.rhs, + path_arc = np.pi/2, + )) + self.dither() + self.play(cost_equation.restore) + self.dither() + + #show_difference + neuron = self.last_neurons[0] + decimal = self.decimals[0] + double_arrow = DoubleArrow( + neuron.get_right(), + self.desired_output_neuron.get_left(), + buff = SMALL_BUFF, + color = RED + ) + self.play(ReplacementTransform( + dC_da.rhs.copy(), double_arrow + )) + opacity = neuron.get_fill_opacity() + for target_o in 0, opacity: + self.dither(2) + self.play( + neuron.set_fill, None, target_o, + ChangingDecimal( + decimal, lambda a : neuron.get_fill_opacity() + ) + ) + self.play(FadeOut(double_arrow)) + + #da_dz + self.play( + MoveToTarget(da_dz), + Write(da_dz.equals) + ) + a_rhs = VGroup(*aL_formula[2:]) + da_dz.rhs = a_rhs.copy() + prime = TexMobject("'") + prime.move_to(da_dz.rhs[0].get_corner(UP+RIGHT)) + da_dz.rhs[0].shift(0.5*SMALL_BUFF*LEFT) + da_dz.rhs.add_to_back(prime) + da_dz.rhs.next_to(da_dz.equals, RIGHT) + da_dz.rhs.shift(0.5*SMALL_BUFF*UP) + aL_formula.save_state() + self.play( + aL_formula.next_to, da_dz.rhs, + DOWN, MED_LARGE_BUFF, LEFT + ) + self.dither() + self.play(ReplacementTransform( + a_rhs.copy(), da_dz.rhs, + )) + self.dither() + self.play(aL_formula.restore) + self.dither() + + #dz_dw + self.play( + MoveToTarget(dz_dw), + Write(dz_dw.equals) + ) + z_rhs = VGroup(*zL_formula[2:]) + dz_dw.rhs = z_rhs[1].copy() + dz_dw.rhs.next_to(dz_dw.equals, RIGHT) + dz_dw.rhs.shift(SMALL_BUFF*UP) + zL_formula.save_state() + self.play( + zL_formula.next_to, dz_dw.rhs, + DOWN, MED_LARGE_BUFF, LEFT, + ) + self.dither() + self.play(ReplacementTransform( + z_rhs[1].copy(), dz_dw.rhs, + )) + self.dither() + self.play(zL_formula.restore) + self.dither() + + self.derivative_equations = VGroup(dC_da, da_dz, dz_dw) + + def get_lost_in_formulas(self): + randy = Randolph() + randy.flip() + randy.scale(0.7) + randy.to_edge(DOWN) + randy.shift(LEFT) + + self.play(FadeIn(randy)) + self.play(randy.change, "pleading", self.chain_rule_equation) + self.play(Blink(randy)) + self.play(randy.change, "maybe") + self.play(Blink(randy)) + self.play(FadeOut(randy)) def fire_together_wire_together(self): - pass + dz_dw = self.derivative_equations[2] + rhs = dz_dw.rhs + rhs_copy = rhs.copy() + del_wL = dz_dw[2].copy() + rect = SurroundingRectangle(VGroup(dz_dw, dz_dw.rhs)) + edge = self.network_mob.edge_groups[-1][0] + edge.save_state() + neuron = self.last_neurons[1] + decimal = self.decimals[1] + + def get_decimal_anims(): + return [ + ChangingDecimal(decimal, lambda a : neuron.get_fill_opacity()), + UpdateFromFunc( + decimal, lambda m : m.highlight( + WHITE if neuron.get_fill_opacity() < 0.8 \ + else BLACK + ) + ) + ] + + self.play(ShowCreation(rect)) + self.play(FadeOut(rect)) + self.play( + del_wL.next_to, edge, UP, SMALL_BUFF + ) + self.play( + edge.set_stroke, None, 10, + rate_func = wiggle, + run_time = 3, + ) + self.dither() + self.play(rhs.shift, MED_LARGE_BUFF*UP, rate_func = wiggle) + self.play( + rhs_copy.move_to, neuron, + rhs_copy.set_fill, None, 0 + ) + self.remove(rhs_copy) + self.play( + neuron.set_fill, None, 0, + *get_decimal_anims(), + run_time = 3, + rate_func = there_and_back + ) + self.dither() + + #Fire together wire together + opacity = neuron.get_fill_opacity() + self.play( + neuron.set_fill, None, 0.99, + *get_decimal_anims() + ) + self.play(edge.set_stroke, None, 8) + self.play( + neuron.set_fill, None, opacity, + *get_decimal_anims() + ) + self.play(edge.restore, FadeOut(del_wL)) + self.dither(3) + + def organize_chain_rule_rhs(self): + fracs = self.derivative_equations + equals_group = VGroup(*[frac.equals for frac in fracs]) + rhs_group = VGroup(*[frac.rhs for frac in reversed(fracs)]) + + chain_rule_equation = self.chain_rule_equation + equals = TexMobject("=") + equals.next_to(chain_rule_equation, RIGHT) + + rhs_group.generate_target() + rhs_group.target.arrange_submobjects(RIGHT, buff = SMALL_BUFF) + rhs_group.target.next_to(equals, RIGHT) + rhs_group.target.shift(SMALL_BUFF*UP) + + right_group = VGroup( + self.cost_equation, self.zL_formula, self.aL_formula, + self.network_mob, self.decimals, + self.a_labels, self.a_label_arrows, + self.y_label, self.y_label_arrow, + self.desired_output_neuron, + self.desired_output_rect, + self.desired_output_decimal, + ) + + self.play( + MoveToTarget(rhs_group, path_arc = np.pi/2), + Write(equals), + FadeOut(fracs), + FadeOut(equals_group), + right_group.to_corner, DOWN+RIGHT + ) + self.dither() + + rhs_group.add(equals) + self.chain_rule_rhs = rhs_group + + def show_average_derivative(self): + dC0_dw = self.chain_rule_equation[0] + full_derivative = TexMobject( + "{\\partial C", "\\over", "\\partial w^{(L)}}", + "=", "\\frac{1}{n}", "\\sum_{k=0}^{n-1}", + "{\\partial C_k", "\\over", "\\partial w^{(L)}}" + ) + full_derivative.highlight_by_tex_to_color_map({ + "partial C" : self.cost_color, + "partial w" : self.del_wL.get_color() + }) + full_derivative.to_edge(LEFT) + + dCk_dw = VGroup(*full_derivative[-3:]) + lhs = VGroup(*full_derivative[:3]) + rhs = VGroup(*full_derivative[4:]) + lhs_brace = Brace(lhs, DOWN) + lhs_text = lhs_brace.get_text("Derivative of \\\\ full cost function") + rhs_brace = Brace(rhs, UP) + rhs_text = rhs_brace.get_text("Average of all \\\\ training examples") + VGroup( + full_derivative, lhs_brace, lhs_text, rhs_brace, rhs_text + ).to_corner(DOWN+LEFT) + + mover = dC0_dw.copy() + self.play(Transform(mover, dCk_dw)) + self.play(Write(full_derivative, run_time = 2)) + self.remove(mover) + self.play( + GrowFromCenter(lhs_brace), + GrowFromCenter(rhs_brace), + Write(lhs_text, run_time = 2), + Write(rhs_text, run_time = 2), + ) + self.cycle_through_altnernate_training_examples() + self.play(*map(FadeOut, [ + VGroup(*full_derivative[3:]), + lhs_brace, lhs_text, + rhs_brace, rhs_text, + ])) + + self.dC_dw = lhs + + def cycle_through_altnernate_training_examples(self): + neurons = VGroup( + self.desired_output_neuron, *self.last_neurons + ) + decimals = VGroup( + self.desired_output_decimal, *self.decimals + ) + group = VGroup(neurons, decimals) + group.save_state() + + for x in range(20): + for n, d in zip(neurons, decimals): + o = np.random.random() + if n is self.desired_output_neuron: + o = np.round(o) + n.set_fill(opacity = o) + Transform( + d, self.get_neuron_activation_decimal(n) + ).update(1) + self.dither(0.2) + self.play(group.restore, run_time = 0.2) + + def show_gradient(self): + dC_dw = self.dC_dw + dC_dw.generate_target() + terms = VGroup( + TexMobject("{\\partial C", "\\over", "\\partial w^{(1)}"), + TexMobject("{\\partial C", "\\over", "\\partial b^{(1)}"), + TexMobject("\\vdots"), + dC_dw.target, + TexMobject("{\\partial C", "\\over", "\\partial b^{(L)}"), + ) + for term in terms: + if isinstance(term, TexMobject): + term.highlight_by_tex_to_color_map({ + "partial C" : RED, + "partial w" : BLUE, + "partial b" : MAROON_B, + }) + terms.arrange_submobjects(DOWN, buff = MED_LARGE_BUFF) + lb, rb = brackets = TexMobject("[]") + brackets.scale(3) + brackets.stretch_to_fit_height(1.1*terms.get_height()) + lb.next_to(terms, LEFT, buff = SMALL_BUFF) + rb.next_to(terms, RIGHT, buff = SMALL_BUFF) + vect = VGroup(lb, terms, rb) + vect.scale_to_fit_height(5) + lhs = TexMobject("\\nabla C", "=") + lhs[0].highlight(RED) + lhs.next_to(vect, LEFT) + VGroup(lhs, vect).to_corner(DOWN+LEFT, buff = LARGE_BUFF) + terms.remove(dC_dw.target) + + self.play( + MoveToTarget(dC_dw), + Write(vect, run_time = 1) + ) + terms.add(dC_dw) + self.play(Write(lhs)) + self.dither(2) + self.play(FadeOut(VGroup(lhs, vect))) + + def transition_to_derivative_wrt_b(self): + all_comp_graph_parts = self.all_comp_graph_parts + all_comp_graph_parts.scale( + 1.3, about_point = all_comp_graph_parts.get_bottom() + ) + comp_graph = self.comp_graph + wL, bL, zL, aL, C0 = [ + getattr(comp_graph, attr) + for attr in ["wL", "bL", "zL", "aL", "C0"] + ] + path_to_C = VGroup(wL, zL, aL, C0) + + top_expression = VGroup( + self.chain_rule_equation, + self.chain_rule_rhs + ) + rect = SurroundingRectangle(top_expression) + + self.play(ShowCreation(rect)) + self.play(FadeIn(comp_graph), FadeOut(rect)) + for x in range(2): + self.play(LaggedStart( + Indicate, path_to_C, + rate_func = there_and_back, + run_time = 1.5, + lag_ratio = 0.7, + )) + self.dither() def show_derivative_wrt_b(self): - pass + comp_graph = self.comp_graph + dC0_dw = self.chain_rule_equation[0] + dz_dw = self.chain_rule_equation[2] + aLm1 = self.chain_rule_rhs[0] + left_term_group = VGroup(dz_dw, aLm1) + + del_w = dC0_dw[2] + del_b = TexMobject("\\partial b^{(L)}") + del_b.highlight(MAROON_B) + del_b.replace(del_w) + + dz_db = TexMobject( + "{\\partial z^{(L)}", "\\over", "\\partial b^{(L)}}" + ) + dz_db.highlight_by_tex_to_color_map({ + "partial z" : self.z_color, + "partial b" : MAROON_B + }) + dz_db.replace(dz_dw) + + one = TexMobject("1") + one.move_to(aLm1, RIGHT) + arrow = Arrow( + dz_db.get_bottom(), + one.get_bottom(), + use_rectangular_stem = False, + path_arc = np.pi/2, + color = WHITE, + ) + arrow.set_stroke(width = 2) + + wL, bL, zL, aL, C0 = [ + getattr(comp_graph, attr) + for attr in ["wL", "bL", "zL", "aL", "C0"] + ] + path_to_C = VGroup(bL, zL, aL, C0) + def get_path_animation(): + return LaggedStart( + Indicate, path_to_C, + rate_func = there_and_back, + run_time = 1.5, + lag_ratio = 0.7, + ) + + self.play(get_path_animation()) + self.play( + left_term_group.shift, DOWN, + left_term_group.fade, 1, + ) + self.remove(left_term_group) + self.chain_rule_equation.remove(dz_dw) + self.chain_rule_rhs.remove(aLm1) + self.play( + Transform(del_w, del_b), + FadeIn(dz_db) + ) + self.play(get_path_animation()) + self.play( + ShowCreation(arrow), + ReplacementTransform( + dz_db.copy(), one, + path_arc = arrow.path_arc + ) + ) + self.dither(2) + self.play(*map(FadeOut, [dz_db, arrow, one])) + + self.dz_db = dz_db def show_derivative_wrt_a(self): - pass + denom = self.chain_rule_equation[0][2] + numer = VGroup(*self.chain_rule_equation[0][:2]) + del_aLm1 = TexMobject("\\partial a^{(L-1)}") + del_aLm1.scale(0.8) + del_aLm1.move_to(denom) + dz_daLm1 = TexMobject( + "{\\partial z^{(L)}", "\\over", "\\partial a^{(L-1)}}" + ) + dz_daLm1.scale(0.8) + dz_daLm1.next_to(self.chain_rule_equation[1], RIGHT, SMALL_BUFF) + dz_daLm1.shift(0.7*SMALL_BUFF*UP) + dz_daLm1[0].highlight(self.z_color) + wL = self.zL_formula[2].copy() + wL.next_to(self.chain_rule_rhs, LEFT, SMALL_BUFF) + + arrow = Arrow( + dz_daLm1.get_bottom(), wL.get_bottom(), + path_arc = np.pi/2, + use_rectangular_stem = False, + color = WHITE, + ) + + comp_graph = self.comp_graph + path_to_C = VGroup(*[ + getattr(comp_graph, attr) + for attr in ["aLm1", "zL", "aL", "C0"] + ]) + def get_path_animation(): + return LaggedStart( + Indicate, path_to_C, + rate_func = there_and_back, + run_time = 1.5, + lag_ratio = 0.7, + ) + + self.play(get_path_animation()) + self.play( + numer.shift, SMALL_BUFF*UP, + Transform(denom, del_aLm1), + FadeIn(dz_daLm1), + VGroup(*self.chain_rule_equation[-2:]).shift, SMALL_BUFF*RIGHT, + ) + self.dither() + self.play( + ShowCreation(arrow), + ReplacementTransform( + dz_daLm1.copy(), wL, + path_arc = arrow.path_arc + ) + ) + self.dither(2) + + self.chain_rule_rhs.add(wL, arrow) + self.chain_rule_equation.add(dz_daLm1) def show_previous_weight_and_bias(self): - pass + to_fade = self.chain_rule_rhs + comp_graph = self.comp_graph + prev_comp_subgraph = self.prev_comp_subgraph + prev_comp_subgraph.scale(0.8) + prev_comp_subgraph.next_to(comp_graph, UP, SMALL_BUFF) + + prev_layer = VGroup( + self.network_mob.layers[1], + self.network_mob.edge_groups[1], + ) + for mob in prev_layer: + mob.restore() + prev_layer.next_to(self.last_neurons, LEFT, buff = 0) + self.remove(prev_layer) + + self.play(LaggedStart(FadeOut, to_fade, run_time = 1)) + self.play( + ShowCreation(prev_comp_subgraph, run_time = 1), + self.chain_rule_equation.to_edge, RIGHT + ) + self.play(FadeIn(prev_layer)) + + ### + neuron = self.network_mob.layers[1].neurons[0] + decimal = self.get_neuron_activation_decimal(neuron) + a_label = TexMobject("a^{(L-2)}") + a_label.replace(self.a_labels[1]) + arrow = self.a_label_arrows[1].copy() + VGroup(a_label, arrow).shift( + neuron.get_center() - self.last_neurons[1].get_center() + ) + + self.play( + Write(a_label, run_time = 1), + Write(decimal, run_time = 1), + GrowArrow(arrow), + ) + + def animate_long_path(self): + comp_graph = self.comp_graph + path_to_C = VGroup( + self.wLm1, self.zLm1, + *[ + getattr(comp_graph, attr) + for attr in ["aLm1", "zL", "aL", "C0"] + ] + ) + for x in range(2): + self.play(LaggedStart( + Indicate, path_to_C, + rate_func = there_and_back, + run_time = 1.5, + lag_ratio = 0.4, + )) + self.dither(2) ### @@ -2803,11 +3378,11 @@ class SimplestNetworkExample(PreviewLearning): result = VGroup(comp_graph) for attr in "wL", "zL", "aL", "C0": sym = getattr(comp_graph, attr) - comp_graph.add( + result.add( sym.arrow, sym.number_line, sym.dot ) del_sym = getattr(self, "del_" + attr) - comp_graph.add(del_sym, del_sym.brace) + result.add(del_sym, del_sym.brace) self.all_comp_graph_parts = result return result From a2e8d0aab93e488eafb0dad05eabca3ea98978cb Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 31 Oct 2017 07:41:20 -0700 Subject: [PATCH 38/43] Change default Write run_time --- animation/simple_animations.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/animation/simple_animations.py b/animation/simple_animations.py index 0f7a9299..3b01feea 100644 --- a/animation/simple_animations.py +++ b/animation/simple_animations.py @@ -82,12 +82,10 @@ class Write(ShowCreation): def establish_run_time(self, mobject): num_subs = len(mobject.family_members_with_points()) - if num_subs < 5: + if num_subs < 15: self.run_time = 1 - elif num_subs < 15: - self.run_time = 2 else: - self.run_time = 3 + self.run_time = 2 class DrawBorderThenFill(Animation): CONFIG = { From cfa9aba0ce05540e7aa1549fac1787133181a663 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 31 Oct 2017 07:41:33 -0700 Subject: [PATCH 39/43] Beginning GeneralFormulas of nn/part3 --- nn/part3.py | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 187 insertions(+), 2 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 154f5063..8f655a5a 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -3263,7 +3263,7 @@ class SimplestNetworkExample(PreviewLearning): dz_daLm1.shift(0.7*SMALL_BUFF*UP) dz_daLm1[0].highlight(self.z_color) wL = self.zL_formula[2].copy() - wL.next_to(self.chain_rule_rhs, LEFT, SMALL_BUFF) + wL.next_to(self.chain_rule_rhs[0], LEFT, SMALL_BUFF) arrow = Arrow( dz_daLm1.get_bottom(), wL.get_bottom(), @@ -3387,7 +3387,192 @@ class SimplestNetworkExample(PreviewLearning): self.all_comp_graph_parts = result return result - +class IsntThatOverSimplified(TeacherStudentsScene): + def construct(self): + self.student_says( + "Isn't that over-simplified?", + target_mode = "raise_right_hand", + run_time = 1 + ) + self.change_student_modes( + "pondering", "raise_right_hand", "pondering" + ) + self.dither() + self.teacher_says( + "Not that much, actually!", + run_time = 1, + target_mode = "hooray" + ) + self.dither(2) + +class GeneralFormulas(SimplestNetworkExample): + CONFIG = { + "layer_sizes" : [3, 3, 2], + "network_mob_config" : { + "include_output_labels" : False, + "neuron_to_neuron_buff" : LARGE_BUFF, + "neuron_radius" : 0.3, + }, + "stroke_width_exp" : 0.5, + "random_seed" : 1, + } + def setup(self): + self.seed_random_libraries() + self.setup_bases() + + def construct(self): + self.force_skipping() + + self.setup_network_mob() + self.show_all_a_labels() + self.only_show_abstract_a_labels() + self.add_desired_output() + self.show_cost() + self.show_example_weight() + self.show_values_between_weight_and_cost() + self.show_weight_chain_rule() + self.show_multiple_paths_from_prev_layer_neuron() + self.show_derivative_wrt_prev_activation() + + def setup_network_mob(self): + self.color_network_edges() + self.network_mob.to_edge(LEFT) + in_vect = np.random.random(self.layer_sizes[0]) + self.network_mob.activate_layers(in_vect) + self.remove(self.network_mob.layers[0]) + self.remove(self.network_mob.edge_groups[0]) + + def show_all_a_labels(self): + Lm1_neurons = self.network_mob.layers[-2].neurons + L_neurons = self.network_mob.layers[-1].neurons + all_arrows = VGroup() + all_labels = VGroup() + all_decimals = VGroup() + all_subscript_rects = VGroup() + for neurons in L_neurons, Lm1_neurons: + is_L = neurons is L_neurons + vect = LEFT if is_L else RIGHT + s = "L" if is_L else "L-1" + arrows = VGroup() + labels = VGroup() + decimals = VGroup() + subscript_rects = VGroup() + for i, neuron in enumerate(neurons): + arrow = Arrow(ORIGIN, vect) + arrow.next_to(neuron, -vect) + arrow.set_fill(WHITE) + label = TexMobject("a^{(%s)}_%d"%(s, i)) + label.next_to(arrow, -vect) + rect = SurroundingRectangle(label[-1], buff = 0.5*SMALL_BUFF) + decimal = self.get_neuron_activation_decimal(neuron) + neuron.arrow = arrow + neuron.label = label + neuron.decimal = decimal + arrows.add(arrow) + labels.add(label) + decimals.add(decimal) + subscript_rects.add(rect) + all_arrows.add(arrows) + all_labels.add(labels) + all_decimals.add(decimals) + all_subscript_rects.add(subscript_rects) + + start_labels, start_arrows = [ + VGroup(*map(VGroup, [group[i][0] for i in 0, 1])).copy() + for group in all_labels, all_arrows + ] + for label in start_labels: + label[0][-1].highlight(BLACK) + + self.add(all_decimals) + self.play(*it.chain( + map(Write, start_labels), + [GrowArrow(a[0]) for a in start_arrows] + )) + self.dither() + self.play( + ReplacementTransform(start_labels, all_labels), + ReplacementTransform(start_arrows, all_arrows), + ) + self.play(LaggedStart( + ShowCreationThenDestruction, + VGroup(*all_subscript_rects.family_members_with_points()), + lag_ratio = 0.7 + )) + self.dither() + + self.set_variables_as_attrs( + L_neurons, Lm1_neurons, + all_arrows, all_labels, + all_decimals, all_subscript_rects, + ) + + def only_show_abstract_a_labels(self): + arrows_to_fade = VGroup() + labels_to_fade = VGroup() + labels_to_change = VGroup() + self.chosen_neurons = VGroup() + rects = VGroup() + for x, layer in enumerate(self.network_mob.layers[-2:]): + for y, neuron in enumerate(layer.neurons): + if (x == 0 and y == 2) or (x == 1 and y == 0): + tex = "k" if x == 0 else "j" + neuron.label.generate_target() + self.replace_subscript(neuron.label.target, tex) + self.chosen_neurons.add(neuron) + labels_to_change.add(neuron.label) + rects.add(SurroundingRectangle( + neuron.label.target[-1], + buff = 0.5*SMALL_BUFF + )) + else: + labels_to_fade.add(neuron.label) + arrows_to_fade.add(neuron.arrow) + + self.play( + LaggedStart(FadeOut, labels_to_fade), + LaggedStart(FadeOut, arrows_to_fade), + run_time = 1 + ) + for neuron, rect in zip(self.chosen_neurons, rects): + self.play( + MoveToTarget(neuron.label), + ShowCreation(rect) + ) + self.play(FadeOut(rect)) + self.dither() + self.dither() + + def add_desired_output(self): + pass + + def show_cost(self): + pass + + def show_example_weight(self): + pass + + def show_values_between_weight_and_cost(self): + pass + + def show_weight_chain_rule(self): + pass + + def show_multiple_paths_from_prev_layer_neuron(self): + pass + + def show_derivative_wrt_prev_activation(self): + pass + + #### + + def replace_subscript(self, label, tex): + subscript = label[-1] + new_subscript = TexMobject(tex) + new_subscript.replace(subscript) + label.remove(subscript) + label.add(new_subscript) + return label From 109bff8a27b7378147e65b2a4196222eb550ff9a Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 31 Oct 2017 10:59:17 -0700 Subject: [PATCH 40/43] Finished GeneralFormulas of nn/part3 --- nn/part3.py | 341 +++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 322 insertions(+), 19 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 8f655a5a..ee8c72ce 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -3413,16 +3413,15 @@ class GeneralFormulas(SimplestNetworkExample): "neuron_to_neuron_buff" : LARGE_BUFF, "neuron_radius" : 0.3, }, - "stroke_width_exp" : 0.5, - "random_seed" : 1, + "edge_stroke_width" : 4, + "stroke_width_exp" : 0.2, + "random_seed" : 9, } def setup(self): self.seed_random_libraries() self.setup_bases() def construct(self): - self.force_skipping() - self.setup_network_mob() self.show_all_a_labels() self.only_show_abstract_a_labels() @@ -3431,12 +3430,14 @@ class GeneralFormulas(SimplestNetworkExample): self.show_example_weight() self.show_values_between_weight_and_cost() self.show_weight_chain_rule() - self.show_multiple_paths_from_prev_layer_neuron() self.show_derivative_wrt_prev_activation() + self.show_multiple_paths_from_prev_layer_neuron() + self.show_previous_layer() def setup_network_mob(self): self.color_network_edges() self.network_mob.to_edge(LEFT) + self.network_mob.shift(DOWN) in_vect = np.random.random(self.layer_sizes[0]) self.network_mob.activate_layers(in_vect) self.remove(self.network_mob.layers[0]) @@ -3462,7 +3463,7 @@ class GeneralFormulas(SimplestNetworkExample): arrow.next_to(neuron, -vect) arrow.set_fill(WHITE) label = TexMobject("a^{(%s)}_%d"%(s, i)) - label.next_to(arrow, -vect) + label.next_to(arrow, -vect, SMALL_BUFF) rect = SurroundingRectangle(label[-1], buff = 0.5*SMALL_BUFF) decimal = self.get_neuron_activation_decimal(neuron) neuron.arrow = arrow @@ -3515,7 +3516,7 @@ class GeneralFormulas(SimplestNetworkExample): rects = VGroup() for x, layer in enumerate(self.network_mob.layers[-2:]): for y, neuron in enumerate(layer.neurons): - if (x == 0 and y == 2) or (x == 1 and y == 0): + if (x == 0 and y == 1) or (x == 1 and y == 0): tex = "k" if x == 0 else "j" neuron.label.generate_target() self.replace_subscript(neuron.label.target, tex) @@ -3544,38 +3545,340 @@ class GeneralFormulas(SimplestNetworkExample): self.dither() def add_desired_output(self): - pass + layer = self.network_mob.layers[-1] + desired_output = layer.deepcopy() + desired_output.shift(3*RIGHT) + desired_output_decimals = VGroup() + arrows = VGroup() + labels = VGroup() + for i, neuron in enumerate(desired_output.neurons): + neuron.set_fill(opacity = i) + decimal = self.get_neuron_activation_decimal(neuron) + neuron.decimal = decimal + neuron.arrow = Arrow(ORIGIN, LEFT, color = WHITE) + neuron.arrow.next_to(neuron, RIGHT) + neuron.label = TexMobject("y_%d"%i) + neuron.label.next_to(neuron.arrow, RIGHT) + neuron.label.highlight(self.desired_output_color) + + desired_output_decimals.add(decimal) + arrows.add(neuron.arrow) + labels.add(neuron.label) + rect = SurroundingRectangle(desired_output, buff = 0.5*SMALL_BUFF) + words = TextMobject("Desired output") + words.next_to(rect, DOWN) + VGroup(words, rect).highlight(self.desired_output_color) + + self.play( + FadeIn(rect), + FadeIn(words), + ReplacementTransform(layer.copy(), desired_output), + FadeIn(labels), + *[ + ReplacementTransform(n1.decimal.copy(), n2.decimal) + for n1, n2 in zip(layer.neurons, desired_output.neurons) + ] + map(GrowArrow, arrows) + ) + self.dither() + + self.set_variables_as_attrs( + desired_output, + desired_output_decimals, + desired_output_rect = rect, + desired_output_words = words, + ) def show_cost(self): - pass + aj = self.chosen_neurons[1].label.copy() + yj = self.desired_output.neurons[0].label.copy() + + cost_equation = TexMobject( + "C_0", "=", "\\sum_{j = 0}^{n_L - 1}", + "(", "a^{(L)}_j", "-", "y_j", ")", "^2" + ) + cost_equation.to_corner(UP+RIGHT) + cost_equation[0].highlight(self.cost_color) + aj.target = cost_equation.get_part_by_tex("a^{(L)}_j") + yj.target = cost_equation.get_part_by_tex("y_j") + yj.target.highlight(self.desired_output_color) + to_fade_in = VGroup(*filter( + lambda m : m not in [aj.target, yj.target], + cost_equation + )) + + self.play(*[ + ReplacementTransform(mob, mob.target) + for mob in aj, yj + ]) + self.play(LaggedStart(FadeIn, to_fade_in)) + self.dither(2) + + self.set_variables_as_attrs(cost_equation) def show_example_weight(self): - pass + edges = self.network_mob.edge_groups[-1] + edge = self.chosen_neurons[1].edges_in[1] + faded_edges = VGroup(*filter( + lambda e : e is not edge, + edges + )) + faded_edges.save_state() + for faded_edge in faded_edges: + faded_edge.save_state() + + w_label = TexMobject("w^{(L)}_{jk}") + w_label.scale(1.2) + w_label.add_background_rectangle() + w_label.next_to(ORIGIN, UP, SMALL_BUFF) + w_label.rotate(edge.get_angle()) + w_label.shift(edge.get_center()) + w_label.highlight(BLUE) + + self.play(faded_edges.fade, 0.9) + self.play(Write(w_label)) + self.dither() + + self.set_variables_as_attrs(faded_edges, w_label) def show_values_between_weight_and_cost(self): - pass + z_formula = TexMobject( + "z^{(L)}_j", "=", "\\cdots", "+" + "w^{(L)}_{jk}", "a^{(L-1)}_k", "+", "\\cdots" + ) + z_formula.to_corner(UP+RIGHT) + z_formula.highlight_by_tex_to_color_map({ + "z^" : self.z_color, + "w^" : self.w_label.get_color() + }) + w_part = z_formula.get_part_by_tex("w^") + aLm1_part = z_formula.get_part_by_tex("a^{(L-1)}") + + a_formula = TexMobject( + "a^{(L)}_j", "=", "\\sigma(", "z^{(L)}_j", ")" + ) + a_formula.highlight_by_tex("z^", self.z_color) + a_formula.next_to(z_formula, DOWN, MED_LARGE_BUFF) + aL_part = a_formula[0] + + to_fade = VGroup( + self.desired_output, + self.desired_output_decimals, + self.desired_output_rect, + self.desired_output_words, + *[ + VGroup(n.arrow, n.label) + for n in self.desired_output.neurons + ] + ) + + self.play( + FadeOut(to_fade), + self.cost_equation.next_to, a_formula, DOWN, MED_LARGE_BUFF, + self.cost_equation.to_edge, RIGHT, + ReplacementTransform(self.w_label[1].copy(), w_part), + ReplacementTransform( + self.chosen_neurons[0].label.copy(), + aLm1_part + ), + ) + self.play(Write(VGroup(*filter( + lambda m : m not in [w_part, aLm1_part], + z_formula + )))) + self.dither() + self.play(ReplacementTransform( + self.chosen_neurons[1].label.copy(), + aL_part + )) + self.play(Write(VGroup(*a_formula[1:]))) + self.dither() + + self.set_variables_as_attrs(z_formula, a_formula) def show_weight_chain_rule(self): - pass + chain_rule = self.get_chain_rule( + "{\\partial C_0", "\\over", "\\partial w^{(L)}_{jk}}", + "=", + "{\\partial z^{(L)}_j", "\\over", "\\partial w^{(L)}_{jk}}", + "{\\partial a^{(L)}_j", "\\over", "\\partial z^{(L)}_j}", + "{\\partial C_0", "\\over", "\\partial a^{(L)}_j}", + ) + terms = VGroup(*[ + VGroup(*chain_rule[i:i+3]) + for i in range(4,len(chain_rule), 3) + ]) + rects = VGroup(*[ + SurroundingRectangle(term, buff = 0.5*SMALL_BUFF) + for term in terms + ]) + rects.gradient_highlight(GREEN, WHITE, RED) - def show_multiple_paths_from_prev_layer_neuron(self): - pass + self.play(Write(chain_rule)) + self.dither() + self.play(LaggedStart( + ShowCreationThenDestruction, rects, + lag_ratio = 0.7, + run_time = 3 + )) + self.dither() + + self.set_variables_as_attrs(chain_rule) def show_derivative_wrt_prev_activation(self): - pass + chain_rule = self.get_chain_rule( + "{\\partial C_0", "\\over", "\\partial a^{(L-1)}_k}", + "=", + "\\sum_{j=0}^{n_L - 1}", + "{\\partial z^{(L)}_j", "\\over", "\\partial a^{(L-1)}_k}", + "{\\partial a^{(L)}_j", "\\over", "\\partial z^{(L)}_j}", + "{\\partial C_0", "\\over", "\\partial a^{(L)}_j}", + ) + formulas = VGroup(self.z_formula, self.a_formula, self.cost_equation) + + n = chain_rule.index_of_part_by_tex("sum") + self.play(ReplacementTransform( + self.chain_rule, VGroup(*chain_rule[:n] + chain_rule[n+1:]) + )) + self.play(Write(chain_rule[n], run_time = 1)) + self.dither() + + self.set_variables_as_attrs(chain_rule) + + def show_multiple_paths_from_prev_layer_neuron(self): + neurons = self.network_mob.layers[-1].neurons + labels, arrows, decimals = [ + VGroup(*[getattr(n, attr) for n in neurons]) + for attr in "label", "arrow", "decimal" + ] + edges = VGroup(*[n.edges_in[1] for n in neurons]) + labels[0].generate_target() + self.replace_subscript(labels[0].target, "0") + + paths = [ + VGroup( + self.chosen_neurons[0].label, + self.chosen_neurons[0].arrow, + self.chosen_neurons[0], + self.chosen_neurons[0].decimal, + edges[i], + neurons[i], + decimals[i], + arrows[i], + labels[i], + ) + for i in range(2) + ] + path_lines = VGroup() + for path in paths: + points = [path[0].get_center()] + for mob in path[1:]: + if isinstance(mob, DecimalNumber): + continue + points.append(mob.get_center()) + path_line = VMobject() + path_line.set_points_as_corners(points) + path_lines.add(path_line) + path_lines.highlight(YELLOW) + + chain_rule = self.chain_rule + n = chain_rule.index_of_part_by_tex("sum") + brace = Brace(VGroup(*chain_rule[n:]), DOWN, buff = SMALL_BUFF) + words = brace.get_text("Sum over layer L", buff = SMALL_BUFF) + + cost_aL = self.cost_equation.get_part_by_tex("a^{(L)}") + + self.play( + MoveToTarget(labels[0]), + FadeIn(labels[1]), + GrowArrow(arrows[1]), + edges[1].restore, + FadeOut(self.w_label), + ) + for x in range(5): + anims = [ + ShowCreationThenDestruction( + path_line, + run_time = 1.5, + time_width = 0.5, + ) + for path_line in path_lines + ] + if x == 2: + anims += [ + FadeIn(words), + GrowFromCenter(brace) + ] + self.play(*anims) + self.dither() + for path, path_line in zip(paths, path_lines): + label = path[-1] + self.play( + LaggedStart( + Indicate, path, + rate_func = wiggle, + run_time = 1, + ), + ShowCreation(path_line), + Animation(label) + ) + self.dither() + group = VGroup(label, cost_aL) + self.play( + group.shift, MED_SMALL_BUFF*UP, + rate_func = wiggle + ) + self.play(FadeOut(path_line)) + self.dither() + + def show_previous_layer(self): + layer = self.network_mob.layers[0] + edges = self.network_mob.edge_groups[0] + faded_edges = self.faded_edges + to_fade = VGroup( + self.chosen_neurons[0].label, + self.chosen_neurons[0].arrow, + ) + + self.play(faded_edges.restore) + self.play( + LaggedStart( + GrowFromCenter, layer.neurons, + run_time = 1 + ), + FadeOut(to_fade) + ) + self.play(LaggedStart(ShowCreation, edges)) + self.dither() #### def replace_subscript(self, label, tex): subscript = label[-1] - new_subscript = TexMobject(tex) - new_subscript.replace(subscript) + new_subscript = TexMobject(tex)[0] + new_subscript.replace(subscript, dim_to_match = 1) label.remove(subscript) label.add(new_subscript) return label - - + def get_chain_rule(self, *tex): + chain_rule = TexMobject(*tex) + chain_rule.scale(0.8) + chain_rule.to_corner(UP+LEFT) + chain_rule.highlight_by_tex_to_color_map({ + "C_0" : self.cost_color, + "z^" : self.z_color, + "w^" : self.w_label.get_color() + }) + return chain_rule + +class PatYourselfOnTheBack(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "Pat yourself on \\\\ the back!", + target_mode = "hooray" + ) + self.change_student_modes(*["hooray"]*3) + self.dither(3) From 4429b9bbc644f60ae9012efc63aae4076d6c0d6d Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 2 Nov 2017 22:58:42 -0700 Subject: [PATCH 41/43] Many tweaks upon editing the video --- nn/part3.py | 695 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 601 insertions(+), 94 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index ee8c72ce..7cfbe569 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -151,7 +151,7 @@ class InterpretGradientComponents(GradientNudging): def circle_magnitudes(self): rects = VGroup() for decimal in self.grad_vect.decimals: - rects.add(SurroundingRectangle(VGroup(*decimal[-5:]))) + rects.add(SurroundingRectangle(VGroup(*decimal[-8:]))) rects.highlight(WHITE) self.play(LaggedStart(ShowCreation, rects)) @@ -537,6 +537,11 @@ class ShowAveragingCost(PreviewLearning): self.curr_image = image +class FocusOnOneExample(TeacherStudentsScene): + def construct(self): + self.teacher_says("Focus on just \\\\ one example") + self.dither(2) + class WalkThroughTwoExample(ShowAveragingCost): CONFIG = { "random_seed" : 0, @@ -547,6 +552,8 @@ class WalkThroughTwoExample(ShowAveragingCost): self.setup_bases() def construct(self): + self.force_skipping() + self.setup_network() self.setup_diff_words() self.show_single_example() @@ -878,7 +885,15 @@ class WalkThroughTwoExample(ShowAveragingCost): ) self.dither() self.play(sigma.restore) - self.dither(2) + self.dither() + for mob in b, w_terms, a_terms: + self.play( + mob.shift, MED_SMALL_BUFF*DOWN, + rate_func = there_and_back, + submobject_mode = "lagged_start", + run_time = 1.5 + ) + self.dither() self.set_variables_as_attrs( rhs, w_terms, a_terms, b, @@ -926,10 +941,12 @@ class WalkThroughTwoExample(ShowAveragingCost): prev_activations = np.array([n.get_fill_opacity() for n in prev_neurons]) sorted_indices = np.argsort(prev_activations.flatten()) bright_neurons = VGroup() + dim_neurons = VGroup() edges_to_bright_neurons = VGroup() + for i in sorted_indices[:5]: + dim_neurons.add(prev_neurons[i]) for i in sorted_indices[-4:]: - bright_neurons.add(prev_neurons[i].copy()) - bright_neurons.set_stroke(YELLOW, 3) + bright_neurons.add(prev_neurons[i]) edges_to_bright_neurons.add(edges[i]) bright_edges = edges_to_bright_neurons.copy() bright_edges.set_stroke(YELLOW, 4) @@ -959,6 +976,11 @@ class WalkThroughTwoExample(ShowAveragingCost): ShowCreation(bright_edges), ShowCreation(bright_neurons) ) + self.play(LaggedStart( + ApplyMethod, bright_neurons, + lambda m : (m.shift, MED_LARGE_BUFF*LEFT), + rate_func = there_and_back + )) self.dither() self.play( ReplacementTransform(bright_edges[0].copy(), w_terms[0]), @@ -969,6 +991,11 @@ class WalkThroughTwoExample(ShowAveragingCost): for x in range(2): self.play(LaggedStart(ShowCreationThenDestruction, bright_edges)) self.play(LaggedStart(ShowCreation, bright_edges)) + self.play(LaggedStart( + ApplyMethod, dim_neurons, + lambda m : (m.shift, MED_LARGE_BUFF*LEFT), + rate_func = there_and_back + )) self.play(FadeOut(terms_rect)) self.dither() self.play( @@ -1076,7 +1103,7 @@ class WalkThroughTwoExample(ShowAveragingCost): seeing_words, thinking_words, words, morty, neuron_arrows, two_neuron_arrow, - bright_edges, bright_neurons, + bright_edges, ))) self.play( ApplyMethod(two_neuron.set_fill, WHITE, two_activation), @@ -1094,6 +1121,7 @@ class WalkThroughTwoExample(ShowAveragingCost): def show_desired_increase_to_previous_neurons(self): increase_words = self.increase_words two_neuron = self.two_neuron + two_decimal = self.two_decimal edges = two_neuron.edges_in prev_neurons = self.network_mob.layers[-2].neurons @@ -1118,6 +1146,13 @@ class WalkThroughTwoExample(ShowAveragingCost): negative_arrows.add(arrow) negative_edges.add(edge) negative_neurons.add(neuron) + for s_edges in positive_edges, negative_edges: + s_edges.alt_position = VGroup(*[ + Line(LEFT, RIGHT, color = s_edge.get_color()) + for s_edge in s_edges + ]) + s_edges.alt_position.arrange_submobjects(DOWN, MED_SMALL_BUFF) + s_edges.alt_position.to_corner(DOWN+RIGHT, LARGE_BUFF) added_words = TextMobject("in proportion to $w_i$") added_words.highlight(self.w_terms.get_color()) @@ -1138,38 +1173,45 @@ class WalkThroughTwoExample(ShowAveragingCost): for positive in [True, False]: if positive: arrows = positive_arrows - edges = positive_edges + s_edges = positive_edges neurons = positive_neurons color = self.positive_edge_color else: arrows = negative_arrows - edges = negative_edges + s_edges = negative_edges neurons = negative_neurons color = self.negative_edge_color - self.play( - LaggedStart( - Transform, edges, - lambda mob : ( - mob, - Dot( - mob.get_center(), - stroke_color = edges[0].get_color(), - stroke_width = 1, - radius = 0.25*SMALL_BUFF, - fill_opacity = 0 - ) - ), - rate_func = there_and_back - ), - neurons.set_stroke, color, 3, - ) + s_edges.save_state() + self.play(Transform(s_edges, s_edges.alt_position)) + self.dither(0.5) + self.play(s_edges.restore) self.play( LaggedStart(GrowArrow, arrows), - ApplyMethod( - neurons.set_fill, color, 1, - rate_func = there_and_back, - ) + neurons.set_stroke, color ) + self.play(ApplyMethod( + neurons.set_fill, color, 1, + rate_func = there_and_back, + )) + self.dither() + self.play( + two_neuron.set_fill, None, 0.8, + ChangingDecimal( + two_decimal, + lambda a : two_neuron.get_fill_opacity() + ), + run_time = 3, + rate_func = there_and_back + ) + self.dither() + self.play(*[ + ApplyMethod( + edge.set_stroke, None, 3*edge.get_stroke_width(), + rate_func = there_and_back, + run_time = 2 + ) + for edge in edges + ]) self.dither() self.play(Write(added_words, run_time = 1)) self.play(prev_neurons.set_stroke, WHITE, 2) @@ -1184,13 +1226,26 @@ class WalkThroughTwoExample(ShowAveragingCost): prev_neurons = self.network_mob.layers[-2].neurons rect = SurroundingRectangle(VGroup(arrows, prev_neurons)) - words = TextMobject("No direct influence") - words.next_to(rect, UP) + words1 = TextMobject("No direct influence") + words1.next_to(rect, UP) + words2 = TextMobject("Just keeping track") + words2.move_to(words1) + + edges = self.network_mob.edge_groups[-2] self.play(ShowCreation(rect)) - self.play(Write(words)) + self.play(Write(words1)) + self.play(LaggedStart( + Indicate, prev_neurons, + rate_func = wiggle + )) self.dither() - self.play(FadeOut(VGroup(words, rect))) + self.play(LaggedStart( + ShowCreationThenDestruction, edges + )) + self.play(Transform(words1, words2)) + self.dither() + self.play(FadeOut(VGroup(words1, rect))) def show_other_output_neurons(self): two_neuron = self.two_neuron @@ -1207,6 +1262,7 @@ class WalkThroughTwoExample(ShowAveragingCost): output_labels = self.network_mob.output_labels quads = zip(neurons, self.decimals, self.arrows, output_labels) + self.revert_to_original_skipping_status() self.play( two_neuron.restore, two_decimal.scale, 0.5, @@ -1218,7 +1274,7 @@ class WalkThroughTwoExample(ShowAveragingCost): FadeOut(VGroup(self.lhs, self.rhs)), *[e.restore for e in two_edges] ) - for neuron, decimal, arrow, label in quads[:2]: + for neuron, decimal, arrow, label in quads[:2] + quads[2:5]: plusses = VGroup() new_arrows = VGroup() for edge, prev_arrow in zip(neuron.edges_in, prev_neuron_arrows): @@ -1254,52 +1310,68 @@ class WalkThroughTwoExample(ShowAveragingCost): self.play( LaggedStart( - FadeIn, VGroup(*it.starmap(VGroup, quads[-7:])), + FadeIn, VGroup(*it.starmap(VGroup, quads[5:])), ), LaggedStart( - FadeIn, VGroup(*[n.edges_in for n in neurons[-7:]]) + FadeIn, VGroup(*[n.edges_in for n in neurons[5:]]) ), Write(all_dots_plus), run_time = 3, ) self.dither(2) - def squish(p): - return p[1]*UP + ## + words = TextMobject("Propagate backwards") + words.to_edge(UP) + words.highlight(BLUE) + target_arrows = prev_neuron_arrows.copy() + target_arrows.next_to(prev_neurons, RIGHT, SMALL_BUFF) + rect = SurroundingRectangle(VGroup( + self.network_mob.layers[-1], + self.network_mob.output_labels + )) + rect.set_fill(BLACK, 1) + rect.set_stroke(BLACK, 0) + self.play(Write(words)) + self.dither() self.play( - arrows_to_fade.apply_function, squish, - arrows_to_fade.move_to, prev_neurons, + FadeOut(self.network_mob.edge_groups[-1]), + FadeIn(rect), + ReplacementTransform(arrows_to_fade, VGroup(target_arrows)), ) + self.prev_neuron_arrows = target_arrows def show_recursion(self): - network_start = VGroup(*it.chain( - self.network_mob.edge_groups[1], - self.network_mob.layers[1], - self.network_mob.edge_groups[0], - self.network_mob.layers[0], - )) + network_mob = self.network_mob words_to_fade = VGroup( self.increase_words, self.in_proportion_to_w, self.in_proportion_to_a, ) + edges = network_mob.edge_groups[1] + neurons = network_mob.layers[2].neurons + prev_neurons = network_mob.layers[1].neurons + for neuron in neurons: + neuron.edges_in.save_state() self.play( FadeOut(words_to_fade), - LaggedStart(FadeIn, network_start, run_time = 3) + FadeIn(prev_neurons), + LaggedStart(ShowCreation, edges), ) self.dither() - for i in 1, 0: - edges = self.network_mob.edge_groups[i] - self.play(LaggedStart( - ApplyFunction, edges, - lambda edge : ( - lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), - edge - ), - rate_func = wiggle - )) - self.dither() + for neuron, arrow in zip(neurons, self.prev_neuron_arrows): + edge_copies = neuron.edges_in.copy() + for edge in edge_copies: + edge.set_stroke(arrow.get_color(), 2) + edge.rotate_in_place(np.pi) + self.play( + edges.set_stroke, None, 0.15, + neuron.edges_in.restore, + ) + self.play(ShowCreationThenDestruction(edge_copies)) + self.remove(edge_copies) + #### @@ -1315,6 +1387,14 @@ class WalkThroughTwoExample(ShowAveragingCost): value *= -1 return value +class WriteHebbian(Scene): + def construct(self): + words = TextMobject("Hebbian theory") + words.scale_to_fit_width(2*SPACE_WIDTH - 1) + words.to_edge(UP) + self.play(Write(words)) + self.dither() + class NotANeuroScientist(TeacherStudentsScene): def construct(self): quote = TextMobject("``Neurons that fire together wire together''") @@ -1750,6 +1830,21 @@ class ConstructGradientFromAllTrainingExamples(Scene): for x in range(n): self.play(random.choice(self.all_eyes).blink_anim()) +class WatchPreviousScene(TeacherStudentsScene): + def construct(self): + screen = ScreenRectangle(height = 4.5) + screen.to_corner(UP+LEFT) + + self.play( + self.teacher.change, "raise_right_hand", screen, + self.get_student_changes( + *["thinking"]*3, + look_at_arg = screen + ), + ShowCreation(screen) + ) + self.dither(10) + class OpenCloseSGD(Scene): def construct(self): term = TexMobject( @@ -1960,7 +2055,7 @@ class BackpropCodeAddOn(PiCreatureScene): morty.change, "pondering", morty.look, UP+LEFT ) - self.play(morty.look, DOWN+LEFT) + self.play(morty.look, LEFT) self.dither(2) class CannotFollowCode(TeacherStudentsScene): @@ -2007,6 +2102,7 @@ class SimplestNetworkExample(PreviewLearning): def construct(self): self.seed_random_libraries() self.collapse_ordinary_network() + self.show_weights_and_biases() self.focus_just_on_last_two_layers() self.label_neurons() self.show_desired_output() @@ -2095,6 +2191,52 @@ class SimplestNetworkExample(PreviewLearning): self.feed_forward(np.array([0.5])) self.dither() + def show_weights_and_biases(self): + network_mob = self.network_mob + edges = VGroup(*[eg[0] for eg in network_mob.edge_groups]) + neurons = VGroup(*[ + layer.neurons[0] + for layer in network_mob.layers[1:] + ]) + expression = TexMobject( + "C", "(", + "w_1", ",", "b_1", ",", + "w_2", ",", "b_2", ",", + "w_3", ",", "b_3", + ")" + ) + expression.shift(2*UP) + expression.highlight_by_tex("C", RED) + w_terms = expression.get_parts_by_tex("w_") + for w, edge in zip(w_terms, edges): + w.highlight(edge.get_color()) + b_terms = expression.get_parts_by_tex("b_") + variables = VGroup(*it.chain(w_terms, b_terms)) + other_terms = VGroup(*filter( + lambda m : m not in variables, + expression + )) + random.shuffle(variables.submobjects) + + self.play(ReplacementTransform(edges.copy(), w_terms)) + self.dither() + self.play(ReplacementTransform(neurons.copy(), b_terms)) + self.dither() + self.play(Write(other_terms)) + for x in range(2): + self.play(LaggedStart( + Indicate, variables, + rate_func = wiggle, + run_time = 4, + )) + self.dither() + self.play( + FadeOut(other_terms), + ReplacementTransform(w_terms, edges), + ReplacementTransform(b_terms, neurons), + ) + self.remove(expression) + def focus_just_on_last_two_layers(self): to_fade = VGroup(*it.chain(*zip( self.network_mob.layers[:2], @@ -2244,6 +2386,24 @@ class SimplestNetworkExample(PreviewLearning): ) VGroup(C0, cost_word, cost_arrow).highlight(self.cost_color) + expression = TexMobject( + "\\text{For example: }" + "(", "0.00", "-", "0.00", ")", "^2" + ) + numbers = expression.get_parts_by_tex("0.00") + non_numbers = VGroup(*filter( + lambda m : m not in numbers, expression + )) + expression.next_to(cost_equation, DOWN, aligned_edge = RIGHT) + decimals = VGroup( + self.decimals[0], + self.desired_output_decimal + ).copy() + decimals.generate_target() + for d, n in zip(decimals.target, numbers): + d.replace(n, dim_to_match = 1) + d.highlight(n.get_color()) + self.play( ReplacementTransform(pre_a, a), ReplacementTransform(pre_y, y), @@ -2254,6 +2414,10 @@ class SimplestNetworkExample(PreviewLearning): cost_equation )) )) + self.play( + MoveToTarget(decimals), + FadeIn(non_numbers) + ) self.dither() self.play( Write(cost_word, run_time = 1), @@ -2261,6 +2425,7 @@ class SimplestNetworkExample(PreviewLearning): ) self.play(C0.shift, MED_SMALL_BUFF*UP, rate_func = wiggle) self.dither() + self.play(*map(FadeOut, [decimals, non_numbers])) self.set_variables_as_attrs( cost_equation, cost_word, cost_arrow @@ -2455,12 +2620,25 @@ class SimplestNetworkExample(PreviewLearning): comp_graph.z_to_a_line.copy(), ) new_subgraph = VGroup(new_terms, new_edges) + new_subgraph.next_to(comp_graph.target, UP, SMALL_BUFF) self.wLm1 = new_terms[0] self.zLm1 = new_terms[-1] - self.play(ShowCreation(rect)) + prev_neuron = self.network_mob.layers[1] + prev_neuron.restore() + prev_edge = self.network_mob.edge_groups[1] + prev_edge.restore() + self.play( - new_subgraph.next_to, comp_graph.target, UP, SMALL_BUFF, + ShowCreation(rect), + FadeIn(prev_neuron), + ShowCreation(prev_edge) + ) + self.play( + ReplacementTransform( + VGroup(prev_neuron, prev_edge).copy(), + new_subgraph + ), UpdateFromAlphaFunc( new_terms, lambda m, a : m.set_fill(opacity = a) @@ -2471,10 +2649,13 @@ class SimplestNetworkExample(PreviewLearning): self.dither(2) self.play( FadeOut(new_subgraph), + FadeOut(prev_neuron), + FadeOut(prev_edge), comp_graph.restore, rect.shift, -shift_vect, rect.set_stroke, BLACK, 0 ) + VGroup(prev_neuron, prev_edge).fade(1) self.remove(rect) self.dither() @@ -2712,6 +2893,11 @@ class SimplestNetworkExample(PreviewLearning): def show_chain_rule(self): dC_dw = self.dC_dw + del_syms = [ + getattr(self, attr) + for attr in "del_wL", "del_zL", "del_aL", "del_C0" + ] + dz_dw = TexMobject( "{\\partial z^{(L)}", "\\over", "\\partial w^{(L)}}" ) @@ -2734,19 +2920,18 @@ class SimplestNetworkExample(PreviewLearning): y = mob[1].get_center()[1] mob.shift((target_y - y)*UP) - last_sym = dC_dw[2] self.play(Write(equals, run_time = 1)) - for fraction in group[1:]: - self.play(LaggedStart( - FadeIn, VGroup(*fraction[:2]), - lag_ratio = 0.75, - run_time = 1 - )) + for frac, top_sym, bot_sym in zip(group[1:], del_syms[1:], del_syms): + self.play(Indicate(top_sym, rate_func = wiggle)) + self.play( + ReplacementTransform(top_sym.copy(), frac[0]), + FadeIn(frac[1]), + ) + self.play(Indicate(bot_sym, rate_func = wiggle)) self.play(ReplacementTransform( - last_sym.copy(), fraction[2] + bot_sym.copy(), frac[2] )) self.dither() - last_sym = fraction[0] self.shake_dot() self.dither() @@ -2807,7 +2992,6 @@ class SimplestNetworkExample(PreviewLearning): ).update(1) cost_equation.target[0].next_to(cost_eq, LEFT, SMALL_BUFF) cost_equation.target.shift(x_shift) - cost_equation.shift(MED_SMALL_BUFF*DOWN) self.play( FadeOut(self.all_comp_graph_parts), @@ -2834,10 +3018,11 @@ class SimplestNetworkExample(PreviewLearning): deriv.equals = TexMobject("=") deriv.equals.next_to(deriv.target, RIGHT) + #dC_da self.play( MoveToTarget(dC_da), - Write(dC_da.equals,) + Write(dC_da.equals) ) index = 4 cost_rhs = VGroup(*cost_equation[index+1:]) @@ -2848,6 +3033,7 @@ class SimplestNetworkExample(PreviewLearning): dC_da.rhs.next_to(dC_da.equals, RIGHT) dC_da.rhs.shift(0.7*SMALL_BUFF*UP) cost_equation.save_state() + self.play( cost_equation.next_to, dC_da.rhs, DOWN, MED_LARGE_BUFF, LEFT @@ -2870,19 +3056,42 @@ class SimplestNetworkExample(PreviewLearning): buff = SMALL_BUFF, color = RED ) + + moving_decimals = VGroup( + self.decimals[0].copy(), + self.desired_output_decimal.copy() + ) + minus = TexMobject("-") + minus.move_to(moving_decimals) + minus.scale(0.7) + minus.set_fill(opacity = 0) + moving_decimals.submobjects.insert(1, minus) + moving_decimals.generate_target(use_deepcopy = True) + moving_decimals.target.arrange_submobjects(RIGHT, buff = SMALL_BUFF) + moving_decimals.target.scale(1.5) + moving_decimals.target.next_to( + dC_da.rhs, DOWN, + buff = MED_LARGE_BUFF, + aligned_edge = RIGHT, + ) + moving_decimals.target.set_fill(WHITE, 1) + self.play(ReplacementTransform( dC_da.rhs.copy(), double_arrow )) + self.dither() + self.play(MoveToTarget(moving_decimals)) opacity = neuron.get_fill_opacity() for target_o in 0, opacity: self.dither(2) self.play( neuron.set_fill, None, target_o, - ChangingDecimal( - decimal, lambda a : neuron.get_fill_opacity() - ) + *[ + ChangingDecimal(d, lambda a : neuron.get_fill_opacity()) + for d in decimal, moving_decimals[0] + ] ) - self.play(FadeOut(double_arrow)) + self.play(*map(FadeOut, [double_arrow, moving_decimals])) #da_dz self.play( @@ -2925,6 +3134,9 @@ class SimplestNetworkExample(PreviewLearning): DOWN, MED_LARGE_BUFF, LEFT, ) self.dither() + rect = SurroundingRectangle(VGroup(*zL_formula[2:4])) + self.play(ShowCreation(rect)) + self.play(FadeOut(rect)) self.play(ReplacementTransform( z_rhs[1].copy(), dz_dw.rhs, )) @@ -3073,12 +3285,12 @@ class SimplestNetworkExample(PreviewLearning): self.play(Transform(mover, dCk_dw)) self.play(Write(full_derivative, run_time = 2)) self.remove(mover) - self.play( - GrowFromCenter(lhs_brace), - GrowFromCenter(rhs_brace), - Write(lhs_text, run_time = 2), - Write(rhs_text, run_time = 2), - ) + for brace, text in (rhs_brace, rhs_text), (lhs_brace, lhs_text): + self.play( + GrowFromCenter(brace), + Write(text, run_time = 2), + ) + self.dither(2) self.cycle_through_altnernate_training_examples() self.play(*map(FadeOut, [ VGroup(*full_derivative[3:]), @@ -3185,6 +3397,7 @@ class SimplestNetworkExample(PreviewLearning): dz_dw = self.chain_rule_equation[2] aLm1 = self.chain_rule_rhs[0] left_term_group = VGroup(dz_dw, aLm1) + dz_dw_rect = SurroundingRectangle(dz_dw) del_w = dC0_dw[2] del_b = TexMobject("\\partial b^{(L)}") @@ -3224,7 +3437,14 @@ class SimplestNetworkExample(PreviewLearning): lag_ratio = 0.7, ) + zL_formula = self.zL_formula + b_in_z_formula = zL_formula[-1] + z_formula_rect = SurroundingRectangle(zL_formula) + b_in_z_rect = SurroundingRectangle(b_in_z_formula) + self.play(get_path_animation()) + self.play(ShowCreation(dz_dw_rect)) + self.play(FadeOut(dz_dw_rect)) self.play( left_term_group.shift, DOWN, left_term_group.fade, 1, @@ -3232,11 +3452,18 @@ class SimplestNetworkExample(PreviewLearning): self.remove(left_term_group) self.chain_rule_equation.remove(dz_dw) self.chain_rule_rhs.remove(aLm1) - self.play( - Transform(del_w, del_b), - FadeIn(dz_db) - ) + self.play(Transform(del_w, del_b)) + self.play(FadeIn(dz_db)) self.play(get_path_animation()) + self.dither() + self.play(ShowCreation(z_formula_rect)) + self.dither() + self.play(ReplacementTransform(z_formula_rect, b_in_z_rect)) + self.dither() + self.play( + ReplacementTransform(b_in_z_formula.copy(), one), + FadeOut(b_in_z_rect) + ) self.play( ShowCreation(arrow), ReplacementTransform( @@ -3262,6 +3489,7 @@ class SimplestNetworkExample(PreviewLearning): dz_daLm1.next_to(self.chain_rule_equation[1], RIGHT, SMALL_BUFF) dz_daLm1.shift(0.7*SMALL_BUFF*UP) dz_daLm1[0].highlight(self.z_color) + dz_daLm1_rect = SurroundingRectangle(dz_daLm1) wL = self.zL_formula[2].copy() wL.next_to(self.chain_rule_rhs[0], LEFT, SMALL_BUFF) @@ -3285,14 +3513,33 @@ class SimplestNetworkExample(PreviewLearning): lag_ratio = 0.7, ) - self.play(get_path_animation()) + zL_formula = self.zL_formula + z_formula_rect = SurroundingRectangle(zL_formula) + a_in_z_rect = SurroundingRectangle(VGroup(*zL_formula[2:4])) + wL_in_z = zL_formula[2] + + for x in range(3): + self.play(get_path_animation()) self.play( numer.shift, SMALL_BUFF*UP, - Transform(denom, del_aLm1), + Transform(denom, del_aLm1) + ) + self.play( FadeIn(dz_daLm1), VGroup(*self.chain_rule_equation[-2:]).shift, SMALL_BUFF*RIGHT, ) self.dither() + self.play(ShowCreation(dz_daLm1_rect)) + self.dither() + self.play(ReplacementTransform( + dz_daLm1_rect, z_formula_rect + )) + self.dither() + self.play(ReplacementTransform(z_formula_rect, a_in_z_rect)) + self.play( + ReplacementTransform(wL_in_z.copy(), wL), + FadeOut(a_in_z_rect) + ) self.play( ShowCreation(arrow), ReplacementTransform( @@ -3422,6 +3669,8 @@ class GeneralFormulas(SimplestNetworkExample): self.setup_bases() def construct(self): + self.force_skipping() + self.setup_network_mob() self.show_all_a_labels() self.only_show_abstract_a_labels() @@ -3605,6 +3854,7 @@ class GeneralFormulas(SimplestNetworkExample): lambda m : m not in [aj.target, yj.target], cost_equation )) + sum_part = cost_equation.get_part_by_tex("sum") self.play(*[ ReplacementTransform(mob, mob.target) @@ -3612,6 +3862,14 @@ class GeneralFormulas(SimplestNetworkExample): ]) self.play(LaggedStart(FadeIn, to_fade_in)) self.dither(2) + self.play(LaggedStart( + Indicate, sum_part, + rate_func = wiggle, + )) + self.dither() + for mob in aj.target, yj.target, cost_equation[-1]: + self.play(Indicate(mob)) + self.dither() self.set_variables_as_attrs(cost_equation) @@ -3627,6 +3885,7 @@ class GeneralFormulas(SimplestNetworkExample): faded_edge.save_state() w_label = TexMobject("w^{(L)}_{jk}") + subscripts = VGroup(*w_label[-2:]) w_label.scale(1.2) w_label.add_background_rectangle() w_label.next_to(ORIGIN, UP, SMALL_BUFF) @@ -3634,9 +3893,33 @@ class GeneralFormulas(SimplestNetworkExample): w_label.shift(edge.get_center()) w_label.highlight(BLUE) + edges.save_state() + edges.generate_target() + for e in edges.target: + e.rotate(-e.get_angle()) + edges.target.arrange_submobjects(DOWN) + edges.target.move_to(edges) + edges.target.to_edge(UP) + + self.play(MoveToTarget(edges)) + self.play(LaggedStart( + ApplyFunction, edges, + lambda e : ( + lambda m : m.rotate_in_place(np.pi/12).highlight(YELLOW), + e + ), + rate_func = wiggle + )) + self.play(edges.restore) self.play(faded_edges.fade, 0.9) + for neuron in self.chosen_neurons: + self.play(Indicate(neuron), Animation(neuron.decimal)) self.play(Write(w_label)) self.dither() + self.play(Indicate(subscripts)) + for x in range(2): + self.play(Swap(*subscripts)) + self.dither() self.set_variables_as_attrs(faded_edges, w_label) @@ -3831,6 +4114,7 @@ class GeneralFormulas(SimplestNetworkExample): self.dither() def show_previous_layer(self): + mid_neurons = self.network_mob.layers[1].neurons layer = self.network_mob.layers[0] edges = self.network_mob.edge_groups[0] faded_edges = self.faded_edges @@ -3838,16 +4122,59 @@ class GeneralFormulas(SimplestNetworkExample): self.chosen_neurons[0].label, self.chosen_neurons[0].arrow, ) + for neuron in layer.neurons: + neuron.add(self.get_neuron_activation_decimal(neuron)) + all_edges_out = VGroup(*[ + VGroup(*[n.edges_in[i] for n in mid_neurons]).copy() + for i in range(len(layer.neurons)) + ]) + all_edges_out.set_stroke(YELLOW, 3) + + deriv = VGroup(*self.chain_rule[:3]) + deriv_rect = SurroundingRectangle(deriv) + mid_neuron_outlines = mid_neurons.copy() + mid_neuron_outlines.set_fill(opacity = 0) + mid_neuron_outlines.set_stroke(YELLOW, 5) + + def get_neurons_decimal_anims(neuron): + return [ + ChangingDecimal( + neuron.decimal, + lambda a : neuron.get_fill_opacity(), + ), + UpdateFromFunc( + neuron.decimal, + lambda m : m.set_fill( + WHITE if neuron.get_fill_opacity() < 0.8 else BLACK + ) + ) + ] + + self.revert_to_original_skipping_status() + self.play(ShowCreation(deriv_rect)) + self.play(LaggedStart( + ShowCreationThenDestruction, + mid_neuron_outlines + )) + self.play(*it.chain(*[ + [ + ApplyMethod(n.set_fill, None, random.random()), + ] + get_neurons_decimal_anims(n) + for n in mid_neurons + ]), run_time = 4, rate_func = there_and_back) self.play(faded_edges.restore) self.play( LaggedStart( GrowFromCenter, layer.neurons, run_time = 1 ), + LaggedStart(ShowCreation, edges), FadeOut(to_fade) ) - self.play(LaggedStart(ShowCreation, edges)) + for x in range(3): + for edges_out in all_edges_out: + self.play(ShowCreationThenDestruction(edges_out)) self.dither() #### @@ -3871,6 +4198,15 @@ class GeneralFormulas(SimplestNetworkExample): }) return chain_rule +class ThatsPrettyMuchIt(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "That's pretty \\\\ much it!", + target_mode = "hooray", + run_time = 1, + ) + self.dither(2) + class PatYourselfOnTheBack(TeacherStudentsScene): def construct(self): self.teacher_says( @@ -3880,12 +4216,183 @@ class PatYourselfOnTheBack(TeacherStudentsScene): self.change_student_modes(*["hooray"]*3) self.dither(3) - - - - - - +class ThatsALotToThinkAbout(TeacherStudentsScene): + def construct(self): + self.teacher_says( + "That's a lot to \\\\ think about!", + target_mode = "surprised" + ) + self.change_student_modes(*["thinking"]*3) + self.dither(4) + +class SponsorFrame(PiCreatureScene): + def construct(self): + morty = self.pi_creature + screen = ScreenRectangle(height = 5) + screen.to_corner(UP+LEFT) + url = TextMobject("http://3b1b.co/crowdflower") + url.move_to(screen, UP+LEFT) + screen.shift(LARGE_BUFF*DOWN) + arrow = Arrow(LEFT, RIGHT, color = WHITE) + arrow.next_to(url, RIGHT) + + t_shirt_words = TextMobject("Free T-Shirt") + t_shirt_words.scale(1.5) + t_shirt_words.highlight(YELLOW) + t_shirt_words.next_to(morty, UP, aligned_edge = RIGHT) + + human_in_the_loop = TextMobject("Human-in-the-loop approach") + human_in_the_loop.next_to(screen, DOWN) + + self.play( + morty.change, "hooray", t_shirt_words, + Write(t_shirt_words, run_time = 2) + ) + self.dither() + self.play( + morty.change, "raise_right_hand", screen, + ShowCreation(screen) + ) + self.play( + t_shirt_words.scale, 1./1.5, + t_shirt_words.next_to, arrow, RIGHT + ) + self.play(Write(url)) + self.play(GrowArrow(arrow)) + self.dither(2) + self.play(morty.change, "thinking", url) + self.dither(3) + self.play(Write(human_in_the_loop)) + self.play(morty.change, "happy", url) + self.play(morty.look_at, screen) + self.dither(7) + t_shirt_words_outline = t_shirt_words.copy() + t_shirt_words_outline.set_fill(opacity = 0) + t_shirt_words_outline.set_stroke(GREEN, 3) + self.play( + morty.change, "hooray", t_shirt_words, + LaggedStart(ShowCreation, t_shirt_words_outline), + ) + self.play(FadeOut(t_shirt_words_outline)) + self.play(LaggedStart( + Indicate, url, + rate_func = wiggle, + color = PINK, + run_time = 3 + )) + self.dither(3) + +class NN3PatreonThanks(PatreonThanks): + CONFIG = { + "specific_patrons" : [ + "Randall Hunt", + "Burt Humburg", + "CrypticSwarm", + "Juan Benet", + "David Kedmey", + "Michael Hardwicke", + "Nathan Weeks", + "Marcus Schiebold", + "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", + "1stViewMaths", + "Jacob Magnuson", + "Mark Govea", + "Dagan Harrington", + "Clark Gaebel", + "Eric Chow", + "Mathias Jansson", + "Robert Teed", + "Pedro Perez Sanchez", + "David Clark", + "Michael Gardner", + "Harsev Singh", + "Mads Elvheim", + "Erik Sundell", + "Xueqi Li", + "Dr. David G. Stork", + "Tianyu Ge", + "Ted Suzman", + "Linh Tran", + "Andrew Busey", + "John Haley", + "Ankalagon", + "Eric Lavault", + "Boris Veselinovich", + "Julian Pulgarin", + "Jeff Linse", + "Cooper Jones", + "Ryan Dahl", + "Jason Hise", + "Meshal Alshammari", + "Bernd Sing", + "Mustafa Mahdi", + "Mathew Bramson", + "Jerry Ling", + "Vecht", + "Shimin Kuang", + "Rish Kundalia", + "Achille Brighton", + "Ripta Pasay", + ], + "max_patron_group_size" : 25, + "patron_scale_val" : 0.7, + } + +class Thumbnail(PreviewLearning): + CONFIG = { + "layer_sizes" : [8, 6, 6, 4], + "network_mob_config" : { + "neuron_radius" : 0.3, + "neuron_to_neuron_buff" : MED_SMALL_BUFF, + "include_output_labels" : False, + }, + "stroke_width_exp" : 1, + "max_stroke_width" : 5, + } + def construct(self): + self.color_network_edges() + network_mob = self.network_mob + network_mob.scale(0.8, about_point = network_mob.get_bottom()) + network_mob.activate_layers(np.random.random(self.layer_sizes[0])) + + for edge in it.chain(*network_mob.edge_groups): + arrow = Arrow( + edge.get_end(), edge.get_start(), + buff = 0, + tip_length = 0.1, + color = edge.get_color() + ) + self.add(arrow.tip) + + arrow = Vector( + 3*LEFT, + tip_length = 0.75, + rectangular_stem_width = 0.2, + color = BLUE, + ) + arrow.next_to(network_mob.edge_groups[1], UP, MED_LARGE_BUFF) + + self.add(arrow) + + title = TextMobject("Backpropagation") + title.scale(2) + title.to_edge(UP) + self.add(title) From b07b9507d0c70e52e753cee9fb771af4f2065125 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Thu, 2 Nov 2017 22:58:54 -0700 Subject: [PATCH 42/43] Change patreon thanks default --- topics/common_scenes.py | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-) diff --git a/topics/common_scenes.py b/topics/common_scenes.py index 431a88db..9e39c6ec 100644 --- a/topics/common_scenes.py +++ b/topics/common_scenes.py @@ -61,36 +61,7 @@ class OpeningQuote(Scene): class PatreonThanks(Scene): CONFIG = { - "specific_patrons" : [ - "Ali Yahya", - "Meshal Alshammari", - "CrypticSwarm ", - "Justin Helps", - "Ankit Agarwal", - "Yu Jun", - "Shelby Doolittle", - "Dave Nicponski", - "Damion Kistler", - "Juan Benet", - "Othman Alikhan", - "Markus Persson", - "Dan Buchoff", - "Derek Dai", - "Joseph John Cox", - "Luc Ritchie", - "Nils Schneider", - "Mathew Bramson", - "Guido Gambardella", - "Jerry Ling", - "Mark Govea", - "Vecht", - "Shimin Kuang", - "Rish Kundalia", - "Achille Brighton", - "Kirk Werklund", - "Ripta Pasay", - "Felipe Diniz", - ], + "specific_patrons" : [], "max_patron_group_size" : 20, "patron_scale_val" : 0.8, From 60937802159abc863f2c4364e30c7fe0fea43c71 Mon Sep 17 00:00:00 2001 From: Grant Sanderson Date: Tue, 7 Nov 2017 16:11:36 -0800 Subject: [PATCH 43/43] Finished nn/part3 --- nn/part3.py | 140 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 121 insertions(+), 19 deletions(-) diff --git a/nn/part3.py b/nn/part3.py index 7cfbe569..0e8471b7 100644 --- a/nn/part3.py +++ b/nn/part3.py @@ -3669,8 +3669,6 @@ class GeneralFormulas(SimplestNetworkExample): self.setup_bases() def construct(self): - self.force_skipping() - self.setup_network_mob() self.show_all_a_labels() self.only_show_abstract_a_labels() @@ -3925,22 +3923,34 @@ class GeneralFormulas(SimplestNetworkExample): def show_values_between_weight_and_cost(self): z_formula = TexMobject( - "z^{(L)}_j", "=", "\\cdots", "+" - "w^{(L)}_{jk}", "a^{(L-1)}_k", "+", "\\cdots" + "z^{(L)}_j", "=", + "w^{(L)}_{j0}", "a^{(L-1)}_0", "+", + "w^{(L)}_{j1}", "a^{(L-1)}_1", "+", + "w^{(L)}_{j2}", "a^{(L-1)}_2", "+", + "b^{(L)}_j" ) - z_formula.to_corner(UP+RIGHT) - z_formula.highlight_by_tex_to_color_map({ - "z^" : self.z_color, - "w^" : self.w_label.get_color() - }) - w_part = z_formula.get_part_by_tex("w^") - aLm1_part = z_formula.get_part_by_tex("a^{(L-1)}") + compact_z_formula = TexMobject( + "z^{(L)}_j", "=", + "\\cdots", "", "+" + "w^{(L)}_{jk}", "a^{(L-1)}_k", "+", + "\\cdots", "", "", "", + ) + for expression in z_formula, compact_z_formula: + expression.to_corner(UP+RIGHT) + expression.highlight_by_tex_to_color_map({ + "z^" : self.z_color, + "w^" : self.w_label.get_color(), + "b^" : MAROON_B, + }) + w_part = z_formula.get_parts_by_tex("w^")[1] + aLm1_part = z_formula.get_parts_by_tex("a^{(L-1)}")[1] a_formula = TexMobject( "a^{(L)}_j", "=", "\\sigma(", "z^{(L)}_j", ")" ) a_formula.highlight_by_tex("z^", self.z_color) a_formula.next_to(z_formula, DOWN, MED_LARGE_BUFF) + a_formula.align_to(self.cost_equation, LEFT) aL_part = a_formula[0] to_fade = VGroup( @@ -3973,10 +3983,16 @@ class GeneralFormulas(SimplestNetworkExample): self.chosen_neurons[1].label.copy(), aL_part )) - self.play(Write(VGroup(*a_formula[1:]))) + self.play( + Write(VGroup(*a_formula[1:3] + [a_formula[-1]])), + ReplacementTransform( + z_formula[0].copy(), + a_formula.get_part_by_tex("z^") + ) + ) self.dither() - self.set_variables_as_attrs(z_formula, a_formula) + self.set_variables_as_attrs(z_formula, compact_z_formula, a_formula) def show_weight_chain_rule(self): chain_rule = self.get_chain_rule( @@ -3996,6 +4012,9 @@ class GeneralFormulas(SimplestNetworkExample): ]) rects.gradient_highlight(GREEN, WHITE, RED) + self.play(Transform( + self.z_formula, self.compact_z_formula + )) self.play(Write(chain_rule)) self.dither() self.play(LaggedStart( @@ -4151,7 +4170,6 @@ class GeneralFormulas(SimplestNetworkExample): ) ] - self.revert_to_original_skipping_status() self.play(ShowCreation(deriv_rect)) self.play(LaggedStart( ShowCreationThenDestruction, @@ -4225,6 +4243,70 @@ class ThatsALotToThinkAbout(TeacherStudentsScene): self.change_student_modes(*["thinking"]*3) self.dither(4) +class LayersOfComplexity(Scene): + def construct(self): + chain_rule_equations = self.get_chain_rule_equations() + chain_rule_equations.to_corner(UP+RIGHT) + + brace = Brace(chain_rule_equations, LEFT) + arrow = Vector(LEFT, color = RED) + arrow.next_to(brace, LEFT) + gradient = TexMobject("\\nabla C") + gradient.scale(2) + gradient.highlight(RED) + gradient.next_to(arrow, LEFT) + + self.play(LaggedStart(FadeIn, chain_rule_equations)) + self.play(GrowFromCenter(brace)) + self.play(GrowArrow(arrow)) + self.play(Write(gradient)) + self.dither() + + + def get_chain_rule_equations(self): + w_deriv = TexMobject( + "{\\partial C", "\\over", "\\partial w^{(l)}_{jk}}", + "=", + "a^{(l-1)}_k", + "\\sigma'(z^{(l)}_j)", + "{\\partial C", "\\over", "\\partial a^{(l)}_j}", + ) + lil_rect = SurroundingRectangle( + VGroup(*w_deriv[-3:]), + buff = 0.5*SMALL_BUFF + ) + a_deriv = TexMobject( + "\\sum_{j = 0}^{n_{l+1} - 1}", + "w^{(l+1)}_{jk}", + "\\sigma'(z^{(l+1)}_j)", + "{\\partial C", "\\over", "\\partial a^{(l+1)}_j}", + ) + or_word = TextMobject("or") + last_a_deriv = TexMobject("2(a^{(L)}_j - y_j)") + + a_deriv.next_to(w_deriv, DOWN, LARGE_BUFF) + or_word.next_to(a_deriv, DOWN) + last_a_deriv.next_to(or_word, DOWN, MED_LARGE_BUFF) + + big_rect = SurroundingRectangle(VGroup(a_deriv, last_a_deriv)) + arrow = Arrow( + lil_rect.get_corner(DOWN+LEFT), + big_rect.get_top(), + ) + + result = VGroup( + w_deriv, lil_rect, arrow, + big_rect, a_deriv, or_word, last_a_deriv + ) + for expression in w_deriv, a_deriv, last_a_deriv: + expression.highlight_by_tex_to_color_map({ + "C" : RED, + "z^" : GREEN, + "w^" : BLUE, + "b^" : MAROON_B, + }) + return result + class SponsorFrame(PiCreatureScene): def construct(self): morty = self.pi_creature @@ -4363,11 +4445,16 @@ class Thumbnail(PreviewLearning): }, "stroke_width_exp" : 1, "max_stroke_width" : 5, + "title" : "Backpropagation", + "network_scale_val" : 0.8, } def construct(self): self.color_network_edges() network_mob = self.network_mob - network_mob.scale(0.8, about_point = network_mob.get_bottom()) + network_mob.scale( + self.network_scale_val, + about_point = network_mob.get_bottom() + ) network_mob.activate_layers(np.random.random(self.layer_sizes[0])) for edge in it.chain(*network_mob.edge_groups): @@ -4377,7 +4464,7 @@ class Thumbnail(PreviewLearning): tip_length = 0.1, color = edge.get_color() ) - self.add(arrow.tip) + network_mob.add(arrow.tip) arrow = Vector( 3*LEFT, @@ -4387,14 +4474,29 @@ class Thumbnail(PreviewLearning): ) arrow.next_to(network_mob.edge_groups[1], UP, MED_LARGE_BUFF) - self.add(arrow) + network_mob.add(arrow) + self.add(network_mob) - title = TextMobject("Backpropagation") + title = TextMobject(self.title) title.scale(2) title.to_edge(UP) self.add(title) - +class SupplementThumbnail(Thumbnail): + CONFIG = { + "title" : "Backpropagation \\\\ calculus", + "network_scale_val" : 0.7, + } + def construct(self): + Thumbnail.construct(self) + self.network_mob.to_edge(DOWN, buff = MED_SMALL_BUFF) + + for layer in self.network_mob.layers: + for neuron in layer.neurons: + partial = TexMobject("\\partial") + partial.move_to(neuron) + self.remove(neuron) + self.add(partial)