From 16b6aa22b69feef6898432f75d5e50bcc7644448 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Thu, 23 Feb 2017 15:03:16 -0500 Subject: [PATCH 01/83] Check it out! --- interactive_color.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 interactive_color.py diff --git a/interactive_color.py b/interactive_color.py new file mode 100644 index 0000000..f034d5e --- /dev/null +++ b/interactive_color.py @@ -0,0 +1,4 @@ +""" +This is our awesome Project +@author Colvin Chapman and Sean Szymanski + """ From 7204bfaa1da19d4c64c2df008978e4ffa90f948f Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 27 Feb 2017 13:33:59 -0500 Subject: [PATCH 02/83] Project Proposal for Sean Szymanski and Colvin Chapman --- ProjectProposal | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 ProjectProposal diff --git a/ProjectProposal b/ProjectProposal new file mode 100644 index 0000000..f5f9a77 --- /dev/null +++ b/ProjectProposal @@ -0,0 +1,27 @@ +Catch Them Colors! +Sean Szymanski and Colvin Chapman +Overview +Main Idea: The main idea of this project is to create a game involving color sensing. The game will be played in real time using a computer’s webcam. The game begins when the computer generates a color. The user will then take the computer around the real world and find that color. When the color is found, the player wins. The game may vary from this slightly. For example, you could match the highest number of things in a certain time period, or you could base a match on the average value of the pixels on the screen instead of having an exact color. The specific goal will be flushed out as we go. +Topics: This will be related to graphics and vision processing. It will also be interactive with the user. +MVP +Our mvp is a game that will run in terminal without graphics. +The program tells us to find a color, with a visual representation of that color. +There will be a command to take a picture using the camera in the laptop, and our program will tell you if the colors in the picture are close enough to the original. +Stretch Goal +Stretch goal is to do the game exactly in real time. This would involve having a bar on the side of the screen that currently updates with the RGB value that it reads and shows an image of the color it sees. +Implementing a profile system. The program would save the profile of a user and would save the number of colors caught. +Implement a scoring system. +Learning Goals +Colvin: Learn how to find information about programing online. I’m assuming there are many structures already in place, and learning how to utilize them will be vital to growing my software skills. As a more concrete goal, I would enjoy looking into graphics and interactive display, but OpenCV comes first. +Sean: I want to learn how to use OpenCV succesfully. This would be a very useful tool for the future. I also want to learn how to make the interface for the program. Interfaces seem difficult, but also very useful. +Libraries +OpenCV +Image Processing? +General Graphics Library +We will figure this out by doing online research into analyzing webcam images +Mid-Project Check-In Progress: +Chosen Libraries +Implementation Plan +Random Color Generator +Implemented OpenCV in some form + From 9f26f10a7fe365495fa4d4282c3f719e07bcebc0 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Thu, 2 Mar 2017 13:39:01 -0500 Subject: [PATCH 03/83] Rectangle Game --- continuous Rectangle.py | 150 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 continuous Rectangle.py diff --git a/continuous Rectangle.py b/continuous Rectangle.py new file mode 100644 index 0000000..6fcc9f6 --- /dev/null +++ b/continuous Rectangle.py @@ -0,0 +1,150 @@ +import pygame + +import pygame +from math import pi + +pygame.init() +size = [400, 300] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) + +class Rectangle(): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + def draw_rectangle(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_shot(self): + self.x = self.x + 10 + self.y = self.y + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + +def main(): + # Initialize the game engine + pygame.init() + + # Define the colors we will use in RGB format + color_matrix = [BLACK, BLUE, GREEN, RED] + # Set the height and width of the screen + size = [400, 300] + screen = pygame.display.set_mode(size) + + pygame.display.set_caption("Example code for the draw module") + shoot_object_list = [] + #Loop until the user clicks the close button. + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangles_x = 100 + rectangles_y = 100 + rectangle_list = [] + which_object = "Rectangle" + color = 0 + draw_rectangle = 0 + while not done: + clock.tick(10) + keys = pygame.key.get_pressed() + if keys[pygame.K_UP]: + rectangles_y += -3 + if keys[pygame.K_DOWN]: + rectangles_y += 3 + if keys[pygame.K_LEFT]: + rectangles_x += -3 + if keys[pygame.K_RIGHT]: + rectangles_x += 3 + for event in pygame.event.get(): # User did something + + + + if event.type == pygame.QUIT: # If user clicked close + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_c: + color+=1 + if color == 3: + color = 0 + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + text_x +=-10 + if event.key == pygame.K_d: + text_x+=10 + if event.key == pygame.K_w: + text_y += -10 + if event.key == pygame.K_s: + text_y += 10 + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + rectangles_x +=-10 + if event.key == pygame.K_d: + rectangles_x+=10 + if event.key == pygame.K_w: + rectangles_y += -10 + if event.key == pygame.K_s: + rectangles_y += 10 + if event.key == pygame.K_f: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + shoot_object_list.append(rectangle) + if event.key == pygame.K_g: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + if event.key == pygame.K_z: + rectangle_list = [] + # All drawing code happens after the for loop and but + # inside the main while done==False loop. + + # Clear the screen and set the screen background + screen.fill(WHITE) + + # Draw on the screen a GREEN line from (0,0) to (50.75) + # 5 pixels wide. + myfont = pygame.font.SysFont("monospace", 15) + keys=pygame.key.get_pressed() + + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + #pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) + #pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80]) + + #pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5) + #rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y, 10, 10) + for rectangles in rectangle_list: + rectangles.draw_rectangle() + for shooters in shoot_object_list: + shooters.draw_shot() + pygame.draw.rect(screen, color_matrix[color], [rectangles_x, rectangles_y, 50, 20]) + pygame.draw.rect(screen, color_matrix[color], [0, 0, 40, 40]) + + pygame.display.flip() + + # Be IDLE friendly + pygame.quit() + + +if __name__ == '__main__': + main() From 6baec2ab8f8c50c379a601c2c8beaee423f65e2f Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Thu, 2 Mar 2017 13:39:50 -0500 Subject: [PATCH 04/83] Pygame Format with minimal function --- NewPygame.py | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 NewPygame.py diff --git a/NewPygame.py b/NewPygame.py new file mode 100644 index 0000000..29bd0e2 --- /dev/null +++ b/NewPygame.py @@ -0,0 +1,96 @@ +import pygame + +import pygame +from math import pi + +def main(): + # Initialize the game engine + pygame.init() + + # Define the colors we will use in RGB format + BLACK = ( 0, 0, 0) + WHITE = (255, 255, 255) + BLUE = ( 0, 0, 255) + GREEN = ( 0, 255, 0) + RED = (255, 0, 0) + + # Set the height and width of the screen + size = [400, 300] + screen = pygame.display.set_mode(size) + + pygame.display.set_caption("Example code for the draw module") + + #Loop until the user clicks the close button. + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangle_x = 100 + rectangle_y = 100 + which_object = "Text" + while not done: + clock.tick(10) + + for event in pygame.event.get(): # User did something + if event.type == pygame.QUIT: # If user clicked close + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_LEFT: + text_x +=-10 + if event.key == pygame.K_RIGHT: + text_x+=10 + if event.key == pygame.K_UP: + text_y += -10 + if event.key == pygame.K_DOWN: + text_y += 10 + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_LEFT: + rectangle_x +=-10 + if event.key == pygame.K_RIGHT: + rectangle_x+=10 + if event.key == pygame.K_UP: + rectangle_y += -10 + if event.key == pygame.K_DOWN: + rectangle_y += 10 + # All drawing code happens after the for loop and but + # inside the main while done==False loop. + + # Clear the screen and set the screen background + screen.fill(WHITE) + + # Draw on the screen a GREEN line from (0,0) to (50.75) + # 5 pixels wide. + myfont = pygame.font.SysFont("monospace", 15) + keys=pygame.key.get_pressed() + + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + #pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) + #pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80]) + + #pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5) + #pygame.draw.arc(screen, RED, [210, 75, 150, 125], 3*pi/2, 2*pi, 2) + #pygame.draw.circle(screen, BLUE, [60, 250], 40) + pygame.draw.rect(screen, BLACK, [rectangle_x, rectangle_y, 50, 20]) + + pygame.display.flip() + + # Be IDLE friendly + pygame.quit() + + +if __name__ == '__main__': + main() From 3be3fe07357f58e995546ffcce8dce679b1a862a Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Thu, 2 Mar 2017 13:40:29 -0500 Subject: [PATCH 05/83] Example Pygame --- PygameTest.py | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 PygameTest.py diff --git a/PygameTest.py b/PygameTest.py new file mode 100644 index 0000000..b0fc374 --- /dev/null +++ b/PygameTest.py @@ -0,0 +1,83 @@ +"""Animates a bouncing ball. + +Author : Oliver Steele +Course : Olin Software Design Fall 2016 +Date : 2016-10-24 +License: MIT LICENSE +""" + +import pygame + +BLACK = (0, 0, 0) +BLUE = (0, 0, 255) + + +class Ball(object): + def __init__(self): + self.radius = 20 + self.reset() + + def step(self): + self.y += self.dy + self.dy += .08 + if self.y > 480 - self.radius and self.dy > 0: + self.dy *= -1 + self.dy *= 0.99 + + def reset(self): + self.x = 320 + self.y = 240 + self.dy = 0 + + def contains_pt(self, pt): + return (self.x - pt[0]) ** 2 + (self.y - pt[1]) ** 2 < self.radius ** 2 + + +class BallView(object): + def __init__(self, model): + self.model = model + + def draw(self, surface): + model = self.model + pygame.draw.circle(surface, BLUE, (model.x, int(model.y)), model.radius) + + +class BallEnergyView(object): + def __init__(self, model): + self.model = model + + def draw(self, surface): + model = self.model + ke = model.dy ** 2 + pe = (480 - model.y) ** 2 + pygame.draw.line(surface, BLUE, (10, 480), (10, 480 - int(ke * 20)), 20) + pygame.draw.line(surface, BLUE, (40, 480), (40, 480 - int(pe / 10)), 20) + + +def main(): + pygame.init() + screen = pygame.display.set_mode((640, 480)) + ball = Ball() + ball_view = BallView(ball) + ball_energy_view = BallEnergyView(ball) + + running = True + while running: + for event in pygame.event.get(): + if event.type == pygame.MOUSEBUTTONDOWN: + if ball.contains_pt(pygame.mouse.get_pos()): + ball.reset() + if event.type == pygame.QUIT: + running = False + + ball.step() + + screen.fill(BLACK) + ball_view.draw(screen) + ball_energy_view.draw(screen) + + pygame.display.update() + + pygame.quit() +if __name__ == '__main__': + main() From a71ea8f0ccc273e912f49d7cbfc6126ead338211 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Thu, 2 Mar 2017 23:58:15 -0500 Subject: [PATCH 06/83] World --- RectangleClass.py | 134 ++++++++++++++++++++++++++++++++++++++++ World.py | 79 +++++++++++++++++++++++ continuous Rectangle.py | 58 ++++++++--------- sprite.py | 0 4 files changed, 243 insertions(+), 28 deletions(-) create mode 100644 RectangleClass.py create mode 100644 World.py create mode 100644 sprite.py diff --git a/RectangleClass.py b/RectangleClass.py new file mode 100644 index 0000000..31aaa4c --- /dev/null +++ b/RectangleClass.py @@ -0,0 +1,134 @@ +import pygame + +import pygame +from math import pi + +###################### +#Model +###################### + +pygame.init() +size = [400, 300] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) + +class Rectangle(): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + def draw_rectangle(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_shot(self): + self.x = self.x + 10 + self.y = self.y + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + +def main(): + # Initialize the game engine + pygame.init() + + # Define the colors we will use in RGB format + color_matrix = [BLACK, BLUE, GREEN, RED] + # Set the height and width of the screen + size = [400, 300] + screen = pygame.display.set_mode(size) + + pygame.display.set_caption("Example code for the draw module") + shoot_object_list = [] + #Loop until the user clicks the close button. + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangles_x = 100 + rectangles_y = 100 + rectangle_list = [] + which_object = "Rectangle" + color = 0 + draw_rectangle = 0 + while not done: + clock.tick(10) + for event in pygame.event.get(): # User did something + if event.type == pygame.QUIT: # If user clicked close + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_c: + color+=1 + if color == 3: + color = 0 + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + text_x +=-10 + if event.key == pygame.K_d: + text_x+=10 + if event.key == pygame.K_w: + text_y += -10 + if event.key == pygame.K_s: + text_y += 10 + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + rectangles_x +=-10 + if event.key == pygame.K_d: + rectangles_x+=10 + if event.key == pygame.K_w: + rectangles_y += -10 + if event.key == pygame.K_s: + rectangles_y += 10 + if event.key == pygame.K_f: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + shoot_object_list.append(rectangle) + if event.key == pygame.K_g: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + if event.key == pygame.K_z: + rectangle_list = [] + + + ########################## + #VIEW + ########################## + screen.fill(WHITE) + myfont = pygame.font.SysFont("monospace", 15) + keys=pygame.key.get_pressed() + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + for rectangles in rectangle_list: + rectangles.draw_rectangle() + for shooters in shoot_object_list: + shooters.draw_shot() + pygame.draw.rect(screen, BLACK, [rectangles_x, rectangles_y, 50, 20]) + pygame.draw.rect(screen, color_matrix[color], [0, 0, 20, 40]) + + pygame.display.flip() + + # Be IDLE friendly + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/World.py b/World.py new file mode 100644 index 0000000..09124de --- /dev/null +++ b/World.py @@ -0,0 +1,79 @@ +import pygame +from math import pi + +pygame.init() +screen_x = 1840 +screen_y = 920 +size = [1840, 920] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) + +class Rectangle(): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + + #draws the rectangles that are dropped + def draw_rectangle(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) + +#Control +def main(): + color_matrix = [BLACK, BLUE, GREEN, RED] + pygame.display.set_caption("Game!") + shoot_object_list = [] + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangles_x = 100 + rectangles_y = 100 + rectangle_list = [] + which_object = "Rectangle" + color = 0 + draw_rectangle = 0 + + #Main Loop + while not done: + clock.tick(10) + + #quit, change color, and change from controlling rect to text + for event in pygame.event.get(): + if event.type == pygame.QUIT: + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done=True + num_rows = 3 + for z in range(num_rows): + for i in range(int(screen_x/40)): + pass + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(i*40, screen_y-40*z - 40, 40, 40, rectangle_color) + rectangle_list.append(rectangle) + + + #VIEW------------------------------------------------------------------- + screen.fill(WHITE) + + #draw rectangle objects + for rectangles in rectangle_list: + rectangles.draw_rectangle() + + #draw color matric and main rectangle + pygame.display.flip() + + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 6fcc9f6..71e7041 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -1,5 +1,3 @@ -import pygame - import pygame from math import pi @@ -19,26 +17,23 @@ def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): self.width = width self.height = height self.color = color + + #draws the rectangles that are dropped def draw_rectangle(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + #draws the objects you shoot def draw_shot(self): self.x = self.x + 10 self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) -def main(): - # Initialize the game engine - pygame.init() - # Define the colors we will use in RGB format +#Control +def main(): color_matrix = [BLACK, BLUE, GREEN, RED] - # Set the height and width of the screen - size = [400, 300] - screen = pygame.display.set_mode(size) - - pygame.display.set_caption("Example code for the draw module") + pygame.display.set_caption("Game!") shoot_object_list = [] - #Loop until the user clicks the close button. done = False clock = pygame.time.Clock() text_x = 150 @@ -49,8 +44,11 @@ def main(): which_object = "Rectangle" color = 0 draw_rectangle = 0 + + #Main Loop while not done: clock.tick(10) + #continuous motion with arrow keys keys = pygame.key.get_pressed() if keys[pygame.K_UP]: rectangles_y += -3 @@ -60,11 +58,10 @@ def main(): rectangles_x += -3 if keys[pygame.K_RIGHT]: rectangles_x += 3 - for event in pygame.event.get(): # User did something - - - if event.type == pygame.QUIT: # If user clicked close + #quit, change color, and change from controlling rect to text + for event in pygame.event.get(): + if event.type == pygame.QUIT: done=True if event.type == pygame.KEYDOWN: if event.key == pygame.K_c: @@ -75,6 +72,8 @@ def main(): which_object = "Text" if event.key == pygame.K_r: which_object = "Rectangle" + + #control text if which_object == "Text": if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: @@ -87,6 +86,8 @@ def main(): text_y += -10 if event.key == pygame.K_s: text_y += 10 + + #control rectangle if which_object == "Rectangle": if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: @@ -99,50 +100,51 @@ def main(): rectangles_y += -10 if event.key == pygame.K_s: rectangles_y += 10 + + #make shoot object if event.key == pygame.K_f: draw_rectangle_x = rectangles_x draw_rectangle_y = rectangles_y rectangle_color = color_matrix[color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) shoot_object_list.append(rectangle) + + #make rectangle object if event.key == pygame.K_g: draw_rectangle_x = rectangles_x draw_rectangle_y = rectangles_y rectangle_color = color_matrix[color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) rectangle_list.append(rectangle) + + #clear objects if event.key == pygame.K_z: rectangle_list = [] - # All drawing code happens after the for loop and but - # inside the main while done==False loop. - # Clear the screen and set the screen background + #VIEW------------------------------------------------------------------- screen.fill(WHITE) - # Draw on the screen a GREEN line from (0,0) to (50.75) - # 5 pixels wide. + #draw text myfont = pygame.font.SysFont("monospace", 15) - keys=pygame.key.get_pressed() - text_color = (0, 0, 0) text_position = (text_x, text_y) label = myfont.render("Sean and Colvin's Game", 100, text_color) screen.blit(label, (text_position)) - #pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) - #pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80]) - #pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5) - #rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y, 10, 10) + #draw rectangle objects for rectangles in rectangle_list: rectangles.draw_rectangle() + + #draw shooter objects for shooters in shoot_object_list: shooters.draw_shot() + + #draw color matric and main rectangle pygame.draw.rect(screen, color_matrix[color], [rectangles_x, rectangles_y, 50, 20]) pygame.draw.rect(screen, color_matrix[color], [0, 0, 40, 40]) pygame.display.flip() - # Be IDLE friendly pygame.quit() diff --git a/sprite.py b/sprite.py new file mode 100644 index 0000000..e69de29 From a719eda2c7fa980245097428b1c18aed576ec430 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Fri, 3 Mar 2017 00:00:23 -0500 Subject: [PATCH 07/83] updated speed --- continuous Rectangle.py | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 6fcc9f6..33d102e 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -12,6 +12,9 @@ GREEN = ( 0, 255, 0) RED = (255, 0, 0) + +### Model + class Rectangle(): def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): self.x = x @@ -48,9 +51,12 @@ def main(): rectangle_list = [] which_object = "Rectangle" color = 0 - draw_rectangle = 0 + + +### CONTROL + while not done: - clock.tick(10) + clock.tick(40) keys = pygame.key.get_pressed() if keys[pygame.K_UP]: rectangles_y += -3 @@ -60,15 +66,13 @@ def main(): rectangles_x += -3 if keys[pygame.K_RIGHT]: rectangles_x += 3 - for event in pygame.event.get(): # User did something - - + for event in pygame.event.get(): # User did something - if event.type == pygame.QUIT: # If user clicked close - done=True + if event.type == pygame.QUIT: # If user hit q or closed + done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_c: - color+=1 + color += 1 if color == 3: color = 0 if event.key == pygame.K_t: @@ -80,9 +84,9 @@ def main(): if event.key == pygame.K_q: done = True if event.key == pygame.K_a: - text_x +=-10 + text_x += -10 if event.key == pygame.K_d: - text_x+=10 + text_x += 10 if event.key == pygame.K_w: text_y += -10 if event.key == pygame.K_s: @@ -113,10 +117,7 @@ def main(): rectangle_list.append(rectangle) if event.key == pygame.K_z: rectangle_list = [] - # All drawing code happens after the for loop and but - # inside the main while done==False loop. - # Clear the screen and set the screen background screen.fill(WHITE) # Draw on the screen a GREEN line from (0,0) to (50.75) From f5e0393eca3d095cffb9e8dfad5223c7f3a67d6e Mon Sep 17 00:00:00 2001 From: Colvchap Date: Fri, 3 Mar 2017 00:01:39 -0500 Subject: [PATCH 08/83] updated speed --- continuous Rectangle.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 33d102e..f3f3b8c 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -24,11 +24,15 @@ def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): self.color = color def draw_rectangle(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_shot(self): self.x = self.x + 10 self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def jump(self): + + def main(): # Initialize the game engine pygame.init() @@ -90,7 +94,7 @@ def main(): if event.key == pygame.K_w: text_y += -10 if event.key == pygame.K_s: - text_y += 10 + rectangle.jump() if which_object == "Rectangle": if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: From 98f7bfe05c55e6e19b5e21cfa7d1a511467aad0c Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Fri, 3 Mar 2017 00:13:46 -0500 Subject: [PATCH 09/83] Sean's --- continuous Rectangle.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 71e7041..5c0b67a 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -28,7 +28,8 @@ def draw_shot(self): self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - +def menu(): + pygame.display.set_caption("Menu") #Control def main(): color_matrix = [BLACK, BLUE, GREEN, RED] From 70fb301250fd3f73abaf59a7e61f5336a999c50f Mon Sep 17 00:00:00 2001 From: Colvchap Date: Fri, 3 Mar 2017 02:39:37 -0500 Subject: [PATCH 10/83] working condition with objects --- World.py | 72 +++++++++++++++++++++++++++----------------------------- 1 file changed, 35 insertions(+), 37 deletions(-) diff --git a/World.py b/World.py index 09124de..4bab518 100644 --- a/World.py +++ b/World.py @@ -4,6 +4,7 @@ pygame.init() screen_x = 1840 screen_y = 920 +block_size = 40 size = [1840, 920] screen = pygame.display.set_mode(size) BLACK = ( 0, 0, 0) @@ -11,65 +12,62 @@ BLUE = ( 0, 0, 255) GREEN = ( 0, 255, 0) RED = (255, 0, 0) +color_matrix = [BLACK, BLUE, GREEN, RED] -class Rectangle(): - def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + +class Block(): + def __init__(self, x=10, y=10, width=block_size, height=block_size, color=BLACK): self.x = x self.y = y self.width = width self.height = height self.color = color - #draws the rectangles that are dropped - def draw_rectangle(self): - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) + # draws the rectangles that are dropped + def draw(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, + self.height], 1) + + +class Field(): + def __init__(self, num_rows=3, color=0): + self.blocks = [] + + for z in range(num_rows): + for i in range(int(screen_x/block_size)): + rectangle_color = color_matrix[color] + block = Block(i*block_size, screen_y-block_size*z - block_size, + block_size, block_size, rectangle_color) + self.blocks.append(block) + -#Control +# Control def main(): - color_matrix = [BLACK, BLUE, GREEN, RED] pygame.display.set_caption("Game!") - shoot_object_list = [] done = False clock = pygame.time.Clock() - text_x = 150 - text_y = 20 - rectangles_x = 100 - rectangles_y = 100 - rectangle_list = [] - which_object = "Rectangle" - color = 0 - draw_rectangle = 0 - - #Main Loop + field = Field() + + # Main Loop while not done: - clock.tick(10) + clock.tick(40) - #quit, change color, and change from controlling rect to text for event in pygame.event.get(): if event.type == pygame.QUIT: - done=True + done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: - done=True - num_rows = 3 - for z in range(num_rows): - for i in range(int(screen_x/40)): - pass - draw_rectangle_x = rectangles_x - draw_rectangle_y = rectangles_y - rectangle_color = color_matrix[color] - rectangle = Rectangle(i*40, screen_y-40*z - 40, 40, 40, rectangle_color) - rectangle_list.append(rectangle) + done = True - #VIEW------------------------------------------------------------------- - screen.fill(WHITE) + # VIEW------------------------------------------------------------------- + screen.fill((150, 190, 255)) - #draw rectangle objects - for rectangles in rectangle_list: - rectangles.draw_rectangle() + # draw rectangle objects + for block in field.blocks: + block.draw() - #draw color matric and main rectangle + # draw color matric and main rectangle pygame.display.flip() pygame.quit() From 400b3d3dcf0465e8cd63c4644c25e21453a8f29d Mon Sep 17 00:00:00 2001 From: Colvchap Date: Fri, 3 Mar 2017 02:53:56 -0500 Subject: [PATCH 11/83] ready for collisions and World --- continuous Rectangle.py | 148 +++++++++++++++++++++++----------------- 1 file changed, 84 insertions(+), 64 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index f581297..b1bd1a9 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -2,7 +2,7 @@ from math import pi pygame.init() -size = [400, 300] +size = [1840, 920] screen = pygame.display.set_mode(size) BLACK = ( 0, 0, 0) WHITE = (255, 255, 255) @@ -27,17 +27,53 @@ def draw_rectangle(self): def draw_shot(self): - self.x = self.x + 10 + self.x = self.x + 1 self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) -def menu(): - pygame.display.set_caption("Menu") +class Player(): + def __init__(self, x=40, y=10, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.velocity = velocity + self.fall = fall + self.left = left + self.right = right + self.acceleration_constant = .6 + + + # draws the rectangles that are dropped + def draw(self): + if self.fall == 'on': + self.velocity += self.acceleration_constant + + if self.left == 'on': + self.x += -4 + + if self.right == 'on': + self.x += 4 + + self.y = self.y + self.velocity + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + + def draw_shot(self): + self.x = self.x + 10 + self.y = self.y + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) def jump(self): - pass + self.velocity = -8 + self.fall = 'on' + + +def menu(): + pygame.display.set_caption("Menu") #Control @@ -52,24 +88,32 @@ def main(): rectangles_x = 100 rectangles_y = 100 rectangle_list = [] - which_object = "Rectangle" color = 0 + player = Player() ### CONTROL while not done: clock.tick(40) - keys = pygame.key.get_pressed() if keys[pygame.K_UP]: - rectangles_y += -3 + player.jump() if keys[pygame.K_DOWN]: rectangles_y += 3 if keys[pygame.K_LEFT]: - rectangles_x += -3 + player.left = 'on' + else: + player.left = 'off' + if keys[pygame.K_RIGHT]: - rectangles_x += 3 + player.right = 'on' + else: + player.right = 'off' + + if player.y >= 740: + player.y = 740 + player.fall = 'off' for event in pygame.event.get(): # User did something @@ -81,60 +125,36 @@ def main(): color += 1 if color == 3: color = 0 - if event.key == pygame.K_t: - which_object = "Text" - if event.key == pygame.K_r: - which_object = "Rectangle" - - #control text - if which_object == "Text": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_a: - text_x += -10 - if event.key == pygame.K_d: - text_x += 10 - if event.key == pygame.K_w: - text_y += -10 - if event.key == pygame.K_s: - rectangle.jump() - - if which_object == "Rectangle": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_a: - rectangles_x +=-10 - if event.key == pygame.K_d: - rectangles_x+=10 - if event.key == pygame.K_w: - rectangles_y += -10 - if event.key == pygame.K_s: - rectangles_y += 10 - - #make shoot object - if event.key == pygame.K_f: - draw_rectangle_x = rectangles_x - draw_rectangle_y = rectangles_y - rectangle_color = color_matrix[color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - shoot_object_list.append(rectangle) - - #make rectangle object - if event.key == pygame.K_g: - draw_rectangle_x = rectangles_x - draw_rectangle_y = rectangles_y - rectangle_color = color_matrix[color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - rectangle_list.append(rectangle) - - #clear objects - if event.key == pygame.K_z: - rectangle_list = [] - -### View + player.color = color_matrix[color] + + # make shoot object + if event.key == pygame.K_f: + draw_rectangle_x = player.x + draw_rectangle_y = player.y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + shoot_object_list.append(rectangle) + + # make rectangle object + if event.key == pygame.K_g: + draw_rectangle_x = player.x + draw_rectangle_y = player.y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + + # clear objects + if event.key == pygame.K_z: + rectangle_list = [] + shoot_object_list = [] + + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- screen.fill(WHITE) + #draw text myfont = pygame.font.SysFont("monospace", 15) text_color = (0, 0, 0) @@ -151,8 +171,8 @@ def main(): shooters.draw_shot() #draw color matric and main rectangle - pygame.draw.rect(screen, color_matrix[color], [rectangles_x, rectangles_y, 50, 20]) pygame.draw.rect(screen, color_matrix[color], [0, 0, 40, 40]) + player.draw() pygame.display.flip() From 5795de164be1b3ef7aea425b4f71c2d04c4da838 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 16:39:26 -0500 Subject: [PATCH 12/83] Deleted --- sprite.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 sprite.py diff --git a/sprite.py b/sprite.py deleted file mode 100644 index e69de29..0000000 From 7891a1db1c48a4d7b9ade95015b447c8e825e7c1 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 16:40:03 -0500 Subject: [PATCH 13/83] Inventory Added --- continuous Rectangle.py | 287 +++++++++++++++++++++++++++------------- 1 file changed, 198 insertions(+), 89 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b1bd1a9..ff2550d 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -7,14 +7,16 @@ BLACK = ( 0, 0, 0) WHITE = (255, 255, 255) BLUE = ( 0, 0, 255) -GREEN = ( 0, 255, 0) +GREEN = ( 20, 255, 20) RED = (255, 0, 0) - - +block_size = 40 +color_matrix = [BLACK, BLUE, GREEN, RED] +text_x = 20 +text_y = 200 ### Model class Rectangle(): - def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLUE): self.x = x self.y = y self.width = width @@ -24,6 +26,8 @@ def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): #draws the rectangles that are dropped def draw_rectangle(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_with_outline(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) def draw_shot(self): @@ -31,9 +35,19 @@ def draw_shot(self): self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) +class Field(): + def __init__(self, num_rows=3, color=0): + self.blocks = [] + + for row in range(num_rows): + for column in range(int(size[0]/block_size)): + rectangle_color = color_matrix[color] + block = Rectangle(column*block_size, size[1]-block_size*row - block_size, + block_size, block_size, rectangle_color) + self.blocks.append(block) class Player(): - def __init__(self, x=40, y=10, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): + def __init__(self, x=40, y=0, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): self.x = x self.y = y self.width = width @@ -71,108 +85,203 @@ def jump(self): self.velocity = -8 self.fall = 'on' +class Text(): + def __init__(self, text, x_pos, y_pos, size, color): + self.text = text + self.x_pos = x_pos + self.y_pos = y_pos + self.size = size + self.color = color + def print_text(self): + font = pygame.font.SysFont("monospace", self.size) + label = font.render(self.text, 40, self.color) + screen.blit(label, (self.x_pos, self.y_pos)) def menu(): - pygame.display.set_caption("Menu") - + menu_screen = True + done = False + for event in pygame.event.get(): + if event.type == pygame.QUIT: + done = True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: # If user hit q or closed") + done = True + if event.key == pygame.K_p: + menu_screen = False + #if event.key == pygame.K_r: + # player = Player() + screen.fill(WHITE) + text_list = [] + text1 = Text("Sean and Colvin's Game", 150, 50, 100, RED) + text2 = Text("Instructions:", 50, 250, 60, BLUE) + text3 = Text("-Press Left or Right to Move", 100, 350, 60, BLACK) + text4 = Text("-Press J to Jump", 100, 450, 60, BLACK) + text5 = Text("-Press Q to Quit", 100, 550, 60, BLACK) + text7 = Text("-Your Inventory is in the upper left. Cycle through which item to drop by pressing 1, 2, and 3", 100, 700, 30, BLACK) + text8 = Text("-Add items to that slot by pressing E, and drop them into the world by pressing R", 100, 800, 30, BLACK) + text9 = Text("-Which Block you will drop is shown by the \"Current Block\" space in your inventory", 100, 750, 30, BLACK) + #text6 = Text("Press R to Restart the Game", 100, 650, 60, RED) + text6 = Text("While In Game Press P to Return to Game", 100, 850, 60, RED) + text_add_list = [text1, text2, text3, text4, text4, text5, text6, text7, text8, text9] + for texts in text_add_list: + text_list.append(texts) + for texts in text_list: + texts.print_text() + return [menu_screen, done] + +class Inventory(): + def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): + bin_list = [0, 0, 0 ] + bin_list_item = [RED, BLACK, GREEN] + self.init_quantity = init_quantity + self.x_pos = x_pos + self.y_pos = y_pos + self.bin_width = bin_width + self.bin_height = bin_height + self.bin_list = bin_list + self.bin_list_item = bin_list_item + self.dropped_blocks = [] + def add_to_inventory(self, block_type): + self.bin_list[block_type] += 1 + #self.bin_list[block_type] += 1 + def remove_from_inventory(self, block_type, player_x, player_y, current_block_index): + if self.bin_list[block_type] > 0: + self.bin_list[block_type] -= 1 + drop_block = Rectangle(player_x, player_y, 40, 40, self.bin_list_item[current_block_index]) + self.dropped_blocks.append(drop_block) + #self.bin_list[block_type] -= 1 + def draw_inventory(self, current_block_index): + text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) + text.print_text() + for bin in range(len(self.bin_list)): + rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width, self.bin_width, self.bin_height, self.bin_list_item[bin]) + rectangle.draw_rectangle() + text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_width, 40, WHITE) + text.print_text() + text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_width+60, 20, RED) + text2.print_text() + current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) + current_block.draw_rectangle() + for dropped_block in self.dropped_blocks: + dropped_block.draw_with_outline() #Control def main(): - color_matrix = [BLACK, BLUE, GREEN, RED] + #color_matrix = [BLACK, BLUE, GREEN, RED] pygame.display.set_caption("Game!") shoot_object_list = [] - done = False clock = pygame.time.Clock() - text_x = 150 - text_y = 20 rectangles_x = 100 rectangles_y = 100 rectangle_list = [] - color = 0 - + player_color = 0 + menu_screen = True + done = False player = Player() - + field = Field() + inventory = Inventory(0, 0, 20, 40, 40) + inventory_block_index = 0 ### CONTROL - while not done: - clock.tick(40) - keys = pygame.key.get_pressed() - if keys[pygame.K_UP]: - player.jump() - if keys[pygame.K_DOWN]: - rectangles_y += 3 - if keys[pygame.K_LEFT]: - player.left = 'on' - else: - player.left = 'off' - - if keys[pygame.K_RIGHT]: - player.right = 'on' - else: - player.right = 'off' - - if player.y >= 740: - player.y = 740 - player.fall = 'off' - - for event in pygame.event.get(): # User did something - - if event.type == pygame.QUIT: # If user hit q or closed - done = True - - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_c: - color += 1 - if color == 3: - color = 0 - player.color = color_matrix[color] - - # make shoot object - if event.key == pygame.K_f: - draw_rectangle_x = player.x - draw_rectangle_y = player.y - rectangle_color = color_matrix[color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - shoot_object_list.append(rectangle) - - # make rectangle object - if event.key == pygame.K_g: + player.fall = 'on' + if menu_screen == True: + returned = menu() + menu_screen = returned[0] + done = returned[1] + if menu_screen == False: + clock.tick(40) + keys = pygame.key.get_pressed() + if keys[pygame.K_UP]: + player.jump() + if keys[pygame.K_DOWN]: + rectangles_y += 3 + if keys[pygame.K_LEFT]: + player.left = 'on' + else: + player.left = 'off' + + if keys[pygame.K_RIGHT]: + player.right = 'on' + else: + player.right = 'off' + + if player.y >= 720: + player.y = 720 + player.fall = 'off' + + for event in pygame.event.get(): # User did something + + if event.type == pygame.QUIT: # If user hit q or closed + done = True + + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_p: + menu_screen = True + if event.key == pygame.K_c: + player_color += 1 + if player_color == 3: + player_color = 0 + player.color = color_matrix[player_color] + + #inventory + if event.key == pygame.K_e: + inventory.add_to_inventory(inventory_block_index) + if event.key == pygame.K_r: + inventory.remove_from_inventory(inventory_block_index, player.x, player.y, inventory_block_index) + if event.key == pygame.K_1: + inventory_block_index = 0 + if event.key == pygame.K_2: + inventory_block_index = 1 + if event.key == pygame.K_3: + inventory_block_index = 2 + + + # make shoot object + if event.key == pygame.K_f: draw_rectangle_x = player.x draw_rectangle_y = player.y rectangle_color = color_matrix[color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - rectangle_list.append(rectangle) - - # clear objects - if event.key == pygame.K_z: - rectangle_list = [] - shoot_object_list = [] - - if event.key == pygame.K_q: - pygame.quit() - return - - # View------------------------------------------------------------- - screen.fill(WHITE) - - #draw text - myfont = pygame.font.SysFont("monospace", 15) - text_color = (0, 0, 0) - text_position = (text_x, text_y) - label = myfont.render("Sean and Colvin's Game", 100, text_color) - screen.blit(label, (text_position)) - - #draw rectangle objects - for rectangles in rectangle_list: - rectangles.draw_rectangle() - - #draw shooter objects - for shooters in shoot_object_list: - shooters.draw_shot() - - #draw color matric and main rectangle - pygame.draw.rect(screen, color_matrix[color], [0, 0, 40, 40]) - player.draw() + shoot_object_list.append(rectangle) + + # make rectangle object + if event.key == pygame.K_g: + draw_rectangle_x = player.x + draw_rectangle_y = player.y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + + # clear objects + if event.key == pygame.K_z: + rectangle_list = [] + shoot_object_list = [] + + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- + screen.fill(WHITE) + + #draw text + + + #draw rectangle objects + for rectangles in rectangle_list: + rectangles.draw_with_outline() + + #draw shooter objects + for shooters in shoot_object_list: + shooters.draw_shot() + + #draw color matric and main rectangle + for rectangle in field.blocks: + rectangle.draw_with_outline() + + + inventory.draw_inventory(inventory_block_index) + player.draw() pygame.display.flip() From 870f0bb10589dc44408dfa0729f27a4e215e9a70 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 17:02:38 -0500 Subject: [PATCH 14/83] No Infinite Jump --- continuous Rectangle.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index ff2550d..2b96496 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -13,6 +13,7 @@ color_matrix = [BLACK, BLUE, GREEN, RED] text_x = 20 text_y = 200 +jump = 0 ### Model class Rectangle(): @@ -191,8 +192,6 @@ def main(): if menu_screen == False: clock.tick(40) keys = pygame.key.get_pressed() - if keys[pygame.K_UP]: - player.jump() if keys[pygame.K_DOWN]: rectangles_y += 3 if keys[pygame.K_LEFT]: @@ -207,6 +206,7 @@ def main(): if player.y >= 720: player.y = 720 + jump = 1 player.fall = 'off' for event in pygame.event.get(): # User did something @@ -215,6 +215,10 @@ def main(): done = True if event.type == pygame.KEYDOWN: + if event.key == pygame.K_UP: + if jump == 1: + player.jump() + jump = 0 if event.key == pygame.K_p: menu_screen = True if event.key == pygame.K_c: @@ -240,7 +244,7 @@ def main(): if event.key == pygame.K_f: draw_rectangle_x = player.x draw_rectangle_y = player.y - rectangle_color = color_matrix[color] + rectangle_color = color_matrix[player_color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) shoot_object_list.append(rectangle) @@ -248,7 +252,7 @@ def main(): if event.key == pygame.K_g: draw_rectangle_x = player.x draw_rectangle_y = player.y - rectangle_color = color_matrix[color] + rectangle_color = color_matrix[player_color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) rectangle_list.append(rectangle) From 991d421c24a4185551b1f1f1bda5f5aef6d6a72a Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 17:23:12 -0500 Subject: [PATCH 15/83] No infinite Jump --- continuous Rectangle.py | 1 + 1 file changed, 1 insertion(+) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 2b96496..c1a1431 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -86,6 +86,7 @@ def jump(self): self.velocity = -8 self.fall = 'on' + class Text(): def __init__(self, text, x_pos, y_pos, size, color): self.text = text From b7c86b9f921ac5b8c38b55d042dda51e38b99227 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Sun, 5 Mar 2017 17:30:12 -0500 Subject: [PATCH 16/83] change to edit field --- continuous Rectangle.py | 41 ++++++++++++++++++----------------------- 1 file changed, 18 insertions(+), 23 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index ff2550d..5ae3e33 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -16,7 +16,7 @@ ### Model class Rectangle(): - def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLUE): + def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): self.x = x self.y = y self.width = width @@ -140,17 +140,16 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_q self.bin_height = bin_height self.bin_list = bin_list self.bin_list_item = bin_list_item - self.dropped_blocks = [] def add_to_inventory(self, block_type): self.bin_list[block_type] += 1 - #self.bin_list[block_type] += 1 - def remove_from_inventory(self, block_type, player_x, player_y, current_block_index): + + def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index): if self.bin_list[block_type] > 0: self.bin_list[block_type] -= 1 drop_block = Rectangle(player_x, player_y, 40, 40, self.bin_list_item[current_block_index]) - self.dropped_blocks.append(drop_block) - #self.bin_list[block_type] -= 1 - def draw_inventory(self, current_block_index): + field.blocks.append(drop_block) + + def draw_inventory(self, field, current_block_index): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() for bin in range(len(self.bin_list)): @@ -162,8 +161,7 @@ def draw_inventory(self, current_block_index): text2.print_text() current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) current_block.draw_rectangle() - for dropped_block in self.dropped_blocks: - dropped_block.draw_with_outline() + #Control def main(): @@ -184,11 +182,11 @@ def main(): ### CONTROL while not done: player.fall = 'on' - if menu_screen == True: + if menu_screen is True: returned = menu() menu_screen = returned[0] done = returned[1] - if menu_screen == False: + if menu_screen is False: clock.tick(40) keys = pygame.key.get_pressed() if keys[pygame.K_UP]: @@ -223,11 +221,11 @@ def main(): player_color = 0 player.color = color_matrix[player_color] - #inventory + # inventory if event.key == pygame.K_e: inventory.add_to_inventory(inventory_block_index) if event.key == pygame.K_r: - inventory.remove_from_inventory(inventory_block_index, player.x, player.y, inventory_block_index) + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index) if event.key == pygame.K_1: inventory_block_index = 0 if event.key == pygame.K_2: @@ -235,7 +233,6 @@ def main(): if event.key == pygame.K_3: inventory_block_index = 2 - # make shoot object if event.key == pygame.K_f: draw_rectangle_x = player.x @@ -264,23 +261,21 @@ def main(): # View------------------------------------------------------------- screen.fill(WHITE) - #draw text - + # draw text - #draw rectangle objects + # draw rectangle objects for rectangles in rectangle_list: rectangles.draw_with_outline() - #draw shooter objects + # draw shooter objects for shooters in shoot_object_list: shooters.draw_shot() - #draw color matric and main rectangle - for rectangle in field.blocks: - rectangle.draw_with_outline() - + # draw color matric and main rectangle + for block in field.blocks: + block.draw_with_outline() - inventory.draw_inventory(inventory_block_index) + inventory.draw_inventory(field, inventory_block_index) player.draw() pygame.display.flip() From 4e55ec9d7b980fc31f5518a66aba28fa82d7e0ce Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 17:35:43 -0500 Subject: [PATCH 17/83] A --- continuous Rectangle.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index c1a1431..5c24d11 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -15,7 +15,6 @@ text_y = 200 jump = 0 ### Model - class Rectangle(): def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLUE): self.x = x @@ -287,7 +286,6 @@ def main(): inventory.draw_inventory(inventory_block_index) player.draw() - pygame.display.flip() pygame.quit() From 8f358330d5fca3292f14a323c0c83244abd98bb9 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 18:02:39 -0500 Subject: [PATCH 18/83] Mouse --- continuous Rectangle.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 3e997b3..f46053b 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -183,6 +183,8 @@ def main(): ### CONTROL while not done: player.fall = 'on' + mouse = pygame.mouse.get_pos() + mouse2 = pygame.mouse.get_pressed() if menu_screen is True: returned = menu() menu_screen = returned[0] From 2d95083ac33097cb6aa513359beef6ab0d0314d8 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 18:12:22 -0500 Subject: [PATCH 19/83] Fixed Physics --- continuous Rectangle.py | 1 + 1 file changed, 1 insertion(+) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index f46053b..7e75e2d 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -206,6 +206,7 @@ def main(): if player.y >= 720: player.y = 720 + player.velocity = 0 jump = 1 player.fall = 'off' From 001ec851c0ad29a4b5ce32c38e52d1610a4b10eb Mon Sep 17 00:00:00 2001 From: Colvchap Date: Sun, 5 Mar 2017 18:20:18 -0500 Subject: [PATCH 20/83] ugh --- continuous Rectangle.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 718ed7c..898dbb3 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -131,6 +131,14 @@ def menu(): texts.print_text() return [menu_screen, done] + +def ground_collision(player, field, jump=1): + if player.y >= 721: + player.y = 721 + jump = 1 + player.fall = 'off' + return jump + class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): bin_list = [0, 0, 0 ] @@ -203,10 +211,7 @@ def main(): else: player.right = 'off' - if player.y >= 720: - player.y = 720 - jump = 1 - player.fall = 'off' + jump = ground_collision(player, field, jump) for event in pygame.event.get(): # User did something From fa2cf79acaec8adb29a33896551dedc31802dedd Mon Sep 17 00:00:00 2001 From: Colvchap Date: Sun, 5 Mar 2017 18:23:21 -0500 Subject: [PATCH 21/83] not working --- continuous Rectangle.py | 31 +++++++++++-------------------- 1 file changed, 11 insertions(+), 20 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index bb2beb4..22b3a5f 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -13,8 +13,8 @@ color_matrix = [BLACK, BLUE, GREEN, RED] text_x = 20 text_y = 200 -jump = 0 ### Model + class Rectangle(): def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): self.x = x @@ -85,7 +85,6 @@ def jump(self): self.velocity = -8 self.fall = 'on' - class Text(): def __init__(self, text, x_pos, y_pos, size, color): self.text = text @@ -130,17 +129,9 @@ def menu(): texts.print_text() return [menu_screen, done] - -def ground_collision(player, field, jump=1): - if player.y >= 721: - player.y = 721 - jump = 1 - player.fall = 'off' - return jump - class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0 ] + bin_list = [0, 0, 0] bin_list_item = [RED, BLACK, GREEN] self.init_quantity = init_quantity self.x_pos = x_pos @@ -191,8 +182,6 @@ def main(): ### CONTROL while not done: player.fall = 'on' - mouse = pygame.mouse.get_pos() - mouse2 = pygame.mouse.get_pressed() if menu_screen is True: returned = menu() menu_screen = returned[0] @@ -200,6 +189,8 @@ def main(): if menu_screen is False: clock.tick(40) keys = pygame.key.get_pressed() + if keys[pygame.K_UP]: + player.jump() if keys[pygame.K_DOWN]: rectangles_y += 3 if keys[pygame.K_LEFT]: @@ -212,7 +203,10 @@ def main(): else: player.right = 'off' - jump = ground_collision(player, field, jump) + if player.y >= 720: + player.y = 720 + player.fall = 'off' + for event in pygame.event.get(): # User did something @@ -220,10 +214,6 @@ def main(): done = True if event.type == pygame.KEYDOWN: - if event.key == pygame.K_UP: - if jump == 1: - player.jump() - jump = 0 if event.key == pygame.K_p: menu_screen = True if event.key == pygame.K_c: @@ -248,7 +238,7 @@ def main(): if event.key == pygame.K_f: draw_rectangle_x = player.x draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] + rectangle_color = color_matrix[color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) shoot_object_list.append(rectangle) @@ -256,7 +246,7 @@ def main(): if event.key == pygame.K_g: draw_rectangle_x = player.x draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] + rectangle_color = color_matrix[color] rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) rectangle_list.append(rectangle) @@ -288,6 +278,7 @@ def main(): inventory.draw_inventory(field, inventory_block_index) player.draw() + pygame.display.flip() pygame.quit() From 139e03847c43597b77d7573ad5fbd1fc29997e04 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 18:57:04 -0500 Subject: [PATCH 22/83] changes --- continuous Rectangle.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 7e75e2d..7f3d9dd 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -14,6 +14,9 @@ text_x = 20 text_y = 200 jump = 0 + +a = matrix[[1,2], [2, 2]] +print(a[0,0]) ### Model class Rectangle(): def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): From e69454daccb842a1638bf4339b24e22ec0d3ef50 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 19:08:08 -0500 Subject: [PATCH 23/83] Matrix --- continuous Rectangle.py | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b7f6e9d..60b37e8 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -15,8 +15,7 @@ text_y = 200 jump = 0 -a = matrix[[1,2], [2, 2]] -print(a[0,0]) + ### Model class Rectangle(): def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): @@ -41,24 +40,22 @@ def draw_shot(self): class Field(): def __init__(self, num_rows=3, color=0): self.blocks = [] - self.block_points = [] self.matrix = [] inner = [] - for j in range(size[0] % 40): - inner.append(j) - for i in range(size[1] % 40): + for j in range(size[0]//40): + inner.append(0) + for i in range(size[1]//40): self.matrix.append(inner) - for row in range(num_rows): for column in range(int(size[0]/block_size)): rectangle_color = color_matrix[color] block = Rectangle(column*block_size, size[1]-block_size*row - block_size, block_size, block_size, rectangle_color) self.blocks.append(block) - self.block_points.append((column*block_size, size[1]-block_size*row - block_size)) - - + def print_matrix(self): + for rows in self.matrix: + print(rows) class Player(): def __init__(self, x=40, y=0, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): self.x = x @@ -143,10 +140,6 @@ def menu(): texts.print_text() return [menu_screen, done] - -def ground_collision(player, field): - pass - class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): bin_list = [0, 0, 0 ] @@ -195,6 +188,7 @@ def main(): done = False player = Player() field = Field() + field.print_matrix() inventory = Inventory(0, 0, 20, 40, 40) inventory_block_index = 0 ### CONTROL @@ -298,7 +292,6 @@ def main(): # draw color matric and main rectangle for block in field.blocks: block.draw_with_outline() - print(field.matrix) inventory.draw_inventory(field, inventory_block_index) player.draw() From 184cffb9a5aa4a0cb27f9508349a9fa2bb726dbd Mon Sep 17 00:00:00 2001 From: Colvchap Date: Sun, 5 Mar 2017 19:37:05 -0500 Subject: [PATCH 24/83] index tracker --- continuous Rectangle.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index df56433..582dac1 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -41,9 +41,9 @@ def __init__(self, num_rows=3, color=0): self.block_points = [] self.matrix = [] inner = [] - for j in range(size[0] % 40): + for j in range(size[0] // block_size): inner.append(j) - for i in range(size[1] % 40): + for i in range(size[1] // block_size): self.matrix.append(inner) @@ -142,7 +142,12 @@ def menu(): def ground_collision(player, field): - pass + player_i = player.x//block_size + player_j = player.y//block_size + print(player_i, player_j) + for matrix_row in field.matrix: + pass + class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): @@ -170,7 +175,7 @@ def draw_inventory(self, field, current_block_index): for bin in range(len(self.bin_list)): rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width, self.bin_width, self.bin_height, self.bin_list_item[bin]) rectangle.draw_rectangle() - text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_width, 40, WHITE) + text = Text(str(self.bin_list[bin]), self.x_pos + 5, self.y_pos + bin*self.bin_width, 40, WHITE) text.print_text() text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_width+60, 20, RED) text2.print_text() @@ -224,6 +229,8 @@ def main(): jump = 1 player.fall = 'off' + ground_collision(player, field) + for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user hit q or closed @@ -295,7 +302,6 @@ def main(): # draw color matric and main rectangle for block in field.blocks: block.draw_with_outline() - print(field.matrix) inventory.draw_inventory(field, inventory_block_index) player.draw() From 01f116051643c47ae6fa714ed5f47a5f08cceb49 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 20:35:20 -0500 Subject: [PATCH 25/83] Block Matrix --- continuous Rectangle.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 60b37e8..17ebcb0 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -33,7 +33,7 @@ def draw_with_outline(self): def draw_shot(self): - self.x = self.x + 1 + self.x = self.x self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) @@ -42,20 +42,28 @@ def __init__(self, num_rows=3, color=0): self.blocks = [] self.matrix = [] inner = [] - for j in range(size[0]//40): - inner.append(0) for i in range(size[1]//40): + inner = [] self.matrix.append(inner) + for j in range(size[0]//40): + inner.append(0) for row in range(num_rows): for column in range(int(size[0]/block_size)): rectangle_color = color_matrix[color] - block = Rectangle(column*block_size, size[1]-block_size*row - block_size, + block_x = column*block_size + block_y = size[1]-block_size*row - block_size + block = Rectangle(block_x, block_y, block_size, block_size, rectangle_color) self.blocks.append(block) - def print_matrix(self): + + def matrix_update(self): + for block in self.blocks: + self.matrix[block.y//block_size][block.x//block_size] = 1 for rows in self.matrix: print(rows) + + class Player(): def __init__(self, x=40, y=0, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): self.x = x @@ -157,7 +165,9 @@ def add_to_inventory(self, block_type): def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index): if self.bin_list[block_type] > 0: self.bin_list[block_type] -= 1 - drop_block = Rectangle(player_x, player_y, 40, 40, self.bin_list_item[current_block_index]) + player_x_to_grid = (player_x//40)*40 + player_y_to_grid = (player_y//40)*40 + drop_block = Rectangle(player_x_to_grid, player_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) def draw_inventory(self, field, current_block_index): @@ -188,7 +198,6 @@ def main(): done = False player = Player() field = Field() - field.print_matrix() inventory = Inventory(0, 0, 20, 40, 40) inventory_block_index = 0 ### CONTROL @@ -239,6 +248,10 @@ def main(): player_color = 0 player.color = color_matrix[player_color] + + if event.key == pygame.K_o: + field.matrix_update() + # inventory if event.key == pygame.K_e: inventory.add_to_inventory(inventory_block_index) From 1c43b62311016d6d0ca3b34b61fec8b00e7d07ed Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 5 Mar 2017 23:06:38 -0500 Subject: [PATCH 26/83] WORKING :)' --- continuous Rectangle.py | 72 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 64 insertions(+), 8 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 17ebcb0..488269a 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -59,13 +59,13 @@ def __init__(self, num_rows=3, color=0): def matrix_update(self): for block in self.blocks: - self.matrix[block.y//block_size][block.x//block_size] = 1 + self.matrix[int(block.y//block_size)][int(block.x//block_size)] = 1 + def matrix_print(self): for rows in self.matrix: print(rows) - class Player(): - def __init__(self, x=40, y=0, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): + def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): self.x = x self.y = y self.width = width @@ -79,6 +79,55 @@ def __init__(self, x=40, y=0, width=40, height=80, color=GREEN, velocity=0, fall # draws the rectangles that are dropped + def check_left_collision(self, field): + if field.matrix[int(self.ygrid)+1][int(self.xgrid)] == 1: + #print("Player", (self.xgrid-1), self.ygrid+2) + #print("ONE") + #print (self.x, (self.xgrid)*40) + if self.x < (self.xgrid+1)*40: + #print(self.x) + self.x = (self.xgrid+1)*40 + def check_right_collision(self, field): + #print("Player", (self.xgrid+1), self.ygrid+2) + if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] == 1: + #print("ONE") + #print (self.x, (self.xgrid)*40) + if self.x > (self.xgrid)*40: + #print(self.x) + #print("GRID", self.xgrid*40) + #print(field.matrix[int(self.ygrid)+1][int(self.xgrid+1)]) + self.x = (self.xgrid)*40 + def check_top_collision(self, field): + if field.matrix[int(self.ygrid)][int(self.xgrid)] == 1: + #print("ONE") + #print (self.x, (self.xgrid)*40) + #print("Y", self.ygrid*40) + if self.y < (self.ygrid+1)*40: + #print("TRANSPORT") + #print(self.x) + #print("GRID", self.xgrid*40) + #print(field.matrix[int(self.ygrid)+3][int(self.xgrid+3)]) + self.y = (self.ygrid+1)*40 + self.velocity = self.velocity*-.5 + def check_bottom_collision(self, field): + if field.matrix[int(self.ygrid)+2][int(self.xgrid)] == 1: + #print("ONE") + #print (self.x, (self.xgrid)*40) + #print("DETECT") + if self.y > (self.ygrid)*40: + #print("TRANSPORT") + #print(self.x) + #print("GRID", self.xgrid*40) + self.y = (self.ygrid)*40 + self.velocity = 0 + fall = 'off' + jump = 1 + return jump + + def player_in_grid(self): + self.xgrid = self.x//block_size + self.ygrid = self.y//block_size + def draw(self): if self.fall == 'on': self.velocity += self.acceleration_constant @@ -100,7 +149,7 @@ def draw_shot(self): def jump(self): - self.velocity = -8 + self.velocity = -12 self.fall = 'on' @@ -166,7 +215,7 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b if self.bin_list[block_type] > 0: self.bin_list[block_type] -= 1 player_x_to_grid = (player_x//40)*40 - player_y_to_grid = (player_y//40)*40 + player_y_to_grid = (player_y//40)*40+40 drop_block = Rectangle(player_x_to_grid, player_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) @@ -200,9 +249,16 @@ def main(): field = Field() inventory = Inventory(0, 0, 20, 40, 40) inventory_block_index = 0 + jump = 1 ### CONTROL while not done: + field.matrix_update() player.fall = 'on' + player.player_in_grid() + jump = player.check_bottom_collision(field) + player.check_top_collision(field) + player.check_left_collision(field) + player.check_right_collision(field) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -224,8 +280,8 @@ def main(): else: player.right = 'off' - if player.y >= 720: - player.y = 720 + if player.y >= 719: + player.y = 719 player.velocity = 0 jump = 1 player.fall = 'off' @@ -250,7 +306,7 @@ def main(): if event.key == pygame.K_o: - field.matrix_update() + field.matrix_print() # inventory if event.key == pygame.K_e: From a6b2d46c425847bb5ef6470e699acd4348899492 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 14:01:08 -0500 Subject: [PATCH 27/83] Print From Matrix --- continuous Rectangle.py | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 488269a..35251c2 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -210,12 +210,15 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_q self.bin_list_item = bin_list_item def add_to_inventory(self, block_type): self.bin_list[block_type] += 1 + #x_bin = (mouse[0]//40)*40 + #y_bin = (mouse[1]//40)*40 + #self.field[y_bin][x_bin] = 0 - def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index): + def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): if self.bin_list[block_type] > 0: self.bin_list[block_type] -= 1 - player_x_to_grid = (player_x//40)*40 - player_y_to_grid = (player_y//40)*40+40 + player_x_to_grid = (mouse[0]//40)*40 + player_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(player_x_to_grid, player_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) @@ -312,7 +315,7 @@ def main(): if event.key == pygame.K_e: inventory.add_to_inventory(inventory_block_index) if event.key == pygame.K_r: - inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index) + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) if event.key == pygame.K_1: inventory_block_index = 0 if event.key == pygame.K_2: @@ -359,8 +362,19 @@ def main(): shooters.draw_shot() # draw color matric and main rectangle - for block in field.blocks: - block.draw_with_outline() + #for block in field.blocks: + # block.draw_with_outline() + + row_count = -1 + for row in field.matrix: + column_count = -1 + row_count += 1 + for column in row: + column_count+=1 + print(row_count, column_count) + if field.matrix[row_count][column_count] != 0: + rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) + rectangle.draw_with_outline() inventory.draw_inventory(field, inventory_block_index) player.draw() From ebfd4c8adc01169bd0733d53b60fb0c504ba6fe2 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 14:33:08 -0500 Subject: [PATCH 28/83] WORKING FIELD MATRIX PRINT --- continuous Rectangle.py | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 35251c2..8847339 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -57,9 +57,10 @@ def __init__(self, num_rows=3, color=0): block_size, block_size, rectangle_color) self.blocks.append(block) - def matrix_update(self): + def matrix_update(self, block_type): for block in self.blocks: - self.matrix[int(block.y//block_size)][int(block.x//block_size)] = 1 + self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type + self.blocks.remove(block) def matrix_print(self): for rows in self.matrix: print(rows) @@ -200,7 +201,7 @@ def menu(): class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): bin_list = [0, 0, 0 ] - bin_list_item = [RED, BLACK, GREEN] + bin_list_item = [BLACK, RED, BLACK, GREEN] self.init_quantity = init_quantity self.x_pos = x_pos self.y_pos = y_pos @@ -209,14 +210,14 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_q self.bin_list = bin_list self.bin_list_item = bin_list_item def add_to_inventory(self, block_type): - self.bin_list[block_type] += 1 + self.bin_list[block_type-1] += 1 #x_bin = (mouse[0]//40)*40 #y_bin = (mouse[1]//40)*40 #self.field[y_bin][x_bin] = 0 def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): - if self.bin_list[block_type] > 0: - self.bin_list[block_type] -= 1 + if self.bin_list[block_type-1] > 0: + self.bin_list[block_type-1] -= 1 player_x_to_grid = (mouse[0]//40)*40 player_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(player_x_to_grid, player_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) @@ -226,7 +227,7 @@ def draw_inventory(self, field, current_block_index): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() for bin in range(len(self.bin_list)): - rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width, self.bin_width, self.bin_height, self.bin_list_item[bin]) + rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) rectangle.draw_rectangle() text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_width, 40, WHITE) text.print_text() @@ -251,11 +252,12 @@ def main(): player = Player() field = Field() inventory = Inventory(0, 0, 20, 40, 40) - inventory_block_index = 0 + inventory_block_index = 2 jump = 1 ### CONTROL while not done: - field.matrix_update() + print(inventory_block_index) + field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() jump = player.check_bottom_collision(field) @@ -317,11 +319,11 @@ def main(): if event.key == pygame.K_r: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) if event.key == pygame.K_1: - inventory_block_index = 0 - if event.key == pygame.K_2: inventory_block_index = 1 - if event.key == pygame.K_3: + if event.key == pygame.K_2: inventory_block_index = 2 + if event.key == pygame.K_3: + inventory_block_index = 3 # make shoot object if event.key == pygame.K_f: @@ -371,7 +373,7 @@ def main(): row_count += 1 for column in row: column_count+=1 - print(row_count, column_count) + #print(row_count, column_count) if field.matrix[row_count][column_count] != 0: rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) rectangle.draw_with_outline() @@ -379,7 +381,6 @@ def main(): inventory.draw_inventory(field, inventory_block_index) player.draw() pygame.display.flip() - pygame.quit() From 2c139be6219eb89048944bea5b11acd9f1af5f17 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 15:03:49 -0500 Subject: [PATCH 29/83] Merge Resolved --- continuous Rectangle.py | 46 +++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 8847339..23f9db8 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -209,31 +209,43 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_q self.bin_height = bin_height self.bin_list = bin_list self.bin_list_item = bin_list_item - def add_to_inventory(self, block_type): - self.bin_list[block_type-1] += 1 - #x_bin = (mouse[0]//40)*40 - #y_bin = (mouse[1]//40)*40 - #self.field[y_bin][x_bin] = 0 + + def update_bin_width(self, block_type): + if self.bin_list[block_type-1] > 9: + self.bin_width = 1.5*block_size + else: + self.bin_width = block_size + + def add_to_inventory(self, block_type, mouse, field): + if self.bin_list[block_type-1] < 64: + if field.matrix[mouse[1]//40][mouse[0]//40] != 0: + self.bin_list[block_type-1] += 1 + x_bin = (mouse[0]//40)*40 + y_bin = (mouse[1]//40)*40 + field.matrix[mouse[1]//40][mouse[0]//40] = 0 + self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): - if self.bin_list[block_type-1] > 0: - self.bin_list[block_type-1] -= 1 - player_x_to_grid = (mouse[0]//40)*40 - player_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(player_x_to_grid, player_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + if self.bin_list[block_type-1] > 0: + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() for bin in range(len(self.bin_list)): - rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) + rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) rectangle.draw_rectangle() - text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_width, 40, WHITE) + text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 40, WHITE) text.print_text() - text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_width+60, 20, RED) + text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) text2.print_text() - current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_width + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) + current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) current_block.draw_rectangle() @@ -256,7 +268,6 @@ def main(): jump = 1 ### CONTROL while not done: - print(inventory_block_index) field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() @@ -315,7 +326,7 @@ def main(): # inventory if event.key == pygame.K_e: - inventory.add_to_inventory(inventory_block_index) + inventory.add_to_inventory(inventory_block_index, mouse, field) if event.key == pygame.K_r: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) if event.key == pygame.K_1: @@ -373,7 +384,6 @@ def main(): row_count += 1 for column in row: column_count+=1 - #print(row_count, column_count) if field.matrix[row_count][column_count] != 0: rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) rectangle.draw_with_outline() From 12bb3768a27e9f39ea09de1d58d167a2de69e075 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 15:12:15 -0500 Subject: [PATCH 30/83] RANGE --- continuous Rectangle.py | 46 +++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 23f9db8..1fe0a89 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -81,7 +81,7 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa # draws the rectangles that are dropped def check_left_collision(self, field): - if field.matrix[int(self.ygrid)+1][int(self.xgrid)] == 1: + if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: #print("Player", (self.xgrid-1), self.ygrid+2) #print("ONE") #print (self.x, (self.xgrid)*40) @@ -90,7 +90,7 @@ def check_left_collision(self, field): self.x = (self.xgrid+1)*40 def check_right_collision(self, field): #print("Player", (self.xgrid+1), self.ygrid+2) - if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] == 1: + if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] != 0: #print("ONE") #print (self.x, (self.xgrid)*40) if self.x > (self.xgrid)*40: @@ -99,7 +99,7 @@ def check_right_collision(self, field): #print(field.matrix[int(self.ygrid)+1][int(self.xgrid+1)]) self.x = (self.xgrid)*40 def check_top_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid)] == 1: + if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: #print("ONE") #print (self.x, (self.xgrid)*40) #print("Y", self.ygrid*40) @@ -111,7 +111,7 @@ def check_top_collision(self, field): self.y = (self.ygrid+1)*40 self.velocity = self.velocity*-.5 def check_bottom_collision(self, field): - if field.matrix[int(self.ygrid)+2][int(self.xgrid)] == 1: + if field.matrix[int(self.ygrid)+2][int(self.xgrid)] != 0: #print("ONE") #print (self.x, (self.xgrid)*40) #print("DETECT") @@ -216,23 +216,33 @@ def update_bin_width(self, block_type): else: self.bin_width = block_size - def add_to_inventory(self, block_type, mouse, field): - if self.bin_list[block_type-1] < 64: - if field.matrix[mouse[1]//40][mouse[0]//40] != 0: - self.bin_list[block_type-1] += 1 - x_bin = (mouse[0]//40)*40 - y_bin = (mouse[1]//40)*40 - field.matrix[mouse[1]//40][mouse[0]//40] = 0 - self.update_bin_width(block_type) + def add_to_inventory(self, block_type, mouse, field, player_x, player_y): + mouse_x_grid = mouse[0] // 40 + mouse_y_grid = mouse [1] // 40 + player_x_grid = player_x//40 + player_y_grid = player_y//40 + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid): + if self.bin_list[block_type-1] < 64: + if field.matrix[mouse[1]//40][mouse[0]//40] != 0: + self.bin_list[block_type-1] += 1 + x_bin = (mouse[0]//40)*40 + y_bin = (mouse[1]//40)*40 + field.matrix[mouse[1]//40][mouse[0]//40] = 0 + self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): + mouse_x_grid = mouse[0] // 40 + mouse_y_grid = mouse [1] // 40 + player_x_grid = player_x//40 + player_y_grid = player_y //40 if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: - self.bin_list[block_type-1] -= 1 - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid): + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index): @@ -326,7 +336,7 @@ def main(): # inventory if event.key == pygame.K_e: - inventory.add_to_inventory(inventory_block_index, mouse, field) + inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) if event.key == pygame.K_r: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) if event.key == pygame.K_1: From dcc8b9e3b577ec2c294dc46b8c9d50f33e4c40ac Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 15:43:22 -0500 Subject: [PATCH 31/83] Bottom collision --- continuous Rectangle.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 1fe0a89..1a1719e 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -42,7 +42,7 @@ def __init__(self, num_rows=3, color=0): self.blocks = [] self.matrix = [] inner = [] - for i in range(size[1]//40): + for i in range(size[1]//40 + 1): inner = [] self.matrix.append(inner) for j in range(size[0]//40): @@ -306,12 +306,12 @@ def main(): else: player.right = 'off' - if player.y >= 719: - player.y = 719 + if player.y >= 839: + player.y = 839 player.velocity = 0 jump = 1 player.fall = 'off' - + print(player.y) for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user hit q or closed From 5273e48742cd0a933e17072a00eb208817675d4e Mon Sep 17 00:00:00 2001 From: Colvchap Date: Mon, 6 Mar 2017 22:29:16 -0500 Subject: [PATCH 32/83] refresh --- continuous Rectangle.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 34684db..e000b4f 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -42,7 +42,7 @@ def __init__(self, num_rows=3, color=0): self.blocks = [] self.matrix = [] inner = [] - for i in range(size[1]//40): + for i in range(size[1]//40+1): inner = [] self.matrix.append(inner) for j in range(size[0]//40): @@ -121,7 +121,7 @@ def check_bottom_collision(self, field): #print("GRID", self.xgrid*40) self.y = (self.ygrid)*40 self.velocity = 0 - fall = 'off' + self.fall = 'off' jump = 1 return jump @@ -296,12 +296,15 @@ def main(): else: player.right = 'off' - if player.y >= 719: - player.y = 719 + print(player.y) + + if player.y >= 839: + player.y = 839 player.velocity = 0 jump = 1 player.fall = 'off' + for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user hit q or closed From 1ab2059c5be2fc132e84f06aa9e49e0c779e53b9 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Mon, 6 Mar 2017 22:37:46 -0500 Subject: [PATCH 33/83] refresh --- continuous Rectangle.py | 41 ++--------------------------------------- 1 file changed, 2 insertions(+), 39 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index e000b4f..b0eab1b 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -253,11 +253,7 @@ def draw_inventory(self, field, current_block_index): def main(): #color_matrix = [BLACK, BLUE, GREEN, RED] pygame.display.set_caption("Game!") - shoot_object_list = [] clock = pygame.time.Clock() - rectangles_x = 100 - rectangles_y = 100 - rectangle_list = [] player_color = 0 menu_screen = True done = False @@ -284,8 +280,7 @@ def main(): if menu_screen is False: clock.tick(40) keys = pygame.key.get_pressed() - if keys[pygame.K_DOWN]: - rectangles_y += 3 + if keys[pygame.K_LEFT]: player.left = 'on' else: @@ -323,7 +318,6 @@ def main(): player_color = 0 player.color = color_matrix[player_color] - if event.key == pygame.K_o: field.matrix_print() @@ -339,27 +333,6 @@ def main(): if event.key == pygame.K_3: inventory_block_index = 3 - # make shoot object - if event.key == pygame.K_f: - draw_rectangle_x = player.x - draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - shoot_object_list.append(rectangle) - - # make rectangle object - if event.key == pygame.K_g: - draw_rectangle_x = player.x - draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - rectangle_list.append(rectangle) - - # clear objects - if event.key == pygame.K_z: - rectangle_list = [] - shoot_object_list = [] - if event.key == pygame.K_q: pygame.quit() return @@ -367,18 +340,8 @@ def main(): # View------------------------------------------------------------- screen.fill(WHITE) - # draw text - - # draw rectangle objects - for rectangles in rectangle_list: - rectangles.draw_with_outline() - - # draw shooter objects - for shooters in shoot_object_list: - shooters.draw_shot() - # draw color matric and main rectangle - #for block in field.blocks: + # for block in field.blocks: # block.draw_with_outline() row_count = -1 From e14fda5c79006e17b7d0809a4cbf3d039352b4de Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 22:45:58 -0500 Subject: [PATCH 34/83] Mouse --- continuous Rectangle.py | 49 ++++++++++++++--------------------------- 1 file changed, 16 insertions(+), 33 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 1a1719e..8aaa67a 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -124,6 +124,10 @@ def check_bottom_collision(self, field): fall = 'off' jump = 1 return jump + def bottom_collioin(self, field): + pass + def left_collision(self, field): + pass def player_in_grid(self): self.xgrid = self.x//block_size @@ -281,10 +285,11 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - jump = player.check_bottom_collision(field) - player.check_top_collision(field) - player.check_left_collision(field) - player.check_right_collision(field) + #jump = player.check_bottom_collision(field) + #player.check_top_collision(field) + #player.check_left_collision(field) + #player.check_right_collision(field) + player.left_collision(field) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -306,12 +311,16 @@ def main(): else: player.right = 'off' - if player.y >= 839: - player.y = 839 + if player.y >= 720: #839 + player.y = 720 player.velocity = 0 jump = 1 player.fall = 'off' - print(player.y) + print(mouse2[0]) + if mouse2[0] == 1: + inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) + if mouse2[2] == 1: + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user hit q or closed @@ -333,12 +342,7 @@ def main(): if event.key == pygame.K_o: field.matrix_print() - # inventory - if event.key == pygame.K_e: - inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) - if event.key == pygame.K_r: - inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) if event.key == pygame.K_1: inventory_block_index = 1 if event.key == pygame.K_2: @@ -346,27 +350,6 @@ def main(): if event.key == pygame.K_3: inventory_block_index = 3 - # make shoot object - if event.key == pygame.K_f: - draw_rectangle_x = player.x - draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - shoot_object_list.append(rectangle) - - # make rectangle object - if event.key == pygame.K_g: - draw_rectangle_x = player.x - draw_rectangle_y = player.y - rectangle_color = color_matrix[player_color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - rectangle_list.append(rectangle) - - # clear objects - if event.key == pygame.K_z: - rectangle_list = [] - shoot_object_list = [] - if event.key == pygame.K_q: pygame.quit() return From 40d654e95774f52a808dc2768a3672a451198347 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Mon, 6 Mar 2017 22:49:32 -0500 Subject: [PATCH 35/83] pulling --- continuous Rectangle.py | 102 ++++++++++++++++++++-------------------- 1 file changed, 51 insertions(+), 51 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b0eab1b..139eec1 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -79,51 +79,51 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa self.acceleration_constant = .6 - # draws the rectangles that are dropped - def check_left_collision(self, field): - if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: - #print("Player", (self.xgrid-1), self.ygrid+2) - #print("ONE") - #print (self.x, (self.xgrid)*40) - if self.x < (self.xgrid+1)*40: - #print(self.x) - self.x = (self.xgrid+1)*40 - def check_right_collision(self, field): - #print("Player", (self.xgrid+1), self.ygrid+2) - if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - if self.x > (self.xgrid)*40: - #print(self.x) - #print("GRID", self.xgrid*40) - #print(field.matrix[int(self.ygrid)+1][int(self.xgrid+1)]) - self.x = (self.xgrid)*40 - def check_top_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - #print("Y", self.ygrid*40) - if self.y < (self.ygrid+1)*40: - #print("TRANSPORT") - #print(self.x) - #print("GRID", self.xgrid*40) - #print(field.matrix[int(self.ygrid)+3][int(self.xgrid+3)]) - self.y = (self.ygrid+1)*40 - self.velocity = self.velocity*-.5 - def check_bottom_collision(self, field): - if field.matrix[int(self.ygrid)+2][int(self.xgrid)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - #print("DETECT") - if self.y > (self.ygrid)*40: - #print("TRANSPORT") - #print(self.x) - #print("GRID", self.xgrid*40) - self.y = (self.ygrid)*40 - self.velocity = 0 - self.fall = 'off' - jump = 1 - return jump + # # draws the rectangles that are dropped + # def check_left_collision(self, field): + # if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: + # #print("Player", (self.xgrid-1), self.ygrid+2) + # #print("ONE") + # #print (self.x, (self.xgrid)*40) + # if self.x < (self.xgrid+1)*40: + # #print(self.x) + # self.x = (self.xgrid+1)*40 + # def check_right_collision(self, field): + # #print("Player", (self.xgrid+1), self.ygrid+2) + # if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] != 0: + # #print("ONE") + # #print (self.x, (self.xgrid)*40) + # if self.x > (self.xgrid)*40: + # #print(self.x) + # #print("GRID", self.xgrid*40) + # #print(field.matrix[int(self.ygrid)+1][int(self.xgrid+1)]) + # self.x = (self.xgrid)*40 + # def check_top_collision(self, field): + # if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: + # #print("ONE") + # #print (self.x, (self.xgrid)*40) + # #print("Y", self.ygrid*40) + # if self.y < (self.ygrid+1)*40: + # #print("TRANSPORT") + # #print(self.x) + # #print("GRID", self.xgrid*40) + # #print(field.matrix[int(self.ygrid)+3][int(self.xgrid+3)]) + # self.y = (self.ygrid+1)*40 + # self.velocity = self.velocity*-.5 + # def check_bottom_collision(self, field): + # if field.matrix[int(self.ygrid)+2][int(self.xgrid)] != 0: + # #print("ONE") + # #print (self.x, (self.xgrid)*40) + # #print("DETECT") + # if self.y > (self.ygrid)*40: + # #print("TRANSPORT") + # #print(self.x) + # #print("GRID", self.xgrid*40) + # self.y = (self.ygrid)*40 + # self.velocity = 0 + # self.fall = 'off' + # jump = 1 + # return jump def player_in_grid(self): self.xgrid = self.x//block_size @@ -267,10 +267,10 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - jump = player.check_bottom_collision(field) - player.check_top_collision(field) - player.check_left_collision(field) - player.check_right_collision(field) + # jump = player.check_bottom_collision(field) + # player.check_top_collision(field) + # player.check_left_collision(field) + # player.check_right_collision(field) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -293,8 +293,8 @@ def main(): print(player.y) - if player.y >= 839: - player.y = 839 + if player.y >= 720: + player.y = 720 player.velocity = 0 jump = 1 player.fall = 'off' From c30c2ea7406a49b48bb3512afa31c32452ad174d Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 23:31:18 -0500 Subject: [PATCH 36/83] Collision --- continuous Rectangle.py | 35 +++++++++++++++++++++++------------ 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index a3eb986..e00dd6b 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -123,10 +123,22 @@ def check_bottom_collision(self, field): self.fall = 'off' jump = 1 return jump - def bottom_collioin(self, field): - pass + def bottom_collision(self, field): + if self.x%40 == 0: + if field.matrix[int(self.ygrid+2)][int(self.xgrid)]: + print("BLOCK BOTTOM") + else: + field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0 + print("BLOCK BOTTOM") def left_collision(self, field): - pass + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : + print("BLOCK LEFT") + def right_collision(self, field): + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : + print("BLOCK LEFT") + def top_collision(self, field): + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : + print("BLOCK LEFT") def player_in_grid(self): self.xgrid = self.x//block_size @@ -240,12 +252,12 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b player_y_grid = player_y //40 if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid): - self.bin_list[block_type-1] -= 1 - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) < 5: + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index): @@ -261,7 +273,6 @@ def draw_inventory(self, field, current_block_index): current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) current_block.draw_rectangle() - #Control def main(): #color_matrix = [BLACK, BLUE, GREEN, RED] @@ -280,7 +291,8 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - + player.bottom_collision(field) + print(player.xgrid, player.ygrid) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -307,7 +319,6 @@ def main(): player.velocity = 0 jump = 1 player.fall = 'off' - print(mouse2[0]) if mouse2[0] == 1: inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) if mouse2[2] == 1: From ec17b3ead3b08851954a4f2e55b9feda9d46076e Mon Sep 17 00:00:00 2001 From: Colvchap Date: Mon, 6 Mar 2017 23:37:08 -0500 Subject: [PATCH 37/83] ahhhh --- continuous Rectangle.py | 43 ++++++++++++++++++----------------------- 1 file changed, 19 insertions(+), 24 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index e00dd6b..b531e2c 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -78,6 +78,11 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa self.right = right self.acceleration_constant = .6 + + def check_left(self, field): + if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: + dx = self.x - self.xgrid + print(dx) # draws the rectangles that are dropped def check_left_collision(self, field): if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: @@ -87,6 +92,7 @@ def check_left_collision(self, field): if self.x < (self.xgrid+1)*40: #print(self.x) self.x = (self.xgrid+1)*40 + def check_right_collision(self, field): #print("Player", (self.xgrid+1), self.ygrid+2) if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] != 0: @@ -123,22 +129,10 @@ def check_bottom_collision(self, field): self.fall = 'off' jump = 1 return jump - def bottom_collision(self, field): - if self.x%40 == 0: - if field.matrix[int(self.ygrid+2)][int(self.xgrid)]: - print("BLOCK BOTTOM") - else: - field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0 - print("BLOCK BOTTOM") + def bottom_collioin(self, field): + pass def left_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") - def right_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") - def top_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") + pass def player_in_grid(self): self.xgrid = self.x//block_size @@ -192,7 +186,7 @@ def menu(): done = True if event.key == pygame.K_p: menu_screen = False - #if event.key == pygame.K_r: + # if event.key == pygame.K_r: # player = Player() screen.fill(WHITE) text_list = [] @@ -252,12 +246,12 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b player_y_grid = player_y //40 if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) < 5: - self.bin_list[block_type-1] -= 1 - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid): + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index): @@ -273,6 +267,7 @@ def draw_inventory(self, field, current_block_index): current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) current_block.draw_rectangle() + #Control def main(): #color_matrix = [BLACK, BLUE, GREEN, RED] @@ -291,8 +286,7 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - player.bottom_collision(field) - print(player.xgrid, player.ygrid) + mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -303,6 +297,7 @@ def main(): clock.tick(40) keys = pygame.key.get_pressed() + if keys[pygame.K_LEFT]: player.left = 'on' else: From acd487e1e691b6009f6aab1234cdbc37cbf7cdc3 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 23:42:42 -0500 Subject: [PATCH 38/83] Bottom --- continuous Rectangle.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index e00dd6b..2b3df11 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -125,21 +125,27 @@ def check_bottom_collision(self, field): return jump def bottom_collision(self, field): if self.x%40 == 0: - if field.matrix[int(self.ygrid+2)][int(self.xgrid)]: - print("BLOCK BOTTOM") - else: - field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0 + if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: + print("BLOCK BASE") + else: + print("BLOCK FALL") + elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0: print("BLOCK BOTTOM") + else: + print("BLOCK FALL") def left_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : print("BLOCK LEFT") def right_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") + print("BLOCK RIGHT") def top_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") - + if self.x%40 == 0: + if field.matrix[int(self.ygrid-1)][int(self.xgrid)] != 0: + print("BLOCK TOP") + else: + field.matrix[int(self.ygrid-1)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)-1][int(self.xgrid+1)] != 0 + print("BLOCK TOP") def player_in_grid(self): self.xgrid = self.x//block_size self.ygrid = self.y//block_size From 1df2065ba63f10dcbffc7a81135674a4a07a628e Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Mon, 6 Mar 2017 23:47:36 -0500 Subject: [PATCH 39/83] TOP --- continuous Rectangle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 2b3df11..5206083 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -297,7 +297,7 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - player.bottom_collision(field) + player.top_collision(field) print(player.xgrid, player.ygrid) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() From 0b2171d18cb22ab40c62bb8b667bf4a58e8e3bc4 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 00:02:59 -0500 Subject: [PATCH 40/83] Left --- continuous Rectangle.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 8d78724..b3551bf 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -136,6 +136,12 @@ def bottom_collision(self, field): def left_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : print("BLOCK LEFT") + difference = self.x - self.xgrid*40 + print(difference) + if difference >= 4: + return True + else: + return False def right_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : @@ -245,7 +251,7 @@ def add_to_inventory(self, block_type, mouse, field, player_x, player_y): mouse_y_grid = mouse [1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid): + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) <5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: self.bin_list[block_type-1] += 1 @@ -300,6 +306,7 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() + player.left_collision(field) player.top_collision(field) print(player.xgrid, player.ygrid) mouse = pygame.mouse.get_pos() @@ -313,7 +320,9 @@ def main(): keys = pygame.key.get_pressed() if keys[pygame.K_LEFT]: - player.left = 'on' + player_left_move = player.left_collision(field) + if player_left_move: + player.left = 'on' else: player.left = 'off' From ff668dadc6ef2e8b8da76bbac73602363727ef95 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 00:03:05 -0500 Subject: [PATCH 41/83] good --- continuous Rectangle.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 8d78724..07fd4da 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -138,8 +138,9 @@ def left_collision(self, field): print("BLOCK LEFT") def right_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK RIGHT") + if self.x%40 == 0: + if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: + print("BLOCK RIGHT") def top_collision(self, field): if self.x%40 == 0: @@ -300,7 +301,7 @@ def main(): field.matrix_update(inventory_block_index) player.fall = 'on' player.player_in_grid() - player.top_collision(field) + player.right_collision(field) print(player.xgrid, player.ygrid) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() From d9452d75eeb389920c8075d24a10248390b6e219 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 00:43:00 -0500 Subject: [PATCH 42/83] Left Collision --- continuous Rectangle.py | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 284ac4b..5726043 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -134,14 +134,21 @@ def bottom_collision(self, field): print("BLOCK FALL") def left_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid)+1][int(self.xgrid-1)] != 0 : - print("BLOCK LEFT") - difference = self.x - self.xgrid*40 - print(difference) - if difference >= 4: - return True - else: + if self.x%40 == 0: + if self.y%40 == 0: + print("in line") + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 : + print("STUCK") + return False + else: + return True + elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: + print("FALSE 2") return False + else: + return True + else: + return True def right_collision(self, field): if self.x%40 == 0: @@ -319,14 +326,14 @@ def main(): if menu_screen is False: clock.tick(40) keys = pygame.key.get_pressed() - + player.left = 'off' if keys[pygame.K_LEFT]: player_left_move = player.left_collision(field) - if player_left_move: + print(player_left_move) + if player_left_move is True: player.left = 'on' - else: - player.left = 'off' - + else: + player.left = 'off' if keys[pygame.K_RIGHT]: player.right = 'on' else: From 4944bd413ccd1b739808a3c6782d674a29bd23ed Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 00:43:50 -0500 Subject: [PATCH 43/83] ug --- continuous Rectangle.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 284ac4b..7b03dc6 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -146,7 +146,7 @@ def left_collision(self, field): def right_collision(self, field): if self.x%40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: - print("BLOCK RIGHT") + return True def top_collision(self, field): if self.x%40 == 0: @@ -328,11 +328,12 @@ def main(): player.left = 'off' if keys[pygame.K_RIGHT]: - player.right = 'on' + if player.right_collision(field): + player.right = 'on' else: player.right = 'off' - if player.y >= 720: #839 + if player.y >= 720: # 839 player.y = 720 player.velocity = 0 From 3a9e0f3b4df1610cba70b66445cb83fe57166a11 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 00:55:11 -0500 Subject: [PATCH 44/83] great --- continuous Rectangle.py | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 72cd41f..dc89463 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -137,7 +137,7 @@ def left_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: print("in line") - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 : + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: print("STUCK") return False else: @@ -152,8 +152,20 @@ def left_collision(self, field): def right_collision(self, field): if self.x%40 == 0: - if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: + if self.y%40 == 0: + print("in line") + if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: + print("STUCK") + return False + else: + return True + elif field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] != 0: + print("FALSE 2") + return False + else: return True + else: + return True def top_collision(self, field): if self.x%40 == 0: @@ -327,6 +339,8 @@ def main(): clock.tick(40) keys = pygame.key.get_pressed() player.left = 'off' + player.right = 'off' + if keys[pygame.K_LEFT]: player_left_move = player.left_collision(field) print(player_left_move) @@ -335,10 +349,10 @@ def main(): else: player.left = 'off' if keys[pygame.K_RIGHT]: - if player.right_collision(field): + player_right_move = player.right_collision(field) + print(player_right_move) + if player_right_move is True: player.right = 'on' - else: - player.right = 'off' if player.y >= 720: # 839 From a6a3e4c8e96d3f5bb495e77eb2985bdb86d313e6 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 00:55:14 -0500 Subject: [PATCH 45/83] BOttom Coll --- continuous Rectangle.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 5726043..4bd9295 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -125,13 +125,15 @@ def check_bottom_collision(self, field): def bottom_collision(self, field): if self.x%40 == 0: if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: - print("BLOCK BASE") + self.fall = "off" + self.velocity = 0 else: - print("BLOCK FALL") + self.fall = 'on' elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0: - print("BLOCK BOTTOM") + self.fall = "off" + self.velocity = 0 else: - print("BLOCK FALL") + self.fall = "on" def left_collision(self, field): if self.x%40 == 0: @@ -316,6 +318,7 @@ def main(): player.player_in_grid() player.left_collision(field) player.top_collision(field) + player.bottom_collision(field) print(player.xgrid, player.ygrid) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() From 9cc3f0fd892ee89fb67723692d7675c00b2679f2 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 02:42:04 -0500 Subject: [PATCH 46/83] broken --- continuous Rectangle.py | 113 ++++++++++++++-------------------------- 1 file changed, 40 insertions(+), 73 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index e2a4221..524e5a2 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -77,75 +77,39 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa self.right = right self.acceleration_constant = .6 - # draws the rectangles that are dropped - def check_left_collision(self, field): - if field.matrix[int(self.ygrid)+1][int(self.xgrid)] != 0: - #print("Player", (self.xgrid-1), self.ygrid+2) - #print("ONE") - #print (self.x, (self.xgrid)*40) - if self.x < (self.xgrid+1)*40: - #print(self.x) - self.x = (self.xgrid+1)*40 - def check_right_collision(self, field): - #print("Player", (self.xgrid+1), self.ygrid+2) - if field.matrix[int(self.ygrid)+1][int(self.xgrid+1)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - if self.x > (self.xgrid)*40: - #print(self.x) - #print("GRID", self.xgrid*40) - #print(field.matrix[int(self.ygrid)+1][int(self.xgrid+1)]) - self.x = (self.xgrid)*40 - def check_top_collision(self, field): - if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - #print("Y", self.ygrid*40) - if self.y < (self.ygrid+1)*40: - #print("TRANSPORT") - #print(self.x) - #print("GRID", self.xgrid*40) - #print(field.matrix[int(self.ygrid)+3][int(self.xgrid+3)]) - self.y = (self.ygrid+1)*40 - self.velocity = self.velocity*-.5 - def check_bottom_collision(self, field): - if field.matrix[int(self.ygrid)+2][int(self.xgrid)] != 0: - #print("ONE") - #print (self.x, (self.xgrid)*40) - #print("DETECT") - if self.y > (self.ygrid)*40: - #print("TRANSPORT") - #print(self.x) - #print("GRID", self.xgrid*40) - self.y = (self.ygrid)*40 - self.velocity = 0 - self.fall = 'off' - jump = 1 - return jump - def bottom_collision(self, field): + + def bottom_collision(self, field, next_y,jump): + # nexty_index = (self.y + next_y)//40 + # print(next_y,nexty_index) + # if self.y + next_y > self.ygrid*40: + # if self.x%40 == 0: + # if field.matrix[int(nexty_index+2)][int(self.xgrid)] !=0: + # self.fall = "off" + # self.velocity = 0 + # self.y = (self.ygrid+1)*40 + # jump = 1 + # else: + # self.fall = 'on' + # elif field.matrix[int(nexty_index+2)][int(self.xgrid)] != 0 or field.matrix[int(nexty_index)+1][int(self.xgrid+1)] != 0: + # self.fall = "off" + # self.velocity = 0 + # jump = 1 + # self.y = (self.ygrid+1)*40 + # return jump if self.x%40 == 0: if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: self.fall = "off" self.velocity = 0 - else: - self.fall = 'on' - elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)+2][int(self.xgrid+1)] != 0: - self.fall = "off" - self.velocity = 0 - else: - self.fall = "on" - + self.y = (self.ygrid)*40 + jump = 1 def left_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: - print("in line") if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: - print("STUCK") return False else: return True elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: - print("FALSE 2") return False else: return True @@ -155,27 +119,33 @@ def left_collision(self, field): def right_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: - print("in line") if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: - print("STUCK") return False else: return True elif field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] != 0: - print("FALSE 2") return False else: return True else: return True - def top_collision(self, field): + def top_collision(self, field, next_y): + nexty_index = (self.y + next_y)//40 if self.x%40 == 0: - if field.matrix[int(self.ygrid-1)][int(self.xgrid)] != 0: - print("BLOCK TOP") + if field.matrix[int(nexty_index)][int(self.xgrid)] !=0: + self.fall = "off" + self.velocity = -.5*self.velocity + self.y = self.ygrid*40 + else: + self.fall = 'on' + elif field.matrix[int(nexty_index)][int(self.xgrid)] != 0 or field.matrix[int(nexty_index)][int(self.xgrid+1)] != 0: + self.fall = "off" + self.velocity = -.5*self.velocity + self.y = self.ygrid*40 else: - field.matrix[int(self.ygrid-1)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)-1][int(self.xgrid+1)] != 0 - print("BLOCK TOP") + self.fall = "on" + return jump def player_in_grid(self): self.xgrid = self.x//block_size @@ -326,12 +296,11 @@ def main(): ### CONTROL while not done: field.matrix_update(inventory_block_index) - player.fall = 'on' + next_y = player.velocity player.player_in_grid() player.left_collision(field) - player.top_collision(field) - player.bottom_collision(field) - print(player.xgrid, player.ygrid) + #player.top_collision(field,next_y) + #jump = player.bottom_collision(field, next_y,jump) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -346,20 +315,18 @@ def main(): if keys[pygame.K_LEFT]: player_left_move = player.left_collision(field) - print(player_left_move) if player_left_move is True: player.left = 'on' else: player.left = 'off' if keys[pygame.K_RIGHT]: player_right_move = player.right_collision(field) - print(player_right_move) if player_right_move is True: player.right = 'on' - if player.y >= 720: # 839 + if player.y >= 839: - player.y = 720 + player.y = 839 player.velocity = 0 jump = 1 player.fall = 'off' From 92a2d4d332de6a488782578bc25be43d29fb9146 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 03:08:25 -0500 Subject: [PATCH 47/83] pretty much works! --- continuous Rectangle.py | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 524e5a2..12e8ce4 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -65,7 +65,7 @@ def matrix_print(self): print(rows) class Player(): - def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off'): + def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off',jump=0): self.x = x self.y = y self.width = width @@ -76,9 +76,11 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa self.left = left self.right = right self.acceleration_constant = .6 + self.jump = jump - def bottom_collision(self, field, next_y,jump): + def bottom_collision(self, field, next_y): + self.jump = 1 # nexty_index = (self.y + next_y)//40 # print(next_y,nexty_index) # if self.y + next_y > self.ygrid*40: @@ -96,12 +98,16 @@ def bottom_collision(self, field, next_y,jump): # jump = 1 # self.y = (self.ygrid+1)*40 # return jump - if self.x%40 == 0: + if self.x % 40 == 0: if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 - jump = 1 + elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: + self.fall = "off" + self.velocity = 0 + self.y = (self.ygrid)*40 + def left_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: @@ -145,7 +151,6 @@ def top_collision(self, field, next_y): self.y = self.ygrid*40 else: self.fall = "on" - return jump def player_in_grid(self): self.xgrid = self.x//block_size @@ -171,7 +176,7 @@ def draw_shot(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - def jump(self): + def jumps(self): self.velocity = -12 self.fall = 'on' @@ -292,15 +297,15 @@ def main(): field = Field() inventory = Inventory(0, 0, 20, 40, 40) inventory_block_index = 2 - jump = 1 ### CONTROL while not done: + player.fall = 'on' field.matrix_update(inventory_block_index) next_y = player.velocity player.player_in_grid() player.left_collision(field) #player.top_collision(field,next_y) - #jump = player.bottom_collision(field, next_y,jump) + player.bottom_collision(field, next_y) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() if menu_screen is True: @@ -328,7 +333,7 @@ def main(): player.y = 839 player.velocity = 0 - jump = 1 + player.jump = 1 player.fall = 'off' if mouse2[0] == 1: inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) @@ -341,9 +346,9 @@ def main(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_UP: - if jump == 1: - player.jump() - jump = 0 + if player.jump == 1: + player.jumps() + player.jump = 0 if event.key == pygame.K_p: menu_screen = True if event.key == pygame.K_c: From c3262721b04b41549a6986e65f639a79a48b39b5 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 21:17:03 -0500 Subject: [PATCH 48/83] Working --- continuous Rectangle.py | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 12e8ce4..9807309 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -1,4 +1,5 @@ import pygame +from pygame.locals import* pygame.init() size = [1840, 920] @@ -49,7 +50,7 @@ def __init__(self, num_rows=3, color=0): for row in range(num_rows): for column in range(int(size[0]/block_size)): - rectangle_color = color_matrix[color] + rectangle_color = color_matrix[1] block_x = column*block_size block_y = size[1]-block_size*row - block_size block = Rectangle(block_x, block_y, @@ -80,7 +81,7 @@ def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fa def bottom_collision(self, field, next_y): - self.jump = 1 + self.jump = 0 # nexty_index = (self.y + next_y)//40 # print(next_y,nexty_index) # if self.y + next_y > self.ygrid*40: @@ -103,11 +104,12 @@ def bottom_collision(self, field, next_y): self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 + self.jump = 1 elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 - + self.jump = 1 def left_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: @@ -156,7 +158,7 @@ def player_in_grid(self): self.xgrid = self.x//block_size self.ygrid = self.y//block_size - def draw(self): + def draw(self, img): if self.fall == 'on': self.velocity += self.acceleration_constant @@ -167,8 +169,8 @@ def draw(self): self.x += 4 self.y = self.y + self.velocity - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - + #pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + screen.blit(img,(self.x,self.y)) def draw_shot(self): self.x = self.x + 10 @@ -177,7 +179,7 @@ def draw_shot(self): def jumps(self): - self.velocity = -12 + self.velocity = -9 self.fall = 'on' @@ -297,6 +299,9 @@ def main(): field = Field() inventory = Inventory(0, 0, 20, 40, 40) inventory_block_index = 2 + img = pygame.image.load('amon.png') + grass = pygame.image.load("grass.png") + stone = pygame.image.load("stone.png") ### CONTROL while not done: player.fall = 'on' @@ -385,11 +390,14 @@ def main(): for column in row: column_count+=1 if field.matrix[row_count][column_count] != 0: - rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) - rectangle.draw_with_outline() - + #rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) + #rectangle.draw_with_outline() + if field.matrix[row_count][column_count] == 2: + screen.blit(grass,(column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 1: + screen.blit(stone, (column_count*40, row_count*40)) inventory.draw_inventory(field, inventory_block_index) - player.draw() + player.draw(img) pygame.display.flip() pygame.quit() From 948f02ab6fcd9d75ffc0721aa6b579d47f5752f6 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 21:18:55 -0500 Subject: [PATCH 49/83] Images --- amon.png | Bin 0 -> 7223 bytes grass.png | Bin 0 -> 3901 bytes stone.png | Bin 0 -> 1355 bytes 3 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 amon.png create mode 100644 grass.png create mode 100644 stone.png diff --git a/amon.png b/amon.png new file mode 100644 index 0000000000000000000000000000000000000000..8c91379c9742491847dee32578f00402ed73dc3b GIT binary patch literal 7223 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 literal 0 HcmV?d00001 diff --git a/grass.png b/grass.png new file mode 100644 index 0000000000000000000000000000000000000000..36ef53c95c08e0b5f6d1a22718738048c98d44f4 GIT binary patch literal 3901 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 literal 0 HcmV?d00001 diff --git a/stone.png b/stone.png new file mode 100644 index 0000000000000000000000000000000000000000..ef96c8a5cad3fd7b5fdc24f7242960ce8cb77b7f GIT binary patch literal 1355 zcmV-R1+@B!P)uk00004XF*Lt006O% z3;baP0000WV@Og>004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00002 zVoOIv0RM-N%)bBt00(qQO+^Rc0|yj16{^;AQUCx121!IgR5;5eR0)#fAQ0oTJDJ?( zzA?tP@%(v3qEw|^U_+}VH92do?6#g~34o@z8 zf-@?Vl>Bw0oC_gj2*#%rgW*JQ-KP{n-zU~dK^ey@^eyxUaTxm04}*J?cK)%a{;Ws$ z*fQ0@hcMPJ&U&76KwbTXjN^LlON^yt`sy8(##`>^X-q(W)H#P3qka%deJwsX3Uv5U z=H$P3XbX(;bpu1m0Fq27squ}2q|{7PQQg10EbBDQ$)-Mp==|I>vV)U%*1NG<+PPYH zMelDp9jF}F2cxx%YmuaE`>uX}Up``y%G9S2*L@#QVVr9ne}672;w<8)Wzo0W%UWYK zUO#9hP+p znh6CSF(ogFVU!u~0L!~)C#B*7S5MnASST-p2Th|GfnR*^g5iDIU1-xC?Z-JB1u*M_ zVIP3CFfJ(GNOpHV?I&a~V{#wXQhTTQ_eCsdX#M?8`l+7NMVtjEwp+OKQ8F$#c}T65 zbRLoe(>fTZU+!;T=XC2(xPb4PDCFuQ*xBH6Q+GcSZ45S;wA@5O^(t61Z7Z?s3{wPi zeJUj$PbnCcYY`4!aZ}AWF1{`Z2DC1q7VNu2MjnqRl{PF{=_YzC&R|aqrJB|t6GGZ& zd>hn18aFh^f6U4_$b_&|xRRi0NmJXyeO_t)ph%ul3aJ_fNSxm+%;#1VIRW#d(q3z5 zM|?pC$PRYLbbGn7ACo|?6%|rQ?fPK9&E=L~1PqLWUr((V;vGE^g58-#>d|#XinTxo zbrYZqn<47TIE$T@>)l)jobI8pV|}e_^7zQ*7VPCpk9ssR2;1tO{RV?N2bWmP1|vE2 zvbj$sb6ut}`qrLi=yq*$#)k-H@1N)Q*)|_x0ysus*m;?exMflIl$k(fHVotZ!M1Hv z825d=kyglgCBaaPw|t~4W*=ZuiVw!N)_ zEaNyrJLb|DG?(aw*FFv9W8-BR>EkX#?k$Pid4`|M)naOU$=mRb$KPMUgT*{wA3qn0 zkU~OZjg~;G9Yx|_?SFqg9L6QohAkDQHAh^TuwboJTUHtqUyRG*-&hv{R_R-^ttHOI z?Km=0@&P1A=%jdF-ta7@$=~vw=>GwuEC53c`lxsS002RBMObuWZ*6U5Zgc=cQbj>j zPf|J{XJjpEaAjv8b}=q6ASiWnX>MmANlHf`N>D{dAa*t~DJ&pybzy92ba@~>AU8D% z0Gx-00000bbVXQnWMOn=I%9HWVRU5xGB7bWEif}JFgH{(Fgi6hIx;aWFf}?bFxmYW z9RL6TC3HntbYx+4WjbwdWNBu305UK!H!UzTEigA!GB7$dHaapfEig4YFfgc~prHT& N002ovPDHLkV1f+xQ!oGk literal 0 HcmV?d00001 From a5a132ffa2c443a777a7d7592aa85ec655841321 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 21:25:32 -0500 Subject: [PATCH 50/83] wasd --- continuous Rectangle.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 9807309..7466f2c 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -323,13 +323,13 @@ def main(): player.left = 'off' player.right = 'off' - if keys[pygame.K_LEFT]: + if keys[pygame.K_a]: player_left_move = player.left_collision(field) if player_left_move is True: player.left = 'on' else: player.left = 'off' - if keys[pygame.K_RIGHT]: + if keys[pygame.K_d]: player_right_move = player.right_collision(field) if player_right_move is True: player.right = 'on' @@ -350,7 +350,7 @@ def main(): done = True if event.type == pygame.KEYDOWN: - if event.key == pygame.K_UP: + if event.key == pygame.K_w: if player.jump == 1: player.jumps() player.jump = 0 From d783106cd4b335de190791f98e6ada312d26c7a9 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 21:36:31 -0500 Subject: [PATCH 51/83] range --- continuous Rectangle.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 7466f2c..74ddf1d 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -250,7 +250,7 @@ def add_to_inventory(self, block_type, mouse, field, player_x, player_y): mouse_y_grid = mouse [1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) <5: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) <5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: self.bin_list[block_type-1] += 1 @@ -266,7 +266,7 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b player_y_grid = player_y //40 if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) < 5: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: self.bin_list[block_type-1] -= 1 mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 From 3e19f10995f83d227429298f8e473a2a630e4c7a Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 21:58:07 -0500 Subject: [PATCH 52/83] BLOCKS --- continuous Rectangle.py | 46 +++++++++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 9807309..9bea669 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -48,14 +48,16 @@ def __init__(self, num_rows=3, color=0): for j in range(size[0]//40): inner.append(0) + print(num_rows) for row in range(num_rows): for column in range(int(size[0]/block_size)): - rectangle_color = color_matrix[1] - block_x = column*block_size - block_y = size[1]-block_size*row - block_size - block = Rectangle(block_x, block_y, - block_size, block_size, rectangle_color) - self.blocks.append(block) + self.matrix[row+20][column] = row+1 + #rectangle_color = color_matrix[1] + #block_x = column*block_size + #block_y = size[1]-block_size*row - block_size + #block = Rectangle(block_x, block_y, + # block_size, block_size, rectangle_color) + #self.blocks.append(block) def matrix_update(self, block_type): for block in self.blocks: @@ -245,11 +247,12 @@ def update_bin_width(self, block_type): else: self.bin_width = block_size - def add_to_inventory(self, block_type, mouse, field, player_x, player_y): + def add_to_inventory(self, mouse, field, player_x, player_y): mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse [1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 + block_type = field.matrix[mouse_y_grid][mouse_x_grid] if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid) <5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: @@ -274,18 +277,26 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b field.blocks.append(drop_block) self.update_bin_width(block_type) - def draw_inventory(self, field, current_block_index): + def draw_inventory(self, field, current_block_index, grass, stone, dirt): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() + image_list = [grass, dirt, stone] for bin in range(len(self.bin_list)): - rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) - rectangle.draw_rectangle() + #rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) + #rectangle.draw_rectangle() + if bin+1 == 1: + screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 2: + screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 3: + screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 40, WHITE) text.print_text() text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) text2.print_text() - current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) - current_block.draw_rectangle() + #current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) + #current_block.draw_rectangle() + screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) #Control def main(): @@ -302,6 +313,7 @@ def main(): img = pygame.image.load('amon.png') grass = pygame.image.load("grass.png") stone = pygame.image.load("stone.png") + dirt = pygame.image.load("dirt.png") ### CONTROL while not done: player.fall = 'on' @@ -341,7 +353,7 @@ def main(): player.jump = 1 player.fall = 'off' if mouse2[0] == 1: - inventory.add_to_inventory(inventory_block_index, mouse, field, player.x, player.y) + inventory.add_to_inventory(mouse, field, player.x, player.y) if mouse2[2] == 1: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) for event in pygame.event.get(): # User did something @@ -392,11 +404,13 @@ def main(): if field.matrix[row_count][column_count] != 0: #rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) #rectangle.draw_with_outline() - if field.matrix[row_count][column_count] == 2: - screen.blit(grass,(column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 1: + screen.blit(grass,(column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 2: + screen.blit(dirt, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 3: screen.blit(stone, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt) player.draw(img) pygame.display.flip() pygame.quit() From ac77fbd52ec81f2999694fa97f21e686df07e28b Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 21:58:37 -0500 Subject: [PATCH 53/83] fix --- continuous Rectangle.py | 29 +++++++++++------------------ 1 file changed, 11 insertions(+), 18 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 74ddf1d..95f53fe 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -138,21 +138,14 @@ def right_collision(self, field): else: return True - def top_collision(self, field, next_y): - nexty_index = (self.y + next_y)//40 - if self.x%40 == 0: - if field.matrix[int(nexty_index)][int(self.xgrid)] !=0: - self.fall = "off" - self.velocity = -.5*self.velocity - self.y = self.ygrid*40 - else: - self.fall = 'on' - elif field.matrix[int(nexty_index)][int(self.xgrid)] != 0 or field.matrix[int(nexty_index)][int(self.xgrid+1)] != 0: - self.fall = "off" - self.velocity = -.5*self.velocity - self.y = self.ygrid*40 - else: - self.fall = "on" + def top_collision(self, field): + if self.x % 40 == 0: + if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: + self.y = self.ygrid + self.velocity = self.velocity * -.5 + elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: + self.velocity = self.velocity * -.5 + self.velocity = self.velocity * -.5 def player_in_grid(self): self.xgrid = self.x//block_size @@ -309,7 +302,7 @@ def main(): next_y = player.velocity player.player_in_grid() player.left_collision(field) - #player.top_collision(field,next_y) + player.top_collision(field) player.bottom_collision(field, next_y) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() @@ -334,9 +327,9 @@ def main(): if player_right_move is True: player.right = 'on' - if player.y >= 839: + if player.y >= 840: - player.y = 839 + player.y = 840 player.velocity = 0 player.jump = 1 player.fall = 'off' From bf00e1726ef8731265f20ba50882c5dcfac14dfa Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 22:11:49 -0500 Subject: [PATCH 54/83] top --- continuous Rectangle.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b135bd6..b6a1146 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -143,11 +143,11 @@ def right_collision(self, field): def top_collision(self, field): if self.x % 40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: - self.y = self.ygrid + self.y = (self.ygrid+1)*40 self.velocity = self.velocity * -.5 elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: self.velocity = self.velocity * -.5 - self.velocity = self.velocity * -.5 + self.y = (self.ygrid+1)*40 def player_in_grid(self): self.xgrid = self.x//block_size From 3f85b83d24aeee49cb5e2a7b3fd28f12b3bfab09 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 22:38:37 -0500 Subject: [PATCH 55/83] BEDROCK --- continuous Rectangle.py | 44 ++++++++++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 16 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b6a1146..a5ebb7b 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -38,20 +38,20 @@ def draw_shot(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) class Field(): - def __init__(self, num_rows=3, color=0): + def __init__(self, num_rows=4, color=0): self.blocks = [] self.matrix = [] inner = [] for i in range(size[1]//40+1): inner = [] self.matrix.append(inner) - for j in range(size[0]//40): + for j in range(size[0]//40+1): inner.append(0) print(num_rows) for row in range(num_rows): for column in range(int(size[0]/block_size)): - self.matrix[row+20][column] = row+1 + self.matrix[row+19][column] = row+1 #rectangle_color = color_matrix[1] #block_x = column*block_size #block_y = size[1]-block_size*row - block_size @@ -68,7 +68,7 @@ def matrix_print(self): print(rows) class Player(): - def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off',jump=0): + def __init__(self, x=40, y=660, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off',jump=0): self.x = x self.y = y self.width = width @@ -224,7 +224,7 @@ def menu(): class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0 ] + bin_list = [0, 0, 0] bin_list_item = [BLACK, RED, BLACK, GREEN] self.init_quantity = init_quantity self.x_pos = x_pos @@ -246,14 +246,15 @@ def add_to_inventory(self, mouse, field, player_x, player_y): player_x_grid = player_x//40 player_y_grid = player_y//40 block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) <5: - if self.bin_list[block_type-1] < 64: - if field.matrix[mouse[1]//40][mouse[0]//40] != 0: - self.bin_list[block_type-1] += 1 - x_bin = (mouse[0]//40)*40 - y_bin = (mouse[1]//40)*40 - field.matrix[mouse[1]//40][mouse[0]//40] = 0 - self.update_bin_width(block_type) + if block_type != 4: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) <5: + if self.bin_list[block_type-1] < 64: + if field.matrix[mouse[1]//40][mouse[0]//40] != 0: + self.bin_list[block_type-1] += 1 + x_bin = (mouse[0]//40)*40 + y_bin = (mouse[1]//40)*40 + field.matrix[mouse[1]//40][mouse[0]//40] = 0 + self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): mouse_x_grid = mouse[0] // 40 @@ -270,7 +271,7 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b field.blocks.append(drop_block) self.update_bin_width(block_type) - def draw_inventory(self, field, current_block_index, grass, stone, dirt): + def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() image_list = [grass, dirt, stone] @@ -283,6 +284,8 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt): screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 3: screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 4: + screen.blit(bedrock,(self.x_pos, self.y_pos + bin*self.bin_height)) text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 40, WHITE) text.print_text() text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) @@ -307,6 +310,7 @@ def main(): grass = pygame.image.load("grass.png") stone = pygame.image.load("stone.png") dirt = pygame.image.load("dirt.png") + bedrock = pygame.image.load("bedrock.png") ### CONTROL while not done: player.fall = 'on' @@ -339,8 +343,14 @@ def main(): if player_right_move is True: player.right = 'on' + #left + if player.x <= 0: + player.x = 0 + player.jump = 1 + if player.x >= 1800: + player.x = 1800 + player.jump = 1 if player.y >= 840: - player.y = 840 player.velocity = 0 player.jump = 1 @@ -403,7 +413,9 @@ def main(): screen.blit(dirt, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 3: screen.blit(stone, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt) + if field.matrix[row_count][column_count] == 4: + screen.blit(bedrock, (column_count*40, row_count*40)) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock) player.draw(img) pygame.display.flip() pygame.quit() From 6d51a8666e65e2cec54c3b5400f08d2dc35b8cc1 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 23:15:02 -0500 Subject: [PATCH 56/83] jumpy blocks --- continuous Rectangle.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index b6a1146..69e3dcc 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -28,6 +28,7 @@ def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): #draws the rectangles that are dropped def draw_rectangle(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_with_outline(self): pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) @@ -47,28 +48,30 @@ def __init__(self, num_rows=3, color=0): self.matrix.append(inner) for j in range(size[0]//40): inner.append(0) - - print(num_rows) for row in range(num_rows): for column in range(int(size[0]/block_size)): self.matrix[row+20][column] = row+1 + + self. matrix[15][15] = 5 + self.matrix_print() #rectangle_color = color_matrix[1] #block_x = column*block_size #block_y = size[1]-block_size*row - block_size #block = Rectangle(block_x, block_y, - # block_size, block_size, rectangle_color) + #block_size, block_size, rectangle_color) #self.blocks.append(block) def matrix_update(self, block_type): for block in self.blocks: self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type self.blocks.remove(block) + def matrix_print(self): for rows in self.matrix: print(rows) class Player(): - def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off',jump=0): + def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off', jump=0): self.x = x self.y = y self.width = width @@ -101,17 +104,23 @@ def bottom_collision(self, field, next_y): # jump = 1 # self.y = (self.ygrid+1)*40 # return jump + block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] if self.x % 40 == 0: - if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: + if block_below !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 - elif field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: + if block_below == 5: + self.jumps() + elif block_below !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 + if block_below == 5 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] == 5: + self.jumps() + def left_collision(self, field): if self.x%40 == 0: if self.y%40 == 0: @@ -147,7 +156,7 @@ def top_collision(self, field): self.velocity = self.velocity * -.5 elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: self.velocity = self.velocity * -.5 - self.y = (self.ygrid+1)*40 + self.y = (self.ygrid+ 1)*40 def player_in_grid(self): self.xgrid = self.x//block_size @@ -395,8 +404,10 @@ def main(): for column in row: column_count+=1 if field.matrix[row_count][column_count] != 0: - #rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) - #rectangle.draw_with_outline() + if field.matrix[row_count][column_count] == 5: + # rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) + rectangle = Rectangle(column_count*40, row_count*40, 40, 40) + rectangle.draw_rectangle() if field.matrix[row_count][column_count] == 1: screen.blit(grass,(column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 2: From 769454a4fe2d47ae4b283164c956514223925022 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 23:18:16 -0500 Subject: [PATCH 57/83] Bedrock --- bedrock.png | Bin 0 -> 1269 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 bedrock.png diff --git a/bedrock.png b/bedrock.png new file mode 100644 index 0000000000000000000000000000000000000000..91f5e02fb768ade8c244c4140a12f241e28a2f3c GIT binary patch literal 1269 zcmVuk00004XF*Lt006O% z3;baP0000WV@Og>004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00002 zVoOIv0RM-N%)bBt00(qQO+^Rc0|yoxE7qFL_5c6_{YgYYR5;5`R9#czW)#kaII|Y% zlokBi9d~=#b-^T%L=qGju{xj$Atb>i2)6Yn^kQ{)MW7Hn3BrYf{j)vieFNijmApB; zhv(xQ#Ov~YH1&#g=MD*6&-b66q0m!4iG%6W$n#wHb|)M=hC<7> znxk2OX#hXZW?lL=d)Qw3`4n%|&TBp2^YF*6N8$HRlw!yCAIIbIr1$IUx(0>X`(M`O z0^s1|_Ks2@$e(<7JLP<_(QdU`&GV9e4~1%UY2_1APK1|Mc8LHiE4weyJzcR7wteYA zVP$7+gA)P#S|s{gGMN@dMJe_s!y{o|HL3*l9u$7L?S89QbX~8MOU3o@+KCP#^sZZ% zhOR0S#eNP7ozZO4HnD+iYi~o5vfUiLOj>wiNOLDREcB-!Y@=2+4C5@m56|LA~Y)GGx(aj4U8BLX(6Zz969PLfOg}#Ky!400Y-fk7B~WN zAvMpDAPRd4>3#x=KcX89GAe+umj)77=aCc6^wLH+Zh+wJ<}p~n5Pd;dlPGIQL0>_) zwP+|(vP{#eiY&`ABwdG9q7DghN~R~awiSt&;mk7faKMmob(^N$YPaebVi}pjiDjOZ z$~ElM=)eg>Sb^a7)t^^&3lz>iya35bJLq8%M}YMh@$aQ+J58r%XcDK~0ZA0Rs;OEP zy#`r;b&J5ZjDt*OUy@RMDo1jbk)iQQbZPLz2b{TtHfw2OXN&&ub zB{jNpB&8zDVOGj_e9t9e_`(p1Fim~|3rVCQ?Ob9tw6e=7^Q|(uVpLT#EoX>RETlN4 zi;;$Bek%rQ!*q{n7_OPO(akg11Z|vRi4!l7DWu)J>2?P=-4uWQ!z=?knkJlLf$k9e zGuV_&H^6i}CK8FA8WfN*R2xyfz`gtY=v0H(9#blv%E8{ijLjeOF793bSX`_Wo9qp$ z_F|;@fG?4Po}q;>JK&shps0W%I~{{veN4yHw7AqM~e03~!qSaf7zbY(hYa%Ew3WdJfTF*hwRGc7PT zR5CI;GB-LjGc7PRIxsLUsLMqF001R)MObuXVRU6WZEs|0W_bWIFflhRFf%PMH&ik* fIx;spG&3zQH99abU-fhO00000NkvXXu0mjfsfRTg literal 0 HcmV?d00001 From 6eab25a16765510cac2caf3f141c771758cbc08f Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 23:24:29 -0500 Subject: [PATCH 58/83] Self Place --- continuous Rectangle.py | 39 +++++++++++++++++++++++++++++++-------- 1 file changed, 31 insertions(+), 8 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index a5ebb7b..5a95bb6 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -257,18 +257,41 @@ def add_to_inventory(self, mouse, field, player_x, player_y): self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): + print(mouse) mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse [1] // 40 player_x_grid = player_x//40 player_y_grid = player_y //40 - if field.matrix[mouse[1]//40][mouse[0]//40] == 0: - if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: - self.bin_list[block_type-1] -= 1 - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) + if player_x%40 == 0: + check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) + print(check_top_player, check_bottom_player) + if (check_top_player== False) and (check_bottom_player== False): + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + if self.bin_list[block_type-1] > 0: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + else: + print("HEY") + check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) + check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) + check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) + print(check_top_left_player, check_top_right_player, check_bottom_left_player, check_bottom_right_player) + if (check_top_left_player == False) and (check_top_right_player == False): + if (check_bottom_left_player== False) and (check_bottom_right_player== False): + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + if self.bin_list[block_type-1] > 0: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + self.bin_list[block_type-1] -= 1 + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock): From 80835cd4f10e8ec928c5951233e46adf36620495 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 23:24:34 -0500 Subject: [PATCH 59/83] bed and jump --- continuous Rectangle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index d3aacd8..1b94159 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -50,7 +50,7 @@ def __init__(self, num_rows=4, color=0): inner.append(0) for row in range(num_rows): for column in range(int(size[0]/block_size)): - self.matrix[row+20][column] = row+1 + self.matrix[row+19][column] = row+1 self. matrix[15][15] = 5 self.matrix_print() From f12c387199ac8479cf01a0f2ebc4f234520399c1 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 23:27:12 -0500 Subject: [PATCH 60/83] Self-Place, No Print --- continuous Rectangle.py | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 5a95bb6..2eda218 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -48,7 +48,6 @@ def __init__(self, num_rows=4, color=0): for j in range(size[0]//40+1): inner.append(0) - print(num_rows) for row in range(num_rows): for column in range(int(size[0]/block_size)): self.matrix[row+19][column] = row+1 @@ -84,23 +83,6 @@ def __init__(self, x=40, y=660, width=40, height=80, color=GREEN, velocity=0, fa def bottom_collision(self, field, next_y): self.jump = 0 - # nexty_index = (self.y + next_y)//40 - # print(next_y,nexty_index) - # if self.y + next_y > self.ygrid*40: - # if self.x%40 == 0: - # if field.matrix[int(nexty_index+2)][int(self.xgrid)] !=0: - # self.fall = "off" - # self.velocity = 0 - # self.y = (self.ygrid+1)*40 - # jump = 1 - # else: - # self.fall = 'on' - # elif field.matrix[int(nexty_index+2)][int(self.xgrid)] != 0 or field.matrix[int(nexty_index)+1][int(self.xgrid+1)] != 0: - # self.fall = "off" - # self.velocity = 0 - # jump = 1 - # self.y = (self.ygrid+1)*40 - # return jump if self.x % 40 == 0: if field.matrix[int(self.ygrid+2)][int(self.xgrid)] !=0: self.fall = "off" @@ -257,7 +239,6 @@ def add_to_inventory(self, mouse, field, player_x, player_y): self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): - print(mouse) mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse [1] // 40 player_x_grid = player_x//40 @@ -265,7 +246,6 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b if player_x%40 == 0: check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) - print(check_top_player, check_bottom_player) if (check_top_player== False) and (check_bottom_player== False): if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: @@ -276,12 +256,10 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) else: - print("HEY") check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) - print(check_top_left_player, check_top_right_player, check_bottom_left_player, check_bottom_right_player) if (check_top_left_player == False) and (check_top_right_player == False): if (check_bottom_left_player== False) and (check_bottom_right_player== False): if field.matrix[mouse[1]//40][mouse[0]//40] == 0: From 2b6999dada5aff8d9295cc1dd0a55585b3a90906 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Tue, 7 Mar 2017 23:30:46 -0500 Subject: [PATCH 61/83] NEW DIRT --- dirt.png | Bin 2751 -> 4008 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/dirt.png b/dirt.png index 2959a9cab7350b9c7cdccee398b1a4d5bd19c5ba..161ccbbe2547a7e2c05b25219f3ed65d1ef32b9b 100644 GIT binary patch delta 3982 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 delta 2688 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 From a82e1716fa85dffb87d42fed6e6ac66fa3c88760 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Tue, 7 Mar 2017 23:31:22 -0500 Subject: [PATCH 62/83] g --- continuous Rectangle.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 1b94159..71d91aa 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -183,13 +183,19 @@ def draw_shot(self): self.y = self.y pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - def jumps(self): self.velocity = -9 self.fall = 'on' class Text(): + def __init__(self, text, x_pos, y_pos, size, color): + self.text = text + self.x_pos = x_pos + self.y_pos = y_pos + self.size = size + self.color = color + def __init__(self, text, x_pos, y_pos, size, color): self.text = text self.x_pos = x_pos From fd18c33c923f57cbe973a23977f8b6213a9c8905 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 00:12:48 -0500 Subject: [PATCH 63/83] g --- continuous Rectangle.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index a5eb9ed..8274692 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -97,14 +97,14 @@ def bottom_collision(self, field, next_y): self.y = (self.ygrid)*40 self.jump = 1 if block_below == 5: - self.jumps() + self.super_jump() elif block_below !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 if block_below == 5 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] == 5: - self.jumps() + self.super_jump() def left_collision(self, field): if self.x%40 == 0: @@ -158,7 +158,6 @@ def draw(self, img): self.x += 4 self.y = self.y + self.velocity - #pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) screen.blit(img,(self.x,self.y)) def draw_shot(self): @@ -170,6 +169,10 @@ def jumps(self): self.velocity = -9 self.fall = 'on' + def super_jump(self): + self.velocity = -13 + self.fall = 'on' + class Text(): def __init__(self, text, x_pos, y_pos, size, color): @@ -224,7 +227,7 @@ def menu(): class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0] + bin_list = [0, 0, 0, 0] bin_list_item = [BLACK, RED, BLACK, GREEN] self.init_quantity = init_quantity self.x_pos = x_pos @@ -242,17 +245,15 @@ def update_bin_width(self, block_type): def add_to_inventory(self, mouse, field, player_x, player_y): mouse_x_grid = mouse[0] // 40 - mouse_y_grid = mouse [1] // 40 + mouse_y_grid = mouse[1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 block_type = field.matrix[mouse_y_grid][mouse_x_grid] if block_type != 4: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) <5: + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: self.bin_list[block_type-1] += 1 - x_bin = (mouse[0]//40)*40 - y_bin = (mouse[1]//40)*40 field.matrix[mouse[1]//40][mouse[0]//40] = 0 self.update_bin_width(block_type) @@ -267,7 +268,7 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b if (check_top_player== False) and (check_bottom_player== False): if field.matrix[mouse[1]//40][mouse[0]//40] == 0: if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: self.bin_list[block_type-1] -= 1 mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 From f418059a0e5b48b4524f8ed3eabf4a2a88d2234a Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 01:05:05 -0500 Subject: [PATCH 64/83] jumpy --- continuous Rectangle.py | 43 +++++++++++++++++++--------------------- spring.png | Bin 0 -> 684 bytes 2 files changed, 20 insertions(+), 23 deletions(-) create mode 100644 spring.png diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 8274692..59bc38b 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -50,9 +50,12 @@ def __init__(self, num_rows=4, color=0): inner.append(0) for row in range(num_rows): for column in range(int(size[0]/block_size)): - self.matrix[row+19][column] = row+1 + if row == 3: + self.matrix[row+19][column] = 10 + else: + self.matrix[row+19][column] = row+1 - self. matrix[15][15] = 5 + self. matrix[15][6] = 4 self.matrix_print() #rectangle_color = color_matrix[1] @@ -96,14 +99,14 @@ def bottom_collision(self, field, next_y): self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 - if block_below == 5: + if block_below == 4: self.super_jump() elif block_below !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 - if block_below == 5 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] == 5: + if block_below == 4 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] == 4: self.super_jump() def left_collision(self, field): @@ -182,12 +185,6 @@ def __init__(self, text, x_pos, y_pos, size, color): self.size = size self.color = color - def __init__(self, text, x_pos, y_pos, size, color): - self.text = text - self.x_pos = x_pos - self.y_pos = y_pos - self.size = size - self.color = color def print_text(self): font = pygame.font.SysFont("monospace", self.size) label = font.render(self.text, 40, self.color) @@ -228,7 +225,7 @@ def menu(): class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): bin_list = [0, 0, 0, 0] - bin_list_item = [BLACK, RED, BLACK, GREEN] + bin_list_item = [BLACK, RED, BLACK, GREEN, BLUE] self.init_quantity = init_quantity self.x_pos = x_pos self.y_pos = y_pos @@ -249,7 +246,7 @@ def add_to_inventory(self, mouse, field, player_x, player_y): player_x_grid = player_x//40 player_y_grid = player_y//40 block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if block_type != 4: + if block_type != 10: if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: @@ -291,10 +288,10 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b field.blocks.append(drop_block) self.update_bin_width(block_type) - def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock): + def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() - image_list = [grass, dirt, stone] + image_list = [grass, dirt, stone, spring] for bin in range(len(self.bin_list)): #rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) #rectangle.draw_rectangle() @@ -305,7 +302,7 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc if bin+1 == 3: screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 4: - screen.blit(bedrock,(self.x_pos, self.y_pos + bin*self.bin_height)) + screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 40, WHITE) text.print_text() text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) @@ -331,6 +328,7 @@ def main(): stone = pygame.image.load("stone.png") dirt = pygame.image.load("dirt.png") bedrock = pygame.image.load("bedrock.png") + spring = pygame.image.load("spring.png") ### CONTROL while not done: player.fall = 'on' @@ -406,7 +404,8 @@ def main(): inventory_block_index = 2 if event.key == pygame.K_3: inventory_block_index = 3 - + if event.key == pygame.K_4: + inventory_block_index = 4 if event.key == pygame.K_q: pygame.quit() return @@ -425,19 +424,17 @@ def main(): for column in row: column_count+=1 if field.matrix[row_count][column_count] != 0: - if field.matrix[row_count][column_count] == 5: - # rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) - rectangle = Rectangle(column_count*40, row_count*40, 40, 40) - rectangle.draw_rectangle() + if field.matrix[row_count][column_count] == 4: + screen.blit(spring, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 1: - screen.blit(grass,(column_count*40, row_count*40)) + screen.blit(grass, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 2: screen.blit(dirt, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 3: screen.blit(stone, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 4: + if field.matrix[row_count][column_count] == 10: screen.blit(bedrock, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) player.draw(img) pygame.display.flip() pygame.quit() diff --git a/spring.png b/spring.png new file mode 100644 index 0000000000000000000000000000000000000000..73dcb97fc7f15136851ec46053d7663c43bddc42 GIT binary patch literal 684 zcmeAS@N?(olHy`uVBq!ia0vp^8X(L8Bp6mseZCP$v7|ftIx;Y9?C1WI$O_~uBzpw; zGB8xBF)%c=FfjZA3N^f7U???UV0e|lz+g3lfkC`r&aOZkpafHrx4R3&|Mvbf`++?6 z5>H=O_J_7Rl~w$%mvyN|*pZ`8wk+U=h za0!xpBLDBOJ>T`yyxY0Yzh9*xcW>v}BHqN$jSE*s^)AX7(6YFebIN~O6maLTJX(_Z9ORCbgc#^01rDexouXfMpo##@vEobn!c~ Date: Wed, 8 Mar 2017 01:05:09 -0500 Subject: [PATCH 65/83] Nether --- continuous Rectangle.py | 297 +++++++++++++++++++++++++--------------- netherack.png | Bin 0 -> 3536 bytes netherquartz.png | Bin 0 -> 4012 bytes soulsand.png | Bin 0 -> 3256 bytes 4 files changed, 183 insertions(+), 114 deletions(-) create mode 100644 netherack.png create mode 100644 netherquartz.png create mode 100644 soulsand.png diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 5e2b4dc..0cd634f 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -68,8 +68,9 @@ def matrix_update(self, block_type): self.blocks.remove(block) def matrix_print(self): + print("Matrix") for rows in self.matrix: - print(rows) + print(rows, ",") class Player(): def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off', jump=0): @@ -147,7 +148,7 @@ def player_in_grid(self): self.xgrid = self.x//block_size self.ygrid = self.y//block_size - def draw(self, img): + def draw(self, amon_picture): if self.fall == 'on': self.velocity += self.acceleration_constant @@ -159,7 +160,7 @@ def draw(self, img): self.y = self.y + self.velocity #pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - screen.blit(img,(self.x,self.y)) + screen.blit(amon_picture,(self.x,self.y)) def draw_shot(self): self.x = self.x + 10 @@ -184,8 +185,8 @@ def print_text(self): label = font.render(self.text, 40, self.color) screen.blit(label, (self.x_pos, self.y_pos)) -def menu(): - menu_screen = True +def menu(previous_level_select): + level_select = "Menu" done = False for event in pygame.event.get(): if event.type == pygame.QUIT: @@ -193,8 +194,17 @@ def menu(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: # If user hit q or closed") done = True - if event.key == pygame.K_p: - menu_screen = False + if previous_level_select is "unknown": + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + if event.key == pygame.K_p: + level_select = "Level_One" + else: + print("going previous", previous_level_select) + if event.key == pygame.K_p: + level_select = previous_level_select #if event.key == pygame.K_r: # player = Player() screen.fill(WHITE) @@ -214,7 +224,7 @@ def menu(): text_list.append(texts) for texts in text_list: texts.print_text() - return [menu_screen, done] + return [level_select, done] class Inventory(): def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): @@ -307,131 +317,190 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc #current_block.draw_rectangle() screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) +def level_two_map(): + matrix = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , + [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , + [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0] , + [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] + return matrix + + +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select): + level_variable = "open" + player.fall = 'on' + field.matrix_update(inventory_block_index) + next_y = player.velocity + player.player_in_grid() + player.left_collision(field) + player.top_collision(field) + player.bottom_collision(field, next_y) + previous_level_select = str(level) + clock.tick(40) + keys = pygame.key.get_pressed() + player.left = 'off' + player.right = 'off' + + if keys[pygame.K_a]: + player_left_move = player.left_collision(field) + if player_left_move is True: + player.left = 'on' + else: + player.left = 'off' + if keys[pygame.K_d]: + player_right_move = player.right_collision(field) + if player_right_move is True: + player.right = 'on' + + #left + if player.x <= 0: + player.x = 0 + player.jump = 1 + if player.x >= 1800: + player.x = 1800 + player.jump = 1 + if player.y >= 840: + player.y = 840 + player.velocity = 0 + player.jump = 1 + player.fall = 'off' + if mouse2[0] == 1: + inventory.add_to_inventory(mouse, field, player.x, player.y) + if mouse2[2] == 1: + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) + for event in pygame.event.get(): # User did something + + if event.type == pygame.QUIT: # If user hit q or closed + done = True + + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_w: + if player.jump == 1: + player.jumps() + player.jump = 0 + if event.key == pygame.K_p: + level_select = "Menu" + if event.key == pygame.K_c: + player_color += 1 + if player_color == 3: + player_color = 0 + player.color = color_matrix[player_color] + + if event.key == pygame.K_o: + field.matrix_print() + # inventory + if event.key == pygame.K_1: + inventory_block_index = 1 + if event.key == pygame.K_2: + inventory_block_index = 2 + if event.key == pygame.K_3: + inventory_block_index = 3 + + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- + screen.fill(WHITE) + + # draw color matric and main rectangle + # for block in field.blocks: + # block.draw_with_outline() + + row_count = -1 + for row in field.matrix: + column_count = -1 + row_count += 1 + for column in row: + column_count+=1 + if field.matrix[row_count][column_count] != 0: + if field.matrix[row_count][column_count] == 5: + # rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) + rectangle = Rectangle(column_count*40, row_count*40, 40, 40) + rectangle.draw_rectangle() + if field.matrix[row_count][column_count] == 1: + screen.blit(grass,(column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 2: + screen.blit(dirt, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 3: + screen.blit(stone, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 4: + screen.blit(bedrock, (column_count*40, row_count*40)) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock) + player.draw(amon_picture) + return [level_select, inventory_block_index, previous_level_select, mouse] + #Control def main(): #color_matrix = [BLACK, BLUE, GREEN, RED] - pygame.display.set_caption("Game!") clock = pygame.time.Clock() + previous_level_select = "unknown" player_color = 0 - menu_screen = True + level_select = "Menu" done = False player = Player() field = Field() + field2 = Field() + field2.matrix = level_two_map() + player2 = Player() + player2.x = 0 inventory = Inventory(0, 0, 20, 40, 40) + inventory2 = Inventory(0, 0, 20, 40, 40) inventory_block_index = 1 - img = pygame.image.load('amon.png') + inventory_block_index2 = 1 + amon_picture = pygame.image.load('amon.png') grass = pygame.image.load("grass.png") stone = pygame.image.load("stone.png") dirt = pygame.image.load("dirt.png") + soulsand = pygame.image.load("soulsand.png") + netherack = pygame.image.load("netherack.png") + netherquartz = pygame.image.load("netherquartz.png") bedrock = pygame.image.load("bedrock.png") ### CONTROL while not done: - player.fall = 'on' - field.matrix_update(inventory_block_index) - next_y = player.velocity - player.player_in_grid() - player.left_collision(field) - player.top_collision(field) - player.bottom_collision(field, next_y) + pygame.display.set_caption(level_select) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() - if menu_screen is True: - returned = menu() - menu_screen = returned[0] + if level_select is "Menu": + returned = menu(previous_level_select) + level_select = returned[0] done = returned[1] - if menu_screen is False: - clock.tick(40) - keys = pygame.key.get_pressed() - player.left = 'off' - player.right = 'off' - - if keys[pygame.K_a]: - player_left_move = player.left_collision(field) - if player_left_move is True: - player.left = 'on' - else: - player.left = 'off' - if keys[pygame.K_d]: - player_right_move = player.right_collision(field) - if player_right_move is True: - player.right = 'on' - - #left - if player.x <= 0: - player.x = 0 - player.jump = 1 - if player.x >= 1800: - player.x = 1800 - player.jump = 1 - if player.y >= 840: - player.y = 840 - player.velocity = 0 - player.jump = 1 - player.fall = 'off' - if mouse2[0] == 1: - inventory.add_to_inventory(mouse, field, player.x, player.y) - if mouse2[2] == 1: - inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - for event in pygame.event.get(): # User did something - - if event.type == pygame.QUIT: # If user hit q or closed - done = True - - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_w: - if player.jump == 1: - player.jumps() - player.jump = 0 - if event.key == pygame.K_p: - menu_screen = True - if event.key == pygame.K_c: - player_color += 1 - if player_color == 3: - player_color = 0 - player.color = color_matrix[player_color] - - if event.key == pygame.K_o: - field.matrix_print() - # inventory - if event.key == pygame.K_1: - inventory_block_index = 1 - if event.key == pygame.K_2: - inventory_block_index = 2 - if event.key == pygame.K_3: - inventory_block_index = 3 - - if event.key == pygame.K_q: - pygame.quit() - return - - # View------------------------------------------------------------- - screen.fill(WHITE) - - # draw color matric and main rectangle - # for block in field.blocks: - # block.draw_with_outline() - - row_count = -1 - for row in field.matrix: - column_count = -1 - row_count += 1 - for column in row: - column_count+=1 - if field.matrix[row_count][column_count] != 0: - if field.matrix[row_count][column_count] == 5: - # rectangle = Rectangle(column_count*40, row_count*40, 40, 40, inventory.bin_list_item[field.matrix[row_count][column_count]]) - rectangle = Rectangle(column_count*40, row_count*40, 40, 40) - rectangle.draw_rectangle() - if field.matrix[row_count][column_count] == 1: - screen.blit(grass,(column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 2: - screen.blit(dirt, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 3: - screen.blit(stone, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 4: - screen.blit(bedrock, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock) - player.draw(img) + if level_select is "Level_One": + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select) + level_select = level_one[0] + inventory_block_index = level_one[1] + previous_level_select = level_one[2] + mouse = level_one[3] + if level_select is "Level_Two": + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select) + level_select = level_two[0] + inventory_block_index2 = level_two[1] + previous_level_select = level_two[2] + mouse = level_two[3] pygame.display.flip() pygame.quit() diff --git a/netherack.png b/netherack.png new file mode 100644 index 0000000000000000000000000000000000000000..ce0612c3d08f8f1b59989c6490d376db98c5dfd3 GIT binary patch literal 3536 zcmZ`+X*ARi7yb=H_GbDsBr#1wmLYpXwq|Ta$Y6#BA^Vb@A?uq#DkV$CBtqFrw#cA} zYGer`WGtm2%h-p6*Z<@D;XU`<`<(mS`<(mnIXBhH(nOF?oDTp1K{Hdd%^}MDn>-wc zm6NQDIs~w%p@ks;)ZF9$>&kW5!`)16EC3){1_0ud0pQOe6+Z_6VJZOd+XVnnxd0#< zL~gd$Jsfafzhr_24*rcoYT3g>=18cS1?I>!Cl7#-&2;Hl2LOR;Gqj3Hrivp34j*zv_ zfiX|z&caMOrthy$eb3un9A}lIy3>DI**r~HM%sqi5AU?H$VcOLY0ex5+069WW7YYh zFDgY6swS4b%C2fHN3`ji56TDrUiIMu6cHmyTvNu`OURthx%xXR9s9kOSnR`jTeKxC zou(MVc!Gr0hp@G@;zHR-gwSrR;A8-a1gvG)W1d5xPzYdv1{+j&Pie^_I1n80I`#qq zy|cvztvc$%GJn+8Vk!A5PLpFso!xze>brcd4wjdEn@(Vkve_V)wZBp4o)Ak)Z!V^q zXQqav&8gCUOMl9yiKe8yCu6aL>Ua8wr!*oR_3|%6ZrY#S+mr{;Kc}|0cXoEh{`?{O z`WixFLRV&f6nh$1Xf-qx!NoRrrCQd7IAU%_N7p;iyA+E^Aif(+vXPT>m8u&oCns)u zQEf}lP@N<;_io8TAj>~Zx!cW1;D>`F3)HSkyaBT|=Q1qJ3TALZ0dSgnCbtzr`m3Y{ zXC$EfzDF_>Eph#ACrC~^)Y8}6J%E8BaLi$mCArMf!T9qh1C871i z#$|~6yifEFnbfcw8(ZVVVPLXgD28YcQXzHpm(F9eHG2KSP!rnpo(Xk}$1>s7g62P( zf?8p6RsN6@ECn>D3zgkl!v^9JXJ#JA8TnY9Djy567B+t|hM(Z=&}^YKbI0$vC!#Tf zm0>8#&W*OV!KFlYkCVCuv>SJgv)zU0FB%?_-GP&#a8~I6XFM#3f9N2PDH{z(C z@jG1EUIF}VZ@FMkes^APO2W79%qtA1|ImLM5!gR} z8R{%?l6S^C+Z%yKBW%$KBN8~Cr~kp4xaiV?!Z!RhNp#v5LKWvU80kZYewodtkLb3- zfW1cjSb#+H4vV6se;iz0Ei%PC5A8%)OB}s@abeH$8vAjV+#{_F(%-F5(>pQcrWvRS z>$1k-`R|M2T!nt(-F}IMlMAP2-i?la3iaW@epZbyO>SwXOU1H!W#G?lQhyNzF5gE6 z%U9}B%W?32R2pJ7_87(#4A6 z@XV9MBN-R3zj|2*v(~?$4FWq_T|Emr>*K89^w$2!1N&iVivsp&3}LulwM&{e-K*pd zFT%}uB0vo6TVUBX=$aWtabzVl-4ucr8)QUVAIrlIL?)Qcb|E-k`H27BHN1ij_|6!Q zTd5{F^_F6=QJF(gAk(ZgQs?g4%Ki10x3#rjtQX55H_oa&i zMxqa%T%laHuP|63NN^Sf$=GNTgp~OgX8jtr7dM1~XxHbo*U;(G8VU}bive%rhc48L zK$&l-_{3INT#>;Gg9U@LRkk{*AiVcQC_-8q7EY*iqd9THoKo75+j#!(x*(Z0m*I@pJgx%$N2!8ut)-#CqIv3q0}T;%ZCE0Ujt4+0r05?@ zja-F;^L6!|Qb^^#U+bN@`M$o%k#VuHf!g5CqjB38-FgOBwY#jXD2B|tZHj%4mN*L!~@}-nt=Dq3xMM50tW4toEYk) zZ_5q}A}21AiV4a>9p248oUUBDYS0>Jd z96E9A&us9{_Ds>m@=^s30*zQJyx+jVyDQWz9+X~x=@sww7G!i_%x zHBbb|ByMf7d%UYf-msf~P+2;i-l`+M_l3xU&Q$5m+XeRJ&?cXdbz}6-C9k|%V8*!-B|kjbA>{QI=&rJlT>~Vso4F|Pqg% z`1>xP>;$2A?I8N^`&w!9;jWE`KbfpH{kc#}%7tB~^B$jpRe~Lw$EEJ>9c$8_wxrBS zfvbn6*!^9F7>}_N84Ez4bmxL&a9?t~%S7`WWGCPP^@yP~Zfc}9$!8&h-dlS$?NM4C z!_j$iZZo^A?BOT$p`Tt^mw;ZQyqs-9tXX8gt&`^08TX3qAF>|Qj{n?L89uBaY1BA5 z`EATRI*F-#V-Tm&iq~Ke@2}3v(|)hxqV@96_nASGyLe`PJbY*=M!6!BY6BQhDYwo& z;cqvlu#hm*pXKvCHXmp}@CwybpVp8XZ#wzrsbg%+nFZ%@&X{X6ZJMB< z0?w5a1yv!DO0Nm%+$O9#@So?Y_ypetOKt!P8<>y=b+%MX5nm=ZIOzt*E}Xb+iliV$yCbspB>80rD~uNx_R==A_7I|t6KJ&(I^<8H7_mVcmr%t93ww?EE&;u%H- z=cdM!@-6Fa_#h`b^VodtNpy%j1PlhlY8XV;IJVYw=>j77twoX5f~HbKJ_Ytcv9I1# zkpt18-Fi-hJyyhfDZ{MU>>eF}V~r0s zla9Rf`+a>Hvp+jf+|hkc#M(uG!+}W-L41uo3e?x%^}@#bb!@Y=xeqsDCeilo(V=Nl=~Nh)`W-@U3m4ao9W@Is*?2qJn6mUbw)(Jq_o*J z;WAm-Fl6fr1tVQuN0rk0wp6uWGvsLD+$e%eOmf)%PaX zLtuHQ3GgivBNgG+lTq}hO2f-P*O%$bX6tNZZcOf6%&)ib6TV-bihwZ$FqPaC^%_D!R3w;gO+{o4P}#h1VcXc^du&NNgN2dmn$R^ipKz) ziVp`eTh+u*wMUn&7feHdugwAE^gBD-b0pGNL%h=wBYk!Jt#O0we4vk7u;b|3H3z9TZ?K zEF~q0`V|(MbjuHS_eSlbb>kPEV!)i1MZ1L0-qu#QY+52R7oDK&TO!Gz?wSO7#<)+9eZU_+GiO3E4x#R@p&lr=V2?upR8`Jt zDXFL_sc74(sG!u;QEKOvR5Va3DkU*2!T%BX2fBOTi2DD6p;PuXhXV0`FI)}05gOqd m>;YK0dIy9eEitz6a5ba`^4vL-btA3AEx-(8iLN$sN&GKVCVo-? literal 0 HcmV?d00001 diff --git a/netherquartz.png b/netherquartz.png new file mode 100644 index 0000000000000000000000000000000000000000..1c8dece614f73e5aa324e8afd215b2f0e4c5a6e3 GIT binary patch literal 4012 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 iGtYhW{zu^L>+0zq^8W=j{S!xQ0bp!kp Date: Wed, 8 Mar 2017 01:26:31 -0500 Subject: [PATCH 66/83] 9 --- continuous Rectangle.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 0947f45..c7049f0 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -51,7 +51,7 @@ def __init__(self, num_rows=4, color=0): for row in range(num_rows): for column in range(int(size[0]/block_size)): if row == 3: - self.matrix[row+19][column] = 10 + self.matrix[row+19][column] = 9 else: self.matrix[row+19][column] = row+1 @@ -257,7 +257,7 @@ def add_to_inventory(self, mouse, field, player_x, player_y): player_x_grid = player_x//40 player_y_grid = player_y//40 block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if block_type != 10: + if block_type != 9: if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: if self.bin_list[block_type-1] < 64: if field.matrix[mouse[1]//40][mouse[0]//40] != 0: @@ -345,7 +345,7 @@ def level_two_map(): [1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0] , - [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0] , + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0] , [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] return matrix @@ -453,7 +453,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro screen.blit(dirt, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 3: screen.blit(stone, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 10: + if field.matrix[row_count][column_count] == 9: screen.blit(bedrock, (column_count*40, row_count*40)) inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) player.draw(amon_picture) From 59c32ea83a2317ce6773d8ec5a7d409633d5fba4 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 01:35:38 -0500 Subject: [PATCH 67/83] Nether --- continuous Rectangle.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 0947f45..5bd4519 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -457,7 +457,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro screen.blit(bedrock, (column_count*40, row_count*40)) inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) player.draw(amon_picture) - return [level_select, inventory_block_index, previous_level_select, mouse] + return [level_select, inventory_block_index, previous_level_select] #Control def main(): @@ -491,6 +491,7 @@ def main(): pygame.display.set_caption(level_select) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() + mouse_y = mouse[1] if level_select is "Menu": returned = menu(previous_level_select) level_select = returned[0] @@ -500,13 +501,11 @@ def main(): level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] - mouse = level_one[3] if level_select is "Level_Two": level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring) level_select = level_two[0] inventory_block_index2 = level_two[1] previous_level_select = level_two[2] - mouse = level_two[3] pygame.display.flip() pygame.quit() From 99f94e6c85802f7f03ea30b7522fbadb00053360 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 01:38:02 -0500 Subject: [PATCH 68/83] Removed Wall Jump --- continuous Rectangle.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 957103a..d437f7e 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -379,10 +379,8 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro #left if player.x <= 0: player.x = 0 - player.jump = 1 if player.x >= 1800: player.x = 1800 - player.jump = 1 if player.y >= 840: player.y = 840 player.velocity = 0 From 6a145450f995bf40ad609f16828ce04c2599c4b6 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 02:39:49 -0500 Subject: [PATCH 69/83] cool --- continuous Rectangle.py | 45 +++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index c7049f0..f4496d2 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -55,7 +55,7 @@ def __init__(self, num_rows=4, color=0): else: self.matrix[row+19][column] = row+1 - self. matrix[15][6] = 4 + self. matrix[18][15] = 4 self.matrix_print() #rectangle_color = color_matrix[1] @@ -323,30 +323,31 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) def level_two_map(): - matrix = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + matrix = [ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , - [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , - [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , + [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , + [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0] , [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ] return matrix From f3a83fa44e60860c036da49dc5c07759c61f48b1 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 02:44:31 -0500 Subject: [PATCH 70/83] Game --- colvin.png | Bin 0 -> 7495 bytes continuous Rectangle.py | 58 ++++++++++++++++++++++++++-------------- sean.png | Bin 0 -> 7876 bytes 3 files changed, 38 insertions(+), 20 deletions(-) create mode 100644 colvin.png create mode 100644 sean.png diff --git a/colvin.png b/colvin.png new file mode 100644 index 0000000000000000000000000000000000000000..b89661a13ef8fa3ed49433e13a4256d37f940cef GIT binary patch literal 7495 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 D`nQqQ literal 0 HcmV?d00001 diff --git a/continuous Rectangle.py b/continuous Rectangle.py index d437f7e..4cac251 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -76,7 +76,7 @@ def matrix_print(self): print(rows, ",") class Player(): - def __init__(self, x=40, y=700, width=40, height=80, color=GREEN, velocity=0, fall='on', left='off', right='off', jump=0): + def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall='on', left='off', right='off', jump=0): self.x = x self.y = y @@ -151,7 +151,7 @@ def player_in_grid(self): self.xgrid = self.x//block_size self.ygrid = self.y//block_size - def draw(self, amon_picture): + def draw(self, amon_picture, sean, colvin): if self.fall == 'on': self.velocity += self.acceleration_constant @@ -163,7 +163,13 @@ def draw(self, amon_picture): self.y = self.y + self.velocity #pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - screen.blit(amon_picture,(self.x,self.y)) + print(self.color) + if self.color == 0: + screen.blit(amon_picture,(self.x,self.y)) + if self.color == 1: + screen.blit(sean,(self.x,self.y)) + if self.color == 2: + screen.blit(colvin,(self.x,self.y)) def draw_shot(self): self.x = self.x + 10 @@ -216,17 +222,19 @@ def menu(previous_level_select): # player = Player() screen.fill(WHITE) text_list = [] - text1 = Text("Sean and Colvin's Game", 150, 50, 100, RED) - text2 = Text("Instructions:", 50, 250, 60, BLUE) - text3 = Text("-Press Left or Right to Move", 100, 350, 60, BLACK) - text4 = Text("-Press J to Jump", 100, 450, 60, BLACK) - text5 = Text("-Press Q to Quit", 100, 550, 60, BLACK) - text7 = Text("-Your Inventory is in the upper left. Cycle through which item to drop by pressing 1, 2, and 3", 100, 700, 30, BLACK) - text8 = Text("-Add items to that slot by pressing E, and drop them into the world by pressing R", 100, 800, 30, BLACK) - text9 = Text("-Which Block you will drop is shown by the \"Current Block\" space in your inventory", 100, 750, 30, BLACK) - #text6 = Text("Press R to Restart the Game", 100, 650, 60, RED) - text6 = Text("While In Game Press P to Return to Game", 100, 850, 60, RED) - text_add_list = [text1, text2, text3, text4, text4, text5, text6, text7, text8, text9] + text1 = Text("Bounce Bounce Play Time", 150, 50, 100, RED) + text2 = Text("Instructions:", 50, 200, 60, BLUE) + text3 = Text("-This is a rudimentary version of Minecraft. Use w, a, s, d to move.", 100, 300, 30, BLACK) + text4 = Text("-You can move around the world and change the blocks within it.", 100, 350, 30, BLACK) + text5 = Text("-Your inventory is in the upper left. Cycle through which item to drop with 1, 2, 3, and 4", 100, 400, 30, BLACK) + text6 = Text("-Use left click to pick up items and right click to drop them", 100, 450, 30, BLACK) + text7 = Text("-Which block you will drop is shown by the \"Current Block\" space in your inventory", 100, 500, 30, BLACK) + text8 = Text("-There are multiple worlds to choose from. Press 8 or 9 to enter a different world.", 100, 550, 30, BLACK) + text9 = Text("-Pause with P, and return to your previous world by pressing P again.", 100, 600, 30, BLACK) + text10 = Text("-Press Q to quit the program", 100, 650, 30, BLACK) + text11 = Text("-You can also change your character by pressing C", 100, 700, 30, BLACK) + text12 = Text("-Trampolines will make you jump extra high when you land on them", 100, 750, 30, BLACK) + text_add_list = [text1, text2, text3, text4, text5, text6, text7, text8, text9, text10, text11, text12] for texts in text_add_list: text_list.append(texts) for texts in text_list: @@ -350,7 +358,7 @@ def level_two_map(): return matrix -def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring): +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring, player_color, done, sean, colvin): level_variable = "open" player.fall = 'on' field.matrix_update(inventory_block_index) @@ -393,6 +401,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user hit q or closed + print("HELLO") done = True if event.type == pygame.KEYDOWN: @@ -403,10 +412,12 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro if event.key == pygame.K_p: level_select = "Menu" if event.key == pygame.K_c: + print(player_color, "C") player_color += 1 + print(player_color, "A") if player_color == 3: player_color = 0 - player.color = color_matrix[player_color] + player.color = player_color if event.key == pygame.K_o: field.matrix_print() @@ -454,8 +465,8 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedro if field.matrix[row_count][column_count] == 9: screen.blit(bedrock, (column_count*40, row_count*40)) inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) - player.draw(amon_picture) - return [level_select, inventory_block_index, previous_level_select] + player.draw(amon_picture, sean, colvin) + return [level_select, inventory_block_index, previous_level_select, player_color, done] #Control def main(): @@ -463,6 +474,7 @@ def main(): clock = pygame.time.Clock() previous_level_select = "unknown" player_color = 0 + player_color2 = 1 level_select = "Menu" done = False player = Player() @@ -484,6 +496,8 @@ def main(): netherquartz = pygame.image.load("netherquartz.png") bedrock = pygame.image.load("bedrock.png") spring = pygame.image.load("spring.png") + sean = pygame.image.load("sean.png") + colvin = pygame.image.load("colvin.png") ### CONTROL while not done: pygame.display.set_caption(level_select) @@ -495,15 +509,19 @@ def main(): level_select = returned[0] done = returned[1] if level_select is "Level_One": - level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring) + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] + player_color = level_one[3] + done = level_one[4] if level_select is "Level_Two": - level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring) + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) level_select = level_two[0] inventory_block_index2 = level_two[1] previous_level_select = level_two[2] + player_color = level_two[3] + done = level_two[4] pygame.display.flip() pygame.quit() diff --git a/sean.png b/sean.png new file mode 100644 index 0000000000000000000000000000000000000000..ecf6808346f32c1649c2c117b908e7cb5e5fbb24 GIT binary patch literal 7876 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≠C|{lJ zpQQf~+RGwkkE~OFZocn>Arbj@cJ22fIwH}R-&wlSz!1(GpuTR?UJ`@P1e$(mm^@=X|S|j+M3)Z*4tbU<9)&}yC#GW+P;oa*|+k)_0 z3&lRDiNghgW!V2iqFeejdCZQXwZ18Bn4%^_E2!4p5dmCM+o_ ziT|aLBRTyR-Q$CftIf=DX_Hy+H+L%hB%fbOP1W%gF~$}bSafxE^vf&pYr*NV+*!YC z4Wml7Jz_#cjenhu?R8ux$>siAL5E9q-C^cYzVQ;FoISG0o@1C4NoW}X63kwsIi>xw znvZnN=;CAWb+I{^%P?rab!$?5VR_kGeRT6=_Mq!_RO$eoQbnc6NXe|OFGff|THJRP z(AIvjfnM-_3jZDBx0TxdY3opNL8-gW+E?yrESotrTEy8iaLBetYswCP`37sc+YJa67uZ{GrdV~Ze!HB&-*VM2^74723kDsUKN+MyMyBRV z&X_4KDl9SSX!JXb;>J)R4n2dmJ_m0f&n=k#+v)5~|Efr%h>|&jp99m?hj* zcHi<(`EJMD=9*$BJH3~%x53x`Nk^yJrq`3#gYyw5a)XI;9HtwD_BRJfcxy?H9y53! zaE%S-jy#0<>13)_-SAldRSTWn43ETDs734J^~L9m9&~i`yNc&T_1yHi z!sYDAI1@x@2(f)plmYQ-`c{RE@!xIH*{jJ-h@;szx7Td9<-tsZIeI6gTmHE>i=N9; zYT1H2i*De4^0%?ciF@R_|GbL7E0k9V&y!A%8uLrJRN+{EXaIWLMEUUx^#2O$#_Mng zZD_c^f$~eJPv1U|qW4xlDhlcr?*x^7a#<-jgkP+1WF@jA((~Q-5=Q zY9ne~2F{H}+rxr4%>BO6jI~aPRs;`T$2+V{Ks|Ftn21KAvRInxd8^9 zQk`vnMV)Q$nQ6m$H6F5&9dut{&y1U?ID)SlT}*HKwQt3Y@fqyju1syY$AJsB8_jNR6@uBQ`pKrZ3(cWTU?wK#_7xj_NBI?BF#EoBr!ibk<8Y}fP>v;an}e8X z;yar{i_hxu`T2S0#ZoHG`hiwQ?PlXT;*}r`fVq$ELT^j5tIB^fW=kGqlQ&? zv(LOG@F-E>zXQAo!RRl^xIl=@qU?*J^b$Vge#0wyxyASrZ|q*HoKlDX-4QlhBZ`e# z=&K}i3Zxq6d?8JOY7@aDNbYjFZqr>=K4+K4&B?_FDm{#v$0;=f3!GhNYtQ=a|J>;? zqX3h)KtuCGE&54Tm?LRvRZxej$lQZSB>35hZkPz z_lfJ~#HxB`TPkzdwLQs(ww*QdM?S=^Vd2-~)tSk}S39VHpb>ge5{M-)yPk|7{;C2# z&Sns#F*J)4tk9w4dx|zGsnJ+Zrx_pT5e}t`*q6+sf`V|JVrt7I`9^KI`;si70GBzq zF>^G?#K=&B_9G=5Ti24$Hkte9V-%0Qpn9@-&%2=%^91o!PCIsJG>LO%_sv8Nf}X2^ z`b5ny?A}n?? zs&BLhaIB~dDK)o`$%~=dBr;;spRJp$dzZ96xAIqfrOUEGK(q)S7tQ`VtAQ^H%x9MD z2|&m`^(9bKh~zWV7l6glG9g(6aa8e8X~v>4uXvZBoe$FwT<49-MyT;1q_~N!vCKfE zax~}u59uNMpLS;%>qErU(rdM45t6+KZ3UZ{Z}g6p!Sb+sXIn^m5`6zNrYUlwAeii~L;4(q)8kMX{7+`uknlYNCAT3W%4AKtnf3U|@+NOj z+7}9M3emm3`CzweA0MBeE*0#m#-lnJUxTJG2qu119ZlU=kTyF6Nda{PzK={(E9=cZ zVDCqiTM+}wBkq9NvlOGYcNTAMrrkAtv%uOGOU22Y2V{oSR&cYPiSI;Jk!Trcbd8t) z7OwTH4=7%Oiq&Xf7nBb&TLB~KIeG(g-6`4kKzc?pAmKrPbA;zY9-1alsJWwj Date: Wed, 8 Mar 2017 14:20:01 -0500 Subject: [PATCH 71/83] with some comments --- continuous Rectangle.py | 64 ++++++++++++++++++++++++++--------------- 1 file changed, 41 insertions(+), 23 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 2a0282c..0000f4a 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -1,5 +1,4 @@ import pygame -from pygame.locals import* pygame.init() size = [1840, 920] @@ -18,6 +17,12 @@ ### Model class Rectangle(): + """Used when initializing block objects. These block objects are later put into the field matrix. + has atributes for: + x and y position - the upper-left pixel of each block + width and height of the block + color of block as an RGB value + """ def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): self.x = x self.y = y @@ -27,19 +32,28 @@ def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): #draws the rectangles that are dropped def draw_rectangle(self): + """Uses pygame to draw the rectangle on the screen + -filled solid with color + """ pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) def draw_with_outline(self): + """Uses pygame to draw the rectangle on the screen + -as a colored outline + """ pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) - def draw_shot(self): - self.x = self.x - self.y = self.y - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - class Field(): + """ Used when creating and storing the blocks in the field. + Contains following atributes: + blocks - a list of block objects + matrix - a matrix with each value equal to the block type in that position + - This is helpful because you don't need to iterate through every + block on the map to look for collisions + """ def __init__(self, num_rows=4, color=0): + """ initializing field using an algorithm""" self.blocks = [] self.matrix = [] inner = [] @@ -54,30 +68,33 @@ def __init__(self, num_rows=4, color=0): self.matrix[row+19][column] = 9 else: self.matrix[row+19][column] = row+1 - + # setting up the trmpoline self. matrix[18][15] = 4 - self.matrix_print() - - #rectangle_color = color_matrix[1] - #block_x = column*block_size - #block_y = size[1]-block_size*row - block_size - #block = Rectangle(block_x, block_y, - #block_size, block_size, rectangle_color) - #self.blocks.append(block) def matrix_update(self, block_type): + """Uses the block objects in the list of blocks to update the matrix used to detect collisions""" for block in self.blocks: self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type self.blocks.remove(block) def matrix_print(self): + """Prints the matrix in a format that is easy to read""" print("Matrix") for rows in self.matrix: print(rows, ",") class Player(): - def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall='on', left='off', right='off', jump=0): + """Contains Atributes and Methods regarding the player's position, + appearance, and motion. + """ + def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall='on', left='off', right='off', jump=0): + """The first 5 atributes are the same as the Rectangle class above. + velocity - change in y position for each time step. + acceleration_constant - change in velocity if falling + fall - whether the player should be falling + jump - whether the player is allowed to jump or not + """ self.x = x self.y = y self.width = width @@ -92,6 +109,9 @@ def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall=' def bottom_collision(self, field, next_y): + """ stops the player's downward movement if his vertical position is + colliding with a block.""" + """Also makes the player bounce if this block is a trmpoline""" self.jump = 0 block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] if self.x % 40 == 0: @@ -171,11 +191,6 @@ def draw(self, amon_picture, sean, colvin): if self.color == 2: screen.blit(colvin,(self.x,self.y)) - def draw_shot(self): - self.x = self.x + 10 - self.y = self.y - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - def jumps(self): self.velocity = -9 self.fall = 'on' @@ -359,8 +374,11 @@ def level_two_map(): return matrix -def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring, player_color, done, sean, colvin): - level_variable = "open" +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, + bedrock, amon_picture, inventory, inventory_block_index, + level_select, level, previous_level_select, spring, + player_color, done, sean, colvin): + player.fall = 'on' field.matrix_update(inventory_block_index) next_y = player.velocity From fe05f4d8e274186b0d943879d1c3bc45b707a46b Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 14:26:50 -0500 Subject: [PATCH 72/83] update --- continuous Rectangle.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 0000f4a..b80e03f 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -72,7 +72,8 @@ def __init__(self, num_rows=4, color=0): self. matrix[18][15] = 4 def matrix_update(self, block_type): - """Uses the block objects in the list of blocks to update the matrix used to detect collisions""" + """Uses the block objects in the list of blocks to update the matrix + used to detect collisions""" for block in self.blocks: self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type self.blocks.remove(block) @@ -88,7 +89,8 @@ class Player(): appearance, and motion. """ - def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall='on', left='off', right='off', jump=0): + def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, + fall='on', left='off', right='off', jump=0): """The first 5 atributes are the same as the Rectangle class above. velocity - change in y position for each time step. acceleration_constant - change in velocity if falling @@ -107,30 +109,32 @@ def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, fall=' self.acceleration_constant = .6 self.jump = jump - def bottom_collision(self, field, next_y): """ stops the player's downward movement if his vertical position is colliding with a block.""" """Also makes the player bounce if this block is a trmpoline""" self.jump = 0 block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] + block_below_right = field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] if self.x % 40 == 0: - if block_below !=0: + if block_below != 0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 if block_below == 4: self.super_jump() - elif block_below !=0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] !=0: + elif block_below != 0 or block_below_right != 0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 - if block_below == 4 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] == 4: + if block_below == 4 or block_below_right == 4: self.super_jump() def left_collision(self, field): + """Prohibits leftward movement if it would bring the player inside a + block or outside the screen.""" if self.x%40 == 0: if self.y%40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: @@ -145,6 +149,8 @@ def left_collision(self, field): return True def right_collision(self, field): + """Prohibits leftward movement if it would bring the player inside a + block or outside the screen.""" if self.x%40 == 0: if self.y%40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: From 5bbaf33211f6479347b0630aef10bc4be5b72d0c Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 14:40:39 -0500 Subject: [PATCH 73/83] COmment --- continuous Rectangle.py | 66 ++++++++++++++++++++++++++++------------- 1 file changed, 45 insertions(+), 21 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 0000f4a..acb662d 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -346,6 +346,7 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) def level_two_map(): + """Stores the map for the second level""" matrix = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , @@ -378,32 +379,38 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring, player_color, done, sean, colvin): - + """This is the main function of the program. It contains the controller for the program + user keystrokes and other actions are turned into actions in the game + by referencing other funtions and classes.""" player.fall = 'on' field.matrix_update(inventory_block_index) - next_y = player.velocity + next_y = player.velocity #how far the player will move on the next iteration + #finds where in the matrix the player is player.player_in_grid() - player.left_collision(field) + #top/bottom collisions player.top_collision(field) player.bottom_collision(field, next_y) previous_level_select = str(level) clock.tick(40) + + #move left/right keys = pygame.key.get_pressed() player.left = 'off' player.right = 'off' - + #move left. Allows for holding the key down. Left collisions if keys[pygame.K_a]: player_left_move = player.left_collision(field) if player_left_move is True: player.left = 'on' else: player.left = 'off' + #move right. Allows for holding the key down. Right collisions if keys[pygame.K_d]: player_right_move = player.right_collision(field) if player_right_move is True: player.right = 'on' - #left + #stops plyaer from moving out of screen to left, right, or bottom if player.x <= 0: player.x = 0 if player.x >= 1800: @@ -413,34 +420,38 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.velocity = 0 player.jump = 1 player.fall = 'off' + + #pick up block if mouse2[0] == 1: inventory.add_to_inventory(mouse, field, player.x, player.y) + #place block if mouse2[2] == 1: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - for event in pygame.event.get(): # User did something - - if event.type == pygame.QUIT: # If user hit q or closed - print("HELLO") + #possible actions start here + for event in pygame.event.get(): + #press teh x in the top left to quit + if event.type == pygame.QUIT: done = True + #Here begins all the possible actions dependent on keystrokes if event.type == pygame.KEYDOWN: + #jump function if event.key == pygame.K_w: if player.jump == 1: player.jumps() player.jump = 0 + #pause if event.key == pygame.K_p: level_select = "Menu" + #chance player character if event.key == pygame.K_c: - print(player_color, "C") player_color += 1 - print(player_color, "A") if player_color == 3: player_color = 0 player.color = player_color - if event.key == pygame.K_o: - field.matrix_print() # inventory + #cycles which block to place by pressing 1,2,3, and 4 if event.key == pygame.K_1: inventory_block_index = 1 if event.key == pygame.K_2: @@ -450,22 +461,24 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, if event.key == pygame.K_4: inventory_block_index = 4 + #Switches between levels if event.key == pygame.K_8: level_select = "Level_One" if event.key == pygame.K_9: level_select = "Level_Two" + #quit game if event.key == pygame.K_q: pygame.quit() return # View------------------------------------------------------------- + #prints the background screen.fill(WHITE) - # draw color matric and main rectangle - # for block in field.blocks: - # block.draw_with_outline() - + #This prints all of the blocks on the screen + #row and column counts are used to keep track of matrix row and column + #there is a for loop to run through each row and column row_count = -1 for row in field.matrix: column_count = -1 @@ -474,6 +487,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, column_count+=1 if field.matrix[row_count][column_count] != 0: if field.matrix[row_count][column_count] == 4: + #based on the number entry in the matrix, it prints a different block screen.blit(spring, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 1: screen.blit(grass, (column_count*40, row_count*40)) @@ -489,11 +503,13 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, #Control def main(): - #color_matrix = [BLACK, BLUE, GREEN, RED] + #how long between each cycle of the while loop clock = pygame.time.Clock() - previous_level_select = "unknown" + + #initializes player, field, and other variables for level one and two player_color = 0 - player_color2 = 1 + player_color2 = 0 + previous_level_select = "unknown" level_select = "Menu" done = False player = Player() @@ -506,6 +522,8 @@ def main(): inventory2 = Inventory(0, 0, 20, 40, 40) inventory_block_index = 1 inventory_block_index2 = 1 + + #loads all the pictures amon_picture = pygame.image.load('amon.png') grass = pygame.image.load("grass.png") stone = pygame.image.load("stone.png") @@ -519,28 +537,34 @@ def main(): colvin = pygame.image.load("colvin.png") ### CONTROL while not done: + #sets the caption to the name of the level pygame.display.set_caption(level_select) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() mouse_y = mouse[1] + #setting up the menu if level_select is "Menu": returned = menu(previous_level_select) level_select = returned[0] done = returned[1] + #setting up level one if level_select is "Level_One": level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) + #the variables in the main function can't be accessed from the main_movement function. They are level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] player_color = level_one[3] done = level_one[4] + #setting up level two if level_select is "Level_Two": level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) level_select = level_two[0] inventory_block_index2 = level_two[1] previous_level_select = level_two[2] - player_color = level_two[3] + player_color2 = level_two[3] done = level_two[4] + #prints the game on each iteration of the loop pygame.display.flip() pygame.quit() From 4007fd17a32709972046c8b295e3e5567fb4a5cc Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 15:11:16 -0500 Subject: [PATCH 74/83] More Comments --- continuous Rectangle.py | 87 ++++++++++++++++++++++++++++++----------- 1 file changed, 64 insertions(+), 23 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 2dac9d4..a1ffd64 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -220,14 +220,24 @@ def print_text(self): screen.blit(label, (self.x_pos, self.y_pos)) def menu(previous_level_select): + """This is the menu screen that is shown when you first start playing the + game. It gives brief instructions on what the game is. You can start + playing the game by pressing 8, 9, or P""" level_select = "Menu" done = False + #Looks for player input for event in pygame.event.get(): - if event.type == pygame.QUIT: + if event.type == pygame.QUIT: #quits done = True + #looks for a keystroke if event.type == pygame.KEYDOWN: + #quits when q is pressed if event.key == pygame.K_q: # If user hit q or closed") done = True + #whhich level to go to is selected here. + #p is used to go to the previous level. + #on the first iteration, this is "unknown:, so p takes you to level one + #8 or 9 also take you to level one or two if previous_level_select is "unknown": if event.key == pygame.K_8: level_select = "Level_One" @@ -236,11 +246,13 @@ def menu(previous_level_select): if event.key == pygame.K_p: level_select = "Level_One" else: + #After you have entered a level this takes you back to the previous + #level when you press P print("going previous", previous_level_select) if event.key == pygame.K_p: level_select = previous_level_select - #if event.key == pygame.K_r: - # player = Player() + + #Fill the screen white and print a bunch of text. screen.fill(WHITE) text_list = [] text1 = Text("Bounce Bounce Play Time", 150, 50, 100, RED) @@ -248,7 +260,7 @@ def menu(previous_level_select): text3 = Text("-This is a rudimentary version of Minecraft. Use w, a, s, d to move.", 100, 300, 30, BLACK) text4 = Text("-You can move around the world and change the blocks within it.", 100, 350, 30, BLACK) text5 = Text("-Your inventory is in the upper left. Cycle through which item to drop with 1, 2, 3, and 4", 100, 400, 30, BLACK) - text6 = Text("-Use left click to pick up items and right click to drop them", 100, 450, 30, BLACK) + text6 = Text("-Use left click to pick up items and right click to drop them. You have a limited range.", 100, 450, 30, BLACK) text7 = Text("-Which block you will drop is shown by the \"Current Block\" space in your inventory", 100, 500, 30, BLACK) text8 = Text("-There are multiple worlds to choose from. Press 8 or 9 to enter a different world.", 100, 550, 30, BLACK) text9 = Text("-Pause with P, and return to your previous world by pressing P again.", 100, 600, 30, BLACK) @@ -263,8 +275,12 @@ def menu(previous_level_select): return [level_select, done] class Inventory(): - def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_quantity, x_pos = 20, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0, 0] + """The inventory is used to pick up, place, and store blocks. The inventory + is shown in the upper left. The blocks you can place, and the number of + those blocks that you have are shown in the inventory. Additionally, the block + that you are currently placing is shown here.""" + def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width): + bin_list = [0, 0, 0, 0] #initializes you with 0 blocks of any kind bin_list_item = [BLACK, RED, BLACK, GREEN, BLUE] self.init_quantity = init_quantity self.x_pos = x_pos @@ -274,67 +290,92 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width):#, init_q self.bin_list = bin_list self.bin_list_item = bin_list_item - def update_bin_width(self, block_type): - if self.bin_list[block_type-1] > 9: - self.bin_width = 1.5*block_size - else: - self.bin_width = block_size + #def update_bin_width(self, block_type): + #if self.bin_list[block_type-1] > 9: + #self.bin_width = 1.5*block_size + #else: + #self.bin_width = block_size def add_to_inventory(self, mouse, field, player_x, player_y): + """This method picks up a block from the world when you left click. It + then increments the count of that block in your inventory by one""" + #finds where the mouse and player are in the field grid mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse[1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 + #finds what block type you picked up block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if block_type != 9: + if block_type != 9: #9 is beckrock, which cannot be mined + #implement a range in which you can pick up from if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: + #you can only hold a maximum of 64 of a certain item if self.bin_list[block_type-1] < 64: + #only adds if there is a block in that space if field.matrix[mouse[1]//40][mouse[0]//40] != 0: self.bin_list[block_type-1] += 1 + #sets that space on the field to empty field.matrix[mouse[1]//40][mouse[0]//40] = 0 - self.update_bin_width(block_type) def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): + """This function is used to place items in the word. The current block in the inventory + then removed from the inventory and placed in the world in the position of the mouse""" + #finds where the mouse is located in the field grid mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse [1] // 40 + #finds where the player is located in the field grid player_x_grid = player_x//40 player_y_grid = player_y //40 + #To prevent the player from dropping a block where he or she is standing + #many if loops were used. + #the first is based on if the player is directly over a block if player_x%40 == 0: + #in this case the block cannot be placed in either the top or bottom + #block of the player check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) if (check_top_player== False) and (check_bottom_player== False): - if field.matrix[mouse[1]//40][mouse[0]//40] == 0: - if self.bin_list[block_type-1] > 0: + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: #A block cannot be placed if another block already is in that spot + if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place + #The range in which you can place a block is a circle with radius 5 if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - self.bin_list[block_type-1] -= 1 + self.bin_list[block_type-1] -= 1 #subtract one from inventory + #place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) else: + #In this case the player is halway over a block, which means + #that the player spans 4 blocks, and you should not be able to + #place a block in any of these places check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) if (check_top_left_player == False) and (check_top_right_player == False): if (check_bottom_left_player== False) and (check_bottom_right_player== False): + #make sure a block isn't already in that position if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + #make sure you have at least one item in your inventor if self.bin_list[block_type-1] > 0: if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: - self.bin_list[block_type-1] -= 1 + self.bin_list[block_type-1] -= 1 #subtract one from inventory + #place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) - self.update_bin_width(block_type) def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): + """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() + #A list of all the images to print in the top left image_list = [grass, dirt, stone, spring] + #For loop to print the inventory for every item in the inventoryy for bin in range(len(self.bin_list)): - #rectangle = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height, self.bin_width, self.bin_height, self.bin_list_item[bin+1]) - #rectangle.draw_rectangle() + #checks what type of block and prints that type if bin+1 == 1: screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 2: @@ -343,12 +384,12 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 4: screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) - text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 40, WHITE) + #prints the number of items in the inventory in that slot + text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 30, WHITE) text.print_text() + #prints the current block and the text for it. text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) text2.print_text() - #current_block = Rectangle(self.x_pos, self.y_pos + bin*self.bin_height + 80, self.bin_width, self.bin_height, self.bin_list_item[current_block_index]) - #current_block.draw_rectangle() screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) def level_two_map(): From 13561f89e6490a4e1349af5edadb52ae149b227b Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 15:55:30 -0500 Subject: [PATCH 75/83] comment updates --- continuous Rectangle.py | 180 ++++++++++++++++++++++------------------ 1 file changed, 97 insertions(+), 83 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index a1ffd64..0063b79 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -165,19 +165,26 @@ def right_collision(self, field): return True def top_collision(self, field): + """ prohibits movement if the player is going upwards through a block. + Incorprorates a 50% bounce back velocity""" if self.x % 40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: self.y = (self.ygrid+1)*40 self.velocity = self.velocity * -.5 elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: self.velocity = self.velocity * -.5 - self.y = (self.ygrid+ 1)*40 + self.y = (self.ygrid+1)*40 def player_in_grid(self): + """Finds the matrix value that the player's position corresponds to + stores this in the new atributes self.xgrid and self.ygrid""" self.xgrid = self.x//block_size self.ygrid = self.y//block_size def draw(self, amon_picture, sean, colvin): + """ The actual printing of the player on the screen + This is where we excecute our movement if the player is supposed + to be moving or falling.""" if self.fall == 'on': self.velocity += self.acceleration_constant @@ -187,8 +194,10 @@ def draw(self, amon_picture, sean, colvin): if self.right == 'on': self.x += 4 + # update the y position self.y = self.y + self.velocity - #pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + # change-able skins integrated here print(self.color) if self.color == 0: screen.blit(amon_picture,(self.x,self.y)) @@ -198,15 +207,21 @@ def draw(self, amon_picture, sean, colvin): screen.blit(colvin,(self.x,self.y)) def jumps(self): - self.velocity = -9 + """regular jump function + triggered by the 'w' key """ + jump_strength = -9 + self.velocity = jump_strength self.fall = 'on' def super_jump(self): - self.velocity = -13 + """Extra high jump triggered by a bottom collision with a trampoline""" + jump_strength = -13 + self.velocity = jump_strength self.fall = 'on' class Text(): + """ Used when forming all of our text boxes - especially in the menu""" def __init__(self, text, x_pos, y_pos, size, color): self.text = text self.x_pos = x_pos @@ -215,6 +230,7 @@ def __init__(self, text, x_pos, y_pos, size, color): self.color = color def print_text(self): + """ A pygame pring function integrated into the Text class""" font = pygame.font.SysFont("monospace", self.size) label = font.render(self.text, 40, self.color) screen.blit(label, (self.x_pos, self.y_pos)) @@ -225,19 +241,19 @@ def menu(previous_level_select): playing the game by pressing 8, 9, or P""" level_select = "Menu" done = False - #Looks for player input + # Looks for player input for event in pygame.event.get(): - if event.type == pygame.QUIT: #quits + if event.type == pygame.QUIT: # quits done = True - #looks for a keystroke + # looks for a keystroke if event.type == pygame.KEYDOWN: - #quits when q is pressed + # quits when q is pressed if event.key == pygame.K_q: # If user hit q or closed") done = True - #whhich level to go to is selected here. - #p is used to go to the previous level. - #on the first iteration, this is "unknown:, so p takes you to level one - #8 or 9 also take you to level one or two + # whhich level to go to is selected here. + # p is used to go to the previous level. + # on the first iteration, this is "unknown:, so p takes you to level one + # 8 or 9 also take you to level one or two if previous_level_select is "unknown": if event.key == pygame.K_8: level_select = "Level_One" @@ -246,13 +262,13 @@ def menu(previous_level_select): if event.key == pygame.K_p: level_select = "Level_One" else: - #After you have entered a level this takes you back to the previous - #level when you press P + # After you have entered a level this takes you back to the previous + # level when you press P print("going previous", previous_level_select) if event.key == pygame.K_p: level_select = previous_level_select - #Fill the screen white and print a bunch of text. + # Fill the screen white and print a bunch of text. screen.fill(WHITE) text_list = [] text1 = Text("Bounce Bounce Play Time", 150, 50, 100, RED) @@ -290,78 +306,73 @@ def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width): self.bin_list = bin_list self.bin_list_item = bin_list_item - #def update_bin_width(self, block_type): - #if self.bin_list[block_type-1] > 9: - #self.bin_width = 1.5*block_size - #else: - #self.bin_width = block_size def add_to_inventory(self, mouse, field, player_x, player_y): """This method picks up a block from the world when you left click. It then increments the count of that block in your inventory by one""" - #finds where the mouse and player are in the field grid + # finds where the mouse and player are in the field grid mouse_x_grid = mouse[0] // 40 mouse_y_grid = mouse[1] // 40 player_x_grid = player_x//40 player_y_grid = player_y//40 - #finds what block type you picked up + # finds what block type you picked up block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if block_type != 9: #9 is beckrock, which cannot be mined - #implement a range in which you can pick up from + if block_type != 9: # 9 is beckrock, which cannot be mined + # implement a range in which you can pick up from if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - #you can only hold a maximum of 64 of a certain item + # you can only hold a maximum of 64 of a certain item if self.bin_list[block_type-1] < 64: - #only adds if there is a block in that space + # only adds if there is a block in that space if field.matrix[mouse[1]//40][mouse[0]//40] != 0: self.bin_list[block_type-1] += 1 - #sets that space on the field to empty + # sets that space on the field to empty field.matrix[mouse[1]//40][mouse[0]//40] = 0 def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): """This function is used to place items in the word. The current block in the inventory then removed from the inventory and placed in the world in the position of the mouse""" - #finds where the mouse is located in the field grid + # finds where the mouse is located in the field grid mouse_x_grid = mouse[0] // 40 - mouse_y_grid = mouse [1] // 40 - #finds where the player is located in the field grid + mouse_y_grid = mouse[1] // 40 + # finds where the player is located in the field grid player_x_grid = player_x//40 - player_y_grid = player_y //40 - #To prevent the player from dropping a block where he or she is standing - #many if loops were used. - #the first is based on if the player is directly over a block + player_y_grid = player_y//40 + # To prevent the player from dropping a block where he or she is standing + # many if loops were used. + # the first is based on if the player is directly over a block if player_x%40 == 0: - #in this case the block cannot be placed in either the top or bottom - #block of the player + # in this case the block cannot be placed in either the top or bottom + # block of the player check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) if (check_top_player== False) and (check_bottom_player== False): - if field.matrix[mouse[1]//40][mouse[0]//40] == 0: #A block cannot be placed if another block already is in that spot + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: # A block cannot be placed if another block already is in that spot if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place - #The range in which you can place a block is a circle with radius 5 + # T he range in which you can place a block is a circle with radius 5 if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - self.bin_list[block_type-1] -= 1 #subtract one from inventory - #place the block where your mouse is + self.bin_list[block_type-1] -= 1 # subtract one from inventory + # place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) else: - #In this case the player is halway over a block, which means - #that the player spans 4 blocks, and you should not be able to - #place a block in any of these places + # In this case the player is halway over a block, which means + # that the player spans 4 blocks, and you should not be able to + # place a block in any of these places check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) if (check_top_left_player == False) and (check_top_right_player == False): if (check_bottom_left_player== False) and (check_bottom_right_player== False): - #make sure a block isn't already in that position + # make sure a block isn't already in that position if field.matrix[mouse[1]//40][mouse[0]//40] == 0: - #make sure you have at least one item in your inventor + # make sure you have at least one item in your inventor if self.bin_list[block_type-1] > 0: if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: self.bin_list[block_type-1] -= 1 #subtract one from inventory - #place the block where your mouse is + # place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) @@ -371,11 +382,11 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) text.print_text() - #A list of all the images to print in the top left + # A list of all the images to print in the top left image_list = [grass, dirt, stone, spring] - #For loop to print the inventory for every item in the inventoryy + # For loop to print the inventory for every item in the inventoryy for bin in range(len(self.bin_list)): - #checks what type of block and prints that type + # checks what type of block and prints that type if bin+1 == 1: screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 2: @@ -384,10 +395,10 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) if bin+1 == 4: screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) - #prints the number of items in the inventory in that slot + # prints the number of items in the inventory in that slot text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 30, WHITE) text.print_text() - #prints the current block and the text for it. + # prints the current block and the text for it. text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) text2.print_text() screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) @@ -432,32 +443,32 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.fall = 'on' field.matrix_update(inventory_block_index) next_y = player.velocity #how far the player will move on the next iteration - #finds where in the matrix the player is + # finds where in the matrix the player is player.player_in_grid() - #top/bottom collisions + # top/bottom collisions player.top_collision(field) player.bottom_collision(field, next_y) previous_level_select = str(level) clock.tick(40) - #move left/right + # move left/right keys = pygame.key.get_pressed() player.left = 'off' player.right = 'off' - #move left. Allows for holding the key down. Left collisions + # move left. Allows for holding the key down. Left collisions if keys[pygame.K_a]: player_left_move = player.left_collision(field) if player_left_move is True: player.left = 'on' else: player.left = 'off' - #move right. Allows for holding the key down. Right collisions + # move right. Allows for holding the key down. Right collisions if keys[pygame.K_d]: player_right_move = player.right_collision(field) if player_right_move is True: player.right = 'on' - #stops plyaer from moving out of screen to left, right, or bottom + # stops plyaer from moving out of screen to left, right, or bottom if player.x <= 0: player.x = 0 if player.x >= 1800: @@ -468,29 +479,29 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.jump = 1 player.fall = 'off' - #pick up block + # pick up block if mouse2[0] == 1: inventory.add_to_inventory(mouse, field, player.x, player.y) - #place block + # place block if mouse2[2] == 1: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - #possible actions start here + # possible actions start here for event in pygame.event.get(): - #press teh x in the top left to quit + # press teh x in the top left to quit if event.type == pygame.QUIT: done = True - #Here begins all the possible actions dependent on keystrokes + # Here begins all the possible actions dependent on keystrokes if event.type == pygame.KEYDOWN: - #jump function + # jump function if event.key == pygame.K_w: if player.jump == 1: player.jumps() player.jump = 0 - #pause + # pause if event.key == pygame.K_p: level_select = "Menu" - #chance player character + # chance player character if event.key == pygame.K_c: player_color += 1 if player_color == 3: @@ -498,7 +509,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.color = player_color # inventory - #cycles which block to place by pressing 1,2,3, and 4 + # cycles which block to place by pressing 1,2,3, and 4 if event.key == pygame.K_1: inventory_block_index = 1 if event.key == pygame.K_2: @@ -508,24 +519,24 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, if event.key == pygame.K_4: inventory_block_index = 4 - #Switches between levels + # Switches between levels if event.key == pygame.K_8: level_select = "Level_One" if event.key == pygame.K_9: level_select = "Level_Two" - #quit game + # quit game if event.key == pygame.K_q: pygame.quit() return # View------------------------------------------------------------- - #prints the background + # prints the background screen.fill(WHITE) - #This prints all of the blocks on the screen - #row and column counts are used to keep track of matrix row and column - #there is a for loop to run through each row and column + # This prints all of the blocks on the screen + # row and column counts are used to keep track of matrix row and column + # there is a for loop to run through each row and column row_count = -1 for row in field.matrix: column_count = -1 @@ -550,10 +561,13 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, #Control def main(): - #how long between each cycle of the while loop + """ The actual call of the start of the program. + Main movement is referenced by this function. + """ + # how long between each cycle of the while loop clock = pygame.time.Clock() - #initializes player, field, and other variables for level one and two + # initializes player, field, and other variables for level one and two player_color = 0 player_color2 = 0 previous_level_select = "unknown" @@ -570,7 +584,7 @@ def main(): inventory_block_index = 1 inventory_block_index2 = 1 - #loads all the pictures + # loads all the pictures amon_picture = pygame.image.load('amon.png') grass = pygame.image.load("grass.png") stone = pygame.image.load("stone.png") @@ -582,28 +596,28 @@ def main(): spring = pygame.image.load("spring.png") sean = pygame.image.load("sean.png") colvin = pygame.image.load("colvin.png") -### CONTROL + + """CONTROL""" while not done: - #sets the caption to the name of the level + # sets the caption to the name of the level pygame.display.set_caption(level_select) mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() - mouse_y = mouse[1] - #setting up the menu + # setting up the menu if level_select is "Menu": returned = menu(previous_level_select) level_select = returned[0] done = returned[1] - #setting up level one + # setting up level one if level_select is "Level_One": level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) - #the variables in the main function can't be accessed from the main_movement function. They are + # the variables in the main function can't be accessed from the main_movement function. They are level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] player_color = level_one[3] done = level_one[4] - #setting up level two + # setting up level two if level_select is "Level_Two": level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) level_select = level_two[0] @@ -611,7 +625,7 @@ def main(): previous_level_select = level_two[2] player_color2 = level_two[3] done = level_two[4] - #prints the game on each iteration of the loop + # prints the game on each iteration of the loop pygame.display.flip() pygame.quit() From 62456f4b622fe329f2959eb75fbf281b631bfdb7 Mon Sep 17 00:00:00 2001 From: Colvchap Date: Wed, 8 Mar 2017 16:12:38 -0500 Subject: [PATCH 76/83] final comments and menu condition --- continuous Rectangle.py | 68 ++++++++++++++++++++++------------------- 1 file changed, 37 insertions(+), 31 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index 0063b79..d77f62c 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -1,5 +1,8 @@ import pygame +""" The following section of the script initializes a few global varables that +are helpful to reference at any point in the program.""" + pygame.init() size = [1840, 920] screen = pygame.display.set_mode(size) @@ -15,7 +18,9 @@ jump = 0 -### Model +""" Model ------------------------------------------------------------ """ + + class Rectangle(): """Used when initializing block objects. These block objects are later put into the field matrix. has atributes for: @@ -68,7 +73,7 @@ def __init__(self, num_rows=4, color=0): self.matrix[row+19][column] = 9 else: self.matrix[row+19][column] = row+1 - # setting up the trmpoline + # setting up the trampoline self. matrix[18][15] = 4 def matrix_update(self, block_type): @@ -235,6 +240,7 @@ def print_text(self): label = font.render(self.text, 40, self.color) screen.blit(label, (self.x_pos, self.y_pos)) + def menu(previous_level_select): """This is the menu screen that is shown when you first start playing the game. It gives brief instructions on what the game is. You can start @@ -243,14 +249,14 @@ def menu(previous_level_select): done = False # Looks for player input for event in pygame.event.get(): - if event.type == pygame.QUIT: # quits + if event.type == pygame.QUIT: # quits done = True # looks for a keystroke if event.type == pygame.KEYDOWN: # quits when q is pressed if event.key == pygame.K_q: # If user hit q or closed") done = True - # whhich level to go to is selected here. + # which level to go to is selected here. # p is used to go to the previous level. # on the first iteration, this is "unknown:, so p takes you to level one # 8 or 9 also take you to level one or two @@ -296,7 +302,7 @@ class Inventory(): those blocks that you have are shown in the inventory. Additionally, the block that you are currently placing is shown here.""" def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0, 0] #initializes you with 0 blocks of any kind + bin_list = [0, 0, 0, 0] # initializes you with 0 blocks of any kind bin_list_item = [BLACK, RED, BLACK, GREEN, BLUE] self.init_quantity = init_quantity self.x_pos = x_pos @@ -340,7 +346,7 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b # To prevent the player from dropping a block where he or she is standing # many if loops were used. # the first is based on if the player is directly over a block - if player_x%40 == 0: + if player_x % 40 == 0: # in this case the block cannot be placed in either the top or bottom # block of the player check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) @@ -396,7 +402,7 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc if bin+1 == 4: screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) # prints the number of items in the inventory in that slot - text = Text(str(self.bin_list[bin]), self.x_pos+ 5, self.y_pos + bin*self.bin_height, 30, WHITE) + text = Text(str(self.bin_list[bin]), self.x_pos+45, self.y_pos + bin*self.bin_height, 30, BLACK) text.print_text() # prints the current block and the text for it. text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) @@ -406,30 +412,30 @@ def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedroc def level_two_map(): """Stores the map for the second level""" matrix = [ - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , - [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , - [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , - [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0] , - [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0] , - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ] + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] return matrix From eda6679c989e6acfbb21a64f9544918fb91df8e8 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 17:20:49 -0500 Subject: [PATCH 77/83] Comment --- continuous Rectangle.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/continuous Rectangle.py b/continuous Rectangle.py index a1ffd64..db81fba 100644 --- a/continuous Rectangle.py +++ b/continuous Rectangle.py @@ -1,15 +1,16 @@ import pygame -pygame.init() -size = [1840, 920] +#initialize values used throughout the entire game +pygame.init() #initialize pygame +size = [1840, 920] #size of screen screen = pygame.display.set_mode(size) BLACK = ( 0, 0, 0) WHITE = (255, 255, 255) BLUE = ( 0, 0, 255) GREEN = ( 20, 255, 20) RED = (255, 0, 0) -block_size = 40 color_matrix = [BLACK, BLUE, GREEN, RED] +block_size = 40 #width/length of blocks in pixels text_x = 20 text_y = 200 jump = 0 From ff9ef590762adf58894a79d439d027c3fa1438af Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Wed, 8 Mar 2017 20:31:52 -0500 Subject: [PATCH 78/83] Interactive Programming Final --- NewPygame.py | 96 - PygameTest.py | 83 - README.md | 1 + RectangleClass.py | 134 -- World.py | 77 - Write-Up.rtf | 3853 +++++++++++++++++++++++++++++++++++++++ continuous Rectangle.py | 646 ------- interactive_color.py | 650 ++++++- 8 files changed, 4500 insertions(+), 1040 deletions(-) delete mode 100644 NewPygame.py delete mode 100644 PygameTest.py delete mode 100644 RectangleClass.py delete mode 100644 World.py create mode 100644 Write-Up.rtf delete mode 100644 continuous Rectangle.py diff --git a/NewPygame.py b/NewPygame.py deleted file mode 100644 index 29bd0e2..0000000 --- a/NewPygame.py +++ /dev/null @@ -1,96 +0,0 @@ -import pygame - -import pygame -from math import pi - -def main(): - # Initialize the game engine - pygame.init() - - # Define the colors we will use in RGB format - BLACK = ( 0, 0, 0) - WHITE = (255, 255, 255) - BLUE = ( 0, 0, 255) - GREEN = ( 0, 255, 0) - RED = (255, 0, 0) - - # Set the height and width of the screen - size = [400, 300] - screen = pygame.display.set_mode(size) - - pygame.display.set_caption("Example code for the draw module") - - #Loop until the user clicks the close button. - done = False - clock = pygame.time.Clock() - text_x = 150 - text_y = 20 - rectangle_x = 100 - rectangle_y = 100 - which_object = "Text" - while not done: - clock.tick(10) - - for event in pygame.event.get(): # User did something - if event.type == pygame.QUIT: # If user clicked close - done=True - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_t: - which_object = "Text" - if event.key == pygame.K_r: - which_object = "Rectangle" - if which_object == "Text": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_LEFT: - text_x +=-10 - if event.key == pygame.K_RIGHT: - text_x+=10 - if event.key == pygame.K_UP: - text_y += -10 - if event.key == pygame.K_DOWN: - text_y += 10 - if which_object == "Rectangle": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_LEFT: - rectangle_x +=-10 - if event.key == pygame.K_RIGHT: - rectangle_x+=10 - if event.key == pygame.K_UP: - rectangle_y += -10 - if event.key == pygame.K_DOWN: - rectangle_y += 10 - # All drawing code happens after the for loop and but - # inside the main while done==False loop. - - # Clear the screen and set the screen background - screen.fill(WHITE) - - # Draw on the screen a GREEN line from (0,0) to (50.75) - # 5 pixels wide. - myfont = pygame.font.SysFont("monospace", 15) - keys=pygame.key.get_pressed() - - text_color = (0, 0, 0) - text_position = (text_x, text_y) - label = myfont.render("Sean and Colvin's Game", 100, text_color) - screen.blit(label, (text_position)) - #pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) - #pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80]) - - #pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5) - #pygame.draw.arc(screen, RED, [210, 75, 150, 125], 3*pi/2, 2*pi, 2) - #pygame.draw.circle(screen, BLUE, [60, 250], 40) - pygame.draw.rect(screen, BLACK, [rectangle_x, rectangle_y, 50, 20]) - - pygame.display.flip() - - # Be IDLE friendly - pygame.quit() - - -if __name__ == '__main__': - main() diff --git a/PygameTest.py b/PygameTest.py deleted file mode 100644 index b0fc374..0000000 --- a/PygameTest.py +++ /dev/null @@ -1,83 +0,0 @@ -"""Animates a bouncing ball. - -Author : Oliver Steele -Course : Olin Software Design Fall 2016 -Date : 2016-10-24 -License: MIT LICENSE -""" - -import pygame - -BLACK = (0, 0, 0) -BLUE = (0, 0, 255) - - -class Ball(object): - def __init__(self): - self.radius = 20 - self.reset() - - def step(self): - self.y += self.dy - self.dy += .08 - if self.y > 480 - self.radius and self.dy > 0: - self.dy *= -1 - self.dy *= 0.99 - - def reset(self): - self.x = 320 - self.y = 240 - self.dy = 0 - - def contains_pt(self, pt): - return (self.x - pt[0]) ** 2 + (self.y - pt[1]) ** 2 < self.radius ** 2 - - -class BallView(object): - def __init__(self, model): - self.model = model - - def draw(self, surface): - model = self.model - pygame.draw.circle(surface, BLUE, (model.x, int(model.y)), model.radius) - - -class BallEnergyView(object): - def __init__(self, model): - self.model = model - - def draw(self, surface): - model = self.model - ke = model.dy ** 2 - pe = (480 - model.y) ** 2 - pygame.draw.line(surface, BLUE, (10, 480), (10, 480 - int(ke * 20)), 20) - pygame.draw.line(surface, BLUE, (40, 480), (40, 480 - int(pe / 10)), 20) - - -def main(): - pygame.init() - screen = pygame.display.set_mode((640, 480)) - ball = Ball() - ball_view = BallView(ball) - ball_energy_view = BallEnergyView(ball) - - running = True - while running: - for event in pygame.event.get(): - if event.type == pygame.MOUSEBUTTONDOWN: - if ball.contains_pt(pygame.mouse.get_pos()): - ball.reset() - if event.type == pygame.QUIT: - running = False - - ball.step() - - screen.fill(BLACK) - ball_view.draw(screen) - ball_energy_view.draw(screen) - - pygame.display.update() - - pygame.quit() -if __name__ == '__main__': - main() diff --git a/README.md b/README.md index 61ec120..04e025d 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ # InteractiveProgramming This is the base repo for the interactive programming project for Software Design, Spring 2016 at Olin College. +Use Interacive Color diff --git a/RectangleClass.py b/RectangleClass.py deleted file mode 100644 index 31aaa4c..0000000 --- a/RectangleClass.py +++ /dev/null @@ -1,134 +0,0 @@ -import pygame - -import pygame -from math import pi - -###################### -#Model -###################### - -pygame.init() -size = [400, 300] -screen = pygame.display.set_mode(size) -BLACK = ( 0, 0, 0) -WHITE = (255, 255, 255) -BLUE = ( 0, 0, 255) -GREEN = ( 0, 255, 0) -RED = (255, 0, 0) - -class Rectangle(): - def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): - self.x = x - self.y = y - self.width = width - self.height = height - self.color = color - def draw_rectangle(self): - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - def draw_shot(self): - self.x = self.x + 10 - self.y = self.y - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - -def main(): - # Initialize the game engine - pygame.init() - - # Define the colors we will use in RGB format - color_matrix = [BLACK, BLUE, GREEN, RED] - # Set the height and width of the screen - size = [400, 300] - screen = pygame.display.set_mode(size) - - pygame.display.set_caption("Example code for the draw module") - shoot_object_list = [] - #Loop until the user clicks the close button. - done = False - clock = pygame.time.Clock() - text_x = 150 - text_y = 20 - rectangles_x = 100 - rectangles_y = 100 - rectangle_list = [] - which_object = "Rectangle" - color = 0 - draw_rectangle = 0 - while not done: - clock.tick(10) - for event in pygame.event.get(): # User did something - if event.type == pygame.QUIT: # If user clicked close - done=True - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_c: - color+=1 - if color == 3: - color = 0 - if event.key == pygame.K_t: - which_object = "Text" - if event.key == pygame.K_r: - which_object = "Rectangle" - if which_object == "Text": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_a: - text_x +=-10 - if event.key == pygame.K_d: - text_x+=10 - if event.key == pygame.K_w: - text_y += -10 - if event.key == pygame.K_s: - text_y += 10 - if which_object == "Rectangle": - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - if event.key == pygame.K_a: - rectangles_x +=-10 - if event.key == pygame.K_d: - rectangles_x+=10 - if event.key == pygame.K_w: - rectangles_y += -10 - if event.key == pygame.K_s: - rectangles_y += 10 - if event.key == pygame.K_f: - draw_rectangle_x = rectangles_x - draw_rectangle_y = rectangles_y - rectangle_color = color_matrix[color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - shoot_object_list.append(rectangle) - if event.key == pygame.K_g: - draw_rectangle_x = rectangles_x - draw_rectangle_y = rectangles_y - rectangle_color = color_matrix[color] - rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) - rectangle_list.append(rectangle) - if event.key == pygame.K_z: - rectangle_list = [] - - - ########################## - #VIEW - ########################## - screen.fill(WHITE) - myfont = pygame.font.SysFont("monospace", 15) - keys=pygame.key.get_pressed() - text_color = (0, 0, 0) - text_position = (text_x, text_y) - label = myfont.render("Sean and Colvin's Game", 100, text_color) - screen.blit(label, (text_position)) - for rectangles in rectangle_list: - rectangles.draw_rectangle() - for shooters in shoot_object_list: - shooters.draw_shot() - pygame.draw.rect(screen, BLACK, [rectangles_x, rectangles_y, 50, 20]) - pygame.draw.rect(screen, color_matrix[color], [0, 0, 20, 40]) - - pygame.display.flip() - - # Be IDLE friendly - pygame.quit() - - -if __name__ == '__main__': - main() diff --git a/World.py b/World.py deleted file mode 100644 index 4bab518..0000000 --- a/World.py +++ /dev/null @@ -1,77 +0,0 @@ -import pygame -from math import pi - -pygame.init() -screen_x = 1840 -screen_y = 920 -block_size = 40 -size = [1840, 920] -screen = pygame.display.set_mode(size) -BLACK = ( 0, 0, 0) -WHITE = (255, 255, 255) -BLUE = ( 0, 0, 255) -GREEN = ( 0, 255, 0) -RED = (255, 0, 0) -color_matrix = [BLACK, BLUE, GREEN, RED] - - -class Block(): - def __init__(self, x=10, y=10, width=block_size, height=block_size, color=BLACK): - self.x = x - self.y = y - self.width = width - self.height = height - self.color = color - - # draws the rectangles that are dropped - def draw(self): - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, - self.height], 1) - - -class Field(): - def __init__(self, num_rows=3, color=0): - self.blocks = [] - - for z in range(num_rows): - for i in range(int(screen_x/block_size)): - rectangle_color = color_matrix[color] - block = Block(i*block_size, screen_y-block_size*z - block_size, - block_size, block_size, rectangle_color) - self.blocks.append(block) - - -# Control -def main(): - pygame.display.set_caption("Game!") - done = False - clock = pygame.time.Clock() - field = Field() - - # Main Loop - while not done: - clock.tick(40) - - for event in pygame.event.get(): - if event.type == pygame.QUIT: - done = True - if event.type == pygame.KEYDOWN: - if event.key == pygame.K_q: - done = True - - - # VIEW------------------------------------------------------------------- - screen.fill((150, 190, 255)) - - # draw rectangle objects - for block in field.blocks: - block.draw() - - # draw color matric and main rectangle - pygame.display.flip() - - pygame.quit() - - -if __name__ == '__main__': - main() diff --git a/Write-Up.rtf b/Write-Up.rtf new file mode 100644 index 0000000..92fc5de --- /dev/null +++ b/Write-Up.rtf @@ -0,0 +1,3853 @@ +{\rtf1\ansi\deff3\adeflang1025 +{\fonttbl{\f0\froman\fprq2\fcharset0 Times New Roman;}{\f1\froman\fprq2\fcharset2 Symbol;}{\f2\fswiss\fprq2\fcharset0 Arial;}{\f3\froman\fprq2\fcharset0 Liberation Serif{\*\falt Times New Roman};}{\f4\fswiss\fprq2\fcharset0 Liberation Sans{\*\falt Arial};}{\f5\fnil\fprq2\fcharset0 Noto Sans CJK SC Regular;}{\f6\fnil\fprq2\fcharset0 FreeSans;}{\f7\fswiss\fprq0\fcharset0 FreeSans;}} +{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;} +{\stylesheet{\s0\snext0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033 Normal;} +{\s15\sbasedon0\snext16\sb240\sa120\keepn\dbch\af5\dbch\af6\afs28\loch\f4\fs28 Heading;} +{\s16\sbasedon0\snext16\sl288\slmult1\sb0\sa140 Text Body;} +{\s17\sbasedon16\snext17\sl288\slmult1\sb0\sa140\dbch\af7 List;} +{\s18\sbasedon0\snext18\sb120\sa120\noline\i\dbch\af7\afs24\ai\fs24 Caption;} +{\s19\sbasedon0\snext19\noline\dbch\af7 Index;} +}{\*\generator LibreOffice/5.1.6.2$Linux_X86_64 LibreOffice_project/10m0$Build-2}{\info{\creatim\yr2017\mo3\dy8\hr17\min40}{\revtim\yr2017\mo3\dy8\hr20\min27}{\printim\yr0\mo0\dy0\hr0\min0}}\deftab709 +\viewscale100 +{\*\pgdsctbl +{\pgdsc0\pgdscuse451\pgwsxn12240\pghsxn15840\marglsxn1134\margrsxn1134\margtsxn1134\margbsxn1134\pgdscnxt0 Default Style;}} +\formshade\paperh15840\paperw12240\margl1134\margr1134\margt1134\margb1134\sectd\sbknone\sectunlocked1\pgndec\pgwsxn12240\pghsxn15840\marglsxn1134\margrsxn1134\margtsxn1134\margbsxn1134\ftnbj\ftnstart1\ftnrstcont\ftnnar\aenddoc\aftnrstcont\aftnstart1\aftnnrlc +{\*\ftnsep\chftnsep}\pgndec\pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +Project Overview: } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +\tab This project is a rudimentary version of Minecraft. While the game does not include tools or crafting, the game copies the more simplistic aspects of Minecraft. The player can move around, pick up and put down blocks, }{\rtlch \ltrch\loch +jump, and cycle between two different worlds. This game is also in 2D instead of 3D.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +Results: } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +\tab We accomplished what we set out to do. Our game is a simplistic version of Minecraft. When the game starts, it opens into a menu. This menu was an important part of the project because it made the game feel more complete. Once the player enters the game the player is a rectangle that is two blocks tall and one block wide sitting on a field of blocks. }{\rtlch \ltrch\loch +The player can move left and right with the A and D keys, as well as jump using W. }{\rtlch \ltrch\loch +The blocks can be picked up with the left mouse click, and put down with a right mouse click, }{\rtlch \ltrch\loch +just so long as they\u8217\'92re within reach of the player}{\rtlch \ltrch\loch +. When blocks are added, they go into the respective slot of the inventory in the top left of the program. The player can also cycle through which type of block they want to place. } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +\tab }{\rtlch \ltrch\loch +It is also very easy to switch between worlds in the game we created. Switching between the worlds is a fun way to mix up the play experience. By pressing 8 or 9 the player can cycle between these world to make a slightly different game experience. The ability to move between the menu screen, world one, and world two, allows for a more complex game experience that seems like a real video game.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +\tab }{\rtlch \ltrch\loch +The code could easily be altered } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +\tab Lastly, we added some features that Minecraft does not have to make the game more interesting. For example, we added a trampoline, which makes the player bounce up and down whenever they are standing on it. In addition to this, you can change what your character looks like }{\rtlch \ltrch\loch +just by }{\rtlch \ltrch\loch +pressing C, }{\rtlch \ltrch\loch +which}{\rtlch \ltrch\loch + cycles between three characters.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +Menu:} +\par \shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbxcolumn\shpbxignore\shpleft0\pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch +{\*\flymaincnt5\flyanchor0\flycntnt}{\shp{\*\shpinst\shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbottom5135\shpbxcolumn\shpbxignore\shpleft0\shpright9972{\sp{\sn shapeType}{\sv 75}}{\sp{\sn wzDescription}{\sv }}{\sp{\sn wzName}{\sv }}{\sp{\sn pib}{\sv {\pict\picscalex36\picscaley36\piccropl0\piccropr0\piccropt0\piccropb0\picw1837\pich946\picwgoal27555\pichgoal14190\pngblip +89504e470d0a1a0a0000000d494844520000072d000003b20802000000419bde450001729e49444154789cecdd077c14c5dbc0f1492195debb5401418a0d458a +a0a274a423a288150b08027fb05014518ad255408a884a574010549a204545449a887444e9bd8594f7996cdecb71498ebbbddb2be1f7fde413367b5b666767e7 +661e6677c39bd5af1f9b27264b78585858a8020000000000000078434242e2d5abf167cf5ddab2637f788efc5943424212e213aec6c5fb3b6100000000000000 +9049848686444484e7ca117b6b85e2e18989490909446001000000000000c09b12129312ae2466090fcb96353afcea5582b00000000000000060892b71f1e1e1 +61e1494949fe4e0900000000000000645a898989cee2b0f2d1f90b972e5fba72353e5e160d0d0dcd121e1e1d13191b131512e2eca55ea6570400000000000080 +4c263e3e21c338ecc54b97cf9eb9f040e982754b142c9d335bb6c8f07357e2ff3e7d7ec5de7f97eff92f7b8eacd1d19119ad78e6cc8552a54b952a592267ce5c +91911157aec49d3e7d7acfdebd7b77efc991f18a00000000000000902985a71b863d77ee623695f8dec3554b468727c55f55974fa94b49d943426e8b09bbbd4a +d196650b0e5cbde35c7c42d6ac3169574c52210d1b36888d8d898f8fbf7a352e2eee4a484848b66c596fbfad5ab97237af5af9637cfcc5b42b02000000000000 +406695ce78d84b97ae644b4a18755fb9ac091713cea6f316afe261e1236b97edb6f2af8b972e474745daaf98a4421eac7f7f5262e2c58b171cd68a8bbb92253c +ecc1faf5be5bbadc6145274e5f0c3f7be270920a2d5d203a3e22d69899a4c24f1c3b7ee1725c6896c8d205b2c78584b871c400000000000000e05b8e7158f9f3 +dcb9f383ef2d1573e94c62423a4158436c58f8ebb715e9b6766f64449690e430a8ac78f6dcf9fbefaf7b352e2e212121ddb5e2e3e3c3c2c2eeb9e7cee5cb57d9 +5674e2cca5f0a4321d678e2b1faa4e2f19f0daca93e7e322629354f8a9e371b7bd32b65bd52ceaf0dceeaf7f1f993b1ba15800000000000000012b3cf1da38ec +c58b97ea14cc5a2cec4ac2a5cbf2e7a584a40317e3cb65cb627cbaf3dcd5e231e1d1613ae879535474ed0231bf9ebb1c1d1365ac58b468d1c8c8c8b8b83827fb +4b4848888a8a2e5aa4f0a953278d159d88bf7a3557e19cc92ff6ca59bfc33ddf0c5a1d9337f1545c447ce15aedab26272947a16c2a292e31212134f2ecb94b97 +2f9cbd9a901412169e3336347bd66c092121894991a74f1d9724c527241f6668588e98f05cd9b3c687845c4d883df5dffe38155a2a5f645c44d653e7e22f9c3d +159a25b244fe5899692e370100000000000020ad70756d1cf6ca95abb5f244275c38a712f598d6fd1712fbef38f35ad96cb7e608df72267ef0ae73032be4b839 +36394c192f4b46ac397ed678ef96ac58a850c12b572e2726263adfe5952b89050b15faf7bfffaeffc2aeab09d90b67332643cb36695262dd0f272fc59d4bbaad +f3fdf98db9b1f9726749fa2f31f4e4a9b8d20fb6ebd8e8ced239c312ce1efcf5bbd9d316fd199533cf89f311f59ee959ff96a2857246e9445ff877e3f7b3a62e +dc1e9a35ffe94b85facf18504e9d5ef27a9f1947ae64aff7bf4f1f2dac0ecdeaf6c6f290dc59ddcf4900000000000000489fe37309e2e3e34b84c7275ebe68c4 +67cb668bed57b3fc5babff6c5b307ce67ff1afdd5bae6cfcf1c44bc9cf7e0d092991253a3e3ec1d882ac1813137df56a7cda07ce3a0809498c8d8db2ade84452 +6252b6dcd17ae2c2d590d89cf55a57fb6ae886f87cf26f844a389f1096354cc5e48d0dd9783abe449bd70634ccaf54c2b9d3e7637316abdeaa47f1c8b7defaea +506252b98a7794291221dbb87af96a96a8d842b737ef96e742dfa1cb4fa8b0a2767bba66b7d74d1800000000000000b82eedf361556cc2e5c42b9752fe8ebb5c +2e26ae63a522e37e3ff8f4ad452a5e3a9c70f19c6de1ac21a1898929514bf91512a2ae5ebd6a7cb47efdcf697776f7dd771913919111b6159d484a8acc9d550f +63fd77f957ff3ed8e6f64a4dea15d8b2bd51fd624aedf9ea9bcb2ddadd121a9b2756c55fadd6b1417ea58e2fecdf6fdace2b59ab3e35ba4f8d42f5ea179837e9 +f4ff1fc68677ba0ddb9ee5ceae43fe573dba44cd4aa1dfad4a0abb6657d7ee97382c00000000000000af097708398684849c8d8bcf9194687b5ec196a3a73ffb +e7dc73558b7fb9ed50f1c209956353173d13171f1a9ab2a0ac78f1e2e59090942066bdfbeba5ddd9d933678c252f5cb86c5bd19990a89c31fadf8bfffc3677f9 +83b7372cd8b063ebdb2b66539737cd5975f0de464a4547e78a0e0b8bae78937e626dde26033f6c625b37b640fe28b5f352eab6b24526edd97244552fa1b2e689 +0d493a61b79f6b5292e442c200000000000000c0658ee361c3c242779fbf5a2d225125e9c7bceeba14f2dee1f0d7eebce996907325efb869f02ffbde281c5f36 +da88bc86eebe181f1696c5d882ac78f6ecd9ac59638d3f4f9d3c99d12e434242ce9d3b1f161676dd61a7892191b9f4abbc122f9c3dbb67e9b7bb1b3e5aba72ad +ac4a9df8fe9b3fce2655baac547464f698d090cbe1c90fac3db7e9fb9f0e5ef9ff95af1e3b167acd9057d96ffc9584e4a9301d2f4e4c4cde7d7844969010c741 +c1046201000000000000784d78e2b531c72c59c2579f8eaf5a204925e89065b16c5907562f56f2c23ff117ce968fcd3eb07ac982a70f26c59d4f5e3564f51915 +9e25650bb2e27f478e968ab92921794527c2c2c28e1c396a5bd189a4d0a81c3a0e1b77e16a52c8e99fe7fed2a2f79df2f7fe05df1e4c0829702139e41a9d3d2a +7edf8e7f54d5122a36fb99dfe77fb5f34c820a8dcd5b38fc4c4258b6908c371e9a70f6e805553e366bb95bf2c6edfcd77eb7d74d1800000000000000b8ce713c +6c4444f8ba73218d2f8594084b5249891157ce9738bd3721f9c55c09674f95b81a9778e5725262820a09dd7b3174dd85b0acd952c6c3ca8aa74f9d3a9f2f4f64 +64a493f1a4c98f2fb874ead4996cd962aeff7cd8d0a8982cf26ffce5ab2a7b96842d7316accf5a3572f7829fcf268626265c4a7e146d54f6a8d053ebbf58d5e0 +b53a394bb7ea33a955fcd5c4f02ca1eae0177d062dbb664cae7e82ad5d4292128facd878be76edac45dabc3dbde9e584a828bb2589c302000000000000f01ac7 +38ac88888cfce048fca08257b3a944159f90101f67fb28e1c259fd4f48c8b9a4b0f78f84474645d8072d23232376efde5ba66ce9d090d0744399212121894989 +b24c54541657a29d2111b111fadff8b8ab49d161972f9ff975e43bdf458427658dc9a1cec71b71d8c86c1131a1e7b74d1ef4d63f2ddbd5bfede6bc915942d5e5 +53070e5e0e0b5521d73ef7d55e52eeaca1bb3e7d7f62628796f796c91d1515aaae9e3ff6efeedf0f278525108705000000000000e045e9c461c3c3c3ce2444bf +feafea96e75ca9f0e460a76d99103da274cfd588512762ce66898a0cbfe619afb2626242e2aebf76172d5a24323252d9855a439257bc7225eed0a143a1617a49 +57629d91493b5e6ff764bc0a299223f472587494ba14953d5ae627a8abb1594356f57beafbf8c4ac5121d131b13149093b7f98deef9b89f1c90f7d0d0d0dcd11 +951416151bab8e8e78fc49398622d94323a3c2ce6dfaa855bb1321616185b247c6275d898a4c5c3e79f8771f5f4979d35868487484ca1a73fd81ba0000000000 +0000e0baf074438e5922b29c0b0ded773cbc7ac4c57b222f978ab89a2d24f15c52e8eeb8f07597a37ebe1a93253222223c9d7565c590f884fdfb0fc4c6c464cd +96353a3a2a34342c3131e1e2a5cbe7cf9dbf78f1624464962ce9ad98ae2cea42965c5965e292721cceaa545cd66c31c654827ee0407c6c64a88a8cb55f223149 +85aa8bd9ecb69035cb1595fce7e5e43f43d5d56cb159546c16fbb5e289c102000000000000f0aa74c6c31ac2c242a363a27ebd9a65c3f9ac898989c971d090d0 +d0d0b0f0b0a8e8b0909010272bc6c4445eb91a77f1e8318715a3a3239dac08000000000000009952b8721a158d080f53f293d6f562a9a6570400000000000080 +4c263c91c028000000000000005829c3e7120000000000000000bc82382c00000000000000588b382c00000000000000582b7ce5aab5fe4e0300000000000000 +6466e1fe4e00000000000000006472c46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac461010000 +00000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101 +000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac4 +6101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c0 +5ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac461010000000000 +00c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000 +000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac4610100 +0000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac461 +01000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05a +c46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000 +c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac4610100000000 +0000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac46101000000000000c05ac4610100f0b79327555c9c1bcbe7cfaf +42432d4b0dfce1d42975e54a869f72c601000080e0471c160000ff99364d75efaee3b06ef9f75f55b0a0350982cf7df6992e03274e385b86330e000000043fe2 +b00000f84f8f1e6e076191c95c37080b0000002053200e0b0080ffc4c41083bbd15106000000801b0371580000fc67e2443d2476d72e75f5aabf93023f993449 +9781bffe72ef19c100000000820d71d8cc62c912d5bbb7eec53979cb870911112a3656152aa44a9552d5aaa95ab554edda2a32d29bbb0000d765bebaeea187d4 +b66d2e2d1912627152e0270f3ea8b66c49673e671c000000c85c88c366169d3beb9778785d5c9cfe39754a6ddfaebef946cfc9964db56dabba7655b7deeafddd +018073d4750000000080e0441c36b3484cf4d18ece9d539f7ca26fa26cd346bdffbe2a52c447fb0500455d07000000000856c461338b51a3d44b2fa9e3c77db4 +bba4243573a65abc584d98a0dab5f3d14e0180ba0e00000000109c88c366166ddbea9f53a71c9f9958a850eaf41f7fa87cf9dcdbecf9f37a9b478faa5f7f55eb +d6a955abd4e5cba99f9e3ba7dab7d79b1d3cd883a40380cba8eb0000000000c189386ce6922b97b34ff3e553050b9adc72a346faf7c9936aca143d1eede0c1d4 +8fde7d57072c3ef8c0e49601c05dd475000000008060431c16eec89d5bbdfaaa7aee39f5da6b6adcb8d407358e18a1ca96555dbaf8357100e025d47500000000 +006f230e0bf765cdaa468f56f5eae9a725da6e0deed143cf2957ceaf290300efa1ae0300000000780f715898d5bcb95ab040dfc31b1fafffbc7c59f5eeade6cf +f777b200c0aba8eb0000000000de401c161ea85f5ff5e9a3060d4af973e142f5d75feae69bfd9a2600f036ea3a0000000080c788c3c233fdfaa9cf3e53fbf7eb +e9a424f5f9e76ae0407fa70900bc8dba0e00000000e019e2b0f04c962ceab1c7d43befa4fcb96c19b109009910751d00000000c033c461e1b1c68d5363135bb6 +f86ebf478faa5dbbd49e3dead42975e1821ea1161bab72e450254baa3265549122be4bc90de2bfffd4f6ed3ac3cf9e55972ee9acce9b57e5cba76ebf5de5cce9 +efc4a5f1efbf6af76eb56f5f4af1888f57d1d1fab54b52306eba49bf642922c2df49b423a9fdfb6fb577af3a7d5aa73631511766496df1e2aa440955bab40a0b +f37712e1bfba2e180569fd1c5cf5060000008060431c161e93dea9cdd9b3baef2afd6d8b5cb9a2befd567dfdb55abd5af7f09d285c58d5aca99a3451cd9aa96c +d9ac4acf8d40f279fc78fd9ea23fff4c7f81d05055ad9a7ae001d5a5cb3585c1f74e9dd26f4f5ab448ad5ba7fef9c7d9921111aa72659de6c68d558d1a2a24c4 +5749b473ee9c7ecca864ec4f3fa943879c2d9935abbaeb2e75fffdaa756b55b6acafd287347c59d705a320ad9f83abde0000000010cc88c3c26379f35ef3e7e5 +cb96c4260e1f562347aa0913d49933ae2e3f6b96fe898a528f3eaadf6f5eae9c1792b178b1ded4ae5d2a2e2ec365fefd57152ce8f696972ed55bdeb953c7329c +33b77d317fbeeadb578ff64a37f169377bec987af555f5c5172a21c1d9661313d5c68dfae7fdf755bb76fa319abe8f15fef28bdefbbc79eaea559796971cf8f5 +57fdf3de7b7ab4e933cfe82072f6eca90b2c5ba69e7a4a5dbca8468fd607e55ddbb6a91123f40346e56271c5f9f36af972fdf3faebaa7a757d525ab46084ac1f +f8a6ae0b4601523fbb2bb8ea0d5748997cf659fd3d75e2844bcb4747ab4a95d49831ba6201000000603de2b0f0d8a953a9d32121face53efba7041bfa6fc830f +9c853e9d907ee9e4c96aca14d5a993ee3ce7cfef51629e7e5ac72badd0b9b38e4d58ea99677468d545f3e7eb249d3ce9c6f6e3e3d5f4e9eaabaf74affec9274d +24d08c5dbb548f1eea9b6fcc6f61f76ed5a78f1a3a54ff7ee515fd185021db34dec8d4bdbb37e329728a5f7b4d4d9ba66fd33667c306d5a68dbae516356a941e +97075fb2baae0b4601553fbb2eb8ea0dd749ddf2d9676e2c7fe9920e4677edaa2b1600000000d6230e0b8ffdf147ea74e1c22adcab85eac71ff5bb710e1e4cff +53d95da952fa776cac0e8b5cb8a01f4a28dd6359de21ce257f4a57ffabaff42df66dda984f4f62a2f975fdb5651b2352e08a8103f58f431e4644a89b6fd6cf76 +cc9143e7f68913eaf8717df625dbedc99f9d3bab152bd4a4496eecd10449def0e1ea8d37d20f00c9ae4b96d43fb972e9e271f5aabe91fccc191d25d9bb379d30 +e8c9937a50def4e9ba9cdc769b1e986cf8ef3fbd9657226ed3a6a9975ed28f234857f1e23ab5050baa9818fda8874b9774613e70403f37366dd9d8be5d3df8a0 +7ae209356e1c43327dc7d2ba2e18055afdec8aa0ab37dc62ee7bc407df3e0000000092ddf0dd48784e3acf36356a7873cbefbeabde7cd3f1a6f8e868d5b0a16a +d952d5a9a37bf8e93a7142ad59a31f53283fa74fa7ce97e9b66d758870cc1893319451a37428edf87133eb3a2749922d1f39e2fd2ddb8c1eadefa2753e24563a +e4cf3faf264e4c9d1312a21f86f8f4d3faf9a469437ef1f1fa2edd2fbfd45157fb80ec679fe9bbe9e7ccd121452b9c39a34fe5d2a58ef32b5450ad5aa9871ed2 +6f0f8b8a4a7f5d49d8962d7addb973d5d6add77cf4c71fba0c8f1d7bcdd3218c97927942b6f6cc33e98c53cb9953479d1a35d2cfcacc9d3bfd7525577ffe593f +7673c60cc780d7a79faaf5ebf598be32653c4a1e5c645d5d178c02b07ebeaee0aa374c78ec31fdc8e9254bdc18715fbcb81a32c4ca340100000048451c169e39 +724407836c5ab7f6ce66a56fdfa5cb35d140217ddaeedd75b0324f9eebac2e0b346ba67fa4633c6992ee64dadff2fff1c77a70d3ecd96606124a1f5e7e4e9d72 +7c8a6ba1426e6fca41ab56fae7f4e9f49f19eaf9f645cb96fac73ef10e9b4d4cd4432ca74f4f9df3f0c36ad830fd00c18c8487abbbefd63ffdfbebe7964e9d9a +fad1575fe9c7d15ad1c3ffe71fd5a081e30bebebd7d73708d7ad7bfdd5b36655f7dca37f060cd08f6a7df75d1de2b485938c98a9174986376daa034ff66eba49 +3fa0e0f1c7330cfad848299583929ff7ded321d7b7dfd6816f9b9d3bd5bdf7ea28ed6db77933cd48cba2ba2e18056cfdec5c70d51be64822172fd6437da5dad9 +b449b56f7f4da4bb74693573a62a5224754e74348fd7000000007c89382c3c9094a4c74eda4641162ba69a37f7c266131355c78e7a88a53d99337cb8db4f0f94 +9e7cd7aefa36f9b7ded2ef63b1dd7df9edb7ba43be74a9ee859a902b9799b55c9133a7555bb67192f8175e480dc2ca621327eab8ad8b72e7d677e6d6a9a347ce +da621372ca9a36d581422f3a7a54074d76ed4a9d53b4a88edd346a64666b152bea43eed74f8790162ff6561a539d3dab07d9fdf24bea9c2c5974dce7b5d7ae1f +8175101aaa33537ea64e553d7ba6be874732e48107749cf7965bbc966c38b0a8ae0b46815f3fa72bb8ea0d0f4544e8ffad69d74e8fe1b5a95d5bbf91ecba5172 +0000000056220e0b0ffcef7ffac6529b0f3ef0cef3405f7cf19a4ebef4d53ff9c4a3779e64cdaadfa6221dfbf6ed536ffc5fbd5adf122ee9e7bdf38637dfd4f9 +6c28554a7dffbdfeedae4e9df450ace79e4bf93331510f925dbfde6b89bc70410fd1b50fa6346ca8eff7cfe8a67e17dd7cb35ab4483f9bb26b5793af1b4a577c +bc0e9bda07610b17d6cf6ab8e71e8f362b99fcc003baf4ae5b9732e7d4299d2d3fffac1f2f0b2b5854d705a360ac9f83abdef0dcd8b1fad561f68f8c78f2499d +ce1bb6d0020000000183382c4cb97c598f9d9c322575ce638fe9dbea3df7d1477a8c924d8102baa37bfbed5ed872ddba3a6e25bdf1bffe4a99f3cd377a40d33b +ef7861e399802d087bd34d6ad52a3d58cc9c679fd581575bd9d8b04167bb8791479b2e5df4cdb6369d3bab0913bc16497fee3955a2848e9c7a2ba4d2a387ce49 +9b62c5f4b32f4b97f6c296e5ec2c5ba69a34d1bf0d070fea674a2c59a29fe70b2fb2aeae0b46415a3f0757bde189c4443d4477f4e8d439a1a1fa110abd7bfb2f +4d0000000052118785fbe6cfd701a63d7b52e7d4ae9d1ac5f3847495a50f699337af8e5b55a8e0852d1b4a96542b57ea7722d9122f1dd4fbeed3af9e8721776e +7d3bb0e920ac417275ce1c75ee5cca9fb36679270e3b7dfa35afba6adf5e973aef861d1f7a480f257bf6592f6ceadb6ff5eb866c6eba4917662981de121dad03 +55cd9aa9efbe4b99231392f8975ff6da2e605d5d178c82b47e0eae7ac313172ee8a35bb830754e6cacfafc735d4b00000000080cc461e1b2f3e775706dd224c7 +370e356ca8e747467abafdc444fd9e13db2ba4a2a27424cb8b9d7c43a1423a5c75e79dfa566ef5ff8f7ddcb6cded8775664aa1a13a665aae9ca7db2950403f58 +d6f6ceae952b3ddda04a7ed179cf9ea97fca1994ed5b31f6530ae19429a9b7fc9b73f1a21e82671311a15f62eec520ac410aed575fe93774eddc9932a75f3ff5 +e8a33c02d25356d775c12848ebe7e0aa373c71f8b06adcf89a61bf458bea986cd5aa7e4b12000000803488c3de488e1d7363e1ab57750f567efef947fdf69bda +b851ad5daba34bf64243d5ebafabfefdbd7383e784097a2f36a347ab3beef0c266d32a5d5abff7bc69d3943ff7ecd16f9879e30d4bf6155cfaf553f7dfef9d4d +356f9e1a87fdf34f1d4ff130f6f1eebba9cf8e8c89d16f2a8f88f068834ebcf492a7f19471e3f43bdf6d060d52952b7b98a8f449564c9fae871bc7c7eb3f4f9f +568307eb571edde002bcae0b46415a3f0757bd61dae6cd3a087be850ea9c3befd4a3b90b15f24f7a00000000648038ec8dc4bb91a02a5574b0e9de7bbdb3b5ab +577587d9e68107f4f022eb3469a2870d7ef145ca9f2346e8b79a64cd6ae11e035fddbafa555dde52a952eaf4e5cbfa1905d9b39bdfda9933fac194367dfb9a79 +8798ebeebbef9a3fdd8d20cbf1da47426bd4d02f2bb3ce1d77a8d75ed36f9c377cf2891a304065cb66e11e035f20d775c12848ebe7e0aa374c5bbc58b56dab07 +71dbb46ead63d9d1d13e4a00000000009711878529c58beb708f17c743cd98a10e1c48990e0bd3cfdab3daf0e16ade3c1d3213274feac391aefe8d6cfc783de8 +cf5b1cc6615dbae4511cf6d34fd5d9b329d379f35a1bd614850beb5bfb4f9c48f933470ef7569f3f3f75089e4a1e65ecc58c4d9764c8c891295924bf3ffb4cbf +5a0a5ee1f5ba2e180569fd1c5cf586391f7ea8ba76550909a973de7843ffaf0cefeb030000000212715898227df23bef54d5abeb1e60bb765e0833d9ee61176d +da78e111a5d755a8907aea293dcccdf0d967377a1cd6bb23286362aef93329c9a3ad7df965ea74972ebe18e7d5aa950e4c8b7bee71fbd9949f7f9e3a5da58a7e +878fd5b267574f3fad3ef820e5cf397388c37a8dd7ebba6014a4f57370d51bee4a4c4cf90f189bc848fd50e30e1dacdd2f000000000f10878507366cd05dbe21 +43f42dab0d1b9adfced1a3d7bccac9fe0547967aeeb9d47efe6fbfa9ddbbf5a30911680e1fd625cda663475fec74c4087d0bf3b9736e0734af5e55cb97a7fed9 +a38777d395a16edd749a8d78f78f3fead71ce5cae5a35ddf08bc55d705a320ad9f83abde70d7850bfad10d0b16a4cec99f5f7dfdb58eff020000000860c4616f +24fffeab0a167475e1c4447d4fe8952bfa9e50e987fff38fdab143bfb7faa79fae791988f8e30fd5a8917e20ddf8f126433fd2c997dd198a1553356b9ad98809 +b7deaa2a56d4076558be9c386c205ab3267538ad9cafb2657db1d3e868d5bbb799157ffd5587480ca1a1fad2f08de2c575e66cddaaa71312d4faf5aa41031fed +3a00056c5d178c82b47e0eae7ac32d52bc1b37d6b1699b4a95d4c285aa4409cb770d000000c033c4619181d0507d6bb9fce4cae5d8fbddb54bcd9dab6fbe3682 +3e86d9b375e847e6df79a7dbfb920eb34dbd7a3e7db09decced6cf976458faf2199863ff0a729fc5804cdbb22575faf6dbf5f3227d460ab3ed92dcb0e1868ec3 +bac597755d300ad2fa39b8ea0dd7fdf1870ec21e3c983aa76143fd00df1bfcd57c0000004090200e0bf7952dabfaf4d13fcb96a9d75f4fbdf7537a86f7dfafdf +ddec6ea7f7cf3f53a7efbedb6be974458d1a6acc9894e91d3b7cba6bb868e7ced4e9db6ff75f3a5cb37b77eab414e6fffef3ddaeab54499da6307b85d7ebba60 +14a4f57370d51b2e5ab2443f9ff7dcb9d439d1d1fab56904610100008020411c161eb8ff7e3d5e69d428d5ab978a8fd773a47ff8f0c37ab058a54a6e6ce7efbf +53a76fbed9cb8974ce7e77f6c940e0d8bb3775ba5429ffa5c335f681d7316352a3483eb66f9f7ff69b5979abae0b46415a3f0757bde18a8f3f568306e9a78ed8 +bb744917ce952bf5934900000000043ce2b0f04c48887e8d75e9d2aa654bfd862295fcfe9076edd42fbfb8f172ea932753a70b17f67e229d28562c75fad429dd +c50d0bf36902705dc78ea54efbb87898607b38ac7ffdf38fbf5390e978a5ae0b46415a3f0757bde18a810353a7a534da9e7ebb77afbaef3eb56285bae926bfa4 +0b00000080eb88c3c21b9a34511327aa4e9d52fedcb64d0d1daafaf7777575fbd0556cac7793761d59b35ef3e7f9f32a470e9f2600d7655f3c6262fc970ed718 +8325fd4e4a32ace0615d178c82b47e0eae7ac32d254beac713f7edab962e4d99630bc5f2aa2e00000020b0118785973cf184ee047efa69ca9fa347ab575f75ec +4567c4fec52fb6313ebe9125cb357f0648100df6e2e252a7c303becaf271a02a23172ffa3b05999727755d300ad2fa39b8ea0dd7dd7db79a3f5fe5cfafbefe5a +356f9e1a8addb74f876257ae24140b00000004b24cd43981df0d1daae6cc49198574f2a49a354b75eeecd28ab1b1eaf4e994691f8fe373d85d8004d1602f3a3a +75685be08717edc7eb0d1ca8faf5f35f526019d3755d300ad2fa39b8ea0d17b569a3ff03202a4a4fcbeff9f3752876c992944ff7ef5775eae8506cc9927e4c23 +000000002788c3c27bf2e7d77dc2cf3f4ff9f3fbef5d8d4de4ce9ddacf3f7448dd728b15a94bdfd1a3a9d3111129fd5b0494ac5953e329f68faa0c4cf68f68dc +b2c57fe980954cd775c12848ebe7e0aa375cd1bbb77aefbd6b86274746a68c8ab585620f1c48794041e678351900000090e910878557b56e9d1a9bf8e92757d7 +2a5d5aedd99332fdd75faa7e7def272c233b77a64ed3710d4c458aa8234752a6a59c54afeed7d45c8ffd1bded7adf35f3a603173755d300ad2fa39b8ea0d5774 +ef7e4d10d66084621f79447dfb6dca1c2314bb7225df680000004000220e0bafaa542975fabfff5c5dab7c793da0ccb076ad7ae9252fa7ca89f5eb53a7ed2368 +081ca54babdf7e4b99deb245b56fefd7d45ccf9d77a64efff38fdab14355a8e0bfd4c032e6eaba6014a4f57370d51b9e888c545f7d754d28f6e0c19407144826 +000000000824c461e155850ba74e5fbdaaef66cd99f3fa6bdd7baf1a3326657af9729598a84243ad485d3a7ef82175ba460d1fed146ea95245cd9e9d32bd668d +5f93e282a24575ec63f7ee943fe7cc516fbee9d704c11ae6eaba6014a4f57370d51b1e4a1b8a3d7428e5010565caf8356500000000ae411c165ee5f03a1417bb +eb75eae8db2d8d37711f39a2962d530f3ee8fdb4a5f5f7dfeae79f53ffac5bd7173b85bbeebd37757add3a75fcb8ca9bd77fa97141d3a66ac48894e9cf3e536f +bc91ceddc40876e6eaba6014a4f573d0d51b1e3242b12d5aa8c58b53e618a1d8952b09c5020000008183382cbcea9f7f52a72322f49b525c51b0a0aa5d5bad5a +95f2e7d8b13eeae77ff861eaf44d375d73473902c73df7a8ecd9d5d9b37a3a3e5ecd9ca95e7cd1df6972aa63c7d438ecae5d29ef34472663aeae0b46415a3f07 +5dbde1b9c848356fde35a15829a5c6030aca96f56bca00000000a4200e0bafb21fbe54a68c1b63c41e7f3cb59fbf70a1fafd7755b5aa7793e6e8bfffd4c71fa7 +fed9b1238316035464a48e634e9b96f2e7c891aa4b97801e7e58ad9a7e29d0860d297f0e18a047c80672826182e9ba2e180563fd1c74f5865718a1d8962dd5a2 +4529730e1f4e7940010f40070000000200715878d58c19a9d3f6b7855ed7a38faad75f4f79dd4d52921eb8b4668db581d1575e51972ea54c4745793a542a3c5c +0fb932d826bc65c70e2f6f30e83cfd746a3ce5efbfd5e4c97a4e207be30dd5a449caf4e6cd6afc781d03426662baae0b46415a3f075dbde11591916aeedcf443 +b1e5caf935650000000088c3c28b366ed43d3d1b5b1cca15d2d3eedd5bf5e891f2e7dab5face6edb9f5e376b96be4dd5e6f9e7f5bdb79ec893473f39d170f4a8 +7e5993b76cdba6ead5f3dad68254ad5aeaeebb535f9edeb7af6ad64ce5cbe78b5d6fd9a2befc52dd7187bedbd7758d1beb34af5e9df267af5eea8107b83538f3 +f0a4ae0b46415a3f075dbde12db60714d842b1fffeab1fb04b2816000000f037e2b0f092c444f5dc73fab7a14811d5a0817b5b78e925f5c9276afbf6943ffff7 +3fdd89ad5ddb9b89346cddaa9e7a2af54fe9e1f7efefe936a56f6f8bc3eed8a16ebbcdd30d1a366e540f3facdf308377de51f7df9f322d19d2a1835ab2c4f2bb +8c274fd603f12e5fd6d3b2bb871e7263ddf1e3f5bddb71717afac2051d1359b346e5c861493ae14b9ed775c12848ebe7a0ab37bc2522229d50ac312ab67c793f +a4070000004032e2b0f086a4243d6469e3c6d439afbfae6fd5774b962c6ae244ddb14f48d07fc6c7ebb14bd269f4ee8308fffe5bd5afafce9f4f9d3376acca99 +d3d3cd962ba7c307866fbed1bd7dcfcd9aa53a754abd39f70657af9e6adb367594dcf7dfabae5df5b9b38814c2575f55a346a5ced9b5cbbd784a850a6af060d5 +b367ca9f523c9a37d7319198186fa6d3c1ead53a5856b9b2eade3df33f0ad32fbc52d705a320ad9f83aedef0222314dbb2a5fe4a32fcf79f1e15bb7cb9ae9d00 +000000f8c30dd07b84d5a4e7d9ad9beea2dbdc71877af659339baa51430f5fead327e5cfd3a7f5dddc0b17ea375f7bc5e6cdaa51233d2cc846522edd54cf3df8 +a07e249f41babe7bf7aa9225cd6f2d2e4ef5eba7860ed5411fd88c1dab7efa491d3a94f2e7b8713a36f4c107de7f4ee55f7fe908f8ba75a9734a94d06f0a72d7 +abafea7ba2e7cc49f973e54a1d639a3f5f3fc5c2eb2e5dd2778edb024cb20b3904789717ebba6014a4f573d0d51b5e141191f2acd8b4a1d85b6ef167c2000000 +801b1571587866ff7ef5d863fa866b9b9c39d5e79fabb030931becdd5bf7c6bffc32e5cf1327f45da51f7da49e78c2d3a4ce99a33a7756e7cea5cea95f5f0d1f +eee9660d0f3da47bf546d8342e4e0fb95ab0c0643fff8f3ff4dbc925136ceebc53fdf28b77d219d4f2e6d52f47aa572fe5667f95fc0ef44387d4a4492a7b76ef +ece2f2653d966de0c06b86211728a0befdd6e423053efd54073e6c17c84f3fe9c8ddecd9fab717cd9faf1f41bb6b57ea9c6ddbbcb97d280beaba60148cf57330 +d61b5e9436147be4484a28b66245bfa60c000000b81111878559870febdeecc71f5fd3738e8ad2dde99b6f36bfd990101dba3a7b36f5a976d2b3edd449776865 +77e6ded672fcb80e1f4c9972cdcc5ab5d4575f79ed86e2122554ebd6fa490206e9f1f6e9a3860c716f23fffda7060cd0d181f8f8d4994d9ae820426cac77d219 +eceebd57c780dab449b9395a25876f366e541326e8a1799e888b535f7ca19f4479e0c035f3cb95538b17ab52a54c6e36264697e4071f543fff9c3267df3e3d7e +b0674ff5c61b9e9e56c90429c31f7c70cd103c21a5ba5d3b8fb60c7b16d575c12848ebe7a0ab37bccb08c5b66aa5072f1b8e1ed5816942b100000080cf1187cd +5c4e9d5257ae64f8e9b1631e6d5c3a9cd26196fedb2fbfe8c702ae59a3ae5ebd6681ac597567cff65214d3b264d1db79e2896b5e992dd3d2adedde5dbf2ec6f5 +175e9f3ca9c76a0d1fae6fa1b5d7a0818e997af7499d0306e864dbfaf94387eabc92bd47455d7fddeddbd5871faaa953f50b9d6c4242f48dedefbde738e0ce76 +1ec3c355eedcee3d06d44909b12f1eb2e53c79cc8ce7cd68fbb68dcbc995347b7247708b166afa745d3c6ca3dbf6eed581ce860d75ecbb562db737b86b97dee0 +f8f1a96f5ab369d952bf72c7c34173b2faf2e53a062405d8101faf4fab6cb9674ffd4a22c910776ddca8a3f3f263bbdbda26224287b46ebfdda33407becc51d7 +4905652bc6ee72eb18a554982866e90ad2fa3928ea0de7a5dab473e7f437cbd8b17afbb601dd52bcebd6d591d99b6e4a5d52d26ce903ac010000801b1e71d8cc +e2b3cf741ff8c40967cb54ae6c61024a97d69df32a55bcb3b5c8483d7ca964493da4d4f68c54e94cbef5968e6f366aa487f6d4aead0a174e7f75e961ae5aa5d3 +239dcc8b171d3f7df1453d74cbebafd6a95041bdfbae1ed8653375aa0ee2bcf1868ec1a5ed93c7c5e947102c59a207cf6ed8e0f869eedc7adc59e3c6e9ecc8fe +3c4645e96720b832f076fa745d428e1fcf700187e29135ab7afb6df5ca2bd7dfb2c17909b4df78b66c7acbddbab9bae5b4dab553f9f3eb3270ea54eaccc58bf5 +4fc58a7afe430fa9db6ed3a52823fffda7f37cdd3a3daccff682357b3972e871a69d3b9b4fa4bdd858fd9c8afffd4f6fd3569ea5944a69e9d74f47829a34d1e5 +d9c9e8b9ab57753a7ffb4d3f64f6871f74fad375c71dfa3d5ddeba0c0353e6a8ebe4ea96a3b02fc0ee72f718a50a92eb4eaa0bcf0563fdac02bbde70a5549bb0 +76ad7ecacdeedde97f7aec98bafb6ec79952ae66cfbee1067a03000000be421c36b3b0a20be722e930bff0827e35bc77ef9d0f09d161cdfbeed32398ec071c5d +beac3bf0c64bb1a49f5fa68c2a5448ef5a96bf7041f793a5cf79f060fadbcc9d5bbf63a7450b6fa6d35eaf5eba733e6d5aea9cfdfbd533cfa82e5df4335e8b16 +d5bdf4f3e7f55dbd7bf7eae154f6cf1fb0d7bebd1a31423f5ef0ba2437860ed52f70bfee6bc19c0761d39274cae148ca9d44251cb6ef62093c774e8f039534bb +b8e574d5aba79f53d9b1a30ee8d8dbb64dff0c1ca80700962aa59f1721273d26462526eae2210775e8907e32c09933196e590a52870e3ac0945114c99cb0303d +eeefc107f500d87ffe499d2f6770de3cfd2372e5d2692e564c87aaa3a2f4c8b88b1775ace4c0019d6c8721990e6ebd55bdf69a7e35bcd7df3e146832475df7ea +ab1e05614d906a4776fadc731e5d7736c1583fab00ae372c2ad5fdfb671884cdc81f7fa861c3ae79191d00000000ef210e9b594847d7f7b109d9e9a38fea989a +7563671e7a48eddca93b93e3c6a513b53c7c58ffb8223454c743df79c79257d5db9b3c593f2471e8d06b664aca1d9ee099917bee518306e96081ebe4d0b265bb +fe6226ee36cd92c58d7710c9f65d2f8111115e78bb51b162fa7effa953d5ebafa7333e342e4efdf9a7fe715d64a48e63f6eaa52a55f2346d1931caf3e0c13ace +6eff4a1fc3a953fa8103f2e33a497393263ab876fffd993f026bc81c755d74b477b6e316b9eebc3bce34e8ea6715a8f5865bf5a75b9bf5d95a000000005c401c +36b39834498f7592dea3e9a70d5e5748881ea3973bb71e2e54ad9aaa53473dfcb02f3a6c3972e8db545f794587aea64cb9e65539ae90143efeb8ce9c3265ac49 +dfb5c2c2f490a87beed1ddf2bfff7675adf0709d995dbbeaf1926eedab7871fddc83bc79afbfb05b2544b65cb2a48e08bb1eb591edf7e8a1fefaeb3adb970d4a +f9716bcb4e8486ea5b80dbb6d50563f4683dc4d80439d89a35f5b323dab7d72352ad161babe34d529ec78dd30f97cce80903ce65c9a283f5eddae9c183de7ae7 +7bb0c81c75ddc489fa7a912ac2f930676f910223c72205cff3ffff70105cf5b32100eb0d17eb4f77c99791f1bf3b699fff90ae6cd9f441f5edebcd3400000000 +b0431c36b378e0017dbb652656a2841a354abfdde89b6fd4fcf96af56ac7f7533b285244bf7aa56953fde3dd0726b8a279733d4af1cb2ff5a8ab9f7ed2f7eaa6 +4b3abd75eaa8faf555ebd6d779d5b8ed218ca6595d421e7c506dd962e1f69d90f3fbd24bfae7e79ff50dfecb97abdf7fbf4e782b22423fcfb7460d9dff92333e +1885e7205f3efd62b77efdf4f35ebffa4a9767c9bdc44467abe4cca907dc49a99634d7ace987521d2032475df7f0c3fa27d308aefad91050f58645f567f9f2ea +c71fbdbf59000000006611874550898ed6214bf951c9af4cd9b54b3f68f5d429fd08bfa4243db42a674e3d90b36c59ddcff7afb030f5d863fae7ca15ddcf3f78 +50df767ae68c3e846cd9f4b362a5875ca2841e99056fb9eb2efda3921f52f9d75fba6c1c3eac9fed287fcae9909ccf954b3fbdb178713df8ce8a1701b94bce7e +bd7a298fa190744a9af7ecd16f3192f22c6996f22c45c5282de5cae9570c01812c88ea677b41576f00000000085af42810b40a16d43fb56af93b1dd713191904 +89cc64a2a2f45bbfdd7da1bc7f65cdaadfd52e3f4026102cf5b3bd60ac37000000000415e2b000000000000000602de2b000000000000000602de2b000000000 +000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b00000 +0000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b0 +00000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602d +e2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000 +602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b00000000000 +0000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b0000000 +00000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000 +000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2 +b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b00000000000000060 +2de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b0000000000000 +00602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000 +000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b00000 +0000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b000000000000000602de2b00032b4664dca44850a2a4f +1ebf26050000000000209811870590a15ab5522666cf56ad5af93529000000000000c18c382c00000000000000588b382c00000000000000582b68e2b0ad5bab +afbf56f1f166d62d52442d58a06ebbcddb690a421d3baa254bd4ca95aa62457f27052ee07c010000000000640e4113875dbedc641056fcf38fdaba9538ac366b +968a8bd399495c2f2870be0000000000003287a089c3fef0835ab52afd506caf5efa77e3c6aa4e9d743e0d0951c58aa9962dad4d5eb0888bd3bfaf5cf1773ae0 +1ace17000000000040e6103471d86ad5f44fba8c386c9d3aaa674f5fa608c8fc9292fc9d020000000000804c2168e2b00000000000000010a488c30200000000 +000080b588c30200000000000080b588c30200000000000080b588c3ba6ad52a357dba5ab74eeddfafdf5f9f3bb72a554ad5adab3a755265cb7a61fb89896af5 +6ab570a1faed37f5d75feacc1975f9b2ca9143efa87c7955a3866ad85055aeec851d05a0e3c7f5b1efdead33a1644955af9eca93c7df6972cdbfffaaa54bf5cf +9f7faaa347f5814447abbc7955f1e2aa766d5d3ce4774888bf5319c0ce9d533ffca0162d529b37ab2347741ec6c6aa020554b162eafefb55a346aa6245efef94 +6b190000000000f81e71d8142d5beab8c9d5aba973860d533d7bea897fff559d3bab254bae59fec811fdb36e9d7aef3d1dbe19354a65cd6a72d749493a2ad4af +9fdab7cff1a31327f4cfae5d3a6d7dfbaa9a3555fffeea8107747c6af366b57cb9baf966675b6edf5ecd9d7bcd41197af5d23fd755a8905ab040dd71871bc722 +3a7450b367a7b3535b7edafbe5173578b0fae61b151f9f3a3332523dffbc7ae71d1d924b57b3667a95c4c4eb6cdcdea38feaac888b732955aed8bb570d18a04f +9c7d3284ece2cc191d535eb1420d1ca8e36ebd7bab8e1d5578b86ad74e2d5ba656aecc30b6e897f365239780ac6e7f22ec99cea88c9c3dab860f572346a8f3e7 +af997fe58a3a7952edd8a1befb4efdef7f3a6a3964882ef9aecb94d7b22b64e3afbda6cbd8e9d32a5f3ed5b8b1beb80a14f074b30000000000c02b88c3a6d8b0 +219df897d8b2453568a0fef9474f1728a01e7c508fd48b8dd503f764959f7fd661b8c993d5dab53a9252a890dbfb3d7346072e172d4af9332c4cc7d12a55d29b +ca9a550fa33b7d5afdfdb75abf5e8fb55cb34627a04b173d00332141ff761ebbf9e187f40fca45fffeabb66e753baeb764894b3b3d7142bdfaaafaf4d3d439e1 +e1faa0929274246ed4281dc7944da59ba53ffee818fdbcaeefbf4f27086bdab061eaf5d7530fb3420575d75d2a7f7e3de0f1e2455d36fef8438f859403f9f34f +1df89b38517df1858eb1c6c7eb7292511cd62fe7cb66e5ca0c83b05e2767b663475da40d79f2a83a75f495952f9fba704167e0e6cd6ae3465d18e4caaa554b47 +a83ff944c5c4b8b4f14c792d5fd78e1d3a662dbb30c841c9b12c5ba68f4b4a260000000000f03be2b02956add2b1a14b97f4b46dece1d6adfa1ef9e3c7f5cdf2 +4386a8e6cd55962cd7acb57dbbeada55073bfefc533df4908eb0b8182a32c4c7aba64d755451142ca8f7dba9938ee5a565dce93c74a85abc587df451cacc2b57 +aeb3fd952b75daece38fc6a1356eacc35ece8584e8f8519b36ae1d899d152bf48f7d202ced58cee5cb7518eef0613d5da68ccec3264dd44d37e9fc5fb448bdf1 +86be9bfb8f3fd4238fe82c4d6be9521dc63242b1ae0c1455196785bb24cf9f79467df6999e8e8dd529efd24587f3d23a7b56cd9ba74fd98e1d7aac65d5aa2951 +4e2767cd2fe7cbc618ab9b36146b2ea39c183e5c0f74354e5ffdfa3aa25db3a60a0d755cece85135658abeee4e9d525f7ea976ee54f3e7aba245afbffd4c792d +5f97ecd11684b5d9bf5fbdfdb61a33c6d38d030000000000cf11874d51bab47af1c59469237673e8907af8611db879e2091d2e898e4e67ad5b6ed1774f77eaa4 +03735bb6e8fb9adf7acb8d9dca668dc0cd830faa1933d28fda18424375244e7ea64cd171c0840497b65fb1a2e3d04be3d0643bdebdc7dc5ee5ca8ecfbe7408e4 +492ebdfeba8e4665c9a2efdc9794d822623131aa756b1d76ecd64d8f21ddb3478f884cfb7cd5bbeed23fe96e3c23196585bb9e7e5adf782eead6d5c14127377d +67cfae0bc6e38feb5bef5f7b4d0f96349d484bcf974dd5aafa272defc661870ed54158953c06f6f3cf75c43323f9f3eb259f7b4e3fa462e64c3dbeb85e3d3d70 +3557aeebec22535ecbd7b572a57bf30100000000808f1187cdd0e8d13a08d8a1830e973879d55268a8be637ac3063d84535679f34dc771764ec89645f1e2eaeb +af5d1d7cf7e493fad6e6c1835ddd4540b97c59c7b966ced4d372d473e7a67f137d74b49a304187cc0a1408ac975c0d1b96128495b4c9490f77e1ea91e2f1eaab +3ac6d7ac9947cf1cc81ce6cfd78f4655c94f7258bc58952871fd5572e6d4614dc9c0fefdf5f34f5bb7d6635d5dc9797b37c2b59c7640b1f3f90000000000c0c7 +88c36628294955afae9fb178dd506044847e17d3d34feb318f3ffda4eebbcfd55dfcf597feddae9d7b77403fff7c4aec26b8222c274ee8b71249fe08c9a2d9b3 +55debcce96bff75edfa4cb557bf6e861bca2766d3d56d7ad506083067a84eff0e116252d389c3ca9a3f089893abcfeedb7fa3114aeebd74f1d3ba6c68ed5cf0d +1839d2edd1c137c2b55cbfbefe8f8d74e703000000008040401c3643d9b2e9772b4544b8b4f0030fa44cecddeb46ec263252bf95c8dd219fc58aa9b265f5d8c0 +f2e5dd5bd1bf860cd1e130953c0c70fc7837461a06880103f480d698183d3cd344e29f7efa468fc3befd76ca034c67cd722f086b183952fdfaab7e6cebbbefea +cccc99d38d756f846b594ad7dab5fa5d6df62a5448f9cf030000000000e077c46133d4bdbb2a55cad5850b174e993879d28d5ddc738f7e2dd5679fe9a758e6c9 +e3c68a4b97ea804b8d1a6eace277461076d0a0a00c0c496e7ffeb99e78e105fd3a2c136ebe599fe21327dc0b20661a725d7cf8a19e68d54a0f2836212c4c871a +6bd6d49b1a37cebd5274235ccb254ae838f55b6fa91f7ed08379f3e6d5efbe935cca91c3d32d030000000000af200e9ba16cd9dc58d83640d28836baa84f1f7d +83f6e1c33a88f3c107aa512357c7d3952ca97f828b64d1c489fac9aac168c9127d43bdb0bd00ca5d7266274cd0b7d5b76ae5c574058dc58b555c9c9e78ed35f3 +1bb9f75e55ab965abd5a3f67d6ad38ec0d722d172eac3efed83b9b0200000000005e471cd69f6ad6d4a1c9e79ed337263769a28a16d541bae6cdd55d77a5ff4a +f7a0f6da6bc11a8455c9831645d9b22ebd5a2a232d5ae89f1bd337dfe8dfc58aa96ad53cda4ee3c63a0efbebafeac811fd9cd9c071435dcb0000000000c004e2 +b07ed6b9b38e4cbdf28afaf14775e8907e08a6fc8487ab2a55d4edb7ebd7c41b3f458af83ba11ecb9ad5df29f0c09f7feadf77dfedef7404ad1d3bf4ef3a753c +dd4eddbafa775292dabe3db0e2b0ea46ba9601000000008009c461fdaf5a35b56a95faf967fd2aa1efbfd721bff878b571a3feb1c9914355aca8eebc53bffdfc +a187f4b332e14b478feadf8116f80b22fffda77f9b7bb4ae3ddbc35b8f1cf1745356e05a06000000000019210e1b28eeba4bff888b17d5ce9d3a82233f3b76e8 +dff2e79933fa65e8f2336a942a5e5c0d1daadab6f5778a6f24274ee8dfb973fb3b1d41ebd429fd3b572e4fb7932f5fcac4b1639e6eca3a5ccb0000000000202d +e2b0012726468faab37f8ce6e5cb7a84ddead56aea54f5f7dfeac001d5ae9dfae927357ab4ff52798391931217a7ce9ff7773a8256eedc7a04ebc9939e6ee7cc +999489ecd93ddd940f702d0300000000001be2b041202a4ad5aead7ffaf655f3e6a9debdd5debd6acc1855bab4ead6cddf89bb31e4cba74e9f4e793a014c2850 +40c7610f1ff6743bfffe9b3251b0a0a79bf20bae6500000000006e58c461834968a87e097bbd7aea9e7bd45f7fa90103f4fbd9a3a2fc9dac1b40b1626ad72ef5 +db6ffe4e47d0aa5041fdf1875ab952bf622b24c4fc767efc3165a24c19afa4cb6fb8960100000000b8d11087f59ba347d5d9b366c249b973ab61c354b3667a84 +e68f3feab7fdc06af5eaa9e5cbd5a64dfaace5cfefefd404a1468dd4cc997a3cec2fbfa43c3bd59cafbfd6bfcb97d703480307d7320000000000b82ee2b07e53 +bbb67e69cfe2c5aa4103b7d7ad53276562cf1eef260ae97bf861f5c61b7a2ce7c489eaf5d7fd9d9a20d4b0a1ca92455dbdaade7947cd9f6f72231b36e868b868 +dedc7b29f306ae650000000000705dc461fde6afbff4efcd9bcdc46ee2e35326c2dd3c8121213a989890e0f61e035664a4ba7245bffec82d1327bab7fcedb7ab +3bee50bffeaa860f572fbca072e5726f75d332cdf9ca93473dffbc7e10ea82056ad93275fffd6e6f4132e19557746ec4c6aaae5d2d48a207fc722da775fcb81e +5dbb7cb97e9b59debc3af6ddbdbbce2e0000000000100888c3fa4d5292fefdfbef66d6fdfefb9409776f85ce9b571d3ba6fef9c7cc4e0353fefceae0c1944098 +8bc68c31f34ea477de510f3da4ef1fefd85107134343ddde82888b533366a82a55f48f2b32d3f9ead74f7dfaa9be7fbf5d3bf5f3cfaa6449f7567ff965b57ebd +9ee8dd5b152a644502cdf3cbb5ec40ae827befd5bf0dbb76a975ebd49c396ad52a952387475b0600000000005e411cd6cfe6cc516bd6a89a35dd58e5e8d1945b +e38b1655b56ab9b7bb4a95d48a15fa219bc387ab880837563c754a8f390db4f897b8f34e1d7b5ab8508f01bc6ebc490ea1470ff5d147667654bfbe7eb1929caf +458b744c70cc18b743b13ffda49e7d566ddfae2a57d663275d9199ce57debc7a1872bb767ad8668306fa2efe52a55c5a3129493f14c2386bf7dca3e3b081c9c7 +d7b283575f4d0dc2da48311b3c580d19e2d196010000000080571087f5b38404fd0aa3091354dbb62e2dbf79b38e64198f921c34488585b9b7bbf6ed755cefe0 +411db51933c6a555fefb4f8d1ead7f54f2fdd7850bbbb747abb56aa5e6cdd3c3545f7a497df699b3257ffc513f5260db363dddaf9f7aeb2db7f73575aafafb6f +3decf1c30ff529983e5ddf6eef0a59f8bdf7d4279fe8906264a41e5aeba24c76bedab4d1cf5195cc97df77dea93eff5c3f78d7b9132754e7ce7a00b228554a3f +5b362aca072935c3c7d7b283a54b339c4f1c16000000008040103471d8df7ed37134dbb314d35ab52afdf92121aa5831d5b2a5b330c7eeddeabbefd4850be96c +50562f50400756b264497fdd0d1bf438c7c4c46bd6ca9d5b75e8a0236ed7151d9d72a7f6871feaa19a0f3d947e98292949ef4896f9f2cb944ce8d64d3df1c4f5 +b7efe0c927d5b8713a003476acbedb7dd8b00cdf3b2f79b27cb90e7b49ce5cbdaae7e4cdab53ebdcefbfeb1c30967790d10932483e1729a283aaee3e25534ecd +bbefaa2d5b74543421411f9764be3d498c1c82cc5fb244ff298720d9d8a9534a1cd64895ecf4eebbf58f73b1b1ea9b6f54e3c6fa30656ba54ae9b3f0dc733ae5 +e93a724417da2953f4c2c6adeb65cae8e712dc7ebbab4767f5f9127ffca156aed40f4c70cec9e9937357b4a8bec45c39776fbea997efd74f9d3ca947c5d6afaf +0784d6ac99cee0e27fffd5e367df7f5f5f20a26a553d2e385fbeeb6cffc6b9961d64f410612775260000000000f0a5a089c33ef080bed5da896fbed13f19993a +d559a4a3460d7d83b0930d5ebdaa2362e97ae8217d477cdab59292d4534f394b7078b80e910c1aa4773d74a80ed8c94f4c8cbaeb2e75cb2d3a8826d3972feba3 +deb95387a16d298c8cd403dc4c3ce1d4d8e9c285aa6e5d1daefaea2b1dd8baf34efd06aa8205f547a74febe898ec6ef3e694e0974d93266ae4c8ebbf9feafefb +f516d2e5fc0419ae5c713b20151aaae6ced52154d9ef975fea8706346aa4ca97d761f71327f44300d6ae55e7cea52c2c793b6992bed93f6daae4f08f1d533973 +5e6777458ae8509d9cd919337416bdfdb6fea958516f397f7ebdbaec4b5272fcb8dab44967b24d54947e69d29b6fba141bb5b1fa7c09d97846a7ccde754f9ff3 +4bccde1b6fe8273374eaa4cbf677dfe99f3c79d47df7e9ff2fc9974f8750a5a86fdca883dd46f05a74e8a0c799ca15715d37ceb5ec4032500a7f5a727e010000 +00004020089a38ec830feadbcfcd8ded2a5244c77d9c78f8611d56cb684860b162eab6db325cb76e5d7dd3b46d0c9d216fdeebec51251fd1962d3a6858ae9c6a +de5c0fea5cb8505dbca80727ca4fba222254ebd63adc53a2c47536ee841cce2fbfe8fbdc3ffd5427fbe79ff54f46ca94512d5ae8b855f9f22e6d5c0e6aee5c93 +a7a950211dd034a16c593dc05072e6f7df7538f2cb2fd35946d2ffda6b3a9c97ee435dc3c274fc2e6b5697761713a377f1f4d37a50e7dab57aceb66d298f3bc8 +2879b2df679f35f9b4564bcf974a7eeeed9c399e8e9a2c5ad4d5378f199a36d591e5a143f5f313a4cc9f38a18b4dba6ad7d68f7170fda1ab37d4b56c6fd830fd +3f04a74f5f33b378711df5060000000000812068e2b033675ab8f14f3fd53fe67cf595c915172f4e9dbefb6e7d47f9eeddfa06f655ab7450efc4093d4a314b16 +fdeea9c28555b56afa0d452d5a5c7fc0a62b72e5529327abfefdf5bdfc6bd6e8ddc9be2e5fd6433573e7d681a1f2e5f5b8cbdab5d5cd37bbb7e51933bc903c13 +ca94d12328e7cdd321c50d1bf40301e2e3f561962ba7f3ad4993740279b6b196e6dc7fbffed9bc593f7f73d932b57fbf1e4e7bf6ac0ee6ca292b5244c725ab56 +d52f5faa50c1a31d292bcf97f8f2cbf423d75693837af75dd5b7af1e0f2bd7c2efbfeb51a292873131fae901c58bebe066a3467a3ca95b6eb46bd9468ad9cf3f +ebfcfce1073daa376f5e5dec070fd6990900000000000241d0c4616f04a54bab175fd43fbe71d34d29ef6acf1c4243f5e365e5c797aa54d13fbd7bfb625f99ec +7c19b267f7c359f3011f5fcb86b265f5ff43000000000080c0441c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c16000000 +00000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600 +000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c +1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac +451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c16000000000000 +00ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000 +000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c160000 +0000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c16 +00000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac45 +1c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c1600000000000000ac451c3633dbb76f9ffc2e5cb870444484bfd392bec0 +4f21ec71be10bc28bdc185f30500000020f3210e1ba076eedc79ecd83199a85cb972f6ecd9cd6da464c992f27bd3a64d55ab56f562dabc28f053788370b1bc71 +be10bc28bde9920b7fdfbe7da1a1a1b1b1b1050a14c8952b97bf539482f3e545017b96811b9c575afb000020b810870d500d1a34d8bb77af4cac5ebdba66cd9a +fe4e0e3239ca1b70a3993367ce9b6fbef9e79f7fdacfcc9327cfe6cd9b8b1429e2af54c1bb38cb4020a3f50500c00d8838ace54242425c5cd2be11b667cf1eb7 +d6053c716396b7b265cb2e5ab4e8e69b6ff67742005f9b3061c28b2fbef8e69b6f3ef6d863c58b170f0ff75a63a064c992c62305060e1cd8af5fbf749791ebae +71e3c632111515b575ebd6d2a54b7b6befb0e7d6590ee4fab0448912fbf7ef37a6a5ccecd8b143e6187f96295366f7eeddb68fb66cd92273fc9248c0042b5a5f +817c2d030000451cd6373efcf0c35b6fbdd5f667ad5ab51ce61833bdbedfa4a424af6fd3bb023f85b097c9ced7df7fff7df4e851fa2a37884c567a3d3478f0e0 +fefdfbbff1c61b5edff2c2850be5dbad65cb9663c68ce9d9b3674c4c4cda65860f1f2e0bcc9d3b77f4e8d1c6f307d2e27c79ceadb31cc8f5e1fcf9f3ab56ad6a +349c6263636fbae926db474b962cf9efbfff5472236ae4c891191527e0c611c8d732000050c4617d437a0e0e771ba59d0300806f1c3870c08afffc13952a5592 +df5dba7459bb76ede4c9935f7ae92587057efdf5d755ab56fdf1c71f73e7cead50a1426868a815c980b2f22cfb58952a5554060da732c98ce98a152b868585f9 +3a71000000803b88c35a2e2626263636f6ba8b65cd9ad595c50000f050525292a511abc8c8c86eddbabdfffefb5dba7471d8d1b061c31a346860846b6129abcf +3200000000771187b5dc8e1d3b8a152b76ddc5b66fdf5eb468d1743fba7af5aa745ca74d9bb66fdfbeecd9b3d7ab57af7ffffe152a54c8685337df7cf3ae5dbb +6c7fbafeecff03070e8c193366c9922532111f1f5faa54a9264d9af4e8d1a359b3661f7ef8a13120c52b023c85870f1f96ad6dddba55f622d367ce9c494c4c2c +5cb8f0030f3cd0bb77efb265cb7a652f864a952a6ddbb6cd98b6e5834c8c1831427ecb31d6ad5b77c89021f63b2d5dbab4f14031877c9322617b198b932cddb0 +61c3a851a356ad5a75e2c48982050bd6ae5dbb6bd7ae77dc71879344ba7ebe643b1b376e948965cb962d5dba74ead4a9172e5c907cfbf8e38f0b14283079f2e4 +71e3c649228b172ffecc33cfbcf2ca2be9c608246de3c78f5fb366cd91234762626264ef4d9b367de9a59772e4c8e1648f92aa8a152b0e1a34e8ebafbf3e74e8 +9071a50c183020ed95629f5169078b454747cb356b7fdfab3d7365c3ddb33c77eedcb66ddb262424a8e4c7c6bdfffefbddbb77b76d6dfefcf9ad5ab592b5645a +3270e6cc992d5bb64c77bfd725758b24fef8f1e3b639850a153a78f0a0715e2401458a1491b360fb346fdebc72d459b264b1df885be7cb446ed833510398ae6d +a414c9bea418cbe56664945c2ccf3fff7cf5ead5d32e6ca21c7acead141a6cb5874a53f89d977c13242583070f9e356b56fbf6ed6d33f7eedd2bc5fb871f7ec8 +682d77cf978739ef6ee9b559bc78f1279f7cb26edd3aa94865e1db6fbfbd53a74e6ddab4b9f5d65b172e5c2825d37e617365def437915b67d993fa3058986b39 +982e1bae70a87b2525526e1d9669debcb9d4f6c674b972e51c5eb6e633be6c1179c2672d58d34cb4bedce2f9b56ce23bc5755e691fba9842bfb46d0000701d71 +58cb4993c295c5328ad59e3f7ffebefbee9389be7dfb4abb61fffefd13274e94d6cc77df7d77efbdf7a6bbcaa2458b6ccd0bd7ef495cbe7cb9b4304a9428f1e4 +934f4a8b3f222242dab25f7df555e5ca95fffdf7df73e7ceb9b81d5704780a73e6ccd9b061c3871f7ed836e7e2c58bd280331e51377bf66cf9d45bfb9a33678e +d15234f2415aa52fbffcf2f4e9d31f7ffc71e9e45fbe7c79ecd8b1d24597a6a76d15c93d59256dbe7df3cd37920f2ae32c4d4a4a7afdf5d7a5b72fdd9277df7d +b768d1a2a74e9d9206b16cbf4f9f3ef251468974fd7c7dfae9a7b24d59e6c5175f9433f2d65b6fe5c993a757af5e8d1b3796d22bfbeadebdbbecfa8f3ffe908f +b66fdf3e69d224fbd52f5dbaf4dc73cfcd9831a375ebd6efbcf38ea4503264d3a64dd2401f3d7ab4e455dabddbf628db6cd7ae9d3494df78e30db99ae47c4906 +ca9522ed7587388e7d46a57d52b3b4b69d5cb3e6ca86bb67b951a346df7fffbd6c4ab2b1458b160e2994bd4bc740724ffa2a726aead4a993e1f9b81ee975187d +42d94b9b366ddab76f9f2f5f3e5be7472656ae5c29295fb870a19c8279f3e6c9d9b4efa898385f2672c3c65c0d60aeb6f9e8a38fa4acca39955449e7568e5aea +5ed9548d1a353a77ee2c298c8c8cb45fde4439f490bb29342c5ebcf8d8b1632abdc2efbce49b209d55e91e0f1d3ad43e0e3b62c4886ad5aa195f6ae972f77c99 +ce7973a5d758b153a74e7251c86f59522e0a297eebd6ad93adc9ba72614a7fde210e6baecc9bfe2672eb2c7b521f060513f586e9b2e13aa3eeedd1a347debc79 +e53249f7b1b6e3c68debd9b3e7e0c183e5527afbedb73ddca369be6c1199e6cb16ac09a65b5f6ef1f05a36f79de23a0fdb876ea5d02f6d1b00005c471c36d075 +e9d2e5fefbef1f3f7ebcad0121ad0d6955c8ef9d3b77a6bb4ad964eeee481a46d28a959ea1fdd3fa9e7efae9e1c3874b3bc95ce23312e02994d6aab4ead2ce7f +eaa9a7a41dd9b16347e92d4747477b655fe5cb97b74defdebd5bfa637171713ffffcb334348d996ddbb6b5bd273aed2af64a2773b2af7efdfa492bf6bbefbe93 +12659bd9b2654be9e9356ad4c8490bdbf5f355b1624563e2ca952b1b366c90b6b54ce7cf9fbf4e9d3afffcf38fcc311678e8a187a40ddda44993810307da8681 +272626b66bd76ef3e6cdbffcf28bfdd01569a3ff2f5983060dd6ae5d2bddaa74f7f8f2cb2f8f1c39527edb3eead4a993b4a1e5f7ae5dbbec5f466c9f51ee3ea9 +d95cd970f72c47454549f74c522e274b8ab7c3d6e44c55af5e5dfa03b296e4a4eb894fd72db7dc22bf9f7df6d9afbffe5abafde9a65c3a8acf3cf38c43c7c3dc +f952a6cabcc15c0d60a2b619366cd880010324871f7df451fbf97296376edcd8aa552b49a1f4dcec9361a21c7ac2440a0de59219d33e784cf92bafbc326ad4a8 +a54b971a05f5e4c99392e62953a63859c5ddf3652ee74d975e63b37ffcf1c7b66ddbec63671d3a7478ebadb7a4cf9f6e22cd9579d3df446e9d654feac3a0e06e +bde149d9708bd4bdf5ebd7974a3ea33c2f92ecc89123921edb33707dcf972d22d37cd98235c174ebcb2d9e5ccba6bf535ce749fbd0440a7ddfb60100c075c461 +dd70f8f061dbbd7e4e942a55aa70e1c2dedaa9b4a5ec83b02af93e65e9ef490b63e7ce9db6be96e70e1e3cf8c1071fa46d6349b776d2a44981f0ecda4048a174 +b6a5132e3d702fde4a6623adc9071f7c70c68c190e373d79e59ed0df7fff7df0e0c14b962cb1ef0618a4c42e5dbaf4f6db6ff77c2f3663c78e351ad9c2e8c24d +9c38d1d60a57c9833a55f28d84b676f6b469d3962d5bf6db6fbfa57dc96f4444c4881123ce9d3b274deaf5ebd7a7bbc7d75f7fdd3e04a392af94b7df7e5bae94 +1d3b76182d724bb958365c3fcbd27b944c5bb46891f4d31c3e3a7af4e8679f7db66edd3aafa45c25ff7fcfd0a14325ffd3160fe98d489e7ff9e5970ef33d3c5f +06b7cabc6f6a804d9b36f5eddb77c18205e90ef292cb64f9f2e5f25baa65c9b4b40bf8a01c7a98425f2a54a8d0638f3d2645cb88c37ef8e187050a14c82858e9 +21b772de74e95dbc78f1c2850bb76edd9a760063eedcb9a74c9922d5a9f3508557ea794bbf89321977eb0dafd46c2eaa5ebdfaa041839292926cff4fd0ba75eb +a8a828a9de8d3fe3e2e2a4b005ec590e9c721808edc38cf8b8f565828fbf534cb40f4da7d05f6d1b00009c230eeb86175f7c31ed03bcd26adebcf9575f7de5ad +9df6eedd3bed33928cf0ebf1e3c7bd188795fe80b484ead5abe7f03ff3f2a77462bdb5174ff83e8557ae5cd9b367cfd9b367b366cd9a3f7ffe7cf9f28587eb4b +e6f2e5cb56ecae73e7ce1f7df49145af5519356a54e3c68da5ff9feea7c58b17efd1a3c76bafbde6addd65cf9edd366d645ace9c39ed173066262626dae68c1b +374e2eb1b40d5f9bf7de7baf58b162bffefa6bba5dbefaf5eba79d695c20a74e9d7237fdd765ba6cb87e96a587d6b66d5b39eab47158399b75ead4f1e203efa4 +b7f3c8238f8c1933266d5f45ce4bb366cdd23e38c5c3f36570abccfba60678fffdf7a50e7772a76dc99225e54a193e7c78ba3d521f94430f53e863bd7af5bae5 +965ba41854aa5449badf6fbef9a645559c5b396fbaf44a09ecd8b1a3c363076c24e75f7ffd75e7d17613f5bc8fbf89321977eb0dafd46c2ebaedb6dbce9d3bb7 +6bd72e6377bffdf6db9c397354f27f2a18e3f5b66cd912111191d14d303e16c8e530905bb03e6e7d99e0e3ef1413ed43d329f457db060000e788c3bac18bd155 +0f19ffe79f9494e4c56d7ef8e1878d1a35bae9a69b5ab76e5db366cdca952b972d5bd6680c05085fa670c18205d274fef1c71f8db72119a4e36169abebf1c71f +b7eeddd62b56ace8dfbfbf93055ab468e1c79e405c5cdcc68d1b3b77eebc66cd1a278b952b576ed5aa55ae9f052bae140fcb865b67b94f9f3e55aa54f9e9a79f +ec1f067de1c2858f3efa68debc796e25fbbaba76ed5aa74e9dbd7bf7da0ff43b7dfaf4e79f7ffecd37df382cecadf3e5566ef8a606902b65d8b061ce97918ba5 +57af5efbf7ef77710ca377cba11529b48e9401e9eb0e1932e4c1071f4c484878f2c9277db9f77473de93d2bb7efd7ab9fc9dac3568d020e74972abccfbe59b28 +9371abdeb0e89b2823d1d1d1929e0d1b3618419fb973e74a851f1515356bd6ac7efdfac91c494cb56ad53cb919dc2b02bf1c06720b36c05b5f2a18be533c49a1 +5fda3600003817106d14040269556cddbaf5db6fbf95a6f6d4a95377eedc79f8f0e1f2e5cbd7ab57ef85175ef0e3b3c97c9c422352f0c5175f346cd870f6ecd9 +b7dc724b912245a41774f6ec5969de6ddebc79f1e2c55ed9918ffdfbefbfce5bcf254a94f0555ad2216de2a4a424398fd75d32eda0069ff17dd9b8f5d65ba56f +f9de7bef2d5cb8d03673e2c48952da9dbce9c81ce9bb56ad5a557ab3f6bd1db9d0a4eb52b76e5d8785fd72be7c53031c3b76ac60c182ce97316e963c7af4a85f +7aa4819f4207fffbdfff6ad4a8b17efdfa175f7c312626c6dfc9f1a8f49e3871227ffefcd6a4eb1a99f59bc8f7dcaa377c5fb355af5e7dc3860d1d3b7694e979 +f3e675e8d041ae912953a6d8e2b0fe8df5044b390ce4166c80b7be54307ca77892c2c06fdb00006e40c461912a2a2aea9164c69fd2ce5ebb76adb4bf6fbdf5d6 +810307f6eedddbbfc9533e49e1f0e1c3e7cf9fbf7af5ea7beeb9c77e7e747474810205eebaebae679f7dd6f3bdf89e74ed24bb9c2ce0df170ae7ce9d3b2c2c6c +f9f2e5b56bd7f663329cf34bd9e8dbb7aff422a48759a95225f9333e3e7ec488111f7cf081d777a4921fa5d7a3470fb9948c6099f4468cd713a75dd25fe7cb07 +3540be7cf98c574e3bf1df7fffc9ef3c79f278be3b13023f850eaa57afdeb061c3cd9b37bff8e28bfe4e8be649e9cd9e3dfbc99327ad489583ccfa4d649a5cfb +972e5dcae8d38b172faae4afb98cd675b1def07dcd265787f112a1eddbb7fff9e79fad5ab58a8d8dedd9b3a74c972f5f7ee3c68d5227fb2625e90aa27218b02d +d8006f7da960f84ef1308581dfb60100dc6888c3425bba74e99d77de29ed0ffb99d2e17c3859bb76ed1a376edcbe7dfbb4cf51ca7c299c306142bf7efd1cba1c +9940952a557ef8e187e6cd9b67b4807ceac3e4380a0f0faf53a7cecc993303b9edeb97b251a3468d5ab56a0d1932c47873cb8c19332223236d5d4def922b483a +abd3a74f37bad6df7ffffd9123478c815a0e7c7fbe7c5603dc77df7d73e6cce9d0a1839365e6ce9d5bb468d1b46f6af28dc04f615af603bafdce93d25bad5ab5 +152b5658f4aa317b99f59bc8b43265cafcfefbef193d64f3b7df7e0b0b0b4bfbdc5e77eb0ddfd76cd5ab5797faf6ca952bf3e6cdab54a992f1285899396bd6ac +3e7dfa6cd9b2c5f978583984f3e7cfcb44b66cd9a64d9b96254b16ef26cff37268750a95c7df0e56a730c05b5f2a18be533c4c6120b76d00003726e2b0d09a35 +6b26fde48c7a38f7de7b6f5252d2a953a7fc1887f5590a0f1d3ae4e42d2b6bd7aef570fbde12151575e2c489b4f3a5a79aeef29d3a75ead2a5cb4b2fbd94ee1b +3fa413e2fcf9653e207d4ee92c3df9e4933ebb0d53ba5b67ce9c717d797f958dbe7dfb3669d264d0a04137dd74d3f0e1c37bf5ea65d1e3022323239f79e69931 +63c6187d9571e3c6c9e9c8e84dd33e3e5f3eab017af4e871d75d772d58b0a069d3a6e92eb07bf7eeb7df7ebb5fbf7eb6579cfb58e0a730f0992ebd4f3cf1c4f3 +cf3f2fd760f1e2c5335ae6c081034e3e7591ef6b1b77eb43072b56ace8d6addbf1e3c75bb76e3d72e448af97bd56ad5a498df4c20b2fa45b23bdf7de7b523938 +bced4799aa377c5cb3952b572e262666d3a64d73e7ce95633466b669d366f2e4c98d1a358a8e8e2e5bb66c46ebfef1c71f3367ce34a6070c18604588d3c372e8 +83142acfbe1d7c9042dfb7bedcbd9603ff3bc5c314fabe6d63757d08000876c461a15db972459a2f55aa5449fbe43bf9a87bf7eed27c346e8bf6179fa5f0d65b +6f9d31634683060d1ce69f3c79527a7a23468cf07c175e71db6db77df6d967d2fdb0cd919ec6d4a9535f7ef9e574977ffcf1c7a74f9ffef0c30fcf9f3f5fb2d1 +fea363c78e49f72f6fdebc7ffdf597b589764a3a515dbb7695147ef9e597e976a8366edcf8da6baf3dfffcf3de1a0d5aad5ab569d3a6495fd761be9428c9abe2 +c58b3b24c35f6543f244763d7cf870e91b1c3972444ea5453b122fbcf0c2d0a143a50b51aa54a9c58b173b79d3b48fcf97cf6a80db6fbf5dba73eddab59b3061 +c2638f3de6f0e9faf5ebdbb469231dfb8c2e341f08fc14063ed3a5f7d1471f9d346952c3860d172d5a94f6398972bd74e9d245aae255ab56799842dfd736eed6 +870e9e78e28983070fcac4e8d1a3efbbef3eaf8fd9976b5c92d7b265cbd9b36767cb96cd363f3131f1d5575f5db972a594fcb46b99a8377c5cb3858484dc79e7 +9d72ae7ffffdf7cf3fffdc98d9ba756b3928c976f9a27712c159b264893151b060c19e3d7b7a9e98b43c2c873e48a1f2ecdbc10729f47debcbdd6b39f0bf533c +4fa18fdb3656d787008060471cd677b66fdf6e7baedc962d5b54f2ffd04adb22dda16dd2263b7af4a8b1644c4c8c34aa6c6d71271fedd9b3e7f0e1c30e9b32f6 +657058de5e6c6c6c9932659a366d5aaf5ebd42850a8585851d3972e4e79f7f9e33674ef6ecd9172e5ce8952178819f426933d5af5f7fdfbe7d1d3a742851a284 +f4f1fef9e71fe9547ffdf5d7f2a774f66ad6ac290996bd4b0749cea087bbfbf3cf3f8f1f3f6e4cdbe7834a3edeaa55ab66d407ebdfbfbf748da4552a4d5249a4 +ac2b4d4649eac489131f7df451f9332a2acafe3ff32573e6cd9b270bcb4c594bd6953c3c73e6cc8f3ffe3879f2e41a356a485f2b478e1c0e87e6eef9b22dbf6d +dbb67beeb9c7feb5e0b296f4918cb7426734535ac979f2e491ce43ad5ab59a376f2ef3232222a4a3b279f3e6a54b976edab4497a2cf6ef5590d324876cbc0c3d +ede52064c574136378fffdf7a5912dc5495accc58a15bb74e9d2eeddbb376cd8f0edb7df4a764977c56179d365c3f459b6e9d3a74fa74e9da4b4bff2ca2b9e97 +3a278a1429d2a2458b214386185d35e7af3771f77c194ce786bb3580e9da46ba58d9b2657beaa9a7c68c1923174b850a15c2c3c3e5bc2f4c66ccb72f4e1e9643 +13dc4da18d743e6de3e8cd15c5eb320ed6d878d6ac59659b0e0bfcfdf7dfc683fcd4b57962e27c7992f3e64aaf5191b66cd9b262c58a526fc80279f3e63d7bf6 +ac94eaefbfff5e3af9729d8e1c39d2612d1365de936f227367d9ddfad041424242bad3de22d7f892254b1a376e5cbe7cf9e79e7beece3befcc92258b34ab3ef9 +e49343870ecd9f3f3fa3409b899683b9b2615af5ead5658f7215db469e162d5a544aec471f7dd4b56b57272b4a628c898103076634b8cf431eb6887c904283e9 +f6a10f5268aef5e50913d7b2e9ef14d779d83ef430853e68dbd8b3ba3e0400043be2b0bed3b061c3fdfbf71bd3c6bb38e57b5d7a11a54b974ebbb0743676edda +652c297d4b59cc36f4c6c947d26890fe9ec3a6ecdffb29ad4c593eed2d93d20df8e0830fae5ebd3a7efc7869a648af262e2e4e5a21d2617bebadb7a4252749f5 +3c07822285d2269614cabea4fb21e74b7af8d27abbf7de7b67cd9af5d0430f19dd574970545494f4753d7fcb6d93264dfefefb6f63dae10dadd1d1d1b28b8c5e +4d2b5da3458b160d1830409a83d26a97aee9a38f3edaa54b975cb972c9846c4a922de9b76f954a6f6441b249932675efdefdd4a953f9f2e5938ec19429536cff +57ef7068ee9e2f499534f765e295575e79e08107eccbb6ac25dbdcbb77afc3a6ec674af6f6e9d3a76ddbb663c78e9d3871a2cc8f8f8f2f58b0a01c9df46166cf +9eedf0e42fb916a4416fdb94b4d1e54ffb7b0f8d513c2fbdf492b4981d9af82af92dba5bb76e1d3c78f03befbc73f0e041c9f0c2850b1bbd5f392f695ff962ba +6c983ecb367296df78e30dd9fbf3cf3fef7c49cf49cf5f724626a480395fd2ddf36530971b266a00d3b58d4a7ead47b366cda45f2757871c97ec57ca469d3a75 +d6af5f7fd75d77392cec613934c7ad14da346ddad4c3a2785dc6207d63e3722dc82970d8e6c30f3f6cd412eada8ac2c4f9f224e7cd955e2175ec0f3ffc3063c6 +8ca953a7ce9c39f3cc993352b5ca5ab20bd954b972e5d2ae62a2cc7bf24d64ee2cbb5b1f3a983061827c011d3b76ac4d9b36160dfe2a5bb6ec6fbffd26e9914c +18366c989c2f39102903afbefa6aa14285d25dc55ccbc174d930471229a9b23d94c020d9b876ed5a2777465fb87061cd9a353251a14285a79e7aca8be9b1e749 +39f44d0a9507ed439fa5d044ebcb13e6ae6573df29aef3b07de8790aad6edbd8f3417d0800086ac4617d67dfbe7dae2fece41e25271f39b9d1c639db0d7dd274 +30b70517057e0a55f2501427efa337c65e798b115237c7780745daf9ce53d83459ba1fa55dd1ddf365ebfcbb92a48cd2290ddcf7df7fdf95dd494fc3f9026987 +d739909e80f48b5cd997c15cd9f0e42c1b424343cb9429d3bc79f31c397278b8a9eb329ea6e7faf2ae9f2f83b9dc30510398ae6d0cc58b171f96ecba4b7a5e0e +cd713d85369e17c5ebbaee375d46b58489f3e579cebb5b7a0d723d3e9accc5e5cd65bbe96f22d367d9ddfad05ea3468d0e1c38606e5dd7c5c6c6f64ce6e2f29e +b41ccc950d131a376e9cf66c764be664ad152b56c4c5c5c9c4902143bc32ca3e23a6cba1cf5268fa2cfb2c8506b75a5f1e32772d9bf84e719d57da879ea4d0ea +b68d3ddfd4870080e0451c160002ddf6eddb972f5ffec9279ff83b210000ff331e6c5abb76ed264d9af83b2de92385000000e9220e0b00816ee8d0a18f3df658 +e1c285fd9d100080ff7df7dd77f2dba2a18b5e410a010000d2451c160002daa1438766cc9861bc71080080bc79f33efcf0c35e7970a7454821000040ba88c302 +4060494c4cdcb469d3a54b978c3fa74c9952a952a563c78e9d3b77ae5ab56a3e788c1d002090ad5dbbd6df49b80e52080000902ee2b0001058b66fdf5eb366cd +cb972fdbcfac55ab566464e4faf5ebab56adeaa774010000000000f388c3024060a954a9926d302c0000000000c81c88c30200000000000080b588c302000000 +00000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200 +000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c3 +0200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b5 +88c30200000000000080b588c30200000000000080b588c30200000000000080b588c30200000000000080b588c3020000000814fbf6ed93df850b178e8888f0 +775ad2470a01008039c46101c00b76eedc79ecd83199a85cb972f6ecd96fd834640ebb76ed3a72e488ed4f0ff333b39e974038ae4048c38d29c073dec3e479b7 +06f0ae00cf796f2959b2a4fcdeb46953d5aa55bdbe71afe4a1a529f48ac04f2100003726e2b000e0050d1a34d8bb77af4cac5ebdba66cd9a376c1a3287468d1a +eddab5cbf6a787f99959cf4b201c5720a4e1c614e039ef61f2bc5b03785780e77c50200f0100801f1187b556ddba7557ae5c694c172b566cfffefd212121b64f +ebd5abb762c58a8c3e051044f6ecd923bfbd7b09972d5b76d1a24537df7cb31fd37063faebafbf6cd39ee767663d2f81705c819086cc2193d5361e26cfbb3580 +770578cefb45262bbd7ee16e1e020000d388c35aebd34f3f5db76e5d870e1dde78e38d471f7dd4a1cd279fae5fbfbe7dfbf6c3870f6fd8b0212d4200f6fefefb +efa3478fd22f0260356a1b0494a4a424d717f64be9752b857e11f8790800c08d8938acb58a27fbedb7dfa64c99f2eaabaf3a7c5aac58b1975f7eb971e3c6afbc +f28a3f5207000000000000c01788c3fac2c08103172c58d0b367cff1e3c7dbcf9f3973e6aa55abb66fdfeeaf8401000000000000f001e2b0be1015153565ca94 +9a356bb66eddfa81071e30661e3f7efce5975f7efffdf70b152ae464dd43870e8d193366e9d2a57bf6ecb97af56ae1c2856bd7aefdfcf3cf57af5e3dedc2a54b +97361e7ae5f0e6810a152afcf9e79fc6b4152f2558bc78f1279f7cb26eddba13274ee4c891e3f6db6fefd4a9539b366d6ebdf5d6850b17962a55ca7ee1c3870f +7ff8e1875bb76e3d70e0804c9f3973263131518e4b72a677efde65cb964dbbfd3beeb863e3c68d46e22b56ac3868d0a0afbffe5a72267bf6ecf5ead51b306080 +1ca0e74761dbcbb265cb24c3a74e9d7ae1c20549d5c71f7f5ca04081c993278f1b374eb2b178f1e2cf3cf3cc2bafbc1216169676232e9e2fe3232903b639520c +0e1e3c686c332121a1489122f62f6bce9b37afe455962c59ec37b26ad5aaf1e3c7af59b346968c8989b9f9e69b9b366dfad24b2fc929f03c376c4c9c2f51a952 +a56ddbb619d3b622271323468c90dff1f1f175ebd61d326448baabfba0cc7b58a2366cd8306ad428c97f29f0050b1694e475edda55b6e96415b7d827be56ad5a +0e9f464747efd8b1e3a69b6e72be11c9ba61c3864d9b366ddfbe7dc671f5efdfdff971595aa21cca7cb366cd24cf1d9669debcf9fcf9f38de972e5cad932c1c6 +adb2a13c2b87e6585d360cbeaf457d735c366e7da7d8b855e67d9c87972f5ffee8a38fbefcf24bb97843424264fbeddab5933680340f8c471265cb964dca6ab1 +62c51c56b4ba9ecf94b54d5a7296478f1e2d8547266263636fbbedb6279f7c524e81d79f07e56e1d6563aecc1b929292e41c4913c2f8531a129f7ffe79dbb66d +d35d58724052b864c91299903a50b6dca449931e3d7a489d2c5744952a55cc1db8c1f37a5e4a82eb6f48f34be9752b85ca572d58d329f44a1e020000b71087f5 +91bbefbebb7bf7ee4f3ffdf4962d5ba4bb2573a4135bb56ad5ce9d3b3b594bba6db2962cf6f8e38f4b53294b962cfbf7ef5fb468518d1a3564c5b163c7464646 +da2f2f1f49f3376d43ea9b6fbef9f7df7f557a6d2c0f5dba7449ba0ad24990dfd2c9c993278fec483a12cf3df7dce4c993b76fdf2efd5b87fe43ce9c391b366c +f8f0c30fdbe65cbc7851fa0fd22e97239d3d7bb67ceab0974f3ffdf4d4a95392f83ffef8433a4ed2c47ce38d37a4bf2a6b49bf45dab8d2e7f13cb86cdbcb8b2f +be78eedcb9b7de7a4b0ea757af5e8d1b372e52a4c8b265cbe45cbcfbeebb9206f9480e6dd2a4490e5b70fd7cc9474644a3458b16d2d16adfbe7dbe7cf96c815d +9958b972a59c4ac958c9c679f3e6494aec83b092ed92c33366cc68ddbaf53befbc53b468d10b172e6cdab4491696b33067ce1c2f9e6813e74b481a8c9e989112 +49decb2fbf3c7dfa74c9193965972f5f96dca85bb7ae74454ce7a1c15c99375da2a4bbfbfaebaf0f193244ba97521824e7653b5236e458faf4e9231fb992a5d7 +659f78e9184b3fdcfed3989898e2c58b3bdfc2f9f3e7efbbef3e99e8dbb7af945ec9c3891327ca717df7dd77f7de7b6fdae57d50a28c322fbdfdbc79f33efffc +f3254b964cbbccb871e37af6ec3978f0e01c3972bcfdf6db0e9fba5b369407e5d004df940d832f6b515f1e9732f59d6270b7ccfb320f0f1c38d0a851a363c78e +c9510c1830408aaeb404c68f1f3f65ca94254b96c802729957ab56cde13f657d53cf67cadac6819c53294e924829ae46015ebe7cf9534f3d255fe272a273e5ca +e5ad1d99a8a3940765de262424e48b2fbe78e491470a1428306ad4a8d8d8584943ba4bca81376ddab44489124f3ef964b972e5222222a4707ef5d557952b5796 +9d4acbc7c31cf0bc9e97ecb2fd27f4754b82ef4bafbb2954be6ac19a4ea1e779080000dc451cd677a4b929edec5ebd7a7dfcf1c70b93494fccc9f2c3860d930e +9bb4c21f7df451fbf9d279d8b87163ab56addab66d3b6fdebcd0d050db47e5cb974f7753a59379e5281c48b7415a96dbb66db36f6d77e8d0e1adb7de6ad1a245 +baab48ab4efa2469e7cb71496bb563c78e870e1d8a8e8eb6ffa862c58ac6c4cb2fbf3c72e448f96d9f00e9cbc9ef5dbb767938b0c5b6972b57ae6cd8b0415ae4 +329d3f7ffe3a75eafcf3cf3f32c758e0a1871e92fe5593264d060e1c283d3adbeaee9eaf5b6eb9457e3ffbecb35f7ffdb5744b1c12639cca3e7dfa3cf3cc330e +cde8c4c44469ca6fdebcf9975f7eb11fbad2b871e3ff256bd0a0c1dab56ba55be5496ed898385feadaa2b87bf76ee98fc5c5c5fdfcf3cfb6cea1e48674781cd6 +f25999375da2faf5eb273d6de9a1dd7ffffdb6992d5bb6945e65a3468dd2ed639b609f78e91499e8a175e9d24552387efc785b70bf73e7ce6ddab491df3b77ee +7458d867254aca7cfdfaf525f7323aa222c9a40329e92953a68cfd4726ca86325b0ecdf14dd930f8b216f5e5712953df2906b7cabcf2611e5ebe7cb961c386f2 +55b27af5ea9c39731a331f7cf041595dd2265f282af932bffbeebbedd7f2d95599596b1b9b65cb968d1d3b76d6ac5992e7b69952805f7df55529c04d9b365dbe +7cb9c3bd26e698aba3940765de462ab7279f7c524edf575f7de57c40f18b2fbe28873c7dfa74fb643cfdf4d3c3870f97d6a92bfbba2e4fea795136998bfbf271 +e9359142e5ab16ace9147a9e870000c05dc461dd70f8f061e30e68e74a952a55b870e1b4f38da713d4aa554b3a03ddba757bf7dd774b942891d146366ddad4b7 +6fdf050b16a43bd8f0f6db6f979e83fc96b6a33422dd39086f5abc78f1c2850bb76edd9a76c843eedcb9e560252bd276399c908e87b447a53792d1edaeafbffe +ba7d1356250f0379fbedb7a5ddbf63c70e23b2e939e9b31941586174d4274e9c686b490b6308d58103076c7158d3e74bfe1c3a74a87414ed631c06e9a9ae5fbf +fecb2fbf74983f6dda3459feb7df7e4bfb5adb8888881123469c3b77eed9679f9575dd3d70775df77c19a4172a657ec68c190efd43873bddfc52e6dd2a51bfff +fefbe0c183972c5992f66449515fba74a924cf5b09f390f4a6ec3b962af9b8a4572f47247dcb72e5cad92feccb1255bd7af5418306252525d9fa9cd20b95baf1 +b3cf3e33fe8c8b8b932ac5a14479a56cb8580ecd099cb2e1dd5ad4c7c7e5c9778a5b65de39efe6e1c71f7f7ce2c4899f7efac9a1e065c992458ee89e7bee4977 +178153cf5f57c0d636868103077efbedb7f64158835180ab56ad3a66cc981e3d7a78b817d37594e7eda85f7ffdb551a346728093274f963c749ece83070f7ef0 +c107693728e579d2a449b1b1b1ce577791b97ade2fbc586f5c976f5ab0000020f0118775c38b2fbe98f6415769356fdefcabafbe4af723e97175ebd64ddaa335 +6ad490ad39d9c8fbefbf2fdb49b7416f9026fb6bafbd367cf8703fc661274e9cd8b163c78c6e9793144aa3d349cbf2ca952b7bf6ec397bf66cd6ac59f3e7cf9f +2f5fbef0705d202f5fbe9cd12af5ebd74f3bd368289f3a75caed03c840f6ecd96dd346926c8398ec67262626dae6983e5f458b167de49147a41f9836cc316edc +b866cd9aa57d5ca0cc97c293b6136bf3de7befc95ad237f36e27c7c4f93274eedcf9a38f3e4af771baf6fc52e6dd2a51a3468d6adcb871dafebca178f1e2d299 +97147a2b6d9ee8ddbb77da0c378eebf8f1e30e7d4b5f96a8db6ebbeddcb973bb76ed3276f7db6fbfcd9933472577508db1ab5bb66c8988887018e6ec95b2e162 +3934c75f65c3ea5ad4c7c7e5c9778a5b65de9ed579386bd6ac679e7926dd518ab2a3be7dfbb66cd932ed47feaae74d08d8dac6d0a8512363d0715a52807bf6ec +397af468cfe3b0a6eb280fdb51df7efbad3429bb76edface3befb832a0b27af5eab2c77af5ea398c64973f77ecd871ddd55d64ae9ef70bd3f58609be69c10200 +80c0471cd60d194557dd3268d0a00f3ef860c08001ce5bcc2b56ac18366c98f34db568d1a257af5efbf7eff7d713f4d7af5f2fbd74270bc8c1a63b7fc18205b2 +e28f3ffe181f1f6f9b291d6073fd2e6364475252928975bdc593f3253da83a75eaecddbbd77e38cce9d3a73ffffcf36fbef9c661237171711b376eecdcb9f39a +356b9cec4b5af6ab56adf2563fd6c3f3f5f8e38fbb12fc0a9c329f51899214f6efdfdf79f202240e9bae748fcbc7252a3a3aba72e5ca1b366c30fae773e7cead +52a54a5454d4ac59b3faf5eb27732431d5aa557318aee595b2e1623934c7f765c337b5a88f8fcbf4774a469c7f3bf8260fb76fdfeee429bab56bd74e3bd32ff5 +bc7705426d63707e6bbf7c2a67e7c081031e3e04d3741de549999f366dda942953a4467dfbedb75dbcabfdc30f3f6cd4a89124a075ebd6356bd69475cb962d6b +fcc7831799abe703872f5b9581d0820500003e461cd6d78ce7cd497bd4f962c78e1d2b58b0a0f3658c9be28f1e3deaaf38ec891327a4cbead62a0909094f3ef9 +e4175f7cd1b061c3d9b367df72cb2d458a149166e8d9b367a573b279f3e6c58b175b945a4b7972bea42f54b56a55e91dd9f7e2a64e9d5ab264c9ba75eb3a6ce4 +f4e9d3d25e7fe18517ae9ba4b4036c4df0e5f90afc32ffefbfff3adfaf93278d042c1f9728953c204bfae71d3b7694e979f3e675e8d021262666ca9429b6fe79 +daf80b65c39e2faf4a1f977913df29e6f8320f2f5dba24253ca34fed6fbfb0f1fd55e91b7e392ee705d8f8efcf23478e781887355d477952e6a5008f1a35eaad +b7deead4a9d3a79f7eea4a58b35cb9725bb76efdf6db6f7ffcf1476966ecdcb9f3f0e1c3e5cb97af57af9e9c97b44f6b35cd443d0f00007083200e1ba0f2e5cb +67bcc0d489fffefb4f7ee7c993c727294a8774204f9e3ce9d62ac3870f9f3f7ffeead5ab1d1e8a171d1d5da04081bbeebaebd9679ff56a1a7dc4c3f3f5f2cb2f +f7e8d163e0c08146775d7aaac66b97d32e993b77eeb0b0b0e5cb97a73b8acaeb7c79be02bfcccbd9397bf6ac93053c7fd9b4eff9b844a9e4feb9f162baeddbb7 +fff9e79fad5ab58a8d8dedd9b3a74c972f5f5efae769ef11a66cd8f3e555e9e3326fe23bc51c5fe661fefcf90f1d3a94d1a7870f1f4e3bd3f757a56ff8e5b8ce +9f3f7fdd4fd38d86bbc5741de549999f366d5a8b162d2433efbbef3e29b113274e7465546c5454d423c98c3fe5025fbb76ed175f7c71ebadb74a23a477efdee6 +12e3c0443d0f00007083200e1ba0a4553d67ce9c0e1d3a385966eedcb9458b164dfb6e079fa956adda8a152b5c7c9faf61c28409fdfaf5cbe8cd24c1cbc3f3d5 +be7d7be9fc4c9f3edde8fc7ffffdf7478e1c31069238080f0faf53a7cecc99337dd38ff5e5f90afc325fa54a951f7ef8a179f3e6192d209ffa3039dee1e312a5 +92fbe752ceaf5cb9326fdebc4a952a198f089499b366cdead3a7cf962d5bd28e93a26cd8f3e555e9e3326fe23bc51c5fe661cd9a35172f5e9c6e7dae929fef99 +76a6efaf4adff0cb71ad59b3a669d3a6197d2adfb679f2e4f17c1ca8e93aca93326f0ca4955a548ec278e4ab11faccc8d2a54befbcf3cedcb973dbcfcc9e3dfb +c3c9dab56bd7b87163698da47d2abd0926ea790000801b0471d800d5a3478fbbeeba6bc1820519f51f76efdefdf6db6f4b4f32edf087a8a8a813274ea45de5f7 +df7ff76e229f78e289e79f7fbe57af5e4e6ee87378ecdaa143879cbc7162eddab5de4da1cf7872be54f22b329e79e6993163c6187158e94a3df9e49319bdb958 +fa30d25992057cd08df1e5f90afc32dfa953a72e5dbabcf4d24be9be5de4fcf9f3ce9fa46942962c59ce9c39e3dd6da6e5cb12a5926f8c8d8989d9b469d3dcb9 +735bb56a65cc6cd3a6cde4c9931b356a141d1d5db66c5987553cbcbe7cc09765c39757a58fcbbc89ef14737c998752abd7af5fff7ffffb5fd5aa551d3e3a77ee +dcd0a143d35dcbc757a5caa4b58d183f7e7cb76edd8a142992f623c97fa934e4cbd7f327479baea3bc52e6ab55abf6edb7df3ef8e083f255f8fefbef67b458b3 +66cd162e5c98d16bf7eebdf7dea4a4a453a74e79250e6ba29ef7846f4a6fe6e6611eae58b1422eb4e3c78fb76edd7ae4c891fefa2e0600202810870d50b7df7e +bb34d9dbb56b3761c284c71e7bcce1d3f5ebd74b73561acd2fbffc72da756fbbedb6cf3efb4c1adcb639d2b69e3a756aba0b7be2d1471f9d346952c3860d172d +5a94f6116c3b76ec900ebcec7ad5aa55b699b7de7aeb8c19331a3468e0b0f0c99327df7befbd1123467837853ee3c9f932bcf0c20bd22197866ca952a5162f5e +ece4cdc5d289eadab5ebc30f3ffce5975fa6dba1dab871e36bafbd265d3bdb8d87a6f9f27c057e997ffcf1c7a74f9f2e393f7ffefc2a55aad87f74ecd831e96a +e6cd9bf7afbffef2e21ea5773d6dda34e9b53accbf72e58aa4447ae619f5a8dde2cb1225a47b76e79d774ab9fafdf7df3ffffc7363a6f4dc5e7df55539283995 +69fb6f9e5f5f56f365d9f0e555e9e3326fe23bc51c5fe661ddba75dbb66d2bd7cef7df7f6f3feef2c2850b92818d1b371e3b766cdab57c7c55aa4c5adba8e480 +60fdfaf5bffefa6b87c0df9123475ab66c191515e5e42d6aae335d4779abccdf7df7ddb20529d27244efbcf34ebacbc8a9ecd7af9f5cc8699f482b1f75efdebd +7cf9f2952a55bacea1bac6443def09df94decccdc33c7ce289270e1e3c2813a3478fbeefbefbbc75fd020090291187f59deddbb7db9e02b665cb16953c0a52da +ee19bd5a41ba22d9b2657beaa9a7c68c19238dfb0a152a848787efdbb76f6132637eba8338faf7ef2f6d7159453a03898989b22fe9f0fcf3cf3f13274e9416bf +fc29cd74af0c459194cf9b374f7a32152b56941698f436a54f7ef6ecd93ffffc533a9c2b56ace8d4a9d3c89123ed5791f699f488e4283a74e850a24409499e24 +4c3a18d247923f57ae5c59b3664d49a11c9734d3257f6415595896315e262b1fc5c4c44863d1be05bf79f366f9bd6ddbb67beeb9c793512d7bf6ec311ed59776 +53b25fe9b7186ffecd68a6e9f3652852a4488b162d860c196234769ddf263974e8d03c79f24873b956ad5acd9b3797344444441c3b764cb262e9d2a59b366d92 +ee7dda777c9960e27c19a40c1c3f7edc9651f6db8c8d8dad5ab56aba7d30df9479d325ca28f0b20bd994ec4bf658a850a13367cefcf8e38f93274fae51a386f4 +3973e4c8916e8698f3fefbef4b61a857af9e5c5fc58a15bb74e9d2eeddbb376cd8f0edb7df4a62a46be4b0fc5f7ffd75f4e8d1748fcbc947ca8725ca50bd7a75 +d9a39c5fdb98c4a2458b4a6e7ff4d1475dbb764d77157365c35c39dcb973a71cbbfd1cfb75d3e69ef26dd9f0652deae3326fe23bc55c99f7f1379154446ddab4 +91f2f6fcf3cfcb41c9c525d7d4d8b163efbefb6eb9c6d38dc32a9f5f9599acb6d9b871a31c824a7e16f09c39732a57aedcbe7d7b39c082050b9e3e7dda28c052 +ffc81eb366cdeab0ae891a4099ada34c9479fb6acd5e952a557af5ea3570e04029a50d1b3694939836b02bf59eb42e9a366d2a275aae6549cf9123477efef967 +c9a2ecd9b34b3a5d79d9978bdcade76d6d307baee4bcf255e93591429fb5604da7d0c6dd3c7490909090ee340000488b38acef48b378fffefdc6b4f1be60e97b +6cdfbebd74e9d219adf2f2cb2f376bd64cdaee53a64cd9bb77efd5ab570b172e5ca74e9df5ebd7df75d75d19ad25ddcb458b160d1830403a33d2812c5fbefca3 +8f3edaa54b975cb972c984ecba4891229212cf1b7c42b6f9c30f3f48577cead4a93367ce94feb934e5658fd29790be65b972e51c96977ebb74213ef8e003e906 +4b1aa46d2a89b9f7de7b67cd9af5d0430f194d4349615454d48e1d3b8c3771376edc585aa8c6eaf291f473e44ffbfbe68c314d2fbdf492ecd42154ea16c93769 +74cac42bafbcf2c0030fd89f17d9af24464e81fdf269679a3b5f36d23391cebf4cc8e973bea464549f3e7ddab66d2b992c3d7cd9577c7cbc742f25e71f7becb1 +d9b3677beb299926ce97a14993267ffffdb731edf076ece8e8685938a37758fba0cc7b52a2a4782f483669d2a4eeddbb9f3a752a5fbe7c77dc7187a4d636fa23 +dd0c3147cac3d6ad5b070f1efcce3bef1c3c7850b24e72c3e8c74a0ea77d09bb1cdaae5dbb8c34c8a752bdd8f2d9c947ca8725ca20fdf3b8b838dbcdaa86366d +daac5dbbd6c97f1199281be6caa1e4956dadb4eb66b4a2cfca868f6b511f977977bf53cc95791fe7a19419c9c0cf3efb6cc28409e3c78f978aa862c58a725da7 +1d3869cfc7576526ab6da43ed9b3678f4a0e74ca596ed7aeddc71f7f2cfbfdefbfffb266cd5ab56ad551a34675ecd831dd8690b91a4099fdfe3251e68db68a83 +0f3ffc70e0c08132f16e3239a1ab57afb65f402a5e29f3922a298443860c3974e890d4c379f2e491dc78ebadb79e78e209699466944813dcade71b356a2457a5 +c34cfb9c8f8d8d95b294ee231a7c537a4da4d0672d58d329b471370f1d48e5268dae63c78ec92966302c0000ce1187f59d7dfbf699584b5a4bc392b9b596f1d6 +85b4f38dff93f72ee9e43c9accc5e58b162d2a3d818c3e4d9b4269173adf60baef9b36c1a1dfe5244919cd5466cf97c1783a9bebcb4b67d5c993e0bcc5ddf365 +30ba31e6585de63d2f514d93a5fb91d72fb1d2a54b4f9a34c9c5859ddc21eecacde3be29512ab96b9a36a3ba2573bea2bb65c35c39f4a4f4faa66cf8be16f565 +9977eb3bc57499f7711e8684843c9eccf946d2f2d955a932576de310a9ac91ccc5757dfffde55699cfa8add237999315d7af5f6f4c4c9830c1ade499e36e3def +e4714caef041e93591429fb5600dbecc43078d1a353a70e080277b0700e0c6411c160000c00f8c3ba0d3de1a0f0000002053220e0b0000e0073ffdf453444484 +e7f72303000000080ac4610100007cede2c58b6fbcf146c78e1daffbec450000000099037158000000cbeddcb9f3d8b163c6f4c18307870d1b96909060ee79e2 +0000000082117158000000cb356edcd8f692a57cf9f23df2c823efbcf34eae5cb9fc9b2a000000003e431c160000c072bb76edf2771200000000f81371580000 +0000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b0167158 +00000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016 +715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000 +b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b016715800000000000000b0167158f8d3be7dfb +e477e1c285232222fc9d160496c02f1b819f420000825166fd86cdacc7056484320f00691187853f952c59527e6fdab4a96ad5aafe4e0b024be0978dc04fa18b +76eedc79ecd83199a85cb972f6ecd9fd9d1c5868d7ae5d478e1cb1fde9e3332ec54cfa63a1a1a1b1b1b1050a14c8952b97cf767d43f1ef59b6027594bdc0cf0d +afa4d0d26f583fe661a66939dc9802ffea0b4099f55a3e7dfaf4efbfff5ead5ab51c3972f872bfae3b78f0e07ffffd973b77eed2a54bfb3b2d193a79f2e48103 +0764a24c993259b366f5777202880fcab664fef6eddb2ddd059c200e0b0037b4060d1aecddbb572656af5e5db3664d7f2707166ad4a8d1ae5dbb6c7ffaec8ccf +9933e7cd37dffcf3cf3fed67e6c99367f3e6cd458a14f141026e28fe3acbd6a18eb217f8b9410a91595172028dbfcec8c58b171b366cb86eddbac02c09b367cf +eed7af9fadd155bc7871f9f3a9a79ef26faa1ccc9d3bf7fdf7df5fbf7e7d525292fc191e1edebc79f30f3ef8a058b162fe4e5a40f041d97efef9e7a5a858ba0b +38411cd65a75ebd65db972a5312dd5cafefdfb4342426c9fd6ab576fc58a15197d8a1b44d9b265172d5a74f3cd37fb3b21c824dc2d517bf6ec91df543e3782bf +fefacb36edb3333e61c284175f7cf1cd37df7cecb1c7a433204d6d270b07457d78f8f0e1b163c72e5cb850beb51313134b962cf9f0c30fbff2ca2b458a14a95a +b5aa742dfc3bf6c42f67d92dd4519e08fcdc2085de1214f5a109c17b5cc152728257507c3bc4c7c7b76ddbf6ecd9b3bedca9ebfef7bfff8d1e3dfa85175e983d +7bb6b4468e1f3f3e67ce9c1e3d7afcfcf3cfe3c78ff777eab4848484471f7d74d9b265d2329c366d5ab162c54e9f3ebd71e3c6fefdfbdf76db6d6bd6ac2957ae +9cbfd3e87f5697ed75ebd62d5fbefce4c993b973e7b66817708e38acb53efdf45329e51d3a7478e38d37a4c671b896e4d3f5ebd7b76fdf7ef8f0e10d1b36bc01 +bfd78dff01bbc1fdfdf7df478f1e0dc6f6a8a502bf6c046c0a2951082883070f96b6b57c09bab270e097de2fbef8e2d9679f2d5ab4e8934f3e59b97265e94eec +debdfbcb2fbf1c376edc471f7db479f3e67ffffd3790ef010c04817f96e17701fb0deb21b78e2bb35e2999f5b890aecc57e69f7beeb98d1b374a17fea69b6ef2 +775a1c7df2c927d21a59b264499d3a758c39c58a15ebdebdfb430f3d54b366cdaa55ab76e9d2c5bf2914927bbffefaeb4f3ffd648bb7162850a061c38692c847 +1e79e4a9a79e5ab3668d7f537823e8d1a38734ce7944981f1187b556f164bffdf6db9429535e7df555874fa5667cf9e5971b376efcca2baff82375000058ebc0 +8103b56ad5f2772abc63d5aa558f3df658cf9e3d070f1e6c3fb0b75bb76e8b162dead0a1831fd30600002cd5af5fbf59b3664963403af8fe4e4b3ade79e79d1e +3d7ad882b036b7dc72cbc08103870e1d1a0871d8bbeeba6bf7eedd69e78785850d193244927af0e0419e4e60a91933669c3e7d3a100ac38d8c38ac2f48c5b760 +c102e9b939dc0e3073e64ca9c78d0724030090f924252549dbdadfa9f0822b57ae3cf7dc732fbdf492f464d27edaa851a3891327b669d3c6f7090300003e3067 +ce1ce9bfdf76db6dfe4e48fa5ab76eddbd7bf7743fbafffefbbb76ed7aead4a9401e0269dc4e74ecd831e2b0d691d66cdfbe7dc78d1be7fc4161b01ab9ef0b51 +515153a64ca959b3a6548e0f3cf08031f3f8f1e32fbffcf2fbefbf5fa8502127eb1e3a7468cc98314b972eddb367cfd5ab570b172e5cbb76ede79f7fbe7af5ea +691796cacb789888c3e3962b54a8607b5677ba4f62ae54a9d2b66ddb1c169089112346c8eff8f8f8ba75eb0e1932a46cd9b226b3e05a37df7cb35b6f11b9e38e +3b366edc682c59b162c54183067dfdf5d79233d9b367af57afde800103e400ed9737324a72d8364732f9e0c183462c202121a1489122f6af93ce9b37efe1c387 +b364c962bf9155ab568d1f3f7ecd9a35b2644c4c8ca4b969d3a6d2034ff7b598eea6505d7b52d20e168b8e8edeb16387f31b5edc2a1bcafdb33c77eedcb66ddb +4a76a9e4c7d34859b5ff6a9f3f7f7eab56ad642d95fc1f98d22869d9b2a593d4bac8ddb26173e0c001c98d254b96c884a4aa54a9524d9a34e9d1a347b366cd3e +fcf0c32a55aa789e367329345136ccf1bc44a9e46b67d8b061d3a64ddbb76f9f91c2fefdfb3b4fa15b578a39266a36c96ae3bfb88cf972994c9c3871fdfaf5d2 +b68b8d8d954f5bb468f1ecb3cfcab4fd8eccade5496ef8b8ee35cdc459b69d3595a640a62d8d5e29bd56fbf4d34fcf9d3b976e10d620b54dd6ac59edf3c42bb5 +e8e2c58b3ff9e49375ebd69d387142367efbedb777ead4a94d9b36b7de7aebc2850ba5aef3d6015a7d2dfbbe8ef2e4faf24deb4b5cbe7cf9a38f3efaf2cb2fe5 +f0a5904862dab56b27ed43693a1a8fabca962d9b1c45ba9d521335b68b1cda5152b6e59bcb6199e6cd9b4b1936a6cb952be7f0223e732934dd065066af14ebf2 +d09e5bc7e5f995e2e2b56c6b9f2c5bb64c8afad4a9532f5cb820fd948f3ffeb840810293274f968ebaa4a478f1e2cf3cf3cc2bafbce2e1ffa8f9beddeb890d1b +368c1a354a72528a53c1820565475dbb76951ccb6879dfd4369eb7525ce4790de0e332af7c752d07f8f029274d1429c9e1e1e1d24af1657adc657c937ab16163 +c2e1c387a5e7b875eb56e951caf4993367121313e57290bab177efdee95ec21ef6f5dcad6d3c3472e448b93c1b366c68d1f6e122e2b03e72f7dd774befebe9a7 +9fdeb2658b34a9658e5c6055ab56eddcb9b393b5a4692e6bc9628f3ffeb85cc059b264d9bf7fffa2458b6ad4a8212b8e1d3b363232d27e79f948be32d37e817d +f3cd37fffefbaf4aefbbcd3067ce1ce3bbd65840da61d207983e7dbaec571ab5d249907d4903422a140ff2e09a74dac2a0aedcaf2abddf53a74ec9927ffcf187 +f44fa4ee78e38d37a44f72f0e041499ed453d210b1ff76978c32ea32698e4813bc7dfbf6f9f2e5b3351f6562e5ca9572bcd22e9756e6bc79f3f2e4c9631f84bd +74e9d273cf3d3763c68cd6ad5bbff3ce3b458b16950cd9b469932c3c7af468c9abb469763785eada9322d5bdf413ec3f9576b3f31b5edc2d1bcafdb3dca851a3 +efbfff5eaae9175f7c5172d221850f3ffcb034f1a53922ad73d96fda5b60cc71b76c18962f5f2e7d8c12254a3cf9e493d2168c888890efceafbefaaa72e5ca92 +c9e7ce9df34adacca5d044d930c7c31225ce9f3f7fdf7df7c944dfbe7d8b142922254adaf792c2efbefbeede7bef4dbbbc892bc51c1335db175f7c21e75de64b +e747bae29f7ffeb95405d2052a54a890b4a87efae9a7b7de7a4bba3d73e7cead56ad9a876b79921b3eae7b4d307d96172f5e2c3d43955e814c5b1a3d2fbd3e30 +73e6cc279e78222a2a2aa3058c9ac77ea48987b5a864be9443f9aa92df92dbf25525b9b46edd3a392392ffb2a2f410bcd25df1cdb5ecfb3acaf4f5e5b3d69714 +18292472a548fe4b574d7624adc4f1e3c74f993265c99225b2806494d436e9fe87bdbbb9e116a31dd5a3478fbc79f33efffcf3254b964cbbccb871e38c6774e4 +c891e3edb7dff64a0acdb5014c5f2996e6a13db78ecb932bc5ad6bd9d63e910a4abefbe40b4eb2ae57af5e8d1b3796dc58b66c995c05efbefbaeb45ee423c9c6 +49932699cf027fb47bcd494a4a7afdf5d7e5abbf59b36672f89287924b921b5257f4e9d3473e4a772ddfd4369eb452dce2790de0b3326ff0d9b51cbca41cd6ab +57cf61d45140494c4c7cf3cd375bb56a9533674e3f2643f62ecd3669a1d9e65cbc78517a6df3e7cf97eb74f6ecd9692398a6fb7ae66a1b4f487b63e8d0a13ffe +f8a3d7b70c771187f51df98a9236a2b46f3efef8e385c9a4b5ed64f961c38649a35c5a4e8f3efaa8fdfca79e7a6ae3c68d5249b56ddb76debc79a1a1a1b68fca +972f9feea64a2773b22ffb1577efde2ddfb87171713ffffcb35437c64cd9977ca55def105d553699ebcb57ac58d1989036cdc89123e5b7ed236985485b537eef +dab5cbfe4567b7dc728bfc7ef6d967bffefa6b6928386cd0385ea9e0a4f7ebd03890ef00a940376fdefccb2fbfd80fa29456e9ff923568d060eddab5952b57f6 +3085f627451a1c6e45e24c940de5fe598e8a8a92af0149b93462860f1fee9006691756af5e5dd2206b3df4d043ae27de3977cb8641ba104d9b3695f6aefd213f +fdf4d3926cb9e2bc9536830f4aaf399e942843972e5deebffffef1e3c7dbfed342fa00d2c497df3b77ee7458d8dc95628e899acd96a4175e78415ae752ceedfb +248f3cf2885cfe92f9f5ebd7fff5d75f6d832cccada53cc80d1fd7bdeef2e42c974b664c5fb7407a5e7a7d409ad7f6d76fba1c6ef7f3b016951565a7dbb66db3 +ef0377e8d0417ada2d5ab4307b1c8e7c762dfbb88e5266af2f9fb5be2e5fbe2cddb9fcf9f3af5ebddad6ed7cf0c107a598c91119454232eaeebbeff64a6eb84b +da5152d749d1cde84c154976e4c811293f65ca94f14a0acdb5014c5f2956e7a18d5bc765fa4a71f75ab6b54fae5cb9b261c306399b322d05b24e9d3afffcf38f +cc311690a258a14285264d9a0c1c38b068d1a22e26c68bc7a5ccb67bcde9d7afdf471f7d24255fca866d66cb962d7bf6ecd9a851a38ca2bdbea96d4cb7524cf0 +b006f04d99b7f1d9b51ca466cd9a3573e64cb9fcfd9d9074c809924b63c78e1d9f7efa694444c4c2850bfd9b9e9898981a356aa49d2f57a5a4b063c78e870e1d +8a8e8eb6ffc8745fcf5c6de389fefdfb4bad624b30fc8838ac1b0e1f3e6cbbcbd28952a54a152e5c38ed7ce3e904b56ad5924676b76eddde7df7dd12254a64b4 +914d9b36f5eddb77c18205e90e1abffdf6db972f5f2ebfe5fbc6eb8f58965a46523863c60c87db97fc7e4fa878fdf5d71dbac152a3bdfdf6dbd25690eadb88bd +da93cc193a74e8b265cbec6b3783b453d7af5fffe5975f3acc9f366d9a2cffdb6fbfa57d59a77c378c1831e2dcb973cf3efbacaceb95149ae095b2e1fa59eed5 +abd7c48913172d5a24df070e1f1d3d7af4b3cf3e5bb76e9dd943f19a83070f7ef0c10769dbdf722e264d9ae4f9fd595ee183b2e12169fbda376155720aa51f2b +699346922da666f0f04af119a9b4259169b3376fdebcd2d4bbe38e3b5e7bedb5cf3fffdcc3b5bc921b0158f706cb59f68de3c78fe7c993c7c48ae66ad1c58b17 +4b61dbba756bda8148b973e796e6843436bc127408a2b3ec561de5c0c5ebcb97adaf8f3ffef8c489133ffdf4934392b264c922e7f79e7bee71beba27b9e1a2ea +d5ab0f1a34282929c9d67b94fea4b466a5d01a7fc6c5c54911cde8f6491fa4507976a5f826853e63fa5a1e3b76ac118415460042aa2cfb8eba3134ecc081039e +c4614df3e555f9fbefbf0f1e3c78c99225693b0e5290962e5d2a3bbaee467c50db986bdbb8cbc31ac09732d9b5ec5dab56ad7af2c927a5320cccc7da3668d060 +efdebd2a39fe2885d68ae0a3b774e8d0a153a74edbb66dcba8ccbbd5d7f34a6de31649c3ac59b3d27d88107c8f38ac1b5e7cf1c5b40fc749ab79f3e65f7df555 +ba1f49abba5bb76ef21d26ad1cd99a938dbcfffefbb21d274fee90e6a67cc50e1f3edceb71d8ce9d3b7ff4d14781f95a95faf5eba79d697cb99e3a752aed47d2 +5e7ce49147c68c1993b6821b376e5cb366cdd23e704de6cba949db84b579efbdf764ad5f7ffd35dd2ad8dd149ae095b2e1fa59966f82b66ddbca51a78d208c1a +35aa4e9d3a5e7cf4aa69d252943e43bd7af51cbebce54ff9caf157aa1cf8a06c78a877efde698b8491c2e3c78f3bb4623dbc527c46ba4319c5b8b366cddaaf5f +bfa79f7efaf2e5cb0e379bbbbb9657722300ebde6039cb3e636edcbab95a54eab48e1d3b66f4d801a9e7a5b9ef95ffbf09a2b3ec561de5c0c5ebcb97ad2fe90e +3df3cc33e93e7e373c3cbc6fdfbece9fbaee496eb8483aede7ce9ddbb56b97513c7efbedb73973e6a8e4aea631fa6fcb962d111111190d07f6410a9567578a6f +52e833a6afe5ecd9b3dba68d37b738dc176ccc4c4c4cf46e825de4cbab52eae4c68d1b3ff8e083e97e5abc78f11e3d7ac8be9c6fc407b58db9b68dbb3cac017c +29935dcb5eb461c306e9f04ae5d0be7d7b7fa7257dbb77ef3e72e4c882050ba4dc3ef4d043f3e7cff7e21b263c71e5ca953d7bf69c3d7b56aea9fcf9f3e7cb97 +cfa809e5caca6815b7fa7a5ea96ddcd2b3674f695ae4cd9bd78bdb8469c461dd905174d52d83060dfae0830f060c18e0bc3bb762c58a61c38639df548b162d7a +f5eab57fff7eef8e967afcf1c7032a10705dc63087a4a4a4743feddab5abf472f7eedd6b3f50e2f4e9d39f7ffef937df7ce3b0705c5cdcc68d1ba5fdb466cd1a +277b94fa74d5aa55aef7489da7d05d5e291b6e9de53e7dfa54a952e5a79f7eb27fc4d2850b17a495396fde3c173762a90f3ffcb051a34672b0ad5bb7ae59b366 +e5ca95cb962d1b146f81f46ed9b042ba29b4e84ab14246ed1bc3030f3c70e9d225696639f467dc5acb5bb91168756f109d65df906bc178a79609266ad1f5ebd7 +4b1bddc936a539612e31f632c15976b11675f1faf265eb6bfbf6ed4e9efe56bb766d13dbf4ee774a7474b47c9f4a37de88c2cc9d3b578a715454d4ac59b3a4c3 +2c73a4f054ab56cdad71d95effd6f3fa9512f8dfcbe9ca04d772467c7955cabefaf7efef7c47d78d8cf8a0b631d7b671971535802f05e9b5ec456bd7ae6ddab4 +a9b434023608ab92ff87bb60c182cf3efb6cc3860da58dd4b367cf891327fa37490b162c90af951f7ffcd1bed5973f7f7e73356746e5d02bb58deb962d5bf6d7 +5f7f79259c05af0882384526633c4fe4baff3f79ecd831a9929c2f63dc1c74f4e8d140786240c0aa59b366d5aa553ffcf043fbb6ced4a9534b962c59b76e5d87 +854f9f3e2db5e40b2fbc70ddcda61d60eb33be2f1bb7de7a6ba3468dde7bef3dfb47f6c877649932658c87e2fb9df42bb66eddfaedb7dfca57a69cdc9d3b771e +3e7cb87cf9f2f5ead593b399ee73ebe089a0b8520cf6c37cd23286fc5cbc78d193b5822837dc92598fcbb4bc79f31a2f1231c1442d7ae2c40969f49bdb9deb38 +cb0e7cf90d7be9d2a59898988c3e755e0bf94cf5ead5376cd8d0b16347999e376f5e870e1d24cd53a64cb14561fc1ed1f3cd9512f832f1b5eccbab522a79e75b +70f24c397779725ce6da3626047e0d808c489fa875ebd6d3a64d7332e63aa048691f31628494b1912347faeb99720909094f3ef9e4175f7c2199367bf6ec5b6e +b9a5489122a1a1a167cf9eddbf7fffe6cd9b172f5eecad7df9b2b611afbefaeab061c3222222bcb84d7882386c80ca972fdf75fb7bfffdf79ffc36f7b8ba1bca +cb2fbfdca3478f8103071a1d1e69a71a2f274dbb64eedcb9c3c2c2962f5f6e6e1c8a6ff8a56cf4eddbb766cd9a5bb76ead54a992fc191f1f2fdf941f7cf081b7 +b6efb9a8a8a84792197fcaf7e5dab56be57bf4d65b6f9553dfbb776fff262f93098a2bc5b06fdf3e279f1e3870407ea7ed08b9b55610e5865b32eb719976d75d +77fdf0c30fa60795b85b8b4a37fbe4c99326d3ea32ceb2035f7ec3e6cf9f3fedcbd36d0e1f3eece1f6bda27af5eac6cb4eb76fdffee79f7fb66ad54abac73d7b +f694e9f2e5cb6fdcb851da57fe4da16fae94c09789af655f5e95d2539006a49305ce9d3be7e12e6c3c392e736d1b1302bf0640baa42a78e28927befaeaab745f +3915b01e7ae8a1cb972fefdebddb2baff93561f8f0e1f3e7cf5fbd7ab5c323daa3a3a30b142820edc0679f7dd65bfbf2656da3925f8d63eb263ba853a7ceb66d +db02e101233714e2b001eabefbee9b33674e870e1d9c2c3377eedca2458ba67d2f011c48b7b977efded3a74f37aaceefbffffec89123c67fed3a080f0f979a68 +e6cc9981dc8af54bd9906ff15ab56a0d1932c47836ff8c193322232333aacd7d6ce9d2a577de79a7f440ec674ac7ece164eddab56bdcb8b19481b4cf02866941 +71a518e6cd9bd7b973e78c3e9516aa5c26695f3ce2d65a41941b6ec9acc765da934f3e2915ef8001039c5426e7cf9fbf70e18234d6d37ee46e2d5aad5ab5152b +56387fdbbbe738cb0e7cf90d5bb366cdc58b17a7db1a11df7efbad87dbf78aead5ab4bdbe9ca952b522b56aa54c9e8a7c9cc59b366f5e9d367cb962d7e1f0de7 +9b2b25f065e26bd9975765952a557ef8e187e6cd9b67b4807ceae12e6c3c392e736d1b1302bf060822d2259146824c64cb966ddab46959b264b16847df7df7dd +8b2fbeb864c912fbb7edb9c26729cc88b4a0d4ff3f903a5d56a770c28409fdfaf5bbee7b32bdc297b58d58bd7a75baf3a569fae1871f962d5bd68bfb822b88c3 +06a81e3d7adc75d75d0b162c68dab469ba0becdebdfbedb7df969a22ed7366a3a2a24e9c38917695df7fffddebe90c0ad2d77de69967c68c1963c461c78d1b27 +dde98cee77905645e3c68d65019f352ce42be4cc9933ae2fef49d9f044dfbe7d9b34693268d0a09b6eba69f8f0e1bd7af50a900742356bd66ce1c285193d2aeb +de7bef4d4a4a3a75ead48d138775b74499e3fb2bc55ccdb668d12269891aef7a76f0cf3fff0c1d3a540ab6e76bf93e377c23f0eb43072b56ace8d6addbf1e3c7 +5bb76e3d72e448efd6812d5ab490fa44fa00cb972f4ff77dbe92f27af5ead5ae5d7bc48811e96ec1ad5af489279e78fef9e76599e2c58b67b4cc8103079c7cea +a2a03bcb96f265eb4bda24f5ebd7ffdffffe57b56a55878fce9d3b27f58cbb89b742b972e5626262366dda3477eedc56ad5a1933dbb4693379f2e4468d1a4547 +47fbbdf3e6b32bc5f7dcbd5282e59b2890dbbd9d3a75ead2a5cb4b2fbd94eed0b0f3e7cf3b7f9ea35b3c392e736d1b137c5c0304f2b78387fef8e38f9933671a +d303060cb02ec4b978f16239fb3ffcf043da7bde2f5dba643c20d1bf297462c28409458a14c96860a60f5278e8d021274f555ebb76ad17f7e5cbda4625ffd76f +461f55ac5831a05e507183200e1ba06ebffd76f9ea95fe9ed4478f3df698c3a7ebd7af97af40e910befcf2cb69d7bdedb6db3efbecb366cd9ad9e62425254d9d +3a35dd856f102fbcf082344aa48b5eaa5429f97edab16347464b3ef8e0835dbb769596cd975f7e996e686fe3c68dafbdf69a34fabd351ab45ab56ad3a64d4bfb +1eed2b57ae4c9f3e5d7a0e0ec9f0a46c7842f2e4d65b6f1d3e7cb8b4f28f1c39f2f8e38f7b77fba649464923b54a952a699f10271f75efde5dbede8c1b816f10 +ee9628737c7fa598abd9a47dd3be7dfbd9b3673ff0c003f6f3f7eedddba449939b6fbe5916f07c2ddfe7866f047e7de8e089279e3878f0a04c8c1e3dfabefbee +f37a6e4b07406a5729153366cc90ae82fd47fbf6ed93ba57d2f9e69b6f66b4ba5bb5e8a38f3e3a69d2a4860d1b4a7f3b6d6f4abec5a4f92e97c0aa55ab3c3922 +158467d952be6c7dd5ad5bb76ddbb692abdf7fffbdfd73cc2f5cb8d0aa552b292463c78ef5c63179242424e4ce3bef9402fffbefbf7ffef9e7c6ccd6ad5bbffa +eaab72b2e490bdfbbf1d26f8ec4af13d77af9460f9260ae476af54cb9206c9c3f9f3e74bc3d2fea363c78ec98599376fdebffefacbf31d29cf8ecb5cdbc6041f +d70081fcede0a1254b961813050b16ecd9b3a7457b59b060817478972d5b260535eda7d26e59bd7a754683647d934229b75251f7eddb37478e1c0e1f4d9c38f1 +adb7de92139dd17f51fb2085d24893d2dea0410387f9274f9e7cefbdf732fa5f76737c59db20001187f59deddbb7db9e60b565cb16953c4e53be8333aa6ba4a9 +942d5bb6a79e7a6acc9831f2255da14285f0f070e9e92d4c66cc4ff7ff2efaf7ef2fd587ac225fea898989b22f6990fdf3cf3f52bb496b55fe8c8a8a72f8aff2 +3ffffcf3f8f1e3f669b3898d8dad5ab5aab7be65f7ecd993f69167f67b8c898991ef60fbddc9214be28d970cca926917d8bc79b3fcdeb66ddb3df7dc93d17fe6 +c8174f8b162d860c19627c853b7f71937c81e5c993471a01b56ad56adebcb9b466222222a442941d2d5dba74d3a64d5233dabfe3cbc314befffefb92a47af5ea +3df1c413c58a15bb74e9d2eeddbb376cd8f0edb7df4ad9900a3a6d0acd950dcfcf729f3e7d3a75eaf4f3cf3fbff2ca2be90e07f38489b26123e99773dab46953 +c9c642850ac9b11f397244d23967ce9cecd9b34b9e7865e8aebf4aafbbdc2d51f21d7ff4e8d17453e8e423e5fe95e22113359b68dbb6adb438a55b22eb4acf53 +aa8253a74e2d5fbe7cca9429d5ab579f3b776eba4fac37b196b9dcf059dd2b76eedc29e9b19fe3caf565fa2cefd8b1c33636d0f54333511fda4b48484877da5b +242bd6ae5d2bbd08c9072987f7df7fbfb492253756ac58211d54c92249a1c333521cb85e8bcaf1ce9b37af65cb96521425372493655f67cf9e9532f3fdf7dfcb +1e653b23478e7458cbc767d91c9fd551e6ae2f5fb6bee4a3366dda484a9e7ffe79c961c976c9edb163c7de7df7dd924be9c6614de7866952e94909917cb08d12 +2a5ab4a87c677df4d1475dbb76f5560a4db7014c5c29becc434fda3626ea43b7ae655bdad236422485f9f3e797d51d929d76a6093e6bf79a601427b984e55295 +1dc9152dadca3367cefcf8e38f93274fae51a3c68c193372e4c8215921bbbbedb6db6cd5b88f6b1b736d1b73dcad017c59e67d5c1f4a621c1ee96b3b2ea9dea5 +53ef641772011a1303070eb4ee2554ddbb771f376e9c94c6743f3d952ca3757d93c26eddba3dfdf4d39248e998df77df7dc6d33324c15f7cf185545352a8e43b +d18f291c3d7a74fdfaf5e51aecd0a143891225e4ab5cbec457ad5af5f5d75fcb9f2b57aeac59b3a6c3e56fbaaf67bab6f18a5dbb764967d998f66e3f142e220e +eb3b0d1b36dcbf7fbf316dbccf54be23b76fdf5eba74e98c5679f9e5979b356b26dfc1f2b5ba77efdeab57af162e5cb84e9d3aebd7afbfebaebb325a4baa8f45 +8b160d1830401a5b72c5962f5f5e3a005dba74c9952b974cc8aee5db5a52627fb1c917f9df7fff6d9f369be8e868e94e7bf8fa511b691aa6fd6eb0dfa3d4aa92 +27f6b78f356edc586a07db92d25e913fedef3137fecfeaa5975e9296a593d6a1b4158c01f99239ce132955a77495a589235d20e92349cec7c7c7172c58507252 +eacad9b3673b3ca7c9c3141a6f6e193c78f03befbc73f0e041c97039cb46fb46ce4b462f533651363c3fcb52a2de78e30d3983d26374bea40926ca86411a881f +7cf081e4c0f8f1e3870c1972e8d0a1b8b838e98748abf7adb7de92969cb71aa37e2cbd6e71b7444922e5cbd848a17c2a87602b094e3e52ee5f291efa3ff6ee3b +2e8a2b6c1f3e46a55888bd001a7b0916d444a38285a85140ec157b6f18356a6cb16becbd445131f65e205812c5184b3089214645d1800a6aa26088bdc37bfd98 +e7d9779f6dee9cd99d5de0fafec167999dd93973ea7d0ecb8c40cf264175c58c74e9d2a53816a1529e3c79102121c15dba7431b1402ff728b1dc50adef75482f +4dcdb9f4cf68ec74c2a51c181828706962fda1c6dab56b512592929210c75be90b5f050a14c04c003364f4bd23468cc0c4bb50a142f5ebd7dfb367cf679f7df6 +cec365f5a2a8dbc78e1d4320be71e3c69d3b77223a77757545cea3bb407154ac5851ff10954b598c6a7d9470fb522dfa4232c2c2c2366fde8caa8b210c6f797a +7a2267f4bf1ca73c37846190c5a8aaf99764099ad8d9b3670dfeffbb580a85630007f92d45cd3c54725d02fda1acb68c1a1b17178717e8ca9a3469a23d1f410a +4b952a85c37592adbf51806a71af18549eb074ebd7af1f3972644a4a4ae1c28551d5715ecdb082ac707676461fa279a0b9cabd8d83686c23406e0fa0669d57b9 +3fc45c5ee7fb899aeb427dc0298c8d954f9f3e3d7dfa345e54ae5cb96fdfbe0a9361427c7cbcfe7739cda15a0a3ff9e4938b172f9e38710251d3c2850b131212 +d047a11d356fde7cdbb66d26820d755258af5e3dd45ecc2b972d5b86f13a2d2d0d033762bc5dbb7621c6935657759abf92b99e586f63114895d4ff3ba42f8e7f +fae9a7a6bfa64616c77558f5987eb4a53118a5e6a7937594f48422fdedd2df6af44903950a4cdc10c0188cc7a67730f399c2d27d42cd3f2f46020c0fe6eca93c +85887dd1ff9a9bb2ff25b76e282f650476e8a35bb76eadffbf24ca09d40d094255e905e6b1964b8e0136acbd72c9aa5126fee7c59c7f8731bfa52827b767d3f0 +f4f414a81e0247c9cd0dd5fa5e85e7122865e1d389f587124cffa4e7445b5bcb740207caed45b17fd774667ebecaa52c4c9d3e4a496ea8137d39a42f9cf54867 +e62914f6d80230c9d44fffe7e9e426c3c45bc2318044564b51330f155e97587f68665bd6f99b8d86c1ea2a2b847e2775e25e2502d3197ccb6056a8dfdb3888c6 +3672c9ed01d4acf32af787b1b1b162079e3871e2d5ab57783177ee5cab7eeb50b89daa964287f451cf379daca3544ba18787c7a2458b8cbdab9fc3cae77a727b +1b8b30d6ff936ab80e4b44e68a8989898c8c5cb76e9dad1342449421b117253349ff519b274f1e5b2784888814916e6cdaa04103b1bfe0aa8029245219d76189 +c85cf3e6cdebd6ad9b9b9b9bad1342449421b11725339d3973c6d1d1d152f7ab2122225bf9fefbeff1539daf728b610a8954c675582232cbeddbb777ecd821dd +6b9c8888e4622f4a667af6ecd9a44993ba77effece7b221311919d2b54a850f3e6cd2d7b2363cb620a8954c6755822322c3535353a3afaf9f3e7d2afa1a1a155 +aa54494a4a7afcf8718d1a35f85045b2679a27174b8fb2757272aa55abd63b9f5c2176149131ec45c94cb1b1b1a818d2ebc4c4c4f9f3e7bf7dfb965ffc21226d +8c5232a8b367cfda3a09efc01412a98cebb04464584c4c8cb7b7f78b172fb437faf8f820ec8b8a8af2f2f2b251ba88decddfdf3f3e3edee17f1f658b4a8bfa5c +a64c196b1c45640c7b513253404080e6a119850b176ed3a6cdac59b3f2e7cf6fdb5411915d619442449439701d96880cab52a58ae66b5c44194b5c5c9c6a4711 +19c35e94cca4e461eb449445304a2122ca1cb80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d7618988 +8888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8 +bab80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb04444444444 +4444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c87 +25222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c575582222222222222222 +2222ebe23a2c1111111111111111119175711d962863bb79f3267ebab9b9393a3ada3a2df46e2c2f5b61ce9365b146d90a739e88882c45cd3185e3171149b80e +4b8a5cbf7efddebd7b9a5fab55abe6eaeaaadad9939292309ebdf7de7bb973e72e5ab468fefcf9553bb50529ccc3d2a54be3677474b4979797c5d3161b1b8b4c +16481519c3f2b215abe63c599b1dd66db665611cf53207e69539984b59014bd9b6ec794cb1e1b92c82759bc84ab80e4b8af8fbfb63f0d3fc7aead4296f6f6f15 +cebb67cf9eafbefaeaead5abda1b0b162c78e1c20577777715126041b6ca4373b468d1e2c68d1b0e76962a3286e545995556abdb99fb7a39ea650ecc2b733097 +b20296b26dd9f39892d1b16e135909d761adae54a952b76edd925e3b3b3b5fb972055ba45fcb952b171717a779ebe2c58bd86293440abb76ed9ae675b66cd9d4 +39e9dab56b870e1dfad5575f75ebd6ad64c992397298aac6e5cb978f8888a850a1823a691360933c34537c7cbc83baa9b2fff2b267ea975766c57a686fb25add +5672bdf65f7b39ea69b3fff23226abb54a89dcf2ca9ab96450e3c68d7ffcf147e9758912253039d2ce165f5fdf13274e187bd7ceb1946dcb9ec71425ec617460 +dd26b212aec35addc18307bdbcbc56ad5a55b56ad5dcb9737ff0c1079ab78e1c39f2cf3fffe0858f8fcf92254ba47f55a0779a3d7bf6942953264d9a64cece7f +fdf5d7fdfbf733e20cc74c696969b64e8225b1bcc84a64e57ca6af87a49cddb6e54c5f7bed36e7c564faf2ca64585ec2befdf6db9f7ffe39282808017cd7ae5d +755676f06e545454972e5d162c58e0e7e7c7751f528d9a630a63512292701dd6eaaa57af8e9f55ab56d5ff327fb974d26b4f4fcfecd9b3ab9db88c292121c1c7 +c7c7d6a92022222222a2772b99eef7df7f0f0d0dfde28b2f74de2d51a2447070704040c08811236c913a222222f5701d96329eb4b434ae5913111111116520d3 +a64d0b0b0b1b3d7af49a356bb4b7efdcb9f3e4c993313131b64a181111916ab80e6bef121212962f5f7ee4c811bc78f3e64d9932655ab66c396ad4a856ad5aad +5ab54afab2ad3e8432886f4e9f3e7defdebd5cb97255a85021303070d8b061efbfffbecae93746208565cb96956e52e3907e2707edb75c5c5cae5cb9a27dcf87 +ca952b6b9ee2a5ffe559fdfd2de8d0a143ebd6adfbf9e79f1f3c7880cba955ab56af5ebd3a76ec58b56ad5f0f07094a045ce821c13be27bd9214a6a5a521df12 +1313a55fb367cfbe75ebd64e9d3a095f88447979ddbe7d1b2de5e8d1a3a824af5fbf7673736bd0a0c1a04183ead4a9a3306d124f4f4f697a2065354e14121212 +1515959494943b776ebcdbb66ddb010306e0b5c1c33359793968b5479d6bd12e4a9db714e6a1185939afbc1e9ad9b37df4d147e7cf9fc78be3c78f231f366edc +f8f4e9d3264d9a7cf3cd37458b16ddb061c3ca952b919292254bf6efdf7fc4881106fff224363ac875f7ee5d7cdaa54b977016bc7ef8f0616a6a2ada17523b76 +ecd8f2e5cbeb1fa2b93ae4368a75e6cc99070e1c400b757575f5f5f59d3a752af2d9c419cf9d3bb774e952e4242a7cb162c5d090870f1f8ecfb4c8e56854a952 +e5f2e5cbd26b4dadc08bc58b17e327f2b371e3c673e7ced5bf40b1b6fce2c58bd5ab576fdfbe1d55285bb66cf8d8ce9d3b0707073b3b3b4bff7e9b376f5ea4a7 +448912fac7a2439b3f7ffea64d9b6edebc29e5e1942953f4f390a39e95529865473d6d725ba570fb92755d6a8e2916695f66b6656d6a8e29ea40a7171a1a8af2 +ead0a10352286d4c4e4e467fb870e1c2e2c58b9b3856569d1788522c425629cb1a61a54b465e69b620bbd03549a5f9f6ed5b777777d413cdbb850a15c267e6cc +9953fb43d499210a440eea337f4c51debeec3316d561cfd197cab1a870cc66ff2b30643fb80e6bd7222323d17a4b952ad5bb77ef8a152b3a3a3aa2f7d9bf7f7f +b56ad5fefefbefc78f1feb1ff2fcf9f3810307eed8b103f1cdac59b33c3c3c3054444747639058b66cd99e3d7b6cfe1ffdc229c43c0ab1b543fa9824dd6f57f3 +167a3a0c7eda3b7ff7dd77c822833b1bdcdf529786a91d2675f8896b2958b020d280891fae175787d902460e4bcd4823222234c196f965aa3c85187eb66ddbd6 +a64d1b441e18ad31bdf1f2f252782d0e8acb0b83e5c8912391921e3d7a605845d079ebd62d6451bd7af5faf4e9b362c50a2727278529c455a3c521790811907b +9887630e8f40014130a2813367ce4c9f3e1dd383bd7bf7d6a85143fff04c565e0ee95784c980feb56817a5ce5b0af350389de6e7bc927a28ab67fbf6db6f5352 +52b065e8d0a1c8135c380a77cc9831010101984721d0477dfefaebaffffcf34fbc85825ebf7ebdcee904460731f9f2e5f3f3f36bdebcb966cbb367cf30f1936e +7dbe7bf76ebcab7388e6ea907e44ae0843274d9a84681547ad5bb70e9131a63106672069696913274e449568d5aa152e1f7988cf416e20281f376e1cdeb2d445 +014a449acd4ae582c24284bd65cb16f42148244270f41b382f42769d0305da328ac6dfdf1fe3176a08427f7450172f5e44a41e1a1a7ae4c811ec80ca863a6f70 +01e2c993278d1a35c28bf1e3c7a36ea0670b0909411e7efffdf7f5ebd7d7de93a39e95529865473d8958ab146e5fb2ae4bcd314579fb32bf2d4b541e53d4f4c9 +279f203dfdfaf5434f98376f5e6c193e7c380a1d456ce228b9755e204a514e6e29cb1a6171c9d21a59dbb66d51d5bb74e952b87061cd921f5efcf8e38fb86474 +77a824fbf6ed431dd05e84557386281039a8cffc314579fbb2cf5854c3fea32f356351b198cdfe5760c8de701dd6aea1bbc74c1b7dd37befbda7d988c065c182 +05e8fdf5f74f4d4d454773e1c2855f7ffd55fbcb501827be4cd7a2458bb367cf62a2ae46ea0d5192c28ae9a4d706efb7abad6c3a3377b6144c03d0d75fbe7c59 +fb916b4141411895113359f65ce5d3c93d4a790ae3e2e27af7ee8d2cddbf7fbf05ffb8a7a4bce6cf9f8f6112e35cd7ae5db5b7f7eddbf7fcf9f3eddbb7efd4a9 +13e251ed462440535d870c198238fb975f7ed19ed7618a8e4805436fb366cd7efbed37fd3f5367b2f2824a952a19dcae5d943a14e6a11859392f5c0fe5f66c9e +9e9ed28b972f5f9e3b770e713c5e172952a461c38677eedcc1166987cf3efb0cb3cd962d5b4e9b360d219df619e58e0ec210f16396abbf1ded0b316ef7eedd11 +2bbbb8b868bfa5b93ac4d64b962cc14fcd5ba8d22862fcbc7efdbafe6358264f9e8c9936e6ab9f7efaa96663bb76ed468f1e8d98d852eb4a12ed0a8c663268d0 +a057af5ea14e6a96d8d06f600aad7fa0dcb68c4905a60728dc53a74e6122216d6cdab429b2a54f9f3e286287f4caf6c9279f183c7cf0e0c1c80d4c0034936d1c +8519387ec6c6c66aefc951cf20bbed45ed7fd49388b54ab1f625f7bad41c5394b72ff3dbb2832dc61495cd9831233c3c1ca3d537df7c139eeee2c58b26f617a8 +f302518a72b24ad941fe08fbe1871fe2e78001030e1c38b072e54a9da3a44b46b5efdfbfbfcea28fca334481c8417de68f29cadb977dc6a21af61f7da9168b8a +c56cf6bf02437688ebb032dcbd7b57f37ff126942953c6cdcdcd22674c4c4c5cb468917e248dbe60fdfaf5faff69b569d3a6e3c78ffffefbeffa8f567474745c +bc78f1e3c78f317847454559247902ec3f85c20e1d3a8438f2d2a54bda933d4981020542434351312c322912a63c8598c9603cc668845018e565cdc49a2b3a3a +7afcf8f161616106ffb45eab56adc8c848fc444c8ce0d822674427800a2c85c2da0a152a84ecfde8a38f264c98b075eb56e527ca94e525512d0f5523dcb3ad58 +b1420ae8410a3143424234b123487ffc4f4848d089e9e58e0ed61014148428f6f2e5cbc6fe6d6de2c489da81af43fa570b31fd46d15fb97245a702fcf1c71fb3 +67cf3e72e488f6344082aa7ef4e8513464cba65f03713c9ac98e1d3b7456d92cf2c7806fbef9e6c1830767ce9cd1f9f09c3973a215d7ad5bd7f4e108f7b5a7f4 +0ee979387dfa74e41e66f59abf4dda04473d9b5073d4b348ab34b37d29b9ae0c31a6c86acbea8f292a93ee4ee0e3e383baf1f9e79f7ffdf5d7a54a9532b6b3fa +919e300bf6d82646585ce6bc79f35043f41be6850b17502bb66fdfaeb3dd7ee65fef8c1cec999db72fb152cee8d197656351b198cd7eda1765205c879561e8d0 +a1070e1c78e76ead5bb7debf7fbf45ce58a74e1df4efbebebe3a7f89c2afe838f4f75fb9722512a9df0568cc9933a74489129857d86af0b3ff140a434975efde +ddd8bf3762128861407f92a02685293c7cf870870e1d860f1f3e6bd62cfd2fb2d9cac2850bd1e24cfc7f13ae0b13b0050b16582a3a47d0602c97f2e4c93379f2 +e47efdfabd78f102730c8527ca94e525512d0f5523dcb3b9baba6a5ee7c8f1ff4664cd9fdfb537a6a6a6ea7ca0dcd141b9972f5fc6c7c73f7af4086554a44891 +c2850b4b694349193ba459b366fa1ba589684a4a8acef6a54b97060404202237f851254b961c356a14dab2f80518d7a74f9fd5ab575be98689bb76edeadfbfbf +c1ef512203c78f1fdfae5d3b13878f1d3b563f61521e262727db761d96a39e4da839ea59a4559ad9be945c5786185364b565f5c714f5d5ad5bf7f3cf3f4713ab +57af1e2ed6c49eea477ac2847b6c5923ac8787479b366d962f5faebf70869ad3aa552bfddb56da6afe251039d8333b6f5f62a59cb1a22f6bc7a262315b265edf +20ebe13aac0c965a5d35dfaa55abfcfdfd3ff8e0038429dededed5aa552b5fbebcd4dde87bf5ead5f9f3e7d1a39d3e7ddac467a2df3979f2a44d7a01fb4fa112 +51515118c94cec3073e64cd512639092146edab4293434143570c68c19f6331d8513274ecc9f3fdff43e6ddbb61d3366ccad5bb72cf2ed3663918aa4499326cf +9f3f4788a07cf52153969744b53c54874d7a3659a38342616161a88a3ffdf4d39b376f341b11fe8a5d8bf4f5c3b4b4349ded68cb53a64c3171201ab29566023d +7af4b0de536b6262624cdc5bad418306029f692c0f55c651cf26d41cf52cd22acd6c5f4aae2be38e2906db72e68e96b5a1012e5ab468ead4a9a69b98fa919e65 +99eeb1c546d8e1c387376cd8f0c68d1bda5ff6ffefbfffb66eddfadd77dfe9ec6c931a65d9c881de49b894334af4a54e2c2a10b3659d1e9b2c8bebb0760d2df6 +d2a54b870f1f46a7b371e3c6d8d8d8bb77ef56aa54c9d7d777c89021e5ca95d3de19a32f7a136c7fe7c7eafff9541df69f42251e3c7880c1c0d6a93045490ab7 +6ddb86c16ffaf4e9bd7af5faf6db6f6dfbafa6da9292928a152b667a1fe99f83eedfbf6f91e85cfb8fe1faa43f8c3f7bf64cf9893265794954cb4375d8a46793 +353a087bfbf66defdebd519dfcfcfc76efdefde1871fbabbbba33a3d7af408d3dd0b172e1c3a74c8222782bffffedb740b35f15fabf6ecf9f3e7b972e532f6ae +e9b660e738ead9849aa39e9aad52c975714cc9a0a4fb39bef37bcaea477aea5032c27a7b7b7b7979ad5ab54a7b851ac140e9d2a51b376eacb3b3ca354acdc881 +34844bd9fea32f356b9440cc96757a6cb22caec3aa0111065ab5b177a5d0d0589bc7b16dd249bfa2c7397bf62c7aa2aa55ab4e9b366decd8b19a3d0b1428903d +7bf6c8c848b1efd7a8c0fe53a804bae67ffffdd7d6a93045490a376ddad4b66d5b145ca3468d060c181012126227df0f2a5cb8b0f4505113fef9e71ffc2c58b0 +a045ce78f3e64d13ef262424e0e73b270ce6c894e525512d0fd561ab9ecdfcd141d882050b0e1e3c78ead4299d5b6261f25cb468d1dab56ba376293f8b048320 +2ec1c40e8f1f3fb6d4b9d454a44811fd87c26bdcbd7b57cdc45816473d9b5073d453b3552ab92e8e29999bfa919e3a148eb0c1c1c1a3468dc2702f4d21d3d2d2 +56af5e3d72e448fd3d55ae516a460ea4215ccaf61f7da959a3046236f6d82486ebb06a2857aedc1f7ffc61ecdfa67efffd77b45efdfb971d3d7af4e38f3f46db +d6de884945f3749d3b770e0808e8d2a58be61e403972e468d8b0e1ce9d3bedb617b0ff142a51a3468d13274e58fc09d116a42485d2578aaa54a9f2c30f3f48b7 +a4d47f4eab4d6086bc67cf9ea0a02013fbecddbbd7c3c343ff392d62f6eddbd7a74f1f63efeedfbf1f27b2c8edf93365794954cb4375a8dfb3c91d1d84ad5dbb +76f2e4c9ef7c96944554af5efdd8b163ad5bb736b603de55211916e7eded7de8d0a1eeddbb1b7cf7f0e1c32aa7c78238ead9849aa39e9aad52c975714cc9dcd4 +8ff4d4a17084c5283f76ecd82d5bb6488b50e8a9eeddbb6770ac51b946a9193990867029db7ff4a5668d1288d9d8639318aec3aaa17dfbf608df870c1962f019 +d673e6cc69dab4a9ce7dbea155ab56e1e1e1c6566febd7af9f9696969292a23dd31e376e1ca6dfbd7bf7b6db9b8fa89fc29c39733e7cf8508513f5ecd973d0a0 +4163c68c2959b2a4b17d1212124cbc6b6d164921a6b51884502d9d9d9d172e5c68f144ca2daf51a346d5ae5d3b2c2c2c3030d0e00e7171713366ccc0f86da9af +324544441c3972447a22aa8e3b77eecc9b376ffcf8f116395186282f7cec83070ff4b7fff1c71f268e522d0f85c9ad872af76c02a38398dbb76f9bb8a3e2d9b3 +67157ebeb65ebd7a0d1e3c78d8b061952a55d27ff7c99327a6ef5f66b730436ed6acd9975f7ee9e5e5a5f3d6e3c78f51db2d7e468e7a1a19a217b5e7514fcd56 +a9e4bad41c53d4695f368ce74f9c38f1f9e79f27272777e8d061c99225f6f035702575432c4a5187c211d6c9c9a97ffffecb972f97d66131d344853138d37450 +b746a91939646eeac4a2f61f7da959a3c462368bb42f3bec7bc9aab80eab869123476edab4a95dbb76bb77efce9b37af667b6a6aea175f7cf1e38f3f464545e9 +1ff5f2e54b8414d5ab57d7bfbb19dec267a2bbac52a58af676cc13860f1f8e4874fbf6ed06a7e8e7cf9f9f306102a6259a7f655599fa29c40c0a99efefefafb3 +1d79b865cb16ccbe4c3fdec17c5dbb765dbf7ebd9f9f1fe603faf7d9b972e50a06b9b4b4b493274f5ae474022c95c24f3ef9049fd0a2450b44b7b366cdb26c22 +e59657ad5ab5107c77eedc79eddab5ddba75d3390a2dab63c78ef5ebd70f0e0eb6540a11a974e9d2056db9499326dadb6fdcb8d1b265cb0a152a60078b9c2843 +9457cd9a35376fdedcaa552bcd162469e3c68da6335cb53c1426b71eaadcb3098c0e62aa56adba63c70e541e9dedfffefbef9c3973162f5eacfc141a3d7af440 +de220f0f1e3c884bd37e2b2929a97dfbf6850a15ba76ed9a05cfa88ec68d1b77ead409e5fec30f3f68dfb7f7e9d3a7b82804ee2b56acb0ec1939ea6964885ed4 +9e473d355ba592eb52734c51a77dd9309eefd9b3676262225e2c5bb6ac51a346b69a2f68535237c4a21475281f61870c19326fdebc13274e942953e6d0a143e8 +d38ceda9668d523372c8dcd48945ed3ffa52b34689c56c16695f76d8f79255711d560daeaeae478e1c41d3c5dc78e0c0811f7ffc71ce9c39636262d6ad5b77fb +f66df47ac626ccb973e74617101818e8ebeb5bbc78f1ecd9b3dfbb77ef975f7ed9b3670f3e333c3c5cffc111188f0b162c882edbc7c7a775ebd6883e1d1d1dd1 +8d5eb870e1e8d1a3d1d1d1e844f4efe02e263636169facbde5e2c58b9ad7b972e5c2f8a1ffc71ce11422bcd0fc4d5bfb440ee919e5e5e565f00f470b172e4487 +880c44ef56a24489e7cf9fc7c5c59d3b77eef0e1c3c83d0c3c62d7ae0f9fb66fdfbe76edda797a7ae25cb8048c5b8f1e3dba7af52aba720449bd7af55ab26489 +ce510279181f1faf7f7b1a73725e2085782b393959ff62314e8f193366dab469086731c545c65aeac10802e585812d6fdebc7dfbf65dbe7c39c2f4ca952be7c8 +91e3e6cd9be1e9a4ed167c183a86676420a67608083046babbbba7a4a4444646868686d6a95367efdebda8cfdafb67eef29a32650af201d98ea9516a6a2aae0b +21c89d3b77424242ba76ed8a5f9d9d9df5ff382c370fc508e7bc83503d94d5b369d276f9f2e5ba75eb6ad74fa4b0489122385c27d93a1b0546070188059b356b +86d614141454aa542914310af7e4c993070e1cc0af3ffef8a3b7b737d286b363aeebe4e4e4907ea346ec233d82166fe9673232c4e0854b151e15091506350a75 +03d7f5f0e1c39f7efa69c3860df5ead54314fefefbefeb9c4e98766331734011ae51680e1d3b76c4672204471d40c5407d4028ffc9279fa0a6198ce931e7b97f +ffbe83a13c34f19684a39e921472d4d326dc2a05da9792eb52674c91c82d2fe1b6acf298a2f1f6ed5b83af2d0b9320cdbd9ba51a82ca53ab562d63239770dd10 +8b52e4122b6581115607aa7adbb66de7ce9d2b2dc9997e44a76a3344e5d7258b0a638a92f665cfb1a8c4fea32f35635107a198cdc112ed4b9dbe97ec07d76155 +52be7cf9df7fff7df5ead5bb76ed9a3f7ffe9b376f10c10704047cf1c517e8ec0c1e82d871d1a245af5fbf5eb3660d86d8dbb76fbf7af50a2d1cfdc2f4e9d3d1 +231b0c2bd1c58c1b370e2129ba09f423376edcc0b98a152b56a95225f4b0bb77efb6e0bd9390febffefa4b7b8bf6b3025d5c5cae5cb9a23f51114e616060a0e6 +743a0f2534762e87f4fbbc5cba7469f6ecd9b366cd4a4c4cc49e6e6e6ee873511608d94d3c125140fefcf98f1d3b86e16ae3c68d3b77eec418e6eaea8aeb42b7 +8b8bad58b1a2fe210279882e1e6398cee7681f85610c01aec17fb4949b42240f43befee7ac5ab50ad351bcf83a1d32f9d4a95306f3442eb1f20a0e0e6ed5aa15 +a2704cba50a3d06a7054c3860da3a2a26ad7ae6d918469c3c08c5176e9d2a553a74ec5309f274f1e8ceea8cc5dba74d19f4264eef24260141111817c407881d0 +0769c3c466f0e0c148395ee0323149b875eb96feec48561e8a5192f302f55056cf867c934a6ac488114d9a34295bb6ac760a1156e2709d646b6f141b1d0420fe +461ee25c0882518e886851a0f5ebd7c740f6d9679f49112dd286792c7a2ae989baa884886b35c9c6cc19bf6adf2141fa46c3b061c3508d75a62ea8de61e9d6af +5f3f72e4c8949494c2850b63628076adf95e80cee984a11ce50e28c2350a1f888bdabc79f3dab56b5164680e9e9e9ea85dfa5fecd240365ebf7e5dfa7cd4377c +ac263d26de9270d45392428e7a3ac45aa540fb52785d2a8c2912b9e525dc96d51c53b4a19bc2209e9494d4b16347eb7d21cbcfcf0f638a2631f889610b39a09d +721d627543384a9145ac940546587dc3870f479d7448bf3b87e944aa3643b4c875994f85314549fbb2e75854c3cea32f9563518198cdc112ed4b9dbe97ec07d7 +61d5837e76743a33f7d7dcac00cd52eeb9d0d4ad7117331d526021462085c2a7c378897145ec58b910ee774d67e6fe021765e2df8ecc212b853a918dc6f8744a +92618258792182999fce1a49d28721d9cc8699e9cb4b7a3694fe76e9afd026989f876214e6bc583d34b36733565206334d7fa392d1412e0f0f0fc4bec6ded54f +1be60ca63fd0e0d366b505a633f374c254ee7b11a0f74867e6fe26fe07d09c7f0fe4a8a7cdfe7b51fb1ff5e4b64a25f1a1f075597b4cd190555e0adbb23a638a +367f7fff848484779e51a19b376f0a1c25563784a314f30997b2dc11569f7447f877eea6a1ce0c51f975994f85314549fbb2e7585487dd465f0eaac7a2726336 +0d25ed4b9dbe97ec07d761898888886c40fa7fd53c79f2d83a214444444464146336b220aec312111111d9c09933671c1d1d0ddea59188888888ec046336b220 +aec312111111a9edd9b36793264deadebdbb65efd94a4444444416c4988d2c8bebb04444efa679bea7390ff62583988794c5693fd639313171fefcf96fdfbe55 +edaed644990cc7142222b212c66c64555c8725227a377f7ffff8f87887ff7db827e67b31313165ca94b175ba3212e6216571da8f752e5cb8709b366d66cd9a95 +3f7f7edba68a2883e29842444456c2988dac8aebb04444ef16171767eb246478cc43cae2943c449e8874704c2122222b61cc4656c57558222222222222222222 +22ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec312111111 +1111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c111111111111111111917571 +1d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888 +888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b44 +4444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb099d9cd9b37f1d3cdcdcd +d1d1d1d66921b25f6c2959014b998888286b620c90b1b0bc882873e33aac9d8a8d8d4d4a4ac28b6ad5aab9baba8a7d48e9d2a5f1333a3adacbcbcb8269935824 +852a9ce8faf5ebf7eeddd3fc6aedd4caa25a1e9269b25a8a588db2877a98c5eb9b55fb433565f172d49689b322135f1a6511f630ea19c3f69505659a18208b60 +791151e6c675583bd5a2458b1b376ee0c5a953a7bcbdbd6d9d1c03544ba1c213f9fbfb6332a0f9d5aef2d3fe4b99f489d5287ba887ac6f9903cb512313674546 +b9b4ce9d3bbf79f3062f2a57ae3c63c68c7bf7ee0d1d3a547aab42850ab367cfb669eac896ec61d4334649fb629d2722222285b80e6b453ffcf003c2d0d7af5f +6bb60407072f5bb64cf3ebc89123972c59a2f93567ce9c478f1e6ddcb8315ec7c7c7e367b66cd9d44bae4caaa550e189ae5dbba6796d6ff969ffa54cfac46a94 +3dd443d6b7cc81e5a89181b2a27cf9f2111111152a543073ff8c7269e7ce9d93fe7bb473e7cef859a0408183070f4aab541d3a743071e0ddbb7757ac58111e1e +7eebd6add4d4d4d2a54b376fde7cc48811eeeeee5e5e5e7bf7ee2d5bb6ac2a579051c9ad5162f0f9da6ba91a88574b952ad5a64d9b71e3c6e5cf9fdfe0b1f630 +ea19a3a47d09d779222259d4e9e789c826b80e6b458d1a354270e6e7e7b76ddbb612254a20e0ab54a992f60e93264d6adfbe7d5a5adaa3478ffcfdfdbffbee3b +cb7e59009f6cc14f23caacd852b2029632d9d05f7ffd75fffefdcc379b2a53a68cb42685170ee9cb73a54b979656eea42d0621281a306080878747efdebdab55 +abf6f6eddbb8b8b8eddbb7af5cb972f5ead5172e5cf8fbefbfb90e6b9a3a352a2c2c2c3939d9c7c767d5aa5555ab56d56c47d47af1e2c565cb96eddab5ebe4c9 +93254b96b46a32ec8a589d279b630c90b1b0bc1c326fe440440e5c87b52a0467cd9a35cb912347b162c50c2eb0162c58b07efdfa78f1e79f7f3a3939356ddad4 +debe32404444446450d9b2652323231db456a02a55aa24ad49195b483d79f264b76edd468f1e3d7bf66c04489aed9f7ffe79444444505090f5534de6d27c7ba0 +6ad5aa3a71ac9f9fdfb061c35ab468d1a74f9f63c78ed92275b62150e789888888b4711dd6bab267cfeee6e6969898a8bdf1e6cd9b6fdebc2957ae9c664b4242 +82878707176189888828a3d02c3c69d6a42a57ae1c1e1eee60644deae5cb9703070e1c366cd8bc79f3f4dff5f7f70f0909e9d8b1a3d5d24b96943b77ee152b56 +54af5efdeeddbb88756d9d1c95c8adf3444444443ab80e6b75254b964c4848d0fc9a949484402d3535f5e2c58b55aa549136620713ffd5f5faf5ebf9f3e76fda +b4e9e6cd9baeaeaebebebe53a64c41d8676c7f9dfb79c97a0ac1a14387d6ad5bf7f3cf3f3f78f0e0fdf7dfaf55ab56af5ebd3029aa5ab52aa24c63ff72253785 +4a20af962d5b86c4e005e600356bd6ecddbb77e7ce9d2dbe8a7dfbf6ede5cb971f3d7a343e3e1e1788394683060d060d1a54a74e1dd3078ae5a1242d2ded830f +3ed02cdc67cf9e7debd6ad9d3a7552782d7bf7eec587bc7dfbd621fd86680b172e1c3972a4e6dd83070fb66fdf5ebabb19ceb873e7ce76eddae97c82acdc400d +976ebea653f75025ae5ebd2abd56fec80e2919c9c9c9d2afad5ab53a70e080ce3ead5bb7c6d549af2b56aca839bb44494bb173e7ce9d5bba74e9c9932751098b +152b86c21a3e7cf8471f7d646c7ff445972f5f965e6bf2012f162f5e8c9fa81b8d1b379e3b776ef9f2e5f58f35bf6e787a7ac6c4c4684e8143424242a2a2a2d0 +2ba22de3ddb66ddb0e183000af2d96110a4a193d0caeebc8912378811c40cb6dd9b2e5a851a350d356ad5a55bd7a750b2652f85c027daf99e5a5a47da1a69d3f +7fde213db751ac3367cec4b138af94c2a953a7da767450de1f9a4fbbd3f3f1f1d179d7c5c5e5ca952be8f34d7f884029a3edaf59b3e6f4e9d3f7eeddcb952b17 +5a416060e0b061c33024095f8b419a8527cd0bcd37280dae497dfbedb78f1f3f36b8082b414dcb93278f4e3a85c714b19e4d497f282be7055a8a456a9405a1e1 +e3e7df7fff6dc175583b8fbee4d67985cc1f1d948cb077efdec5a75dba740967c1eb870f1f629e829c6fd2a4c9d8b1630d56756d0239af5a1f253706506dfcca +2891b992fe5080b5cb4b27b681e2c58ba3e12393f11ac5e1eeee8e3aa979b750a14268113973e6d4fe10fbefe7e5f6a2724b59cd388a28b3e23aacd595285142 +fbfbb0e813cb952bf7fcf973bc30671df6c993278d1a35c28bf1e3c7636cb875eb16e22af4e9df7fffbd744f037d1111119a2144bffb36064942d88480093f31 +952d58b020026b045503070edcb06103623b8c4306632981140a43cf8ee4e17413274ef4f0f0484949898c8cecdbb7effaf5eb77efde6dec61110256af5e8d11 +c5cbcbab478f1e180e3100e3ba90b1f5ead5ebd3a7cf8a152b9c9c9cf48f12ce430d0c66dbb66d6bd3a64dd1a245972e5d8a701969507e39fefefe3ffcf0839f +9fdfd0a14311886bdfe50d9a376f8e6002c9ebdfbf3faeb161c3863a87cbcd0dbc25dd514ee773befbee3b6488839c6a690292814808b3110449882d4a972ead +bfcfca952ba5ff7e456c3463c60c9d77c55a8a9dc36412ad03d11226695f7ffdb5d44c8e1f3f8e106adcb87178cbe0517bf6ec91a252291f9e3e7d1a1c1cbc65 +cb16943826572f5ebc4029e31310d8e91c28ab6ea06e3f7efc18a74070863682592ee669482a8260ccface9c39337dfa74048e08ef6ad4a861a90c112b65742c +88aa4b952ad5bb77ef8a152b3a3a3aa297debf7f7fb56ad550877115964a9e927309f4bde6979792f6f5edb7dfa2d621b7fffcf3cfce9d3b638a3269d2246928 +4475420a31fc59fc6f1ee68f0e0afb4359b43b3d9d3b6c02e66fefbcb1a6dc52c630841167c78e1d1d3a7498356b16b202cd393a3a1a63104625b474cbf675d2 +88864a8b13495ba43529d41fcd166d988ff5ecd9d3d9d9d9d8074af55f6734171e53c47a36b1a304725ea0a528af5196850bcc912387c1fe418cfd475f72ebbc +12b2460725236cbe7cf9d025a2f7d36c79f6ec19ea21fa55e403ba50bc6b30850239af721f253706506dfcca2891b9707c28c6dae525c5360f1e3c409ea38174 +e9d2a570e1c2d222ac43faa2e18f3ffe88eb45954685dcb76f1faab4f6226c86e8e7057a51b9a5ac661c459459711dd6ead0575eb87041f3ebe1c387d16da183 +43b7fbc5175f481b115769dfa640dbe0c1833ffdf4d3356bd6680609f4a11839f0333636d6e021e5d3c94d2742288c10972f5fd68ea783828210b7a1873571a0 +400ac51c3f7e1cc3c0ae5dbb9a366daad9d8ae5d3b6423c60384aa085875fe622966fefcf953a74ec598dab56b57eded98d29f3f7fbe7dfbf69d3a75c2d8fcde +7befe91c289c871a71717188b6319e21ceb6e0970230e9c5f089e461eabe60c1029d77311ed7a95307d78bebfaecb3cf74de15c80d9de7d169944d67890bfa1f +1f7ef861b366cd7051c66262f77408e910fae83731b19662e7264f9e8c080c798256a9d98866327af468341383335887ff5b64a88483060d7af5ead52fbffca2 +9988a29411c6e91c25b76e68beb93364c890274f9ee0f3b56783d2a3b711daa24c7ffbed374b7da54bac941159a24b410caa5db1fbf5eb87e63366cc188b244c +f9b9e4f6bd72cb4bb87d797a7a4a2f10c72f59b2043f356fa1174211e3e7f5ebd72df84f0cb2460725fda15cda9d9efe1d36cd21ab94535353511608397efdf5 +57ed2fca0504047c99ae458b1667cf9ead56ad9ae805e992ae0ead55536da4cea454a9529a046bc310a95d1f0cd2ff93aaf09822d6b3091c2596f3022d45798d +b2a07ffef967e0c0819869172850c0221f9821a22fb9755e0959a38392113657ae5cf5ead5d34f0072fedb6fbfeddebdfbeddbb75d5c5cf477909bf3eaf75172 +6300d5c6af8c12998bf5a2c254282fc436f83960c08003070eac5cb952e703a5eb456341cfa6b3a89a21fa79b15e546e29ab19471165565c8795e1eeddbbd2ff +749856a64c19edffcf2a59b2e477df7d27bd460f8e0e6bebd6ad889010a63c7ffe5c0a6b1212127c7d7d0d7e1afa5fed099843fa1fed11df6014c11c4cfa8f30 +e50e1d3a141e1e7ee9d225fd2f3520bc0e0d0dc545e907be6aa610a64d9b76f8f061ed69b604693b7af428868ae5cb978f1a354ae159a2a3a3c78f1f1f161666 +f08fffb56ad5c27c1e3f71c9981e6bbfa5240f25888cfdfdfd718118ba1c1d1d155e883e44ed212121111111388bce5bf7efdfdfbc79f3cf3fffacb35d383754 +83917ee6cc996969699a0806310de2035c8ef42b2209148a897fc9cf4cfef8e38fd9b3671f3972447b115622351314d63b3f04b11a2ae18e1d3b74e6a23ad336 +2575031de9efbfff2e85c2da0a152a844684c29a306102fac97726d57a121313172d5aa4df601140af5fbfdeb2774e103e97acbe57acbc14b6af891327ea2cba +e17366cc9881145eb97245bf020813181d04fa439b9055ca9b366d3a7efc381a97fee39531a62c5ebcf8f1e3c7987c464545592a79e8253ef9e4938f3ffe58b3 +257ffefc3a5bb4252727172c58d0526797c5cc9e4dec288539af5a4b1176f1e245cd6b84b277eedcc1141d2d28303070e9d2a51639454689bee4d67925c44607 +cb8eb098adf4ead5ebf2e5cbfafdbc40ceabdf470953a75566acc85cac175587dcf242e6cc9b370fb5513f60be70e1026ae0f6eddb75b6db7f3f6f91ba617e29 +6794388ac83e711d5686a14387eadf204f5febd6adf7efdfaff9b54489129afbc3fefaebafcf9e3d6bd8b0e1cb972fdfbc7973f2e449e99f80106919fb1783b1 +63c7eaff815d9a7a613e63a9554e74a3ddbb7737f64f5b08b03078181b21d449a143fa3f4118fbab1a726ff4e8d1cb962d53be0ebb70e14294a0b1ffc07248cf +0d84b00b162cd019c394e4a143fa17a53b74e8307cf8f059b36659e9896d485ba74e9de6cc99a33f5e621e856aa97f1b4ae1dc504dcd9a3511f75cbf7e5d8a8a +101eedd9b3c7213ddc91feba8bd923c223635f04c864508e010101faab5112341334109497e90fe9d3a7cfead5abdff9bd1e257503419eb1b690274f9ec99327 +f7ebd7efc58b1726fe79d9daead4a98316edebebabf30d62fc8a70d94ece25abef152b2f85edab59b366fa1ba584a5a4a498b834b904460781fed0266495f2ca +952b11a8e84f113570bd88497efbed370bfe694a7fa2657aea65ab47929ad9b3891da530e7556b29c2860c19a2bfd1d5d515c38da50a3403455f72ebbc30b1d1 +41c9088be9497c7cfca3478fb0679122450a172e9c23c7ff9b2a627ffd9d0572de267d9418755a65c68accc57a5175c82d2f0f0f8f366dda2c5fbe5c7f1d16b5 +b455ab56a887fadbedbc9fb748dd30bf94334a1c45649fb80e2b83f6eaaaf93009c43cf6bffffecb972f1fa23d299c82ba75eb1e3d7ab479f3e66fdfbebd7bf7 +aeac5b7a497f5e4e4b4b13488f41515151a6bfd13073e64c591f68f11482e97f2ec3bb08f84c3ff1cc1c274e9c983f7ffe3b533266cc985bb76e69ff6d50491e +6edab4293434b45ab56a3366ccb0ea1c75dcb8711814cf9c39a37d63c1a74f9f62c4ddb76f9ffefec2b9a11a171717e4dbb973e7a4c068efdebdb840cc2e76ed +da85c906b69c3f7fbe468d1aa6bf0b9369a0bca64c9962620714d63bd7617bf4e8614ef8a5a46e185b29963469d2e4f9f3e7980adaf05b60ab56ad4258896463 +7eeeeded8d3a56be7c79693a6ae7e732d6f78a959735da97fd8c0e72fb43fb61300f5fbd7a85e2c00ceaf4e9d3268ec5acefe4c993b65ae340caa56777a8cfcc +9e4de0282be5bc355a8a30eda7e52049086b6fdebc79fcf871042d885e0e1c38a0fcd604993bfa1223363a888db0616161c8c69f7efa49bb85162952c4448d95 +9bf319a28f32cd1aad320345e662bda80d992eafe1c387376cd8f0c68d1bda5fe8c6847debd6ad9aff64d5c810fdbc45ea86ac52ceb8711491cd711dd6eaa489 +5f6262a2b40edbab572f697bf3e6cdb76cd9e2907ebb03043d2a3f5a41c783070f106cd93001e6301d4c4883e8bd7bf714e664525252b162c54cef233d8ae1fe +fdfbda49529287dbb66d432c3b7dfa74548f6fbffdd67a8b8655ab56454c3f67ce9cf0f070cdc690909072e5ca498f82d1219c1b6aaa53a7ceb973e7ba77ef8e +d718f583828272e5ca859995669dc83ea3796bf8fbefbf4d9742a952a52c752e2575c3d5d5d5c451e82a1dd21f12a234890a2092be74e9127a6c4c4a376edc18 +1b1b8b8eba52a54abebebe43860c31763b6f7b3e9770796588f625363ac8ed0fed1c668f98cb19fcdea20efdafffa8a650a142d2e34732930c91f316942d5b36 +f4e1d5d2f5efdfbf499326b8f61d3b7628fcd8cc1d7d89111b1de48eb06fdfbeedddbb37b2c2cfcf6ff7eedd1f7ef8a1bbbb3bb2e2d1a347b76eddba70e1c2a1 +43870c7e94dc9ccf6a2dc54c993232cf10bcbdbdbdbcbc56ad5aa5bd7689868698a171e3c63a3b6788daab7eddc8647114919ab80e6b75f9f3e7cf93274f4242 +42f1e2c57ffbedb79d3b774adb5bb4683171e2c4c4c444bc55b06041cc6c6d9848046dfffefbaf0d13608e274f9ebcf35dd3d1a7390a172efcce59e23ffffc83 +9f3a37b95392879b366d6adbb66d83060d30680d1830000398f5be97317efc78441e88ecab54a9825fdfbc79b378f1e2458b1619dc593837d454a74e1de946fb +31313157af5e6ddfbe7deedcb9478f1e8dd798ae9c3f7f5ef9dd2a320a7423983899d841e7f1ca4a28a91b376fde347194742397778692d6e6ececdc269df42b +32f6ecd9b398a922e89c366ddad8b16333d6b984cb2b43b42fe1d141567f68e70a1428903d7bf6c8c8480c25b64e8b51b56bd73e76ec58972e5d6c9d104bca10 +396f25886fd15eead7afbf6ad52a855f89cdf4d1971881d141ee08bb60c18283070f9e3a75aa6eddbada7bbab8b8142d5a146d163963f0a3e4e67c566e29a665 +bec83ca3080e0e460c83a6244dc3d3d2d256af5e3d72e448fd3d3344edb549ddc84c7114919ab80eab8612254a242626fef7df7f152b56d47c1fcdcbcb0b61d0 +d1a34731a7b5ed9761a1468d1a274e9c30f3a9b2b672faf4e9c0c04063effef0c30f1854947f770cb1f89e3d7b8282824cecb377ef5e0f0f0f9de71228c943e9 +0b0518c07015d29d2bf49fe06929f5ead5f3f1f1993b77aef4a49d1d3b76e0749a105f87706ea8a94e9d3a9824bc7cf972dfbe7dc843e95695d8b86bd7ae71e3 +c65dbc78d11ebeafa78eead5ab1f3b76ac75ebd6c676c0bb963a9792ba8192ead3a78fb1a3f6efdf8f43a4bfd8db04bae58f3ffe58674d0113cee6e93a77ee1c +1010d0a54b17fd7b87d9f3b984cb2b43b42fe1d141567f68e772e4c8d1b061c39d3b77daf32cb177efdea88453a74e3551a59f3c79f2f4e9d3a2458baa993025 +3244ce5b8ff440ed1b376e285c87cdf4d1975cc2a383dc1176eddab593274fd659843587dc9ccfe22dc584cc17996714684163c78eddb2658bf4c706f403f7ee +dd93fe01484786a8bd36a91b99298e225213d761d550b264c984742d5ab4d06ccc962d5bb366cd106661126bf375d89e3d7b0e1a3468cc98312652a2fcd6ab0a +ad59b3e6f3cf3f777777d77febf1e3c70822fbf7efaffcbe45a3468daa5dbb76585898b1597d5c5cdc8c1933703a9d2f4d58240f11d44a4ffd7676765eb870a1 +d825bcd3f8f1e35bb66c3973e6cc0f3ef860c1820548b3b1ffc513ce0d87f42f713c78f040ff903ffef84359f27555ac583157ae5cd1d1d1882ddab76f2f6dec +d8b1e3860d1bfcfdfd5d5c5cca972f6fd933daad5ebd7a0d1e3c78d8b061069f9bf4e4c913d3778f954549dd8888883872e488f494421d77eedc99376f1eaaa8 +a5d229a055ab56e1e1e1c66eb157bf7efdb4b4b49494148bacc3aa762ee1f2ca10ed4bc9e8607e7fa844ce9c391f3e7c68f18fd5316edcb8808080debd7bdbc3 +e2b8416ddbb645adeedcb9736464a4cea38724c8255f5f5f4c74172f5eacf3966a638a00f5735e9d1a658eab57afe2a7c1d6274b5688be64111e1de48eb0b76f +df367137f6b367cf1a7b4b20e7edbf8fb2954c169967141886101e2c5fbe5c5a875db972252a67eedcb90dee6cfffdbc92baa1843a71145126c37558352048ba +75ebd6f7df7faf73ff2c044943860c2958b0a0cdd761bb76edba7efd7a3f3f3f446ffaf78bb972e5cae0c18311f09d3c79d226c99354ac58b159b366070e1cd0 +99f6dfbb77af5dbb76882d264e9ca8fc2cb56ad5c2108559e2dab56bbb75eba6f36e545454c78e1d11fe060707ebbc65a93cfce4934ff0092d5ab4c015cd9a35 +4be1e518848a57b56a558c948827907b3d7af430b6a7706e38a43f697df3e6cd984868b6e0f2376edc68706725104c7cfcf1c7685c8823b76edd2a6decd0a1c3 +175f7cb165cb1624c3defecdd07a5094b86494efc18307759e529a9494d4be7dfb42850a5dbb76cd22e7525237860d1bd6a54b97ddbb773769d2447bfb8d1b37 +10c955a850013b582491625ebe7c89201519a87fe73bbc3572e4c84a952a49ff7e9581ce255c5e19a27d29191dccef0f95a851a3c6a64d9bf49f298c52463622 +0630fd681d33e143860f1f8e2bdabe7dbbc10f3c7ffefc840913060d1a64c3efaaecdcb913350d6d1f954a67f1eee6cd9ba887c893afbefa4aff40d5c61401ea +e7bc3a35ea9d9e3c79225db8f23bc96485e84b16e1d141ee088b0e108d51fb9b22927ffffd77ce9c39fa7f11d110c8f90cd147d944268bcc3310ccc4e7cd9b77 +e2c4893265ca1c3a7408f5d6d89ef6dfcf2ba91b4aa813471165325c8755033a4ac431af5fbff6f1f1d1de8e79e3a3478f0e1e3c8809adce21d7ae5dbb7fff3e +5e5cbc783157ae5ce88835735d136fc5c7c7dfbd7b57e7a3b09be6b5cefe1aefbdf7debe7dfb305ff5f4f4ecd9b367e3c68d0b152a84b45dbd7af5871f7ec0e0 +d4ab57af254b96284fa1008c6acf9f3f7748bf83d59e3d7baa55ab86f812030f82fefffefbefa79f7edab061c3871f7e78f4e8d13c79f2e81c1b1b1b9b949424 +37373088e6cd9bb76fdfbecb972fc76056b972e51c3972607e189e4edaaeffd52a813cc45bc9c9c9fa978cb07bcc9831d3a64d43788400b744891216bfd1feb8 +71e3909e5f7ef965c4881106bf94a421961b3065ca1484f53804a1406a6a2a721e81cb9d3b7742424210bbe3574c752cf527e53a75ea208a42da34dfe9f0f0f0 +a85bb7eeead5ab1133e9ef2fdc52c46a94d85102a44a880c47c622e791ffc58b177ff8f0a1d44cead5ab87b9d6fbefbf8fb3a3c8108e6b8a5ebb2a6aa70d72e7 +ceede5e5653079c275a353a74e6826981022858856dddddd53525222232343434351947bf7ee757474549e1bc2a5ec907ed5e5ca950b0c0cf4f5f5451ee22a10 +59a2bda00b727575c5d559f04ffd72cf25dcf70a9797acf6850f4433971efe6b3019172e5cc0cfcb972fe31314fe078392d1419bf9fda1b0850b17226128628c +0ee8d291ecb8b8b873e7ce1d3e7c18e52b3db4539b7029a3a40a162c88691be28dd6ad5b57a85001ad09fd0fb21df9101d1dddbe7d7bfd2790a809c93b7bf62c +4a0a694367f5e9a79f62ac440a314a6eddba15c9466e18fc0f77813145ac67133b4a6ece2b6c29726b94184d56e8e48343fa839e2e5dba84e03667ce9ca74e9d +d27997d19745888d447247d865cb96613e827c0e0a0a2a55aa141a176ae6c993270f1c38805f7ffcf1476f6f6ffdb0c14128e71d54eca304620035c72f7df619 +998bf587026c555e68206ddbb69d3b77aeb4ac69fa0677f6dfcf8bd50de5a5ac421c4594c9701d560de8d91103b56ad54a27f44157fef1c71fa33fd5ff3e6c40 +40c0f5ebd71dd2ff4c875e3b262646130b9a780b0383f40f62dab49fed88ce14fb1bfcfa6dfefcf98f1d3bb663c78e8d1b37eedcb9f3e1c38708f22a55aa84e1 +64c58a15152b56b4480a0574ecd81163b3437ac087601183ca37df7c83eefe9f7ffec1d41a63c3d2a54bbb77ef6e707c454afefaeb2f63b9e1e2e272e5ca1583 +690b0e0e467961ac42d87ae3c68dd7af5fbbb9b9356cd8302a2aaa76eddac6922a90871850f53f67d5aa559806e0c5d7e91001eb4f721442a03069d224d49641 +8306bd7367b1dc40581f11113175ea549c0b4332f20141dee0c183914b78818240e873ebd62d8b04b2985abc7af54af34fd312d41cccf60d2ef50ab714b11a25 +5c0f05a0ca85a55bbf7efdc89123d1f3142e5c189980b2d3fc7d1e6747a88d936a6e578d099b26853a4f83359d3cb1ba01a8788862d178514310a4a22d2336c5 +4ca04b972e965ae2142e6554a7458b16e15ad6ac5983d0fcf6eddba85de8aed1db4c9f3e1dd1b045968985cfa5a4ef152b2f59ed0b69c08c427a8d64603e805f +b5ff7356fad6d5b061c3d031620e2327b77429191db4c9ea0fc5484fb1983d7bf6ac59b3121313d1ac90f3d25a365a9ffe833a854b199325e440a74e9d30e8a0 +41a194dfbc7953ac5831f4c09878efdebddb1eee1858a040014c593127443dc49c0dd3bf42850ad5af5f7fcf9e3d9f7df699b1a304c614b19e4dec28b939afb0 +a5c8ad516202030335954de72d343a6478bb76ed264f9eacbf6ecee84b39252391ac11b65ebd7ae8fd702ef4a268416969692859b4c75dbb76a13d4aeb2ffa61 +83446ece3ba8d84709c4006a8e5ffaec3332178e0fe5b261790d1f3e1c8ddd21fd9e1ea6139921fa7981baa1bc945588a3883219aec3aaa1673a836fa14f34b8 +ddc4ff0e9b78cbc43f539803c159d774e6ec2c9642013ab172bd74661e2bcd1fc460a49f9f4ed651b2f2506796a2313e9dacf3ca8574962b57ae75ebd6efbfff +be39fb8be586f43409fdedd25f862d08818efe677e9ecee0fec22d45ac4629a9876202d3197ccb60e6abdf52c0d3d373eddab5c2e77d27e152d674cb564d9ef0 +b914f6bd02e525ab7d61ce60fad3f4bff0224cc9e8a04d6e7f28a66cd9b2ebd7af37736785a58ca9a09ddce3d28496e9641d22774c51bfc7363fe795b7145935 +4a8c7038c7e84b39852391ac11d6c3c3c3c4f3cd4dc76cb2725e43853e4a20065073fcd2679f91b96a11ac0dcb4bbadbb2f9e7b5ff7e5e6edd505ecaeac45144 +9909d76189b2a2989898c8c8c875ebd6d93a21444436c6fe9088886c8b2311655cacbd4472711d96282b9a376f5eb76edddcdcdc6c9d1022221b637f484444b6 +c59188322ed65e22b9b80e4b94e5dcbe7d7bc78e1dd2bde18988b232f6874444645b1c8928e362ed2512c07558a2cc2f3535353a3a5a7ab03884868656a95225 +2929e9f1e3c7356ad4b0f8235f890cd279f4b6939353ad5ab52cf5542e2233b13f24a2cc87236cc6c29188322ed65e22e5b80e4b94f9c5c4c4787b7bbf78f142 +7ba38f8f0fc2f4a8a8282f2f2f1ba58bb2167f7f7fe9e9f6d2c35851fd5033cb942963eb7451d6c2fe9088321f8eb0190b4722cab8587b8994e33a2c51e657a5 +4a15cd1f2d896c45e7e9f64436c1fe9088321f8eb0190b4722cab8587b8994e33a2c1111111111111111119175711d96888888888888888888c8bab80e4b4444 +44444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6 +c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c87252222222222 +22222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c +1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111 +115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822b2ae9b376fe2a79b9b9ba3a3a3add34244444444645f182d1311651d5c87 +b553b1b1b14949497851ad5a355757575b27873289ebd7afdfbb774ff3ab3ab5ab74e9d2f8191d1dede5e565a553d8e4ba3219cbe6217b30eb61de5a0f321633 +e1f7de7b2f77eedc458b16cd9f3fbfad534459c8ad5bb7d009bffffefbe5cb974725b475726ceccd9b37e8eb5ebd7a8510225fbe7cb64e0e913833476d85d1b2 +d8f8c5518f249c0510a98cebb076aa458b16376edcc08b53a74e797b7bdb3a399449f8fbfb63a0d5fc9a696a5766bd2e3559360fd983590ff3d61af6ecd9f3d5 +575f5dbd7a557b63c182052f5cb8e0eeee6eab545156909696f6cd37dfcc9b374ffa361ce4cb976fc0800193274fce9d3bb74d93661ba9a9a973e7ce9d3f7f7e +4a4a0a7ecd9123476060e0d2a54b3d3c3c6c9d342211d61eb5c5c62f8e7aa48db3002295711dd6eab265cb66e69eda5d557c7cbcac6389cc71edda35cd6bf36b +57f9f2e52322222a54a8609d445980d8759136cbe6a1fdf460f65f7be5b29fbccd34d6ae5d3b74e850cc48bb75eb56b264c91c39181abd1bda94f69c4d235fbe +7cb56ad51a387060870e1dd44f5586f3e6cd9bce9d3bfff8e38f93264d6addbab5bbbb7b4a4acab163c7a64d9b76e8d0a1c8c8c8c2850bdb3a8d6aebd1a3c7f7 +df7fbf68d1a2c0c0c05cb972fdf9e79fb366cdfae8a38fce9c3953b66c590b9e28f38d0e4a3037acc7aaa3b6d8f8c551cf8175feffcaacb30022bb9515bb5df5 +ad5ab5aa6ad5aa9a5f7d7c7c74b6481b554f179159fefaebaffbf7ef0b472a696969964d0f91f914d65eca0a66cf9e3d65ca94499326d93a2119495858587272 +b24e3c83de1ecd0d33dbae5dbb1e3c7870d3a64dfcff7ad3162d5a74faf4e95f7ffd55fa97642852a408722f3030b069d3a6fdfbf73f70e0804d13a8b66ddbb6 +a1e6fcf2cb2f952b5796b6d4ae5d1b5b7af6ecd9be7dfbdf7efb2d7bf6ec963a1747076dcc0d9b138b96c5c62f8e7a0eacf34464535c875503a6283adfc9d7df +42444444ea4b4848e09f42e5aa54a992f4423f9e69d7ae5daf5ebdfcfdfd67cd9af5d5575fd9227519c6dab56b274e9ca85984d5c89327cff2e5cb6bd7aefdcf +3fff142b56cc2669b389d5ab570f1e3c58b308ab81dc2853a6ccd6ad5b7bf4e861938411d927b1f18ba31e11916d711dd6ea72e5ca65ce1dbe107367cd1b8111 +1111d9505a5a9a05bf6447d0a04183b973e74e983061dcb8713973e6b47572ecd7ddbb773ffcf043836f55a9520535133b64a975d83ffef803d5467fbbabab6b +bf7efd424343b90e4ba44d6cfce2a84744645b5c87b5ba2b57ae942851e29dbbc5c4c4187b04c1ebd7afe7cf9fbf69d3a69b376f2212f5f5f59d32658afe9705 +b49d3c7972cd9a35a74f9fbe77ef5eae5cb92a54a8101818386cd8b0f7df7fdfe0fe08f72f5fbe2cbdd6dca6162f162f5e8c9f6fdebc69dcb831e654e5cb9757 +7e2e31988aac5ab5ead2a54b09090978fdf0e1c3d4d4543737b7264d9a8c1d3bd660c2ecf9ba3efae8a3f3e7cfe3c5f1e3c78f1e3dba71e3c6a74f9fe25abef9 +e69ba2458b6ed8b061e5ca9557af5e2d59b264fffefd478c18a11d2d952d5b56baed8ecebdcf512534b7dbb7c86dd1b53f50ffcfe62e2e2ea8db1f7cf081b1c3 +75ee1e683a499e9e9e68029add9027212121515151494949b973e7c6bb6ddbb61d306080c5ff5661d55246cb45154d4e4e967e6dd5aa95fe7f98b66eddfae0c1 +83d2eb8a152bea3c30016edfbebd7cf97264080a5dfac0060d1a0c1a34a84e9d3a064faaa4ce8b3977eedcd2a54b91930f1e3c2856ac1892377cf870d470d347 +a121e3ba8e1c39821748559932655ab66c396ad428e4125a7af5ead515a64a61ed75909ff30a1d3a7468ddba753ffffc33b211d5af56ad5abd7af5ead8b163d5 +aa55c3c3c3913f068f12181dc4ae4bec28b15256674c71d0ea4b1df42a89b11aa2a47d9999874a4607bbd2a953a7a14387c6c6c622d3b4b7ab3f2e8bd5436bf7 +5112e4068afbd34f3fd57febf7df7f777272b2605f2db1f331e5eddbb7c66e5559a952258c3548b3c295fd8c353ac8aaf39ade034583c069e6cc99883a905a69 +74983a75aafee8a03c37d49c71c82536775042202292152d6b088c5fc24739d8f1bcd22675de4c9c051091095c87b53a4c96ccd9cdd85aed93274f1a356a8417 +e3c78f777777bf75eb564848087ab7efbfffbe7efdfafafb3f7ffe7ce0c0813b76ece8d0a1c3ac59b33c3c3c30858b8e8ec6e46dd9b2657bf6ec31f87f28d82e +8d13d2bb3824383878cb962d3d7af458b76edd8b172f56ac58818e1b8381f27389c9972f9f9f9f5ff3e6cd355b9e3d7b96989888d1cbcbcb6bf7eedd7837035d +d7b7df7e9b929282cfc134f5f1e3c7d3a74f2f58b0e098316302020250ca987e8f1c39f2ebafbffef3cf3ff1564c4cccfaf5eb35c74644444877e5d3f9ccefbe +fbeeefbfff76b0dcbd86b53f50ff8ec6888d4cd76da4132194f4fa9d49dab66d1bf201bb2144e8d5abd7d6ad5b3b76ec8840a178f1e2889bcf9c39837c4020b2 +77efde1a356a28bbacffa1422963ae88b804f3f642850a2166d2ffcf5358b972e5e8d1a367cf9e8df872c68c193aefae5ebd1a3501351c351681233e103d0032 +b65ebd7a7dfaf441edc52c5de710b13a2f262d2d6de2c48928260497a8aec843d46ad45e7cfeb871e3f096b1032323231155972a55aa77efde883b1d1d1d3147 +dabf7f7fb56ad550e5501394a74d61ed15c87961a88aa8f3e1e1e1f889ba87ae0029fff9e79f513f511bd1fc317b34b80e2b777410be2eb1a3044a59cd31c521 +7ded3b2929c9c1502531564384db97f979a86474b02bd215a14bd7d9aef2b82cd6dba8d04749d0ed77eedcb96eddba3ae9c7e9faf6ed8ba69d376f5e4b9dcbc1 +eec71487f43fca9e3a75aa69d3a63adbfffdf7dfa953a7e2744870b972e5949c22a38c0e02755ed37ba07f40bdaa50a1c2a4499330bf40b48cc2c2e870f4e851 +9d353e25b9a1e68c438cd8dc418c7044242b5ad61018bfc48eb2f379a5ca755e16ce02949f822813e33aacbd1b3c78f0a79f7eba66cd1acd775ed0f376ecd811 +3f63636375764e4d4dc52074e1c2855f7ffd55fbcb1a98bf7d99ae458b1667cf9ec54442e740cd8dde202e2e0ea3c5ab57af7ef9e51774fdd2c64e9d3aa1ebb7 +c8b9c4605cc4a8a3bf1d13158cc1ddbb77c788e2e2e29251ae0b330de9c5cb972fcf9d3b87d9b543fad3391a366c78e7ce1d6c9176f8ecb3cf30eeb66cd972da +b4699aaf4b6b5f94b6b2e994a4cac4070adcd1b87c3a3377d664f59021439e3c798232d25e6f6dd3a60d46748465cd9a35fbedb7df94ff995ab5dafbe1871f22 +cddf7fffbdb1dc734f87101ce9d1995bce9f3f1fd34e449f5dbb76d5de8e3a7ffefcf9f6eddba3f6eedbb74fe7313802755ed8e4c9931123e2eab4bfccd5ae5d +3bc494fefefe26e6a243870e0d0c0c445ca89df87efdfa2d58b060cc983116499b92da2b96f3c27af5ea85f9c3e5cb97b563f4a0a0a0e9d3a7b76ddbd6c481b2 +460707d1eb12ce0db9a5acf298e290fedd13905e9b5949c4da97ac3c54323ad815cc7573e7ceadc9610d95c765b1de46853e4a82725cbf7e3d5a3aaa1fba4d8c +6ef7efdf3f73e6ccd6ad5b317b9f32658a05cf65ff630a0c1c381023488f1e3db407c4e7cf9f23793d7bf644af8879bec2536488d141acce6b7a8fe0e0e0254b +96e0a7e62d0c3408a2f0f3faf5ebda0f3117ce0d35671cc2c4e60e6284232259d1b286c0f8257094fdcf2bd5acf302380b202263b80e2bc3ddbb7735ffcd6142 +993265dcdcdc2c75528c10dad36cc0588248143d3b66da3a339c4d9b361d3f7efcf7df7fd77ff8a3a3a3e3e2c58b1f3f7e3c60c080a8a828136744ffdeb469d3 +1d3b76e8fc0388cee29745ce651141414118652f5fbe6cfa9f20ecf3ba56ac58214db3410a16434242345105487fc64f4848b0cf99b6c5a18921f3f5ef9757a8 +50a1f0f07014f18409133041557816354bb94e9d3a3367ce4c4b4bd34481880b9d9d9d376fde2cfd8a08e9d2a54b3ab5373a3a7afcf8f161616106bfac51ab56 +adc8c848fc44e73078f06063a736b3ce8bf9e38f3f66cf9e7de4c811fdffa8451f78f4e85124cfd8b18989898b162dd29fa922805ebf7ebd6def946d919c37df +a1438750b15101f4bf2851a04081d0d05064a6b129bdacd141ecba94e486dc52b69f31c54c66b62fe13cccd0a3036ae0c89123870d1b667a8d43857159acb751 +b38f6adbb62d2e1fd543fb5f56bffefaeb71e3c659f02cf63fa6684e111111e1e3e383fcc74c1e5b309a4c9d3a153d246a14fa3794b8a5ce25979aa383c2fe70 +e2c489da0b520ee9a3c38c1933303a5cb972c5d82d89d54ca144851a658c99730733298988ec59069a57aa50e7c57016404406711d5686a14387eadfd8455feb +d6adf7efdf6fa9938e1d3b56ffee6fd2043b39395967a6bd72e54a24527f00d39833674e8912257efbed371361479f3e7d56af5efdce5bce59e45c025ebe7c19 +1f1fffe8d1a33c79f2142952a470e1c2d2adc45ebc7861fa40fbbc2e575757cd6be942f2e5cba7bd83b431353555f9b93204040dc6a22594f8e4c993fbf5eb87 +b24604a3e42c6a9672cd9a35113b5ebf7e5d3a1d42cc3d7bf638a4878cd25fad2f5ebc881053e76bce0b172e444f62e23fe630299d3061c282050b4c446066d6 +79314b972e0d0808d0ffef5149c99225478d1a65f0712b0ee95169484888afafafce5fcbf12bc265cba7550e8be4bcf9900fddbb773776fb579c0bf5c4588b90 +353a885d9792dc905bcab61a538499d9be84f330238e0eaf5fbfbe71e3c6ae5dbbe6ce9ddbac5933fdffb2d4a1c2b82cd6dba8d9472d5ab468ead4a95f7df555 +972e5dd073fefbefbf98c162b0bb70e10226eac66e962a97fd8f29926cd9b2eddebd1b193260c080274f9e38a43784e1c3874f993245fa0e57c18205ad7776d3 +d41c1d14f687687dfa1ba54141f9178a2d9242890a354a223c7730939288c89e65a079a50a755e0c6701446410d76165b0e0eaaa42d27734d2d2d2b437be7af5 +eafcf9f3e8734f9f3e6de2588c49274f9e34315ef6e8d1e39d5db6a5ce254b5858183afd9f7efa49fb7e7308a7ccfc7cbbbd2ed2666c44973469d2e4f9f3e708 +a695fc655be552767171a956addab973e7a4086cefdebdd5ab57777676deb56b1766dad882c4d4a85143e78b57274e9c983f7fbee94f6edbb6ed983163303535 +f6976d73eabc30a4d0f4ffcc2279c622b055ab5649ff81dba143076f6f6fe44ff9f2e52db5dca0904572de7c515151e8d64cec3073e64c591f6870747010bd2e +25b921ab943362df6b66fb52b946a94fff867d984f2e5ebcb86fdfbedaff0a6a900ae3b2586fa35a1f151e1e8e810029d77c75a868d1a2c8169c1de7956ebd67 +9113d9ff98a2817c46bf3769d2a4ab57af3a3a3a962d5b565a0d8f8e8e7675752d5ebcb8b513608c6a6dd94afda1b1d1c1862954a146299c3b9849494464b732 +c1bcd282755e1867014464905dcc7bc922fefbef3f8c3443860c79e79e069fcc6bb7e772487f7e6eefdebdb76ddbe6e7e7b77bf7ee0f3ffcd0dddd1d23d6a347 +8f30fc5cb870e1d0a143cacfe2a0fa75913eedaf80e993be0ef6ecd93325a750bf94ebd4a98308ac7bf7ee78bd6fdfbea0a0a05cb9728586866a2230fd983229 +29a958b162a63f56fa67e4fbf7efdb64ede6efbfff367dde52a54a197b0b91f4a54b970e1f3e8ca9d1c68d1b636363efdebd5ba952255f5f5f948bc267b028a4 +72ce3f78f0001342851f620eb1eb52921bb24a3913f7bdf6df9615d27ece8993931346670bde9ac94171dd10eb6d54eba3e6ce9d3b62c408fdffdf2c58b0e0a2 +458bdab76f3f75ea548bdcbf32c3d543676767cd0d0d25e1e1e1dedede2a2c041ba35a1eda7f7f68ff29745071eee0a02c22b25b99785ea932ce0288481fd761 +338f02050a203c8d8c8c6cd0a041663a172c58b0e0e0c183a74e9daa5bb7aef6764c4e8a162d5abb76ed01030658e4442a5f17e9bb79f3a68977131212f0f39d +a18969ea973222b0952b57e2454c4cccd5ab5731b5ce9d3bf7e8d1a3f11a137b4460a3468dd239a470e1c2d2e35c4df8e79f7f1c6cf74f9a0822319931b183e9 +478a638edd269df42b3eeaecd9b3982f55ad5a75dab46963c78eb5645ae55039e75d5d5dfffdf75fe59ff34e62d7a53037cc2fe54cdcf7da7f5b56c8dacf3951 +5e37c47a1b75faa83ffffcd3d8578a1a366cf8ecd9b3ebd7af5be4d97419bd1edeb97367d7ae5da1a1a1364c836a7968fffda1fda7d041c5b98383e288c83e65 +e279a5ca380b20227d5c87cd3c72e4c881a87de7ce9d2a8c616a9e0bd6ae5d3b79f2649d40ca1a54be2ed2b76fdfbe3e7dfa187b77fffefda54b9756f8501af5 +4b191118c2fd972f5fe2eaaa54a922dd040a1b31ab1c376edcc58b17f5ff12dea851a33d7bf604050599f8d8bd7bf7222bf49fefa48eead5ab1f3b76ac75ebd6 +c676c0bb06b71f3d7af4e38f3f46ccadbdd1d5d5b579bace9d3b07040474e9d2a5448912964db09954cef91a356a9c3871a26ddbb6ca3fca34b1eb12ce0db9a5 +9c89fb5efb6fcb764e49dd10eb6dd4eca3de7befbda74f9f1a7c4bda6ea9af7f66f47a3876ec586478870e1d6c9806d5f2d0fefb43fb4fa1838a730707051191 +3dcbc4f34a9571164044fab80e9ba9a037c7f4a077efde2adc3e4fcd73ddbe7ddbc4fd40cf9e3d6bc173a9795d4a383b3b3f78f0407ffb1f7ffc61f173e5cc99 +f3e1c38716ff58832222228e1c39223d075cc79d3b77e6cd9b377efc78e56751b9942b56ac982b57aee8e868c44ceddbb7973676ecd871c3860dfefefe2e2e2e +e5cb97d73964d4a851b56bd70e0b0b0b0c0c34f8997171713366ccc01ce39d7760b4925ebd7a0d1e3c78d8b0613acf16903c79f2c4d897bc5ab56a151e1e6eec +46c0f5ebd74f4b4b4b4949b1d43aacdcdaab72cef7ecd973d0a04163c68c2959b2a4b17d1212124cbc6b26b1eb12ce0d8152ce287daf5c366ccb274e9cf8fcf3 +cf9393933b74e8b064c9125bf515ca09d70db1de46cd3e0a9fb663c70e8353596c2f58b0a0c10e5680fd8f29264c9d3a75f7eedda74e9db2ec4d09ec797450bf +3f949b1bf6df63ab3977108e88ec5c669d574a549bdd7016604ca689528804701d3653c1b461f8f0e1cd9b37dfbe7dbbc129c4f9f3e7274c988069bfe65fed32 +c4b9aa56ad8a09498b162d74b6fffbefbf73e6cc59bc78b1c2cfd7a6e6752951b366cdcd9b3763baa8d98299e1c68d1b8383832d7eae1a356a6cdab409b182ce +f6972f5f6ed9b2a564c992a61fae250b46f42e5dba60c6d5a44913eded376edc68d9b265850a15b083f2b3a85cca082c3efef863d4e13ffef863ebd6add246c4 +1c5f7cf105321045a91f79d4aa550b0156e7ce9dd7ae5ddbad5b379d77a3a2a210c061026f8de236538f1e3d9078e4e1c18307ab57afaefd5652521202cd4285 +0a5dbb764dff40541b048e3844ffbea8786be4c89108e9aa54a962a974caadbd2ae77cd7ae5dd7af5fefe7e7171111a17fa7ad2b57ae20cc45d33e79f2a4c213 +895d97706e08947246e97be5b2615beed9b3676262225e2c5bb6ac51a346192bdfb409d70db1de46cd3e0ac96ed8b0210a0817a8bdfdc71f7f1c3f7efcf4e9d3 +2db5f268ff638a41fffcf30f66e9fbf6ed437853a74e1dcb7eb83d8f0eeaf7877273c3fe7b6c35e70ec211919dcbacf34a896ab31bce028cc934510a9100aec3 +aa27262646731fc08b172f3aa43fd102fdacce131225e8b9eedfbf2fed992b572e0c159a3edac45b306fdebc82050b6250f1f1f169ddba75850a151c1d1dd121 +5eb870e1e8d1a3d1d1d1e8191b376eac73baab57af2627276ba74d2377eedc5e5e5e06ff4225762e01e89d9b356b76f3e6cda0a0a052a54aa5a6a6deb973e7e4 +c993070e1cc0af98ae787b7b23d998ae6030939eab6be7d7151f1f7ff7ee5dbcb87cf972ddba75b5275a4827e67ed253354d6c9c32650a824b8cd0189e9121d8 +01810bb2252424a46bd7aef8d5d9d959e74fcab1b1b1b80a9d8fd5bcd6af4b1a0b172e442ce2ebeb8bf1b2448912cf9f3f8f8b8b3b77eedce1c387517b310c1b +bb3a817375ead4c9d3d3b365cb96b83a8cc7eeeeee292929919191a1a1a19883edddbb1765a17388d875a9567b25483cce58b97265cdb7333c3c3c50f4ab57af +d6997e6b20dccc9b376fdfbe7d972f5f8e82c6b13972e4402b084f276dd79fa28bd579813c44d1636e8cea876a86e4a1bc8a172ffef0e1c39f7efa69c3860df5 +ead543c4f9fefbef1b6c984849b972e502030351a9701476b877efde2fbffcb267cf1e5757575c9dc15e518cdcdaeb209af362a46c6cd7ae1daa3d52882a87c8 +f5d1a34728c71f7ef8e1c48913bd7af55ab26489f621c2a383d87509e7864029abdc2aaf5cb9a2f9af02331b8b58fb929587ca47078db76fdf1a7c6d119aacd0 +e403061d8434effc3e8bcae3b2586fa35a1f8589f4aa55ab860e1d8acf44778a993feae477df7d87ae091563e4c89116398b44cd314598d48921aaf9fbefbf8f +1d3b86c006e51e11118120d0826791d8f9e820b7ce23190802a547c31b1c0270a083a18e453837d49c7108109e3b08108b889444cb02e397d851f63caf54bfce +0be32cc06013b36a944264e7b80eab1e3f3fbf5bb76e49afa527426274898989295bb6acfece010101d7af5f97f644f787dd345f9532f19643fadfdcc68d1bd7 +a953a7152b56848484dcb871e3cd9b37c58a15ab54a912facaddbb771bbc8f4ccb962dfffaeb2fedb469b8b8b860d836f84844b17309406f8e7165d1a24508aa +90871871dddddd317bd9b56bd7679f7d260d0c4836268148aaf6f319edf6ba101a62b0c78b1123463469d244bb0e209db8049c547b7ffd8df804cc4ca64e9d8a +a004631bd2d6b56bd7c18307e7cf9f1f2fb03fb20879a53d42a3e6687243f3b1e6640842d54b972ecd9e3d7bd6ac59898989d8d3cdcd4d8a1e90c3a8843afb23 +844279e96cd43e174201d45b63ff6a3d68d02044604b972ec5d521c0ca93270f867f1444972e5d0c4e7dc5ae4bb5da2b4104f6ead52bcdbf23493a76ec78f6ec +5913ff81151c1cdcaa552b445aa1a1a148e1ebd7af91f30d1b368c8a8aaa5dbbb6c143c4eabc581ebababa86a55bbf7efdc891235352520a172e8ccb416a357f +d3d66f98c80ab4655ccb9a356be6ce9d7bfbf66de40c226f4487d3a74f4734acbfd4ae84dcda2b11c8796168b3c78e1d43c0ba71e3c69d3b77228a45c6a21e62 +b281ca59b162459dfd854707e1eb12384aac94556e95818181721b8b58fb72909387ca47078db56bd76250c0e40a5d8dc5bf668290463aa9261fd0d251e5de59 +466a8ecb62f550e53e6ac08001e836172e5c8859370a0b13ef8f3ffe18f35b63ff8eaa846a638a30545a5cfbddbb770b1428e0e9e9397ffe7c64b8b18e5a213b +1f1de4d679f4ff972f5f965ea3a45091f0abf6dd33a46f860e1b360c838bfe5f6e047243cd198700e1b9831881884849b42c307e891d65cff34af5ebbc30ce02 +0c3631ab462944768eebb0ea31fd20781d26bec96fce3fb660a0424c6ffee9a4a9bb18b9e712e3e1e18158cad8bbd2df42f5d9ed75e98c761a062fc4d8d549cf +0c317f7f25b951b66c598cb266ee8ce156f84412ccbe30369bb9b3dd96b2368438fae5f2793ad30722fe9e9fcecc1389e586923c0c4c67f02d835511e1a3f4c2 +fc22564856edd5909bf34abcf7de7b5dd399b3b3c2d141ecbae41ea5a494556b9502d55e494b31330f2d323a4830c94f4848303f85b2c4c7c78b1da8668f2d56 +0fd5efa36ad6aca9f967556b53674c11b6209d6aa7b3ffd1c1fc3a7fe9d225d33be87ff55287586ea839e3904b6ceea084ac884849b4ac72b0679ff34a5bd579 +019c051864d52885c8ce711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec31291ede93c7adbc9c9a9 +56ad5a967a20351111111111111191cd711d96886ccfdfdf5f7aea8bf4804e2727a79898983265cad83a5d444444444444444496c1755822b2bdb8b8385b2781 +88888888888888c88ab80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac +8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b4444444444 +44444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c57558 +22222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c87252222222222222222 +22b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c111111 +1111111111119175711d96b28a9b376fe2a79b9b9ba3a3a3add3424444191bc714a2ac8c3d4056c0522622226be03a2c6515a54b97c6cfe8e8682f2f2f8b7f78 +6c6c6c5252125e54ab56cdd5d5d5e29f4f62582e446425561d53c852ae5fbf7eefde3dcdaf0ac7020b8e291c9e323af60059014b998888ac81ebb04416d0a245 +8b1b376ee0c5a953a7bcbdbd6d9d1cfa1f2c1722a2acccdfdffffaf5eb9a5f158e05161c53383c11111111654d5c87b5ba0a152a68cf0134f2e5cb57ab56ad81 +030776e8d041fd549169e5cb978f888840d999b97f7c7c3c7e66cb96cd9a89fa1fac51e653b35cac416e3dccdc981b4424d7b56bd734af958f05161c5332faf0 +449906a34a22222295711dd6eac2c2c29293937d7c7c56ad5a55b56a5569635a5adafdfbf7232222ba76ed7af0e0c14d9b36bdf7de7bb64d67a6873c377fe7bf +fefa0b05649f2b3eac5159873dd743f53137c8aec81a53882893c9343d00a34a13324d291311915de13aacd555aa54497a81e046e75fcfdab56bd7ab572f7f7f +ff59b3667df5d557b6481d653cac5144444444a41ca34a22222295711dd6c61a34683077eedc0913268c1b372e67ce9cb64e0e6578ac5144444444a41ca34a22 +22228be33aaced75ead469e8d0a1b1b1b155aa54d1de7ef7eedd55ab565dba7429212101af1f3e7c989a9aeae6e6d6a44993b163c7962f5f5effa3ca962d2bdd +714ce7b10f952b57be7af5aaf4dac4132170a2e5cb971f3972042fdebc7953a64c99962d5b8e1a35aa55ab564849f5ead50d1e75f2e4c9356bd69c3e7dfadebd +7bb972e5aa50a1426060e0b061c3de7fff7db10cd1f6faf56b5c727272b2f42b5272e0c0019d7d5ab76e7df0e041e975c58a1535572ad1b9ef95e90762686794 +8f8f8fcebb2e2e2e57ae5cf9e0830fde99e6f9f3e76fdab4e9e6cd9baeaeaebebebe53a64cc1279b3eca828cd5283509d4de8f3efae8fcf9f30ee965e4e9e939 +73e64c94f5eddbb7a53c9c3a75aae93c3c77eedcd2a54b511b1f3c7850ac5831cc1c860f1f8ecfb4ec75214b2f5fbe2cbdd6d425bc58bc78317ea2d5346edc18 +33168317687e4b11ae87c23d80c075292c2ff3296f9548157ab6a3478f2273a42e05d563d0a04175ead4b1480af7eedd8b46f7f6ed5b87f4bb3d2e5cb870e4c8 +919a77d13bb56fdf1e7988d7d9b367dfb97367bb76ed94a450cd521680ca101313a339052e2a2424242a2a2a29292977eedc78b76ddbb603060cc06bfd635568 +5f3a630a142f5e3c3131114583d728447777777c82e6dd42850aa107d35e7d9035a66853a7942562a3b999948fcb0ef25ba53ab5579b3a638a064a6ad9b265e1 +e1e17881d651b366cddebd7b77eedc59e706b2ca7b1bf3d9795bd62156e7058e92db0328192b5fbc78b17af5eaeddbb76398437123bb50258283839d9d9da58a +91376f5ee4738912254c244039cb469502f1a144203784cfa5662913115116c47558db737272c24f296ed6962f5f3e3f3fbfe6cd9b6bb63c7bf60cd345c4d95e +5e5ebb77efc6bb3a8744444448f778d2d9fedd77dffdfdf7df0e8656313422232311e9962a550aa13f664d8e8e8e885af6efdf5fad5a351cfbf8f163fd439e3f +7f3e70e0c01d3b7674e8d061d6ac591e1e1e4f9f3e8d8e8edeb06103a6137bf6ec31713a3361f68b881c313126c398a1952e5d5a7f9f952b578e1e3d7af6ecd9 +88d167cc98a1f32ef24433a97e677ab4334afb3e5912cc074a962c69fa139e3c79d2a85123bc183f7e3ce6f3b76eddc2bc05f1d9f7df7f5fbf7e7dd3c75a8ab1 +1aa52681dafbedb7dfa6a4a420e7fffcf34fc4d60882274d9a84781a47ad5bb70e798849a0c138382d2d6de2c48998d161e2f4f5d75fa31ee2738e1f3f8e69de +b871e3f09605af0bb55a5a7d90ea122a3ce6005bb66ce9d1a307128949c28a152b705e04dfda47c96d29c2f550b80710b82ee1f2924b61abc4b46de4c891a875 +b8164c84d0a5a05522a3ead5abd7a74f1f5c97d45e94f0f7f7ffe1871f50a531536ddbb6ad4e0ad10a4e9f3e1d1313d3bf7f7f9cb761c3860a53a866290bd8b6 +6d1bc60b9c025d50af5ebdb66edddab1634734cfe2c58b630e7ce6cc99e9d3a72f5fbe7cefdebd356ad4b0480a65b52f694c79f0e0014a0a09ebd2a54be1c285 +a5455887f4a5ab1f7ffc1169080f0fc7e1fbf6ed2b58b0a0ce57c0648d291aaa95b283d0682e8bf27159a055aa537b256a8e29128c8c682c081ef0e1d2e95088 +7dfbf65dbf7e3d86cbfcf9f36bf654d8dbc862e76d599b589d173b4a6e0f203c56223128eea4a424e4c9d4a953d14c2e5ebcb866cd9ad0d0d023478e60070c88 +c87914c73bd3a09065a34a81f8d0413437c4cee5a06229131151d6c47558dbc3b42a77eedc080175b6e7ca950b7312fdfd119a63bcefdebd3be257171717edb7 +34f778d251369de96420a6473c8a2859fb4efcfdfaf55bb060c1983163f4f74f4d4d45a871e1c2855f7ffd55fb2b030101015fa66bd1a2c5d9b36711ce9a3eef +3b7df8e187cd9a35fbfefbef8d4530eee91030213de5ca95d379b77c3a33cfa59d51faf7c932c7e0c1833ffdf45384869a893d669598bae0676c6cacdc4f1363 +ac46a949a0f67a7a7a4a2f305b5bb264097e6adec20c10b332fcbc7efdbafed3a5274f9e8c593d6a08725eb3b15dbb76a3478f46d4ae7c954d9b76138b8b8b1b +3468d0ab57af7ef9e51704f4d2c64e9d3addba754bfb108196225c0f857b0081eb122e2fb994b4caf9f3e763c286397cd7ae5db5b7a31e9e3f7fbe7dfbf6b8ae +7dfbf6297cfc88b3b373e3c68d71bda884e83075de450dac53a70ed280737df6d967ca53a866290bd054f22143863c79f2049fafbd46d3a64d9b71e3c6a17aa0 +57ffedb7df74bec8ac4efbc298829f03060c3870e0c0ca952b75d22fa50189ecdfbfbfc1e9b7ac3145a266293bc81fcd05281997c55aa53ab557a2e69802c78f +1f5fb162c5ae5dbb9a366daa7dba2fbef802a743514646466afe18a0a4b791cbfedbb286589d173b4a6e0f203656be78f1c2cfcfaf489122a74e9dca972f9fb4 +11350487239e940a1703e2279f7c627e4a845936aa14880f857343e05c12754a998888b22caec3ca70f7ee5de9ff044d2b53a68c9b9b9b999f191b1b3b72e4c8 +61c386198c038c090a0ac2887ef9f2650bfe8b5c6262e2a2458bf4d723104cac5fbf5effffce366dda84c9c3efbfffaefff8724747c7c58b173f7efc1813dda8 +a828e569c3bc62e6cc996969699a0806310d66239b376f967e457c7fe9d225ebfdc3a0f910086a2fc23aa4ffe7e0f4e9d3316b4559abb0362a56a3d4f4ceda3b +71e244ed10d6213d0f67cc98813cbc72e58ab486a2f1c71f7fcc9e3dfbc89123da1366095ae2d1a3476bd5aa65d9f46b208ec73460c78e1d3aff2ca9331d55b3 +a5588499d7a521abbcd4141d1d3d7efcf8b0b030835f7841c5888c8cc44f34d8c183072b3f1de6ed212121111111fefefe3a6fddbf7f1f9dd5cf3fff6cdb146a +935bca02305ca2daeb578042850a858787a3f94f983061ebd6ad0a5328dcbe90a5f3e6cdc3b1fa5dc7850b17b0fff6eddbcdb9cc7752bf94e58ee662c4c6658b +e486556baffa63cab469d30e1f3eacbd08ab7d3a2f2fafe5cb978f1a354afb2d81de46093b6fcb0ea2755e9d96a2216bacfce69b6f1e3c7870e6cc199d4ccb99 +3367686868ddba752d9b3613d48c2a8dc587d6c80d6bcca41cec3822222222bbc2755819860e1daa7f13347dad5bb7debf7fbfe97d5ebf7e7de3c68d5dbb76cd +9d3bb759b366faffb5a7ede5cb9708821f3d7a94274f9e22458a142e5c38478eff57702f5ebc9093fc77c09c0a61bdafafafce773df02b4207fdfd57ae5c890c +d10f9735e6cc9953a24489df7efb4d798853b3664dc4dfd7af5f974e87307dcf9e3d0ee9e18ef49d8b8b172f224c37f60522358d1d3b567b1156222dbf262727 +5b6f1d56568d529340ed45faf5374a59979292a2b37de9d2a5010101fa335849c99225317dc51451fc028cebd3a7cfead5abf58b5b879a2dc522ccbc2e0d59e5 +a5a6850b17a23736f65f8750ba7469d48d050b165864fdab4c99329d3a754269eaaf8ca096366cd850ff56832aa7509bdc5216d0b76f5f63734ef40693274fee +d7af1ffa016767672529146e5f1e1e1e6ddab459be7cb9fe721b3eb355ab5696bae5a2faa52c77341723362e5b2437ac5a7bd51f53d06318fbee2a4e377af4e8 +65cb96e9acc30af4364ad8795b7610adf3eab4140d596325c2b9fefdfb1bbc252e82a8f1e3c72bb9f3af3954882acd8f0f95e7863a3329073b8e888888c8ae70 +1d568677aeae9aa6ff1f8e989f2c5ebc1801aeb17f54090b0b4348fdd34f3f69df9509018435d66b56ad5a8580fe830f3ee8d0a183b7b777b56ad5ca972f2f85 +29fa5ebd7a75fefc79c4d6a74f9f36f199883c4e9e3ca93cb52e2e2e48cfb973e7a4007defdebd986320e24764860900b62031356ad450f8cfc5d623252c2d2d +cdb21f2b50a3d464d9da6b2c0f4f9c383165ca141307b66ddbd64aebb03d7af478e7c452e5966211e65cd73b59a9cecb82ba317ffe7cd3fba07a8c1933e6d6ad +5b16f926ddb871e3d0359d397346fb66d04f9f3e5dbd7af5be7dfbec21851a162965d38cad64499a3469f2fcf9734c8c8dadefa8d0be860f1fdeb061c31b376e +68dfe1f4bffffedbba75eb77df7d67fad4e653bf94658de6c2c4c6658be486556baffa630a3ed0f4bb13274e4c4848d0b911b6dcde4609fb6fcb62755e9d9662 +9ab1b1322626c6c49d881b3468608dc4a81655ca8d0f95e4869a332963ec2122222222bbc27558f5683f61c6c9c9c9ddddddc4ed0bdebe7ddbbb77ef6ddbb6f9 +f9f9eddebd1bd12df6c740fee8d1234c4e2e5cb870e8d021cb260fd1eda54b970e1f3e8c6065e3c68db1b1b177efde4504e6ebeb3b64c8109dfbbb61a68a7802 +dbdff9b1fa5f351253a74e1dccf7ba77ef8ed79863040505e5ca952b34345433dfb393352c35c9aa516a52b3f6fefdf7dfa6572e4a952a65a9730950bfa59046 +525252b162c54cefe3e1e1e190fe9fbc1659ff427bc4ac7ece9c39e1e1e19a8d212121e83fa5c7f7d93c856a72757535f1ae748fbf67cf9e293985c2f6e5eded +ede5e5858e547b6510c35fe9d2a51b376eac2461dad42f6559a3b91202e3b2fdd779f5c714d3a793fe4870efde3d9d7558b9bd8d12f6df96c5eabc6a2d45c0f3 +e7cfd19a8cbd6bba4484a910558ac58762b9a1fe4c8a8888c84c5c87558fac27cc2c58b0e0e0c183a74e9dd2b9ed918b8b4bd1a2456bd7ae3d60c0008ba7d0d9 +d9b94d3ae957442a67cf9e450483944f9b366decd8b19a3d0b1428903d7bf6c8c8482bfd4d5e1fe67bd20355626262ae5ebddabe7dfbdcb9738f1e3d1aaf1134 +63bea7f35f7b5981d893c454a066ed45688e8a6a6207e50f075742fd96421a850b17969e2c6fc23ffffc839f050b16b4d449c78f1f8f5689b97d952a551cd21f +30bd78f1e2458b16d94f0a5573f3e64d13ef262424e0e73b97e44c53debe828383317660809326f9696969ab57af1e3972a49254e9b049299b3f9a2b21302edb +7f9d577f4c79f2e4c93bdf35b8d224abb7512243b465b13aaf4e4b1150a44891dbb76f1b7bf7eeddbbd638a90a51a5587c28961b3699491111119983ebb0766a +eddab593274f56ed4efc478f1efdf8e38f11076b6f44dcdf3c5de7ce9d030202ba74e9a2b95f5e8e1c391a366cb873e74e35d7611130bd7cf972dfbe7d987248 +b79cc3c65dbb768d1b37eee2c58b59f0fbb0c250a0d2d42e6fdebc9b366dd23c88d952d4acbdd5ab573f76ec58ebd6ad8ded807755488631eab714d268d4a8d1 +9e3d7b8282824cecb377ef5e0f0f0fed7f4b57a85ebd7a3e3e3e73e7ce959e56b463c70e272727cd24df1e52a81af4d57dfaf431f6eefefdfb7151d2371f8529 +6f5f18d7c68e1dbb65cb166942fec30f3fdcbb774ffa82a7a5a85cca7247732504c665fbaff3ea8f29a74f9f0e0c0c34f62eea64c182050d7e3753566fa3849d +b765b13aaf664b11e0eded7de8d021637dd1e1c387554e8fa588c58762b9a1f24c8a8888c87c5c87b553b76fdf36f154cdb367cf9a38d6d9d9f9c18307fadbff +f8e30f6387b46ad52a3c3cdcd82dc0ead7af9f9696969292a21d8f62968520b577efdeea2c8056ac583157ae5cd1d1d198a1b56fdf5edad8b163c70d1b36f8fb +fbbbb8b8942f5fde82a7cb9933e7c3870f2df881f6e3cf3fffc454477a3d75ea548b2fc23a28abbd72f5ead56bf0e0c1c3860d33f894b6274f9e98bed39f0a94 +b414b17a28d0036408727363d4a851b56bd70e0b0b33b6c61117173763c60cccd32c7be7bbf1e3c7b76cd972e6cc991f7cf0c182050bc68c1963ecd6d54a5268 +ffa51c111171e4c891e6cd9bebbf75e7ce9d79f3e621a3949f45e148e4e4e4d4bf7fffe5cb974bebb02b57aec44759f639e92a97b2c0682e4c605cb655ab349f +fa63ca9a356b3efffc73777777fdb71e3f7e8cac401535767f55f37b1b25ecbc2d8bd579355b8a00f448cd9a35fbf2cb2fbdbcbc74de42ad409edb2251162016 +1f8ae5869ab1a8459c3871025d41727272870e1d962c59620f4f7a2022222be13aac9daa5ab5ea8e1d3b5ab468a1b3fddf7fff9d3367cee2c58b4d1c5bb366cd +cd9b3723c4d46c4134b971e3c6e0e0606387bc7cf912b17ef5ead58b1429a2ffd6c89123312191fef14d03c1ebf0e1c311976fdfbedd60207bfefcf90913260c +1a34c822dfce4038f2f1c71f234f30ffdcba75abb41191ca175f7cb165cb165cb265e3951a356a6cdab449ff49c4c80d9cae64c992a61f5b61cf309b925e142b +566cf4e8d1d6388592da2b578f1e3d5022a887070f1ed4794274525252fbf6ed0b152a74edda350b9e512e252d45ac1e0af4001982dcdca855abd68c19333a77 +eebc76edda6eddbae91c151515d5b163474cb62d9e2d286b3481050b16040404dcbb770f55d4d89e4a5268ffa53c6cd8b02e5dbaecdebdbb499326dadb6fdcb8 +d1b265cb0a152a6007e567513e120d193204d3784c80cb942973e8d0218b3f275de5521618cd85098ccbb66a95e6537f4ca958b162b366cd0e1c38a0b36c8dde +a35dbb76cecece269e50647e6fa3849db765b13aaf664b11d0b871e34e9d3ae14a7ff8e107ed6f433f7dfa149510c5bd62c50a5ba54d09b1f8502c37d48c452d +a267cf9e89898978b16cd9b2468d1a59e3bbed44446427b80e6b7557af5e4d4e4ec68b8b172f4a5b1055632a627add106330e2f29b376f060505952a552a3535 +f5ce9d3b274f9e44a48e5f7ffcf1476f6f6f7c60f6ecd931d5717272d23e76ca9429083b30cfc1240707623704b5383c2424a46bd7aef81509d0ffba41eedcb9 +11dc040606fafafa162f5e1c9f8c98fe975f7ed9b3678fabab6b7878b8fe972c30772d58b0a0bfbfbf8f8f4febd6ad118b3b3a3a62a272e1c285a3478f464747 +233cb2e0d34eead4a9833356ae5c59f3f76d0f0f8fba75ebae5ebd1ab1bbfefef1f1f1fa378dd2948243fa6de06ad4a861b020162e5c886900b2025151891225 +9e3f7f1e171777eedcb9c3870f231f3049d3d91fb3b2fbf7ef4b9faff3b126de122356a3345034d28b69d3a659f66b5f1a02b5173b631fe961b206330a950a3f +2f5fbe8c12d7fe66108a63dfbe7da8eaa8d2a8f3a8f9a8bd0f1f3efce9a79f366cd850af5e3d44e1efbfffbeb1c6229726f31dfe6f5d72486f415e5e5e064b41 +b8a5c8ad8712811e40ee750997971202b981497bdebc79fbf6edbb7cf97264087a8f1c397220f1e1e9a4edd678f0fab871e37af5ea85fe73c48811a6ab9c700a +55286585306df6f4f46cd9b225d289f9a4bbbb7b4a4a4a6464646868283af3bd7bf7a215e81ca272fb9220616ddbb69d3b77aeb4946fe2e13cc2638a9aa5ec20 +349a0b933b2e0be78658dd888d8d454dd0def2cef2526d4c397ffe3c3a3187f4bb58a268aa55abd6a54b17d4c062c58afdf7df7fd2e990aba8c379f2e431f139 +e6f736c2ecbf2d8bd579b94709f4004ac64a34f38e1d3b22af060d1a84ab4656200756ac58f1c9279f6034b4e03aacc2a85216e1d98d406e889d4be552d6f6f6 +ed5b83af898828f3e13aacd5f9f9f9ddb871c321fd4b37d216c437313131a6ef7d86581f81d1a2458b1046dcba750ba33b02dffaf5ebefdab5ebb3cf3e934677 +7c203eeaca952b3a4fef45d81111113175ea5404ac082c2a55aa8409dbe0c183f3e7cf8f17380a1f85cfd40e051049e35caf5fbf5eb3660da6a3b76fdf7ef5ea +15a261443cd3a74fefd9b3a77e90ed90fe5d184c0010a02300428484cb7cf3e60da6103823e630bb77efb6ecfddd9048a44af3cf8f12846567cf9e35f85f6c08 +e591873a1bb59fc68b101c05a1f30c6289f4ec8bd9b367cf9a352b3131d1c5c5c5cdcd4d9a5b622aa2ffd8d6808080ebd7af4b9f8f77f1b19a27209b784b8c58 +8d923c7dfaf4f4e9d37881a92fa6bb4a92618240ed452e2142950ec75b98a5e357edff0794bed1306cd830c4df989b699f0ef3a5b074ebd7af1f397224e68785 +0b174695c01451f36d02638d452e94fe5f7ffda5f94cedb75049f0f9060b57b8a5c8ad8712811e40ee7529292f6162b9111c1cdcaa55abe5cb97a33e20e7d1cb +e1a8860d1b464545d5ae5ddb2209d3879c9f3469125a01668cefdc592c852a94b272b87c1f1f9fa54b97229d98a6e6c99307b35334812e5dba185c1651b97d69 +0c1f3e5c7a3a0db2d4c46e4ac614d54a596c341726775c9608e48658dd404fa5394aff586307aa33a62097e2e3e31dd2577e315676eedcf99b6fbe414dfee79f +7fd052505e6838ddbb777fe71f8a64f536c2ecb92d8bd57981a3047a00256325320a9570f3e6cd6bd7ae452251133c3d3d3102ea7f915c212551a55cc2b31b81 +dc103b97caa5ac0d9786ee3d2929099d03bf0c4b4494b9711dd6eaa4385b8087878789e7de4a7f7735467ace80f94761f223bd401020278dff0f02b5850b17ca +3d4a00021dfdf47f9ecee0fe0affbdb46cd9b2988399b9b389ff52b4f83fc50bd72887f49b4f61a68117987558e36b801a726befa54b974c7fe03b9f0e1c98ce +ccd3099396d4c588b51459f550436e0f20f7ba94979718b1dcc07c697e3a6b24c9a0f7de7baf5cb972ad5bb77efffdf7cdd95f2c85d62e658bc054d9fc6145fd +f62591ee05f9cedd148e29ea94b292d15c80dc7159436e6e88d50d2535cada634a5c5c9cf6aff5d2097c8edcde4698ddb665b13a2f7094400fa070accc962d5b +8f7472cf2b8b92a85280f0ec46203704cea57e296bf8fbfb272424c83d3b111165445c8725ca42a49bc33668d0a065cb96b64e0b51a6151313131919b96edd3a +5b2784883239f636599074b72bd337acc83a981b444494e1701d96280bf9fefbeff153cd2f06126541f3e6cdebd6ad9b9b9b9bad134244991c7b9b2ce8cc9933 +8e8e8e96bae74f46c7dc2022a20c87ebb0445948a142859a376f6ebddb6212d1eddbb777ecd8213d978388c87ad8db6441cf9e3d9b346952f7eedd8ddd153d4b +616e10115146c47558a22ce4ecd9b3b64e025166939a9a1a1d1d2d3dfa1c424343ab54a9929494f4f8f1e31a356a58f546cc7648e7d1db4e4e4eb56ad532f824 +1f22924bcdde866dd94ec4c6c6a288a5d7898989f3e7cf7ffbf66d96fdc726e606111165025c8725222212171313e3ededfde2c50bed8d3e3e3e4e4e4e515151 +5e5e5e364a976df8fbfb4b4f7d911e308d4c40fe942953c6d6e922ca0cd4ec6dd896ed444040c05f7ffd25bd2e5cb8709b366d66cd9a953f7f7edba6ca56981b +44449409701d968888485c952a55345f4f239da7c0139105a9d9dbb02ddb89ebd7afdb3a097684b94144449900d76189888888888888888888ac8bebb0444444 +44444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d +5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c57558222222222222 +22222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec312 +1111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c111111111111111111 +9175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec31291b96edebc899f6e6e6e8e8e8eb64e0b11 +1111111111115146c27558223257e9d2a5f1333a3adacbcbcbd66951243636362929092faa55abe6eaea6aebe41011111111111151e6c7755822ca725ab46871 +e3c60dbc3875ea94b7b7b7ad934344444444444444991fd761adae42850ad7af5fd7df9e2f5fbe5ab56a0d1c38b043870eeaa72a837afbf6edfaf5eb376fde7c +f9f2e557af5e952d5bb66ddbb623468c78fffdf72d7ba2f2e5cb474444a0ec2cfbb1598a9a7928f75cf1f1f1f8992d5b366b268a88888888888888e8ffc77558 +ab0b0b0b4b4e4ef6f1f159b56a55d5aa55a58d696969f7efdf8f8888e8dab5ebc18307376ddaf4de7befd9369df6ef9f7ffe69d9b2e58d1b37faf5eb377af468 +2727a78b172fae5fbf7eeddab5fbf6edab53a78e05cff5d75f7fa180b80eab03f5d6fc9dd5cc43961711111111111111d939aec35a5da54a95a41755ab56d5f9 +0fe876eddaf5ead5cbdfdf7fd6ac595f7df5952d5297613c7cf8b051a346850b17be7cf972d1a245a58dcd9b37fffcf3cf478c18d1ac59b353a74e55ab56cdb6 +892422222222222222223288ebb036d6a04183b973e74e983061dcb8713973e6b47572ec577070f07befbd77e8d0a1bc79f36a6f7774745cb56a554a4a4ad7ae +5d7ffffd77fc6aab1412111111111111111119c37558dbebd4a9d3d0a143636363ab54a9a2bd1dbf5ebe7c597aad799a105e2c5ebc183fdfbc79d3b871e3b973 +e7962f5f5eff334f9e3cb966cd9ad3a74fdfbb772f57ae5c152a54080c0c1c366c98e9fba82624242c5fbefcc891237881cf2f53a64ccb962d478d1ad5aa55ab +55ab5655af5edd8247c9121313b365cb165c8ece22ac064e54b66c59ecd3a74f1f2527aa5cb9f2d5ab57a5d73e3e3e3aefbab8b85cb972e5830f3e30f109b76f +df466e1c3d7a343e3efef5ebd76e6e6e0d1a3418346890656f9b00a9a9a97bf7eeddb469d3afbffe9a9292923f7ffeaa55ab76eddab5478f1ed9b36797ee7c8a +ec42152a51a2045e237fa49ba2ea3c994afb928d3db44ae71ec7a69f6da53c0fcd679173a198e6cf9f8f9cbc79f3a6abababafafef942953f0c9260e116b5fe6 +f3f4f4449d77f8dfac46750a0909898a8a4a4a4aca9d3b37de6ddbb6ed800103f05aff5825fd8640ed7df1e2c5ead5abb76fdf8eac46adc3c776eedc393838d8 +d9d959bf122a49e1ddbb77d1cc2f5dba847e06af1f3e7c882680143669d264ecd8b13a3b7ff4d147e7cf9fc78be3c78fe372366edcf8f4e953ecf9cd37df142d +5a74c3860d2b57ae44cd2959b264fffefd478c188126634eb91011111111111129c17558db737272c2cf376fdee86cdfb3674f7272b2c3ff2e303d7dfa343838 +78cb962d3d7af458b76edd8b172f56ac58d1b871e3dbb76f6b1ff5fcf9f3810307eed8b1a343870eb366cdf2f0f0c081d1d1d11b366c58b66c193e537fb94a12 +191919181858aa54a9debd7b57ac58d1d1d131212161fffefdd5aa55fbfbefbf1f3f7e6cc1a3e442e2ebd6ad5baf5e3d633be4cf9fbf6fdfbec81685ebb0df7d +f71d92ed909ee7daf7f395e4ca95ab64c992260e5fbd7af5c89123bdbcbc5046952b57ce9933e7ad5bb72222229072240ce52595b5724949491d3b763c77ee5c +5050d092254b8a162dfadf7fff9d3a750a6747b2c3c2c21cd2d7a66bd4a851bc7871e9102443ba4fb1894b36763a1c7befde3de9b589ddf43f50200f65517eae +274f9e346ad4082fc68f1fefeeee8ef20a0909f9e8a38fbefffefbfaf5ebebef2fdcbe64d9b66d1bda0e3e0add42af5ebdb66edd8ae29e3b772e4af3e1c38767 +ce9c993e7dfaf2e5cbf7eedd8b22d63956acdf7010aabd68ecfefefea88dc893a953a7e2908b172fae59b3263434f4c891230e7a9550490af3e5cbe7e7e7d7bc +7973cd9667cf9e2526261e3c781069debd7b37ded5bcf5edb7dfa6a4a4e0f3870e1d8a9c4476152c5870cc983101010128e5e3c78fe34abffefaeb3ffffc136f +c5c4c4ac5fbf5ea49c88888888888888e4e03aaced7df7dd77b973e7ae58b1a2ce76cd8d65212e2e6ed0a041af5ebdfae5975fbcbcbca48d9d3a75ba75eb96f6 +21a9a9a99d3b77be70e1c2afbffeaafd45d48080802fd3b568d1e2ecd9b306efa33a74e8d0c0c0c02d5bb6683f31ac5fbf7e0b162c1833668cb1c48b1d25d78f +3ffed8ae5d3bd3fbf8f9f92d59b2e4e9d3a706bf2468a6b2e9a4d7faf7f3356dfefcf953a74eddb06143d7ae5db5b7f7eddbf7fcf9f3eddbb74779eddbb74ff9 +03d95ebf7eedefeffff2e5cbcb972f972e5d5ab3bd4d9b36e3c78fc7897c7d7da5f47ff2c9279a77b5ab9336ed4b36a67c3a3393a7240fe5527eaec183077ffa +e9a76bd6acd17c23b24f9f3e1d3b76c4cfd8d8589d9d95b42f59341f3e64c890274f9ea0d56bafb7a2a0c78d1bd7a1438766cd9afdf6db6f3a5ff815e8371c84 +6aef8b172fd0e88a142972ead4a97cf9f2491b9b366d1a1c1c8cdcfbecb3cf1cf42aa19214e6ca95cbe05f6290c26fbffdb67bf7eeb76fdf76717191367a7a7a +4a2fd04cce9d3be7eeee8ed7486ac3860defdcb9832dd20e4864e5ca955bb66c396dda340f0f0ffd0f27222222222222b220aec3ca70f7ee5de93fbb4d2b53a6 +8c9b9b9b999f191b1b3b72e4c861c3866956100ceadbb76fd3a64d77ecd8a1f38fcf3a4b309b366d3a7efcf8efbfffaeffe0784747c7c58b173f7efc78c08001 +515151faa7484c4c5cb46891fe2a617070f0faf5eb8d2d6e8a1d25d78d1b37340b2bc654ad5af5cd9b37488fb10547ab8a8e8e1e3f7e7c585898f697f2346ad5 +aa151919899f6bd6ac193c78b0c2738584845cbf7efdca952bc58a15d379ab70e1c2df7df7dd471f7da4f0145907aa8df6222c64cb966dfaf4e91f7ef821daa6 +ce5f4794b42f31e870703a2446677ba14285c2c3c351d013264cd8ba75abb1c3cdec37c46aef37df7cf3e0c1833367cee87c78ce9c39434343ebd6ad6bce059a +9942d38282827af5ea75f9f265fd9abf62c50a691116a4655c341fedce44fa826d424202d761898888888888c8dab80e2bc3d0a1430f1c38f0cedd5ab76ebd7f +ff7ed3fbbc7efdfac68d1bbb76ed9a3b776eb366cd66cc98617aff3e7dfaac5ebdfa9d37315cb9722512a9bf48a43167ce9c12254afcf6db6ffa0b1675ead409 +0909f1f5f5d5f9ef63fc7ae5ca15631f2876945c8f1e3d72757535bd8fb48ef3f0e1434b9d5496850b17a2dc0d2e63494a972e3d61c284050b16285f87ddb66d +dbc08103f517612579f3e69d32654a505090c2b3641163c78ed56f56d2f26b7272b2ce3aac92f625a66fdfbefa8bb0923c79f24c9e3cb95fbf7e2f5ebc707676 +36b88f99fd8658ed45f7d5bf7f7f83b7c4cd9123c7f8f1e3dff91d76f353a8ede5cb97f1f1f1e8139003458a14295cb8304ee790fefd5cfd9db5fb0d6937cd57 +77b537a6a6a69a9f0022222222222222315c8795e19dababa6e9df38b252a54a8b172feedbb7aff4401b13a4872f99dee7d5ab57e7cf9fefd3a7cfe9d3a74dec +56b162c593274feaaf13ad5ab5cadfdfff830f3ee8d0a183b7b777b56ad5ca972f2f2d52982076945cb973e77ef4e891e97da47bd15aea4149729d387162fefc +f9a6f769dbb6ed9831636eddbaa5f02955972e5dfaf2cb2f4decd0a44913259f4fd2f7bbd3d2d2b4372a6c5f629a366d6ae25d14f4f3e7cfe3e3e38dadd59ad3 +6f3888d6de9898988913271adbbf418306ef3caff929948485852d5dbaf4a79f7ed2be9b76912245f80570222222222222ca10b80eab1eede708393939b9bbbb +9b7ffb0273fcf7df7f69696943860c79e79e9f7efaa9fec68a152b5eba74e9f0e1c33ffdf4d3c68d1b636363efdebd5ba952255f5f5f7c66b972e50c7e94d851 +72e1732e5fbe1c181868621fec903d7b765bfd7371525292b12fa86a4869bb7fffbec275d8e7cf9f9bbee183ce37fec82214b62f31a6bf062e15f4b367cf149e +45acf6a21ee6ca95cbd8feeffc02bb2c6fdfbeedddbbf7b66ddbfcfcfc76efdefde1871fa2ff7cefbdf71e3d7a74ebd6ad0b172e1c3a74c882a7232222222222 +22b206aec3aac7dacf2c2a50a040f6ecd9232323cdfc269a3e6767e736e9a45f1f3d7a74f6ecd96ddbb621e5d3a64d1b3b76ac058f92c5c7c727222262fcf8f1 +26f6c10e356bd6cc93278ff2d309285cb8f0df7fff6d7a9f7ffef9073f0b162ca8f05c458b164d484830b183e977498cf2f625e0e6cd9b26de950afa9d4ba8ef +24567b8b142972fbf66d63fbdfbd7b5761aab42d58b0e0e0c183a74e9dd2b9edac8b8b0b9a43eddab5070c1860c1d3111111111111115903d761338f1c397234 +6cd870e7ce9d02eb44478f1efdf8e38f0b1428a0bdd1d5d5b579bace9d3b07040474e9d2a5448912ca8f12d0bd7bf7254b969c3d7bd6e003d321252565eddab5 +b367cf567822618d1a35dab3678fe9bbb2eeddbbd7c3c3a374e9d20acf85f2ddbf7f7faf5ebd8cedb06fdf3e85a7207d4ada973014659f3e7d8cbd8b6a80eaa4 +fc3be062b5d7dbdbfbd0a143689b06f73f7cf8b0c2546943eb9e3c79b299cffe22222222222222b24f5c87cd54c68d1b171010d0bb776fb9374c6cd5aa557878 +b8b19b51d6af5f3f2d2d2d252545674555ec2801356bd60c0c0cecd7afdfb973e7f2e6cdabf32ece3270e0c042850af5ecd953e1893472e6cc29eb915fa3468d +aa5dbb76585898b19b27c4c5c5cd983163f2e4c9efbc17f03b0d1d3a14791b1919e9ebebabff6e6262e2bc79f38c1debececfce0c103fded7ffcf187c254e993 +9b87f67f2ee1f6252c2222e2c89123cd9b37d77febce9d3b2868d35f12379358ed1d306040b366cdbefcf24b2f2f2f9dfd1f3f7e6ca2120ab87dfbb6b17be0c2 +d9b3672d782e222222222222222be13a6ca6d2b469d3e1c387376fde7cfbf6ed069747cf9f3f3f61c284418306696e232079f9f2e5e4c993ab57af5ea448119d +43f0d6c891232b55aa54a54a15fdb7048e12b372e5ca5ab56af9f9f9edddbb57fb7438d1b061c32222224e9c38e1e2e2629173418d1a35366ddae4efefafb31d +a7dbb2654bc9922575b217699b316346e7ce9dd7ae5ddbad5b379da3a2a2a23a76ec58bf7efde0e060e569ab5bb7eed0a143dbb76fbf7ffffe860d1b6abf1517 +17171010101414b46cd93283c7d6ac5973f3e6cdad5ab5d26c494b4bdbb871a34512a6436e1edaffb984db9730d4ed2e5dbaecdebd5be7d96b376edc68d9b265 +850a15b083f2b388d5dec68d1b77ead40957fac30f3f68df09fae9d3a7a89ca8872b56ac509e3649d5aa5577ecd8d1a2450b9dedfffefbef9c3973162f5e6ca9 +1311111111111111590fd761adeeead5abc9c9c97871f1e245698bb3b373ad5ab5def9bd48cd81dac74a72e7ceede5e565f013e6cd9b57b060417f7f7f1f1f9f +d6ad5b57a850c1d1d1312929e9c2850b478f1e8d8e8e6edfbe7de3c68df50fc467962b572e3030d0d7d7b778f1e2d9b367bf77efde2fbffcb267cf1e5757d7f0 +f070e921f216394a808787c7912347fcfcfc3efcf0c3fefdfbd7ab570fd7858b5ab76edda3478f0e1d3a54bb766d8b9c48b270e1c2a64d9be2a27af6ec59a244 +89e7cf9fc7c5c59d3b77eef0e1c3b8a22d5bb6e81f3261c284bc79f3f6eddb77f9f2e59d3b77ae5cb9728e1c396edebc199e4eda6efea3e14d5bbc78f1dbb76f +518eeddab56bd5aa95bbbbfbbffffe7becd8b18d1b3776efde7dd1a245c6d661a74c99d2a2450b24af5bb76ea9a9a9a857dbb76fbf73e74e484848d7ae5df12b +2aa7f6973de3e3e3f56ff4a95d1b73e5ca55a3460d835551200f85c93dd7b56bd7eedfbf2f5d8bce259878cb4141fb12d3a953274f4fcf962d5ba2d4dab46983 +824e4949898c8c0c0d0dad53a7cedebd7b71769d43c4fa0db1da8b6ad3b163477ce6a0418370d5480c7260c58a159f7cf2094ac4d83aac400a519f9b356b86f4 +040505952a550a551795f6e4c993070e1cc0af3ffef8a3b7b7373e0a29ac59b3a6939393a6de5ebe7cb96eddbada29c76e458a1441c1697fbec18d4444444444 +444496c57558abf3f3f3bb71e3065e689eb4eeecec1c1313f3cefb84b66cd9f2afbffe925eeb3ca5ddc5c5e5ca952b9a07976bcb962ddbb871e33a75eab462c5 +8a9090109cfacd9b37c58a15ab54a952b76edd76efde6df0bc75ead459b468d1ebd7afd7ac593377eedcdbb76fbf7af5aa60c1825e5e5ed3a74fefd9b3a7fe72 +8ff051c26ad4a871f1e2457c32ae6bce9c39c88472e5ca75e9d265f8f0e1ca1f7ea5c3dbdbfbd2a54bb367cf9e356b56626222cee5e6e656b76eddd5ab57a35c +8c3d263e3838b855ab56cb972f0f0d0d45ce23677054c3860da3a2a22cbb4c9c23478e55ab5675eedc79e5ca9563c78e4d4e4e2e5cb8304e71f0e0c166cd9a99 +3810ef4644444c9d3ab57dfbf64e4e4ea8155dbb761d3c7870fefcf9f102d5ccddddfdd6ad5b9a752b7f7fffab57afea7c88766dcc9d3b372a73c99225f5cf25 +968762e49e2b2020e0faf5ebd2b5e05d5c82a6359978cb41b47d293168d0201f1f9fa54b97a2d4eedcb993274f1e34049c1a35dfe01f39c4fa0d07a1da8b0f0c +0b0bdbbc79f3dab56bd109a0da787a7aa214f4bf54ab3085f5ead5433d94fec080fa999696868a5abf7efd5dbb767df6d967d2ba2d3e0a5d2b0e2f55aa14ea79 +5c5c1c368e1831a249932665cb96d57c1476c30e529f6c7a231111111111119165711dd6eae2e3e3c50e941683c4942e5d7ae1c285e6ef1f151525bd58bb76ad +b58f52a250a1423366ccf8f5d75ff3e7cf1f1d1d9d274f1eeb9dab6cd9b2ebd7af977b54c99225e7a7b3469274344827f728e9296afadbd3d2d2f4375eb97245 +2465ff4b2c0f5538d7b56bd704ded290dbbe14f2f4f434bf8929e937046a6fb66cd97aa433ff10b1147a78782c5ab4c8d8bb3ab557b3ce6b7a37131b89888888 +8888882c8eebb09491fcf7df7fcd9a358b8e8e0e0f0f8f8d8d2d5ebcb89b9b9be6dd9d3b7776ead4c986c9232289746f07abfea5848888888888882863e13a2c +65182f5ebc68d2a4c9f9f3e773e6cce9efef9f9a9a8a8d8d1a359a3c79b2a7a7e7d8b163376ddad4ac59b3fcf9f3db3aa54459dd9933671c1d1d79c755222222 +222222220daec35286f1e0c183f3e7cf7ffcf1c7bd7af56adebcb99b9b5b5c5cdcb265cb3efbecb3d7af5f972c5972ebd6ad5c8425b2b967cf9e4d9a34a97bf7 +ee96bd0b301111111111115186c67558ca30dcdddd1312124a9428a1d9e2e9e9b966cd9a193366dcbf7fbf72e5cafacf73cf6aae5cb9f2e0c103e9f5c58b179d +9d9d6bd5aaa5fff479b27357af5e4d4e4e76482f44fc74727242391a7c2a979d888d8d4d4a4a925e272626ce9f3fffeddbb7eadc259988888888888828a3e03a +2c6524da8bb01a45d2a99f183be4efefaf79e6fb9021439c9c9cae5cb952ba7469dba68ae442394acff743213aa4afc3c6c4c4942953c6d6e9322a202040f368 +acc2850bb769d366d6ac59fc723a1111111111119136aec312651ed2e21d6574717171b64e823cd7af5fb7751288888888888888ec1dd7618988888888888888 +8888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b4444 +44444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6 +c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c87252222222222 +22222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c +1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec31211111191da6edebc +899f6e6e6e8e8e8eb64e0b11111111911ab80e4b6431d7af5fbf77ef9ee6d76ad5aab9babada303db6121b1b9b9494e490857380ec01eb61a6c722cee84a972e +8d9fd1d1d15e5e5eb64e0b11111111911ab80e4b6431fefefed7af5fd7fc7aead4296f6f6f1ba6c7565ab46871e3c60d872c9c03640f580f333d163111111111 +11652c5c87b5aec68d1bfff8e38fd2eb12254adcba752b5bb66c9a777d7d7d4f9c3861ec5dca70ae5dbba6799d958b323e3ede216be700d903d6437de5cb978f +8888a850a182ad1362192c62b23777efde5db1624578783822bad4d4d4d2a54b376fde7cc48811eeeeee5e5e5e7bf7ee2d5bb6acadd34844444444b6c47558eb +faf6db6f7ffef9e7a0a0a049932675edda5567ba8877a3a2a2ba74e9b260c1023f3f3f4e268988c87afefaebaffbf7ef679a7558cae8d2d2d26c9d044bdab66d +db8001033c3c3c7af7ee5dad5ab5b76fdfc6c5c56ddfbe7de5ca95ab57afbe70e1c2df7fffcd7558222222a22c8eebb0d65532ddefbfff1e1a1afac5175fe8bc +5ba24489e0e0e0808080112346d8227544444444a4d4c99327bb75eb367af4e8d9b367e7c8f1ff47d79f7ffe794444445050900dd34644444444f683ebb06a98 +366d5a585818a2f3356bd6686fdfb9732702f79898185b258c888888889478f9f2e5c08103870d1b366fde3cfd77fdfdfd4342423a76eca87ec288888888c8de +701d560dcececea1a1a1dedede1d3a7468d2a489b431393939383878e1c285c58b173771eceddbb7972f5f7ef4e8d1f8f8f8d7af5fbbb9b93568d060d0a04175 +ead4d1dfb96cd9b2d2fdf2741e5a52b972e5ab57af4aafadf13c9343870ead5bb7eee79f7f7ef0e0c1fbefbf5fab56ad5ebd7a61ca51b56ad5f0f0f03265ca68 +ef7cf7eedd55ab565dba7429212101af1f3e7c989a9a8aeb42ce8c1d3bb67cf9f2fa9fffd1471f9d3f7f5e4abca7a7e7cc99330f1c38809c717575f5f5f59d3a +752a2ed0829723904285702294f2912347f0e2cd9b37c8b1962d5b8e1a35aa55ab564849f5ead50d1e25ab6e2827ab943590b0f9f3e76fdab4e9e6cd9b52794d +9932c55879a95c375ebc78b17af5eaeddbb75fb972255bb66cf8fcce9d3ba355a2c14a3709c99b37efe5cb974b9428a173e0c99327d7ac5973faf4e97bf7eee5 +ca95ab42850a8181819881235bcccc4cd3f6eedddba953a7b76fdf3aa4dffb12bdc4c8912335ef1e3c78b07dfbf6a827789d3d7bf69d3b77b66bd74ee713d4e9 +37aa54a982fcd1d9012f162f5e8c9f4861e3c68de7ce9d6bd926639ff5d041343714f63666e6867651faf8f8e87c888b8b0b9ac0071f7c60e24472ebbc4dea06 +f270d9b265b870bcc89d3b77cd9a357bf7ee8d46ad73cf1fe5edcb7ce894a43fb54a9980261912121215159594948414e2ddb66ddb0e183000aff58f55928762 +7d94d848247014d223eb999636e9e765f9f6db6f1f3f7e6c70115682dcc893278fa5c60822222222cab8b80eab924f3ef90433bd7efdfa5dbc7811413fb60c1f +3edccbcbab4f9f3e268ec2e4014761b71e3d7a609a913367ce5bb76e454444d4ab570f07ae58b1c2c9c9497b7fbc959c9cac3fcdfeeebbeffefefb6f07433370 +859e3f7f8e693fe6bdf8890970c1820571a29f7ffe79e0c0811b366cc0fcf3eeddbb3a2b23f9f2e5f3f3f36bdebcb966cbb367cf12131331fbc595eedebd1bef +ea9c05339c94941424fecf3fffc40c0a53b849932661d684a3d6ad5b87191a26b7165c5c1648a1129191919821972a55aa77efde152b56747474c46c76fffefd +d5aa554366626a67f028b97543098152963c79f2a451a34678317efc78777777a430242404e5f5fdf7dfd7af5f5f7f7f35eb0632d9dfdf3f2929095781693c32 +106d73cd9a35a1a1a1478e1cc10eab56adaa51a386ce9f499015d87fc78e1d1d3a7498356b968787c7d3a74fa3a3a3910fc8993d7bf658a48921613ffcf0032e +76e8d0a16ddbb6ad5ab5aaf6bbc89fd3a74f23dbfbf7ef8f126fd8b0a1cee1aaf51bb85e1ca8d90159111c1cbc65cb169c1799ffe2c50b9cab71e3c6b76fdf56 +961fffc39eeba1706e08f736b27243bb2851b1756a54ae5cb94a962c69f02c0ea2755ee5bae190be7e8aac40414f9c38118944b780aeb56fdfbeebd7af4736e6 +cf9f5fb3a7c2f625cbb66ddbd0872313debc7983e46dddbab563c78e73e7ce45c7f2f0e1c33367ce4c9f3e7df9f2e57bf7ee456fa373ac581e0af751622391d8 +51c8d87bf7ee49afcde93355eee705ecdcb9b367cf9ecececec676907246bb1e1211111151d6c47558f5cc98310373e63163c67cf3cd37e1e9301f30b1fffcf9 +f3316dc0dca96bd7aedadb31b13c7ffe7cfbf6ed3b75eab46fdfbef7de7b4ff356a54a950c7e54d97416b90a1d9858625e74f9f2e5d2a54b6b36060505616e89 +f9adc14330e7af57af9efe765c17e65addbb77c7acd2c5c545fb2d4f4f4fe90566a14b962cc14fed0460b6899fd7af5fb7d483ce0452a8c4d0a143318fc5ec5a +bb28fbf5ebb760c102d416838708d40d25044a593278f0e04f3ffd1493deecd9b34b5bfaf4e9d3b16347fc8c8d8dd5df5fb5baf1e2c50b3f3fbf22458a9c3a75 +2a5fbe7cd2c6a64d9be270a4edb3cf3ec3af55ab56fde4934fb48f4a4d4deddcb9f3850b177efdf557ed2f790504047c99ae458b1667cf9ead56ad9a893c3107 +26f38d1b3746cabffffe7b54039d779d9c9cead4a983d247294b49d5a666bfa17d605c5cdca041835ebd7af5cb2fbf787979491b71ae5bb76ebde36acd66cff5 +d0413437847b1b59b9a15d94a8d8e6ffd54ab8ceab5c378e1f3fbe62c58a5dbb76a1156b36b66bd7ee8b2fbef0f7f747071b19199933674e69bb92f6259726d3 +860c19f2e4c913e480f67a6b9b366dc68d1b876eaa59b366bffdf69bce579205f250491f253012091f553e9db177f5a9d9cf8b4163d44e95415c842522222222 +07aec3ca72f7ee5de9bf774d2b53a68c9b9b9bfe76e9ee043e3e3e98067cfef9e75f7ffd75a952a58c7d487474f4f8f1e3c3c2c20c7e19aa56ad5a9855e2e79a +356b060f1e2ce7222ce9d0a143e1e1e1972e5dd25e089014285000178bac90b51418141484d9d4e5cb973ffae823833b4c9c385167aa8379d78c19333efcf0c3 +2b57aee0a7dc4b90eb9d2914909898b868d122fd8cc295ae5fbf5effff5555ae1b4a4a19535cedc52f87f4f29a3e7d3a4a2a3636b662c58ae627c3b275e39b6f +be79f0e0c199336774fe4b3467ce9cb8a2ba75eb1a3cc5a64d9b8e1f3ffefbefbfeb3f6eded1d171f1e2c58f1f3f1e306040545494f9d765c298316342424222 +2222fcfdfd75deba7ffffee6cd9b7ffef9679ded36ec37faf6ed8b9e6dc78e1d3a596afabfddcd9751eaa1c422b961e25c16ef7b8db1489db776dd7048bf09fb +e1c387b5176125c887a3478f7a79792d5fbe7cd4a851da6f09b42f25103c201bf507a942850aa12851c413264cd8ba75abb1c3cdcc4325e52577245272943015 +fa7931c9c9c9050b16b4e007121111115166c5755819860e1d7ae0c08177eed6ba75ebfdfbf71b7c0b71ffe79f7fdea143877af5eae1d34c7cc8c2850bf13926 +feff1dd36f4cdb162c5860c375584c62bb77ef6eec868c4821a64c26d6465fbe7c89a9e9a3478ff2e4c953a44891c2850b4b8f187ef1e285b1439a356ba6bf51 +5a46494949917d01ef2290420175ead4414efafafaeafcb7387ec5c4527f7f95eb8692521e3b76acf6e297442a2fcc5a4dac7f59bb6eecdab5ab7ffffe066fd5 +87138d1f3fdee01d2157ae5c8966abbfc0a13167ce9c12254afcf6db6f1659a6479e77ead4099fa9bf4eb474e9d2860d1beadf78d186fd469f3e7d56af5ead5f +dc969251eaa1442037649d4b61df6b3e8bd4796bd70d87f45b0d18fbee6ac99225478f1ebd6cd9329d755881f6a544dfbe7d8d95084a7cf2e4c9fdfaf543591b +fbc77633f3504979c91d89941c254c857e5e98a5fe2387888888883237aec3ca606c7555969933672e5ab468ead4a9a643f613274ecc9f3fdff447b56ddb76cc +9831b76eddb2e0b78a64898a8ac27cd5c40eb85883dbc3c2c270e04f3ffd243d0b4552a44811b1d52be99b3869696902c71a63d9149ab66ad52a7f7f7f146287 +0e1dbcbdbdab55ab56be7c796909c62095eb8670291b63babcd4a91b31313113274e34765483060df437be7af5eafcf9f37dfaf4397dfab4893356ac58f1e4c9 +9396aa27e3c68dab5ebdfa993367b46f63faf4e9d3d5ab57efdbb74f7f7f1bf61b3d7af4b0ea425bc6aa87b27243e05c16cf0d832c55e7ad5d371cd26bb5e977 +d1de131212746e832bb77d29a1ff5d5d6d4d9a3479fefc797c7cbcb1b55a73f2506179c91d89941c655916ece795a441bbfd121111111119c37558b54977fa33 +f1300749525252b162c54cefe3e1e1e190fe1f94b65a877df0e041912245641df2f6eddbdebd7b6fdbb6cdcfcf6ff7eedd9873babbbb6302f3e8d1a35bb76e5d +b870e1d0a143564aaddda610b3e24b972e1d3e7cf8a79f7edab871636c6cecddbb772b55aae4ebeb3b64c89072e5cae9ecaf72dd102865316ae6fcf3e7cf73e5 +ca65ec5d575757fd8dfffdf71fe6f92891777ef8a79f7eaa28715aaa56adeaefef3f67ce9cf0f070cdc6909010d40ae9c1533a3244bf212653d643e173a9931b +36a9f3624c5766e9ee0df7eeddd3598795dbbe9430d8ab6848772f7df6ec999253282c2fb9239192a3d421d0cf0b2b54a890f4283c2222222222d3b80e6ba70a +172efcce98fe9f7ffec14f1bde920cd3987ffffd57d6210b162c3878f0e0a953a7746ecde6e2e252b468d1dab56b0f1830c0a26994cd26297476766e934efaf5 +d1a34767cf9eddb66d5bd5aa55a74d9b3676ec58ed9d55ae1b02a52c46cd9c2f52a4888907b5dfbd7b577f63810205b267cf1e191969d96f51bdd3f8f1e3bdbd +bd2f5dba54a54a15fcfae6cd9bc58b172f5ab4c8e0ce19a2df109329eba1f0b9d4c90d5bd579014f9e3c79e7bb06d7dd64b52f256edebc69e2dd848404fc7ce7 +1f514c535e5eb246228547a940a09f1786d67aecd8b12e5dba58f033898888882853e23aac9d6ad4a8d19e3d7b8282824cecb377ef5e0f0f0ffde7b4a8a6468d +1a274e9c30fd0fa13ad6ae5d3b79f264cb3e1fc3b2544ee1d1a3473ffef863cc9fb537bababa364fd7b973e78080004ced4a9428a17957e5ba2150ca62d4cc79 +6f6fef43870e75efdedde0bb870f1fd6df9823478e860d1beedcb953e535a97af5eaf9f8f8cc9d3b77f3e6cdf875c78e1d4e4e4e9a250f1d19a2df109329eba1 +f0b9d4c90d5bd57901a74f9f0e0c0c34f6ee0f3ffc50b0604183dfcd94d5be94d8b76f5f9f3e7d8cbdbb7fff7e3449e9bbeac2949497c048247c946a04fa7961 +bd7bf746c73b75ea541317fbe4c993a74f9f162d5ad482e725222222a20c87ebb0766ad4a851b56bd70e0b0b3336b78c8b8b9b316306e6f0faf7997576767ef0 +e081fe217ffcf1876513d9b367cf4183068d193346e79f3db5e9dc92eff6eddb269e1e73f6ec59cba65080ca296cd5aa557878b8b15b07d6af5f3f2d2d2d2525 +457b6aa7a46e08102865316ae6fc8001039a356bf6e5975f7a7979e9bcf5f8f1e379f3e6193c6adcb871010101986f5be336c1268c1f3fbe65cb963367cefce0 +830f162c5880b2d07f3ab92443f41b6232653d143e97706ee4cc99f3e1c387e6a7d056755eae356bd67cfef9e7eeeeeefa6fa145a3c2f7efdfdfd8fd55cd6f5f +4a4444441c3972a479f3e6fa6fddb973077d0e92a1fc2cc2e5253012091fa51ab17e5e4cdbb66d71bd9d3b778e8c8cd479649904edced7d7b74183068b172fb6 +e0798988888828c3e13aac9daa55abd68c193310d3af5dbbb65bb76e3aef46454575ecd811417f7070b0feb1356bd6dcbc793326489a2d980b6ddcb8d1e0ce4a +74edda75fdfaf57e7e7e9861eadf9eefca952b83070fc6a94f9e3ca9d958b56ad51d3b76b468d14267e77ffffd77ce9c39f6303f5139852f5fbe9c3c7972f5ea +d5f5eff688b7468e1c59a95225e91f663594d40d0102a52c46cd9c6fdcb871a74e9ddab469f3c30f3f687f4beee9d3a7eddbb70f080858b16285fe514d9b361d +3e7c78f3e6cdb76fdf6e70e9e1fcf9f313264c1834689065bf4f87332273162c588084ddbb77af478f1ec6f6cc10fd86984c590f85cf259c1b356ad4d8b46993 +bfbfbfce76f4365bb66c2959b2a44ec5b6559d97ab62c58acd9a353b70e040f9f2e5b5b7a3bdb46bd7ced9d9d9c4f39acc6f5f4a0c1b36ac4b972ebb77ef6ed2 +a489f6f61b376eb46cd9b242850ad841f95984cb4b6024123e4a3562fdbcb09d3b77a27745f9a251ebfc49e0e6cd9be87b91275f7df59505cf48444444441911 +d761d5131313a3b9a3dfc58b17f1d3c9c9a956ad5ac6be7a83c952debc79fbf6edbb7cf9f2ce9d3b57ae5c39478e1c88e6c3d349db0d7ec167ca942998d8e390 +6eddbaa5a6a6e25c9892ddb97327242404b377fc8a49a945bedc8494efdbb70fb35c4f4fcf9e3d7b62ce53a850a1478f1e5dbd7a15d39e13274ef4ead56bc992 +25da872c5bb60cb3655c45505050a952a5903c24ece4c993983fe3d71f7ffcd1dbdb1b29c475d5ac5953fa520976c63ed2a390f156ae5cb96ad4a8a1fd6dbe0b +172ee0e7e5cb97ebd6adabfca9dc022994c4c6c6262525697f9454ca12fd646be4ce9d1b53c4c0c0405f5fdfe2c58be393efddbbf7cb2fbfecd9b3c7d5d51565 +ad5f4384eb86008152be76eddafdfbf71d0c959789b754ae1b680e98187b79790d1a340817e5e8e8181d1d8d69f9279f7cb270e14263f3f379f3e6152c58d0df +dfdfc7c7a775ebd6152a54c08128779ce8e8d1a3f8044ceff16916c9796de3c68d433ea3568c1831c2e097ad34d4ec375007929393a5d7dab5dd21bd56236f2d +f28d6c893dd743e1dc103e97406e4850b79b366d8aae0647952851e2f9f3e7717171e7ce9d3b7cf8303e73cb962dfa8788d57975eac6f9f3e771090ee977da45 +8759ad5ab52e5dbae0028b152bf6df7ffffdf4d34f1b366cf8f0c30f91ce3c79f298f81cf3db97b04e9d3aa1b05ab66c8956d6a64d1b7777f7949494c8c8c8d0 +d0d03a75eaecddbb17b9aa7388581e0af751022391c051f1f1f1fa3766353d56aadfcf8b41b69f3d7b163510798e5ef4d34f3f45ab44cea33d6eddba15c581f6 +a5730f0722222222ca82b80eab1e3f3fbf5bb76e49afa5271a634a10131353b66c596387040707b76ad56af9f2e598aaddb871e3f5ebd76e6e6e0d1b368c8a8a +aa5dbbb6b1a330b18f8888983a752aa65b985256aa54a96bd7ae83070fce9f3f3f5ee0d4980122251659a7c3671e3b766cc78e1d1b376edcb973e7c3870f31f5 +c21931e1c10ca762c58a3afbd7ab570f73cb458b162d5bb60c69c0cc0a89a95fbffeae5dbb3efbec33696685143a3b3b5fb972a554a952f835202000f32be970 +bc95376f5efcaafd7f8ed2b7c9860d1b869362fea3f08a045228413afffaeb2fed8fd27e6eb58b8b0bf6d7ffe61a66e038174a76cd9a3573e7cebd7dfbf6ab57 +af309dc3bc71faf4e93d7bf6d49f9c4bc4ea8618b9a58cacb87efdba437a0e60ce8c4aaeb970136fa95c3750226161619b376f5ebb762d321fcdc1d3d373f6ec +d9fa5f23d586648c1b37ae53a74eb870ccf091f36fdebc2956ac18720307eedebddb4af75d455b9e346912f267d0a041efdc59b57ea365cb969a3aaff3947663 +155e09bbad87c2b9217c2e81dc9048cfa4423d9f356b566262221286ba51b76eddd5ab5723fd061f2e2f56e7d5a91b1d3b768c8f8f77485f98461e76eedcf99b +6fbe416afff9e79f3c79f2a0175dba7469f7eedddf39d8c96a5fc2f0e13e3e3e48125ad99d3b7790c21a356a204bbb74e9627089532c0fc5ca4b6c241238cadf +df1ff9acb351fbea72e7ce8df6a87d4b0df5fb7961050a14387af468787838fade112346242727172a54082d7acf9e3d68d1d638231111111165385c87558fe9 +c7251b83d9c8fc74b28e929e92a1bf5dfa4689656102d9359d99fb7b787898781ab57e0a2f5dba64fa032dfbd46307f9299448cb3a72454545492f304b947bac +58dd1023ab94af5dbb26f09683ea75235bb66c3dd299fe107da54b975eb870a1dca39440fe972b57ae75ebd6efbfffbe39fbabd36f88d57925ecb31e4ac47243 +ec5c12b97dafa46cd9b2ebd7af97758883fc3aaf4edd888b8bd3feb55e3a81cf91dbbe84797a7a9adfd52bc943b9e5253612091c75e5ca15f33f5f62ab7e5e58 +cb74aa9d8e888888883216aec31211fd1fd27fac9bfe476695c5c4c4444646ae5bb7ced60921ca84d8beb2203bece789888888282be03a2c11d1ff71e6cc1947 +4747e5f7b8b0a079f3e675ebd6cdcdcdcdd60921ca84d8beb2203bece789888888282be03a2c11d1ffefd9b36793264deadebdbbc17b65dac4eddbb777ecd821 +3d8b86882c8bed2b0bb2c37e9e88888888b208aec3125196161b1b9b949424bd4e4c4c9c3f7ffedbb76fd5b9ebae31a9a9a9d1d1d1d283e0213434b44a952a48 +e4e3c78f6bd4a8619127ec1165596ab6afab57af262727e3c5c58b17f1d3c9c9a956ad5a069fca45566587fd3c11111111654d5c8725a22c2d202040f350f2c2 +850bb769d366d6ac59f9f3e7b76192626262bcbdbd5fbc78a1bdd1c7c7c7c9c9292a2acacbcbcb46e922ca0cd46c5ffefefef1f1f1783164c81087f475589cbd +4c9932163c0599c30efb7922222222ca9ab80e4b44599a3a0f7697a54a952a9a2feb119165a9d9bee2e2e2d43911996687fd3c11111111654d5c872522222222 +2222222222b22eaec3121111111111111111115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a +2c1111111111111111119175711d96888888888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec31211111111111111 +11115917d76189888888888888888888ac8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d968888 +88888888888888c8bab80e4b444444444444444444645d5c8725222222222222222222b22eaec3121111111111111111115917d76189888888888888888888ac +8bebb044444444444444444444d6c5755822222222222222222222ebe23a2c1111111111111111119175711d96888888888888888888c8bab80e4b59c5cd9b37 +f1d3cdcdcdd1d1d1d669c9a898879409a01a3b3b3b172b56ccd609a1ac88bd28111111115156c67558ca30ae5fbf7eefde3dcdafd5aa5573757535fff0d2a54b +e3677474b4979797c5d39645c8ca43b1f25258ca76283636362929c921535c4be6806a5cbf7efdd3a74fdb3a2194c158a42d5b7524b2ffdec6fe5348fa32eeb8 +ccfa660ee612111191cab80e4b1986bfbf3f26039a5f4f9d3ae5eded6dc3f4906962e595f94ab9458b16376edc70c814d7429495d97f5b660ac91a32eeb8ccfa +660ee612111191cab80e6b75d9b26533734f0640a65dbb764df3dafc5c255b112bafcc57caf1f1f10e99e55a88cc57be7cf98888880a152ad83a211663ff6d99 +29246bc8b8e372d6ac6f72fbdeac994b44444436c4755835ac5ab5aa6ad5aa9a5f7d7c7c74b6481b554f57d692969666eb246478cc43ca04588dd5f1d75f7fdd +bf7f3f33adc35a04ab1f115915fb5e2222223bc775583554ad5a55e78baefa5b88888888888888888828b3faffdabbef7829aabb61e0c48214458d8a1d7b8b15 +8d1d7b070454107b004bb0be4a44417dec1d140b82888a022a2a360c828dc48282d1a05151ec0a563444514123f0fe9e3befb3cfbeb7797776672fdc7cbf7ff0 +d93b3bbb73e6cc3967ceefc7ec8c3c6ce69a356bd6bc79f35f5d6de9a597aecb6a00000000c022471e36736fbdf5d69a6baef9abab4d9d3a758d35d6c85fb2d9 +669bbdf9e69bc9ebdcad63e3c5800103e2df5f7ef9658f3df6b8eaaaab36d86083fc4f7df6d96783060d7ae38d373ef9e49378fdedb7dfce9f3f7fb5d556db7b +efbdcf3aebac4a2bfffef7bf7fe59557e2c5d34f3ffdf8e38fdf71c71d3ffcf043ac79f3cd37afbcf2cab7df7efb4d37ddf4f6db6fb76ad5eaf8e38f3ffdf4d3 +175f7cf1e4839b6eba69143857b0f8ecd0a143274d9a3473e6cce6cd9bc7bb071f7cf009279c504b6679c68c1937de78637cf0830f3ef8f7bfff1d25dc75d75d +7bf6ecb9fdf6dbd7a556eb6ec30d372ce8f912b93a893563472ebdf4d2871f7e384adba2458b3df7dcf3c20b2fdc64934d6af9f833cf3c3364c890e79f7ffecb +2fbf6cd6ac596cbd43870ea79c72cab2cb2e5bcba7e260456d8c1f3f3e5ec4915d77dd750f3cf0c05ebd7a75ecd8318ee6965b6e59e04eff7f92eafdfaebaf93 +3fe33b638f2aadd3a953a7471e792479bdd1461bc541cf7fb7d03a5c98a56ef38982fa574d162c58b0d65a6b4d9f3e3df9333671d75d7775eddab5da95d3b5a8 +ba7be0810762d3f3e6cd6b54717bb86baeb9e68c33cec8bd1bada273e7ced1269372de7befbd871c7248a56f28a82fafb7de7ac9ade82ab5a2e856b95657da06 +963be25555bba1424b588fa3683a05b5a8eeddbbc71e25af975966998f3ffe78f9e5978fd7b18fabafbe7ab4ffe4ad6eddba0d1b36ac6a4555bddf4ed3a64de3 +9c18edbfdab295e1ac572ad1d4fbf5eb377cf8f08f3efa28393b5c70c105b59c1dd28da273e7ce1d3c78f03df7dc139516dd33f6e5b0c30e3bf5d4539b346992 +dccc310e4ad458b5738c424b5877c59f535297b0a0d65be4d9bcee1afc289a428a5e59e4f19a3c79f2f5d75f1f2de49b6fbe59659555a2024f3bedb4f8ce2cf6 +aea0e355b67658ccd89b935daf2c72f605000d893c6ce6624a5197d5aac651a3478f4ee29c643a15f39588be468e1c79cc31c7dc7aebad119e0d1c383082d298 +cce57f6ab9e5966bdbb6edfefbef9f5bf2e38f3f4e9f3e3d2281adb6daeafefbef8f77736fdd79e79db366cd8aef3ff9e49367cf9e7df1c517afb0c20abd7bf7 +6edfbe7dc4d831558a58e28a2baef8c73ffe116f4d9d3af5b6db6e4b3e78f7dd77c7faf1c1082d2202bfebaebb0e3df4d0088f575d75d5986d4f9c3831d68f49 +6a0427ad5bb7aebab31158c6374779625f627ab7e4924b46783f76ecd89d76daa9478f1eb15f4b2db5549d2ab70ee26b636a98bcaecb4d787375127b1d116f4c +28cf3befbc383a518751ed318f8ce963b5e1cd9c3973fef8c73f8e1a35aa4b972e975d76d91a6bac11876cca942931b9bce1861be268d6b4f5091326c49c75ed +b5d7eedebd7bc4ab8d1b378eb8e5a1871eda628b2d3efffcf3a8e762763f44f5c62cb957af5e2baeb862c409ebacb34ed57562fa7be699675e7ef9e5316fbee4 +924b2abd5b681d2ecc52b7f94441fdab2611a8470f3ae8a08322f688b8b179f3e6f1d9aaaba56e510569d7aedd934f3e19c58e0a39f8e0832bddb73af63482ab +a887888ba219ecb6db6e953e5e685f8eb76258ab5af23ffff9cfd1da1b65d0c0e2a07cfae9a75597d7b4a1424b585fa3680a295a549467955556b9f2ca2bffeb +bffeab73e7ce49123644a38d86118361ece9d9679f9d9f75caafa8aa77428f28bd96736219ce7a25f1fdf7dfefbefbeef1a26fdfbe7194a3cd0f1d3a34ce0e4f +3cf1c4ce3bef5ced47528ca2712288ee3973e6cc386a175e786174aed75f7f7dc89021c3860d1b3f7e7ca38a5bcf47db8806539212d65df1e79414254cd17a53 +9fcd0bd5e047d11452f4cad4c76bc18205e79e7b6e0c561d3b768cc136da467c4f8cbd3156f4e9d327de2aedae157abccad60e8b197b1399f6ca22675f00d090 +c8c32ebc36de78e3dcebf7df7f3fa29d9f7ffef9a5975ecaa56cba76ed1a93a44a9f8a9956cc05ab7edbb1c71e1b73a0a38f3e3a22d8a64d9b260b37dd74d3e4 +c54f3ffd3479f2e49809c5eb962d5b469cf0e9a79fc6926485fdf6db2fe69a071e78e045175d945cb49bbb42f3a4934e8a795b942a3f5370d04107c5dc37a665 +fbeebbefcb2fbf5ce9bfdffbf5eb172165ccd28e38e2884a257ce5955722d48ffd7af0c107175b6cb1022bac7a1b54a8fbfab93a89f8ffbaebae8b7f736f75eb +d62d762afe7df7dd772b3d5876fefcf931bd7eedb5d7fef6b7bfe55fbe1af3cbb32b1c70c0012fbcf0c2165b6c51758b3125edd0a1c3c89123f377f9b8e38eeb +dfbf7fcc50eb5ef25afcee77bf8b631133e99ae6faab57f8f2cb2f632fd65f7ffd4aef165a870bb3d46d3e5150ffaa4974e7eeddbb478cf4d0430fd574596b31 +2daa204d9a348960355a75348f687295de8d7872fbedb78fde1abd32eaa4d2bb29fa72feb0966fbd0a45ee4bb5d6a950f7f50b2d61bd8ca229a46b51b1231118 +2fb1c412d13692f83c27ca1cd1f279e79d17ffe62fcfafa842ef845e86b35e499c78e2897bedb5d790214372576cf5e8d1e3d0430f8d7fa74d9b56ed470a1d45 +e7ce9ddbb66ddba8ffe79e7b6eb9e5964b16eeb3cf3e714a8aad249d31aa77871d762855090b52e439a5d012a66bbde9cee62934f851348514bd32f5f13afffc +f3070f1e1c951f2d2ab7f090430e39f3cc33dbb56b57c2ffd76f94ea7895ad1d1633f62632ed9545cebe00a02191872dc0679f7d96fc16ac76ebaebbee6aabad +56da4dc70c2f02b051a34655cada14149c1f79e49131db7bf3cd37abfe506be0c081c994282453e7a14387e6e64c8d2a2ee8685471794ea5595154c8dffffef7 +08c92a7de18a2baef8e8a38fc686ce39e79cbbeeba2bb77cca94297dfbf61d33664cb517286db3cd3613264c887f631618d3c1baef5a16ce3df7dcfce972a38a +cb182fb9e492d8d9b7de7aabd22e0f1f3efce9a79f8eaaa8fa80dac68d1b0f183060f6ecd9279c70c2a44993aa6e68faf4e9d75e7b6dd5bc736cfdb6db6e2bd5 +af92230ebcf4d24b172c58909bebc7ec3fa2c7112346247ffefcf3cf6fbcf146463fe25b08a56ef335a9a57fe57bf9e59723328cee1c815cb48d9a562ba645a5 +d0bb77efd8fdb163c746d92abdf5d5575f452379f1c5172b2d5f84fa7279946d144da7981615e35e84dc11188f1b376ed75d778d25b15a44cba79c724aa5246c +09657dd62bc6e69b6f9e9faa6854717688aa8883386ddab48d36daa8f84ddc7cf3cddf7cf3cdc489132bedfe924b2e396cd8b01d77dcb1de4b58e439a5a01216 +391e1674364fcd285a47bfda2b0b3a5eafbefaeae5975f3e7efcf8fc246c2266e38f3ffe785460a94a5ee4f12a4f3b2c46797a65c9675f00b0c891872dc0c927 +9f5cf526685575ead4e9a1871e2aeda67bf4e83178f0e0826e96f4d34f3f4578ffdd77df2dbdf4d22d5bb65c69a5959658e2bf0ff7dcb973abaedca2458bdceb +64b5dc0538f90b2314aff4c108956b9a3bc676cf3ffffce38e3b2eb618b159b2f09a6bae89faa9e557a2ebacb3ce39e79cd3bf7fff7a8f3af6dd77dfaa0b9369 +e8ac59b32a2dbfe9a69ba279549d8ce65c79e5956baeb9e6cb2fbf5c35f0886836e6a07beeb967a5ab36e2cf989aa72c7d155b6fbd75cc89df7df7dda4903175 +1e3d7a74a38ac020b9b8e6f5d75f8fa9734d17da343ca9db7ca2a0fe95336edcb82e5dba9c76da69975d7659ed17bf14d3a2528878b56bd7aef19d553308d75f +7ffd6ebbed56f526c58b505f2e8fb28da2e914d9a2a2c5ce9b372f9ac7f8f1e3175b6cb188934f3ae9a458584c916a97f559af18679d7556d582256787afbffe +ba2459cefbeebbeff8e38faff67af9d8a9be7dfb56bdc768994b58e439a5a01216d97a0b3a9ba76614ad568a5e59d0f18aba6ddfbefd3efbec53ed57b56ad5aa +57af5e5187e977204f91c7ab3cedb018e5e99545cebe00a00190872d40c9b3ab7577cc31c7d43d1c1d33664c4c4c9f7df6d9e4b9108998fe6671a9634d73dfc4 +de7bef3d67ce9c9882e7b20c7ff9cb5ffaf5eb57fb771e7cf0c1bd7bf7fef8e38f8bff296ec92557ad2e58b0207fe1cf3ffffcca2baff4e8d1e3f9e79fafe5b3 +31857de69967aa1e8541830645d8163bdba54b97366dda6cb1c5161b6cb041320d2da1a64d9bc6374f9e3c3999343ff0c00311133669d224a2fdf3cf3f3f96c4 +2eb46eddba54b78368c052f7afe1c3870f1b362c8ec225975c527b12b6c816954e9f3e7da2494c9c3831ff36703ffcf0c3e0c1831f7cf0c1aaeb2fea7d79e151 +e8289a42495a5404d511181f70c001f1ba67cf9e575c7145eaf2d4c5427bd6ab49b56787d4a64e9d5acb7d2d93ab920b55da1266714ec9e20c5bd0b68a6414cd +57da5e59d3f18a3abce0820b6af9605460a9f2b0591caf2cda616995b35702c07f0879d80665debc79ddbb77bffbeebbdbb66d7bfffdf747dcbefaeaabc714ea +bbefbe8b49e16bafbdf6d8638f95768bf9ffad5d55f25fdc3ffef8636ec9cc993357596595dabf33f921d2575f7db5a8441dfffad7bf62867ad24927fdea9a55 +7f37d7a8629efac61b6f8c1b372ec2953beeb863dab4699f7df6d9c61b6fbce79e7bc677567b67bd74b6df7efb88998f3efae8781d31e191471ed9ac59b361c3 +86e5626673e5da15d9bfe28311945e7cf1c5ddba75bbf3ce3b6b494f14d9a2d2d97cf3cddbb56b77e595573efae8a3b98543870e8d1658e9c6a08906d997eb45 +a1a3680aa56a51eddbb71f306040f2a298f29450f9cf7ae53167ce9c189f6b7ab7f6365336e539a7d4cb78988e513451ce5ef9f9e79fd75e336bafbd76a9b6d5 +508f570a8b50af048085903c6c83d2bf7fff471e79e4b9e79eab74f3b8a64d9baebcf2cadb6db7dd09279c50da2d7ef4d147b5bcfbc9279fc4bff9d3d695565a +29799c6b2dbef8e28bf8778515562841f9cae2b7bffdede28b2f3e61c28474d72835aa78cac74115923f235679e18517228689a0eea28b2e3aebacb34a52ce88 +996fbae9a64615575abdfdf6db9d3b776edebcf999679e19af37de78e388997bf5ea55920d355445f6afe1c3871f7cf0c1d14822208f352338afe9aad8e25b54 +3a7dfbf66dd3a6cd1b6fbcb1d9669bc59fbffcf2cb800103aebdf6da6a576e907db95e143a8aa65092163571e2c476eddaf5ecd933c2efe40605d53e41bbccca +7fd62b8f962d5bce9831a3a6773ffbecb37216a626e539a7d4d778988e51b451797b65b366cd62ca54cb0ab367cf2ed5b61aeaf14a61d1ea9500b0b091876d50 +6eb9e596f3cf3fff579fe051420f3ef8608f1e3d6a7af7a1871e5a679d75f26fb4bffbeebb8f1e3dfac8238face53b1f78e081f848418f38af5f4b2cb1c46ebb +ed76efbdf7a6988f3efef8e3db6ebb6dcc68f317b668d162ff0a871d7658fbf6ed0f3ffcf035d75cb3f87246cc1cc1cf4f3ffd14472d42c4e4b67db1f0befbee +ebd3a7cfebafbfee7ad8da15d9bf5ab66c19ff46cd3ff9e493c9ed8093144655c5b4a862ecb4d34ebbecb2cb55575d953c6967d4a85151c8dc7f0f54d220fb72 +bd2874144da1f816f5e28b2f1e70c001ddbb77bfe1861b1a55fc4635fe7ce2892776d86187620a56bcf29ff5caa34d9b368f3df65872a96955e3c68d2b7379aa +559e734a7d8d87e918451b95b7576eb9e5964f3df554a74e9d6a5a21de2dd5b61aeaf14a61d1ea9500b0b091876d5066cc9851cb3d045f78e185926f71ecd8b1 +e3c78f4f9e6d5ac9a79f7e7af5d557f7eddb377f61af5ebdb6db6ebb3163c674e8d0a1da2f7cfffdf72fb9e49298c1d77e03cd854dc49ceddbb7efdebd7ba161 +67c78e1d1f7df4d19a6e10b9f3ce3b2f58b060d6ac5925c9c36eb4d146cd9a359b32654ac4099d3b774e161e7ae8a1b7df7e7bbb76ed9a366dbac1061b14bf95 +06ac54fdab75ebd6e3c68d8b83dea449936baeb9a6da7552b7a82245873df0c0032fbdf4d2b5d65aab7ffffebd7bf7aee9fe09c5f4e5d8f16fbef9a6ea475e7d +f5d5e28a5f32e52c61a1a3683ac5b4a8975e7a298a179fbdfefaeb932503070e9c3f7ffe7efbedf7e4934f4633a8f6534b2eb9e4b7df7e5b54a1eba0fc67bdf2 +38e18413f6dd77dfb3cf3e7babadb6aaf4d6ecd9b3a355d447a12a2bdb39a5bec6c3748ca2e5ec95ddba753bf1c4134f39e5946a9f08f7fdf7dfd77ef7d8822c +2a33d8f28cbd8b56af0480858a3c6c83b2f9e69b8f1a352a798e4abe7ffef39f575e7965725fbfd28ab9efe1871f7efffdf7efbdf7def9cb3ffcf0c3884336dc +70c358217ff936db6c1393d4c30e3bec965b6e39eaa8a32a7ddba449932284db79e79d4f3df5d492173553fbecb3cf69a79db6fffefbdf73cf3dd526555f79e5 +9573ce39a767cf9e95ae8bf9e9a79f62cabee5965b26174b567aeb8c33ce88d022f97963f12230d876db6da385449c76d75d77250bbb74e9f2a73ffd69e4c891 +5b6fbdf5a295fb2ebf12f6af1d76d861ecd8b1f155114b57fbd0f9d42daa48b1c5d8cdfefdfb477cf5e5975f1e73cc3135ad594c5f8ec63662c4888e1d3be696 +2c58b0e08e3bee58783a7e394b58e8289a4eea16f5f2cb2fefbbefbe116c5f77dd75b98531560c1a3468fefcf9f1d6534f3d556d1cdeba75ebe1c387577d767c +8c6c31e0b46ad5aaf60794d551f9cf7ae5b1c71e7b74edda358ec5934f3e997f97f01f7ef8a173e7ced13d070e1c588fc54b94ed9c525fe3613a46d172f6caa8 +de686c51e78f3cf2484ca5f2df9a397366749615575cf19d77de29c9b61695196c79c6de45ab5702c042451eb67ca64e9d1a73d0e4f5ebafbf1eff2eb5d45231 +ababe94289b7df7efbebafbfce5f3fa779f3e65b6db555d508e7861b6e88a8f8a38f3e3af2c823d75e7bed08923ffdf4d3679e79e6e1871f8e3ffffad7bfb669 +d326be6af1c5178f197c6cfd830f3e486e33f7e69b6feeb8e38ef90fa78ed55ab66c993c07b9968511286ebae9a6071e78604cb863a6b5faeaabcf9a356bc284 +09c3860ddb7efbed1f78e081c68d1b572a644ccb96596699638f3df6c61b6f8ce9ec269b6cb2c4124b44991fad902caffa98ec69d3a6c594ba526172af9b356b +16f3ce4a1592dbbbba7f2a8a1135963c1636d6acbac26bafbd566d7585abafbe7a8515568889ef2ebbecd2a953a7a8a5d8f728737ce4f1c71f9f32654ac40311 +5a37aa228e6684d91d3a74d873cf3d575d75d5f8da88dc5e7ae9a5d1a347b768d122eaa4a0e74dd72e0e4a9433ea3c77adca1a6bac11fb3278f0e0984f575d3f +451d26521cafd49f2a48316dbed0fe957c437e47ce171163efdebd2fbae8a2686f6ddbb65d73cd352b3dd623758b2a529f3e7dba75eb162df0f4d34fcfed45b5 +d2f5e570c10517c488111f895036aa312a2d02b9a8cca143871e71c411f16793264deaf7129bba97b05e46d1740a6d5173e7ce7dfae9a78f3efae868abf156ee +969789b7de7a2b2a273e1b9d62c488117bedb557d449fee6aeb9e69a08ce6358fbc31ffe10cd7bce9c39efbffffee4c993c78d1b1763dac89123ab96b00c67bd +622af09d77def9eaabaf1a557776a8e5add4a36834b6430f3d34f6ba67cf9e715ce260c5311a3870e00e3bec10755b6d1e365d098b51e8392575090b6dbdc59c +cd8bd79046d114e7e514bd32f5f18ac1e4c1071f8c4a889d8dda883a8979d4b7df7efbecb3cfde7efbed3bedb4d3a851a3965d76d9520d02851eaf7a6987858e +bde5e995c59f2b01a0c190872d9fb66ddb7efcf1c7c9ebe419a3315f993a75ea7aebad57edfa1196bff7de7bf9ebe7346dda3462e0aa0f638d1967c4b1d75e7b +6d4c82635b31f38b907ee79d77beefbefbf6db6fbf64f2145f15b3f3f878cc8663a21c93b35818a1c2de7bef9d5f92582d56f8f0c30ff3bfbfda851122c60cec +faebafbff0c20b63bab9f4d24bc7442d2281c30f3fbca604e2a9a79edab163c798ad0e1b362cbeeddffffef76aabadb6db6ebb4d9a34a9a69fb8b66fdf3e571b +55eba4da0a89a961d446a5efc9ff5404f651ffad5ab5cadf4a4c10736bc66c3bfeccbf2740727dc729a79c1233cb4ab3c3a8de08bdba76ed1ae171ec7eecd72f +bffcb2ca2aab6cbcf1c61121dc7ffffdd5de2f2c82d8385e510343860cb9eaaaab66cc98f1f3cf3fc7bc3662ef8b2fbe38e6d0a54ac1e43617df9ffb01692242 +fd175e78a1da802d451d26521cafd49f2a48316dbed0fe95dba9648b950c1a34e8a28b2e8a17575488b8f4b9e79ecb5f215d8b2a5e348ff3ce3b2ff634baf6af +ae9ca22f37aa380a63c78e8d1123b6155171ecd111471c71e289272ebffcf2f122ea302a366ab8e4c991baab7b09eb6b144da1d0161535102bcf9b37efd9679f +8de22db7dc72314045978fb76218d975d75d733f8b8e3670efbdf71e72c821f91f4f9e5674f9e5975f76d965d3a74f8ffe1b6d23c9d0c5d92d42faaa252cc359 +af980a8cbefceebbef265f18e58fa12f579e5ade4a3d8ac62e8f193366c48811b7dc724b9c20a2b16dbae9a6519f552fc42bb284c528f49c92ba8485b6de62ce +e6c56b48a3688af3728a5e59ccf16ad1a2c5980ab7dd76db19679c316bd6ac95565a299a5fd467ee4acc520d028d0a3c5ef5d20e0b1d7bcbd32b4b72ae048086 +411eb67c6a7f287655c9d4a7506bacb1464d4fe66d54f1b3b5fc3f2bcdad6b5aad968589080e2350ac7319ff5bc49cfd2ad471fd14b51113ee423f1233d7da57 +f8d5a754c7a4b3a63b7e562b26eec98b422b309d9852573d8effa742b5eba7a8c344bad69bee530529b2cd17d4bf6adf62df0a3516f47f14daa28ab7d8628bad +bffefa9d3a755a76d965ebb27ea17d39913c89aeeaf25ac69932ab6309eb71144da7ee2dea90430e89a0badab71a376e5ced55de9544a47ddb6db7d5bd6c6538 +eb15a3965f37d7f256ea51b451459ae3980a755c3f5d098b51e839a5c812d6bdf5167f362f46431a45cbd32b8b3f5e1d2ad4717345aafbf1aaaf7658d0d85b9e +5e59aa7325003400f2b000fcafa953a74e9830e1d65b6fadef826428b9454cb59764c2c22ff9a5f0d24b2f5ddf05a17aff09a3280000e9c8c302f0bfaebefaea +a38e3a6ab5d556abef826468f2e4c98b2fbe78fee38f60113271e2c4c68d1bbb73e242eb3f61140500201d795800fe9f1933668c1a352a797248433567ce9c3e +7dfa74e8d0a1458b16f55d1628d88f3ffe78de79e71d7df4d12ee85e38fd278ca20000a4260f4b1ab9a75a278fcd5d6aa9a5b6d9669b123e4f06288ff9f3e74f +993265ce9c39c99fc3860ddb6cb3cd66ce9c397bf6ecd6ad5bd7e393b24ae5bdf7defbe28b2f92d70b162cf8f0c30f070c18f0cd37df8c1d3bb67e0b6614a58e +f21f583f7dfaf47efdfacd9b37afd07b89929d063f8a02005042f2b0a4d1ae5dbb0f3ef8a0d1ff3c3677a9a5969a3a75eabaebae5bdfe5020a133db74d9b3673 +e7cecd5fb8cb2ebb44a79e3469d2565b6d554fe52a99f6eddb4f9b362d79fd9bdffca665cb96b1e4e28b2faef79f0c1b45a9a3fc07d6afb4d24a071d74d06597 +5db6fcf2cbd76fa9c869f0a328000025240f4b1aefbfff7e7d17012881cd36db2c77195783f4f6db6fd77711aa6714a58ed23db09eb269f0a328000025240f0b +00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2 +250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e461010000 +0000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e461 +0100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040 +b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000 +000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c +2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500000000 +c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992870500 +000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b00000000000d992 +870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b000000000 +00d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205bf2b000 +00000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e1600000000205b +f2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e16000000 +00205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c30200000000644b1e16 +00000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c3020000000064 +4b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c3020000 +0000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d795800000000806cc9c3 +0200000000644b1e1600000000205bf2b00000000000d992870500000000c8963c2c0000000040b6e4610100000000b2250f0b00000000902d79580000000080 +6cfd5f74ea10b3eb88fa5f0000000049454e44ae426082}}}}} + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +World 1:} +\par \shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbxcolumn\shpbxignore\shpleft0\pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch +{\*\flymaincnt5\flyanchor0\flycntnt}{\shp{\*\shpinst\shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbottom5135\shpbxcolumn\shpbxignore\shpleft0\shpright9972{\sp{\sn shapeType}{\sv 75}}{\sp{\sn wzDescription}{\sv }}{\sp{\sn wzName}{\sv }}{\sp{\sn pib}{\sv {\pict\picscalex36\picscaley36\piccropl0\piccropr0\piccropt0\piccropb0\picw1833\pich944\picwgoal27495\pichgoal14160\pngblip +89504e470d0a1a0a0000000d4948445200000729000003b0080200000005b8df340001209f49444154789cecfd79bc65575d27fcefe9cc77a83955954a529943 +426610484084c814106c9406fa795026a5916e151bb4b57d8120f86b6cda16ba51f2880ab413834237caa44110020921320442a6aa24358fb7ee78e6b3cf6f9f +bb939b4aa52a24b0531792f7fb7539597bedb5d6d9fbf0dfe7b5eabb9257befc4501000000000045180cd25eaf3f31be3269b7bacbfd3000000000008f105114 +96cbc9c2c24c320c86cbfd3000000000008f10837438e8a4a5244ed254f60a0000000050a44eb79f0c87b2570000000080821d257bcd7ae6175aed56a7d7efa7 +691a455129496af54aa35e0dc3e801d6fabe2702000000003cc21c99bd365bedd999859f3c7dfdd336af3f7dc5f8782599ebf46f9f9effe73b767f6eeb9e89c9 +b15aad72d485b28933330ba79d7eda69a76e5eb16265a552ee74bad3d3d35befb8e38e2d5b278f3d71b9a4c3646e6161d0ebad1d4b06a5ea723f0e00000000f0 +88921c1ebdcecd35c783f4bf3efba2536bc9b0df0bda8782d670220c2fa9c7975eb8e967ce5cff962f7e77ae3f181bab1fb14a36711884575ef99c46a3deeff7 +7bbd6eb7db09c3707c7cecd24b2e3efbecb3bef0f97fe9f79bf79fb85cd26132db2c6f3af7bcc79cbca275dd27bfbbd016bf020000000005ba77df6babd5191f +0edef513678f0d9a83d9fefd879e1c277ff8e367fecae76f6db6dab5eabd9b58b389c3207cc633af18a669b3b970c4ac6eb7534ae2673cf3e99ffdcce78e9878 +2ce9b07268cfcef97e3ade28af59b522fd015eef5806c352a7d9b8f2175efa63e5ee75dffac47767d361f2400f36484bb3f3739de67ca7377a9ca45c9a6cc493 +8df141183e0c4f0700000000fcc8bb3b7bcd3ee7e6e67feff2d3eaad99747094e035d78893ff72c989bff2e53b2ae552b8183b661367e7e6afb8e269bd6e7730 +181c7556bfdf8fe3f8494f7afce73ef785a5890fe0d081f459bfffa72fdd18ccfcd3db7efdafb78faf9c2c3c7e1ddeb7d4c2304d1fe0ccb1f6a03a3bd3bbf059 +2f7eee8f5f78f686461cf4a6b7dd7cdde73ef5f12fdcbe6265a313958a7e3a00000000e0475e922e668ecd66eba9ebc74e8a3b83563bbb6c0d86db9afdb3c7ef +4e156f99eb9d5c4f6af128333da55afbf113ea5f9b6bd7ead57ce2a64d9b2a954ab7db7d80af190c06d56a6dd3891b0f1d9aca273e80fb86a0c3ec09d37b6f25 +3373adcec26c6f300ce364b2114d8e8d0fc2f2d481fdcd4ebf522daf5f35da8b3add4ae6a7f60461e9cc0d8d6658bdff94f4be5f321c6db63d7af6da1dd4e65a +2bfedfb7fddab3372ef595569c7cfeb35e7efe4f3cf1236ffa6f9f2b4f860b417de6d081ec17e80f161789e2c97ab27262ac9fc7d3477f661b6601000000e091 +2c091633c74ea7f794d5b5c1c25c908ef6aedeb590bef9bb33bf75e6f8f993c98d33fddfbb6dee2d8f993cab118d66f4b391e52f1d98cdcfceca266ed8b0bed3 +69a7e9f7d89cdae9a4eb376cd8bd67cf433c746b18dc938a0e83f2d454e7f467bce465cf7dfce92be2c1ecf6af7df6231ffc879be782894b7fe3aa5f3937ea7d +e37ffdc73ffc56a7b63a7ecccb3ef4cbe7c6cdafbef53fbc6f7b1a9d71bf29e515f7cd7f87f77ecb11bfcfc274f3b1affdcdc5e075fafabffab3bffa972d8792 +132e7cd6bf7bdd4f9d5139e745af7ffe777ee7ffee5e88563cfd17def0cc73376d58511dfd460bbb6ff8c70fbfff13375527c6ba61e5a8cf5c5f31de13bf0200 +0000c023d7dd3507fafdfee6a49fb69b790479e678e34d4f3ee7ad5fbcf9c5eb930fede9ffd6e5679fd93f90b6166bb986e1e652addf1f2c4dacd76bbd5eff01 +fecd7e2e0cd346a3ba34f1c11a0ef3fa00c361343ddbd9fc6f7fe377ae5c170483b9e9f9c68a939ef0b3bf7672e5adbff5919d377d61cbf0dc334b67ffd889d1 +376e6db6ce7dd2e97110b4be7dcd1dbdd2a92f3dca94b77e6cc7305879c4f7dcffcb3b83d2a07ed64f3fa196b5f77de25deff9d4ce952bebf5a0f9f50fbfe7dd +1bffeb1b2eadac7ffa156b3ef6c1d9b471dee3ce38b19c8deab57ba56a63c3a53ffd2bab177ef39dff7c60369d38ea33bff5e3dbcb13130fe17700000000007e +a42cd57b0d1a8376da69dddddd6d9f5defbeecb127bee71bdb5f7dfe89e7b5760d9a734b73c6c268b13eeadd13c330e8f57af9ad6baffdeafdbfe3894ffcb1bc +51a99497263e80fb9603b83b7beda495b47ee6cb9eb32e080e7ce2cd6ffae02d9db18b5ef5eeff7cd986a73ff394bf7bdfad377ee9d6e19967d7ce7df229a56f +df75e253ceab64336efcc296f6e48f1d75ca097ff7a7d3f7f992a3d77bedf687d19ad3d68f9ab3dfbc7ef7ba89b01d4549d00dea959baed9165c7a6630bee9c4 +7ab0a579f7f0ebdefe2bffeda6d2e37ff91dbff184dae6273f36f8ece707e3171ce301fe6cea2165d000000000c08f94240f00c3309cedf62787e9d23fbdbf71 +dff4ffde39f79a8b4efeebefec3879e3e082c63d33c270a6db8fa2606962b3d90ec3bbf78d3efd8aa7dfff3b666766f2910b0beda5890fdea81e4010747bc370 +d379a78cfe99fe9a9f7acb1ffdd4d2edc609ebaad1edf3dff9cccde9d98f19bbe4f24d63d1e517d583a0f98dcf7eb7959c7eac29c12dadc3bfe3e84fb55846e1 +deca0087552658ea0ca3fb84c5e17865b8f5c6bdc113360763abeb413ab3e1980f7050f40a000000008f5c77ef7b8de368cb7cefe2721a2c9e6b755b2bfcafbb +92df7afc29e78673a73eee94dfbbfecedfded83fb396a7add196663f8e4b4b13676767c7c61af9e5a1a9a9637d5318867373f3711c7fef7daf87dd1fe63b5f83 +204d8741942c569c9dfbfa3f5eb3bd73cf88defe83611857e36f7ee63bbdc79c3ff9b8a75d317ee15836e8abffbca51f1d6bcafe283efc0bd363d41c2845c3e6 +813bf6074f9d0c26cebff884bffcd8ae8989c168076eab75ce134f1a8d58d8b5b3393cbc6e6bf69afdce60b11587c1033df343abbd0000000000fc4849d2c504 +b0544abe38ddbfe884613018e586278d8fbde509279dbab0b3bf307b4e63e22d4f3875fdf4f661777e7146f8c5992029dd3b71cfde7da7d54f192c4e7c00711c +efddbb6f69e20338fcf6422b9d6a4d2f36674a7bbebb33b86873d09898f9c6fff9d82d3383206aacd998644f9354cad1c28d9ffecac2f93fbee2b27ff7846cf0 +81cf7dface5aad317d8c2983783c0cf3e3c1ca6b378e1dbc756a7c6278ffc3c292b01334bff3897fedbcfe92cafa7ff3cbbf30f3a77ff3e53bdbc98a8b5ef80b +ffe1c746a7751df8c23fed0da3f0be61f1617b62a3feb19ff97bfe0e00000000c08faebbf7bd96cbc957e6c2e7b5c2cdf13018a6e5cefce6e93b068b876b0d66 +0f6dee75d34e7b980e8230baa3197d65211e1b2f2d4d9c3e74687eedea4aa5f2001b39174b13b40e1d9a191faf3ff8fd9e933ff9db7ff9934b57bbffe6d77fff +afbef09cdf7aea8ad37ff63fffe9cff67b69528a82ed7ff59fff7f57ef4f6aede160f7273e77e0c77f6acd68ecd6cf5ebd7b908c85e1ecd78e3ae5f7fee94098 +566ed91b3cf194e0b457bcfd8dfddffea3eb0e06d5b1fb3d59af526b5cffbef77de1775ff7d4d5ab2f7ff9af5ffef27bef0deefcfb3ffcdb1d95fae4dcc26133 +eeb34414ce5c7fac671ed64a0ff27700000000007ee4244b4968b952f983bdfdb7adef8d0769d01f0cfadda5418385d9d17fc2706e18fff7bd49a55a3efcdfe8 +572ae52d5bee38e3ccd3a3303a6aae1a86613a4cb331d56ae918ffb8ff3e8e713f0ad3e6b7fef477dfbaf3675ff2cc4bce5a53294541fbd0b6ededd13fed4f87 +836aadb1f3d39ff8ee735ff198a875eddf7e65584a7bc1a0518bbff3676f7bebce9f39624ab656521bfcf37bfefca4d7fc9b1f3fbdba70603ebbd539da9395a3 +f9c160fb7b7ffdcddf7cfef3afbcecbc33d656b3df636ed76d5ffb97cffcdda7bf9dd49356101f3eedbe4b0c57d582a33ec0e233dbf70a000000008f58f766af +4912cf0c6aff6577f02babe74e4b7aa3aea570301cfd33faadbdf2bb0ed6674bd54a729f9aadd9c47490de76eb964d9b4eac542ac161f16ab838b1d3e9eed8b1 +238a47231fcca6d7b1c6ccdfbff1957f3b38626474d24434de486ff9a7bf78d3dfff493f1ddd8da268b23a8caba36ab3a5707e38b8f9adffee15d9a3af1f8f7a +e57af61c61d0a9d793a34ea906cdd6cc77febf375df3c783c10963d583ade160b870df6f1c4e54874975ac1a2d24e5deb51f7bdf351fea0cf245e2b05e0e1bb5 +6a335b6fb8d0a80fffc7cf8dbef7c489a8528de7befec73ffb9283611c6f98a8f4c2deb11e40bd570000000078044b0e0f004be5d25c14bde940f28472f34995 +f669e5de7898ce0da32ddde42bedea577bf552a55c4e92fb6786d9c4b03fb8ebae6d8d7a7d6c7cac56ab46519ca68366ab3d3f37df6c36cb9552e968138fa531 +d168dcaf7361544ab5dfa84441e53e37d37b962d85cdd2cab1ac31dab2bb941b1f7b4a35ea54276a8361ed4077dd2ffdb7573fb676c417f677fec31ffcd1e776 +0f2b6371d01dab2541f67798de3ddf1205cdf1c5ef6d2df68c953ac1e2657bf1f2819f190000000078444a8ed87d19c751ad5efd5aaf74ddfcd8e25954c3c523 +a3a23889abb5380cc363edd6cc26d6eb954eafdbdcb7ff8889b55ae501262ebb7418054179f5c615abee77ab3f5e4a07c30751260100000000e03e92e0a8454e +9338c8feeeef7b8590dff7c465940473e3a55bfef035af3bfaed6ae387f9e101000000801f4e89139f00000000000a7764cd0100000000007e70b25700000000 +80e2c95e01000000008a977cfe0b5f5eee67000000000078a44996fb0100000000001e8164af0000000000c593bd0200000000142f09c2f0deab534f0db66e5d +be877910ce3c33b8edb6e57e080000000080ef210986c351fc9a7dfe48b8fdf6e57e020000000080ef4dcd010000000080e23d60f67aeaa9c19d7706fbf605ff +e13f04fff00fc1e464f0e217076f7f7b50ab8dee7ef6b3c1b39f7df786d96cc0fffc9fa3c62ffd52f0c77f3c6a8461f0e94f07cf7ce6dd4b7df083c1bbde15dc +74d368ee539f1abce52dc105173c84efca9c7efaddf510968a246cda146cdf7ee43367cff3810f04575d15dc78e3a87dfef9c12ffe62f08a57dca7b4c2196704 +5bb6dc3df8e0c1e0377f33f8f0878355ab46aff0dce78efacf3e3bb8f5d6fbbcc2b7be155c7a69d0ef8f6edd7cf3915ffa0bbf10fcefff3d7af73ff88307fa3d +0100000080478d07cc5eefb863943ffeeccf06af7b5df0fef707bb7707fffedf07bffaaba36433f3cc6706691a5c7c71f0a94f05ebd7df3de58ffe28f8bddf0b +9ef18ce0faebef5de7f5af0fbefef5e07ffc8fd1e0d9d9e0939f0c5ef082e02ffe22b8fcf207fb5d993c2d7de0f2088341f09297047bf6046f7b5bf0c4278e7a +aebd36f89ddf1945a87ffdd7411cdf3d2c2f5c902df5afff3a1a9f7de35d778dd6ffc77fbc3b7bfdce77820b2f0c3efff960eddabba75c7041b0b0307ae06bae +39caf77ee42341a733fa94bd02000000008b1e44cd81fffedf83c73d6ed438edb4e07def1b85924b7968e6d5af0edefbde51beb9e44fff3478f9cbefbdfcfce7 +831b6e08aebe3a28954697e3e3a35da24f7c62f0733f37ea8fa287f05ddfd33bdf19cccf07fffccf4172cf7b5d71c5689bedf39e374a45dff8c623c7fffccf07 +7ff777c1631f3b6a5f72c9e82f974d7fddeb461b75dff6b67b07ffe55f06fff6df06e5f251bef72ffe22f8f8c78397bef4213c2a00000000f088f620b2d73c0c +cd9d7c72303d7d9fbb3ff773a37f8cff5bbf757728391c8e82c82f7ce1de017ff557c19bdf7c77f0bae4fcf3477b60afbf3e78c2131ec2777d4f7ff227c1c73e +766ff09acb2edff18e516c7affecf5739fbb7767eb115ef9cad113fec66f8cc2e260f1bddef7bed10edfa37adef3467f0000000000f7f881cfda1a1f1f151ff8 +c84782ffe7ff195d7ef293c1939e144c4cdc3b60c78ee0277ff2e8737fe2278ecc5e7f40dbb78feab1dedf39e78caa0adcdfb182d74cb53adabd7bd555c11bde +30bafcfbbf0f7efcc7eff35e0000000000c7f60367af99d7bd6e7498559ebdbee73dc1effffe7dee6edc38da5efab4a715f045dfd3c92707b7dc32da547b845b +6f0d4e3cf121aff6dad78e72e45ffee5d196de77bf7b749a1600000000c0835344f6fa98c7048d4670dd75c1ead541ab7577f9d4253ffff3c19bde343aa5ea88 +4aa9c3e1e8b4ab87aa521955741d1b3bfadd57bd2af8f55f1fed515d3a562bd3eb05ffe93f8d6e3d541313c1bff937c1073e300a734f3beddef3c4eeef539f0a +fecfff191ddbf5133ff190bf050000000078242a227b0d16b7bebefbddc1092704fffedf1f79eb294f192592d9df6fff76f0f8c707b55a70c71dc135d78c4ee8 +facbbf0cce3befa17dd1339f19fccaaf046f7d6bb06a55b06ddba862ec9ffee9e8efb4d34677dff086e0ab5f1d7dd75bde323ace6b380cbefce551f2bb61c328 +93fd3e64dff58c6704a79e7ae466de23bcf4a5c1cc4cf00fff302a7a000000000030ca5ef3cda7f9e7a9a7065bb7de7de7b18f0dbef39d51e39453ee2d969ab5 +8fe8c9bde005c1affeea6887e93bde71942f79f39b478768bdf39da3a8344d4739e99557061ffd6870c6190ff9bb3ef081e0377f7394e14e4d8daa193ced69c1 +dbdf7e77f01a2c1eabf5b77f1bfcd99f8dcefefad6b7462f95adfc8bbf383a38ebf03db6d99adbb6ddfbd647bcf8e1d6ae0d9efad460d7aee0cc338ff913667e +e667463972f60900000000b028196d0e3daa6f7ffb289d473db12a13c777a799c7f2dce78efe8ee5c17fd7ca95a30db3d9dfb184e1a8bcc003571838d65b1cd5 +ececf7de339befbd0500000000b8474135071ea976ee0cf6ec196db30500000000782864af0fe80ffe60544b0100000000e02192bd1ecdb39e157cf6b377b7ff +e00f82a73f3db8faea657d2000000000e0474cf2fffcde13866918045110a451380cc2380ac34130188efe9366b7a228bb150c83413a08daed7e1c8749294807 +519aa6711c075158ca6644c34c308cf24547ed300d174fb20a8338bb4c83c15ffdd675cbf9a20fc9673eb3dc4f0000000000fc684ba26a298e82c9f15a6f306c +357bdd6e6f66a1dda82451140de33889e3b9b9f9284ac6c62bc36eda1bf4c330e8a6c3721296e2a452af26a5a09294a2309c9e6b0d86e9c2423b9b3856af0e06 +83300c7bbd5eabdd6bd4cb956a79b9df1400000000e0f8494ae36112c541238a06a3dda9b5f1526575a9562f8fd5ab3353f39d5e6fa2da184661b99a84613816 +d6e3459d7eafdfef87e9b03748cbb53088c3721c0f875150afc64158af9582a8323e566bb5dbf3cd4e3671b4131600000000e05123094a51588ae2c938ed0cfa +ed61ad96d4ea49b55a1d1fab2eb43abda01f54e2d11ed8689894a2f1b15a92448d7a757ea133df6eb5163add56af51af04d5789086693f8893241e066139aa24 +a5c9b5b5a419468da8ddea2d347bcbfda60000000000c74f328c86ad5dedf687f7266737269f349976d356a7dfed2f2c2c3417e63b41188c8d954b49b8ba3a1e +c561b594b47afdddbb0f85613c180ce2389e5c35d6b96eae7bdbdcda679f503961acd7ee05c3a85e2e75d2feee7d87c2e1301d8c4ac88e35d41c00000000001e +4592a89a74baedf45b73e16454a9afed0f7b8330ed75fbadee60900c4ba552528dcb51b26abc918451ad94ec9f9f9b5968d6eaa5b012968671522f37773517be +367dfab34f199fa8b7c3ee68d130ce965998ef96ca61524e92204ce2e4c13ccdf4f4f437bef18d8b2fbe787272f2c1bfc3f6eddbf7ecd9b36ad5aad34f3ffdfb +fc1900000000000a95743eb467d81c449349b95c6eacaccc7e7d6eee1ff7ad7efec6894b57dcf9813b5a7b7ae7bef682f28a523408d2283d9036fb517ae2292b +5bdf9a9bfae4ee154f5bd778faf842392e8f95a787dd56afdd6cb793283873ed86b85bde3019b66f9d3ff8f19d934f59537bcaaaeff928cd66f3ca2baffcca57 +bef2c52f7ef1c94f7ef28379fa8f7ce4236f7ad39b6ebef9e6fcf2e4934fce2e5ff5aa57fd403f0900000000c00f2ce96f6bf7d3b41ac4711454aa71d81c0cb6 +34cbbd686c4525d8dbeb6f694d56ead546b9d7ea0ec27410a74125982cd7d26eb37f4b2b78e2a0d228c5711c0c87dd7e3f1df43a412f089346a31696a36e290d +06addecdcde1858372e37bec7bedf7fb2f7ef18b6767671ffca3ffc66ffcc6bbdffdee5ffaa55ffac8473e72fae9a71f3870e0a31ffde8affddaaf7df5ab5fbd +eaaaab7eb09f0500000000e007929cba7e45bb9f1e38d46c6f696f7feb6de942bfb4babad0690fa79b1bd6af18b6cbd7ff8faf25e3a575bf78d26066b0f77ddb +e2532b8d179fd0ee744aab2b0bd74f776e9aef1decc6b552a39e54c6ca33efdfde9c1a7ca1b43b5953197ff9fa56bb9b0d6b7d6b76cfd656f091077a8ed7bce6 +3537dc70c3b5d75e7bca29a73c98e77edffbdef79ef7bce7d39ffef4539ffad4bce7a4934e7afdeb5fffac673debc94f7ef245175df4dad7bef607ff75000000 +0000be3f49b594c4613057ee0dbbc3de8e66540aa27818f4fbddf660451485e5f2ce3d87e2b9fe78af3f68755bdb16cae3834a7730e8f7932808e606dda95e54 +4aca953889e23808a3e97478a0d31a0c9341afd6efa7fd411445e95c2f9dee3dc043bce94d6ffaf0873ffc852f7ce1e4934f7e90cffdf6b7bffdd77eedd79682 +d725e79e7bee5bdef296dffffddf97bd0200000000cb28498761a31afee4e337b7dabdfd5373611897c2e1ee6fb5f75f7b57b5541aafd54ebaeccafe6078f05d +ff324c7ba5c972b82f9dff83edababa57567ac4ee3613a0856af1e9ba856aefbc4feddcd9dffe6b2c7d64ac9f61d7be75add1bdfbd7d45a972e699ab06c170f8 +800ff1d18f7ef4431ffad025975cf2e09ffb452f7ad1eb5ffffaa3debae28a2b7ef9977ff9d0a1432b57ae7c283f0500000000406192280e4a7134512f05c330 +89a3240ca352a934d74967faf1aa4a1c874992a4c36138db0bd341588e8234ea4ff5923595d2786530e8a5c3b05eaa8cd5ab71b31f4e0d1ab54aad9c34eab57e +2f181ce8c72b2b95c96a77d08b1e307cbde9a69b1eea73fffeeffffeb16e1d3c78307be6b1b1b187ba2600000000405192789826a5729224d3cdf9ef6c9faa44 +519a8eb2d6301c4671100efa3bbffac952929c79e244180595a434db6c6fd933b36fb67560a615454177d01f1bafad9ca86c5a535d375e3e70602a0ae26c727f +98067130bdd099deba3b5c74dc5ee97def7bdfd39ffef452a974dcbe1100000000e00849148c52d141300a5b2b6138562b8f52cb74d00fc24a9cf5c6138da49c +9426c7ebc3e1301d0ccae564f56423cf52078341da4ca3280ae2a4529f4c4b6918c4d9b061b66e12ad9a68c471945df5fb836eb77f7cdee7c31ffef0873ef4a1 +2f7ff9cbc7e7eb00000000008e2a29579376abb3f58efd71189d73e2aad3cf5c7fce6336b5dbed242efff397be3d33b5f0e2e73e7eac5a0a93b0d3ec7de5dadb +4e5ab7f279cf3eb537e8d7aae59bbfbb6bcb96dd834e77cb969d138f7b496d62c3ce2ffc59ba30d5190c57ac6cbcf2c54f4ad3a0528db76e3970cb77b71d8797 +f9c217bef08a57bce2cffffccf1f52e9580000000080c225f1300ce3a8564d86c3e1601077bbfda983f3d98d5a2d0e878bbb6187c3fe30488661679076d3613f +08d220ec75d25ea7ddeff74b4914674b0ca34a301b05f5f17a94c6b56a3fa85793340d3a9d5e77519c3cec3507aebbeeba17bce005ef79cf7b5efad2973edcdf +0500000000f0c0927e9a366ab5cd9bd7ceceb476ed9e3ab07f6ed78e43ab5737d69e3096f646f5040eec9d8ee22029c7b3b39d6f6ddd7752b37be2c6f1bdbb67 +0f4c2d944b71180e57af593151afa4d3370c0f85675e726214c4c330e8b4ba7b76ec9f9e6dee3f30172f7a585fe3cb5ffef2f39ffffc3ffee33f16bc02000000 +003f0c92288a16f7b68e8ccec81a0c5abd5ebb376835fb699a663ded4e3f2985711c267178e29ac644a3dc59e877ba834eaf3f8a54c3d186d9340c9aed6c78d4 +6a0ec2a037b7d0ee7707fd5e3f9bbbd01ed42aa3b90fdf3bfccbbffccb8b5ef4a20f7ef083575e79e5c3f72d00000000000f5ed2ed0f6ac3a45a4e5aa552a594 +ec9d6dddbc7dffa9ed5eb7dd9b9d6f4551b463cfc17aa57aeae655638df2b39e72d6a1e9f6d6bbf6ed9b69ddb16ffadc9356af9d6894b289d564db8efdade620 +29a5fdeee0cebb0ef6d3e144a3ba7fb679dbaea9d336ac3a65cdc4c3f4029ffbdce77efee77ffe631ffbd865975df6307d0500000000c043956cdab062381c6e +dd36d5e90d66173a699a6e58516b54e3ac73dddac94aa572606a7638485bcd5ed6d38afaad4e378ae34625d930d9e8a7c1f442a7bf6f666ebe9cf687491cb65b +697f90ce77fbd9d29361582b8d86c56134b5d07e389efeb39ffdeceb5ef7ba4f7ffad3e79d77dec3b13e00000000c0f72779fc25a76fddb6ff23fff0afa552dc +eaf64e5e3b71d6896b07c374380ccf3963e3c4cafa97bf7253af9ddeb5fd40948641308c4a61b55a5e315e5f3d51bf7de7d46d07f6972bd160189fbd7155bd9c +ecd871b0ddeddeb673a6512f6f5c3d3ed1a8ae1cabdeb977fab6bbf617fee89ffce4277ff3377ff39ffee99f4e39e594236eb55aad5aad56f83702000000003c +48c9aebdd3ed56ffc4132626c7c756af9988d241b5141c38d49e9a69ad9d1aed833d30d38dc3510e3b1c0e9224995f686fdd3eb562bcba66ac72fae6b5a79fb1 +f1e0c1e9d999f6a613578e35aa83c1b0dbe94db706d9d2fb663ae3b5f2eac9caa9a7acde74d2da629ffbfffedffffbfbbffffb575f7df59a356bee7ff7c4134f +fce217bf68332c00000000b05c92435373835ebab6513b6df3da273fe5dced3ba6a60f4eefdcb7f5b63b779cb8ae160dd32dbb66cae5e8f9573eae520a4bf5ca +d62d7b3ff14fdf78fc85a76d3871c38ad52b4edcb4e69a2f7d7bcb6dbbce3eebc455abc7babd41bbdd3d34dd3c34337bcbd66d8f396dc3058fd930be627cd3c6 +d5c77a822d5bb6ecdebdfbf09e1b6fbc316f54abd54b2fbd340c8f724ed7eb5ffffaf7bce73d37df7cf351d73cb4e807f85900000000007e20c977b6ee1f6f54 +1e7bfe4983fef09a2fdf1c4541bd14d6d79db6a172f6aed96dfb67f6ac5f512b95e37d7b0f85495c2fc5b3ad68c3854fadae4d0783c1ae5d0776eedc5f2e2767 +3fe6e4f9b956b3d51d0e87ed56b7dd6e46e5dabac73ea53a364cfbbddd7ba7f6ec997acef38efe04575e79e5adb7de7a78cf2ffdd22fe58d6ab57ad34d379d7a +eaa9f79fb575ebd6e73ce73945ff1a0000000000c548be79fb9e534f5af392c79e7adb6d3bbff42f379d78e2ead34f1aafacdd3cb1f1f4ad9ffdb3d6c13d8f3b +6b63a35a9a9d9d8fa2a81b0cdbf1aa89732faf057725d12ddb77ceedd871e0c93f7edea9a79e70d3b7ef5868764b49d0e9a6fdee20ad8e8d9d75793dd85f0abf +7d68dfdcee9d53c70a4a6fb9e596efe3b987c3e10ff2da00000000000fabe4d47513abeaa5db6fdfddebf59ff0a4b3e6e7dadb76cff7c2ef8e853b36d407bda8 +31180cda9de0d0cc421c45d9844e30a8075fee46f33bc399c91563eb379edeeff6eeb863cf200db2fbd3d3ed344d57ac1ceba5417bf75787617b47345fafd72f +bc78d572bf2900000000c0f193ac19af8c954b53070e8d8dd5cf38ebc4efdeb4fde6ef1eaad7e74ac1aec9721094c792281c0e877b76cd467150a99483e15c2d +d8db0993ed9dfef9e7af3ce79c936fbd75c7d481e952298ea2e8e081b9200a376f5ed76ab50eedfb6e272addd5ea9e73eec9679db569b9df1400000000e0f849 +7afda0d9edefdbbf30dfec8551d26ef74f3a6975abdd6fb53ac361b7db1bec986bd62ae51f7ffc19cd56e7abdfbaab512faf6ed4eaf5caaa55713678cb96ddfb +f6cc34db9d6150ee07611c27fdb4bf63f7749aa64158a955cb2b578d0f7ae996ad3b4f59ee570500000000386e924130ecf57ab3b3693aeccfcd95833458b5aa +be77f76cabd9ed4783eceedee985462dddb871c5a199f65d7be7d7aea88e97e2894665edaaf166bb3b33bd303bd76a363bbd281c951de87787c341bbdf8fc351 +81827abdb266d578a7dd9b3e34bfdc6f0a0000000070fc24611c2c74077ba6db93cd5e92240766dabba7e62e3c73c3e39f70c6f5dfbca3dd693de9bc93e328bc +e6dadb2a95d24b9e7b511205e363d53b771cfcfb2fdd76e2dac69af1da8efd7353cdcea6d561250ece7accc634187ee68bb78e35aacffb89f3eeda75e053d7dc +bc6ee5f8daf1ea72bf2900000000c0f1930cd2a0ddeaed9d991ff4cb6b6aa58333ad3b764d5f74ce891bd64d66b7fbbd74edcada300d6eb973dfeac9b1c75f78 +4a2f1dd66aa5bb764e6ddf335d4bd2723a3838b330d5eaae6994e34a323e510fc37066a11dc4d1bab5e33b0f4c6fdf3d1ba74165d85fee370500000000387e92 +b593b5c97aa5564ac7d69f5ebdf0396bb75e1707d735e73b37ddb4bd5189cb6b1a5b77cca6611ac6517bd0bb6debdee1a09f24e5ce7cf7319beaabcebaa87ada +8f9df48dcfacda7bfbfab513b552b26bc75414453ff38cf3fbddc14d37ed9c9b699db3a13a79e6058dd31ebfdc6f0a0000000070fc24711c9786613589a37239 +ac4f96abb57aad3c0c8266a71bc651323a6fab9d5d96c26898c6cd85561a0c4bc9a09f0e6bd538a98f05d595a55aad9a94ca9952d46c36b305d7ad59d38c3bd3 +d3ed340d6af56aa55a0f6a2b96fb4d01000000008e9fa4d3ee6756af6a940653fdeb3f70e6a655a7fc9bcbfbfdb4548aafbde6e6830bed675ef1d85ab9142749 +b3d9fee6d7b7ac593b79def927f7bb8352e9dcdbefdcbff3860f4e0e07f5c946ed9c67242b4f6cffcbfbd3b9996f7ebb3d3659bbec09e7f4d35e929cb56dc7ec +9d5fffeb20f8f9e57e590000000080e32409c2611805d56a75380c86ad85206824513c0c8324490661928da8954bf54a391a6d76edf707d9a0b0542a0d876132 +1ad71fb617e25a39aa26e572392e952a954a9a56dafde1683b6d290e7a41298e936137e83497fb4d01000000008e9f241d0c1bd5cac99b4f989fe9ecd93bb56b +c7a19ddba756ac6c9cb06632ed75c330dcbd732a4ec252299a9bef7cfbce7dd3edde861326f6ec9f9d3e3417c76194c4ab568f4fd42bfd035f0e0e44a75d7862 +186e1c0ec36ea7bfe3cebdb3f3edfd0766a24c2959ee370500000000387e4691681a06e1e82f0ca2e1200d3a9d41bd33e8b4bbfd619a75f6b2aeec4e14a4695a +ab969228ec75fbd95fbb33289793d1ec6c62324c3bfd34bd7bd176a7d7edf67ae9a0d31b0dab54a2281c2ce75b02000000001c5f49b73fa80c935212c5c930fb +3838dbbc65c7a1535b93cd66bb39d71a86e18e1d07aad5f2c927ad6cd4cbcf7bca63e69aaddbb71ed83f3d7fc7fe43679db86af5582d8a825254dab167aad949 +c370d8eff7efd8363348fb13f5dafed9e6965d074f59b772d3eab1e57e530000000080e32759b7988aeedd3fdb6a769bad7e3f0d261a491226c3613836568b4a +51abd5cb7a7bbdc170380ca2b4df0bd2613f8a835a29c9fa5addc1dc6cb7df0fbae948a79b76bb69abd3ceda8d4a920461ad52ca26b6babde57e530000000080 +e32779dca5676cdf39f57ffef11bd55ab9d31b6c58d1b8e0d40dbddea0d71d3ce6b19b564c4c7cf9ab37f5bafdeddb0e65a347e50582208ae255e3b5135634ee +3a307be3f63de51d49371d9eb56165bd5adab9f350b73fb865e75cbd1cad9e189b6824174caedb7d60ee9b77ee5fee370500000000387e924f7ce69bcd4d4f99 +bcf8e443377d3a08c2ed079b3ba79b6914ae1b2fa7dfbeab970ed3345db766627cacf6a56f6f3f30b3f0ff3eeb924a39beebae7d73adeeb6430b6b1b6327adaa +e5c36af5cac478f5b63bf69fb2b6d13de5c9b7a7c9d44d9f0dfabd601084e170b9df1400000000e0f849a2288886dd280de34118a669508ea341d8e9f692612d +8a92301d8441508a934a1c95b29b83288ea2388ecb9552a933087bc378184451290afae960980d2b27a53009a35e10a583781825836190a6d99c200897fb4d01 +000000008e9f244a073bbff69952929cb97e2c8c826a12cf34bbb7ef9e3e30d3cafea228e80ed2f189faca95b5135757d68e95a60ecd0d8783388efbc37e344c +a7e6160ecd37a328ca86d51ab575abebd524e985bd3ddfb83a08c33337344a61a3542acdb7bbcbfda60000000000c74f1286e14463b45f756cbc160da374d02b +97cb6b568c0551180561bfdf4f9b9d288ab2a195fa645a4a8741301c86d94792242b26eb711c0f3383c160a19b0d1b66b38669384cc76ba30db263e3d55290f4 +bb8372122ff79b02000000001c3f49f6bf173ff7f163d551ad8066b3fbd56b6f3ff98415cf7bf645bd41bf562d7ff7a69d77dcb1376d77b7debe7bec712fae4d +6edcf985f7a50bd39dc170c5cac62b5f7c599a06d572b4e58efd37dfb43decf7b6deb67fa1d54d92e485cf3e6f7cac5a8e93b966ebfaebb6ac5f3db9dc6f0a00 +00000070fc8cf6bd0e87c37e1a9582b83fe874066937eda741d8eba4fd6e6b301824711825611244d5603e0a661a8d24886bd57e50af26691ab43bbd6e77d8ed +b5932489e3304cc2b8170dd360303a7d2be847697f30eca6836ccd07f334fbf6eddbb66ddb9a356b366fdefc30bf3800000000c0c32889a2e4c0dee9300ecaa5 +787ab67de39dfb0e35bb276edcb76fcfdcd4543329459935ab27c61b95fea1af85d3e199179f1805f1300c3aadee9e1dfb0fcd2c1c38381fc771180d57ad9e5c +3559bdf9b63d730bed43fbe7e667e693249c9bef656bae5d39fec0cf71fbedb7bff6b5afbdfaeaab87c3617679eeb9e7befbddefbee28a2b8ecb8f0000000000 +50b0240c87ed4e3f2985a5242ac7d189abc726c62bdde6a0d31db47abd7a5cca06a5c1300d83762f4dd3a8d5cc9abdf985762fd3ed67c3b266a33a5a6b381ca6 +4110455118869d6e6f300c1b71358ee38dabc6c7c7aa0ff010b7de7aeb65975d76f1c5175f77dd75e79f7ffef6eddbdff9ce773eeb59cffae8473ffad33ffdd3 +c7e57700000000002852d21bf477ec39582f974e3d756d63acfcaca79c7568ba7dc7b6fdfb665a5bf71e3af7a4556b27c6ca49a9524db66fdfdf6aa7e552d8e9 +76efbaebe060908e8fd5f6cf366fdb75e0b40d6b4e5cd528c551a55a1a0e87bd41ba6bef7435299d7a5ab5de489e71f959730bed633d4136fe652f7bd905175c +f0e94f7f3a8e4747729d79e699575d75d5e4e4e4cb5ffef25b6fbd75ddba75c7f10701000000002840b269c3aa0353f3c3346c2e748761d06af65b9d6e18258d +4ab261b2d14fc3e985cee0c0eccc7c32180ce32868b5fbbd7e3adf1dd56f9d08c35a29593f311687d1cc423b8de2b966bbd2289d3cbe6afa5073180e9bad4e38 +0c9a51bfd7eb1deb093ef5a94fdd70c30d37dd74531ebc2ef9dddffddd0f7de843ef7ad7bbdefef6b73fec3f030000000040a1920b2f38e52bd7ded26d0db66f +9f5aec19c64958ad26138deaaaf1daed3ba76e3bb0bf5c4e064178f6c6558d52b27dfb8176b77febaee9b15a79e3eaf16cd8cab1ea5dbb0fddb26dba5e2977bb +fd9f7ef6c5e79e71c217be784bbbd9d9b16d6a381c86617044ae7ab80f7ff8c3575c71c559679d75447fa55279f5ab5ffd810f7c40f60a00000000fcc8490e1c +9cdf3fdd8983f0ec334e08c3308ec3f985f6d6ed07564e34c6ebe5d337af3dedf40d53533333d3ad4d27ae6c8c55d3feb0dbe94db746fb58f7cd74c6eba5d513 +d5534f597bd2a9eba7a7e7a6a69bdd5677f79e9903b3ed41b777ce99eb93248ac3a8d53ee6bed7ebafbffe15af78c5516f3de319cf78d39bde343535b56ad5aa +87eb070000000000781824b38716b6ec3a542d452f78dea54929a8d5aab76fd9f3897ffac6e32f3c75d386f5936b569cb869d597aff9eeedb7ee3cfbac1357ad +1eebf606ed7677ead0dca1b9859befd876ee291b2e3867fdd8e4c4e6534ff8ea576ebdf9e66dfd5eefe0d4cc1d7b0e0683205bb3562fc549b277cfa1633dc1f6 +eddbcf39e79ca3deca37c3eedcb953f60a00000000fc68496eba73cf092b6be552bc77cf545c4a2af1c26c2b5a7fd1536b6bd27edadbb5ebc0ce9dfb4ba5f8ec +c79c3c3fd76ab6bac3e1b0dd6e77dbbdb8543be1bca7d4c683c1a0b76fdf74363d0c878f396ff36d77ec99dddd5e33518da3e8e0dee9385b3a8ea69b83633dc1 +fcfcfcc4c4c4516f4d4e4e669f7373730fd7db03000000003c3c926fddb6eb71676eaa5792d9d9f9288a2ac1b01daf9a7ccce5d5e0ae7278cbf6bdb33b761c78 +ca531fbb79f3baef7ee7cef9a94e29093addb4d7eba7d57ae3aca7d482bd95e0db7b0ece6dbd73cf932e3bf7bcf34efee237eefcf66dbb9e7ceec646ad7c686e +3e89e372182e4463c77a82e170987def516fe55562d3347db8de1e00000000e0e1919cb47ab23fe875bac1a19966940983f6707f23f872376c6e0fe726578cad +df38d9ebf5eebc736f7f308ca2607aba9da6c18a95b5de70d8daf59534ee6c0be6aaf5fae31f7f4e9aa6b7dfbe67b29a9c76c2f86030e8747a33b3adc55c7538 +088e59ef1500000000e0912759373116c4c3e120ddb36b268a834aa51c0673d5e1de6e906cebf42eb860f29c734ebef5d61d07f61f2a97e2288aa60ece0fc3e0 +9453d6763abde1de9bfb71b2add93bebacc6398fd9b4e5b69d07f7cdd493e8841563a578b4a175d7ee99240aaae57210348ff504711cf7fbfda3deeaf546896d +92240fd7db03000000003c3c9256afbf7faa59ab947ffcf167b43bbd6bbf7147a35e5e53afd51a9595abe376bbbf65cbee7d7b669aedce3028f7833088a26098 +eedc7368540920ac641357ac98180efa5bb7eed9b36f6661a1998decf6067ba65a713979ea8f9dd1eb0eb235b361c77a82898989a9a9a9a3de3a78f060704fd5 +5700000000801f21c92018ee9d5e68d4fb1b37ae3834d3be63dffc0993d5f1523c1655d6ae1a6fb6bbd387e667e75acd66bb1785833488fabde17010767b619c +44e9a05eafac5e3dde6ef567a6e7e6e69af3739d6e7f9086c1beb9f938296f5cbf726ea17dd7ded99563c7cc5e4f3ffdf41b6fbcf1852f7ce1fd6f65fd711c9f +72ca290fe72f000000000050bca43f4c2f3befa4288aaeb9f6b64aa5f4efaebc28898289f1da1ddb0ffcfd976e3971edf89af1da8efd7353cdcea6d551258ece +7accc634187ee68bb74e34aacf7dda63efdcb9ff535fba75cd8adac695f51dfb16a6e67a63b5a05a293deeec4d9538f9ca576fab56cb2fbef2e2fcd4aca3bafc +f2cb3ff1894fbcf9cd6fbeffadacffa28b2eaad7eb0fe72f000000000050bc64d04bd7ac6864ad9befd8bb7a72ecf1179ed24b87b57a7ce78e70fb9ee95a1294 +87bd83330b53edce9a4639ae241393a3c1b3cd4e90046bd78cedd87f281b1685e978329c9e69ee9d5b288563a5385933598f93e8d62dfb26272bd99afd617aac +2778d9cb5ef6ae77bdebeaabafbee28a2b0eef3f78f0e0fbdffffeb7bded6d0ff74f000000000050b864fd9ac6961d5341144649dcedf76edbba773848932469 +2d74cf39b1b1faac8baaa7fdd849dff8ccea7d5b36ae5951adc43bb71f8ae2e10b7ff2b1fdeee0a69b76cecdb4b2612b4e3baf7af653367cfbea89eddf5db972 +45a91adeb16b3a5b338dc35e7f78cbedbbb36fbaf4184f70e9a597bef8c52f7ed5ab5e75edb5d7ae5fbf3eefecf57aaf7ce52bd7ad5bf79ad7bce678fd140000 +00000085499224eaf506592b8aa234489a0badc130ad94ca699ad66be5a43e36acad4caad54a9c94aaa55212b65a0bd9c875abc79a716f7aba99a6412debaf34 +82eacab852af9492a414969352af373f0ca2388afa6990ad1986e1033cc455575df5b4a73ded924b2e79c31bde70c10517ecdab5eb3def79cf962d5b3efff9cf +572a95e3f55300000000001426692ef49e79c5636be55298c4ad56e75b37dcb1f68489731f7b52af3b2c97e22d771dd8f1b50fae4c07ddc946f5ec67c6931bdb +d77c703037fdcd6fef189bac3de989670d06c3243967c78ea9ad5ffbc0ca20edae9e68757afd7effe94f3d77b2560b16d7bcf19b774c2e562a3896c9c9c96bae +b9e61def78c77bdffbde6ddbb6ad5ebdfaca2baffcd8c73eb671e3c6e3f64300000000001428c9fe572b97aad5729224616fd04f07c33428954ac3613f49a228 +eda5adf9b851ad8449a5528a2a49b99ca483b8dd0fa328ca8685c341298ee260306c2f44b572ad526e77dbe930a896abb55a36291ca6fd5ebee803aad56abfb3 +e878bc3400000000c0c32c09c370cfae43511c944ad1ec5cfbc63bf64eb77b1b4e98d8b37f76fad05c1c87712959b96a6ca251eeefff4ab82f38ede28de170e3 +7038ec743abbeedc3733d7da77602e8987c35269e58af18995d5deedfb66e75bfb761f3c548ecb7134b3d0fece5dfbd7ce3597fb4d01000000008e9f240ec34e +7f5009c3c120180e87f55a2589c25eb79ffdb53b837279b4737554ad358ad26e274d83200d8370d8eef43a9db43b483bbd7ea7d31b969328ed05d13089e2d1e0 +70d84b87719af6a3d19ad54aa992c4cbfda60000000000c74fd24fd35d3b0f96cb95934f9a68d4cbcf7bca3973cdd6ed77ecdb3bddbc6bdfa13336ad5adba8c5 +61528ae3ed7b0fb4daa3d201fd5eba6dc7c15e3a98a835f6cfcd6fdd3d75caba95eb262b6118268b61eba01fecd875b0564a4e3e7955b6e6739e7276abd95bee +370500000000387e92f1897aabd58907fdc16038520a7afd34934441ad94a483a0d31fce2e2cf4837e6f905d0dbabd41bf9f36bbdd340d06955e3c4cabe5241b +df1f0c179abd206a26a5686265bdd3eaf67b69b654301cc67130180c96fb4d01000000008e9fe4098f3bf3cbd7dd3ce8f4efd87a20bb1e86411c86e552bc72ac +ba66b276e7ee99db761cac969241303c7dfdca4629d9b6ed40a7d7ffee8e997a395a3bd19868942f983861c7fe435fbb6dba92947abdde954f3fff9c534fb8e6 +da5b5aadce5d771cccbf268a87cbfa9a0000000000c75532bfd06ab57b691aac5f3d1e454914059d6effe0cc42bd9c549264edeaf1c664add5ec349bddd5938d +5a35190c86ddde60ecc042528a663bfd521255e360f5e444a551ebb4bab3b361afd79f9e6fcdb43b835e6fe3da9541144641d8eff797fb4d01000000008e9f64 +ffbed9ef6e3b58aa949ffd9317544a61a95ad97ac7fe7ffad04d979c77e239276d9a58b9e2c44d6bbef2e59b6edbb2e7dcf34e5ab3b2d6ed07ad76bfd96ccf2c +2c7cebb63bcf3ce584c79c7ecad8c4c4a9a7aeb9fefadb6efeeece41a7b367f7c15bb71d0882e8993f7961ad9ac471bc67dfec72bf2900000000c0f193ecd87b +70a25eae944a33d3cd3809aaa54eab3b5c71f263ca63b5c16078686a7e7ea11d45d1a60d6bdacdf6fee1304d87ed56b7d7eb87716de2c4c7545694d2349d9f59 +b8f9d6de200d4edcb4e660736170a8395eab64ab676bb64ba53819ceb7d2e57e530000000080e327f9cab7b65f74c6867a29dcbfef501cc4a5a83f1baf5c79e9 +0baac15d5170fb9d3bf6efda71e8f2cbcf3eff8293bffb9dbbf61f984d92a4d3ed753a9d6175e58af39e571fee49c29b76ec99da7ad781273cfe8c4b2f3eed8f +feeaf3dfddb2ff8967adaf574b07f64f27c3308e82b9787cb9df1400000000e0f849d64dd6fafd7e3b8867173a61669876a243b5e18dbd78766fd86c34aae79c +bba9db1becdc3ed51f8ceecfcc2ef4d3606cacd68d86d1be6f0da2e69eb055aa94cf3bf7a4344defda76a09e2427ac1aeb0dd256279d9beb45711a05613bb0ef +1500000000781449d6ad9848e234b36de7812808abb552349cab0d77b7a3f0b6f6f0e2f3373ff69c936ebe75d7eeddb3a572363eddb37f3a08a2d34f5ad36977 +0fecfbd76e106de9a6e79c79e245179db2e5f6bd3b771d6c944a27aca82771300cfadb77ee0be3a05aaec4e172bf2800000000c07194b47bfdd9f94eb9145f72 +d6c65e7ff89d2d7babe552a39c54cb95b5f5a0ddeade71e7be4353b3330bed302af5d3200ce3611aee3a303b1c0efb61a9522ead1b2bf7fb836d774d1f3838db +5ce836bbbd412fddbfd08be3f8a2733664b7beb3657f398997fb4d01000000008e9f641084dbf6ce8e552b675cb9fed04cfba3fffc9d1326c74e5e531b1baf9d +72e2aa8566f3c0d4ecfe43b3f30bed5e54ef0fe2a897a651da9aedc6611205fd5ab572d2a615cd85eec18387a60f35b3719dfe3008c36dfb674aa5e4674ebb38 +9bf8b79fbf79e55879b9df1400000000e0f849d2c1f0c2d34f48a2f05fbf796794949e7df9599552bca251db3f35f72f5fbf63f5786345bdba7fba39d7ecad1c +2f97c2dec9a7accca6ddf0ddedb54ae589179c7268a6f9c51bb64e34aa2b276a7b67e6a7173ab552a91447e76e5e9744f1d7bfbd2dfb7cce6567663dcbfda600 +00000000c74f3248bb9b4f583f18f66fb9636ae58afad39f74ce6030a855927d330bdfbe7def591b570dc6eb7b0fce4f357bb54ab9520e36ae1bcfa67deacb0b +9313e9e927adfe66b373e3d67d27af9b4c3bc3d1b0b9ce86d58da451dfb4763c89e29beedcbf62bcfab4cbcf8e86cbfda20000000000c751d23ced297b4e3aa9 +542a9d7046d06c36fffe40f7ee3b6b369efffc4bbbdd6e6fc58ab36bb5aca3dfef6703bed41d66cebef29cace76f770795b59b7ffce79f96cf38330cb3017bf7 +ee0d57ae9c5eb122eb597dca20ebf9e4fe346b3f71395e0f00000000605924e3e3e3ed456118a6693a1c0e7bbd5edec86423e6e6e6161616f276d69fddedf7fb +954a258a4665043a9d4ebe50363debcc1a939393597b7e7e3e6be78b0c06836cd6b2bd2200000000c07197542a95c16090b5e2380ec330fb6cb55a699a964aa5 +3c36cd73d87c743e20ffcc1cb156d69f244936319b924d5c1a935df6fbfde3fc620000000000cb2869341a0b0b0b61188e8f8fe7db54676767fbfdfefaf5ebdb +edf6cccc4c6951d69f8dc926542a956ab57aff85b2bb4b633a9d4eabd5ca86651383c5ec355bea38bf1800000000c0324a0683411eb9369bcd6031270dc3308a +a256ab95170ac877adc6719c8dec7647d55eb3bbf994c32b0964b31a8d46d61895885deccf17cc7bf2101600000000e05122c937bda6699a5768cd4551343b3b +9bef63edf7fb83c1a05aad668d7c4b6cbeb9359bd26ab5827b76bc6653b231593befccb4dbedbc9a41a65c2e3f98a7d9b76fdfb66ddbd6ac59b379f3e662df13 +00000000e0784af220358aa2f2a22449e6e7e7f3f2acd56a756c6c2c588c59b3ce7c376b76abd3e98c8f8f974aa57abd1e2c66af594f76b7d56ae5abe59dd980 +6cc16c4cb7db9d9b9b7be0e7b8fdf6db5ffbdad75e7df5d5796dd973cf3df7ddef7ef715575cf170be3b00000000c0c325c98fd28aa2288ee372b95cad56dbed +76bfdfcf3b2b954a704ff61a86611ece068b59edd2515ad9c86c40bedc6030c8e7068b8777458b8e7a30d7e16ebdf5d6cb2ebbece28b2fbeeebaebce3ffffced +dbb7bff39def7cd6b39ef5d18f7ef4a77ffaa71fee9f0000000000a070c9d4d454b05813607c7c3c2fd51ac771a552c9b7b2cecdcde52505b2015967bd5e8fa2 +2858ac27b054a320bb5bad56b3e979ff810307f2a2b1939393d952cd66339f7eac27c8eebeec652fbbe0820b3efde94fe711ed99679e79d5555765d35ffef297 +df7aebadebd6ad3b1ebf04000000004071923c4b0d1637b7e67b60f3b035efc90fd7ca2b09248bf276bfdfcf6e2d8dcc1a7969d7acb352a9e49df9615c79fb01 +7cea539fbae1861b6ebae9a623f6c6feeeeffeee873ef4a177bdeb5d6f7ffbdb8b7f6f00000000808753b262c58a6031276db7db4bbdc34559a3d3e92c752e15 +16c843d5c3b3d7ac9ddf8aa2686c6c2ccf67b3b94bfd4b7560efefc31ffef015575c71d659671dd15fa9545efdea577fe0031f90bd02000000003f72925aad96 +6f6ecd8b061c2edf12dbebf5fafd7ef639180ca6a7a7f314b5d56a659da552298ee3ec331f5fad56f3d2aef9aed846a3b15410f601b2d7ebafbffe15af78c551 +6f3de319cf78d39bde343535b56ad5aa42de1600000000e0f8482a954aafd70bc3707c7c3c4f488fa812d06ab5b2fe7ebf3f180c9acd663e20bb4cd3343f472b +49927c4ab65476990dce6b17944aa5bcccebd22edaa3dabe7dfb39e79c73d45bf966d89d3b77ca5e01000000801f2d49b3d9cc8fc69a9f9f0f17753a9dbc786b +2e6b0f87c33c69ad542a79e7ca952b4ba5525ee6b5dd6ee71b63b389f9983c69cdfaf39205d998a5e203f7977defc4c4c4516f4d4e4e669f73737305be300000 +0000c071902c1d8795e7ad59bbdbed0e16e5f504c230cc8b0fe48d7c6f6c762b6ba7693ab8479ecfe61560f376befb35582c147b78987b846cccd2795f47c84b +162cd5990500000000f85191048b2765e5f9665e9875e9f8ac7abdbe76eddabc7f6161612903cdc6b4dbedfc78aea589f98ed73c457de08dae00000000008f78 +49be9b75a924eb5261d62449b2fe6eb79b1fa855a954b2f6dcdc5cb95c6e341af9015c4b83f3c436ebc9a6e413b359870f7800f9d95c47bd957d4bfe24c5bc2b +00000000c0f1323a26ab5c2ea769da6eb7f37a02c162969a6f626db55ad9e55215d7858585ac5dabd5b2f66030c823d7a513bab29e6c9dfcb8ad7ccd7cccd25e +daa39a9898989a9a3aeaad83070f06f7547d0500000000f81192e43b5bf3b4344992ec73e95e1445711c67030e1e3c98b5078341a552c906e4c96c36ab5eaf77 +3a9d03070e649d593bb8a75c6c5e28365faa56ab1dab9c6beef4d34fbff1c61b5ff8c217deff56d69f2d75ca29a714fdd600000000000faf643018e45502f272 +01d56a35bf91ef540dc3301bd0e97482c336c3f67abdac1d2fca0fd14a162d1daeb574c456dec86b1a1ceb092ebffcf24f7ce2136f7ef39bef7f2bebbfe8a28b +f2541700000000e047c8286c8da2a8dfefcfcccc2449d26c3683c5d8342f4190dd5d3a802b8ee355ab56f57abd7ca36b3638af12bb62c58a7abd5ea954161616 +b275b246b018d466979d450fbceff5652f7bd9bbdef5aeabafbefa8a2bae38bcffe0c183ef7ffffbdff6b6b73dacef0f00000000f07048f26034af39907da669 +ba746f381cb6dbede41e711c673dd980bcfe40bead352ff6dae974b2cb6eb7bb54ef35bb55abd5b23597d63fd6135c7ae9a52f7ef18b5ff5aa575d7bedb5ebd7 +afcf3b7bbdde2b5ff9ca75ebd6bde635af79787f000000000080874192ffa7542a6ddcb8b1dfefe7fb5ea328aa56abdd6ef7d0a14363636359bbd168e45b59d3 +34cd0667b7f26a03b9ec72e9dcad6c6e9eb44e4e4e6623e7e7e70f1f7954575d75d5d39ef6b44b2eb9e40d6f78c305175cb06bd7aef7bce73d5bb66cf9fce73f +9fefa20500000000f8d1922c2c2c54abd57cb36a5eefb5dd6e773a9dbcd26b1e7d663d79c1d66eb79b4fcb8665839756c92bbae6530e1d3a94ad56afd7f39e5a +ad96cd9a9f9f7f8087989c9cbce69a6bdef18e77bcf7bdefddb66ddbead5abafbcf2ca8f7dec631b376e7c38df1d00000000e0e132ca5e4ba5525eb935dfeeda +e974fafd7e704f2182ac31180cf2fdb0b96c64a3d1583a02ebf073b4badd6eafd7cb4b130c16e5a7781d5ecae0a86ab5daef2c2afc0d01000000008ebf647272 +324dd356abd5e974e2382e954a596fa552c937b1f6fbfda568358f62bbddeec2c2423632aff79a9779cd07e4db63c7c7c7f342b17921827c29a5030000000080 +4795d1215a83c1204f5183c5803513c7717ebbd7eb4551b47419df2358dc0c9bc7b2f9695af95ae9a23ca5cd0b11048b1b631fe0ac2d0000000080479e647a7a +7afdfaf5d56a350cc36eb7db6ab582c5047669bb6ba3d1181b1bcb1afd7e3fbb5b2a9556ae5c9967a9d99872b9bc62c58a7c64bec2f6eddbb3d5366cd8902fb2 +b0b0f03dcfda0200000000788449f2cdaac3e1703018e45b56f30db0f90ed660b1846b5eec352f2f900fcbabb8669d9d4e27580c6133f952f57a3d6bb4dbed7c +df6bbe785e401600000000e0516254efb5dfefcfcfcf2f7565974bf50482c57435935fe645605bad56a5522997cb79671ebf068b5562e338aed7eb597fd69997 +2f081693d95eaf77bcdf0c0000000060f924b55a2d8f56f3b203c1e246d776bbbd7af5ea288a666767b3cf2449f2d17929d855ab562ded7b3ddc5259d87ebf9f +ad90e7b3f982d3d3d3c7ef9d0000000000965b522a957abdde6030489264e974acec32ebcf37aee6676de5b16c9aa659bb56abe5a50996f6c6e6f261d9dca593 +b5f25a0487f700000000003c1a240b0b0b7969d7a9a9a9a5e0b55aadcecccc048be1695e8220dfc19a75964aa5bc2c6c76abdd6e1f1ebfae5cb9321bd66c36f3 +c3b5e6e7e7976a17e4d301000000001e25927c536a7e2856b0b87735dfac9a07ac954a65a966eb605176d9ebf54aa5529224d9ddc30fe6ca8bbae63dc1628182 +288ab29179f9d7e57b470000000080e3edee42ae511495cbe552a954afd7e7e6e6e6e7e7f3d2ae2b57aecc0b111c3a74a8dbed068bd16aa7d3a956ab8d462358 +cc64b391594fb3d9ecf7fbbd5e2f1f9f75e65562c7c6c6b2cb7c2e00000000c0a344d26c36f356b55acd73d5e170582e97fbfd7e5e5560294bad542a8d46235e +945d2e4d0c16a3db3c8a1d0c06535353bd5e2f9b52afd7b329795d8252a9b43cef0700000000b01c927c8b6b1445954a25af2a30ea4d92bc8c40bbdd5e3a26ab +5c2e8f8f8fc7719cb5171616966e65c3aad56a5ed135af48d0ed76b346bfdfcf3af31dafd9facbf68a0000000000c75d32393999b7f28dae4b37f2b2ad9d4e67 +297b8da2686c6c2c6f0f06837c876c7e379bbbb0b090df6a341af9b03cba3d5e2f0200000000f04324a9d7eb4b2765e5876ee5716abe5375e918aefcb3dbede6 +1b63fb8bf2317951824c5e8e202f2f900dcb7b96f5ed00000000009647d268349acde670385cb56ad5d216d725594fb7db6db55a79ea3a3d3d9d27ad9d4e27eb +a956ab499294cbe5bcb35eafe7edfce8adeaa265792b0000000080e595bcf18d6f5cee67000000000078a44996fb0100000000001e8164af0000000000c593bd +0200000000144ff60a0000000050bc1faeec75dfbe7ddbb66d5bb366cde6cd9b97fb590000000000be7f3f2cd9ebedb7dffedad7bef6eaabaf1e0e87d9e5b9e7 +9efbee77bffb8a2bae58eee70200000000f87efc5064afb7de7aeb65975d76f1c5175f77dd75e79f7ffef6eddbdff9ce773eeb59cffae8473ffad33ffdd3cbfd +7400000000000fd9f267afc3e1f0652f7bd905175cf0e94f7f3a8ee3ace7cc33cfbceaaaab2627275ffef297df7aebadebd6ad5bee6704000000007868963f7b +fdd4a73e75c30d37dc74d34d79f0bae4777ff7773ff4a10fbdeb5def7afbdbdfbe5ccf0600000000f0fd59feecf5c31ffef015575c71d659671dd15fa9545efd +ea577fe0031f90bd02000000003f72963f7bbdfefaeb5ff18a571cf5d6339ef18c37bde94d535353ab56ad3ace4f0500000000f08358feec75fbf6ede79c73ce +516fe59b6177eedc297b05000000007eb42c7ff63a3f3f3f313171d45b939393d9e7dcdcdcf17d2200000000801fd4f267afc3e1308aa2a3deca4fdf4ad3f4f8 +3e1100000000c00f6af9b3570000000080479ee5cf5ee338eef7fb47bdd5ebf5b2cf2459fe8704000000007848963fd69c9898989a9a3aeaad83070f06f7547d +0500000000f811b2fcd9ebe9a79f7ee38d37bef0852fbcffadac3f8ee3534e39e5f83f1500000000c00f2269b7db4774e5275c0d068323facbe572f6d9ed761f +e4f84c1445fd7e3f1b50a9548ef504975f7ef9273ef18937bff9cdf7bf95f55f74d145f57afd7bbf0700000000c00f93e46b5ffbda7038cc5a6118669f597be5 +ca9559e3d0a143794f2e6b9f74d2495963fbf6edf9f8dcfdc72fad96999898d8b265cbe6cd9b2fbae8a2633dc1cb5ef6b277bdeb5d575f7df515575c7178ffc1 +8307dffffef7bfed6d6f2bf27501000000008e8ba4d96c6ed8b0218ee3ddbb77a7699a75edd9b327b827425d1286e16db7dd96f71f71ebf0f1511465ab0d0683 +6cb5ad5bb7cecdcdedddbb77e3c68d0ff004975e7ae98b5ffce257bdea55d75e7bedfaf5ebf3ce5eaff7ca57be72ddba75af79cd6b8a7c5d0000000080e322b9 +e5965bce3cf3cc4aa5b277efdec343d5288a4aa5d26051deb37437dfdf1a2feaf57a876f9bcd66ad58b1a2d3e964cb5e73cd35cd66b35aad1ebe7ff6a8aebaea +aaa73ded69975c72c91bdef0860b2eb860d7ae5def79cf7bb66cd9f2f9cf7ffe018a150000000000fcd04a3ef7b9cfdd70c30d1b376ebcf4d24b57ae5c39bc47 +ad563bfffcf377ecd8b173e7cefb87a7d980134e3861d3a64d37de7863b3d90cef313535f5bffed7ffdab56bd7cccccc8a152b92243978f0e09e3d7bfafd7ed6 +3ed6434c4e4e5e73cd35ef78c73bdefbdef76edbb66df5ead5575e79e5c73ef6b107de300b00000000f0432b79ea539fbab0b0f0f5af7f3dfbdcbc7973bd5e3f +f5d453d72c1a1b1b7b80c034bb950d38e9a4930e2cbae38e3b9acde69d77deb973e7ce8b2fbeb8d1683cfff9cfdfb163c7dbdffef68f7ffce3699abee0052f78 +80e7a8d56abfb3a8f857040000000038ee925ffdd55fedf57a7ff7777ff7377ff3375bb76eadd7eb4f7ce2137feaa77e6af5ead5cd45dd6eb752a9846178ca29 +a76413eebaebaee1709875e677b36159fb0b5ff8c2b5d75e9b5d2649f29297bce4852f7c61a9540a16cfcbcae64e4f4fffe33ffee30367af00000000008f24a3 +6dada552e9f9cf7ffee31ef7b866b3f9fef7bfff5ffee55f6ebffdf67abd3e1c0edbed7676f7c20b2fdcb469d309279c900dbef3ce3b77ecd8f1cd6f7eb3d7eb +e5b55cb359bb76ed3aedb4d35efef29767b3366edc9807af99f3cf3fff452f7ad1c73ffef1657c430000000080e3efee9202b55aedf4d34fcf1afff13ffec78f +7ce42337de78e32db7dc522e97ebf57a18867bf6ecb9f4d24bf3aaafdff8c6376eb8e1867ebf3f1c0ef35db11b376ebcecb2cb5ef4a2176ddebcf988d5abd56a +d69f4d99999939beef0500000000b09c8e2ce7ba79f3e637bef18d5ffffad7efbcf3ce2d5bb67cfef39f0f164fd6fad297be74dd75d765eddea23c877dfad39f +7efae9a767532ebef8e2637d41a9548aa2e8617c0300000000801f3e473f4aebe245333333cf79ce73b2cb300cbff6b5af7df6b39fcdda3ff5533ff5b8c73d6e +381c66ed4d9b364d4e4e1ecfc70500000000f89170f4ec3537b9286f6fdebc79cb962d59e3677ff667ebf5fa43fd9a3cab0500000000789478a0ecf570e57239 +8ee3bcf150bf239b52a9541eea2c00000000801f5d0f367b0d162b0f7c1f5f1045d1ab5ffdea5eaff77dcc0500000000f811f510b2d756abf57d7c411886a79e +7aeaf7311100000000e047d783cd5e87c3e1a1438702955b01000000001e8487b0ef55ea0a00000000f0203d84ec15000000008007e92164af51143d7ccf0100 +000000f048f260b3d7388e5ff39ad7e48d87f37900000000001e091e6cf61a45d185175ef8b03e0a00000000c023867aaf0000000000c593bd0200000000144f +f60a00000000503cd92b0000000040f164af0000000000c593bd0200000000144ff60a00000000503cd92b0000000040f164af0000000000c593bd0200000000 +144ff60a00000000503cd92b0000000040f164af0000000000c593bd0200000000144ff60a00000000503cd92b0000000040f164af0000000000c593bd020000 +0000144ff60a00000000503cd92b0000000040f164af0000000000c593bd0200000000144ff60a00000000503cd9eb0f6ce3c660f7ee5163387c18bf65c38660 +cf9e87f72b0000000080e224c19a35c1fc7c70eaa9c14b5f1afca7ff143ce109c1b7bfbddc4ff58339f3cce0b6db7ea015366d0a76eebcf7328e47bfcf6b5e13 +bcfef5a3f61176ed1a7d86e10ff48ddfd3eedd0ffb570000000000c54982ef7c27989808b66e0d3ef8c1e0e94f1f5dfea8bbfdf61f74851d3b4641e7d226d34e +27f8d77f0dfee37f0c666783b7bef5075d1c0000000078144882134e18fdf7bcf38277bc23f8c42782e73f7fb91fe9874fa5123ce949c1473e123cf9c9b25700 +000000e0c1b86fbdd7e73d2ff8955fb9bb7dff02a3679e79f796d2c33bcf3823d8b2e5eece830783dffccde0c31f0e56ad0afee7ff0c9efbdc873026f3c10f06 +ef7a5770d34d41ad163cf5a9c15bde125c70c17d1eefd453833bef0cf6ed0bfec37f08fee11f82c9c9e0c52f0edefef6d1f8dce9a78f36f006875500d8b429d8 +befdfbfd71eeabd309a2e821cfca5ef9031f08aeba2ab8f1c651fbfcf3835ffcc5e015af38b28040f652ffe5bf04fff7ff8eb6d63eee71c13bdf392a71f08d6f +1c7dcd3ffff3e095af1c351a8dd116dd152b8e1cf00bbf10fcefff1dfcd22f057ff0070ff981010000008022dc377b0dc3e00ffff0eef6fd0b8ce645548fe8cc +d3d8acf35fff3578c94b82d7bd2eb8ebae51d2fa8fff786faefa60c6bcfef5c1d7bf1efc8fff115c7cf1287ffce4278317bc20f88bbf082ebffcdeefbae38ed1 +223ffbb3a315defffed113fefb7f1ffceaaf8e92cd5c9ef01e5e2ea010d9f35c7b6df09fff73f0ee773fb48983c1e87df7ec09def6b6e0894f1cf564ebfcceef +049ffe74f0d77f7d6fe9d8a9a9d16b3efff9c135d78c22efebaf1ffd1adffce63197bde082e0a28b823ffdd3e0924b8e3ee0231f1925c5d9a7ec150000000096 +49f2bd873c483ffff3c1dffd5df0d8c78eda975c72f458f058633efff9e0861b82abaf0e4aa5d1e5f8f868e7e6139f18fcdccf8dfa8fd86dfadffffb686768e6 +b4d382f7bd2fb8f0c27bb3d7621d9132bfe635c115573cb415def9ced13966fffccf4172cfef9cadf0d4a78ef617ffc11f046f7ce3dd9d6f794bf0cc678ede2b +f7133f11fccddf8c360b1fd5673e334a6fffcfff094e3ef998dffb177f117cfce3a3c3d3000000008065525cf6fab9cf056bd77e9f63feeaaf8237bff9eee075 +c9f9e78ff6c05e7f7df08427dca73f0f5e73279f1c4c4f7f5f8ffb202c6d9eed7647850b3ef6b1e0b2cb82bffddbe0ecb31fec0a7ff227a359c97d7fe4ecf21d +ef08feedbfbd377bfdf8c7834f7dea3e63b2f73aeabed70f7c20f85fff2bf8a77f1ad55b7800cf7bdee80f00000000583ec565afdf33787d80313b76043ff993 +47bff5133f7164f67afc95cba34ab26f7843b07efda888ead5573fd889dbb71f3da83de79c51d58525bb76059b371f39e6318f39cac4cf7c6654a9e04b5fba4f +9d5c00000000e0874f71d9eb0f62e3c6d196d8a73d6db99fe37b79fef383d7bef6218c3ff9e4e0965b461b788f70ebadc18927de7bb9766db06ddb2890fd9efe +f22f47c5619ffdecd11ee1673ef3213c0900000000707cdd377b3d706074c2d59ffee9dd3960bd1e1c3c18ac5e7def80af7ded61798a9ffff9e04d6f1a9d3755 +2edfa77f383cb2e8ea8351a98caaac8e8d15f574f7bae186e0d4531fc2f857bd2af8f55f0ffefeefef3d562bd3eb05ffe93f8d6e2d79ee73479504b2bfef29fb +35b2ff3bb2059ff39cd16ff5133f71f4619ffad4a820ec4b5e72cc0100000000c0c32c196dcc3cedb4d16eca4f7e7274e8d3affffabd1b309ff9ccd136cf77bf +7b74f8d5b7bf3d2a36fa3065af4f79ca2825ccfe7efbb783c73f3ea8d5823bee08aeb92678ef7b473b3dcf3befa1ad963df6affc4af0d6b706ab568df6935e7f +fd284dcefeb2d7fcbeb55aa303c17ef11783fff6df1ec2ac37bc21f8ea5747ef95fdb04f7ce2284afef2974729f3860da3df7949f6a83ff663a3c8f8977e69b4 +0578c78e5155813ffff3e0777f777430d7fd9d7042f0894f04575e19fcd11f8d02ebfb7be94b839999e01ffe6154f40000000000580ec968d3e5f6edc18a15c1 +d39f3e3a48ead24befbdf9277f12fceaaf8ea2cf767bf40fe75ff6b2e00fff701411ae5f1fecde7df78ed4534e19e59b4170ef06d5534f0db66ebdcf973c9831 +6f7ef3e810ad77be731495a6e92827bdf2cae0a31f0dce38e3ee018f7d6cf09defdcbdda52b1d4ac7d444fb07820d56ffee628c39d9a1a45994f7b5af0f6b73f +b4e0f5a493eef3b499280ace3a2bf8bddf1b6d263d62e48e1d77b7f3f1594ffeb2c1e2b15ad94ffa677f16fcd66f05dffad66840f616bff88bc12b5f799fc537 +6c1865b2d933ffd88f8d42de934f1e85d1ffdfff779f2a04d998c37de843a3059ffce4606222d8bb37a856ef73f7677e669459679f00000000c0324982db6f3f +e6cd356b82bff88b233b87c3fb5c1e1e7a1ecb8319132cfed3fb073842eadbdf7eb02baf5c39da309bfd7ddf1efc76d1ef39320c47e5050eaf307054279d7494 +9ffa70bb77dfe7f2d77e6df4772cf93e5f0000000060f9fc709cb50500000000f0c8227b0500000000289eec1500000000a078c9eb5ef7ba934e3aa9542a6517 +cd66b3dbed2eddebf57ad9e58a152b6ab55a76d9eff7b301c345e13d47455516e5edac331bb077efde952b5766b3b29ec16090f5a4699ab5dff6b6b71ddf5703 +000000005836c9f8f8787b511886699a0e87c35eaf9737868bc76acdcdcd2d2c2ce4edac3fbbdbeff72b954a1445594fa7d3c917caa6e721ece4e464d69e9f9f +0f46e7728d0c06836cd6b2bd2200000000c07197542a95c16090b5e2380ec330fb6cb55a699a964aa53c36cd73d87c743e20ffcc1cb156d69f244936319b924d +5c1a935df6fbfde3fc620000000000cb2869341a0b0b0b61188e8f8fe7db54676767fbfdfefaf5ebdbedf6cccc4c69d1529d814aa552ad56efbf507677694ca7 +d369b55ad9b0bc94419aa6d952c7f9c50000000000965132180cf2c8b5d96c068b396918865114b55aadbc5040be6b358ee36c64b7dbcd466677f329875712c8 +66351a8dac918dc9fbf305f39e3c840500000000789448f24daf699ae6155a735114cdcecee6fb58fbfdfe6030a856ab5923df129b6f6ecda6b45aade09e1daf +d9946c4cd6ce3b33ed763baf66902997cbc7fdd50000000000964d9207a9511495172549323f3f9f9767ad56ab636363c162cc9a75e6bb59b35b9d4e677c7cbc +542ad5ebf560317bcd7ab2bbad562b5f2defcc06640b6663baddeedcdcdcb2bd2200000000c07197e44769455114c771b95cae56abed76bbdfefe79d954a25b8 +277b0dc3300f6783c5ac76e928ad6c6436205f6e3018e47383c5c3bba245473d980b00000000e0112c999a9a0a166b028c8f8fe7a55ae338ae542af956d6b9b9 +b9bca4403620ebacd7eb5114058bf504966a146477abd56a363def3f70e0405e34767272325baad96ce6d397f12501000000008eb324cf5283c5cdadf91ed83c +6ccd7bf2c3b5f24a02c9a2bcddeff7b35b4b23b3465eda35ebac542a79677e1857de060000000078544956ac58112ce6a4ed767ba977b8286b743a9da5cea5c2 +0279a87a78f69ab5f35b51148d8d8de5f96c3677a97fa90e2c00000000c0a34152abd5f2cdad79d180c3e55b627bbd5ebfdfcf3e0783c1f4f4749ea2b65aadac +b3542ac5719c7de6e3abd56a5eda35df15db6834960ac2ca5e01000000804795a452a9f47abd300cc7c7c7f384f4882a01ad562bebeff7fb83c1a0d96ce603b2 +cb344df373b49224c9a7644b6597d9e0bc7641a954cacbbc2eeda205000000007894489acd667e34d6fcfc7cb8a8d3e9e4c55b73597b381ce6496ba552c93b57 +ae5c592a95f232afed763bdf189b4dccc7e4496bd69f972cc8c62c151f0000000000783448968ec3caf3d6acdded76078bf27a026118e6c507f246be3736bb95 +b5d3341ddc23cf67f30ab0793bdffd1a2c168a3d3ccc050000000078c44b82c593b2f273b4f2c2ac4bc767d5ebf5b56bd7e6fd0b0b0b4b676d6563daed767e3c +d7d2c47cc76b9ed2dae80a000000003cca25f96ed6a592ac4b85599324c9fabbdd6e7ea056a552c9da737373e572b9d168e407702d0dce13dbac279b924fcc66 +1d3e0000000000e05165744c56b95c4ed3b4dd6ee7f50482c52c35dfc4da6ab5b2cba52aae0b0b0b59bb56ab65edc1609047ae4b2774653dd93af9715bf99af9 +98a5bdb400000000008f1249beb3354f4b9324c93e97ee455114c77136e0e0c183597b3018542a956c409ecc66b3eaf57aa7d33970e040d699b5837bcac5e685 +62f3a56ab55a5e880000000000e0d123190c06799580bc5c40b55acd6fe43b55c330cc06743a9de0b0cdb0bd5e2f6bc78bf243b492454b876b2d1db19537f29a +06cbf5860000000000c7df286c8da2a8dfefcfcccc2449d26c3683c5d8342f4190dd5d3a802b8ee355ab56f57abd7ca36b3638af12bb62c58a7abd5ea9541616 +16b275b246b018d466979d45f6bd02000000008f36491e8ce63507b2cf344d97ee0d87c376bb9ddc238ee3ac271b90d71fc8b7b5e6c55e3b9d4e76d9ed7697ea +bd66b76ab55ab6e6d2facbf5860000000000c75f92ffa7542a6ddcb8b1dfefe7fb5ea328aa56abdd6ef7d0a14363636359bbd168e45b59d334cd0667b7f26a03 +b9ec72e9dcad6c6e9eb44e4e4e6623e7e7e70f1f0900000000f068902c2c2c54abd57cb36a5eefb5dd6e773a9dbcd26b5e4020ebc90bb676bbdd7c5a362c1bbc +b44a5ed1359f72e8d0a16cb57abd9ef7d46ab56cd6fcfcfcb2bc1e00000000c0b21865afa55229afdc9a6f77ed743afd7e3fb8a71041d6180c06f97ed85c36b2 +d168d4ebf5a5cba55bdd6eb7d7ebe5a509068bf253bc0e2f650000000000f088974c4e4ea669da6ab53a9d4e1cc7a55229ebad542af926d67ebfbf14ade6516c +b7db5d5858c846e6f55ef332aff9807c7becf8f8785e28362f44902f95ef9f05000000007894181da235180cf21435580c5833711ce7b77bbd5e14454b97f13d +82c5cdb0792c9b9fa695af952eca53dabc1041b0b831d6595b00000000c0a34a323d3dbd7efdfa6ab51a8661b7db6db55ac16202bbb4ddb5d1688c8d8d658d7e +bf9fdd2d954a2b57aeccb3d46c4cb95c5eb162453e325f61fbf6edd96a1b366cc81759585870d61600000000f06893e49b5587c3e16030c8b7ace61b60f31dac +c16209d7bcd86b5e5e201f965771cd3a3b9d4eb018c266f2a5eaf57ad668b7dbf9bed77cf1bc802c00000000c0a3c4a8de6bbfdf9f9f9f5feaca2e97ea09048b +e96a26bfcc8bc0b65aad4aa5522e97f3ce3c7e0d16abc4c6715cafd7b3feac332f5f102c26b3bd5eef78bf1900000000c0f2496ab55a1eade6650782c58daeed +767bf5ead55114cdcece669f4992e4a3f352b0ab56ad5adaf77ab8a5b2b0fd7e3f5b21cf67f305a7a7a78fdf3b01000000002cb7a4542af57abdc1609024c9d2 +e958d965d69f6f5ccdcfdaca63d9344db376ad56cb4b132ced8dcde5c3b2b94b276be5b5080eef0100000000783448161616f2d2ae5353534bc16bb55a9d9999 +0916c3d3bc0441be8335eb2c954a7959d8ec56bbdd3e3c7e5db9726536acd96ce6876bcdcfcf2fd52ec8a703000000003c4a24f9a6d4fc50ac6071ef6abe5935 +0f582b95ca52cdd6c1a2ecb2d7eb954aa52449b2bb871fcc951775cd7b82c5020551146523f3f2afcbf78e0000000000c7dbdd855ca3282a97cba552a95eafcf +cdcdcdcfcfe7a55d57ae5c9917223874e850b7db0d16a3d54ea753ad561b8d46b098c96623b39e66b3d9eff77bbd5e3e3eebccabc48e8d8d6597f95c00000000 +804789a4d96ce6ad6ab59ae7aac3e1b05c2ef7fbfdbcaac052965aa9541a8d46bc28bb5c9a182c46b779143b180ca6a6a67abd5e36a55eaf6753f2ba04a55269 +79de0f00000000603924f916d7288a2a954a5e5560d49b2479198176bbbd744c56b95c1e1f1f8fe3386b2f2c2c2cddca8655abd5bca26b5e91a0dbed668d7ebf +9f75e63b5eb3f597ed1501000000008ebb647272326fe51b5d976ee4655b3b9dce52f61a45d1d8d858de1e0c06f90ed9fc6e3677616121bfd56834f26179747b +bc5e0400000000e0874852afd7974ecaca0fddcae3d47ca7ead2315cf967b7dbcd37c6f617e563f2a20499bc1c415e5e201b96f72cebdb01000000002c8fa4d1 +68349bcde170b86ad5aaa52dae4bb29e6eb7db6ab5f2d4757a7a3a4f5a3b9d4ed653ad5693242997cb7967bd5ecfdbf9d15bd545cbf2560000000000cb2b79e3 +1bdfb8dccf0000000000f048932cf70300000000003c02c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a +277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000 +008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e0100 +0000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e +01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2 +c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b25700000000 +80e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000 +000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b257 +0000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078 +b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000 +a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec150000 +0000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec15 +00000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289e +ec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000 +289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b050000 +0000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b05 +00000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a27 +7b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e0100000000 +8a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e010000 +00008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01 +000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c9 +5e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080 +e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b257000000 +0080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b25700 +00000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2 +570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a0 +78b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec15000000 +00a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500 +000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec +1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b050000000028 +9eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b05000000 +00289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500 +000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b +0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a +277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000 +008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e0100 +0000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e +01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2 +c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b25700000000 +80e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000 +000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b257 +0000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078 +b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000 +a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec150000 +0000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec15 +00000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289e +ec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000 +289eec1500000000a078b2570000000080e2c95e01000000008a277b0500000000289eec1500000000a078b2570000000080e2c95e01000000008a277b050000 +0000289eec1500000000a078b2570080ff3f7b7f1e64c975df879e67cb3def5efbd25ddd8dde013440005c4042b4288a02298ad493ada1c3f6c453781cf6f80f +47e88fe77fde44cc1f2fec09c74cc833e371bc9988a7275bf28c9e17d98fa3c51225d1e2828d04406269f4565dfb5e75ebeeb99e3ce7ccc99b4009437943775f +141af5fba855cc9bf7e4f9deacca5b95f787932701000000000000e0c183da2b0000000000000000000000003c78507b05000000000000000000000080070f6a +af000000000000000000000000f0e041ed150000000000000000000000001e3ca8bd020000000000000000000000c08307b55700000000000000000000000078 +f0a0f60a00000000003e985ffbb55f534a15cb3b3b3b711ccfcfcf1b86a11f866198a6e9514bceb97e58ad561dc7d10fb32cd30dd410c6b868630d15cb7aa56e +b0b7b757abd5f4567a8d1042af9152eae57ff00ffec187b793000000000000dc37a8bd0200000000800fe6f0f0507f25841886615996fe1a0f618ca5944a29ce +79b1509468fbfd7e1004c5b25eaf9fcdb24c6fa87bd06b922429bad59b1745d84aa5a2970783815e2e3a1142e8ad8e6b7f010000000000b837507b0500000000 +001f0ce75c29c5868ae1ae4208fd95528a31d65fa3289252eaa78ab26951872db62d1a145fb59fe859af2ffad49be80d8fdae88759967db87b090000000000c0 +fd82da2b0000000000f860c6c7c78b8562de00a55410047ab9542a15c3547bbd5e9665535353711c77bb5d63e8689e01cbb26cdbfe8bddea678fda2449124591 +6e56d476a594baab0f6f0f0100000000007810a0f60a00000000003e986246d76280aa182a4aae6118a2619d14634c0889a2a89828a018b54a29d52df5b6baa5 +7eb6d8e4fd3309e8ad3ccf2bfa2fd6171d166b8a222c0000000000000f11a8bd0200000000800fa6d56ae9afaeeb56abd564a898e9b598a1b54008e9f57ac538 +d62ccb8410b66deb8562486c31b8556f1245117a6fc4abde44b7d1cbc54a2d8ee3623603cd34cd0f7b3f010000000000b83f507b0500000000001f4ca9544ad3 +b428921e15520921e610636c301814d3b3dab6edfb3e1a9659f5ca6234ab7e2a4912dd896118aeeba261ed55afd1cfea0e8bde8a95ba81ee50b7d171fd7effd8 +76180000000000807b02b5570000000000f0c114330328a58a09040a84104aa9699ab66dc7719c6559b1d2b22cf45eed15635c1467d1b0567b742b2ddd523728 +3a174214dba2e1cdbbc8d07ff4c65c0000000000007cc441ed1500000000007c304992b8ae5b0c503d3c3cecf57a68382740311e96734e29b52cab18cadaeff7 +8b29057403bd526f480841c3f9048ee628d0cfdab6ad372fd6379bcd62d2d84aa5a2bb0ac3b0d8fcf8f6180000000000807b01b5570000000000f0c12449520c +4745c399018a05341cdcaa1573bc160357f5c3626c6c51a86543c5729665c5c405454bbd504cedaa575a9655ac2c6ec6552c030000000000f0d081da2b000000 +0000f860c2a1a2846a1846b55a45c33a691cc7476d8a8908d0b0507bb4f2686281a2a8fafedaab5e2e9e2284f8be5f74aeb73d5a7f340f2c0000000000000f0b +a8bd0200000000800fe6681a56c33018637aa118dc5a4c1af07ec59058ce799665faab10a2d3e91455d4e23e5dba07dd9bfe5ab4b76dbb98dab51815eb79ded1 +84b0507b0500000000000f1da8bd0200000000800fc6b22c8c3163ccf33cbd20a5e49ceb8552a95454487f629680288af4fa2ccb84106118160df443bd61711f +2ddd55b189ee593f2cfad46b0cc328a6793d1a450b0000000000c043046aaf0000000000e0034b879224310c831052dc1a6b3018e021bdbe98bcb5a097955245 +a5d5b2ac6265ad56d3db16d3bcc6715c0c8c2d66923d9aef55af2fa62cd06d8e261f000000000000e06101b5570000000000f0c10821b22c2bc6aeeaaf94d2a2 +545ad45bf5729aa662a8984fe0e87e5cc5423136b698b8404a29de53d4678b19608be562f42b1a4e14fbfe622e0000000000000f05a8bd0200000000800fa698 +dd95525a4c3e50145b8bfb681513b31edd3ecb75ddf1f1f1627d100447f7dad26de2382e6ecf75b46131e2b5a8d2c240570000000000f03100b5570000000000 +f0c11c4dbd2a8420ef399a92f5e8d9a3db701537d4b22c4b2ff7fb7dd3343dcf2b6ec075d4b8a8d8ea357a936243bdd5fb1b000000000000f0d081da2b000000 +0000f8c08a795a35d334f5b2fe2aa58ce3b8984fa068500c628da2483f3c9ac5350802bdec388e5ed69b1725d7a33b74e935ba9fe2765b459f459ba3b1b40000 +000000003c44a0f60a00000000003e18ceb9e338c5e400c58403c5a4aea66932c6f4d7a396ba0da55437383c3cd4cb4208cbb28a72ad5ed05bb9ae9b2449b3d9 +d42bf5f25187c544b1455747590000000000003c5ca0f60a00000000003e182144318d8052aa983aa09825a0982ec0b6eda2593152b518219b24097adf6058bd +955ea643c54db4d8d0d1cdb58e6eb1552c14731a1cd7fe020000000000706fa0f60a00000000003e986ab55a2a95a494511431c628a584902ccbbaddae7e1886 +211a964d8b29086cdb3eba01976e59afd739e7c54057ddb898255677e8baae65594110e87ef4021a166af5c36408c6bd0200000000808711d45e0100000000c0 +0753cc1e504cc65a0c7745c352693199805e7fd4522915c7317b4f3154563738eae168b2d72449f4c3344d8fe67bd54f398ea3fb3ceaffb8f617000000000080 +7b03b5570000000000f0c18443c5b2699a8661e805fd75666626cbb2e22942886ddb699ab6db6ddff7f5b2e779c5505629a56eac9f2a661b28e88747f7ddd2db +1695d64aa5a25b0e0683f7b7040000000000e06101b5570000000000f0c1789e572c104292240982c0b6ed62b06a31df6b1cc77a7d31d36b3181805e534cd89a +a669b1ad6ea61b1ff559cce85a6cd26eb7756faeeb166b1cc7d15b0d06830f7d47010000000000b82f507b0500000000001f4cb55a3d5a6e369b4110188651cc +dc5a0c774d9224cb32f4de440468787baea3a1b268381781e779aeeb1e3d3c7a2a4d53ce79313581182aa63578ff54060000000000003c14a0f60a0000000000 +3e98c3c343342ca772ce29a5954aa5b8ef569224fa613105816559c520d62ccb8e4aab4529364dd3200874cb62bed7629ad7a241313cb6542a1513c516131114 +5d15e367010000000000788840ed1500000000007c309c73fdb5a8995a434288a28a8a8605568d527ad4981072f490be070dabb74559b6b89b96c61893434595 +b69888000d07c6c2bdb60000000000c043076aaf0000000000e083191f1f3f5a6eb7db9d4e676a6acab66d8c719aa65114a16105f668b8abe779beefeb852ccb +f4b38661d46ab5a296aadb98a679348941d1c3c6c686ee6d7a7abae8240802b8d7160000000000781841ed1500000000007c30c5b8578c7131136b3158552925 +842886ac1603608b11ac6838856b31d96b3154b668566cab57264982864558ade8ca755dbd10c77131eeb5e8bc9840160000000000808708d45e0100000000c0 +0753ccf75adc564b7fad542a59960d0683a306fae1d17c0268585dd58a87c524b051145996659a66b1b228bfa2e12cb19452d775f57abdb298be000d2bb345c1 +170000000000808708d45e0100000000c007532e978baa2863ac9816a028ad16d30ea0e140d7388e1b8d0621a4d7eb1563638b6d8ba960ebf5fad1b8d7f73b9a +1636cb32dd43519f2d3aec743a1fde1e020000000000f02040ed1500000000007c30c5e4ad68584845c3990438e74208c6d8d1ddb1f443c3308a126d71afada3 +c67ad9719c626a82a3b1b185a299def6e8ce5ac55c04ef5f030000000000c0c3026aaf0000000000e083d9dfdfd75f4dd3acd56a699a2649524cedda6ab58e0a +afb66d77bb5d342c9e165310142358f54ac3308a6961f553711cbfbffcaa3bd4cdc2302c6eae35180c8ee62e2836070000000000e02102b5570000000000f081 +4929b32c2b86bb1683528b9b62a1e1d8d562b06a5160b52ceb68ced6a3c67a43c3301863fad9f7df98ab98d4b55883debb9d976e594c6b707cbb0b0000000000 +c0bd80da2b0000000000f860c6c6c682201042e8af472b0921a6691a86e1ba6ebfdf1f0c06c5d4aeb55aad9888a0dd6ea7698a86a5d524496cdbf63c0f0d6bb2 +baa55e13866151cf2dda17f3c9a2e11407fa61b12d0000000000000f11a8bd0200000000800fa698cb55d3cb45cdb4586fdb765157554a99a699655931abc051 +2dd5b22ccff3e8907e78b4211a966e8b52aceebcd56a71cef526aeebea4d8a79098a380000000000001e22507b0500000000001f4c14459ee715835293242986 +b812422ccb2a6615d0ebf5b3c53402711c1fdd26cb34cd52a94429d5cb41101c3da59bd9b65dcce85acc4890a6a95ec8b24caf2c46bceafe8f6b7f0100000000 +00b837507b0500000000001f4c14459cf3628e57ad52a914eb8b81ae47cd8a695b932439aabd12427cdf2f968510c508d9e259bdedd10c069ee715cd8ad2ed87 +b55b0000000000003c60507b0500000000001f4c31b1c0d18db08aa9068a3b651505d9a29c5a8c543dba0d57f1354dd362606c3654b4292625d08ae9088ae905 +74b362cdb1ee2b000000000000f70e6aaf0000000000e083b16d5b7fa5947a9e57144fc330544ad5ebf5a321ae47f49a344da3282aaaae9d4ea7a8b42649a2d7 +e8ae1863a669162b5dd72d968b6964eda163d8430000000000001e04a8bd0200000000dcaf7ffcd73f6732bcd909f7dac164d9f11d3b9c7b2ecd64fbc61f2121 +9540842249f044c99cad785ce6c33f27c6ca25df79e1fa46b31bfc8d9ffb8465d2b5b5fd7e94bebab437ee39f375a76836562f974bf6e2ca4194f0f4f4e7b864 +ad1b7f8c328e04c2585dfefadf3abac67f6767278ee3f9f9f962d0681886c534a9856206d56ab5ea380e1a8e392daaa5476354356ba8582e6e84b5b7b757abd5 +f45668380a55af29a611a8d7eb7f31b79825e03f955bcc4bf0fedca3ac9fc80d82e0fdb9c52645eeaffddaaf1dcffeae7ce7587ebebffebd9bf77e5002000000 +00808f00a8bd0200000000dc2f4c10c694ea2f52e9454210512991980abd4622931281939433e510c2b014182183328b12433f29082584526a5a869108cc1555 +881083a04c0aa59b99ccc00c138e88145411261492526fa3630f0f0fd1f0827dc3302c4b6f6fc443388fcdaff1e79c170b45c9b2dfef0741502c1753046459a6 +372cc6ae2649f2eeee605c14252b958a5e1e0c067ab9e84408a1b73a69b9c7f5f3fd308e5d0000000000304a507b0500000000b85fb7d70f314252e5139b129a +17d1b65efb96c1d8f9291f136433da0dd3bb3b9d6637d2ff0841a990a5b25bab39b30d6bdc375aedbe5282529aa98c28d9ea07ed414808d1cd1ccf9968b83663 +1cf3dd37be8d303e3fed19d8330c6310a72dce75221b3a9a23150d6703c079b190465124a5d44f1565c4a22e59bce6a241f1f52fcea9aad7177dea4df486476d +f4c32ccb8a295c4f4eee71fd7c1fccd10900000000008e0fd45e0100000000ee97efd926d3a755122162d1fcaaf6b2978f67f44b0e51440a6e9ae658d547241f +409965990c9362e8a5e556a421553eca12eb2f8cb16ac5a594be3be43248f35950f5564a62254b4e3e80d22fd90662592a4c46c7c7c78b17505c47af370a8240 +2f974aa562d866afd7d371535353711c77bb5d63e8e8ba7bcbb2fea3b3a9beff7e5949924451a49b15b54e29a5ee6a6666e644e51ed7cff75e8f470000000000 +f05101b5570000000080fbf5c54f9fbf707e3a4a3863ec3b2fbcd56945dff8f9677c3bbf963c0cd31fbe72f7d464f5abcf3fc145e6d8e6cd1b5b2b2b7b324e97 +efeef84f7fc3a9cc6c7df7d765d04984aad6bcbff98d67a544b64996560e6eddd8c0195f5e3c08a254f7fc4bcf5f2df9b649593f8c5efdc1d254a3b2329ce1b4 +18b029868a12641886685837c4181342a228e29ca3f74671524a75cb344df3519cc33b5c1557eb1fed8edecaf33cbda0db14eb8b0e8b353a2b3d61b9c7f5f37d +f0472a0000000000f87041ed1500000000e07ec5096fb6061863c7c14891621c6526898168269244c8546612619ec82c8d84108c62c23043c4460382ba9ec710 +75ec0cb9369332ef2d4d55ca63c6587e953cc3941325f3bb3ae967332233a15229749fad564ba7bbae5bad5693a162e6d362c6d20221a4d7eb15e33ab32cd3e9 +b66deb8562886831d8536f1245117a6f04a8de44b7d1cbc5ca7c07e3b8b8ba5f334df3a4e51ed7cff7411ea30000000000e03840ed1500000000e07eeded76b6 +d75bf5316f6cb22cb9248435f73a9822d3a09d5efcf6ea7e3b4c6767f6f777fbad56c80ca28d35ca25cfcadaafe10e3effe42c4154619444e9eee641bb1b340f +07f9e4a444d51b957ac5beb5b8db0fe2f6417fd01d3086fb03aefb1caf954a4f95d2342d8a86478545ddb939c4181b0c067abd5e69dbb6effb685876d42b8bd1 +9dfaa924494aa5926118aeeba2612d52afd1cfea0e8bde8a95ba81ee50b7d171fd7e5f6f72a2728febe7fb211dbe00000000006064a0f60a0000000070bfa452 +91c8622e9228195ef9aee224630636183129996df8e5929586224945c4b94b8713892225318ab96e4ea2502ff24110732dcd7433bde80d2726554ac9617931af +12a65c28ec519b523a532f957c9b0caf94d76d8a0bea0bbab16e609aa66ddb711c675956acb42c0bbd578bd4bd15c54a34ecfce8d652799c94c54e09218a6dd1 +f0665664a868e99db0dce3faf98efcc00500000000002306b5570000000080fbd51ac48bdbad8528e549d61b449892cddd43d734ce9c19f77cf3e79ebbd0eec4 +2beb07fbdd6879af7d65be3e5ef64d665836dbd8388862691a3849d3b5b5432164c9770e7ae1e276f3ecf4d86cdd3328b1ecfc6e515cc8edbd8ecd8c33676dd7 +633ffbd90bfd207e23495cd72d066c1e1e1ef67a3d34bc46be181fca39a7945a96550cedecf7fbc5c5f2ba815ea9372cee0715c7f1d135fbfa59dbb6f5e6c5fa +66b3594ca25aa95474576118169b27272cf7b87ebe1fde110c000000000046036aaf0000000000f74b293555763d8b49292727aaa6c99aad8192380c52855114 +66519262c27483e98a9749dc0912d1ec75074c0845098ae28c677290e617cb9731760c3655f62926dd209684f6c3d8f28c53a57aa71d2aacc228c10a8524e39c +272a298667a2e195f2c5021a0ef6d48a394f8b819cfa613156b4285cb2a16239cbb2e242fea2a55e28a63ad52b2dcb2a561637a72a960b272af7b87ebe0ff420 +050000000000c7006aaf0000000000f72b4ad2f3b3f5fc327385cf9f9baed6dc975fb99d466263a3357c5e51866d9b953dbb5e72ee6eb5169b07a6c904c21767 +ea9ec136369a719addd9eef88e39d328e96635df5edb69df5eefb89699a6d92f3effe4954726bffbfddb71986caeb78625c5fcbaf8703cd48a92a26118d56a15 +0d0b8571fce743268b0bf3f5429224472b8f2eb42f8a8cefaf45eae5e2294288effb45e77adba3f57a8d5e3e51b9c7f5f3fdcf1d730000000000e06100b55700 +00000080fb75fecc8445f161276975a389763f93f2a09350842f3e328931a6140f827879a3592b7b25d73cb7307ef6dc74abd5ed76a2b9d99ae7db325369c23b +513ece71bf9b945ca351b6cf9c1e9f3f33d5e9f45b9d308dd29ddd6eb3178b945f3a3fc518a19844315f43ef4e4b6a1806d36b0929067b1617d1bf5f31449473 +9e65f9804a2144a7d329ea8cc57dab740f9452fdb5686fdb7631d569314ad4f3bca30952f556dd6ef744e5ce1dd3cff7411c9b0000000000e03841ed15000000 +00e07e3df9d8b95ebbb77db0b4b8ba3937e9128996b6dbb641befed5a798811cc7bebbb4fb7b7ffac633d7cecc4d4f55c6aab373f5975ebc79f7ced6c50bb3f5 +869f7211c769abdd6ff7835b2beb574e4f3f7e69caaf9417ce4cfef0e53bb76ead679c1fb6ba2bbb874820dda7e31a94b1bdddf69b3b16c69831e6799e5e9052 +72cef542a9542aea8cefbf5a1f0dcb8e7a7d96654288300c8b06fa617e43a8e17da57457c5269665e987459f7a8d6118a669a2f74695ea674f54ee71fd7c4775 +bc0200000000800f0bd45e0100000000eed7e6f6816b6067fcccf41317b6ba1b7b9dddc99a631a746fb7450d66d1a01791a9273eef8cc94cf2edede6d6d68161 +d08b974f0dfa5118a5c555f369cca9e14c5e7dce292121f8fe7e476f8eb1ba7c75617165b7b7138f956d4ac8e15e87eaae29e984efce52aa254962180621a4b8 +55d46030c0437a7d319969412febaca2f2685956b1b256abe96d8b694ff5cb28068aea0d8b36456952af2f2ee1d76d749c699a272a77333eb69f2f0000000000 +78a841ed1500000000e07e1dee77fdb9923d71b1327366e94f7e236a6d3f7d7eceb558af37c82b7a48c5b45eb9fc591bad99f8f6c65e6f73b3f9dce71f5d5898 +b8f9ceeaa095180c25a9e43c93b6eb5d78ce417b16babe7bd85f5eddfdccb357ae5e3df5fd3756af2f6e7feeca8ce798edfe80516a621c105f08916559319653 +7fa59416a5c3a2fea897d3341543c5f5f547f7a72a168ab1a2faa9a28829de53d42b8b19518be56234281a4e9c5ab43951b9c7f5f33d86431900000000003c50 +507b0500000000b85fe59abfb513707cd3c3ebd3aee0b892099ea4a8dd0df3d949318ad581875e4a71b881fb95aa3f3553e19cafaeee654211823a9d584a54ad +395ca968fb65499375d4b75df799672e4929efdeddadd8ecec6449089124bcdb8b86f54425104fd95851822c2ec62f8a8fc57da58a894a8f6e27e5baeef8f878 +b13e0882a37b4fe936711c1703338f362c46801655cb62e0e74fec6f31cbeac9c93dae9feffd1e970000000000e0b841ed1500000000e07e99ccb8bbd3b3acbe +8144d994d4f011554ac8dded2ea1c8b24c8cfab6da4b115b4ff8e38f572e5d3a75e7ce66f3a06d1af918ccd6e1406174faf4789270b5772ba36c3de4172e7897 +2ecf2d2d6e1dee775d4626abbe41f342e1f64e971164e7b391866ae2dde94d8510e43dc5e04df4bec94f8f6e4b55dc60cab22cbddceff74dd3f43cafb821d551 +e3a282a9d7e84d8a0df556ef6ff0fe9e4f48ee71fd7c1fccd10900000000008e0fd45e0100000000ee579a663333d528cec2302692475976d00a1dcbfca9671e +8913feca1b2b9e6b8eb98ee359b5068de36c6969677fb71bc68942668630220429b9b5dbce0762624b6f58ad9695c896977777f7bb41a07b4d522e765b1135d9 +e73ff9084f85ee533743c3d26171e1bc699a7a597f9552c6715c5c5f5f342806754651a41f1ecd6a1a04815e761c472febcd8b12e4d11dabf41add4f71fba9a2 +cfa2cdd185f9272af7187fbe0000000000e0a106b5570000000080fb8595acd7dddddd5e1c2729c602a9bd4ee0b979c1aedd8d57f6079315bb64509f58e3f552 +18a79df6a0d78fc230e6040b8948c6951238e598322285eb5a8d46298eb26ea7dfef87837e92664262b4df1f5066ce4cd5fa41bcb6d7abf9a631c71dc7292e96 +2f2ec02f2639354d9331669a7f5ebcd36d28a5bac1e1e1a15e1642589655942ff582deca75dd24499acda65ea9978f3a2c264e2dba3acadadede3e51b9b8bf74 +2c3fdf911fb8000000000060c4a0f60a0000000070bf6ead1eecb4fad7ce4f3ffdc90bafbdb116a5c1b357e709212fbeb26859c65ffbca138ca072c959d968fe +fe0bb767c74b632567f3a0df0a93b906b128b970794622f5adefdf297bf6cffff4a3ab5b077ff8c29db1aa33537337f783569ffb0eb22de3e98b7316652fff70 +d1b6cd6f7ce5494ae9b7f6457159bd52aab894beb86abeb87cdeb6ede2e51597cf172346932441ef1b1caab7d2cb74a8b863151b3abad9d4d12da78a85e21a7f +ddf244e51ed7cff7c338760100000000c02841ed1500000000e07eb5dac1ea4ef7894bb3331315fd50703956f5f4c2ad95bd46c57fe6da692e95e3d2d54dbcb1 +db711832153fec06ad3819f34c6ab172256fdc0b137d6a363ee66f1eb47533826589a94e37dceb0706f60dcac62a2e65e4ced27ea562e93e3325ab69b5542a49 +29a328628c519acf2e9a6559b7dbd50fc3309f30f4e8927cdbb68f6e48a55bd6eb75ce7931f053372eaee8af56abaeeb5a96150481ee472fa061e1523f4c868a +71a0bad989caa5c7f4f33d86431900000000003c50507b0500000000b85f63e7af51f46ad08f6fdcd82a59d41cf396365b8860c2689af1c5e53d2524632c0ad2 +4bb35ee3c213f6d94fcebff1adc6fed2cc58d5b6e8d6469b50f54b5f7c344b85eea1df8d74b3ead9abf6c5e7a6af7fbbbc71b356ab1a365ed9eee83e25c53c53 +b7efeee85c624d1513951edd7b0a0d4b87c5c5f552fe79f14e2915c7317b4f3174543728aec72f867916939f2649a21fa6697a34ffa97eca711cdde751ff475b +9d90dcc631fd7c9f1afda10b0000000000460a6aaf0000000000f7cbb02dd73111516112634619129ce7d7b313422462611009252d23bf83936ec65c5f393566 +db1665866d180c47517e1ba889861f52dee984522247afb73c64d7a8e55a0663063699c1f940214209c924d27d628c431116833d35d3340dc3c85f8c61cccccc +6459563ca57bb66d3b4dd376bbedfbbe5ef63caf18daa95f8f6eac9f2aaebe2fe88747f7a1d2db1605ca4aa5a25b0e0683a26590df1fea04e51ed7cf7704872a +0000000000f85041ed1500000000e07e5dae8473bff839c13366e2975fbad30bf8977ee651c73430a35194bcf5facaf864f9caa3f33c55a64197d69a9baffd56 +4d8ab4e2d917bf442b33f18bbf25fa9d37af6ffa15e7339fbe208462ecd2e6666bf9b5dfac219936ca5192cf6dfa85cf5fa9380e1af6f9f69b2b958aa7152f80 +109224491004b66d1783378bf94fe338d6eb8b994f8b0beaf59a6226d3344d8b6d7533ddf8685f8a194e8b4ddaedb6eecd75dd628de3387aabc16070d2728feb +e7fb800f530000000000f0a183da2b00000000c0fd5222a118a9fc8e4f8644f985ea8e69d8763eaf28e6229342c97c78a652597e6b28c96534a09e6d61665906 +b198693229689ce5e32e7533ac8441094542c501714cc732e334960ad9a6ed387a23ac64c6879d56abd5a3d7d06c36832018a6e48ae19f4992645986debb305f +2f08218e868ea2e1b5f99ee7b9ae7bf4f0e8a9344d39e7c5a5fa62a8b8cc5f3f3c69b9c7f5f3fd20c7200000000000f82882da2b00000000c0fddada3adc58db +af36fcc9b10ae71c63bcbbdd26141906e9f5e3b757f63a319f9e2cef1ef43aed3ea5981aac56f7cb9e991dbc8cf7d1d92767b09a514a2549b2bdbadfed47fbcd +3ea34a1946ad5a2ad76c7e77bf3788f6770edb263529e906f13b6b07e3fd50b88768585ed4a194d24aa552dc874af7a31f1697e45b96550ceaccb2eca8d45894 +26d3340d8240b72ce63f2da63d2d1a14c3454ba55231716a71617ed195fe7a7878b2728febe7fb611cbb00000000006094a0f60a0000000070bf78269344b869 +96c4a9528a629c64c2ca2b80f9c84ad7b118c13ccdf4bf3811a6998f6ccc67f32444a6497e832889115671c29344a642263c4b12ae4c4624474431925f53af1b +70a9a89419c9fbb42dc362b4cbb94e2f6a88d69010a2a82aa261c151a394befb223927841c3da4ef41c36a6651a62cee2ea531c6e45051b52c2ecc47c381a27a +0d3f69b9c7f4f37dc087290000000000f8d041ed1500000000e07eb506f1d2f6e1425c0d8324ec478890edad43d3b44ecd973dd7fcea7397fa617477657faf13 +aeedb71f99ab8f7b0ec5cca07463af19c579dd30e3727df3904b5176bc83fe6079a7757aa23651c9c75db261314e646873fbd031d8a95375dde7979fbb1885fc +4e6dfce835b4dbed4ea733353565dbb6de2a4dd3288ad0b0227934fcd3f33cdff7f3b82cd3cf1a8651abd58a7b3ae936a6691e5dd45ff4b0b1b1a17b9b9e9e2e +3a0982a0b8f7d4f8f8c9ca3dae9fef8338360100000000c07182da2b00000000c0fdc24af94e3ed5a752d8f79de2164c5464c3e1954a19f9c0588d11e4184c0a +9464aa170419cab8d08f44ca4596c9304da544c2e25449dbcc8761664205214724640629d7dc244a332e755748294adfbdf41e0deb86c5cca4c5e0cdbc902744 +3184b318105a8ce844c3294d8bc94f8ba1a345b3625bbd324912342c4a6a4557aeebea85388e8b71a045e759969db45cf7987ebe1ff6710c00000000001e34a8 +bd0200000000dcaf20e28f9e9e540aab0c5dba3a57adf82ffde09648b295e5a67e56614431360d5af3edb18ab3bad35ddc3cb40d26903a3755f30cb6bede4c78 +7673b3eb9a64bcec953df3f1f2e4e641fbb5c58ec50ccef957bef0d8a533932fbe723b8a92b595c32294507598e5cbc56da6f4d74aa59265d96030387a61fae1 +d1f5f568586dd48a87c5a4a851145996659a66b1b22847a2e1aca99452d7758b594a8bcbf9d1b052a95f4f31efeac9c93dae9fef7d1e960000000000e0d841ed +1500000000e07e4d8c950ccaa294f763310812c668147329d154a344082304256976d80d5c93598c8d374a5ec589c2240cd346c5736c26844ab9f09b0133482f +c90c466c8a1a95b2e5394994f67a98f3ac3388ba7122389f19af218209c2599695cbe5a24ac8182b2e932f4a8dc565f86838f0338ee346a34108e9f57ac558d1 +e2351753a3d6ebf5a371a0ef77344daa4ed13d14f5caa2c34ea7333e3e7ea2724f1fd3cff7be0e4a0000000000f01100b5570000000080fbf5ec27cff7dabdd7 +afafbf7d77a75e357992dd5c3f342cf3f92f3e6e19d8b0ade595833ffd57373e7175f6d2fc5cb9569d9d1b7bf9a51b8b4bbb57aece8fd59c3443519c8561dc0d +82b71657cf9f9ebc7ceeb45f2e9f3933f6eaab8bb76e6e8924d9dd39bcb3de44887ce98bd71c9b514a77f77b07dc2f5e405179945272ce85102cbf3efeddbb45 +e98786611425cbe2de53478df5b2e338c5a5fa4763450b4533bd6dd118bd776d7eb1a69844f5e4e41ed7cff7011c9a0000000000e05841ed1500000000e07eb5 +0efb5809b332513e5d3d0c92303d2cbba66518dd4e4819b28d244a55f5d465d3778450edd66010e4338ace4d8fc5617c90cf2baae228e53cc3d429cf5eb6aa86 +9472d00d6edde142a2d9b9b1c33010edb0e4583a4bf7191b06656a10c9fdd6be5e639a66ad564bd334499262aad356ab755488b46dbbdbeda26131b1b824bf18 +d1a9571a86514c93aa9f8ae3f8fde548dda16e16866131ebe8603038ba965fafdfdf3f59b9adc3e6b1fc7c4776c00200000000800f09d45e0100000000eed7c6 +66ebec4cc599bd343e77e6d677ff45dcda7ee29169d7c007fb6d8aa841b21eadd59efaba8dd608babbba79b0bdd9feec672f3ef6f8a99befac1d347b8cb124e5 +f9e5f376ad7af5abaeda65f8c6e66e6b79adf9a9671e79eac9b3ffe36f7fe7e6d2c1a72f4cb9b6d13ce8308529417d5a42c3e19cc54da8c45051582cee344529 +2d066f160547cbb28ee6303d6aac37340c43bf00fdecfb6f5455dcd5aa5883debbbd956e595ce67fd2728ff1e70b00000000001e6a507b0500000000b85fae67 +ec1cf639dab054a7664a5171f2694311ed05c3bb36299990b6a3dee6b4b78743cfb32f5d994bb9d8da6865793d10777b412691ef3b295164ff2d41c25d1c1996 +79f5cabc94726dbde9323659f7b9905122fb7d4ea82408c7488ecd5f0b824008a1bf1ebd184288699a8661b8aedbeff707834131d569ad562b2ecc6fb7db699a +a261a9314912dbb63dcf43c31aa56ea9d7846158d4378bf6c5fcaaba81effbfaa1de766c6cec44e51ed7cff7c338760100000000c02841ed1500000000e07ed9 +8ef9cecd4dc7e8d898372c03596546f3d194eb5b4d82b0ed1844f51db51313bc18ab271f5b78f4d2fcad3bdb3b3b3d23bf1a5eee1e741022e7e6c792386deeff +284564299597cecf3ef1c4e9a5bb7b5bdb879e614c565d469142d9c6d63ea6c8362d8a9198c9e736d5742f450df1ddd763db459d5129659a669665c555f647b5 +45cbb23ccfa343fae1d1866858ca2c4a93428856abc539d79bb8aeab3729aed3d771c59caa2727d726c7f3f30500000000000f3ba8bd0200000000dcaf384a27 +1a7e9cca24c60249ce456f909806fdc485199ea97796f66cd3f04c669bd6b89b375e59dd6fb77add20c6c4c824c2982a89b79bbd7c8a526c58a631e19b5926d6 +d73acdc35e18a461ca05970701a7943e71695a3ff5ced281c9288e22cff38a419a499214433e092196651557d9ebf5fad9e2b2fa388e8f6e24659a66a954d2bd +e9e520088e9ed2cd6cdb2e26482daed04fd3542f6459a65716a34775ffd109cb3dae9fef8771ec0200000000805182da2b00000000c0fd6294ce4cd536767aed +4e5f122a105edfebf9b6f5c857a6daddf877feec9dc98a7f6accf14bcee9d97a1086cd56efa0dd1b0431276e2628e1521219f5528a194199635bf373d530480f +0fdb9d76a8db25994218af1f740d83fde5b34fea0dffed776ed57c733c8a38e7c59ca75aa552295e4f31f0f3e8e515d398264972548b2484f8be5f2c0b218a11 +a3c5b37adba32bfa3dcf2b9a15a5cca30e8b32e5c9c93dae9fef7fe1b00300000000001f79507b0500000000b85fcb9bad834e706ebe7eedb18577167792845f +3b37c908fed19bab8419cf7ff68265d0aae71cb4fadffbf14aa3e4555dfba013f6435e2b9906e6a74ed77427afdfdc702cebd38f9f6e77c3efbfbe5cf6ec5ad9 +d9eb0e3a41e2188641c995850946e88fafafebaf5f7ef6bc5e736378a1fdd18da18a4bef8b3b471505caa2bca89f45c3c265711faae26b9aa6c540d16ca86853 +5ca4af1597e71757f7eb66c59aa3fd4d864e4eeef2eaf1fc7c4779cc0200000000800f03d45e0100000000eed7d67e6779a773eef4d899d9caadbb7b42a60b93 +534265b7575ab5aafb85cf5c12423816dbef06d7efee5d98a98b92bb77386885dcb14ccb443313f91dedfff0a5a05296e7e61b6f86c9dbcbfba7262a325179b3 +7e32ddf098e7ce8d9718a137560faa25fba73f7b9128b47c60eb0d29a59ee715c5c4300c9552f57afd68c8e711bd264dd3288a8a2a64a7d3292a8f4992e835b6 +6d33c64cd32c56baae5b2c17d3aada43475db5dbed1395bbfec3e3f9f9020000000080871dd45e0100000000eed7c264f5c26c6d6dbbf5c3773626cb4ec5f7ee +584fa4996cf33f3adced2cfece2b842249f044c97cfee9335ce6c3307feaa9b325df79e1fac66e2b788e999649bff6d94bfd28fd27bff3f2b8e7fcdc530b45b3 +67af2d944bf6e2ca4194f015e71a97acc5ffb8b5df5bfe9d573156bffebddf7ce0fbb2b67e170deb98c36aa61afecb0d2feac7c347efbfbeffcfe5c34b85d4ff +53e6bc3ae8915672371d7fdd2c4dd571d5423b01bedb52176af24c0309a96eeec96620c75d6c31fd0fcd54f0d52b8f3cf07d7960febbffee68f1dafffe3fd9ea +4984feee7fba8fe7ff8f7fdeec571ecccb1a957ffcd73f6732bcd909f7da813e9e7dc70ee79ecb8fe71b7f94fff0043a3a9e672b5e71a04e8c958be3b9d90dfe +c6cf7d421fcf6b6bfbfa787e75694f1fcff375a76836562f1f1dcfe9e9cfe5c7f38d3f461947020d8fe79bc7bdeb00000000000f18d45e0100000000ee1726f9 +fd94a8fe22955e240411951289a9d06b24322911384939530e210c4b81113228b32831f49382504228a5a6651889c05c5185083108caa450ba99c90ccc30e188 +48411561422129497e41fa4f8ef47cb086155685715e727db7daaad47b5f7ea25951a8cdcb67f9be604bda8e303842c9a445c711f2134125450ef50dfdbdc9bf +530ba564dc908932f7621325a8eeca91ee0bf8403e96c73300000000c0b180da2b00000000c0fdbabd7e8811922aaf51129a1795b65efb96c1d8f9291f136433 +da0dd3bb3b9d6637d2ff0841a990a5b25bab39b30d6bdc375aedbe5282529aa98c28d9ea07ed414808d1cd1ccf9968b836631cf3dd37be8d303e3fed19d8330c +6310a7a3d81721785e50c3b818fd5a945bd1d1927ab740f613635ff3395365fe4f1214481c664cd80eae9005539579e40eba65c5cad55ae659b6c51812552f94 +46dcceca7dce7a89cce448f605dc9b8fd3f10c0000000070bca0f60a0000000070bf7ccf36993ead9208118be6777c2a7bf9f83ebfe41045a4e0a6698e557d44 +f201855996c93029a62bb5dc8a34a47ab7a6a91863d58a4b29cd4b99428820cd6723d55b2989952c39f98042bf641b8865a93019fd2fbeb07b30bc211579ff9d +a68e142f12fd85a1afc3e79054f98e08213b09edc4b663181315e633ea756337ee1b96ab3cca5d93606c6489835b94f40823677cd677b06307a3d817706f3e4e +c73300000000c0f182da2b00000000c0fdfae2a7cf5f383f1d259c31f69d17deeab4a26ffcfc33be9d5f5b1d86e90f5fb97b6ab2fad5e79fe022736cf3e68dad +95953d19a7cb7777fca7bfe15466b6befbeb32e82442556bdedffcc6b35222db244b2b07b76e6ce08c2f2f1e0451aa7bfea5e7af967cdba4ac1f46affe6069aa +5119c5befcf98056a5de3fdf6bb10afdff175e8f261c50ef8d8d950a7513bc1b93b93265061d4e31401065d834093308a1685877637260c88ec526c72d5c2318 +db087c747c9c8e670000000080e305b5570000000080fb1527bcd91a608c1d072345f25aa452992406a299481221539949847922b3341242308a09c30c111b0d +08ea7a1e43d4b133e4da4ccabcb73455298f19639462cc30e544c9fc2e47fad98cc84ca8540adde728f6252f8f22254486df55ccf79a3ff5beaaabfa8b15d89c +6e2d954964cd269e95cf5b20f5378719b252cf4c4b10dd8f1cce1d8b335cca47ca52c330f55e126598a3d817706f3e4ec73300000000c0f182da2b00000000c0 +fddadbed6cafb7ea63ded864597249086bee753045a6413bbdf8edd5fd7698ceceecefeff65bad301ffd49c858a35cf2acacfd1aeee0f34fce124415464994ee +6e1eb4bb41f3704029c544d51b957ac5beb5b8db0fe2f6417fd01d3086fb03aefb1caf9546b12f4a492124c698108c107def0e48ef8e7055ef83df1b135bd4e6 +f2162a2fd4d55c59f7b065e4f76812180bdb4e2843bab7e13c067a938c98a13189485d100b61fd0451026aaf1f211fa7e31900000000e07841ed1500000000e0 +7e49a52291c55c245122a5c458c549c60c6c30625232dbf0cb252b0d45928a8873971af926f9b5f728e6ba398942bdc80741ccb534d3cdf4a237bc0c3fbf8555 +3e16351f7b98a45c28ec519b523a532f95fc515fa83fbcd7d6bbff9f175af56bd5af8751c60c960f71cdf7000fefca854426d224e119d7cfd91665940eef5c9f +6f8b1993840eefdd35ec1063490d494ac36aee7b1d48a8bd7e847c4c8f6700000000806300b5570000000080fbd51ac48bdbad8528e549d61b449892cddd43d7 +34ce9c19f77cf3e79ebbd0eec42beb07fbdd6879af7d65be3e5ef64d665836dbd8388862691a3849d3b5b5432164c9770e7ae1e276f3ecf4d86cdd3328b16c43 +29c585dcdeebd8cc3873d6763df6b39fbdd00fe251eccb709e81bc368686a5d262a28161d155599685306a36f7d7d7d63aad563018c4496adb56b9529998989c +9d9bf3fd321e96d73041ef0d95cdebb334bf151792ef4e5d703483ec70b4ac94e827a63000c7ede3743c03000000001c2fa8bd0200000000dc2fa5d454d9f52c +26a59c9ca89a266bb6064ae230481546519845498a09d30da62b5e2671274844b3d71d30211425288a339ec9419acf7759c6d831d854d9a79874835812da0f63 +cb334e95ea9d76a8b00aa3042b14928c733e8a7da1f4dd79068eeaa17aa72865a6692cdebdfde277bfbbbab4124791cc24330c9e65499aeaf686618c8d371eb9 +70e1e94f3d73f6ec1984b2848779dd551043223b53588804a1845081c9b0e85a7cdf8aa1b40a41edf5a3e4e3743c03000000001c2fa8bd0200000000dcaf2849 +cfcfd6f3cbae153e7f6eba5a735f7ee5761a898d8dd6f0794519b66d56f6ec7ac9b9bbd55a6c1e982613085f9ca97b06dbd868c6697667bbe33be64ca3a49bd5 +7c7b6da77d7bbde35a669a66bff8fc93571e99fceef76fc761b2b9decae75ac54591f4c11b4edefae70f851096650761ff5fffcbdf79f9c51f189879aec3f4fe +b0e1a8d8bce84aa5405ccaf5b58df5e5b51f7effc5679e7dfaa79fff69bf6405838064862308e29ca43c443860861cce57801156c3490cf2c965f5ee103c8a7d +01f7e6e3743c03000000001c2fa8bd0200000000dcaff367262c8a0f3b49ab1b4db4fb9994079d84227cf191498c31a57810c4cb1bcd5ad92bb9e6b985f1b3e7 +a65bad6eb713cdcdd63cdf96994a13de89f2717ffbdda4e41a8db27de6f4f8fc99a94ea7dfea846994eeec769bbd58a4fcd2f929c608c5248a47324e7058787d +f7ce5a4264b66defec6dfd3fffc9ff636b7da754f219cb676ed5cfa7699abf8624c14a26493a516f3cf1d8e33313f5a9f16ad46dbdfa07df9abdf6d8c2c2429a +640926125181b2785863a384e553c1622c95c032bf4d131e4e003a8a7d01f7e6e3743c03000000001c2fa8bd0200000000dcaf271f3bd76bf7b60f96165737e7 +265d22d1d276db36c8d7bffa143390e3d87797767fef4fdf78e6da99b9e9a9ca587576aefed28b37efded9ba7861b6def0532ee2386db5fbed7e706b65fdcae9 +e9c72f4df995f2c299c91fbe7ce7d6adf58cf3c3567765f71009a4fb745c8332b6b7db1ed1ee14e35e8b11af5b3bebbff68ffecfad834ec9f75496712544c619 +25fa7f18631513cf4e4e3f726afad478f5912b57bdc979fd3cefb77bcdfdd76f2d6d64ecfc9547d39467965e6b53a51833086384907ca2d7e1ffe5555eac0886 +318f1f211fb3e31900000000e01841ed1500000000e07e6d6e1fb80676c6cf4c3f7161abbbb1d7d99dac39a641f7765bd460160d7a11997ae2f3ce98cc24dfde +6e6e6d1d1806bd78f9d4a01f8551aa948ae3388d39359cc9abcf39252404dfdfefe8cd315697af2e2caeecf676e2b1b24d0939dceb50dd35259d508c666f141a +ce06c018ebf65affb7ffcb3f6eeeb54abe6752cc28311845423224ea25ebd1737367e626aaf55a6d7c92f73bbdede538e81b7e95e87d769c4f3d76e1a51f5f5f +f74ae72f5e0a83c0308cbcca9adfc6ebbdfb700924b120842a249592a3d917702f3e5ec73300000000c07182da2b00000000c0fd3adceffa73257be26265e6cc +d29ffc46d4da7efafc9c6bb15e6f4008b1908a69bd72f9b3365a33f1ed8dbddee666f3b9cf3fbab03071f39dd5412b31184a52c979266dd7bbf09c83f62c747d +f7b0bfbcbafb9967af5cbd7aeafb6fac5e5fdcfedc9519cf31dbfd01a3d4c43820fe48760663349c708050f4cffee75f5f5b5ef73c172bc9285352f886592b9b +17e727af9e5fa8d5ca22cb24c23c0c78cab338caf88e6a1f60cc8861616a3d75e9fc8b3f7aa552ab8f351a3c4df39ed1f03e5e6a587bc5c554033a0e43edf523 +e563753c03000000001c2ba8bd0200000000dcaf72cddfda0938bee9e1f56957705cc9044f52d4ee86c584a6b13af0d04b290e3770bf52f5a7662a9cf3d5d5bd +4c284250a7134b89aa35872b156dbf2c69b28efab6eb3ef3cc2529e5ddbbbb159b9d9d2c09219284777bd1b064a9041ac9fc9804538944c92f7feb4f7eff85ef +bc54ad541846b6c1e8701ed871877ef9b94f4cce4e1184d3385698a88c0ff6b7d394e715556a286ae57309e86e0cdbf14b1767c65f7fe17b3ff78bbf34bc9bd6 +bb37d4d20df36943315558bd9b8961bed78f908fd3f10c0000000070bca0f60a0000000070bf4c66dcdde95956df40a26c4a6af8882a25e4ee76975064592646 +7d5beda588ad27fcf1c72b972e9dba7367b379d0360d4a08691d0e1446a74f8f2709577bb732cad6437ee18277e9f2dcd2e2d6e17ed76564b2ea1b341f2ebabd +d36504d9a68950388a7dd12f9b60d2ebb5ffe077ff80518611726d8b2055b1e895b9b14f3d71657c7a5a489126f9adb3329e26e120e87594245222858dfcae5a +ccc0181b98a64952ad946badeeddc5c58b172fc671acd717b7f1cae1e1ff0dc1bdb63e523e4ec73300000000c0f182da2b00000000c0fd4ad36c66a61ac55918 +c644f228cb0e5aa163993ff5cc2371c25f7963c573cd31d7713cabd6a0719c2d2dedecef76c33851c8cc86d7de2325b776db5222842dbd61b55a56225b5ededd +ddef0681ee3549b9d86d45d4649fffe4233c15ba4fdd6c14fb9271eebaee2b3f787d6365c32b954c460ca2e61ba547e7ea4f5c3a65bb46d4d7af534921a51449 +18c45194a642bffe2415844ac3249420cbb26cd7345c0b2975667a7c79f56e787a81a8e2de5a6a78a32d958f83c5ef8d843d2ac8828f808fd3f10c0000000070 +bca0f60a0000000070bfb092f5babbbbdb8be324c55820b5d7093c372f60b5bbf1cafe60b262970cea136bbc5e0ae3b4d31ef4fa5118c69c602111c9b85202a7 +1c5346a4705dabd128c551d6edf4fbfd70d04fd24c488cf6fb03cacc99a95a3f88d7f67a357f34b52aa5a4c87ef4fa6b0a21916599c4b6679d9b2c3d75690e19 +340c7a08e5435ca5103c4d39e7699c665ce6b7ce92f92856c9112319734c8311468944c82bf9336a10769af5a959bdcff96dbcf221b279b535afbd12a284900a +eeb3f411f2b13a9e01000000008e15d45e0100009c384992082118637901e82fa094eaafbac14fac37f34b62519aa6ff95edd1f032ea2ccb7403cbb21ec82b07 +1f59b7560f765afd6be7a79ffee485d7de588bd2e0d9abf3fa0078f19545cb32feda579e6004954bceca46f3f75fb83d3b5e1a2b399b07fd5698cc358845c985 +cb3312a96f7dff4ed9b37ffea71f5ddd3af8c317ee8c559d999abbb91fb4fadc77906d194f5f9cb3287bf9878bb66d7ee32b4f16c7de034728ebf57b8b77160d +8361a4186514a3b1b223951071c639cf32a110e649925760a514431851cbb6282686651aa6297812b40e25eef504ddee45773776b217defa85bffc8be3b52a36 +4cbd991219c244518af5725e888571af1f211fa7e31900000000e07841ed150000c08973f3e6cdd5d5d573e7cef57abde2f267f4deb5cf7ab956abe98576bb7d +743574f1ecfcfcbc5ed8d8d8787f91e82fb63fea4d2b97cb4b4b4b0b0b0b4f3cf1c487b983e0c3d76a07ab3bdd272ecdce4c54f443c1e558d5d30bb756f61a15 +ff996ba7b9548e4b5737f1c66ec761c854fcb01bb4e264cc33a9c5ca95bc712f4cf4a9d9f898bf79d0d6cd089625a63add70af1f18d837281babb894913b4bfb +958aa5fbccd47fe43f1edc3fca5877d0eb76ba04137d34678277fb32cc872a669c8b7cba0029f2ff13f9ff6242986198966d9ab65e507a4dbe158ee3b4d7efae +37077f7663f59dd5ad8a57b97066e1dbbffb278dc69439d6f84b9fff441ae7b7e32ade637a93fcfe4de023e3e3743c03000000001c2fa8bd0200003871d2347d +e185171617174ba5d2d9b367a7a7a729a53b3b3bc530d8dddd5df417669fc418ebf6c5fa9f78eafded0921ba372184ee6d7979b9dfefefededcdcccc7c68bb06 +8ecbd8f96b14bd1af4e31b37b64a1635c7bca5cd162298309a667c71794f09c9188b82f4d2acd7b8f0847df693f36f7cabb1bf343356b52dbab5d12654fdd217 +1fcd52a17be87723ddac7af6aa7df1b9e9ebdf2e6fdcacd5aa868d57b63bba4f4931cfd4edbb3b3af7a911ec8b3eda4596e1e1686ea19444ca33d8cd8d439be1 +e9b192d4eba4227ac70cfd0f1b866530933286114ed32ccbf4363c13b8df0f7f7c77e3cfae2fadedee3f75f5f1e73efd19bb5c76fcfacce9e9975ebf1d0489eb +9a42c861c935bffbd6fbff530738761fa7e31900000000e07841ed150000c08983315e5f5fbf73e78eebba9cf3f3e7cf5b96b5b7b7f7fea22a21c4308ce262ea +62cdd1b34591880ee9cddf3f6c566f55ad569324b97dfbf68b2fbe1886a16ddb50543a090cdb721d1311152631669421c1797ee4e843422216069150d2324c29 +a56ec65c5f393566db1665869d5fd91f45816e39d1f043ca3b9d504ae4e8f59687ec1ab55ccb60ccc02633381f284428219944bacf111d5a4a0ac77175649045 +f941aee4204917370f7bddc1cf7ee20c238a126cd98e61d9f97057cbd32f348bc341b7d71f247aa7a5244992b5fafd3b9b7b16217fe317fff2f8e4cceb7756db +87ef7cf6a947af5d9d7bee9397f52e90fc02f377878a0fdf4430e7c047c8c7e9780600000000385e507b05000070b26459b6bbbbdbeff71b8d866118ffe13ffc +87d75f7f7d6666e6a9a79eaad56aefdd835d398ef3d8638f6d6e6e6e6d6dfdc58a806e303939393737f7f6db6f876188dfd36ab5fee93ffda7dbdbdbdd6eb75a +ad32c60e0f0f759c0ed5cbc7b2bfe0c371b912cefde2e704cf98895f7ee94e2fe05ffa99471dd3c08c4651f2d6eb2be393e52b8fcef35499065d5a6b6ebef65b +3529d28a675ffc12adccc42ffe96e877debcbee9579ccf7cfa82108ab14b9b9bade5d77eb38664da284709d747d1173e7fa5e23868d8e7db6fae548657763f70 +691055fc52a556edb4bad42071cc9bc920365918c56fadec3fb630a6a432a4a49418968b29db6fb696d7b7b7f77b11978e5e45b167d00ce18b67ce7da231dded +0dd636b6fabde8c2c2dc230bb32a4d8c4ca429777dbbf8ef16efd65e61bed78f928fd3f10c0000000070bce0732000008093e50ffee00f7ef7777f574af9b7ff +f6df9e9b9bd3cb4110fcf8c73fd65f1716165cd73d73e6ccd890effbff9982a97e4a37989f9f6f0eadacac8461b8bababab5b5f5e4934f7a9ef7b5af7d6d7373 +f31ffec37ff8cd6f7e53c77dfdeb5fff3077137cc894482846f9a5f8cc9088e8358e69d8b6a98f13cc45268592c8300ca532c608915c4603ead916669665108b +99269382c6192e065c63250c4a28122a0e88633a9619a7b154c8366dc7d11b6125335e743a0241abdf9819bb7cf9f2cdeb37f5ebcf44a65f72c233dba4b7369b +d3756f7ea2625896ed5753496edcb8fbd25b4b3fbab371d06efb96bd30d13837599ba9787e6562eadca3ad83f5fd95bbd5f1f127a74b93537519f6089d357dcf +716d29f217ffe79378c098c78f928fd3f10c0000000070bca0f60a0000e064f9933ff9934ea7635996e33867cf9efdd55ffd55cef9bffb77ffee5ffecb7fb9bc +bcecbaeea73ffde95ff8855f68341ae1509aa6ba31c6f8f4e9d37af3b5b535a5945e593cab9be9e5ef7ef7bbafbcf28a7ec818fbab7ff5affed22ffd926118ba +f1e1e1a1de56c7e950a8bd7ebc6d6d1d6eaced571bfee458451f51fa80d9dd6e138a0c83f4faf1db2b7b9d984f4f96770f7a9d769f524c0d56abfb65cfcc0e5e +c6fbe8ec933358cde8432b4992edd5fd6e3fda6ff61955ca306ad552b966f3bbfbbd41b4bf73d836a949493788df593b18ef87a3d897b81da775aedf08bffbcd +df4d391fde0a2b9f93354d33ec9929cff40a663987bdf00f5f7ce3bb3fbab3b1bb3f5ef29ebe78697666ceb14d9791300a0cccf0e01013e3d2a5b32215a572d9 +42bc56af668a9264609933520d671c8092eb47d2c7e9780600000000385e507b0500007012fdf22ffff2638f3d562c1b86f1b5af7dede9a79f0ec3f09ffff37f +febdef7defeeddbbaeeb2aa5e238d6cf5ebb766d6e6e6e727252375e5d5ddddcdc7cf3cd3739e7c55cae7aabedededb367cffecaaffc8ade6a6666a628bc6a3a +42077df39bdf3caedd041f1a9ec924116e9a2571aa8f1c8a7192090b6321f2a19dae633182799ae97f71224c331fe997cf6541884c93fc1e6f1223ace2842789 +4c854c7896245c998c488e886284e68db1e25251293392f7695b86c5e828f645711447d1c50b172f5ebaf4c68fded22f3e0c531d17a719566aa2e6234412a1be +f967af7dfb07efd886f957bef4fce3579f38e8a6b717aff7db07b315c7743ca9d24727f97e6872315eab9533623925afaabf0d9d032e45dced3a8d3191a6a378 +fde0fe7d9c8e670000000080e305b557000000274b1cc70b0b0bbffccbbf6cdbf6d14ac771ce9d3ba717fededffb7bffe6dffc9bb7df7efbf6eddba669baae9b +0ff8dadd7deaa9a78a595fdf78e38dd75f7f3dcb32a554312a766666e6d9679fd51dea6e7f224b47e8f57a936eb7fb21ee223806ad41bcb47db81057c32009fb +1122647bebd034ad53f365cf35bffadca57e18dd5dd9dfeb846bfbed47e6eae39e43313328ddd86b46717ea975c6e5fae62197a2ec7807fdc1f24eebf4446da2 +928fb966c3e294c8d0e6f6a163b053a7eabacf2f3f77310af928f6454925a5b44cfbeb5fffda1b3f7a4bbf008209e702533c512ffb9e6359e6f53b6bfadf63e7 +cf7dfeb99f49b8f8de8fdef8e1db6ffb2a3d3f336e346c46332ac3c9b99953aedf6c85bd14a34e8704fba4dec076192912340fbc890949084cf3fad1f4713a9e +01000000008e17d45e0100009c38c51484ffd1a7161616fefedffffb3ffef18f575757979696bef39defa0e194942fbcf0c20f7ef003bdcc878a3aec17bef085 +73e7cee94d9e7cf2c9ff54960ed27123d90df0518295f29d7cea4ba5b0ef3bc52d89a8c884184e686ae403093546906330295092a95e106428e3423f12291759 +26c3349512098b53256d93e9f6995041c811099941ca353789d28c4bdd953e282945428891ec4c2a88c28330fcd4b39ff9e4a79f7af595571ddbceb22cccc4a1 +7ed12197198962f2d4339fb32be36fdf7ce7f69d3b33f3671e3f35e1333c53f74e8f7b6d8e1b65972a81309a3f3313466a274bba5bfb6d45edaa854d336ab545 +c609a3f92ec8e28e5b23d915706f3e56c73300000000c0b182da2b000000f0939e1cea76bb5ffef297513e23257eedb5d7fef88fff582fffc22ffcc2d34f3f5d +dc1d686e6eae52a91cf36b051f0d41c41f3d3da9145619ba7475ae5af15ffac12d91642bcb4dfdacc288626c1ab4e6db63156775a7bbb879681b4c20756eaae6 +196c7dbd99f0ece666d735c978d92b7be6e3e5c9cd83f66b8b1d8b199cf3af7ce1b14b67265f7ce57614256b2b874528a1a329580aa5a4424a11427fe57ff72b +6fbcf1f6de618760e5bafecd03b1faed15d776c3382a97ab93314ec2e0fc6ca36c46b46efbb6bd3053b7eb63340ea75dc1b3d44432ec1c486c4d9d3ea544b6f4 +d68fc74f11bb3e81918a7a7da75e9759368c52126aaf1f251fabe31900000000e05841ed150000c0c9a2feabc7d755868ae5858585a5a525bdf057feca5f715d +7774a1e02135315632288b52de8fc5204818a351cca544538d12218c1094a4d96137704d663136de287915270a93304c1b15cfb199102ae5c26f06cc20bd2433 +18b1296a54ca96e72451daeb61ceb3ce20eac689e07c66bc86487efbab2ccb46b12f9950522a4a48122517af3cfe77ffdbffcdfffb7ffa8df56e6c1a2ce37cda +4593156930cb5403dfc6eedc23a8bfab84b41cbf5aad1a969305ade4602b9d9a204a1e6e6d769a9d8c550eda59dadd2394ecadde6910c3f0fda8ddb6c6c604c2 +0249a1140c7cfd48f9381dcf0000000000c70b6aaf0000004e16cbb24cd3fca05be94d28a5c5c23d6cab433fe856e0e1f2ec27cff7dabdd7afafbf7d77a75e35 +7992dd5c3f342cf3f92f3e6e19d8b0ade595833ffd57373e7175f6d2fc5cb9569d9d1b7bf9a51b8b4bbb57aece8fd59c3443519c8561dc0d82b71657cf9f9ebc +7ceeb45f2e9f3933f6eaab8bb76e6e8924d9dd39bcb3de44887ce98bd71c9be9037277bf378a7dc9af2657f965e0a6ebb5afbf7e667ffdbffffae7dfdadafd83 +3bfb52a43ff3f8f4d9b9f1f6204a93cca438e09c4dcf7ba6c1c3500cbaa4bd130fba7bedfe271ebd72b8bdfbc28f6f13e6d9ee4064ece2c2946b1b3bad76e760 +ab6a2cb477774ba7e615caefd144f26bdba1f6fa11f2713a9e01000000008e17d45e0100009c2cbffaabbf7a6f73b01673bc7e503ae86ffdadbfc539dc43e663 +ae75d8c74a989589f2e9ea619084e961d9352dc3e87642ca906d2451aaaaa72e9bbe23846ab7068320d6c7c6dcf4581cc6072a1f671a4729e719a64e79f6b255 +35a494836e70eb0e1712cdce8d1d8681688725272fe2eb3e63c3a04c0d22398a7dd187eb70524f450db6f3e31ffdd1fffabd739fba36dfa83ffb08fbcecd8d6e +94294cc61a7582711a67ce208ae3818a842325662a4ef161371944c9fac6ee0fde5a5ede6dd6ea55cf19c48a6e84edf1aa5faa8e19b615f43ba8571ab45b8ee7 +1bccccaf6047f7f2fe0223f2713a9e01000000008e17d45e0100009c2c172e5cb8b70da328ba87ad30c667ce9cb9b744f010d9d86c9d9da938b397c6e7cedcfa +eebf885bdb4f3c32ed1af860bf4d113548d6a3b5da535fb7d11a417757370fb637db9ffdecc5c71e3f75f39db583668f3196a43c491265d7aa57bfeaaa5d866f +6ceeb696d79a9f7ae691a79e3cfb3ffef6776e2e1d7cfa423e74b479d0610a5382fab4348a7db16b3665647827fa14b99eef5a731395d6a07faee66c4c54ee6c +1c5c3c35612a420926049bbe470d2ee2248b1291a138950853cb60d76f2d8b2c397b6a7ab1d9beb9db6c0f82474f2f8c972e5ebf7dbb9f64cf5cbc7026e351b7 +cf88812dfd0d32d03dfdb70d30221fa7e31900000000e07841ed15000000f82f534ab5db6d0433b782ff04d733760efb1c6d58aa5333a5a8385996c588f68204 +6b4a26a4eda8b739edede1d0f3ec4b57e6522eb6365a99c89feff6824c22df7752a2c8fe5b8284bb38322cf3ea957929e5da7ad3656cb2ee7321a344f6fb9c50 +49108ed148c60956e6ca866b124ad341af7afedcccfc44160c96de59f4c6ebcf3f7bf5b7ffe807ebfbed46c5b7192584604c6c4ca492699208a9b85212a3c95a +f9f444a39ba17fffe6dd41188e7bee9589c985c93353eed446b4f7c26b3f90291f9f9a74832053ca304c66b07cdceb239747b13be01e7c9c8e670000000080e3 +05b557000000e0bf0a545dc17f86ed98efdcdc748c8e8d79c332905566546aeb5b4d82b0ed1844f51db51313bc18ab271f5b78f4d2fcad3bdb3b3b3d239f4058 +ee1e741022e7e6c792386deeff284564299597cecf3ef1c4e9a5bb7b5bdb879e614c565d469142d9c6d63ea6c8362d3a9aa1a26ecd2394628c65caa56dce7ce2 +72b4b86a52830a3ad7a878ae75fdeef6b58bf326a5ae450942bd416c5026b00ad2244ed20c29cb713a92fc686347eff627e7e7302792f88155fec3fff09db373 +93a7c76bcbebeb6b9bbbeefc6c36e8bf7b972d853ef9999f1ac9fe800feee3743c03000000001c2fa8bd0200000000dcaf384a271a7e9cca24c60249ce456f90 +9806fdc485199ea97796f66cd3f04c669bd6b89b375e59dd6fb77add20c6c4c824c2982a89b79b3da554860dcb34267c33cbc4fa5aa779d80b83344cb9e0f220 +e094d2272e4deba7de593a30191dc5be50f6eef9212614f1ccbf38475aadcba6b1d319ecddd9f8c499e9efbfb3363b59638cd53dcb3529a22408c3544821659a +a5a9923d445fbab1daeb0f9e9c99d939883383d95537debcf3e4ccf4954f3c559972bff9d2ebdbcdc34f384e2285e099fea2b71dc5be807bf3713a9e01000000 +008e17d45e01000080ff2af7707b2e7072304a67a66a1b3bbd76a72f091508afeff57cdb7ae42b53ed6efc3b7ff6ce64c53f35e6f825e7f46c3d08c366ab77d0 +ee0d8298133713947029898c7a29c58ca0ccb1adf9b96a18a48787ed4e3bd4ed924c218cd70fba86c1fef2d927f586fff63bb76abe39eafda2183915835c9a55 +3f5ab97cf9b45df7ea59fae3a5ada5f583cbe7a60f0709770c957122443e3f2c920aebaf68bdd97b7b796bd2b5dfbcbda18859f73dbf2917983f79e6e26ea7e3 +97aa96e5b4068389c9a9546f28f3d2ab36ea7d01fff53eaec73300000000c0870f6aaf000000c07f19a5f4effc9dbf532c1cf76b011f45cb9bad834e706ebe7e +edb18577167792845f3b37c908fed19bab8419cf7ff68265d0aae71cb4fadffbf14aa3e4555dfba013f6435e2b9906e6a74ed77427afdfdc702cebd38f9f6e77 +c3efbfbe5cf6ec5ad9d9eb0e3a41e2188641c995850946e88fafafebaf5f7ef6bc4147f3df03144278381380fe4a5912613539cbe6394b4364d82ccb3e7d76ea +dfbe72fbd474c3b68d7e985a2c2fd1f2942b8c15250aebefc641abdd77b9b838bb70ba52b598a5304b307a63fbae72c8e53333d57229c98461db162152e42366 +158c7bfd28f9581dcf0000000000c70a6aaf000000c07f1921e4dab56bc7fd2ac047d7d67e6779a773eef4d899d9caadbb7b42a60b93534265b7575ab5aafb85 +cf5c12423816dbef06d7efee5d98a98b92bb77386885dcb14ccb443313f91ddefff0a5a05296e7e61b6f86c9dbcbfba7262a325179b37e32ddf098e7ce8d9718 +a137560faa25fba73f7b918c660a6285547ee7abfc2b41d411e654c6057a741c35777a776e60cc9d281fe87a6365e7f1f3734a488ac8208a33c115a11ea342a9 +8dfd76d5b3ae3d326d1974236a73895b31bfd3ea38b6fdf34f5fa314cf4d8d6f0e62fd3d6194292528c60a43dded23e4e3743c03000000001c2ff6d7ff4f9fca +ef47abcfad912458214c09c6020995ff8fd44f1597582a24a440719ce9d3656620298894321ffb43b0a1b7202abf03897af7a4395fc612e37cc27c8ca87e2891 +0883ccb62833a91228bf3faa8e805cc87d68737ffbbfffc1a8de94007ce87ef1fff0d4897aff422ee48e22f7e9c9ea85d9dada76eb87ef6c4c969d8aefddb19e +4833d9e67f74b8db59fc9d5708cd5fc144c97cfee9333c1fe5297feaa9b325df79e1fac66e2b788e999649bff6d94bfd28fd27bff3f2b8e7fcdc530b45b367af +2d944bf6e2ca4194f015e71a97acc5ffb8b5df5bfe9d57f5fe7dfa571ffcef04bd47efee1d65cc74add2b821f53711cbc6945d1d0fb73671b6fcf967d877aeaf +96bdd6cc78390d38462ae61229416d4b62bdaba851722d8324286e67692fe2dd8853955d9ca8628a17b7775777766b53b3beef21a94cc6e2208071af1f29eb9f +b27c6be64573f0c2e12dfc987ee7385bb297bf8f66ed6d2cde096ee56fa044a8055c9d9fdb93f8207f1f8d3b48ac0fdf4737b255fd3ec25f9bec48f98f9ad7d1 +38aefef5537da26ee6efa3868d501ba196526b38c88fb453f62ea2378345fd3efa47f0f708722117722117722117723f76b98cd8f9f53d9592c3858a429ea6bc +1bc49ec574d78a524669bf3f2084f9254ba5928b4c6f98e667c9ba6b66b9b6ceb398a15f4fa71fe9171b04b1ded0776d2184cee09c4731f75cd3b24d9e64ccd1 +67f046bf1f2aa93ccf865cc87d78737ff2330a000f3383a113f5fe855cc81d45ae3edfc2589f7c612cf539973e454344a54462aa1b4a894c4a044e52ce94a3e3 +b014fa442c8fa0c4d04f0a4209d1a76ea6651889c05c5185083108caa450ba99c90ccc30e18848411561422129497e81f6686e0cafde1bfa8a71feb2a8cece67 +db5052542e3e9ad5a77efc83579ebb3a473df78fbeffb6c8c478ddd3fbab4f30e32809631e44dc31d97e3f5e3dec9f9d289f6ab80ad14ce91db263816e6ded1c +f4c3563f381c2cfdce3ffb979ee737c66b4f3cfda4edba23d917704fe0ef02e4422ee4422ee4422ee442ee83ca6546093342913e671679f5d7291956c3705c53 +b7ebb60609e765db53049b36d3dbf8d8a54349c6b32cd39f2eb890a68311c5a63e23d79f355c5b7fea701d0311abe43b511c0fc224af222b3539d6d08da51265 +c71ad6862117721fe2dce3fe4c04c0833479e164bd7f21177247917b7bbd89d1f05653ba1dcd8ba45baf7dcb60ecfc948f09b219ed86e9dd9d4eb31be97f84a0 +54c852d9add59cd98635ee1bad763fbff49ed24c6544c9563f680f427ddea69b399e33d1d0a7758c63befbc6b711c6e7a73d037b86610ce27414bf13f271afef +ce3a20791cf7bb2d8c88ed79f9f9a74a97de7ee377bff5dd4f5efaebe7671b3b1767deb8b17e894ff8befe6e0bfd6d4b9294731173bedf0b4c46261ae572c537 +180d62d9ec476bcd7e9048a15098e8a6c1ffebd7ffa727af5e3b3535b7b9ba717a61fefce34f8e6277c03d80bf0b900bb9900bb9900bb9900bb90f2a97218360 +83d00a9589c862e538cc71996ddb25df0ea284a30c5934aff512c50ca237638c78ae3d0892411c45419246dc732d645321b1cc10658c2a844d6231a332eeb010 +138fc4110f42eed7ed6e10890431c232999fd7432ee43ebcb9c7fd99088007e9a4bd7f2117724791dbf06c9331847424b1687ecd7ed9cbc7abfa2547f72e0537 +4d73acea238209c2fa444d864971f992e556a421d5f095ea2f8cb16a253fa5cb2f5b124204e9f0e561a22456b2e4e40364fd926d2096a5c26423b9f39bd2e7a2 +14a37c70ad4c92786f7d8dc77c6266caf16d83a8b8dd63a6fbe28f6ffce24f7fe2da233307cdde0bd79767c72b538db2998ffbcdb733f2fff68f632e763a6137 +d6fb210751d209f97e2fa4944569a6bfebbd4ebb5aaede5eb99d7f4728f9de77bfff8dbffb7747b13be01e9cb4f72fe4422ee4422ee4422ee442eee87299de38 +da8ee37fbdc72e7a95cf54642aa3244bb32008c26090208c7cdf34186ed82542b16db088673b3b6d8ca9fe38a03f1854ea7ef2837ebad81f7f7ed29af4f5a939 +52c4358d44663bfb6dac9414f9f9b4ef995356a9c11c2e453b0ce2341b2409e442eec39b7bdc9f890078904edafb1772217714b95ffcf4f90be7a7f5e91963ec +3b2fbcd56945dff8f9677c3b9f2b200cd31fbe72f7d464f5abcf3fc145e6d8e6cd1b5b2b2b7b324e97efeef84f7fc3a9cc6c7df7d765d04984aad6bcbff98d67 +a544b64996560e6eddd8c0195f5e3c08a254f7fc4bcf5fd567812665fd307af5074b538dca287e2728f4eefdb6f49928e7d9fefe6e6fafc9a360f6f464b7d55d +babdfca96bd75ef8d19b3ffbe92b8ec99eba349d66e99df5fdddd6409f8f7a26734c9a649990f2a01fa19db66b0d7826934ca499ec849c0bf5f9a7aecdd7bd7f +f6bffe9e61b07aa5b6b2b1da0ffae716ce8d625fc0bd3969ef5fc8855cc8855cc8855cc885dcd1e53262b3248de55b7d5c21963b9e292eb0e46916a5423065e8 +93629b9a84d54b1ec3c431d8c1a0df0d42c735b0850d45996b86db61f05ae7dcf3a74b6537c6f9b56f0c53dd4d30480d13b37c10086694555d577fde90527645 +62e403382017721fe2dc63fc3804c00377d2debf900bb9a3c88d13de6c0d30c68e83513e337f7e415326898168269244e8b3b84c22ccf559581ae91335463161 +982162a301415dcf63883a76865c9b4989746f69aa521e33c628c5584772925f0495df7d0b65446642a552e83e47f13b0193fcc5e753c9aa7ce65a4c509a0cda +875ba5327eedc76b1b3bbbe3e363638da96fbffce6f39fb97a68d0a72ecece36bcadfd6eb317f6c278bfcb539ee90ed28cc719774c1b2319738931a995cacf3d +f5899f7ee6f1ed8d25bd67f9745abd6ead5a8be2e4d6e2ed51ec0bb83727edfd0bb9900bb9900bb9900bb9903bc2dce45fedaa50900a334dd3ab59bd1ff7fb7f +b2dff8da4cf9a9eaea6fae44bbfccadf7ddcac1a442049645386fa747ff6742d7aabdffaf73bd59f9ef0be500a4c6afa6647a5118fc33866049d1f9fa6a9395d +c1f19dc1e137b72acf8d39cfd5db2ab0b1c9b03a5dabc59d64ffb7de865cc87d78733fdc4f40008cd6497bff422ee48e22776fb7b3bddeaa8f79639365c92521 +acb9d7c1149906edf4e2b757f7db613a3bb3bfbfdb6fb54266106dac512e7956d67e0d77f0f9276709a20aa3244a77370fdadda07938a09462a2ea8d4abd62df +5adced0771fba03fe80e18c3fd01d77d8ed74aa3f89d7034b3b9fe7f93d1e9c9498bc7b66b626c645c709e365bedd333a7ee6cae8ddd583d3fdb5052945c6bac +e2965d238cb330c9129ef14ca6c3b1ae085383e97fa6effa17ce9cbb72ee6c1084486698e034cb2ccb3a681feaa7aaa5ea28f605dc9b93f6fe855cc8855cc885 +5cc8855cc81d5d2ecbd6e34c4a1b514a9065531c0ab1149a9cf8550bedf16c29aa58aeed993c4a0596824a64a18ae9c834cc6e47e8d3c2f20cfdc10029a5cf9e +a5e009e20833cf73b04952432211f15ba1ba264c8f65421a0a318a3dd30e4c0cb990fb50e71ef76722001ea48c9eacf72fe442ee2872a55291c8622e92289152 +62ace224630636183129996df8e59295862249f536dca506caa7865512a398ebe6240af5221f0431d7d24c37d38b9e9dbf439552f924b2241f4b9ba45c28ec51 +5bbfaa997aa9e4dba3f89da05f50b1a0132dcb9a9a9e2d316ab83eb61dd75aaf54caad76474859ad8ebff0f67e14c5e7661b6325374b78b3c7459611a41c83d8 +8c0845b1c2447fef09f3dcd2586362bc564b92844a19c7a1631add4162db96effa611cc17d2c3f52e0ef02e4422ee4422ee4422ee442ee83ca6567a6aa3aa4d9 +0ee3a578e37f5894416634ec208955279c9eaaaad87cf5fffa1a2b19137f7b5e74c5deafafd33396f78dc938498c8615bcda496e0cf8614a1dc37399e59bdd7f +be11b6c4778d1d3666957e652a8a53dd2c7aabb7bb1ca1484cfc6fe78c697be71fbf25ba1c7221f7e1cefd37c7fda9088007e7eeff70e364bd7f21177247906b +626b71bbb510a53cc97a830853b2b97be89ac69933e39e6ffedc7317da9d7865fd60bf1b2defb5afccd7c7cbbec90ccb661b1b07512c4d032769bab67628842c +f9ce412f5cdc6e9e9d1e9badebb33962d98652f94d54b7f73a3633ce9cb55d8ffdec672ff4837814bf138ecaa01821d3b2cb8d49cb72a8697389da9d437d6eea +f95e1846ba51a5dc786db1d9ea45f3137ed9b74c835884f4f537418824934462a9943e8bb54dea5a8c1022458691ea76db7112d9260b9910194f9268626c9211 +a8bd7e84c0df05c8855cc8855cc8855cc885dc0795cb6c83518cfa2657a9e29b213110a10a65591a8b2a21d834b776dbb49f957826a2345a0fcc92b0527da29c +3182505fa42d4e0c665a94114a11261da99a49241413dcc9329989fc3cbbcf65878b544521cf123ad88f5537995d702117721fdedce3fe4c04c08314efc427ea +fd0bb9903b8a5c35674e955dcf6252cac989aa69b2666ba0240e83546114855994a49830dd60bae26512778244347bdd011322af4e46717e91fe20cde76f2d63 +ec186caaec534cba412c09ed87b1e519a74af54e3b5458855182150a49c6f948fe1efdf910548c986938a532b36c2165a356bff4c4e3dffde36f57ab0d9ef238 +8963213cb77c77b71f25fdb3d3fa5b8dab65cfb2cd2815f9ddb614e25ceaef9363d90665064614a9388ee2b81fe95d40d4b21c8352dd73afd7196f8c8f625fc0 +bd81bf0b900bb9900bb9900bb9900bb90f2a9749853d1b7ff1998528e607ad3ec6d4c06ae7adf8e09535db304a8e33ffec5732a10effefdf53921b1513efcbc1 +3fde68d8c6c4230d49f3db75351a7ed9b67ef07b073be1d67ff3eca3fad3c2c6e65e3f4adffe271b55c33a7fbe2e507e0a7f6bb3d7fd5fb69441a7ae7e89512c +d75f865cc87d787301f838619e71a2debf900bb9a3c8ed0ce2f3b3f57c1a0185cf9f9baed6dc975fb99d466263a3357c9f29cab06db3b267d74bceddadd662f3 +c0349940f8e24cddd37d6e34e334bbb3ddf11d73a651d2cd6abebdb6d3bebdde712d334db35f7cfec92b8f4c7ef7fbb7e330d95c6fe5f7c2c228bfbe6904deab +bde65ff5392435f233509a472aa43033ec6ebf93e9fd44449f70f6fa7dc7b6b65a69100f2ece78b6499863db860c137d7eaa2c86302696e9d84e7e835825b330 +08793ce80ef4f38260625b16cebf396667908c625fc0bd81bf0b900bb9900bb9900bb9900bb90f2a97118a0c4acaae919f4c53c2f409b26118fd4476335ab728 +c58ce55398e11ec75260932049b21667639651b284e0fac4db352cdfb56998e196f01ccb3199e73a1947a299d19a6555ec5470a2102512c718c58a206c620ab9 +90fb50e702f07172d2debf900bb9a3c83d7f66c2a2f8b093b4bad144bb9f4979d04928c2171f99c4fa0c8ee241102f6f346b65afe49ae716c6cf9e9b6eb5badd +4e34375bf37c5b662a4d7827cac7b1ee7793926b34caf699d3e3f367a63a9d7eab13a651bab3db6df66291f24be7a7983e83c3449f208ee6b7c2bbd557acff4f +4ad3b4e33479e787afb6d637df7eedc75b7bfb13638d38ee97fc7212c7fa5ba2bfda96d909f98f56a3857173cc5706333ddb10229f3856494428cbafb322384d +c28c0fa4c87a314f38f76cdf32ccb2ef1df60299c135251f2127edfd0bb9900bb9900bb9900bb9903bba5c46956486a93bea848377365a162152e67d62ac743c +16d9d60fffbdc1d8f9d93226c862462f8c9776bbfbbda8d98d0841a9c8fc92532b5b7363f644c96c365b0451bd71a64fb429ea04496779070f5d9e1b53fa4529 +b9f8f6b733993d32e1432ee43ebcb9c7fd99088007e9a4bd7f2117724791fb773eff58afdddb3e585a5cdd9c9b7489444bdb6ddb205fffea53cc408e63df5dda +fdbd3f7de3996b67e6a6a72a63d5d9b9fa4b2fdebc7b67ebe285d97ac34fb988e3b4d5eeb7fbc1ad95f52ba7a71fbf34e557ca0b67267ff8f29d5bb7d633ce0f +5bdd95dd432490eed3710dcad8de6e7b14bf13f2c26b5e7dcd47ba1ab61b05e1bffd17bf7db8b1ed38ce5eabdd0b82b2572af9a55ebf57f2cb3c0b2a954a7fd0 +732c3388a2b543b31ff3f90629fb5efe3d52584aa41026589faca6194fa4e494d25e10ebce3329f40fa31bc5bbadd6646d7614fb02eecd497bff422ee4422ee4 +422ee4422ee48e2e9791fc3e0afa343eefd4c2d8774cc330901419c296cec0b4ec31931995929bdf665708d3648d8a8787b52721840c25d15194596e451a12a3 +fc8a347dc6ce18a9973d4a897e9465224d337d9eedba967eaa116459462117721feadce3f81c04c0a89cb4f72fe442ee287237b70f5c033be367a69fb8b0d5dd +d8ebec4ed67418dddb6d51835934e84564ea89cf3b6332937c7bbbb9b5756018f4e2e553837e1446a9ee278ee334e6d47026af3ee794743adfdfefe8cdf52bbf +7c75617165b7b7138f956d4ac8e15e87eaae29e9846214bf13643e5c351fb0ca0c63d0ebfdfe6ffdabd5c5c5f1f189959ded388a6dd3d83e3c989d98d467a861 +1494cba5201894fd72bbdb29797e7fd06f93f2602b5e189753f59252c4b25d4269100419e70ae91359a9ffb737081452bea3bfd564757b5b7fab851ac9be807b +73d2debf900bb9900bb9900bb9900bb9a3cb65a6cde228595e39a0985c9aad9f3b3f75e9f29c3efb67d4fcb317ae775bc1377efe19df3630c349c85f7e65717e +a2f6d5e7cf709139b679ebe6f6d2d28e48d2a5a5adf2d37fd5294f6f7df73764d04a84aad6bcbff98dcfe85377cba6cb4bcddb37d71996571f9dab96dd4f0915 +45c9f75fbe05b990fbf0e68eeed30e001fbe93f6fe855cc81d45eee17ed79f2bd913172b336796fee437a2d6f6d3e7e75c8bf57a037d36662115d37ae5f2676d +b466e2db1b7bbdcdcde6739f7f746161e2e63bab8356623094a492f34cdaae77e13907ed59e8faee617f7975f733cf5eb97af5d4f7df58bdbeb8fdb92b339e63 +b6fb0346a9897140fc51fc4e9052e17c6a574919fbb36ffe41a77978e6cc99a5d5b5284e6dcbae481424d1ead6c6ece48c92491847cc3094128d5abddd6dd7aa +b56eaf8d2c6ff94035bb87574e4d58065384dab62595d427bbfaec334a9284a794104cf0204e394f1dcbe13c1ac5be807b73d2debf900bb9900bb9900bb9900b +b9a3cb65549f5d53e2d84c9f0a0b41f53971eb70a04fb91c87eab3eebceaab54a61053381132952ad367e408f344f224ceb2ccc8efe3a5b0d21f2a7a04b92597 +48ead819726da603f233eb21ca70948a38c9d24c7fae102917900bb90f75ee317e1c02e0813b69ef5fc885dc51e4966bfed64ec0f14d0faf4fbb82e34a267892 +a27637245a3ea3d481875e4a71b881fb95aa3f3553e19cafaeee654211823a9d587758ad395ca968fb65499375d4b75df799672e4929efdeddadd8ecec644908 +a143bbbd28ffafeb48093492395287df15a9d30f77f77a7bcdb1f1f1c5d515a9f2db6ae9ef551c478cb26aa9bcbab57ee9ecb95eafeb79be10fa7b65d5aab55e +afe77b159e2559260e84f1cd576efda527ce9f9daea72abf0f997efd281ffa9acf26ebd836265610362dc3524819a6398a7d01f7e6a4bd7f2117722117722117 +722117724797cb32293dc7595818ef75a3ed9d56f3a0bfbdd96e34bcf1495ff27cdc6c73af43286226edf592b796f7e7c37476a6b4b7d36bb602d3a0fa3534c6 +aa65d7929dd7551b9fffc42c413a132551babb79d0e98507cd3e1dba7e776f6ab29244b1deb78c23c885dc873af7c3fd0404c0685d5f3b3851ef5fc885dc51e4 +9accb8bbd3b3acbe8144d994d4f0f3eb8d84dcddeeeafe2dcbc4a86fabbd14b1f5843ffe78e5d2a55377ee6c360fda3a45bf0c7d86a7bb3d7d7a5c9f9fa9bd5b +1965eb21bf70c1bb74796e6971eb70bfeb323259f50d9a4fc2babdd36504d979b1321cc5ef048c9169d95994bcf3e2abed6e77f7b0bd7778e83bf644bddaeaf6 +05333bfd6eb55c712c67efa0393936168403d7f57b837eb552f67d2f0822cbb284ccd63637370e76360e9b9f7ff4e23317e6f47793107df28aa59294e8af2acb +186306c23293fa87958c625fc0bd81bf0b900bb9900bb9900bb9900bb90f2a97e54331f21a6e2e9f0b568888f3988b28d4e952af89938c19f9fd7919c5b3635e +d93393204b5291f07c8a04bd3a1f1a815118ebe6240a0546bc1fc459aa7720d3db06b170ace1b68d326379c52acdf74d412ee43ed4b9c7f979088007eda4bd7f +21177247919ba6d9cc4c358ab3308c89e451961db442c7327fea9947e284bff2c68ae79a63aee37856ad41e3385b5adad9dfed8671a29099218c08414a6eedb6 +f3a956b1a537ac56cb4a64cbcbbbbbfbdd20d0bd267a8f765b1135d9e73ff9084f85ee53371bc5ef04c7b2e230fc937ffdbb771797dac18011aa5fb8ed3a82f3 +b15a1577ba18570f0ef7c61b53dd7e370803dff37bfd5ead5aef745bd54a1dfb9827499aa18d831ddbb4d234f9e3d7deda38e84f37aafa05c7494086136ad986 +a7b30cc6523e28b965027f5a3f4a4edafb1772211772211772211772217774b92ccd84a3986db2c8302c83edf5a25b1b0767629ec6bc37c8af68dbdc3d742dfb +cc42ddf7cc9f7bee42bb132fafedef77a395fdce95f9c678d933f486365bdf3cd001cc90baf7d5b5c34caab2671ff4c2c5edd6d9e9fae9b1f2cf7ce6119da577 +647fb71f6529e442ee439dfbe17e020260b44edafb1772217714b958c97addddddedc57192622c90daeb049e9b1764dbdd78657f3059b14b06f589355e2f8571 +da690f7afd280c634eb09088e8f33e2570ca3165440ad7b51a8d521c65dd4ebfdf0f07fd44ef883ea5dbef0f283367a66afa7c6e6daf57f347527be583f677fe +bf7fbabdb1e9784ec9f752a1a2244e93d8726ca45fa9503c6b954a9556af6d1866100525afe43a5ea7d3aed7c75bed66bd5a3798f1c65bd77ddb1552daa62d05 +bfb9b67267935d985b981e1bebc4c1e661ec954a2c1fc5ab2ae54614858eef8c625fc0bd3969ef5fc8855cc8855cc8855cc885dcd1e5b2b9e9aa3eeb5d5e6f25 +5cf482444a395d753c3bbf2dd7c478c5b2ac66aba7848c42fd914045248b929450ea596cbae26512758224dbeff607a6cc14a3388ea4fe683018de05be82b163 +e4cd2826ad20ae742385df9d28c120747cba04b990fbf0e61ee3c721001eb8ce097bff422ee48e22579fa5edb4fad7ce4f3ffdc90bafbdb116a5c1b357e7f5b9 +da8baf2c5a96f1d7bef20423a85c7256369abfffc2edd9f1d258c9d93ce8b7c264ae412c4a2e5c9e91487debfb77f429dacffff4a3ab5b077ff8c29db1aa3353 +7337f783569ffb0eb22de3e98b7316652fff70d1b6cd6f7ce5493a9a3970befb077fb6b7b557afd7bbfddee6ee3ea12c080389b0639941102242c6eb0d428c4e +bf8709a1c4ea745b9313d304a3fea0d7a88fa571b8b6df1e8481e7d852a97cfa57ce5da5a414fbdd5eabdfef47dd380ebdfaacc9ac34ee892c2bfbe52c4b47b1 +2fe0dec0df05c8855cc8855cc8855cc885dc0795cb9ef9c4b9e5f5837ff3073f320c1aa5fcd478f9c2ecb850fa54195f7a64a65c735f7af9068fe5da4693488c +902206d6a7fbd592db28bb77b75a8bcd03d32242d18b3375d7649b9b87719a2e6e753dd79c6994f4e7879a6fafee7516d70ea8905861fdb982316a98147221f7 +a1cefd703f0101305aebebcd13f5fe855cc81d45ee54a3b4bad37de2d2eccc4445bfad049763d5fc9afa5b2b7b8d8affccb5d35c2ac7a5ab9b7863b7e330642a +7ed80d5a7132e699d462e54adeb8172688a1f1317ff3a0ad9b112c4b4c75bae15e3f30b06f5036567129237796f62b154bf79929398adf093b9b7ba6692669ba +bdbf6fdb96c844b95c59df5aef741133cc201c54cb9572c99f4a26360f7622128f9f3adde91c56aa75deeb88946f36db2b9b6bae6521a55ccb89a37eb53cae14 +324d3b494282896d19dd7e8ba6b1c9cc6aa536087bfa5b6f1ac628f605dc1bf8bb00b9900bb9900bb9900bb990fba072d9f65e278eb2d9c972a5e437c6ca440a +db40cd76dcea46e3adbcdedbeca614e7794a09c6d8208897375ad5923de65be716c6cf3d327378d8e975e3b9d99aefd942a834e19d48e893b6fd6e5272cc46c5 +3a73ba31373fae23652ebb7e675fc629e442ee439d7b8c1f870078e0ce9d9f3951ef5fc885dc51e476c91445af06fdf8c68dad9245cd316f69b38508268ca619 +5f5cde5342eafea320bd34eb352e3c619ffde4fc1bdf6aec2fcd8c556d8b6e6db40955bff4c547b354e81efadd4837ab9ebd6a5f7c6efafab7cb1b376bb5aa61 +e395ed8eee5352cc3375fbee8e7e194f8de07782ef39fd41b0dfe9788e4f0816446042af3c723e08c3e6616b6c663e8cc230e87b8e5bf14aed7ea7d9e99e9e9e +dadc5e5f985f78e7eecaface3625cab2ac2c9fe62ab30c4b64a965b982278ee998a63d08db1811d7722d662a4464c6fbd1a0511b1bc1ae807b047f1720177221 +17722117722117721f542e6bb7fa82cb71cf39bb30feb9e7ae6c6cb63a879dadfde5c5d5cdd9098728b9b4dd354df2b5af3c6d19d870ade5a5bddffbd3379eb9 +76767a76badaa8cece8dbdf8c2f5a5c5ed8b1766eb0d3fe5228ed376276c777bb797d72f9f9d7efcf274a95a9a9b69f4c3102992a6d99fbcbc1465d955c885dc +8739f7c3fd0404c0685db93a77a2debf900bb9a3c8fdff7cafe93a26222a4c62cc284382f3fc948b1022110b8348286919a63ecbd3cd98eb2ba7c66cdba2ccb0 +0d83e1280a74cb89861f52dee984522247afb73c64d7a8e55a0663063699c1f940214209c924d27d623c921b5425691a44b16d395849d33052cef3d95e938c10 +7a6a7e616f6fc7318d5aa5babdbba75f926eb6b5b73d556f9c39757a697d6fb7d5d5bb6530234a22cff694eec1b482b06f18a66b9728a54912e96f8f9557607b +15af2ca46cd4276897b6baad51ec0bb837f077017221177221177221177221f741e5b277960f4a9ef5e863f322532fbe748b10e41ad89d383b6d5ddceead1f74 +77a7aa8e61d2fdbdb6fe20e11ab41791e96b9fb7c7a510627bbbb9b575609aece2e553837e1446a9522a8ed2380e89e94c3cfa9ced2b99f19dbdd6ee6ecbf76c +7d26976562aaee263c835cc87da873bffcd5e3fc4404c083b5b571884ed2fb1772217714b9972bd6dc2f7e4ef08c99f8e597eef402fea59f79d4310ddd6d1425 +6fbdbe323e59bef2e83c4f9569d0a5b5e6e66bbf559322ad78f6c52fd1ca4cfce26f897ee7cdeb9b7ec5f9cca72f08a118bbb4b9d95a7eed376b48a68d72a477 +26cbbef0f92b15c741c33edf7e73a5329ca9e081d3a78c699a2a9c178e3b83a4db1f447154f14b25cf8fa370ac313e087b1bdb1b13639308e334cb522bbdbdbe +5c2f37360f76aba5729c4452f2925726f93c5a288ea26ab91e4603c33018731dc74bd2bcfcda0dbab393b38c30fd4d741d4fa091cc9f00ee0dfc5d805cc8855c +c8855cc8855cc87d50b9eccdbbbb67e6c7feeaa3671617b75ef8de8dd9d9c6b9f99235be509e39b7fcc7bf111dee3e7d61c6b38d5e6fa0cfbf53a4625a2f5ff9 +ac83d618b9bdb1d5dfdc6c7eeea7ae9e393379e3fa4a10a60643499adfd24bdabe7fe1b32e3a30f0f5f67e7f67ab75f5f2bc404a483956f6c398bf746b137221 +f7e1cdfdf287fb110880911a748313f5fe855cc81d45eea38f2d508c14218c191211fdce724cc3b64dc618e62293424964188652196384482ea301f56c0b33cb +3288c5f4199b1434ceb07e19ba1956c2a08422a1e28038a66399711a4b856cd3761cbd11ce4fe28a4e47a0d3efedb5dae572092bd50f06bd203a68b737f6f62c +d33a333b6f649952786a62a6dde9542b158429cf442fecefb79b4aa6fa9feff8993e75454aca4cef8eebfa294f4cc3e03c9eaccf84613008bbbe57ea85bd95cd +e5471fb99aeaf351c396a3d917706fe0ef02e4422ee4422ee4422ee442ee83ca656726ca75d7b87b7787f3ec539fb930e8c7eb3b038e6ffa7873da159c784288 +3841ed6e4049fe412241c2452fa564b085bb95aa3f35732e4bf9cacaaed09f3308ea74622965b5e67389e29d1f2a1c6f9281ebbad79eacefeeb4a5c20a892449 +b22c835cc87da8738ff1e310000f5cb31d9ea8f72fe442ee2872d7d7f636d6f6ab0d7f72acc239c718ef6eb7094586417afdf8ed95bd4ecca727cbbb07bd4ebb +4f29a606abd5fdb26766072fe37d74f6c919ac669452fa656fafee77fbd17eb3cfa8528651ab96ca359bdfddef0da2fd9dc3b6494d4aba41fccedac1783f1cc5 +ef0485947e858c924eb7673b9e50c8f7bc56a7b3b1b77dd069cf4fcd38064d04db3d6836c2687e7a5e9fb3a65916f3d077bd94278c19fa9b893121a6a9f4f74b +098470d9ab4825fbfdb66138b6e5e810df29ede9f3df6060e86622cde769001f19f077017221177221177221177221f741e5b2b192e59b46abd9f67df7910bb3 +376f6cdcbad976ddbe81b62b2642a6cf08d69f0476b77bfaf383659948f51db49760b691648f3d56bb74e9d49d3b9bad66c7c84fb3c961b38f085e589888a2a8 +bd7f3321c65a945eba72eac285b99b3737d29473a16c333f25875cc87da8733fdc4f40008c56bb333851ef5fc885dc51e42e2ded248970d32c89f34b8d28c649 +262c8c8540faa1eb583a88a799fe1727c234f391abf905f984c83491122189115671c29344a642263c4b12ae4c462447443142f3c65871a9683e9a34efd3b60c +8bd151fc4ed0e797b54a8d0beefb5e4f9f7ec649a954ae94ca65bfb47db07b777d796662c662b67e4977b73699e18ed5eafd70a05fa0425228c1795c72cb0853 +fd2aa961ea976a98461285f99dbba8adf289084818f55ca7c40fb6b70eb62f2c5c947abfa818c5be807b037f172017722117722117722117721f542ee3190ad3 +6cff2018841c1316c7d9fc7c238ab3284a94d22f466cf643c7327fea9947c228f9e15b6b9e6b363cc775ad7a9deac6fa93c6fe6e378c1385cc4c9f655396c96c +73a723f5c7086c39b659ab9704974bcb5b1bcdfe271f3d5d2edbdffec15d7d123f5e722117721fdedcd3c7fda1088007e8a4bd7f2117724791db1ac44bdb870b +71350c92b01f2142b6b70e4dd33a355fd67d7ef5b94bfd30babbb2bfd709d7f6db8fccd5c73d87627db64737f69a519c5f6e9f71b9be79c8a5283bde417fb0bc +d33a3d519ba8581863362cb68a0c6d6e1f3a063b75aaaefbfcf27317a3908fe2778250248923fdbf1853c7b2cb5e79b7b98730736dbf56aad996bbbebb659af6 +d999b3dd7eebfad23be7e71ea9941b428a281e94ddf220e8a759c208ab94c7d22436184b785cab8e6519529886d1400a5ef66b411819d408a2411885f9205932 +923a32b83727edfd0bb9900bb9900bb9900bb9903bba5c2690e29cf77a52aaacdf379144f5babbb7d38b7432c9c76aec7502cf913333d576375edb1b8c57ed92 +41cb9e355e2f8571daed04bd7e14860927381f5e9ba5faa3419c6514e70371f54b19ab97929877da83f5fde08b357f6aa274d88b8328aa971cc885dc8737f718 +3f0e01f0c09db4f72fe442ee2872b152be934fe5aa14f67da7b8c5161599102a67209ee91330c908720c26054a32d50b820c655ce847429fd565990cd3549fa4 +098b53256d93e9f6995041c811099941ca353789d28c4bdd553ea494e6035447f13ba1dbeb9aa63e53f4a328088241a7df77bdb26d59cdc37dcfaf562d4f7f47 +f6baad95ad9533b3676eaddd59df5b3b357db6e23708c2613ab04c2b4de3726dbcdf6bf97e95a771c9abc4492a15d1df36d72d454937cb3821c431ad41d86f77 +0fe7a6cf2649348a7d01f7e6a4bd7f2117722117722117722117724797cb3045412a763b7125e48cb16637de69f5af9d9f7ee6538fbcfae64a9c449fb97a8a12 +fce22b8b9665fcd59f7f427f6628f9f6eae6e1efbfb0383bee8d959ccd837e2b4ce61ad8a2e8c2e519fd69e05bdfbfe37bf657ffd2d5b5ede61fbe786ba2561a +2fd97fede71fdfdadc5fbcbbf9c4b971fd51a11bc6900bb90f6fee87fb090880d13a69ef5fc885dc51e406117ff4f4a4525865e8d2d5b96ac57fe907b74492ad +2c37f5bb4c614431360d5af3edb18ab3bad35ddc3cb48dfc3f819f9baa79065b5f6f263cbbb9d9754d325ef6ca9ef9787972f3a0fdda62c762863e1dfcca171e +bb7466f2c5576e4751b2b67258bc790955a3f89dc079aacf3d7bdd4eb5564b33512ed7a228e45c34c6260641d0ed75a6274f51c35cde5ab61df7ccec99eb8b6f +9acc3a73ead220e896dd1acf4709849d7ebbe6d728218259bd20c098398ea3bf1141d8c5187191797e0db5b64cd3ec06ddb124d646b12fe0de9cb4f72fe4422e +e4422ee4422ee442eee8729990288ef85e77203273cc310ebbd1ca76e7894bb3d3131534bcfc6dbce628896eafee372afe33d74e73a91cc758db6a6dec761c26 +4d290ebb412b4ac73c935aac547631c6dd2046944c8c97b69a9d8d9d1e95c852d9d34f9f5ddf38dc6bf62e9f9bd41db60631e442eec39b7b8c1f870078e0e667 +eb27eafd0bb9903b8adc89b192415994f27e2c0641c2188d622e259a6a94086184a024cd7457aec92cc6c61b25afe24461128669a3e239361342a55cf8cd8019 +a49764062336458d4ad9f29c244a7b3dcc79d61944dd38119ccf8cd7503e841467d948fe1e298585524192f0b60e8cabb627a4723d73ff60cf306cdf2ff7065d +c7f22f9cbe7c777d716a7cfefcc2d53b2bef4c8ecffb5ead1fb415228c1959c6114641d0d75b20855cd7d75de17cb2576c9b6e1c876992306a12dd26ea0fa2c8 +71cba3d817706fe0ef02e4422ee4422ee4422ee442ee83ca65e315a7e25a8e21fda973f6b52f8f2fff80a21f8483e4c68d0dcfa2e698b7bcd99358624a62c117 +97f794c8183393417a79cead5f78c23efbc9f937be55dfbb3b355e760cb6bdd92284fce59f7d2c4bc58d1b5bfd6e7469daae9c7fdc3bfbccd2d2b79394134697 +b63a4862c885dc873af7c3fd0404c0682d2ded9da8f72fe442ee28729f71aef7dabdd7afafbf7d77a75e357992dd5c3f342cf3f92f3e6e19d8b0ade595833ffd +57373e7175f6d2fc5cb9569d9d1b7bf9a51b8b4bbb57aece8fd59c3443519c8561dc0d82b71657cf9f9ebc7ceeb45f2e9f3933f6eaab8bb76e6e8924d9dd39bc +b3de44887ce98bd71c9b514a77f77ba3f89d601a344a38462a8c82c160a01449d3d4346d84916d5b5212c3b4f57adfaf4c8dcdec3537cfcc5f2a976a5b7b6b17 +cf5e6bf70e3ca7d40f3965acd56dcd4d9d938a244914467dd37409612215dd4ea7e4f8a6613362a659e839ae7e9631b8a6e42304fe2e402ee4422ee4422ee442 +2ee43ea8dcfcc4dd5058ff2f314dec564cdb711d53211426a9ee97e5f3cac6faa1818992340c228994c14426956353e6fac8ae198e3eff374ccd206118ea0e27 +c6c6429a743ab194c8716dcb7691530dc2484a89114d937c8c06a536e442eec39b7b8c1f870078e04edafb1772217714b9adc33e56c2ac4c944f570f83244c0f +cbae691946b71352866c238952553d75d9f41d2154bb351804b13e2d9b9b1e8bc3f8402929551ca59c67983ae5d9cb56d5d07b31e806b7ee7021d1ecdcd86118 +887658722cbd53bacfd830285383488ee277826198125185944b0d8c90542a93224a127d926aea6f2b97a572ddb2dccdadb572a5c1a57867f1cdd3731736b697 +e238746c3f88067a772cd3944404496051d7734a0a6366d883414f486e9b36a654af312d2b1311c258af0ce2fe28f605dc9b93f6fe855cc8855cc8855cc8855c +c81d5d2e4be24c6bd43d43b4b2577ff3fc5cfdf47ff3d92c93fa94fe95176f1d06f1977ee651c7d4e7f72c0ce3377fbc34365eb9fad8a92c158671e5eeeac1d6 +ebbf5551c2ad78cea59f65b5d9f87bff5cf6bb6f5e8ffd8af3eca72e65923376617db3b7fae3ff2511d9a79fb9502ed9baf3284e5f7b7d197221f7e1cd45e8bf +fd703f040130424974b2debf900bb9a3c8dd20f2ec4cc599bd343e77e6d677ff45dcda7ee29169d7c007fb6d8aa841b21eadd59efaba8dd608babbba79b0bdd9 +feec672f3ef6f8a99befac1d347b8cb124e5499228bb56bdfa5557ed327c6373b7b5bcd6fcd4338f3cf5e4d9fff1b7bf7373e9e0d317a65cdb681e7498d2a782 +a84f4ba3f89d8031ee0f7a611c33664829f45782519c843ce3bd415f0a492865c4a8d5a7bbbdb66b956ddb6df70e7dbfbadfda9ea8cf4649e83a7e18f54c537f +577bb5a90921b2200ad324d2ebfb4153efec60d09f186f30cae4f0566494d111cd9f00ee0dfc5d805cc8855cc8855cc8855cc87d50b90c618509b26d5b29a4a2 +00218f11aa30d2a7c502337deea5035ccb24795137cb846e840dc3500ab3bc5da6e2803a26b199699ad4302ccb92d28a33950fa73528e2c8d067e72a454998e5 +1b32dbb5d234cb6f0c01b990fb30e71ecb0721004624e3f244bd7f2117724791eb8e95760efb1c6d58aa5333a5a838babf18d15e90e4539c2a9990b6a3dee6b4 +b78743cfb32f5d994bb9d8da6865227fbedb0b32897cdf498922fb6f0912eee2c8b0ccab57e6a5946beb4d97b1c9bacf858c12d9ef7342254138462319f7ca28 +b54c4328a990fec6304a2841543fd43b2da5e232ed0e7a8e657bee9861d8fd41e7f4ccb9ad9d35bfdc6877771b9509cbb0e3a42f8460d4269876fa6d8a693ea5 +0026691a27494888ac946a0811a4f40f824a2944264a2598eff52304fe2e402ee4422ee4422ee4422ee43eb05c2994675ba7162607dd6477afb5bdd9d61f03aa +356f72ac2279aa3f0cec6cb528d3fd92fe20b9bebadf89f9f46479f7a0d769f729c584d17aa35476adacf9126a92b3d766319ed1af204db2cdd5bdde203e6876 +8966b0b7eeee36264a41df4b53c13309b990fb50e78eeed30e001fbeebeb0727eafd0bb9903b8a5cdb31dfb9b9e9181d1bf3866520ab9c1715a55cdf6a12846d +c720aaefa89d98e0c5583df9d8c2a397e66fddd9ded9e919a67e17cadd830e42e4dcfc5812a7cdfd1fa5882ca5f2d2f9d9279e38bd74776f6bfbd0338cc9aacb +285228dbd8dac714d9a645f1487e270cc20863924f98300874de70646a5e884598e8f3cd4ca97ed8ef053dab37989e3e8731eaf57b7e692c8a038259abbb3f3d +b1b0db0c7cafd41f74cb7e4df76058f98db6843e5d1569b954eb74f79049789a5a96dfeeed19f989a90de35e3f52e0ef02e4422ee4422ee4422ee442ee83cacd +4b4832bfe96c7e7d19224a489424c24d843ef5cf94d42bf369c6f43304e9cf0f8e6d3082799ae97f71224c93e55beb0d9992897ebdef9eaec5893e9de65c8a84 +e7cd2c8b102c7cc7d41f10841029d7a7de127221f7a1ce1dd5671d008ec3497bff422ee48e22378ed289861fa73289f51f09c9b9e80d12d3a09fb830c3b3ff5f +7b77f663cb751ff6be865555bbf6bc7b387de681e4393c1cc4c1a41449146dd1d1b569458883e4c1c08d85e05ec08ffe539c876be03e5d04480c0430203d04b1 +a3384e105a03258ba229511c0e79e6d37d7a1ef658bbe6babfaea5de68917480c86a1fecbdbf3f081b55abd6fa7dd696aa5a7d7e58bdaa78fff656c5756aaeaa +b8de72d590ce77ef6d1fecf77ba3d0b41c99a669da329df5dd7e5114a9e978ae73aaeea669f6e07e7777af1f8ce240be4f92ef8c12dbb65fb87e462ebd7f7bc7 +55f649fc4cd8ed76abbe5ff5ab86ccca308271601e2e594d2cdbc98bb8e1d6f3bc48b374100cdcbd0dd7adba4e25c9f324eb56bcda7e6fefecca65dfab0f823d +47394ac977a904e3a16158d2cdb6cc51b05ffed79e749a6746d1e1f7751c2f4b932c1b9fc477217eb598b7e71717171717171717f7e45c15a79957c8afc696ad +0af9905fef3f5a3bb8326e0541180cc68569aeaded562aeec50b9d5ad5fdc6ab4f0d82f1ad3bbb3bdde1dd9d836be71616ebbef08ee5ac6dee079178459aa677 +1ff4b23c6d56fd9d7e707b7defd2a9cef9c5faef7ce9aafc53c4cc8dadcd6e18a5b8b853ed1a043143316fcf2f2eee49b8cab6cf9eeeac6ef40fba83dcb233c3 +7cb0d5af57bc27be7efaa0177eeb7fbebfd2aa5f5cf2eb0dffd2b9855110eceef7770efac3519858d534b3ad24cfad7cdc8f6d535946ea57bc0be7dbc128dedb +3be81e04d22f4a0bf97df0c14ecf71d4bf7aec4519f8ed376e74eaee49fc4c905f2b0fc528caf3ccf7aa9651d8963d8c874a19e1785c1456911b8ef22c33dcd9 +df50aa72eecc13bbfb1bb9fcee6a9a511a7507fb2b8b67c7e3aee739ddc1815759f02b8d248dc3706898799ac6cd7a477e1f8dc240fedb741d37cb52d7f5fbc3 +e1497c17e2578b797b7e71717171717171714fce55a7ca2ad2d64e7f1cc4c1f8b0e0dbac2965aaa230eb32deb1c6e3445a93242b8ac2b0f23431f222b56cc377 +94b48de36cd08fd3d4880fffae2e8fe23c8ef37114ca71cd935fd14ddf7364e0384e86e1e17e679236298cc2327071a7da7d84ff1c22885f7bccdbf38b8b7b12 +eef6dafe4e77f4f88585e73f77f9fd9b1b51943cfff88ab2ccbffbd93d4b39afbf72cd73ec76cddfd91f7cf79dbb8b8d5abb5ad9e9068320e9345cc74c2e5eea +c83cdffe70d5f7bc2f3e77e9a0177cefed3bcd5aa5d3f4b77ac3ee28f21dc7b1ada72f9f92df08df79ef817cfede97af4acb49fc4cb04de370bb2b39508eebb9 +6112d9871b5879be5fcf8ba252a9caa7e755e5ba6198fbbddd6e6fb7566d0dc783c3b1b6daefedb4ea4b8ee38fc27ed5f3f3acb0cc621c0ce41b98a6e538de60 +34f0bd96fc7a9b1b4692259ee11eee3990ec9ec477217eb598b7e71717171717171717f7e45cf5f24b4fac3edcff4f7ffdd38aef464976a65d7beeca19c998c4 +d953cf9e6f379b6ffef883244e571f1c18e57b6fe5d3b2ec8586bfd2aedddfedff7c75d35d53715e5c3bd3a9569c870f0fe234fbe8e1a0ea5a8bcdba4cf7b9d6 +a98dddc1cfeeed9885951faebe35b33cb31d1b1777aadd93fe370f41fc63c6e6fa60ae9e5f5cdc93703ddbbab3d17dfcd2d29573ad1bb7b6b23cbebc723a2bd2 +8feeee77dad5dffed2f52ccb7c4f6df746efdddaba7676216b54b7f686fb41e27baee71a674f3584fece9ba356337ffcc2e2cf82e8e777b62f9e6ae55171d86d +109d59aca95af5fc724359f607f776da8dca6baf3c691527f233a1d9688649d21f0c6dcbb24c6bf7a06bda83388e9ab9390c02d372c3288e53238c22d7f15cb7 +1a844347b9ca7283a86f1ad670d41b85c3767325d91f3baa128e835abde21e166193f178685885f4f1fd769cc486fcba6b1efeef1584417632ef0d237eb5e0ff +1770717171717171717f5daefacf7ff5b3e0fcabad172f1e7cf05f25c9ea5ef0b01be49679aae1e6efdd4ff24226746aa9d9a8fbdf7f6f75b737fac3dffd0dcf +b5efdfdf1e8ce30707a3e55afdc282afbbf955afd9a8dcbcbb7369b9165ffacaad5ced7ff0df8c343132995c314e1257996bdd60eb60b4d2f47171a7da3db97f +ed10f31cfff65f7fe5f8fd5cf72b723fc7697e783f67799119966de8fbf95cabf6bfbe9fdfbabdb55cf327f7f3d24253dfcfe32891fb39f9e5fbf9e90b8b73f5 +fce2e29e847bf96cfbdab9cefdf5fd1fbfbf2a6eab5efbd87be1f0f94dfeebde66f7e6b77e34797e5f7ff98a4ef89b2f3da6ddcdfdd1abca15f79fbf725ddcff +e75b3f94e7f7775fbaacbb7df9f9cb93e7f7aefffce1f39bfcb7fdedfe9d6fbd25ee9b6ffdfa7f6efce625fd7363e517eeb9e6b19f1bb6910dcc05f9b9517555 +ad748d9566b5ee1bc1f9df3fe6ee89fbc442e554c33ad77292bc7fe42e956ef287bfbb54baee60bc52bac685850bfff60f5ff9dffd79f5a87e4ece9b3bf3cf2f +2e2e2e2e2e2e2eeec9b9cab20cab88addcb433d3cc73c3b5adcc8ce24415be652933cf4cc3706ce5d996231733cbb62cdbb65dcf71a2cc4c0abb302ccbb18c34 +cf0ae9e62ac754a69518569ed985a5b2c2c873ebf00fe24cd33a7c8f842d1f792187b8b853ed3eea1a1d319b316fcf112e2e2e2e2e2e2e2e2e2e2e2e2eee6cbb +4a4e1efee4af1ca5ae9eae0b5f51762f886f6d74777b63f98fcc20cef246b3dae9f8e716bde5bab37f30288a4c98b448ad22df1f8c0e86816559d2cdaff9a716 +ab15a51233d9fce9ff906f71f54ccd316b8ee30cc3f8a3077b32ddbc308ba2b06c031777aadd475da3236633e6ed39c2c5c5c5c5c5c5c5c5c5c5c5c5c59d6d57 +99a6d9ac1dd665eb0ddf2a444c5cd75d6ad70debb0109ca6691e4492c2300cafdaca9dbc308ca29049164aa976ab2a98ccb5c8b26c144bb7c35dbb8adc2cf286 +7f5808ae372a8ea1d23873955daf555ca58cc3cdbc2ccf2e7071a7da7d84e539628663de9e235c5c5c5c5c5c5c5c5c5c5c5c5cdcd9760533fee09f7dbe5e395c +131b04f18f7f74ebe24afb1bafbf9064a95f713ffce0e1ddbb5b7918dfb9b5517ff90ffcd6d9877ff3ffe5a36e9415ed4eedfffe832fe7b95171addb77776e7c +b06aa6c99d9b3ba3712cfcbf7cfd9946bde2da6a108cdffadbdba7175bcf5c3f77edea997194c8d537beff6e777f8c8b3bbdee0997e088398daf7df1ea5c3d47 +b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3ed1eae7b2d8a22cd2dc7b0d32c8ab23cced3dc3093284fe3719665ca362d652ac3aa1843cbe8d56acab0fd4a6a542b4a80 +304ae2b8889350f2dab62913b513abc80f77ff97aba995a75911e799e4949ebbfb43e17cdf3c7cab2d2eee34bb8fba4647cc66ccdb73848b8b8b8b8b8b8b8b8b +8b8b8b8b3bdbaeb22cb5bbd5356dc375ec6e3ffcf9bded83203e77767b7b73b0bf1f28c792585a6c366a5e7af013b36b5e7df19c65d8856944e378736de7a037 +dadd1bda92de2a16165b0badca8d9b9b835178b03318f6864a9983612239973b8dc7c364fdc1fec2526d69a59927392eee54bb8fba4647cc666c6d76e7ea39c2 +c5c5c5c5c5c5c5c5c5c5c5c5c59d6d5799661146a9724c4759ae6d9d5bac371b5e1c64519c8d93a46a3bc6e11608456e1a6192e7b9350ee430198ec244224ea5 +9b1cd62a875583a2280e374bb00e6bc6519c648559b32bc29f5d6834ea95bc28c6591a2659348e24112eee54bbffa80539626e62de9e235c5c5c5c5c5c5c5c5c +5c5c5c5cdcd9765592a56b9b7b55d7b97265b956777ff7d56b07ddf0ee839deddef8ced6c1d31716969b7557395e45adaeee8cc3dc75647c7cfffe5e96e58dba +bfd30f6eaeef3e7666e9dc42cdb12dafe2889464f9fa56b7a29c2b8f55aa35f57fbc726d300adffd68e3e6fafee5719c44697f38366d0b17777addff55fd8c20 +7ed5d81f8673f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6abce9f59d8dd1f16b9198ce2c234c6413a8e62d352354f9d69d5d2dcec8ea26cb7df1baa2c2b6ccb +18876992e6c3f870bfcba669fa8e3addacdba6d51b85b9650f82d0ab39171b0bdd83a0308b601c99851158699224629f6e56256d9ee72ba7daaeab7071a7d77d +84e539628663de9e235c5c5c5c5c5c5c5c5c5c5c5c5cdcd976d5f3cf5dfae18f3e8ac7d9eaeabefeb7bfadcc4a45356b9585867febe1fecddd1d994766984f9e +5da8396a7575378cd38fd7bb75df3dbbd8906e9d7ae5fec6c1470fba55cf8de3f45fbcfee2d34facfccdf73e0a8368edc1be7c25d3346cdb96a95f3db770b84c +b730af3e7ea6dda9e2e24eaffb6b2cb711c424e6ed39c2c5c5c5c5c5c5c5c5c5c5c5c5c59d6d57edee0d77ba912d299e58314dd3b6cde128bcb3badb69d61a55 +f7f1cbcb8f3d7e667fbfd7eb8ecf9febd4ea953c2de228e98e0fd7fd6df7a246d5596c56ae5c5abe70e574b73bd8ef06f138ded8ecedf6c32c4eae5f3dad9465 +9bd6384cea0bbe679b7bdd68bf373e753048f31c17777addcf2c9c11c43f30ae5e393557cf112e2e2e2e2e2e2e2e2e2e2e2e2eee6cbbaa7f30babd7e5071acdf +ffc64bca317cbf72ebf6e67ffeef3ffdfcf357ce9f39dd5a6a9f3bbff0e60f3ebcf5f1c327af9d5b58acc7491686f1fec1e06030ba71f7c1d397ce3c77fd74bd +d5bc7c65e5c73ffcf8c68d076992ecedf7ee6eee19992139fdaa632bb5b57950f1bcfe417f7de7f6cd7b6be757aa566ee0e24eaf7bd23538623ee3c5cf3d3e57 +cf112e2e2e2e2e2e2e2e2e2e2e2e2eee6cbbea837b9b2b1ddf75ecadcd7ddb519e3dea8fadd32ffc96bf94a779b2bebefbf0e18ee3d84f3e7571381807e3b828 +8a509030b11d7fe59957fd869165c9f67657869b66f1d433976fdeddec6f844bcd8a6d597b5b5d5b52db5637c8f2a45f754c7ff9ca9917ae3decad6e757171a7 +d87dd4353a6236636d7d67ae9e235c5c5c5c5c5c5c5c5c5c5c5c5cdcd976d5bb37d75fbe7abeeaa97e7f6859966714a1bdd07aea958a71df353f5addeaafaded +befa5bcf5ebe7ceac3f7ef0df7234719519c27499a57aab56baffac69667bcb7b937b8736ff34b5f7efa99672e7eefa7f7debbb9fe95a7cfd67cf7603054b6ed +9ae6c8aa073bbdfaf946e5d493adb3576efff5bf1befe3e24eb1fba86b74c46cc6def67c3d47b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3edaa0b8bad344ba2d838e8 +056258a611163b35e3cdd80c56cd41ab5d3f7db69524c9bd7b5b69565896d1ed86796eb43b7e5214e3f51fe676f4c01854aad5cf7ffe7a9ee7b76e6db62aeab1 +954696655194f4fa63496918456624ed4efde1c628313fac990fce54b3c4c4c59d62f751d7e888d98ce69c3d47b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3edaa53cd +ba611745966faef72cdbf03cd79431c5566ca80751f2dc73adebd72f7efcf1daeece81ebd832607f6f5898c6a54bcb92a2d8ba91daea41905cbb56bbfed4f9db +371fee6df7aaca5a69d71ddb288a627da3a72ca3e2ba86119c5a387b6ba3ef7903c7c89a6e6e3bb8b853ec3eea1a1d319be12a67ae9e235c5c5c5c5c5c5c5c5c +5c5c5c5cdcd976d5384977f603df737ff3f34f8451f2a39fdead55dda5aaefd7bccea21d86e9eddb1bdb9bbd208c0ac34d0dd3b02ca3c81f6e1ee4b961989e0c +6cb79b4596deb9b3b9b9dd1b8d02e91927d9e6fed876d56f7de18924ce24a774bb10a767cfb6c7612a3dac3c19a7b8b853ec3eea1a1d319b11cfd973848b8b8b +8b8b8b8b8b8b8b8b8b8b3bdbaeca8c62ab3baa550fe1835e78777bb8d2aa341cbb6e79cb0b8d208cbb07c3fe602c4313cbcc72c34a93a2c8cc38316d65e559b5 +ea2d2e36c271daeb0e0683603888e234cb4d637b30b4957bf67467300aef6ff53b75d72cf28585eae6663f944998262eee54bb8fba4647cc66ccdb73848b8b8b +8b8b8b8b8b8b8b8b8b8b3bdbae4a8bfccbcf5cb02ceb073fbae979cefff9f5179465341bfeddd5ddbff8fe47e7961b4b0d7f6d67b01f44e7172dcfb6ae3d7536 +378abffadec7cd5ae59fbdf6ecbd873bdff9fec74b6dff6ca7bab63dda1f2475dfa878cecb4f9ef76cf5c31fdfac54dc3ff8fa8bb66ddff8f8e1c6fee0f9ab67 +5efec2b59ffcf4fe381ee1e24eaffba86b74c46cc68d7b3b73f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6abb2245f6ad70effcd7f776bb155fffcf39792bcf0 +abf6bd357375b3eb2bc32d92bdde683f8c966aaeeda966ebb0733f880c652c2fd5d7760ea49b65e60d55747bc1d660e49875c7564badaaadac8f6f6fb75a9ee4 +4c8bfccdbf1ddddbe8bd70fddcd9532dc9808b3bd5ee3f6e458e9897d83f98afe7081717171717171717171717171777b65d757aa9767b6ddfb04c4bd9719adc +bcb35564b9526a3c8aaf9fab2d5e7ba1f2d8172efcf4af16b76f9f5d6a573cfbe1ea816517fff26bcfa671f6c1070f07bdb1746b3ff64ce5c957cfbcf73f9aab +1f763a6da762de5def4acedc3693b4f8e8d6864c6be9eaf3b6f1d66810caa88667bbb8b8d3ecbef499953382f887c5bc3d47b8b8b8b8b8b8b8b8b8b8b8b8b8b8 +b3ed4a362b4932b12dcbca0d158cc659917b8e9be779d57755b55ef81d5591e4caa9388e32c7e391f43cb5580feca4db0df2dcf0a5ddab19958eed553d4729c7 +74959324c3c2b06ccb4a7343729aa6e9d43c496858451085a6b29591e1e24eaf7b72d537629ec3a9ccd773848b8b8b8b8b8b8b8b8b8b8b8b8b3bdbae244d7ee7 +9f3eebbb8e78e371f4eedb7797579a4f3f7b21890bd7b16fdfdf5dfbc97fe8e459dcaa559efc1dbb7536fcc17fc806dd9fbdb7566ff95ffae2b52c2b94babeb6 +b67fe727ffbe63e4f162731c25699afef66f3dddf27da3ccf9f39fdd6db56a4fb582f3ffe22b59922ad7fce19b1ff77171a7d93de91a1c319f316fcf112e2e2e +2e2e2e2e2e2e2e2e2e2eee6cbb4afeb52fc0e1ceaf4a994996e659911b8ee31445aa9465e5493e1edab58a672acf732c4fb9aeca333b4c4dcbb2a49b59648e6d +d946568423cb777dcf0de3302f8c8a5bf17d196416799a94498b2cb24da3b02ca59cdcb07071a7da7d84e539628663de9e235c5c5c5c5c5c5c5c5c5c5c5c5cdc +d97695699a9beb07d2cb71acfe20fcf9ddad6e989c59696eeef4bb0703db366d477516eacd9a9beefcd0dc361e7bf1ac599c2d8a228aa2f57bdbbdc1787b77a0 +eca2709c4ebbd1ec54925bdbfde1787b63efc0b55ddbea8dc2f7efef2c0f82681cafdedf6e2fd657965a4992e0e24eb57bd23538623ee3e1c3bdb97a8e707171 +717171717171717171717167db55b6694669e69966961932b2ea7bca32933895ff8451e6ba8715dac3dd2d2d2b8fa33c378cdc34cc228c9228cae32c8f92348a +92c255569e1856a12cfbb0b359247961e7796a1de6ac788ea7ec24cda328abc66914c6d2888b3bd5eea3aed111b319f3f61ce1e2e2e2e2e2e2e2e2e2e2e2e2e2 +ceb6abd23c5f7fb8e7badec50bcd5ad5fdc6abd707c1f8d6ddedad6e707ffbe089f30bcb35df369563dbab5bbbe3f0f04fadd3247fb0b697e459d3afed0c8677 +36f62f9dea9c6ac93c4d5526cd52636d7dcf77d4c58b0b92f3f75e7d721c241fdcd9babdbe77396c07a328188c65d2b8b8d3eb3ec2f21c31c3b13f0ce7ea39c2 +c5c5c5c5c5c5c5c5c5c5c5c5c59d6d57359ad5f138b2b334cb8ac3700e175e49486fe99467469416fdd12895cc999c657192a5691ec4719e1b9997d8455e7195 +f44fb3621424861528c76a76aad13896a9482a316ddbc8b2cc2c8aba7fb855425198f5baafb7b0c5c59d52f7a46b70c47cc6bc3d47b8b8b8b8b8b8b8b8b8b8b8 +b8b8b8b3edaa7ff2f2d537fff64616a577efeccabffc0bd3b04dd375ec4ebdb2d4f2ef6df46eaeed551c9519c5e3a73b35473d78b01b25e9876bbdaa6b2d376b +cd9afb5c73656de7e02737bb9e729224f9fa6f7feefa95951ffce82399fafdbb7bbaa060d9c5689c3c7b6945be58911ad79f39df6ed57171a7d73de1121c31a7 +316fcf112e2e2e2e2e2e2e2e2e2e2e2e2eee6cbb6a381a8fc324cf8dd38b0dcb5296654471bad71b555de529b5bcd8a8b5fc71100541bcd8aaf9159565459c64 +f5dd9172ac7e943acaaad8c662abe9d5fc681cf7fb6692a4dde1b8174659929c5dee18966919669aa6a72cdbb1d5384e0661361c454ad9b8b8d3eb1a04710271 +6aa93157cf112e2e2e2e2e2e2e2e2e2e2e2e2eee6cbb6a67bbffe1833dc7735fffda739e633a15efcedd9dfffee71ffcc633e7ae5f38dfecb4cf9d5ffae19b1f +dcbcbdf9f43317963a7e9c1ae3300d82b0371abd7bf3ded54b2b4f3d7ea9de6c5eb9b2f4d65b376f7cf8308ba2cd8dbd8f1fec1a86f53b5f7b5ea665dbf6e676 +df779dfe41ffedf71efcfcd6c642db4da21417777add475da3236633befc85ab73f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6abd6b6f69a55d7739c5e37b095 +5171a2715cb42f3ee5d6fd2c2b0ef687c3516859d6f9334b6110ee14459e17e1384e92d4b4fde6b9a7bcb693e7f9b037baf17192e5864c682f18650741c3f70c +c3909ca1e3d8aa188ef3f160601699db3ad5bcd4de1b45418c8b3bc5ee232ccf11331cfb7bf3f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6ab7ef8eeea0b4f9c +a93ae6cef6816dd88e95f6ed4ee7a5dfaf18f72de3d6bdb59df5b583575e79f273cf5dfcf0fdfb3bbb7da5541427511415954efb996f548b4d657eb0b6b97fe7 +feee3ff9fc132fbdf8d8fffb1fdff8f0f6ce17af9dae569cdd9dae2a4cdb32067663bcb7ffd8d9967feefaf2f92b37fee6cfc2fd755cdce9754fba0647cc67ac +aecdd773848b8b8b8b8b8b8b8b8b8b8b8b8b3bdbae3ad5f2d3340d0dbb3f8a4c89228fac03bff87962f7b7cca056ab5c7ffa7c9c640f57f7d3ecf07aaf3f4a73 +a35ef763abb0b6dfcdac60d31c3b9efbccd317f23cbfff60b7aad4ca423dc9f271940f068965e7966186465eaf391b7b83c458f58a6ec7cd335cdc69761f758d +8e98cda8ced973848b8b8b8b8b8b8b8b8b8b8b8b8b3bdbae3ad56e2a5baee60f1eeeca242abe631503bfd8082df36658bcf8b9cbcf5ebf70e3e3f58d8dbee31a +86916fee740dc37afcc25214c6bbdb7f171bd6ed38bf7ef5dc0b2f5cba7d6bebe1fa5ecd7156da55651b8591ae3edc366da3e27ab6692c3d7efafd0fd77ca75b +319345cf313c5cdc297609e224a2e2bb73f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6abc224ed0f23d7b17fe3dad9242ddebfbd55719d9aab6442cb55231cc7 +77ef6d1fecf77ba3d0b49c34374cd32e72737db75f14456a3a9eeb9caabb699a3db8dfddddeb07a33888932cc97746896ddb2f5c3f2397debfbde32afbcc383e +b5580fe33c0acdccc89324c3c59d5ef71f56612388cf8e70ce9e235c5c5c5c5c5c5c5c5c5c5c5c5cdcd9765566980fb6faf58af7c4d74f1ff4c26ffdcff7575a +f58b4b7ebde15f3ab7300a82ddfdfece417f380a13ab9a66b695e4b9958ffbb16d2acb48fd8a77e17c5b52efed1d740f02e917a5854ce4c14ecf71d4bf7aec45 +19f8ed376e74eaee734f9e397bbab3bad13fe80e72cbc6c59d6af751d7e888d90c65db73f51ce1e2e2e2e2e2e2e2e2e2e2e2e2e2ceb6abf2ac78fef11565997f +f7b37b96725e7fe59ae7d8ed9abfb33ff8ee3b77171bb576b5b2d30d0641d269b88e995cbcd4310ce3ed0f577dcffbe273970e7ac1f7debed3ac553a4d7fab37 +ec8e22df711cdb7afaf22965d9efbcf7403e7fefcb57a5e5cedafe4e77f4f88585e73f77f9fd9b1b5194e0e24eaffb08cb73c40cc7bc3d47b8b8b8b8b8b8b8b8 +b8b8b8b8b8b8b3edaa2c8f2faf9cce8af4a3bbfb9d76f5b7bf743dcb32df53dbbdd17bb7b6ae9d5dc81ad5adbde17e90f89eebb9c6d953876f78ffce9ba35633 +7ffcc2e2cf82e8e777b62f9e6ae55171d86d109d59aca95af5fc7243b27f706fa7dda8bcf6ca935661fcc7bf78fbce46f7f14b4b57ceb56edcdac2c59d6a9720 +4e221e6e77e7ea39c2c5c5c5c5c5c5c5c5c5c5c5c5c59d6d57058fbdba79e182e3382b4f184110fcc56efc8b1ac0d2d9cffdf397e2384edaed277d5f1ad23495 +0edf8f0b8927bf7e5d5abebd6178cb977ff3dfbca6475c354de9b0b5b565763add765b5a162f65d2f25f760e5f0a7fe9f79ebb581423c3f8eba1b17376215c08 +7171a7d7fda241cc72fcc99ffc89dc18fa786363230cc30be57d25a7720fc88d34e99924899cb6db6dffd87d5594619abf78299b57863e368feeab4ea7d32eef +2bf9b12e2d79aeefe7ff6bae9e235c5c5c5c5c5c5c5c5c5c5c5c5cdcd97655a3d108cb304d53fef12fe39324d107baf430180c46a3913e9676b92a98e7799675 +f867d75114694086ebe242abd592e3e17028c73a499665326a6f6f4f5a64947c1fe9299fb8b8d3eb1ac44cc7bcddcfb8b8b8b8b8b8b8b8b8b8b8b8b8b8b827e1 +2ab920b69cdbb62dd7e4733c1e4b2eb1f5b4b4374934e92661fc7248bb524a06ca101938e923a7322db97ae895a1978fe1e24eaf6b10331df2c374aeee675c5c +5c5c5c5c5c5c5c5c5c5c5c5cdc937055ad561b8d4672b9d16894d5d8a2dfefcb544e9f3e1d8661afd773ca288efe7ed6f3bc4aa5627c2af4d4759f288a64a2d2 +4d7f072125d5d9b367273d8db2f48b8b3bbdeea78710b314cbcbcbfa604eee675c5c5c5c5c5c5c5c5c5c5c5c5c5cdc93705596653a7510047a1ed2cfb22ce9a4 +ffb05a57856ddb969e717cb8ab815cd5438effe5b58caad56a7270b81542d9ae13ea16c1f40e89ba009c95818b3bbdeea79e3262a662deee675c5c5c5c5c5c5c +5c5c5c5c5c5c5cdc9370952eee4a22bd13810ec9d2eff78bb25e2b8064af542a72a04bbfba882b43641ec651655786481f39d68d12611866e5aa5d09d775f7f7 +f7e5a05aadb6dbeda80c5cdce9750d62a663deee675c5c5c5c5c5c5c5c5c5c5c5c5c5cdc9370951e203ddc32945282a5e5769632a65eafeb74d2a8abb67249a6 +d568341cc791896a435ae4aa64d7d974a3749084d2278ee3c1602043e4404f6232515cdc29750d62a663deee675c5c5c5c5c5c5c5c5c5c5c5c5c5cdc9370555e +6e192b866ddbd22479c3309444ba51bfa24b1b324c4f42cf69b265acf4940e3a7596657aac516e526b95a17bea95b772492fd0d5818b3ba5ae41cc74ccdbfd8c +8b8b8b8b8b8b8b8b8b8b8b8b8b8b7b12aed24b6d65b0aefb264922d724b52ed90e0603b35c3a2b1da4b15aadca18a35c373b3c5a8b2b576566325cb7efeeeee6 +e5e608ad564b520541a0874b4219ae0bc07b7b7bfd7e1f17777a5d8398e998b7fb191717171717171717171717171717f7245ca5c7186511372fd7c0eaa4ba45 +d780f5845419fa384d53bd4057f79403bd858134ca547463516e3aab8f75e872afee8f8b3bed2e31c3213f64e7ed7ec6c5c5c5c5c5c5c5c5c5c5c5c5c5c5fdb5 +bbaadd6eebf3300c279328ca30ca02c4a4313f5a40ab071f37e2f21d617af6f57a5dcf43c64edaa5458e8320d0971cc7c1c59d6ad720663a8232e6e77ec6c5c5 +c5c5c5c5c5c5c5c5c5c5c5c53d0957f9be1f97455cbd38f678e8d2afa44bd3543eb32ceb76bb7abcde8f56a668dbb67ceafe954a456f76a0abbfb55a6db2f181 +8ceaf57abaae2cfd953a5c6f8b8b3bbdae41cc744cb6659993fb191717171717171717171717171717f7245ce5799e8c979162e8f1c5b155b83a9db4cb303182 +20d01de434cf73abdc595626aa87482a3995ce7a8dae53becfcb38aa16cb55b9249dc5d67d7071a7d73588998e79bb9f7171717171717171717171717171714f +c255322c2fb780d56fec9288a2486f52a0438e8bf28d5dd6d1ebbd243a9d8ea430cbed0cf4fbbf64a27a87c4c9be06d2ae97e64a9f388ec58bcb9046192b3d71 +71a7d73588598fb9ba9f7171717171717171717171717171714fc255c9d176b33aaf1c0b9f95a1d7cd9a47fbceea03b3ac01dbe51fe40a9c1d859e8759ee74a0 +8f7595d7283744d07d642aba362c9f920117777a5d8398e998b7fb191717171717171717171717171717f7245c6594cbbbf272bfd8e2d8cbbca4b15aad2e2f2f +ebf6d168941fed292b7dc2302cca6d682703756557cf26fbac858171b97b824c4e2feed55f0617774a5d62b663deee675c5c5c5c5c5c5c5c5c5c5c5c5c5cdc93 +7095aeda1665e8debfb870b4ddac536e1c2be3e5783018b8ae5babd5f446b393ce7a66d22243f4401975bcc3f1cc3203eb287071a7d425663be6ed7ec6c5c5c5 +c5c5c5c5c5c5c5c5c5c5c53d09f7703b581996e7791886e6d1dbdbe540176bc7e3b151bed84bef56301a8de4d8f77d399629ead4e6d14eb4d22279ec725b599d +53f7318f16dc9ae53e08127275d20717771a5d8398f598abfb191717171717171717171717171717f7245ca52bb8ba5529e5966fe0d26195afeb920e7b7b7b72 +2c0344d2d392031955ad56a328dadddd954639d692f4d71b22e8543221ab5c70bbbebe3e39d6dd7071a7d725663b922499abfb19171717171717171717171717 +1717f7245c2523f56a58ab5c165ba9543450942bfb742558bf966b52f44d92448eed32b272275a55467eb489acfe9c9c5ae5da5de9a997e9cab15e9a8b8b3bbd +ae41cc74ccdbfd8c8b8b8b8b8b8b8b8b8b8b8b8b8b8b7b12ee6152192652afd7937e4110e8cb7aa9ad5c2d8e369a958c0b0b0b02e882ae742eca68b7dbd56a55 +f8d1682479e4404f484ea332acb2962cdd1a8d86641e8fc732d62edf08868b3ba52e31db316ff7332e2e2e2e2e2e2e2e2e2e2e2e2e2eee49b84ac366b9b6563e +f3a3977619659956247514ba242c1dac729dad2edf9ae5a60692484ee3f2bd6076b9af815cf27d5f724ef24f4665477bd9e2e24eaf6b10331df3763fe3e2e2e2 +e2e2e2e2e2e2e2e2e2e2e29e84ab743ac771ce9e3d9ba6a9aeefca854aa522630e0e0eeaf5ba1cd76a35b32cd94a16e92c97f4aa5a1d726a1eed2f2b6335dc6a +b5a4e77038d43d65ac4e2e21b65cc2c59d5e9798ed08cad0c7f3703fe3e2e2e2e2e2e2e2e2e2e2e2e2e2e29e84ab6498a4d0455955ee6b108661144566b9a381 +5e282b2d45b94381e4d249a59b749e1856b963821e22d3926cd56a55b7f8be2fa34492594e3a4b7e5cdca9760d62a663deee675c5c5c5c5c5c5c5c5c5c5c5c5c +5cdc93700f6baf8ee31465e8b2ae00699a1a470b6e8df2b5339392b051aeb99589ea177819473bc8ea9049244952944b70b332ac32e4b4dd6e4fbaedeeeee2e2 +4eb56b10331df3763fe3e2e2e2e2e2e2e2e2e2e2e2e2e2e29e84ab5aad565eee2f2ba96ddbd64b6d3dcfd3c55ac12629342959645ad2332ff735c8cbed0c7407 +5d066e341a45b921825e70ab53c9e7dede9e9eae4c4286e3e24eb56b10331df3763fe3e2e2e2e2e2e2e2e2e2e2e2e2e2e29e847bb859ace4d2bd75220949a187 +c93c2ccb9a9cda47a167a979ebe8b5ef922a2f43cfc62a17dc1a6501585a249551be294c6caf0c5cdce9750d62a663deee675c5c5c5c5c5c5c5c5c5c5c5c5c5c +dc937055b7db3d7dfa74a552910ba28ec7632d154765dd5aad56afd7e5204d53b9ea384ea7d331cbda93f4915c93c5ba3ac3eaeaaa643b73e68c4e321a8db272 +f7d9e5e565e3280e0e0e7071a7da25663be6ed7ec6c5c5c5c5c5c5c5c5c5c5c5c5c5c53d0957e9a2ac9cc80c746956177a75a5d628b72ad09b1ae892b0ee6695 +218d5114694c42a7aa56ab721086a1aeefeae4323f5d5736cb177e49e0e24eb56b10331df3763fe3e2e2e2e2e2e2e2e2e2e2e2e2e2e29e847bb8dfabc0c7dfdb +2ea79375b33a8b843e35cbcd0ec6e3b1e779aeebea46cd18e56e08f6d19bbca2f28d609332b07c31bd9f82556e5b2b9fb8b853ed1ac44cc7bcddcfb8b8b8b8b8 +b8b8b8b8b8b8b8b8b8b827e12adff7750abdbcd6280bba61182e2e2eca0cfafdbeae01eb2c66b9e5c1c2c2c2a4be7b3c26db1fc82c25839e874ed8ed76979797 +b52ad9cc72d92d2eeef4ba0631d3d16c36e7ea7ec6c5c5c5c5c5c5c5c5c5c5c5c5c5c53d0957398e932449966592c83ada05564ea55d4fc52af794d57c9ee772 +ecfbbe592ec19dd4802786591680cda337111565e816bd39829ea84e858b3bbdae41cc74ccdbfd8c8b8b8b8b8b8b8b8b8b8b8b8b8b8b7b12ae1a8d467919fbfb +fb13a052a9f47a3ddd492fb5d5955a69143b2fb73f904b61181e673a9d8e740b82202b37af1d0e87d9d11a5d69dfdeded607d22d8ee3288a7071a7d73588998e +79bb9f7171717171717171717171717171714fc25559598e2dcacd5f8db2465b94a113799ea78bb545591ed69d93241149292557f3631bd0ea4d30758b71b46d +adf42ccae5bbfa525a6e6a3b49858b3bbd2e31db316ff7332e2e2e2e2e2e2e2e2e2e2e2e2e2eeeafddfdc5860572e2baae9c57abd5c160301c0ecd720b834ea7 +a317dc1e1c1cc471ac53c8442b954aad56d3b6f494962008f4bc757fb3dc37c128ff74574e65ecd2d2d268349259caa77114b8b853ea1ac44cc7bcddcfb8b8b8 +b8b8b8b8b8b8b8b8b8b8b8b827e12ab9a61919a6c74b0ff1644051ae9e9d8cf13c4ff2da65c8e964a09ea22665eafbfbfb22c91099ae0cd1eb6f65f659b95782 +8451be020c1777aa5d8398e998b7fb191717171717171717171717171717f7245ca54bb9d249cef5ea59e9aa94d2cb65a58779b441acc08d46c32e5fda351a8d +2697a49bcc4f6f7c60962b6fe338960399a534eaaab0e41f8fc7320f5df4956f828b3bd5ae41cc74ccdbfd8c8b8b8b8b8b8b8b8b8b8b8b8b8b8b7b12ae6ab55a +3a852ee81a479197db13c8242686cc63f22e30998aae04ebab3276b25257be80eea6a73849a879b3dc4341021777aa5d62b6437e16cfd5fd8c8b8b8b8b8b8b8b +8b8b8b8b8b8b8b7b12aeaa56abba943b81f530bdb2cf3cda6e567fc671ac0bc06919ba8f552ebe95d0cb6ef5aaddac7c93972e06eb88ca308f369ad54b797171 +a7d425663bf2f20f0de6e77ec6c5c5c5c5c5c5c5c5c5c5c5c5c5c53d0957d56ab52008e47c6161c13c2ae54e425a24ef783cd6d9bbddaece28b39416999f52ca +755ddd58ad56f571546e9750296392eae0e0c028df1726a29e1c2eeef4bac46c87fedf7a7eee675c5c5c5c5c5c5c5c5c5c5c5c5c5cdc9370d59ffff99f1b7f4f +c8f873e7ce398e23235f7cf1454951948b6f05eef57a7ffaa77fbab5b5d56eb7fff88fff786565250cc377de79476693a6e9c3870f9324f944b6279e78c2280b +c39f79151777badc9ffce42773f57d7171717171717171717171717171717171ff77ddc39d658b63db191c8fa28cc9f16776f8fb5a26b3f9fb329be5aa5d5c5c +5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5cdc99749584e3389f3909dbb63dcfd3f5dd4f77d003e5737249ba656554ab55b994e7791004f2291df466075a95b47a +142e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2eeeacbaeaf2e5cb4f3df594effb9f2ed6cae0498a4aa572bc83b49f3f7f5ebfba4b8ee59224953c79f916b034 +4de5733018fcd99ffdd9dede9e247ff1c517f540cbb2565656a4bf4c081717171717171717171717171717171717171777565de5795eabd5aa56abc667c5a7e1 +09afebbe6eb989ac59be1d4c267abc8384606118da654cda6588a4c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c59d61578dc7e3d168549431e9a10bb44659 +c7fd4c4046c9e46ab55aa552912c92c1286bc6e6d13a5bb37c1198f41158fac8c164d25114e565e0e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ceaaabbefb +ddefaeafaf4f6c0dacaeae4a0f012e5cb8e0baee278ca2ac0a7fe10b5f104380b7de7a4b0ce9bcb2b2e238ce64ae32fb679f7d36cb32e9fcc20b2fbcfffefbd2 +2869df7efbede1702869717171717171717171717171717171717171717167d55583c1a0dbed7ec2d8d9d991c192bdd168c8a5e3a55f7d5cad5605e8743a324b +01248318f57afd1313d24b76bdb2123c192efd05959eb8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3eaaa66b3e9952fed9a5c304db352a9589625c3f23c +d7eb6cdd72ff0239d03d7ddf4f9244e611c7b16ddbd2289fd239cbb2e3139a241c8fc7fa5892c8bc75725c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5cdc5975 +d51ffdd11fddba754b7a4fb624904e67ce9c914f19ffeebbef8e4623215f7ef9e56ab5ea942fedd2c083070fa483746bb7dbcd6653b2efededa5471b227ce2bb +6d6c6cacacac1865c5f79bdffca67c2b198b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3babae5a5e5e5e5b5b931edad09f7aa9adc032268a225deb75cb68 +b55a7a3b0301822090feb66dcbd5b40c69fcb4212149f47793548b8b8b325d69c1c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c59d55571545e1388e576e5e10 +956ff8328f0abd02eb75b392428e25855c92bcbaf42ba79399e9ce954a457dd6fbbf3e11c551e0e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ceaaabf47259 +19361e8fdf78e38dc160707c12a74f9fd6eafefefec1c18159aeceb52c6b32a1496701bef295af341a8de253fb1ae878e79d778e9fe2e2e2e2e2e2e2e2e2e2e2 +e2e2e2e2e2e2e2e2e2ceb0ab6480effbba4cab57d24e4ab672e01ced359b1e6d58201d3e9142ba156591588076bb7ddc98a4fa74e0e2e2e2e2e2e2e2e2e2e2e2 +e2e2e2e2e2e2e2e2ceb0ab822010464ee2a337734d0ce99de7f927eab593abd259679781d22d4992a88c49ff4f0cd7b314ebf83bc57071717171717171717171 +71717171717171717167d255dff9ce7756565624b59cb7dbed46a331c99265d9d6d6960c363e1502e85192f4edb7df1e0e87d56af5dd77df9dacad9524327c73 +737352180e8240b7ebd5b9930cb8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3e7aa6eb75bafd75dd7956b76193a8b749a4ccb288bb59f6004905132b338 +8ea3f29d5fe3f158864f0c19deebf5e2a3377c4da6ae6bc04a295c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5cdc597555b55a95cbba75c2174731f12a958aee +a6432fc7d5c77249d2c9e7f10c7a94249779189f155619b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b833e9aaaf7ded6b376fde0cc35086e97ec52fbfab4b +4ea5fdb5d75e3bbe6e368e631925dd24c54b2fbd9497effcf27d7f322d6d7ff5ab5f95cfe38d135e67c0c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c59d4957 +b55aadc97a5a5deb9d64378f8ab5d2d86c368fbfab4bb2eb51d2a756ab4d66f3892f20a3aad5eaa7afcaa549065c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c +dcd973d5f1526e92246659df4dd3547f4e060741a094d259ccb2be2b9d75872ccba45d1aeda3377c4d6626a38a32e454861f9f415cbe050c1717171717171717 +171717171717171717171777265df5fefbef475164965bc0aeafafeb619309c9a95c0ac3f08d37deb08eed6b501cadbf15607575554899c1850b17f4deb4ba8f +79f4ca307d7af1e245e397031717171717171717171717171717171717171777565d15048159aea1956b7119e6b11aede452bfdf373e1572354992e170289ee3 +383295c9c0c9ec272d4b4b4b9f1e8e8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b3b93aef23c4f9f5be58e06699aca41b55ab56d5b4e2793534a9947db1c7c +229acda6cc4c8c7abd7ebcbefb99df443e3f910a1717171717171717171717171717171717171777f65cf5e28b2feaa3c160f0a31ffd687b7b5bc67cf39bdf5c +5a5a0a82e08d37dee8f7fb02acacac48964f0c9674d2f8faebaf7b9ef7e9497f22de79e71d3dd7a79e7acaf7fd493b2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e +2e2eeeecb94abfe7cb2cf7354892248a223968341a9d4e47c6ebbd0ce4aa1cbbaeabf3ea9166b90457b2cb6c7492e397febe6f2897aa65e8ceb8b8b8b8b8b8b8 +b8b8b8b8b8b8b8b8b8b8b8b8b833e9aad168a45bc7e3b16ddb924b3ee578381c06419097affa92c15996a5e576b3a2eaec7ad9ad441886d62f6f372ba326de27 +a2285f0da607e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ceaaabfef22fff521fc9854ea7d36834c4f8c10f7ea0f735188d4692510eb6b6b6a48f34aeac +acb8ae2bc0db6fbf2d577ddf9774f57a7d3257998a74d6133a1ecbcbcb46b9cbec1b6fbc21339eb4e3e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ce9eabba +ddeee4b25d8651ee71707c5a45f9aa2fa3dc0d61d2228074935c4110e8faaece232dbd5e4ff79f8424d7df4da6dbeff78fbf350c171717171717171717171717 +1717171717171777f65ce594a1a5300c279efef43ceff8ba59ebe89d5fba30acbb6565c841a552910e72b55aadea9c93094dcabd66b9f5acb498e55e09b8b8b8 +b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b833e9aacb972feb177b8dc763fdf62e7d4d3019f3da6baf351a8d092c93f8def7be371c0ed3328cb24ebcb5b5d5ed76 +25c357bffa55dd592ee9217a541cc7376edc488fb64558595991abaeebe2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ceaaab3ccf6bb55ab55acd397a7bd7 +24e454c6b4dbed89311a8db22c93b9ea2c45b97d6c922466592d9639499e49f68911459128d9d11e0a02c9272e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2eee +0cbb87cb6bc5b66d5b464a52bd73415ebe90ab28b73388caf776e901722a3da58f8c145e92cab1e4755d578e053bde7912324aba8dc7634d4a67f3e88d60b8b8 +b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b8b833e92ab9f0e1871f5ae58605ed76bbd96c6659b6b5b525e9f425cff38aa3faaeee23d91dc779fdf5d725af516e34 +2bc3a5f383070fe25fdec2568774be72e5cab7bffd6dc923d95e7ef96599162e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2eee0cbb87eb5ec330d427ba769b1e +ed3b2b97c6e3f1642deea48f84c04b4b4bd56af578e957220802f3682bd94912af8cc16050945b1ec844753b2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2eee +acbaea1329242686512eb2fd740719264c7eb4fef6784f894f1bd22873d5c560995c5ebe11ccf854e0e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2ce8cabd6 +d6d63e93d12b69b7b6b63e7d55c2f7fde3539974eef57a9f30f4d5f5f5f5575f7d554fa5dfef1f1c1c7c665a5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5c5cdc +d970ff7fae2209e6d9bd5ac60000000049454e44ae426082}}}}} + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\rtlch \ltrch\loch +World 2:} +\par \shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbxcolumn\shpbxignore\shpleft0\pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033\rtlch \ltrch\loch +{\*\flymaincnt5\flyanchor0\flycntnt}{\shp{\*\shpinst\shpwr2\shpwrk3\shpbypara\shpbyignore\shptop0\shpbottom2718\shpbxcolumn\shpbxignore\shpleft0\shpright9972{\sp{\sn shapeType}{\sv 75}}{\sp{\sn wzDescription}{\sv }}{\sp{\sn wzName}{\sv }}{\sp{\sn pib}{\sv {\pict\picscalex48\picscaley48\piccropl0\piccropr0\piccropt0\piccropb0\picw1357\pich370\picwgoal20355\pichgoal5550\pngblip +89504e470d0a1a0a0000000d494844520000054d0000017208020000004e676c690001186c49444154789cecfd7b8c64d77de709def72bde199919995599f5e4 +ab285264b14a6c592dcaa41bd34b3721d970db3302768936b0868dfe838056807b81e55ff38781c5ceec6231f2601798996d63b56a78d6d3b6e0696f5b326c17 +5f3665a954545112594f66e5abf29df1bcefc77ecf399557c1cca248169911ac88df87c9a81bf79e737ff79e8838bfefb9e79cdfd1b22c9388d1e2eb5fff3a5e +9324b97dfb761445b22cebba8e577cd6beeff77fe2d8699aa6a228f91e6cd76a354dd390f21ffee11fbaddae65595ffad2978ac5228e621b09e238cecf2c72e1 +9cd8f98ffff88f83bd51822008822008822008623fdab02f80382cd0206f341a68811b8671e6cc19dbb63dcfbb70e142bbdd16ed731c42bbfdb9e79e2b954aa2 +f18ffd68debff6da6b68dec71cec4cd3747d7dbdd96ce20ccf3efbac488c43f9f302e40ac3f0dd77df1de2cd12044110044110044110026ae78f207937bbaeeb +78354db352a9140a05bcedefba97f8b300b4dbabd56adeceeff57a4992a0dd2e5af200ed7cd175af699a655938cfbe312038140401ac0ceafe08822008822008 +8220880f84daf92388e779126f7e1b862186eba31daeaa2a5aef68d8a3b92ef15e7ad18cc74e1ccd9bee788b9448838ca552090d7b6ca36d8f53611b0dfefec4 +39c8254e4b1004411004411004410c176a9b8d20afbffe3a9ae2a6699e3f7f1e4d7434cedf79e71db4f0d1b6af56abe572394992f5f57534cec521a4ccfbf345 +1ab4f0755d7ffef9e7d1b6c77eb4e1911d8917171791eba045243e79f2e4a0ef932008822008822008823800b5f347904ea723a6d0a3d12ef179f8beef8b43a2 +af5e4cbc17873ccf43b3bf3fbbca41e37f7272d2719cfeae7ee0ba6e3e2f203f89c939f41b230882200882200882203e0c6ae78f20a2131e0d6fb4f3f3267d3f +fd3b91665f3b5fe24d7734f5f3b1fdfd29c1c1763e768ac902044110044110044110c470a176fe08f2cc33cf48bc59de6eb7777777ef9a064d7d314a7f7d7dfd +ae096cdbee7f1c90276eb55afbdaf9e2e8eaeaeacb2fbffc29dd01411004411004411004718f503b7f0429954a126fc9a3912fa6d3f72f742f36f2a5f5a2283a +183f1f7b445cbd7d4d7a9c53c4decff7e479832038a4db210882200882200882203e3ad4ce1f41f2a07ab66d8ba5f57cdf4fd354ec1101f9c4fa79d8639ae6be +767b3e5cdf75ddfe28fa782b42f7e10caaaa8a5c2232ffc06f91200882200882200882b83bd4ce1f59d080ffca57be625996e779afbcf24aa7d3c136f694cb65 +6c7fe73bdfd9dedec69ea79e7aca719c3c9708c52fd6db7bf5d557d19ecf0fa1857ff5ea55dff7d1b69f9b9bd3751d471b8d06ada8471004411004411004f1d9 +815a68230b9af7dffbdef7d038176f655946131d7bc4db3a074df442a18016bb611867cf9ecda3eb2371abd5fad6b7be85367fb55a7de9a597d09e47f64b972e +e1b4711cafacace0cc4992acaeae0eed0e098220ee37befef5af4b7c0e94a8457f494ad4cf478f1ebde7fa79dfd97ef4a31f1dde4d1104411004f15983daf923 +0e74a1986fff4147f343774d7370e7bef434689f2008e2dea0fa9920088220884382daf9230b149eaaaa62febcaeeb77157c48609aa6e82f3a98007971a87f06 +3e9289a5f51cc7c1a1344d5dd71533ff452000822008e243a1fa9920088220884385daf9238ba2288d4623cb3288bf3367ced8b67db0f307fa2f97899665f527 +1093f00b8542b158c4360e4129e23c508d121f748ad74ea7f3ed6f7f7b7b7b1b273f7bf6ec006f8e2008e23e86ea6782200882200e156ae78f2c50875090d07f +a669562a95fe607bfd7cd09051d10564702049f116afd08bfd090004a5effb2ae7506e83200862e4a0fa9920088220884385daf9230b0462100429a7d7ebf54f +f594f63a7c24de2f74302f04a2e77910a08542c1b22c28459c41e27d50f918516c84618834109748838dc3bf278220885180ea6782200882200e156ae78f2c10 +79172f5eec76bb8661acaeaef6eb3c88c8a5a5252480889c9f9f47827d79452fd3d34f3f0d1d0911f9c31ffe103a12891b8d86aeebb91e85427decb1c7922441 +e2279f7c7260b7461004715f43f5334110044110870ab5f34716a83d88bf4ea70399d86c36f7e9c8cdcd4d08441c2a954a38d4df9524b61dc78188acd56a50a2 +380fce001d592c16f7894e31dc54f42c0deace088220ee6fa87e2608822008e250a176fec8a2280a34225ea1ff44d0e6fc902ccb96658943699a8a31a2629e27 +36444adbb6a32882d60cc3505555ecc42b12274972d778519ee70df0e6088220ee63a87e2608822008e250a176fec8e238ce8b2fbe0805092178fdfa7528c27c +ea2684e0ecec2c5e71e8f2e5cbbd5e0fb2f2fcf9f362352611fc1922727171110990ac5aad96cb6528c8ededed7ce2683f38f3eddbb75f7ef9e5c1de224110c4 +7d09d5cf04411004411c2ad4ce1f591445a9d7eb908641102c2f2f43050a1d295ec53051884be84224107d47227a73a55211d33e21225dd7cdd7798e39d87957 +7338c920ef8e2008e2fe85ea6782200882200e156ae78f32d91ebaae8b499e22c273de71047129c67c4226621b321187a01d455712dee6ea5324b62cebaef19f +098220888f05d5cf04411004411c1ea409461f31d413d2d0f3bc0b172e743a9dfc1076cecccc0865b9b3b3b3bbbb2b46782a8a928bce3c3144e497bffce552a9 +f4414b3a130441101f0baa9f0982200882380ca89d3ffa4014dab62dba7dc428d0fe3596f3f84ff9c4ce83233c914c743a414456abd57e1d999f8a200882f8b8 +50fd4c10044110c46140edfc11442842c8c73cc632b621f8f2c8ccfd019fd234ddd7ff931f4562a1209111c9a2280a3879fabb66270882203e08aa9f09822008 +821800d4ce1f41565656a4bd18cb509090838d4603f2119aaf5aad964aa5fe299debebeb1088074f92e78270bc78f162b7db751ce7f2e5cbf9b8509c04d9d7d6 +d6f28ea66f7ef39b83ba45822088fb12aa9f09822008821800d4ce1f41f290cba26f47d3b462b1681806b6558e380a21d8bf08d3c16e1f8848e482fac40945cc +67cff3903dd791c8de6ab53e28c233411004b10faa9f09822008821800d4ce1f410a8542ff5b852371e5d73f225420de62bf655922599e2b4f8c43908c78ed3f +83c8e5380eb4e6a1de0e4110c4c840f53341100441100380daf923c80b2fbc906f8b699fd7ae5df37d1fd25068c17db19af116fb9f7beeb9fe319f2217924126 +9e3b774ec47cb66dbbbf5b09b99e7df659bcd214508220888f02d5cf04411004410c006ae78f20d56a35df86f88316ccc7828abea35c41e69d3fd8592e97fb63 +35e7b99026ef803a18110ab91cc739c49b2108821821a87e260e097c2b9224d134ad7fc1c51cf18541827dfbc5888f83f33b3e28bdc4bf90711c2381699a9fca +95130441108701b5f347907d0b2f8968cc623b8a22d15f04272d5ec57e6cbbae0b7dd0df5f84c422013c3df663671ee159e482b347aefef1a5044110c42f81ea +67e29078e79d771616164e9f3edd6eb7f3cf5d3c2dc276ad56c3c6eeeeeebec91df3f3f3d8585a5aeaff9e1c4c9f9f4d3c3fba71e3c68913279e7cf2c941de20 +411004f1b1a076fe0872e9d2a57d7bc49acc1085ababab421ae622006f71c8f7fd0b172ef4cfffccc78e42444201405642654210887851224d1e325abca578ce +044110bf1caa9f8943025f83d75f7ffddab56ba552e9d4a953b3b3b3aaaae23b201e24adadad49771bf481f452df572ea73f3dbe45381bbe6c38dbcd9b373b9d +cefafafa91234706766b044110c43d40edfc11c475dd7d7bf2e7f121a7bfcf273fd46eb70f9e0a47a328ea76bbd094baae436eee9302fdcb3513044110bf1caa +9f894302df87c5c5c5ab57af3a8e832fc6830f3e689a261ae4fddf01b4d8f155493862cfbe2f9b58f401d9fb87032057b55ac5d7e9ca952b6fbcf106bec32296 +c4a0ef90200882f838503b7f0411de17af9aa6f57b6231f3338e636c4007c097e36d2e04f725eea75c2e437d421ce4eb3f0de646088220460caa9f89c300df9c +b5b5b54ea753afd7f165f8bbbffbbb8b172f1e3972e4dcb973b55a2d5fc1c1b6edc71f7f7c7979796565e5e0370a091a8dc6dcdcdcdb6fbf8dc6bcbcc7cecece +1ffff11fafaeaeb65a2d34f8f16ddcdede863918c5f650ee97200882f850a8821e59e07dcf9c3903a79eef810278f3cd37373636a00b5f7cf1c5c9c94938f20b +172eb4db6d2486778738d87712787dec7cfef9e74dd33c284c098220887b80ea67e2d3e5affeeaaffef22fff324dd3dffffddf47431ddbbd5eefd2a54b783d71 +e284e338274f9e9ce4148bc55fd238c72124989f9fdfe2bcf7de7bf81e2e2c2cacacac9c3d7bb650287ced6b5f5b5e5efea33ffaa3ef7ef7bb30f71bbff11b83 +bc4d822008e2a343edfc91452c9e0cf2d177711c4751140401364aa552ad568346cc976ec6b688bbdb3f8a0fdb509050062268f3be017e044110c43d40f533f1 +e9f2377ff337cd6613df07dbb64f9d3af58d6f7c035fa73ffff33fffd33ffdd39b376fe21bf2c52f7ef1ab5ffd6abd5e773961188ac743c78f1f47f65bb76e89 +9923e2289261fb95575e79f3cd37450cc8af7ffdebbff55bbf251e366d6f6f232fccc128b5f30982203eb3503b7f6411219afb83ee7a9ea7aa2afc345eb1dded +76914044e8419a244944082828cb7c0d67915daceddc7f66e4a2d1a1044110f706d5cfc461f03bbff33b8f3ffeb8d8c677e96b5ffbdaf9f3e7f145fa933ff993 +575f7df5faf5ebe2d112be3338fac4134fcccdcd351a0d245e5858585e5efec94f7e124591987b8f5cabababa74e9dfadddffd5de43a72e4483ea2042660e8bb +dffdeeb06e93200882f828503b7f64810abc70e142ffe2b7107fb55aad542a4147bef1c61b62fe67afd78347c7c6fafabac463f0c0eb1b8681ec172f5ec451db +b6210b8ac5627fbf1312e76b3ee5503c678220888f02d5cfc4a70b9aee274e9c40f31badf47c27be1ea74f9fc6c64b2fbdf4677ff6676fbffdf6952b57f0fd41 +bb1d5f95b5b5b573e7ce89d11f6fbdf516be51624147d1db8f86fd97bef4259c10a7dd670b26b01f595aadd6006f91200882f878503b7f6481346cb7dbfdd19b +c502cb40e27341fb138b017b129f9b97ef81884432387e787dd15f942ff504ef2ed2e7d048518220888f08d5cfc4a78e88a57fd74368abffe11ffee1a54b9716 +16166edcb871e1c205897f615e7ffdf51ffce007d88e38e27bf26bbff66ba74f9f4696b367cf7e90ad7c5209411004f19985daf9238b08cb04472ee6760a3599 +2fbc94c77c364db3df5be7319f4547934896afc163591612e0a8e338e29c2217ce79b0fb88200882b82b543f1383e72ca7d56afdfaafffbac4bf3f3ffad18fbe +fffdef63fbab5ffdeaf9f3e7c5d76f6e6eae52a90cf95a098220884f0cb5f3471608be46a301b76d188608ecec799e88de9cafc90c5df8dc73cf954aa55c5c42 +68bef6da6bdd6e37e648bcdf697d7dbdd96ce20ccf3efbac482c46f70943c81586e1bbefbe3bc49b250882b88fa0fa99f874f9e811192a1cb17de2c4891b376e +60e3b77ffbb74534c743324a1004410c1e6ae78f2079378e18c2679a269c7aa1503838d00e6fa10babd56aae237bbd5e9224d08542298a904e62389fa669d09d +38cf3ed78e434110c0caa0ee8f2008e27e85ea67e230c0472c5664f858208b982a726f79e97b451004f15986daf92388e77912977770c3796466f872a8430847 +31c353046416d33e45dc6691176f9152acc30c8909e1886d68479c0adb62d9a7838ff091eb97acc74b10044108a87e260e836f7ce31bf73667fede6237c0d0ef +fddeefe12b770f7909822088c140be7f0479fdf5d7c5bacae7cf9f870484277ee79d77c4c4ce6ab55a2e979324595f5f87f813879032ef2f1269a020a1189e7f +fe7911b9171a11d991787171715f782701129f3c7972d0f749100471bf41f53371183cf4d043f796513c78fab8e0db485f2a822088cf38d4ce1f413a9d8e98a2 +99afbdecfbbe3824fa82f2984c38041fdfbfb6934803202e272727c55abb627fc8715d77dfe37fa15969fc1e4110c48742f533f1d9015f8fdddd5d8966da1304 +418c22d4ce1f4144270f849d88cc7c3041ff4ea4d9a72325eef2c5eacd62ec687f4a70504762e7bdf5091004418c15543f139f29a8854f100431aa503b7f0479 +e69967a4bdf599c5a3fa83404a8a51a0ebebeb774d60db76bfdccc13b75aad83d3f9b0677575f5e5975ffe94ee8020086234a1fa9920088220880140edfc11a4 +542a495c2942448ae99afd0b298b8d7ce9a6288a0ec667c61e11b7699f64c439456ce77c4f9e37088243ba1d8220889181ea67e233c53d84ee23088220ee0ba8 +9d3f82e4419b6cdb164b37f9be9fa6a9d823023e89f599b0c734cd7dba301f0eeaba6e7f9466bc15a1a170065555452e11f979e0b7481004715f42f533f1d901 +5f953ff8833f101bc3be16822008e25386daf9230b04e257bef215cbb23ccf7be595573a9d0eb6b1a75c2e63fb3bdff9cef6f636f63cf5d4538ee3e4b944a867 +b19ed3abafbedaeffba120af5ebd0a490aed38373707858aa38d4683566c220882f85850fd4c7c165014e589279e18f65510044110870229809105f2f17bdffb +5ebebcad2ccb9080d823ded63962ed652842c330ce9e3d9b476f46e256abf5ad6f7d0b9ab25aadbef4d24bd08bc87ee9d2259c368ee39595159c19a273757575 +6877481004717f42f5334110044110870ab5f3471ce842319ff3838ee687ee9ae6e0ce7de96950284110c4bd41f53341100441108704b5f34716283cb11a3336 +745dbfabe013eb308bfea28309901787fa6778229958bac9711c1c4ad3d4755d31b3544c34250882203e14aa9f09822008823854a89d3fb2288ad26834b22c83 +f83b73e68c6ddb073b7fa0ff72996859567f0231c9b35028148b456ce3109422ce03d528edadf0dce974befded6f6f6f6fe3e467cf9e1de0cd110441dcc750fd +4c10044110c4a142edfc9105ea100a12facf34cd4aa5d21fcca99f0f1a322aba800c0e2429dee2157ab13f0180a0f47d5fe51cca6d1004418c1c543f13044110 +0471a8503b7f6481400c8220e5f47abdfea99ed25e878fc4fb850ee68540f43c0f02b45028589605a5883348bc0f2a1f238a8d300c9106e21269b071f8f74410 +04310a50fd4c10044110c4a142edfc910522efe2c58bdd6ed7308cd5d5d57e9d0711b9b4b484041091f3f3f348b02fafe8657afae9a7a12321227ff8c31f4247 +2271a3d1d0753dd7a350a88f3df658922448fce4934f0eecd6088220ee6ba87e2608822008e250a176fec802b507f1d7e97420139bcde63e1db9b9b909818843 +a5520987fabb92c4b6e3381091b55a0d4a14e7c119a0238bc5e23ed129869b8a9ea541dd194110c4fd0dd5cf04411004411c2ad4ce1f5914458146c42bf49f08 +da9c1f9265d9b22c71284d53314654ccf3c4864869db761445d09a6118aaaa8a9d7845e22449ee1a2fcaf3bc01de1c4110c47d0cd5cf04411004411c2ad4ce1f +591cc779f1c517a1202104af5fbf0e45984fdd84109c9d9dc52b0e5dbe7cb9d7eb41569e3f7f5eacc624823f43442e2e2e22019255abd572b90c05b9bdbd9d4f +1ced0767be7dfbf6cb2fbf3cd85b240882b82fa1fa9920088220884385daf9238ba228f57a1dd2300882e5e565a840a123c5ab18260a71095d8804a2ef48446f +ae542a62da2744a4ebbaf93acf31073bef6a0e2719e4dd110441dcbf50fd4c10044110c4a142edfc5126db43d77531c9534478ce3b8e202ec5984fc8446c4326 +e210b4a3e84ac2db5c7d8ac49665dd35fe33411004f1b1a0fa992008822088c38334c1e823867a421a7a9e77e1c2854ea7931fc2ce999919a12c777676767777 +c5084f455172d199278688fcf297bf5c2a953e684967822008e26341f53341100441108701b5f3471f8842dbb645b78f1805dabfc6721eff299fd87970842792 +894e2788c86ab5daaf23f353110441101f17aa9f0982200882380ca89d3f82084508f998c758c636045f1e99b93fe0539aa6fbfa7ff2a3482c14243222591445 +01274f7fd7ec044110c40741f53341100441100380daf923c8caca8ab41763190a1272b0d168403e42f355abd552a9d43fa5737d7d1d02f1e049f25c108e172f +5eec76bb8ee35cbe7c391f178a9320fbdada5aded1f4cd6f7e7350b7481004715f42f53341100441100380daf923481e7259f4ed689a562c160dc3c0b6ca1147 +2104fb17613ad8ed0311895c509f38a188f9ec791eb2e73a12d95badd607457826088220f641f53341100441100380daf92348a150e87fab7024aefcfa47840a +c45becb72c4b24cb73e58971089211affd6710b91cc781d63cd4db2108821819a87e26088220086200503b7f0479e18517f26d31edf3dab56bbeef431a0a2db8 +2f5633de62ff73cf3dd73fe653e44232c8c473e7ce8998cfb66df7772b21d7b3cf3e8b579a024a1004f151a0fa9920088220880140edfc11a45aade6db107fd0 +82f95850d177942bc8bcf3073bcbe5727face63c17d2e41d500723422197e33887783304411087036ab92449344deb5fa02e47548048b06fbfe8213f381efe83 +d24bbc828de318094cd3a4fa9920088220880140edfc1164dfc24b221ab3d88ea248f41741748a57b11fdbaeeb42eff6f71721b14800e58afdd899477816b9a0 +3e91ab7f7c294110c4fdc23befbcb3b0b070faf4e976bb9dd763a2758ded5aad860db16a7d9e05dbf3f3f3d8585a5aeaaff70ea6cfcf26dadb376edc3871e2c4 +934f3e49f53341100441100380daf923c8a54b97f6ed116b324314aeaeae0a69988b3fbcc521dff72f5cb8d03fff331f3b0a1109450b59099509812be2458934 +79c868f196e2391304711f816aedf5d75fbf76ed5aa9543a75ead4ecec2c9acaa8d344c37b6d6d4dba5b2739d24b7d55684e7f7ad48a381b2a4f9cede6cd9b9d +4e677d7dfdc8912312d5cf04411004410c046ae78f20aeebeedb93f72f859cfe3e9ffc50bbdd3e782a1c8da2a8dbed4253eaba0eb9b94fdaf62fd74c1004711f +81fa6d7171f1ead5ab8ee3a0a27bf0c1074dd34483bcbf4e433b19555fc2117bf6559e22483eb2f70f0740ae6ab58aeaf1ca952b6fbcf106ea6431f75ea2fa99 +20088220888140edfc11444843bc6a9ad63fe254ccfc8ce3181bd0b5d0a6789b0bc17d89fb2997cb509fd091f9fa4f83b911822088430235e1dada5aa7d3a9d7 +eba8dcfeeeeffeeee2c58b478e1c3977ee5cad56cb23dedbb6fdf8e38f2f2f2fafacac1cac2191a0d168cccdcdbdfdf6db68c0cb7becececfcf11ffff1eaea6a +abd542831fb5ebf6f6b658cd9eea6782200882200600b5f34716e8c23367ce40a4e67ba068df7cf3cd8d8d0de8c2175f7c71727212c2f4c2850bed761b89a156 +a114f79d0492113b9f7ffe79d3340f0a53822088fb94bffaabbffacbbffc4bb4a57ffff77f1f0d756cf77abd4b972ee1f5c4891368699f3c79729283f633aabe +0f3a0f0e21c1fcfcfc16e7bdf7de43bdbab0b0b0b2b272f6ecd942a1f0b5af7d6d7979f98ffee88fbefbddefe653f1a97e2608822008e250a176fec822164f06 +f968d2388ea3280a82001ba552a956ab4123e64b37635bc491ee1f328a6d2848284e11b479df6852822088fb94bff99bbf69369ba8dfd0d83e75ead437bef10d +548f7ffee77ffea77ffaa7376fde448df7c52f7ef1ab5ffd6abd5e773961188ae6f4f1e3c791fdd6ad5b62a4bd388a64d87ee59557d0561731f3befef5afffd6 +6ffd96689c6f6f6f232fccc1a8b04ef5334110044110870ab5f3471611a2b93f88b4e779aaaa422fe215dbdd6e170944ff12d224492242404159e66b388bec62 +6de7fe3323178d0e2508e27ee7777ee7771e7ffc71b18dbaf16b5ffbdaf9f3e75131fec99ffcc9abafbe7afdfa75d114471d88a34f3cf1c4dcdc5ca3d140e285 +8585e5e5e59ffce427689c8bb9f7c8b5baba7aead4a9dffddddf45ae23478ee43df0300143dffdee7773bb543f130441100471a8503b7f64810abc70e142ff62 +ce107fb55aad542a4147bef1c61b62fe67afd7836ac4c6fafabac4634a41c51a8681ec172f5ec451dbb621198bc5627fbf1312e76b3ee5503c678220ee17d03c +3e71e2049adf68a5e73b51dd9d3e7d1a1b2fbdf4d29ffdd99fbdfdf6db57ae5c417d88763baabeb5b5b573e7ce89def2b7de7a0b35a458004ff4f6a361ffa52f +7d0927c469f7d98209ec479656ab25f650fd4c10044110c4a142edfc9105d2b0dd6ef7476f160b2c0389cf05ed4f2c06a04a7cd668be072212c9a017a162457f +51bed413d4aa489f4323450982b8bf10b1f4ef7a086df53ffcc33fbc74e9d2c2c2c28d1b37d026977805f8faebafffe0073f90f85af762b97b6cffdaaffddae9 +d3a791e5ecd9b31f642b1f842fa0fa9920088220884385daf9238b08cb04e527e6760a35992fbc94c77c364db35f7de6319f4547934896af2965591612e0a8e3 +38e29c2217ce79b0fb882008e2bee62c07cde65ffff55f97787df8a31ffde8fbdfff3eb6bffad5af9e3f7f5e54a7737373954ae5639d99ea6782200882200e15 +6ae78f2c107c8d46030acf300c11d8d9f33c11bd395f9319baf0b9e79e2b954ab9b884d07cedb5d7badd6ecc9178bfd3fafa7ab3d9c4199e7df65991588c5615 +86902b0cc377df7d7788374b1004f1b1f8e833d82b1cb17de2c4891b376e60e3b77ffbb745f4bb7b334af5334110044110870ab5f34790bc1b470c49354d1322 +b55028ec1b382a71ad095d58ad56731dd9ebf59224812e144a51847412c353354d83eec479f6e9631c0a82005606757f0441109f1454592282fdc70259c4d0fa +7bcb0ba3aeeb8ab7543f13044110047178503b7f04f13c4fe2f20eb2328fcc0c6d0a7508e12866788a80cc62daa788db2cf2e22d528a75982131211cb10ded88 +53615b2cfb74b01f0cb97ec9fad20441109f35bef18d6f1c6c5a7f14ee6dae3b0cfddeeffd1eaad07ff7effe9d44f5334110044110870cf9fe11e4f5d75f17eb +2a9f3f7f1e1210e2ef9d77de11133babd56ab95c4e92647d7d1de24f1c42cabcbf48a4818284027efef9e745246a68446447e2c5c5c57de19d04487cf2e4c941 +df274110c4bdf2d0430fdd5b46f120f5e382da555492543f13044110043100a89d3f82743a1d3145335f7bd9f77d7148f405e5319970089ab57f6d279106405c +4e4e4e8ab5a3c5fe90e3baeebeee2ca159695c284110230faabbdddd5de9e34cefdf07d5cf04411004410c006ae78f20a29307c24e44663e98a07f27d2ecd391 +12978662f5663176b43f2538a823b1f3defab8088220ee2feeb9852fa0fa9920088220880140edfc11e499679e91f6d667165d4f07819414a340d7d7d7ef9ac0 +b6ed7eb999276eb55a07a7a762cfeaeaeacb2fbffc29dd014110c46842f53341100441100380daf92348a95492b852848814d335fb1752161bf9d24d51141d8c +cf8c3d226ed33ec988738ad8cef99e3c6f100487743b0441109f1dee21745f3f543f13044110043100a89d3f82e4419b6cdb164b37f9be9fa6a9d823023e89f5 +99b0c734cd7dba301f0eeaba6e7f9466bc15a1a170065555452e11f979e0b7481004310450f5fdc11ffc81d8b8b73350fd4c10044110c400a076fec80281f895 +af7cc5b22ccff35e79e5954ea7836dec2997cbd8fece77beb3bdbd8d3d4f3df594e338792e11ea59ace7f4eaabaff66b5928c8ab57af4292423bcecdcd41a1e2 +68a3d1a0159b08821813d08a7ee289273ef979a87e2608822008e250210530b2403e7eef7bdf83f8136f65598604c41ef1b6ce116b2f43111a8671f6ecd93c7a +3312b75aad6f7deb5bd094d56af5a5975e825e44f64b972ee1b4711cafacace0cc109dababab43bb43822088fb13aa9f09822008823854a89d3fe240178af99c +1f74343f74d7340777ee4b4f8342098220ee0daa9f09822008823824a89d3fb240e189d598b1a1ebfa5d059f588759f4171d4c80bc38d43fc313c9c4d24d8ee3 +e0509aa6aeeb8a99a562a229411004f1a150fd4c10044110c4a142edfc9145519446a3916519c4df9933676cdb3ed8f903fd97cb44cbb2fa1388499e8542a158 +2c621b87a014711ea846696f85e74ea7f3ed6f7f7b7b7b1b273f7bf6ec006f8e2008e23e86ea6782200882200e156ae78f2c50875090d07fa669562a95fe604e +fd7cd09051d10564702049f116afd08bfd090004a5effb2ae7506e83200862e4a0fa9920088220884385daf9230b0462100429a7d7ebf54ff594f63a7c24de2f +74302f04a2e77910a08542c1b22c28459c41e27d50f918516c84618834109748838dc3bf278220885180ea6782200882200e156ae78f2c1079172f5eec76bb86 +61acaeaef6eb3c88c8a5a5252480889c9f9f47827d79452fd3d34f3f0d1d0911f9c31ffe103a12891b8d86aeebb91e85427decb1c7922441e2279f7c7260b746 +1004715f43f5334110044110870ab5f34716a83d88bf4ea70399d86c36f7e9c8cdcd4d08441c2a954a38d4df9524b61dc78188acd56a50a2380fce001d592c16 +f7894e31dc54f42c0deace088220ee6fa87e2608822008e250a176fec8a2280a34225ea1ff44d0e6fc902ccb96658943699a8a31a2629e2736444adbb6a32882 +d60cc3505555ecc42b12274972d778519ee70df0e6088220ee63a87e2608822008e250a176fec8e238ce8b2fbe0805092178fdfa7528c27cea2684e0ecec2c5e +71e8f2e5cbbd5e0fb2f2fcf9f362352611fc1922727171110990ac5aad96cb6528c8ededed7ce2683f38f3eddbb75f7ef9e5c1de224110c47d09d5cf04411004 +411c2ad4ce1f591445a9d7eb908641102c2f2f43050a1d295ec53051884be84224107d47227a73a55211d33e21225dd7cdd7798e39d879577338c920ef8e2008 +e2fe85ea6782200882200e156ae78f32d91ebaae8b499e22c273de71047129c67c4226621b321187a01d455712dee6ea5324b62cebaef19f098220888f05d5cf +04411004411c1ea409461f31d413d2d0f3bc0b172e743a9dfc1076cecccc0865b9b3b3b3bbbb2b46782a8a928bce3c3144e497bffce552a9f4414b3a13044110 +1f0baa9f0982200882380ca89d3ffa4014dab62dba7dc428d0fe3596f3f84ff9c4ce83233c914c743a414456abd57e1d999f8a200882f8b850fd4c10044110c4 +6140edfc11442842c8c73cc632b621f8f2c8ccfd019fd234ddd7ff931f4562a1209111c9a2280a3879fabb66270882203e08aa9f09822008821800d4ce1f4156 +5656a4bd18cb509090838d4603f2119aaf5aad964aa5fe299debebeb1088074f92e78270bc78f162b7db751ce7f2e5cbf9b8509c04d9d7d6d6f28ea66f7ef39b +83ba45822088fb12aa9f09822008821800d4ce1f41f290cba26f47d3b462b1681806b6558e380a21d8bf08d3c16e1f8848e482fac40945cc67cff3903dd791c8 +de6ab53e28c233411004b10faa9f09822008821800d4ce1f410a8542ff5b852371e5d73f225420de62bf655922599e2b4f8c43908c78ed3f83c8e5380eb4e6a1 +de0e4110c4c840f53341100441100380daf923c80b2fbc906f8b699fd7ae5df37d1fd25068c17db19af116fb9f7beeb9fe319f22179241269e3b774ec47cb66d +bbbf5b09b99e7df659bcd214508220888f02d5cf04411004410c006ae78f20d56a35df86f88316ccc7828abea35c41e69d3fd8592e97fb6335e7b99026ef803a +18110ab91cc739c49b2108821821c6b07ec6d52649a2695aff428039e2469060df7e3112e1e0bc830f4a2ff1828ae318094cd3fc54ae9c20088220ee5fa89d3f +82ec5b7849446316db511489fe228821f12af663db755de8b0fefe22241609a0a8b01f3bf308cf2217441572f58f2f250882207e0963583fbff3ce3b0b0b0ba7 +4f9f6eb7dbf9f588a718d8aed56ad8d8dddddd37e9607e7e1e1b4b4b4bfdd77f307d7e36f15ce3c68d1b274e9c78f2c92707798304411004f11984daf923c8a5 +4b97f6ed116b324314aeaeae0a69988b2dbcc521dff72f5cb8d03fff331f3b0a1109a50559099509e125e245893479c868f196e239130441fc72c6b07ec6e5bd +fefaebd7ae5d2b954aa74e9d9a9d9d555515d7261e70acadad49771b8c80f4525f51e4f4a7c7dde16c28049cede6cd9b9d4e677d7dfdc8912303bb3582200882 +f8cc42edfc11c475dd7d7bf27e8f90d3dfe7931f6ab7db074f85a3511475bb5d684a5dd72137f749aefee59a098220885fce18d6cfb8cec5c5c5ab57af3a8e83 +0b7ef0c1074dd34483bcffdad062c72d241cb1675f2188c50890bd7f38007255ab55dce6952b57de78e30d94ad887130e83b2408822088cf1ed4ce1f4184cac1 +aba669fd8a47ccfc8ce3181bd05bd04c789b0bc17d89fb2997cb509f1061f9fa4f83b9118220881163dcea67dcd1dada5aa7d3a9d7ebb8c8bffbbbbfbb78f1e2 +912347ce9d3b57abd5f295056cdb7efcf1c79797975756560ede2912341a8db9b9b9b7df7e1b8d79798f9d9d9d3ffee33f5e5d5d6db55a68f0a394b6b7b7610e +46b13d94fb2508822088cf08e4084716a89c3367ce403ce57ba0b4de7cf3cd8d8d0de8c2175f7c7172721282e9c2850bed761b89a1a220c2f69d04ea0a3b9f7f +fe79d3340f0a53822008e21e189ffaf9affeeaaffef22fff324dd3dffffddf47431ddbbd5eefd2a54b783d71e284e338274f9e9ce4148bc55fd238c72124989f +9fdfe2bcf7de7b289f858585959595b367cf160a85af7ded6bcbcbcb7ff4477ff4ddef7e17e67ee3377e6390b749100441109f35a89d3fb288c593413eca318e +e3288a8220c046a954aad56ad088f9d2cdd816f18dfb474b621b0a120a4c046dde379092200882b807c6a77efe9bbff99b66b389ebb46dfbd4a953dff8c63770 +9b7ffee77ffea77ffaa7376fdec4957ff18b5ffcea57bf5aafd75d4e1886e2b1c5f1e3c791fdd6ad5b624683388a64d87ee59557de7cf34d119bf0eb5ffffa6f +fdd66f898720dbdbdbc80b73304aed7c82200862cca176fec8224234f70737f63c4f5555e821bc62bbdbed22818884843449928810505096f91ace22bb58dbb9 +ffccc8f5591b1d4a100471bf306ef5f3effcceef3cfef8e3621bf7f8b5af7dedfcf9f3b8c13ff9933f79f5d557af5fbf2e1e79e05e70f489279e989b9b6b341a +48bcb0b0b0bcbcfc939ffc248a2231f71eb95657574f9d3af5bbbffbbbc875e4c8917ca4034cc0d077bffbdd61dd26411004417c76a076fec8021578e1c285fe +458621fe6ab55aa954828e7ce38d37c4fccf5eaf07e5848df5f57589c73a82ba320c03d92f5ebc88a3b66d437e158bc5fe7e2724ced77ccaa178fb0441101f85 +f1a99fd1743f71e2049adf68a5e73b71d9a74f9fc6c64b2fbdf4677ff6676fbffdf6952b57705f68b7e316d6d6d6ce9d3b274625bcf5d65bb853b1d0a0e8ed47 +c3fe4b5ffa124e88d3eeb30513d88f2cad566b80b748100441109f45a89d3fb2401ab6dbedfee8cd62816520f1b9a0fd89c5c04889cf81ccf7404422190416d4 +95e82fca977a828a12e9733e5323450982203ecb8c55fd2c62e9dff510daea7ff8877f78e9d2a58585851b376e5cb87041e237f2faebafffe0073fc076c411d7 +ff6bbff66ba74f9f4696b367cf7e90ad7cb203411004418c39d4ce1f59445826082631b753a8c97ce1a53ce6b3699afdaa288ff92c3a9a44b27cad23cbb29000 +471dc711e714b970ce83dd47044110c45da1fab99fb39c56abf5ebbffeeb12bfaf1ffde847dffffef7b1fdd5af7ef5fcf9f3a258e6e6e62a95ca90af95200882 +20ee13a89d3fb240f0351a0dc823c330446067cff344f4e67c4d66e8c2e79e7bae542ae5e21242f3b5d75eeb76bb3147e2fd4eebebebcd66136778f6d9674562 +318a521842ae300cdf7df7dd21de2c4110c47dc4f8d4cf1f3d52408523b64f9c3871e3c60d6cfcf66fffb68832784846098220086254a176fe089277e388a192 +a669423c150a8583031af116bab05aade63ab2d7eb2549025d2894a208e924864d6a9a06dd89f3ec935038140401ac0ceafe088220ee57c6ad7e8669b152c0c7 +0259c414867bcb4bfe8820088220a89d3f82789e27717907b99347668666823a847014333c45406631ed53c46d1679f11629c53acc9098108ed88676c4a9b02d +967d3ad855825cbf64dd6382200842306ef5f337bef18d7b9b337f6f310560e8f77eeff75014f790972008822046096a9b8d20afbffeba5857f9fcf9f3908050 +3cefbcf38e98d859ad56cbe5729224ebebeb107fe21052e6fd45220d142494d9f3cf3f2f22244323223b122f2e2eee0bef2440e293274f0efa3e098220ee37c6 +ad7e7ee8a187ee2da37820f27141299133220882200889daf92349a7d3115334f3b5977ddf1787445f501e930987a0a5fad776126900c4e5e4e4a458d358ec0f +39aeebeeeb66119a95c6491204417c28543f7f1470d9bbbbbb12cdb427088220887b85daf92388e8e481b01391990f26e8df8934fb74a4c4a59558bd598c1ded +4f090eea48ecbcb7be17822088b182eae78f08b5f009822008e29340edfc11e499679e91f6d667165d2207819414a340d7d7d7ef9ac0b6ed7eb999276eb55a07 +a74d62cfeaeaeacb2fbffc29dd014110c46842f53341100441100380daf92348a95492b852848814d335fb1752161bf9d24d51141d8ccf8c3d226ed33ec98873 +8ad8cef99e3c6f100487743b0441102303d5cf1f917b08dd4710044110440eb5f347903c68936ddb62e926dff7d334157b44c027b13e13f698a6b94f17e6c341 +5dd7ed8fd28cb7223414cea0aaaac825223f0ffc16098220ee4ba87efe28e016fee00ffe406c0cfb5a08822008e2be84daf9230b04e257bef215cbb23ccf7be5 +95573a9d0eb6b1a75c2e63fb3bdff9cef6f636f63cf5d4538ee3e4b944a867b19ed3abafbedaafb1a020af5ebd0a490aed38373707858aa38d468356d4230882 +f85850fdfccb5114e589279e18f65510044110c47d8cb6b87c4392ee0cede3fd0c327f77f70838ac332149f14f398aaaddb6b2135c0fa72e1aa59909b96a4ab7 +7bf2f59deca15a7ab22e2569f6ce7abad54ba71cd9d4f0271da9c89f7bf48141dedbd0f9bdaf3dcb7a69144595e534cb9657d75ddfd735ad522e2ab2dcedb97e +c0066db2559164394e92902ff98b0de4d254b55a2e1d1cb808f53635350501072d082188cf026749780f4f18b1e99af5896af5d4e725be28d1f7bef7bd7c1961 +59962101b147bcad73c4dacb38a7611867cf9ecda3372371abd5fad6b7be054d59ad565f7ae925e84564bf74e9124e1bc7f1caca0ace0cd1b9baba3aa8e22408 +82f8d4a0fa79300cab9cfffa9f7e3ef89b1d2254ce044110c43e34d4d7b2cc9af7775af659b6f7f20b726dc15f3395391233b5ec44879f081aa63a2549c52051 +5355b2d5a20e5f21abaa74a2144ce9699019ebbe2105d284930efef6864b268a8e8fc884674c5838e454915948e44c5192bd40ca6cbe25de7224de63c3724872 +92b2cc2c417ec20c09950ce7e25197d8004e1ecf896fe1fcec110c7b10d37f0decf395effed8861fcd0fdd35cdc19dfbd2dfa7834209821873a87e1e0c9f8572 +1e07a89c098220887db0117da2692fe55bd9fe9840f9db2c657fa922f552d98db5c4b2e58a72c2c8ca91e7745be54c2b576b71c1b44c4d93926ac14d757f372e +7722ad1da4711a0ef8de864ecff5e0061545d5750dc5572a151dc761532e750dea4b558a453e2013258ae2c77e4555442e3f08f096f9e1f48ef7c67ec7b14cc3 +60132fb10bbe3789c5e379f63c3e630f5faae532cea21b86b08e3388d598b1a1ebfa5d059f588759f4171d4c80bc38d43fc313c9843ec08de010dcbdebba6266 +a998684a1004715f40f5f360186e398f0f54ce044110c43ef6cfdce38dfcbb74e9f363cc4364ec0170da0cd4a66fd9ba3e5dd18a9a5a68f98edfd14d272ba891 +6328a8fde3c0967754a5ad68cac9a2d6b165dbea0de48e3e43345b6d682cc3d01dc7861f9d9e9a840e4b9324f0bc2ccb20e00c5dc7061b699924b665552a65e4 +5adbdcda6db7933861d9f79ead607fbd56c19ff85ce07ae328eeba6c4964b870a4d26d7b66a601afecfbbeb0ae284aa3d1c021183d73e68c6ddb073b7f7055b9 +4cb42cab3f8198e45928148ac522b699095dc7797047d2de0acf9d4ee7dbdffef6f6f6364e7ef6ecd9c32f518220884f07aa9f07c370cb797ca07226088220f6 +a1f1067dbfbcd8dfc8cf87ff657b7dfef002ad405ef395b9b2aae92a1fa6af48aa261b86a2e98aa24a592a67a99676f5b4696a8d2953aea1e96f0df4c63e0bb0 +316f59df9c080e7b50c2a7b7b15174aa7a2728021fba29c6d1b1919c6c872c2b8a0cd1c61fa7efa55278b865a6e4d8203b99ffc75def2fcedfb73213dcbc70f0 +954aa53f98533f1f3464547401191cdc08bf1c057ab13f0180a084a757399fb0b80882200606d5cf8361b8e53c3e503913044110fbe89f9fcfdef73b8883ad7d +0652a799a1a4354b29f0157fe0047c4d4f2b13b161260ace93723f23c772898d0050214658e4974c1fbbf15db3b333f091bee7773a1df8d0c8091429f3bc6061 +692549135dd3c4ea478dfa84691abbadf68dc565e42a159c8265a64cffb147239d4e77737b1b1b4ec1999c9a6c77ba6ffffcdd288a91b15c2c603f7b002f4938 +9b08bc14048118a4810f01db62325dafd7eb9fea29ed75f848bc5fe8e095e3e49ee74180160a05cbb2a0147106892b897c8c2836c230441a884ba4c1c6211625 +4110c4a70ad5cf836158e53cacfb1d1654ce044110c43eb43b31f619777aeeb33ee4bdbe7ef10098a5c83248899a934e1464539715454a6439b1ac40d5244596 +78a701b2c48ae1ea0d4999481453927140c992b16be7435ea56c5e5bccc3d6b04836f0914912bb7ce01c9caec243e34ed62a481c4651abdd61b94c43531d94b4 +aa2b2878cff7c507a36a1ab49ae6f95dd70bc3c8328d62814fb76327971455cdf8b377f1909e9d300c2f5ebcd8ed760dc3585d5dedd77910914b4b4b48001139 +3f3f6f1c9862277a999e7efa69e84888c81ffef087d09148dc6834743ef64f2483b9c71e7b0c1691f8c9279f3cf402250882f894a0fa79300cb79cc7072a6782 +2008621f3c0edf9dff59a39e57e299863a5ed758d77d968a315d3898c4491804511ce19865aa1adc068fe3c262ba685aca3cc89de8be2c3aabaaa74ae9ce4304 +718274ecdaf97e10a040e123e10bd9a84a45d1f8f84931a2128ed3324d118d89171dcb2282e0647c989c78889e26a92855c8be6eaf07378c93647aa6aaf91238 +ec83e393e6524952ac3dbd88f7107f9d4e0732b1d96ceed3919b9b9b108838542a9570283b3090c3711c88c85aad06258af3e00cd091c562719fe814c34d45cf +d22116254110c4a70ad5cf8361b8e53c3e503913044110fbe06302b96ee00d7cd64b806a7c6b6b63f1d6ade6ce4eafdbf583d0b2cc72a5323ddd383a37572c96 +45152f2bd29ee460cf025416a64f4aef0cffcf67fcf351007c7ed718cee3babd7a3b4953b84f386055512ccb2a97cb1977ba288db9d9d9634767133e68334dd9 +43f1888fd54c5881aa711ab5db6d2483db36b9745b5fdf6c365b28cd52c1114114ee3c7767732598e34ee218af278ecddde64fd8e1e6a11199b3e70fe6fbe32d +33af6f59e2509aa6628ca898e729f12573f16adb761445d09af0f75006d88957f1fcfeaef1a23ccf1b44991204417c1a50fd3c188655cec3badf6141e54c1004 +41ec43bbd3524f5355d50c43bf76fdca1bafbcb270e33ddff3d238d5741dce20084348052889c9a9fa030f3d74fe9f7de1d4a99392140791cbdaf889a2a79215 +677292049214286a222b792c98ecce1081ec6e11fc479c24cdd79ae5932078a824455644e443555550a44a9228dc718ad913f924cdecce00b93b19f9d91221f8 +f8f008f6003e9f7171e7f13c8f94a3a9aac475a4e3382fbef822142484e0f5ebd7a108f3a99bc83a3b3bcb9d7a78f9f265387e6882f3e7cf8bd59844f06788c8 +c5c5452440b26ab50ac50005b9bdbd9d4f1ced0767be7dfbf6cb2fbf3c8862250882f8c450fd3c188656ce63069533411004b10fd69fcfe7ef593db7f3fffdd3 +ffe51fdff8812e6b05c7d6544dd678adce1af86a9a48519a2ede5a5abc79eb9f5e7be30b5f3affdcf3cf154b66afdb5362dd4e14298a9410ed7eb9a7e9291ff3 +0f5fc0d75d655d0c6cba987297f581471bcb34f9031415f7ae2a4a9ca45e10c2f73e78e2789aa56114bd7bfd067c25141e9b5597a4a56211b92627aa8da9baeb +f9ed761b1f8d6d5bd52a9b50a7f007f3f0d605db92ef6cb30e9cd5b575df67b1704410a666a723f1a174785bafd7210d8320585e5e6663f964112c97bd8a61a2 +300d5f8e04a2ef48446fae542a62da2744a4ebbaf2de3acf3127640f7dee02c5e32108e23e82eae7c130b4721e33a89c098220887d68a8d92dcbbabdbef2fff8 +efbeb5b278bb542a6a9a2a1ed6b20181b2e205819ca541104e4fd49f7cfcf347a62766a6aa5e6be7877ff5bda34f3c7ee2c4893088035949253591629f3f0d56 +158d4ddd97e5344be4943f53e65e61d8373b684cc3489254dc385e1314691c6363ee48031ef2ca8d85e5db6b125ffa28cd32dbb2aa15e65f2ba552bd5a31740d +6962bebaf2c4444de28f63e065754d9bac9659401d55c5a1384936b7773c3fc8f61652eab9aeb437632e8fa7a8ebba98e429223ce71d477ca91d36e6133211db +b8121c8276145d49789bab4f91185f95bbc67f260882b8bfa0fa79300cad9cc70c2a67822008621f9a695a2bb717ffafffe7ffcbce66b3542c64711cb110ad91 +a62af807a2a162c8471bb30f1c9b3d36557de0d1cf151af3381e7576db5b1b17dfbdb1146b0f3efa581846b189bd969a659aa62b9a2696724df97f6cc0979c29 +f2d88defe2116e722d97a5091fd9204b69a264429c718da68881747b2b1ab0011062f49d24a63bfc629d5ba10c23386fbe16a2c6c74a88e1792af7c4c2f5eebb +0c31d413193dcfbb70e142a7ef013c76cecccc0865b9b3b3b3bbbb2b46788a8f4f88ce3c3144e497bffce552a93486a11608821831a87e1e0c9f91721e79a89c +098220887d68adf6cefffdbff9bf6dadefa0916fa8329af7baa64a49aa49c944c97cecf4dcc9b9e9ea44ad36d5883acdf6ea4dbfd7d18b5545d535dbfe678f3f +f40f977eba58283df8f0236eafc757f491841b90849f48a4544ee0113236bd2bfdd0ab1931fcc0e7717122cff7e163835b8bb2229b86716c7606e5ec0741cc1f +b7d7aa5543d783306cb5db28b5eddd5d5d535ccf735d3f66c3ebd238667eb7e058b669b87eefd6e2321cee44b57c74661a65dc98ac4fd727745dab4d4c28b272 +6b69b9f7fecb8009dbb6853f16a34073df8c8d3cfe533eb1f3e0084fa109901222b25aadf6eb4872f30441dc8f50fd3c188655cec3beef4143e54c100441ec43 +fbf7ffd3ff78ebe662a1e0c859aaa95a962645dda8958d87e71b9f7bf044ad5666cbb14a72e4f6a2308a7d2f8e6e67bb9bb2ac29ba29abe6b9471e7ce3c76f56 +6a1393f57a148677566b61c3fe793b5f16c3f5652993c7b09d2f82e224c91dc729841a0b889cc42840f1185de2fd39a66946710c0f8db7110a3a0ca388795c3e +0c2f09f97e3bd1c5b3f64eb78b139a862ed28bc5720cc328974ae2218b30848d3cc6b2984a974766ee0ff824a2eff45f767e543cb0176344532e20024e9efeae +d90982203efb50fd3c188655cec3bce76140e54c100441ec437bfdc23f542b154d962c5d53f9f22953b6faebcf3cd5383aa34872e8fb99ac6471d4dd58852f60 +ad7755cf54938dc7971459b7ec62e9e12353175f7ff57ff39bbfc523eded0914890d0c5365359385c8808e193b7f0057ca875c4a8e6da34802b6b02d5497840d +385578ca5ab5a2c80a3ca8a62a96a1170b8e783ed2f3fc200c9913e58bd632f79c65aaa659968513fca290d9e809166517850b1fdc6ab7910589575656a4bd18 +cb62665da3d18077c7a16ab55ae2ee599c015e7c7d7d5df8ef7de4b9201c2f5ebcd8ed761dc7b97cf9723e2e142741f6b5b5b5bca3e99bdffce6004a952008e2 +9343f5f3601856390fe56687089533411004b10f8dc5d59724c7321529ab98eaa37393ffecc947a766679334090316562f8ec2c0edf6dacd2c5558fd2feb2ce2 +9ec6fa1c74590d83a05a29d7765ad7af5d7bf8e187c5e240bfe84090f97f9c317ceedb6c77a0b42627aa27e78ec23bde5c5ceeb91e9cf1dad6368e9e3a7eecdc +cc34f6efeeec465128574bf34a0385b5b8ba76f5e62da83fcb320dd948e2d8e7dd3e9552697eeee86eb379edbd5b299b7cc7fe24e67d23946db7e75eb989fd59 +a558c8432e8bbe1d4dd38ac522dc3cb6558e382af3903cf9d51eecf68188442e38729c50c47cf63c0fd9731d89ecad56eb83223c1304417c66a1fa79300cab9c +877bd78387ca99200882d8875628150d4dd1956cbe5e7a6c6ee2c9478e598eee75765351b5a749e0f650ef876122656910268a9aea067bec6b9aa6e518ba63a2 +e23f393b7573e1ba7bfc849265691e06462cd2da370471b8b73a78d8a8497ed7aaaac8f9030fbed620fe41211a2c406ea2aa7c51dbbdc036125f08f74e345bfe +960fb3c8f8d376652ff6c13e430c11473793b242e17dae57d9cbd51f35278fd623de62bf6559fdcf62c45052b18d4338395ef7c5ddc1b6e338b88b4fa9c00882 +200604d5cf836158e53cc87bfc2c40e54c100441ec43636bf5a4b255304f374ae71e999374d5edb5e11450f3a749c2276e45a11fc611f32049ca9c471a499a12 +6b365b8a455315f89042a97824ebbacdad8999a39eeb667c9e9868d933cfa128191b40960cfb6607cdb163c7e1561d534f78694c4fd627921825d1e9b1859136 +b7b67d8f8d98703d3761a17193308a51be519c4008c2515ba68157b5e09886c54e27675bdb5bbe1fcc4cd5d969d9d83c86d082d88343cc50b5fcc20b2fe4d720 +a67d5ebb76cdf77df86ca105f7c56ac65bec7feeb9e7fac77c8a5c48067170eedc3911f3d9b6edfee735c8f5ecb3cfe2750c1fe21004715f43f5f3601856390f +f19687029533411004b10f4d96324dd554599a2cdb688a273e8bce12c74926c911931a128fecc29025d5b44c555674d3d00d238982dece762ab7db89badaf6ae +2fdd8e5fbffcd57ffd9b53b5aaac1bc89625f0224aa6aaf29d255bc6ae29383d35c5e218a47116b30996b50a9b78e90761d7f5501aad76a7d3e94afc693a9f44 +17f45c365eae5c2ec3efcab264ea065e6dc7a9d626b03ff2dc4ebb838cb50af3ac79df8e2858367a338a702a5992abd56a7e0db0082d988f05157d47b982cc3b +7fb01376fb6335e7b99026ef803a18110ab91cc7f9d48b8e2008e250a1fa79300cab9c8775bfc382ca99200882d887863a3b4ea256277583304ed0c84f7890de +442cbe8a575951345d374ccb302c6c64d883d6bb24fb7ed8eeb416b7ba7ffff3859f2dac540a95874e9ef8dbbffc9b7a7dc698ac3ffbab4f853e0bd5279c000f +cb3a76fe40ac3fab48b2b227e304a25094be58b548a9f25172e22d0f7b2b89150a52b6ce0d9ba599edad799b24ec3342fabc4065eebc5531f8f3c0c24b221ab3 +d88ea2489c04e714af772e20cb5cd7d534adbfbf883ff189f9f524c27a1ee159e4c2052357fff852822088fb02aa9f07c3b0ca79dca07226088220f6a1b148ac +5256d0b57796b62d4d9e9d2ca17d9fa5195af7aa8e3f59d74d5d33544d9325680bb80054fbc824773aeea5eb4b7fffd31bb7d636ce7deef3cf7cf157ac72d92e +4e1c393efb0f17aff47a81e318dc7fb049fac2670cfb66078da6aa892c554ae5d9c93adce7e6d656180470b69669c24d1aba0edd8662314d13faacd7ebe93bbb +c8e505e18eebb1497445479121d4fc66b385fdd552b1e8d810770bcbab097bda72a7b78749b84c320cfde8cc344adb328d4b972eedbb12b126333ebcd5d5d5dc +8b0bf187b7eca9bfef5fb870a17ffe673e76149ff7d2d2126425ae767e7e5ec48b1269f290d1e22dc5db2708e27e81eae7c130ac721ecacd0e112a6782200862 +1f5a86567b967683f0daf276bbd5fd2f9e3aa92999aac8a665eba6c5baf1cd029afab1ef765bed4e378812294d952088773a9dabcbeba6a2fcef7ef35f4f358e +5cbcbab0bbfdb37f7eeeb1273e37f7ccd367541ee6453ceddd932c63d7e5cb9f9f67866e148b45f8dd56ab9526719cdc798e0e5f0bbf8b0d28336c445124de66 +5e80ed2c559338c9945f74e9248ec58223a499ef0771f2be60073c184e068f2bfa733aaebbff4aee7868b6d272c857d0e9d782e250bbddbecb2df01574badd2e +34a5aeeb909bfbba86fa976b260882b85fa0fa79300cab9c077ea34386ca99200882d8870627e0fbd156d0f50dcdf5fccbef6d3c7e62324b333d4d5555d14d47 +56b58dad9d9b8babab1b6d2f4ad1fa7754b9a0abb1243f7cf2f453f5d956bb7b6b69a5d3f61e3a31f7c089a35918e87112869153bc13fee74e3b7fd86a63f0b8 +9e9b2689a1a9bbcd569aa53dd70d0336248287c395755d330d1dc9d872b6aa6a1a46814fa4f482400e99cb56f1e1b021788acefd31fcb81fb2ecec505f878f58 +d516db7e10e23c389b70bd7815cfeff3eb11333f637e06c77190186f7321b82f713fe5721996a123f3f59f0ebbe80882200e15aa9f07c3b0ca7998f73c0ca89c +098220887d684992c649ac294a10c596a1bebbbc353b51989faee8a66915ab61aafcfce7d7ffe1f28d1f5f5ddadcdd2d9ad689e9fae946ed48a550ac4ccf9c7e +6c677371e3bdebd5a9a9b3b3a5c6cc44eab615f5a8512cd88e952662b5d5bdc981e3f7dc7771e11684daba65de5e5b471124506c69aaa84ad1b1e1778bc58270 +b450666cd45cb9343355c7db77aeddf43cdf3074160557514a85c2749dc5c559babdbebab983136a3a73ad908351c4c2ed88728dd932b93bf0e7931355a9c8f6 +40179e3973c6de0b930b3a9dce9b6fbeb9b1b1015df8e28b2f4e4e4ebaae7be1c28576bb8dc48d46034a71df2de0b3c3cee79f7fde34cd83c2942008e23e85ea +e7c130b4721e33a89c098220887d6821abbb65596173e8c330960b065f6d45d64c7bbbedfee737de7a054dfcb58da952e1fcc38f1c3d32675b86a329aed7d365 +4dee6ecb8afec823a792302995cba614d526aa71a62a41d7348ea49924ba2d867d8f432315b0272922ba619aa599ac6462a15ae54e6c42992f842cab7bb328f7 +6217f2119b2c768e9c47636667fb80be1a118327eddb23164f0679e826e1aa8320c046a954aad56ad088f9d2cdd8162b2df70f19c536142414a708dabc6f3429 +4110c47d0ad5cf8361b8e53c3e503913044110fbd03a9d9e639bae1b5aa6eea39d9f65d3b5222aff20c9befbf73ffadb1ffcccd28ddffe97cf7ffe734f6eb6c2 +2bd77edad9dd3c5ab10dbb9066e1638d68c335a264aa562bc78a69970a5553539a9b519af8ad965d9f4cc270d837384cd87039494e93c4ebf5e044272a6543d7 +f822c9acef657367f7c6ad251e24191e572e978a4766a624367a53b678a41c169c49927d4d13f1994b05dbd0d4244d3bae97b1c80799caa7cfad6d6e8551c4c6 +d1f93efc340b84cbad8b10cdf9780a18f23c0fa7855ec42bb6bbdd2e128850cf22acae989ba7702120e23c89ec626de7fcbeee6888cfd8e8508220888f0ed5cf +836158e53cecfb1e3454ce044110c43ed8dc2af1ac378a125995a727cac5826d9ac64fafdec2dfe30f9efed567fe451025affef8ad7f7afbed62163e78644aaf +5b9a1aaba9db983b72cc296eedb8ed50969a4da5b7a14cd465ab2c654a6f6bb3303d2d566b19f63d0e0dee76e11fd3300854456143216c5bf4ccb0684cdddee2 +ca9acc1fa7675276a431d59862e3e5e07775ee9ee388a9ba18ff246c039f8a635971828f498388d355051f03c4dff66e33e0cf53f8d00c297fc80e6f7de1c285 +a42f820ec45fad562b954a70ea6fbcf18698ffd9e39a808df75b5f9778b49e46a3611806b25fbc7811476ddb86532f168bfdfd4e489c07ecc9a178fb0441dc2f +50fd3c18865bcee3039533411004b10fede92f9efbe19b3fb451a1c7b11b27dbed5ecf8dd258f17ce5dc17be6c55a6de7ee76757ae5e3d327ff2f3c7a68b9a7c +64a2707caab01bc9f5b2a36689244bf3278fb85e763b0e5a2b1bbb996a554dd930bc9ddd248e14ee18a4f44ef89671438c9793780f0cdc6b92a4511c2bb2a2c1 +ef72c5a6f3984c699a88c28198631d357ba32eef74d164928876aba99a2adf39a51869273a7344e01c31328fe592ef74ece06ced76bb3f7a337f96af8a51799d +4ea7ff5245a86789cf1acdf740442219fb62b8aeb8987ca9a756ab15be7fb0c6676aa4284110c42f87eae7c130dc721e1fa89c098220887d68bffbbfffddb7de +7a7b7dbba9c899e314dfd94c16fef63dc7725cdf2b97ab0d5f0edcde8347eb65c35327aca2659d3832614d4caabe3beb24511c1a52ea363753d99c397e2c4be2 +1b972f4d1d53ac896959cabc76c79e9848e338cdf848c2f16be7178a0e5c299ca2639a6996ddded80ac2b0e0388f3efc00761e694c161d0b0916966f7bbe1f45 +71bbdd452e94946599aaa28ab838aee75dbdb180fd9f7be4a123478fb03175eb1b7cd9e438e20fe04f1f9f871fd635bd5eafc3f9ae6f6cb6b87599876542c9e7 +4ff4c558bb5c538a57d334fbc77ce6319f454793489670b06159167bf01fc78ee388738a5c38e7c1ee23822088cf2c543f0f866195f3b0ee7758503913044110 +fbd01e7ef4f3fff6dffc97ff9fffe1ffb5d8f20d5d435d3eeb488d4aca1661c9ba454b76e61e903a6b59929a76b15aadeaa61df77682cd9570665ac9d2ed95e5 +e65633d62a9bbb71d85a5754657de16a5d612bfc78bbbbe6e46422c989c41f208f5f87beaa69729ae8ba66183a3c651845aee743db292cda8dc217b6b1932455 +1439e5332aef483736d18e2f6fc3266a32bf8b5c120f9668db96c4d7424cd9e83c996b44c9b16db6bc8da14fd4aa38edceeeaeb08eed46a38134866188c0ce9e +e789e8cdf2de9accd085cf3df75ca954cac52584e66bafbdd6ed76638ec49ffaafafaf379b4d9ce1d9679f158971a83fe6531886efbefbee30ca982008e25ea0 +fa79300cb79cc7072a67822008621fdaee4f2f9edc58fc3ffdc6af5e5e59fbabab1b6912fe8bcfcf9e9a9bdaed7a61101baadc8b226d76be60e891eb26dd96b2 +7bdbefb6d6773b4f3df6e8f6eadaeb97ae285ac172ba49ac3d7c62c6b1f4db3bbbcdcd95aa7e62776dad746c3e93d8d830f883cf4e58a081d16e77e056cbc542 +a558bc130a97c75262616c24a9d5e9365b6d8905bc711ccb72b84f05499a46518c8c626626b2948a0576b64e67e1d6722ae232296a262799c406dd0551acc449 +1825e9da3a9c73cff5e4524d9c4aacc3649a66a55229140a79f4e61cb68e4ea954ad56731d09a3b0c8d7cd8dc538bd945d4f247a9fa03b719e7d1f250e054100 +2b875ea00441109f12543f0f866195f3b0ee7758503913044110fbd06e5ffaf15fffc5aba7ffd913f3f5892f3da05d7867a9e5c599ac4cd62714590efdd8ee7a +bedfcdbcc44e5359cbfc50de6e055d2f585c5afbc1e59b37d7b66a13d582ddf53375c9dd9daa164bd549dd327b9da6d42e757777ec4251d70c49cd27798d119b +5bbbf09a9aa258a6890dfe889d395d3f08b0bdb5d35c5ddb5055f5c193c78aec417b2242d7c231077cd2a6cfc329db96559f60ba707b676765f5b66959f3f373 +c89531d7cb8ad40b58381ce45e5963819ad8043ccd131b8661e491999105ea10c251ccf0140199c5b44f11b7595c33de22a55887191213c211dbd08e3815b6c5 +b24f071fd920573e71942008e2b30fd5cf836158e53cacfb1d1654ce044110c43e34c929141d736ebab2d3ed9caed94bd395ab4b9b0f1f9b3650afb3155765a3 +5850f528f183d80b9258f2c354925553d77efaeecd240e4e1d9bbdb6b5fbcedad66eb7f7d8f11353a5877f7ae54a2788bff0f04327e3c86b753445974d49d575 +89fc81d4f7aca35f8ab1edec7dc9f6d21d74a2bfa410f3784eafbffeba5857f9fcf9f39080107fefbcf38e98d859ad56cbe5329cf4fafa3ac49f388494797f91 +480305a9ebfaf3cf3f0fed28f1e04fc88ec48b8b8be1ddd64a44e293274f7eccd2200882f8ec40f5f3601850398f3d54ce044110e38e567df0f491f9e9b8d7bd +f1b36b85a989e7bff4b9fff0d73f58dcd8ad578a96a6f2b8ad8a252b295fac2549b328cb52596ad4cac7a7ebad58fafffde47ad775a70acea3d38d138d9333ce +cc92b7fefa8f7e9086d1d44cc3e9f5e22cd37543d335e6731e3833ecfb1d288e6dc671522c38950aa45b7a6466ba522ec2cbbeb7b82cb151765dd66723252beb +1b9aaa964ac5d9e949ec573ad89faaaa8a8c70a57815cfd7935a15651fc5c9e6e6161fae99a4098b7b2006d6e5d3ed241eab594cd1ccd75e664bdd72445f501e +9309873ccfeb5fdb49a40110979393938ee3f4772501d775f7a901a15969dc3e4110f711543f0f866195f3b841e54c100441ec434b2de3c85367bc6b0b86aaab +893a57af141cf3a7d7579f7878de5055c754157888aeafab5a2267bd30f083309632d3b69ba9f2e3a5dbba923d3d3f27474aaa147b66f93fffdd8553738de353 +b59b8b8bb796d79cf9a371b773e75972263dfd2b5f19f6fd0e1453d75545312d136a8cad8d5c29dba6eef9c18dc5653eaa8e07274cb366bbc397ab61b16d24be +0aae08c26c592cd272c1b12ba5a22416cb51956eb7b7b4721b4250de7ba02efc6e3fa29307c24e44663e7861fd3befeab0c5f5e46347fb5382833a123ba1473f +69791104410c0aaa9f07c3b0ca79dca07226088220f6a149515c7c784ed9d93963e8b79bddf5ab4b4f9d9c7ded67b78e366a9aa64d144cc7502555e9b96e98a4 +7016611c8659da96d47ff8f942bbd33d7be4c8ed4d3fd635abeaf8cb57cf1e997df4a9739519e7bbff7071756bfb29db0ea03da238dd9b0c365688c567e11aa3 +38ced85ab5dc772a8a184e877fe15e7942a6d5e053d952b4dc9deec557124fcfb3bcdb079b2846968e856bfac55a8599187b2756c195e5679e7946da5b9f79f7 +03c2e132cfcd4781aeafafdf35816ddbfd72334fdc6ab5ee32ba4f965757575f7ef9e54f545e0441108382eae7c130ac721ecacd0e112a67822008621f9a2a4b +7645571e399afdf8bd33678e5b13858938bc7463e5c6e2e699d3b3dbdd20b2f52c8e1436642b4ba43493f12a2d6eb5dfbeb9d270ac9f5c59ca1463a258286ea5 +27b462e3e4c36bcd66b154354d7ba7db9d6ecc84c8b8d7cf30ec9b1d34c562116e328e9285854538c58989da64bdde6a77ae2d2cc195964a25db76e034a32884 +3bad562a13f509b8e4a5d50dd7f7b55893950e73d5b2529fa8e06c9d6ecff759409d92c372b97ed0eebacc0cefcf8127b64d03be77aa3ee1164a12578a109162 +ba66ff42ca62235fba298aa283f199b147c46dda2719714e11db39df93e7650bed120441dc2750fd3c188655cec3badf6141e54c100441ec43cb542df0e4ac71 +549b8fb4d095744b8be32f9e9af98f6f5e39365bb72cbde386a626a9b21485510685a12a992cdd5cdedcd9ed3851f2f0d113c72b55533333590b64e9add5eb99 +ad9c3979a45a2e0571a2f3a16068e5c3af64e3d79fafaa2a94189b7e19042c90329f54a9eb3e7f9e9e618f61e8e2497a2225d06d866e487b3d33f9704dfe709d +7956b6400e17859aaab0c56de5f7e93ff6889d0553904d43efed056db26d5b2cdde4fb7eca1ef0b33d22e093589f89a537cd7dba301f0eeaba6e7f9466bc15a1 +a1d8803e5515b944e4e7c194274110c4a705d5cf836158e53ca4db1d1a54ce044110c43ed082b71363268e12e9b12969eb76fbeacf6539b23dd681fff3f76e7f +fec1b92c495549e97a7e9c4499a2163435c9b2a58ddd6ac17ce28159535797bcdd289577fce8ea4ed3b6ac17ce3f018d313733b5dcf5d92a2faa966509444726 +2b1f7e39a345b552de73a049ca822db11e95388eeab56a9c24f0c12a1bf4263be5225bfd5855d7373625aef9c45838312cb3dbebdd5edf92c44a4b929cb2004e +f0c772c4bb6e8421385dcb302ae592aa28508a12df8df37fe52b5fb12ccbf3bc575e79a5d3e9601b7bcae532b6bff39def6c6f6f63cf534f3de5b007f67710a1 +9ec57a4eafbefa2a970e7780b9ab57afe2f22011e6e6e6a05071b4d168d08a7a0441dc7750fd3c188656ce63069533411004b10f4d331cb334a5a7291c405a9f +b1aa53eecab21cdffcd52f68177eba502eec1c992a87bd4896323f4a25b4d82d3395552995ea25c7d49540f277e3b0ed452d2f52b3f8e1e9aaaccad756d7166e +afd5668e168b0529cd0c4df37bbd21f6e7ffded79e65bd258aa2cacc6f2dafaebbbeaf6b5aa55c8487ebf65c3fe0cfad350d6fe11143eecf621ebb06eeb05a2e +f1f969ef032a6a6a6a0a420a9a0c824ccad8c0b684f7b48411f397f589eadcccb4b06bea3a0efce467efe6762dd980dd56abdd6ff7dd3dbb62fe9b6319b08b72 +dbd8dc3e6857d534e677f7ec7abeffced51bc26ef5d4e7b101f9f8bdef7d2ff7cd6c815cdfc71ef1b6ce116b2fe39c86619c3d7b368fde8cc4ad56eb5bdffa16 +3465b55a7de9a597a01791fdd2a54b382d04c1caca0ace0c3db1baba7ab81f1e418c1943afafc6c4eecb5ff957126fd8345b2d9627627f49567864ee11d482d3 +f3c5fa4c2108e337debcd96efbbd66f7fad5db12ef519f51cb2c7dc81a3cb38b3bf36fbfa71ac6132fbc509e994125b9b5bd8d344bcde686d6c5452e379b411c +3f509bfa95fa09d4abd572f97fda62eda8c1d7cfc3fa5e0dab9c3fd28fed1018faef77c07a6340c54a1004417c7c348557e1b2c2067d65695279f8b17862e6d2 +0fde7ce673736ac1f9ebd7de4ee2646aa200bf9349b2ef05ae1ff5bcc836b48d8ebfb0dd39355d3e567732498d3345d12d3f91de5db9bdd971773abdedee8dff +e5dfff69a150ac4fd59e3c7fd6eaeb9418309998a6c84746c233263c2aa022b3c7deb8ea646fc41a9bf788b77ba10478e840f6f823e1f16924a97f31da4c78c4 +6c6fcc5bc69f7ff3ad8c451ccc58049b61d97ddfbdf350bafb6678f61fcd0fdd35cdc19dfbd20f7d5028418c18e3565f7d16ea49717eb96f6171bc531559e5b1 +cdc4a9455d992f3e2ef767646964b92f3ed99dbdb8e6f79f5f3a100c7f60f5f33897f32019f3df11411004f1d9418b7cbfd3da9125c52aa0319fa95978e3edb7 +fef27baf3cfdc8fff6c1a3f5db0f1f79ebe78b8f44d3c5a2093711477110845194f851b4d1ee199a325d2f972b455d537b7ebad5f16e6d757a419a64921b2069 +effff93ffe0f673ff7c4b199b9e585a5e327e61ffcfcd9a1dc64cff5e08e1445d5750d9ea9542a3a0e5b2ad6d4358801552916f93388344bd9c30c5956d86282 +2c971f0478cb87c1ddf1ded8ef389669186c022476b1b96eb1783c1ff3c172aaa2b09e0459d60d635876c55d33fdc45763c686aeeb776d90ab77a6f0b1fea283 +09901787fa67782299d007b8111c82bb775d97eb0a594c342508e213326ef5d570eb49019a340b2b2b9d5ecf30cd89e9699cf6f27bb73b375dd86c6d7b519416 +2debfce9d348b975eb96bbbb9ba8eab66de3a2bd2cdb8a639c76a3db0d1ca7db6a2d5ebf0eb35ddf0fc310eda7a22625f88bbcf7b6b670daf9bd91f683af9fc7 +b39c07cf38ff8e08822088cf145a10f8eb8bb7223f9a3e3263172d5dc9fcddb666386f5cfaf96f3ef7d4130f1cd9dc6abffed39b47a72a33f5b2a1b2a7e49994 +ea3a0bc1e247c9eda6dbf233d4fc5d2f68ba68fcbb902e5e189baad26eee56cbd52bef5d61abb7a8caabafbcf65ffddb7f3b949b6cb6dad03a86a13b8e8dcb9e +9e9a841e4a9324f0201e3208294367f169d888c724b12dab526143fed636b776dbed244e5876bec88c5857a65eabe04ff49aa030e228eeba6c6962563259a6db +f6cc4c03ded1f7fd66ab3514bbe2ae154569341a3804a367ce9cb16dfb60e70f9ba7b727132dcbea4f202679160a8562b1886d6642d7719e94cfbf1073f93a9d +ceb7bffdeded6d2831fbecd9e13cc421881163dceaab21d693f25e131987ae2e2cdc5a5dad4d4c3c55aba1aefba7ab8b3fbaf99ea1a90f4e4f5bba5e2f97bf72 +e60c12ff6c7979b3d50a0ca36959a80ad18c4665a8caf244a7d3c5ce8d8d77de7e1b178f06166b9aeb5ae5d894acab51e8bebbbe0eaf69dab6c427cc0fbe7e6e +ee2c8e57390f8971fbfd0eab9c098220880f458ba2786363adbdbe1579bda3c71bad9dd68d2b37ffd9134fbcfee39ffc175f7cd436b4738fcc8671787571636d +a7abe94ac1d06c430de23849d3cd8e27ddde75cc6e14a7419c84718aa67e9464bf7aee89f989c2bfff8bff55d7b5894aedbda5854eaf73fac4e961dd241b7bc6 +fcd5fb8647624b4c6f63a3d954550c73144328c5783636a2520c0a541419e2893fd6de4ba5f0b0c74c51b1c16eb224461cf6f7b8dc19f3360cbb6203a9e1e685 +83af542ace07cc9bf8a021a3a20bc8e0283cb2aef2fea03b62b424b4173cbdcaf9581f0a41107765dceaab61d98df879a2942d12ceba285555c4ae432b48e213 +a47555d114058d721517b937861e2745b6841b48b8a5786f0d3c89ff898a3195e5445c1dff63bda47cfcf330ebe7b12ce7c1336ebfa3c32d4d822008e213a0b1 +ca5d91c2a0bbbbbd522acb3fba746be9f6dad4d4e4647de66ffff127cfffcae7b675f5dcc3478fd60b2b1badadb6db76fd8d56144631bc4318477e1cd986254b +a91fc1e12ab552f999734f3df785cfaf2eddd034350ca356bb55abd63c3f78f7da9561dde4ecec0c7c95eff99d4e07b71b398122659e172c2cad2469a2e342f9 +2a448dfa84691abbadf68dc565e42a159c8265a64c875912eb1be96e6eb3f8344ec1999c9a6c77ba6ffffcdd2882f690cbc582c4e405f3783a0f57030f1a04c1 +b0ec8af0ca70c0d81693e97abdde9e7cba83e8f09178bfd0c112c3c93dcf83002d140a96654129e20c125730f918516c84618834109748838d43faf80862ac18 +b7fa6a5876ffd35b6f61bf2ecb16afd3668e1f6f1c3fde09820b57aec0bd6959f6e0d4145e1fea76ed389e2d95c4a7b393242b51e4a7e9addddd485162d85014 +5d51a650436a1aab277935bba2694d4d3375eda45e3274bddbee6c6fdc627df8e5b23433230da37e9e18b7721e12e3f63b1a5639130441101f8a6668ea6ca361 +46bee518b2acc7511245e1d6ceeef123c7ae2edf9afcf9c28347eb599a941c73b2e2941dddf563378883288ee234e47df892acea1afe8ca2537ce8e4e9474f9f +eaf55c298d65450ee318f26273771b87aaa5eab06e123287f509c431ef4e601165e0ab922476f90036383f8587c69dac5590388ca256bbc37299281b073e4dd5 +15a826cff7850e53a12a4c53f3fcaeeb8561649946b1c0a7bdb1934b8aaa66a20b820f8d1b8a5d71d71079172f5eec76bb8661acaeaef6b7c321229796969000 +22727e7ede3830c54ef4323dfdf4d3d09110913ffce10fa1ab90b8d168e87cec9f4806738f3df658c2d7ec79f2c9270ff54324883161dceaab61d95de3e1df0b +9a56314d992d4b56b14d336ab737bb5d78aee942a168db5a9a16db6d270cd104150de83049dd380932c983a7445b3a497c594605ca1a3db80511ea2ccb3c596e +298a252b218b31a706099b2a8f7b09f602ec0fbe7e5effd99b6358ce8367dc7e47c32a67822008e2436155f9ccecd1121aea4e51b66cc75cac54ca3bbbcd244d +abd5a9d7dfdef03cfff4d1fa64c941e37eab1dc18b285266eb8aa52949a6ca99ac30ffa1159cd2647d7aaa560b82404d53df776d436f7503cb32d1c8777d6f88 +e3bbfc20804782af824f62a31b71b97c1ca318f8070766417ff0a8483c9a2fcb2282d1647cb89a78989d26a9e82a81fceaf67a70873849a667aa9a2f81c3a208 +f3c96ba9242938e7b0ec8abd780ff1d7e97420139bcde63e1db9b9b909818843a5520987de37d2ef4e181e0722b256ab4189e23c38037464b158dc273ac57053 +d1b3f4e97f7204317e8c5b7d352cbb0599870ecdb216ef93dcddda8275370c6b8502dcdf917279a65894783472ec746dbbcb93551ab57969be9766d777ba5992 +ea9a868a0f2e70bbd7435b3474dd2eaad334554db3ac698e61ccd76a68d6b6a248c7f52b0aee535ccde0ebe7f12ce7c1336ebfa341972f411004f191d10cd32a +d71ba669ab8615a5d26e733b4ed342b1e0ba1e6aff4ab9fea36b5b3b6d6f7eba582e9a86ae988ad2f1982709e25449651e7955b20cd53135f8953489e1005aad +5d3ff02c4373b52489a320f0a6271b9a32b476feedd5db101170637084100a966595cb6531bd0fce6a6e76f6d8d1d9840f9e4c533e93908f99c4562aab711ab5 +db6d2483fb34b9845a5fdf6c365b7072a582c36e696fbca5aac86ccea02427ac47423e716ceeeaf51b43b17b9b3f61c7c7018dc89c3d7f30df1f0f9f797dcb12 +87521edf48e2b19ac5b2bd22a56ddb5114f93c9a713ea3523cbf3ff8c8468c233de48f9120c68271abaf8665d7dc6055d656b7bbd442fa6c617bbbe57935c739 +7fe2042ee3d1a9a9072626d0a4fc49a9d4441d582c6e743a68e2cc3f76e2f4b9e35b6df7adbf7d4bf20234accb86013f787563238863348a0aa5122ac412f6ab +6ac9b69f3e75aa52286ccbf2e2cd9bb0bfdced8a4f79f0f5f3b0be57c32de7c1336ebfdf619533411004f1a1689aa1dba5b2665a7000f5dac4234f7efe95efff +6db55a8fc2c80f7c3f490a4ef9fa5ac70b3aa7661d5596abe58269195e98b0487c9914455021a96d5abaaae9b2a44a99ef7bbedff1bc00ef4cd386fac099dbed +e6547d6a583799a4f99aaf0c1e71868525c8f8f36c55552092942451b80313cbc7e69325b33b03d5ee64e4674b84f092f9fb5484ace186ee3c26e7116b347ee3 +43b12bf176bee3382fbef822142484e0f5ebd7a108f3a99bc83a3b3bcb9d7a78f9f265387e6882f3e7cf8bd59844f06788c8c5c5452440b26ab50ac50005b9bd +bd9d4f1ced0767be7dfbf6cb2fbf7c981f23418c05e3565f0dcb2e9fccce02d4a83c80190be426628cc97b81c9f8df5e36de912eb347db098f4a2ef7a741bb7d +6f9bb5c6f7aa5ab92f6859ffa2f1d230ea67732ccb79f08cdbef68f0254c1004417c44581c3e55d7ef4cb79233299335dd6a759a710a57c0ba0fda9d8e6d992b +3b61cfef3e7ca460198a665b969eba41142799a9a1c6574cc3b6eca2a16b591abb3d37f2bbad2e8e27f0316ca89894a99ad1ec0e2d5e0bae013e8c0d57e35223 +4e522f0871e30f9e389e66691845ef5ebf019f05a5c566b72569a95844aec9896a63aaee7a7ebbdd6693df6cab5a6513dbb86891e1350bb625dfd9661d29ab6b +ebbecfee5104436a763ac3b22bf1a174785bafd7210d8320585e5e6663f964112c97bd8a61a2300d5f8e04a2ef48446fae542a62da2744a4ebbaf2de3acf3127 +fc80f190148f87203e15c6adbe1a96dd7ff32f1e436dd8daf637565918bc1beb0b4db78d76a8172b68d558b65da956a32499098252181aaadae38dea57af5c5f +dddd5615b55e28d60ba5e942e148b18826901786719a1aba5e2e9570feab2b2b4bdbdb86ae7a594b97424fea8979cf791374f0f5f3bc3d8ee53c78c6ed7734bc +92260882203e044d620bae5a7e18fcec9f7eb8b3b8fcf68f2eadac6f4c4fd67dbf532a9603dfb74d1baf966934dde8c70bde892963b298e99a51b07436a58ec5 +5f951455d335e65dc2c08da32e9c48db8f82282a58455337cac5c276bb97c6438b8b631a062e550c7ac46b9265611c6363ee48039eeaca8d85e5db6b125f8208 +b2c3b6ac6a85f9b94aa954af560c5d439a98af723c3151c3fe84cf24d4356db25a66816d541587e224d9dcdef1fc20db5bd0a8e7bac3b22bedcd98cbf6d0755d +4cf214119ef38e23bed40e1bf30999c8c31bb1197ad08ea22b096f73f529125b9675d7f8cf04417c5a8c5b7d352cbba74e4c49b2d4b6835a524aa55491dacd9e +e246d98dcd20cd58447154776a92389625f36b8bf890f85beb3b57566e176debc9d3a7d1daac394ea354bad31dca07d557ab555cd2caf6761427317ca114c6b2 +924a91e811ed5f946cc0f5b3a907e359ce0366dc7e47c32a67822008e243d174c3f47aee7ffcf67fd85e5ab56d7b7d67b7ddeb950ba552b1d4eeb4d1d48fe25e +a552e974dbb669f43cefd6b6d1f1a3f9ba82d67bcac6e9b3255733898da34b93308e205322b884367baa2ec3fbc2a3b43c7f6d67a7513b3aac9be49166724d95 +e1a2e0c232594a1325136a806b25450c68e393d932114b568c82bbb364ef2fd69b150a2d8213e50bf66a7c5aa41826a7728f285ce0b0eceebb7d31d413193dcf +bb70e142a7ef013c76cecccc0865b9b3b3b3bbbb2bf3119e62255e213af3c450635ffef2974b105bb4642e411c1ae3565f0dcbee8dab4b687f46ae12fa2a4ee0 +06891fa6417ca72bb8e7fb5bed361a36dddd5d36e119ad1cc7813bd3588347b70ca35e2c9a687f160ae54201fb777b3db6507c9a86bc356ee96abd643996d171 +c32493b6fc789d5f59e7407ffbc0eae78b7ffd1fc7b99c07c6b8fd8e8655ce044110c487a275dbedfff4fffe9f17ae5d9b9a9a7eeff6aaeff996a1af6e6f1e9d +6e689ae67abd72b9d4eb75cbc5f26eab592a143bddceae52eeaef827a6d29909480ac5b41c54f9bd5e2f8ea28c4de34af16fbbdb83cb28da05388585d5d58445 +071adafa2b7ee0f3f83491e7fbf075c1ad4559914dc338363ba3a90ab445cc1f7bd7aa5543d783306cb5db7070dbbbbbbaa6b89ee7ba7ecc86b9a571cc6ea1e0 +58b669b87eefd6e2321cdf44b57c74661a3eb131599fae4fe8ba569b985064e5d6d272a7dd198adddefb6f1f266cdb16fe588c02cd7d3336f2f84ff9c4ce8323 +f08526404a88c86ab5daaf23c9cd13c4a7cbb8d557c3b2fbdfffb7ff0155d9ecb1e3a71ffd1c3636763cd74f5957329b1e2edf5c5f5fdddc44a3c7bb7e3dedf5 +8a33338dcf7f1e159fc163d74f96cb5f7ef0c19265551c070d51b43c5fbb72054d7454a699eb22fffc6471ae3e87a6e7cf6fed4449b6b2d37c9bb7c94b3b3b4f +beffe31e58fd3cacefd5b0caf953fa397e6cc6edf73bac72260882203e14edf5fffc37cdaded93274fde58b8e5f9a1655a9554ea05dec2cad2d1c6912c0d5cdf +d3d892bc49bd36b1dbdaad556badf6ae64166e6e665baded478f4d9bba9629aa65996c0e5818b37e0928912864e17714b9eb875114daa60def33ac9b14c16992 +e48e0313828905264e6259d6c4e36c89f7ab98a619c571c497dec56547212e9e793e3e1c2e09f97e3bd1c533ef4eb78b139a862ed28b456b0cc310f306d9ea03 +43b22b0c61238f812fa6d2e5919973f1271ee7efebffc98f8a07f6191f239a72011170f2f477cd4e10c42761dceaab61d9f5bc30cbf83a64bc12133559ba5799 +b1261376c4712afec482ed7bc395915f475daa6978650b8f890f4ec433e3ebba73efa7c027c64916c56994a601cf1eefc5cf1f7cfd3c6ee57ccf3fc04fc8b8fd +8e8653ca044110c447406baf6f4d4e4d5d5b780f7eb7dde9c42c4c8ba7a95ab5545e58597ce4d4e976bb552814e12a74cd4423bfdd6e170b95280e50f56f26fa +77df7cf7d9271f3c353b1166a994a57cc4d71d6161b3e97666cfdd3275339332fdfdebfa0e12b8343ef451726c1b0a2160cb02e222256cc0b9c163d5aa158545 +13d43555b10cbd5870c400b89ee70761c89c195f3c96b9c92c53f97c42b6d88094ab313619106e12620dbeb0d56e230b135e43b2bbb2b222edc5581633eb1a8d +06bc3b0e55abd51277cfe20cf8bcd6d7d785ffde479e0bc2f1e2c58bdd6ed7719ccb972fe7e3427112645f5b5bcb3b9abef9cd6f1eee07491063c0b8d557c3b2 +6bb22392823666928806a408057fe75380cfe3cbd42d4a92a7288ee7ad2e2cb0fd5134e538b6a2fc7465c5d434d3f3ac5e0f2d757366e658bdcec69f076cf632 +aecd0b5c4956268b25bc6a684af189e5709cc3aa9fb5312be74ff62bbc77c6ed7734ac72260882203e146db7d55adbde5ddfde2edad6f44475a7d54934a3d969 +55cb15dbb4d737b71a93933d171aa2d8ee76aa9572b158e8f53cd3349334beb5bcbcb4797b697beb571f7bf80b0fcda97ced9c2c93d32c5515b62e4e1c6b9aa6 +4b72cac2e444438bc7de6c7720232627aa27e78ec24bdd5c5ceeb91e9ce2dad6368e9e3a7eecdccc34f6efeeec465128574bf34a039e6d7175edeacd5b506196 +651ab291c4b1cfbb5f2aa5d2fcdcd1dd66f3da7bb75236092ee5e108e1052388b66ecfbd7213fbb34ab1302cbb79c865d1b783cfa0582cc2cd635be588a3320f +c99397d2c16e798848e48223c70945cc67cff354be32439ebdd56a7d5084678220ee8171abaf866557e3951e3c56c25b86125fad2d1fe6ce1a494982d7e52ceb +c8b2edfbdbebeb383a5d28544c13766f6d6db17e78ec5c5e4645f9c5e79faf95cb5ddf6f7a1e4edb76a3663730346d6eaa868695dc6c86bc49b49e65cd21d5cf +7a77bccaf953fa397e6cc6ed7734ac72260882203e14edd6dabaa6a88e6d5b8e9d44d164ad2a375bb25cdddc5e9faacfb43aad9edb2b168aed4ebb569d68b676 +aa9509b928474110c6121af9966142637cff479797363bb3f5aa6d1a7ed053a4446201729803d0352d8cba25a7ac0c6f1eb7182a28f12564d9d2af7bbbc5a368 +45550c16a836c151b6b8ec5e8019890f29dc1b3ec8179be5e7e24fbd15315c6d9f9610816d443cdb4cca8665b750789feb55f672f547cdc9a3f588b72ca09165 +f58fc1134349c5360ee1e478dd177707db8ee318c31ba94110a3c7b8d557c3b2ab9a266c2822403d0f4eee45911890861dbaca567e8f5475b258441d77c72eef +dc4cf9558bb1e529fe14057f2ddf977abd208ac4e278529248118bfdde0bfc20d53dde29cfa69dcbf2b0ea67bf737bacca591a12e3f63b3a9c52240882203e05 +b4638d4698645ee087816fda16dc019fe7b6532a5576dabbba6ef4bc5ea95072ec42b3b93b3131b5b3bb35519dd035fdadcb3f2d5a0e3c8465586912bd73ebbd +abcbda4373276627279b7e6f79db2f944a1af7089572ddf35cbb680feb268f1d3b0ef7e6987ac207a44d4fd627923849d24e8f2d50b4b9b5ed7b6ccd5dd77379 +d7421246318b0f1c27106470989669e0552d38a661b1d3c9d9d6f696ef07335375765afbce7d094d863d38c40c55cbc3b2fbc20b2fe4f72ea67d5ebb76cdf77d +f86ca105b3f7c76ac65bec7feeb9e7fac77c8a5c48067170eedc3911f3d9b6edfe6e25e47af6d967f14a53f409e2d362dceaab61d99d7ce411ec12ad6e6cbcb3 +b1b1b2bb8ba6e6915a0d277c6062e278b58aaaf085b3675107de585ffffb9ffd2ce53396bb6188d66989b7ad3625699579cdf8dae5cbb2ae4f954a5f7ae001b6 +d2f8ce8eb7b09068dabb9b9b31debbaece07ab7f4ed76786543ffff0fb7f3156e5fc69ff2e3f2ae3f63b1a4619130441101f096d797d4351b59edb4b2599ad9c +d7732545999aa82b8adeecb465b6808ad96ced34a6671559ea74dbf589c9d0776f6dec76dd5ec1b6e08fd974fd2872d8c3e464a3d5dee9743a5ecbf7ddc2c451 +433343bf9dc471b9588ee3a18dee9e9e9a4ab3544ae32c66131d6b153601d20fc2aecb06feb5dab8e2aec49f6af3c96c41cf65e3d6cae532fc9f2c4ba6cefa06 +6cc7a9d626b03ff2dc4ebb838cb50af370791f8bf07f6c1465c4020ec9923c3d353914bb55c8a63d60115a301f0b2afa8e72059977fe6027ecf6c76ace73c97d +1d50fbdaf338845c8ee37c4a1f14411063575f0dcbae6a9a2c81a68965c38238eef159caa253545355db602d9f7aa9649be676bb233ad0a38c4f51462d9a654a +964559e6f38070a1ef676128b2a8bc9f39e3e1f1bc200855d58863894f6c36b26c58f5f3b0be57c32ae78ff193fb5419b7dfef604b97200882f8186896652671 +522e571657169b2d49d38d9edbad962be5527126985edebced29fed4b1e3cde676a53a11b59b49182d6fedbeb77ccb3159781dc7b47daf532d4fa1f2370c2b08 +5c45562c536f7576d4d03734a35aa975dd365c8131bce7eb621d584592953d392510224ae98b198b942a1fad26def2f0b36c189ec41d9b982d99edad3dcbd60a +cc32a4cf1d9dcc9da82a06610ecfeebe8597443466b11d45913809ce295eef5c4096b9aeab695a7f7f11128b04c22276e6119e452e5c3072f58f2f2508e21332 +6ef5d5d0ecf25aeb76ab75796d4de20dcee3f5ba936547db6d342cb5286a6e6fabba56ae68895e30ecf8ccb109d6b51c295922a3aaac552ac852d13483072873 +250955aa264957d7d771cd6b61d8b46dd4b65b511444d1e7eaf57ff9d453d87fb4acac0da97e1eb7729686c4b8fd8e08822088cf2c9aa91b8992c0333cfac083 +3dd7dddade993c32ef7aaedbeb146ca75228ed769a5bcdd6f1d999e5d5c513f3277e76fdbdc5dbabaa9299a619c76112c7a66e2671689a4e1205b661a3b5df75 +776549714cc7846b9694348e3a5eb75e9b1cda4daa6a224b95527976b20e37b6b9b51506019c9ec5a209a686ae434cc0a5e18ea0937abd9ebeb38b5c5e10eeb8 +1e9bcc5674141982c96f365bd85f2d158b8e0d91b5b0bc0a07c926c289596dcccd4a86a11f9d995614360a6e58762f5dbab4af04c49accf0dfabababb91717f2 +0b6fd9537fdfbf70e142fffccf7cec28dcfcd2d2126425ae767e7e5ec48b1269e4bd90d1e22dc5db27884fceb8d557c3b29bf658d5b7da6abdb9b484f6f1178e +1f9faf562dcf3b8ab74912efeeb6d1bc310df7d1e9ac949a4efac87c1de731225b4d7434a50aa5129a3a0eda54bc425c6fb783284693e81a6fcd76a2c8b52cb4 +48373dcf8be37ffed043bff9ecb36815a953e97ffd0fc3a99f1f9d298d55391fc66ff3a3306ebfa3619533411004f1a16845c74155ce66e707b1a2a8c7e64fac +afdfb60dbd56a9aeaead1b9a6e99f6cafaeacc44fde4b1e33716d7d7765a9665ea9aee055ec12a64596a1866cfede8bae15825f88f2060cbf299acb5dfae14ca +7030f58969b5a5eeb476867593fc397666e846b15884ff6bb55a6912c7c99de7d9b8668d87088242c2461445e26de605d8ce523581a8507ed1b59238160b1194 +663e8a8c2ff69bc383d264f07ca25f6558763baebbbf04ee7868b6d272c8c74cf66b4171a8dd6edfa5e8f80a3add6e179a52d775c8cd7d5df7fdcb351304f1c9 +19b7fa6a687679e0770d0d2116094eb175dd860dbe885d26cb29ef37467a3788122f4ce344e22d473f88b22846a3a95c2b6b1aeb1695797d0aafa8ea4a9ca451 +18f3fe5245e3375087874d534b515aa860d1fed4537748f5b37ca43256e57cb0b806c3b8fd8e0ebb3c098220887b466b76bbad4ed7f3bd4ab1542a147dcf9dac +4fa189beb4ba343dd9808e08e33834c32b8b3727caf5e5cdb56aa9ec075e9a46a54259e122c4f7bc6a79c2f5ba3a7b60ecd87621085953bfd56b1d6d1cd5142d +4b63c72edcf1dec3c0f5dc34490c4ddd6db6d22cedb96e1884b82f1e9656c6559b069b53c096955555d3300a7c42a3170472c85ca70a91c186c229ba88182cc9 +7ec8b2b3437d1d2f6275596cfb6c9ea08ab30dcbae70bd7815cfeff37210333f637e06c7715810a334cd85e0bec4fd94cb6558c6e79bafff74781f16418c39e3 +565f0dcb6ec13050dfcd148b8f4d4fa331f46b0f3f7caad1e86e6e2e2c2eb266529234e31817f6a37fba8a36f4895af5999327d1bef9a79fbebd747badd1a8ff +db67fe75a55af2347775c3d234e5fc93f385a2b9b1d37bfdf2629266a85e03c3283bce6f7ce10b954261e9bdf7fefdb7bfcd1ab6aa24fff35f9586513f8f5b39 +ff777ff8df7c825fe1bd336ebfa3a11432411004f151d05aed56bbe76deeee2eadaf9b8679f2e8bcce6606ca33d347769bcd6aa522c96a14276db7b3b1bb95a5 +21fe8a76314ee28cadd7221449318c0243d7a3c86f4c1c71dd5ed76d150ba5b6db7e6ff9e6630f7c2e8c234db7d26c68edfcc5855bd013eb96797b6d1d9e2a81 +724a5345558a8e0dff572c1684c3834262a3d7caa59929366ef09d6b373dcf370c9d45a3559452a1305d67f169966eafaf6eeee0849ace5c1c64195fcae7ce2c +b8982d57bb03bf3a3951dd59db1c8a5da9c8f640179e3973c6b67fb1cc41a7d379f3cd37373636a00b5f7cf1c5c9c949d7752f5cb8d06eb791b8d168e8076228 +c09d63e7f3cf3f6f9ae641614a10c4a7ceb8d557c3b2ab2a65163846d32c9c5996cbb65d750ab2d9166d9a384dc3344d24a9d9f55d2d9ab40a72cada3baee7ef +b6da859265d89a53d44d93358ff07fa564572b5610a1a1a5c5498ad655aaaa68981e9f98982c955acbcb5b5b5b77da499cc1d7cf7ffb677f3286e53c78c6edf7 +3b9442260882203e0a9a6517924c820bd869369750b13777e7678ed8ba1a24dadae656ddf5e667e75d3f0ae3d88fdca25340935ed37455e1515d0c83adcd9ac1 +47cbe542052df94e6757d76dcb8476c98a76697d77a3d3ebea4896849a3ab4e7bea9009a80479461979c66b292ed0d29644b11f3d176ecadba379b51d9134c32 +9f9a86a379546476b60f901122164e3a54bb79768793876e12ae3a08026c944aa55aad068d982fdd8c6db1d272ff90516c434142718aa0cdfb46931204f1a933 +6ef5d5b0ec6ef77aac56ecf56abd1e4e9b84dd5edcf694489a69c851a287811586b124f971dc0de0fec4baec52b15c9e9c9e764a955b8b3bdb3bfefa66274c92 +44cad6373add6eb0bad35eddd941fbd3d175138e4f962f2f2d154c73756bcbe197a7944a9dbdcb1e70fd3c6ee57cd70b1b00e3f63b220882203eb368aed7f5fd +a0542a574ae572b1b4bab9767df1e691e923a6c616f2bdbeb2ace9ce646da2e376d9602d294db2248afc92539664161747d5d92841ddd003cf2dd84545b5d8a8 +2e5971bdb66397a2cdd595cdd5874e3c0c77a1aac9875fcee1c086ad49729a241e171c1395b2a16b7cb162d607b2b9b37be3d612f37caac21e58948a4766a624 +368a52b678c41a162449927d4d1371ec4b05dbd0d4244d3bae97b178b399caa7b1ad6d6e8551c4c6b3f93eca8007a41d925d7ed72244733edc0e863ccfc369a1 +17f18aed6eb78b0422d4b308ab2be6e6295c0888384f22bb58db392fcf3b1a8246ef13c4213076f5d590ec2eeeb69160b2d79b6f36d1be89fded9d48f1f5547a +f041b83ad3758b9e873677fbead5ad5eaf53a948bc1645e3532916354dfbf1a5655c52cff53c344d23e9facd2db49d6eb75a3f5b5a8ed3f4ccd1a3139393a854 +fff34f7e825657b9db6da00a55146d7656b4f3075f3f8f5b391feeaff48319b7dfd1b0ca99200882f85034dbb4ca85f2dad6ba246b8e55ac956a96e92caead18 +8675eac8a95667e7a7377ef6e0dc0395723d4913cfef969d72b7d709e34053b44a79320c7c1d8e21f26bd54988904c565daf9b2651b9588363d655bde7755dcf +e52162d40fbf9cc381bb3ff8a9340c024804db321cdb163d2478ed747b8b2b6b327fac9d49d991c654638a8d5b83ffd3b99b8c23a6ae62fc93b00ddb341dcb8a +9344563588295d552cb8c324d9de6d06618804a1883094a5c3b22bee1adefac2850b495f041d88bf5aad562ab170896fbcf18698ffd9e39a808df75b5f9778b4 +9e46a3611806b25fbc7811476ddb86532f168bfdfd4e489c07ecc9a178fb04f1c919b7fa6a587645a7372ab594376378d9cbf94a61d9818672cad76fcf77f2ec +72de73bed7859a8953a83cf29cc4df8a31e4a2bd9e77900ebe7e36c6b29c07cfb8fd8e8655ce044110c487a275bbdd66a7e314ca96696e6d6f148ad5aa59f05c +77bdb5f3deca7b278f9e7cf7d6d5c5f55bc7664f558a754592ddb06b1a6618fae5da54a7bd532c56a3d02f152a7e10a699222b92e394bca0056fc122eb1a66d7 +edecb6b6e7664f058137ac9b14e3d624de13023797246914c7b8560dfe8f2b279dc7ae4bd3446803a808d661b237faf14e57492689a8b39aaadd09222cdf912a +a2534504b01123e4582e5919965d71d7385bbbddee8fdecc9fe5ab62545ea7d3e92fa28c877a96f8acd17c0f442492412fbaae2b2e26db5beaa9d56a89f4fd85 +fc297e640431b68c5b7d352cbb45c7c1297a41703949d44c998eed7a5c8e923095daacbb328a3a9e17b2a1e26cb5f6284d375987a714f00e4c31cf5c43533c8e +bb7c39f19fdfbedd0dc3388a4abc2ffdf146e3fcc30fe30c7ff7d39f7683a025493b2c4c79166f6f4f4877ee62c0f573431daf72be97dfdea7c1b8fd8e0659b6 +044110c4c7420be3a45cae799e1b45497d72badbebb5dacdd9c63155376eaedcb46c074dfd9f5efb89a199278f3dd2edb5ca4e2d8a3d2f709b9ddd5ab1c6a6db +69669bf539682ca45026f7dc161c4394c485624dda59310ca3d56b4d063e1be535240a45072e8d2d06609a9006b737b682302c38cea30f3f809d471a9345c742 +8285e5db9e0fd511b7db50145296669665aa8a2ae2d3b89e77f5c602f67fee91878e1c3dc2c6b6ad6fb0d9700924077bfe7dfaf83cfca1aee9f57a1d4e707d63 +3393a5a1d86df1bb9679582638e6fc89be186b976b4af16a9a66ff98cf3ce6b3e86812c9120e362ccb620ffee3d8711c714e918b85533ad07d4410c43d306ef5 +d5b0ecfabd365b50469677d0fe442d8746b464aaf06112fb0f5712897a8ff715e36d9024325f078e37721453d37416abe6ced262dbaebbd3eba1c2b5793bb36a +dbb3d5aaad8945dfa430cbbaace12ac3138a76fee0ebe7822d8f55391fe24ff497326ebfdf619533411004f1a1686ee057ad025b9fa6606c6caeebba552c96db +dd966d161f3a7ee6fae2b599a9f9074f7ceeea7b3f6b4ccd170bb54e6f379314b8dd388e50ddf77a1de49032c9718a7ee0cbdc355b86e3fb6e18049a6a2848e3 +75ba9e673be561dda4aa69729ae8ba66183a3c561845aee74363f158820a5f60c64e925451e4940f09bc23a1f8dabcece9359b30c9fc1f72b1fdb262db162b3b +5549d92839996b35c9b16db6cc8ca14fd4aa38edceeeeeb0ec8abbc676a3d1401ac330446067cff344f466796f4d66e8c2e79e7bae542ae5e21242f3b5d75eeb +76bb3147e24ffdd7d7d79bcd26cef0ecb3cf8ac4711cf7c77c0ac3f0dd77df1df8074b1023c8b8d557c3b23b85868a24a1362cf086e576b71badaec0fa369f36 +dfec76db9e17b3b866acdb13af2eef7bf73b9dc075635d5fb52c5cf956abb5d66cc2dc89c9c9e35353b1ebf65657d95546d12ebca3ef5b9a96188653744a4a0d +c9daaa213ee5c1d7cff1c6f5312ce7c1336ebfa3619533411004f1a168ed4e37cb14e800c3b050e55b9699a68a6e585012c5626566f2c8fad6f2c9f947caa5da +cafaad874f3db1dbde2cd8a58e1bc1a9ecb476e6664ea7991204f00d1d385945d1923069359b25bb68e896a61861ec166c074735cd1ad64db6db1db8b772b150 +2916ef84a4e5318d583819496a75bacd565b6281671cc7b21cfbce75264c42c4c8286648224ba9586067eb74166e2da7223e92a2667292496cf05b10c54a9c84 +5192aeadb3618aae372cbb72a9264e25d661324db352a9140a853c7a730e5b47a754aa56abb98e845158e4ebe6c6629c1e975291e87d82eec479f64da8c4a120 +0860e5f03e4182181fc6adbe1a96dddf79f43c92747b3d3492932cfb8f6fbd75fdf265b47974bede7bc41bd26cc03c6f0e0551b48116b824b98b8bf1ce0e9a94 +57dbed4cd336db6db43f1dd3fc3fbef0c243b3b31b4b4bffb4b9994451dae95ce593e4271ca7629ab655a9166670194bcd6873af9b7dc0f5f3ce9895f3a7f57b +fcb88cdbef6818654c1004417c24b4125c025bc336f1a005c2c80883384a4be509d37496576e952bf5284d7e76ed27c7e71e5a5abde1fbae6d157b5e374d33d3 +305225e9053d5375d0f2cfa03374abdb6d2769641996acc231c88669c689c783b2463dbff3e19773386c6eedc27b698a62992636f8a36ee6fcfc20c0f6d64e73 +756d4355d5074f1e2bb207de8908210b0719888e051ed6d8b6acfa046b3f6fefecacacde362d6b7e7e0eb932e602996ef302262c907b658d054c42c661d94d35 +4f6c1810527b91999105ea10c251ccf0140199c5b44f11b7599415de22a55887191213c211dbd08e3815b6c5b24f07233923573e719420884fc2b8d557c3b22b +2634abbcb713cde58cb779448599edcd46bed3c0e69f8bd8cef7a7efff6355aba2a8bca52eea4711f29ee79515be9e5996dd89ab2f0da37e1eb772fe947e8e1f +9b71fb1d0dab9c098220880f454bd344d3744596fcc08de2a8ddeda449aa4049287a6d62b6d5de75ccb26539bbeded62b1bab1b33a3d71d40b5cc72eba5edb30 +34d76dd766a69324ee796e1878d8dfe96d415274bb9de9a9bac623b5b2d82d9afa599abfbd175846ba13a1b76f3b7b5fb2bd74079dd92f716eb22c1f545a83b4 +fbfaebaf677c5de5f3e7cf430242fcbdf3ce3b626267b55a2d97cb70d2ebebeb107fe21052e6fd45220d14a4aeebcf3fff3cb4a3c4833f213b122f2e2eee0bef +2440e293274f7ef0a5110471cf8c787d352cbb62ca371a371bbe0f3f552f161fc8b26aa1f0d4a95338b474e5caed9b37555d9f78f451ddb68324e9f065c95724 +6957514c553d5e2ce2e87c1cdb9ea7e9bacd967f0fba51b4c327cf1735ade23881eb2e2f2d05be1fd72aba36032bebcdeeeb3fbd3a94faf9c76356ce1f7c6903 +66c47f47044110c46716cd326d555115494db25455f534cda2346c75dbb669159c495db73adde6f123a7576edf2a96ebbbadb57a65dad42d3fe8b027c7aaa5c8 +6ab3b3abca2a1b962f2b61e807810bc5526143c71578134d53790c97a4541adafc7cc73621098a05a75281844a8fcc4c57ca4578bbf716972536ca8e0d4fc8a4 +64657d4353d552a9383b3d89fd4a07fb51262a32c2a5e1553ce74e6ad52c4ba338d9dcdce2c3269394e912490c70cba7bd0dd16ea7d3115334d3bdb597f32088 +a22f287fe682439ee7f5afed24d20088cbc9c949c771fabb9280ebbafbd480d0ac346e9f203e15c6adbe1a965d8db73fb1b7c357082b5996224933d5eaaf9c3e +6deafa4fd7d7cd34d565f9f491234eb5bad26e5f5c5dc585eccaf29a2c9714e58c65198631ebbac7340d7ece48d3204e823876d31435afcc969b31b220f07776 +dc6e57453bbc71044eb6ed05c3aa9fc7ad9c3fe1cff09e19b7df11411004f19945733d6f6f741c1bf5063f116759c7edb47b6db3dd9d9d3d0dcdd0eeb48ba549 +cfef29b2b6d3da989d3eb1b6d52b164a9d6eab5caca131af9b2c081f9b0b9684e552add95a970c250a43d32ceeb6d775b6a08b35c4fe7c8809b87fd332a18ae0 +9f6a95b26dea9e1fdc585ce6a3db78dcde346bb699fc12316624be0a2e0f3c235b168b785c70ec4aa92889456b54a5dbed2daddcc64dc97b0fb685fffb2cd815 +9d3c1076298fcc7cb040fa77ded5618bebc9c78ef6a74c782ca57d89b1530c462508e213326ef5d5b0ec6e773a38c94ea7b3dbebe16ddbf35cdf2f5a56c09ba3 +419204a8d9d2b41304b1ef3347c97da59624a624e97c6239cedc8de3cd245154b520278692484a8a46ad18e19cf231ea56b128d6286ff91e9b229724c3aa9fc7 +ad9c0f16ec6018b7df11411004f199452b97cbaee7caac2b3e52543dcdc29251844b407b1fad7d63fbb66138866e45691a254dcb2cecb4b68f344ed866b1e36e +eb7cbd1bd3b05caf0bbf8064aa22f7dc1df88328896ae5d95ec016c8d575338923288d61dd249f1ec85c141443c66606721f064d2089656365bea08f24a604b2 +997f6c961fcb261e807007c95ef3ee176cc26fb2747c92207f46c2f38b317062355a1e3a7828769f79e619696f7de6dd0f08871b73f194f258cd774d60db76bf +dccc13b75aadbb8cee93e5d5d5d5975f7ef91e3e1d8220fa19b7fa6a5876fff38f7f8ced9566f3eac606f6246198c4315aa19b9d8e65189bbebfc1961f977beb +eb6ab7ebefee46efbd879357e035f197246d345f356dadd7f37ddf4c93df507bb669c9ba5f5064d4ad12eb768ed19c3af6b9cfe1ca6eedeefee3cd9bb8807478 +f5b331a4efd5b0caf997fec80e9171fbfd0eb674098220888f812625992265aaa276c3aea6493e7b94ae64a9a46ba622fb9b3bb735cd3a3afbc0d6ceed3461d2 +2388836667a7513fe2794dd3d49b9d5dd39ab0ad521487bedf95e4348ec372b1e60751e0bb591c1bba9124b161d8edeed0e6cb158b45b8ab384a161616e19c26 +266a93f57aabddb9b6b00497562a956cdb81f38aa2106ead5aa94cd427e01a9756375cdfd7624d563acc65ca4a7d02da43ea74213858609b92c372b97ed0eeba +cc0cef578147b44d033e70aa3ed16cb58762d72d9424ae142122c574cd5cf9e59d3ff2ded24d5114ed9b6527b4820807b54f32e29c22b673be27cfcb16da2508 +e213336ef5d5b0ecfab7bb2c2a5e187aa8d3d0328c22782fd646e29f025a3d09ef018d45d3274924deae56786039857741637f98a61e8f6d9ec9196b37c92c0b +5e441529b3f0b43adba328229ebcc443e84bc3a89f4f0ce97b35ac72bea71fdfa7c0b8fd7e8755ce044110c487a219a6e14781aa198661da368bbd6f594eca66 +f4a17257e140775a5bcdd656c1a9743d16305f55b59dd666a538a9eb76cf6f3ba69d269922679edbd1751d7e59d7cd4eaf639b1545d552498a92c8940c366e3f +da1ad64daa2abb11360d320858b45e3eb951d77d11d2177b0c43174fb41329817e3274b6f4aee821c9874df287dcccc3b1856ab838d354263714f97d3a8ccf7e +6001864d431f96ddde5ed026dbb6c5d24dbeefa7fc613ff688804f627d2696de34f7e9c27c38a8ebbafd51f4f15684866203faf8944b898780a288bb04f12932 +6ef5d5b0ec1ee3ebba4f140a73d52a0eb583208c63cb307e74f3268cb6ddae5cb21345b9b1bb13b5db6828678621f166278c199af648a3c1169d999948d35918 +5adeeaacec7a921f4c9c3e8a645b49b0f4de7bacf91a4578ddf53cb66c9e2c3f3e3fdf1d52fdacaae95895f327fa117e02c6ed7734c8b2250882203e166c7efe +d66e53563b61189453b9ebbab262f84118c6f0a481a1c3c33aaedfd53543530c3768cb92d2edb57a7eb75a6e443b9eae59bee7168a96c11afc91e7752525431a +dbae86119c44a6c84cb5b8be9b48439bd655ad94f71c5992b2a047ace7398ea37aad1a27097ca1ca069fc94eb9c8ba0554757d6353e2da4b8c4913c323bbbdde +ed75f6a882cf0694d90cc0187e518e78178a30c466091a46a55c521594805dada443b12bf1dd38ff57bef215cbb23ccf7be595573a9d0eb6b1a75c2e63fb3bdf +f9cef6f636f63cf5d4530e7b607f0711ea39e3eb39bdfaeaab5c3adc01e6ae5ebd8acb8344989b9b839cc2d146a3412bea11c4a7c8b8d557c3b27bc22c8afd32 +3fb4e6796e1c375df747d7afc7693a21c795b21da5d9cd9d9d4e9c18aaea18ac5d540e433d4d4ddefe2c58965e948c8a1c46c97f7ae3dddbdb9dc9b27dfef451 +b4b2176eac5d595ec315b2f1d1383f5fdf1e177ffee4c90bbcbd34f8fab99ab5c7aa9c3ff10ff11e19b7dfefa0cb97200882f8c868f333ba9c2aaeefe9050dee +49992ca0196fca68a2bb5a4953e4041e2264f5fbaa5961f3bf34d5a9964b8ac26615968fa08a870fe8e14f2fe9535353aa5a8246814091b245370dac523a55ac +8411fcc7edf993d5dffbdab3290f90abcacc7f2cafaebbbeaf6bb05b84a7e9f65c3fe0cf8f35d895f7ec4a318f2103b7c4edee1f8c0735c3edaa7b76d900b384 +f77870bb527da2faf257fe95c41d58b3d5627922f697648547e61e81e29a9e2fd6670a4118bff1e6cd76dbef35bbd7afde9678cfc98ccad7080899639b5ddc99 +7ffb3dd5309e78e185f2cc0cbce3d6f636d22c359b1b5a1717b9dc6c0671fc406dea57ea27e047abe5f2ffdcfaa9b85f53d771413ff9d9bbf9fd5ab281fb6db5 +dafdf7fbeedefd8af96f8e658805873736b70fdeafaa6911efc110f7ebf9fe3b576f88fbad9efa3c36201fbff7bdefe5be1997846bc61ef1b6ce116b2fe39c86 +619c3d7b368fde8cc4ad56eb5bdffa163465b55a7de9a597a01791fdd2a54b382d04c1caca0ace0c3db1baba9a5fdbb03edfb99969b24b7647c6eeb0ea2bab61 +8d975deb7d761bfc6d52283c54adf6db3d23ec86c17a878d684bf7ba35ffd79fff9cd9ed76e75b2dd8fd2fdf6ff7f119ab519cfc85dda9a95f397952d8bdb0c5 +da5183af9fff0fcf3e3b56e53c6e7a6358bf23f2fb6497ec925db2fb99b5abb1d552d803e0144d7a90294ab237828bcd03c45b8ec47b12d8554a72c2e3b5487d +6bab8a5161199b3b77670c58c69f07f32d3e002f63115d32315d908f50c48181d9dd5734321fc898f5bd551559e5b173c4a9b3ecce0ab3228ddc9f91a591e5be +383477f6b2f982ef3b3f9f4138fcfbcd7828dd7d333cfb8fe687ee9ae6e0ce7de9df37a67448f74b76c9ee28d9ddf78b1b587d4576076f7790f5f367e17e0769 +977ebfa35dce6497ec925db24b763fd4ae162771a954741cb674aaa96ba8b955a558e40305d30ce9985545654f117aaee70701de32fbe99d561df63b8e651a06 +9b10885d6cee572c1e4bc47cf098aa28d5721967d10d036780594551755d43de81d995fa40d12cacac747a3dc33427a6a771dacbefddeedc7461b3b5ed45515a +b4acf3a74f23e5d6ad5beeee6ea2aadb369b3de865d9561ce3b41bdd6ee038dd566bf1fa7598edfa7e1886f81c8a9a94e02ff2dedbdac269e75575b8f7cbfc3a +5f8d191b3c74c25d049f7a670a1feb2f3a98007971a87f86279289ef1f6e0487f075725d977f6f998961dd2fd925bba3647758f5d551d324bb03b03bacfa79dc +be57f4fb1ded7226bb6497ec925db2fba176b5208ea7a726a10fd22409f8bab5101686cee2b5b0118049625b56a5c28675ad6d6eedb6db499c345b6d362c20bd +b3ce4abd56c19fe84580c9388abbaec7750c7336ba6dcfcc347035beef375b2d680ec3d01dc7c6750fccae943f7be6feefeac2c2add5d5dac4c453b51ad4cf3f +5d5dfcd1cdf70c4d7d707adad2f57ab9fc95336790f867cbcb9bad5660184dcb42f1ba7cad635596273a9d2e766e6cbcf3f6dbb8787c504c82e95ae5d894acab +51e8bebbbeaee0c3b36d76c143ba5f8947c46d341a3804a367ce9cb16dfb60e78fcc67338ab2b12cab3f8198e45928148ac522b699095dc77952bee88e98cbd7 +e974befded6f6f6f4321d867cf9e6dee2c0ee57e87f5bd22bb647794eaaba3f53ad91d805d894f981f7cfd3c6edfab21fa5f2ae711ae9fc92ed925bb64f73eb2 +abe5d201ff8861fd6cf480aaf211067c08419689f103195b7d95f91116671562823f46d84ba5f030c04c61b0c105b2244686f5f74064628c014fdfaf57066037 +e2e78952b6182c7bd4a1aa2246114a53acbea3ab8aa628105f2a5b543013674f79ec81841b48b8a5989f971de47ffc9ae45496137175fc8f3d6de1e3288678bf +6203a9f135125fa04aa5d21fcca99f83e232cf2efa9180c223eb2aef0fba236e1f9a00df2495230de97e8755ce6497ec8e527d45760763577cd083af9fc7ad9c +e9f73bdae54c76c92ed925bb64f743ed6abee7474ea04899e7050b4b2b499ae82c5a2d9bc6d5a84f98a6b1db6adf585c468652c1295866ca74090bf7d2e97437 +b7597c38a7e04c4e4db63bddb77ffe6e14c147c8e56281196096259d878bc3150741303b3b836b82c54ea7836b1e98ddfff4d65bd8afcbb2c50b60e6f8f1c6f1 +e39d20b870e54a9c655a963d383585d787ba5d3b8e67f9e2c660274956a2c84fd35bbbbb91a2c4b0a128baa24cf57a92a6f5f0ca3fad154d6b6a9aa96b27f592 +a1ebdd76677be316ebab29978775bfdade078c6d31590357bbe7d6ef203a7c24de2f241d0027f73c0f02b45028589605a5c8ee97f741c97b5f226c8461883410 +9748838d8921ddefb0ca99ec92dd51aaaf6eedec90dd01d895666686523f8fdbf78a7ebfa35dce6497ec925db24b763fd4aec627f9a7389624b1cb070cc098c2 +43024ed62ac8164651abcde2dfdaa6a1a90ecea1ea0a5484e7fb4297a8a8fd4d53f3fcaeeb8561649946b1c0a719b0a71492a2aa997854cc8722b08d38e687e4 +81d95de3e1670b9a56314d992d7b53b14d336ab737bbdd308ea70b85a26d6b695a6cb79d30840b1442294c52374e824cf2a22884664a125f960d496285875b10 +2113b2cc93e596a258b212b218376a90b02991b897208a6cab3094fb15fe1b22efe2c58bdd6ed7308cd5d555b36ff21e44e4d2d212124044cecfcf1bef9f5228 +710d8af44f3ffd34742444e40f7ff843f87b246e341a3a1f5b2292c1dc638f3d96f0357b9e7cf2c9f59fbd3994fb1dd6f78aec92dd51aaafd63c8fec0ec0eeb0 +eae777fee22fc6aa9c87e57fc7edf73bac721e37bf4076c92ed925bbf7605743339f75ebf3717d6280163258f0133c4a108fbaca85059ffc9ff1e101e2e1419a +a4a2eb0072a4dbebc13c4e92e999aae6a1ff7134e39305524952704e3f086019d704db6c94e1a0ec16645d88a356c05694ddddda8275370c6b85026eff48b93c +532c4afc810776bab6dde5c92a8ddabc34df4bb3eb3bdd2c49754d2ba0701565bbd7832f0c5db76b9ab81dd534cb9ae618c67cad06b7da8a221dd7af28b8cf61 +dd6fae0521fe3a9d0e6462b3d9dca723373737211071a8542ae1d0fb4692f06dc77120226bb51a9428ce83334047168bc57da2530c37153d4bc3ba5fb24b7647 +c9eeb0eaab82a822c8ee21db1d56fd3c6ee54cbfdfd12e67b24b76c92ed925bb1f6a57735dcfb2ac72b92ca661e1e0dcececb1a3b3091f4c98a67cc6171f4388 +ad5456e3346ab7db4886cb35b9a4585fdf6c365b3869a9e064dccddc79dea0c86c6e972427ecc9b17ce2d8dcd5eb37705a5c2e0cc3910cccaeb9c19e736f75bb +4b2da4cf16b6b75b9e57739cf3274ee0321e9d9a7a6062022eed27a552330cd56271a3d34151cd3f76e2f4b9e35b6df7adbf7d4bf20208a8b261a0b8af6e6c04 +718cc22d944af8344ad8afaa25db7efad4a94aa1b02dcb8b376fc2fe72b77b7bd51dcafddee63dfaf81a4123b22f137ff0d31f6f997dab2c4b1c4a79dc1d89c7 +6a56c42c3e9ed2b6ed288a7c1e6557dd9be9279e0ff58bcefc849ee7dd5ebd3d94fb1dd6f78aec92dd51aaafea737364770076459d39f8fab98e66de3895f3b0 +fcefb8fd7e8755cee3e617c82ed925bb64f71eecb2387c320fe1a3c84ac69f1fa8aa02d1a02489c233f0c703f949f8a3051e36406464d7c14622c4424cc8fcc1 +4326f2f078006c57c62204c061f02902697ff6c1d8e5931659140395074260816444ac02792fc001ffdbcbc63b4c6419274c787443b93f0df4d9de36535df29d +d990725ff003995f2dbfc2e1dcafc4dbf98ee3bcf8e28b50901082d7af5f8722dcbb5866657676967f69c2cb972fe38b85efdcf9f3e7c56a4c22f83344e4e2e2 +22122059b55ac537120a727b7b3b9f38ba4f47debe7ddb1cd2fd0eab9cc92ed91da5fa8aec0ec6ae60f0f5f3af18fa589533fd7e47bb9cc92ed925bb6497ec7e +a85dcdb2cc3849bd2084cd074f1c4fb3348ca277afdf401a280f369b20494bbc1f6072a2da98aabb9edf6eb7d9a07fdbaa562bc21fc86cb08152b02df9ce36eb +58585d5bf7fd40da0b0ed4ec742c93b504d9b004ee8a0666f7dffc8bc770dfad6d7f6395853bbab1bed074dbf0835eaca0742cdbae54ab5192cc0441290c0d55 +ed71f1f4ea95ebabbbdbaaa2d60bc57aa1345d281c291651945e18c6696ae87ab954c2f9afaeac2c6d6f1bbaea652d5d0a3da927e64fe06f58f72bf1f17b785b +afd7210d8320585e5e666345f8f743bc8a61a2308def0a1288be2311bdb952a988699f1091aeebca7beb3cc79c706fdce93e7092797b38f73bac7226bb647794 +eaab7ff52f1e25bb03b02b187cfdfcaffeab67c6aa9ce9f73bdae54c76c92ed925bb64f743ed32e990645918c7d83b77a48123576e2c2cdf5e93f8923c700fb6 +65552becbc9552a95ead18ba8634315ff57762a2c69e2bf0195fbaa64d56cb38098ce1509c249bdb3b9e1f64e279832cf75cd784ad2415830ff13a30bba74e4c +49b2d4b6835a524aa55491dacd9ee246d98dcd20cd586442cbb2d424712c4be6d716f1a18fb7d677aeacdc2edad693a74fc3dbd51ca7512add79acc2074f56ab +555cd2caf6761427313e18298c65259522f16405e68775bfd2de4ccf6c0f5cad98e429223ccb7bcfe4f9520e6ccc2764220fbbc36680403b66bc2b096f73f529 +12a3a0ee1aff5960eac150ee7758e54c76c9ee28d55764773076f30a73c0f5f3b89533fd7e47bb9cc92ed925bb6497ec7ea85d366e3f4d5264c964294d944c88 +06ae1d143180804f1ec844ec3e31ea800ff8cafad6f7138a25c245f38555d99c42ae3f98797e05c224cbf50b6d3338bb37ae2ec1ff45ae12fa2a4ee006891fa6 +417ca76ba5e7fb5bed360aa8bbbbcb264ea0b41c0705adb182d32dc3a8178b26fc5fa1502e14b07fb7d7630bd5a669c85597a5abf592e55846c70d934cdaf2e3 +757e651df6b07c38f7bb4fde89a19ec8e879de850b173a9d4ebfd09c999911ca72676767777757e6233c153ef04f88ce3c3154c297bffce5124440964977e3e2 +5fffc7a1dcefb0ca99ec92dd51aaafc8ee60ec0eab7ebe71f5bdb12a67fafd8e7639935db24b76c92ed9fd50bb5aa7db0b6e2dca0a7b287b6c76465315f88098 +3f66a855ab86ae0761d86ab771c2eddd5d5d535ccf735d3f66c30ad23866f60a8e659b86ebf76e2d2ec3d044b57c74661aa76e4cd6a7eb13baaed526261459b9 +b5b4dc6977781c82c8f37ddcd3c0ecfef7ffed7f4071cc1e3b7efad1cf616363c773fd943dca66d3d3e49bebebab9b9b283ceffaf5b4d72bcecc343eff79949a +c163144f96cb5f7ef0c19265551c078e109eefb52b5720c57494b1eb22fffc6471ae3e07d7f7f35b3b5192adec34dfe6daabb4b3f3d0b43394fbedbd5fdec184 +6ddbfc2b248951a0f2deb3006ce4f19ff2899d010fc3db8ff8ce21254464b55acdfa74647e2ae007fe50ee7758df2bb24b7647a9be22bb83b1fbe490eae7fffe +dffdd15895f3b0fcefb87d9f8755cee3e617c82ed925bb64f71eecde99d4876c2c506f12cbb2261e1f48bc9fc134cd288e23bee46f148551184611b3c4871f24 +21df6f27ba78c6d0e9767105a6a18bf4629100c330c4fc2edc007f2ac1f28a0b1d985dcf0bb38caf67c02319f01729ddd342ace8b1238e53f127168cdd1bf680 +fcbaaaea9a8657b68001cf928ab808125b579605529095344be3248be2344ad380678fd37458f72b0cf11bf7722989437964e65cfc89c745fdbab05f1a8a0742 +191f239af22f68c0c9d3efcb3eacfb25bb647794ec0eabbe22bb83b13bacfa79dcca997ebfa35dce6497ec925db24b763fd4aee6d856c016f4834f90b0819321 +45ad5a419d8e9c9aaa58865e2c3862c041cff383306499f9627decb2b24ce5f3be12e64f7275c22621e2b2205e60bbd56e230b132231730a38e4d836520dccae +c98e480a7c5c920807a6f050b4025c44cc4a305984125214c7f356171678f946538e632bca4f57564c4d333dcfeaf5a0c8cc999963f53a1bff16b05910b8362f +702559992c96f0aae123e113db027c4e43badf95951589fb6f31c21372b0d168e0db8343d56ab5c43ffe3bbe3f49d6d7d7c5f7631f792e08c78b172f76bb5dc7 +712e5fbe9c8f0bc549907d6d6d2def68d28674bfc32a67b24b7647a9be22bb83b13bacfab93e66e54cbfdfd12e67b24b76c92ed925bb1f6a573b7d7cfee6e272 +cff5f0666d6b1ba94f1d3f766e661aa9777776a32894aba579a581332daeae5dbd790baac4b24c43369238f6797744a5549a9f3bbadb6c5e7bef56ca261db03f +6e358288e9f6dc2b37b13fab140bcd76076e6672a27a72ee28d20cccaec67b36e42c4bb86792f86a31f9704656d84982d7e52cebc8b2edfbdbebeb383a5d2854 +4c13766f6d6db1fe16ec5c5ed60de38bcf3f5f2b97bbbedff43c9cb6ed46cd6e6068dadc540d1f90dc6c86fcb1cc7a960deb7ef390cba26f47d3b462b188af11 +b6558e382af3900f7bc520edeb3592f88325e4c2dde08422e6b3e779c89eeb48646fb55ab939bd3b9cfb1d5639935db23b4af515d91d905f1852fddc18b772a6 +dfef489733d925bb6497ec92dd0fb5ab69aab2e70932316c40511516849f45fae58bf9ed4de897f8d0afbd615eec6dc6cfca9f3230f8bbf709918c23e20766d2 +9da164125f2a902df13728bbaa69c286220211f320875e14257cc941a69654b6e26da4aa93c5a2631877ecf2872429bf6a31b62dc59fa2e0afe5fb52af174491 +cc5da9942452c462cff6023f48758f77beb0696f6c44e570eeb75028f41f55f672e527ccb3e4da11fb2dcb12c9f25c79621cc2c9f1da7f0691cb7150668678eb +776e0fe57e8755ce6497ec8e527da5a2a949760fdfeeb0eae771fb5ed1ef77b4cb99ec925db24b76c9ee87da65f1f6a727eb13499c2469a7c716ecd9dcdaf63d +b636aaebb9fc11701246318be31a271028b840cb34f0aa161cd3b0d859e56c6b7bcbf78399a93a12f33109778c497ce4210eb10bad968f1d3bce12987ac2071e +0ccceee4238f60975057d878676363657717aeee48ad86133e303171bc5a4539be70f62c0afac6fafadfffec67299ff9d00d4378c7122fab4d495ac58711c7d7 +2e5f96757daa54fad2030fb0150b7776bc858544d3dedddc8cf1de75753e58ee73babe34a4fb7de18517f28f5ce6d33eaf5dbbe6fb3ebe13420b66ef8fd58cb7 +d8ffdc73cff58ff914b9900c6572eedc393ee044b66d3bebfb4e21d7b3cf3e8b57b1f387dfff8ba1dcefb0be576497ec8e527d2591dd81d89d1952fdbce6fb63 +55cec3f2bfe3f6fb1d56398f9b5f20bb6497ec92dd7bb0ab615fadc22604fa41d875d900ad56bbd3e97425fe1421639307829ecbc60994cb65d89365c9d40dbc +da8e53ad4d607fe4b99d7607196b95b2c4fb19faedb15185110b0c234bf2f4d4649aa5521a67319b703830bbaac916945734b60261c66794f5f86c07f1704553 +55db6025582f956cd3dc6e7744474994f1a90e8a82644a964559e6f3803421d452188a2c2a7fce9df130485e1084aa6ac4b1c4274818f820a7a68672bf55b8f3 +3d60115a301f0b2afa8e72059977fe6027ecf6c76ace73c97d1d50fd22521c422ec771c4db61ddefb0be576497ec8e527d9590dd81d81d56fdbc3966e53c2c7f +346ebf5ff2fb6497ec925db2fb99b5abe50a43e283b32411bb25cf23492a1f1d20def2707f38512a4e24660f667b6bfd25095bc305e9f3818332bf68550c4ae4 +6743024592953ea383b0cbeffc76ab75796d4de20eef78bdee64d9d1761b8e4d8ba2e6f6b6aa6be58a96e805c38ecf1c9b608fb623254b644dd36a950ab25434 +0d2e0dd7ea4a52cce7c25d5d5fc735af8561d3b62359de8aa2208a3e57afffcba79ec2fea365e5ef8774bffb165e12d198c5761445e22438a778cdbf1caeebe2 +66b3befe222416098445eccc233c8b5cb860e4ca38d2103f5fb24b7647c9ee90eaab1fac75c9ee00ecae0dab7e1eb3efd5b0fc2f95f388d7cf6497ec925db27b +ffd8d51e7ce081cdadad300860c4324d1c36741d953e4e619a267443afd7d3777691c10bc21dd76393078a8e224340f8cd660bfbaba562d1b1213a1696577141 +6ce2819845c06e4b320cfde8ccb4a2b05107f022892c554ae5d9c93a2e776076d35e8c43abadd69b4b4bd0415f387e7cbe5ab53cef28de2649bcbbdb46319986 +fbe874564a4d277d64be8ef31891ad263a3e9242a9842273f0d97007bede6e07518ca2bdc6bd69278a5ccb8247dcf43c2f8efff9430ffde6b3cfa274d5a9f4b5 +0b178772bf972e5d92de8f589319df8fd5d5d5fc5b22e408deb2a74abe7fe1c285fc8b251288b1a3f81a2d2d2d4156e26ae7e7e745bca8bd2fe89d90d1e2eda3 +33a5a1dcefb0be576497ec8e527df58f7ff2d764770076ffeb7f184efdfc79ae0cc6a79c87e57fc7edf73bac721e37bf4076c92ed925bbf7609745fa6db55a69 +12c7c99de707b0a1f1502e500cd888a248bccdbc00db59aa26a8fc955f7435248e25b3c70c99ef07315f94b54f8bb075016049f433f0e71599a11b308afb1c9c +5d1e78564381b248348aadeb366cf0c58a207c52fedc1ae9dd204abc308d138977aef8419445310abf5c2bb370852c76027b7e6299baaa2b71924661cc9fbb28 +1abf81bae384696a294aabdd66fe4f4f8775bf1dd795decfde3780adb41cf2b17cfd5a501c6ae3b20f20f3151abadd2e34a5aeeb909b794641ff72cdf291ca70 +3edf617dafc82ed91da5fa8aec0ec4ae3bacfad971c6aa9ce9f73be2e54c76c92ed925bb64f7c3ec6abbad56cf75c3200ce39887019451e39b86ceece96c54bf +6918053ec1cf0b02396497aab218fd0a12eb22b2ab24fb21cbce0ef57544f0c15fecadcfe673a9389bebb96992189abadb6ca5593a30bb05c34089cc148b8f4d +4fa3507fede1874f351addcdcd85c54556dc49d28c635cd88ffee92ab4d2895af5999327514efff4d3b7976eaf351af57ffbccbfae544b9ee6ae6e589aa69c7f +72be503437767aaf5f5e4cd2cc51d5c030ca8ef31b5ff842a550587aefbd7fffed6f33c7aa4aee3f7b6228f72ba4215ec5f3a1fce357f8cccf989fc1711c165c +274d7321b82f713fe5721996a123f3f59fee9a6c589f2fd925bba3647758f555e5c13364770076e57ffeab43a99f0bba3e56e53c2cff3b6ebfdf6195f3b8f905 +b24b76c92ed9bd07bbdac5cb3f4ba024d2545195a263c35eb1581006a018d868817269668a8def7ae7da4dcff30d4367d1ff14a554284cd7593c80a5dbebab9b +3b7024daffbfbd7f81b1ebc80f3be1aa73ea3cefbb5fb7f968362992a248492391e2481e8f34a6c6503ed972e2ec666613c4d0c2d85d60910f1e181f16b1b3bb +d84de260370bc4bb5860368b0d12c706c66378938c27b39e6f3d5ecfd89cd1684623897a504fbec97edfeebecff37ed5f9fea78a7ddd6a2a30be019b97ecfb2f +5d5d9e4755fdaaea5657fdfff5f817a454ac331447aedcde759016c70376201f5313f5ceda06786b99c6ea5a0b5274cfb8aa5285673a6326c44c69d5b2ea7689 +1a03593629e731e719213d37f459326596282fcacd0fc26e7f50aa98bac5ecb266184531c3ffb58a55af9951023f184b330ebf125755e818e72726a62a95fed2 +d2e6e6a62cefcecd5b23c92f29174f402e3c79f2a4b56586119ce338afbdf6dafafa3ac8852fbffcf2d4d494effbe7cf9f1f0c06e0b9d96c82a4b8433484f281 +872fbef8a26118770aa63bdcf7feedef8d24bfa3aa57c845ee5e6aaf264e28c8bd075cd95adefbf639f8b33f1bab721e55ff3b6e7fbfa32ae771eb17908b5ce4 +22f7a7e0b2e2903dce739e5325df5a7206b1815f2a0ee8a5ead6ee3e654b80a0622b00bc1ddaf0e3fcf6c18077ba5cc8227ce8add850c8536139e09e71db9e07 +6153cf6b781e449bc5ae970e022521b34d9a645a1c99719c1212a6a91ba5e1ed736149b95a9d9a99b12bb55b0b9d76276c6d38719665246fad3bae1bad74062b +9d0ef47fb6a619ba0e79b8b8b858328c95cd4d5b244fa954364794df61705b3839cc43c5fe4fa80a5114c145a55269341a2023ca4523623c4993272d0fa783e4 +f251902041e294469bb7bfba330da3fa7d918bdcbdc41d557b85dc7bc375b6aac73d6e9f97c6ac9c47d5ff8e5b7d1e55398f5bbf805ce42217b93f0597454130 +51abea5ab1f7ca348b39818d4ef7daadc582a40289562be5fdb3d305afd8d35f5808288c06111a3226edba574a96ced48c73c70ff2c2be5fae8a6d036b1b9b71 +9214eb07c210d2270c001629e55916880ee99e7117ba03f030e57973bd1e94531ab63b89126a9c1c3f0ee561f87e390840b61a5cbebce9794ead26cb143a3fa5 +5c668cbdf5f61224c9f38300bac6845cbdbe09bfc16abfffc1e252caf9c9030726a6a6a067fc9377df855fafeaba4df8851485eddbb7a04423c9afac05b930d1 +3c5cce01a02008205a9017e11bae5dd7050f5c987ace85d946b9f74311152d17769e647079b6f35fd6215947efa861a3fa7d918bdcbdc41d557bf571b78bdc7b +c07546d43e2f8c59398faaff1db7bfdf91c93963d62f2017b9c845ee4fc165691c5ba66e5bc5ca019030e0db71bd85e5352a86117292ef6f4e37a727244f13c9 +4a9342da48e19facb8b00cc336cd34cba8ca40b8d054c5047c96b5bbbd288ec1432c2dc1e45c6413d2c3e328822ee49e71a93465440abb339448e9878acf6da9 +6887405478dbf65004a7746b58656b28269751a8c2f20d11b7724da694cb8ad36847945f994ea80de7cf9fcfb659688054371a8d4aa50295e6d5575f95fb3f3d +51e7e0a2d56a11610da2d96ceaba0ec12f5cb8006f2dcb821c97cbe5edf34ee079681062e8f411e57754e58c5ce4eea5f60ab9f7862bfddffbf6b93266e58c7f +bf7bbb9c918b5ce42217b97f25b7089f653c4953852a4cd8e911530a4cc81699ec04a0b587dbfc764f406e4f1de4445af9632abb6d6496deee52e42483341850 +3c564428aadcf62462809b7bc62ddb3644e145d1c52c53736526b526d36a92c59c0c8a618f247182202e96aa15a7c5269c6f14032724121329729f1b03912b4d +5d712ce187abab6e1ca749521173268f379b674f9c8018fefcfdf7dd28ea13d229cc1de669bbcd0ed44692dfdbbd38e783c160bbf5663156a4ca551f8ee36cef +f27361ea99885da3c3272044823790177ddf978991f1c0937ebf2ffd0f1d44de5447f3fb8eaa5e2117b97ba9bd9a999d45ee3de04e8ca87dde3766f56a54fdef +b8fdfd8eaa9cc7ad5f402e72918bdc9f82cba6a72656d737a3382ed9f6a913c7c0c7fee654d936817173693508a177480703b78885e7a669a88a2aed01f84170 +f9da4d78fee8230fef3fb0bf584bd05a2f761f64d03514e30d47e7e780af316d72721248adf58d9c164907846d18d075dc336ee80da0a8409eea40ff077d1808 +4bc450495e940f2429cf932c135bd28ab16ab88db28c8a73684461290663903c4d1c5100f1b77dbfe3792ccf2dd1cfd52d6b5fbd6e3179e80c89f3dc2d3a4e1a +85e191f2be91e4b72f7e752acc32e562985f8e18e5622dc750a694df86616c5ff3a96cd97c96134dd25b26cb8710d3348b81a534b56d5bc649b66a183c2c5974 +24f91d55bd422e72f7527bb50f344ce4ee3e776244edb30a7ec6a99c47d5ff8edbdfefa8ca79dcfa05e42217b9c8fd29b84cd7589c247e1082cca18813fe8441 +7f2bcbb8a2502e966edd1629c419aac56841b181b0e04128216a28966592628041e1c5aa042a6417625b5661d65fd7261a7588b6d3edaa8c519e691a838710ed +3de34e43860919505a121d5bdb75939565a0b7c5f6c89eeb0e82202dec2314c327f0ed8b3996d07122df4f356dc53421e59bfdfe5aaf07b8c35353f3d3d3a9ef +7b2b2b452a93a4eb794e189a8c65ba6e97ed8ad2006f03551f557e871261b3d9043fbaae4bc3ce411048ebcdb223875720173efffcf3954a65285c82a0f9ca2b +afb8ae9b0a47c4a852abd5eaf57a10c3b973e7a46778956fb3f914c7f1c71f7f9cae5f1d497e4755cec845ee5e6aafe6907b4fb8a36a9fe7daedb12a67fcfbdd +dbe58c5ce42217b9c8fd2bb98593318264506cdf27a4efb8bdfe80141bfd6ddb346d1117114bb992248574c81d8310a4522e150dbde3dcbcb5049114cbbf1435 +a7594e8ac50651922a691627195f6b15cbc9fc6030702078b55caa95cb5cb87bc3fdf2a9b3e0c5f53c1086b23cffc63bef5cbd7811ca4e13e7dc2642602a1646 +8a628d92641d242d42fc8585b4d3812eedf2609033b6311840ff671bc66fbef4d2c3fbf6ad2f2ebebeb1912509779ccb6233e4846dd70cc3326bf5d22c2463b1 +975c1d0c46925f5a69c8a8e4394c8661d46ab552a934b4de3c74700b7261bd5e1fca910005a238973195eb4044179fc8d927903b219ea104399423a328024a67 +44bfefa8ea157291bb97daab174e9d42ee3de06e6c4db3dfe3f679dcca7954fdefb8fdfd8eaa9cc7ad5f402e72918bdc9f82cb0c5de7c5d042010ba308ae373b +bd95b57555558f1f39542e061800514405098ae400b030f36b99e6e444a14fb63b9de59555c334e7e60e42a8bc4016724c1015660020f4f25a4b4a1b1b9b5db8 +658a621a8688f51e71e5c608558c9a8058948bb293eb24f3ad5d0db7052951b2f27af89c7ff20391401654219149794a9a361661a922ce4580fb11e697b3405e +e8d0c16f59668620201d1689173b3cb9d874978b6d9fd26eb3ac55700b3ee539cc206282e008d7203b4254702d8f7dda2147ca50e06d54f9452e72f7127754ed +1572ef0d370846d33e8f5b39e3dfefde2e67e42217b9c845ee5fc995467db636f28b56ff2fa503d13bfce5ed36dbad9452f249b7f37efbab2d3b4377beb9375c +b9e50c0a693d0ca1af9a2c978fe579bd543af3d043f06af1d2a5d5ebd7554d9b38754ab3ac28cb1c71bce132215d45315475be5c86b773696a0501d334ab387e +367293a42336499619abd976e4fb4b8b8b5118a68d9ac66681d2eab9a3caef0f7ff8c35c9cab7cf6ec59100141f8fbe8a38fe4c6ce7abd5ead5621d9ad560b84 +3ff90a7ce65bf345d20f48909aa6bdf8e28b203b1261fc098283e78585851de69da403cf478e1c796b44f9bdf30d7291fbe07247d55e21f7de707ff8fee591b4 +cf5aaf3756e58c7fbf7bbb9c918b5ce42217b97f2597d56ab5fdb333b56a1962bfb1b0048f0603b7984b20d9726b9da96aa552de373305cf15079e735555cb25 +1ba2806f39ae9035ea79ce9334dbd8d82c468579c68bfe83c805057c6b9b0138db32a0cb8080b51a8832fc9e7199e8ffe0a9234e1aa898a642c86cbdfeb9a347 +0d4d7bbfd53238d7283dba7fbf5daf2f0f0617565620215d4ad728ad28ca49d3d4757d9fef1f620c442a9df328cda234f5394f39a78a62e97a1e4561a7e3bbae +0af256737f96f341108d2abf8ee3e4628b26df3a7bb9384a51383917343c72095e0541300c38f4030e84cba9a929dbb687752516cef7fd1db54dcaace046955f +e422772f7147d55e21f7de7047d53e8f5b39e3dfefde2e67e42217b9c845ee5fc965a592dda8552d430bc2e8dac292584d9017f65579de1b14e288dcd35ff0a8 +dce84f4db3b0005cb2ad5aa54ce42101aae2badee2f22a0828746b2041f2b63be86ca07b304c03a413787bcfb86dc781483a8ed3f5bca24083c00fc3b26946a2 +3b8cb22cca73e03b519486a11f04205b413c2ccb0c4234b1b10d6276d37423cb14552dd14c5732a270e854e54a092ed6c899e5b23cebb01f06909514828f28bf +729207043b2e2c33933bdcf687db2bc4d0c9f40cd78e6ef799091b3f3b3cc343904747955fe422772f7147d55e21f7de7047d53e8f5b39e3dfefde2e67e42217 +b9c845ee5fc92da60ea00d578493cb08c4b62b2928143244b143abd88d554423840a99a0e27b381d019790cec29fd8cc95f3db9287dccd25c50e459878954981 +1e252faeef11f74fde7a0bae977bbdcbebebf0248be32c4da117dc701c53d737c270bd38c6907aad96eaba61b79bdcb80191d70861f0c9b201749f8cad795e18 +8606cf7e59f52cc3a45a5852685176c5b0770a3fcba1471f8594ddea767f7cfd3a2400b23755ab8e24bfcf3df71cd93a9fb9bb657e7f8713bf7bb10ab4d56a7d +aa07cbb2b68b9b43cffd7eff53568f50bab2b2526c361d457e4755af908bdcdde08eaabd42eebde18eaa7dde10dbfcc6a79c47d5ff8e5b7d1e55398f5bbf805c +e42217b93f05972d2c2e4f4c34a62627fb03e7cacd4588a252a958960d9e93248668eab5dac4e40424657165dd0f439632aa384512a93239017d04715ce8180a +430215bb08e587d1c0f5656a45ea15cbd081393d39d1eb0f009926d9cd9b0b90887bc60d575dc005711c2409649d27094fd3a2ac45a140e96562242595459865 +44c84f8a306ca3882170781e731ef0c2e5342fca9f1641e04bfe32103fd3b4e289a2487bb6908272b93c92fcfaa50a119222089172bbe650f2cbb7267fe493a2 +ce25c9f0e1f0153c91e6a076888c10a7b4ed3c7c320c1b45d1e111e57754f50ab9c8dd4bed5528f440e4ee36176ace48dae75051c6aa9c47d5ff8edbdfefa8ca +79dcfa05e42217b9c8fd29b82c8a632636fb695a28c6110a3babbaaec911848c64204fe89a4eb6660cf8d6324231a8904bd9420a2b4c2dba05857e422e298616 +847861e89aaaaa70076fc32802ca3de31e12e7ca4e944a07eb75783588a2384d4d5d7ff3fa75800e7c9756ac4c51ae753bc960000251aeeb44747b00d3197ba4 +d92c4e25989de07c1f8096369de56e40c268e2e801f0b699458b376e14dd6792c07737088ae391287d7c6e6ea0f291e4d713cfe1dab22c79745318865c0c26c1 +1345187c92e73315fe0d63875cc8b79683fabe2fa549e9e0569a86528ae31c55194a5a7e961ed411e57754f50ab9c8dd4bedd5e17a1db9f780eb8ea87d1eb772 +1e55ff3b6e7fbfa32ae771eb17908b5ce422f7a7e0325e18018a44b064b2512f765b19860a1e08b5abe562f856555beb1b44c8228a9018e47241d7f3565b9be4 +f6ae2d5aecd44a211d3411530a43187433b56a4555149060eab56182b37bc93d6c94e5732a5ead05819fa63ddf7ff3ead594f3099ad6aa56c2f3eb9d8e9366ba +aada7a51bed538d6383744ff57324dad4cf41a8d93ecdbaf7ebcda76a6aad6d9a307409aba796dedd2d21aa4b0586701f18b738c21f1678f1c792bdc18497e89 +780cf17fe10b5f304d330882ef7ffffb8ee3c0353ca956ab70fdf5af7fbddd6ec3933367ced8c580d06d274d3de7e23ca71ffce007a26ade7680bb7cf932240f +f277f0e041e8e6e16db3d91cca9af57c3092fc8eaa5e2117b97ba9bdaa6f1dde8edc5de59e17fdf1bd6f9f0f43d7304ee53caafe77dcfe7e4755cee3d62f2017 +b9c845ee4fc165ffafda5ca1162624cb4b8f1c7c04249099b9f2e46c298ad3575fbb3e18845ecfbd7a799588998459b55a44131711ed5be8ccbd7743d5f5275e +7aa93a3b0ba9d96cb7c1cf62afb7ce5c48f752af17a5e9b1c6f4e7260f43baebd5aad93465427bfd7e11cf3de39a9fe036c56d562a3d5caf6fe79e94dc386a39 +0ed93a2d16dc1f7ff861c175ddb97e1fb8ffc927b98fcf9acdf2d45f72a7a73f77e488e43e6a1e18497e7f67b3a807203efee99ffee9f0b7875710169ec8db49 +e1e4d9cb2011eaba7efaf4e9a1f566f0dceff7bffad5af824c59afd7bff295af80bc08c1df7efb6d88162adcf2f232c40cf5756565856cb9ffcfb973a3f97d47 +55af908bdc3dd45e1dfc95bf41444420cbbb03e70f7eed1f6c6cb67feeb153ffe9d3cf70253ffcf884a9ab6fbeb5387d7d53d3d5854eb758e74b7801a6c5f2df +6f5dfaf858af373b70f2927df64b5ffacf7ffe85ee7ac7f5bd284b3f68adefafcc28b9d1769c4aadfa9bffecb7ea8dc6b5ab97bb1bebaaaa3df299c746c29dba +b23292723e3fa2f6f9c027dbe77b96df71eb7f4795dfb12be771eb17908b5ce422f7ff7feeed3d7e7200782870a80a2d96fdd1dbe7fbe5a227c8b7fcd06d3e85 +9f22f870dfffeda7c5beae6ddec43fe4930eb9f7809b0b538ddb5774ec783b7cf5a97eee7cb8c33fbd239ba3cd2f72918bdc9f8eab8a35e45ab19c4c23c560b1 +922be225cf158dd42cc33499a16b8a580f16c6519671a2334555f29cd33049541a797ee4b990209b3153d35c4337b294649aa28137952b6ac6f32c2f368f1155 +e19cc471aa6923e3de0fbf2fb6cfc8452e72918b5ce4227797b80ca2bab9bcec789e6e18133333f0eae28d55e7ba9f73d26f0749c2cba679f6e851f0ba79eb96 +dfed66aadab68a5d5e419e6fa6a9aa28ebae1bd9b6dbef2f5cbd9a73ee86611cc79c923223197c92e0c6e626443ba7aa070c639849e4ee1ef72feb8d388d192e +34906a3f4de0536f6f1129e68beef40061e1d5f61d9ee04d1edd64db36bce29cfbbecfc5ce52b9d174acca19b9c8dd4b5cf583f77555f9f0cae2c2da3a68c359 +bfab79411445be429c41f017dffc21a8c999cff398439bf0fce38fd996b5f2d1c79d9b37b546c3f8ec1329a1476bb50315db8f936f7ef06198676677a0ba03e8 +788230229c429bd1b414438dfbdd5e9224d5c2152b9c9746c48d6fac63fbbc87eb3372918b5ce42217b963ce2df4fccb376fde5a59694c4c9c6934401a78fdf2 +c29bd76fe84c3d3e33636ada64b5fa859327418ef8606969a3df8f74bd679a9c105f9cfdab523ae1382e3c5c5fffe8bdf738481894162289c66a87a6a9a626b1 +ff71aba5506a58d681c949ba25922077f7b8446cc85414a5d96c021784bf93274f5a9675e7e40f15bbec641a4dd3dcee416ef22c954ae57219aee115a419e211 +76206eef15711ce76b5ffb5abb0d35d03a7dfa34198e218d47392317b97b89ab2edf2c69dadb3ff9c94f2e5eb275cdecf5591481629c2ab413467ff2a38b014f +4fceeedf572f31ae9f3974a85eafbf7bf51aeb750dcb2c1f9d4f533effd823f347e7dbedeefff6fffc45d7f5e79c7ecd71a1259a602a68e9e6fcb4552a6b4c09 +7d3749a2e6fe03b5a909504a5f7ffbb5917017c84fb07ddec3f519b9c8452e72918bdc31e7b22ccf555595367bd22c23c2948ba62a4c51401851f35cd95a3b08 +8c0c3ec2de6f260e6249459a7371580b11eb0fc1714a3371a1884fb1eaa038a3451c1b280c0626bc38f48f2377d7b84319112448b8350ca356ab6d37e6b4dddd +295c0e83cb79247072c5ac228dfc6df3000eea5c1886aa70e356cec845ee5ee242f4b14a34d398aa35748de6fd7e4268cea91f435ad27ab564676989293aa75a +4e124a434a5243e3a6955ba6389f2b8ffdc0ebf693dea0cc8cd8488c50373496ab2c55144e324aa892e594734a204bccf73c2e8ef21a1517dbe7bd5d9f918b5c +e42217b9c81d732ebbb6b9393b3fdf9c9f77a2e8fca54b699eb33c3f3e3d0ddf0fbbae95a6fbc461bfe03a59b69c2421e7b7badd4451d262be45d11465daf308 +631e7c0b896499b11e6320661dd12abaa6b903a7bd7eab98bba8566f753a45662835454291bb4b5c323b2beb411445d2c22384daaa36b79d9cf021625ee85385 +c8200840002d954aa66982a45870c51c14dd5a230a17711c831f102ec10f5c7cfb9d77c6aa9c918bdcbdc4fdee1f5d49737ea05c3f7d701fb415d6fe794b575e +bb7ee37bdf7fa56c1a27a6a653851ef3bc99b53556af359f7fa63a33bdaef17076da6e4e9f3cf7b3d092acacb52e2dacc449e8465e1425292f1a199fe4ef1946 +a2f383513ed98d4c4bf3dc41dd9cfeceeffcfefbafbe6694ec6ec91a0977eac0416c9ff7707d462e72918b5ce42277ccb9cc8fe37aad66813c34186cb86e9ca6 +33a552d9b218e7e5c1c08e63404ac121ceb89f66514e8224894186c8b290529d90c2aa6f9a72315641f33ca0b4af282655e2c2a6801a65c516415555a324590b +02f05362ac661810277277892beb070879172e5c705d57d7f595951563dbe6101022171717c1030891737373ba385f67bb93b34c4f3ffd34c8912044bef1c61b +509fc073b3d9d4346d288f8284fad8638f65e24c88279f7cf2a36f7e73acca19b9c8dd4bdc28c9928cd34a61cd8e135a2b9916b40c8ada8f829cf286aa66aa0a +c9489d42a5244ca5864620069e5b4431ede22878a6ebccd2d2db23cb54cd15c673952ad04b15f3f069e6a549ac689a5536aa55687fbaed4e398a235d1f09372d +57b07ddec3f519b9c8452e72918bdc31e7b25e14753737a9a280c2df289532cef757abb3e532c98ac505f0d0b72c372a0efaab351b7364cee3f9d58e9b675c63 +ac4488aa286dcf0376ecfbae61e49cab865165ccd6f5b94603b2d14f124d05894be1715c92a24c9ef74584c8dd25ee501604e1cf711c10137bbdde0e39726363 +0304447855a954e0d5f6a924796ddb3608918d460324518807620039b25c2eef103ae5725339b3346ee58c5ce4ee25eea0d7833857292976c76769c7f553c235 +aa3e7ee060a5649d7be60ccfc8a103b313d53ae8d05ab51ce7d9ec23c74a33134467cbcbcba66e7cf893b76f5cba4415d677bd28cdd614da2f9508d3f6574aa0 +6c9f999f7f64a6e967f15bdff8f7aac23aad8dc6fca162367e445c1bdbe73d5d9f918b5ce42217b9c81d732ebbd5ebdd6cb7fb41d0b0edb3870f43f853d3d3c7 +2626208a772b955e1cabe5f2bae35042e61e3b7cf4a9f9cd81ffcef7de214104024555d7799e5f5e5f8fd294a96aa952219456e0b9aa562cebe9871eaa954a6d +4a17ae5fcf295d72ddc983c53ac94dd75decf7415841ee2e71a584a7280ac888f00df29f34da3c14fe28a5a669ca575cd87520c256b3227789089f9665254912 +0a2b8ec39d24c516912cbb73cba85c473a592e8f55392317b97b89bbd16ec31f3728d57e02bd43fce1eab29724cf1d3d76747ac62e5b4f3ff1993c8ef73ff7f9 +c6a38f245ed05bb8010dc7be63870f990f7b9e7fe1cd77538b2f5eb9f1e18fdfd22cab3b70922c0b0d83aa8aa992c7ec4a9444c70f1c3c73fcf866affb877ff8 +6f02cf31e6e7cdc6440e3aedf56b23e18eaabdc2f619b9c8452e72918b5ce4de032e53c5963e451eb3270fe5dbdaca2f6f899c40a014a22e8c016cedfbbfed47 +d841bafd0129646b7720dd765e20fc9bdf966c44400564b0c2ca007277892b9d6ddb2fbffc32489020085ebd7a1524c2e1d64d00eddb576c858557172f5ef43c +0fc4cab367cfcad398a4f1671022171616c00378abd7ebd56a1524c876bb3ddc38ba438e5c5d5dfd9cae8d55392317b97b89fbd08169085db22b65dd8ab2b4ed +0dc224669ae2a7b196590984d70d6fe068abad348ab22481c85aabebae3b8096c1e9f682c0c8f24cb76d665ab3d353a073ea9aa93385e604620893d40b7d271c +847150b234466c71ac3da4371f1517dbe7bd5d9f918b5ce42217b9c81d732efbf2673f7bad75b3e70f801ba40a44675a56ad5e4fb26c368a2a71acabaa278489 +1f5cbabad26dab8a3a592a4f962a33a5d2fe7219220ae2382d442bad5aa900eef2f2f262bbad6b6a90f7351207c40bc5fc027c7ef1e74f412afaed707da5303b +84dc5de292dbbfae32393909a26114454b4b4b2005caca20bfe53251102e412e040f72ee485a6faed56a72db270891beefd3ad739e53e1e2ad75a73b1c44f28b +7ffbb9b12a67e422772f71ff8fffee5715a66cdc0c9ccd24cbd33f7eeb27f0e7ee2ba613a6b5aa75e48be798a6b9dd767f69912b24701dd02d7fe75ffede1f7d +e38fa71a13cd8929e872529e243c2b2be437feb3974b9659ac8db74bcbadf57ff4d57f31f0fd33c9a64fab2ef19aa0ae076127e33da5d84b3f2a2eb6cf7bbb3e +2317b9c8452e72913be65cf6f06c5321839ea7f8497e6d23e239d118334d53cd32db34a958289888a580b75a9d4bcbab65cb7cf2e85188bd61dbcd4a2517c67e +72b198b05eaf83c8b5dc6e276996f22c25714a154e122e7890c3870e4f134a0656d4c82a9c70e4ee127728dbe55b0e42c94d9ed2c2f3d6e80f01e152aef90431 +51987548e115c88eb9984a82dba1f4293d43823fd5feb374e356cec845ee5ee2d66a5555537c338fd58c132d8dfc308e72532d46a0e14bd58a53e9742d4b201a +15ba25ab6c43e390119a24c960e0c275c293340ee511ee4263553471a25b96f328e3a0ac1aba6a326a52e87ea8ab504d515532322eb6cf7bbb3e2317b9c8452e +72913be65ce684a11f6561cca3f4f6548317869b830148106eb71b4691aaebba6d4318a6c2a566eafa64b96c00af54aa964af0bceb79c5c1809cc7420a313575 +b262daa6eef8719693cd306d099e13c7d72e2f423e135f8943352739727789bb43bc934b3de1651004e7cf9f771c67bba0393b3b2b25cb4ea7d3ed76a958e1a9 +88852552e81c7a865af8ecb3cf56a092ddb1ff53ba6b976f8c55392317b97b89fbaffff73fe2793a3171b05a9e0e497cfaf92f1aa6f5c63b1fdefae8b25d773a +ad45dd60edc565bfbd093af6a58fafeb2a5b5b6a01bf3e39f1ab7ff74b0aa1cc3472a66844a94d4f146ab61fba61986469c5d674cd6ab5fd1f7fb4ecf9f18524 +8b69aef6fb248909cf47c5c5f6796fd767e42217b9c8452e72c79ccbaeb4d6d73b811ff262e8a0d80e40afb75a2b1b1b79960557af72cf2bcfce363ff31908a0 +0b9bbd53d5eab3c78f574cb366db0006d22b972e8168a28150e2fb107e6eaa7c70f220a03ebcd549b27cb9d37b4fc822954ee79ffff61f0063dfa1f9a3a71e85 +0be4ee12f7c94f8a7720145a9625a77de42ad0e114105c0ced3f0d377646c2cce37607dee4a4130891f57a7dbb1c49b74d4ffdf3dff81fc6aa9c918bdcbdc4dd +b87e2322fccce9fcc8711d1e3dfec5cf3526a7deb97603ba9f897032f23a3cd19d8d5567752dc9f3f77efc0ee169bbb59ed102fdc2cf3f4b89aa37aa76a59ac6 +c9f54bd7329a44294d8300a22a1986a62a1d27cae2be9fa66f46b19fc64dd7a94421a7e4bbdfbd35122eb6cf7bbb3e2317b9c8452e72913be65c5658f11713fc +7c4b368027204ee569cae5471ed027240661074011cb28197c33559581b8d80600df54183782ff78ced32c4f529e701e89e029e74110e7398fe3449a4142ee2e +71a54408e263200e6c94d710e5d032f350f813a9e2dbe5c2eda2217896122404046f499244c20dfdef083e6ee58c5ce4ee256ec5b28c383634569cc742f32cce +e08fddd0cd46ad6edbb6eb0546cafd1054e50c52a41a6a9a53bb5c9e6c4c807ae97a21343211cdfd20cab28cc7414e490c7e83281616e61442558532a61a94cf +94cbd0a09824d7213b391d1517dbe7bd5d9f918b5ce42217b9c81d732e4b85d22f4dff499764592a8ee75900c94051ec2058b979b3789e24d3b66d29cafbcbcb +06634610989e07128a313b7b6872b2586f001206215e1006914fa83255aec037836c898d04519a1aa4903814c84b96c984227737b8cbcbcb44d40fb9c213c4c1 +66b309e223c87cf57abd22cc36dcae5b59d66ab58048ee70c35020385eb870c1755d90b92f5ebc385c170a9140f0b5b5b5e144d3e49895337291bb97b8669e31 +9e9134f1a258d594c983fbec72e96ffcad977ee1afbfd8dedcfca7ffcd6f4303b2ee3a5dcf038dbc645afdeee0bffaef7fe3cb7ffb4bbd4e972401636ce9c38f +36176e699ac132c536f5d75f7ff3bd0faf9475e368755225ea863f58585f354ba5dffafbbf3e35d3f877bffb87affde08715db1e1517dbe7bd5d9f918b5ce422 +17b9c81d736e319f4f84757eba8d0734f85eca7387522b0cdbad16bc9d29956a860152c9adcdcd62fe011e2e2d69bafe332fbed8a856dd30ec05014818033fe9 +b991ced8c1e986ae31daebc56213612bcf999861a0799e8914207797b8bdad2da0726e07e4e072b9aceb3a5c0beb54aa7c0b69d97e08d38e592322368e422888 +358e6369f3390802083e94232178bfdf1f5a786e8e59392317b97b899ba70917ae1823a654187767a0791a869693acd5dea49caeba83f5c0d708adeb5e3f8a54 +aa4ccf4ce58487835c31345d534d4561aa626aac64993cc907ae4f4bca3474504c8ddad17abb5dcfb28a65d6cab542b3cd852d3a311d7defb9d83eefedfa8c5c +e42217b9c845ee98731990e3340d922403214bc80785a56245495475aa5cb6755d4e3850b106a0f00009153204878fa2c0a71f86c4f3a224a122e924cb4852d8 +faf3a230e25a202623205e9d52154419ce15691018b9bbc62d954a649b5384235b2b40e4c37ccbc95b786e9aa6f4360c35f40caf406484efed31c850b60d69d7 +e5ad6a186355cec845ee5ee2d68f3d9c66b15ead4207a1a46c7171d9aa59177ffceee5ebd76daabe70f2144f93f2ecacdea8404c8d130f6759f6e49927ba9d9e +e7b81fbef18eaeb277df7df7c6b5ebd02038dd0120cc949cdabf2f4c93e576dbf782675e38f7773ef3681a27da449d9b5a5567d384d81aabcf8d865ba8c4d83e +efddfa8c5ce42217b9c845ee9873195c7db4bebedced42d4fb1b0d901d8e4d4cccd7eb10f2a5d3a74144b8d66afdc5071f407890aedc3886d454047583901590 +36d2f4cac58b54d3a62b959f3d760c52c63b9de0e6cd8cb18f373652b8f77d4d2c4e7854d3c8238f004e4a39c8dd3deeec4b2f6d17f5e238be72e54a18161b59 +a52c987fd25633dcc2f3e79f7f7efb9a4f190abc41da9e7aea2969f3d9b2acedd34a10eadcb973f02d1fae85e15895337291bb97b86cff4cc689512ae98a4a14 +d2ed76139a5f78f7bdf3dffdd1fcecc4dffbfce7b3283d76e6f17d470f6784369f7f0ef4c6d0f18a66842acb576fe84cfbe0d2b5f7ae5ed7185b595cf282f085 +93279f9a9f6f0dfa4b9bedcd76fbcb8f1cff8f7ee5ef6cae6facdcb8422d1d300d85d8849646c49d7ce404b6cf7bb83e2317b9c8452e72913be65c06c24194a6 +5e1c174305421a60aa6ae93a80272b15cb30da03474e1c2479612a006411f0a6e47992e721290c00c4203dc4b10ca28a7105b90e3388a25855f53425108a521d +526c1810bfc218dce662e7007277835b87eab24d8e045970b81654ce1d0d25c8e1e40f3cac56abdb6d350f43d16d13503bd68ec22b0865dbb6bcdd18b372462e +72f71237890bd32f6e14f969aa6abadd775342ed9cce57ad59d38c329ee589cf894b699a64e6669f1aaaef0685ed3b6790a43ca789a9aa13b609294caad5b209 +4c3de6b9a2b1c30fcd4f4c4d1a86d1ebf502df57b39ca53957b44c37535dcb46c455b17dded3f519b9c8452e72918bdc31e7b21f5fbb0680f9c9493bcf0f0c06 +10114b925ebbad6aac5a639956d2adf4e4a18962282151f28c32c61ab51a04a93106518028e113928a3d00975b2d88772d8e7b969550ba992451923c3a39f9d7 +ce9c81e707aaca4fd65cc8cf6abf7f716d4d660cb9bbc15dfbe4c14bd21ab3bc4e9244ce17a5692abf8702a2effb00dd3e5f049ea5872c2b4e7f8087ea9685e7 +a1f409a186eb4be5f7f894337291bb97b83f5a76758dfef0ca950fd75b8511bb8f2e658c9d76faff7118d0c0a84dd849a04c9d3ad6fcdcd389e743fb6029ec8d +f3dfbdf8c61baaaeddbcb59ae5a41a679f312b29cda79b33499a4f37ea112333cd43bff69bff332487f08caa4aad5653afdeb4e380d52be1f103aa65f38c8c84 +3baaf60adb67e42217b9c8452e72917b0fb8ec47d7af7f767e7eae5e3783e0c0e2a29a6569b73b288e2fd2fd533379851b367f646e1292a527969a698aaa962a +1555516c559582436b30889214048d2b22f54e92f8a60929d80882204d3ffff0c37ff3dc3942893acd7ffc7bdf012964a5df7f0d4094227797b8fff8476f934f +3a79263308852b2b2b52341c0a7f700bafc2303c7ffefcf6fd9fc3b5a320442e2e2e825809556d6e6e4eda8b927ee896c96879fb19216b8e4f392317b97b89fb +caef7e9b1033e53c4c33a6a46e14a4b10a2d033404799ca461c4c3c26e9caa68a0374387a4324d812f5521c54c7b1e1371748b42d49c66690e1f685ba0dd8006 +442f7c425f4639252c2fccced5345db74cc01083656932122ecf46d35e61fb8c5ce42217b9c8452e72ef0197198c599a56ac741487f78020c0c538414e723f4a +b220e66926e4281246499ea49ac6aa8d2a03214b2d9615d03c370d4dd59434e3499c021e92c284643169dbc561c58ad21f0c0a9e566c208430f0d62c2c0e28c8 +dd25aeeffb3be448b9fe3317272dc762adc8765950be1a40f03b1cbc4d92c4755d9029354d2b84ef4f2e0ddd7e5c33b5edb12a67e422772f716dcd3054f560b5 +96a6bc626abff0e469c6f48ae7e881ab4fd4e7ce3d57d8c9ab97baeb2b3c4e9cf6866559572f5f7bfbbd2bf55af978bdaaa96a7bb3d7771c68288e1e69027c72 +767fb53261d6cad0e628194d1d574912e886fef077fe751ac51b4bcbd5f536637dfbd8c323e1d223c7b07ddec3f519b9c8452e72918bdc31e7b2c76766be78e2 +c443cda6bbb17173610124aa7e96f540e0cab2375fbf0cb2c3e146fdb92347484e5e7fffbdc5d5b56673f2ef3df7b76af54ac0fc95759331e5ec9373a5b2b1de +f17e787121e3b9adaa91ae576dfb973ffbd95aa9b478e3c6ef7eed6b454654523b7e126496d972f9b1991948167277894b3fff735204648cd16de697e5cecf34 +4de1c2b6edc27803e743417087e7edae5aad82f40972e4f0fca74ff556d2b4b12a67e422772f71274e9c620a9bb0ed244baba6fdf9a3c74b06db0c9c81ef5913 +8de9274e81a72c8942b79f73eeb537896daeaeb62edd5a3b34537bf640d3d4756763737de05925fde0fe4985e61373fb2b1307985e98b5cfa8c28340f183c471 +befbe73f683bee61854ee724558875f2d191704b274e61fbbc87eb3372918b5ce42217b963ce65a6a6552dab6e97a831908b0553ce63108f08e9b9a1cf9229b3 +44b90a01fc20ecf607a58aa95bcc2e6b86c15485c2ffb58a55af995192e98ca5194f413a515548c8fcc4c454a5d25f5adadcdc94bb03274e28904ff00692994a +297277892ba53a900b4f9e3c6959d650ce731ce7b5d75e5b5f5f07b9f0e5975f9e9a9af27dfffcf9f383c1003c379b4d9014778886904e78f8e28b2f1a8671a7 +60bac3057ff6676355cec845ee5ee2568e651cfe4d32f8646aec440127c2a09da2908c478e43551625499a519e457e14178be1a952b5345dd3dc384e4041659a +5d2b1986e6f83eb41496176aa6ab654692c42a67411873cff382a06eea4a0cc9640a81a4d3e2e4d85170a1afc5f6790fd767e42217b9c8452e72c79ccb1abe9f +c5ae970e022521b34d90b9b43832e33825244c53374ac3dbe7f09172b53a353363576ab7163aed4ed8da708a1d90246fad3bae1bad74062b9d0ef06c4d33743d +a7f4e2e222485e2b9b9bb6300bac542a6dcf2b76217a5ec3f340c642ee2e711d21d551717832b87ccb74539aa6499244510417954aa5d168808ca86c1ddd0cd7 +f2a4e5ed4b46e11a24489038a5d1e61dab4977b8a5312b67e422772f713f6aad67941ee8f73fd3efe596d94bd79c34dff7f4b3d3271f0b07839b1f7f641aea77 +7ff8ce3b97aeeb1a5dbfb91c27c9c31393e7e60ffb71f2bd0b1ffba1ffd2dffca55ffafccfb4dbeddfffdaff095aeb13edf0e0c41af46c21096cdbfce36f7df7 +c24fde2959da89206239570fceb199299266a3e262fbbcb7eb3372918b5ce42217b963ce6507badd346c771225d438397e1c62367cbf1c04206b0c2e5fdef43c +a756937203c094729931f6d6db4baaaa787e1040521272f5fa26247ab5dfff607129e5fce4810313535390923f79f7dd2ccfabaedb04494551d8be7d1f77bb90 +f029cf9bebf5a8a2207797b8528ecc8589663154745b8e0c824055559017e11bae5dd7050fd2d4732ece699426a040b2a45b6738cbe0f26ce7a1bc084f20d49d +ab4317c6ac9c918bdcbdc46d0541717e4be86bbe97539e865ec253786354aac56eb13c235c49c4467792b29ee37a5174b456af1806c4d67107a060c3856140fb +c278022a6b61465e4c995343516c5d8be378bddf9f484c93705058158db192cd2368763647c2bdb4b284edf31eaecfc8452e72918b5ce48e39977122a5012a3e +b7a5841d020217e7f50d1f8ab9023a9c31c8b6c40a19852a2c0d10712bd7284a39850b63bf448c5114112277d7b8d23f4881e7cf9f2f867e86f173de68342a95 +0ac891afbefaaadcffe9894126b868b55ae0071e369b4d5dd721f8850b17e0ad6559402e97cbdbe79dc0f3f0cca7a1ab8c59392317b97b895b2995d33cd74f9e +d098460cede0335f60ba911bc6eae58f41556ead774c535f5b5d5d5958ac58e6d15a15105112bfbdb86859c697fefa2f809f27cf3e35f5d031a55c89416be579 +6b6d23ef79b1cadf5959a64cedacae1f999e008df4baef2984a6bd2e34498467a3e262fbbcb7eb3372918b5ce42217b963ce65ef677c26b526d36a92c59c0c8a +c981247182202e960614a7f3259c6f4411048ec4c482dc57c04004495317609c7fb8baeac6719a24153187f078b379f6c40988e1cfdf7fdf8da23e211da0e679 +da6ecfccce423abd28ba98656aae207797b813b296703e180cb65b6fa6e28065552ce7701c677b95ca85a96722768d0e9f801009de405ef47d5fce17c978e049 +bfdf97fe870e22df67db6355cec845ee5ee2ce1e38489254ddb79fce367455dff799a72a95d2eab51b83ce469cf1bee7c53cebb4bb1badf5b8643ffed043254d +bbb2d9b9d96e1fda37f3f4993334cb0e3cfae8be634758a594d03ca1b40ded4fb713a4f9477d27c9c9c1b23d65dbd07aac8bde29707d481725fccc7c6d24dc27 +0fce61fbbc87eb3372918b5ce42217b963ce659d62eb3fc80e864a40042afe83404996892d00c5d800dc465931f5c1e56082a2188c69f0515539b4d0f6fd8ee7 +b13cb744bc75cbda57af17b68e84e411e7b95b24944661b80f24184a41aee9403e21adc8dd1deec496600742612e8673344d93d2e4f0e02519277c1b86b17dcd +e7d0e6b39c6892de32994e424cd3040ff0d6b66d19e750e884872af819a772462e72f712f78455caf4b4c4b9e6475449166fdc84c6a1bdb11eba6e926652294d +b2145a15d045e1c223a45c291d32d8f4d4242f0eb357d7d7d7bd0ff37ea74be25449b9a1eb151dbcf3fd9a9ee57cba5a9e2c572012a7bd99f2ccd635c332952c +af8d88ab62fbbca7eb3372918b5ce42217b963ce65f3cd661bc4a995c2b8515b6c17ecb9ee200852d0ff7971f21e7cfb62ce21749cc8f7534d5b314d95b1cd7e +7fadd783180f4f4dcd4f4fa7beefadac140b0992a4eb794e189a8c65ba6e97ed8ad2006f03559f9b9c84040e282d890c207797b84389b0d96c0248d77569d839 +080269bd595614780572e1f3cf3f5fa95486c225089aafbcf28aebbaa97044cc3bb55aad5eaf07319c3b774e7a8657c31525100a64e88f3ffe78aedd1eab7246 +2e72f712f74b679f80787abd41619c3ee3fff5dfff87619c1055e154219c2869024d8a9f44d09e40346e92a4aef7fc2fbef0c499c739a1079ffeec64a3f63ffe +93ffe91bffe65bf56a65c275ad349d9d691eb62b89aa3e71e810342c8f7ef1d987ce3cb1d1dafcadfff61ff707fd235393d3951af46da3e262fbbcb7eb337291 +8b5ce42217b963ce657fede9a7bff1ce3b572f5e541545d375484722048862a1a098228892641d240f42fc8585b4d381282e0f0639631b8301f06cc3f8cd975e +7a78dfbef5c5c5d73736b224e18e73596c0e9cb0ed9a615866ad5e9a058963b197bc70ea1444e87a1e0825599e237797b81b5bd338f21c26c3306ab55aa9541a +5a6f1e3ab805b9b05eaf0fe54810b5b32c03b950a64dee014992848ad927903b219e1d1b49e05514454019b772462e72f712578c1a1736de54aa30028d000f93 +308a6892e72aa586a631cec32c87a6013c1607dc85116899c2d88b5a6b54eb13135c373a71aca4a91906d08c444108ca76cc183410b11f4013d1989a4ce23021 +104f4273a2a9aa9cd01e0917dbe7bd5d9f918b5ce42217b9c81d732e03f12a17cbfda95837984b7b00797e5bb0108282bc1e3ee79ffc802cc2144515128a942f +b80820c252053e0ac45c481b8528570873855407e2097277895b18a616e29d0e1568cb32b30a822f88c21089d8e1290d32e762dba7b4db2c8542b8059ff21c66 +10314170846b901d212ab896c73eed90236528f0366ee58c5ce4ee252e5340a556dc345d0b02f072bc39ed86e55307e70ece4cb97df7caebaf29290f1ab5c832 +0d553ffdec1908327bf460662b83aef7bffe937f06fd157df39d97e1a542a73fff1cc4b0ffe8e1faec34608cc969683f2ebcf7ee37bff33da6d2471a9379b5d1 +8be32b1b2d95e4a3e262fbbcb7eb3372918b5ce42217b963ce651b5134592e1fcbf37aa974e6a18734555dbc7469f5fa7555d3264e9dd22c2bca32272b6cfb2d +13d255144355e7cb65783b97a65610304db38ae3fe2237493a62d36099b19a6d47bebfb4b8188561daa8696c1652d0eab9726b018821eb61084f90bb4bdc1fbe +7f3917e72a9f3d7b16444010fe3efae823b9b1b35eaf57ab5508de6ab58a5dafe215f8bc5dbd846167f00312a4a6692fbef822c88e44187f82e0e07961616187 +7927e9c0f3912347b45e6facca19b9c8dd4b5c55219a42fd345df75d5d5167abe5c0d07fe6e8e1671e3ed15a5dd35e7f8df0342897e289295d638f3ff3a46630 +aea8b464869deeb7fee0dfb93cffb2a19d539430a7d3274e1085959f38691e3d982771b55aaf371adff8b3effcfefffd9dfda6f92bcf3c532f59afde5858edf6 +75c8d288b8d83eefedfa8c5ce42217b9c845ee98739997a615d3540899add73f77f4a8a169efb75a06e71aa547f7efb7ebf5e5c1e0c2ca0a04e852ba46694551 +4e9aa6aeebfb7cff10632062e89c476916a5a9cf79ca3955144bd7f3280a3b1ddf05d951499afbb39c0f8288897c72429c2401e103b9bbc4751c27175b348767 +2f876128053e3917946e1db904af8220c8b69ded24fd8003e1726a6acab6ed7cdb541238dff7e9d6bad361248670e356cec845ee5ee2821ec969b18c1cd448f8 +0b8f36369c381c0471d7f7fb41e0150d419e7092f2a271e9ae7774dda006339324f4c3a989ba41489a241b51947162476161e5aedd8e4d95726864a22888f59c +1e50d5c94ac94b222550d29c6b4c61c5d0f368b8d83eefedfa8c5ce42217b9c845ee987359d7f30641e08761d93423818fb22ccaf38c73278ad230f4832017cb +2959968144a5898d04905c374d37b24c51d512cd7425230a874ce442c2e0624d82592e1345a19ad60f834242cbb2b6e32894761c07a0e00db9bbc495933c20d8 +49cbcc774eef6c7f087e76c891523494a7370f57920c7d665976a71c090f411e1db772462e72f71297d54a3c4e1f7de1d9a70eedef6d76feaffff2d757d6da0f +37670f37f7b71c773589b3383679ae331a46f11ffd2fff02feea1325cf880a1a73bd3ed15095cb9dcefb516429f4ef6afd5aadf4f6b7feedf2073733db7cbf52 +062dfcf1c9a9ffe28be7bc243d7ff96a94a484a906d3202ba3e262fbbcb7eb3372918b5ce42217b963ce65df7bff7d90a2b23405ea86e398babe1186eb690a09 +f25a2dd575c36e37b97103783542187cb26c00c9656ccdf3c2303478f6cbaa671926d5c292422121a4186648410c39f4e8a339e7b7badd1f5fbf0e784ee99fbc +f5162474b9d7bbbcbe0ec942ee2e719f7bee39b2753e73b7dbbd538e94a2a45c05da6ab53ed5836559dbc5cda1e77ebfbf438e946f57565636847dc8f12967e4 +22772f718b4e268b0dc68c92adfb7ec6695c6c036386ce3495154a69c6154531349d2659eafa5992862a8989ca744d2d679024274a7a41542f769e33bb648272 +e90e0679e00f7212a68936353551ae2abe5f9cfa0afd0fc4579c204346c5c5f6796fd767e42217b9c8452e72c79ccbc224e1f049d3043c099980e77956ac94cc +53ce73314740843ca1880dfd8a187280e731e7012f5c4e73b1f4b208025f744bb0609a563c5114693f90284a28e48c208e8324016fc8dd256ea5529192220891 +72bbe650f21b4efed0ada39b9224193e1cbe2a86918439a81d2223c4296d3b0f9f0cc34651140aa3d9e353cec845ee5ee22a47f75350b22b1628d2100b3cd329 +7d7f69d1c9d2d873b3aaa5e5e682dbdfbce2ab39cf0c3d07ad9a674a169b86f6cc4387014ee69b942690ce1f7fb09051c5b6cd63671f1bf0d45c7398a22ef4fa +5e94463cd6340da27feab1e30f1ddc0fbaf7a8b8eb5797b07ddec3f519b9c8452e72918bdc31e7b2e78f1f1f44519ca6a6aebf79fd3a087b03df2d442e45b9d6 +ed248301080820571181219ceb8c3dd26c1abace672738df07112f6d3acbdd8084d1c4d103e06d338b166fdc28929b24f0dd0d82e2b8204a1f9f9b3b5caf436a +264aa583f53a2400b9bbc475b78c365996258f6e0ac3900bd38ef0441a7c92e733c113c33076c8857c6b39a8effb529a940e6ea569288841155b4d883001350c +3e6ee58c5ce4ee252e3d30a14287a19a34cfa07be124d798726b6363d5e9693999b74d45216b3df7aa1318aa5ab76daab25a14b1a4b0a277b2394372664d12b3 +aefa5ef4afbefd66db893e7762dfe187eab41fa8ad1e25b4edb91dd7851ca94ce7343b7ef8e0179e7adc0bfc5171dfea06d83eefe1fa8c5ce42217b9c845ee98 +73d9cf1d3fbe16047e9af67cffcdab5753ce27685aab5a09cfaf773a4e9ae9aa6a038f906a1c6b9c1b8257324dad4cf41a8d93ecdbaf7ebcda76a6aad6d9a307 +40bab8796dedd2d21a005445815ce5e25c5fa6aa678f1ca96f1d0e4cc54900c8dd25ee7921478280f8852f7cc134cd2008befffdef3b8e03d7f0a45aadc2f5d7 +bffef576bb0d4fce9c3963dbf6505894a69e73719ed30f7ef083c2a8d5960309f2f2e5cb209202e7e0c183508de06db3d91cca9a872d6bacca19b9c8dd4b5cb5 +1801ce79a1168a0414ea243599661aa6c6739a7994282a653ad3000a9a79ceb3fcf6d12f34485206d711cf7d1644b1a62ab6c9406fcfc2384b8a6d63a0bd33aa +aa624a598c33f3308a5dcf07cfa3e21e9e9cc4f6790fd767e42217b9c8452e72c79c0b3252de146681b252e9e17a1d249099b9f2e46c298ad393af5d1f0c422f +8e5a8e735bfa12a9fce30f3f848b7dae3bd7efabbafe9fbcf452757616c48bcd761bbc3c3e6b36cb5369962df57a519a1e9b9efedc91232063d5ab55697fc8f5 +bc5ebf0f17c8dd25eef9cd4d080ee2e39ffee99f26c2c60311d34710169ec8db49e1e4d9cb2011eaba7efaf4e9a1f566f0dceff7bffad5af824c59afd7bff295 +af80bc08c1df7efb6d88364dd3e5e565881984ce959515b2e50e9c3b3756e53c2aeec15ff91b4444047fd3eec0f9835ffb071b9bed9f7becd47ffaf4335cc90f +3f3e61eaea9b6f2d4e5fdf04c568a1d32dd6fb80be03e04293a2dfbaf4f1b15e6f76e0e425fbec97bef49ffffc0bddf58eeb7b51967ed05adf5f995172a3ed38 +955af537ffd96fd51b8d6b572f7737d655557be4338f21770f7335bbae096eb1f19be7fbeb752dcdbef0f0b14766f76fe75efd34ee37df7b2fa374c8fd7f7fe9 +4b46d9965ca39cfeec4354a5cadaa0ff29dcfac8b84fbcf0c248caf91f7ef2f7fdad5ffb07d166fb85c74e15f9bd76a5e0d6d4999f79fc767e1797b673a942a7 +b7e5f7ecb6fc165c7ee213f9fda7ffe87ea857a3e24e5d5919ab7e01b9c8452e72917b7f724728b7dfdee3270718a4a3c590002d96fdc163b1e22f1739ccb7fc +d06d3e859f22381dee15a4b7ddf608a9f8877cd221f71e708ba931b19f937c9a93eb3f87d79feae13ff4643822f0a9318f2abfe3c055c55a5fad385b4b835600 +64ff5c112f79ae68a46619a6c90c5d53c41c66184759c689ce1455c9734ec3245169e4f991e742826cc64c4d730dddc85292698a06de54aea819cfb3bcd8b24d +54857312c7a9a62117b9c845ee03c31db77e01b9c8452e72917b7f7247d8ff16f3f93797971dcfd30d6362660600176fac3ad7fd9c937e3b48125e36cdb3478f +42fa366fddf2bbdd4c55db56b18b20c8f3cd34551565dd7523db76fbfd85ab5773cedd308ce39853526624834f12dcd8dc8468e754f580610c0b17b9bbc7fdcb +fa2a4e63860b0d7eed3bea371147311b50e9c47cfe9d1e202cbcdabec313bcc9a39b6cdb86579c73dff7e5ce52b9d174acca79545cf583f77555f9f0cae2c2da +3afc3567fdaee6055114f90a7106c15f7cf387f0679ef93c8f39fc76cf3ffe986d592b1f7ddcb979536b348ccf3e91127ab4563b50b1fd38f9e6071f86796676 +07aa3b8086290823c229fcb64d4b31d4b8dfed2549522d5c1952be845ce42217b90f0837beb13e56fd0272918b5ce422f7fee48e506e2ff4fccb376fde5a5969 +4c4c9c6934405b7bfdf2c29bd76fe84c3d3e33636ada64b5fa85932741cffb606969a3df8f74bd679a9c105f9cfdab523ae1382e3c5c5fffe8bdf73868809416 +2aa3c66a87a6a9a626b1ff71aba5506a58d681c949baa5322277f7b8446cc85414a5d96c021794f393274f5a9675e7e43c15bb38641a4dd3dcee416ef22c954a +e57219aee115a419e201ad9e6c9df0ec38ced7bef6b5761b6abe75faf469321cbb1a8f721e15575dbe59d2b4b77ff2939f5cbc64eb9ad9ebb328823fec54a19d +30fa931f5d0c787a7276ffbe7a8971fdcca143f57afdddabd758af6b5866f9e87c9af2f9c71e993f3adf6e77ffb7ffe72fbaae3fe7f46b8e0b356682a9d0ca98 +f3d356a9ac3125f4dd24899afb0fd4a626b22c7bfdedd7908b5ce422f781e02e909f8c55bf805ce42217b9c8bd3fb92394db5996e76ab135b3b0d993661911a6 +023455618a02caa29ae7cad6da6ec85b061f61ef371386fe535156b9380c8088f5e1e038a599b890e70114ab1d8a33008aa5e38930f49f4070613218b9bbc41d +eaf0a0e1c3ad6118b55a6dbb31a7edee3fb4a45f4ed1ebc2c99524f06d6d5972225beb53a0ae8761a80a376ee53c2a2e441fab44338da95a43d768deef2784e6 +9cfa31a425ad574b76969698a273aae524a134a42435346e5ab9658a733af2d80fbc6e3fe90dcacc888dc408754363b9ca5245e1242b76016739e59c12c812f3 +3d8f8b233d908b5ce422f741e18e5bbf805ce42217b9c8bd3fb923ec7fd9b5cdcdd9f9f9e6fcbc1345e72f5d4af39ce5f9f1e969f87ed875ad34dd270efb05d7 +c9b2e5240939bfd5ed268a9216e3108aa628d39e4718f3e05b688ccb8cf51803fc11ada26b9a3b70daebb78ab9e56af556a7531422a5a62820e4ee1297ccceca +fa174591386ab138a569abbade7672429e8879fb4f55f28320300ca3542a99a6099a7cc1156b04e8d61a7eb888e318fc80f20f7ee0e2dbefbc3356e53c2aee77 +ffe84a9af303e5fae983fbe037b5f6cf5bbaf2daf51bdffbfe2b65d33831359d2af498e7cdacadb17aadf9fc33d599e9758d87b3d37673fae4b99f855f7c65ad +756961254e4237f2a228497951197c92bf671889ce0f46f96437322dcd73077573fa3bbff3fbefbffa9a51b2bb250bb9c8452e721f08eed4818363d52f2017b9 +c8452e72ef4fee08e576e6c771bd56b3c0df60b0e1ba719ace944a65cb629c9707033b8e21ab52b18b33eea7599493204962d0f1b22ca45427a4b0ba9ea65c8c +91d03c0f28ed2b8a4995b8b065a04659b1855b55d52849d68200fc9418ab1906c489dc5de2ca7a094af8850b175cd7d5757d6565c5d8b6290594fcc5c545f000 +55676e6e4e17e7376c777215c0d34f3f0d7a3e28f96fbcf106d463f0dc6c36354d1b8e1770ce1f7bec314817787ef2c9273ffae637c7aa9c47c58d922cc938ad +14d63838a1b59269c12fa8a8fd28c8296fa86aa6aa908cd42986660853a9a1118881e716514cbb38b29be93ab3b4f4f6c823557385f15ca50ab462c538629a79 +69122b9a66958d6a15ea49b7dd294771a4ebc8452e7291fb4070d37265acfa05e42217b9c845eefdc91da1dcce7a51d4dddca48a020a7fa354ca38df5fadce96 +cb242b1635c043dfb2dc28026eadd99823731ecfaf76dc3ce31a6325425445697b1ee439f67dd73072ce55c3a83266ebfa5ca301c5d74f124d8594283c8e4b52 +d5ccf3be8810b9bbc4954a3868e3a09c3b8e036a7cafd7dba1e76f6c6c80020faf2a950abcda3ed52faf6ddb0625bfd168b8ae0bf1400ca0e797cbe51d830272 +3b809cf91fb7721e1577d0eb419cab9414bb7bb2b4e3fa29e11a551f3f70b052b2ce3d738667e4d081d9896a1dda00ad5a8ef36cf69163a59909a2b3e5e56553 +373efcc9db372e5da20aebbb5e94666b0aed974a8469fb2b25682ccecccf3f32d3f4b3f8ad6ffc7b55619dd64663fe50319a885ce42217b90f08d71eb37e01b9 +c8452e72917b7f724728b7b35bbddecd76bb1f040ddb3e7bf830a4fbd4f4f4b1890948fabb954a2f8ed57279dd712821738f1d3efad4fce6c07fe77bef902002 +85afaaeb3ccf2fafaf4769ca54b554a9104a2bf05c552b96f5f4430fd54aa536a50bd7afe7942eb9eee4c1621ddda6eb2ef6fba04c227797b852035714057478 +f8865f5a1ad51f2ae79452d334e52b2eec4910614b5f91bb53844fcbb292240985f5c8e10e96626b4a96ddb9a55faef39f2c97c7aa9c47c5dd68b7e1478046c1 +4fa0f5883f5c5df692e4b9a3c78e4ecfd865ebe9273e93c7f1fee73edf78f491c40b7a0b37e007de77ecf021f361cff32fbcf96e6af1c52b373efcf15b9a6575 +074e9265a16150553155f2985d8992e8f88183678e1fdfec75fff00fff4de039c6fcbcd998c8d374e3fa35e42217b9c87d20b8d81f2117b9c8452e72ef07ee08 +e576a68a2dd78a3c56501e06b8654240dede9ee0a514b2541821d8b23770db8fb00f70fb035ae2d6ee6dbaed9c42ba75f0a0d8dc0dde206d857503e4ee12573a +dbb65f7ef965d0f0a14a5dbd7a1534f6e1d67a00eddb576c118157172f5ef43c0fd4feb367cfcad3f2a4717e50f2171616c00378abd7ebd56a1534fc76bb3ddc +d8bf43cf5f5d5dfd9cae8d55398f8afbd08169085db22b65dd8ab2b4ed0dc224669ae2a7b196590984d70d6fe068abad348ab22481c85aabebae3b805fd0e9f6 +82c0c8f24cb76d665ab3d3539c735d3375a6d09c400c61927aa1ef8483300e4a96c6882d8ee584f4e6c8452e7291fba070c7ad5f402e72918b5ce4de9fdc11f6 +bfeccb9ffdecb5d6cd9e3f80fc06a9028f4dcbaad5eb4996cd4651258e7555f584b2f7834b5757ba6d5551274be5c95265a654da5f2e1767f7c5715a20b56aa5 +0229bbbcbcbcd86eeb9a1ae47d8dc401f14231ff0b9f5ffcf95390fb7e3b5c5f29ccc2217797b8e4766d5626272741758fa268696909ea8aac84f25b2ee307e5 +1ff476f020e7f6a575fd5aad26b7e58392effb3ef8575515dea6c2c55bfb02763888e417fff6736355cea3e2fe1fffddaf2a4cd9b819389b4996a77ffcd64fe0 +67f115d309d35ad53af2c5734cd3dc6ebbbfb4c81512b84eb55afd9d7ff97b7ff48d3f9e6a4c3427a6a0494a7992f0acac90dff8cf5e2e5966b1c6d52e2db7d6 +ffd157ffc5c0f7cf249b3eadbac46b427313849d8cf794622f1072918b5ce43e28dc71eb17908b5ce42217b9f7277784fd2f7b78b6a99041cf53fc24bfb611f1 +9c688c99a6a966996d9a542ce44ec452ed5badcea5e5d5b2653e79f428e4aa61dbcd4a2517c6d872b1d8bb5eaf435296dbed24cd529ea5244ea9c249c2453ea1 +641f3a3c4d2819585123ab70c291bb4bdca1ee9d6f39082537e14b0bfc5ba34e04947fb9261f6a8c302791c22bd0ede5543fdc0e4707a46748f0a7dae7976edc +ca7954dc5aadaa6a8a6fe6b19a71a2a5911fc6516eaac508257ca95a71aa86ae650944a342b365956df81133429324190c5cb84e7892c62110e58023a58a264e +46cc721e655c511443574d464d0acd137515aa29aa4a908b5ce422f781e18e5bbf805ce42217b9c8bd3fb923ec7f9913867e9485318fd2db53c15e186e0e06a0 +e1b9dd6e1845aaaeebb60d69652a5c6aa6ae4f96cb06e4b354aa964af0bceb79c581849cc7424b343575b262daa6eef8719693cd306d897c3a717cedf222946f +e22b71a8e62447ee2e7177a8df72293ebc0c82e0fcf9f38ee30c5fc1c3d9d959a9f9773a9d6eb74bc50a7c452c6891830243cf50fb9f7df6d90a54ee3bf6e74b +77edf28db12ae75171fff5fffe473c4f27260e56cbd321894f3fff45c3b4de78e7c35b1f5db6eb4ea7b5a81bacbdb8ecb737a18db8f4f1755d656b4b2de0d727 +277ef5ef7e4921949946ce148d28b5e989a299f043370c932cadd89aae59adb6ffe38f963d3fbe906431cdd57e9f2431e13972918b5ce43e28dc71eb17908b5c +e42217b9f7277784fd2fbbd25a5fef047ec88b218b621b02bdde6aad6c6ce459165cbdca3daf3c3bdbfccc6720a1bab0a93e55ad3e7bfc78c5346bb60d19861c +be72e912a88e1a288dbe0fe1e7a6ca07270f42163fbcd549b27cb9d37b4fe88a954ee79ffff61f0063dfa1f9a3a71e850be4ee12f7c94faadfa0b45b9625a7e5 +e52afde1143d5c0cedf30d37de47c2bce47607dee4a20050f2ebf5fa763d9f6e5b3ef0cf7fe37f18ab721e1577e3fa8d88f033a7f323c77578f4f8173fd7989c +7ae7da0d689e26c2c9c8ebf0447736569dd5b524cfdffbf13b84a7edd67a460bf40b3fff2c25aadea8da956a1a27d72f5dcb6812a5340d0288aa64189aaa749c +288bfb7e9abe19c57e1a375da712859c92ef7ef71672918b5ce43e10dc71eb17908b5ce42217b9f7277784723b2b4e0f100b0bf896ee064f0093a729971f7930 +2091160a0a6b03627901836fa6aa321017db0fe09b0ae337f01fcf799ae549ca13ce23113ce53c08e23ce7719c48f300c8dd25aed4d841bd0fc44191f21aa21c +5ace1f2ae722557cc7fcfcf02d78961a3e04046f499244c20dfdef083e6ee53c2a6ec5b28c383634569cd741f32ccee0473174b351abdbb6ed7a8191723f843f +f50c52a41a6a9a53bb5c9e6c4c542a15d70ba1324434f78328cb321e07392531f80da258586a54085515ca986a503e532ec30f6f925c87ece414b9c8452e721f +14eeb8f50bc8452e72918bdcfb933bc2fe97a562b0419a1c942ec9b2541c9fb6009a9ba2d841b072f366f13c49a66ddb5294f797970dc68c20303d0f34486376 +f6d0e464b1ce01344042bc200c229f5065aa5c816f06c529363044696a90422354a00cb34c1610727783bbbcbc4c44bd942bf0415d6f369ba0de834e5eafd72b +c25cc4ed3a9d65ad560b88e40e370c0575f1c2850baeeb425dbc78f1e270dd3e4402c1d7d6d6860b0126c7ac9c47c535f38cf18ca48917c5aaa64c1edc67974b +7fe36fbdf40b7ffdc5f6e6e63ffd6f7e1b7ee875d7e97a1eb42825d3ea7707ffd57fff1b5ffedb5fea75ba240918634b1f7eb4b9704bd30c9629b6a9bffefa9b +ef7d78a5ac1b47ab932a5137fcc1c2faaa592afdd6dffff5a999c6bffbdd3f7ced073facd83672918b5ce43e28dc71eb17908b5ce42217b9f7277794fd6f067a +be3815806ecb27e412be97f2dca1d40ac376ab056f674aa59a6180d6786b73b3981f86874b4b9aaeffcc8b2f36aa55370c7b41001ae0c04f7a6ea4337670baa1 +6b8cf67ab1d8e4ddca73266680699e6722e7c8dd256e6f6b8bbe9c7b87fa512e97755d876b61b541956f212ddb0fc9db31ab4fc4c67e0805b1c6712c6df20741 +00c1877a3e04eff7fb430bfccd312be75171f334e1c2156388948a431258bd5e370c2d2759abbd49395d7507eb81af115ad7bd7e14a954999e99ca090f07b962 +68baa69a8ac254c5d458c93279920f5c9f96946968c0981ab5a3f576bb9e6515cbac956bc508512e6c3a8a651dc8452e72917bff73c7ad5f402e72918b5ce4de +9fdc11caed0cfe8dd33448920ce0427f2b2cf8294aa2aa53e5b2adeb7242988ab50785072820a1e371f8280a7cfa61483c2f4a1279681bc93292143606bd288c +b81688c9628857a75405559373451a6c47eeae714ba512d9e614e1c8d6ca13f930df72f2169e9ba629bd0d430d3dc32b50e9e17b7b0c32946d43da7579ab1ac6 +5895f3a8b8f5630fa759ac57abd06428295b5c5cb66ad6c51fbf7bf9fa759baa2f9c3cc5d3a43c3bab372a1053e3c4c359963d79e6896ea7e739ee876fbca3ab +ecdd77dfbd71ed3afc704e7700083325a7f6ef0bd364b9ddf6bde09917cefd9dcf3c9ac6893651e7a656d5d93421b6c6ea73c8452e7291fb60708b21e971ea17 +908b5ce42217b9f7277784723b83147cb4bebedced4296f6371aa0db1d9b9898afd721c52f9d3e0d315e6bb5fee2830f2052a0ba710ca55011b9dd206405b4c1 +34bd72f122d5b4e94ae5678f1d8312e19d4e70f366c6d8c71b1b29dcfbbe2616453caa69e491470027b550e4ee1e77f6a597b6abe2711c5fb972250c8b0d1e52 +57cf3f694b1f6ee1f9f3cf3fbf7d4dbe0c05de206d4f3df594b4c96f59d6f6697f0875eedc39f8960fd7c270acca79545cb67f26e3c428957445250ae976bb09 +cd2fbcfbdef9effe687e76e2ef7dfef359941e3bf3f8bea38733429bcf3fa71a46e878c5cf4d95e5ab3774a67d70e9da7b57af6b8cad2c2e7941f8c2c9934fcd +cfb706fda5cdf666bbfde5478eff47bff27736d737566e5ca1960e9886426c424bc8452e7291fb8070271f393156fd0272918b5ce422f7fee48e506e67a0bc45 +69eac571314421b435a6aa96ae4386272b15cb30da03474eec267961a2007445f0a6e47992e7a1303c10837617c732882ac633e43abd208a6255d5d39440284a +752829c380f815c6e056ee5840ee6e70eb504db7e9f9a0ab0fd7eacbb9fda1863f9c9c8787d56a75bb2dfd6128ba6d81c08eb5fdf00a42d9b62d6f37c6ac9c47 +c54de2c234881b457e9aaa9a6ef7dd94503ba7f3556bd634a38c6779e273e2529a2699b9d9a786eabb4161bbc3192429cf6962aaea846d420a936ab56c02538f +79ae68ecf043f31353938661f47abdc0f7d52c6769ce152dd3cd54d732e42217b9c87d40b8ea98f50bc8452e72918bdcfb933b42b99dfdf8da3508363f3969e7 +f981c10032c092a4d76eab1aabd658a695742b3d7968a218c248943ca38cb146ad06416a8c41d241d5f30949c59e87cbad16e4672d8e7b969550ba992451923c +3a39f9d7ce9c81e707aaca4fd65cc8e76abf7f716d4d1628727783bbf6c983f1a4b57c799d24899ccf4fd3547e0f1578dff701ba7d3e1f3c4b0f59569c3a010f +8716f887a303106ab8fe5f7e8f4f398f8afba36557d7e80faf5cf970bd5518e1f8e852c6d869a7ff1f87010d8cda849d04cad4a963cdcf3d9d783efc8e96c2de +38ffdd8b6fbca1eadacd5bab594eaa71f619b392d27cba3993a4f974a31e3132d33cf46bbff93f437208cfa8aad46a35f5ea4d3b0e58bd121e3fa05a36cf0872 +918b5ce43e105cec8f908b5ce42217b9f7037784723bfbd1f5eb9f9d9f9fabd7cd2038b0b8a86659daed0e0ab3feba7f6a26af70c3e68fcc4d4271e889a5669a +a2aaa54a4555145b55a562d71a0ca2240545f08a283527497cd3849c6f044190a69f7ff8e1bf79ee1ca1449de63ffebdef8096b8d2efbf06204a91bb4bdc7ffc +a3b7c9275d1445d26cdecaca8a54dd87ca39dcc2ab300ccf9f3fbf7d7ffe706d3f28f98b8b8b50eda08acfcdcd497b7ed2cfd0a4bfbcfd8c180b189f721e15f7 +95dffd362166ca7998664c49dd284863157e41f8c1f23849c3888785fd4555d1e0ef1e1a2c95690a7ca90a29460af39888233614a2e6344b73f8401d80df177e +68bdf0096d1de594b0bc30df58d374dd3201430c96a50972918b5ce43e105c9e617f845ce42217b9c81d3d7784723b3318b334ad5801200e57838e918bf1899c +e47e946441ccd34cc44fc228c99354d358b5516500578be50c34cf4d43533525cd7812a7906d28022634bf49db2e0ef15394fe6050e4532b36784318786b1696 +0e14e4ee12d7f7fd1d7abe5c9f2f2c2f166efb9cfcf0d50082dfe1e06d9224aeeb82ceaf695a51293fb9745f9af4bfedd9b6c7aa9c47c5b535c350d583d55a9a +f28aa9fdc293a719d32b9ea307ae3e519f3bf75c61e7a35eeaaeaff03871da1b96655dbd7cededf7aed46be5e3f5aaa6aaedcd5edf71e0073d7aa409f0c9d9fd +d5ca84592b43dd50329a3aae9224d04cfde1effceb348a379696abeb6dc6faf6b187918b5ce422f781e0d223c7c6aa5f402e72918b5ce4de9fdc11caedecf199 +992f9e38f150b3e96e6cdc5c5800523fcb7a90902c7bf3f5cba0db1d6ed49f3b7284e4e4f5f7df5b5c5d6b3627ffde737fab56af04cc5f59371953ce3e39572a +1beb1def871717329edbaa1ae97ad5b67ff9b39fad954a8b376efceed7be5614a04a6ac74f824e395b2e3f363303c581dc5de2d2cfff9c54d11963749b797cb9 +333f4d53b8b06dbb301ac1f95051dfe179bbab56ab5093a07a0dcfe7fb546f254d1bab721e1577e2c429a6b009db4eb2b46ada9f3f7abc64b0cdc019f89e35d1 +987ee21478ca922874fb39e75e7b93d8e6ea6aebd2adb54333b5670f344d5d773636d7079e55d20fee9f54683e31b7bf327180e98579ea8c2a3c08143f481ce7 +bb7ffe83b6e31e56e8744e528558271f452e72918bdc07825b3a716aacfa05e42217b9c845eefdc91da5dc6e6a5ad5b2ea76891a03b9983be53c866084f4dcd0 +67c99459a25c8584fa41d8ed0f4a1553b7985dd60c83a90a85ff6b15ab5e33a324d3194b339e82f6a8aa5000f3131353954a7f6969737353eede9e38a140f982 +3748b14a297277892bb56ed0db4f9e3c6959d6500f771ce7b5d75e5b5f5f07bdfde5975f9e9a9af27dfffcf9f383c1003c379b4dd0e477a8ee904e78f8e28b2f +1a8671e7c0c10e17fcd99f8d55398f8a5b399671f837c9e093a9b113059c08831c8a42321e390e5559942469467916f9515c2ce6a14ad5d2744d73e338495385 +6976ad64189ae3fbf08b5a5ea899ae96194912ab9c0561cc3dcf0b82baa92b3124932904924e8b9345918b5ce422f741e0820c3756fd0272918b5ce422f7fee4 +8e506e670ddfcf62d74b07819290d9263cd3e2c88ce39490304ddd280d6f9fff47cad5ead4cc8c5da9dd5ae8b43b616bc329760690bcb5eeb86eb4d219ac743a +904f5bd30c5dcf29bdb8b808295ad9dcb485d976a552697b5eb14bdcf31a9e077d30727789eb08ad9b8ac3edc1e55ba6f5d2344d92248a22b8a8542a8d460374 +78b9bb1edec2b5aeeb649b517db9bc1f34fca9a92969547fc76aff1d6e69ccca7954dc8f5aeb19a507fafdcff47bb965f6d23527cdf73dfdecf4c9c7c2c1e0e6 +c71f9986fadd1fbef3cea5ebba46d76f2ec749f2f0c4e4b9f9c37e9c7cefc2c77ee8bff4377fe9973eff33ed76fbf7bff67f3a8ef3443b3c38b1062d5f4802db +36fff85bdfbdf093774a9676228858ced583736c668aa41972918b5ce43e28dc71eb17908b5ce42217b9f7277784fd2f3bd0eda661bb9328a1c6c9f1e39023c3 +f7cb4100bae0e0f2e54dcf736a35a9d7412695729931f6d6db4baaaa787e10401124e4eaf54d28acd57eff83c5a594f393070e4c4c4d4109fcc9bbef66795e75 +dd2668928ac2f6edfbb8db85029bf2bcb95e8f2a0a727789eb6c4dc56f37860f310741a0aa2ae8f3f00dd7aeeb8207698a3f17e7434a137da0f94b0d5f2ee907 +1786e10e137d10eaced5fb0b6356cea3e2b682a038df23f435dfcb294f432fe129bc312ad56237519e11ae2462a30e4959cf71bd283a5aab570c0362ebb80368 +20e0c230a01e309ea449521cc720a6bea8a128b6aec571bcdeef4f24a649b80ef54163ac64f308aac72672918b5ce43e10dc4b2b4b63d52f2017b9c8452e72ef +4fee08e576c689d4d6a8f8dcd6e27628705c9c13387c28e672e9704637db52fb6414aab07040c4ad5c432ef5482e8cb1133136524488dc5de34affa0a59f3f7f +be18721ac6cf79a3d1a8542aa0e7bffaeaab727fbe2706b7e0a2d56a811f78d86c36755d87e0172e5c80b7966501b95c2e6f5f17009e8767f20d5d65ccca7954 +dc4aa99ce6b97ef284c6346268079ff902d38ddc30562f7f0c7feaadf58e69ea6babab2b0b8b15cb3c5aab02224ae2b717172dcbf8d25fff05f0f3e4d9a7a61e +3aa6942b31a501cf5b6b1b79cf8b55fececa32656a6775fdc8f404b448d77d4f2134ed75a1ea109e2117b9c845ee83c21db77e01b9c8452e72917b7f7247d8ff +b2f7333e935a936935c9624e06c5e46d92384110174b128a530113ce37a208121d89895fb99f81818a98a62e6492f30f5757dd384e93a422e6781f6f36cf9e38 +0131fcf9fbefbb51d427a453182fccd3767b667616cac78ba28b59a6e60a7277893b216b27e783c160bb757db850852362affef6aa9c0b53fc44ecea1f3e0125 +1fbc813eeffbbe9ccf97f1c0937ebf2ffd0f1d44becfb6c7aa9c47c59d3d709024a9ba6f3f9d6de8aabeef334f552aa5d56b37069d8d38e37dcf8b79d6697737 +5aeb71c97efca1874a9a7665b373b3dd3eb46fe6e9336768961d78f4d17dc78eb04a29a17942691bea49b713a4f9477d27c9c9c1b23d65dbf02baf8bd62b707d +481725fccc7c0db9c8452e721f08ee9307e7c6aa5f402e72918b5ce4de9fdc11caedac53981c00ddce5009bc2afe033f499689ad07c59804dc46593134cee520 +86a2188c69f0515539a4d1f6fd8ee7b13cb7447eea96b5af5e2f6c0008cd30ce73b728201a85e13ed0302905bdb303e50b6584dcdde14e6c29dea0b4e762f84a +d334a9ed0f0fc69371c2b76118dbd7e40f6df2cb8500d25b26d34988699ae001dedab62de31c0e0ac04315fc8c53398f8a7bc22a657a5ae25cf323aa248b376e +c28fd8de580f5d37493339b8936429fcfaaaaac2854748b9523a64b0e9a9495e1cc6a9aeafaf7b1fe6fd4e97c4a9927243d72b3a78e7fb353dcbf974b53c59ae +40244e7b33e599ad6b86652a595e432e72918bdc0784ab8e59bf805ce42217b9c8bd3fb92394dbd97cb3d906cc4ab1e9bf2db673f75c77100429e8ffbc386910 +be7d31271c3a4ee4fba9a6ad98a6cad866bfbfd6eb414e0e4f4dcd4f4fa7beefadac140b1892a4eb794e189a8c65ba6e97ed8ad2006f03559f9b9c848219505a +120587dc5de20e35f666b309205dd7a5e1fd2008a475fddb0b57f21cf4f6e79f7fbe52a90c95ff300c5f79e515d77553e1e4ba8056abd5ebf5208673e7ce49cf +f06ab892054241ddfaf8e38fe7daedb12ae75171bf74f60988a7d71b14c63533fe5ffffd7f18c60951154e15c2899226f0d3fb4904bf3b44e32649ea7acfffe2 +0b4f9c799c137af0e9cf4e366affe33ff99fbef16fbe55af56265cd74ad3d999e661bb92a8ea13870e410578f48bcf3e74e6898dd6e66ffdb7ffb83fe81f999a +9caed4a0ed432e72918bdc07853b6efd0272918b5ce422f7fee48eb0ff657fede9a7bff1ce3b572f5e541545d375c87f2214bc6221b798c28d92641d344342fc +8585b4d381a45f1e0c72c6360603c8a76d18bff9d24b0fefdbb7beb8f8fac6469624dc712e8bcddb13b65d330ccbacd54bb3a0112ef692174e9d82085dcf03a5 +31cb73e4ee1277636b9a5d9e93671846ad562b954a43ebfa4307b7a0b7d7ebf5a19e0f5530cb32d0db65dae4de932449a8581d609a26c4b363030bbc8aa20828 +e356cea3e28a51c5c256a24a1546e0c7e2611246114df25ca5d4d034c67998e5f01382c7e2808e30229c0b63206aad51ad4f4c70dde8c4b192a66618c0cf1d05 +2134163163f043c67e003f65636a3289c384403c09cd89a6aa72610872918b5ce43e10dc71eb17908b5ce42217b9f7277784fd2f036c2eb61950b1ae3b977608 +f2dbc608a4be28af87cff9273f9074a628aad020a5fec7450011962af05120e6421b2cb25864b2c82da88fc8dd256e61b051a8df3a54dc2dcbf92a5408a82210 +89d8812f0de6e7625bbeb4ab2f9576b8059fe00702562a1550ece11a747b880aaee5b17c3bf47c190abc8d5b398f8acb14681214374dd78200bc1c6f4ebb61f9 +d4c1b98333536edfbdf2fa6b4aca83462db24c43d54f3f7b0682cc1e3d98d9caa0ebfdafffe49f417b46df7ce76578a9d0e9cf3f0731ec3f7ab83e3b0d186372 +1a7ee70befbdfbcdef7c8fa9f491c6645e6df4e2f8ca464b253972918b5ce43e28dc71eb17908b5ce42217b9f7277784fd2fdb88a2c972f9589ed74ba5330f3d +a4a9eae2a54babd7afab9a3671ea946659519639596153709990aea218aa3a5f2ec3dbb934b58280699a551c3318b949d2119bbacb8cd56c3bf2fda5c5c5280c +d3464d63b390f356cf955b1a404d5c0f437882dc5de2fef0fdcbb938f7feecd9b3a0a28372fed1471fc98df7f57abd5aad42f056ab55ec0611afc067be359f2f +fd8086af69da8b2fbe08ba3d11c6f92038785e5858d8617e4f3af07ce4c811add71bab721e15575588a6503f4dd77d5757d4d96a3930f49f397af899874fb456 +d7b4d75f233c0dcaa578624ad7d8e3cf3ca9198c2b2a2d9961a7fbad3ff8772ecfbf6c68e71425cce9f489134461e5274e9a470fe6495cadd6eb8dc637feec3b +bfff7f7f67bf69feca33cfd44bd6ab371656bb7d1db2845ce42217b90f0877dcfa05e42217b9c845eefdc91d61ffcbbc34ad98a642c86cbdfeb9a3470d4d7bbf +d53238d7283dba7fbf5daf2f0f0617565620a15d4ad728ad28ca49d3d4757d9fef1f620c54409df328cda234f5394f39a78a62e97a1e4561a7e3bb90372569ee +cf723e082226ca9713e224092887c8dd25aee338b9d842cfb93cd3a130bf27157239573f3c120f5e0541b0fdec3de9071c28ff535353b66de7dba6fac1f9be4f +b7f6050c2331841bb7721e1597009416db312a950afc12d1c68613878320eefa7e3f08bce207cb134e525e5482ee7a47d70d6a303349423f9c9aa81b84a449b2 +11451927761416d6aadaedd8542987ca104541ace7f480aa4e564a5e12298192e65c630a2b8626918b5ce422f7c1e08e5bbf805ce42217b9c8bd3fb923ec7f59 +d7f30641e08761d9342391ed28cba23ccf3877a2280d433f0872b1cc8065199034b181018ac94dd38d2c5354b544335dc988c2a1f072a10172b116c22c9789a2 +504deb874191f22c6b3b8e4269c771000ade90bb4b5c39090ff5495acebf73fa7dfb43f0b343cf97aa3b54a3e1dafeed3eb32cbb53cf878741108c5b398f8acb +6a251ea78fbef0ec5387f6f7363bffd77ff9eb2b6bed879bb3879bfb5b8ebb9ac4591c9b3cd7190da3f88ffe977f01bf4ea2e4195141f2add7271aaa72b9d379 +3f8a2c85fe5dad5fab95defed6bf5dfee066669bef57cad08a3c3e39f55f7cf19c97a4e72f5f8d929430d5601a6405b9c8452e721f14eeb8f50bc8452e72918b +dcfb933bc2fe977deffdf721f62c4d21b71b8e63eafa4618aea7291484d76aa9ae1b76bbc98d1b90cf1a210c3e59368062626ccdf3c2303478f6cbaa671926d5 +c29242a1004831bc91829a78e8d14773ce6f75bb3fbe7e1db2cd29fd93b7de82025aeef52eafaf4371207797b8cf3df79cac6d83c1a0dbeddea9e74b555faed2 +6fb55a9feac1b2acedc30143cffd7e7f879e2fdfaeacac6c08bb94e353cea3e2168d50161b8c19255bf7fd8cd3b8d826c40c9d692a2b067732ae288aa1e934c9 +52d7cf923454494c54a66b6a3983243951d20ba27a61c181d925330b027730c8037f9093304db4a9a9897255f1fde25450689f20bee28411825ce42217b90f0a +77dcfa05e42217b9c845eefdc91d61ffcbc224e1f049d304122774369ee799380930e53c1773b844e87b8a3060a088a10e781e731ef0c2e534174b038a20f045 +b7143fa669c5134591760b89a284420f0ce2384812f086dc5de2562a15a9c983922fb7d30f35f3e1e43cdd3a5a2f4992e1c3e1ab62f84a98ebdba1d2439cd2f6 +fef0c9306c1445a13026393ee53c2aae72743f8546a262414300b1c0339dd2f797169d2c8d3d37ab5a5a6e2eb8fdcd2bbe9af3ccd073681578a664b16968cf3c +7418e064be496902e9fcf1070b19556cdb3c76f6b1014fcd358729ea42afef4569c4634dd320faa71e3bfed0c1fdd0762017b9c845ee83c25dbfba3456fd0272 +918b5ce422f7fee48eb0ff65cf1f3f3e88a2384d4d5d7ff3fa7548ccc0778ba428cab56e27190c4081031e11d9239ceb8c3dd26c1abace672738df07195ada74 +96bb0109a389a307c0db66162ddeb851145392c07737088ae3dc287d7c6eee70bd0ea530512a1dacd72193c8dd25aebb6554cfb22c79b45e18865c98948427d2 +209f3c3f0f9e1886b1436f1f2ed7f77d5f6afbd2c1ad34dd0731a8628b0b1126fa86c1c7ad9c47c5a507265468505493e619343f9ce41a536e6d6cac3a3d2d27 +f3b6a92864ade75e75024355ebb64d55568b22961456404e366748ceac4962d655df8bfed5b7df6c3bd1e74eec3bfc509df603b5d5a384b63db7e3ba902395e9 +9c66c70f1ffcc2538f7b818f5ce42217b90f0af7ad6e3056fd0272918b5ce422f7fee48eb0ff653f77fcf85a10f869daf3fd37af5e4d399fa069ad6a253cbfde +e93869a6abaa0df924a41ac71ae786c867c934b532d16b344eb26fbffaf16adb99aa5a678f1e00edefe6b5b54b4b6b90315551a0347371ee3a53d5b3478ed4b7 +0e6fa7e20402e4ee12f7bcd0f34181ffc217be609a661004dffffef71dc7816b7852ad56e1faeb5fff7abbdd862767ce9cb16d7ba8cc4b53fcb9386fef073ff8 +4161ec61cb81867ff9f2e5300c8173f0e041a8bef0b6d96c0ec7020e5bd65895f3a8b86a314298f362784524a01896a126d34cc3d4784e338f1245a54c671a40 +a165c97996df3e1a840649cae03ae2b9cf8228d654c53619b43b59186749b1ad085a1f4655552ccd10e3903c8c62d7f3c13372918b5ce43e28dcc3939363d52f +2017b9c8452e72ef4fee08fb5ff6db972e91a19b9a822f9f902571579d21138c1d387000343a5dd74f9f3e2dadafa7840c28edf7fb5ffdea574127acd7eb5ff9 +ca5740df030df0edb7df4e1e9e39f450babcbc2cad1a480757ffeaca9563c78e11b1f61bde26dbde227737b8a0deffe99ffee9900b3f3f048427f2765238a881 +a5526907577afe0f7121da618eb22c5b595919d2fffd5896f3bde79eff977ff409eea1438d432426441e78d82653220d645eacb6d8c10d3eedf7fdb99fff55a5 +d9ac85e189d94ffcbea4d89234f9ffbdbc001fb83ef6e12272918b5ce43e18dc31eb17908b5ce42217b9f7277784723b2b8614c47e6cf2696ebbb9f54ff573e7 +c31dfeefb4d9367c8b5ce42217b9c8452e72918b5ce42217b9c8452e72ef2e97c9fdd59aa67d6a82e439ea725ce14e0f10165e6ddfa10ddee4d16bb66dc32bce +b9effb7267b8dc282e53204f71472e72918b5ce42217b9c8452e72918b5ce42217b977975b2c0f004f274f9eb42cebce41022a7617c8e84cd3dcee81894ddaa5 +52a95c2ec335bc8218211e889d6c9dd0ee38ced7bef6b576bb0d919f3e7d5a065414a5d96c827fe42217b9c8452e72918b5ce42217b9c8452e72917b77b90c60 +8661d46ab5edc6d8b6bb3b13314c8a1c6f00a788ddfff06d6d5962931ec001380c4355b8e1730802d12217b9c8452e72918b5ce42217b9c8452e72918bdcbbcb +654110c853d672e186bee5c00011e3079f0a838090d052a9649a26c4083110315641b7d612c0451cc7e00712017ee0629881288ac4d183c8452e72918b5ce422 +17b9c8452e72918b5ce422f76e72d92bafbca2ebfacacaca301d12b6b8b808be01363737a78b7305b6bb5c8c463cfdf4d3c003d81b6fbc013cf0dc6c36354d1b +a61b72f2d8638f6559069e9f7cf2c90f3ef8001e42b4172e5c705d17b9c8452e72918b5ce42217b9c8452e72918b5ce4de5d2e731c07a2ebf57a3b781b1b1b10 +11bcaa542af06afb9083bcb66d1b608d4603520c30880178e5727947e2e4b2043902310c0efe918b5ce42217b9c8452e72918b5ce42217b9c845ee5de7b27abd +0efe0c61dc6fe889526a9aa6a228f08a732ed712e8623f005c489f9665254902698ae35855557808dfe039cbb2ed891b46180481bc8648200f3272e42217b9c8 +452e72918b5ce42217b9c8452e72917b17b9ecd77ffdd721c0d5ab5721e470893f04d8b76f1f7cc3ab8b172f7a9e07f8b367cf4aabfdd24820c0161616c00378 +abd7ebd56a1548ed767bb8c160076f7575b5d96c1231d2f0f2cb2f430e918b5ce42217b9c8452e72918b5ce42217b9c845eedde5b2999999288a969696c0b7e4 +c96fb99c001201e1c1831c63d085abd56a727b00c07cdfa75be701a6c2c1c33b79e02012994f886a727212928e5ce42217b9c8452e72918b5ce42217b9c8452e +72ef2eb7387f2f1747f0c9cd00d212e07080011221d7064074700dd1c12b60c82107b81da6527a364d937d9a9dc01d2edf72c8452e72918b5ce42217b9c8452e +72918b5ce422f72e728b77724900441104c1f9f3e71dc7d99ea0d9d95999824ea7d3ed76a95809a028ca307143cf007bf6d9672b954a7ec73e01e9de7efbeded +b7c8452e72918b5ce42217b9c8452e72918b5ce422f7ee720b3d1f025b96258707e46a81e150015c685b7602d2ad0d00e0614744e02d17831300abd7ebdb79c3 +a8ee74c8452e72918b5ce42217b9c8452e72918b5ce422f7ee7299effb12092fe22d0b7e434f109273be639c60f8163c4b1204046f499244c20dfdef082e530c +acedb607918b5ce42217b9c8452e72918b5ce42217b9c845eedde2b26f7ffbdb10acd96c0206ded5ebf54aa5328c31cbb256ab0511913bdc3014002e5cb8e0ba +ae6ddb172f5e1cae1f804820f8dadada7040428e29d0ad1508c8452e72918b5ce42217b9c8452e72918b5ce422f7ee7259b7db658c95cb655dd7c19f2a9c7c0d +01865e891824d8810418848254c6711c09db80411040f0210f82f7fbfda125c06136e4d80372918b5ce42217b9c8452e72918b5ce42217b9c8bdbbdc82a40827 +ef8749c9b7dcd0ab699ad29b7472c981bc865710357c6f8f4186b26d1bd2443ecd2117b9c8452e72918b5ce42217b9c8452e72918bdcbbcb65bff44bbf047aff +952b57c23084286498fc9336fde0169e3ffffcf3dbd706c850e00da27beaa9a7b8b00d6859d63089321de7ce9d83efed0f8749412e72918b5ce42217b9c8452e +72918b5ce42217b97797cbeaf53a8419ae1990630c4312dd1a248087d56a75bb4dbf6128f0532a958629db91190865dbf69d6fe11572918b5ce42217b9c8452e +72918b5ce42217b9c8bdbb5c1686612cacf6c94749925031ae90a6a9fc1e7a2d76f333b67d5c013c4b0f5996c17378a86e59021ca61242e5c2c12d04df9e1ae4 +2217b9c8452e72918b5ce42217b9c8452e72917b77b9ecedb7df266290808aedfb2b2b2b328aa127b8855761189e3f7f5ed9b64f20df5a6300b0c5c545c0436c +737373d2ae80f443b74c0bcadb43870e914f3ae42217b9c8452e72918b5ce42217b9c8452e72917b17b96c68eb5f46110bb77d6c60f86a3018903b1cbc4d92c4 +755d606b9a06c91a061ce664f8646a6aeacee0c8452e72918b5ce42217b9c8452e72918b5ce422f76e71996118c3777287409aa67061dbb6aaaa703b0cc018a3 +5bdb0676b86ab50aa904def09c804ff52683c3f78ea8908b5ce42217b9c8452e72918b5ce42217b9c845ee5de1b2d3a74f0fef1dc779edb5d7d6d7d721fccb2f +bf3c3535e5fbfef9f3e7078301c09acd26c4b8230a881a1ebef8e28b8661dc99811d4eee11003f274f9eb42c0bb9c8452e72918b5ce42217b9c8452e72918b5c +e4de5d2e2b954a7218808a7d02499244510417954aa5d168405ccad6117f702d4fe4dbbeb400ae81042993c6fd76ac3af85447c5e17ee0908b5ce42217b9c845 +2e72918b5ce42217b9c845eedde532cff386bc200854558578e11bae5dd7f57d5f9a04043f5996495301900249924b0bc0c933008791c213083564ef70b93021 +28032217b9c8452e72918b5ce42217b9c8452e72918bdcbbc865dffef6b78737e0a9d168542a15e0bdfaeaab729f80e779103b5cb45a2df0030f9bcda6aeeb00 +bb70e102bcb52c0ba22e97cbc37443b2c073ba7536c0d04d4f4f136121e0fcf9f3907ae42217b9c8452e72918b5ce42217b9c8452e72917b77b9acdbedd22d2b +7f541cc4078e883d03dbbde6c22420d97606203c01187883787ddf97e30a321e78d2eff7a5ffa183c8653e21e983c160bb7541e42217b9c8452e72918b5ce422 +17b9c8452e72917b57b84cd3342af60048ead0403fddb20d6818c6f6b501ca966d40392021bd65c2c185699ae001dedab62de31c266e38cc4085d90078825ce4 +2217b9c8452e72918b5ce42217b9c8452e72ef2e971d387040d775690030080269e54ffa034f10fef9e79faf542ac34440825e79e515d77553e188189f68b55a +bd5e0f623877ee9cf40caf6410192a8ee38f3ffe38ddda66d06c36e12d72918b5ce42217b9c8452e72918b5ce42217b9c8bdbb5c0630c3306ab55aa9541a5af9 +1b3ab885f0f57a7dc8f33c2fcb32082f63ccc5d6ff2449e42805a46f68c07fe8e055144540c9b6f62468e29c00e42217b9c8452e72918b5ce42217b9c8452e72 +917b77b9c5a2ff5c58f0535515620180dc09c085e1be5c6c0f90f6fd6460b8059ff2bc3e480a00e01a18baaec3b53c1e60074f86026f4110483c78a65b960391 +8b5ce42217b9c8452e72918b5ce42217b9c845eedde216c1c0d3471f7da4880d00f57abd5aad6659d66ab5c0937c651846be35ae20fd0049d3b4175f7c111844 +180980e0e079616121fea41900e9c0f3912347bef18d6fe4e2dcbfb367cf4212918b5ce42217b9c8452e72918b5ce42217b9c845eedde5de9ecf0fc350be9063 +06e996cd00781504c170bdc1d00f3848c4d4d4946ddbdb871cc0f9be4fb7cc000c233184731c27175b08f8d6d980c8452e72918b5ce42217b9c8452e72918b5c +e422f72e72ff32eaed6efb4348d30e9e8c4215a7fce5c26df709ee4e1e3c8474cb41080073613910b9c8452e72918b5ce42217b9c8452e72918b5ce4de5d2e5b +5a5aba93279172b540abd5fa540f96656d4fd6d073bfdfdfc1936f5756569e7bee3999acc160d0ed76918b5ce42217b9c8452e72918b5ce42217b9c845eedde5 +b2582ceb1ffa180e12d02d13ff49920c1f0e5fc11369366047d4908244d8001c3e19868da268767656fa814c2217b9c8452e72918b5ce42217b9c8452e72918b +dcbbce2d4cf6c14d18869c73f0675996340c20edf8c313c33076841f2e1bf07d5f52a583db5898108018545595a1a485c0ed6c4991470b2017b9c8452e72918b +5ce42217b9c8452e72918bdcbbc8fdff01317552b92f0af84f0000000049454e44ae426082}}}}} + +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +Implementation: } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b0\ab0\rtlch \ltrch\loch +\tab The code was developed in a very object oriented style. }{\b0\ab0\rtlch \ltrch\loch +One main function was called, which called many other functions and classes. This main function started pygame and called which level the player asked for. From there, all of the movement, collisions, and drawing of the game was split up further into more functions and classes. This was extremely beneficial because many parts of the program were used a multitude of times. } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b0\ab0\rtlch \ltrch\loch +\tab The game was run over a series of iterations as opposed to running continuously. This influenced how the movement and collisions were written. }{\b0\ab0\rtlch \ltrch\loch +Because of this, the left and right functions were written to move the player left or right by an increment of 4 pixels for every loop in the program. This allowed the collisions to be written in a more concise fashion as well. The left and right collisions were written in order to stop a player from being able to move when the player is exactly touching another block.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b0\ab0\rtlch \ltrch\loch +\tab }{\b0\ab0\rtlch \ltrch\loch +A design choice that was made was how to store the blocks in the field. The original idea that we had was to store all of the blocks in a list that could be printed out in each iteration of the program. This is where we had our biggest design consideration. We thought about how difficult it would be to write a collision function if the blocks were in a list. To check for collisions we would have to sort through each block to avoid collisions, which would greatly increase runtime. We thought about how we wanted to avoid this problem. What we decided on was a field matrix. A field matrix is a matrix that has an index for every position on the field that a block could be in. That index is represented by a 0 if no block exists, or a number that represents what type of block it is. This made checking for collisions much easier as we could just check the blocks near the player in the player matrix. This design consideration greatly helped our project.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +\tab } +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +Reflection:} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b\ab\rtlch \ltrch\loch +\tab }{\b0\ab0\rtlch \ltrch\loch +Our process was successful overall. We successfully scoped what we wanted to do, without leaving ourselves incapable of completing the project. To do this, we kept scoping out what we wanted to do for each iteration. For example, we would write a list of next steps on a white board such as \u8220\'93implement bottom collision\u8221\'94 or \u8220\'93add additional levels\u8221\'94 . This allowed us to stay organized and keep our objectives in sight. It also kept us on track. If we were ever unsure of what we needed to do to next, we could look at the list for help. This made the development of the program much smoother. In addition, it allowed us to divide up the work. By each picking a task on the board, we were able to understand what the other person was working on without both working on the same part of the project and creating merge errors.} +\par \pard\plain \s0\widctlpar\hyphpar0\aspalpha\ltrpar\cf0\kerning1\dbch\af5\langfe2052\dbch\af6\afs24\alang1081\loch\f3\fs24\lang1033{\b0\ab0\rtlch \ltrch\loch +\tab We also did a good job of cutting our losses early in the project. At first we were planning on doing a project involving OpenCV. However, OpenCV had a lot of problems, which set us back at the start of the project. We didn\u8217\'92t give up too early, and spent a reasonable amount of time searching for solutions to OpenCV. Additionally, we didn\u8217\'92t sink all of our time on this part of the project. We knew when we should give up, and we did so, allowing us to develop a well-built game. Overall our process was very }{\b0\ab0\rtlch \ltrch\loch +successful.} +\par } \ No newline at end of file diff --git a/continuous Rectangle.py b/continuous Rectangle.py deleted file mode 100644 index 00b551d..0000000 --- a/continuous Rectangle.py +++ /dev/null @@ -1,646 +0,0 @@ -import pygame - -""" The following section of the script initializes a few global varables that -are helpful to reference at any point in the program.""" - -pygame.init() #initialize pygame -size = [1840, 920] #size of screen -screen = pygame.display.set_mode(size) -BLACK = ( 0, 0, 0) -WHITE = (255, 255, 255) -BLUE = ( 0, 0, 255) -GREEN = ( 20, 255, 20) -RED = (255, 0, 0) -color_matrix = [BLACK, BLUE, GREEN, RED] -block_size = 40 #width/length of blocks in pixels -jump = 0 - - -""" Model ------------------------------------------------------------ """ - - -class Rectangle(): - """Used when initializing block objects. These block objects are later put into the field matrix. - has atributes for: - x and y position - the upper-left pixel of each block - width and height of the block - color of block as an RGB value - """ - def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): - self.x = x - self.y = y - self.width = width - self.height = height - self.color = color - - #draws the rectangles that are dropped - def draw_rectangle(self): - """Uses pygame to draw the rectangle on the screen - -filled solid with color - """ - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) - - def draw_with_outline(self): - """Uses pygame to draw the rectangle on the screen - -as a colored outline - """ - pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) - - -class Field(): - """ Used when creating and storing the blocks in the field. - Contains following atributes: - blocks - a list of block objects - matrix - a matrix with each value equal to the block type in that position - - This is helpful because you don't need to iterate through every - block on the map to look for collisions - """ - def __init__(self, num_rows=4, color=0): - """ initializing field using an algorithm""" - self.blocks = [] - self.matrix = [] - inner = [] - #makes a matrix that is the shape of the field - #adds an extra row to width and height to prevent out of bounds errors - for i in range(size[1]//40+1): - inner = [] - self.matrix.append(inner) - for j in range(size[0]//40+1): - inner.append(0) - #adds blocks to the first 4 rows of the field - for row in range(num_rows): - for column in range(int(size[0]/block_size)): - if row == 3: - self.matrix[row+19][column] = 9 - else: - self.matrix[row+19][column] = row+1 - self.matrix[18][15] = 4 #add trampoline - - def matrix_update(self, block_type): - """Uses the block objects in the list of blocks to update the field matrix - used to detect collisions. The block is then removed from the list""" - for block in self.blocks: - self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type - self.blocks.remove(block) - - def matrix_print(self): - """Prints the field matrix in a format that is easy to read""" - print("Matrix") - for rows in self.matrix: - print(rows, ",") - -class Player(): - """Contains Atributes and Methods regarding the player's position, - appearance, and motion. - """ - - def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, - fall='on', left='off', right='off', jump=0): - """The first 5 attributes are the same as the Rectangle class above. - velocity - change in y position for each time step. - acceleration_constant - change in velocity if falling - fall - whether the player should be falling - jump - whether the player is allowed to jump or not - """ - self.x = x - self.y = y - self.width = width - self.height = height - self.color = color - self.velocity = velocity - self.fall = fall - self.left = left - self.right = right - self.acceleration_constant = .6 - self.jump = jump - - def bottom_collision(self, field, next_y): - """ stops the player's downward movement if his vertical position is - colliding with a block and allows him to jump again.""" - """Also makes the player bounce if this block is a trampoline""" - self.jump = 0 - block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] - block_below_right = field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] - #below is for if the player is directly over a block - if self.x % 40 == 0: - if block_below != 0: - self.fall = "off" - self.velocity = 0 - self.y = (self.ygrid)*40 - self.jump = 1 - if block_below == 4: - self.super_jump() #trampoline jump - #below is for if the player is between two blocks - elif block_below != 0 or block_below_right != 0: - self.fall = "off" - self.velocity = 0 - self.y = (self.ygrid)*40 - self.jump = 1 - if block_below == 4 or block_below_right == 4: - self.super_jump() #trampoline jump - - def left_collision(self, field): - """Prohibits leftward movement if it would bring the player inside a - block or outside the screen.""" - #collisions occur when the block is directly over a block - if self.x%40 == 0: - #if the player is not jumping only two blocks are checked - if self.y%40 == 0: - if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: - return False - else: - return True - #if the player is jumping more blocks must be checked for collisions - elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: - return False - else: - return True - else: - return True - - def right_collision(self, field): - """Prohibits rightward movement if it would bring the player inside a - block or outside the screen. Essentally the same as left_collision""" - if self.x%40 == 0: - if self.y%40 == 0: - if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: - return False - else: - return True - elif field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] != 0: - return False - else: - return True - else: - return True - - def top_collision(self, field): - """ prohibits movement if the player is going upwards through a block. - Incorprorates a 50% bounce back velocity""" - if self.x % 40 == 0: #if directly over block - if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: - self.y = (self.ygrid+1)*40 - self.velocity = self.velocity * -.5 - #if between two blocks check more spots for collisions - elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: - self.velocity = self.velocity * -.5 - self.y = (self.ygrid+1)*40 - - def player_in_grid(self): - """Finds the field matrix value that the player's position corresponds to - and stores this in the new atributes self.xgrid and self.ygrid""" - self.xgrid = self.x//block_size - self.ygrid = self.y//block_size - - def draw(self, amon_picture, sean, colvin): - """ The actual printing of the player on the screen - This is where we excecute our movement if the player is supposed - to be moving or falling.""" - if self.fall == 'on': - #the player has a velocity to allow vertical position to change - #fluidly - self.velocity += self.acceleration_constant - if self.left == 'on': - self.x += -4 - - if self.right == 'on': - self.x += 4 - - # update the y position - self.y = self.y + self.velocity - - # change-able skins integrated here - if self.color == 0: - screen.blit(amon_picture,(self.x,self.y)) - if self.color == 1: - screen.blit(sean,(self.x,self.y)) - if self.color == 2: - screen.blit(colvin,(self.x,self.y)) - - def jumps(self): - """regular jump function - triggered by the 'w' key """ - jump_strength = -9 - self.velocity = jump_strength - self.fall = 'on' - - def super_jump(self): - """Extra high jump triggered by a bottom collision with a trampoline""" - jump_strength = -13 - self.velocity = jump_strength - self.fall = 'on' - - -class Text(): - """Used when forming all of our text boxes - especially in the menu""" - def __init__(self, text, x_pos, y_pos, size, color): - self.text = text - self.x_pos = x_pos - self.y_pos = y_pos - self.size = size - self.color = color - - def print_text(self): - """ A pygame print function integrated into the Text class""" - font = pygame.font.SysFont("monospace", self.size) - label = font.render(self.text, 40, self.color) - screen.blit(label, (self.x_pos, self.y_pos)) - - -def menu(previous_level_select): - """This is the menu screen that is shown when you first start playing the - game. It gives brief instructions on what the game is. You can start - playing the game by pressing 8, 9, or P""" - level_select = "Menu" - done = False - # Looks for player input - for event in pygame.event.get(): - if event.type == pygame.QUIT: # quits - done = True - # looks for a keystroke - if event.type == pygame.KEYDOWN: - # quits when q is pressed - if event.key == pygame.K_q: # If user hit q or closed") - done = True - # which level to go to is selected here. - # p is used to go to the previous level. - # on the first iteration, this is "unknown:, so p takes you to level one - # 8 or 9 also take you to level one or two - if previous_level_select is "unknown": - if event.key == pygame.K_8: - level_select = "Level_One" - if event.key == pygame.K_9: - level_select = "Level_Two" - if event.key == pygame.K_p: - level_select = "Level_One" - else: - # After you have entered a level this takes you back to the previous - # level when you press P - print("going previous", previous_level_select) - if event.key == pygame.K_p: - level_select = previous_level_select - - # Fill the screen white and print a bunch of text. - screen.fill(WHITE) - text_list = [] - text1 = Text("Bounce Bounce Play Time", 150, 50, 100, RED) - text2 = Text("Instructions:", 50, 200, 60, BLUE) - text3 = Text("-This is a rudimentary version of Minecraft. Use w, a, s, d to move.", 100, 300, 30, BLACK) - text4 = Text("-You can move around the world and change the blocks within it.", 100, 350, 30, BLACK) - text5 = Text("-Your inventory is in the upper left. Cycle through which item to drop with 1, 2, 3, and 4", 100, 400, 30, BLACK) - text6 = Text("-Use left click to pick up items and right click to drop them. You have a limited range.", 100, 450, 30, BLACK) - text7 = Text("-Which block you will drop is shown by the \"Current Block\" space in your inventory", 100, 500, 30, BLACK) - text8 = Text("-There are multiple worlds to choose from. Press 8 or 9 to enter a different world.", 100, 550, 30, BLACK) - text9 = Text("-Pause with P, and return to your previous world by pressing P again.", 100, 600, 30, BLACK) - text10 = Text("-Press Q to quit the program", 100, 650, 30, BLACK) - text11 = Text("-You can also change your character by pressing C", 100, 700, 30, BLACK) - text12 = Text("-Trampolines will make you jump extra high when you land on them", 100, 750, 30, BLACK) - text_add_list = [text1, text2, text3, text4, text5, text6, text7, text8, text9, text10, text11, text12] - for texts in text_add_list: - text_list.append(texts) - for texts in text_list: - texts.print_text() - return [level_select, done] - -class Inventory(): - """The inventory is used to pick up, place, and store blocks. The inventory - is shown in the upper left. The blocks you can place, and the number of - those blocks that you have are shown in the inventory. Additionally, the block - that you are currently placing is shown here.""" - def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width): - bin_list = [0, 0, 0, 0] # initializes you with 0 blocks of any kind - bin_list_item = [BLACK, RED, BLACK, GREEN, BLUE] - self.init_quantity = init_quantity - self.x_pos = x_pos - self.y_pos = y_pos - self.bin_width = bin_width - self.bin_height = bin_height - self.bin_list = bin_list - self.bin_list_item = bin_list_item - - - def add_to_inventory(self, mouse, field, player_x, player_y): - """This method picks up a block from the world when you left click. It - then increments the count of that block in your inventory by one""" - # finds where the mouse and player are in the field grid - mouse_x_grid = mouse[0] // 40 - mouse_y_grid = mouse[1] // 40 - player_x_grid = player_x//40 - player_y_grid = player_y//40 - # finds what block type you picked up - block_type = field.matrix[mouse_y_grid][mouse_x_grid] - if block_type != 9: # 9 is beckrock, which cannot be mined - # implement a range in which you can pick up from - if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - # you can only hold a maximum of 64 of a certain item - if self.bin_list[block_type-1] < 64: - # only adds if there is a block in that space - if field.matrix[mouse[1]//40][mouse[0]//40] != 0: - self.bin_list[block_type-1] += 1 - # sets that space on the field to empty - field.matrix[mouse[1]//40][mouse[0]//40] = 0 - - def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): - """This function is used to place items in the word. The current block in the inventory - then removed from the inventory and placed in the world in the position of the mouse""" - # finds where the mouse is located in the field grid - mouse_x_grid = mouse[0] // 40 - mouse_y_grid = mouse[1] // 40 - # finds where the player is located in the field grid - player_x_grid = player_x//40 - player_y_grid = player_y//40 - # To prevent the player from dropping a block where he or she is standing - # many if loops were used. - # the first is based on if the player is directly over a block - if player_x % 40 == 0: - # in this case the block cannot be placed in either the top or bottom - # block of the player - check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) - check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) - if (check_top_player== False) and (check_bottom_player== False): - if field.matrix[mouse[1]//40][mouse[0]//40] == 0: # A block cannot be placed if another block already is in that spot - if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place - # T he range in which you can place a block is a circle with radius 5 - if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - self.bin_list[block_type-1] -= 1 # subtract one from inventory - # place the block where your mouse is - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) - else: - # In this case the player is halway over a block, which means - # that the player spans 4 blocks, and you should not be able to - # place a block in any of these places - check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) - check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) - check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) - check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) - if (check_top_left_player == False) and (check_top_right_player == False): - if (check_bottom_left_player== False) and (check_bottom_right_player== False): - # make sure a block isn't already in that position - if field.matrix[mouse[1]//40][mouse[0]//40] == 0: - # make sure you have at least one item in your inventor - if self.bin_list[block_type-1] > 0: - if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: - self.bin_list[block_type-1] -= 1 #subtract one from inventory - # place the block where your mouse is - mouse_x_to_grid = (mouse[0]//40)*40 - mouse_y_to_grid = (mouse[1]//40)*40 - drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) - field.blocks.append(drop_block) - - def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): - """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" - text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) - text.print_text() - # A list of all the images to print in the top left - image_list = [grass, dirt, stone, spring] - # For loop to print the inventory for every item in the inventoryy - for bin in range(len(self.bin_list)): - # checks what type of block and prints that type - if bin+1 == 1: - screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) - if bin+1 == 2: - screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) - if bin+1 == 3: - screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) - if bin+1 == 4: - screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) - # prints the number of items in the inventory in that slot - text = Text(str(self.bin_list[bin]), self.x_pos+45, self.y_pos + bin*self.bin_height, 30, BLACK) - text.print_text() - # prints the current block and the text for it. - text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) - text2.print_text() - screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) - -def level_two_map(): - """Stores the map for the second level""" - matrix = [ - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], - [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], - [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], - [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] - return matrix - - -def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, - bedrock, amon_picture, inventory, inventory_block_index, - level_select, level, previous_level_select, spring, - player_color, done, sean, colvin): - """This is the main function of the program. It contains the controller for the program - user keystrokes and other actions are turned into actions in the game - by referencing other funtions and classes.""" - player.fall = 'on' - field.matrix_update(inventory_block_index) - next_y = player.velocity #how far the player will move on the next iteration - # finds where in the matrix the player is - player.player_in_grid() - # top/bottom collisions - player.top_collision(field) - player.bottom_collision(field, next_y) - previous_level_select = str(level) - clock.tick(40) - - # move left/right - keys = pygame.key.get_pressed() - player.left = 'off' - player.right = 'off' - # move left. Allows for holding the key down. Left collisions - if keys[pygame.K_a]: - player_left_move = player.left_collision(field) - if player_left_move is True: - player.left = 'on' - else: - player.left = 'off' - # move right. Allows for holding the key down. Right collisions - if keys[pygame.K_d]: - player_right_move = player.right_collision(field) - if player_right_move is True: - player.right = 'on' - - # stops plyaer from moving out of screen to left, right, or bottom - if player.x <= 0: - player.x = 0 - if player.x >= 1800: - player.x = 1800 - if player.y >= 840: - player.y = 840 - player.velocity = 0 - player.jump = 1 - player.fall = 'off' - - # pick up block - if mouse2[0] == 1: - inventory.add_to_inventory(mouse, field, player.x, player.y) - # place block - if mouse2[2] == 1: - inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - # possible actions start here - for event in pygame.event.get(): - # press teh x in the top left to quit - if event.type == pygame.QUIT: - done = True - - # Here begins all the possible actions dependent on keystrokes - if event.type == pygame.KEYDOWN: - # jump function - if event.key == pygame.K_w: - if player.jump == 1: - player.jumps() - player.jump = 0 - # pause - if event.key == pygame.K_p: - level_select = "Menu" - # chance player character - if event.key == pygame.K_c: - player_color += 1 - if player_color == 3: - player_color = 0 - player.color = player_color - - # inventory - # cycles which block to place by pressing 1,2,3, and 4 - if event.key == pygame.K_1: - inventory_block_index = 1 - if event.key == pygame.K_2: - inventory_block_index = 2 - if event.key == pygame.K_3: - inventory_block_index = 3 - if event.key == pygame.K_4: - inventory_block_index = 4 - - # Switches between levels - if event.key == pygame.K_8: - level_select = "Level_One" - if event.key == pygame.K_9: - level_select = "Level_Two" - - # quit game - if event.key == pygame.K_q: - pygame.quit() - return - - # View------------------------------------------------------------- - # prints the background - screen.fill(WHITE) - - # This prints all of the blocks on the screen - # row and column counts are used to keep track of matrix row and column - # there is a for loop to run through each row and column - row_count = -1 - for row in field.matrix: - column_count = -1 - row_count += 1 - for column in row: - column_count+=1 - if field.matrix[row_count][column_count] != 0: - if field.matrix[row_count][column_count] == 4: - #based on the number entry in the matrix, it prints a different block - screen.blit(spring, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 1: - screen.blit(grass, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 2: - screen.blit(dirt, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 3: - screen.blit(stone, (column_count*40, row_count*40)) - if field.matrix[row_count][column_count] == 9: - screen.blit(bedrock, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) - player.draw(amon_picture, sean, colvin) - return [level_select, inventory_block_index, previous_level_select, player_color, done] - -#Control -def main(): - """ The actual call of the start of the program. - Main movement is referenced by this function. - """ - # how long between each cycle of the while loop - clock = pygame.time.Clock() - - # initializes player, field, and other variables for level one and two - player_color = 0 - player_color2 = 0 - previous_level_select = "unknown" - level_select = "Menu" - done = False - player = Player() - field = Field() - field2 = Field() - field2.matrix = level_two_map() - player2 = Player() - player2.x = 0 - inventory = Inventory(0, 0, 20, 40, 40) - inventory2 = Inventory(0, 0, 20, 40, 40) - inventory_block_index = 1 - inventory_block_index2 = 1 - - # loads all the pictures - amon_picture = pygame.image.load('amon.png') - grass = pygame.image.load("grass.png") - stone = pygame.image.load("stone.png") - dirt = pygame.image.load("dirt.png") - soulsand = pygame.image.load("soulsand.png") - netherack = pygame.image.load("netherack.png") - netherquartz = pygame.image.load("netherquartz.png") - bedrock = pygame.image.load("bedrock.png") - spring = pygame.image.load("spring.png") - sean = pygame.image.load("sean.png") - colvin = pygame.image.load("colvin.png") - - """CONTROL""" - while not done: - # sets the caption to the name of the level - pygame.display.set_caption(level_select) - mouse = pygame.mouse.get_pos() - mouse2 = pygame.mouse.get_pressed() - # setting up the menu - if level_select is "Menu": - returned = menu(previous_level_select) - level_select = returned[0] - done = returned[1] - # setting up level one - if level_select is "Level_One": - level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) - # the variables in the main function can't be accessed from the main_movement function. They are - level_select = level_one[0] - inventory_block_index = level_one[1] - previous_level_select = level_one[2] - player_color = level_one[3] - done = level_one[4] - # setting up level two - if level_select is "Level_Two": - level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) - level_select = level_two[0] - inventory_block_index2 = level_two[1] - previous_level_select = level_two[2] - player_color2 = level_two[3] - done = level_two[4] - # prints the game on each iteration of the loop - pygame.display.flip() - pygame.quit() - - -if __name__ == '__main__': - main() diff --git a/interactive_color.py b/interactive_color.py index f034d5e..32f4ac8 100644 --- a/interactive_color.py +++ b/interactive_color.py @@ -1,4 +1,646 @@ -""" -This is our awesome Project -@author Colvin Chapman and Sean Szymanski - """ +import pygame + +""" The following section of the script initializes a few global varables that +are helpful to reference at any point in the program.""" + +pygame.init() #initialize pygame +size = [1840, 920] #size of screen +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 20, 255, 20) +RED = (255, 0, 0) +color_matrix = [BLACK, BLUE, GREEN, RED] +block_size = 40 #width/length of blocks in pixels +jump = 0 + + +""" Model ------------------------------------------------------------ """ + + +class Rectangle(): + """Used when initializing block objects. These block objects are later put into the field matrix. + has atributes for: + x and y position - the upper-left pixel of each block + width and height of the block + color of block as an RGB value + """ + def __init__(self, x=10, y=10, width=20, height=10, color=BLUE): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + + #draws the rectangles that are dropped + def draw_rectangle(self): + """Uses pygame to draw the rectangle on the screen + -filled solid with color + """ + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + def draw_with_outline(self): + """Uses pygame to draw the rectangle on the screen + -as a colored outline + """ + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height], 1) + + +class Field(): + """ Used when creating and storing the blocks in the field. + Contains following atributes: + blocks - a list of block objects + matrix - a matrix with each value equal to the block type in that position + - This is helpful because you don't need to iterate through every + block on the map to look for collisions + """ + def __init__(self, num_rows=4, color=0): + """ initializing field using an algorithm""" + self.blocks = [] + self.matrix = [] + inner = [] + #makes a matrix that is the shape of the field + #adds an extra row to width and height to prevent out of bounds errors + for i in range(size[1]//40+1): + inner = [] + self.matrix.append(inner) + for j in range(size[0]//40+1): + inner.append(0) + #adds blocks to the first 4 rows of the field + for row in range(num_rows): + for column in range(int(size[0]/block_size)): + if row == 3: + self.matrix[row+19][column] = 9 + else: + self.matrix[row+19][column] = row+1 + self.matrix[18][15] = 4 #add trampoline + + def matrix_update(self, block_type): + """Uses the block objects in the list of blocks to update the field matrix + used to detect collisions. The block is then removed from the list""" + for block in self.blocks: + self.matrix[int(block.y//block_size)][int(block.x//block_size)] = block_type + self.blocks.remove(block) + + def matrix_print(self): + """Prints the field matrix in a format that is easy to read""" + print("Matrix") + for rows in self.matrix: + print(rows, ",") + +class Player(): + """Contains Atributes and Methods regarding the player's position, + appearance, and motion. + """ + + def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, + fall='on', left='off', right='off', jump=0): + """The first 5 attributes are the same as the Rectangle class above. + velocity - change in y position for each time step. + acceleration_constant - change in velocity if falling + fall - whether the player should be falling + jump - whether the player is allowed to jump or not + """ + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + self.velocity = velocity + self.fall = fall + self.left = left + self.right = right + self.acceleration_constant = .6 + self.jump = jump + + def bottom_collision(self, field, next_y): + """ stops the player's downward movement if his vertical position is + colliding with a block and allows him to jump again.""" + """Also makes the player bounce if this block is a trampoline""" + self.jump = 0 + block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] + block_below_right = field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] + #below is for if the player is directly over a block + if self.x % 40 == 0: + if block_below != 0: + self.fall = "off" + self.velocity = 0 + self.y = (self.ygrid)*40 + self.jump = 1 + if block_below == 4: + self.super_jump() #trampoline jump + #below is for if the player is between two blocks + elif block_below != 0 or block_below_right != 0: + self.fall = "off" + self.velocity = 0 + self.y = (self.ygrid)*40 + self.jump = 1 + if block_below == 4 or block_below_right == 4: + self.super_jump() #trampoline jump + + def left_collision(self, field): + """Prohibits leftward movement if it would bring the player inside a + block or outside the screen.""" + #collisions occur when the block is directly over a block + if self.x%40 == 0: + #if the player is not jumping only two blocks are checked + if self.y%40 == 0: + if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: + return False + else: + return True + #if the player is jumping more blocks must be checked for collisions + elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: + return False + else: + return True + else: + return True + + def right_collision(self, field): + """Prohibits rightward movement if it would bring the player inside a + block or outside the screen. Essentally the same as left_collision""" + if self.x%40 == 0: + if self.y%40 == 0: + if field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0: + return False + else: + return True + elif field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid+1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] != 0: + return False + else: + return True + else: + return True + + def top_collision(self, field): + """ prohibits movement if the player is going upwards through a block. + Incorprorates a 50% bounce back velocity""" + if self.x % 40 == 0: #if directly over block + if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: + self.y = (self.ygrid+1)*40 + self.velocity = self.velocity * -.5 + #if between two blocks check more spots for collisions + elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: + self.velocity = self.velocity * -.5 + self.y = (self.ygrid+1)*40 + + def player_in_grid(self): + """Finds the field matrix value that the player's position corresponds to + and stores this in the new atributes self.xgrid and self.ygrid""" + self.xgrid = self.x//block_size + self.ygrid = self.y//block_size + + def draw(self, amon_picture, sean, colvin): + """ The actual printing of the player on the screen + This is where we excecute our movement if the player is supposed + to be moving or falling.""" + if self.fall == 'on': + #the player has a velocity to allow vertical position to change + #fluidly + self.velocity += self.acceleration_constant + if self.left == 'on': + self.x += -4 + + if self.right == 'on': + self.x += 4 + + # update the y position + self.y = self.y + self.velocity + + # change-able skins integrated here + if self.color == 0: + screen.blit(amon_picture,(self.x,self.y)) + if self.color == 1: + screen.blit(sean,(self.x,self.y)) + if self.color == 2: + screen.blit(colvin,(self.x,self.y)) + + def jumps(self): + """regular jump function + triggered by the 'w' key """ + jump_strength = -9 + self.velocity = jump_strength + self.fall = 'on' + + def super_jump(self): + """Extra high jump triggered by a bottom collision with a trampoline""" + jump_strength = -13 + self.velocity = jump_strength + self.fall = 'on' + + +class Text(): + """Used when forming all of our text boxes - especially in the menu""" + def __init__(self, text, x_pos, y_pos, size, color): + self.text = text + self.x_pos = x_pos + self.y_pos = y_pos + self.size = size + self.color = color + + def print_text(self): + """ A pygame print function integrated into the Text class""" + font = pygame.font.SysFont("monospace", self.size) + label = font.render(self.text, 40, self.color) + screen.blit(label, (self.x_pos, self.y_pos)) + + +def menu(previous_level_select): + """This is the menu screen that is shown when you first start playing the + game. It gives brief instructions on what the game is. You can start + playing the game by pressing 8, 9, or P""" + level_select = "Menu" + done = False + # Looks for player input + for event in pygame.event.get(): + if event.type == pygame.QUIT: # quits + done = True + # looks for a keystroke + if event.type == pygame.KEYDOWN: + # quits when q is pressed + if event.key == pygame.K_q: # If user hit q or closed") + done = True + # which level to go to is selected here. + # p is used to go to the previous level. + # on the first iteration, this is "unknown:, so p takes you to level one + # 8 or 9 also take you to level one or two + if previous_level_select is "unknown": + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + if event.key == pygame.K_p: + level_select = "Level_One" + else: + # After you have entered a level this takes you back to the previous + # level when you press P + print("going previous", previous_level_select) + if event.key == pygame.K_p: + level_select = previous_level_select + + # Fill the screen white and print a bunch of text. + screen.fill(WHITE) + text_list = [] + text1 = Text("Bounce Block", 150, 50, 100, RED) + text2 = Text("Instructions:", 50, 200, 60, BLUE) + text3 = Text("-This is a rudimentary version of Minecraft. Use w, a, s, d to move.", 100, 300, 30, BLACK) + text4 = Text("-You can move around the world and change the blocks within it.", 100, 350, 30, BLACK) + text5 = Text("-Your inventory is in the upper left. Cycle through which item to drop with 1, 2, 3, and 4", 100, 400, 30, BLACK) + text6 = Text("-Use left click to pick up items and right click to drop them. You have a limited range.", 100, 450, 30, BLACK) + text7 = Text("-Which block you will drop is shown by the \"Current Block\" space in your inventory", 100, 500, 30, BLACK) + text8 = Text("-There are multiple worlds to choose from. Press 8 or 9 to enter a different world.", 100, 550, 30, BLACK) + text9 = Text("-Pause with P, and return to your previous world by pressing P again.", 100, 600, 30, BLACK) + text10 = Text("-Press Q to quit the program", 100, 650, 30, BLACK) + text11 = Text("-You can also change your character by pressing C", 100, 700, 30, BLACK) + text12 = Text("-Trampolines will make you jump extra high when you land on them", 100, 750, 30, BLACK) + text_add_list = [text1, text2, text3, text4, text5, text6, text7, text8, text9, text10, text11, text12] + for texts in text_add_list: + text_list.append(texts) + for texts in text_list: + texts.print_text() + return [level_select, done] + +class Inventory(): + """The inventory is used to pick up, place, and store blocks. The inventory + is shown in the upper left. The blocks you can place, and the number of + those blocks that you have are shown in the inventory. Additionally, the block + that you are currently placing is shown here.""" + def __init__(self, init_quantity, x_pos, y_pos, bin_height, bin_width): + bin_list = [0, 0, 0, 0] # initializes you with 0 blocks of any kind + bin_list_item = [BLACK, RED, BLACK, GREEN, BLUE] + self.init_quantity = init_quantity + self.x_pos = x_pos + self.y_pos = y_pos + self.bin_width = bin_width + self.bin_height = bin_height + self.bin_list = bin_list + self.bin_list_item = bin_list_item + + + def add_to_inventory(self, mouse, field, player_x, player_y): + """This method picks up a block from the world when you left click. It + then increments the count of that block in your inventory by one""" + # finds where the mouse and player are in the field grid + mouse_x_grid = mouse[0] // 40 + mouse_y_grid = mouse[1] // 40 + player_x_grid = player_x//40 + player_y_grid = player_y//40 + # finds what block type you picked up + block_type = field.matrix[mouse_y_grid][mouse_x_grid] + if block_type != 9: # 9 is beckrock, which cannot be mined + # implement a range in which you can pick up from + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: + # you can only hold a maximum of 64 of a certain item + if self.bin_list[block_type-1] < 64: + # only adds if there is a block in that space + if field.matrix[mouse[1]//40][mouse[0]//40] != 0: + self.bin_list[block_type-1] += 1 + # sets that space on the field to empty + field.matrix[mouse[1]//40][mouse[0]//40] = 0 + + def remove_from_inventory(self, field, block_type, player_x, player_y, current_block_index, mouse): + """This function is used to place items in the word. The current block in the inventory + then removed from the inventory and placed in the world in the position of the mouse""" + # finds where the mouse is located in the field grid + mouse_x_grid = mouse[0] // 40 + mouse_y_grid = mouse[1] // 40 + # finds where the player is located in the field grid + player_x_grid = player_x//40 + player_y_grid = player_y//40 + # To prevent the player from dropping a block where he or she is standing + # many if loops were used. + # the first is based on if the player is directly over a block + if player_x % 40 == 0: + # in this case the block cannot be placed in either the top or bottom + # block of the player + check_top_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) + if (check_top_player== False) and (check_bottom_player== False): + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: # A block cannot be placed if another block already is in that spot + if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place + # T he range in which you can place a block is a circle with radius 5 + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: + self.bin_list[block_type-1] -= 1 # subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + else: + # In this case the player is halway over a block, which means + # that the player spans 4 blocks, and you should not be able to + # place a block in any of these places + check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) + check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) + check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) + if (check_top_left_player == False) and (check_top_right_player == False): + if (check_bottom_left_player== False) and (check_bottom_right_player== False): + # make sure a block isn't already in that position + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + # make sure you have at least one item in your inventor + if self.bin_list[block_type-1] > 0: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + self.bin_list[block_type-1] -= 1 #subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + + def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): + """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" + text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) + text.print_text() + # A list of all the images to print in the top left + image_list = [grass, dirt, stone, spring] + # For loop to print the inventory for every item in the inventoryy + for bin in range(len(self.bin_list)): + # checks what type of block and prints that type + if bin+1 == 1: + screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 2: + screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 3: + screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 4: + screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) + # prints the number of items in the inventory in that slot + text = Text(str(self.bin_list[bin]), self.x_pos+45, self.y_pos + bin*self.bin_height, 30, BLACK) + text.print_text() + # prints the current block and the text for it. + text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) + text2.print_text() + screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) + +def level_two_map(): + """Stores the map for the second level""" + matrix = [ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] + return matrix + + +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, + bedrock, amon_picture, inventory, inventory_block_index, + level_select, level, previous_level_select, spring, + player_color, done, sean, colvin): + """This is the main function of the program. It contains the controller for the program + user keystrokes and other actions are turned into actions in the game + by referencing other funtions and classes.""" + player.fall = 'on' + field.matrix_update(inventory_block_index) + next_y = player.velocity #how far the player will move on the next iteration + # finds where in the matrix the player is + player.player_in_grid() + # top/bottom collisions + player.top_collision(field) + player.bottom_collision(field, next_y) + previous_level_select = str(level) + clock.tick(40) + + # move left/right + keys = pygame.key.get_pressed() + player.left = 'off' + player.right = 'off' + # move left. Allows for holding the key down. Left collisions + if keys[pygame.K_a]: + player_left_move = player.left_collision(field) + if player_left_move is True: + player.left = 'on' + else: + player.left = 'off' + # move right. Allows for holding the key down. Right collisions + if keys[pygame.K_d]: + player_right_move = player.right_collision(field) + if player_right_move is True: + player.right = 'on' + + # stops plyaer from moving out of screen to left, right, or bottom + if player.x <= 0: + player.x = 0 + if player.x >= 1800: + player.x = 1800 + if player.y >= 840: + player.y = 840 + player.velocity = 0 + player.jump = 1 + player.fall = 'off' + + # pick up block + if mouse2[0] == 1: + inventory.add_to_inventory(mouse, field, player.x, player.y) + # place block + if mouse2[2] == 1: + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) + # possible actions start here + for event in pygame.event.get(): + # press teh x in the top left to quit + if event.type == pygame.QUIT: + done = True + + # Here begins all the possible actions dependent on keystrokes + if event.type == pygame.KEYDOWN: + # jump function + if event.key == pygame.K_w: + if player.jump == 1: + player.jumps() + player.jump = 0 + # pause + if event.key == pygame.K_p: + level_select = "Menu" + # chance player character + if event.key == pygame.K_c: + player_color += 1 + if player_color == 3: + player_color = 0 + player.color = player_color + + # inventory + # cycles which block to place by pressing 1,2,3, and 4 + if event.key == pygame.K_1: + inventory_block_index = 1 + if event.key == pygame.K_2: + inventory_block_index = 2 + if event.key == pygame.K_3: + inventory_block_index = 3 + if event.key == pygame.K_4: + inventory_block_index = 4 + + # Switches between levels + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + + # quit game + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- + # prints the background + screen.fill(WHITE) + + # This prints all of the blocks on the screen + # row and column counts are used to keep track of matrix row and column + # there is a for loop to run through each row and column + row_count = -1 + for row in field.matrix: + column_count = -1 + row_count += 1 + for column in row: + column_count+=1 + if field.matrix[row_count][column_count] != 0: + if field.matrix[row_count][column_count] == 4: + #based on the number entry in the matrix, it prints a different block + screen.blit(spring, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 1: + screen.blit(grass, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 2: + screen.blit(dirt, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 3: + screen.blit(stone, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 9: + screen.blit(bedrock, (column_count*40, row_count*40)) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) + player.draw(amon_picture, sean, colvin) + return [level_select, inventory_block_index, previous_level_select, player_color, done] + +#Control +def main(): + """ The actual call of the start of the program. + Main movement is referenced by this function. + """ + # how long between each cycle of the while loop + clock = pygame.time.Clock() + + # initializes player, field, and other variables for level one and two + player_color = 0 + player_color2 = 0 + previous_level_select = "unknown" + level_select = "Menu" + done = False + player = Player() + field = Field() + field2 = Field() + field2.matrix = level_two_map() + player2 = Player() + player2.x = 0 + inventory = Inventory(0, 0, 20, 40, 40) + inventory2 = Inventory(0, 0, 20, 40, 40) + inventory_block_index = 1 + inventory_block_index2 = 1 + + # loads all the pictures + amon_picture = pygame.image.load('amon.png') + grass = pygame.image.load("grass.png") + stone = pygame.image.load("stone.png") + dirt = pygame.image.load("dirt.png") + soulsand = pygame.image.load("soulsand.png") + netherack = pygame.image.load("netherack.png") + netherquartz = pygame.image.load("netherquartz.png") + bedrock = pygame.image.load("bedrock.png") + spring = pygame.image.load("spring.png") + sean = pygame.image.load("sean.png") + colvin = pygame.image.load("colvin.png") + + """CONTROL""" + while not done: + # sets the caption to the name of the level + pygame.display.set_caption(level_select) + mouse = pygame.mouse.get_pos() + mouse2 = pygame.mouse.get_pressed() + # setting up the menu + if level_select is "Menu": + returned = menu(previous_level_select) + level_select = returned[0] + done = returned[1] + # setting up level one + if level_select is "Level_One": + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) + # the variables in the main function can't be accessed from the main_movement function. They are + level_select = level_one[0] + inventory_block_index = level_one[1] + previous_level_select = level_one[2] + player_color = level_one[3] + done = level_one[4] + # setting up level two + if level_select is "Level_Two": + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) + level_select = level_two[0] + inventory_block_index2 = level_two[1] + previous_level_select = level_two[2] + player_color2 = level_two[3] + done = level_two[4] + # prints the game on each iteration of the loop + pygame.display.flip() + pygame.quit() + + +if __name__ == '__main__': + main() From 83f3ad3b924ded5300a2e051da67826a9db36dac Mon Sep 17 00:00:00 2001 From: Colvchap Date: Thu, 9 Mar 2017 13:52:25 -0500 Subject: [PATCH 79/83] final --- interactive_color.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/interactive_color.py b/interactive_color.py index 32f4ac8..0af3288 100644 --- a/interactive_color.py +++ b/interactive_color.py @@ -438,8 +438,8 @@ def level_two_map(): [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], - [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], - [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] return matrix From 454ca33eef6f9a56161c4904ba00b412910bb0fb Mon Sep 17 00:00:00 2001 From: Colvchap Date: Sat, 22 Apr 2017 00:48:46 -0400 Subject: [PATCH 80/83] mini project 5 --- Zombie.png | Bin 0 -> 2723 bytes continuous Rectangle.py | 640 ++++++++++++++++++++++++++++++++++++++++ interactive_color.py | 211 +++++++++---- 3 files changed, 798 insertions(+), 53 deletions(-) create mode 100644 Zombie.png create mode 100644 continuous Rectangle.py diff --git a/Zombie.png b/Zombie.png new file mode 100644 index 0000000000000000000000000000000000000000..7b2779e95d72b270616459850c1ea2cfe1c10e44 GIT binary patch literal 2723 zcmV;U3S9MxP)004R>004l5008;`004mK004C`008P>0026e000+ooVrmw00006 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 dH99mjD=;!TFfb^UBE 0: #you must have at least one in your inventory to place + # T he range in which you can place a block is a circle with radius 5 + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: + self.bin_list[block_type-1] -= 1 # subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + else: + # In this case the player is halway over a block, which means + # that the player spans 4 blocks, and you should not be able to + # place a block in any of these places + check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) + check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) + check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) + if (check_top_left_player == False) and (check_top_right_player == False): + if (check_bottom_left_player== False) and (check_bottom_right_player== False): + # make sure a block isn't already in that position + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + # make sure you have at least one item in your inventor + if self.bin_list[block_type-1] > 0: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + self.bin_list[block_type-1] -= 1 #subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + + def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): + """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" + text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) + text.print_text() + # A list of all the images to print in the top left + image_list = [grass, dirt, stone, spring] + # For loop to print the inventory for every item in the inventoryy + for bin in range(len(self.bin_list)): + # checks what type of block and prints that type + if bin+1 == 1: + screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 2: + screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 3: + screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 4: + screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) + # prints the number of items in the inventory in that slot + text = Text(str(self.bin_list[bin]), self.x_pos+45, self.y_pos + bin*self.bin_height, 30, BLACK) + text.print_text() + # prints the current block and the text for it. + text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) + text2.print_text() + screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) + +def level_two_map(): + """Stores the map for the second level""" + matrix = [ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], + [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] + return matrix + + +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, + bedrock, amon_picture, inventory, inventory_block_index, + level_select, level, previous_level_select, spring, + player_color, done, sean, colvin): + """This is the main function of the program. It contains the controller for the program + user keystrokes and other actions are turned into actions in the game + by referencing other funtions and classes.""" + player.fall = 'on' + field.matrix_update(inventory_block_index) + next_y = player.velocity #how far the player will move on the next iteration + # finds where in the matrix the player is + player.player_in_grid() + # top/bottom collisions + player.top_collision(field) + player.bottom_collision(field, next_y) + previous_level_select = str(level) + clock.tick(40) + + # move left/right + keys = pygame.key.get_pressed() + player.left = 'off' + player.right = 'off' + # move left. Allows for holding the key down. Left collisions + if keys[pygame.K_a]: + player_left_move = player.left_collision(field) + if player_left_move is True: + player.left = 'on' + else: + player.left = 'off' + # move right. Allows for holding the key down. Right collisions + if keys[pygame.K_d]: + player_right_move = player.right_collision(field) + if player_right_move is True: + player.right = 'on' + + # stops plyaer from moving out of screen to left, right, or bottom + if player.x <= 0: + player.x = 0 + if player.x >= 1800: + player.x = 1800 + if player.y >= 840: + player.y = 840 + player.velocity = 0 + player.jump = 1 + player.fall = 'off' + + # pick up block + if mouse2[0] == 1: + inventory.add_to_inventory(mouse, field, player.x, player.y) + # place block + if mouse2[2] == 1: + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) + # possible actions start here + for event in pygame.event.get(): + # press teh x in the top left to quit + if event.type == pygame.QUIT: + done = True + + # Here begins all the possible actions dependent on keystrokes + if event.type == pygame.KEYDOWN: + # jump function + if event.key == pygame.K_w: + if player.jump == 1: + player.jumps() + player.jump = 0 + # pause + if event.key == pygame.K_p: + level_select = "Menu" + # chance player character + if event.key == pygame.K_c: + player_color += 1 + if player_color == 3: + player_color = 0 + player.color = player_color + + # inventory + # cycles which block to place by pressing 1,2,3, and 4 + if event.key == pygame.K_1: + inventory_block_index = 1 + if event.key == pygame.K_2: + inventory_block_index = 2 + if event.key == pygame.K_3: + inventory_block_index = 3 + if event.key == pygame.K_4: + inventory_block_index = 4 + + # Switches between levels + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + + # quit game + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- + # prints the background + screen.fill(WHITE) + + # This prints all of the blocks on the screen + # row and column counts are used to keep track of matrix row and column + # there is a for loop to run through each row and column + row_count = -1 + for row in field.matrix: + column_count = -1 + row_count += 1 + for column in row: + column_count+=1 + if field.matrix[row_count][column_count] != 0: + if field.matrix[row_count][column_count] == 4: + #based on the number entry in the matrix, it prints a different block + screen.blit(spring, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 1: + screen.blit(grass, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 2: + screen.blit(dirt, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 3: + screen.blit(stone, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 9: + screen.blit(bedrock, (column_count*40, row_count*40)) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) + player.draw(amon_picture, sean, colvin) + return [level_select, inventory_block_index, previous_level_select, player_color, done] + +#Control +def main(): + """ The actual call of the start of the program. + Main movement is referenced by this function. + """ + # how long between each cycle of the while loop + clock = pygame.time.Clock() + + # initializes player, field, and other variables for level one and two + player_color = 0 + player_color2 = 0 + previous_level_select = "unknown" + level_select = "Menu" + done = False + player = Player() + field = Field() + field2 = Field() + field2.matrix = level_two_map() + player2 = Player() + player2.x = 0 + inventory = Inventory(0, 0, 20, 40, 40) + inventory2 = Inventory(0, 0, 20, 40, 40) + inventory_block_index = 1 + inventory_block_index2 = 1 + + # loads all the pictures + amon_picture = pygame.image.load('amon.png') + grass = pygame.image.load("grass.png") + stone = pygame.image.load("stone.png") + dirt = pygame.image.load("dirt.png") + soulsand = pygame.image.load("soulsand.png") + netherack = pygame.image.load("netherack.png") + netherquartz = pygame.image.load("netherquartz.png") + bedrock = pygame.image.load("bedrock.png") + spring = pygame.image.load("spring.png") + sean = pygame.image.load("sean.png") + colvin = pygame.image.load("colvin.png") + + """CONTROL""" + while not done: + # sets the caption to the name of the level + pygame.display.set_caption(level_select) + mouse = pygame.mouse.get_pos() + mouse2 = pygame.mouse.get_pressed() + # setting up the menu + if level_select is "Menu": + returned = menu(previous_level_select) + level_select = returned[0] + done = returned[1] + # setting up level one + if level_select is "Level_One": + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) + # the variables in the main function can't be accessed from the main_movement function. They are + level_select = level_one[0] + inventory_block_index = level_one[1] + previous_level_select = level_one[2] + player_color = level_one[3] + done = level_one[4] + # setting up level two + if level_select is "Level_Two": + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) + level_select = level_two[0] + inventory_block_index2 = level_two[1] + previous_level_select = level_two[2] + player_color2 = level_two[3] + done = level_two[4] + # prints the game on each iteration of the loop + pygame.display.flip() + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/interactive_color.py b/interactive_color.py index 0af3288..bde7dcf 100644 --- a/interactive_color.py +++ b/interactive_color.py @@ -3,8 +3,8 @@ """ The following section of the script initializes a few global varables that are helpful to reference at any point in the program.""" -pygame.init() #initialize pygame -size = [1840, 920] #size of screen +pygame.init() # initialize pygame +size = [1840, 920] # size of screen screen = pygame.display.set_mode(size) BLACK = ( 0, 0, 0) WHITE = (255, 255, 255) @@ -12,7 +12,7 @@ GREEN = ( 20, 255, 20) RED = (255, 0, 0) color_matrix = [BLACK, BLUE, GREEN, RED] -block_size = 40 #width/length of blocks in pixels +block_size = 40 # width/length of blocks in pixels jump = 0 @@ -60,21 +60,21 @@ def __init__(self, num_rows=4, color=0): self.blocks = [] self.matrix = [] inner = [] - #makes a matrix that is the shape of the field - #adds an extra row to width and height to prevent out of bounds errors + # makes a matrix that is the shape of the field + # adds an extra row to width and height to prevent out of bounds errors for i in range(size[1]//40+1): inner = [] self.matrix.append(inner) for j in range(size[0]//40+1): inner.append(0) - #adds blocks to the first 4 rows of the field + # adds blocks to the first 4 rows of the field for row in range(num_rows): for column in range(int(size[0]/block_size)): if row == 3: self.matrix[row+19][column] = 9 else: self.matrix[row+19][column] = row+1 - self.matrix[18][15] = 4 #add trampoline + self.matrix[18][15] = 4 # add trampoline def matrix_update(self, block_type): """Uses the block objects in the list of blocks to update the field matrix @@ -89,18 +89,17 @@ def matrix_print(self): for rows in self.matrix: print(rows, ",") -class Player(): - """Contains Atributes and Methods regarding the player's position, - appearance, and motion. - """ + +class Unit(): def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, - fall='on', left='off', right='off', jump=0): - """The first 5 attributes are the same as the Rectangle class above. + fall='on', left='off', right='off', jump=0, health=100): + """super Class that Player and Enemy classes inherit from + The first 5 attributes are the same as the Rectangle class above. velocity - change in y position for each time step. acceleration_constant - change in velocity if falling - fall - whether the player should be falling - jump - whether the player is allowed to jump or not + fall - whether the unit should be falling + jump - whether the unit is allowed to jump or not """ self.x = x self.y = y @@ -113,15 +112,16 @@ def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, self.right = right self.acceleration_constant = .6 self.jump = jump + self.health = health - def bottom_collision(self, field, next_y): + def bottom_collision(self, field): """ stops the player's downward movement if his vertical position is colliding with a block and allows him to jump again.""" """Also makes the player bounce if this block is a trampoline""" self.jump = 0 block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] block_below_right = field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] - #below is for if the player is directly over a block + # below is for if the player is directly over a block if self.x % 40 == 0: if block_below != 0: self.fall = "off" @@ -129,28 +129,28 @@ def bottom_collision(self, field, next_y): self.y = (self.ygrid)*40 self.jump = 1 if block_below == 4: - self.super_jump() #trampoline jump - #below is for if the player is between two blocks + self.super_jump() # trampoline jump + # below is for if the player is between two blocks elif block_below != 0 or block_below_right != 0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 if block_below == 4 or block_below_right == 4: - self.super_jump() #trampoline jump + self.super_jump() # trampoline jump def left_collision(self, field): """Prohibits leftward movement if it would bring the player inside a block or outside the screen.""" - #collisions occur when the block is directly over a block + # collisions occur when the block is directly over a block if self.x%40 == 0: - #if the player is not jumping only two blocks are checked + # if the player is not jumping only two blocks are checked if self.y%40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: return False else: return True - #if the player is jumping more blocks must be checked for collisions + # if the player is jumping more blocks must be checked for collisions elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: return False else: @@ -181,17 +181,56 @@ def top_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: self.y = (self.ygrid+1)*40 self.velocity = self.velocity * -.5 - #if between two blocks check more spots for collisions + # if between two blocks check more spots for collisions elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: self.velocity = self.velocity * -.5 self.y = (self.ygrid+1)*40 - def player_in_grid(self): + def collisions(self, field): + # finds where in the matrix the player is + self.in_grid() + # top/bottom collisions + self.top_collision(field) + self.bottom_collision(field) + + def in_grid(self): """Finds the field matrix value that the player's position corresponds to and stores this in the new atributes self.xgrid and self.ygrid""" self.xgrid = self.x//block_size self.ygrid = self.y//block_size + def jumps(self): + """regular jump function + triggered by the 'w' key """ + jump_strength = -9 + self.velocity = jump_strength + self.fall = 'on' + + def super_jump(self): + """Extra high jump triggered by a bottom collision with a trampoline""" + jump_strength = -13 + self.velocity = jump_strength + self.fall = 'on' + + +class Player(Unit): + """Contains Atributes and Methods regarding the player's position, + appearance, and motion. + """ + + def __init__(self): + """The first 5 attributes are the same as the Rectangle class above. + velocity - change in y position for each time step. + acceleration_constant - change in velocity if falling + fall - whether the player should be falling + jump - whether the player is allowed to jump or not + """ + Unit.__init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, + fall='on', left='off', right='off', jump=0) + self.cooldown = 0 + self.attack_speed = 15 + + def draw(self, amon_picture, sean, colvin): """ The actual printing of the player on the screen This is where we excecute our movement if the player is supposed @@ -217,18 +256,71 @@ def draw(self, amon_picture, sean, colvin): if self.color == 2: screen.blit(colvin,(self.x,self.y)) - def jumps(self): - """regular jump function - triggered by the 'w' key """ - jump_strength = -9 - self.velocity = jump_strength - self.fall = 'on' + def attack(self, other_unit): + """decreases health of player""" + if self.cooldown < self.attack_speed: + self.cooldown += 1 + return None + other_unit.health -= 35 + self.cooldown = 0 + + +class Enemy(Unit): + """Enemies are zombie obects that inherit from the Unit class. The units + give damage when the unit is within reach, and move with a simple condition + based AI.""" + def __init__(self): + Unit.__init__(self, x=1600, y=600, width=40, height=66, color=0, + velocity=0, fall='on', left='off', right='off', jump=0) + self.lag = True + self.attack_speed = 30 + self.cooldown = 0 + + def think(self, player, field): + """logic behind zombie's movement""" + if abs(player.x - self.x) < 2: + self.right = 'off' + self.left = 'off' + elif player.x > self.x and self.right_collision(field): + self.right = 'on' + self.left = 'off' + + elif self.left_collision(field): + self.right = 'off' + self.left = 'on' + + if self.right_collision(field) is False or self.left_collision(field) is False: + self.jumps() + + def draw(self, zombie): + """ The actual printing of the player on the screen + This is where we excecute our movement if the player is supposed + to be moving or falling.""" + if self.fall == 'on': + # the player has a velocity to allow vertical position to change + # fluidly + self.velocity += self.acceleration_constant - def super_jump(self): - """Extra high jump triggered by a bottom collision with a trampoline""" - jump_strength = -13 - self.velocity = jump_strength - self.fall = 'on' + if self.left == 'on': + self.x += -2 + + if self.right == 'on': + self.x += 2 + else: + self.left = 'off' + self.right = 'off' + self.lag = False + # update the y position + self.y = self.y + self.velocity + screen.blit(zombie, (self.x, self.y)) + + def attack(self, player): + """decreases health of player""" + if self.cooldown < self.attack_speed: + self.cooldown += 1 + return None + player.health -= 20 + self.cooldown = 0 class Text(): @@ -359,17 +451,17 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) if (check_top_player== False) and (check_bottom_player== False): if field.matrix[mouse[1]//40][mouse[0]//40] == 0: # A block cannot be placed if another block already is in that spot - if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place + if self.bin_list[block_type-1] > 0: # you must have at least one in your inventory to place # T he range in which you can place a block is a circle with radius 5 if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - self.bin_list[block_type-1] -= 1 # subtract one from inventory + self.bin_list[block_type-1] -= 1 # subtract one from inventory # place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) else: - # In this case the player is halway over a block, which means + # In this case the player is halfway over a block, which means # that the player spans 4 blocks, and you should not be able to # place a block in any of these places check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) @@ -448,18 +540,15 @@ def level_two_map(): def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring, - player_color, done, sean, colvin): + player_color, done, sean, colvin, enemy1, zombie): """This is the main function of the program. It contains the controller for the program user keystrokes and other actions are turned into actions in the game by referencing other funtions and classes.""" player.fall = 'on' + enemy1.fall = 'on' field.matrix_update(inventory_block_index) - next_y = player.velocity #how far the player will move on the next iteration - # finds where in the matrix the player is - player.player_in_grid() - # top/bottom collisions - player.top_collision(field) - player.bottom_collision(field, next_y) + player.collisions(field) + enemy1.collisions(field) previous_level_select = str(level) clock.tick(40) @@ -491,13 +580,15 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.jump = 1 player.fall = 'off' + enemy1.think(player, field) + # pick up block if mouse2[0] == 1: inventory.add_to_inventory(mouse, field, player.x, player.y) # place block if mouse2[2] == 1: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - # possible actions start here + """ possible actions start here""" for event in pygame.event.get(): # press teh x in the top left to quit if event.type == pygame.QUIT: @@ -554,10 +645,10 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, column_count = -1 row_count += 1 for column in row: - column_count+=1 + column_count += 1 if field.matrix[row_count][column_count] != 0: if field.matrix[row_count][column_count] == 4: - #based on the number entry in the matrix, it prints a different block + # based on the number entry in the matrix, it prints a different block screen.blit(spring, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 1: screen.blit(grass, (column_count*40, row_count*40)) @@ -569,9 +660,11 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, screen.blit(bedrock, (column_count*40, row_count*40)) inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) player.draw(amon_picture, sean, colvin) + enemy1.draw(zombie) return [level_select, inventory_block_index, previous_level_select, player_color, done] -#Control + +# Control def main(): """ The actual call of the start of the program. Main movement is referenced by this function. @@ -591,6 +684,8 @@ def main(): field2.matrix = level_two_map() player2 = Player() player2.x = 0 + + enemy1 = Enemy() inventory = Inventory(0, 0, 20, 40, 40) inventory2 = Inventory(0, 0, 20, 40, 40) inventory_block_index = 1 @@ -608,6 +703,7 @@ def main(): spring = pygame.image.load("spring.png") sean = pygame.image.load("sean.png") colvin = pygame.image.load("colvin.png") + zombie = pygame.image.load("Zombie.png") """CONTROL""" while not done: @@ -622,8 +718,13 @@ def main(): done = returned[1] # setting up level one if level_select is "Level_One": - level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) - # the variables in the main function can't be accessed from the main_movement function. They are + level_one = main_movement(player, field, clock, mouse, mouse2, + grass, dirt, stone, bedrock, amon_picture, inventory, + inventory_block_index, level_select, "Level_One", + previous_level_select, spring, player_color, done, sean, colvin, + enemy1, zombie) + # the variables in the main function can't be accessed from the + # main_movement function. They are level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] @@ -631,7 +732,11 @@ def main(): done = level_one[4] # setting up level two if level_select is "Level_Two": - level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) + level_two = main_movement(player2, field2, clock, mouse, mouse2, + soulsand, netherack, netherquartz, + bedrock, amon_picture, inventory2, inventory_block_index2, + level_select, "Level_Two", previous_level_select, spring, + player_color2, done, sean, colvin) level_select = level_two[0] inventory_block_index2 = level_two[1] previous_level_select = level_two[2] From 59b465fc51ea4df6118837b5b3412eba0cc3544d Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 23 Apr 2017 18:17:23 -0400 Subject: [PATCH 81/83] Create Branch --- Game/NewPygame.py | 96 +++++ Game/Older Game/get_compliment | 18 + Game/Older Game/get_compliment.py | 20 + Game/Older Game/test.py | 3 + Game/PygameTest.py | 83 ++++ Game/RectangleClass.py | 134 +++++++ Game/World.py | 77 ++++ Game/Write-Up.odt | Bin 0 -> 264018 bytes Game/continuous Rectangle.py | 646 ++++++++++++++++++++++++++++++ Game/continuous Rectangleold.py | 163 ++++++++ 10 files changed, 1240 insertions(+) create mode 100644 Game/NewPygame.py create mode 100644 Game/Older Game/get_compliment create mode 100644 Game/Older Game/get_compliment.py create mode 100644 Game/Older Game/test.py create mode 100644 Game/PygameTest.py create mode 100644 Game/RectangleClass.py create mode 100644 Game/World.py create mode 100644 Game/Write-Up.odt create mode 100644 Game/continuous Rectangle.py create mode 100644 Game/continuous Rectangleold.py diff --git a/Game/NewPygame.py b/Game/NewPygame.py new file mode 100644 index 0000000..29bd0e2 --- /dev/null +++ b/Game/NewPygame.py @@ -0,0 +1,96 @@ +import pygame + +import pygame +from math import pi + +def main(): + # Initialize the game engine + pygame.init() + + # Define the colors we will use in RGB format + BLACK = ( 0, 0, 0) + WHITE = (255, 255, 255) + BLUE = ( 0, 0, 255) + GREEN = ( 0, 255, 0) + RED = (255, 0, 0) + + # Set the height and width of the screen + size = [400, 300] + screen = pygame.display.set_mode(size) + + pygame.display.set_caption("Example code for the draw module") + + #Loop until the user clicks the close button. + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangle_x = 100 + rectangle_y = 100 + which_object = "Text" + while not done: + clock.tick(10) + + for event in pygame.event.get(): # User did something + if event.type == pygame.QUIT: # If user clicked close + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_LEFT: + text_x +=-10 + if event.key == pygame.K_RIGHT: + text_x+=10 + if event.key == pygame.K_UP: + text_y += -10 + if event.key == pygame.K_DOWN: + text_y += 10 + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_LEFT: + rectangle_x +=-10 + if event.key == pygame.K_RIGHT: + rectangle_x+=10 + if event.key == pygame.K_UP: + rectangle_y += -10 + if event.key == pygame.K_DOWN: + rectangle_y += 10 + # All drawing code happens after the for loop and but + # inside the main while done==False loop. + + # Clear the screen and set the screen background + screen.fill(WHITE) + + # Draw on the screen a GREEN line from (0,0) to (50.75) + # 5 pixels wide. + myfont = pygame.font.SysFont("monospace", 15) + keys=pygame.key.get_pressed() + + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + #pygame.draw.lines(screen, BLACK, False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) + #pygame.draw.aaline(screen, GREEN, [0, 50],[50, 80]) + + #pygame.draw.polygon(screen, BLACK, [[100, 100], [0, 200], [200, 200]], 5) + #pygame.draw.arc(screen, RED, [210, 75, 150, 125], 3*pi/2, 2*pi, 2) + #pygame.draw.circle(screen, BLUE, [60, 250], 40) + pygame.draw.rect(screen, BLACK, [rectangle_x, rectangle_y, 50, 20]) + + pygame.display.flip() + + # Be IDLE friendly + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/Game/Older Game/get_compliment b/Game/Older Game/get_compliment new file mode 100644 index 0000000..055f6c9 --- /dev/null +++ b/Game/Older Game/get_compliment @@ -0,0 +1,18 @@ +def get_complement(nucleotide): + """ Returns the complementary nucleotide + nucleotide: a nucleotide (A, C, G, or T) represented as a string + returns: the complementary nucleotide + >>> get_complement('A') + 'T' + >>> get_complement('C') + 'G' + """ + # TODO: implement this + if nucleotide == "C": + return("G") + el if nucleotide == "G": + returns("C") + el if nucleotide == "A": + return("T") + el if nucleotide == "T": + return ("A") diff --git a/Game/Older Game/get_compliment.py b/Game/Older Game/get_compliment.py new file mode 100644 index 0000000..41ca987 --- /dev/null +++ b/Game/Older Game/get_compliment.py @@ -0,0 +1,20 @@ +def get_complement(nucleotide): + """ Returns the complementary nucleotide + nucleotide: a nucleotide (A, C, G, or T) represented as a string + returns: the complementary nucleotide + >>> get_complement('A') + 'T' + >>> get_complement('C') + 'G' + """ + # TODO: implement this + if nucleotide == "C": + return("G") + if nucleotide == "G": + return("C") + if nucleotide == "A": + return("T") + if nucleotide == "T": + return ("A") + +get_complement("A") diff --git a/Game/Older Game/test.py b/Game/Older Game/test.py new file mode 100644 index 0000000..bb04a1c --- /dev/null +++ b/Game/Older Game/test.py @@ -0,0 +1,3 @@ +import math +a = eval("(math.sin(3.14159/6))") +print ((a)) diff --git a/Game/PygameTest.py b/Game/PygameTest.py new file mode 100644 index 0000000..b0fc374 --- /dev/null +++ b/Game/PygameTest.py @@ -0,0 +1,83 @@ +"""Animates a bouncing ball. + +Author : Oliver Steele +Course : Olin Software Design Fall 2016 +Date : 2016-10-24 +License: MIT LICENSE +""" + +import pygame + +BLACK = (0, 0, 0) +BLUE = (0, 0, 255) + + +class Ball(object): + def __init__(self): + self.radius = 20 + self.reset() + + def step(self): + self.y += self.dy + self.dy += .08 + if self.y > 480 - self.radius and self.dy > 0: + self.dy *= -1 + self.dy *= 0.99 + + def reset(self): + self.x = 320 + self.y = 240 + self.dy = 0 + + def contains_pt(self, pt): + return (self.x - pt[0]) ** 2 + (self.y - pt[1]) ** 2 < self.radius ** 2 + + +class BallView(object): + def __init__(self, model): + self.model = model + + def draw(self, surface): + model = self.model + pygame.draw.circle(surface, BLUE, (model.x, int(model.y)), model.radius) + + +class BallEnergyView(object): + def __init__(self, model): + self.model = model + + def draw(self, surface): + model = self.model + ke = model.dy ** 2 + pe = (480 - model.y) ** 2 + pygame.draw.line(surface, BLUE, (10, 480), (10, 480 - int(ke * 20)), 20) + pygame.draw.line(surface, BLUE, (40, 480), (40, 480 - int(pe / 10)), 20) + + +def main(): + pygame.init() + screen = pygame.display.set_mode((640, 480)) + ball = Ball() + ball_view = BallView(ball) + ball_energy_view = BallEnergyView(ball) + + running = True + while running: + for event in pygame.event.get(): + if event.type == pygame.MOUSEBUTTONDOWN: + if ball.contains_pt(pygame.mouse.get_pos()): + ball.reset() + if event.type == pygame.QUIT: + running = False + + ball.step() + + screen.fill(BLACK) + ball_view.draw(screen) + ball_energy_view.draw(screen) + + pygame.display.update() + + pygame.quit() +if __name__ == '__main__': + main() diff --git a/Game/RectangleClass.py b/Game/RectangleClass.py new file mode 100644 index 0000000..31aaa4c --- /dev/null +++ b/Game/RectangleClass.py @@ -0,0 +1,134 @@ +import pygame + +import pygame +from math import pi + +###################### +#Model +###################### + +pygame.init() +size = [400, 300] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) + +class Rectangle(): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + def draw_rectangle(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + def draw_shot(self): + self.x = self.x + 10 + self.y = self.y + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + +def main(): + # Initialize the game engine + pygame.init() + + # Define the colors we will use in RGB format + color_matrix = [BLACK, BLUE, GREEN, RED] + # Set the height and width of the screen + size = [400, 300] + screen = pygame.display.set_mode(size) + + pygame.display.set_caption("Example code for the draw module") + shoot_object_list = [] + #Loop until the user clicks the close button. + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangles_x = 100 + rectangles_y = 100 + rectangle_list = [] + which_object = "Rectangle" + color = 0 + draw_rectangle = 0 + while not done: + clock.tick(10) + for event in pygame.event.get(): # User did something + if event.type == pygame.QUIT: # If user clicked close + done=True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_c: + color+=1 + if color == 3: + color = 0 + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + text_x +=-10 + if event.key == pygame.K_d: + text_x+=10 + if event.key == pygame.K_w: + text_y += -10 + if event.key == pygame.K_s: + text_y += 10 + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + rectangles_x +=-10 + if event.key == pygame.K_d: + rectangles_x+=10 + if event.key == pygame.K_w: + rectangles_y += -10 + if event.key == pygame.K_s: + rectangles_y += 10 + if event.key == pygame.K_f: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + shoot_object_list.append(rectangle) + if event.key == pygame.K_g: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + if event.key == pygame.K_z: + rectangle_list = [] + + + ########################## + #VIEW + ########################## + screen.fill(WHITE) + myfont = pygame.font.SysFont("monospace", 15) + keys=pygame.key.get_pressed() + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + for rectangles in rectangle_list: + rectangles.draw_rectangle() + for shooters in shoot_object_list: + shooters.draw_shot() + pygame.draw.rect(screen, BLACK, [rectangles_x, rectangles_y, 50, 20]) + pygame.draw.rect(screen, color_matrix[color], [0, 0, 20, 40]) + + pygame.display.flip() + + # Be IDLE friendly + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/Game/World.py b/Game/World.py new file mode 100644 index 0000000..4bab518 --- /dev/null +++ b/Game/World.py @@ -0,0 +1,77 @@ +import pygame +from math import pi + +pygame.init() +screen_x = 1840 +screen_y = 920 +block_size = 40 +size = [1840, 920] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) +color_matrix = [BLACK, BLUE, GREEN, RED] + + +class Block(): + def __init__(self, x=10, y=10, width=block_size, height=block_size, color=BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + + # draws the rectangles that are dropped + def draw(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, + self.height], 1) + + +class Field(): + def __init__(self, num_rows=3, color=0): + self.blocks = [] + + for z in range(num_rows): + for i in range(int(screen_x/block_size)): + rectangle_color = color_matrix[color] + block = Block(i*block_size, screen_y-block_size*z - block_size, + block_size, block_size, rectangle_color) + self.blocks.append(block) + + +# Control +def main(): + pygame.display.set_caption("Game!") + done = False + clock = pygame.time.Clock() + field = Field() + + # Main Loop + while not done: + clock.tick(40) + + for event in pygame.event.get(): + if event.type == pygame.QUIT: + done = True + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + + + # VIEW------------------------------------------------------------------- + screen.fill((150, 190, 255)) + + # draw rectangle objects + for block in field.blocks: + block.draw() + + # draw color matric and main rectangle + pygame.display.flip() + + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/Game/Write-Up.odt b/Game/Write-Up.odt new file mode 100644 index 0000000000000000000000000000000000000000..b64d595730fde0f994c5c0cfbe159afbeb665838 GIT binary patch literal 264018 zcmbTdbCe|A(l6YaX`9p5v~AnArj2Raw(V(8+qP}nwr$<&=bZE2_pJ5Zf4*InE3-1Q zB4Y=Cu~(#=Bq$gP5D)|q5dAk(3GD#}7*Zf0psx*Z3dqvb(#XNp#z@b`#=_J<&%xB% ziq^@>kj7fi-qfDP+Q!Jr(AvP!(#Xnz#=*$NLGHhZy%zi6@lyiW@=~vn2?#7g|VfRg}sxxqr0Vtw~e8m?Qb(Xa|1gI zGdD9`cSj3*J4btacUw0PH%EI9S6dGcPXkL|3zr}>_ZT}TA1CK9dk;Sw?+|wnUu(ZG zcmE*w;6y(~et$=EUspR{PtOofrz&0HPZt+oFP~6<_rx%_%y^HyWDh?-fB(QR|ImQI z@QCmr|A?Tl@UVdJ@Noa&1pn}O|ERR^$he5u2>+Obz}WQQ)Qs@h`0)7Ds6R0g=^1h1 zp>a|1$$%4pk(ieBCm|svEj2MdB{4NEH6bl6%_llLJSi_ODLWxGCqAR(PjXROdQNIa zNqTmA!r$D4?9z;!+_apMjH1HK;?lID`n>pn?8L}|w4l7yh~gyQinP$2^yKV}+_JwB zg*j>UMQOQ!kynyil$TdrTAUBqmzEX-w$j4VnzHJO(we5)(t@he+QypFrl!V>jL(dk z?(E90(#HPs_UWp+uG-d~+V+vw_MX;`p^A#n#>UU~?)J*AiPG-b`tJVv?veKHzP8@c z_K}H}p~aT*t@i1??uxwrhLY}%=IM@_&+zciGq+ap~114vFWkV>G_$l!TG8Fxv8ezzkWWuzB{{nK6`$@JKMXtIQ`t+{X9Lry1aV4 zIlaBTy}5t6e|orketW&YeS5k8`1k-g!sq9wis<)wARzKLaUp&smz8r*SO=^@Pvh4L zXVaI9l@6B5#X9K=nneO*2lk`jdpA}k~yF~nHY-n#B2r#T;O8X*Kp z1K(z%Zx|JiG$hi2K4tLfD9vMoy6DU9grY49kb8FOB3mVB${N(htR#XOeLX-2?PDY!S|OPaHNG>^@L!}-M6A;(Gw+rx8wr|solfqU@8hI#{{_3P0e7eo?2 zu*&pp<*a?soqNJ^HaM)4v$k{{TNPu-*zj-6!VY4xv@&I(cP~pN@qz3w^y0I=ixqbr zx(PIQ3!;1qt%O~FiTwkpnr)Hz8FDmX1jv{JU4cRH1734y{>HIK>Iy*>0tM*v`jWRY zFAXS*f}uzk_My}T4nihd_&d_|{A5Je9EbWd3gxDw7LupXGNhzE#W1JDUyq zi@A2|HHrvIi4znl(_}oH;h_{hq`@f{mUzP9IaF%k=w3q!nV&(32|(%J0*-DyYby9q zhZ*D$IR40YsRF$bzVY8pia#1y!X$2&$vRWK0=cYzYx$))B$2Cttkh%YYt?Ow+8R zZxsskyVEOJsB>VWx0FbrWe&w@1TC^#%M-){Z7_{x56GUL?M2rLs6IpZ@5M7)fyg> z?E6Ixfrx+>arr1%Opo>*LaK`fKOX{!FOCp0khs^2TxBr{2HYSNNKOKnK!M2D!C4_n zO%4e{Dl_aQzFVvXkNC-kK?DCB&4ol@1=ywGmU9y(noG9FG>Vr8ijNR8<5D)AGSn9s z=uMxBn2XcqS)TU@Jo^{@wO*3~M*JZ3Vus))_U_%uNtVys_dn2df)Z__fAv3hmVfO> z##LENGEP#r26)^3SwPEYh#KxmJ@v`AuC4-`ZOP`qXGGLG(mqv!N>r4%!r@KV(Sl5r z=0P{gB8qs?1v1&ED8#ld@HU`>lcbqkvN0y2ZIXy;5mTH@>$e_z~|<)bq_?!r8bLX z>2MAANhGZ8M$&U{li{SAxrgiC51GD+@5hN#V6Bs*x6l+X2;9Nn(JwOONG42GL1|oL~l{`yK}TB{TvE)Us}7B z)s?obj}7xVeBBMBW%IbdG5c#X(x(1vhxIQ<(N52V$B8=?OG!!YP1gm-zk#cP>km?` zkGA^WVm_Skp2d!x@A$*qH&8b9D)AgT@#}-$Tp9@S(!(2jC8e-qw&z}>S_JSpM=e;NTDgOMOjy>GRT3M>^dUscbrZ2OwUOg_(BQpyqe2dYaUGOqeK& z+Tw`?rc{2$$GoT1Ir}DrV6(rWXyQyGjz6*Q3wVmIvef=U%`yz z)F=u!8zqSII`M}8SjU0g&2cz6gMqmd5{=;eA(HQ32$Bo3O9V?)NINfgI|8_F-EoDr z{82|t%A*V$>onN&bV2*kO=`w->#qFxF>%O)jMHhLr|B{?dLJwtJh=6Qvy`(*3t^jlo(hH>r8DX@+H zox@$KJcuTKPH6trs|%)frMoC)=xsM&md)Sk-<$KtkF7iNZQ}-6j=mit&Z6tt*%xw6 zZath$r`nX*E(#7~Eg&BPO&8021dDPdmv@U;dV~0?>swWkI8OOPTV2Oi8}f@=S66zt z3w9l2a#O#wPS5v2GvHVuA)F|Wk4$b=tc$PnPl!9hu!ycFP7)#;SykZIFeBpISI<+@ z-#ap+d)QionjX&h6hG?q{1 zB1balW-=C!W!Vo=XDIhDZ7`uhqgrX8+`cIkM}r9u(H_q$B+0%ushTM>J@}2YKqxst zMcOA&i;t$)jTVx~h>l)#sXsA-VhDyx#I7|EWZ8s6 z=?bp`#O13YQ-4N&+W`R=0V~S}4({;h;e#m$#FUJOgWggJuct{^Vh`v6TR?sMv6j8K zuJ^tUm10;*S)08;Rx}*&dI+egzii~lAcR1w2zPG@o^-^%3-^B%a-BFVl>cmyybFK7 z)ynvVh1u`kIHy& z2+qA`bN}}8n^g<12?IGV&55+?_Z;c$1tk}TI57>&M~FQp`ydX~ zheRi1EpC<>nJE-asu1Jz2MkGq#)BnROaxUN1TiHYTawtPY-|t-i0=p*wJL&GCNV=-{VmGbTF)Iq+ZqyCXxCbkJiT;yZqy!~BmQOXv_n zpfl23ur*!yrF5Mo&|t_lYv=UM3@E>t79$(ItVe2o(L24@VT_hjpRh0BxG+1Or?Q`V zPH*OUcl8(or>HH`)4<%Dp*^4ms z-dwY&Z{V%xmJqLeC7?Mnv0~zE`cN3`qFm=>$uN(>p-CPbSN^8+c-^+ha!qY~NA0ZW zS+i;%PbYKvEfXDj&B-~OR`+rY-q$MT=5Uv==~100mI5pW$io+OzU!1{|2R<`GswfM z^CabUT6^o_XB7S+lv|E)%z&9vD!^;EJyyv)u!)s^!VPZ&x?FsC%Mv=7w60h!GlE z6L7Bo$R#WDlq{m%mq_T`z_l`6pCG+soV{{|L@T{`*mW0rgSiV5S+-P7-kEY2}AhR+@KC;T}3TNk-cwDG!aCN4|`#>fb)c zq?UHhj?Q{ow!AtyjLi4!cgt;F>BdyUqnJsZe3p$w!i+cI4?xO(1yz#NWPG)p$?m0n z&k^vTPB;GG4a%w`oxJwSdWwH)(4G*DKQm-s!iS-fHMfJyq3U4+HJWb%Nj!s~iqI{A ziAaxdTn-46KpRtMhMs+~fFl<^@h_f=sg+1-l$A1rh;<+-EGmims}d(Iq*N9WQHnsI zMfB1XR?`xJ%8*lhXQocUJrn{*&{I$rorKBEoR&>*J2Pcu9At+gqVxwLabMS;jx0RU z3c~!LvR1>Y-@02Zc@6Z;@zwpEAKXaI60M8p)Sok(sWv22<$=a4_H}) z_{i%maqaFxci0(vOh{El2BjN8ZpQWyL%iN4vSSO~AiKZ*AB?-8hBdo?g-uzr6v-?l zmTg1E^|Nldm#nogoLN~Rkr|`iy~vxn*YMBaw2$Cl&6zmMzv;!lI>&=|BCiuFe|A0< zwE_8>^ z2{u2_^1TAy#Q3T6(M-7>u)6Vs+Exn$FD&V;11OreDl;}Qfd<$FJHqz(Oj z10~`(AE~)#M1f%NiPX6_gIsZ=WX*ry_nnF4RCnYjp#XdB&*Se|ql<_1Nsw$c6#ST6 zBD4;+4!v|iett1Kz}%@|Sug_MY*vsF-9I6T9}?3YV{OcWoWnu&x_{XD6m`mHf`aH= zvAo1h$AOA%Kx_joofGqwP&8q37E{8v@#EJ+BRpwkxDLPzGe=EaJyiaEL%YrCvX96CA70;eAMa^I1z_P`G za~W(;=hCz_#J_}H8JmJ7WRW)4PH!)*Td_l}P`(@djQ}^a@deWJw~(+W%?M^?gqr7Ofp+wnu#2*RNeFKw?(cJ z3BG+&gQrS_dwYrBjlx4vx6K`#skE^bzOYl&V(wlbmYtiySfol5c?1eHqGID@3xii# z$`Gq^!pY#hsf4m?1am@c8PAGOJSB%IDp_a8HWb@Ww=QeIj>p0D& zoM85I>*cwa^3U$XA9~4oaRpxXnJ6ok4^Sgym z9raeo2M>?wKp!Gk-|&u6SW9^>(XPeaJ0~ZHs-V^>V3^_xBfH|HN_90V51@Kq*r=+> z8^rtr<0=ps<7*FUQV_Xw6}_aSu?l>rLqxC#=X_gQA9yBpX?4L1r?tdKYE38B01F0Y5+>+$s-=9jm_33_eFuQVaX2? zwARHKrXYvQSu~GDG0BC!MhWP7lJ5Sqd{>BTyE%1W?bv`gktV(ht*_?6#pR?o%QHNm z2XlX4=Ru2kcFoIt9j26Z;wl{DMQZl6s}qa8F}Lq|bkTdIniK7DcyUCugWSAMesfNm z;oq)=`*NlbKXrb&gWX-qKPgp}pGJ%+k)ieJxp_ocz6@JdS8^t|SHg)Z19&;XE*{lt8)p*T zO6-J?a@GO|sLo_qhano;de*&;MXe#-PR?PMnM9r9Bo*dUlEeH-$P(N#RN zmBU8h9Y?ow_yN}S*SYmHOXgbN7n@zDU-JdN-Q$|SG7KIof-N3SEF&{Z#_jX&)S5bM z?Rl2#MrV62E9-sNcq+0TJ_VheB`pUFHhMF`FFOiTlN(elSM*gyOf4T( z@!CD<4vRb97)U$GHa;pJo`uSY(oQl*add2Q9r2!`zGqD&JhYreF>R`C-p-~n621(L zq=z%lh9MoV0=BJL+SlPFSx>)$)6PG_lL0jd1^Ir10FPx?92bI3D^by+YztPOf7 z1Fa`=$xI)S4fU2TVV}R%*5=uf*Vd=czU30P6*mf7@HBJN zqdhI)y_D(_EXt!lCpOX79Z#cW!gGQjdXP5M)%TH#{ka8yN@|fFqGvt&(d@l5!f4zo zv`x7~q*>Rsza$2{dH$?XZl{CWl$uos*&#IIyfT(+z7>wcttr`L}huzfMGK*WU+C; zDt43t?H_V+b=N9sl`T{;oVXu!?%#?Oz$Qw_IF?2I^B9`*;-va+dZ$68No}z=@+=cJ z2%cWmk*^l)NE}?1>tk>}k5iuVY@f=6#S2Xmpez(%o6n=~-C#LE=YdxrzI!d~V%Dj0 zHdykwllG9!x9P8T?)C%eG*#+3<4jsx3fDU0N1VC@$k+vAU-Em~sV9zCUM$HQ&o?s* zvG{FH*f9J^X(^Boj>HOquaFFHz7KR6*0lDyCTT?pfy?(fksu(H&UT<6EsmVZJdxy- zNXSO=E4o8$UE_t(D$biqPPzdmoytz*qPx;D_zNw(pFk$~OOn4lo*=(xS&;yOJ8(b^ zZD3C5HyMSr=7T(lg{a)H>xrVS$9FO$A|AF&P)~7o;_T-b+G%QEC8URIAfcJ=Uq07D z^N)e1HWCCx2rr=-?pFp)*o^zT+K$c$R)r^7=&wkx5R;f}isMn14qHb65my}I%qj&5?n0R4m<5d$Wqzqe)f_Z|Bn zKQ@6Qbn{kTA(kZinc|0}v^8}7W)r~zN+9omNAdF`1{e3o~`Ias9(V%2dXC5{-dnPwM*AG-%XW%44%O?#JlrRW73= zvk=0a{Ajnr;a)RLw+n;>;o(X9gu<$^4cO&@Ap7f2%Wd^tET-hsV$Fuu?5s@mrA>Os zop1Zd-Q3YqR?wCcR?bV<%rqMtQekk9v#S%Zs~VYZcApE>+y0EJ2W=C3?-LxaS+0+^ zZHvbyB|rPNLGIhyf33ax53~&M7_VPvIMxTY(-gKhD_w4Lwpm>^(3${OsJt)5VYDdS?{jZ9W=|d+ zzRnd#dYoA(Z+DerTb;OuzpTEr#Bh3Fy4=%X$bXqAJmYpObWaDf$?%fRn7xcmA9zeX z`32u^S-(+$Ia9|ub?m6u(RyTuhjxK!X>F%>DR#QGgc_`Cjdenx{kp4pppqti;apw? zd958Ee!0-Asz0o$KFFc-d@uk(qqoNNo)}37USTX*NEejMc2yM{6B*khK_{u}`D|@I zQMm!VfA3pQLRp4ya7|NN3}R8C0{Pb{`uV!IGzYwk;wMwaCR>D|jx@s-0tihdV;`?G z!}f_6Ok0sgVG^v$)^@gcIDsH~SD zGS#p5F<>VK=>}A|_YmuZm87o^HziXLr#aWZRcmi1Wo-Cfa@Abw_R!n9+#iI%h)*;p zs_P^lY`d66op`C83wJUfd`7=%>1{w_ZZ2U&3}afyuRrn)&5|)$a&SVF^y6Vy{HT|4 z^=lX8bat4t0pwo2t5IJ(Xlj3C9_L_mmeW0Q_9Hv!Yy0%v4BF}`qkAmN?>^1hk zSnB3g7-L@*qpTlV#C6*;?9aX1ju*j$%-mL>KRp`X)SovO^45QD{8Cjl-)mT=Sz77N zjzVvL=sMIHi&-ypbH>z@gI$?nPVXgeak7m0u=~D1&*Jd%?3w*aZL#wPGVrb8X?12i zB9tzZWl&mEjgC3a;MSsA{~pmodiO@@SA!k)t|~p83!{aRORTgQLj@VTh1p%YTLS6f z2^y@*P>M!q#*cl}9gflkbSa!khCx#|_MB4^Vt?c6{8>Yjm?{@1{|5QY%X%i_IPS&) ze|0yj@}IP@C{^S$)>uO7YFhNVcBSA(7;R?e-`n_CG2CRbzpL_cM4;yl$CR11iNK1nsd-@W!XMom5iy#oKZh>iwT4*9D_4iUJmB-Jv5H6fH2hXFg-Qwe4N zi4oZcA3{%0m8U3xB&@qF7{p&e?LiJtMEj_5Dj$omi~>#?(o_qsIbwf(@!^8mdt;L=N> z(ReSfcMTQs^{F46PmacIztawFbJ{zaCTzaDNh`&n#c9sS9FP|<@ruInjBj(QcPVqZ zuQwPhg801@HW;Pdj&?)=>m1Qd#@XR?S6{k!G;jWa#}fgd#4ce{5UtsMr*Umk{Y0v& z;~t4kj;2#U)1Qd-K`N?K5PilBwL6s7Pb7@Fg8}PsSHF5>ic*P7KJ&}-xL%UU{th>u zHM&|<=+J>gS%cMh^{+0lc5r zlwAW@uFD=ppgfm|Y;xuRz1^|G^-vn^CQIPS$+W>43F9jMV3bzN-N7`WCxvQs(xhs{ z=S;Q1U|4|0c>ZYvzi*5|vQ=84{C4EOd^l1b47R3B__427$yaNSBJJ z$Q(&1t_9*A#y;_9fKddZU!Q=*w6S5IAAfbY@e$~R>$PGH!nGDMlT;bo}i;?tEs+*hk`Wi&Yg6WqB>_}Dv zC+f!R2$?vz3!4{jndmb%2&AZL(~lC2w&T>RBfZJ#q*RUy!-N=Pt*R1d=47ZC`bm_k z&;K~&$fb3InR6^KvWuA@9E3UkkR@pFCy#sarXA9fmTVlR38hE?)^Ba-sDG}6%)F2_bW4<@_s ztL#hqz~%YhUff(e^-frgOq2MDs1+zFrZ$->v~@2ds+Sx%GxCKf5BhI9`kFLrlMinb zH?L~$y4O@?XIoug;$xwVH2R4o+~s&=LS+i}(^sg5kR@yl`9sKv`r7iiy&P{0b#7tzOIP=140%?4v(Wb%&sGr`6)VzGptdVkBj#1M1@qE-T zA^K@T-vnU!uox8T5wxVjEnBc~q2H?kQ#qC9Cc`CCERbqBxNK>Sh9{7SKgTRY;+9*e z@)B7y^3dh<)IHJ2Qv}w9DB^xt3j`ScXx}XCPQYhor2s`Y-OksDUSL|%ok?y_O2GNq z0~6C+GhPZMWNbZ0XdzQS*6_0c%tRrXTw}fpg)G)Uow6p`;MgTBRJ^p!pJ>4(Lv%Jn zzo(i@FI6P>Ok6MpiN&U$g@=KTid$GY-PcH?M*Y-Rc~^2(`&Zq3H%jc!S?d#xE*D>N z@rU2ck-8)xj*`EDziBunB@iddTl8vT0;h15H!cU|V8RxmBC5L~V;h9o>9)6>GqdpG zW3Y8A=uDOE?=6D>k!V3es)v)TG9_wwx<+T*U>y{gESUU?QGvblR|wVc$|4_+Hex^= z`@O3OEf1SGFEtmSY~&kAQp9JNK}|%)TFszjnxvy{oRg)Utx-tcF(JJgV%L9(+D)cn zVNh(niLsU>-wXM}?NcKx`Q_EEGH>P=dyrge zHEhF995={AP|Qt^e1U0%Fq&sJHna6kn<>h1{%`xSryE0GZ8~cW)K!;4aC`grqlK0D zok%!58~B}8$=;$0V~6%=$8eL9Z`6d<`uyK;--pk7sVYHp1GS7JabTqxDY64K3c0eY zsnw(y)(om8@p$r3*sk=|c=hSZ1FJe<{lU7G6PWt+_XIEx8+k8RBp& zDoA4>n^)jw>u1XF8$FYr##l0RcRD?5FDhdkG8_}xMiBhnC!Ip$Uz}K*8Zx3z;XF!s zBQve^%xqNSvR+RJ%L>+;kld1(Qb4#rQEeya%ZzOzK8zfhgtI{0rPf)_$%~ky0nhJG zR%Syap)V&QNyjj^Vx%=c_s0r1_-dlaM)gn8)59aw)@p~Gr&1mPO~p(ge->Qx6_4Oq&ma0#!~DCp*GEv#`--O&D>>4{}kmgt?*w#Y8G(H->$| zzm#C3b=`G&ZwQu`{3STm&w6MSv$~DbOj7o-kwHJs+U=kRKz3P$9GNK;iibd|5L|2# zXIZv)K-%x?+C$VHE1JawXR1!yN=x*ySZU`f?X9kHT6I`2?y|2%nm=Xci#T$;_YoQL z&>d8Mj|4Z*Me~V$FNHc4or(f=PK}z&q!YqoX$#C`NgQK01 zJuN-m{~F9pLjU}tXJue#;b)>_VPfJJVx?zdWMu#U?hF4W4d@HEg8%_glrgq21p>yf z_@@^({p{U6!f?^^5OU*@a^pwJj}+yU`@K>!1;c6y3w7#|JgiwsR)S@lRYnk}P?oBo z$Pa%X6(4useVyB2-~Nd+efk?+^gk(<2K8nx3$qPdrq;h0EYNjWjEa?%vgnWh%xkUisCESfP(&&J%~eQe{ktXCMR>%7b)hxHRi z>0?3euuV)-*=?sUJx6~&Mf#NVZQbp^-Mm2?R&4g*`i(eh7TP$}>^Op(~QL7gi8K z&}lACMG1w*rO8rmGtITO+jPXB4EA{1g-dvXn14jR0wk=vMXqJEq8=9P$44Lg&`%l3 ze{%)K4})%&7KvZk`2pxXDlpCD^~RNUV4B!;J;bTInr^66Dc!eY7mvHYcVwFAC&(Ln zy%ol+yK>a>{&+r|ZW#2c+m6KvMMp=EJ^d?8%;S2q_xCdXKT`E$1FF9jjgcuNDwxWh zrnz=~>bMLS%&F9tYC{j^niQ<<pULvT zd`T_`85h>N?)H|%llPr7_O}kF&W^M*)BSDr`#X7ew-b+3*f7Zd$hyxa+vx-1W{h!C ztWABxs?pim`7-spv?slUx2NZO1*FC5g*SE#sa3tk>&o-a(aFilC~fB(`8x1_lm%uR zEyw8%MxH2vWIdc4OItAeNb5k$a+80bL&kx@i{~z++3qRrmaf>hG5NUX>W|Nsw@UDT zIp&y~z~jI9>(*cyo`3JLDLbolh6w!J_u{%_kb2PJA3zu_ToY*@VE_AQWB;~ z$ne=^9s56mYvKe@P@nSo98vAiS5G>0t!%rID4gwPc}N&FvhY6S++5z+7|1NlbQ`fv z=Sqg?r(IZezn@o~&YXnL4)nf1QQmxyRKT6XLHgleuy%ahS4w)oB@_vJi%ZN+iUNwr!xz`hWv{zj zJe&<_#4qJstNR1&7S192kM$?N=&hi$w7tz?#~qVN7Cywz#^0BeF9C!I`T=f&M#(HG z(f??xICVz#5YtU9IHKkF1LSI3jNtFSN;_Nk;di2=Q0YfdbWPeJpVNp({f zmUHNe@HbGPyM~HPIGumTQ|=i<-XcIRgb5*8%s;ZXlN2Bid7uAc0>KrXR{PAUHAoL2 z{fASokfHqipTs^P=~-E#ex9zvw6n9ays$Wsh|j%v9|#;sp;(bY6{pR(fdZaq)q`=w z{5zys9(KBoA_!o%I)e9%|JZym6u?u_inv2MWeP!4mMmBvkB7#`r6Gi{DH0{v<~9?F z8*m1FL(1mOQK7d{Hv^ zFG_%@9ZuT;@ePu|<^9ExtjFVoBw*|8j7r<~=w^SkT^qjU=I!}bpP2;l?FXTqtt}#C zOqoV`(x?&H(E0hf$Bqdv+wJ*kqmI|}e)k3;KSG};4YV-QBowY9aat&}1z6k&1U6I}E{d&z($WrgB9en}2w zzy$E1OTK79__4thW$?c6p{z7ew|MrEO?@yY-9E`a_f7Z{am7kGaPSMMl+JtMq-2Ew zZhmT#dzbnO27P*b=WmEYWCBBjTmuXZ1Wz|ZWADIOGfeA?pYeFY`q}ugh{FIivbnyr z{w4+Jg$Lr_&%*%vif<|^DtYY~qjE7Z{*fY}H;Ac~0I5sle~@RKo}MCvfXl`m`q{L( zTmkzePxUg^&RbcIPo95pl43NYt(tlCCi5bnY7M-oruQtK>-k==C z21T&c2{GGkg%={W=l9YFDLiI8c^kvM7(29KR?kD$^JTx)@c%^vDp26_S0It?{vt1- z68?rhpm~;1J(E&4LNF%6<($`lXrB$P?jU;u4j_afzJGfFs1LwPhoEWOVyweWvlc6~ zZawj4=X{K`T?tbj+Kz={Z*Zz=b|65KTvi82t7+Y*2U(?jAk;E_M2LpelR!?Z! zP?Irz&M?Ah9WYXA?S3zd)(U9PsZE`LK0;tF?gs;7+->zezgp3XkL&y|rPKPJ81KZm z9A-G9p`poS@vK`l-cD+9QTI5NtMm?BTwHVv;{aZjT2j-{IQh)PmdeVK=HhL!-5m%; zCe8G?8Rp->{|e;Qe*p>B?sz8O)4eZs3?UHk+L{370U?mJ?a<>pz>M!EKgR~61cU^D z`BVgq1Q0@8Ep`}95>LMQGeU$l2ZvTGrW^jLhf2nFEN0dM9fImEs zNh%5E-uotS-O{zPIGg@t2W^_#9q{sNFetuiy+;4y@kk=2b=&p#j$Xo~zQ30-Uyj7~ z1rZQ8&?{35?%nn2ZyBQuEcn2?l6Ng>z#e~I6l&54dJ16go$|sShydJ21O_nYUZBnN z`ucjALdD9(Yon*u&ezs(bXr_?yS=q$`+5y(o$l_2^Fcgs4_8-LBcuH-Rwzi!$bq%B zwN>lR$bq)D!HJ0pyw7XA%8H5x4Qi&RYsx&az=9TJo5lRIq6w0GO4e?|0lRFZvYF|7DB=A&Gi-wd#DB7~ zHh0<{H{73aX{e~m%F5EY-5cb{JkHH^eraoe8JI&F4cKAYu9#W*TV=K z6da7k6MgvAXcd}5v_lrB_nN4x?FtZ%Fw9V;_xow*{jbiSxGa{|)p-DLH*0AcXd z0yJ!hNRayKf8mx{SVHl}q+Pv!?i9->bi|)ZEG`5=MmFjJYaFXpcE0BQdoO1?8^Gk_ z_xZ^_y(`YnTh3_SkEW#o=VNmn0M5KUycT|m=Y5V>)$s(ph^BQkitVTdeXs57G|YLfNc=0ZH2SJ7ez$W9!cM zheS%%t9SlZ9Gygf4ci}1gihmGx8I|6$m{cqPOnA>y(f3v{Y*zFTsMX$slrp&C|>~j z2h={f{KF`dMdRxGbXq^iDBq4f|0{Ahusc##TJoiDh!6vtmy74LP6F*c*d@)(;glGl zHVcV{07$YhDkR@~QP8CHa~n|8}+mFAEn_e+CUfN7lo zRNB92ZDm!VPz>{|@#Q_TFkdhVqC+GXxX}_L2;%I_H8W%*y>b{v>uJq?GEpL5Q&YgC z15i7zTd^L9wQZXI@7j?{o4+^=lo${K~yW1LEo?v^db#x@0Koed2rDl3TG+qL6}rve4Y z!(wFg*|G{ur!v?kc^0Dt`4PHC{$4}_JkbjPV|M7eM5$B^pVaWf|4`UjyB@m>f5G)2 zKu-KBGn1WddR+~FKiL%tLWt7$DuNlJ&GHDZ{f;&QBut*xz& z3n?&C7MH8t)T1~6(020QGumQs-AxHTCdqTTyfkgCis?`Q9yH1Jg;_W}-e^1I4EyB_-|GXw~-~vek0l-1W{@H+{neB$!|UK+IVN)`?zU z*9!f;0!ShegkQ9TNZ|uALdHDk_&;UxmJ5k~UflGbjO(A7cuUyGiRvG=-$Mcf5P=FX zqAc>FKv@JZ`jW4V;d+o_oY#Jz(x3a{&nFQk{}%w4oTYVFojTXXkQ+71{b!%6j2#{C z_mg!#5-xlIl?2m&DjVRhT$iUrA+AX-AQX0-`VLJV9_evhKo$l!U_5|}*l3z%*vBqx zap)nN$qL~o*n$I?dF)rlXYA(=xcI86FQ5Tf(Ql7G&0-ZzlJ&VGtDty^2!to}KBa1q zY234g4iE06#mYP3cN=PUw#|2CWnmh`XVcv!#_CE0?d? z_?6o2P~uSMY^kA}%+GX| zsNKXw)bt-Y_KuE@CeB}z@dixh|CT=3M*{R&xBgKF!566qTN9qgrgCHe-M0hG>0dX2 zeK|H6S2ZRhi-T5Y=@#-SUHC_iKV%Gg@QbkvVTxMIuq`&W#O$1-7JaRf6cfOC@p(}G z1JIQKLa!kUn=xUkq4Iy?v_FWjTm|R!{`+Z{Vxq3%4MIO$D@TSBE^M)jkU%&AI!|_9 zezkV&(D8n54H&z7fPx%nYaCERuMPeOy=Mym^5?e`1Sq7JNv3g${29El;w*Sf28tFR z7&v0`jU80CYF=QUzjvNG``9CvU#5r+FhzhU!EB5E3CDaee)#)$ZtWk%nKRnK(S5Ih za0h{WcUc5#Fyxi#zU$Y$5_e@26fo0Z~HR-03Mt?!{cWqG;|1 zwK!t2x4n2-xU+>X^E3wp48Z>1RU}9~`1Rtk13q%v_yG@2b8|DKZ-^jZJuCR7HLkB= zmklAdUISJF<*@t5U!w5-9iD0OptP{eeE#(x0Oh^I{-?(Jcb(@e(nooh1+kKj7iY9w zLuE@Q{eRedtEjlLZ(le@NN|VX?hXkAO_1R3-nhGa;}$$vVF3aJry#f`xH}Y3xVyW4 zyVA-3cK12=;XC6#o-ufYqV`&ItvP=(=T>6-pxl4b9xQGS1qj7qkUkzj#-zK6E>lYE z_$4M>P z^a%oH5-^%%+3-Kd1%^&YLWQ8!qBYTYa5F8P4#W?1nN#j|fi!VpvNWOH7F9E46emhB zT8ISq_c4LtSpOHIFRqfi)H~li(<4r)6I@gR<=tHS9_NTNVo|b_191H@jhruJ7x=?= z_}~BUFYwme8~zQ~@D&1vL-~l=I{~2+VAT~1#sza7y}gN^0PQiy+GtUKktb0r+Ra{X zNpQpCNpEImH0MW72W)*D<^OZd{XFzPKUJLALF07K45Z44gWUGLx))uH?AZ;jKF`$N zQ}i%x`AqJt(5qc{;))F(jA^ZsNqA8=Sp1&<UW)}Hv}^6wFiKJO zIj)7-zlcLGyE8=taG>8L-#Cmz#C!GY1QY01 z{D|u(hVI4_c;3D>2jAj#KHSk&B6)ZUA+n?u?hrQ)*oFJlqK;C6Q)Wl+GqafTpW@}V zEt_P5+{E_*qf(9jkt=vFrN_Sf3YniDZ?w=VMUG!N6_qW1iu>LvTn$VDE!`11IKRLp z1B*Xe3%{F65p%<-`z#P! z-~$H5|`g%KC>tBv)DU>=(V`)X%;B+IB$;wv=XTI z>zGKJr?s_Ay%x>eQ7LZ~Gg)7c@o;VedbzZ{^?}rMSyO;S?vACv_zm};!3wa_oqcHh z1xrxcy+G!ze8Zf88$DrU_E+ehkkWQNN?o1Y%sC4LAYOofdTniQf3!VO6t(g>+w<@T zyv&$LKx2!nFz+iBy;gM3bCnEoae;~pRQPwL7FFTfN58P=wh`NfZuYMw_xnlShzmDb zfF=c(mHTf$uHX?2R}JU6r6T_D4!faC>XXkLj=j2;3#dZ}ssQ09ua|&8&mRNGuCKHA z`v>>?z@;q~MflcrU%N!Lk76ELeRsJM&BDS0aJz)XWU-$|%m850baxIl``+idySsaP z1R&4tZHuA_p#YMqo%8c*^?{6E4A^rR(~q;+3XrYuzN~wGHe2vI8HkKT-fYFy^Rjnv zz-T>f4MN;=AqdM-&BD4!e-?+%n+a5MW1Of6O2F5<`P6b<)NcXQ5MmL|ehhdtT!)m;^fOC$*W>g+j6tW+;x3@SOO&9aRP4(sF z54WZjrFFy8}5aLLM+SJ&^a62mm&`sqm&ZlLhs&dtXpzN>>5~a+;dRiMxsywrTc~}@I&l- zYY&dBKl%kT71-{3GH-i;8p{J9Oh>T9h(dGZ_>S6VXSH)i-Yo|O1+A^EW!|pRn59M3 zU36E~*L!S_7cAV(Er^y zTU#RuxQ3~d+~6*+cgh|X;RRzZH7^Y6JgpvP%I;>i#`0s=cBd;zj2K7)S$^NJe`Rg} zWUkTt17zxXum1*_bjJS`WG*+aGr|w7>ph(5CAoQD=8)WN-Yh%_RJUADl);J!<$Om+ z#{|hW!}OHDbIpusUI6EcFvN<4J~e&9hu-v7FaA~i;a>t}U2Wj7*IpH*e$J*p)~#ji z`r4y%y8RW5sf<-c{>7BDUNh_zb3F?C^w-Ttk+y_Zn!Z^3)}_2i z0KmK>E*$o~IJi$2`TYz?SNG_vz-5oSL!SwVoET`!2kEZ!=$O0!Os>Bol>&S+e_ac!oLTnkg8mbZKQr=bifKmd`J^e1jvTz-C#;-z5D4S|^u2n|r!EC1 ze!}PH8w~wj{A@S-4T}CMeF~K0Y83-RvBqBC;40z}T#d>oU=e*B`p8di1N41`I)+aT zUS;svqCE?7;)U%4(LR}zp5Q-L;(vrR*`CRt-TffB^_!}#;rM;L9|4qe_Y=R%gfg#= z3dW%mUH7#F+57-4D7pS2i_8^2_m`eOlpmXGY)FDBd{TE-E{>)S&GKm|mec zA>P4(f%jRH6!6{6iN-O9z-c;Raz?0>S)U+rl8= z@;lt{t27cPPC+LKC%o&vlw5!iz=G@}|NbRP7*2e*6gH6z&f2-wfy-16(Ky8=lK!)i zdt9&$v!{JjCTe9-9+U^1pOjpKY@mvIc9ivdg?>UpQH4(*a$=2NwJ)S_m|8&vrmmje zCH0B)Ra|3+N@N5HWvMe75QKcjvM2uf!Q3`z==l|-Se^bT(SNHs1-SaO! z{ePr;c9#2ePEbo^n`=G@{rPtJL(CrwK5Q6Ei;V%Ok}OC5;Xi@qt#WA^z{r#C>%p?? zu9lmGh#?MC0W0jDJe2H+{@f7itg~5ue@{+{^YZi8auVK?7enN@BG?XR(JU|~&gZ3} zx?s!6ATJ^!A|Mdh)IhJ!Li6#aN+&F)rsn46xVHZA@gXLVl9IZE__BKYygAZd>5L=* z#1OY*U^1e60Fd3D9le6NuDbsV+GP4KXfqcMhBlX|{(&~%-#Wmab*<_CdIyk~0Vf$C z?ts$MRaCGc)WmkhKPAtPf1WDpDXgC6cg-zX(LVbp;C$Nf8em!cFZ%)N@0aB16CE?Q zun|vUQ3HjS3(8Tza&FKulhlEbaa~B1-migR9J}5i-sDj2;C}>9M4#W7^I>M#po@u; z5NxVP7TWP5rpcH4k%LN+%IrFz^vt`hAb%-hsV8it^0w!o_|e zPOV|-zavgG{r@0Nbi>(g)7g>VptH6c&^lWh+>Vw3?RGGoSFLE`I04QI>T`S4m6VjE zrmBiEPlv&Y9|^F0H48ojk?w%cIz3(Renn7MN5{HK)9f(kQ*}*^KFS9$|EC++u7(c1 zSbYJwR?=XolW)!Q^SAkbp-%s;->5U2wDmmw**3!8QRj!BU-?*)3fhmKdxGy#gx>A8T8m~GL`N1ccp2RBANctp;5YmP7Dfg=^$_q+UfbSH+J=RY zLZQ%ZL`PQ1Jue`p4EkZ79daSg3wW+`J~(ZU+ze?k`si2re!G_`L_XacX}6I;WsJ;79`)Qf6ZJ zMP0j7fXh!#O||627jFardt>8meC91>I62z|ahTA9iiI znbV)6hEZ`|E;*~CQ9kDr#uGMKdXqf-!!foT1(aYIlvJSaqskql!PdeV z+RV1^Wr(jE;H&_m3lRIXYwg}Ia~=NzqTgNG(IF52mN_e)!q({HTi|?Zh^SM)pk}L4 z`r6~Ql*_kXX%4z8q>a8}D0AXIGO;r;@AH&Nzu25e`x`uh4heL`qj7erAlm&OgaO^~f_&ut&7L)qQLKL88#!ay13=!|n+3C)Vj zGZ*5+MhFUcihqPtUk;F(JQa`~Dv2jLw4btHY*7ZwSb(0-g`Moi%m2+dyRX(+;uCBR zR{RbFp;*D5eNy)@k(U&fP~0+T?A_t(;>ApYP5gNR?XWobMBkaP?J2ceFmJRNY%?qD{3wf-I7?>Y} z^uxr8yXANqIh1Pw7*^l{p2KG|D`cN3$Bp#Z{ykkR2Oyb|z6b+ylSKX) zx)SF}Rg(7tZitAUJaPQXkk7f-5El&dN9}8?t6$W|)OS(e0#xOW2|6gDQv$Fjd(kQj z`eNBlH#9V0419z6yh1%;Dn#h!s$V%~Yziv%=0X_fjnkL*+ywO|jgLfoaxYP~#djNP znsI^O1^aJrM8Bvygl*DtJdBk5Kd6)Z|AIPY{-2^wil-ApB(a_^=6+gSMNj}DGKSAA z-WqDKMZIt_#)<7I@|^}OfO(#rS0{(N-u7MxvKKx2v4)%zYw&YnVK)`IAnGj+Y-y#w z`rOkl;@mHy-oLX#y3vF!>vA(J>HiPp%`))k|3=;%2Q*liym{NF@OO2y-TPy8t(S1z zKGNRG9TK~*>%|N1Vh%EiBe}QXg>%&vnA)iM%=oz}FY7EMYdnw7(s#2oJt~-~%+Cis z>L;Y~38%*oX^0BCGd)lJ-p@maubRsE`#j9CL=)CH`x4b4It!53C5p`Sz>L5;pYPAD zD^y~QfI)FFELRc8tE0+*)J{ZL`{L})>(_9P;hA2Lg$_M2m2g9q!vk-D&cZCt#y6;% zX-6)aFPgkw>1!mCJqC+4mN>T0^l|6^atm|)b_>JF0D-ONu|>5hYSiMig&|AOb=2F7 zFo-l#S6|Qbbs4B7F2_G#yR#w{r9E6{`UqU65|JyzOkwQ;oa2y+e$a)h=D9}o#WA9T z^$$Icgtr(RRl6b~nJ@73c&H>gNEMV+Dkic~^vH?|owBi{x6ET+?KG3YjRwY}+@A+a zQHMuGcL$nEt8=d^$7+bLN-M-Qz3a7VrkZ!4oHuN95O;{H=x2QI(~9&m0cm4dA!+K7 zEb&m7?b7WoI+7>am@o3~Ny5SXR4~Z^>fGyrAL%!v3;8gZj_3H*hZrd{$blICYZ?$P zq2A@_-r43XYg*Iy$?vY9jK;nNC8v9^2L2!8#N9g~JI0zK@ z9=V7%+q6?}U{a852Fu-g@6JyCz_WQ9jrwc#&xdALB5xaos+?P5*4vXk2{wjqBdmctZU-A^`|c~O8)R|QvH#6slDj2 zLc3pYC1F%+_hr=D(VFQt{t8Tn3z$NyV0w^ON;{>E4&=$E{zL5l@6c2uXl z)ai1!6C0gJ7)qDjfG*sh1AYTpAAqW9V}ZGdx~+(XG}vZ*_{4 zH|3#A=YVB!p@toEw$bhoZ~+M>D+!Wt8Yw$HenmL@qJU+ryXIgHJF4w%RS z^lR7n1mpps>OI=cW@hHl`~`1lK#BKr#r%}4FR!KO4zYa~pLxm1F<^rAsSyU_9Rw-5 z9Ks?W$&-ChUrmxGX*klUtmHV1ZQgL@A-Wvyeu+hQ()fqIIh6#a&RF}lSmbq}IetUQ zd1Qz2Dm`|Zzj2=Q16YhAUDnmnlYl_>M@kyV%C+A1;dYKTJQl3Y_=lk9BNhqn)EA9d z&;0Pd_@O?A8nEk>L3T2?>Gqs2#T)fD7ZX-iGdAA;iGu*wR{@Yr&%+qPygt&tX=N1w zhAMpd(Mg6w1)TJJ1lZ%LukjV%5aIj^zi+&3=dWBn_A3Qeo0@%&9wp~?vx|p;;$^Xn zl#;MTC5_&Ki{DL9iYB_{KdxvGU)n~NND;?UinD*$69=~35Z2AL($(s3n=BW9a~Lau z(cra6m{!^*(x3+|gnIcqsk|{jH#&En%_&jYmp`&$aoc zcxX4t{b9&(toW=Mr<1_B9A!XV7qKT2PV8k5O(x&z69B1Pe)@Ug)ueU7)5Dk(0}?)z zh4crFoD8+)lwclRh&seOF`P|@JGor~@0kMOQnGO&{_OMUl~#j#GtFMU?)1%OMxLU= ze95gr;b->#PP;Q#K4_ocEm15XPJfjY9l5-eV9Umc8e^A1j|{^l>Ld4GH1bMLa|_L& zE}&KEZni0d=lU3LJrUUGpJ%B@VF zU`NZ#8q;P^7}~8_@|-ICWD#jNw!^?aa}%pgMs#TO?|b;S5M4BUQfIS>>@_L%r-hfL zrQy+J$@-vd8T2e*xT4=7mz{r(n}UV^g53cD5lg_BY42`8dK(ig(waI|4P1=mke`JL`F zy_d!d;^VO3WBX<$zVyB%S$*5%h6hJ;lPlD5aN7`=X21dLiJp>;}r!$7=Gtd+tSrMVzXV^d;8-y^flu zFtVV2=L(RKNg}PaCg@Y;^AF)q4kzKDaR*kFC}|T_&I_hsI}x-zlYEM!EGIXuG6)%R z04ZRrH8H$0LT5~B3fIqOMb?Y@x0B|09OaKj~N@0~&vTvi1k-HwR*lU%B4w z>oikeeN*%C!{tG9RfSuFGQ9oMdiHfgdsA)6aC*B`fw$Sg-2E*d+_q!uS? zydzTS$l{iGQ{&1f*nN(pxLsHJjmwZZI{)iVeexN%ln62gK<-R1DCY3VJHWEs+kIW18bMj=sFMo_?aGFk;$9rp# zu9byE!EM`&lik@R8M@?7f6?B0w%>pRbj!T@t2HzK;4$C7nq|VH31GFM4$Ww#utz4e3?ZUtBC#iuHst7{@Sgop{v{id^Iyy?)LykIv zCT%;T+$KIXi|W=_YeHnm20^Chp-73UNgr6!Vf8$lHQbve%Eq)IwW64=o~~%UPK?-V zrOQ^;0yF;111s27)l$Fh-knzur|ry`F21WgoyC8dvWKXPE)X9vG_9TX-4UM7^4;4! z^AGk&sF5}32s}tRq3+rONGva}e0WDXD$iwWA}~S0%%c$<4oGdZNs`NC5v+lce4Q1^ zl1XAF`>2 zj5Ue6WlyG;trcPDaA(i<8$gkEPs@^sthT|M|LG)Y1Hf*Y%NhJ;p+LG z`JSY_*_lLC>sRor?ttFpTh z_`c@RCuZRyM!5-$p4^fmrC_c_OtN3385ibhBmzTqvty<=U*Z_!1|gEnTGYhCg#jcd ztYyl;L?>tDPuH$2fW=zg*GPM;>*ejOb9vysT1QIwSJ6S#Rp)i(Ai#`8^Zpz#LNw-V zr7qmAKavFam*se2SmCbv7In=e5giadB0iQMLATFAaG9Ay$rI3#0cP*RmVy=AC*u3_k zR<57F0k3?84|*?!LRgZ4ZOjQID4P51Z`xG4?=@-BrFwPUQ?7ece6p_D(5(x*)5ult7G{oUCXyKg z%J*45Sd$n1NetiB1o7@U&caj=31Koc|CIMnV_kimwn_@-9`I?wcTaO%pvy z@w4OXZpffrUJ)EA%>7pPqGRp{;8v}TkSq8OEAF5Ds(!mYZyA3Fuc77HmkJeDIWEZ! z;*@x&iM^^NEcugsiB=jL(JYcq^b=Bv-ZU|M2@rp#nF`o%(^2u#}vP z9TTsNWV30Gp)A^01n&}&ZcN|@fN@4kszge1ZsyW*lQeO7R3ls9px8Gx)!xyO$#(o) z`dRkztlFRWhyAAlg!|>IZd(yq zRw1N$-ntDg0~g+xR#|Wt9TuHhyT1E%8`oW4;o9QQ?d|qw-=d#PSMS|#yzV~RtsGi* zMj}~;;mzM+dz2XRZCcd1HMg~bHjiByN=l6i&4=~P;srF7iOay+#~h5Ai`Rf5DU-4TtS5R_EW(>syZL^6xIbtMLd} zN2vVo5Or>8^Zym1!92XO*{U?o0j#pa-EwX*^CFDR;c6NRoH|_6eXNXDMpFTk4U{)N zQ~Td=YU+I-PJ%L-ih!hQdJs7^H)XHHJ(Y5oL+HBko$-F73ftw$_y0IF z)1GZ$mANvL_Gv>VI7?buLIsb)uFfc1Jz(vEt#A}-50^jvZ%<&@xxCkX_BVD0ix(@Z z4p+G*Rx`x0YtubEvm5J^s(8=r zsuRsyW$^1!=7J5_WH7IbAv;^V4c%*SOHn&u2`5ppShDe3lggmG2}SVc6q+kyU(rj? z8HfCu5Q$o8cBH$_eojd!dn8~Y+-tx9Q*#J30tWTj2*jh1n%#ny1HD?iEZ=)m0T-;y zi_uXGBdSstA0OTJ2n_S%n2}|s4k!)au=9fzg2fKRy#pxdzX~JGU{%jVmw>~WW0!`B zJC+Qd0=ksK?mXk2ypH;#fhVAA@PUigo-9`=2Axa-X{aktdQsm_UiR&Q&xxMg>nQEU z`tpXmN?)ISFpU7$MgN$oGV!`7-`-q2qakFiFEi6L*aqkYxSUfhN}#q+n{|&u(L-#B zK&Iue5>cR>H_`obk5MI_yXTXh(-vh^hd;%almmGCAYI@{~3_Nbb9t zRgXG!s|{~K{FebkYI7gcA+}Tf95ZKb=}t`QO?~ink|nJ0)BDB7!TaP02mcD%=QN8q zBdWt^$OC7$eFxTjJ_hVk9Q-mWDkCyts#TFC>8TM#MFiF?k|Woy%5|TMz?6bs$EQkX z)2a=gmgc!*=fpg07vIBjH1Iaqu71VlTMn@G3Ej;^Zt7rC}4eZ&9#+MRD>4 zAJXsoPa>{UqL@w+ts^n3xuNkjuR?NW>1Liec9DMJ?d=BSVd*%ML{DdCc8&=&8Mbx3 z^# zOug~Eu9g@&rM#7S;aABK@RDmphriu7c@wK~?K(~ll`g1j>D(#b0;>}aoSK4UP^(jV zM~4Q0GV1FBFfDi-OJV{P+FSQR9U`aM>v#`0;xSbUy3gO?X1sOmoJWjD?K zlJ>#?_ZU5u(IqNP%+SR2=Fet)^Z=SYCF03Dh&9SHp;+sf%>ZB4HhL<{)?GL zTTYmB-1{eg^f&Hdm?u5MFtwCGGjBg9J=1usik$v|w5R#zLhu?&a@#)|xp1E}r7D0fOA>W5rCaT$xVWXK z?A}Vq#<%aBEsD_48w*1&$$N?qj2%rcI!maCDPIw*F(-wKndDKv@ldLE`$CA5CK2Z? zgL#x91qU4-rO#*krr}X9zl~~&ZDYSQvTnXHAA_n%AM4$~^xgp>k^P%Pk>9#Xe zH_S0(gvt+*7ndfd=G&2xF7t)K+`hNX`(~j-Q=30~%u#-o4!bwRoWF>(sag7?VyAff#RoVSziLb}ao&k=4n~`Lh76`wn0GiC}&`)Qx zSGy;l2$IRI$&wy7E@Cv6w6&~cs3>g>53)U}bI5)pghP{8ZL_p}63LMGP_JwmBj>RFR z%V8us-)y@Yi4hXw#ps6}I`C)nm^k?LS7T|&XmhmA+AMbgEUZWej zm^Cz5i3KO(?oL)b4Su)hr+_=l^0V^S8eDn$tBBa!V#&B!N)`O3kkthypn>k`4n>Zt zA9=0K;x=2Uda!kS~rA}y~Yjs_CQ8XC{ z8d5A&WTsgg)8{Cou=er3oXTD%+6#Y7ig!arnzfAkqCm({k^SSqp(F1kS=t;F+Ul2V zNc7q>hxx#1#3(M*rKkWzzwkB}&zy$GQDl*jjXioT?!akx(Q417LC}N4H?b^S!986z z|3Ojot7+H}{=iR3_{N~Nv^LqRAYZizyVqR#FsdUww}!-qV^4QqRgK@8K)Fxhu3nKZs;_D|GdleT+N~o zi!Nt#-XZXsUgcg!U6doq3?Z3(-K1OAc2#O?RbA_x5@IaWvmtldq28da6s|VLdDG?f z+a7IKuCIaPc}UU~wE`GRwYfKb>{9^j{Sc$FAZoCF!b$nQtNJf4e3;nh^yJ}u;Wp_Z z^I_?sYU&tSM_5N-M?6xp7e~LRUR26uoj8WaQX>xJ0@f_q&Lg^T@gGRAGtulB-AhLhil6{nGNNy$?BloWc5`-v=``!Zrtv=Ry6$K|}l(+6BtJ9aMqqmSs(odoG4i z?U~nQWo2BcGHFZGrkU7b_FsV}AH3j$=9_)i-elkc*Znt@JhLyyk}<1(D|pvgrmL%Q z1LS3MjQfb8p$t&!%$|on8bRS~1i7_K^BPc5#IsWs_^X-|Pq*7YV z9}e{r#r$3do#0a_Z^OVqLZOd=t96N!l|cN|6zgTckgWP=zY!bPMb*9zp&=4W2}3~v%D6u9?~7(#SE!^{>K|4n4r=v^P_J#-Z1KTKnuoQ1LQf7Wp`Em-SF zDVCn3!O}pvo7(qiUKnU>msQf}yOp1}fzx48*VerGv6jjOskXqJ@Si*5aPFB)FT|0W zkeFllOwSuG;ls8q4Y3o4cRnC6I zcZKi1_aqmBw6ei_jphxt(LobcGXJQz^E5RzKC3p@I5~0bPGE!dg^weua}%!WY8d)~ zrk?Q)U=jrDug0dpIyzew`VX-lr*wRiL$A@$=9nkXRS$WEf!T@<9ggD0uI{Lig9m6c zH355AKCeXmuSyDM4;>bfqfLFq*j`%cwA5HakyI)wN$MN<`s`GRT6kjKacxOB6$71KF_lCmZJ(ls#dvR5{!WSd z^~2q&2gEraVK8Sb5;HQMW3WH2=Kea`Cnk7gT)J)RY?*P)S$ORAx+5_+$LT$94rMQ(v&YRBRol;Pp*yaQ4$wvNRRYGbWNn@9DbQH_=a}$pb}pmqa^_^ z8;@E!b)|X?alR;c4D#h_W$ZT6`>t)TV>x?O*)>q(OngD0mv_ zN|T1Rq#}K=HDxnG>5En?4aQN2A7F;uY)YIyg#??Lnr{vSLh|#TpP6rM1b=rdxar^V z9&DF)oUIy)-6;77@L=#}i3ys!16`j;2>(Ww5(?U0ZnD$UZw)tVQs>T!q~y}my!T9N zqTX15@?@~2yX2`zu4jE69#L{B#!%DUI{gf@q4az@5u;GzAoCn>{A;ePVqi1 za7=i$(ePkr?`(NP2SxeJpUpj&iu6V`w8L}>KZkp8O0#O#l|CF#HpF*H*Ig)YVo_;Y z@!M?reuo-{+)!mB6h4*qLt<2r<#mTMZ8kp8EwOYB1fVt%D% zWeczUtf6-f9CEW3Rr~Dqa*1kcYOq05a>}~E4HfWHMEECm1kp>mh^i641>IdXahOJF zVFrb9H#!-vbuO=`j8#JCNGr}5qp;o>F-U#kj6b4hvZ-2Vt{b&0&eYcE#WKuRr?ttY z`DU=P+GaUm0#<%451X=tt{sE=zcjQw>`O+lYJeb6nZU+}owQt5&~5 z!3_cxmUmdMU2F-Sho-|R#mERB?7>-ASZguPt={ z*mWYS8$Uk5T7mL`SzbTI>@QFv{9iTsuzwAvA$1hS7MRX_$K_^w$oOpq|D@l;$%T#Y z{f|0E2^EPg51%xVlx!T%*F6=vk#iP5yq5hml+=4sj9aIVm3}R*kXAk%VlVm2J^0qnl(&)xrwBK7nxNtkcVutHe zFVDP7m_i@YB%a7FC`t8giismZg)U*6s%t#q-LdOR`JN~fi(=*F(pF({FGLlBV^cO^ z5`_~1M>l{ZbK==VcE0g256LiYq6*LM?YCtrD{W{lv((Jh4h-2j*A`qHDtV1;yM!*h zKV(4M@O-~qllkb%{NO3Qg@pxz5CRCvU%Geddv)N&w?Oohq_eQ?+5T_kmfJiix2vWH z>n=>we*!ejobAONe}ln&s^P2h2nXoYtbm!?1n0Wz#jZ#5!{7u#s}10g0zbaGY&!5} zxfrnW(_ZNM)i$(}7OW3ULwXZE|FIpQvb7ejaX5|t8mIUfH}(#gsKm|m?8i@o6h9c~ z#H=MDe*f{6a9LSr`+lF^l^TZa6sHzbB8`EsgsPj-KKi)-*h$B=G}((4uKC7ko0}$+ zi|Yv}#(_enLLZ}dH$Gow1n-G$OFn)lCQGAyM#_7tx~ir~PN{+Q;K>eAX0Futgo5&^ z*9q4z$AOUqSH3d_dtZM*hT5)mk&Dsi|qb@4dV@gVdHPTAzCx zn=86sg53<(M^Wd!)*T%!eq8N9=4F?SEV3W9#7k5hz?G7mHFm%G78%u2KKJ&uj)1Bw zyF?_1=m?Ww?7U80)3m)SPt)Fhpy%onCc z=0OC<^gJk9 z^poSSLm#Wq;aqWqa!O6NA!(>i8Td0Mkvwzj3;8j3G(UB~ooJ3{^@P#|TxSDz<0Cow z;ZT@ep7Bg$64_AQr9+3~u3gQr6PW+#Y8_MLns*5P`^=JI_*!&A{{~l`q#Xne*vOJ) zOm>^I3A-JM#~@Bb28MLqA=ZJgE%UVVW6v61E}bbWYfptwI7~aYTVvvN&O3<>4XIzZ ztF2eEn;4VQHdW?nKm(3xWjL4RM)tdT!^cO}K5fudi$cF2*rY38!Z*TJFbE#q#Mn z&MLAh@>f$nZSx@hSQhKq%Yz zSq|{R2e9?c9~-Et`870{OnuvOq}1*}XMh1X)Y?P{VxRG8s0GdO3gGN&TJHAttZCV9 zcBhy4+Q~v;of1W4lkvy8n6E-gnHgs_bxLHU`BaLsN^kOuA_VKNGO`L#W#zQ$by<>H z9M+LA9<1EmD<=?;a?CZpB8+_eVEncBSR{X}V=yw(b>4>nH~Kk_C1^);ZR%5Tk-}zk zLo-U5`Al^?O+RY0kIg<~l-gU=F#DT3l%k(TMpV&=Y&S#0lBQ;C_okdKf|B&fNCqwd zLCH1VuVmf=9sJ{OzBxws2ivu&=QWYk-*OVJ1TjqG(zNJ4$N#NOeJ8=^%W*{YPYnU^wtb*i- zB~07l_U28tA`*f!)~n?(!O3~4+{5xNX$9~Pn+nPggy$Evv#(CxAT<~~Em&F)3Mf;i zAB68uz5Gm;la1KDNXu7IdVK$x*WerFH(b7^-Yazyg!gE!#=xTLPe)$5XMbYC7_6sN zQE4v~W)NS-{Nk)Kf&~}pfQ?(n6--PcS{+CrUYqM?i_91H5EjmsuqL8S^kCTZ1@LmP z?reY=H-2!~wB)og{Ty3|`5D}+6WjW^p`l5UzE7~;$#Uy_W_*0r$a~%P;fQAFp?9O& z`E0gLEP4`=fuN+M8tQTvsfzW1tx*_H%!hC~m`bXEx z5Nz4lR9v9@E$1-@XcW;>Lrj_7oNW*^lzw@WWoa?^8JOTOLjG8D8}Pn}>udHi$!si zE?1A>7bfy=p#BhJiR&8i=NTDTw7m%62{z^S`5rm?YMK7&%a$C9+q;Hh+0sK9` z2^=pKUTBhy=#Lsn5Uyhn`RAnGnl>`>q{PISN8}DZKJ(nH9kQqF{CB`Bv}4g?1#g#7 zvx;JBN6a?8b~DAFJHiGdwL*5?f$lTZGhxb5HvON`th2JTfCy4$lSyHcQU%L!Sk!Pe z=(v?`31yiI@M5pFu-)yN389q&b2J8uX5GDJA#3~Evry%)ummm z+zW6+lrlvV1(1dLL%xU8k!z!#_bWa{L_Z>E6-{=+bLk}VdQ*y7AF{C1Mvc5Z3RMyP z-^nN~xLOO_IzR1WAL(}WwhdirxF!8l%)iWE&LD@tzRrs<2k#Od-sHXS;a71!5DQ>l z95M2$1-T`sQx|N~``vDzd)S3=OXQgrf>`|8vR|C^SQb#yac=-|+~kJ(-_M7d=Ndhb z#Uq9%uK?zIgaKmFQzs*^`Ya7khn><$<>{8M!!tIYk6PZZ85`hILQn=Oa1P>U=Vtt! zxsWV_p3E-9I=JVle{$n=*mbgQ=!;juuW~nUPBMYG)@#IVgM!0Rne7@N!dje8bIgTf zoGLPv#pY4^{SXVY$?9zJt}_ONeI@OI#hs0#U$@8mBo-G>pPNW37v3+w{Tz>6pM zjaE&i0uSS^Zj=LymxA~Cs5j6pIek`y!3;+(&Ht|)n_kHz6z@O60d+2NA9H5^;FIyM ze1E<|T%|Vn*yHKfbGe}VWZ7N|>W)4%w`}CVwgbjqIW@=^~as7Wjy) zwxUQOtH|=g9#E&aGfd3!L=SXZ9%sVkc9_&qnHQ*wl=g&K7#8k(_%zI!#4lJCX&Pff zYt3SpUL#ghElisb(G^+lG!N}7JQKEX;c2U2_#e1DZ~r`s!HNzc6~OK+X~s{S^F3i9 z7Pg+6IpMmjG6z03g|_>^AqsACp=X>#Q8bUE5S+YB>24zczw#K4 z%4T?J>v%?op_S+ixda-*y)^&2U-M<9B`U_N12h#SbCqLf1~QgEOh*oo4ycRRE4y06 zaVJupSVmmNTx#v`s;S!GTJQ9X<&Vr1zm?5Vt{)@ng`ZF>QqdmmJ$J#PVf+6$d&{^e z+qG}hLX_^3l8&KMQlzB2yQPL68l+`Fkd_vZ?v5d(8w4bWkd`j#+821Qd);fj&-3oz z-k#h8~i6c`?@wNsWmu4KW53q zutt!pP}Bu-dloRaU$$jc3HaJttbU zBrFCb|~3ii(9GfKgB zq^aO{NoyWWj`csbT>3i?!G&53IQ(-%CCa-cXS6w^iO=66byg9po;T^UL}Z4`ElVHR z!QcV?bTbINK|$l=f#QfnGZ&0LKab8hqt-9?U0RF9wW8$OdAa$s@{y{<2gp4CjgPgr zhr?hEIdy644L$?G_1O*s;EaFZV;BD5V};7uw9-oyel@5ke^xYIofvh@og;+K&0pG) z(Eu{1H=5y(2E94B5C77{-w&dBE&Z1QVecSzM{a-JxJG*gpu1Fi`%rCqyL>s9?3$RH z8zL~Npryf{Ov=2VYhW-pE0)y_^AX%RhH`Lx9QGx}O>Z@sREY040O<75W@^NUs7h4= z1~5kiIcL?J#4U>3D^rIOp^%*QVY?kMshWy0ujJZZ8Ge3+=G$db&1-?8z45ZXbCru% zJ~mxDr~F0t{B zl5tusqgNsxWBZ39(8wEWO>`{Vgq{|D&LQk{=t!9FG?RSEoaQbhM9lmLqRX-OH$+$5 z8l@fM=;`$4W6=sm6eG$=KbD-))u=?L16tDcy{+5cNGRe7AsJ)?xRmUmxTglPp1=35y{zpp`)HdJhTTR9baD&9L ze{iXlqcmyScRTGw=mBe z3n_?mEZ6*XEHK6y!`WQj*jVN6Y3aG8LFRdej6Rs}wUYvh83U=|)&S5y0E8>!*w?lq zCK}c~Z{tc%`4`MsX6_HncDgxa@2W>L?n;n-Nt+b(9ao3>dOUuVzQ)%#UU~ zYn8d5Gp{Z_TSTDzPy-%ra>Tx@lrCol!Q6YyMrs3wzi5Km22FHUKV-3^_r@fQwu0U7 z{3Iy5|M*F$HnWSSHH}+&D+U7mtX;qR+ErsYj#NOsO(z)3pqPnlZHP!p%71bdwAE9w za|z$t;^ot$QPv{9cdnvkJ^0D1>q`nvxNN$% z>G2qTwqgQs*}h=2T1B_?EwvNJW68nZtm6;0pf6Eo$C0hrqEemQXp1XubNH@^@Q7uC z_80jg7+Kx-@mZKeV?#&rS`b}+S3HW~Q!q(GpSn+^s!N5Y7>R2)^WLoNxmsBHD*X)( zf-loTf=3fMv}4IlIr=ST*!4W}75TW}JpFJ^YX4!`rbUaBXHlOP(cKh)FGcxIheQaW z%H*TOXH)&3A%1o0j<@`&#>AUrR6f=_J#iAh zhsdGg0@1!4@_sHCEXdn|qSg;&mOI?^Df2&Z)0L;)|2uFROuga(C?y<7tNebxG-iC? z`KNlVU~Xd-gKZis%gZZZVL5A2+NiW%hQ>>7)zE_dph^oR#Cc7F+spK8&?-kf%;>{} zWoT_NH??J)`{3EkYJWwELY%aL$Ipi~qh~`AwPl~)&A^hA+2&y-Lx_dG@{<<9s=~MX zm%eQ3t5=q{%)$(JgBJZEpU$;)D2Z~2wxo7A z)N4j8XMEfR#<9|ss?y6Kb8Hf8T<(XX=xrtaPj9Mc>Xu46(yfkqZA6C6mM4H+)Kxl2 zCTHm4sm*`kwe8)>!uEY_aLhU$q4h=!2y(r`fvNT62pVE)vyve*Ttqk`B)Z-h(r%x0 zTMaq&dXp$#&K&Uu>P9SkNt5A-V3=qCty76r638zn)U4f~clSW6FH=QTMGbDqla7&-(L?JM=d{ z%9jV%AlZDF)yYx>Om;iXwO;*fT5crWRox+pM_N0vhvWA%^&aBJ& zM@#9?is1Y9q4pM}(8b+WZV7d0`M4p*OcHL(396>E0^1cfsF%D8)o0y48z_H1QB6#* zMUhodq{h&rJi-}(NasZTT&;jcN(1n(9ke!@sa zokYwpBD+CIW=}P!>Mf7paM-f%&3Dn3^XiH!l#V?Y;i6?y*n*(CkE9J{Pc#{C1DBf%{ zX%|7imBCcYiokq$=U2m`CiPh)xncidVo~)%2~M9q>v5=Mb@px*B-kb9>J`NNmqfW{ z;H`DFwk1|~Z|eGVo%zR*XZ~;6Byhx+Y}XK`hLpMd@)UhWs-t=FkTGM;g`nXqC&}#r zqo(^_nFeN>5dIQa%agzG?%lE{)*=phbKr&SUuQ^sK;f69Jn7Oi=&g5pZvk}BO9%|G z-$C4ex}u`K#CtAZ?lKpQ+WbL}rk{R~N5TU@?X$=(i!Cup3V*1elgP@~Wwa*R!i#hF zMk>wQ1Q@DH1V=Z@;>$dWAt7=qGD_Nch9fsWR9xR4S9*PAS6}rit9#lGge@9O;7%mM zQ^FboE0&);YLYHjWx(+sPAyW%2yL!v;1ryGAMtFNm$RKQjEA=Gcy+MaDt{YMKS?6{ zjn*PX$7!RLd)sjXpQqvW6y)VIEtQsWYZ6=HaU3QYlWykOgZcJv$FrPLC~|YQHKU-N zdN4s?9Sdo^dY4-A(`1!z@o{QuW2{JCZ?f>8IQHn~B1N?Zx6wCzAOQ9H^i))edXumi zyJ*>5+N6DfRszr8Us!rajK8q-niyG}gF!!=JFWr8LCvo9f$LzeBZ;6Juycn$L67o12_H zi%0Tq;TAV8+1iJkt}gAPoU2zcM?snOG+52ycUt;-WY8(o!(s6 zwhR*06j0qB8N>xE2}kO@x^?wETk!HXSZuo6%VglN-%VDPzH9HO!`5wgcbSVzlY`w4 ze>D!7KkefflY}G>T4hu8TH(;z)>f9o;<8`fKp|}MOX0lybGBHt%+>I)ik+V{gT~d)ktuG59%3tB9*XBT#QOKzM=e z0dI`6Ci}7z>AAuCsn)>N;z3Cj&r*w3&S2F8c8l@g(o*p5&%mT1U1C#0gTD14P~B%H z4cOxrzE?_fT5w{h-rtb^8sG8(k=(I6SE7GfHch(RDVc+7qwdxNh{kl^QcczY^qgJN znuw7!06+QjNE9-d;qgk0fl{>M`)l-EkSeC}Y?FB9+BxN@@~4mWn3AfH9Q$VYOV;;l zW`d&4rjk^C$i;9)?)zq&YA~u}WMpJ_N;*i<2oai0^kFD zFD-o8gYPF;r~I*R?k8ACNoM%bvi`_ZmfQ)7n;c#@T-v1QrQlY+C{RZSr^=$|kt@Z|YaVeXKS zm=G{l3E#6vHnGy#fM~(T&n$D{w&kOax1W@3L`B{>K)(!LO2lA2ImqV#R@`OV;8Twx z_3dM;CQ|w2z&ZWdli0UOmOV%XQOI(jd}tI$`{9{+kPP zTG?o^z6l=ST`6lA)1R9bxf~mD!H!UfXJKK&m34Bl?q5vEjg?Mq>L<0oZ(1jjUpxRx zsXL7(p~`n9lgHOzR2ej+R~^f%8tNh52WwFqlsR2^hfU2DMH@q=wwcS2X+tJ@xe6-i zRkTXHDIUJ$_%xl!-1o=BOjF|G)l+%QS`JM$CJC8?<8g!IA@Tw!t{DZrAqGQ>--3&! z9FwR>@rkkHDl)9S%8e%wE9xsfmnX1}yb9V#HDmwq6rjpAZXHB;RQEguhwXpx6x=ES zo>BpgZ8&uqPBhDxVcHuC3AQKKsC{ za3>A-ie;Fe$X{X)yW=G*>f3{3RgZm#-ZcwBOq2ia!2%EQM3oN|;K7lTYyso+{|VIA#=vEKtDS=cc# zd8)TZ3O@eo8uf77FGy-Qwh;BIBSeF{hkoI$>EeaCB|1VWvFmYl7486m^#-7dObBzT|3qEyzNt? z4^J{au*PNsBi3D_`3pd?P|Dy5$%htg0H;@OANv25A@L`{X+p$vc^Il=c}(1<`_H9~ zru~8)`zGy%T@SY%=bf4-gOWm3@&pc3Iu@X8E16AcuAk7FeYm?S0BpwHgyrusATWl{ zUB>B)w*=eT;Xua=wDxsfo2rlI`#fnQ)4Wb6#ygL7y3G~Tpf2Lkb7j^<<^&h3Gpe~w zDj@Z&?<}|sJ{UQP6pYc!v5j94>{=H{=Smdx-FkNC5q5ifKxs%R0Gh7v|*8o178{@9Ur| zdLPp#Y&CzT)8gH&^d2Gr!{>)=V#JPzZbUR|+)NRS9mb|BoUkyT+X|fQQ>~i2*;V%&C(=HEDR)u0op$tP`xI53G{RZ$A$Ml7qkAVfA96afAAe(QlTg9Ecs{ zqr!qz_`Z9K0d9?eS|0HFUNmv*C`!b;e!mf83X!NXE!a20x?G3JE*4`^J$MWk6V>lioznauE-K#`v zt~-v%K={8nBD=sk8`cE@92$uJmQ*x%xBK5T6&0=lG56#_nxTDwVh!zZAU^H(`pb3v z3{eJyvgf{Y;13FhQe|+1_Jda;wJ(ZGzFlyqb1!T|;A!}kb>>BI>{8}E&r|-?Z!RW! z2Gt6LpPgHHi`C#;iS^qpuP6v{Cdz{rnssTpO^y$Ybs)O8k?CP_FPOH_MS`jWzY0o6o)7Xmc!>k zQ`r$OTJyK7AZzCGxq#TtJ}L>XmiS0Ct0h-5HSFE5_#6VGZ9E%9Nv=Vn3Aq|LNnNdD zxgtH@Uf|bNwvU>;gi=;64TI`B#(oyW-4(=_LoPJ3Z#sJD%->STgmJ4+}dOLQ9I(fbYnTal>t^gh|G(gq!!EYX|`b06MnGN05m=#*$T;rq~wR}8tdqSDPcTT0r-rtUohCas~hz7h6%aaYO}D#tOvw&}T1^5eYv;AdpT>)f8Pku@<)5+b$}a=Vr3@ z@ji7xh@|R+U{eT zk%qIdu@-x9HN4hcEGThjP@;M4+gf_q)X-_}-mQsRVP;-qHuI(==3&};9By-(R{UIO zAq#*f0wxMKu|5%G$qtt!0NC}eJ3|)-GR>H?c>LA3k4t%TJ71*=UQ5w=*c#W21E97F zvsbX49pmzb@=88Ihabqg-OLU8a8}Mq+e!1B7^+=&FoE0D!iKGgvNJ4oBfp`Gvbti5 zDd|Ehsig^DQ=$Poqt=e!)1acs88LO5#Q|IaB2(24sJaBiTrIrxRsl&S(MNBtngCg9 zV`B@z{57H9e)K=pK);r34GZ52RAqGp2*3PKIZ&VdY|JMP!{Kgs7#8C`9wMF>&FI2v zEO=x+6;>JhfLJhZmGf%fPBM?0Ub@?FrMa2_s*QcKUJWWs4JBDML4DBDFE3(vTJA=} zV7xDSgHlyH?Jz!9@e;4!7BdSILNnPULj(6?#;w8KE#W4<*o*US6ZIi7FU!Z~9lrOv zu@-oP?6zu3xKeTzs%poagPEK*F2G(DH$_UXmTzwDfHGGDyuc8@1uL%hFq`?oB>bz4 zw!0v^$Evcju#e$IJPV`IFGN4&P5^h=jq8Rjr{a#1@Ku#)=E|#^`{i>eLawr3pmgMb ztVW->8|)M>fttH70#%{stEri{s0v{0#mg@kdM%B3sYJuT-j=wI zU23O^iQT}GLb319Z9*LZ-wUITHB|%9-Vd29biQl;qG{{Lr8`uk4?gq*wz%C6fTP^| zt%l1V@4pvug46#64$%8pD_maNuJMdfE1p7%V|=qTMaXvZLSb@pkaOJZ{C5#){-Nh-wi^KbAK;e21IZhOJ611~(CVp}JR2b7jt9z%))3$OhHB}IG@cV96 zShm#g9(_g4*v#itq4Jt>Mm*_MaG`Ed23u(|=owiua(v*ba`Ciw0tz*f=oo0XX40kR zOBh$jjn{|gb-rWl8PK2UR&f=!n`vaTn!0OQaJSicPV1V)D=ap1fZD^1E-9vh3A()mP2r{rU_j_22fWH&U%1YX8-;E4c1N7#%DREF zy+g}YP$d3^BLQS3lzHt*R_twZS!2W-3>LQ}qL%9iZCBMqa>`GcmoJ02yqaE& zmFboux4btkpg5f+ISZf*wOXCl|AyBy?!pmDN%s)|s-~0n=;Gjrc9}nQBzr1H9%^P{ z*8C-sD(6W>qOVOnSw9WwdwaxQ{i9ucn>M=&XRl~-Ux~J(FgAN*E^SgiH#$hV`x>F8 zo%h-t`m>N1P6x4vnuGte`Gke<#;gKz6bS%dh*StL>b$s{O98;jqe$QIojCKO&90{> zR7RgW*t9c}QzOg>lABvvHW(O=~&f=ozzNsg3|XKaaS{#WZ9ipymFTCPDpzRPbDLpz*Cqm&;4%mF}z@RGaS z*pK8?y|JXSVr86==7qQw&WLu$@-;-IpD-=r7Y$KV)yo_ z8X7A=KdNx9zNYL+f;vN-4czYtnu!4}*3OsxLHm;^L7hi;VbWMmoo~RbPuly@jOeEG zOI}UGhbRN__UriN0oWFCb*-18|t@3|{ zSgpVg*!tEuHPa6Fx<#iSMFEw!L#Tn(i%HNf627xr7NIpcybjv zHs_KpM8# zPMt8%=FQ)N4BPSNq|zi(Sfs&6Tu6MhCI{t9O_BkLSY;__bWbb_H&}QEsD%m`V3^#f z?9Vi-^o8n`CcQC7@jX#Q@fE7D>HU1zoojxV{Ce3NB6k=vJJ4PpWL3vIrb@$ubMDO- zKI~)oFj!8M3}ATcf2V=hbdJh3@8w<@0W_%h3dY_v@$;Og8*N^^fO6cm((eQHz+mIY z7iY0Dp&{=xKfs?MZE$JlG8W?T6F+7I%^#eX3@8=spAu!=gr5kag<{Z>PT@tFug z*Zx<(jP`cEl7(?DQ56)Pcm2^o*W}?-s|^<8Pb<-CUdMyRw-Q}Nt-DZDixR<0f-zIX za(ZN|>zb3_iY8B}6~~?uYeiRlkt|w&6_MppOho(KE2HmedarzaPXmIgi?@l&(u_>F z6m~l$tZ9D7fSkz8DF@Zsia5$RMkQ})ihIMld_>mbpr z95;5SI7u)Kl3XM8TS`h}nXo_-A!s>R8-&33xL}i|^YL!Oz2SY6&z>ckBaP{zZ_9DN|KxNWFMEHCf zc7Cm0;dg0UJ#&3}xjTOiJ-3T6`+yL_!(EF$Us_;^xz~zux^;fTuVMG$vN-KRfSa7G z<+N#UwV5y>(7NmYA0I5q0A41vP@ia7Ap?=@+AZ5;EHwId2wZ{OedgPd;%Aw z+zxK_2>JL<=Cpz9b~61oWqJp)uER8S&9Y#3dO%pHlyVg`m!EI&%3XP?sjPEG31H#e zq7Mu4tFH=xJxnxPC=V}96SkxEDlQYN3(Loqryl>rk@NUOFI~aoA2#^7Lnorc6KhIM z+Oci9`mMKhAymnTFqz-g0!0%*lpHY$Jzz1x)MIDU`xL3z;paC!r@_fi*7NzeN$rkq z<ABOe7nED~%opm;Esxk0_hnA|# zFyBiV>!@e91-k(A+?^V@R0^Qa%?%=NsvMHO)7<_g{=SzN3M=V$L2=@4upJ)YwC8Hx zF>9nMHqpa6**wR0j((iKSjQkn}0=o?g#v!|M+5yzMKMlv2AxjXsbRU$4wM4Q`gwd z!mMMyX_EJPp$ebxQDX~*FE0!j)-g-cdzpd5G(8onC|n(Vc>BTV+UEEBfUhVUW8zuh8v6@NOaTNW)^D;#WvvJR0V(+S^tGvR_(O$-QjMpEJWK1L$~6Qa z&mS2D6cU)yDn-p%h0q*23gdq&ac^aPR>->ak*)p%?Nm#auY+r?$N zV7C^4#dN@hW$@)M&+dRF_F?9WsP}D@TMT>X4U}NAqz4OBag?YVcSQv7jU$xr;@?EW z>-!yht~h1mlz(Pb7V_8c5#6zBUYC^r@-}fD0a=DoD(M$Un<=?#JWt_sPC49aK~q;E zSh=B)Fyx%8Wj4Nktm6UHydmNpyH3zZqT*lifq)!NO zX_=Wv47X*|daMCkpV%Yk^P-w(p(1%edn)j^4|&gS!l_8FrvZgcpwS0TjD)uVA46Zx z?EzE%?dUnBf>Q9#_NTdrQ*q|z!OFss@Kfl2KM-BC=efM`ROS7MDBnJ}i9P}(!F%uk zN$|m?g_)d;e6*pAO(fO8^~*O2d3o1z|3T^@EX&1-&MZiDQymDQDEr8}7P8_u4bX5b z{-WV{s{BR6nPZK}MGnfewYJo@sZC`KM8;TL=9 z%5)B>(BBHe*PPB&Vk_vrXQF4GRA5dbJ~ADO=+;@2NWu7hF3&Wt!`|ccrdP3-Bon95 zKgTp75V?)^4agzut~X08T?Hv2tG?a$$Wv0Dme+sc>C{j|lq20`>&U^|_&pxG=03K7 zG)81YUl2n2RrRZ#C>|9_nOkaobYHD@TG@Me7Xyt#hlcpwl7#crf-l5G_=0F)YcE}nNQ5yU& zF3hvM3ZpM|rC^&U4&iM~vC?Op(o>}c)Nr4RANkT5Wla5HJa%n2jXGhB zC(A2%H1dTiw2foG`|-KdSr!5*_iIzr$yN!9jyJMBSFNHnhx=|1Y&5zko_sUfr+;MW zd(t|!8iS{W^EeLijiH~ZSkWVQmTwPl;r(6wvZjQzvTn|z^}?vXr{}p<^bS*}KRFug zKTb4YYH3@XE$x7xM=Uo2@^^}#F#IP=4MHepVVdS<5J{~T@3fMo zIO7moSz4mNBG;n=keqM!h7*t8@nL}oAj!UfZliUT7y`77Qi2Q3 zIF4%{N!Z~f~ z0W56+Ts!^67Y<0vwUPDMl=&%_F`W-_Z)s}k>6~7_otkU4?e z>5;*yM@LMLrxdGC&}C`$%cEYk?Yy+42xM#bqG8jFNe@XdpLR{*r=8|0!7?2qs${Frb4#E*#olgqL&!eb-IMnoqW&kx`W~~8 zQUm1(BZ1fTRq0Kk1@M^scUEHG_++X@&^^WP`qht80}KK!=*OHz3)rIrCLoO4jd9BP z`o#nd!JKRc$F9biU1^N_ga!>ca_arO&%+lLQ>c>R{ApySOYQ-nQ{BnHVk+DK^aDOt z*#F8VF@4it@q@|%B(pY&caRZTJKi=ew2ocbS zn^DJ69GD`k0f}gIUUt|9UAOpNFumV%c;#Ff&1QhslmZ>rZvOr?zj@`x#(-IOKw)gK9NPEP# zh1fRVqo4I%Oq^mvsoTVlg4Cu{-joP`cK1POqv}6Kw&mc3@su#P-irSR_rp5-p8J86 z2ZQy~$bYFKMnots_a9?w&%+O+xiZL5WX37;t(`PM9?!AtQA@}!JdR$~l;}o{k)1hQ zcJVPIIVtnvJ%uUEhi0Vp{BoZULdNGym2df;l9-6u=V)PJ;p(cfMk#%r4bUR(g3ig?g zjjbeaZ51Xb(+TWd99K;;4h?V$-MYsnwVL4kleQ6ok+xUOs6pQ899#Y`)&}C_>5&e< zQgrb)=fc`dVO8bP_bQIq%bg~J`PM*N_!T2nsM43i`N{`2D+lR^p{Wni+u@OCLocbt zOslmAFPu$%7=9w&+=a&i<6X+hZ>E3+lwYoV+FZZAS-2hnCL4FpsCPP0;r;U&olpD` zVgpjN!|Jb~Atig;nBK}cNCz;jR_p*>90Cc<%8n2+s+S9Pv<+@u-!~u*2ss&Hzm20F zw6k_xG0#5mWoSKwB9na98%C}SFSYnaNw|+sKR5QK=vO&qgvtReUijRLllNB*1ptLr zqvrj?;b>^xGb|mAcm(B7ahx*CRAEb;(qr!}BFCJ8#{%Wx#i=8GsHnT?n(kF-xA=8K znE??L@y#8{D0r3!L=L)blqf`ZKn ziFaj+TN!nrq&MO%l9z7uGsK*I#i~cTVgu5wT7g)~INe9;_;_yT5-JfUjC~3k>aubi zg2S7~UwQ@-6HSi!Ufkl9X<^iHv)EH>C4%Dj3jp^NZ1^KDdC`W2xH#OV^x5bMJeWAg6-&@o#Z=PT+wF%)GKXs zKLaV&D%ah6(zf23+Er`UziQ%7xg=4)dkXlak8!6-J{b@wU(W)R{+xxqw+S47a%uD& zdUc^?LB;xWb~c;WO1OA|>EaiwVdpz?zY@;Amo^#cZ`*ba_ocJ5p21F^M}<=^A)1e- zW|(3bFnnS<;Gu&RShfXIJOaegL-cW|y?RA*;#F&wY`+%7bY_|mxNaYYP|>$ovDGkj zrf2>vUA7Sfw4PT$#bV zWa`K2J=AqKCT{CJnDKoY)$gEa9_+T|3PuMS&VRLL*_ruL5cGw+vfANNe`L?Ksvl@e z?jOM2kQuXslU&*@Y^f9~%iM0f?djQ>6Tuqpg01>1O#3?)!7>po23_6je$M>@JmRsk zDXmo-YtR1EfW&-0tRuGPuHjN%D=*Q?k&EL2UcwO89W8+rWng!OGSVlaDQ@68#cw^)_PW>koGeJ&N=APEq)X#O=5jKwe0@z#Lsi8=(ScpCXaQ;GB0cHJrSAT)<(e~V$c1@>8 zATJ{1!ZO!RY6`4Zq4B>E+9QUElMN$lD5+&k<;JYykSbI;QJGOEH>H&a*4y;-47#~W zgN(*%D7EIHndDF*jndox+_bivEVI?U5a*UlJbkQ@&z%qeh)uo(XzT(Y%fUfFza zv>YhDJwPcCrdwyY(#JcBA^cZ!^=Y$^tjMKz_rZ1vYM~ElC9rC`Vu?HYFgg5ZUgdc^ zHBRdF({Hf2nDv=q2fG|Gw=+qcki1b6jk9R!(g zugH~d_5}ovufnLYK9pyj5iv0_iKs7Gt*@_(H|905{7MCY{X1D4+5fy6$C18=lXpGV z?UpZr{PmT42})P)|J<4x&VP!544W)i_?62b{X1rj9UJ|G1k-Dji`c=H;gcfgc+w6Bj$-R_s zW{EcD$fX-uKVpZvmYj*iinAfL=rUH?2Z11uJbjE48wwa5q9u$5(qVK&Eq)ElftFVE z(uH&8Hwp?s=}a;iH$Obj^S-!>_^{mTT3eCWYPkZP{0NumZ@qbU36WdJ!NaINd!Yp* z?^2+1{L^Q3lmO{++Tl+JvGnh`R{ORUtXO^6rJWpQ`E$s_Sf%CU;Gyje8`Ty|0tBJf zVdO`zOcM$!2(FQ^wkRqJsV-mk51}2qi0!u;Y!?r&Ipy;vZ`E5y6C?qtGg}Mj91z-H zhYtKftSkENEQTm>5zP$_26c+7&q|Gko9IqO-fS>bjs5|wE6Lyf9;;0NmvRvu`(6&T zl&H$2t(AZ^lX6mg9h((7c_1F82Kut214`rHSoLYFXoKVEA)-s{=8fF0I^usnqW#*=VN!J?d3kZRNO&hgIL3Leczm z;HOtx6|5sU`3}8x9o2{Pt8cw=GS+e&t&|==_TXPMZRIFoW9jcii;R znQx^iqn6&1MsntKDGE(HE^V8eV|RRSo6<9kLMJ64!z-_ZP01}8@*sD>G!41KP_eq7 zcA2=vgws~0*$L_oPo<2!lb{UsP*iB{^;y_$9zOCJKflR^de2!gur@zTPT0O=(bG$l zRJ$(NRM)t^JwC(#s#?T>BUv&#@A3(+`!R%^Oa=RRXy&P#bz;}1HnOtwa9x3NkOiL! zO^2-Ic*Q0pl<2V*H~l)>I^jz}p5I#RX7O|^eS_$2U|+?8&kdd173KuuZ0)zzP_@!T zrANX9G8||vSQ=`-2-az7av0)nMn~7yazJ}SgF2MGEcEyaubBnh55HEM0ZYMU-qNO% z89=JGCy1rx>hQ;p*uBg3;dC;Tr$6hbZT!F1iE;)W`h@^iYnes_u1Gojv!^#ZdmpJ< zvI;bM#CP?rN@?WjdYTY*r?uxVPhOo>3co0HBvk{xoo`DP!@9#3{--eA6^hf`pA}1= z1c#i`RHzrU9iNu_88D#z%HEvV6*7}~|HYW`K_kh`{_@pH>wDJ*-5v_BU&T|3Jt{`8 zex^CV(-4hRhOOO5#gaQq63`w|zpRu?GSwzdbV$L%%E^C`y}09KBvr4Snv_`1SgnJc z3Zb>J<#mWRqp~aJFL_by{FE^j?YD1D4q*eDdtF_fCVP0?pqvhsLcS`uWbA^Gy$1& z2Z@?z(5z>>OHDzyAUHjtt0+Zs{5C?zn^f&pq)y9w;Ai943nL_mi?AvcZfcjG_Hl;2 z^7|-%I#b-~|MgL*I^*hf!b=BRei8NM)sD?ij%PNIf7;V+)%;(j! z*EK}C&5axG^2Id$IDEp{y5`|c$0t}+y+;8L8oB~?o0^}uv|6>?wk|36o%cRQq{+$o zVsRDYx)5Ygy4fIi7K9VD1F!ueM%i0hgiy~qBA`3;@C*4fa_vv}i!Vy_CK1qeKYI)X zO-t0Dieln2;X~3)?cHmR3?^P`N$%wt{o{a+9csg7J-@j~{19RZ*LoFMa7$9#vJln# z%4C9t9KRk2A%#{mOJbcIuuf;+!%wU~;SNnft6U7hn2ynVcJe&Av{VY%z0xsnX5KEQ z7uA)av~v$~_UHAzuKTXq`NS)}8rDP?(JBgJYF*Ja#U5>6rt@cBNpr~OG!sLDam2pe z2!RgU=D!Pht?C9pQGAl?Y^`Z#O-GZUl-G8MidpL@mlN9$9eXDkYmg|PhYCdgaE;cx z_o_TZAEmP&#jTBN7{px)3o5Pu%pAAEG(ydsw%KezYX#UT5A2xw{fQI$S9gx&f4aZJ zF#h!$bJbOKHC%UPH~R#s{xq2Jdg1bMD0yqg21=Pjp3T98JjNd1F zb}_-Z#TLa!IzcKi0j-9x zV{M@o8bXMkf)QSCu@vj4055 ziC^!T-;|V?D!wcDQ$9S;d!EPq*h=*pn4Vro6r^+)8@y(A1g=iHe}7Icjrt@{7BBPk zNj`S>x9*!Y)oE@&2PaFeXBn<<5g*rn2wKmv%!4xQJUkPzKcA6vyZJ?lz9(GPqABxT zn*~B<`kf1B8C7z9{e3B$t)nB>+v4MoDR@$dfwlzSU1mAJzfiyAy-wSFeT(Q#@Jyyd zQA$4+or-=q2869M3N5#)`&bbUb$TaeME}&}lYktt(u0Fq@0MkE&@j`;@HmsTK@*tG z{TE8;(JT|6JWwD*^$KmNV5kiCWVeX2(-y&uVl|*_B-(S7WiAN+h4I{QEZp zzOa`EI1XJP+(k&wHGQ4zq-F}04~G9h#s}=1KoMWY{<=&>=6LWN9(@O4LFYS>a=)^l zB6KgU=;FJPCM=XPS~sX?+z3T3S73GoG(|CuWz(V5$oDjRF1~R z^7lL$8O0f5zHYh86C{P3HGmU#pra4$9;=b5`GjB@RZc$ZMyERxr8KOas zFLZl#6en#)r|bXaypOT8t|S>rvLjEqaD4OF1Eam(Y5l8(Tby0xIZpRMH<@ori2;d} zkEGhrpOmup$y1>&%PM_+W(SzBU0u$>@2=JT(J`biW{e+v#*u9iHs^QlragC!m4cZ%szSS^;w!Xh75QTP~(r$rX*BM zZ?1xZs>b}7cMc6dan!I8yuP(~(Ph{Cd$j%Xq?m=dxw$-w`nhXLzcI&3pzS0|JG=Gq zD2U3WJVBQPMIzcj+p;Hb<&|u((GRO?<$TVnc>!m8WJjYWeX_o&2MC$G32bp&uf_1w zd!}hW@xM&Vc=9TiGK=n!w1rs9Ufw3IV-zf5rVw8~^$l>nz&3J~3(F_&vwiOW;{`*} zTkrh-<{@&{vl1TurnqVsHMK~xSE|fU2_7hkAv}k!JSby5vQAuE5zA1h;ZI$SQ~Q4? zdkelQyRGdT1nH9Q5Re85=}u{BY3XihSfDi0&7u(&vMA{Wr6eQ->CQ!W=X0vpweP*} zYd`PreZIju=bCfOF^};d$LQpNZD2`$Y7r-NRl*^#grhz^)>Bje%NpGvF8@UYt;qCSKlK0nAHiQv7sCCh+FT zMryUV(dNikCtb@>YHA9?2qGcj#;Lcd9~^Q<9ji;VoY6(s1-?_8zF$I_q!yCYbY_e7 zpP`ZKf3@VGc_jlJ8C*}zJp$JQOgSuj4)bp#8v6 zi10(`c72a`wk%2gSib%QbW_46B<0!G$Y;>Fj)7()f{|AN(5kWP-mRK~CnHjawnw9d z<2#dD${GCb3e}~I1LQ6(%Um>uGMt+3Z3dzBZZ@`$;m3GN_(8m`i3PO0@+l-G(;jO# ziXT3x5ksQEJ(llAw;Mn99{?rEPJ_%6zw=#P9C(S#o6V20Ydu3gtwv?qG}C3;=)q!F zXnq^|Co-ehFXOk5ZpQcDX?P`}*Y+IQ}`DeLu2Lc0YNyE8r zvt80RAC`(~RY*UjK_q+aTkjh`%3&(|wvTi1Pcn)$1+*Jha9|@5X=_u{7%EIMmNE9r zkNtG_&pDtn#gJysI$;E;=raLTfucy$Egwo5lcLq;ar;JjdWaMZgLkC@yB2tqXIfCmg!Cqo`HxFI|#NHeP$`$>H+X zipY)smt9~{m@xlIi%kl>V{@h>;k9xc(YcoQ0vY~F_}rNB;itJxRpsi>a0XRndWA}B zH1N=sriGPbW)#M^cGMEbbwZo=xxUYp5DM_Te1{txzP)=X7&CU(k}n?g1-rA#MmAq4 zs*1JWZAnNi3Fvc2q}G=ZW*xwgk#s$*ed#OIQ(lq#8u){>?TMoZ6K@#Uw0PmLSu$eH?{d@`F5HaAG$jU|)j zl`Q{`lAfdd;K_yRf)9Fms&DJS&dwp-hgDYPJfb;ga*av84(C?>o;aVflBIpALizlVxX;(`>o3{Q2zy-*;_yj_^+8X8!Nl25)b4V!wmwge^4eoU%mKs3TAd9 zU8wbT?M&AiBAtbc#XPoD3Kx`L2Dg|?0Nx+b#bA>dP3jRrGs=3{k1uBywldoU10(MQ zLkqe9OX=jy_o?%|g0YHS)Rr z$8Z{FFG@Gc!;W(6K<~y(ViqcMTvK9-gtF9 zQ2#7oEir$HzVC4PkU%(oBiAE53a6-MPuPzOgG}bf@~@on46U(uUU5&0@lkBtV;#)AyszRTZwd6+?n8KU2?kL`2y|M{^SeGvI zfzJ_t-YVgXCm%}WYCNOApQB^$as1jO-th8F6|47KV2+Og#o$%;`K={waHx9ZD!CSkf*vS^^5?%T#`v-iMdL-_PRu8Npo!(bJ}9}2h~Xop zKbu#nad_yHgrZTR)RwH9UTSOU?~qCNK8=hcUUQY0Jki$ASUWFg)7$;2KtsU;B-~QO zZ-JmGqlF*$X1mtpeYJ0&h<(z!8?#Z_<99g_k;QSVlK~uFQ?{{vhDtCT8`^3*lnz66d?Kih$O6$Ie7>0LH)6O__n#V%Y_YU-ASY#EPv&7r&pv^2|P~im2PMYJl6~LMnWFwrT3b-`+ z>OS8HqH1{PV`z*W1`i(pGuZy4?hj2pXx#MH5E{rpG z3yTo@#)siXw~tr;f1-@YPa}%k<6&!T*qL7J_A8-``(jY&=Az{xwX|3m(#ayy#?jefheAPssT=!T(&*_!^k27qaj3?W~niQOvsR zpyE4Y;}4Hag|h36hu!+^=$_h=)Mm0BC{*M){hMq@R#O#Mf~%-l{`u7xhFO?z%A(6o zfL!uoCCmTlBM$-ldm3MdMudxYx)KXmXxn;DDGsm9GYm$0{)*9oeGdMNI45av~lFY&R@A#5g zY1N0P#NGR6A_)-bq>9vxLsnMH(7OWII8Mp^Q7_WYcxC2OI{iV7L8H6Y_7F z30$-!ehEuG8_%SLilE3CW@++k`;-?PJJI~nBb947OW@12NoGnM z5-r}+eCkUdK1q|xIJ{kroldDe{_!m7J*6zPv zu<7;w`O{3vj2|`lQqec_MhSG|9Rw_ysj^+sPNilyEnz#{e-?zO(QJtA^mc&HX+cld zMoB5thDV&#>+ZNCW726;Nko*}%y!1S_BteyK_cezjg8I6#n`v4R^Ut=yvMyPoVa^Xppw=)xZQ2D*02ehcg;za$L97W9FJL(0mB87@@0Yol9eYO)Q$%PF61yf;~TwZ%oihq z{?|MtF*MO~0<^%BJ)(qtk=15qR_v-zmEEYyeQ@_o7yq4UCUXs*Y{2oy5Adq0L;H(5 z9GvAj0&hPVRkZt_k?y!-4zN;XscMKmOwpdm!DjdNAI=|cWhT#HnV>F zb|ig(Fe|Bv6RVv7!lDpL6ozQWg3~iBQ+XM%o6BqTCp*|*T@<)o^1@Xsw{!VF%8-*W zVjw+h;XjR~^_*;wB6&jhvf-D(e2D|!M$P;@lL1!HfH$49Yj^3>=v#*qIIL|0;!vpb zs`l>}=ZfTMr2@}b8uZ26=#4v&r1elSm6YD7Pp!F?O$3u*k)8^!f|P=~)G8!dAHtu* z5_|V$=R9#C_j}aT%cxg;JSiotTKFnl3ZD|zliU=j6~A8yv&S5h5)jS8S`Bml5`KCq z+}NAz8U=*J7Bh1^^EYn`6>YMsg~dcgFc-0#%ab8DT_){Ig1U8?bTqK~rg>?#QPVb= zANUqCCn#o=e&`YA>6Mgb)Rq)Kn42Jt2t}=+lC?TO^!dWM~g<}LLNkg!~PZ9!0#r@ z6G%6Hi<)=)REF|ypj-nne`l&1f{A-?MIEDN(5mlZK%qS;0|cTGLV41XUi(73;zdpX zM3B3+{K(m3#!)3l_@a6wp|rG?oeh|HwNM!R*g49H(qm>j-<|O7b z?}rX3! zrS*|c7yZ$phH0rKF%E;PX9UX*GKx15yMeQz&g2VfD-TK=GMe- zY}K4tt@MjG?Tx3FZaeBBdzJIWt$O+=j{{@u`{3&-vsjB2rErEEzvGWiAh*9_&KzT3 zLe!Xo$zTkg9!ol54MyZl?EB2)P^cvot?y-)WFehWVW=!MQntP{=iUmV7i8!A=;$o% zfaV}Uk6SYHh$6wsq0L62e5o~9ix;Y89niF=A`nSyNQKJBrt^=pVubI`$5)&m*s;i% z%r$hOQ&PRo)fd_Q_;942m5&+gy5t3!oB7b{)p$&Xm4R8QbU2jJVHm+<_om!rEwdz4 z&EosSS)(jM)elu%<;M|<%Ps~9`AXRrGQqv`^!u*}5toNu$Z_y|TNkhdT+Pf75T(7e ziZz$U&x`529cFn^;(=MabZX(qrf>pP2J8nog6pmt0@XZ@zvWN*{oKhQejO$zk8f5s z-_A5TUO+`bOK%FzvwSx&hI{i6s`17JH%Ihp$zjvGwBHoC@uUHiegNX=cbQo4WY8o{ zFyYzCI5>en!;y?KcCMq4YoC*z6JQS6vO3aVyu5&R2$n_n+~%3`f}{<|W?>@#dB(V=(1T-JxCm)H4DlC&hwZ9v6)zrZbDKn=qcW z*=^vHft;W&JK)^#JN7pJaO|YwV;l!PYL&WO-mXfe8>SHPc#nPLGB;H(-N3(pZ9fXLhu}JFB(h{O{0fu(p7}uF;($DnnV#fW1CD z)6d})ktv>wpU)lzZ@+ibz9%;&(R2sTWNzn4J?~*eeVehEVlOTJ*!*)xKisbqmE|xC z6py%G#!;gfwfYdybu3RP!|l!L*oTDZ5OElt3S)QmS6dDDkEInHSpjE_knjtFSIOkg zxGe!)uSc`U9DkEkjDexyU1mAp#`b$zZbshOpcq!MSj4u$`BkuWzf_# z>QE9XsLQOH!pvPbdhbf|6m5l{O_~Mh;e^{iK0Y>WF0-?ZyLf?%+=bqK`^XP;1XGn@ zzTR{8FMKW(JZHF)Fxy_vB_M#BZ-OtQsHjN&xWAveeVt1Uhh2gl5!-eDrJhsyxUDNN zfjz$MV5|(Nlr686xfcnMOCNs-xM>80(BCS^L+r!84gth|4kL4rZeUCdw8L-++h>8` zL29AyYad`~kj8nB0GoIgI%kRzwg8y%{Q{N$YHSfH-e3gNrmK23oiGc_8sB|&s$z<6 zX>`5fK-pQq>39I=;T?A$M74zd2%HOmiVUkFg;R=R%hKu^>Ia;;4J zY*Z1{TRZ2-V3TspO7EgTpn}Wp71tStrHZG3r2Vs(In#My{c3mG!vQIgCwBuxA z6B~Y6z5EK1Q!UN??x>reJ2&9r!2^7T_r7*}&k zNtOum0SJ=Y8(3e5EhXad7B4_kJ;yT1lzev?GweBoYYIs@6ibV*4ZeC~jnjRycp9Fn4V#t~94 z7zBU=)GXDKs3@{*frAJXpghT~nsWt&gjnbYREoy-Jc?g07l((?t8bF~gz8-a)+gGz z3G1OT}mUu-yFjSh%JLR!X zh3hcO@DQ)q2?VdqlR)B{Rf9B)gOfFxqta^8{cuDnlPBY&CqJ4V%ee1T@g@RJ#zI*t^v!aDY z4}_+i2xqQiLE#@+(OOpSY<(vepj)hEo95c=ACK-jhQ$;kpnOn|LU2#tnc^fDSei*W z2ri$QBox9-!O*|bmIHB;t<33Bo-CH8DOzh@Y<+?Ik4>Zf`iKbc)=!Z)kbzod-KKwC zj&g*74#@;r{K)_#i66IC^1Fs9B)COQV!rneUPEK7s_NO!lo3lzFbN!(KVn&T+pEQZHKEieK>JqPbWp=$|FQ3LM1(yyH(Mdi*x&!m>07dk#E7-BSDvF<% zM;q9HC#*wDvGXH?vSp65bvut``|ofx*D=%!NNvFy%?8=_N`XFGJ~TXBPX_O(`>Ue9 zNvOzUfPxqa2{-U1wL-Wcq)Ed`10%Uer3l)n3_jV|5Np{Wk*xNM^D)Y1zoQk(@%l)~;2ro#1ehXpC@>;#EI!X_bHB3$l-h zMpOfn7R2%6_bR6J1wZxVYXDLL>7Uq*9e7<|Evr#iXnXz6d|ID==bbCp*PXDf4Sc!p z-1&-{->AX)tGi)bBZpB7zX1_iy!c^lZSAu3*jidL@G5IgZLrMd%#P$>H1Tb2r1u4tcHn7b`{7<7_CsM;4a97c$4G1t4>UuwTT2v{8mxKV6XNu`4~v)}5B zB|ZdS^%AQv*-%)-twSS4ZTvCD+E% z9YF*19Zjeoy3I5QWh_RQ_9<_SBxCrC7&Ds_0hC85qDizgUhRuidR~q(x_@rkj3QK` za$;JDCb6egt~Y6DN@D5wLP2JEQ_$I$NtCi3Be6(LsM4^~dT>~f0Vj{4hO&$a)YP`r zJYBdCxm;DTpXco>rRbR-KFvS}QKZF0f30NoUFGWM(64*UM~)0SNO~b#Y}PRwUE1(x^-lIj_Lp#bp|*OB8UszrHi+0Bv(V z##c=|-Ys4DB(4;Vhi#>MzLw6=l$8x@plUmcDX;Qe^uOq--5H_gpNFUZo|HM$&Y_gJ z?lF7u-pYvo!c+9bnv`KiIx9m@%W5ominL@nI#mBt7qAHP|FH-L{xxlFb9<6MZ^$s? zC}NbAzEAGp92briNk}(L*xq#`Q;B=UmCx~q{?tTt4~ip*;~hQi@BW}U24P9g5%IuK z?-9yc+8B(gjOF81Z@BPRW>xXh9P6cxg;P-w=$#kY-&N#rAUa#&Z*yH&ASNW!Eo4m# z7}e&U>o|es1b}Y9sw8MF5;NI8+e|hm(^aK=V+uIibB%6?Y*ghT%Ru+f?{j1Spwttg z#=I4&fIqtDfd@ABx@bKCNdDX1uEm>MST&=F$HtMr9JW<3Z%zQ#Y0t<}q-8MkfDWK^ z+$@dOUX&Y666@<49KSyV^o|^GjuYm!V#eN}$IU=2`9myd{lLE5sdTPEl8xdyX2?`< zifk9)_>BnU8x8-SZyi3ZV3i5un-J9pFxmQA*b^;VTLn*atK-T zPJq!cVZe1!i*!|D_Fd$(K(hu9NQjS5? zb#5Tk9HPLa?_FNQ7B1BWe4$=oOZ{-bdnGgx)4_sbF zY@oJH^PU=#dznKzWx8WgT-oap!x4%$VDk;j98%~3Qplc=Ra}8^QA9BmuMU+-2|8Yd zswA?}m|xk6J*cXrOd9%Q=j_pN6Svv@*+$bY1EFRxOzxyNfC=Vk<~tbJ7+C9Q5zNst~Q zDzss44||kxJ>%9H^lTj+@tRg`;)OJ z^+TRC$Ff^QWqDjbxDbzg`J_B0pR1H5IB`2S76FsGdBe0DeX`hk*+T{`pKqxJuNRP7 z<#4hv4Hji^%Y#+Y{YWj%&d&b+HL8|_ zqoc~qhXl}ON}sj&4GE21jOt&Hnf?P%1`hYSuo5?y^IX z1XNuqSY+NE#t!!81;zjX6UsJMzLR8eo(JX>SLm6gvf z0QW$nnSlVzmO?Nh%!jEwp2V{%pZSO~p(EIw(`L5Yq&sqy3Ii=$+nzf3`QZdBD;6W5 z36vk)2(7(ryyqrjVEblT*6X4Bs*P0qP>8%mIiU-|+ zD-MItHP7DEra)RuZQBpmYZD4ScFwF&qFPAbvTTDZ(3Q- z^sc;Gp~beo)svp&){HTfHjn&VJpyXEOeXqAHW*2iDRks#?N@o z{BNc@X_rT7zx_ie`DSI==C#r#H3(_0ba69*r-Oo0&cv7ctN4uDF{(P3W$zkk`@)s$4h%dAZQ6HkLu-%XJ)XQpIkj^@?k} zR(lRWdv-Fin(9IzT=SG^*Q?5Ol9z-)La!+H;HHjf9`(avBXxafm`8cJqi(Om3jro2 z;T#6rE7vP~e~Rk5c6eK)dZs;E^Y>~osAQU=WqjVFQ!IhpU48tfh%}3l`R+g$FM5kX z1WKc2rU&^%w1fs=O;+Xo0Gw#Dze z>&?u~B{d^3s4&K<9wH^AD=__12?_<{&{eaAZFDDI4Y`rSYA22Kjg65T57$$Tv%%nF z|A*VFlc29~!h9LZarmC$p>Zl+04Tvh8tPK?rm6FBz`51mSGabJ1^K-)*QL4bt~5MD zM{ZVrT$EgllolbqJXkGT282)aVYyhnmd9{xj$cJw!UAl_LK3=hDO!V{LSzdmv5-yZ zVz!bXb{jregkhczz`snS3@L9Rw(>o9T@e=o?;$j^0;7qPf>Q6 zl|i}*T5&RyXYt~+dW?Yz9XTk2D!`m{ z8*mRF5=t%KAvJ7oBxmUB#7l&2VBfeLx1v+sxWA8MUc4e=5)BxI?DljGePj`M=U#^_cG=5tf{qZ}np^ z-ivE#{R>GQ{prR&WRvtPSG=k~-->@=>DV5Y*Mg!-{WGgXiU^={f9u;0k0o3{iko(A zsT$d#MjaYnW}47$$4X&Z1Nkml&xES%RUfstHQE)#NL>>y$hmJiLrlbPI=mh++nLB3 zDWz*jso5KTSoLaM%z3Gl==|z6L3CxpAg#3ruUtoKO;zyT31#`e3S=hJtBggVNyjlJ`&92?5*oUBMD(<#l&%8nPgND2thY%myS}yfASP4UyO>qd9_D1U-gsdAJaq11D?;K~gLSRm5;7%khO*%#%_Y#sx>RPNE6$!eFbm82 za&q{+D6a${ZGWq1`b^1Vz(}v`ku+J1y(MnrH%;+mJ=^QC5?YRBo=O_V`i6$OuS;KV z{Lmx7QNwL-ZLrquNxi@32+Uy^7JYFx!dYk#Az`=fZRbFH;9c3jsH+Q6+AA%mO3#Li zK5aT+3Wl_@^T-EV{g>TvVCDBeaBAPXKX57%e$feirjzs&#F(zG_j5X5#1Z8+h~8ud zG&F7ZxPa*hIKvLTs=d#w5A)-F7CHeNn)cY{3r;Apz ze}|AEO8%D#n)CHJL%eUb7BA9^n3G4hYsrF!WHXQ2VBNwyHO*vYXAS0Jz|07G<>spC z#%V{Y8NQR#bZ(vjEaB_THZ!@`g-IjAc{P}Os`YpUS91OgeSKf6L@Z`Ud`dqoFgg3b zB%;6l?&m-^$ACTbk64>!x+B($6{;YP$b26pE}s&?2G>0WHz%vhdG>Yv&HH@fD4Rny zErFVm^Sc;WrEtA;i~GQgP6bh2Oz_$hSff5&lB`JsHXX5oMERDuC{0=KJjH%j${S=! z6ZTLy9_7T*wZkQP5(YoA&`SS7*vLk8rgg#sSGtO%(ikH4;Y6JS3GCHoa2WF?NztDK z_aa!U|Fov7aYIg1p3rG7xF@f*lCsG$!BQP?X2;hf7?D}-pe-<9qTrf3{Yl4xRSk?Y znQX;A0Tn3%BU>Bub_gh1PVT_j>wZmo*{nL$xJ9k$$KNMjbaExLRz!!F0P&*eKjOv7 zpe0#XadJn4n!Y{JZsR^Riu%Zdx63i5-;L=I&D+f03k_v`PUYmvK~O;1WDqg7s`8+! zYEj!kSt&j`YQjHh)SQgWU_>lNwg`-0J47ntGf*CVIq7aQ1-yK1T6MMYy&k(R17ie? zi#0<#=uyBGEys~NO~uaA--T-R08@5k&P*Xs6`xR@P6B!yH1o|^v3sxbdCHQ%)<@AQ zC(z5MRl+1wboJqE@gdA46Gv-VlO~hV=8jIFDmOLHWfkN84dn`Zs|*zQdbl8w^<&T-$GC=dXK)$2Z zNE}NhJ$3jmrz&7?tEl~GNJxjnNRvQj%>AX@Q^au7yxg>>;lBV??7sk2Ms{o@0W-27 z_(S{7%fVD5AFsu>v+nLmKHe(2(0?0Anr;g>VjavW7w6g$a@8LY`QscT9cI zv(wzc!!zI$bSW(;CP5mBl9oW}_xMiCgHuT*j`t%CthDl+21ixWEx#C=IYNp0kD4mN z5i`-iUGZzaG(}%HZ;<|HocHfrC`Dm8w}Gr3_%Z~zkx3j4DAXP5k44eC3|^9jFzTSV zg=iwLpaMyWJ~4!FB@2tddVs4M?L9|$2TsJ)G7}~j%yhP>W|lQXvf**gF}WoUr-XB` zT^t1sb3@8E(Y-iY3&um(lIUYlx$mrT4uot?nfegbMQflwmAYIgStRyA-u3xmbNPCg=S@_fjkOqi z%f&ul`-uo-6!0(iuKn?0m4%EgdF{V!2r@MuU3RL06QAO@8+ljcVabX~708yo6FA+BnaZt0PzMpYq8InvT6muLL{DwYAqY5Qmt| ze6q18R3F)HbhU#Ir`a(oTF+B5Fmmv=ZN?cN{i#%i(YTiHda;}RRB{;Q5I}# zBMmE72rgR;TZ2uk4iRt*AT~g^(9_-+Y2twQOH1A+CMIFt3|n7L;%Vh-jGX=^G_+{I zl6O3Y7lwvvRwe6SMglfAm#rv8f9M&G83jZi@-U{ZL@*he#fqI2SUxZRRAU~RwO@a~ zwAd*8P?eXZk@UQ1j6nq_BsquQhEgPr!KD^JWJwns{8(eQ@mk8N3*{~j>UYl8zb)Gjrkj~^HiU)6!`}S@TKI~SCyZ!96pN3i)#Sl9)tT7u!z27$B{S*Z zmk}D9yWGhci1c~FtT@6<7$1uY5G6TMG$K~Kr|zxG+M~M*L|AsUwe7Fl^PAPg=!E|J5NiL>xCMN6U^D)ZFuGZ%HjNxaQl&{A76#5jO(!Uzbv{N$a9yzi8 z$8zXSo*+pqg_%tA(7uZWaMzP4H-^a3=chr`L<3B^Det5U0gX1!fKQpPN=a=TcknGe zEn1k;nqx5}90L5`fegb6G`a-uNxl>ESVPn84v02Gi% zZ@fBBQV}1vP6CF%rLIR2IV!dUCB58Kd*N=H>vCq)g8yfqx)?<`r&XiQnyyoAFq-JvW9Nd%$ZIPZ142SPS5M_ z_l}YIxM%&^)sfh4kNS!qRzAR5=tKgpY?BIti;>2tS^mp`TJ(MJkIS#(dAuFEn%30z zBy`6H4fR-$ZQQ-nk+0DO!Rv)2v0s%vT%U#g;7P}G9v#lC2N%;i^k7sOa zMaP3IbZ5H<^I)L%cBz;oCmn5V-eCXUBc?xT{s)z3A255O63T8sJvIjR2xg%}JjnzK zHa!F~oIF|2bhoc{6GE9IBKqGdvsuN_F(~**XmWUDb2pp6ciqB5@?OGr#f3!hzIdTl z&fI34d5w05-KCRBEhYQUl1>NR@}c|~qA+TDAk164H0is>kQ=9*c(8C@IObg>v1=gE ziU`kPpyF0}T7~k+_^smSH(+gHHGCVfI7S7=wJ7SCAUb#_Ks9hIRFD4`3rnVQKT`HF zBY}=Yl)Q~OG(K416U9^7E+z*d>>P|vSv7pLkJGCfe?(elxeJX~RV;*zqd4foV@&=5 zHb44Cr`)Qch3gydXBS&mN(6>6M3BqCRtkg}q37SF!r)alGLoLf4N(Prj#KNd8#J?` zB0KzP;FgxpetK<`Br80@gP9+&UAc-)F^AoB@u^`)C-om{0W6k^N?I)w0x56zz7s_8 zMOb8$W|wK4*rN-AM?s<1dGd}Xb0Vd7flg9++o1*LRt2GR@V_ z%xrwiMj*XjS%$_=(tuDVdI<08Cvz(0p8jlv2 z!?tUvK9y0@*X%V?OoosbE5Ue#K$lBI**f{-dU}{btc?&61U~nB z7%b7z7-F#2E73z8uJ9C80dGNV5n|(P$?Y=9-v3|d*rtX*bS#{v%sYei6$4`k6rf{^ zohY!By5-@1F(=+Ma_<8#Lpb~Z{}*bMwuid|p%{e8!vejsj$P9)bVLN1p)Q=czu96;Sp@oEss-PRieeyiga2R>`;|gVVX4n5x3DCLJ7w|3LRjF?Q;PU^FwTTsmR2Y&RF?um> z`q#L{x2xDZzfa_CkgFb9AQIqZM3@0`f<3+@7 z>%1|xiJQPSgeA$u{Kclzqe>$ukEJ#Go88p5)0~G}^!c-x9bdH+(1_lmak`r8$36aJ zy)(XtX{T|rXgeJaPreB)E#EcnSQ<}kw-?RjsE(CK8L*ojcecT{!^28B%L^x%(H+k| z-=Z(a$G5$A0RdZzvePLBA2aWFr8EosXL28y=B|4iR9g-^UiM#6fsQZk%7CBz!}2EN zn+m~It4HC|#Lx5`?^_QLQEHuAv1C#G`o(VDEujHu1@G#v=m9A5>wH{MG1Mg~0m1(v z8+-#?h<$H4&%?pL$Q6%HbS?|(D6{1p2H1@-giD8-jyexo!Ol+GWD zIV*D#{lJMkVqudx+sk67=KN0&i#cPN+gHD6b?X_I@#`xFX~UU67(C(dF1IeQB!To{ z7;1EpTN2CZ_CyTfYxTLQbkeEWtX;*!B;VWjC@H&P&iAS(*hC^NXqJB>8Ln=bs#4Yr zal`#q3<3Hpff5!%Cq@0g|Lmy;!jmh$)KrS$F-$X4OC&fVr&7VmyUaw8&`Vq+-oa|Q zSjlT%r}^XNc_pn`?aB|-y(fb_S_BsJ?zFQWH+LZ=I&MSr&!bk;G}JBWf>d$mrsjgJ zVVY-wCK%{Mjm_Wg27nptW})bqpgo~&z9({=WUscm{O+?TsaacQ+B)%C`aWjZ&xYz` zx-DL;|ApatYyJm=d;7xbu6*OM8vYfU3({9(zmu>-tL!V`Sbxc6U3+~J%5PZHNUFo}@)<9{P@3%Q>D z2Z@_>@;8YqOwi2#UrAi}vTXaT!(INN$+q)a4>H>}_v=#|F7js5SXW8{9m6)=(VF^z z3ysYQfiByIdUOuiK4{bgXE_dJaq|SWq=1V4DSJ=I_yxQ~w zA76c=OcxVebo2y9y2F6^PhzlByBPErmhX#4`qNIvw2MnQ=}+hBBEUD;KOxVmSbgvI zCjYeNzguFD%ZbwZt6{yjRjiRVX;wD{W?T89`tx+6CCL-WBOWc2$VdJ8U|9dejAO4p z5|zmTA71FahMIOGKSp5q+42&9VR}Ox3?9FPB9a>}vT!xx`Du>0vk4bartPBGKFnS2 zEHfdl)pKa(EZW-_t0^#6`LWZ{mrQr);GpaJRDVY!w>-?`6B?f*5RKTSsY;}|ql@*V zCao6^7=kx4uQ?0o%XAbyQc}|L-Jt7qc{~MlFL)gF8Z9E-1dpe%TO7r03t)M4b^M z+&(GGw*w0~&+ODkHm=*AX%}hWKP`kXQUlyd>i41kYa(FOtZgNKp-oBCf`_YQcDVPA zs@8E3^>d7mn#}1CRIuMy0z1Ub2~to)_$u*j;4wC6X=V1Hh5L7K_I%h>0G}YNUvCB7 zEb-Nz59>D_&zzAh-rTcTjPY~6$YMTCgAJCJRr-`&-ExnoZ@EW@RgZbNU9UCfgc$o- zl)2lO(5p!D0k*92-f946-)==5F@!C9WzNUNHt2@z?shHIesXirehpTuYNkj39TKTf z_J6($G8_NXrVo^sRQFNVJvP3%v}#v>S$y+(xyc1Ql%!xWV49hVj35+4Q=(q^fqTD5 zHz|=?-gM-sinTzKq2O~-Rxb_$6l=Opd$zTUc~Y)iFIzy6x_kIfT=)0!nK{Fg|-vSAs8Ns$!TvqKsF- zlsKfHW`}e3yf2i=Vu+lFsC;)hUlMtNj{6wIt~dAqQ+K)U=mge2{xbXte*V1L1e>oM zfZHu&FO$L*jEC5lFI-jncmFhVt@X8x*-Ey3!V)AL?hEw_*(gF>_#({6rK zu(u5^3)nI_+LmBjzJ8ub&ZS`IHx73r?mXsdQTkWgw#@!rA4T5WkdNBW`MH9~M`!^b zHT(G&jmw5o2IyD_Uwn~TteRtd_DFR3YG<4d_FaPB|(+;vE+ z^Anfl&b7fu`0hyn%?(Ln6pm3;AOC*R7LN1lHKo9By_%Z|q(-)W6_c}hFeiKaz(?2> zfJEFfBRbAe;V_Ft-~Pk8p&b2493vM7_!CeBJ#rNa%)Fuk+NcOTM|LDKOOo)LeXD9# zubGxfwW!3LKdV;_iMWMYt&O~!j&94U11r0vY+rC*ocEfzM zoo1sXOFOi^RE1!h8y0$N)}imiVq9aV)t6;Xx4v2?Srf8m_pdm?;eUnYNy_SfzpEJQ ztMywK20fao5HV*(eJ`IE-26N}t&Bi@dEK0>z!5X<>OJqmNaGeuA$tAucH>I`%=aLU z`cX&)bVqoYqoP92reCvGvlvH#<MrjdloKcV0fOe*7)&TjLPto#m*LkXyUh{dzk2= z*J*qgx(_)Zb$lH3wLCd1dBYAS6ZA}$7zNU37ePi zf~;bw7I)nr4zVAUmjrrlTc*=`$KI}9zxdtQ>`&b=MfLl(2hJVxuX6{9WSfi>)_z5a z)LJOx95&*eE^p78n2=RSG&7oYp{{x_d{T;KwFb^PyqF3;^RK6k2JYS{R1 zJ~uY<{|U}D9{Eo=H`C3K+Z{5JDUM;1;FEU{9P}JZA*CmrEoMFVbmPyl%60zRDgt1W zbLO6$x9<+*-0jv*3}%Z3-Xax0id7zfj_=5)49cp}$GB^q1y@}JDeCAn0kfGH6xaLI zEg+gR#_U8^7u_y;)U~#SkC>WUT3V(Ycfh1;{?T3VN0OWm=sCu>R~m6QARz-|rtcjz zz;0RdaL|6nz#!osn{RDngSs7A8hotJzKXm~b?R|Q4LdJ%2ZV)Z_3J?i2REXZI$8t^ zkdAKsn@1k};cG+>=Wal8;p56Z)x&%Rv(j_}34exsN>RY=gzA#j5y2ShnBKVHakrZi zV8YhiUeil}+n`dbcb64#Ffht~gF&SmTzi zz3$0Trgc<0q}Vdu0j$ZorqZRpr(ZTyxISKGA?kg~xCZ?T)17jyoN6|zkWx>X-J=^+ z&n~1>DejQ(kP*!@rxFxaW+Zv7MqA?C0W_M-VH&0ObTdxMr9lI zoFTr0Wn^z%Q)~`P4!OYUSCl3y54)uZMJ?M9*ZE7o&? zhL&5PN`I8Bwn%oke8Mf6NJoNU(4gX#&_jc>9!Ogl`AkLjyDO!Iff~M)j!Pj7=P`Y zp4KhC@)QK7wkmd``N^Qfok?Wh#hej+PvZP=~n%ZqL}J#sg+uv27Pnq*)AogIMW zX_C@qhw!5rYquiu(+{QiFcMkIroiR8Wpxj$u_+>AZE@zDgX5qaI?iQ*|J%N39@R5G zKm_%Ep!r}*_NaBiw#?psO_$K1wO^z{SZMb4yA^d_)8}GQtuj&HTd!_lP8KFfD0!Rf z7Vf7QQpV^u>}43FADIDLl2GhlyzXY?|Ap6uF6P$g1HA6~I`iE!z6ikUo?!AV$aS== z{o-}=;a(l@oLzf}x>(3U%R?My z)srq#QvtD&`nd=;&r36p^N}_4${~0jamf~HjHfxTET9JOoRGSic%Mt#*v3iHYUW~8 zD-q%VXdMt|m84sfSPmr&op>{H7lKrbDkfPv47&CNvn&8BjPNxqK8(liN5IJ6@*PRT z7O$ff=Xp`-M_(r=CPLBSpM3*Nw7OrML>)yHL=bgDAxe~UR;h{st4^(_=mB@#=NlVh zcTONO(5Cw&;4V?aNI$miiTp4g@IYpKKWn`0-b9B=Y^F#Bs%dmq9K%Rqsw-~4zs@-D z_bMzUlPgJNR^z+<+HnolWxktOd^jsk?`gl87xUXg7Au|N{jX;x>COqsr;VQ=&~boa z4Yw`zcrNcJTBk?JV<#(xLa<5TgqNLLbsAM@n4%)M{Neit4xo3755rdij&$jZs*hs< zw}*36o?X%RrlKtEaGE;;56|hqg@LuxmB;RCmKLJCj<8WG5Q7S?s=9 z&JxwG9uUgo${rV1hht<3xUXS8qKF3xQ`y=d6|H*BpJZMddZ}a57k(& zD%)|DOpB~V4nbz5&Rcc4WJL43HhC$`p@8dcP1eVifX|E6${5u^7~W?Zu2ZD>SS!&@ zhSXkezuZN!5O;b5f4O&}AMfhBI3Of z;aCI{*bj4R`B<_$@449OvL|@!tl|lW!cAXvetUy@_{v;xAoIlWPxorROu={hhx(Ws1`~AUpQ_lHFb7v_s($Xp>X}USGL@_yy z>}u~YPi5bko8it~wO&(t?EGN!qk zwr7Mg!cd#FcsV$R+E+l=v*&qXYF){S3%PNlD?P>sOiFc~VKEy;D#zt3pnBczuiS?5 z7)b6^Mb46H`kZtp&TRrv+yPVC%M|R%4(C$fvNfm+c(&TbnEY0T9&O8`8Fi4OYsOcn!Y-8^0_+_L#@T`uN9uKn1P_y6$q9Z*eXTie*cLQzra#StkY5T)0M2nq;D z5tM2`dhaEWC@2U@8Jbcfy%UjMLIe~9q)3EF38DAUNoYy_7o53wX1=*UYq^$Wh4Y^G zoU`}Y<=M~1N*lVEW+XDc3%%`hTl3d)J#!P_k-hPcD2(m<237loFYY()T&|GJEley` z3H=X(cZuI0l1byG`U}CE0a7>{;=|H*^VPLh@hLeJZ-nK;eoXu=K@D#~p_XUc7hA^+ zmml3)c5z#LpjAD;^S+1)yUnCwEr#XpeG+j!_WAd&UP)_=ltLNA#=sdg|gbfI1uQs2S`(1h7r z7B0MSzI{5*q0;H7el!reTUu4wVAhWdg=_|(K9Tyb+uCEU~m4i*l*P=y!)$; zyyg%0T}#zVOr@9gG2t>7pN=bfhjw ziAO<`>9Jv|+!3a*OWR>t$Id#`P%L24I9zi}&!h5$ z9btGg^djwe$BzQ5t{%lSKc)Ss#O6^MD(V4ZAS_KsH; z_l=tvg-u8F4p_zGWKVwK4+qJu1uc2TN2v4M;P=K-JtzOTX-$`+4^1{ekdFDj@Q~m8 zzO{%*Lm-NBmYL{pTDRTj!gFkrGYfMx0KyKFhdGv5 zcKS@d6RN8bf|3I2ftVMmuE&*QauM+DakT$3XU3hh888L4@+`5YZv{=ut8rkg!uPYP z+Xc*kx@f1-j*bWeTv&(fNOKX0z6SwF6P)7a3>MsZ{rdF-!uyDxt}b;btgojx8{I&D z!+M4l0hlDD1Uy;lvQ3BoJDdCJIKg{X7h%fVP3to1Ew92}l2spmA6wyOzn)-!I?_2;^zL*T!{ zm|wXR4;Dt8wOpd)(GgxoqmZcIU$2FyPQl`zDu2V=|E$w2*dAwqc~q%uO=I+WnqHzu zOGRJuYM0;nyclP}qx=$R^|w^Fj@L4QcUaq@aZ0l7IY zj}0T7o<&!xq>GRznL=i>%oj?Lt1|9G9EsLus6YaNRQkhldUC5Uw~)|fj&~oUQw+#H zwc0*N?(cZx&GF z9>l#5VCb3MGjP4CbwGN0(RbprQ0|9Q!`dG!9EK3!fQF|Zx<0XOr%Qf+2b;Ly*AXk| zwI@4k4vqUcv*57US5m1WUTMoDp=IVPC55F+f7r*gj4-fMx>1e3>Hci~rT@a4YYHbX zfbVh6*25_wRg>I?b6(ndFCPi;{Gv>t3pSB+clcZQDQCpR!T1l#*xGmU(+Z(aUTlu^ z+P23(&NO}b0$>^^Flk)WuYPAXKp#?Y`X$xzVv)Ic79WO9Q#?JGm|ysSW`mhoKS2X- zZ|~`;zdV{QlW}V&So&VsFAQ&`OYiU>7+xmd|6q7garPaDoi32UrNQ&g8&GxqDrm>keo}|!S98cp$cg|v+8rD^`O?`d! z^Hl9l3oJEorMV3@hu)Ni&%afoiW7YHNN6HlE^6bByn;*_t%$|Fqr+0vZ4*3dHO^Nf z(dV~UkGlIqJe_PJvf2LC;sv4y^1XyyNPV1OMr-@pWXzQoQl~Oa-PqXrv{sL&gJc0# znLpugSl)AdQwv*Kg2nwXYRH!yAP+*vc>lhZ@~Qpy`V||0b8j5KU2H@%k+4@Y{PJkZ zdPA*w^tICmOXj5Y#Z@|#=?0zh`@(B;8>02wH~m~GpJf)K`r{sVl%Sk( zkrDkd%f*^wcD!TFp!eLM^lWuK&NklM#{3Mys?sm+4WlbMe7Wj1j9bc9#ZNa*7Pj&K zp^`^5g*E>f`fd&XF_6DKGBDvI=w_PAEE6a=<1z21COxdT_w+*H2e(_FOH5Tnx9*9) zDPz7NrFZAmh}onD^?eQk3~yxhU~ld5&-xCWhxfB+pz)~(yitI*`hZpTIgj5@Cn>-I z7z0Qto>eDWAE`AJb+urjNe{DKXE3uqJRKSZsWY{(^%t!YmUeWAouin@5s;x6oF2YV zvK3{&;8;{7eCGAVP6gwlqrYiPRI{*%bZ+-qP*1FGObzDca?9n$3*X2&(qrPt;otN6 zA*H+HrnQ5uH~H)4@rrxcAf3w+1n-Q6v+2JQj3LecOfY^Vi7Uk!$JtA^TWZsOnR1Sm zQ9jF}c|Jn_2y?e|=E?J1;o%mwi098E-sOrujon}}GQ!Dd$7TOE?{h=r+V^!M*9 zE$}EExysYdwyL~X^L(!dZd(;{Ui zgL+>357_%k8!x)I!}c@6G?IO+%RS3+N)@g%^WwI4iCli0--FtsK4=JK_}{kY0K)r! zL-MW)BVP{)|B2*f_%kmOM>qS=OR8A^9VZR0`@yM(Ym{SP0M1)N_vPL35dh9B(LK!@ z`X`(>`}?18Uf4onCDL5XiRNS%sN1tzkQX4CRq6!^oj{czn?7UxVgxs??Ibk%zGBvL zTLU9eKwx5OjdO3VhOiD}r#WYfpp$S2Cj{5hw)aHN)nNlX*{Ody|LH7_D<|5`mh=M!f?11S*K$!hiZA z)?0sks_vO#QUBr=Z>Z;Nw|dX2Lrv_7+se4z?aAmvQdz)*Mtc!Yy~@LKTxgXPr&v(Q zaMspSx)-%CHiyUZuVVJpkE7-9O!BKQ1oTiR&gi82r!ohu&i80bIZ!9TJBY?L*T#oP zLw-}N24*m622vlJzrY;EsC>e2^L3As*Gzciz>F)onpy*%<4HRf_i5*F0xd^iH29)5>slW6kz% zt6C!8h`Z?Pu3_dXGjaOP;(pEY_vb{3u>e(U@JXPsIp;>FCtv{jS~(`0rN`N_s+AZD zCupcF?yAsLzputFZe^r1Jp^^$>>aiqni`GcQ_p|I^(2}9bGg;AGYt`$Cj|kXg{+AP z-7n3CnHm?>#@Z$z=he<>t()fj=#^;oe>c6#9NaeXED9jWI%CD_P@-F+bKea&_qi-K z*M{{|57&vy5|?gRt*W%bXu#H14mZPFUffbR)fJvw=mGiDIrv8yjx2V}NwkXXL0PH% zTc4Bb!>uQ?8wHVJJv##67_VHx!d~7SN}DRpxx{O$y1X;DIj(cfq69cO5l4LexZnUPb*nU?^?y zHvoJ(*ztamjHFH>l%Z<)z*%d*g5LQaFx`zMa6pZcJOith2Rm%`%nE9+Yb7wcVDtCZ zr{>O^6WbkXnpgj4oObwCX1mAEqjaohjyRKIcEQ3#j%E=SS(Gg0z7TKoST|AjF+|@j zDW)`&wNTDNv}L$fqB8iIeey$2an@S(zH=#cop1V`)%40SRdlF38 zZ)uq_srUs0@N zneRZR1+%)mJBRLwn|f${@&RW6e9Y+cfr1gu`E;y}uI# zJ2Mq}WPCFP8C1Y0J<7g4vu2BtD0_Y+qFoCUd0pS2@{YJ!`>W=RRga7#9%YxBufGk? ze4w=$21K&2JIY7hwr_K%IXw#C!cApQF>R?EccVRbgZ5Nb%T;>b7RnoBjSo=>O6Aw< z^?Sm?l+V67lqZL)+Cx3p-nWBJYW60W$ zro4q8L2GADvFR$WmtY0h3q5Kv{@{q~FDYgv7DWl8lmWCEWz5DVWyPqYH$p*4cFQ7g zE%j~ote8b)Y&@v{3H#F%|10Pnv_d9bCSKRNT+I<>wXmzkTAC+x;RV*App?U>zCDs7 zricA9z0zZ;XO@=#2i%)MbMHpO@4?A_bKmcJb^|?4!HqDkk6l9Kxa!g1qsGfyqDZ8Q z`$6FeK!KZD>>SecewZ*?Fsu2{qO=ca4~AH10t)S0jvR2{!o$+V@TJAYPABW*0mN(8 z#HGjwmpI8VcwTK#3N#hs26iW0)j2#-|i;a>ionvEwb{MS$7zZgDuHPbIaFNLg(MIbBfA z0P)Kz0r;L$4=?abwMzx(Kk*-+F$G``qA_ze9Z4jEB4u z>yMnu3eTeZG;DK8WVA;2g8mqPvlA`TEQ`{@u_fpv(2$FFADl26hh& z;%3++z^PO0`Yz5+#d3-w0vlBYf=^3k&ApGRJY1~OdT99ix5NvEx3r~f?{yceTMj(L zzozt8|T*9;@undQqiVJy{oXC1F0*rj3bbzga&T`aJrNBS9*00sV7n zz`pz2#%H(fhc?L4NOLV&#C!V^hpP(c(RmsB+@eB;9lmV#Hul-jueR+Hl{ddTN@#y{ zMenXT3?~&D+eUNK5LRX?D>XG8V{SaueJ|nZzAUHTUw$|0M>V5s-o){vfC)ls=-p6$ zPHkpse3EQ)_BftOA#t@mcl6UMF&y7rw4esm<3a^&yHm@Yq50o5_4jLKTvzD8+scq7 zNayoV_|Ez?i2k`JK!%&&xLP&n#MpL}(PZE-JK%8R_PY&BKUKc>tce-?nENe1{ItcR z&#UI#w`ISTVcqVZh*x5NL95;|CO1*r6D&Aj@I{KPLjEzUt$JC>Nn;+hhYzoJot=zP zcw>p(X!^zH3FOsV;^O}92ku!Ahu@0+o{^FqEQW}=>TZ;FnfVQuj2n%FoEcUJp(Ij* z%zHsENFeQ5kQa=U1&XnY7CRkAxA4apRteR3ZSHj0%?EW24cAN9@6j1i7djHG+M>>t z5jjTrher=+Z{Ckm56Ew0&Va$kUkI%G=*i?i2VxC$MgbHi_sc_&sE^l89zSO5qmmyb zZlGqscmJSy{DV{M*O_aiu6 zY4Tp-s0YwP%Q)^&M`Y+#9@dO|o;>>fpvS~vaP2>D2NVt0cUmi-{i;9UF&^4D{fXw> zBpu>($g`MUy@IEJk$m#TS%7%5df@ygRnE3Cy7Nb1W0vop3r2kY9`b*N0!Agdcnk_7 z8!{JnJ32Z*T<5ERkW%9jDQW4v*PbV;>P_FMDUdfYpN{?HaBVoE@CUjrm&0TIfOYaQ zZ8|_Y+0LZ2O~ZY=;*iAhUnUF$PR&F;Iq5PNw*ut-I5;@Yo@*#HxVGxB7ZcJ@<;?K} z2ubPDgI*o+oA&U(J2Ca~xa`pz^o*24^Wh)kEt}1L3_vkb=piGnbK!ap$+?+=s}Y`} z*zehVhx~>|?IR{1J$&eQ5LLp~iarc|+(uUZ$HK|GFnEwM$qy8GHFt zf05DUDYtO&@t@VMJb^7mK)=y|bh>Q-jHFRS?z_kP>C#`g0`C!gpfycT=v=+MD+is< z-{@Oi?-WyE{MTvYravYnB?(3(CMJHWo@#fkO{F=1WV|Va)2jDn5kRvCrTG+y&oh}l zlH1(WBJV%Odp=3$l>^X6CN}CXTmPT`u83C4z{ObZuC{m4^qn7bdv@gfWi0J2FE@to zO~OyUUZ$(z%GC>y(uxa8PW!|qiud@}trzup?dzdV1C&2E0qwcD+6L3#1K^RQ;6HfY zPQ4fG0J*F5&_IcUwt#~MYg0NhKMLC;5UT%mxMhzsiabXFfJGSHl*9A!2S-fpOni>^ zl`znZLGIoe6JZHqrU6(Mhy7dfm%aYS2uUk@=TC`Eh@63`=$wu9Y_v*!vVBQG^ZZ`` z3ZnY-#e^!le_!T_kFM~&;j_g+sV(g&;Baf?+@n)s;FA z13ZwNr998>@oodtv;_?hzATdS9uf=PSijH{m@Qd2*V9V)Yb2r#OCBslw|z)F~Ud-X_fk$rMs zikC+_a5jz3N(Q<{D~En`=IFbl)b$6}?r-mSAou7^P4w{qYJ#v)Gw6lj(|7xEQsl8q z>0qF{%`les>w__dOz1*EUd;yvyT=2d@S9w--Dx2!1g0=`<-e<;Keb%v!j{|%woP!|5`$*(D3hU0Phen&2=1T_ws+$Evnx1QYhqlF|qxwdhCN6 zr7^h$``iH{J{#gyL8eCz@_mU-o__f*kB@TZp1(ca+$3@wpU(cTGU!{o1l&jbmNCyF z2zvmv&CQ4mftr^_5Y}`s+bMe_lG-+oeY0%&pjN}p}2RNp_-F{~2C_`8nW zzmCaL>twfRp?2;}b&%7OZ3hr*%%21?PaKnJ+u3P3XPyGA9S#fKWBY( z6|OdaLM0YxWqf(RQw*&jDLK7I0fde&+0Ogje7!QDi3riL3UXiA?S7m8~o`xMJ<8{GXe z4jcQ|3F4-2_H2YU@SZey_|osNo7z^8Me_0E;KzyT`bT1b;Wf{EY8R&o`@Na@q~y~T zw_4C;!DIh8*S``#^Il^jN`nI{+3mhB}BWBY>j4v+|}D#v-f7m{Pic%2k?r zxACJ5mDkT?0xS_NUMe3ydDeMLed^WH(P4&MK0va?1pMoM`qmZ?6Z%Ai;Rc+a>7rgK z9veo@H1qKe`q1(!9AWhf@dFxxO`g8V?bo+L%Asb2e6?1(Jb%zU%v$*&s~wv40%K!?UoAo4C~U33HbxDEk!y&0)~S=71LQ zQ(T}mt6HOEDKD8u9aF(#5qOUE4(q9Bhn3iuDcNi^ze=$i*CJh~CPvV}ReSsVzdvAl zG`)wZR2PcVoP;V{}T=rD%VHnfj+`gE%Ki%w1I<>6Lt?vqKVmF>dD<7F~N6!(r_xVg+^xD`S=*_KEMC(lGZJ9pV*|u8k*|4YWp}* zf}WSK-EvT~`GQB3V>QS^FDGR9(Yv$HSPdQ~WMsemL~v67{qC7VH}oI(z)1a9GWEy} zZ@pTv)7v^Uz>m7B_MOt(Pl6w49y@-4hUO#<&5aZG8aef!cYg97p*i>`34H5;y_J`@ zhqb5J4bWeHq;JX|{w97KqY{MUD-(@(>ej50D2K9S) z^k``4glK4veK>g(_~b+lUV`QbFGBr}vVmXf64}4O+Q>{`e`WrgZ@%oq1P#3;mD@IF z@7;Rw^}<=Fc-me62mCp|yIka`s0@0}yY1*Sbg52v{nhCT=8)Uc9ofofkDj`G^Z4!D zLO#jp>SaHmcd#p>J}yNg=NjJ!eU@0#p115{D4}v-aBmeqTe(mlYt*=}dIXpU4UH-* zeV;iJe53KEeRW+Y8Fctz^jX~tiJk4u&G&E8hyM4&5HFdzYyg?uXFxo7Et&_}+SLg9 zu#ZLuzdQ@(x(e+Im|-y{80KMD^6c4Fb%oRcI9bn2|U58P!jJ-oflxWwbf%a7sW;%D;GU_Z@2zZd7-dWLwB4 zT4^s+-?9Az{>)HV@PONI^kM~VZ_R7wZM#jWiDEF{QZOq=5l@+hlsoGSBlDe9wXD$< z5)|c9J$$OgEiiDYPg7KBZ>hX-bq79AN+BU?O#2`=hp)TJks8`k8#29d0_ghQOX$Pb zJ5lG0cP#2><6#`#Vz!NDNDdjKki*hB1>oD0wv>)pSLdps$^}%)qw??;-oRFIBx|mH zd9B;$VwY-tjR{+Yjd=w5+icW3zw7fKJnVY9cVKd(g2=~}zmboauRNk{(aRgGS!Xfd zwVGb`#_xXiwZ%ZzZ!t;T(=6ZcOq&VJlMYDDHcfW=92dE!%&J7MLwB$k`(Nwjp-jYSuN)}Yvr43wIpIuWz0Wrvqp5jfIM#3bm|++hSsjf`y{-V`8m<1(4ASBm`&LGLFDH+w zUwteFTaLEyBZjJRZsu0w0&%lSTWew?jh5C~%n1=Nxr1qq-8GLDwTbGoSu9v=(~gi2 zF_f=&Vh9~hCYQIZXkTU z(n50RwH!`kCXaX=GXISs(&iD08o$|Sag)=zN-=;q#PwswSeSyZCJ&WMi*6+trUp{V z&0!QBg|#cLyRHafozOGNK{LJ2mssYQF0q79vJVUhOGZEnBBB(n6mB(+MgGmXj&p7 zgNRpn_QO(UgTn#5ZlQ&&^g_@ioZJT9H_WS&gMI5%+U%Td?Lszgfg4<*>}l?3q3MgH zE_fIT)_D%y)9kfTh9q}=8S~!VMemlQci)PH#WITq4xphpoitt9Syd#Q;tQLlE}OqH zR3NjAu72~Bc7CMGMOHgg@4DT_gr+h}KNM)KgG}f5m|ENzWj>UJPgk%wNdQ(snaM^} zrT8EBpYfa2(ovc%v1r)&vKYrin5Pa*+ad4q6gCL!& zBjTF2)SuzsrCpq>x`X=W-OpAu26b_v`U=DpJL0QhPHmt^{+~%B)K2-3zW1;J9dJfs zB`IjaY-Q(1cY^TZ*880;CiE!@ehD2BMS8@eMFiUHAtsRrOwmg@lyS z!AqtAHlW7&&jBBD{7I{eqZDB(A-8W5zQcuHdoeU40G8Tbnx&g$;ha1|aay=+-Fxu1 zpQ7XWm}pu+sRW`x*nA%tg?7hpQb%P;$*;93iz`bq{*zPeAGZjJVtiDgP^oP9PiR^(@C#1rPg_=Z4TF{eoI+c&q#z#A7!XENJTAkM3(@L<25?&xhIypODp z#Ru#Q&4zmBDJ{q2>nYv%(VyV*#JrO4i8kOUO-*K7Tido)_MPdBf&!}`px2tG=Y~5c zd?g4OhU1x$w+P|Y3R8~1ZkU?3w+l8eM|t+V8l{9lSdAuKVKefmwp8#=O`h2e*!Ux< zxgu&q4iA@O2Sre6{|v_J2dAKF%gl3mBAreeJ%2ZP`vrRcXK8qNlO3H)k#{$<4twOI zpOxjZ3Jorf#AI^!ld_9pO~({BREkgsdqJ~*PrdKU@ec+XjWRg&+zSYZbvjfaG8#2~ zN+7N7Lpd4*)wY@t(UI{cZxSKCFn6`>FG;*YIC=M;(V)D39k%P*fi&)%E4X@B`-x*R z`^4MAX%1RqQnnh<#(MD@JI~&C?{-?LJ3mFlLwFsE2j4x_i8JW<-W-XbbTsdP8z(-( zNiUpMpZ5gqb{m)62znzF;-^5rG1=7NC>_Ps;O!7-=|^p8j{U$af!+v*6B;P79lP+2 zPBdsE556%iKinSi+I;&Ab-Yb2&zozz8BAcvT5W`^L77!0b*Vhggq%*`PtqLr%TWd|cH zXymNZaLBS~GFLEiCA0A$!Q15YIPlIed?!xRsGd55g;SA@tEu>ag$N9s2&T^W5TW*Z z5y1rb7J>>lTG4SJj6Wd>DEW@H!5zBnmIivvQP7w-FUOa#QF7BH%KWW&hAx8~3TyFW z6-Eu@NHU(1wa7@@U$&?C7^&xIN^K+sjr&@Ve)JcK!FP}rly&F|!}9(fcz>8HVRvez z86v)1e&<5BDZJR0dq4wdLU*{cuqi%Gb-P-T3M)0mlR%BC;A zZo}4M{hMaDvA&S1@?LKhf$$wn&qi>UruVw9(Hpj| z(8X?qtffYkp&rNn29&a&jonY-0i){No+#D#%MQgQWbHIP*@ME#UHCxC2C`wPL43fl z9B<`=iTWvzVxrq786+HbK@LYGleV^UFWW zu0-6u!t*T`Th{swk6ufF%gb0k_3FDLF?!E+ClBq1!Bf@2TsXk>_$c?LD9fQd#|cj_gMvh7caTC{?-h3u%TTf&o>2r9#UgT^er476n8v@~U zeV4!4JX*$m3w3Ba`yJP0WTMfW?lZlBn!mOF!ec`{foMNH>i4djAxi`|B}`Z_f^O;M zm}OG@^b6v9;-z zn3Ii>Uby|A6ORpAzFf)5lnF1Yl%a32A`E=vA6QJ#Mh=fuQ(uKw8c!eL7p?bVJ)!Ks z)q1gL*|!L6u0hvAr^|onl8hce-PUe_URwa@0y99^H zu$}RPuRi0^4rfLjO2%p5r(M4s8kpN3{>VhT`QaxKZv!c3EXzmxq zpCS)G`x1vbwB0X=ooZekEz;LvsB$rD4D&zRtsq`QsG5cWej)I*mCL6>TXgr6gDCfE z$i!*b;om%4(fak^XA_D~hye=)O=-Tgd&Cpeaqw}V!nkSb>FNXvohuyrpeS+~Ml5eC zM+A{V2c14q_YqmGVr0G5Hn@Vr3&`rc4qZ>+3{Ep>HKeJ2^x}vY#%@_3!QL<}(sY7F z;l)ZvDr^_Gbv7}A&uQp_6CO4tZrii*oawlc*~JmR$^0P7PLmkLay7zeB(I{G&GxuS z)rjKuSkss^Tzq>qEaYL48gg}HHfpy=Nxo)lV6UOMy78iEfPL>uvJcub7) zTh0DD-JV&Jf=JNV`pFRG)!4Vkp~T~^P?Ocq0#N~_D5>o_}5kZq?zL5jeHh6ZbhR11Mn3u~fE$1e>~|oF~2; z|7&+&bKe1)PEqh7ZHg{GWC#^wK`R_DV>SKlX8MtgqkE&ejkQxcR0+SG&K1=D{%i<` z%gNG4Il%4oUbuvIfWMjp@ht%r`f-=pl&12uF1VwXbLNSD@7 z#c#J>X#+l{gOhxlta#)dEIiuh#NKMbaf@mk-gsgal#V)WK}#j#X{Xn98%e-AY;U)P z0Q5bV6|Nl|v(;Bb-j7%X`mVG<50GLIq8?20%!0q6nxMUX1!Xy-g1?Fdj*lLJZy7bE z-~)YE>!$WM?n0j+(Mo>J%-qesK|1htfu=SkAJ^67PEq_?l&(_%b!p2JQSWQJc+PyM z<2y5@)%8vD#FI7DD5>!~BR(r&bVCh(@N62=_Vb=0b{?LKJlkLI22*FLY-X_axTd)D z3-|Aj$UkX|8WVu8&w0Wp1fsr~!*2~&M=z9(;$>&w6rLWzmjz?*SIP~cp#2Ye}{}1rI^jOwLdkvv`6! z4~}$EG+<_KLhnd7(J6sWd+Nv&MmIh$ujnIAQ+lXuT*F(;;I$a^iGyeQ@m>23%5bT= zv2hRAbV}ejaFlrb7lm}#uEq}HU8z2++ii4}#%^s~O_JC*+H<>|X!>sXm5iY8;t00= z4&-syAjc054?j2$=UXlTN#?ng3XGaBel>Kg$bu^fYchIMuG>+DzHxtAcfB6cA{a+j zdWzqAV|zR=Jz&aa^h(2KPSdyh0A~T{TEM|{Xh0q28(n!jvjusyCe@=svt`i?jT>pY zlkxh?B8kbB(R1ynu@g;5%7R_ky!@zpyqNz+%H1$K)J9rXzJ%6Y+4%$`S{|~UTPqvW zPQB9Vb3jvg#*b@jMHaFt5bT?V@i5<2_Uqh5Th(xmgW`d1%I-k5npi@~{%f?1oXp~? zV%1>sa20NE;BLeA_&_N``tFY>*wV3Y;?X%u)=Qn&hX2dEpV8YqIv_u*ePgy}7u6@m2 zWl1{j0-t4i;u4#4`LF#De2Qe6W1>7U&^*-VW0zx5++F4A7XyjqzSYz*rr&{81`>4a_PRo7Jn|0N@1P}v@&d1XsGWGXEnk>iz-km#{OzpNx=hMBwFewv0SzEg!sL|Rg+~P9Cu?aYQxh)>&6DP9u zko-CCW8*VHsp*akq4UkRod2SH zC4x2!S5Ud8XYE~JC>GscB(A@aX6~9f#Ht3VO@0B9xim1Tng&DSSHk8$NZ;$M1ifnU z;A9HZeSmCLeuPX2&cCT-=vX4LbN{q^7oWLSW*mDbGQb;_A&z&cyd;M+MCu}s_xr_!+Jj%k@p02a zWDEIn+AAxw+0-KQaSI|6&`xsh!Tf33bZ)*0EinW9PZGbaG(SQj$p>SYhbM?#zb?Tt zBd^T*CNe=&y{1l%`wOHpz5*axs%Lr$QD6m7PwA$T1GO%t(BY9GTf_rdNHKQ#L`%N8 zsCOS_IVh}o9K`iT<7<@U56;5}ajVAWCwtWqHcdRopBfY(2~5xs5W#z|Wcf)9y=IP{ zUSy~4M~8;rU+9*^FCh>qkL?B)az30-40YENllGNlX_N}uE!SZ~CIN6xhyFr|*) z37g=PQ+B78FY1_J{dTu+%Zf%PmG_^`RYw zD?5T+HX9wn$o&qZ#`P~^u(fs_*m{WnZgk+(71sbvic2HFwX{AJr_(KJu~le9z6CxM z&`(U)=Up91mwarJp1f?a3y|M`y{qK0JDd6sqBFn00>E+4ZgE$Sf9e+806^F zGhn#-J6%8&wqZt6dc>^-Xp{i$5Xw_{Hw(k>jgrzy4YL>oWm6xq`=entJ5D=*3;?H! zZ50;})>)OsY;y=87o($kA0EL*uzF?uX9&n>nW4UAG|I-{bfzEc<{pmtMD@bU>Gf{K zu!&lV9};ZmZ8ChRV=_d;7c@tT6FfOXiz_fU(CA2z37?QTnKkd__a4JeAE%5QSji&; zEoSFU#nP4)KdCg#Yq{>OhJp71=EiYgPhl}VWMVa%jD-=fiNV;bvp{mjWOO|dPbK5u z{<48O1=YhKS?rXlN$Kh#6j|RB!uqy(eA%^cmJZ6%L zXq()&pE0d{kA`ik@a*l~|~RiLr9dwFwI+v^)6rzUBr6qULi`xEDOB6u{~z zbKz3(13_oX%F4p(_zyPgmTs)yJN_JxSUybG&WaPF@Q!YB)W-o3r<(g&Mu4Gfw_Ptb z)qmm+>xqPHiD4(#LGg0eD(@$`7gd#gdwDpJC8_yN#`Sb!yNZo2> zj?7Mt=WknV0hAhj$Mn;!r&oIP=t7i-?q>;}2CfXmeNB7T&x0QzRW9dClI=db$D3{K zg}7A114n0Dcqpr3N}Cx#T%ogVcJbgzG*Q=tjN*KX%D1A(?yPB^6NQ)_Q+T(PR3$(* zBTC(P+o&jBxjHec1S>W^9rppV6f`|FtZiJq?%$(SDLscRoK8X4J9Z}GLbQE56VsTZ zq3X_-E!|@KkLy7FZ1hIOP7Ui{bTlyU^&+cXWZgP_tGUA7?f^hTz#D0p=mD%@9=-WT z2NQYLe02?o$mbhsg|>`8IqO?bE(qBej5HQu40~M<32UK%?u9~ZV|*|W@X0>jCGS4- zJlqONQ~iRiCViF$h~vc8T0nejr2{zMC{BVwF3sFmH&tOtlCHFVxsIh_?8J(H57d0O z@2%1Z{_sSteu{-9OF2|_rC__eD|`s)av$I>*eI1EBk6&3P$E%n>p0_5TGRxuP+NI< znyWL;SFap8(Yl7Jw`IC760hmb%4mdqd_xzRjgh8jdTDF!VR_**aCcYKL4B4G>CVew z5P+I`WHH$Zgm5+h0!}bx5`3xQ&@%+n#|lPVB2`7b>Hf-259Gn?rR^m5?2~O23EE(x zm+qYW?tT-=t#`6U9?$vKg=iyzW^XOuLkA`3lL=0KKO7jF-%D5bF8k7v&A}=4z1%;p zWz{m_<@Y<$`<<`NH!}|?SdD;OdkabAU}Mmrix16^Gi94Mr(a{tLlj?lsUxylmL7~8oqJB2dgbR9e>3IXk=hqVz@1RxcdtC z+DlOwf+6)YGe3V@n;|mkRiAR@1x}eC>B;sbY3zg$MGz*kMVC>YlQEVr$->SRr&MX# zP-j!@u{%?lhbUVcYnmTSBIYt1MM)NhG<_JJ*Q%x+?Ax=Eo2*=4XzwV~ z0gecDZx2n~GqMQUN|tn7hLb)s>+DakpzXx3A1uxX(^wUK&k*yvDqVT!jUfT>^aw#d zH#L_|MJzHY2g|2YIWDu0;rMjuum+}(3mX|surCM|$ zO{HdZKFcE(q5`(ynW>#x!}5ME#xR0mHO@tCdZ?~VDMwD~{vHYk%_A-)1$1vjQH~#o zP)YS@fM1Uoxle35(xEZ{qa~dNL~=-oO7F#iS%q0yRVw@8CRZA%Xr zc9utPib<#WO)Ow^*pbCJg|fBH5(K$?ph+=W-q9+{I5{mXIy0Yxet4}g+*1sB!uRTT zkzwC%!cX_Hb}($TATQkwQ@!%Y&PP+dcRrWA%v%x_nda@U_|xJvI>-(`vYe*hc3Q)= zb~>agYxMtmen@oTawx@S}jVakFF4xYpi;B89we|Fa!xLqhij*9AzlU zC=3F>A>*bZKZj4n5z+uy5K>__HO>{~-S*@8yq-{0=G@rxTHe#r zuI5;WN=Cw-i@-Hp|3bRwa=UF>rTu^XoB;CsLBh%~8iZeZsoUp5(vh?GF2cE1%C$hM zhdGwsISyQ#=7I0Cbs5eU;p>WY#gHyP7PdMHAG%BV0aw)?@teeO8sxz;9fVVWT!FSC zc_rs6KPq_GDQpzU6fmDyBCqp!+2~Md$+*NSgO;`e%FFHLmU_ApLL?ql7B>2loQehs zcSDwzN9SLviQsD7zhop4&7iZ`()=i(LxP$$p>WNnUS1pplE*qo$)f~06S(Gl!&;Q< z@zE{1&w~R{A8q>m@^C3i66g`v!^pPVJ|Behx)&WZcQ~%gJeH5n28dbBh$?utOd{M` zx9|;FID5tUhPX+=hMA#Zpf8SQI#l=kiAk$|d0)=`Ju#fm#87MU+E5hPQ@^V_w;ytq zu{+>fs{|`-=5;loCwlh6Hrozen&*cL$Pgq%0J5*X0KcMW<~> z_7o36_jW6pEA>7)wi#Sd1#i6B0D>=C(uC9$`?T^5Iscgxkr?j3tgbuf+fayPc$SB3 zu})%9Wk87neXva)N2~5lIoF~zv&3e*cdcD74cX~6+utJ?9s6YpqEGZE6$}nr4mrk54#J6hT8ANqC`2}9+13#05KpU5UIe?%cwZ1e5aZrtS11X z9U1!2l9#-8e7XwsA$;nzkl4ul1kEiCS$1b10*P+${Re|<3}KL)>{y;EmI-6oLjGwF zS{-3cNSs{P!@`cgGkRwy#3FM@o~{}^mnwU=)6PBFAd69I<{q`4d)pa zJEeZGxk>PD0ga$MuW2{y2_>hj1nzYQVF;t4%>2Y9M4FNWOB*EqbCF@R&JSVoF$+e< zJ9%b)maHzEj4dvC=*ezW`38YZXOnqf=<$D!huZIU?6l)^V)U8gynr32j1r%#s3${` zy@?-7m$WZr+Zz`p#tJTZ?+seiiwnMu`@ZC4dGo$JSpo(9?vsZl5Ci7lV>lR!3^D~d zug{tsUb&nW>eb+U`Z&GwU)n)?GBU#r)@>R3CUIRh^|Dy@(D5iPy25^dpti*6M`sVT z!)hkEWVo99Cs+~QMp3a%t8v(RBoYyi~|ol_@tD;zzqEC>gV|ZCq>HewT5m{e`f#`)#N5a zpIL!F(+2@Zgcu98?;7KpMx3hgOm*}3@=|>2?TawoLy;P>#~~$p9sE^wsQ(V`KaykX zgqPidQ`R{8jcYL+PLICVjQwChjlRcnDa@3m7~a1hxKkv(RYxWaGg@ceojwuF8!_>4 zvXa?QVp$FZog^wwbE!*nrB_0%QN}~H8xN|%|Bt=*j%qUd+J+q)I?_fF7^;paAV^Vq z6%`Q>kX{YFccgbgVFUq(-cc|VAp{aS1jGnPml`@Koe)9|C6xChIO9Ce_k8Pn*Lv6b z*89hA{=Faq(z?$x52n%D?uln*Ur{r;1ui z-OkK?(Ey2apKugul6h&ibj8g4d6V^pNz{Gd7ECKM{~`j^*;!Tqxq2jnja3q_#})@X zgRNBDzhKX7&I$W4i?-Wp`|J(k3qls6qDOkRwKA`@UnPrb4`o98;+xCQlO9}?5(avK zOv?c&)RX8OxuHcutm&6_f)^egB7W!6d*k`06uki1m~^1cqSyVxyMTZzw<5$J0> z%;s94?p=Ge*OpLzNmq9;Iw6<3lPWw^ESiW86ndODM^D`;n#0u=Ho#QwQHUMjSbT|+ zo~)8MhrS~!q+|-3M|W1%{=~H|hJAZrUS{m!P)ARdGo}rbYH1l< z5r}sQdlm*t;c@~jVZ#cs96UF$t}HZnfMoYw8Wpn@GR#)&af^Kp6~cUaK;zA3ZK&Ht z{_V75%a&CnG%(0+ubB_1!-B1l!~uI}+1(eHyZs3AD7glmTS42o8D3+hqK;mb6ZL+} zuKdL+PGh?-x1ksMG8$c)+M0Qc{qm{y&F)8oq5?Um^KWi(B%aa?zzCUoX7hvRYWxQ^B@xg$J z%&%5VQ5=8T4+K7e->_vWlLYdyAzXPJ$E#_9$DgVgsQOF}U zhyX3Ca2y5Es)+N%zCeQ*InY3Jy~>{XII$=|4a${$D*~o7h}6QhoK9nv&fR1ET6ehR zQ-ljSo0$_1-@#w@eM@1;Vmt%#NeS3WCM%Jqlb1zIjJ?H`kxCZ^z(Rf0ZiV!-3%L8l z`8n&kIF9r*yrq5dQ}M%(-L6DjWdorcPSR|LqfI@1R;uR#s*kS+xI}b&3~4MUo|JG< zhLbZjD96o~o>zq}H=23I=ic_QmieN5joQva8wIFBJ^5Ao@&`InQM)fa`TKCzXoOXc zgn_*nORgNPygFl8h7(YrF}n&!Pe&Ctx3qkqS)~QBCKhB&o@-4E#$Mwdpo798n2gEY zE-x9Ze)ryjg6v+O>_K14>@nxhrP0g0>9s7b$DgDs?cr!%v|p5$?qO3C&{AM<}g zGegR94M8Y3UgOcSMnQIoTz3(+=ntnfH_$>3eD2|)h7 zkINnYw;3s?xopabs6dHH)&b{?b7%u@eOW>J@Scu)l2PBQt!jI@GNkJ5_MSXrq)vmW ziczMjH(;==*z+=51#06iXe!ZhcTKiBzTNT3gK?UGh5LA4Ozi}a;L9${o+2&S-FLAU z_{C;XZu9q(zs13P0c%Z`d})Y#SX8v`wqzo-b13^cBgwY7CLZgKvPZMueSi3mp7lA zn>McFwVj!A3W<}e^y*5%#&JZT^9N++>M>Y&!{KGPcayra^z`rD-hF`m5*988AappE zEd4y;&B%car>|I+(7Gkh?>zxkhECn z1AN65L!=IWlOn>a`<=OTBQWW1@%i+ei8fL6%2>7LkD0MibgFsQeV)gDR-?|VTgyo4 z=GrF*9)qABO?&&^z>(2%?8mMQqB3-6xg}jn7GqaYgZ@@B?&LL!s?w7DR+rb`42rue zohRKzq$$H=#GN-By_QqP$02vrqjDCeK(VZ$M09RiC>X&0KDZJ0v%0g2s;X5MD59ak zjFQbnN-7qh1Xx#Vrw_WZ!^68=5jPu4SmCMu9kT;d#ctm11Qb%zlf}DDlfBkwqXr*1 z-?dwy%6(p9ybOcQ8}OYj%Ign7B}|R_QFl24SyvpNfv|Mm3@L^ZKnT9^Fx@w zjg!o)X*Wi`2j(CR{^pV#fLC{()i&!B3aFZ3BU$Uzx4+WMd=at>9yN{cQmo?7hZ0)@0-%b}m{Uf0_KIzc}?p1?fMdzg-ze+TVx>Rf4jd zeKzoI!s(3zc9XBlWIg?vYW>zAD+Pi5X3}@Ah+OI}8uV1W=Afqp>f1yb(G>w3mc$k{ zi^mL?%~oVkYOI5Cm0_f_mFc^bsAa-gzgz=Xai67_j2&dhNktCg+OUzVJEg zc>@q6GQ12G`g0HU&4t#}&ouqP;#&y32qHb0JP3Vi?pAcR&E)vk5ScH4+kk;B0x|%97>Q#!WNNPg;NzPwL*wKIWIizvqf5t|n9{ zK{xTmbzHAPUagI=j?(NOBsqz@;&%R()`8CIKhru@p%2{wBj)(A>LX3#8jsG1k>-Rg zRw8}woUeKLTLW(Cm1UI#F;M61T&UB|U%&o+zrQG_W`Dh1cI}l~-EOCI{SmC_C_9qx z0|xtZL>6C_F-0~OFtD?0echJV7&3d6!^?gB=c8SSnTrM&6sC7js;S z%V|V*s=hgGk9mz73gTj>f4S&=J3Z5OCBu;Gr8!hg|Bil4+``~3;tfuo;nV|D-y%-$ z;dTh2*b9YSDuk09D>Yu$dv%Hk>dq@sI7gc8W770VmBm47b0Vvz9Nk03G2FJ(XpNWH zqc{%RTkhTBrKNjCkstC7h7>1vI+g+qMT+&+VV@-{*(1JxyAZTq3J}WNG|#TiGK49Q zswCW(pef={TzZ9@d|K@$U%)g`YA<1UCkhP-@@~h~BAshC8P!}Cp-J^SfEpVpgm{1| zwPNE289d1S;r_sLzznxj0rlg3KqgyHyi|EPQ3&USL3R_ZLoqcOka^-Ge;X)xxZB-iZ_}KS!iE$cmQCZ4t zv4}m}H?ZHszMYc#tgZWWt1M3%7pu(YgJzy^0UDp>k#ejw0I(Bp83Hv+x9-h^=`C`e zaf0rKE#GFQPm?(~HIqNXbmk33$4Ut=UOi*?(|}9zCVju<#X7WBPE-7tV!ZX?*0ObT z9P=o~-$g+5pwk)8m{ugc_{y5B9ivO-!A?s!^bYxDu4mrm~9JTsSCfw@MxMLJ_JFaZ|B6{e5WFI1MSBeu)Oz=XVnU z2mS};ZZHjSwl50ggIwJ}gqtPz08+nj>cfCt19HK;PKfl9k7!;{h0$GnU!5ghsb|@U z*eppgH4S%tH$%9MS8@hraD&@8aX# z3=MRC^OOnzxeZw&wc|omXA>Y&j|*oxm?zmO8B$SK>~279%q&rTOF#fyp(Vi5>?*)W z`4bPBIUggr(T*9HTG+%7`Ch4I3zK6B1HRp@sKyH6Ilq!J>d8`+2;enP>eKd+d$)Ic!I0a3dnT zeJ_=4a4p)m8@}3=``I#qG=)uGk?u@})6rDNJyg0@tOagqt=R%Luq>1|J`fjWApARJ z*!YCW^2d7`5mu518W**vO}1tpK-IBjHAti>9Fvvl+*u|W3UQtuNdTvh9LV>7nt;Vo z{V?81Qtv~2)5|JsT5mTRRdmcCE9XT>gpGEf4v*WJ8MMmG1O)ik<%eRV|b>a$PrXGcRv6@wTxG41C8b-;+ya zKhjA!{3f76Lbx&5a979gpIfwa;(LWMvh=HV2PdvjkuZCcXQnRs;*dg%LTmd9WvJNi zU6s8*QHI^N$_ium<}hFGu?GATme0_9S!TGA&*Fs-jZf8Gh#8Uu{D|wqdV9CbQAk_^ zF{75io~#o4z7OXikzwjF8?lk8%f6!cDa~^^WyBZroKx!XwKBg9F6MA)V{#mE^vW6r z*HxwB5GeVlHG_nyRkCOH{qk>7C~r^aAqSxk^Xat(0OcK% z8DM|C(%r$g*=OQVG#C}uQ}0ZbJ(pRc{UN?va{IlI3Vy`%Z6*h25fhfGSBEnr4J+@; zbjDP&6rc)e*B|rKugmj#L&ULP^Ttg_mkjkqvXSIT``h7!GmXIFjR1bofaU|4D zL}nZrByldgPtBmu){ADDh;gEIT+E#Zystb%24a?glJsJAh*#n)%I9l(ysKJGXY4lE3<=uFxaC(ktC5qg)t*qk1>n~S*ZKPUn#emB zZ~`~C`mRt;n=%2Q22emm(*g}X7&Ff{G1SpZg&lxbMhhafC^`P|hOd#+JK4`fEGp}f zmOUq-(~Zz&SKvSCpVL)~dB)X*-o! z4L-Aa|B@c{Hm-i^Q+t%XYTV#s9Uq?=u&bY-QJ1YgDl5FrZ`@$M(?OwB{9cD|d05_lRGX%zC(B51t~R%ujo9nUa_=$`$k&byxN~8$J^-)JtV`95^`q%h z6ZR`ts@9+uDQ51@4OnWw5O-;DkrQ@kg?u(W7{Ccndn}3WDXH!X8;E+ZK3V1|_3C@t z%2=wI2iTuTHdxc83I2}^@2Ub6z?Fx2x z=1|C9)>RxrLwb#gKF9R*G)~?WAYKwI)IjGo@x|iW+}s>!xv}m!m^BXcG6_o8BOY3w zmdH@8es>M)2v{c&t`Nm@4(8cp7me;1=h3lJU34Qx{r zm7r20ozI5+-DR#Eb+DA`3}$gCiU_8~su(fFJtYtiruWUr-`mb*E5vl+!Ua>t=$M%K zQ7xd*As!s=ZDB`ogpQ8Kw(5gfQLQ(?3ji&4^b%34Yz_ugIM5bmc`3AMS=ew%tbvg{ zirY$OL*>}2MbbJ=1UaeD0uk9dg$WG5e({1eyQW7idnyb-khQzo3a5iH&*rCzkaph=6 zTAJU~Jdk^j8WTq_kbtcLAIITmpv~AgxW?qNuF;xHy(Ibj(brpJdLy#AqNm-ejbJ*X zIM0U3Zb{I%z(tJ!YA@Kj&PM9vdesevzc}2jA2Sj7G7rjByyPRJeFZSzoKRbX?R>S% z-+`KJr3TvtdR*W}D;qX4@cx6y%q^0RCNF3&kA3A>?EcoJwZC7hMDLP`zrPg!08@)A zRHL;L(bd^Gd;JXJ7kz6KBqp0nuZXimE9XkBAxsCk=yUY^6vcXWDKMg8jZUjOS%F2I zUsmduE%|GwLN3T0EUL}_hD))|^cm3Bwd?~hPtv3>7KR;!NwPJZCVk*t*H|fKDtgh% zIX{z)5@CER4W^CfJV)d@={ucnMRhRw*kX#18U-^MyQW4y#9#cEG_z{Hg)uwTEaqM# zGy^UF;R;EY0uq9!q`oDQLC&P-28U}R%$g#A(KuF)Dx=Wy`Z;}zydHd)>A&0`KqE0l z8Iuv&Hek)Vt&!Er2g)8Mcsxns0_NUzP~V!h$GAWX0=hi~O`T$Yb1ZU_b&EBCB|1BG zMxJHio4hy*F1k4gB#1Lo=H}&X(3KC^S!O^15jnklhus*av(a0;TRikIr&NoU@C)Mq z9Z$J8acrkMj{ubd$6O#)21}_uipjqS0usbwV1q0pWooCD%#~WuXF*nhM={o4sY1&$ zg{sS*Azleu*MaTj8_5}|4*-40)1UPl?ph6HNP4xAYZQXnZvnojBc?euD~pB!IMzCE zdp>)baI};yOzWo4d|Lt!kSs#x%Ez7Nnaz=}c9W%SJNGtX&kQF+zn|Jp3c&vtsN+mM zxs3ax>lh{$#{0zXu#o~PAwc<%qp6OE^puZlwPF~5D&ItAvMt1QmsAAGBio2m8WJ-lbTf` z9;O4wY-EBHq!aAMpy2T2^z^#9RQrjwXs^0$6n-3dnWce3c-?wiOu(`^v#685*d!}? zslMHAgOK)VweaK$m?m)QxTswXDFRB2^@EaX2aB8@J&BXp)n{cj<4$l)yYeMU`q?~h zR!G}azFqkUp7-WH)iKT7VBzL=Tcr=QQC@WaF23s_TH^`CHV3HuIy%0TG9xH~ff_l2z&M z5i)({{X%iQ^8@;u3)mWlIvZ3ayVQdwr7!Fu%fkHpZ)n;JtE@6IR5|r1P4Db#Z23yt zgEPf{(!Smsa`#7UV5WsH2RopwwJ zEmn-d>IV&`B=Mi4j~fR2xNee?v^XZa9OVYLVsthTry9RM#CX=Ce7BakBCM>fk=-1M z>pec)Ltrc2!ud&$Y3L6HHe|ux%p-S0K&y!sdX)kNS?ti_^x(eiC< zw`lR4wc~85Lu#&mtxn-A^n4zHV?je4G52QcN5m!~*^i;FHiPAQS8A z=r|qu%@z`JWwJ5V0|aYzybhjV3$U{_6dP6FW*&49*+7?rh$YF6VWy946KvOG{Wa|Z zxpYdZyo4uD!vJ%1E;HnPVqudhI-FzVqoy$%cH zU;1ju;pJ^23c}Bx4_4SSpP_SI(ZQ7!fy&J zsl?X3zFRvEA)op&F)=N!>E+-`%tR+kGysJlJ;LxupwkTUA&5C7Hdx`qd+me>(r8Y! zJiRS0o>I9URje$!j(}yTT66n>+D;HRIMbXB^$&Ll6iurwDS0z#2Ru)SRE;!*pKO|| z_c;nMSY_be!kuPa?dml>78#58k)yadW^-cXx}cAG$YV(K6=0@R?S6?{IP%L96?$!i zQak5d#Ebyb(o2uIuCG=(3fz*FDc`_XBoj=gx<10+0vG&Mw8bOM<)#p;3n;quo1XGjO0h&lvqO4lNES+)l6fa*d~)S?Qot3n-^M3)-*s9z1$I|Pyu z0uBUNU4U;%Gxb^-_dZIL9Zdh9qYcFV zFm^F7D{wkWw0`v^e;vT$WuvDxfnsz=mQ2rlr1`_Pa#X>6meYvpZ0NPU_E|T=FwT>G zX6G@TJUD2XpA=|CZ=Fs8x5#qJti2L#*zMeINZ2xV?~w=hkoz@|x6wzMxEXtpp}2^3 z7??6zW$F9Pwk7CK1CQ#X#%G`9-m9o@4(4TdXY8PbAC{PsoIHfEYzJ1vU$c-6$TEP` zBS?WcNkK}Ati6vKLn%ldVjFOd&OGZL$8IU|{jdY*O>#AQdc4*v&oU5Tc;7c6JVTP3;CBcE;oo2M z#J{xV8}6LeX$8|O&F)*YXoo!O6z;S_8o=1HA^1=x^A0f~TIVQ#^Lq={p7KF?4P z*{yy}3@;NivtRH>q1ps0vBmds)Vwv*(URcc0lMdEFe;EOR`u9O0kUAS)VyUB^rMRj z+Ml*ft)Du>?;Sj!PlD0&cXY`%Dz*}9d@x{)+wukbFlZYHmqiULonRO&Deeqf$_umu zL+g|ucdFDVcwy=dLRyPUAQdeJ+@;5y7t&OpcmYJbpdKde=?%s8*rd7{z;&4xX#Gmx z-QG5*s-_06W;mP%6`rI|IuXN>;|POlERrUAnr*wv3b_kx=?Ii@8ap){fH+u&g&L&D zp4*=;@Q;<*_MPWUe*>x)yClJUuXQ>HA~D$6awDXEttU+db)1yNyD`?;O^O$$TIL?_NO!=pn{c$#-H7oR=x*l7M8&F3+On0`fppb2#ikQ zR)D`8V;CqpUD_5ru2WIKgmyxJ`uN@b@RJFK$I-}(@DjZC5?Rx_dPVxhGI=irQ!HM! zfUDC<`*)LnYZYV@NQ_vt@kT0UCMtZxhin^c=h++xO!7T186Z0)GUP{mycXtrY&idv z;{WaVq=v~p^X}Szuhsv*>ld&z4%5vh+binkV*ZQ`mgq2(?#%G*V|V|ZqcK&uao^ts zGzU;NX4=m?qLcb|zOk|aHKw)|D!$P%RWTa)_OgiMubwM)+qa_?8oKQvm+B6;atOb9 z;+O)$zR_$(P4=yf(-6s?=tPrZ2;QGFIr&_L6P3(P3Nja^c3Y2IC`>h0IioQ1()>FK#?`d}M<;UtK(w9Mi%e|JoIj$>B#wm(+}LQOIg9tzb?H-)gV9TE6*L-7Tr_fN3}D0eYlceVDG9g> zhv=Ylhu_#kT3e@@_^E-8r)OtuF)v1B^=!EIiJ>y?q51>jf$K_P-}&r?tKDso-Bax6 zife9Gtu?C?_cua~_nW3J!^IH6cL^Ftvkj+@wvVDK24z-U8zm>jZ@R8VIkNWY_a z*{jgTg@Enl^Am)MsaI+&TNc>;F8t}NL-$ooP=NE|P(eYDJ)ne1b>)BHv2gYSrpf&| z!6ejF$W(S@2+)d6#VSY3OkHFD{d&`I-tk^cR9r`eOFbeL#7`bPT^(wP9s$m9Q*Twz z96V|&j5(wbPOSv(ncdm3nV-9q#kfD#9kmxT&?pAK8?&xUTb z=j3aV3+w~dGIx}mkGhY}tIF&qPZAk|e)Hd-&O!H)&Vyh}4I{!{b@v&2OkkGz;SxLq zgg7fx9<96cF@%qhpn%mEoMU;iG>~VUSuBs$f{bH`S9l#Wah?hi3!YX4m=2)_FX?Kw&aXYczZfd~120{<;L z^lG${T{>TSK3#p_<@H+6Gijpi;&XyA;%%S1{jIbLrj(6q)G~}nUpE!5<~od}F`I7g zNgT?PcC5~t_VYR12nC_~)z`ASGgFC%51GAVT(GdlSDX`m)t-)^K>*jAgUrKqeuXAe zQ0&yh_RU&m@Bo~tPec}2TNP)f z3{h>q$-E#jDa683sCvQc4@J>Ym$%%v0U$fougU&t=eQRF&EX*)Fa5I_!Y!YbX9@|Y z5e;~5qA=n}5^*MLBfZC&G!dJopyoCI%Ca)Vt%H2H177}j#||l6S&vhjTA-WzLLdBS z55+8ywcF7n(oJgBurpBEAbnG0Prwqc=F`S?z2h*DSQ*+PE0aGEBDr#|xcY`S-cLbN zx*K#!fF(*3;QLCegOz6sb)pDyke~xDm99esX1~7NAm>zL;2J~d5n+<;Q;}%hRUkf7 zz$YA(fY60Y34{g;+#6w3Ig>t$gnU_odCr%eq(IxUGu|!H>e|mqXMk6bm%9MwAj9R} z>MJ!+@bmkA4|~)}EYWXKIW#3@iv7@3Ym>BCC-kUWZTe;jxW9YJ&$#HLq%i3xC6&A^YLMl?$Mivk{~m3Utna6X*lLT98h z$)~9K8LR?TW7*W!`?!^jvJ|dgyCir(M-^tr8`5So(X3vT8*BP%hls}Sr3S-ld)7hp z`-9GBCiezy?h@!5b|M>jjD512L>(9{5yN+mhGL@bO~k3Oz3e%fJo3uAd3rb*4aAc< zXFvg)iP;}RwW9et_-EVJfmZSQ)?|9&<88%|QD@n?PGS2H@VIM|;b@`}8=Eg%d+6_% zcn|xC6k_+5KzE1|9=MVCh(Ovwz$DwgXAfTdHYHG?Q^N&Zv^X=|?UbIL^$tGLKKJx8AL!!oD~%_h!ieg85M#AE<8f9i9cT zwOzS^=P-U7`3qY9o3w(wHvKHF=niuU$PGY)a4RGt6EI*~?`>1dNq8pfq%Jws(i3Uj z+41%RI$YaSpks!>lSIQJTkJYJJ8$vw&ftnmfa@O^qojl2RhpI zFQ5hg*+_9)#xQj{fF{*Fxm#}!6vhq~m7|>xt-Ln4!*wryu>x+d=&z_&;>MYcOsN+? zqQgh)DsbD>xyuI6)ag3Ay5@*_fbIi?s!pN)waJTVfHcW1Gk{HH0&FGT;qhRXB)HU4 z5^nVdKx{1s1IJ@fiKQq2ND{+!#oMy7SxMF~okD=yHkx&$dd$`8BMkxg;_qLlbrU4X zCW4?PETR_Nd1ibI-*MLBf|YsA_zFn8f0CCo3byjso!{0Qd57Ww?7GZym_br!2h&v z?&=IyS6A1)zbkSDTZF-?)18UjI-O`oXW<3ndJ$>7tjpA0h>$11SPef6JIwVZtz9P{ zY0*fIZjI2UPS`Hnkd#BG-#WT{UFl?Nb{(ieMj9$#Lq3Fz2xCE?F(2zdM%@WAeBrI7 zs8gi(8}HnEa6>|YR~47NyF>=G3;OA#Prk1=A+>zNP@OI+Dr$DuLBy*dsDPRrihsV-oAT1eCz__{To|#=?04qXj-E4AA515+hh}U8g~4Y?1Oy{Wy-+JwU|=z6IEC>j=>H&bn0t(tyI{ z7FE}!(IU>YShWr-R&rhNi79nU_s2TbMyh>ffIK51$GpOmpGN>?*ABf|4BkirZY^=( z^iU{P=5)7|9+ud3HQY_zO@^Y%$e$T=QL!E=tfma!DwDKAwpEcSK%VIP2`~a;+~IC! zhZPdQ5qW*$z^(>U%0vCyn&w`bZ9u`91^JWwjH#Y$pi`|+LU5hYU4WQ6&q!*c1v<_G zQ<*C1ECJA{eM{u}{jykj<#793tfdK}>#1kkx5CJO+cNooOaKv%iP0DlMYh*-!W4*Z zA(f;Rs&KStZN}KO=;D#7?G=6d)38Hn-!DQ`oL zVODM4{7-}oxBx>+Hrpa5nkrHG9>`_X1OhVedkc_i^|;Y2iL&^Tir+0k@eFb z5sa3g%$plNmg?+^HZ;(|=F}Z3N1y8HeR(*y1=+X_-wpQn zTL!KK@PPae-tZ^jj~kPC$1}2K3xgAxPFRmp?~W_Wd?nb)bn?ncYtkW2oh3fJX<4}m z@C3d#&5=4>DE89Z(@J6T&cUfyH#Ix5OC3NR4k zw-S^{@I12L;c>MQ=zc9PbKBSyz<9%U%pwk781(h@Tn5Pm$*N7LbmXGljfRfMkKiZ*Ziz2xqf07~ioWo3v#SvR@ehmc@Egcej!aK&j6hB+QvG(eLI?LQ7xn6FO71zZYH&ZE0Z8_aG5=L{5e z=U{f_sq=t4D>32&+WNW=A2kvU3bcTNrjD!DD3y`-VWkh9B#<`b<^tkZ1PXy$Yp&Ov z2A5X(Opx;$6LF4RdJHIXNKgXoOn(}O&+pFx`9(ex+1S}*rp4?*?(KmicLt(~PB|WJZ?;3B(y1(wkrdTaJ2o-$}&F z)bwh@fQ`_)sgJu~9fXWKPK7@LtWT0^TN}-I+jPHw-cqli(XKU!R79Hz4729z*{4(L zSmc12GAC~HVn>fHA?AILjZj+WH|KGV#TRb$=cpH?5m@otmX_=MESznemG{`cVXzjuxN&o7Xd zBH};u@Sk}AD9u0JRR3cS|FMVv*uz`z|M&}%bN$ae{0(0H#~%J;4<}Ci1T+6*5C2!$ zL-3KTUl5x`tH)$`rgghC9zyJWIvzFgi_qN@MtAR(aYdZuj_8kry+ac|YkIQ~c4!n9 zV&;P;9(1ttFQ0FD{N>KHYhB8pd7OspuQM5jV{)1|QzFCzyHcGg zHQ&*icK7^!pZi|MbWB^seC>|3?U~()qBg^X?eI8Ga^wI=p~lb=GBr$^A<}ejv1XIx19rNKo{sG*&j60UA{P+hpsr+M1=f}?AUW;Jy0xSUPq>CfS%+ zZmg+vxm{9H(v<~>D4E0Fv4@!^=Ps%%cU1@K!E{(#dT5ZmeN_Fl%~dw$RF~U*p-v^0 zmAZukn>xNxwD;hDX)MhKt?DfN=MX-L-|j8IqV0o@ zC#OpE@2Oy?oHycb3XAwweDB;rf<}bkpm7dYtj1Da1j1H5{8q&+COYHttOb2I|6YIE z0#(e&Lb!fnK$RaEWIFNjAmqm!@0ftb8<8)~CQd-LXixiAgUcGxS|H<2v;=5@D~ng{ zQ}YFz%wO6O4x@*W<4e{tBOHns<^OWh>Gy=j*A&t?(;Sb?oA&37nmxpr1%F_?sZ?yr zm~EOtXa4xytL*$_uD6WkO56jtwkm3%ffYkD2Y1ddz@)l)_V@=GSn2H}{ve|*Kqda$ zKa-aWZsdR$V}aDyB0qVtJo#Pu-E)guzD;6-yzMV&D;%*e%^o=jR%tt5l>g1w`E%jK zgUX)vCZ$`^(`F*4I)yrE{A7Pjoa{dn_qaeysjrMHmhG~}`KxoZ<_-dkbbZK?3LH^} zDN%o`%}l5;@TTI$@mHpd#n^09oHo3tdx<)7A|j#Y`O1^Z9#>EnJmg8P>p2nZck+i} ztv1r#ImHEyIDh)r7qm(Rwy714K%Qx-U)qb{-GtySn;X$t_mt@Px%1o_*AV5BV7Ny& zn*FV__RH6x&1N#BapHvk=fCaPUqCUos@Rb7iL{gyD8IH5v26su z9m##h{S->W`O!H!^zP~CIj*nWBNZ@F{z1{SPP1N;`PBZ3E*aY2A^bhiU;Y^=hoT0h zf;>9qmxwb$EMp%oKdYlZrMrbTb8t}4x4hrvmT1}Z`HZ|W>d9l=2VH|i?IK>MW^LYM zh+y^W^M4HI)4S{!c8m|p4dl@hwk$0QjuEfUeJy$7SGI0r_B=a(?{K6L!k78Si=BF7 z_u@)vgCHTAzgPIeKPx5X2OPom{sAuUj@(P{U8mw8%4 zF`jm4P*&+!n>pke*zSQ$~8K&HE@*SN2=u+NG~n^ksSX`t2#vT)95dO!8#PT=} zV>tvVLuoa}m_SRPsjH~^Y>PAhd}wa+c!Gw(W0@y(hLJ>@%a@RB<1+0Y<7;bc zW&yOP6}Cru9f2_3soSH>RPcLwe($Hd$EV+_;E8{%fJFs$^Tidscxvp{!f?*0%Vp7i z1g|pxHZh=2NV=QH>7z$~RsPVDuy35%ebfMv`S@V_*ZO~q@G%hX6WT%?-h{rMu1Z#W zYx9KCEGqkvtW;`~@VS$yWwB_;U>d`9Opc`cqHs;tcTYq4EcvvY(qrb}gw%t7jts`G z>S?j2nG;PfPBpzR&b7VWyot$4tf7KxiHb={^|#+U*N%vAgF(I;Ru`vnfNG$Ao~?ED z@TLc)^12GgO5YPwMn4~S^?_hiu*QdEiMPqu-zM{YtiWaK3u=@zUQOdT?>lLthf09t z-fvPV8~WPQSsv|Fs?AIHjEMzvNR|ShaB=?UNyz}Uy_xVnUY$;`nG5>j4R3qRcySU}NN-ud(c`uj}3<>Jj;J(}<=%*&Ar6Ve~^vwo=;ZWQ}3#r7+ z`3```(|9qu>M@b)4MZ zLd^R#J<;KYIu&Kzv|{F32v^u1?;WL27zAg8A!tmqT}ehF|BI!1XX^6O-izfp9|C61 zti(=m(w?QoH$bq@UhsJ^MDy`bYOZZ5%qf?deM`S%!N8%{snWx_7)uX+tH%(iTWJCm zejK~}e{WOv$K?jn22LVra{dxCC@Zc|y{_LPU zKgHnwy+5-fBErt-L}~c;C)2uZzNx36Dy)>(uc%5(Y-WtRFP~76{O1WOisnzK3i5h< zyif7>p%MB!JG-m_z+(Z?YiHM1;rQA$HCLVPo#`2ZO;zE%Pdy&{lDB;m8D*yzfCCfRx_pQhOq>bLwfr#)XjuLe`{Y1-Dt5O74L-se`(s&Jw2Ou91$@M3w zc#!gqKg{so59CXV{J>>iluZAY3r62Z{r1~kAZ}!iI(zj!27B4uJkl|;zyzo@ za9B>W@33pSnO#UuY3a-ClnKH@mqC-!X}s~Vm->i4`Ok6;PflWtRr)|}t8MBHMUBTe zKx#$*3a@Ykp^Xr4CcP#t-8H=}CGcch(=8D3G&JmgknHdLB*5!b49KhKIX*6t<6coy zSO0PL&lS0mygXsG^r0G&X=d-f4Gn-@qHa>oi?!(*1cL(uWi;O#-kwY@Oztn&3!SLV z0H?%bdl&!OA6^C({Er`PZf*{_LVIrkuE2BtYOXEl#aQFi02)l3ZR#%u0*2&2-;O)w z*+zsx2RIZRMhQ|hRQ8A(DCAO@se1RV5r&P{>~C}wd#0twjjsPo_>|nP-PbPPS*GVa z>Zz`)t(20RVyQ1!_)-1V0D`xBW8qDpcNsX!oFX-fR_X@qT)Vbz6l0fEB7DwAkbBOZ zIKlSE&mBxBpE-XyR0Hq|VO1CJ@wVTzy8IQpg=`W!>B_=BexqHeQ={Mk_dvTGEsHcX zZMfnoI2$@1ft%nVUl5PsybtS^4rBg@NERsh(>Khbbzz{|9UJ+)SfMk*)-aAk`~&LZ zJ^xAm#Fw;9=Z3%Qqi{WxXTbnEBYJV+fJZK*yYkj+J`26-rqs8zVt7N(#U#A7Jnf>b3gu5^PP+Wb`nhx_ennTNi{&d$T zeZK8IL^AJ3Wf5Ok_Li3)1jg6bl!>m0Z+PU{i0JSqDHFc8$;Gd3Zq8R(z?g$x-;O^0 zN$=_5-lRlLbC9()XY};$?ylKa8^*9Ep@NrY;Of`%B{6EIXz^PgpbF+%!uI)kd`>UQ ze`GE;V!vv`xpRNZ$6$j5E0eEJ$tDP&meTQ&@>2AlbXvdNpo`UT&M~KF_c+EAuM1hlgbgrk9r8~u@O2nLH zV_dX8NZ4ETn}_Ng(0;YcmY=iv^y}ub<<_?N zy9z#F7y_15Hp3JgH_^Q95!^;kNQNgy3UJY1L+$al^=F>9P~+E*ILtv7 z)E@=vE5<%hf1h@_T$LNTVrOMF_h6O{)4dIeAs5V@SXKWK*9H@}n$)ryTmmJO#LSl^ z`RfL3!7X3A*8Y+WiBgn(?DcNj{T5q=-Lj4Hb3=2T%!WKXez#SV@GCoNLFj@Ghk$L2 zzVpYOcN*O8 zSuh>tyxL+=f*JSDY_89&x%VX56HZG2EMbwHy8dY+IHY-;x}MHIPF>slDWt%#IRnyWZV40{=!Wb2P&%r)3)dU~y$mu9jJdhGKW-{euDK1mC9m@~Tmq?*zG^ zudD)L#8bsY7I=b^T0*bTt%xv%m-6G);-49r!RA6iY)32bL>oQNexAsljJ*O5MI~tL zagKaT8#}vYyTxGViC0+r;a``deRiwU{SIn@it~oHQmd(tApByk5!bSM znudfXe}aD+B|IME7;$0gLQScYNoua+C@9L-*C{IFy@1k<>_=U0QW9F;Ul`QzNsn(* zJ%2UAv1ipv$0FZmF{5N`dT%#+|Ko8kdF||RR2@tlVEP<63VX>lt2oH~AUU>k{60pg zEB*Iv|Bd;~+OI30d9W13aT_0afMvZ5grH)jCo(!D_NSRGlbB*(dHMaT7Oh^?zTduk zZY*yOIgH=oDqY@pQaAd7Lq&JKzGLl(F_$F{UpTlDcumm=bL*@F8yg$JS6Zm#>vUM zT@_f*KJgnRd8!|t`r**FmAQqrJ*6WRxj8vM;W`{W+F7?Gqn zcK%||vIoWEbMogSzQ4A1do#z-o+Ri=DWXl_zA=6!@dW`rwEkKX>YK-Uv*;67|&$=#LOri+r9A0&tx&E+fP{GjWiG+&j#MLb!4z26%3@-_)TO z&AXX+f%7J5oHUzPj_14O#NXrOQR>}5ZtdTG_Od%Gt$1)O$+$Y>p_zG(us=jS%rPxN zx)$QL0&devqsVPN{fWVPDYH>TB-J%_e0XIiTD*^I(Mos{GHN>su47D0$sOhg2A`mC zqk(uZ>YD6OTp4z~X}@O2MXEm{HrteO!0s~Dg_o}T^Y?E=Uf9?IiH-tK3||?4#A`fU zercAJKjDe;^S+}wTfR{c8FjKh>1KU)yb(=*I~MnO!}cIzM__)Ap03x=fer|KjZ}qvA@t zZqe=zO@KhK5L|;pu)?(=xVua6;1Cj=A_?vZ?gS|`KyarL2yOv_QxLRpFQ6z2&W?26 z@AmtC_l|SVH_jOQ7k{Yz?DZ^}bFI0cnMtMvS`DLFG`Uis$*oh9Y@XQhY?x~;X>^i> zs8lyuUYabg#iIjt6-P462`6keO#l0&V^9lT*(A>#TjUF6dfDO$w(Xei!18DKN!sZ8 zCqS0RJL$ly{N<#r09zZO56A|{u8&YpjGjwVW&U&{zx3Ys1nQq$1uDXaBFq?)(+o{vm*->F4}=>wPNP!&&s**@YRId-$#emT{`z+dq7LL|%MLJmVDn(LtJM1h|?0!!g?}l%V z`D^W`BM2ElL})wa0BTH&HyGy^m|`mv!Gjx(d1(oLRI(fhd1lbfoMO8bE|=>U`%MWb z|6D$K+g?NWTfkI!{$q*E3;a8O2h8b>vzJbf?XQMTiAft;DE+fx{TbF2&)gd2@a)Fk zlD;Wrkvxd$S3Ta_+nAbqY56%iRRix*iwx4Ocj7Qqx~ys*IKoCxe{l^~aEq&M33zVl zVcXb99G~o>+_!8VzFo<-6>>15UB;wjMFvzfO?qD*^L%&&l*H){(%d`m@{gYw=~vh2 zmv6a5J7^#VSuvxw@uCIg9JH&rxt6D0o@F^?u&{fBBpY(Mzkdgxl3(9}dfyw}oFL&* z&F5*ir2&56=pq#e9;r9166)jdQ|zuYZ@x03tVq8&>oIrptVJ%sY0V7Nnvf&gZ@A`$7qZJi_1=bs& z07%gRlHB`{uKeqg)Cqo)N8Jd7!g(?K{iy2v%hLRaZx|FuG`SXlLGiOvsAn11iG05U z5@Cd?lJ~sH|HdVp{qHWvi6<{7a+RdAdE965GKdtYT(&*G38J4P)DUbQnUG zi9lo4Q0o;ZR}Xhoe0LxuDpEP#m1VtUA80kKmc)8h;IFYI=s`t#3luNNDgWZW-k{Z2 zxW=v<@8EWSzeHv30h%WDhtW6vI_&hJrq+qtcO5TfXOq4h66z`U!S=ZFfbt~fvSChz z&_v^6HQs>BO!PT?#O~y+3k8yFXlnT{%V(FTJ_+vi-W&za5^JPfKB-)z4*q&qTUn{N8CIku_obwId!M&Tzx7ws z=JGNj6qtoeA+a<<_jQCGb&XqkEVnsi_!$KyYXeB8sf7hUE9P@~twLIwVMhv#m*!qn z3fw!x(L`%w)a9oXFbxk>Y5r*b@K`7kaOY$}Kcf5BykD_1H2K{$3{V}WVqxp~qqJT9 zYqRgiN?5GH+3iGyG#A5>k>?i)|@!wDz)aToy2Fe8Y9r7 zik|E7A;Zar%_;dzO@xX?0KZD;e%?~-v)b+1azLfLs4A$n&7)SooI=oic7Icnsass9 z@nC<`)JlznIGG0KkAtTY-rbGRzV(#wa3&#M8IzTzHOKb8LomBn6e}?j8=PbD@2kEMhEyd3qZoeQ}6?gNvBjgjeexs>A$DyozkD)FS>H%v;&P z{SD^L17O}i2Y$l5`L?f@Xty!G)fCbeSzw<#tH|2jzCq zg;?#5Z`e5@>zCfqrwa~fC5*aUhK^d40!YLe@+=dm)r(2EUl1fPDiL5bxR3@5MI$v< zg{O9+(>0>+Y$GzPm?!wvqFtVYU>8p;qR7>w)#mmZ_J^OttYTM%{mMT+b|3##JPPLGMDOvE^jCfA>)BwEs)c_6va%ol4G-M$q{sV-d>!tht zBQIEg@~t1xb915#hVxZ|SN+vEa4PGzRv7a=a?CBnYNNrKC~s~K=K;;B=$<4bjpCjD z`Cv{ubz98&*er|v`wT5*CZ(G8mZd!f)UafMGP!((G5fSL*c&Poaprw@o>_ox3-d_K z>GmpGvnl+Eq4}4*q;a4-eIZ==ynyz8>Y52qRBR8`?3R2nOacxW@6}(8oEuUPizEQ9 zxJwR@X5#g5^soevC13mb_|$wqWJ{{nA3ieamyh&ePLyqONcmK%9c7he(>cKL0@;TWBW-$ly#L+qp|{VhtH`^3VLYo(15aM7XnC~-UqALOe(skqsMX(V zR%6MlZu7(w^_h33ROdMio|@ZA7J8-ba#`d%T79#k?N9@#o9CH*(>)|b#1zqla95h2x?<-pav^QnKqz&(nbN^33B$ zc}c_nH}qFUw-TR|ql;6HYt|xaP;tSH{+gm#le}I8*0+@96~r?>*{hDKZJ97z5U;~y zel04bcY@o{v8d|fXW+| zk~E*Etq*p)6rD~3aD(maV;*5YOMt3CAf6byd;zG6!jgYc6$<&w?@GT>712h@(Syjb z_u8cv8oUQT)4@QRl<&6kb>^3?sKq4X4&*1DTk~QO^*p)f$u_22AdB??gUP{b2G2Cn zC?-}&*}OZllM#19zT4B8IYhbnF!OhiB6mNoymJ&qa?QGkQqq}U+Q~amM2iQ5a4vZj z{VVKFqZB|%Dqp#ejDstYTRFDd_Tq`~At-KDzCikW`-0)viU6rj!4!Zld%QjH=2t6I zACtI;7|8De>`77*oc~mV7AV>}?ka!(!H0yuN>0Qs%jo%B`*c+mG|;=)T);O0W-7(c zd4lAYbS0m8U$LGXEQK}@lJt0fHhyK=te>4t>5qg^Mys?MRF1??X7NAL$_lkyzRbS!$9zlP>Lx}g*;uIoa5+^I%W|VuFVO3XusqlM zVV1l*n}B__q*zofElC+QS9EPuUj-<5efWWR<759SHhb)Lc2&F6+xaEEH>SLA#m&A5(SKk=&Y zLzGv}*m|L~EVN86JCzMS(&{(ExIjdW(v5O zp>h0Gv{l;gQk{v+z1J-=_<`Lb5Cr2 zB?!FzrJ3Ixh_Pwe+&q--G@~L<@kI=@B|UX%-{KQAI&Xfh#efP_FJZ*$Rg4?9xbx~S ztUM@9JDE(xH(t7_5*Q-}1AL=5LD*&ghE>jnEje{$RPyN47NphRWIjB{ zQdQqf{*BCR&y-|QpWwr&H);KF!O3Uba(G9uY3q5pY%Ml`5CxiJ^v)FOda+<=*EEM3Z0mhy` zlt$#-UZ-KAKZTO#lzOL}IZqs_+GS2PWeS-a!Q2}CV01m7`WQRY*drS=+XJGsoehh4 zmotr+r=~@RyUfW7EeHNgz5RP}lB9=&u@qut{AE9D9K+~Ilyrtt!o5e5*z_s3BnE&2 z-sS8{&82W$yelK{3Z=T^?OW?~SaCVy!_MmR&@QDX42xH7XYYZH+pw4=zS)2&TTJSTY+@$u)gy-Mbp(q+i1XrJK)qt|OSw()NE zyj>>)JjJ7g;oVuqz@A<e*c36ruF@0?}M2Y!Rqd=9pJs{Q1AQR2_Y6@Lj73RW0~b4Ab^kTyT=GQ6w6KaK6;5h!zGK&&QGiwpQ&-U_RJk8hj)+l`Kz4AHR$VRV?NIhP5u>@eUpv z1Rzw1Td%tS67t6jgj4@|fleDlr?ZPoE27I=kaZr$WWf3?b6!sY-o=whfiF3iW2l}Rt3$9W`Uj@H^HwKbneL2+E)Slr+@IFByft< zcilHl^-Ct#*#^A&086z>g-8QM`NC)A}6__>1y?dVUEmzH{TYio49_as(Io?PJ%ym)wK zZ~M;oEC8SE@AD*OMxv8St{IZe88HZxi6TosJ2CRH5eh4b=-j2pRe4Fs$6CwEdz$!4 zQ-&1+MApa;rdpv`yjTN;nl0)5xI;Y45sK0zmNN8gN?_?rjkwc*_hBUZp&sT>0~_bc zzW7^!^NqAhh6nAD9gkJ!;&_B*`U~ZH36F`TndI&w@X+o3P@Ovvn}yereCJlgOeOmR zZ}#t8{3V&v3;Om;KUDwhZTNt0X$MCTCa_m&0gP+%|1jfPFhff3W3JiNM20p_G8r37 z@N4|*jM&=ZL`28-T7&4GB9)!$%-zb@f9fRruH9|1?H-sk-Y{zDCL_}0PLf|383-Kl ziyT^0Jo|GYGk)Uedur?6_N&eb7!^#HtVqBjjNb4LVE0E}NJ7^L^d!DF*+p^pxQWoAc~xET*Sg3!EP65Qy-y9+WW*#JpzY_@Li>~{<>CWoiI1Ia zB7;qmPO%=?2TXatx4sR$wY!_7`p=U-`sJA~SBgh1gr%sNvUtz3Nf)>4^4+ekKpoi@ zCe&eD_!iCnjy0E)@Z7Hqp3Wy5u@%Y566D2$-riTm&}Ch_h7QyY-zKAsp3~yeRZp!p z!#tx3$L&T}=dUr`+%y6=SY-jkfL0EZD485(NKJJU_X6}7x`haX6E8tl` zR-FAedwH??=ijs&2}|27#p4+2+YjW9jSIEY88P$I6^ZC|(v?Dd8EW~7WO$;myKo69 z@vyf2XdZp32CdDh4zxA$>#@a?TPIl!@vO`CUvVj1&c^hqmgwTZ;H+m%-0=)dvSCYl zL+2S%h>o)I%V?6BEZ2w0N;bpHImx3YbO@nv@*3??RTTnQJkGw`r9d(x>(5y? zT0|mc+WT%x57qNe44>u;wc$!ZL-i!@3()$f75`NFUh?oxEkBfmG~qzq z%$+}Y*S+pt(k4q0&u_hZtIx#0CnHqcet zoKh6_1YQw`IkN|gqHOInH4ptgCe|oWPQP@_LctcxT>WCEH3^9Umb8M9|w$H*W zftr@4*?k$SVBzL^8;=#n{sVyzWI285=uw=qpFw;G%!F>(}4hI%(`olg3PpWsz0tk2yc{ zq{qR_zI9b>L$#nVb27l+r8v;Pebv}5!w!0Jm1sbdezkw@)@xbQyf^?i?v{IV`jJw7 z@e+<7N|0iE+w#WZW^lWor{2BbhChP&$N>-t`tnlM7su6=1g!)}dxX1mrhW)2HlF2Z-e?Xzs)ZMsRJb-04-Zd?FQud_6E8*{ zdjz3ig=-YCHGvza7gy<}>cvajAr49VyIz^?hJ{z-NVXoVZpJ7DK6Q6PpTP4GV;P$U zmxEmwwA4-ijkQx?vFA_%X^^Lt25rIUO@*MOFkQO>CIcE1BTDNDzC?*g$@>HTYM}V77ul}R)k&Z zQF~x_CtLKu)>bdK8Z!B~Grga-BLF^CfrvTj()YGKC%`U5Ju?mFYiOLO8QZ_NY938k zWg@l%J&V5{1#wx^}<(qXq^LJQbyzzintNrQK$bNY>7gyRQOs}3% zRVfe4^499<+3a^BMbhV9CSM-k$MYjh_ggs`NgHBZT6A@Fp(ev@_d$MnOB=KZ0F4n%cF1$$zPTmak%F>YV zT87YCSez@vxy^BcKk&q~4P-3!?6jlYu^FrBLf9FT6AETY-MJ;re}?#fA%da{2bZ2q z{wr3t8$;u{SMp!xz?WB9PSxgae_>U>j&f*!imVkh1|99iwl8kjoivY1wY=x?ILV%r z=HMk$*6#OZcA0KH%nCl^d=_~A9@^G|O1G~vZTH(oxxF*DSh!wDCLiUUNB>^%<&!Yo zwW1fMHGh`-3(eEfYq*7liTSxWDMvr6j`l^E5l1E|oTVzqqGWP_VUV#?9M@-{R(Rkd z&XM-wGqX3>{%z1lkKXkGMdH2 zDv@OZ;T$9`P)>)MxXXqe$&(=_wslx*D@kT{HYYZHLWsBj*n68&42u4%Gz^_c*?#Vz z9S!hJ=s}xqg)W(V!^cf`ni-F9FtS-gbwr&oWI|X!tt1BjtZ^abUNSz3GZO zf22Zc-(wN9>@Rg54drjkoN5*NGLCoR@Q7E>ust)_H+bSgwwGIa0Z@TRiP+eLoB0DPuWM-@PYatP#(GZQ$R? zH!$@Gy!^_0>v&;&Woj8bZEI7rP03Ho)zUs;i!oaisVN*4IL4j%czmb+=BxM33#~B1 zr!LWSdexiB&D9zb9<~8~#)@y4krlOkIn2v+o6nONwHZQVuPTj)K9EtS6)9;~Bso>= z!@9epNx6GG-c6G>9t|un-{5_0Z;;gf4_T)2gtJ`{MYj=IkL)q);9cW9>vSo^&;yT7 z3t#JQ&tcwa5ApJ;w;ov!AMWiQcy$SD^$mqhFFs&u^qSXZ2zl6US#PY*U}C-qgB@VL z+!s)4o^g@;Vv~Eb_CTDZMFZx150&7t-?Gmk)9cNec;neCmi}Ww&|Z5?6WgDC7wInCFjTW!&-l23Ly{&SR;olJJXHEkpv{G zem~&@a!=J@LitG9J`N7pQ6{$`5&svtN5kcw8--^PM$_ zBl%t#W(g}LV9}FV`~JSk{WfX4s^z1`JE0R5E3J&8o8-N*L%wa!!DqJyYiRm7Zqphy z>f?JEqn+Tzxz}r<(~E}D<6mdXPcDD+IZBorCIQJ<|1x-O%kXH@q;$ort_sRx1ke)I1{86lYkO9Fu1UCY=62~KkC;EwCIF-wFW*Dcy_dVb=77*Gc)58^k$R0L26qK z*h;UWq5`O%X^0g%*((ZxeHV4Qq4+d*E|i0sLVD1&BqyXAQ(iY2xuNo49mCHF>_0^YdFzG&^2 zcy+Dz^}*^t5*=ZWasI&NP}2LPq$-f{*;;!*WQq*}Ouu&X%)nq~r=)hdpMcobeVOaC zjo!niZxNyo*>~{;Hr*W@?ClK?4Fx=D#f%%AK|0-Qr#M}u6lzeuFVNct8NSbu#*<+e z;Nh!*-A@+%>U8|wbkku-;925{TR?d=lpmyD|FETgj9C{wPD(qho#(&l{Q&mP@2o8F zsCjE=iOX%_-DFuK=$E}#G12o(+naf+% z314;!8T@*2(fE{MwmgY^VT9@vz+8=>IC0Yweo%n->S!f*#ooTubHou`5>4J}>UDKF zw6&FL4yDG3+{uvXv+NguqNY$cI=6+r{!t)(hz#a6x3GYE!sB*YvQAFmqb4ap-~9P? zK0Ey30MU7}usoM}OG1L_|b{gwD_A-NG#+mL?qQueYSo#q;y? zfaIKU1z*oyeEjEGcP9sXYoK4dJer9{&?|6^(X>bl@RmCFSBuMZ1?q_pG4fi+Q#%~1 ziR&EkBPY7)m}bUKt{rD40&L?^_7+z}6+@r6uTwU?7u!0v46;T8E?*HuRjXuXR;*8h zYr|~jSQW6R6~;&}?-EI}T zQVl#sg?xpDNn|O}Z1ZjnDbv7b_a{t^GncEj|BSmFZ9fv2&kNhbn-XleY~SqcTzGJ& zmR&7IwUEs_u=V2L{=t;_w`?HcUy@Z%$_B1TZOc zbf?p=swQ%g%reLZ3=QNu6i9FW3y z@$@{Q1th{RfL#DOy@BW*iyIzq;()#+MOJwv$D=+ZkzX~_gKe#m^ty>4V-Ufn6hV}qvX2Kgc>(dk!q>+`0R>G zY3CUe7Bb2#^#R*jZ7&p51S8PNt&>MbEX68`I?u_^u(AaLM?GBFj!AFei9R3FdjIQT zeTUz^+8`4FjcN5_YonA^Vf)b>U^N3;Zv+WNdEe|?Tn`2{x3%rI>=#R+w=6C~EuQdG zENf;Iwea>_oNi6{oz&M0K$6Uj#LF|c)`2~Qt-vy>C~zMcsyql$bv@3F2AbAej(}dV zMg86_O#pIeb8(?|eYa;odA(*RN2_)DVix8~9EBTvdU-U@;h&wRp^@T^@0abBtF4Ns zUyiaJ9lC4YgWB9p1Q`x*J_1(R0g#WY)STNHx!wSeP5ni!uUUL zEfM;d`{vj>UP7OfGVBPjn>}FF%H1wNSp6jEy8R&VU?0|6xx)_JjHyxcRU6&th8XSH8EmS8G3dJy3NOwFpdt6tT8Bipty$Jjq-VuY_UHQsneA z61rwEd6dOdMR_D(-?64Y&daW}=6&Uxu@&UOpbDbhN*%S8j!;d!qH!a7@NOl9B~mq1 z)hC6~G(AQ!F2X8gBer@)TZ;{paPD9d*1gFJ^u*m$80)@6%5C0q+7rJx&Mk?nLrq#t zuJ4$?@j#X+uLEgc6^OchFcSuJ44huA8srLZ7B!MqozLH{CFy-8UOKM8f&@Q#%4=Sp z46+hosw#uxW#8hGTi6qg<$Y6B;Di2p9rzFUkwt~77l{4Pt3fC*WjChW>oJloR!n-m zxPI#>@0`lI8+jXrZ^?lwr z%d>v3Q@q_W$}Q#1i-QEtPKgOpr-}lc!W^ZPp9=K1SJ?1Bbi}o|Q90H|8wfF{%Oz|0 zXyA2ou2R#*V*KL8^1K_0T|x@v%I_=>V(;p2PS>eiat>|3SD+q_fht`5;6=_x#E;(= ziLHdCdU82->hX8pN%}MI?7kOrGgb_UOkQ6v-JpQYBk=|X2B|429l(yxx64UM+---Q z_~64^?L*;FqPwKPsvjUL+fvI3IPSmEO}RVn@n9D3Q0rCladyDA3grEPSog!olD-f! z^(T&Nx3C4|Ut9CAX(p7K6WFk>%19Bhks2{~@h1~uN9!=TByOFhYfASKVy88fsm(>M73caPk`1WmM`}2SKIMVO=u^oft&YEda%(wO z-IfC2XW3$)6MGsdfn|`m&bfNLze^mYZ7Taqo(w4vvAiRTN{b1~MQ*PwR1M@`&KZw$F_I=QcaCBaf= z3)D|sT`RRqsZN~!q{Wl|L@OatdQYFc<=OK}<0Fg9j}PD2a15%U-*rYc z89`*#Y>v7EDR4%uxgE=q+7Y_#p2)8Oc5PvbU{pEhAOM}GYihGAD-to0R*7GG-^||( z-=KmnV-c>-6r8I8b8?9!4m^Xpx0ZVL7ao*A%R}m@pvDyxDT#kptUcz)&Y)AKadq*^ z$d1vwJ7+WpdyuqSvFJe1b%-v3HT3jgbpD}~cMmrJt%ww+{vo5;d*^%qr~3WD8r6xb zwRsc#eeUbg{J*!Q#-0N-i>%; zcK#Zstg9reNgzva(Ysld>oUGEK$AH}np1Cc8OC?e$EY!$wtZNdRY7fQpR~{7hBXm)# zFQY;pFxj!IA6W{K%l2RP?Bg#Qn=iUdZR?Gae~NMq**hw;D2pR+AUPE)F`%e3iGx!P z4OKl>I6uDrAQzKphYfE?qPmldbR&%55A;Ij7b9Q#AaBXT2d}QHr9~xmY zuOZI2M{)5OszxZFI8{(Tr(@ALMj`EOAcWr_G!HDd=@wKQ7?~Xkcw8%t(L`_Zgp;v!1|I|9Yc!{b zzoTFEY)A9FGyW?D4epp!E^}yLYp%_xX`4Iqs#fD@#LI_hJigBo=tevqhJTb#zg=+a zDA&)sV1OE5-C#_EyzZi?Tnx)}K#&q)qm=H5vsV~S%FKm(C5<9`d&{3sc2x{Ew7D7t zjnn&b56)hxGAwy(=l5Nkyb5U*=HoosPWEM6pYxlrb*|a>q%V*?LuF|y5yXut_F(I8 z41_rmDNjgO`CTszUCG|ZO<6QL?b#WX@<%k@Y~J2M?a6mHk~4)oR&`b_OmIlRDs9px zD(E*xp2`+v<^|nsz@*9I{P&Y1`$PLdI{RPb>&`o!q+YYp=4Lz#rqdbVQMG#?u(0zW zRiRq!E6qO{%db!zU9*otVS8x@3k%O;;$nTf_+IPT={o+uHzVc#W%$3@j3k6{r~G(l7Q%j;SKUL2Y?1YT^bkr&fE#+S8e`!O!qZuoP|qmr+Cpwl!u(U zyF>GAA4$)A?`Q}rtYBO*SX4bhz6+bZ_>{hN0Id}iGqR4Elo%9X%V)&u(p99l&4839 zNXS~WRL||;=VYbNibQ~dXZ3^@+fLSoPLnmn_0pe0k>fk_!(AG}>I|V@)35Uzf&cQt z|KuMo>ctKFxw}7?`%@le`yxk5v39RwZfp{)sslv8yx$s!&YtU)SkT#sO}CW5#sw4n z)L8#eJt^bn0A!un`L@yJDx?B}2p)tN;orvg#!dEMkd>6; zOu*TxdeT1Y@9*n0Ucc1Vo)=+sE&*jDO_TE7SaB_0O)X1Vufq(E>@U@IV?7x!7u*i~ z{RSaf`7;j*|DllfA&4AudT^Bu)#0Q%clw=H?*CpRl(fRh(yeQpmh<=Nwbvflk;M3;S&@c+2j3sV7r^V%uK^1Od(rG46sG@A zx~3NYH@c=`>~O3?b;0oRD-P)|gd4g&fBHS667cr(c6~gQ%}TrJXKf2VI`LFijOwF{ z0(~UOqbZOnjYWG+)>caJxsX45;OH4?!V8_)7H&YFXjl~78&!*SyK9A(uuNiOV(r0s z1lxP?Ur5-q=^KsQfdhr|(TX>WhV-h~J%3;)-^2r21F44WjD>%BWNl5@+R?E^B=OOr z9=*?Nq+^HPiu5}#6tUQ9XdNV=d}}l;H;XG9d!V!&QS!-ZUjARnm4-2HozLT z_$b@|t$RzHcAf42sCx@>9e8O#dv$=(u5hqVZ9DX=V!VkSAw)RXlVnDX-zezOaD}v= z@vf{&X`dSM5y2CdXWt-VlXg+DYA-L*dipS!k=51SfqMlOp_6QuRbmxI+URZI?d7CX z+i^f&s@k(c_X5C**>-Yk0-QGFJP$jUA6}(_;ld_0snB@4Jr~YJY}a+Sx3VRFnr7$D zCtlD6(Z-4?zQbQq5USBbOLkgh?kXbVGp5IcE3Xkcf%&c*2L)lVnv{7d+D^iK@pU?9 zT=_!5a%jm*g~M~Kr}U&hA1SZqm>DEOA~~TeG)g9?sEzVdPWQ9vC~bKMs1#iYl1T-U z5UuK#wqf7j;$+v{FjAYAXQ5F{yG2TgQN8%t+l4-4ic__vYhd6KYiA~k-;7-cK!e85_@^}#1*${k@7Oiz`Ah1F|Sj1R&5zRNc4LBL-W-uU~sM~)rp z>$Ff0M;Dq@1r9#my-JG5t|8wG+k$1Q*HUf;g}l}6)1IxE%$f}o*r%-Ul7gP*jH}wp z_UlVM!IueKEXowg0gZhweja1pf$C`_?12|c-0}~z#9euI4@!LOQFSmPO6N;;-uf^m zV$T5i&AGsXJT zZXq%}tJz%zr(y7G#XQZl&7zMtJJUDCELG-W0s@WAEgpWB*H^0=aaP_RBwj%8yuQ=? z>%nJFr4N1_{23=Xvd?N=c*rB&Wu9s2ZhlAst`UC~f~XreU&uPfr&0ndL7GZVIzfKH z^P!Cnef1E5Z47&eniX#W-~M|7;`mR5_%i#`d#(hL7`&Z)>ABO7xYi`wntRddSiq*s z!k>pZf9RaZ8}f{?`U!X#JUiH1e#xY8&h@8|n&-Ri2f(DnrL0<*k_R&3n~cfiVe^GW77JpW!nfO~~%f{$BZY;S;- z-N2Dca7h!)x(Kxr?{>AK5wtS*0CanJ@y>LreJ_VjY)yJRYPb<}d~+6W&E+L(DKv$m zzpXWnjRbQSCdoMzL3i5KTa7Ch&6~4>6j+gq-q4#^0B!u9^kvnZbN_9OfK~2qK22W~ zo{L)zYVYOpOCHs=VJ~1*sini}eEga&CSZx5%youIrrPCwguR%UOHApt@LMS|-EHu3 zFt}xgHV8bPaf&Dv(f%Y5D{Ci)a(S0@4~eWhNY~LX{Yb?nCx*MiPsxZ4{F|;!|ApMh z-+W%H&!GS};(f2#;_4K62VRWWBL9C1t>kjh{Z9$4OxnL>wng*!A#SVa#1626Sy)f^ z(G92Rtnk_EYgf0b{({G6r#6j~W-aYkrB2i47h{=Hs4b4T{+t&6Y`d*&1R6H=S8lu? zv!`l?P5SHOx3qcL4NiE#%$RCn`ff(oj=9hkpsbKN4$Y z@u6MB;lQE~@LxZlg|T%$t6Ij`b(26-`V_GoHm>(;4)-B4Jhq#OR+$+glPWY_pLl0J zzFoqT=@ob%iYJ%u6gF>pXbfLCDORx+>Ot1K;p)KDcogx7YXbOevsv4u$}og5GNjld z7Lez)Ory6d_+8p;)H*`cE6g-gDe{?{Lzy-WsE4)NP~mBU1xE5x;2m38I~j=frli7= z*zbu~-Ef`$vVaX^Rm}|Cxo{H*A9$}9sHR(2SFNpMOWmMX8z;HVeosCZbB&A$wpE}3 z9f-3|ALyV?&eq-Wm|k*kRZ4&xj^r&(9vGECMCO7wfKCslc6;PA<962y6C1A!Y-c$ojrT#SH5(4E;gB)bJ(GYqw08RrvM?0?-I7d$fnILDityNc$EEdS*VeH zG*)DEa-RKtb^m)&v-0k2o14bPA0bISgQ*T;6GM`RY%B@w^X_EcV#>I0cN#-a`0uu(!U# zZxcHw$-l`-P_<~ zo+D_oHvuZ%cdm?u8A?b2fh)<>>D@|-*@Ku`o_?a7Bh{j=>Pjq~;H{vdgGmqE5!zqJV`o_&k1zaDBcuED8QRb@&o<=3`4R5;c5GO{l8 z?(7{ovy~ZE?xl+>|C#bi*(NV)tB-%kRbg|Y^B5QX@i#WeXb$8n_6ing)bqWP_9F(u zBa^%qX4QCG844WUD2a)?s<_RsQJQd?b9;v0XbNL;-hJ~x`>anPKXr57Xj{GeH{BeB z-~t45pg2sAs32`;gAoV8K#RdUJ+3M=5uK9_eUz+?WUOJNRmuF`v}pn@OZO{Xn+Fc< zt%YXwTjGa<85ubbc^#W18>pv^t8@n{yc86TD&nArXW)C?a63wCCLtA{+FrR7!a}Ox znHVg&>Q3391MHK9aYJjXHhqUys?!kPf_*C4Ibm*52uAPwNO2!KVKd} z3-zK)fsh2>zj0sv8RK6&Svh&M))PR)`~8BkbZVOYH#2(DL901#*9)GcbJ;$&=*LjX zhX?glL({#39sRh2c9fL2wK&you{g9ec(I0XB1fdTO&45qvS~6ac4|eeX2Z0RYPyZ* zqJp52ta`I}G%)dX8tel^`?!I(Wb_j?gRx43PfHv;Bj>Uo1-fn{&B^3jv>*#UF4eQ! zawo*#*+$i1!;n*ikaPrNqO4VEl4Nwf+O}~F0fSuFn{BUo529J-JLv@E8VOIVoD%?r zWN^rbr9b~=i=hj*lLwuHwPG%r4N6xs>3IqAaBPhzqS@(Z_<`=5y4++R=6rr*{Go*R z+JX65ystDZ3LmQD+8HMiDibnOmu4t2-XmV<=Sz>g5^o)~4Ug89qaP&_or%{IN;h-= zmMSg&OqK2(d}7)D=3vC4Oa<)Klg&o0vb1vJ}QEidt#NG?9UMDYBMyQMF8is1UBEeDW zK`LI;ppgW+F=-CM5WZSxdfNhh=;^1`CG@JBK{;N|v2dg{y?A4QcOxwmx_08yB(~gk zv}Tx<1PN=nw_>_|kZ3)NX^Sa;uT(g0rHOXS?5{61RKeOX&#Gy1x0v{Eq2}ekWkpJ% z5|lwl>7lF}w<{!jzI1@_=?-p@~~)S=n6ov&+EVh6ZB?0(`C!p9ZBg>-jKT z;y`d2XBZE2%GQiJIM|S>mIupMeDm(<$*ad!Cih36B6jw#WB&805=P-F4^+O%Rn_S{ z#jdd=L(6)Bj2l_IW7c)jmT7vmA1Bf&)!etYPSL6f`Fi%^=KKmp6qW}{v{Xb)Oi>Z9FO<1Yec1ZC5;_bbono7I&;hC|a zqF7M6AR^MFOE02=QiK7dHz@(>odAJkq)OM&yMlnU&;(3EU;wG1C=eio5a~Tg4K45; z#+m1R<~Pjy`_}r_`p$AK*YS^&<9+tM_r9*Z?`wl4i~;gvCeW(HOYS;;knRuz=ojKe zx!bK&0D{&Bs5yVY#{dF`?fY3(cM+% zMQ(4^ilxenjvt$~?|~H#4a+yJvnNuVbk8{t~xgc1b>y*88c1KJ!b9 zJz~5Ybh#`o=+Z$OXCL~#U&!4*vXTFQ%UHqWH~R|bcEuG|2AYP!8qLD5>6x06dVc@7 zBofb*2u~;38qoCH#6*UNSKqlALVNqGc7lSQTFRt-x&-u+6lXW-YI-e`e9@t+x$uxUz{;E;oVXY($y-s~@1J1@9Vgf4;W$plY zRL>t9??0$A7YoYop5QSumwuaKnpT=EtLQzymZ7j`H?UvDfB>5`N0en~zoRCP)r3 zB^j`17AFz4&R$dQpjgzO0^Gp&nOJiF#h=*gf8=It%4DEVHk%)Rm4RQ(F6m%OGG}nB ze|FY1YSaHjpoHzsYyJMyYj(~bZ6^pU5KMRXjAu5?%hGaUMz%Ou-%2>)J$zkb1OXnG zKC^5zw@bE!`FT^sdd-pkn*$V*A*TKl70EA_WnHs(LZvXm{r%w5`(o{5DmGN`Z2kxMEm&DZIAq5GSG`@3aN^7xU$K{xhi0fk({8_e{?!>T0_PO&) zo6_!!Zf~`atl}LCgh;85J`EV+5-$VrMd`fBB2d;}zP*(F1CEVqPbE1X3~K(q`joCr z3mr76#_bEw@sZ>*R>&RrSB)>Q;s2`f_3j}W!*f`+_~fiOTv{ibbgi(T4ovZfbXTmd zw&1Q6t`QvOSM*pPM^`!&)}gAQ^GitcvPHl8OS=#duBh6)Y!-4Y>$Va1#gNr*0~c!E zou2GWL;+s|T`H8y!@ir=%e^=(!L5Hu;%>9f6Q+EiAPAiJ_(4hlyYt7N$H`bxUimg7 zL&g>F+~rLD^|uWeyo-3TFG3)ro^m6n#c9&%!66A}!q*4YXaqT$3= zhI9=|NJ?Jxk+_(i4cnLyW0=_h$6pFui_C*3%$4zB8Ldw@iN^1SC;m&=pMEH^#_S@P zeO~|7tM!y9o`HFtvWWO-rX8vuQ%jY#IbJNDLtW?1_khTg7#Vivm)eX+kmZz09s6ga zA}~ik;dF&t$#_kSsI^}UUpM8c5f?!!hPBqn*)(g!q_2Ld(xjA$@d%!@9Oj<$I`w8Wjgp$na?N_7enp;Si9S}% z28%_b_lO){Fx>uef7eE10hX|>azc1N9!5oj8IngDf4f{{@o8BmXuZPt8W_cBKzEVS z%A!kzO46JltwX5hrN%2>CO9>=y_7quY42i!*$5x|#CIl##zv&(v?PmmPqnGu54-As z4=bpmZPiiWL4tmP87r#&pm_eW%bQ>?q(FB_Zi;hdyRbm;@@9?+%NaYXtkyco_Ocg* zQF*VsdtDERl&)+D`2qT>P}%YdI5&~nlep9Bix=AnlQ1F4efhcTHHw0(Zq_KOv}50B zYFQq{&+pDxtn~)WT+Yk`+rVnsLA(H{e3-d64*lhq=O6z=GZ}XH1L|$dE$(nDf!8C8 zC$rKSYzRbO5KP#pLjCk+#65GNQ1=mgI)5q;t+i%3&}_J_aNDg@1oY_KP&IRm4l9VL z*+8N@Lw&UJN+FN1LdPQpl-70wT%5}c)*tIYrh~V@2MsV3refX~I1r@sE{97qe%Qn5 zy+z@#a*l~=iTY*EjJB6f-7cGwF)!#x47Hgo+hU9*Q&w9|h5`xKbVl;;o@zkWc-Y08 zrI@7LU|Ia!IAgh#s3ySPQp`84LLVBt@`qLalTE5b&KD^xnwh)aHr)t%q$X|VEhpP> zcj&WkOJ#{|aY0D*1L~Xm%3M+KgkKkooQ}|ocMun0W$R3S7k#c&?E8Zk!i;05>Vqn* zr@DE#OF0l;w?avoJdGS)0jQII1fv_1Z8v|q@u}zRpR|WTcHZ(o73DUOBT;1n#!0I~ z^=l_@eK7UVmq=?kY+A;z_8E5I<>qReY!FHUYJ#R&Z=M7$?twRWNB&<+%E_cjyVdWV zfz{Mj8A;7;kEuj9mLg?GrKjCNA z&S&KGW-x61jG`zlbKd@d?@rUwr(buUFydIp>B(ek+_n6@jh4Els~HpswMK8aG!IE_eM^Lf@VD z79h*Pe@&f|$}1g7Itw&X=i77Jqc9DwgrxRINK+#cu;nj{b#bsh!zOxkWUFyY(D`s) ziOZHD&a>(ld5KsWPDu@Sk@YB>bG=u=tM2SE|eOhjl@enm%@L!JZ; zWY@%%x%G%>V%bLj^goRK>%F%g_$~80v6c7^kGv_#*3L)g2=}{vMi*2jOY6o6OZoJ( zerji1hdEv)OB&Y?WG=pj>Z0S(rP3nfi4u`i zMBD-iqM>#ctv@^gB$_?^C*N;9nc32R#VMZ-dgZdy)a}-oQn+%rh^u{7C=GXXK9hy% znC^pxgIo@b_~Jc5Im>M7)IJNzVM(YvTF*Jk#rfk|y@rjJ$5qefZtN1DNET;d94rD{ zc6V#BERv4ZMV6C^%duo#oh~u&J#s9RNh{_XIA}$hs#H#z_l?z}x&G++gEBb}1)Am= zOGhVLh3F>XIY_L@s@gKN06(9Vl{GSIZjoZ)J4^1|?UA_MSy>{GJ;PT;t8P;WLI&N5 zolnV^ry($29`d+r%lF8pb?@t2Z5EbB#BY$3Fb074{Z9_S{!GxZb~gy?-Ybn3K0wYQ zoSbT8!ZS;$(=E7e{Mm3G>fg!cYLqge^(ET;9LgTb_`;F#HyzqQ{c3mAk2(NdP6iEM- z6d+~5f5Ct1VL;iu3^ymAhE*5O!=Uy3gs4lLm(K@3;jw4RSHSjnr!4Xpv^o)Ty2>vE zkMo@K!v5c-1Lfc>&u-f@KdNw+HdO5w*6CTto5x3A@^^q*y1KTB#2DwHFz5mcxJylS zt-PLVhP1c8eV}VC4u=K_-%{i3-AW)geheyiWz2U>=E+mNGVdCfXz(0ztxVv()4-h< z$u+3bKRD;_;Gh3zRc}(1rYpfobZS|fbJpvexfMcBbBg30{$L!j+yh~O;;7{7pU+_nVFSbwWV#K_L+-}A)f9h%`W{~WHr8ot0 zCxfht$lP+lK>hQBXTv^ja{m!f$E&V(f2G;?XTcbHC2a@|Tq6lfqU1eUAT@idd-SRH;0rruOY67Unnc^(;$bk^Vo+&gl{Jh3?r z$QvprfYBkIY;Ed&b^9Y1P*w3&(ZbZHUTj)#-*jdFM82?Z22|_+!$1fAid^bOqwQwe z4i<9lt~1n{Z;!>`@vX=m_`UjHv!rYH+Zryjkre_hTdQKsUElUL=)Siy7P8nW2_9rb zVk&T?Q70(50Ffmv<~O;kb}9e#L)A1=pZZ8WY`jWPM)>>Y78GVz?7g{GcVF#^wEk9e zN`sf<)gxlHo4OXhcbVq5H_Tqa|M9@Nad&@>roS1@bmcO&$3vsJ=4mVAkpiPCpwzF! zWF7KEF!$$8r}JW1(N`@SOzHIEJ>^g)6qA0_+Yruo6TeC2Tc^4+tA{%E`>6(iZ8%CN}8nG7*||s&nky0`BS%-6ET`y1$VIMGeE6Ui#Pvt zF^*bkXM09yGSF+QgQ>(eL1z~P1WWMVS7=r52OU6rFsbuiI*GV)A%~jTT%-C_4W+c- zGt%g*c!Ui?6QH5daLrmf*{omNDRueTjN1m2Y%? z{R~gZy5a!R(VhwUFKQU{LClO}3B8&uiY; z04EpFUh@N)vgxI^ZS7iB9hOybH0FjWuW~+MU}860jT6jK9t%yO$aG1`z68&APGX9; z!~gIHKZ;NKXtDnQF2TFYToG>l0uk%#F+8oR+yc>|_jlhd8p^yXNIhV<(n=3buldXKP-fHMx_(CB~e5JpJHtH(?{J+d5SF6RGC-0eSWkXw43!fnpIzbH| z1Ir=cKtEfnR;wDQD!5i6bvzcgKy`a-@%DiZPotly2bM;c%2#N)knE76awT*p6aArd zErR9=zvKbRXPdmp2n6kPaHn03svVp!rCe6Ih}Rmf=d+tRFaN`6LEPA9nVR6uWtP-fpf^28e$4 zg!`sCQ*kmp1v~;Ae)<-559W~LH5?VpQ=+~Wt?IAH8c|Fi7(|9132PvL#S z%!y|}#rYj!F)d#~cO#dFCP=A(1jbZ48+A7a_Lk}2)q*|VLX{?#CW=+rxs(!(NG7uP z0&6BDX__o$$~E|(PI@@kksNoRi3RQ*#h+FAu6-p*4Bb^$mBdQj{47$cH0%ndo6Ya# zRs~v&kEKWZiF1MOWBLj@fUPWdhY|-MG5l8MTZ@K#@E0%Kij@R1#<(mkoOW zv*p>@T9_GMX(*SHCC4OYbO%HEHD;KHbLN_+nW*;POh^rrkS&A5K3w(k412w=V~#$v z5FWNX%T5{@wWvb_sKcGA{f?#eh`Vwnhwq)G`R%LBU)_u(wKe4m)Yq>ey2?=T)E}YNWAw`QS+_NtQ}uJkM+0I5vw+i1DD6zl{FrQb$(~{fI{l;enq|V5Ta(azPgyU;7|_Fl&N?t_i3ds%ij5S zw6vQ|$Bb*(C|ygbi&3s=T{4~veH?R1MCRVdXG1cf=$Rp&n?Xhxj^9&&S$_?em4;gw z-QV~@FI3lP^e>$zR&WghhZ??(9n+2SnkRPK9Lyo=*(Guj{k79)7SR6gzj{r)Zr{0X zh9|etFPBT0=qZV6_m53tpo7WvVV@&h5v*e(850vwH~fGZg#tU(1%D>X63SP9-v zb4Z}E40+4d?PY-I5NK^>xm`B#$nr{!hF0Q%r-b3E=@OiJW6G@12+N^C& zD5E|A9O&*4aIoKmljUF0i0$1oFJ=FDjWe3bsP(dn(w89ri5Th&5wLWjTQu!jUswZ>fN&6!E5t;5F~ zTB%tzG9*(H+8M>-mHhpBN-cbw6!toHBg%hGPq?a*TqEc6=`KrkWmuM8mD9r6FS#4BLE&zZ&5fOg90pvLEK z=~ep&#GOOlIGgBPY5utBPb$-h>0Y`g+1q8om+W8yab)Nh0LeE^;JVRZj9@mIq` zA(5v``WggxHr<=_+=b-i>GjUm-FGh|;NrBL5ebctxD%~)XLj2WOtA`wk{aC{mW&G* z@3gi)Nb{1ZNN9I=#`?U`z0mYTE#mUi_<-osc@qC^ssCZMN}Cn*n@Thiv<&Eixisjo z2zw@#+N(NYPPZa-^yIzq8*De9q3 zpPc7GtQ_qwt@g-k%=5Kd?e6zvkf=$Xkn(a;e0AC%EYP3u=%ng%?IBOKbJn)Q!Ae?B zT+$`-pOuN+<-dBl$*_!e;^1F;Pt+$g90%kdeylWrt?!#sH(={{f%x5ogG2^bw$rPB z2)GZ-QUquxC1G{q66VO=;X;9HVeZr9g~q|f20iVjQs17uY*00R8**s6g?2TMqeiYT z6$pahVm_9ERkgd5hqo`|3$l^F3gS`gJen4eK&C%3f91IbfPFdnv+x5|ugX75*F=uB z|8I)8s&F2(K4w?XU|BT4+OxL0Zg77)RxJz1)2))}plxJzME) z!uvkwr<-w?i-h|MT7D4=BP zQY?|K;2zIJ`xm=eK4sOEX%07*51bIQi4e9=D^1Ro)2)R`0P4I+AHM!#BI-fNA=08k^~2u%kMYng4B2)ajV@*#^49pPZZsA^(f)=D^jFga;oO(r@{|7ko721#Lk9|ALZ?k zJ%zU=N&O;1AFv z1y42p9uxY_{P(y6-HdR@Zwh87pU|EZ=8!*Gkt?Nn$@s+Ws2pBx){A~K{ek{BwhYlT zs0Kvd*o!w_zqLECFJT%KX;}1%2X_MplZuQ3p@x_u-@`5a7HOSGey3qz$S&D$O8T#Nd3 zBT(0srA`p3m@Y{Ev9wwTxbWoUJ4?g9?wT&`a*KnZEUz>>m9OIzZ&o4ocmbB|&)}QT z>Xh19hCeULl+_LY&Sx6qsIA3X z7lKwxWzn+4abjk$a6L_BA2*q(4m4yE5(`v%5h}|b$9Ba zyKfnwi?I5Jz9I|LwZ#jEeaKMlOG{)5_~LG}c8VcRysDI|w=`fh&RN$;Wx=5C{4Al7 zXN({_cjIKAklOj3!0(Nkz3u}I{!7YC+sl$JUJGPkWnWwH)3xw)u6I$2lC+1DGj{R#I6a5jp9ka7I~1nuA=u?ko#nZG;L<@Gkg3|c5Rc0S!rV9O9P|t{4rcH z&2BGJ{L)&x{U1ZwW18+C5WLtVu{uMWd(Gpj0SprcQGO7p`=6Iqk6uA1U*Di63^2m& z@^6F^UQkhv@S^BgMeF1v<9IIq$foi&agjC7YNuv!!bf0a(wDgYfmd{g2*J1sx!84g z`cC)mc#E%3NuD;}q%_0E$Dwv`3Et=?Q8)L3k-(5cR?b%zkS@Y{R21Y2d28fA6TGn< z8ak^8-l3+mXeY=WZbw#jHSFQ#)uqcCJi0xXe7Z?^_5eyIIx5B(ZH%7>jGqSS$ zaX~$HGOh`VTVF3J@3La0odQ(9rlrQ7i+{%??fa**sK9S$jo%nGYGkpsUzhxUbi>PRWjZ6U^|#g(}10oaT?+}-CwyB8rINDGs5ZUCdBvV#@{Xgr5=<91vyw41L)R}ms3I$*%9^ks^qHJSQx-X z#P|bAI;DN<)|uVsh%5`!(Rep`0;=k3;C^3UqGu^fZB3#&8Jm@yS658zJc^l6zTXZEh*cdZ$592cPIsm5 z!d&)eZc{z2ry0n|nTl+dnl~4^PVFGIz4c1HViIku$t;aKB*htW#NOuz)6be^hCJYP zuqnYrm$mQ)^fMIsd7TcbH8k}6;TE064vFfw`2niglP$ey5wz=$8qI3%SegcQgFR0V^ypvx%ewF8K1FzxU^_I-%7xZyZdO zvF0JN5a%tleS}`QI(va3);n=s96f6)RU`A;v)3`xs4AE+Pozf5$0wznB=+cwVZeC% zzV5P}g6qZC@~(*C_va5^ySi^`bc;B~PSQ4S=bnLx66=Jca>|`f9Brq^X1TX)#b%bJ zn_B++%5*jWW@MJI4T2UgkoX>Hm=2ja3|&|(zmx%tsd)r%5~eL1>CCJXj?Q_ldR?v1 zryDzFv?Go(RC^2NUElk!Y7E7LR0i*D|&6X+HE;VP%4t-`Fw zvTm9F_ce<5IVE=REjzH@T-x+1%gNO^nAhTj+8#?;!)u#D3wOo+Z{tL?i60{gS*;D* zq1zwChr`wnr*mBrt}SaWA07k?%_6nkO9^1GOF+3pen)1yY_7Y&enS8?RRuFK;&3UN zv`ZiqFqrh3DuS06Qr#2Uagz0iE?`)6lq`mPHu>8t>6o&>)df@e$DjUoRW08@K<-9z zcHeC)?-z)ylH561&YaskD61+5yosp{+;br zAAUF`ZRKKhj6vwZ^BmJ5dP7JL5Kf{*R|=!5QxyJZuv5^Q#M^=or7_~Z17?rp;AJe-Bk zk*F^wXLb*!-7_B9!=xmf&ohAiiHCaBXbvcDm_5vMlXZOJzptK};+|}yVIuo=BvbT6 zlX$C=OsrME&ONP6dtBe>Qf!V>Es3Q_fZqwr2#`rL&D(Ab*nIolSQ%moAs@#QiUiRG zeJPe^U^!0=ek&aHoHaG{vY|bk%PQMN|F(11EPufWq8QjBLxCaxwncF3y=J@PaSD-b z_=Sb~gW87DE;Z$Qj)|dRu*LC%ZX#RiW7`z1EVB>N4&L69(fx5lXm64{dib?VrvLOo zYvW@&lwNPl4S$$mFQ;au>G<;MDe+x_BBgrq_X`C7M68nwb@3ebFF;lzYy z*`A|7?d8v0$GM4R@&z#J&0XFsLy@QbHQnPpbyX;W{UEa*WfhB!lLsV48ip2Qd$Sh@ z782#|PVmgf(hX6aDLE=QBPV@?sd2sAv{$X{@XF~`sj=au<*jA`O@xJfX#yyHP)cLr ze7#*dg!rOCQo&pJ$vW%N$LSTwxcpgB7-24b&)}b4vj`>(OceOly@Yhws@^FQ(BQGS zH3K_XQKas#8}wvL6OA3RWgEWF&?(eyt~TE(%QP`8X;Zx(wtCR`?YS_@ozmE!+#?63 zdSP&N0ifwN#eJZ$;fy_eX_-QHAv2}kl%^J0^H*2<{kmFrpact?-Rg!o&KeZyyLrry5Yh-heu`d$&UUV z=8OMAVx&9io}w{vp{#Vde%GYeygp!|nX+<$a_cdZb_UR}W>8e^Shm}mWLH;FrB zx~^^k-35lTLRShXV`$_-VnOd<0Oh&xvzq0!nf9VHvY6c+mFa=_(kcU&!_5YkmB|Us zioFkxUZ0&>$F>6g>1B(~N0o}J=L}2Dow72_zkFTx-emVMt$w#sv6*6EO(ItZ24Z5b zZ%LQ`V*Yv6bUR}WW#7y43xU2jdBC7*nW98^(_c(A!I81kvFNSqbz;)gvS!x4=>(|qt;;Newlmq)W&d`^3pl!!BE+NgTruAoGd z`^e(O)4|WBUQLK&pISqNKPE!9yzGR}t+;N=dJhS#g@!K7*eWKdrf~mH{5dWPszvQ% zdriv)7SAZ6=KXpOcQzRkK;kS1L>#eU`{40x5{vo;n6q6u`=eQgyS+6Cd2b2H$cEjq zwr=C;Y|PdYCR~=ZbI_*leCSkws*xXI=kg|f@a@5BWl@|qo7qVv&qfuucL5n%()RXv z>%q63VmtGLrt0kdjRUD0<3}Fwht0-7WRD98m0T7MLl+ObVPMA!y~F+WWO&{8;w{WQ zPw%Ql{^q-I%-9RX=p+Zka-r>Fxu@bQT9AMcZpi22`*hIE1wAiFNv;HHW-g8)gvP-zd9Y>zZxmU?8_QzVH$RsC_#2 z=DTk-o}oK~sqk`C+|rotFzBtLD5e#&`^Y#KSdE#jsP&9W#DCnL8w}HMoL^Y4Ssi?F zsq;ga9s1L!{-yej)I_nM?eLbme{Lc*34T@4io4j(3)iAsjov_F(`Wr~V7+SdZ8p6( zQ=P!cE77*eHyd)*hIC8s2^ZEzzvmH)nG$1{_2eJ(ws|GSb2T@WJ7Lv4A9|$a&kx9{ zzA#k26q;X|_~z(~Ks<1gR$0x3T|@sgSFWef*=&VHbgb{B`v#c+PBuu>QiR-$I6qY3 zN+OxyE|lM702a0;;~I1~z-=u-cma9B*EikuhXFZ$fTXFXQu!j7cW20%qo(7Y%+gPE%f_% zPnlY(YSN4mKyggcD;Fhzrd1Vgj8sS3@%4HNXdw}uVzL@fv6b)Bjcj6_@hbWux3J*A z-V2k$LeY^XtAR{5*ZtBGRHFncpXQbeklse-Y(fZ_Mqdc{?NW|gh9>&!(lfXT zfjaIBv0nMT+KjLe(?nTW5ugit!CE#(auFIdNHSK11F^6A&)7HKj6wRx{)JtCKv+A1 zUX8tq{Ybf$58khomx;s)FM7O{RFdygcMXiX?KK~H}Fu2tI41uL&fo-*n$ zTc!;IOKb^cE@U`#$UW8L?$!aqXfJr6CF(qUonjv7!OF!xibrAU!O~7=a(Nh|L4Ckx zSX5|QV-;zxP^3LBf4-N7Ta~J;630e1yIo{3SAF6-pJ1nwaGm;>5v-gHO>{sieXud?L<-_R21SNEGao-UIEFO;lNJc}q*C z4&}Y0+vkARW42%sY;6rEdAOx=Jr4{plMVal`^%s9doO8XDhJk9oHtw$%X+MdOf8cI zviBa#`H&wjfjiO%wXbM5T9!pOUciR}Axw^DbhXb9@< zb9~E-3^|Csa=qaj=Amq9k_!&l21D}WS6D>~j@t$fQp|D9T)i>XAnRi| zb$%^*XyKTXIkIwN&_vQTU>iWw-7%Or_9f=9O<4mvo?+>;< zAUw^XKgwQz;O+YT(Bk9b$Y9M@n%Xw(t^vYQb<5HUNfsfP~WI?HRkZ%d}UKV5BgRCEeZ=l=ch4We&g)%ceTQ8l5V-vTQHD~ik zWsH=&lY^M*%+2ax19QJM&t9|r@6X9O%iz|4vBVe9ijf)-oN*;58n*qcD79U0^@~kmy8#(CbOx0ErSJY_ zifW#@<`nDV@)}Zi$@6|z*{r>;eug!L;1Q-nf#zE;Re^H|fx~q6shtmceDI2I%JKc_C9&pyT5Bu6eh+{)irk zCG-tKVN}97cf!BMUO*nYOQjnMC@>L;SMC*&GacpiIXl6XGl4$NUYfX;>23{Gz$QoV zTzAJBFnaEpX~i}VuzI&x+y1BWks&Ur(J$!X8CYvUuk0X`wU|+awojA)L?RLw&*VzI ziWlert3)^xgiIB0B?C{H-i^`(6ddU ztJ&R*qUXFH~ddAGHEctt@E>stWZLP;&6VwzgzC{K(sBL4@O$WUa*a zVD%a(6-KFoBzc&_rqgDJm(v=m6t~H;U_5e(n$``7&`vJX83gw3 zO?W0>^lzk$)%Ta^$vlM>OD@H7lH6Gd{<~|uApA-l<-P)J1#6Hu-SZDx{|Nc*(O^A4 z)3zPwf(7D)$})N)H*(Q?nLeAf4PJl_FiDqy`3kA6L1db>Gvi7zsta1yuN!qDwI`qb%UO2m(h_XV2zSFG&yg$fR77Ar{XXu zzww|+DSjUI56KKKQC!Tnb6n8%2P6O1;xE^Eai%o{D zlj`yxo8EgmUtV1e@{u9>m>6Fd0`;v~_*}F&2b-s4p$+M8HE%DztMK%>X-abx38*GGR%Q=Nb*7QrOf&z zd2ibdY17-^4_lmgP>h35j=S-+$*3lQL>*jRwTx{N0@&wyv;PPdpEcU*h`oPf`#ycT zGtP(PsL3GI+#Qqok_%Jh$b(#}l-U+Ud?qOj7f=3PkTB{pS+jCC44* zq>h)w*w&i85M;amrZr8EsuY0!KTC{?2lDHS1l({AX$AXCGh2Zz%(86Avy&(G016Zo z)$*(Y_%;T-vw0$Ia{8Xa&fL6>!&lkek&mg|h&tjY3&Jl|(POdL-RGLe{X!B*#{1Gq z{~LY1l>+nc56g`WLY)aoS?&R!ieH-I9>yL{S4RU<{2p$fu06mbt}a|}+_)Hl`Y9vv z=8aw8}iGpM`PR!Mp7d!e^C{dN>{J+_hJ>&CutKNWm#sAReMyoc+AnXad z^kB>tOGex2BD1qY-V_RD`mJ$k4Pp5M?U7TzV3luu?6Yrh$d8I9=mh0W`y`3x11C7W z`aTrbc&O&%UWl`{y@_ymXgpP9Glcib^?DuB2OM>7e9rN3>b{nhs5amm|Mj_g<}OV9 zVa|j;F282sghwdth8%SkQ4OsJz4n!$l8uCmGTuob{}OE%9mm9XkcGrr4^^QrIA9_2 z5K3KMT?A_MfAg?M^*ltMx-+O8vB#~-ImA^hh`)IHM3t!wKim5XVAT>SwP;{5Lr2!sk{2a*7@;FS54+C8Sf;Wq{fmuX%b zBj~cE(9rJ-?@`J_zioy*W7?H^s*AaAKuI`(34JNv`OM2&+eM~0&U?}`=2RP2`u`c z{p-f!^z&a3Y62Dx64jJlecl!~R2w^2uD*<3*z`vs1gMEJrmjcUd$g_^HK5e^WB%jQ zep%7UZ>;84TPpNE$z*=S3X24Bd|{gs@AWJmHPYuU3V*^Uo!H|agV3$-#Yz=j$Lb-u zGFt`%kC@VXuTo?E(Aj@gdH*W*HtC592-W_Eb6tYJ%6a0d^Y&qE)LM+$;MYYAmrQ2t zdtvM{?Z#e%O^$!~=Z^Z*eTd{4wQQ-_mMH9N6()Z9BlmUhl~EiLbLu$XVpD!#|xwvY4S#(gI5y5`j` z(G!b2z+w*Eww0avhcU^YrMSr&G9}IWF^0{2B@m|XGdQ+QR%q7`tFPz_GsjE~Qv#)v zcozm{zG{B#txX5RV$_N~9%51A_s6nF~UA33k4y zCEy(Nw!gmM@&g>z6U|)FlFB3jB6Ccb&5gJ=(Lq5HO&H*41VsoUt`xDq)%}k8Fw~j> zc}IPP_1t71CQzzAmp46%OMtD!BePVHls27z8vaCcat-s`2U+&gbS==rLvu|_1@st# zKO*Xn0?@jT;^cpqERO21#a=SNu!1c4^!!2uFl$pSkJI|%#fuA@DApl|dsPB>wd?Z& z$s0w+Y#t6bmWBAO?~OWCzn^uJ8juH-XbRq}F$Ho8^W>Cen$9n6>u$$9-zMe#7iA+o zvg4&NOL}EnWbR9I9{#(^$cHbd`c(7My#OSSv<|w#*$;OD)~0s5UMTkw+(=VK9cnsS z=<{#UfzGiEU`jx9m5870)0iKhcZpf67K?|MYa@_}5ep2yOpj&T7hbD!sp=%CyH$yn zh)#VZx@e)6$z)(Ls{eH{j7#;+$wK^v&V)gAXZha#7UM>4UU6O{8{Sk;m`s z3jG%6s#oBALJxae`4~o-K|dQBb0uom^J+Mi{jb4Mua+Pmxa$RIdY#XSZL_|6?J}!MhoRW-oS}%Kj27m9oL7rN^FX_y4@N%+k;>{Q!ebRVPP^4e%aVhK_Vr5}URME^p z0?PnZJ>q-*ZFM1^NX5UmkqCkX@!nN3Q6UQVu-zA1Co5+C5Q_^c-Hg*NG+STO>vGm& zp2v%p2Z&&@gY;ZX_<>vuXh-_DT#Q8VK8L9rKa633FToY*8N={C$=EHY+;DPGu2I{m(|5qo8*@a`mnsjVD7myXg+hs;h z>1*bhX|?cC5^w=ovmQ%(^+tk?nFGJw2{XF>TX(MHlo>vtPh%@f5x-p`~!kH zM#Yb5Z*TAFTb;rUe|e&+P&F>m*q&Zis8;c{x+UWcJ0Sdcoe$#Rmn>tu7>@tSY-Udy z8yh^+cQJJ?S(W#;!MZiemxZUo z-cjx!ol7?aI;YXQI>s&zvZ_Zfe7wIYBT`$!PI*kA5E%x=xW?zgtQWgI&IfB2+5?V4mav7aHj{p;KILt zL1aD?Q+}H|-Kx!fZA4aP^s1cJ+6bt9-sWvq4mW54STD|wOQ{IjuZymrEhD5sP>6Q@ zFSJ05!oO!r>c~FTp3McL`J#kAEGRGB@1s)5?=dRPf)*q9m}9t;-=}wJxduE>;&+{t zN;;96C%#ZrKE)1rU^=snMAsmIJN(yN&!O5_CRA{a`SF`%!qs*z?yxTFH9_IjNW{s- zVo{$;9fSJc$oU0QsvrESMjtBua`c*3H4mZJdvV7kj=&B=CCI+q6vkBc%8j__!+<%8 z=YO|nLdEF`)+c_!x@;B^O9JAP1y3)&>J*NXNW-c70qMt4EM8lqyKrnehI6RqpqUD= zv}}~)o7Q|_%(dbxH;6|Q5j{Lr3D;AzbvnJxh=!&5o9@qCl7Hp3hA({k_B#)WfjcLQ z^=M0cb_zcr`9qJ%_Ho&VJJ~ESt@dqT0*iF)ty>lWtIDd{2~n=6$eaGK-2xaeX$t33 zdkBmx@dbfy(>8<0{2trJ=g&8X)5UY`JgT{q<=ez_zB$|P8Uq+Ln!P`D$8$6A|47f= z-4DUU=1fqOHGzpWE+@KU)y`*o&zQSvXHPU8fDnJjPk-Evrg|lYOiE=-pC!})P8(3d z1%Ej)?dhS40)d_t>md_n{Vttc<7L~hJ!72s(VzbBf%T6&atUf-Z5pd3znQSImn}Hh z`As!aEzhGa_+z#r%)9}m9y<-^N|f{4xn3^*blOvxaUY*e#RION3%1(Auz4R_sjsj9 zzCq*frI#OhJXqgs+RwZg2Yl^TyOx6Svt^6*F35-yqk1+CZvVRAkmr_+BOr|t(5v@< zPt||iWm+1IU&_!gAm=b%MO&liq7vhofoP*JlN~wu?L13Ed#LG{vV$X_y;?jUU1`E z!ZNgJ7>|F`2*-SV(VjP%XAx*xs()(EOGZ@vXRctzO@Hdut9|M|n93`1OoG%?iCO;# z%>LuHYN5!sYCchDIn7k~X_Zc)Vbbm9HMyZhC!)vUFVbJ+14&x&M>Ch(DgZdglieqc zt(?4?#>E=fwrdD)uk-de&Q^@PallXyb|T7K-CwJQ>$N5@WaEt%(;*qX6036SrUi6o z+M#+OL1?+}_uw;h?}NP@YYE-9x|P8E!o0^UoB7+2z{TnW=u$jjFu%`nZyX1p@4mqYd0D2z~wiAG83j zqemk*_at1;-sF0m!+~JL)u!{Su!?BuaJB&B=*Ie8?%bF}OdpVF`HUPPC2zE8{14N= z>tsMD!W40K@YMGgZ@q8ks;7-$Pfkw0e}8X)=&Rzf6-| z+$}uqACzgnue8wO9qy=JrBH8BO{v;xmSJ5undy!GJx0kW>3SN=DE)W9aha1}vIs8! z*qhSA5BILitIcPMI;&p8z?Tm>uvIaIg9g?K?+1Ay(RrUCr|Q?x6}MIo#M=JPy3yZ? zXFaGhbJ*twth@(RDK!)8@|gmi(UxN)Bk|WnBx%mCXhiR>*UT_c2BB>5Q*JZxqT;v* zg5J)~&YE{9KRl~hMb*Vz`$x4~F0ijLDnUchakj2>piq}2mF|b3RcS9SMrsIFJPFU- zhMO*I=?AJ`qnlpE1Ksyl%|Y0HQ{wz*ebcEjjO(t4{h(D4*y4%{*~pRM??81pK?XaQ zx2}1{K1lGmlSZRU_fI_$!V~~Uui1(^OkZnx9*FU6<3|=Mt7Q|b&?aKd_9Edg>DZs=-k^kqF?a z<*OQlxw?g_Ry)D`_c9Am*xZt?Y{=z*8q%0EYD?2T`hk_fjOviKpW0GN(xyH($E;f1(&`?f`&!B(Ko;QrX@0-s;gD1rBUYV+#L=)hiZ**cMk$ zGg=J4{5q*is>-nHjgcBhjFwWO!UTi&{iNQU9+l6Y!0CU@M~O4QksDE0|EV8)#`yVA zer)FV7n_;P#8+NkM(y6f!FR@nhF3q#0^?iRKROQ>62*A+Yw<3F2ZYrUuhe}E#P9yJ z$1$=zI9U57LQY-&| zx$55zEVZzHYU6h~G*Dy1@vXO^++hKK<|KvL;Qe*!$Ge3;p1?c6;T- zdawYH%<;t3VR_{0eC*CvBX9guNGfD6_=a56!?6LTtLHm8{z-YRH3W6rwpG6|l2_7f za+We_jx2mwBlM|j-xYJtiAy3o;`1$&=&rKgFsNSmC9!Fbn}SO9z{pgUtanzzUi`BF zxav0Nf|v~#123(+HjLR>8B|wQv0--E`gcMy35X5WF~$xLA|B0FqGA7-yCr)EaIN#E z(?4{BT$-I0yK0ccH=V3wCccN3iMRiUF0Y!jJR0VxcTHwm7voN7U)ZwX-N=gY{{}2# zz`VO-^zL6dzw?TF405yN^Y<6eV~v=8%EJC}@c^M7H75|cYw(p5T}bKJReUQ?_T1Hj z)#(QxI-}ZNBpRDE-{?8e{zsqnxo~7;L^5W8`*lrqwWN>EkA32TR-y|K0H;0LMd9&y zJyRbY_3RlOGXsOSmEk{{&$p+3i2GzqV@-zbB)|tErzVS#e(~YC@`a1HNJy@bkO*9Q zt+bQ$gbeL;j^yl57`W>B>z6JtCrf93fk*%K5fzmE>pvlB!N)?vq5`r{ov!qP^`%%xoAyleyJ=YoSF zWMr~0{yMpwgydWD&6_bd5f7}$sJi2YLC08~52b%@d=bp;2%OVuHV1(~PSnW${Ayts z930#?U%EYTNS?rFTJIz*X>yx_f}-~(6B8pf9X&P8&H1%#lN`N^f8X#w47VZD00 zBs76fK|yZ30U(e$q^iL(TLW*lYf6^i^Ky zJ&@%6kuQl^Khzn-eCM2uU&a3%yj0#1;9u+5`e$^rM&XY7hdYyXJ0EepG|m_mb7_#2 zzKosz!Dif3M2`*&;D>&5$uh zbW7V<)_cxyy^x)QQz6}si<3`)h2`<~TAgwNe@atQi!^^*jC=Hv;DA(yFzvFwP}@;rZv1WgiKx$KF4;%h$9 zKRSP}_$}-W!(LZhVb!)Qhw+o#oA@syMB1B2xF#2pu3q@VZvJGUMm2Rl1xW-*RC_!2n{VIO&lIQ@YrBpV~Q7Gjs_7J02{ zK1IdB-v(E%FWw;@hSilFI$1*q`~thb^J@pGs#ix>`Uao2-0WjI#y5-&-6qn-3H1l> z+`y+|3{K-S0-WSAvZe=a3;Pv0e3MK`!lxMJ07Czr=W1}1ZO=411%yS(K2n{Tw}`SA zyVt%QIcYG}5BW1~ifIeZWPl1N`*(1dG{0)K?zReD*Q+=-Dm=9_dgQ(2w^cG_gs?l_ zYE|y+_oX1?jA8>xN`4>xP;`fy+6QmrJxX-T)pb8YS5~8{&c^VZ+*v1$L_~s zD|dqCNqB=XA3Ne@_WcE4@WF1e9G3|w~Q|I8He#cZi7Ne;d=EjX*`zpizsIIl({|7t)5~cb+Hd2bD}3vFWak> zK2xl8wZTdcy^-*Q=TFZ|$lR_x4fOX<2@CCyihbo}@;yE?7ksol>8um#SGWFr>jxRI zl>)5;5d04fhiLEY| zV_zS0lGWi)FJB6#fPlmVtjOSH7+4)Ho;bh<_#5Dq zX6Di?Te4-l`Qq_{E$n<-Ue4U5w^h70oxQ? zl9$i>DTK#|)N!(S$Z-IWb~wXR8>4~XtY3KyAWC|-IUCKNn6%}S!Hj+Q_WsGG877r0 zoNrm4{=N&B;PRab_tQq*iyaZgP0!oX&o^6NY z#X>Hxcz<5!+eQ6`!cO}i()!s0+1ZVid~dzc-pl)?wTje7%~pY)D%W6z@^y|;t(!dQ z*jZYi%e)O%DhS^X#Zc+!n-N8$?#-_2MRMbf5>1#z|Gb9{Y{4ymoZsf%jweN*K7Br( zRXqOsL9ZfTmL@IoIQF?=|;OITm0j6Rp?i#J2G(T_)Yk6QXAhkAjGqIP6qhO&cdP_akp;M z&=-b>yB|ZI2Hqc&Va@!}_lA(C(?HE)W)@Jc(9Qu34pA|d^f+*1HidW$>AzBR@$b6p zOnhJeXSvSSZ@S2Y8{98XA*Wb(6L0ivZS%U%pAb@;#QR{&SaW5gb`zG6>DzoahE4GP zeQ`L3q*AwuE&pg1O(>hv%8o3;Yjx_b6Jac9!&8U1P@j^-q^r$ zKH7<)uRz;)#7>}H`-AW7GjBVKypYdTruPLP0R^FBYt@m$-86B>%ZtCkGANW?nSr+5 z?W3ys;P3y^lLD9amb*WGNN2vx@NG)6Y&k3f!o*HTKoNfZD%~v2TPcl+w4`S!nZ_)9zfUy{RS zO$>*QaSA=K+)Jcoc$F!R=Y~09i%NlMPVIpDznfKHxJ^QGnkb?Q!yy(*?GN`&bxOYq zlYQv-*-PZRz@hfUC{TzJ5X(jIJdh3^s7El_lbS_!8jD^b2Y$V$b&ryq-CQf z0~(ispWe}5a0C*EW9xZYi3hG|J{Z0L8FL<-_!yG#9(m$~qx*g)o?MahO6K3@zUKichsEa zppwk1wu4wpS~CF8`f2>B#p*U(Y&F5%9cr9%@)V}@W(LuGDBs^1uUhq{u-;XtW*SSJ zI`__b7`8r;;GoW_vUHzG8NUo=xb>PheHccy+AuSO|46wV* zetF)9lM`!)JD$l35e24xI;$i3I)%fF-T7&$V!7ir=wwFm(T`ad-gW1#o;`%*d+-yx zrD*Pi3iX{utxM!dlTMlPg#FGKo32|DOzX4Xha;wa^hkLm55E15Klcs#XDBaZ7;bO; zgc~&x3OqNS;>T@mCToXDg~RWpcg5>K>kot-NoLvpzLvy+m6CklvbR7!LKlz4#^mFRw(oHQP7id{-3Cb5%jieN!!BYM~IspW?dk&xdnsdco!iphF_ zKU}t%edd=-M$#Dex9n!==1VtK;(4%T9m8U{tm8U6x-v47#OpA|vnPBLYBifHYY)?U zNo`bpV2=bO32hh#-suFCc?y))C};cir@QR z&vlBEJZI0Lvb%)?zVEBS2LaM7u*ZN=?#W@tSoDn>1x}XmrS>qLu)ACjTJ<26&KoJd zJ$V*u>fn5tpcLLj;llb=KG-R-0A{OGT~sm{^w`?~eJS%^aoWei=`#Ud?*XRZrN@rR z&hlb+d@DO8vo5Pb0U7mhq7Z@)Y#VZf=Ho_E^{xN9!5a9`1o2ZPl$Rn zJS%(g34AD{={l_r!4#ny9|6B+?1Wy#o|5R+Yf-PYFP?ZEd>btn%l9!WYHCz_7-5;X zuhZa45J+l{pgGwNojz*xz+!b0;u9DS@Os3ZX)n)8j8Ol|J*U03d~zP6oK#OGXk(sy z#0cpkbfP-{2J7wx`9*Wbw!$=A&s?`NF@5`5*^DE`LrF+`wInrO;DM z^xiWdO2Fp*mAe%b3YFr9zX;U-l_0#3090x;Un_rzg@w?kg{yxnh0HnrNR<*G36J!} z{O$x+6e>SvLwva(r(vGzYuLeE{Hv}aTvZ>NXzlU}CAYJ@`T#DDY2RB|K<#3%g(WT} zC!HLs4}N`yHfTpMVUrzt9L)CZQMnO!LE5Lji!{VL&sioOPyZZlY7kxEbP6%`QdLdP zaTpS@Zn=!g39DbcEo>9Zlt5})UVkN}B(=2^#eoA_$ zg(bVZdvC_SsH>Z29KwiImh`Nevmx&<;3H(1hSZ8t&mNi2d5YMacB#95zgJkcy-ep&UO9u5-f7JK_tPqmFy%7}>@eMB$HCI%7Pa zPw!&tQzil6_>0{E4%`&4ci(;}CqKbtFoIQ4Z)+Y@b&0&-%N=4~kaB{HndIANU{R4b zW24PbiG#16^JK#I3^IZ~9fN19$dI@e^0iQO(tN|Km2^h(Z0ylfn^TJJYM_1*VHC5)qtGgd0}{>4{B)kkJMo#R7?%N)e4q>Z-48BdS5tvg-^^eRJlGu~9A>?i@!i@Y z@J;a}hc)z$-mO`uVHz;YJp(Lq+$m2p)q!(g!gsi}pBEeE2QdvgP=$sl`9UG0@w}c> zbe2XpGDRdHVvApXR#DNo*UG;OTCE7;og z_$)|Olw-J^`qW95^rM|&&0e2Xw!;iyF$SKo_>6B%!Ab?yQ&)@l$RFG0_+`Bme;vJH zF+Q_>y4B(Nc4%$P>het`W)ojExRZB?ZMw9*Lzh&cE@62WvztbTJ=~M)jwf_TZc!$y zstn8URMnHlx<{Q~*w zDjF?%1zqe#L{(Vn>`!L;UB31!!p3JG$~a#c5cByc4wTahaGXv_$`WlN%1}{|A>rF z_V`#Oq{_ihHLJnpHQh zQyt^{2<@85RFa#0JI?^#P?B2nE((0un(3Bm(OWQ+bD!~OZ(Ymb*tE%T<|ZFzxoIa* zbY}R_?xBv7&uP=iIzkP;`@Cp5RrydzK!Yk8ik!9$ZhR|6HBd#B^VlvAx8J`4Y`-_< zT><=h-evVdsf4)A`>uB9%)M=_7WY5;Lg*;J8-02ndd^RM8b2nQ^e8+pmYe>}w#U-KN zlVY8Qdaq|RHd-oW-4GO|kjw|&?X4C8%o-VW<86rF##5aP|L_z~?ySMgpgu^ldE0IU zzjDIfkNCwk!1p9Q9zar%Qemx?cnmVqmdW|c5x^8k8G=dmn&yIAWhG?Yc2|adg0Y^*y=yN#|UYg6p2>9K$9esE5dGEaVyOoc+Rjm;lcLtIcp zYK^N-DQ4QMsiF!POVHTTd(z#_ z`>T&%X9Q9BZpn3}vC6O1Bw6&@%rRXsovJ73K&LhHHL<&k-2}QzV-?9W|XcQxPr9p@GpMuiatiSJhaJ>LyD;PcJSRt&n&yG&YpGeKVnuf zYSahPAX3MPO8erMV*>+{N@rapNdQ!tvn_P>Z3JzHOz)R;N(RM5O7fxp@rv=yIh$#5 zMnP&0b!7GmCu=EwL^Me9d>3Q3Y|7DxqE*jz?p$X@037Xm*HiPz0*nT2CEZ zEO~HmvHz*_rxwpJ^lJT!TUmH#z|(9fsi+)M-AVqbNPNCP$yhYSep=meB6h!^ z%`7szyoD6>Ni%%|ndru@&XY?D@tzxX!@egD$o#1Wd?wkASCq^nY`r-z6-?J$TCez! z@6(@cRpBK-8sWL|mEYUc3Z^rZ0WZ5P;FtE`XuN*p&K^*JW!bSGlGOa@s)$W23d z(0w{sphD$E`QDp4*kYFf4|XO@(S^`x3EL)(eIl!wF5uD~CbiUWPI+Q?&#;0W_M|wa zq}L;76l|WKDKqozq=MkkEW`Wd*Ou+%_1Kp1IH?0D+)_9 z9=Q`o(UcXcO`eiIrSP@Bk^Te=eZn@~mzSqkozmLgsZ5l!!3cX3_?`Pc@>eU?qbEz} z0>fMC+Y(^VM^^_4PtSs9;#Lsl4<_+1pjG0Gcg{#hgdNbJY)77}&`z}@lr zXjAp3eJ#(x{h5-PsWtoD{eG}kF0OgP7ULopcGsroODu*_%)8#U_SJIVFlNGG-xOqA z;pK*{ytQhAi0|%60hwU!sjq~| z>*0r}!i10rv~!l){Jk}lT(&y{8*ZFLAv_TYBug!Uy-6FjA z9xd=vGgDEr+9AzvFWJDO@ZT0@E+hi1`|&a+H+;0g1wz{w$BmEqtH5_r{48-+{Nx)3 z!weQ!DiZ_m#~q(Ux~>oNBWt&uurVB3x#YBazW3n|b$MWfVa};G3i6%T=ifp*!n4(m zYTduQ@Oo0@N8E`(YDHq)v;V8b_ZPHsvmcMA`Zl7SfA_)1`@t@XQ%<2Y z`N}f`nfXIEZg3KfF2)uaXf1H=MHF09*^78JSq_|;@Gef}KZf0SprOVS*JK;Wp&+00 zIixDUoQgrwJFhPYfG>ZdWjVRV#O$_0<)IY~{ik zU**K7r)>AuO^w4=tCr29xk4{WZ88fY==HshJbS79xJfF{8v;9ZJMk5sVM9)Eu5~;ncaTjYF9kow(D$= zS%A?jDQ9lh&iPFLvX#kCyebX(Hl08Ob`dIYi&H%Ym=S5}6aXM2n zt9d*-NA>IsUp-IasPB&YOqV~jR})}@&WtDkjJ3ydzPj@Y8{}yLr9_F*SA*Iat)r_{azCVnggkgO+LPbWMrPh{|I3 zawybcETj2YbILKOc>)a!qhAF)KYZJ|#02}Ev{v}Z&Suts`ovpJdTUg=4Djg8rOFS_ zfS*lKz@A69%Hk)T2{q}8H-H4&%g7zWhVSICIogW_pYDUFf{URO$-$2Sx18$9g;&SS z0hIXy8# zm6Y_Qsl$a_i@FkrhI-?@Q#gjzQ0#RS?IOGg{$D%;`x^?B)X^9>1 z)gk^y%|BrjVtVsF>#d3M>=PxyKSV09d{c(xmE}z4i;D z*?Jv#`PA^Mxq*}@Ddy47jD@}g2qP$Vd%4yTB(nRRblOjC(bNxf<)9vx@2nL2%i*dM zy08T6m9g9dIdooBVtfg>C2-r1RX*sTTlmCzm2&c@7u^$R|AeD}Z7{iYBWk;7v@(6v z$bQTE2hjO<^fbVVu{!m|kG>=X+9szwMJ=ZlmOhH1Uz;-8Z$};rF7{J%>_W4deX@Xe zgNCyD5;H+=y32jpefg%Q6wDhKD+(%!EHAwL=wm)LDgfaBW&u8p0Pjw8vQgV@G-?sI zL)`}HhPRhc{0aqn{EJq8amSRqGC=@D$mQjVTbtjul!$*b`^`3xh4$gsX5z?i)=QE^ zZBj`)+MnuR%+IN{F+vS(Z(0enRD-P^Hs#GkW1Y`K@-vhE8SngPgx(}p>z?1i@eTQ5AqVh=erJ8tPexnURk;= zO^-Mo*HSX8Bs%r>7*-AInR=`T&fjFyUL7Go&R@oC?O`$luQ@ufo)U8bAZpk5gHKZgt!E@9d`qp>@$K}fsk)sPIa`>$-}YV?XUVRIibYgk^SX`t zJF7igGu>C(s%^4K`RT)%Q14$$mz_;r|BawtV<2GCLs%SO%3dT0x4i? z4Z6HFqP4aO)3XO#`3{B^ug5fzP8}^$&gF#dMbPC3mqxEMm#7!o)mf_(m4KHE-QG;* zW$tXhY?v5lzb_qBX^))Bd`#Nhqk)E8vgB^xa9X{St^MVp73M6Ee~6`6&K|FHUfvb$ z9xd}csy;WR*|<7_iW*C{SAuE|+F>pfokiF5OhCDCzM|iS`Jk1|x?3AzXLepGVFbRz zrPEkZ^;1#8JKq8#ku|*cSsSC$jE@g@5V6S$+8ag`U!_&^gJH}Nz^3l3@SadwMzGJ8 zoP0&fNd@T+n=!aG~eX8+;cxdZzrl2U+Eed$pZs_f&md{bJ>K zmDb_Ts^D9!HnyiN6tCVE;&~!Nl|NxWl>P8bM|ZrZKoUj$dmn_oo;s~K<^bpGsb@8f z>Jw8!PKoLcL%ONiu}ZHoXmy1T09Lg)*11v#fCwPJBUP})UJ$bjVF=d2NRWU|*I&D! zwUoE|8ylZl%KvS{Y5z|4)#z2V0`h*q1s9!fn0}kBoeacdzFoZ=Qy4$bwJ-HY_8p0u z2&?|)xyznsX?L?UP!cW8AYZbCK9)yK-4p znrY5wE^S4eVLbA!)P78MzsKea!bA_;2>CKsjvO$|CM72I&XR8ou_?qOlu&;j0LuxP zgx*Fq?d~k&p-o=<*g5UJe&$kibJJY`X|Ty={R2_Jkn+DpZrFZLAvGI{cIlc^?1Ia( zF;wHs$;92%A}+)|Zm3;!K^5kvX^oX-Qm%|nRI8p|W5^>ViRa2rqh;ZcV3%iO$Ii2m z!d4=E1-~T<(b*eZ)eNEpeT&t&)tOTINMZx`ofJ

URQx^IN~27ALYgEe^is(^Uy7 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 0: #you must have at least one in your inventory to place + # T he range in which you can place a block is a circle with radius 5 + if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: + self.bin_list[block_type-1] -= 1 # subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + else: + # In this case the player is halway over a block, which means + # that the player spans 4 blocks, and you should not be able to + # place a block in any of these places + check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) + check_top_right_player =((mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1)) + check_bottom_left_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid) + check_bottom_right_player = (mouse_x_grid == player_x_grid+1 and mouse_y_grid == player_y_grid+1) + if (check_top_left_player == False) and (check_top_right_player == False): + if (check_bottom_left_player== False) and (check_bottom_right_player== False): + # make sure a block isn't already in that position + if field.matrix[mouse[1]//40][mouse[0]//40] == 0: + # make sure you have at least one item in your inventor + if self.bin_list[block_type-1] > 0: + if abs(mouse_x_grid - player_x_grid) < 5 and abs(mouse_y_grid - player_y_grid - 1) < 5: + self.bin_list[block_type-1] -= 1 #subtract one from inventory + # place the block where your mouse is + mouse_x_to_grid = (mouse[0]//40)*40 + mouse_y_to_grid = (mouse[1]//40)*40 + drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) + field.blocks.append(drop_block) + + def draw_inventory(self, field, current_block_index, grass, stone, dirt, bedrock, spring): + """Draws the inventory in the top left. Also prints the number of blocks in each slot of the inventory""" + text = Text("Inventory:", self.x_pos, self.y_pos-20, 20, RED) + text.print_text() + # A list of all the images to print in the top left + image_list = [grass, dirt, stone, spring] + # For loop to print the inventory for every item in the inventoryy + for bin in range(len(self.bin_list)): + # checks what type of block and prints that type + if bin+1 == 1: + screen.blit(grass,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 2: + screen.blit(dirt,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 3: + screen.blit(stone,(self.x_pos, self.y_pos + bin*self.bin_height)) + if bin+1 == 4: + screen.blit(spring,(self.x_pos, self.y_pos + bin*self.bin_height)) + # prints the number of items in the inventory in that slot + text = Text(str(self.bin_list[bin]), self.x_pos+45, self.y_pos + bin*self.bin_height, 30, BLACK) + text.print_text() + # prints the current block and the text for it. + text2 = Text("Current Block:", self.x_pos, self.y_pos + bin*self.bin_height+60, 20, RED) + text2.print_text() + screen.blit(image_list[current_block_index-1],(self.x_pos, self.y_pos + bin*self.bin_height + 80)) + +def level_two_map(): + """Stores the map for the second level""" + matrix = [ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 4, 0, 9, 9, 9, 9, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 9, 1, 2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 9, 2, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0], + [2, 2, 2, 2, 9, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 9, 3, 3, 3, 3, 2, 2, 2, 2, 2, 0], + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] + return matrix + + +def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, + bedrock, amon_picture, inventory, inventory_block_index, + level_select, level, previous_level_select, spring, + player_color, done, sean, colvin): + """This is the main function of the program. It contains the controller for the program + user keystrokes and other actions are turned into actions in the game + by referencing other funtions and classes.""" + player.fall = 'on' + field.matrix_update(inventory_block_index) + next_y = player.velocity #how far the player will move on the next iteration + # finds where in the matrix the player is + player.player_in_grid() + # top/bottom collisions + player.top_collision(field) + player.bottom_collision(field, next_y) + previous_level_select = str(level) + clock.tick(40) + + # move left/right + keys = pygame.key.get_pressed() + player.left = 'off' + player.right = 'off' + # move left. Allows for holding the key down. Left collisions + if keys[pygame.K_a]: + player_left_move = player.left_collision(field) + if player_left_move is True: + player.left = 'on' + else: + player.left = 'off' + # move right. Allows for holding the key down. Right collisions + if keys[pygame.K_d]: + player_right_move = player.right_collision(field) + if player_right_move is True: + player.right = 'on' + + # stops plyaer from moving out of screen to left, right, or bottom + if player.x <= 0: + player.x = 0 + if player.x >= 1800: + player.x = 1800 + if player.y >= 840: + player.y = 840 + player.velocity = 0 + player.jump = 1 + player.fall = 'off' + + # pick up block + if mouse2[0] == 1: + inventory.add_to_inventory(mouse, field, player.x, player.y) + # place block + if mouse2[2] == 1: + inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) + # possible actions start here + for event in pygame.event.get(): + # press teh x in the top left to quit + if event.type == pygame.QUIT: + done = True + + # Here begins all the possible actions dependent on keystrokes + if event.type == pygame.KEYDOWN: + # jump function + if event.key == pygame.K_w: + if player.jump == 1: + player.jumps() + player.jump = 0 + # pause + if event.key == pygame.K_p: + level_select = "Menu" + # chance player character + if event.key == pygame.K_c: + player_color += 1 + if player_color == 3: + player_color = 0 + player.color = player_color + + # inventory + # cycles which block to place by pressing 1,2,3, and 4 + if event.key == pygame.K_1: + inventory_block_index = 1 + if event.key == pygame.K_2: + inventory_block_index = 2 + if event.key == pygame.K_3: + inventory_block_index = 3 + if event.key == pygame.K_4: + inventory_block_index = 4 + + # Switches between levels + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + + # quit game + if event.key == pygame.K_q: + pygame.quit() + return + + # View------------------------------------------------------------- + # prints the background + screen.fill(WHITE) + + # This prints all of the blocks on the screen + # row and column counts are used to keep track of matrix row and column + # there is a for loop to run through each row and column + row_count = -1 + for row in field.matrix: + column_count = -1 + row_count += 1 + for column in row: + column_count+=1 + if field.matrix[row_count][column_count] != 0: + if field.matrix[row_count][column_count] == 4: + #based on the number entry in the matrix, it prints a different block + screen.blit(spring, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 1: + screen.blit(grass, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 2: + screen.blit(dirt, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 3: + screen.blit(stone, (column_count*40, row_count*40)) + if field.matrix[row_count][column_count] == 9: + screen.blit(bedrock, (column_count*40, row_count*40)) + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) + player.draw(amon_picture, sean, colvin) + return [level_select, inventory_block_index, previous_level_select, player_color, done] + +#Control +def main(): + """ The actual call of the start of the program. + Main movement is referenced by this function. + """ + # how long between each cycle of the while loop + clock = pygame.time.Clock() + + # initializes player, field, and other variables for level one and two + player_color = 0 + player_color2 = 0 + previous_level_select = "unknown" + level_select = "Menu" + done = False + player = Player() + field = Field() + field2 = Field() + field2.matrix = level_two_map() + player2 = Player() + player2.x = 0 + inventory = Inventory(0, 0, 20, 40, 40) + inventory2 = Inventory(0, 0, 20, 40, 40) + inventory_block_index = 1 + inventory_block_index2 = 1 + + # loads all the pictures + amon_picture = pygame.image.load('amon.png') + grass = pygame.image.load("grass.png") + stone = pygame.image.load("stone.png") + dirt = pygame.image.load("dirt.png") + soulsand = pygame.image.load("soulsand.png") + netherack = pygame.image.load("netherack.png") + netherquartz = pygame.image.load("netherquartz.png") + bedrock = pygame.image.load("bedrock.png") + spring = pygame.image.load("spring.png") + sean = pygame.image.load("sean.png") + colvin = pygame.image.load("colvin.png") + + """CONTROL""" + while not done: + # sets the caption to the name of the level + pygame.display.set_caption(level_select) + mouse = pygame.mouse.get_pos() + mouse2 = pygame.mouse.get_pressed() + # setting up the menu + if level_select is "Menu": + returned = menu(previous_level_select) + level_select = returned[0] + done = returned[1] + # setting up level one + if level_select is "Level_One": + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin) + # the variables in the main function can't be accessed from the main_movement function. They are + level_select = level_one[0] + inventory_block_index = level_one[1] + previous_level_select = level_one[2] + player_color = level_one[3] + done = level_one[4] + # setting up level two + if level_select is "Level_Two": + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin) + level_select = level_two[0] + inventory_block_index2 = level_two[1] + previous_level_select = level_two[2] + player_color2 = level_two[3] + done = level_two[4] + # prints the game on each iteration of the loop + pygame.display.flip() + pygame.quit() + + +if __name__ == '__main__': + main() diff --git a/Game/continuous Rectangleold.py b/Game/continuous Rectangleold.py new file mode 100644 index 0000000..f581297 --- /dev/null +++ b/Game/continuous Rectangleold.py @@ -0,0 +1,163 @@ +import pygame +from math import pi + +pygame.init() +size = [400, 300] +screen = pygame.display.set_mode(size) +BLACK = ( 0, 0, 0) +WHITE = (255, 255, 255) +BLUE = ( 0, 0, 255) +GREEN = ( 0, 255, 0) +RED = (255, 0, 0) + + +### Model + +class Rectangle(): + def __init__(self, x = 10, y = 10, width = 20, height = 10, color = BLACK): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + + #draws the rectangles that are dropped + def draw_rectangle(self): + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + + def draw_shot(self): + self.x = self.x + 10 + self.y = self.y + pygame.draw.rect(screen, self.color, [self.x, self.y, self.width, self.height]) + + +def menu(): + pygame.display.set_caption("Menu") + + + def jump(self): + pass + + +#Control +def main(): + color_matrix = [BLACK, BLUE, GREEN, RED] + pygame.display.set_caption("Game!") + shoot_object_list = [] + done = False + clock = pygame.time.Clock() + text_x = 150 + text_y = 20 + rectangles_x = 100 + rectangles_y = 100 + rectangle_list = [] + which_object = "Rectangle" + color = 0 + + +### CONTROL + + while not done: + clock.tick(40) + + keys = pygame.key.get_pressed() + if keys[pygame.K_UP]: + rectangles_y += -3 + if keys[pygame.K_DOWN]: + rectangles_y += 3 + if keys[pygame.K_LEFT]: + rectangles_x += -3 + if keys[pygame.K_RIGHT]: + rectangles_x += 3 + + for event in pygame.event.get(): # User did something + + if event.type == pygame.QUIT: # If user hit q or closed + done = True + + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_c: + color += 1 + if color == 3: + color = 0 + if event.key == pygame.K_t: + which_object = "Text" + if event.key == pygame.K_r: + which_object = "Rectangle" + + #control text + if which_object == "Text": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + text_x += -10 + if event.key == pygame.K_d: + text_x += 10 + if event.key == pygame.K_w: + text_y += -10 + if event.key == pygame.K_s: + rectangle.jump() + + if which_object == "Rectangle": + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_q: + done = True + if event.key == pygame.K_a: + rectangles_x +=-10 + if event.key == pygame.K_d: + rectangles_x+=10 + if event.key == pygame.K_w: + rectangles_y += -10 + if event.key == pygame.K_s: + rectangles_y += 10 + + #make shoot object + if event.key == pygame.K_f: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + shoot_object_list.append(rectangle) + + #make rectangle object + if event.key == pygame.K_g: + draw_rectangle_x = rectangles_x + draw_rectangle_y = rectangles_y + rectangle_color = color_matrix[color] + rectangle = Rectangle(draw_rectangle_x, draw_rectangle_y+5, 10, 10, rectangle_color) + rectangle_list.append(rectangle) + + #clear objects + if event.key == pygame.K_z: + rectangle_list = [] + +### View + screen.fill(WHITE) + #draw text + myfont = pygame.font.SysFont("monospace", 15) + text_color = (0, 0, 0) + text_position = (text_x, text_y) + label = myfont.render("Sean and Colvin's Game", 100, text_color) + screen.blit(label, (text_position)) + + #draw rectangle objects + for rectangles in rectangle_list: + rectangles.draw_rectangle() + + #draw shooter objects + for shooters in shoot_object_list: + shooters.draw_shot() + + #draw color matric and main rectangle + pygame.draw.rect(screen, color_matrix[color], [rectangles_x, rectangles_y, 50, 20]) + pygame.draw.rect(screen, color_matrix[color], [0, 0, 40, 40]) + + pygame.display.flip() + + pygame.quit() + + +if __name__ == '__main__': + main() From 96e5a7e7050720f4e02025edb167314ad83c9f78 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 23 Apr 2017 18:21:21 -0400 Subject: [PATCH 82/83] Updated File --- interactive_color.py | 1065 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 878 insertions(+), 187 deletions(-) diff --git a/interactive_color.py b/interactive_color.py index bde7dcf..f0bdb0d 100644 --- a/interactive_color.py +++ b/interactive_color.py @@ -1,18 +1,21 @@ import pygame +import pickle """ The following section of the script initializes a few global varables that are helpful to reference at any point in the program.""" -pygame.init() # initialize pygame -size = [1840, 920] # size of screen +#A bunch of variables used throughout the game +pygame.init() #initialize pygame +size = [1840, 920] #size of screen screen = pygame.display.set_mode(size) BLACK = ( 0, 0, 0) WHITE = (255, 255, 255) BLUE = ( 0, 0, 255) GREEN = ( 20, 255, 20) RED = (255, 0, 0) +LIGHT_BLUE = (0, 255, 255) color_matrix = [BLACK, BLUE, GREEN, RED] -block_size = 40 # width/length of blocks in pixels +block_size = 40 #width/length of blocks in pixels jump = 0 @@ -60,21 +63,21 @@ def __init__(self, num_rows=4, color=0): self.blocks = [] self.matrix = [] inner = [] - # makes a matrix that is the shape of the field - # adds an extra row to width and height to prevent out of bounds errors + #makes a matrix that is the shape of the field + #adds an extra row to width and height to prevent out of bounds errors for i in range(size[1]//40+1): inner = [] self.matrix.append(inner) for j in range(size[0]//40+1): inner.append(0) - # adds blocks to the first 4 rows of the field + #adds blocks to the first 4 rows of the field for row in range(num_rows): for column in range(int(size[0]/block_size)): if row == 3: self.matrix[row+19][column] = 9 else: self.matrix[row+19][column] = row+1 - self.matrix[18][15] = 4 # add trampoline + self.matrix[18][15] = 4 #add trampoline def matrix_update(self, block_type): """Uses the block objects in the list of blocks to update the field matrix @@ -89,17 +92,18 @@ def matrix_print(self): for rows in self.matrix: print(rows, ",") - -class Unit(): +class Player(): + """Contains Atributes and Methods regarding the player's position, + appearance, and motion. + """ def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, - fall='on', left='off', right='off', jump=0, health=100): - """super Class that Player and Enemy classes inherit from - The first 5 attributes are the same as the Rectangle class above. + fall='on', left='off', right='off', jump=0): + """The first 5 attributes are the same as the Rectangle class above. velocity - change in y position for each time step. acceleration_constant - change in velocity if falling - fall - whether the unit should be falling - jump - whether the unit is allowed to jump or not + fall - whether the player should be falling + jump - whether the player is allowed to jump or not """ self.x = x self.y = y @@ -112,16 +116,15 @@ def __init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, self.right = right self.acceleration_constant = .6 self.jump = jump - self.health = health - def bottom_collision(self, field): + def bottom_collision(self, field, next_y): """ stops the player's downward movement if his vertical position is colliding with a block and allows him to jump again.""" """Also makes the player bounce if this block is a trampoline""" self.jump = 0 block_below = field.matrix[int(self.ygrid+2)][int(self.xgrid)] block_below_right = field.matrix[int(self.ygrid+2)][int(self.xgrid+1)] - # below is for if the player is directly over a block + #below is for if the player is directly over a block if self.x % 40 == 0: if block_below != 0: self.fall = "off" @@ -129,28 +132,28 @@ def bottom_collision(self, field): self.y = (self.ygrid)*40 self.jump = 1 if block_below == 4: - self.super_jump() # trampoline jump - # below is for if the player is between two blocks + self.super_jump() #trampoline jump + #below is for if the player is between two blocks elif block_below != 0 or block_below_right != 0: self.fall = "off" self.velocity = 0 self.y = (self.ygrid)*40 self.jump = 1 if block_below == 4 or block_below_right == 4: - self.super_jump() # trampoline jump + self.super_jump() #trampoline jump def left_collision(self, field): """Prohibits leftward movement if it would bring the player inside a block or outside the screen.""" - # collisions occur when the block is directly over a block + #collisions occur when the block is directly over a block if self.x%40 == 0: - # if the player is not jumping only two blocks are checked + #if the player is not jumping only two blocks are checked if self.y%40 == 0: if field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0: return False else: return True - # if the player is jumping more blocks must be checked for collisions + #if the player is jumping more blocks must be checked for collisions elif field.matrix[int(self.ygrid)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+1)][int(self.xgrid-1)] != 0 or field.matrix[int(self.ygrid+2)][int(self.xgrid-1)] != 0: return False else: @@ -181,56 +184,17 @@ def top_collision(self, field): if field.matrix[int(self.ygrid)][int(self.xgrid)] != 0: self.y = (self.ygrid+1)*40 self.velocity = self.velocity * -.5 - # if between two blocks check more spots for collisions + #if between two blocks check more spots for collisions elif field.matrix[int(self.ygrid)][int(self.xgrid)] != 0 or field.matrix[int(self.ygrid)][int(self.xgrid+1)] != 0: self.velocity = self.velocity * -.5 self.y = (self.ygrid+1)*40 - def collisions(self, field): - # finds where in the matrix the player is - self.in_grid() - # top/bottom collisions - self.top_collision(field) - self.bottom_collision(field) - - def in_grid(self): + def player_in_grid(self): """Finds the field matrix value that the player's position corresponds to and stores this in the new atributes self.xgrid and self.ygrid""" self.xgrid = self.x//block_size self.ygrid = self.y//block_size - def jumps(self): - """regular jump function - triggered by the 'w' key """ - jump_strength = -9 - self.velocity = jump_strength - self.fall = 'on' - - def super_jump(self): - """Extra high jump triggered by a bottom collision with a trampoline""" - jump_strength = -13 - self.velocity = jump_strength - self.fall = 'on' - - -class Player(Unit): - """Contains Atributes and Methods regarding the player's position, - appearance, and motion. - """ - - def __init__(self): - """The first 5 attributes are the same as the Rectangle class above. - velocity - change in y position for each time step. - acceleration_constant - change in velocity if falling - fall - whether the player should be falling - jump - whether the player is allowed to jump or not - """ - Unit.__init__(self, x=40, y=700, width=40, height=80, color=0, velocity=0, - fall='on', left='off', right='off', jump=0) - self.cooldown = 0 - self.attack_speed = 15 - - def draw(self, amon_picture, sean, colvin): """ The actual printing of the player on the screen This is where we excecute our movement if the player is supposed @@ -256,72 +220,59 @@ def draw(self, amon_picture, sean, colvin): if self.color == 2: screen.blit(colvin,(self.x,self.y)) - def attack(self, other_unit): - """decreases health of player""" - if self.cooldown < self.attack_speed: - self.cooldown += 1 - return None - other_unit.health -= 35 - self.cooldown = 0 - - -class Enemy(Unit): - """Enemies are zombie obects that inherit from the Unit class. The units - give damage when the unit is within reach, and move with a simple condition - based AI.""" - def __init__(self): - Unit.__init__(self, x=1600, y=600, width=40, height=66, color=0, - velocity=0, fall='on', left='off', right='off', jump=0) - self.lag = True - self.attack_speed = 30 - self.cooldown = 0 - - def think(self, player, field): - """logic behind zombie's movement""" - if abs(player.x - self.x) < 2: - self.right = 'off' - self.left = 'off' - elif player.x > self.x and self.right_collision(field): - self.right = 'on' - self.left = 'off' - - elif self.left_collision(field): - self.right = 'off' - self.left = 'on' - - if self.right_collision(field) is False or self.left_collision(field) is False: - self.jumps() - - def draw(self, zombie): - """ The actual printing of the player on the screen - This is where we excecute our movement if the player is supposed - to be moving or falling.""" - if self.fall == 'on': - # the player has a velocity to allow vertical position to change - # fluidly - self.velocity += self.acceleration_constant + def jumps(self): + """regular jump function + triggered by the 'w' key """ + jump_strength = -9 + self.velocity = jump_strength + self.fall = 'on' - if self.left == 'on': - self.x += -2 + def super_jump(self): + """Extra high jump triggered by a bottom collision with a trampoline""" + jump_strength = -13 + self.velocity = jump_strength + self.fall = 'on' - if self.right == 'on': - self.x += 2 - else: - self.left = 'off' - self.right = 'off' - self.lag = False - # update the y position - self.y = self.y + self.velocity - screen.blit(zombie, (self.x, self.y)) - def attack(self, player): - """decreases health of player""" - if self.cooldown < self.attack_speed: - self.cooldown += 1 - return None - player.health -= 20 - self.cooldown = 0 +class Button(Rectangle): + """This Class is a sub-class of the rectangle class. This class makes buttons + which register activity when the mouse is over them or the mouse is clicked. + I could have used the pygame button class but chose to write my own""" + def __init__(self, x, y, width, height, color): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + #Rectangle.__init__(self, x, y, width, height, color) + + def is_hover(self, mouse_x, mouse_y): + """This function detects if the mouse is over the box, but has + not been clicked""" + + #checks to see if mouse is over box + if mouse_x > self.x and mouse_x < self.x + self.width: + if mouse_y > self.y and mouse_y < self.y+self.height: + return True + + def is_pushed(self, mouse_x, mouse_y, is_pushed, current_state = False): + """This function checks to see if the button has been pushed. + It checks that the mouse hovers over the button and the mouse + is clicked down.""" + + #is hover + if mouse_x > self.x and mouse_x < self.x + self.width: + if mouse_y > self.y and mouse_y < self.y+self.height: + #is clicked + if current_state == True: + return False + else: + return True + else: + return False + else: + return False class Text(): """Used when forming all of our text boxes - especially in the menu""" @@ -338,47 +289,200 @@ def print_text(self): label = font.render(self.text, 40, self.color) screen.blit(label, (self.x_pos, self.y_pos)) +def username_exists_function(username, user_information_list): + """This function checks whether or not a user has already registered + in the database. It returns true if they have, and false if they have not.""" -def menu(previous_level_select): - """This is the menu screen that is shown when you first start playing the - game. It gives brief instructions on what the game is. You can start - playing the game by pressing 8, 9, or P""" + if user_information_list != None: #makes sure the profile box on the register screen has input + for profile in user_information_list: #checks through user profiles + username_current = profile[0] #username is a subset of the profile + password = profile[1] #password is also subset of profile + if username == username_current: #checks to see if they match + return True + return False + else: return False + +def invalid_password(password): + """This function is used to make sure the password is of a reasonable + size. The requirements could be increased or simplified to make more + or fewer passwords valid.""" + + if len(password) < 6: + return True + +def enter_new_user(enter_button_state_var, user_information_list, old_user_information_list): + """This function is used to enter a new user into the database of information. + If the file that the information is stored to is blank, an error occurs, + so a try loop catches it.""" + + #it first checks to see if the user profile already exists + username_exists_result = username_exists_function(user_information_list[0], old_user_information_list) + #it then changes the next screen it will show if the user does not exist level_select = "Menu" - done = False + if username_exists_result == True: + level_select = "register_screen" + #makes sure that it wasn't the default user with no input + elif user_information_list[0] != 1: + #catches an error thrown when there is no text in the file + try: #try loop makes sure file is not blank + #loads the information + files = open("user_information_list.txt", 'rb') + old_user_information_list = pickle.load(files) + files.close + #adds current information to the old information + #then it saves it + old_user_information_list.append(user_information_list) + user_information_list = old_user_information_list + with open('user_information_list.txt', 'wb') as fp: + pickle.dump(user_information_list, fp) + except: + #it just dumps it all if there is already data + with open('user_information_list.txt', 'wb') as fp: + pickle.dump([user_information_list], fp) + enter_button_state_var = False + #sort out 1 profile from them all + user_information_list = user_information_list[len(user_information_list)-1] + return [level_select, user_information_list, enter_button_state_var, username_exists_result] + +def validate_user(username, password, old_user_information_list): + """This function is used from the login screen to make sure that the + user has entered the correct credentials with a username and password that + are in the system""" + + #defaults to no error message + error_messages="No_error" + #tries to validate user + for profile in old_user_information_list: + if username == profile[0]: + if password == profile[1]: + return [True, error_message(error_messages)] + else: + error_messages="Incorrect_Password" #error message if incorrect password + return [False, error_message(error_messages)] + else: + error_messages="Username_Not_Found" #error messagae if incorrect username + return [False, error_message(error_messages)] + +def error_message(message_type): + """This function generates the error messages based on keys""" + + text2 = Text("", 5000, 5000, 60, BLUE) #default error message is off screen so it can't be seen + + #below are a bunch of the different possible messages + if message_type == "Username_Taken": + text2 = Text("Username Already Taken", 650, 650, 30, RED) + elif message_type == "invalid_password": + text2 = Text("Your Password Is Currently Too Short", 550, 650, 30, RED) + elif message_type == "Username_Not_Found": + text2= Text("Username Not Found", 685, 650, 30, RED) + elif message_type == "Incorrect_Password": + text2 = Text("Incorrect Password", 685, 650, 30, RED) + else: + text2 = Text("Incorrect Password", 5000, 5000, 60, BLUE) + return text2 + +def save_world(field, user_information_list, level): + """This function starts the process of saving the user's information by + putting the field's current status in the user's profile""" + + #checks what level you are on so it can save the right one + #updates user profile to reflect the current field + if level == "Level_One": + user_information_list[2] = field.matrix + if level == "Level_Two": + user_information_list[3] = field.matrix + #runs the function that completes the saving process + old_user_information_list = save_world_to_file(user_information_list) + return [user_information_list, old_user_information_list] + +def find_user_profile(username, old_user_information_list): + """This function finds the user in a list of all the profiles and returns + the user's information and the index of the profile list where the user's + profile is""" + + username_index_var = False + profile = [] + profile = [] + username_index = -1 #count variable + + #loops throught to find user profile + while not username_index_var: + username_index += 1 + profile = old_user_information_list[username_index] #loks at new profile + current_username = profile[0] #checks current username + if username == current_username: + username_index_var = True + return [profile, username_index] + +def save_world_to_file(user_information_list): + """Saves the user's information to the file""" + + username = user_information_list[0] #finds user's username + #reads old data from the file + files = open("user_information_list.txt", 'rb') + old_user_information_list = pickle.load(files) + files.close + #finds the whole user's profile from the fund_user_profile function + profile_with_index = find_user_profile(user_information_list[0], old_user_information_list) + username_index = profile_with_index[1] + #updates the user's old profile to be the new profile + old_user_information_list[username_index] = user_information_list + print("\nold_user_information in save_world_to_file", old_user_information_list, "\n") + #write the new data to the file + with open('user_information_list.txt', 'wb') as fp: + print("\nold where python dumps", old_user_information_list, "\n") + pickle.dump(old_user_information_list, fp) + #returns the new list of data + return old_user_information_list + +def menu(previous_level_select, username, user_information_list): + """This is the menu screen that is shown when you first start playing the + game. It gives brief instructions on what the game is and how to proceed to + playing the game""" + + level_select = "Menu" #the level key for this screen + done = False #quits if done is True + # Looks for player input for event in pygame.event.get(): - if event.type == pygame.QUIT: # quits + + #allows the program to close if the x is pushed + if event.type == pygame.QUIT: done = True - # looks for a keystroke + + #below is what to do with keyboard input if event.type == pygame.KEYDOWN: # quits when q is pressed if event.key == pygame.K_q: # If user hit q or closed") done = True + # which level to go to is selected here. # p is used to go to the previous level. # on the first iteration, this is "unknown:, so p takes you to level one # 8 or 9 also take you to level one or two - if previous_level_select is "unknown": - if event.key == pygame.K_8: - level_select = "Level_One" - if event.key == pygame.K_9: - level_select = "Level_Two" - if event.key == pygame.K_p: - level_select = "Level_One" - else: - # After you have entered a level this takes you back to the previous - # level when you press P - print("going previous", previous_level_select) + if event.key == pygame.K_8: + level_select = "Level_One" + if event.key == pygame.K_9: + level_select = "Level_Two" + if event.key == pygame.K_p: + level_select = "Level_One" + if event.key == pygame.K_x: + print("\n user information list in menu", user_information_list, "\n") + + #goes back to the previous level. + #The first if statement prevents a bug when you press p on the + #first time through and there is no previous level + if previous_level_select != "unknown": if event.key == pygame.K_p: level_select = previous_level_select # Fill the screen white and print a bunch of text. screen.fill(WHITE) text_list = [] - text1 = Text("Bounce Block", 150, 50, 100, RED) + text1 = Text("Welcome, " + username, 250, 50, 100, RED) text2 = Text("Instructions:", 50, 200, 60, BLUE) text3 = Text("-This is a rudimentary version of Minecraft. Use w, a, s, d to move.", 100, 300, 30, BLACK) - text4 = Text("-You can move around the world and change the blocks within it.", 100, 350, 30, BLACK) + text4 = Text("-UPDATE: Press z to save your world when you are in it. When you log in again, it is the same", 100, 350, 30, BLACK) text5 = Text("-Your inventory is in the upper left. Cycle through which item to drop with 1, 2, 3, and 4", 100, 400, 30, BLACK) text6 = Text("-Use left click to pick up items and right click to drop them. You have a limited range.", 100, 450, 30, BLACK) text7 = Text("-Which block you will drop is shown by the \"Current Block\" space in your inventory", 100, 500, 30, BLACK) @@ -388,12 +492,502 @@ def menu(previous_level_select): text11 = Text("-You can also change your character by pressing C", 100, 700, 30, BLACK) text12 = Text("-Trampolines will make you jump extra high when you land on them", 100, 750, 30, BLACK) text_add_list = [text1, text2, text3, text4, text5, text6, text7, text8, text9, text10, text11, text12] + + #put the texts in a list and print the text for texts in text_add_list: text_list.append(texts) for texts in text_list: texts.print_text() return [level_select, done] + +def menu2(previous_level_select, mouse, mouse2): + """The first screen that appears. It allow the user to navigate to the + login screen or the register screen.""" + + level_select = "Menu2" #The level key for this funtion + done = False + + #Mouse input is conerted to x and y direction + x_mouse = mouse[0] + y_mouse = mouse[1] + + #parameters for the login and register buttons + register_block_left = 535 + register_block_top = 400 + register_block_length = 300 + register_block_height = 60 + + login_block_left = 865 + login_block_top = 400 + login_block_length = 300 + login_block_height = 60 + + #creates the register and login buttons and determines if the mouseu is + #hovering over the button + login_button = Button(login_block_left, login_block_top, login_block_length, login_block_height, RED) + register_button = Button(register_block_left, register_block_top, register_block_length, register_block_height, RED) + login_button_state = login_button.is_hover(x_mouse, y_mouse) + register_button_state = register_button.is_hover(x_mouse, y_mouse) + + #Takes in user input + for event in pygame.event.get(): + + #if input is clicking down the mouse + if event.type == pygame.MOUSEBUTTONDOWN: + #checks to see if the register or login buttons are pushed + register_button_state_var = register_button.is_pushed(x_mouse, y_mouse, mouse2[0]) + login_button_state_var = login_button.is_pushed(x_mouse, y_mouse, mouse2[0]) + #changes the menu to the right screen after button is pushed + if register_button_state_var: + level_select = "register_screen" + if login_button_state_var: + level_select = "login_menu" + + #quits + if event.type == pygame.QUIT: + done = True + + # looks for a keystroke + if event.type == pygame.KEYDOWN: + + # quits when q is pressed + if event.key == pygame.K_q: + done = True + + # Fill the screen white and print a bunch of text. + screen.fill(LIGHT_BLUE) + + #print the white box around the buttons + white_box = Rectangle(500, 375, 710, 115, WHITE) + white_box.draw_rectangle() + + #input text for the login and register buttons + register_box_input = "Register" + login_box_input = "Log in" + + #draws buttons based on if you are hovering over it or not + if login_button_state: #are hovering over login button + login_button.draw_rectangle() + else: + login_button = Button(login_block_left, login_block_top, login_block_length, login_block_height, LIGHT_BLUE) + login_button.draw_rectangle() + login_button = Button(login_block_left, login_block_top, login_block_length, login_block_height, RED) + if register_button_state: #are hovering over register button + register_button.draw_rectangle() + else: + register_button = Button(register_block_left, login_block_top, login_block_length, login_block_height, LIGHT_BLUE) + register_button.draw_rectangle() + register_button = Button(register_block_left, login_block_top, login_block_length, login_block_height, RED) + + #printing text + text_list = [] + + text1 = Text("Welcome to CraftMine", 300, 50, 100, RED) + text2 = Text(register_box_input, register_block_left+7, register_block_top, 60, BLACK) + text3 = Text(login_box_input, login_block_left+40, login_block_top, 60, BLACK) + + text_add_list = [text1, text2, text3] + for texts in text_add_list: + text_list.append(texts) + for texts in text_list: + texts.print_text() + #returns what level you're on and if you should quit + return [level_select, done] + +def register_screen(previous_level_select, username_list, password_list, mouse, mouse2, password_button_state_var, username_button_state_var, most_recent, username, password, user_information_list, old_user_information_list, username_exists): + """The screen you are taken to if you click the register button. + On this screen you can register a new account.""" + + level_select = "register_screen" #level key + done = False + + #initializes a "username_list" which holds a users information + username_list = username_list + enter_button_state_var = False + + #Reads mouse input + x_mouse = mouse[0] + y_mouse = mouse[1] + + #Parameters for username, password, and enter buttons + username_block_left = 650 + username_block_top = 300 + username_block_length = 400 + username_block_height = 60 + password_block_left = 650 + password_block_top = 400 + password_block_length = 400 + password_block_height = 60 + enter_block_left = 650 + enter_block_top = 500 + enter_block_length = 400 + enter_block_height = 60 + + #initiializes the buttons and sees if the mouse is hovering over them + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, LIGHT_BLUE) + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, LIGHT_BLUE) + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height, RED) + password_button_state = password_button.is_hover(x_mouse, y_mouse) + username_button_state = username_button.is_hover(x_mouse, y_mouse) + enter_button_state = enter_button.is_hover(x_mouse, y_mouse) + + #Checks user input + for event in pygame.event.get(): + + #What it does when clicked + if event.type == pygame.MOUSEBUTTONDOWN: + #checks to see if any of the buttons are clicked + if username_button_state: + username_button_state_var = username_button.is_pushed(x_mouse, y_mouse, mouse2[0], username_button_state_var) + most_recent = "username" + if password_button_state: + password_button_state_var = password_button.is_pushed(x_mouse, y_mouse, mouse2[0], password_button_state_var) + most_recent = "password" + if enter_button_state: + enter_button_state_var = enter_button.is_pushed(x_mouse, y_mouse, mouse2[0]) + if enter_button_state_var: + level_select = "Menu" + + #quits + if event.type == pygame.QUIT: + done = True + + # looks for a keystroke + if event.type == pygame.KEYDOWN: + #checks the most recent button state to see which you should be + #able to type in to + if most_recent == "password": + if password_button_state_var == True: + if event.key != pygame.K_TAB and event.key != 13 and event.key < 300: #makes sure the input isn't a tab or shift or other input + password_list += (chr(event.key)) #adds a key to the password box + elif username_button_state_var == True: + if event.key != pygame.K_TAB and event.key != 13 and event.key < 300: #makes sure input is just regular keyboard input + username_list += (chr(event.key)) #adds key input to username + else: #if neither of the buttons are true + if event.key == pygame.K_q: # If user hit q it quits + done = True + if username_button_state_var: #moves from one box to another if you press tab + if event.key == pygame.K_TAB: + password_button_state_var = True + most_recent = "password" + if event.key == pygame.K_BACKSPACE: #delets key if you press backspace + if most_recent == "username": + username_list = username_list[0:len(username_list)-2] + if most_recent == "password": + password_list = password_list[0:len(password_list)-2] + #changes menu if you have entered all the right information + if username_button_state_var and password_button_state_var and (len(password_list)>4 and event.key == 13): + level_select = "Menu" + enter_button_state_var = True + + # Fill the screen Light Blue and print a bunch of text. + screen.fill(LIGHT_BLUE) + + #print username and password in their boxes. + username_box_input = "Username" + password_box_input = "Password" + + #draws box around buttons + white_box = Rectangle(600, 260, 500, 340, WHITE) + white_box.draw_rectangle() + + #changes color if you are hovering over or clicked pasword button + if password_button_state == True and password_button_state_var == False: + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, RED) + password_button.draw_rectangle() + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, LIGHT_BLUE) + elif password_button_state_var == True:#if you have clicked on it + password_box_input = "" + password_button.draw_with_outline() + else: #if neither + password_list = "Password" + password_button.draw_rectangle() + password_list = "" + + #changes register button if you have clicked it or are hovering over it + if username_button_state == True and username_button_state_var == False: #hovering + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, RED) + username_button.draw_rectangle() + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, LIGHT_BLUE) + elif username_button_state_var == True: #clicked + username_box_input = "" + username_button.draw_with_outline() + else: #neither + username_list = "Username" + username_button.draw_rectangle() + username_list = "" + + #changes enter button if you hover over it + if enter_button_state: + enter_button.draw_rectangle() + else: #if not hovering + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height, LIGHT_BLUE) + enter_button.draw_rectangle() + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height, RED) + + #prints a bunch of text on the screen + text_list = [] + text1 = Text("Register Here", 500, 50, 100, RED) #Title + + #if hovering and not clicking username button + if username_button_state and not username_button_state_var: + text2 = Text(str(username_box_input), username_block_left+60, username_block_top, 60, LIGHT_BLUE) + elif username_button_state_var != True: #if not hovering + text2 = Text(str(username_box_input), username_block_left+60, username_block_top, 60, RED) + else: #if clicked + text2 = Text(username_list, username_block_left+7, username_block_top, 60, RED) + + #if hovering and not clicking password button + if password_button_state and not password_button_state_var: + text3 = Text(password_box_input, password_block_left+60, password_block_top, 60, LIGHT_BLUE) + elif password_button_state_var != True: #if not hovering + text3 = Text(password_box_input, password_block_left+60, password_block_top, 60, RED) + else: #if clicked + text3 = Text(str(password_list), password_block_left+7, password_block_top, 60, RED) + + #if enter button is hovered + if enter_button_state: + text4 = Text("Enter", enter_block_left+110, enter_block_top, 60, LIGHT_BLUE) + else: #otherwise + text4 = Text("Enter", enter_block_left+110, enter_block_top, 60, RED) + + + error_message_input = "No_Error" #default error message + + #checks to see if username already exists + username_exists = username_exists_function(username, old_user_information_list) + if username_exists == True: #outputs an error if username exists + if username != "": + error_message_input = "Username_Taken" + elif invalid_password(password): #outputs error if invalid password password + if password != "": + error_message_input = "invalid_password" + error_message_text = error_message(error_message_input) #makes text for the error_message + + #print out all of the texts to go on the screen + text_add_list = [text1, text2, text3, text4, error_message_text] + for texts in text_add_list: + text_list.append(texts) + for texts in text_list: + texts.print_text() + + #sets username and password + username = username_list + password = password_list + + #sets the user_information_list to be used later + user_information_list = [username, password, level_one_map(), level_two_map()] + + #checks to mak sure the password is of a reasonable length + if enter_button_state_var: + if invalid_password(password): + enter_button_state_var = False + level_select = "register_screen" #resets if it is not + + #if enter is clicked and pasword is reasonable, it enters the user + if enter_button_state_var: + #uses enter_user function to save user to file + new_user_information = enter_new_user(enter_button_state_var, user_information_list, old_user_information_list) + level_select = new_user_information[0] #changes level + user_information_list = [username, password, level_one_map(), level_two_map()] + enter_button_state_var = new_user_information[2] + username_exists = new_user_information[3] + + if username == "": #makes sure the username isn't blank. + level_select = "register_screen" + return [level_select, done, username_list, password_button_state_var, username_button_state_var, password_list, most_recent, username, password, user_information_list, enter_button_state_var, username_exists] + +def login_menu(previous_level_select, username_list, password_list, mouse, mouse2, password_button_state_var, username_button_state_var, most_recent, username, password, user_information_list, old_user_information_list, username_exists, error_message): + """The login menu screen. This logs the user into their old profile, which + is stored on a file in the computer""" + + level_select = "login_menu" #level key + done = False + enter_button_state_var = False + + # Looks for player input from mouse + x_mouse = mouse[0] + y_mouse = mouse[1] + + #parameters for username, password, and enter blocks + username_block_left = 650 + username_block_top = 300 + username_block_length = 400 + username_block_height = 60 + password_block_left = 650 + password_block_top = 400 + password_block_length = 400 + password_block_height = 60 + enter_block_left = 650 + enter_block_top = 500 + enter_block_length = 400 + enter_block_height = 60 + + #initializes password, username, and enter blocks, and checks if mouse is + #hovering over them + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, LIGHT_BLUE) + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, LIGHT_BLUE) + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height, RED) + password_button_state = password_button.is_hover(x_mouse, y_mouse) + username_button_state = username_button.is_hover(x_mouse, y_mouse) + enter_button_state = enter_button.is_hover(x_mouse, y_mouse) + + #checks for user input + for event in pygame.event.get(): + + #if input is the mouse being clicked + if event.type == pygame.MOUSEBUTTONDOWN: + if username_button_state: #if hovering over the user + #changes the button state to true and makes it the most recent + username_button_state_var = username_button.is_pushed(x_mouse, y_mouse, mouse2[0], username_button_state_var) + most_recent = "username" + if password_button_state: #if hovering over the password button + #checks if clicked and makes the most recent button the password button + password_button_state_var = password_button.is_pushed(x_mouse, y_mouse, mouse2[0], password_button_state_var) + most_recent = "password" + if enter_button_state: #if enter button is clicked + enter_button_state_var = enter_button.is_pushed(x_mouse, y_mouse, mouse2[0]) + if enter_button_state_var: + level_select = "Menu" #moves to next menu + + #quits + if event.type == pygame.QUIT: # quits + done = True + + # looks for a keystroke + if event.type == pygame.KEYDOWN: + if most_recent == "password": + if password_button_state_var == True: + if event.key != pygame.K_TAB and event.key != 13: + password_list += (chr(event.key)) + elif username_button_state_var == True: + if event.key != pygame.K_TAB and event.key != 13 and event.key < 300: + username_list += (chr(event.key)) + else: + if event.key == pygame.K_q: # If user hit q or closed") + done = True + if event.key == pygame.K_p: + level_select = "Menu" + if username_button_state_var: + if event.key == pygame.K_TAB: + password_button_state_var = True + most_recent = "password" + if event.key == pygame.K_x: + print(user_information_list) + print(old_user_information_list) + if event.key == pygame.K_BACKSPACE: + if most_recent == "username": + username_list = username_list[0:len(username_list)-2] + if most_recent == "password": + password_list = password_list[0:len(password_list)-2] + if (username_button_state_var and password_button_state_var and event.key == 13): + level_select = "Menu" + enter_button_state_var = True + # Fill the screen white and print a bunch of text. + + #fills the screen light blue + screen.fill(LIGHT_BLUE) + + #changes text on boxes to username and password + username_box_input = "Username" + password_box_input = "Password" + + #draws white boxes around buttons + white_box = Rectangle(600, 260, 500, 340, WHITE) + white_box.draw_rectangle() + + #checks state of password button and prints accordingly + if password_button_state == True and password_button_state_var == False: #hovering + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, RED) + password_button.draw_rectangle() + password_button = Button(password_block_left, password_block_top, password_block_length, password_block_height, LIGHT_BLUE) + elif password_button_state_var == True: #clicked + password_box_input = "" + password_button.draw_with_outline() + else: #neither + password_list = "Password" + password_button.draw_rectangle() + password_list = "" + + #checks state of username button and prints accordingly + if username_button_state == True and username_button_state_var == False: #hovering + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, RED) + username_button.draw_rectangle() + username_button = Button(username_block_left, username_block_top, username_block_length, username_block_height, LIGHT_BLUE) + elif username_button_state_var == True: #clicked + username_box_input = "" + username_button.draw_with_outline() + else: #neither + username_list = "Username" + username_button.draw_rectangle() + username_list = "" + + #checks if hovering over enter button + if enter_button_state: #if hovering + enter_button.draw_rectangle() + else: #If not hovering + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height,LIGHT_BLUE) + enter_button.draw_rectangle() + enter_button = Button(enter_block_left, enter_block_top, enter_block_length, enter_block_height, RED) + + #prints a bunch of text + text_list = [] + text1 = Text("Welcome to CraftMine: Please Login", 150, 50, 100, RED) #title + + #prints username button depending on state + if username_button_state and not username_button_state_var:#if hovering + text2 = Text(str(username_box_input), username_block_left+60, username_block_top, 60, LIGHT_BLUE) + elif username_button_state_var != True: #If nothing + text2 = Text(str(username_box_input), username_block_left+60, username_block_top, 60, RED) + else: #if clicked + text2 = Text(username_list, username_block_left+7, username_block_top, 60, RED) + + #prints password button depending on state + if password_button_state and not password_button_state_var: #if hovering + text3 = Text(password_box_input, password_block_left+60, password_block_top, 60, LIGHT_BLUE) + elif password_button_state_var != True: #if clicked + text3 = Text(password_box_input, password_block_left+60, password_block_top, 60, RED) + else: #if nothing + text3 = Text(str(password_list), password_block_left+7, password_block_top, 60, RED) + + #Prints enter button depending on state + if enter_button_state: #if hovering + text4 = Text("Enter", enter_block_left+110, enter_block_top, 60, BLUE) + else: #if not hovering + text4 = Text("Enter", enter_block_left+110, enter_block_top, 60, RED) + + #checks to see if it is a valid username + username_exists = username_exists_function(username, old_user_information_list) + #if enter button is clicked checks validity of sign in + if enter_button_state_var and level_select == "Menu": + #checks valididity of username and password + valid_user = validate_user(username, password, old_user_information_list) + error_message = valid_user[1] #prints an error depending on result + if valid_user[0]: #if it is valid move to next menu + level_select = "Menu" + else: level_select = "login_menu" #if not stay on login menu + if username == "": #if username is blank don't move to next menu + level_select = "login_menu" + + #print texts + text_add_list = [text1, text2, text3, text4, error_message] + for texts in text_add_list: + text_list.append(texts) + for texts in text_list: + texts.print_text() + + #update username and password + username = username_list + password = password_list + + #finds the profile of the user from the file and reads it + if level_select == "Menu": + user_information_list_with_index = find_user_profile(username, old_user_information_list) + user_information_list = user_information_list_with_index[0] + return [level_select, done, username_list, password_button_state_var, username_button_state_var, password_list, most_recent, username, password, user_information_list, enter_button_state_var, username_exists, error_message] + + class Inventory(): """The inventory is used to pick up, place, and store blocks. The inventory is shown in the upper left. The blocks you can place, and the number of @@ -451,17 +1045,17 @@ def remove_from_inventory(self, field, block_type, player_x, player_y, current_b check_bottom_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid+1) if (check_top_player== False) and (check_bottom_player== False): if field.matrix[mouse[1]//40][mouse[0]//40] == 0: # A block cannot be placed if another block already is in that spot - if self.bin_list[block_type-1] > 0: # you must have at least one in your inventory to place + if self.bin_list[block_type-1] > 0: #you must have at least one in your inventory to place # T he range in which you can place a block is a circle with radius 5 if ((mouse_x_grid - player_x_grid)**2 + (mouse_y_grid - player_y_grid)**2)**.5 < 5: - self.bin_list[block_type-1] -= 1 # subtract one from inventory + self.bin_list[block_type-1] -= 1 # subtract one from inventory # place the block where your mouse is mouse_x_to_grid = (mouse[0]//40)*40 mouse_y_to_grid = (mouse[1]//40)*40 drop_block = Rectangle(mouse_x_to_grid, mouse_y_to_grid, 40, 40, self.bin_list_item[current_block_index]) field.blocks.append(drop_block) else: - # In this case the player is halfway over a block, which means + # In this case the player is halway over a block, which means # that the player spans 4 blocks, and you should not be able to # place a block in any of these places check_top_left_player = (mouse_x_grid == player_x_grid and mouse_y_grid == player_y_grid) @@ -536,19 +1130,60 @@ def level_two_map(): [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] return matrix +def level_one_map(): + """Stores the map for the first level""" + matrix = [ + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] , + [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0] , + [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0] , + [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0] , + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] , + ] + return matrix def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, level, previous_level_select, spring, - player_color, done, sean, colvin, enemy1, zombie): + player_color, done, sean, colvin, user_information_list, old_user_information_list): """This is the main function of the program. It contains the controller for the program user keystrokes and other actions are turned into actions in the game by referencing other funtions and classes.""" + + #updates the user's profile to reflect the current field + if previous_level_select == "unknown" or previous_level_select != level_select: + if user_information_list[2] != 1 and user_information_list[3] != 1: #if not default from the register screen. This would cause an error + if level_select == "Level_One": + field.matrix = user_information_list[2] #updates level one + if level_select == "Level_Two": + field.matrix = user_information_list[3] #updates level 2 + player.fall = 'on' - enemy1.fall = 'on' - field.matrix_update(inventory_block_index) - player.collisions(field) - enemy1.collisions(field) + field.matrix_update(inventory_block_index) #update field + next_y = player.velocity #how far the player will move on the next iteration + # finds where in the matrix the player is + player.player_in_grid() + # top/bottom collisions + player.top_collision(field) + player.bottom_collision(field, next_y) previous_level_select = str(level) clock.tick(40) @@ -580,15 +1215,13 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.jump = 1 player.fall = 'off' - enemy1.think(player, field) - # pick up block if mouse2[0] == 1: inventory.add_to_inventory(mouse, field, player.x, player.y) # place block if mouse2[2] == 1: inventory.remove_from_inventory(field, inventory_block_index, player.x, player.y, inventory_block_index, mouse) - """ possible actions start here""" + # possible actions start here for event in pygame.event.get(): # press teh x in the top left to quit if event.type == pygame.QUIT: @@ -603,6 +1236,7 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, player.jump = 0 # pause if event.key == pygame.K_p: + print(field.matrix_print(), "P Pressed") level_select = "Menu" # chance player character if event.key == pygame.K_c: @@ -628,10 +1262,16 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, if event.key == pygame.K_9: level_select = "Level_Two" - # quit game + #saves if you press z + if event.key == pygame.K_z: + save_world_info = save_world(field, user_information_list, level_select) + user_information_list = save_world_info[0] + old_user_information_list = save_world_info[1] + #quits if you press q if event.key == pygame.K_q: pygame.quit() - return + done = True + return [level_select, inventory_block_index, previous_level_select, player_color, done, user_information_list, old_user_information_list] # View------------------------------------------------------------- # prints the background @@ -645,10 +1285,10 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, column_count = -1 row_count += 1 for column in row: - column_count += 1 + column_count+=1 if field.matrix[row_count][column_count] != 0: if field.matrix[row_count][column_count] == 4: - # based on the number entry in the matrix, it prints a different block + #based on the number entry in the matrix, it prints a different block screen.blit(spring, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 1: screen.blit(grass, (column_count*40, row_count*40)) @@ -658,13 +1298,11 @@ def main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, screen.blit(stone, (column_count*40, row_count*40)) if field.matrix[row_count][column_count] == 9: screen.blit(bedrock, (column_count*40, row_count*40)) - inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) - player.draw(amon_picture, sean, colvin) - enemy1.draw(zombie) - return [level_select, inventory_block_index, previous_level_select, player_color, done] - + inventory.draw_inventory(field, inventory_block_index, grass, stone, dirt, bedrock, spring) #draws the inventory + player.draw(amon_picture, sean, colvin) #draws the player + return [level_select, inventory_block_index, previous_level_select, player_color, done, user_information_list, old_user_information_list] -# Control +#Control def main(): """ The actual call of the start of the program. Main movement is referenced by this function. @@ -676,7 +1314,7 @@ def main(): player_color = 0 player_color2 = 0 previous_level_select = "unknown" - level_select = "Menu" + level_select = "Menu2" done = False player = Player() field = Field() @@ -684,12 +1322,20 @@ def main(): field2.matrix = level_two_map() player2 = Player() player2.x = 0 - - enemy1 = Enemy() inventory = Inventory(0, 0, 20, 40, 40) inventory2 = Inventory(0, 0, 20, 40, 40) inventory_block_index = 1 inventory_block_index2 = 1 + password_button_state_var = False + username_button_state_var = False + most_recent = None + username = "" + password = "" + user_information_list = [1] + enter_button_state_var = False + old_user_information_list = None + username_exists = False + error_message = Text("Incorrect_Password", 5000, 5000, 60, LIGHT_BLUE) # loads all the pictures amon_picture = pygame.image.load('amon.png') @@ -703,47 +1349,92 @@ def main(): spring = pygame.image.load("spring.png") sean = pygame.image.load("sean.png") colvin = pygame.image.load("colvin.png") - zombie = pygame.image.load("Zombie.png") - - """CONTROL""" + username_list = "" + password_list = "" + + #gets the old information from the files + #it is in a try loop because it errors if there is no data in the file + try: #if there is data + files = open("user_information_list.txt", 'rb') + old_user_information_list = pickle.load(files) + files.close + except: #if there is no data + files = open("user_information_list.txt", 'wb') + + #this is the main while loop for the program while not done: # sets the caption to the name of the level pygame.display.set_caption(level_select) + #find mouse position and whether or not it is clicked mouse = pygame.mouse.get_pos() mouse2 = pygame.mouse.get_pressed() + + #decides which screen to go to based on the "level_select" function # setting up the menu if level_select is "Menu": - returned = menu(previous_level_select) + returned = menu(previous_level_select, username, user_information_list) + level_select = returned[0] + done = returned[1] + # setting up level one + if level_select is "Menu2": + returned = menu2(previous_level_select, mouse, mouse2) + level_select = returned[0] + done = returned[1] + #setting up the register screen + if level_select is "register_screen": + returned = register_screen(previous_level_select, username_list, password_list, mouse, mouse2, password_button_state_var, username_button_state_var, most_recent, username, password, user_information_list, old_user_information_list, username_exists) + level_select = returned[0] + done = returned[1] + username_list = returned[2] + password_button_state_var = returned[3] + username_button_state_var = returned[4] + password_list = returned[5] + most_recent = returned[6] + username = returned[7] + password = returned[8] + user_information_list = returned[9] + enter_button_state_var = returned[10] + username_exists = returned[11] + # setting up the login screen + if level_select is "login_menu": + returned = login_menu(previous_level_select, username_list, password_list, mouse, mouse2, password_button_state_var, username_button_state_var, most_recent, username, password, user_information_list, old_user_information_list, username_exists, error_message) level_select = returned[0] done = returned[1] + username_list = returned[2] + password_button_state_var = returned[3] + username_button_state_var = returned[4] + password_list = returned[5] + most_recent = returned[6] + username = returned[7] + password = returned[8] + user_information_list = returned[9] + enter_button_state_var = returned[10] + username_exists = returned[11] + error_message = returned[12] # setting up level one if level_select is "Level_One": - level_one = main_movement(player, field, clock, mouse, mouse2, - grass, dirt, stone, bedrock, amon_picture, inventory, - inventory_block_index, level_select, "Level_One", - previous_level_select, spring, player_color, done, sean, colvin, - enemy1, zombie) - # the variables in the main function can't be accessed from the - # main_movement function. They are + level_one = main_movement(player, field, clock, mouse, mouse2, grass, dirt, stone, bedrock, amon_picture, inventory, inventory_block_index, level_select, "Level_One", previous_level_select, spring, player_color, done, sean, colvin, user_information_list, old_user_information_list) + # the variables in the main function can't be accessed from the main_movement function. They are level_select = level_one[0] inventory_block_index = level_one[1] previous_level_select = level_one[2] player_color = level_one[3] done = level_one[4] + user_information_list = level_one[5] + old_user_information_list = level_one[6] # setting up level two if level_select is "Level_Two": - level_two = main_movement(player2, field2, clock, mouse, mouse2, - soulsand, netherack, netherquartz, - bedrock, amon_picture, inventory2, inventory_block_index2, - level_select, "Level_Two", previous_level_select, spring, - player_color2, done, sean, colvin) + level_two = main_movement(player2, field2, clock, mouse, mouse2, soulsand, netherack, netherquartz, bedrock, amon_picture, inventory2, inventory_block_index2, level_select, "Level_Two", previous_level_select, spring, player_color2, done, sean, colvin, user_information_list, old_user_information_list) level_select = level_two[0] inventory_block_index2 = level_two[1] previous_level_select = level_two[2] player_color2 = level_two[3] done = level_two[4] + user_information_list = level_two[5] + old_user_information_list = level_two[6] # prints the game on each iteration of the loop - pygame.display.flip() + if not done: + pygame.display.flip() pygame.quit() From 3cbac3791e37aba8964320b70e9fc094b8caac44 Mon Sep 17 00:00:00 2001 From: Sean Szymanski Date: Sun, 23 Apr 2017 21:17:19 -0400 Subject: [PATCH 83/83] Reset User List --- user_information_list.txt | Bin 0 -> 4803 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 user_information_list.txt diff --git a/user_information_list.txt b/user_information_list.txt new file mode 100644 index 0000000000000000000000000000000000000000..29de46322bd16c1743bd0347a476e28586943262 GIT binary patch literal 4803 zcmcK6$8y3j5CBlQB;fSkdsQ0gU*R9%;sXa=GozRsl2blCyVeLBP-DoB1~9g)w<`&} zzeyokAtT;xF~&;K`zU|DW!!DUx4tO*U#0kz&?n`EoZ&g6Y@(2}^hArEXwwrJJuyd5 z%+nJK^u!`Pu|!WS(-SN7#40_pMo+BM6C3ozCOxr5Pi*^$bh>9EJoR>X9uYPM#4gWc z!iK~i&lAFi#6Hh6!iL0wZ@H%|fdm+bP)r?BJB2(BB|_%ZkTzs;5=t0u5Bb>uaY|2| z)kNlqDrB0B_d^!vK0^PC7zY>%%Gd*l3m*}_1~%f7p186TI7NC5)R8+QTNc-L!ad;l zRU5(SiJM6Yy~FHTBrw7Fsv7L5+ewM>q4gP@sKLK+7CYp~Rz=62;6ZJCMCkZpD z`{}$C@!%s;^Q~&8hu&>O$498>-0`cZZN#G{B1^RDd{o7&-W$^pl*N-Gu-X}oLRCO9 zoR6STVO2e38y?S(-e2{F<$hMhR9q3mWtFagvZ@k727B2XhBDf4N4>a;DcpdVg~r^U orhZ7gjuXwDT_3xKSG}@9QC9aw;*GwTde=M3wUAR>6GHSlf2aELUjP6A literal 0 HcmV?d00001