From ef3fcec685a41be16bb9aa39915a9534596cb460 Mon Sep 17 00:00:00 2001 From: Yang Wang Date: Sat, 20 Feb 2021 07:06:16 -0500 Subject: [PATCH 001/604] Fix: cyxpy cannot be installed (#483) Add a few lines in yml file to clarify dependencies --- environment.yml | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/environment.yml b/environment.yml index a5361d4a29..1441b79080 100644 --- a/environment.yml +++ b/environment.yml @@ -1,9 +1,11 @@ name: python_robotics +channels: + - conda-forge dependencies: -- python -- pip -- scipy -- numpy -- pandas -- cvxpy -- matplotlib + - python=3.9 + - pip + - scipy + - numpy + - pandas + - cvxpy + - matplotlib From 078c62bc3eb0ed59e6c41b10dbb52fcafa39037a Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Sat, 20 Feb 2021 21:30:55 +0900 Subject: [PATCH 002/604] enable rundiffstylecheck.sh to run (#484) --- rundiffstylecheck.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 rundiffstylecheck.sh diff --git a/rundiffstylecheck.sh b/rundiffstylecheck.sh old mode 100644 new mode 100755 From c025299dcfe8db7383704601c28dc48f6dc262db Mon Sep 17 00:00:00 2001 From: FXCarl Date: Sun, 21 Feb 2021 14:23:13 +0800 Subject: [PATCH 003/604] Update greedy_best_first_search - calc_final_path method (#477) * Update greedy_best_first_search.py parent_index should be pind. other wise it cann't work * add breadth first search test * Add greedy best first search test --- .../greedy_best_first_search.py | 2 +- tests/test_breadth_first_search.py | 22 +++++++++---------- tests/test_greedy_best_first_search.py | 11 ++++++++++ 3 files changed, 23 insertions(+), 12 deletions(-) create mode 100644 tests/test_greedy_best_first_search.py diff --git a/PathPlanning/GreedyBestFirstSearch/greedy_best_first_search.py b/PathPlanning/GreedyBestFirstSearch/greedy_best_first_search.py index 7100b0e604..f2416fba98 100644 --- a/PathPlanning/GreedyBestFirstSearch/greedy_best_first_search.py +++ b/PathPlanning/GreedyBestFirstSearch/greedy_best_first_search.py @@ -132,7 +132,7 @@ def calc_final_path(self, ngoal, closedset): # generate final course rx, ry = [self.calc_grid_position(ngoal.x, self.minx)], [ self.calc_grid_position(ngoal.y, self.miny)] - n = closedset[ngoal.parent_index] + n = closedset[ngoal.pind] while n is not None: rx.append(self.calc_grid_position(n.x, self.minx)) ry.append(self.calc_grid_position(n.y, self.miny)) diff --git a/tests/test_breadth_first_search.py b/tests/test_breadth_first_search.py index 14c1ac6988..bfc63e39d6 100644 --- a/tests/test_breadth_first_search.py +++ b/tests/test_breadth_first_search.py @@ -1,11 +1,11 @@ -import conftest -from PathPlanning.BreadthFirstSearch import breadth_first_search as m - - -def test_1(): - m.show_animation = False - m.main() - - -if __name__ == '__main__': - conftest.run_this_test(__file__) +import conftest +from PathPlanning.BreadthFirstSearch import breadth_first_search as m + + +def test_1(): + m.show_animation = False + m.main() + + +if __name__ == '__main__': + conftest.run_this_test(__file__) diff --git a/tests/test_greedy_best_first_search.py b/tests/test_greedy_best_first_search.py new file mode 100644 index 0000000000..e573ecf625 --- /dev/null +++ b/tests/test_greedy_best_first_search.py @@ -0,0 +1,11 @@ +import conftest +from PathPlanning.GreedyBestFirstSearch import greedy_best_first_search as m + + +def test_1(): + m.show_animation = False + m.main() + + +if __name__ == '__main__': + conftest.run_this_test(__file__) From d391cdbb8c82f9c3e643f4c2fd95e85d03b47c9e Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 23 Feb 2021 07:27:33 +0900 Subject: [PATCH 004/604] Bump scipy from 1.6.0 to 1.6.1 (#485) Bumps [scipy](https://github.com/scipy/scipy) from 1.6.0 to 1.6.1. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.6.0...v1.6.1) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 8402a5206e..cb46f475da 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.1 -scipy == 1.6.0 +scipy == 1.6.1 pandas == 1.2.2 matplotlib == 3.3.4 cvxpy == 1.1.10 From d53ec936bce2f01ffc99297372cba9081b92c24e Mon Sep 17 00:00:00 2001 From: zarmars Date: Tue, 16 Mar 2021 22:13:11 +0800 Subject: [PATCH 005/604] Fix the problem that the length of candidate path is not correctly compared. Optimal path may be discarded. (#487) --- PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py index 3bed9e2997..7808f2c9f9 100644 --- a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py +++ b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py @@ -40,7 +40,8 @@ def plot_arrow(x, y, yaw, length=1.0, width=0.5, fc="r", ec="k"): def mod2pi(x): - v = np.mod(x, 2.0 * math.pi) + # Be consistent with fmod in cplusplus here. + v = np.mod(x, np.copysign(2.0 * math.pi, x)) if v < -math.pi: v += 2.0 * math.pi else: @@ -76,7 +77,7 @@ def set_path(paths, lengths, ctypes): for tpath in paths: typeissame = (tpath.ctypes == path.ctypes) if typeissame: - if sum(tpath.lengths) - sum(path.lengths) <= 0.01: + if sum(np.abs(tpath.lengths)) - sum(np.abs(path.lengths)) <= 0.01: return paths # not insert path path.L = sum([abs(i) for i in lengths]) From b30ba3e9d022e519431993ab173e610e841f431d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sat, 20 Mar 2021 14:32:52 +0900 Subject: [PATCH 006/604] Bump cvxpy from 1.1.10 to 1.1.11 (#488) Bumps [cvxpy](https://github.com/cvxgrp/cvxpy) from 1.1.10 to 1.1.11. - [Release notes](https://github.com/cvxgrp/cvxpy/releases) - [Changelog](https://github.com/cvxgrp/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxgrp/cvxpy/compare/v1.1.10...v1.1.11) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index cb46f475da..d2fc6db92a 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.20.1 scipy == 1.6.1 pandas == 1.2.2 matplotlib == 3.3.4 -cvxpy == 1.1.10 +cvxpy == 1.1.11 From dbcb8d7ea5c78cb55aae13610cf923ecf7602c33 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 30 Mar 2021 07:24:34 +0900 Subject: [PATCH 007/604] Bump scipy from 1.6.1 to 1.6.2 (#491) Bumps [scipy](https://github.com/scipy/scipy) from 1.6.1 to 1.6.2. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.6.1...v1.6.2) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d2fc6db92a..5b6b9eff2a 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.1 -scipy == 1.6.1 +scipy == 1.6.2 pandas == 1.2.2 matplotlib == 3.3.4 cvxpy == 1.1.11 From 5c408b5d80b53b6835d1d432f1669f06cfe7fce6 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 30 Mar 2021 07:25:17 +0900 Subject: [PATCH 008/604] Bump matplotlib from 3.3.4 to 3.4.0 (#492) Bumps [matplotlib](https://github.com/matplotlib/matplotlib) from 3.3.4 to 3.4.0. - [Release notes](https://github.com/matplotlib/matplotlib/releases) - [Commits](https://github.com/matplotlib/matplotlib/compare/v3.3.4...v3.4.0) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 5b6b9eff2a..5e8cef887e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.1 scipy == 1.6.2 pandas == 1.2.2 -matplotlib == 3.3.4 +matplotlib == 3.4.0 cvxpy == 1.1.11 From f17c991c68d72cf84bb3a89393d0a12454f66583 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 30 Mar 2021 20:23:54 +0900 Subject: [PATCH 009/604] Bump numpy from 1.20.1 to 1.20.2 (#493) Bumps [numpy](https://github.com/numpy/numpy) from 1.20.1 to 1.20.2. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.20.1...v1.20.2) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 5e8cef887e..2d7c47554b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.20.1 +numpy == 1.20.2 scipy == 1.6.2 pandas == 1.2.2 matplotlib == 3.4.0 From bf2d9df83dc6b4927763f6c47786813900f14b47 Mon Sep 17 00:00:00 2001 From: Shamil Date: Fri, 2 Apr 2021 13:49:16 +0200 Subject: [PATCH 010/604] Add ICP support for 3d point clouds (#465) * Add 3d support ICP * icp_matching function returns R,T corresponding to 2D or 3D set of points * update_homogeneuous_matrix - general operations for translation and rotation matrixes * Add test for 3d point cloud (with 2d visualization) * Separate test for 3d points to main_3d_points * Add test for ICP 3d * Correct style * Add space * Style correction * Add more spaces * Add 3d visualizing for ICP * Style corrections * Delete spaces * Style correction * remove space * Separate plot drawing * plot drawing in a separate function for both 2D and 3D versions * figure creating before while loop * Style correction * Comment 3d plot drawing Co-authored-by: Shamil GEMUEV --- .../iterative_closest_point.py | 94 ++++++++++++++----- tests/test_iterative_closest_point.py | 5 + 2 files changed, 76 insertions(+), 23 deletions(-) diff --git a/SLAM/iterative_closest_point/iterative_closest_point.py b/SLAM/iterative_closest_point/iterative_closest_point.py index db252247a8..5ed01fa383 100644 --- a/SLAM/iterative_closest_point/iterative_closest_point.py +++ b/SLAM/iterative_closest_point/iterative_closest_point.py @@ -1,10 +1,11 @@ """ Iterative Closest Point (ICP) SLAM example -author: Atsushi Sakai (@Atsushi_twi), Göktuğ Karakaşlı +author: Atsushi Sakai (@Atsushi_twi), Göktuğ Karakaşlı, Shamil Gemuev """ import math +# from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import import matplotlib.pyplot as plt import numpy as np @@ -19,8 +20,8 @@ def icp_matching(previous_points, current_points): """ Iterative Closest Point matching - input - previous_points: 2D points in the previous frame - current_points: 2D points in the current frame + previous_points: 2D or 3D points in the previous frame + current_points: 2D or 3D points in the current frame - output R: Rotation matrix T: Translation vector @@ -31,19 +32,16 @@ def icp_matching(previous_points, current_points): preError = np.inf count = 0 + if show_animation: + fig = plt.figure() + # if previous_points.shape[0] == 3: + # fig.add_subplot(111, projection='3d') + while dError >= EPS: count += 1 if show_animation: # pragma: no cover - plt.cla() - # for stopping simulation with the esc key. - plt.gcf().canvas.mpl_connect( - 'key_release_event', - lambda event: [exit(0) if event.key == 'escape' else None]) - plt.plot(previous_points[0, :], previous_points[1, :], ".r") - plt.plot(current_points[0, :], current_points[1, :], ".b") - plt.plot(0.0, 0.0, "xr") - plt.axis("equal") + plot_points(previous_points, current_points, fig) plt.pause(0.1) indexes, error = nearest_neighbor_association(previous_points, current_points) @@ -68,24 +66,20 @@ def icp_matching(previous_points, current_points): print("Not Converge...", error, dError, count) break - R = np.array(H[0:2, 0:2]) - T = np.array(H[0:2, 2]) + R = np.array(H[0:-1, 0:-1]) + T = np.array(H[0:-1, -1]) return R, T def update_homogeneous_matrix(Hin, R, T): - H = np.zeros((3, 3)) - - H[0, 0] = R[0, 0] - H[1, 0] = R[1, 0] - H[0, 1] = R[0, 1] - H[1, 1] = R[1, 1] - H[2, 2] = 1.0 + r_size = R.shape[0] + H = np.zeros((r_size + 1, r_size + 1)) - H[0, 2] = T[0] - H[1, 2] = T[1] + H[0:r_size, 0:r_size] = R + H[0:r_size, r_size] = T + H[r_size, r_size] = 1.0 if Hin is None: return H @@ -124,6 +118,28 @@ def svd_motion_estimation(previous_points, current_points): return R, t +def plot_points(previous_points, current_points, figure): + # for stopping simulation with the esc key. + plt.gcf().canvas.mpl_connect( + 'key_release_event', + lambda event: [exit(0) if event.key == 'escape' else None]) + # if previous_points.shape[0] == 3: + # plt.clf() + # axes = figure.add_subplot(111, projection='3d') + # axes.scatter(previous_points[0, :], previous_points[1, :], + # previous_points[2, :], c="r", marker=".") + # axes.scatter(current_points[0, :], current_points[1, :], + # current_points[2, :], c="b", marker=".") + # axes.scatter(0.0, 0.0, 0.0, c="r", marker="x") + # figure.canvas.draw() + # else: + plt.cla() + plt.plot(previous_points[0, :], previous_points[1, :], ".r") + plt.plot(current_points[0, :], current_points[1, :], ".b") + plt.plot(0.0, 0.0, "xr") + plt.axis("equal") + + def main(): print(__file__ + " start!!") @@ -153,5 +169,37 @@ def main(): print("T:", T) +def main_3d_points(): + print(__file__ + " start!!") + + # simulation parameters for 3d point set + nPoint = 1000 + fieldLength = 50.0 + motion = [0.5, 2.0, -5, np.deg2rad(-10.0)] # [x[m],y[m],z[m],roll[deg]] + + nsim = 3 # number of simulation + + for _ in range(nsim): + + # previous points + px = (np.random.rand(nPoint) - 0.5) * fieldLength + py = (np.random.rand(nPoint) - 0.5) * fieldLength + pz = (np.random.rand(nPoint) - 0.5) * fieldLength + previous_points = np.vstack((px, py, pz)) + + # current points + cx = [math.cos(motion[3]) * x - math.sin(motion[3]) * z + motion[0] + for (x, z) in zip(px, pz)] + cy = [y + motion[1] for y in py] + cz = [math.sin(motion[3]) * x + math.cos(motion[3]) * z + motion[2] + for (x, z) in zip(px, pz)] + current_points = np.vstack((cx, cy, cz)) + + R, T = icp_matching(previous_points, current_points) + print("R:", R) + print("T:", T) + + if __name__ == '__main__': main() + main_3d_points() diff --git a/tests/test_iterative_closest_point.py b/tests/test_iterative_closest_point.py index 3f212f7298..3e726b5649 100644 --- a/tests/test_iterative_closest_point.py +++ b/tests/test_iterative_closest_point.py @@ -7,5 +7,10 @@ def test_1(): m.main() +def test_2(): + m.show_animation = False + m.main_3d_points() + + if __name__ == '__main__': conftest.run_this_test(__file__) From 3abc9c69e3074d2ead16a5ae87c529536cafb406 Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Fri, 2 Apr 2021 20:53:26 +0900 Subject: [PATCH 011/604] enable 3d plot --- .../iterative_closest_point.py | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/SLAM/iterative_closest_point/iterative_closest_point.py b/SLAM/iterative_closest_point/iterative_closest_point.py index 5ed01fa383..2b44de2c07 100644 --- a/SLAM/iterative_closest_point/iterative_closest_point.py +++ b/SLAM/iterative_closest_point/iterative_closest_point.py @@ -5,7 +5,7 @@ import math -# from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import +from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import import matplotlib.pyplot as plt import numpy as np @@ -34,8 +34,8 @@ def icp_matching(previous_points, current_points): if show_animation: fig = plt.figure() - # if previous_points.shape[0] == 3: - # fig.add_subplot(111, projection='3d') + if previous_points.shape[0] == 3: + fig.add_subplot(111, projection='3d') while dError >= EPS: count += 1 @@ -123,21 +123,21 @@ def plot_points(previous_points, current_points, figure): plt.gcf().canvas.mpl_connect( 'key_release_event', lambda event: [exit(0) if event.key == 'escape' else None]) - # if previous_points.shape[0] == 3: - # plt.clf() - # axes = figure.add_subplot(111, projection='3d') - # axes.scatter(previous_points[0, :], previous_points[1, :], - # previous_points[2, :], c="r", marker=".") - # axes.scatter(current_points[0, :], current_points[1, :], - # current_points[2, :], c="b", marker=".") - # axes.scatter(0.0, 0.0, 0.0, c="r", marker="x") - # figure.canvas.draw() - # else: - plt.cla() - plt.plot(previous_points[0, :], previous_points[1, :], ".r") - plt.plot(current_points[0, :], current_points[1, :], ".b") - plt.plot(0.0, 0.0, "xr") - plt.axis("equal") + if previous_points.shape[0] == 3: + plt.clf() + axes = figure.add_subplot(111, projection='3d') + axes.scatter(previous_points[0, :], previous_points[1, :], + previous_points[2, :], c="r", marker=".") + axes.scatter(current_points[0, :], current_points[1, :], + current_points[2, :], c="b", marker=".") + axes.scatter(0.0, 0.0, 0.0, c="r", marker="x") + figure.canvas.draw() + else: + plt.cla() + plt.plot(previous_points[0, :], previous_points[1, :], ".r") + plt.plot(current_points[0, :], current_points[1, :], ".b") + plt.plot(0.0, 0.0, "xr") + plt.axis("equal") def main(): From 6bd25b922159dfe6df77f03bd24d61a9ba78ae67 Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Fri, 2 Apr 2021 21:43:29 +0900 Subject: [PATCH 012/604] fix state_lattice_planner.py coordinate conversion (#495) --- .../StateLatticePlanner/state_lattice_planner.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/PathPlanning/StateLatticePlanner/state_lattice_planner.py b/PathPlanning/StateLatticePlanner/state_lattice_planner.py index 51eeb000d2..b5fec697a4 100644 --- a/PathPlanning/StateLatticePlanner/state_lattice_planner.py +++ b/PathPlanning/StateLatticePlanner/state_lattice_planner.py @@ -156,8 +156,8 @@ def calc_lane_states(l_center, l_heading, l_width, v_width, d, nxy): :param nxy: sampling number :return: state list """ - xc = math.cos(l_heading) * d + math.sin(l_heading) * l_center - yc = math.sin(l_heading) * d + math.cos(l_heading) * l_center + xc = d + yc = l_center states = [] for i in range(nxy): @@ -301,7 +301,7 @@ def lane_state_sampling_test1(): k0 = 0.0 l_center = 10.0 - l_heading = np.deg2rad(90.0) + l_heading = np.deg2rad(0.0) l_width = 3.0 v_width = 1.0 d = 10 @@ -309,6 +309,9 @@ def lane_state_sampling_test1(): states = calc_lane_states(l_center, l_heading, l_width, v_width, d, nxy) result = generate_path(states, k0) + if show_animation: + plt.close("all") + for table in result: xc, yc, yawc = motion_model.generate_trajectory( table[3], table[4], table[5], k0) From d4153bcaa1ac81aeedefa60fbde56fad2773b51f Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Fri, 2 Apr 2021 21:43:52 +0900 Subject: [PATCH 013/604] add workaround for dependabot related issue (#496) --- .github/workflows/codeql.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 078590997d..5e6c03aa16 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -2,6 +2,8 @@ name: "Code scanning - action" on: push: + branches-ignore: + - 'dependabot/**' pull_request: schedule: - cron: '0 19 * * 0' From 079de036f3ce80eb6245396e7afabe728bcfb280 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 2 Apr 2021 21:45:09 +0900 Subject: [PATCH 014/604] Bump pandas from 1.2.2 to 1.2.3 (#489) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.2.2 to 1.2.3. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.2.2...v1.2.3) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 2d7c47554b..07ec77dde0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.2 scipy == 1.6.2 -pandas == 1.2.2 +pandas == 1.2.3 matplotlib == 3.4.0 cvxpy == 1.1.11 From add704866aa2df4fd7699875b6ec199dfa817f56 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 6 Apr 2021 07:07:34 +0900 Subject: [PATCH 015/604] Bump matplotlib from 3.4.0 to 3.4.1 (#497) Bumps [matplotlib](https://github.com/matplotlib/matplotlib) from 3.4.0 to 3.4.1. - [Release notes](https://github.com/matplotlib/matplotlib/releases) - [Commits](https://github.com/matplotlib/matplotlib/compare/v3.4.0...v3.4.1) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 07ec77dde0..b3610549b6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.2 scipy == 1.6.2 pandas == 1.2.3 -matplotlib == 3.4.0 +matplotlib == 3.4.1 cvxpy == 1.1.11 From 52e6225e73780e13c4f79015f6efb3ebfcf38ccc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 13 Apr 2021 07:22:10 +0900 Subject: [PATCH 016/604] Bump cvxpy from 1.1.11 to 1.1.12 (#501) Bumps [cvxpy](https://github.com/cvxgrp/cvxpy) from 1.1.11 to 1.1.12. - [Release notes](https://github.com/cvxgrp/cvxpy/releases) - [Changelog](https://github.com/cvxgrp/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxgrp/cvxpy/compare/v1.1.11...v1.1.12) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index b3610549b6..8ab982f887 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.20.2 scipy == 1.6.2 pandas == 1.2.3 matplotlib == 3.4.1 -cvxpy == 1.1.11 +cvxpy == 1.1.12 From 6e98da47fd5535f8535f84ecb57964945ab0b041 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 13 Apr 2021 07:22:32 +0900 Subject: [PATCH 017/604] Bump pandas from 1.2.3 to 1.2.4 (#502) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.2.3 to 1.2.4. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.2.3...v1.2.4) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 8ab982f887..d2fd8f7f2b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.2 scipy == 1.6.2 -pandas == 1.2.3 +pandas == 1.2.4 matplotlib == 3.4.1 cvxpy == 1.1.12 From 0705b1cb5b7c6626c54ff7868d4416240fcb8ed6 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 27 Apr 2021 07:07:54 +0900 Subject: [PATCH 018/604] Bump scipy from 1.6.2 to 1.6.3 (#504) Bumps [scipy](https://github.com/scipy/scipy) from 1.6.2 to 1.6.3. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.6.2...v1.6.3) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d2fd8f7f2b..0e1d0dfe94 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.2 -scipy == 1.6.2 +scipy == 1.6.3 pandas == 1.2.4 matplotlib == 3.4.1 cvxpy == 1.1.12 From 3ff6b7d1ec9ecc1865b74225d9c31d888f0fa884 Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Sat, 8 May 2021 13:27:33 +0900 Subject: [PATCH 019/604] Update MacOS_CI.yml (#507) * Update MacOS_CI.yml * Update MacOS_CI.yml * Update MacOS_CI.yml * Update MacOS_CI.yml * Update MacOS_CI.yml --- .github/workflows/MacOS_CI.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/MacOS_CI.yml b/.github/workflows/MacOS_CI.yml index 5bd9a60828..6b3ffa2588 100644 --- a/.github/workflows/MacOS_CI.yml +++ b/.github/workflows/MacOS_CI.yml @@ -8,7 +8,7 @@ on: [push, pull_request] jobs: build: - runs-on: ubuntu-latest + runs-on: macos-latest strategy: matrix: python-version: [ '3.9' ] @@ -17,6 +17,9 @@ jobs: - uses: actions/checkout@v2 - run: git fetch --prune --unshallow + - name: Update bash + run: brew install bash + - name: Setup python uses: actions/setup-python@v2 with: @@ -25,6 +28,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip + pip install numpy # cvxpy install workaround pip install -r requirements.txt - name: install coverage run: pip install coverage From 02cb3ad556c999fba9f793c9b995486aa0fed830 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 11 May 2021 07:14:13 +0900 Subject: [PATCH 020/604] Bump matplotlib from 3.4.1 to 3.4.2 (#509) Bumps [matplotlib](https://github.com/matplotlib/matplotlib) from 3.4.1 to 3.4.2. - [Release notes](https://github.com/matplotlib/matplotlib/releases) - [Commits](https://github.com/matplotlib/matplotlib/compare/v3.4.1...v3.4.2) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 0e1d0dfe94..2c05e5ec72 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.2 scipy == 1.6.3 pandas == 1.2.4 -matplotlib == 3.4.1 +matplotlib == 3.4.2 cvxpy == 1.1.12 From 0e232037c751cbeb8bb8cdac0b33bf48e4937f2a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 11 May 2021 07:14:31 +0900 Subject: [PATCH 021/604] Bump numpy from 1.20.2 to 1.20.3 (#510) Bumps [numpy](https://github.com/numpy/numpy) from 1.20.2 to 1.20.3. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.20.2...v1.20.3) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 2c05e5ec72..6241a11e5b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.20.2 +numpy == 1.20.3 scipy == 1.6.3 pandas == 1.2.4 matplotlib == 3.4.2 From 2cf4f6f001ec7fa74dc2d3bce3818b5eff11d9eb Mon Sep 17 00:00:00 2001 From: nirnayroy <32942494+nirnayroy@users.noreply.github.com> Date: Sat, 15 May 2021 11:31:29 +0530 Subject: [PATCH 022/604] Added D* Search to path planning folder (#490) * changes * updated docs and readme * Update a_star.py * Update a_star.py * Create test_dstar.py * trailing loc * Update dstar.py * Update dstar.py * Update dstar.py * Update dstar.py * Update dstar.py * newline * corrected changes requested * 13, five, 21 * corrected changes * latest * linted * lint * removed diff --- PathPlanning/DStar/dstar.py | 241 +++++++++++++++++++++++++++++++++ README.md | 14 ++ docs/modules/path_planning.rst | 16 +++ tests/test_dstar.py | 11 ++ 4 files changed, 282 insertions(+) create mode 100644 PathPlanning/DStar/dstar.py create mode 100644 tests/test_dstar.py diff --git a/PathPlanning/DStar/dstar.py b/PathPlanning/DStar/dstar.py new file mode 100644 index 0000000000..bc7e7c966e --- /dev/null +++ b/PathPlanning/DStar/dstar.py @@ -0,0 +1,241 @@ +""" + +D* grid planning + +author: Nirnay Roy + +See Wikipedia article (https://en.wikipedia.org/wiki/D*) + +""" +import math + +from sys import maxsize + +import matplotlib.pyplot as plt + +show_animation = True + + +class State: + + def __init__(self, x, y): + self.x = x + self.y = y + self.parent = None + self.state = "." + self.t = "new" # tag for state + self.h = 0 + self.k = 0 + + def cost(self, state): + if self.state == "#" or state.state == "#": + return maxsize + + return math.sqrt(math.pow((self.x - state.x), 2) + + math.pow((self.y - state.y), 2)) + + def set_state(self, state): + """ + .: new + #: obstacle + e: oparent of current state + *: closed state + s: current state + """ + if state not in ["s", ".", "#", "e", "*"]: + return + self.state = state + + +class Map: + + def __init__(self, row, col): + self.row = row + self.col = col + self.map = self.init_map() + + def init_map(self): + map_list = [] + for i in range(self.row): + tmp = [] + for j in range(self.col): + tmp.append(State(i, j)) + map_list.append(tmp) + return map_list + + def get_neighbers(self, state): + state_list = [] + for i in [-1, 0, 1]: + for j in [-1, 0, 1]: + if i == 0 and j == 0: + continue + if state.x + i < 0 or state.x + i >= self.row: + continue + if state.y + j < 0 or state.y + j >= self.col: + continue + state_list.append(self.map[state.x + i][state.y + j]) + return state_list + + def set_obstacle(self, point_list): + for x, y in point_list: + if x < 0 or x >= self.row or y < 0 or y >= self.col: + continue + + self.map[x][y].set_state("#") + + +class Dstar: + def __init__(self, maps): + self.map = maps + self.open_list = set() + + def process_state(self): + x = self.min_state() + + if x is None: + return -1 + + k_old = self.get_kmin() + self.remove(x) + + if k_old < x.h: + for y in self.map.get_neighbers(x): + if y.h <= k_old and x.h > y.h + x.cost(y): + x.parent = y + x.h = y.h + x.cost(y) + elif k_old == x.h: + for y in self.map.get_neighbers(x): + if y.t == "new" or y.parent == x and y.h != x.h + x.cost(y) \ + or y.parent != x and y.h > x.h + x.cost(y): + y.parent = x + self.insert(y, x.h + x.cost(y)) + else: + for y in self.map.get_neighbers(x): + if y.t == "new" or y.parent == x and y.h != x.h + x.cost(y): + y.parent = x + self.insert(y, x.h + x.cost(y)) + else: + if y.parent != x and y.h > x.h + x.cost(y): + self.insert(y, x.h) + else: + if y.parent != x and x.h > y.h + x.cost(y) \ + and y.t == "close" and y.h > k_old: + self.insert(y, y.h) + return self.get_kmin() + + def min_state(self): + if not self.open_list: + return None + min_state = min(self.open_list, key=lambda x: x.k) + return min_state + + def get_kmin(self): + if not self.open_list: + return -1 + k_min = min([x.k for x in self.open_list]) + return k_min + + def insert(self, state, h_new): + if state.t == "new": + state.k = h_new + elif state.t == "open": + state.k = min(state.k, h_new) + elif state.t == "close": + state.k = min(state.h, h_new) + state.h = h_new + state.t = "open" + self.open_list.add(state) + + def remove(self, state): + if state.t == "open": + state.t = "close" + self.open_list.remove(state) + + def modify_cost(self, x): + if x.t == "close": + self.insert(x, x.parent.h + x.cost(x.parent)) + + def run(self, start, end): + + rx = [] + ry = [] + + self.open_list.add(end) + + while True: + self.process_state() + if start.t == "close": + break + + start.set_state("s") + s = start + s = s.parent + s.set_state("e") + tmp = start + + while tmp != end: + tmp.set_state("*") + rx.append(tmp.x) + ry.append(tmp.y) + if show_animation: + plt.plot(rx, ry) + plt.pause(0.01) + if tmp.parent.state == "#": + self.modify(tmp) + continue + tmp = tmp.parent + tmp.set_state("e") + + return rx, ry + + def modify(self, state): + self.modify_cost(state) + while True: + k_min = self.process_state() + if k_min >= state.h: + break + + +def main(): + m = Map(100, 100) + ox, oy = [], [] + for i in range(-10, 60): + ox.append(i) + oy.append(-10) + for i in range(-10, 60): + ox.append(60) + oy.append(i) + for i in range(-10, 61): + ox.append(i) + oy.append(60) + for i in range(-10, 61): + ox.append(-10) + oy.append(i) + for i in range(-10, 40): + ox.append(20) + oy.append(i) + for i in range(0, 40): + ox.append(40) + oy.append(60 - i) + print([(i, j) for i, j in zip(ox, oy)]) + m.set_obstacle([(i, j) for i, j in zip(ox, oy)]) + + start = [10, 10] + goal = [50, 50] + if show_animation: + plt.plot(ox, oy, ".k") + plt.plot(start[0], start[1], "og") + plt.plot(goal[0], goal[1], "xb") + + start = m.map[start[0]][start[1]] + end = m.map[goal[0]][goal[1]] + dstar = Dstar(m) + rx, ry = dstar.run(start, end) + + if show_animation: + plt.plot(rx, ry) + plt.show() + + +if __name__ == '__main__': + main() diff --git a/README.md b/README.md index 804966d121..ca9e6192b9 100644 --- a/README.md +++ b/README.md @@ -37,6 +37,7 @@ Python codes for robotics algorithm. * [Grid based search](#grid-based-search) * [Dijkstra algorithm](#dijkstra-algorithm) * [A* algorithm](#a-algorithm) + * [D* algorithm](#d-algorithm) * [Potential Field algorithm](#potential-field-algorithm) * [Grid based coverage path planning](#grid-based-coverage-path-planning) * [State Lattice Planning](#state-lattice-planning) @@ -301,6 +302,19 @@ In the animation, cyan points are searched nodes. Its heuristic is 2D Euclid distance. +### D\* algorithm + +This is a 2D grid based the shortest path planning with D star algorithm. + +![figure at master · nirnayroy/intelligentrobotics](https://github.com/nirnayroy/intelligent-robotics/blob/main/dstar.gif) + +The animation shows a robot finding its path avoiding an obstacle using the D* search algorithm. + +Ref: + +- [D* Algorithm Wikipedia](https://en.wikipedia.org/wiki/D*) + + ### Potential Field algorithm This is a 2D grid based path planning with Potential Field algorithm. diff --git a/docs/modules/path_planning.rst b/docs/modules/path_planning.rst index f74867dcdf..a0bdd45511 100644 --- a/docs/modules/path_planning.rst +++ b/docs/modules/path_planning.rst @@ -39,6 +39,21 @@ In the animation, cyan points are searched nodes. Its heuristic is 2D Euclid distance. +.. _a*-algorithm: + +D\* algorithm +~~~~~~~~~~~~~ + +This is a 2D grid based shortest path planning with D star algorithm. + +|dstar| + +The animation shows a robot finding its path avoiding an obstacle using the D* search algorithm. + +Ref: + +- `D* search Wikipedia `__ + Potential Field algorithm ~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -427,6 +442,7 @@ Ref: .. |DWA| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/DynamicWindowApproach/animation.gif .. |Dijkstra| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/Dijkstra/animation.gif .. |astar| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/AStar/animation.gif +.. |dstar| image:: https://github.com/nirnayroy/intelligent-robotics/blob/main/dstar.gif .. |PotentialField| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/PotentialFieldPlanning/animation.gif .. |4| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/ModelPredictiveTrajectoryGenerator/kn05animation.gif .. |5| image:: https://github.com/AtsushiSakai/PythonRobotics/raw/master/PathPlanning/ModelPredictiveTrajectoryGenerator/lookuptable.png?raw=True diff --git a/tests/test_dstar.py b/tests/test_dstar.py new file mode 100644 index 0000000000..f8f40fecef --- /dev/null +++ b/tests/test_dstar.py @@ -0,0 +1,11 @@ +import conftest +from PathPlanning.DStar import dstar as m + + +def test_1(): + m.show_animation = False + m.main() + + +if __name__ == '__main__': + conftest.run_this_test(__file__) From 1de0ffddb1ea11396a019403bbb986c8df8e0bdd Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Sat, 15 May 2021 15:21:15 +0900 Subject: [PATCH 023/604] change DStar animation --- PathPlanning/DStar/dstar.py | 13 +++++++------ README.md | 2 +- docs/modules/path_planning.rst | 2 +- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/PathPlanning/DStar/dstar.py b/PathPlanning/DStar/dstar.py index bc7e7c966e..e01508b3df 100644 --- a/PathPlanning/DStar/dstar.py +++ b/PathPlanning/DStar/dstar.py @@ -63,7 +63,7 @@ def init_map(self): map_list.append(tmp) return map_list - def get_neighbers(self, state): + def get_neighbors(self, state): state_list = [] for i in [-1, 0, 1]: for j in [-1, 0, 1]: @@ -99,18 +99,18 @@ def process_state(self): self.remove(x) if k_old < x.h: - for y in self.map.get_neighbers(x): + for y in self.map.get_neighbors(x): if y.h <= k_old and x.h > y.h + x.cost(y): x.parent = y x.h = y.h + x.cost(y) elif k_old == x.h: - for y in self.map.get_neighbers(x): + for y in self.map.get_neighbors(x): if y.t == "new" or y.parent == x and y.h != x.h + x.cost(y) \ or y.parent != x and y.h > x.h + x.cost(y): y.parent = x self.insert(y, x.h + x.cost(y)) else: - for y in self.map.get_neighbers(x): + for y in self.map.get_neighbors(x): if y.t == "new" or y.parent == x and y.h != x.h + x.cost(y): y.parent = x self.insert(y, x.h + x.cost(y)) @@ -178,7 +178,7 @@ def run(self, start, end): rx.append(tmp.x) ry.append(tmp.y) if show_animation: - plt.plot(rx, ry) + plt.plot(rx, ry, "-r") plt.pause(0.01) if tmp.parent.state == "#": self.modify(tmp) @@ -226,6 +226,7 @@ def main(): plt.plot(ox, oy, ".k") plt.plot(start[0], start[1], "og") plt.plot(goal[0], goal[1], "xb") + plt.axis("equal") start = m.map[start[0]][start[1]] end = m.map[goal[0]][goal[1]] @@ -233,7 +234,7 @@ def main(): rx, ry = dstar.run(start, end) if show_animation: - plt.plot(rx, ry) + plt.plot(rx, ry, "-r") plt.show() diff --git a/README.md b/README.md index ca9e6192b9..fac8b53dce 100644 --- a/README.md +++ b/README.md @@ -306,7 +306,7 @@ Its heuristic is 2D Euclid distance. This is a 2D grid based the shortest path planning with D star algorithm. -![figure at master · nirnayroy/intelligentrobotics](https://github.com/nirnayroy/intelligent-robotics/blob/main/dstar.gif) +![figure at master · nirnayroy/intelligentrobotics](https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/DStar/animation.gif) The animation shows a robot finding its path avoiding an obstacle using the D* search algorithm. diff --git a/docs/modules/path_planning.rst b/docs/modules/path_planning.rst index a0bdd45511..cfe7b6ad40 100644 --- a/docs/modules/path_planning.rst +++ b/docs/modules/path_planning.rst @@ -442,7 +442,7 @@ Ref: .. |DWA| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/DynamicWindowApproach/animation.gif .. |Dijkstra| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/Dijkstra/animation.gif .. |astar| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/AStar/animation.gif -.. |dstar| image:: https://github.com/nirnayroy/intelligent-robotics/blob/main/dstar.gif +.. |dstar| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/DStar/animation.gif .. |PotentialField| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/PotentialFieldPlanning/animation.gif .. |4| image:: https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/ModelPredictiveTrajectoryGenerator/kn05animation.gif .. |5| image:: https://github.com/AtsushiSakai/PythonRobotics/raw/master/PathPlanning/ModelPredictiveTrajectoryGenerator/lookuptable.png?raw=True From 1050aea5277eb27e1dab13e71f19588b19d1763d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 1 Jun 2021 07:54:57 +0900 Subject: [PATCH 024/604] Bump cvxpy from 1.1.12 to 1.1.13 (#512) Bumps [cvxpy](https://github.com/cvxgrp/cvxpy) from 1.1.12 to 1.1.13. - [Release notes](https://github.com/cvxgrp/cvxpy/releases) - [Changelog](https://github.com/cvxpy/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxgrp/cvxpy/compare/v1.1.12...v1.1.13) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 6241a11e5b..fea1a9562b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.20.3 scipy == 1.6.3 pandas == 1.2.4 matplotlib == 3.4.2 -cvxpy == 1.1.12 +cvxpy == 1.1.13 From 2ac1d9c8156eda2e6b87f501197a8ea42b649653 Mon Sep 17 00:00:00 2001 From: vss2sn <28676655+vss2sn@users.noreply.github.com> Date: Mon, 7 Jun 2021 07:28:23 -0400 Subject: [PATCH 025/604] Add D* Lite. (#511) * Add D* Lite. * Add test. Minor changes * Modified based on LGTM report * Fix linter errors * Fixes and lint. * Update README.md Made requested changes Add transform between world and grid coordinates to allow negative wold coordinates Modify to allow diagonal motion * Added display of previous and new computed path --- PathPlanning/DStarLite/d_star_lite.py | 398 ++++++++++++++++++++++++++ README.md | 13 + tests/test_d_star_lite.py | 11 + 3 files changed, 422 insertions(+) create mode 100644 PathPlanning/DStarLite/d_star_lite.py create mode 100644 tests/test_d_star_lite.py diff --git a/PathPlanning/DStarLite/d_star_lite.py b/PathPlanning/DStarLite/d_star_lite.py new file mode 100644 index 0000000000..603c053dab --- /dev/null +++ b/PathPlanning/DStarLite/d_star_lite.py @@ -0,0 +1,398 @@ +""" +D* Lite grid planning +author: vss2sn (28676655+vss2sn@users.noreply.github.com) +Link to papers: +D* Lite (Link: http://idm-lab.org/bib/abstracts/papers/aaai02b.pd) +Improved Fast Replanning for Robot Navigation in Unknown Terrain +(Link: http://www.cs.cmu.edu/~maxim/files/dlite_icra02.pdf) +Implemented maintaining similarity with the pseudocode for understanding. +Code can be significantly optimized by using a priority queue for U, etc. +Avoiding additional imports based on repository philosophy. +""" +import math +import matplotlib.pyplot as plt +import random + +show_animation = True +pause_time = 0.001 +p_create_random_obstacle = 0 + + +class Node: + def __init__(self, x: int = 0, y: int = 0, cost: float = 0.0): + self.x = x + self.y = y + self.cost = cost + + +def add_coordinates(node1: Node, node2: Node): + new_node = Node() + new_node.x = node1.x + node2.x + new_node.y = node1.y + node2.y + new_node.cost = node1.cost + node2.cost + return new_node + + +def compare_coordinates(node1: Node, node2: Node): + return node1.x == node2.x and node1.y == node2.y + + +class DStarLite: + + # Please adjust the heuristic function (h) if you change the list of + # possible motions + motions = [ + Node(1, 0, 1), + Node(0, 1, 1), + Node(-1, 0, 1), + Node(0, -1, 1), + Node(1, 1, math.sqrt(2)), + Node(1, -1, math.sqrt(2)), + Node(-1, 1, math.sqrt(2)), + Node(-1, -1, math.sqrt(2)) + ] + + def __init__(self, ox: list, oy: list): + # Ensure that within the algorithm implementation all node coordinates + # are indices in the grid and extend + # from 0 to abs(_max - _min) + self.x_min_world = int(min(ox)) + self.y_min_world = int(min(oy)) + self.x_max = int(abs(max(ox) - self.x_min_world)) + self.y_max = int(abs(max(oy) - self.y_min_world)) + self.obstacles = [Node(x - self.x_min_world, y - self.y_min_world) + for x, y in zip(ox, oy)] + self.start = Node(0, 0) + self.goal = Node(0, 0) + self.U = list() + self.km = 0.0 + self.kold = 0.0 + self.rhs = list() + self.g = list() + self.detected_obstacles = list() + if show_animation: + self.detected_obstacles_for_plotting_x = list() + self.detected_obstacles_for_plotting_y = list() + + def create_grid(self, val: float): + grid = list() + for _ in range(0, self.x_max): + grid_row = list() + for _ in range(0, self.y_max): + grid_row.append(val) + grid.append(grid_row) + return grid + + def is_obstacle(self, node: Node): + return any([compare_coordinates(node, obstacle) + for obstacle in self.obstacles]) or \ + any([compare_coordinates(node, obstacle) + for obstacle in self.detected_obstacles]) + + def c(self, node1: Node, node2: Node): + if self.is_obstacle(node2): + # Attempting to move from or to an obstacle + return math.inf + new_node = Node(node1.x-node2.x, node1.y-node2.y) + detected_motion = list(filter(lambda motion: + compare_coordinates(motion, new_node), + self.motions)) + return detected_motion[0].cost + + def h(self, s: Node): + # Cannot use the 2nd euclidean norm as this might sometimes generate + # heuristics that overestimate the cost, making them inadmissible, + # due to rounding errors etc (when combined with calculate_key) + # To be admissible heuristic should + # never overestimate the cost of a move + # hence not using the line below + # return math.hypot(self.start.x - s.x, self.start.y - s.y) + + # Below is the same as 1; modify if you modify the cost of each move in + # motion + # return max(abs(self.start.x - s.x), abs(self.start.y - s.y)) + return 1 + + def calculate_key(self, s: Node): + return (min(self.g[s.x][s.y], self.rhs[s.x][s.y]) + self.h(s) + + self.km, min(self.g[s.x][s.y], self.rhs[s.x][s.y])) + + def is_valid(self, node: Node): + if 0 <= node.x < self.x_max and 0 <= node.y < self.y_max: + return True + return False + + def get_neighbours(self, u: Node): + return [add_coordinates(u, motion) for motion in self.motions + if self.is_valid(add_coordinates(u, motion))] + + def pred(self, u: Node): + # Grid, so each vertex is connected to the ones around it + return self.get_neighbours(u) + + def succ(self, u: Node): + # Grid, so each vertex is connected to the ones around it + return self.get_neighbours(u) + + def initialize(self, start: Node, goal: Node): + self.start.x = start.x - self.x_min_world + self.start.y = start.y - self.y_min_world + self.goal.x = goal.x - self.x_min_world + self.goal.y = goal.y - self.y_min_world + self.U = list() # Would normally be a priority queue + self.km = 0.0 + self.rhs = self.create_grid(math.inf) + self.g = self.create_grid(math.inf) + self.rhs[self.goal.x][self.goal.y] = 0 + self.U.append((self.goal, self.calculate_key(self.goal))) + self.detected_obstacles = list() + + def update_vertex(self, u: Node): + if not compare_coordinates(u, self.goal): + self.rhs[u.x][u.y] = min([self.c(u, sprime) + + self.g[sprime.x][sprime.y] + for sprime in self.succ(u)]) + if any([compare_coordinates(u, node) for node, key in self.U]): + self.U = [(node, key) for node, key in self.U + if not compare_coordinates(node, u)] + self.U.sort(key=lambda x: x[1]) + if self.g[u.x][u.y] != self.rhs[u.x][u.y]: + self.U.append((u, self.calculate_key(u))) + self.U.sort(key=lambda x: x[1]) + + def compare_keys(self, key_pair1: tuple[float, float], + key_pair2: tuple[float, float]): + return key_pair1[0] < key_pair2[0] or \ + (key_pair1[0] == key_pair2[0] and key_pair1[1] < key_pair2[1]) + + def compute_shortest_path(self): + self.U.sort(key=lambda x: x[1]) + while (len(self.U) > 0 and + self.compare_keys(self.U[0][1], + self.calculate_key(self.start))) or \ + self.rhs[self.start.x][self.start.y] != \ + self.g[self.start.x][self.start.y]: + self.kold = self.U[0][1] + u = self.U[0][0] + self.U.pop(0) + if self.compare_keys(self.kold, self.calculate_key(u)): + self.U.append((u, self.calculate_key(u))) + self.U.sort(key=lambda x: x[1]) + elif self.g[u.x][u.y] > self.rhs[u.x][u.y]: + self.g[u.x][u.y] = self.rhs[u.x][u.y] + for s in self.pred(u): + self.update_vertex(s) + else: + self.g[u.x][u.y] = math.inf + for s in self.pred(u) + [u]: + self.update_vertex(s) + self.U.sort(key=lambda x: x[1]) + + def detect_changes(self): + changed_vertices = list() + if len(self.spoofed_obstacles) > 0: + for spoofed_obstacle in self.spoofed_obstacles[0]: + if compare_coordinates(spoofed_obstacle, self.start) or \ + compare_coordinates(spoofed_obstacle, self.goal): + continue + changed_vertices.append(spoofed_obstacle) + self.detected_obstacles.append(spoofed_obstacle) + if show_animation: + self.detected_obstacles_for_plotting_x.append( + spoofed_obstacle.x + self.x_min_world) + self.detected_obstacles_for_plotting_y.append( + spoofed_obstacle.y + self.y_min_world) + plt.plot(self.detected_obstacles_for_plotting_x, + self.detected_obstacles_for_plotting_y, ".k") + plt.pause(pause_time) + self.spoofed_obstacles.pop(0) + + # Allows random generation of obstacles + random.seed() + if random.random() > 1 - p_create_random_obstacle: + x = random.randint(0, self.x_max) + y = random.randint(0, self.y_max) + new_obs = Node(x, y) + if compare_coordinates(new_obs, self.start) or \ + compare_coordinates(new_obs, self.goal): + return changed_vertices + changed_vertices.append(Node(x, y)) + self.detected_obstacles.append(Node(x, y)) + if show_animation: + self.detected_obstacles_for_plotting_x.append(x + + self.x_min_world) + self.detected_obstacles_for_plotting_y.append(y + + self.y_min_world) + plt.plot(self.detected_obstacles_for_plotting_x, + self.detected_obstacles_for_plotting_y, ".k") + plt.pause(pause_time) + return changed_vertices + + def compute_current_path(self): + path = list() + current_point = Node(self.start.x, self.start.y) + while not compare_coordinates(current_point, self.goal): + path.append(current_point) + current_point = min(self.succ(current_point), + key=lambda sprime: + self.c(current_point, sprime) + + self.g[sprime.x][sprime.y]) + path.append(self.goal) + return path + + def compare_paths(self, path1: list, path2: list): + if len(path1) != len(path2): + return False + for node1, node2 in zip(path1, path2): + if not compare_coordinates(node1, node2): + return False + return True + + def display_path(self, path: list, colour: str, alpha: int = 1): + px = [(node.x + self.x_min_world) for node in path] + py = [(node.y + self.y_min_world) for node in path] + drawing = plt.plot(px, py, colour, alpha=alpha) + plt.pause(pause_time) + return drawing + + def main(self, start: Node, goal: Node, + spoofed_ox: list, spoofed_oy: list): + self.spoofed_obstacles = [[Node(x - self.x_min_world, + y - self.y_min_world) + for x, y in zip(rowx, rowy)] + for rowx, rowy in zip(spoofed_ox, spoofed_oy) + ] + pathx = [] + pathy = [] + self.initialize(start, goal) + last = self.start + self.compute_shortest_path() + pathx.append(self.start.x + self.x_min_world) + pathy.append(self.start.y + self.y_min_world) + + if show_animation: + current_path = self.compute_current_path() + previous_path = current_path.copy() + previous_path_image = self.display_path(previous_path, ".c", + alpha=0.3) + current_path_image = self.display_path(current_path, ".c") + + while not compare_coordinates(self.goal, self.start): + if self.g[self.start.x][self.start.y] == math.inf: + print("No path possible") + return False, pathx, pathy + self.start = min(self.succ(self.start), + key=lambda sprime: + self.c(self.start, sprime) + + self.g[sprime.x][sprime.y]) + pathx.append(self.start.x + self.x_min_world) + pathy.append(self.start.y + self.y_min_world) + if show_animation: + current_path.pop(0) + plt.plot(pathx, pathy, "-r") + plt.pause(pause_time) + changed_vertices = self.detect_changes() + if len(changed_vertices) != 0: + print("New obstacle detected") + self.km += self.h(last) + last = self.start + for u in changed_vertices: + if compare_coordinates(u, self.start): + continue + self.rhs[u.x][u.y] = math.inf + self.g[u.x][u.y] = math.inf + self.update_vertex(u) + self.compute_shortest_path() + + if show_animation: + new_path = self.compute_current_path() + if not self.compare_paths(current_path, new_path): + current_path_image[0].remove() + previous_path_image[0].remove() + previous_path = current_path.copy() + current_path = new_path.copy() + previous_path_image = self.display_path(previous_path, + ".c", + alpha=0.3) + current_path_image = self.display_path(current_path, + ".c") + plt.pause(pause_time) + print("Path found") + return True, pathx, pathy + + +def main(): + + # start and goal position + sx = 10 # [m] + sy = 10 # [m] + gx = 50 # [m] + gy = 50 # [m] + + # set obstacle positions + ox, oy = [], [] + for i in range(-10, 60): + ox.append(i) + oy.append(-10.0) + for i in range(-10, 60): + ox.append(60.0) + oy.append(i) + for i in range(-10, 61): + ox.append(i) + oy.append(60.0) + for i in range(-10, 61): + ox.append(-10.0) + oy.append(i) + for i in range(-10, 40): + ox.append(20.0) + oy.append(i) + for i in range(0, 40): + ox.append(40.0) + oy.append(60.0 - i) + + if show_animation: + plt.plot(ox, oy, ".k") + plt.plot(sx, sy, "og") + plt.plot(gx, gy, "xb") + plt.grid(True) + plt.axis("equal") + label_column = ['Start', 'Goal', 'Path taken', + 'Current computed path', 'Previous computed path', + 'Obstacles'] + columns = [plt.plot([], [], symbol, color=colour, alpha=alpha)[0] + for symbol, colour, alpha in [['o', 'g', 1], + ['x', 'b', 1], + ['-', 'r', 1], + ['.', 'c', 1], + ['.', 'c', 0.3], + ['.', 'k', 1]]] + plt.legend(columns, label_column, bbox_to_anchor=(1, 1), title="Key:", + fontsize="xx-small") + plt.plot() + plt.pause(pause_time) + + # Obstacles discovered at time = row + # time = 1, obstacles discovered at (0, 2), (9, 2), (4, 0) + # time = 2, obstacles discovered at (0, 1), (7, 7) + # ... + # when the spoofed obstacles are: + # spoofed_ox = [[0, 9, 4], [0, 7], [], [], [], [], [], [5]] + # spoofed_oy = [[2, 2, 0], [1, 7], [], [], [], [], [], [4]] + + # Reroute + # spoofed_ox = [[], [], [], [], [], [], [], [40 for _ in range(10, 21)]] + # spoofed_oy = [[], [], [], [], [], [], [], [i for i in range(10, 21)]] + + # Obstacles that demostrate large rerouting + spoofed_ox = [[], [], [], + [i for i in range(0, 21)] + [0 for _ in range(0, 20)]] + spoofed_oy = [[], [], [], + [20 for _ in range(0, 21)] + [i for i in range(0, 20)]] + + dstarlite = DStarLite(ox, oy) + dstarlite.main(Node(x=sx, y=sy), Node(x=gx, y=gy), + spoofed_ox=spoofed_ox, spoofed_oy=spoofed_oy) + + +if __name__ == "__main__": + main() diff --git a/README.md b/README.md index fac8b53dce..e2eafe74f0 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,7 @@ Python codes for robotics algorithm. * [Dijkstra algorithm](#dijkstra-algorithm) * [A* algorithm](#a-algorithm) * [D* algorithm](#d-algorithm) + * [D* Lite algorithm](#dstarlite-algorithm) * [Potential Field algorithm](#potential-field-algorithm) * [Grid based coverage path planning](#grid-based-coverage-path-planning) * [State Lattice Planning](#state-lattice-planning) @@ -314,6 +315,18 @@ Ref: - [D* Algorithm Wikipedia](https://en.wikipedia.org/wiki/D*) +### D\* Lite algorithm + +This algorithm finds the shortest path between two points while rerouting when obstacles are discovered. It has been implemented here for a 2D grid. + +![D* Lite](https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathPlanning/DStarLite/animation.gif) + +The animation shows a robot finding its path and rerouting to avoid obstacles as they are discovered using the D* Lite search algorithm. + +Refs: + +- [D* Lite](http://idm-lab.org/bib/abstracts/papers/aaai02b.pd) +- [Improved Fast Replanning for Robot Navigation in Unknown Terrain](http://www.cs.cmu.edu/~maxim/files/dlite_icra02.pdf) ### Potential Field algorithm diff --git a/tests/test_d_star_lite.py b/tests/test_d_star_lite.py new file mode 100644 index 0000000000..b60a140a89 --- /dev/null +++ b/tests/test_d_star_lite.py @@ -0,0 +1,11 @@ +import conftest +from PathPlanning.DStarLite import d_star_lite as m + + +def test_1(): + m.show_animation = False + m.main() + + +if __name__ == '__main__': + conftest.run_this_test(__file__) From a0db9d266c65e54f61a525fb5305772e929cee08 Mon Sep 17 00:00:00 2001 From: vss2sn <28676655+vss2sn@users.noreply.github.com> Date: Wed, 9 Jun 2021 10:02:32 -0400 Subject: [PATCH 026/604] Fix D* Lite README.md link (#513) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e2eafe74f0..c9e45d9363 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,7 @@ Python codes for robotics algorithm. * [Dijkstra algorithm](#dijkstra-algorithm) * [A* algorithm](#a-algorithm) * [D* algorithm](#d-algorithm) - * [D* Lite algorithm](#dstarlite-algorithm) + * [D* Lite algorithm](#d-lite-algorithm) * [Potential Field algorithm](#potential-field-algorithm) * [Grid based coverage path planning](#grid-based-coverage-path-planning) * [State Lattice Planning](#state-lattice-planning) From fe4ce92c4bc5bdbc6549d2512514f5bfb7cb72e6 Mon Sep 17 00:00:00 2001 From: Haegu Lee <34788458+benthebear93@users.noreply.github.com> Date: Mon, 21 Jun 2021 22:44:06 +0900 Subject: [PATCH 027/604] Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart (#516) * Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart * Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart * Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart * Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart * Fix No module error in GridBasedSweepCPP and ClosedLoopRRTStart --- PathPlanning/ClosedLoopRRTStar/__init__.py | 8 -------- .../closed_loop_rrt_star_car.py | 17 +++++++++++++++-- PathPlanning/GridBasedSweepCPP/__init__.py | 7 ------- .../grid_based_sweep_coverage_path_planner.py | 11 ++++++++++- 4 files changed, 25 insertions(+), 18 deletions(-) delete mode 100644 PathPlanning/ClosedLoopRRTStar/__init__.py delete mode 100644 PathPlanning/GridBasedSweepCPP/__init__.py diff --git a/PathPlanning/ClosedLoopRRTStar/__init__.py b/PathPlanning/ClosedLoopRRTStar/__init__.py deleted file mode 100644 index 0e49cd14d3..0000000000 --- a/PathPlanning/ClosedLoopRRTStar/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -import os -import sys - -sys.path.append(os.path.dirname(os.path.abspath(__file__))) -sys.path.append(os.path.dirname( - os.path.abspath(__file__)) + "/../ReedsSheppPath/") -sys.path.append(os.path.dirname( - os.path.abspath(__file__)) + "/../RRTStarReedsShepp/") diff --git a/PathPlanning/ClosedLoopRRTStar/closed_loop_rrt_star_car.py b/PathPlanning/ClosedLoopRRTStar/closed_loop_rrt_star_car.py index 740fc5590a..c0c8c356e8 100644 --- a/PathPlanning/ClosedLoopRRTStar/closed_loop_rrt_star_car.py +++ b/PathPlanning/ClosedLoopRRTStar/closed_loop_rrt_star_car.py @@ -5,15 +5,28 @@ author: AtsushiSakai(@Atsushi_twi) """ +import os +import sys import matplotlib.pyplot as plt import numpy as np -import reeds_shepp_path_planning -from rrt_star_reeds_shepp import RRTStarReedsShepp + +sys.path.append(os.path.dirname(os.path.abspath(__file__))) import pure_pursuit import unicycle_model +sys.path.append(os.path.dirname( + os.path.abspath(__file__)) + "/../ReedsSheppPath/") +sys.path.append(os.path.dirname( + os.path.abspath(__file__)) + "/../RRTStarReedsShepp/") + +try: + import reeds_shepp_path_planning + from rrt_star_reeds_shepp import RRTStarReedsShepp +except ImportError: + raise + show_animation = True diff --git a/PathPlanning/GridBasedSweepCPP/__init__.py b/PathPlanning/GridBasedSweepCPP/__init__.py deleted file mode 100644 index f1c41ce433..0000000000 --- a/PathPlanning/GridBasedSweepCPP/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -import os -import sys - -GRID_MAP_LIB = os.path.dirname(os.path.abspath(__file__)) + \ - "/../../Mapping/" - -sys.path.append(GRID_MAP_LIB) diff --git a/PathPlanning/GridBasedSweepCPP/grid_based_sweep_coverage_path_planner.py b/PathPlanning/GridBasedSweepCPP/grid_based_sweep_coverage_path_planner.py index 984b0affdf..c0c8fc4319 100644 --- a/PathPlanning/GridBasedSweepCPP/grid_based_sweep_coverage_path_planner.py +++ b/PathPlanning/GridBasedSweepCPP/grid_based_sweep_coverage_path_planner.py @@ -5,13 +5,22 @@ """ import math +import os +import sys from enum import IntEnum import numpy as np from scipy.spatial.transform import Rotation as Rot -from Mapping.grid_map_lib.grid_map_lib import GridMap import matplotlib.pyplot as plt +sys.path.append(os.path.dirname(os.path.abspath(__file__)) + + "/../../Mapping/") + +try: + from grid_map_lib.grid_map_lib import GridMap +except ImportError: + raise + do_animation = True From 9036e1527028347469a474ccc26f748a3a7bef82 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 22 Jun 2021 07:14:54 +0900 Subject: [PATCH 028/604] Bump scipy from 1.6.3 to 1.7.0 (#517) Bumps [scipy](https://github.com/scipy/scipy) from 1.6.3 to 1.7.0. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.6.3...v1.7.0) --- updated-dependencies: - dependency-name: scipy dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index fea1a9562b..e0b9e76a34 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.20.3 -scipy == 1.6.3 +scipy == 1.7.0 pandas == 1.2.4 matplotlib == 3.4.2 cvxpy == 1.1.13 From ad366d2ec6c555bba722e1a16ed32203b16c58bd Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 29 Jun 2021 07:26:28 +0900 Subject: [PATCH 029/604] Bump numpy from 1.20.3 to 1.21.0 (#519) Bumps [numpy](https://github.com/numpy/numpy) from 1.20.3 to 1.21.0. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.20.3...v1.21.0) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index e0b9e76a34..d98897d70d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.20.3 +numpy == 1.21.0 scipy == 1.7.0 pandas == 1.2.4 matplotlib == 3.4.2 From 01874cee24e6944015a72e701140b23e5d291d47 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 29 Jun 2021 07:26:50 +0900 Subject: [PATCH 030/604] Bump pandas from 1.2.4 to 1.2.5 (#520) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.2.4 to 1.2.5. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.2.4...v1.2.5) --- updated-dependencies: - dependency-name: pandas dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d98897d70d..70af779df9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.0 scipy == 1.7.0 -pandas == 1.2.4 +pandas == 1.2.5 matplotlib == 3.4.2 cvxpy == 1.1.13 From b0df3c7db3c100b0b3c4680305921482bf9ae2b0 Mon Sep 17 00:00:00 2001 From: mbosetti Date: Tue, 29 Jun 2021 18:37:49 -0500 Subject: [PATCH 031/604] fix dijkstra hypot check bug (#522) --- PathPlanning/VoronoiRoadMap/dijkstra_search.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PathPlanning/VoronoiRoadMap/dijkstra_search.py b/PathPlanning/VoronoiRoadMap/dijkstra_search.py index aef07ebbaf..503ccc342e 100644 --- a/PathPlanning/VoronoiRoadMap/dijkstra_search.py +++ b/PathPlanning/VoronoiRoadMap/dijkstra_search.py @@ -136,5 +136,5 @@ def is_same_node_with_xy(node_x, node_y, node_b): @staticmethod def is_same_node(node_a, node_b): dist = np.hypot(node_a.x - node_b.x, - node_b.y - node_b.y) + node_a.y - node_b.y) return dist <= 0.1 From 8f3337e78d0258386d220192caa97763e17a33d6 Mon Sep 17 00:00:00 2001 From: Jonathan Schwartz Date: Thu, 1 Jul 2021 09:46:32 -0500 Subject: [PATCH 032/604] Dubins path bug fix (#521) * Without equals sign, sometimes get points that are in the wrong direction - relative to the points before and after it- when change in x or change in y along path is 0 * Created test script for dubins path generator * Broke == 0 into its own case in dubins planner, also Renaming files to appease CI * Reverting some naming changes * Turns out theres already a test for dubins.. not sure how I missed that * Note to self: run the test cases on your own before throwing them at CI --- .../DubinsPath/dubins_path_planning.py | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/PathPlanning/DubinsPath/dubins_path_planning.py b/PathPlanning/DubinsPath/dubins_path_planning.py index 9c13198aff..64d29e5061 100644 --- a/PathPlanning/DubinsPath/dubins_path_planning.py +++ b/PathPlanning/DubinsPath/dubins_path_planning.py @@ -254,11 +254,13 @@ def generate_local_course(total_length, lengths, mode, max_curvature, ll = 0.0 - for (m, l, i) in zip(mode, lengths, range(len(mode))): - if l > 0.0: - d = step_size + for (m, length, i) in zip(mode, lengths, range(len(mode))): + if length == 0: + continue + elif length > 0.0: + dist = step_size else: - d = -step_size + dist = -step_size # set origin state origin_x, origin_y, origin_yaw = \ @@ -266,22 +268,22 @@ def generate_local_course(total_length, lengths, mode, max_curvature, index -= 1 if i >= 1 and (lengths[i - 1] * lengths[i]) > 0: - pd = - d - ll + pd = - dist - ll else: - pd = d - ll + pd = dist - ll - while abs(pd) <= abs(l): + while abs(pd) <= abs(length): index += 1 path_x, path_y, path_yaw, directions = interpolate( index, pd, m, max_curvature, origin_x, origin_y, origin_yaw, path_x, path_y, path_yaw, directions) - pd += d + pd += dist - ll = l - pd - d # calc remain length + ll = length - pd - dist # calc remain length index += 1 path_x, path_y, path_yaw, directions = interpolate( - index, l, m, max_curvature, origin_x, origin_y, origin_yaw, + index, length, m, max_curvature, origin_x, origin_y, origin_yaw, path_x, path_y, path_yaw, directions) if len(path_x) <= 1: From 51689d62b9c0c2d245f59fd711ff36774d89a833 Mon Sep 17 00:00:00 2001 From: Jonathan Schwartz Date: Fri, 2 Jul 2021 07:53:02 -0500 Subject: [PATCH 033/604] Issue #523 fix (Reeds-Shepp planner handling length=0 case) (#524) * Without equals sign, sometimes get points that are in the wrong direction - relative to the points before and after it- when change in x or change in y along path is 0 * Created test script for dubins path generator * Made len == 0 it's own case, also changed 'l' to 'len' to appease travisCI * More variable renaming to appease CI * Broke == 0 into its own case in dubins planner, also Renaming files to appease CI * Reverting some naming changes * Turns out theres already a test for dubins.. not sure how I missed that * Note to self: run the test cases on your own before throwing them at CI * Added handling of length=0 case in generate_local_course() * Missed reverting 'mode' back to 'm' in one spot * Addressing style issues (line length) --- .../DubinsPath/dubins_path_planning.py | 2 +- .../reeds_shepp_path_planning.py | 19 ++++++++++++------- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/PathPlanning/DubinsPath/dubins_path_planning.py b/PathPlanning/DubinsPath/dubins_path_planning.py index 64d29e5061..a813d79b0d 100644 --- a/PathPlanning/DubinsPath/dubins_path_planning.py +++ b/PathPlanning/DubinsPath/dubins_path_planning.py @@ -255,7 +255,7 @@ def generate_local_course(total_length, lengths, mode, max_curvature, ll = 0.0 for (m, length, i) in zip(mode, lengths, range(len(mode))): - if length == 0: + if length == 0.0: continue elif length > 0.0: dist = step_size diff --git a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py index 7808f2c9f9..0b31e73793 100644 --- a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py +++ b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py @@ -285,8 +285,10 @@ def generate_local_course(total_length, lengths, mode, max_curvature, step_size) ll = 0.0 - for (m, l, i) in zip(mode, lengths, range(len(mode))): - if l > 0.0: + for (m, length, i) in zip(mode, lengths, range(len(mode))): + if length == 0.0: + continue + elif length > 0.0: d = step_size else: d = -step_size @@ -300,17 +302,19 @@ def generate_local_course(total_length, lengths, mode, max_curvature, step_size) else: pd = d - ll - while abs(pd) <= abs(l): + while abs(pd) <= abs(length): ind += 1 px, py, pyaw, directions = interpolate( - ind, pd, m, max_curvature, ox, oy, oyaw, px, py, pyaw, directions) + ind, pd, m, max_curvature, ox, oy, oyaw, + px, py, pyaw, directions) pd += d - ll = l - pd - d # calc remain length + ll = length - pd - d # calc remain length ind += 1 px, py, pyaw, directions = interpolate( - ind, l, m, max_curvature, ox, oy, oyaw, px, py, pyaw, directions) + ind, length, m, max_curvature, ox, oy, oyaw, + px, py, pyaw, directions) # remove unused data while px[-1] == 0.0: @@ -390,7 +394,8 @@ def main(): step_size = 0.1 px, py, pyaw, mode, clen = reeds_shepp_path_planning( - start_x, start_y, start_yaw, end_x, end_y, end_yaw, curvature, step_size) + start_x, start_y, start_yaw, end_x, end_y, end_yaw, + curvature, step_size) if show_animation: # pragma: no cover plt.cla() From 21e748731973fef52a8e4af22d2fb0c53b53e8c1 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 6 Jul 2021 07:06:53 +0900 Subject: [PATCH 034/604] Bump pandas from 1.2.5 to 1.3.0 (#525) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.2.5 to 1.3.0. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.2.5...v1.3.0) --- updated-dependencies: - dependency-name: pandas dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 70af779df9..d393dcec01 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.0 scipy == 1.7.0 -pandas == 1.2.5 +pandas == 1.3.0 matplotlib == 3.4.2 cvxpy == 1.1.13 From 6f06b535b9d614ed0c6f00dab7811d6917b8ffa1 Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Sat, 10 Jul 2021 07:15:10 +0900 Subject: [PATCH 035/604] fix dubins path length bug and clean up codes. (#527) * fix dubins path length bug and clean up codes. * fix line length CI error * fix line length CI error * fix line length CI error * fix line length CI error * fix line length CI error * fix line length CI error * fix line length CI error * fix line length CI error --- .../DubinsPath/dubins_path_planning.py | 164 ++++++++++-------- PathPlanning/RRTDubins/rrt_dubins.py | 9 +- PathPlanning/RRTStarDubins/rrt_star_dubins.py | 15 +- tests/test_dubins_path_planning.py | 30 ++-- 4 files changed, 124 insertions(+), 94 deletions(-) diff --git a/PathPlanning/DubinsPath/dubins_path_planning.py b/PathPlanning/DubinsPath/dubins_path_planning.py index a813d79b0d..f8e6d7b1c1 100644 --- a/PathPlanning/DubinsPath/dubins_path_planning.py +++ b/PathPlanning/DubinsPath/dubins_path_planning.py @@ -14,6 +14,46 @@ show_animation = True +def dubins_path_planning(s_x, s_y, s_yaw, g_x, g_y, g_yaw, curvature, + step_size=0.1): + """ + Dubins path planner + + :param s_x: x position of start point [m] + :param s_y: y position of start point [m] + :param s_yaw: yaw angle of start point [rad] + :param g_x: x position of end point [m] + :param g_y: y position of end point [m] + :param g_yaw: yaw angle of end point [rad] + :param curvature: curvature for curve [1/m] + :param step_size: (optional) step size between two path points [m] + :return: + x_list: x positions of a path + y_list: y positions of a path + yaw_list: yaw angles of a path + modes: mode list of a path + lengths: length of path segments. + """ + + g_x -= s_x + g_y -= s_y + + l_rot = Rot.from_euler('z', s_yaw).as_matrix()[0:2, 0:2] + le_xy = np.stack([g_x, g_y]).T @ l_rot + le_yaw = g_yaw - s_yaw + + lp_x, lp_y, lp_yaw, modes, lengths = dubins_path_planning_from_origin( + le_xy[0], le_xy[1], le_yaw, curvature, step_size) + + rot = Rot.from_euler('z', -s_yaw).as_matrix()[0:2, 0:2] + converted_xy = np.stack([lp_x, lp_y]).T @ rot + x_list = converted_xy[:, 0] + s_x + y_list = converted_xy[:, 1] + s_y + yaw_list = [pi_2_pi(i_yaw + s_yaw) for i_yaw in lp_yaw] + + return x_list, y_list, yaw_list, modes, lengths + + def mod2pi(theta): return theta - 2.0 * math.pi * math.floor(theta / 2.0 / math.pi) @@ -148,14 +188,14 @@ def dubins_path_planning_from_origin(end_x, end_y, end_yaw, curvature, alpha = mod2pi(- theta) beta = mod2pi(end_yaw - theta) - planners = [left_straight_left, right_straight_right, left_straight_right, - right_straight_left, right_left_right, - left_right_left] + planning_funcs = [left_straight_left, right_straight_right, + left_straight_right, right_straight_left, + right_left_right, left_right_left] best_cost = float("inf") bt, bp, bq, best_mode = None, None, None, None - for planner in planners: + for planner in planning_funcs: t, p, q, mode = planner(alpha, beta, d) if t is None: continue @@ -166,10 +206,15 @@ def dubins_path_planning_from_origin(end_x, end_y, end_yaw, curvature, best_cost = cost lengths = [bt, bp, bq] - x_list, y_list, yaw_list, directions = generate_local_course( - sum(lengths), lengths, best_mode, curvature, step_size) + x_list, y_list, yaw_list, directions = generate_local_course(sum(lengths), + lengths, + best_mode, + curvature, + step_size) + + lengths = [length / curvature for length in lengths] - return x_list, y_list, yaw_list, best_mode, best_cost + return x_list, y_list, yaw_list, best_mode, lengths def interpolate(ind, length, mode, max_curvature, origin_x, origin_y, @@ -203,49 +248,15 @@ def interpolate(ind, length, mode, max_curvature, origin_x, origin_y, return path_x, path_y, path_yaw, directions -def dubins_path_planning(s_x, s_y, s_yaw, g_x, g_y, g_yaw, c, step_size=0.1): - """ - Dubins path planner - - input: - s_x x position of start point [m] - s_y y position of start point [m] - s_yaw yaw angle of start point [rad] - g_x x position of end point [m] - g_y y position of end point [m] - g_yaw yaw angle of end point [rad] - c curvature [1/m] - - """ - - g_x = g_x - s_x - g_y = g_y - s_y - - l_rot = Rot.from_euler('z', s_yaw).as_matrix()[0:2, 0:2] - le_xy = np.stack([g_x, g_y]).T @ l_rot - le_yaw = g_yaw - s_yaw - - lp_x, lp_y, lp_yaw, mode, lengths = dubins_path_planning_from_origin( - le_xy[0], le_xy[1], le_yaw, c, step_size) - - rot = Rot.from_euler('z', -s_yaw).as_matrix()[0:2, 0:2] - converted_xy = np.stack([lp_x, lp_y]).T @ rot - x_list = converted_xy[:, 0] + s_x - y_list = converted_xy[:, 1] + s_y - yaw_list = [pi_2_pi(i_yaw + s_yaw) for i_yaw in lp_yaw] - - return x_list, y_list, yaw_list, mode, lengths - - -def generate_local_course(total_length, lengths, mode, max_curvature, +def generate_local_course(total_length, lengths, modes, max_curvature, step_size): n_point = math.trunc(total_length / step_size) + len(lengths) + 4 - path_x = [0.0 for _ in range(n_point)] - path_y = [0.0 for _ in range(n_point)] - path_yaw = [0.0 for _ in range(n_point)] + p_x = [0.0 for _ in range(n_point)] + p_y = [0.0 for _ in range(n_point)] + p_yaw = [0.0 for _ in range(n_point)] directions = [0.0 for _ in range(n_point)] - index = 1 + ind = 1 if lengths[0] > 0.0: directions[0] = 1 @@ -254,7 +265,7 @@ def generate_local_course(total_length, lengths, mode, max_curvature, ll = 0.0 - for (m, length, i) in zip(mode, lengths, range(len(mode))): + for (m, length, i) in zip(modes, lengths, range(len(modes))): if length == 0.0: continue elif length > 0.0: @@ -263,54 +274,57 @@ def generate_local_course(total_length, lengths, mode, max_curvature, dist = -step_size # set origin state - origin_x, origin_y, origin_yaw = \ - path_x[index], path_y[index], path_yaw[index] + origin_x, origin_y, origin_yaw = p_x[ind], p_y[ind], p_yaw[ind] - index -= 1 + ind -= 1 if i >= 1 and (lengths[i - 1] * lengths[i]) > 0: pd = - dist - ll else: pd = dist - ll while abs(pd) <= abs(length): - index += 1 - path_x, path_y, path_yaw, directions = interpolate( - index, pd, m, max_curvature, origin_x, origin_y, origin_yaw, - path_x, path_y, path_yaw, directions) + ind += 1 + p_x, p_y, p_yaw, directions = interpolate(ind, pd, m, + max_curvature, + origin_x, + origin_y, + origin_yaw, + p_x, p_y, + p_yaw, + directions) pd += dist ll = length - pd - dist # calc remain length - index += 1 - path_x, path_y, path_yaw, directions = interpolate( - index, length, m, max_curvature, origin_x, origin_y, origin_yaw, - path_x, path_y, path_yaw, directions) + ind += 1 + p_x, p_y, p_yaw, directions = interpolate(ind, length, m, + max_curvature, + origin_x, origin_y, + origin_yaw, + p_x, p_y, p_yaw, + directions) - if len(path_x) <= 1: + if len(p_x) <= 1: return [], [], [], [] # remove unused data - while len(path_x) >= 1 and path_x[-1] == 0.0: - path_x.pop() - path_y.pop() - path_yaw.pop() + while len(p_x) >= 1 and p_x[-1] == 0.0: + p_x.pop() + p_y.pop() + p_yaw.pop() directions.pop() - return path_x, path_y, path_yaw, directions + return p_x, p_y, p_yaw, directions def plot_arrow(x, y, yaw, length=1.0, width=0.5, fc="r", ec="k"): # pragma: no cover - """ - Plot arrow - """ - if not isinstance(x, float): for (i_x, i_y, i_yaw) in zip(x, y, yaw): plot_arrow(i_x, i_y, i_yaw) else: - plt.arrow(x, y, length * math.cos(yaw), length * math.sin(yaw), - fc=fc, ec=ec, head_width=width, head_length=width) + plt.arrow(x, y, length * math.cos(yaw), length * math.sin(yaw), fc=fc, + ec=ec, head_width=width, head_length=width) plt.plot(x, y) @@ -327,9 +341,13 @@ def main(): curvature = 1.0 - path_x, path_y, path_yaw, mode, path_length = dubins_path_planning( - start_x, start_y, start_yaw, - end_x, end_y, end_yaw, curvature) + path_x, path_y, path_yaw, mode, lengths = dubins_path_planning(start_x, + start_y, + start_yaw, + end_x, + end_y, + end_yaw, + curvature) if show_animation: plt.plot(path_x, path_y, label="final course " + "".join(mode)) diff --git a/PathPlanning/RRTDubins/rrt_dubins.py b/PathPlanning/RRTDubins/rrt_dubins.py index 55cea0bde3..8ab06c7323 100644 --- a/PathPlanning/RRTDubins/rrt_dubins.py +++ b/PathPlanning/RRTDubins/rrt_dubins.py @@ -133,9 +133,10 @@ def plot_start_goal_arrow(self): # pragma: no cover def steer(self, from_node, to_node): - px, py, pyaw, mode, course_length = dubins_path_planning.dubins_path_planning( - from_node.x, from_node.y, from_node.yaw, - to_node.x, to_node.y, to_node.yaw, self.curvature) + px, py, pyaw, mode, course_lengths = \ + dubins_path_planning.dubins_path_planning( + from_node.x, from_node.y, from_node.yaw, + to_node.x, to_node.y, to_node.yaw, self.curvature) if len(px) <= 1: # cannot find a dubins path return None @@ -148,7 +149,7 @@ def steer(self, from_node, to_node): new_node.path_x = px new_node.path_y = py new_node.path_yaw = pyaw - new_node.cost += course_length + new_node.cost += sum([abs(c) for c in course_lengths]) new_node.parent = from_node return new_node diff --git a/PathPlanning/RRTStarDubins/rrt_star_dubins.py b/PathPlanning/RRTStarDubins/rrt_star_dubins.py index 9cfd4e692a..26367eecea 100644 --- a/PathPlanning/RRTStarDubins/rrt_star_dubins.py +++ b/PathPlanning/RRTStarDubins/rrt_star_dubins.py @@ -139,9 +139,10 @@ def plot_start_goal_arrow(self): def steer(self, from_node, to_node): - px, py, pyaw, mode, course_length = dubins_path_planning.dubins_path_planning( - from_node.x, from_node.y, from_node.yaw, - to_node.x, to_node.y, to_node.yaw, self.curvature) + px, py, pyaw, mode, course_lengths = \ + dubins_path_planning.dubins_path_planning( + from_node.x, from_node.y, from_node.yaw, + to_node.x, to_node.y, to_node.yaw, self.curvature) if len(px) <= 1: # cannot find a dubins path return None @@ -154,18 +155,20 @@ def steer(self, from_node, to_node): new_node.path_x = px new_node.path_y = py new_node.path_yaw = pyaw - new_node.cost += course_length + new_node.cost += sum([abs(c) for c in course_lengths]) new_node.parent = from_node return new_node def calc_new_cost(self, from_node, to_node): - _, _, _, _, course_length = dubins_path_planning.dubins_path_planning( + _, _, _, _, course_lengths = dubins_path_planning.dubins_path_planning( from_node.x, from_node.y, from_node.yaw, to_node.x, to_node.y, to_node.yaw, self.curvature) - return from_node.cost + course_length + cost = sum([abs(c) for c in course_lengths]) + + return from_node.cost + cost def get_random_node(self): diff --git a/tests/test_dubins_path_planning.py b/tests/test_dubins_path_planning.py index 99fbd29100..18492ccc59 100644 --- a/tests/test_dubins_path_planning.py +++ b/tests/test_dubins_path_planning.py @@ -1,12 +1,13 @@ -import conftest import numpy as np + +import conftest from PathPlanning.DubinsPath import dubins_path_planning np.random.seed(12345) -def check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, - end_x, end_y, end_yaw): +def check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, + end_y, end_yaw): assert (abs(px[0] - start_x) <= 0.01) assert (abs(py[0] - start_y) <= 0.01) assert (abs(pyaw[0] - start_yaw) <= 0.01) @@ -15,6 +16,12 @@ def check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, assert (abs(pyaw[-1] - end_yaw) <= 0.01) +def check_path_length(px, py, lengths): + path_len = sum( + [np.hypot(dx, dy) for (dx, dy) in zip(np.diff(px), np.diff(py))]) + assert (abs(path_len - sum(lengths)) <= 0.1) + + def test_1(): start_x = 1.0 # [m] start_y = 1.0 # [m] @@ -26,12 +33,12 @@ def test_1(): curvature = 1.0 - px, py, pyaw, mode, clen = dubins_path_planning.dubins_path_planning( + px, py, pyaw, mode, lengths = dubins_path_planning.dubins_path_planning( start_x, start_y, start_yaw, end_x, end_y, end_yaw, curvature) - check_edge_condition(px, py, pyaw, - start_x, start_y, start_yaw, - end_x, end_y, end_yaw) + check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, + end_y, end_yaw) + check_path_length(px, py, lengths) def test_2(): @@ -53,12 +60,13 @@ def test_3(): curvature = 1.0 / (np.random.rand() * 5.0) - px, py, pyaw, mode, clen = dubins_path_planning.dubins_path_planning( + px, py, pyaw, mode, lengths = \ + dubins_path_planning.dubins_path_planning( start_x, start_y, start_yaw, end_x, end_y, end_yaw, curvature) - check_edge_condition(px, py, pyaw, - start_x, start_y, start_yaw, - end_x, end_y, end_yaw) + check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, + end_y, end_yaw) + check_path_length(px, py, lengths) if __name__ == '__main__': From 177f04618c4bbba40bea38cd57d642f7ab9e3725 Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Mon, 12 Jul 2021 21:04:27 +0900 Subject: [PATCH 036/604] fix example run issue and clean up for arm navigation codes. (#528) * clean up arm navigation codes. * add project toml * add pylintrc * add pylintrc * add pylintrc --- ArmNavigation/n_joint_arm_3d/NLinkArm3d.py | 3 ++- .../n_joint_arm_to_point_control.py | 4 ++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/ArmNavigation/n_joint_arm_3d/NLinkArm3d.py b/ArmNavigation/n_joint_arm_3d/NLinkArm3d.py index 3f6c5ddd2a..0cea963168 100644 --- a/ArmNavigation/n_joint_arm_3d/NLinkArm3d.py +++ b/ArmNavigation/n_joint_arm_3d/NLinkArm3d.py @@ -63,7 +63,8 @@ def forward_kinematics(self, plot=False): if plot: self.fig = plt.figure() - self.ax = Axes3D(self.fig) + self.ax = Axes3D(self.fig, auto_add_to_figure=False) + self.fig.add_axes(self.ax) x_list = [] y_list = [] diff --git a/ArmNavigation/n_joint_arm_to_point_control/n_joint_arm_to_point_control.py b/ArmNavigation/n_joint_arm_to_point_control/n_joint_arm_to_point_control.py index b7834ee98b..36093df08d 100644 --- a/ArmNavigation/n_joint_arm_to_point_control/n_joint_arm_to_point_control.py +++ b/ArmNavigation/n_joint_arm_to_point_control/n_joint_arm_to_point_control.py @@ -4,7 +4,11 @@ Author: Daniel Ingram (daniel-s-ingram) Atsushi Sakai (@Atsushi_twi) """ + import numpy as np +import sys +from pathlib import Path +sys.path.append(str(Path(__file__).parent.parent.parent)) from ArmNavigation.n_joint_arm_to_point_control.NLinkArm import NLinkArm From 2c3896879b91117e8af1016acf25effd310e2def Mon Sep 17 00:00:00 2001 From: Atsushi Sakai Date: Sat, 17 Jul 2021 18:28:26 +0900 Subject: [PATCH 037/604] Fix reeds shepp path issue (#529) * code clean up * code clean up * code clean up * code clean up * fix length handling issues --- .../reeds_shepp_path_planning.py | 292 ++++++++---------- tests/test_reeds_shepp_path_planning.py | 27 +- 2 files changed, 146 insertions(+), 173 deletions(-) diff --git a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py index 0b31e73793..5bc04c8ee3 100644 --- a/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py +++ b/PathPlanning/ReedsSheppPath/reeds_shepp_path_planning.py @@ -14,28 +14,29 @@ class Path: + """ + Path data container + """ def __init__(self): + # course segment length (negative value is backward segment) self.lengths = [] + # course segment type char ("S": straight, "L": left, "R": right) self.ctypes = [] - self.L = 0.0 - self.x = [] - self.y = [] - self.yaw = [] - self.directions = [] + self.L = 0.0 # Total lengths of the path + self.x = [] # x positions + self.y = [] # y positions + self.yaw = [] # orientations [rad] + self.directions = [] # directions (1:forward, -1:backward) def plot_arrow(x, y, yaw, length=1.0, width=0.5, fc="r", ec="k"): - """ - Plot arrow - """ - - if not isinstance(x, float): + if isinstance(x, list): for (ix, iy, iyaw) in zip(x, y, yaw): plot_arrow(ix, iy, iyaw) else: - plt.arrow(x, y, length * math.cos(yaw), length * math.sin(yaw), - fc=fc, ec=ec, head_width=width, head_length=width) + plt.arrow(x, y, length * math.cos(yaw), length * math.sin(yaw), fc=fc, + ec=ec, head_width=width, head_length=width) plt.plot(x, y) @@ -68,35 +69,35 @@ def straight_left_straight(x, y, phi): return False, 0.0, 0.0, 0.0 -def set_path(paths, lengths, ctypes): +def set_path(paths, lengths, ctypes, step_size): path = Path() path.ctypes = ctypes path.lengths = lengths + path.L = sum(np.abs(lengths)) # check same path exist - for tpath in paths: - typeissame = (tpath.ctypes == path.ctypes) - if typeissame: - if sum(np.abs(tpath.lengths)) - sum(np.abs(path.lengths)) <= 0.01: - return paths # not insert path - - path.L = sum([abs(i) for i in lengths]) + for i_path in paths: + type_is_same = (i_path.ctypes == path.ctypes) + length_is_close = (sum(np.abs(i_path.lengths)) - path.L) <= step_size + if type_is_same and length_is_close: + return paths # same path found, so do not insert path - # Base.Test.@test path.L >= 0.01 - if path.L >= 0.01: - paths.append(path) + # check path is long enough + if path.L <= step_size: + return paths # too short, so do not insert path + paths.append(path) return paths -def straight_curve_straight(x, y, phi, paths): +def straight_curve_straight(x, y, phi, paths, step_size): flag, t, u, v = straight_left_straight(x, y, phi) if flag: - paths = set_path(paths, [t, u, v], ["S", "L", "S"]) + paths = set_path(paths, [t, u, v], ["S", "L", "S"], step_size) flag, t, u, v = straight_left_straight(x, -y, -phi) if flag: - paths = set_path(paths, [t, u, v], ["S", "R", "S"]) + paths = set_path(paths, [t, u, v], ["S", "R", "S"], step_size) return paths @@ -131,22 +132,22 @@ def left_right_left(x, y, phi): return False, 0.0, 0.0, 0.0 -def curve_curve_curve(x, y, phi, paths): +def curve_curve_curve(x, y, phi, paths, step_size): flag, t, u, v = left_right_left(x, y, phi) if flag: - paths = set_path(paths, [t, u, v], ["L", "R", "L"]) + paths = set_path(paths, [t, u, v], ["L", "R", "L"], step_size) flag, t, u, v = left_right_left(-x, y, -phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["L", "R", "L"]) + paths = set_path(paths, [-t, -u, -v], ["L", "R", "L"], step_size) flag, t, u, v = left_right_left(x, -y, -phi) if flag: - paths = set_path(paths, [t, u, v], ["R", "L", "R"]) + paths = set_path(paths, [t, u, v], ["R", "L", "R"], step_size) flag, t, u, v = left_right_left(-x, -y, phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["R", "L", "R"]) + paths = set_path(paths, [-t, -u, -v], ["R", "L", "R"], step_size) # backwards xb = x * math.cos(phi) + y * math.sin(phi) @@ -154,55 +155,55 @@ def curve_curve_curve(x, y, phi, paths): flag, t, u, v = left_right_left(xb, yb, phi) if flag: - paths = set_path(paths, [v, u, t], ["L", "R", "L"]) + paths = set_path(paths, [v, u, t], ["L", "R", "L"], step_size) flag, t, u, v = left_right_left(-xb, yb, -phi) if flag: - paths = set_path(paths, [-v, -u, -t], ["L", "R", "L"]) + paths = set_path(paths, [-v, -u, -t], ["L", "R", "L"], step_size) flag, t, u, v = left_right_left(xb, -yb, -phi) if flag: - paths = set_path(paths, [v, u, t], ["R", "L", "R"]) + paths = set_path(paths, [v, u, t], ["R", "L", "R"], step_size) flag, t, u, v = left_right_left(-xb, -yb, phi) if flag: - paths = set_path(paths, [-v, -u, -t], ["R", "L", "R"]) + paths = set_path(paths, [-v, -u, -t], ["R", "L", "R"], step_size) return paths -def curve_straight_curve(x, y, phi, paths): +def curve_straight_curve(x, y, phi, paths, step_size): flag, t, u, v = left_straight_left(x, y, phi) if flag: - paths = set_path(paths, [t, u, v], ["L", "S", "L"]) + paths = set_path(paths, [t, u, v], ["L", "S", "L"], step_size) flag, t, u, v = left_straight_left(-x, y, -phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["L", "S", "L"]) + paths = set_path(paths, [-t, -u, -v], ["L", "S", "L"], step_size) flag, t, u, v = left_straight_left(x, -y, -phi) if flag: - paths = set_path(paths, [t, u, v], ["R", "S", "R"]) + paths = set_path(paths, [t, u, v], ["R", "S", "R"], step_size) flag, t, u, v = left_straight_left(-x, -y, phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["R", "S", "R"]) + paths = set_path(paths, [-t, -u, -v], ["R", "S", "R"], step_size) flag, t, u, v = left_straight_right(x, y, phi) if flag: - paths = set_path(paths, [t, u, v], ["L", "S", "R"]) + paths = set_path(paths, [t, u, v], ["L", "S", "R"], step_size) flag, t, u, v = left_straight_right(-x, y, -phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["L", "S", "R"]) + paths = set_path(paths, [-t, -u, -v], ["L", "S", "R"], step_size) flag, t, u, v = left_straight_right(x, -y, -phi) if flag: - paths = set_path(paths, [t, u, v], ["R", "S", "L"]) + paths = set_path(paths, [t, u, v], ["R", "S", "L"], step_size) flag, t, u, v = left_straight_right(-x, -y, phi) if flag: - paths = set_path(paths, [-t, -u, -v], ["R", "S", "L"]) + paths = set_path(paths, [-t, -u, -v], ["R", "S", "L"], step_size) return paths @@ -222,7 +223,7 @@ def left_straight_right(x, y, phi): return False, 0.0, 0.0, 0.0 -def generate_path(q0, q1, max_curvature): +def generate_path(q0, q1, max_curvature, step_size): dx = q1[0] - q0[0] dy = q1[1] - q0[1] dth = q1[2] - q0[2] @@ -232,98 +233,70 @@ def generate_path(q0, q1, max_curvature): y = (-s * dx + c * dy) * max_curvature paths = [] - paths = straight_curve_straight(x, y, dth, paths) - paths = curve_straight_curve(x, y, dth, paths) - paths = curve_curve_curve(x, y, dth, paths) + paths = straight_curve_straight(x, y, dth, paths, step_size) + paths = curve_straight_curve(x, y, dth, paths, step_size) + paths = curve_curve_curve(x, y, dth, paths, step_size) return paths -def interpolate(ind, length, mode, max_curvature, origin_x, origin_y, origin_yaw, path_x, path_y, path_yaw, directions): - if mode == "S": - path_x[ind] = origin_x + length / max_curvature * math.cos(origin_yaw) - path_y[ind] = origin_y + length / max_curvature * math.sin(origin_yaw) - path_yaw[ind] = origin_yaw - else: # curve - ldx = math.sin(length) / max_curvature - ldy = 0.0 - if mode == "L": # left turn - ldy = (1.0 - math.cos(length)) / max_curvature - elif mode == "R": # right turn - ldy = (1.0 - math.cos(length)) / -max_curvature - gdx = math.cos(-origin_yaw) * ldx + math.sin(-origin_yaw) * ldy - gdy = -math.sin(-origin_yaw) * ldx + math.cos(-origin_yaw) * ldy - path_x[ind] = origin_x + gdx - path_y[ind] = origin_y + gdy - - if mode == "L": # left turn - path_yaw[ind] = origin_yaw + length - elif mode == "R": # right turn - path_yaw[ind] = origin_yaw - length +def calc_interpolate_dists_list(lengths, step_size): + interpolate_dists_list = [] + for length in lengths: + d_dist = step_size if length >= 0.0 else -step_size + interp_dists = np.arange(0.0, length, d_dist) + interp_dists = np.append(interp_dists, length) + interpolate_dists_list.append(interp_dists) - if length > 0.0: - directions[ind] = 1 - else: - directions[ind] = -1 + return interpolate_dists_list - return path_x, path_y, path_yaw, directions +def generate_local_course(lengths, modes, max_curvature, step_size): + interpolate_dists_list = calc_interpolate_dists_list(lengths, step_size) -def generate_local_course(total_length, lengths, mode, max_curvature, step_size): - n_point = math.trunc(total_length / step_size) + len(lengths) + 4 + origin_x, origin_y, origin_yaw = 0.0, 0.0, 0.0 - px = [0.0 for _ in range(n_point)] - py = [0.0 for _ in range(n_point)] - pyaw = [0.0 for _ in range(n_point)] - directions = [0.0 for _ in range(n_point)] - ind = 1 + xs, ys, yaws, directions = [], [], [], [] + for (interp_dists, mode, length) in zip(interpolate_dists_list, modes, + lengths): - if lengths[0] > 0.0: - directions[0] = 1 - else: - directions[0] = -1 + for dist in interp_dists: + x, y, yaw, direction = interpolate(dist, length, mode, + max_curvature, origin_x, + origin_y, origin_yaw) + xs.append(x) + ys.append(y) + yaws.append(yaw) + directions.append(direction) + origin_x = xs[-1] + origin_y = ys[-1] + origin_yaw = yaws[-1] - ll = 0.0 + return xs, ys, yaws, directions - for (m, length, i) in zip(mode, lengths, range(len(mode))): - if length == 0.0: - continue - elif length > 0.0: - d = step_size - else: - d = -step_size - # set origin state - ox, oy, oyaw = px[ind], py[ind], pyaw[ind] - - ind -= 1 - if i >= 1 and (lengths[i - 1] * lengths[i]) > 0: - pd = - d - ll - else: - pd = d - ll - - while abs(pd) <= abs(length): - ind += 1 - px, py, pyaw, directions = interpolate( - ind, pd, m, max_curvature, ox, oy, oyaw, - px, py, pyaw, directions) - pd += d - - ll = length - pd - d # calc remain length - - ind += 1 - px, py, pyaw, directions = interpolate( - ind, length, m, max_curvature, ox, oy, oyaw, - px, py, pyaw, directions) - - # remove unused data - while px[-1] == 0.0: - px.pop() - py.pop() - pyaw.pop() - directions.pop() +def interpolate(dist, length, mode, max_curvature, origin_x, origin_y, + origin_yaw): + if mode == "S": + x = origin_x + dist / max_curvature * math.cos(origin_yaw) + y = origin_y + dist / max_curvature * math.sin(origin_yaw) + yaw = origin_yaw + else: # curve + ldx = math.sin(dist) / max_curvature + ldy = 0.0 + yaw = None + if mode == "L": # left turn + ldy = (1.0 - math.cos(dist)) / max_curvature + yaw = origin_yaw + dist + elif mode == "R": # right turn + ldy = (1.0 - math.cos(dist)) / -max_curvature + yaw = origin_yaw - dist + gdx = math.cos(-origin_yaw) * ldx + math.sin(-origin_yaw) * ldy + gdy = -math.sin(-origin_yaw) * ldx + math.cos(-origin_yaw) * ldy + x = origin_x + gdx + y = origin_y + gdy - return px, py, pyaw, directions + return x, y, yaw, 1 if length > 0.0 else -1 def pi_2_pi(angle): @@ -334,17 +307,18 @@ def calc_paths(sx, sy, syaw, gx, gy, gyaw, maxc, step_size): q0 = [sx, sy, syaw] q1 = [gx, gy, gyaw] - paths = generate_path(q0, q1, maxc) + paths = generate_path(q0, q1, maxc, step_size) for path in paths: - x, y, yaw, directions = generate_local_course( - path.L, path.lengths, path.ctypes, maxc, step_size * maxc) + xs, ys, yaws, directions = generate_local_course(path.lengths, + path.ctypes, maxc, + step_size * maxc) # convert global coordinate - path.x = [math.cos(-q0[2]) * ix + math.sin(-q0[2]) - * iy + q0[0] for (ix, iy) in zip(x, y)] - path.y = [-math.sin(-q0[2]) * ix + math.cos(-q0[2]) - * iy + q0[1] for (ix, iy) in zip(x, y)] - path.yaw = [pi_2_pi(iyaw + q0[2]) for iyaw in yaw] + path.x = [math.cos(-q0[2]) * ix + math.sin(-q0[2]) * iy + q0[0] for + (ix, iy) in zip(xs, ys)] + path.y = [-math.sin(-q0[2]) * ix + math.cos(-q0[2]) * iy + q0[1] for + (ix, iy) in zip(xs, ys)] + path.yaw = [pi_2_pi(yaw + q0[2]) for yaw in yaws] path.directions = directions path.lengths = [length / maxc for length in path.lengths] path.L = path.L / maxc @@ -352,54 +326,42 @@ def calc_paths(sx, sy, syaw, gx, gy, gyaw, maxc, step_size): return paths -def reeds_shepp_path_planning(sx, sy, syaw, - gx, gy, gyaw, maxc, step_size=0.2): +def reeds_shepp_path_planning(sx, sy, syaw, gx, gy, gyaw, maxc, step_size=0.2): paths = calc_paths(sx, sy, syaw, gx, gy, gyaw, maxc, step_size) - if not paths: - return None, None, None, None, None - - minL = float("Inf") - best_path_index = -1 - for i, _ in enumerate(paths): - if paths[i].L <= minL: - minL = paths[i].L - best_path_index = i + return None, None, None, None, None # could not generate any path - bpath = paths[best_path_index] + # search minimum cost path + best_path_index = paths.index(min(paths, key=lambda p: abs(p.L))) + b_path = paths[best_path_index] - return bpath.x, bpath.y, bpath.yaw, bpath.ctypes, bpath.lengths + return b_path.x, b_path.y, b_path.yaw, b_path.ctypes, b_path.lengths def main(): print("Reeds Shepp path planner sample start!!") - # start_x = -1.0 # [m] - # start_y = -4.0 # [m] - # start_yaw = np.deg2rad(-20.0) # [rad] - # - # end_x = 5.0 # [m] - # end_y = 5.0 # [m] - # end_yaw = np.deg2rad(25.0) # [rad] - - start_x = 0.0 # [m] - start_y = 0.0 # [m] - start_yaw = np.deg2rad(0.0) # [rad] + start_x = -1.0 # [m] + start_y = -4.0 # [m] + start_yaw = np.deg2rad(-20.0) # [rad] - end_x = 0.0 # [m] - end_y = 0.0 # [m] - end_yaw = np.deg2rad(0.0) # [rad] + end_x = 5.0 # [m] + end_y = 5.0 # [m] + end_yaw = np.deg2rad(25.0) # [rad] - curvature = 1.0 - step_size = 0.1 + curvature = 0.1 + step_size = 0.05 - px, py, pyaw, mode, clen = reeds_shepp_path_planning( - start_x, start_y, start_yaw, end_x, end_y, end_yaw, - curvature, step_size) + xs, ys, yaws, modes, lengths = reeds_shepp_path_planning(start_x, start_y, + start_yaw, end_x, + end_y, end_yaw, + curvature, + step_size) if show_animation: # pragma: no cover plt.cla() - plt.plot(px, py, label="final course " + str(mode)) + plt.plot(xs, ys, label="final course " + str(modes)) + print(f"{lengths=}") # plotting plot_arrow(start_x, start_y, start_yaw) @@ -410,7 +372,7 @@ def main(): plt.axis("equal") plt.show() - if not px: + if not xs: assert False, "No path" diff --git a/tests/test_reeds_shepp_path_planning.py b/tests/test_reeds_shepp_path_planning.py index f1ce82d4c2..34ccfe7730 100644 --- a/tests/test_reeds_shepp_path_planning.py +++ b/tests/test_reeds_shepp_path_planning.py @@ -1,6 +1,7 @@ +import numpy as np + import conftest # Add root path to sys.path from PathPlanning.ReedsSheppPath import reeds_shepp_path_planning as m -import numpy as np def check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, @@ -8,14 +9,21 @@ def check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, assert (abs(px[0] - start_x) <= 0.01) assert (abs(py[0] - start_y) <= 0.01) assert (abs(pyaw[0] - start_yaw) <= 0.01) - print("x", px[-1], end_x) assert (abs(px[-1] - end_x) <= 0.01) - print("y", py[-1], end_y) assert (abs(py[-1] - end_y) <= 0.01) - print("yaw", pyaw[-1], end_yaw) assert (abs(pyaw[-1] - end_yaw) <= 0.01) +def check_path_length(px, py, lengths): + sum_len = sum(abs(length) for length in lengths) + dpx = np.diff(px) + dpy = np.diff(py) + actual_len = sum( + np.hypot(dx, dy) for (dx, dy) in zip(dpx, dpy)) + diff_len = sum_len - actual_len + assert (diff_len <= 0.01) + + def test1(): m.show_animation = False m.main() @@ -23,6 +31,7 @@ def test1(): def test2(): N_TEST = 10 + np.random.seed(1234) for i in range(N_TEST): start_x = (np.random.rand() - 0.5) * 10.0 # [m] @@ -35,11 +44,13 @@ def test2(): curvature = 1.0 / (np.random.rand() * 5.0) - px, py, pyaw, mode, clen = m.reeds_shepp_path_planning( - start_x, start_y, start_yaw, end_x, end_y, end_yaw, curvature) + px, py, pyaw, mode, lengths = m.reeds_shepp_path_planning( + start_x, start_y, start_yaw, + end_x, end_y, end_yaw, curvature) - check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, - end_x, end_y, end_yaw) + check_edge_condition(px, py, pyaw, start_x, start_y, start_yaw, end_x, + end_y, end_yaw) + check_path_length(px, py, lengths) if __name__ == '__main__': From 4df7b7a6a176527e44aaee4ccc16184e02127437 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 20 Jul 2021 07:22:44 +0900 Subject: [PATCH 038/604] Bump numpy from 1.21.0 to 1.21.1 (#531) Bumps [numpy](https://github.com/numpy/numpy) from 1.21.0 to 1.21.1. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.21.0...v1.21.1) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d393dcec01..e98fafb68d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.21.0 +numpy == 1.21.1 scipy == 1.7.0 pandas == 1.3.0 matplotlib == 3.4.2 From d777bea5005eef54e461152f9207cf0fa0e4458b Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 27 Jul 2021 07:21:13 +0900 Subject: [PATCH 039/604] Bump pandas from 1.3.0 to 1.3.1 (#532) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.3.0 to 1.3.1. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.3.0...v1.3.1) --- updated-dependencies: - dependency-name: pandas dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index e98fafb68d..b5f4ad9244 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.1 scipy == 1.7.0 -pandas == 1.3.0 +pandas == 1.3.1 matplotlib == 3.4.2 cvxpy == 1.1.13 From 74ca49b813dd5665c01a134dec3272a149d2e087 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 27 Jul 2021 07:21:43 +0900 Subject: [PATCH 040/604] Bump cvxpy from 1.1.13 to 1.1.14 (#533) Bumps [cvxpy](https://github.com/cvxgrp/cvxpy) from 1.1.13 to 1.1.14. - [Release notes](https://github.com/cvxgrp/cvxpy/releases) - [Changelog](https://github.com/cvxpy/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxgrp/cvxpy/compare/v1.1.13...v1.1.14) --- updated-dependencies: - dependency-name: cvxpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index b5f4ad9244..4cc16fa789 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.21.1 scipy == 1.7.0 pandas == 1.3.1 matplotlib == 3.4.2 -cvxpy == 1.1.13 +cvxpy == 1.1.14 From a942f6e4ed6f7de8be7a0f0a4d1b2236ae89bae6 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 3 Aug 2021 07:20:27 +0900 Subject: [PATCH 041/604] Bump scipy from 1.7.0 to 1.7.1 (#534) Bumps [scipy](https://github.com/scipy/scipy) from 1.7.0 to 1.7.1. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.7.0...v1.7.1) --- updated-dependencies: - dependency-name: scipy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 4cc16fa789..fc636e01ca 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.1 -scipy == 1.7.0 +scipy == 1.7.1 pandas == 1.3.1 matplotlib == 3.4.2 cvxpy == 1.1.14 From 6ee8985004879604d9417eef8604891bd6a4d423 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 17 Aug 2021 07:21:08 +0900 Subject: [PATCH 042/604] Bump cvxpy from 1.1.14 to 1.1.15 (#536) Bumps [cvxpy](https://github.com/cvxgrp/cvxpy) from 1.1.14 to 1.1.15. - [Release notes](https://github.com/cvxgrp/cvxpy/releases) - [Changelog](https://github.com/cvxpy/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxgrp/cvxpy/compare/v1.1.14...v1.1.15) --- updated-dependencies: - dependency-name: cvxpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index fc636e01ca..c195634a32 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.21.1 scipy == 1.7.1 pandas == 1.3.1 matplotlib == 3.4.2 -cvxpy == 1.1.14 +cvxpy == 1.1.15 From d3db011ab5f9a747ffbf8763206d06456a278d39 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 17 Aug 2021 07:21:27 +0900 Subject: [PATCH 043/604] Bump numpy from 1.21.1 to 1.21.2 (#538) Bumps [numpy](https://github.com/numpy/numpy) from 1.21.1 to 1.21.2. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.21.1...v1.21.2) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index c195634a32..2e35c69679 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.21.1 +numpy == 1.21.2 scipy == 1.7.1 pandas == 1.3.1 matplotlib == 3.4.2 From 3b7f88ea95e4f025e05dbe89bb3dc58066f7bdbc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 17 Aug 2021 08:07:06 +0900 Subject: [PATCH 044/604] Bump matplotlib from 3.4.2 to 3.4.3 (#539) Bumps [matplotlib](https://github.com/matplotlib/matplotlib) from 3.4.2 to 3.4.3. - [Release notes](https://github.com/matplotlib/matplotlib/releases) - [Commits](https://github.com/matplotlib/matplotlib/compare/v3.4.2...v3.4.3) --- updated-dependencies: - dependency-name: matplotlib dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 2e35c69679..469e3e96d1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.2 scipy == 1.7.1 pandas == 1.3.1 -matplotlib == 3.4.2 +matplotlib == 3.4.3 cvxpy == 1.1.15 From 4aae5f35c5b63498ba35fe54a3afcab21a8687ff Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 23 Aug 2021 20:42:32 +0900 Subject: [PATCH 045/604] Bump pandas from 1.3.1 to 1.3.2 (#537) --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 469e3e96d1..55d3e523fd 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.2 scipy == 1.7.1 -pandas == 1.3.1 +pandas == 1.3.2 matplotlib == 3.4.3 cvxpy == 1.1.15 From 06b2450591d63901c07d43fea53d1ec5fafb0cd2 Mon Sep 17 00:00:00 2001 From: Trung Kien Date: Sun, 29 Aug 2021 11:49:15 +0700 Subject: [PATCH 046/604] Fix markdown equations syntax (#535) --- ...redictive_speed_and_steering_control.ipynb | 78 +- SLAM/EKFSLAM/ekf_slam.ipynb | 948 ++---------------- 2 files changed, 128 insertions(+), 898 deletions(-) diff --git a/PathTracking/model_predictive_speed_and_steer_control/Model_predictive_speed_and_steering_control.ipynb b/PathTracking/model_predictive_speed_and_steer_control/Model_predictive_speed_and_steering_control.ipynb index 6e3fe45be3..244f63c8c1 100644 --- a/PathTracking/model_predictive_speed_and_steer_control/Model_predictive_speed_and_steering_control.ipynb +++ b/PathTracking/model_predictive_speed_and_steer_control/Model_predictive_speed_and_steering_control.ipynb @@ -2,16 +2,15 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "## Model predictive speed and steering control\n", "\n", "![Model predictive speed and steering control](https://github.com/AtsushiSakai/PythonRoboticsGifs/raw/master/PathTracking/model_predictive_speed_and_steer_control/animation.gif?raw=true)\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "\n", "\n", @@ -26,11 +25,11 @@ "This code uses cvxpy as an optimization modeling tool.\n", "\n", "- [Welcome to CVXPY 1\\.0 — CVXPY 1\\.0\\.6 documentation](http://www.cvxpy.org/)" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### MPC modeling\n", "\n", @@ -46,22 +45,22 @@ "\n", "a: accellation, δ: steering angle\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "The MPC cotroller minimize this cost function for path tracking:\n", "\n", "$$min\\ Q_f(z_{T,ref}-z_{T})^2+Q\\Sigma({z_{t,ref}-z_{t}})^2+R\\Sigma{u_t}^2+R_d\\Sigma({u_{t+1}-u_{t}})^2$$\n", "\n", "z_ref come from target path and speed." - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "subject to:\n", "\n", @@ -89,20 +88,20 @@ "\n", "$$u_{min} < u_t < u_{max}$$\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "This is implemented at \n", "\n", "[PythonRobotics/model\\_predictive\\_speed\\_and\\_steer\\_control\\.py at f51a73f47cb922a12659f8ce2d544c347a2a8156 · AtsushiSakai/PythonRobotics](https://github.com/AtsushiSakai/PythonRobotics/blob/f51a73f47cb922a12659f8ce2d544c347a2a8156/PathTracking/model_predictive_speed_and_steer_control/model_predictive_speed_and_steer_control.py#L247-L301)" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Vehicle model linearization\n", "\n", @@ -120,21 +119,21 @@ "\n", "\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "ODE is\n", "\n", "$$ \\dot{z} =\\frac{\\partial }{\\partial z} z = f(z, u) = A'z+B'u$$\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "where\n", "\n", @@ -168,11 +167,11 @@ "\\end{bmatrix}\n", "\\end{equation*}$\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "$\\begin{equation*}\n", "B' =\n", @@ -196,11 +195,11 @@ "\\end{bmatrix}\n", "\\end{equation*}$\n", "\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "You can get a discrete-time mode with Forward Euler Discretization with sampling time dt.\n", "\n", @@ -210,11 +209,11 @@ "$$z_{k+1}=z_k+(f(\\bar{z},\\bar{u})+A'z_k+B'u_k-A'\\bar{z}-B'\\bar{u})dt$$\n", "\n", "$$z_{k+1}=(I + dtA')z_k+(dtB')u_k + (f(\\bar{z},\\bar{u})-A'\\bar{z}-B'\\bar{u})dt$$\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "So, \n", "\n", @@ -222,7 +221,7 @@ "\n", "where,\n", "\n", - "$\\begin{equation*}\n", + "$$\\begin{equation*}\n", "A = (I + dtA')\\\\\n", "=\n", "\\begin{bmatrix} \n", @@ -231,14 +230,14 @@ "0 & 0 & 1 & 0 \\\\\n", "0 & 0 &\\frac{tan(\\bar{\\delta})}{L}dt & 1 \\\\\n", "\\end{bmatrix}\n", - "\\end{equation*}$" - ] + "\\end{equation*}$$" + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "$\\begin{equation*}\n", + "$$\\begin{equation*}\n", "B = dtB'\\\\\n", "=\n", "\\begin{bmatrix} \n", @@ -247,14 +246,14 @@ "dt & 0 \\\\\n", "0 & \\frac{\\bar{v}}{Lcos^2(\\bar{\\delta})}dt \\\\\n", "\\end{bmatrix}\n", - "\\end{equation*}$" - ] + "\\end{equation*}$$" + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "$\\begin{equation*}\n", + "$$\\begin{equation*}\n", "C = (f(\\bar{z},\\bar{u})-A'\\bar{z}-B'\\bar{u})dt\\\\\n", "= dt(\n", "\\begin{bmatrix} \n", @@ -285,28 +284,29 @@ "0\\\\\n", "-\\frac{\\bar{v}\\bar{\\delta}}{Lcos^2(\\bar{\\delta})}dt\\\\\n", "\\end{bmatrix}\n", - "\\end{equation*}$" - ] + "\\end{equation*}$$" + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "This equation is implemented at \n", "\n", "[PythonRobotics/model\\_predictive\\_speed\\_and\\_steer\\_control\\.py at eb6d1cbe6fc90c7be9210bf153b3a04f177cc138 · AtsushiSakai/PythonRobotics](https://github.com/AtsushiSakai/PythonRobotics/blob/eb6d1cbe6fc90c7be9210bf153b3a04f177cc138/PathTracking/model_predictive_speed_and_steer_control/model_predictive_speed_and_steer_control.py#L80-L102)\n" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "### Reference\n", "\n", "- [Vehicle Dynamics and Control \\| Rajesh Rajamani \\| Springer](http://www.springer.com/us/book/9781461414322)\n", "\n", "- [MPC Course Material \\- MPC Lab @ UC\\-Berkeley](http://www.mpc.berkeley.edu/mpc-course-material)\n" - ] + ], + "metadata": {} } ], "metadata": { @@ -330,4 +330,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/SLAM/EKFSLAM/ekf_slam.ipynb b/SLAM/EKFSLAM/ekf_slam.ipynb index a64c145ad4..f4c9d61436 100644 --- a/SLAM/EKFSLAM/ekf_slam.ipynb +++ b/SLAM/EKFSLAM/ekf_slam.ipynb @@ -2,40 +2,39 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "# EKF SLAM" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 11, - "metadata": {}, + "source": [ + "from IPython.display import Image\n", + "Image(filename=\"animation.png\",width=600)" + ], "outputs": [ { + "output_type": "execute_result", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIwAAANoCAYAAACiJHG1AAAMSGlDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnltSSWiBCEgJvYlSpEsJoUUQkCrYCEkgocSQEETsLssquHYRAXVFV0VcdC2ArBW7sgj2/lAWlZV1sWBD5U0KrOt+773vne+be/+cOec/JXPvnQFAp4YnleaiugDkSQpk8REhrCmpaSxSN0AAHegDHcDk8eVSdlxcNIAyfP+7vLkBraFcdVFy/XP+v4qeQCjnA4DEQZwhkPPzID4IAF7Cl8oKACD6QL317AKpEk+D2EAGE4RYqsRZalyixBlqXKmySYznQLwHADKNx5NlAaDdDPWsQn4W5NG+BbGrRCCWAKBDhjiQL+IJII6EeExe3iwlhnbAIeMLnqy/cWaMcPJ4WSNYXYtKyKFiuTSXN+f/bMf/lrxcxXAMOzhoIllkvLJm2LdbObOilJgGcZ8kIyYWYn2I34kFKnuIUapIEZmktkdN+XIO7BlgQuwq4IVGQWwKcbgkNyZao8/IFIdzIYYrBC0SF3ATNb5LhfKwBA1njWxWfOwwzpRx2BrfBp5MFVdpf1qRk8TW8N8SCbnD/K+LRYkp6pwxaqE4OQZibYiZ8pyEKLUNZlMs4sQM28gU8cr8bSD2E0oiQtT82IxMWXi8xl6WJx+uF1sqEnNjNLiqQJQYqeHZw+ep8jeCuFkoYScN8wjlU6KHaxEIQ8PUtWMdQkmSpl6sS1oQEq/xfSnNjdPY41RhboRSbwWxqbwwQeOLBxbABanmx2OkBXGJ6jzxjGzexDh1PngRiAYcEApYQAFHBpgFsoG4va+pD/5Sz4QDHpCBLCAELhrNsEeKakYCrwmgGPwBkRDIR/xCVLNCUAj1n0a06qsLyFTNFqo8csBjiPNAFMiFvxUqL8lItGTwG9SI/xGdD3PNhUM5908dG2qiNRrFMC9LZ9iSGEYMJUYSw4mOuAkeiPvj0fAaDIc77oP7Dmf7lz3hMaGT8IhwndBFuD1TvET2VT0sMAl0wQjhmpozvqwZt4OsnngIHgD5ITfOxE2ACz4eRmLjQTC2J9RyNJkrq/+a+281fNF1jR3FlYJSRlGCKQ5fe2o7aXuOsCh7+mWH1LlmjPSVMzLzdXzOF50WwHvU15bYUuwAdg47iV3AjmBNgIUdx5qxNuyoEo+sot9Uq2g4WrwqnxzII/5HPJ4mprKTctd6117Xj+q5AmGR8v0IOLOkc2TiLFEBiw3f/EIWV8IfO4bl7urmC4DyO6J+Tb1iqr4PCPPiX7r8EwD4lkFl1l86njUAhx8DwHjzl876JXw8VgFwtIOvkBWqdbjyQgBU+HUyAMbAHFgDB1iPO/AC/iAYhIGJIBYkglQwA3ZZBNezDMwG88BiUArKwSqwHlSBLWAb2AV+AvtBEzgCToKz4BLoANfBXbh6esAz0A/egEEEQUgIHWEgxogFYos4I+6IDxKIhCHRSDySiqQjWYgEUSDzkG+QcmQNUoVsReqQn5HDyEnkAtKJ3EYeIr3IS+QDiqE01AA1Q+3QcagPykaj0ER0OpqF5qPFaAm6Aq1Ea9E9aCN6Er2EXke70GfoAAYwLYyJWWIumA/GwWKxNCwTk2ELsDKsAqvFGrAW+D9fxbqwPuw9TsQZOAt3gSs4Ek/C+Xg+vgBfjlfhu/BG/DR+FX+I9+OfCXSCKcGZ4EfgEqYQsgizCaWECsIOwiHCGfg09RDeEIlEJtGe6A2fxlRiNnEucTlxE3Ev8QSxk9hNHCCRSMYkZ1IAKZbEIxWQSkkbSXtIx0lXSD2kd2QtsgXZnRxOTiNLyEvIFeTd5GPkK+Qn5EGKLsWW4keJpQgocygrKdspLZTLlB7KIFWPak8NoCZSs6mLqZXUBuoZ6j3qKy0tLSstX63JWmKtRVqVWvu0zms91HpP06c50Ti0aTQFbQVtJ+0E7TbtFZ1Ot6MH09PoBfQV9Dr6KfoD+jtthvZYba62QHuhdrV2o/YV7ec6FB1bHbbODJ1inQqdAzqXdfp0Kbp2uhxdnu4C3Wrdw7o3dQf0GHpuerF6eXrL9XbrXdB7qk/St9MP0xfol+hv0z+l383AGNYMDoPP+IaxnXGG0WNANLA34BpkG5Qb/GTQbtBvqG843jDZsMiw2vCoYRcTY9oxucxc5krmfuYN5odRZqPYo4Sjlo1qGHVl1Fuj0UbBRkKjMqO9RteNPhizjMOMc4xXGzcZ3zfBTZxMJpvMNtlscsakb7TBaP/R/NFlo/ePvmOKmjqZxpvONd1m2mY6YGZuFmEmNdtodsqsz5xpHmyebb7O/Jh5rwXDItBCbLHO4rjF7yxDFpuVy6pknWb1W5paRloqLLdatlsOWtlbJVktsdprdd+aau1jnWm9zrrVut/GwmaSzTybeps7thRbH1uR7Qbbc7Zv7eztUuy+s2uye2pvZM+1L7avt7/nQHcIcsh3qHW45kh09HHMcdzk2OGEOnk6iZyqnS47o85ezmLnTc6dYwhjfMdIxtSOuelCc2G7FLrUuzwcyxwbPXbJ2Kaxz8fZjEsbt3rcuXGfXT1dc123u95103eb6LbErcXtpbuTO9+92v2aB90j3GOhR7PHi/HO44XjN4+/5cnwnOT5nWer5ycvby+ZV4NXr7eNd7p3jfdNHwOfOJ/lPud9Cb4hvgt9j/i+9/PyK/Db7/env4t/jv9u/6cT7CcIJ2yf0B1gFcAL2BrQFcgKTA/8IbAryDKIF1Qb9CjYOlgQvCP4CduRnc3ew34e4hoiCzkU8pbjx5nPORGKhUaEloW2h+mHJYVVhT0ItwrPCq8P74/wjJgbcSKSEBkVuTryJteMy+fWcfsnek+cP/F0FC0qIaoq6lG0U7QsumUSOmnipLWT7sXYxkhimmJBLDd2bez9OPu4/LhfJhMnx02unvw43i1+Xvy5BEbCzITdCW8SQxJXJt5NckhSJLUm6yRPS65LfpsSmrImpWvKuCnzp1xKNUkVpzankdKS03akDUwNm7p+as80z2ml025Mt59eNP3CDJMZuTOOztSZyZt5IJ2QnpK+O/0jL5ZXyxvI4GbUZPTzOfwN/GeCYME6Qa8wQLhG+CQzIHNN5tOsgKy1Wb2iIFGFqE/MEVeJX2RHZm/JfpsTm7MzZyg3JXdvHjkvPe+wRF+SIzk9y3xW0axOqbO0VNqV75e/Pr9fFiXbIUfk0+XNBQZww96mcFB8q3hYGFhYXfhudvLsA0V6RZKitjlOc5bNeVIcXvzjXHwuf27rPMt5i+c9nM+ev3UBsiBjQetC64UlC3sWRSzatZi6OGfxr0tcl6xZ8vqblG9aSsxKFpV0fxvxbX2pdqms9OZ3/t9tWYovFS9tX+axbOOyz2WCsovlruUV5R+X85df/N7t+8rvh1Zkrmhf6bVy8yriKsmqG6uDVu9ao7emeE332klrG9ex1pWte71+5voLFeMrtmygblBs6KqMrmzeaLNx1caPVaKq69Uh1XtrTGuW1bzdJNh0ZXPw5oYtZlvKt3z4QfzDra0RWxtr7WorthG3FW57vD15+7kffX6s22Gyo3zHp52SnV274nedrvOuq9ttuntlPVqvqO/dM21Px0+hPzU3uDRs3cvcW74P7FPs+/3n9J9v7I/a33rA50DDQduDNYcYh8oakcY5jf1Noqau5tTmzsMTD7e2+Lcc+mXsLzuPWB6pPmp4dOUx6rGSY0PHi48PnJCe6DuZdbK7dWbr3VNTTl07Pfl0+5moM+fPhp89dY597vj5gPNHLvhdOHzR52LTJa9LjW2ebYd+9fz1ULtXe+Nl78vNHb4dLZ0TOo9dCbpy8mro1bPXuNcuXY+53nkj6catm9Nudt0S3Hp6O/f2izuFdwbvLrpHuFd2X/d+xQPTB7X/cvzX3i6vrqMPQx+2PUp4dLeb3/3sN/lvH3tKHtMfVzyxeFL31P3pkd7w3o7fp/7e80z6bLCv9A+9P2qeOzw/+Gfwn239U/p7XsheDL1c/sr41c7X41+3DsQNPHiT92bwbdk743e73vu8P/ch5cOTwdkfSR8rPzl+avkc9fneUN7QkJQn46m2AhgcaGYmAC93AkBPhXuHDgCoU9XnPJUg6rOpCoH/hNVnQZV4AbAzGICkRQBEwz3KZjhsIabBu3KrnhgMUA+PkaEReaaHu5qLBk88hHdDQ6/MACC1APBJNjQ0uGlo6NN2mOxtAE7kq8+XSiHCs8EPRkrUdlMXfC3/Bt/Mfk3hn2jmAAAACXBIWXMAABYlAAAWJQFJUiTwAAABnmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyI+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4xMTY0PC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjg3MjwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgqYwCqRAAAAHGlET1QAAAACAAAAAAAAAbQAAAAoAAABtAAAAbQAAP4D405cAwAAQABJREFUeAHsnQecE0UDxV9ylePg6L0rNpogKCBNRRFFQQQ7WBEVQVBRERBUUClir4AUlWoDUUEFRRBQmh9SRGkiIL1zHNfyzSzesZt22c0kt0ne/n7HZWp2/vPI3rxMcbjEBV4kQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIk8B8BBw0jaoEESIAESIAESIAESIAESIAESIAESIAESEBPgIaRngZfkwAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJgIYRRUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkbUAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgIEADSMDDgZIgARIgARIgARIgARIgARIgARIgARIgARoGFEDJEACJEACJEACJEACJEACJEACJEACJEACBgI0jAw4GCABEiABEiABEiABEiABEiABEiABEiABEqBhRA2QAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkYCNAwMuBggARIgARIgARIgARIgARIgARIgARIgARIgIYRNUACJEACJEACJEACJEACJEACJEACJEACJGAgQMPIgIMBEiABEiABEiABEiABEiABEiABEiABEiABGkYh0kBmZib++usvrfaSJUsiPj4+RO/EakmABEiABEiABEiABEiABEiABEggdglkZ2fj0KFDGoDatWsjMTExdmEobDkNI4Uw9VWtW7cOdevW1UfxNQmQAAmQAAmQAAmQAAmQAAmQAAmQQAgJrF27FnXq1AnhO8RO1TSMQtTXNIxCBJbVkgAJkAAJkAAJkAAJkAAJkAAJkIAPAjSMfICxEE3DyAK0QIrs2rULlStX1rKuXLkSVapUCaQY85CAVwIZGRlYvny5ltakSRMkJyd7zcdIEgiEAPUUCCXmCYQAtRQIJeYJlAD1FCgp5guEAPUUCCXmCZQA9RQoqcLLt2/fvvwVPjt37kSlSpUK72ai6J1pGIWoM/fu3Yvy5ctrtf/999+oVq1aiN6J1cYCgVOnTmHJkiVaU5s3b46kpKRYaDbbGCIC1FOIwMZgtdRSDHZ6CJtMPYUQbgxWTT3FYKeHsMnUUwjhKqpaP/7es2cPypUrp6jm2K6GhlGI+l8vWBpGIYIcQ9XyIRVDnR2GplJPYYAcI29BLcVIR4epmdRTmEDHyNtQTzHS0WFqJvUUJtBBvI1+/E3DKAiQbkVpGLkBURXUC5aGkSqqsVsPH1Kx2/ehaDn1FAqqsVkntRSb/R6qVlNPoSIbm/VST7HZ76FqNfUUKrLq6tWPv2kYqeNKw0gdS0NNesHSMDKgYcACAT6kLEBjEZ8EqCefaJhgkgC1ZBIYs/slQD35xcNEkwSoJ5PAmN0vAerJLx5bJOrH3zSM1HUJDSN1LA016QVLw8iAhgELBPiQsgCNRXwSoJ58omGCSQLUkklgzO6XAPXkFw8TTRKgnkwCY3a/BKgnv3hskagff9MwUtclNIzUsTTUpBcsDSMDGgYsEOBDygI0FvFJgHryiYYJJglQSyaBMbtfAtSTXzxMNEmAejIJjNn9EqCe/OKxRaJ+/E3DSF2X0DBSx9JQk16wNIwMaBiwQIAPKQvQWMQnAerJJxommCRALZkExux+CVBPfvEw0SQB6skkMGb3S4B68ovHFon68TcNI3VdQsNIHUtDTXrB0jAyoGHAAgE+pCxAYxGfBKgnn2iYYJIAtWQSGLP7JUA9+cXDRJMEqCeTwJjdLwHqyS8eWyTqx980jNR1CQ0jdSwNNekFS8PIgIYBCwT4kLIAjUV8EqCefKJhgkkC1JJJYMzulwD15BcPE00SoJ5MAmN2vwSoJ794bJGoH3/TMFLXJTSM1LE01KQXLA0jAxoGLBDgQ8oCNBbxSYB68omGCSYJUEsmgTG7XwLUk188TDRJgHoyCYzZ/RKgnvzisUWifvxNw0hdl9AwUsfSUJNesDSMDGgYsECADykL0FjEJwHqyScaJpgkQC2ZBMbsfglQT37xMNEkAerJJDBm90uAevKLxxaJ+vE3DSN1XULDSB1LQ016wdIwMqBhwAIBPqQsQGMRnwSoJ59omGCSALVkEhiz+yVAPfnFw0STBKgnk8CY3S8B6skvHlsk6sffNIzUdQkNI3UsDTXpBUvDyICGAQsE+JCyAI1FfBKgnnyiYYJJAtSSSWDM7pcA9eQXDxNNEqCeTAJjdr8EqCe/eGyRqB9/0zBS1yU0jNSxNNSkFywNIwMaBiwQ4EPKAjQW8UmAevKJhgkmCVBLJoExu18C1JNfPEw0SYB6MgmM2f0SoJ784rFFon78TcNIXZfQMFLH0lCTXrA0jAxoGLBAgA8pC9BYxCcB6sknGiaYJEAtmQTG7H4JUE9+8TDRJAHqySQwZvdLgHryi8cWifrxNw0jdV1Cw0gdS0NNesHSMDKgYcACAT6kLEBjEZ8EqCefaJhgkgC1ZBIYs/slQD35xcNEkwSoJ5PAmN0vAerJLx5bJOrH3zSM1HUJDSN1LA016QVLw8iAhgELBPiQsgCNRXwSoJ58omGCSQLUkklgzO6XAPXkFw8TTRKgnkwCY3a/BKgnv3hskagff9MwUtclNIzUsTTUpBcsDSMDGgYsEOBDygI0FvFJgHryiYYJJglQSyaBMbtfAtSTXzxMNEmAejIJjNn9EqCe/OKxRaJ+/E3DSF2X0DBSx9JQk16wNIwMaBiwQIAPKQvQWMQnAerJJxommCRALZkExux+CVBPfvEw0SQB6skkMGb3S4B68ovHFon68TcNI3VdQsNIHUtDTXrB0jAyoGHAAgE+pCxAYxGfBKgnn2iYYJIAtWQSGLP7JUA9+cXDRJMEqCeTwJjdLwHqyS8eWyTqx980jNR1CQ0jdSwNNekFS8PIgIYBCwT4kLIAjUV8EqCefKJhgkkC1JJJYMzulwD15BcPE00SoJ5MAmN2vwSoJ794bJGoH3/TMFLXJTSM1LE01KQXLA0jAxoGLBDgQ8oCNBbxSYB68omGCSYJUEsmgTG7XwLUk188TDRJgHoyCYzZ/RKgnvzisUWifvxNw0hdl9AwUsfSUJNesDSMDGgYsECADykL0FjEJwHqyScaJpgkQC2ZBMbsfglQT37xMNEkAerJJDBm90uAevKLxxaJ+vE3DSN1XULDSB1LQ016wdIwMqBhwAIBPqQsQGMRnwSoJ59omGCSALVkEhiz+yVAPfnFw0STBKgnk8CY3S8B6skvHlsk6sffNIzUdQkNI3UsDTXpBUvDyICGAQsE+JCyAI1FfBKgnnyiYYJJAtSSSWDM7pcA9eQXDxNNEqCeTAJjdr8EqCe/eGyRqB9/0zBS1yU0jNSxNNSkFywNIwMaBiwQ4EPKAjQW8UmAevKJhgkmCVBLJoExu18C1JNfPEw0SYB6MgmM2f0SoJ784rFFon78TcNIXZfQMFLH0lCTXrA0jAxoGLBAgA8pC9BYxCcB6sknGiaYJEAtmQTG7H4JUE9+8TDRJAHqySQwZvdLgHryi8cWifrxNw0jdV1Cw0gdS0NNesHSMDKgYcACAT6kLEBjEZ8EqCefaJhgkgC1ZBIYs/slQD35xcNEkwSoJ5PAmN0vAerJLx5bJOrH3zSM1HUJDSN1LA016QVLw8iAhgELBPiQsgCNRXwSoJ58omGCSQLUkklgzO6XAPXkFw8TTRKgnkwCY3a/BKgnv3hskagff9MwUtclNIzUsTTUpBcsDSMDGgYsEOBDygI0FvFJgHryicYWCS6XC7KPMjIycPLkSe33mjW/49Chg7jwwgsh0/U/8qZlODc31yM+Pj4e3n4SExORnJyMpKQk7bfM43A4TLefWjKNjAX8EKCe/MBhkmkC1JNpZCzghwD15AeOTZL0428aRuo6hYaROpaGmvSCpWFkQMOABQJ8SFmAxiI+CVBPPtEoT5BGztGjR7F//37s27dP+5k/fz5ee+21/Pdq1aqVZgzlpaenp2vGT36GMLxwOp0oWrQoSpQogdTUVBQrVkz7LePyfmSa/ElLS8v/kabTli1bkJKSgjat26BCxQqaCRWGW+ZbRCEBfjZFYacWYpOop0KEH4VvTT3Zv1P1428aRur6i4aROpaGmvSCpWFkQMOABQJ8SFmAxiI+CVBPPtEEnJCZmYmDBw9qBpA0g+RnvvzjZPfu3drPjh07sH37dmzevBnZ2dkB1xsNGaXZVKNGDVSuXBmVKlVCuXLltJ+yZcuiTJkyKF26NEqWLImE+AQUK15MM8tkXl4kwM8makAlAepJJU3WRT3ZXwP68TcNI3X9RcNIHUtDTXrB0jAyoGHAAgE+pCxAYxGfBKgnn2gMCXJm0Lat27Bl6xZs3bpV+1mxYgWWLl1qyMeAWgLt27fHkCFD0KRJE8iZT7xihwA/m2Knr8PRUuopHJRj5z2oJ/v3tX78TcNIXX/RMFLH0lCTXrA0jAxoGLBAgA8pC9BYxCcB6ukMGvkHxbJlv4j9e4ADBw5g48aN2LBhA1auXImdO3eeyWijV6VKldKMFLnnkDRU5O+4uLj813lx8pblTCj5I/dDkv0uZzvJvY4i7XrwwQfx+uuva/sxRdq9834DJ8DPpsBZMWfBBKinghkxR+AEqKfAWRVWTv34m4aRul6gYaSOpaEmvWBpGBnQMGCBAB9SFqCxiE8CsaonuYH0M888g9GjR/tkE8qEChUqoGbNmli/fj2OHDmivZWcTdOtWzdtiVbx4sW1fYPkfkByb6AiRYpov+VraQipuqRhlJWVlb+xtjSTtJ+T4vepMxtt6zfdPn78uLYX0+HDhyF/Dh06lL8vk1x6d+LEibAYUZKVnPkl91l6ov8TqN+gviosrMcGBGL1s8kG6KPyFqinqOzWQmsU9VRo6AN+Y/34m4ZRwNgKzEjDqEBE1jLoBUvDyBpDljpDgA+pMyz4KngCsaInaWL8/vvvWL58OUaNGoV//vkneHheajjvvPNQrVo1VKlSBdIUkj9y357y5ctre/bIvXvkrKCEhAQvpSM7Kk9L0oRq0KCBZhzJvZ3kbC39Rt/yDze5v9OuXbsgl/WpvFq3bo2XXnoJjRo1gjz9jVfkEsjTk2xB8+bNuYF65HalLe6cerJFN0TNTVBP9u9K/fibhpG6/qJhpI6loSa9YGkYGdAwYIEAH1IWoLGITwLRqic58+SXX37BokWLsHDhQixevDjoWS9yZk/Dhg1Rt25d1KpVC9WrV9fMIXn6mYyXJ4ZZOY7eZ+dEWIJVLcly8jm5bds2jBw5EnPmzAm65XImVpcuXXD11VdDmkjSwOMVWQSs6imyWsm7DRcB6ilcpGPjfagn+/ezfvxNw0hdf9EwUsfSUJNesDSMDGgYsECADykL0FjEJ4Fo0ZM8fn7VqlWaMTRv3jzNJJJGjtWrTp06uOaaa3DOOefg7LPPRs0aNVG5SmXum+MHaCi0JGeGTZ8+Hffee6+fdy446cILL0SnTp1wxRVXaBtoJyUlFVyIOQqVQCj0VKgN4psXKgHqqVDxR92bU0/271L9+JuGkbr+omGkjqWhJr1gaRgZ0DBggQAfUhagsYhPApGqJ7nvzpo1azSDaP78+fj666+Rk5Pjs52BJNx66614/vnntdlDsTxTKBBW3vKEQ0vSBJRL2X777Td8+umnmDBhgrdb8Rsn94W67bbb0KHDdWjTprU2M8xvASYWCoFw6KlQGsY3LRQC1FOhYI/aN6We7N+1+vE3DSN1/UXDSB1LQ016wdIwMqBhwAIBPqQsQGMRnwQiRU9yXxx5atnPP/8MaRDNnj0bclaRmSs+Ph5t27ZFy5YttVkmchlZmTJlzFTBvH4IFJaW5Kbb0ujbtGkT5J5JS5cuDXj5oTxFTs48kj9SGxUrVvTTQiaFk0Bh6SmcbeR7hY8A9RQ+1rHwTtST/XtZP/6mYaSuv2gYqWNpqEkvWBpGBjQMWCDAh5QFaCzik4Bd9SRnksjPyyVLluCHH37ArFmzsG/fPp/t8JYg97GRRsDll1+uGUQXXHABN0L2BkpRnF20JE+dk7r57rvv8Mknn5ja4LxNmza48cYb0a5dO20pImeaKRKHhWrsoicLt84iNiRAPdmwUyL4lqgn+3eefvxNw0hdf9EwUsfSUJNesDSMDGgYsECADykL0FjEJwE76Uke175s2TIsWLAAn3/+Of744w+f9+0tQW5KLfcdkvvUtGjRAvXq1aNB5A1UiOLspKW8JubNTPvxxx+1ZYty6aKMC+SS+1idXrrWQdMSzaNAqKnLY0c9qWsdawo3Aeop3MSj+/2oJ/v3r378TcNIXX/RMFLH0lCTXrA0jAxoGLBAgA8pC9BYxCeBwtSTHLhLU0ieYvbNN9/gq6++CngwLxskB/DyBCw5G0QaRPIodbk/Da/CIVCYWgq0xYcPH9b09uWXX+Ljjz9GRkZGQEXPPfdc3HHHHbjuuus080guZeMVWgKRoKfQEmDtKglQTyppsi7qyf4a0I+/aRip6y/bGUbr16/XvmmWxyGvXLlSW56QmJionVojlxjcfvvt2lHGgSKQ9UycOFH7Y1EaN/JIZDnYuOuuu7TBRqD1mM2nFywNI7P0mN+dAB9S7kQYDoZAuPUk9x168cUXMWzYMEu3LU0hOYtI7kN0ySWXcMNiSxRDUyjcWgq2FdIskvsdSaNSmke7d+8OqMratWujW7duuP7661G/fn3NuAyoIDOZIhBpejLVOGYOOwHqKezIo/oNqSf7d69+/E3DSF1/2cow6tixo7apaUHN69evH0aMGIGEhASfWeW32AMGDMDIkSN95nnyySfxwgsvIBTfGuoFS8PIZxcwIUACfEgFCIrZAiIg9bRo0SItb/PmzUMyQ0duRJy3D9GHH34Y0H3lZapVqxbk86B16zZo1qwpypUrl5fE3zYjEMmfTfKEvdWrV2Pu3LmYNm0a1q1bFxDdunXr4t5779X2yqpRo0ZAZZgpMAKRrKfAWshc4SRAPYWTdvS/F/Vk/z7Wj79pGKnrL1sZRhdeeCH+97//accbyxlATZs2RaVKlbRjk1etWoXhw4drJ6LI5j/88MN44403fJIYPXo0+vfvr6XLDS2feOIJVKtWDdu3b9dMJLm3gbxkvscee0x7rfIfvWBpGKkkG5t18SEVm/0eqlZLM0eeDJWZmYlixYppsyxULOvasWOHtumw3Itozpw5kJtYB3JJ8/+GG27A1Vdfrc0iOuussziDIxBwNsgTLZ9NUqt//fWXtkxSzjxavnx5QHTlzOfu3bujQ4cOKF26dEBlmMk3gWjRk+8WMiWcBKincNKO/veinuzfx/rxNw0jdf1lK8NI/tEll5xdeeWVXmf9yH0I5Mam0jyS14oVK3DRRRd50JAGjRxwyG8P5ZG5cuCSlJSUn09OSZd7Enz//feQG6Zu3boVVatWzU9X8UIvWBpGKojGdh18SMV2/6tuvRwQy71Z8q4ZM2aga9euecGAf8tBttyP6Ntvv4WsQ55SFegljSpp1ssBd+PGjVGkSJFAizKfjQhE42eT1PXmzZu1ZWtTpkzBr7/+WiBxOVP5pptuwq233qr93aHCgC3wTaMwQzTqKQq7KWKaRD1FTFdFxI1ST/bvJv34m4aRuv6ylWEUSLPkRqlyxpC8hg4diiFDhmiv9f8MHjw4f68MOWNJ7jfgfq1ZswYNGjTQomX+5557zj1LUGG9YGkYBYWShQUBPqQog0AJrN71GxpWutBvdvkZKj9L8y5p2oz+8OUCy8n8eSaRNOInT56MtWvX5lUT8G9pMskNhXlFPoFY+GzKM48++uijgGYeSbPonnvu0QykZs2aIT4+PvI7OkwtiAU9hQkl30YQoJ4oA5UEqCeVNENTl378TcNIHeOIM4xOnjyZv9+G/IbcfW8MOZg5++yzsWXLFjRp0sTvN4MyXc5Skvn//PNPpUsg9IKlYaROsLFaEx9Ssdrz5tr9+rI38ciSZ/F+qxfRo/F9Xgtv2LABF1xwgTGtfSLQtjheaz4EfZo+bEwTIfm5unHjRm22pjSJfv/9d4883iKKFi2af8pUq1attOVv3vIxLnIJxNJnU55Z+tlnn2HcuHHYtm1bgR1XuXJl9OjRAzfeeCPq1Kmj9O+MAt88AjPEkp4isHsi7papp4jrMlvfMPVk6+7Rbk4//qZhpK6/Is4wOnr0aP4JOXKfowkTJhho7Ny5E1WqVNHinn76aW3fI0MGXUCmy5N75CX33pB/2Km69IKlYaSKauzWw4dU7PZ9oC2XM4saTbsyP7s0jbbP+lvbzDc/UryQ+xfJn/zrP7MoL1xxdhKK7iyiHXV/1VVXQZ4OJY353377LS+L39/yc1Sa+fJUM7kPnTzlklf0EojVzyZ5sMYvv/yCmTNnaubRsWPHCuxkuU+jnHnUuXNnpX9vFPjGEZQhVvUUQV0UUbdKPUVUd9n+Zqkn23cR9ONvGkbq+iviDKP58+dr+wNIBPKkNLmZtf7SL1mbOHEi7rzzTn2y4bVMv/vuu7W4n376Sdts1ZAhiIBesDSMggDJohoBPqQohEAIjF0xDvf/NCA/q/OndOTOSs8Pe7xwM4vw/VHgm0yPbAVF1KtXT9u7RW5aLZf6huLkyYLugemFQ4CfTYDcF1GeCDh16lTI/cGkmVTQJTd5l3+fyD0bud/RGVrU0xkWfBU8AeopeIas4QwB6ukMC7u+0o+/aRip66WIMozkH2Ht27fXNliVCNavX4/zzz/fQGP69Om45ZZbtLh58+ZBfkPu65IbtbZr105Llkfq3nzzzb6yesRLQfq79u3bB3n0rrzkySuqN9X2995Miz4C8iG1cuVKrWFyo3f9Ju7R11q2KBgC41dPQK8lg89U4csE0ptF8jCzmYeAX3LOlCvglfx8k4cUyM9kuR+Rw+EooAST7UZA+hrHjrlw7IQD6SdcSM8Qv4W/mH7ShRPpDvGD/J+MUw5kC3lkZwFZ2UCOKJslXp88lYtde48IkwQoUyoNCfFOcZgEIH6J3y7EOR1aWPwSe/lAfHYBRYu4kJwsfwNFxG/tR8QVSXYgRcSlpgJpxV0oXtyBpAiboHbo0CHMnTtXM4/k3xgFXXLZ5n333aftd9SwYcOYN1v5rCtIMUw3Q4B6MkOLeQsiQD0VRKjw06VJVL16de1GaBip64+IMozk8jM5nVteck+A999/34PE+PHjtT++ZMLixYtx6aWXeuTJi5DpLVu21IIffPBB/myjvHR/v80Mjj755BOUKlXKX3VMIwESIAFlBL7c/RVe+XfSmfrcTaM8syhdjPJ/OwF8eQoIYGKRNL6lyd68eXPtgWzmc/DMzfBVKAlkZTtw+HAiDh5OwiH5czQRR4/Haz8l9+1B/Z3L0ejoT6jlWINjuWlYgVZYntgYiUIAlbL/RcXcfxHnysZnRTviixKt4BSvq5/ajXNO7UCtrB3YE18Gs4s3Q7ZTOD9BXPXSN6HHkWlIcp0S73Ut5hW/BMJ19KgxDjkoFpeNtKQsFE8Wv1OyUSwlC6XSMrWfkmmnUFK8LiF+UotmaeaURyWFFCG/WFq0aBG+/vpr7TTWgm6jWrVq2gmucr+vsmXLFpSd6SRAAiRAAiRAAjoCcsuFLl26aDE0jHRggnwZMYaR3Jxa7oeRk5OjzdaR+2l4M2HeeustPPzw6U1b5f4CF198sU9E8qjcSy4Rf6SKS5Z76KGHfOZ1TzAzUKJh5E6PYRIggVAT8GkaSbOojpjGsVQYRUvFVBHhGfm75J5EcqmZNIlq1KjBmUT+YIUh7fiJOOzdXwR79xXBngNJOCBMoX1HkrD3qPg5mYQTuQn5d5GYcxIdjv2CK9N/QEvHN6gcvyc/LdAXOS4xQ8ghp6CduQ7mFMM4Zz98ndoK2xPK4kh8Kmqd2oVTjgTsTCyLXIfvU8EuOLkFzxx8Be0SZ5+pULzanlUZH8f3xFepLYSJlIWU3FMomnsSieL1huTq2JRcVeRyoGLmXgza/w4uxk9IcqQjHlmnfxzCLBLm0l5XVfye1AIbyzXCrrPPRbGKcShbOgPlymSgdKkMJCYY22K4iRAF5GbZW7du1ZatzZ49W8zqKni/I/n/Te4D1rixMPO4D1iIeobVkgAJkAAJRBMBGkah6c2IMIzkkbbyaFq5zEv+4bRkyRLIZTnernDNMOKSNG/0GRcqApwGGyqy0V2vYXmaXG0mZxMtE7OJtvh3ieTnrJzFedttt6FRo0Y0icIpk/37cWr+YmR/PR/Y+Q/+LtUUE2r3x4ZdCdgoVkIfEzOICrqkKfPQoY/QKW4yijrFurEwXlJZ+7JLY1duTexCNfwdVxMzircXZlK8MIpeFUbRFxCr1UxfB3NSsS+3Ms5N2Giq7N7skvg79zyI81XFHKokbCx6CZbU7YzyNVJRvYoLtWu5UKuGA1Urn14yZ6pyC5kzMzMh90ycMmWKtiF9QfsdlS9fHg888IC2ZL5WrVoW3jGyivBZF1n9Zfe7pZ7s3kORdX/Uk/37i0vSQtNHtjeM5Klncnr2li1btLX933//PS677DKfNMK1h5HPG/gvQb/pFje9LogW0wsiIB9S0iiVl/zmmXsYFUSM6XkERs99Gf3ffBpYINacncyL9f37qaeewoABA8T+McV9Z2KKeQJilgl+Ww189gmw+S+gbDlklq+O3aXr4Z9DqXD8uhKV//wa1V3rPOpeldkE11aYjIy4FI+0vIi43Czccng+7j45Hhcl/poXzd9eCBzPTcTXObfgmKO4mGDnFDOipAnnRErRZGTUPh+Oixugcr1SOKumAzWrO5BwZtKWl9qsR+0X5qCccSSX18sZ0QVdHTp0EEvue4hloVeJPaDE5k9RePFZF4WdWohNop4KEX4UvjX1ZP9O1Y+/uSRNXX/Z2jCSM4quuOIK/P7779o33J9//gU6drzeb+t5SppfPEyMUAJ8SEVoxxXSbcslMMuXL8fYsWMh92craBaD/jb79euHMWPG6KP4OhgChw/BNWsWciaMQ/y+rcHUhH+yK+GP3IZYldAYvxRpgJOOJDTK2IBLT/2MZnHfomScmEFWwJUeXwqH6l2DjItboVjWAaRtWIqEbWvhSCsBR6Uqwlg0LhXLry5BGBTZwnR0+Z+dlp8/kBeJos6yYmrPzs2B5A5rHsl6dW4L/JrcFGvOuRrn1UtFgwscqHO+A+ee7UARsapT1SX/v27YsEGbcfTuu+9qs6n91S2X4/fu3VvbdL527dr+skZcGp91Eddltr5h6snW3RNxN0c92b/LaBiFpo9saxgdPnxY2zcj71s3eVStXB5R0CVnJFWpIv7oFdfTTz+N4cOH+ywi01988UUtfceOHZB7dai69ILlDCNVVGO3Hj6kYrfvzbRcfu68/PLLmDlzZsGb7MpZE1metZcoUQLyWxnum+LJJtCY/ftd2DlrBYrOmIga/8xCvNseQIHWoyxfo5bAFeLE0JatgFpned1cOv+95EyoBWI53I5/gIqVIB6o4qcqUKzY6XLrxQyose8CPy8QR6gdzi9m6oU0n3r0Be68SxyVJo5EE3sS4uPJwLefi+PXhCgdYtFavNhrK0m4MjnZYmac+54/YkZQB3Ea6hVXivJFtT2TjmfE4/CBbLiWr0KRFT+g9J5lYk8jNebWpqyzcFm5WTgeLxiIS85HOlecY9HkXAcurANcWNeJC85zaCe/aRmC+EcuWVuwYIFm9Mr/xwVdchP6+++/XzutsIhKF6ugNw5ROp91IQIbo9VSTzHa8SFqNvUUIrAKq9WPvznDSB1YWxpGx48fx/XXX69tECmbKqdry/00ArnkN3Vnn322toStSZMmkBtb+7rkhtjyW3iZ/88//1S6T4desDSMfPUA4wMlwIdUoKRiM58cYMrZmAFd54vBeAsxED+nCFodqY+1b/8GuUmg/vrxxx/RunVrfRRf6wnIM+S3bQNWLEfusiXIWfQjXBknsKTCffj+aAPcKvbqqZO4Vl/C1Gu5ZCrVKWbzBHOlpAHd7gduuhmoUDGYmnyXzc7GqX934Xehv8ziabhInEqaJI6Vh4jDrp3An2K/oVlTxAl8GafriBcnq2lG0d2nDSj3miVXaVjFxZ1JkeFdor61vwvjSKyplEuxLryw4DZlCeNJml5is2ns3IHMoxnIWrwMKWu+1QyfM28Q2Cu5F9J78Y8jQ8zqSs1NFxtyn0BR1+kZXZlis+8cRyKc5Soio+3lOL9pSTSs70D5cg7xd0Vg9XvLJb/ImjZtGl5//XX8849oi59Lnqr25JNPolu3bihXrpyfnPZO4rPO3v0TaXdHPUVaj9n7fqkne/ePvDv9+JuGkbr+sp1hlJGRga5du2LOnDlaK+XSCLlEwsw1ePBgDBs2TCvyv//9D/Xr1/covmbNGjRo0ECLl/mfe+45jzzBROgFS8MoGJIsKwnwIUUdeCOwbNky7UAAb2mGOHloVSUxct0uBt/ylLS2xfOTnz+/H+Y8O9uwhwqXpeXjMb44cADZL46A67svkJBd8PIvY+HToW1Z1THbeQuSXSdxQe7vaBz/E5KdOdjjrIl/z+uAnCsuR6krG4rTQOMQ/4GYyfPFDGF8bDptpHir0D3uwkvFzJ17gcsuR8g239G9Z4GfTUePAvPmii2ChFF55VUQm2PpShfCS2n0ffkFsHu3OCFQGFTi5NWsU7lispT4veNfpO3+FYkQs5osXlniVLmFWe3xcdFbsbJCc7Son4BLGgJNGztR+yyHhsFs1VnC/JIm7oQJEzQDSX4x5uuKE2abPCm2Z8+eOP/8831ls218gXqy7Z3zxuxIgHqyY69E7j1RT/bvO/34m4aRuv6ylWEk/yjq3r279geRbKI0caSZY/aSBo08TUTu29G2bVvNfNJvEiz/w8vNI+UG2vKPK7mhdrVq1cy+jd/8esHSMPKLiokBEOBDKgBIMZTlqBiEDx06FK+88or/VpcXJtFlyehzdU98PvhTbZaCnK15/h118OiK06a6rOCNps/ifxNWY9y4ccKoqKqd4NSiRQv/dcdIqpyosmZtLlYuOITO49qijHOv6ZZnChNhblYXTC95OzLrN0Tjeg7UE3vhSAOhRuVcJAjDSKwB9F2vWKYkHlTAxj+A1SuBJQvF12hiBk+WmLmTVga49AqgWXPg4qanl5D5rkl5StR9NgkDCZuEQbfge+DNF4LidTQnGetymmCtsyFWJ9fD4tIt0LxRUbRu6kDTJqLvq5mfgbRLzLaaMWOGNutoq5w95ee64YYb0KdPH+3gEKc07CLgijo9RQDzaL5F6imaezf8baOews/c7Dvqx980jMzS853fVoaRXIcvN2mVV5cuXfL3F/J1+wni6JLq1at7TR49ejT69++vpbVp00abqi1Noe3bt2PEiBHat3UyUeZ77LHHvNYRTKResDSMgiHJspIAH1LUgSSQnp6OSZMmYdCgQR7LyDwIPSj2Wzk7Ce+3ehE9Gt8HuS/cDz/8gE6dOkHukzLgs4F45d9J+cXea/kiyu4orZ1CKfcxitVLTjr5a7MLP/+SiwVLXZi/LgeNj63Fs0efR6PE5aaw7HVVwtqLHkZO5444p3GaOLrd2gwTn28qzQ398i2fGUOXENWfTZs3A0/0Bf5YpQTgwZxiuD9lIuYXb6zVV06srmt/kQMtL3Gg2cUOVKogDN4ArxzR9z/99BPGjx8Pucejv6thw4a49957cffddyMlJcVf1kJPi2o9FTrd2LsB6in2+jyULaaeQklXTd368TcNIzVMZS22MowcJhf7y+nW69ev90pDzi6Sx0OPGjXKa7qMfOKJJzRTKhTfvOkFS8PIZxcwIUACfEgFCCpKs8nZl3JWgTzuvqC9THCL2J+oSVGNRJ5Z5I4lT09f7v7KYBr5yu9ePtrCh48Ai5fmYvF3R7D75804kZmF6lm70DZjPprHzUPxODGTx8R1qkp9JDzaF04xw7WwDR0Tt20pa56WZOHmzZtDP5vXUoV2KySXfy35+fSm3H+LWV5yk+5UYcbK3yni/5mYuZOdfgondhxB0T/mIz6AjbY3ZJ6Pu0q9hz+LGL/wqiMmi13X0oHLxc+F9ZwBryjcJpbZydmBcsN7uay/oEuePFu3bt2CshVKetTrqVCoxu6bUk+x2/ehaDn1FAqqauvUj79pGKljG7WGUR6iRYsWYeLEidqMIjnQksst5Iwj+U1bKJdc6AVLwyivN/jbKgE+pKySi+xycq8SuaG1nC25evVqv415d8Z7eOCfgfl5/Jk/ej1tKLIRvZYMzi+36pbv0LCS2FQ4ii/pAWzeKtguzMX+mT+j4V8zUM+5DFXi/w2o1XuyS2HIBbNQrVV1tKy2BxdmrUKxMmJD5woVTm/GXEaM/GPk0mspKg0jM/14XJzmNncuXFMnw1HArKQTuQm4P3kyvk4TSwm9XEXigOsbOnBVKzEDqbkDZcsUPPtIziKcOnUqRo4cKfZk3+alVmOUPPSjcePTs52MKYUXop4Kj300vjP1FI29Wnhtop4Kj32g76wff9MwCpRawflsZRgVfLuRk0MvWBpGkdNvdr1TPqTs2jOhu69169bh6aefxuzZs32+Sa9evbSZknl7sL2+7E08suTZ/GVovgq662ny7x/i/p8G4LXmQ9Cn6cO+ikV0vNwG6NeVufjuJxe++CkXTXb8iEfTR+GCRHFMvIkr25mEnEmzkdTInjM0TDRFSVZ3LUXdDCOrlOSm2uuFtuTpbj98J06M+82jJrH6Ea/kDsSq5Lo45kzBsbgUbEiqilNxYpag29VIeJGdLnegfVsnzqrpf+8jueT0m2/mYsyYl7Vla25VGYLnnXceVq1ahSJFPN/TkDFMAeopTKBj5G2opxjp6DA1k3oKE+gg3kY//qZhFARIt6I0jNyAqArqBUvDSBXV2K2HD6nY6ft///1XWyr7xhtv+Gy0PDp74MCBOPfccz3yrN71W4EzhLzpKZByHm9m8whxvgEWL8vFl9+6MGOZCyezXbj90Dz0zRiFsxPExsZmrurnidPl2gN3dIc4t9xMyajO601LUd1gK42TO6f36gn8PK/A0jlig/S1WQ0xM+lWfFDyWpyMO728VF/wbLHF2M1tHbj6cifqiM3Tfa3mlzMUf/31VzRt2lRf3OvrKVOmaCfUxsfLIxUL76KeCo99NL4z9RSNvVp4baKeCo99oO+sH3/TMAqUWsH5aBgVzMhSDr1gaRhZQshCOgJ8SOlgROnL48eP4+2339ZOhpQzBLxd7dq108wkuYltMFc06+mk2MJF7kc0W5hEM39xQZyYrl0lsw5j2t4HcXHiksDQxYslZq3aAZeLfYgubUmTyAe1aNaSjyZbi5b/p8eIPRU/fDvg8idz4/B99g3IcBRBcdcRpOIoEpAJB1zaj/z376QG2HJbX7S9JhUX1ve9qfqrr76Kfv36+X3vBg0a4IUXXsDVV18ttmYqnFPVqCe/XcREkwSoJ5PAmN0vAerJLx5bJOrH3zSM1HUJDSN1LA016QVLw8iAhgELBPiQsgAtQopkZ2dj+vTp2tIyeWS2t6tOnTraiY7SMDJ7OIC3+qJNT3Im0Y+LczFrngufrThjEuW1/aITG/DR0TtQIX5/XpTh98nUKkh4uA/iLxJ7Nx04ABQvDtQRS84KebaF4SZtGog2LYUcs9xA6y0xe/CdEcreaklma1xbeRLKJTvQ7UoHbrjGiQvO8z7zSJ6odscdd/h9b7nP4/Dhw9GsWTMlnzd+38wtkXpyA8JgUASop6DwsbAbAerJDYgNg/rxNw0jdR1Ew0gdS0NNesHSMDKgYcACAT6kLECLgCJyucjDDz8Mufmst6tUqVKaUXT77bcjMTHRWxZLcdGgJ3EQJlb+lotPvnThQ7Ev0Ulxwry3664Dc/BSTm8kOf6baqTL5KpyNhx9nwSuEjOJCvl4et1tRdTLaNBSoQBf9BMwYRywTSyNPHkcyDgBZArnU8wesnI95XgF75XpnF/03JJi9eQ1DnRs70TVKp4bZq9Zs0b77JEHg/i6unbtimHDhuGcc87xlUV5PPWkHGlMV0g9xXT3K2889aQcqfIK9eNvGkbq8NIwUsfSUJNesDSMDGgYsECADykL0Gxc5ICYxfLss8/C1z5FccK8GDJEbEDdpw/S0tKUtySS9bRlmwuff5WLiV+7sEOMsd2vKqd249Yj32onlzVwLkHl+D3uWYA0cYrZ8y8Dl12uHYvumYExgRKIZC0F2saw5csQ6ylXCPN42sdiytwc4R2ZM49WZTbB50ldMS2tLfYnlM6/7WZVgds6OHHNVQ6UKmk0j1asWKEtg50rTnfzdskZjY8//rh2UmPZsmW9ZVEaRz0pxRnzlVFPMS8BpQCoJ6U4Q1KZfvxNw0gdYhpG6lgaatILloaRAQ0DFgjwIWUBmg2L5IppMfLYazmrSB6B7e3q0aMHBg0ahLyTz7zlCTYu0vR0SKD6cm4OPpztwgrvq/bQ8MRGjD48EI0Svc/WymdWv5lYEvQ+IGZv8QqeQKRpKfgWh6mG/WL55NfCNNr0F8QRZkCxYuJHLJWUMw2FieMS6Q4/y9oWZF6N+8u9iAMJZ3QudyXq1NCB7jc60KKZM39Sndwc+4cffsCAAQO0TbK9tTAlJQUjRozAvffeG9IT1agnb/QZZ5UA9WSVHMt5I0A9eaNirzj9+JuGkbq+oWGkjqWhJr1gaRgZ0DBggQAfUhag2azIunXrtBlDCxYs8Hpnbdu21QZkjRo18pquMjIS9CSXnK1YnYsPP3FhqjjhLCdvsoUY3HY4+jPuOT4ZtRzrsRhX4X9J9fFc9qNIdvpYl5YH7zZxUtWTT3NvojweCn5HgpYUNNOeVTwtllPO+sjnvW3KOhtXlPsMR+M9ZymWFx5Uz+sc6NrRiSqVT886kob2rFmztP3UNm3yfopgrVq1MGbMGFx33XUh2RibevLZnUywQIB6sgCNRXwSoJ58orFNgn78TcNIXbfQMFLH0lCTXrA0jAxoGLBAgA8pC9BsUuTo0aMYNWqUtoms/Cbf/SpTpgzefPNN7UjrcJ1MZGc9HTokNq6ek4t3P3Vhk24SlsOVi/sOzkafzJdQJf5fd4z+w844YLjYaPj6jv7zMdU0ATtryXRjIq1AjjBI3xa6nvAWcCrd692vy6yLKyvMwMm4ol7TZeSVYouiu7o40baNU5vAlCGWxn3wwQeacXTihJd1n6KM3Bh75MiRaNKkic96rSRQT1aosYwvAtSTLzKMt0KAerJCLbxl9ONvGkbq2NMwUsfSUJNesDSMDGgYsECADykL0Aq5iDSHvvzyS2352T///OP1bvr27avtHyI3tw7nZTc9ydlEv67MxeSZLsz4VcwmcoPR7sgyPHdiMM5J+NMtxUcwWQyO214P1KgJlCghXl8FhGH/FR93E9XRdtNSVMP21bisLGDpEjHb6DNg7iceuQ47yuJQZioSHSexPbc2Fse3wYKiTXEwrhjixf+2RFe29lM6LhtNr6mEG+4pr22UvV8sexs9erRmeMvZR96uu+++G0OeGYLqNap7SzYdRz2ZRsYCfghQT37gMMk0AerJNLKwF9CPv2kYqcNPw0gdS0NNesHSMDKgYcACAT6kLEArxCL//vsvpBk0Y8YMr3dx8cUX46233kLjxo29poc60i56kpMXPheziV6bmmuYTZTX/gtObsGIg8+hReIPeVEF/77pXuDpwUBCQsF5mSNoAnbRUtANiZYKduwAbuoAHNlnqUXSFhrjGozf2/bA/bc50OxiJzZv/ksztqdPn+61TrlJ//PPP49HHnkEcq+jYC7qKRh6LOtOgHpyJ8JwMASop2DohaesfvxNw0gdcxpG6lgaatILloaRAQ0DFgjwIWUBWiEUkbOKpEkkN64+duyYxx0kJyfj9ddfx1133SX8jMIzNApbT//scOGLsbuAT2ajeuZGfJ1yNaaXbJvPKzHnJF7dMwI3J0yA3Kg3oEtsBIxnxMlnN90cUHZmUkOgsLWkphVRVsv27UCX9sAJ3ZpOk018M6c/BlfohdolHOh9qxOdrnXgf7/9jMcee8znxthyfyN58mP79u3FvtzG09gCfXvqKVBSzBcIAeopEErMEygB6ilQUoWXTz/+pmGkrh9oGKljaahJL1gaRgY0DFggwIeUBWhhLrJr1y7tG/ZPPvFcEiJv5Z577sGwYcNQsWLFMN+Z59sVhp7k9k2/rMjF8lGL0WT1W7g4cbHBDLo74UN8UaIV6qRvxoeH70XNhK2eNy5jqp8njKFhwCVNgYULgVHidao4QeopMauoYeg3DPd+U7EbWxhail3aJlq+eTNwy3VA+hEThYxZx2c/jCfL90WOMwFFhHPbo504Ya2rOKlw+aeacbRz505jgf9CXbt21YzxChUqeE33F0k9+aPDNLMEqCezxJjfHwHqyR8de6Tpx980jNT1CQ0jdSwNNekFS8PIgIYBCwT4kLIALUxF5KwiaRLJ46a9zSqqXbs23n//fW2T2DDdUoFvE049ZWYCs7/JxUfjD6DnhqFon/iFz/ublfQQrj31nravikem1JLAgOfExtWdII5n8khmROEQCKeWCqeFEfyuhw8BixYBOdlAitjXS7q2y38BfvwO+FdnyIrZQLnCvnW63HcPA7Zk1UT/1JexoPhF+SBubOTAfbekY9HCdzFw4EBkyT2U3K4SYu+wyZMno0OHDqZmG1FPbiAZDIoA9RQUPhZ2I0A9uQGxYVA//qZhpK6DaBipY2moSS9YGkYGNAxYIMCHlAVoYShy8OBBPProo5g0aZLXd3vyyScxaNAgpKamek0vrMhw6EnuTzTtsxyMnXQUN+2cgntdryAt7qT5JjvjgQf7A3eLvYmKiLPAedmKQDi0ZKsGR8vNSJNHLhsT+w9pv2W7PhWzI595xGsLx2b3wRMVHxVpZ5aataoJ3HbtDrHX9kBMnTrFa7mePXtixIgRSEtL85ruHkk9uRNhOBgC1FMw9FjWnQD15E7EfmH9+JuGkbr+oWGkjqWhJr1gaRgZ0DBggQAfUhaghbjIggUL0L17d3hblnHuuedqx1I3b948xHdhrfpQ6ungIRcmThEziqYfwsN73sctzveR4vScgRDQnZ9VVxwbPg6oUjWg7MwUfgKh1FL4W8N3xBefAwN7CxBiNpLbtSKzKXahGlYkNsbYUtchI+70BtfnlXShXaOFmPLhw/jrr41upYCaNWviww8/xKWXXuqR5h5BPbkTYTgYAtRTMPRY1p0A9eROxH5h/fibhpG6/qFhpI6loSa9YGkYGdAwYIEAH1IWoIWoSHp6OoYOHaodNe3tLeSsosGDB6NoUbEExKZXKPS0c5cL70/OxdvzXLj+0I8YldELpeKOeyWQ6RQzhQaOQGI5ceR97+5e8+DW+4EnBgCJid7TGWsLAqHQki0aFss3sX6dWP75OLBpjU8Kx3MT8WnuPXitZDdsTa6i5SsTfxzV457F/G9f9VpOfi4OGDBATBT0PVOQevKKjpEWCVBPFsGxmFcC1JNXLLaK1I+/aRip6xoaRupYGmrSC5aGkQENAxYI8CFlAVoIiqxevVqbVbR27VqP2qtWrap9i966dWuPNLtFqNTTtr9deG1sLiYvdiExJx1v7BmOLgkf+Wyyq+0NcAwRexGVKnU6z2Kxx8rE8cDvK06Hz75A7K77INDmMp91MME+BFRqyT6t4p0gNxf4QMzue+VZvzBELizOvAI/J7TCiuR6WJhaH46jPyL9r7uRnr7Ho2zDhg21Jbz16tXzSJMR1JNXLIy0SIB6sgiOxbwSoJ68YrFVpH78TcNIXdfQMFLH0lCTXrA0jAxoGLBAgA8pC9AUFpGbur722mt44oknxL6xnks15IbXo0aNQsmSYmPmCLhU6Gn7DhdefS8Xkxa5xIa5wJVHf8UrJ3qjcvxuDwIuse+J4+obgfsfAsRyPV7RQ0CFlqKHRpS1RH7W3ShOWtu4OuCG7c4ug15F38f3ydWR8edjyDzgubeRU2xa/8orr+Chhx5CfLzYo0x3UU86GHwZNAHqKWiErEBHgHrSwbDpS/34m4aRuk6iYaSOpaEmvWBpGBnQMGCBAB9SFqApKrJp0ybtBLSffvrJo0a5kevEiRPRsWNHUycBeVQU5ohg9LRjp5hR9H4uPlh42igqmn0cr+590fesojYdxPKWwWIfotPLVsLcVL5diAkEo6UQ3xqrV0Hgjz+Am9sD2eK4wwCvHJcDozAEI8rehfTdM5H5Vw+xJVK6R+m2bdti3NhxqF6jen4a9ZSPgi8UEKCeFEBkFfkEqKd8FLZ9oR9/0zBS1000jNSxNNSkFywNIwMaBiwQ4HykPnUAAEAASURBVEPKArQgi8iZRFOmTME999yDTHk2vNt13XXX4Z133kHlypXdUuwfNK0n0f7DEz/Hvg++EjMG9uAEiuMY0nBc/G7unIey8Yc9Gx0v9h567hXg+o5nTmHyzMWYCCdgWksR3t6YvP09YmnZmv8B54vlotL43bkTYodr8TMWyMzwieT7zGvQvfwoHM86iONrHxCe0XceeVNSUrTPWWm6y4t68kDEiCAIUE9BwGNRDwLUkwcS20Xox980jNR1Dw0jdSwNNekFS8PIgIYBCwT4kLIALYgiR48eRb9+/bSTztyrkUsopFEkjSS5tCISLzN6OrRsI7J79kDZ7M2BN7VeU+Dl1yHctMDLMGdEEjCjpYhsIG/aN4GTJ4HvhQm0cjmwVMzA3LHJI++hnKKYl9sVqxLrY+6Rjfh9h9wTSS5iNV59+/bF8OHDERcXhyVLlmiJ8pTJpKQkY0aGSMAEAX4+mYDFrAUSoJ4KRFToGfTjbxpG6rqDhpE6loaa9IKlYWRAw4AFAnxIWYBmsYjc2PrWW2/Fxo2ex0PLAcyECRNwzjnnWKzdHsUC0dOJ47lY3WsiLl7+DBIdnvs2eW2JnFU08EWgy00QbprXLIyMLgKBaCm6WszWeCUgN8ke+x7w+jCvyXmRM062R4+dK3E087e8qPzfjRs31kz6/fv3a3E0jPLR8IVFAvx8sgiOxbwSoJ68YrFVpH78TcNIXdfQMFLH0lCTXrA0jAxoGLBAgA8pC9BMFskVA553330XvXv3FgcEeX4DPmzYMPTv31+c8i5MkQi//OlJ7O+NmZ9modqQnmgRPy/wljZrCwwbAVSoEHgZ5ox4Av60FPGNYwPME1gqZgc9fBeQccJn2Z3Z5fHgofr4ct8kjzzy81V+zl5++eW49NJLOcPIgxAjzBDg55MZWsxbEAHqqSBChZ+uH3/TMFLXHzSM1LE01KQXLA0jAxoGLBDgQ8oCNBNF5DfaDz74ID755BOPUpUqVcL06dPRokULj7RIjfCmJ3kg0qJPdqLM4IdwQdx/R9y7NfDPrHOx45I7cUlLJ4q6jgNi6Z52XSrYNGvOvYrceMVC0JuWYqHdbKMfArv/Bfr1FvseLfWZSVryo090xlPbJ4uTJ//7HNHlvvbaazFp0iSULl1aF8uXJGCOAD+fzPFibv8EqCf/fOyQqh9/0zBS1yM0jNSxNNSkFywNIwMaBiwQ4EPKArQAi/z888+4+eabxT6uYiNXt6tz587arKOyZcu6pUR20F1P6/5IxLMjMzBq+TU4J+FPj8bJwd2SGo/g3HH9ULZigkc6I2KXgLuWuOdM7GrB0HLpQG8WexotXCiMo9XAD18BOWL6otu18lQ9DN29H3NOrHRLAerWrYsZM2bg/PPP90hjBAkEQoCfT4FQYp5ACVBPgZIqvHz68TcNI3X9QMNIHUtDTXrB0jAyoGHAAgE+pCxAK6BIdnY2Xn75ZTz11FMeOeVm1m+88QYeeOCBiN3Y2qNRuog8PR04lIjf5ldF6g/z8EDuSJSI8zz6Whbb+8RYlLvzGl0NfEkCpwnkaUmGuOcMVeGTgDTkH+sD/L7Ma5afT5TB0J1r8X22cTmwXKImZ3h26tTJazlGkoA/Avx88keHaWYJUE9miYU/v378TcNIHX8aRupYGmrSC5aGkQENAxYI8CFlAZqfIvL/pzzl7KuvxLfeblft2rUxbdo0NGrUyC0leoJHj2Tg857TUWflLDRK/AW+tqfOhQPOPgOBng9GT+PZEqUE+NmkFGd0VxbAxthzDmegx78Hsdttn/0BA57G0KFDomIPuejuZHu1jp9P9uqPSL8b6sn+Pagff9MwUtdfNIzUsTTUpBcsDSMDGgYsEOBDygI0H0V++eUX3HjjjV6XoEkTacyYMUhLS/NROrKj5SqRBT/mYO8jL+PWnNf8Nsb1+mQ4mjUDUlL85mNibBPgZ1Ns97+l1i//FejbEzi812vxg9kuDNm5H2+eMC5ha37pVfjs08koX76813KMJAF3Avx8cifCcDAEqKdg6IWnrH78TcNIHXMaRupYGmrSC5aGkQENAxYI8CFlAZpbEXny2XvvvYeHH37Y4xS0hIQE7Tjn22+/HQ6Hw61kdAQ3b3Hh6RE5uHTh2+gTJ04z83G50srC8dr7QJOLfeRgNAmcIcDPpjMs+MoEgcxM4NOZwKsvAscPeS247HgGeu04hFW5Z6YbJSZXxLxvPkebNpd4LcNIEtAT4OeTngZfB0uAegqWYOjL68ffNIzU8aZhpI6loSa9YGkYGdAwYIEAH1IWoOmKHBWnefXq1QsfffSRLvb0yzp16mDmzJlRu7HqyZNiTPZeDkZ/4cJTe8ahv/N5DwYZSILzmpuReFNn4KKLIDZu8sjDCBLwRoCfTd6oMC5gAhkZwPSp4kNqOJApPqzcrkwxLXLsviN4dH86hMX03+XEY/3HY+RLd4qPqug0+PNayt/BEeDnU3D8WNpIgHoy8rBjSD/+pmGkrodoGKljaahJL1gaRgY0DFggwIeUBWj/FVm/fj26dOmCDRs2eFRy55134vXXX0fx4sU90qIhYuHiXDz8Yi72HT2Jgfs+QO+4kR7N2nXnMFTqezvE5iAeaYwggYII8LOpIEJMD4jA/v3A4AHAT197zb4zMxtP7jiAjzNy8tPPqf8k5s56DjVr8LMrHwpfGAjw88mAg4EgCVBPQQIMQ3H9+JuGkTrgNIzUsTTUpBcsDSMDGgYsEOBDyjw0l/hmWh7J3K1bN2RlGffCkKegvf322+jRo0dUnoK2d58Lg0fkYvGS3XjqwFjc4JyEVOeZ7+fzaG7seh9qiM1keRR6HhH+NkuAn01miTG/TwLiMzvz23lwDeiDpFMnvGb7/mg6xuw5igyxSq1yvBMbEi7DbS9MR++eJSFWFvMiAQMBfj4ZcDAQJAHqKUiAYSiuH3/TMFIHnIaROpaGmvSCpWFkQMOABQJ8SJmDdlKswxowYABee81zY+eqVavi008/RZMmTcxVGgG55SFEU2bm4gmxBO2OfbMwJPtxFHUazbK8Zmy64U78c8WVPAo9Dwh/WyLAzyZL2FjIBwGpp2ULFqDm7M9RddHXEH+k+sh5OjpHpD+xMxELms7Hey/UxMUXcTmtX2AxlsjPpxjr8BA3l3oKMWAF1evH3zSMFAD9rwoaRupYGmrSC5aGkQENAxYI8CEVOLS/t/2NW2+7FUuXLvUodN1112H8+PEoW7asR1qkR2z804VHnsvB5q0HMHbvk2iT+J3PJmX3G4JFZ9XW0ps3b84ZRj5JMaEgAvxsKogQ080Q0Ovp0grlkfjcM8Aaz89yfZ2nhGnU4s8TWF/3K/Tt0gwD+sUhtag+B1/HKgG9nvisi1UVqGs39aSOZahq0o+/aRipo0zDSB1LQ016wdIwMqBhwAIBPqQCgzZv3jx07doVx44d8yjwwgsvoH///oiPj/dIi+QIudrurXE5eH56Lrod+BpDsx5Hibh0jybJ7+kdLdsD9z+IU3XqYsmSJVoe/hHtgYoRJgjws8kELGYtkICHnuTeanO+BJ59Ajjp+bmeV+G6k5losPUg4mpPQu2zb8E7g51o2YyzjfL4xOpvDz0lJcUqCrZbAQHqSQHEEFehH3/TMFIHm4aROpaGmvSCpWFkQMOABQJ8SPmHlpOTgxEjRmDgwIEeGdPS0vDJJ5+gbdu2HmmRHrFhows9B2Wj3OaVeP7YYJyfuN57kzreAfTuC1SsqKVTT94xMdY8AWrJPDOW8E3Ap57ESZeYMB74aCyQfsRrBa/uOYx+B9IRX2kQUs8ehHvbxOOZx+LEoQZeszMyBgj41FMMtJ1NVE+AelLPVHWN+vE3DSN1dGkYqWNpqEkvWBpGBjQMWCDAh5RvaHI2Uc+ePTF1qjia2e269NJLMWXKFFSrVs0tJbKDclbRtJGbUXTSe7jUMRfl4w94b1BKGjD6baB1G0M69WTAwUAQBKilIOCxqAeBAvUk9zQ6chhISERux3Zw/rs1v45cuDBp/1H03nsCJ9O6oljd91GuaCreedqJK1pztlE+qBh6UaCeYogFmxo8AeopeIahrkE//qZhpI42DSN1LA016QVLw8iAhgELBPiQ8g5N/t/q3LkzVq1a5ZHh0UcfxfDhw5GcnOyRFskRf4i9ioY+/i/e/bO116Vn+W27/Hrg+ReAEiXzo/JeUE95JPg7WALUUrAEWV5PwJSe1q+D66Z2Hhtj78rMxiPbD+BTNERqw88Ql1wRtzd1YNiAOJQQHjqv2CFgSk+xg4UttUiAerIILozF9ONvGkbqwNMwUsfSUJNesDSMDGgYsECADylPaL/++iuuvfZa7N+/35CYIM5W/vjjj9GlSxc4HA5DWiQH5Kyit8fn4Llpufhm5224OPH0HkQebapUCxj0PNCqtdi0yHv7qScPaoywSIBasgiOxbwSMK2nd94C3hTGuNslZxu9vPswnjhcVphGXyM+9VyUE98djB/iRAvubeRGK3qDpvUUvSjYMgUEqCcFEENchX78TcNIHWwaRupYGmrSC5aGkQENAxYI8CFlhPbNN9/g+uuvR3Z2tiGhatWq+PLLL9GgQQNDfEQHxBKMXQv/xNeDfkHCvr9RO3c9mif+5NEkV8nycDzyFND5RiAuziNdH0E96WnwdTAEqKVg6LGsOwHTepJL1CZ+AIx5FsjNca8O68Vm2KP3pGP62d8gsWRzLf2Raxx4qk+cmH3qkZ0RUUbAtJ6irP1sjloC1JNanqGoTT/+pmGkjjANI3UsDTXpBUvDyICGAQsE+JA6A23SpEm46667zkT896p169aYNm0aKlSo4JEWqRGuLVtw5I4HUOLIOp9NyHXEwTl1DlC3ns8ZRe6FqSd3IgxbJUAtWSXHct4IWNbT9u3AgMeB3372Vi0+O3QC3Yu/j4QKnbX080sBH7wUh/PO8T4L02sljIw4Apb1FHEt5Q2HgwD1FA7Kwb2HfvxNwyg4lvrSNIz0NBS+1guWhpFCsDFaFR9S4svj3FyMGjUKTz0lZtG4Xffffz9effVVFClSxC0lcoPpn4hlFEMeQCI8vzXPa5X4bh2OD2cDjS7KiwroN/UUECZmCoAAtRQAJGYJmEBQehLPCHwwHq5XhsKbDbTyRAY6uZ7C8ZrixEiRQ87DfOEuB+7rLkx37okdcB9FUsag9BRJDeW9hoUA9RQWzEG9iX78TcMoKJSGwjSMDDjUBfSCpWGkjmus1hTrDym59Kx///6aKeSugSFDhuCZZ54Rf/BHyV/8YrOiPb2Hofyice5N9Qw/Mhi4/wHP+AJiYl1PBeBhsgkC1JIJWMxaIAElevplGXKf7Avnvn883u/vzCxcdfRm7D1vtPCMTi/dbV1L7A/3QhwqVfBmM3lUwYgIIqBETxHUXt5qaAlQT6Hlq6J2/fibhpEKoqfroGGkjqWhJr1gaRgZ0DBggUAsP6TS09Nx3333YerUqR7k3nvvPfTo0SNqNrfO/Gc3DnS+FxXTf/No66GcothVsT3OvaYa4quIZXf16p9ehuaRs+CIWNZTwXSYwwwBaskMLeYtiIAyPYnZRrmzZyFnYG8kiA2w9ddOcYra1fta4J/6k+Bwnt7IKFV4RxOfceKK1lHyxYO+wTH8WpmeYpghm36GAPV0hoVdX+nH3zSM1PUSDSN1LA016QVLw8iAhgELBGL1IXXw4EHcfPPN+P777w3U5GyiTz/9FJ06dTLER3Jg3+yfkfTkXSjuTPdoxuzc7ij5zhC0bKNml9ZY1ZMHWEYETYBaChohK9ARUK6njRuRftM1SMnO0L0LsCcrB9fuPA+bGn4OR3yx/LR+1zowoG8cxGGbvKKAgHI9RQETNsE6AerJOrtwldSPv2kYqaNOw0gdS0NNesHSMDKgYcACgVh8SMn/Q+3bt8eqVasMxFJSUjB37ly0bNnSEB+xAfFN+NZH30T170bA/bvtUy4nptR6HddP7oTSpdQtl4hFPUWsPmx+49SSzTsowm4vJHravw/Hr2uL1KP7DTSO5uTi8V2lML3uAjgTS+enNakstkIaGYcqldV95uZXzhdhJRASPYW1BXwzOxGgnuzUG97vRT/+pmHknZGVWBpGVqgFUEYvWBpGAQBjFr8EYu0htXPnTrRr1w7r1hlPB5MnoH377beoV0+cCBYFV9bOvdjZtS9qHFno0Zp/sqtgzUOTcU2fc8WSO4/koCJiTU9BwWJhvwSoJb94mGiSQMj0dPgQ0ju1R4qXfY2Wn8jGt4n98UWpztiUXE2746JiidoHA5246nJ3G99kg5i9UAmETE+F2iq+eWERoJ4Ki3zg76sff9MwCpxbQTlpGBVEyGK6XrA0jCxCZLF8ArH0kNq2bRuuvPJKbNq0Kb/98kWdOnXw1VdfoXr16ob4iAuITa3x00JkfDQTyb/O8Xr7Sx3XoNzUMTir3pmlEl4zWoyMJT1ZRMRiARKglgIExWwBEQipno4dQ8ZNHZG8faPPe/lfZkNMTL4PH5W8CtnORPRp78DAfnFITPRZhAk2JhBSPdm43by10BCgnkLDVWWt+vE3DSN1ZGkYqWNpqEkvWBpGBjQMWCAQKw+pv/76C5dddhnkDCP91aRJE8yZMwflypXTR0fea7E0AvfcAWxe6/Xec1wOfFP7WVwx9R4USVE8rUj3jrGiJ12T+TJEBKilEIGN0WpDridxiEJ6v95IWTzXL+Hd2WVwd7FJWJZaF40rAZPHxKEiT1Hzy8yOiSHXkx0bzXsKGQHqKWRolVWsH3/TMFKGFTSM1LE01KQXLA0jAxoGLBCIhYeUXH4mzaJ9+4SportatWqFzz//HKVKldLFRuBLsVeRq9utcPy22OvN78sugfUPTEarvhcpX4Lm/oaxoCf3NjMcGgLUUmi4xmqtYdGTy4VjU6fA8Xx/pDp9G/Mnc+Nwb/LH+CatGUqITbCnv+TExRdxiVokaTMseookILzXoAhQT0HhC0th/fibhpE65DSM1LE01KQXLA0jAxoGLBCI9oeU3Nj68ssvx5EjRwx0rrrqKsycORPFixc3xEdi4NRbY5H09lCPW88VMUtc16HipGE4q0kZj/RQRES7nkLBjHV6J0AteefCWGsEwqmno+Jghfc6dkCNbX/gsuIpKBMvNi5yu7LFrM8xGIzRZW5HjjMZo3s4cNdtcSE39d1ug0GLBMKpJ4u3yGIRRIB6sn9n6cffNIzU9RcNI3UsDTXpBUvDyICGAQsEovkhtXTpUs0sysgwHnvcsWNHfPzxxyhatKgFYvYqsvO7tSj/yNWId7jyb2xPdimMSXgGOW2vxNDhJZAaxmZGs57yAfNFWAhQS2HBHDNvEm49nTx5Evfccw9mTJuGu1Pi0btcGhqkJHnwljNAByW/jBkl26JbMwdGDIlDkWSPbIywGYFw68lmzeftKCZAPSkGGoLq9ONvGkbqANMwUsfSUJNesDSMDGgYsEAgWh9SP/74I+Qsoiy5EbTuuuWWWzBhwgQkJ0f+X+SLvjuOGg9fgarxO/JbKGcVdS3yBW7ofxFuv8kZ9m+ro1VP+YD5ImwEqKWwoY6JNyoMPcnnT58+ffDuu+8iXlD+vFIaOpTw7uC/4Hoeo8p1RwOxnd5Hr8ShSmXfS9piosNs3sjC0JPNkfD2giBAPQUBL0xF9eNvGkbqoNMwUsfSUJNesDSMDGgYsEAgGh9Sc+fORYcOHZCTk2MgIr/tfeedd8SpNJF9LI3YsgiTXtuLhm/fhwsTVxraOMHxOBp83BeNGhTOYCMa9WQAzEDYCFBLYUMdE29UWHrKFR/YTz75JEaPHg35qTyuXFHcUybNK/MPsnvhsQr9USzBgWnDnWh+Cfc18grKBpGFpScbNJ23EAIC1FMIoCquUj/+pmGkDi4NI3UsDTXpBUvDyICGAQsEou0h9cUXX+DGG2+E/CNdf/Xq1Quvvvoq4uPl97yRe504AXx857fosrYPSsUdMzTkL1dDFJ//BcpXLLw2RpueDIAZCCsBaimsuKP+zQpTT/J5NGjQILz44osa57bxTjxbqQSap3rOdP0yswvurvgSXM4EvNHLidu60jSyozgLU0925MF7Co4A9RQcv3CU1o+/aRipI07DSB1LQ016wdIwMqBhwAKBaHpIffjhh+jevbsHhf79++Oll16C0xnZf3jv2XgIf3Z5Bi1zP/NoYwYS4ZyzGIk1K3ukhTMimvQUTm58L08C1JInE8ZYJ1DYepKm0dChQ/H888/nN+Klksl4sqLnKZ1LMluhc4X3cSquCB65xoHBj8UhznPf7Px6+CL8BApbT+FvMd8xlASop1DSVVO3fvxNw0gNU1kLDSN1LA016QVLw8iAhgELBKLlIeVweF+CJf9AHzx4cGSbRbv/xcGR45AydyySHcZldrLLTySURYrYxNtRp44FBagtEi16UkuFtVkhQC1ZocYyvgjYQU8ulwvDhg3DM888k3+bfVMTMapqaXFwgfEZtijzcnSsNB4uhxPXio/2d0fGh/UAg/wb5AuvBOygJ683xsiIJEA92b/b9ONvGkbq+ouGkTqWhpr0gqVhZEDDgAUC0fCQ8mUWjRw5Eo8//rjY+Nn4h7gFTIVTZMsW4L23kTtnGpw4cwqa/mYO1bkGJceOBtK874mhzxuO19Ggp3Bw4nsUTIBaKpgRcwROwC56kqbRiBEjMGDAgPybvzUpDuNrlkMRp/FZ9U5OPzxdoa+Wr04ZYMYbcahU0ZgnvxK+CCsBu+gprI3mm4WMAPUUMrTKKtaPv2kYKcPKGUbqUBpr0guWhpGRDUPmCUT6Q0ruCfH00097NPzNN9/EQw89FLlm0RefwzWot/wg9WibjDieWwSZA19FqduvFfM57TOAiHQ9eYXNyEIhQC0VCvaofVM76UmaRvKkzszMzHzeVyY4MaNWWZRwW3v2fnYfPFPuIW15WilxXsOnL8fhwnr2+czPb0CMvbCTnmIMfVQ2l3qyf7fqx980jNT1F2cYqWNpqEkvWBpGBjQMWCAQyQ+pKVOm4Pbbb/dodZz4gzs7O9sjPmIiNm6E68YrvJpFOS4Hfi16E+p98jRSq4uvnG12RbKebIYy5m+HWop5CSgFYDc9SdPIfV+96xOd+PSs8h7L0zLF5/6KrFb4PrEd5qRdjqHPVsY1V0b2nnxKO7cQKrObngoBAd9SIQHqSSHMEFWlH3/TMFIHmYaROpaGmvSCpWFkQMOABQKR+pCaOXMmbrrpJq8tln+IR+y1fz9yO7WD89BuQxMycuMwI/de7L7+XvR7oQoSEgzJtglEqp5sA5A3kk+AWspHwRcKCNhRT95Mo2fSkvBs5dI+WyzP/xyTOwilB92Pu2/nTtg+QYU4wY56CnGTWX0ICVBPIYSrqGr9+JuGkSKoohoaRupYGmrSC5aGkQENAxYIROJDSi436927t0drX3nlFfTte3q/B4/ESIg4eRLZnTsifvs6w93+mHkl7io3GgPvL4n7usfZaQWa4T5lIBL15NEIRtiCALVki26Impuwq57k6WndunWDnDGbd71RJgUPlUsTe9d5X3omTaPOyV/gkm6N8GSfODFTKa8kf4eLgF31FK72833UEqCe1PIMRW368TcNI3WEaRipY2moSS9YGkYGNAxYIBBpDylfG1i//fbbePDBBy0QsE+RI2PGI238mdNz5J39nlkfV1X6DJOGJOGqy+0/Kog0Pdmn93kn7gSoJXciDAdDwM56kqbRI488AvllSN51aZwTI6uUQrPUJK/Lk//JroTG5RbglpYpGP1snG1nnea1J9p+21lP0cY6FtpDPdm/l/XjbxpG6vqLhpE6loaa9IKlYWRAw4AFApH0kEpNTcWJEyc8Wvnqq69qf2x7JERQxJYFW1Crd0vDHe/PThPHKi/EO2+UQf263r9pNhSwQSCS9GQDXLwFPwSoJT9wmGSagN31JPfd69mzJz744AND2xpUroTvxYmfpZcsguOHLw1pE7MfRL+KT+Hq84Fxo+NRtKghmYEQErC7nkLYdFYdAgLUUwigKq5SP/6mYaQOLg0jdSwNNekFS8PIgIYBCwQi5SHVrl07fPvttx4tvO+++/D+++9H7mlookWbxi5AlTF3IdmZY2jf60VG4IYvbkfVKpFhFsmbjxQ9GUAzYEsC1JItuyVibyoS9CRPTbvzzjsxbdo0A+c6dergh/nzUbZ3T2Dd8vy0k2Jvu5pl1mknqF1UEZj+VhxKl4qc50V+QyLwRSToKQKxxuwtU0/273r9+JuGkbr+omGkjqWhJr1gaRgZ0DBggUAkPKTkcrNevXp5bZ2cyu9rmZrXAjaLXPPKfFww9k5xKo5xo+6juSnI/no5StUsYbM79n87kaAn/y1gql0IUEt26YnouI9I0VNGRgZuvvlmzJ492wC+efPmmDd2LFJvugrQHezQJ+4dfFjqGi1vzeLA7HfiUKUyTSMDvBAEIkVPIWg6qwwBAeopBFAVV6kff9MwUgeXhpE6loaa9IKlYWRAw4AFAnZ/SB0+fBglS5b02rKcnByPY4m9ZrRp5M/Pz8clUz3Nop04GyVnTEBKnVo2vXPft2V3Pfm+c6bYjQC1ZLceiez7iSQ9yaXX119/PRYsWGCA3qFDB8wqLTbDXv5Dfrw8FOGGyuPywxWKAF+/K2YeVadplA8lBC8iSU8haD6rVEyAelIMNATV6cffNIzUAaZhpI6loSa9YGkYGdAwYIGAnR9Scnr+jTfeiDlz5ni0TN53YmKiR3ykRMwftACtPuuOBLeZRb+WuBUXzh2OxGJJkdIUw33aWU+GG2XA9gSoJdt3UUTdYKTp6eDBg2jbti1Wr15t4PzBFZfh7n83GuK+yuyMIaUfxebkqlp8KfFo/FosTzu3Nk0jAyiFgUjTk8Kms6oQEKCeQgBVcZX68TcNI3VwaRipY2moSS9YGkYGNAxYIGDXh5RLTLnv06eP4dSYvOYdOnQIJUpE1lItbQnBpr+AjRuxcsbfqL/iJQ+zaFXF7ppZ5Iy3/2loeX3h/tuuenK/T4btT4Basn8fRdIdRqKedu3ahRYtWmDr1q35qNPEq30XVEJCfsyZFyszL0a/ki/i95SzUSwe+Oq1ONSrQ9PoDCF1ryJRT+paz5pUE6CeVBNVX59+/E3DSB1fGkbqWBpq0guWhpEBDQMWCNj1IfXaa6+hb9++hhbJGUU7duxA2bJlDfEREXjvHeD1YT5vdUOt7jhv1nA4nJFrFsnG2VVPPsEzwbYEqCXbdk1E3lik6mnTpk1o1qwZ9u/fn899cvlUdCstNizych3NSUa7tLn4o0hNJInHyZyXnWjcMLKfK16aWehRkaqnQgfHG/BKgHryisVWkfrxNw0jdV1Dw0gdS0NNesHSMDKgYcACATs+pGbNmoVOnToZWlOsWDGsWLEC55xzjiE+IgLr1sElNir19T3vX+d1R+2ZwyE2ZIqI5vi7STvqyd/9Ms2+BKgl+/ZNJN5ZJOtJLktr2rQp5DJtecknxfCSyXi8cjnE52Zrcfp/dmaXR+syc3EgoZSYyQp8+oITLZtF/vNF38bCfh3Jeipsdnx/TwLUkycTu8Xox980jNT1Dg0jdSwNNekFS8PIgIYBCwTs9pCSppD8NjU7+8wfwU5hpCxcuFCbmm+hiYVbRLTD1fFqOLZt8HofWy7ohlrTX4gKs0g20G568gqdkRFBgFqKiG6KmJuMdD3JDbDlnkZyuXbedW5KESzp9RBKfTMTcDOO1mbWwxUVZiIzrgjihGk0fYgTV7ShaZTHLtjfka6nYNvP8moJUE9qeYaiNv34m4aROsI0jNSxNNSkFywNIwMaBiwQsNNDatu2bWjSpIlh6r1s0tSpU3HLLbdYaF3hF8kdPx7OMc8YbmRdZl1sFyehVejSBg2H3xg1ZpFspJ30ZIDOQMQRoJYirstsfcPRoKdx48ahR48eBs61a9fG0u++Q+nePYHNvxvSlmS2xv/ZOw84KWr2j//u9mhHP/od0hGk995EOkjvKB2R3jsqSEdQuoDSFBCU3os0eZFeleorTQR9QURA4H/1P1nY3OTq7G5md2bnmc9HNk8mySTf/LzMPJNJGmdbggj/JLApZ9aOV5xG1clpJEBy0fAFPbnYdMqmAwHSkw5QJRepfv4mh5E8uOQwksdSKEktWHIYCWjIcIGAUQYptpB19erV8dNP4g3vpEmTMHr0aBda5v0skbduI7xBFSRFBK/ML2H5UTHbLiwflRSN6vnejbtR9MSBU8C0BEhLpu06Q1bcF/TEZhcNHz4cM2bMEBjXrl0bW1csR7K2yqfcD34Xzu0ObYx2wbMR5edvdxqtm+CPGlV9b+wRGu0Bwxf05AFMdAmNBEhPGkF5MZn6+ZscRvI6ghxG8lgKJakFSw4jAQ0ZLhAwwiDF1mVgaxbt3LlTaEG3bt2wePFiZWkf893cRr34P/yvQn1kCYve/jhSaV2zwG3oM6046tQ0X5uEzonHMIKe4qkaRZuMAGnJZB1m8Or6ip7YeNmqVSts2bJFIN6rVy/MHz4Mfi3qAS+eCue+DeuInsEfK3F+9s/TNkz0R7XKvjkGCQ3X0fAVPemIiIp2ggDpyQlYXkqqfv4mh5G8TiCHkTyWQklqwZLDSEBDhgsEvD1IRUZGol+/fliwYIFQe7ZWA7shTpEihRBvBoMtMXGu3miUvLNCqO6a8G7I+uU4n3676209CcDJMDUB0pKpu89wlfclPT169AhVq1bFzz//LHBmu4v2r/UW0K4REP5ygWxHglVh3TAw6wiE+ydDgLKm0QZaCNuBxqVfX9KTSwAok1QCpCepOHUpTP38TQ4jeYjJYSSPpVCSWrDkMBLQkOECAW8PUp9++imGDBki1LxgwYL4z3/+gwwZMgjxZjCYs2j7+9vQ6D/KehKq49ewvLi7cBeq1gxUxfpe0Nt68j2i1m0Racm6fa9Hy31NT9evX0fp0qXBnEfqY9q0aRj+5ptAl+ZAFJvXGn1cDSuAN7NsxHNbSrvTaPNUf1QqTzONoglpD/manrS3nFLqQYD0pAdVuWWqn7/JYSSPLTmM5LEUSlILlhxGAhoyXCDgzUFq48aNaN5cualVHWnTpgXbKS1fvnyqWHMEmbNo+cQbaLP6TQT6h/FKP4+04fy4A6jQJi+P89WAN/Xkq0yt2i7SklV7Xp92+6Kejhw5gmrVqoHN1FUf3bt3xxcd2gN93lWio3dVY2nG+n2C+Rlb25OzmUZbp/ujQllyGtmBOPGPL+rJieZTUskESE+SgepQnPr5mxxG8gCTw0geS6EktWDJYSSgIcMFAt4apC5cuIAyZcogLCzascLWKjp8+DAqVarkQku8nOX//g97Ru5H5V29kFLlLGK1+qndAhQd28TLFfTM5b2lJ8+0jq7iSQKkJU/S9v1r+aqeVq5ciXffZY4h8fjnn3+Q5vAhYPj74gnF6hXwJdakq6UsaeSHpIrTaPccG0oUVQJ0aCbgq3rSDIASSiVAepKKU5fC1M/f5DCSh5gcRvJYCiWpBUsOIwENGS4Q8MYgxXZEY84iNqVefaxduxatW79886mON3z45k2gYeU4q/lb8Q54bfX0OM/5YqQ39OSLHKlNAGmJVCCTgK/qie2cFtfGEGzm0cGDB+E3dRKw8vNYKPeENkLb4Ln23dNS2YB9i2x4PR85jWKBiifCV/UUT3MpWmcCpCedAUsoXv38TQ4jCUBfFUEOI3kshZLUgiWHkYCGDBcIeHqQYlPnO3bsiFWrVgm1nThxIsaMGSPEGd5gjqIN64Aln8VZ1cep8yHNwd1A8uRxnvfFSE/ryRcZUpteEiAtkRJkEvBlPb148SLODSLYZ99Ny5YF6pRXUIqfpjG2n0R+gMlZutsxZ0oGfL/EhhzZyWlkB5LIP76sp0SaTqd1IEB60gGq5CLVz9/kMJIHlxxG8lgKJakFSw4jAQ0ZLhDw9CC1ZMkSsPUV1EfLli2xZs0a2GzKa06zHGu/ASYMU+7BY9+EsyY8D0iHFJu3Ablym6VFUurpaT1JqTQVYkgCpCVDdotpK+Xrevr999+RPXt2oX9SpkyJixcvIueVy8BHynj15KFwPizKD3VT7sbZlAXs8TlSKU6jZTZkykROIwFUHIav6ymOJlOUjgRITzrClVS0+vmbHEaSoCrFkMNIHkuhJLVgyWEkoCHDBQKeHKTYukWlSpVCREQEr2muXLlw+vRpBAUF8ThDB5iD6ItFwOwJCVfz+FUglXL3bbHDk3qyGFrLNZe0ZLku17XBVtDT3r17UadOHYFjzZo1sWvXLiRhsTu2A6P7KoHoFx3Xw3KjeuateBqQ2p6vkLI56falAUiX1m7SP/EQsIKe4mk6RetAgPSkA1TJRaqfv8lhJA8uOYzksRRKUguWHEYCGjJcIOCpQerx48eoUKECLl9W3nS+OvyUBTePHj2K8uXZdHmTHJ/NBL78NM7K3gzLiXtl3kHFpV0t9RmaGoan9KS+JoV9kwBpyTf71VutsoqeRo0ahalTpwqYp0yZgpEjR76Mm618Qr14hnD+v2H50CjjGvyZNJM9voIyUWn94gAEBgrJyFARsIqeVE2moI4ESE86wpVUtPr5mxxGkqAqxZDDSB5LoSS1YMlhJKAhwwUCnhik2KKc7733Hr788kuhhrNmzcKAAQOEOEMbJ08AnZvFquI3YV2wOF17VGr8OiaOCWAbz1j28ISeLAvXYg0nLVmsw3VurlX09Pz5c1SvXh0nT54UiB45cuTlDqRsZ9IWjYBffxbO3wvPhGbp1uFqilz2+DrKV2or5wUgiX1qkpCUDIWAVfREne0ZAqQnz3B25yrq529yGLlDUsxLDiORhzRLLVhyGEnDatmCPDFIsQWu33nnHYFxkyZNsH79enOtW/RuW+DMYaEd4zAVszO1Q5syflgw3absViOctpzhCT1ZDqpFG0xasmjH69RsK+np2rVrKFKkCMKYc+jVkSNHDpw9e/bl59+/3QZaNYy1ptGjiEB0D/wa+9KUsefqVNkPn020WfoliINfzF8r6Slm28mWT4D0JJ+p7BLVz9/kMJJHlxxG8lgKJakFSw4jAQ0ZLhDQe5Bin6AVL15cuHHNmjUrzp8/j8yZM7tQYy9l+Vl5G9umrnDxKVEfY3rmTqj9+ss3sUmTCqctaeitJ0tCtWijSUsW7Xidmm01PX311Vfo1KmTQJO9uGHx7HNw3LsHvNMS+OOmkIYZW0JbYUjmUXiQJAM+bO2HQb1NtCFFrNboE2E1PelDkUp1ECA9OUgY91f9/E0OI3n9RA4jeSyFktSCJYeRgIYMFwjoOUg9e/YMlStXxrlz54SaHTp0CNWqVRPijG5EFc8Nv/BQoZoZM/wXJbMnwaYvAqBsRkOHQkBPPRFgaxEgLVmrv/VurdX0xD4F79ixI1auXCmgZXaHDh1exj36G+iizP69Jo7R7OTTyKQYmHQx1qd/E4sH+qNVU4tPnxUo0lgXAweZbhKw2t8nN3F5Jbv6+ZscRvK6gBxG8lgKJakFSw4jAQ0ZLhDQc5Bi6xPNmTNHqJWw+KZwxrhG1Nat8Bv5vlDBI6E1MKjwCuxWtiBOn97CixYJVOgmOgYOMt0goOffJjeqRVlNSsCKenr48CFKly6Nmzdv8l5Lnjw5rly+gpy5cr6MU9Y8Qp+ewPF9PI0jwJxGeTNeQLgtBTZN8UfViuQ0crCxop4cbadf+QRIT/KZyi5R/fxNDiN5dMlhJI+lUJJasOQwEtCQ4QIBvQap7du3o1EjZWFN1VG3bl1sVZwvScy0iubePYgc2BX+qm2II5U2tU+7EzO+K4rsIeQsUnUxzTBSw6CwWwT0+tvkVqUos2kJWFVPbCfSSpUqCf1Wu3Zt7NixAwEBAS/jI5VR7ds1wLQPgNAXQtp3k67CtrRVkEzxFR1caEPB12nMY4CsqidBHGRII0B6koZSt4LUz9/kMJKHmRxG8lgKJakFSw4jAQ0ZLhDQY5C6e/cuChcujEePHvEaBQUF4cKFCwgJCeFxhg/s+x6R/TsLziJW5yl+k9Dgm04oXpRunGP2oR56inkNsq1BgLRkjX72VCutrKfx48dj3LhxAurZs2ejf//+QhyUGUl4pxVw6wqPXxH+PgZmG2W3MydXnEbLbciWlcY+K+uJi4MC0giQnqSh1K0g9fM3OYzkYSaHkTyWQklqwZLDSEBDhgsEZA9SkcqbymbNmmHLli1CbXbu3Il69eoJcYY2Dh5EZJ93YjmLloX3Rsjno1CnJk3Nj6v/ZOsprmtQnDUIkJas0c+eaqWV9fTixQv7uoEnT57kuP2VLT3ZSxz2ckc4Fn0OzJnIo/6OSIliGY/jaUBqe1zhjMDuFbRun5X1xMVBAWkESE/SUOpWkPr5mxxG8jCTw0geS6EktWDJYSSgIcMFArIHqYULF6JXr15CTQYOHIjPPvtMiDO08ccfiKxTEf4R4iLXq8O64tmYcejeiXaMia//ZOspvutQvO8TIC35fh97soVW19OlS5dQrFgxREREcOwVK1YE24RC+Ez86lWgeU2ehgVWhPdUZhmN5nFNi/thyWc2KD4nyx5W15NlO16nhpOedAIrsVj18zc5jOSBJYeRPJZCSWrBksNIQEOGCwRkDlJx3ZCyt5fHjx9XdhEzyTZiys4yEZ07wXZKXAD0m7Au+LnjOEwcE6BsSewCaItkkakniyCjZsZDgLQUDxiKdokA6QmYN28e+vXrJ/BjG1PEjENfZZOHA1t5uogoPzQM3I7jqaJnI41p6Yehfa378oT0xOVBAQkESE8SIOpchPr5mxxG8mCTw0geS6EktWDJYSSgIcMFArIGqefKTitVqlTBmTNneC3YlPfTp0+jRIkSPM7ogcgVy+E/fYxQza2hLbG21gwsn5tEWSRUOEVGDAKy9BSjWDItSIC0ZMFO17HJpCfYZxfVqlULB5VPrh0HW/j68uXLyJcvnyMKUNYhRN0KQGT0bKT/RWRAuQz78U+SdDzd1yP90aieNacZkZ64DCgggQDpSQJEnYtQP3+Tw0gebHIYyWMplKQWLDmMBDRkuEBA1iA1YcIEfPjhh0IN2Gdo7HM00xzKTXRUnw5QTyD6X3h6dH3jP1i7Kp0yS8o0LfFaRWXpyWsNoAsbhgBpyTBd4RMVIT297MYrV67Y1y1i6w06jjp16oCtM8he8vBj/lxgwVRussCOsBboEPwpjwtQBsv9820oWkg9avLTPh0gPfl093q8caQnjyN3+oLq529yGDmNL94M5DCKF417J9SCJYeReywpt5ytYdmsojJlyiBK+ZzLcbAb0O3bt0dv2+s4YdRfZd2GiBZ1YIsKF2rYJ8VKjNpcA9lDrHdDLIDQaNBNj0ZQlCxRAqSlRBFRAicIkJ6iYc2cORNDhw6NjlBCy5YtQ+fOnaPj2FpHndoDZ/8THaeEOiZZia3pqvK4LCmAw1/ZkCmTtcZI0hOXAAUkECA9SYCocxHq529yGMmDTQ4jeSyFktSCJYeRgIYMFwi4O0ix3VfYwpnnzp3jV0+aNCmuXb2GnLly8jhDBx7cR3j9Wgh49kCo5syosaiyoifKl1W9dRVSkBGTgLt6ilke2dYlQFqybt/r0XLSUzTV0NBQ+7it/oQ8MDAQ165dQ0hISHTCv/4CapUHQp/zuGdIhVqptuFyitw8rnx2YPOSACRLxqN8PkB68vku9mgDSU8exe3SxdTP3+QwcglhnJnIYRQnFvcj1YIlh5H7PK1egruD1OTJkzFmjLjmT6w3lUaG/PgxIlo2ge33a0ItN4W1xePx09GxnXUX9RSAaDTc1ZPGy1AyCxAgLVmgkz3YRNKTCJs5i0qXLi1EtmrVCmvXrlU2dlDNFtqyGRjVW0j3OCotaqfeimspol8Kdanqh5kf2yyzKQTpSZAEGW4SID25CdAD2dXP3+QwkgecHEbyWAolqQVLDiMBDRkuEHBnkLp48aJ9m171Wgj169fHtm3bxLUQXKiXR7IoC3VHdWgNv6vRC3Wz654KLY91bVZjyoTklrn5lcXbHT3JqgOV4xsESEu+0Y9GaQXpKXZPsHUH2fqD6mP9+vVo3rx5dBT71Py9rsCPe6LjlNBfEelRJ902XE+uTC96dSzs7482za0xI5f05Oh1+pVBgPQkg6K+Zaifv8lhJI81OYzksRRKUguWHEYCGjJcIODqIBUeHo6aNWvi8OHD/KrsU7SrylpAuXLl4nGGDvTpCRzcJlTxVthrGFlyO1Z8nQFKc+hwkoCrenLyMpTcAgRISxboZA82kfQUG/a///5rn2XExm3HERQUBLYwdqZMmRxRwLNnQGdlPaOLJ6PjlNCf4RlRN2grbiULtsezRbAPKItgF7HAItikJ0EKZLhJgPTkJkAPZFc/f5PDSB5wchjJYymUpBYsOYwENGS4QMDVQWrRokV4//33hSt+/vnnseKEBEYyflE+QWv6plCjP8OD0DF4J1Z+F4JMGVVT8oVUZCREwFU9JVQmnbMmAdKSNftdr1aTnuImy176VKtWTTjZrVs3fPHFF+KnaU+fKitetwWunhXS3gnPhnKZ9+G57eU2otmVn8OrA5AurZDM5wzSk891qVcbRHryKn5NF1c/f5PDSBMyTYnIYaQJk/OJ1IIlh5Hz/CiHSMCVQerWzVt4vcDrYAtnOo6qVati//79ptkV7enEz5DqmxmO6uNxRHI0SrcL877Mh2JFyFnEwTgZcEVPTl6CkluEAGnJIh3toWaSnuIHPWDAAMyZM0dIsHfvXtSqVUuIw9MnQPtWwK8/CfGzIkdhfJboF0gNCgFfzwtQPk0XkvmUQXryqe70emNIT17vgkQroH7+JodRorg0JyCHkWZUziVUC5YcRs6xo9SxCTg7SLH1itj6Bps3Kwthvjr8lbvCCxcuoHDhwo4oQ/+GhUbhr+IVkNX/Dq/nkvC+SPrxCLzbxofvcHlr9Qs4qyf9akIlm50AacnsPWis+pOe4u+PR48e2cfvu3fv8kQFChQAWxib7Z4mHMpGEWjfArhxiUf/G5UC+TOc5rOM2Ilx7fwwoKfvbhpBeuLdTwEJBEhPEiDqXIT6+ZscRvJgk8NIHkuhJLVgyWEkoCHDBQLODlLffvst2rRpI1xp0qRJGD16tBBnZOOr/ifQcV8zoYozyu/EkCXFaJFrgYrzhrN6cv4KlMMqBEhLVulpz7ST9JQw5+3bt6NRo0ZComnTpmH48OFCnN349b9A4+pC/MKAsRiVvocQt2WyP6pW8s2XMKQnoavJcJMA6clNgB7Irn7+JoeRPODkMJLHUihJLVhyGAloyHCBgDOD1P379/H666+DvY10HGxW0cmTJ5EiRQpHlKF/9238C0VG1kCWgIe8nn9GZEGq06eRMiV9isahuBhwRk8uXoKyWYQAackiHe2hZpKeEgYdpeyG1rp1a6xbt44ntNls9o0s8ubNy+N4oF8vYP8WbkbYUuCtFNtxPkV02jQBwInVNmTJ7HtjK+mJdz0FJBAgPUmAqHMR6udvchjJg00OI3kshZLUgiWHkYCGDBcIODNI9ejRA19++aVwlSNHjqBSpUpCnFGN3878ib/bdkexJGeEKj7oOB4ZR3QX4shwjYAzenLtCpTLKgRIS1bpac+0k/SUOOebN28if/78YLugOo4mTZpg48aN4gLY7OS1a0CzNx3J7L8v/FOhl+1zbEpXVbFfOolqKP6jdYsDoPiefOogPflUd3q9MaQnr3dBohVQP3+TwyhRXJoTkMNIMyrnEqoFSw4j59hR6tgEtA5SbAHMOnXqCAUMHjwYM2fOFOKMaoTv3IMXQ3ojld9zoYoPslVGxt3fwOfuZoVWes7QqifP1YiuZFYCpCWz9pwx60160tYvn376KYYMGSIk3rlzJ+rVqyfE2Y3B/YHd62PFXwotjE9SjuSOowkd/NC3h295jEhPsbqdItwgQHpyA56Hsqqfv8lhJA86OYzksRRKUguWHEYCGjJcIKBlkHqsLHJZvHhxsLePjiMkJAQXL15E2rQG3ztXWaQbE8YD34ozo1g7HvsFIc0Ph4CgIEez6NdNAlr05OYlKLtFCJCWLNLRHmom6Ukb6BcvXqBMmTL28d2Rgy2Afe7cOSRPntwR9fL32TOg67vAT8fE+FfWN2Fd0Dt4HNgqRntn21Cq+MtZR3EmNlkk6clkHWbw6pKeDN5BSvXUz9/kMJLXX+QwksdSKEktWHIYCWjIcIGAlkFq5MiRYItfqo8dO3agfv366ijjhZmzaMxIYMuqWHX7KzIjUq1di2TFCsY6RxGuE9CiJ9dLp5xWIkBaslJv699W0pN2xt9//z1q164tZJgzZw769esnxNmN58qs3fe7AaeUly9xHKVTH8H15NmRPSVw5JsApEkTRyITRpGeTNhpBq4y6cnAnfOqaurnb3IYyesvchjJYymUpBYsOYwENGS4QCCxQer8+fMoUaKEUPK7776LFStWxF7TQEjlZSMBZ9HusGbIt24S8hYz+OwoLyN05fKJ6cmVMimPNQmQlqzZ73q1mvSknSxbALtly5bYsGEDz8RmF924cQNZs2blcTzAxttdO4AZk4E/b/FoFtgQ1h7dgqfY41qX8cPCT2w+sRsp6UnoZjLcJEB6chOgB7Krn7/JYSQPODmM5LEUSlILlhxGAhoyXCCQ0CAVERGBmjVr4ocffuAlp06dWlnr8lrcN408lZcDoaHA8MHKHPiNQkVCo/wwwjYPZca+jQ5tfGs9BaGhXjQS0pMXq0WXNiEB0pIJO83AVSY9Odc5v/zyCwoWLIhI5gx6dfTp0wfz5s1zmLF/lXsGNKoF3FYWxFYdPQOW4Nv0SrxyLOzvjzbN2Udq5j5IT+buP6PVnvRktB6JXR/18zc5jGLzcTWGHEaukkskn1qw5DBKBBadTpRAQoPU119/jY4dOwplLFu2DJ07dxbiDGU8fQL0VKbHnzsiVIs5i7olWwn/qlWxXFlLwc93llIQ2ultIyE9ebtudH1zESAtmau/jF5b0pPzPfTBBx9g4sSJQsbTp0+jVKlSQpxg3LkDNKgCRITx6McRyVE5/SHcSZYVSZSx99gyG/LkMvcgTHri3UsBCQRITxIg6lyE+vmbHEbyYJPDSB5LoSS1YMlhJKAhwwUC8Q1SDx48QL58+fDPP//wUitXroyDBw8iICCAxxkqcP8+0KktcOuKUC2Hs+h45io4vsaG9OnNfaMqNM5gRnx6Mlg1qTomIEBaMkEnmaiKpCfnO+vRo0fInz8/2P2A46hRowb27dsHf/8EZglt2QyM6u3IYv89G1oGtYK/RaSfDWVDgB0rApR7CSGJqQzSk6m6y/CVJT0Zvoto0WuduogcRjqBJYeRTmAtWmx8g1T//v0xd+5cgcqZM2dQsmRJIc4wBnur2bYx8PefQpX+jUyCLilWY2+actg+zR+VyidwkyvkJMMVAvHpyZWyKI+1CZCWrN3/sltPenKNaFwzjdetW4cWLVrEX6CyBhKGDQJ2fiekmRb1EaZm7mqPm9DBD317mPfTcNKT0LVkuEmA9OQmQA9kVz9/0wwjecDJYSSPpVCSWrA0w0hAQ4YLBOIapE6ePIly5coJpQ0ePBgzZ84U4gxldHkHOHFAqNJfEWnQKvU6nE1ZAMOa+GH0IPPenAoNM7ARl54MXF2qmoEJkJYM3DkmrBrpybVOCw8PR5Uqyuzc48d5Aa+99houXbqEVKlS8bhYgX//VT5NexN48Ds/9Xt4VhTJdkyx/cBG48OLbHijgDln/JKeeLdSQAIB0pMEiDoXoX7+JoeRPNjkMJLHUihJLVhyGAloyHCBQMxBik0zZ5+eMaeR48iYMSOuXr2KoKAgR5TxfovnAcL/T6hXiTRHcStZMIpnVta/XhWAJEmE02ToQCCmnpIlS6bDVahIKxAgLVmhlz3XRtKT66yULuyTAABAAElEQVSPHj2KSpUqCQV88sknGDp0qBAXyzh7FninkRBdPeX3uBCY3x5XOCOwf3UAkiYVkpjCID2ZoptMU0nSk/G7Sv38TQ4jef1FDiN5LIWS1IIlh5GAhgwXCMQcpL766iu89957QkmrV69Gu3bthDhDGYozC81rClXqlmQFNqSrYX+LeWSxDQVeN+dbTKFRJjBi6okcRiboNINWkbRk0I4xabVIT+51XJcuXbB8+XJeSFLFy3P79m1kyZKFx8UKsE/Tqiuzlf+6y08tC++NwdlGcHtEUz+MHGi+2b+kJ96FFJBAgPQkAaLORaifv8lhJA82OYzksRRKUguWHEYCGjJcIKAepPLkyYNChQrh2bNnvKSaNWti7969CS9wyVN7KTBkALBrHb/4w4hUKJD5LML9k8Ls6yTwRpkkoNYTeyNNDiOTdJwBq0laMmCnmLhKpCf3Ou/WzVvIkzcPIiMjeUFDhgzBjBkzuB1nYNpk4Kv5winmNBqSdRii/PyVj9OA72fZUKqEuV7qkJ6ELiXDTQKkJzcBeiC7+vmbHEbygJPDSB5LoSS1YMlhJKAhwwUC6kGKLW65bNkyXoqfsvf8hQsXUKRIER5nuMDlS0DL2kK1Po0cjQlZeqJ0NsWP9LW5d2IRGmYCQ60nchiZoMMMXEXSkoE7x4RVIz2532kffPABJk6cyAti9whXrlzB66+/zuNiBS5dBFrViRX9Q+hbaJt1Lp7bUiJ3GuDI2gCkSBErmWEjSE+G7RpTVoz0ZPxuUz9/k8NIXn+Rw0geS6EktWDJYSSgIcMFAo5B6qeffsKAAcpMHdUxevRoTJo0SRVjsCB709m6KXD5NK/YM2VXtAIZzuJ5ktQ4tsSGfHnM9daSN8SkAYeeWPXJYWTSTjRItUlLBukIH6kG6cn9jnz48CFy5cqFJ0+e8MLY5+rss/UEj8+VGUbzlJlGMY7/huXFW5k34nFAWgx52w9jh5jn0zTSU4zOJNMtAqQnt/B5JLP6+ZscRvKQk8NIHkuhJLVgyWEkoCHDBQJskDp06BB69eqF69ev8xKCg4Nx+fJlpEmjvPoz6rFtKzDifaF2MyLHYlKWHpjayQ89u5jn5lNohIkNuukxcecZrOqkJYN1iMmrQ3qS04Hz589H3759hcJ+/PFHVKxYUYiLZWzeBIzpB0RFf9LG0qwP64DuwZPtn6YdWmBD0ULmeMlDeorVwxThBgHSkxvwPJRV/fxNDiN50MlhJI+lUJJasOQwEtCQ4QIBNkixmUSffvqpkHvdunVo0aKFEGcog23Z+6aymOa/j3i1boeFoFTWQyiTIwm2rwiAjfxFnI2nAnTT4ynSvn8d0pLv97EnW0h6kkP7+fPnKFy4MG7cuMELrFatGg4cOJD4Wods17TubYEXT3leNis4R6bLiPBPgqKZgH3Krmlm2NGU9MS7kAISCJCeJEDUuQj18zc5jOTBJoeRPJZCSWrBksNIQEOGCwTu3LmDvHnzIjQ0lOeuXbs2du3alfjNH8/hhcC4D4DvlgoX7phkJXamr4rjy2zIk8scbymFBviAQTc9PtCJBmkCackgHeEj1SA9yetI9kKpVatWQoE7duxA/fr1hbg4DWVnNdQXZyM5Zgaz9FOU2cHvm2B2MOkpzt6lSBcJkJ5cBOfBbOrnb3IYyQNPDiN5LIWS1IIlh5GAhgwXCPTr1w/z5s0TcrKFrosWLSrEGcrYsxsY1FWo0qHQWmgasgQT3/FDn+40tUiA40GDbno8CNvHL0Va8vEO9nDzSE/ygEdERKBy5co4fvw4L7RUqVI4ceKEMrNXw/jbqglw6RTPywL9bAuxMqg+ApR3PSeX25Arp7Ff+pCehO4jw00CpCc3AXogu/r5mxxG8oCTw0geS6EktWDJYSSgIcNJAufOnUPJkiWFXEOHDsUnn3wixBnKuPMb0LA6EP5/vFrPI22okvYHJA/JjoNrzDGdnVfexwJ00+NjHerF5pCWvAjfBy9NepLbqfv27UOtWrWEQjds2IBmzZoJcXEamzYq6xmJ6yD9E5ECb2Q6bd81rUZeZW2jLwKUWc5x5jZEJOnJEN3gM5UgPRm/K9XP3+QwktdfhnMYsd0d2E5Q7CGZvQXZv38//vjjD3uLBw8ejJkzZyba+k2bNmkbDJWSNm7ciKZNlR2cJB9qwZLDSDJcCxUXqewwVrNmTfuC145mp0uXDr/++iuCgoIcUcb6DQsDWjQCfv1ZqNcQ/7lYmqEx9s+xoWQxY7+VFCrugwbd9Phgp3qpSaQlL4H30cuSnuR2bFRUlN1hxO6lHccbb7yB8+fPK2sQJXFExf2r5MXYUcCmr4XzcyOG48Osfexxiwb4o3Uz43qMSE9C15HhJgHSk5sAPZBd/fxNDiN5wA3nMPLzi/9BkhxG8jqeSjIHgbVr16JtW2XxSdWxZMkSdO0qfuqlOu394HZlV7Th4q5om8LaokvwNPSu5YdJYzVMhfd+K3y6BnTT49Pd69HGkZY8g5t9XuQ4NH1O5Ehssl/Sk/wOO3LkCKpUqSIUvHr1arRr106Ii9NgTqNunYDj+/hptgB2yfTH8L+kGZFSGc7Pf2dDhqD47915Ri8ESE9egO7DlyQ9Gb9zyWGkTx8Z2mFUsGBBlChRAmvWrLG33hWHERsoM2fOHC+9LFmyIHXq1PGed/WEWrA0w8hVitbO9/jxY7z++utgHnLHwf6fOHXqFFKmTOmIMt7vsMHAjrW8XnfCs6F05gNIG5gCp9cFKP+/8VMU8BIBuunxEngfvCxpyf1OPXtX+ew4uES8BT179gxZs2bFkydP7PcrbNZ1YGAgEssXb4EGPkF6kt85bJZR48aNsW3bNl547ty5cfnyZSRLlozHxRtQZjSjcTXh9NbQlugY8nLGf9dqfpj5sTFfBJGehG4jw00CpCc3AXogu/r5m2YYyQNuOIfR7Nmz7U4itpgv++Tm7t27CAkJsbfYFYfR77//juDgYHnENJakFiw5jDRCo2QCgQkTJuDDDz8U4ubPn49u3bppu8kTcnrIYG/BKxUHnv7NLzgOUzE7Uzt8M9Yf9WoZd+o6r7AFAnTTY4FO9lATSUvugZ5zbB4G/Dgei6tNQY8y3eMs7Ntvv0WbNm34OWY/yv0P3vthFGZX+gj9K4jrzPCEJgyQnvTpNPaiqWzZskLhy5cvR6dOyuwhLQf7NG3jV0LKZsk34mDqUvY4o35qTnoSuowMNwmQntwE6IHs6udvchjJA244h1HMppHDKCYRsq1A4NbNW8ibLy/UnyE0bNgQQ4YMQaVKlYzrMDp4EOjTQeii8ql+QMHyubB8tg0JfHEq5CFDXwJ006MvXyuVTlpyvbfZDKFSa2rzAuJzGrF17A4cOMDT5X2vAH4t8Be3z7Tdm+AMJZ7QBAHSk36dxJyOzNnoOPLkyWOfZZQ0aVJHVPy/fysvgWqWAUJf8DS/hOVHhWy7EelnQ4kswPerA5Td1/hpQwRIT4boBp+pBOnJ+F1JDiN9+ogcRvpwhVqwNMNIJ8g+XGyXLl3A3v45DrY45cqVK5EpUyZDO4yi3usKvyO7HdXG+dCSqJ19E86ttiE4mzHXOOCVtVCAbnos1Nk6N5W05B7gL059aZ8p5CglptOIfTZUqFAhx2mgvvJwXysNt2Om5ydMGiA96ddxce24yhxIrVq10nbRb1YBE4cLaWdGjsHELO/Z4+b19keH1saaRUx6ErqLDDcJkJ7cBOiB7Ornb5phJA84OYzksRRKUguWHEYCGjISIXDs2DFUrFhRSDV58mRUqFDBHmfYGUbKuhqRb5WG+nZxuP9sZO/XDP3fM9hrR4Gu9Qy66bFen+vVYtKS+2RjOo3SnvJHppMvnUJs51j2n/2I4SxSp2Pn2QYJ7FNmMx+kJ317r1mzZmA7CTsOtvzD2bNnlZlBGsZo9sl547rAzcuO7AiP8kP11PtxKUUepFKKOL/OhqD0xnk5RHriXUUBCQRITxIg6lyE+vmbHEbyYPu8w4gNjuytym+//YaMGTOiePHiqFu3Ljp06JDgYtjuIlYLlhxG7tK0Tv7IyEhUq1YNbLF2x/Haa6/ZNcy2wWWHUR1G4ZOnImDVXEe18a+yk8pbuX7GwY2pkDw5j6aAAQjQTY8BOsFHqkBaktOR849+jr5HVWvWff8Y2BkaXXgMZxFinldSss0QHjx4oPy9Ne8fXNJTdJfrETp69Kj9HkJd9tatW9GoUSN1VPzhn38C2tRXziu7p706vgnrgt7B4+xWjxp+mD5Og/PJkVnnX9KTzoAtVjzpyfgdrn7+JoeRvP7yeYdRfKjYN9tfffWVsJBkfGnjimeCTOi4f/8+ihQpYk/yyy+/gD3000EEEiPA3vyxt8Tqg32K9vbbb+P06dP26NKlSxtuDSO/iz8j4N3GwuwidhOZdt5YvFXdOG8b1VytHGY3PUbWk5X7xmxtJy3J6bGff/4ZZT6sBLwV/bkZdwppcBaxWvgpi8SdPHmS33vIqZlnSyE96cub7ZjG1kPcv38/v1C5cuVwUFl/0N9fPT+Yn44VCPhkKmzfLObxf4RnxBvZTin2y7F+z8wIFHt5+8vTeCtAevIWed+8LunJ+P3KnEQ5c+a0V5QcRvL6y2cdRmx3qfbt26NMmTLIli2bnRibZbR582YsWrQIbNBkx9q1a9G6dWt72Jl/2I2Z1mPdunX2Hd+0pqd01iQQGhqKzp07g22Z7DjeeOMNzJkzR9t0cUcmD//6KfUuNXYE0jy7z68cpkxT75lzK94Z9ogWuuZUKEAEiAARiJ8Am0U65OAYRFYLjE70PBJIoXqQj2NmEUscGBiISZMm2WdRR2emEBGITeDMmTMYOnSocOKTTz4Bexml5Uip7F5cbrK4llGDFNtwNFVRe/b8aZ5gyoBzigNKS2mUhggQASIgjwD7hLtly5b2AslhJI+rTzqMnj59ap+aHZ9T59ChQ6hVqxbCw8PtN1m3b99GhgwZnKIaX9lxFUIOo7ioUFxMAlu2bMGsWbOEaGYXK1ZMiDOakf+blch+ZJdQLbYQZtYPSyM46zMhngwiQASIABGInwC7we29dSD+Lq2sFxPziMdZVKBAAYwbNw5ZsihbVdFBBBIhwD5979u3L65cucJTsuUaPv30U/ssNR4ZX0B54VphRF+kePYPT/F/Uf5YGjkAC9K3xZ1kWTGs4RVULBP9EoknpAARIAJEQEcC5DDSB65POoy0oFqwYAH69OljT8rCvXr10pKNp6FP0jgKCkgg8M8//4DNJuKLmyplsvW3Vq9ebb+BM+o0WP+1a5Bk2miBwM+hRbGx20YMH0SvFwUwBjKMqicDIaKqaCRAWtIIyolk//77LzIseQOwKbOLHAebaTT21eLXjjjlt2vXrmCzQ9j6Rb5wkJ4804u7du1C06ZNhYsdOHAg1oYbQgKVETBjGmyrF6liooM/hlbHxNemYs2mLMrn89Hx3giRnrxB3XevSXoyft/SJ2n69JFlHUbswZwtgs0+TWvTpg3WrFkjlbB60S1a9FoqWp8srHz58jhx4oTQtkuXLtmdSCySDVI//vij/bxhFr2+fAlRrepA+SPC6x2qfIrWKugAVu3Oj1S+8fzC2+ZLAUPqyZcAW6gtpCX5nR1z1zR+hThmGLG1Z6pXr86TmD1AevJMD7JZRuwTNLYpjONo3rw51q9f7zAT/v3jHtC0DvAkthOTZTwcWhOXxyzHe529uwA26SnhbqSzzhEgPTnHyxup1c/f9EmavB6wrMOIIQwJCcFd5Vts9rDOtjKXeagFSw4jmWR9ryy2jlbMha7ZdPG5c6N3HDPcIKU4sPB2beD3X4UOmRI1HnkmdkWb5jS7SABjMMNwejIYH6qOdgKkJe2stKSM5SxKZA2jQYMG2T8l0lK2GdKQnjzXS8w55Fjrw3FV9pka+8RR06HMjMZc5TP6NV8om6ZFvzhiedknarmzXsfF9QFIn177mp+arutEItKTE7AoaaIESE+JIvJ6AvXzNzmM5HWHpR1G2bNnx++//04OI3l6opJcIBDXelh37tyxOzQdxRlukPpCmYo+62NH9ey/bFe0OYU/wuHvkiAgQDhFhsEIGE5PBuND1dFOgLSknVViKWM5ixwzihLYJS1dunRgN8Vs51dfOEhPnutFttFG/vz5wdbxdByDBw/GzJkzHaa23+vXgakTgSO7hfSvpz2Ntm9nwsejvDfLiPQkdAkZbhIgPbkJ0APZyWGkD2TLOoz+/vtv+0LX7JM0tksam+Uh81ALlmYYySTrW2WxrW3feuutWI1y7OLnOGG4QaqRMrvoxiVH9XAptDCqBm/BuolJ8WZVml3EwRg0YDg9GZQTVStxAqSlxBlpSRGvs+hV5iTNUyOssmpBGIczSTnvS5+lkZ60qEVemvnz59sXwHaUGKC87bl37559yQZHnKZf5RM3FH1NSNowxVYcS1UMJ5fbkCeXd2YZkZ6ELiHDTQKkJzcBeiC7+vmbZhjJA25Zh9Hnn3+O3r1720myAdMRloVWLVhyGMmi6nvlpEiRAi9evBAaxrZWjrkzmqEGqWfPEFX2dfghegp6y2TrEV6iDDYuCVAW6RaaQ4YBCRhKTwbkQ1XSToC0pJ1VfCljOotqPCqOgxP28eQVK1a0v9Ta9eduvPfDKB6PV04jX/osjfQU3b2eCLGXp1mzZgWbbeQ42G5pTFNOHzUrAX/e4tk+xHTMzdQGjYv5YcUc78wyIj3x7qCABAKkJwkQdS5C/fxNDiN5sH3OYcTWJHr8+DEKFiwYL6VDhw6hdu3aCAsLQ/LkycEcOpkzZ443vSsn1IIlh5ErBH0/z7Vr1+JcKyDm7CJGwlCD1KmTQKfo3VXClYWus2W8iv0LA1G0EHmLzKBcQ+nJDMCojvESIC3Fi0bTiZjOosXVpuCNFwXRvn17/Pbbb+jRowdmzZqFwMBAe3kx0wcej8TufptRpUoVTdczeiLSk+d7aNSoUZg6dSq/MHMg3bhxw35/zCO1BLq+Cxzfz1Mqc44wO3IUPs7SE/vnBKCk4jjy9EF68jRx374e6cn4/at+/iaHkbz+MpzD6OzZs3YHjqOJbDezbt262c1GjRrxsON8zG1BT506hbJly6J+/fpo0qQJChUqZP/0jKVnN1+bNm3CokWL7LujsTi2bXm7du1YUOqhFiw5jKSi9ZnCmK6XLl0qtIc5O1OnTi3EMcNIg9TjmYuQZmn0+kUXQ4vg8xY7MG+qd94gxoJFEYkSMJKeEq0sJTA0AdKS691z9u45lFqjfN776mDOoh5lututR48egW1zzu5xYq5zF9NpdKbtXpQMLuEoxtS/pCfPd991ZQ2ivHnzChdmOwezHYSdOuYrG3UsiHY8OfKO8ZuByxVaYf0Xnp+BTHpy9AL9yiBAepJBUd8y1M/f5DCSx9pwDqMhQ4Y4teNHzNkYDodRYojY27ply5bZ1y9KLK0r59WCJYeRKwR9O8/FixdRpEgRoZELFixAr169hDiHYZhBSlmn4M+SNZEl/BdH1bAqvAeq7/8I2UM8//aQV4ICThEwjJ6cqjUlNiIB0pJ7vTLn2DwM+HE81M4iLSU6nEazK32E/hX6asliijSkJ+90U4cOHewvUB1XZy9e2e7B/v5OrEn4/DnQuwdw4oCjGPvv0dCqaBCyEjum+6NiOSfKE0pxzSA9ucaNcsVNgPQUNxcjxaqfv8lhJK9nfM5h9ExZX4UtJHzy5EkcP37cPluJ7QDBPj/Lli0bypUrZ19kmC10HRQUJI9kjJLUgiWHUQw4ZMZ6Y8ymgP/666/8s4OYiIwySN3f+iMyjWwlVG9t9VVos6CGEEeGsQkYRU/GpkS100KAtKSFUsJp2EwjV2YIuZov4dp49yzpyTv8jx49ikqVlDWIVMcPP/yAqlWrqmI0BNni15/OAJbN5okfRqRG3qw/o3x2YOfXnp1lRHri3UABCQRITxIg6lyE+vmbHEbyYBvOYSSvad4tSS1Ychh5ty+MdvXOnTtjxYoVQrWWLFmCrl27CnFqwyiD1KVK76HQP9t51a6H5UHaHw8hQ0bPvjXkFaCASwSMoieXKk+ZDEWAtGSo7jB9ZUhP3ulCNlufrYP1448/8gq4vIPwnd+AuhV4OSyQP90ZPEiSAes/9kfNap67XyA9Cd1AhpsESE9uAvRAdvXzNzmM5AEnh5E8lkJJasGSw0hAY3kj5noUDMhzZSo3W4A9vsMIg9T/Vu9B5kldhCruKzMNb614R4gjw/gEjKAn41OiGmohQFrSQonSaCVAetJKSn66DRs2oEWLFkLBbHOO/PnzC3GJGmyWUYk8QEQYT9otyQpsSFcDRTMBB9cGKJ+68VO6BkhPuuK1XOGkJ+N3ufr5mxxG8vqLHEbyWAolqQVLDiMBjaUNtvB6jhw5YjGIuRZXzAReH6T+/BPPlC1zA/GCV+1pZFKE7zmPdK+l4XEUMAcBr+vJHJiolhoIkJY0QKIkmgmQnjSjkp4wNDQU+fLls28Q4yic7aA2efJkh6n9t11L4MJRnn5vaEO0Dllgt1eN9keDOp7xGJGeeBdQQAIB0pMEiDoXoX7+JoeRPNjkMJLHUihJLVhyGAloLG2MGzcO48ePFxg8ffoUKVOmFOJiGl4dpI4qU9S7i+sWsfrtqT4fdRY0jVlVsk1AwKt6MgEfqqJ2AqQl7awoZeIESE+JM9IzxezZszFw4EB+CbZBzB9//BHn7q08UVyBb9cC4wfzM+FRfiiQ/iweJkmPfOmAY+sDYPPAxqqkJ94FFJBAgPQkAaLORaifv8lhJA82OYzksRRKUguWHEYCGssaT548sS+8/u+//3IGU6dOxYgRI7gdX8Brg9SZ08C7jWNVa094M1Q4ORdp0tDOaLHgmCDCa3oyARuqonMESEvO8aLUCRMgPSXMR++z7N6VbRATyT4re3UsX74cnTp1cpjafp8+ASoWBiIjePopUR9jeuaX5awc5Y+GdfWfZUR64vgpIIEA6UkCRJ2LUD9/k8NIHmxyGMljKZSkFiw5jAQ0ljXYwtbdu3fn7Wfb1d69exdZsmThcfEFvDZItVdmFp2PXgST1e9eeCZs63sIPfqlja+6FG9wAl7Tk8G5UPWcJ0Bacp4Z5YifAOkpfjaeOtOrVy8sXLiQX65EiRI4ffq0su6Qkw6e4UOA7Wt4OdfDcqN08AHF9kPhjMAP3+q/lhHpieOngAQCpCcJEHUuQv38TQ4jebDJYSSPpVCSWrDkMBLQWNKIiIhA4cKFcfXqVd7+3r17Y/78+dxOKOCVQeqnC0Db+rGq1T71VizeVwqpEv6KLlY+ijAOAa/oyTjNp5pIJEBakgiTigLpyfsiOHXqFMqWLStU5MiRI6hUqZIQl6hx+hTQsYmQrGGKrfgxVTF73Lpx/nirhpNOKKG0xA3SU+KMKIV2AqQn7ay8lVL9/E0OI3m9QA4jeSyFktSCJYeRgMaSxq5du1C/vuh8uXDhAooWLaqJh8cHqd9uA/Uqxqpb4bQn0KdbVvTu5oHFB2JdnSJkEfC4nmRVnMoxHAHSkuG6xNQVIj15v/vYJhyVK1fG0aPRi1Z37twZy5Ytc65ySjmoqdxH/O83nm9zaBt0Dplut0tnA/auDoCfjl+2k544egpIIEB6kgBR5yLUz9/kMJIHmxxG8lgKJakFSw4jAY0ljSZNmmDLli287cx5tGPHDm4nFvDoIPXLNaDpm7GqNDlqAuZl64irmwKUBTBjnaYIExHwqJ5MxIWq6jwB0pLzzChH/ARIT/Gz8eSZtWvXom3btvySfopXh+3yGhISwuM0Bb78AvhsnJB0kP98LM/QyB63dYo/qlTUb5YR6UlAT4abBEhPbgL0QHb18zc5jOQBJ4eRPJZCSWrBksNIQGM549dff7VvVatuOJtxVLduXXVUgmGPDlLjPgC+WyrU53FEchTIdBaDW6fEsH40u0iAY0LDo3oyIR+qsnYCpCXtrChl4gRIT4kz8kSKZ8+e2Z1Djx494pebNm0ahg8fzm1NgQf3geollaTKbKNXB1tOe7D/AqzI0BBVcwGbl+k3y4j05KBOvzIIkJ5kUNS3DPXzNzmM5LEmh5E8lkJJasGSw0hAYznj448/xkcffcTbnSNHDvz3v/9FkiRJeFxiAY8OUo1qAzcuCVWaHzEU47L1w5X1NmQI0nH+uHBVMvQi4FE96dUIKtcQBEhLhugGn6kE6ck4XTl+/HiMGzeOVyhr1qxg97NJkyblcZoCH4wGNqwQkjKnUX/bIqwKqoe9n/mjTEl9ZhmRngTsZLhJgPTkJkAPZFc/f5PDSB5wchjJYymUpBYsOYwENJYyXrx4gddeew0PHjzg7Z4xYwaGDFF2D3Hi8NggpdQXZfIpLwOj3wayauZMfwGdGqbDx6NodpET3WbYpB7Tk2EJUMVkESAtySJJ5TACpCfj6ODWzVvIlTuXUKHdu3ejTp06QlyiRlgYMGaksGMayxMa5YfyaY6gQIkQrFkYkGgxriQgPblCjfLER4D0FB8Z48Srn7/JYSSvX8hhJI+lUJJasOQwEtBYyti0aROaNWvG2+zqOgAeG6TOngXeebm2gKPSpVMfwc3k2XFhtQ0hwTS7yMHFzL8e05OZIVHdNREgLWnCRIk0EiA9aQTloWRNmzbF5s2b+dU6dOiAlStXcltzgL2EmqEsdr18jpBl4KtP0459YUOB/PLvL0hPAm4y3CRAenIToAeyq5+/yWEkDzg5jOSxFEpSC5YcRgIaSxlscWu2XpHjaN++PVatWuUwNf96bJD6fD4wbzKv19WwAqgQvAedq/jhs4k0u4iDMXnAY3oyOSeqfuIESEuJM6IU2gmQnrSz8kRK5ixiTiPH4e/vj3v37iFz5syOKO2/zGlUuypw7wbP43AYdavuhxnj5d9jkJ44agpIIEB6kgBR5yLUz9/kMJIHmxxG8lgKJakFSw4jAY1ljGvXrqFAgQJCe/ft24eaNWsKcVoMjw1S7VoCF6K30l0e3guDso3EqaU25M0j/+2flrZTGvkEPKYn+VWnEg1GgLRksA4xeXVIT8bqwOfPnyNLlix48uQJr9jChQvRs2dPbjsVqFsduPNfnqWfbSFWBtWHTbm9uPydDZkyyr3PID1x1BSQQID0JAGizkWon7/JYSQPNjmM5LEUSlILlhxGAhrLGB988AEmTpzI25snTx4wJ5LN5vxbNI8MUsqNYVTZ1+EXxZajfHl0TLIS/tWrYfls5+vsKIN+jUfAI3oyXrOpRjoQIC3pANXCRZKejNf5I0eOBNshzXGUKFECZ86cAfvE3umjZiXgz1s824PwtBgUuADb0lbBB638MLiP3HsN0hNHTQEJBEhPEiDqXIT6+ZscRvJgk8NIHkuhJLVgyWEkoLGEwQaV4OBgPHz4kLd31qxZGDBgALedCXhkkPrxCNCjNa9WuLIg5WsZLmHTZ6lQvow+O5jwi1HAowQ8oiePtogu5i0CpCVvkffN65KejNevF85fQPESxYWKnT59GqVKlRLiNBmdOwAnD8ZKOsh/PjZkaYQr2wKQInms0y5HkJ5cRkcZ4yBAeooDisGi1M/f5DCS1znkMJLHUihJLVhyGAloLGHs2LEDDRs25G1lb+Lu3r0Lti2tK4fug1SkMquocV3gxiVevXOhpdG/xAYc+jZAeZPIoyngAwR015MPMKImaCNAWtLGiVJpI0B60sbJk6milLWHypUrh1OnTvHLsp1e2Y6vTh9XrgDt31a2w3smZL0Rlgulgg9hQT9/tGsh7wUV6UnATIabBEhPbgL0QHb18zc5jOQBJ4eRPJZCSWrBksNIQGMJo23btli7di1va+vWrQWbn9AY0H2Q2rAO+ECc/TQ/YiiyTR+A5o3l3bxpbC4l05mA7nrSuf5UvHEIkJaM0xe+UBPSkzF78csvv0SPHj145QIDA3H//n2wX6ePB/eBkcOAo3uFrMXSHEOyLNlwfEMAlLW1pRykJykYqZBXBEhPxpeC+vmbHEby+oscRvJYCiWpBUsOIwGNzxt//PGH/XM09lbOcWzbtk2YceSI1/qr6yDFZhexnUv+uMmr8zQyKepnOYrvd2dFsmQ8mgI+QkBXPfkII2qGNgKkJW2cKJU2AqQnbZw8nerBgwf2xa8j2f3Cq2P9+vVo3ry5w3Tul5VTrhDwPHox7Q/8pmNexjbYMMEfb1aV4zEiPTnXLZQ6YQKkp4T5GOGs+vmbHEbyeoQcRvJYCiWpBUsOIwGNzxsLFixAnz59eDuDgoLsn6Mlc8PzousgFcfsol4BX6JgrzoY8L7cBSg5FAp4lYCuevJqy+jiniZAWvI0cd++HunJuP3bpUsXLF++nFewWbNm2LBhA7edDgwbDOyInol9PLQy6oWsRn3Fj7R6QYDTxcWVgfQUFxWKc5UA6clVcp7Lp37+JoeRPO7kMJLHUihJLVhyGAlofNpgs4pKliyJ8+fP83aOHj0akyZN4rYrAd0Gqf8cBt5vB6hmQ10Lex2Vgvfg8roA6VvcutJ2yiOfgG56kl9VKtHgBEhLBu8gk1WP9GTcDtuzZw/q1lXWOlQd9+7dc3ltRuzdAwzswktjc5dKKJ+l/ZYsG86vtCFHdvcXTyQ9cbwUkECA9CQBos5FqJ+/yWEkDzY5jOSxFEpSC5YcRgIanzbOnTtndxipG3nhwgUULVpUHeV0WJdBSrnRQ4MqQOgLoT79bAuRpEkDfDqBZhcJYHzI0EVPPsSHmqKdAGlJOytKmTgB0lPijLyVIjQ0FNmyZRN2f124cCF69uzpWpWU3WRRXplOFBZ9D/JXRBoMTPE5CneqipED3b8HIT251jWUK24CpKe4uRgpVv38TQ4jeT1DDiN5LIWS1IIlh5GAxqeNcePGYfz48byNZcuWxfHjx5Vdxtx7UyZ9kAoPB9oqaw9cPs3rygJrwjqjV/A4HFamgxcp5F6dhYLJMBQB6XoyVOuoMp4kQFryJG3fvxbpydh9PGrUKEydOpVXku2eduzYMdfvcT4YDWxYwctzBCYHzMCQE+3cXkOR9OQgSr8yCJCeZFDUtwz18zc5jOSxJoeRPJZCSWrBksNIQOOzBlsMMnfu3Lh9+zZv49y5c9G3b19uuxqQPkjNmQUs+kSozs7QpmgfPAulg/2wd3WAcgMonCbDhwhI15MPsaGmOEeAtOQcL0qdMAHSU8J8vH32zJkzKF26tFCNS5cu4Y033hDiNBt//QU0ehN4rPyqjkcRgfjh06to3MC9xa9JTyqoFHSbAOnJbYS6F6B+/iaHkTzc5DCSx1IoSS1YchgJaHzWOHHiBMqXLy+07+aNm8iZK6cQ54ohdZBStsLFmyWFdYt+Cw9Gucz78MIWiEUD/NG6mXs3aa60kfJ4joBUPXmu2nQlAxIgLRmwU0xcJdKTsTuPvRgrVqwYLl68yCs6YcIEjB07lttOB5jTaKCyUcgZZU3FVwfbqbVtuV+wbYV7i1+TnhxE6VcGAdKTDIr6lqF+/iaHkTzW5DCSx1IoSS1YchgJaHzWYItbT5kyhbevevXqOHjwILfdCUgdpOYqs4sWRs8uCovyQ4OUO3AqZSGkUPxE/90WgMBAd2pLeY1OQKqejN5Yqp+uBEhLuuK1XOGkJ+N3+axZszBo0CBe0Rw5cuD69euw2dxYcyjGfcnJ0IqoE7IGx76woUB+16c7k554N1FAAgHSkwSIOhehfv4mh5E82OQwksdSKEktWHIYCWh80ghX1gTKnj072B8nx7F48WL06NHDYbr1K22QUhatRKViwPMnvD7fhnVEz+AJdrtPbT9MHOPGTR8vlQJGJiBNT0ZuJNXNIwRISx7BbJmLkJ6M39W3bt5Crty5hIoePnwYVaoom2i4enTtCBzfx3N/Gd4Pw7INhbv3JKQnjpQCEgiQniRA1LkI9fM3OYzkwSaHkTyWQklqwZLDSEDjk8aRI0di3SzduXMHISEhUtorbZDavAkYrUz9Vh2VUx3ApRR57DFHF9tQ8HXX3+apiqWggQlI05OB20hV8wwB0pJnOFvlKqQnc/R0nTp1sHfvXl7ZwYMHY+bMmdx2OtCuJXDhKM+2JLwvhmYbhmTKrOcb2wOQIgU/5VSA9OQULkqcCAHSUyKADHBa/fxNDiN5HUIOI3kshZLUgiWHkYDGJ42hQ4cKN0t169bFrl27pLVV2iDV9V3lLd5+Xq+joVXRIGSl3S6r+Lb2rHJvvQBeMAUMTUCangzdSqqcJwiQljxB2TrXID2Zo69XrFiBzp0788oGBQXh3r17SJo0KY9zKvDJNGD5HJ7lQXhaFMh6FpF+NqwY7u/y4tekJ46UAhIIkJ4kQNS5CPXzNzmM5MEmh5E8lkJJasGSw0hA43NGqPKZV7Zs2fDw4UPetmXLlgk3U/yEiwFpg1T5IsDTv3kt+toWYVVQPbv9xSB/tGxCi11zOD4ckKYnH2ZETdNGgLSkjROl0kaA9KSNk7dTqe9xHXVhazaytRtdOpQ1kPB2VSFrf9vn+DqoAWrlB777wrWXWaQnASkZbhIgPbkJ0APZ1X+byGEkDzg5jOSxFEpSC5YcRgIanzN++OGHWDdJsv9ISRmknijrFlUoKPCvkOoQrqbIZV/s+lc3pn0LhZJheAJS9GT4VlIFPUGAtOQJyta5BunJPH3duHFjbN26lVd44MCB+Oyzz7jtdKDF28CVMzxbqLIhR5dkq7EjbSVc/MaG4GzOfy5PeuI4KSCBAOlJAkSdi1A/f8t+FtO56oYunhxGOnWPWrDkMNIJskGKHTVqFKZOncpr07BhQ2zbto3bMgJSBqmfLgBt6/PqhCs3Y1ky/VeZ8h2AHjX8MH0cLXbN4fh4QIqefJwRNU8bAdKSNk6UShsB0pM2TkZItXLlSrz7rvKZ+6sjXbp09o0/XP4sbbvifBr+vqM4+++zyACUSn8MfbtkRt8ezt+jkJ4EnGS4SYD05CZAD2RXP3+Tw0gecHIYyWMplKQWLDmMBDQ+ZURGRiJv3ry4efMmb9eXX36Jbt26cVtGQMog9b2yQOWAzrw6v4UHo1i2l4tM7vnUH2VL0edoHI6PB6ToyccZUfO0ESAtaeNEqbQRID1p42SEVPfv30eWLFkQFRXFq7N//368+eab3HYqwMoZMRTYvkbI9knkB/gmf3ec2hQAfydvU0hPAkoy3CRAenIToAeyq5+/yWEkDzg5jOSxFEpSC5YcRgIanzIuXLiA4sWLC21izqOcOXMKce4aUgaptd8AHys3Y6+Os6FlUDNkPbKnBM5vdf5GzFEO/ZqPgBQ9ma/ZVGMdCJCWdIBq4SJJT+bq/KZNm2Lz5s280v369cOcOdGLV/MTWgPKSzj0fg84vJPnOBZaBfVDVuH7z/xRuqRzHiPSE8dIAQkESE8SIOpchPr5mxxG8mCTw0geS6EktWDJYSSg8SljxowZGDZsGG9T2bJlceLECW7LCkgZpObPBRZEfzr3fWgDtAr5HB+29sOg3s5P9ZbVNirH8wSk6Mnz1aYrGpAAacmAnWLiKpGezNV5q1evRocOHXilU6dODTbzKFmyZDzO6cDBA0Cfd3g2tpZR/qDzaFMrndOfzpOeOEYKSCBAepIAUeci1M/f5DCSB5scRvJYCiWpBUsOIwGNTxnly5cXHETTp08XHEiyGitlkBr/IfDtEl6lNWGd0St4PM59ZUPOHM4vJskLooDpCEjRk+laTRXWgwBpSQ+q1i2T9GSuvv/rr7+QKVMm4bO077//Hm+99ZbrDXn69OUGHapP3eZFDMPE4L64sSMAKZJrL5r0pJ0VpUycAOkpcUbeTqF+/iaHkbzeIIeRPJZCSWrBksNIQOMzxu3bt2N9enb+3HkUK15MehulDFLtWgIXXq5ZxCo4N2I4dpXrg+1fubZdrfRGUoEeIyBFTx6rLV3IyARIS0buHfPVjfRkvj5r3rw5Nm7cyCvep08fzJs3j9suBYYPEdYyehyRHAUyncWyj1KhXi3tn6WRnlyiT5niIUB6igeMgaLVz9/kMJLXMeQwksdSKEktWHIYCWh8xli2bBm6du3K25MjRw7cuHFDWZRR+80Mz5xIwO1B6pjiKOqmOIxUR7ckK1Drg5po10J+fVWXoaABCbitJwO2iarkHQKkJe9w99Wrkp7M17Nr1qxBu3bteMXZbmnsHjhJkiQ8zunA9evA21WFbFOixuNmgy5YNEP7J/SkJwEhGW4SID25CdAD2dXP3+QwkgecHEbyWAolqQVLDiMBjc8YTZo0wZYtW3h7Ro4ciSlTpnBbZsCtQeqff4C6VYAnD3mV7G/rsvyEK1sDkTYNj6aARQi4pSeLMKJmaiNAWtLGiVJpI0B60sbJSKkePHhg/yxNXacjR46gUqVK6ijnwz2V3Wb/s4vn+zG0Oppk/wo3twUgpbJZh5aD9KSFEqXRSoD0pJWU99Kpn7/JYSSvH8hhJI+lUJJasOQwEtD4hPHo0SNkyJABkWxHj1fHoUOHUK1aNYcp9dflQYqtATCoH7A3ero4q9hHmIZbtdph+Wztb+qkNogK8yoBl/Xk1VrTxY1IgLRkxF4xb51IT+bsu3r16mH37t288mPHjsWECRO47VKgbQvgp2M867dhHdEzeAK+GuGPt+trmxlNeuL4KCCBAOlJAkSdi1A/f5PDSB5schjJYymUpBYsOYwEND5hbN26FY0bN+ZtCQwMxN9//42kSZPyOJkBlwepvXuAgV2EqhwJrYFGIcuxfLgNTRpou+kSCiDD9ARc1pPpW04NkE2AtCSbqLXLIz2Zs/8XL16Mnj178srnyZMHv/zyi+uf6D9/DpTJr5SnvPR6dXRO8jU2p6uGxsX8sGKOtpddpCcHPfqVQYD0JIOivmWon7/JYSSPNTmM5LEUSlILlhxGAhqfMPr374+5c5Vt6l8dXbp0wdKlSx2m9F+XBil2w/VWBeCfB7w+7FO0skFH8FeyjLixNQCpU/FTFLAQAZf0ZCE+1FTtBEhL2llRysQJkJ4SZ2TEFDdv3kTu3LmFqv38888oXLiwEKfZUD5zQ/XiQvICaU/jf0kzgrmKft0SoOlzetKTgJAMNwmQntwE6IHs6udvchjJA04OI3kshZLUgiWHkYDG9Ab7DC0kJAR//PEHbwtb9LFNmzbclh1waZCaMwtY9IlQlb62RVgVVA9NivvR52gCGWsZLunJWoiotRoJkJY0gqJkmgiQnjRhMmSi0qVL48yZM7xuM2fOxODBg7ntVCAiAiiWU8kSPcOoZuAenE1ZwF7Ml4P90aJx4jOkSU9OUafEiRAgPSUCyACn1c/f5DCS1yHkMJLHUihJLVhyGAloTG/89NNPKFasmNCOu3fvIlu2bEKcTMPpQUqpD+qUV+61otdYOhpaFQ1CvlaqpUznHu6PxvQ5mswuMlVZTuvJVK2jynqSAGnJk7R9/1qkJ/P28fTp0zFixAjegPLly+PYseg1iPgJrYGKyn3W4794ascnaSyibkFgzcIAfi6+AOkpPjIU7woB0pMr1DybR/38TQ4jeezJYSSPpVCSWrDkMBLQmN6YPXs2Bg4cyNtRrlw5HD9+nNt6BJwepEYrN22bV/KqhEf5oWrqA7iSIjdsfqDP0TgZawac1pM1MVGrNRAgLWmAREk0EyA9aUZluIQXzl9A8RLiZ2Ru3f82awhcO8fbOTVqHKZlfrkmI5tbdEP5LC1NGn46zgDpKU4sFOkiAdKTi+A8mE39/E0OI3ngyWEkj6VQklqwbg2YQqlkGIFAnTp1sHfvXl6VyZMnY9SoUdzWI+DUIHXrFtCgslKN6KncK8Lfx8BsL+vYVPkcbRntjqZHN5mmTKf0ZJpWUUW9QYC05A3qvntN0pN5+5Z9rs/WMbp9+zZvxJIlS9C1a1duOxXo/R5waLuQZXVYVwzMOgJh/sk17ZZGehLwkeEmAdKTmwA9kF39/E0OI3nAyWEkj6VQklqw5DAS0JjaYDuhZciQAVFsu/pXB5tyzaZe63k4NUgNGQDsWser8ywyAEWCTuPvJOnscfQ5Gkdj2YBTerIsJWq4FgKkJS2UKI1WAqQnraSMmY69PJs6dSqvXKNGjcB2lXXpmDwBWLUwVtYpUR9jeuZOaFvWD59/kvBuaaSnWPgowg0CpCc34Hkoq/r5mxxG8qCTw0geS6EktWDJYSSgMbXBbnwaN27M25AyZUo8fPgQSZMm5XF6BDQPUkpdULWoUIUFEYMxJqviRFIONo37JtsdLbXdpH8sSkCznizKh5qtnQBpSTsrSpk4AdJT4oyMnOLw4cOoVq0ar6Kfnx8eKDueBQUF8TjNgfPK52jtlc/SYhyHQ2uiccgyJFNuaG7vClDuv2IkUJmkJxUMCrpNgPTkNkLdC1A/f5PDSB5uchjJYymUpBYsOYwENKY2+vXrh3nz5vE2dOnSBUuXLuW2XgHNg9TpU0DHJrwaYYqLKE/6C3ga8NJDVCs/8N0XiS8UyQuggE8S0Kwnn2w9NUomAdKSTJpUFunJ3BoIDQ1FxowZ8eTJE96QTZs2o0mT6Bdt/ISWwJnTwLti3uthuVE6+KA995Yp/qhakb0Ki/sgPcXNhWJdI0B6co2bJ3Opn7/JYSSPPDmM5LEUSlILlhxGAhrTGuz7/ODgYLA/QI5jzZo1aNOmjcPU7VfzILXve6B/J16P3yOyo0jWI9z+7D0/dG6f8BRunpgCPktAs558lgA1TBYB0pIsklQOI0B6Mr8OunfvDrZ2kePo3bs35s+f7zCd/z17FninEc8XqmzikT/oPB4HpEWf2n6YOCb+exrSE8dGAQkESE8SIOpchPr5mxxG8mCTw0geS6EktWDJYSSgMa3x888/o2hR8XOvu8r29dmyZdO9TZoHqfXK2kUfvvz8jFXqp9BiqBYSvX7A+ZU25MiubJNGh6UJaNaTpSlR47UQIC1poURptBIgPWklZdx03333HVq3bs0rmClTJty7dw82W/yOHZ44rsCjv4HKRYQz34Z1RM/gCciSAri0PQD+8UwyIj0J2MhwkwDpyU2AHsiufv4mh5E84OQwksdSKEktWHIYCWhMayxcuBC9evXi9S9btixOnDjBbT0DmgepLxcDn43nVXF8688iCipLCBzdQJ+jcTgWDmjWk4UZUdO1ESAtaeNEqbQRID1p42TkVOr7X0c9zyqzhEqUKOEwnf8d2BfYu5Hni1RCNVLuw0+B+XB4gQ1FCsX9Ioz0xJFRQAIB0pMEiDoXof77Qw4jebDJYSSPpVCSWrDkMBLQmNZo0aIFNmzYwOs/btw4fPTRR9zWM6B5kJqgOIvWKE6jV8f6sA7oHjzZbo1s5ocRA1x8w+cokH59goBmPflEa6kRehIgLelJ13plk558o8+rVKmCI0eiP4f/9NNPMWjQINcbx5YCqK3sRhsRxstYF/YOegRPwkdt/DCwV9z3NqQnjosCEgiQniRA1LkI9fM3OYzkwSaHkTyWQklqwZLDSEBjSuPFixdIkyYNwsKib1b279+PN9980yPt0TxI9eoB/LCD12luxHB8mLWP3d43y4ZSJeJ+C8czUMASBDTryRI0qJHuECAtuUOP8sYkQHqKScSc9ieffILhw4fzyteoUQMHDhzgtkuB+XOBBVN51v+L8sfrQefwRq602LUy7tnTpCeOiwISCJCeJEDUuQj18zc5jOTBJoeRPJZCSWrBksNIQGNK4+jRo6hUqRKvu7/ywfw///yDVKlS8Tg9A5oHqcb1gF9/4lXZHtoc74R8hjTKvdT13QHKGgL8FAUsTECznizMiJqujQBpSRsnSqWNAOlJGyejpzp16hTYZ/vq48GDB8iQIYM6yrmwkh81lM/aoqJ4vmlRH2Fa5q64vjkA6dLyaB4gPXEUFJBAgPQkAaLORaifv8lhJA82OYzksRRKUguWHEYCGlMaM2bMwLBhw3jd69Wrh507d3Jb74DmQapYLmHKNqtX+ky30KmyH2ZNIm+R3v1klvI168ksDaJ6eo0Aaclr6H3ywqQn3+jW8PBwZMyY0f5izdGiXbt2oW7dug7Ttd+hA4Gd3/G8V0ILomLIbqwa448GtWOvfE164qgoIIEA6UkCRJ2LUD9/k8NIHmxyGMljKZSkFiw5jAQ0pjTefvttbNu2jdedOZCGDBnCbb0DmgepwiGxqsIcRsuH+6NJg9g3U7ESU4QlCGjWkyVoUCPdIUBacoce5Y1JgPQUk4h57XfeeQerVq3iDWBrPrK1H906Tp8COjYRiiiR5ijq1A3B9HGxX4qRngRUZLhJgPTkJkAPZFc/f5PDSB5wchjJYymUpBYsOYwENKYz2ADBPj1jb8wcB1vMUf2JmiNer1/Ng1QMh9HJ0IqoE7IG176zIVMmWr9Ir/4xW7ma9WS2hlF9PU6AtORx5D59QdKT73Tv4sWL0bNnT96gqlWr4ocffuC2S4GICKBcIeDFU559IiZiVY53cWlHAPxi3OaQnjgmCkggQHqSAFHnItTP3+QwkgebHEbyWAolqQVLDiMBjemMmN/is/WLHj9+jJQpU3qsLZoGKfZdf+WSwD/3eb2mRo3DtkJd8J91cS8IyRNSwFIENOnJUkSosa4SIC25So7yxUWA9BQXFXPGnT9/HiVKKGsOvTr8FG/Oo0eP7BuIOOJc+h0zEtj0Nc96JLQGGoWswMmlNuTLI3qMSE8cEwUkECA9SYCocxHq529yGMmDTQ4jeSyFktSCJYeRgMZ0xvz589G3b19eb7YzGtshzZOHpkHqwnmgXQOhWpVSHUSD1nkwdkjsqdpCQjIsRUCTnixFhBrrKgHSkqvkKF9cBEhPcVExZxzbVZbNzg4NDeUNYDulsR3T3Dq+3wsM6MyLeBFpw2uZrmB6z2To0kG81yE9cUwUkECA9CQBos5FqJ+/yWEkDzY5jOSxFEpSC5YcRgIa0xlt27bF2rVreb0nTJiAsWPHctsTAU2D1OgRwOaVvDq3wl5DieDD2DLZhqqVaP0iDoYC0KQn4kQENBAgLWmAREk0EyA9aUZlioTNmzfHxo0beV2nTp2KESOUexV3DmWGNyq+IZTQMtl6JK1QBqsXiLOpSU8CJjLcJEB6chOgB7Krn7/JYSQPODmM5LEUSlILlhxGAhpTGRHK9/Jp06bFv//+y+u9d+9e1KpVi9ueCCQ6SD1VvuevWBiIjF5naXrUh5ieuRtuK9/1BwZ6opZ0DbMQSFRPZmkI1dPrBEhLXu8Cn6oA6cmnuhOzZ8/GwIHKzmavDrZLGtstze3jrcrAHzd5MQP9F2B1xob4fU8AkiTh0fRyJBoFhSQQoL9PEiDqXIT6+ZscRvJgk8NIHkuhJLVgyWEkoDGVcfHiRRQpUkSo88OHD5E+fXohTm8j0UFqy2ZgVG9ejfAoP7yR/jSKFMyAjUvEN248EQUsSyBRPVmWDDXcWQKkJWeJUfqECJCeEqJjvnPHjx9HhQoVeMVtNpt9DchAd99ilS0EPPuHl9s+6RrsTFsRB+baUKJo9DpGpCeOiAISCJCeJEDUuQj18zc5jOTBJoeRPJZCSWrBksNIQGMqY/ny5ejSpQuvc9myZXHixAlueyqQ6CC1cAEwdxKvzqnQ8qgd8i0mveuH3t3Eb/p5IgpYlkCierIsGWq4swRIS84So/QJESA9JUTHfOeeP3+O1KlTg83WdhxHjx4VnEiOeM2/bMfa4jmF5NVS7sNPgfkwtZMfenaJvuchPQmYyHCTAOnJTYAeyK5+/iaHkTzg5DCSx1IoSS1YchgJaExldO/eHUuWLOF1HjlyJKZMmcJtTwUSHaQ2bwJG9+HVuRmWEyWDf8D+OTaULBb9to0noIClCSSqJ0vTocY7Q4C05AwtSpsYAdJTYoTMd75evXrYvXs3r/isWbMwYMAAbjsd+PNPoGYpIVvO9BfwOCAtGipf5q+cHz2rmvQkYCLDTQKkJzcBeiC7+vmbw0SPIAAAPatJREFUHEbygJPDSB5LoSS1YMlhJKAxjRGlbFOfPXt23L17l9d5y5YtePvtt7ntqUCig9TPPwFt6vHqRCifpGXP9Atuf59C+J6fJ6CApQkkqidL06HGO0OAtOQMLUqbGAHSU2KEzHd+2rRpYC/bHEezZs2wYcMGh+n876+/Ao2rCfkyZ7iKMP/kSKHs7/Hb3gAoX77ZD9KTgIkMNwmQntwE6IHs6udvchjJA04OI3kshZLUgiWHkYDGNMZvv/2GHDlyCPW9c+cOQkJChDhPGIkOUmzR6/IFhKoMKnQQn32XX4gjgwgwAonqiTARAY0ESEsaQVEyTQRIT5owmSrRoUOHUKNGDV7npEmT4smTJ2C/Lh3KZ24ow+5tonj2MX4zsCBjK7v9n89tKPzGy5nVpCeOiAISCJCeJEDUuQj18zc5jOTBJoeRPJZCSWrBksNIQGMaY9u2bcJsotdeew2sL/38PP+JV6KDlLI4N1rXEdgubf8juo4Rv/MXEpBhWQKJ6smyZKjhzhIgLTlLjNInRID0lBAdc557/Pgx0qVLBzZr23GcPXsWJUqUcJjO/9Z/E7h9Tcg3N2I4PszaBzO7+6HrOy+nGJGeBERkuEmA9OQmQA9kVz9/k8NIHnByGMljKZSkFiw5jAQ0pjHGjRuH8ePH8/qyxa+XLl3KbU8GEhukIiZOgu0bZeHrV8dv4cG4uewYqlaKXvzRcY5+iUBieiJCREArAdKSVlKUTgsB0pMWSuZLU61aNRw+fJhXnK0N2bVrV247HfhgNLBhhZAtUrGKpTmOcuWzYekschgJcMiQQoD+PknBqGsh6udvchjJQ00OI3kshZLUgiWHkYDGNEadOnWwd+9eXt/PP/8c77//Prc9GUhskHpWuwEC757nVVoQMRTvnhqE1Kl4FAWIACeQmJ54QgoQgUQIkJYSAUSnnSJAenIKl2kSjxkzBpMnT+b17dGjBxYvXsxtpwNXrwItawOR0buvsTJmR47EzJBeuLknAP7KekakJ6fJUoYECJCeEoBjkFPq529yGMnrFHIYyWMplKQWLDmMBDSmMEJDQ5EyZUqEs+1bXx3Hjh1D+fLlHaZHfxMcpCIjEV40FwIQfeM0NvhbTNxb2aN1pIuZh0CCejJPM6imBiBAWjJAJ/hQFUhPPtSZqqZs2rQJbLFrx5E7d278qixe7dYn/rdvA/UrOoq0/94Lz4TCWU/g9FdJkDunHzmMBDpkuEuA/j65S1D//Ornb3IYyeNNDiN5LIWS1IIlh5GAxhTGhfMXULxEcV5XdlPDFmlkTiRvHAkOUr8pN031xJumma3OYci4TN6oKl3TBAQS1JMJ6k9VNA4B0pJx+sIXakJ68oVejN2GWzdvIVfuXMKJe/fuIWvWrEKc08aVy0CLWkK2moF7MGD8G2jSwJ8cRgIZMtwlQH+f3CWof3718zc5jOTxJoeRPJZCSWrBksNIQGMKY8WKFejcuTOva8WKFfHjjz9y29OBhAapqH374Ne/I6/Sw4hUOD73MurXVuZj00EE4iCQkJ7iSE5RRCBeAqSleNHQCRcIkJ5cgGaCLGzB6yxZsuD+/fu8trt27ULdunW57VKALaRduSTwT3S53QOWI6R9TYwfYSOHkUtQKVN8BOjvU3xkjBOvfv4mh5G8fiGHkTyWQklqwZLDSEBjCqNv376YP38+r+uwYcMwffp0bns6EO8gpXyOFlG+OGzPHvIqHQ+tjOyH1iIk2O//2TsPOCmKLIx/m8hJksBKkAwiLpIXkYyIoIAEEyISlCBZgqQjI0FyzklBgoKBHCW7SkbJiMrpoQgqaeNNjU5t1+7OTPdMs9MzfH2/c+pVvaqt/tejp+ub7iqZxwQJaAk4jSetE9MkoIMAY0kHJLroJsB40o3K7xxfe+01rFixQvZ7xIgRGDRokLQ9TrR4ATgdJasPwTgcLtcKm5aHUjCSVJgwgwCvT2ZQvL9taOffFIzMY03ByDyWSkvagKVgpKDxC6NcuXI4evSo7OuqVavQsmVLaad2wumX1LgxwJLpSndWJryNVqcG29YGULJpkIAk4DSepAcTJKCPAGNJHyd66SPAeNLHyR+9xI9w4sc4x9GgQQNs3LjRYXr+2a0zsH29rD8zrheG5O2Oq5tDkZBwTz4dHhkZibRp00o/JkjAKAFen4wSS31/7fybgpF5/CkYmcdSaUkbsBSMFDSWN/7++29kzpxZ6efp06dRqlQpJS81DadfUhVtfbr9p9KVWUXmo9OGZ5U8GiSgJeA0nrROTJOADgKMJR2Q6KKbAONJNyq/czxw4ACEaOM4wsLCIO630qRJ48jy7HP0CGDFbFl3bcyraJ9vNPbMCEHxotEUjCQZJrwlwOuTtwTvf33t/JuCkXm8KRiZx1JpSRuwFIwUNJY3vvnmG1SoUEH2MzQ0FLdu3fL+pka2aDyR4peU7XU0PJ5faexyTEGs77YT3bvyVzQFDA2FQIrxpHjQIAF9BBhL+jjRSx8BxpM+Tv7oJcShLFmy2J76sa079O9x7NgxlC1b1mF69jl9KjDrfVl3Z/QzaBY+F9M6BaNFkxgKRpIME94S4PXJW4L3v752/k3ByDzeFIzMY6m0pA1YCkYKGssbSRe8rlGjBnbt2uXTfqf4JWXbtQ1VSir9Kp31a0wfmwe1n+aC1woYGgqBFONJ8aBBAvoIMJb0caKXPgKMJ32c/NWrfPny+Pbbb2X3TVkf8p1OwI4Nss0VMe3QNd8QvPFUEMYOjqVgJMkw4S0BXp+8JXj/62vn3xSMzONNwcg8lkpL2oClYKSgsbzRq1cvTJo0SfbTlBsa2ZpniRS/pK5eBepVVBrMk/17nFiXCblycQEjBQwNhUCK8aR40CABfQQYS/o40UsfAcaTPk7+6lWmTBmcOnVK6b72iSOlQK8hdkm78T/p/V7QRMzK2RzFsgFfrYqjYCTJMOEtAV6fvCV4/+tr598UjMzjTcHIPJZKS9qApWCkoLG8Ua1aNXmDITq7fPlyvPrqqz7td4pfUj/8ADRMXA9AdLBB7oPYtFN9Tc2nHecftySBFOPJkj1lp6xOgLFk9RHyr/4xnvxrvIz29qGHHsKNGzeUavG21+uDPN2lIzYWeKKg0t7ZmOKonG8Lgmz/u/BpHI4e2W8v56LXCiYaHhDg9ckDaKlcRTv/pmBkHnwKRuaxVFrSBiwFIwWNpQ3xZZAhQwaIGxjHIXZLe+KJJxymTz5T/JKKicHdiJJIh7uyT5/lHYjG22w7hvAgARcEUownF/4sIgFnBBhLzsgw3xMCjCdPqPlPnWnTpqFbt25Kh8UramJnWo8OsR5Sg5rAT+eV6s3TrsX2LBWwbVIs/rxxwF5GwUhBRMMDArw+eQAtlato598UjMyDT8HIPJZKS9qApWCkoLG0IR6VFo9MOw7xq5dYqFGISL48nH1JHS3XHhHRidvSnitgewx74xRfdpV/2w8IOIsnP+g6u2gxAowliw2In3eH8eTnA+im+7dv30bGjBkVr9q1a2P79u1KniHjzBngxbpAQuIPffNiu6Fv3t6Y0SUOeXPyCSNDPOnslACvT07RWKZAO/+mYGTesFAwMo+l0pI2YCkYKWgsbaxfvx5NmjSRfRS/emkXaJQFqZxw9iW1s2Rn1ApZL3vzY+TbyD9vsLSZIIGUCDiLp5R8mUcCrggwllzRYZlRAowno8T8zz+l18+8Xsdo7Chg2UwJIyq6MuqFf4wu9eNRp+o+ez6fMJJ4mPCQAK9PHoJLxWra+TcFI/PAUzAyj6XSkjZgKRgpaCxtTJw4EX369JF9bNu2LRYuXChtXyVS+pL6w7YMwP8q1UaJMNuva/8ev3f9ADk6tXKY/CSBFAmkFE8pOjKTBNwQYCy5AcRiQwQYT4Zw+aXzfRGM9u0FOibe+9yND0F47nOo9mgQerahYOSXgWLBTvP6ZMFBSdIl7fybglESOF6YFIy8gOeqqjZgKRi5ImWtsg4dOmD+/PmyU2PHjkW/fv2k7atESl9SX0fFoezrhZA2KPEx7PjF6xFcsYKvusm/6ycEUoonP+k6u2kxAowliw2In3eH8eTnA6ij+ykJRl4tfC3+5s2bQGRp5a9XzrQHP2UqgGUD99oW1bYVR0Yibdq0ig8NEjBCgNcnI7R846udf1MwMm8MKBiZx1JpSRuwFIwUNJY2KleujMOHD8s+rl27Fs2aNZO2rxIpfUl9OvtHNJlWRe3SnuNAjhxqHi0SSEIgpXhK4kKTBHQRYCzpwkQnnQQYTzpB+bGbWPRaLH6tPU6ePInHHntMm2Us/ddfQJWSSp3HsxzCT2nzYG7Xw8iZ4x4FI4UODU8I8PrkCbXUraOdf1MwMo89BSPzWCotaQOWgpGCxrJGXFwc0qVLh1ixTeu/x5EjRxAREeEwffaZ0pfUxpZL8eypAbJPd2z7paU/adspxNPtaWVLTAQ6gZTiKdDPmed3fwgwlu4P1we1VcZT4I/8999/j1KlSikn2r17d0yePFnJM2RcvAg0rq5UyZnjPOKCwzC42SmUe/w6BSOFDg1PCPD65Am11K2jnX9TMDKPPQUj81gqLWkDloKRgsayxpUrV1CwYEGlfzdu3EDWrFmVPF8Yyb6k0qTBfx+rhrxBP8juXC74Agp9mbjooyxgggSSEEgWT3xMPwkhmnoJMJb0kqKfHgKMJz2U/NsnOjo62athw4YNw5AhQzw/sYMHgHbNZf3rcZlQJM8pu92mymW88MyPFIwkHSY8JcDrk6fkUq+edv5Nwcg87hSMzGOptKQNWApGChrLGrt370bNmjVl//LkyYP//ve/0vZlIumXVNjxEwh+4wWlSyf7fIIybSspeTRIICUCSeOJ6zqkRIl5eggwlvRQoo9eAownvaT82y/pOkaFCxfGhQsXPD+pDbbdYgd0lvXPxJRAlXxb7Hbdwr+ic+uzFIwkHSY8JcDrk6fkUq+edv5Nwcg87hSMzGOptKQNWApGChrLGkuXLkWbNm1k/5599ll8+eWX0vZlIumX1L1Zy5Bl3lDZpUsxhZBx717kzm1b2ZEHCbghkDSeKBi5AcZipwQYS07RsMADAownD6D5YZWkglGDBg2wceNGz89k/lxg0jBZ/6vo2ng+fJHdLpH1T4zpcYyCkaTDhKcEeH3ylFzq1dPOvykYmcedgpF5LJWWtAFLwUhBY1lj5MiRGDx4sOzfO++8g6lTp0rbl4mkX1K/jv0QBT4eJLt0KOZpVDrzEZcvkkSYcEUgaTxRMHJFi2WuCDCWXNFhmVECjCejxPzT/6233sLcuTaR59+jS5cumD59usM0/jnSJhZ9lNjempjX0CHfKHs76YJisGLwQVSrxl3SjINlDS0BXp+0NKyZ1s6/KRiZN0YUjMxjqbSkDVgKRgoayxrt27fHggULZP8mTpyIXr16SduXiaRfUieGfo4Kn3WTXbqQ8DiKnN4kbSZIwBWBpPFEwcgVLZa5IsBYckWHZUYJMJ6MEvNP/+XLl6N169ay814/0d31bWDnZ7K9GXF9MCjPO9Je2vsA6tevlGztJOnABAnoIMDrkw5IPnbRzr8pGJk3GBSMzGOptKQNWApGChrLGrVq1cKuXbtk/z7++GO0aNFC2r5MJP2SOtN0OMr+sFh26begR5Dz5CFpM0ECrggkjScKRq5oscwVAcaSKzosM0qA8WSUmH/6J10zskCBAhD3yh4fnTsCu7+Q1ZfEdUKPPP2l/X7rY2jzWhkKRpIIE54Q4PXJE2qpW0c7/6ZgZB57CkbmsVRa0gYsBSMFjWWN3Llz49q1a7J/+/fvR9WqVaXty0SyL6knCyvduR2UGRlOfq/k0SABZwSSxRN3SXOGivluCDCW3ABisSECjCdDuPzWWSxwXbRoUaX/d+7cQbp06ZQ83UaSV9LibRVbp/kIX2YV93BB6PnMWfTrVYSCkW6gdEyJAK9PKVGxVp52/k3ByLyxoWBkHkulJW3AUjBS0FjS+Pvvv5E5c2alb1Yat6RfUnHlSiJDULTsb2xQKEJPevHrnGyJiQeBQNJ44hNGD8Ko359zZCzdH64PaquMpwdj5O/evYv06dMrJ3v+/HkUKVJEydNtbLa9kt+rXTL3qOgqeDbvUrxY/ldMGRtOwSgZIWYYIcDrkxFavvHVzr8pGJk3BhSMzGOptKQNWCsJD0onaUgC586dQ/HixaUtEuKLIU2aNEqerwzlSypdeqRt/6LSlUs9luDRDnWVPBok4IyAEk+RXAjUGSfmuyfAWHLPiB76CTCe9LPyd8+CBQviypUr8jTEkgA1atSQtqFEbCzwsu2+6HRUsmrDMRqHI57B2oUPUTBKRocZRgjw+mSElm98tfNvCkbmjQEFI/NYKi1pA5aCkYLGkoa4URFrGDmOwoULQzwybZXD8SUVbPtVrkaf9sm69cem7/FQfvUJqWROzCCBfwk44kmYkRSMGBdeEGAseQGPVZMRYDwlQxKwGQ0bNsTGjRvl+S1dulRZCFsW6E3cvAk0bwRcvajUOBj9FN4uNgeHPrH92MbXrxU2NIwR4PXJGC9feGvn3xSMzBsBCkbmsVRa0gYsBSMFjSUN03fsMPksHV9Sub79BmUWTlJa/zMuHTKfPo+g4CAlnwYJOCPgiCdRTsHIGSXm6yHAWNJDiT56CTCe9JLyf79u3bph2rRp8kRGjBiBQYMGSdujxK1b/4hGV87K6tEJQSiV8wROb81AwUhSYcITArw+eUItdeto598UjMxjT8HIPJZKS9qApWCkoLGkMXr0aAwcOFD2rWvXrsqNjCzwUcLxJVVy4Vzk/XaP0ovlmQfhtYOdlDwaJOCKgCOehA8FI1ekWOaOAGPJHSGWGyHAeDJCy799J0+ejJ49e8qTaNu2LRYuXChtjxO2NSlRuYRSvVbGrVizsTBy5PBwUW2lNRoPKgFen6w/8tr5NwUj88aLgpF5LJWWtAFLwUhBY0mjY8eOmDdvnuzbhAkT0Lt3b2n7OmH/ktq7F9V6dUSa2LuyO5/EvIwvGr2P+R+EyDwmSMAdAd70uCPEcr0EGEt6SdFPDwHGkx5KgeGzbt06vPhi4nqM1apVw17bfY7Xx9WrQL2KSjMls0Zh7YLseKxUWiWfBgkYIcDrkxFavvHVzr8pGJk3BhSMzGOptKQNWApGChpLGvXq1cO2bdtk31auXIlWrVpJ29cJ8SV1bM0aVBrdV+nKk5n34YVm+TG0LwUjBQwNlwR40+MSDwsNEGAsGYBFV7cEGE9uEQWMw6FDh1ClShV5Prly5YK4d/b62L0L6PyqbEa8tl8wz/dYPTQedWtRMJJgmDBMgNcnw8hSvYJ2/k3ByDz8FIzMY6m0pA1YCkYKGksaxYoVg9jS1XF4tVuHoxETP8WX1Mlly1B+0lDZ6u34UIQ/fAET2gWhXWsKRhIME24J8KbHLSI66CTAWNIJim66CDCedGEKCKfLly/j0UcfVc7lzp07SJfOy9fG5s0BJg+X7UZFV0G98FWY8lYcXn+ZgpEEw4RhArw+GUaW6hW0828KRubhp2BkHkulJW3AUjBS0FjOiI+PR1hYGMSn4zh9+jRKlSrlMH3+Kb6kTnz0ISqMVxeEfCjXD1jxXjAa1g/2eR/ZAf8hwJse/xkrq/eUsWT1EfKv/jGe/Gu8vOnt7du3kTFjRqUJU+6X/zMYWJ24FtLqmNfRMd8I9H0hDgN6UjBSgNMwRIDXJ0O4fOKsnX9TMDJvCCgYmcdSaUkbsKZ8ASqt0zCTwPXr120LIeZQmhTjJx6PtsohvqQujxmNEqvnK10SgtH2KSF48gnukKaAoeGSAG96XOJhoQECjCUDsOjqlgDjyS2igHIQ917iHsxxHD58GBUrqusPOcp0f06dDMwZL923RTdEi/BZeLlSHGaOo2AkwTBhmACvT4aRpXoF7fybgpF5+CkYmcdSaUkbsBSMFDSWM86cOYOSJUvKfgUHByM6OhohIdZ5zUt8Sd1o2xoPH9sn+ykSD+W8jFOrQpEvDwUjBQwNlwR40+MSDwsNEGAsGYBFV7cEGE9uEQWUg9il88CBA/Kc1q9fj+eff17aHiXWrQEGd5dVv4suhcjwTaiaPwFfLguT+UyQgFECvD4ZJZb6/tr5NwUj8/hTMDKPpdKSNmApGCloLGeIXTmqV68u+1WoUCFcunRJ2lZIiC+pv1s2QY7zx5XuZLc9YfS/baEIDVWyaZCASwK86XGJh4UGCDCWDMCiq1sCjCe3iALK4ZVXXsFHH30kz2n27Nl46623pO1R4tBB4M3E3df+WfT6DB7JmIATX1Aw8ogpK9kJ8Ppk/UDQzr8pGJk3XhSMzGOptKQNWApGChrLGWvXrkXz5s1lv2rWrImdO3dK2woJ8SUVW6sqMt78VXZnRlwfTHv0HXy/kWqRhMKELgK86dGFiU46CDCWdECii24CjCfdqALCsV+/fhg3bpw8l8GDB2P48MQFq2WBkcSPV4AGVZUa+R46hZiwjPjfjjAE8YFshQ0N/QR4fdLPylee2vk3BSPzRoGCkXkslZa0AUvBSEFjOWPmzJno0qWL7Ffr1q2xdOlSaVshce/2HYRVLIZgJMjuNEn3Ke6WKodNyykYSShM6CLAmx5dmOikgwBjSQckuugmwHjSjSogHKdMmYIePXrIc2nbti0WLkxcsFoWGEnExAARhZQaNTNuw7EMxfDjF6HIpK6zrfjRIAFXBHh9ckXHGmXa+TcFI/PGhIKReSyVlrQBS8FIQWM5Y8iQIRgxYoTsl/jFa+zYsdK2QiL64kWkaZz42pzoU+Fsx1C9/ENYMtU6ay1ZgRX74J4Ab3rcM6KHPgKMJX2c6KWPAONJH6dA8Vq9ejVatmwpT6dWrVrYsWOHtD1OVC0L/Pm7rN4jeCaW5HgOR5eFoGB+PmIkwTBhiACvT4Zw+cRZO/+mYGTeEFAwMo+l0pI2YCkYKWgsZ3To0AHz5yfuPjZ58mR07564YKIVOhy9dQvS9Ggru3IzLj0K5fkO7WsEY/wwCkYSDBO6CPCmRxcmOukgwFjSAYkuugkwnnSjCgjHpGtI5s+fH1eu2F4p8/awrfmIU1/LVm7Hh+L19Kvw3qLK3FVWUmHCKAFen4wSS31/7fybgpF5/CkYmcdSaUkbsBSMFDSWM5599lls2rRJ9mvlypVo1aqVtK2QiB07CqHLZsquREVXQb3wVejfNAj9ulMwkmCY0EWANz26MNFJBwHGkg5IdNFNgPGkG1VAOJ4/fx7FihVTzkXsUhsW5uXi1NOnArPeV9q9lxCMqKF7Ua1VQSWfBgnoJcDrk15SvvPTzr8pGJk3DhSMzGOptKQNWApGChrLGRERETh27Jjs19atW1G3bl1pWyER/1xdBF/+TnZlalw/DM3TGRPaBaFdawpGEgwTugjwpkcXJjrpIMBY0gGJLroJMJ50owoIxz///BNZs2ZVzkWISEWKFFHyDBs20QmdOwAHtilVj9UciidmdFTyaJCAXgK8Pukl5Ts/7fybgpF540DByDyWSkvagKVgpKCxnJEjRw5cv35d9isqKgrly5eXts8TN28CkaWVbogFr3dnLoeFfYLRtFGwUkaDBNwR4E2PO0Is10uAsaSXFP30EGA86aEUOD4JCQkIDlbvYV5++WV8+OGH3p+kbfHrv54oi8xBf8q2dlebgBpzX5Y2EyRghACvT0Zo+cZXO/+mYGTeGFAwMo+l0pI2YCkYKWgsZcTGxiZ79PnChQsoXLiwdfq507YAZNfWsj934kOQP9cZxAWHYcPoYFSPVG+2pCMTJOCEAG96nIBhtmECjCXDyFjBBQHGkws4AVoUlMI+90JI8vq4dQuoVFxpZm69jeg42bYgNg8S8IAAr08eQEvlKtr5NwUj8+BTMDKPpdKSNmApGCloLGX8/vvvyJkzp9InkZc9e3Ylz6fGujXA4MRFuM/FFEOlfP88Zv3VzBCUKc0dP3w6Pn74x3nT44eDZtEuM5YsOjB+2i3Gk58OnBfdvm+C0bffAK2flz2LSQhCn4bnMGVCepnHBAkYIcDrkxFavvHVzr8pGJk3BhSMzGOptKQNWApGChpLGeJpoqJFiyp9Ek8dhYRYaF2grw8DbzSVfRQLN+bNdQEJQcE49VEI8uWlYCThMKGLAG96dGGikw4CjCUdkOiimwDjSTeqgHFMKhjVq1cPW7Zs8f78li4G3h8o2/kuuhRG1tuEFTNDZR4TJGCEAK9PRmj5xlc7/6ZgZN4YUDAyj6XSkjZgKRgpaCxliPWKKlasKPuUK1cuiLGz1HHjD6BaGaVLlTPtwdn0BfHjF6HIlFEpokECbgnwpsctIjroJMBY0gmKbroIMJ50YQoop44dO2LevHnynAYNGoQRI0ZI2+NEnx7AxtWy+uqY17G4ygh8sZSCkYTChCECvD4ZwuUTZ+38m4KReUNAwcg8lkpL2oClYKSgsZQhdkSrX7++7JPYMe3IkSPStkoioWJpBN22LX797/F26AKseqguft8Ralsw0pHLTxLQR4A3Pfo40cs9AcaSe0b00E+A8aSfVaB4TpgwAe+++648nU6dOmHmzJnS9jhROxL49QdZfWDQBOwo3gIH1lEwklCYMESA1ydDuHzirJ1/UzAybwgoGJnHUmlJG7AUjBQ0ljJWrVqFl156SfapQYMG2Lhxo7Stkoh//WUEf7NHdmdpbEf0DR+IX2yCEQ8SMEqANz1GidHfGQHGkjMyzPeEAOPJE2r+XWfx4sVo27atPIlmzZph7dq10vYo8fffQOUSStW6GTbhxxylcGYT75sUMDR0E+D1STcqnzlq598UjMwbBgpG5rFUWtIGLAUjBY2ljFmzZqFz586yT23atIG4ebHaETttCkJnj5Pd+m9sLtQs9DXObA6TeUyQgF4CvOnRS4p+7ggwltwRYrkRAownI7QCw3fDhg144YUX5MlERkZi37590vYoEfU10KaJrCoWvM6b85xtfcow/LqTgpEEw4QhArw+GcLlE2ft/JuCkXlDQMHIPJZKS9qApWCkoLGUMWrUKIj35R1H7969IR6PttoRfeok0rR8RulWh7ybMW+buraR4kCDBJwQ4E2PEzDMNkyAsWQYGSu4IMB4cgEnQIuEOPTUU0/JsytQoADEfbNXx+KFwPjBsolb8WF45OHzdvvatlCEUjOSbJjQT4DXJ/2sfOWpnX9TMDJvFCgYmcdSaUkbsBSMFDSWMnr27InJkyfLPo0ZMwb9+/eXtlUS9+7exb2K5ZEl/obs0pqMvdH8cC9pM0ECegnwpkcvKfq5I8BYckeI5UYIMJ6M0AoM3++++w6lS5eWJxNsW5gxJibGtj6jFws0Tv4AmDdRtikSOXOcR1xwGC6tD0W2rEoRDRLQRYDXJ12YfOqknX9TMDJvKCgYmcdSaUkbsBSMFDSWMl577TWsWLFC9mnOnDkQO3ZY7RBfUjcrVkfuuJ9l184FV0KxE59ImwkS0EuANz16SdHPHQHGkjtCLDdCgPFkhFZg+P7yyy/ImzevcjI3b95ElixZlDxDxulTQIvEDU1E3RoZt+F4hmI4sSIEj4QHGWqOziQgCPD6ZP040M6/KRiZN14UjMxjqbSkDVgKRgoaSxnPPPMMtmzZIvv08ccfo0WLFtK2SkJ8SX1X6y1E3Nwqu3Q2zVMofmSVtJkgAb0EeNOjlxT93BFgLLkjxHIjBBhPRmgFhq8Y83Tp0iknc/nSZRQsVFDJM2w8XgCIj5PVGqX/DPsylUXUwhAUKUzBSIJhQjcBXp90o/KZo3b+TcHIvGGgYGQeS6UlbcBSMFLQWMooX748vv32W9mnzZs3o3599VcpWejDhPiS+qFKcxSPTuzr9gLvos7GHj7sFf+0vxLgTY+/jpz1+s1Yst6Y+HOPGE/+PHqe9z1Tpky4deuWbEDcl5UrV07aHiWqlgX+/F1W7RoyByuyN8C+2SEoXZKCkQTDhG4CvD7pRuUzR+38m4KRecNAwcg8lkpL2oClYKSgsZRRsGBBXLlyRfZp//79qFq1qrStkhBfUndtN09Zg27KLq2qtACtFjWQNhMkoJcAb3r0kqKfOwKMJXeEWG6EAOPJCK3A8S1TpgxOnbK9RvbvsW3bNtSpU8dhevb55uvAoe2y7mfRzfF6+ETsnBaCiMcpGEkwTOgmwOuTblQ+c9TOvykYmTcMlhOMrl+/jhMnTuDo0aM4fPgwduzYAfF+szh69eqFiRPVRezcodi7d699m/Tdu3fbd10QAkGNGjXwxhtvKLsyuGvHaLk2YCkYGaWXev5p06ZFdHS0/IMi9sSNi9WOe7Z/F2mrP650a/ZzO/H2uOJKHg0S0EOANz16KNFHDwHGkh5K9NFLgPGkl1Rg+Yknu7duTXzlftWqVWjZsqV3J/mx7ZX9YYkbg9yMS49Ceb7DpgkhqFzBiwW1vesVa/sxAV6frD942vk3BSPzxstyglFQkHPV34hgFB8fjwEDBmDcuHFOafXr1w+jR4/2bicGJ61rA5aCkRNIPs4WQpEQjLTH5cu29+ZtoqLVjugLF5Dm+aeVbk1o/T369M+s5NEgAT0EeNOjhxJ99BBgLOmhRB+9BBhPekkFll/r1q2xfPlyeVIzZ85Ep06dpO1R4vw54IWaStUcOS/i07FhqF6VgpEChoYkcOTqUZTLFyFtbUJcn7766it7VmRkJDJkyCCLXdWTTkzcdwLa+TcFI/NwW1owKlmyJCIiIrBy5Ur7GRsRjCZMmIB3333XXq9mzZro27cvChQoYH/9SIhIu3btspcJv969e9vTZv5HG7AUjMwka15b4mm2HDlyKA3+/vvvyJ49u5JnBePetWtIW1P9Apv7ymF0HBhuhe6xD35GgJMyPxswC3eXsWThwfHDrjGe/HDQTOiyuL+fNGmSbGnUqFF47733pO1R4uQJoFXia/t34kOQ7+GLWPOfYNSpScHII6YBXmnqwenovn8Y5j49Bh0qtE92tmLeIHb0Ez84Z86c2f4GjBCN5kXNR8c9AzAlcii6VemarB4zUo+Adv5Nwcg87pYTjKZMmWIXiR5//HH7xP3q1asID/9nUqxXMBICTZEiRRAXF4e6devi888/V54kuXv3Lho3bgzxjnRISAguXbqE/Pnzm0fV1pI2YCkYmYrWtMbEuBQqVEhpT9yspkmTRsmzgnHPFrPBTxZFWFCC7M6qFzei1XDboo48SMAgAU7KDAKju1MCjCWnaFjgAQHGkwfQAqDK0KFDMXz4cHkm4g0B8QaAV8eB/UD7xF1vr8VmQ/G8x7BiYDAa1qNg5BXbAKwsnhB6cmU9eWYpiUYrVqzAa6+9Jn3Ezso3Hr1pF4scmd++tNXpE0oOH37ePwLa+TcFI/M4W04wSnpqnghGgwcPxsiRI+1NHTt2DGXLJp9UHz9+HE888YTdR/hrv6iS9sETWxuwFIw8IXj/64gFFrXrFQmhSNysWvEQ/forogJyBl+X3dv03DI0GFdb2kyQgF4CnJTpJUU/dwQYS+4IsdwIAcaTEVqB46t9K0CcVdeuXTFt2jTvTnDrFqBHW9nGpZhCeDLfbizsE4ymjSgYSTBMSAKOJ4UcGUlFI/HGilgT13EU6VgCF0r87jCdPpkkHZi47wS0828KRubhDjjBKCEhAUWLFsXFixdRsWJF+8LZznCJ8qioKLv/2bNn4Wr9JGdtOMvXBiwFI2eUfJt/8OBBZUc08ZSZdsc03/ZO/espCUb/y1YeufdtUB1pkYAOApyU6YBEF10EGEu6MNFJJwHGk05QAeY2e/ZsZc2iNm3a2Des8eo0160BBneXTRyPjkCN8PWY9U4wXnqRgpEEw4RCwJlo9N1336F06dKJvs/a3kaom0XaScUlWcBEqhLQzr8pGJmHPuAEo59//hmPPPKInZB4/1m8B+3sEOVjxoyxF//000/y1Tdn/kbytQFLwcgIudTz3bx5Mxo0SHy/PVu2bPjjjz9SrwMG/pK4ib4TURbZgv9Wax29DISFqXm0SMANAU7K3ABisW4CjCXdqOiogwDjSQekAHRZtmwZXn/9dXlmTZo0wSeffCJtjxKTJgLzP5BV90bXQuPwxRSMJBEmnBF4dmQjbMpwSBZnjQpGyOZYiDWM7EcSsUiU5/o6UTx66aWXMGLECFmfidQjoJ1/UzAyj3vACUbiUUHxyKA4Fi9eDPErhbNDlLdt+8/jqnv27EH16tWduRrO1wYsBSPD+FKlQo8ePSDWzNIe4gk1Kx7iJnp3xf6oH/ex2r1R04EmTdU8WiTghgAnZW4AsVg3AcaSblR01EGA8aQDUgC6CHGoWbNm8sxq166N7du3S9ujxIuNge+/lVVnxvXGwDzdKBhJIkykRECscys2xLldI1Z5ggjb/gQ2RgNJxCKZr2ksY8aM+O2335AuXTpNLpOpQUA7/6ZgZB7xgBOMVq1aBaHsikM8QVK/fn2ntLZs2YJnnnnGXi52YmvVqpVT36QFIiBdHddsu1o51sc5d+6c6Ytqu/rbLNNHIKULufiisOIhbqK7tLyEZT82VLoXH14EMRts7+kHBSn5NEjAFQERT998843dpXz58sqmAK7qsYwEkhJgLCUlQtsbAownb+j5b12xCU2jRo3kCZQrVw4HDhyQtuGEbRerNFVLwTbJkVVbpf0YW7JUxtS349CSv7NJLkyoBE6ePGlf0sT+A3JScehOPJBe8zqjQ0RSm7AvcfL111/LeWCSYpr3kYAQiQoWLGj/CxSMzAMdcILRggUL0L79P1sh7t27F9WqVXNKS5Q7nipauHChfNrIaQVNgZH1jtasWWPJrdo1p/NAJlu3bg3xCqP22LFjh9a0VPo/0x/HY+cPY2ZsB6Vfx97ui+tlyip5NEiABEiABEiABEjAHwgcOXIEvXv3ll0tUKCA/S0BmWEwEWTbJblmd/UNgw6hi7DmodroUvsc6lT/xWCLdH+QCIgNkwYOHIjbt28nf6LIAcKJWJQhQwb7ciiOjZUc7vxMHQLitcHmzZvb/xgFI/OYB5xgNGPGDPvuCgLRoUOHUKlSJae0Dh8+jMqVK9vLRb3OnTs79U1aQMEoKRH/sxctWgTx3rzjEIulz50712Fa7nP4jDI4ei0bov5bG0XCLsr+/ZG/BI72GyxtJkiABEiABEiABEjAXwiICXrPnj1ld8PDw5X7M1lgIFFuzDBk+/mcrLEluhFahc+gYCSJMOGKgBAb/vOf/+DMmTPAyOzqk0XiSaNB/65npGmkRIkS9joPP/ywJpfJ1CRAwej+0A44wSi1njDiK2n3JyBTs9VJkyZhwIAB8k926dIFEyfaFkm04CEe02/a7h6+vfYQul1biWHop/Ty3mbb4ny5cil5NEjAGQG+9uGMDPONEmAsGSVGf1cEGE+u6ARu2f79+yHWLXIchQsXxunTpx2mR5/Btl3Swkb2lXWvx2VGkTwnMa1THFo0kdlMkIBTArdu3ULDsY1xKM/Z5D5JnjB68803MX78eIj1i3j4jgBfSbs/7ANOMEqtNYzcDYd20S0ueu2Olm/KxQ56gwYNkn/83Xffxbhx46RtpYS4iW70+k1E/foQZl8dilZhS9Tu7TkO2yp9ah4tEnBCQMSTuEEXR2RkJNcwcsKJ2e4JMJbcM6KHfgKMJ/2sAsnz4MGDqFq1qjylQoUK4dKlS9L2KLHc9gT5mP6y6q+x2VEy7xHM7haMVs0069BIDyZIQCUwL2o+Ou5J/GEZLtYw2rVrF2rUqKE2QCvVCWjn33wlzTz8AScYcZc084Ij0FsaMmSIsu2leF955MiRljxtcRP98itX0eH4BNsGDZ+qfaxUC1i0XM2jRQIuCHBS5gIOiwwRYCwZwkVnNwQYT24ABWixdokIcYr58+fHlStXvDvbV1sCR/fJNtbFvIJ2+cZQMJJEmHBFIJlY5HiiKOlC2P/mi1cqP/jgA1dNsiwVCFAwuj+QA04wEosYP/LII3Za7733nn3hMWfoRPmYMWPsxT/99BPEO9NmHdqA5RNGZlE1t53+/fvj/fffl40OHz4cgwdbcy2ge7Z3qX+v2Rj5gtVFuu2dX7AGqJL4y5w8ISZIwAkBTsqcgGG2YQKMJcPIWMEFAcaTCzgBXLRv3z489dRT8gyLFSuGs2dTeA1IerhJxMQAEY/anBKk45thS/FJthoUjCQRJpwRcCoWOSqkIBplO5AB4omWNGnSOLz46QMC2vk3nzAybwACTjAS2yCKxYsvXrxo3xZR/Grh7BALYottD4W/+GIyspC1szYd+dqApWDkoGKtT/FrwOTJk2WnhHjUt2/i++6ywAKJ2HFjEbpkWvKedLE9Ktu5a/J85pCACwKclLmAwyJDBBhLhnDR2Q0BxpMbQAFaLHaorVOnjjy7iIgIiJ3TPD7u3AEqFFWq18y4DccyFMOid4PR5Dm+kqbAoSEJuBOLxC5oYjfuWT8tQky1tLIebE8a7eq3ha+lJRLxSUo7/6ZgZN4QBJxgJNCIp0QcrxaJnRfKlk2+5fjx48fh2PJQ+IunS8w8tAFLwchMsua1JXbFmzVrlmxQiEfdu3eXtpUScX17I+SLlbJLf8alw/7Gc9FgfOINlixkggTcEOCkzA0gFusmwFjSjYqOOggwnnRACkCXjRs3omHDhvLMxNp64qkjr46nngT++FU20SN4JpbkeA4rBgajYT0KRhIME5JAUrGo5o0nsGvEdlkudtYWPzbnzp3b/tpkrTH18dNjf8nyWjcisGP4VmkzkfoEtPNvCkbm8Q9IwUgINGKHhfj4eNStWxeff/65sqiruCFp1KgRtm3bhpCQEPvTSAUKFDCPqq0lbcBSMDIVrWmNtWvXDgsXLpTtzZw5E506dZK2lRKxE8cjdGHi01Bbo5/DyZ6z0LNziJW6yb74CQFOyvxkoPygm4wlPxgkP+oi48mPBsvErn766ado2rSpbFHcu2/d6uXE++32wFcbZZsLYruiT953sWZYMOrUoGAkwTBhJ3Dk6lE8ubKepDH36TEodbckXnnlFfz444/o0KEDxo4dC/EggjiEqBkXF4c6w+rj4MNnZL1vX9qKcvkipM1E6hLQzr8pGJnH3nKCkXgEVQgsjuP69esQE3txCJHHkXaUN2nSxJFUPidMmACx65U4atasiX79+kGIQmIRPfHqkVjNXhzCr3fv3va0mf/RBiwFIzPJmtfWG2+8gSVLlsgG58yZg44dO0rbSomYD5cjbFQ/2aUT0WWxodPnGNiLgpGEwoRuApyU6UZFRzcEGEtuALHYEAHGkyFcAeOs3eFYnFTjxo2xYcMG785v+hRgVuLOt/ujn8Zz4cvw2ZhgPFWVgpF3cAOz9tSD09F9/zAIsahDBZvgaDtu3LiBnTt3Qsw3o6Ojk+0wKx5O6LykK+b8sRpTIoeiWxUuE+HL6NDOvykYmTcSlhOMhHhjZJV5sWZRSof4BywWNR4/fnxKxfY8sV6NWPQ6ONj8Lw5twFIwcjoEPi3wJ8Eoevs2pOnWRvK6FpsNU9scx4j3KBhJKEzoJsBJmW5UdHRDgLHkBhCLDRFgPBnCFTDO4sc7cU/mOFq2bAkhInl1LJgPfDBUNnE6+jFUC/8SWz4IRsUnzb/vl3+ICb8mIJ40cvaEkKvrk6t6fg3EzzqvnX9TMDJv8AJWMHIg+uqrr7B48WL7E0XikUKxVad44qht27bKjgwOf7M+tQFLwcgsqua2I2JAxIbjmD17Nt566y2HaanP6JMnkabVM7JP8bZU/yYXMG5UOpnHBAnoJeDqpkdvG/QjAUGAscQ4MJMA48lMmv7T1ty5c5X7rzZt2ij3Zx6dSX/bWwaffSirbohuiTbh47F7egjKlgmS+UyQgF4CvD7pJeU7P+38m4KReeNgOcHIvFPzbUvagKVg5NuxcPbX33zzTSxatEgWiwWw3377bWlbKXHv2jWkram+Ez3o6UMYOesRK3WTffETArzp8ZOB8oNuMpb8YJD8qIuMJz8aLBO7OnXqVGXTEfHjnfgRz6ujzStA1G7ZxJiEYRiX+w0cnBuCEsUpGEkwTOgmwOuTblQ+c9TOvykYmTcMFIzMY6m0pA1YCkYKGssY/rTo9b27dxFUvhjSQDxb9M8x5onPMeDDcg6TnySgmwBvenSjoqMbAowlN4BYbIgA48kQroBxFstHiGUiHEe3bt0wZYptDSJvjsb1gYunZAt9gqdiQY4X8M3iEBQuRMFIgmFCNwFen3Sj8pmjdv5Nwci8YaBgZB5LpSVtwFIwUtBYxmjfvj0WLFgg+zNjxgx07txZ2lZKiC+p6PJPIHNC4vad44quRN/11a3UTfbFTwjwpsdPBsoPuslY8oNB8qMuMp78aLBM7OqIESMwZMgQ2aIQj8QGNV4dTz0J/PGrbKJt2DJ8mu1pnPwwBOH5KBhJMEzoJsDrk25UPnPUzr8pGJk3DBSMzGOptKQNWApGChrLGGKLzPnzbYsi/ntMnz4dXbp0cZiW+hRfUrcqVUX22MSbn0l556DntkaW6ic74x8EeNPjH+PkD71kLPnDKPlPHxlP/jNWZvZ04MCBGD16tGxSiEfDhg2TtkeJsoWAuBhZtUfwTCzJ8Rx+2BCKLFlkNhMkoJsAr0+6UfnMUTv/pmBk3jBQMDKPpdKSNmApGCloLGN07NgR8+bNk/2ZNm0auna15naY4kvqt8hnEH73nOxvVHRVVHjxUaBdB6BYcZnPBAm4I8CbHneEWK6XAGNJLyn66SHAeNJDKfB8ku6QLMSjAQMGeHei1Wyv7N/4n2wjKroK6oWvwm/bQxHCDWYlFyb0E+D1ST8rX3lq598UjMwbBQpG5rFUWtIGLAUjBY1lDLGootiZw3GIRRffeecdh2mpz5jPNuBS7w9QPCxRMJIdDLI9Wj3BJnw1eFZmMUECrgjwpscVHZYZIcBYMkKLvu4IMJ7cEQrMcrHhyJw5c+TJTZo0CT169JC2R4khA4G1i5WqZXMcx/E9OZQ8GiSglwCvT3pJ+c5PO/+mYGTeOFAwMo+l0pI2YCkYKWgsYyS9QRELLIqFFi13nDuLhKa1cTm6AMJDryBNUELyLgrR6JMdfNIoORnmpECANz0pQGGWRwQYSx5hYyUnBBhPTsAEeHbLli2xevVqeZZiB9s33nhD2h4lNm0EereXVaMTglC5wDkc2ZRe5jFBAkYI8PpkhJZvfLXzbwpG5o0BBSPzWCotaQOWgpGCxjJGp06dlG1bJ0+erGzrapmO9n8X+OxD9915/lVgzDj3fvR44AnwpueBDwHTADCWTEPJhmwEGE8PZhjUqVMHO3bYfvT691i3bh2aNm3qMD37fN+2JtLSGbLu17bX+HtFrMRXq0NlHhMkYIQAr09GaPnGVzv/pmBk3hhQMDKPpdKSNmApGCloLGOIHdFmzZol+2NJwSg+HoiwrVMUFyv76TQRYrsJOnoJCA526sICEhAEeNPDODCLAGPJLJJsRxBgPD2YcVC2bFmcOHFCnvy2bdsgRCSvjkb1gEunZRNT4vtjR5VOWL+IgpGEwoQhArw+GcLlE2ft/JuCkXlDQMHIPJZKS9qApWCkoLGM4ReC0Z07QIWi+plFnQfS83Fr/cAeTE/e9DyY434/zpqxdD+oPrhtMp4ezLHPkycPxOTOcRw+fBgVK1Z0mMY/Y2JsP7YVUuq9kmYlwqpHYslUrnitgKGhmwCvT7pR+cxRO/+mYGTeMFAwMo+l0pI2YCkYKWgsY3Tp0gUzZ86U/TFlkUXZmkkJPmFkEkg2oyXAmx4tDaa9IcBY8oYe6yYlwHhKSiTw7XjbfU5YWBjEp+P4/vvvUaJECYdp/DMuDihbQKnXLN06FGhQAZNHUTBSwNDQTYDXJ92ofOaonX9TMDJvGCgYmcdSaUkbsBSMFDSWMa5evYq//voLQbYFo8X/s2fPjhw5LLh7BtcwskzMBEpHeNMTKCPp+/NgLPl+DAKpB4ynQBpNfedy69YtZMqUSXH++eefkS9fPiXPkJHCE0Z1M2xCtealMawfBSNDLOksCfD6JFFYNqGdf1MwMm+YKBiZx1JpSRuwFIwUNDSMEvh3lzTbP1bnNblLmnM2LElGgDc9yZAww0MCjCUPwbFaigQYTyliCejMX375BXnz5lXOUfyYl1REUhzcGZcvA89VU7zyZT+NgW0yoUt7CkYKGBq6CfD6pBuVzxy1828KRuYNAwUj81gqLWkDloKRgoaGBwRiPtuAkP6dEYwURCMhFk2YBzR41oOWWeVBJMCbngdx1O/POTOW7g/XB7VVxtODN/Jnz55VXj8TT3zHxsba9u/wYgOPPbuBTq9ImNfjMqNInpOY2yMYLZp40a5skYkHkQCvT9Yfde38m4KReeNFwcg8lkpL2oClYKSgoeEBAfEldXzVKuTf/AUePnEQQWLXNLEr2nOtgDfbA8WKe9AqqzyoBHjT86COvPnnzVgyn+mD3CLj6cEb/aioKGWB61y5ckHcQ3t1LFsCjH1PNnE0ujxqha/DuhHBqFWdgpEEw4QhArw+GcLlE2ft/JuCkXlDQMHIPJZKS9qApWCkoKHhAQHlS6pKFaQVbaS1/debX+A86AerBAYBJZ4iI22hZI+owDg5nkWqEmAspSrugP9jjKeAH+JkJ7hjxw7UqVNH5pcpUwYnTpyQtkeJgf2BT5fJqutiXkG7fGOwZ2YIHi9teyqbBwl4QIDXJw+gpXIV7fybgpF58CkYmcdSaUkbsBSMFDQ0PCDALykPoLGKUwKMJ6doWGCQAGPJIDC6uyTAeHKJJyALP/30UzRt2lSeW61atSBEJK+OF2yv6J8/LpsYlTACE3K/jlMrQ5AvDwUjCYYJQwR4fTKEyyfO2vk3BSPzhoCCkXkslZa0AUvBSEFDwwMC/JLyABqrOCXAeHKKhgUGCTCWDAKju0sCjCeXeAKycPHixWjbtq08t+bNm2P16tXSNpyIjgaeLAxoNgppkXYNtmWpiF82h9ofzjbcJiuQgI0Ar0/WDwPt/JuCkXnjRcHIPJZKS9qApWCkoKHhAQF+SXkAjVWcEmA8OUXDAoMEGEsGgdHdJQHGk0s8AVk4ZcoU9OjRQ55bhw4dMHfuXGkbTvx2DagRoVQrlO0YYtJlxc/bw5R8GiRghACvT0Zo+cZXO/+mYGTeGPwfAAD//3Kx8Q0AAEAASURBVOydebxVU//HP3do1kiDRAOZCikZmmhQkSJpJKHkUU9KoQnhVyqSMoSopEEpkUIpScgjQ1EeKUOiHhRSSu74O/tyd2vdc/a+Z62z9r7nnP05fzhrre9a373Xe31ed7U+ztknJTf0Al/GCfz888+oWrVqXt7vvvsOJ5xwgvFrMGFwCPz1119Yv3593oSbNGmCEiVKBGfynKlxAtSTcaSBTUgtBXbpPZk49eQJ1rhOetddd2Hs2LH2PY4YMQLjx4+368qFH74H2p0vDat89DbUqlgcHy4tJrWzQgIqBPj3SYVW0fQVz98//fQTqlSpUjQ3kmRXTaFh5M2KioKlYeQN4yBl5SYVpNX2fq7Uk/eMg3IFaikoK+3PPKknfzjH01X69++Pp59+2r6lhx9+GEOGDLHryoWvvwI6XSgNq1h5By6sk4uXZxaX2lkhARUC/PukQqto+ornbxpG5taAhpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyuepAxedtllePXVV+25zZ07F1dffbVdVy58/jnQra097HBOGo6t+g36NM3BlHE0jGwwLCgT4N8nZWS+DxDP3zSMzOGnYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15IonKYMNGjTAp59+as9t5cqVaNv2iOFjB6ItfPIx0LuT1LviMTsw+qoc3DaIX+eXwLCiRIB/n5RwFUln8fxNw8jcEtAwMsdSyiQKloaRhIYVDQLcpDSgcYgjAerJEQ0DigSoJUVg7O5KgHpyxZOUwXLlyuHAgQP23D7++GM0bNjQrisX1r8H3NhNGjYwbTqa3d0GPa+iYSSBYUWJAP8+KeEqks7i+ZuGkbkloGFkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKJ+mCf/75J0qXLi3Na8eOHahZs6bUplQJjUeHptKQadlDUX/Gv9GiKQ0jCQwrSgT490kJV5F0Fs/fNIzMLQENI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxJF9y1axdq1KghzeuPP/5AmTJlpDalivXjz/XlnMNSH8W/XuqAuifRMFJiyc4SAf59knDEZUU8f9MwMrdENIzMsZQyiYKlYSShYUWDADcpDWgc4kiAenJEw4AiAWpJERi7uxKgnlzxJF3QenaR9Qyj/Ffx4sVx+PBhpKSk5Depv+/dC1x4ljTugqPWYuXqE1CuLA0jCQwrSgT490kJV5F0Fs/fNIzMLQENI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxJF3zzzTfRpk0be1716tXDli1b7LpWYe1aYOCRX1k7mFMMp1Xbgu0riqFECRpGWkw5KI8A/z7FvxDE8zcNI3PrRcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVT9IFFy5ciB49etjzateuHVasWGHXtQq3DgLeWGIP/SCjKQad9hTeWVSahpFNhQUdAvz7pEPN3zHi+ZuGkTn2NIzMsZQyiYKlYSShYUWDADcpDWgc4kiAenJEw4AiAWpJERi7uxKgnlzxJF1wwIABeOKJJ+x51a9fH5s3b7bryoUPNwDXdZaGTc0Zgbcad8HCp4+mYSSRYUWVAP8+qRLzv794/qZhZI4/DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8SReM9KyiXOuh1TqvzMzQr6O1BnZ9bY/en10SZx79AS5r8jseGluDhpFNhgUdAvz7pEPN3zHi+ZuGkTn2NIzMsZQyiYKlYSShYUWDADcpDWgc4kiAenJEw4AiAWpJERi7uxKgnlzxJF2woGHUvHlzrFu3Tm+eLywE7h0qjR2dMgnTjumK2ztsxbBb6tIwkuiwokqAf59UifnfXzx/0zAyx5+GkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56kC9atWxdfffWVPa/ly5ejQ4cOdl2pMGwwsGKxPWRXVjWcUe195KakYvL1n6BXj7NoGNl0WNAhwL9POtT8HSOev2kYmWNPw8gcSymTKFgaRhIaVjQIcJPSgMYhjgSoJ0c0DCgSoJYUgbG7KwHqyRVPUgUzMjJQsmRJiF9B++KLL3DqqafqzXPObGDCKHtsTqjUsNz7+K5Edcwfvh6tWp1Hw8imw4IOAf590qHm7xjx/E3DyBx7GkbmWEqZRMHSMJLQsKJBgJuUBjQOcSRAPTmiYUCRALWkCIzdXQlQT654kir49ddf46STTpLmdPDgQZQuXVpqi7ryxwGg6ZlAVoY9ZFLOnXis+rWYdecGNGnShIaRTYYFHQL8+6RDzd8x4vmbhpE59jSMzLGUMomCpWEkoWFFgwA3KQ1oHOJIgHpyRMOAIgFqSREYu7sSoJ5c8SRVcM2aNWjdOvSQ6n9etWrVwrfffptf1Xu/4Vrggzftsc9m3YxZ9f+Fe/69mYaRTYUFXQL8+6RLzr9x4vmbhpE57jSMzLGUMomCpWEkoWFFgwA3KQ1oHOJIgHpyRMOAIgFqSREYu7sSoJ5c8SRVcMaMGejXr589p06dOmHp0qV2XbmQE/oSWuPQ19kOH7SHDk19DD83aYS+Pb6mYWRTYUGXAP8+6ZLzb5x4/qZhZI47DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8SRUcOXIkJkyYYM/p9ttvxwMPPGDXlQvbtgGdW0rD6pXfgMva/IH2LXfTMJLIsKJDgH+fdKj5O0Y8f9MwMseehpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyuepAp26dIFS5Yssef01FNPoX///nZduTDnudBDr0faw77Pqo4zj30f93XbjPqn7aNhZJNhQZcA/z7pkvNvnHj+pmFkjjsNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxJFTz55JOxfft2e05vvPEGLr74YruuXGjdFPhxhz1sUWZv9K8+Fs8O/Q/Klc2kYWSTYUGXAP8+6ZLzb5x4/qZhZI47DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8SRM8fPgwSpUqJc1nW+grZXXr1pXaoq789RfQsI7UfWlGd9xWZyKmj3g3r52/kibhYUWDAP8+aUDzeYh4/qZhZA4+DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8SRP873//i3r16tnzSUlJwaFDh1CyZEm7TamQnf33A6//OmQP+zHrGNza8kP07/5eXhsNIxsNC5oE+PdJE5yPw8TzNw0jc+BpGJljKWUSBUvDSELDigYBblIa0DjEkQD15IiGAUUC1JIiMHZ3JUA9ueJJmuBLL72EK6+80p7P2WefjU8++cSuaxX69QHeX20P/TW7LJ648VM0abg+r42GkY2GBU0C/PukCc7HYeL5m4aROfA0jMyxlDKJgqVhJKFhRYMANykNaBziSIB6ckTDgCIBakkRGLu7EqCeXPEkTXDs2LG466677PnceOONmD59ul3XKtz/f8C8J+2h72VchJ8nz0SFo2gY2VBYiIkA/z7FhM+XweL5m4aROeQ0jMyxlDKJgqVhJKFhRYMANykNaBziSIB6ckTDgCIBakkRGLu7EqCeXPEkTbBr165YvHixPZ9HHnkEgwYNsus6hewO7ZG2Y7M9dHLOKLRb0g8//0jDyIbCQkwE+PcpJny+DBbP3zSMzCGnYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15IonKYK5ubmoUaMGdu/ebc9n9erVaN26tV1XLhw8iNxzT0EKcu2h3Ustwcy3G2DDBhpGNhQWYiLAv08x4fNlsHj+pmFkDjkNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxJEfzll19wzDHHSHPZuXMnjj/+eKlNqfKf94G+V9lDMnNTcEX9L7FkTjrWr6dhZINhISYC/PsUEz5fBovnbxpG5pDTMDLHUsokCpaGkYSGFQ0C3KQ0oHGIIwHqyRENA4oEqCVFYOzuSoB6csWTFEHLwGnatKk9l9KlS+PAgQNITU2125QKoU8s4cbrQw+8XmUP+zSjIRb2eRljbs+iYWRTYSFWAvz7FCtB78eL528aRuZ40zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFkxTBmTNnom/fvvZc2rVrhxUrVth15cKboV9GuyX0C2nCa2rOCNSYOBCXtcukYSRwYTE2Avz7FBs/P0aL528aRuaI0zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFkxTBIUOGYOrUqfZchg8fjgkTJth1pUJODnDRecAvR56HtDerPM6svB7rniuP44/LoGGkBJSd3Qjw75MbnfiIiedvGkbm1oSGkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56kCDZu3BgfffSRPZd58+ahV69edl2p8O03wGXNpSED06bjxWPaYffqdGRm/kXDSKLDSiwE+PcpFnr+jBXP3zSMzDGnYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15Ion4YN//PEHypYtK81j8+bNqF+/vtQWdWX5MmD4v+zuP2UdjVOP/Rit66Zg8dPpoJ5sNCwYIEA9GYDocQrx/E3DyBxsGkbmWEqZRMHSMJLQsKJBgJuUBjQOcSRAPTmiYUCRALWkCIzdXQlQT654Ej64YcMGnHde6Ctk/7zS09Nx8OBBFC9ePL9J7X3KZODph+wxazLao8txT2FUlxTcPiiNhpFNhgUTBPj3yQRFb3OI528aRuZY0zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFk/DBp59+Gv3797fn0apVK7z55pt2Xbnwf/cCC6bbwxZkXoebq9+LxfekovVFqTSMbDIsmCDAv08mKHqbQzx/0zAyx5qGkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56ED950002YPv2IwTN69GiMHTtWf14jbgeWzbfHz8waiGHH3oEvF6WhSuUUGkY2GRZMEODfJxMUvc0hnr9pGJljTcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVT8IHTzvtNGzdutWex4svvogrr7zSrisXbrgW+ODIJ5Qey74dT9T5Nz5/LT0vFfWkTJQDXAhQTy5w4iQknr9pGJlbFBpG5lhKmUTB0jCS0LCiQYCblAY0DnEkQD05omFAkQC1pAiM3V0JUE+ueBI6+Ouvv+Loo4+W5rB9+3acdNJJUlvUlV9+AS48C8jNtYcMTX0M2R07Yer9aXlt1JONhgUDBKgnAxA9TiGev2kYmYNNw8gcSymTKFgaRhIaVjQIcJPSgMYhjgSoJ0c0DCgSoJYUgbG7KwHqyRVPQgffeecdtGjRwp5D6dKlsX//fqSl/W3u2IFoC7NmAJPutnv/mZOGE4/ZjClDy6Jb59S8durJxsOCAQLUkwGIHqcQz980jMzBpmFkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKJ6GDDz/8MIYOHWrPoWPHjnjllVfsulLB+lRR66bAT9/Zw17K7Ikbqk/AxtlpqFUzJa+derLxsGCAAPVkAKLHKcTzNw0jc7BpGJljKWUSBUvDSELDigYBblIa0DjEkQD15IiGAUUC1JIiMHZ3JUA9ueJJ6GCnTp2wbNkyew4TJ07EHXfcYdeVCtu2AZ1bSkPuwQTMr9ETX65IR8rffhEfei0RYiVWAvz7FCtB78eL528aRuZ40zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFk7BBa13Lli2LzMxMew7r1q1D8+bN7bpS4ZOPgd6dpCFLM7rjjSsfxOMTj3zFjXqSELESIwHqKUaAPgwXz980jMwBp2FkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKJ2GDH330ERo3bmzff2pqat7zi8qUKWO3KRV+/DH0lbRG0pBZWQNQctxI9Lzq7+cXWUHqSULESowEqKcYAfowXDx/0zAyB5yGkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56EDT766KO45ZZb7Ptv1aoV3nzzTbuuXLh3DPDCM/awrNwUnFvuXSyaXxMn1vnn+2ihKPVkI2LBAAHqyQBEj1OI528aRuZg0zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFk7DBLl26YMmSJfb9jx07FqNHj7brSoUffgDanw9YD77+57Ug8zqMrHkvvl6ZjtCHl+wX9WSjYMEAAerJAESPU4jnbxpG5mDTMDLHUsokCpaGkYSGFQ0C3KQ0oHGIIwHqyRENA4oEqCVFYOzuSoB6csWTkMGMjIy85xdZ7/mvNWvWoGVL+aHV+bFC3yc9AMyaanf7KzcVZ1XYgJZNq+CJB488v8jqQD3ZmFgwQIB6MgDR4xTi+ZuGkTnYNIzMsZQyiYKlYSShYUWDADcpDWgc4kiAenJEw4AiAWpJERi7uxKgnlzxJGRw06ZNOPvss+17Twn9hNm+fftQrlw5u02pcFNf4N0V9pB5mX3x7+p34+lbU3HV5cLHi0I9qCcbEwsGCFBPBiB6nEI8f9MwMgebhpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyuehAw++eSTuPnmm+17t34ZzfqFNO1Xvz7A+6vt4eNz78UDVa7DFwvTUK3qkecXWR2oJxsTCwYIUE8GIHqcQjx/0zAyB5uGkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56EDPbs2RMLFiyw7/2ee+7BmDGhh1brvHJygCZnAQd+tUePTpmEt07uivVL0u22/AL1lE+C7yYIUE8mKHqbQzx/0zAyx5qGkTmWUiZRsDSMJDSsaBDgJqUBjUMcCVBPjmgYUCRALSkCY3dXAtSTK56EC2ZlZaFChQo4ePCgfe8rV65E27Zt7bpSYfNnQI9LpCHnHbUOHbvVwp3D5OcXWZ2oJwkVKzESoJ5iBOjDcPH8TcPIHHAaRuZYSplEwdIwktCwokGAm5QGNA5xJEA9OaJhQJEAtaQIjN1dCVBPrngSLrhlyxacccYZ0n3/8ssvqFSpktQWdeWhB4GZU+zuX2fWwTnV38Ky8alodoH8/CKrE/Vko2LBAAHqyQBEj1OI528aRuZg0zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFk3DBZ555BjfeeKN93+eeey4++OADu65UyM0FWl0A/Py9PWxa9lCMOXYwvn89HSVL2s12gXqyUbBggAD1ZACixynE8zcNI3OwaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbniSbhgjx49sHDhQvu+R48ejbFjx9p1pcK2bUDnltKQ1qVXoso5p+L5J8KfX2R1pJ4kXKzESIB6ihGgD8PF8zcNI3PAaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbniSaigtZblypVDRkaGfd+rVq1CmzZt7LpS4b57gIVP20P+l1UZpx/7IR7ql4obrgl/fpHVkXqycbFggAD1ZACixynE8zcNI3OwaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbniSajg+vXr0bRpU/ueU1NTsW/fPpQtW9Zui7pw6BBwQT0g64j59Hj2bbiz2iBsei4NNU9IiZiKeoqIhY2aBKgnTXA+DhPP3zSMzIGnYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15IonoYITJkzAyJEj7Xtu3749Xn/9dbuuVFi7Fhh4tT0kOzcFZ1TYgArVqmD9kshfR7M6U082MhYMEKCeDED0OIV4/qZhZA42DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8CRVs0aIF3nnnHfuep0yZgsGDB9t1pcKc54AJR8ynjRnnoNVxL2L0VSm47d+Rv45m5aeelCizcyEEqKdCAMVBWDx/0zAytyA0jMyxlDKJgqVhJKFhRYMANykNaBziSIB6ckTDgCIBakkRGLu7EqCeXPEkTHDv3r2oXLmydL8bN25EgwYNpLaoKw+MB2Y/ZndflnEVrj3uIax7PA1n1Iv8dTSrM/VkI2PBAAHqyQBEj1OI528aRuZg0zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFkzDBV155BZdffrl9vxUqVMCePXuQnu789TG7c6TC4IHA6pftyFPZgzG51lB88Vo6Qo9GcnxRT45oGNAgQD1pQPN5iHj+pmFkDj4NI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzwJE7z11lthfQUt/9W3b18888wz+VW199xcoFM74JvP7XF34wHk9OqBsaOdv45mdaaebGQsGCBAPRmA6HEK8fxNw8gcbBpG5lhKmUTB0jCS0LCiQYCblAY0DnEkQD05omFAkQC1pAiM3V0JUE+ueBIimBsyeGrVqoWdO3fa9zt//nz07NnTrisVnp8HjL1DGnJdsTno+8RFaH6By8eLQiOoJwkbKzESoJ5iBOjDcPH8TcPIHHAaRuZYSplEwdIwktCwokGAm5QGNA5xJEA9OaJhQJEAtaQIjN1dCVBPrngSIrh9+3acfPLJ0r1a5tHxxx8vtUVVCT33CL07AtanjP557c8uiQbVPsXWN45C8eL5rZHfqafIXNiqR4B60uPm5yjx/E3DyBx5GkbmWEqZRMHSMJLQsKJBgJuUBjQOcSRAPTmiYUCRALWkCIzdXQlQT654EiI4c+ZMWF9By3/Vr18fn332GVJSnB9Ond9Xes/MBC46F9j3s9TcL/1ZlGjfCo9PdP86mjWIepLQsRIjAeopRoA+DBfP3zSMzAGnYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15IonIYJdu3bF4sWL7XsdNWoUxo0bZ9ejLqx/D7ixm9R9WvZQjK42GIvvSUXri9y/jmYNpJ4kfKzESIB6ihGgD8PF8zcNI3PAaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbniifvg/v37UbFiReTk5Nj3unr1arRu3dquR1WwvoJ2/TXAh2vt7t9m1kKjY99CyfRUfBv6dbQSJeyQY4F6ckTDgAYB6kkDms9DxPM3DSNz8GkYmWMpZRIFS8NIQsOKBgFuUhrQOMSRAPXkiIYBRQLUkiIwdnclQD254on74LJly9CpUyf7PouHHjK0b98+lCpVym6LqrAk9AmluwZLXSfnjML/Vb0JN7RIwUP3Ff51NGsw9SQhZCVGAtRTjAB9GC6ev2kYmQNOw8gcSymTKFgaRhIaVjQIcJPSgMYhjgSoJ0c0DCgSoJYUgbG7KwHqyRVP3Af/9a9/4amnnrLv87rrrsOsWbPsetSFlhcAPx/5lbW9WeXRqPI72J9eHq+MTy3019Hyr0M95ZPguwkC1JMJit7mEM/fNIzMsaZhZI6llEkULA0jCQ0rGgS4SWlA4xBHAtSTIxoGFAlQS4rA2N2VAPXkiieugxkZGahUqRIOHjxo36f1LKMuXbrY9agLF50H7PnB7j476yYMOXYUyhcDtoe+jlYs9B7Ni3qKhhL7REuAeoqWVNH1E8/fNIzMrQMNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxxHVy7di1atmxp36P1q2h79+7NM5HsxmgLD4wHZj9m9/5fVmWcXu1DDLg4FePujO7raNZg6slGyIIBAtSTAYgepxDP3zSMzMGmYWSOpZRJFCwNIwkNKxoEuElpQOMQRwLUkyMaBhQJUEuKwNjdlQD15IonroNDhw7Fww8/bN9jx44d8corr9h1pcLWrUAX+UHZp5b/CM89WhXnNir819Hyr0U95ZPguwkC1JMJit7mEM/fNIzMsaZhZI6llEkULA0jCQ0rGgS4SWlA4xBHAtSTIxoGFAlQS4rA2N2VAPXkiidug9bX0Y499lj8+uuv9j0+99xz6N27t11XKny6CejVQRrStNqneGfVMUiN3i/iJ4wkgqzESoB/n2Il6P148fxNw8gcbxpG5lhKmUTB0jCS0LCiQYCblAY0DnEkQD05omFAkQC1pAiM3V0JUE+ueOI2uG7dOlx44YXS/cVyWMt5/HGkTrvfzrct82QsGbAaI4ZE/3U0azD1ZCNkwQAB6skARI9TiOfvWP4GeXybCZeehpFHSyYKloaRR5ADlJabVIAW24epUk8+QA7IJailgCy0T9OknnwCbfgyw4YNw+TJk+2sHTp0wPLly+26amF/284ot2uDPWxm1kBc+PpInFgnxW6LpkA9RUOJfaIlQD1FS6ro+onnbxpG5taBhpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyueuAxmZmaievXqeQ+4zr/BZ599Fn369Mmvqr1v3IicazoiFbn2uPtqPI+7V7aw69EWqKdoSbFfNASop2goFW0f8fxNw8jcWtAwMsdSyiQKloaRhIYVDQLcpDSgcYgjAerJEQ0DigSoJUVg7O5KgHpyxROXwXfffRfNmzeX7k37oBZ62HVO90uRmvWXnS8jNwUv3/kluvUqY7dFW6CeoiXFftEQoJ6ioVS0fcTzt/bfoaKdQlxenYaRR8siCpaGkUeQA5SWm1SAFtuHqVJPPkAOyCWopYAstE/TpJ58Am3wMrfffjsmTZpkZ7zkkkvw2muv2fWoC9nZwMUh4+mn76Qhs7MHovOGUShXTmqOqkI9RYWJnaIkQD1FCaoIu4nnbxpG5haChpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyueuAtmZWXlfR1tz5499r3NmjUL1113nV2PurD+PeDGblL3NRntsbTzNEx9oITUHm2FeoqWFPtFQ4B6ioZS0fYRz980jMytBQ0jcyylTKJgaRhJaFjRIMBNSgMahzgSoJ4c0TCgSIBaUgTG7q4EqCdXPHEXfO+999CsWTPpvv73v/+hWrVqUltUlaG3ACtftLt+lXkSLqj2Ol6aWBLNLki121UK1JMKLfYtjAD1VBihoo+L528aRubWg4aROZZSJlGwNIwkNKxoEOAmpQGNQxwJUE+OaBhQJEAtKQJjd1cC1JMrnrgLDh8+HA888IB9X+3atcOKFSvsetSFAweAJvWAnNDX0v55jcFEvHBCD3z+ajpS9fwiUE/5NPluggD1ZIKitznE8zcNI3OsaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbniiaug9XW0GjVqwDqU5b9mzpyJ66+/Pr8a/fvroWce3Xaj3d960HXdSp/i1qsrYMjNaXa7aoF6UiXG/m4EqCc3OvERE8/fNIzMrQkNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzxxFXz77bdx0UUXSfe0e/duHHvssVJbVJXHHwWmTbC7rs9ogY7HzcHnC9NQrWqK3a5aoJ5UibG/GwHqyY1OfMTE8zcNI3NrQsPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVT1wFb775Zjz55JP2PbVv3x6vv/66XY+6kJOD3MsuRsp3W+0hizJ7Y0WHcZjxsP6ni6xk1JONlAUDBKgnAxA9TiGev2kYmYNNw8gcSymTKFgaRhIaVjQIcJPSgMYhjgSoJ0c0DCgSoJYUgbG7KwHqyRVP3AT379+PypUrIyMjw76nBQsWoHv37nY96sKaN4FB10rdb05/Br2nt0OT8zQfXvRPNupJwspKjASopxgB+jBcPH/TMDIHnIaROZZSJlGwNIwkNKxoEOAmpQGNQxwJUE+OaBhQJEAtKQJjd1cC1JMrnrgJvvDCC5I5VKxYMezduxflypVTu8fQp4vQoTWwc5s97tvMWuh+6lv4z8vFtR92nZ+MesonwXcTBKgnExS9zSGev2kYmWNNw8gcSymTKFgaRhIaVjQIcJPSgMYhjgSoJ0c0DCgSoJYUgbG7KwHqyRVP3AQ7duyI5cuX2/fTv39/PPXUU3Y96sJ/3gf6XiV1H5g2HY3uaI8bront62hWUupJQstKjASopxgB+jBcPH/TMDIHnIaROZZSJlGwNIwkNKxoEOAmpQGNQxwJUE+OaBhQJEAtKQJjd1cC1JMrnrgI7ty5EzVr1pTu5a233gp7ALbUwakyfiww9wk7+nVmHZxffQ2+eqUYyit+WMlOIhSoJwEGizEToJ5iRuh5AvH8TcPIHG4aRuZYSplEwdIwktCwokGAm5QGNA5xJEA9OaJhQJEAtaQIjN1dCVBPrnjiIjh+/HiMGjXKvpdq1arBMpGsr6WpvnJbNUXKTzvsYQ/njMSubjdj0r2xf7rISko92WhZMECAejIA0eMU4vmbhpE52DSMzLGUMomCpWEkoWFFgwA3KQ1oHOJIgHpyRMOAIgFqSREYu7sSoJ5c8RR50Fof69NF1kEs/2UZSCNGjMivRv/+1Xbg8ouk/m1Kr8CU2fVR//QUqV23Qj3pkuO4SASop0hU4qtNPH/TMDK3NjSMzLGUMomCpWEkoWFFgwA3KQ1oHOJIgHpyRMOAIgFqSREYu7sSoJ5c8RR5cOnSV3DFFZdL96H7b9zc24ci5bWFdq69WeXR74JP8fKz6p9UspMUKFBPBYCwGhMB6ikmfL4MFs/fNIzMIadhZI6llEkUrO5mKiVkJdAEuEkFevmNT556Mo40sAmppcAuvScTp548wWos6aWXXorXX3/dzte9e3csWLDArkdd+O475F4a+joacu0hU3NGoP4TA9H6olS7LdYC9RQrQY4XCVBPIo34LIvnbxpG5taIhpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyueIg1u27YNp5xyinQPq1atQps2baS2Qiu5IZOo77XAB2vsrody0nF5rU+w8tWjkWrOL+IzjGzCLJggwL9PJih6m0M8f9MwMseahpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyueIg1ee+21mDNnjn0PderUwZdffon09HS7LarC2reAgddIXZ/KHoyj7rsNV3cz6BaFrkA9SZhZiZEA9RQjQB+Gi+dvGkbmgNMwMsdSyiQKloaRhIYVDQLcpDSgcYgjAerJEQ0DigSoJUVg7O5KgHpyxVNkwT179qBKlSrS9adMmYLBgwdLbYVWQg/NxsXNgF92211/zqqIi6q/j49fK4tSpexmIwXqyQhGJvmHAPUU/1IQz980jMytFw0jcyylTKJgaRhJaFjRIMBNSgMahzgSoJ4c0TCgSIBaUgTG7q4EqCdXPEUWHDp0KB5++GHp+lqHsSmTgacfkvIMSnsSNftfitv+nSa1m6hQTyYoMkc+Aeopn0T8vovnb62/UfE7tSK9MxpGHuEXBUvDyCPIAUrLTSpAi+3DVKknHyAH5BLUUkAW2qdpUk8+gVa4jLUmlStXxoEDB6RRudaziFRe27cBnVsBwriPMs5D++MW4otF6aFrpKhki6ov9RQVJnaKkgD1FCWoIuwmnr9pGJlbCBpG5lhKmUTB0jCS0LCiQYCblAY0DnEkQD05omFAkQC1pAiM3V0JUE+ueIokaP0KWs+ePaVrb9q0CWeddZbUVmjl5huBda9J3Zoe9RbOb3ciHrrP/KeLrAtRTxJuVmIkQD3FCNCH4eL5m4aROeA0jMyxlDKJgqVhJKFhRYMANykNaBziSIB6ckTDgCIBakkRGLu7EqCeXPH4HszOzkaDBg2wZcsW+9rdunXDwoUL7XrUhfrHhz5dlCN1P+aYr7FhdgnUqWX+00XWhagnCTcrMRKgnmIE6MNw8fxNw8gccBpG5lhKmUTB0jCS0LCiQYCblAY0DnEkQD05omFAkQC1pAiM3V0JUE+ueHwPLl++HB07dpSu+8EHH+Dcc8+V2qKq1DsurNvjZy/CwLlNwtpNNVBPpkgyj0WAeop/HYjnbxpG5taLhpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyseX4M5OTlo1qwZ3n//ffu6bdu2xYoVK5CSoviJoF27gLbhJtM3T32AOs1q2PlNF6gn00SDnY96iv/1F8/fNIzMrRcNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBKgnVzy+BteuXYuWLVtK11yzZk1Ym9TBoZI9fgLS5j4qRWfWfRI3vCx/eknqYKBCPRmAyBQ2AerJRhG3BfH8TcPI3DLRMDLHUsokCpaGkYSGFQ0C3KQ0oHGIIwHqyRENA4oEqCVFYOzuSoB6csXjW9D6BbRLL70079NE+Rc977zzsH79eqSmpuY3Rff+55/IaFwfxXMP2/1nZ/0LDZfciTPqKX5Syc4QXYF6io4Te0VHgHqKjlNR9hLP3zSMzK0EDSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSoJ1c8vgWt5xSdf/750vWWLl2KTp06SW3RVLLnzEXahOF2V+ux18Mavo+H55xgt3lVoJ68IhvMvNRT/K+7eP6mYWRuvWgYmWMpZRIFS8NIQsOKBgFuUhrQOMSRAPXkiIYBRQLUkiIwdnclQD254vEteMUVV8AyiPJfp512Gj777DOkp6fnN0X3fuAA/mrSCCVyDtr938poh3IvPINGZyt+UsnOEH2BeoqeFXsWToB6KpxRUfcQz980jMytBg0jcyylTKJgaRhJaFjRIMBNSgMahzgSoJ4c0TCgSIBaUgTG7q4EqCdXPL4EP/roIzRu3Fi61oIFC9C9e3epLZpK1v+NQ/qCaVLXe056GWNebhx6cLbU7EmFevIEa2CTUk/xv/Ti+ZuGkbn1omFkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKx5dg165dsXjxYvtadevWxZYtW1C8eHG7LarCd98h59KmSEWu3X1VRgccvegpNGzgg1sUuir1ZKNnwQAB6skARI9TiOdvGkbmYNMwMsdSyiQKloaRhIYVDQLcpDSgcYgjAerJEQ0DigSoJUVg7O5KgHpyxeN5cNOmTTj77LOl68ybNw+9evWS2qKpZIybiOLzH7G7ZuSmYETj9Zg82/tnF+VflHrKJ8F3EwSoJxMUvc0hnr9pGJljTcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVj+dByxh6/vnn7evUrl0bW7duVf90UehX1g40aISyWT/ZuWZlDcB5S0fh9FP9+XSRdWHqycbPggEC1JMBiB6nEM/fNIzMwaZhZI6llEkULA0jCQ0rGgS4SWlA4xBHAtSTIxoGFAlQS4rA2N2VAPXkisfTYKRnF82ePRvXXnut8nUP/GcLyvZtJ427//zVGDXjNKnN6wr15DXhYOWnnuJ/vcXzNw0jc+uVtIZRSpRP07N+CeKll14yR/SfTKJgaRgZxxu4hNykArfknk6YevIUb6CSU0uBWm7PJ0s9eY7Y8QKR/t38559/omTJko5jIgYOHwYanSiFdmSegOwV7+HEOt7/Mpp4YepJpMFyrASop1gJej9ePH/TMDLHm4YRDSNzamImzwhwk/IMbSATU0+BXHZPJk0teYI1sEmpp6JZ+rFjx+Kuu+6SLm79Kpr162iqr4Pjp6DM3AelYW+dMAwtXx8qtflRoZ78oByca1BP8b/WNIy8WaOkN4zuvPNO9OnTx5FeqVKlcNxxxznGdQOiYPkJI12KHJdPgJtUPgm+myBAPZmgyBwWAWqJOjBJgHoySTP6XJE+XfTDDz+o//s49OmiQ43ORGkclC7+01NvoWqzk6U2PyrUkx+Ug3MN6in+11o8f/MTRubWK+kNo6lTp+KWW24xRyzKTKJgaRhFCY3dHAlwk3JEw4AGAepJAxqHRCRALUXEwkZNAtSTJrgYhn388cc455xzwjLkhh5crfr636OLcOyTQ6RhP5Q6BzU+Wiq1+VWhnvwiHYzrUE/xv87i+ZuGkbn1omFkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKx3jQMoU6dOiA119/Xcq9Y8cO1KxZU2orrJKbk4v/ndEC1fGN3fW37KOA97eiYkX/fhnNvnioQD2JNFiOlQD1FCtB78eL528aRuZ40zAyx1LKJAqWhpGEhhUNAtykNKBxiCMB6skRDQOKBKglRWDs7kqAenLFYzy4bt06XHjhhVLekSNH4v7775faoqlsu28BTl44TOr6eueFuGRsM6nNzwr15Cft5L8W9RT/ayyev2kYmVsvGkbmWEqZRMHSMJLQsKJBgJuUBjQOcSRAPTmiYUCRALWkCIzdXQlQT654jAZzcnLQsmVLWKZR/qtevXrYuHEjihUrlt8U1XvWp1uQ3fNSlEjJtvt/n10LVTa9ixIli+bTRdaNUE/2crBggAD1ZACixynE8zcNI3Owk94wOu+882B95Pazzz7L2wBPPPHEvA2yZ8+eaNy4sTmSBTKJgqVhVAAOq8oEuEkpI+MAFwLUkwschpQIUEtKuNi5EALUUyGADIaXLl2KK0K/FCy+rLZOnTqJTe7l73cCUycj9/VFKGgLfdhvARrf2tx9vMdR6sljwAFLTz3F/4KL528aRubWK+kNIzdUffv2xZQpU3DUUaHvWCu+LEG6vfbs2YP69evnddm+fTuOP/54t+6MkYArAWuTsh5Mab0aNWqEEiVKuPZnkATcCFBPbnQYUyFALanQYt/CCFBPhREyEz8c+jWzhg0b4ptvjjxvyPofrGvWrEFaWlpUF0n55GMU698DKTlHPlWUP3BFyX648N1RSE3Nbymad+qpaLgn61Wpp/hfWcskyn/+Gg0jc+uVtIZRmTJlcP311+Oiiy6C9ami0qVL49dff8V//vMfPPDAA/jxxx/zKFr/d2XRokVIT09XohrpJ0idEixevBiVKlVyCrOdBEiABEiABEiABEiABHwhsGTJEjz22GPStaz/gXrmmWdKbW6Vsybdj0o7/hvW5bOMBvjotjtR++TDYTE2kAAJkICXBKyz/lVXXZV3CRpG5kgnrWF04MABlC1bNiIpS0xdunTB2rVr8+LPPfccevfuHbGvUyMNIycybCcBEiABEiABEiABEohHAvv27UOPHj2QkZFh316LFi0wZswYRPtv25TMTDQf2hdpuTl2jj9yiuMZDMN7DS7DgP7f2u0skAAJkIBfBGgYeUM6aQ2jwnDt2rULtWrVQlZWFho0aJD3kL/CxohxfiVNpMGy1wT4MVivCQcrP/UUrPX2crbUkpd0g5ebevJ+zUeNGoXJkyfbF7JMIus5n3Xr1rXbCiukbP4MxfvIzz86tfxH+KXEMfhgVg6OO7awDP7EqSd/OAflKtRT/K80v5LmzRoF1jCycFqfKpo7d24eWcsAqly5sjHK4kO3+NBrY1gDm8japNavX583/yZNmvAZRoFVgpmJU09mODILf4WIGjBLgH+bzPIsmG3btm049dRT834MJj82fPhwTJgwIb8a3fuc2cCEUXbf7Zl1cW711bivVwoG9Y/uGUj2YA8L1JOHcAOYmnqK/0UXz9/8Spq59Qq0YWRtkCNHjsyjuWXLFlg/J2rqJQqWhpEpqsHNw00quGvvxcypJy+oBjMntRTMdfdq1tSTV2SRZxJZX0V74YUX7ItYz/u0/o169NFH223RFDLuHYviLzxhd12WcRXGnPYQ3l+UHvofWnZzkReopyJfgqS6Aeop/pdTPH/TMDK3XoE2jCZOnIgRI0bk0aRhZE5UzGSeADcp80yDnJF6CvLqm507tWSWZ9CzUU/eKeCdd96B9awi8WU9+HrgwIFiU+Hl0POLfm94Hsrn/GT3nZ31L9SeORotmhbxz6LZd/R3gXoqAITVmAhQTzHh82UwDSNvMAfaMLr22msxZ86cPLKmXUhRsPyEkTfiDVJWblJBWm3v50o9ec84KFegloKy0v7Mk3ryhrP1vM6mTZtiw4YN9gVOOukkbN68GSVLlrTboin8/NBzqDLz70/n5/efdvocDFjUKr8aN+/UU9wsRVLcCPUU/8sonr9Nn+3jf/be3WFgDSProde1a9dGZuj/lJx11lnYtGmTUcqiYGkYGUUbyGTcpAK57J5NmnryDG3gElNLgVtyTydMPXmD99lnn8X1118vJX/55aW4/PJOUlthlZx9v+Nwk4YonXLY7rolswEqrV2G6tXj69NF1g1ST/YysWCAAPVkAKLHKcTzNw0jc7CT0jBau3YtmjdvjrS0yA/es35yr0uXLrD6Wa9Zs2bhuuuuyyub+o8oWBpGpqgGNw83qeCuvRczp568oBrMnNRSMNfdq1lTT+bJ7t27F9aniX7//Xc7ecuWLbF69WqkpqqZPF/1GYuTPjry7CIr4ZKur+LKexrYueOpQD3F02ok/r1QT/G/huL5m4aRufVKSsPo9NNPz/u/CtZXzho3bowax9VAiZIl8Ntvv+H999/HpEmTsHv37jyKHTt2xOLFi1G8eHFzVEOZRMHSMDKKNpDJuEkFctk9mzT15BnawCWmlgK35J5OmHoyj/fWW2/FlClTpMSfbvoUZ551ptRWWOW3tZtQfmAHiBbT2tzOaLLpsdC/oQsbXTRx6qlouCfrVamn+F9Z8fxNw8jceiWtYfTFF18USql///555lHZsmUL7avaQRQsDSNVeuxfkAA3qYJEWI+FAPUUCz2OFQlQSyINlmMlQD3FSlAev3HjRjRs2FBqHDZsWN6/faXGQiq5X3+NPzu1RWkc+SqaNWTTuHfQ4Io6hYwuujD1VHTsk/HK1FP8r6p4/qZhZG69ktIw+uijj/Cf//wn79NEW7duhfW8IusjuRUrVsQpp5yCCy+8EN27dVf+vysq2EXB0jBSIce+kQhwk4pEhW26BKgnXXIcV5AAtVSQCOuxEKCeYqEnj83Ozob11TPr19HyX5UqVcL27dthvUf9Cj0w+1CzFih94DtpyIdV+6DxmvultnirUE/xtiKJfT/UU/yvn3j+pmFkbr2S0jAyh0c/kyhYGkb6HDnybwLcpKgEkwSoJ5M0g52LWgr2+puePfVkjui8efNwzTXXSAmfe+459O7dW2orrHJoyWsofdeNUrf1WW1Q7/0ZKF8pXWqPtwr1FG8rktj3Qz3F//qJ528aRubWi4aROZZSJlGwNIwkNKxoEOAmpQGNQxwJUE+OaBhQJEAtKQJjd1cC1JMrnqiD1o+7WJ+otz5dn/9q0qQJ1q1b5/iDMPn9pPfcXPx4dhtUy9xqN2/NOBXfT12Giy8tbbfFa4F6iteVScz7op7if93E8zcNI3PrRcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVT9RB61NEc+fOlfpbj2to1KiR1FZY5ctZ7+GUSd2kbk+eOhs3LW6DlBSpOS4r1FNcLkvC3hT1FP9LJ56/aRiZWy8aRuZYSplEwdIwktCwokGAm5QGNA5xJEA9OaJhQJEAtaQIjN1dCVBPrniiCk6ePBnWg63F16BBg/DII4+ITe7l0CeL/nplJf4aMQjlUg/Zfb/LqomSb7+LqtXE30qzw3FXoJ7ibkkS+oaop/hfPvH8TcPI3HrRMDLHUsokCpaGkYSGFQ0C3KQ0oHGIIwHqyRENA4oEqCVFYOzuSoB6csVTaNB60HV6evhzhax/k1auXLnQ8XkdfvkFGDMaeGtZWP8PO0xF4weuCmuP1wbqKV5XJjHvi3qK/3UTz980jMytFw0jcyylTKJgaRhJaFjRIMBNSgMahzgSoJ4c0TCgSIBaUgTG7q4EqCdXPIUGZ8yYgX79+kn9ateujW+++UZqc6wcOAB0bAPs+SGsyw7UwwmfLEdqieJhsXhtoJ7idWUS876op/hfN/H8TcPI3HrRMDLHUsokCpaGkYSGFQ0C3KQ0oHGIIwHqyRENA4oEqCVFYOzuSoB6csXjGty9ezfq1q2LQ4eOfIXMGvD777+jXLlyrmPt4KNTgCcftKv5hdVZnXD60vtR/dSK+U0J8U49JcQyJcxNUk/xv1Ti+ZuGkbn1omFkjqWUSRQsDSMJDSsaBLhJaUDjEEcC1JMjGgYUCVBLisDY3ZUA9eSKxzGYG3rmkPWg63nz5kl93n33XTRt2lRqc6yEcuCi84C9u+wuWbkpGFTsabS6tx26XpEYzy2ybz5UoJ5EGizHSoB6ipWg9+PF8zcNI3O8aRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2dyVAPbnicQyuWLECl1xyiRQfNWoUxo0bJ7W5VrZvA65oKXXpXuIFlGh6PmY/kpYQv4om3XyoQj0VJMJ6LASop1jo+TNWPH/TMDLHnIaROZZSJlGwNIwkNKxoEOAmpQGNQxwJUE+OaBhQJEAtKQJjd1cC1JMrnojB/fv344wzzsDOnTvteK1atfDZZ5+hbNmydlthhYOPzkCZJ++2u+3Kqoomx3+Ajxako/IxKXZ7IhWop0Rarfi/V+op/tdIPH/TMDK3XjSMzLGUMomCpWEkoWFFgwA3KQ1oHOJIgHpyRMOAIgFqSREYu7sSoJ5c8UQMjhw5EhMmTJBi1ieO2rVrJ7W5VXJygG0Ne+DUzHfsbgsyr0P5x/8Pl1yceF9Fy58E9ZRPgu8mCFBPJih6m0M8f9MwMseahpE5llImUbA0jCQ0rGgQ4CalAY1DHAlQT45oGFAkQC0pAmN3VwLUkyuesODHH3+Mc845R2rv06cPZs2aFfoKWfSfCpr/9G+46uEzUDwl9Byjf14zzpqNvvNDv5iWwC/qKYEXLw5vnXqKw0UpcEvi+ZuGUQE4MVRpGMUAz22oKFgaRm6kGIuGADepaCixT7QEqKdoSbFfYQSopcIIMa5CgHqKnpbF6oILLsDGjRvtQWXKlMFXX32FatWq2W2FFb7YkoGDnXvhnOLv212zQw+7PvjmVpQ79ii7LREL1FMirlr83jP1FL9rk39n4vmbhlE+ldjfaRjFzjBiBlGwNIwiImKjAgFuUgqw2LVQAtRToYjYIUoC1FKUoNgtKgLUU1SY8jpNnDgRI0aMkAY8++yzsD5hFO3r0MFcvHP+CLTLmSsN+bV+B1RaOF1qS8QK9ZSIqxa/90w9xe/a5N+ZeP6mYZRPJfZ3GkaxM4yYQRQsDaOIiNioQICblAIsdi2UAPV5a4vvAABAAElEQVRUKCJ2iJIAtRQlKHaLigD1FBUmfP755zjzzDORYz186J+X9cyi1157Damp0T9z6NXLZ6DDV0cedG2l+iO1Eo5aswaoXDk/dcK+U08Ju3RxeePUU1wui3RT4vmbhpGEJqYKDaOY8DkPFgVLw8iZEyPREeAmFR0n9oqOAPUUHSf2KpwAtVQ4I/aIngD1VDirzMxMtGzZEu+9957duVixYti6dSvq1KljtxVW2DBxDc55rjdEeykjNw2pL6xEev3TChueEHHqKSGWKWFuknqK/6USz980jMytFw0jcyylTKJgaRhJaFjRIMBNSgMahzgSoJ4c0TCgSIBaUgTG7q4EqCdXPHnBRx99FLfccovU8fHHH8eAAQOkNrfKro0/okKv81EmNVPq9us9s1Gpa2I/6FqcEPUk0mA5VgLUU6wEvR8vnr9pGJnjTcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysB6skVT94DrU877TRkZWXZHVu0aIE333wT6enpdptbIeOvXGw+5wY0ynlD6ra9/d2o+9BNUluiV6inRF/B+Lp/6im+1iPS3YjnbxpGkQjptdEw0uNW6ChRsDSMCsXFDoUQ4CZVCCCGlQhQT0q42NmFALXkAochZQLUkzOy7OxsXHLJJVi1apXdyXpe0ZYtW2CZSNG+Fly/Aj029JW6bz6mC85YOxVISZHaE71CPSX6CsbX/VNP8bUeke5GPH/TMIpESK+NhpEet0JHiYKlYVQoLnYohAA3qUIAMaxEgHpSwsXOLgSoJRc4DCkToJ6ckc2YMQP9+vWTOkyaNAnDhg2T2twq6x75BGdPuwpl0/6yu+3LKYeS6z5Aycrl7LZkKVBPybKS8TEP6ik+1sHtLsTzNw0jN1JqMRpGaryi7i0KloZR1NjY0YEANykHMGzWIkA9aWHjoAgEqKUIUNikTYB6iozO+ndkrVq1pGDjxo3x7rvvonjx4lK7U+X7eW+jyrhrUCLlyC+rWX1/Gj4TVa9t5zQsodupp4Revri7eeop7pYk7IbE8zcNozA82g00jLTRuQ8UBUvDyJ0Vo4UT4CZVOCP2iJ4A9RQ9K/Z0J0AtufNhVI0A9RTOy/oqWsHnE6WEvjq2ceNGnHXWWeEDIrT8sWk7SvVqibSUXCn608mXoeqSJ5Puq2j5k6Se8knw3QQB6skERW9ziOdvGkbmWNMwMsdSyiQKloaRhIYVDQLcpDSgcYgjAerJEQ0DigSoJUVg7O5KgHoKx9OyZUusXbtWCtx77724++67pTanSk7oA0X/O7M1jsvdKnX5qlJ7nLR6GlCihNSeTBXqKZlWs+jnQj0V/RoUdgfi+ZuGUWG0oo/TMIqelVJPUbA0jJTQsXMEAtykIkBhkzYB6kkbHQcWIEAtFQDCakwEqCcZ37fffos6derIjaHawYMHUbp06bD2sIY//8TnvSag3rZnwkKZH+9EsZJpYe3J1EA9JdNqFv1cqKeiX4PC7kA8f9MwKoxW9HEaRtGzUuopCpaGkRI6do5AgJtUBChs0iZAPWmj48ACBKilAkBYjYkA9XQEX1ZWFtq1a4c1a9YcaQyVevTogeeff15qi1j54Xsc6todpfd/FxY+3LonSj4yKaw92Rqop2Rb0aKdD/VUtPyjubp4/qZhFA2x6PrQMIqOk3IvUbA0jJTxcUABAtykCgBhNSYC1FNM+DhYIEAtCTBYjJkA9XQE4dSpUzFkyJAjDaFSt27dsHDhQqktYuWXX5DZsT2K/b47LLy/bkuUmxt6btFRR4XFkq2Bekq2FS3a+VBPRcs/mquL528aRtEQi64PDaPoOCn3EgVLw0gZHwcUIMBNqgAQVmMiQD3FhI+DBQLUkgCDxZgJUE9/I9y8eTMaNGiAHOsBRP+8zj33XKxbty70yKFCnjl06BCyu16JtB2b84fmvR/OScPGVuNxwWO9kvYh19KEQxXqqSAR1mMhQD3FQs+fseL5m4aROeY0jMyxlDKJgqVhJKFhRYMANykNaBziSIB6ckTDgCIBakkRGLu7EqCegD9Dzx1q2rRp3q+g5cNKS0uDZSKddtpp+U2R3zMzkXPj9Uj98C0pvj2zLl5oPROjptVB6AfWAvOingKz1L5MlHryBXNMFxHP3zSMYkIpDaZhJOEwVxEFS8PIHNegZuImFdSV92be1JM3XIOYlVoK4qp7N2fqCRg9ejTuv/9+CfLjjz+OAQMGSG1SZf9+4LlZwIuhZxv9/L0U+iHrWNxxxmuYObcKSpaUQklfoZ6Sfol9nSD15CturYuJ528aRloIIw6iYRQRS+yNomBpGMXOM+gZuEkFXQFm5089meUZ5GzUUpBX3/zcg64n6wHXrVu3lsC2b98ey5cvh/Upo4iv0KeKcGkrYPc3YeHfssugT7WVmLGoFipXDtBHi/4hEXQ9hQmCDTERoJ5iwufLYPH8TcPIHHIaRuZYSplEwdIwktCwokGAm5QGNA5xJEA9OaJhQJEAtaQIjN1dCQRZT9a/G88880xYh5z8V+nSpfHFF1/ghBNOyG8Kf1+7Fhh4dVj7n6FnFvU4ahnGzT4T9U8PnllkAQmynsIEwYaYCVBPMSP0PIF4/qZhZA43DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSCqifr4dZdu3bFkiVLJD4vvvgirrzySqktrDJ6BPDyHKl5R2ZNDCr7KG4efzYubZsqxYJUCaqegrTGfs6VevKTtt61xPM3DSM9hpFG0TCKRMVAmyhYGkYGgAY8BTepgAvA8PSpJ8NAA5yOWgrw4nsw9aDq6Yknngh7RtG//vUvTJs2LfSQapdPB4WMppzG9ZB6OPQMo39eyzO6oPdxD+GurqkYOtDha2z5nZP8Pah6SvJlLbLpUU9Fhj7qC4vnbxpGUWMrtCMNo0IR6XUQBUvDSI8hRx0hwE3qCAuWYidAPcXOkBn+JkAtUQkmCQRRT+vXr0ezZs2Qm5trozzllFOwYcMGlCtXzm6LVMhYtRbFh8hfRzu77Ho0alID0yelITW4Hy7KwxVEPUXSCdvMEKCezHD0Mot4/qZhZI40DSNzLKVMomBpGEloWNEgwE1KAxqHOBKgnhzRMKBIgFpSBMburgSCpqddu3bh7LPPxp49e2wuqSGXxzKLGjVqZLdFKuS8uAQ5d92C9JQjRtNXmSdhQOM3sfSZdJQqFWlUsNqCpqdgra7/s6We/GeuekXx/E3DSJWec38aRs5sYoqIgqVhFBNKDg4R4CZFGZgkQD2ZpBnsXNRSsNff9OyDpKfDhw/D+gW0t99+W8I4ffp03HjjjVKbVMnORu4DE5Ayd5rUbFWmlxiDLqtvxNGVXL7GFjYqeRuCpKfkXcX4mRn1FD9r4XQn4vmbhpETJfV2GkbqzKIaIQqWhlFUyNjJhQA3KRc4DCkToJ6UkXGAAwFqyQEMm7UIBEVP1tfPhg0bhocfflji1L9/fzz55JPuzy2K8JBrK8n7Wa1w7GszUevEYlLOIFeCoqcgr7Gfc6ee/KStdy3x/E3DSI9hpFE0jCJRMdAmCpaGkQGgAU/BTSrgAjA8ferJMNAAp6OWArz4Hkw9KHp6/vnn0atXL4lg48aNsXbtWpQuXVpqlyrbtgGdW0pNVmV29kCc+fwdoa+3pYfFgtwQFD0FeY39nDv15CdtvWuJ528aRnoMI42iYRSJioE2UbA0jAwADXgKblIBF4Dh6VNPhoEGOB21FODF92DqQdDThx9+iAsuuADZoa+W5b/Kly+PTZs2oVatWvlNEd9/GPoQaqycbMcyclMwMu0RtJt6Bdq2CvgTrm0qRwpB0NOR2bLkNQHqyWvCsecXz980jGLnmZ+BhlE+CcPvomBpGBmGG8B03KQCuOgeTpl68hBuwFJTSwFbcI+nm+x62rFjB6xPEu3du1ciuWrVKrRp00ZqK1jZOWUJqk2/BcWFh1w/kzUIaXffjuuvTivYnfUQgWTXExfZXwLUk7+8da4mnr9pGOkQjDyGhlFkLjG3ioKlYRQzzsAn4CYVeAkYBUA9GcUZ6GTUUqCX3/jkk1lP+/btQ4sWLbB582aJ24MPPojbbrtNapMqWVn47Y5xqLhyutRsVWZeugLXP3BG6JlHYSE2hAgks564wP4ToJ78Z656RfH8TcNIlZ5zfxpGzmxiioiCpWEUE0oODhHgJkUZmCRAPZmkGexc1FKw19/07JNVTxkZGejSpQuWL18uIevbty+sX0VLTXX4Otlvv+HwDTei5Lb3pXFW5ZOje6DB2odCY8NCbPiHQLLqiQtcNASop6LhrnJV8fxNw0iFnHtfGkbufLSjomBpGGlj5MB/CHCTohRMEqCeTNIMdi5qKdjrb3r2yagn6xfRBg8ejEcffVTC1apVqzwDqVSpUlK7XfnuO2T3ugpp+3bbTfmFNccMQIs3RiC9BL+Kls8k0nsy6inSPNnmDwHqyR/OsVxFPH/TMIqFpDyWhpHMw1hNFCwNI2NYA5uIm1Rgl96TiVNPnmANZFJqKZDL7tmkk1FPU6dOxZAhQyRmp5xyCt59910cc8wxUrtd2bgROTd0Q2rGIbvJKvyVm4pZJzyGG165HMWLSyFWIhBIRj1FmCabfCJAPfkEOobLiOdvGkYxgCwwlIZRASCmqqJgaRiZohrcPNykgrv2XsycevKCajBzUkvBXHevZp1senr55ZfRuXNnCZf1i2jWL6XVrVtXas+r5OQAc2Yj98G7kZIbKguvH7OOwcST52HcwvooXVoIsOhIINn05DhRBnwhQD35gjmmi4jnbxpGMaGUBtMwknCYq4iCpWFkjmtQM3GTCurKezNv6skbrkHMSi0FcdW9m3My6entt9+G9bWzHMsE+udlPavIam/WrFl+k/x++1DgtYVyW6j234x6GH3qHMyaWxUVyoeF2eBAIJn05DBFNvtIgHryEbbmpcTzNw0jTYgRhtEwigDFRJMoWBpGJogGOwc3qWCvv+nZU0+miQY3H7UU3LX3YubJoqdPP/0U559/Pg4fPixhmj9/Pnr27Cm12ZUffgDanWdX8wtrMy7GqJMew8vPlUGVyvw5tHwu0bwni56imSv7eE+AevKecaxXEM/fNIxipXlkPA2jIyyMlkTB0jAyijaQybhJBXLZPZs09eQZ2sAlppYCt+SeTjgZ9PT111/jggsuwJ49eyRWEyZMwPDhw6U2u7JvH3I6XozUX+UHXE/PugWP1R6C12YUR43jaBbZvKIsJIOeopwqu/lAgHryAXKMlxDP3zSMYoQpDKdhJMAwWRQFS8PIJNlg5uImFcx192rW1JNXZIOXl1oK3pp7OeNE19OPP/6I5s2b46uvvpIwDR06FJMmTUJKSgHTJ/QLalj6MnLuG47Uvw5KY7ZmnIrOJ63EG0+n4fgaBcZJPVlxIpDoenKaF9uLhgD1VDTcVa4qnr9pGKmQc+9Lw8idj3ZUFCwNI22MHPgPAW5SlIJJAtSTSZrBzkUtBXv9Tc8+kfW0L/QpobZt2+Y90Frk0rt3b8ycORPp6eli89/lO0cCLz0X3h5qubfk47ju5ctR83iaRREBRdGYyHqKYnrs4jMB6sln4BqXE8/fNIw0ADoMoWHkACbWZlGwNIxipcnx3KSoAZMEqCeTNIOdi1oK9vqbnn2i6mn//v244oor8NZbb0lILrnkEixZsgQlS5aU2vMqu0NfP7u4cVj7wZxieLzk/ei+tCdqnkCzKAyQQkOi6klhiuzqIwHqyUfYmpcSz980jDQhRhhGwygCFBNNomBpGJkgGuwc3KSCvf6mZ089mSYa3HzUUnDX3ouZJ6KeDhw4gCuvvBKrV6+WkJx77rlYtWoVypUrJ7XnVUIPw86+/FKk/fClFFuZ0Qnja4zBrGeronZNmkUSHI1KIupJY5oc4hMB6skn0DFcRjx/0zCKAWSBoTSMCgAxVRUFS8PIFNXg5uEmFdy192Lm1JMXVIOZk1oK5rp7NetE09Mff/yBLl264I033pCQnHLKKXj77bdRtWpVqT2vEnrOUdb1fZC+c4sUO5STjrNO+Born0pDnVo0iyQ4mpVE05PmNDnMJwLUk0+gY7iMeP6mYRQDyAJDaRgVAGKqKgqWhpEpqsHNw00quGvvxcypJy+oBjMntRTMdfdq1omkp71796Jy5cphKOrUqYO1a9fi+OOPD4th4yfI6Xc1Ug/vl2KWWTSg4ku4a97ZOLE2zSIJTgyVRNJTDNPkUJ8IUE8+gY7hMuL5m4ZRDCALDKVhVACIqaooWBpGpqgGNw83qeCuvRczp568oBrMnNRSMNfdq1knip6+//57nHDCCWEYateunfcco5o1a4bF8NqryL3jJoT+4S3F9meXxK2VF+Pu+Q34gGuJTOyVRNFT7DNlBj8IUE9+UI7tGuL5m4ZRbCzF0TSMRBoGy6JgaRgZBBvQVNykArrwHk2bevIIbADTUksBXHQPp5wIerJ+Da1ixYoRKXz77beoVatWeOzXX5FzYUOk5mRKsR2ZJ2BUzTl4aM6JOLYaP1kkwTFQSQQ9GZgmU/hEgHryCXQMlxHP3zSMYgBZYCgNowJATFVFwdIwMkU1uHm4SQV37b2YOfXkBdVg5qSWgrnuXs063vX0a8j4OfrooyNOf8uWLahXr17E2LcvfIDa914pxaxPFvU69WM8O6M8jjmaZpEEx1Al3vVkaJpM4xMB6skn0DFcRjx/0zCKAWSBoTSMCgAxVRUFS8PIFNXg5uEmFdy192Lm1JMXVIOZk1oK5rp7Net41pP177rLLrsMH374Ydj0x48fjxEjRoS1IycH3901A8e/fA9SC0QXlxmGNquGokL5AgFWjRGIZz0ZmyQT+UaAevINtfaFxPM3DSNtjGEDaRiFITHTIAqWhpEZpkHOwk0qyKtvfu7Uk3mmQc1ILQV15b2Zd7zqadeuXWjfvj2sTxEVfE2ZMgWDBw8u2Azs34+feg5B1R0rw2OhlsN3P46S3a+IGGOjGQLxqiczs2MWvwlQT34TV7+eeP6mYaTOz2kEDSMnMjG2i4KlYRQjTA4HNymKwCQB6skkzWDnopaCvf6mZx+Pevpux3doc3EbfPXVV9J0K1WqhE8//RQ1atSQ2q1K7n//iz969UbZzB/DYlm5Kci9bgiK3TYUSC34uaOw7myIgUA86imG6XBoEROgnop4AaK4vHj+pmEUBbAou9AwihKUajdRsDSMVOmxf0EC3KQKEmE9FgLUUyz0OFYkQC2JNFiOlUC86Wn79u1o3bo1rF9FE1/nnHMOXn31VVSpUkVszivnLH0FOaMGIB3yr6HlhKIfVO2Hc+YMQLHjqoaNY4N5AvGmJ/MzZEY/CVBPftLWu5Z4/qZhpMcw0igaRpGoGGgTBUvDyADQgKfgJhVwARiePvVkGGiA01FLAV58D6YeT3ratGkT2rZtiz179kgzbd68OV5++WVYnzAq+Mqc+zyKjb+tYDN+zT4Kb146C10mNeGHisLoeNcQT3rybpbM7BcB6skv0vrXEc/fNIz0ORYcScOoIBFDdVGwNIwMQQ1wGm5SAV58D6ZOPXkANaApqaWALrxH044XPa1duxbt2rVDRkaGNFPLQFq0aBHKlSsntVuVP5+YhVKP3RnWvjHjHHxz+1Po0r9aWIwN3hKIFz15O0tm94sA9eQXaf3riOdvGkb6HAuOpGFUkIihuihYGkaGoAY4DTepAC++B1OnnjyAGtCU1FJAF96jaceDnhYvXozu3buHfuDM+hLZkdfll1+O+fPno3Tp0kca/yn9dv80VJw3Lqx9bvZNqPLIiNAnlYqHxdjgPYF40JP3s+QV/CJAPflFWv864vmbhpE+x4IjaRgVJGKoLgqWhpEhqAFOw00qwIvvwdSpJw+gBjQltRTQhfdo2kWpp9zcXEybNg3//ve/w2bXp08fPPnkkyhZsmRYbOeYGThh8d1h7dMwCufOvRnnnM0HW4fB8amhKPXk0xR5GR8JUE8+wta8lHj+pmGkCTHCMBpGEaCYaBIFS8PIBNFg5+AmFez1Nz176sk00eDmo5aCu/ZezLyo9GR9mmjMmDEYO3Zs2LRuv/12jB8/HmlpaX/HrE8ePfQAsOo1YNfXYf2thseK/R/avXg96p6YEjHORn8IFJWe/Jkdr+I3AerJb+Lq1xPP3zSM1Pk5jaBh5EQmxnZRsDSMYoTJ4eAmRRGYJEA9maQZ7FzUUrDX3/Tsi0JP1nOKrE8VPf3002HTmTx5MoYMGYKUFMH4mT8XGDc8rG9+wzNHT8TlS65G5WOEMflBvvtKoCj05OsEeTFfCVBPvuLWuph4/qZhpIUw4iAaRhGxxN4oCpaGUew8g56Bm1TQFWB2/tSTWZ5BzkYtBXn1zc/dbz0dOHAAvXv3xtKlS6XJWAbRnDlzcPXVV0vtoQcbIeei0C+d/fK93P5PbWnt0CeLFt8Q+upaxDAbfSbgt558nh4v5zMB6sln4BqXE8/fNIw0ADoMoWHkACbWZlGwNIxipcnx3KSoAZMEqCeTNIOdi1oK9vqbnr2ferL+nda5c2esX79emkaxYsWwbNmyvF9JkwLZ2Tg4YBjKvLtIas6vfHjmHWg0bzBS+ciifCRF/u6nnop8srwBzwlQT54jjvkC4vmbhlHMOO0ENIxsFGYLomBpGJllG8Rs3KSCuOrezZl68o5t0DJTS0FbcW/n65eevv32W1xyySX48ssvpQlVqFABb7zxBho3biy1448/8GuPm1Dp27Vye6i2J6sC9nS6Hac/0Aeh766FxdlQdAT80lPRzZBX9pMA9eQnbb1riedvGkZ6DCONomEUiYqBNlGwNIwMAA14Cm5SAReA4elTT4aBBjgdtRTgxfdg6n7o6bNPP0Pbdm1hHSbEV61atbBy5UqcfPLJYjNyfvwJv13WA0f/uU1qtyoTiz2IdnN6osEZNIrC4MRBgx96ioNp8hZ8IkA9+QQ6hsuI528aRjGALDCUhlEBIKaqomBpGJmiGtw83KSCu/ZezJx68oJqMHNSS8Fcd69m7bWe3n77bbRv3x6HDx+WptCwYcO8r6FVr15daj/0yRfIvKYryqf8JrVblT05VZC5/F1UP7FMWIwN8UHAaz3Fxyx5F34RoJ78Iq1/HfH8TcNIn2PBkTSMChIxVBcFS8PIENQAp+EmFeDF92Dq1JMHUAOakloK6MJ7NG0v9bRgwQL07Nkz7M7btm0LK1axYkUptvuFdah4T2+USsmS2q3K52U74MTZo1DylFphMTbEDwEv9RQ/s+Sd+EWAevKLtP51xPM3DSN9jgVH0jAqSMRQXRQsDSNDUAOchptUgBffg6lTTx5ADWhKaimgC+/RtL3QU25uLipVqoR9+/aF3bX1K2hPP/00SpUqJcU23/Mi6i26BQWfX/1tZi1sHLIAnW8+no8rkojFZ8ULPcXnTHlXfhCgnvygHNs1xPM3DaPYWIqjaRiJNAyWRcHSMDIINqCpuEkFdOE9mjb15BHYAKallgK46B5O2bSerK+e9evXD/PmzQu766FDh2LixIlIT0+3Y3/9BbxxwyJ03DTEbssvbMo6H7kzZuLsZuXzm/ge5wRM6ynOp8vb85gA9eQxYAPpxfM3DSMDQP9JQcPIHEspkyhYGkYSGlY0CHCT0oDGIY4EqCdHNAwoEqCWFIGxuysBk3qy/h1mfQVtzZo1YdccN24cRo4cGfqU0JGHVX+3MxcvXf0Shvw6KKz/u8W74uTlD6DKccXDYmyIXwIm9RS/s+Sd+UWAevKLtP51xPM3DSN9jgVH0jAqSMRQXRQsDSNDUAOchptUgBffg6lTTx5ADWhKaimgC+/RtE3p6bPPPsPll1+OHTt2hN1py5Ytw0yk5StyMGbsz1j/a2OUSMmRxrxTawjOW3Ibipc4Yi5JHViJWwKm9BS3E+SN+UqAevIVt9bFxPM3DSMthBEH0TCKiCX2RlGwNIxi5xn0DNykgq4As/OnnszyDHI2ainIq29+7ib09Morr6Br167IyMiQbjAtLQ0rVqxAmzZt7Hbrx9LGTMzG9Ldy8czuUehSTP7q2rYWd+DkabeADyyykSVUwYSeEmrCvFlPCVBPnuI1klw8f9MwMoI0LwkNI3MspUyiYGkYSWhY0SDATUoDGoc4EqCeHNEwoEiAWlIExu6uBGLRU05ODh588EGMGDEi7BoNGjTAkiVLULt2bTv29be56HN7Nnb+uB8Tf56MnsVm2TGr8EeTLjhq+lSaRRKVxKrEoqfEminv1g8C1JMflGO7hnj+pmEUG0txNA0jkYbBsihYGkYGwQY0FTepgC68R9OmnjwCG8C01FIAF93DKevq6Y8//sDNN9+MuXPnht1dt27d8n4JrVy5cnmxkK+E+YtyMPSJbPTduwTDs+5EhbRDYeOwcAVQ/4zwdrYkDAFdPSXMBHmjvhKgnnzFrXUx8fxNw0gLYcRBNIwiYom9URQsDaPYeQY9AzepoCvA7PypJ7M8g5yNWgry6pufu46evv/+e1x11VXYsGFD2A3dc889uPPOO2F9Hc167dmTi8FjsvHrhs8x6ffhqF98c9iYvIbzWgEznuOniyLTSZhWHT0lzOR4o74ToJ58R658QfH8TcNIGZ/jABpGjmhiC4iCpWEUG0uOBrhJUQUmCVBPJmkGOxe1FOz1Nz17VT198MEH6NixY8gI2iPdSnp6OubPn5/3LKP8wBtrcjBo7GHc88P9YV8/y++D1HRg8Gigz/VAsWJ2MwuJSUBVT4k5S961XwSoJ79I619HPH/TMNLnWHAkDaOCRAzVRcHSMDIENcBpuEkFePE9mDr15AHUgKaklgK68B5NO1o95ebm5hlC1157LaxnF4mv6tWrY9myZWjYsGFe8x8H/36w9Stv7sXin/vhrOKfiN2PlNtcAYy8C6hW7UgbSwlNIFo9JfQkefO+EaCefEOtfSHx/E3DSBtj2EAaRmFIzDSIgqVhZIZpkLNwkwry6pufO/VknmlQM1JLQV15b+YdjZ4OHTqEUaNGYerU0AOpC7yaN2+OBQsWwDKNrNcnm3Jx/Z3ZOPqnLzF/fy9US99bYESoWr0OMPZB4Lzzw2NsSWgC0egpoSfIm/eVAPXkK26ti4nnbxpGWggjDqJhFBFL7I2iYGkYxc4z6Bm4SQVdAWbnTz2Z5RnkbNRSkFff/NwL09M333yDnj17RnxeUb9+/fJMpNKlS+PPP4EHH8vGI8szMWDvixiZMxKlUrOlG85NS0fK0DHA1b359TOJTPJUCtNT8syUM/GDAPXkB+XYriGev2kYxcZSHE3DSKRhsCwKloaRQbABTcVNKqAL79G0qSePwAYwLbUUwEX3cMpuelq69BX06tUT1ieMCr6mTJmCQYMGITU1FR98mIOb781G852v4/a/7kON9P8V7I7cStWQMmsBcFLdsBgbkoeAm56SZ5aciV8EqCe/SOtfRzx/0zDS51hwJA2jgkQM1UXB0jAyBDXAabhJBXjxPZg69eQB1ICmpJYCuvAeTTuSniyDaPTo0bBMoYKvChUq4IUXXsDFF18M61lFkyf+jgovzEb33GdQNf2Xgt3/rp8R+urZk88AFSpGjrM1aQhE0lPSTI4T8Z0A9eQ7cuULiudvGkbK+BwH0DByRBNbQBQsDaPYWHI0fyWNGjBLgP/oMcszyNmopSCvvvm5F9TTjh07Qp8q6oVPPgl/UPWFF16IOXPm4Pjjj8e693Jw95hfMHtnR9Qs9r3zjXW5DrjrHn4FzZlQUkUK6qlEiRJJNT9Oxl8C1JO/vHWuJp6/aRjpEIw8hoZRZC4xt4qCpWEUM87AJ+AmFXgJGAVAPRnFGehk1FKgl9/45PP1ZP0K2s6dO9G/f39kZmaGXWfkyJEYM2YM/jxcAvdNysYLbx3AvJ8G48Liq8P65jWc1ggYEfoFtHMaR46zNSkJ5OvJmlyTJk1Awygpl9m3SVFPvqHWvpB4/qZhpI0xbCANozAkZhpEwdIwMsM0yFm4SQV59c3PnXoyzzSoGamloK68N/O29PTGG2/g8ccfx8qVK8MuYn0F7fnnn0fbtu3x0rJsvH/fKnTaPx8XFFuDYim5Yf1zTzgZKSNCD7ZucSGQkhIWZ0NyE+Dfp+ReX79nRz35TVz9euL5m4aROj+nETSMnMjE2C4KloZRjDA5HNykKAKTBKgnkzSDnYtaCvb6m579hg0b0LlzZ+zevTsstfWcolmzZuHgn9Ux4c6fcN3Hd6BF8TfD+tkNI8aHfgHtGoSehG03sRAsAvz7FKz19nq21JPXhGPPL56/aRjFzjM/Aw2jfBKG30XB0jAyDDeA6bhJBXDRPZwy9eQh3IClppYCtuAeTTcnJwfTp0/HwIEDYZULvsaPH48B19yIdfetR8raVbgwbRmOSs0o2C2vnhv6JFHKU6FfQGvaLGKcjcEhwL9PwVlrP2ZKPflBObZriOdvGkaxsRRH0zASaRgsi4KlYWQQbEBTcZMK6MJ7NG3qySOwAUxLLQVw0Q1P+ZdffsHNN9+MRYsWhWWuXr06ljw+DSe8sA5VNi1EWoSvneUPyk1JRUqzdsC/hwD16+c38z3ABPj3KcCL78HUqScPoBpOKZ6/aRiZg0vDyBxLKZMoWBpGEhpWNAhwk9KAxiGOBKgnRzQMKBKglhSBsbtEYP369ejRowe+/z78l816XXYZHjr9XFRaNh3FU8I/dZSfKKNERRS/ZxzQug1Qpkx+M99JgF/npwaMEuB+ZxSnJ8nE8zcNI3OIaRiZYyllEgVLw0hCw4oGAW5SGtA4xJEA9eSIhgFFAtSSIjB2zyOQlZWFyZMnY/jw4WFE0kNfKZvbpj067N6Bo3J/D4uLDTntuiF1zD1A+fJiM8skkEeAf58oBJMEqCeTNL3JJZ6/aRiZY0zDyBxLKZMoWBpGEhpWNAhwk9KAxiGOBKgnRzQMKBKglhSBsTt27dqFvn37RvwVtHp1amPxUTVwatbXEUn9lZuKL0u0QY2b2qNS54uAqlUj9mMjCVgE+PeJOjBJgHoySfP/27sbODmKOv/jv90km80jeSCQB5KIgEYIhAQBCY8qIurxEAVBAQUPRREJj3ryB+/vA4giCCpyFx59OA45hID4F44TEkIQggiJ4elAEJAQSUxIICGEZOdf1TBD1e5U7VRNzaZ3+jO+4m53VddOv+vL9PZve3oaM5Z5/k3BKJ0xBaN0ltZIZmApGFk0LEQIcJCKQGMTpwB5ctLQEChAlgLBCty9VCrJr3/9azn22GNlzZo1loR+I9kX9j5YPvaPcfJBudlq0wsbSy3ym5bPyWbnzZT9Dh4p6iIkHgh0K8DrU7dEdAgQIE8BWJuoq3n+TcEo3SRQMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCsoN2XL18uo0aN6rL3JwzsJ18fO0wmtvXr0lZeMe+N/eWZY74hh5+xjQwYUF7LVwS6F+D1qXsjetQuQJ5qt9pUPc3zbwpG6WaBglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgBeuuryq66aab5BOf+ESXPd+9T6vMf9eW6pPPql8utK6jj1yzy3/IwT/YS8aOrt6ny6CsQMAQ4PXJwODbugXIU92EDR/APP+mYJSOm4JROktrJDOwFIwsGhYiBDhIRaCxiVOAPDlpaAgUIEuBYAXqrj/57LTTTpMbbrih6l7fO3GS7DFoddU2vfIvx/9Ytjn14852GhDoToDXp+6EaA8RIE8hWpumr3n+TcEo3RxQMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCsAN03btwoV199tXz5y1+W9evXd9ljfbHQ+WMPkM9utthq61BLL23cUtYOHy9rZuwp75o5U/r372/1YQGBEAFen0K06NudAHnqTmjTt5vn3xSM0s0HBaN0ltZIZmApGFk0LEQIcJCKQGMTpwB5ctLQEChAlgLBmrz7Y489Jl/60pdk7ty5XfZ0S1Uo+vrIcXL85n1kUOsGq33ZxuFywwnz5YjP9peFC/+QtU2fPp2CkaXEQqgAr0+hYvT3CZAnn04+2szzbwpG6eaEglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgTdr9hRdekK222qrL3uk7D32irY8cN2qE7D+0TdpaSl366BWvnP1vMuRTB/Ex6FV1WBkrwOtTrBzbVRMgT9VU8rXOPP+mYJRubigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCNZk3fXbz/r27Wvt1aTWFpnYp0UOGNJfjhgxRMa12e1m55K64XXLyWeLfP4EEfU9eTJ1+L5eAfJUryDbmwLkydTI5/fm+TcFo3RzRMEonaU1khlYCkYWDQsRAhykItDYxClAnpw0NAQKkKVAsCbprj/97Ne//rUcfvjhlT3aThWKZk8cKdsPaKusc32jrzNq+diRIiefKurSpEo38lSh4JsEAuQpASJDVATIU4Uit9+Y598UjNJNEwWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwXp5d10ouuuuu+Tb3/62zJkzx9qb60cPkcPVFUW+R0dLq7Qe+AmRL31FZJttunQlT11IWFGHAHmqA49NuwiQpy4kuVthnn9TMEo3PRSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBOul3Ts6OuT3v/+9fOc735G7777b2ouBaunEIW1ywfjNrfXmwtqR75IBJ/yztPzTQSKbbWY2Wd+TJ4uDhToFyFOdgGxuCZAniyOXC+b5NwWjdFNEwSidpTWSGVgKRhYNCxECHKQi0NjEKUCenDQ0BAqQpUCwXtZdF4ruuOMO+da3viX33nuv9ey3VvccOm+LwXLQsEEyqE+r1VZeWLbnsTJq5qdFtt8+u0dReb3rK3lyybA+RoA8xaixjUuAPLlk8rPePP+mYJRuXigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCNZLuutC0W233Sbf/OY3ZcGCBV2e9W6qQPS7bUbJiL59urTpFW+0bSb9FiwU6devartrJXlyybA+RoA8xaixjUuAPLlk8rPePP+mYJRuXigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCJbz7uvXr5dbbrlFzjvvPHnooYe6PFt9HdG3hrXLqaOHy0B1k+uqj83UW9MuniWy2+5Vm30ryZNPh7ZQAfIUKkZ/nwB58unko808/6ZglG5OKBils7RGMgNLwciiYSFCgINUBBqbOAXIk5OGhkABshQIltPuq1evluuuu06+973vydNPP93lWb5Dvf3s2KFt8umRw2S79q5XFWWferbnh0WO+ozIXnuL9Onap8ugVVaQpyoorIoWIE/RdGxYRYA8VUHJ2Srz/JuCUbrJoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgWM66P/vXZ+WKK6+Qiy66SNauXVt5dvv1bZVTRg2WUf36yDBV/Jk0oJ+0iuOKovHbiVz+c5HxEyrbx35DnmLl2K6aAHmqpsK6WAHyFCvXc9uZ598UjNK5UzBKZ2mNZAaWgpFFw0KEAAepCDQ2cQqQJycNDYECZCkQLAfdS6WS3H///XLppZfKL3/5S+sZjVI1oUu2GCJHjBzsLhCZWxx2nMiZ/yIyeLC5Nvp78hRNx4ZVBMhTFRRWRQuQp2i6HtvQPP+mYJSOnYJROktrJDOwFIwsGhYiBDhIRaCxiVOAPDlpaAgUIEuBYJuwu74/0a233ppdTTR//nzrmQxRSyeqt5z9y5jh2RVFVmO1hYmTRM6/SGSnKdVao9eRp2g6NqwiQJ6qoLAqWoA8RdP12Ibm+TcFo3TsFIzSWVojmYGlYGTRsBAhwEEqAo1NnALkyUlDQ6AAWQoE2wTdV6xYIb/4xS/kggsukI1LXpD3t/WRif37yLi2vjJGveXsPe39/W85Kz/nvv1FDvy4yEGHiEzfU6RV3wI77YM8pfUs+mjkqegJSLv/5CmtZyNGM8+/KRilE6ZglM7SGskMLAUji4aFCAEOUhFobOIUIE9OGhoCBchSIFgPdn/88cfliiuukJt//CM5e1h/2W/oAJnYFvYx97LFeJEPfOTNG1nvuZdIW1tD94A8NZS3cIOTp8JNeUN3mDw1lDfJ4Ob5NwWjJKTZIBSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBGtw9zVr1mRvO5s1a5bceeed8pVB/eRbW42o7W1m5nP7wMEi/+cbIqPHmGsb/j15ajhxoX4AeSrUdDd8Z8lTw4nr/gHm+TcFo7o5KwNQMKpQpP3GDCwFo7S2RRyNg1QRZ71x+0yeGmdbtJHJ0qafcX0T68WLF2dvO/vxjy+VdevWyifVW85O3XIzed/g9tqfYIt6i9mUPUROOkVkj+m1b5ewJ3lKiMlQQp4IQUoB8pRSszFjmeffFIzSGVMwSmdpjWQGloKRRcNChAAHqQg0NnEKkCcnDQ2BAmQpECxh99WrV8stt9wiP7n03+T+++bL7n1a5aND+smnRwyVbdvdbz17raOPLO/3Hhm43QQZvtM4aR2/lSoU7Syyw2SR9oACU8J9KQ9FnsoSfE0hQJ5SKDJGWYA8lSXy+9U8/6ZglG6eKBils7RGMgNLwciiYSFCgINUBBqbOAXIk5OGhkABshQIVmd37T1nzhz5zZW/kNH/c5NMau8j7+zfpv717fZtZ/PlIFl+zFdkr8+9S0Zu4S4o1fkU69qcPNXFx8adBMhTJxAW6xIgT3Xx9cjG5vk3BaN05BSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBIvo/sYbb8iCBQvUW85+Lb+/epZ8bTORo0YOlQGtLTWN9mrrcFlx+iUy/rMflJbaNqlp3EZ0Ik+NUC3umOSpuHPfiD0nT41QTTumef5NwSidLQWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwWrs/tprr8k998yXa6+9Va79z19Ix+sr5NwR7XLSFsNlYI2ForWbbS3tp8yU1oMP2uRvNatxt7nnTK1Q9KtJgNenmpjoVKMAeaoRahN2M8+/KRilmwgKRuksrZHMwFIwsmhYiBDgIBWBxiZOAfLkpKEhUIAsBYJ5uut7Ev33HXPkyqtulgdv/6Xs22ejTB/cJtMG9ZddBrbLYHWPou4e6/pvIf32P0D6HKo+5ex96gbWrd1v092YPdlOnnpSu/l/Fnlq/jnuyT0kTz2pHfezzPNvCkZxhtW2omBUTSXBOjOwFIwSgBZ8CA5SBQ9A4t0nT4lBCzwcWapv8vXvB9f+5+1y7/X/T05ZNle2H9AmrdIio/q1Zl99o28siSwa/DEZsO/uMnH/bWXADtuIjBsnuX/fmWenyJMHh6ZgAfIUTMYGHgHy5MHJSZN5/k3BKN2kUDBKZ2mNZAaWgpFFw0KEAAepCDQ2cQqQJycNDYECZCkMrFQqyWX/dq18+cSjrQ3/e6th8qGhA611roUO1fDStE/JiP87U9q2Ge/q1ivXk6deOW25fdLkKbdT0yufGHnK/7SZ598UjNLNFwWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJa6B3vqqeVy+pnfkYWLnpBnn74t22CYuvn0x/r3kd3V282mDuwvew0Z0P1AqkfHdjtL67nfF9lhh5r697ZO5Km3zVi+ny95yvf89LZnR57yP2Pm+TcFo3TzVYiC0YsvvihXX3213HTTTfLoo4/KoEGDZMqUKXLkkUfKUUcdJe3t7elE3xrJDCwFo+S8hRuQg1ThpryhO0yeGspbqMHJkj3d6gIi+fPiFer3jfvlhd/cIu945jey+4A1WVGoXd1PaOkbG6Sf+qiy8W197Q2rLHWot6atHz9F+u+zh7RM20VkpykiY8b06recVdlNaxV5sjhYqFOAPNUJyOaWAHmyOHK5YJ5/UzBKN0VNXzCaM2eOzJgxQ15++eWqatOmTZPZs2fL+PFpL+s2A0vBqCo9KwMEOEgFYNG1WwHy1C0RHWoUKHqW1IeZyfw/LJPZtyyQ126/SfZaebvs1L5W3t3eVtNNqp3MV/1aZOepIv37O7s0Y0PR89SMc7op94k8bUr95vvZ5Cn/c2qef1MwSjdfTV0wevzxx2Xq1Kmybt06GTJkiHz/+9+X6XtMl3Wvr8uuNjr//PMzSV00mjdvngwcWNv9A2rhNwNLwagWMfr4BDhI+XRoCxUgT6Fi9HcJFClLujj0+P9ulD/d9pAsv/13svSpP8vKFX9SVxC9KAcPGyzjarhqyOVYWT9yrMi31FvO9nt/ZVWRvilSnoo0r5tqX8nTppJvzp9LnvI/r+b5NwWjdPPV1AWjQw45RG655Rbp06eP/OnBP6mruXey5K688ko5/vjjs3WXXHKJnHzyyVZ7PQtmYCkY1SPJtlqAgxQ5SClAnlJqFnusZsySflvZypdL8r9PluTJec/IP26/TYY+eads1/GwbN++Rkb27ZNu0t+j3mq2+55vXk20444iW45u6recdQfXjHnqbp9pb5wAeWqcbRFHJk/5n3Xz/JuCUbr5atqC0eLFi2VH/cuXepx11lly7rnndlHr6OiQPfbYQxYsWCCbb7656Hsd9e3b/X0FugxUZYUZWApGVYBYFSTAQSqIi87dCJCnboBorlmgN2dJ/Qogf3+pJM8+8Zo8/chKuft/18rCPy6Q7R48Vg4dPlD2VTeirrc49FJpoKydvI+M/dTB0jZxK5EXl4g8/7yIvlzpIx8TmTSpZusidOzNeSrC/PS2fSRPvW3G8v18yVO+50c/O/P8m4JRuvlq2oLRhRdeKGeccUYmtWjRokrxqDPdrFmz5IQTTshWz58/X6ZPn965S9SyGVgKRlGEbGQIcJAyMPi2bgHyVDchA7wlkPcsbdggsvTvJXnq6dfkkUeXqreUvSRPP/U32eGxufLR9XfLLu3LZEgf9ZFliR7LWgbJmg/MkPEfP1D6TJ4ssvmoRCMXY5i856kYs9A8e0memmcu87An5CkPs+B/Dub5NwUjv1VIa9MWjMpvR9OfiLZq1arsbWnVYBYtXCRTdlafPKIeF198scycObNat+B1ZmApGAXzsUEnAQ5SnUBYrEuAPNXFx8aGwKbM0uuvb5Rn/rpKnn5mhTz77Ar5yzNL5cc/PE7Wr1+RPcOW1qEi/XaQAW88IZNkpWzTr1UOGNouHx8+WEbU+baytR0l2aA+xWxoq8j6gcOk72FHSeshM0Tera4YUp+CxiNOYFPmKe4Zs1WeBchTnmen9z038pT/OTPPvykYpZuvpi0YjRs3TpYsWSL77LOPzJ071ym2evVq2WyzzbL2L37xi3LZZZc5+4Y0mIGlYBQiR99qAhykqqmwLlaAPMXKsV1nAStL732v9FcfNiG77tq5m3O5QxVe1qx5XZb/41VZseJVWbbsFXnp76tlxdKVsuqll2WZWvfcilfU13+o9mWyYuVLsnrVi/LGa3+TUsdLalx1wyHjod9UfmhbHzlo+ADZbVC7jO3XV4b2UVWdOh6vbOyQv7zRR14eN0kGv39vmXDQx2SU+rCMllY17saNov4iVcfobGoKWHlSV3z3L9inxJkWfF+/AHmq35AR3hYgT29b5PU78/ybglG6WWrKgtH69esrv2Qcc8wx8vOf/9wrNnjwYPUL6xo58MAD5Xe/+523b7lRB9L3WLZsmUzWl6Orx5NPPinjx4/3dacNAa+APkg9+OCDWZ9ddtmlkm/vRjQi4BAgTw4YVgcLHP7pS+UB9aESHapwck3rIvnw4JXy76vGyLdatpYOVczZqNZ3dGxUX9fJG+vXysYNa2TDG69KaaP617FS/bz12c/sp/7/W8Pb5ZiRQ6t+2thadcOhVzeq4pL6qv+1qP9t3b+fPLluvTy4dp1s3dZPJqjl8eqTytrqvMJHP++HVBFr9fs+KFt85rMyfs+9pH97e7ANG4QL8NoUbsYWbgHy5LahJVyAPIWb9fQWukg0ceLE7MdSMEqn35QFo5UrV8qIESMypRNPPFEuvfRSr9iECRPUPSifz+5fpO9jVMujJeAX0htuuKHyfGoZmz4IIIAAAgj0BoEZR16srgS6Rb4zrF3+z9g3j7v6eb+qrspZ9Nrroq/OWb6hQ5Zt2Ki+6jdxtUi7On4OaG2R4X1bZYS6Oke/Pexd7W2yZb+evVLniQ1t8seJ28urO0+Wd6hi0zYrlsuGLcfIP6bsLOuHqrez8UAAAQQQQACBXiOwYsUKOeyww7LnS8Eo3bQ1ZcFIB2T0aPXRtOpxyimnyA9/+EOv2CT1KSVPPPGETJkyRR5++GFv33IjBaOyBF8RQAABBIoq8PFP/Vh2XH6zzHn3ltKqikF5fqxv7SuvD9tCVk6eKi/us5+sHT0mz0+X54YAAggggAACAQIUjAKwAro2ZcGoJ64w4i1pASmja90CXAZbNyEDGALkycDg27oEtnnP5+SFZ66Vc9UVRv8ydnhuikYd2+woHR/6iHTsPFXUX5CkNGoLkQED6tpXNm68AK9NjTcu0k8gT0Wa7cbvK3lqvHG9P4G3pNUrWH37piwY9cQ9jKpzvr3WvOkWN71+24Xv4gT0Qeree+/NNp7OjUDjENmqIkCeKhR8U6fAWefcJHff87C0qhtAH9y6Uk584QYZ2GLfiDrkR3RM3l1az/y6yJixIm1tb95UWt1jUNa8qt7npv7p7/U9BM/7mmpX9xUav63IO7dT/9TXie9489871Ndhw0J+LH1zIsBrU04mokmeBnlqkonMyW6Qp5xMhOdpmOffvCXNAxXY1JQFI20wZswYWbp0KZ+SFhgIuudTgINUPueltz4r8tRbZy5/z7tLltQNqWX+PaI+0kzktbWiPtJM1EefqSLP39W65SJ91e2t9Q2k+6t/w4aLjBj51j/1/XbvEtlBfVhEwD0C8yfCM6pHoEue+JS0ejgLvy15KnwEkgKQp6ScDRmMglFDWKVpC0aHHHKI3HLLLTJo0CBZtWqV+tTb6jfTXLRwkUzZeUqme/HFF8vMmTOTSJuB5QqjJKSFHoSDVKGnP/nOk6fkpIUdkCwVduobsuPkqSGshR2UPBV26huy4+SpIaxJBzXPv7nCKB1t0xaMLrzwQjnjjDMyqUWLFsmOO+5YVW3WrFlywgknZG36E9L0231SPMzAUjBKIVrsMThIFXv+U+89eUotWtzxyFJx574Re06eGqFa3DHJU3HnvhF7Tp4aoZp2TPP8m4JROtumLRgtXry4UiQ666yz5Nxzz+2i1qEund9jjz1kwYIFsvnmm8uLL74offv27dIvZoUZWApGMYJsYwpwkDI1+L5eAfJUryDblwXIUlmCrykEyFMKRcYoC5CnsgRfUwiQpxSKjR3DPP+mYJTOumkLRpqo/LY0/Xa0Pz34J9lpyk6W3JVXXinHH398tu6SSy6Rk08+2WqvZ8EMLAWjeiTZVgtwkCIHKQXIU0rNYo9Floo9/6n3njylFi32eOSp2POfeu/JU2rR9OOZ598UjNL5NnXB6PHHH5epU6fKunXrZMiQIXLBBRdkVxTp/+Bvuukm+e53v5tJTps2TebNmycDBw5MJmsGloJRMtbCDsRBqrBT35AdJ08NYS3koGSpkNPesJ0mTw2jLeTA5KmQ096wnSZPDaNNNrB5/k3BKBlr8970ukw0Z84cmTFjhrz88svlVdZXXSyaPXu2jB8/3lpf74IZWApG9WqyPQcpMpBSgDyl1Cz2WGSp2POfeu/JU2rRYo9Hnoo9/6n3njylFk0/nnn+TcEonW9TX2FUZtL3JrrqqqvkxhtvFH3Vkb6SaOedd5YjjjhCjj76aPUJYfddowAAMFRJREFUv+rjfRM/zMBSMEqMW8DhOEgVcNIbuMvkqYG4BRuaLBVswhu8u+SpwcAFG548FWzCG7y75KnBwAmGN8+/KRglAH1riEIUjNJx1T6SGVgKRrW70bO6AAep6i6sjRMgT3FubNVVgCx1NWFNvAB5irdjy64C5KmrCWviBchTvF1PbWmef1MwSqdOwSidpTWSGVgKRhYNCxECHKQi0NjEKUCenDQ0BAqQpUAwunsFyJOXh8ZAAfIUCEZ3rwB58vLkotE8/6ZglG5KKBils7RGMgNLwciiYSFCgINUBBqbOAXIk5OGhkABshQIRnevAHny8tAYKECeAsHo7hUgT16eXDSa598UjNJNCQWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwejuFSBPXh4aAwXIUyAY3b0C5MnLk4tG8/ybglG6KaFglM7SGskMLAUji4aFCAEOUhFobOIUIE9OGhoCBchSIBjdvQLkyctDY6AAeQoEo7tXgDx5eXLRaJ5/UzBKNyUUjNJZWiOZgaVgZNGwECHAQSoCjU2cAuTJSUNDoABZCgSju1eAPHl5aAwUIE+BYHT3CpAnL08uGs3zbwpG6aaEglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgdPcKkCcvD42BAuQpEIzuXgHy5OXJRaN5/k3BKN2UUDBKZ2mNZAaWgpFFw0KEAAepCDQ2cQqQJycNDYECZCkQjO5eAfLk5aExUIA8BYLR3StAnrw8uWg0z78pGKWbEgpG6SytkczAUjCyaFiIEOAgFYHGJk4B8uSkoSFQgCwFgtHdK0CevDw0BgqQp0AwunsFyJOXJxeN5vk3BaN0U0LBKJ2lNZIZWApGFg0LEQIcpCLQ2MQpQJ6cNDQECpClQDC6ewXIk5eHxkAB8hQIRnevAHny8uSi0Tz/pmCUbkooGKWztEYyA0vByKJhIUKAg1QEGps4BciTk4aGQAGyFAhGd68AefLy0BgoQJ4CwejuFSBPXp5cNJrn3xSM0k0JBaN0ltZIZmApGFk0LEQIcJCKQGMTpwB5ctLQEChAlgLB6O4VIE9eHhoDBchTIBjdvQLkycuTi0bz/JuCUbopoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgGN29AuTJy0NjoAB5CgSju1eAPHl5ctFonn9TMEo3JRSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBKO7V4A8eXloDBQgT4FgdPcKkCcvTy4azfNvCkbppoSCUTpLayQzsBSMLBoWIgQ4SEWgsYlTgDw5aWgIFCBLgWB09wqQJy8PjYEC5CkQjO5eAfLk5clFo3n+TcEo3ZRQMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCM7l4B8uTloTFQgDwFgtHdK0CevDy5aDTPvykYpZsSCkbpLK2RzMBSMLJoWIgQ4CAVgcYmTgHy5KShIVCALAWC0d0rQJ68PDQGCpCnQDC6ewXIk5cnF43m+TcFo3RTQsEonaU1khlYCkYWDQsRAhykItDYxClAnpw0NAQKkKVAMLp7BciTl4fGQAHyFAhGd68AefLy5KLRPP+mYJRuSigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCEZ3rwB58vLQGChAngLB6O4VIE9enlw0muffFIzSTQkFo3SW1khmYCkYWTQsRAhwkIpAYxOnAHly0tAQKECWAsHo7hUgT14eGgMFyFMgGN29AuTJy5OLRvP8m4JRuimhYJTO0hrJDCwFI4uGhQgBDlIRaGziFCBPThoaAgXIUiAY3b0C5MnLQ2OgAHkKBKO7V4A8eXly0Wief1MwSjclFIzSWVojmYGlYGTRsBAhwEEqAo1NnALkyUlDQ6AAWQoEo7tXgDx5eWgMFCBPgWB09wqQJy9PLhrN828KRummhIJROktrJDOwFIwsGhYiBDhIRaCxiVOAPDlpaAgUIEuBYHT3CpAnLw+NgQLkKRCM7l4B8uTlyUWjef5NwSjdlFAwSmdpjWQGloKRRcNChAAHqQg0NnEKkCcnDQ2BAmQpEIzuXgHy5OWhMVCAPAWC0d0rQJ68PLloNM+/KRilmxIKRuksrZHMwFIwsmhYiBDgIBWBxiZOAfLkpKEhUIAsBYLR3StAnrw8NAYKkKdAMLp7BciTlycXjeb5NwWjdFNCwSidpTWSGVgKRhYNCxECHKQi0NjEKUCenDQ0BAqQpUAwunsFyJOXh8ZAAfIUCEZ3rwB58vLkotE8/6ZglG5KKBils7RGMgNLwciiYSFCgINUBBqbOAXIk5OGhkABshQIRnevAHny8tAYKECeAsHo7hUgT16eXDSa598UjNJNCQWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwejuFSBPXh4aAwXIUyAY3b0C5MnLk4tG8/ybglG6KaFglM7SGskMLAUji4aFCAEOUhFobOIUIE9OGhoCBchSIBjdvQLkyctDY6AAeQoEo7tXgDx5eXLRaJ5/UzBKNyUUjNJZWiOZgaVgZNGwECHAQSoCjU2cAuTJSUNDoABZCgSju1eAPHl5aAwUIE+BYHT3CpAnL08uGs3zbwpG6aaEglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgdPcKkCcvD42BAuQpEIzuXgHy5OXJRaN5/k3BKN2UUDBKZ2mNZAaWgpFFw0KEAAepCDQ2cQqQJycNDYECZCkQjO5eAfLk5aExUIA8BYLR3StAnrw8uWg0z78pGKWbEgpG6SytkczAUjCyaFiIEOAgFYHGJk4B8uSkoSFQgCwFgtHdK0CevDw0BgqQp0AwunsFyJOXJxeN5vk3BaN0U0LBKJ2lNZIZWApGFg0LEQIcpCLQ2MQpQJ6cNDQECpClQDC6ewXIk5eHxkAB8hQIRnevAHny8uSi0Tz/pmCUbkooGKWztEYyA0vByKJhIUKAg1QEGps4BciTk4aGQAGyFAhGd68AefLy0BgoQJ4CwejuFSBPXp5cNJrn3xSM0k0JBaN0ltZIZmApGFk0LEQIcJCKQGMTpwB5ctLQEChAlgLB6O4VIE9eHhoDBchTIBjdvQLkycuTi0bz/JuCUbopoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgGN29AuTJy0NjoAB5CgSju1eAPHl5ctFonn9TMEo3JRSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBKO7V4A8eXloDBQgT4FgdPcKkCcvTy4azfNvCkbppoSCUTpLayQzsBSMLBoWIgQ4SEWgsYlTgDw5aWgIFCBLgWB09wqQJy8PjYEC5CkQjO5eAfLk5clFo3n+TcEo3ZRQMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCM7l4B8uTloTFQgDwFgtHdK0CevDy5aDTPvykYpZsSCkbpLK2RzMBSMLJoWIgQ4CAVgcYmTgHy5KShIVCALAWC0d0rQJ68PDQ6BB5a8rBMHbtzl1adp3nz5mXrp0+fLgMHDrT6uLazOrGAwFsCvD7lPwrm+TcFo3TzRcEonaU1khlYCkYWDQsRAhykItDYxClAnpw0NAQKkKVAMLp7BciTl4fGKgI/uu8nMvPeb8qsfb4rn3/v8VaPFStWyJgxY2T9+vUyZMgQWbp0aaVodPkfr5Av3P11uWT6v8rJ7zvJ2o4FBKoJ8PpUTSVf68zzbwpG6eaGglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgdPcKkCcvD42dBPQVQtOu+1Blbeei0X/8x3/I0UcfXWm//vrr5fDDD5dysajc8Kcj76h6hVK5na8IaAFen/KfA/P8m4JRuvmiYJTO0hrJDCwFI4uGhQgBDlIRaGziFCBPThoaAgXIUiAY3b0C5MnLQ2MVgc7FH7NotN9++8ncuXMrW33gAx+QI7/3qezKovJKs395HV8RqCbA61M1lXytM8+/KRilmxsKRuksrZHMwFIwsmhYiBDgIBWBxiZOAfLkpKEhUIAsBYLR3StAnrw8NDoEqhWN9hq0p2y//fb2Fh9pE9l/aGUdxaIKBd/UIMDrUw1Im7iLef5NwSjdZFAwSmdpjWQGloKRRcNChAAHqQg0NnEKkCcnDQ2BAmQpEIzuXgHy5OWh0SFwzjnnyI//MktWvbej0qPf/NfljRtfqSxLp2LRZn9slVEPvFk8OvLII+Xb3/722335DoEqArw+VUHJ2Srz/JuCUbrJoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgGN29AuTJy0NjFYF169bJyJEjZe3atdK5KCT/s1rkd+vd698ab9CgQbJ8+XJpb2+v8hNYhcCbArw+5T8J5vk3BaN080XBKJ2lNZIZWApGFg0LEQIcpCLQ2MQpQJ6cNDQECpClQDC6ewXIk5eHxioCixcvlp122klKpdKbrZ2uJJLX1FVHA1rf3rJcRHp7jbS0tMiiRYtk8uTJxlq+RcAW4PXJ9sjjknn+TcEo3QxRMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCM7l4B8uTlodEhcPfdd8uMGTNkxYoVb/boXDQqb1elWDRixAiZPXu27L333uVefEWgqgCvT1VZcrXSPP+mYJRuaigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCEZ3rwB58vLQ6BF47rnn5JOf/KTcf//9b/b6zgj7yiJ9pdHZbxWU3hpn9913l+uvv14mTJjgGZkmBN4U4PUp/0kwz78pGKWbLwpG6SytkczAUjCyaFiIEOAgFYHGJk4B8uSkoSFQgCwFgtHdK0CevDw0diOg72N0yimnyOV/+5n1aWiVzYwrjD7/+c/LxRdfLAMHDqw08w0CPgFen3w6+Wgzz78pGKWbEwpG6SytkczAUjCyaFiIEOAgFYHGJk4B8uSkoSFQgCwFgtHdK0CevDw01iBw+nVnykVLrnm7p+MeRnPmzJF999337X58h0A3Arw+dQOUg2bz/JuCUboJoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgGN29AuTJy0NjNwKX//EK+cLdX3+7V/mKos73NFLrT530Zbnooove7st3CHQjwOtTN0A5aDbPvykYpZsQCkbpLK2RzMBSMLJoWIgQ4CAVgcYmTgHy5KShIVCALAWC0d0rQJ68PDR6BJzFovI2nYpGfee/Lmv+c7m0tbWVe/AVAa8Ar09enlw0muffFIzSTQkFo3SW1khmYCkYWTQsRAhwkIpAYxOnAHly0tAQKECWAsHo7hUgT14eGh0CvmKRvkfR8ccfL7/85S9lxe6vWvc2Om3csXLhERc4RmU1ArYAr0+2Rx6XzPNvCkbpZoiCUTpLayQzsBSMLBoWIgQ4SEWgsYlTgDw5aWgIFCBLgWB09wqQJy8PjVUEfMUi/Slop556qmyxxRYyfvx4Ofroo+X+EQ9ZRaNZ+3xXPv/e46uMzCoEbAFen2yPPC6Z598UjNLNEAWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwejuFSBPXh4aOwk8tORhmXbdhyprz9jqc/KrM/5Tnn/+edGfgnb++efLwoULs/bp06fLxo0bZebMmXLFCz+3ikZ/OvIOmTp258o4fINANQFen6qp5Gudef5NwSjd3FAwSmdpjWQGloKRRcNChAAHqQg0NnEKkCcnDQ2BAmQpEIzuXgHy5OWhsYrAj+77icy895tSvlLo5ZdflrvuuksOPfRQWb9+vdx7773ZVrpg1L9/f+no6JCbb75Znt38eTn1gW/LJdP/VU5+30lVRmYVArYAr0+2Rx6XzPNvCkbpZoiCUTpLayQzsBSMLBoWIgQ4SEWgsYlTgDw5aWgIFCBLgWB09wqQJy8PjQ4BfaVRtSuEusuTazvHj2F1wQW6y1PBeXKx++b5NwWjdFNCwSidpTWSGVgKRhYNCxECHKQi0NjEKUCenDQ0BAqQpUAwunsFyJOXh8ZAAfIUCEZ3rwB58vLkotE8/6ZglG5KKBils7RGMgNLwciiYSFCgINUBBqbOAXIk5OGhkABshQIRnevAHny8tAYKECeAsHo7hUgT16eXDSa598UjNJNCQWjdJbWSGZgKRhZNCxECHCQikBjE6cAeXLS0BAoQJYCwejuFSBPXh4aAwXIUyAY3b0C5MnLk4tG8/ybglG6KaFglM7SGskMLAUji4aFCAEOUhFobOIUIE9OGhoCBchSIBjdvQLkyctDY6AAeQoEo7tXgDx5eXLRaJ5/UzBKNyUUjNJZWiOZgaVgZNGwECHAQSoCjU2cAuTJSUNDoABZCgSju1eAPHl5aAwUIE+BYHT3CpAnL08uGs3zbwpG6aaEglE6S2skM7AUjCwaFiIEOEhFoLGJU4A8OWloCBQgS4FgdPcKkCcvD42BAuQpEIzuXgHy5OXJRaN5/k3BKN2UUDBKZ2mNZAaWgpFFw0KEAAepCDQ2cQqQJycNDYECZCkQjO5eAfLk5aExUIA8BYLR3StAnrw8uWg0z78pGKWbEgpG6SytkczAUjCyaFiIEOAgFYHGJk4B8uSkoSFQgCwFgtHdK0CevDw0BgqQp0AwunsFyJOXJxeN5vk3BaN0U0LBKJ2lNZIZWApGFg0LEQIcpCLQ2MQpQJ6cNDQECpClQDC6ewXIk5eHxkAB8hQIRnevAHny8uSi0Tz/pmCUbkooGKWztEYyA0vByKJhIUKAg1QEGps4BciTk4aGQAGyFAhGd68AefLy0BgoQJ4CwejuFSBPXp5cNJrn3xSM0k0JBaN0ltZIZmApGFk0LEQIcJCKQGMTpwB5ctLQEChAlgLB6O4VIE9eHhoDBchTIBjdvQLkycuTi0bz/JuCUbopoWCUztIayQwsBSOLhoUIAQ5SEWhs4hQgT04aGgIFyFIgGN29AuTJy0NjoAB5CgSju1eAPHl5ctFonn9TMEo3JRSM0llaI5mBpWBk0bAQIcBBKgKNTZwC5MlJQ0OgAFkKBKO7V4A8eXloDBQgT4FgdPcKkCcvTy4azfNvCkbppoSCUTpLayQzsBSMLBoWIgQ4SEWgsYlTgDw5aWgIFCBLgWB09wqQJy8PjYEC5CkQjO5eAfLk5clFo3n+TcEo3ZRQMEpnaY1kBpaCkUXDQoQAB6kINDZxCpAnJw0NgQJkKRCM7l4B8uTloTFQgDwFgtHdK0CevDy5aDTPvykYpZsSCkbpLK2RzMBSMLJoWIgQ4CAVgcYmTgHy5KShIVCALAWC0d0rQJ68PDQGCpCnQDC6ewXIk5cnF43m+TcFo3RTQsEonaU1khlYCkYWDQsRAhykItDYxClAnpw0NAQKkKVAMLp7BciTl4fGQAHyFAhGd68AefLy5KLRPP+mYJRuSigYpbO0RjIDS8HIomEhQoCDVAQamzgFyJOThoZAAbIUCEZ3rwB58vLQGChAngLB6O4VIE9enlw0muffFIzSTQkFo3SW1khmYCkYWTQsRAhwkIpAYxOnAHly0tAQKECWAsHo7hUgT14eGgMFyFMgGN29AuTJy5OLRvP8m4JRuimhYJTO0hrJDCwFI4uGhQgBDlIRaGziFCBPThoaAgXIUiAY3b0C5MnLQ2OgAHkKBKO7V4A8eXly0Wief1MwSjclFIzSWVojmYGlYGTRsBAhwEEqAo1NnALkyUlDQ6AAWQoEo7tXgDx5eWgMFCBPgWB09wqQJy9PLhrN828KRummhIJROktrpCVLlsi4ceOydQ8++KBstdVWVjsLCIQIrFu3Th544IFsk1133VXa29tDNqcvApYAebI4WKhDgCzVgcemXQTIUxcSVtQhQJ7qwGPTLgLkqQtJ7lYsW7ZMJk+enD2vF154QcaOHZu759gbnxAFowbN2iOPPFIJbIN+BMMigAACCCCAAAIIIIAAAggggIAhsHjxYtlhhx2MNXwbK0DBKFaum+3mzp0r++23Xze9aEYAAQQQQAABBBBAAAEEEEAAgVQCFIxSSYpQMEpnaY30/PPPy4QJE7J1Cx9eKKPHjLbaWUAgRMC8xFK/AI4aNSpkc/oiYAmQJ4uDhToEyFIdeGzaRYA8dSFhRR0C5KkOPDbtIkCeupDkbsWGDRtk5cqV2fPabrvtpK2tLXfPsTc+IQpGDZo1brrVINiCDkueCjrxDdpt8tQg2AIOS5YKOOkN3GXy1EDcAg5Nngo46Q3cZfLUQFyGzrUABaMGTQ8vKg2CLeiw5KmgE9+g3SZPDYIt4LBkqYCT3sBdJk8NxC3g0OSpgJPewF0mTw3EZehcC1AwatD08KLSINiCDkueCjrxDdpt8tQg2AIOS5YKOOkN3GXy1EDcAg5Nngo46Q3cZfLUQFyGzrUABaMGTQ8vKg2CLeiw5KmgE9+g3SZPDYIt4LBkqYCT3sBdJk8NxC3g0OSpgJPewF0mTw3EZehcC1AwatD08KLSINiCDkueCjrxDdpt8tQg2AIOS5YKOOkN3GXy1EDcAg5Nngo46Q3cZfLUQFyGzrUABaMGTQ8vKg2CLeiw5KmgE9+g3SZPDYIt4LBkqYCT3sBdJk8NxC3g0OSpgJPewF0mTw3EZehcC1AwatD08KLSINiCDkueCjrxDdpt8tQg2AIOS5YKOOkN3GXy1EDcAg5Nngo46Q3cZfLUQFyGzrUABaMGTQ8vKg2CLeiw5KmgE9+g3SZPDYIt4LBkqYCT3sBdJk8NxC3g0OSpgJPewF0mTw3EZehcC1AwyvX08OQQQAABBBBAAAEEEEAAAQQQQACBnhegYNTz5vxEBBBAAAEEEEAAAQQQQAABBBBAINcCFIxyPT08OQQQQAABBBBAAAEEEEAAAQQQQKDnBSgY9bw5PxEBBBBAAAEEEEAAAQQQQAABBBDItQAFo1xPD08OAQQQQAABBBBAAAEEEEAAAQQQ6HkBCkY9b85PRAABBBBAAAEEEEAAAQQQQAABBHItQMEo19PDk0MAAQQQQAABBBBAAAEEEEAAAQR6XoCCUc+b8xMRQAABBBBAAAEEEEAAAQQQQACBXAtQMMr19PDkEEAAAQQQQAABBBBAAAEEEEAAgZ4XoGDU8+b8RAQQQAABBBBAAAEEEEAAAQQQQCDXAhSMcj09PDkEEEAAAQQQQAABBBBAAAEEEECg5wUoGDXAfO3atfLYY4/JwoUL5YEHHpB58+bJI488kv2k97znPfLoo492+1OXLFki48aN67af7nDaaafJhRdeWFNfOvU+gRR5Mvf6qaeekquuukpuvfVWeeKJJ2TzzTeXXXbZRY466ig57LDDpE+fPmZ3vi+YwIwZM2T27Nk17XWpVKqpH52aU+DFF1+Uq6++Wm666absuDZo0CCZMmWKHHnkkdnrSXt7e3PuOHuVTKClpaWmsQ499NAsZzV1plNTCqxYsUL+/Oc/y8MPPywLFiyQO++8U5YuXZrta8zvwffcc49cc801MnfuXHn22Wdl4sSJsu+++8qxxx4re+21V1MaslNvC6TIk/5dSf/OVMtDHyf16xgPBHqlgPqFn0diAfXioc+iqv5TBaOaftoLL7xQdftq46oDZU1j0ql3CqTIU3nPr7/++lK/fv2c2TrggANKK1euLHfnawEF1C80znx0fv0pIA+7/JbAXXfdVRo2bJgzK9OmTSs999xzeCHgFej8muJa1q9LPIot4MqGXh/ye/DGjRtLX/3qV52vXXq8r33tayXdj0fzCqTIkyoCeXNk/gzdlwcCvVWAK4zUf82pH+Zf6Lfcckt5//vfL7/97W/llVdekZgrjH7605/Khz70IefTHDp0qGyxxRbOdhp6t0CKPGkBfaXbfvvtJx0dHTJhwgQ599xzZeedd5ZVq1bJz372M7n88sszqIMOOii7wqS1tbV3w/HsowTKedt///3lsssu846x7bbbettpbE6Bxx9/XKZOnSrr1q2TIUOGyPe//32Zvsd0Wff6uuwqkPPPPz/bcVU0yl53Bg4c2JwQ7FXdAuUrjM4++2z57Gc/6xxvwIABNV917RyEhl4tUM6K3olJkyZlv79cd9112T6FXGH0gx/8QM4888xsO/07kSoeZb8TqQJ39lo2Z86crE33O/3007Pv+b/mE0iRJ/MKo/nz53vPxfT5oD5e8kCgVwr01kpXnp/3r371q5IqEFl/XdVXFqmAlGKuMKIqnefZbvxzS5GnN954o7TjjjtmGdRXBTz//PNdnvg555xT+UsJmevCU5gV5SuM+It+YaY8eEcPPvjg7LVCvX21tPDhhV22v+KKKyqvJZdcckmXdlYgUBbQvxfpf+SkLMJXl8DFF19cUsWc0j/+8Y+si3klfq1XGP31r38t6dctnTn1R5GSKnpbP+61117L1ut23Y+rJC2eplpIkSfzCiOdRx4INKuANOuO5W2/KBjlbUZ69/MJzdNtt91WOYH793//96o7r39RGjVqVNZv9913r9qHlc0vQMGo+ee4nj1U9xCpvJacddZZVYfSb+XYbbfdsn7qHmklXbDmgUA1AQpG1VRYV4tATMFIXclWef1S9xmt+mP0+nIu9R/SeBRDICZPFIyKkQ32Ut2wFISeEQg9wTdfuLjao2fmqDf9lNA8nXTSSZVfgJYvX+7cVX0CWP5FSf8ljkfxBCgYFW/OQ/ZYvU2j8hqxaNEi56a6MF1+LVGX6jv70VBsgXJGuMKo2DmI2Xvz9+RarjBSb8cvvfOd78xel3bddVfvj3zve9+b9VNvuy7p7Xg0v0BonrQIBaPmzwV7+KYABaMeSkLoCb75wkXBqIcmqRf9mNA8vfvd785++dG/BPke+q2U5V/gb7zxRl9X2ppUgIJRk05sot0qvx1NfSJaacOGDc5R9VvVyq8l+tJ/HghUEyhnhIJRNR3W+QTM35NrKRj97W9/q7wmua6OLP+8r3/965W+ejsezS8QmictQsGo+XPBHr4pQMGoh5IQeoJvvnCpm2aX1EcVl9ra2rJPpdFvF9IHu0cffbSHnj0/Jm8CIXlas2ZN5Refz33uc95deeyxxyp91Y1rvX1pbE6BcsFI3Ri9pD81b8SIEdlrj/5L63HHHVeaPftm3mLUnFNf016NHTs2e43YZ599vP3VzfQrryVf/OIXvX1pLK5AuWCkf6/Rb2Nsb28vqRvDltQHMpROPfXUkvr49OLisOdeAfP35FoKRvr+R+W8XXPNNd6xr7766krfu+++29uXxuYQCM2T3muzYKQ/0Xjrrbcu9e3btzR69OjShz/84dJFF11U+vvf/94cQOxFoQUoGPXQ9Iec4OunZL5wlQ9w1b7qwtHrr7/eQ3vBj8mLQEiennnmmcovPt/4xje8u7By5cpK3y9/+cvevjQ2p0C5YFTt9aa8Tp/cPf30080JwF45BfSxppyBY445xtmv3KCvQtL9DzzwwPIqviJgCZTz5Pv6z//8zyX1KbPWdiwgYP6eXEvBSH2iWuX16/bbb/cC6vZyJvV2PJpfIDRPWsQsGJXz0vmr/mM/GWr+/DT7HrboHVTh5tFgge23317U1RuiTvRFXRnU7U9bsmSJqKuK5Nhjj5W99tpbtn7HO6Stf5ssW7ZM9Ed+XnDBBaJ+gcrG+cpXviI/+tGPuh2TDs0jEJKnRx55RCZPnpztvP746/LHyVbTUCeEov7CmzXpjzhWf4Wr1o11TSzwiU98QtSnw8hHP/rR7PVKfaqeqKvUZPHixXLppZeK+ot/tvfqCiS5//77Rf0lrYk12DVTQBWURV1xlq068cQTszyY7Z2/1xlRn8go06dPF/2RwzwQ6CygioqirlwU/fHm22yzjQwcOFBWrFgh9913X/YR50uXLs02UYVs+a//+i9Rf73vPATLBRXQvyePGzcu23tVMJILL7zQK3HllVfK8ccfn/W55557ZM8993T21+1777131n7VVVdlGXV2pqEpBELzpHd69uzZov4QK5/+9KdF3fJBxowZk1no497NN98s6l5++sKMbJ36xGP55Cc/mX3P/yHQ6wSavSKWl/0LuSJEP+f169eX9KdWuR7PPvtsadKkSZW/gNx1112urqxvQoGQPD344IOVnHR3LxH96UbqRSz7d/jhhzehHLvUncDq1audXfSnXem/5JYzon75dvalofkE1Ml7Ze5POeWUbnewfO80/ZZqHghUE/C93uiPT1eFpErmfv7zn1cbgnUFFQi9IuQnP/lJJUvqjx1eNd1ePs6pP5R4+9LYHAKhedJ7ra989N0UXb8NUr9FTWdJFcNLvg+daQ5F9qJZBQr7lrTygaCeryE3ow45wa81bGYhQFWta92Mfg0QqCdH5W0blSd1ZUjlFx91hZF379etW1fpq64w8valcdMJlDNTz9eQvJl7qm90XP4EGf3zeX++qdPc36srPyqvD+oKo253dvz48Vl/dYVRt33pgEA1AX3D4fIJl76vEQ8EygKhJ/hXXHFF5fVLXUFUHqbq13nz5lX6qiuMqvZhZXMJhOap1r3XBcfy72o//elPa92MfgjkSoCC0VtXU5T/Yw75GnLC1YiCkU6SvpeIfs76PbL66hAem0YgJDeuvo3KE/cw2jSZaORPdWUoZH1I3jrvi/mL96233tq5meUmFeAeRk06sTnfraOPPrpywvXSSy/l/Nny9HpKIPQEn3sY9dTM9M6fE5qnWvdSXynZ0tKSvYYdccQRtW5GPwRyJVDYexj99a9/VedW9T0233xzGTx4cE2DhNxzpqYB3+qkPn0me4+sXtTv+x8+fHjI5vRNJJDnPK1du1b0fSL0Q31Kmuj38bsejz/+eHbfGt2uPiVNvva1r7m6sn4TCvR03jrvqvrUGNl3332z1ap4JOqmtJ27sNykAvoeDfq+MupT0mTu3LnOvVRvNZLNNtssa9fHqcsuu8zZlwYEfAL6WKQ+5jzrou+ltsMOO/i601YQgdB7zujXK32vLP3Q92fU92l0PXS7vreWfujjXfl+Rq7+rO/9AqF5Ctljfa8tPb76I392f7aQbemLQC4EclW+auIn06grjPTHFasgZf/02wV4FEMgNE/le4notxL5Hr/97W8rebrxxht9XWkrsID+mOHy646+2ohHcQQOPvjgbO71J6Dptye6HgsfXljJSHf3TnONwXoEtIAqGFWypN9izQMBLRB6RYh+e2P5uKU/Ydj3UAXKSl+9HY/mFwjNU4iIKhhledLvCuGBQG8UKOxb0np6skJP8Gt9fnvssUf2IsRb0moVa45+oXk66aSTKr/8+G66p3+JKv9Cpa5iaQ4s9iK5gLpKrZKT3/zmN8nHZ8D8CvzgBz+ozP2iRYucT1R9Okyln/qENGc/GhDoTuCYY46pZIl7pnWnVZz20BN8fXPid77znVmWdt11Vy+Ubte/C2277bbemxp7B6GxVwmE5qnWndN/zC+/JY37zdaqRr+8CVAw6qEZCT3Br+VpPfTQQ5VfovhEq1rEmqdPaJ5uu+22Slb0iVy1h/5UvlGjRmX9+CtINSHWaQF9Vcluu+1WyZP+5CwexRH485//XJl711/p9f30yhlRb90u6U/X44FAjIC+uqNfv35Z5vi0vRjB5t0m5gT/7LPPrrx+LVy4sCqOXl/+w9k555xTtQ8rm08gJk+1KOgbXZfzxCfu1SJGnzwKUDDqoVkJPcH//e9/7/2rxnPPPVeaNGlS5UXojjvu6KE94cfkQSA0T/qEbccdd8zyMmzYsNLzzz/fZTf0L0blg1o9N0TuMjAreo3AggULSr6PudY5Ou200yo5OfbYY3vNvvFE0wmU35bWp0+fkn7rWeeHeVP0Sy65pHMzywhkAnfddZf3bY36ZrHqnjOV15urr74aOQQqAjEn+PrK6dbW1ixT+++/f0l/Mqz50Mt6vf5dSL++Pfvss2Yz3zexQGiedP/HHnvMKzJnzpxKwbu9vZ1PlfVq0ZhngcLe9FodDBr2UCfjoj7y3hr/S1/6Unaj0NGjR3e5+ae+md7IkSOt/uryRVEfISuf+tSnZOrUqaK3U287k2XLlon6JUsuuOACeeWVV7Jt9Niqgm1tz0LzCKTIk9ZQHxOb3fBRXZYtEyZMkPPOO0/UX2xF35z2Zz/7mcyaNStDO+igg2T27NmifqlqHkT2pCaB008/XS6//HJRhaDsJp/q8v3sxv76xunqypLsdeb+++/PxlIfmS5/+MMfRN/MkUexBPTN8fVxSZ1cyZAhQ7LjkXp7tKhPURNVbJbvfve7Gci0adOy152BAwcWC4i9rUlAfxiIzsxnPvMZUW8Bkq3GbSX92/vLypUrs9cW9fbH7EaxejB9XLrhhhuy34NqGpxOTSegrqoXVcCp7Jf+oJfyBy780z/9U+X7codDDz20/K31VefqzDPPzNbpm2DrD/fQvxOpP8TK9773PVEn+Vmb7qePiTyaU6DePP3xj3/MXrc+8pGPyCGHHCL69ax8Lqd/b9e/R6sr+vWFGRngtddem53TNacme9X0AnmuZvXW56avzlDBqfnfAw880GVXa91eX16rP+qYR/MKpMhTWef666+v/LWjWsYOOOCAkvplvdydrwUTMK8eqpaP8ro999yz9Je//KVgOuyuKaCvDtFXK5Yz0fmrKhaV9JWwPBBwCZSvlO2cnc7LX/jCF7xXPrrGZ31zCdR6fCrnx7X3+i2zqmDkfO3S23/1q18t6X48mleg3jzpc7dy1nxf1R9MSr/61a+aF5I9K4QAVxip/8pTP3RVecaMGTUPq150RH16ldVf/4VDX6V03333yZNPPim6Wr1q1SpR94MQ9dai7EqRI444QtQN+aztWGg+gRR5MlWeeuopUTctFvWJaPLEE0/IiBEjsr+SHHXUUXLYYYeJugzb7M73BRJ45plnso8Q1lcRqfs4iLp/SPYX/gEDBoi+2kgVirK/pKlL9rkCrUC5cO3qiy++KFdddZWoT1QUfdWRvpJIXxmrj01HH320qEvwXZuyHgHRf6HXv+PoKxV1ftRbPER9KIMMHz5c1Cd7yr777itHfPII2WnKTmghkF3tc9FFF9Usoc7ivH31VdfXXHNNdkWR/h1bXzWrrzg67rjjZK+99vJuS2PvF9BXj9WTJ33l9Z133in6HE7/zqSvftNXqam37suYMWNE3cdPPvjBD4q60XX2e3bvF2MPiixAwajIs8++I4AAAggggAACCCCAAAIIIIAAAlUEKBhVQWEVAggggAACCCCAAAIIIIAAAgggUGQBCkZFnn32HQEEEEAAAQQQQAABBBBAAAEEEKgiQMGoCgqrEEAAAQQQQAABBBBAAAEEEEAAgSILUDAq8uyz7wgggAACCCCAAAIIIIAAAggggEAVAQpGVVBYhQACCCCAAAIIIIAAAggggAACCBRZgIJRkWeffUcAAQQQQAABBBBAAAEEEEAAAQSqCFAwqoLCKgQQQAABBBBAAAEEEEAAAQQQQKDIAhSMijz77DsCCCCAAAIIIIAAAggggAACCCBQRYCCURUUViGAAAIIIIAAAggggAACCCCAAAJFFqBgVOTZZ98RQAABBBBAAAEEEEAAAQQQQACBKgIUjKqgsAoBBBBAAAEEEEAAAQQQQAABBBAosgAFoyLPPvuOAAIIIIAAAggggAACCCCAAAIIVBGgYFQFhVUIIIAAAggggAACCCCAAAIIIIBAkQUoGBV59tl3BBBAAAEEEEAAAQQQQAABBBBAoIoABaMqKKxCAAEEEEAAAQQQQAABBBBAAAEEiixAwajIs8++I4AAAggggAACCCCAAAIIIIAAAlUEKBhVQWEVAggggAACCCCAAAIIIIAAAgggUGQBCkZFnn32HQEEEEAAAQQQQAABBBBAAAEEEKgiQMGoCgqrEEAAAQQQQAABBBBAAAEEEEAAgSILUDAq8uyz7wgggAACCCCAAAIIIIAAAggggEAVAQpGVVBYhQACCCCAAAIIIIAAAggggAACCBRZgIJRkWeffUcAAQQQQAABBBBAAAEEEEAAAQSqCFAwqoLCKgQQQAABBBBAAAEEEEAAAQQQQKDIAhSMijz77DsCCCCAAAIIIIAAAggggAACCCBQRYCCURUUViGAAAIIIIAAAggggAACCCCAAAJFFqBgVOTZZ98RQAABBBBAAAEEEEAAAQQQQACBKgIUjKqgsAoBBBBAAAEEEEAAAQQQQAABBBAosgAFoyLPPvuOAAIIIIAAAggggAACCCCAAAIIVBGgYFQFhVUIIIAAAggggAACCCCAAAIIIIBAkQUoGBV59tl3BBBAAAEEEEAAAQQQQAABBBBAoIoABaMqKKxCAAEEEEAAAQQQQAABBBBAAAEEiixAwajIs8++I4AAAggggAACCCCAAAIIIIAAAlUEKBhVQWEVAggggAACCCCAAAIIIIAAAgggUGQBCkZFnn32HQEEEEAAAQQQQAABBBBAAAEEEKgiQMGoCgqrEEAAAQQQQAABBBBAAAEEEEAAgSIL/H8oVzrPrACkCwAAAABJRU5ErkJggg==\n", "text/plain": [ "" - ] + ], + "image/png": "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" }, - "execution_count": 11, "metadata": { "image/png": { "width": 600 } }, - "output_type": "execute_result" + "execution_count": 11 } ], - "source": [ - "from IPython.display import Image\n", - "Image(filename=\"animation.png\",width=600)" - ] + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Simulation\n", "\n", @@ -46,39 +45,39 @@ "- Black line: dead reckoning \n", "- Blue line: ground truth\n", "- Red line: EKF SLAM position estimation" - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Introduction\n", "\n", "EKF SLAM models the SLAM problem in a single EKF where the modeled state is both the pose $(x, y, \\theta)$ and \n", "an array of landmarks $[(x_1, y_1), (x_2, x_y), ... , (x_n, y_n)]$ for $n$ landmarks. The covariance between each of the positions and landmarks are also tracked. " - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "\\begin{equation}\n", + "$\\begin{equation}\n", "X = \\begin{bmatrix} x \\\\ y \\\\ \\theta \\\\ x_1 \\\\ y_1 \\\\ x_2 \\\\ y_2 \\\\ \\dots \\\\ x_n \\\\ y_n \\end{bmatrix}\n", - "\\end{equation}\n", + "\\end{equation}$\n", "\n", - "\\begin{equation}\n", + "$\\begin{equation}\n", "P = \\begin{bmatrix} \n", "\\sigma_{xx} & \\sigma_{xy} & \\sigma_{x\\theta} & \\sigma_{xx_1} & \\sigma_{xy_1} & \\sigma_{xx_2} & \\sigma_{xy_2} & \\dots & \\sigma_{xx_n} & \\sigma_{xy_n} \\\\\n", "\\sigma_{yx} & \\sigma_{yy} & \\sigma_{y\\theta} & \\sigma_{yx_1} & \\sigma_{yy_1} & \\sigma_{yx_2} & \\sigma_{yy_2} & \\dots & \\sigma_{yx_n} & \\sigma_{yy_n} \\\\\n", " & & & & \\vdots & & & & & \\\\\n", "\\sigma_{x_nx} & \\sigma_{x_ny} & \\sigma_{x_n\\theta} & \\sigma_{x_nx_1} & \\sigma_{x_ny_1} & \\sigma_{x_nx_2} & \\sigma_{x_ny_2} & \\dots & \\sigma_{x_nx_n} & \\sigma_{x_ny_n}\n", "\\end{bmatrix}\n", - "\\end{equation}" - ] + "\\end{equation}$" + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "A single estimate of the pose is tracked over time, while the confidence in the pose is tracked by the \n", "covariance matrix $P$. $P$ is a symmetric square matrix whith each element in the matrix corresponding to the \n", @@ -86,26 +85,26 @@ "belief of $x$ and $y$ and is equal to $\\sigma_{yx}$. \n", "\n", "The state can be represented more concisely as follows. " - ] + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ - "\\begin{equation}\n", + "$\\begin{equation}\n", "X = \\begin{bmatrix} x \\\\ m \\end{bmatrix}\n", - "\\end{equation}\n", - "\\begin{equation}\n", + "\\end{equation}$\n", + "$\\begin{equation}\n", "P = \\begin{bmatrix} \n", "\\Sigma_{xx} & \\Sigma_{xm}\\\\\n", "\\Sigma_{mx} & \\Sigma_{mm}\\\\\n", "\\end{bmatrix}\n", - "\\end{equation}" - ] + "\\end{equation}$" + ], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "Here the state simplifies to a combination of pose ($x$) and map ($m$). The covariance matrix becomes easier to \n", "understand and simply reads as the uncertainty of the robots pose ($\\Sigma_{xx}$), the uncertainty of the \n", @@ -113,13 +112,12 @@ "($\\Sigma_{xm}$, $\\Sigma_{mx}$).\n", "\n", "Take care to note the difference between $X$ (state) and $x$ (pose). " - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 22, - "metadata": {}, - "outputs": [], "source": [ "\"\"\"\n", "Extended Kalman Filter SLAM example\n", @@ -148,24 +146,24 @@ "LM_SIZE = 2 # LM state size [x,y]\n", "\n", "show_animation = True" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Algorithm Walkthrough\n", "\n", "At each time step, the following is done. \n", "- predict the new state using the control functions\n", "- update the belief in landmark positions based on the estimated state and measurements" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 1, - "metadata": {}, - "outputs": [], "source": [ "def ekf_slam(xEst, PEst, u, z):\n", " \"\"\"\n", @@ -187,11 +185,12 @@ " xEst, PEst = update(xEst, PEst, u, z, initP)\n", "\n", " return xEst, PEst\n" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 1- Predict\n", "**Predict State update:** The following equations describe the predicted motion model of the robot in case we provide only the control $(v,w)$, which are the linear and angular velocity repsectively. \n", @@ -287,13 +286,12 @@ "$\n", "\n", "Notice this uncertainty is only growing with respect to the pose, not the landmarks. " - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], "source": [ "def predict(xEst, PEst, u):\n", " \"\"\"\n", @@ -311,13 +309,13 @@ " # sigma = G*sigma*G.T + Noise\n", " PEst[0:S, 0:S] = G.T @ PEst[0:S, 0:S] @ G + Fx.T @ Cx @ Fx\n", " return xEst, PEst, G, Fx" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 3, - "metadata": {}, - "outputs": [], "source": [ "def motion_model(x, u):\n", " \"\"\"\n", @@ -337,11 +335,12 @@ "\n", " x = (F @ x) + (B @ u)\n", " return x" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## 2 - Update\n", "In the update phase, the observations of nearby landmarks are used to correct the location estimate. \n", @@ -392,13 +391,12 @@ "$\n", "P_{t} = (I-K_tH_t)\\bar{P_t}\n", "$" - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 23, - "metadata": {}, - "outputs": [], "source": [ "def update(xEst, PEst, u, z, initP):\n", " \"\"\"\n", @@ -434,13 +432,13 @@ " \n", " xEst[2] = pi_2_pi(xEst[2])\n", " return xEst, PEst\n" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 19, - "metadata": {}, - "outputs": [], "source": [ "def calc_innovation(lm, xEst, PEst, z, LMid):\n", " \"\"\"\n", @@ -492,11 +490,12 @@ " H = G @ F\n", "\n", " return H" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "markdown", - "metadata": {}, "source": [ "## Observation Step\n", "The observation step described here is outside the main EKF SLAM process and is primarily used as a method of\n", @@ -506,13 +505,12 @@ "\n", "Observations are based on the TRUE position of the robot. Error in dead reckoning and control functions are \n", "passed along here as well. " - ] + ], + "metadata": {} }, { "cell_type": "code", "execution_count": 24, - "metadata": {}, - "outputs": [], "source": [ "def observation(xTrue, xd, u, RFID):\n", " \"\"\"\n", @@ -548,13 +546,13 @@ "\n", " xd = motion_model(xd, ud)\n", " return xTrue, z, xd, ud" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 21, - "metadata": {}, - "outputs": [], "source": [ "def calc_n_LM(x):\n", " \"\"\"\n", @@ -590,13 +588,13 @@ " return G, Fx,\n", "\n", "\n" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 11, - "metadata": {}, - "outputs": [], "source": [ "def calc_LM_Pos(x, z):\n", " \"\"\"\n", @@ -665,13 +663,13 @@ "\n", "def pi_2_pi(angle):\n", " return (angle + math.pi) % (2 * math.pi) - math.pi" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 13, - "metadata": {}, - "outputs": [], "source": [ "def main():\n", " print(\" start!!\")\n", @@ -731,18 +729,22 @@ " plt.axis(\"equal\")\n", " plt.grid(True)\n", " plt.pause(0.001)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 20, - "metadata": { - "scrolled": false - }, + "source": [ + "%matplotlib notebook\n", + "%matplotlib notebook\n", + "main()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ " start!!\n", "New LM\n", @@ -751,810 +753,38 @@ ] }, { + "output_type": "display_data", "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('
');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '
');\n", - " var titletext = $(\n", - " '
');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('
');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('
')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('');\n button.click(method_name, toolbar_event);\n button.mouseover(tooltip, toolbar_mouse_event);\n nav_element.append(button);\n }\n\n // Add the status bar.\n var status_bar = $('');\n nav_element.append(status_bar);\n this.message = status_bar[0];\n\n // Add the close button to the window.\n var buttongrp = $('
');\n var button = $('');\n button.click(function (evt) { fig.handle_close(fig, {}); } );\n button.mouseover('Stop Interaction', toolbar_mouse_event);\n buttongrp.append(button);\n var titlebar = this.root.find($('.ui-dialog-titlebar'));\n titlebar.prepend(buttongrp);\n}\n\nmpl.figure.prototype._root_extra_style = function(el){\n var fig = this\n el.on(\"remove\", function(){\n\tfig.close_ws(fig, {});\n });\n}\n\nmpl.figure.prototype._canvas_extra_style = function(el){\n // this is important to make the div 'focusable\n el.attr('tabindex', 0)\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n }\n else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n\n}\n\nmpl.figure.prototype._key_event_extra = function(event, name) {\n var manager = IPython.notebook.keyboard_manager;\n if (!manager)\n manager = IPython.keyboard_manager;\n\n // Check for shift+enter\n if (event.shiftKey && event.which == 13) {\n this.canvas_div.blur();\n event.shiftKey = false;\n // Send a \"J\" for go to next cell\n event.which = 74;\n event.keyCode = 74;\n manager.command_mode();\n manager.handle_keydown(event);\n }\n}\n\nmpl.figure.prototype.handle_save = function(fig, msg) {\n fig.ondownload(fig, null);\n}\n\n\nmpl.find_output_cell = function(html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i=0; i= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] == html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n}\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel != null) {\n IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n}\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { + "output_type": "display_data", "data": { - "text/html": [ - "" - ], "text/plain": [ "" + ], + "text/html": [ + "" ] }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "New LM\n" ] } ], - "source": [ - "%matplotlib notebook\n", - "%matplotlib notebook\n", - "main()" - ] + "metadata": { + "scrolled": false + } } ], "metadata": { @@ -1578,4 +808,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file From 4fe851cc1d1f2e5d21684e24267d78c5e0299e36 Mon Sep 17 00:00:00 2001 From: Geonhee Date: Mon, 6 Sep 2021 20:46:28 +0900 Subject: [PATCH 047/604] Correct typos (#542) * Update cubic_spline_planner.py * Update rear_wheel_feedback.py --- PathPlanning/CubicSpline/cubic_spline_planner.py | 2 +- PathTracking/rear_wheel_feedback/rear_wheel_feedback.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/PathPlanning/CubicSpline/cubic_spline_planner.py b/PathPlanning/CubicSpline/cubic_spline_planner.py index 7ec01d1f4e..d2ef8622ad 100644 --- a/PathPlanning/CubicSpline/cubic_spline_planner.py +++ b/PathPlanning/CubicSpline/cubic_spline_planner.py @@ -195,7 +195,7 @@ def main(): # pragma: no cover import matplotlib.pyplot as plt x = [-2.5, 0.0, 2.5, 5.0, 7.5, 3.0, -1.0] y = [0.7, -6, 5, 6.5, 0.0, 5.0, -2.0] - ds = 0.1 # [m] distance of each intepolated points + ds = 0.1 # [m] distance of each interpolated points sp = Spline2D(x, y) s = np.arange(0, sp.s[-1], ds) diff --git a/PathTracking/rear_wheel_feedback/rear_wheel_feedback.py b/PathTracking/rear_wheel_feedback/rear_wheel_feedback.py index 52b4a11a0b..ff72454f34 100644 --- a/PathTracking/rear_wheel_feedback/rear_wheel_feedback.py +++ b/PathTracking/rear_wheel_feedback/rear_wheel_feedback.py @@ -12,7 +12,7 @@ from scipy import interpolate from scipy import optimize -Kp = 1.0 # speed propotional gain +Kp = 1.0 # speed proportional gain # steering control parameter KTH = 1.0 KE = 0.5 From a2fc9f914ade3ecb6cda7e687acb39b3f8fc2e46 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 16 Sep 2021 21:10:36 +0900 Subject: [PATCH 048/604] Bump pandas from 1.3.2 to 1.3.3 (#543) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.3.2 to 1.3.3. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.3.2...v1.3.3) --- updated-dependencies: - dependency-name: pandas dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 55d3e523fd..7363658a5f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.2 scipy == 1.7.1 -pandas == 1.3.2 +pandas == 1.3.3 matplotlib == 3.4.3 cvxpy == 1.1.15 From acc3604f738f2c47942f4e06f99c02b896bd3ae0 Mon Sep 17 00:00:00 2001 From: szaguldo-kamaz <86873213+szaguldo-kamaz@users.noreply.github.com> Date: Sun, 3 Oct 2021 16:40:44 +0900 Subject: [PATCH 049/604] Limit play area in RRT (#540) * add support for limiting the play area * plot the play area * Update rrt.py * fix param list * fix code style * fix more code style * fix code style even more --- PathPlanning/RRT/rrt.py | 46 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 43 insertions(+), 3 deletions(-) diff --git a/PathPlanning/RRT/rrt.py b/PathPlanning/RRT/rrt.py index 834fb24e39..dfbd4b1b7f 100644 --- a/PathPlanning/RRT/rrt.py +++ b/PathPlanning/RRT/rrt.py @@ -32,6 +32,15 @@ def __init__(self, x, y): self.path_y = [] self.parent = None + class AreaBounds: + + def __init__(self, area): + self.xmin = float(area[0]) + self.xmax = float(area[1]) + self.ymin = float(area[2]) + self.ymax = float(area[3]) + + def __init__(self, start, goal, @@ -40,7 +49,9 @@ def __init__(self, expand_dis=3.0, path_resolution=0.5, goal_sample_rate=5, - max_iter=500): + max_iter=500, + play_area=None + ): """ Setting Parameter @@ -48,12 +59,17 @@ def __init__(self, goal:Goal Position [x,y] obstacleList:obstacle Positions [[x,y,size],...] randArea:Random Sampling Area [min,max] + play_area:stay inside this area [xmin,xmax,ymin,ymax] """ self.start = self.Node(start[0], start[1]) self.end = self.Node(goal[0], goal[1]) self.min_rand = rand_area[0] self.max_rand = rand_area[1] + if play_area is not None: + self.play_area = self.AreaBounds(play_area) + else: + self.play_area = None self.expand_dis = expand_dis self.path_resolution = path_resolution self.goal_sample_rate = goal_sample_rate @@ -76,7 +92,8 @@ def planning(self, animation=True): new_node = self.steer(nearest_node, rnd_node, self.expand_dis) - if self.check_collision(new_node, self.obstacle_list): + if self.check_if_outside_play_area(new_node, self.play_area) and \ + self.check_collision(new_node, self.obstacle_list): self.node_list.append(new_node) if animation and i % 5 == 0: @@ -163,6 +180,15 @@ def draw_graph(self, rnd=None): for (ox, oy, size) in self.obstacle_list: self.plot_circle(ox, oy, size) + if self.play_area is not None: + plt.plot([self.play_area.xmin, self.play_area.xmax, + self.play_area.xmax, self.play_area.xmin, + self.play_area.xmin], + [self.play_area.ymin, self.play_area.ymin, + self.play_area.ymax, self.play_area.ymax, + self.play_area.ymin], + "-k") + plt.plot(self.start.x, self.start.y, "xr") plt.plot(self.end.x, self.end.y, "xr") plt.axis("equal") @@ -186,6 +212,18 @@ def get_nearest_node_index(node_list, rnd_node): return minind + @staticmethod + def check_if_outside_play_area(node, play_area): + + if play_area is None: + return True # no play_area was defined, every pos should be ok + + if node.x < play_area.xmin or node.x > play_area.xmax or \ + node.y < play_area.ymin or node.y > play_area.ymax: + return False # outside - bad + else: + return True # inside - ok + @staticmethod def check_collision(node, obstacleList): @@ -222,7 +260,9 @@ def main(gx=6.0, gy=10.0): start=[0, 0], goal=[gx, gy], rand_area=[-2, 15], - obstacle_list=obstacleList) + obstacle_list=obstacleList, + # play_area=[0, 10, 0, 14] + ) path = rrt.planning(animation=show_animation) if path is None: From ee729d6b6ef1809c4cd402531e8fdce91a54d155 Mon Sep 17 00:00:00 2001 From: The-Anh Vu-Le <26211510+vltanh@users.noreply.github.com> Date: Sun, 3 Oct 2021 17:31:08 +0700 Subject: [PATCH 050/604] Modify notations (#548) * Modify notations I modified some of the notations so that it will be less confusing: - It is better to specify of which the Jacobian matrix is, here it is the transition and measurement function `f` and `g` (writing it as `J_F` and `J_H` is misleading) - It is better to use `Delta` so as not to confuse people with the `d` commonly used in derivative - It is more correct to use `\partial` instead of `d` since it is more multivariate than it is not * Update docs/modules/extended_kalman_filter_localization.rst * Update docs/modules/extended_kalman_filter_localization.rst Co-authored-by: Atsushi Sakai --- .../extended_kalman_filter_localization.rst | 36 +++++++++++-------- 1 file changed, 22 insertions(+), 14 deletions(-) diff --git a/docs/modules/extended_kalman_filter_localization.rst b/docs/modules/extended_kalman_filter_localization.rst index 565fb4ed20..5021563b5b 100644 --- a/docs/modules/extended_kalman_filter_localization.rst +++ b/docs/modules/extended_kalman_filter_localization.rst @@ -77,32 +77,36 @@ Motion Model The robot model is -.. math:: \dot{x} = vcos(\phi) +.. math:: \dot{x} = v \cos(\phi) -.. math:: \dot{y} = vsin((\phi) +.. math:: \dot{y} = v \sin(\phi) .. math:: \dot{\phi} = \omega So, the motion model is -.. math:: \textbf{x}_{t+1} = F\textbf{x}_t+B\textbf{u}_t +.. math:: \textbf{x}_{t+1} = f(\textbf{x}_t, \textbf{u}_t) = F\textbf{x}_t+B\textbf{u}_t where :math:`\begin{equation*} F= \begin{bmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 \\ \end{bmatrix} \end{equation*}` -:math:`\begin{equation*} B= \begin{bmatrix} cos(\phi)dt & 0\\ sin(\phi)dt & 0\\ 0 & dt\\ 1 & 0\\ \end{bmatrix} \end{equation*}` +:math:`\begin{equation*} B= \begin{bmatrix} cos(\phi) \Delta t & 0\\ sin(\phi) \Delta t & 0\\ 0 & \Delta t\\ 1 & 0\\ \end{bmatrix} \end{equation*}` -:math:`dt` is a time interval. +:math:`\Delta t` is a time interval. This is implemented at `code `__ +The motion function is that + +:math:`\begin{equation*} \begin{bmatrix} x' \\ y' \\ w' \\ v' \end{bmatrix} = f(\textbf{x}, \textbf{u}) = \begin{bmatrix} x + v\cos(\phi)\Delta t \\ y + v\sin(\phi) \\ \phi + \omega \Delta t \\ v \end{bmatrix} \end{equation*}` + Its Jacobian matrix is -:math:`\begin{equation*} J_F= \begin{bmatrix} \frac{dx}{dx}& \frac{dx}{dy} & \frac{dx}{d\phi} & \frac{dx}{dv}\\ \frac{dy}{dx}& \frac{dy}{dy} & \frac{dy}{d\phi} & \frac{dy}{dv}\\ \frac{d\phi}{dx}& \frac{d\phi}{dy} & \frac{d\phi}{d\phi} & \frac{d\phi}{dv}\\ \frac{dv}{dx}& \frac{dv}{dy} & \frac{dv}{d\phi} & \frac{dv}{dv}\\ \end{bmatrix} \end{equation*}` +:math:`\begin{equation*} J_f = \begin{bmatrix} \frac{\partial x'}{\partial x}& \frac{\partial x'}{\partial y} & \frac{\partial x'}{\partial \phi} & \frac{\partial x'}{\partial v}\\ \frac{\partial y'}{\partial x}& \frac{\partial y'}{\partial y} & \frac{\partial y'}{\partial \phi} & \frac{\partial y'}{\partial v}\\ \frac{\partial \phi'}{\partial x}& \frac{\partial \phi'}{\partial y} & \frac{\partial \phi'}{\partial \phi} & \frac{\partial \phi'}{\partial v}\\ \frac{\partial v'}{\partial x}& \frac{\partial v'}{\partial y} & \frac{\partial v'}{\partial \phi} & \frac{\partial v'}{\partial v} \end{bmatrix} \end{equation*}` -:math:`\begin{equation*}  = \begin{bmatrix} 1& 0 & -v sin(\phi)dt & cos(\phi)dt\\ 0 & 1 & v cos(\phi)dt & sin(\phi) dt\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 1\\ \end{bmatrix} \end{equation*}` +:math:`\begin{equation*}  = \begin{bmatrix} 1& 0 & -v \sin(\phi) \Delta t & \cos(\phi) \Delta t\\ 0 & 1 & v \cos(\phi) \Delta t & \sin(\phi) \Delta t\\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \end{equation*}` Observation Model ~~~~~~~~~~~~~~~~~ @@ -111,15 +115,19 @@ The robot can get x-y position infomation from GPS. So GPS Observation model is -.. math:: \textbf{z}_{t} = H\textbf{x}_t +.. math:: \textbf{z}_{t} = g(\textbf{x}_t) = H \textbf{x}_t where -:math:`\begin{equation*} B= \begin{bmatrix} 1 & 0 & 0& 0\\ 0 & 1 & 0& 0\\ \end{bmatrix} \end{equation*}` +:math:`\begin{equation*} H = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ \end{bmatrix} \end{equation*}` + +The observation function states that + +:math:`\begin{equation*} \begin{bmatrix} x' \\ y' \end{bmatrix} = g(\textbf{x}) = \begin{bmatrix} x \\ y \end{bmatrix} \end{equation*}` Its Jacobian matrix is -:math:`\begin{equation*} J_H= \begin{bmatrix} \frac{dx}{dx}& \frac{dx}{dy} & \frac{dx}{d\phi} & \frac{dx}{dv}\\ \frac{dy}{dx}& \frac{dy}{dy} & \frac{dy}{d\phi} & \frac{dy}{dv}\\ \end{bmatrix} \end{equation*}` +:math:`\begin{equation*} J_g = \begin{bmatrix} \frac{\partial x'}{\partial x} & \frac{\partial x'}{\partial y} & \frac{\partial x'}{\partial \phi} & \frac{\partial x'}{\partial v}\\ \frac{\partial y'}{\partial x}& \frac{\partial y'}{\partial y} & \frac{\partial y'}{\partial \phi} & \frac{\partial y'}{ \partialv}\\ \end{bmatrix} \end{equation*}` :math:`\begin{equation*}  = \begin{bmatrix} 1& 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ \end{bmatrix} \end{equation*}` @@ -132,7 +140,7 @@ Localization process using Extendted Kalman Filter:EKF is :math:`x_{Pred} = Fx_t+Bu_t` -:math:`P_{Pred} = J_FP_t J_F^T + Q` +:math:`P_{Pred} = J_f P_t J_f^T + Q` === Update === @@ -140,13 +148,13 @@ Localization process using Extendted Kalman Filter:EKF is :math:`y = z - z_{Pred}` -:math:`S = J_H P_{Pred}.J_H^T + R` +:math:`S = J_g P_{Pred}.J_g^T + R` -:math:`K = P_{Pred}.J_H^T S^{-1}` +:math:`K = P_{Pred}.J_g^T S^{-1}` :math:`x_{t+1} = x_{Pred} + Ky` -:math:`P_{t+1} = ( I - K J_H) P_{Pred}` +:math:`P_{t+1} = ( I - K J_g) P_{Pred}` Ref: ~~~~ From 90c6cfa27584b5d72349459a93bc655b062e7444 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 19 Oct 2021 07:10:21 +0900 Subject: [PATCH 051/604] Bump pandas from 1.3.3 to 1.3.4 (#553) Bumps [pandas](https://github.com/pandas-dev/pandas) from 1.3.3 to 1.3.4. - [Release notes](https://github.com/pandas-dev/pandas/releases) - [Changelog](https://github.com/pandas-dev/pandas/blob/master/RELEASE.md) - [Commits](https://github.com/pandas-dev/pandas/compare/v1.3.3...v1.3.4) --- updated-dependencies: - dependency-name: pandas dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 7363658a5f..a4a84bdf76 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.2 scipy == 1.7.1 -pandas == 1.3.3 +pandas == 1.3.4 matplotlib == 3.4.3 cvxpy == 1.1.15 From 187b6aa35f3cbdeca587c0abdb177adddefc5c2a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 26 Oct 2021 19:36:03 +0900 Subject: [PATCH 052/604] Bump numpy from 1.21.2 to 1.21.3 (#554) Bumps [numpy](https://github.com/numpy/numpy) from 1.21.2 to 1.21.3. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.21.2...v1.21.3) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index a4a84bdf76..48660d08a6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.21.2 +numpy == 1.21.3 scipy == 1.7.1 pandas == 1.3.4 matplotlib == 3.4.3 From ea052a9829210d378a47d35edddaf9c99492a113 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 9 Nov 2021 07:53:34 +0900 Subject: [PATCH 053/604] Bump numpy from 1.21.3 to 1.21.4 (#558) Bumps [numpy](https://github.com/numpy/numpy) from 1.21.3 to 1.21.4. - [Release notes](https://github.com/numpy/numpy/releases) - [Changelog](https://github.com/numpy/numpy/blob/main/doc/HOWTO_RELEASE.rst.txt) - [Commits](https://github.com/numpy/numpy/compare/v1.21.3...v1.21.4) --- updated-dependencies: - dependency-name: numpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 48660d08a6..0157212e47 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -numpy == 1.21.3 +numpy == 1.21.4 scipy == 1.7.1 pandas == 1.3.4 matplotlib == 3.4.3 From 26ed1ab631a4dc77bbdf861b951fc3a25bd57756 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 9 Nov 2021 07:54:03 +0900 Subject: [PATCH 054/604] Bump cvxpy from 1.1.15 to 1.1.17 (#560) Bumps [cvxpy](https://github.com/cvxpy/cvxpy) from 1.1.15 to 1.1.17. - [Release notes](https://github.com/cvxpy/cvxpy/releases) - [Changelog](https://github.com/cvxpy/cvxpy/blob/master/CHANGELOG.md) - [Commits](https://github.com/cvxpy/cvxpy/compare/v1.1.15...v1.1.17) --- updated-dependencies: - dependency-name: cvxpy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 0157212e47..f9af4fd2ab 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ numpy == 1.21.4 scipy == 1.7.1 pandas == 1.3.4 matplotlib == 3.4.3 -cvxpy == 1.1.15 +cvxpy == 1.1.17 From 4d3fb2825cf66f6a9f7680d5ef399d89df01c8d3 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 9 Nov 2021 20:58:17 +0900 Subject: [PATCH 055/604] Bump scipy from 1.7.1 to 1.7.2 (#559) Bumps [scipy](https://github.com/scipy/scipy) from 1.7.1 to 1.7.2. - [Release notes](https://github.com/scipy/scipy/releases) - [Commits](https://github.com/scipy/scipy/compare/v1.7.1...v1.7.2) --- updated-dependencies: - dependency-name: scipy dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index f9af4fd2ab..77a0bea427 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ numpy == 1.21.4 -scipy == 1.7.1 +scipy == 1.7.2 pandas == 1.3.4 matplotlib == 3.4.3 cvxpy == 1.1.17 From 0df55e943e661162230aa96bdb352e5bb8459da9 Mon Sep 17 00:00:00 2001 From: Jonathan Schwartz Date: Fri, 12 Nov 2021 05:28:16 -0500 Subject: [PATCH 056/604] Dynamic Movement Primitives Implementation (#526) * Without equals sign, sometimes get points that are in the wrong direction - relative to the points before and after it- when change in x or change in y along path is 0 * Created test script for dubins path generator * Made len == 0 it's own case, also changed 'l' to 'len' to appease travisCI * More variable renaming to appease CI * Broke == 0 into its own case in dubins planner, also Renaming files to appease CI * Reverting some naming changes * Turns out theres already a test for dubins.. not sure how I missed that * Note to self: run the test cases on your own before throwing them at CI * Added handling of length=0 case in generate_local_course() * Missed reverting 'mode' back to 'm' in one spot * Addressing style issues (line length) * Mostly works, now just need to setup linear regression to solve for weights * Re-arranged class * Wrote DMP program and added tests file * Styling fixes * More styling * Missed one indent * Multi-dimension path learning (e.g. in x and y instead of just x) * Added potential field obstacle avoidance * Potential field working much better but has issues with reaching goal state * Path ending to short not a result of obstacles, should be fix-able * Mostly working! end won't go to goal * split DMP and path following * pretty close * Okay this is working pretty well * looks.. okay. was using the wrong vector before * a plan to fix this mess * Okay seriously going to pivot to the dubins approach im done with potential field lol * Finished obstacle circle handling (and merging circles that are closer than their radii) * Finished circle event finder function * Some progress in preparing for dubins curves * Finished angle finding algo, need to test * Okay getting back to this, going to ignore the navigation and just focus on path generation since that's what DMP is for * Moved DMP files to path planning * changed folder name * Made demo path cooler * All working and added visualization tools (will remove * Fixed unit test and handled TODOs * not gonna handle this one * demo now scales with data * CI errors * CI errors * Fixing code style issues * more styling * fixing CI errors * formatting * Removed dead code * removed unused imports * removed uneccesary initialization * Applying PR feedback * fixing CI errors * added description to header and removed unused variable --- .../dynamic_movement_primitives.py | 261 ++++++++++++++++++ tests/test_dynamic_movement_primitives.py | 49 ++++ 2 files changed, 310 insertions(+) create mode 100644 PathPlanning/DynamicMovementPrimitives/dynamic_movement_primitives.py create mode 100644 tests/test_dynamic_movement_primitives.py diff --git a/PathPlanning/DynamicMovementPrimitives/dynamic_movement_primitives.py b/PathPlanning/DynamicMovementPrimitives/dynamic_movement_primitives.py new file mode 100644 index 0000000000..468d3b9f97 --- /dev/null +++ b/PathPlanning/DynamicMovementPrimitives/dynamic_movement_primitives.py @@ -0,0 +1,261 @@ +""" +Author: Jonathan Schwartz (github.com/SchwartzCode) + +This code provides a simple implementation of Dynamic Movement +Primitives, which is an approach to learning curves by modelling +them as a weighted sum of gaussian distributions. This approach +can be used to dampen noise in a curve, and can also be used to +stretch a curve by adjusting its start and end points. + +More information on Dynamic Movement Primitives available at: +https://arxiv.org/abs/2102.03861 +https://www.frontiersin.org/articles/10.3389/fncom.2013.00138/full + +""" + + +from matplotlib import pyplot as plt +import numpy as np + + +class DMP(object): + + def __init__(self, training_data, data_period, K=156.25, B=25): + """ + Arguments: + training_data - input data of form [N, dim] + data_period - amount of time training data covers + K and B - spring and damper constants to define + DMP behavior + """ + + self.K = K # virtual spring constant + self.B = B # virtual damper coefficient + + self.timesteps = training_data.shape[0] + self.dt = data_period / self.timesteps + + self.weights = None # weights used to generate DMP trajectories + + self.T_orig = data_period + + self.training_data = training_data + self.find_basis_functions_weights(training_data, data_period) + + def find_basis_functions_weights(self, training_data, data_period, + num_weights=10): + """ + Arguments: + data [(steps x spacial dim) np array] - data to replicate with DMP + data_period [float] - time duration of data + """ + + if not isinstance(training_data, np.ndarray): + print("Warning: you should input training data as an np.ndarray") + elif training_data.shape[0] < training_data.shape[1]: + print("Warning: you probably need to transpose your training data") + + dt = data_period / len(training_data) + + init_state = training_data[0] + goal_state = training_data[-1] + + # means (C) and std devs (H) of gaussian basis functions + C = np.linspace(0, 1, num_weights) + H = (0.65*(1./(num_weights-1))**2) + + for dim, _ in enumerate(training_data[0]): + + dimension_data = training_data[:, dim] + + q0 = init_state[dim] + g = goal_state[dim] + + q = q0 + qd_last = 0 + + phi_vals = [] + f_vals = [] + + for i, _ in enumerate(dimension_data): + if i + 1 == len(dimension_data): + qd = 0 + else: + qd = (dimension_data[i+1] - dimension_data[i]) / dt + + phi = [np.exp(-0.5 * ((i * dt / data_period) - c)**2 / H) + for c in C] + phi = phi/np.sum(phi) + + qdd = (qd - qd_last)/dt + + f = (qdd * data_period**2 - self.K * (g - q) + self.B * qd + * data_period) / (g - q0) + + phi_vals.append(phi) + f_vals.append(f) + + qd_last = qd + q += qd * dt + + phi_vals = np.asarray(phi_vals) + f_vals = np.asarray(f_vals) + + w = np.linalg.lstsq(phi_vals, f_vals, rcond=None) + + if self.weights is None: + self.weights = np.asarray(w[0]) + else: + self.weights = np.vstack([self.weights, w[0]]) + + def recreate_trajectory(self, init_state, goal_state, T): + """ + init_state - initial state/position + goal_state - goal state/position + T - amount of time to travel q0 -> g + """ + + nrBasis = len(self.weights[0]) # number of gaussian basis functions + + # means (C) and std devs (H) of gaussian basis functions + C = np.linspace(0, 1, nrBasis) + H = (0.65*(1./(nrBasis-1))**2) + + # initialize virtual system + time = 0 + + q = init_state + dimensions = self.weights.shape[0] + qd = np.zeros(dimensions) + + positions = np.array([]) + for k in range(self.timesteps): + time = time + self.dt + + qdd = np.zeros(dimensions) + + for dim in range(dimensions): + + if time <= T: + phi = [np.exp(-0.5 * ((time / T) - c)**2 / H) for c in C] + phi = phi / np.sum(phi) + f = np.dot(phi, self.weights[dim]) + else: + f = 0 + + # simulate dynamics + qdd[dim] = (self.K*(goal_state[dim] - q[dim])/T**2 + - self.B*qd[dim]/T + + (goal_state[dim] - init_state[dim])*f/T**2) + + qd = qd + qdd * self.dt + q = q + qd * self.dt + + if positions.size == 0: + positions = q + else: + positions = np.vstack([positions, q]) + + t = np.arange(0, self.timesteps * self.dt, self.dt) + return t, positions + + @staticmethod + def dist_between(p1, p2): + return np.linalg.norm(p1 - p2) + + def view_trajectory(self, path, title=None, demo=False): + + path = np.asarray(path) + + plt.cla() + plt.plot(self.training_data[:, 0], self.training_data[:, 1], + label="Training Data") + plt.plot(path[:, 0], path[:, 1], + linewidth=2, label="DMP Approximation") + + plt.xlabel("X Position") + plt.ylabel("Y Position") + plt.legend() + + if title is not None: + plt.title(title) + + if demo: + plt.xlim([-0.5, 5]) + plt.ylim([-2, 2]) + plt.draw() + plt.pause(0.02) + else: + plt.show() + + def show_DMP_purpose(self): + """ + This function conveys the purpose of DMPs: + to capture a trajectory and be able to stretch + and squeeze it in terms of start and stop position + or time + """ + + q0_orig = self.training_data[0] + g_orig = self.training_data[-1] + T_orig = self.T_orig + + data_range = (np.amax(self.training_data[:, 0]) + - np.amin(self.training_data[:, 0])) / 4 + + q0_right = q0_orig + np.array([data_range, 0]) + q0_up = q0_orig + np.array([0, data_range/2]) + g_left = g_orig - np.array([data_range, 0]) + g_down = g_orig - np.array([0, data_range/2]) + + q0_vals = np.vstack([np.linspace(q0_orig, q0_right, 20), + np.linspace(q0_orig, q0_up, 20)]) + g_vals = np.vstack([np.linspace(g_orig, g_left, 20), + np.linspace(g_orig, g_down, 20)]) + T_vals = np.linspace(T_orig, 2*T_orig, 20) + + for new_q0_value in q0_vals: + plot_title = "Initial Position = [%s, %s]" % \ + (round(new_q0_value[0], 2), round(new_q0_value[1], 2)) + + _, path = self.recreate_trajectory(new_q0_value, g_orig, T_orig) + self.view_trajectory(path, title=plot_title, demo=True) + + for new_g_value in g_vals: + plot_title = "Goal Position = [%s, %s]" % \ + (round(new_g_value[0], 2), round(new_g_value[1], 2)) + + _, path = self.recreate_trajectory(q0_orig, new_g_value, T_orig) + self.view_trajectory(path, title=plot_title, demo=True) + + for new_T_value in T_vals: + plot_title = "Period = %s [sec]" % round(new_T_value, 2) + + _, path = self.recreate_trajectory(q0_orig, g_orig, new_T_value) + self.view_trajectory(path, title=plot_title, demo=True) + + +def example_DMP(): + """ + Creates a noisy trajectory, fits weights to it, and then adjusts the + trajectory by moving its start position, goal position, or period + """ + t = np.arange(0, 3*np.pi/2, 0.01) + t1 = np.arange(3*np.pi/2, 2*np.pi, 0.01)[:-1] + t2 = np.arange(0, np.pi/2, 0.01)[:-1] + t3 = np.arange(np.pi, 3*np.pi/2, 0.01) + data_x = t + 0.02*np.random.rand(t.shape[0]) + data_y = np.concatenate([np.cos(t1) + 0.1*np.random.rand(t1.shape[0]), + np.cos(t2) + 0.1*np.random.rand(t2.shape[0]), + np.sin(t3) + 0.1*np.random.rand(t3.shape[0])]) + training_data = np.vstack([data_x, data_y]).T + + period = 3*np.pi/2 + DMP_controller = DMP(training_data, period) + + DMP_controller.show_DMP_purpose() + + +if __name__ == '__main__': + + example_DMP() diff --git a/tests/test_dynamic_movement_primitives.py b/tests/test_dynamic_movement_primitives.py new file mode 100644 index 0000000000..3ab1c8a32c --- /dev/null +++ b/tests/test_dynamic_movement_primitives.py @@ -0,0 +1,49 @@ +import conftest +import numpy as np +from PathPlanning.DynamicMovementPrimitives import \ + dynamic_movement_primitives + + +def test_1(): + # test that trajectory can be learned from user-passed data + T = 5 + t = np.arange(0, T, 0.01) + sin_t = np.sin(t) + train_data = np.array([t, sin_t]).T + + DMP_controller = dynamic_movement_primitives.DMP(train_data, T) + DMP_controller.recreate_trajectory(train_data[0], train_data[-1], 4) + + +def test_2(): + # test that length of trajectory is equal to desired number of timesteps + T = 5 + t = np.arange(0, T, 0.01) + sin_t = np.sin(t) + train_data = np.array([t, sin_t]).T + + DMP_controller = dynamic_movement_primitives.DMP(train_data, T) + t, path = DMP_controller.recreate_trajectory(train_data[0], + train_data[-1], 4) + + assert(path.shape[0] == DMP_controller.timesteps) + + +def test_3(): + # check that learned trajectory is close to initial + T = 3*np.pi/2 + A_noise = 0.02 + t = np.arange(0, T, 0.01) + noisy_sin_t = np.sin(t) + A_noise*np.random.rand(len(t)) + train_data = np.array([t, noisy_sin_t]).T + + DMP_controller = dynamic_movement_primitives.DMP(train_data, T) + t, pos = DMP_controller.recreate_trajectory(train_data[0], + train_data[-1], T) + + diff = abs(pos[:, 1] - noisy_sin_t) + assert(max(diff) < 5*A_noise) + + +if __name__ == '__main__': + conftest.run_this_test(__file__) From 17920dcbf489dff0f804ac541973c1c7b8ed77f0 Mon Sep 17 00:00:00 2001 From: Kajal Date: Fri, 12 Nov 2021 11:29:36 +0100 Subject: [PATCH 057/604] Changes in Slam/Ekf_slam.ipynb file, added a dtype=object statement to jF=np.array so it can render the output without numerous depreciation warnings (#552) --- SLAM/EKFSLAM/ekf_slam.ipynb | 1163 ++++++++++++++++++++++++++++++++--- 1 file changed, 1068 insertions(+), 95 deletions(-) diff --git a/SLAM/EKFSLAM/ekf_slam.ipynb b/SLAM/EKFSLAM/ekf_slam.ipynb index f4c9d61436..7634bfde9e 100644 --- a/SLAM/EKFSLAM/ekf_slam.ipynb +++ b/SLAM/EKFSLAM/ekf_slam.ipynb @@ -2,39 +2,40 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# EKF SLAM" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 11, - "source": [ - "from IPython.display import Image\n", - "Image(filename=\"animation.png\",width=600)" - ], + "execution_count": 1, + "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", "text/plain": [ "" - ], - "image/png": "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" + ] }, + "execution_count": 1, "metadata": { "image/png": { "width": 600 } }, - "execution_count": 11 + "output_type": "execute_result" } ], - "metadata": {} + "source": [ + "from IPython.display import Image\n", + "Image(filename=\"animation.png\",width=600)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Simulation\n", "\n", @@ -45,21 +46,21 @@ "- Black line: dead reckoning \n", "- Blue line: ground truth\n", "- Red line: EKF SLAM position estimation" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Introduction\n", "\n", "EKF SLAM models the SLAM problem in a single EKF where the modeled state is both the pose $(x, y, \\theta)$ and \n", "an array of landmarks $[(x_1, y_1), (x_2, x_y), ... , (x_n, y_n)]$ for $n$ landmarks. The covariance between each of the positions and landmarks are also tracked. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "$\\begin{equation}\n", "X = \\begin{bmatrix} x \\\\ y \\\\ \\theta \\\\ x_1 \\\\ y_1 \\\\ x_2 \\\\ y_2 \\\\ \\dots \\\\ x_n \\\\ y_n \\end{bmatrix}\n", @@ -73,11 +74,11 @@ "\\sigma_{x_nx} & \\sigma_{x_ny} & \\sigma_{x_n\\theta} & \\sigma_{x_nx_1} & \\sigma_{x_ny_1} & \\sigma_{x_nx_2} & \\sigma_{x_ny_2} & \\dots & \\sigma_{x_nx_n} & \\sigma_{x_ny_n}\n", "\\end{bmatrix}\n", "\\end{equation}$" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "A single estimate of the pose is tracked over time, while the confidence in the pose is tracked by the \n", "covariance matrix $P$. $P$ is a symmetric square matrix whith each element in the matrix corresponding to the \n", @@ -85,11 +86,11 @@ "belief of $x$ and $y$ and is equal to $\\sigma_{yx}$. \n", "\n", "The state can be represented more concisely as follows. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "$\\begin{equation}\n", "X = \\begin{bmatrix} x \\\\ m \\end{bmatrix}\n", @@ -100,11 +101,11 @@ "\\Sigma_{mx} & \\Sigma_{mm}\\\\\n", "\\end{bmatrix}\n", "\\end{equation}$" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Here the state simplifies to a combination of pose ($x$) and map ($m$). The covariance matrix becomes easier to \n", "understand and simply reads as the uncertainty of the robots pose ($\\Sigma_{xx}$), the uncertainty of the \n", @@ -112,12 +113,13 @@ "($\\Sigma_{xm}$, $\\Sigma_{mx}$).\n", "\n", "Take care to note the difference between $X$ (state) and $x$ (pose). " - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ "\"\"\"\n", "Extended Kalman Filter SLAM example\n", @@ -146,24 +148,24 @@ "LM_SIZE = 2 # LM state size [x,y]\n", "\n", "show_animation = True" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Algorithm Walkthrough\n", "\n", "At each time step, the following is done. \n", "- predict the new state using the control functions\n", "- update the belief in landmark positions based on the estimated state and measurements" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, + "metadata": {}, + "outputs": [], "source": [ "def ekf_slam(xEst, PEst, u, z):\n", " \"\"\"\n", @@ -185,12 +187,11 @@ " xEst, PEst = update(xEst, PEst, u, z, initP)\n", "\n", " return xEst, PEst\n" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 1- Predict\n", "**Predict State update:** The following equations describe the predicted motion model of the robot in case we provide only the control $(v,w)$, which are the linear and angular velocity repsectively. \n", @@ -286,12 +287,13 @@ "$\n", "\n", "Notice this uncertainty is only growing with respect to the pose, not the landmarks. " - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, + "metadata": {}, + "outputs": [], "source": [ "def predict(xEst, PEst, u):\n", " \"\"\"\n", @@ -309,13 +311,13 @@ " # sigma = G*sigma*G.T + Noise\n", " PEst[0:S, 0:S] = G.T @ PEst[0:S, 0:S] @ G + Fx.T @ Cx @ Fx\n", " return xEst, PEst, G, Fx" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, + "metadata": {}, + "outputs": [], "source": [ "def motion_model(x, u):\n", " \"\"\"\n", @@ -335,12 +337,11 @@ "\n", " x = (F @ x) + (B @ u)\n", " return x" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 2 - Update\n", "In the update phase, the observations of nearby landmarks are used to correct the location estimate. \n", @@ -391,12 +392,13 @@ "$\n", "P_{t} = (I-K_tH_t)\\bar{P_t}\n", "$" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "def update(xEst, PEst, u, z, initP):\n", " \"\"\"\n", @@ -432,13 +434,13 @@ " \n", " xEst[2] = pi_2_pi(xEst[2])\n", " return xEst, PEst\n" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, + "metadata": {}, + "outputs": [], "source": [ "def calc_innovation(lm, xEst, PEst, z, LMid):\n", " \"\"\"\n", @@ -490,12 +492,11 @@ " H = G @ F\n", "\n", " return H" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Observation Step\n", "The observation step described here is outside the main EKF SLAM process and is primarily used as a method of\n", @@ -505,12 +506,13 @@ "\n", "Observations are based on the TRUE position of the robot. Error in dead reckoning and control functions are \n", "passed along here as well. " - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 8, + "metadata": {}, + "outputs": [], "source": [ "def observation(xTrue, xd, u, RFID):\n", " \"\"\"\n", @@ -546,13 +548,13 @@ "\n", " xd = motion_model(xd, ud)\n", " return xTrue, z, xd, ud" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 9, + "metadata": {}, + "outputs": [], "source": [ "def calc_n_LM(x):\n", " \"\"\"\n", @@ -580,7 +582,7 @@ "\n", " jF = np.array([[0.0, 0.0, -DT * u[0] * math.sin(x[2, 0])],\n", " [0.0, 0.0, DT * u[0] * math.cos(x[2, 0])],\n", - " [0.0, 0.0, 0.0]])\n", + " [0.0, 0.0, 0.0]],dtype=object)\n", "\n", " G = np.eye(STATE_SIZE) + Fx.T @ jF @ Fx\n", " if calc_n_LM(x) > 0:\n", @@ -588,13 +590,13 @@ " return G, Fx,\n", "\n", "\n" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, + "metadata": {}, + "outputs": [], "source": [ "def calc_LM_Pos(x, z):\n", " \"\"\"\n", @@ -663,13 +665,13 @@ "\n", "def pi_2_pi(angle):\n", " return (angle + math.pi) % (2 * math.pi) - math.pi" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, + "metadata": {}, + "outputs": [], "source": [ "def main():\n", " print(\" start!!\")\n", @@ -729,22 +731,18 @@ " plt.axis(\"equal\")\n", " plt.grid(True)\n", " plt.pause(0.001)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 20, - "source": [ - "%matplotlib notebook\n", - "%matplotlib notebook\n", - "main()" - ], + "execution_count": 12, + "metadata": { + "scrolled": false + }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ " start!!\n", "New LM\n", @@ -753,38 +751,1013 @@ ] }, { - "output_type": "display_data", "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "/* global mpl */\n", + "window.mpl = {};\n", + "\n", + "mpl.get_websocket_type = function () {\n", + " if (typeof WebSocket !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof MozWebSocket !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert(\n", + " 'Your browser does not have WebSocket support. ' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.'\n", + " );\n", + " }\n", + "};\n", + "\n", + "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = this.ws.binaryType !== undefined;\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById('mpl-warnings');\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent =\n", + " 'This browser does not support binary websocket messages. ' +\n", + " 'Performance may be slow.';\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = document.createElement('div');\n", + " this.root.setAttribute('style', 'display: inline-block');\n", + " this._root_extra_style(this.root);\n", + "\n", + " parent_element.appendChild(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message('supports_binary', { value: fig.supports_binary });\n", + " fig.send_message('send_image_mode', {});\n", + " if (fig.ratio !== 1) {\n", + " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", + " }\n", + " fig.send_message('refresh', {});\n", + " };\n", + "\n", + " this.imageObj.onload = function () {\n", + " if (fig.image_mode === 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function () {\n", + " fig.ws.close();\n", + " };\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "};\n", + "\n", + "mpl.figure.prototype._init_header = function () {\n", + " var titlebar = document.createElement('div');\n", + " titlebar.classList =\n", + " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", + " var titletext = document.createElement('div');\n", + " titletext.classList = 'ui-dialog-title';\n", + " titletext.setAttribute(\n", + " 'style',\n", + " 'width: 100%; text-align: center; padding: 3px;'\n", + " );\n", + " titlebar.appendChild(titletext);\n", + " this.root.appendChild(titlebar);\n", + " this.header = titletext;\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", + "\n", + "mpl.figure.prototype._init_canvas = function () {\n", + " var fig = this;\n", + "\n", + " var canvas_div = (this.canvas_div = document.createElement('div'));\n", + " canvas_div.setAttribute(\n", + " 'style',\n", + " 'border: 1px solid #ddd;' +\n", + " 'box-sizing: content-box;' +\n", + " 'clear: both;' +\n", + " 'min-height: 1px;' +\n", + " 'min-width: 1px;' +\n", + " 'outline: 0;' +\n", + " 'overflow: hidden;' +\n", + " 'position: relative;' +\n", + " 'resize: both;'\n", + " );\n", + "\n", + " function on_keyboard_event_closure(name) {\n", + " return function (event) {\n", + " return fig.key_event(event, name);\n", + " };\n", + " }\n", + "\n", + " canvas_div.addEventListener(\n", + " 'keydown',\n", + " on_keyboard_event_closure('key_press')\n", + " );\n", + " canvas_div.addEventListener(\n", + " 'keyup',\n", + " on_keyboard_event_closure('key_release')\n", + " );\n", + "\n", + " this._canvas_extra_style(canvas_div);\n", + " this.root.appendChild(canvas_div);\n", + "\n", + " var canvas = (this.canvas = document.createElement('canvas'));\n", + " canvas.classList.add('mpl-canvas');\n", + " canvas.setAttribute('style', 'box-sizing: content-box;');\n", + "\n", + " this.context = canvas.getContext('2d');\n", + "\n", + " var backingStore =\n", + " this.context.backingStorePixelRatio ||\n", + " this.context.webkitBackingStorePixelRatio ||\n", + " this.context.mozBackingStorePixelRatio ||\n", + " this.context.msBackingStorePixelRatio ||\n", + " this.context.oBackingStorePixelRatio ||\n", + " this.context.backingStorePixelRatio ||\n", + " 1;\n", + "\n", + " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", + " 'canvas'\n", + " ));\n", + " rubberband_canvas.setAttribute(\n", + " 'style',\n", + " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", + " );\n", + "\n", + " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", + " if (this.ResizeObserver === undefined) {\n", + " if (window.ResizeObserver !== undefined) {\n", + " this.ResizeObserver = window.ResizeObserver;\n", + " } else {\n", + " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", + " this.ResizeObserver = obs.ResizeObserver;\n", + " }\n", + " }\n", + "\n", + " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", + " var nentries = entries.length;\n", + " for (var i = 0; i < nentries; i++) {\n", + " var entry = entries[i];\n", + " var width, height;\n", + " if (entry.contentBoxSize) {\n", + " if (entry.contentBoxSize instanceof Array) {\n", + " // Chrome 84 implements new version of spec.\n", + " width = entry.contentBoxSize[0].inlineSize;\n", + " height = entry.contentBoxSize[0].blockSize;\n", + " } else {\n", + " // Firefox implements old version of spec.\n", + " width = entry.contentBoxSize.inlineSize;\n", + " height = entry.contentBoxSize.blockSize;\n", + " }\n", + " } else {\n", + " // Chrome <84 implements even older version of spec.\n", + " width = entry.contentRect.width;\n", + " height = entry.contentRect.height;\n", + " }\n", + "\n", + " // Keep the size of the canvas and rubber band canvas in sync with\n", + " // the canvas container.\n", + " if (entry.devicePixelContentBoxSize) {\n", + " // Chrome 84 implements new version of spec.\n", + " canvas.setAttribute(\n", + " 'width',\n", + " entry.devicePixelContentBoxSize[0].inlineSize\n", + " );\n", + " canvas.setAttribute(\n", + " 'height',\n", + " entry.devicePixelContentBoxSize[0].blockSize\n", + " );\n", + " } else {\n", + " canvas.setAttribute('width', width * fig.ratio);\n", + " canvas.setAttribute('height', height * fig.ratio);\n", + " }\n", + " canvas.setAttribute(\n", + " 'style',\n", + " 'width: ' + width + 'px; height: ' + height + 'px;'\n", + " );\n", + "\n", + " rubberband_canvas.setAttribute('width', width);\n", + " rubberband_canvas.setAttribute('height', height);\n", + "\n", + " // And update the size in Python. We ignore the initial 0/0 size\n", + " // that occurs as the element is placed into the DOM, which should\n", + " // otherwise not happen due to the minimum size styling.\n", + " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", + " fig.request_resize(width, height);\n", + " }\n", + " }\n", + " });\n", + " this.resizeObserverInstance.observe(canvas_div);\n", + "\n", + " function on_mouse_event_closure(name) {\n", + " return function (event) {\n", + " return fig.mouse_event(event, name);\n", + " };\n", + " }\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mousedown',\n", + " on_mouse_event_closure('button_press')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseup',\n", + " on_mouse_event_closure('button_release')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'dblclick',\n", + " on_mouse_event_closure('dblclick')\n", + " );\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband_canvas.addEventListener(\n", + " 'mousemove',\n", + " on_mouse_event_closure('motion_notify')\n", + " );\n", + "\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseenter',\n", + " on_mouse_event_closure('figure_enter')\n", + " );\n", + " rubberband_canvas.addEventListener(\n", + " 'mouseleave',\n", + " on_mouse_event_closure('figure_leave')\n", + " );\n", + "\n", + " canvas_div.addEventListener('wheel', function (event) {\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " on_mouse_event_closure('scroll')(event);\n", + " });\n", + "\n", + " canvas_div.appendChild(canvas);\n", + " canvas_div.appendChild(rubberband_canvas);\n", + "\n", + " this.rubberband_context = rubberband_canvas.getContext('2d');\n", + " this.rubberband_context.strokeStyle = '#000000';\n", + "\n", + " this._resize_canvas = function (width, height, forward) {\n", + " if (forward) {\n", + " canvas_div.style.width = width + 'px';\n", + " canvas_div.style.height = height + 'px';\n", + " }\n", + " };\n", + "\n", + " // Disable right mouse context menu.\n", + " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", + " event.preventDefault();\n", + " return false;\n", + " });\n", + "\n", + " function set_focus() {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'mpl-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " for (var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'mpl-button-group';\n", + " continue;\n", + " }\n", + "\n", + " var button = (fig.buttons[name] = document.createElement('button'));\n", + " button.classList = 'mpl-widget';\n", + " button.setAttribute('role', 'button');\n", + " button.setAttribute('aria-disabled', 'false');\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + "\n", + " var icon_img = document.createElement('img');\n", + " icon_img.src = '_images/' + image + '.png';\n", + " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", + " icon_img.alt = tooltip;\n", + " button.appendChild(icon_img);\n", + "\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " var fmt_picker = document.createElement('select');\n", + " fmt_picker.classList = 'mpl-widget';\n", + " toolbar.appendChild(fmt_picker);\n", + " this.format_dropdown = fmt_picker;\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = document.createElement('option');\n", + " option.selected = fmt === mpl.default_extension;\n", + " option.innerHTML = fmt;\n", + " fmt_picker.appendChild(option);\n", + " }\n", + "\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "};\n", + "\n", + "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", + "};\n", + "\n", + "mpl.figure.prototype.send_message = function (type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "};\n", + "\n", + "mpl.figure.prototype.send_draw_message = function () {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1], msg['forward']);\n", + " fig.send_message('refresh', {});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", + " var x0 = msg['x0'] / fig.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", + " var x1 = msg['x1'] / fig.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0,\n", + " 0,\n", + " fig.canvas.width / fig.ratio,\n", + " fig.canvas.height / fig.ratio\n", + " );\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch (cursor) {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_message = function (fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", + " for (var key in msg) {\n", + " if (!(key in fig.buttons)) {\n", + " continue;\n", + " }\n", + " fig.buttons[key].disabled = !msg[key];\n", + " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", + " if (msg['mode'] === 'PAN') {\n", + " fig.buttons['Pan'].classList.add('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " } else if (msg['mode'] === 'ZOOM') {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.add('active');\n", + " } else {\n", + " fig.buttons['Pan'].classList.remove('active');\n", + " fig.buttons['Zoom'].classList.remove('active');\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function () {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message('ack', {});\n", + "};\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function (fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " var img = evt.data;\n", + " if (img.type !== 'image/png') {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " img.type = 'image/png';\n", + " }\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src\n", + " );\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " img\n", + " );\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " } else if (\n", + " typeof evt.data === 'string' &&\n", + " evt.data.slice(0, 21) === 'data:image/png;base64'\n", + " ) {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig['handle_' + msg_type];\n", + " } catch (e) {\n", + " console.log(\n", + " \"No handler for the '\" + msg_type + \"' message type: \",\n", + " msg\n", + " );\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\n", + " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", + " e,\n", + " e.stack,\n", + " msg\n", + " );\n", + " }\n", + " }\n", + " };\n", + "};\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function (e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e) {\n", + " e = window.event;\n", + " }\n", + " if (e.target) {\n", + " targ = e.target;\n", + " } else if (e.srcElement) {\n", + " targ = e.srcElement;\n", + " }\n", + " if (targ.nodeType === 3) {\n", + " // defeat Safari bug\n", + " targ = targ.parentNode;\n", + " }\n", + "\n", + " // pageX,Y are the mouse positions relative to the document\n", + " var boundingRect = targ.getBoundingClientRect();\n", + " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", + " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", + "\n", + " return { x: x, y: y };\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys(original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object') {\n", + " obj[key] = original[key];\n", + " }\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function (event, name) {\n", + " var canvas_pos = mpl.findpos(event);\n", + "\n", + " if (name === 'button_press') {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * this.ratio;\n", + " var y = canvas_pos.y * this.ratio;\n", + "\n", + " this.send_message(name, {\n", + " x: x,\n", + " y: y,\n", + " button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event),\n", + " });\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "};\n", + "\n", + "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "};\n", + "\n", + "mpl.figure.prototype.key_event = function (event, name) {\n", + " // Prevent repeat events\n", + " if (name === 'key_press') {\n", + " if (event.key === this._key) {\n", + " return;\n", + " } else {\n", + " this._key = event.key;\n", + " }\n", + " }\n", + " if (name === 'key_release') {\n", + " this._key = null;\n", + " }\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.key !== 'Control') {\n", + " value += 'ctrl+';\n", + " }\n", + " else if (event.altKey && event.key !== 'Alt') {\n", + " value += 'alt+';\n", + " }\n", + " else if (event.shiftKey && event.key !== 'Shift') {\n", + " value += 'shift+';\n", + " }\n", + "\n", + " value += 'k' + event.key;\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", + " return false;\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", + " if (name === 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message('toolbar_button', { name: name });\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "\n", + "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", + "// prettier-ignore\n", + "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";/* global mpl */\n", + "\n", + "var comm_websocket_adapter = function (comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.binaryType = comm.kernel.ws.binaryType;\n", + " ws.readyState = comm.kernel.ws.readyState;\n", + " function updateReadyState(_event) {\n", + " if (comm.kernel.ws) {\n", + " ws.readyState = comm.kernel.ws.readyState;\n", + " } else {\n", + " ws.readyState = 3; // Closed state.\n", + " }\n", + " }\n", + " comm.kernel.ws.addEventListener('open', updateReadyState);\n", + " comm.kernel.ws.addEventListener('close', updateReadyState);\n", + " comm.kernel.ws.addEventListener('error', updateReadyState);\n", + "\n", + " ws.close = function () {\n", + " comm.close();\n", + " };\n", + " ws.send = function (m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function (msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " var data = msg['content']['data'];\n", + " if (data['blob'] !== undefined) {\n", + " data = {\n", + " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", + " };\n", + " }\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(data);\n", + " });\n", + " return ws;\n", + "};\n", + "\n", + "mpl.mpl_figure_comm = function (comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = document.getElementById(id);\n", + " var ws_proxy = comm_websocket_adapter(comm);\n", + "\n", + " function ondownload(figure, _format) {\n", + " window.open(figure.canvas.toDataURL());\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element;\n", + " fig.cell_info = mpl.find_output_cell(\"
\");\n", + " if (!fig.cell_info) {\n", + " console.error('Failed to find cell for figure', id, fig);\n", + " return;\n", + " }\n", + " fig.cell_info[0].output_area.element.on(\n", + " 'cleared',\n", + " { fig: fig },\n", + " fig._remove_fig_handler\n", + " );\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function (fig, msg) {\n", + " var width = fig.canvas.width / fig.ratio;\n", + " fig.cell_info[0].output_area.element.off(\n", + " 'cleared',\n", + " fig._remove_fig_handler\n", + " );\n", + " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable();\n", + " fig.parent_element.innerHTML =\n", + " '';\n", + " fig.close_ws(fig, msg);\n", + "};\n", + "\n", + "mpl.figure.prototype.close_ws = function (fig, msg) {\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "};\n", + "\n", + "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width / this.ratio;\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] =\n", + " '';\n", + "};\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function () {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message('ack', {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () {\n", + " fig.push_to_output();\n", + " }, 1000);\n", + "};\n", + "\n", + "mpl.figure.prototype._init_toolbar = function () {\n", + " var fig = this;\n", + "\n", + " var toolbar = document.createElement('div');\n", + " toolbar.classList = 'btn-toolbar';\n", + " this.root.appendChild(toolbar);\n", + "\n", + " function on_click_closure(name) {\n", + " return function (_event) {\n", + " return fig.toolbar_button_onclick(name);\n", + " };\n", + " }\n", + "\n", + " function on_mouseover_closure(tooltip) {\n", + " return function (event) {\n", + " if (!event.currentTarget.disabled) {\n", + " return fig.toolbar_button_onmouseover(tooltip);\n", + " }\n", + " };\n", + " }\n", + "\n", + " fig.buttons = {};\n", + " var buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " var button;\n", + " for (var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " /* Instead of a spacer, we start a new button group. */\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + " buttonGroup = document.createElement('div');\n", + " buttonGroup.classList = 'btn-group';\n", + " continue;\n", + " }\n", + "\n", + " button = fig.buttons[name] = document.createElement('button');\n", + " button.classList = 'btn btn-default';\n", + " button.href = '#';\n", + " button.title = name;\n", + " button.innerHTML = '';\n", + " button.addEventListener('click', on_click_closure(method_name));\n", + " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", + " buttonGroup.appendChild(button);\n", + " }\n", + "\n", + " if (buttonGroup.hasChildNodes()) {\n", + " toolbar.appendChild(buttonGroup);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = document.createElement('span');\n", + " status_bar.classList = 'mpl-message pull-right';\n", + " toolbar.appendChild(status_bar);\n", + " this.message = status_bar;\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = document.createElement('div');\n", + " buttongrp.classList = 'btn-group inline pull-right';\n", + " button = document.createElement('button');\n", + " button.classList = 'btn btn-mini btn-primary';\n", + " button.href = '#';\n", + " button.title = 'Stop Interaction';\n", + " button.innerHTML = '';\n", + " button.addEventListener('click', function (_evt) {\n", + " fig.handle_close(fig, {});\n", + " });\n", + " button.addEventListener(\n", + " 'mouseover',\n", + " on_mouseover_closure('Stop Interaction')\n", + " );\n", + " buttongrp.appendChild(button);\n", + " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", + " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", + "};\n", + "\n", + "mpl.figure.prototype._remove_fig_handler = function (event) {\n", + " var fig = event.data.fig;\n", + " if (event.target !== this) {\n", + " // Ignore bubbled events from children.\n", + " return;\n", + " }\n", + " fig.close_ws(fig, {});\n", + "};\n", + "\n", + "mpl.figure.prototype._root_extra_style = function (el) {\n", + " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", + "};\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function (el) {\n", + " // this is important to make the div 'focusable\n", + " el.setAttribute('tabindex', 0);\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " } else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager) {\n", + " manager = IPython.keyboard_manager;\n", + " }\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which === 13) {\n", + " this.canvas_div.blur();\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", + " fig.ondownload(fig, null);\n", + "};\n", + "\n", + "mpl.find_output_cell = function (html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i = 0; i < ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code') {\n", + " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] === html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "};\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel !== null) {\n", + " IPython.notebook.kernel.comm_manager.register_target(\n", + " 'matplotlib',\n", + " mpl.mpl_figure_comm\n", + " );\n", + "}\n" + ], "text/plain": [ "" - ], - "application/javascript": "/* Put everything inside the global mpl namespace */\nwindow.mpl = {};\n\n\nmpl.get_websocket_type = function() {\n if (typeof(WebSocket) !== 'undefined') {\n return WebSocket;\n } else if (typeof(MozWebSocket) !== 'undefined') {\n return MozWebSocket;\n } else {\n alert('Your browser does not have WebSocket support.' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.');\n };\n}\n\nmpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = (this.ws.binaryType != undefined);\n\n if (!this.supports_binary) {\n var warnings = document.getElementById(\"mpl-warnings\");\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent = (\n \"This browser does not support binary websocket messages. \" +\n \"Performance may be slow.\");\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = $('
');\n this._root_extra_style(this.root)\n this.root.attr('style', 'display: inline-block');\n\n $(parent_element).append(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n fig.send_message(\"send_image_mode\", {});\n if (mpl.ratio != 1) {\n fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n }\n fig.send_message(\"refresh\", {});\n }\n\n this.imageObj.onload = function() {\n if (fig.image_mode == 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function() {\n fig.ws.close();\n }\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n}\n\nmpl.figure.prototype._init_header = function() {\n var titlebar = $(\n '
');\n var titletext = $(\n '
');\n titlebar.append(titletext)\n this.root.append(titlebar);\n this.header = titletext[0];\n}\n\n\n\nmpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n\n}\n\n\nmpl.figure.prototype._root_extra_style = function(canvas_div) {\n\n}\n\nmpl.figure.prototype._init_canvas = function() {\n var fig = this;\n\n var canvas_div = $('
');\n\n canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n\n function canvas_keyboard_event(event) {\n return fig.key_event(event, event['data']);\n }\n\n canvas_div.keydown('key_press', canvas_keyboard_event);\n canvas_div.keyup('key_release', canvas_keyboard_event);\n this.canvas_div = canvas_div\n this._canvas_extra_style(canvas_div)\n this.root.append(canvas_div);\n\n var canvas = $('');\n canvas.addClass('mpl-canvas');\n canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n\n this.canvas = canvas[0];\n this.context = canvas[0].getContext(\"2d\");\n\n var backingStore = this.context.backingStorePixelRatio ||\n\tthis.context.webkitBackingStorePixelRatio ||\n\tthis.context.mozBackingStorePixelRatio ||\n\tthis.context.msBackingStorePixelRatio ||\n\tthis.context.oBackingStorePixelRatio ||\n\tthis.context.backingStorePixelRatio || 1;\n\n mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband = $('');\n rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n\n var pass_mouse_events = true;\n\n canvas_div.resizable({\n start: function(event, ui) {\n pass_mouse_events = false;\n },\n resize: function(event, ui) {\n fig.request_resize(ui.size.width, ui.size.height);\n },\n stop: function(event, ui) {\n pass_mouse_events = true;\n fig.request_resize(ui.size.width, ui.size.height);\n },\n });\n\n function mouse_event_fn(event) {\n if (pass_mouse_events)\n return fig.mouse_event(event, event['data']);\n }\n\n rubberband.mousedown('button_press', mouse_event_fn);\n rubberband.mouseup('button_release', mouse_event_fn);\n // Throttle sequential mouse events to 1 every 20ms.\n rubberband.mousemove('motion_notify', mouse_event_fn);\n\n rubberband.mouseenter('figure_enter', mouse_event_fn);\n rubberband.mouseleave('figure_leave', mouse_event_fn);\n\n canvas_div.on(\"wheel\", function (event) {\n event = event.originalEvent;\n event['data'] = 'scroll'\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n mouse_event_fn(event);\n });\n\n canvas_div.append(canvas);\n canvas_div.append(rubberband);\n\n this.rubberband = rubberband;\n this.rubberband_canvas = rubberband[0];\n this.rubberband_context = rubberband[0].getContext(\"2d\");\n this.rubberband_context.strokeStyle = \"#000000\";\n\n this._resize_canvas = function(width, height) {\n // Keep the size of the canvas, canvas container, and rubber band\n // canvas in synch.\n canvas_div.css('width', width)\n canvas_div.css('height', height)\n\n canvas.attr('width', width * mpl.ratio);\n canvas.attr('height', height * mpl.ratio);\n canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n\n rubberband.attr('width', width);\n rubberband.attr('height', height);\n }\n\n // Set the figure to an initial 600x600px, this will subsequently be updated\n // upon first draw.\n this._resize_canvas(600, 600);\n\n // Disable right mouse context menu.\n $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n return false;\n });\n\n function set_focus () {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n}\n\nmpl.figure.prototype._init_toolbar = function() {\n var fig = this;\n\n var nav_element = $('
')\n nav_element.attr('style', 'width: 100%');\n this.root.append(nav_element);\n\n // Define a callback function for later on.\n function toolbar_event(event) {\n return fig.toolbar_button_onclick(event['data']);\n }\n function toolbar_mouse_event(event) {\n return fig.toolbar_button_onmouseover(event['data']);\n }\n\n for(var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n // put a spacer in here.\n continue;\n }\n var button = $('