From 23a1ebca029a20c2024dd410b081068113636434 Mon Sep 17 00:00:00 2001 From: Bertil Chapuis Date: Sun, 1 Sep 2024 23:06:30 +0200 Subject: [PATCH 01/21] Add a wrapper for the gdal bindings - The idea is to access gdal in a more idiomatic way. - For instance AutoCloseable is used to release the underlying resources systematically. - Objects ease the creation of options. --- baremaps-gdal/README.md | 6 + baremaps-gdal/pom.xml | 19 + .../java/org/apache/baremaps/gdal/Band.java | 83 ++++ .../apache/baremaps/gdal/BuildVRTOptions.java | 183 +++++++++ .../baremaps/gdal/BuildVRTResource.java | 33 ++ .../org/apache/baremaps/gdal/Dataset.java | 55 +++ .../java/org/apache/baremaps/gdal/Driver.java | 47 +++ .../java/org/apache/baremaps/gdal/Gdal.java | 179 +++++++++ .../org/apache/baremaps/gdal/InfoOptions.java | 149 +++++++ .../apache/baremaps/gdal/InfoResource.java | 33 ++ .../java/org/apache/baremaps/gdal/Layer.java | 35 ++ .../org/apache/baremaps/gdal/Options.java | 59 +++ .../baremaps/gdal/ProgressCallback.java | 27 ++ .../baremaps/gdal/ProgressResource.java | 41 ++ .../baremaps/gdal/TranslateOptions.java | 326 +++++++++++++++ .../baremaps/gdal/TranslateResource.java | 34 ++ .../org/apache/baremaps/gdal/WarpOptions.java | 376 ++++++++++++++++++ .../apache/baremaps/gdal/WarpResource.java | 33 ++ 18 files changed, 1718 insertions(+) create mode 100644 baremaps-gdal/README.md create mode 100644 baremaps-gdal/pom.xml create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Band.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTOptions.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTResource.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Dataset.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Driver.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Gdal.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoOptions.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoResource.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Layer.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Options.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressCallback.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressResource.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateOptions.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateResource.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpOptions.java create mode 100644 baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpResource.java diff --git a/baremaps-gdal/README.md b/baremaps-gdal/README.md new file mode 100644 index 000000000..da2672c51 --- /dev/null +++ b/baremaps-gdal/README.md @@ -0,0 +1,6 @@ +# Baremaps GDAL + +This module provides a set of utilities to interact with GDAL in a Java-friendly and idiomatic way. +It uses the official Java bindings provided by GDAL and hides some of the complexity of low-level API. +For instance, it wraps the classes, such as `Dataset` in an `AutoCloseable` interface to ensure that resources allocated by GDAL are properly released. +In order to use this module, you need to install the GDAL native libraries for Java (`libgdalalljni.so` / `libgdalalljni.dylib` / `gdalalljni.dll`) on your system. \ No newline at end of file diff --git a/baremaps-gdal/pom.xml b/baremaps-gdal/pom.xml new file mode 100644 index 000000000..8bb5b69b1 --- /dev/null +++ b/baremaps-gdal/pom.xml @@ -0,0 +1,19 @@ + + + 4.0.0 + + org.apache.baremaps + baremaps + 0.7.4-SNAPSHOT + + + baremaps-gdal + + + + org.gdal + gdal + 3.9.0 + + + diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Band.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Band.java new file mode 100644 index 000000000..71d58f3b7 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Band.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +import java.awt.image.BufferedImage; +import java.awt.image.WritableRaster; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.Band} class. + */ +public class Band implements AutoCloseable { + + private final org.gdal.gdal.Band band; + + protected Band(org.gdal.gdal.Band band) { + this.band = band; + } + + public int getWidth() { + return band.getXSize(); + } + + public int getHeight() { + return band.getYSize(); + } + + public void read(int x, int y, int width, int height, byte[] buffer) { + band.ReadRaster(x, y, width, height, buffer); + } + + public void read(int x, int y, int width, int height, int[] buffer) { + band.ReadRaster(x, y, width, height, buffer); + } + + public void read(int x, int y, int width, int height, long[] buffer) { + band.ReadRaster(x, y, width, height, buffer); + } + + public void read(int x, int y, int width, int height, double[] buffer) { + band.ReadRaster(x, y, width, height, buffer); + } + + public BufferedImage asBufferedImage(int imageType) { + // Copy the data of the band into a byte array + int width = band.getXSize(); + int height = band.getYSize(); + double[] values = new double[height * width]; + band.ReadRaster(0, 0, 256, 256, values); + + // Create a BufferedImage from the byte array + BufferedImage image = new BufferedImage(width, height, imageType); + WritableRaster raster = image.getRaster(); + for (int x = 0; x < 256; x++) { + for (int y = 0; y < 256; y++) { + double value = values[y * 256 + x]; + raster.setDataElements(x, y, value); + } + } + + return image; + } + + @Override + public void close() throws Exception { + band.delete(); + } + +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTOptions.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTOptions.java new file mode 100644 index 000000000..380e0ff1e --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTOptions.java @@ -0,0 +1,183 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * Options for the build vrt method. + */ +public class BuildVRTOptions extends Options { + + public BuildVRTOptions() { + super(); + } + + // Basic Options + public BuildVRTOptions help() { + add("--help"); + return this; + } + + public BuildVRTOptions helpGeneral() { + add("--help-general"); + return this; + } + + public BuildVRTOptions tileIndex(String fieldName) { + add("-tileindex"); + add(fieldName); + return this; + } + + public BuildVRTOptions resolution(String resolution) { + add("-resolution"); + add(resolution); + return this; + } + + public BuildVRTOptions targetExtent(double xmin, double ymin, double xmax, double ymax) { + add("-te"); + add(xmin); + add(ymin); + add(xmax); + add(ymax); + return this; + } + + public BuildVRTOptions targetResolution(double xres, double yres) { + add("-tr"); + add(xres); + add(yres); + return this; + } + + public BuildVRTOptions targetAlignedPixels() { + add("-tap"); + return this; + } + + public BuildVRTOptions separate() { + add("-separate"); + return this; + } + + public BuildVRTOptions band(int band) { + add("-b"); + add(band); + return this; + } + + public BuildVRTOptions subdataset(int n) { + add("-sd"); + add(n); + return this; + } + + public BuildVRTOptions allowProjectionDifference() { + add("-allow_projection_difference"); + return this; + } + + public BuildVRTOptions quiet() { + add("-q"); + return this; + } + + public BuildVRTOptions addAlpha() { + add("-addalpha"); + return this; + } + + public BuildVRTOptions hideNodata() { + add("-hidenodata"); + return this; + } + + public BuildVRTOptions sourceNodata(String... values) { + add("-srcnodata"); + add(String.join(" ", values)); + return this; + } + + public BuildVRTOptions vrtNodata(String... values) { + add("-vrtnodata"); + add(String.join(" ", values)); + return this; + } + + public BuildVRTOptions ignoreSrcMaskBand() { + add("-ignore_srcmaskband"); + return this; + } + + public BuildVRTOptions nodataMaxMaskThreshold(double threshold) { + add("-nodata_max_mask_threshold"); + add(threshold); + return this; + } + + public BuildVRTOptions assignSRS(String srs) { + add("-a_srs"); + add(srs); + return this; + } + + public BuildVRTOptions resamplingMethod(String method) { + add("-r"); + add(method); + return this; + } + + public BuildVRTOptions openOption(String name, String value) { + add("-oo"); + add(name + "=" + value); + return this; + } + + public BuildVRTOptions inputFileList(String filename) { + add("-input_file_list"); + add(filename); + return this; + } + + public BuildVRTOptions overwrite() { + add("-overwrite"); + return this; + } + + public BuildVRTOptions strict() { + add("-strict"); + return this; + } + + public BuildVRTOptions nonStrict() { + add("-non_strict"); + return this; + } + + public BuildVRTOptions outputFilename(String filename) { + add(filename); + return this; + } + + public BuildVRTOptions inputRaster(String... rasters) { + for (String raster : rasters) { + add(raster); + } + return this; + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTResource.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTResource.java new file mode 100644 index 000000000..86c19b726 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/BuildVRTResource.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.BuildVRTOptions} class. + */ +class BuildVRTResource extends org.gdal.gdal.BuildVRTOptions implements AutoCloseable { + + protected BuildVRTResource(BuildVRTOptions options) { + super(options.asVector()); + } + + @Override + public void close() { + this.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Dataset.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Dataset.java new file mode 100644 index 000000000..7e754201a --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Dataset.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * A resource that wraps the {@link org.gdal.gdal.BuildVRTOptions} class. + */ +public class Dataset implements AutoCloseable { + + protected final org.gdal.gdal.Dataset dataset; + + protected Dataset(org.gdal.gdal.Dataset dataset) { + this.dataset = dataset; + } + + public Driver getDriver() { + return new Driver(dataset.GetDriver()); + } + + public int getRasterWidth() { + return dataset.getRasterXSize(); + } + + public int getRasterHeight() { + return dataset.getRasterYSize(); + } + + public int getRasterCount() { + return dataset.getRasterCount(); + } + + public Band getRasterBand(int index) { + return new Band(dataset.GetRasterBand(index)); + } + + @Override + public void close() throws Exception { + dataset.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Driver.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Driver.java new file mode 100644 index 000000000..a170eb6ed --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Driver.java @@ -0,0 +1,47 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.Driver} class. + */ +public class Driver implements AutoCloseable { + + private final org.gdal.gdal.Driver driver; + + protected Driver(org.gdal.gdal.Driver driver) { + this.driver = driver; + } + + public String getShortName() { + return driver.getShortName(); + } + + public String getLongName() { + return driver.getLongName(); + } + + public String getHelpTopic() { + return driver.getHelpTopic(); + } + + @Override + public void close() throws Exception { + driver.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Gdal.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Gdal.java new file mode 100644 index 000000000..610688d42 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Gdal.java @@ -0,0 +1,179 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.Vector; +import org.gdal.gdal.gdal; + +/** + * An utility class to interact with the GDAL library in a more Java-friendly and idiomatic way. + */ +public class Gdal { + + private Gdal() { + // Prevent instantiation + } + + public static void initialize() { + gdal.AllRegister(); + gdal.UseExceptions(); + } + + public static String versionInfo() { + return gdal.VersionInfo(); + } + + public static Dataset open(Path path) { + return open(path.normalize().toAbsolutePath().toString()); + } + + public static Dataset open(String path) { + if (Files.notExists(Path.of(path))) { + throw new IllegalArgumentException("File not found: " + path); + } + var dataset = gdal.OpenEx(path); + return new Dataset(dataset); + } + + public static Dataset copy(String path, Dataset source) { + var driver = gdal.IdentifyDriver(path); + return new Dataset(driver.CreateCopy(path, source.dataset)); + } + + public static String info(Dataset dataset) { + return org.gdal.gdal.gdal.GDALInfo(dataset.dataset, null); + } + + public static String info(Dataset dataset, InfoOptions options) { + try (var infoOptions = new InfoResource(options)) { + return org.gdal.gdal.gdal.GDALInfo(dataset.dataset, infoOptions); + } + } + + public static Dataset buildVRT(List files, BuildVRTOptions options) { + var buildVRTOptions = new org.gdal.gdal.BuildVRTOptions(options.asVector()); + try (var buildVRTResource = new BuildVRTResource(options)) { + var target = org.gdal.gdal.gdal.BuildVRT( + "", + new Vector<>(files), + buildVRTResource); + return new Dataset(target); + } finally { + buildVRTOptions.delete(); + } + } + + public static Dataset buildVRT(List files, BuildVRTOptions options, + ProgressCallback progressListener) { + try (var buildVRTResource = new BuildVRTResource(options); + var progressResource = new ProgressResource(progressListener)) { + org.gdal.gdal.Dataset target = org.gdal.gdal.gdal.BuildVRT( + "", + new Vector<>(files), + buildVRTResource, + progressResource); + return new Dataset(target); + } + } + + public static Dataset translate(Dataset source, TranslateOptions options) { + try (var translateResource = new TranslateResource(options)) { + var dataset = org.gdal.gdal.gdal.Translate( + "", + source.dataset, + translateResource); + return new Dataset(dataset); + } + } + + public static Dataset translate(Dataset source, TranslateOptions options, + ProgressCallback progressListener) { + try (var translateResource = new TranslateResource(options); + var progressResource = new ProgressResource(progressListener)) { + var dataset = org.gdal.gdal.gdal.Translate( + "", + source.dataset, + translateResource, + progressResource); + return new Dataset(dataset); + } + } + + public static Dataset warp(Dataset source, WarpOptions options) { + return warp(List.of(source), options); + } + + public static void warp(Dataset target, Dataset source, WarpOptions options) { + warp(target, List.of(source), options); + } + + public static Dataset warp(Dataset source, WarpOptions options, + ProgressCallback progressCallback) { + return warp(List.of(source), options, progressCallback); + } + + public static void warp(Dataset target, Dataset source, WarpOptions options, + ProgressCallback progressCallback) { + warp(target, List.of(source), options, progressCallback); + } + + public static Dataset warp(List sources, WarpOptions options) { + try (var warpResource = new WarpResource(options)) { + return new Dataset(gdal.Warp( + "", + sources.stream().map(d -> d.dataset).toArray(org.gdal.gdal.Dataset[]::new), + warpResource)); + } + } + + public static Dataset warp(List sources, WarpOptions options, + ProgressCallback progressCallback) { + try (var warpResource = new WarpResource(options); + var progressResource = new ProgressResource(progressCallback)) { + return new Dataset(gdal.Warp( + "", + sources.stream().map(d -> d.dataset).toArray(org.gdal.gdal.Dataset[]::new), + warpResource, + progressResource)); + } + } + + public static void warp(Dataset target, List sources, WarpOptions options) { + try (var warpResource = new WarpResource(options)) { + gdal.Warp( + target.dataset, + sources.stream().map(d -> d.dataset).toArray(org.gdal.gdal.Dataset[]::new), + warpResource); + } + } + + public static void warp(Dataset target, List sources, WarpOptions options, + ProgressCallback progressCallback) { + try (var warpResource = new WarpResource(options); + var progressResource = new ProgressResource(progressCallback)) { + gdal.Warp( + target.dataset, + sources.stream().map(d -> d.dataset).toArray(org.gdal.gdal.Dataset[]::new), + warpResource, + progressResource); + } + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoOptions.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoOptions.java new file mode 100644 index 000000000..60e00ab4f --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoOptions.java @@ -0,0 +1,149 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * Options for the info method. + */ +public class InfoOptions extends Options { + + public InfoOptions() { + super(); + } + + // Basic Options + public InfoOptions help() { + add("--help"); + return this; + } + + public InfoOptions helpGeneral() { + add("--help-general"); + return this; + } + + public InfoOptions json() { + add("-json"); + return this; + } + + public InfoOptions minMax() { + add("-mm"); + return this; + } + + public InfoOptions stats() { + add("-stats"); + return this; + } + + public InfoOptions approxStats() { + add("-approx_stats"); + return this; + } + + public InfoOptions histogram() { + add("-hist"); + return this; + } + + public InfoOptions noGCP() { + add("-nogcp"); + return this; + } + + public InfoOptions noMetadata() { + add("-nomd"); + return this; + } + + public InfoOptions noRAT() { + add("-norat"); + return this; + } + + public InfoOptions noColorTable() { + add("-noct"); + return this; + } + + public InfoOptions noFileList() { + add("-nofl"); + return this; + } + + public InfoOptions noNodata() { + add("-nonodata"); + return this; + } + + public InfoOptions noMask() { + add("-nomask"); + return this; + } + + public InfoOptions checksum() { + add("-checksum"); + return this; + } + + public InfoOptions listMDD() { + add("-listmdd"); + return this; + } + + public InfoOptions metadataDomain(String domain) { + add("-mdd"); + add(domain); + return this; + } + + public InfoOptions proj4() { + add("-proj4"); + return this; + } + + public InfoOptions wktFormat(String format) { + add("-wkt_format"); + add(format); + return this; + } + + public InfoOptions subdataset(int sdIndex) { + add("-sd"); + add(sdIndex); + return this; + } + + public InfoOptions openOption(String name, String value) { + add("-oo"); + add(name + "=" + value); + return this; + } + + public InfoOptions inputFormat(String format) { + add("-if"); + add(format); + return this; + } + + public InfoOptions datasetName(String dataset) { + add(dataset); + return this; + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoResource.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoResource.java new file mode 100644 index 000000000..1e48b2a22 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/InfoResource.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.InfoOptions} class. + */ +class InfoResource extends org.gdal.gdal.InfoOptions implements AutoCloseable { + + public InfoResource(InfoOptions options) { + super(options.asVector()); + } + + @Override + public void close() { + this.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Layer.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Layer.java new file mode 100644 index 000000000..cbac48881 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Layer.java @@ -0,0 +1,35 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.ogr.Layer} class. + */ +public class Layer implements AutoCloseable { + + private final org.gdal.ogr.Layer layer; + + protected Layer(org.gdal.ogr.Layer layer) { + this.layer = layer; + } + + @Override + public void close() throws Exception { + layer.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Options.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Options.java new file mode 100644 index 000000000..188d47fa7 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/Options.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +import java.util.ArrayList; +import java.util.List; +import java.util.Vector; + +/** + * A simple wrapper around the {@link java.util.List} class. + */ +public class Options { + + private final List options; + + public Options() { + this.options = new ArrayList<>(); + } + + public Options add(String value) { + options.add(value); + return this; + } + + public Options add(int value) { + options.add(String.valueOf(value)); + return this; + } + + public Options add(double value) { + options.add(String.valueOf(value)); + return this; + } + + public Options add(boolean value) { + options.add(String.valueOf(value)); + return this; + } + + public Vector asVector() { + return new Vector<>(options); + } + +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressCallback.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressCallback.java new file mode 100644 index 000000000..36059630a --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressCallback.java @@ -0,0 +1,27 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * A callback interface for reporting progress. + */ +public interface ProgressCallback { + + void progress(double progress, String message); + +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressResource.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressResource.java new file mode 100644 index 000000000..4505f7943 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/ProgressResource.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.ProgressCallback} class. + */ +class ProgressResource extends org.gdal.gdal.ProgressCallback implements AutoCloseable { + + private final ProgressCallback callback; + + public ProgressResource(ProgressCallback callback) { + this.callback = callback; + } + + @Override + public int run(double progress, String message) { + callback.progress(progress, message); + return 1; + } + + @Override + public void close() { + this.delete(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateOptions.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateOptions.java new file mode 100644 index 000000000..12197094e --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateOptions.java @@ -0,0 +1,326 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * Options for the translate method. + */ +public class TranslateOptions extends Options { + + public TranslateOptions() { + super(); + } + + // Basic Options + public TranslateOptions help() { + add("--help"); + return this; + } + + public TranslateOptions helpGeneral() { + add("--help-general"); + return this; + } + + public TranslateOptions longUsage() { + add("--long-usage"); + return this; + } + + public TranslateOptions outputType(String type) { + add("-ot"); + add(type); + return this; + } + + public TranslateOptions strict() { + add("-strict"); + return this; + } + + public TranslateOptions inputFormat(String format) { + add("-if"); + add(format); + return this; + } + + public TranslateOptions outputFormat(String format) { + add("-of"); + add(format); + return this; + } + + public TranslateOptions band(int band) { + add("-b"); + add(band); + return this; + } + + public TranslateOptions maskBand(int band) { + add("-mask"); + add(band); + return this; + } + + public TranslateOptions expand(String option) { + add("-expand"); + add(option); + return this; + } + + public TranslateOptions outsize(int xsize, int ysize) { + add("-outsize"); + add(xsize); + add(ysize); + return this; + } + + public TranslateOptions outsizePercent(int xpercent, int ypercent) { + add("-outsize"); + add(xpercent + "%"); + add(ypercent + "%"); + return this; + } + + public TranslateOptions targetResolution(double xres, double yres) { + add("-tr"); + add(xres); + add(yres); + return this; + } + + public TranslateOptions overview(int level) { + add("-ovr"); + add(level); + return this; + } + + public TranslateOptions overviewAuto() { + add("-ovr"); + add("AUTO"); + return this; + } + + public TranslateOptions overviewNone() { + add("-ovr"); + add("NONE"); + return this; + } + + public TranslateOptions resamplingMethod(String method) { + add("-r"); + add(method); + return this; + } + + public TranslateOptions unscale() { + add("-unscale"); + return this; + } + + public TranslateOptions scale(int band, double srcMin, double srcMax, double dstMin, + double dstMax) { + add("-scale_" + band); + add(srcMin); + add(srcMax); + add(dstMin); + add(dstMax); + return this; + } + + public TranslateOptions scale(double srcMin, double srcMax, double dstMin, double dstMax) { + add("-scale"); + add(srcMin); + add(srcMax); + add(dstMin); + add(dstMax); + return this; + } + + public TranslateOptions exponent(int band, double expVal) { + add("-exponent_" + band); + add(expVal); + return this; + } + + public TranslateOptions exponent(double expVal) { + add("-exponent"); + add(expVal); + return this; + } + + public TranslateOptions srcWindow(int xoff, int yoff, int xsize, int ysize) { + add("-srcwin"); + add(xoff); + add(yoff); + add(xsize); + return this; + } + + public TranslateOptions errorOnPartiallyOutside() { + add("-epo"); + return this; + } + + public TranslateOptions errorOnCompletelyOutside() { + add("-eco"); + return this; + } + + public TranslateOptions projectionWindow(double ulx, double uly, double lrx, double lry) { + add("-projwin"); + add(ulx); + add(uly); + add(lrx); + add(lry); + return this; + } + + public TranslateOptions projectionWindowSRS(String srs) { + add("-projwin_srs"); + add(srs); + return this; + } + + public TranslateOptions assignSRS(String srs) { + add("-a_srs"); + add(srs); + return this; + } + + public TranslateOptions assignCoordEpoch(String epoch) { + add("-a_coord_epoch"); + add(epoch); + return this; + } + + public TranslateOptions assignGeoTransform(double gt0, double gt1, double gt2, double gt3, + double gt4, double gt5) { + add("-a_gt"); + add(gt0); + add(gt1); + add(gt2); + add(gt3); + add(gt4); + add(gt5); + return this; + } + + public TranslateOptions assignNodataValue(double value) { + add("-a_nodata"); + add(value); + return this; + } + + public TranslateOptions assignScale(double value) { + add("-a_scale"); + add(value); + return this; + } + + public TranslateOptions assignOffset(double value) { + add("-a_offset"); + add(value); + return this; + } + + public TranslateOptions noGCPs() { + add("-nogcp"); + return this; + } + + public TranslateOptions gcp(double pixel, double line, double easting, double northing, + Double elevation) { + add("-gcp"); + add(pixel); + add(line); + add(easting); + add(northing); + if (elevation != null) { + add(elevation); + } + return this; + } + + public TranslateOptions colorInterpretation(String... interpretations) { + add("-colorinterp"); + for (String interp : interpretations) { + add(interp); + } + return this; + } + + public TranslateOptions metadataOption(String name, String value) { + add("-mo"); + add(name + "=" + value); + return this; + } + + public TranslateOptions domainMetadataOption(String domain, String name, String value) { + add("-dmo"); + add(domain + ":" + name + "=" + value); + return this; + } + + public TranslateOptions quiet() { + add("-q"); + return this; + } + + public TranslateOptions subdatasets() { + add("-sds"); + return this; + } + + public TranslateOptions creationOption(String name, String value) { + add("-co"); + add(name + "=" + value); + return this; + } + + public TranslateOptions statistics() { + add("-stats"); + return this; + } + + public TranslateOptions noRAT() { + add("-norat"); + return this; + } + + public TranslateOptions noXMP() { + add("-noxmp"); + return this; + } + + public TranslateOptions openOption(String name, String value) { + add("-oo"); + add(name + "=" + value); + return this; + } + + public TranslateOptions srcDataset(String dataset) { + add(dataset); + return this; + } + + public TranslateOptions dstDataset(String dataset) { + add(dataset); + return this; + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateResource.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateResource.java new file mode 100644 index 000000000..99e8fb4a8 --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/TranslateResource.java @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.TranslateOptions} class. + */ +class TranslateResource extends org.gdal.gdal.TranslateOptions implements AutoCloseable { + + public TranslateResource(TranslateOptions options) { + super(options.asVector()); + } + + @Override + public void close() { + this.delete(); + } + +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpOptions.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpOptions.java new file mode 100644 index 000000000..f220cf65f --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpOptions.java @@ -0,0 +1,376 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * Options for the warp method. + */ +public class WarpOptions extends Options { + + public WarpOptions() { + super(); + } + + // Basic Options + public WarpOptions help() { + add("--help"); + return this; + } + + public WarpOptions longUsage() { + add("--long-usage"); + return this; + } + + public WarpOptions helpGeneral() { + add("--help-general"); + return this; + } + + public WarpOptions quiet() { + add("--quiet"); + return this; + } + + public WarpOptions overwrite() { + add("-overwrite"); + return this; + } + + public WarpOptions format(String format) { + add("-of"); + add(format); + return this; + } + + public WarpOptions creationOption(String name, String value) { + add("-co"); + add(name + "=" + value); + return this; + } + + public WarpOptions sourceSRS(String srs) { + add("-s_srs"); + add(srs); + return this; + } + + public WarpOptions targetSRS(String srs) { + add("-t_srs"); + add(srs); + return this; + } + + public WarpOptions srcAlpha() { + add("-srcalpha"); + return this; + } + + public WarpOptions noSrcAlpha() { + add("-nosrcalpha"); + return this; + } + + public WarpOptions dstAlpha() { + add("-dstalpha"); + return this; + } + + public WarpOptions targetResolution(double xRes, double yRes) { + add("-tr"); + add(xRes); + add(yRes); + return this; + } + + public WarpOptions targetResolutionSquare(double res) { + add("-tr"); + add(res); + add(res); + return this; + } + + public WarpOptions targetSize(int width, int height) { + add("-ts"); + add(width); + add(height); + return this; + } + + public WarpOptions targetExtent(double xmin, double ymin, double xmax, double ymax) { + add("-te"); + add(xmin); + add(ymin); + add(xmax); + add(ymax); + return this; + } + + public WarpOptions targetExtentSRS(String srs) { + add("-te_srs"); + add(srs); + return this; + } + + public WarpOptions resampling(String resampling) { + add("-r"); + add(resampling); + return this; + } + + public WarpOptions outputFormat(String format) { + add("-of"); + add(format); + return this; + } + + public WarpOptions srcDataset(String datasetName) { + add(datasetName); + return this; + } + + public WarpOptions dstDataset(String datasetName) { + add(datasetName); + return this; + } + + // Advanced Options + public WarpOptions warpOption(String name, String value) { + add("-wo"); + add(name + "=" + value); + return this; + } + + public WarpOptions multi() { + add("-multi"); + return this; + } + + public WarpOptions srcCoordEpoch(String epoch) { + add("-s_coord_epoch"); + add(epoch); + return this; + } + + public WarpOptions tgtCoordEpoch(String epoch) { + add("-t_coord_epoch"); + return this; + } + + public WarpOptions coordinateTransformation(String ct) { + add("-ct"); + add(ct); + return this; + } + + public WarpOptions useTPS() { + add("-tps"); + return this; + } + + public WarpOptions useRPC() { + add("-rpc"); + return this; + } + + public WarpOptions useGeolocation() { + add("-geoloc"); + return this; + } + + public WarpOptions order(int order) { + add("-order"); + add(order); + return this; + } + + public WarpOptions refineGCPs(double tolerance, int minimumGCPs) { + add("-refine_gcps"); + add(tolerance); + add(minimumGCPs); + return this; + } + + public WarpOptions transformationOption(String name, String value) { + add("-to"); + add(name + "=" + value); + return this; + } + + public WarpOptions errorThreshold(double threshold) { + add("-et"); + add(threshold); + return this; + } + + public WarpOptions workingMemory(int memoryInMb) { + add("-wm"); + add(memoryInMb); + return this; + } + + public WarpOptions srcNodata(double... values) { + add("-srcnodata"); + add(join(values, " ")); + return this; + } + + public WarpOptions dstNodata(double... values) { + add("-dstnodata"); + add(join(values, " ")); + return this; + } + + public WarpOptions targetAlignedPixels() { + add("-tap"); + return this; + } + + public WarpOptions warpType(String type) { + add("-wt"); + add(type); + return this; + } + + public WarpOptions cutline(String cutline) { + add("-cutline"); + add(cutline); + return this; + } + + public WarpOptions cutlineSRS(String srs) { + add("-cutline_srs"); + add(srs); + return this; + } + + public WarpOptions cutlineWhere(String expression) { + add("-cwhere"); + add(expression); + return this; + } + + public WarpOptions cutlineLayer(String layerName) { + add("-cl"); + add(layerName); + return this; + } + + public WarpOptions cutlineSQL(String query) { + add("-csql"); + add(query); + return this; + } + + public WarpOptions cutlineBlend(double distance) { + add("-cblend"); + add(distance); + return this; + } + + public WarpOptions cropToCutline() { + add("-crop_to_cutline"); + return this; + } + + public WarpOptions noMetadata() { + add("-nomd"); + return this; + } + + public WarpOptions conflictValue(String value) { + add("-cvmd"); + add(value); + return this; + } + + public WarpOptions setColorInterpretation() { + add("-setci"); + return this; + } + + public WarpOptions openOption(String name, String value) { + add("-oo"); + add(name + "=" + value); + return this; + } + + public WarpOptions datasetOpenOption(String name, String value) { + add("-doo"); + add(name + "=" + value); + return this; + } + + public WarpOptions overview(int level) { + add("-ovr"); + add(level); + return this; + } + + public WarpOptions overviewAuto() { + add("-ovr"); + add("AUTO"); + return this; + } + + public WarpOptions overviewNone() { + add("-ovr"); + add("NONE"); + return this; + } + + public WarpOptions verticalShift() { + add("-vshift"); + return this; + } + + public WarpOptions noVerticalShiftGrid() { + add("-novshiftgrid"); + return this; + } + + public WarpOptions inputFormat(String format) { + add("-if"); + add(format); + return this; + } + + public WarpOptions srcBand(int n) { + add("-srcband"); + add(n); + return this; + } + + public WarpOptions dstBand(int n) { + add("-dstband"); + add(n); + return this; + } + + // Helper method to join array elements + private String join(double[] array, String delimiter) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < array.length; i++) { + sb.append(array[i]); + if (i < array.length - 1) { + sb.append(delimiter); + } + } + return sb.toString(); + } +} diff --git a/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpResource.java b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpResource.java new file mode 100644 index 000000000..09ff9088a --- /dev/null +++ b/baremaps-gdal/src/main/java/org/apache/baremaps/gdal/WarpResource.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.gdal; + +/** + * An auto closable wrapper around the {@link org.gdal.gdal.WarpOptions} class. + */ +class WarpResource extends org.gdal.gdal.WarpOptions implements AutoCloseable { + + public WarpResource(WarpOptions options) { + super(options.asVector()); + } + + @Override + public void close() { + this.delete(); + } +} From 0e26b33954798118fa332e35949f9a01c3c1f9f4 Mon Sep 17 00:00:00 2001 From: Bertil Chapuis Date: Sun, 1 Sep 2024 23:09:35 +0200 Subject: [PATCH 02/21] Implement algorithms for digital elevation models - The ContourTracer implements marching squares to trace or polygonize contours. - The HillshadeCalculator computes raster hillshades. - Martini is a port of mapbox's martini algorithm to java. - The ChaikinSmoother enable the smoothing of linestring and polygons. - Some tests and utilities enable the verification of the results. --- baremaps-dem/Dockerfile | 12 + baremaps-dem/pom.xml | 20 + .../apache/baremaps/dem/ChaikinSmoother.java | 126 +++++ .../apache/baremaps/dem/ContourTracer.java | 509 ++++++++++++++++++ .../apache/baremaps/dem/ElevationUtils.java | 214 ++++++++ .../baremaps/dem/HillshadeCalculator.java | 150 ++++++ .../java/org/apache/baremaps/dem/Martini.java | 294 ++++++++++ .../org/apache/baremaps/dem/RasterUtils.java | 49 ++ .../baremaps/dem/ChaikinSmootherTest.java | 40 ++ .../apache/baremaps/dem/ContourRenderer.java | 89 +++ .../dem/ContourTracerLineStringTest.java | 161 ++++++ .../dem/ContourTracerPolygonTest.java | 191 +++++++ .../baremaps/dem/ContourTracerTest.java | 90 ++++ .../baremaps/dem/HillShadeRenderer.java | 158 ++++++ .../baremaps/dem/HillshadeCalculatorTest.java | 103 ++++ .../baremaps/dem/MarchingSquareRenderer.java | 110 ++++ .../baremaps/dem/MarchingSquareUtils.java | 127 +++++ .../org/apache/baremaps/dem/MartiniTest.java | 62 +++ baremaps-dem/src/test/resources/fuji.png | Bin 0 -> 578765 bytes 19 files changed, 2505 insertions(+) create mode 100644 baremaps-dem/Dockerfile create mode 100644 baremaps-dem/pom.xml create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java create mode 100644 baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java create mode 100644 baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java create mode 100644 baremaps-dem/src/test/resources/fuji.png diff --git a/baremaps-dem/Dockerfile b/baremaps-dem/Dockerfile new file mode 100644 index 000000000..03f696a34 --- /dev/null +++ b/baremaps-dem/Dockerfile @@ -0,0 +1,12 @@ +FROM eclipse-temurin:21-alpine + +# Install gdal-tools using apk +RUN apk add --no-cache gdal-tools java-gdal + +# Set the working directory +WORKDIR /app + +ENTRYPOINT ["/__cacert_entrypoint.sh"] + +CMD ["jshell"] + diff --git a/baremaps-dem/pom.xml b/baremaps-dem/pom.xml new file mode 100644 index 000000000..bd03f8740 --- /dev/null +++ b/baremaps-dem/pom.xml @@ -0,0 +1,20 @@ + + + 4.0.0 + + org.apache.baremaps + baremaps + 0.7.4-SNAPSHOT + + baremaps-dem + + + org.apache.baremaps + baremaps-testing + + + org.locationtech.jts + jts-core + + + diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java new file mode 100644 index 000000000..18ca804b2 --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ChaikinSmoother.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import org.locationtech.jts.geom.*; +import org.locationtech.jts.geom.impl.CoordinateArraySequence; +import org.locationtech.jts.geom.util.GeometryTransformer; + +/** + * A geometry transformer that applies the Chaikin smoothing algorithm to the coordinates of a + * geometry. + */ +public class ChaikinSmoother extends GeometryTransformer { + + private final int iterations; + + private final double factor; + + /** + * Constructs a ChaikinSmoother with the specified number of iterations and factor. + * + * @param iterations the number of iterations + * @param factor the smoothing factor + */ + public ChaikinSmoother(int iterations, double factor) { + this.iterations = iterations; + this.factor = factor; + } + + /** + * Transforms the coordinates of a geometry using the Chaikin smoothing algorithm. + * + * @param coordinateSequence the coordinates to transform + * @param parent the parent geometry + * @return the transformed coordinates + */ + @Override + protected CoordinateSequence transformCoordinates( + CoordinateSequence coordinateSequence, + Geometry parent) { + return smooth(coordinateSequence, iterations, factor); + } + + /** + * Smooths the coordinates of a coordinate sequence using the Chaikin algorithm. This method + * distinguishes between rings and lines and applies the algorithm accordingly. + * + * @param coordinateSequence the coordinates to smooth + * @param iterations the number of iterations + * @param factor the smoothing factor + * @return the smoothed coordinates + */ + public static CoordinateSequence smooth( + CoordinateSequence coordinateSequence, + int iterations, + double factor) { + if (CoordinateSequences.isRing(coordinateSequence)) { + return new CoordinateArraySequence(chaikin(coordinateSequence.toCoordinateArray(), 2, 0.25)); + } else { + Coordinate[] original = coordinateSequence.toCoordinateArray(); + Coordinate[] smoothed = chaikin(original, iterations, factor); + int sumOfSquares = (iterations * (iterations + 1) * (2 * iterations + 1)) / 6; + int trimmedLength = smoothed.length - sumOfSquares; + Coordinate[] result = new Coordinate[trimmedLength + 2]; + result[0] = original[0]; + System.arraycopy(smoothed, 0, result, 1, trimmedLength); + result[trimmedLength + 1] = original[original.length - 1]; + return new CoordinateArraySequence(result); + } + } + + /** + * Applies the Chaikin smoothing algorithm to the specified coordinates. + * + * @param coordinates the coordinates to smooth + * @param iterations the number of iterations + * @param factor the smoothing factor + * @return the smoothed coordinates + */ + private static Coordinate[] chaikin( + Coordinate[] coordinates, + int iterations, + double factor) { + if (iterations <= 0) { + return coordinates; + } + + for (int i = 0; i < iterations; i++) { + int l = coordinates.length; + double f1 = 1 - factor; + double f2 = factor; + + Coordinate[] smoothed = new Coordinate[l * 2]; + for (int j = 0; j < l; j++) { + Coordinate c1 = coordinates[j]; + Coordinate c2 = coordinates[(j + 1) % l]; + smoothed[j * 2] = new Coordinate( + f1 * c1.getX() + f2 * c2.getX(), + f1 * c1.getY() + f2 * c2.getY()); + smoothed[j * 2 + 1] = new Coordinate( + f2 * c1.getX() + f1 * c2.getX(), + f2 * c1.getY() + f1 * c2.getY()); + } + + coordinates = smoothed; + } + + return coordinates; + } + +} diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java new file mode 100644 index 000000000..6773cc127 --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ContourTracer.java @@ -0,0 +1,509 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.util.*; +import org.locationtech.jts.geom.*; +import org.locationtech.jts.geom.util.GeometryFixer; +import org.locationtech.jts.geom.util.GeometryTransformer; +import org.locationtech.jts.operation.linemerge.LineMerger; + +/** + * Provides methods for generating contour lines and contour polygons from digital elevation models + * (DEMs). + */ +public class ContourTracer { + + private static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory(); + + private static final double EPSILON = 1e-10; + + private final double[] grid; + + private final int width; + + private final int height; + + private final boolean normalize; + + private final boolean polygonize; + + /** + * Constructs a new ContourTracer with the specified grid, width, height, normalization, and + * polygonization options. + * + * @param grid The grid of elevation values + * @param width The width of the grid + * @param height The height of the grid + * @param normalize Whether to normalize the coordinates + * @param polygonize Whether to polygonize the contours + */ + public ContourTracer(double[] grid, int width, int height, boolean normalize, + boolean polygonize) { + this.grid = Arrays.copyOf(grid, grid.length); + this.width = width; + this.height = height; + this.normalize = normalize; + this.polygonize = polygonize; + } + + /** + * Generates isolines for a given grid at a specific level. + * + * @param level The elevation level for which to generate isolines + * @return A list of LineString objects representing the isolines + */ + public List traceContours(double level) { + validateInput(grid, width, height); + + // Process each cell in the grid to generate segments + List cells = new ArrayList<>(); + for (int y = 0; y < height - 1; y++) { + for (int x = 0; x < width - 1; x++) { + cells.addAll(processCell(level, x, y)); + } + } + + // Merge the cells + List contours = merge(cells); + + // Polygonize the lines + if (polygonize) { + contours = polygonize(contours); + } + + // Normalize the coordinates + if (normalize) { + contours = normalize(contours); + } + + return contours; + } + + public List merge(List lineStrings) { + LineMerger cellMerger = new LineMerger(); + cellMerger.add(lineStrings); + List mergedLineStrings = new ArrayList<>(); + for (Object geometry : cellMerger.getMergedLineStrings()) { + if (geometry instanceof LineString lineString) { + mergedLineStrings.add(new GeometryFixer(lineString).getResult()); + } + } + return mergedLineStrings; + } + + private List polygonize(List geometries) { + var polygons = new ArrayList<>(geometries.stream() + .map(Geometry::getCoordinates) + .map(GEOMETRY_FACTORY::createPolygon) + .map(polygon -> new GeometryFixer(polygon).getResult()) + .map(Polygon.class::cast) + .sorted((a, b) -> Double.compare(b.getArea(), a.getArea())) + .toList()); + + List polygonized = new ArrayList<>(); + for (int i = 0; i < polygons.size(); i++) { + // Skip null polygons + if (polygons.get(i) == null) { + continue; + } + + // Extract the shell and holes + Polygon shell = polygons.get(i); + List holes = new ArrayList<>(); + for (int j = i + 1; j < polygons.size(); j++) { + // Skip null polygons + if (polygons.get(j) == null) { + continue; + } + + Polygon polygon = polygons.get(j); + if (shell.contains(polygon)) { + + // Check if the hole is within a previously found hole + boolean within = false; + for (Polygon hole : holes) { + if (hole.contains(polygon)) { + within = true; + break; + } + } + if (within) { + continue; + } + + // Add the hole to the list + holes.add(polygon); + + // Set the used polygon to null + polygons.set(j, null); + } + } + + // Combine the shell and holes + Polygon combinedPolygon = GEOMETRY_FACTORY.createPolygon( + shell.getExteriorRing(), + holes.stream() + .map(Polygon::getExteriorRing) + .toArray(LinearRing[]::new)); + polygonized.add(combinedPolygon); + + // Set the used polygon to null + polygons.set(i, null); + } + + return polygonized; + } + + private List normalize(List contours) { + NormalizationTransformer transformer = new NormalizationTransformer(); + List normalized = contours.stream() + .map(geometry -> transformer.transform(geometry.copy())) + .toList(); + return normalized; + } + + /** + * Generates contour for a given range of elevation levels. + * + * @param start The starting elevation level (inclusive) + * @param end The ending elevation level (exclusive) + * @param interval The interval between elevation levels + * @return A list of contour geometries + */ + public List traceContours(int start, int end, int interval) { + validateInput(grid, width, height); + List contours = new ArrayList<>(); + for (int level = start; level < end; level += interval) { + contours.addAll(traceContours(level)); + } + return contours; + } + + /** + * Validates the input grid, width, and height. + * + * @param grid The grid of elevation values + * @param width The width of the grid + * @param height The height of the grid + */ + private static void validateInput(double[] grid, int width, int height) { + if (grid == null || grid.length == 0) { + throw new IllegalArgumentException("Grid array cannot be null or empty"); + } + if (width <= 0 || height <= 0) { + throw new IllegalArgumentException("Width and height must be positive"); + } + if (grid.length != width * height) { + throw new IllegalArgumentException("Grid array length does not match width * height"); + } + } + + /** + * Processes a cell in the grid to generate line segments for a given elevation level. + * + * @param level The elevation level + * @param x The x-coordinate of the cell + * @param y The y-coordinate of the cell + * @return A list of line segments + */ + @SuppressWarnings("squid:S3776") + private List processCell(double level, int x, int y) { + List segments = new ArrayList<>(); + + boolean htb = polygonize && y == height - 2; + boolean hrb = polygonize && x == width - 2; + boolean hbb = polygonize && y == 0; + boolean hlb = polygonize && x == 0; + + Coordinate tlc = new Coordinate(x, y + 1.0); + Coordinate tmc = interpolateCoordinate(level, x, y + 1, x + 1, y + 1); + Coordinate trc = new Coordinate(x + 1.0, y + 1.0); + Coordinate mrc = interpolateCoordinate(level, x + 1, y, x + 1, y + 1); + Coordinate brc = new Coordinate(x + 1.0, y); + Coordinate bmc = interpolateCoordinate(level, x, y, x + 1, y); + Coordinate blc = new Coordinate(x, y); + Coordinate mlc = interpolateCoordinate(level, x, y, x, y + 1); + + double tlv = grid[y * width + x]; + double trv = grid[y * width + (x + 1)]; + double brv = grid[(y + 1) * width + (x + 1)]; + double blv = grid[(y + 1) * width + x]; + double avg = (tlv + trv + brv + blv) / 4.0; + + int index = + (tlv >= level ? 1 : 0) | + (trv >= level ? 2 : 0) | + (brv >= level ? 4 : 0) | + (blv >= level ? 8 : 0); + + switch (index) { + case 1 -> { + segments.add(createSegment(mlc, bmc)); + if (hbb) { + segments.add(createSegment(bmc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, mlc)); + } + } + case 2 -> { + segments.add(createSegment(bmc, mrc)); + if (hrb) { + segments.add(createSegment(mrc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, bmc)); + } + } + case 3 -> { + segments.add(createSegment(mlc, mrc)); + if (hrb) { + segments.add(createSegment(mrc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, mlc)); + } + } + case 4 -> { + segments.add(createSegment(mrc, tmc)); + if (htb) { + segments.add(createSegment(tmc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, mrc)); + } + } + case 5 -> { + segments.add(createSegment(mlc, tmc)); + if (htb) { + segments.add(createSegment(tmc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, mrc)); + } + segments.add(createSegment(mrc, bmc)); + if (hbb) { + segments.add(createSegment(bmc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, mlc)); + } + } + case 6 -> { + segments.add(createSegment(bmc, tmc)); + if (htb) { + segments.add(createSegment(tmc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, bmc)); + } + } + case 7 -> { + segments.add(createSegment(mlc, tmc)); + if (htb) { + segments.add(createSegment(tmc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, mlc)); + } + } + case 8 -> { + segments.add(createSegment(tmc, mlc)); + if (hlb) { + segments.add(createSegment(mlc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, tmc)); + } + } + case 9 -> { + segments.add(createSegment(tmc, bmc)); + if (hbb) { + segments.add(createSegment(bmc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, tmc)); + } + } + case 10 -> { + // Detect saddle points ambiguity + segments.add(createSegment(bmc, mlc)); + if (hlb) { + segments.add(createSegment(mlc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, tmc)); + } + segments.add(createSegment(tmc, mrc)); + if (hrb) { + segments.add(createSegment(mrc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, bmc)); + } + } + case 11 -> { + segments.add(createSegment(tmc, mrc)); + if (hrb) { + segments.add(createSegment(mrc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, tmc)); + } + } + case 12 -> { + segments.add(createSegment(mrc, mlc)); + if (hlb) { + segments.add(createSegment(mlc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, mrc)); + } + } + case 13 -> { + segments.add(createSegment(mrc, bmc)); + if (hbb) { + segments.add(createSegment(bmc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, mrc)); + } + } + case 14 -> { + segments.add(createSegment(bmc, mlc)); + if (hlb) { + segments.add(createSegment(mlc, tlc)); + } + if (htb) { + segments.add(createSegment(tlc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, bmc)); + } + } + case 15 -> { + if (htb) { + segments.add(createSegment(tlc, trc)); + } + if (hrb) { + segments.add(createSegment(trc, brc)); + } + if (hbb) { + segments.add(createSegment(brc, blc)); + } + if (hlb) { + segments.add(createSegment(blc, tlc)); + } + } + default -> { + // No segments + } + } + + return segments; + } + + /** + * Creates a line segment between two coordinates. + * + * @param c1 the first coordinate + * @param c2 the second coordinate + * @return the line segment + */ + private LineString createSegment(Coordinate c1, Coordinate c2) { + return GEOMETRY_FACTORY.createLineString(new Coordinate[] {c1, c2}); + } + + /** + * Interpolates a coordinate between two grid points. This method avoid division by zero by using + * a small epsilon value. It also ensures that the extreme values are not reached using the same + * epsilon value. + * + * @param level the elevation level + * @param x1 the x-coordinate of the first grid point + * @param y1 the y-coordinate of the first grid point + * @param x2 the x-coordinate of the second grid point + * @param y2 the y-coordinate of the second grid point + * @return the interpolated coordinate + */ + private Coordinate interpolateCoordinate(double level, int x1, int y1, int x2, int y2) { + double v1 = grid[y1 * width + x1]; + double v2 = grid[y2 * width + x2]; + double t = (Math.abs(v2 - v1) < EPSILON) ? 0.5 : (level - v1) / (v2 - v1); + if (t < EPSILON) { + t = EPSILON; + } else if (t > 1 - EPSILON) { + t = 1 - EPSILON; + } + double x = x1 + t * (x2 - x1); + double y = y1 + t * (y2 - y1); + return new Coordinate(x, y); + } + + /** + * A transformer that normalizes the coordinates of a geometry. + */ + private class NormalizationTransformer extends GeometryTransformer { + + @Override + protected CoordinateSequence transformCoordinates(CoordinateSequence coords, Geometry parent) { + for (int i = 0; i < coords.size(); i++) { + Coordinate coordinate = coords.getCoordinate(i); + double x = coordinate.getX() / width * (width + 1); + double y = coordinate.getY() / height * (height + 1); + coords.setOrdinate(i, 0, x); + coords.setOrdinate(i, 1, y); + } + return coords; + } + } +} diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java new file mode 100644 index 000000000..10a811944 --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/ElevationUtils.java @@ -0,0 +1,214 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.awt.image.BufferedImage; +import java.util.function.DoubleToIntFunction; +import java.util.function.IntToDoubleFunction; + +/** + * Provides utility methods for processing raster images, particularly for elevation data. + */ +public class ElevationUtils { + + private static final double ELEVATION_SCALE = 256.0 * 256.0; + private static final double ELEVATION_OFFSET = 10000.0; + private static final double TERRARIUM_OFFSET = 32768.0; + + private ElevationUtils() { + // Private constructor to prevent instantiation + } + + /** + * Converts a BufferedImage to a grid of elevation values. + * + * @param image The input BufferedImage + * @return A double array representing the elevation grid + */ + public static double[] imageToGrid(BufferedImage image) { + validateImage(image); + int width = image.getWidth(); + int height = image.getHeight(); + double[] grid = new double[width * height]; + image.getRaster().getPixels(0, 0, width, height, grid); + return grid; + } + + /** + * Converts a BufferedImage to a grid of elevation values. + * + * @param image The input BufferedImage + * @return A double array representing the elevation grid + */ + public static double[] imageToGrid(BufferedImage image, + IntToDoubleFunction pixelToElevation) { + validateImage(image); + int width = image.getWidth(); + int height = image.getHeight(); + double[] grid = new double[width * height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + int rgb = image.getRGB(x, y); + grid[y * width + x] = pixelToElevation.applyAsDouble(rgb); + } + } + + return grid; + } + + /** + * Converts a grid of elevation values to a BufferedImage. + * + * @param grid The input elevation grid + * @param width The width of the grid + * @param height The height of the grid + * @return A BufferedImage representing the elevation data + */ + public static BufferedImage gridToImage(double[] grid, int width, int height, + DoubleToIntFunction elevationToPixel) { + validateGrid(grid, width, height); + BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + double elevation = grid[y * width + x]; + image.setRGB(x, y, elevationToPixel.applyAsInt(elevation)); + } + } + + return image; + } + + /** + * Converts a pixel value to an elevation value using the standard color scheme. + * + * @param rgb The input pixel value + * @return The elevation value + */ + public static double pixelToElevationNormal(int rgb) { + int r = (rgb >> 16) & 0xFF; + int g = (rgb >> 8) & 0xFF; + int b = rgb & 0xFF; + return (r * ELEVATION_SCALE + g * 256.0 + b) / 10.0 - ELEVATION_OFFSET; + } + + /** + * Converts an elevation value to a pixel value using the standard color scheme. + * + * @param elevation The input elevation value + * @return The pixel value + */ + public static int elevationToPixelStandard(double elevation) { + int value = (int) ((elevation + ELEVATION_OFFSET) * 10.0); + int r = (value >> 16) & 0xFF; + int g = (value >> 8) & 0xFF; + int b = value & 0xFF; + return (r << 16) | (g << 8) | b; + } + + /** + * Validates the input image. + * + * @param image The input image + */ + private static void validateImage(BufferedImage image) { + if (image == null) { + throw new IllegalArgumentException("Input image cannot be null"); + } + if (image.getWidth() <= 0 || image.getHeight() <= 0) { + throw new IllegalArgumentException("Image dimensions must be positive"); + } + } + + /** + * Validates the input grid. + * + * @param grid The input grid + * @param width The width of the grid + * @param height The height of the grid + */ + private static void validateGrid(double[] grid, int width, int height) { + if (grid == null || grid.length == 0) { + throw new IllegalArgumentException("Grid array cannot be null or empty"); + } + if (width <= 0 || height <= 0) { + throw new IllegalArgumentException("Width and height must be positive"); + } + if (grid.length != width * height) { + throw new IllegalArgumentException("Grid array length does not match width * height"); + } + } + + /** + * Inverts the values in the input grid. + * + * @param grid The input grid + * @return The inverted grid + */ + public static double[] invertGrid(double[] grid) { + double[] invertedGrid = new double[grid.length]; + for (int i = 0; i < grid.length; i++) { + invertedGrid[i] = 255.0 - grid[i]; + } + return invertedGrid; + } + + /** + * Clamps the values in the input grid to the specified range. + * + * @param grid The input grid + * @param min The minimum value + * @param max The maximum value + * @return The clamped grid + */ + public static double[] clampGrid(double[] grid, double min, double max) { + double[] clampedGrid = new double[grid.length]; + for (int i = 0; i < grid.length; i++) { + clampedGrid[i] = Math.max(min, Math.min(max, grid[i])); + } + return clampedGrid; + } + + /** + * Converts a pixel value to an elevation value using the Terrarium color scheme. + * + * @param rgb The input pixel value + * @return The elevation value + */ + public static double terrariumToElevation(int rgb) { + int r = (rgb >> 16) & 0xFF; + int g = (rgb >> 8) & 0xFF; + int b = rgb & 0xFF; + return (r * 256.0 + g + b / 256.0) - TERRARIUM_OFFSET; + } + + /** + * Converts an elevation value to a pixel value using the Terrarium color scheme. + * + * @param elevation The input elevation value + * @return The pixel value + */ + public static int elevationToTerrarium(double elevation) { + double adjustedElevation = elevation + TERRARIUM_OFFSET; + int r = (int) (adjustedElevation / 256.0); + int g = (int) (adjustedElevation % 256.0); + int b = (int) ((adjustedElevation - (r * 256.0) - g) * 256.0); + return (r << 16) | (g << 8) | b; + } +} diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java new file mode 100644 index 000000000..38eae5b63 --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/HillshadeCalculator.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +/** + * Provides methods for generating hillshade effects on digital elevation models (DEMs). + */ +public class HillshadeCalculator { + + private static final double EARTH_RADIUS = 6378137; // in meters + private static final int TILE_SIZE = 256; // in pixels + + private double[] dem; + private int width; + private int height; + private double cellSize; + private double[] hillshade; + + /** + * Constructs a HillshadeCalculator with the specified DEM, width, height, and cell size. + * + * @param dem The digital elevation model + * @param width The width of the DEM + * @param height The height of the DEM + * @param cellSize The cell size of the DEM + */ + public HillshadeCalculator(double[] dem, int width, int height, double cellSize) { + this.dem = dem; + this.width = width; + this.height = height; + this.cellSize = cellSize; + this.hillshade = new double[width * height]; + } + + /** + * Validates the input parameters for the hillshade calculation. + * + * @param grid The DEM grid + * @param width The width of the DEM + * @param height The height of the DEM + * @param altitude The altitude of the light source + * @param azimuth The azimuth of the light source + */ + private static void validateInput(double[] grid, int width, int height, double altitude, + double azimuth) { + if (grid == null || grid.length == 0) { + throw new IllegalArgumentException("Grid array cannot be null or empty"); + } + if (width <= 0 || height <= 0) { + throw new IllegalArgumentException("Width and height must be positive"); + } + if (grid.length != width * height) { + throw new IllegalArgumentException("Grid array length does not match width * height"); + } + if (altitude < 0 || altitude > 90) { + throw new IllegalArgumentException("Altitude must be between 0 and 90 degrees"); + } + if (azimuth < 0 || azimuth > 360) { + throw new IllegalArgumentException("Azimuth must be between 0 and 360 degrees"); + } + } + + /** + * Calculates the hillshade effect for the specified altitude and azimuth. + * + * @param altitude The altitude of the light source + * @param azimuth The azimuth of the light source + * @return The hillshade effect + */ + public double[] calculate(double altitude, double azimuth) { + validateInput(dem, width, height, altitude, azimuth); + + double azimuthDeg = 360.0 - azimuth + 90.0; + double azimuthRad = Math.toRadians(azimuthDeg); + + double zenithDeg = 90 - altitude; + double zenithRad = Math.toRadians(zenithDeg); + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + double a = getElevation(x - 1, y - 1); + double b = getElevation(x, y - 1); + double c = getElevation(x + 1, y - 1); + double d = getElevation(x - 1, y); + double f = getElevation(x + 1, y); + double g = getElevation(x - 1, y + 1); + double h = getElevation(x, y + 1); + double i = getElevation(x + 1, y + 1); + + double dzdx = ((c + 2 * f + i) - (a + 2 * d + g)) / (8 * cellSize); + double dzdy = ((g + 2 * h + i) - (a + 2 * b + c)) / (8 * cellSize); + + double slopeRad = Math.atan(Math.sqrt(dzdx * dzdx + dzdy * dzdy)); + + double aspectRad = Math.atan2(dzdy, -dzdx); + if (aspectRad < 0) { + aspectRad += 2 * Math.PI; + } + + double hillshadeValue = 255.0 + * ((Math.cos(zenithRad) * Math.cos(slopeRad)) + + (Math.sin(zenithRad) * Math.sin(slopeRad) * Math.cos(azimuthRad - aspectRad))); + + hillshadeValue = Math.max(0, Math.min(255, hillshadeValue)); + + hillshade[y * width + x] = hillshadeValue; + } + } + + return hillshade; + } + + /** + * Returns the elevation at the specified coordinates. + * + * @param x The x-coordinate + * @param y The y-coordinate + * @return The elevation + */ + public double getElevation(int x, int y) { + x = Math.max(0, Math.min(width - 1, x)); + y = Math.max(0, Math.min(height - 1, y)); + return dem[y * width + x]; + } + + /** + * Returns the resolution of the specified zoom level. + * + * @param zoomLevel The zoom level + * @return The resolution + */ + public static double getResolution(int zoomLevel) { + return (2 * Math.PI * EARTH_RADIUS) / (TILE_SIZE * Math.pow(2, zoomLevel)); + } +} diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java new file mode 100644 index 000000000..1c3701995 --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/Martini.java @@ -0,0 +1,294 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.awt.image.BufferedImage; + +/** + * The {@code Martini} class implements the MARTINI algorithm for generating 3D terrain meshes from + * height data. + * + * @see Martini GitHub + */ +public class Martini { + + private static final double ELEVATION_OFFSET = 10000.0; + + private final int gridSize; + private final int numTriangles; + private final int numParentTriangles; + private final int[] baseCoords; + + /** + * Constructs a new {@code Martini} instance with the specified grid size. + * + * @param gridSize the grid size (must be 2^n+1) + * @throws IllegalArgumentException if the grid size is invalid + */ + public Martini(int gridSize) { + this.gridSize = gridSize; + + int tileSize = gridSize - 1; + if ((tileSize & (tileSize - 1)) != 0) { + throw new IllegalArgumentException("Expected grid size to be 2^n+1, got " + gridSize + "."); + } + + this.numTriangles = tileSize * tileSize * 2 - 2; + this.numParentTriangles = this.numTriangles - tileSize * tileSize; + + this.baseCoords = new int[this.numTriangles * 4]; + for (int i = 0; i < this.numTriangles; i++) { + int id = i + 2; + int ax = 0; + int ay = 0; + int bx = 0; + int by = 0; + int cx = 0; + int cy = 0; + if ((id & 1) != 0) { + bx = by = cx = tileSize; + } else { + ax = ay = cy = tileSize; + } + while ((id >>= 1) > 1) { + int mx = (ax + bx) >> 1; + int my = (ay + by) >> 1; + + if ((id & 1) != 0) { + bx = ax; + by = ay; + ax = cx; + ay = cy; + } else { + ax = bx; + ay = by; + bx = cx; + by = cy; + } + cx = mx; + cy = my; + } + int k = i * 4; + this.baseCoords[k] = ax; + this.baseCoords[k + 1] = ay; + this.baseCoords[k + 2] = bx; + this.baseCoords[k + 3] = by; + } + } + + /** + * Creates a terrain grid from a BufferedImage. + * + * @param image the input image + * @return a double array representing the terrain grid + */ + public static double[] createGrid(BufferedImage image) { + int gridSize = image.getWidth() + 1; + double[] terrain = new double[gridSize * gridSize]; + + int tileSize = image.getWidth(); + + // decode terrain values + for (int y = 0; y < tileSize; y++) { + for (int x = 0; x < tileSize; x++) { + int r = (image.getRGB(x, y) >> 16) & 0xFF; + int g = (image.getRGB(x, y) >> 8) & 0xFF; + int b = image.getRGB(x, y) & 0xFF; + terrain[y * gridSize + x] = (r * 256 * 256 + g * 256.0f + b) / 10.0f - ELEVATION_OFFSET; + } + } + + // backfill right and bottom borders + for (int x = 0; x < gridSize - 1; x++) { + terrain[gridSize * (gridSize - 1) + x] = terrain[gridSize * (gridSize - 2) + x]; + } + for (int y = 0; y < gridSize; y++) { + terrain[gridSize * y + gridSize - 1] = terrain[gridSize * y + gridSize - 2]; + } + + return terrain; + } + + /** + * Creates a new {@code Tile} instance with the specified terrain data. + * + * @param terrain the terrain data + * @return the tile + * @throws IllegalArgumentException if the terrain data is invalid + */ + public Tile createTile(double[] terrain) { + return new Tile(terrain, gridSize, numTriangles, numParentTriangles, baseCoords); + } + + /** + * The {@code Tile} class represents a tile of terrain data. + */ + public static class Tile { + + private final int gridSize; + private final int[] indices; + private final double[] errors; + + private int numVertices; + private int numTriangles; + + private int[] vertices; + private int[] triangles; + private int triIndex = 0; + + private Tile( + double[] terrain, + int gridSize, + int numTriangles, + int numParentTriangles, + int[] coords) { + if (terrain.length != gridSize * gridSize) { + throw new IllegalArgumentException( + "Expected terrain data of length " + (gridSize * gridSize) + " (" + gridSize + " x " + + gridSize + "), got " + terrain.length + "."); + } + + this.gridSize = gridSize; + this.indices = new int[this.gridSize * this.gridSize]; + + this.errors = new double[terrain.length]; + for (int i = numTriangles - 1; i >= 0; i--) { + int k = i * 4; + int ax = coords[k]; + int ay = coords[k + 1]; + int bx = coords[k + 2]; + int by = coords[k + 3]; + int mx = (ax + bx) >> 1; + int my = (ay + by) >> 1; + int cx = mx + my - ay; + int cy = my + ax - mx; + + double interpolatedHeight = (terrain[ay * gridSize + ax] + terrain[by * gridSize + bx]) / 2; + int middleIndex = my * gridSize + mx; + double middleError = Math.abs(interpolatedHeight - terrain[middleIndex]); + + errors[middleIndex] = Math.max(errors[middleIndex], middleError); + + if (i < numParentTriangles) { + int leftChildIndex = ((ay + cy) >> 1) * gridSize + ((ax + cx) >> 1); + int rightChildIndex = ((by + cy) >> 1) * gridSize + ((bx + cx) >> 1); + errors[middleIndex] = Math.max(errors[middleIndex], + Math.max(errors[leftChildIndex], errors[rightChildIndex])); + } + } + } + + /** + * Returns the mesh of the tile with the specified maximum error. + * + * @param maxError the maximum error + * @return the mesh + */ + public Mesh getMesh(double maxError) { + int max = gridSize - 1; + + numVertices = 0; + numTriangles = 0; + countElements(0, 0, max, max, max, 0, maxError); + countElements(max, max, 0, 0, 0, max, maxError); + + vertices = new int[numVertices * 2]; + triangles = new int[numTriangles * 3]; + triIndex = 0; + processTriangle(0, 0, max, max, max, 0, maxError); + processTriangle(max, max, 0, 0, 0, max, maxError); + + return new Mesh(vertices, triangles); + } + + private void countElements(int ax, int ay, int bx, int by, int cx, int cy, double maxError) { + int mx = (ax + bx) >> 1; + int my = (ay + by) >> 1; + + if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * gridSize + mx] > maxError) { + countElements(cx, cy, ax, ay, mx, my, maxError); + countElements(bx, by, cx, cy, mx, my, maxError); + } else { + indices[ay * gridSize + ax] = + indices[ay * gridSize + ax] != 0 ? indices[ay * gridSize + ax] : ++numVertices; + indices[by * gridSize + bx] = + indices[by * gridSize + bx] != 0 ? indices[by * gridSize + bx] : ++numVertices; + indices[cy * gridSize + cx] = + indices[cy * gridSize + cx] != 0 ? indices[cy * gridSize + cx] : ++numVertices; + numTriangles++; + } + } + + private void processTriangle(int ax, int ay, int bx, int by, int cx, int cy, double maxError) { + int mx = (ax + bx) >> 1; + int my = (ay + by) >> 1; + + if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * gridSize + mx] > maxError) { + processTriangle(cx, cy, ax, ay, mx, my, maxError); + processTriangle(bx, by, cx, cy, mx, my, maxError); + } else { + int a = indices[ay * gridSize + ax] - 1; + int b = indices[by * gridSize + bx] - 1; + int c = indices[cy * gridSize + cx] - 1; + + vertices[2 * a] = ax; + vertices[2 * a + 1] = ay; + vertices[2 * b] = bx; + vertices[2 * b + 1] = by; + vertices[2 * c] = cx; + vertices[2 * c + 1] = cy; + + triangles[triIndex++] = a; + triangles[triIndex++] = b; + triangles[triIndex++] = c; + } + } + } + + /** + * The {@code Mesh} class represents a mesh of vertices and triangles. + */ + public static class Mesh { + + private final int[] vertices; + private final int[] triangles; + + private Mesh(int[] vertices, int[] triangles) { + this.vertices = vertices; + this.triangles = triangles; + } + + /** + * Returns the vertices of the mesh. + * + * @return an array of vertex coordinates + */ + public int[] getVertices() { + return vertices; + } + + /** + * Returns the triangles of the mesh. + * + * @return an array of triangle indices + */ + public int[] getTriangles() { + return triangles; + } + } +} diff --git a/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java b/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java new file mode 100644 index 000000000..d91ca42ed --- /dev/null +++ b/baremaps-dem/src/main/java/org/apache/baremaps/dem/RasterUtils.java @@ -0,0 +1,49 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.awt.*; +import java.awt.image.BufferedImage; + +/** + * Provides utility methods for processing raster images. + */ +public class RasterUtils { + + private RasterUtils() { + // Private constructor to prevent instantiation + } + + /** + * Resizes a BufferedImage to the specified dimensions. + * + * @param originalImage The original BufferedImage + * @param targetWidth The target width + * @param targetHeight The target height + * @return The resized BufferedImage + */ + public static BufferedImage resizeImage( + BufferedImage originalImage, int targetWidth, int targetHeight) { + Image resultingImage = + originalImage.getScaledInstance(targetWidth, targetHeight, Image.SCALE_DEFAULT); + BufferedImage outputImage = + new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB); + outputImage.getGraphics().drawImage(resultingImage, 0, 0, null); + return outputImage; + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java new file mode 100644 index 000000000..40df6c7ef --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ChaikinSmootherTest.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; +import org.locationtech.jts.geom.Coordinate; +import org.locationtech.jts.geom.Geometry; +import org.locationtech.jts.geom.GeometryFactory; +import org.locationtech.jts.geom.LineString; + +class ChaikinSmootherTest { + + @Test + void smoothLineString() { + LineString lineString = new GeometryFactory().createLineString(new Coordinate[] { + new Coordinate(0, 0), + new Coordinate(1, 1), + }); + Geometry smoothedLineString = new ChaikinSmoother(2, 0.25).transform(lineString); + assertEquals("LINESTRING (0 0, 0.375 0.375, 0.625 0.625, 0.75 0.75, 1 1)", + smoothedLineString.toString()); + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java new file mode 100644 index 000000000..d518e5618 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourRenderer.java @@ -0,0 +1,89 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.awt.*; +import java.io.IOException; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import javax.imageio.ImageIO; +import javax.swing.*; +import org.locationtech.jts.geom.Geometry; + +public class ContourRenderer { + + public static void main(String[] args) throws IOException { + // Load the image + var path = Path.of("") + .toAbsolutePath() + .resolveSibling("baremaps/baremaps-dem/src/test/resources/fuji.png") + .toAbsolutePath().toFile(); + var image = ImageIO.read(path); + + // Convert the image to a grid + double[] grid = ElevationUtils.imageToGrid(image, ElevationUtils::terrariumToElevation); + + // Trace the contours + List contours = new ArrayList<>(); + for (int i = 0; i < 10000; i += 100) { + contours.addAll(new ContourTracer(grid, image.getWidth(), image.getHeight(), false, false) + .traceContours(i)); + } + + // Create a frame to display the contours + JFrame frame = new JFrame("Contour Lines"); + frame.setSize(image.getWidth() + 20, image.getHeight() + 48); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + frame.add(new ContourCanvas(image, contours)); + frame.setVisible(true); + } + + // Custom Canvas to draw the contours + static class ContourCanvas extends Canvas { + + Image image; + + List contours; + + public ContourCanvas(Image image, List contours) { + this.image = image; + this.contours = contours; + } + + @Override + public void paint(Graphics g) { + + // Draw the image + g.drawImage(image, 10, 10, null); + + g.setColor(Color.RED); + for (Geometry geometry : contours) { + List points = Stream.of(geometry.getCoordinates()) + .map(p -> new Point((int) p.getX() + 10, (int) p.getY() + 10)) + .toList(); + for (int i = 0; i < points.size() - 1; i++) { + Point p1 = points.get(i); + Point p2 = points.get(i + 1); + g.drawLine(p1.x, p1.y, p2.x, p2.y); + } + } + } + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java new file mode 100644 index 000000000..e11b06a17 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerLineStringTest.java @@ -0,0 +1,161 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.locationtech.jts.geom.Geometry; + +class ContourTracerLineStringTest { + + @Test + @DisplayName("Test case 0") + void testProcessCellWithCase00() { + var lines = trace(MarchingSquareUtils.CASE_00); + assertTrue(lines.isEmpty()); + } + + @Test + @DisplayName("Test case 1") + void testProcessCellWithCase01() { + var lines = trace(MarchingSquareUtils.CASE_01); + assertGeometryEquals("LINESTRING (0 0.5, 0.5 0)", lines.get(0)); + } + + @Test + @DisplayName("Test case 2") + void testProcessCellWithCase02() { + var lines = trace(MarchingSquareUtils.CASE_02); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 0, 1 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 3") + void testProcessCellWithCase03() { + var lines = trace(MarchingSquareUtils.CASE_03); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0 0.5, 1 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 4") + void testProcessCellWithCase04() { + var lines = trace(MarchingSquareUtils.CASE_04); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (1 0.5, 0.5 1)", lines.get(0)); + } + + @Test + @DisplayName("Test case 5") + void testProcessCellWithCase05() { + var lines = trace(MarchingSquareUtils.CASE_05); + assertEquals(2, lines.size()); + assertGeometryEquals("LINESTRING (0 0.5, 0.5 1)", lines.get(0)); + assertGeometryEquals("LINESTRING (1 0.5, 0.5 0)", lines.get(1)); + } + + @Test + @DisplayName("Test case 6") + void testProcessCellWithCase06() { + var lines = trace(MarchingSquareUtils.CASE_06); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 0, 0.5 1)", lines.get(0)); + } + + @Test + @DisplayName("Test case 7") + void testProcessCellWithCase07() { + var lines = trace(MarchingSquareUtils.CASE_07); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0 0.5, 0.5 1)", lines.get(0)); + } + + @Test + @DisplayName("Test case 8") + void testProcessCellWithCase08() { + var lines = trace(MarchingSquareUtils.CASE_08); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 1, 0 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 9") + void testProcessCellWithCase09() { + var lines = trace(MarchingSquareUtils.CASE_09); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 1, 0.5 0)", lines.get(0)); + } + + @Test + @DisplayName("Test case 10") + void testProcessCellWithCase10() { + var lines = trace(MarchingSquareUtils.CASE_10); + assertEquals(2, lines.size()); + assertGeometryEquals("LINESTRING (0.5 0, 0 0.5)", lines.get(0)); + assertGeometryEquals("LINESTRING (0.5 1, 1 0.5)", lines.get(1)); + } + + @Test + @DisplayName("Test case 11") + void testProcessCellWithCase11() { + var lines = trace(MarchingSquareUtils.CASE_11); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 1, 1 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 12") + void testProcessCellWithCase12() { + var lines = trace(MarchingSquareUtils.CASE_12); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (1 0.5, 0 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 13") + void testProcessCellWithCase13() { + var lines = trace(MarchingSquareUtils.CASE_13); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (1 0.5, 0.5 0)", lines.get(0)); + } + + @Test + @DisplayName("Test case 14") + void testProcessCellWithCase14() { + var lines = trace(MarchingSquareUtils.CASE_14); + assertEquals(1, lines.size()); + assertGeometryEquals("LINESTRING (0.5 0, 0 0.5)", lines.get(0)); + } + + @Test + @DisplayName("Test case 15") + void testProcessCellWithCase15() { + var lines = trace(MarchingSquareUtils.CASE_15); + assertTrue(lines.isEmpty()); + } + + List trace(double[] grid) { + return new ContourTracer(grid, 2, 2, false, false).traceContours(0.5); + } + +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java new file mode 100644 index 000000000..effeee978 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerPolygonTest.java @@ -0,0 +1,191 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.List; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.locationtech.jts.geom.Geometry; +import org.locationtech.jts.geom.Polygon; + +class ContourTracerPolygonTest { + + @Test + @DisplayName("Test case 0") + void testProcessCellWithCase00() { + var polygons = trace(MarchingSquareUtils.CASE_00); + assertTrue(polygons.isEmpty()); + } + + @Test + @DisplayName("Test case 1") + void testProcessCellWithCase01() { + var polygons = trace(MarchingSquareUtils.CASE_01); + assertGeometryEquals("POLYGON ((0.5 0, 0 0, 0 0.5, 0.5 0))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 2") + void testProcessCellWithCase02() { + var polygons = trace(MarchingSquareUtils.CASE_02); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 0.5, 1 0, 0.5 0, 1 0.5))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 3") + void testProcessCellWithCase03() { + var polygons = trace(MarchingSquareUtils.CASE_03); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0 0, 0 0.5, 1 0.5, 1 0, 0 0))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 4") + void testProcessCellWithCase04() { + var polygons = trace(MarchingSquareUtils.CASE_04); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 1, 1 0.5, 0.5 1, 1 1))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 5") + void testProcessCellWithCase05() { + var polygons = trace(MarchingSquareUtils.CASE_05); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 1, 1 0.5, 0.5 0, 0 0, 0 0.5, 0.5 1, 1 1))", + polygons.get(0)); + } + + @Test + @DisplayName("Test case 6") + void testProcessCellWithCase06() { + var polygons = trace(MarchingSquareUtils.CASE_06); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0.5 1, 1 1, 1 0, 0.5 0, 0.5 1))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 7") + void testProcessCellWithCase07() { + var polygons = trace(MarchingSquareUtils.CASE_07); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 1, 1 0, 0 0, 0 0.5, 0.5 1, 1 1))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 8") + void testProcessCellWithCase08() { + var polygons = trace(MarchingSquareUtils.CASE_08); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0.5 1, 0 0.5, 0 1, 0.5 1))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 9") + void testProcessCellWithCase09() { + var polygons = trace(MarchingSquareUtils.CASE_09); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0.5 1, 0.5 0, 0 0, 0 1, 0.5 1))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 10") + void testProcessCellWithCase10() { + var polygons = trace(MarchingSquareUtils.CASE_10); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0.5 1, 1 0.5, 1 0, 0.5 0, 0 0.5, 0 1, 0.5 1))", + polygons.get(0)); + } + + @Test + @DisplayName("Test case 11") + void testProcessCellWithCase11() { + var polygons = trace(MarchingSquareUtils.CASE_11); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 0, 0 0, 0 1, 0.5 1, 1 0.5, 1 0))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 12") + void testProcessCellWithCase12() { + var polygons = trace(MarchingSquareUtils.CASE_12); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((1 0.5, 0 0.5, 0 1, 1 1, 1 0.5))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 13") + void testProcessCellWithCase13() { + var polygons = trace(MarchingSquareUtils.CASE_13); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0.5 0, 0 0, 0 1, 1 1, 1 0.5, 0.5 0))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 14") + void testProcessCellWithCase14() { + var polygons = trace(MarchingSquareUtils.CASE_14); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0 0.5, 0 1, 1 1, 1 0, 0.5 0, 0 0.5))", polygons.get(0)); + } + + @Test + @DisplayName("Test case 15") + void testProcessCellWithCase15() { + var polygons = trace(MarchingSquareUtils.CASE_15); + assertEquals(1, polygons.size()); + assertGeometryEquals("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", polygons.get(0)); + } + + public static List trace(double[] grid) { + int size = (int) Math.sqrt(grid.length); + return new ContourTracer(grid, size, size, false, true).traceContours(0.5); + } + + @Test + @DisplayName("Closed LineString Bug 1") + void testProcessCellWithCaseClosedLineStringBug1() { + var grid = new double[] { + 133.3801854240864, 121.23325422569911, 153.52819487296264, 167.57377406292332, + 100.937349262252, 96.62896517856514, 132.65708268451803, 147.307915356104, + 98.7659308960914, 104.55934526711907, 141.3071569592299, 151.71211629894563, + 139.87179431281479, 144.5483699607932, 171.74295402684095, 175.7901414451639 + }; + var contours = new ContourTracer(grid, 4, 4, false, true).traceContours(99); + assertFalse(contours.isEmpty()); + assertTrue(contours.stream().allMatch(Polygon.class::isInstance)); + } + + @Test + @DisplayName("Closed LineString Bug 2") + void testProcessCellWithCaseClosedLineStringBug2() { + var grid = new double[] { + 491.0, 495.0, 502.0, 503.0, + 487.0, 493.0, 500.0, 499.0, + 490.0, 495.0, 500.0, 497.0, + 499.0, 502.0, 505.0, 500.0, + }; + var contours = new ContourTracer(grid, 4, 4, false, true).traceContours(500); + assertFalse(contours.isEmpty()); + assertTrue(contours.stream().allMatch(Polygon.class::isInstance)); + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java new file mode 100644 index 000000000..f96cf5a7f --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/ContourTracerTest.java @@ -0,0 +1,90 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.apache.baremaps.testing.GeometryAssertions.assertGeometryEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + +import java.io.IOException; +import java.nio.file.Path; +import javax.imageio.ImageIO; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.locationtech.jts.geom.Polygon; +import org.locationtech.jts.io.ParseException; + +class ContourTracerTest { + + @Test + @DisplayName("Test grid normalization") + void testGrid1() throws ParseException { + var grid = new double[] { + 0, 0, 0, + 0, 1, 0, + 0, 0, 0, + }; + var generatedContour = new ContourTracer(grid, 3, 3, true, true).traceContours(0).get(0); + assertGeometryEquals( + "POLYGON ((0 1.3333333333333333, 0 2.6666666666666665, 1.3333333333333333 2.6666666666666665, 2.6666666666666665 2.6666666666666665, 2.6666666666666665 1.3333333333333333, 2.6666666666666665 0, 1.3333333333333333 0, 0 0, 0 1.3333333333333333))", + generatedContour); + } + + @Test + @DisplayName("Test Mount Fuji") + void testMountFuji() throws IOException { + var fujiImage = ImageIO.read( + Path.of("") + .toAbsolutePath() + .resolveSibling("baremaps-dem/src/test/resources/fuji.png") + .toAbsolutePath().toFile()); + + var fujiGrid = ElevationUtils.imageToGrid(fujiImage, ElevationUtils::pixelToElevationNormal); + var fujiContours = + new ContourTracer(fujiGrid, fujiImage.getWidth(), fujiImage.getHeight(), false, true) + .traceContours(500); + + assertFalse(fujiContours.isEmpty()); + } + + @Test + @DisplayName("Test polygon with hole and island") + void testPolygonWithHole() { + var grid = new double[] { + 1, 1, 1, 1, 1, + 1, 0, 0, 0, 1, + 1, 0, 1, 0, 1, + 1, 0, 0, 0, 1, + 1, 1, 1, 1, 1, + }; + var generatedContours = new ContourTracer(grid, 5, 5, false, true).traceContours(0.5); + assertEquals(2, generatedContours.size()); + var polygon1 = (Polygon) generatedContours.get(0); + var exteriorRing = polygon1.getExteriorRing(); + var interiorRing = polygon1.getInteriorRingN(0); + assertGeometryEquals( + "LINEARRING (0 0, 0 1, 0 2, 0 3, 0 4, 1 4, 2 4, 3 4, 4 4, 4 3, 4 2, 4 1, 4 0, 3 0, 2 0, 1 0, 0 0)", + exteriorRing); + assertGeometryEquals( + "LINEARRING (0.5 1, 1 0.5, 2 0.5, 3 0.5, 3.5 1, 3.5 2, 3.5 3, 3 3.5, 2 3.5, 1 3.5, 0.5 3, 0.5 2, 0.5 1)", + interiorRing); + var polygon2 = (Polygon) generatedContours.get(1); + assertGeometryEquals("LINEARRING (1.5 2, 2 2.5, 2.5 2, 2 1.5, 1.5 2)", + polygon2.getExteriorRing()); + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java new file mode 100644 index 000000000..98c05bba3 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillShadeRenderer.java @@ -0,0 +1,158 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.awt.*; +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.nio.file.Path; +import javax.imageio.ImageIO; +import javax.swing.*; +import javax.swing.event.ChangeEvent; +import javax.swing.event.ChangeListener; + +public class HillShadeRenderer extends JFrame { + + private BufferedImage originalImage; + private double[] grid; + private JSlider altitudeSlider; + private JSlider azimuthSlider; + private JSlider scaleSlider; + private JCheckBox isSimpleCheckbox; + private JLabel imageLabel; + private JLabel altitudeLabel; + private JLabel azimuthLabel; + private JLabel scaleLabel; + + public HillShadeRenderer() throws IOException { + super("Hillshade Display"); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + // Load the image + originalImage = ImageIO.read( + Path.of("") + .toAbsolutePath() + .resolveSibling("baremaps/baremaps-dem/src/test/resources/fuji.png") + .toAbsolutePath().toFile()); + grid = ElevationUtils.imageToGrid(originalImage, ElevationUtils::pixelToElevationNormal); + + // Create UI components + altitudeSlider = new JSlider(JSlider.VERTICAL, 0, 90, 45); + azimuthSlider = new JSlider(JSlider.VERTICAL, 0, 360, 315); + scaleSlider = new JSlider(JSlider.HORIZONTAL, 1, 100, 10); // Scale from 0.1 to 10.0 + isSimpleCheckbox = new JCheckBox("Simple Algorithm", true); + imageLabel = new JLabel(); + altitudeLabel = new JLabel("Sun Altitude: 45°"); + azimuthLabel = new JLabel("Sun Azimuth: 315°"); + scaleLabel = new JLabel("Scale: 1.0"); + + // Set up sliders + altitudeSlider.setMajorTickSpacing(15); + altitudeSlider.setPaintTicks(true); + altitudeSlider.setPaintLabels(true); + + azimuthSlider.setMajorTickSpacing(45); + azimuthSlider.setPaintTicks(true); + azimuthSlider.setPaintLabels(true); + + scaleSlider.setMajorTickSpacing(10); + scaleSlider.setPaintTicks(true); + scaleSlider.setPaintLabels(true); + + // Add listeners + ChangeListener listener = new ChangeListener() { + public void stateChanged(ChangeEvent e) { + updateLabels(); + redrawHillshade(); + } + }; + altitudeSlider.addChangeListener(listener); + azimuthSlider.addChangeListener(listener); + scaleSlider.addChangeListener(listener); + isSimpleCheckbox.addActionListener(e -> redrawHillshade()); + + // Set up layout + setLayout(new BorderLayout()); + JPanel controlPanel = new JPanel(new GridBagLayout()); + GridBagConstraints gbc = new GridBagConstraints(); + gbc.gridx = 0; + gbc.gridy = 0; + gbc.insets = new Insets(5, 5, 5, 5); + controlPanel.add(altitudeLabel, gbc); + gbc.gridy++; + controlPanel.add(altitudeSlider, gbc); + gbc.gridy++; + controlPanel.add(azimuthLabel, gbc); + gbc.gridy++; + controlPanel.add(azimuthSlider, gbc); + gbc.gridy++; + controlPanel.add(scaleLabel, gbc); + gbc.gridy++; + controlPanel.add(scaleSlider, gbc); + gbc.gridy++; + controlPanel.add(isSimpleCheckbox, gbc); + + add(imageLabel, BorderLayout.CENTER); + add(controlPanel, BorderLayout.EAST); + + // Initial draw + redrawHillshade(); + + pack(); + setVisible(true); + } + + private void updateLabels() { + altitudeLabel.setText("Sun Altitude: " + altitudeSlider.getValue() + "°"); + azimuthLabel.setText("Sun Azimuth: " + azimuthSlider.getValue() + "°"); + scaleLabel.setText("Scale: " + (scaleSlider.getValue() / 10.0)); + } + + private void redrawHillshade() { + int sunAltitude = altitudeSlider.getValue(); + int sunAzimuth = azimuthSlider.getValue(); + double scale = scaleSlider.getValue() / 10.0; + + double[] hillshade = new HillshadeCalculator(grid, originalImage.getWidth(), + originalImage.getHeight(), scale).calculate(sunAltitude, sunAzimuth); + + BufferedImage hillshadeImage = new BufferedImage(originalImage.getWidth(), + originalImage.getHeight(), BufferedImage.TYPE_BYTE_GRAY); + for (int y = 0; y < originalImage.getHeight(); y++) { + for (int x = 0; x < originalImage.getWidth(); x++) { + int shade = (int) hillshade[y * originalImage.getWidth() + x]; + int rgb = new Color(shade, shade, shade).getRGB(); + hillshadeImage.setRGB(x, y, rgb); + } + } + + imageLabel.setIcon(new ImageIcon(hillshadeImage)); + revalidate(); + repaint(); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(() -> { + try { + new HillShadeRenderer(); + } catch (IOException e) { + e.printStackTrace(); + } + }); + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java new file mode 100644 index 000000000..4d3408dae --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/HillshadeCalculatorTest.java @@ -0,0 +1,103 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.stream.Stream; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +class HillshadeCalculatorTest { + + @Test + @DisplayName("Test hillShade with valid input") + void testHillShadeValidInput() { + double[] dem = { + 1, 2, 3, + 4, 5, 6, + 7, 8, 9 + }; + int width = 3; + int height = 3; + double sunAltitude = 45; + double sunAzimuth = 315; + + double[] result = + new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, sunAzimuth); + + assertNotNull(result); + assertEquals(dem.length, result.length); + } + + @ParameterizedTest + @MethodSource("provideInvalidInput") + @DisplayName("Test hillShade with invalid input") + void testHillShadeInvalidInput(double[] dem, int width, int height, double sunAltitude, + double sunAzimuth, Class expectedException) { + assertThrows(expectedException, + () -> new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, + sunAzimuth)); + } + + @ParameterizedTest + @MethodSource("provideInvalidInput") + @DisplayName("Test hillShadeEnhanced with invalid input") + void testHillShadeEnhancedInvalidInput(double[] dem, int width, int height, double sunAltitude, + double sunAzimuth, Class expectedException) { + assertThrows(expectedException, + () -> new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, + sunAzimuth)); + } + + private static Stream provideInvalidInput() { + return Stream.of( + Arguments.of(null, 3, 3, 45, 315, IllegalArgumentException.class), + Arguments.of(new double[0], 3, 3, 45, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 0, 3, 45, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 3, 0, 45, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 2, 2, 45, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 3, 3, -1, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 3, 3, 91, 315, IllegalArgumentException.class), + Arguments.of(new double[9], 3, 3, 45, -1, IllegalArgumentException.class), + Arguments.of(new double[9], 3, 3, 45, 361, IllegalArgumentException.class)); + } + + @Test + @DisplayName("Test hillShade output range") + void testHillShadeOutputRange() { + double[] dem = new double[100]; + for (int i = 0; i < dem.length; i++) { + dem[i] = Math.random() * 1000; + } + int width = 10; + int height = 10; + double sunAltitude = 45; + double sunAzimuth = 315; + + double[] result = + new HillshadeCalculator(dem, width, height, 1).calculate(sunAltitude, sunAzimuth); + + for (double value : result) { + assertTrue(value >= 0 && value <= 255, "Hillshade value should be between 0 and 255"); + } + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java new file mode 100644 index 000000000..dee4d9376 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareRenderer.java @@ -0,0 +1,110 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.apache.baremaps.dem.ContourTracerPolygonTest.*; + +import java.awt.*; +import java.util.List; +import javax.swing.*; +import org.locationtech.jts.geom.Coordinate; +import org.locationtech.jts.geom.Geometry; +import org.locationtech.jts.geom.LineString; +import org.locationtech.jts.geom.Polygon; +import org.locationtech.jts.geom.util.AffineTransformation; + +public class MarchingSquareRenderer extends JPanel { + private List geometries; + + public MarchingSquareRenderer(List geometries) { + this.geometries = geometries; + } + + @Override + protected void paintComponent(Graphics g) { + super.paintComponent(g); + Graphics2D g2d = (Graphics2D) g; + g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); + + g2d.drawRect(718 - 10, 790 - 10, 20, 20); + + for (Geometry geometry : geometries) { + if (geometry instanceof Polygon) { + drawPolygon(g2d, (Polygon) geometry); + } + if (geometry instanceof LineString) { + drawLineString(g2d, (LineString) geometry); + } + } + } + + private void drawLineString(Graphics2D g2d, LineString geometry) { + if (geometry.isClosed()) { + g2d.setColor(Color.RED); + } else { + System.out.println(geometry); + g2d.setColor(Color.BLUE); + } + + Coordinate[] coordinates = geometry.getCoordinates(); + int[] xPoints = new int[coordinates.length]; + int[] yPoints = new int[coordinates.length]; + + for (int i = 0; i < coordinates.length; i++) { + xPoints[i] = (int) coordinates[i].getX(); + yPoints[i] = (int) coordinates[i].getY(); + } + + g2d.drawPolyline(xPoints, yPoints, coordinates.length); + } + + private void drawPolygon(Graphics2D g2d, Polygon polygon) { + Coordinate[] coordinates = polygon.getCoordinates(); + int[] xPoints = new int[coordinates.length]; + int[] yPoints = new int[coordinates.length]; + + for (int i = 0; i < coordinates.length; i++) { + xPoints[i] = (int) coordinates[i].getX(); + yPoints[i] = (int) coordinates[i].getY(); + } + + g2d.drawPolygon(xPoints, yPoints, coordinates.length); + } + + public static void main(String[] args) { + JFrame frame = new JFrame("Geometry Drawer"); + + JPanel mainPanel = new JPanel(new GridLayout(4, 4)); + // mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS)); + for (double[] c : MarchingSquareUtils.CASES) { + + List geometries = trace(c) + .stream() + .map(AffineTransformation.scaleInstance(50, 50).translate(0, 0)::transform) + .toList(); + + MarchingSquareRenderer drawer = new MarchingSquareRenderer(geometries); + mainPanel.add(drawer); + } + + frame.add(mainPanel); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + frame.setLocationRelativeTo(null); // Center the frame on the screen + frame.setVisible(true); + } +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java new file mode 100644 index 000000000..c7e8fec57 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MarchingSquareUtils.java @@ -0,0 +1,127 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import java.util.List; + +public class MarchingSquareUtils { + + public static final double[] CASE_00 = { + 0, 0, + 0, 0, + }; + + public static final double[] CASE_01 = { + 1, 0, + 0, 0, + }; + + public static final double[] CASE_02 = { + 0, 1, + 0, 0, + }; + + public static final double[] CASE_03 = { + 1, 1, + 0, 0, + }; + + public static final double[] CASE_04 = { + 0, 0, + 0, 1, + }; + + public static final double[] CASE_05 = { + 1, 0, + 0, 1, + }; + + public static final double[] CASE_06 = { + 0, 1, + 0, 1, + }; + + public static final double[] CASE_07 = { + 1, 1, + 0, 1, + }; + + public static final double[] CASE_08 = { + 0, 0, + 1, 0, + }; + + public static final double[] CASE_09 = { + 1, 0, + 1, 0, + }; + + public static final double[] CASE_10 = { + 0, 1, + 1, 0, + }; + + public static final double[] CASE_11 = { + 1, 1, + 1, 0, + }; + + public static final double[] CASE_12 = { + 0, 0, + 1, 1, + }; + + public static final double[] CASE_13 = { + 1, 0, + 1, 1, + }; + + public static final double[] CASE_14 = { + 0, 1, + 1, 1, + }; + + public static final double[] CASE_15 = { + 1, 1, + 1, 1, + }; + + public static final List CASES = List.of( + CASE_00, CASE_01, CASE_02, CASE_03, + CASE_04, CASE_05, CASE_06, CASE_07, + CASE_08, CASE_09, CASE_10, CASE_11, + CASE_12, CASE_13, CASE_14, CASE_15); + + public static final double[] buffer(double[] grid) { + return new double[] { + 0, 0, 0, 0, + 0, grid[0], grid[1], 0, + 0, grid[2], grid[3], 0, + 0, 0, 0, 0, + }; + } + + public static final List BUFFERED_CASES = List.of( + buffer(CASE_00), buffer(CASE_01), buffer(CASE_02), buffer(CASE_03), + buffer(CASE_04), buffer(CASE_05), buffer(CASE_06), buffer(CASE_07), + buffer(CASE_08), buffer(CASE_09), buffer(CASE_10), buffer(CASE_11), + buffer(CASE_12), buffer(CASE_13), buffer(CASE_14), buffer(CASE_15)); + + + +} diff --git a/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java new file mode 100644 index 000000000..b978b6a35 --- /dev/null +++ b/baremaps-dem/src/test/java/org/apache/baremaps/dem/MartiniTest.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.dem; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import java.io.IOException; +import java.nio.file.Path; +import javax.imageio.ImageIO; +import org.junit.jupiter.api.Test; + +class MartiniTest { + + @Test + void generateAMesh() throws IOException { + var png = ImageIO.read( + Path.of("") + .toAbsolutePath() + .resolveSibling("baremaps-dem/src/test/resources/fuji.png") + .toAbsolutePath().toFile()); + var terrainGrid = Martini.createGrid(png); + var martini = new Martini(png.getWidth() + 1); + var tile = martini.createTile(terrainGrid); + var mesh = tile.getMesh(500); + + assertArrayEquals(new int[] { + 320, 64, 256, 128, 320, 128, 384, 128, 256, 0, 288, 160, 256, 192, 288, 192, 320, 192, 304, + 176, 256, 256, 288, 224, 352, 160, 320, 160, 512, 0, 384, 0, 128, 128, 128, 0, 64, 64, 64, + 0, 0, 0, 32, 32, 192, 192, 384, 384, 512, 256, 384, 256, 320, 320, 320, 256, 512, 512, 512, + 128, 448, 192, 384, 192, 128, 384, 256, 512, 256, 384, 0, 512, 128, 256, 64, 192, 0, 256, + 64, 128, 32, 96, 0, 128, 32, 64, 16, 48, 0, 64, 0, 32 + }, mesh.getVertices()); + + assertArrayEquals(new int[] { + 0, 1, 2, 3, 0, 2, 4, 1, 0, 5, 6, 7, 7, 8, 9, 5, 7, 9, 1, 6, 5, 6, 10, 11, 11, 8, 7, 6, 11, + 7, 12, 2, 13, 8, 12, 13, 3, 2, 12, 2, 1, 5, 13, 5, 9, 8, 13, 9, 2, 5, 13, 3, 14, 15, 15, 4, + 0, 3, 15, 0, 16, 4, 17, 18, 17, 19, 19, 20, 21, 18, 19, 21, 16, 17, 18, 1, 16, 22, 22, 10, + 6, 1, 22, 6, 4, 16, 1, 23, 24, 25, 26, 25, 27, 10, 26, 27, 23, 25, 26, 28, 24, 23, 29, 3, + 30, 24, 29, 30, 14, 3, 29, 8, 25, 31, 31, 3, 12, 8, 31, 12, 27, 8, 11, 10, 27, 11, 25, 8, + 27, 25, 24, 30, 30, 3, 31, 25, 30, 31, 32, 33, 34, 10, 32, 34, 35, 33, 32, 33, 28, 23, 34, + 23, 26, 10, 34, 26, 33, 23, 34, 36, 16, 37, 38, 36, 37, 36, 10, 22, 16, 36, 22, 39, 18, 40, + 41, 39, 40, 16, 18, 39, 42, 21, 43, 44, 42, 43, 18, 21, 42, 21, 20, 45, 45, 44, 43, 21, 45, + 43, 44, 41, 40, 40, 18, 42, 44, 40, 42, 41, 38, 37, 37, 16, 39, 41, 37, 39, 38, 35, 32, 32, + 10, 36, 38, 32, 36 + }, mesh.getTriangles()); + } +} diff --git a/baremaps-dem/src/test/resources/fuji.png b/baremaps-dem/src/test/resources/fuji.png new file mode 100644 index 0000000000000000000000000000000000000000..9e4e8b7662d2cf059b85a697a279403a7a6927d0 GIT binary patch literal 578765 zcmV)7K*zs{P)wW@X`3W5R( zN)RQ8cnla241m^s`WU@{c3ZpO`R@Jmo%>_9Rkgw!<{V@6KGJ;W%$@&^nYr`7H#2v^ z8yU-I=Jvg7W^Vt%Gjj)ao0&U!<}se+y)F5SYaQd5<4w-X|Aj|q z=9X5NnOo+*$|o`Q;{Pu&j^^)A&CIR*eP(X$<1=&XTzB(xGjm(-;kC=SkiVxGckp-r z%-qK2eDAL_bF07SH-BQR&hI&P`41fHGVb%EoNMs^2V>%)#3k>oc}sY{fW$flQRY%qTOSV7^#` z%6bgWQ{j9SzEfe1E1ajoaVpGZ<)6&&e=t^M?9TWYgYQ>&VXWo%-^us>^l%<7?LS zp6TmEM;feO<1-A_x52zMHekG)v5H^O$Hu-4=BDuh2J757gMr>Qn5V|Ij5Y(gXe?vg z#rQ8@6YJbKn{)q-@gv6f8JhQp7}$x%n;4rgKJELzkx}rg=IJm7de~sC8`zA-`x)GO z1Dn%8w;ISoguhw%}{?)jUVWN-oFI?LiG7<^Xa z8mq`%Z6#ixW-Mf2hpL>fx-Nq`uOMd?=B$GJR({I3opB3ef`QIfkf{pmTw$&%4F+pa zDKU_}%0Ucdvy6Q#-_74|$^R>FWpMpv^tb$L2J2BqM$4>Wc@d+sqMQmsh zJ6!xF19>kocV)g?F4zw1Gw!9p{1lMy!cz>^r+^JAAcqCkzVKlNx;x3-O`RW{mXMVawym@=zvbA)fBL>P4_spjnJ6KfC3LRDb(fII5^G)p z*GkB4X*<8C?<0#PWV(c{E3M+sG_b`bWUqw&mG<>}-O>mHnJ8VrxXx>G zrERkY_N9bAm9W31i~ZT9w%0YUC-%RDeJg>T<<~Pdnwc|q!PPT!7h-4@ZpPpweSmL2 zMr+`B1`05U@C|(~!Fq)6470dH9AtP6{{JMvdm_Ngq)s4s6HMkL3Q<643ru_g<1={z z?{i_}(~Pe$n3!=UZfp;Ji%}opbp+ubg@lY@K*s^v35019BQ(kRCb+%{6m|Ube2x&0 zGKnJ?*%5$gm<1f>_rnkKJ`*~|F(xn`lPE`lNh$u2n?)$g`!o2v4EUEMgq*)}Ln@|} zJB%I^*SH{!T9e~8W!NAfb$(lAPAW`fnK>wPpXE2_L>5tw;++2h;Qrr@A%+wVvQq>+ zix|x!_gvhbv9HIcth^#{5~Mj6+5;^}7_ZW28OTHF9t#n3UEYs@5SLMuGV5CgoXQAj z889xt#Jq8y3d&PqEh`+Of>KrL3`kbxHU{8U`8RWnL8-DXRY0f8I#n^^RTQ@h(X3*e zs$6pwB2h(ot0-U&RYxI~();4g9QY9XYMD z#`Q-S&l~(9gbl8{0a<8ZU>aOcW6&TdP=~xUFpv$1MuYok-0ROUNR4lr95npB>6E3$ zeF^eS?x%?yH!%=Rj@{(inh@(I_tj)gn%q}&)f^3xk>?n?uHX24T?0G7)40ypwygnN z*LtMi*SS&r28O@U@Bj51bi0A>Hn@fc`rG)t3Btbqtq8*IZuLnTPuM4D3n$ zyC#8$J z#x^Dc08a&?Sq6y95VA7!Q$`lc$YvSGt;`&k(W~-0wvpQ;Fi5urfG^uRWUho$SAs~D zK48#)hyP|BN;p|X>}C-;D5Cepd(!sC>#YgIC3K^FLXwOUuSJekM4yX*VG#mRz*ZEv z&jNP1fHPPCpbOZS0_Q2P<^}F!lH*OH_91qfteF~^b3XYPu~auK3b zg5;D=Nzg9p^PBP-OUO$J94l*n(DMp1SpoYh$U$Z2bYe;k|6X8^9VtQ5OOUM6T;Ka@ z25)_5eS`cu2J=-7@SE6)ngx0hs67nuYnX`qr+>SVi3T!N+SSJuVZdQ3?Qa`=WnOoQ z`6*rN@l6B%6&}cU37rXNm-{JUk4ycw+r?Lr0Oq^AA_QO|La-2Tw+|N6$AtG`p!-?) zeiUhd$r(T~1~5QF2=@>MatM|>hyo8`XogXw5l%MBB9Fo5#s>gkJe0{xOajF2xWGx+ z?<5K|@c@H`9ltrjeiWuVg7F{4iy32#bL`3e&FFr@U=a!^{v;DW&auW=s8QJLCi(+wjdF3TuSU|9ZAuHdB0=_vJdJSQz{W}4n z!NfNq7flwSj^Nbzef2e|IHecN%2=o(ieF^z3P1cG0Pz3aVBQMMNf9GaWIl`BV-Zj+ zZfz2PF)9MQMF74CNEb28#b>PGA^@jZc*R6DpR9lRb;;(-2w52!DYKU4n`~r|lZuQR z@>JnF6^wfYAgEky&mRw<0%@!~oROI7>kaZE0Q(yFF%s3!m;kWO)h!(r;8;}*U=^cY zLwRZ#rrIA3>{?Icrgob>{k;wLyW8j=Xd`~@tH1!pU&p941ZG@E137A}Zx9mj9AUte zr+XZ zdANzdrj7zI&&~hHC_#fYY&>nUvC!ZNxohB^H9l)_zt-dfPp|O@|CYIJ{L8<+&)1I* zM#KWc*!Z=F?q}&tdi%_O<6H)wR)e)|{4$TH`)E99GNOnBdLNOCn+@2CFknO*%zFbv z6=VgyZ(x`kkLT~2b9}zreEiFO4=0&`9AWYy;xOpr%&x=X2L4_BT@e?^Wn*rxV_jsB zYpgTxb*{S(d8yy+=m5v6W3TF$8uXE!I)=Z#*yQ16gS%t`Vq4cSnZG)EUdR5`zhWX$ zwG8cJ;>n!VkdGS2ui-4!xW*dmQG?*s(4m^-`zPs0RIhau;FIZjR+x_p9(RS$EBBiS z{LGOtfVlFQ3Bu1Ae=tGd{wkNJ_ZpEk$VLTkz5D2ao=Vum@@h!}N|3$Mas$r!wt@Q28xjn|Gv*vc1+nSFQFSHMMnV1$}SA_sLZ^V zk+(ABOp$?bb~f^L%MtpJ|6b34y`hKxUfu8O`y2c9{XXZ%Oc3<Gya@n=wuGZw0%uFun9{djMGiy&t~LqKdx{ba_%}ly$ZiQ) zFEMAOXA}Y8Bnx0u3t)T;xqyW*vpy!U9|i7b;RgZcK>%bBKo~?x2VpJ)2-6@FG=#to zGm#@0{85<67{4Ef1x>;#3xH{Xi<@LJ3mCKlf?Gg0b>Z*7{?kzfF?G` z&x;%9VisX91%P)FrJ8`CjG>sLfcGeZGRAd}?U#{*k)=*YU}VNo&pcEnMJyZBA5Qi!PT;u(kya9O`tJ)jmwJvrKQ?72|u)o+bAXCJs6~B?*ba>bQ zrvd(dHL6L3#ITFZVNvAelMerHYcjB#J%7Bx;;BiR6e=tJ*(6|h3*{xLAZ3KQ%=(rq zjQcaxFVHVPnO=wtP6eT_aGuJ+_WTjx3i4AyPAY(J1y)+QI|+acU3CSA_LTxaajSr`c>AhiZQ66+%;sP_L#%6+o#7?d&-7ezz?CQV-)HqIxH+Bjsd76 z^L4JFE`WNSJxgS_v8Ml)hl~Mg9AhAo=M7C_0c}7~` zn+Ed-4C41BS!hD+n#^01`ERnuO^9@a?H8Gt+>!UwT-)b7I0-`oqph%h<9h~tjoC=V zKN7&3Z!oENDM?BkZ@$4=k%W_TzMAiJy5miG{^ol<7syppgsbOyD){#zPiL7B+~~O# zDPi3j%u^7b%ltj1LX>h*FoCc5wi@a1mYtTnlD-fbcvniZ? zw28p$Gg?soy$Qgm2lrn_&&nTlGyvHue=r@S5@aEw0P=XBx8o$>P$-#o3eQ*`u{>0H z!}4Z7X)xQvc0;MgzuGJRn+e2|`Mn~bT%54I0bCWHFFfpVv+)ACE}*vs9K*to>=<&- z1mx8xfVf&rZpnzNcsM{vr~g^dmN}g057M)iU!{nlRw* z=3^;Ru(t09-3^a^TYn}GeqED;)eZOp@Y$$=LjCgScl3K7_8e_$f};P|^y~Jo0)CML zh5gaR(oVh}h5e6D`&&X+!U+?o%lns?f4PakEYOPxoac2?B&6S;DT;&KM`{Pc0|}Zl zcRoTkAElj-KrBG;7GTsCqDcKL_5gx9$Yc%jgF%#dfSc+^Q3nvV0hsd;ia5+g52M5* z9A^}v9^<`7~KLlGKn`ap_Bm1FvdcTbBu9>Y*L|~^AcngvM8bu z%Ihd9FwVk`DRKbo9>)NU<4pJjMr;y;R=^_?6D{M-RlefI zKEq+Mw;PzAMLD^*`f3hawlnwNl(+ayhL@`dL}d#T2ozf3oZ`coXZk-5@c-SAGGWjQ z%x@7;F79aXKfuZ-&_COZ9M)Lucew0Fsaz56605$8duOi8V@{_4-eo+>^0S_o#~gxu zz2{e9f7YPF997OV0l2__i+p|8DFB#%<%J|-Rg6XzQdj+gz5LIa1R&7W&--tMP`SqH z&+TRPoa@KCu7A=-SvmeqY`{_SI^U~*$sysg!2qDF1DJKZtH@I;TrC2)i@i;Okiz5F z8D#G<0TA&1A^|o$-@n)se#YcL9(CCu`+fiBC42Q;UlUnwVx*hr80@*PCfC(OIh!~7 z|C9XrxsDX|5=X)>(*S~$GObMLXVpp*!!MMC(K4A z^gRrF6P;`}@;U?Dxv%CHCLtRc#NXq;F?dZ3cXPcY1usVqt~Uv&n}n?HD8yPOFdy?h z?2%E9AW=#wJm|SvY~rDa%Mzy$ltc=eVj{Xeh$6dVVjCA&|#bM5+L?R%gwkzF@ft#Sa`+IKiaz z_enf!kGK|vW7nAX+J=q-047yHw936!@ye>`L3LY4zuuqVUgf;icQKH|>PAj=;lNax z=jvYhenbJ5nM{Aq=>SF6khcogR=L*UY<&)pRG9Bb!>NX51rziiI|aa8mjRP9$0(y) zW%Q=JlEFc>1zby6peD~A@>fFk!+XBl9;kq6VcNs+j`uSOkf(c2zE=czi-1oNeT%R< zx=_Lv7k}$C0s33yI7Q^4$h8(YSApv*AfJUL84W0Mtm0LP1*+{*eVJ+q!b_H?D<^L_ z2}b!Ar#;4qd4;uQ5ok<{?6`zQKQU z-}n0r^0Q(5wM~H5H?VJLVzi~-|A0xtp}vRJO)U2DT+W95^*z-EC<=S5fnW14uU>Tu z6N!@n?s`wTe$9iT0VnyhaSwg2bO5%jgsuh=dkO+@Ba1K(Af1Pj%oq4`BYh}vKMK{4 z5g0)52Uwhbl%x;C(GMf(XL1G+$|3$9LV0gzt%d zkzbW-yT%cK-`WUn=e+2-Hjv*o&@b@+{HA)f--lRM@la}fw^mH!8y^3DHrf}?WVj!o zsh{oeEx)NFr*({5{bwcs4i`7L-Y7al<|4$bkhDVS+;^jCuUf@51t(uc&!GJyc-U1VYlkK5zVNYHus-1lP zjZH4LF)*%dki`f$F?LOeR`V-9#x4f)9g;va*Y$Uqn&}o2-5FY@g>8UpFAp zJk0l@_rC3GQ~E-Ae{?-k3<~S3Q1EBIzO77HbiL?N^N7@~Cbpw_fCEUkwoiz%1%HHa0oXu|)P+lPFq5 z|Le%HiWlSi>zD{&qf`r0U+O5q6%PH6J38=;$wbq#wpo&ZI_Ih571tmaHEcu;xvz1( zHPs40ern7|Rq~FVta9AyaZYLN?z$J*8Rn{r-c(ty>ak80C>_Q;R{^j{o5}mX)9C<# zy=)z2$6Rea3K(A38h~16?!Y57UrQ=*r8M|JFjF(x{^7f7nutsI& zwDIQ4BKxwdiUwR{@A6m!oKl3!M}N)Wb5y1UiuYxjKsGZ949_{SG~3aC|C-x_jMQ_&a7R$t2=zrY@0kIL^|?D^kok4+Wos`7u@uTLfrH27`g zl~stQT)L|LnZF2YE9AXGdZH1&eviH1P3=*?*1+{#0%3%;1%`i2Z#=%givf%4YNC)$ zSb7scX#xUG7=%@`Dj9FS{S(&>)rgFNx&VxMiB|@MDu$8PLT>l z3~ux1NBX=XAa6-vjzUK1(U*M9(kl#Z5TDQb6?q8aqVK=Xgh6A~1patW^Y=j?TOxO%QhXQ0<2* z|9@(^x!FWP(Uo_bC~W4mfuaZ}I{E~F*O7tRKi!$ade@Mp+E+|gMFh6Wlt2}`S;a0^ zA9ig(!9*7@uU_Ct*Ts&6Va%(5U3KqF5rmhou7C-@%9$B62@v?J#zw`qC)m>!ad^KY z0jkSUXOz+ouQL$dm7a4M9gBLNYpm~km;k8LM^*gWq+=G|GUqAP4MrjZKk}>Io3f{= zt}xXG{BkC};`2-p)^v)uX9r}y!};f>Qx$be?@!wwuS!t@+(p$6V5f_hq`iu8Imalg z7C~g@T-zpLh^pytFhDD+u~UL!8Tp*;f{4($oSYpD)bBIEzsJY^feD7{0nj}a6qXJ# zxUX#>f49>csu9@I$6L?G+uZN(W55?-P@$me0(Lbikca;cUxNt2-u~<$pO<@zC;=F( zTDAz|kNDmc;+Mxi;L$KC_@0S?uKgx|r|i$r_tNdYw|hkZSoj-QxEm3cc?j!#4C4a+ zU%<&1e3*goE#RgXaAONN$--(D3J!3y0|@Z|-yP(_hPlZR1ak~yH_i#iQKGSrWc%JY zLOzc2jDIkT{l*aDi7&fYaI*~gXkpdP5UpeTn!%}+1Enosm?l*Of>KZJn>7KGcnp(F z@;F9r41ph4B!TOlRM8;EC}4zDSW*6FhRvcqM`2{VoGJ@neTe_@Kxzuk75B!N?&KXSx(rq{0)wK}rUc&ojC$-uD=B`f!=w!ZreXsa27X1&?1 z4P4v$GkMe78-SH}m#4n23Bgtd>w*CtxoiI3APZS-%FBJ$a`tDxuQox2&ynLM^V8&7 z!rMN_ppVgQ-erJBAES^^Abh;PBhbf~H}M9WJ^x-qsV$L@0srndmUU#Kg)X$vtrqjw z;$B+lR!bm^m)r!PB0`{Ro6hTQy~)=v;&Qo3g1}y(eHA&LV6w2#pMBleju+DWhDn5? z6N(5ZGJt`PRL4f1%RN0*m#~k?#G$^AM?F-(Afm2_i9C4KbDU=au%jb793u(_Rn)1r z!r1~v?l)=`)IGsHN7~_vbO2&(?NGnc8!8N4AwfR~g3?5vNtubx5p|Mq-l#DFEbHh& z?MZi|eAjgWgRTuY)*S*$3vjQsHM0h(dW+?rd8vLcqm9*Toc2;w3_DY0eWO+I41@e^ z2LUn?-2&Wybk|_`D;WL?wl`93=b8xYmErEnw${&8lE|0QuPA~O5n!#$96LG%(4R7M z67@cSQ`G;+yN0lpkc%jm`@IJwGQ!F~^kAK$rR~iILWQ+eNUU(U(x~bjP`jS$0Isz| zB5+rSfVz^lw$s9O7e8(AKhS?)WD+1pMfr2|M;%^q?Xpw<;qxnZzp7K2Z!vg(+vG&y zaHT|5+pwZRSROxQF1+byZTocnvu%-!lSD+pp5DjKMO5I;ew8P`#>^`PezSS~0}Sf3 zZG$`c@7Y>`^-L1>HaXbXb0xCG8b%BDS&5GU?nMvXy{Oo6oe9bNY-Skij zK!i;ZfO%ZZjR5M6T=ofytXd7{*b)aSZGPH(QWrepoI*S-CNUs;Zo?`g$?w zwSx^D3Ii**%fd(D7K+pa7}_X$8-;EI5N#M=ONQxf2`07grBW*Nt*T6U(*d&oU%+|H z_k$5HJZ_*ypo(~qMT~24%S?Y1*ECqGFmGFX@Edp@G>boMn`*d{Gjg@cP%V$G@HpiU@#m zjI*srYdHe&F&is^KZZa0nK5$F|KGNu5}>cx%Xo{1hyEImqY3b>!0EG4)*I|2Eq9TZ470LYi#Xhpxq)twuNzOVOU!jq!x48 zVvbwPZ|hw-nvmHh^Auh;_uj(eX`xpwj7E$5X#UDTFF;nP`~?$=pZj;{bMuD=bM&~0 zE;W&z7P{VIeOs(`3ms}fGFljj76zpy*+++(GkHv1QxFuL=dV8Z7A6IXG?WbJeI^(J z`31gjk&U|KOF?!6p*Nn=~jb zc(@4$Kod108@k5eeiH$upj0%tr6U0%5i7brpk@+qw1-+)v2(RGoEpHcRv$F!y~UpY z=}v#Ccu*cZM4%!k33*oCOyw_r|6vmVWUazlM`uCJLpBxr9L2Zl$T`^Le6!T$Aoc%c zGVp{6LDgviMFqHyvI^z4%!pu#YgMsb33)3)qDwFOeWe0lm;Xo4y1;Bp6M;QEv}XYG zr5wA6KtutwF97F@eFSD(1Qq>NJD>KHVP2x;TJ=e)2RO}SL8;5f5**9uL3APsP?c&p z*gz^^SNL9@w~FuNy}#2y{Fc0)=*t%XUy%SAQ39nuK4IrafUXWOMSc~TR=9r^A4idZ z_vSrC$0BZv-PW zdUC#wU<5`nDq}GCaV~rkz%2+&#a>iI^79nBC~VQ9oo8?o2r7@Gg0u}Yw4{O&?H4d{ zru+ZZF7k9vxWYVYIaA&^+QgU?ZS)E73vIQiotIEYi4c-gV=$vbny7v z3iIBOMj*NYwE4zad2F#V31VUC|4ZP1(##ga7I`lgt;jVOVVuRs%}BYQ67v+{H7&Lj zP=zh5l{Pk#qD8^S#mR0%Y37(rsCpKqC;&FmR&!Glj3NRX75|^K@?7onOZlG2FkR&S zAG1(PI5Fg9?!650iPoVf9Nu5Yp~OvXL^gH!e*?e2;j2;r3PWCFkDv9caE%oROSCx& z$Y+b5wl@LzxpdF?~~ABC<#G-~p+0IC|otxa3%kf%CErhc8%Iq!6M zUj*(&1HPg;YV+fJQRT0Kx4jGq@&LbOAdttaaJam9dG#o5wCE|feu{zpGxkbVX@9QA z8Gb$QRiJfm0%eQ)X(59xfTwk;K@{C;L4I3%C)o@yoOx?;udS_37LM^}fKZDyYjJ(8 z2fSgG!1+vv?*-`GV~h1@F=wq64B*ctc(;&|7IWR=9$Elc>l==AAqy?!v8CwOPZ&@7 zZyonw6BH2uMJp6lK;~NLZ0n0jTAIrD|CoWSH8Iq!*XDPEfc(_NL7fmvr~E6U2bzlj zaFK!`lLw_LR2X@&J^Oo29;Wi#B0E8vFw89#Q@&)fAwssZ*9tv}Isy?m6(*`pvf!wW z{vI~KYiN&wTCR0;b1XIa<36J9qu_{;UI#53>ON4{!RP(=E*Tw&+JH$%0z?3IcWO#e zDRrl)698b3O@q!f5%{_b1(AUoYgd(RdXu}7xR2_D(_PXB41LtdtYlr;&}lOj&jMgk zOsn=mwKuCJ@UJEX%yEUeh^`w&-c*FE;%5~$s|8MbqO5IwUD4^+KRcAp@1j278b<>l zVo_ALha&>3JN*8i1#@n&@jmV$E$#TEfau`%)GKe(vAjl5ui_a>}$XmQP|$+ z-ql3mRAZn>fg%8!f2A*;FnBAk4>1i-|5jhGz+UMP<@RqkW)%INNPt59YT?uzDRQm! z47#KZprQ+4AtznHWY0%=<{?ZsqCE4iOt4?Dnp*__z*xw4FedW>k@-yY0w!R=*YdMI z6k-5lJA@Dnp+rO6%n$}(2v8Y92!{E8`0*Sg+WZG&FbX>vQ(eHexua7-LUBWSqfxcr zvp}zC!IMXSidkMKnPyS#Z2-(93p)Yhon+G0GNP6VwYjJuraGL87aM&j7rfjBKq}fo zxLUBIHuu)XfOS~VE<)J_TslYcnfkZ&-Ayw0ugHY*VOqEdTd4@}C;ywkuQbQ&66hnR zrs`XTh}0YVt5l?@QkAk{jFbkcoSq)F6f%nE{$|DgO_CcaacuITT+wSB-WQ?bI|b%n zyZ*&K1-izU905@N|44_?FhE7Xy@;__VNDe4C|~zMlMv=5+G%cac<`Q?%=drXVMG-d z?QG+r(EkSw{vR~>%iB24;D4J#l^RbP{8z9cLm8`h#8LgPFz8Rx00zj5v~jI9)o~!J zHI%Ey{MB}J2vz@Mh-=71O~qL%+&si7fIr)F+s}Zn-0p0y|7?4Crx_gj4GuE)Pucrd zK^=e^g?0)-D+-|EwF_sm5be_@0ms@)RhavHd$jZHtqK4Em=@%ug$%VIk*&{}0Gw%X zM@L%M8-y?OXZsuc(XG}312b#WW?tGDk~Z_(WhW;em(S-m}R5UKq4&P5A&;m$X zfQiy_E#|s)qN4!%{^z|OT7v_;W+Hp43s9%PU5*Y&=h27gG*EqqS`gKJ@LZC;=!_5v zc-((K?9cD@Z`28*?hd63)aH4mWef6Ezr*PzwGSc#FYhkM^+a*1B9J1rkdRuxhav)H z7YhPhHNYq~x7sL4ZuQTp3lR;#o<*VT25F0`%xQEHh>&Yv00^dbDvfB`_9oV=WpqIM zm;?!!-GhTQk96EYjt1;zJ>A4nJw^Cb+kfIBp?l-Y8tde0A%mvl`BuqJ*q`8KveIklAk$OHGdQ$t0;NGw&|t>{{YraO(LGP zy{aWiP(fnU0930qVnm4RE5tgL1Ec zL73MNfHw%!7~&#^PcQ+1eT{s|8~4Db#!t+B0VbJvwRwoysgF}zVOF^|Rp>_#I1?Pz z;;W=0L>OM4FUN^pqY%DHdE*G6TH7>9<&g}5X%{Z#;iBd1>o)H4?f}^~0@%R_cVSvx z?zf8oc3?&dYuH-%*1Wko&I z-;0t|wKu^(93n(;Vk^R>T;h1_C0Ukq)u(P$5bpPLA% z4N%23kf`G6CIARj6#ca_x)Qm6NL(;=RrL11iU6>7Dt;`#Xs>~Fd^xX(j6@nhk$|mD z40f||VQnJZuQny+DHYySPcw$D%J-{~m*|UDUB;K414TKtdzz}IRk#_&ek!C=+aC&7 zjQQA5UJ+f~-PCIifU*Ewgj{h>hG;3eAogaF`uIoGZ{`L7ZTmCuimzC2gtxP{C{sQpHR^tTMy z)tOhq?-;+XM3S) z8Qk4~Ia>s`t^r!Ww}~SIQ;tL`?2p}1T~g%L79e+HM_ap!}IZa)-o+ z$caCno^%kDwTGdfUipgU~7ZB-dBB_q7p~=`j4J@WtTtAgQ5ZZngl2Upvb^b;$U3gmg(>YN%?~T zUSO|6Ohp2I?+Ol)RBUnzi!!T;w5|GVS=Idl7AG<~qh1$<#XC!L4kn9l_) z06_Z?;C_U30H)usygv%rhY?x$j8gzy+ycDG1sH^dENVZ-aA3XMFJKVC96}g|nW*8r za<{$_48thj9la!5_r@?be7M(c`X-Zy*s0yJeZSs11{x`cuKxqK6?qiZ5 z71hQ#nyHsiIC=hJwjZ|;i_HSqYWaztT6q9!qmlQH5>>Wzl;RMB{Z4*w8+-q10pwiK zigbdB05YXL{bQ#;3|$mBeJ$%MqP4H+-2cCG?ZYFI8~~D0O)am9xvK5!$iTk#{#D)2 z{KZzTYRwwY`Kl}As}{9Bdwkz@=vJXz05{t7p0`o|MS_2T{%mWV`tDU>FE3YxXsTvc zh<~;!UhQ+2JAAD+KIXg0d7AfR$U8#T@^}^M2M}5p8IXT!j~=7idNjd3#%=bliWvTbCojp1&|D_5ioqu5%K zo_>%B{brG)U-~U`*Jf_o7_Ih}Neo&5V2inoNQF`p>m}eubV4Zv;h?UqmNFXjEsw^+g2a8WWNaJ6*v2y<7{iw@HE`CM$a$F_bOVv-On6kNv+0 z5@b~og_lzTO4FziQ3Zvo7|@?jP=9$tqP6_L)>=h~TlsILG}dzj;U5Ni?NgvSi`V9F zgCwX`QF|3Icd7-5wn25I-0u1l{f(Z+J_CwCUS(a?J^`#p>^}NS*9Iu!r5YpTDRvYD zG@?#PQ7&~1@SQ5_rM>E-6;|m;=D2#DZO4VK6F|PAeNg(flfC~y7$=8w`{u*<(J~;ECRs(Q|Dx z9EE|)4S)h}rEt&i5Gjy%&iA9A{tcOe49{Mv(%+@Mjo<8KvY=?^Nd`|vDZ!5Lz7@5c zEu`DVWMeWz_Hj+K^$aR7U(=3_fczYj8r3-|?61@Y@)Y|8obLCIPRA|U(+~FNJNR!A zg4L2_L|f!1eC|DcooD*GPxbxp=b`IA%Gazkz`--GY`3m?(OxU>GNDpLLN#(5Bq>m& zq6{I56wDlhy2b+r`8!PjZZlaBNx0qQ2w94#^HkvDoVf!WuScK8w77 z8|uSL892wSejH@*jNB7o0Oje2$@bw*F66)qU?2-HL8$uCA@T5jC z%A@PKUmv9#dn&{KWB8Q-*10m~CuRjk!w0y`*f2PWQS0($^$k8A9T3}Dz>zs``aLVNPG zD|jJgwOJ_VvWW=?pBEOn_)Z0VL;pA6*Z*R$@}$>JVNnje`a2h^Ep*6`^VI;Kc$kR7 zhcHd$Dw}{n6l|@Mo~o*=BgZ>r5K-RwikuhiORiA39v-4RT~5sU)D)iM&GmPi#x zMp2DIK&v?K4|o<;ETUqVbIl;dGJlc65)b(i8)Xj5zsrn3vkq$AHBC41>;bil`wMdXP$VZ2%Ir0f+Zdh#KHp8?~XtSk;iH znl^pmT(QmTpKOS^uW0pC7+00w^)%pNwC}UmuTZes-;^g;d!M>MR!(3Dz(3jE{^<_u zU*vIF&U<*8%2T&q<+=XTLm_1qswo$b{9;l)Y7TSprBKW+k|sKala@=z^-i2Ut7 zrn(MPV=(G9(%Pw*a0e3s0sBt&_7CtHZ}ci+r}~a#O#C*q9IQO^$}W$y?VxHGe8G_- zk#cPmh2ChdfoKc-r@IIKm4&DA3W12Nr$zel;43y;gRHxD z8H_E4MFiARINwn^^eZ;V+0S~tYue+83aH!X?Ir`*j_3@UFd5Kmzasoyz4u<|w8>_oejS%ji-RH_xUIE-(=|-q(M;Ny2_60H^qSiUzAL;7g7YoR~Ni z;dZs$DYY=->ps)~uc-7PCMcgU0n+`bAaFOof2wWp?+pBkRIKL+fFc3ROYGAi^0KY3 zO+}n?+!O^-Q~JqfN2A_3eM#5E4|HI;#|ta~Rs{sI@NCvJDE}oEsi$=*FQ*ouxMz51r{TBDT;xu^l|QSE=LjVE$agSbY& z|009^=8lp8D$xRVgv0$9iP)v@K6`aD4)f2owxwbZ5aU1f~2AtZEtu}Mi#%Q*= zpEiWC&AoI0_YU{j;r|YXw1YA0VCdQcbPRc$HES!Z|4S2>1s)6S^(&en(joGos2PT? zy))xuj#8}WdlCsy(V!x3B1Ql3-zpZIZxXPJqXU;aGN5xPMN;Xn#&FBisYze^8%AN5xTFM$Z@_%=P*w%Z+5h|BM6EJyw0A# ziXh)_0^tppB0ZpJoC*ciX2`wAJ_8$?c&gBtYl>Dur2}?!G;<}_1YlFtB@hoDlC68x z5dt{{M_3OINxg_V0O<*`9^C@ijMyMZq@d*}fjSAWx9X6Ih?*jUkf_*9=mSXvqKFU~ zRP8{d8L?hzzy$ti6M+w=0}%TM$lmcomDTCsb27g5g&hy{L`FqEjOtcKT0yShZa`_J? z5C(W7t7Yti>I0&>f1R0#GKcqmy1`xJ4BI>r1N0@*0!l4hXs}0D%9oia9Od8W_gDG- z!%Q}m9#9Q}s`Ni&@W05Qf1n5Q8c_g6T95EOU7Q3WQW3}a`c!kUvyZ)(ZMV*Sg5MV@ zSk**JB&Gy zMsk3gA3_+1VKpNN{K)AU+8<=%2T;&H7~VoId?7}l4+ZGw#s^T;Aq>|rCmrErqe=l_ zFh^kaBe1Mdn9CS9I?lpRVkio$yHHL7Arf#Q^Vpx92g4q z(klE_K~duInerr=kSao0eKNys(en3?^nf~mV;4c0!jMj*&{JI36w2CFE|v4Oj!(}| zy}}|O5nkKQBtuLKWr>X`xNcR~3+$uf{z13iDeQl7E`WB-Q_+pWblMwS4;axyOq%kD zerN-Bo;^*qh^?ERV4Hd9a4j7SdgrVJ{w_k<#lUqjFl~8O>N{ugwV%Ce24btwwNr3n zD`iCjN?Giuo>k?&qE+v~4Bd;lMt|vRER?@A!xYPfIK<;aF-YZS?D=C5qjGo)hx-q- zVL06B0C^0bu;I{#KPohWC`J1bWF+$b-^vt70REFUZfa$MKq}W6Pf$C?c~QO-yZp&u zzMJtHdrJ>y7&UhPV~%5k7FGAF&~IDk`4#RTaE?|Xc~yt2>RcePg+YH8lQ8wJi%cn( zuOdGc_nm2w5I`urUp25O*Q_G7r|sp-a|aNjl3(2<%7H6K&K$P5h6w9Fo*usP>H&-j z;oso!{mJ&!w{t{5Yx^M+0p;iS^!HiM_IVD|WBl6?&o%(qfh=^^&DS>Mv@P%Z7mg4h zukBm>-JhgPwUNa(gsQ{(bvS>AHSZw19p7Z?V%`_Y9Eln z=yp(DjtU+>>UlyQ+FO_mtYlp}F3EfBQE-n5+ofqQVoe(+Z~b1=rG8KULolLU^IF@O z&zcY_HL!{0MQxy;^#AX3T0zcMA+PLv4c0dF&B@T*qUHAs2P0`eO5{ zEiL1c?-w2IQk{=#UyjYFVHHxZN0LV^fC#{EtV7IA?2*B`SJBmIkyR^U-9%fzKh+Td zMc)oE30DE(x*n=EkZpjN#b!cso(8SEBK6pv*u3iiNB&gki|vgE5Gl7llc|DmlAcMM z7q&y;^(_*dB9$oc!bU|XTb@1+TM2oJ9QFhDniU~9-r#tkJ^R_-b``-XVsN;+VB`j16MYzfJ^-i> zCfSbx>jx0~QSyEiY5=1EU_hV0IEZl>#w!}Zc#N>P!+`$~MsDz&ObPUH@e7p_P{AOJ zF@T^9qOe112V@e4r(6igO%0>uBPie~267A~pV%;W1}yBFfT|)pF+&NM+F%62(NC)i zZG~IailoYIwfewd)#ev1Vyc{lVb-=yZ!va)Q!x%?L|eKlOxs48x*T(g^GqX9i%`;O z1b7;N?D5+U3#{TOwFN3q9DU^|OjPeG3^tGx8ijLTa!wtgDz2Mhb`{@gt6hbzR6M8W z2-FZFZB!E=rAqN{r)Lu$9G|xv4xJ)kZRV)MIlC-sk8A94tS$=OQ^W!Vn}S((nS;)T z877sNqFMkI52^S^)%mf1_xDn;R4p4DU7VBxtoFOuVUPP!TTlq?US`I-T9~y7h&ljn zpLu1=UlD+H990p~P_F-@27ClG3Wr1l4tkZ*I5*ExQAY+!9*^`r-QJ6g)#C~NQRt|= z|7)DvhvjR7rr4hO&Gwvj_v^M<>?iN3uFxy<5<9x_yV!$X{n_g8222`7hiQLfFOK<) z4SjaBmnY(-JpN=xhME%wfB}1pD)3XmA0(;?NW~6xl0D=u^42P}oh(n$_s~Y_AK0BLa z>uLuh&|$4&AB#UY%nzt{knaxb*HMQHveiNFJLp6Q^4@`XbwoHJ{T)RlL_i;PG(pj( z-3`7<3n*HlR0QW~f7sxTF^uQ~^W0WCL(vK5EYb;gB;knv@APLFpZ1l$$2VrmAnFA~ z2%fg5|4_akX@zHeZq3)#oLuxotKp=clEciPx0iUa!`1=uocgTk(Dk#?wtzQy*!^5Ox~>hm+N z?2#d2aF2&k4wQSx)l3id``Tqw^2=u?Az9kU=6kz}X>1QJP z5rTduxF4f1z(o#luzr+efSVq~NDQ9=aN|XfG8rQ%%P@v(hzTA*0QAU8Ky;rmR+Fy|TOxFeiv6oDN>a3{`oD&Xj>R9EhzEEam5!&a)~ zzaewy+8iXpf}1)7w}!*ODwtC%m%P0@QbA*PHW?K>=r)4g!K3SOJyWphX+UQY_cV<` zm_`VuP}JTHt^>Fy2}6W|rK|#+_a=y`xFsHQsUB1aM(j?tjme7&?J%CoovZp?q(nJ- z?NSySs2rUhUWd^|X}W+;hdF37SK5H6!}+=x_$lsr3c;S@JX0+E6ks;Zv8Pe29>$?7 zPf}rO^(zCIde*%>gs6)E{Gw>&!)Ck^2oziFTpR7gbIX5fPh7z6{$T-ogz|o6hO1&9 z)d4&_lUs)ZA{7~mH5~;I0ocna02HipqEiB=*jSwEh|FUSH)2R*w?D40`l!7a?mMde z-)19sq`iN6_N-SOLl^t4tFW)^f-1FhVkn}kV?%rWr&$*IU6_TOM8&rX!ypW?VUIjI z<%K_GuTY+zTJ=N_R1l_W@;m$4`Rky=9gfxEJ~{wPhxP9=zg>(?_poe#?JP?I9AskU zJVzUY(dHOYcQ9nHTTzKaQ~u(fo;DF#*Q8{Q2?6A@!`gPFcXJtU@Mnrp)J!gpwO6mX zQjw!N85I3MZ`u&Mh??m08%-vr{CmKn-C>9{pO&N~qG>8Hl!vZ$S9(Tu42m}F>~w=( z_i&WvtzO4xEd#Ur7A$v!;9|?mr%e`R3r?~eNuJQf*hApf)bH3ma@0gX1OQ!EF>h=> zCAq!MwEzNo74cr_)PRP%R?apNSS4k@h78rNbxnZUV6}I^`A&}kI?*A+v0_)j|M2Ta ztw*ans`h=S4bbN(9vsSOY19;`MgY)O0kJv-s_U5$Xs})t)laD%8+nhdhA(ndPvc+{ zf50i)ebqgHor--yR&$zwIV^LYD56sV-Ps0Efu*91$J;(_=Fs&cY4;$F z%pKx{0~pMH7{LHSJqV}{%Cl!;2k~eIV1Wa_O#mN;L64v;qa0*}$sWEid;bTR^nQ$Q z-w(1~uc%nlNg->ima_5V=v?> zFW4^=NVI3Rc6XEEj>0H;TnC%AD^#nttkbOAGO7r66gjHjL0N6ANy9j}t z=31s%>?wq9iizy8upJqg@27XB>S^^Ui`lDyN4c|j7|=)D4bYc`ezA2W_o4?|XoCw0 zj*9-Ih${3`2)cEljU-Cd1+;qz%@j)4gV1y_99;}Z?_*hyFpa@kgitQxH`5TIX^h(< zgln4XnnIYm%tL3r43S1kgwJaHJ~k`*qCIg8Or_;;-h0y<7vM%;@^>6+R5kJ?GqDeO zgzD9LqP!kPFxnF}R6z3&hy7GU^m;4#o(>Blgi#3iS$qB`*!$m?{%gqlXdL8x|91BL4|E<@>!d#I+p|dPWshII z`W<_M%Hacqkqd^PMW`5~5X#1OIA&F&ZJO|}5gD2}_v z;cSSMa{Ve&Yj19V`-VZjWI)y46ZhKFW`5gTS40FPt5?`_o(o`hO6#QxQ*FchQeR_V1+^Q_wq9QCsLYif z=QvWMNS`)mS|KAk@f-vdaYC@8EfJy`X#~lE?0`}P>H<03Q2}%%o&y0e#bcJ2IVJE7 z%j7|pS2+RCWg0R%1ioWuh2zFUhHmuuj>&=22FyWyQx^rQLjXOlHT<`_Vz{>0W*8e5 z8w(wl^#ZZI`4Jg))TUWMvXSNJB2W|#f?wrYqu^Fu1=s>TV?eFMk)p#PsD3#Aj);JY ztpVQ(`WO2LsEtqsgMe0a_I%ES0QryNUqvBzPX|G*&1K{|a_e6-=wmOV>i#@?${J@T zfUD{~h`9$f3M_5_+XL@Jcxnj?3qye2~20SvmFx6A!?0i~`y zd=UVyX%XJWA_QWZ$?KuOJ?^=u;=ny@wBDHBhqh!@^|90;$J*s*6BX>3Zy`q6+Fh=%SE4lwgYAPNNXh%;D6fNkXRa7^ZoD5rk(k zjD0b{yBJVijKVL5!7gH6ryl3`+;dmP`DWKFpm24JTXJym(uUz@SqF> z>^3$X5%JLGBnWf#`g5=Ga32&r_Bw!+)L^%<`H50EfNAvltK|^-P*1nsZ8dBBvsy5UL-76aOyhHbYwZVUbqcX~KL%gExY;C{) zygfqwcA+BxTz{kpI_Wh=%bLihirLg^_tZ>Qzt6STdX52;-$n@kCrL!*87p7kQIX&C z23JJ`SmQQ^KC1c^6=Lq9SZ_Uh@PJ0=+XnYL4EE|~flPK-`wn{6;rLx-w>vi@OP!}3 zX+j>m$Z+>a?{|Sdb-BMDveMJ{ncJ@FOmsfUX`OMcNd)WCQQlu^g?|~0@6W$G=zOO? zNo`!i`5r1(z24WV)B-@!!O(XOH4#AeI`Z^i@Ugz_NW;aBEQlEVn1Q~>J_kSW`8IK6 zu>~~uKrE^?k zv=u5z@{DxGmcvRJsPI>* zz;~qGi1s@TY+jjrEF)JD8BhrQO9ubX*@ON_dcXp&0DRUVs@zvIunOQ5lII#D*N+TD zs9avVyzgTSn6uFZMIPk2t7`vzlZ_qn*m0bL4E~4ub$fp%U{z#5p1i{SYIVHW@15-L zALHXG!l87j_6bn;!{`0IBMrvyw->(LV5~X^6+D8GQS|p^M*}YLXV{}4HT*7!&GxS% zEc+&|#GHv_tY>1NdqR$*Fi`ijo56oJ|F86lIsoo8_$&PX28aIQ-TaihM<_>8%25Dz1O*<(&X)MdR6Z0lw~ga!0@JQEBXYoWIA-PhkWWp#+N%=0z~XDZbyEn}$*w z0<~4JHJUla*r9CIj5;XfrYCi&`c+%x##62^`thvmOI>ZR2|m%`cIDo#&H90c+sKp; z?u?|-of^*CgT;W&A{J^9Mr#oSV-e?Cj36!HdY1sgOPQ0U%;yq}`4WV7F@QM@A)3OF z^c4PmBEzQIid9?L%BzSJ$VU_4wH>YiG>im{Sr0ymN5EoaRVgo{q9>ARhcE$qfctt$ z0wQYg29LK|p_LMNI>|tMXETHUc1{NX$k9v8J?LqFk-pg{=PtaCdmWm5!CwD9CMw4n z{Li-`6Iqe5oZ|vOm~tJ%8jomwBtxqW);IQQm$!Aj!?4_o`ud|_bhixSN1k5bu%pM8 z_Wl$S=K7<}?DVXuh;Xs$E8b;q@Ii-!mpEGRoIl6Qd3jHNfwqeLRJ^yfz1Pn;Y%P%D zdLyUKJx5L+4?{H^k&oy9DBOF%UcbJhJpP*g9>?l1ryY!S=P7&W08L|yrftg} z0;@t`)wbxnl5Z8dqJPoKdV%YXF#hTksB`|<;#yq;e@>loVDU5bO*%$p*A?#o0|7CgitgX_#0nis2zy!Vuzwc_`Q$Ac_ zZ+X~X_K;_-qC)lat4d#XSx(nw{#(cUmO)uS>b!Vp=9TLI$4mt7b9Cj7jGll~ zb0U{NgmMn@#?bN3&9jgr2-Pq^JUrl5zRMl{hcJvGM574Yh*|>yw48_l9J%Dz83TDVc zDpy|JKSO!iic}t^JeV#5+XEb@5#U7-sl^p=f8=8UZE*5^50phWdvTEk%9QmHjW0U1yF@UBlZw}?eOAR z4nwN;K$ZV$ed4~<84+QBMJg1*;J2~A|CJ7VK4Bxsd+}U$yp3q{+sxrr5v;=`|21dRIXIT@Mk2>+HpAU@&6mJk~Ncz5yg-2fVl2+edM=(_ZxP zGt`zAp1*R|XWNTaIQl|+r>t*>xr^Mm0AKlfb#-89JO7!X@%FznysehL4zkNVEsjV1<)5NLmcZ}|08rv^^&`X6m_sK}7^Qc#LW1%&rH6{LvJ zRZcxB3a9!2>6r-XQI1TVW7)hR$#-l=y{*Z)_7nib;#mTai`c%J^T(rw*Z0^ooe0$* z)!%9&pvVAvs68;^^$wE(Y^Z8yLWfi@pn4i@DD)|(1&(uMka?)7OX@GyMd>8>5QTwi z&y}s6=aik&1dy0`TBlkGU!UoK>U;d&9vSIWZB(QQWEak`{dk|#g~)Xj26ErA&9Lf@ zW;Yj7-dpK`3+>@<{wi-)5dwMO3bU)Vu+JdB-^?o;`N#`bgy9?hzPxc&{VUplGg`jc zATC0n$iNu}N`>{cQ4lsfQWBTXywc`3>T#ow{XKtnm5U-lp?^S;9*jJH@ zJq@^Zga3_=0toQ0a}?kkP7^4~s&t5I0k$_8QMms=AMbM}F&{DbAMNj)@6YA^|G}XD z1E*Ae?D2>RfKt4x#yrf49Q-hgJ_P6v*R#TZ6oDG$qDJn{V!sh?ZWKWs!vK!6u;T#J z7!x&$FbzW%hPj|&7JCQ-GlU@-1Y`#Ao(56uLDdN$07IO32qhdsPzG4cLA}>aVll?e zj&qaaOu{$|J^@plRC^u3U*HCcPbK?OVTyLis$ZX;o*s#+eZeDV`fqzFG8`&4IwB2( zTIYJo^CPf}1iE~8F-CmxDd~at(X32>`094nm|hva9lc8A5HW z5*r37hyIwulzgv&@WqqQHp{AGRSCy~dRXhI>_^$7?Qc^@0#?nie|Z1@l>{KRFPSQr*Hunf_5R zRn!8=z#gB`l`ycX_{XS6k2XdmTDDZU^^m=OfxlYw6p2xb8H6t?^|g`AZT1os#%Eq4 zUwlHYS!_&mszb`EVt-qDs-1V*i+!g7T)F6__GEwLq4v79>@{OVJI5OIzL_!?VR8Ze zwFdrA_;ZXzgy0t$=zpEB0rCQ7^rHJ3d;Du>$4Hks>F(g%zCa(6(ZwKi0idpGOqMZ_ z%`S$hrw$WjqjzZ5q4Y!~f8jL1Pck*oZTc8{WrVFWV{gA@0LKt^e&vY4ohBGNIr4^) z@2-~QyQ^bsu0(!UPC}r~x8j~um$1|%N2CaVigZSwhvw%LgT9EvJ&qFxVpAbSE2kX^09<0jEMzl^3D0n}4LPep zl;R;<8)Pj`)Cr&~Q8dV0$HqcqX%}MGK}7{V=bC{NOz1@z&Phin>IU9yg1}rvVemh-dA^*L|-w{~LYiGT+t+_g!;&awLx}QWe6g3z#kYD3-e9dFh-yJsS%lohU zx2grW*2mCLht-#Ty<2B^|K(Q3J{RK6Hvzy_#>Q)Fnb>S^pjWlO(i|W2adbUOmmKQ3 zQi0+LeqUr@6MOw!V{D0hzsUgl9mSL)1URtq?3oKi05FClEY1jC)d-6`io%WY-WZBC z$_0&bfKdc}3HT(Q=adtl}VnHJT2w^7h&+1;GHi; z@s_X4Ksc8(@5>SVg2v&aYH(A6J)&A;cz~EFicWr=b z0@Uw|Kq;J8!7I|vU{MdCV!-`8r08dx0IcFP0D>O7n%(ONz~=T)6a~1%QGm-c-BLT< zInH9HE=2kwM+)(3a87N791mlG7zePJeT(=q;D$_h@>B z(LVNs$$+9iu;kdZ2L+A|m^iOCq=}F+z^bCR@Kom~uyqCQDooqid3)9=LgdU_y13U)@;yZV8~#1uK^bCw!5a&Tx&X{|Iv(Eb@5KSkcuuc*TtxJ znUgL?p^Mz9yCe$y@Cdscvx`i2RqL{X!Czj#(q9m$9>3`UC_PAU4^q(ssJqB`mpSNu z#XydXX#a`M^Ny^EfB;}BAnd)%!~w(BMLxSKwncusXU=5J!7ffmh@@cPx?7tdtd{rJ z!AN)TRyvxyhy6Z!*7=di#*@CkH8SE6_pUAnr76@BduEb9#jW`x(09p;whUezN$_DJ&(4b$AGKI0c#({$`6_(-08msr2jBsSnlJoKCwxWx&#!#e9{EqA3n#e z{?2lP`PY2>f`OfRE4Tgor8BR1{DUSb-!b^l=HV695V4U{sCs}8xd880d*cr~9Z+&) z;0}lWmG)2yM0F1$NUBLdZ=!8dg?_3rIMKvH$5!}X5dcLuuo1Bbzyl8V|Io#Mzcuiy zt7|=9kFNipA^eM-S4>9j9Vy^y1yj#$6y;pv*S{sZ*N%RjTXUP=DVWwGCT%fB zVKK~pF$7^6#h#L}Q4W1Pi@~Iz^|Mk@s((#SUI3@!j$mwRr_(|L#IdU$^HlZ1u9J16P@%~Sl}lhH>xBlWRudRz*tsslm>OAoMVpg7u6IlKb3 z*daL4cBi7d#c4F^2x~mUT#Ajt#Iwa`d;JCeYh~yz>I7b};_7~%bC~aKjufoz$bq5( zDlP;-EBD(wfJnvmzsu9OMAg4?lxlN=c*TQIF0^5i=knbo0I_Kb*QMS5q7V@B&^XiJ z&-})AtN?24%%*%To>4pu<}w@WP5B#hRKi`Xo>j(^(-*_6{^ZxwFBy5q_S8?g( z3GNYY7Jxr%K!c2Q(Sxo?fx_L2@@$-BAiUY@?Xe2b6}G=Czb8*PLiOt>fl&IY^Lqm! z_Yehqs?=BUo>E!Je-|$|YFkkFC}>qA0K?n;hJjk4d*(q8v+6S6U4bU^)Ro8mBZEKW zsK=W3KAW86)0c z?mUl6O$rV-S<$_)_ED#>agvFS2#0ERHZ$1}X?SrO7*so;)<=;E6>*~5t$#W# zbdBX`I}?HJ9TDKWu><5BM+Q_Ua)#3ZM_LY7a0Cwdi^mFo(KP~!z%e(oT`fV-m-$up zt>Z#LbqjpKz^@1>Kv_TDk%6sE1`hJ8KF1@E-31|#vD+Z?5PPNEX;RI)MJuqPZU?5V ziiiN@rpmg<#zX3OLLaoRKs=iGh5S4A7ElW>$F6d%RRBHq7l25rXt44^IzaK%LDd4O z7+CFu$WlB8eAFqzz9ayu4T!Yjq`l@51N7hgzS@%iZTli1{Jnwtx3)n)H<-Uj<%cFGqyFAv ze@8`tszp#bL*Ds*23v*ak?Ck%e83?5PDcRbm8+{k#nlS?s}&o$kIn}iyfS(fT?xAy z=mq|ANDue%m3CI=f;!K@wJ12e)yEYPP&>UaOhuWjV{{hWYA5Y_2te%1k8qEnsAG5J z&U_OOI0w%UCJ>}a7HJY;EO1jrgs*r~K6ZDqluz=TKsm=T$YW~lJKr1rptM6w))1c$ zF}cGlWprQ&1sTNf3<6+7FvVfm)Ch|@ig1jhd=pH{I{05)L9sy5fp00`)rG8(5vK|qtUBm>w+L$CB zO{#FcT6(JX{@-svUo{maih15-CN9P*#;^9k)ibXbsRD#DS_D-Mtn|r58i05Zkm>nVzpr&Z^(!8#y2emM-#?!>m8)gl z)Vimh@OX0EvRr~dhgxNA@7%={3yU1u($pvgVqHGSN`wudGC^J z9hIjYVRF4z?bZL=UhD4mgt?X|(35BUWdp0;-^uH@wSjIA6NHZ&I0fo`24fZS$t%Aw z0l3Q?sk^1Ct`LRo73K%XdXTc-#u?#Kh`-0Z_PEa;a@51S>7ma(MZh>#k7M=DbUgsz z*87kn1?X^39=k{hbEouGcieNZIN$3XmT9QiRvSR={>9g#V#A;NdN@~i%-51(g>VG^)nIim>pZ?x^%v4a<)P0eT);5j77%<`W~GE z>K3}eDS_=A4fvqb0&jASz=urwcJ}KEjtC7q8l+-D<}jYFs2YL2O$1bMxRQ%T)iS6( z1om(`Y6I8itddcxc=Dt=R+c&{pp@nzE(k=Y;#mU7TyzJh1L+P&1-SP5<*tRf){%kF z`@L^DVsM$G1sM8hCtTH$0`5!2gt6tY(rWV^^<%DT$YB%>s$*cT$Li@MM5J!bncSgM zMT8qMkm=|wU~W}F9O;AcnOE8h)jgp4p`WKS6t8j=xbJw@K*tV-I)>IT7|RR4#jn`J z*lY}4iFzbC9|ACW?2nohJUjDBTk;$I_pBY#UL|jJgw|2o?zefBO#H#hb zL^kg>5zu*lY%=nMu>e~cQHDjnR;42psrZTCQ#9aO4*|al_7vri*ZzUTkqEu7lVSJ( zXx;nk{JK(p76pzgn-HibLMZ`76;z*au8+C7iGfJY8u|V3{(qM_{+G8y7D3`ZBW0rB zVxOXGOKW!w1Ym*#Odxm@Z((qPNhYFz@)YjREo}=dSOM@Wo}HoZ2q(b)v z^>CVCEn-wE&^XzDPa9Y;M$zsDz-z}XZTb;mTHaSbvb>I-a_uPQB95~N;aLpRT{Pki ze-@J@g2 zXAgWejfyPK;(N2o-yl~~}4{%gtECoG)8KbWaf})^D z&)V&wV@zfSz?9+sE#lk(nsm)4W|_4-s(ha6Ijh7vRJ(RW;uOoO((r^<@;N z_p98HsizQl&14ebjaEBV)XPKvfW2jo7a@2EY82uL6d#$%+_^kt3`BIRh!kKv!lOrS zx?eN!-=BmdfcRWE^Na6{j|bPgw<4mS`C2q*|LhyfAIjEZUcUEfvfa(VxFKAldV z^E`Xku3A;Ks_O0-Tq%~RKbJA~JqsL7kH+9jcBkbLOcNQCmoq(3XM~c}X&H~{O9BK= z4L{&*^<2|Z#?w0#Y0!}Y{qNMj^ZQRGn!x|PJm6vLT-zkIK;&zkO2+|ArXUYW?x%i` zd*^$}hK8xhSC9E=5qwAM!6XEg@p@+(eplaap@L1-Pd3^OY6FbOWt7CS?GB;NXCK?VsljOe7ir30Uhjto3w-!1I!tgFv`vjKAK) zJe@b?tO5r1Nz_35=@|r6X;D_VB&mUSCOz=7TpI=i=$Yw{;&#KN2uL;VR|ebj1s*HU z-4#W;f2R=-k50i@!!desfd)Gp=%p9M&{K`HhKuy3yvObV1zSb`t-r9AvxHvTH@Zst zhe)UO+28WM>*u~mcM@^Olo18M7XVsKB74UyjSEQCj6=<&v% z6eEv5eoB6~S*{)O70(_H06Bl6Bajb|3sBHAyJ?Ud!^gV*#OrHy?;jwdhL}pCKwLDVjbY6GSo{Y z^aGIUF4Cn#Ft||&b`r$FFf<7%VMNFkV-y(n0YQs0B@_l;PeY5+)CRUFor7U7A#Q8& zTUxLNN`;an2@362$?riR;{cB69)|F0hl4B;z`cUvsKwkQ8%0j+)I!Mg>An%eC~t^T z8gkhts}Y%)DMdoJwT3>YCA8VusaXDf-D6*`?dx#$q?CIy0zDa~t_*mGRD~3CQ^u#E z?;F~SFZodYdL^g8;AP7k;6_1@He$ijzSPNoG+e* z`v4r6l*E7L`*%j^NI5e5w}f^6dd0L>m4#o;U`WiWb=WPl`wW zQ2w@EJpC=oW4H0ueow!%o?#l|srIX(=WOg$ji#pc9Mg9O7<{wt-9Sd*c6u(~6CEJT ze?b5NgxXgmN^o$Z30j9~?Xiby5m~r8KmxF&JvPUHD2di#TJldt4j_eRaCOd>1r7{s zLRLI-`o@VeSH9}!0+gbDjhJoNf86xK77OICaukg*22>+ zNfX>%dd9#&;BQ27?vACmgfnw|QhQVuoLwnC&rc!GueEU1z<448TIb>Ol9I#FYww1S z&82lRZ-8h4#AxmR@LmB4M;9O%()o8q!Gj?ZUKKz9KR~Y=(zzZ&Z%{rA*;vlZjRMAQ z73gI)|TdKR)FM8Wgp zxI*X?z;a0cc`@ARVA26Q2MjzpMjVg-;Jj|rc<}u0(f|v{fJ7|d2oRZtCjf~O`>1o` zo-L#`s95-PfP-wNIa@Cc03faY2LXU(U&vHD3C*(IGK`0tm$2KrC2S&LbUio1LKqn| zLiwA7c|bS5R3ErRuURAyWw9P?u^xJnl-UhJz1QRAODSJ30l7g7a6Nf{ea^Ldpljtp zU4LMW2wn`3SXDCtmddLdczGu54X3|8Lb6Me{PTsRVX1opnY={$lM{x-`)kVJx3!raDfOO!RZl|Q)28+GUR@!_t^hz+Le&vi zY6~5=bWoa?l=7Z_K^YE|{?z+R$+-#8@*+Yq+uUR$?VFpC=zm8yEwoS0{l+!rBk(E? zNQj7X5DB?URo1Xr^}f!n;oUzRLEmWM@xdQ!3_l0L;Wu)4+INS~exKKq0(egjtoG1h zK$?i?-aVvA&*6FHD-&Xr%y|4M>$q(I0g(Ze)&AwVQ2+1xX#q6XS8J_DWhmW&jlU6b z(K>r-n+&acxJ!;aq=zy+?WafK?wdR?Az?^nI^ZtPBkV5lGxg7k)HGzg8!{}-@7WCQ=i*BqpC0($H%Y=EKdKljIP7rBQfT;#aq^WOzXW!7ua}W47Cr_&yH~? zOuu7{AqMXkxfi@>t;zHr0RUW(_$1%X*Ym!VmY$UN#1ogIpr!RRXF*1xA(?CF;5TFt z8{D^)dSi>4D>1FTn|?SzhR@R(qh$8+2#5B_(E=GNM-#Yzod<{gG5(~sB!|;_&S~xc zv>XaY8I}ZCNcos+aAg1q0A;<%vkc9&WZsbqfYB!PtWGt+uNcc~cMdQh5~Am!agm9K z@GnRwNLE~-KI-@^u5EkA#z<&+|+K1z2(^j zyyk$&&hx_)fiKbv@P>daIUm=$yT8QNi2`&(3LLGfqOmKAl25dBEfVvu7gDb(|g=vkPZGIGZg(gW}XUX=4B zP(h=u;op>#V8WpGYFO)Kj=*3daN38*`wlD(2sk}agGEW*QO!e7k!=D1bU&{4A*#4{ zKmg}`hdTT2Fi3BJcEG^0c;pA}rPL2a}V1UC;0VW%j2kkDY(plyx5CvE_ z0D#EAis(;_G$g{w7+<~;A%-Nre+>U~N)Hu_ixFI`|6$0KBn>E^J?=2-Fvnm%+$;H0v%! z0HLLMwQ8!-C!Ret{l9jrwXx*IO6 z)WEe8yz690uh)&=poLqkjaj0HTB1!{@~4^*xKxWbK!csbs&s-N?asc7oH8ZyMwx*zh$CX>N9*Ba4I)_H9X{ggiU;;acdKp4b2 z(DWO3d*JuRQzwG4O9>q%CnlZ{W;!%Tm5>#sG~~2o0ASQw_@y|UGXo56T7vIz648Qf z>i0ez4-`uFV35;uph%~{CxBQ;_z!{(X%;;{y%kUvo&`W&QHN>h?;#+`qw!#;y`r!L zbZDn)003!99+=1b{v{qi7s~e~xn$&M-Rj0Ze+}tNGUg^dLi=tUGo6q>gueC4@J{P< z8`_tq_OB&n)snGmNj}?>$F}ymO;kw$xurdA9+aqn?rEC;eJ}>|t1-%l#uLZzlV|@{ z{`Sdu+@FatJv+u#ifCH*Xl}u-F}D2egcx}KF6BZuOTU-y!ybBTp*(gy&vd_@VHz)6 z>(`LsXy|zxAF1-whLl7@;He=wZJdz5>E0Uh>KZzKjXiQnmK)l~27p;0xIyXQuX4{{ zh|!l!HKcGF>ldhQ>{)#^3@GjmAd<{F3V|`#JxsqYV25YZ8aw^Kvz(G=d|d$|gP=bJ z00ER<7$5|2APOP_FipuJ)fk5r|H5R!=U4TFCmh}$KE_9q4$%2`=Rzuf7AorF2$1&D z&4?&3gn0O@0ENc_3N8#+WVebSxpD;J;Qgr@7zr;x??0~d#e4{N5+oY6s!~ypx0b%V zxH*ml0B8k7Mn}SBp=#)p0R(zK54QSr2!nuw69NieQBDTrUjMvFjK7|p;aGqJ8~z6q z9T*FL04@!HT7b*MU!9GSy^AN{w%}SXHyWa>@ZMYi1j&;74d}eNq1brR2tNyG_+WG; zBw|Vv;Xth)et_iNC4^c-cO%v3yDj+oaC!_p(Mc*5bPimRK$L(;#Jd9yaPZCyupnPf zT2tr1)lM7c>pIbqR7H^*SRJS7chRB$T~4x70|0}$I9V8RNPC3uA@l82sR4Wbc=TJw z;|Ca!<9|v(!3z=**fvHV-T-=-$nLUo+MKfG8KsA5S#MyqUmQ7z-2J3r*Qxa!dW`^p zS=#)OunM7*)rH=u4IkAFdDx0>V)T#-uTsNG=*UeU)~gWx03N%P+|r*^KmWzLvBeUq zMLIx>B#eux^VdQz)`Kr1C7=zt?xboZeEkcn3Sp6iU@_%|LQ6|@KTCDs1|&4gr1)tC zOen^c05b3%^Ge?LX_Z5>rzhj>@;`YXlv$afETh`cCN?kAB`>U{&1&hj%`?lpA;d^G zF=n~DgBK-c135T4>-69pLMAVa5EEwlTZOt{+!AUxK}|y9R>d+#v?QhFDWs-p za`!sKt@|qt(UIVEb@)0m;B9?wTS&GoMcle6^9gRPQbBwEcx6(~lRqp^#SLVhT%mrZ zmyI4#_u%l|rUgQr$6He|ftP+`gpvjrg#Gn8x7!3=ZWM$`i3w#TI78GD%yZy95Fa}48jylXsZd92e~D~HT6jGvDOEg7*V|BZOjivlt*?$3yKPg-m1 z7;xQlLu=W1b)_hfe`ZHCWK0?|E)6Noh5$oD&)3jrHT3=s8OesuQ$zRK(3&-_%xeWc z8kbhetRcB<07{4q$UAQAkmr7zE*YnWjm}9o!S)X(J`gNwo%jLXIpj;3h*lD=yo7Wq!8?B*>t+o%4m^3CQ@mL{MkQ4TXMIXMOzK za01>QVj$H4o7FY;NL43|30S(Lg$6urAsr4H>x=$TC@B&~>(f_DqikP_xc%ENVJLAu1z z174@|=d^>?(tQfhN0-E4qN9iyTof?C-{jmnG9ZW64iNf}^yV5)6sdt9m%%q5il`~6 zfpzPvOA)DJ_-OzD<%QQh!HdT*ADJisI(4r^4o-^U-#Sr(_2cdHyQij95HP@JLMViI zPV=@0i)S$;5I)q*n#%$4EST5Tx-#TAFJZO$+^u>E6figbCSk z$agFc0OM{2vZ|C^Q;Mx6!{1t`Lc5eaxvLtWK?l)&1U_8(I~$hSD&b+M3tQXHnoXkT2Pnw>|aD52t%}UML9KOcv=#Sw$`I9Bj46xY)i=6dROYYeGui;$Ugpgd0Y-KA)#cOTL7!Q!Ve2Lwb9>-bKgW23#@N(dYZ zIxT{=LBdCnPc{#V+%JCzD9i)|5Zb4@;co$nc=oynclKJtsQu4e0Rc`4z$pO9OW0in zKtmwdzoY^d;st0;81+nzu}cym6-nTSewE(=3ieLOQGmh?QNCVzPAj=Xq7Z)>&wrPN z$2+mn&%r5xua;Nl84;9*j#gC06Zate!S07q|J`s#UYIbyp1CbW(b0Q$q&&LXVVz~9CL7P^TR?2_k`+%|MR8@lI) z)~lhtZOrC((hUurwZ^HrN9|SPd5Ivb0WL2JP}(rhc6&eqTmp!Pq&T)qL;x`K*#HQ> zhf^RRZW1EzyK&MjGQ2Jy1O(78LHj;M1&-EmQqS$?MQ{bAXx)4XqM+8xjfD2iSN^86 z<+j7?ggmHwbDLt_gXcQ{AP-w`6$#~{?iB!0@Z@lDjtdCT>&9Q73IUxP_YIJtaOXfu zboKtO3edXHtHbT93FSYS-(&nG7bXi%1rS`2XaNxd=>fWxj(#mVi?5Q4Q9Zl64Q^IZ zGm{Db8~{BPAaGfLfaG-Kzd{()nI6$IF}mEnR`fn@IK-v%;i>}44G*cb=g5`;13FtC zQlxwFU?QRchwGx3iu9+)6VH?mciQjrI8rYR2*8L-FWQTjoVh{?<1Yh8^EVrR-fNTc zZcQS*D+WFhMH_x}G`i{U0R;>7^U(jx?|zp5(RsL0^6$vNR|5>@qdx%$*W~vX=6fOo zZwweXWuejugwxTVHwOgZXb~Mp^p$|@(7aXnj09%v`YOXCoJc#?>4)kw zTRT<*AUY5>wFXTY^9CNHfL4RZ#5Uzk5%z@tLeUE|i@2b3= zTlrEWOF7Cwg`C`WbB9_(1AwE->vzcMsX>wCnT|_13L?pOBCI;74sG3DXxBCVka!3! z5e|a@BSCe!4v3f>9wEHFayTxC;C(I!tREE4p_K9;64>;t^7|4t+&SRt(0~EHQm0Hb zO3&e00M{nHLFI>x06d2=JvW1pJiGnU;&Y7YS!jVgwz8D+#D2;3j)(YlOeu4`K$zqh zm4=jfQ}WUxA|n~=2w-+42VEJrp6<6Nnd(XrcUFf>@_W60NerqEXXEAZ!u9-(BjY_w z!J53eTdw``_2mUP3?F!Tl{7kLo^jej5+u zUhwWG^R*kpJfEKjV&o+Y_V~4)P03YL0Jf=TZE7Ez+S{fSPvg#jfr*7mbLiO{AI&o@ zE2H0Br$AFvXS^xJ(*ywhJ)j8S-Op>a)(t5-NU**H3>}qVZ2(WtDUf7hVk?mk&H)?& zossFK3v1IH@@QSXAYkc~2&tBXQ=LGmAtj3XKbIL&NpMtw0JXpr{}WL6^t}}#1$ zdE4*_00&R2D5+->2xNK|!Q10hzMxWh?jb-rvJ>DB30UBcE};(ZW3Y)T6Xt)Y?26Nb zI(HsWBm-#@AzrqCu$z_rv0i)QzhZ|dZF@?71~@=Gl)m)HW1JJXOTQ1;pvMd4-ggEx z{4)RqT_yQ)RAObmYRwr-@2G(G%^U?HoKzTW9>-|gTzf?~zC5~jO+?_1I8y>|=3K!Q zfTVY3A^;HgC>wlRqOp|y?H|t{06_Y7=kofkzp0RWZGjB#b4W5p4+r;oAvN>)tT`zS z$bXN;>7w$A$}l(_4+#L^At9I;Qjgfxhq^=xqfeMzz<`D#kaQ?fa^Lv}%E*B>A#TCU zggCfN26I5DcR+$TFkV#x%V6d5J6 zMmV#f?;UbIzYKuAK0>*afXR!U`b$Eb_m*O#Sq!aA9bN=@QP=+7cmi54+6z-#Jo>Ie zE+pl zbX{75*AHVB-pCO_$5MbM)^JGvD@b}e2%GCSg~&Z|3?bD48-99H7bp(xhsj0S%i+mV zE-q>MN)*>k@o*$7V|Y{muaA~IdStH*qua3x)Onc8cjB#$R(fbcUhTxv^6Kd1M?M;F zwfWg1UAAQ$J6hlFM5;2RWcreio@Ar9K@m9H0=jJ}=;n`NOfhaRDS2X~v_s=>j&aj_ zJf3ftQgw)2#>Juf&C4@xNLe*D$oByS1_=knSn~gb)ggr9(d*tD_m{D4N+~p@ESj&W z=uuO~qq$`fP8+|DLB{K*jP#lLn>?u|9FzTvDBBcJYks~)P&Xw9O?miDa{7_*H=3Hf=<#0{JgAyvN;rhegOSn1L~!JTzW~#rS{eR761Y=1nyv{`*O=-^oE|t zvlb*bF8}1~$4Z|}%0RiJqt2Pzi$6JJLCNQYfQDxe91%weFaMTuoLmubbX6CP<4nDx zWYL^}J1S!7>4Kk#tV%Y<^!l+A!(BNlsVp22oU=a%2t1rL0S?eiQU`xe1mQ=C0DL0p z19TUSvLrvFGVJa)h`|=v9Jwnuty>V z&kO+g-*5+TlpqmmPdwb~tx4rc4|*K2Kr3a|Ljv9|JJ$IddR`gsAw9b*tG12T5C2SS z>sbW5=I0G!+({$u9pk=P3_b57`8LUT!vF}KBM&qpeE+*#e~KP@QhCUZl)`nAesBY$ z@8)%+It9GUVFCzzC13y`00B|=@3Ly0b5|6sAsKQJ0o|pXFgG89D?s=jP5^u>ngeMq zU80Bg5ApBB=xNB<*99Eln7yuyy(6{g_EVy}-x4Q}@IIxMq-_9nyCyPoa)1F&+CLU* zsFTivE3dw3(6^2!dQGej8~P_jsBwdiy9#wXoQP3wjlNb#P=5FT5PNd3C~u#ZxeWg4NO^SiES+B$ z*{-FvB0{mD6ZcWI4heQAl%0bX)x|{|A&1JbHkj_JKkiHkx{ZI}#AV6zrA|PJ>hsx-C z?5SQue{(7`MkF&PGQsqJM)LnZkM|^*^l0Ay&{wUAXSr*gXwT|!tk&DZVPJ$4?RiP@ zK0KFUvb^o)4mDeWv`j~9(EU`EWA>zQ`#L~<{l5Rw3}w=LcC>~q?M-ta-Z92~-+1Y- z4FEVU2K@M(q4xyVN_n zx8_@_+QF3&fRu;g@$1YqzfsTM6ew%z%+qSSDdX7udZpX^8Y#)9&UkaPfRUe81j1)j z`k`@io^S80-+_7dEdq{6nS4JH5Gs0ysD?%?06D&*73mcqMvYN(Jd2 z=m~>5^X?o-WKetU!BUdz@x6o{J{4do5G9d0RAU*HKLtI)n^9Fts zfbh!#44y73gX&%c^c;|p8rdsR02xp71V|k~Ce#@n)@Qqs*QYBw>GIy~%R_Yv;PyoS z;02r(hX78{Nip_&l|FNnkmx3cjLIx{Sg#FGAnhr~%M}KD!~pJ?zwMH!0bqd2gF_2I zI1PXy#EJP^dHrrq_Oe6>eibL>m%09)2m^cr93i5ZvQ>_3k{&oW`i{sa9J<%WS$#u5 zf%eR#LDHo-Tr@e-et4WO6#;Or4vv>k`t`gR_yZCNcwhALTce|?>4(E5fZ;R%Km*`% zahzk))kJ8tmJCmGREBk(58#5caZsEs$e^1F0Jxk-A8Ha5Axa26azKiDK)_^~1Z$ZT?BHks0IczUmpABEM>ssaellZSKz5-E94Cwpzec@h@a@^TONt` z_v7;%zY7n5u%W;cb;>sU2(s?mHO(leN29z>jPg4^X&}6>UBkfMxhf+Z)k66azC~%j zzCyW^Zz!)0Pmo-4-H^*Y21-hG8Rm7|Lsk-Op^<}X6Kc1tdv)p=PN*pob zGS-l0n^OKwQVj4N^ju9Tyrzs}Q}WQfKR{dHyQODsNwKsf7fqd`rW}f<0C$sUfsA2O z``VOlp(AJWO#vh)6cBJ~g638i)ERba4E=O5jR>qyK-PADFW#xPaHfhd*>Fz*ffzRx(!IKk^liEXoIO|wAfPpN8{rcYT@;8K`)48ow^gdjBd4Xu z#ssL$Zz7c?9Xa-vL<2~3Nv_N{qQ}MV`Q4uRUZ3qA7?2JD$#RY$BRh3)T~cOLJ5fmh zxm)r&s`YVc;d3fYV7|a(`Q0X!HW-yLhG^`mo6^hX5@^rN8_=FIo_$1X0uk9|)RIH` zc6c~Zv$$fzl6?;$I;M=2XMsqjhKA#j;`Iw8IW6$zeAV;2azL`<`2*;@59X4M8q&TD zk^4R&0O5q_!%Oo&Z%TAv^F#n7zaDqIV?1HX;5G^HI4D1F8m}Lo0Yt(-S0ur|`#~I- z`8YMCHoul=!0FL{fB`BDj!6UnM=1nqS4p8yzaG#39ns1AM?Vt@ki+CkENrRP{@`qX@`kKK&}q?QfoURoicKGMa$u241KqvF|Gi?ft0Qo*-ZcdhHeAY zPCgICCZo{8aIRbBXl=ggDIz&C zdbo2)iA<1hq+4G5xz+Tit3%Nhg6e94x-vFBDVYAX)p@Tk1JK*8#_Q6RuSMupfWkzj z3o3^=Nf=-EFaaA_Lf|fPdsi;mLw6cc5CRZWZ?2l;X~MD+{%P(>N`oHp?(FutT!&Vq z#U8>N;~D&C!h)X*@8a}?Aiq(m4N@FqhZp*$=fLoE8BCXWV0@`5{b>N#k@5E55Fx?S z-!CB~kmgB=5WFh__|9AqQna5QZwZHh{Qoaw{C}AU0J*cLB+Ru_!d!Z9cicKUhu}Ry z#Q=e`V*It{ZUsCP0PwqnLb@|E8&06^5qBUKmT zE!`XAe|mDTIux$`my&aBHXN3x<>l_KhB%{uZNyL$x$=vn## z8-2-K|5<6zEaTUf475I4z|jWl*m(L!#=EEH9fbYlQ~%TaK?sWw7hfBGi4=P4nPr%pqz8Tx?_6hx_Semy6i8_4 zSz45uO5wEhyY`c+LZzjBYDuBBw63kI0uBzVv)}B;8IYIW+M~#{tu0a}`59e$u9lR1 zYm>S!rd`s+%7Eb7fDj@SU&{SoR*?m#8AvY(Ff?Qk=+bFoA?XImr3r+rE9sS|Co-Tj zWJft(^c>=#nL;xUgO}=6`J{BOLef1>5Z{_kaPf*3UcsV*@Pk1d%Lf|DbauE#9iYkks_tyiZbb`TtorRj6OyOU%Ie%Br&Pm zPv_^;;;5Y&=lYcBb3lXE-n^{0lw)NeBUv4Ob46oZ8m{+o2S}Yy%J@h1Jyjzf2zLz; z077z~tpPLiobO1GIyzV#DcH_^RioaP5pSJRp*MPT6Z*mvCNyhC{H0-RQ%#`PQ8Q|` zDC80%1$33tLJjRx56bYIWxH4R!6iD>i?qOtwAhOzyo;oWmguIJ>hKI`!WOm z*5vxni1DXx_9IWYVE)hMz)*@KSsK#&nF0Kf9QcQeEllfQ8~%ff(_r!u%0&Y0wx^Ua zp~zrKzqGgzV`nA;08r9Fa#NOxcw8u5DFKgql`$H>xd5EU`09S>qzFqN!`OlwBJkLe zq3CEWI#Oa?y=QNIT{^UV-BV8ry$bu(Ty7?QK%2qWx}5mfJdSEh*oY_N%2c(2|mC z$uPJ6D;~d;W=l%9B~Pz49Ki75RNF|-TE`?R02ujgfQdYjrk=I=okSzxA#Ana$(9Yg zdnzWVN|3>F+T(qRp0K`qCt^a{PVz{HLz4&Blo%2Tpo~!K>~4fa-gLh%!@Q(Gx#uCQ zo7BLs7plA9F{vEbv?^}Q4|r~!KSu;^3gG{I$bwqi$>%Rrnc#|~0;EGcZIB27Ie#Kh zkFAxx@v+FK4Ep%T0|X98YT$q(3c74?-2w$3Oa7fi1@yUNq+O-M-~qXpz}Er}v={Cx za8}X=($8a(VOPUIh85VQ=YVHrNUx9T9FBe_7kcGm0RyLnCqSC>sxlJroZP7By8LaY zN(VRD;(~fDE&H2*~kq(=W(@axR9n2ksZpOLSm$ zIeGqh)j~}kB!qokIh!{AL=V0i{h_@bA_p!#@5llb2N3(l10IM9kZP3751pR~!KsM| zoRDaO>Z3F6h&s;PfdL9QZ66O{&>p$3!2QwBL}BLwTE16= zO!s`aIcb|0)Si*fCVD^mh|@vq7)gWFsc-ITfqQtz`tY6$mt`@Q{!!#qK zGb80VtIeO&qR;8QW*~S;FuPxkSEtWvzcb;^4dP{J0X<4pO3+=}-dhm@dv+)$*vs1V z>E~3*k@JcBhPD6oC;>`>bPw(t26y0(A@6LOd^S}DOA1ksO3^ZD45qQU7&3knkJfuo z3Ph71YW>|I>%{>8vk4!OGa}zlerT^4`ojYXPR-8{OpcAgKPSR;X#fNQr}c22f1N_C zX15}^+tlY7$>RM(0EFOjXoUUDpkBU$N-s%hjPk!`MTK0a3ejiJ0&zz8cn8`;_Zo+M zv~z()_cYhvT*J)oM;EH{L!RpBuJK?d;tA<*W4DKBg@<)bh?7(RNLh?ikpV|Qie}$J5^?d2>By^VoRJSH_DcbpN$V z$F;VJLB{A_9?xA$yM?irvTR8awT=r9X1hf8J{rT1r!VE&epc~g7?0i7`?n?2ZRvov z07zSgy8Xo>I|3A1G8`=#+7`OtrvV09%a-oF_49nyGquJ82$m(apz{e2#{go}iXu2N z00&1-LG$d2q!`%n+%K+FM?-&y^WZ83dJ>QhIU|viEAlhM!5xanF%4&_9irfLE>dv1 zx9NM5l6zmkx<1Dp2{#X40Mad~H=TJ;c@!Y>)IlPilnVbLAYdT80HSoeCY5(@Qh8qv z7XUJ_&YMe5w+x@?;gUb61(ucLGA`xr3IU>klpt%J#t*HCASHwD9Uy}^_S-lNl5zTe zc-o-OljjZSp2ijjBP^S^)*a0Rx{%s-T`6stk<~goa%tx z0|fNdvjpx582DF3jXjZ&=&|$=XO=BjQ?ecE}R)qa8kT!A_#C2b_y`i+PReQ?il~&iE0l?V5FS>h;;lID4v3At7zAn?I zOi?oER_kyt1Y(%?U{Hqbn5f7pl_yS-j@mY_W43Wiho~c^+?8SK>qh%pxV|2)_pdUd zct@=x%iEzt7eddhbcAo5yq6Zp-LIxAXO57&>zWR;yJmf`LRQqFGJt~o4i7x2gj-4@bni1VO0yD_IT?p}Dav_ycC+^+5+G30(|vTc!5t~cwv>G9p5#-tP}4FF z?xv=LXU6jyFJ||69~&;zR5B?Jx`mDFzC0<6Dg~J8Qm|t(m?rcPf`Qq7XTseO-rkoe zO22*&Vh1?bOO-H8K2XYK3}bjx9U#~I&(~VG0mYJ_$k#8d4fhiTI3_|yxar*i3FpM% zpPT=K>_^z2{FIc9=N};GI~P!Ue6WTTxZ8B@kx0O+BXp+){qlF}Wsgr}fRxZsg{E%Q z`wl%n$QuNHZBRYl!Coa34*d(@xpz6lB*~b2p6h>I$4n`c0LZ8muo=*L?lCDN6R03$ zO324_7~GCk2YFnFaQt(XZt;j$J&&im$w1I1c1m(a;~G3`nlH7bygK^dju3Z82e*UA zFL~|VnkoQ+#_qEMhQD8i*d(@N3oJGch*84BKfB($q0e(3`|O1D3G;unqD&?a&c)-G zB5g|PH{seq;v23!J8i3-i-VzmYG+S{i(MrXbKKe>pCaTc~LPDERB(%!$CANhJiq60FFZTJv- zq(h?4K}$xfrFCmPny=r>eJ#&D=&ZLk&;7$U(7iRkkY@%6==_+d2moMzAP)W@DFGR` z24$DmCPlJ_WXYPtrGP-FHFPtk|4Vw{FFB+4CJLZEae1)*$MXy%$DX%vWv(@;x-TU) zKwp79!w+~Qgk1=}7lso6iEz8(lsF}zGt3|^&k(pOAOMG8o#LX9&LhI-SpthohZ?XV zr=JQ>KxfS}1zw&D8P}e;ir^3VUdrF3SJGhj2NcL?L(Ddx0AL{SN)?kM1m`A=@apIy z>FhD>A49VsH5&*_#qi@L%DWxKnUnm}XT^O9NFQ7jE&!1L0d9zd4kiCGQ2|l|GXd~~ zp^q-lb6EE{{L?Z>!@8fx2Y*rNL&%zvay_Rz2<{w!@WL1|F0C;Q&0N-of!8_=>GOte zilP5*ynaA~?wj$&!=$IbpNPO+0RmJVjV8hXpX`D}5566pM1=L@3u`+UzHeb|dH}xC z|BL4jM}U%M$_1r2TrNoEz@iv^($(;us2CtMx_2U|a$rmZl&*5Qwf5fOew_n13K~rW zfOITr+4o0Z!^?tKM~YU?rTeX16rk~eIA4ILmnPal8bvz5W%GZC@h9{zo!|+nRH*0~ z$F~*$XuhOEc5NNjuKv)IGVV(t`&zvIE~WTL3AD-UZCN2Uhqw2r@U|K35MX|i@~Xdw z0nY(~aE0e3CB{h2F_iZkiyQ)L5%M4-f0yCu>tHUGU@Xz1E|HN~qJy&ZwyGLfrq5lb zg&sVkLe=DNXwOTI*ddKy$7m9|e_bhL$WU#8fG*FW&zY4HnU}z>(BD?*b@O`GS)uBg zhl=RclMwf`L0!G3BcvZzKWGkZis$1N;#rVH=VQs(dv*Ohw zaBqp{FF@!=wIybL@l!`I;0(eg|^m$o)Xl|o45u5cx60(Le=LaOiix;?EwJi zBvqh$ccYx;331;YuYarL_uriy`F#naV?Y4{^7dM!>CT7;PYOV5*dpci&obz(yUVz@ zC2wtgew#?e^YV9{$ClQlEhW^}y|%Tt?Gr2I*M`v+*>r|v8s4vGQk zo$U$jzei4QRr~<=3wSgjK;X<(0}uxFY~xE486awPY*JV_13J?txx#DF8k@V7W0(j8+&%C1QYLAu8r0i7j!h(ID7l>v8IAyotb47@|ql-f%g z6*+3KPDLQyviQnG;NTDF*&q;(KDWRC1YMuou|)D9F6%Y!9{8kin6#h6-$^=PSxAC< z&f(J*)(!xpazMs!Scc7`!m$|w*uyUiUx*9R9xQ&s-nS%*@K|vS3>ru^KANaPD*%8< zf%e}i1PuP?5{U#zP-Z?+y4aC}PvnA|Al*lGfm@ib8=Z!J!x&El0LZwSj156hYwaOu zUy1(2agu&<_rU*o!X+E!{wzPq&o{>Se=>Ue3vtfi9Y7`|#qhy^3?dQmvSe30(RIfH zLvE@5)~qL~Q#myZh@zXM`6IU_HA-sgmqY-h2%0xk7!L(N$iJsI=-rjlCyXeHLJI}6 zn6Mk6ao5h%AArz1NV!qr@@Y`G6c_!$-TCXvBErF*rEMk(dh`pG8v<346B(4k8PFje z&`mF;Nzy_q5499k32wl2BHAuTp>=d3;?xL+2}% z18vIVpzk_idXxa8WkKK`Jxm zBY^rG6A6Eja1sQ+BVz2&50WLk^wl8R1LEyp6l4GG9Ee93)-q`Svaq(y=A}W?*94I- z1o{866vW7J$sv9`06+&~1n*@1q)Gq)l1-N~$#|OKOloP5003&I-Gk10MB#S*M)t;1S@0m5EiPQjw76!dbW8V~G zLkZtW3Gsh89{+iX0-TU^kq&J`M#WwEFlKO8^!!c9ni=xP)qOOtE29Vr&xU%wsty3N z?Q3IzkB-6p&v@gT7irfK0LdX`uAL1Q+|984?p%Nu$!`17;=E7+)BbTqG&)iY9T|s? z_PV3b=x7f*l9P@MSVy{`qxJ8slQdZ`_o20IOQzfMtZA1FFly^r+c*IxCY@5N$6R)BR2iMBYwFm4IZ@?Syr%+|=vePv8mgRp*9@ zrsk|%7eIhhp>-W6HF$N>20GvFFK}?cEqWF5-(wZpHCT8?0Rxi@bq-B1{7#|)?+IX* zu^p4_ySiz;h3Yw=wQ^bwLZM{L6$pn`q|MO+Qm^zI=p|hs-8%ZJg(48Xu)a4@_rXL1 zaCr0{Ba#KrA=o4-0m;1w5D^8HPGEW}5m0~6MJ15Ho{7QdM{i1I-5iYfAPW4ZfB?y_ z%iA#gdhX$k<5;{V5e51IK#==!zCu8}JrRS|0S`Yk=8@E8GFRY>0rQ zNdG7L?!K}`COJ#5IMqqS6Yi6q!#pU+fZ9JdQhQp`061CN8_!UY9Js=YNbc%H1poox zsFZ+7e*FJU&f}ILJCYigT+w97&n$U!`*hh?clE_Nl3t+qgwsyLAYOefkpUt~RDiT14;Hl_2y02m0L3U&@PuJcftCR5E(WQx80TRUIh5KR^(B=yG_e}L9sV))7D%V4?OWoTh7lOHet z9YMD;0v^o_Ig@;ul*$k}JxWp_`D|av+2uMI|H(Rtu0^F>=%fhg>k=*`P4t88=?1wr zOvq7(-bAIv<*hJHjUEkFTKmWN>kyduM7bt}s76IjoEG>-rK9KyI0>0`<06AmT1NLf z`bGfwIyx*}9k{L(LQjXLC%NgqyZQron3V3*y(2I}M+N}ACdLL1${8_2ABm@WLOj)v zB>Ye6fE>1D!$d&IoSXOTm0Y;?r1`fB@3%3&lGl#pw4?j%==^mKi&u{Ey`o;z-aYyJ zmz8nvNLh8HKs$u@CEsm_`?mdUnsPkfLf!QMDz5ZQV~>GS{A|2x43RLxlwClr{i{NSX{eX$eOko|5zcdIaLF z6n{&yNfl00M%iVD`s}9U)6I>D2FR0Zz_)-W@lb%*HBX47kRs6e@l1w+qzH(vd?ot; zM?>e{q)Z5!^cZ+%@tNFN@P?2FwFc9=Ur$s#GW>vFl|$ib0XaWYmoIqy@YF5~HD}q?K}7Dl0RmGCHFkJaQUtpfQE+01M5eZ^5<)6f93cPhuhVn6_q0zLom*@+IEoG`ccc=#nr8^}Hl>zO^5 zK@A7L{wrVtTl1>`hOyGgk9RG6QRy^0Za<42|89&w z-al#C_CgT@2jV=P7kx=dpq|}TRB~)QLq+T6uBz(>1Q3DkR64+O2PD7lr9!oX&d-p} zjLDJL2fXlHkQM)2Ajm)OQR@bQ+7TKe??j0pOGA{VDn(~@LeD;N9F2hfRvtW|G>AD6 zdD@>U)ZZoiDPijEo+dhnL}_eVp}&?kvUPLN|3?!3dqsw)z$P9k@=x=`%EL_&KKo*M z%5=1X7(z!U=P-mwAgT@OK?kI~2DEtt7$p{sTsfs+pDePW1?+|hE;(QxiYNmlAK1_T zSJez%ZGKOl{*3N@R>D6oVOyyKxLSu~wFG{Zl=@1c{gqm%6q_%afXs;PiE1y4w7X-nTWn;M!<%zYqjb2y_Xf5s1h0-d6-R*TWuEp?*T)4yA7z z#78(DM*f+F1l^qq!G{t5aE08)^|=$<7I1Qk<$o)sLOG&qjuHQ1wLHw zFE7h%Q)){u&UH<4|K$8(wQd*zWUYT6!TUr6cqYOVL1*uP;?Q*`|DvDzRe|6Fs zAJ0X;Uu$fl&9y<*L_#3{2vj)duXS_1|4~s87lyS8N$JS}0OTNduGEp0%+(1+{v?9E zPe8!o@oZ#t-CPAC>UT@|x$Nqi0D#>pS4*w8+cY0lhJw0!8{IP!3ja~10y=-rq(&L+ zmSl{kJ0|Zz^m|=G{|6@mu*Tq=m}tO7@k9?#c>0tA+Xf9s1}xyY>hRJS$B_WeAplnQ z*p@Qs=&*NXB)T_LcS3jw9YXB4#ru|gLtbqk7SCSm+7W>3YG1oAh$p{KEmLC&?n z2UA0*^f_+OMa95n=^t=Z$_FLSo;3gvkRF_TQ-FYEi@78d{|I>3etEpGbe`u>yeXWN zBNHijO?XpV7iYk{0rLI-2pG6$q56-ECsF{pRnErv`2huzKNAUchRlDFKK5WDcu4@| zKNlDtBMN&*d4rEnC*;gfg`{&jrswqZLhYZqHT?eVIa@^Cv`_9iAmHj|L^6EtKnQo> zqah0F^`klyOe}OH03z=v5)B{{0P&fezxL8?YXwd`cnCfA{EBM2ia`JCDTQB3szA>+ zta~1A<>#+Pmq<4bpBb6BJU#Wd6(x3B=g5izjc=Kh(R~4i z_Xq&c9@Xt?4=iuRM4W#nB&x&RmFLuxF!W}smcFM4?a5eorHngz^Uks=x$C~Bl!=v< z4oX*o)7`X`040XB6NPv+sm)|^7HATt_pl5Lorz#^dT5Of=`taiWqO}w7^y}foRL44 zQ5`!c;jSw}>^incfN&2W&EY|GBt%^yx4w+$j5d2#hi+aEyh6WQCFHeQ_j8l(`zF2q zCV7LaB`_TANmg1n?sd-wW02fp#;^bf< zeOSDZXbb>!@8qx$BKNQUn4U?WV-lY3dr*ga@WC?L9<&3=h5v&{gV(F)9{XX?y@YB) z3Tk3`g%r&y-nSwk4Ce5Z!X4uMzazlnBMJYXAFqF|jJ<1A$=AQLkf_5_F#O41{iqDQ z!}x@|exG~SvzX9FevO)0?XAmb2$ezVlfiPX?XG-J+0J0XZGVj5k{_h2*fuf#GLUX6 z@~t9vj@(@!&tD%&D&Q&M0_eFsG8JX>{R&Gu4S?5wd_0$nYc{neaQMZS7|##En6N2uJRk6xiy@**mn4A%9uCe@gv`Jjn=~ zjP}kLnNK_+4FDg2RKY8AK^iNUuqK@RD^UX?q5y67Y*!eAO} zrF(6i9v~on)MP)d2rod&)2)Z`-v6|)wrYZk37QHW5EA8oWPczKQeCksUvFP10wGZY z=`)W*mXY>!!^Z*ys30JPc}2cr?+1+w*&!$KmdR%cGq-fHxo~(&WO=Ct7e^A_QEd4d7rM9%Ff6 z00Lq2y#f^0fPmjek9~b%Z4Uwn*asyHFFAE-pq|^a1R7<(3;;fn2xuVbXgux%j7HnHU0*8wGas>qp|J%ZwqEuQSn)waxxquze|G81# zt`!+}S?5@Eq@KmSBLsFJh>m}hSpXnWc?Xk670RWo4P{1u@3tPYs}Jq#A7-{HHvNp= zY(~HD@0a}OB`F&e80bl9_XetkYVW}cqr<9homR@xowznDVRu_h{hw#q!yE;{y}m-t z3_qY(z@RpWeDpBN9%HA?oshC}=RHbxg!X8{!{OsAIX;L+lyY^Y)Mqf_Ql|4-j1{`) zl@jLFLPIy{;cwA_x<#LNv!3TB3C=40ZKa-Zg@k;CK*hWa`n)!6PMa{J!_+4kt=JbR%gpOM$py^L)ir9^%7r{n!g z$&Wz}g&j>eb;IOMFHQdIpdtjC!3}VPElzlus177M-J8qnCS#;Xa}88F%U(X-`|A_- z$N2A=XuuIqxQGIr9nYWWz*}PYUzEQC2+m7LTW81p`SE!5I%@nGMU2q~M0fQ*-GQW~ zNNrKBNF-prg!m!6-c?ZnllLA;`by8(70~X;P;{6aE%}^1}km?f*)YLdwo% zgb)~i6EHBCYJtnL?(Yi-kP%|yqT33;KZag=|o1sI%_)X6?sKiylC|J9y1pOT1y zp4l@IW|JZy4MS<6&V)-i^*T=^lreN?!4t|MGQUY{;f{hEg(L_Fkk>V}A}N7)ge15{ zNV}8*-xiJlgz1y3GJ?qFbq9e91px{UV=~Pk$0*50qx+8e*a0)sVO{NVlj+3ja4k_L1>4eyp z(*g_t1=5GZ?^;+(mLpOixiNtb5TG>~UN@0|*#Lmc;?PJA-FfiXI6;uGN#Wj_uS5bq zx3IQCfM@_c0m$P+o_=Aa0&MJm5&-bxiUhb(kUrCd?A3_`;2eLjz>jidtt2X&oJ;N1PSsYHi+X-Pfw^D^0LM z8!@l1a~q{xP)55;`r|o8wrak!jK&lPUTf&qpii%mGc~jfu0bG8&f7JHfAgTdABUVL zv^FR~8I*7ho?K&z6eA>mOcRpNUo?o9@R6A zf^hFBrDHTp`2XXT3UW6!K+@Bq*yMeWq?BAU0=opm46XM@5zXK#3oJfI`tMk#4&xQ;l>~?#xQ~|)l zIj26arDtkO?mAnS0q=gG%5l3gjvXo6&g&};K$^{Ei-%O$-(h-4e77blr~B;gQV|4~ zHEJ)qlCiEpO;?7wyHMQ?dwh=8s;hPFemG!2=eB!NK*4SWDmrtzwBIz(qGfVN>)eqt z=}2~%wc)hFmvS#>C*450;#Y|TKn{FKA}kw+w*W8T{ zGkDxE=UZoT`t*gGGXPPL%Ae=Pk&!~3qF=|=x}+EABsiu0ozgSYEX>^mbrvTDHYQI< z^Pra(5OAfy9f<}!l(gRW!yAyiPiUWM0Olb>T1yDV1_1}==OY6Eq?;!;NQ!Wmq!nIT z5d?Q3yt_C=t}@W`LL_z494Cjqa~JvS)2v8BY@K z&F-bU0pg=NXYO$V>s+7X@_h~$m#!i> zF_FSe3m^>tGsa)%d1U?ahKE<_YA>uM7TzB~fK${DFt{#}15yV>o*^1up6CIDWJ(hc zO#}hwM^1q`0@5F@5+IWK-_dzrOnMU#Ku;9ygNe^NXPz5Cs`SeXYug2XrtFv_0XSOx zkJiFOKq3N^^=XY6w&u>O0D#*A7PNMd6g?M(QccN%%P|34Ity;tBxl0&8*~;&_1;vA z834%HFi~9hPa`>3Z(uvnl}FfNTF0H6Mi*5+XndqPTp`pTWjc9bznA020=^)JsJ5$IoUgq>UDNWNwy0xJd%KT7tGphGC@^aK&*| zH9&c zJScQIs7)Nyy$@=w2c>KVA?1-D+ATS!H&*`1xu0H)rGx^Or^gdZk-Al`_L2OT0e}>u z>;B&#paJ`z+J7Ak52zp?1+$+<77$K!P+Yg#sR)86WIZKOfS2YTAQ|fZ+`;d}L;yg< z%VPNNi18=XFHgi1zz(h`hDm?q@BUb+3U{c|TDptabuscZ6uB`d77t-0&!x3DDUcMv zmf-??BA$j2vrCmuPww)zGWupgZ(XUF@r@Gt{Ln%*W1=i|!$bkJ#}Ktp(4G{xvIwg* zmGS6ZqG7Q1A@l8>@IImYQ)2wzmT16%i2@J}(EhueGN$G8%bKPRuDcfmEu+5cY*x0GyG@7X;o zp?-N0U7eAhWTv-OrSf{ONXN{LD{9sqPeg!fh^s3C=(0$_hLj@1w9Jptb9E0-go2d8 z!{HCWE6~~O$gsg*a7yB3b#6=!gctC+B3!nm_}g!)Xorb{FD)KX>-Izew1zEtOUxSZ ztOJ0zWW`N`{yX46a=;7__fF6nxw{}$I#d+AHDE#e;|4=p78qclk}C_o9PmbD=9#Gw z(E3eFCa3jY?j$H#oBlv5pAO5{XQo{6u|x#)nyHIYDF8|E`2hd|J{~fp&zaQkJyb~d zF}Xpa0n$;E(mBi?A)*O6)qDX!z_$`1_-axG{~cgJ`rutL^a7d_Z;mX#BWVPF-mw6} zgupfx2K2#j*%u{XKTWy-5Ad@A#V6;2Q=t8J)xk$gpLxCpU_kOgxi!5u%nyKM`^7{d z-;xmXtIJVy12{?t?=IUidS3F;R4~B-_+8FBpkI2!QwXmLAV4213kWzlVeTUn6*w%; z0|aa7{SiICOQO*^L>y%Y+PbZ4$T&yOE1l`VL3bw_fcH<;l%C6EK+*!_^da?0f4IjA*ESUq zHYebz#RXe_Z;0Vr6`*j{6zLM_HkUyYVUav|60FWTL(;4_^*o+XOIfC5f-0&JeYVFp z-&9dl^eX*SD4`yGL;wK80!xz(8Y8!?8)qO6-OC{8P!(VvfCPR<2WVD`Wln-IFM~I) z4O}6`yh4g_#l=-(H?I$wBO;(1?n^oKgr2(q0llWJgX5+p5O?4Od_N=`DIw-{(@v8z z6v9EEFPF!?FW&FZDi20KeF%lk6(MYWIbMmLp`*W315N(2r;VGDQkc_0TA}AyrHxvx zg}PbF;1+$(trGrQb?-Op^Ka6?(vUMQX(`_k&==7bIs)NUzhL6|4WID${3HnHleKxa{%Tl2g%?QDF z261YOD6c)E)JU7?vpjTZql8rTOcUB~dRTbuYp+sCQ#TX~d|GQXEoDNtOdE5I`0fj9 z2mBlnK(Kv`yw-jC_Z3cNtZ#!V1IdU-{n9T$`$6*`%G=!AUvl5nIrCJ%Z;6+P73Vz4IU8BoK;!Q9|(_4FC`zqe=m=-H|+WB_G{eGSN_bPJ^#*%3FH^Jw3@> zZ#3z;%kw+kPfz#TeJq#uwaa@+>2={0yf5!7P}My!X^9W41qbF1Y?HLXkri!Vta1lJ zvAm$pmEj9)84yEtfE00C4n|w@+eSZ7MkvKaPX>1$l!9xWn*Ij@eyyDg!W zwC=@Cgmy_Z;DPiI_@|6LdIs!JJxeBKI41Sn?kp&yJE>=M zyYPP`RX_!h-rpmvB{vf~FK#lVb2ah07<>Vb$43)i7Err?K!En%{3y6mYbp&W5By`& z2M~#8b1tZoS(a#l&Y~L^eZ9C=o?`$QpyY7Vqy;8&QTZgD!YmWFB-XyVI!B*PBOxZ3 zIuZbR_pR|x_4g4-(psO9djkAdC(?I+g{?h~__8C1m z>;KkQ=fR0OLOT9c(vCWx%&r-sIsw9;KnU$}4G16;UKBlgR`eFm%O2&(m=8dOzz+ik zs2q^}aFd{e0|H2sKDQiJbEvd;?hyb8_;@Z-t!F1CK%^TE7F7X|0(YqBuyg*By8F@QG8`b6YI;6mXL5=jp$i8u|SkJo?U4dJ1U_Cd(o7_?Lza5!b$90UuN0-8- zjU)(@S=x9iG(6#uy05;JPGA2#^A#D!AILyzVOB^mRtg}jlrmYVgDqKYkE)(_` zWAVuwv z|MGx>Uo5OG2i!Ww|L}yiu1GEmMzapOD?$Fd0IUb8ER@IM9_yzj-1()Dq)@CfSnk`7 z0+o`RkjF^{hn2AQ#;stbco-3Fg|GXYCWH*{Lq^c~e^LPgG9FrUVF5x9f)W6s`y8|F z87}3BfE0g2atw#S`D|+5FAm8~>+dnV-%SJy<1blpe}BnZ`@oRtgj!YQ{m?58GGks8fK%SS^dq6)Y|)TNWPT)zPYAl_FkN( zSfu}CTzh!?KTrDLynq7u1Ct>VQgt8$+dV#@;FRJSbRog8fnUe)>t2~Z(0Y16 z!I#1z(4KoTA(5JYR?5(o17Az(hBW1d;RWdPr*BWnlC;2NN(KiPYW%Pix?2nHnu-B^ z)|A$pIUp{1{!8?No^?{6F*y|w(5iCi$@3BwxFDoKdI?CLCZ+5>vU=SD0+X92Dxmjc znkB8QZRjBcQx-fF8Af+YM$9dMRCr3{8}fiq^e-MN(;E**{$K)P*EV+bQz)c-Ca+&O-g{CD3V#awvGzyjmlvgrGcAX z=l%g0BhseZ#&d-qr1y4rLG%D=LFsX)21pr_GB`KhF29FMK&s%(I2Je;a@wye!{F{!5~A_@%G-vS+uE|cpq}ny z24gMdGNVJ@*FE>NA^k0KpHgrugo0Mdh^*EjxLHDSi#G2T{rzSsz|{git8{2q%4=C6 zU7{)Nbbsq2wER|>)3{~-Y2SpfjB zUuE1qhnu|r4=OiBH!hFzCFBpQmUM;Id-#eVYeH-Tb;yj&<>k0R5(juR2OQ2sHvj

f~beEFSwhoG|WSd3V#VsFV{!v*;@4w!eh?F(?rCK3t(@H>9B?aLc@A zzq}5j9}%mKlcT;V#-7l1FClFVzxJjjCDjs$Ye}Bn@ejkOXLBdM>%*+43WabxB*DXS z5vgm(_-|1JKgwVGIv;%*uf7a-U-#9Qy!4+@gRuGnF#T6l>u)$dy>Hk5^mLYcq|l^< zdizufa1YO(w1Nyo7vk>*H7Ke3*Q56y{}bn#_evdEd2A?(VVqM1?`z5x{u zI=8M!&>5$!n9^E$6|`^4v%V?(00B0)H69O9@SCX|fGeTT@(?80|CA5@HWxsBi~7AA z4K>0MfE%E-a<3AI&QulrJ9~FVqB_SVrL$v2a2hgp)BmnW&a`CSGY0gz(|TSH7=keP zs_+7|UsEz1ZXdi;^nhe;YTfVwq#q`w$LNmAU@^B9ChaOCIVo?E85NUyUpk9UexNF* zJb>ubM5u^dtqxz{AK?uA;0Y0epOqYYTrogb28b#z+Fv`Z0PpH^k$VV*&r6En$(1JH zXY&bmOvHfvzxLhz2y}nrIvXx4+^y1Ublh~+0EAqs1}MGNx$vYy87FrXM4wBpJ%2#Y z2j^^5dci#eILC)ouG*}1%6%cWK^lBsahyB?eIQ2fh8XcQQh0fHx^u7 z;C=(xw8QgNGHtdz5rbm_5Fi*5i6Bk;o1_W!jC7bC);VwkBE7FU0k5p6D_kab9Hin& z`{yP>I%}RWfO907r$WFD(R4;#Iz1An3T8i~zr{%dK=yujoHpq-w^oPsF9773D_51% z=u=}FeAm)*F*P(Qu=zYzLY@!?eS0qG`jDtJRvCu!f2GQjB=CIl3r8F zd;&JDHgrn&%ji#r_7L{(ODJX~_;at0*RFe>kwKi%XUz#z%BL5Q7pyo0wV0)X*;8ZK1ljN z_scLOPx#ZJSuRw#{HZDV8;Xa&L71dJ3z_7e|sBkPOZ87^<(^XaBsXP zq5u0U@8mK-DJoiDf@)p*0_#-=!(*Od{%dXBSYxxG&jSG_lCT; zB;n^RLn?y+NQofCKbZb9R1G}Rt&@)?Bn|7IXu#j%vC6o#+S&n^I_KiIngwM5I6IYymt33qF`6vM^DP8FBzL5YPVB$xwOIGr}|k?)za5z_O%~< z$x-juHTS?3JvuKvy{0EH*LznDLh5M^ditN99D?2!6%})&VAFsBA_Cv9)I;~y5DG~Z z>{{o>kpZ1yH`byGLB_o^n-syx;R@(pJCFpmr|o6w8=!OL`2~8Wwv4%Z2z)O*0YHHi zY3ry&1BehDmgvAi0S7yVBk=x2U5K_&(kW2nl1mKzuaXX6ufCJW4t)c54Xc-Cdw`QpRFZ=Vt;SAy3&QhA%GOz~tt|E11+hPHqvRq26;+Kxcw1acVB;{Sy@sIPo~*UCI%38+G)@-=iBy5B@j~ z0%^qa0thf}Uy5;qRCrR1{?&0dIspVk21p@jt(+FXh(1t8lO8OdTqwtZsw$TjYMsmv zAk44xKlDg08F;s2*JlptIb148q?DZgzZR-9;H^ogYJc7H=B}h(Kb~j+>44W)RM+WV z?8J772JQ;_t=VUl~vT-AQ9m0tr}d{#hUMh1IEhigWMa8`>kD+Mtlh0)jM_O~y>5dFy+n>zlR3hh$f zHmbwmCO?$fEHAevE*Y;u3BcgF3HieZSQY@#4?$4RGAJaue7ku5 z7=FV4M=n&Kf6@c;;A!j2bf_Dj9HX!Q^Gtx{RchkMz+bEM#H>?2qsLT|lR76r;Cm5H zt%V!^z-oofPubrK0s^*A$cwU=ks|(i@CGRW39Om482`@(mFii{(EWZwZT}8}JvfK+ z*nj~d0(urt5<5ExAC@o#A?k=9Ntke#cnq&ECM(m*OgP#v0N}#`0mC5!zA&t2lon-C z->=Z-#Kuv2mnDRXr*v;cmnOeair0f+D2sh^K)?qR3AihKfXm}iwksD+B*3IHcmYz* zuKAY?dg#y33miK9d~@>F7^!C$!+{B0| zf#jW;BSZo^Iuo>B?&yqlKAu#@#T9XM>to4S`_oAY0EG4lQBZ5q(&w}!AMPqh8KIP= zy9!cuBqQ9CLiY4S8DUow=)LGn>S10J0R>AcipLP9hMun>Bf3IZ_yUAV3Nt%>?n0#|C8KlWq<$7V# z34j2t*@T{L;_Rdf1ZXENNvhxl0Rl(l_j^~`%xMFv2rkM+T7YyX6$w-)Ngmx>U@qs7 z^LT2`CRGDF2LwpJjS4Whk&pnb`+7(}d(anAf!%fK*=VQk^xrcQ5!fJrfb_s$0}Q^G zC;))q(L@w+93(fcFrxp!Z2ZU}Q2gH< zl;?{I0U3BV43dnyA=+6<2k3r>q-)%x|KR9O$tN!^~FXe>OdLz0SkIN(J4>`s7sFLw+iP5aXr`<3+!CTd@qXvQ67kA}~L1MtbZ z0hBrlcx>wm1(6FSzeU?k#*KD9R{1`NMSZ=|jD&7h%4AMAI{$PTQ6d03NUNk6RtrI{ zIv$zFmZji4SVh9bNLJ@|H!6isjk24KY?^%FdKF&gP*4vG zQiIh`?tbvbVH}(;d z_C&w$S1&xIoEkPbLLs2uVqDIfBAGI;I{ zFp~o=#XJhD7-EsuU{rF)JPFqyuNUIc0YxBnk8=n~QY@ZS2?&r}kL#Y?Fom+KrzZjc zLtFPgskNBgDkLnzun&}{Huc`50+2l!C3lKjUZH-Mm|Y(-nhrXpXbktU*H5|M-jybx z5si&M1T>wQ<^%CeA=&N~&mZGOXFSP>hxTZX-9}gE(tZEuLZEwD>iz!~BH))Q&)(g$ zh`L?vS5N=j`+OO5gIKL!U!c7&dFe~B_74dN(7yMz27M`~zV5d#Mc$Vp>AyRF+o#fK zj@rHX2~mTyss~74K(Z&{zLRw&c~#j-*%IarFGG%Rxmd_L=-mq5%RDEdbe6K!F^N*11Wo2%xrh z3qRnFq+)IlVNkN1XgZZh)7rObNXdH?U&J5)GN25s zX9?V#w7}0&F|aD2;NSoOq5{$Z9y&zYN&7RkNq**aCk80s!AtHY^?8$8>q$8{lS`5+ zxFTP_9Uj3a^E$o?z)tFYCUsujrSSMlBhadtXn}!%K&vYZ#sh>Yla<3Xp=Wk)f<*xa zy61^)LK?&=)7rVMtlrZt%hA)X3lPv+jOpBaOz}X7f)^JU@Js>v3mh1-^dF1NYo5Sp zQhNY=O5C)EE^~f+e)pnq1b&gIAfSL6c*%$dt^o>kR!uG>jo41qfYQPHqE|=-=-J#= z7F~06q6Dug9c69+(E#ZN&u<|Wp!Ie8VR%jOn{?l<5cpRNFD1~F2||vhPk`iiNax8V z(|Wy226r#x?1pOX=vy2w$^+jOKET`a6&{z)>5W?^BCuj@8{&)s?Gr_uiO51=9f)1Q8TL zk-opV)+F3JzB}%?-*-HJyrcK-uJFFkv(mHHTyr5*O&nTNCvt%Yx$!2O)?g#+2uuAL zd3q74$@o|rT=i`WO{%e%BG(ybA=Qo*+yq}uKvR`}S22Qh7N?~aJ_Ngsvb8Y8EsR`? zO=z=F9U=W$hNuj>hMDTD@H57vsvdi|Q-%T&9pTy` z8zI_ZwK9%>GPx7RF)ZV+wDO6_gZB;Jl4-6%1XOKxa>hL zm%5LI?;6*vh8+Yb3&45?-KA1Un^=%p?`R3U+<1V;G65>!XzlxfoLy#~!Y;5f^h z2Ff=j9Dq>i>ICTXN%1Y2sS0#C$~uYR3Pw9lIzcidXN5tZ!Z=TTcQyOo)hkcH661Dp zT0!y4{l=i3Kl+5MOca5Y*!e2Rf(Cb0W?iR8mZwi}S?z~;T8|X}`|b3fo2mXPfk<_K zJM&LE8^Fn{Dt*GKR5>wJ(dp{9{r4~W_X;A`WL81bGXqzkpaMr;B{-ZeJSj6E%#Scb zo4aJ7fPnq4plg+qg8B9 zib0$_UvN8Y?{0y9F7&3zJroJTia4aAz=Jy&546@elFc)VG%h^AjlRxLtW}T+eczzd z^ZYy3dVJE^gFQ0{5dTRyeq?S;SSa)}x(f&@#?aRQ7oulltj`#>T-+pM=s*Av3zq2% zE$at47}!1o;88w%^e*eex)~q@hJgJZ<$I#@;3Td$7(cUhmWrdZMgT$XImm@}@@2an zfdKX|<`7J|G$1?|_GkET2ki>pSuaf=3=RRFX=u^`!J_pHB%ht&r{@JB~31>zX0H{6iTsvj#Q7{PZyH=l^$X*R0HLeyEX27=l`kvk~L zEDt-&Ld~$K9sbrvVcP->;%r*nKnnxe#ECapu=;+O8cfDsty+1 z1T2>L1Y`uKcgY%k{l0YGEu8C&()zq^hUm7#y|&rl4o+s4=a{=9`~DXYe$%Q~D)q{OYVP_Z25I5~r~XhZ4GS6HBWuQ^Kge`iIDB3&#BH?D zu)!m2%J7GBZ3T?$lat0!_v~(_!}lBg{|N^LM1(!pm>h_W?s>?me>r?!+spd)zS4mJ z-yhTdc#hty?eux}Ue+~w{!z*p0K|HUPFbaa;GP!J^hN%;te-36iCVw@O@LTskE_URl>n_Od=9~8m9?p2 zfNPvKt12J-%J>(R>G-}Hr;FOgsjJfYssaqwv`P?IJvy@mQ9@u{rY~_v0Wv;~ti({I zEfPo=t%d>wf6W;IbUJtn*ej71RfK6MuI3B_jAxm>DWh9KezcQ2h<@o3fr0@}YBA;T zKm#TZ$x=a#L9QjPD6%W8+Z3M}ErmG0DT0#d9uRm?{0qa*=%723(s|*G*n15mnm}GB z2zr7O;#zkNd~7wiB19t{pg?pdNP~<43id$Os>pr>k&uE%^sT6rKl?7)@^N%zoIQA) zQ()2=17#9$-0H>}Ki%ah^j_nL$8l~!G^9hC@Br*t3?q{542fWAni;Tn|HD?KeP)Jz;wXCtnL&#DP z;poCI1<4RWXpn>L?h9ENVx5BqSO0#64-NQ+02C?{aI=E}_B+}P)jh!81+reP+bU^3 z=yHGnbaPM21}LqL%^1KA#;_qdVRfu2!^@uabDx2cB6x@y0vFg`3fy;BmQ@2J*s{a^ z&T0|`sVnQ_4ge1Hp==)q0lPT^aH3x;3_&{&Y*C_BkfH9bZ@ZN6>CEQ#;~Szy`)-#9 zUh8{8-h$uYcbWyTlm=20)|46%3R9ESM$Sou>DWIL?W+2hB4a60q~M8~DmP~>v4#*f z5U`dI_1xGjj&2U)GmCQ0U|46^K1~c#0|QZK6Kl`URHBT4#+Mc)hzM>l zwtY8Ku|;76RHswj@6aqqsK2?6v1nijTHi?E;SA1q7UMljKroB3ni0?s!J5UG&9m5x zeAfa(I?w&j?Vh-R&c9_lW8;|QE~w#@s+(lJQYWt%X7si+?wT~H48@oNB!Y`k452u- zgUJvBKeAn(JY#AWk$?2Us&!?D6b`lU1ppA|-GdYBQAYrq-E)Y8fODM%xHef31L>~- z;3zwLrT<^D^0NB#$rO!CRm7t@b0fdpGSLDpI#xM?nXLye2Prc7|r=~Lkce^C; zQlI*dbv9rZ2L%G@yvwD5lO3gB<2oL}M(_iuK8S-ANOXvkO3(tUY@{-l+L{PNMuzS9 zb(+Cw2BVs4oXCj!tD|oESsO*1K#;Zwgf-&~fQ&7l7xUp!+9I+P#4z&)i7h%^{8Oij zyX+`1T$8LtwEZC;K~<|#f!fzF043HjM)|%zbtzikzT?_HGWhuL9@Zr2b#W9LPhIKB zntOFCJ6?6F?3j+Ziqoui`vl+c&k6rj{lDhd%Zcyq_sN-KtZNv`8jhm2Y07^M{jYJa zH5_>DEjcQ?_BOw7FTaNSuc`#_2WJG%aA^Vgnw~c{fc*=qZ~+KE=uE|q#tPh#c!dgj zQ9;jxeNZJgl{N%$WG~7Daxszc1h+Y!oxtDdeAvn$NOZN#-fO~POe0h#@ni=B=(Z?_ zOY7#kPhrqCW;uoseZbiO;dcIMoPbJu;|>U}dQuR;cTFG<6WEbp6GWDyeehD3d;}6? zU5l)5QNU4Ts(7$*BkB~u&J>a17&NqZW(uNfVA+|af6q&$f|yW=p?-W4A@2=Pp~?Zs z_c-=%Tv(NVI1u=qOI91Zj3A()fQLN4MqURHak~s2B-3LzI~Y*r;2YL~cO^a`xC!2| znsYKZWQ<|+gSC+0V)VbaSOrxU;4?-xPhjrw zyfFeQ5A?Zn=U8X%q`RLnpm)zKMMr5sydLXixi8v(S=(S46m9?qK6Ih81fO4hVh#ba zHpFueaUan&v~y+;RVs+Az-pEigKtC`M(kq%3DqI+#?00RR{(nyghI2%GAXl(y&QON z*5PBYnNHj2dC&&`&OZsxf&o@#(o=j|e@)s?jeqZdsvWp^0?_RsWm7ibVxRH}GJ+>S zCEA^xt;MDWc>8^}+mDq9bb$McGqu?I=qgZ#SDjuzc1A*_iKk=$(l5NgY})Jo9})nJ zza?uxTKuTLsD6qNXq2i9s1T;&x-KFVB03R)$<(j14_U2zRidIg0^LO6+x)w8M>^p- zK4%VNIg2vSBHXh)bmyoX$Ri9uod>O90H<$C)Us-TQ#fJ`^AMOusi!d%GN!ft!fCv6 zB7lV&p2q0Z5uPT((Yigc2eaJA97b}U*Uj&h0mv*uF;8T>!1pe4DqdtW7Ff(Vl__|> z_I$Q8MmBs#0$5j z6BF=4eVupF+9DmHQ- z@u{DaRB-*PW$-{>JZnq?6i^UhkAV}y0AMs@4Dq851dxG1qDpvBsOVk2n(J$sQWBCi z(oITvsn_+B7OD%K1?YD4E1|-eMq8kir(g+AgF6nZg^^Dgr5;+by$`gP&}CMNCRugh{kkoh2|!AY;K5CPD> zVW8l8u16Epl~C*;zTvyo<6qt|yKJH*PU&yfK8SO!blQISX$F-8_y;-*! zvQ#_RpR>2WM?amxi;RJSkaIE<5pzM<>uC&K5Dux6K%GArK$!=N2*I5U9p57MI}3>w_mm+%qXLutz86SWa;=WE;S+9|!*<$+$8UiM#& zvE@@c=l)FcelamlD&u*9F&oI!D@WRz%?h-tY3j+ta=UC&p*}e`U#@Zj1nX zI(lB(zfo*ta0aLo;BJ@LxW|}Kh`eg*Ys?MVfpR8#NBtn*B2obUoQ!dFe%zVb{lJ7B2eF#e9??efg0AMvYKE_49I3q3fcSbaaV-uoO0GBxN5SdIo zlFm5V0=eNT8(qhEHxa-V58gqbW{-2fJ&Qeu;h#fLW-z!NPAx4Iv%!YdS^Vm70*C|< z(il_CWS{tY3jP=iF}`i4*`$c2E7KtdBbic@82&on(Zq~MDUgnm_;1O0!DF8m;r>a{gK2YG`CNN!#a+vru62KnYz?ql=4Rt10lec z41jup`U^(CX`k!`mc{V|Q{5L_OUBp-oh`CDg_>c_TFaG{JNA;B>-u6uwTN+u-jFWT*biq^z#}j0@eVb?n5^ zhZ?$7WAAF{U;W>Fy)H{{^*82c)$a7`aoV*%WI$1WM+Ww_zxns&Z2zrY?Vy2Rv&P=n zu1Nk3v4mFHvue{I!B=ECB030K4gypfzVq}LqKcAXO_7S(UnIlA!}Xwom(c)bUB4Up>&ilVFfUlQ>?`l`Wu`A0${3S zfD_Xg=E=30tqG0>{uZ18pY~7IJ{SdgzMvLH-X?hFi9weK)CHn$5bihFAKz@dsSKj9 z0XI7+xWpXJ-I!Xha%42X5uZx)ltYLJ*AkV>0_&Jvgq$4}$VKA@(;uS#F zgMDz1ED4OrXLMXM|_+IN=PzyIdA{xdQ_3LmdW# z*w`3CCY+IY29V7`0;^!uQ#L^T|G%?M`kAo+tj)lF4g`d(XFp=_kjkH|MRW-0v@Nh+ z!S+#yremFkS399>?=6|Ck1T7|B>{r*zy%!Z5`eG)@BM#q{{LT>@LuZrI>lK9eKyY- z(_J}e^*@6EKhG0%z;Z`NJ=e#>XJBspaIF$wq z)8e%q4Brf&Gm9gbM_}iPw&q@#EPU<1CQd+U`}$xSt190yEkMt`3DS{a)f6s8vqc1O zawt=#N&||WOu)Yy5oAsM|2X+3hM@gfll-X0&*v}lSxZDZi`?@9g0P5FSmZ>p#KJEk z2=k9*urR~@bvOyP-<4T}7Ms(=XfKd?4?$254yxxhZVBXhd%oZn!4a-mcLA{Z zK_7fq1_c2SR8aAB|5T8m4gpRyy$UE$?A}eCH8|9P0S>sAlWy-|I{#j^7e3+$@&!&a z>Hbw``l_=4H#%}uDd2}0$n6ZbG0)8 z6D|j+wx*UFo^@cr*@0GYiN062=l-x~{{EWlf`6c9Y*>bkfwgV~Ww zvu!EHseZt@=jUH7js=qy8D`eWxvUEbBVnxUGBO*>k}h!Icb-Wn;^dt_zeRQ-1&dC(?d=w zpU9Md<^FV#(@M1yWN5xceQS5sU|^cubK}ySdRfO<){(b5!DXHMsv{S5WVO!v)d>>o z7?e5&x&Eyjl2t#~@4-RUUz1?mI?qtwi|Yu#_dx&qp!~cDFfi`5Tb(8Nxw8Zxa#?_Y zxQaay4S4kscOD2IfG$k4XCeffCIG9x)}03%x!v#;&IGVdK^FD{cMBks6=bZkm$L)n z5!fRGgEH%^>71HPP`=Kc66mu=6~~2v4N{@YoE136L4aBc*KtWeodOt0k$X+C7tt#C zSN|ML>_%Ly*`zXo;u8>`1G*NI37=}9;NM*yAfSm+(BgzpXULZlygY%-Y2H9^3EXPz zfPza7LBSsR>y)p^5{x@YAZRH*EAasVF2pGo*?$dFD?Y^;f^!_GUTvJph7J_OFMtje zpYDGPU%)zz-)Y(YfXfLg5pZ7tE*x@DEZw-)|DQKL=88Nhjy~Y-frbO>Oze76s7 zn)rao4ybKV2PO0=_&7f5fAjglCGgHHp*}u&ko%3vgE+Z-Jejf=Ly%Z*3k zd1L4hpBpWLbIxMkWV8fQEDTSsdbrco5A zL@6evrd0nI3toVdxT%;`{+A>QsUc7e-q#|+>*%!47tONha~Rcm9()dGGs}Z@SfKU^ zK5-+=jkEH^p?+ckoJtr3Q3D6XE>VyOI)vseb1%~`PlF;3fd=2*K=GS6*%q7B;o)XE z(a&)*SisRN@o-Bh(bAQ6{3z0rezI|k1QYWZ-#I>Omd}}Cb7oMQ4$sl%YJEAm4eA)M z+6NNYq|S%3(8k<@NMAH4NeJIjqNouBQz%psOK9|D-&)t?d7j>HuI6xu!`$-sYG(n6 zetR(Bh1Dko0DBu0xc`%~0DMm{0?xZNaN5K``d!0W0;266J}0;Wp6|b@9S{Q{#z27% zV=VAvSb^Te14K*UJuU+%N>tD3{;P>dRSHU20F3A3a|3S5XN&m*>~BBM{P4H{;E9B$o`YE-L|6Bu};tg3)2M5Vz{hgl&ZJp3B1m|G+2k`(GCLmtUAF}9r>^S zXO^?VaT7$;6)dyw_3j+hRp&%gXWi?pd!2i(D~rea)G^TYqx}9e9Uv%BxGp<=>a1z~ zwayTzjK?zu-8bJ``>X>1oN|>QsETu_qJLF>Up>j7#NB=E;~?RJ)oeS&7)~$xS&_w< zU2wNM1`5s&Xibo#%BAKL&^qyb6%4qT27_K0TN7i6Pcwi}4*#zP4f5PUH%t&!`p*Ok z#>|0VItW1Tr3wJivir zf_0cc&Vp(1-FbKjA}Mtk@cl)eQv;(k$~-az*wkn%0*3uCC! zZw!nT?*L9X7zbAz2p}J$tlQ`*&a@qGeS2R913@RuI*ceQ*XOK2pTW5T3}Po^aMu=G zuP}~E*#KlJrh8t*b(t{&?|Bkv@L+=oSyM3$1_kjuG9VaYEr-$FAp)Q1B;cSnbg_c~ zVFuJj{9XqGIz+5%Y`{IXG2H7Q`VixHw_bgG3ZZ5V1Qy`?&Ss9=W+?-#cDv(k_mpP; zivs}UrvEaROiwo^fJ30#tNYZI#pm^X*LGHIfvWBEY=HrIp>6Yjhx7kmWd}AQ08rE` zvWw#WnHCK?NFq1&s>U#sD^rk^>ME&5d1prI!4@WzFR!Vw0F7;v6|jwQ>mb0hY|Pvl zINNiQdw-72oJ9aTJa8LB(?qcw0voAq=(_A>E)%V)M>p9P%G62^21g;++hmvJ1+`ZtDP83kR!U@Y?Yg`KiIFo&|t zqOh~#3n=EjX?kGe!c3D^F`N|{>~^*siM4HlXm}h)EK&_2Uxy`7s{N}sQ}y`Y=Bd3$ zEq@4A4~o)*vi9(OJqUZxx()*5{0V4!1P)}~d!Fl`dfhe#3!dWA00yt8C%FNFCk5V%Bj zB@{pA2HfVY++!8j8}^-_gEQEl>9VuFwLG%3x&@K zC+K@s2Dl+>{dJsR0~u%%s5akWc_kpIqdWC4+nFObb#$Ok08+m@`7#<$<6{3BI`LzK z>g++ClX4xIsu%qexu~-j^|k)DT4a&;dehkhp1J;!CzT0=DNuIeFn19Um{xgxmCvn? zxa;6r2L=U$6*~qds@;&i4k99Cd-^l(8hBxL4aCS|g5{tb?l?FQrvRt(U>3vyS6<_? z0BcjOIv8N>%iL@EfW!wxdEoEv8aT(@04u3WD2q<%)_G7-IxVwW?VF%7|aG>k~HZ*2g;4q6@I55~Xe+qmU z7kfU=X*1fHck<6uodx4QgQq~jfZ7RJw=rZVrk^Skfcysyad&n?1vY@S2y!8H+8_&} zZ;t=~IgTMjtYyp}VDDo-2Qojx{f?l^BRsq2y=a(MPz(>dd!TKs0D2tlgJ(H7;QL|_ z(P6%hbzmS{@WRXt1kZr70pHAnLg0l|79fZk;vS=A5Z^N-+}5MUaOseN9>xHoLkvj9 z9uGX?Y$Y-r_$FZjDn7iZG=S^|G0#pe17KJC|I4M(3+?=m%B-+5sR7(0I0^0*0RfNl zAxwCzSN)3||Ns43Cm6LfJ6nRKK|2COsdshaQz^u%XBE}UtW%BjdEAKr0Du5VL_t&# zxf9ubR6~er@60;B#soJoW-X=p2_9wyz&qRl0LEy66ZSkOlvxD3!^yS%6rZv&PE{6g zT2Z`s2KbI31M1J3+N6~FMVSUw%TXO+Z*baaBBV`(uf^5jy)!tISsc_no4N2qoc!fD zdmQ%)hI9=<#u^OB3K8)VpS_5qTzpF60Om1B^IvdVAO?DdtAjwd1ynqg@B4hVMCoLr zUgZ+ehL}MuID%-{SmUBH#q>n2=|~I1zunH zGZ%u@vq_c&3aotrr(7ViETBAv`yCjlYvAL~3}9?~P=X!=t%qmsIo-b#&OmL17|I?5 zzvmy$4s2vVpn?DlZtt)&0enX<5o+&rW&>5 zj6ie06wzO*Ueqg%e4Wk+c!2dAU>#!+(6_B9cc#OC3}qXvfKPQ+VA;{O+5%a_!HbN{ zE*msY@eHBPTuy1HgKYy(&vvW8AMO zS>yEoDyKxxbO7+H1Y(6j#qdrD_@!X^Ft>s6T%vuR_-%HH=#(g0+R`?ee%3U+Y4%f7 z_rzAI@ziSF6HmS}T9K~4ED`U~3;zYT#r@IFUyiVmjxl=ih3Nl@TlK!2&b`4sG>=FU zEB(9v4?FN-pWM5Aa_8O}%A6rD4GenY<2k3Ju~%je8t7t!fUfc3Y=>=NNEdR}pAjRAk;521giR=;+mFp32$sQ7cM&LK$^D2q zQEkl8ZGn7fnrQF|yvl8vC6_sQj+jKq2{kB%1r*%CErSI8B6Ct{GAMtpD_H+^*npDfE4h=f#|I-}=mu0ClGD*q|9J88J2|tpDvG}*L1v9*}o!=uy~CzDnD}>0Y_IHGPVE*Uu0cHSQO)o+1ny^b6f|#n~e=XCSs&9 z!OA$g8tsTz`FF2%_rO&ym#IX6JsbUJ9u^}IV9jHw7VizJVQkGP&o#>ZjlR@a9039K z9`SP!#ElR%1Wh-4F!FK#L>6O?$6L5~{*iT@5m;HxZY!1e(1&3H=V1I)*_!(wCcqjd z$Q=HZgMfFsqhNPq1%8`{wCE;44u{nF#^(&N2O8KGSpnIV7a6>LqXB`!9qnUa;AYNR z)@`%yNxL;LX*;JjL4m%xcMV4iw!S|ab$^5LQpy4dZ}n#f0LWa7V;A`EeB0YMI9>lg z5ddf|w^*@6axs2d){`clV&Rp6<6$RinIaP-o_PD!UtHfT)BYmzX`tv09A}G%=->=y z*yLG+Vh)9wM?mHg{yB{844c?q$)P(9oi1LVDb4CGnF7>2@u{D=_V(!n<&=bgUXuvp z+OP5?(iG>w?m3B2jDs^opmTc}0LUq52}iKPXRl#%*PyU#IHj(zsLPzZ7cmSA7=U^1 zb&idm-?Y)i*W$x{At03Re$L9wH zrP@_QT%j72dQuhC;E;p`5TZ1YtoyqDf0iR#)+h)uq#&GXf)(&Mr^l{!w9I;o1K@F_ z|4WRt<^Bedt!N449%JB#T69F(f&4}PzxsmJ&%2Y;cZd2X_b{~Jbf8j;LL_5+M_Bt& zoR8?3V~)C<|DZ7d0y^PvG>|2F{RR3{>(u@}{qWjxoJsU=vo=Kmz0?Y(K7ZCNc;hjU z6KWX~dYtvtB#VixjxpW%=%DWzT-%)9RO8zvd)W`H##Fh(lkz`f&p0 z`KQsF>aK3xbYM_clM%z z(QNSf4P>l=UN^2w3hl<4)XPTAzdO!BfdULdT&a>9hmAbkCSf3isrpEf$ zklz}Ih#JOK(>UYj$qo*%9W{(-z~_l&RONu^F8HW}0s*B7fP##OeJ-+p#XGogC`D|`1kVv8 ztkrdZJuOz8#r@oqG6H-~v>GB)!CKg`ic}1{$gp23r^eL~4^22>R3R z9C(>q2)E3DKwJVrD#ZGZe%sjq-X9~0-{On4jIqSX>j=+0a=inA?>ZZR%?W}bbrigB zH70uoEr&eA{|WozO98mc|A zsdX8L6+2lX)8IINZ}#;D@yAJ-MpbWq?R#10Y!DcE%GEN<&n^f6I*Gip+~coM8FS$ErQ?w1)1hAaLRH zPNKkl6nLfrf?L1{6i}c7&s?ZDVECQi-*Uk47Y6~G7(;M_0|3^e=e8^b^ziI4Iq;>% z1DtL=K*8kzWdtOQ2!6DY@Z8ZAp!Pu3qfS`O?f|t2s^_2Q?`NN5I-s%u7_1<`KruBU zSjovHEvj8~W7~i>{Q*Ao&^BqCZp<3K6S?`Z|02nzDDn-gp zr~kuU(?g*&b3D+(|8)QHVOe{OdZbeS-!W+ER(AlfpJVJ(u%?MPMJ-p`xfc2<*Z-gG z6zkY(jQO2lPbN;av6l1ao+jAO7zm_n*~5t}7kQ6Bqawf&z%3j&0hAak#m_(eEM)po zBiM^h|8oL~(YhG$7~^|V1`9#nbE!|!LfT`rYgZbucXX!i)xO%e-rWEXWQMHq@;t2v zQ1BTk!y3xfV2>K;Tw^%_gu>CNBPSd`y3ydI*-)7PBiERDQm}xtZ(su&82tvpPJ?}~ ztE=EP;|o-hc&Y;dfdnTrSg#>dwcq&?VDQ1j{KVu=bXqeCqLpxacMm9A!oF2`f0g~M zqBqlb86SYI2g4!vI*q}d#$m+3qMaNFpidP(qk_|^9G|U(6@e^~|MJgV4nUTJVi;#o zx+4!4rDb;uu%$QmkH$L)h_rmmk=ghV%pzM|1%B{a8w#X6%3PVk7j>G zO{`2o3@+N!87dr*MpqXfHJ*Td2m-Td2LuBy?{1T2fZ}sqO4!yVFKoVWUx6)XIume| zF*2Ly6$6V3&ITx$Mpwp=`QQ;Cupbrv2Io3TU@>}?!Gh;I2>+VPaw-!LSO>N6urKaw zr0gz&DF*_3X4gQB`c~HfIvle;Hq1@};jlCUJXi-+F1W)#k=fzBjTu0fhVdE0yJa8{ zZG~zZB-k55hJ$*T04aC_wl~oD8@5S@8W6~#GR6y|!vm`s1Ux=Wh;>xwQgl6G)1p1_ zIcW>~k=K|U_-&U-AL|BC82~#Hcqz%6gUGJP!y=feb!a?WCL3mq7H&Si=xi)x_LHZ zalbtMFXPbHAjoTRcxw^bH7MW;4u6@~EI&Ij0t>uokSU(n}#$JqeZpm3uv*1XVmAb`<|_Cl2d zzHb}=#;xa9zV0?K5a-l;vNHe(fA4K}{!0IgSVH}#hx*j778JFQD64^!i|JKAaRy*# zN3x%GRI3tz`d(4e{y#Ya-o`aCo+DaiZm_~|N*ToA4zj*6s`KNHvP) z10ch;hfh0d)mqPBE1bjx`x%2_1m?mZPW&OuW|OD54y?X%q05o=@=FrWGQFL9;rZ;~ z%s<3{(t8p|6SZpIS5~>;NG@Rk1ggbw#3)~-{#lo*+EQ^^F-%Ko_G7XwuYQ%&`g{6h z&NFG4RfF|zoa~EzY$)4ywgZKNPxpL(lYMBgZVgVuBJpZq(3&q!UXA!0vMh#80S)!~ z#_t^{==a?YC{$9|!ngyK^wfQ@OJ)b_yC;UG{%(U2-{tNC{#N7JYtrXWJ42xMMowwL zZ-C6zw$5yabiS(YpNBILh*8GulUNU@Z*x#^+GlT+> zKI(%7&sk!9j~Brt7&AclSt zd76}s5HG}3;+P^B&}%Mrrr`Yvs*chTauM|63MBP;`#K=tggb#_2!_cimqq7R6CZVx zO9gz6*ij=W_*|AvC%BIZ9Bl9s5Y$Ytp3#B8o))>+03WJT;Ma-!iY}KEoJly_nS#Td z{o28q0Q4-{3cu|x8D$8#*I*#TZUyD=tjhx&24e2O&WVvy#w}WJ32MYH8$tMxvjUum zgP-Fi#s%;>BYb9X3#g;usctF6PKi z&ML}P%1YC;N(g321_~k4l(DE;-j*p!fpDgANHsQ~K{V6;HU7ai?O#ZJ z0*7|n-}|`)^DT@gz;79&vVwtHgA%Oae%J7x6*hbsfm{B!yq1n}89)R@MCct(7H#gO zjl#DO{H8hqUX|SjB3h|(uhT@Q8g;5VqEdnr4?0Dse%kM4v^$I-4L+2pca7QY#o+Z2 zRTgkO1(df?vg1dn3SCa|BXk7>tbpSyuto*$zrgznd~SjDFC6C}fZ(I>b-(sX2L)aJ zOl1WAV61?EgREyy(Om-#0|wRq&mQ$6xV^`@E1+TkpxOaZxM&4b?VtULTGVkq`78ZT z;1^WEC|UnY9RR%fNq7LIxA;yCq39R54`V&Br6XY>W^rIK9Z*i4`wZs4>wPKRui)Ss z|C}%o=XQf~ev+Ah006Q!L)_C4(Yg4-qxAy&Gkp_Deqb%c=AF<`!8xXkrMP1l&#bsriQN ztZDEJjYs`D_OXcrZ4&%933!`3J7}o6jG(N*=2>P45TVKs!XvPkb(~ZkJ**SBYWinn zEtJL30RqEY6QJ=t2Q^1J7*Huet-c335K!=h%*Wi159dLlN?=yyUZ)ABrd3+OaZT^T z^=1bF_t;i_!5D!ZGt&~~0A&K$_ZX&xAun%fY`|Z#H8UoC)*TdxuVIhO48#cHAGs`W zzPSU05!l;-z{9@&=yDKi7Mu`w`R6Yk3P9Q@8Iuy=;@0bw2g?)+c zmKzN!M9+%Iey|pvXCUGF35XqMzk;^-s04_MR46(GZgcm*Pu)6*-w0wMfo!+6o?*vF z|6$p>vmo*6}M&5%vK&1foCZ-W$-(!}5@Jj4mOc&%c z2C;*K?^sR7(wEzgz5WT1;NZ3{6QBz*JZSek2x&53Py-{U{n(iPt+NdsyhRMbJOVw3u+DH|Yw1KnWLCQ^ovXOZr%|x#dlNw% zbfpL9iK6i=*C`R^rig?vzHK&T1|gZnNX+5H=2759ob?idwSr==;r`dKkt>|ORyK0& zpYLBJkXa2eAsDU*-RzHmxAk6`{9f7!FTG z)~T>4@YoA8{Uy>1wWO$5T_6yR*wy5|sQK&UP83+U*v=azD}37y9c3%9CIuqY0_#}7 zS#+Z?1)OUEMJQnK3Os+|iw*>IUEpkivIsS27w$-GKo6&!9+aww_r$1SbqgTCy(n`` z7JQep04Qv)fGGUFk5fVL7bpPOZ}o}!0CM~aXfDa1rjPv*#zB*(`f(cld{+OS#sf&m zaf-o>Er86f1_NG^DYB^bKg&uZU=7Y;koN=?C(d$k&_TdecKknf27uE+^!*FWLr^kw zuA}u|XWLH<8DZ~&ZA>QwaR3OA#2$>|s7G-wG4)K~q&0amiHT?`1qjFSkU@ZZ84;~E zK=!W4vlV}7gQ=4k1~SNhkg>@VZR|0GQZ|@7E)fA2Zk zn5I_%V-^gyD8bM1<`p;U|K4V*h zQxHXQv==V8RM7A2fI!GkVXX)bVhW+Mg(rIrk+T>+^cAn|>x~QGcV%=Z7zKG>nfndO zV9_HE z5?+u$)t#atRMCR?EeEfptmPMo$^u*Y*7_KE9+dVr6)IvChjS&s^C^l>Khc3_Y+GrzGSpZu+ z`epzBQ_c{etxE!DsLG)(uqrQ;201Cd>B>|NJ-joNR z-~<@;A&J9KKl&RZf?t#wfc^~}0I2t$184xT2`2t!Er3rB00hFBzQDDzy?ufaAnDIm zvWKmNos8-mEOz7StQj_m*4w;q2B$d71I)9i3y&t!ehH(q#KJEk;0sF86K&7pd}js{ zEZ9)W58TD&vM5DO^C0tR@Vh;|->H+QHR3itELpHop|vou7(aei{P zIg0VH?AET5(tsFcp?;NO)7)>d$ORg9ht=Rw5PhX;+3Er9MF4v+sD%|f{mj?&IEr7>NDVgsT`&sQ}FR_ zv8O{PItZv4)bm-Rf**9f@FKSv{lP&1-y5uD(|HPsQ;C2}`)Bq>jA){}4mLGq04_2P zfW4UD_W{;YCyWr@oPeYM`-U{;aSG(VHGD>Gvf}kGZ<{D|we@NEO|-Nj3nKW5Ho!&K zrFBYuu1~0}bwwouLUjDsqVjV2Ca<~o$7Bm z0Qjj-?tFifHE6!YPFxOrSO1RBZQ^X3H)LyW^IT`Z(6c6c*F;yF7{4Ym)?}}m80;p` z+dM5tdN=>*|6_2QJ7ft#nYv&pd~sqEqBMc-1^2*L-A1UAz_!i?JZ#4=3;}XjQ)W=D zg#>m%Fr?rB`3ibt)~m`o#Dqe0SiAxO5**0xr0J#uf>&ooCDy&>7E6qGunO{>8Yf=v zaqA%VCzu$ob6|juioYSU0wNT;$2ONfkW(>sKevm=-m`L zHuW(F1nMZjR!!+N|A6I386-LHyIofJcb5@Z_enl;lKq(E^8;}BedA5|?jRvj=HN(Y zqj0tXLS)~9f_hU23ir6Apg@)bS&TWp)#ZX63>@6p83F+ekwvkuMleuud!d2_b&73Z zTmbJ6cET%M7C6qj!(NQ@{-7DgM#PBXZx}F$E(N8qFaqi-*x34r9FL;AqgOaHAgs>3 zf3K_^x;XlN2lC&McC&tj0-I6B1U*gwRV(h3FErRCd}i6=GM>d z01XQYI^bP>8sLG|i`>8%)e)@51D^f9&X2v$bVZH7SHxGwD@B5AkzUcYhy) z|4y~TXYC6JPXU8mKzRxnhXVK8jbe1GY(RuqV7&_m`gO-SL+}v?1E2P#tOCZlfblEb z?Jfaf5OCx@A|b+%_nAlq)00IDVn&@M_g6L9;Qyn{ z!3`kfs%l#p@SwHibAt?s;7wDpVoDZ@K5&3r0o4MCJjJNZT~a~f61e7k*VrCw`#aTv zfqsgNqvHVJw_JQ@aCobA2ZJ4>fK~fDJX3v|JT^iEKEis8+>|xNU?tnhT>zXo#$IG2 zq!i`nT(?v|G)8ayb3XkOOo=hAs37k-uD4=1Cvl{c2f6N#6Q4rVAwPeXZrb>&JNNaW!x^w*1s6L%`?^ri0U|t zI{R10S=VtO(ZNd->-8Q(Xu^7T&@ZQS$S&k|5eKC80K(u^d0-rUKSR5s# zahC-?Xp8_xw6x)BOfd~YA@){GkTHGmmh2b`wm}@(6tWeAh)#620OvD>&QHC=fdTe! z>YxM}M$4fx1@}5Ic&5t?cR6FQubn>*eR7fuhZ5vOmt+|?a0WP^Xh&4GieM|cx`a7+ zrT@>qO`vlV#~Me#`(n5e>l1B=|B>yl!AeMAU%c2I1jl4BARd$$SfmbuuQ)59p9dQx zsBRn9Am$AWSMG3>+`pEJh#k0L`NpNoluw`O@RF8zDfSb=Z2gr@*ty9DjtOM_7ZAd6x-TpOMQm8ynLJStbglJDD*ovv8AGAGF2>`hegJ}Q)4|M<_;xwK$rl$Vbhop;r zaN0e~seQ;#5U;U!(S9vEEF6Hc1phif;5w1It7Eh@)MpxD6jyic=~;6O);$@D8&mP) z6uyvC{W>Vd3`Tu!Ju~oeT3#e_UB=uo;B1U)q_UrJ|q8C)fhcqCiw!;Cs6Hj&7VoH{Vg~0bJy{038DWm4d<$$6%mWI}OGD1}Nnq|6kE5LL1{KQL;V^ zXa8o#1MrzK_EK$vBFp%YYhY)aB%|&YK;&THPnjZ%PJpeQQe#aA`TW5X98C)xh_Q%1 zT-IWcdmQ4sg2(%CpZ#5cMqm`DGpf`i-#5nJV+hc- z8NiLNX8_M2{{U$ zf1FEsH?Ca_K-1~+iYz6S2{g($)(ZPlnSP@FFUnj^*%U`cl>i}n>pzm{`Un6%b12#QY1$8B$;{j6T876z2QTVb0gl}f%Ah-#TzlpU59sV)pJVqWLkePuX zBdT$+4#7hBO=Dx8miVV4`yAtog%d!o#?NyQz+Q}F$H(q+>tMs>w(lAvz~9G^xtKWk zGM5PUGhX0_&H}74co6?H%6nq&fLeQBo!tYYo1}h6K)_mzaQ`Fd;mBHN1km4+PrEF* zjZ1{+V@xI#X#3180}KmWgv`e5fUmn0a7<b{}1@*u`X@C z*g!yJBxa(#GVNmjt?me59b!hnHw>bFpW6a?PcX6W>ny=MnA&K4XDR zUL+7%LU@;1@FgPfB?6Dd4`=7W!j|dy6)eoMNwX(snWDozw%O=5M!fyZ3`ROEbX&E~ zd$Mm@)6E1X(loZxdRdZlx2-+_ z20SXCA)-?O0om^$1!7P7?r>MN~qIPoF%?S9@-`kmRsE2RzapTIqQ?l9{c1R?}2F^z1|MnXWqOY&3^ z28SSQ>~yClo32-?zIj*@palD$5YS&raFiI@qIQaWOe#HlYRbgahCacuo>P694lX^* zWdMSi5^Gh$NR-4M@!Z7K#L%C!oMu)AU_Nmr6+W|ayMb)z&GcUkctiK9=ud5D*Tpf6 zb>yUeumgZieEP5Di9gc*|7Eb=-cHlY*()1>9yRax2_C1>THinUjMm%izy+|yh_w#z zh2v?xB{O!dcPCADi&I(a#suQFc$OCX-Xb7raZjyvongSZHxF>BLEu96D)Y2Hu2w83KAgpERAp5jzz1OyU%fw2JugcSlOO<4@*FRTDEQMt(bp%y}QZ18=eYA*APWwi#@62V_fW? z=B!NNoP(P93;uu6LBk;~AK+A{p6h^MSIZ&6!X)22S#y?>!%2)bRtEyl8=VO%TMha( zy)GNP$XS7Hj442WCw}B?z@b?VC}N|6kmzU53Vg=c0G=_3h*(###f~Fq;}he zqfc{o;J@5aKwuk`!xuRiKt_UN06Q~`4#e1Y0@2}*7)SK9#1ut0fOrAe+aY9n2zw9= zf!K*bWGy-abSS~D1$bFOz}e0We9Gm4=h^1*oiQ*7c^pvd^!@IVDmnmADS$wupFpx- z8CZgy-~^boQO4#Avei!$48>#66lxkrS0&=r{Bosi6?so6{q@oW zyF`l%4r{dK6xB0Qki;sb)Q?CaqG$cyOnLY3njkw(?o%B;SpIm9Dv#ZaY)e)s7wHY+Q<82vXn9b1aL9Q z3d7Kkfsbid?4Rf_2cF_ySk`M`&?Ff+-hAq`u~evJC~CbqW`r{um9KpzjYGF zA{NW$r?ZUKd=U9&ZCiX#>oqy>s-+w$O(b zMzMu)Zz0<)g4-5>Tx&W3y)B-twHw#QE)8H9o7Xt=fc`Xhav-3e1Wo}UJjJ*Iz3!tf z8|+}LfH(;V`s()@==gPK1%yRXM&v}UH)V%VbP3Ej6L66`20m#3r8;;p#?$vFuR=^7 zRH^e@4DqFE1->AAoiAPNcy zl!91@;H!jPDjn*Q0s2$=uuBN~_a_`Y5SVC0w6X?bWeqk$_HF8(yc9qPUlLTs1T8^K zw6lSQ3O=#R!Ca`a!Y+v+5Lr-SvB5L&iYKz45g_y2MPwt!WFO?xz#}FVQYq~M;{&+Qm^JXIy9J8QzMbWO zfX|AN+=u0%DguK~_}_1GRseY${i4CVUvf~dHs3=G97In?u{)ao5t)FyTpqYJu|PpG zB#wb&-7@$KA0CcO%$97+(C?iEz;4FO0F?rs=Td-L{(kCg0D-tj-$eaBh`z?~AcC4` zXJ-9lz6o*>BxvWk4H|nou&FZvw>bd7&c`4%wFL?^j(+v=z90nBp-UJnVFCz50+jvV z9|WwEEkHQ5rt09_Nb|fj7Ht%}eQ&17XFg-+&+q0jb_;Cu0t>%@QZ4d8%Q)Q?jPeQs zxXj|OV2GA6G>d=B;XG>7n`JR)woU5ZHj384`F8l6HiFi{na;8}bKJ`u4?By~n`IH^ zaAxyt;KB}>MOb9>moSbiIGkmKX_>z*5#=u;YzqVt^RLQM!z>1W=EoUSbXfTI#mQG7 z08@hvuj{nWCaQb-4}q?|rh{&BmSm6ERSkbu9DwW$vR~&$PdS00Gh}>|I420)H}+U8nvH zR&#*P&kVp->mRxn<9jjoLG3Gm9sAtCaW&A>Cg0oSUX;;`n!Yjt5BUUtlASaTsC9~+ zHjcN&ezZDv`YP`!1IIIKymo8Fr+uEig$-zNDr|9&ZSJkTQMUg^Fz|B+4~IERu%XL^ zDhJ$QEP=p-WtSaRon^SeL4|;b!UwRY4W7L*HLPp}Fi+tbfZ{spyd2DPxV1AKlk z3SxIeC=^o%G3I4-IEaLJw%`x=r@IBv(Go^qd@8{s(CthC>srFe#sDJyj?WHm6`ry5 zWB;A?DIwP-0@xD!JH>j6jHrYyEgk8AK|uifKefQ6;1in_AVbL<&k{2Xu5t-M7YDbg z_ZwgEHvd~-)%W@52h+C2e1l?Uw4!t%z~M2*3asmL!1vraAWi~4cjDC!0+b1mzThy6 zJX;YtE(!?9{*I%YF?q1%mRg=^oP7vNVH{@+;37yE>s`%J#QbgSat8&cIzT_)zgKqP z`Kh~64$y^6j(*==J!d$;KiH){0*0UfU(eU3whK!J2p(rZ;Ii$=@#Y1<0c+x*a7ED> zpe`fyJD5lDeZdZRn@a-fXu@Yj_tH(qFMZM3%co)2)CGpj4)7TR*vpuPx<~Q?46wKT zKX(=Yf7XAl0f7WC{RA+5tX*_l>5#?qM@ir#4glECAPL(1zcBz%A93{g@=z_M`-u?S zEKUa_I)gCJ+?5>pvpP|qnyq~EJoLidPQ$YqOKi^a#_5cgI595CG2dXvjKIthQP1k) z#52PK&0w%+e(AJ4&US|AewHYG9zma9Ha|a+>pYHd0i(ExL0;79pG8~2z^q}TRxqf` z+q%SnQJzO==P=|mJkJcD(@}pv2BE!ip7aG$QddD;rw0U8gGy9OY&_p}Nuu^T>!A4t zA{|jH*VMKNicwu_^v)!iP=q)*?a1#Lxw)$A^kH;*F+_ou7r>4+=~+o|UN>ve&F6IU zIo&95H?QwTLAq;p@(4>e!9q7{+|9;xzl@9L?k0HZMghCI_wI$n2t+x6=PTf#3kZ9G zNWZYYGXxmZ0!m(BZ3>sICd(iOvFGhvtbgy8#sFMsBA`ik0U+4D824TjyYHFK1n_w= z(s)NZ{*O8$J=XyM#wS`=)Z((C+geo5VozfVmOwC1cPBuXPyLT6#WltTaDp0OO`|n% zTi4Q9yTJ>bT2mI_0kd@RnZpDX!x#q9e+I&LZ@2$^+vz_={y5i>H4Xq&E5tF4UhAyQ z?_CDK2nMgY4Ai=5n8rVufTkcu;pCE+$KKH$077LyWaBDh$~{aCJM}AL zzF&5Wl&($$d0FUx)s|ViGQqFrX_WcA3VTtxJWrwmss#pzzgO8`P138et~EZthSRFE zuXPNI2J}c~qyK&=Tl^yB|2b#3l({1~Xz^JZ&eh`HS{K{lUz3hrGc?-lO&cfB=6>6o zCkI9whu0>^Y`-Lff!56q4(?7pYU7mJTO9+wjcOx0BrxB;A6 z>naBzx(`mdZSK8&i8BdmCH#oX1os&)z~=?~Ap6!3CO~`#3V_spjKQyS4?&Fd39k?9 z9ZZQwxLm@sXx2ak2f_*P{nc-{b6~)kfKg8jq}|>v;7Q%10TxP!6*$>?feP4#~yH&fS@Z#hQ!mcS7u(vo{>17=oApX z2iXiR0R;o%5@3IV`dcLe?mc(}wsl!R7=i1J4^q1zdmZ$_>L6k*hIyu8_H5{3X9CdO zA=Y4spjIP;heTk;^9~8W^dsBpS4Em}|0s9yn%`^A2mi>Hp zumWD@@~Qg&(TzTW$vy(3z*_OQKHeK6+J(c~!-0Uxvzz=k1pqa^v`#c5VxAU;q&1i$ zd)u6(Iw*Z-@2veRb>AUUnmIm){45~cizxS^TK#zV#m)E~r<;ZEx+fn4vBd8d5!iVa zWnMf1I_VE4pl=R?F#AxV`gK~L+crxDi|cz>4?(~J5&8m)y@Zf2^LZ;Q(wa@P%&@Fh zLll1zL7PXh=lJ_9iaEpkJDVhqKqnr7`$Sk0BTzR=0;B4-W)|BoPgdeDud?Y?qSNYE zvred#pU}JNsny6$)s4kGB@!CdtE0bDn}UD~CEttE_Tc1tuJhEsS0ym78zbF)j01pc zUEfEzx-r<@7_e>vi0=KlFlyZhW%uR|08pOp?Ohh&{<~S*?msvaAg8}YmIfk&aHq2f ze>0fyGzS0}y8;1K&(lo~#CrE0VI0621_EMidr`>V-(>(0V}c0+0~4T#bQedUY71ly z`Y_CWIHKSK_(j&P`dP33x48^3XrK#DqyNzazyu!PTTe=h;Ru2p=u$_^1Pj5awWlNL zuiN=6#fC#062^ji8~zWod0|jubSTDu1O<-KzpV4f?CRr$Au)i2zsC@u8w@IXz;ey35|(f_YDQ|>!v0H7n&1jbd2mu3glb~I5AP9nzpu65micengq zmY}~N^Eo$b{Vg1lm^ND%`r@S3Y9`L6#oo5nS;ObIk^MHZ*A_14gZ{ai*bYX4LV|Er19o#bBuvR$WRap?e3Pry2*ohPp#o@ffF4Z9PS_h zCsV^=)!yUMfyyfEXY~s%4S1M+o)Ku>evz;l(kpJ+9_(!szj&N2vFLcmh` ziUR}%ojiB27GmQ{M>$i#9+h@*P@o{;Z^jOs=2QQLE;DpoPQWfqea2Y=>{m>(+`uIQ zbv#{X5Fz$HMji9F3G8!BG-Qt_KAv0xF(czS&I&Y5Aar`R&_?^9GHM$-3vgZ%2#q7J z*7rvFZHnKX;k)I@>>GL)jYN~6CgYpha}O=2Wb2MJQJ|ay46{?7pcdejc*?3(}cC(-KB>Q7L*H&H@H+{)fB<0h`~#llWfm zT0IXs$L1{%-7MlXmM}s~Dj^V!Es9To?_A+MYY_gme9sy-VC8igWT?$=9%Y?Fh-Z#; z%KzW<)FIS!F~P{{x0sL zi*@OeLl+qEIsUuw0^D2o8asK`u>0=@3_hG$fe0|Tw{F(C`#xg?P~6}c!08q+qA_~- zdeZ@O+Ub42iGVKhEC68va4x-z{`a!4yPXM820$P{BHaN0VMKz!f|G4@Vv+!fAM92e|lNuvEIOrBY?q`g(AN!^QfIpbPg!LIm{(}7v zMJ=)>G5Qx-j=?NE^Tc1>Qgw{m0A)laBYPOEHJo6szyKhFC7v&k;usLIYL@QviSgrZ z1$@+GTjx6fKq03I(yC8eO$y+fk^m{pXuC|dhQ6YLkK z@wPL1Ja_A_iFIi|*A5&9)W)c`2~gTRU;7MSCuK)W8~JFz&QAXjJ9=cPjYDa7C1AJB z^R_QbTuobhn{!KBtD8vh=TgF91O7kb=JL(e8jwgDU%8*OK?`UGY8wCcm)X7Y6OzC z&D=(~W0EvYBnQG^9W1#tpzfH1tS7sfMCcX=0@r05ZIRC{zQc@y-23{?|9p;&a(VrM2teXFC%npc*$Jk(Dkl2$U0ha&ZQox8)|2h!jGlSBc z_lq4c#+;)IF(hcrWl(hl;0H7xpdT6S=U^KHg08mRWUu@A{C)xcWOs$h`kk`?_?W(% zToOQ5`q2Lv7^K%e@Bc6W(5a((V%8b!n`G-vtv{7Z)9}Q-uaTmn7Hy(99X4kM13vp3 zr}lrDV}7GV@Rm&V&#?dt7@9>K+#;X5h_ElAAd3eW#eY(s>=*d|JpZ46x)}sn@Ff;# zdBYs%yNu#5^V!Q7l{G~0Yx(ZAylxGrfE5H`35T+%;Db$_!w}5i1UoqQ&L`7&wOFX8 z48yOoE;x-aR}`gR?3yf2w1N_9nppXvjOqpckwU9hC%RA7y#x#!Q>qzd8T#jHOsxy1 zKa{`s%pAX~RD0o2*YS(f!O!?RN>#hk$gUC|w9@7XseJcX#1zyZFv7 zj7OIoyFh`@av*S=%Le+~yA2$C&>+ErvkF&duu&koEMR1VBZ)6z9X3Tex0p%O?05Cnm#9$K<9tgr~bQL zv**;%{*aydpdEQ{w%RHkA3x>L35?q~=r#v{_NN>y@SSZ8ZHGPYJUcLS=G z@eR=>fFo<1Y2f4Al9xn4$e2UGch$u!BHj|E|Nm~VAi7eUahBkgv}-kj%i6J7Ua7K1 z)oqfZIR*=;_=w4xcwJ?u><$oLN|bPLQWXv+6~43bcDEEF$1#=gKywYO zWH6voLS+wk9PnKg>_-`=R7Q@B*pkx6j7>Sg!2+KX%!cYd7f2TZs{U@%V5 zG0vKe?`=Iq9>&>wjp%+HE1*)qw~Pzm?_h3_8$R0F`#D#seJc62OB71F9q7d*&TcAaF$5BTXg^ev(;(|IRXSSpa7C zcyQCiHU;n*9UC~u-2m8+ft?Koyx*W{_914fZ0Ag>cvVz}<$%!7X9U)YJ?+CD1`o@H znQ@LX!0Y~xGXd-5a34q!3OXMrHx>ej!3|bMjl7{PAxxt|0MS&&VRLtX^@PV<|GU{tty?< z_x&W;iIhL@4;H_ReA35Qb+fVE>!)My;`_P?n7S}XT{zq>l&*_)?&AKsSl=#;P8U&Q z*CTmF;DCea#%OoX8W5rpuaiFt(#@KwtDwO12V)?HP16EneDHoA5qy>B18{%6 z824TTvKM3D%k%ZJN4*3QF%}r-*gKK9fQU5J`iJsG>z`8p1XKN+IAuj35i_oFAVF@S zlmDNx6F@^Sq9sr`iRU^SfUNXmvX%8W&G5S}% z|7zVqnTJu{82%$XK+9bK>hVSSMsPACcW3P{fI&pfqXY}1N+)8t$1q0Ghuq_n$F?>+ zoZ`nX&QxWQ6Ht*;Ud#YE!DwjqZ4yO|0WbIErBhO*P(P97qA5-jB88FREuoyz4tS2! zw=-$L%lyB*#y#i)ni1fMsV+tU^RtRPS21u^WFn>j9+cb^BF71$oO4{Vdyj+iT@&pe zz57D;tDR5(pLE)t_qAW{lRvu9{=S_x!C_nNy_`zh829#^e=hp(a@ZKZHagQL5bJR7 zo%5{c1d|;Cq~2ieAX_@ zj6n546D^52=+j>R6V2Ml3BH1SRJebQKacA?V*>Pdl?oIn>~4qtHFp!Rb`|8gg02LK zm@pp5LS;kmGmcWMqVadur}8!j7u#hY4ug8{W7J}Uu)fknV+ zimN0r1sfZ8z*+@Y!KJooDifeP0Z9F!0|fn>?j3)ftGOrpD{Mzoh}b3u;1Ao1NS%!P<2^A;6MWG z;0(at2a6!<8H2-KU_jtklT&2q5rYA5cNRdnFYMnC-#5eoW{C9~!qx{l*<obY!RrKFM=x18Ds6J=<&@TMeLd{!!3+X~1(4%cS)gCM0snMqU=NoDSc8GzW(&>Z+}al<$~Hy-BV$9{ z;}B~-gkc=U@DHQV!x;NvUNcOfF!GcP&PLex7%TcumjO_i(Q?)b$B?O@0Y2Pa0Nl$s z&k^*c1V!Vguf|MtjY2IVQ<}3LG^uY*E{Ny^z>vrM_uHKTc$I6ctkDz(F9ybN8VN=~ zwR-))*La@T;xxzp#iTk6V};XN<>w}?K@Y0?CKILFQG+I1DQpZ@UD-H{c^%{4*wATl zPJvC~T$*%e{73hYkTm=Ph~C zZ}S;#^rXW+bvDS!n*rDrkQawAvt^F=?hr(Fj>sWjA_wbWR6E;bw~vB`2sBvJ&a?bo zIJ?e^^Jj2!T#)w~Er(|sLvXme30Th{D>}^>2W&^s4L`+ggE-^{cBp~Dt_vq2uq66Z zuV$7ccm>#}I?qu*#+U(>0}oA*V1NOi=Jr6fU$S@8#~BAOZ70s_EB$T{JbE?hgm?5w z|3L2{jx(k>Du{TIu>{Clg?+1>=@Wl%W)`N^`ibqU;KVDZJHzmK2N&;lreSMm6wrs5 zKf?NyTP`DDm&!*PhoH;>?=S1%a=QN}{K;Jo0+jaumCH}-Ib-mT{C`~cI-~GqXRG)= zaT5fKp)dm6b9A_%k5f1&jXw_B;s>%7Hi(7Jbo(ItHG#vPU>{?4#_O|;R-AA-fZr8A zmEb^Os>YGQ7%+rA9B2K=>X2x~TkUl_W<+yMB% zA@+Dk9ZRg`;H_>|79Rl5J$SqW0Q6^&`yKdoW;bIl!0|49zRtD~nGE8zGu#UJHXo|^ z>|j{cVM#bFWU`O7>O)@o*#AC)&AzK$4nXJnj&uN^lE7yF8v%eOnU#owORsh+==Mxy zP6>gkwx#7vlUMoT+Cv89yeqi^gw}2Hn#bmdw}dF>)H8#S%wja>4spkT0DV045=y_! zrme8iYxtZMHh*QS3)7)#ab41EyidK!n=k= zS;Ipwe<9fhg&&w>)8|;=S&YPtjFDQJ5DHC0(}c0Af}KC7vXpR`lPvD!;YPS#Z??Ci z)4)$DjYf2+b{ipN#iL#PV)nEu%@mXW{*m>ap!`K3d)1<+6ZxoteJFA_8`;I{yI7;H z-#G1G@o699)`cK;@%}E9wQI;30lu$m$r%IT0tmReaWLH|Qa9_@&ELD1?EFy(5eo%r z&^G1>xGIByp7lH;_+Wz**{>e8{jt`)C`#`K?fgIPVBpiv28bX?sebk|SgB5O>S-`b z0R7K$7GQs;uu!s?c%}YU_No8(&IAbUs*J&s1)h5iDoj3OKoRl|Zjn)hOu#arh#Ex* zzU?ntvDnig6l&--3BU|x#9+SgG}Th2LPwp zXxwhl5e{kml{Px6W4_C*XUmClj+yJ~heqKiIW5IpclA*7Jd*@BQ}1;96*4eYNB~wa z#3|FndX(;T2|(E;*162HR=BqqFr||wvOdlIRFOB$pQ!#O>27PRc};bHjBou=m*Unj zfeuEnxshxCa{B+77@atAf5fSL{qAc%=_9M1_3d;Y$`pP$Y1X2HLFu4t9gNujMcI3Y zM_X2F->?-6f=W~D0`>}sieLq|=te>8qGCfSN>Q<3S3pHnP(iREwv?G9lgXr)nIw}; zpOgm$1$#q5x7)6WJn!#Z>r^?8@A%&G#~gW{WaggxzOL1-wa#^}#;5GipWsx#96xf> zV4a%;UQGhYCUVfcBmu#~1jT1DP7QRZfgx|4Vfya(XUQ;}{`35M^rOLN8}D@xz}~Op zgkuCZda{NLt(DwSu)kXg+YSbXj7#DqR!6s2dprM4GyI$cND3$zAjyl}MQ~o)tDqo$ zcoLokXb}4l1BM=+z{{$f_>WA)bZk0uIrf<9$huWk<5vce>n#!ZE*eCZI>NB;(!5NREAdUgi&T- zonm%@K%~lCa^EpkvS>U3K}rA;6=Xi$SORon@lh^69dE1wLCoU82|$dD!7m&Le8yR; zrzWT{m-Mkzs1z?}25BF=o1Pn%2V8dAfWdz3k5_iBGGs`!*)13k; z337;;B*>lQyMi_FmnH`iu=@~miJ;FD$i>7Lon<75C==hj>rsvm{v#CRmL6% z;2N7S%DRlQPXQ1_Mq*McvOoG92Lb#1KbHe`i58Bzecbzr@XTQpW^Z-f6C<<0!mD+u ziV)Qgnx3n*uYry5V8(}(Z=Ak zSp4Rmu2HHT>fM<>Tt<*bQ?HCzE*B6`)cqY$(EB=|1|zwlkb{)Q50 zl&0FmlyXx0*#u5^e8Yb9YF2)9bGRbYCwGDY+L9T);pYLB0GXB4^XI>64W@ZR*hcaux zmcXw%wXfgcQ@+yu*Z72wjy7JA+#3y^x$#0?JVS%MZt(ub%{gzQ!D+KmNgPd_>IqUB zIGo0a0|2hu#PGEUxS9lKO#;B?{@Hrlyj@akM~UDMIlH65DZHU}-+CSln&?ym`_SMt zsli@R26&0_23NXNaeHS29^z+vLLM&S-^h3!n^PZ2aPlgKUPF(91@T>Ok7S)<=#heh zf0!#l7>cWsNJ&!_mp^430D4_}qJuB~AA^P7Z9ITZ^#rLg)$s_Q-qH0X_IQbPTjJU= zyy=r}-;|Rl_^ayoH#i8ukt|{GtFL!pu$)*AjZ~LSRUi=8c$_l_zwvcdI=C(ajF1xr zi~s5JkusU5J1}@)W@`0Qa}8p!kva@G1T3Q0i=VdKDM;Xc7FpMzqW-Xd|LhC|Vgll? zjV(AoL4v_zc;7q(1tsw-T^i88+4Fg1VE)by0^a5hnFl0bc6P+P0rzy50Cr~veTdlt z>J%XGoMDe<)D?ifOk>NZ@fS0^H)aZ)W?=4{T_!lu*#Kd7_VK?Tp6!IuEr2fxf+1vL zinW~D)h&Yp24a_k5bVC08LWKI41sUX&aR4nPhdSk02PCRUYBiwF(^o7$nP10BrL!& zCI%7~;4jVqpl30>4BZ@;P5Z060obeHJ5l`~J5^%;G#eleMY4x;1_FM;nbgyKs6sBr zc($LU082y^d03UD`Kp<@byci{Xm;a|sz%IK^{UYlwf!KVf>z_h& zVkBpuok&o%ov5{?dbW}D5_A@%N;FkNP?qnSC}oWwUE3?cKMe$~#dX?zwu=(rRg z#XiPk6M@@8>9%>$Z6dF2qS|c~cn1Qtje*%lP`6R!Z4B4eb=ms2i80t9nCRo!`tMKP zfejXSgGK9e^6jFuZIr6Hn8qy#P3~<2u~#CgV{+K82K=4s=vOH*o%q@G*`K6P#wn1K z-V8y)48j)^v+ipqETx&$Qbq(;A=oHyBmhJXPl$Qd*@Nzv=Ne{1MC>z!K_9|F5B<06 z{qtB!aT+`M2t~-trdl}DG|_= za4a!8_|dMdU1>Z3!Dt!9Ewh&sQdsVN;$;p1h>R!Lx5^XU8aR~ozF-QI0bq|Ob#f5$ z_@tdV2uQL|z&XwOOryNP1<*4aV8MOP56*p$At@MwnA46t&K>QZX{G&9)L>*Ih?(yg z2q-kRYPmv@v-Z(KhVhT~KV&(;e{u-OaTR^35~S4j$bNP4+%KP%05&mmuHYb6pQU^ic%l;83HQgVDW zIoUK1HjVhX$?_S2z*Q~>C@3M&7b9o{FKQ=LMzL(dAO$(-bx;xOkinY7fFhLz{xjPk zqjm5{nH3PR&>9YX?Vu$83ZkK3XYdr`i4_F2%?I*(W1rLw#GYyrW0iZXB4<_BwTct1 zs$Gx(yoznC9^^f{tDQH-xVn~Q(i;056AID680Msag7prs1QN<}# zzu~OGr_#P^^m+sf+)q#!KPJB~vJt`=9N=I;2bnJ#TX1%kCZf9l-HT3xALYSqaVdia z$zA;Ye_T>vorCK5n^`u9AoV{JY#7}Itn&hLxqwWF;40=BTxGy34lP(P35w>G5yL^n ztbt1m6x=6mX@CPyHFp5_J@e-T*Ulh|Gw5T?+BnyC_CWu9iZcM%(P?aIOdR~8@d46R z)?}J}h>4x*BtVX)xrb@&#T0u#b)_=_&q#paOGD0k$O%s7E^4pdRPO^ib0!tY9dQjhc0VlHxsxa zy4}Lx902erdZhI{yUgZsYX)BZR8`hv3nDg_MM`SV>vO7Gv_t%GVMB+wZ~NP|X&RSzs*+tU-Y_D4_5K)}V+}C}MDm+*gskEpmz~{>rU^3Iv{K zaNzsg9?1QSEV@1LI+Fw)zyGMVi{F?{4q0|D!91H|YBZ~4cJ0eH64|1xAe(=75g`!=^f{m$U0XJ+|m z?ki~oqm4?v)~r{|j%S~u|6eDp^9}66=mz>9S&PxXd;1jlb~_Q(|5uy=z{o6@Qm8hgW}>ofEPND=&3907tugha?7*)2=qM922K> zwPz|rgML-nm#ToopW*dZ2M1ru_lIN0W@?~X?Mr^K4lz!B@5C3>2#{-6`FGrF^`{Ot zxF>ZdRr`LaB@y|quKW6*O|F^L}e0CDOoP4b@0NBfz8zA10S2_UL+w6ec*95^&j23^X z0{~?KZZaZ17N<80@Y0q{H9FnQcFi|DzO}Jj4cyu_1*2fypq~=LFSL zCxNcRf_1od2Vw7EAi5aWE{faZ^IaTB=eT4P)Ja5SMxr2H`F0Y6)Cg>r zh9d+dBTX|LDze0g#4G@%o|>QRuAOcMyFGZl zD9ctc{qF?V{xK99s#AYy_WZ{z3uH&Myz4l@b)GqT_5Yfuea+Tr?U8t#aJpQ-Nnp_w zQ1_X63fHM#fY~PN+&s-JoqE4mHJ_05-Oarm9H0X&PP{FivCUex`Fxwtwb7HdT7$1M z+b8?p;@MjSE-mTg(TU4xq3w?_+H>T3uNN z5fF*8xb_v79rjLKQf(iXAfA!g)%d>qWp=g7^Hq`c>cyE2kmC=q;ma*QY9Ez@=X;kH zjVTal5uI3igfJ2QB5Ey#QxPbS$tx%m)`x_gDp3Z;X zyaC+DJWg-!F9yh}WO`5r%d@|*ZRP#JsHsvKvNVev&LW#L*ykB#-PpSs`I`ZQa3AcB z0i0+I7!qKReUGVwd?pwM39_P{@JS8;mTjMTrb%qlB>#^w;Ml~NB*|%zF+q?SzVSay41_-@ulfLTni&Gw53^?cxCgf-QVJ-!T2Y@vU zG9Yxe#2S`3D8#Td_5A-K@lY`(P(i@kTux<=#?E$0KnE(;VeC%nU(_BLWdLL-=z>4# zOaQtaSS@^UjBsbagF5*C6aa{IElyU7dK3k*coPCgoSF#A>ANM{lZHgd$i=`D{x6aW z5ogperkYN+dS#|0MKLO5aBKG*8r1o|*#S|2J~y?&!fsxZWIo$0$`;?XiBaA7evT6E z6TS4fc5kmd>34B79gKemVd~)Y+CRuCe=#@U%cdsgy`BFw2B4B@&2^T9ySL=Io%5Ni3G*eB7UF>nSU&~S-K0+b4ZslgIu zrGf63r`^B-9GfTbBKKLuAr(2@6x0RqYuER6(#M$$;b?|F?Gix2Cx7+%^K8Ka_@vAn zL;xTRz*`&yoa5F&;Q=b{4*0nP0Fl$afYA z9*QVx5#u!S5Yq({;g4`nBUihwL{vYDlZn<7zCTz26%4%7*Z}pa{@FDvoZBdS7ep2c z0t6c5`^SWU;pg0^reIOm6IQoOh4@0ny0oD8touC^$U$bvVEJy!4 zr{o6=;A8KaFShf)&}sR%C3dIz6gz*R{SWp3FG)ZZ2*Ka+|Bf94ti12%j>u#cdO#uhdod(aZ}2Q499sW%W)p$}8Dn0*)NF%lrQ|a!Dzlts z0wLtOHtp^JK3h8{9e52}SR+WNu?FHyiHU<>_bFchV{F0lGn}<~y2+c)&cGsq0CZU_ zqsuBi;B1z;kC;_(map@*v`rC6s1$)s5II@xT|0A*0l`XDog&z@>d~1|sG`TgU%>NM zpX*YAup|VS)qB{%%h7K-Fj#bupukfAN9^d*2b>8|2|(azaS-tRG4}um7j3K9g9UZ9 zu+}l=T5Z&ibP%BOFpeuG7qTYv+~*wo8*>F%r@8;kKp>`Q%8&53S!~TL_dlx=GlA`_ zFazlDEDmWF-JjvUX85j|IpYP8zv*8XFo+GAd1#hrr&-r&+3yd#H1KeD38-c8I3Li| z4vc@A>?E4F-Wh;*_;7J|X8{xdVB=y)5NlL^p*c$a z$qOLB^2rVWc;@jvva_j#?F|C7^UVjq8kca=C1hocCSvH{qgm<=%LGAW15vG?0v z%D1piV~;Dh{lysw4xaRtL9_T^Y^Eh$) z3<9QJnwv2D7S}vk^aVwT0=q~!`LdOJWK=B!x#xUPF+vsWIPN-5=1yQBJRmGalbtLb~?=`ealRWHJbRp#6is(Q^E9MNIi zV+K7+F>$if&EuIeQjJLTz#_sK<-0}%2;9?s_J7Wkb>WBv^hE~%j%MgGw*y|`tN;dS z2!S2O*$iW7gFTRS8RkSjjIa%J@54M#%m)zPz&l(DKv{<8vMsQ1n0Ww{g?O_W0nf_` zfkhOe$nT36@H*E&`QGA|0{{gqtkno>IKtYDU<5`m<|70MBN)*@mr9^8i~$Hd$HJ!C z(@9Q4sb5uXD^0&}e52|FP|Zs{tr)7YHyR9x(3kFI03b#r#slw~fmBQdJkIHV?tL65 z9RoRVxSG5e)4HzC$b4cimjVbDCJIUHQNch|2!tvqb5H{Fos%d^j09#MV#o-Ag4o8U zADk(~>GNFw*XiSnym;^IZm$0;3&38?zRS*^&&(lnb0;|iaPO2S)kz~jRsc}QY||p^ zvZ&PUVXpg+8(FSe@>3Ehrdn~Nkc9)dIT7mNKnT!c{4dJ9^5dLkvC6gTZ%^jDXve+T z;JG!Y|5?)p!AawTKE)$%O||dw_a?@*`CDEB^nKo^?+<6DAe^vXXSytKf}OHT2k1nT zb#3u|Z3Ww0ze6C^;ThV0u?9iF|7jI@613;~X@b#2;$Hg=}{sLUF)c6c_3vI!W& zmhb^T@;%<*pHo?iX#CWj1FT2m`F_4#-PWiUN1ic;7pZK3{b(qVL3Wyz%xE-_E3po) z^Sm*$07p^hvvr*RYR$mGw;CI8Sau67Bdax>mADvc$XV^jS>}uk0ghB-(}P-A_$Tbf za={eDSNbRW78K*<4CrdhnT6C$hvlzjfLCLUYTQo@ds3_QPM0FCO#-OM6rh`;gs!pQ zwYwRMpt68E53Y6)@MVJyg(DGgk^Kx-!~3M8ud2&I0R;COOs8kKq`(?3VgHsm)GeKv z2czH{5O&}f4g$_i>{oCO=-_md`2(;;q8yGf#{4b@6serb_s`wpOu)6q1)StI!Q&HP zKF1+omS>$s24)HFW(k63g}*v2!L~EE8hpD~@~_OW<}rEjO~$C5n5~2}*pwJNbfxuo zztra`d`e7hRY@CPHi`U9s?5#4#(V&LQ;ZK**U-F4fjA^p(D4amNb_DM(Bld0M~oXk zFk8OMtV?;F7lCE@^?4YH5`b_3>`}}Ec&SSOI=ry96x&h!QnX~FL!)X#|C~z!tWz)sDl^MH##C1Y4Ey|V z0sx)T#!#@B<&FTB*pzW1jWQc9%2lOL#MCq+WB9>L?<^o-8ev+)P%aCBdt5Shi3427 zViEDQ)d9eDyC_l*W8X(uHW27d-m`@eZnFqmrL6Jy^ge{SgTi;7>~tc=zQv}to}4F{ zCJv{`W;casKG6UtPHr(-@MO0iJtbR~f?R}$UcD?&Poh*6z)FZ-)yWo*Ou>~9svlJ} zk`vt9#O?_MiD^(TND#*u$}&c@RucIGr@&x-5x)`X}s_g$8gQluv`2DNJ(mm3qb zjzr0tyjMV|hhJn=KffRTOrGY4{$hqeo;79wAUwke(J=QtjN-+Rpf?#)@M#ACDD3c? zT?!a?+u^di0AA`=Kmvrq;34)>waNoo+1VPY< zI|6>gb8v5?&+|*q$MvE`P+bC?jZl-ae|S%pU;4-f+MORV-*~a zXh2n}2^;{|n&N#^pS(@|UqB+hYr32#im3myb~709nctfO;Am$61Oy~dnq!~mFgh_A zaECDfJXcI-yEOyk1@vY?snydnSPp)T3-TmZ-OYe90^6#b40~TA$g6!Yoki^*<^W*N zSCI1<|9g!)05C@Nw;2HVMrQyN0Q}H8fgx)kyA7V9!J0N7=hOad*5g$YXc9y;+4JUV zI^0OlKh8CKq4hB)%}+X8fU{{~pjsHA7VF<8IPIL3z}^ne)xmjo(7z5rMhA!1VPD$< zq7rTUs{JcFcBul9)sNwC)`k=@(!07FyO6M^5P)Vyr+SY$m<$1y@pMxqvv(5Uq@c+tnccC z=Ym-An_XA(83BWn4-bLNP;rS$vd_h&n2 zlyX?-7&vyF*$4?gxkfx?P22ulBp?|^4mI>(&_=&2@DYE<>&w+s+e*8uNbJisL_ z1p?T(1#~?I7oiLDx3~jFTo}R$>}}ov1p$MJlZlMLYy9Fpv+Un2ws-c+<__QhIm`3M z`0Ym|09|DQ0kCJTGiZ>YZU)(#;n`+z;?pYEqAx)tBoOZ%liX{Hy$i-b0-q^#O*G)a z21@W1^8r{_jS5$ZFj|JOX_b3sCs8nq;^>2I^l_PCEVJ%qWUq{^Ex+HL0EhaeLkj^= z%m!c`$GO%xLE$)oLrEo0;hfO<(k0FSaNW{JTn<17N(ZFhi1z6bzf=-Xw-kZH*ttG9 zsWafAnGJ}JfUmj?Fl?uPt~0S0`Cz61K$w7s?EK%g2JVtXF#WuUqK%TG93EhTn-#~p zoa3}oFLz8plx9pXjAS}fEP*Q+$~pqLzHipu8VE-V1K-)qp+0@CzrhV{;xIN5k}V>) zEjD0_jof7O`)p2EX~duVg#WcXsWiT~Gf7BL);) zQYyiBKWVTAN?W>bZt^(S9!FqHSMAImPYi2`wF=&644B637J06MQv2NFFwuR14GjiA zHg)(RcK(la%by(oa|{5K^XId}V>^>!@IA%@s04uV_!k@Cf;#~Yw)4NxSOBH}_wqzQ z*0G2(7teQFpl|@c%-0BOJwjkI@>sV6Vu(i&_z~7|1fv#{0lC+ppM1E>0z#&;pD{sD z_yCl9l<$rnRi&j=pF;6O9URn_DA^d_KZa2dQBaBN#k9bScjl^Ki>`PKsX1Rt~&*mQGlMUCIyE=hT(IPdUZBsD=0NGyPnS*lr zyGC!bcT3m$^#3x~b&dP0HU2gTfM$~me-)=*M?UJy)&q>e zI)=J|<85&7(Zf&B(fGJq@01mLt)1!rtbNP{K<7%|afg!*I$w9j^FreS4zjPfj~)Lt#szeYlTsOg zYeuJ)4p0ZU)G9z=$w7c#1W*AEWDSG3O=W=7eL#EI|8FT^m+1di^dLqek+P`gS}Bl8 zghPWCgu;&tA)Hb0dr!y-}!kelW@)vw|&nwl4mPbnC+To5>oA!z?-!>6r#xKVgy4u@<2c1V+;aBQDZoeG8oEgV7z1S#6vRx5Kln-{kskh zaHN3|P*19G0vN~OtX3c(q^|75n2qaGI5_=GIz?H0-Df<+)fA({n{Tu&I zl5Rxrt$;Te%`%2E<^m`}f2L3W=eiSsd#c>o08Sx(_cIXi^O+75Rp``v-81}CmjGVv zlf+*g0DL)(O_Tth;gbp1n7zhs-?z3$dO z)_e)Y7Ts+0mJ3l{O<-A#dx-Y2H)U;kS*OrT%mZ+`8356*)j`waUSl-80CHC(??nUv z+-Ku0ZujGv8W`AU#rs;O*_EAZJ&D%^SxyT_t9Cy2sdZYOyuukU_0~x54m#C2&DjEsdYd)u?CWg7jkn1R zAe(IhllG%sCeZiuU9Ee#H1H*tEii@+40eM9NMkz>9f5g3H(GDbNuv=|9OXlWN&=6_ z(qMEKV25HzlDa3}mEgiPoZuSwQ~z+ znq^XB&tt;jnJy#j%q(o}{VpHjfT9hN=daECZ|Xic+VX{N*N!y4L1h8fFWMVd`DpqF|IzG=c&Og)u zL1hE}Xa+%^DTZpH`!Q|s7-MRrZ`jmXzH9a~E(;*1v#&B>@W<{FcyeNOf;0#joF-VB zW}igsJ@sdI0=(PZY>!PA(8vIw6G0EYr^$fSDl8y3@=#GJk#(OKN>F?Z9lM)30JdEJ zN5+C47~524&&t@^7!Uk=w*n$VK?Zb~Gnv?-(l2jQ3YhkbXA5E=wFV;Zr2}0K*u@9P zAGjQ#PN{;k0538aP(VO}icuZP^F#@AsJdqf=@ zPjbs227L42450C=tu6m3M{ zzTGkqP)1;6-L%0ClLl!W*b~trM}~lPi?Nk_$0&i3dRU_r@MMEsShJWDaFpv}IB2y} z#vlz0R?Gvq+*yDh8wc<(gK&6X`NuBV5EM-C9TQi&g$L!R9BP1%6#v0a`-!_j=|LR9 z)Wrq?qCnFamTC4R=tyrd2L=XpW=HlcM-TIx+|PVo)-S_g@fpzp2MutM*Z-J7jr~|) zZ5H|780vz9)GYa+cg0AFNT#|^Vo_oM&AbucFSp^A5$E&E&oc&q`&}V$SXs1#;o0jK zWE-4D?g|yZzV7lDfn%`ko$m}lHQRBUk2kn(J8?5D99iolPPKD?t@>?V1V1gFvxQM< z@9q>n_t56r?Uy9zufzYld%7L>r8)UC+H#TCE`dT9+3O-FU7h-QPls!DxYy2=p4-9u zI`Ze7FsQX2ain~p$>y4hlZw3_TThR?zf3iZDONh z)Hs1-8>8KRdtwioDvw}0#7Y<)1;0xQ;`N%>>~;w(T*G$MziKj}``ekn#Rm-8lxfoo zbD~{+vH!-}uc{Maf0GUgT-Z*k<`vd{700;xbia_B)rVyuw}O*ed8_wU83dJk1X?DL zU#U3AcvN(nlHaB#jsjRH7M zS=MgnAb{%xSHUUnF4!|UDwaO)mQ@0TU>+QmkA`we6IYSvq9+Y_fHs(o@I7guafB6bkRx!V5%$ix>^_s_JGgtR_}@>CP} z*M4)R0@bqDN0>JdqD_Qg^BKti*i&WzLFjPJ4x83JDgl2n$`=J**U1LsTt{hF6@9ZA z8da=b=w%j6?S?VsYck6ZRTijvzQKsM&$`+Qk=wFTsYFfHJrabqfbp3}apxuy*{!+n zQ{4L`hQ2~TG4bNWJe1gMaWd;4afU*JS`o+c%vsMKRZ()Cr2F7R46`U0ZZTj zQ1p?n8VHCijQr7#e}~%xKWp0HZ<;UQTEFj4`QFHs;FN-@lIIOD-~)|nT};$#Fae^l zB~DN!9A|0OigO>AVtBUT*q+N)n`i_4q$6_m?A{~yZi2O(V1FlWFaYob1AJ~V27v2N zVq_+NVj>`&4(6Q!cz`ni+~drynH37kQuaSsAs_FwB(f!9lVHt!u>rBaGXaoJJipF* z=mPtop({ZEq*g#=RdlT}JO(2k-14f^-Y)B~O3T&=Vrw|{8U`lD0PkWXIfiiMndul- z*|XJeXT5rjy#>m3FE@64=##)#`6(8l<+&v$nL`q}0>ZEQwM&i$>y9xlLHL13CqOYu1j-I@Akh%C z021~MWYmiwsK%Pq1U}rwj{h6R2XOih5~BUHTou^>l?onZE{o5(Q{dbrxQc85db_|g z#VG9E&9Q>L32J$Qh?p{notVcK%nN_Tcg7$s?DO1D%p~~LP{-1NCST+;sU4ha5w_9&J{@&!mkP4j?84E}0VqzcP7er~emtebN|!eKUI) zS;SWw=zV}||NOp;&X!r5GW%I(FJnR}ds9X)$C06N^n9G}9OoX!_xFLC=ZMy3o&K*g z765-%BG?Pw6SV{$Yx}1_0NY;LZ)Xe)ikT_g_t>?@=poB7Hdx&Qk908bqznkc`OE*P zJ#gJYKq<4&F*D#i2LWmge6zE(_jLd;eqFY?Ra7f|tc|2d8a|RO9E#``cTa+es*v<& zCOTI2D*==02v}p6tk-qes2=a_qf8r|^ftKZ4Hm1F=i8`A4d^l zCcyg=jTT*Aaj1 zHX|HEOfvheIRKEwS>$aNxtc>c=RV+*3;Q+yRvWkLlUh2s)Rh5vq>bdXQ>f|$c$nJ& zm)x?2GFCB^wTC*5i!lox0KRYe8}0yjSGKaM%SOajYpluo{gd{0?N9Fi=UyA^U(oxq zH;oUcQ)}|OCi@u-d<#yaE0wRbIF72tv$y%~Hf!DHe%tS{!^a`C-)a!wqU-i@{H#TX z0HZ@N(UCs0jy(dD9^cm^*ze)sdaQj9ee4npb}>X<0S1xJF89_YVCiBwyWCHg=juMt z?Y+N996<+1)#3M@`x-}Zv%7#kNG(2f~H-i1NL$GBzGSOPFwHme4Ok?=Sp1&lS^@4MS?*fE zwl2If0pbf!bUQ3M8bgJIlR@|9FE)#yFap@wdEPh2bBIzqhHGI<=Q!}pu~xI+G7jK! zV*&1xt+_!O^zQ5inC4zIrF9zJh(TWeWkx{sXbRsE69a|#M}{VUVPdzVT>?N}D$5Q4 zUX$D*6Ufd4dp+?X^NJjt2aRX}>^l>%XdD3hUw%oJ0mjkoaeg0cfM>gv`N76B3G6IB zfFV17bp(9L>3`WhY($CAl(<$<1wS_NQGo|obyq;kW$BY$a^`RpWNU|~O&!G!1W}Nj zKmL65mwq8n0mw#10w5?KRmco?fCLW^5zrZ#3Q>J@TEq(|@eE%u+eswn!Zqn=hr!nU*5yWbeq``AOq53b3_#y5%@J$LY-9Z zo{V309KwnKFDz;m#SFSj0*fU+8!T#Lrm$2w;&i8)STGG(5$|@DO%&hul1^TCOyLXE zDfh2I6ykdq+hOHZMt7=CgQ1UpOrl&d;T4HS3j_g$T{Fc##ODV2ozUtG<7feTe56dcLWEQI4UuX9WBt=LHP!;}pL# z2B-V-xV+%1(c&OnDYTdN>o5`iWs8e z>-=0}5p@FA%PZq~1ey5SZ(LRJsOn=3_#jL{& ziWUP*eq==QDNaKwZFxu6Er+rtcAmYTKi2@LpP4c3n+5=$U>*S8x5W3vB)LmW=JFJS z0Qp<(0qy{hA!p6hkG?$T`v0F?_a|_v<2csPnRT4j`fuD1e|Dnb128KL0Q(>=|0aQG z^EC;cYw-*%1=`Q_Y59n(`?oQwZPnyiL(york;gU$q}}oh2h%}LIy_(J%;egLRK9RK z=uDTtb-$Z5-#zxF$2EG$M32)?kJCwy>vwsM?nY({x~xf;_3fhDU40%s>k3eaUFq`t zUB07>?dcHkbddWF>(ybMI%*+Q#{rJC!#Z}@=QjJ%ew9lTugdIWln#)u_StSXWQ|%^ zX11VtU3Nc2>7#4x1F{tih6Ei=oP-95HE{%u=Omr^8f&%A_pNW|Oa);r*3q%GF;fyB zo5W{e$CR4p#%6R-wvx=g^ff+JcvB(nz5)o@mp z6QZqArGOKR3*dfg7aLT_XR54E&=c$AkFAKQhRDwndb7m$1{3U^-6?R6ZSnQl`l|UC zF-zcB&k}g3U%R_BK#(&3HQQ|*(meM)e+Rb?%2t2f`~i0{9^lf%0z`Wtf15!UXP#!F zAnsxMMl%IspQe%P={salKec4iFW~~vjmhsB2c+yEG8jXFbV$JVR0ymq0uys+nP9Ic zKI;HL+#=Z87zx~W_YuCVJnd5Ct9Ry*vi-76e0;_L^1B)c_^8Zgmi}an(~5%u0=^PK zh6c%%KHzKs`z>yO5}zwQ&;WAT%q@2WD7(yB2T_nP0jE0{I4-eOfd^10!R?$C;2B5R z^B5e|$wO%b1nlkT)&AQB1OS?nG^KVZ495)4c@76NhjUs`U+5ju@m6)JzCKa0t1oa3 z5(BEqV!{WAIfA$zN zM?E8XqD2f541P*6KO+HYQBUEtFk-OW@Q*XyK2+z$`V3y+7m73Z!*t-oH~J*~8=sC5 z@*)CP5W4@Lr+S>`5K1$|HHQ$UA(Uqb$2;_9^ZhTG{g3+|y4F~Lhr8B)l7oO}?aWSr zd$>e!rz|G~VUT{_$K?R=1z_NYw~~0MaFAO9FZ6^!Ie-3EWN(Wvcl!UVoDVR9!x-Ur zF%RIp1TK!8VkeIR2S31_Tq;nfz_T0(u*NY==o1bUFn}X}XD#cy3qrad)Ib>Ves2p9LwH0fg1BtRG%(Y98R+u(ecjN|NTJV%XStM(V4 z+J+Mhw(_a0N7tX6oEB@s$jH&N7mb(NF@4e)fIZwRub}!NSsxdozxBqQ$=s*byazjd zetFi`qZJR?X!9&>*01w0JKXylwSQ!$`r~x|(@f>7uHR*Uy6jJvQ)-uW>#^oNjAHL9 z<9i55dza*x?%q=q92mpElpRpk0DbK7%w2-@-kv7?`mTw;2)eqbIx|3k(0RK-g{)79 zgGNVo=A*oLmd=wh)gM8DN*2E}mf&ZZS!^GZ&mLq%+?Pm-+UNN_tZf_P*v28X-)NBI zN_IOm-)<72CncVuxkt8B#*m~_lX5vmFJsu(ev=u4^|u&Tz+SCwdyc_7ojFi;b2n!Q z_H=M?vK>A~zpgF>&WXW&SVv5zlxl#9_uW@;l>ZBbWnC6Krj~Lj|Yq&;GnW{ zlAXRXsW{RVVG+3gif~dmu^58HS_SzK_ZtL6zjo;Wdn7vQ$O@>`i{lLnVh$%uUp9di zfkMn4KzA4aVT{XBiLnwkVBrTzf)!YpGu#e~U0QgWg8&@SJbOHk?T^_RtnWOwYyOcg z38);v+Rv%=Vyk;#wuH6|I4?e>_*|1ZM%TPbGX_j8Xq( zg3HIscK(IzK#NW^^eO0qvBP8PBG|(}_i_Mmwee|c#a0{koqQ0(hm7qP0mCkVepXs# zRzwcGX`T-*{3h%D0ap5K)+AR1V&P%xJp4Kezs^R+bg!%3CiI(BybeOu;aXj#0oDE^ zrF)3e{5aZ%4B02Lohew&)RMC!fq%NT6k=61E_E8nq2oB`Kb!s5b13NCrdvzYmPODo zdqko}_4^oGNi?;by61idSJ*0;cV6>y@3-?}9bfhnT+#Symx3dca?8KZ%f(pMSe@B}&*g&X+(&KM)C zj)9`uA`fuc<5_<12c0d@>7M{j?13XcNX$S40SK#j0W{EJ>{JW%e>>7u7r~84OP63%htbn_H5x1PJ2GY zh7Z|T+|8gVouFQrssE+FyD$5zcK$qn4WnGU$$jDI#xe@KLSVXrj;$)qe7L#)k-c@U zxjyZ__W#Llne`nBpluLrG=7)eG|gLm+PyJb?d06s*W}5#eUQ=iA5Lf3;aZ)eP39wf z&T$6mea9*MkN79SeisMXMW4FpQkOOF{wz=Wz0a7ko9F5^b3j+0{poEb_NRx=^wb(W zZ_EJ3zjwC(#%ZX>wR`AnPr(KE+DArPF@H!N6PGSs+Z5N=ba@3eUBo?9%t$ z(x@^3>%4p?mj|$6HEdpx4jtk)!OPr2cpqo2^b_5Pp+s*oc@VO&NFcaK;IN2{En=q@ z(TxS{O-vSKpBFyjmciq#C+z3^56zo#rNM&22Ry+g0f7U#2aVs3G61rw87)B@{Bf56 zq^krWGkY2kNWe19eoa5e-2mv$)I=Wmrfz2tFl!vN;OCeJfakBY%^7lpU-!szqBw8@ zT)dxK0srXq|G0wz{X}+SL^=1ZvE}1Gv8}>>2UpCgE(HkKEW8r|SgGbr05+jCSaHHJIWdJ$vmJ8(me@s_p`erDmcp z3BcFQy3s7BqnOTyFlb22%!S_g5pxt^9A;VkITl{@tRiWdRUP*|S>qJ}Ol8dd;uyO! z_bg^PrEHXvmID(izJO2`5K{Hv%V`fHRD--{kcA%PG&9I^4Wej6)lAceqh+BBI{6FD zFLXbfILPT>5JNtQ(;XzL9Q>8b2i*G*25jhr#1ss1-Jx?mA3!CB8-22Wrcd=4gCW*` z=nu{)2vB%Cg9rIJ%>E2N*8;W|o%;HU6+;*RrPPjcJ0L;WINvY2%`zvZ@;T-JILH}*_Zhica~a@B za{x5l0YFeQ`I*~v0U)ze$D0nA_fNBjF#zb1S^Anmu4j;kS(JG8Nj`xHK&sP8CCg&- zIPLit8sKzeX3G{hAueE)76=j+2(A_gQWn`0&2EojEK2>WzIvEb|KBkP3z@44)vexe zWP15muJwHA=U)Fp*8bPOll&Nw6?k6qXEf!kc*fSv>Cj>z z*Q@iS+#c}BR}NHw+!wf}&-FT=xAWv)I|P#5$0b2m7f07+J-cD1f=e-3Hflx5fWWSrc`Nh6A*rx^#tHGK!2q+uuXRsAw2i9@6 z>o~0SduONAx`H<3XH6~6tgVI_MOFa0UeoWca;aK zd^V=O68u%)c5!Nf5dSnc8H(Zo@iaf~v+xIuwy zZU-a~DkEQI)}<`)->=;Y$U%7gVjp7A%V647cfjAB>8!XLKzsn__#pI5mjJlmAWBmi z06iV!eu6G|#el%7e-c=ZVaH;Epg@8jF)$Fl9AiJnxK2>8BX?uyWXxfCrL(Zu&9P$% z05rWxlgt)SmPNHH;lP&=o~jX~%g1H62Ntg~MgXG~ zLxfnTkvsc6$0ufDWXxRvJ2C(mRSk-Ji}Ar2j(?62j@A`LpvSn5rBgq_PU*?6i3taw zmcP3>eWp$ToYFXQSH8Qs0FWthb597s$)0F#MRWjguM;R&1x2cG&y~I@Ki_EZ56UyC zw4mCAkdLXeJOhIJm?p@Kaik~sgrN?Y`#AkCc_QeULl5RS_0FsO#52X@zoBe>TDXVP z{>b72&$OV@)w44_DrU8%cO`a3%xhJpSk;DgXSZe{*P?z6ME5n>#j=7yUEL=U<8=&Z z{f!2i33tO@t|JrcCnvq_`i*ut|7rHWjXb@!?w4(J?RtXhqNaZDOp}Ykx1+4UrrY)I z>iRoDLRVz~*0Fo2k^IO=4>{~1^SyIi>qmZi=y&h+KEV^r^+tT^$0+q#gMQsOAoixu zI`s$q6KC14_$SZTM_2lMZ=ZYZ-z_miJ)WzFPWC?QE`!&2J_u{vdy}&bDmfsFy|dhc zczRSp#C!#13NCgl;z2HH;-nkvX&05TiD5?E$2xMoMsTxsvR_|t zcHqm-4jk-Y@6N^x{LGnw4<$!IWP>;z*U`QDV=`N?s$h}tUS*wDUuhtrx(?2CKydez zslX8MJ`otj?1O?qgW?*%E-n-JEE9Cpe&f=>-ewk5*$Vxtve%kkxwK_Yi^rQm@cs$7 zUK}%pFxQD8SghwFe_zDDEOHME-?~jHS6G?-GUFU{!ZW=1{rvqi%Qp8(^bY-;Etn60 zwf`4YFzY&lJ()p1XP%$bz|+WE4D&i789t}}o@8HB_@gPlYYLk?iSA6c4G2c&Dt~nu zpkgcl_NK!3$7tZ|O$c_P4hzy^+UP%N>YG5u6{00P?*HZtge4{!j0&IUgK>sI;?2LQ;F=;oswpq6t2*_f<~ zd<40gf&hHu7_t(Bh4k}M+gkQw47)XUflCSBj6>KiyUwa76N5DW_1u)m0w`69aj4>m zYHxHPpp!X~TpeW)4|)9;2EiPer}~&kc7gkmS%4TWa+1k6?vd%P)kh`a#qw{nXI1s3 zs?tthNfdNU;QEPwz9W&Q3tM^O5)b>#?cL(>Xf|-r8+Ncco-xu>FK{m?#$WTIr#^1b z2M?_2P8uSkUQM-JM31GSqkY}?|CmJ0$LX5u4q`k85%@uj&LBo*kj)q*3LHE!F#$t- zcIZe0_yiK%0I`@d6m3q*$DpY4K&x&r`XH_UnuV^D{`?TiF#QFy26fPbFDiJ}dVJub3F#kXYo zf8_Rd=4t^%Sx301BBz~V!OmYGK>;JLaMnP-Ct@!W>5j1OBkaq_mCgVVz=%I#6eAUs z!Kb(d1!FY&rL0Mf@!VqsR59%e=O7O3Xn_$q#*Hok?B^8P3GS=CEEOu|RIq7h6l_AA0LV>+-&K&;O35TZ_so({P=H>S?LYwlJT|!ircw53WPcjvno+<=^gQ#) z3?3th)ak#MfF!jkDMdMt!Jhw#TbwxYF0khd+~)#De}RB_;cv;7w)iDGe;G;z0vMhu zG8AKEb;`ncYLJ$A;FsTKP7BrjFEro9EAymRe{`bJgZM{nYFA{p%({STpZ4IJ`}_3I z{~PFR^TF=^d+PISeT-m_b?yB=|J_F?`xv%9dfR8u`n$Qr@Eu;0 zi8D}XqKi=tD)PT2=SbW?Mtg%`ZUedNeb+$)^55ft(_?*lDr?{vx_8R*r5Fzb(0H7A z4HQ(38ECk_iINCJMUyO+#h9@m492q!c3$(|Ae-yx?K(2Qeox~EZt}l>l6($gbqt16 z)?n?zY)4!p&{#wM>gp;Ob@zeV4F~*ssXGg9a&|yvg6j+>9B_7kdtFs)HP>1Bqj3Z1 zm*|TFF!)!O2Gnx>(JT$r(8t=#vI9#%!C)7>GC2b@%VMeP4gq9tiTzmO85eJK+bcF_ zkpt2q`muPXSp*MBVC(|H#KNZy5@d}QxZcA3-8Ohhf@kl`#Rxcy z+|2yl%z&quxQlB~|I}O_CuVDJU;vP*DRgTJXFv5{$pJD+;4}F-X9m^vhFn%;JGk!( zdRBRgGXM$zeq;M`PL>;^Bj6g70jV6o-!wO;OaLeL+%mR#99uHZy#zII!2!TY&I0g# zrN6p8P=IIFJXivG#-Iuo5bz-`1+YIQ)?Q43W9Ur)0@V?~`bCF;N(4&pqkm&{X9WZT z{J#H>Tn3w<-mAkG0p{3S90VvR7>jG|vg-^RK8w)K9hRw=`Hv@xd67+u5vGrJ2LKmX z=65R#3DR5rT9RHUEmh|W*I4Lv9#j*%8cL0+KbeKlkPZpzDgi)nV?WBo6lyWycT116 zfkbd)IK^4XmbN7D-=&#e73gZ_#-whI8P7Px%6TSfz#vZW{t60PVbdqSlgLkzKSYY> zcG!ip zAVM+t_N?y@axVi2#sGppfD#R$hy!faAnP`S&<$}q8+w?*gn!M~&~6SO4tIcXfja}( z;Gy4V>Oa~5pPktN)%*W7Dezuy1ysOtUZVbozv2u4&s^Y{3n))PB?|Vpz&#ZfGYAOu zKlfC`uoYSFB5N4Kiw<{fUw^;WPX9ay0B88$`uV!VJ46=XXmS#F1arP?cfIsctT&^?m z=#0`;w^QU^Vc#pra%DSPeIf&Jh_e9S&Q_q{0T2cN`HeBatj#nAU}mq(FwL-UF|HIv z39j;6vMot<$>2HX*%vURF(dtCgPkzinwGYRd@k$LLn~HSiCoBL4Oo z20?6X5dd(aS^kkx-0b73GH&n6cCi48z1;!#6HHx;0bGBs%K$e!=w_W7=vCuaI3Au) zLx5Um8x^lEoQn+NW4*hNNT8jV{4`2CPS-p`k9+8GzrBmx+V>4!D|Ya&N(bNnAur^- z&zknp`99CuZ>59ZV1GB+iw&H`279}S@!H_vuz`+lAOjm}4}M8b1dSIb(Tzvs=z^`+kbPh0nbwh`HG-lw zKEL)2Gd?PFfGn>O7_QwdO9u6w?kphCsXs5d3+l*O{Z;-yLCz}cw#ps`b1Hkaifm{^ z`U1?n#kcZ0D0L(z3%=93bCxjy*pGSa^87)j5MIvt0UEv)L4Yy=$aBo) z*uxnB9SYgwnZ3;lSo$|3U~~fr_k-`4!j?_3ep3%~0DuphWIrakeoPBh5U`m(C0d9d zo;3Iq_<;$6-w9-Q0v*vHxbn}FgzR7KfCNQlo+DUFxepPR#dzS6^f_^OQP%lWZfRzX zV%n)%ow3uUKRWY?&c&p_R~Q(5f?vvx-ri*Zt{qIX_=eKa#tR&nHdK=ZBUA7b2L&oK zsLN_E0}6#9s5pZ#@Av#lAV8gb4ocvYxX$MuV=x`3j0L4_a3YH$h`eNT}bMO`Um0BDX6Dm&Wpnvau{@fiRX4-ZF+{f(4ymgDPj|Mrt&yQZ%AvED145 zWGN=PQK8u};zc&4_#z|spO|fQgG6_OY{uYwGxa}!F&khp2XJl!Kl8~RBQwDB46;6h z2*v=ob1Qre{2w8WEUmO5W z{P*c!>Ho+M+{3MbJm)a$qjtk#_GlP~5j4Yp@=SmeOawGwEP&eo?rBQk^AgynbqE%~ zgA)r-M6in}bP)qze2y^#2wag9Ymo@Hi194;9XKF(BkYS96Qc!?`xv=C0hPf9$TN+; z!L5L=PM(BdOH>9x5iieCLVilctc%6T|3Cw0Sl970T}R_2QC1D^RVL#=Rwh`_nASCB zg=MWPXQm=g?vkxOlaFx_z#hj~&=unV9*{&K>I#`gNi}O+MkG>-+J-S&s^ zn3I8Go#r`>#5hzO%L1|;yy%kMKiI(G02XlsOV9ABA9<-h%?xWe*($%Q9hgK_!S}Bd z|DD~|^?~HpSUtgYUi7QZXT?re=f2lokUABPLMU|%V*>}-;2I5#Ujun>?w&xk==aBv z#OQ2fvGaNZb1`P!uVh`n#|f}^S_1dtbSx)|4d^3R{pV#$zK?G7PtLUc2K%x>pxFO) z&hXIB4Pxp^0kS9-6S~Ol(QxH*hH>3k=qT{e}jA6Kz=qhGhm3%vZosu zsLcmDXuybVaB|wo!kaP-i@o-hrpLAT;y zK-dc8Ean{WENyh9#do!^g)R29i9Ra~dR4{IRWV4;xa!Viq&(xDl3tV+q5NkL|AU%0669W-+ zRX*V|;$w{~((7}{6dM7+uY3SOe#!&x3?RTQpPgX9vYflhn18wrFmP&T@&piwh#*L0 zXQjV503g5-18NC-5@XSk=MuIoW~98xWdS+)yZHa?MKGrlK$Vc45(mT>Dnt-hI@y^5 zWTeEpmR{~)g21oz@Y`ezuHTvS25wdx;E!^Vg7g2aNx7&6pF7)Br?1V@z!CVlK3^WIgRat5-l6vD$pFJd$oc?b;^nqTt9BS7;A z)%;}!h1}1me~fYr?RjseaMkV=tr>C<4>gF42QQTpff*=q)npJv^^TA4;`+%0k{)qH zP9G&H;7kjupA%^guV(suNT5BQXOR0I#7Pd~6b1-52Dr`un?CR(X8?HC0UY1}!ZAQ( zHo!9uAb108&cIa;2Dt7Zn=;7X1`+U~{nF_R2M_^)fPfgJp(i*?pi%%vX6R7k08o&MM9pVQ7T>oxrK>{uA)UWV7R1#lRLH2e>f6|qi*%W^1Cf#)d7(VyZj z0EE8y_dLzZp+}wnLv9f~C~*UY@A>E7TtdLP#1z45W(tBpNLYXijRg>(@)o22A8jrG z_F@!y89ggm0b{Dw=UwaiX8^z{GNu9E$*5Un0Ep1XuW%%-RvezW%=(sZOmyx93NbP0 z?2m#z{rks${ULE5YI6-LU`71v$pJBi(oCuKkM)`UNCp8j4@`9NEP?JUYdI?p0QO*x z-_Lz*=f9`^eZc+ALr(W|(pcOpd!b`&ssK{#-%`aX|JSD8RC$i-L=vsU;FgjJTG-Rz zoX7C5tQc$aQC`=(+{SzA3al|4YdDd$DQ5sMuL;KaLm1zlWapS?@kN)<>TE=vn_d*X_pGQ~YAhHhIq`_p!-6Z+@TG zkOKzRZu2hw_ep*aItW_1ie@wlD%5Seh967B;W7TjB%)D9A~)aiD>N$ZF%fWFibIbew|*o@umk z1PPzZjKDh2xQ@K9tE9?atg|+23JOOZ2p~gi1Y>L1v^8vt2DAxe82AA`S3k_$1FSG&H!Zs`eqH3Oyi)Iew)DYC7xsHb1n^> z!;Ae{I@+88%8>E@V8}ekfitqafIV4Yedc+N`3p=EbeOpT_)H8BIx;a}Q3gQnW_4iY zzGfEPvMU_G?hXKugK6G3eVj7^{C-M44x2osY#{qFsq$dW;NauT7RuUJ2r4QccQ=3n zfWNuL_{*jT=JylqLm3^8c_eBDyvTrZu3si_FW<{}C2YE;#Rf?b`zRu_$OK@2W8R5u z9JVNU0r00Kz9+f_hVrl)nSf{7!T*;*f_zU2SuOG1K_;X_6!%+V{{uvg-3V%R1rV%f z3Hd6qw*fYM>CS&M4E{c|3Z?rH08~^T8PX4k7pX>nFs#j6Ftsppy!|5{{YTqfS_W4h$WVp7tqAqY z`c88FNn~;IEr}ZuGuRYHW~yu!K>j{`PIi*ah;T$HM`Ui6HJ|;vS^t_2h992He+xo3 z&n81=aH12qEq>VTetbs^`e7}q*Z8!ge~+19gMjhv)5w>gG-`Zvxe$m#hAaS6Uqz*+kbjIrVJv`7J)P z#WQcS9$S3p7N@Cg_GTNs+v2)g+`}eozWKX!xSPo8Cil3Bu54i#xAeZ3=1G0?XS~Mq z{c^yY$`JfAgM=-feT#r@3+J(gJZ|3XVPkUS$it?BfPZA*utmVJ&Ax4Oy{p-`t1;MD zBab_HZF8+{g5xb+lWT7igl(e>+dR(}y1k`<0Ug{%*S65Z%||)|LEzJWhk=OLknXk# zjL@MDj-!oDX@A)ah3HfZeQdqOWJLS3UpR{f>)t#h0h`UelD{G5HxR&S%z5K}N$eD} z3shQF=3v+4AczveC2q&&`PZ=>YyWLRvcaU--Jmq)IW<>h zRoSPpBwt%8@M67|(f4Jpv&?-iAD#RZwXeHf6(?R}e`~v0ra9GCb@IR2t%BU+(hk2A z45Ra+z+Sx8W#v;77`X8LEHwvs_7TR_uzvF&bTIy}22e-9%iJnV09)ZXD_>1kzzXlH z?CvrEpPhJ*$${`q<$o9msMjZ44k(xyNHz-FS3caCX_W;C>VhtK%C<}|?roePHM#ai7}d(BEL^KI8Xbb2T+JI;P4F90Vv7oMCHLqNV!4Y)LGs+X`Dz zdVtFaDhcomrTxSNh+7 zt;870?>cHE%3pcCBg{`E35AAFEMc@4AC*0!8p<=T+WzyLZbd+5#wmkCCX*Juz`__oP0Ip)@#%QG|4q4I4eppfdztbL&Sia7Bz+;T)&QpXyrs z**nehr@69wErnPebxW@&H;?*08VHCp%_3Z z247*U0Bbl%05rIst%1S-1V6xj&H@}_z@Se5pG{{UTmXA!a1tB=Z1T`e&H||Q4`m$w zoE`tBU+md1#$=d4p}=Pghno`ki^*?LJk(B}wJ2Vc*^uIU{5zb2<^&Yl?jB(83kX=@ z9~l4?G5p0xnMXi)036x~dlYj6)DFnnj38{92N0uz`To&;%{_gIsVKSD7;6#}6xrj_ zy&dJUMo|aD2$XJeq|7~zFBnn#H)nQ`lQQd2RwfAJIWe3Ro)w%yBWvd42TOk%7#6m|aTnWb7lkroz` z_+$}hx%hgg{W&FR4toU0>_LsSs1eLnznxt*(f5yYtFd+(;!=t|&JpU$!cyrXJbb_-@zI&5r*ks=} z2@U%Tx{bow~(i;ai8Ql^=_ey+sM!k z*5+zt@mo0dZ=v_!!m)h|!+bUNVh6@_2hXsBYhKO1?m(_~aP1vD%MR?r4xG(4j%thN z*~Erz-ZL{HksWzzWxRJTM|-4-~x4*S;TJ~fD_&2zMozgEMz0Dj+mlLr`0XZv(> zzyq7G!3|Dl4NlgYZm8J>>*#RiZQflZ%3?6!ixdH^% zMyIOCMHS~-MGs=Wh5m;AF5ToH09jl5k1Qp}RKZiTyDQ3Q$^;)}{tWJWUTxpl)OprW zW47nev$=OU06<@7k*`_o)GYfI!+|Eq#8sB;#{m(8*re$gABIfUcHRqExy0i_QWN zaF)@b@(~6utApSU*sw1c3&8q~zstZtt`|4}Y*>js4LWq5xpb)yM14E?TeEyH{xE|H zRYqXnN;=Ko=zsslLBXQi4v%#y^`6cI9JMoN4e&nY@X2^TOF3kXNde@3ttF%*lxO`1pzlc?c1G^2X?g(eN+CRg`Q_CU>|Ub;Nf zKQTL6tsZRNtZJ@jIDK=eTlR3WQ*6u>hCpL_bw4uZLi|q%6o#P)FyGOMbR5O_jJzYA zQ4rb)(XP6+PNE3%2#Z#jvQw1fN3lf06MgzzXYiLk`Rg@h#Q$DK{c}G9f3!14@CMlI zfk8WX1qB2$1LwN-|0Vyf;c~&XnL!vN_!vYm2NhtPW^BQil2&+7S%N>hBp^r6vks}v za68-nqV|u$4?5wW+WFs@KZjYvVNMG%Yv3C$12mlh__=9}b#f=rD)7898W;r*BA~k) z2k=_sAWk7X+T{YCrGV2YU_=Y7UEy0UA>h!97}Vm~i3JGoAbT^y8jK8N05D24 z9TTVaPI~0gH#qUMc@T)*s1>@9%Su{m*CWKgM(utZlF_o5;-OrYCt~h&DN0 zY_WG+&vqT1_13;Cef7PTR^7{5rD)TLckX zoaVOJ@9n)DFvz(pgMch-%lTu}wvn%GUF+3(5|6)OE4GovZSH9Y`nrR4*m3XtzHJ2{ z$maHEc=7oiT=!~Z@M_laTkOfV(Yb55?{Am*Kf3iT0<^2q*{k{PZ}IHk;<>Koey>K? zujYAna0=UIf42yPHU(@v?BAGxKKj-tczw-B!pwH7+pg<4asR(2Kok z+&M{!)?e=u0W!U|W&)xkOge=8#8`FKbd`HteXrXE(Fu(=4%%T3X)8FV6|S)?+}FpQ ztwJwq3S!kMa8k;3l{K&OELC-lEx5~tHK{%)%e?{cex*BN?(9S4jPYMTF(B|^ z*P|s+9RYlP@@FmseC;+^fV(7DOa=L>U@t1@`oxbCZ#IFgpZJuq06a$!11S^G_MrqF zic#g*)G~TiMo-EF4CNOZ8z6jB%Nb39(pkfC#52f&C)= z&zcONBm>;jK*8X?tDNp1aNQpT8eq)^FgODU-oTde0qPncQXIG?u>^w%^Z#P%yyK%S ztGq7=h$~7_SwT^8Rm3hu5F6M9)U_a%WfcTPlrGpPf*?f@3yO*bQIkwElQuQI_dYF| zNq-86SP;R2ulu~;bI#9Q{+Lga$;^FU_qk5HPWhci6n!H?(+IOS;zTvV%#GZ`(FXsn zqCgaP6H2hj90S(T1k*GX)oy6101Tqd3~)f8!{XTzcgX?3>raeCCxAr&5_pHrFjn*7 zDh5QbTJ}>&{~y8xfc7ni>ZG3#co5Ik%(FDZsLeP#%>&^Ccm&{6Dh|9%PS(qLoh1Z8 zi^Tj+VgDo53BZXnb%!vicdGRg#&j}0;)t;i4Ov@fx_80H-8ggIV*&WnYxOM0spokm;8G1nb&zKtY?Bl4LK*#ImHW2{ z0em+AU;DroYp+E?46%QX{r>r=+Vt3jbrw#}VX-Cn)p}pH3ba zxb{UM1+Xgg#k1 zR*?%1NDD&|^_YiW=Fy9DH>)M`WYq*%jm3U~F18{;bnEofA`&nO9Vg*UAH$4JnM7w! zVz4LCZ<8Mm+>}Wi%1L-;Vn=ikOrSR=;I9e3Gr=i!{BLsjkp1zBoC2#QxJfe%Sg*rF zqq_~t*rG*VM2If+VMf+Hz%_g}0dyW_Z-%Xo%eqfk>#%jAObSKtxF}Hd;=pr+9yp|Q zfbsCxmCkytY6JfCxY_`V20Swkem+0oBz1gQmyAV&(Q~~|mlN<~IRRYD;eyxq#FWj` zWpgY|44u2s2?f6E1A;h26yT!*e3G}rDtwXW`nkVEG|y%FV?qXm&$8@M_J`^SK>jli zMnSN@ZdaNRLz=c|qIDKs%gdtUPf*<%x~uaZwFJIC4j?`wU{rNU)(HS_8@jCj zecGXggAct}*D}Wfhs5F2u~XJg?b8TZn->OJbb-TtTNVev(b;x~=h1;O?BrCJE=7*S ziYIK^l2u0+-Wz$*E(G4@IeRtqo1+4{_qG7->4)+A*{J?U0#IV;#_%L96xx4Ac!9lm zy*>K}jB0_6E*u^GoL0DzwH7}Jl$q!CQ{`eMstC2M}vgr-KQ2`*I zZD^I@|EYdj6adB10FySLa2p_K1M6@2hCT}eHk6}4u<=0E6rd~`d6q_$ks}ITt=fQX zy>>*MfTIJ}6!tI60hrgz9D^CvEtr8nP@MwS{|_T3Py`7KPhv$yfM)#nRV@Gtrul1X z2V9QReDm*><7fYxVZ>$_wHd*0{<<82d*lfGKrMu?7k*Ph$sBR3rc2;OldK#KxE zFB{is!q~}Ldlr~NN37isc^XB@`P__bz{)!AJaiaiU&bw;{QJl)PvQhjqDXDT zuZ`E9szl$v0ocs$9sTm&K8G{6a8`ux=OA$P$XR$N`}Quaz*~CFG-o(kj98MV@2nQKbmJ6DRbgNqy%7 zyx`v=%CTsnd6ab#=e~$s7ts?X3)!>gQkPEb=ztQ2sl+)=UqU}D!52%1 z$N}OR7WYvk;5s=0-x8uB-<^dYXW+*fPVzHn2iVdyyyqi|U#gUV6$_>{m*6?EXO7y) zK23f%1~pB-RhR;H`hPee*C%dM`T&`qxLie_ZwV)Gd_Xu5tZR&C8AB(Gp_j%!ABBUX zyVXK^gPed?!4JPH(oMq?N`w=} zyyIeCT&II)>tNqH&=>9K@^&1$_MfO0z|x%u>lFVHr3law-bH|8-wwUne-oWh)(-9C z(SIPPz?=m3#v#+s)=!*x?>^vJ+FQdRXe+9w;C9s+SekV&9Do#FSL3efveee}Ih|Lj%70PFkg`c({mu&_>khjKV9ICpNeaX6Y2>&RMF=0Bpvufsef3zNWHDHK%_ z!`5QCZU~#;!4lsRFb>K+VZHVUMibtxPve7Ono#IX2P^DuFRSWDQ8b<(Ise9^!U=E( zU|fZND5VD0*l@Q_{omK?GQHTa1^}@@PQRG7;d(^@26-(-{Xiq@Y=lW04_5@>HR=wq z=);tp5fpf1CDzi^8-4$YeN?A_qHUVi&#Hc}Mq8lI2EeE!T2=j@R6*ds>Hzk{%ZCC% z=Vtb*`MV13!+gysnC5qfqu}4ccsCy}5Fu+Jyi7nseUTn$d5v%ZzARv%#Xt;nNMI|p z#QCr>$X)|rEr2j+3VQemN{neM>uvo{!B92^NQKYCwnCSSRH*WkU{)83J3x$f!!3<%5hgr`sv>rKIh?{Q@e2r0fWfW)71_6!1zhhsB3UR~Q zFqF-SJ2mYO#W{uZFolwzwo|C(rP;$-_;GGK47?lnlOmMAfDv8b+2=^8#L+Nqs;6i?)Zf-IsOi_cN$eM#Ydg>r9>o1}dizwqF{85CLio91kKJHg~vrh2*zXVU0_-+XYt9)FX&dVsk@{C?wyNm*^ zpr4E%S_33`d1ME^(kK za*d)zI%?`5z^Pb7rWdbL!Qqin2x*SM9D6_a>HsjB{i<38I}`;#pH21f8r8s}TFhqf z$bhA4;1wUe%yUhm=X{JYyfVrEC(o2)hXds!ojHk4z;hEk+XVVy;s+5S7{{QE|4{{o z$nW@pf+9x$jbWh2Uad#~hI91zND260qVGq#X&BlLmxUq-Zw`&{xFzSQozrkyx z#%s`c9KB|vg}v4Vy*}_6IRHF=KTcmi-|IhG9RlM*!el>vvMV~Hw?(P5R|IlqPeKKO zuMBu?Yya*>PuR3TtH1H#TUIoVj1)NV6_DY=#|7BMzWDUcD~100XhigKO9BVFT9Llz z#UV3$y$XR}CR_maFoV;Uf&Q6&RYUaih(M=L5IUf>9*?OYkiGFy`#W&}k|@5^mqRhzbRvT^>_ni_ zFnp#(%JSK~eilf4j=Ri;*ce97m;N+zG~FmOABIwn+5qblwQ!N)P8$T}AjW&(3+n&3 z;*XyM0+f4v82&EqTi|{LPJRW1yntfKTl9fz=T8V_ond`x7}Q`G%}ChfBP%v*u^#uN zTKfJ&J@ijh7@hYVXCEcwU_0+psNGuc_-vD%&=ID_OO*dVC{FDL`qNNS6u=yS9_9Y6 z*zb0Q{Vo5GacF?C8+f*cA4cfk(Ez!=BLkkG6aU9_4-{h~MywIKI-n2?(}>aW34=$) zsoxB{WB(VlZj5D9LQ#N+!m;rIK^6f(VJ9$@322pIeTjP&1t_Q;(7FNsO?3bmzh>_5 zsItUP88-d)y`wk`iu+jirH;Exi<`e}u zGNvo0zM}qrlvN5P)e5uwKnoOC>zMbVMhyUa;eD-E!Me5Q|B3*+BRypkw|w#z``q~y zdEu1I+=l z;(gW^2l|?iaBa|l7Yom_-cgMGDD)n^OL>2*06$vbF$ndTwU50&u;^{V=H!tv^==Ap ze+t7peM=0@nMnj>?)<^g+Gf@4UW8|k0J6M*)3ace^f)UEo66;*IG1jdLB?SzAz!7> zDeP`1`8l1&-w~nxBG)Kl0E+NL(em=_U+Fd#-QmoZxlai>E}7#{j+3=J5WiLU-mb;> zOB@VJoZ3prcNrR&S#KFVREE#W$V!?0D5E?p$b1D}s9-)=PEo~=YBPweFd5<^XyfwUB)RZS>ypZDmEz! z!F88-?j`QGh)!5UP8PndqCmq)c&Ab-<_w@mX4%gfWNZ3i%~;_1r)xrCgfFJiU(?Xf zMlk#2#n)(xA)lKt~>nQ<@%mB{80CG5haqFMf+<;30K+c_jzeR_D&35r901jSnO#ngWNF#4O(6$Ht z+;e=?*myA@hZUc;X@^amkS?CH>&u!H2%i%7RY;PbYCZHw1HzjdYm=*9Fpe-BB@6L z{;(%T1@rtJi;4DF+T<4tdWSz2(q8hdesc>Q`|9EQD^LEru)H zzE2b|*Z>3@m+KXh2xEo^$?hfPX(EdS;;^n`>^^ z|3lM(9Wd}Tg@$kf`mBfazyMKkOy~=gYqd5HJBi&87yuR>$d#j))B3ut5ThL-X*(tG zk5g8?ZbfT&W`>_{So&5e-(=PHctuUW=Jg#_{htvP|2~oLAf*LnR2P8f-?+DO_}hvC zSj*qMjK7`!*_Z|xuK{nk0ma+!X&Ha(1elQVw@^Pytr4bcAk5v!Qp<=+l$_cP2 zz$;Y?fRHvLP|YvmeLToSlfGvu6CAJvOz!vrc;?OQuT2qb;d?&u@R|A@<=KJ~aHwGR ztL2dZ5=tU0$$OLv;5sSm(s)7CYNXhM6iUEHSE3|aF~UCGiqE#<)OZW$CzYG}AEf|z zw)V>u(t0$UQ^$F*qMOIm3V6Q2pUzSjKx@1%OiRW_{f}uaEq-%4Ljgj}IN_qvkt?_I%lwb{oT4(Q9*{?OOy9y7~ zF~l|ATY)dD=!yzXS{b=5{Y;Jt*C<(J!)g?u^Ad(==`AV>w6;VX#f5(p4gt?S&vVY9 ztmlxSnTIu?=pqd=x>G}oJ{JRwEJEWm8U7M2nqDvPIz+&cH zXo%;SWZjcbmJ{$v)dxI1QbS%ah)x_c+=yABN5b2q==9O^)mqBFjy$B4zy}o#xIb!9 z43%=|-_#apwJp}Vimn{IDs=haQGxGb#or#;I!I9N#{cYHKhMx_HDd5VKWpr>Zm@F$ zAgK4RnjP?Eb%$}C9`4t}|9bY)pdhZ({Y_!SKm!}Z( zbjW!juOsxbG$=e^aQ6Nga}uo3@B{k&Wr{Fxka1|@_bc7-t0)3A+wL&yRv?I-YyY&T z5uV^9UQ_&GBM93MiLimSG;|&7QAjZsNDd{4Zruw?L_Km;7XSPmFtoD`72ju!RQ7zp7Zp2O7MaZ+ra4Q|P> zuCzrdIAuE85=P2kWK$M)MtEAxsAZHRN4Yq(E`r+Bpd!EztL5%>kp{2|e0Ko;sFV0- zA_dU!4;AoP3t&w}fIpDY|Dy8!*7N@(r2^6_82r0({O{3epYJrb$oQiG8c|@4-&Fx3 z&(O#^8(}J+76=_1F=|b0Xwz+SS}+z(Y-rQ3A~j$T!A*}w6u<`tSto!wJt(jQ>+x~G zpHV~rK}q~c4glY2es**PBw$uY3q(02KA;E!d+U(GtjmFg5Qb)qSu+CCjA3iR7_=Oy z4uT`p1z@-eUlMX4pKsX+7~$l3>ISd^!H0wifS{yopV+@vgsb&D4W;1Z+&T~lRW|v` zk*=U=+irQO&sBKL+Gj8*9aaZ|f%AeJ6R3v*qucrPMatW?2dIY^{=w*(&&s=>R{kGF zlC^d~){?`3*>I^mbjY)g0zzImO~$`59DpwPzY9mKYlm`@JZsM(f&%_Z3_0nwt{6)N zJfyzohk~!YJqib~e=+)|y%qq&=3`f_3*emry5fLZ-;V+;NB`p)N37!iI3fR8b@!Wu z{}1iPQUa5~NZFK4%Lh;Xr^5eVk5RbO$kPl8boM>M>rV>?m*-sMx{Lb@4G%tD=u}%C zvb$s_^DAZ4Ul=*{GW08>T+1lEGRn3Leai4xc}Z3D{9b~;OBlG)aGdzdIGknZQ-)?` zlztiGSVnfr@KPBASLXg@9M>|kQHFNqZ|eW7rHrDhz<(7KV#RXv@JtouR>gs;@~l<% zt9nZq?5c(N+v4Xk{IbmHd<8wV!Zm9s#v1!u$8oIl{B`7E72aG!zSfY%RrsLJ^ViTv z%g98P`&V#&Do<79;mD{ZaL2`*6_jWZ1GRLGumi4Bm&ErYf@0VM^T@Z)LU^GD7r|q* z9291MEZl{+#^9nE5GgIPct+rHbg@TWcJSn2W0N}lplAi_ z+#}CD^5`+26!;@*}5iIAsHcN65y0l?6u-VjAuZ78BP%THL3B8xKkLK|@4O4s@tVSo-!;++Ut8UvNF zPzpE8ant;N$Iz4>h}HM1X#E=;j-e(a|BOjiR%9}ScQ$xgR6~1VpcN3}IP{_1d&Z*G zssIz_*{B?!@wv{{!Ue(8D4R|g)ut>N4uG8;TVEOjXj+CMv~B(IO=%ha^JMJpWc?Hw z{AuOgt>?d2f7kW58D^NT5n?y|kHY^}2ar=6ptbv5qP)MQ0t^$NTj>I8`D1O3JV)c% zGWLAF@lH7cmh=Cy{_a#UBHm=6g&N2ty~$;;4Q0GOv4G!b8I-EozIGpTpHS?QGV$$wE<#e zGAOppsnP$RnGgyf#v{v~*{~3=5`I(#M0_T{OBetsp#sXYu&r7b_^BKI>4p!xS!d5- zs#xw87!b;#HyhaJKKYOL`~Ix%7_RL@R8Ry1Z&ef^5htfXjPu~6A^<-R2VjJ2`%L&* zfw|z^j-mL*&Jtcc0zD3W#y=6g;u9~637nJGZiX_SG6TYAr@8(N&cp1-qd;xWivFG* z`Thmgw7`BWpdc1b31`4h{_IE5^56Ta4Gx|wpQs9YoRm{Z?4V3Vc!Hd1}Z`oolV4A6B{78vMP6PFv@D z>#T8&!^kS@t)p;P*x%(JMgG5vPO5b9I$jQrtra?#xlYNt5zbXAfVC{~`(m5YCi^Lx zVs!z>3RUrYF?`5jg|CU312)iTmOY)t(9Cl0S*|&IfF>B;q2WyM>@-GdhJBxgE>p? zsun?Hb(rrDb6OsPCx*EG(6?e*>(G&^2SAPouN0Ey$%+D4x{LeR7~uhUZh-F(>=Sig z{ht(o++KnWwxU^hp%+`z%X9alb9#@8^l^{L7w`43&Ysr^B@k!78ya@Q*WLTX%o-cc zWvMwoEY1rh5Z=r`s(OIi6bV4)b2wYM;XsqMalu(+AZt-=u49vAtu@$CX01agbC)8A zC#sGJxlVsA3enRz7->71L;p_py%XoY^NNU=J1jZR-ua%;Nj^Bp4k-JnUg;#IEnlZd z!8yFxYlk-96|IGxtj))pTic=OHtWnY=i*)!A0oG%=w*i^ekh^@9sdXi#IL!jh=bK4 zoE0g7_9hh#;%Iuez)gw@*lP|4!1B9EPK~Lz#nd)O)PphGShzzGo+)60@5G7BrXShj ztYso=U<(U@p4N3`OiQzw=zSQu0Zuz04zQ+|XJSJqTFxFtr>x=45wNrCaNo7sGM#NIXfWnc3!F?R^*is;?awg`Yt02K%Cs3XV_AY?| zGhm@+p1&DI<`V@`kj;ZpZ0SHiM+y@7u5i3spivUxPQv8Ln>7~z!;r*zN+O)8L)8(0 zz_qf+ttf<6KG%A!q5+&NTe(&n>vhOWtCBSwfE$$~Gp}|Z8GkFL;k}M=dCTvVr;PGT z|CfL~c;58G!K0b?sKVFkSva|8p_R=Fw@_e?>*V&toC$9wf|m-M@Cv_<4wbGaN0F+5 zVRc*Q3I?Sc9_xNg5T<280lz|Z00>;)Cxic8(d~*HX#b6BlRZw#@uzYCxYyv6x&X!k zlx5^U0>ag&Y~CISZ;k{9e~(!-U{k|?PzvKH?&|`{I*R-81aVlo=ns)cs zK(3o(ujZ|K9X|E}J*;ox#OUu|dRA28m!1)Q@MWCJGW%Xm%2*ebTSuO&7>g?WQiUcJ ze3cRwy8kf;qD;!8xaF|w*hZXj9<)H}Y*U&R{o@*6eU1JZ| zpvgLWy@BJr0WH_ri#6nZ68A?jPL?OE{@ZPZ9DV>sWZZ+AMF0fkX2b2r?OmZO-<=a2R-R?!B5u$Y*9RiP6L! zF@T?Eb_-a@(gVoiGzxv@xf()*BQb^1n}R2&SnnkAJ!uZ$WikB8a0MndH4oyL7!Kug zBF>Mw5jMiz`3QqDc8)LujtP*d5uD&*_-*({8XWX$`0_8oo9+Z$9Yx(k=-0tn)dWoI zKvz?1phdTSB1ab<=wE*vSP=W#XSFi?zYn|8$KSoH(H`#OvtKJmz|sL-niFGPH#|c( zPDwX>+0CJ(dvBox!WUi7jcy$u+l_H6@cF#8uv==6{mUP(u7LJHy7ef)2@$!@V#u?| zYxaea*3SG^5dbR~hK`O7h+$2mJJL5R6>yAN)1iMS?|0%zcCzNq52!W(TiS`PWxHFKV zde;IAy4!lIza2QxU6;k?S?i&VZ?qZB7H;XVN=G))VGR+o)LhJ)Pog}NFhk3+YHx$s z&CgJA8ww)9^%4-q`sNdR$0^rx>K<}`Kt*_VDrdcoY>eXoVB{Jhq=WbHY(59TTKj&X zlRrY!@IBQ8SZZKSz5lfk?D%MsvvJ|DmwfF(r%Dk=oDx&=10 z={j{Sd{+g4ZK?|>g=3SzQSgC4Fi7HZh5oP9@1IvXAg$B??^PgZT>>b60~qq+LQ9KS zcZ8)(tQG*qO2GID_Q&u9ymgT4H?#ic8=}b4<^s4AaF|*Gtqy?qEsf-Zf!?Q+e?A;D z9}NuMQ+URyrsxDn{YkR`I3cvYGuk;@KNTY@efIU6c>U^e`G50Vo8bXI>#a2w=7NbG z2fzdYp6t9doKmY>Nh8o{l$8&S;`Ek5U^5t(4ByLOFl|I=jy2`32((F`0RYeDe-TB1 z1$e)JQu8T*2w|6Xyi_9m=paDwPxnKr0kDF=UBUw}N4BH^DC|Wa2BGh_fr!@sSrtb; zCOiNu62$QsMDPcH6RELbcy1UW9l0PPW}_dC>i;nupRo&7&HX1q|3Z`TDYb*46en?J zCM{o#Y)qlZr@yCZe>IJ`{gaB*<^$f>ar`kF^ScAZZ;|ybwFWAlwZE02VR@%o=%7Ib z#a!VURo1W!y_Zq4RUGgt#;0lqlC@M=R|O?r;k%VHqvyWD9#r7F%0DB7zigp)_Imk* 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Π5U{G2w(C%JCB~^a5{357w~dx3iNkt1&@qp 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

YRCyGGjioMF9uPVeZWcP=^HdM;F>g~XqL7LR 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

_H>R@_8bm(_RnViLr!LX=iztQ&lzR- zxb`$QVOr(nL)`v;tM&gfxB9UjF%S=b6I}o7|D>|f>XO6mO`ewR>FS;f=dbrZ)rSq% zK=kAh0DRa1fU?;<=Q#d#{M&iJj#(#9vh%;zEr7~?Uts_shvnb_*dyxxQI447@1o0MVI8UU>pJhiVY=SZwIFJC%DNw>e2?W^BCYP$tSO}!I zTb5U%weNPH^p(2jzKRG&=>-P-9qv>AD-st`BA_UpX&~T$9lZh)l}yeuPT(vD0%d0g zexKhTL_yDU31T~cC$9ht?w-L{KgKe;2R`f!1&SO)gp}n_n;~nWcF_P4-jt<{z&Hr+ zpbmx)I}@<6C3y}o#DmMs9)$ff5K(U7o@{34zh-VqX=nP@Ff+odz&5qlVtq2%hR(vrceW=l#pOCGaX(12GEA=*Ke8 z*kHdKT))vUd*D7fNJwei){8yb6(iK%KKs1e0)VkDosVT}U>8TyMLxR(*xg%`D?Uz@ z$K^>s>ij41Gi%U8*Lp8?rT{0|W6gV9tM`I*Lcuin@(d)p=yw;r=^|U*2lH>;E$Og& z+c}89`StEKhCo<>uNh3p0cUkvUR-OH`-}0#?AO|HJ|T-k;1dQ4-tUfqql^(i2iHI0 zKmhx=zMPDM(LHdS=NDA6jW7lj9q-gVYqS}=6Vv$C4DeItVBLVfbvyWXJAS0rd z<;;lyyg)<0IQgIDa*~|?-RAy3!RY_njQ;02>f;%x)_&r)KXtXd&ZmCW^}pdV*Le;A zbmHGHfv}6W=CG_7_``lw@n6+qa{R}1P1d>khwPvU7QkCv0wBn!zSTSc+|xXto0s0{ z)X)2730i0F%Chmy|73e_Q2w&!)1P;yPuT$0bc*W-+0V4Ig32=g(N1444j+@>$qu;y z`(gJc_x0(2F9!gRapw`XA!Y(#w3v~wl1Q7O?OjAKv{KF9&8*VKFNtxvjAcWpK9@H#X^`WM0}%VcM-67!y8!-7P4Ga zwk3>kQQy6m83>Wt1RLF_^Y2BJtcZ~-3DovApE!S?|Th#^O63;eAA zz1nzyCuW&th-(b7enV$F6VOO-poRzyVc>@_0y5I^9HK>8V;OG}8GPZR_#L*wCP8FQt_%7}Mcu@jcW41Q3CdRD^b&BxZ z6H;IWk9)W^kmuIK$w}ll`gm_ng`av&)&r;aFj3IQ5_CF!Q<8=Rdl<%lMy-N>H*N6o zCK|yw&VJnkNB&=y1?G45ya0lxg&lKlxj;(-FzIx&$UQHf_p2R^-*06~aXf7q7tMxWdcl%SG z`r158=Mf16(*U9FzR3&UMIO6z4g}EA-hc7p^wwh!R?xrRh{0w!weDSZJU{p8Qw|3? z4ccLxWw+ngd%s_UCZfS9Xi8!CHx3+F`yMj5f<0Tgz?cE#ZUy~Y!49na#iaq9>gpZ; zRu{)6tYP@qkk^=ucWq_^*6ztP`Z{~G&U3Aw>dXMTv(BMoV{4=9&o@SZz1xf~#S}wi zH97}$QYT>C%zFOc$l@P67+@`9RIl&^1aL8<;0^x$+Z-HR=+CP?Q5^yT1tNDb36WrA z<6SOOU^myVad*Qm&T3$@*09;D=>6((M*JhEE8ldt#l8mp?ch59ZGNp7?8kR^xpoH~ z>3l7*9-TLPV3g|qY7yoBTiBKs_MwISZapFirlO+++tlP4ng?Yt+29b-AP{K?lY%@i zvp>uGCvQca{i<`XwFNW%@f@}1y4CMS_w-})miXHe^0>s`m(Yzx{LSKKUfAfx<(!^b z<-4l{QdJyrl^~(YzE-gZRf3%=@2!5zOn_Wx0UNV`+%6nuD&P~6sdE+?oMkU&1mrE| zz@G>JkfE50i*J}_-!%6ofPY+b3VDoyKgjhIdNYYF45mM1SkrNXPeg=2CuM0m?1&Di z$k*iK(=WyUADO^)4bz)A#UMc0D86I-@_$SHquXQ1=NN%S(DUP;#!gJ|eT+tDk75Kc zcBz7HRj{uW^rv#F0sstH<)TcJj(#Xfc2wgZkl|<1N(bYRKIIcR!c<((TD8#OgE*xj zwdS!wBOftsu)b8$i9k~bXYc_aFrwX6I#uaa(GivrJdN`m;k_eUXT5z;egE5M{kn+r zE)e+^F^GY4I`|G(B^b|3yC1E1A%eKhK#{AmB zz;k`lzrfd1Fu)#_*p~orV%$n7Xz3Wg591fW!E+rHC^OK_5J8U%ybe7%M!L!R64J+XYelA=YLXBR0%uHMub+2dYZ|IUD)9IRd8tEdU@u zDF4DtmhW;9u#s)4lEbKtEw}?f0pYgJ1R&qz?AiF25^X#2D3fuhyXE^^az6J%*+DYN z{ZFzlnl>3I-l~HDq!o^ZpzQ ztKM+6h;`Y|?$OyE7)*gDI9;!D!0R0p?2-XOm$mDD){b4LPh>PGhqt-DSY{$1HnfRs)M70Knj{vaV~}m_TUvOo_+z z!sF~Xk=2+_z&@;XTpr+_*LkLO_F$dAud@d0$kGNfw!!Z<(60?SXk=!y+WWZX<{g|B zP(A-AS(RzsDGXcliI8_!`K|#!vix*qse@XAxEw10hjx`lDVk4U9aZ@dTFY(EL*~tI@HvWX~TIT0EL1$g^$aB?L%ELyq0SbhS>`ZV-8^6J6|1Y}r z@3q-y(Rk-MO_%_Qk}Mmm?uP9a8ZJ= z%9m#kx4?FB!h4Co^96aLEnu_@L`OwAErNvTd1q0J2uhKts`%w}X8ml082W;2hD8b< z`UkUje3bhe{k}Qlzn`g(@rNa-YjQY)0M%4fGtpf6(e*4#$oU7Y?f0_-VW8qVxWI7F zPQY9M@jh!%9Sa)>evGX8?Zs>uZGk6e>Rk62C4hn*v}*agkBA+j^aYYoi zi0~G#_Oq%j^0x^JED~rGzh}n8*ZTCYzyjx5I??~?d-ihnK!L#f{5J&z7&VntA{bb7 zd7$nL!KkwZ!V)Oc!x}^hLO6swjStYXDD%M{2DgC90jyC!dlj<<4lzh@%H!@L zatV1_`h!!czjIdLz~oe~EA>iXR>$eq@AeFKG&h)2gBImxw~6Cz`((G_slePm*>%NnjUM_L(Y2ab&vP2Jl8=0GP#0t(tLZ( zxer?6xeNrNKF)ouJ#&AQtznPWPIBkK_uW!=XU-Z}N5|JUdGOG$(+LMQ;6ir~ z5FBhEGaGzn^TDq5E7dQK0k!Q-C9qHJeF5@2#zBBUg#?tFU+uDh-p_ui#V;}n=-LMB z8>5jwl+1>jbFfa3wa#_dvBhiL(;Dl!#{H~{OM!b@-PdK2FJ{+7@Bg{>uXVi1Yp(3d zi*ju{$VrEwtb-lsoMGorklg-F?sfaWG7A)=elJWG$tFKHk22BE-8qW7!S^)KnFj0F z*gxk}1nU1qnSrV!r}dBg+mt`G`^mwxZcD#%JD-98>{LwmQ~Do!vcz*QZJ&f#i#Ya0 zo_A4w{jFsATR`s?2n-jNvU4T^0c8dFt}20bmHns+Tzf$V*7NA%{4-3?jqc7~lo`61 z_J=;s@J!R_*)%#hP4F;%Zg!JRKO@QIq~}w}Q%w3hz&ta2e)2a?{|h`k?d-TP0BZN! z*#`>z;{=CaG1NxwpM&NEfp?4o#)eODKjR#T#=qbarLvT-PwY~p|B>zJ`9HyR|L0_> zv% zUZQs$J~f&8MiG$8bKG)pZ=S3oRiVh{vW#ZNzmY9iWgc=A$361ttlP_h2fz~oq6h^9xqtu{4dUOo5`B9cGL~X3P@dyTM6vHrjl~02!nf_J8 z6!fk#);RR>zh=Z#zB&iah=)F=0RGJ_f83i$e4>Azdx*hBYSDXtp0N8rYUfX67X1C! zB}gs+bVnsfFh=kyHGgk9VPPDKU$wK>3nx=Vu!>Le&-z^@%N)g32LyT{*P{!b08E{3J z00R{)g9`lAI*4!uR{(Mmt%W!kQ3^*}pt3_JIsg)Z&}9yw)E>yXiFP_h3S(Rbx$nU% zTn=FEG>Te5Kwvo}gK80dl3P!?-VjbwgikR<=#1zWAP0{B~u55_>u9PGLx>o$XPpFtL9Ft#(d zC-5lP0w3Wig3As9E_PcW24Dflzi^)onSuc1b@8oEgR)LbPstO~(qnl&*QjY_2gWlP zs1an>Fpl+SnLUvEth2^-4AL_4y)3{W!AxT}4{Skhn@=)V05a6V8MIExOhAh@Zln9{ zYs?MsC6mLTuN^sk3|;rd29%xU6Z;KY{xwbRcsrhF`DbLhOCZ*Hz(Z!fYO2{QU4Lec zI=|0sgMRMfFuL4Rm-lqpuVAcuk%5FanRDPR#s<729pUO@^HjWgig^Ptt}&ND9Rz=K zAi%S)v4(3H;5Fnf<_lm<*M4bwVPtdt!wv)psMj(08_4$t*WKWn8_3TF_rG~Bmjw>a z)cs}xh|R3oRebiUOOn1ffPecKN1(qy!$0rkf018JFx+5GHf}V1F+s=%&S#zbjtPp# zd61F-jc-q!Lv%qPZ!7HUictS&`t*-2=^f!c_?Xv__ji7iz&Qwvr9O@V8DE0w!ki8Ll*HDi%R!%Pt}i`;uk$w;P(sc&BCB3 zZ0>4mZM}9k!zSN1&v(yb-{uI|=G3Kw9iPR9<H6_@)_b!8AT^8b2~k5HgLPO|#b1 z_|0jqrNKYZ2B>ym{KOP{J@pu80e(tOW%y?;9sz89&J_?vHc&U+sS!M1t{;y&Bsk0neJ>Q(?U-@ADyuK(ex5 zWJR}%{^&7f09f4e^V|(^h-s|UlI;jF*Smc3K2Ulu)P)Kgo@nwMTPvBil z8X9)*HPPYNC$e5KptvVa8yvVfB+ zaBl^SR8h`NC5qqVi985_9-Ak~;XRVYFQ&+ym4L7c3a6=m<9B7+C5Va?oa~$_kr-9H zM>>-r|JfyL*WtJx>9n_;D*_dOJQS=X=l)XH!@1XfA~v;8MvI>^69U&gh~!~IM@M#f`}s>MCdvyC7j`a;V=gnzsL+wbQA1p5TV)@F;wb?P$xtX zNc}p&jsX_r+R*~Jn@b|EGB!Y^B?WrlOT5S6Va5oY>lVS^IS61cgCt7-Z#oEgqj>`` z=0hlw#y=|yFpO*ss}lgDHKHznC+6TN5jl;rS7kn1J|hD_b%h9j60-tOG>r?c{LKKF zlN`9JZKjx+fN=tq;Mf*^h0~!1Ud5mwoXP}i7`)s#(BKQ$I zYEJ`$P{?T+l7>$azsgBsGn_(ZP~>SG+6-$rgF~2omVtryd3X>;VeT&;9sHrBDqZ0D z76`zq5BHn^ooX=7i`>&9fzBd(y2!IF;*1wDD2uA2A`?pjR(&>4R#9g~-f9GyHNL<8 z7SCTN$XI@&Sp>gn;vkGjgHvLI`)=}mP4=hB&n=$4#XYx_7CtCJf$bj}82DMIkFQPV z(&gTQHdqdxYX_l>Qux@1j(}(Aad$U6BJ{7*wd2RAc5rqb*1hvVr=!twM^ml##NtwDt!b|(RPDV~89PM|BuzzPmmzA|8Uy=W`p*Aogl!NF@O$Ug>G#g z*pkx;cS#&Uobqo?&VhJ8y1aQie!jsOhRYK8x50C+bJ$r&M%E8cf}@y$aIgaaJp;~d zg=bp98LY70!SO$s9TY+C^A-nGLtblSsq-e+`V|0hPi^+GjlFE6f2~`R6C!H<|DC~L z^Q*4+vyKg(v%z&5T%*B$Eu-7ZtHznUGI1x-o+>QLzDE9c-TFuHBv#7+{;@_e+3zz> z{p0+W_>LuXZ|MbY`NQEaA{UFuYn7m=s^IuKJAY*Yc$Nh|yHL*d*@Xvl(&hp-b^%+q z@H8`TqKk9bw^{Ce7JD#@e$D(bJI7|^=)Z58Z}ecAXPahSrqQ!$_F$Uto??Bc&T;t< zd7i{COx~V0U~=7=XXJhIwTX?365>;{_Ae5>=r+R6O>oT#4zn8n8-svOFaYqE&H``` zF#+&Dv(-HU0CY6S&4g>h-e?9&MgEvQu5h0fd}alISH3UpVENYs0FeT{KKrA~ET~5C z4ik|LZ8%EoBQUWNCK z$(SOX<1E~m+ORN^Wj1vbV>ql9FqB~M3yB^V4Xt|K3oJk%5o{le-^b$h@gRNQ$ya!Rtrl@U6PKoswLlqH&(ei6V+9LeQxW~N{SBQm_m z=MkpCR(2MM_(qht0e*X4rp1+lFD|B&?Eeot!8?4?$5})h-H7o4a{LQEDXaF6@D>SL ziYjxU)PTH7oQi!OHlPT?UY%ao^*7*Ek9~ezRKyk@<X9qrEQWZ{= zH3FO3 z)s93j_Mmf)#klzo%)f1&J)~zC}0}v zB9wafX)Yst+%;|PxkoS+QwovuV78k|4uK#SVqI2Vqs;`y*qE7;qW|1jTz+WtCu`tSV80oCy)cf!GT(9_OtiScL?478Dl z7W>-zyqO`@A#%Ivqgl%)`_lNWPygtAgF{l|d8VNz_*i~xPO7XEK-4dC=1G12_>bCv z!GG#z;TdA09|y!G^lC{#0c*E}Z4$FzWVNzLsCMW6avpUN)IhHew3Q33#jdyFp^Ls}UF zHbMkGBIAmJ57qKSJ-A(-Xp3w};ma8W6a^5Q%Tup<c{6nGy=GS zBOKo^YpM~g=tfYSQGp0W;)CMG*xj?!fvEOe#6b1&**-RY6H4EQvKCmtB8nVLc>=2a z(jc{uX9`-5WaxuQH$2L{mvzF&0gOF5!4eZ+O%TQe4t7jg3It^Ip`0)`!h46`V8WpT zUBg$+9|PWx!t`Sx1FW~2PFU=G3Os^KU(WuU2F9VR{Wy)F*gehvel*kQLh(l_1BEM0 zIRId@ihO?&BUMCEiac-e5(fZ0W08$7{?J(ioODrL5?Y74gM%xb9Z-1&15sq%1)hxH z;d%!K>YTX3zh8F%aGP-kw>zLvYa&5c>1i%2pui;qFJt=Px3l~at%5klAPxF}%OAoy z{5>6hWI_ZUyxKt#hCW&)_j88ey~dZw$+I^a|2#0xEN{1~HK1r_Km`#pqr3YyxEy)n~K=u|8Am?-b5q zO5`Cs`6PkSo5oR1_a&$J%$`{a5cnuM1Nhr44sVXn%@Lf;pX_dM%4-}B@$0RwR| z3mCHMjtP9K9%HWaFS*~DfNyb6X9f7&qObrw)6$Yts{~LrJ{#aM8iQx}E)! z9X{`k*#hVCVr@GZY4w_S(9bse)W(st7wwSlbP#ZmPpMsJ4fw8@P^fak$q7J=l7rCg z$^tyWAVl_|*EDy)E6jy|Spwx^Vj*&~iq5X?=ga_W7bA1;%)0s-LEakAw^lcsAWn0g z_pWm=TE~&Evo7oC%{n@;{!iEHl`%k1*15*Ub}kVpozJ~(Y&PrQnE%C@ZM?;Sz#Cjr zc!vRp`((Lc{UI~{ss8^VqyO2%HTEt>{oa^CjAkVS^8ZA4V4#~Z;qR%&UmWe4f6+J& zWm=9l*bn>CW-r?4XdC%zp`R^uvV~1;@+?gP$L7m@^2b3n281u!j89j`PqT9N5y3vsJ45zc5k%OW5(B-W;}c?$O!$H;W^kAy}V5 zR%c%1)<0zc@LSUyR;SU&Y3@gp|APJR27`W2as3~=uc1Ga?EhrVr~mT|6h6!)fY)sa zZjp&qpZ@U^6Kb93yCX2>dqRK|Cz*S%7&J|p#VVSJzq};S;iQ}s9zl0u#nfcXF4`cm`CsFH`*pwJpgrEjO9>d>1<5Pai zKlAxO$)E24Ky85AX2zf>T*F3U911*V;kwKOg!9MX6cJR-LeTr-dp>W6eP3of!qGpI z*C~Dvfmo4i75nV)M>D%nL|}``5cK=^M7Kq?P@d>(==V65BEeW-3s|3`_EcR41U=E2 zAdn#eLv$=$?A!vnf zWVAx7`cGFOxY2ns4MvSP5lV?0lAXLFq~{U4bgXT4*()*+6zU+IV&r!f8&2LkHD zJ-}#Owd)|`6Re$hFajfhJWf8>2H+dU1fZ}}#~B>>dm9mq=QQ^{t@{6Vi3f;|00jUT z^I3Fej^Jr-*Gy5yfRekiU1`4PasW!d@J@pRd!`CzO{)aRRUAO|W7+#0ql7Qdx~UB5 z65qYVS_Y^3g9*N>VQ_0Vx?QlDCpOWvEbJl*Ah`;7_U{#wXN zdk2#R9pg>`zN1ZW6(fb^)UhR<3;eH6`k(jDNYB=)4oXL>li-qr^HDTw->%PMy|8z4N#ex3mNc%%J)?Mx5r z+(F2?8kc#%5BJhw@0Nd*IFe;-)H3qCytixrtsM1R$A;9ob`9OA-IjAK zYS`@B3$lA9f&g@237K6&rWe1Rqp%l?4rcK;iv(#^Y)lm=T1CGWSmT9r)7j7e!YBN1 zy3Wsc%o8NebIp0=Xr48n_P-->VVd(*pC3o7+S6f9`R5 z2iN{PW&q?mQwO^ZP$&GaISa_zPvV<`L*!Uz1K#dzzzzl#&)9Y-`}n)eERHv_TP^Gj z*U-$Gz$U3%Xv4;MWt;Eg+b{X9bLB9~<4bkq$+zVsZdV=L$GD^j(ZH4>Ndwo}@+M zA~b%5hYWhcZzb}&BF+FAWt43gAstffU8g?*$CPTv!4^@30!F3}rcXEo6j4lg zfkx*VFu;eRCY%#iM# zg%z<+fck`*$1ud;9i6nrO~7Ibs8^E1yTloQiXGoT1~B3L6cn&tBG{1=)k!^^KKEWg zND3%gfzK3Jm%?pX)+nG*qCzebXcaMp>UJo8H*5Kk?mxvDgQHz0U@eL$QBk-FbrGn< zfI=1b^9#csWd)TO*yAEjBuWkMav;Du6=yQIQ=k#p24w=?YCHhOGFS)Mf1NM_mp$ z$Jqb^xfmdX6COf#hA;#}TsKBl^L!)R^T@k112uAGmZC;cpwTyZU=W6M^ix}s^-_Y5 zqb-lQ6u{b4B>zu$-z~e)3_C_Akyh!Kv+SB#`MT4EPi>pt<3}8E}(Zjvnyn(RZ1Ri~w{NnVaJt z=8(a;_vfi)9-};eusZ})-+Z2Ho;@2v3~-g8qKfmVo|zoz!HceP0Qb3sE-ayEORUM# zPs|~JBdl?~TF>(YWUOz^nF4j4=5Wl*O*01~7tI|__JS@o(WTart`8$GEgXKE=Wp-r z5wVxJmV8g9mOGE}3I2_K{kNU|?gpL7>EGZ}KljnT)T!uqxXgh3wOOAwx)NiGZ_P|W zhiB*z9Cwh%&ZRCtsC(c^#tNvz0J{+U0mx6UWdb1rlNIi91*f>eUafFCTltPz1#!}= zM|#?zG6CG%8u!0;vTN@8KQ?X+r?`e)TKiL`<0Bhzk^=!gzs@?W3t;$w`32Nkh>Wh| zm|`H&u5Rl?7GiME&BhfhyVj5MTAwrUPyxhe9ZcXz*N~^Ra}ui%fy%*2iyY5{zO3w* zIEcVS@U!TegI@ui?tCZl8fvwSGR$p>wP-iY?LTJ{DAu%vqiNy?nyh>CWA5`;>K_}> zI3#5wD1Q0uGP1RdZZG2ymyx$RI#kET*OAjY@><{8B>9o3*kM?`$pA*^%A2J)sv0$DkC_f*X68t z0l8u#91AyyFb#Yz9gNb}1r)LmBeV%4x(R_S9OLx6oY7yMfjBRNhhbgs6CM=vGp?_G zZ$(JrAs|AWAo7`bMy7eo4!c$`3qJ!YvE&pN}M}>I`^MW`{)36nqWh3iuyqJx+4@1cxdhWN-!S z;F7>|jSEm0hgwPrY6cP97$=MZ4!+SZ-ZO~78`?8*A_ArgqcKGA5Yq!sFs1aY*#Y_f zkqaFJpdh19OM<6S_F{A*X9YwifM+QqCl!oTg?#npa%&Nq_#1nZ5&LS?{ELqCwQ*Wd7?7}+h*CI zy=KRcVQix>?f3W^Pjeuk)b!i^^Vtpt){GNS`ygxH5zgR9ml#xX__Of>;ulzRCIFf3 zo#k@Co*qKZ*eP_Gj(ASqfO2=Y@S(W1ZJl{r~SKnUEL; z*9eAV_Q18~7|`psOx;Ju0DWG^t_B4$wsakNU&qd@zr{d9wH~t1>)5{a*ZRd;uRZ9% z;|eqX{U&h?!GhRyK!aRq8eP>F@`;?LWO8IwP<9~`z`#9`*{IfT+?8EFAJnauZHPbU==TW?#oGhNx>g2&@PU8=z(XHtNk_c$( z?u zCw~0sIL|T8J&r%psef#m$oIzBn`i@kN*-#0`ux4lbn?40?<)(J*Gp_(`CtVA>e;_E zYYb|Ks-Re->g&fi3}N_#!(CuM8F8h(5y}D|?qdTAoZ8f<-;W{&OB@Ro{oyxePx#=S zX`IE*7U>6}?XS<_L8A!A2;Vt8lP9`CHf&HecU^}lRNVJPjA;QwwTUQl6F+Z4xcj(= zg3{MQ)W0KZ?SpL25K29QppNQfhj5nr6X-RjvICnu@!33yjbj8VY+hN;;^&?-Poz1l zE`$dYL!e%EwY5d>KE^g^clYrLT@JjJsdo_(1sLuiXCyx3fIyD#^%Ql~an&0;o=pG6WvrB~I7lh(r%8kX~dTFf>IJxQKuhU*`AiZf8%_ zu2w>|N)~r^%cOvSFLh9`*T3FVe2fEw!yQN*<)4*F5RmW>?h<&1%K`7rJqe0oaRaR8 z+NiV1@X=YE%q4gy%)=2JaJ`0`{8Z2sKAz{AZRSmVWY+8Dhy z>(G{S!H~uX*{jVex9*?0kM_lGEquS<$FsEl;>-dDxqXPc4%pB3OaCnhIN#-g>;LWF ze;U~KzdQwUeh0dBkpGJXuZJz^aZkO5vjG_QmG`-BPLQ#}`&KaMtJtMg)_N8FSS2`E z{h@<^!;QRGM&N9-3JQpaZCLxH$%Wo;q9FqPHP&zK_3T(K=48 zu58kp|3&BP=eqq*xDx`88v0Yi{?u@0HST}uj}AtK0YJu=9^v6W?{^uC(|h%wp6WN6 zjDA(s`EPaa|6vXQ`2ReC>--T}Hj9ay*s;0eT~2#mj^qyHzq)SNrx~^B{w%w3Vt&U9 zGYFX3)>xgh%;~{3r_rM+0-7oO!W4n<)EUn1?dmRojm-MRiJ!F(wopDl$@fq4{FCfg zQ2(lvi2Inh)2RPf836c2ca|$;xWE=Og;~vQ2APR_C>q1Y}>g> z)32;|nY}IJi^_W`0NBIP#m_R;DS{M%rA86B;SZXLO{aPy@c}lb!~zyE?tOf5-={N; z9kpYnj@h7+>fT4BQCBT~WLwj-ek?l#$~)xgJbJkGo*!lp_`n%H9jeys7P&r7<(r6> zH=#(I5T-s1cYy~isCLa}i?n87+pHUFuKe(y{ap`a|KpgD{s?_gC?a$d>X%$L3n7MN zghkZIU!5X{Fj^X2t3W4!e>%lKeM_?BDG1=Rgok^2(*za;#C9RC;X+_!fi zu&>|8--`%O@zI$vDct33!%y;_Bct&A+_&PR^8NAmKRDyS{ujBg;&WUoU=502cP4;f zD#(TQc3A-B2ofX|wKQpf;O)GA=(YMsVkM$m04J!?(g7I!f=eO_no#V4?abeRaUH@aCvrL#0X*TC#DK22xXrJ|B(RCA?|PJPsRY?pocL;F<$!r84qw|cC(DAyu+G~ zu%@GjWXFl-Rm7YKm4HsjOq3>B1{e@y5;L=pcR4`+VtB>~I7BBscBX@alT)_F-tK?_ zy%FP93>IQdVze;N5JVk(X8fy;=8ras(1ULM*(%9C;$I^3-~$&hNa;k3uto~cuwOH8 zHFfZuX9pbb>12F%_JKUXMEz2j0OV?(y_y%X33{@?{w^TT3m5rR#J*QwV+vH{a#5$M zE1XtUiy&*hMBo#A>kDoZ06hP=jAnH0x-l4^t5rm#|fWh z(x4R_2XftF&080^Z(LwOoN0S!mj>9+HtXI-x7z4No9}FI>$)4ugr@@U5 z29T!~!AN^62NitB|4k}H2irK`XkAla@r?u%MrmLpyAitRMfXr+1Gr`kE@F>+$YP8w zR$w3i9kR9ZdOOqWc-`XJ0?5JY+0F=HVAt5AHP(0y`Cr@Ffq|So*Ih&IR|%q4xsO#& z<*N-3C3>QH26+B80;-r$C?MZ;E+b$&)*8+zD9gZouVLiZ*uymfueC3mqu{v)C|+gY zAM3XAZMQt?x%7NzJN3^V1%>h_6EGPqfC5n>+a2zsgQMwiPi^fHa?*O2YyQ}kCbHFR znC6##YM`5qbp!v9mt|yU`L!PJi@eua!+JflM|A>@I%`(v{_5;`o%N~_c+^JCP>EBl zJKz+7N27O-9O-0wX1GS9uw zV;AQB?g3lKus#tZ=VNwY#CAh^+|e`GKSflhNrfVu(xVj>{nh~$_5 zYUDpYG5Y_H$udB2|MOg9oBpkAiJuDHStfukoqC< z0K7WW2SIsSNrP9xV3eQf6FLi^>1>1NCn1go+UR87$L}^F0DUL;B&!-X4p0nonu4dH zFT)rjO$!{sz>jh|8y(7;f3W|durUU9$8@}E8w)4$*-U$@R=x?L-z3LLl-|etg8>ks zEwNc@bt~z_sMDfOg($Bk_>JD1=xzZUqwfDoBeMDXcsu(d%NUXo6nj{&7dz82lGz8P zrUST!@bn}6F+k_wOo>ZLxYK8^zNUs)*qY%1TsOhdqCc2f$uCJw0$UT zf#)sYdp>(C~E$4vJ5ARsf+Y+~N1!=wRTU3?7OY+oG}!>|b;p@cSSZQc!b(vjL}O zRwGyjKWKb_$|SdBFjV?k28tyDvi?UqDP$>KVx=9%Liv!wiZ& zgKo|I!{j8JT>{w4(*rm8WFxR3>po9_JCB2%|Bgw6a4-w()k4ASfp6x;&(-gGMmjpM zIF_txK_&c7GYPUTOYH5^Z8?!m{n-H!yw#Ziu2IKmEuWcffaKIAz9$VKCxq=9Yn z-A!c(zME9B5ez6R@Jyr0FEnQ07uh|aEJ2GsZH;=W9M^1dfM{XtTA$#B)6!Vt7Hbq^ zXS>Nk&=MyB^4#7jomQKDYGVW1uXC9|^=!2!>a@$>|F6fr>p)=0EP{{rfFcC~$ZfA? z=gHcx@VS-uxP6c{Ucqjy@a!wd^y+_`J3v3PW~=DI>dj8a|J-ea=Vx7h6ln>$N5@&f`frqJ1em4(|yS;hiX0Ka22x)1VF?ltr0+pv`9>bL1u&vUQq@Exmy{| z)PE2Ch!M=JMUVH!j0QRX_a!$&)cfmRlQ+5r5Z!I_JZ)@NOa1-qbrZYLY-Lc_yeI>` z26E7NPqv80WJ$@x)=u^F{yH*VM@H)-W}Q6QB_-CfhVIl_ZUI!u>7c}+L=ejT#N@x1 zn(v=$EFxQr5BETyWw*Vex7BAl06+&8u%`?Axy29LF^|Ka=RNb-%sIYq?h1F*eApZt zLjGe@XK}u>1dOw+>+H5>>Qom1|DV~)KtQfPjVw=}n(e$(oZ2;Mc8X`4LieYz0aNU5}9!HW3~RA&}4oy~}Lwkr+p6QUi1q{(+m zg$E(g8E!??34F?#5B1D{#STxcek^)PU_F8Yq52CriawO9kIn7-i^+}l&fgbaot+hh z^RgpA7=yUB95HKH7SzG< zkOPG82JXp{fQX%l8mI@>xU5KyNFfx+kz*^#2ofHJaH#sHLm>i*bwXV2^y*N^$x z80O%}U~hvTK!L%-5?wncTnTa$!!2PW{W5H~<)Qiy#5p z{EXWKg?dJh79O9|&KA(~>VJ6>8rQGhYxY2;R(0y%*6e|-SIk*I-YHo0VCe==8f3p~ z$Z;Lnt$)v_y#bd3UgBwj=eQ+|0JyoUdEvk8lOuc3wNd5*Ud<{$zU~g4Ll;-)*_RDF>SNf?aSSbpb`UX zC0_ezH)Jik+;?}?sd02llLmXNaqnnP%Tsv(eT*rF>JY$Lt(@Z)Le_SL^3x4` z`eJ1wZt?eszu~@2^5ysBT#5Q!KJhP`?T>5MkK=_-)%jeVy{_+X z;NKTL`R{}Tpo*7biQg|xn5%;8Epm^G$k^f=klFhU{QHK7{OprtSPNfq`v2WYk~NR5 zoJVKok<kc&h)3Os_6H)0VBC@_trkF(` z8?1b<%C@`#ZhC--V+bW0<}<_pllAtYO4j`~LN}cMIeGFe?CG{YKDUV|YLig&N>dZ< zYNFl11ql>XO?Xh~|Gg8vKcds!d}0iuwGrd2xdS?V1+yE^Q~6{D2U8|m zO=L8bK~3MU9RNJVIDkW(RZwTZnos9joaVtp7;yOA|Uv|BXEne3%_+x z@JpZQ*X+!>=fEAD<(B}5M6=O?_yxb%TVWcaD?v^lLmTXb0w7+PK~6j$0u_@8cW}_7 z@(Aw>HpT<|f0YVY=aR}JII9>?bVX(d1g4CU#KKE_z@SOtO1S3%oY4RQ5*_IQ}z4YR%@1dJm)8Wi{%a|95qj&i@F z1bU+=Vi|*7=44dnbXmr@RWMANhf!&p7>M8@2sJQ*749Qg12OIuWI1MP-(ipqGF8Di zR|teF4dV#-ZjIgyhCwN%x(C#+i~NjtvaT1bfjq|q`#Nz%G6+r(Y)!t{sX=6A3gbVe zbR$8*v`PY8XNEvwmVKDL)B%9n0@1ZOjNlw=IyaHvrg`Le9{Hc2bP#}Zod2GCp}D6j zx)>u;k>@Hhy!Z&WQ(a_Eb+rrr%=mz<&AP_tmXL=Uds0JYYXsDFbhOUz0E|F$zm_q+ z%cmOg%^ozKlOV7L_taR;SCjo{vaZd&O(l#YYrfTKWUkTtUg8B}e*A{h%sgka?7=dX z%phpeT#KNp#WS{cGxq>`-Qqf}4;X83o_p0nz;31ULwkNo$SnRw{^Za3`Nv2*>^wzCR<^Y5{Rt8a5x!U=Z#PfJF_6&&Tt zdwoCXXYUv0JwOk;tYMeu@AA3sv1VXYYbL>C=PiC6ZqVf6xjyY-zs^bgMgTewG~iQv zeSz!#s`ZPJUTOve$KP5^N&ufjAm;@;C!Sp0M{4; zz&g)zpR+vMjP&g*rsx(hkiDG#t_J{p-gLn4&33@4dtCzH8K(ZrC4il_{A&W>O?Lbv zTXHCn@Bjo#F$(}0p1@zl8~_~#1{?sKWHKOiu@QWXFS;AxqXq&#)|tjLU8>};B=)~J z`TxnSfPXa~0Jbw`{yf|P0Bc;{l>k8e{be3%OsNHKYFs_gGGwaR^S~oIQ4wJb$@pHK zwc3)>&p5jRr=U$lQdhFkoA_)Wk*M0!f-#PV)lB&k&Zz&yZ21~QkcL>WK{j{rw5;)p zIZk!sqSDps`A1PU5vgp#$ZSGLHgWTPSLZ2LV`~TQHXGbso(hLU96{+v&&ir@4$4KMuIe^&_wfiEaC!+I9p73n@H5W^*d+%$jiB%&1PCKsbL2-R31W@Q$WWQ@FB3SFxn>3DR3Y%IAUBl{SYcSt ziueMSw&WB+j9d)TxWXBOBb`=5ek&NDin342sHyk1l|e(a7YZ<_Iv)Euj=YVpxijEt z<_%CFpjx4NhTrX$A?|UC0Ah;upQ>b=m}`)gO_@Rs_g-4(#|EWg=oZ|G`+!$aeB=^Pq3@VEKIGfdq{SIo{;^n(R>% zxooobP1d!Eel`Eofr5gBqy6uN?mK6_nmo7W&9~U=7JAeo5NaKf2=&$*-GM+r)B1vO z2VDaPS^G9lQ6p^IpL84HZ=CW*emlry=Z7W|dY-WX$W}}$)bG*X9(&Nkq4bcu-Upo> zIL_Sq?0XNHSm7R4K4RuQ_J4(aTxoe00YOX5BRJc=`JXXOZ#S_8D@x_FHlpuc<=Iys zpQrj&WPKG~UVTqy52D8Z4}V4gMeNK9wr=GGz7OuV_Y;>fc1l*n?q$6G)6e##Bu(nD zmmRLzd4=02_3s(R10bIrbS;K3O&b(gO58n{@9#@;diSJAZuEEDm;-eVOHVGuIh> zdx>XuuqM;LOR}z@0LHdWD>H!2n&!IG1b0)&($uTd`A_lvF%+z49uNTmS?5VUKZ%Y^ zBA=72lg9t5J$-`rOnk~&>(3bo_zDLBk50QW-f~+YayNcl9xfvNzr7DCdi~iae*8kv z@-G_W^fdSXvwr25gg@MB>k*89WC4h1#(wDtW6w+*lm(a)kdKEO<|cy{_>!!7>jbRy zbssmoiRkD`BAiVazrt&MVpQ55!>JZC4Vn?aPjdqXQ5-Ss3F#lqajG3Jr6cV_P&Xlj zSK_cYz0I8lEI^@~HE99MG?G_Py(>9RrLZ{0wwu64YPwCGv81K1$ zy(QD^I_3BA**!3gZO%7PMx*bc{I?)L-lH>9P&m;}U0_FyTjBT4BIt$S6fjl= z1VqD-qP{=jpKs2Sd*NGl;wqzX+EoWdymWmwzksk6UgSXF4Gs+6_H4;QWt`<8z^10Byx|z8mN;$K~u~fP}`(B47lgg!<`{G)q#}o1SnK=5ePGJ zcy@6FIPkUvbZUM=WMC8oV9W*-baE|?o{lMk{BH0z^8&OT0KCw_pl~NYa&ULO0iMY8 z$WvSjKt4uQ0^;8?_glWgEivEAl2-%*IOz)ORe792GZ?=L@=LhW=LjO^FamS;d6e*&GXZ}zKf160LQVlRH|42sdB+^`vW$UUX783c z9XD9h1~Sk%H`xOl<8BvgnJ@kx&x!w~|If2EZt=VUl@z$&Cil}sW}DcBCi2tV>^d~x z(fni9rd!BPi{P*MQ2yIO&s&^yVot#UZb!V<{p6=g;Tr*yuWIQ9s&T5|2p$X>^m^=AT!M{{Nr}s3ceTl^W}_#PyeWuB8Lq z|9`770QiqZ_Gc0MTV=hg>{skoLAcn%>7Tg%f3|6Wb^5O%DdZP49qQku4j?2WI_An$XKvo@zW{v&k5{{b~zL^M(1wj zl==Mz%%LC!Zn}?6-GsBgQrA;We0u{62_}TL?`N?G{%Wp&-4{YVdTs*$%6vx|r7pAJ z<$baoFiPY&a=IPEGkikC&=2!`!@o@i!r_C=chE_8x_-6o@w2Aq6(7j^49eV-?SzHI z|9d+B_*dnLN92iLw7%hx+5A54vF`#qe*~rvLGQ!3_5CKh0s8JrJU~I8eT@G-%qjY^ zoqNYY2kTNeJ_D`@5-L9Jf5YD=@ZOUhFz6)zgj_oX83Iohwss((-wS(y;1$%?_SNY!1%?`p{FNMFlG!0_n=M@j8t@m?BpQf z(;4WM*xO(j>=-klE&*Xc*vtO=O%$}hF#+$)fGo&@6a@TdGCd9wJZgBf`*ZUL1GtPI2&wB!=HG!;6U<`vc zSlj?SOHhV>-C!cFuTi7Ztl>2BGxKp?=-w>vo8>!Zf0r$Rvo|DJ&>X?VoLZhZrObWK z903nH4XV@7H4XsA6ER&y=c~wS^+E>&$U_yKsh(l_;Ex)8&E76?uS@M@X{&w4Y=Hy` z^^>v`5NThv2O|H=81QA@yL>ke0vT!G=o;*6gJ*9XWvsy4lSnAg<41YekWQ4`bAx?s zaJ|Nqy9zLdO=Ph74!^ioP!KB(eU&ofeMkI zASn`1kTnR(+wW)XyMrSRO5&T{B8NV8pW~GIPcm&DZG@LP7(gz2kM+EP<6S1ePWHZJ z%H7-Dg2z7fzU{R9-3iWHK~H-3J7B;et!(GOVNW}E_HqTsvT~H$6502aJ@WlMWU@En z?;=?3@t)qxGTpCXNL}6kiOGc6;b77sIO}|2OHNf(Q1F;6bHwCCzOOss=fp;Iu{D~k z*u5*CFL(p6p<)Sa|GD3Ve& z@rwU$a{zGfbJ&O3e>wwze#{h3-iV@F1ROaP#PKVsrjZB%`NV^<~+P)uj4ca~4g^r=o-I(-S@AMAJ-r9h_3 zDX~eLh-|JrEgiUsd*TF)0%)L*+Sg)S?LJu>R()JN|KUIm&or~hg*LIlS0ad4@=%)| z%Ik{mRy+d(k4-$m;9_DDh9?r?J^K1g?Uz59bzO15tLtEd1s>*iLtk;**ejCRaOkES zAfwT-Bgba|5Sb0t`_Q|${0AcUDE^!lmU(YUzKAy7=A?v%t8G(cB>`(U#Ar0OEVFlQe!pT0Va~g--&?^I3yG0H+Wmi;){~8^qutWegDBqB0TUGPo`=1I52*sUYwJ!iNxjip8mu)j+M7=Y-@{jKYC>JE7LmgM%n$9MoK{kLocgc5#J z0)+wys0;u>==8xZ1K>Dkkf|9A>TJ=53;CG6z(gh;)0yhDbF_ni>yz?y{`pCX8UesT z=1V7#sS=b|cXC2mT8rDd48W;qk>F}k;4Jn}liC6ZCPHqjZ*+9-3=t%R? z4g@gVO+FWs=eW-%avyAT1h7r+ugUW@+0$m#Sc0W&VH1F@^;F{q-fgfT>)raZ$%WX< zwmK2+GaCLQPJ=g0Af(p88|*xBx?O^YE(W=KWr7D|`k>P9JEzl(ZUUaC_a2uE(4F3x zo%N6%_n>(P^!kGTK52Zxnga)=@$1eisLb$7|Nj%lB;cI7f3cGmx}QDij$~KE|2h8~ z@}4`aX@>(^=Y%}*$7}?(JfbHnd%N}VVZH{k+I`53iLd4Lfdmg~Erg{I8Bjy}J!0q2 zI>#i*GmQ^Xn;+{D!+!ppJQ6kbzIL<0f5McoPqic6YAOIK&%1<;Upm(WRrrdft&*@R z0)TUq1+a>oSMd>5g61l^9n=3VcZq8U0|2@9{DGeG$Ft1wo;mEv+-Jdd+(EYOJKe@M^|DNvsSEt&P)BpI$3HB|90=+Za*aJj-vbzBGHfC=dcLJyzY1Jox z>_QCxQC45zW`Ui#?=m(Z_;Gfy^S>@;rEInJAjWd&+u1S|Ep+Oi7r6iqWQ+@x^+uwf zVJ@)G8*#&n6JJha6BoUb_gu*WY~rNQ$4zg-`1TQb6%+`l%}uRuM4SZz zgu>(Uq*+ue9Fcw>ini%6JO7e{2NYk-bp0wJwD|55vR)r8e=_hGkCES*?;T?}O0Y5V zY-1KMc!T$uNp2zuWrk47A*G60w2{Ai<^cwAkbegrm#u0sVpqNI2x938e!a__0Jo+? z?7PQ3{R)0&>@06c#~IH3gAM@Lz&-@FZ^T%Ds)K_o90@vhR5}y&72L&B!8&o^uHqHj98v$XC zvVlr282{iV&|V3gsLluN^VQA*9AJC^!WnIfLm8+Af53>b5I@Q+fLa(!7{TZyP%9yy zD>btm5UrMH8wbEz#B7Is-5QAT9XP-|0R)?aI~WImOblWOh7L*~Y2W}hCo#~F_$5@X zV(*5Zlfhkd2i)&q@euO>a9?GVsEjgcYGoP4EFT%D*l_qU9O_pdCiE9a&N%e)ZmB@= zUIhZ&PZ_-_AK}y*C(H7BVrpXK=KtaXF12!E0LNIrv5{o)is3??MEM5b=RyO3Iwl7} zR$_pV49m|FZ9I*xX(ss$f1CM@I|2^Lv890v(Cc)+bkgBD=Z-Sq=}v z7kGvRw&tZ|vcK;8K?k z+Q~QH+}^>!&c+Jhu$oUwKw1O`!VbL00RnQ`e4n!g*fWvXv^Y?-us1F4Bjy&MBQ4gt z{T8zg%HgvH!AL0H0M?+xes|8Z6BS~9)`U6Oq%P0hJkhilUV#7(tou*5 z81A1)d=c?Phk<~FFSjFS|9YqRh3)DQ2==ghy~DHA(8GrIkhdW6;eP%|28QB$ev&t=3 zdBznC>GB&)@N<-r{>bXmgADjnN`U7cG7m$>JH%-iaxxxXV<+IVuKib3=@Bjgyu{r9 zug}O+08%lueROOeN3Z{OH~tZ)1-g6jx9P}6sq5qI0Q|raF9BrPGxO-~dB!;3a`^x4 zPMbZ<5wv9k0MUPQ%-tN<>7oa^%t4p^(fOIf|6H^49;X0sPTD+Ad)d7`-kkOS?T5PD zujQ(q*V*{9CuV+;fZv%vn*-!`<_Ez>&Y%-#*k{och`>nO52H zl+pi+I$mn5(wBVdXHQJY;Iq%83o7!^ROFI%X#PG~aGMi20M!c;1>azUH4n=$x@w}M z9O{vo7mZLlibKtQYFDQ*R*9V0;6&IXKwGJn5r87XQ{=%)I1fdPZV|&=`f=9smoN+^ z7NX4LmYDGJY=))FOm68|K8pb6z1XS$pWr=SwG$>fxGM|uwiR>#MQmbShu^8{0HRosR@u$4;3NW z*+2r_l`)9rS7+rzgxqU3#wzy{mf=u40oVTnDqvFr9Lu`q^vfs-8#;It`RN2DTDO8EE0e+0P@!Wex86b)c*g110U!GJ~YvT>e%z{692X;CM!p zR5Hp&Ng82{Zj*Iva*xT!I*P#DM{j`_ZHZ=DDyxkM!LJ+%VE&@QfW4uHSZca8%{A4+ zGw3{#ji3uwt`8?-<|EGk{n`})jHSJ=m5WLOPe?R!-~ezcx<7ZvvI`xuWFF^sbQp6X zX@esYAkF~fZk~BqIMJn1{BPk-gQfnFWmCZzsFM_Xr^o#FKH^$y9LFBA*+&NZIL!SU z+?h=XZq{b_ev<@Yy=~1$j_IqLq!t6(DabcO}R$_y_iN#6Zyk6yqu<=GCU1 z0M;#NZB^dJURq;5){vVu_Ca(pWE|@o%tknxL_(VwbF?*nlgV<}=bO+IqR`#^IOod` zO@pc0`pw*bGjhB6EE`f8>u)%;j{e(>dC!<-4Dp~6@XMNo444 z%nJs6;Sdu5&6oh_eI^0Ifto+a_5U~!b0u>CV2kFS=PCe!0FnPLd$YrRI;>ykQkMaq zV>)2=bQ>9L7ajh8NRoNYe%B7bhYk1>;{O3j{x!q%MB^X5xQ@Eh&fv(;Fn2Tm<c1fe z;7v)d8a(<4Li0q2J=s807|2N}PyW~7e|1hUHKF8X9F=!g4*M@@+)5~m0+U?eb47%* zz+@E=kOCf8kwqvXY(*xjh*B;x_#z8Y;sjD+z(tf+5#cOi6idPsC@OGJ=9^VtuU_+N z&{LZ>8O)Vg?=33d2&}Ac8)H7+;ZxFQ>s5STM@=l;=Op zW59baD;2;-DXTgI#ac$`l@YeGuog>BNhmVF9F`GQ0WgEBKn{RP6ICI==`l(cRi-Fh z0^^U00gO&?BFOo8x+?|_$@vMVKqZSRDctPz0QZSD#djK4fqVpQFmqEG*!bU?L{m`; zh|Hi8%d#%|B6!bv8;JWn5>2)_>`Az%LR9GI6hsIcu!8 z*U<}LzXSxTXGAm#(xyPEH&H~*gB>x@XPAfPA?6X#`{EV&5wCTFPlYGgKE3RS0?Zgx zC``ap4Hi_XA;x0r|6CQo+P0AS7VFp=+6mx3Gsn3!koi;ZidlZnD#XafZ6li<*0^&` z0+PDScb74Bk8_^#b0!O79p@fxMK+S@0F^q;BV+Td$@~_l1Nhzo3UvX+y1+daM4<8l z_YOdA7B51X3h=Cp+YDLce9P+$Nd~S)kUs}kT@a1i6 z^ts0pV~B<@$o2Bxd4gPKJj-u%$2j)KGV{2+kWGh_GFV{_R`xKU5aYDMy07s673O^9 z2xALWX>h4o=@`cfdnOtcJu)4GRn@TLq_37-awz_RmzsoV@js+O!A|&U6A0~dKdNCF zRMvBo46U#L$U_hbaeCW?ZrOwkZo1h~f+>UO9%kdr0bw)p6{UBq{bt6onf2LRb;Ljb zJ&aS3^GrFKfGlkOf=~Atg=lZQM~3t_;}~sb-*39pU_RyMaW*!wenH`j;@`yjY(kDV zAuF36=jaA&6}=erxkoyU@dV=?+idV<_*usx#$1i16a`p%ik$>uN6;Tj%KdY28}huv{fz3;KMfkG<(L7d;$@-ZN897w63W$9ye5BgwC#1n>lx|KYGl&kW{d9{nN;?a2EJ zOpDylam_jO*xaGU)^OeK-39^9mgtyr+=P%7I~WG z|Fh_@=>GRwM*w)18O9QXV0>rhB%k%hStS&u`8xeC8auRWrst#euTKBy z<|*lxZ~LVRC1gnbc2wCE*d*2bBZHIJ-{v2Z2u)4!n$tJ{6*gN{r)mVbfs$yTpe7LV z$vrcSsV_vso;|aczlIVMZLdo5#=epv=rRjcVnY@2!V4(J0tUIj=SEO~BP>J#@3Fwb z6;N7*UF{g)p%j>aA_lX-wF(GP3FB6})dq4)hP#6Rh=r&s_sb@z^APoVg1kg5)O>al z0Eq*>!KSL=aaMotkUkSzIgsD=j8|o;UyU)LgvzCU`u?iyiGuVUl`&>zHdI;HU@T>xUt9;} z_t`1H(FnYN!uA*15Z~yRPVGOivA#A>>Z7}+gA_&?2TY_vk+0v{*HZ-IXusryoaB3J z9E>?q5uJ>{lo71JY<$zNtBn)j9#OLRLq{aol)+t~)Bu}#l#|NnW&U}00wIIENZ1Yp zb?hXk1h`Lh8dRkR&og#Q@&i;JY%YLR14EIuD&MWLj@9#c@!Zian9WyJI_FjC00tMp zT}e-^w!n4Puii;Y>G};$1+c~q6nKNVZ+zFC0&#MhY=q{#HvwaA^0_7ov58`9;sg+w-E-KnnNC0lnds=$&%L`C z{4R>Ci%fNw>;xbybDXs2aJ1%7(9uEgQ?7yLwXjv5jshr!!CDZB3dU{mRVGqtB&%Aa z19o-EAYe?uJKA&PX!_0`*5;IB~jZ#PI##^T!!7oTsy7;+>^ z;Q$Zv?91$@Wn_2xBW@wfUR*|gmanlBu&V)uCz)&DrFIPT^Ef*Q?Cq6VmmL1W(E<#~ z%8gDHsMPRdTauLMpDrOh!)1f$mbL3l9>g53p^KsgF1l%*^@yfK$mKfD$GSjuD11@o zZW214HQjW$fB)e9(gZU;m9zeve#HwTviZe!3J!F{;IV%12%qfH$(xzq&CK6s4mxUS z9Q^zXPC>|EGe5y!@JSnc8Tvi^LYCGU_d14h{U%2-_HvYiajb8XRLPrOUaS1`z20~JTCbZM8LGFXbX<>vet|}yM)dk-ec$QyICSSgXz2v;&|t5yohV z=Uw6%m$>H=`(cTB7_v@7)@{hx2Y)s36es$=(okHte}yTlk>mc8-Te>8aq)K!|DT;4 z7vTUX{LlO>;D9dh_dG^=p7G8zmU-4{jy*faL39oSIfpKv!=}w~tvQ}$4*8oy&bq8q z7yZ<&yC1;w3VM@S%xS&;qiC6R$Zv`T^)YLkg5w}h4GB(w99)X=Aise8~&P4$tYdr+DpGl z5Mv1eFCh?RHm*1gA|>!X8)20;qHxOyaG6b1-rtb~6hIlJQAXjFQAlN_L9X&^v!eq) z@=IleDE#0JV1q<8z|Rv;5h)1Whs{++P}H%ptTe)FeQ&(NGHV*C2~{bK+3Ao&AgqAW z1qgLu6O>9=uv4H2!5`AW2zV+#;(b9fT957 zd|yqHD#%#{$0z84Z_0>G_0=W<`ktMD3)7*C2*3x8=eR4=Jav?{x&qeOOm!4-{huZV z!f9(f&bDRPJ$@CIi6>Z z%|FlHnrH0u2fJJl#j${lEHKt+m5NeX;8_+AH7?*>pRo9DkA2&#m@k0;^=C6TJ9wb! zgZpkJ%)TA6_lD=BF<9CvPk8|lJk0>H4JL-sPjt)@&%eal25l_Lb@@e(3Lxjp$2xVu z^_Q=<(Ghr1jsk1GjI$PPXYX;U;AsXH79Az{j-3G3aRsMx<=0tW7-fa;&6DiEF#*W! z8pd!9IS88JuNfq$&#)InH5^fa_n2B(n1OejPvAzMkh#~o3?^&2=~0dtJj0O!ovc~2 zO_wHiAVTa{`X}?gdD}eYZ@R}Jcka81ac}yIfB&q(d(7{qeQfACMQ`G?xQTgQSNeke zyRImPDjdGb>ti18%k9YE2&{e7q)C;0FPbPV^ZJSz5|tWRwXsJpuYS*fN@Q!5wO-Nb z|Da6UEUlQ)k7pS2`*7YTeq?xvz8oHxKv5A#MGD{v<^;g#su5764GzroQ8)}w&(zWY z`57Ra{hO1aGVmt?qwbO=ssRFgt8pu*xcrZ?Eh6&^l557WaJWzZx4HJ8=bFbcn)`*x zf6yIs$mQI-4E}pgIso0@-LDS-bJcx=djVj;JIG&$|96H4=01siiQaE>k2d#c3*nE> zn%!(tFFElzr|R{gJ|N)$)QtGYuFUM|lRt9OLie>!Vro-#Q>!Mb)NU z45QP>`!K=$Mf+bx?Jv(%qZ|N5@h4eh_4X0{{p5B|0kDsnXKoQI>Q+JeqB1+7u|?KX z=f;hWl^fo3lP@$7<~oC_aZ0K%K(&L73IHZ{^eh9@n4r=fyafKkV=ZwCD578rOzH@V zZexj`e6}F00D@a&a*GH<5yMf$AQds#r9(5CAOjnDW;Vt+!at5TH~x*p9aMQR^^32+ zHW|(yENVisGos zFfsAtC=+$*DwT`Pv3|8WWK*6 z1A1T11LG<0U_*^C2Vn5NFukG;y5|{o1QZ$gg~59m`QQcMxr6>%l4o)W~q7cFf2#dfvl~DwdE@;^y7}_bguVUesjzH|5sfH*YJl6n0RW7Ik zg3pg41Hp^%l&lbm4udF(AP^EBKqa8eM^FSmeoJ;vMDbUyF$VzG72{+T#Z_JQ@4s|Y zAg%pc%BUD1>&!vD?6eL}T4QUM1n%Inz%QqBIDrE?A+J{og#F5D?8J!~a9&$VJMLPt@>I9o?LJrv$ zu$181Y4L6_AJHoS<R(tV?&3X-xl^h~~fqs6t@LjsRnyf0^k}l@fT9L#4>*0y40O!dQHaD+NB4odg3M z_#!(2%yVB=0_cN2YuV?T1J-lE8Vz`FAY;%<&IA(%6QLpj$ma@krFO+D zjC+O8udtU^Zgy&bYX_hGCi4fVN&p9C4Wqfn$!+ajS?U&10pxq_8q*7lcnD`_4aL9q z52pw)PU}3+I`@hOM5mi%h`q7?b5|DZ#EUuJ#B**c-S70yK8y~93gHWDfJ_D{5&L7) zaX#I%@1i_$D;swl#&r$}>m3_!9NP6WT+WDt9~~5#^L3taUBEx&KN=~$&KwC3aET=Q zX$?7F!ZO2Z?YxfB@R!JWpFc~gI3sc(fElqU4BcRi3ew11vq&#{c-l1BehPN(IrG!7ahq1{XO3z`XXqZ(=HReV@J5V~u+}cdwir z0MY&L-P!qX5yx)fZ^?DBz?v<*A<2IhwlN0a925V@0l-n3!!FEm&pGz|+`(qqd|U!- zqXh8tZUm&t8}>pM`_RF;=uCL;VU#<1598YAzHRhO`)x_&6~sTEF#7*sV|unq$3FP} zzi8Z#@IN@!E#7Z^&msQ{ee!2qt-YNtWNoJT%rx>8T}fY^jHPN~764;a?p@=mBb6~@ zA1BXnHPe$aogYyE4)0MuU&a9tqFo&F;(Av%J8|>ZZ%wZJ$bCK}+0^PN|EfadDv6UK ze}NI-Z}bTdg&+`H7$=l}8R0D<*hK_k1W#ro%56lc0XABZQ*4RFDWjCi2zE)~|J(DV zE1KFM4|+iY#wr;4>Ps>YANgVwc9rkfFzhvqUi}zeY@9lZp@wH(eP%ieLFV&O1JM?J z0$uTGf7NJz1bh75KAGy7P!1KYQ^AN;&dxaz$G&p(C5`nl&X0c~9Ug)CAu%yJ0VK* za34h^qIzJDjC=&sAkQ;;U`A{rGJ?YpT?pAg(W?L>6TJ+sbBQ3bHO{GGT&b3axeQRh zv*D{K)@TpR=c~L|{gxvD*C(xXbOl5SMcZbb_8)B`r>O+~HTZsmHEJNUjiZtbC|U&b zyc3M8xuf&=`#8V`b8en7w$nl_- zOPxQ_?aH-!jj% zj8a_Yd(m*_Q?4es*hDmA1{3Oco%&hB6%5MC)=m?g%+t73p>77ei) z6s@v;YkX&oIbK5#ti8sJf(s6bt7@R{C_z05aiU`(hoW_!aUI!QLym%an0u}>r|akV zME*~o+L4(k$9stlyZ%N;5iQ-8p3(J+|izQIP#;MKJO0&^keKn@S|FP0NgnnF77u*c_>0z>BK zC$lnU?k@9Y$N|9Fnq%(f_D=>tMa{bCsxCIFi~Z>y=Dj2bK>JQu9PCSHe;fbjxFaAs zuYF;r0cLM;2_Uv?_83P1*ncxT{|quPQ*{1csDJkN4C~d>f#5PT{R#AkooV54w=nW8 z_Q3S5sWYZeagUOnl4vX#|1S3n-8=PF;{YD*6aeF%#P&>n$T$F1_Pr;7&Nu*ga-(c~ zHTV&2uTlYZCZK`vG`CNMHX%Tj(AIb_)jv4}uR(4C0pvwL>27IQ*b!#Y*8rP_!MCy1! z^&{;7@R=G)O08up`aYh{_@%t|PQxGh=mU*ZKhb4tD4Ow)<*776)wgA-pD+h%{u7OS z1XN_RmvkEbx{aSs>@xN|TZ!wG5dIPys>I@#Fhu3;>;UZHpRf1nAEjSrAasxAeH=q6nrJndQa8v*(csucQy?~Z6-O=Tfd6GCz|)ejsdkg2 z06beA#Zv#S!~dM%>VJ272#>dc^Vzs6X@Mtn+P}>C{N3yfsDk8i4(+qP6I^TJ8QD)D zm;@P9<7U$d@9!Q1N*S;Y6U;^M3g~(`GR2k_kUS7xoW$Wo%E@Sdg*Rvr~YxyYL(>;3=$fB;EE zK~y~!dG*aZa3YIlp zdZ7P)mcfFm96+fro$IhNN_>g+TjE*NSxyaRmKoc!PM#Q=)d-?Q3b}azJ9-|17tm# z7U@)vtgT;e!{2a}0foN4cY+m_pO>K*p;1I6ru`C9|77DE4)HU**x*O@d-P&>iqj$Q zG*1FLDH=8LtSfwOg|%IIt&#pJ(?mZm|I2f$b!)n=|5zLTN7(4&{0`6+15WotRx|0Q)h?8ce=3F-y%O!U@0uQ27{2Z;Z(p*Xf!?sq=6RJSDXQ7I(f*HWLVR<6x98 z-c|McSsEuYAf2@1w0(`)-FVos(w3}=mr+Ck7TLTbOy~%Pv48*;uS{d4&URycqsRp; zMCquNYz2p-%Kd^0RvnvLIus?&}Uzn)%_`LqdSVjfTlaXKW30_f(Eg2Gzs0EW;LUEP2 zUx|%bLfMoAntPNDxQy+i{Zk=+#!=oXorKa)lP^IP1;PxdJhFs9mG1J%efx|!gfnoE zjkS#Qxp^uNP#%s|@GB_)&pZY}5ROq)0-#t+2u$fVI~s~SC?)X#zYr*;HNwe2VMa9O zt#$&05!m3DQUsHJDHVcYigHDi{V3lbWkZd!fk#mo!CP>g9gz!MDtLk&!*g62aJroU z?lXRqxd4!j3iDR^e#)P^Nk;fz5dbztl?_&VU}8IJ3mE|jVkeb-wo@kRclvdgoq#`? z6X46)6Ck(%Ug}f;*P2jyARBFhd#PJsobF}(Rbg^zR+Kc@6AeD!z!*(D$Ps~;x~f2q z@sCU|jZ8(m>jNA$d!d1X*EHh+ zxl}`;Xe<0GpNw!k=2bE9P1j5#lWL#3@CxTszn<8D9tyJep6te^e5^=W`k%>WE#hn+ z?By5hGmvpO*(HKpbNDsqi7$1|_~#k=jfemz;Gm6V?t($?JmUf|GD|nOY5?7^#5I@L zJ3%~y&RN2NT*CPa&H<$i7?Zf@gOeWpwfr$h3;5hJ`+0@^xq@+7VNb5GHY=UP2CTBz zR*yA-5c_HsSzSd&RvF_OGPCv~zhvxDq-%TIV6uj5+%tL)C}n_w7DxWt2b?+(m=2@1 zcAFyvPf9Reqzt}bhd@yRo_n1=z0N(NU%`I7c!u@=_UZn;esAlfo8@5qBn z^THwF9%~2sweOZ-LR`HmPx`B$$nwYlMP8O+{Z-_5^*wfca3V#&yu$jeJj~^o?E7V8 zZkhR7Mqe)L)IOV0oXFe1#wT}`@1Y+C?B~H{=89k}!{<0PfDDKtc=_3O)>IL|d`AUA zKR+|Ts0~i`>Hp`Jt-X_zqK7f-?UTUN#cQ*t#Ugur@nx9;SU@Hg1aL)XE-;S^TU(|t za0S3ijQmHIq6466|JnO<$iy6LGxu=*u>aXq&w~dy~rmaXx36&smlD-Qm#xcsloy>U)TdKlY%7P6?V{*17c=6Y?En zCjfb9J<7TNj~M*7lN|uoFFO8x+QehXR4QO6ne(z&f>itq4Ex@hq8BZMS;FE9Wafn9ASO zDX_@KE}(Qq@K8sXup&mPv^jIg(O+KS_NlDFuj-`7J?gJ_sU8nn<3VdEv<3??!FMNA zv2aD^dIbPecfnwMJ17ZYf*(lJS0Tw<6mHLG zNTdT!wlku%gh~Z@)?g=8#D#etJ0(*);RsCI*%QWs(^dt?Em|SLLriYNf{TgOQdMQ~k4eD7p_Y;cdpd5LF zCvxHm2`Fu#fEp-pwXSYp@EWQ%IV)Kw6-f|d=ESq@EC@4jUOL8#AT%Fre8J8cRS1Sk z_LB&OCb{M$Kc|p~DaI3B2XAy5VBY-!b~iV`5e@-62%KO5;W>5|RDaGqE-`OQT{{UscH{u#8MMTF zXZcKH2>8Fqhh*FYWD7dt(LC|0xBV(cAUYR5(u6`4M+N@Ci?Ig1u>M9i)d(lT=MT)( zLFCrCMzk;1-{`EUED*4eeY!T|^a0meXRg+F&-{Gg2;>+%El=_h!WUW}BeHgtfqKkK zR3#|&!1J!1@3e%#jC_9;8D4u-MlGUO0uG13jVg5v5Z?xe{LytQTzlp7ykzXThNzc= zR0+9SeVtPzdl_ee94#XU%NW_^UDMf$?tTZ_aDOtx{fhVuuJnt!8Sve~ZxatP5Jmv` zA5JFdGn_T{$kMHe2?=5#)_Tag53X|)Am*}qB?jOvrai+un0{`)xUG#l- z8xMw5Ws|Np&)xo#jX$=bjWamQ*rE&Iw{rXFj<&l*g!zk|~J zov!TTStil%lMiwgKpCYqdUT$|gP>(Jm2Qm%sWW+v`BZw1i6mK3Pj;1Njo;!E^xG0a zA5C69ktqNHL{ApoeB7A2%vRHqP3NhP=g|ceH*(v=c`D-57HRaxNdZmW7Ab%-IjSEf#Tx_Pr9k*onz@Isi z^btpYj&muXs#Ct~%9DFt#(7;jhILhaFvj}J%n2Z1D4Sf=){z>*@YQk3>a#8v?3x=u z&f@<|BB>w>lCeM8hX2_aK~OX)m?jTRIc%Ve8lTHZ!UUUZg8NP&2NT?Lg7ur=c_waf zD&ZGdMi>qN-x29XfN;)Cf*|GPrVeu|K#_n0>;&AJ?3=;$Ek%Ixo?)}jARDu+V{{3W zBEe|RD*XREI{^pYuVdh3h9f&KGcfQYE*Zq(>~I?EKHS&HIk(g+6| zTOgxyl);5K1k1?(^1iMrc)3dpSyv~ z98|-fcVs}n^SM>lfAvbEl_m62boeXh+(+3S&p1Ty4}<|hZU@NV0GSxH z4CGTJ0G&7BdTQ-E+|}tH?8y>iT4FAPG-!~Z!NHxT0)CwdfMy*2Kfw8a=B>wAd&t5f z|6g2p{(m=z|0@ptADm^b(fEh;n7_!B*gWsNPWsn6|Np-R04ltHkEwrI|7Za80XqO3 zkh<)_?zRcE?flUoK*rd4sCxjQC)><#`<3PaxSAJwFj@eQB=zqM2eN4S`%&lq1^&I= zXn%B53%k~uvEhHOF#t!}8NiX8{=ei8nP#r0JIMi{3IH7@)W=8M|C7QV@m#@3${Gh{ zIl4gI{{oE69-n-n0sciCfCv$b>_x;r7_adgvOYda0{8VvN@3QgB=AllSt01hzn(@k zkl%mI@cP(=nU5B;os3(N8yC3F2%jH87&mf{k-sJCKd62YgmIzmnW!pCv&w_j3VEW7 z6Pk=Z3apOMH}KXQ-*W!-;6!}anb*wOF5&V(^+gxao2@H2jDhW$tPPh&ZT zlQGVuR#2oBHmNx6b%Kt3w*YZmr-U#S@yJTg$P&O3-gxOm6Bi)>MK*g;##I#pC-_wV z=X7plwBz$S*{i}~+D4x5l{itC1R!KiN<43A;QxKaKtdE@=|_$T{2-lzNF|(@a~t`0 zRVN6M&svSL0fI6Zp&DhQL?fV2W|~E*gs4vViJc8qD_rIj#4qh|NCqC8DT;Vbr8;(S z6hKi2?h&{GMFSdk0!F-EOdScob0&xyp zk-QlJ48(D2;vkD;NSjW408?9=6lf;{b@nuvOjUkSn<5ED#Lz^{fbN#l$liM2)@P3yFs#I`uDy}a3p?hjN0do&C@d=7~4w;K? zXk{~^A*XYV%#%hWfRoVz_g-Y)7m@o#oQ57srT0-s0l02|By+Zk0`$=X{i_`bz~LDn zGivb~;4qZx5Lq6gFkW~xO^a$CEHp*}JxDGJ5@r8BeLdff z364}xh85;;076&HJ;k|y=AwIY8lCd++Q+YTNuAK}e{!B!`Dp>sA;TqkrCYz<{n)5%RW+)qzpp9zF}f=$$5 zLDlbl0s&DIpT^aB;)~X>Ola-@`E-a;t+5emkF~)#(B*s&$&=^kNTwwOSPRSne^=Nr z>P@ebL*=c**ge?BQl*Rv?=#L4*Aa7Jk&|Vy>C#1!A2HD-MG8=&>W5JJokQ(xh7v|5 zZ~<&W^+gDj5vcM2 zr5E^wdwe<vUrP5?OpZ1(zbHvEbV>|uxCM8Ahj)$UFCs&f*K zZh}W-s;fS2rvN1qZHDDEptRIDD#{C4_Xf&9&7~U5U4s)_gLP5gi2xU($S00=ncye> z6Q!D94ks92llRnBGd3d6uKpU6JjWE?_*BjG!0+(JmLk|Ol|gh0j7!aVXT5w8L|DUg=W`^U%S;=zPUh0uMB>NdTxF4S-@kqrEWq z2rhJtNi-PxUXlkbpad7t5eq!iBG0{eRx04$HYNySPWtSVK6BmwnmGc#kN~b|=E7ba zH1dQu+}BZn;~W(bfQ+>c!Wfm2{g40VenVs_nB-7g(LiR!xnk9tGe<-AL$sIG|1S5b z^jb#~Zg3hwr%mw-+-%U`A+93e`f6em-3s?GxzIEHLg}vX{3|@e3VKkDh*s`#dO%eI z&&l^zdA3!3@9sp*ucG@_(Ko9o>*!0MeETU|5^2wRte)&B0Zz>-doBQZ{J!>ZhwAUm zP=0hWWRI>++kkVph^hqEYfV^%Kj(W*;2>kYPjV(znO2&6RJ>23tXd$T-KbOKb`j_c2&qoU<6`(fsT1^{yX zX!0{<)IatyNWqZ#7SG-KfH48+r50=4Vhq#lx#`bjSJCJzA_w3f=Kp8kP92gxNG88- z0y6e)^gBTwo7b7Mg#8m_Xg`z#&`(37x^mIARyJnIm6T#br==Scd{yaWS>6~EJ|^S6 z?Uv~DCp3SYWSQWSYT_~YMU;2};T^#P*@$Pn5oIyLLl^8 z`JBLqLh>WrYV%upty2IP?;tf&*&Um^G?|83r~BeN-J$TtY*Sq1Ig89y5ra_Vxr&Ms z{K;Yc%WY5v5L~|B2_KKR#HJ{r;7SNd>BIi{-~Rb|e@^$s@RTlc1mQm8eSJm(B0n$V zd%cY>o?iLK`ApGI0O1YhJ|Xx89Nfw$e?=x(*V3uJw<;GJc3R{FCb&ku1E&PD#osgF|IP+Dx0T40<{&k91MS$c28I49k&-AHZ zQGmB(N~^}ksv$=;;RKkQIvb{rlNXgFauzrR)gR&aKW#k0Z%i!2dyTV`BO}^Kvyq}D zwVVK+LA^2}D!@r%;t_uT9a&=7e0zd!f-+bofrZ?lQ;d6x6XO)mFpYyVjY60nF*g8C zcMG|iQQiy#uMX>VsI0GVqeBW?C|8ztSoGaHt4*f*VzI~ss| zbf4fz0P@!5b6xgCmo@AnFX}BYr&IuIJ$GsHrwd6PTmgJ{k>3}2=0&c#$l5HTSb8X) z9?GlFT=kK?J`P;}xh@q{Sa@4U0wxU%+uf%}IRmWM5M2@|a=trce+~c3CqHAvxXgZ1 zv!WH|JP3t!T4sG#*xM`Y3w6BCJAY5Tk-K_@J>GN~`8>6wRntK85 zUhL=q&$P;(Tty}Wa9DFF|2#VjpYW-kbzOa`4LHxZ%5_)SufbrbeExs=M2{X=!9cD2 z&EvV!VSJuiTDrW{U$pBXS*TOt|Zx^8BpD+zoaB zW?UAF)6~7yr~iw2vG==tzWc;v{0k@G!6yH?&5krqNatY*zHOtU+YLJa;_G-~rs-xc zGIr;%OykWkk25^)3~L`<{*dz)`>r)@2jGha|9!!R{{yZJLe5*;x%Dq|GtEJA8a+47 zA!eF`!4!I83i+5q&Zl-U0PrH~863Dt9DX(WizYzKN6?tFj?JnZfbaN}hmlZ6IU%#F zOtfmO8yM^QkMd+Ll(s_VVMy;u0GLYBB5#e-E3(mx2zdcRSzzKfG65Ue;2YUw8~J=e zM(4?yPY$A=H)Z&@a$V-@)s&~fLO1rw2tWf*b7D{DSlQUo%;gKo;?}q)6}C= zaFpLW$2u~;T&)>9-vbOD7*oBVxW9Kx>#XUL?BWE`z309 z30SR7C6jN0sgnl{#yQ)!Gec7G|v86;RL#Zu32Hft$f%{z&SShN++=P zD>$4hhxqe~A|P)oZ955<*&*05Pwo*VP`>_P|9rlq2RMhTIJhe~nJdUwbU)m|Vg6(N z^U=QEn)CPQo#>b-hXn_61sPrWFX#E0!xiQu+AJgE!KnCkr$LadAX<808vEsg447p9 zF2BMR7{XLA)+p6Oe-1a>L6ftFAsp^#3?LSRsp2&z<2xDocu;LTZ9Dga;)x$m(*dR)85I`z;Ii{CQ(pXXbYTw+HSW?Z_8 zeqBI@7TDYKa$wJL`2R`CeKCj5nERO>fD@7du=@`a|1fV|=BkSvbzf%EAM{D*X47x$ zCv)9l?K`Yho9neNb!E=M#^yZD4#0w=bxPl{AJzSDX35Qe825}Eeb%?tvjZTbf2tjT zkGKlpBmlyh zJX8*V49-7Pa$a&0jD0u3e!53QE0mvR{K0aEp&HvSs}3U6yhBzp$RQZz zI)S=pV?}u%uL7H)z!(b%dx29@0YNCRU_}JH$mTA}kSgE*HlL~m^83C|@e28Co=|`# z6jtel{&|ocg10(qqACJ`2ss@`C4tfe!U$CE=L~Fi6hO#*mFnRzsV_mC_T|9w+2}c- zQ$LC-h<9-z<3ko z|EmIZ?wO8g816^=rOE*DLvY%u)$Jfu%om_)7VcN$RH0VTH4J4mgkp2nUTi#pq6)$n zO!)h^8%x0d>w6}aq|Wu~djGF3D`XxUjJ2W40TfmP8EY^P4HQ=6XoCe&LJiijp)x__ zeBx$D0kr9myXLJ1zz4$cG(ki z$dss3=XXi;^gOb(@T8;+R=#zSJ+sKZUqp7J4?E8rZCO<%@WyP{+TSV>-2GlQb%{s- z3T;sE$xuk~Z#sYcYXiXk=5Vr%4Z0}EWsY=IKt_mb4wUPEs4EP%N|d=u(1zRE5zwhr zSOc8+V3$+K`WAx**(bp_po)R7WNJW;z|wE*45)k%gRzVZEstc1V0nvwa^IB)8#nNL zgXh>^K|6fnmMooPJj=h&9Qq0dEqWBN?*egurcdP7UQ^c5=tc$?RJZR*`>9Yw_ zZ%-Ildt#OWcCcOTE8GVF8`?&G)Ddu&eHP7t1m5LYXIS5v>s$i(E;svO-?o11{6FJt zecnd@RG<18bFcs+L(_jS10efg`e0WOF?Z7s^5KDdO))o@A30Z0gb#z$cR3r{|f%K%H#~zR;O`Yb8e6}bD z;6d5Ur-0Wqf&m^uQEp^#8`%gOndkzOQWSs;ff{9C<7}>qkllACu}dh|s>A*tPny+< zzuE9tGGsBy>3EU_Xnr+;S8DR2Q&|0$Gyv)(H!j1XQ$E*K+ul(&gGg)2ze>X>(wZ?0 zRfUsm_2^6+jI)8qw$Iaa-{5}Q^eNG0XwA7_UE;VUseC6t>wBMM{~Fa3_71k0ds z17EeHrgA_OKv4GL{RdyaK#RvaSFf~;fPX6Y!|5r#<9_$$`Ae_2lXJ3-zM=q%NU%8r zkMKD=0h$Ye6IF%qJIjdX5=W+dn4JvaCD<_0*-%b^Qb{;8qda>wD!MpRMPmmzZS-nK z0l44ToH-y=Eubn4oUL)>V;nPQP$&U{#mQ`- z_@n25sttq%c&JNH_werm3*uNc7*p^EV2p!G_~I<1Z6Zt2d62oB#Gp>1bSL@j)Pbh& z{9ZQpP#R$R7Uu;2o?xNK845hKoJK!-ivQB2B0qJd0BbmVf{BApvs0k(B>S-a3_AlT z7{yGx|ao+{rQ`^;`V8tLV z3YmRQhG%;i+TI7UVM`x<&}YB*IeGMPB%?eKSsk#y2cL78c*3ahuh@`q|G~w1s?@14 za>tGm1W&v`XE@vg4CP?KCr{*cz&?)p^Itm3pmYO@dB{2rIV6aQPI+f>*GJ`ma@x%6 z67#b3Wv2&JqK2F<%aHS|%Lf|`FCGE*#_~A^5z2T!+=h048~kmvx**ybBO}W{w8QXF zpTrMxWZ-4~TgHCMkprGTmm9Y zWh5uo0@)m}mj=vPpLrapJXHUaqxNJ+1OC?z-%oRG;=BJ$r*DX^99(TjVH=Z6u@`&j zpx(J={*#>j-T8m^{37eLh+Hgu%e^elG@GSP|97|pAbN0~d7OWw%m0v%xl7E3dHDSR zfXrzZT^fyl_IAmi%4pFWowHn7gP!f+uyhz#2f64d(uVDeR>0_zHsfhy6J~kFS*|tv zd>j8C=02VIkgI#pGc%82f1_JlIDM@PeCp>KEuOQ*+PBb`E#`9iW|IJw4H#BM0Qz8h zfAjz23{9Pv2MIMDo5bOpoVVeBo5_Fpev|oXav*QwD5x*W#1=UK8#4r~aPAnwGmfxU zPr#3-vGioby3D4^gAIx%yj0*Y;f3EGHoZ{+hMY~I3) zGLK$X`1heE5c+0<_X2C6(>&J^XM6Lhc|vN+0brqKf;j zSv^p>Gei60ogck0!_k3U*QuEa9sRm%|512Vq5t2Mr%yGv5s)#A@PiHXW9$VMqrgNJ z_*{YS7ch7QlxmSpQbb6Lm)O8R)hB8>0W3s>*k#lombAykf4Xu21rdP3?frVB|3&~y z&vE48fcqI~ITi}tf6zu*)fInA10T$SiUgoQqC8M}d6Yqr5IrE*CvXRfGCa=?$1Zj_ zbRP_O=}1Q&4tGRC;}%ZgGj<+S%K6iDJR+TNkDY+$8V_)UodAvDix~xoMo#->s%2D8 z<@2)QB2NE|IoKHYaa91P?lF{ibPW8SD+9RhIBQa2t*VT@`Vr#*6yD!ED^bFDA7_LA z#C*T{BNGUrbgNvqI_3(34`)?Dg=T3xStmACd*`(1;Qxz*H!k`l7J`)(1iMsg#KAsM2lTAPQ z0*B|21GTzO=bn+ajg{Hb4jU<<@Oz%vbyj{*B-aEZUK6X$pB2(Y(@ z``B;^CxGry``RESVs8aU{rg?!CeR@NSLecImBYQuVRDr6GV;C5HG*4!wO#(6Pu1wn zpd|jJPuCbN(Gf?V0+kescR&uspAE9pX`guz%U(DJatPSl!BfDv0-3M>Ay>gwz#Oh1 zcTuTuyweQZ`1+SPWpU${|MW$;+Ubllo!jSn%NQM%MJ@?}k5O7;ewWyPOASXueq#;= z);{?9546F5lTYjW-7h8cj*QTRvn9t3-8Vpo_J8P-P~@%u)2s#&pf7-+r`W-}&Jmw) zc`dc(*qQo6}JbZ>{}?Y!Q({}*NWzw?ZY zrUeGz9CHA?#u0#9le}wIAl@t807(1we{B4*lP#tC{%9Tm=BkCm(|W&4f%i`2f0PHK zSEu>@G&*(qFrWNi=I}pqGQ~4ZF+Wr6`^n$C3V`{UL@!J-mdS@l$zOIdMej#fRP4;e z?Q#I{B2^kD12}qolC_MpkZRAWoTarGSX-)`D6jJl~_FBGb zG9oEm82|yhgw{UXcmM=WO=BwDdt4{YvyvPq^7?n>iCNtR$3KLLcU#Pv%L@F`u6z;3>VQUh$Z2-^!kz$Oliz@|KrM`-@>&dJLV zqohUT6CgfCB2=Alw6C{wjwkN5y&V=s1fFJxZG@ADt4pjv5t>ZIzDS7#n8nRY}4mrbV@Sj&u!1dW?07ehoa^ zxbPv&O|*07gjf;I139fd-eG+_-`W8-;wZH$8?}mHS5XL69I2|(Li;5DgI<-t8YGHh zsh-N~Y&!=y1<_?tQ2^Gw#u#d>R}JM@N7>X-@OAzlji)|qTmb74{U><7V5VeGLXX8wx?C zLO8cGJGqWnc|_)*b#E$=863YE_QH%#9>~Vb?=$oml>_^`df+Ih2XJO)aVXmCq4o`? z5kARbO`UYuYn?wE7jUup(YdD@sLW$P=0A|+Kv5d_MDwk)jtdyTMU?5{$J{&M*H+p; zNG7-bMmG=otGnBP}!#`pW|uRhNk zdFNdmdRA?^QVj?B=c#rE6dm}TQw1_+r#qL;I!33uCnYgW7(bnY&$m(hXGQ~bQjVNB z`#3lT-fsNB2mHHE+057Sf zH0p8&mId&8o+AjmXL=#7fit{}PK}biq9YG-2AHd;c98QTFdzG1iM3c_?xXwS`}~|3 z}Fvs(BIXreRF#2B(!0smex!4f^^lt|_?eKh^ zN0|Co`G4-yW}`+)(uP76H| zjel-8@DH6aeWmrmXi@;HqiB!-earntjxzfH&rSjG9Fs>l?|<=@Z2t3FlltwEwshiF zIRFBCDbLJ@MEWw?&CqNGB^UhbY^3V#iOQ}hkBiX`y4feCK?$@!8)SsV+K3QtM9?;% zL^q-_TSrO z7`CR+@F&ez@Q@s56@jj@aVrY*3+ex3M*#M*(P9IS?VC6O<(Mldk#P*0XljGkUq+kX zix`+98>YbTBYbZJ4{PME1U43S&AtW&6i5+=p~%D+*|5d$x?>TjfB6Cx`)scY**fH4F##!lsr~ADp`IN3u{fB%qm!TKtfa?aKj}ZSV-xJ0F zgQ3>UN;?#3)%bBU5&wGJp*hJpx{8JOFbv%6CTDxMRFO_Dnkh+xjO;WbEy^4*zBgRF%N~?ia8r zD+9uy3#`YfxORwh{A}XdE0dT?4r_&trnb?QiR6B$@;p^GN(JRm*_59NYUwv`iMG(; z0PJCB@@%IRzHOkP%3z=4pRdWvgWw>**{!3jf{OTXzrK)Q*#_&-z+q?{=Tv|qR?N)= z2Dix^H<90H8pM1~?rI?58R-a2J=g?6U(C{;sPpCh=}XNNc(B1i8xj)`1R^N%*2M-9 zDZD745l;L}-Q`BNC-7)?TjK;6%k0@!OxHOI@D)=DBXb@0K!@=~mqEVY-QHv<-*&0s zClffOTYKb?W#33v&w zeQX4jFMhL)f_|Q8<1ItZdJbM~XWPmyjW``-zP)I2EpP`b5#1 zKcoXNxcxu)i#Wl{DLcl_9N+D4Ht>_N^$RWs<$$QBKCupOb(BU<97d^s3$JS&Dd_vV z`x^cK$Lv1Yd%rvX-Rj&wbGi6L=l+rB1@5!((WI@O|CL++G6(bfnEM|aHP>-zt4{ss zjX9osZl|OHR_p98I<7lv`rijT0)SoWoNdRLb&9TkT)&Nz(!SWQX|r;wA^=&K#i-As z2WQ#Kv*?G}rZs>=2xQ@@w?Y|$jCtzg;+T@ zseIKju=2#Dl~rB&7}r(rdNJ8W6Q8}(AVrD;C0Jo`$5DV|2<~Vt|6jxzC~zt&FfoPe zZ2T3$U~xv6=n<4$Ve6zcF35l{B(5Qx285u<0vB)c3*jh!)sDgUZG11Wvv6gWNft5Q z(F*z6bOiowm>=Pj`7<20*Qp($3$h_$2L$Fj!Vv-C4a6JpCmUv=_urOILpUG^PZ8lQ zHWIH8_vEBeyv6_5{Z($bi|?sOz+1Nbrwmai{-IxrDhP*gy(22fh#DHj?~ienfGQCb z=@Bmh8&&O+#k#1CHZ%u+AMPgKOqV));Ku*BRjS+Z-%LSWRma4uC>QPboT88!G z#Eu*V=L2g{dxpdQ%uV&tmWk(O8mn?+rV=V2a)}|vu=*ya2QK8r9MqWapcpr`y0{UQqeY0?{^RpUAY6LS-PFOi+oV5O592VxfedUa|PGb{%@hJB`^U)vm>s*JAn|bn# z6RG~sJVp1yD}BF{9Cj9>o#zbxfm5B|{(*smtiSryi)bilir<)F@t`1<6L6lZ32;D` zkg4c!_jNl8*V+kqz6~^bDN5~-!6-r8Eggr*z2oFB?{0@-PaE=+ZOCzqgS}AYc^#kh z6?ISv<2!uqr}^6Z`MbKVQWrR5qC}2yahMCbWf^{qYqZ}*_YT@!+~c}AXN0+BG0kFm={)D`iC>IAbI?K zR;@(!3hOp^y-BXla5_unt=v0!|L=AgtSSKJ9RWBp`7#0<(=?fu^8YwFYP{8Et=r4I zI0QyNjuVrNYnC~gy~nlxJpb%*t^iO<4q2V~yD>ccZ|2=e1{5g(^ik^^*Z(u$E%f0u zGBwR!nnov0Gr!YZYx;8r0irvmSc|Ez*a`TY`TucfCqHezf8={oxT8g0=(gxlA|N1R ziB6~o#-VzvRO~V;I>lk^#o?}g?W)DD?UTT($~_sjAA47_&B+MFNmd5&bc`d)cq2l( zK`$O|1BPG&8)zdBHo_(=9GIujNC7C%yMxQ{cFw%L+W6M%uB}#B6^~v-ERAl2DFPQT z@!-t)*HjyRTAm8WKkQm^g_oK1=sSOUBG02PUckGf@`M^44+Ru_clI9;=l>{%LydEk z1}S1R3J6W%{LJ}}U?@l0>D-L)xsgFeI^+Np6;kgT2k=2-2ClMk@7drYIKdRSp3X(Q z-O=!4q|Gumv*z z6|FnMTV>4A9gt_Nv5BK~Fl$m(`QS}<1~D8J=BT1dlPCCfrr9Q6X-q*O$*lx5tZi*s zf4i{&->?%futRW>!G_3hlp3NOf>4OfR!0VdPzWPk|4L$0f=U>LH?e~o2l2mXH;jW2 zod{JDIGKbT(V*ipGXp-wWFCxdiua};Zom&~JEaF`sknwYlFW!Adk*`K!yXjy5Rkx@^(9cwTb1_qs-N??OBOzAAZK5LFPI*24;;FV82A&I%8d8p2Ui` z#Joit<1hO4W;+V3b96NPZGsDz&?!qePXR7OpDpv8%MWl`;i`-#Ed3%KiskK{uV;+{ zgoxY*{s1EvY=*DOuznbSITPrlU^~?J9%YB*o6heuZ_#m&wNnSipkD6U;D6VM{*SsO z4<{+gCtsPMyy)zQLpjvxUP%8-Z2VR7Coo^ZX%}QS>h{rB(ZHwbw9ivL_v|kL`m`qD z6dSa)z4Y=dM~xH!&$oaxw6IM& zqVqSp_Mg-DJZn0~T&U^Q9QG;buaUhut~a-pc`y1deZ}GG{#RDSblCIJREvGwL9ca` z5?~J0eY1_@)1KLq4S?R_(mz$^@a(gy%4wRPgZ(-C*mS_74e;4c-|@UNM`jct9025^ z#Xe{um#r6PgRtoOx6wKO7v`yddJpIP1sq17O!5CI=5y+xBo&)vUrnkKfa^B5WW`+M z{*TVodeD=f=!&Gbha<36AkB3m)QP^#1;@C_c-0sHr#bYGU~XU`HoVgg0D~COsT##zJTt@90TNTG9tvWd4O=-lk=_DZHB{QAe5}A$ zDz7SLN#F$cSF<10WDD$9WkJT3TfRPxhQiB2oR1=8qj-kuZJ;{&sB3>mRyZgW9p#5i z=-B01pRS(wDtXhXxPTEZu%HD#Kk^eBedb{V<2S;*j9_3#R287|Ka^9E$txSWhn$V-N@ln92M{9{)kUryLXnt%zU;XTitp1SoRBb43b6_q{VC0mXkg;-Cn_ z2Yp@cA3Oqb1TJ)%;U+r**Em(6ih)ZqEfnp96$!u*QO|&&CYBR`LL7bV{YZkon&~F7 zFAAJFD%oN_MsYl%OXNcx3E&>%$kRA;UpXwf8>%R~>I*X8U-@IEa{?>yMxXvsf|aKy z2~-97u2gOOw{;4D&sF~)FPzotkA0PWg9BisTJ09b!#eSDQdcisoD^9%OO`Lo|zQ%pPndrRssZ zlenafA&ky~zcg`>(9U0S4wU)nB3IonCs+C$hH38cMo{;XT`d}|Y)a&Hqyvz*g^sHP zj!eqd9bgC_mk=vojqK24TTD;LB}9-pY&l?H_MLfuqq!M?{A>{f-mTKic79 z#@=HLJ=UzpUg{y&y_y}5?=-X-?bl0y2-q1qfT{lq!> zWq*$G2MAH+c(-SSAe@L>(m`0p@GU>Y(S?WG@XL|-s-29Bd<{7zIH*e)3H3=BDs=xf zV;)$aAXDNq!~eFCS2-TWWGKYGFdAnYgMs0XQcHpMR*a*#$>D#M?CqM)RGjW**pb0L z>n!kR??)NN?+ewB?DyFd(LIuJ^>I4;|IbmOZG7t2=h0og4F>+ni9>JnSd+!y@tSx3 ze@}z|(5DL=G8ee^{2$%?=i3JV;c(0|Pjl?!xfMsR-gm#;|FeybV3>@?> zGSc~`PyI(F*sraK*}XRYI{Bjy+hsHVZRe9ex+k4uT3V^GyyS%OvJ;m3ure?ua= z)e~MR1Cjp}P0cm0zF&NK=B3LBTKP|T5>#8*$|Ev= zA3!U-ip7FU+7E<-|rTYx)em?mhlf4Q?P#7bMUNF%koEAq|oDnwF$gK%zEPN$d4Mltu z5rDD{>xnkDJa>`JROGwGPuMBo8butMzz!%nfKn(9ZG`0*bR8u?AOcvZ|F!J^=(B8$ z02Th;hFX9@lvE)1Pw>fK;K98d0nm5eVkd=pC?1e&5aT+=&Hw^aTy+HEX20%rltIqK z=Nt_XC=kULKuKXnzT?!xh3P;AII-ktz!p~_a2hOgoifiAjD?Il=!@@83`sZvtk>vy zb_B*;Ldg88C&Sp*#tD4XQ2>nXI7)Y%dyI3B3ePzH*KFi8E@yH+@dDxz7-yX-k4qej z7%VFou?qLCGOjAhs>&v>Y)Q;WL;@IJ4F|TyGX@_3>s7sL zz$uvG1U|*OPb2Ts#Y_cE^POqNJdL5BzTPE+4{|g>l>-PlE#6$$S=#grqQ;i!Rsc{?*jM^`uq}t^k~r`AVX% z7oO^RYykr~H7&j-Pj3Qp^$s&(&_|NptB!~g6wB4M;&>Jz?x-_F0I z#QQJHQ+*Hl>dl!d_KiM0;^6n*YN}%We!EYY*V!mx9HNH-&!H5-;2F+kE3|#DL*5Ek zs{-Nfd@pziWH@!ImeGA?;spXgh|Dd?c|i9CSN`qB6UZ@mwSjgjJ!Czi5stuxbB+`g zolZaxE*)kkLGOLd;d>m6`~}GS(wa~D|8g2)%1*|~jzF-6(GP)V3UDN{|T?( zRtW%=!>6cE4|$D_ez({WVBUJzm>x3T;~9GwJ3@3;()~s$DGqKAhjZ~~yd+EL{zdH0 z;?A!BXZ{wBHShoJ2LCZH^Vp|(?7|%TeC~2b02WRC`%aTwJ-`tFoUShVFxqBw&kk$W zVSYQTMTfoHVQ+MhQ8n6%&_DaDjf}S6>nPf;S!z3rV>FB7HG8g!y4a7iPjK0;QgIdU zMeM`OzUp`8vn z8Fx6!fKmdbo}M2LFC|I&^9kt)@b%8X4Q{?tvJgF%%E8+?37OG zxGGsbpU!3Fl*F@C0L5NoZfk7tAP!Q502!=`Bvy2A<$#op!=)n@F`REWLOImfwBKGS8*x_rLN=jOIEpb7;)j}Dn< z&gNOi=)cZ>Tfm`P;Mo_LvxRTCOb}zdcuRr<7w@t&fWy_hB*XQ+fAIRJ|GwO>uNw)@ zbM`*xn(!a{#P|=N?on(#9LnCak|#cl2lKUfcjk`cJ_8%11)nghu24|unRQU>*}w(} zaHtYO49)E5no9QG;C%mij+7`8pehZW z?60=d_FA9r|J%_TbWZQDcDR_kXyyCgKG{$E^<{_o(ZkVQl4t7i>^;V`$Ua?Uzb>-Y zi!Jw`;83=BsM#pF_X4uGaAZcE=Kqv{)Op4{&vVYd$?Si>bQAy`KX;aK0K1$0Pvw6+ zSNGj^0MIdNpB)YW)FN`nZ3mhK*t;$tnn=Sapqn} z0M;G;*Is;{LA==B);FB{NB&wE^l4;&nzfkzaFT*e{oP1^l>?&Jr?}n}dS>d)nKD#Q zk*NDu1aa2U#4l#;e_#Qa$L4pEOD8JnbO^ygi)Lk8%K^A84N0`;MJbMdBkQl@6wU+( zTON})CUO@ZKuusuT)c?FDqtW+W^61`78}{{8x#dV0d3@DQuyCAXeDl_hBqo59Q}Lt z6sWK;l^?j2>*6F@sjuXTtAapPRMxlV`tQT?WTu|(6VFX5R@G{&X_3HPV;K5T)xpoZ z6i%nnLv2K5lv(KL()WifO)KA&C)qHxD6YcsiS!>qxJN#fJO(5CXKG`F%{g**b~990 z!vX?W#3PL!0mt~1&+`^BazzB9h|m?^YA4{`b_lqJ+9HP`Kh04CguVD)|C9rvTs?{- za`Z|kFwaF4Z}D_r=g|8(6>OFwYY|Zg<@P7j(Fs5w^C~c5U>g3KRK^7aupoy`VSd(A z?U*AfaD>OB$b=#eN(cPW^QB6J`$`je)?g1*q~Un~JOG$LXTQ!Vh9ElBD$17;`Z8_oROw-^V=$*fbRsW`*^s;Ebu=b@Yl5Z@{yiPT-zZlu?ik zsjN`Wfw(0e?bkNm4@yr7h=?(alEHttB=9XJ4w4+BbQ`-R5m0msWIs$i!KnboK7m|M z{3wB~P37uPlFd_`4%owlS16OI-P|mQYfMQI;HXTYyr%9pPrwPT6c9T2GS>;KB#>*g znAaA{s`W2B0Q(vffFm<=s-1xIw*)QeEJkv6qd|c$H*GL`qx~B@00$ZUjM7&llrE?4 zE^FT9`MUxFs=m77`f5c2*l+V(Z~jh{GS5BFXBHmk+HBrmU`&fgyFviNwz!m`-QGSn z(mMSiLs2=vbN86Po=U+`_+o(T@eCq^i4)@IY(SWcV2R`2y{()lKE-Hp)@pGvYsY&B z*a#JDgxCiGGQ-I9pYOB)#=ifH3~PrYz`74Gpndkv0OJ-!Hh;+zbWjyzeAEs%@B+st zSZ;{y2iL&colh?~-_8LjkoJ2yb-*)HJMA^yyfjvzcNBMeKA_UH9J z27BpK4)gD4=K%*aK#KzTp@)a79v^ZuWKN?qpThe!pXyn+D9vMC2JC?V@+k!)tc6PW z_4@Y#+k-eLpiutOYGp(IIqlnG_r|Qh(tskrR zPlOCfg=o?sMJS0BUll2(jHN-oNruuFNr)sv8PDGPJm>6vhCQD>?{l6<5)vtqNQR=M z5eX?YQE7O7?`y5g@cZNQI@3OTe?IrU?loTPS|4|M|E+24qdbHowzO^T^CI%I$a^p1 z{4HYG7P*hbNgMx{nfo6-KAtl155F7TZtx#6G~!uDy!VLp9isP#S33Itq%&9i|KMIn z|2)&+Z7Xy5&pL^F>GRqcr1g3`0LXstLYK)-N~0eWIX6z{IofNnon7=;_av9u*5Zu) z#solpJK)G|hc#Z{xnk_MQvb;9!j4)0U*N2?IiGFTv;Ect1h@X;bN_M!0FloY_uV2G z)daw%z{LEni5_ioPMgSh^E{UW)Om!CZ2Zz~^#TPV3k~F{v9=t5_htmC@v#D6DWy7h zu%n#Sx$_~eP>3?GTL%dO6peN`w~W}#IuzU!V&^p z!dRBroYLp)9B{9bGMLY^q2Jfhv@Qf?nXnFfuFSasZ?)mq&u{bh|7)ZF#D!vAcBmbK z&)c92Bq%_ka0M6mH8R*QPsd~OKQ`*D(K3X1*|s+7azZ!&fgez&U>%n#1Z>2SnnXY+ zF>Eof!45*qGZ0omB?*-vR1&$?@1qRIpR;TeMje?5QX-x$cnNki-e6B>2Tn9@U{{wR zcF!zKWDCBLB?D1N#}Fd~Hbxq&UGVwF2dE=M^08r-bCl63Z|+h7|6jf{L4y_cwQ{`M z1w|&rXKT`9<;QjkFv1m#%FLEYH$B61&maeyI5@*|&9aWO0=bG00wt$e6ft}(1jnAyHCw11Nes*#K zh#07TpF3WDXOIr^-CW1%yNm46qqLg8HaPGg&kVT2T>{Dme9Q=8_N~olFRaS-I`m}0Ccve$bc6<>dQ_dlPQt%2%|9-ycO zoZZ0jam0G&e|e|U=gDmLxuR=B5S^g zY%Hyv#(oh!w1`8zc($XyL8gJj30TXN!^rUxa5^^$;yDAyQXG_oTgHG1WRA5fbi>k)Ls7-qHFU3iBP_dj*C{>=O;qb;yrloVKxudd|`!_5Zp{WH`0 z;VkUw48rqVhFCQn1$`d~e~i|JtnY=dGkEV|NAc*DXoZ}%Q}Yqm@`b-BJEi}`HI*2R z6`Aon$!Yqr*XoEYr)V^Er25f0OPtHVV4P|PO^zG7Y6-bo+QyfFeGfa@|7~(d zETStGacUQ@HQ^7sXOVzxk#$_;`Nn@T`0paO{&BWO$inE`PW>Na2LRa`adw6en)e?$ z7^0_#8#?u0GuOq|$$;5s@A`jm{hu?^#{mnv-woaRC&&1++3znNjV_Kt7ss;8{dPH* zUG#0YZ2;hINy^pvq04XRv0(E=moNOsSREXKg?%&fUqFv6uy1Vwm^S*j%`>!dSlj4? zp!;3vY{2iF5twmy@KE#rb01C4dyD{9DPY!2qiX&8qsjHy!v<%ufkUM+<@JXJ0#pl_ z+Ot@g%Kb_9Bf^!SL_Id6Z$;#C3@SYMv<%xfa;&fF;U%1gB8Rzv5KdrhCO(-sfFcVq z$>ChKUPhTghx@H$j4N}^Z0|a(09Yb<;eqE6@>v#o1|gf_L1sCevzKI)CNy>o3u-3u zN;oGk&Q!0W!x%rikAY?fXQ@GiIf1;#Q;QOWkm?AZdg_yTDB}s{>9O}vH&Q*z#Q<*ldRq3 zL=Iw_MBpZG$ZSBYha87p?3Bo5FBWe@G*$Z-`gB;xp94MZF*QL`K8We4E2l}U|!smlSMN=!yL0^c-)Aj-VFMYaycguy{_GsLWe|9D^7 zt1|0RMoCm&Zw>*qcJ7_osmkdqlVwm20q-;O>I9k25FyU6o*Ml;^Q~+bon>EUk=NO? z+$Q*tvjDqg_G?aAFxGiat*ZQeP9#GA&Fp|CV+IaDT>==%d6ab!2jLu4QDQaZytca8 zE!7gpXVxAtD)%uLv z1l9h7;%#q~ilKd`@d4kk6QD?f^AW>@P{<3M>xFw#@x&Z*WItvLv@=49_P{SCC@{JL zL~4Sv=slQ`PcWbHKm7|#jf!CzAUgxrVSrH@vZh1zS`&c|Clh!zI@ZzHg-*wwYVsh? z;F!-CV<5)7{~~862D)(m7m?>h&i3L@UGJ6R-!1#SBWo~WN8pkK6)t|w(f+p_kNuheH;fg7!0q@y1GW?UbwAG1ME=@(wQ|FkF$3nau#iP0^2Dqul766 z>xCG>=sduwjcIwTNlZJu!Po-!THOe7skYzo-}K%>_j4~7A~%|$AkKq``f>K61y2qO z>$~Due-$WGd)y5@9r|U)gI-@|Km3P+;gyXjvVo@ws?8B+kWZcXmL$+>NC<{NjL4Cpd9<7M?8qU)XA+38p|a`sP2)-uCJXnd~*_RL(B>06Eb zRr^&90jQybG{b$KMV@VCEx4jKKfJcG0D!;A4ggKfn{xI+z5SY7AmbDSJRFEgelBsS zN(e-0vz%X0T00$p(rW%4n^RJm0|i~$HF*Ihzh#5Ir49ZoZEQJ&(H*dv9Rdzm)ZI7r z>)-4wfHDU-6HyX4(AVKM#2mCp=gSFDYvH^d1{|N5vZ#ojwU|85Uoi-i)5%&Gj)%Gm zdN$_zAB@Z-`#O27|3_U8-}SvJqwp%A)qNv-1CMVf?2fe~dzK1niV$fdC|m zQ{Y#=*gr80E<+(aNnRvuf`Ey0&H_AO5GZRt&0&~k?_$L9r?Le#D4TaSnDaCKnFBU` zr%MI@ml>oo@>#yyd;;qvsI!8iiWvg}1U}DrfVa3+6pwgjY@Uew6FjIXkh3VISq|^) z&>%r^39v^&B`m{#oxhGu9K<>Y@zfqJ16-AvDNPg%LLiJ=?N!FAU^HsTe{I220(tft zYg9+R>ic=nl^g&Zvijc)%K2i}>6*xYb3Y$s3{?xKwZ%Hc$WN4ei~DM!+*_QR7V8jW zLHD#Hfc&)YHWuJOw-;fA7kKss?xFKiBam@qI-fCN(1XSUoNhqiZss;uIe`1=aew`n zm|-$cea{Wx`vFeq;1*{CFhnB(vQUU4bjj#kg9G2|nk;fVe!ly*#Tmf8iqS11 zJQ-{plSS5U5yQC1`C5Etg1r`T5M$ne+P_$vMgD*BWmSz|h7^wd)5H$QI=R0o#tZGjOw=0Q5zW+Mvi+AVXx6b=B-7n2Jyo-yPIdAsmKj?j^j3or5CQTWk?u)iGyrke5F7e=A;=m#`DdPcfn&{jl`kT)QRKDL{SGuJLO>kljV}c9eeP>>+=P z7kbZ6^1dp~|88f9)KT(BQ~fIH$H5u%KV#157~M90n}_~f?@RJ_n!8d|p8A9P|CRbj zM-Elz=iUYjuKNq|k1_9awqqU!zwfiY{iCz|)x*K=u~sqh?_8gab?pEs+Gl@bL^t=* zMXz;t$=?5tGH>Xr&N4dy$ahTtQ}@m#cFxtx%b8hVf7%2Q?Vr2#kM(Nrn{9t${EPV@ z$YC2h)4JN70IXpP-KGIRt#xepRr@bEi>T;-Yh#PV2k?Ej1isaL0ME1oP6c%ag(^aBxZpNRjs}-sgz_`5t7%`cCb@gBF0zj5)+-q&#qk?Zuy6c#BNkmb9nSp`) zt}YLKeFFn061Cgh*j~I4zQ}6xA7=YH*)2fw{=eXEfv;zTpo~CF2`gtWaj*xX3>Gkk zF<9u1tUq=HPEv$|QS9KzbojikTA6siu7FPLTaWvXDT2s-uVF{vQFjQaHi{t~a1I6- zsR2f6fUFJ#w)!;JC1wj`{YUKY==uICOaOXggyS=2{l@Qg8<(QGM{VFwaI}ve(8R%r z_P%EWa7%Iv1lu5MxVV)KyBq-l4skxmtkt3jW7v~1x@U0>I}$rN6Yvpd1E!sEkU>%h zfzal!b8Q-36oZTkHeQ^^(7aT4`cX(1QEu(14Y=}M~pwl0L5fO zrRLX7had(YUAgk9@yEN{h(FhVS2h5rC&nMEjBung2I%UTaL7Gei1E4bT>me7`b4LK zCM!k{|2|Ir-{-nLYY-!L+2iFHy5;w{zAwjywOP*nN7seEZfhhzvJ)VbZ=!Fy=+*9aiT3ZVV@!=| z|Jbn3v@tgV{vi(w*u)t6qq;vfX<=_O{;{TQo~zw9`u~eA?Qw7IHC+ODi0c7I|I;S_ zVLw~1N-FW@Ep`IX2hGnKP|TV(xu2K?z}al9a62G--5@}$--ZJ)b9%N)&7qLzMP!0< ztsQCPG6$?GuoD|M%NuKQn~>X@Qy&02guV2~G?qo)w7{ZGu(=aQ@I5zHWD|-%%sBz- z7zmWQ((ovY@+Y0T$Do$+x`P}>Q5-iZx?x?jt0lYJJVH7DQx9R`!RPx49*hnJ4qin) z<#Gbppt91;DE#P6-`V$h%*q(!8<8-Fsl+pt_*;?pEOHo%LjSW7MU-rj*A;KgtVWTA zE%Di|~CVA$`-?|?Eh|3{=@$Y`_D4X}4{FQ-s>pL5;ma_zkzA+xls?kKvA?M0eVlbI>(+Ve;*|E_Onc`rpI<$046w zI6}=g8O+np6kkgKAPhunj|Bh37~$Ov4&N02Jv0iev!;v2b(NBO?pI=XY=px~xsN?)E@|p4PK7Ai&f9PJ!NK+F&V4 zWMF`980=(R08#jm*AH=`hB$mNcU_qQ^vaOu8=^Oc7@g54j0^Y)3Y^avpW{N-36zvDSah*!GIp!a*39Sk`Q=&;4NIa_d& z%LX^PB(Rsu0*Y91z?OLJ68E<>w>GEa}z9gbvp&Z5)^G%dEVd{AVQ33 zc^A7ZAi&+3b_|9tA>cHv_=Y2Of%9;@SNzjh0vU78QH(`at)Fun07UTBJvpneO}}5x3S?zFO2VX znqL>r%6MeJA7@c?zrp&)|Bcr%^8b8C{fGGL+spy*+r*_r3E<61|Ep2gQUCv7_Wj4y zzbj1l%X#U)&A>m-a*wmvLl?)SKmNbBWoF5u{=aClpO-k|=k*=#w}Wo$AXgp!r-S@- zu!SA&W#QXq{lm$PiGLfpt(X03pJU`dI-~tQbALQL!GEpax($%mwRp}L9j(u=o=wr3n_jfVW;mQJ1#Ph*btITFX@D zopH*Zg_~9{|EA^!*wYTcp4oaRI@fs)L6rrmVld}d0zg z<3OopE!x}=&Pg1Y(l;E<%V9xCi`--Jd+7iaZ{XsYiX5OKho|@x0~~P*N^D+fdDh)y z^fC85c~6!Wq7_mG8iyf9B46(syFm(AfBRV zWe!x!7l*)3{tOv#1ZfflFv(iQkRo+r=fyxzXx4hGti%Wd{IG-gb zj{j;r00$;oG%-3;0-v()L0!D()5;92ac~LXD8=l78?r-X`u~g-*v;Jo9Fj7Msocrd z&KNMnb1S1&IowzP?$lAO&T4H~D+Xms*aSo2aE||zvuZJ4G)SoRqm@=wgbSL)-X6Vp0S4FtD(GWI0!YAOASL=dy!iO zacFB8>N*Fy@eHTuh{821pn+^PU*ygJ-lxeLHBWa&;4Y(nr4%-I9q=>G4Dk0hvedrM z^~Eh6X`nC{_`C&-_`-5`2|VIfLC#$VXQ+!|>+bB7CXsjV8FmDSZeqyEdt4ge8T+p_ zSB(}=YkBd22=&oOc~{(kZY zj6a&0f)Pq?^lvNtH`oZsAgpv`$o-Fzt1+K7X069OZwx28I5PrcIU30BnDrW?aL0em z$TFy8)s83}!ZCINkh>*hBHGqe65wx3JKHHxdK)9ORI!1Rp_36*8eFOLJq(6ZG|YYk zd*MPx$x&w)f}S(Ig6Cg>K8zU%A9e}hfBmyc2&_p=JybUW>nk3DAmaJEBm7^xe4wlY zXJiGASd2)Pp;wEZ0Dj^#z|o8WJxbZ56JtKY*fss_T-FfaPc3_^uFQ5l&i9g90ENuI z&wxI3plF=qS-J1vZ1{px{(AP+T{6-C{@%6!S!Ynx;<>L8{^*mS@;xK#`it!C;@U0) zDPwcb(~LjHa=d8A5d9Qf|0ie4Up@b0BI+3WquM`fHA2=#{5|;pRc_kS4uCoU`Ua`0 zBVcti|Ed1}rlh*=^L%}DS^rqq{pI-Hk<{2x2E$qC{hzrqFr3}X+&Zh08BTxqS!VmY z(`f&)aW=?H2YKy0!>NB{b)o2t9P+-fh8+NP@Zh+%aTwbCP3)gx_*v7|FB0z)k^i|| z$WRc4A?K|P-2Z>PNr2Ax_vppuk?sOeml5*QxWR!1d)H9*5xrIaG7f-fPpj`Tb?L>) z6cp)4IRHP%ai*GzCM5JMho!>d(fC}YYt=rcns|xDD;{eM02?rYGMHfT3OA(#5Lo~o zeiGvv^>1!OBs0^`N<}YVUJQ}pvnwoKWsR)q3(Y;t>*wlbWLqaQ5rOQ+xX~(N!72)_i&mI0~M94rCzUdB)NyPWk^RISYyiSP_L-rMT_7z={zXyU*i8u_hdU_TsU4OITswnNeBRzh_V zO#5$FITLVuIu1cIe2@+Po1GcpeWz3+QQ2T~;|q>;M&JQw3e-iwI!_^g)5ziUFWn*V zKDQEzPXL2Z=HANR@+C|F%BF%rj8Vf^`$G9t?n#iKoW_c}O*o)4Z%n#jv0Vmt018}F zCDny8i@b{oGs*(U*&OdPcZ&gmtoJ+zxcb~|VXb0(s~of{O1ZXXmaD=MSlitJT-AT% z+>07=TO$IjAun~-u+Dnbd9OO}-C(~OtZ8HH-rakW+A~H7f5EjrwfwM;8X}|#U@i8l zb(odJ9d0AyJ{Hz>ixCdW!VxY7@R|korNjSr*yj$)r^8xxuFYts%bIpsi|(JYzq!YK z$AFWET?1vkdtXatG|ddq;FQ7Z?F6v*L-u;8^edk|+&HlT1NJZGu75s>SzI7^_&^gGT3>}YHNPU8~quhzBT7kG~y1Ppe}H^7-*;w*|} zC}th3?Fd>CF=sXg;#{400oC23zg|E?o@+UKuwny)@)S`&lvmW(+2^3y{kqEq0v7UF zE0B*BZG-yIu|da+GZe^t0sQuNNn#U6{Q5i`gyr{V`aakdag>6AQ3m`gS?3Q9hM(Gi zKVpNgG(MlTge)xGXa`_J;{)`Ja+c6ROUP{y{4Bb3f{|J}&Fdt`X?w3F22|V+i%Txq z@EMEh+;~Qob;ihaaQi<2@cWWe{pi6ldn2@ew3K4RHIh2`CcbM2Kr+JfkM>)c)BkXK zM(Ek$ZDs*H*zAALN+&h=EEN6!+u*;lng4LY`_FLdAKlZ#*^5!X2c#pc5?QqRafZ4) zUzhjj{MmrND_r+K+c=vY-GckTAIjc6Pb)5K&-8%=?0Ey4HE&O2OG$I1HD_9UB>~c z?}P&oY068@Q+~S@%RgOr+$Zakfd#lQQ=!4Whfx;SzWD1W@#;$g{c#`*cpVcg*aU{B zzzr6ZQb%zXi3m<%Q(G{$CnH8JSS}CnZ9>%)(bNKotaDRKaRFR8*&leM-w}UclTi z!CMs$K}?U6a_8R4D0Yo9p8jnz{7s7opkN2(jx>ZNJf6~NPW!WgMK-+H;9`M`9D<^p zgGv8|K#m9{x{k1f7=nazFuj=zuZRnD!=BA%os#h1PWCo zJ<1FOo1g%Ls^6p7mZ@{$FOH&5$t*#j{rR8L%}=8!p7rdaJWzIQZkEYmf(GQ2C zsICFlx4eOgg!V|;iB>|q+p?TN$>*83CNE84i&K zNzEK%{s6w8MV4pTJB<^bd#$qqrvAQm%yob;Z=-G_0q(vh`qAOBo5Y zHgv0CC8!WA?bp1f2Dt3}#(A$ZiK2>nh42n(8i?BY@}W zUgUNsoPr**7PA9xv(kLrEP?waKR|Q^NYSc9aE%A8DC&CDC~VI8kk20?7sCe(8Wc7F zc^#pDMttt*Kw}8>6@xQk{bSyM+PpZ|Bb3;PdmrOSj2=&1L3A9j|0Covc;MOd(MqR_ z(E;OEJ3Aml!sm_AedDhrR$z?$N5_G{hw3O$@43+E7(|f?MdXSMM(ZJKE53o~YnKxs zJ_269ggh*vH z_3K}rc!x0dtlbj#6l{&?i6ymY-tDZ1UeDQyR=;oi{}l17*Z-4tj@0(|hIF8U^htz1 zLjC{Q;6G(tHpvXk_yK2fRN_JQ$E;USNwfFC@vr@2Z^r5_;XFmZKf&q<9T6jcB`-4u zo^InVlxG?M_+v8wDhq|)8Va{^snh=l8w7}>-^ZTy&o|JO{f#ldyspQ(_1>Q{-$gga zlt0dRm)~i^X6Nw)(Z;A>MgHjD&c}Rl9%4f0s)@gek=`o99hI56HZs*-VayKtw9VeM zH_b9$i{A&;@7^x=$>_f}uVDYvnP;t=FU~Z7eEqQX0(P~@b2V{T8Y(SvZw;J?2KQY5 zxmii~4=mCu8F9#4P)dQr)aqoNq50peA&9rU#)E4Py2w%lnyL)4M_ax9s)?6)O^E|h z#G{ORR?ss|vM~(=EM%+gF{4+L^7{AgsHtaI;({=(-mc`Fz2BXMk7i%{B zU(I_jZIGpdK-=H@GzZ{`i`PWWU(xiE4XO;lQ79Xl_}7-fX7wrv}~5yh{y~mYau|R47o}e9ONit$SDwJ;6u(LoR!(0 z7&>%YM*2ZL{SRL_1<_5w0SeHd90YZlpu9C}Vv02nmOFZj1nXHT&^wLycC! zf4fcawCo6&U&HePI44zPyUKG{QNGo4lMkSJv#Eha4unir|D9QZDu=$xy4Kk98cuHQ zWVZ?O47JDIF8KL8s0|#428tp^cz(zReg_!j0kSiA z1D=0)dtwHL-$^AtB1#|aVn88EI2hlqbap_XFC3x~`w+v4Hg`Q(ScAv1gfQalj**!W zfr7we!BRM#8GtAW2t2r}QRoNQNL}WR0f7e9UZ@ttZ@8BI*Gy|KA(uf$gdtvHU6zWD zhObNmxqJ)b1$J?boU^}lZ>G$nZjM2SDR>`u=|DAlrT#fzF(&ziE)S@Dz?v_=+n_^q zc61}4^jEO&E8dgYgNXPqv(r)X`)`*~dl-72RlElg;p^-5j{cWi-dJ!NU+H^cA#hlN zHBrX?Vmmtezmt8*Q4l`jAV>V~_Sela@{jdHColfOjsW_25nUT2eO1y?wuUtwi1RWmy9)pZaKO19 zpx+1R)`5)uKi%5Ov-g{pXXL9d?8^-XzFg&$A8u+u7}Y8@S&e9TS6owoL3#6M1NIFU?Er^rMHG zZ%aepK)xHuw}t>k>mTdc;0!me$}E0k+TcGNf_mS^pLMPM8V8_>2iatUTSwRf!MoNF z5}}TzTp9@RO)Q>cX8<8CvN1)BYVmwK272B1-4clLn&dsB z?th65`!&9vF#eZ2q83k{<=_C3_D58|`hx|Se{GYJVm(dlvo;?YW z;jJ0Xmry9BFPoSM0V)a1h@(|HIYE{&x>y+*ITr}V!JRzP_y3@?6}smirc)4^3*Doz2f`<)gnO$x_!40_@T8|c?G6HU54_MF1ADtQP_3Rg4>5We zC#j6GDesx(sj{2{3}6|hQNdVMIII=!v$9#rSPU6bX5eedeNmC~`ABA;Dt~bcs@hUH zOtYu^TAn4apbx&#%z#Syzr^6b<4kCEM7F6`k(cVMGXu9~1|X(fVnnK=Y_W~3fSdr% zU=6veVfbtOt5RUfzif%W}9_uKj>D$1F}UhfJ(?tXB(FUP(U5lv4eu_B5z%cT=xtkpK)S(U(P5g zs8U%|jZ7V^=PbZid?C|=kDFnQwHzQ11D7yq8oZLk&cd_iKwdIX!D$_7HepYIX@ z?;CY;l^7;$Fk6{IU(Q*IVL2)Tyv}v@nUzmXJd{Cazm{XXgQ1W2&=}(AI>`LG?8kuw;&*JB;Q%MsuVE+N}XoZ;w(XxlmX zn!oBj4)*^bV*#L4$wb{0=(WWkxyz#A^+Ue|yC2R)F#Bm8IpZRQiuS&d%QWo!n6o}c z-ebs*N;^FBsBB{|XOA;I!hnz7VZ+b5kJz^%@~Sb_k@iQ=4Nr4t3bHqp9I|eMD=eQo zy8oYZ+UIqBIkjKPR@Y$u<4pCC$sYUAo7cthxduu3wq!E z6Bi_-A6TK)-Rj5pjo&%ym*GF#t;Mq8=-c|E)+z7HmgL&SH~_&dt{!5%iZ&nAMhUi5 zN0`Vy!p3^pzEnji&#`ec|4agw^6Kse;P<6F(qI-)Bol1<1PfkxWex-?$_Ty6j=+Wn z;USzt)GtF|r?yL_9s^-mz?d}n&jj)XInmpa?Qc%e822~BeN`}8W%Y>53E*=z{3p=l zESSa`$8m=E;7@kM|Aic5T>MbBF-F${2BfG`!I_B#5F6m+YL1wP zb_Bla)ILf&QvX-j5l|GZEC&MdLS=S zvjyQC)O@cid@cCd9?L91bULWB;ret6!U1?zW&$SvX@_RB+}D^xpi+VWgz6|zi=prV zD4@U!=(X3{8Mxe;0^t$VC4gZHGNC7cf_!ES7ZPS<`($*K!>24jjD7xjI;3S}tBfO4 z=6z$t@Q)H48j}TAal0S}qM}w)4rAs0b^>@GO^B>ql=B8=`q>>29Ri$zS>$T=G_z7- zeCD5*C8-!3Bt!muPX)x_RdFt=tZ9`4T|GD*=P>wk0@$BwAv;;B$Vl}ME(r)Es0_fa z?h?>pY%3Q~cWt@=?pWRt$Ou(5|eoBq9CcOilB31pA`-rJ& z*BcPX-VJuP(cd9ctdSvLonn{}@;yMd2i(tqXm9X+I|Kr0Va$iD$B^e3{3SC6Vr^6V z){wJ1IXP-#Rx?Ix{R5!2fs?=wxssN2ki`~B~C4clTMcl z6t|BfWEolZB>LoKgfTKfL?mp$YFU>LBA$~B(!=3e-t|Q^84QJsPV@gYO9pZZma9vF z&kAB5)-ihdd49F_g(EWK==>#iT4dl4wNtRCFJ&~o}?@pU-UXmsx-ouW6xMTj-e<=cJ|dzMTCT*YvSR&6j4RAMJg@2O%?!Ta5DW8t}K| z^5J3T7}+2*igkgG`CT2Sy7qS*fM5!{D*J_1i)j5m(+drZbOSHDete>t#dfB)s9B+` zm7ZtOH62bV@Mx*yFcrAriKDm`l18^DkUq!KgVXy?#s`sq!OPND6HT}P;F)?>*-b9Prh*)BLU=MlrM^> zc!yK`9I7H4Rs5gKSQHVCB8#a>hQ$Ny41Chg!9~dxPK4Vq{K^()Vomm1!xtJaD6P<{XRKu*004jhNkl73at!#a>8?SF{ z(1bzAV2l?2o;w6qw-d0w%L1=XplQ$wbLcDcb^`up_CVxh=C;f{&7u%zOP(2UtO0=R z*ZlUT24=tK@w%%h*eY^4kKDyL>s6B4IywYUSXC5kmG`Y4ZRY?b9OHw96Znm12pr}y z!aRGOXQ(5Cb&Pl&#aG8UY9QYYlvV>dXz)HUMCe7y^c4!>Q&|d7TTp8klLv7xt$#Ta zAV&Z>ZX*{OA|xPEfCHc42^eLUfLfMCG4nAXsHr`{veZ=@-3{eap z!axjPnT|pL3SZ;eE>YQV=xzh0dC^V73yuE%kN^I#4aH`eK91JIP3;8mo?~QcjBXmg z)ffSkb#xY}9<5eF^pMDCl&)Uf-WRV4@*>tW<{GFpATS|DW0Cb=WKW}`06h~k4!&SR zs*ZzyICCIldx8z{XZ@OQ-@m(j{6X8^}8div47LFTij z)BU$O`d42*I!QprMdVZzykWfMv^ku@Sil^uC^98)r1$V~1gHKg(uL>(3>4 zGANnva(0Au3xX!}?IQOb?VT#Ih>zhY|Lqu;T(lQ_{`dzj1MHjFjR16V?<4kibc6wZ zM;R9)2jIoIw}B=3s~rH&{IFtK*vZ%HUHeBz4X|MY-fM73%3{?2FEkIp@n-&eNjkRC z@p3K~j(iXO)%}r;znp;`^K1nA|8_HLzQy(a-a(t8lR#~-kLmqT76Sb~P1)>RM^>>)O(khDala%Pii^ z0p@CdvFV6sjrd1U$^vx>5stT8W`UH^h)jT-o9{a7P_?6gatlm>zAyP%uJg0b_?hG|O!#;D-#hXW z5z#UfNpKyYWTN{4*)U+*Z=o3H^BEi90+G(p7ozcInT4^^N%K1#XLqd#tNUAl)+W@xXSugU+AwW&MJqo z`f`^Elo{Xv*O1>@H-}xt%z%?j8_Zd%^SSl;%mPG7;O{O4Am2?n1;|QsJx2y_a-_if zHiafeS+y?BmLdU+qD2r{YIDvPP&hF;@O|vjM8EoXpObG3*TsmMK z1~?D{&b=lO4mdjl^n>`^BdyEXA0S%;)?_HuH|sn+$c{kA_yPeAk@uKUu-rz4&lD|j z7#ejW{KKF^?n}J#WA0^)oW|^e(;b~6mqA8!voiw94s7L&0QzF_OO9|0&J19jqH|zP z8`bq}Amu3Bqffj4wXQUqtORfCdto#o%Q)nW`iR8!*j&cze64Mv*tr(r8px4WMNQnX=)F50HCvC z@?XIWmpo(dK0CJTYmf8MV=cRURt)^%jC5IljnwYk@4o*loHcuejX&$Sz#7J|A3keg zeYg9m^o9(#`KfdQW2K?@wl0zy(i;S>?}0?N9G zU{4A_c*@hFU>S=Gvk!cFF%`2|0cSsID%KBrNYIXEd;66c-gaAZVw|tyxmW7D z^zDp}Rm%_Kf1=a;D9IuUx5xq&pX-bNDZV{38O8nW09<1u%E6!9*v3%zyyR$kxecL= zJ+BJ{zM^In#^iB!1W<%g5~w;`@LgXBZlM3SarCb)0099%=M2D2>0GI%Um6=^iMJj6 z1iv)65``s(!ifCYCyif@s9$9P4tWXhuk;~11V6WvzKbZ2B-P?&-0qxl+PBK4rNY+K~SmVVLLQ(1W-~>(jv6+HLKFWp+Y=s{E%lUeRQ`JIwHYo17E{s%Vp>tqOCY9OgRvR^QZ& zfjj3AA!PvSI4=$ErGc~9XgUS>pucDB8*&c*V}!6u0$ZCg@RrQ(X{2bIvl^p>k)H(| z+n7d%a*6o?4R;0z;f#~jQAPkI*2sd?dm4O2a1st6QIO{{s;1HROAuzn(2t5|#ig6sGSNsH{$XUxElHoaHp8Plg zhMHzL-p3ArG6$UdCkcrju|bm|Hbu}d;Rx6`+KGTpPR;CjD9gbSuJ`zS4>%) zwgaHlJ#xQ15zspJLL}7gftea+5MEl>D-2w0nga1Zu0X#i905k?W>i(Z|?>|9e zZxfUMT;bmTPni8r{r{{{@cgruo#(jbf2l8lZLxW6Y+g+4yw)YSv$71Z@cb;pMOKbr zB6$9JZ%qPi{@zjlaar$gqKg}Ub>07J1N*+@G(UQ)v7^)cZ?)0qoYv6;bzWcpYql5H zW!rJq>-=Axy{T^|2Y?&Wm{7GLG*Nc-KP6&0hVzK~Ah;1?Jg(3N% zBYc7W5V8q8oC%E91j=gy#X7+U7k1AKKoO%{WJ61e&Jm``=h`^jkN~nN0ln}R%O@ou zOD%_UQm)gfQ0G{f+2cGf0HZoHmrjY=y2JsXtb{0v6*WgR%qEmjAVn6wcvw0qMFg_Q z!WWcAN2rS&rXm|zM9~&is@TR^fpgN(MtxntKLPh%W5aizod89@D2wP2IN8|&8N;vm zHD7U7Kp6tP$M^GD!%*Ju)c-zCi9gYYe^h=S07e9=#AX#a^u>E@_*wTNQFw8jnSdB# zbiPXfXZn7Hvp^x0K4K?eFJ}pq(O@k~S2zoxJ>VcrZj_EjbP1@uA>09nS{wqA{m?!k zV1W}rSx&yi&Vhb+pr5^B=RsW$Dto9zGH{kaWdRIVkQM2BCFJKKu*8C$(exj?U>$d zrpjj}q1N2vrU^d5+!gnv(GO?(p`2+ERfh9_j{Xq`~VN$2;|>6d?E0==kTqxgVI%XyWj-wlW?-bw}Q}{dq?s7@+pQlaXv; z3zq<-m{`LFqQ?#qMa(cq0e3Dm*s182K{*5Oc1sk-skcFzF`AtyOEM@$cb8 z_5Nd~HFQRwb?PSX6ra6dU`JqvV1Oq@rTs3kV8gF2P+-8QB2Q zZRIHaeB%O?x@Y|ZOR!|4{%ad{oQ!DGQyZRo@2_&YUl|7B3RLqy+bR3cx`vPO3IO9T zeP0-jpyEB&1|5SO^?PJK>h;1n+_5s-BhR*zP<+ae$CSPU>;&P|M|nif5Nj7{|IHlb zf5({=IX#@M@!!0D9XnV>V=~_9atwPKToB3t9A>PCB7LF!S?3|=YlwXaZV7=%56^V} z00(w}o*A%q1N6~=b33TJ#Ke8ZNNdR@I;oGr?w{oh)vHq;d)#La8SL@9-b+pXBYEfd zT|TS3PxAeDRVrf-I|mv3x26fUE;ixM!AZsy?S9yzHhM9}cc0~-ANE(Z`KfG&QyA0z zwl~Sot!~SIweQwL*;bx9bmbVJRU*YfNHzjyb$Z{F4h;9}6%J7TO2LadA!Xockz=0^>RTut} zSCM-yq6CW1acO|V7lc6f8+6w)4q!bSzawn;|CrAa5%Uucz?WA(RXf*Lq3+v`oCT=6 zE~Dev??Oh>TD?KdE3T29AbbV zk$dUYb_RCx?`NG&s5?6%qm1ANHh?`2t^;)i%sa9d*zn=JCYAAF4JUWAvmmEISrOq2 zl=-;G#$HZ<$|4-dNuDV{g(?f&=f4R&d8ZwqOokFz@@rU<^+WI@NcWORbRvUcUanLUu7D_0u) z_famC{0xr63{L0_@;$>E&2q43k=0p@$Q-gahm$zRYhrZpbb@2&*tFZ0wu z)?i-f|JD6<)%?Et5rY7)$!>sP2jsnL`u;zO0}w$_O&lD5$irIaz}GPXF+d2#9n69I zuFT0^0{QG@Wzf(1U}ON0hvv`B8pfH_6v6h(OgeJ5+XJu8G^Em$kqzMNEu7{yL1b;= zzorc4Svy2Oo&Pm&fWGIwyU%wtq!z&y1_^Fx>eRCg6np|reWh!w{9mtaXMyMH<2?0I z%Kg1vgMF(3S!&5bR{M7*xUjEOKgw{x?+56V!BIwW3wQ8m{|(t2+>9?n1JSRV{+C>z7b2g}4ZxvZBVZr;Bzp7pci|Cal-bi5nT(-|@&$W1R=R&j8}IWR z&41--_owUydT^1oi+K&gO5B%Gd_1SJARF7Ud5@p_8JQ)C=M~q&jgInv=!^gXOb`Io zZ19oe@qWf*$jMUM=L6n{_u242;yORFJS^A&V9%nXMD>35C-^5uzPRVXyi@<2J5B!^ zpce+~8=vwUXQK|x+JB$(*}KIVtv&4kJlh07+-H|P>+(5WWTNxqER%JP%`O_1&P1@a z@KvM!dC!HH*#WrZX+8gwS%Pch^t5-&Zk-_fL7rOdRci;={<)9f_ZPNj6KDGP%!aao zd}d>Jr~L&CW)EY;IGnMXRj?&1^`31uwB+3)LK;MjpjM{ zbMN-#w3n}pDQo2&t$gwLrZHyI0(q$>%ng@#jmUHgL}U{j=m{2XLhXPUi3yZ=fvBh` zP#%j{no0w`3`H57?>yY}!A5tp(d8>0{UhviY}_2iXO6=&%f`igcZ}f-8(!gm$~F7VABgX=D?x?O17Z(z%`r^kOOdB0sv!1 z!0wKiAIP#o7)%szr1c+9Lmr^Gk2pg9oTKDZe90kDnLz0KuRB7%)3yIS?Esu@5Zvcn z5@2mb@vC7Uery3t1!%T!W$-0Q6q4c;Tei?r`ZOW#gWJ?&P(tqtJ5H*$lo+X9J)$J6i9TdR~ z@MGCO%b7UO*?}eh?i_!wC|^7R=eYbK2LPoJq(TA$US$UWCuRy|GlerTg^W(&XilNH zHIQohrEU#WCg4Pa0xwBGX@CPSM>bY9KY(x|r#TBC?(0 zKFfeWp1X=7tF2+SK;)n{#46-fWZ16oFU*G z26@nOrwu!aB36rUOc1-zfWYS&3!pk=-HyOzMkjNx3(qz-fb+G$XLqFRgm}j3igCg` zYX^nWVIMmft`6(d;q%3Z9ssH3sWdeG2GG zWU%*;GX*&6eYI(EhGRB63b`*37i%-v*J<4K3_KLb@P0c0DiNsb00(ct8b#aJpPU9p zwujF*eqe8R6xBDwHHxdYNZ6nfg(ndI%A|Hw#^@E%hc&9M~ ztpAw%7-Lw+7drC2&$aH6%Lvs3yagccV@|;<-LCrijZUxQ@QOHRX$?o~yhrd3uy;!@ zTA8SPA@S9tuXen*IJJM8jlZ0Mj~KM~&NTcYFN!+9()#Dvkn3L2hhyYytiQ3pF;(hg+pF3N^+Ku__nAvcTGbT9q z!O|!POU@BzI;KUg;r72D8vVbkqyAfL{8_`{$L-kh4C?V$StthmDB{Q14#qb8pEH(Z zH_MN}fB#6wGD=S>0dO9I|Nk*(0OSC$p1qw+0CcYF|Hx!_wakEZ_?*s}J`bD`QEO}B z<^u8@wA(7Jt?u+c&Q_cA*zUO{_qZ&@MbE!d|Hqo+pM7hwS54u1u5<=~-!-wj(eJM; z06Mj?M;iUc#@QlVNB--qRsCCBr#af^?A6g@^?iKF_@g&#I4Lz`q_(5F03JzY&{Slx z$S>DTWb+&kG5h-*lp^GPnawP-nH3gMlh?{3ZNUQ<5U%*2G^!JSa|eK;e-6^bSy}%t za#KOUi!u>9T?q0ilwFyKyTSuh*p$ldS(~k(7-puj<~qM>rdns!vW4(eP=J+A-b0zq znC3w=Sx`>I)Q>WKEHGNsyWf%qFz9||{9kP#B8Rwu5iT^dZ84mH`E>6*2fl-n+>Cmk^E;5o!qoTH^2(5uWH2U>#!8 zp+JNGvNI#62&G#>kW0c!uwNyNROzP7a+G-P5{fFi4p_U=cl`Y9W9c%#mWaNjd%WEa z#HP*+{GXkk6P+zkd*Q)$jt=toM|xdk;Mw=+5Wqmh;34q_pbVC^T@JXz41oxH%o6yh zsey?mVwxcGF^%GgvBDp7H_4~W6Tp22E94)I3E(}-$7iWXBvLA81s^~;34t`~IywRV z>M51NmvB!r$mGn;$lxYPOFfHx%_3{FEA0Sqi09s52Y|oLH9SR-dz|Oc&GRhtct}WX4s<$_^W1)el~T*?ft;TOjKl)}w}2k# zsNWgo5#xk0+?}^O3&4JNcDE8lKD+3JE}z%M>Fx4)UA0qj?s_;my*09)+Ivxg2!mCS zv)Mbvz1EkTc%^C*7C8dXHg;f5X9FH}=YVhqDAhg&s*gk0|BFimUodEJ!pi>|r-Bs? zB2&Rih)fUEAs~(co^g1UI|lg7AS8N0_LPq{G5Q=OJQ9fTXKqIuXKFf(mC6VAWVv9Z zl=fDcx(+&HjKi2S9}^E}?I3)}&I0!mT?FrSCO~L;f#(+N3@GycUOEAb+*1rJQrqF( z3BZe1zSrBhzr>{jWekMY7kXdFeIfV-21NIXy>OAeU)}W+b0%X@(>K$Z2s+=dr?V43E1Pn;GXcN0@ju2H z6dC--(yn0*KK^-O+KW)BOe4`nks;_d9%*k^Yi{yPW!;a<=GD1OHSm zVqFHTM~nbg=I9caojz>z|E+HQL(ld&J3)gj@ZYovu?UVj1YMn*-2Nv=82!^>eHV0Y zer5-N_gmm|7Sz|z8U^Jq&R-k5(dL}Axu5n{#^xX&F~|!Y-$FiGIHS#<*a1)$j|ji{ zjJzTPa55K;TAlT*Bj0tE4*CB&>r_9&B}1IFx{&|eZ~cYNEZ*wzUNl0A_e-&1{bdj6*d$<6$d`vOeI}LxH&DG+dg%F0}zF5}f*= z%Mvfjs4|Qb3mb!eWGK0xB0^sHQ`Y?p59Ex3!Z&>Jy26iL7LWsg_f^C*4w_(oA0Rpz zLR-wlrXd9UcG&|302MeZRu46d%u@kalD+wY+a42QRbCtcdY zWr7!^^A;I_WyS~`?duR{3Diz_p34VAI|XtAzGWN%#xObwUhB2l-Oj+ueDEQt8$zvrue1YjpdA37XKJ~*0d6;E#OrMQ1rR(W zxg<1OVp`oKzfVG`G6zzltjjYd3SzG-9NdbqEj(A{G6PFF@H3lxNYKaJ6`&FU%4rq_ zG5gj8rp|I`XK}D*dG;71tWp5-H}|V71I!^W^K07yK%rGJ3Yr)g%z@iF18|)QfiPfI zWTtwu>4drO>YqI?0B5Q;^Z~}u)UI|};C-&=A*XfTvrZ(@c!O~PlcodZ-di|?F-BNj zJ~*Z=6i^Ho;r-eu{`Pt~J0LOxyE!Ak&kL_}8dIP^bqstnm0Rbz$rYfff}QmY7~I%S z!HJm(=%R4C7@C-uetEJ7cE4<=V9sPhXSt(5HCN=Ox4X**7|Gr-CK}>7dMNUkLMUVZ zDjR!#?sr`-K&JYft^Q9lvWwP2br9@lyg=E80EanRz>xF7*%>9qtOA~Sc#@5ZG6Kyk z4Fv0;j63TPBr~Vk_zRH6y$1~~=VgRL8U#Z!Qgc}z7!g^H6!Cw`b!}bfhv+O&>)|u~ zv%qu$*S*2@bVb_lcM4rN0c3WO&yCT!$VSxbf8ufh>mMlm$DAejy}wuKfb|p)LEs8_ zj-}^j<{%sZMfIGKXun(CMp*{D=W+&mBqk?r=+r(z$>K{K+3P*j#wc9GbvE1=*yy8U zVtS(heaoHwsQ7Q+^(AMaZHEY12o^@pSnx2sI02aA`46stWo53gvxUJL?df(ub#x%( z!y}yb=PU(Bgs>ev>pW0L>0aQ2(R@~~D--lM@eX|U&ws$2Ws;mBWxe_&+4Kz=-1 zO!CEXtKsO@_T^c)*}@eOQk?0_;T zZ?`kRvjpRyvMWtHL|54fxF|CNQASub%LtP%UzyzlDD2=H5MJOlc8X4P20+fxMb4sN zjDvz$ZJ{W+WyoNV1aZ$X9O)IF5r6&!+A*Ku`cxWO15oxPL#G1_T%rhvw*;PC&h~Ll3F-6{I z+hz#-e6|S2w7~CkasP9infVhl{U7rJkmD-PQeDkl0Ow>2U;qNYV2*$TO%`;MhX`>d zYUd_HV3Y&6$Dj))@~QJ4^^=VY;PV>DZ!mvdojl+{4urCbK|wn>x+t4v>_$f)N3vUa8^bu!4k-NF6>}u;5}{^yxy%&w;D8fx!VT0rw;PpVQ)IfaF-}EW(n~AU7oGW z{&wGE=YYtyi(GVhhVGaAnupz5s4@V~WDln$<_!oZ@Gh4Ue&W)=7MZf`p#%E+8!(8Y z8e}f&G7#c>&6PQy;3HQ4oSo<>V10vw0K+<1bcR4ZZdG-CH{HR_z@nzKG06cL91ihU)15uXKiB(j|m{IMuJ~E|(T?2^PVwo7a0oxo>KJpK9$zjy^J}7(f+8&{WgC+#n1IoXFBS>x>2ZJNA3D4)NQYaJj!b%3bNlfZO{o{90( zI6%W^8W?)DGeFAroa)GbUmJdcvjO)S)YN<0S>*o*JZE266qT$Vbv8;4!1f7n?Xvz) z^8P=b#5O}>v9=Zm~Glm+~=TZ0AgJIiT*WV4Q})o=!DI5#z3U;Bas3G882!H9s# z+-LP%fdE&_dPVyKnJR3mw~z(UIAGBQDk>2QKjr}ZF@bmGFC{UHqFANdMXOt2VJ8s6 z3EuAl4)g?vyPz~S8z^#}0*X%HIz^i@kW%)V3|AJ$faqg(N3Lqpu4?FtdaUR0N@oQK zTt71o(>%!ZE3@B!`em;9vq=Fun3tF2EFdyp3CImAtXkVSWb94>V$@Oi~UZQPqS z_{v)F8G#u%!P$aS?9g27%mC{Uz`~!W@sH0@Jzt=~7up%nSBzZgl`bnBoLQW35abAO zz@w`GXCr`zatf}=EJ^84#s{c-U~S_DgeiEJO9aY_2p}lu5up~na^NA<68K4%0FaxY z2bPS`lx~c=ez(~KS@SCLUq$iMUTkt8&PnYQI{+8wY>v8md-=Z@ z>>=+T$2Rx@cx~e+>CDG$@b9}5fcs1`3Xh75IT$q2vVM#C85=zH|&^hdu24G=CS0Qx3!3CK-B#+p4DR z2yixfyiW{ZLFPok+T)CLA2e=&&+grAu-0{n8we62^h(gU@;ouuUH#qYDs=}4?LClz z*vW?A&6x%cXW&CN2q@FxY6&6>!@{}-pF9RMrWS5vprFbFoDGrCjGp5%!N&giaCZ+N zmob+1u`CA!&j9iqjCP8+pJ&5)qN8Ay6NEGPzSHHuOd}iySW&lH>GpSt0G$;*`!e=t z+VFqeX?@k})mb2v{)Ed2=Q)+nGX-w}x?>UNDC+Xp*$F{^2mk(O9kC0okIY1?;{(38 zmLq=lJ$m(Z@9gc9WsRe4^w0C}S*!7z>;MU8z}k$@_JtuHBPU~J7Ff#wSFY|7z%pl9 z*vk>;F%tz!(5zptO#0trE%Vro&I=PW6B)C4 zm(cb}XS$6ZZ2!jKTlS&FeYeopE##!d+PCBs?3C&MnDobMo9OhI_kn}cU>}(h!F9Z&>ia#3k2je;I)|r})vu3oT&9SSL#BT8BAYpZ;7&XP2jD_G0W4MlK`*e7 z1%yET^#KChD?wk=Ur)-`nYSd}?+l85=CVw)&LOaK+|R7QS{Qsyd7IwOq(QqUh)`6s z(Tb;bw9Rdl)Xv9e2j{>eNjwzBp3N(;AO#Lbfz2u0>d3$4*Ze1+Avyqv8e%{Y0#p21 zrpkkLPmwUc6F4rI_4c-5}v&@a+G= z(LVxLS`^uUGo2aupq&5?LlI*b9Rruz z0k|ul>j_*&{ER@BPz)vZO3aBR3{0>f;uMwkbSXsq0%|KnVV92bC1>C>xvw$jfwc@g z!Ogi&(LM1$E3<5($X{Fn>Y(^eW<0|2*(LWf=#W3{`agzc8HOxIBmc_;Q7QrOSusJ9 zXP)}1F#)%kCtyQ^0zYA{009A&Wm%%FD705UhZ^a{aGyEw48&;E*JnsvvtB zOcfIYRSr180MuV3CS|tkNr61$EcZ9ZUeB@DbBDM);N&a^%=5nUIJNT}=y~pCp0iTr zjLai%8n9JmZK}vpmFKH&mhFO76hak+Q9H=90&s3>M;Z@sxxs)D8)FtDNs*WKf>W0I-Tp=`qgZ09 zAi80J*NHuJ;Y>RL>}iZTm15*`I^0L+VqfRGJiy+^i~*%jughpE<_y%FW@U}L=VZ;b zx1Jq=ja-9O`2Z!{L(%py?lF#-XY1XR3Ofc9p@{p)XMaC~21V|IocGab{o51yJy03p zzX>1|jvx@>stYeSK0xW?OWi`K*1=yH8^HRF)=Hq@@G*A~+~t-+E{&dzKK0MKM6icT z26HYSAiJZsvjalFzsuKwHi|N^=Q~AywVeVY`SG8fj#mf49yaXkOQ7@xAl!Lnvh3|( zM?l~{)_(C*uJfzC4+A1<;{f5U%rt*Q@mD+g$6<<+#IBCcFZOHIw|}W4dt@M{@(J{) zy8S->Sy%_wFQzS??5JLUQ<;Es7h{=K@(^Bva~bGjP>MMhZwx*{YN)xy5!&|-nXk9`G3iE|I?l7-_Lju584 z&RMhVoK54sV*Iawwiw|S2EBEaBY)Pk#j~|o;}++=`3Ix_Pj?I8vscD|pQb>6{J#c+ zMSCA-w$5J0fFIVXjxMeJ-d#jrH>miSjQneFO0JRWzp~B0%2}#@0tX;aj-Sd0)8TFN zu&rlgi$VRFsf^~?;8_mZ%=KBPFRR^Zhm6h?1()_s!&Fe)AMbMkhW`Q%^#l(-!DdVx znI!_T@CgGT5Zn|CGL51yb1*9x8ssO1Tem}iVwx2S8-q|$bjJ{~bsD9L7S)06?`TqKpc^NaG(4z()Q*)z|;e5%qU6RbE0- zlu(?}#`r87^y8iW$Kwr5z@d(CKWxWfKW7I75In&dfXkc(xYSYb(S_ za0J9xP<*zt82|Rq80g~5odr+^;8Z&-pU(9S5+juec3t_@Y=cw%o+=Y?;G<;lu(1GZ z+A)yvUd6_LOm?%sAh>`i_yX=3B1PX&20@B z2Qyo_gOij^gG)-T0$l}oWr0RM$vUy_b$JSfkXPrzILxN_3)z0 z1V<$iOYaq2A9jg=HHn$+i*7MwKl_~F9?#IIB_H5uUY!an?3f6pueQIP)7S?(U-!;= z6Rts%`eL}!c7Dz4)9^<+UnP%Q(!dAh@+y9Q;UqYhBi4U(k-sjt;a5flnU8i%o;3#l z?4ExM=L_RH+{j=*k^6A2Vz|#a&gPux+P{pxx);rv@#$|V~B|-ly8GfxVor&MtA^u>Viy#2{r7zA_8(D8F z1IPQsxLoax$wsHNRv(T(?ebk*i$Z$h#zwBWH*$w8u*V*vvYCHYU`KYtLA`eq= zP*aBywy4H_)^;(|=(=_QxX&v4TK%{kfM7a$Sw27;0c;9sxM|i7s%z%_^Jv4v)2yiV z3Zd7S)@4GFE1i6Qrlg~;{$c|GIm8#R;1}>-6MXQ*_cG0{8naU6Qt;Dk;xr3W{$c{N zA|?AZBe8#wWIsXuixQb$&Gla%bP55OQsj7%jf5g?3_(e_1H9&_dvj2V>l@{-=pVqv|!U{Y|2=p#T&dLCwJc|!FB9^n$urX7+8wY(7;};wNO7Rz* z0r-fs0m@Lk(~g0h1w7ZF1(wlQ8=<-b)E?N&Y=OXbMFh0S0Vv3kd5(?0G8un&rvgT! z@Dn=%!UQN=ATZxc{mh#?lkrw(5Y#n*gBSG10u~BS@Ks0rDtX-J&y-W}eU}A(lFuAW zgBv;h|K7wUs5LRJ{hSrp+ob^xSqY_4;=M{2+xRbcHejVQCa<+qq>>26F{T}^G$3+^ zr#S$}7!0^%ECA0xrTte1XfJmJ;3#R1L^uK*tf^b<1iZjJ0h_xspx`z^UOSB;5q)rZ z2e$>@XR6>E-GQ>2GXcm!MYt3Gx6(2|@J}WS!U38=24?QEBXG1qfZW^MOLJ&dFa<6* z4uHcr_p|&uzozF1U})x%+xZ*J51_~&B^)D#w=-R^5W5?2p~P$NvIEe{vRs{ru>M}R z1M(Sl_NjppZXkn=bCW2f`6??Bj9>F=GmG8m-r~D`aaNiSxl;gT*kWHq7Sy`hG3hEmpfXoK5kZ=OXtwyAZGhG1W4st0r z(x6vWi`7<%v<^oAXQ9i!b$7EOMptyvCtVa`?{#(rPIQ~$(QY+V?UsG(AFUOmO0lEC$AfR)JFd{x1tG*h8zuv$cMb= z5QQ9^0`E0$V2w0bBSpfz_XwjDsCMpSbh*F3GjRi=zLnvOet5MN&N)RdbpG{@+R?KD z<3;a1G8f2ul?-^6#pk$OuvvaT{!ga*7uT`z$5;hVfdG0V8}uj26RfE~cVjseFLwG~ z*@-7o{)hVha6n?L@^@^oS-(K*-spnfAEFuskJhkA-#t6 zj?un~`2WZK{*T(Bk|Utf3+H*n{l>J&lUxQM5DF&9mW}_BHtgtz0RhqAcxM8p?byvb zOQ7%fG7kXv(Ps@~Rt2Bme@kLb#01#A)mf=iQ!bK(wf~LM;f+if_rI`- zjsMqtu~uzi?Kn$qW#QP%7WWV=oybOueQP~4f%xjii>ZI?VNCWzN5o*C3lrR{4uEL; z6;|&SbAzZom}d-zKXnQr`?X7*LF7!;USy-M`ace175z|U4XgXB1i%e;2ieakw4%}y zq7xM>nLtVNn|KP};n}VyrnRYqGh!3#U9`!m4eb?n0$z|j02knyT)^U8fTuHoBAbwb zStFxP@#>52c8Ud=-Za5|m2FJMBG4aRYX!qm`AUMdrn&j)U5xbRp{7~%DHPQdn-$}K zugM5Icm`z1znq3K91=MmRj2-iRXD`PU%*8aghm!e2H+p*Fhm!CqGy2#XP+{Pks9AC z4O$p;ggW~BM_I=X!;X*#Inr@XdA~Eu9TE8+Vn?C2GBFE_&K3wbD8Sw2Ho9B6Em0i{ zL;!_{-MR3X%NFcUfqN?a%?^uN9XYtszPNK{48l3s*4Y4M2ad?S2^K_^4GLK@2zp@| zd!8i#gmQSk?u%$Emr;H1h}Ul z4iblgzJjG$0 z`hhzG1Q2~JoklTB25Hc{xz2VL04J|}VrH_+SD7aG!sMWc%m4}r01%iIz01D67>b2)(hp5y)JFbZ?L-yCZ@$9m7*c(~eP_|X%w0cD{1*&Ej69bjXLxI&W;xR2yJ-$@~0Hr84Gdmy-NQ2L9aAuk~piK-| zQ)RvHTETG7&2MvE>og<(FV?ZvOPvjPvoi#%yIjEDx7g1Xilfc@x4-CK=6fC4==V1| zwOLKPfb_`1)>ei>LSuA-8BJJ$YwZ+>e}sJsQlV=S7oZlx4zkd>(fEK@+A-MB8Gwqr z3B)si+{aKN&QLZUa3;x%}3T)#D zQiyZ@7GsG|aL@Vf2B00`D0E+6icC?yL)LRBW5|68GY|u6ew<%}zaH5hAx|;U4q1G1 zzWsO807qoZc@KU8rRAqx9vItzBTIp{|GAC7z=S+wAnxyQWPh_G_v@X;*Xs+;Fns=L zMqS1nxf`MXgBqFj8vQyW`!L|jKCG3_Nr3Y>f8*yk`bU074QD%Kyj8CkSWi9sd}gpI z>gTikH-Y%RX=g`H&rSZ^Cu;ocMWp@T?{!m#1SFpvM~Adkppw;SZlvKiu{Iy|QdyW36jv8$i5c@{CmP zcio?}S6ycO(YxdTAk>;^yg;PfW}%xHvj)aQ6UychjM+zXKDtt)Wul*Hl!ZpM#$5M~ zfomL?Qa6oeVZ-DCxB#Vd0f+m7vrGsil>M0og+1=JFDY*xMpN8G$vPuuHiWCPu94fj zI6J^0FLQ{?+-q4NFAmD|i;M;MM)uDK_y0zj%GSie;)`u8$Bz6FLQN+uuvmpJ`}fxy z2>1&d)b(sQ-(v@Wg^yOc-#cB-CI0 z1Jzj>h1^(0ESe21I3$MI#}0P z5tR%!bT;5*J77m=CgaIYf$!(ugz?953n1W$&W5N2a%ajzOcg}dmLagqP`1my;!*&S z#48PBO10YMJ*BDV%|u%|xZuiQfn4H72c3IhZ=BvS$q{@ox!WdX)1Kfw-&;wiH~ z26PzIxf=a9v@ zwVV+U9)LBSyTMri6z9Bvt_Ru?;GXAy>&^gm-^{oZ;0Nis*NA><@9gWP1lW3=%0 z*&)>8UfSDQk*QPQRAU9oHvDJ!=c+RTk7jm2(NJIoICl%2y9NG#foG4o12-8jaICL} zTdOX2H^DVlx)`JwM)VeE1B3_osmlQH*Y zVAbsVj#k2f4S}!%|8P24sb-v?m?`l3G&BJYloOy@H2Nt>h1Sb-bVQ}x`|uma2K>hO z0O1L)O9S>KkWl3S)wWqLO(%?&!fTx_zt>T?>gdNiBk*>o=7qLb&7Ri>anChQ<)7h9 zz(r2oALrK!*^m4MHv#vmVMmdQ-y*-pX9}MnAS3%6Ly{ETj~$`^#s>VOj?nA=y~-V( zjMjrE;R`nMeLu^2e&2JQ0pR{dU1vSe3o+nF7w2d6Ij@DBCY4Hr4Zw&+8Gv9$z5l{q zjI`F+oFD>1#}AR6pa9<4H~@5FkUss?KtF-}aC)KxKn@@>(f?x_{XqRoE;u*A1c)x} zpPSKtkWmR}x@Wcl_SQE65PL78tH=Nd@XBX)c-{_c6C40jM*E-Vvv91-X6&B^akZ3b zyU=)>J=4LCbI4w4`ff0H>O6ARG~TO;KKC%s2cOemZT=rqXC7yJJ^%5t zB_vv8&5|gJL?uPhiim_zmdLNPsgzXOH{Ch2oPC=!b7tnu%$+Ah`$6zqlbok>2|NX}p00OTz_tEA$ZN9(F zbF`4j7H6u(v$fEDEp%3EceMekjY0jsjXdNd2;VSDwZ)e=5$rmKp>}3c?g~9!=1XG& z8_J@rR=z_sjXQW}8U`6KQ33Z2@nYfn_-r47SvVyPm7>Eipz4Q55tmSi=J=+0w}@354s%iS!V*+{~!+Hvx7g#Qc<)A?&%E4H`0L$5+$vNYW)KI zv1UaSUXcS-JTHN!fd`PIhw%-{=x4esK=OxjE1`@_+qpC#PKdi~{IB)TKV_z=%mFK3 zl$`-;BMp3jWa{be6yW|U&$1KnW;+E}@xq|RSYZxRwO}WJb5djfYJW`tYm5yRE&xZQ z&gbjgdmZPh{_AA2jQIiI X6V*Q%}*q&#u0F+ScJ&yc`-5SV!wv>%SfwkXZ2S9Z_ zBCPg3S?`P4-WdGh`^*f6{B^EK+R&H|$a;?KVr7G38bQWJ4m7$Lc^u*WBjN#BVMWB* z9XXsA`=*IxqpZj1hqGO&%eA`bi|)3m*t$3%U7jn3nV?XDP>A)9ai=KhF0$3V%fLb5 z1zvCLfE)wPM-ZkU@8c+c4N@8BdNEjqXBua1#=mYQdz%s1+|vYSbmITqT8QjSpj3l` zSbw|4oCEB6ungji_mt9=ac6BNS-+U`{$mrqsI8E7ooqM-%=%2qh;3!%V zHHtfU1r&YroI=P)M&M0$2m}~B){X(P9y|kz=1+E7|4WYa*^d~eBjo)jvQ{6Xb!Yv$ z*Qt8p5I9>akG50NbyngC8}@V3G0j&iS8A zfc}mC43vM--*uKhiwv%OhwtIFYlD?BjQ>M+q<-u5L(VnTF|q(ZbQy;89ITGd^u7oa zFm1#?dUA?2h?YO}LyV~A?8X3~;Vk`3b_^EX+JI92)?*!eZ%qetg3nBF@4^575(5DB zLhi;{Be7$S@jYVB>>@jw>ZeG*i;Tx8Ze`dmbob3Gv*b1+ME?~&Z^-co`!{m5U)b9b z&QeVKtGVx=wF$m|&X+j%A5v{;~Z@1BZznuUK zmcW0-mu0;>2IPDouPfF;VGqLCk2+%^tb#fhShIe-<$i=EfQ)huIC%XP|83bB0yz&4 z`cy-$*$S>K@Qn!BBMWhDLdyy2%qkjF>$m1br4AhgXwk7^Q z${vbEaP*o~a9!5B`))f1822tlrHhW}B0s@;rn11bStf{)sE@jAz`c&~EMv&Z*mU9p zqJNt29(yp+)PWV?KE^9L3Ln_z7w4m0Nf>o9?0pZJBl2MA1pg%IW2 z`<`(DDC8bzt9M~4`+b@K<)8CZ!? zoO!3zx9KGzO_G6B`KS?-V{P_n^4%2@%W{=aC$ zuj~lAJ+Kq##%cC07#dlNnEE&163caYKhvD)0AjKy(|qqV#yQ48KarK;>;*NjQ2#|| z1NeQgN8+RggCx&5sZ!Eo?*IS2yGuToTojU@iJ#g5K>tsmZ^k*l;|EzbUv9ZQGs|8v z?T_EZSl?@G^wD*re9!3mHu~(rNXyt9?kPt69^|?|@(`oE*LBMOO$qqxe8KI#&$ZF# z48@=y&et$HdKh_a4;uB)I<>KNZSJqlJ+;vf?RS}P8Gq!arE$O_{}|icZGf9* zO0Xk_vGenS0woFA9E$F0M>;3xzpKY3x>_VHF@f*bStnM{eSw?qL!kQjvc3~M8{j_~ zr3!Q=#JC82N-RcsApu$?7Dq#dioeSKZuN6le(Clsfdh+)))u|1N&sSx6a8-R)qg1? zb#V@e^FLDQGL%G2{dj8q803Byvmb@kj{x*@t>6T>^(h=cq|IdvIV1xoJ3?0Ux}j0- zkJ*SR`sV-zjV%YZ_^(8%#{iqd9o24cgTHIm_`@N1_|+;Ro1kM z3{^2WHJ+n(qIm*PjI~?b&Wh5k2{`+T>}089Y-5x#%CEseZJ=bEa<19a<}q#)WUX48 zxD()o?gn75TaRZJAlNyP?>5gE%z(GM8{nDF0-S1PzMY&opY8C~QaVtOJEJ2?mb{TWk+X*;kws3~vm39<#ZPn<1W2Zqid*o&% zhB9yno7mWX)z>`8PROoyNDfNFAF~l2up{#;J1mFz{tieZEw)5W=Ua(!3*e(1nG*Fi^WwC_q~Qgol|IQo}k#eN0nKhGQtjmypgAO|rCkTVw@ z8gjZ$^m|US<0WSdJv6P9KRSGhAYw}8pS#T$fjm#XDlsBGbV%_3BcCw>7-v=#))VNY ziHe=g&Fp|G^55J2{_N-2QHgcw{>K1Wwajkev_I#3^rMNf8R2_I`0f$T`AFA>UQWTw z4A^~U2H%~Z_&oAF9b`kZKH?nXfDI!nM6f0Cc@9#&b3M_CRi`DmOvjZYfLaGnSD4uF$H=C|0Z&KRD6&clw8n;B$ zRYp)MEKY^*jp=PdW@BV382d6FochDV@%TxC(gL*imQ3dd0I+5U;AlGlZ?hA?=lfM} zpK+Ps=V=@RMX%PmPuuv(0l3Z4t&BQ9V+^iZ{#b`#uftO>J;PC`N(3CjAp|X0@ZM+# z0A-`z_sAC1Y{b+lfWc6UoYLoNJB&#FaF;4LX#FY)prraatoI*6=@;V{5=|Bz&dk_Re zEBtR^2Ns+`_+LE0+g&c)Y>dXkrVD4uKBN5XBcUT*vhGQMo38D5#_F(8YnH36V zK;)*#vuiS9k;tZ~&JotN*yk+3<#rJE&a6vOnWK%J5%{3_0xq!ezc#Y~CHAt!8jHlL zjG>Ad0?2Ne$fC@?1cmTQ^9SIpY5HYk39d?+tKh^`+2<;Ux5|E0dA1tYseQ_zKn`c^ z4tKC{KXpD+XRYeDxl4dE(qNq%I8{v?$>u(855!q&qO4n7t3@=~&*>-a%_Ldhh4qCTzmM{ZVUWq@&ZI>01ksFf`cDm+^s|pBuP+5PCn}ylf-s3e*p5` zxyk*;IM*XPx=esk9l4a(pN&}NIY!&=7U1{6Va~mc^1Y+ziqZQr0t&}~`|l!SU7V0E z`_VnpKXG`v80jv`R19fjoPn|TxlHgrI|QszFb`hi^1x2!5g4-~W}n7~vwe9&(LQoF zfsTrCty0?T-^6c|%tf;Yq|}34XczMfY~uf8oMQd}>o|#FoJ4kFJhAG<2O2bn3%2>;K>Kzh#iOx8tFbzU>iFP=%tkx`gO9es}cw65E%qH z9dAkFzLGs(iTpoF@bi0TNyNLL=XsiqyNtg;h-#-iBFiV!d{1;<$lzDgvC{kHOhxy= zc6m?Jf42i69LI*n32g5y0RNxd*d-zHN+35q3}cTqpLop1f2F%nI0xgux6HBsnu9UM zevj3%tQA?UmP=xC1~BZSIH#k7wyj)u^ttZB;XIG5c1BL^_J2ssPDK14{hu`dW=Zwi zd5zETItKl!-+##9KjeRy_qU}N&^c`!tTsVaoAquZ=k0ABI4HPaty-*q3%%YtFggI% zZM_i(Ah^T#N$-CIWjXq(L;)*Bs4o%eNb54ECs7zJ1gMFJU&rgH2|$H%D&xr(mC{#N z0AHd(Ix;eay<7s|f%>?1VI&QmfMG*;C8c+}p3hAccd%jDAv+Aj{VpRPlL9%+6_i5d zW?l~&2&h&uwUH^x{GQSOYTet&weYKK9A!{ZLj8FC{X*F9>~g?`PO&58QAbB{2{;&p zJ9{}DPNWgj^px8ErX2va_MyOr9!MizWK)W~uXtV7u7d$kK)@~6=H$FLtPKj_;wz1A zKhCM`cc>Ma_ zAfTW+3BK=4$CB4X83NVtIV1u86BuwuKl6v|00}pMvI(*w{hsxX7D90i$XPkk&VU?% zpE?8Zw8Ve}gP^(wcn)zI1X~~mI4FWQa|T6OfH$v=E{G`O{KA+J9M2e*#9=EEeHSm>#U3iol89VnGxwm0xnPSp=HD-Zy|x4C10H7Q|4O6+xz2g&$jG)oUBm{k~-GLdju zxDz>*7@Zg{#UU*(XUkxjLtEwtYDIoaHX-(mlY+@y%`}m12|QhvKEx9td%C1j-O~Embq-nicWzYjM%=&rdQi zViy4lS(l(4R`&opriUE$xW^umuK3`CM2Pb|#XU`JVqCzsb^>;>V}M*u4Z5XF8G*VH z=Ct0{FC@4Au2NYez*6!!vBq^*kG-gE4*Y|2)sD zGwKh-|KrX&$Pu{7r4l(S%7lnBK-mr9EiPF5)C`CF{Cp};sKekN+1?m@181eZqaP$xZ{&uqiukR{WVL8;Q-X4_dhcL0vzvx1JJ%WQG*&P z66oO@jR-y?mBuh1Y_nLyD0dAMXsyk$rW%P_Q#3BX-ey^YRePISzXk-XBho0~#r6ph z$QSnUw*n6pod7J*(61BFrJ*kZfQej3wPW?n7pn;lEbWwFzcL56jFGKy=&EdNg~Khj zx6+H#P^hjP^?#I1^vui9sgBN}?nemwxzB!-SwEg;KiBO4u#GF%>qiL%BOnW?p+N(i zIupQi4q<|vF&gD7ryvZzTHe(1__(tH3z_Z@L-sm< z?%4^3(|{cT>f*kSv%~U!X8}HH!;cc}f2A`RatJ=_k^l;_9|ub;i_zZrMLRo(+xgKt zOxdxJ1F&GnheI4CkAocf@1B{Hc<$}&6vzQU;RWH4e(vis!9jKa&PhivfPs2(y%#U;+(W` z4B99((F3)_;wH84hp;_wgae9vZGvGZ=10XR1uIS#)! zeqci@tZ`nvcLW2kNoAw!n7HIqHvEcogd@TT#+(6kM3?XGq8qyGeRp%?2Hxfp!ESa0 zE-+Y70II*brBGP`@sc3tPYxo&K#pU;#y{cL`R){u1AyTc-LM9=OrU5d*vpB}notNQ zDFzVnT@zn4qPw0-zK287!&#m9m+=A>;{i~ZF(?Kl8-s^dIV13#tRqJY*?Y5>JW2)X zN8c&Y=FxhlzI4`W>ie03)|9$wrPOzGNkHl9Ct3*m);j?S{{*KG+1iaDj*~L+_YUn@l{m3y;Qbmk^RHYCg?M2?fa#p{r@;>-_RKXA^%lY5dXp- z?I0ZC>;2oj1n)|RB{CDA_A{u>5&aZQhS!-eiD#KzCtDr`JPgML2WUzi9>|P_15JJ@ z!J**y?yscjOmU)nmOw;;0_&UAKx4d_ED^dSs=EJFXA z(|8PC;uN|fj`>!bYFh~6;=YArW{w?eP>|;Zz`nu}r0tyPe_=xM}GIl7r!5xfl*ZuPRG1x{% z>x_(AV|=e7dW=jF!3%zXjnbJJVuOcX;P(pcKcBdPp+6_kEess@pkX>9<_UDa?ujU_ zA19-KKS%rTbJju*41(9cqa7G!2o7{s03*|nagH(vN~Zt4{){pMN7!jN#?SjfI|LY! z0j?Qc0cz`8-?)GeI}@;rf3MOChA1eBg%LO`vp56F^r&U2X0%9hz@k&)FLn^c6`+m_4tq>d+%_>JMT}3h zqh6ZMWMBgLT#0=sz02hQWdbBm$c+XF#qgl@%@=@jDYGBt-JJ=L10Y~3auU-8cTS+I zfPs}mvnwUq1n*t@)JWm^93E8tuYX>a*)f#@>KxEIMyJmH)={qY`<(^YD@y?lp0A0c z*<`(&dzm`;yvzs$K@iuEIRVH*3rD6^NCzOw0qk>de4|9#7`fp8{-Ln}tWU6nNntEG zoygf3R>^?-k5R%X*I{H!GR0WA=cqAz;@B(=mvlLyG>8#Tfl6P#|Z1 z5@k7wgD_b$U~Gla<9t4b#~_DOtj8qZIeEL=$?h`KAc4@-HU<$QD^tHTI-Rwcl5s~L z1<8==+=|GFUIWB7?ew>z-z#k>@5uDG3}SQ;$O!X2F{1!ETFJdW$&|O3oq@w0{lCbs z_d2@Y($`b%+_m%|+WDw64$rVrmvR2KQ}5S1iWhG|!w!a=k!PiWj?Bc4j{Hw{7C>1A zfeqCH_zF7>O53ZZ{|7q(;sId&0`1RxR+mDw204AA)K$@wh#^sZ0thzXt}2&eS# zt=xLLzFSdMdg7VJdCqZUYm7*IY$<`P-3MLPV!dP1<{{?RczSlx1eo^7H2hJD(|LNn zk^a0lTKr^R?{!x0R-aSOKyd!6oQGTtpYAh@d<@Se_D3zjQU6zG5Ni>vf2>dYX$c?} zmq?5nAF>X4p0kVGYinH`fW}VA^{p*vh3f)#&aJV zP({f?)gR@kSUvUv$8GF%w^H*gWN_c(VZ}5%wEzn6s6Kw2jF{x7bT;peo^}EMUhenl z--p}ymlFdJh7B)N2=}1F-8QoeF->v6MqLrVa1882|LYw6Z<*PP0)kNZr~igP_rJ=H z!5i%~yvj}v_t3ws--BW=s2sy#?cc~wgg}va?|~7}^#l%l$Qh81qkpvwu9ptgz{~x& z<8Azv0T4z4r4Zc#m#IN8sSKNfLy73}WD8j)KZHGVC1kq334yCfF3k z4?qMFBbI0EFbN~^1U7(3r1*SiPhODOf#UAQ0idvp9sd;2lEWk3fD-Z;w80#Z(l`B+ zsJr}pcam_87$>~3@c^8I^4`fEpua2g6b{1MvK$aJ!n>QB;-97xe!E)(k&)`Po+zmH zz|A~9n{}?g#ian`wEmEX2XXxdim7o_f&zm*kmqfx#D?N(emgU5QF`M$Vo;Er0oJ`m z1kmEX+8eq{KpsDaBnAc*vllpq1>wL9bFE0xz~hpcEy>FIK251c= zI52PltosDtGtPI9;|#_8_8%vJa030HAw$vYEubJW-@}pA_~FU-xlQa)mjw8($*-9w zfaje==}scUlYHOgq{)TGohd+%P5#YJz}f%Pj#hT}z#Rsq30=>=Ii`M$sisGiOH zqP~r+253;xIQk|4adS@1qpw6T6e;vKIt{<2GXlG((T)s)>fyWE3E0CC{S%!EE9@YA zWNnlkBKF@aGckjli1JvNh-e`^!eyGnv&|*A(f{mSkp3K>Ao|fqjsEAEMjlJt%m`~LQm&4iaP&>*JI=CkuN~Q4^mg?0 zv(Cd0I2-Vg9re$+tk=Ib$A5F(=={O%3=0s)<&0BB))T-3@YxWFA5Al_W5*AW%l*JHV_{c}oGf}NUEM-k@s(yBkNUa^3 zsA$zmONx3`&t9F;cY&MfQ#SxN+sAtgciY&ijqFqTQjL0GD;p04G&uHo?~st)Y*6tZ z*%nyB%hRlP@c>j%_8RS4J}&FMB9IyUQAVIjXZK(4H1~yRH2V=6%_)fJ_(P7I53=!B zmOwlK!U6DnY99u2Y)!6kqY#*n0cJ5!)N z+SM;*2;^`HbD=H*oVDl-z^NHjs-Ht2!;|*%`Vm;mIF%@qzHsAnfV$>#xvJLh?Igcm!g>z9t83dK|OgaIjd(9E> zj|8Cx)8yN-oE5kfl@snXhXBuBmi#?nt^kxl<+>ya5}j~$Q)2@7o@&hlh1jPWGEqYz z)_B%B@=)K!gh3@(4w=csIB4aM)W!B&|~7 z1KR5u_=9sA^q-u~HqRJy16KRR^9&m_K5!}^3Ipf19hvAyjjToV5FTyz=Mt(Z1 zOXoD#D(^^)z{uvVWnS#`CPrBVVrq4g;){*}&eteLbM$zZ2Dsl*&Uy?$5kTrOzf>x~ z$amjoM?km$oWCxHv&)&*1hp~ld+aQ?4F1Hef=bJ7ZzteHzfN+RmU|r+iW|i`v91-k z+6Xz*F{N-f*LUx7>h~cN2@xgrmW&WbH%#InO+L+}LHZrnnB*FhoSm2+ha61eU``%m zf+5x^=F6*GfRUI&Z^nFqL)<|?1RZk*8X1MgyaD7bItbW|&Th;+ zP{x3L4|YIh5;*fSU-xVSbinM{raxwnXINJaABxYjPP44Z9Pe4+bBoC40`fl3e$68D zv#jSV`#6geJ)>v6JToWLKgzX?R?ijL9njk|Ge(g~Dw~g@-<=qLm8d5u+qDu~Z z;dKT9qL}(Ht_2QxfkRXHhmCF{)6xR&iE3Biu;STS`xnALjQ^fa$MzeT#e-G2c0~y7 zo3pkn10cgOSkBsg7&T=9*r0y?U0_oR>I^_p_v69!^F4tJ*wZO-rOMSZ$YBy{UZ0Pe z_}2^o#2EsF-87uw5 zSpa0K%)cvqR|Vr-L77*O-^%4lkX8A;!GQ<3RqzL94E&Tc0UYicj#i!D)rmmrtaD?R zoU*C0*Nr954tUt}0#IhnlRZF)^=XHlPry-t2r&#DjCY5*Nj4&tMT$O7zvn3J4=`mP-WRF<45VWA?O*P6=Wmo~z5+cKPn^j7tL-+X+Cw zjPcnqaS9M+jXh$%0PcVM&_re{H5-Z=xsG8iw`Z3?bPwR1X_!km1yb~UZi4UET!EM} zh~em=FM2ndDUkJ_Bx>s+qcL0vS(`*R#?(RfH|T|N-Y54le}MYR`%E$;@SobxIF}ka zG{xBoI$CuPAP-Z=8aTMdErhRiX+Y^|zAp%egbCQj23yX-9?lkg#7==;=)@oz>a%f2 z;YVHmpHAZo0WTn*YW^#IEp;lqC(8hl-d7f39UDZ>R@C#ANf3Jf2U$m-<=JOh|5?^- zhI`Yjf|d8D5uZVxW))%IoKd!F@3RCEnjjd=gQvPoaiWdyP#X3b9Jv{EFmQF$9S-H^=wR>fh+BpgKnX&s3iJ{yCmu9ywg#-;11sMQqUgJ^cO;nH8Ah zIc8bc8EneTDmy2fS9MH8*5m8R@t{r+&6^k(;1tIpW>v`GvuEQ3J>zNx;K9a;>5Ms*Cx8X$=Wv? zp;K@G`jeKly}7{#I^e4F@#YvJ^5eta`Q+;ATXsc#Q=0pJxE?#t*r+R%vF20oMZW?=vXuq)0aN?WPfh}PJ|%6g_|WpOGz zNEI)pit?&pluHP@`ta2!E|MJ$r5R8L0OJ_7Zq?DBpAmC`>&9r}Eu9{Jvz-6|0!6IT zbN1jDu8kk(dbXZP#$Gr8^|B8+!CI@m85BDg43r_^gcd3lC-)ApZS$Iy7PA|Liqo%?tl_27p6YK)?$q zw!)POzAW7Ol;aT2!jX>dw@e2t*bsl7`xeHZH3&?^GuA#ik09m_yv(3L9HAJQjNk=f z5PLOnU1kA94is4coUE82_!egZFam?>6hU6pGCHU(3%wV^ID`Ti+T5j+_c#k6Cx8PJ z1CwyZqGeDW1;S+fG1okB0UWrX4?f#~OtoD8zz*blodx)$odA`qI4Chmkb_aWD$7@z z9;j$vL#{M+vcv%^;n2jWVL1Ria~VStq*cgF1?5#iAyrE55Rg;w7ZU|>o~qZlEFgd& z3ciM%*M4HIfZdZNFc<=l&bHb{!$X63fAcja3fj|TK^Vj)GS~c;+XY`|2LQQk4Y*5( z&$b?Lo8a~?32d7npqM9s(u-LF-*wl(=FSKx{rHl^4YVJ#V}K$bM!81I5whCZ+R;kK z5sZ43xlgf%j&SB|( zDid&yG-zgua~K1L&}&niw_q4#U!LTtN5-brR>z*jXxqP}A&NQmV|EVSVCP^L8*jZ> z#{j`$Af|E1r-gJEu#jgB907W8y64P+TILACrrFOREK=FwgIR6}z@6&z-*b84F{kzK zPa_}3pYNZ&EDiDOZ8?T`<{?M^?CUIhIg5>$Wj|+;r&*lHS?VXb0d@%PKZ3sD58%`RBaEL{1Fy2*2xaE;=}Fox^;d z)bfXJ=)A%yf1X(^yut0S)c)1h zx-a!Yi|1&ucjEPFa;@f4WEj_3w}C-v9-H8Ss2A!65P%K~*Wu8P?Bsq$jL+~6SzBmI zVXeqPC^gkTdHBlK8DR<77jTHM> z!PjScKR|Bkbys%-PE?@VZ*ycThCp=~{2?(0A{&bK#kV_ce}CR@;ST@*b{lv(2g{D` zf5z*!oUGZAVGj2Cfmzi29xI8Y+kU z(Z*lS$6vfA!boh9SdM{1GfNWF2K%%06STqHbMOMl3BcG5?q&yo_YGpi2T^Wn4GfB4 zl?_l@gLvoa6bSqT2P=q^P^y6o5SD_-CkU8OvP0K6^CG^0jolr9;wf_dA_gNSM9ML| z!7YIwHyCgWcLpH0C9V@}fjA?j36}{DGH!s+2aDja9fALtKxiwI2w_AkFZFzigX|C> z`;`Yx5_EO~WUDCRDiKSSy{O@c)R3nd>s;R+=u?Z7{MGvjb4}tvR;|>cAsABL8SV-G^Uz0ro3~gN$TaF$_L?(B?Dk zMJo>}k?$EqxS8<*Qc4)a4$mHRr02SJi7W?^3HK6I!|d@0I%MPo0|b9+&YF*J>Bvp#T-I)!`yOw*o{Rix*1KB2dMN)M1~VoJ>gPpn5fn$j>cj?wLx8^P z9pt|u$Gv;aCb+wu06sU_T^nPE!}y~sV))D+?i|>`|3(K)3GM%!1P4xWUsKn)o$wf! z3}!PU5R}B|)hW*D)SvUE-^IKFf%kB*r`g--A!h;<^^e&2W9Whm2R*9EdDGm_G?C}@ zm;GL42ZS*YvL0O$Tm$zejqohGaTd9nBY>IX^K-1j9D6p)duP$zv*@)s&g|UV^EJ!g zXRpaV@CH7^B&n)tNi(GSw>n!qo3phvfI9c=T z(;PB2%bw5fo23L1Gfk=c1II$crUFay@ysxd-DtEw@*G307R*nvkMSy;y)OIS#lVl= z;PyZEcl2cro{_K4gV|9N4gjC;oXP7Lx8y3b{#b%=qrGq5*|#HYi!tWI+uIS?(q({^ zF7xr-YSWK4K=f*x?`pFa(E|9KbpBg7$-)0W;VvQt4KL17(c&*Mic_1Ij8K#SPz-&Gj$(xt z=a2@Nj>9C-pIYpKJAOD*>_xR};T4zojJVpXyuXGJ)%MO-tE$?th#X>i8%9PWU`x+S zgCNd*rJiFJfFk#!kR}b`bcSSQZC(*60{uKVr_T{^=|L z*AL>L)9e6TpRyQp10)|@v!p2hBU!2{v3?@3DxtVa>{ql8zRH;a4qzsE zqr@6qtASE(uwM=KtMOA~0$%0L02FeQHEaIXErJ-AU=8HETkK&AM=6*CkMjR7GKy)5h@$3ef|dLge1tDE;zT>~$mPiI5*0nVyI=b{V!GHZf;>}~_3QHcpcrOfx)|gx zvNy)R$3ABI;C?INGt3~!ca06ZHLGQGHhVGlOFIZRCvYq90mxqr9y-_D0m#4vMyto! zh|%afnki5j0TgaeC~@>c?=WWwke42^)WgB(VHjfK;5W@AC?|mTP7b+UaNF!V52ODg z0|WK@O`Hw*zPkf({HGS&r{3o>0dhZef&qjWp`arEw%^aQO?}rbZNdPo<1B!91&(xS zKzM>3?OdP>f}`L88~^t?b0Fh~!xf{9NBk4xAFYAt*clmgbiy2eo9B1)oUeI4H-~J_ zu@-YUesegdbLghI`_mB5A+K}Kam^k5IfK(P!{29-fmxi=Io4rLHGB4Q4!N5Xa{t2o z`^>#r&ySivGBk&dnMZfbAvbdbadV%u6SAGL0Uylk%p*7R$oT^LaS{Eqgd?-Wx-4Dh zpX|#ba=jps;2J(7XXML?KT!MQ)VW!@i4p+v9b6Oae^6B4XJ>PT$*B%->)$Vp{O9|- zySnzTk`{6jvopA-k-MDwzu#H2AN@}jfc*)ApUo0q7XaL=4g6E-O)Y-=+3@Qe5=;)i zHqT`nISIsnIqh~Equy4B-VRRvBP%UrrL|m|WCvQ8+S<}d6y zT4U|tE<6f1~S7e0nmiIMiiZ3g2cm`Q$ji6P{x{ts0 zad`U%(l{xFEJLakZcGGJ-B*bCTV4A_S!vX+P~DpBR_1}K9O@d2UBgh+q)ZW*>Togy zil#L(4@ws=Wy)P(z=)=0%+7Pl{02wES2#6(xj}WmcXTX}APd#cdWan`B3<>oBSZsi z&L9FY_--TFzwMOu*R$jisc1#50=9iV4Om3BN^O7KC4(z${Q2GhyeZB7WrG3*8pPWi zT+faR!Xqp|80s5+&j>|fRc28ND4s&g5&n;z5t#Ge^NNSjKSS@C~h$x z0Hqh0h>tt_QT3XsBjO5|18#Rl;3}60R5rlb3%&&IGe!=}Q98;c0S?jt_c6fx2e|*3 zqrfu_vOa?xj6oD|e^24yg7KFECzBD{kSd41pDYykHd?U$Q4D;Q5X z(*;@Q(pqN$KACb?UTaVwdtTvwDy(VsGbyhzKA87Ze`K;CWT(deYurbjgIwpF)VY^> z#S;XP%?1XdQOKb|jcW}ITx$p5P|pqE>@|7*Cg-DxEHvf76Ir$1>8yYb_twr1EI1O_ z&1pgQIgrA;I^tL9kI%HZ=QeBGeuWi_l*-pq9|TU|O9l!4+*yE=d9f}rqx{Om40W!{ zC`YNz$ONeE>1!DQ#lJZ#F>t7ynSp4N+R0e}ob;d(euGN^J6f?~kh>o+X%IR})7Hjz zvLmpy|Ic2G;dG3l1IGA{u@AUhAV&dt8vBz=1<2tzvJ|w!pEDkSb2xFlse^xN6!^~* z94HpS31oi);}g>bH_a@8h=h7vtGAsw<3E8cOc!$dd`Ztc*6xR<5;$=GlI4r?xSNHE#zki-n{Cqar z3R%NxbXXAJT$c_+U=5Bi2oM7h<8=AXm|)0RijIR@-JZwiW{|_#v(m`VbG>oAWT&GFoG7^k^i6EmO^L0m%^0(9^kvOkZGo8Qzw*|&LQa_$2D zj^3E%|Fh_)xlOa?FJnK?d7hV{=lsnh+w&?5@XWJ%;pohv>lW5`^iMFj#F<#S)tLbF z?h--J62aA?FapTO+#{KJnAs_Tk)n8xl8u}}?7+CPNbKR*-%@VmJdS+%7fI}Vmv)4fh%(}HW zAI*D&0oWqxeZxz*BWnekEYx{@rv8Nt7NW3uO4cds++=OXRC-aXM*xZ+&z88TZS%Ro zUDAjYcuyZnzfau&GFYQoTOP#A8{#{H`j>?+p?r$^|A#V_9;0zPb|4V-$^_t9 zs)aC6?`&wa7T)P-R@n*+Ui7uA2ECV~d+vRRC@9$M6wS+FxH{49Q7)MF+NcCjw-Gx% zBiJGWBpw0%T?ly%R*xnCAn^ec^mU-I|FQP;j51DFR^2=;J>ly1rDxw7z#Bz z0v*5aT021haMt6A@(0Ex$c0$X7&VOJ6P*;|R6xlGo8XTV9}uO0XB!a6!HcoOr@Jda zudd4hKQboZ4=xEP8}Mdl0#F)*98$G!4mJ|N8RLW1CGb511UVSNy&wl^Q)gZFa8`il zkM01i{r%3sNDjGX5!n+paNq&h^OzMN-UhW`s^-sL7ysxi!S9U~*v=8Z$^$#5gAike zg&An16A(Cn^V|)vTb7_=Vqhsjsp6=pzRN?ikh$uqIWr*0g7}Ua`&?UgXTX&n7{v3` zQEGM8te5Kim?rp=R20Jes9i|22BKdWr5W4;JbRnz`)7NOhqfc0D_9CciPzVnJLyWhSn%kfYUdH(>Ar0-@|>ynA=Mo z(O+%6fHDS?&Irg6z&W2jATt7C{4aK9L7f2m8Z@Z3Kjd`!{dNG@*|D#tdHJd-XzyXJ}z1#{aAvTm#4 zESdlq?Nlsi9c5A9o`0j{t9+))rd7_&_P~+=U^1>en3(Be%sY?JvMFl+2!Z|kbBX(%? zT!*IfRroS5)~>+!70&eM1f5MX<-Bes(h^-0KM2x0Y5cJD5!&9>9s`uVvI0rBVr&Kd`%7%CZLEch_o_2F3_x9-0BX%exipaT26EN-p`RB=$FwpboH=JfEB;IapZ=0H z&=F*9WM3;ol>~5_#EUMbw1}KoqnJmc-^sY^_cHXXd-rqh2AFfr75V6X%fvw_vo10j zqlOR3+UywXIL4V9!{Cgu-eV)i4*WS$+~X)!jdGn}uO@a+a-eb6dHhE62Ykp(g1eYr z7$NhA;M7c=>Bt|w5F>Bd_o?%oJy3h0N)L0H4G6rzLw^6F zu>|jMN5P?X0zPL4U@DD&(EF;5@O|$6N7iSRdPmOY*o%3-Z-M(-;5;wB*FZb=b^d1w z!dpP*=f9mP{W%=WIULSeq5SnbboD&;VxiB@14euSy|thW!i!AcbCRx3?=NzHOYd@|FNcKnUO;viShodT8@ZmnB)bU2Ngx1b z3)OL%U1aa4~3AP_T!dZY1yF-UF-~Nv=06$opW5IWK zMo*=Ae%Cs|2LD`_11~c^h&2fQki!ff=GrY}t9cC$fPhQ2sbnXM$f7SZ0pWRkKfk!e zjWzIq>nv#X8yN{HwHnbbo>UCY!7J2ASs9B0@9#s2^l_5~qtgfQyu^4nz#@r6X7JFA z;)*DsQqSNjuBqAV<>OsvMQE$4{i6(Pf3yQ|gi8S2V--QK5V4dIwvz7Y16fla5aPY% zs1{GC|0_<7w`Cf1c~8`nP$X;RN6jYEHnwYt|;&joJ%QP(gO{Se6(D_cUgK z0}(*KnqMzZCqV6x@jBjFf?1aWPEUtH*^bD7l+tk#m@V1@56kcB-`5VnH*C~pz#C5e z_t~hUI175;|M~A{`kCYad?}r-aCY?jqO${j)_#>5i1MNn0>uy<1ZqY6LSheM)NsFF zGX8uvsD!U`X5fwldJdrEV~V020j)irX3P`#vO5C=sN}G#Gi2bwbP&Ud5ro~8sj|n_lMD#teAISwDPV8^8>Lv|?==iwjnCHKW{v>PL4)sXe8nU|ZF2>j z<$wR&?Skv@+REn^#nWW(nw+U7GSHb%J5(T!a<{kYi#k=0T5D&`EJ{9}H=u$3>r?{XeuvLMDZsD!1gH#aJqwT%gF zTxX2y1)cDaaRO=&WX;A{yK!W2d@3^m(er(V|BvCEK(SA3^p5XAcKz5`#5~v6wvAZGo)eWZh)}@dg~{>;SSi$#+lUglPnEI0~%Wkv|HvX*p6zdwD1!uS+IVs5=StbI`Sa z&X34|V$3hPKm&w=h3|5M@o=u@{+>1T1-^SxJ@@Fz1-@&6XI((X7tsX^$GKd9tj($3 zzO8WqO5eXW>+p-{+(n*aku$u2Jj@F_!2ZuQOyr~N0P8%DGrJ&zj?6Fc-HV)=1(hBy zH5Nb_2stEt-@=3Wz9>&1qjSd_mw}Ot)ZHQW*$+elW>0w(YL>#5k5Z^ie zV%PqUcbnh&DMwvozl*-@9_*Jg0LaiN&UQ@wW8Fu2mM7+7jG&7~PPeQhOC#)M=MtCD zkg4GN$KeRhfA)X)I|l!$^Jf2S0gM4($n@|Qywu5q?TJnRVRUwO$xe>IA$Ht_|3UA! zI3q32MeA2S=gRKm7`JeQTI^}i0B;)nA~*mWC6KSSkWoi-gKYDQmZEY-0xk6`vnVw- zu8Mb95~_XCkv5AT#5GE}ADJn2_54TcpU~(6w6T#fQuk)pdAG{wZwMhOZjjMgnJBFy z^faDj1qD|*C;R=Qt%_^bFno0sV*UHcv0nXm_Fk9ySwbj^D4XJj2^3QuI#SsPSdjg^ z#!<2y0Nvw>Hjtlj6s_`rN)`goJ!<24qHzGqDCpm3JE~=!27c^R_UVrDRjWSC25IZO z2hrEY{oL&mfEky41!re za0?j3!T~n?7=Z$Zsleebe9Hen(a(Q{GXO&Us}tZ&#v8~95CHMhUN1QSJWC86I>i6x z`D28#*7b6i2JmWwDR8~aTEyTW-9H9>00kTz0emJ%f_Q)M9sD)14uK8W!j6>6Du>${ zP+5Tc9o*Ykfgj}>52|#eGRqUKf+u-Bo5llN?@|EIR76q7z$NaX$bA)25=G=OMlm05 z#{lCI)WI0=;=Kk6D(Xk6msC~~fRHm#;vknfXyrFK`oGI$RIG7jDx>}i>rnZfrv*OG z69cz4A<%ac15o|D=LPV$+H368>V;CTvEMb;sQz3#xyWW6quStE8yxh;;bshE&l^+O zDbTn%I|Uj8O6jgl?m^3%OHC-e0^pEVs^Run%VabGT&i6gG7ku>#(jJwFDw- zBkcPK>omgI8{s^QOh~f@Mjp>YLj_?|KDXY8$Z1denjK-~fu0QGW@zux=-Tf5KuTxSBrA;2|b#(+}({C(o(b_D*< zt%I!11lOBD!A>A6J*gdZ+LIf&cy=` z{UeQF31wVX8KOY5!drh&Mo-n}CkRXT6F@HnQ_ONg zqX&ph=yndEdi|q~PSNyvHvVj$sEP}xx-1}LdyU_xRyhFzA2QngJqEiS$O|PrfWT?| z@F2nzQv!F-(nE0CKWA+Yy}2_>BrzdSwSPHHI2pkps5JGYqt81HT6;xi5(W=Q+<`I| zk@7#@#{Nj(_YpSk9H0UlT|jXa)H=AcvjGTZfxRkh=hr8l6+kEpD5~g&a7$ni0_ny3 zV!+T5UN8My-2oqQNrZLk=h}_0tp5=IF0xt85 zwFt7HN1RPj+ooCt5B7Qq^u{lENQ zxBa0sE4R5DH2P`)z{=qj8S20w-sgAg}>j*bz`!;7GR(PP=PB3IWHv^*IB9WaNbh z5O|2_qNSFhLmepyQ22kw5ghE=p@2i|MeALriDnMofX(a-ygN&Y zK_>K3|9jMB0-VzrG=xDL;ddh!ntKFeHF963Qb)g<{naru00(E3GdYSg)qR@r0iQP! zi$H|p1|TvU!zgrFw=T|I_c5n$4|6J4ph1-67*60AdmY1u*tc=MYkV&Q1X;WB6=s2B z&nM846FWK!aDYn!DC`(Aq_O~O(&KMEWU_Zj@&?4X*;ku5=sB4k2z~+mp7TG+`UZ<2 z`X`tK+0RJ~@g%Z0iQb#M!r1`!dJ=h`yd(`*r219+pK-MR{6rG1T*gE{&df^n@INop|1)v|*oWD36W}L9y};fqA_t4e z)DqWQLPsp2yOvnLCFEw2*8<px3X;$S8n-nQ00aVY_vFBK?a17M(f;hHi{o~gscerG^g2BXBY79erGkVbDdjY zH$13lf7`~`fK`rQn_0WpK%${T{QZxvO=LRHRy@PTU4}?NwD&vuR7zS#W>bDX>JlDXDm1a zl$rUDF#ssbU>{^ZWBQ=VI5-vk?=d!j=L(?U6HdWbTwcNP3Fbt#3f^Z-fSj)vx^#lj z2W2oyJ|+jwrsEX200eO0He)K*U7H;Odl(mRpi2VC$KZgSfNA3bE;F$5n)&QOdXVi|F9zmr4M(qqwr2U1D|%8;ES#yDwA++qK+f_PE(ocj^Z$_UpU-NOR`)IYi+`0LMi7GT`K zL9P>g18N;S+SmZ(Yzn!U;#sG8rWilmFyRjlK~Vkj?9<4zruK>UcO|kmgKW=qJX}Zp z{%XbLRJ_4pCobM%^gTkFi${^Z7|lbj@!4+^e+vkfnsUPZxFHc6EA z;I|S0CIi!V{n~X`VDwgS`1>x-s4^mdDPvLxmtm|N681Z=Ox_0wU5EDqS5C z9G>8?SF0q4w|KSd&it)-zu$wmIXIEo1u+sv)P8^szYIBtvaq`i`%9b!K#>&K?1IW1 z0uCbleHixwLMkfeC_l;` zn4@rt%K^dyurC_@94&*afrbkO-eYUy0a))~3M85uAbJ?!yF~;QPQaa+2^ieSWg&qp z5#qsj8Xust0E%po_Yc;M2N2K13!Qa&Z#qpwyg%AU4>Ha|-56Kd0Z`UO?SN{x+}$Mr zVFcLQU=CE7;A1I2#Yfx{_&Re1pd3mMx&F_!%P8UU!|wer+0c)ep;B^;0;wQZm9JTz zxo1re)ClY9y3Pn-ysHm*SP*MeE0*_;Fyi8Cmf?a{?`NwPN2Xia8f4tt_gI^1i{M0 zRfz=%902FD$6EIec8lPtCKVDs;0$L5*ux&z>mdWZhci1ci9;5%2Y5COrU^13IRdQt zB;Ogc2!`A>pom}n{pgk868QMqr#J)jQa1s5Z0e_pa*xS_7@(LXaItBAW$a}vmG;Lm zS&5Up@)u_R!x+t?7iVwG_Pjat=-iG80$gCv7jc}IxW6TI^AZl(@|StB7R!8g8C|-( zIq&&1uRVEvCXM_e#&==VfV_vCF;IIR`f!l|WP$HlK+i2)pP!Qxv4qZF;&V$}dkLp_ zaVX0TfjPh?Eg&xoO8p~SbDXtV-aCU1n)!JW4^3B$ec+5w5hO(i#!9dK&QATypm&_{ z;o31}a(`n%zMn0D6Q?BrbR5}?X@Hz(O$VIVHvb;9z^s>sSB)Yg8jU^jAA@$ltKKY?K*zsayT-^h=0;b?fka!T5(P1e@m$b^wsm_ICL*>i^Sr z0G?%I|A)0XLxksOUKxo0b(-YA1Q3cG$w zrY@!YR4di68_kF>a8rE<#tIgA1)JFScp4GSxgXjf>-byLp*kYj-Y(Y$z-6#{3Vh*L&Xod@T* z6u{xvh}GHjt4Vd+N6#eexv^Sd?%z%n^7ai?B>P*0g6Zjb5HASd58O6?L zg2)ErSmZg2Ja2H;?`5MS<1dFrMv22v5_+9zvG~kPZ4Y+SAPQ3vrHOrfe~S3U4e%B_ z05bM?e?hN|*IL-fnE<@LzO{A&-r(|qGBm;w3_Gi!&Ii`4AjbxU7B~(JTudYUpws?1 z7J(CZy`7=$ofY6P#WX>!DfimX^)&i9$dm9kW2V5P1_$o!G5~8daHcZ>+(Qfys$`~P z;9lbb1Po-IVwjM?r5HCcI>sbH4qmhdsvAIQeenSx>_Zr8kuF7x;7-P2oNHhpiaqFp z@5#N0K}_6Jk@XW>We^9+F_q(n(^=$j1&6>1i3=!k&p{Q8JeQH*GRCot5-MM1I$${g zr={UnR-i0A3Xx6a4dw+n++6}FmI}(Q!eOp*SgVJdArR$XBZ{tVWKbYVwYFrQi$^^; z2;*Moz}CBdVI1nLMICvmv&RjTdxNvtc)q&^-ff^DhrYpk8V|aS5ZP+tFf;}9#Zhbu z0n9x%Pj#69W!wCo4ZrXJ>nBJkB8gp`9T3onv!THvF=u>trzQn1Gzd#}GJ5&z zu4}GLuv0JzzQF(})^u2X(MK68zCAtKnn;7(_NT zb3J~iIxIS&%Xf5l$kKquvUXpezmI`KYAY0&i~H-c*Ijg2mo@G3{M{eAbx>sijC#-u z<2*b$K}G0S(jDp+bZ$S}HEn{q#`2M9IxhJ3RT>O}$d*pD5Gq%irF7bVf-OMU1 zAVZ5A^E-W({aWUGm$~lJwTbRu;;b)TnJs;b==w#B_Tnb)2#}MqRk8$%BxvT}Ik8Y} zk3sUIj0$!{jE%iw;x$yl8Gq2Yk7JAl`9JeRT;ME^oVcgE^W*dR|A~{`GWzVy28^-( z!Cv_^cd@A3g`hxFbvrmn!J5h0=^W}-S@yZJrORak(xMxN)q49+NBq~g%}&IjuzYVQE-s{I$ot##enWCVSAf`4Ox*b|2Tvb8x&L}&eLF6SfXO&r|j&T;^j zvJ0TbA+0|r(~V6QRt#hfHlY5w>|0jkUB|ns9hnNPR7)V1Xkit7s?UD~g0});=~E3I z?_Mon;?LLI_7cXmd`>d=Rk?okD@mOyB^r~~*x<6jeH*3&5K$6JzDiV9Q$6(aIZ>^~ z;#OI_%J=hnYTYWT{*DnEk^%Wjrk2&89zZpvt-0rZB8z?^#^{g7$P`{^W4fD50arNU zmGOV4)8AiqO?*Yxy#w&3Hb-?e?2wV|AU~t0eS1f+2v88!eB06ILgE0_a#q?l8Rv?4 z#YH(T>P7!umIQ(b356@BJTd91{1B=8H`(C7)v5hW9Q7;0f9C)E)bqSF|1Sri!1olk zahc#Vb|z4IPm%+zak=9m8~G>70k6q&Nn{7)L}3(S(%@VC+QZHf$|EoVasn#;d39zk z`hV|Czy`(xs5<}!5UqlT+Zi}Du?|5PbW;LKgEIidE#82Ef4OvYtT6zr>)?HvWr@xU zy*Pw}DA7UIc4!@AOa!(>M${TObZ=rVf@tbrc0||DOiZk|)*j;-BZcvbqccFp9|Kat zzy)0}k%DkC!2uv+ze5sV1t#DU4+%on%Xs_cnzL#9yF-9yuL#u2;jBnzxgU+suAb%2 z0G_)_BwBskm;m;tHsq|=V{Q%Pz}G*M_?*ZLe8O2dWyJoJCA&KJT>qy_1pAvn2;Auy5pY_+=_HYOU-Xcio za*Z*rF?O_Z0snLc;6fV+)^U8s<$x^{F+TBWV*w5|kAOM?SeJ?4+X0Y~-`cE#hj@O# zeHqb*18}Q>iSonZ` zgZ|j(sr$_hz}ifsXJR_wEuPFLv_HmchBH3HJQXP=8mVmPLRf<)}$_0&a;- zt`7lTfe~GSQY-9|%6?Gq8O~Izm;x&ZLv;(MJ-15Kw8r{s7)z7`zQq4o)XFXHqvl>} zGWt?h@ z${^Y?Q8>k>y8@84Ag6k@Spx+Oo>sl>&a~mO(iH0@I%9Y`}E32!<1YBU&Sh(|iqe<vOw+beAU-67bd1#!G%)UZH-1rx+9nQqf5xu5`n@J_ppqCUxf@Uv(Bry zw`BswWzN(R`@Mt_UOFo?1-hT;2;kbYr)TbGno1=~d zUXne@HGWs)Fw`mu(yMHnENN=v8x)G1o9ROUR&Xf$6rCQiHrm0YtcwU;>8lwzRq#ft zs_pNeN>7=DG72yF)J^TBIK)+ir*cn%vXogU^1h)P zvfQAEJg9psnSB^oo2l(EY%-Sr&1kxh_w-@t3(t0xeXMKbGK#-;1gv!TVXk)z5Aao& z6%OG!(6J^EYtsTTKfK;#=np6>HCL&KH$H}@c%R4)Az6)2Z02SvGEtyL7fm^ zvm;QoGayXBkNlH}y1=~!P!NS2w831fe*-%JTRIDXPz5GHxPeo>MgxA$X9gqi6aR5J zfOUv5!k;oQ5P1uJ1%z~9%;f+Mb8t#rYX{)7j__sZJJ}8xcoOY%pD_Y|NbE$6X%^mO zwQK(>Q7JQUhkxGbOaR6>=$Vy;K?w#gfE)nr)v5%j3J@4n!pKhP%_gYgz{f)N=$ZG&q}C?uoLx;9agjlZWNh>`%2 zWOFx{33hkXaJTD;!U+sIjrj8f464T1;@(;)>K4BX2EhZ3SpH4cE{9Rv!$LYM(&7Gt z-c&!w-2eP1gQ4DQEI`@a0sk^z0MT{K5%{LD0AKg-`s^TFH|r;a=D9`8DXEHLU3xWN8h0 zXAOI~iu1h8y)7%cXP=hQd8^ouRjmIq=Vcjvu#EG%gxoBnt5wK62h3GU#u_KiPwz>_!IKobMp;QtDq$I{L1~ z`DwkzcpY{4?3$&37W>!4RyTR>;0eKoG?3W__M-VhUdVRiS2zG7K`G-cRyR*DQe6n+ zpSUi_#@3aB=gX=bs_M^@-K_k*1h7f*%J6AwT_0bvf{pG|ius?J;?)$l=&@ES70Rn} zM{*8SkI9s1`Oi7=PwCbo9#E;zJ=cG8w6saKOa%sk-_b`c=;2pw|HY2>uQ12LT?xAEBJXfXV~ETALjM%9yCOkHU#5iZ64iWPtS?*xwim-XHu57Z?~Qo&^Md03|-~cXtHv_rVKY2H?OBKAa#= z{cVUSAea?D>FA&R8^Z9#kfySKq5y_)Y=%%cL#$~~3@hWpVGvJ4v1;Sb;f~hKo9vj) z_@}Zp$Vl<;`6|80d&hH^PD#?B^4p9L&gCygGX4NhC6uF zI@okq&p*u{@JB}jZ*^pVLT~ODb-_6I%`;pE;GUZpv?lA zPFTN3v5maZKl_|5n0KVLz8MBLHFiLe7wZ`#h>^=tWP0@WY$*&!0Qu>1hQ^+0-T=-aK7)+S9PQ}&ojGZ5?i9D>-IV~nMRdX<&$_5c zoPArxSzV2jy$0D{!`WEFy02lqF6LZa{QpdydA#-I^!_75C5iYVb5bNSWX=$wC`6Je z`BlbLG8T%8c=kT$>~qdOdpPsiXWD0;r)MnWi%KL#BEBjOWQdCJ{NC4ESLu(>>kNDE z&;H!^z3#Qvz1Fp^g$-DF1{Zs4h4ox!FD$WN7I}t6WO4Cof1YPtVtp1B?*Ab7MPDsc zj3q$#Eb&ZBtkDwoWRX3y_-KO-k?VQk1(4&}?=EXFWGJ}+qSZ5NI*vY4$HZ`;(BES(v(v!1N8ao;MkawA z8|cBIyE2m0*e6M;hR!lBMUkfGWhrYg267UQ4w-TQkfpxy+#^v-KYKoUE!lBoyvh_$8idREbQSK@r!664p04-_}?x` z$BU43agz!+t8(MouhUbgW4OggRz(mh#XP-N1mwfJ5`m3QyE^H&ut^JSs>1j4RNDH? z4D+fPj+AI8uXR1qENM^7+Wqp$$+Fgo*DJc#2$QRNA?mc}yj=n9pq6p+Pf z`BOSI5%!h?@%qe@M-BbY@?Nd`Wa>j8!!{I7TYsh=N*L?XxWQ>kO(3wHkI#sSnj1x@ zIsNZLj(jKttuVEs7FVZX6W>7V9(>o!9OB>GMxRYvRFvg98~&f$5x~$3SODg!>m4bp(KA4D%lvn#>~+Dk z!OUajyeHo>bGhW3(Q)8^!qm7MOGA7`U$&*oMZtL8$ zj>A)br=5aR%pHINtK*c_72a2!F#DtX3C8^#<=^+qC_zL7lper=jQ-(D503a!EisBY zc*Yei;Msean_diW^c-N%^zyyYZWsgD_g1r<%_I&W$WWvNpKpEu=BB^u3*FNHrvy?B zFnkz@-{G_Y&$Yy}FR^cy*awS@bCK~bBJWEBjx6BpEU^!lkn=^1*&^$+z%$JwM{^e> zCP4&4Q^@obPUIx}YT^UQZy>@Wl}C;ZI{(i>VFZ~UDI}_2r}|OWXbicJ?u>FASj*;7 z$*(Z>!z}3>xzo-Zx@Y7-r+yw|P$*-HUI9OMDQPL4#Rjs}*voQss0oBrswyz6WE#EE z-<5ly?*d23j?EIlF#O0?FFLswr#Tw^aF6KnC!p@QIXT*m$&mwquIOgn#P<>Tf0g~I z0zim=RRCd6f+u8Orv#CU`j)^1?ULnaY_2k!OSHO`sjT;}>6Gxi3@--o4y7Hv&dF1c2IczVmEt z>zNV>P#VTH`02lyMkG4TAz0C4UTF~l7}@mdN3V*2XeP8rMiE4_E8hM<^Rpp}f3&f` z)DFNkc3yOCb7WxLy%)CHQMkpG0Ez-AEh7xU>m2Dg(ayky{{3u^{~eA9aM}z4B2JLe zUqB88f+d_lqyqMJ3g9K4A8|eiC@II~EB;;cE@0rABLOIcD5u<+G7~%jc;amcf7=Hg z5jfr;L6lTb20uQ_1EZe+Yg|IPmQboCrF+;&f%-ouQ&ABCdZ!KlMG3x)Q@%YjMZBp7z1%SMvk!IIMI;+=6RGk9z8Vc&_~%jK_J9uMnCCNL3D$- z>EmL4NB_@Yz&$b~J;wdUxL+^{emA24I;{pKfY*W&n7JEAFQ^%i=zdifKf%0Cpf4ub zUz2~#T>sR#8~)&IPqCiUZ!_I5axsIf%rLfD4C@?YpT8iH`wPtF63*%hr_vQ1hE;Uu z3jbS0#@5&yYdA$~*oIZsY!w+>MISDshnCTw%gn(Fva-UwtUSx<0_JduaV)VfmXMVt zWM`TEv2t9#9!>&#Wr^olV*HE8B=^7^2gTX%Wiz7b@0thT%ZY7hJ}grrW9)~q{hV%L z{ziUaaAv3Z7?dtKJ|hOr>yiyI90#Rc9%=9&`$>(U#P%2$Ycj&z4J$>2o*PE4hu>qK zfGI}_R2^`SnFYCL1BY#B)egWz66hKcFTSIXajW5800Pkiy^Nz5TiVMy_40hZZ?-eN zmrMO{CVO~aFm84* zxr>2R-e^1khPw97R5q1agPQnog^4SFF7u^Qs5RtysT=tRnnz8aRJSAVr}_>L)r?Df6qB{#uVVXvojAKr(CYU3ZR_SG^Yhe zB0A~ec?F8T;Ya`*A{q_}#f}0~nOo@v4l}DV0Y#_!ei6@f;x($lQM95h+8MYcPmqeH zs98{HE)nsXQz7(=|L4;_il?Z*=WXzp{kQ%PbwfWfq3_iwA4yW%Z z6;yiRD5nRWnURJd5mHqI202O&?Q2P58&GHvH`Q4aVirwzW4*ny}L5bomXzW96xr{f@KLMcTj%2AhR zI)W4Bn*tKvZR4*B0oJ#ZlU3(W4F+Tm%Y1j4dz9aqD4XMn0; z7+>Y-x#uc4K+!?)SVsex?+SBP!AXez0X+r=4jUVQoK!iP)ldvIlwysOLyhNFV=sYu zYk$b99aRd{F@E)Drb8d;0iG$^4gbOw0@t`=K)^v9kvh(|I)rxb>C}Moi3dAX!1%f` zHr>Jsp;)_h@>h70u|=a1ok~!|(MLe2<}Cp!Vi z$so@;h_M`GOoN<|qLnKS*AS=iA?8obg@V{++0Fp_p@B>{#?1Pr)Ba%w2?`*1t;u5k z8orWq>16TUGHA~r| z&j9i@_D!b*6z*nj#!oOo&`g#9Hu>)6sYd@|<+Y0+;85vk+otDv`%k1+N)@_yjvZ5#ex^nqc zzlQ8BqLUZc*Yh~~bIjMw4cV@Eius(lE}0EQmJ|^Z%`fXS`h*1kMY@I0k8LwIz>l&j zLX3gU%aR&-oV`2taaRne8UQ&Q{f4*;KwilJRHFFBROB^AD?a-GAAc+kPP#|TtVyWAo8ummZofkNC zkFa)5+n_U1Y62vRRT=u~qqFj$ijY+Qk$^-I1$7}5WdyN{!IxJPKp04S?p;Q41&u4p zyq){1AH8U8<3!u^N&csKB9_679J?HVtL+^8El;~G+`k0{8Wg%;%cw!*&o9VSK_KGK z&Qop}GmK1$#ZxQb=wmqyyL_ofub@2+Cp5=~j91nA5E`{xbM2 zHuj1DtogLx&V_IlryTxQ=>Jx~uicc)S7a2Rc(=iW2uJ`PQJ_I2r0Rh^oGQ@oN|UH` z@SPdeiIe~vJz5F#T`f2p(NO5u9{ZD>4pG#C`H4nCc&z~pRVZ8#upuX1{TjTB9Vc)j&zrx1{xwws+2zzCL*C-s(y20=I^!42?K zM+flC+j(A9Vg#MA(gQqa^bq({rieO_ljsv5UI0}V;FttwLq|H20SY|RQ5;1Ae*S<8 zfeY-!{mi(P$D1!e4zir;mpdJRA}X^ty7tVdRp48mX|8~acV_PZrNsVW9aJ4XZ_Q@Mw||~ z&4^$D2Tyal06DIoZ!FL*85M|f!e2TyAf>{4y7|6t)*(nmzGHx(LY1sz&-=1IIl`D* zoZr04k$|e{Pj%s}^s#sQnTP&YbDiaj=ZXI5$a_EQr-njG3n&`Ue~)njhdP&fZz|Mq z4CEv{+n52A-~e+OO^4V=(Sn%y8hpH?0*`Zg0J$CPH*WwA;}8mY2sw_XFUVKp2?hwV z294Il2B@jfF#CD!=y>+G)$WMsXO&cP~jyv7`?AtURIeNE{CzH1ekTV=gg*jp>;=M|i+Rb+1! zeYMK`tl%`QJjVdTeY3o9o_#;}#_TyT&Ay!aOja^9my-8j4C6TZ4;yXtP>?Zc-oD}} z3A(q5d`zHYCRxV`40{u2bo?f#RW$$NY+(Mzn7=XREa;e@Z-=bM&VeF1jBWH-U#v@T zLtxB@FUv?#L*=IDBrnAvvNE`LMyUGlFgFHzKDuV2uY)f8Rar6{jxqApdzOiSer;ZW zpBig}o{4Ushqy#nPB@>7o*oZ2X!ivPB|mo~On(VaQYu-{R2r>6t^1Qac%VzB76n$XMRvFu!u?Y^W9t zNYvDS+D1@e?SpLi25q2Fy3zCqXG%5d?Pn(XJWiG8~~bfT2YFHR@0ve@+R2ycUP#b4RTGuJ^D z^e;ykZp*)gGYF?ZSb-1b+yqwO1G&D@I#~e0(R5CtT=GggNnF7lfMJLRLn2dBB?Bjc z=r8asrvj$z1YBxt0H?Yj4*FyMjI_X$oFd?UZF@L!fZ_{UW&sJ6*5MhWg)keU9S5Wx zW82PW)iOBxFuc^!f%o|I&v-;4)c(Ru%_ss8eFFY39W?O)2rr_jR0m@SWZiCXSLoltDBPLe|6?puQC01YlUoC%USIahF;DGM@=1L6le5XqLN* z&bkXl*2QVJi}j0+g2!e0tHM32D2M73Tp=K`AngYnz3N}GJhu8Da|N90{W0eYqgzA9 z>lny7a$3h(i^f8XCz=Z>5`etcnb$gUQpZ8AqfF{3lR8Q=*abiD(}DnmI3wx^TK}h& z3h!6HknVmv0<3G$jtUR(Y}Y5_;Pf8uGywA1D}#^W?&DeePB1XA$9YhG26eC$AfM@H zjia;R7hN5IO!sf*;yLRI&vQG2e~HxIzH=8RmTrzO%tI46|OtCFg~IWX=HO zWti7So{+nH)F&`1XyDZN8gku&e1RWB+EREPP;1L zQzi|%+7$pd*x0`*^Vre$7a3}z@0vd_`yX>Nd05uTPb0%Ky7>R}|GI@Qdvu01okds7 zF~<3qy6g_SFn_8M`pn-lI&PIUT0;)k(GTnF=M4<$24mUGdo~xi81H5dG8;Io>x_F1 z1G~;1-M~0)us_z3t#zdgke4-NVU@XGy~Ak)KC{MWS8)hdd4?5?=rZ?PMBW!vksxp) zax%?#PjR}PWW6RHpLzVT+a302OyXM@dwNDo0wjs-G?DElGCaY(C()sk$lU~crOD56 zMN?RVpk!t($L@7HKp;%r8(T5PJ|06KjD6T8n;%Y+p#W^6`$oha!GUX7)g+RcXJ@~P z=orWt1|OREmHr(z{%848`75@y|5{fE@ZEjvfneKYfA{gMedw{?9~l#HyQ=|~jRz1G zK+%DRJ^%yIk{BQD**N*D8VF~p{@lb0)pp7Oz%#C1>byU~P~X=|fel*|*yxmGHB)=k z=!m9pC#O`g*+uK!wLA?L5!3=gQbh5IZdRS)NR|?stXb z6`EHGTby9e@yS-F?6(^P_(mHxMFW1DA?}C(uwhzd7%%b3`M5O9aT->r{yBMCZx!zV z9;G@31_nUofLA#j%^U^~y+X~WIoiPjbiOmktB8m?(W!}z$ZW)suZBC}oS<-vDA*$J zE6O2YGZqoBBHmq*OnMRT8Qe;5%E+bkyTCM@YV9=ZA4drNFAABT6;=*|-T|1aRDfE8qx61e78Ww*ih( za0aMKU?h!tLWaR;s4V6 zE38B18;*cI+1Gm={=Yh%fSLfZyO|*9m~_~+XQO16XNiVFwDk=jSCPska_ME zu!-NJi3#`Uz1ih~tWh6Is}K3_Lud5iB=kSXitjJx2sp?rYCSgm%u#e2)Cr3H*Uwz^ zGtPdDZT~ha&r5yXYNr61>HoJ&3%_QN;Igp+aujZKDuDY(p8=HW(B6sK9(s<`0_cY5 zHi%(quvU$mTq1~07~bF20q^5t&jhWk^1+;BhcCB7!1s?ZpCjnW5ymqjaM`+zKKBb& zLH6?qPSXg_F~a9Yn5Pl;K#&QYWG6sngviVob2G+)W{f!-yVQID=)vX{X804>4<}&) z!#nZiEQ?cfoJn-~B(gCjqt86f^ktZThH=mE+%xE;8P;PKeK?0K&NDX)$npX*xquuj z2#|+Ev&{UhqMO&zZyT)Z2KsS>ac<^4TUhHYeAkvA`eKeY&^PO>%?4xNj2_;=;oU%& zZJ-x6*q`e><2pKK9UZfdBeu>ut+N+b8;KWK#tB$tJ{E>}CiKcI4#12s3#`#3-#gJv zXD7=2RKoYUjEsyqpFjTpvJq1Aq9i|>+{>H?=)1`?@_$Y472Op1&gdbqw|Nx4ZY}}z zTr^uc!{wHr$aH})1Y^Q#u*XJJGPrAU1vGH(8j_v9B%ca?0AywWy&UaTM++n zk8U~tR~j6w>xH?$(F?oe$zP`n7Q6OUgNEAkbWrQfQlu^h5Vg( zB~ZjT6i_M!2B?~PDR2R~+TU*g)ra#`)`pR7Rn0dWROMS8CnR`JC*(N&E5!dclLc+| z=|;KA<05B~U_gW?xYDH@>zP9p$3W1o>g4s=j3~5!g=gS2+9ou=O88XzCbT<$N9mso zANOd%=?H3ERRH|h22J(ws*C?#p85lg|5_Wzwu}};82rKnxJAgCjoo%{RvxIgy*d-N zb24aW)3sk`(3wvDDB(_&M%0pP4&)%PNGe+^sl4t_Xs>JaAQ~<^=@Bt@ytoJzppLIHb z@dPelBpto`=Sz_Q6t1clA{ua*9f2c_4N#>3n>MNhG-o_xfCN=7!1J{-{{a@f)<17` z+JNtCt>k-yiE%x-62b{k+N6;D2{QU&@NcstAjJP`)6tBELVwTKB0Vr?$LwbY1Rj;? zf)3$Rn1i4TKG9&nH`@U?BO^)zY<3=OJix9AVvW?(#}n)t(SS=592kxO`>Cu57>-0) z6*QL{4EV{!+;pAd-_J7emHUb2y0TvaZYxR?FdlWtjPgJfZ1wX_1*k+9d8-}dN*QFL z#$42pfg0;qV@yFCyv)or!z_!eD_U(~G zD1EGRAA70~r@OC`L_vK50J8u4F*N-+Sp7Ie(M_=3_yE?hzwQbGVFtSWJ2KM$^9-{N zNa?cQ26i__fO|yuL8Sy(%U}~^{|&MhgBKVa_ye;CKG(oN^urM2XmGCvioBt;0DE*8 zV>tYDI|3NpVfJp&%C?#`Xx6*|ccx(&d4wYZ99V*5{sMyrl_ogae_w4w!skYq=im`g z6o7di{hCAB0t6yMW1DUKi%Iu8fexAAJ0}?Tsb1FvcbZZG4wR?*}mQ7=s}< zGTh(f9utgzlCe!O=Tj{v4SGp-LJW=s9F!*ZX#(eV0v*s~{+drSKA=4TmCa^GR3f^< z=f` zAg0W|{miO~PU-tbIt0Cpxfj{)#STOdfOA~?uiXESyblG`ML%?Z&Q$xiT&VHgTbz zp=OnWDLN3REiAP?!Wg+>azKVYZe zWeux;bwvP*r-tKF<2|(_%nz{PpFC6a5fDBAr!eS)Q999RNc&2qggkTY_l^RJP>AtF zZ-JA1on!2P0E0MD;uHv=AY%yvp|cWz6m3bBi#)~bWEhrSp1l`GsTalB%V&c=_z#)a z>|-9I2Reo``Umj2zV&1ejJCqBF+fnbfK847EZX2BOZ_;O{h#pb1C9pBIY58(bN_zb z=a()WJjEf`njHb;c0jxUPcoe_@;S&o2KoQcLGB$Oo`5lz2%?7?pD|@HC&UJyZLoKS zRVM(eKvchutOcJua~2I{799aVkBWDG1id)2kE;bf;wpjX`tLWnY)~k3_SFb`N~ATT zeCB=*0meFdlO2GA?Er8%Y3}9FKL%j}$A9AcCigirPyCbra(iFad`jW||KaM+I{&%D zvc7)~y*hr^BD!0+${}$^FNN9a44EY9w%@e~e+w5dmyv;J9K-=Cngp?T)jqgyyPW`~ z%U+sk0ks0|VUP4MjvnNz=asGm5SPbpS@svCUqb(@q#s*cXa4KxmuT*%gF>sS09a5p zFo}FRi(Ew@M7J9u!)h{0}~Bh#*;3y_-c}(6H-Y4Eg{C=okTzd7F}R9q3+w5 zgc6&oq;fAQ`8zXAtS)y__CW&k&vYVWtVO%pwQmBU!Xf#qPy50nAfPpbA^N9Z<&Y;r zRbAPc6sm7ahCl(Q1ZWiVpt#+|9M@Jg24K65`5%2!Rz6y&e*`fIeFT!b&<0H*?lC(7 zLjE6;;d9Xl2aaGN4PK-H&T`IL5db!ky7@&lzy;1z@8jI_L{>b+iSlw|083iVC z8s(`)h!cGaaAJylM^QgfLPeaU;@fQ8kFjyrcs}Haz}s!;KX0c%&JG4xxQybSunk7 z5%!{l0*-Eia!yf-(M7PHj+HtIM!V);CMF;*RiPY~>43PdNo;_62}GX&RR|nn9LLLY zodOi7h{2B&z^RIX&V!s5V2(OJ?@Eu&E)zrnm3K8hMb!c*_%aHud?nY<(;0|Pn8;ig zvL1B7Di6frtKe)^ZZ-}8V^KwsRA1pp04JjA8421|=S)!rtC3JJXCi;KPx+EFz$qsx zd){a#U^SiV=s0+}BLi|4{^Ka%AqE7#)akc38%(H30P9g_e4-5xAmMMUbUtGY0ORQq zYMC|Z`9{_+i^!yxJ<|Ic*EWCDq$ig;&-qxFM4jW%XVDP>g+!S@wNLH;aH6GyIv6?V zN5-RQi*^#r%8E~S}FI)3@SCZDWnLu{XByyxY0&cATXh*oy7`|5oX1@G(R3Zjr4t8UjGB^!Lg4p`QOg}{@}N%@l36)y zeg=UJ8&)iMBFPCLAP-bT$Wj^f3k<;J zNs(IBiG>YYdwpUQs^=y_N|jArJJcYk^X;&pV5)@-l?q)g;FTzM+q*L_uRL;u^abL3 zq{HGbZTI;4ctc@1<=?82)qvmfZ`AfUQpd)XvAY5HSBvQ&@s^J z_c#)8qVvsnIrYJKq6S?Nkhf-vrpJylxF0BZg&hsy1C;VWK?ISIss;FLlnL%s^`E$ zT;y~J_iEvk7bSwMMPMi706f|$0i2g;F)Yw1a~FI8C+EC{q5pzk`-*?R&`|v-Au{1fH4m9^C~ol+j60(Ez@ubZk1Br3)Q3;CoAK?BEWl zr)35ZMJ zBaQ^9N?^#*0OY6sAJ-nQnvCQQloIkEErc-;JwGvRFzeRy$0RoCJ;Y^#+^1JLPsZH$ zLbC^czzzZ9ik8BRyZ=S56u@BhBi}(Ii~}C+Ri9(bz%h;rFpvG{vmjjgk|P7c2K*`k zgaHsd+7W?4R|oLDgPe{BIcW}}O9oZD{jlVCk1m7E*$`{d5W4#l?i+wnX>g*84uS{l z{BKt|ocRpe>~L$=KPE*)TI zKpe|?4qNl+ky&)X3^Fi{{h7j9nS5i0^+j#me3|ENtH!DEz?ozdp^_2%gien%z1!*x#qmE^(?+xH4*( zF_v8_KN7N7rA2tO@%jVIs(*zF(z&7~ZI#M|fKpLzML?_q=IlI}b_R}j%HZub{>)zy!4Ld^(g1C~ zrhTCR0v{k}U`HB%F**i+0P7wkLQnEfMFKwPXuyZ<1XLX@xoT%(CKL@&4qq4x)}j>y z9kj~(Wn?JI230BWQ5$x~uQJW37|_@S97K@^v*7#ux9|hpx9we-T8fT=oHo?-sf02w zv3709oEkGl=%0Blost-pNCWKY_wAGKEnzfEce`3ZDVnphWU#$zM@&@$%uV~eoq~TD zBk&flmr^+xA(g{MCqV&P?=?v9rCHGuL{&VixE@rMqSn=&|4fIw{4w(cAY)yuO>_-> zyD6sfIM0_*%NyC)q<4RpHL-W1>lu4Mtx@|9bp8`1*M|Y^yDZ64L>?5UA{qJv zoFc$5_CMSXfG`8>`F@OJG#dJZ{}!0AdtQyncEG9w^PgyAijX>3-=(AiIfPx&<_(F z$R;r)Q^>^>dUF~BJ%jwuFvqjpf377@)$_>i0_(VVR?_k={M?QJGC$Af7tlwG$ng?J zdzmq=us&-%<2o|AnYr46gSMSD-j2hx{Td8DI&}vJfQz}`#jMi~)^@v2{Wuj{k(I5; z=2m?UTeG>zh2C4o$gc7X%Q&A)IEagkZ(+lR{{=iJ>ps7G@)68jn4SN^C_gI4+PpM# z^9v493sTtD1c`W1tEWpON|>r&KmE^a?+uHrYr>| z^{M6tkaPQIV^+`u1Fv%h3-Z%{j-z3U0Pwj!Mba3Lns7xWfbcf#gXrI*DjhlF+_U?I zS+;w>BY-Wa>F|7wF#y9j0FlE~PWqb}u8elQ7yLJzSYfd0Zq|980c}D#zcB0dJHMKz z*%E^g=&Oh)RN&zY7}dgMnWrwG6bmSY0)}Z53T4x6*)>otZWaDjdO*DG9lZ&P6Rm0& zo40aaes}Z@*p_8d6&5$Trzuh~V0OY2?I8R)fl$?t8Vj(C%N5Vf(|6m2K3VDnFW?%B z5oL2So&xv@@&1*JTtu#0)dD|ELl$X(&t!-^a^fv(a8>D*1nh(5`jd2VwRtU18{B{r?wYlRHevw7vE*0k8&vX^g#FkIY0sj^8A5?XnHQz92pR=z>hpHk8s)p z0SipPefWTr>;QbhPJnO`U5=J;uc!{V%h3Qn+xob4t^y#)Ge$pwqaArUAtOZL1iZzs zF_zW?{Qoy+3P3;AzGLsIq0$ zmnsB!?&u`QX}63llu;;U*1QWvsjir+w&}t^bzS5#!QUqyCS)CD9aO=J4qTg6GO<5| z0eFy8W^#tPZx!RChFewkQI+Sce%8Q2VSG-G+~0$0N4b;`8H-*UN)=$3YbpsuZd4~6 zjDo`7Fo)50SPlVmRmW+nvkrCSJ-Q4sN8L{|;79DFJ@_hD2B3Hc?{+ExSs&uFLpW4J=(PrO z(O`ZX#SHZh<3J3vKZlXs299ats=S67$1p~G_$V_7qKt>PWm;f_XC6W6k1$UoIz@iK zsQ`@b$W11(5l?_lnoqF*!relgqrE;E-aoRHUeo^|G8 z1KqR*qqB{Dw1a)IgL_=edR@#Z_+sQ`2lKa``)tJl-hwP`R+%7sVDp&<{h@Eyk-s(7 z|6|;ine#>DX<;ne0L$>t;ULU0rdecv78#y7$T@s;;3QY`PJ{e}gJ54au~`$yz~l}a zbad|wb3enuWQKK}LH|v&)>C}v6mvd>uAJf?(>Ny6tnu`=Opyp9F^!y0eJRP4Civ{c zsRjh1H=D@UID2{=*&OGyV>l#Z$i4asjG*_UGvqUk4Z%5RFxL&n+W4Zuf$vH3sll)B zyuW>L^tfPO4Dj613cKwAxPW(AzR}%%tbMfK<}*EfSI>9M#CeSO7%~$ry=xf>5SwTH zJ6Z8lQ(FCcV}MrW0B|bq_*I@}I{D%fWQ<`zy*QK1Y|?u7TA!RPz(iy-d~U*-l&~lOC{UMgsJ6fS-DU) zS>>RlPA$J9>#2iNo##^D0yzoluvR%K(b2VsW+=0Y@KsPGUGGa?fGAgdqEF>dbDsGC zhxpI75mX7_ae2yb!4p&Gy%xSJQ0__zDDVAAhsZB?I9vv>J44>eaYv^+j8t36Csdt8 zncLtz5K>)$L^izoBSiC>qD#^6@`ILkcb_~JwnkyAagI0$;$$uifFckmx*`g%$O0EJ za7E_1D9pw49SLA=BHw?g4ga(3EXWafiz5hlqeX-+_ydFo;KUo123?MdDCM9k0XcAN z?BdP&Gf0A1zn~R9z)=9D0~kwG34AT*Gw=b-e_$wZdIB8yn{)>5@1bx=Is`!@e2}98 zkMpJ1pK0U2tFI?IS|C6tO013V4Yoj@Iob!KV4|zwsfjyLTB&W7OQ1pIA^Htq5ZgKv zL(qnDC@~);6hScV2;}lbcMj>3Eph~PddBpY~+roxl%x-oyR&Fz+86V zq^gTx&;=iACxGvXra{b4r}hl@4>rhYE!GMEi z36v9XlYjr@e=7yTG5ABW2v(V=>LJDpyx2II^V8^u!Qb2Ifq!Rut;T+;ot@Z#I-jix zM{sHWjFKTa*f@oCWV(K!BLFz!(PfbRuWn=AD7$XvzFXiV6ms`cg3AAW&T0(^e>tC=TOnP5~0u&+m0lM(di z$h({d_^PV`kl_(@=*T~^EO6vrlLevs#!hzQpCxzv8*;fH`f%#$d6JEsH=mnft!8-c z*+--yox3s1{1%zlB@SfED!F3~mwC@JI%Vk;u196Vo+Z|4nZ3J=L0&}`*Z!F$dmGHn zmbc*mAXhtheFx6;#q5oXYx#3KdvhCWzXdtoj7)F*PjUvVvsc#`&l>Z(#_4no=VS#L zUdAC_;yw%fKF^ruaCByQt{HUEj6jPr(tQ8aNH#8-WUiYx8kLV8p1=rB9^pJb`(>K< z&7gB<&vK>1=ac7P8u^;W@tj)AJ_6H<3@{Hf$i|F7hIeEiglS}d3OSj2RJItNJjyr# zbk77jxQX3pDk{J}8~=Q!W5$rjQJmvZ^rHGc4Bu;KkNwx+UJcf1=yad{C$c%vAafI) z1955x-{@vml1ZLrK=>9M6m`rLYhWMFW8X2EGV5jDdyy-(=I-Hu6CD9%{C{dZ&OuqB zQ|G(tCmZxzbjnXa`gh;}M6UB2iHufb9rZw0i(Yjqt3D;mk`(S&O|$@iN&|GBpXE$t zHc7|lQi8k^;sq^WH zmKNbq*9loa9ZFP=2#Tx|p(^8Hmv6~hYH_Dm6|wjqgPTyy)qV36C7M<#XraGLDAMRb zFN8Wuvz2iPuog^t%AMck6F#1%c=Q7RcbZSNGHMv0sGnE#;vqf_7c<-~fLcTVSeT%) z6}XWFDlvb-T8FWWy7f_~0+c$@b6w)_GSAVms}0V}UAe$q1t?Lce1tzheJ^oH{}7+> zUtj~jzfb>1I~wq68-0vuk&ReHfd+2iKH#9r2+y%&ajuXRWC~c(g z5!mwHT%RBuy4_9!#=RBe()Ju1`>)yI681t>25gYFXBdzvrw`>E{RZ?u6p^?o6bWiW z2}H|i46#}bx2ptG7z{R0yDB*Fl7n9Oj7)JwT0l;!K&9FX7%Vk!l2Z`a067CVZlVwl z2jC&D^5C_gfM!p0qPWz$x>NG}v2*}B*-vFT)5xh>V5@IH`CnOf8~rdaR9(zPg}qVv zh#diBp)zKp&zRL0BOC!4e;o44r~Q6m0+699b5%uwRdG0;35MA6$L==^j=`*z;pZ)2d(cR$s5qS)2RUzW8b5aB&F|~WD)H9sjCJs!hN4N zkPyY*$9x2zfKLC&Y(Gv$|A{-J3tO-YD%X0WF#)VqPzN(NgUHGtay&Tf4uY3D4S+*F zq!2FhGsFR6=nD4=zyWM9R}I#*!MGbYCoUiqzCyr1F<}t z0Ya0rPe;CJegKT@$Zu@)_exItQRZtDV>o(qo;t^o-*MKd$=D{4=}C;w6f!W4tj}P) zXPJXp)@u$YcTVB|KPAFHnEfykON?cO?_WjcSCO9;4D&MUw2WLVcctN9;l3;E;Z^>> zuFyTYdNX@s3(vF_CuAFYd^_Xa!P@LlD&TaV{#lDH?C%Y}cOAK3Lszb$*H*C~tIXM| zNPigjD(k<(yf3TrfbUyqGu`haY>e;bdVd;iQmXL0;yIRMT6*vOpmWDgwW8ArclVjw;51{8~t^&BiWDq;426~mCabgORANe+r$W}eQHn^Bfx456pU~vSJmgsKnL>t zsWvcpWPz+7$#x(fXxraT0Kz8< z;y|clTuN-L=wYwZ=bxN=KFz?h-z4BHn%A(f>U^gby5iMW4n7RC%KctxCqVyulEeR+ zTZ~Pl1{4L@-NyeAzyHPlTd9HjfP)`!I^Y7|m(3jX!Aduvbc^C3*luS?5dazHN9J4w zU%+Gh`;#0Ec!e+F1CFvI(B>40a1zrt#_jBP3@m2<#7TG>Z%@VDzKKFbcc+SUUhmxpZ(b0fJQ&U66onHlBt(TSd7?<1Ix4n5&v{hRAsB zn??>Rclayw1e|Za5Y{ak2cdMkKVapySZ;SuXq0S1o9jj+lDafqUE z(5~h?7r6=Z)B9SZoO?`z`a?$pr0{s&-Ye_~;B54L-FZ;~q|P$Akg5n!z`?D~9QWZ| z_G75}4|Nm(;~ve11Pc6%c>-Q)B=%(n0_s%uDc5Rmm>b}xtmz&?c7}NNp|0#3(AeFn z0Q66^5&ogM0+y2tzR~SS!0(bECRz&%3xKQ-<5&%I;E4VKFXMW(0fIU~BI_gb4*&1x zRKS6zpXIqm8N()x(m%e~o8bLtfT#yf?VV2C}k&ENyUT+RPr<%DQgD zG2X`5xAXdT^#3;Y-c~sZI9eOX>H356zAI;Parjulp<2P_tl~heFbB(jNSfhAMJAB* z1@zn;^EZoLoZ;E0uVP&PHn5NVKk@Z6z!N{n|4n_)DUZ7y>A<;|KRZ($^SpnKb)H3M z%&^~Pc&?fE8W73+&a$WHknK72!5sIS!(pENN@5NoCBRxuv;U`=pGln2N$k)BvN*9% zaxg>$0DV4sovDJE|4}|S@+orzpnn>Sqwz?C01xJRoE=K$CE8S@D+ZL7VjTx?lm^;O zTy=cPsTcwUe2uce_n8`)@9)8J=|Nv~^E}-+Nzuhu)j7;{@aJH=>d1YNg0Yr0bWe@v zt34S9K)Gg>REa~q17YdpM&&|Ml6J9i$_P}46ebTQRyB26>paqgCWqvyT>0yu1=eX< z;eHu_T{6V0{_j%e1-@ew0<%eBbQU+jbHB;cn?mHl-o`!Dqg_mEWfrPa$`u3Dq55q$ zf5%6&zF#LMF{o9f$nHw?a-9uS-!+|pYFpM*tN%chFRIM$oOEzXC+5jeb?E{GM!s9d zkxdlDJHJTd7cGL{W(Ppy(#d(jVRDtb9qiMt#)0$DdX=4k-R%JUFhOaeAuh34rIH&Wf*442877@@aUN7dul@xA(mTQiUMKy7?FhWn#vP+ve3T;rN)Noy z4#8_2G1%YH0$suayx!4*k2(^d=z_2TN{6uFf^Jyjyx2|v^Ig6`1cJ5z>4w`jW%Yu`}BhpKC`#QIO!eS_dw*bvR6jtf=U>tp~CYt^-~50s^pgwZnc^bv??+f&4r%k$^hm41q3|IxB?HaqUmrXfX_t3Al}n`npw&Cj_4$a-1qEeC*Vb93q+~)Fuq=7sh7FwMZxx9 zFnSn6bVK7Fy(q(8=C*g#rGv9(5Vx!3eT8!Wu@8dSq;bbsXW@M=-b}%y%#b zB10qpG!T$+j((7fxf|Wcu=5yuVH|_sd`0HPbwZs&W~b4=Gpy$QO>ca1HU*lVPoq7DY%Dw^(+Lara4+=F90q?DXK|MG znEebF2h2I-agH^fyCsQ_=Jh-JY!}p*i$&~`k(DtNy$Q!ccmOryQHhtz1OuJj;hJoWLdQR|!k|Mr*?}~QBFgDRz{^J_9kG;O zWpjov)%YY@o(j#30EpUHq0p|EB@L^P*J3hMyI19QWteq3R9HIr0A7}1ZyB`!zfIZD zJ;z2~xo+jt@qUX-85R$8{PB6B4Lace-5Fi)g2$f8Zey|A{^rs&IRL^suvyj0w!~-J zG3e2-21OKQXSyos6qK0HwwERXUPd!Y^!B$ge}#X3z)_1YI>i4(M+Kf~=it?j0O)@x znZOFjIXJ-1fuaaU*$H@0I&I+$@H{~&++rs{5s?);KPaQX2w?Q0B=S*?2JoFhBP@r2 zxeV?A0R&NUQFbYS_}`>HY&iNUETp{PqrYn_x1aHMNc5~8YZXLGe5 z;0OTg-;Ufxe*s-0n40$KU+J6sfSi)o*JqVXqyrj>o9Vzn2Zb=FBQZdB+?7DV01Q4o z9opzAaQA<)E)o60$d#4$x-*Hmf+-LM(S;0keP?I3*8Xu`K^}xc>S9g0gemB=W5Bbk zpFp%0#z0kZ9ID8FmHVlwR)7OPo(^+$)eZp8a1Gh1v9>kVvwEi^0g3`B+J+IX-C`%; z_2vtBm4Snttm;=gEx>!a4|i1HIMW6XWojV0mkGS|bXN!rnA;qk&~uZ^2ET6xL6r*f zJiR!(y*zL4hy6Rx(yR2rwV5L5V{X-KD4GtTANnwKeQ$ImK%^?@g}$p@MtHRAt*5M5 zRT_xnF@W+MVD1O5NphfQGyF4G1)S+f0P{O|hv|Zm`=KYfZvfxX*xP9D(_9_EdNvgL zJ=#t{IU5N@H^Dtz9(YgIj|UC#qU*`8bFQDmRnP+8?b9T4G|HTfvfoEB=A-OW^{gMg z)@6a5JjYqfCJw>``*M=Go4h4E|IH}GeTLd*LO%gQdNaU2uu-Ttvne6#i%4<{QQUjOQs`U_P}ip5%Zs$-bRD zA%T984!G5!fAq>M&oYO@F{cU!Y3>6o6m`&#=HbAFOg@mKT ziwSBQ^+_3FZdX~=zL|S1UGJRv6^R1~O4Z+IWTJAJbDXMO#t=lqllLT8DZou^n94H} zFj#hJmU6WbV&65x!HP^2&-RH~kpP4y5b+3P5#cN1y+-TY!!ryX<#h!czvpJCTUdf9 zSNoh%>KKBy?wl{-4kEqsJVyW+Ur8r@0sauqc8rmD3IYqDs(|zTd~yKTDC(*gAUc8k z-s}^+PW7+#v!FPl^iTg&DnKcL$Jj}Du?_tb{C{0f@%4CLx{ttxI3mFrAUwdA{1c}p zz=5p!{pEs+2q-lm{(zetC1H%wNJvqLe>)n0acJS0B26OBfX~|z_@)i|gpGZlf3k_9 z)pCnZ{Q_eOWAPEcrgQ*u5*!2f+6g$+@}sgr<~Fz{CVc7l%N_dvkgEp%wKIu>gvme_ zOE0(4#~7)kFzB1vh$VqHe`lPAPX4cTL|`{p46qLEosI-tkq&^OR_ZAbT?Lu@pb!46 zF#!uM5frDu9~}|!?`o6X`3_?OP&{SUx6E^taUjZau4mle0(tIwtU<7x8oHR5F6OC= zz0!q}>RL_ifG(Bsa{7r@!#JwZ-SaECS1K5f3eR6rWzX-ucW|&opcNGYtVQ**EDfx^ z*^vOoRQ-d~0dfqO?;7u|eT@raQ$tbJa5QTFwnKny*T;+vxHZ!P^*^N&idMqNKsWlN z8{^YGm6Za~#fw16Ybo5hZ{X5vkA18gZ?9PDPV-zDddW!SRwJbeTGnz5>`q-_e20qYCcHc|G zIn9A%=GhqnpTkJZv%dMqpbpb7)N zb5X`0eYC)QF0d!&x!)Xyf0lhPgHD|0{ZpTI-9Cq^DdptPNK&If^s9CsJu%H3%`*4% zjCFy}E}ouz0*lDN0`_R0y*ZEU&a>|G$n!i7-2(PyLFI<*gIUHovz*P5rqH`n%;6++ zJi)V1l(MHnleKF;JHeM>_~#P&uQeIDEJ>Y)B?rH8ndtuJ0KjP*{3{pxaR6PUj(`In z@%1Fv{3|83!#EZ6Ti?xGlTLFfl2uATY^286Q$5H=&v=6Wx|N1QcXcBl-A$7MDGkRw zsFim#{F*Tt5YJmfuhhy)0q6v(2mm*Y#xy#0urOted8ZKcauD9^lhiqRD(d7UtgdDX zM|Q2}X+`->A=*n@GRzuaD-?n1ymdM(AncnE>`e@?z-IzT$2~;&qBKEt(NlKB%QO&J&fo%Z+fdleaYlrR1N$#x2!W~btPjwYPoF=C{nO5htFD+(sK2u2+V zkQ3lkKsZPb%XtbgC5};4N?>eSQ0y%{V{iw&Z|8sc1J3m+zs;!uo$^2G_sCH|aYR3Y zH`r;o$d1BBMvVj(RCPqFDmsvj)_2?alC0rCM6ZF1?0}+##R3`Sg39ls*wk&YO;`a{ zh5RPxIZ6iEbkR1LwFr`+KR8Om9JXUnN{WKv+yhh1IV!;O1cTtCof?qQXFrvZi}I%uh+FPW984L-RKDKMz)c1TBF9~Y zjKYP%XDz#q$jTTIVX4EQN@OdWOeCbLf$dHU;BW?+5OP)Jd4pY3X#nOaSOhV&wf*c! zGe=eAJ=zY-DPT?2fv|dA0turh$1k00RC-{9i)V-y!}ndtNjDC2H*4CxSJowWBWvB4 zn>lb-;{s5^J#Te-fcy4*Joy6DPoU>VCK2M0(u1<=x$^<6f*7UV#~Vi=E`i(Z6!6~Q zQ$N7~L4{IxGnW9mrT>+V1SssU5G>C$@CoN$k@0~WG956;8V&B7HQR$I>_H6Z;OYMT z81uQ$nlkvxJnc33%n;)onn_C7zzBTW?17h=AAq?ULBEX1h(9(@^MN8~-p6)v6Cn1< z*dyKg7hN{SJdW~gqpbUA)y#kxz_H!kz80An+6;9C004jhNkl5c^51O~6%aZz}!*!n+BjwTT7UbW0j4g^ODs<7xmtU*bE1wN1{(He(J{Hid#H zqX4>ubbdjGHbsl7Ql=V0RKuwV2D5i3N;&udP!1JNc;yee6!5e>iK|4cRi{n?{t)(p z(C#R=0LaM@BJ4#Ja1iFm0YG5|2v0`yD4&Wi%ZNY#;8e}9XF58q{IBgrjsW~2Qvmlf z);-CmPLyOY17dW7ct+r|ciONBEO?n6fbVCBTL8Fl06yzykYV2?`4!@{{|p=V=j0d) zx7exCwXYoj6j0$m{@+u5A2|?8CEQmYh~W*U!P7hkpSLrlRDenZg$=+sMtTGPFsrds2QnIMggfm7d^7h`5C?U+ zWN>Si;C7=y10Kd6p|D0?sN#stVP#@yeEHa ztiZcmInZb0zs0|+lHiKO2Pi!dDFNiYI$<#2pIsdwkRZ=gy(6Omv9ETzl0cXN?K=#r z`UnIs0LrV5<5NfB)-UpjgVR*~k0vBxPt+N=8j}dD)QvOTJ!zc4Z(P1~eUh03fsmX5 zj93q2>X|lP;PYla6QJz)HG=D!KMl3nWCL5dudQ7y65EID%lFapvnc2-yw|d5PuKh zR16{CL&v+9!0k>GAP?m_F#=XaWlO65GF`Q!< zsxjdJE>1oGIRkPEqHjIlJ2sXrZPletC2A8q`^1f=!o^rj<1EkM9L(Y@&T=B1LqE@< z3+HumX5JUsPfP6iW$wSi8m%CsE3eAGRi?MBQbF|giXs3wPiyFlRn~BoXJ5m4UBjta zW6jq&q;2fT7Qq4yu61U_U`2q#S#u7s4;GQ{dGzEwGCX&udlCqN&-zUB*(u&Xh3ros zWW+veJdIN^^ZzoRKZhQeMYqm8G#doXl(J{Q0`tCzoGr2E7B5atg9X-o5yQFkU`IU| z!=iwKto7Wp9r}NDQVpwwP$htq%<%*=&_qU?kMYT0X#b-P_IpACH3i^|#!u||VeD2z zQ2?F%*)Kz1u@k^}qahIbYvBJmx6j)5G0y1tr<4`*(YI`*KQg2~8NH0Dm+w(~?T~f8 zujd73-PB2+`R(Su-R#jiG83Kub~qx(ey%f5b?l(pd5EYH zC3!N9FgymlbaDc!6t-12wh})(`0~zg_=GZ?wfkzDD%#s9Uqev_^P57kZ_f~Rfrr?{ zhTeogZ^F1+h@{3&Vh3v8Ie?LJ-W1pPW2MHVDd0y1s_ z$?=)Ul?yqq^ngOrd_Fqh$*H&@fqTIS$n&+KklTKhhP>_H4nMPjgPxW}YJY}v%8WC* z20kW3%q4_N-R=nYUmW6xg=kk%3-g za9FSCA0TIdy-^nd3F}Zl-U>*0$W=!KloCJ*MgyTQ88CQ~D+p9F_-~U4F^@eTHJQ+f zjuaeiA|WZlRhL02Re)^we#$t3ueq%7N|y}sjD0gM54I2Kk|n$8a9Ta3aT8w{g~IoH-f)v0L7<7sinLu~%n5 zfS{zk#hd`F;rLsV9H{wJQv;u#9RVkKmMKoE)6DY>^FPb;&!TJQ&<}IS@B(^sk=K_P z)AF}$^f6@1=$9q#vxGCg#Pct)$5)=|DgmMSan4qd-!GIa8(fbh1i3V>=tWT^IqSPK0^5-06V_C4Qh)&V^3T+Z<{?#Had$ zAK(n^?$i7}JmX!-y&!`hQ2|8@9+#*8!r$xwJk*f@IXuD$2;Xp|jsFSh6oo^ea=|z4 z{BQq(vmFr-KA>VJNS9Iq!UTNRC;zK_`rpOTfIIWqqij%@uorvU*z8@O3Uom_lx+`A`EA3A zY`Z?OASFHvf-&&61ONsQP_L^xfX&vv z-RS_v+HsOo0<2Xu6*|+^0-tgu;6Ek_!YBn@uu5H7t1{nRexg$XhZ`VRbvgifh+YCb zL;1L!NiBT59fSjn5mnMQ-5pO_zjy%U`T-;lY+Xeo?STz_&p=FvkyrxRqNn|1Hz zp55q>ZpP7#BJIY3?M4>6aa6i*G(KQY|71SY@-)f^&v5CJz=Q0;o=Y+| z2QY?#+Z@il)=>a-+8}#maFe+MblPLQgQvNauwVxP`HLO{7^}wPvQ#jf00GF3F!LX} zXbi_=9Nj#Qb3D#H#!>X+cR2hk(BG9A85rZ4$MktN={#GEhUI4v@tiyfu~MmMc6 z|10mvaK1PLR*$^=4u(oWr;nxuss2S^Q^%v`elYWnlAmfTc8>WP4HYzo}4|V z9iw+;3TBk~9DPA@G>i;n{l6+a#QYdez}H*?$N_rrUx_J^eD$;M`wvO(ir%_GefL&9X2=I{E=KG`escCMXm?p^y{0^)1ztJ;wX;;o^Fs<%45r_?#lP!+vb zWgaU7H~?|t`ecT>Rl*modJlAt^pk0r)%#sxZ2niL*&wBWFP6%@r7v&3pe<0h2jy8paZ__0cdoE>=C3kgstt^1o5>oPi;I) z+n?(uwW#9>w$V2oE(Df=u1%v@W(X{c5qH2zY zO^-4L07F|sUc_|~6)C-r#wZoQXG*_yWx#6<4n#==f5X+r0$iNH)!=fNN++Ow3$pj@ zH2#qqI4Db5qlduPj1Ax(ohX=2fpBr8I=3f*Rp+%?y;4RV%RG1aaY>L>W}QckiBjUX7o2lsdZnIDCdX>9P|Jd!E>AoWvzOUy&lHWgMk-4YVQGgg6ie- zz0679vy(wB$^)xr3gnsk&vkj#L`DGmf9q7h(@YM;^9-D6TmUC+bq)+CVBFUZ0|gH- zMgYfYkmnoxj4KD;@Baz;&G!v{+NFdTp`m+{ENJ*GTt80-Kx}`b%-%!N^#AAH^^CRou54g4!T%=t-bvRH+FW|}=c zqbLCTcMfATk8IB?RL)#1p!*k)(M8s3kufZwI~I7>MfCgSHj^v(7QUbIUIM<1nzu>39*tx6Jyjpg&f4rWIaa z)!*!kWo+3Z<6FR?pFbn317`Vs28VW<@10t3BOt~$vE8kJKk8_TYX8xl<4V2Ytd6}u zF&ksZ%qY5il>dzi;5n4^&cmwyK$aVfc?jDvD4Cg07D@sB`dFX77aQREa7VSi@BmB< zbKQNH9pld?hNjLO1r;~4Q4>&Chhf$_8t3hm>G9|ida5ga(CccX7pXtwD|(C^hyzei z9{eA9>XT7xZD%%pccJnqnc$<)FmLQe|f-`lwCc+bNZgX81f#;ZO7_UWQvCeue*qSwL6>>?`~+ot0?J zq%iz0jsV>3G{9Y6@7?X_JjaoM=j42Z1EdJZAs)LTA@8%}^D%#qQX&Xw00r;6>Nfr} zcH$HnPzfQz8Nk3B9TE7ejr_y%XQWxK^y_k5{*-BhqGUk^{;9?ReB5aOIYcPMAPkZd zfWincsUiW)P3v)Pb^aMu*jyG_p zmk9ED<%zBekQ4ARI{{;k4j{AYzFA=nD?CSqaj4fo^cdLFfI&WAMINfiLi88l1Xg8@ zYsW=7QC_T1kaE2z%W;D^=pH)(I{h;bbsV-jG9dDx`aP}`xHEAAbtyT%ubVmUM!teo zkiFWy$tNMk)5D$!I^iP?6h!uWn8zL*!{9+@kM!J}d;&o)jB)E_Y`r)ry~sfyPG#Tg zOeKsA^)t88G)U0^6m>twG+GEFAN|NnbPZ&@1L&}Ub8PhceAP_Xy4^SdoN{${i?Ttb z1>R&H0rY9~7Wis1zzu!cUE%(f<$}Y!fA|Vl0=zHDWX8DnIP=@YxHZ`m6Eft;L{s2C z?%iY@O=PFZnl^D_nmA)k*0hP!jdW1rYNd)kX1V3OCSIP^^O`RN-H z{5H#Y=2+i3=6e49ZV`N*NrNz43+SN*o@wy}lLs-^OCL`zfh7)m%jae^U=@S2CgYF8 zw2m!UW9+M}-3os%b3j@`b{Cn)1vwik*W+2|a9rp1Oay;m6Z8`qnq?o)T%FXsV(62B z7kWR8yrL8zPo)3Cv58}tU>zp;o=NoX1mkI<3&yciO?Gvp0k8Mu|KoS`LJ#_=8@*DW z&8oLLd!>eMt0CjH?w#4x>p++FDy4^`Q^m=PJ|fZw->~sV-*?@L1F(sS-1L*A?^P+7 zTF|y`&6AT9rW)diBu61+QRb=zu3jr0>Jw}sPe##ey^uNl)=Hk*L{L*u*#ByW{t>uu z{mnQ47GM*`xWGgfFmQ$Mr4bUfth&M}d>$t=ot&jOdA~ZVsdZ|FpVe0;7%BM6|K&U* z@2w$-RTPXGqo}QLS5Hbohj$G}zy3&3VBDZl?7gUe6?CEhDkdE}Lui{PLa z2$PKyL_n&75F-7pd3qIfu}UeUPX7tnUm*;-4C-z+fq-r}xy0^~&Om1`CEP({Jx?O43Tk%f2o^e@A&bii5u`9&LlHcNCDL}5pIMA4t6 zbONJtK&gj6J2HS0D`H&47#WwwAl$$ub{c-S^S@YvYm5yz)J}jvgv?RPsG|VC%_vL@ z8z4#ql`_F&kA4F0H6Ty`R@PB{1X^|S-^Xh-mbjOw3J?et;}hKkg~L!KhQOS6CJrT{ z08R_Unkfx1o4ArV`J9(Lz|K#3U74eHPF3xA{_QFWM9Fnrm?eUphnWzF z@pZl~xi~r}Q`S56I!+L`jrSaf;wd_Y_chAWmx+^U{SJ zbTQWz{$F``k_c7!&I;>ULFrdsXc8gTH7JLf-^%x0I`|Kl)C&A}ABVtU#s>%-ctq|w zMc&k2Sm8z~pr9PZfv+{~1iZya2$X@Q?f1 zotf@?&poG3Rh_D*p5i1JEM+LwfsgoSIR)P{fC)u5$nypn+u(u*ZIsm0SvUi4IqiY~z9;w+8 zK&Oq|=}3U81aJ;VPw~b2jWSQ8I9<`eg?Ea+?mHY6_=S!C0d@qY+)(KASqmQF|Mw$r8YY=b4t5XSaB63;nh5b#oXn2g_TGM-Y$?d0YHdb`F#SpdJRR$m1Gw zv3_lG7l^N5gL|z%lfUu%WmN*4nI(e@0u-{Z=6UWM`(^Hh*+DTbf2G=njJY}fK06pu0Y&cS9lc|| zD#&Yv_p9t0pn4ntj7kxKD6$#bj>;2Wd$*C*S0>V0A@4R8rcH`oC~O8K!k@qksN`?O zh--naxOqo^D(Wx<7p1XKzF(pL0zz11@rwvVamlAmDf?gNX|Vm=1aw8-_TW^`IwhBQ zfu4>miwczUIjNZXglJ^p)u=@I|LAgdUV@&2qhNnm0iZ~__D^hqLdyYqJHSrLAKbB! zjopU9P|M;r7P0Mpb_5j3*ly&#!tDrS)U7KI{RHC|5SC8v+bKtbMeRgcbfR!Nclbn! zpauQxD-AZ&$&t?o+uWsG2xYgcECLgN^P)Dk!W5`$UUVvyu|7JZ5fQ0CNw@vPr~cnN zn(-H>0obT*SK092Y=_})f9BWuxd0G8z!3rA26nR(@ZgLVgkymr42%Hs5S0S&;yOE> z#Vtzp2oIq0Nku1wj}S&cfI)!;tNt4sH$Z|q=_~cZ<_p3l1U~u>h+t^kk%Oxyw^%`RYl#bz~(fJlf0WjK8 z5pYvR0>UAXW5E0dKLGdYLbkd-YUgbzBLU$Aoa0IW-ZO}S*knNxq;%MOoXQc171`*1 zza8a(4YW=-D&g( zn45v61PKN{faj=-*&xPY@Ph^lR$S)90cDW2ALOJpc%7YqcRDJ7fgM7}46#O46l_(b zDFRqA#_D@rL;Zt9R}Z6;hLNY?mf6+*V@H7X8o@Y@EV(Wl`54{HX#oKQkFrB>o~s3> zT`{mdF#+KKeAnfJ!UwRY$B?NSdZ2c^DTIIOHnDfObueR|kO9$&k~N-U?WaGNr~3wm zxryOw>I9E5X&z-JJY=N7dp41+CTrD1M>JXgCQeX-Qq9|w z(|(runEi9o+s?7y=66jbdbd$1=KOg*8~k z;a)>eu4803hD{!%Q#bOxjy_t$!B|C?EhCG|y!X;yU4PF$THxOWY``M=X7SV6r(h91 zw1{q6Saf9KW$7F&@|>k3Glj5nRHhSFSj#1q`0>3Zp0|RIT01;@4G4R%$-TECryEKE z@Yz-7b(u9^VoevAmxX<@VUQXJ1p!d68z^CL=l<>90m21v&nENHxH2Ov)7ZQz@iqJ| zshKBkObX{H2Sgsn_ji*h_Eqf?=l+jOOo<%K;gvl7M@s5vnU+$w%VC^~;iot?fKDC8 z2^q#l3?qNlJ6#HRW^!SOF;j9s$bEu)Lwp=Kg9H410KFxWu738Gh`ofFi)tYBcF>7G zUk(5hT124~kN5T4G=?I)36Ps|;V9HLZqoL!G=_m5M;O|fjNoTSz@x{zLa_JqsqC!= zc%7UlH=XW_e5Zgg6~5zCz-$_mpm{yol>;);s?&aKhU*2QQ+_-^RZ@Ul(I`kKluHxT z(0`bT4Ooc&{W6cKQ;#|u_B=FCXI(r~oCg9sYFuhg6ru0u+X+A@+HeZmPH;p5CD3*% z*GCK#)Jayry0@hf6H{H3FzUo9fMor@K!8U()QkZRE&!Z_E*2(A0hxy`=C?~_lPJk< zHbXa?ue)eR0O1w!Oc&1+Yn__ibm+9J)3DMHpRyrmUfRBFC*USuzw{|zr+;7HUSIv$<-Tz*Zk%Q>H@LW3pO1)m;b9Za4XT?H9mRBXs0P$Z}6|KnUmF9$Yv7e+5y2&0g? zn6K`)7zZFnfcK4ZPCna>QV4zr;ZAr~5CmB2-23q*00cwR}E0oE~^ z2_5Fs{z2&^lz3)|6L-&Jc0@mn=rGvK3Y@?Ps9X@oyZ0BlKY~0+&H%DhMuyAVZTP?M z=m6s`^Zw-vT{m z3A!p62CJ?ZP}$&PT{WPTz_qCytL(ihhN8;%t2kX%=Azo>FzY?06F$knK=e*@7DRWA zuzn+~&xn-ukedhnI8Sb)=&4cUQJvaGan46CbwmJ1V{{;me^d@AB5+-v_<~62vs~YG zSs-gye{nVnisnG*!U^PT^6^>QKlR3J@-u@h%;@BQg8_W3=j`ij%o$^ogTyTIKZ|V5 zBJ0hoGj~19+|FVw=9t4-oa#CB^BnUv$9|qgj%G1%vv+6XocP=;-7*-RIFD@2|0+Z9 zQ7ZUYBkpCOFE%!SJ+#btR#Yu8>4rhf>pFki__Q$q%*)1Kk^m@D0O*hvbmj`WVP*dW z8Y*AE$h<5vrX^%*sp6EwC5b~2anHit>3}RCXN$+VTH#PT0Icx}-(SYIEb|U4=-XB1 zWsPTUprbZ%Ubk|X+A7E7hweFmQC#Nzmp+}5jRoXFbF~9~^*#jmm$mFTPw9>Rn-A<-Bjn@T?4f5rb3Y=b}Q(&&u3= z7zZK1G0aP>bLWCZ_%0 z=@>+}K%KHs96?vi&%G$X^6L$3(y0R_7~RXZB`~leMD(9CpITBmp>p&59DMykpbJ6I zVg&;J0H2;elo60Njp-HsmkDdbi)_PlYTM?Bf%4%$Poop3%Hy2>$9P34ARA2m6{0op z)d@1|M0tuPIZDo+VMD?*gJ|Ys29JqY=1a~QGj7$Kcd>!G5KMKx3*LOK2g0tfzwil> zp3q4jPq9sDoUhsND?;#9pZxW^+x)xV+vwkEXW`fW{r7$S(4YOGf5s?8siD#VN)ZVl zsJYX6zShwIo$%RQ!JBZVf6seG+Ti6Gu?UhSMFiMr!L%rc0Yx1A3Q8L=9|3UOi7V){ zgQiG_P;wKfZ+|ICIJD3t$3rc z8mwJs(MBJKrIT?)1qU0X^A-a)Q6wV6>UxJAvtK%ObE=Iy`==X29sM2HY~8$f^b$D8 zPJki-?3L*E@Hb-t9_uK8$^%i%>Vz3Q0W~uRs`>@_FWqdufN}r(%LKzl6aYifGicnv z&$Cjdw_-=2`d>7{stP#I7i*;!+vQ`-EcjZp3v$1*LjRmtD<3pI;2dKFn4=2!>f`f$ z$J_9~)6M`!Iob?=*8eI!_wNin_J6=cU95LMdta@F12D*Q1~}af2*dMsrw7h(gn&IY zz;gyZn5lumhZ!LF7}q)fA#nrY7;q{aWDTP0pni`L8G4#a20xiO(<+~av9 zK_RR#FESV%-Be15?it(HsetEYH^KUcObCQxpFl57{65Kjrv4}E{Z-C4bFgdqugp_? z7wB2Xd@=o${|x=IhxJzLqw+t8a^acnk)0pPx? zyz?r0ZTX*$LOjR(|6ANSQ56B`v({|R!<^>(oh}LFelx$!DvPNblB{Whxt};C(>QYE z#(7?SG(ny!`5a?Ej4^+s?9oy5;s|Ru!n%$eX%Z^-%_t60w60b<3fnrub4OIEf_@&k z)=mO8bVS&JS0}}FmCsZk;xbwBWrzzv6*kP-Ao?(v0pI8Jz+R4$UulP&x$Zwz4gkVj zL{SzoR7D0}e1>!M7{elhBnH1Q+<1aT3{nxr5l#bwQhb9W1~;U#j#K~3cidaf6?Nar zQ7dQsnlz?GHc9~nSGe9zfa=MWdO$$i1w_OEMbjAWEn=7s)oiOS`{fzNSBNy4r_AOl zMr1!a@dsTglil~pRARkCSN|?q*Say1UBv__s;z8PDJT!F)BYcwD_5FARRIV?8xz@v z5VpOF>+Mbpe9uNuhUNna%5k;CL&|#NK&v>`a8`GF~VR)h~ zuqqr-_`w2*b0HF@Zax=?@}H&g2p}Ny-?@-ROa?H(cK1t%B!H81js#rq-!0nsUvH=2 zRyzed!Hu`uVYt@O1AX?&|8f{^_4nAMZI@@X;a;P^Z$?W33!&7_p+4ci)sB(M2M^hi zl?g9!q)5LLcHk^K2s?2D?HNUiz5^e1MB!vR5=tQ`1)!<|6pl&?qkK>m0nfIaplrqD z7|emf1t2H)wjP!fz*>keASx(W<6vt<0d}yC9e;Lu>5P=E0B$n3ov%sY>%A?Vg~ebk zqlW-;*M+=vv2nVX^R6G+@E^V-87BXok*e<9jql*+;0;iT?33*5$zee829+@5Dk1kJ zWTJ%ASVHNSm{WDH6f0+N1hDQUluwDxt%h9DU&}w;2SP!}5tv5n%Mn&o+4w>l@t%QRLBMgMC}Mz{VdruXGxCi$UyTt^1Vg zKiU62*Hr>?29V9Z)hs>gXKng%Jo-BxWc$*^t?9(aMVp;&dC%d^1^VMYS zn;ar$UzR!PImR@{-{#+v-SXx+na*({o;y8x?B`jN`SWeuag65Ijj|t1irxA5_pFE`kqm;X-?4GVIb36Zubymvfin`cx57NF=wy$6Sb0%m4Z=B4xgh&?NgzLL z$MQ4sdlBY;Ksp|4e0S{#F6Momx!&NNHgSHoVk165s-p*b z#ufhVb$QRW{WF9uV-P8Wy=(wfYmf2hP$;}DOR=K!8lG?u6WUuqVIhnaJmsJ;RSDpi z62UCSK=GybzB3i3dbf-4MP1|s;0y5C5q1D%AeqEAgrH3zI}}D6g4m`KMkYS60bfZ& zrizG;!;OEyn06kN_v|<;u@BK1kb6fz1YsGzmyrNf19Uyl;eQNmw@Sm_YcQFrDi}wQ z%INeN@V8lXdncNs=GTMx3)#_JZtV&D^$@4v#vduM9ko9VcS?Jx|yes_)k zeubR?MF`gHJbcNYz1qK9&Cdr@;y#WTd_N-z_ksprV+ZaIF`~?E{8qN0Kk7{nPAUd=EykG`~Z^sMW@PCA%L9p){;uN{D6!M1fkXe z`Ezt0Jiv6q8|Dspfx$wmy1`IZ?s65t3ldcvz`%QwZzC!M-s*IKfPt)kPy`DMs1zN_ zsh@lGvw!-_JCccvJrK==&b0Ao-wiz6#3d>x#F>ijWvs~n?=*0-QwGS!0J0oyh;Mad z04Hg1+)lu+vSey#KUV~>-b1$;6Ttjd4{^B_3O?EoBR|!W`2tv@VRXtcYctF|4Bu{L z%Xg!R(CLl}p!7$swxSk5@PWxEpiXY1iV*z4q2B9#@_$Owz=|NKhLNnHCu*!$9l5O! zISueGHwL=e41gG-Y36GN-P>SYn>?$zXfmJ2WEfv{@*>BX|5tX*YrWSY>+2lCKh>S@ zShJRZcIf67^VH&*E%ssS82=r)YVn-~9MuKhf8oo{`+tZF*;`~ime9w`y!SG5zQVh# zu!bv@Y~-_wjIFYsYpmlM`(vGPZs25WGUg3*-uhK04PyS+tBDaxTMH_$N~ywe7rct?t)lx@*k8*S@Fn337)$HbnfISl8Q|WTBAG+RXV1*CNmT$enBN)n z`t+wWLL*0Q^69J@dTL@1pZsyUYFcLw6*ZiXG2S;gBZL{@a5;*t7)7>5Z?sIj*-<0* zeGpGArL!=GP8vhD#*l$AY|N;DsmRR8|2P%Eo>CL6Dvp12z{Flvw^+WJ_aSt{5Z@Vk zl%oNRGuSuTRGF zwQ-`n*x*Qqnxho3nkU3)Hgl$dVZ3KIbKQMwo(v-;z`LmLLKo}N$$NAtGSbQuv9Jpf z{^v7oH9G@~KIQ+&&cHQ3#b4`az>WSHVGB&dtbf*b=j{O8@?XxuWq!tHMgbx+&~n59 zCr44Ahz=+%!JI^zK%l}$+VCIhza41@U?+9}r4;3aN&yH@!MsOl;j8UToNgyTcmm-9 zR862#L8T*9ifImkAPIW5qfTc!9Z+z}N%$0$Ts!aB&U|$IKQ2xQ>Jbp#0)_U+JMKi` zsVYF60r5Lzu=7!N0#u5Me0DOPU~^P7;DD5&C<~Nh_Vpdf6~J6|l@0PlNd(<9`$_b{ zT|f8d1o}j-L~R`y0aXUDf1*SXc?nJd-cgkWkrH^H$%1g2O6O%MtGWsH;DGiZ<2_ZE z2qND-e5dCQvj@J>%z+s0-W3~v)~ELrrv{diy|b4+RoE~?CB^<<|83N8^;{`DL#)_$11Gkmr4vW$P^egl<@aWAE4ae;s2|FB$#+K3_OB;~1-P_SVFH#sJ`mPb=4q zTs3fHnw-R&UrT;^871ZN=k7@^d^OEkV6GR?KMTn90tRdW9kH<8J?>fC1@zY<<6rng zp6J8S<4`RepDcI_%=;o^Uu54bp%<6fyGw)FN_PoexBQtT1QM&>3iG?dc$cqDD&G}! z{t6EI3Uj}DU^e?%=boF~Z$r)i266-0TSwP#um?5;$V1Ps^PTlCr86M#;5u`$rhDMf ztjN(oR#z1{Kv%5r?kjK0XRopk)|lgU_V*_5y%htwiC)`$dg2bYKG&c>^xFCfNm>-q z2G())plo`i%7LZVWj8?0+dOkVhjE?dJF_olo|)HX%Q%apGXm4-ba^FnFkQ*s43jsw zRr5vbbjP;QhR2~!07L6^lvgD6!I|kgLD$cbi(J|Mz1wz#HUOqg=~$nuf~3C z)g4uMpR#3O z5Qrk1xPbRj;BN&MtH5R`eA4$|vld^UPC(ncY-nyv#ji5Nzy}UL^qJ9NxL9A0u zw_`08)Mp<}zFvY^j4{VdG`n>{KcKH|SCY9ow*cnS7! z=zm`uegrfc4!yvJ{b(C`RTH2bx13_f;c$QcsdoD0C*z0lp^nBvT3=NMe8G;u&ka)Ta9JP&0O7 zB740&FFFjWB8GeQe#9k%y~!ESt5Vr(GG!2Hf_;n`Kyj(NU^fj@OE@f}$e zP(fBI>q#!s_i`@gG1>3)5N zy%ik>r!!wUzWL+95#zncx-H=hE%E&&9FQe} z`Ow9SugI=|DxnLb|K>!~FF(mO_B$MoM^08a#jY^t%e5@!TSn%V_e?jH%J8iPxH~8+xk=Z+714FdI+HbJ0Ho3zE~LxVBTuwFCl+ZjGL^TH%* znnLePq6;RN^YMF3|I54AkdHCeWehp5Ne*suuL$%-{Xty(u7++NLte(%t7A)c5xVDJTuNr8bB5W2#t`S&6MTI7Y5cUQh$io65wsguul9-sMH z)o6DgkyOO$T3E*GsxXE=Jg&aEEI$(Mq1esJr==1Up-ON8d@fJqB8`a#JIee2#;0VR zq=f<4+l~N=q3t9)BrK5F0(F{I9==0H{T+Ey>^LD$naVqNC{)j9I~Y$;17pxS5dbk7 z1`oi6J}v&m5da~@g(PRZ-6)KpmQ{Ly%^9RJ;~8e|(rNX1S=uIE{UG#Nun|TfwGG-( zU+L3(pB;l08*lwyRU8-DQNS3sA$V=${@#i>KkT4#F2~^gomD9vBH>B2+2y0Y7)n z4u(<-0u|!KL^+`@RazWm!!9HLQl|-&9(tUk1V=bkz?ue4vE+qk1h7<5B!LSVM*t1w z2&igg#*rb`DEI*mPLOH)u{*M<5VF)RN9`1+lWJMY8ZCoWx$!>ZHW;s1ErZ6HcklR; z|NTljco7A7knsWsS^mCgCt!c$0kocHIkoeUl+CzQI>;%qOHrSb92rn0!L-u>!Uo{{ zLgTWCs8_C^6m=^Hmb?mG73mWI!Nu)PtP&FrPilT@Q{@Pt6#B?(%UIKQbyWlgpa60;xy5po1q(MK* z)Ik4N%^$#f5A5#p-d`FQ!21lK^akE&9s%ZbfbR_=bA!(|Z@`643vjPN?mhV1Bv6S+ zz?H5LP=o+ytIGX{{+v0~Y7ZBGAKoKFs=*halB|!r9E-V*maGB`;s6cvy^&oF8hpPi z1#nJB{_K!0MtYR@A48XnvCnFc$a?TP?@xP*~q7oW&=TvsG@fjKJ8SzR$1mg0dad3sbM(vSCI(>X?TMfd7Cq)`@!I_V5=L$XW4wxP zSYw~BqdPY)aKoVeGw;8SgSy7^*Ld$W4k+si;-)}rQ z!~5$B^*=tt{2R*ev)8t<2extG+Q!^(W$w2k&zsEWhDs7~npTA`cv&(UF1^C-fWPCD z|98`Qiar95bHxN>nBB)Ae;NC$Ot!=xnntHiW4ES}t?3gS0YH~e;yg_t|KpF!E`T-m zPL27kp$BU0nfeEl^r_bC7QwtreavJ~?AaQ>tFe}K9HROw6B|-P-fM~o{4T3U0zmk` z=B8k8sDt1LYdZ46tQZLARB|f7>vt^IzcgJoYZbi&4t1q~Qfc3^1JL%mRPIGS93_Dd z%R2o63laDL40?eN7ZLO#Hz@MJ;-fNjU%&_znCJq6T;SnF1}|V;bZ_JHqI6Y=x5$JP z-r|d&3n<~j`)&Anb^&21AeaS|Z&9UpA5YL%lx^X?sfkaQfP752ItHqdP6?suQAl$# z!AlkH(TDNqN5P7>y!@@?O7FQS6{z~O%W+V17?p&{Pz2a)FGm4%0u~-YKPxhT(r-K3 zP5_Fs4Np08-*bs`5Yt?Tz-1`G=zSogzl+NPnd}ag9WoAeqEn9q(Ig9qs0c=I%A;7i z5teR*v>T<+{Vj+8Q5Zoi^DjpPSm-DRWJ7h}P^f{92ztWkDpE4-6Z>|b^uOYh|GH28 zvwpXtPwt2ggCX{`DIUPy~2p@1~Iw%np z*w?9nM>{2e;)^mxyx9N}Dnf9GBN}ob?#{GKI0>(Ds^H8_y+oN|ubqM`Gr|`#lXQl}{ zk98zRPQY!(1niTk0Y!qMY!KxU%z_V0(5i@>x>(~b_Ei@~H+n&QCvgM86L6dj|A-?# zi;4dzA%op2{bSBb?2{5FkJ79w0+6|$2bwnkBii!`vjhIY)W8Rt8kjln!MOGyN4<|X zh471gJs*931D&yZV?9 z?CVIt{ss`9pWFch-*$Dt6HF!ivE&FC#5fKv`2_S5Q>zlj{GotdU#*wUC(tH*3ZowfZ-T3S;0SwTWYSa2177PkaGFLTKvl8Fj{@0sS8@l7+YGyJ}R{4~%V%?n(=&)UvyCU1W0#^lCd zKnE>wzlDn(;zw^R2;j#1F8stO{?pxkZ^c~tau9AZzz?Tt2_3Pd8hK=GS%#B)FC(+d z=$<9?=OXu9#Nl52muvoSx|_7E5>m1wYGFg>`FHLwSuQ!t_nXLPgU>a1<_v$EM(mm8IgZ|| zanP$V?mFWgN2bS-v-$-|5>=~Z3PBB|R6#KIP?Js}$7*5~_!RcoaK)#8^hp)nP`$y# zK_5*<%%O8L6*l-)pZ?!rQ0>9tbnlWNI2i(=`d7J*a9Q9BGHhQ&Ar~>uZ3tlGkx|S= zUZD7FpXz5a1yJbDY669U+c~jDvzJ$8C|8uf1-zib|FaYDCN30Xfm2lhZ=}HI3T(at z!csgaPlO70i&Ur!MHM70SNYV;qW9p*_8yzSrt-liHBo62o|C$iiQ`;ACp9Zl0~Uo^ zyKYa#En3+2eaL!4ANcj%IAyDbR_2!cKzt1K#Ik25fkakjt4)dDDb zRh4w`oSJYFK=PgP*ALTTFN&}gzP8_RF3{~e$ zre`{tOYt=X*b{}Ju9nea`1y_$yueWc=J(#lLUIBaWAqL{PP=)2lz(!spcPi#zZ_j0 zpwd~c1ZYq8K!E{EzcXpjX^sF~cb~!U5lHsS$q~@=+a$vZvLHnQcK3CFQwDELN4b}M z7)^)d6ucvyf&d396~J@LD98#*sDj*99uPF5_bdN{|35vW06`GM{)mP_!>%(v-Qd9g zXC|`8I#uv_M+H!x{TQcyWVN4n?=Ki9Am#K_U!yJ`WDWbj<0ye}0=Mpn1}ITJs7OGY zQO-YfdEkX+4rG4}vNwhp`w+@>=oB*tDopwzV*}6&)t4F*@EU^xRc6IWHrfg^msJd6 zG!^=Ag0M#RGG_p5G=kGH!h8m;Fy9+RmPeV-=qNaCu-C^O0)C@Y0g3|f_xjIJ{9Ek= zFs8}7v!${-i0$a+ZRm$hjOa$gRR^r+8uGD* zE?i}=t+IEQdDkWM$)d)NthOGO6v$B-!87L2U2`wD1AyIYeA4B9?@q#>>4#>^Q+0Lp;I0oj4*>Idz^_$JW%*0d?kM9GRG4pG^ELDS@L^uy6vb!#I0#9Ou7|(XL}N z#=n(L!Z`C>XaCfZ(^|>pgWP-Uf1LtA7Djl#5k;pM$M7i`t*Y|<>Uqg|5$UZPToLe4 zR{=0LgL0N{GU?WbjI$92Aj-l<($E!uWl|tMTzqr3?JZuOhDNpX%CU;nrHB$M%838g zQGkhz1n76FosZLAD=(c&qYnUrP&m%lJAL|R0~AmY1q8qF+WbsW;a(OYNQNHgoU9b5 z5Y&vTq>#SAO&1u*#AKCuenm>=2}yTYW)h+YfJ*FCddK}l%Nu##6SFKVnEW2+Zw{2w5JL1UOtB7@T&LX0+c`2_s6mjdu;y{>Fb9 zVuk$`^5>py!|Aw07+>j_kK4HS`qIh2>eGM0Cw@f=&a~sB6v%PuAchlgh9dwwQwalh zI23XCnw=6E`Mc~0-0Cqh?jRic^^W^W6R+`S^iI3kLD=EwfT93zFlGP&j>-Ya-zQQA zgFuLTME?K*1ci-YZQ384l^T(PdU;j|L}cdCmZuX^2I5jw;2Cxf_-w~9>DYDf?j2`4 z$|EO0Yc2c;&O{IgA$#Ix2r{8QJ9@}%FbVQ5(P~(!0?D3uA0F%oz@-Kde#cJWeoh1N zw;+UKK7&+fB&!2T4^Qrk((~*9e994lOI#kvT=p>D=p%4xvI6#?%zLy)Fo->0u@i8| zeU$>yKY;&7x50x998|=Bebl>$BLl}fDu67NF?!|am|3vmi)WQTo%<}Df_A6iP?~)o zHW?6#vG2hN5DZp9^hD*FB<|{aw?EU7X@Y1d#P8HsppSLzyE=h`ffqo&`ca)=P{{RSUr20@I~AnO(FQxy(nZx3M@qpRSarVi#k)lN7{1$D6& zRo1zR(XO6mDq)pd@!Tr1In2F>ng3yAcvt{HoyfS~$ZJg;^aEE0oM;>X^E<|OYcI-> zZteG3|6d>E>M|4H=ZpbBekakRQzDspK!%)W_)Y`aY(6$gerDN^v*@om=4GCH&a?05 zN3*_vo)hDoA_MICIUM9UoccNLHHXodNB_(}JGu2+=&2S4be?ye|95uLi}F9#qs4nI zF#d(txi0|D%p!Yc@f``4Yt>8_tP?cy(PG~(Fuq0f^WxW%;V3n^^MH$Zz3~Wk@0QVh;2C0+u6h0afY|EH@9<- z%UI*>$oMva4Vl+<NDF6R9z8wJn$K~tn!Pp~ z0L`M4o4ikhwVy$5W{{a_WMm3CoqA4o{hMHKPvA6+w-UHnXAbMU^EmH2&is!5(hi+I zuc{87HGyuK;Jy<$AQNxT?~U`m;~W?!urK4h?>KW&NABzF-8%cQ_O7fVP&Gi5lQIV* z3iGpnhd;x`8di~+>Vko+`#I!~9Uek&sH5f}>k}=6FE9vD)iu2L!2d+hKz)%LMR}TqIbD$k74Rkt zD7pedRCu?;|7STBAO`@?sDJ<#E=)3_D8mzoaC;h7m2P!C)8MIlk~OX8b}KQ)(R*jI zn5l!A(8@{)=oBOXRUqkALb$ID>2l`pJJ^IlAoJP`Ckw3Brm{eVqxZ1`pno4{C*UIAM2h~r*$#mm2w@2X5UknRQ277b{`V^XU+I8be5uOf zo4y1zRQf`ZgB5>P4gu>LEQGrL=%@isLG&UxF&&<$BKWXV0z7}qgfRiF#03P^FyB|- zgt(Lvc%vON);<^~S;r3KEf^>FOh+zAr`T}O68oi26TBxKIhA!rH0KZl1K;clk7Eq* z)P-zzzRC^)8?f_oM+tszCqPlGj~f$!40W*?yI7+x)~#ESp2s;7^m@yIxGOlFl-T&C zeKU#`l>lcO7fyi?77C@GJj><}zAPHLZ^(Au${Kk#}^W6JL;{+b} zUy%X<2zh^z2}Rl9J;ns6tZ)za8aT-yL6k~`HSR;M`%bfAf3-_-S!cEFu5iETJD^H} zhuc};{=p`QaTT4n@ByL~?qkpQ4d(xYI{@9(kKXCWDe6b=qNjP?AizpbAa585(1Sq#H0_nJli zW-m%A;92B*4kJAGR+Ij$Wyo870OT;tv-jtpZw5g2XbY#Vh5WR7?F^tx7Le)I4>O`L zum3-gOSSVK%+!NY3QOpgWyZLIW46i~ts=)O=#b@ulR#(z9kzguSwM%i81KT7N&Tyn z`7&c(;ncc%WY+hqanI%>Z~z$RcGhe=C*sSH=gTp&mm@QmGsl-BKbNsLwtXZk4ult2 z!x31;SgtU}m1DVB+m-LSYT?cV0S5grbKBZ2S^wr9Xr6!8viZX7sW5|XoOqOsn82t`yfxD|<40#We;nBuXPzhKxp--xkqXOpSX_c;H5j)8x|ps+r}pUnz@ z0083fr~_s+4ywB^#wXlB=&N>yAL&xSF9m*Pmkb-D#1!@}R+6qaQUN+melSD%9XiQA zJkipkac%3&G(nUQu4VYY@FQacPV|ZK&uK7(DYzHxr;z^{P6wRl-=A%V;MH~pR+Exg z&55D`krX$Zr4z484TnUgQsNmsY@QxG++My@W`ZhGC=QKxE@Pmu*`!-*-fsDTGye8CLJ=L5x#ps6uZ&>p|v zWoZqcEEP(=-VOjtBx=f009}kPIs(cN@Lo|P&KSB`pr{YmsgKQ4dW{vmkm8*5x-NDq z;XwwfDZQfH`uj3e9t?k%+xW|%s_bvx4uA~x1vc<<0Jhix5V-HN>CA;wz*@Au#l~Kd zoY&gv5g77lI|aJONBrFZ-&@aFurc46g1E-U9)%H6fv@}bN;fE4pmdAU4=w-y8h=LL zQRF~)0HqS{Fn&NFLKJh53cc&UZ~>n&HUK9k`UkKvqv4QJ3BPtqKxKjh>BL6!CK-8^ z5%QdNMYj07*aD-{1S8rZtOc8|;|#AO&TCY4u<<)zh`oq$dZeY6`!xpf_DOv|P(aRD4)M^LyBHg%K){@l*){&oNq{X$ksCv%~!OBjk0 zGE?d>L*SPa=o&l$Ps#oP0TfiV0QCz1(+;u>yQn?M#D9KsbOiTvZ@00c0>JhClBrf!z!ae4!ZyM~raB zz(h}hmzpd{;J|ZSA)wTNfP<|4;P0FgK>mhU=b^h@A;6xjo@1gFMFyVdpA`*2&Z^8^ z6=!ppH5gWT7V9?3`i}A*(It?%8^iemE%wy>f4IJv`FC~kTjZUWKA-G=D;V+> zWNnSL*f=J0``cNA%aDo7k)tcnk5@2vSFndJM|Lmc9^3iOR`%T{GPTZl*I0*D#<_C8 ztV~$O7%ro`m(VXupG+KsN+4SonduL^H;W83zhK~>LjUOd=~=F$vLtf~IiCEc8~)s6 zN8ox#1GJXtn+crj$^A1$FoivxW~|d3IHy^ssYSOAKHgOWJa_}B?kaS6$o!U&7zDpCy1heTzjUmYkz&7{yP;u<)k1`pNv8P1-JQh z&xR=OpSXbHCFwXQtgLQ-g|-9;2I`*;RA3Hk?8{HKl3~+Va3Cs7N|~#-lqG->7DYMqU_eW+O(cHjS$Rs= zi7$);ixl1Tc<saxM<@&+o9DoNH%6 z-&e{&)dVP+NH^$IuT+2{5L<2VZ?^H5qp<1dFmV8xoh_g#NpGKe!4ghK~8 zq9i9k)dWvZEJol1loDV(K`YFCwrtDDk;(-l9e_NxBa1;2^fep(uh?)_rU8+HO7*)NxHZd8!iVV4noTAciAK2T^>%|1gki-^rN7 zgXFFJitSY4f&UegBVK*;}|r; zN(*o*D*eGx009K~P7j8m=Twsi4J0TwA_GbrpmckNTtT3d{(g1@R6W32M|VL1ZIPW` zKHEECaNyBS31IZf%wYwGpn^kJVLw$chHAuBIm%SRI4%|5se%IP+a>Wi>N41e1Jj2d z=;QBw2Xb-0K6FW+@C3+8&NqXo0zD@%MQ-3Xd}f z0rE5dhXfqTpe}KrW#)86Cwcb%GBUc1JS~1PoBFhP=N9rf&-~3R|NaI$5Zq&t-!CG= zi$8X!L1b)AAV8H6q6fAyzuS5D%aNZe7~2)h^A+g5%lX`8==|;Mv2D!3CVO#%`CP|X zuPOq7qqX!KGYG!YhW{5f{@in(eL0Vu&hh+NIZik=4di6zLYMjN%>ARcrr6h0=<2B( zxvC~>!tPAf9Ol2v&H>+pp>8Odx0Dmt|MT z`hcbbE}JC~T{4258bM};Z*#+-ql^oXd_LJkSm^P=Z#fc% zjvr*d4(<_TK)YlJ`0ZSHZf#6LfWQRyQYoDB+v7fYN`XEnL$XDM{D0uGzOF1C47>n? zR(oOHPdI_Xl@9ak)Qe@bUX-TOLpVrQcS&Fn4C1%J$; zUy;cC!{OecEccVLSKoq&03737?>q9er>X}k1E4e1oZ0LrpLJ6v1?ky6fF!tgGV7%?y?EtVI(MtGNb`Dh8fk9Hm zMK}QGIuamUfYMQl@~{D;azGe?t1~hdy&%5nr~n4L^GM?aP$r#9BW$%3DEVg=L!*=y=ad00!IVb=s_ziM?j~0)~bZ!Eb-YA za?yh#>OrP@kiQ=GXb=0ShdtTDvwF_4V<6DrkDL~Gxq*Plc<<-9x?Lr(kP(5v1gO%6 z^^carJfrez_Ymkv2Ry)n7{Llkw^GXde{>bZkW_w=>AIj2en4^x^zog(PunSAENWWP z&z|a+bAS=-!%+8KZ$1H~2b9Ac+L298zLw>L1CKY$*@-4Q;qwFBdjQ9J;0~t+SeHSJ z_8@aN$ofP}RpvLk38IsRSnHwl%@@FThLFRd-z2+Q!H__t}D0 zr_<(xY^cx=GpyY-j_WkCKFxlf;RN2`y&AkvgJ(4`STi>zlVAhG-9VNb_wfBg9VuXc zG%w94f=D&!A{;X>g-O*sbHTZi2+c1MOI?X&zv(D4pW14lG-kN2ZQ%cb&HNYB7qo1bb zEIc;Z0jJQNQx_#s&J&ZmZMxLt7S@o1mYYj1Wb<7;R)u6!R zlT54s%W?p8;%9M+%HJYD0si{mRQ?LL2H5S{&YAC#hPi-pDli!Z1he=wmk(a(^uZlz zJPSW@d0?mi{g+RY0vonx)S!Uj3ql~2M&Z2%2=f0T-e*yUffrF@7le zf9}Xus1L~yzw(SY&e*|KoH3&uV+Jji8X{ugaWsJHKncIdjOt*Z)iBkiX^7@W<=`Ft=Uraw((o z`YQ2z%Z}hCh%!LseD_I`qv#U%IV*IX3in9>VJ92DffaaX@?%7#>pG_ga8lGs zu;*cp2;gM)9O)DR@7MD-M+4Z4J>0v8dGA4~^~$kE=7L2~`-e5{WqqQ@0QWDmSIa22 zGS4sn+w{RGmI{Whd{0&iR5%G$Mr`;|b`?&{YAU4O9RUtRp;wTZ=s1W{?qhBGP^^8- zRUd{cx(e=MBB2H21q2ZMvB`!$?v%iq`2*Mk1ITMM8Df0~RPyv;69zF4(N{pFgsk%* z#y7eQelwe=4Dmig%>U3UoHylpL+7~3imCv1O}4-)-yg=28~%W4gIT)~_D6INM9xQ6 zQz@%W@EG42V?D=^sTzj4#-6A%wsF2cK5FV;-glDsnqt1D*r(IT%rvq-bG%QF%w^+) z*@3Pxm|X!I|Ko0S=;|qq?-cuRY9<|lnOT2FhKKc>IW!H?40?A4UEFvC7jn|T&@_ta zOf=Cc&A;83QkYd5fM>RtgW!<`TkFvYLR49y_y|@w{H-B7>x^rY1Laosz&3u~ zj`6>Y6Yu5d@yl@pFXLX@R3>;&(gLqzJ62zpz(cVVir{FGL+1kfqP3V667v_@5n)Yc z1*|+F-%Syb=BF~1(%|PA)@=s4Y@kCL9Kaf<^Rq(xd~aG&0y$xS$d=7B=!t3MY6`iT zLT;y#=^5m!febbj2|!;>zsFbt=5+D`rw`T)5afB|*xfn~M_pJErYB9ff{2N zL#K`LZll=UQSLv=8jZ3Jqr1EG6niovr}RTvwp#sm0$PWV$!L~UGGUf*Gv~w}*(Jz( ziVD|DQL7GKdEPhM0cgvRcIWO1K2u$`N&*YDbOMU!Wyt^D3x!og5Q+!-zm*Wa5)0R@ye&qh1H}^LIxIr)%|F`jzE_U1_#;<5 z=oG3lwddxT!jK8AuG1v%8T|9hK0)%X9h^u-G!r>vHd*J*31aMG(~1!;s9^;FW3klb zFvx(ebLkfgUAi>iu_R@Wa~3@TP=x9~ph!$a8)U3-wA4v4=yH{o*w-gzq39o$C+DaT z=(AC-*htGb3m5SIbh0Avk5Y;%h=cu(0()YVA~JBgowt|zvx*8J+!4;d%nrq}pRd2f0v*hI2acPn2-<(0 zxPfpEbg63K^mL3>p4q`>3<4;n0{&)D;G2C39LV^)kpC_|7u^N_&%nU183XV#gIq6m zRS0X-y~Ws-FS$HW=>e2^H%g+Lb&bxE$U*mSjTgZ9MIQm-0eTD;e4jZ4kmC}Hse}RR z+1pV8luOScb^5XIf$rr!qS4S*iMxsNK%MN_8x{7odU8}0 z9k@Pu0-~7^vRV0_*#qy+{C|ZpS8&QI%zuUXsj$9%=o|Gb4<|r)034CN6>|#Q;ol)A zeVge3^zk13FX6%%MYqArx#Sq&j0~WE2KF?KFmoPFhghd*f->mzfSdqMRf7vA3}S49 z|Fi?}Q4^=U)J;`XR>k~QKWy&xQ?dp-TDcx+<=g3;tf~P%<5U0+v)Ta%5zw%~fV@|o zb*}$3oq!3(KFR)>;(1d)$`j`F&oZ1pgB&$5ybZ?LKn@zLdxP)JoSHlVQ`_^zsSxy( z%GDm@)9RmX_?hcztl==NKR@gHx9*W;f!o+am-Bv?@tp1Gpl$qa zlkab^PuGyiRX)3dpIRYO*()tZ{Q!M+UxX93^;>phKpJd?QLjFz)J{r6zG>kDU-0BEG)lPz{ z19+JN_Z7onPy-|UYQfts2jl@6P8Cops8J7ej=XG8;HuHdY?|m~rf7h|ncS;KA<{#w zB$>Q!0kr;%uV#!5Oa;9Pbmn29Gol5Cvblzw^Cpyb|LtG3O!+>M9snt`jIi z(ec6zRktHd?TdNRjn>95u_N#thshtlBU$!jKriy?d&CA?23PrhMSFDme~#ZxRSyrd zGpLlv>+LAW@W0TXeTtocciWg>V&`Hfz_87~6Heeve_uvkI0K~{gd;fLpVO&d>4Z~v z+{d?YvcGq}@2^Xd1*H^J=6I7Gfj?%{MwKe}Is*Tfj_MZVbc=HP%t7=FVEoaZT2UJe zaQiuS0D27s#4!reAjTinAydW*{L+6{#NfLLzzo{wqZ6DOc#jt+E+f(eidf<7sz*fU z>l_JC6o~PtGh}pw-H8 z<;;L0Ec2wVbKnk34SrlriLDohJR4_0Z!;c7@;AIT9waMnUg9q zHGH1S0CBvAZ*u><=)?JB+<2^SCvY|FQS$tk<}Z|LDg_9K0!k z&AQD2fb%r{yDR~md48hNXKwYyNpzaMJEgP%b2-W1CXtm%#yiFPO`#vA*_+e)9FE=; z&cGCo+!X6GeWHPFJags%rx*U2C)>ahU?`gy(I)HCwYq7{Z7I#T5gBEi>&wiOlKg=JJ-4Y|k!P+<33r#sJ$os5t61Qh+ zq{*J1`D2Fk8=Tsk%y$zRZK^`!5Ibj#X9ihnU@scTUE|Y<-)d$YcCF_DnaL!Vwy|D`|nFUj?>hSpR=?f>no9 z?Q%?3y#ymBaxlnR4kCkUr#5b{WoOBw$tk@P}Kmssr5fJ37w(b7f&nAF%rDS$GIUts~tN(~I>NvEV!)`v4( zsygegi7e|&T~rwRVYph58nFt6&|DC*`; zP7s|>cO{4%xI0}I$k@A{YzIKj;nkT2==zhRLUII9e%+7d;@;iJOgD4beOStWI02_P zBJe3Y3CwA<8pdG_{($G$nUn)?PNoJ*IBC&cu90r_+(hs>fA@#h{z(C|KxCDe1 zSh5rFf8vn%ZH3i~gb39*MO$a01KRr!Le z1h{|Y6A9k!Ls^Q+v+qp?2;#8!q5S&LD}C?v|KDThU?bB5;RL+QRRTNH0nBwj-|4TJ zYWTON8vb(<2n`(M{sN3G+6m(f3}T=Lary@36x?R=pkop>9ppg*1tJ$!=C{foALe)J z$383sHu9w|f~v9%ZR+l{PP!N-+(APyNsXrHkB}YVv4n!>QChQlo061(iFOH z3Y|1{X9Cow(c?3ZbeaGsW(N6e>|v+i4m$?=`IcnGo8>*{R7EhFy!oOZUi?%d|5v%z zewjJ@b@b9Ivb}`Ex1hZL?a8q}`-OBY8puPFcbR)>;s9oG3T82CbI9#H&uSrCE%x`q z-;%C)nK7>j)W=+`F|QlQ^(Jz=jlwh|y?@nUJ_e#DFzs!5a?&YFr_$n82LGYVf(=k7|9!YHiUlU2@SnsKD9kK$x61W8 z-<05~?y)@0ccWapF&65d-pjLlQ6_4ITE>u;QQT#rp@ozA&*S1$FqEX(VZ z@&4+LWCaumPSpnrZ||BM21Wi>{Jx_Aa$batzr_yCGwc8`-gcB!`(+Lfzutf_?%jz3 z?c_c|2E=@HVWhj3ocmS&c3&&?k0t0!PCz#cCeowG{WFj1LZ?(h#}^Zz7AODP6MGOP zjJ#8n!6`Dq{A{_z(H0!IK+4Op6DnUhd4;R}LLXiMr z0)zulN#F~1WUAnBI|Fa<>HYuNiO|nV-zYjD=kEkxr`wUxvs7*HcF(i^_D0|DP&*(y zpQU@Eh$9N2`)%>KB^Tm85Z2*NM*;RWCg91A&L|3i!y~4^b_{MXQ!?)MBQly5*Z}=s zRUk^K@cm%0e2$$2-bomXc8pCl7n-sYps3FsDUU(=guF%%h$k61*x`zSy|Qv9oB&|~ zP~M&FpHAdHD1%wEu2&iih_UMWiUEO3{&#&xHWE?_=-o~c9AGCv5u@kYN#H%Y4|n9? zZ10WB9qp1MfWas+zfo3-5iKbdhVd1lR-~DfD&RZOZSWw21u=>}Pjv~QumQI@0>B>a z<+EjEqkK*haFyBrW#qEV=gP=m86#ajH=_Z8{>KnSJK;;R6flhcyM6MP@$Yd|fD^kK zc=hpK(O2Lh1_r()%X|A?Y;vLF90kBA2c7V)CJbWD`;oDJ)>du7`#XK{j?q`3+l+!3 zt^w96x)6>fNN^C@7<^W;r42H+K@8f!Wv&>w$qiL-V$@<)oz_INT15_{m9Y2%1iI=q zU9gbYKTNvTAO$)#yTOf}mnXQ|ycy$GO&lXI;KA8QW&(pef&5IC(~t+xyiWIjOZ4~@ zPWTj`nHb60_!)$0b)u{f`Dr{!P8$$ zwEN7yCcOER9Sx-*cvb^L+MG=zJ$Ji7d-pS=pb-1qYxVI-^}CKyTE}5tV=h+r%J#vF z%uVYFd{-ri!Wl4cjW@fmfuad7NOB`}-kUol%Mj;r99!u11@`0u`+Et)x`I5ca{o2- z_yz`d>n;WbqOZ2|w{6VrR`%6abjl`kw#giBqH8wU?;DJD9XVQ6bpi%^c`kb;M2AEi z@C6+Cg%dI@F!xi_0VC6M?2&n;C=Sn-%d^*~;}Rv8cbhKw_QX^KR^xAO7$o2zdwcq+ zcDne?v^X8a3BY_$F%Ofx=Op`KlJQNb8h|;OKwc)^mc&3Jh8o}BT_blfhXnFEhK!7H z&>OwkC4ovmF^?lt?p*njEKQ9HfDff35G{hy%R|ih5Kie3^E&vatb`f(t{east%w3D z-fTtB2jb+7AZ=Md$w|SgEN;r>d~D!?z;PEFJJ9b6fcrb7|CSv|>H8Sh)GNRGFrSnJ zzWRF_DV;JSoxnh&9{_?#l!OCsZuZj5IcmZ-;zjr0r^A`ECX74yK|Z> zWRH-_7`ifo-}~Jxg9@YiBG+K!1w|*e-UQ`!KG`AOJreX7DEbfQ9E1b#(|nJ>16-fw zfy#Rec(;Z72ic6A2%e*yd z;uE?`{>*yjiaQyT`U-R`xMD%*_2~@%s~k{GaklWxEqs3q0=z|`aaB;Lj1pxc;xQSCqSost^56r{a`}`fso1ug$Y3kMIQkaMwAiiUpait zS3C0>l>;gr{i%(=um=AzUf`r$r|1TGU`ClbkrKh-zQ0akJ z7$>0XtW2YYbAS>neciy?zh;W9hrQX;mw;O}-UOLD1(N9biB89c;V+GFtgtUVW@nh4obnVwDp1 zA&-6Ua+<)Pz#tOBIQFyt{WuH#+`s>g$u8KBbJWj!_oFZR`Fua~HlQ-7L)=RM=V0J! z6Qr;%1Lz!eDI7#b29fK*Eyf2Rw?n6zGe9MSIEc|=_;pSV;M5GG14hsXBgo4L%765^ z+2eieRoM})rc?ljgF5eCXaA2g_v0w)I`26yFqlsFr}>00=imj27N6YDyz}he31oi) z{Wm_9<%Hwti}5cSOs0Qtb5!BM`JGATbP^e!WE_*c$5fxI4TLvP%7OhdeW2^s8Rs;o z$QkFtXPKLM9LojdXMuNIgoCi6IZTvGAQ?{2n2e!qZBF0sZd9F*2Ln69H&HdxXuuk_XZ6*tPWYI+B=X(GBV8fD+RmeM z=8)Gp)@J_1j_}t(_!U4tsV8Vj2wQ>0E-3u2T(C;-4$V+)2Tn$Ct)GxUzG$txJwu&6 zjJx-tCM`i}_VTlM(^X#8^%Cb{F$#ga-%O>eP;KPX1#(0|iGnsl)BCs_@D9(5$^)Zdhf5NaZ!pP@CF!>c9m%g-LCvM3UkYKY0%pD%Q@b1cScVFA-`{i%Y$)G zr)SnQ82LKV$l>w_asuA(ll|*`%748L|Nqz# zIKsyK@xIR!?Mxi-U-uWtawp${et)nXgh%^d-B&3Er3(ZW+*xuc@F4;n{0Dz_G(f2U zP6bg7z{U@{XZ|KEiR4jimH`etB%OmT|4FAQ(gnMFJ(aHdgwq5lh<2VCc!6oB1_UI$ z%9szv9{|DoIr_sh)kG*N0x-J48i)bvJi+OJqRRqNq|qlpkpSjCh=TNgPApx>MVI9E zY*!8-A6>|~dRmA^I2=g!X!MF;?9pNJF^(o-WV=y7-F&W_(_4u-=|%~bc<<8FoMw8f z0kp3)RzT5!E1eEtPnGV<{iMp7Aly3C)c{HXV1&!OSD7_0zts_dZ`dI~X3H)mD9%3Qpbw?r$DF7oxcCEtJcxbT&%5_C*8YzgE5Nh*dDj8PJHTEac(%I?vL^jY zSzb86JPx2E280p7a1C-Q9Aw`PVQ>cT$^2?`6l7h7Pjy8A?>mYdjeab{|Dzbeu_N6G zi0{=dbORXHp#D`Z)~$YCqz)QYtqe5oaV4HMt<@E4mq<|C;8qKhI{Jo*>P}+b)CX!PVt`8JbOmqHs!Y$ z6S${S`2u@(5r=V^J-oskt+1a~IiRdzxYz!a#((YU+2m)LwOvGZ7Lb#99ND>}lV-Ph zbLPcoxZezO)j%&b7(?@m`J6d98|c;6{}~Iw{#|CBSDBMF)^hEq+2VH_vay{5*mmZ5 z8_(a$8f`_tZlVh}aiBJt=MBcb@p^Y6{B;5e*Pfl@Ug73oP8pmg8-xO;&^%S%HF%MJ7*wnl7=LubXS@S>1GbhgV z37^BmIC4JDSnJ!8M!3#*>PMO>lD$}$j9~xj&(GcwHDqlJyD^5H8)N>**juCMzftVv z$aI1Lhp%$$Y7Xkdhouux#g0@znUw%T@7)pYu?K5e4m)sx$^d!U;+1*Y4P~s88N$0o z;q6w2oJGZ2K;aaG0br2|Y@XuF4IadJMC)L_Q^50xZhk1rE%gkg3LqsQRM&xN+&aFU zidBY4<#o|V;B=<|Fj57Se*wi@Kw$(~kj5s^m_S-WW#cIYoi7vDIc9JjFQTG2*c8bL4KmEnKQQ8)yO z0^E|=02wwpIHIE!SyGgb{lup`DSj5Xb3AMJ74nTJz*Bvy=lfCj&6vAc*r0>OAa$`p zL?IhQGuJtP{CJ0zaT3~P#Bf5Qj$PoiUprL2yHBxy_^;EfoPbB>sdmeB8pUY*bhC}W z%JP&`7clQ|8|YW~6#jBMfrr@`?~Dd0mB2Ux8?e)G>)&VFiFl=rzET0g3Fy?1F$?^} zE6ctSC|tl+r_Sy&nUGQdD5+ldUGJY=1%P~%S&#DBNxxmb#3Vri1M=*$O8wYt z738L}cXkgfBYQ#GrIJD3zw!*@1x|IUKqY}FPBD50cfdCPU)2P1Do~ykRr=uE^zH3v z0Qc%+-h+mC*wq7kuJ6jk35Y$iC1#oQUUWb|Q5p=`|&fn;VZTQhYV~o9q z(yg%{YL(=8uVdWn7==2|uQTTQ!`&wMgbe+TpPRh!J&ORRB&nL;->`=VSp=O+r3GOk;xF*rzlfoGAZc_&(xsA%(X83;N z4Qb?Nee#|ERz?68aZ;8(mnD8H$k+<|VD$+}x}!Y%$^d`UXK*$akn?%QI(JdB7B+c) z<5UA0pJiSG3|fOd*PKWPVg4x@a$i8E7n#S!yX^oxG>!K$HMQEHkG|ayIVF*1!uVyGanb zvBi3~aPC?H2KQI%jirnKBDKx z&(Gcu!hqEO>h*kX_J^p+LA=Phe(Xl=*8E$f09czE&m6na)WH2_22=_FdoglcHmDLO zMfG292h3in-rPOSFfaiuZmvNA-iu4U{yRWX9Wif)4_zRqd??(USE*gujXMTpoZT_~h32#&bMf<13)-pTmbJJd=qktk)_gsP7S=oDFK|DQm@Mfk<$`#Q7XA& z0HqYIhR-k;z=N|#K$$(zyTiB}9PcvgUgn>}pXI1PuhRlNJ4l53j3fAj(+R5Z;hicqR~M+{@Q=n1>}&AgQ3ei9+X<+-yiidB zoQuBSBz~apZ*~fHb9CTy#u2a=qAAhO?IZ+E2td$cO>-%0KdfF2mZ85+S5 zjWW(r9EmZ$Gsb(@aI9)JOG(Ou_V>c~?KLt1}~5#GpJ4W(Se>8YRNlOGOS4cVf{Zv+nT-K5KI`2C!!_$|IX(pJH2@X#a*SYSTb)Up&Pck2q$k^12 zlj=4q1X!CH)^$c8H}=phdSy~YU$9i^K_9bY&H5(5_J7Ns`GT&c8_STq_ z4c2KZvat=Pe;c}GD|&t_&dw(Le)BvolHvInm{m47z8W zIUdJmjekD7|J8YJU6CAgWBva#b>8u@mqptL0Rm3|_@a*mQSrRrYvw}yV?Q}3 z+5PQZ=AM~*=9+7e$BENi1%lH#@hhxz7kiRRCUH_vHy- zl<`v^d!fyH@gfU-nd1$k&sqr49eG=YXIZ=G1gJ>J=Td18VDzFFz>%59jpjfy5C`S6 z3h#GWnVbRTq<`x0^Qkua2x;#pd^3Hyjn(5F(!MF30o_)^Fe!Dw{Ce&*9^eMgZ^}35 zFWHd3-8Xo>=TP6&cd_B!*|%{y0ZNJB{cct&=Ye(zp61Wp_d47T#gR7pkFsIE%j@~~ ztgh(3!~d5v@N-83Fc`tZaIN3J-BE-`*a3O6pZhvT0~E1QIso~LZjB1jnWQDa7s;l7Iu8m!t;kTY<5o*hLDB9(N6 zBLttYvw2m@wNeBF4{&rzWwP(f2w3zOz#$5PA*IE1W^nR@QkdISk+lpq!3(zsS4I)# zRD5+-4@BGHv(vGTPJ-x#GHX)i7E@+kWzJ6-I-T5{T1ZSu$x5j!5M- z2@Kk&X%q9!_5JJJT%Z@4H<0R=FoRd=G|mY4RlJAJ!+zd znulAtUzlxRo1B;C|M(}e-}sf^&-XRadCgDcGorol2a-Ep5rr0ps&!*FtC>VcPqH6V z%x6kD=^IQqB+h}47z>~ZgE!gm^ZhgE`k7C<4xagUkkxtCU;+7A$U^6WtT0eJ<0Tx+ z73Q~!!CvD$uOmYne9yL%lk;Dl0WW4g+c=}!7}r+5Zz~SP*2^>OudaYw*pCg?YlD4W zXFb>1&yA&|3EudJ*#gloYxkHm2>rP%U?A(TbYi9;7N3~Z$Q|Z1hiuLwBW=#t^mUms znYzSze*Qfv5GVSxB_ogCm|*M^$VihpH_#V9>{F9*P2fm0ugQIGuvQKB zy7Asb`m2Lv0|&K%Q`WdNX@MjE&l#_mk^rd2d8(nO$8k8uu?J&}VT^f?BLAZWUMHK= zf^$5|1#^@!jWUlBJ~zTTj=WtCfO5AA{p!YqfC@P-!xGI<6y7dm__eEUg#QG0jDOoSSer!W(RW0tAZFV8SJn!X>EOjExl+K;h6-_+snpXUqe8 z8rlD*%+K~Woaa3&(*RKhC?^0z-T&PT2Zv#JgpCJ>EeK{bSA?ebgT9Tbru_xZOLJg@ z*hXb-N7@P4(GdU{EY10&1`oa}^VwktWwig0k)AM|JvO3e=DZ?we}tWYC)()V2L^n& z4e`$Yy$yT(UQvKU{JBTlaoF3D0d9QVe>AS*7907W`E_-!X*cs!2g)eDydoW~AYxKv zU`IP0k8{L9(FNfG?kg=s7K1!UMq7YR9KmQD#2Q5hL18>p7CG!&zkbhwh=xM?`+4d7 z1!%D0w8?~jDuQrrM#ZA#u+~;3g=aV|&})ZTQ6|=|aE{9XIlMs*grX|^&glSdBz+uq zwYct+Lpo)n&v^Szc8WmY)KB^MiUx4LqSf%V85QW`rq%xlrr(lw%X14EF$f1ihW_<-2tH&G;XhnTc(tPgN*C;q z&VhbExT~E4&X&r24NbR&SXtd0v%!p|l&XOa6ccYt(p?|BaK{;Cwf5pc{$?FrFso zVB$5|gT93fOd`Wmdzfg3^`F8yn?5U91H<5ByxZ(?yW6aToQs*wX1!BAJ33}oh<)U2 z?&1v3&sUN@cX7Yu?_XlimaoiKzN^fCh4CyQQ;U4};@;VccQNZy8_fv#$1L-^7>D{|#&j{pa~ryQ8|Ppv zwr1=8*+Fm%@85z`w{dxr2(4e1Ai_1ApAGca1~y;=d0LkPP)g>)wV|wNSVku;-Dc`w zWMl!G(m6M4`~&d!`lR@6e>fu<)4$4Yf9*Yz$6*Q^GO64DKi%5*#>9F=#D=rf__xV? z(8~?R(>%k@A7`t9o~@&s>o+-l#My4JpLHDd26EWooYwhV9UWe0p0)4sLQmB8a7RG& z?-=K8?CI&4j-HXg)se5c_WvSx!bGQy9AePx4RQd6t@LkjI2$7!Ap#Rm4@8hoT zKgo6bD5vP;hY}E>k8Z{)6V%Np2yp(H#!c;bgRyTV8OH{0cBoQDjzJ2Mt*&rtJsi(d zCBU5o=!jj;832y!1p`f$hSHN ztQ-Hstb{o<1AHcGxS3l}znRqV?Bft#|elgGN(Co%)S&9VrHX)z(%$19GU=T zo@g8Z1|~|>`qH?E6To^z=^F~Ka8Tx=1wt$Ee6ig1AW%K*Z;#%GKtu;YRb?=?sNI(n zAQ0a%ejT>`ez4zt&cI`QBi}8nM|4XMW51t`v)=b08|$a|=kC7g-|Wv^vHd??C%aL$ z-OQsKhpv0YzeDMEf7K2F3OyP#-R6kIeJOzh?FgU^N*uSsddj=1L;4<*QK)DmjMD4l^L^~6s!;+siZX}}gWPnZmjH^nZ`>&YIj}sZ z@28nQh-koz>;MmJ&$2PQ2=DEjG-utI{@WgLe9#ZmGVK!y%CiHe7oCgyN7?%^^vM{;VVrX^{$n!)B0n``rY_}<&P-qOCZO7whKF+Fp!a+J^1fif-Kcu4Dk*!WrJe8gAk2Z19W? z^yNCTyvF*iBA;vMjdk?c`fp4X%pBIfk?n`qcX!`_(M(~8-ym8avql~Ed2Y#6%)D=g z`ObX9G{JJ580*XzlVE9jySx3>jP%E*O|p)ylatl2iC%AN|IW!UegoUsK;9bI)H=Gk zj?S)QC+nQ6I&xeu^TM{(aW3kQ$@Ef<_tkDO<+RZM82)ke(>UjQ?E0)o8NG)Wwr&)e z9BI3}b=Pc$RmG92vaZ$F24m(9Q8pEO?prR3sdkv4*&0CEWkbn z1G2H*LXzv2_6aLpg>4yAFCLFr0t*5K+UORA3Bag{B2~<51(jKCgN^80OBLSk&311A{{sTm%~DZ!@3Wqdj|@Z^T0Ov;NVU4`UZ8A*BL@2~c_7v33YfaM=AI zI|2JSjDLfT`d=Is*xfHV7klQ-Kb(Qx9M1oNjX%b!n>FfQumf;kMaj(eC^-#&2^^ws z4ndTu3V8aRj3Pv|K`*5qRJM2@7CY(>4uc%3o;P~_$Wo98 z$tgnSdrtD}Lrx=Hm{GBKNj8MT*uzm60WeQ+6yU4I0vw%tC+h5iN;fgKs(ev%C^ZsN z^s5g=U0{5Le`i#naEF~f6mnjN$CQNL>c8${s=Gqn>8taC%XuWL!f+)y9=_u<+o(SAbJZh zj|v91@?KXKyw7+6feFv^PZVC|Jq8-;Jzp}uKq&*x&>-_0e6uSG1SaIH4}RYNXN{uo z05UN6W+SBAiI1fYImWO!n5Z^iUdOHK?lxRMLlQYa2t8&h($m|G4ag;q8Wn5#A zaGn*TF@|F>{s1=!+TtDoKed79Y}av8>qonR%ex&Z;Ip+)CXlO!{MC47ZL9kUuy1wb zy#7#gzJJE7g6O;E2Mroj$RC~2y54>0RfhH;69zG!HtRBj&YF2~8mn1_vSplEyV-A; zyas1!_FGB#Gly=O<9Bm^$-H+5`R=^LQ2^FzfiW!z9nX1LV%?Up8_SGqaUsck=FuCS z`6SAj8FmX?q2yZ$m#XU;^HrDiF z=6*49u4Q$!QajyG+RCXv_;qxo#;WgH64H;Ndbb-s;Dra_$ zGrESHt|42i=M@-bPi@FGP)6+0(sul zixY1Vd<~4L^}pHdM=5~@`mT=iQs@75*00XK)p<|tR)_VGy;^TFN!HNcH9lKo9cnml zHHH4sX*F!kIQF%MuB{!J?2}3ZNdCrV-3gE}j@+JI0IPSnss$%}SlE}JL^aF~k^9`N z8~k@OJRCLcLzxCpo;0Xe$9xlJgSy|CH#7B%SNFUiRJkjSXN12`OMsoi{=puG0;)VQ zk@-c8h4{|Z7)2=t-B@))6Ddpp3iO$zdP&{22=`K|ve9vLvKW7@Chwlue zw-oO}Mge40mG3VKSSLc2ALR|JaAtxAmFw?QSoT|fKMFJmSzeybfYJ#vx@DF;c>vopsU?SAp_#QiSNV!!bR1L6l@ zo%?x4u*E3?aCI7zxZxj}A^iZXU6WChF#5s+pm2Lp{K7@_;t2=M?eR_(aG(kw&gVsc zdX$2C-79RZNP>ur;-)K}1%=ix&1g(?gS^O&z$rGaJU7ty$N5GtqyDHg@&VSnEfM_6 z)rYh6e|84$!w>9`d)NJAhx@Q%7ZDf)7iqYe7rdn^z8 zc#q_u2ou0T4p5-V1W{xvHw}OwdmjA=BS40^U*`I-1{_Dka2Y$XiO9)jxaJj1mHfMQYlm;@V5}z-zUnOKTIt()3(rFp( z3sSBJ8Hn3!3Sri&#qGjZv^mqUNveXe}lyn){sW9IP@>^l;E8Ivcrx<9+np9A3 z<$L`;)~15Yi*`7`h5T+1$A0knjs|?jPQYvZJ9J5K5PU7m2%|5-P9_|Biot_Q2QZf* zbioj}#i22m5WYLB1FASBBN)~Zl<6qnJ+`y^1K?1MA7>JvFS-u<*Qvzo&q*!-kphXU zy~eo5S-Wuz`1t!w-CFQxxoM7bp2lSe4seK<^HJyA){&Pwzi$XbuwPaIv^YnT=#Z(0 zC!^dH}VxQVqCCQI~YqN}NmNCyE19M!qI;?4DU;mUbX7A^ElH{f%qlfIw zBUkgBi}}Z9hrs!}6WJd;`kduO9JeK8bCL7D@aXIzFvmP+xunc|oUvTyG{pW%Ml@YY zf}EKnlYY3vIhjW%FY^0E#=3M*RuHT{D@zU6F;ZLDhpo)}VvOF!b7}myJs}B!w%~Yf z;rSa^X1ITY@vJkJb=GX1@vaF>_y?Q{=CaIqS2$m*tidX4yK+;u3SK=k+Xk=k%vJVe zg|VzKk7d4RsW&kR3+&hYT^ZHra1J_RFywiiSLC|QDjI-ZYri=$7L(}1NzUpd>o)m6 zF8xFHCfMKRUk&(sRJQZ2BYSoBvvy^INXOAl#hT-S$!E&eY;zRPrP-5fCXF3OnvM*nrq$1)i?|)<(-~xkH zIhIiA-F$bn1LpHx2y`$4?(MX|E7Adwp^%a4Vbgo~jvfR{rCSB%O@-?JkQH6o#{VZy zW$c`{FjWln?U=W+K7=qh+V?cz>bDscPy-mXk&PU=QUEWpVUuyfQ}4#}RLH#Nii~&{L8(0OO&{kcU&gPXI`Sqle16&5F_@sAQr1SMM2vUYt3ZQ=q13=Ky^;}FnL7z9-ZoaVjzwC8bO zm4KXqAEpx!Tmgy#JSH94=qI4az&@5O{r%~7GPVA{_c^%M`>j$zl)EY{A|i7^rdT2h zz%vR*WkjrSp0ON^vG8;|1>E!sa!du%tYmbmFq4j{(o}&NU>${}QRF7%R@DOn2Y%7m z0i^=&bQDVwfHVF2pi@oTG7=X~z@1J>Js?wJkq+S5K{t(J8^E!Qo&wxP2DaE)MPWxb z!XGBbMo|$x&PWO6RpRVKYhm`Rq;%WqdEQGH`V!+RU7x)EZ03%oVUjqp-oP)e~@DSq! zkcDVAB&Xo9{{8WG3|POxb#n{|XMn*H2~qt2CPxI&Tf%eRF8%{&*sdG>uCxtm9ib&$Ev$)>>FCtKw%ye4b&=g|=hyJiERMI49)A@(^} z^C$6dp0~iIaUPvBhyI@7S#8eIGCXydU15!v74qjhR`}d1Yq!dNtuXdw^u+RX;sKU1x=Z|hiObL; z|6cfL(ihL;gwMYsO9MMxgy)`^{Q=tOfN9SAl)#r?PY12V+E1v&QxO2+HL!CHWVwMZ zs3XsH_Nayo)^LbwPfJSQFzPr~GpNlHpCE?L}}C zw5N+!Mvt&UQ||rj%sGZ}yUroR<>V4CvzS2%ieOX_p7LQCo>vs0UycKUUtkhFA5P=a zg^&gvu)_aO^6g((fLCUTVYiHv(Cf-u3$3mjF$+`RI}68WNHxmsFpPaDY}H+>o?b1D z3%mL~%F(u*7EqoYqunQ^iJHfXmpRpaVwe#BmU;hX|~A=%e2}Yb2z2 zu*}ucsfl{;e`a1b>ap+ijS4{s3S#|Dsezqr{MoSnH#l66^HaDa4Mi^sJb3<)Rgo4#`Ysu*C+ql2QHfZd%wzyXc!m3&5+3b8&0q0n#a0H`eRP^Vp#0$`5>Z0%Jl zNqfk87LLh(t4(xJMB{81p6atB2jR_mw$zlW;BwSL(~iI|?oSg0t03bEG9lpt#A~5+ z0&*CDK$QnF-{>~U^MX8xdG=r9RFilpZu2?iIYB9F}ni%dA(qE6Ipdc~IHO*aFt9f;?2%*9wZh!kjCN zp@Ne$_y7Y5ABlnsX zc)RIVS>timeVo77j>?v-a7o@Tu zzbK;w>M&S8!9YO)#h&9Dan^N$b!efNCOOB`yr+$RY%}-vSF+*E%t~_8htdCacJS-q zFwL{}^PIbd*YRSm3&RO?TaeM8N+v#)yag}+lx%*1imYxE+W#*u_v7NWb=IN(Go0&3$E~Ap))~hd^0UU?uQ8{!A7{9K_0Je~^vM$Q zUfMU=1y#x@px-hVgBA8+<+7|gP-VjsGQ9MWH2ll#^D<7;5_)S98Cy6b`x?yelnjZ% zZy;;{&eQBJ8TDvm^rz94Q!hx0-`4w*+$Vs5Cz{V6d)weSjW;K$Pkq_Bf96}m@v8Ct zR-k>f{h(Pe~e&H zM;JquxmBMa2S7&P3s!W0caHNQE4TR!M+dnL3Mpu9d7sMqqGlZhB=$1pxQp9-3&1Na zG1;<0c*i*$cY7X09oiDYF5Yor1Y{ul_D#bjraE;d3>Lsg*#W?_>Dtc~0c>{nM{JCB zlY5+RZ?`#Z@yIlo5k5u03%BGAxS*SI!-kT72WLAs?;zI^>RJZ*@d*S}E?#6ly^3%M zQU0mCSw`3z0SWfQQ_?UAd=_L!CuC?o(BUUL1dQPmiaQtpZ*fSKwHnxD02YQWdH@`h zk&1qvtMWmy5(Z*l4wt}xduJLZ`1}zlRZRrb-wS=ye}!|NOz+;>e zc$l4lzh(G8908&H1?c;R_e_6N1;CQS|FgdNmwn4eQFe1!1PJZsP>W5n`%JIllCm>iB@3QPM_Fm?tQp+d>6b9p8=`;s*Fy}`7CVEjyK^KiO41lH_ zgjZ#%rf{xb7uo?p@dlaDc1Hv5a5~`i>99r=;POlZ^!?STEDTEji;XksNo-311LXuT z=l*LAKE2790G-{Z*&(>V6#}YUInU96Y2yOUH&Kvo@2qW!vsT(IBLYR9Swu+|?{fcu zckp69rCwghZHecW&=sYpIeLKZDB(brjyG%PCL8#IZ}!(Y9Wdx}LmU~k`7R4Uh^~r$ zAD>HHQT&a)sJy^<0RCS=o+_NN3UXIr%_{eri{NgT7IFz0e6Ujn7||dh+SeF@vl1gP zG-Vp$c2WWhG&RCm9N|JR@{KH|63SXPtg$oP2&jnSR{kHk9AhoUIU{47gE97V48u4k z?f~@AC`MuwxgN#PjGk*JfU`BO)Bv(sQ#csiQ)iv(80ZFa+4zdP2x71%{@~hjl>6kV z?gIE#qw57qWBju`r^ET~pd07Wf%AOl0(-N-92XeZJdWHv&cr;jJdbXg|2{9qy1?2j z;K(f?KMUx#dCuY77MBFFww>?T0HUYnIIFX7OALYP{MBN3>LMfHKcBdSNmU}S7Hy1s z8yTKu{pOI1&XL(%DAEr&tMllZCFE!YSzklPZ(zW;@|kTI>TT$&ZS27|_J1q$+=@Ql za<##JeCPWA%eKL5w`U%IO~60&;u?B=O=XJc>J{XFi8(H!Qx_H57k&ZRU;1I<7gWx; zf>XBin`{uYcu-a&EOBO+9tH*?6*?Ah)Cfb7nkX$RmhZu$G` zBm|1mz;OE&KtPODH}CHj7J+dJOcvD(-|+2CVO)(H z0WUB45-0qBw&s59JUbw@>*- zswjYri6R$grlS{Ifu9B6&a=v@E*oa-2YLFE(d_kj$HIJ?X>Clsv1D(19e{XO;RD}ciY%} zAfqAbZl~L9I2j6c3k5HOsT=i8P6-GDB7&z$M*&oJcbsqjPjpIP4~OD82vIWmJBRy! zV*|ZtCrThbq5ZjGs%$ij`upryz0^jZXAAJz&E9vTD7xR^7Y9Y%V0)z_? zhk!_${$xjFyPXmNTvcg;fr#pck2wl(Nu~kB84%RSzt1@buY*8?$WT-c2ooS6AkLJk zPofIohfW3D;=MT9kr!2BY)L0Hng)G6&rwuq2qddgLE$#OYI*#tokc|iI7bE6Kkx!5 z(cpgIeFe#q@BvC=sRZyz#shpNaVC8;yuO)^dEd>B1|05ameK;qPCxGnqM)k{4*azp zf^j^-IGQEKs;-1(WTgBO zI|XmF1Mo@%1O*~QSy$fTssYYgg)>l5St8ELATlwyqoV^~a|HqWJ@_~~11Q=-Zu3LP z!4P8@Mh6Y|x(a|ju71I3fU~ofdKCE_{i<(dDC2Q%c;h&9V;Ep{50r8q<=>;9^LzR3 z5tRSP_C#n$^#J1@x_A{Y5$nb3*$o zb%0YeU(3?MNHwsYOE@{p$kZz1*uZFQW$at|`&MkiR>r>-UAF~!+QL}2@XU=LCp+Le z_F^6Tw8k@5(Fd!n+iE+T{;Z_#$TL^rqN{2t2R+-OEu@6&6Wm)DV zYu4iYwRSZ}0P-|(xSau|cjmLYqrN38Ljp5`oR5FZ=^||2=wIE`hxw1PAEPI_)*t;e z#`leGWDDRin77=x%_=X=CUqa5H&lh3qtVVk z93o!vjgU<*JS-y#eJD*4|EK~WO0GDdMWsQcWD(MSHcsq;eaacLegRh0&0cl?x`moeobKNnHYJAYQ|0DcU)f)(ncBNVlE2ls} zRdHviG?%#yaCQc8zM^FHBBud3r$x?UbQI)w#dSOGoTKO&aI1~_hg>FzQ&v>e09lHr zL;C&MuF5&Xse}nf5IA>b9JI3Z0qa}lGi8iI`STe)jNhZY)#kf&v%!YK6`;U_kr0_E zE6w=N1R0BcFu;L0WR(w?b70V^0d!l1wW-|bQbYE!!WyV;c!e`xL2nJB&g1=FxHhS67< zKj6#^*^0-##(LE;5cPhy5azoYlUeuQWIZN0+b!NdiC&vL>8WsQIPiOH@v$2shv z3+Hhd7Ff>(h3{3)#+jb`BQMU)+^z`-oW;qSdtpF=ik90o_k9g|2Fd2 zW({ZV%1VJ*)?(%lSrN)}w_((L#nNk%j388Sr-j&tYyI&Rb{9DTcq9b05RI zaBtqqmz4(KJg#C?*IA=2?AKO4zoo(J$;sZg1^M5=k=-~eodoqFQ0w6}&fOaNZuO7^ z_pR=oyaWOE>(8nJRVyr=W2)b0WC~=F_b=l3EwZMItoMQT=uBX zpqDy7%1(xJCuAkX%n!4pVw-a~&3mU$atB7_cJdPUV!&9pScBFZvJ2$IE6wsKOb6fB zd|*a-8mv#_1ebhrHfo&j8aip5IgI@_X{SeVf<|BFw$;CKXTNKclR}Mtg#3@Le@atv z7DgYHIDm*easEdBZCR8oUn2)VrD4h|b8vg{5CYBI=TPOznVS?~PMqXwHlos?5`t8D zPKNjcxU;|OcYlzFXz2Z}p}jSmZ47@s8MdNp7XuvJ%zKpslyZ4ThAZW0D7@NznNj~c z*$LR&<$Yl%jsY!xCTpzKlt>h>@x3Z3yCp;SK}N*ER9-&N>a2T|t9{q=k&`20pHHS^6GopK zNALg$53u0;zYN6J6X+NvX?y0)Kl0BHvT>5Z|FNBbFW3oqnQy_mLI2Y?W!2Yn+un>J z3BsKd)3`^;ANwB-d&C#;T!-KBNbe&Mipqc+>_Dlsj~i+?@9jRy#-7h~KijY4a(%nG z0dzmcP63Bejib8X=CpuPK?rl;1(1axXX3C0kHA%S1OznvyCV~dRH$t5z}(NMYET-7 zecQa~lz<`vKg#q+I9#7|^o92ZHs<60owx(~GC~v)0Hsm{1jT4YHGm=lpRgmK^b?9N z@EI@l{}m~^!jS?FV>A(ZgwqBJ_rJ&v8uJqmM^pJiO1awBzsdMc>3g9}C z&R&$0Djk55??2wvCKn{gv|o<=kgEk)yXZi8lOqBDc7=eV00Q%V!BH#DMUVsy*a2wg zB_Nyt<`xZwPI8n$FA)dvz0r=CeJmo|V&^Qf-@z=1Ls@!i;seUeyS$I90a&-_HE@`X z{H_Ti3{c@#ml*2ufs!n39W(mY`7-sCl=*22Zw0gQz0m`AW&m+GyBj6LW9B>r*8Rh(rJtsK< zM)|%G#yNrx7(r%7P~;;j%VHl#(GjCKcVqiG$9rc|xz_mJ`XOlmf;5Qp(tMh!U_X~P z#uj>UQUE*MFa@q-|J$64nU7{?y$(0{`8Q_%Uax4xqk8+j-GPsDJ@e`8VyB+{zm=tS%NWCDbpA4Hw}Q;AagH}s*N-0Bf{blpE*r?)#`BZI ze;qxt&bqFn=hj%awF{Ede-%BpqMSZ^xl+!Ke=Eq!%8N3*zkGS-^`pDre#ts0gC1+N zJpq0T?Bo0hW99tLv%d4&GVC9JQ;Ouh&j0frbK*?6#M}VPqm68|(KXYrPX|EwjLA*e zhoQyK7JE0rIi5hrHJMlQ)5ZhvxyGwZ_Jggc|K25n=(yTH5=c6Z-XGs(d$ji*#d#V% z-<T8e~A6{gLyX#zLP~(dpICD+O?h!;`uZs|=2f zj_^6RdNs)j^!&~am1FQkpBr8Ger$t}A&LIp_n2yv%^yZ^tNgAi5DiMU%E7I2;HwI$ zF_FQ0^B^k3S48N=gxBZrwaU-Bex8hgoA{1REJzmu5eAwYMgXrUe#*`U1|w1%3gN37V6&YD4p=lL(&urs#6cf)v)3B{_!b)&<^Kf+ z6kmXH(>NnRGIWET0Nrp|&nSx%3SPPJ2j@Kh(@aPp!B;!vzJo*UGW;)h-u;<2x=(fr z&W1XN0> z^n!2)%XR?d82-d#d~iB#fe+9a-|0xkI~@_gY1-V(h)2vGW&$ttBmAZHKDmu!IE_O&%~_vf{F97x5}9ftr!92Z1p74c1ULIR+{T~t zTfZfvKJ{0c2#WowAD=`~HO|{Oe;+^CsU^vdB1q_f5%!>peXKI~Di^h?(Ef~nrMv;P)c91rDY-=L?58Oso_DLRa{vbB`*s)2&s9o?C>v zg9U+y%4jfTLsbq83UC+)pvuBlQM}dd$)O$I1_K>tB10;{VS~%uIK(e5ic%r=3(IM! z73S8>u}g*@!?cOPZ@Sq|fB=Fh)Myp_3eyL(IbA3C-w1fL7T%J##pqI}8}n%nt8+l2 zQH*l;EUt303cIRpZ{c3&VNnulv?IiKL=!%fk$}i&s{-I<8Ey_h92*c!d7tv_@gI3Z zlp%=5FybfBO^ZzvF^jkfig?CFDY!@TlLM&EgniG-JaF(Ys5Fg(7A$=~w_(zFP!c`d zT%u{sooTe=M!Df|Gwd)GT;FF@bR z9l24spZRvHTu>2%{cZeJVyJS$hubkwWPp9|evKmlAG0&@neF#i5{%jzP-@_sbN~Xw zfnts(L~^P)e9`*?`Hr$dIRYv%?RSJjhW$~FylC!6J2HY|4xEId0F!o@2GZ$^ZiBZw zDj=*0-h6OXsO0dD?U}Y=4WoyH95$7ZD%~cG07^e92spffO<^qxtV!WmpTP^$F;%|` z0Zc_26lW6I>wCE)Js7I!DIj1V-xsZJK#l{-yfo-) zfy3iVp1Sv;n#x$cFkI0l3ZtK%ArD=bQNF;qC%>t;?uTrXv`!kyFg7 zhNE45XJP}YKen;|dMe>6>s3W|tH^&9r*~vO-_!&mMCM0v5XN4TK*8Vu;8``!VQtRL zZ$C<;cvIzMoQW3axOJNI>&WaBH^b>aq|p{ny?|+*Z)ylLh= zjozB#nNytcsXu1;zP%~A`c+AwTkYI0OysjE%lE`FFo~>Ajb~n82=}Rny2;Sfv&Ox} znV6LEL*{32aOYUp`7dM}UEQWT|H{0-0Cvk+Hok4%|BXy^em~K$mSf)Ajx6 zyA9T219@B*s1Mz`#+cSP!>i477*_eNRdnR4%K4C=W%SZAYqiWeE+ebU&vutTbiguu zv9y*seRcbre_!VF)$FKqx}zRf@#0x?oQYZNLFajPVvyVU54m#Uo{SvKa{=ja4(1d+ zc}bQxwr5OvEC3*~GKr0wlsNSpk>`8K!r6%W8QNdy#ZfBde7KC5xj ztqEBA&g7IBKfq*D=#^3Q=jgMICy{)WvP?B(4t-H=XO2IBe#ml_aaK7$!{1K=py~sH z1#rjekvIT_&o~?|qhGMH;XoERq(M%?rUrFsmrL8`vP7uJVwb+2XkC@z4Dn^d`XYe~ z5P*?KX3N15CRqJbcG4PVk%zvNXxuUiuY>>$NFi}>qb2Iw^7h&z02l(^g#c}0!8hGu zf}n@m;3I%tFEdRr-`Rz*bfM6@m~0ngjRryjp((`s9pB1y+Y(@q#f!Z9R7MH&cRKVgSJ|5sH3``gW7>gM*-tqKz4D%v{>;P~iFO$25^ zb5MDsxG;qIPz!zdLXOu)&xKM^VUk{zTsIDH~)z}M^ys8T?V+e|u> z!Q#j>gE&eK7%~_<4qvcr{?Lw`fP<=15g-&rQ$QYqQn;E9Wq~9sB`WSqsj6JV&`9+3vP&D;V* zpqztp7~?XC9vH%D9{QR?|2S#G$X=DtRgr-z>om-Hs-A2@70yw0AGZ-kZiW{!@;QvI z80L%)Mdwy`nS{$FQyz?!Wo zQ#(5E&pJ#Y%WeKYiw>LnY6AM^kfB+O$?Tz7mL`f{QT?`cd;e74)}wVT=X#Qx_tcj& zgsw8w1bWHjuL|JZlSku!S*gLC0=k>>G85{W+8C z=$$q6*cxYd6&YMXKd+)MR&hL5-<%{rYVEts8ZYs?CFE|I_bxHdMfArK=XZ%cS^Puh z_2<#Y9p*D9tOMhm{iB^G&3!aG73%kM7bX*8L{ha}FU&R*8p`}zYC1X@Esj3Y1OxBK-e zV*pM!!OyB`eud~qhg21*LjH$;Yr-mIrOKXH(FMcb&T5vBOQq#s?ar6Xb$AO7K;)kl z2FD1A2~Xv7BFpL9JHzs!RG5J1NBh}K(TxspctjT(UH63U7sD2w-Rc2#+%` z@KwI~AL(cS-_ym!y4b+3vy-k^H_FWl*|Mkt{|TI@9Bq`-y*hseb?y&*6Wi*XD~eFP z;x{v{ph=dY`JxTbhC|w4vmwJ-2-@4d?F3wr;bMWl)b%hzw#wJyRR#fXoxonFqPLZNAIHXZR`F1-?!h+x|N2fty1{Br8p$;M~m5biyXaKSv*a6N` zZ`sBlXF*ida)Ol>2+*b?Hj3)J&rZPBOz#AKMUkG}T^aBKJL+#s@M-M*#ZC+S#?Iic zGdd9b0hjy5p7uY)<%7&koB=wE12~6j7!*+eqY4R6dz=Kz;*+N(G8_HWkjIJd`q0I5@)@{XG+gr#ViMF(RS1+1PV7Jc23eOf`XT6uhaDBrMMb5_+sq+=p$onNjCciOILP=1`K}@9 zCq6T*+Y-*iu&_*LSYhsx`fV6JGJLc<2cm?BP`X3N^APJcgz+2VIm5`x@TW{7#QUlk zhml7mC2MpMM2C*D_G9RXG1g`r`KdiHdj|vt;Qz8#T%qC#4EQAHdeJ{_QV-B;Nrx~8vX6$XwLmPQ-^F7m_&6L3;I%SfZcS}a;6h{GW&+z_KzsY(y z19PnDEazrszzzTgv4sq`SeuqWY@Ejl9Q!5?aYOm+XD7H#&VjlN&b%{ATN0?Yh;i8Hsz`Yo|0OYGqye_Lc-7Juz}ehlt{a{S1B=RngT3k$)z&LX=r ze@bfKS=MoGXQwkbADxdT)$s!Ru&{5Y5QJ@rl1SEbhX1$G$L%AM5_oz~R{|WD(UD2y zqJ{iS^znL-yEs0=Jpq_s9S5q$+-h8I$GNzS^StrbnJnrvE(hcsk5*ESMi}QvJ;9|B zY3JMwe=HdOGKJM;8f(5|2%R=GXNqfG*g5yZhsXh_TVd!H-pZVH(2e3X^r37-)*}TG z=wcL1KbxV(HUkFp=ui!!M29dsLkQ(C!co0GI}QZ^2IDz$Vb&fF-^hCy+~Ahv?N<3t z`RshofG`FKrGcG_F0R*{A zH$e_)IqQdwi~?^E%HqE;>cR~-ousO~FPurnFL-Hc)mEDDMeE9PelVB z?C`t{He=~xU%UQf#@oew)OSKnr@A;CT`1bF+tX=?^ubH*1ibja(gVyt zm;^6$YM|-8k~|3?z+ntb0>X zblQSanCBEO&nSS>R>F5g10huhAkWb|KmgQ=&#|1#OC1$Zx#?y8|2O^fSB?+}53p*i z3Xajhi)`TU_03&iKF)!Nfd)A90|Ob+Qpdq4D^%G32`(pOyaTL>crK#dbt6k(iyug% zUP6{iDEbobDRRbwI84|80RWFnu7D!XEHa)VpDos$J~-Eof}#Lzzt~%~{VuUTCG<-P z<56PoL^oXCEA>mcV(x&893epNf=Gz5Rwj}dXb1y2bV2H;A-;2naSgFALww)R1O0lL z`vo9lLnpbz;IZyD_(;OdGs^^1?Sb zn@uhb6W>kr_$0D6&A8hqWX`@_Pvm)&{Oy$-^+83;T1>MK)9l|g#%6jWk?B+Dq)E<1 z3q8?d%&mP~LWpclat0}Z|=9Is{0{3`ls?YgAy-N2}BaQ4=b#q~*d z>BFe5GoB5cxeaW=2Kr(Hd0G>?pUn zSpr)7SQ1OgF$^vVoVdAhDmMf$zh(_WjK{!>78Y7@_Y!(IrJ}vU-k-(|+KRL#DaF z;H(Sd*tK)w03sEjpZ{mVpyxOhAV=U7I{_bZm4IsZ1@QWH8r9y{Wg0+8{a`#)F8AeD z&IoZYi>gv9r9ygj+kS|{!vdmx$~RV(pVgde7W$ld1TVe7Wy*m|$zSNmg39mynd_@H z6z{(XR)mUHZ}uQlx`G$$s3t&#yA$};E3l%N`0xw^P zc#aJ`-!b^_)J=ovlEM95Mz}4@1qTl_TOj*6h-?qCw*P5E%()+WUbYe*#`zsapH|Ta z)k_@({d<;UjXl>*gE&9q?Bh7br*=j*{1Fm7I{e*|`Qp}0Qp!emKV-Abcg?VdGq2@^ zai2Xf4bSXZ$pJ9UzD^-;lZ<%^Jv{Z!j2uj{Z$qmOh8m(A+Is+BTk@UFqr=+6HH1g8gmbL{BoODb`?`akr7j8FbMs zhHzG8b6-w?;=-92Xx-Ysn=E~6FEw?q9D)f1!Q%Bxh|*zKqZnN&He@*WUhl@?y&xI z0`gt&>V^XoD5$^U$-ig{C|bu*3IPNtdIl&h@KmP(-sNb( zdz=Q40ezKkXadYVCvW{>_}}1L9mZN^UA=<_%Y8DV0g4ht1OTD#{&_wt^48yQI9X+F zm!(k*2LQ)Iq&dMU|GPBIg(2r??@YvXLp?{w~8=?tOzRn39N7;J|KUeu8vnodQe2vm0VXk!4(d7$cnF!)=X zW|&H&-}BFO3{-WX4ta_IjX-k0a&)7-yT5OP$v!DHv6;Qx-0Kj!(ig&BsAQ1m2e6KV z6m|D{sXSBI203QO`8F;Lha5W;O&5o$i)VIy!;S!lq)Vlt;(*}2T^um=h4_ynAgl-D z3(z3)*v*0IMo|Qr5M%6q?SG{PFsy+Mn0E?dCFc`BM&TDwYND5pG{Cgy_Kl3{gn?ID z0HqdUg3MbbK;o^ zDhw)N&dLO5d}1TPg_EyIR>7bZmct?3!5LZB*Lp>ktu-E#ZEJ(1hI7zBzc$Zxw1S^4 z)?o7B#2Ki{Kottnm@96}?jPN@i1WCJOfMXtO?>A0j`@xm5Z`Qi zW7e(nfdoxff{If;pZshrXX>ytByE3_7=s z4sD~ir}@k@_GJp0nc9@ml>k!meJz~!77oS)=WJqkuOI8x;QJdFX1nJ)`&Y-Yt#L+b z*rxGQvQLEgCFDSke$9kH@6B>lRj5=s+ttSgzyFTI!rNi&SVBEuB?0BlMZ zW7))}ZbHFq!i(H=qa6X1K-be84Uj>3wbKCGZLkpXDAiLfy-K&9?(ps{8RG3hfkio2 zR~k_vvU~V!-~dnx>N*!JfJbbPMV0#Rc2!3-Vi<`=yIW}U-TxOGc9RsoE{ zXbf=h)h$r<+Hr$Z3gQnLrVm5@02>>D=j5cY4}rvgm5s?)(g}$C{bxMxns51UHGmT* zsUVQq9qG^n^Pf^60uc&zF6@ASgaTi3^9WL-&pK><<@V$pctnP(d)gU|5%NEp_@Gz= zB>4^hUe3y=(;xTCeBzU+n0xBKk07cb+9Kz2!ilg)pibz%Z3V@+03>dUKY^M=fEC_hY9!I-tWTlVq z?qdw1g6?~bor2Si>p>axadrg0?SH7N0#IT>BaG4OZ)dtMI0BFt_3lv5ih63kt==McIQGm0YIuK}(^(k`Bi@djptQ3U>!0;8>ry}Dna@z@h zffxGqBsF+uhoz5LYcUW;sp4=xBgzi1HtV2n{OFRw4`&0Rp*NWH?BE1l2{2flaCo+v zRIFpWWs{%U3*G8h1{Jwzpm!SQVFdO`f*1k*bQ_N@dg#_E9KflYjM&EjPh;e!8SgZ5 zFs&Rvx8e4)jP8GFmIzK!L71!Pf`=t#8`hDiL%AT%2Axi;+{O2iV{X_Ow zW|Kc)nY~y-XDtfwhdeAYrUmr&{H@u;KphP`%&)_bgP}y=R3N^cT_kNmB-5gn9orE0E#^*L3IPa z)87By_Vhn#Z(pH6COe>9HVa?eH}iNUjDWg#Mbixq)i8osJujJw#vYfAGZY4k5*Zd+ zEeWdv%HY8b{U}2fg9v_wTY&h%RUIJovD)S;w<&@m-G0U9rh0#Y0XN-hT)=g92yV;N zKr|9M#y9~Cw@8B&t`8!Z_u7ymV4LwaH;>xDGrk@augbcjypHdQ60L{(M#lkBNn13f z!NUwHS~m4Ro#`-?!HX{iFF=?O{dj9ZxWoI@+r58}46zQpHBr+=41DwmVDA0=nm=%x+t>oTpNDgc#mb}`ZN2;0ikr z!U!OT0v7%UP$-A(NIL?j*%3I)5do!el*d2923@!QOY8(-L;}#Lij4F8e~ne3Mga%! zs~k|u<9y4~_|5fF0Ap>fJ5ZIrbB!9NZPtb^^Ya zk(v?4ecU?wghScI z)c`W!&$9t%uKgp91}G9(N+)38csl_owtiI@+>*dx^#l=!xBnS_9>yei2!!pyu^Kp( z*Xb$mfh`c;;9u$NM`g@mdCM>EYUe;zGJ9s&UyOu7qb)4K4gTBl|5cUndPfj=Pm#4R zaXv~lmlvLC9)YG`>~HBVg9mZw%XOC!^8PYw82tsL(_ZD0L(WW@byGLfGR8rziNzuq z{R7T(+hBCpFnV+ND(k)741m7UfGzfKjCCKsJ{!I?IA;ycdh<1I?!#J5?49{}(dkB) zzXzugp5nGRwR58XCpmvp7{w{h`xFX&nmw2nc<%@|pLty}@lEXL-T`mVXHKBcn>eZs zzQ2J(*5tbytb4QD5r@gd157iwX>|S64Ziua9}~Oz_K$w3@yr@JsE$Ey3}-}P0zJ?Y zu#j^c12Z1>Em%7}! zkFl=t%=H($5`aBhJJq-UyRwnbGJCPanP1{OEHb_Y&ea0W_`*iEFP=Zz<&hZU&hF0V zqkHF&o4KF6nGc_zoEgFzWwp zfiy2M55N|K|8CBkzale}T5I%pi?y9V_9qzo1a_tQaW@EJ-|Bq6e!e*YSmQdns*d5W zai(jMp>lQs9OHeXcbb!eeH!^{VgW`t+f{*2Id@g`)G*H-9!qS>5ISs#eH=vQ2U*uj zuN(lp(jcnQO`pRuaF}y=PjjfBg^7|Ny!W65)xi^T|6K{n5$AX52gwFF$oq#lbi>8W zON<~4qfCC}sw|xumX~~r%WTGslofK3!!(44s(#(kFzBYt3-$~_Ur=p5-Vtw zLX>x@-hR$X{eUzS0-6Q*j13AP-0w1ntQ%~UlL;;Vq;wpDW8e+O0AK*cx)$IntueP* zwOJjwGL@R>SQV00>sYn&jql$(9iAZ1QAyyE^Up8xI8}y*@(n%%<(x6Z(a1@FKjuDI|P7i#?pS{sh9{~#YGA=+E4gm%Q<~%A>4nZhXvSWC<4f$BkF`6F=gDmJwrv#8KwUh4SyZe}LlnUvI*1`q^UVuFeO5qa{ zI~0`$!Xez9sfE6q>;xbq{U~L%zwW=s5k&!EN7EUO*2H(Gp)aBY2X693<17BV(g$6R zJShLqS``nnqksWcMN*^%zT91x_O0 zEganm^kfr?9H@dyW+BScZ zV{C|*fbSS*zBOc_fdkfjUUJ&E29lRxlCwB_vv{Nt-0MDQAaq}T` z()`ugS#aTKhw5=i7I0{mc;CuXG4`C(bsX(=&es~xT{|YJf>&`$R(i9VU>R9n+UmSN z<5@sv7TB8w9Iyq(K3_~?q|Ql+=AUH^XZK1T|2gc{9M7Ibc4t4r3;jHU&YxzUQ;d0v zvpg-Q1_xmBHUlMhHy#69*hZFS_}vV8c!smuz9qXJh6A9IOXfDozD@4$vPtxDi~XBm zE)(at5&+xLL=QG`G#adX{RR^Nu{Skjq&AvqqF@EQH2VY8(5d5!uAh|7<>)acqQa>f zVQeE^=B@aG%U5y0hTm!@0GSzjK$g7@zFZE#F%H|Y8G+(`hMjLfOxu;XQkXjeUSp!Ze7y}xt0ugtuBgn{2>a3BV56O-R`lL>@&&rot0(tE7D zG3e3MMn>z$zNJbTGykB0eQf>=^!L%eonDj1Bpd)XChE&&`~{8^7l43za#Hqn-u%i` z&_Sd8Fe}r)JE9_|O65~RT5~9cqV7`|S4R3LX&8cn_o@C~ja$Gp)~N^K4?Kfzm9-4h z2XbGC{hwzzUwr`LX82x*kXiR&oI@D}!u)zW06%fQnLQJjFq|H|@IbPk?&m!x9Rxi; z_z;kZpyQQOqBIEyE!qfwJB?@Da5bKD>{#vNa5($Wv!`#zdjAdS)WmBs*G^zO)%1rE zmtp6Scc}^lIqK@MBXFNXP_q*-ZHHjpDFXJiiv!lBYLS225qNY)7rGzp=m1V+&)$c+w4nTT@8cldJ{n@Df`H1{cR07{*l?9l&7 zxmG}RLT4KF|D}cRX;3BmOU2&iYg7nUl4I;cT%L;>RXfzoIgIMUCY$!Cika(w|YZ7@~RXuh!c~3?e z*Vyja0(hMBGS0e>V{~iiy&6t%9V1X@Z5ksk^;0-l29@_ru*MT#v|+}HYaQwifH-w6 z{I_)G&QzK$H#Rc(O7-1wlQ51hpo z@-oR>CfSn~@0s{P{!MvlRV4%+?YUWxUdM50;4n=*G$RC)=+dbV+4v)`Z9X@nusHf< z_S<>;@31EwWTG?do&ev^MnfIswS%tiu;(52ZeCmgs@WGd0GU|3(cS)7$92|zjXhmO z238ay_-6JGSYn-)Sii+awiRArFBdrL^UP@;-8jGOyg&MOj=9cpwr0NS21n<)ih{At zKF9ffbpI6kcM@lO5`8%N+w5)7LT^pJJpq+dtnt+M+=-DroY^@`AKSk$%OW;(N+}WK zd=j~u#Nf8NjJY`9C6vs$iJUcgUQq>wrogIVeGZq|(55rIHlSyLbbH z%nzfmYd$ktA9L6uH2ocqO8`B*#9-{>hOf57J#`zGEAsYOK(UJSCvJ`3bvRj$KrL^R zK|RbEgNR1q=2Lttm9aX&1`FpX>eQc+V^X>#N+AWT)4DNcmA=KTSCtE@ZC6Esa^KuW zqoIz{7RTn_;ZpuTJ701%K>H>Tr<^hjLg6qw0!kl=$&&XMMEZmR56WPrfCOq~?}Os{Y6As@ z6~JHwanN+800Ijj?2o{J+&F_5K)3+pr~h^Ssp!Dz4(YRYK_RT%|JR)+DCXy)^i;s& zO|C%TTt#n!XE=?(7z7NAR>U&y``FNb&S8Eo48cUm+y_qeh2)``a)>s?au#^z!2fg9 z;O}+@ltOrqs|qkarG1>9#OW+?F%YScbXJjZ7CF~Zk$}-FvhUHK>< zs8Z#2@(5IR_3d9JRLIoO-Ol-=<3?1MjiWg7whYUTAur>MX&hOou`V^%u7<9xAt$w| z%J`>2-#96##gc!plx~GM#w!|{Wxt+K+9f&X{ zM;l0nyfmI+qk;jgpPJ4`jWO5J;SJVsg5R|`zb%Yd>(QpF6-EH#)j&tp4{%31;TJG$ zweym>uF1Z(#4B)O-jt^?JnaW&SG<`qm(CsG*1tTzb4xPn&9U}#BY6`SdVUVwH;4Y2 zV?8=Nd!Bt;zS(Yb$QY=d*M!Je%1*){ad8vC}&7*-hXGV8pAtyuhccI#U}_7=D( zEIiQN1~HWL?A1JuatDJy$K2h`?$n8i2iQqifo%+q9}D-jGzlB5xAm(j?=X+%vHj6Rg(+HmHdX zYx3Pq^icy{+IW9PX6l@c`b+HqpyS6smz^TVIdkJ%6BJm(evbb zCptGmZA@N`I?5*{&E_BjAG|qhYDGXGVgi*W4E;Hy0~Lg+{1G#8vFOnv_^(DKVyr8C zzRUzmLIDeCsM`ZVtIlTXMIfUln$@V$7SKz1VT2}H2s2)h2B}}bCN^Qy)us_veptr; zj0`b%-|CzDomTiVM7jlXhy&23a5NscO4))rZX$1`LX``tt`ald4kJ&FVhlvPQWGrh z=8vWWq0VtKtOXQxU%|?=vpvhJ6gp+|qDAXV@)i~#Kn_YU0V+hS+w?t-J}9@mlMTPX za|)Z^YvX!RepiH;#c7}%zH<7ipm=;5h%o%RNvcZVXa2wW0s;%5hyaH&kp6m}kn1ww zCuT|@N+;z2Y{~VCeh4bNQ`q}cc1#3@oAP(Fc2QL@=dky?9Ze9n;o&y^cl(z7H9G)` zZYUZffE~(TWI=)S@5;RkUWcCk{gXdU$S72P?IMd_;36MQH@qyur@g<(3sy zd7xy1#(NKAKhCz{@8>n)hyY5Z@NEMJ6&b<_?_*zrLRclEEgNmd8|A=Pxm564hw{*{GT-aOjUx?~EdJ+g^Jm!c2a}n++mKTEkd-Df*?e$zq^tih`RK=)%h;94SD^9Nk*g-_Iw267!s6Uwr;*n-&e06# zXqGjbd$&6dvR8AQqq&C5>~2YNq1jG42(vhAvqxoFok|4fPjmPmJF>zWuYKPQfK>mF zo>}L6){&oeoRT#hjaBw=897}-pDrrr&-)iJd<*=29+{ZuGST^4mL4ko(D{NXk{_6e z{pr&Z@6g6EpW)oj{MliAocgH?O_=l{=DKDl>>X*qRT9}cJ71Hm*W?whc$i2KV4HoL z{!R8onBuup{Cx`BH2GOq0ASxH6#2n%Z61+CN)6Vsv9DzS*{b81)EHY0T{X^o$9GRM zApIPFwaZ7(af#r?=9D?MLBnLo9dzA(~ z(|JMV1OMSPz$bk$5&kF*R4uRoJIC4qKtYyJq-qOXW+5vWopVF85LKhz=igVVqSs8PMFoFKZ%MF_3Gt+4I?z}zw3+$2xOp%jFyWm)em?zQzFZPWY0~6#n0wT&8 zQ7WTvdsY;j<*35WjsX1A(TvNz_A>ro_WYECKiv+1_Vq&lJl974{r(;D5uG6`zWsB9 z==!u%1d0x{okmc(AkJ2l75>b7$X*30&}ClZKjqCn977aUH!{(EyKngaAJ1)XSRB|nX%6Y@i>hCiu5YB)~PKD!8#O3{V1WJwsupg1iQ3Ofyz->G_ z42~HOAm>fM%`KT?>Q&VW9)9oN>;#~YqTAz}j6V^sWNW6DL`z*zRm#oArKnW!1H8`P zo@8K?E=j%8zdO&M!Sh`%h(QUy5Ty$w$0(Bk4q~wTA7$r(zx5$ID&dWa133eXz3=CV z4G4SziYq9GyBz^zYy%kLs4~JqQdPmgE{;UXLHLca2LdDuJXm&=K&b)@d$4IDO94z~ z48a$m$^d}{uS>%oOoHdRa^S&^8envboVDTw8Tt=y0`{nc6H#LPCFWk@JIYT?a9{3N*L?rqOwzMa<~4@XK90^ApY`pHIgYa)V>p%LFZAy@i#6n@hAyn( z+}Bv2I!2?;UNjEOHo#(uYfc-?x2tdc>`x0vW8w}2^pramz>j^XU*uambFLj?$K$Sy zK8R{~oH5qkbQ{{|W_hA+m}6C5as>3OKWBHs3G{voC#!XDg8syK z*G4zZEF>qv9BVwscxPGDSsbKU5J^m(o3@{ zV2v}e!I(C9{|0AegK@7j=XKU=jrpz$B>4RQ&(xX6+g?w7yga7I6p@mU28j$QQ7I)! zlS)aV!4yd;Ga(Og_c`~TY0vXMXP^1pd+yj|ND+|+6_qJd^F&f1ah~^Qt$BE!<-oBX*UMR4#W`8UI;?tKMio|mFsJ*8`M>ZT4@P2LX81Y% z*?i5gr?cGi?4{YsPZa>ugV{N8l6&p*d=uwqZ6bPvz~rfOJlDd4YSDS?1z*5 zIDdxY7A(e#9&ZAV!gKn&kbfn^g;BGt8hR-<&`k8O7fFt51}RUWc@h11xF`{1vj=#8 zQ~_+BlLQM7>&GO^Pd}8VGUJqYzD&SnF3eNTWKIea* z?UaF{L@Fr+zz+O4?>!m>jr>;>;5LH*07>+C0B}Y11;B4P21O%<<8N2^_nY{&wIc%p z2;5i95)c<)+<@&|Kcmtmw^%lwY~ZG-4FFJWpI6|42mgY5i;I*zm;C|-+kYHn;XPM(W zW{`ntWOC};Im2L@eV^g^X8vgd-u0wIMF0enkmm{ZZ~|RB!FTonv6EbP3OSuYCT7`> z*=v#mF^lZXJmSfK%S_b7AW!kUldOGA1{}!9%><6j_;(WYY2SOQ{lC+o4Tq(3Tmr}T zX*q7X#dEb-ht|Jx>~x!Jwvn0kq3#r@%99Ty5w*#gZmJ@0Mb5OSe(^$ht%u8sv!E6@m^-E9I6!dFrVp95QAvnt#`wUO;I zg_tXBW=VC!Kd=|f!;N0*yx^oG4k{m7>yW>4*az9u;Q^yYdK-twS+Kz$*rVUWxnLOs zgg)y3IamX`r1u|OfFGto802}P{+ss?Vkp%OF2c?#X;V)B#rFJV+(1de`oGT{1Ku;B z??oX5`~3wrYBCUi$=^j7T!#FaNm^7lzEOZj)K^!Q9xs`aVq{aIam%JQn5%7cMXD3| zQ2GD5BM{0fA8JFZdVGc7Pq&c~n|_@=XWpmkfG`?LL!4rdeAos<&1DeQ7y|TxTuYG& zBVWCj??Lt@hO$)?AD#2wK zU+{MbF#Xogae+N$MFTE$Bw!|=PZ67eZ+btEH4ylM0RSLu;Qju2@_!lq4;d)vy&o|M zXd56XO|)np!28Sr7)mZf3<~{BGhr#S*3nGuIz z?*uN9R^p5Vmw@X>THt#IYez>vX~A~@Q^bp}ug zDoi4U!*zq)c}s$T007(k7ddcm69jqI=pBHuiQW+Rnhdzj zIL(AUh4eq|sKA230LCfWO^av18b*s^r4f*uC_w}ON9BP4!6haH0{DYmc&=ZpZB!e` z*s~YvLa4BR^deC8!G64ebPr2{V26F_;+XW_?+5_jKfyI7kjaVfWZt-c zl1m0TWBna+pv*YyK8`H*0AF2nL>Eu8gK=r|U2XJH8#!*@=I(>Mud6(>(g4UyZzLP~ zMDKadafh{PBNy$1^IqHBd$*7^|2<@|w^x$Y`pRdsepBdzY4rar*PUbC<^aEQM`TyR zS!87PrOA|^{cFx8m_hDlSf80|(&L^349$PtErWT^MfBEco@))dZ5_|N0o`~WXZw8C z<9q<^dC0;B^!=k5?L8XuEv#e0pRwZo}T>F!@U2{90fd!EYBjd zvpmlX>pBCln9&*mV5hmqsZ}NfDw4ptn)sfl0UMr*Tzw^OP+P zN>wC5lv45Ed5|O2$byWVXzyOiXdpv|VH8pHL$}!&vDm?^mUkuNt1vx>N4@AbPJj#6 zw?e>xl>r%Tlue8W-rS9X^mh);0LnQS=Kpb6Uv=ECv&W`f?{l5sRfGVAs4=w>idGc? z#(Yr99O2Qhm?-hWI0acw#5pnCrLeC|4|}-h9P1CPWWQjZg%sPG42eefzg^S23u6qZ zh`t2+uCo)|L>;?W@**vs>U(`#z9$UMaejv9Czy%wy@+Hd`6Uo=y1hq~RkRI0CPUA$ zt}-~g<$cFIfZy79kENlCb>~26U`_yleVuzpMl`l}xquMsJhYYb)p$P9Y8fRM&6PH? z-ueFEEgWG0FmJ>7T}J_K_UpR*y>je9?EHk&Iv;h8U;BDUrg;J!@cc0h>L`POll}gU zQG&7~0p$d7(JW}s1ai?7sBYsv?|;_}E|ua?TIFT_KWKVz)bCX^;HHckELSu`{Ew5p zPJ1|Npp*bI8Ih%ipYvX)LD;{jk`M@ctJ44i0pbBnI|3sR07{Qu58`rc=l%Smft)}< z$>|)WoNjb9;DJmh1qVdYy$=`wC=#&B0N^GQ1y!;q9*Xk!D7cZg*x0|~zl`?F3=}?< z|5imo7azk$dPzzp7H2EP;?YP0023P5ydE_QDkitr4}T^ z+npNtj*b86=`2LkA^sjy22twKM*t-r6$894+7y4$|Hi8u<6g!tHev8e>!`DwYWRT( zgRFBj58_!%+)L@TS=AJwf7YbTdRCqo_0pSG(Qh@@vv#c;{_xp`s+`#SrfU6Jvljc@ zy4rbI&T11t*Zi@^wyHFcXKt~l?Gw@%ci7L)U(N1DPxe@=9(&sROHPRk&+x8n6Fb2( zO&}8!Pj=X!`yM~XIsboVxmctYP)<1rWXM+w zxoC~rz@X#X;twEe;{crTYqMF=1m~@fPUy=+W{qdXf-h$Z4v01w004jhNklCQ`&h3+>it^Akws#UBIQdprSX`Oa4GQrGM`AyR>QxSjUK$6)Osq-c5a8zL$+uxZ_goEq98s{j-w zY9mYSEz|Hv8(^I0CNk0FUYn1a`G0Rt35-EO*y1K@-`vY%s?p{36SDbUjs2*eR9Q8Sw;4LUdT_L|zIG8&Qn zDo1HfX)#3&E3#3PS=Yb*Nd#L=5xh7Lm> zedYh=Fz=V`u|8@LfMBjbiLLltdb=^)<>pj|>cv0uQs?=(&k;3RInE>~07bz^MFLbU`ikE>67U&^>IE|PwZZ$WL-QQgjRZRlN{VTVyBlbHEWto{ z|0-8J#n)opVwM5V6}*dY+c2(n6oBW6egg8mQSR!iFo+?GUI5yU)9vZ+Wf1TVgFU>| zXcK*$js7RS{|6d0oa_A-06;kpBFoVafb|$eNe-eI236k3-(%vVdOWn99=OJ9tg=rG z%n!0kWzoFO+NTdLerWXlu1MuSUP8Nl8| zWxx*;%&lNgqq8JuRn;0n>O9py|IaBMrFcZ@ydl#8(d*$p1Azk*kcM#vI1F<}hf%P@ zzfU7QjN%%3LW2E~-EI6gNkc!(IUBymJOV`#RAumUf95le2yk|y>Y!x;;;hpR*ZZYP zqn9|nAX1@94YxL-P(NR7V4#Sj$_+8{F?b9GKFYdBj}oOLF-%b*(6YzRy^J9f(OW~W zFZ*vI5Dz(8fT15d+WZ3cK1y-_7|hPq_S(Pa{s8Eap4j*N zz1PPm@Vw(90Rk!~MDV*OTLx=pfVcuZ^j+`P%-wgz3Rf-|-Pu+IfHiJ?*S+JFFJ^5z z$Y|$C6Z`gbBN^nW`Ag@EMH=JmHaRb?m*llNtY`0pY*(w!b((7*C4=nu47OqRt2sF@ z`rz-D&4iTmp1vgW=+o0Vc37!`>0Of;H^cR3+4otlF*ltP_!d~}m0W8T_qoV9T+Q#- zvhM4+#|`L#_2}jG=#O>W-x_q!>W6c^!&tSXf}K z=CM_CQ;tq3J@GnE?L%Ko%h->*{1SQVv&Q|R+4|$jmr&c|@#kgKr1$e2;3E>|$3T5t0dz!TgC7`@UI>5uPf9^>wlZ}acC=Z56<(* z)SZh_ex*|dA`E`UihZ5ESDtyrQ=G?D{{L3zz@-RTWVPWH!E#6*IfqqaT@`ALlBgpy z&nmK(H~`UvXRGw?!y6TGaTos-IZcGbKjys*vcA!c?*mRzD6jpVT)U`Hcx4*$=;Fuy zMUQ#$3)nwZ3qnqWtX(21+WeQzgT!qX5?=00{npQaqbl7I?-ex8wTjo>jLJ25Xn;Oirfz6ca3 zRfJL+e1oF~N_l+25hB20qzYJnjTTnbfcODXQJ~bpp$3+R83=sMAmFo9`=MFe=ZsO;Dn4YT^!t&W zAQ)es*9p!6=Q<`5D%UR_f}#W}L;R=t1dp0DyN$Us?=c^VzsCepl?19hP}Kk;53*-b zEui1AhGTL<0Kyuv9hC*_@t9I@szN|-j9#BWKpjkrUp83~Wm&x3Jp!)GiY9gai!>&N zt$JXVDA(SZP0niEXC39-;C&5bv9Y(SosgTxr|oU={)Wl}|C*iIn%q;1`)TofZ5*4< zi=Cgp&Lx6}=J1!84ZwHz(2>3GyDcmrd4lsa!Ly9B=e;Mn7e9);%X;>XaJyJ!xWjpC zZ=Vf_T6bnSVhm&BJKG1^(|>2yiih{ed2K3<@e7Y|-^=q`zLv9FI={-)f>II_n`GE} z5@%#u9`4I?>fIdoICofvztt{x8htRWQbqMExH{(pY5cM8XH8sI*I?U+G+W<>~O z4d?jGd^1UUN(HRqdl$#DJK)-L((7M`1GQOE*y0Z_c@_86Ijf@quSUF=U3(Xo2ZooYb7hjQ9!!O11Jqgxk-#+Fx2Z zAC&2gA)ZGiSy6K>PfN^f?ll_isE!`xtd_FDQ{ekVaEzbIQ_p#QWROH^R89K9`JU*P z&wa-L9Ea1xi~p^S{vUm9dDkU-{_+~dGDi@G_IB7_`RVIygp^uPC4$J73W3YmibXFn z9oHC8-dxcS)?wV==#W1LMIvQ}80l@+Oozg?&2_7{{cyK$f>xUCe z4)XrNqrI+2J31gxzyXWY&-1+ApZ5AI6;N?BKrf|6P&ncZMD>6G<*OYrQi)R4+7=5BLR0900^w9L~tj|*_dTb)f}q$z>6C? z!_gS_D#`|tjp6MQY-&_=lmnjUG{E^b(!a6Seu;DV0FEe6Rrw$WZdkk)@d`Mr!`#pC zHGVI$5FH3*_*v)ZOvu{B)I!c`bfo0`jU1YhzY%0_gy&ajU{n=|PlVZAyc?#Zx-!4Ej=9qEp6%I`lpYx&3V zYR8|Lx#4I6!}@lg=HC4B5cymi!_h*|w(wS4$U^g5=_zV@Tno_B!oW7K^6YqIrhyDK zIAhIibHuDt0Bw~k@?2ev^Z2vU^PgbfCXm}cI&x}{ENh!V=g!`cV{@bV4f=Tco6eiR zBWDnV$NMXHH@{J z*8;NE0F2fEW>)`!7wfW`&o18Y@;}bNO5|cC#(sh8&p*M#lK9L#&c^&dviXmy5JcFU zd0$R1oWjAFI^HFgJWC%y(pQKdz&XKMjQ`G4`cw{yz3lFuWX*Aa?l@~U@wy~NsvG0< z-uC>tx9J~c+vch7cuhD98pYf{&;1sZ(m`e?UgJ)UiU46px~yrJ_jkGf4*S&EGSe|_ z_Oh*<|E)kIrc9?uI`+XPq@^AUpMIJQLv3B&^1$;61YuQ0)_n0EpQu zgg)WJIG>?uwG!1~9@^dp;%Xmo9cUJPSYf{p__b+<2S-pQQ9Zy0sKZzBtnA5M<|a!R zky0^B2Q^!K6oDSu++qKIhPPwL%paTr7)=i}y2zbu!+1b?<%$Xf2~J_;Ez_$D!WRcR z%ESZ!-j$wU%ngv&iV($+AU1FSkQ3vDclG;JH?Fk8=4tf9a45B~I=?HrzMbg^z=i%^ zk?-!xuzj?5WwTdYZv(1)EP|wZ?(pg+Y;fg4iEJfCG)R5~<)sn8F?txK5M2(Z9fp2Z z0-fk*f04b>)#>$X$W8RWS1FwG(7%7-D9VYBNa&iM%lC_%7!v~((NTrR!8YtK_a1KRh=Bf&QjgTY z@!r!tyx(v3Ju8}{G{8>{`nL58`3|0i(gJ%VsCjIPpge!|4NxRPq|77y`wtl$C}J>> zz%gFmHvrfoqb30a_R6SCbeKQDq>cFbHtw9aC=I;CfZ!+g z{s95QpLY6y^@@H2iX@<9hdH0a$b%+bhOt+)>oDtwll?+IhS|?3MZCgWs)FDU2{RA?XZZ1>Y)K(h~`@QTQ?1Tlno-o(QD%h z|GZ%7v7ts$Mu;AYsf3)X7%DW7Jp)SUxAK_l{d;a$#vWHW@70GrPyK9j0Je(o>83UG zSq-C9>t(f5{jgwGZ`wd7HF(A*I<0ws@&Po#t&P03pW!Zncy;YFGhg3fuR5IN&OhA# z6%f(ob6xJK$C>VZ-aufpYzNyxH@7i79ROsfmmT`rJa-#?)Hm*tJ*XprAF}&l+TR4KlcfJzdTIFFs%pz%^IxmP3BjZ(#0dPf&a?s}ttg zvpIC#?BA2AuVG75*JaD)s0Mg?_BV*x3rY<<$Nd(blLMThG!J0b1(^4+2R(rE_^H`B zQK9`Q?sJ-Foq3B>AJ28A!G0dBbel^6#qGd`jr0F;zDon4#-C~;;A=81)WK=&ywk)? z^hgV!+WM)v8pv^L$`b+6YfT*0hD!Z-Z=JoX@0Z|Igw@*m91&b+|LV^-F`xHVFBJ)J znR9nM{4fhXf}x1+T_6oHiepTyLX>=2%#43DL&ZbyaK87=Ryen&Vu(n=j>+KF@F11o zln~0|g~<<4dO(canD(de<-=)oG_6lHB$h4?CmR5k3g$MZscke z`oG4;|3n)Ac>r=ijlYX;a4!H1S>axXgpW@!pmxCnJkP)@?J+8(tTe)*ju7Zt=cRWT z=>~*HV_((jFB;k0?(nuk-OAZ29Uvm#O=%RPv`cwm07VSQc}g02d1tD)2xW+(Q>Q@j zE>@`g4X--b|AXmy4j{Bqw=NEX^3SSV;F@CKM`&9{Pr2~VcwKHvV-}2blxa+@8}K~{ z1c)s7!30>*=U?fblhas;Z64{EsWjN?aUbcJ<@WsdG%(Wl)id%UAR(X=2Iw3cocClp zAad8+*`w!oQBlC*3RZmAp>TQs3URX^Q4+^>f(@^f0CE#0j_l_kYZKG|HX8JoCxDAy z54>kUyo9YC33!XWeh~qWGHBSxzf<%=sf+6qGz#zyVrWG6RGDW)1^~ZGJH(p5$spnR ze!t$Qw9|fm5BD3q2*BMSMkZ1Ns@Qm%fz}>gb462B-BC@z69C}X8Tp7k*IKC@b1ws+ zBMqKZDk$<~$x#^r;$Jz+w1t7zYkUU9qd^f59q#=Q82hv%1OUgOJ8aC4acW9oe1ZB~ z9KL5ih8OL*|HL7DRpN*nf-#MzL;Kk1i$kz1qgPRO_+qCBR7r$kQ~!yGI0$G=_`Cj| z>93eZ__vUGy??&9xr1~6$Xg4e*h25LCe74VPM&*jUz^?BI-}V% zsDpfVu5lzl;a_Bx^)suJr=`Mw*nCzxXgex;AK8Ze@lJVxOO&{kmx16zQ zjOR4xeyWmfgd@bw&pzwae}x<9@a$87rYVfw4C^+74Vgv9&0#p_Ie&9YIaO~Z`e7Ak zZV{PZ%{{N>Gwayb_21y7NC5Z0?zveesOf?0Hgj44y|kvuXL#>w)_U<%$t74orsvti z*_i|?>ijpyTFxQ&bLg|#opWf<6lZhtLeE6tY)tXo(_D9ob1}6=4m;`#fT82N-(;P* zpAKh0gOM~Fp@$9~UzR-;CRO%_4xUDDPjeqrcV#=^=qiX#=_3PuWMrb}%7Tk?2EaJ? z)(D>fY5hIPnN4(jQ$PSf(%RCgCGM?>Y&W>y1~S(`HtJln_K;b20DzeE@@SR6RqkA+d1BIY ze^DN$(EPp`ZdZzBgmqD0_5c71*Ms7sx4fbu$|=|UT&hG+`h)L{(ztioAR|bT%8*f3 z4LnAF0Mr=W3stTrV%xOC(|Q&~6n^iB#%~=)7HfZ-1O(x6E=wk)&7KD6|B>u6PZTx0sqnguBppps8< zJpi)7KRL;17=h^1oDvWhKx94?^6*ET0#F$$3NQM96l|ow?~wj-zXt^$rPGB^i+OA>5E7oX<}0!0mv%(P=vARyNx zA_*gR(WY3QKKn4r^Ta?QbcVWTMkm4@oGK83P^HVNEck{~2O<-)-_f$TkpLh{3(+NG z?DyE&t^`oO0QOoViKBJ!#qR#c^~&sFMb%5_n##o)6$momh`|7RT1Cgz6k0tx%c>er zOs~3uL2m$}8ZyS5@g{50T!*55O0u{kPd{Z3{v?yUkj3_`t`2yU340=eaqnIBqqnIW z`~bFM6zslfz=I8bQ-<~%4GIhVNH#K3B75YXHCNPH-vUi`)T_v#}n%u^#ZU9uT)) z{D5r}B&_AT*CO+408*>jr&T}A*1yX8&!R_Xux~TS`7Cli#~RE5WM)sv!97#`tODp` zFefpRlUHW6V(R+|2$aI;pOVBs%~KFJB7mC!+1?4z#+51o!1RB}XBM)XV5ApDT>8g( z>HjO+FHfL*CeRBLIFsXp*%G>k{p@`)!GvZ-L^B}uiTH$5JAkv6h^AjRS7TSdPII~6 zp5}CLJ{t4x|1Z9Zcq_Uw{DCU9PY!nf`!XJ2XKne&} z0q|15xD9M!5Fmme!c&-b>tKO_ZEP&0%oWC!$FH3KE%sP{ZZL400f3C=Vn#8dhWnZ{ zWXqMxP!3xJzN;PK(0ctaqX-eoRn!DQSC4n)dc#PbWTT;czKpp-{d_J;+TNaqSZNKF zIELqoG6`n90D#DH%0r90@X0jP5w;d_@?nDk<+N1_r~5>}qI^$A8X=Amz;Dfvb(F*@ z^#8Y9uY#&D#5WKq5D(%GM-c#fYR?>11W!w^G#c9Ag{Z}{4BK*%1;6MhN+qK?kq5uS zUjK29G6@9z#$W`YSB-qMYSy!;BBN^1v#FyrGWO4O>*og?8F;Zh{MfT}S#J5ia! zzC{zE;}a;wFd;=_#B~v`g|iiDr0*C6+~Ek(iwvj_^t#CVS2{+#02Fh~S5Qxd^DSpe zK|Sh-fYNC%POuz5*~8!gTw=p~cY@C0eH{rpK)_LxR3(SWKq_yy}8pmytjE~ zMs%VIg=cSY-;I^Y?Pzj8&Fyn4WrKBVpr7iOCwaBT*{Na+s^3q3OXX?-01T_@g(DX) z1+4t=1L@Vtn^h^<@EJ>4&UT)S)i3P%UTIJ7OIB#|gvIzf!p+J!$AoAQ#vSE6cJyVs}DU_`owY=t*pY6yr_%TXYjC1ZkdLalX zs3Jp=l>f7Lt?&748cTK06ZnbB0aY11-D#msyav-Y{5Kl(oa*QQl);p|UljOblk(KN z;9E9m$VH@3Fd{*OV~x}tC|dQNkW+EwK<{9Z=`6xtVY?*xbRMe6*8(>oIh zSce{RN49%!YZVz@OK+yx%LnFC^On8q=3lGY& z9F96po0b0r!oHF}XX6-A;SA}(`py#Sv^Wy%hQmWf#$J5$*In^}0Y(Pij z6&VR=^4{jx(qL<3YYQFM{vTfazV(YF2DYwukAN4Ou!nAH-IkpMqx|c3m-g}O?So9_ zTXfD>Wr^%l9bHrZmS@2KK8LZ<3z4;s!p(n7(pmKU z7s2fvY4GID_wlADU@*>_PVkHqzfCScOfY1hW@Lz2 zr&(lg_D4A^XchOk_yLUeM|iRKt2t+D*rRpmjrHi`4eZ$l)@}p8+rVC|NAIpjkFHmG z0DZsibxsNJw>1EwHOTGi^K&rJO3v=W>vHm+$_^vne_@8?rxg`YuAVb7vrmTmCl#8% zB}*XD%QU&3Se(V383M>2A@W z;z?<2^_i%1zi;WW&VONml*9gq|F1O1$p%U?cFX)+!~VA-9WwNvuxI=AlnZ&WQ3`pD zf#qKv1yK4x5eJbyf0z-D0C_w9m+^m5MgcSqI!ZkS02LW|t|JCA{^A5w{7i}zDP01v z7{J2{Lgn=d3>67buY-sTC{iHuBl0nT@{E*|qC~2=c%~yPhdRpg{#>&l2rAbvdEp)- zwZ*+e$H0wbz>^&rI6Z-&2(BSh7?5ZgED*J$WlEI+pE5}Lq(Q)_0h23F0yOEhl&QLi z>c}7iMu+}v!;R94l0cpFf7x>vheIj8f7??Za%$j183l~+z5swyJ*q6&kdc6xP12DFQ zn*&|q$|atww2dbM-izT!Z5@963Pd2AOulzT#Y=S>V|8$H~{!)vn#E!MepKsI=3ZOF1d z^%`jKxjN5VV-ISa;acBhL;y?;Jze{8PG_yMmUZNo(;>?Jw6cUoROx?qa;PXiEV zkc%1Cc={z-sh~dp6I^#3y)g094Bbzz&shu;;zwMRl>qH!*-N2)f2L=8V)4%>Summ| z7~9FudVteY6D&p9AA3BmlmWnId~ULh8@XbVF1jAQ);?6AbiM+K3!w1N@Su$0pc` z2pIW)d7^A+fpsa|?9jJBfIL;@s+ITtwn2wLfIQ9J3|i_o@QMm-Zm*YvEdpB@rtKVU z__8AiTE9KL#>e!mzkLL)s zf8U6~PRR_G<>3}0LVlv2C zi0P3csj@CHFMzewBtfllj2IT+I>PJnb%Ow<1r%XopO-5gBS0+zrHHZba-;+!8!3S? z1F)_mPTx)-FoYZi2@`pWw!tehVmHM4ic1ql`Gx8AN3V|u{JJ%NMtWd{!~f6CS8xFE zBBQ!Myn=W8=VAW2Zvy;yeaPR>8i{WZWWY@fCR8P$l%4>+Du4eLiGI*WS3CLnJ z1ws#vvF=6IrO10qe75vyUaVXBxt?Ci{gsi63c9U=99LM63eQ$$|7x7Q8pgE7nXd1h z)7Ba<$QtbE68Is9YhP@FAiA-M{51hf&7HGxi-1Ce@2|+uwD^4M*KX9ac{Ukppj(Y2aqAL<4_rY7E&L_HZrVxArfY*I$Qhufq_p`-Okv46NlD*P;v7 z007o-Zq@)6R*_f>qYiw5xcYs{jrj>wD98W{ug};m(htYI^ zj&~0KinUpPZGnv{3Yqt zML+oiQsIk(pxj^#072k1IAla#jq>XX#mlq(PI}N${^&3wL>j!QcG3+a1j~!`>)| zxgcZo412jxveA=QjADrfLI-AqW4TC+$~~77@B}#7!^UjbhD&<`APF+t>FMb!O%V6- zfUhqe0c)vHzRJ=fgg{;Z6ew zMG%x$QGWYc8#(qf$`|=v^wn1xvLYUUI01?v35;%$U@b_2ulG+y zUI3agJ@B6iaHBzxho zF6X6(G49=CV{}6r^>NPV#5c08T?1?STc;81%lQ8`J^UW)+Iz@`4EY-W*iw!(J}C|1 zIQKt}9@IEvg}$dSO4I0?84TkbfM@@^%W^Z)5?{KGwU+0*Xk8C_6M2=Ox7>`Qw^rfO8; zsfmBV1;C!Pb~PV>v)BM!HC~u|T*H~KeJX)z6&+edA5>Y_D!;2D_cfIPq64bvx$0Xq z4p{j>)#9Su)txKabn4#^xX*SWnX}5VDFP6T-JZ!geDSDqbOHmsCz=Aa^F3+|5<^Pl z#awQWPmF#kL4FSM+32{Y95o6;3~}Wy#X#1Cu`xWiu^lt=pwOUF1{#+dV{g|vB)nr9 zu^@T5>@V`ZARKk`6DxbUyvUEI;RqvsONN_cs-Q?_FG{6e;2sN=1OY)3+|Dl<8jMUd zh|&Fu1gKKG&pE=ufr*sIH~lR7j0`&mxuASCMz|m_0P-xLkP9fU!bc1QxW57*qkzyC z@M;PejshE1Kwt{2V*w>!K+p;(uL9tuATr?52~Z02Y5W2V2()Z0X%yq#384U>I^=^m#uW*#;hKwWx>;L{VVi8eMlm-K!Zh4V1__;&m0yHXPJe`F5uSR5H1X*F~U5L`v2^Qb$S~DKewJ4+D+{jN0IfP|1Oe*#kW5 zz@UM`VgjLvo?zStM87QAsoWkL|Oqwzp?TocnA8w`VuHzpmN|(8UP?W z!4FW{;3jhp_DpawjM5z5!YRZp9eEI85Sb3*@NOAZjH&>PSWE>yd+G5R1zclf55GsR z{Y@xbZf*d&V&qcmBfal=$tw^kFnW}r{EBbSlH}q;9vQsO69M0yqs_~0mjtqA74D-V z!;0RhVsNVHkQ&CVhWymV9QIfK^s+@c&mY;WA}dvlNCmxDX6-7hO9eesL7!KU zhw8pI{v!YJYSvxze@B)bs-&%lZW@1gcKVaoI>Ej7+1vig9Qq@pHNjp^U}QD6w#Rwt zp)-5j)A+7tuVa|H_c?ccU;b|VeCNdHTt2v$y9c80=HKF`Kb)I+&cjOfXBB^21n8`0 zP1Yc@YteCQIZJB*5NlZbHRzc&?A01{=xWa5BG*~<75D#VT~^_UtYj@$0vJ~E`IP{d zg?UdV+$TH#O`{{G(HYbHeTseUUuVNSnUnbh2Ks#e1Wv~|I=6R7MnopKmkIRIgb0!% z=xv$}lUl5OYiBo4;&a^(_v}z>t4(YAk@Y2 z>fkhW)RSRb&vSTA@$~m&TUTNSw8%xF9EI7smzwrg3r-Q0vcezMr+La%L(x zkQHod^_e--BC1z*iXIo61OZ5gM4kCGbt}4U?e9{V`?9}wGz(H0Pv0aP6xJwGK^07Q28VEr6&CpSI_J zy2}rj?42rAppv!&{hj|~kNatkOejUca~4GYLm?EdaQL75(X>N_{tJJ8{QXfP_y@mk z%CLPj^I5cqFT&bxHe&LE*QCLZP`1hsH%&lQKqw3BPXR@t-U`u`kprM|y)XbzUV1EV z9}$4l((nlAMcPM9dZivjfP2tkYL)h>(g5QblkPbDE5s*2>90^#g*XHP7$OlKYjDNk ziE+VqCU^@n<^>tG2!_7+0B=oWAC(-JdM%!1gfg|oc>9J~SKFGdS13UG6-Z$txr=k&O!N4 z&ii-G`rpKPfAmU~^{t6e1u&{943CV}S;Gc^JK6%DmBg#~Kj*mq*$ltexPI-0nTHi% zsBva%8yuQ{q6u9;dHnNr&Sf3huBj6tXRy}rcOrjP3}N-n8IdUSTxIsG%;zfXca>+U zKH0MiIP3M7IxQh^aa?i+$91NtUGckQoB)&KCLf`jUuf9OR@+7y#V50ZBOPy-r zx&JPE)#cv00HE$J*|$I;>>lf+@xlQBPRxGyliceRz+sx}%q(VYzB>QSwcQ37khE}5 zw)0&?U$36XCO~VD_tpP$$3OJwYUF4&^1I0Xtm4eCWPKMnmkSFSQCQ$R7Fh3vPr4Hz zfM#Bx16i9vr%$tv(;@@%-BalANzO}*ROY;lqjSc8@BBaV(fdaZXX;*-&3R%SCbQg6 z2D|-d4}3Z&NtNy0vt%!Z_q4K7p!;QabNqF73=HG13JY-tSf3vDDyA`_m%Dtn%ky;B znVTWv9{{Gs{9a9oESN@Y7N4F2HNv~+;iBetOGgL(-~k&KxyJuW zx8P(kNAJpVoskbX)c6t`36Tj==9)zwV@bD84@6~5YNVrD<6(vLUS*_yUzX+wv5%ga z=wBg3k&l#n7f~*ZnY{IN_WTaBF~CrYJSXF!JhK2tbiI?(@^Pg9+9bq0T7y+3l(^_!U}^4dGMnK1E-`h zRr8uiSIF?lyZ)68$;I|M1!Pp>rcyQ$8UJ8I%ySo5m%_X3{o@fwX`@mG`n>Ys;sPja zEvEZQd$KZ6_a|@(9>G`|_;{{od%aXaaj6a2(0@fkkcl8h3OrnHLnJcUi|p+oD^W)J z0egNTuN{}hY*0i)5fEjxc63-@<&q+>-IU&A7?FQkJ~p?3IVnTl5eC00BP%g;L4Q|G zy!Q2h1S9I#ACU|hcVt&3o^kKLHMrU>fk9MuyvAVeRbF3l1m0;t@ID*+PuSRhK0#!3 z5EN(-zvNVd1FfIZ1ga#s%7!1AP=~=Fjbe-jMYt3hP-zgA2;Puu5hI6@E6om2i%^Dd_cZuEMpLPKSIDzUu4 zMq1=Qk@Q6HReu15`M;UxAkqdecQi&!|7SYN^F#wZRS0qaLC_QcK;Z@#d$txK>2*0yM_*}@w@7ER^|`pXyOWhqRcavFi>T5 zQ{|oZ_*IqA@_n6`1|iA09|{5XJUqLz$z{ktcY`{6kg zK*mbVf;t%8&d)u45a7{SmL2kx%kH5g$BW4c5D%dLRCfbJey5Rzna}0yfH}bLET5fa z9p>up0?74O0qhnzUyGcpMXs@W-y{hx0u~n0UyC9Qs$amTGrvF28J!0#&L5vZVjf*Q z&sm-4oX?>@<_>WqAoSrh=VJ<+FtwwJfC~AmT0yn=oQvK>Mm5IIc1nYPcePI3XOH*w zK9L}(_gqh1+{}#pw`Rx3Huu`WX2h81r(|QN=&OM396vI9D~KZz1E0_--RlgXIJ?~) zo%_dG>|jgVB7!12kBtC+t~)w@Bj-yru$wV&0$FKrFKPqa5ZL3H>)4$-`mzT2uRf3| zAw`5L0s>z(ki||{uNMILLWb8y5w0Pcjfk!hS1=T z$jMFQJ!puB%7TJlps*+RtG2u`z3mM)pbFO>ZzC#Yj*^JBxGJAgI8&q}ejn4y_#U+{ zRZdd|N8?;o`V}1mQH+JD^t7YyU4~M;g57PLWiU8kiUtHh@8UEJg@3eL5uRj zQHTDowE^OJqVbG!<0smX{Vl`r5u*Np4URwu0v0@iKRT-L4Mz~(<7>}m*gMh<=OrKr zJ_LI*0GNts0>T(gd@#f!OcoFvl|#mL1bRmPE1JNeDct5X#Ah=_5jpk6On-zY|3Dh+ z2s58-4^m}cN~y4RB69{&^HN7gUY#j{FdQo9R0*4y>08_L7YkiEWdL1N0B|Uy_Fq*Y zBF3@aF|v3k8#sBsJX3Vg+auFFiU0*6lIs<&T6(-}QO5tZe)g@rmwVXwtJL%DUS|OS zRXv<$Fm$v*lF}iH%7OF&1LnO?xL@%uA~mz8`2b1@eA1kNqCtStDC#S~feiwx0E8kZoXeOhsC5wmQxz$fCZGy# zh79*Mj;v_iM80HAqjfL}VTkJwVK`#w*Y1Ar4UW*DfTJ8(;A~@Q=0+obdG22fzZ&;T zXY5=94ORMFY=CfkIsm~P;0zC4pWr|h3Q;kD+(v^T0ft*_?74>#MGlq1 zK>5bp0@iRCuP7!Ho^N1q{;jKn#(&A&T735O#sR|W95v0WUwL}?ef?;_q_iSI4_ zH0PB>BOsLle#?M>eJcY_D{nI(V6Q7up!~hIvkkfoKVYu@vg8ERcyEpUuOjzV^jrla zUwv)P7N~wZ>#=L>S&iqcZtheis7rn{d-3ZHe^m%240N!7~T6hd$X#US3iJzQt_(x zKE~C`@E_u^;VsE~PzX{Ut#bI9uqTBd#+3ILKyL*x!xc_eB;ZB%9-nDLva`L)S2=BP zwgJFd_Vl?&jUbNZLOa>GY|H_x2E3FWUU+nXEwS~(n>;uTbuipz)b4i3UuA!)R#;{L zptJy+9o&II1C5@e0{_VS4iCO!kWjVZM>q=XNdd!L;Qk9J{sKy&fY29?;e~(}*w+F; zs(@g{DBWs$w(8&~qa9QKK5E7Oy;SPT;Ya1i$C4*8Sj@D8dih6P`*-Xyemf0Oc>8}d zKooiKzIU}&sL0Ci$UT=V~uYti)1_J_niohJOl<5Nf`yd0$(-UySKqPSnW(@=s5l|^1ibNG4 zQO$w;4=Nf3AdHdCt25dZ{T&4Q{%&~?=y_#=r68Ir#U;SC#+(3E2VCkk`GwO1`rMKu zBgo^5JrV!}IFmtFPF{TlM5YvR6WLeAMMQ3PG3Yuh*FN6+Z0`*+62pjoZqSA-M=ydA zg9D{;Dvme^jDOX8qJ3I02v}!;pnt2v;A8gq$DK|9=tk+Fq7N$!3a+=VP+7665bm_0 zmzR(145JXEgz%CiD=Sr~xf;=N@XL-W_WU=#H!2MzTfffh1pwfFN4byDi!!Y_c5)6T zE3)=QK!524P6c3WO90>!Af*JzD50Cm%CnbD;{jDM& z)gSOeKUKbx;rWWf^qi9l-(B6y<%7sb4F{x(&aAR8RRI8b{OnEjt(m*6pvx*Z=XdKK zO1!s({Fcy3C7!+V3b!nN)TM|b87e=_J+|2A7W%9uCi&Bx{~vdYVbz+mKHbA}0F9~v zVl1sf`7(5uCpj%hX(FfXk`o2hl`dKtU+e}#$VwLw*n4}X6I2Qp9RS&b$@la6dJYkq z;u&W6-Ryuv^2qB9#%`8#JkPVv|2pgTMc!K}7C+Cj3VB@xKv{`iUWraw2_RdE%&tUc z=K)P~iXs4nXW6@1fcq?en?>Gck=fZ}v*}O_9>NGue?FQ1lkYSzLB1wABmEt-tg&}n z0;2A*na`J}-`j+LE8@Yq>u`hc)Pm;|(x62QK+RLQ|}wg6>qRa?9? zfkpS0obM1k0U3Wq4A4^@jB!l;<9plK;5Ogg=I`yJb8bYd;|KsU(O_K~{H?*WG(K+f zC{ADf*N#E~?rQBU39Vsst6#{z6&2R9jBYLeIl(~n&;SCPY&yzfjG6TT@l1m z3 z>vP2`Kw!pH-+QfDz6#xmi=f|e;Kva7qKGV=11Lf&u z@V}fuK&63-WJDBTcdw<&B)7E3{~m+6Egcsv-HuwT~yDmN6Z{QV<8XW3K!3P}) zKp6!&Q0bPd{d#06n+WkeQHi0dl{1_U5MWV>r#KhCO7If=01;cC=4b%-upA{5jgtl} zCjgCTp$yQ8Ho_vqiXS1Opw>g)JLfD)0)Lt7s)j%@WpgRPQUC>c>c95-KjO8oB%qEN z42l#0?xMxF41U4?SGwUygD~+8lyX2hMKne)@ee+hKsyFs={kx`?4Cd%Dg-WYq)4TL z7|`GrD0QT&1@RJ4=EIz^7&69tqACdk7Hx!wd|tn4qTn|(8W@27_5O^i3i#d_MXc)! z45k8^uq zfLY~Q_W?N59zJ_f+azCAp0oPW4AYA=SlN(W1k32n@*f>VU_B~)Z}elAhsHBjuJ;Jy za||$4aUk!W@2#+R<avA`>@d@*agBm6I30ejWpTr|+9P4y7Kp=a%TWCGsyb%Q*vzZ4C^(4eKXjM8P;w_hM)5_!`{pw zOVa?cX`XwU`F{D1GdWb&&*LTjT|yj}LG%YAg%`!;*jKGEG1 zUy%)+)Yn1fl?|R(qj#G-rl;O|Ng8g=YY=$qat6CRL-*BrElqOlJYui^Lm4TE84oXW z^x)ZU62%_3)Efeap}AcGI~o4)`X9`Wj{yJ_`9aR>N*e(%Yusn`?^zxypjwgq@r-5m zsDiz%APbcr2>=YF_b)?RT$QZY(iR?)v9CRS2_8aGx+tgnl`x>C1^*vZRD83^f;xoP zW}YwF`F_j|eK7bjr~?mXjD;w&a77M+=6H`{$TbgqltVbmcaI@ZMHaO5tONitIvC}k zzTnYGOyy@H^=+BnQ}k(<_s^zBy*fe`4O!$xB8+M=8{yFRWzI2%lYqiwR{7aUJ{n?? zlwVZ`JavnU(lU9~U$tRnErKL?rw#v%jlB#kfFg)_f3qQZp^XcIrUo<01xG^|RUC-B zpy&nP9bFR@23IY&xCCPKi(~L!8yB^vl?*0){>abtufJiclp5dlo(C zzh-5Akzexg-{f5NI~?+6A2lgYjQ15N!|3WaW$#c1U%(8ZRXLlCR51N#?e(%(Q7_-K z@!3BCUzEbBLO{ef0SgYH2I;8NV6;qD8skhy0u&i|o(=iVHujqv2)w|+>M#ENbG&!2 z@Xx3F^~3~(!Ijw6kpM*tlor7N1n&eT7nK8w0*FHaSdB(P;sG3z{E)%-83debP5_E5 z8b$G$7;3)MDk#TCunNQWLFY%sCI$-IFv};T|i)nWv97!t7m{=Pkb~y9#PN zdIgYNRjJl?_VPDz$ss_e42URSXyBm81p8Zhg{u}g??rSa0WkvTPC){o;|87UxEzWIO+3gMPW&5o3%y6K*&Bwaj~~C2e@87})kTE_qW5fqQ82 z%&nsh0REYts~Xqzkewd;FoC@E(Gh+0*%Y!cjX|5{8q?_5X+Y&P`!#d0>+u29lmFn~ zocoz#cI%tlIw$tcqdVq#rg_$Bp7+haF?0P3+~)#vG5>|k@z1W$218R^cY3R=HkfAb zW)x+3PqrS`@S-Ws+7!<;#hLE^-F5k@Za^+4`1knX+2%J!D}OKB@2caU>hinDY-cg+ z@LTAq_BOeGtw%B^9|jn}RA((4C*=?(G4!Leqf!O(?$6D(&Yjb;#=rAXxB1;E+X}b! zzT>jwuZ3*2zMn&*Vt~}q9`dwX_KHw@-v;|wpK#8fb+3QTEvd03b?&eB?@R~PUXjr# zk^jn9S_U~gtuL|aUhPx);|uwtBY7)v~O2|*~a=|vRw z7=P1T?g;-+W*Bb-6GmqO?lWr>Rv}xuJ!x0 z9*@}AKfyrn+KeIyd<6h_$yP^%XQUa(| zj#U-FI!9?@!Mp;Ubz~s;4l4J3V>%=eg%pnfLpp-~7#%i=S=9i?W(UAx{lB;XH(ODP z{Kt1y0816_rOIPrgWbC%2K zt_m_!*)Kz~W%j*{Jd}{hGO|`iu1d&yiNBT5X~nOm(-gA{So4zfF|uFT+FXRbQxHGT zlD|6N-(X!E>$2%k>$N#8FlG#JPwj@iO!P*ZzjwAzV=u$k<+|MyvrJGS@AfD8EWoXK zpF0}fl4WRZz*7fDrHlOb4l?X(H0wV3 zaCXU?(%;chGw6(2Y{DGIat_&<<5}haiL-pi?0+)9ujzsFto1wqbq*(Q7T`7Wnw;P_ zrJv}rDdcr}A#47{`k$K0-)kiCBZREXupFxut{y#U- zZ)_>&KOAC^^-Gug0a#iWy6jKi!@f5;(~S!<-4LMT|J(xlBd#{#8ZoAtd#tgawdF1s zz01w3o|Lj!W{=8BOYJEDpj7tRM&#lw6rjE8S?JJTaNH zV?3y)Zi#6-j3B5>;OMp{+@P?Er|`Pgpn{ti<8T+BkibFJ20$h$3Ig|CggoViMmk>~$lM!Ng}nf^9EC*#$N@H)QBH`p5slVO;KM zISU;f-dLB&_n(^zIgFvaSAG{nIuy-{{gN~n?P>Q<&ojJ!RRH|l1`A~n!;8dp=iXz8 zk)i-7#>nUI>YuN7R6rm?Iexr_;3u$d1@s^`Q4`_s zD2J_2wvjp`-y10(l>mw%f3=N~Ld+Q2XgVZ7sOX8(C?Z1sPkQ#^0z^ZlhYhO!WFV!~ z&W{|q*~}o|9|l@_&vga?s-k$3qaXr9uUvX;xKI!+C3{~^;2CoR6oueBqa2X6i;_U4 z0x;x*Z+1lBi%td9%nMM7AfJn#0Wzqn3_u~O9dvXL#DIxQ5zT`nQ&TqFS9vYI>lf!X zqDxARU|gfjRxcE0w3}9>;4cZfp`;AD1K$|K< ze&pYE3?8;LsJq>OL{S5QcBOJuiEz22KN!R)2faJ_2hp5sXP;G7Clr%6FwC08$YJ&~ zdI!kMS5E;|5&gqwNEHVn2*2ENQ}Z?cndtz{GEwS4O@ma?q*3H!r`h8_&LMy9sRV#2 zeJ~@NW%ObhMO?v|sI0M1Bd{(E%rOc%JQ8pG0cCLO!LU?|BM&=+z~5XEOz#yeQ*K?jSN-~ zftYNFj%{6?l>psy-24Yw97q28`@6Buhg|!QEKJM8XYHqcm(6x2G5%AW(<%M?H|dQ} zZk7gmnsYw8OLhyK0}#)?$DTZUJ%a(B{baKG=UBse_Fx|8W$u4H=!dnM;(I6G;?x6c zHocw0{)grOqsjlxAx3@nX#z)K{AWpejI;;$(B0M~$K^KK=%)^Q-}$mV^>ed|qQ(8S zI14RwO6!}Rz_+;#FuJyWh4G6ucGA{0@)V<_{n(d-8>iV_&P zDT#V2!%^RDkphb^$OBe-V&>F}94?In*5`v$pnoI4MGR#T&u0veWsHM3`h%?7jlKfU zPtQP&fWi=bIm4?_$FBNqm2N2~dzp!U7o=fO-}D%eqFkfc&Y<#Pgm#3@iaKJ1b{J!= z$!OtquvuzvDq>S8)?G878|j6X!@D0(B3CH9;q=&K7&yq~rdS)0QG1RGFD_%5O@86Z!sY3<6Nx(HW4<4RT@E#{3u?b9wdK`{z~$1qyS2 z*wKRZ1^_Gld4ZWT9VOVpQGhKoVzBI1a|A>}WX+;qfyj95T}=Pm;1Fvy!9aBWLy(sP z(t@-nFION&Buu3~WN6g80fZX4XO)sEnjkj2^4Tby$al;0Kh)kTMj`Ua9O%d~qYPrk zf;`cSm$G5bcWrFsJ*$!exfw+Hs5CQ-vZ5Wo^h;3__A{y}Ztyz(B#nFg{r;sSTPij3 zpaH-o23pq{IEeefJw*3K@e0Hj5WnMOgHWXbFr2Cch*mjRZvfX(v7+x*$)X}RRo{c;oHG?^iZL60 zm1*)Ek$&L+E4cqi-+bCYPhy*{rZ zpkl<;8zjnmH*@rXGZftkd2S6V3XZ_tnMNGtY>(dQYNj70c{!p0SGpWf%zEyxjO>=h z_wUbpL0^; z{z}M3Y5yct7tv)JO)}9JeuEt$$@(;^t%;{}>~T zT(o!2?spv#=2m1qyISB*ux^vPgT>J;yW7A$PN^^$apUjlrM7W=vuO`sn9A z@;M1eo8&A{ekBQieeS2vb^AQy#M3;54{=Z2}{`x6NI*sZPm6vh`YS_fu2eS=uM5nOp(IJv& zsSIXnsl=L;_`dRPssi|C=H`os<`9fBMxZ3(-+T({#vvHx`;BH*3BUm#`+WijmHkC~ z%>%PzSCrgfgfx?T3`AOF0g60Ci5n=1Yk-m*L)eNZSmHvEkZ*2DH#e{bW(eMGMTG5b}j_cnX; zGX5{I=l)@Xgzwq#uQCY0;0A|5U_$8)aU9<0D8LgEJS^i7EK>+vJOZU9K+b9%ERYgI zU>BRcI&)u;(^@fXuzwSt~or{D7XL@m)m<@&k$QeU6Dg%38)L1f(oIUAsGJZb5W|=- zQW0U%=RWHHkJ@N|A=f=p5IZhCKA%8F|BD6(pYpZ#%XN;IA_YpbVNjNT*x&mx--l8` zN*f6H3g9V9@b5e;aVEc#065NqDhgQhm?(-o26tgD(*)6SSRjDw2VwAR19XM@Ih)bf z16dkU1qAo6-V~}X2@up)~Cxa3{IpfXqJfC0(lLL=+qnRK0-!f3>;5PEwJ|e^28dMas3Y6>ScTGT0>l^l9 zf1KnsH53|0P9^|Jea^@f>pIPzO~1p__xSEf^l~2^H~}E-b7uP7?*w~4!MgOZACsJo zY2Frx{1(M<_fTOv*@E)&h#wnK69U=3^;sKjRYF~`*RerzAL8s z@!3A>I)P4|z=)3Xnen4?vR}8Kkqk95iZsXz(nz;h-2;#vj4byvK#0!*wykvKIwm}B#jLm0(1nyNyI5ByvrQ&Y^S1&k-496*qrB3`&Ajl zC}oq^I%Pnk2*C5~dH=6N(+I385yDetlcT&()dynzE2OV5|FDgeQU>ziZ?%W3_p^Ud z-gt$h3OCp|>isA#<@;sym#Mlzse^CW`{n*r@}{*FlRWPI;S9}2j#fbEb{pmc(vwtk zrf6=2a*CluGSV{s2RVZCMSGVjb(06H(l;4+aT~N!1m2GePX^7!b7n>%AKc zobFzFd|t%f1_AGOBuY`Do?qX}6w(0e9Oa#lI2yq748D9R`d37$Ack~sg;N6K<_275 zPQ$Mp2@p6!7Na`gqq&~(0_;Q^VR`Dx%PW*G{s18GG2VcP1jbi9W z-({zYb24^fMoCqM7;T9^;HE^ZW3`$kgz6)pCNLTn6rp|gw8b8@K9(WqCifa6i2+F( zQY3FxEo7rQfa}NH0j|~JIvP3KW}RE}2_~AXL*pDX&R>{y=$b^RYl{ca<~p4t%>h7O z`zp2DExqw6yy!{J_$2GsXP+k4<&-^5!<*RO69>8fK00PnQG$n)FEBG^-T*Q^$-Yir zX9AyqMc0u4p7;ODdh>Yw=c@Z3l?*9GcQlA5X-?7{l{ARbpfnlMC=yBvDe9chaISeg z<7YsF5N<@J+Yr)-P-~OBd+oK?-uoMx;}f*s zkC#C^PS1DTi|V~};3Exj#XZ$>7pmVSjXzUuirvp(p~4sQI)CRbDm{aRc+m2QCbz3+ z_c*|wXs=Go228)F`a4X2I$-PYVp*njhK%vRPp4oV=aI&4HF<|$L*lC24^3s zud)erWpr0a*qZ(7^QN`_r?uv$1@>t8G(IPBe^UNrt46Z1BaH#ApGO+k(G#ln|C)k7 zgH{UtyuXY;X{CLEtp0up;|o~y&Ik+eMnV8kOfwP0;Q3D`h9wl**M#@=u>C>NTmS^p z1u_1x29)V->3vNNI=TNY%AxO@pRSx+R~7^?XkfY;;O-U?+h{Pl8vHJb|7J1>bo1`v z%|;MdXm-m;TcwY92`@+h!aW4`D>~lY+D7Vf!sJIuWiFi(}4s;TK02q3gJ0GBp9tjj^~k%*kZD#7oPVFXj7p#?v2Wo){bEZ>t>S0DwDV zR1S>idU&k|^5@-y0qwz|iL-0X(AJk+eN*?BWSnH6oFdr>fI`?wmWK`;XMON@YAYNT zK+w!+0dvaQ!){h$wArjT0@3PB(Tzs%+z+-B?x^d7h z87FN{X9-Y0f$R~@%~EPz{G~vYGXrV~dpj~9 zjSv}g4}-d0xi_4S8xLY*%$b7G7arVHDiTQ6IdMUxEwIy%E_c7>weq1&$jkdN8{Gf_nouitY|-W@%-10 zL!`5$_u;7YKU87Ru0F$k1X`8V)Dd9l9G*wglt3ZRgc)w@0iy2fnqnkwZwY^K!j?vuenbT!@MG~Q=3Ap?!)SZjwagEQX^t*tScURuV9rbVMu^S^kjr~>~d|2W;(@%LAF;Dkr(d(GML2>%|P_PZLN)z7Iegw*d}q32r=;92p) zD)GBQVVU*H;~hzCN#iW9+xay-&u7p0oe1qyuXIclQGT zAOO?{w9lx;Y~z1rA>O_Yoc_0~fCUR5wA;}prhO(Qg8>h2$GKst|0)0Ln%sI{t6!+M z^T?w8X|vh6vo=QOhs6d!nRPa+&u^WXoZKBMJ*S0gR}azHsi?l?&#lAEIn*!7;i?C- zaPEh7z|sWAUH|m|qyj=wI$!y*@lcxOVb~yV7Z%{6^f}NXY(63>NBuJTO)Wn6KhTDB z!J?z{_qT^d&~@o|(A-=vEnw#^>oe)E(9r)jbl5aBS>!QWiLAdjA6d+T^X5O4xb(mAKT`>tR0CY~#sibx`&{6!f1X*S~ICTG3MhF_)Wr%ekF1bJ6 zEdoh25qeI?fe}ewT;9D!Yirln<$wS*5wH#VKMViJ{U-(vi*QAG`=+y@yU7^XJjUy_ zq1ShcQPn0|N*bRICaeF)G4Rw#_)?e?ekQ8}fu}&3YbEGVafimQgatrnp>_E{2<5*s zrZ?7jJLQx4dQIjI9ST_~M+5-K`&^=HxJsbL-IXKJ2Wajr8YNqVR6(*O2%l&SoHF=> zumInWLH<)h0Z-2BCGpPneli6Jv$)RyBEtK_7;G9)a90ew=3wb<z#WBrr7k zMR}4?*3%lp@llB_Yd?*34>KBr8N_}v7-QntORA*s=*+~lVF5I@w4|kC-Mr4t1)Z%c zw2oIEmiD>&pVfo|o>a8^s*ja8aOHiW-uJ9hxKzel0Z4$l*Z&`{`#Ju@$rzBMxLRKB zD$VE0D=Tk*wVrFW*23`s1bNrT%Skxys`}s6#Q${$uhP7(eqHni+|w)L?USac^}FJw zRq$wDPVfAys>&f{jOWHx-4FpDEt4_C;~T2t-ZV^#&hqgoskMJYeQ)Z%A58^grSC^? zOZjHq|ygqsso#DMxDwL0|&kp@X0su7J z>40Q)XmsvR+<)s7ykOD2Ae5JGsJl>Tx2;KQ>u_mmvo>xoVIB0p%lm$~v;a;4d{(9Q zc@YBuG1Q4rPnGPVhH=qFT{el=ObOJ((lgGzsog4sgS$XvjDByK? z(yh=1fH3@8q!T)vCVrM$0f-Y(q$9?Y@t@L$Y{(Ea?yor~JmQXuc&-8;OLg#D1V=pv z9kxr~UBzwLam`b$`wffCWMq@VxxITb@Z^ zmAVvW0T4J668L8T)4BzI?8OT-yQMZEgwq2UZm;(d+h0nyitgQQs?UqTKOsh*@X2iU zO+UXwlklNjZ;-rA=$yhZe z1JdO{xM7gSp{37m>Afw@V|%BhA?rRVXhwg44(HYtb#8UvS>Z~T-__@K$sTxZ*aJLu z&3PNqp4LZO>%0A`Iv-nymACK4M2Ezo`9wKOK0~y=X<^*bx!V40>7Y7KsdKicec02y z^^QnNqV}~r627Gld@H|KS0Nb3^fl)*6XpF+pHc<~CHhEbk-H8ePJ3A8i_;l!ti3bV z*)Z1mIMQd0^x5NY#@IbSUjMbFG#{;7>h|%|BLw_d3E-S2r}fJ*5 z6LWumQU5E6%dcDQbm#w5s`~{10Stl8iPa}nnO>Cq$B`+pTPgZiY2H?9jjTMP+7qwV z+B!~a>$uA+rSQ026K25c9~Sk$3SEK5aMf1T!gs|cRlav#>u5m$XhC~!PT+EGS*q|6 z2GF?AYD}o!H?2J}*8GoUB*!|xDXWavKi0U9jwnNHYF}eB{rS=ZOn;(i`l04{pmCsG zH07Y_?LcFvvCfLI?qM3irJiR-^Wow?+Uw(gELK@x*(7&>)R@v%+FrlT?vVh~NN3vU zX;p4|sCye~-43;0ho7kwP}la?8X0Kc_ch0T?a990PYLVZ>B&&pyFynz?d6{KaPI&C z0MIV!e<0c}g(!63^=IoM7XG~^A{V^)ZL~;9?c1j4swU|5+-N?dJZn+?w;cy`N=%O`<9Jd!Y?j;> zPZ7@%MLAgqyT_}1YXHDA0s=^FyT87=Ti{|S|DOZ^d@F|Q3-NfNzKLxg7a;J{c>a9- zehi!DctZa_p=X%TBAw7YO=v+;@W`!&QH-Bl-WK`)E~fOKVn1l>i@?l9ZAg*RI&j(` z>h|@^)3m{wEbrY$j1J)?P>9pcZ^r9 zb-9$R4Qc{x5pW0~c~#gB487L(q}Jo4K%(0+>%Lt?NvM7DjR6OTXS}`^hTuCHyA?Ga z4`?Y!_aoJClYoFXCJZ1D;RZs4sSpNgtd^|ES8Z~OJ+I9@qm$UU?$?6J7X-X8o&tkQ zC*q|uUN9Yi#=pb>-wx@G$?>#5KBP@oukGSv)dC3?rJ*w86dlZn3Fq!x0aCI0( z_w6E1hvdD0g%fjK8C(}JS_2M#TKBRHp)2A;jsG%veapxSd40gZe#IaexS z8<_vLGK!j77cM*g{L}<^a%D2L4~xShaNqe`fs^^5Lre=GF9?y0T4 z*yg;urosypHlwAv4gdZLWpWQ1e|Ij_Gd6z{F(O(i?U~L;qy9%ja7)-%^jE#a{W;XN zUj_ovL#^o%21)lZ{zVz==?mkLj?0rrutzcg3-BE zum_ERH5A{7oi{WjxH`{XY{k=_-juMWs8UU-SEtc`44rELjj(l zK7aV=c>f1S?XS7*omh1&$YkkhE%XriYkhRjwff%ubVn%MdH>|33URhDW_pOG&{*@wiD}8$w1oDWLQySEXj_Y`Ed<*BL#6&X6-I`H z;z7w4_5u+N1ZG!P{LbD#20#m9DP9!?TlBM={m4j>f9}Hr&+$tE z0Xl#kCxxDbLVk2S&X*O4uwq#U85#j{hh2K~;M$-*D9`}t^P329HqSxv!m4TrVmE64 zP*py36+>coYgLS~se7YwQB(KXdUDZ!&Fc#!5I&%luAA8mb69CIC=g>W@ylTVWZ;}) z_V&DXjgb)ocXhiph6g~fe!>CJ{>1f9iTB!#F zCo+yQuom=T?6pZ02nL6D7r5*0)z(8G#nfddtwYO zR6OBoUMhy0Jj5_Itp9-+pH^%+b1)i5`jA-=aQpGZWw9$4WBh4d> zjz9kkxtAjX7Pud37?8C{|Ag)Cx!e^l;Arv)LAd}y_wtx=UsXvsk7qIH`!5C&7 z6&V$m2G#-THt6RkHE?CZmKrx#L)Bs5Ar3FY(~&WuNf{!(mcDPDopVp)-TGkB_%IA+ z$Y36HHoCddwh0GvKFBb+B>Hj18gz6|oiidF)L8U%-ti$#v$s{I!z`jajp?k; zbC)?L=CA8cAGuih{l6?VKW(2q9;5QYP3h~|r(e0~3VjZzydnT#&(vqoI1Cq})4;3O zIvoG7gnf)5>i%gNY`1}49pH6$Y6;-=Z(r9N{w#%k-e2+l;S(y)e<=Gh&|D96_74Ou z22V)c|L2tLcKK@EQ}>Rfr&0re5Z1BvJH2Nu$G3Vy!Tq(XB31u0scQAbN`vXXDyn}S zIPEcFxGfoH14z5M>f4!5X7!8yk$j&*IS$U$M7 zX67*YLLE2;0pE+dT?>KS;>MFJhTkN`@xv94XbI`H_D>NJ9S*HGRDA;47F$#VaCvoQ zJ~U-4DR1l&$h=P*t@ZlQ|ESu@ebxrI!hO5)ju3BI2zYKl05r13%}r|#j7O=(_&{Cz zr^Lu=@wo53z=w4JYv_FpmKL64-`@-)u;w)z5BAc4h9AYa>Ha75{e(8-#2>=~Xq+i} zgaFJr`A62vqAVS(v~neHn|QB{E_1V2?g=`X*!*$vGP!4MY>VXbe&X4lAL76oGspb3 z@LiTxYsq&S6auLXtAMrcMF| zUk9M8BmP&u2N39_7U~Gt{1?3 zlI=k_08Ic{0)%t4?_4(kAn=R;8NwOF_jiZ^$6JSG`EEV8$Mv`Z#WvK0z7W738SkDj zg4U;tG3^qAj=liBfev+t8c0Qadkp@&3Wz!+Apqlg1$*W7$pC|oHvh5`Tv0{{cEXEYy98O6w77H?nU?W&p75FjH+ z&*zlFEpn|^UNA$X6Mnq_go^}ezqtyi=ABBS4Ftb0N;nUX{S{H&lZk|9ujgv(emWnh zx+GBYonOZZ+Pcm)^74H)5LQ4(q^#$~u(l^h-lM7h*20JXqv+i+tZ-o$SP{)Cs zP0U`lgtolHe^vTjU+0axKmK*G8a`=kM~$TMY3#?t0&k}O(N}0~kM|7#ct_&`>Vu{U20?$X>U^s`RmNQ!9;mch_RG%rd>f zH7VArnE%c(`uwvdb)X69PgGSar|xNRJDONZ_gby5gN6=*0D<=Nlg9GA7{xDD{0n7& zhx8cI4bTthdR;x3D_4la!t3UwPMvT|cU{2kUG`p9_z(2mc7JL3spBt5DfsuE5 zolvD4j1WsCt!Q=Pf2j2}Xs!jYM`aUCol$CHH%gIVahX{F2g1E4M!fW~KR2OCERY+xcG4)*{X5ssN>Ky#NIb{hc}lj%i*I@8;(PZitsU zhK?upycko!&QUQQqz4ibcx8;tivkif2JRc6Yq*KgzZ0LvxRcL*ZfO29W4z?axPAb% zHYsh|7*2Pa4@IuSZbI*$m@F2+83Fs(;mRTGj&a0b|52X*6krY77vlxpEf9k6&2{); zC;nBxrxKniaKami8u8kHS{|e0!3e`P$>E>0KZKhWi*24Ux+VZ%B5V$+bi}6Dj`7FK zo(l-k#&EYjjIItvHwQW)UcWxabrVRn6iT0bc=Qgs-lV{T`zGihnbZL>DZ}TQ3Lg&} zFq0SA0HhD1tN2-sx%&(d0uiuypae1602y5~Iv>hh5>}Csu|V->xnIT&YG0t#^#TY9 z0KCwz=sLm6Ngk_Va-y(@p)F-9Kk%(HTh zj|M34x7}m(-y5Ltx|&0?1?UD~97wlBH-Pqr5CwV>G#OfhO9{tZ8}^Ot9W)=L6Y73l z5p%l0x62scT+EWI2?FFbj?N6249%}Oc2~mV1K!b{tXixzQ5Zgb)-t_snf9vF6EXhm zZ^C?}6AC;{T^t~wHQCS}Xe^dy$7zATDuCWPvBbyi?UJIWJ=317G(H*wk;&B7LEO^4 zwlqFX?boKp!zIdfKW<}t-uz>#o8GL9+?>|*{G&^VN9)~{ znuC@6-%g?M2@SkB41xgRya4xt_UMAfcR`=C0%kw}X@$maCEma8cjXnu4y@2wu%JD? zFdx?8m#gPs(;7iZ%WD}nGss6(}!2MgRBX9E7-VSUn+lSdX)WR zfyJ@b{}_$L8wy-eDYCEiM90X%?qOdv2W}a?O{w=s+Vf*FEXJj)@QW}5Ov|yQ*|5q>sQeXa&Sp2L=8(fFZT{d9E5O8ze6?7;b(>U)#c^6 z;ExV3_mI~DaBER{m{W&EH}LNWZf1hW^&Zy`*TFzzAbT0)36s08!JoRTD7&TxsHqJ= zHA4W24+d>8Hw}?jN9_Xx9KOn!PzKrYKm=Z8e7+gAd6!Cj0KFy6I1IzYuX(T*R2Lf{(jrA0K9bVNg2LL^aHwQ zmt5X&v9bdIOQZz;I6#20ygEz(!b5FJ3p9DgZ3EH>3!n`^9pezi$;#z|Uktz#2R`U$-lOj4;x`;?`Ot{vFK1EAmzMxK!g{ z?ZI2(-6PuEH3t7<0SlW3M7%!WLI5 zmf)(S4YKc!D`wH*K2m>m@Hh28&SJVfAwB)RCBxIYEnqB@w9MudwG^vd{U7=inuEt0WsX|CG`rsjb52HpHR_eOigIsE0+UeWmU?~Die z@ud6_`@JDTFs-4H&aTm4L-h+BQ44;EXZY$8pAGa31D$nlP^5czS3$xEI@1T*s{@_e z1MRng?zewa6^j{YP6wKofv)FvvDzO4J;UIRiZ@$`_Ls^InAY4(Usa+*^4e#0w$JK) za~gw%ZMT<7`Zj+Xko>&fCgBEhbQ-6Yjok9RQc1ISrE{j|5n`tx&_zTmuF4u z-f8Im&n4xrSH|CIlN#UYJxVC)Mn9Sh+C2~Cgbcn>A(64}VSGi5_d%7ihk>WdquWKp zreB+Ce18n^(lv)e zp9W`CAt(dI$5g!@1COtjkiVzrb7QIL5&&8QusSwCeDYN zUz?(#4ce3ur!6tU#VKe-EeO(#*u1V6etK={7U@EoEH@3=C16Jz)y0Z5R&5P@ThHHq zU(tomp3tG(zB=#GfzsYIOo5)QIlEXThtV65g7`ntHK1Y^azl{leC(C+z&K#1V>HnP zoE)QpH;Y;u&sPh0*=7%+!Y?at&Z%d_o&~rp4*X-h)KfxZPlX8><0u00f=@h z58U}t?!AyRn@~uGAT$EB)dXu$>ot>QO|9*Kwg_0DQV-9F=0IgU_wUE zX@X0`v|JWY#q$$_*f7rtD}X2xjl`~b?He$l|6L+b=IVij17J?B&kJVY?f?K?+hLCL z19o^H{-HFXciD7-WwpG_3JDF*nnh^Sd&9& zN8>^50E0{RwhlI@2M!Vj7=+%3<%(gmbq~{;%V}x`Y?E1}^~<3EJjKdXd&06AD11GKectMyC+v?8Ag10b8y*E;Wy!T|g!bt{gk z8WvqWLs#S6CA5$2egjzmnm9L?&_?N9qn9=beXFTFWzhhNSS^&!k;!pAAUXUxz&dAF z91Fo8#?A};(|Nx(QC9~~Plqo(h$<&I*_Jx zUvAQ)7tK(JL)t6S0$QqT5syTG1`9y(9k(DB`fj~0aeEDHYjrmEnZ;N*%s^a@&yk^_ zeQ4uf1r&(kTM&e(N8VIRo6J?bG%hZEJWARRdBaonyN(Qv8yIPUx6iKkxH_W7&Y1$O zNj5JbFWK^HOG{Q>}p&wjeTcS&7sUYC`HVilrwp%-mbi=}o;Y;?~$ zOaT#ouK>vd>4CqAr-~jxW8LFw@h1eZ zrm>8HfQ+w&oY2;HmnUqXbW9BEKKZ&qK#<0YMn|r6cx$u`WIS9NmP4O0aer61AOBfdff`kP0`Od&V6Y!@30Ith`SC4UiLB@arMTA4vWO<-b zSQ5aZJ>a5Nnk$zShW$Ayz(5C|nGL|8fZCGN0~$1LE;szofCLQwcLKb$KB(fjpNCt%Z9QQ=0M4)0NF1e{PFzV!fG76agN=d&f~ zZEDZb;=Cy%(hzu^`hBqr&QL(a`pOCcGzP^Iz!oXz z8xxAfVCZb^YdunSc%X52iC3-r;dw>f4>cCUqvB0oQL$x=$?&YAs0Vtc{)MUfraABF z`FdI#ecfYUYoq_chj@sjgu(b~Z}hb%`?^kl{}``Zq8re2j6PCo`0+=RKKPX?SYrkJ zA5zy|`*ex_QAq&VIA(PEQ5L3gLwpiOVZw0=lt9W z)$3qRPUNi44BGCx-0_|9!e5eb3Z6a6eyz7L42<^lP@g^6wm=eXpq=0U)(XLlpPjTl zoiD@RRrtikcQ&lzJNwD?NwRCn5wO=S7Oc%k?jY%=o{SPlpxCij1{~c)k_HRx& z0T8#oer{#0T$#V$oe+S=rjH(AlcWJ^oZV(x&(i&E!tsDmLR~McUi7 z{u$KRLkA#)(Y>xjDxFKpYxjk80MNzHB`oy;EgiBg-9TskGVa}{RN72Wo1&)$*V90B z;dYI`{Pe~P_ODwV(6 zm_ISfZ*C5=GE}Q3-ud{CEzf33f1g4Fq4`>Vb^Q;qSnAN*@bS7YUj79!R>Ob* z001%Ze!PFYR?-K_7$E+QKu%*ep?R3leNP;b{s839cZ)S3wof%aAM6+rEi43Uc>K>9FVUtn?T@hUw%n@#*My#NLiaSGXP(g5O=$5?Xuc`<|EB^5zEy0F>jJze1Waqk1-r=n(fBrH$efdZPCRybRIQUL6oBT*Sv)X{ zu!CC^%jjyK&&~O?OZMeNF?`etX^|~;RvZQWe@E-3b8E7oCQ4x46G-gKsJL}7=Pm3g z*;orz1E5bVUUM?IH8EtZrGbFOXrX1*2{KG9&fmKboWl;Ayih&|4C zosDi;yfW!wFa$3wmbN#D0|)~k@HMz90AsBZrH%R}R2yp^Tov%Bih)mS9^70=0BctJ zcJ71ee79qD)NDoZ&DR;b0BtWPa$fT||9QP8A`;a6&*^z* zzg1ZWvmZ#;LYM)~>%!Y(@HL0?7wfA))PnwJK>%xBb2+E6pVL`5r*mfR*t9;@`7nD{ zl`)>xXVVmET4ONQx*JVZnx8Wv5L%)E(0Mg_V~Hm5xGAzTcu%E9j(P1`R6gQ97hL*i zWlr?TcDp_~_qP`td|Gvho|G!}%(CG0y zeP;jt@%S&Pa6@0u($hKF`)M5d^NL+E>yGz-WNGdYpLX^K0BGR482NqcYYzknO>}lB zB5ic{wPxX75Kn&nLJ@evEgi|0a@vUpV;qS$k_JT_99mQhg4m{60C}!dh6CwSH=z00io3U{MexG{ zB@Rt&Rv8H{JFNR}XtG>pSobpZ`TE|)e(>OrEM@{N1F=6>2@^8yXc4>G7asptqm4MH zP(7Llrw8eoT0(g(y`Qv5QV6L(-Xz4JL#&~DozkLRrh{+UmZ3aPjd)07;6_9j#q)Vd zsCEQS&Cug#M9lc}Xcx9A>TwzI_AkYgd}SF~8+PLSQ1XcXreplI*{lax9uPqMpZs{; zvqf;kzM;$i9K(qR{mppJ8Vlm%)VsHb_mgom&H#W*0ZKr%zY8$9y5TM{ zY#)#D`#{mk#DkY>?w0F%Q#w59250Jb!yK%eCf0jh4tibNbpY;)hq+!ne~k7$`P`l3 z@y{o{v6ru!hl%q83T~=Q2S4XM5d*FtCg2$X19<<05?++=cMJg7FQDnY4v09b;H!w573 z77!W2k|7d(SFTOy2=OHu2I0sIM@yGCQUZF&)_>ooM&Vx88-_H6Z)SzoL=8H{e9TK(wA1c4!nNTaD z^cQe&el~_)W769z>?lI5+Y*xfVgLXsWp~H(gALHwPz;FlFAMWDE+f1}opr;_i?Z+Q zdHXuUdRLd;%4uL4kM6alz3P&UrT07h3!^*EeSNrM#xMkg5J)q#5Djg?eeqB)Os0X( ztnuchV4vQ%YTD1PQ=a~;*2Rp@gqbH*&HGtB%M7V+`W;P(rU?UR-e#X%U}0YOIxmAY z--x%4w=V!OFGDpaU@^CGniHLzPy^wBH&+e+`CleXpnICvyv=J5%*%0_*B+eLIL{#f z)aT9Z6Clz|2teo0tgb%;a6#~QV1+kEy7!UZH`F=qv_I`(8ZD8=H(Xi<7$e(1w6p-! zRiGXN;>giV#rCNgFx1%7l&25dqjBqfE-cI%Z+`uVFaKB}gQ3>+@JGesnB7^ognk3r zFNzBF(G|#9=P&V0a_RRse}b|-5#vI=F7DJG^V{nv$l@Oe6K2YzjGrY z0McCcPOj_T^$(N|?DL@%pU@)iKfFH36@`T8X&6NJEGqb6#9a*N7s;D{Tv6|BJv?PH z+yAOf(EeH}Y#k5Vx#|U=jBUyQG=)Z+PpUY4Lko(U`jr1fAx@c59~e)|0YwOa9B_n5 zI&59v9M4z>>XeW#^#dHwKcG_Y@Wfs1kbK_L!#ohfn_F~8KzHSn7em!Sa`m0gM_A*V zRq(@QJ@wfxVSIeV6W^(8xpufFtFvRhr!B+Ueqn(QKm>;XT@vvs95*CBcyH16)GvVQ zUe2NNl1fiDH_(Qv2 z9Zw%`T$^!Hi`{8${H*(T30xWH$sOYT69?ZYodIu3iC~PG4E)4-5z=AoU}B)1g`Ax~ zzhSfkPp#`Od2? z4tW@q--me^m4|Ki;aRC@*pK1Yrk^+}KWi;boShfX^^d$XRufm2HsGNd0%S%Y9yB8W z2+$n5Q{orHFlg<#cK|7a`!AN(0?onM0bak)9NZot01(3$i99k!!y;p9drGrho#%GlUyt1l+k0O~Fn1 z9*xGe1+-mZ5ra=?=S5+9@a#z+Bus!tK>N?E9HFP%!YTkD)(J!R z0JJKIelTr{2>m=f8^ue)mZ`8>Qu z42nQNUtnM$V>>u80yCYrL#;bk5!AY(sE~CB`y>jLu@(@KTg#jJR^L zj5l==oPxJ^QSy}EWsD5~jxKhEu8@q6>+)-lyW*nGW7k=b12!a+W7BxxeBG{CnEvw$ zp!IJpk*C2OdJA+0S_?ysqf7g0&IhuysQ&x+C7hshw6C>Bi)zoWe(oJvM&Dtb?*+uk zX7qj@W(S5x_usuHx)Xq(&YbQxlmh;8(osMOpi$JQ+DJWZ(w+`)QUOt?_Fqvkq~7YH z|J!$m!q-N3H@&Y{I!sf8LjCLZW~F*<$=I}X@Q^YHvbM+1X4615*Qq$1D`n}%+>Td< zuc1SVe%=)Hpa=~IkiC?Ra;T8H^w;uwDJAL@v2zkT)MUE>j}G&O2DXV8FXPnFB)Jly zCW5k`uGsa_q63|$dvK-nG#8@)o-UB%_MRJ6`UEw=yBgds0!IyKhYkL=Vmt^5w9g51 z@UUVyTJ4AmuPiU3p)qh(!)KHsb8BD#%f01!xRB7dYHUbVavNj}{BKGNF{K4G^~`u5 zvx$Ko6e<<3?}m7cqcSv(L*G<}+V%f2_@9fns%LOG;IQ(REpppC3;;23ZEj-cldJOo zpNdC)PCRJ}2|XfA!v5tgPy8$3;Yaa031Mh~yFwra<{vRCc$S|@{8#r#&bPsv)}AZ3 zZC9Zg4sTbD`)5(ZKIpYEm*MsCHw+S~fY9ofmWPXuVL~W+LhE2cfMY_yZQ|>BHNs?^ z6(DeaSdHH%^Fd&6;+lY+O#)`tNoe4a0RqnrL!yJg83O15rox~w4u=O^5q9}$z?a6s z*%mM|nrn*#pA|-c@1Gj5BrxpI2w%yX*e5Ijp8I< zq+2rfXb@hOuY?|8V91)#SeQvbH$WKW@)&X$Ho)DTG2rjcoIRz$mPLcx)Lt}T0Mwyb z_;s%Lm#jsuvnB)Kr2!6m7E|T0)|wZ48L4pj=P&CXLLq882dQE+m`BVRF`!!jZ(gxp%D!4ru4fxwo|v)Dyn&31d%tVW`}z!u z30Z*s>C$VF&4BL8LPP}KT94i1@>y?+SZ&|({{7PVGhDyI07L!%P~dbZJ1`W$9qGBo z?RfORNGsb9r6`f+Xj*G;d_alnrnRP~5y~x8s@qu4LeG15#?#!+X@2Ge66UBWpz)d0 zwPv;F=CrowNY(p$i4CW zdqg!kn$^6{3Ix&mct&7$1|5UuV7gVJzmY(~@X8os0M%mA`33{ql$ej$druB*Pxmtb z80d@|>HkMxuHrp@X`F{TmxmjMmR~z5?+8BEjphTj{&(ZK-yX4_*2+NhIndvn1p=!B z)qiy~8+ta%^Y=9_{iKcd^s{sR3HOk7w^OkV4k@Aj*StPZ&G-5M0XZ+-M*{%J2Yh}R zG^hRPVY>ev>K=3|FQo^?@W@a~EFK+}bgUxhzo~<_sheqNz^JW{C*OKZ;`-#->V_z< z+mwgr_PZF_cjte!5E|N0u9EezQpz{9v783DWf@9W8^fE}G#-agB*joTAeL*fx_7wl z$pv;~WTu27-9H?3|BN#71^`;nbUW;PxP*J?0w~pM@0*ao-%6}!Met`z^-Eme4ME6^ zkWuXEFm_gh7E||)LDF1Ti=+L|3Kh@*$yLIxN(f>yVnDolEwtsI4N#e?I6i_TGzs)h zaJR7AN<+}p*ftPGY9lpXSjGvyXyB-0)lRXjo_B-A+##% z1fb|SUH15*(gn~rq;+td2z_=(*X(>H=Ll5%oyD|vZYg%4t!uaSzn#s?L2*i;&QN** z^ff>Idny#*8t$ZPccTQ?`W-a#{jKHsyYKrx5rOSmMxcxCfUGUu3k~1=Suc)rqtEPZ zTy$|?XE8bd0|bH^=Yi&l8Udsf4ttf0?hJ!-%Q(UUj5UvR&709VFim>kxe?Co5_SCJ zs?6=Qt})h`Jzh7gfjsnSjmeDeeOBkxtk(Q2v3l+6S?!Too!PUR-&y_7Y_E*<^iNZF zU$$XJ25&}lFuR`qN9X^X?rUDxnA5tRy(siPnFG&C>|ba6?90>A_nL?n$@~9z%JM!o zBEYLErH_h-!|Re~zbuSMXVLAK4X!Y-0vqJlQ!sBJ;6TA8yncKCuLuJ`nC7E3S3QAj zGT^#X#r*X4Onm&dcQ?FqODXHFa<`NscM5c_L(oNg9$p#% zTAo@|v`Kk+&Nb%1M}P(rCl;e4Sz z-@mbIl)+af9HBv`MW=K9QTbn1UcVK)hlC+{L=e=5LGXkGbl>iipoyZ(m@^QB_Ney_ zC39gi2A=zA$NN7pY`{W70`vKs4B>=6 zf8u|_3}_>{8zQX0brB3+pV$2ba9l9yZ_y3h8@A*FG5%Wj4g(yy_+Z_D6^jps1#|$p z2-6<|0&b3x-XcuEvjPU*5GH`|2~_@T0tj9g762fyM}Z#yFKMF)EV)1K^PaE`8dp~; zd{J10gJY<_mbEg-i@7F4Kx6It0e_7Lk7us~)=jsd`(fhH-jE@%Uj7#r0&M{r2ErF; z7S@C?$Ue|P=X69;8}G^g0_Mr&&_1#b;I^=Rh(DjVSf!`6mzHS`UE2HL82ax71mJm- zRWP5wlNqvYg%P|qcB^oJ`$)hb-CLm~iU$FpUC3&$WCw6Y$#6Ebo|+n0`gxeul%qlm zYyhbf^dY$=E#pm(ZXLNtl zpRCGx)4F%J&DDCEfzCg;ni9<&Q?dS8JuH^p<4%?0b#DL8CFUdbl5u5hoH{8dlim!3O3-MyY%|P>K*Zqt6)u1ovGLcvyIIfS z13bI!aC3T}9Dsq&!M@I)zRr=pKwD40cL66HQ&=SIJ-|{+5MMZ+Rxo)LOv7*(ztcsfd)Ves)N_RJVx&7`Va~R zP@}rDQ=!$a4xi4+1s1HRe@Y=;THH49xHSk<^0FF2`EHks(q1>v(1*DeH-?$qTP?7L z2G8}eQPv7jG=%h~pz6L7p_~3^*{z8WZW+%5@z-p52y`fOS2P{cQ}4^?eWbz(?)G(W zu?+4|_`Rejl5Z=3&}H+ z=NzN2(B!+mxE567F^Tz;f_HTpeRtCPVA104%(i0=U5vpFAMU05R>~)*#;9SiOaihkWvaeIm50JboED%Ca6yl`+y)l&kjd^KvIzs{)ed_`*)+?;cec<&U z8QLGiueqN1YK%X?U}=5^xJ>66eh@|g0HF2ZR6%VlcSpQ_@xj^w8x;`n7yz=?4=bQG z=W@dPgb_F}U;v>d+5~}17iU5j@PC;Xgm@2&0e@5(ZD(*m<)eAgI&jv+^J3s%86*DO zumf8L>|GbI_tSvAALn<7{3w?6lCTB{1;4oXpbkT0VVwr+=Ja^=yhuGv`l&+$gmX3s zE1=)IgC*~Sf%s&=1)u~C1I*Ev0t^JWoZ5J5m;tW&?|_Ky5)L>k)V;3f%oqKg!ai;> zyzgRF_ygpU>UTs8@bwh}bUgt=287kniaf2>mqSgLU&`m5!<3UxF=u&(4ljYqDKgnX^D-NsG;|{!l2eKWzE~&WD4Dp zb3*s+x+hxeZS+BZi%<|f5wY3FmUm`DFet$o;a4-W2+8yuR`K6ijBNjagamdi1Ko!n z)>^U9PiLydea}k<(_5=P30()xY;IUoabM>OC1eL$Yi>UDrqImo(i#l3mnb~r7&OI& zwB`ny^C2pEjm7kF)rVk=Kv17I{9^=(dZwX_{7CD;t!xGOXmCTp9ES(JF|(>l^19lfoSzvP+Ub|3+_9c>d}$a2t%q6N&#dNZ_P?td;jBJuM(5Uy z&XSoQMClLHpfh4-&-z^cA4XzYYiwF;a#|qFC6&qL*LgSIpeps@%{#L~^GZsjyW?t& z^>oiY?e*S9dHue|Z@_cQ@o>pt&HZpTp&IQ!8U*!qk3HQlC3&5Tk4Rn)ZWney>(2H2 zWvBYu<9*#1Spgg1s(@ne-~c@g|2_#d?VWJ-ZK3;@$9X?10D$@5 z-cG*&0JH>jh9;n|hj88~DFei|KVK;<2>RNZjLx&8c-P-(-Am5A3*BgOG!7~{&Egsz zx>Nd4H}m0VJ-lmT-xFi~;)w5bm^Qvrao;H&Vl)GBk&su!ph4s5cNPE=3%)#bpf;sj z10(LyVj-`drW-USq9UQ$iBFZ#kp2X8`s$n+6oj$X0Z-dca(wCR*Z6D!2tpK;{O#!T zJH$%%FWL^#4q*^?Q986Xj*BX2qjq1uXpI2zJ7Rri0YKdA=vwn7LZoCU6e8(*r0uyL zfS$)~Ni|XJ7gu(IYYpgs+8Pf!DN=G7K@p8bTt@i7@_t-A=>9UwE~K(^c{?bueYn5r z|6@#UjX@x8|C=)GegO(JF3w{Y*mCR|W&{or19Mxah47{cYY(jOLoH}%jo;SB|8HVV86lz?w0@? zfs$PFWii=X%EQFlb!cK3&mY4t!!n_^ zuJz-33V+G`k+S&L0y|5dU*N#{4nh>y=X(E>IV3glyP01M?qgzog*5Lyk5dkUthY=v_;IRA*Ah<01 z8UV0QfZT-v0M~^DAT4m4^03|378QkS(MR=-vo6;CJ9+!B(KG(fS$VeiEQ2W#6yLGm>=fKW&Pp}lUt)AK` zAxzSJWeD9{;F>rRGJJ0Mb7F~#sRz)yy;w#Zkk<8~<>g#;F%Af~ei!w)Kw?jG*WELJ zBdv_MFM=`*15APD#zlkhPWLL09$^?o*xbKB`_-k|;fX8-W-3=1|X?&;Ich zSB7Ok5ZD(Op)in(0yvi7GwW3uUN_y*^Gsv($qsm7dH2&xQ=LzrNef-q%ohk4{i_P~Od~kd+MChZ zo%vFU`Y1#+qxqiE98F(e_55dazRl|YX8x3T|MJu^cu_(TIzy(lj;3W8$2#lAGO{Dm zD-TN?Ut>!pMye|IudDIGNRwCZ)OI|2fnw6}2AWSd>e2cd>YBsJe0^OqIZmv&ztie> zNEk@}+qrh}L7f?5d#yjx_*}f{xdqZt{Cj?2>EE$fCH1xDT~7k)f2}yB6!^Kb*n4ca zHEXhsU7fwwu4!(a%KvcN!L_QY-joS=b+Pj9$zMm1b7x|3@)${rb7LHgg|6i|F|q#V$5VJ= zjL82+8BTn7GU{NAg(itspRG?6-EW2h&-#W^lcxvc2El`&Nennl^<3JkV zfyD?o)F2>0*YGuQt*tqw0*V9(+?&6l$^w87B;xD2cgS5mqh@7MQEebk}5{K|j;G!lO=kmUSo z=2`1)*;z%mT1$ZOlYwvy8UdP6I>I|s`G>~%9~b~|SeS{gga!CY*Z}~5*5m}N!BGhr zAPyV^M9c;ljPiTH!O39*2o2~karon=ywC>_dq+2caFUD)ZM4Zl!U7x+5O8?F6&i|@ z^7?r|0AK*I;1yvBe)$k^K*)gl4ulPEthsT>;p6ffHu+$b$GgRBeenu5v+)zKdt87^$1SP@424#qf1p&@aV+>1UrNg zz~H|#pRr>BN^1@P5_cA(WQItGKlL!27WlKU0s6ap32ak_o&EwYg7x0e{Tq~5Zy>y3 zfd+S+{A#Wb3$S-WWX}sz_QPTh9D4e2*ryv3b|kY#<3Gjv+b{Z)??v!Os-N~5eFn@x z>KbTo03wJH0jlmZp!=twnQMTM1+Ys}h}SA0Kz{+Z45miFNBluV&a5s(j|LWAzA0#ZGH9tK}OkV#tKBWo{xkBGLDSJ#9L2H8g z`_qI5^bFI80@n#3*gD2vdu{sVRo{O`=f{kI*);6I)w$o_225zLP3wQ@`ZqqVLKI{I z(Dz`d&m6*P>=$9)-o?5=#W8%|>JM zKRySACYxe6)B-2eVDAtyjwW_WziViLy9(gfihgg;Mez!dfwI>kLWn_41Jt-4cnvlk z`x-j<8fY2xTunBq3=;MI0YGkp{DsH}-c_23*0IG9v~_>(L9Tmm6PCEQK#6q#yqC11Gwb=5-7Lxm(Yiy}|PTbRt zcw`V(8QGP$QJje&U$~A@sUBHQ90PrGzP&6`LqGR=o#auv{qNFxR zLp2WF{n~iIXT@74mQD=*_hsy?9}u{44me(&#?eKa-dwDW`!~EK&-TXxg>-dvmIE3P zQYCjuYTvcysN@o%$?<3Hmx$ zsaJ2NVXJbIy4#jf=|M?r9C{iLi=TI@&!R>QwF#&VU_-2RF_O1ABxn7U#HHKAD_dZUhM8mH34{}h<1wsz!`VgXy0<+ZHFeZj${Kn zpDSUtLF=sNin9p*>My)I2yySQO3hJj$+=rD3W1YWQfgfMhYxB?<+jqB#~ z(HW3>sQz|(I&fWZYLGC%W?9=BYuEliJAWJ3nx%uH zLmgxp5I!Ibh3-Uaoqh#$pj@VLS*G>8Oh(k%1Q%rOk=l1|K(?;!o&;KJZd~-lazcDf z{XaDf+>lK7?YTP&d^T=a%qc0-{GEO()>&zMyE-FW zYJI(U{@Wx(uzk)TLXx@$#e=%{#S^`(FN%5n;OIveIyK>qVxBqL=JzNYV zaA2lFX(Nz6BTmsbi#;I5+!eTU2RYQ|kF2wkdh-K~gL?z~Jcjx?<@F9WD5FLR+<^?% zQ2TPEvtg|BbF6t8>pUKRwLpVA;b}ZZKTVn8KgS4vvZ@SHdCy+>{S{LmX$_9vT0mp; z{9ISh>6W}7EHGegfPm8UL818p7pVTCB>Wl0zjImL2J89J&GmU7cTD^6zzjF4Q9s=xTqO!vS>w{t*^o^VDeg zY(N0Iffbd~hj&iLUH6>1h(lq_$)tFd!&q~B%JYtov(3j?xV zrSzHh$LNFFK>hkW7ZZa1L2vPwVjo)14S2Y=^a)evm1pew|I|m&XVdWvRlKQBJbp4H z{--=8Y6I9y5{O&6qUct)4PLJfW&;310c*4Xzsc+G@eZ%5!_rw6-!E|!HJ+G+q+|DifcGr@t&7KA_pEN;)fmej_fFU?3%)pPs2wW0S@b`d$Cx;EtnsbWf+XDnJ)MQ+c zHSoC@e62;NVjdC?{Qzs7e`2iXHfowmzsy5C*~!2~1ib zx^d05(*(74ohg8dANu@VG4%W7t3JmqjrS~8$m`>M0g?a^gr%gIo*gi9Tma>tGFPwz zh!F`-5q2QNfas99U7qU!4A3gv9q>=qiLSj=XU$SwZ|Nu?KwRHp(Xh8C1v=jEb6k{m*@OhH$e2+ z0n~&n$UqRNapy`I>M0%C4Lwhjv+uuB`$TJ~bxeNNd^Fc&K3$Y-fuEOwrlv|q4o&CB z<<+@o`}PUHl2WMWY2O#`T;tf2H%$9r3%B1^)Nqds0|8w3VbQ+q=nQNNj8hi9wQ-4w z-LOrc+qtmlV9qVln!9+L#E#!r=ej*c=xD7ar-!43(zsBj*k118q4wXK3VHigsvK=- z$&DvHZJ_l&)Ofm6;q@`JfCY`I>)vb6j08GHTc*&CzK&L=8sAhZ@o8UEes}ns)H*;* zz;(43N9UBFaC~vX2(S#Ai}A;z@&{qt+#P~l%LJY`alfmr#JPQ%J znz+)A73=21EH==Gwe`OCegy{Fq_gSpZppw z)d5ctk7W-pWNiu#Pf(j{*}saK!)ruQKlO*i?=+x|4^#}_RlQzTs`-`<43z%XH?#`9 znl5`mCQXN7n~;STEPVi6jOUI@-*G!op6e}z$c&0LXs+UQLD6P?=q{9)|4bMFN<|ab zA(c<}*49Bw3E&2X{Ml6xfhIxTfI7&?&803l)Sty5mli$O(&V~@@OKhE(88QrSHPgoMdO;v-KgkYJe*}e zC~Cfe5D^bTi;b>^jQ{er>p+F#wYRE`K%pF$)g@+5oP8!<`T6k%VJd`tseU-61?}`J zUE3;b&Bt;bTX z004fLQJeTez{6DDJDGb1L>v$%;0rPK82*c6>|q8*d7(WZ8{)ixAZjA~IxohRumCj~ z1nTHZF!}6&Ccf8NoYXwJvY_^lse8VDFwb{zjJ^z>Lj}#ef7<|x55(*LdcFb(-j&ak z$1y37--Vt|sCl**4s&vU8GkYmtT)hFaMLEz311VIWlfdBcZYEiaCU2B==@z`)G_`r z6ofE-{SW|fN;9Zoz&Z5B z0PAnmH2}sghO|740t^6*m9FKUBAUCV0E4@Z>P&GlA&kAA$2|nJei~YvjoZpOXnnlc z0m79qjqW+3z2DY3)ZRDeD6HVCiit(M>^LtB;;nV&IOlu6qKS#^I@3UFpso3EBO^qK z>z6~(B>O0`iT18joVDgDcE(v{@!?+r05HOzj*-^<4_{Dq z1Dw+?;L(#KLM1|IZ>#_Ls(WzR;=L<9(6#mTyuDY zhchKu9R49Hex0#HQZ4mdeVto9oiT{-003raz8~O5dLH4AXGJV2;MXTC^7tyKG|*ld z9Gwus&S3$_w0Kv&hu#dHhphqtc8z|G5VStuh3sVSoY^r|01n_`&DrVYj9Y_tUs3$l zq!DV?zG~kd!+%PJg`Ao4DKiLb6&lnpsruK~qM--0`wG81)DYs7pCqoWiKM}fRiw|Y z*aP0N(*?Cy>2}rLKLR*yw5C3=p^ehe0&zYqF<@eHH$>b6ihghI%#7vycF_5W#81IYwlk;yjIsQ3t$1!3IVw&f)-N`3QW(4(9exN zv;mrrFY2zPXJ~)529=nbtNdw!Sb(Fy^|p@a=8jZnLX}H+fkF$KR970*n7QZ%Sq0QV zm!JIZ4~i(qC#3&zcnG=?-laZDa2fV3zbwxlC1 zduC#sTh_tm5W$^AT@p8Sds(R1P0JH>8rpR^p#Kx97Frn9v<`pL^<1b(W8Zv&Ubhy* zLnsH91rWla3>9nxpt*8t;LV}JTk*i5yYU>KUdEg*hX|>bzp=!9=mFg3_3e2U4qt?y z7=Aog&76M>@>%Twh!5s}00M*$zFk1arG$SMz;Ipx05bvTEjEi$etHb}b{RK$ z9TpCv8_@Hcx<}Z!PhJ>xt9JSx}PGhjg;w&{O9XM=oY4iI_j-UtDC zEV&dg+o3}`;B5y0Tqy#a#<^dvuv!6%CZO#)hk*?<-8Piq;_ zDEuVAjg-Xa#Y1OZ>>VQwGoUqY@g6z+TJtVBObrmgpvJ{biD10YlxUAo2+CC;$%uJH z8D@L`q%tBrB)sv=Fc@eK&;z_U|HJvCeZ5Qv_Hylgx183xaoQn*K~fK46v$T4*+W4q z${o8|63i4St``Jk|G5AJDTCGk5aaJ8&Mzb5PM}(g4Lxszblz7K3t+LJKBskOGy;SM zwSU{MPFQs+%qkiJ-J_e2ofOI$1^1!l)w!K8ngIlZc!B~KR{oz*A&3@E&Xon=n_9cA zD=JLsGwz^bEv=K%Jv&|STV;goHSS-G0@N~vYx<;Ub@q4pc)ib+QtX^uz#o!@O%EX4T4N+X1MpvM33*+s<EEZ+&!mZy!iQ7nZjL)t28B~6WgBSf1HW7(Q5{2{G=A3bJaC49Tr=l?HU1~<$G(xS=gnCU#7+B*#7Hk)A7C0K8ou*6qREfDcQp$7C4zX>XQQ^jczZn!d_p1ZBXgz~-?Luw&Y?GMJG1J!m>uDN~1 zkEjEV@PkYXbQMjF1I3h_ouEmcI;(_pq{_Lu396fgk2zbrq$FN{Gu-~hnz>97P} z2rIy~&=q_>U;uzHm-_)I5RxEm5RHKL#Dvx^bpC_OoCZIr`4HX4lUGNEE2S`7BROXv(gkAs(VC9Galurk=@R>&ixEvfHaCJU= zF+c)#;pJJEFbrf5Xy4O^fU1FJ0`&YY0LE8@!S5{xVd-z<{lf$hve4SFFjPj|RSC8C zEt*7Y@R(YAWX4!$0AQew005fol%x_mlm?6T?*i3MNkor;E&(6}lZMdnaRDPI2XtRw z=bG!998)Y=bDIMEu0`_qGW=6I2VAJ^bHxTY9QehAOWF6jXG*BIwvExgyZ{8}nyU(4 zTAn!_S)unkTj#JRrR&(x_;`!NkMCNvxVZKG`hQZj=|e)Zqn7qs`)#3`wNEWTM&SLZ z3Nruz-0k#+Vj_q!bI!Yg5i0a6V$kMe)O241f%ZN^IL=FSQft*Y={f>BO9vQSt@YuV z$&Y_Yy%5T|z|d*MD7fR`Q<8iC+gxAI?A``4cmpc)J#5ic@`iebp`LFvC=nuQd#3cY z--qZ5_9>=exVk)fDE_gYVf^~A1%MBz_^*Vj-zE0~b+0)bVyFpaXid5U?;g{YkYAPN-^E!W(v3 zT(S#vFw!u`>f1k+*1#a()S~XGR)~21MXHsZ$xf7azj9cmI;9IVZ@0O{6 zEiI5`(4+T+0YK!ndnnzvgytnjTgHN-I+WO5{-~nk8?TG;ml1M#;{OE9+!C#Z{!VFF zr-b2ULP0;d3=;;;O`MYZoT=x)WVV!`8=a$DmA@F1t;?@9!t-=hDd7!oVKxyLBAMygA z{B!ZaDuw6ecQ6JpM*j|A1en1j+*HQiVC1gF|9{J5SPVp`yXAYWGiN*iK&~oqXX6jh z`Aa|sp@&0?`LRJqkcvUp*tp9eqCP!`vjz^0CrgBu$z#rS-|2G0N;`?CRtlTT4PRBX_~3*J8fjQ|4YlrEKmR!~x;Ud6ul`(85(RYnI_Cy&h`5e)zSl*Js4*St@59HH z$L?$WIzT~lGJ0i&0!AlA(aUq7|5pXi)dm7YOZZ9{cDr_9(~Ip>^3# z+Dcnr_pQv;*#T*=Ip-x@EeDaZ(w*J&+9Oo|vl5oyI6&c^{2vVYY5@RyvE(OGtl<3U z0Nz`Z?YhFm3S{)0#zH0lLXq=xgP@atlyPW+fVFuVI>;&b;}|c7|JN~A9Qe8>4PY?% z%U)gvY`G3&%6htB2OGOrhJo}OYH+)}=3?k{Eo^u0`a^(*4%P;-X-#J1{!stgjP1i0 zAMC=V!^tUtx(=lfU5V?++E~qN3w661mlg;y_zpCd{@&AO>%T85+0T^PpBR@H?7NdL zsl&xxmiDcU*w)|3vu)u$>s~44+t9*lzN|z+ZC=D?1YSDt$^D_FxGTtA*P}X^3jn>N zm=52umOCXEXvd| z(bJ-YzPM60O=F@`)*;?P)VO)+ImmOKdQJ(Wmf|52U&cUbLDNZaO-{Vy<+Cx&T1yi; zh$eO~kJ0q(`|D6gXt;DS-q!9#HQTGyx^bTU#qp}AW6TlVQEQ+PuYDW9~bBKvjPeZ5dgwS5kxTfoyE%F_)Y-81u^abuk-Ue;`%?x->%N<(!7W3 z2t-;8d3}J!26fM7e4d*ZnF8n#o)-{8mcz-p#;vt>?4iFbECAX7t!bz6;n8c&BLH2h z>$(@nCZX}Sh(Xpox>f-U#F+&!%u>K+5OP2;*$coRjqwjL-kdXJy67HVjEE3|_S;fj zW2qbjmnMesK$D>J%M}y#J_`#qCe{?Zs@MWr7Eh6i{MS1BXe!pw;ZGG*mnYYCmS0}L zdP?Kh(0I}M9I+sMQ5t$rgA67C+Qy*?7vTM0odch+z;{C1lA4X-*4czc!0CbS36k9=Wp( z5JKym?r&4+euFoc*GyUB-ZA9`cQmKnFO|5^)e7}YgH2+v-(E3%ni;w00HJ2h&p=>h zpl4oFKxd%+Fwi~re_xqtu6eL_Wf!2k>gyaF5L(cl8S2?bI`2m^#=}n(+c20a_F$-U zWT3S$Af~VLex&hoqaNM&2*9DSaH(Fcbr(|FG|%^}DESe_Yp(j*Z+)KgkaCnMyn~&v z*6X?onQ)Hxo*Es*xdq0YIdMhq`{+>pdiFj#vX4h6pfjz{vua*lhBk;M$Vs$F=)SN@&5rL W;*5dph2%Z}0000 Date: Sun, 1 Sep 2024 23:13:58 +0200 Subject: [PATCH 03/21] Introduce TileStore for raster and vector tiles - Improve the TileStore abstraction so that it can support both raster and vector tiles. - Add some TileStore for dealing with raster tiles (geotiff, dem, cache, etc.). --- baremaps-core/pom.xml | 19 +++ .../baremaps/tilestore/TileChannel.java | 17 ++- .../apache/baremaps/tilestore/TileCoord.java | 36 +++++ .../apache/baremaps/tilestore/TileEntry.java | 13 +- .../apache/baremaps/tilestore/TileStore.java | 16 +-- .../tilestore/file/FileTileStore.java | 2 +- .../tilestore/mbtiles/MBTilesStore.java | 8 +- .../tilestore/pmtiles/PMTilesStore.java | 2 +- .../postgres/PostgresQueryGenerator.java | 112 ---------------- .../tilestore/postgres/PostgresTileStore.java | 2 +- .../raster/BicubicInterpolation.java | 58 ++++++++ .../tilestore/raster/GeoTiffReader.java | 126 ++++++++++++++++++ .../raster/RasterHillshadeTileStore.java | 105 +++++++++++++++ .../tilestore/raster/RasterTileCache.java | 91 +++++++++++++ .../tilestore/raster/RasterTileStore.java | 96 +++++++++++++ .../tilestore/raster/TerrariumTileStore.java | 64 +++++++++ .../raster/VectorContourTileStore.java | 110 +++++++++++++++ .../raster/VectorHillshadeTileStore.java | 122 +++++++++++++++++ .../VectorTileCache.java} | 30 +++-- .../apache/baremaps/config/TileSetTest.java | 16 +-- .../tilestore/TileDataSchemaTest.java | 4 +- .../postgres/PostgresQueryGeneratorTest.java | 43 ------ .../raster/VectorHillshadeTileStoreTest.java | 26 ++++ 23 files changed, 907 insertions(+), 211 deletions(-) delete mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileStore.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java create mode 100644 baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java rename baremaps-core/src/main/java/org/apache/baremaps/tilestore/{TileCache.java => vector/VectorTileCache.java} (70%) delete mode 100644 baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java create mode 100644 baremaps-core/src/test/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStoreTest.java diff --git a/baremaps-core/pom.xml b/baremaps-core/pom.xml index 2684e792e..dd432b17b 100644 --- a/baremaps-core/pom.xml +++ b/baremaps-core/pom.xml @@ -82,6 +82,10 @@ limitations under the License. org.apache.baremaps baremaps-data + + org.apache.baremaps + baremaps-dem + org.apache.baremaps baremaps-flatgeobuf @@ -126,6 +130,21 @@ limitations under the License. org.apache.lucene lucene-spatial-extras + + org.apache.sis.storage + sis-geotiff + 1.4 + + + org.apache.sis.storage + sis-sqlstore + 1.4 + + + org.apache.sis.storage + sis-storage + 1.4 + org.graalvm.js js diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java index 93d02efba..096bc160f 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileChannel.java @@ -19,15 +19,14 @@ -import java.nio.ByteBuffer; import java.util.function.Consumer; /** A channel that conveys tiles from a source to a target. */ -public class TileChannel implements Consumer { +public class TileChannel implements Consumer { - public final TileStore source; + public final TileStore source; - public final TileStore target; + public final TileStore target; public final boolean deleteEmptyTiles; @@ -37,7 +36,7 @@ public class TileChannel implements Consumer { * @param source the source * @param target the target */ - public TileChannel(TileStore source, TileStore target) { + public TileChannel(TileStore source, TileStore target) { this(source, target, false); } @@ -48,7 +47,7 @@ public TileChannel(TileStore source, TileStore target) { * @param target the target * @param deleteEmptyTiles deletes empty tiles */ - public TileChannel(TileStore source, TileStore target, boolean deleteEmptyTiles) { + public TileChannel(TileStore source, TileStore target, boolean deleteEmptyTiles) { this.source = source; this.target = target; this.deleteEmptyTiles = deleteEmptyTiles; @@ -58,9 +57,9 @@ public TileChannel(TileStore source, TileStore target, boolean deleteEmptyTiles) @Override public void accept(TileCoord tileCoord) { try { - ByteBuffer blob = source.read(tileCoord); - if (blob != null) { - target.write(tileCoord, blob); + T tile = source.read(tileCoord); + if (tile != null) { + target.write(tileCoord, tile); } else if (deleteEmptyTiles) { target.delete(tileCoord); } diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java index 6e3d2f9e1..192dd891a 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCoord.java @@ -191,6 +191,42 @@ public TileCoord parent() { return new TileCoord(x / 2, y / 2, z - 1); } + /** + * Returns the tile coordinate at the left of the current tile. + * + * @return the left tile + */ + public TileCoord left() { + return new TileCoord(x - 1, y, z); + } + + /** + * Returns the tile coordinate at the right of the current tile. + * + * @return the right tile + */ + public TileCoord right() { + return new TileCoord(x + 1, y, z); + } + + /** + * Returns the tile coordinate at the top of the current tile. + * + * @return the top tile + */ + public TileCoord top() { + return new TileCoord(x, y - 1, z); + } + + /** + * Returns the tile coordinate at the bottom of the current tile. + * + * @return the bottom tile + */ + public TileCoord bottom() { + return new TileCoord(x, y + 1, z); + } + /** * Returns the envelope of the tile coordinate. * diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java index 58333c7a7..192e156fa 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileEntry.java @@ -17,23 +17,22 @@ package org.apache.baremaps.tilestore; -import java.nio.ByteBuffer; -public class TileEntry { +public class TileEntry { private final TileCoord tileCoord; - private final ByteBuffer byteBuffer; + private final T tileValue; - public TileEntry(TileCoord tileCoord, ByteBuffer byteBuffer) { + public TileEntry(TileCoord tileCoord, T tileValue) { this.tileCoord = tileCoord; - this.byteBuffer = byteBuffer; + this.tileValue = tileValue; } public TileCoord getTileCoord() { return tileCoord; } - public ByteBuffer getByteBuffer() { - return byteBuffer; + public T getTileValue() { + return tileValue; } } diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java index e7f34b11a..b580525bc 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileStore.java @@ -19,12 +19,12 @@ -import java.nio.ByteBuffer; +import java.io.IOException; import java.util.ArrayList; import java.util.List; /** Represents a store for tiles. */ -public interface TileStore extends AutoCloseable { +public interface TileStore extends AutoCloseable { /** * Reads the content of a tile. @@ -33,7 +33,7 @@ public interface TileStore extends AutoCloseable { * @return the content of the tile * @throws TileStoreException */ - ByteBuffer read(TileCoord tileCoord) throws TileStoreException; + T read(TileCoord tileCoord) throws TileStoreException; /** * Reads the content of a list of tiles. @@ -42,8 +42,8 @@ public interface TileStore extends AutoCloseable { * @return the content of the tiles * @throws TileStoreException */ - default List read(List tileCoords) throws TileStoreException { - var blobs = new ArrayList(); + default List read(List tileCoords) throws TileStoreException, IOException { + var blobs = new ArrayList(); for (var tileCoord : tileCoords) { blobs.add(read(tileCoord)); } @@ -57,7 +57,7 @@ default List read(List tileCoords) throws TileStoreExcept * @param blob the content of the tile * @throws TileStoreException */ - void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException; + void write(TileCoord tileCoord, T blob) throws TileStoreException; /** * Writes the content of a list of tiles. @@ -65,9 +65,9 @@ default List read(List tileCoords) throws TileStoreExcept * @param entries the tile entries * @throws TileStoreException */ - default void write(List entries) throws TileStoreException { + default void write(List> entries) throws TileStoreException { for (var entry : entries) { - write(entry.getTileCoord(), entry.getByteBuffer()); + write(entry.getTileCoord(), entry.getTileValue()); } } diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java index 5afcdafa0..d4bb68440 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/file/FileTileStore.java @@ -28,7 +28,7 @@ import org.apache.baremaps.tilestore.TileStoreException; /** Represents a {@code TileStore} baked by a directory. */ -public class FileTileStore implements TileStore { +public class FileTileStore implements TileStore { private final Path path; diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java index 755739b6d..15149b76c 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/mbtiles/MBTilesStore.java @@ -39,7 +39,7 @@ * MBTiles file format for storing * tiles. */ -public class MBTilesStore implements TileStore { +public class MBTilesStore implements TileStore { public static final String CREATE_TABLE_METADATA = "CREATE TABLE IF NOT EXISTS metadata (name TEXT, value TEXT, PRIMARY KEY (name))"; @@ -119,13 +119,13 @@ public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreExceptio * {@inheritDoc} */ @Override - public void write(List tileEntries) throws TileStoreException { + public void write(List> tileEntries) throws TileStoreException { try ( Connection connection = dataSource.getConnection(); PreparedStatement statement = connection.prepareStatement(INSERT_TILE)) { - for (TileEntry tileEntry : tileEntries) { + for (TileEntry tileEntry : tileEntries) { TileCoord tileCoord = tileEntry.getTileCoord(); - ByteBuffer byteBuffer = tileEntry.getByteBuffer(); + ByteBuffer byteBuffer = tileEntry.getTileValue(); statement.setInt(1, tileCoord.z()); statement.setInt(2, tileCoord.x()); statement.setInt(3, reverseY(tileCoord.y(), tileCoord.z())); diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java index b17b12ba1..d5a9d924e 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/pmtiles/PMTilesStore.java @@ -29,7 +29,7 @@ import org.apache.baremaps.tilestore.TileStore; import org.apache.baremaps.tilestore.TileStoreException; -public class PMTilesStore implements TileStore { +public class PMTilesStore implements TileStore { private final PMTilesWriter writer; diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java deleted file mode 100644 index 1e640fab4..000000000 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGenerator.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to you under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.baremaps.tilestore.postgres; - - -import java.sql.SQLException; -import java.util.List; -import java.util.stream.Collectors; -import javax.sql.DataSource; -import org.apache.baremaps.database.metadata.DatabaseMetadata; -import org.apache.baremaps.database.metadata.TableMetadata; -import org.apache.baremaps.maplibre.tileset.TilesetQuery; - -/** - * A generator that uses PostgreSQL metadata to generate input queries for a {@code - * PostgresTileStore}. It can be used to accelerate the creation of a tile set. - * - *

- * As in - * JDBC, some - * methods take arguments that are String patterns. These arguments all have names such as * - * fooPattern. Within a pattern String, "%" means match any substring of 0 or more characters, and - * "_" means match any * one character. Only metadata entries matching the search pattern are - * returned. If a search pattern argument is set * to null, that argument's criterion will be - * dropped from the search. - */ -public class PostgresQueryGenerator { - - private final String catalog; - private final String schemaPattern; - private final String tableNamePattern; - private final String columnNamePattern; - private final String[] types; - - private final DataSource dataSource; - - /** - * Constructs a {@code PostgresQueryGenerator}. - * - * @param dataSource the data source - */ - public PostgresQueryGenerator(DataSource dataSource) { - this(dataSource, null, null, null, null); - } - - /** - * Constructs a {@code PostgresQueryGenerator}. - * - * @param dataSource the data source - * @param catalog the catalog - * @param schemaPattern the schema pattern - * @param typeNamePattern the type name pattern - * @param columnNamePattern the column name pattern - * @param types the types - */ - public PostgresQueryGenerator( - DataSource dataSource, - String catalog, - String schemaPattern, - String typeNamePattern, - String columnNamePattern, - String... types) { - this.dataSource = dataSource; - this.catalog = catalog; - this.schemaPattern = schemaPattern; - this.tableNamePattern = typeNamePattern; - this.columnNamePattern = columnNamePattern; - this.types = types; - } - - /** - * Generates the queries. - * - * @return the queries - */ - public List generate() throws SQLException { - return new DatabaseMetadata(dataSource) - .getTableMetaData(catalog, schemaPattern, tableNamePattern, types).stream() - .filter(table -> table.primaryKeys().size() == 1) - .filter(table -> table.getGeometryColumns().size() == 1) - .map(this::getLayer).toList(); - } - - private TilesetQuery getLayer(TableMetadata table) { - String tableName = table.table().tableName(); - String idColumn = table.primaryKeys().get(0).columnName(); - String geometryColumn = table.getGeometryColumns().get(0).columnName(); - String tagsColumns = - table.columns().stream().filter(column -> !idColumn.equals(column.columnName())) - .filter(column -> !geometryColumn.equals(column.columnName())) - .map(column -> String.format("'%1$s', %1$s::text", column.columnName())) - .collect(Collectors.joining(", ", "hstore(array[", "])")); - String sql = String.format("SELECT %s, %s, %s FROM %s", idColumn, tagsColumns, geometryColumn, - tableName); - return new TilesetQuery(0, 20, sql); - } -} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java index ba9f35865..311f86ff4 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/postgres/PostgresTileStore.java @@ -38,7 +38,7 @@ * This {@code TileStore} combines the input queries, identifies common table expressions (CTE), and * generates a single optimized sql that hits the database. */ -public class PostgresTileStore implements TileStore { +public class PostgresTileStore implements TileStore { private static final Logger logger = LoggerFactory.getLogger(PostgresTileStore.class); diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java new file mode 100644 index 000000000..c6bcf0ec5 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/BicubicInterpolation.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.awt.*; +import java.nio.DoubleBuffer; +import org.apache.sis.image.Interpolation; + +class BicubicInterpolation extends Interpolation { + + public Dimension getSupportSize() { + return new Dimension(4, 4); + } + + @Override + public void interpolate(DoubleBuffer source, int numBands, double xfrac, double yfrac, + double[] writeTo, int writeToOffset) { + // Initialize arrays for the intermediate computations + double[] colValues = new double[4]; + double[] rowValues = new double[4]; + + // Iterate over each band + for (int band = 0; band < numBands; band++) { + // Interpolate each row + for (int j = 0; j < 4; j++) { + for (int i = 0; i < 4; i++) { + rowValues[i] = source.get(band + i * numBands + j * numBands * 4); + } + colValues[j] = cubicInterpolate(rowValues, xfrac); + } + + // Interpolate the final value for this band + writeTo[writeToOffset + band] = cubicInterpolate(colValues, yfrac); + } + } + + private double cubicInterpolate(double[] p, double x) { + // Using the cubic interpolation formula + return p[1] + 0.5 * x * (p[2] - p[0] + x + * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] + x * (3.0 * (p[1] - p[2]) + p[3] - p[0]))); + } + +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java new file mode 100644 index 000000000..62b906d98 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/GeoTiffReader.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.nio.file.Path; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStoreException; +import org.apache.sis.coverage.grid.*; +import org.apache.sis.geometry.Envelopes; +import org.apache.sis.geometry.GeneralEnvelope; +import org.apache.sis.image.ImageProcessor; +import org.apache.sis.referencing.CRS; +import org.apache.sis.referencing.CommonCRS; +import org.apache.sis.storage.*; +import org.opengis.referencing.crs.CoordinateReferenceSystem; +import org.opengis.util.FactoryException; + +public class GeoTiffReader implements AutoCloseable { + + private static final CoordinateReferenceSystem WEB_MERCATOR; + + static { + try { + WEB_MERCATOR = CRS.fromWKT(""" + ProjectedCRS["WGS 84 / Pseudo-Mercator", + BaseGeodCRS["WGS 84", + Datum["World Geodetic System 1984", + Ellipsoid["WGS 84", 6378137.0, 298.257223563]], + Unit["degree", 0.017453292519943295]], + Conversion["Popular Visualisation Pseudo-Mercator", + Method["Popular Visualisation Pseudo Mercator"]], + CS[Cartesian, 2], + Axis["Easting (X)", east], + Axis["Northing (Y)", north], + Unit["metre", 1], + Scope["Certain Web mapping and visualisation applications."], + Id["EPSG", 3857]] + """); + } catch (FactoryException e) { + throw new RuntimeException(e); + } + } + + private final DataStore dataStore; + + private final GridCoverage gridCoverage; + + public GeoTiffReader(Path path) { + try { + this.dataStore = DataStores.open(path); + var allImages = ((Aggregate) dataStore).components(); + var firstImage = (GridCoverageResource) allImages.iterator().next(); + firstImage.setLoadingStrategy(RasterLoadingStrategy.AT_GET_TILE_TIME); + gridCoverage = firstImage.read(null); + } catch (DataStoreException e) { + throw new RuntimeException(e); + } + } + + public double[] read(TileCoord tileCoord, int size, int buffer) throws TileStoreException { + try { + // Compute the buffer size and expand the envelope + var fullSize = size + 2 * buffer; + var tileEnvelope = tileCoord.envelope(); + var tileWidth = tileEnvelope.getWidth(); + var tileHeight = tileEnvelope.getHeight(); + var pixelWidth = tileWidth / size; + var pixelHeight = tileHeight / size; + tileEnvelope.expandBy(pixelWidth * buffer, pixelHeight * buffer); + + // Create the target grid geometry in the web mercator projection + var sourceEnvelope = new GeneralEnvelope(CommonCRS.WGS84.normalizedGeographic()); + sourceEnvelope.setRange(0, tileEnvelope.getMinX(), tileEnvelope.getMaxX()); + sourceEnvelope.setRange(1, tileEnvelope.getMinY(), tileEnvelope.getMaxY()); + var targetEnvelope = Envelopes.transform(sourceEnvelope, WEB_MERCATOR); + var targetSize = new GridExtent(fullSize, fullSize); + var targetGridGeometry = + new GridGeometry(targetSize, targetEnvelope, GridOrientation.DISPLAY); + + // Resample and render the image + var gridCoverageProcessor = new GridCoverageProcessor(); + gridCoverageProcessor.setInterpolation(new BicubicInterpolation()); + var gridCoverage = gridCoverageProcessor.resample(this.gridCoverage, targetGridGeometry); + var renderedImage = gridCoverage.render(null); + + // Convert the image to the terrarium color scale + var imageProcessor = new ImageProcessor(); + renderedImage = imageProcessor.prefetch( + renderedImage, + null); + + // Convert the image to a grid + var values = new double[renderedImage.getWidth() * renderedImage.getHeight()]; + renderedImage.getData().getPixels( + 0, + 0, + renderedImage.getWidth(), + renderedImage.getHeight(), + values); + + return values; + } catch (Exception e) { + throw new TileStoreException(e); + } + } + + @Override + public void close() throws Exception { + this.dataStore.close(); + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java new file mode 100644 index 000000000..dd0e73616 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterHillshadeTileStore.java @@ -0,0 +1,105 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import static org.apache.baremaps.dem.HillshadeCalculator.getResolution; + +import java.awt.*; +import java.awt.image.BufferedImage; +import java.util.function.IntToDoubleFunction; +import org.apache.baremaps.dem.ElevationUtils; +import org.apache.baremaps.dem.HillshadeCalculator; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; + +/** + * A {@code TileStore} that calculates hillshade tiles from elevation tiles. + */ +public class RasterHillshadeTileStore implements TileStore { + + private final TileStore tileStore; + + private final IntToDoubleFunction pixelToElevation; + + /** + * Constructs a {@code RasterHillshadeTileStore} with the specified tile store and pixel to + * elevation function. + * + * @param tileStore the tile store + * @param pixelToElevation the pixel to elevation function + */ + public RasterHillshadeTileStore( + TileStore tileStore, + IntToDoubleFunction pixelToElevation) { + this.tileStore = tileStore; + this.pixelToElevation = pixelToElevation; + } + + /** + * Read the hillshade data for the specified tile coordinate. + * + * @param tileCoord the tile coordinate + * @return the hillshade data + * @throws TileStoreException if an error occurs + */ + @Override + public BufferedImage read(TileCoord tileCoord) throws TileStoreException { + var size = 256; + var buffer = RasterTileStore.onion(tileStore, tileCoord, 1).getSubimage( + size - 1, + size - 1, + size + 2, + size + 2); + + var grid = new HillshadeCalculator( + ElevationUtils.clampGrid(ElevationUtils.imageToGrid(buffer, pixelToElevation), 0, 10000), + size + 2, size + 2, getResolution(tileCoord.z())) + .calculate(45, 315); + + // Create an output image + BufferedImage hillshadeImage = + new BufferedImage(size, size, BufferedImage.TYPE_BYTE_GRAY); + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + int value = (int) grid[(y + 1) * buffer.getHeight() + x + 1]; + hillshadeImage.setRGB(x, y, new Color(value, value, value).getRGB()); + } + } + + return hillshadeImage; + } + + /** Unsupported operation. */ + @Override + public void write(TileCoord tileCoord, BufferedImage blob) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + /** Unsupported operation. */ + @Override + public void delete(TileCoord tileCoord) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + /** {@inheritDoc} */ + @Override + public void close() throws Exception { + // Do nothing + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java new file mode 100644 index 000000000..7bc83cf26 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileCache.java @@ -0,0 +1,91 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + + +import com.github.benmanes.caffeine.cache.Cache; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.CaffeineSpec; +import com.github.benmanes.caffeine.cache.Weigher; +import java.awt.image.BufferedImage; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; +import org.checkerframework.checker.index.qual.NonNegative; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** A {@code TileStore} decorator that uses caffeine to cache the content of tiles. */ +public class RasterTileCache implements TileStore { + + private static final Logger logger = LoggerFactory.getLogger(RasterTileCache.class); + + private final TileStore tileStore; + + private final Cache cache; + + /** + * Decorates the TileStore with a cache. + * + * @param tileStore the tile store + * @param caffeineSpec the cache specification + */ + public RasterTileCache(TileStore tileStore, CaffeineSpec caffeineSpec) { + this.tileStore = tileStore; + this.cache = Caffeine.from(caffeineSpec).weigher(new Weigher() { + @Override + public @NonNegative int weigh(TileCoord tileCoord, BufferedImage bufferedImage) { + return bufferedImage.getData().getDataBuffer().getSize() * 4; + } + }).build(); + } + + /** {@inheritDoc} */ + @Override + public BufferedImage read(TileCoord tileCoord) throws TileStoreException { + return cache.get(tileCoord, t -> { + try { + return tileStore.read(t); + } catch (TileStoreException e) { + logger.error("Unable to read the tile.", e); + return null; + } + }); + } + + /** {@inheritDoc} */ + @Override + public void write(TileCoord tileCoord, BufferedImage bufferedImage) throws TileStoreException { + tileStore.write(tileCoord, bufferedImage); + cache.invalidate(tileCoord); + } + + /** {@inheritDoc} */ + @Override + public void delete(TileCoord tileCoord) throws TileStoreException { + tileStore.delete(tileCoord); + cache.invalidate(tileCoord); + } + + /** {@inheritDoc} */ + @Override + public void close() throws Exception { + tileStore.close(); + cache.cleanUp(); + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileStore.java new file mode 100644 index 000000000..b468130f6 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/RasterTileStore.java @@ -0,0 +1,96 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.net.URL; +import javax.imageio.ImageIO; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; + +public class RasterTileStore implements TileStore { + + private String url; + + public RasterTileStore(String url) { + this.url = url; + } + + @Override + public BufferedImage read(TileCoord tileCoord) throws TileStoreException { + try { + var tileUrl = new URL(this.url + .replace("{z}", String.valueOf(tileCoord.z())) + .replace("{x}", String.valueOf(tileCoord.x())) + .replace("{y}", String.valueOf(tileCoord.y()))); + return ImageIO.read(tileUrl); + } catch (IOException e) { + throw new TileStoreException(e); + } + } + + /** Unsupported operation. */ + @Override + public void write(TileCoord tileCoord, BufferedImage blob) { + throw new UnsupportedOperationException(); + } + + /** Unsupported operation. */ + @Override + public void delete(TileCoord tileCoord) { + throw new UnsupportedOperationException(); + } + + /** {@inheritDoc} */ + @Override + public void close() throws Exception { + // Do nothing + } + + protected static BufferedImage onion( + TileStore tileStore, + TileCoord centerTile, + int layers) throws TileStoreException { + BufferedImage centerImage = tileStore.read(centerTile); + int mosaicWidth = centerImage.getWidth() * (2 * layers + 1); + int mosaicHeight = centerImage.getHeight() * (2 * layers + 1); + BufferedImage onionImage = new BufferedImage(mosaicWidth, mosaicHeight, centerImage.getType()); + for (int x = centerTile.x() - layers; x <= centerTile.x() + layers; x++) { + for (int y = centerTile.y() - layers; y <= centerTile.y() + layers; y++) { + TileCoord tileCoord = new TileCoord(x, y, centerTile.z()); + BufferedImage tileImage; + if (x == centerTile.x() && y == centerTile.y()) { + tileImage = centerImage; + } else { + tileImage = tileStore.read(tileCoord); + } + for (int i = 0; i < tileImage.getWidth(); i++) { + for (int j = 0; j < tileImage.getHeight(); j++) { + onionImage.setRGB( + (x - centerTile.x() + layers) * centerImage.getWidth() + i, + (y - centerTile.y() + layers) * centerImage.getHeight() + j, + tileImage.getRGB(i, j)); + } + } + } + } + return onionImage; + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java new file mode 100644 index 000000000..2de83a949 --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/TerrariumTileStore.java @@ -0,0 +1,64 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.awt.image.BufferedImage; +import org.apache.baremaps.dem.ElevationUtils; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; + +public class TerrariumTileStore implements TileStore { + + + private final GeoTiffReader geoTiffReader; + + public TerrariumTileStore(GeoTiffReader geoTiffReader) { + this.geoTiffReader = geoTiffReader; + } + + @Override + public BufferedImage read(TileCoord tileCoord) throws TileStoreException { + var size = 256; + var grid = geoTiffReader.read(tileCoord, size, 0); + var bufferedImage = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB); + for (int x = 0; x < size; x++) { + for (int y = 0; y < size; y++) { + double value = (int) grid[y * size + x]; + int rgb = ElevationUtils.elevationToTerrarium(value); + bufferedImage.setRGB(x, y, rgb); + } + } + return bufferedImage; + } + + @Override + public void write(TileCoord tileCoord, BufferedImage blob) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + @Override + public void delete(TileCoord tileCoord) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + @Override + public void close() throws Exception { + this.geoTiffReader.close(); + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java new file mode 100644 index 000000000..60c97be4f --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorContourTileStore.java @@ -0,0 +1,110 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.io.ByteArrayOutputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.zip.GZIPOutputStream; +import org.apache.baremaps.dem.ContourTracer; +import org.apache.baremaps.maplibre.vectortile.Feature; +import org.apache.baremaps.maplibre.vectortile.Layer; +import org.apache.baremaps.maplibre.vectortile.Tile; +import org.apache.baremaps.maplibre.vectortile.VectorTileEncoder; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; +import org.locationtech.jts.geom.util.AffineTransformation; + +public class VectorContourTileStore implements TileStore { + + private final GeoTiffReader geoTiffReader; + + public VectorContourTileStore(GeoTiffReader geoTiffReader) { + this.geoTiffReader = geoTiffReader; + } + + @Override + public ByteBuffer read(TileCoord tileCoord) throws TileStoreException { + try { + var grid = geoTiffReader.read(tileCoord, 256, 4); + + int increment = switch (tileCoord.z()) { + case 1 -> 2000; + case 2 -> 2000; + case 3 -> 1000; + case 4 -> 1000; + case 5 -> 1000; + case 6 -> 1000; + case 7 -> 1000; + case 8 -> 500; + case 9 -> 500; + case 10 -> 250; + case 11 -> 250; + case 12 -> 100; + case 13 -> 100; + case 14 -> 50; + default -> 10; + }; + + var features = new ArrayList(); + for (int level = -10000; level < 10000; level += increment) { + var contours = + new ContourTracer(grid, 264, 264, false, true) + .traceContours(level); + for (var contour : contours) { + contour = AffineTransformation + .translationInstance(-4, -4) + .scale(16, 16) + .transform(contour); + features.add(new Feature(level, Map.of("level", String.valueOf(level)), contour)); + } + } + + var layer = new Layer("contour", 4096, features); + var tile = new Tile(List.of(layer)); + var vectorTile = new VectorTileEncoder().encodeTile(tile); + try (var baos = new ByteArrayOutputStream()) { + var gzip = new GZIPOutputStream(baos); + vectorTile.writeTo(gzip); + gzip.close(); + return ByteBuffer.wrap(baos.toByteArray()); + } + } catch (Exception e) { + throw new TileStoreException(e); + } + } + + @Override + public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + @Override + public void delete(TileCoord tileCoord) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + /** {@inheritDoc} */ + @Override + public void close() throws Exception { + geoTiffReader.close(); + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java new file mode 100644 index 000000000..ad710329a --- /dev/null +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStore.java @@ -0,0 +1,122 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import java.io.ByteArrayOutputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.function.IntToDoubleFunction; +import java.util.zip.GZIPOutputStream; +import org.apache.baremaps.dem.ContourTracer; +import org.apache.baremaps.dem.ElevationUtils; +import org.apache.baremaps.dem.HillshadeCalculator; +import org.apache.baremaps.maplibre.vectortile.Feature; +import org.apache.baremaps.maplibre.vectortile.Layer; +import org.apache.baremaps.maplibre.vectortile.Tile; +import org.apache.baremaps.maplibre.vectortile.VectorTileEncoder; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; +import org.locationtech.jts.geom.util.AffineTransformation; + +public class VectorHillshadeTileStore implements TileStore { + + private final GeoTiffReader geoTiffReader; + + private final IntToDoubleFunction pixelToElevation; + + public VectorHillshadeTileStore(GeoTiffReader geoTiffReader, + IntToDoubleFunction pixelToElevation) { + this.geoTiffReader = geoTiffReader; + this.pixelToElevation = pixelToElevation; + } + + @Override + public ByteBuffer read(TileCoord tileCoord) throws TileStoreException { + try { + var size = 256; + + // Read the elevation data + var features = new ArrayList(); + + // Calculate the hillshade + var grid = geoTiffReader.read(tileCoord, size, 16); + grid = ElevationUtils.clampGrid(grid, 0, 10000); + grid = new HillshadeCalculator( + grid, + size + 32, size + 32, HillshadeCalculator.getResolution(tileCoord.z()) / 2) + .calculate(45, 315); + + contours(grid, 255 - 16, features, 1); + contours(grid, 255 - 32, features, 2); + + grid = ElevationUtils.invertGrid(grid); + contours(grid, 255 - 32, features, 6); + contours(grid, 255 - 64, features, 5); + contours(grid, 255 - 98, features, 4); + contours(grid, 255 - 128, features, 3); + + var layer = new Layer("elevation", 4096, features); + var tile = new Tile(List.of(layer)); + var vectorTile = new VectorTileEncoder().encodeTile(tile); + try (var baos = new ByteArrayOutputStream()) { + var gzip = new GZIPOutputStream(baos); + vectorTile.writeTo(gzip); + gzip.close(); + return ByteBuffer.wrap(baos.toByteArray()); + } + } catch (Exception e) { + throw new TileStoreException(e); + } + } + + private static void contours(double[] grid, int level, ArrayList features, + int category) { + var contours = + new ContourTracer(grid, (int) Math.sqrt(grid.length), (int) Math.sqrt(grid.length), false, + true) + .traceContours(level); + for (var contour : contours) { + contour = AffineTransformation + .translationInstance(-16, -16) + .scale(16, 16) + .transform(contour); + features.add(new Feature(category, Map.of("level", String.valueOf(category)), contour)); + } + } + + /** Unsupported operation. */ + @Override + public void write(TileCoord tileCoord, ByteBuffer blob) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + /** Unsupported operation. */ + @Override + public void delete(TileCoord tileCoord) throws TileStoreException { + throw new UnsupportedOperationException(); + } + + /** {@inheritDoc} */ + @Override + public void close() throws Exception { + // Do nothing + } +} diff --git a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java similarity index 70% rename from baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java rename to baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java index 199734a71..d8b7685ce 100644 --- a/baremaps-core/src/main/java/org/apache/baremaps/tilestore/TileCache.java +++ b/baremaps-core/src/main/java/org/apache/baremaps/tilestore/vector/VectorTileCache.java @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.baremaps.tilestore; +package org.apache.baremaps.tilestore.vector; @@ -24,28 +24,31 @@ import com.github.benmanes.caffeine.cache.CaffeineSpec; import com.github.benmanes.caffeine.cache.Weigher; import java.nio.ByteBuffer; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; import org.checkerframework.checker.index.qual.NonNegative; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** A {@code TileStore} decorator that uses caffeine to cache the content of tiles. */ -public class TileCache implements TileStore { +public class VectorTileCache implements TileStore { - private static final Logger logger = LoggerFactory.getLogger(TileCache.class); + private static final Logger logger = LoggerFactory.getLogger(VectorTileCache.class); - private final TileStore tileStore; + private final TileStore tileStore; private final Cache cache; /** * Decorates the TileStore with a cache. * - * @param tileStore - * @param spec + * @param tileStore the tile store + * @param caffeineSpec the cache specification */ - public TileCache(TileStore tileStore, CaffeineSpec spec) { + public VectorTileCache(TileStore tileStore, CaffeineSpec caffeineSpec) { this.tileStore = tileStore; - this.cache = Caffeine.from(spec).weigher(new Weigher() { + this.cache = Caffeine.from(caffeineSpec).weigher(new Weigher() { @Override public @NonNegative int weigh(TileCoord tileCoord, ByteBuffer blob) { return 28 + blob.capacity(); @@ -56,7 +59,7 @@ public TileCache(TileStore tileStore, CaffeineSpec spec) { /** {@inheritDoc} */ @Override public ByteBuffer read(TileCoord tileCoord) throws TileStoreException { - var buffer = cache.get(tileCoord, t -> { + var byteBuffer = cache.get(tileCoord, t -> { try { return tileStore.read(t); } catch (TileStoreException e) { @@ -64,17 +67,17 @@ public ByteBuffer read(TileCoord tileCoord) throws TileStoreException { return null; } }); - if (buffer == null) { + if (byteBuffer == null) { return null; } else { - return buffer.duplicate(); + return byteBuffer.duplicate(); } } /** {@inheritDoc} */ @Override - public void write(TileCoord tileCoord, ByteBuffer bytes) throws TileStoreException { - tileStore.write(tileCoord, bytes); + public void write(TileCoord tileCoord, ByteBuffer byteBuffer) throws TileStoreException { + tileStore.write(tileCoord, byteBuffer); cache.invalidate(tileCoord); } @@ -85,6 +88,7 @@ public void delete(TileCoord tileCoord) throws TileStoreException { cache.invalidate(tileCoord); } + /** {@inheritDoc} */ @Override public void close() throws Exception { tileStore.close(); diff --git a/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java b/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java index fefd185a8..debba41f5 100644 --- a/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java +++ b/baremaps-core/src/test/java/org/apache/baremaps/config/TileSetTest.java @@ -17,6 +17,7 @@ package org.apache.baremaps.config; +import static org.apache.baremaps.testing.TestFiles.*; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; @@ -31,8 +32,6 @@ public class TileSetTest { - final String tilesetFile = "/tilesets/tileset.json"; - final String tilejsonFile = "/tilesets/tilejson.json"; final ObjectMapper objectMapper = ObjectMapperUtils.objectMapper(); final ConfigReader configReader = new ConfigReader(); @@ -55,9 +54,9 @@ public void testBasemapJSConfig() throws IOException { @Test public void validateTileset() throws IOException { // Mapping to a POJO for baremaps-core and baremaps-server - var tileSet = objectMapper.readValue(resourceFile(tilesetFile), Tileset.class); + var tileSet = objectMapper.readValue(TILESET_JSON.toFile(), Tileset.class); // Mapping to a POJO strictly following TileJSON specifications for API clients. - var tileJSON = objectMapper.readValue(resourceFile(tilesetFile), TileJSON.class); + var tileJSON = objectMapper.readValue(TILESET_JSON.toFile(), TileJSON.class); assertEquals("jdbc:postgresql://localhost:5432/baremaps?&user=baremaps&password=baremaps", tileSet.getDatabase()); @@ -67,14 +66,11 @@ public void validateTileset() throws IOException { @Test public void validateSpecificationExample() throws IOException { // Mapping to a POJO for baremaps-core and baremaps-server - var tileSet = objectMapper.readValue(resourceFile(tilejsonFile), Tileset.class); + var tileSet = objectMapper.readValue(TILEJSON_JSON.toFile(), Tileset.class); // Mapping to a POJO strictly following TileJSON specifications for API clients. - var tileJSON = objectMapper.readValue(resourceFile(tilejsonFile), TileJSON.class); + var tileJSON = objectMapper.readValue(TILEJSON_JSON.toFile(), TileJSON.class); assertNull(tileSet.getDatabase()); - assertEquals("telephone", tileJSON.getVectorLayers().get(0).id()); - assertEquals("the phone number", tileJSON.getVectorLayers().stream() - .filter(vl -> vl.id().equals("telephone")) - .findFirst().get().fields().get("phone_number")); + assertEquals("layer_a", tileJSON.getVectorLayers().get(0).id()); } } diff --git a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java index 17c759b04..0fea6925f 100644 --- a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java +++ b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/TileDataSchemaTest.java @@ -31,7 +31,7 @@ public abstract class TileDataSchemaTest { @Test @Tag("integration") void readWriteDeleteTile() throws Exception { - TileStore tileStore = createTileStore(); + TileStore tileStore = createTileStore(); TileCoord tileCoord = new TileCoord(1, 2, 3); ByteBuffer blob = ByteBuffer.wrap("tile_content".getBytes()); @@ -47,5 +47,5 @@ void readWriteDeleteTile() throws Exception { assertThrows(TileStoreException.class, () -> tileStore.read(tileCoord)); } - public abstract TileStore createTileStore() throws Exception; + public abstract TileStore createTileStore() throws Exception; } diff --git a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java deleted file mode 100644 index 214c13a69..000000000 --- a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/postgres/PostgresQueryGeneratorTest.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to you under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.baremaps.tilestore.postgres; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.sql.SQLException; -import java.util.List; -import javax.sql.DataSource; -import org.apache.baremaps.database.postgres.PostgresRepositoryTest; -import org.apache.baremaps.maplibre.tileset.TilesetQuery; -import org.junit.jupiter.api.Tag; -import org.junit.jupiter.api.Test; - -class PostgresQueryGeneratorTest extends PostgresRepositoryTest { - - @Test - @Tag("integration") - void generate() throws SQLException { - DataSource dataSource = dataSource(); - List queries = - new PostgresQueryGenerator(dataSource, null, "public", null, null, "TABLE").generate(); - assertEquals(3, queries.size()); - assertEquals( - "SELECT id, hstore(array['version', version::text, 'uid', uid::text, 'timestamp', timestamp::text, 'changeset', changeset::text, 'tags', tags::text, 'lon', lon::text, 'lat', lat::text]), geom FROM osm_nodes", - queries.get(0).getSql()); - } -} diff --git a/baremaps-core/src/test/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStoreTest.java b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStoreTest.java new file mode 100644 index 000000000..c79b25e3a --- /dev/null +++ b/baremaps-core/src/test/java/org/apache/baremaps/tilestore/raster/VectorHillshadeTileStoreTest.java @@ -0,0 +1,26 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.tilestore.raster; + +import static org.junit.jupiter.api.Assertions.*; + + +class VectorHillshadeTileStoreTest { + + +} From 929e5f0841439ce83d4b6131a7ae90f91aebe567 Mon Sep 17 00:00:00 2001 From: Bertil Chapuis Date: Sun, 1 Sep 2024 23:18:13 +0200 Subject: [PATCH 04/21] Add utility to scale geometries --- .../openstreetmap/utils/GeometryUtils.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java b/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java index e0d6813e7..8199306ac 100644 --- a/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java +++ b/baremaps-openstreetmap/src/main/java/org/apache/baremaps/openstreetmap/utils/GeometryUtils.java @@ -21,6 +21,7 @@ import org.apache.baremaps.openstreetmap.function.ProjectionTransformer; import org.locationtech.jts.geom.*; +import org.locationtech.jts.geom.util.AffineTransformation; import org.locationtech.jts.io.ParseException; import org.locationtech.jts.io.WKBReader; import org.locationtech.jts.io.WKBWriter; @@ -93,4 +94,25 @@ public static ProjectionTransformer projectionTransformer(int inputSRID, int out return new ProjectionTransformer(inputSRID, outputSRID); } + /** + * Scales a geometry by a factor. + * + * @param geometry The geometry to scale + * @param factor The factor to scale by + * @return The scaled geometry + */ + public static Geometry scale(Geometry geometry, double factor) { + AffineTransformation transform = AffineTransformation.scaleInstance(factor, factor); + return transform.transform(geometry); + } + + public static Geometry createEnvelope(int xMin, int yMin, int xMax, int yMax) { + return new GeometryFactory().createPolygon(new Coordinate[] { + new Coordinate(xMin, yMin), + new Coordinate(xMin, yMax), + new Coordinate(xMax, yMax), + new Coordinate(xMax, yMin), + new Coordinate(xMin, yMin) + }); + } } From ea94a0f00aee28cd9ffd98c2779b7570df69d56c Mon Sep 17 00:00:00 2001 From: Bertil Chapuis Date: Sun, 1 Sep 2024 23:19:06 +0200 Subject: [PATCH 05/21] Add raster tile server and DEM preview utilities - The server can now serve raster and vector tiles. - New assets allow the previsualisation of DEM data --- .../server/BufferedImageResource.java | 80 ++++++++++ ...eResource.java => VectorTileResource.java} | 14 +- .../src/main/resources/dem/favicon.ico | Bin 0 -> 15086 bytes .../src/main/resources/dem/index.html | 150 ++++++++++++++++++ .../src/main/resources/static/server.html | 7 +- .../src/main/resources/static/viewer.html | 4 +- 6 files changed, 244 insertions(+), 11 deletions(-) create mode 100644 baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java rename baremaps-server/src/main/java/org/apache/baremaps/server/{TileResource.java => VectorTileResource.java} (84%) create mode 100644 baremaps-server/src/main/resources/dem/favicon.ico create mode 100644 baremaps-server/src/main/resources/dem/index.html diff --git a/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java b/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java new file mode 100644 index 000000000..82ccc43a5 --- /dev/null +++ b/baremaps-server/src/main/java/org/apache/baremaps/server/BufferedImageResource.java @@ -0,0 +1,80 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to you under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.baremaps.server; + +import static com.google.common.net.HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN; +import static com.google.common.net.HttpHeaders.CONTENT_TYPE; + +import com.linecorp.armeria.common.HttpData; +import com.linecorp.armeria.common.HttpResponse; +import com.linecorp.armeria.common.ResponseHeaders; +import com.linecorp.armeria.server.annotation.Blocking; +import com.linecorp.armeria.server.annotation.Get; +import com.linecorp.armeria.server.annotation.Param; +import java.awt.image.BufferedImage; +import java.io.ByteArrayOutputStream; +import java.util.function.Supplier; +import javax.imageio.ImageIO; +import org.apache.baremaps.tilestore.TileCoord; +import org.apache.baremaps.tilestore.TileStore; +import org.apache.baremaps.tilestore.TileStoreException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class BufferedImageResource { + + private static final Logger logger = + LoggerFactory.getLogger(BufferedImageResource.class); + + public static final String TILE_TYPE = "image/png"; + + private final Supplier> tileStoreSupplier; + + public BufferedImageResource(Supplier> tileStoreSupplier) { + this.tileStoreSupplier = tileStoreSupplier; + } + + @Get("regex:^/(?[0-9]+)/(?[0-9]+)/(?[0-9]+).png") + @Blocking + public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y) { + TileCoord tileCoord = new TileCoord(x, y, z); + try { + TileStore tileStore = tileStoreSupplier.get(); + BufferedImage bufferedImage = tileStore.read(tileCoord); + if (bufferedImage != null) { + var headers = ResponseHeaders.builder(200) + .add(CONTENT_TYPE, TILE_TYPE) + .add(ACCESS_CONTROL_ALLOW_ORIGIN, "*") + .build(); + + try (var outputStream = new ByteArrayOutputStream()) { + ImageIO.write(bufferedImage, "png", outputStream); + HttpData data = HttpData.wrap(outputStream.toByteArray()); + return HttpResponse.of(headers, data); + } catch (Exception e) { + return HttpResponse.of(204); + } + } else { + return HttpResponse.of(204); + } + } catch (TileStoreException ex) { + logger.error("Error while reading tile.", ex); + return HttpResponse.of(404); + } + } +} diff --git a/baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java b/baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java similarity index 84% rename from baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java rename to baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java index 964ac158c..3f7d40ddf 100644 --- a/baremaps-server/src/main/java/org/apache/baremaps/server/TileResource.java +++ b/baremaps-server/src/main/java/org/apache/baremaps/server/VectorTileResource.java @@ -36,26 +36,26 @@ /** * A resource that provides access to the tiles. */ -public class TileResource { +public class VectorTileResource { - private static final Logger logger = LoggerFactory.getLogger(TileResource.class); + private static final Logger logger = LoggerFactory.getLogger(VectorTileResource.class); public static final String TILE_ENCODING = "gzip"; public static final String TILE_TYPE = "application/vnd.mapbox-vector-tile"; - private final Supplier tileStoreSupplier; + private final Supplier> tileStoreSupplier; - public TileResource(Supplier tileStoreSupplier) { + public VectorTileResource(Supplier> tileStoreSupplier) { this.tileStoreSupplier = tileStoreSupplier; } - @Get("regex:^/tiles/(?[0-9]+)/(?[0-9]+)/(?[0-9]+).mvt$") + @Get("regex:^/(?[0-9]+)/(?[0-9]+)/(?[0-9]+).mvt$") @Blocking public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y) { TileCoord tileCoord = new TileCoord(x, y, z); try { - TileStore tileStore = tileStoreSupplier.get(); + TileStore tileStore = tileStoreSupplier.get(); ByteBuffer blob = tileStore.read(tileCoord); if (blob != null) { var headers = ResponseHeaders.builder(200) @@ -72,7 +72,7 @@ public HttpResponse tile(@Param("z") int z, @Param("x") int x, @Param("y") int y return HttpResponse.of(204); } } catch (TileStoreException ex) { - logger.error("Error while reading tile.", ex); + logger.error("Error while reading tile {}", tileCoord, ex); return HttpResponse.of(404); } } diff --git a/baremaps-server/src/main/resources/dem/favicon.ico b/baremaps-server/src/main/resources/dem/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..7162b07e37bb49d44454fb9d82aaa73053343034 GIT binary patch literal 15086 zcmeI2ZHQGx7=X{Jc}vo@3@R(#?1K_YF{vy?!H|OJM@b_6CHwtGDO5yR)5+=ic4BZdq_%c$_)s%*Q+L zymw~aS)-^b8W@cqACcBXZ(bHf*G5rPQ`7Z4Jc@SnZaAsm=M9RYdJ0@Y8LCA0fbWZP zX=jrCn^_>UKxTo=0+|I;EHI6C55PFcL4OLnQ*;U31&d%VOn@_>Kct#QnxFvR!#i*{ zjDi8s7qQ+*xD(bu3v_^e9ETraJw4neYgpMQe)U=FDB0{9dTLR$GFy#Ea1^Q$c$fem1LY4yVV zzrc6>xSS;QSEnhk6m~$G4`?fOOS9weyx$H>U^)x~+X{L*{?lLxOoT^48{{FBiKj2~ zzMM}b^}nC;ivBzjX2BbSRZ9#}s}n*QONsXllE)Ik$yn=poL;4x;n2Ri^(2}8r7cvc|77;>Tt7=&H1q#*w#ob_^PjkXWb04d z8tM6L|4O%uZ!`ZXZJY2V^Pgae6Vrdge>`J{^QvcW&*0_cWX{jV4ri8Wytn(Wv5YZ| zv5hfK(BIg{7|2-2n8@~$Qi=Y?X4@dNe}ud-Tpdh;W0+5z3bQj-hFI^@Xhu=19c1U;;DBl8$q2W z!yGVvD|L5rh;QEEgf@DkKgEl8MHi9IhPAL4(ro2ejzMTYE!D@Hp&qoSF?n3P1Dgo7 z@Hxcq1Cs6aR)3o57Jcdx@VEC4w1Rpk+m1i$13O_Ec!xLwf&6aSP$O4hOsz5EwBdegbQE*^hK;U3hoAN_C08yCa8w~5a)dY%!5U67dTJO zSAR;5#>Rnn`qLnj%mSGOG7DrD$Se>Qio)i0l4-tBXqn0mnIBzJ;`kpI10uC!a`S!@17vN9>REx z&98(9;RCR*P{-7`CA4GS7-JpGh0DSEX=4AzItQQ;et^*K&*bf^7T$tZux-B^S8joq z!Mg;X7s3)SE(`Yr+GRhy0BI|c{aeQPa5RjE$6z!30zns3zH;zfAp^(B_->>^!#h9%>J4GWxv0k*B{qN*UIF*V0`_HuRpHA zuEnm&uFbB|uGOyD@qMPJ-=F1w1J}o0umW6@t*0dWch7O}c@cJkds2Lla?ff4_b~Ue zQDC`J>#w@HpY87|V_Uz2d+4*U0Nh*i;9l#V>$BzDi(A3H**)65+C4ky<6hnf2SEFz z?LWLOo(;6^Tv!L59l}2EnIhyvyPiGl%d^OpFc=iiD%XK$mu6^(P{(#k_0Okn$&u3! zJVSj1_NDEd<4vGlJ?EVP}w|62+n<_;+b{~*!QqXD`(|1 z3;Yun=)5mD@!x%gPYW%z(bSgVgK}+A+f!|u+bWQKZF{NIQgeE)BdX06o+xZSv4_q# zS1>3Sz8dJhrx?V;e^V|*t#cu{H>s_^?~CDT7z%0fJTJGyGcW}#=iW67+_S!gR&cFe z1QWn@FvzQ9{JZ38_yRUUGq@Mj!@KY{+}D-=n$-0(NCTP2yB;njeIH(fv%B6sO}e}* z?<}ZiL)Wv3`B2|y%UUN$yuR-&+hC?k8c6@|^|gs}t;EN#4Yj2<)wW7<{LY1Q;ygJ= z&XsxR&N*~0om1!5Id-m{^C0?yKA~?kLM!MquY*3MFAaq$pq~2L^N=Q%(^vJ`FrIk1 nDjxK8eg2e7fzv}^DZ6hSyZVPK;g!F$lIJaGo + + + DEM + + + + + + + + + + + + + + + + +

+ + + \ No newline at end of file diff --git a/baremaps-server/src/main/resources/static/server.html b/baremaps-server/src/main/resources/static/server.html index d5ef77521..6c74e9a02 100644 --- a/baremaps-server/src/main/resources/static/server.html +++ b/baremaps-server/src/main/resources/static/server.html @@ -17,12 +17,15 @@ --> - + - + + + +