From 55237c42cfc8d52b660049fdeb5b6038c232613b Mon Sep 17 00:00:00 2001 From: Mark Raynsford Date: Fri, 26 Jun 2020 13:45:51 +0000 Subject: [PATCH 1/5] Initial version --- .gitignore | 4 + README-CHANGES.xml | 7 + com.io7m.claypot.core/pom.xml | 57 +++++ .../io7m/claypot/core/CLPAbstractCommand.java | 104 ++++++++ .../io7m/claypot/core/CLPAbstractStrings.java | 56 ++++ .../core/CLPApplicationConfigurationType.java | 34 +++ .../claypot/core/CLPBriefUsageFormatter.java | 88 +++++++ .../core/CLPCommandConstructorType.java | 26 ++ .../claypot/core/CLPCommandContextType.java | 30 +++ .../com/io7m/claypot/core/CLPCommandHelp.java | 62 +++++ .../com/io7m/claypot/core/CLPCommandRoot.java | 49 ++++ .../com/io7m/claypot/core/CLPCommandType.java | 78 ++++++ .../com/io7m/claypot/core/CLPLogLevel.java | 99 +++++++ .../claypot/core/CLPLogLevelConverter.java | 61 +++++ .../claypot/core/CLPLogLevelUnrecognized.java | 35 +++ .../claypot/core/CLPStringBuilderConsole.java | 62 +++++ .../com/io7m/claypot/core/CLPStrings.java | 36 +++ .../com/io7m/claypot/core/CLPStringsType.java | 54 ++++ .../java/com/io7m/claypot/core/Claypot.java | 217 ++++++++++++++++ .../com/io7m/claypot/core/package-info.java | 26 ++ .../com/io7m/claypot/core/Claypot.properties | 23 ++ com.io7m.claypot.example/pom.xml | 49 ++++ .../io7m/claypot/example/CEXEmptyMain.java | 47 ++++ .../io7m/claypot/example/CEXOthersMain.java | 48 ++++ .../java/com/io7m/claypot/example/CEXRed.java | 42 +++ .../io7m/claypot/example/package-info.java | 26 ++ .../src/main/resources/logback.xml | 17 ++ com.io7m.claypot.tests/pom.xml | 69 +++++ .../com/io7m/claypot/tests/ClaypotTest.java | 214 ++++++++++++++++ .../com/io7m/claypot/tests/CrashCommand.java | 50 ++++ .../com/io7m/claypot/tests/EmptyCommand.java | 49 ++++ .../src/test/resources/logback.xml | 17 ++ pom.xml | 241 ++++++++++++++++++ spotbugs-filter.xml | 33 +++ src/site/resources/claypot.jpg | Bin 0 -> 200291 bytes src/site/resources/documentation.xml | 6 + src/site/resources/features.xml | 10 + src/site/resources/header.xml | 8 + src/site/resources/icon.png | Bin 0 -> 9851 bytes src/site/resources/overview.xml | 28 ++ src/site/resources/site.css | 7 + 41 files changed, 2169 insertions(+) create mode 100644 .gitignore create mode 100644 README-CHANGES.xml create mode 100644 com.io7m.claypot.core/pom.xml create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractCommand.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractStrings.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPApplicationConfigurationType.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPBriefUsageFormatter.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandConstructorType.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandContextType.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandHelp.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandRoot.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandType.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevel.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelConverter.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelUnrecognized.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringBuilderConsole.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStrings.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringsType.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/Claypot.java create mode 100644 com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/package-info.java create mode 100644 com.io7m.claypot.core/src/main/resources/com/io7m/claypot/core/Claypot.properties create mode 100644 com.io7m.claypot.example/pom.xml create mode 100644 com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXEmptyMain.java create mode 100644 com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXOthersMain.java create mode 100644 com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXRed.java create mode 100644 com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/package-info.java create mode 100644 com.io7m.claypot.example/src/main/resources/logback.xml create mode 100644 com.io7m.claypot.tests/pom.xml create mode 100644 com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/ClaypotTest.java create mode 100644 com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/CrashCommand.java create mode 100644 com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/EmptyCommand.java create mode 100644 com.io7m.claypot.tests/src/test/resources/logback.xml create mode 100644 pom.xml create mode 100644 spotbugs-filter.xml create mode 100644 src/site/resources/claypot.jpg create mode 100644 src/site/resources/documentation.xml create mode 100644 src/site/resources/features.xml create mode 100644 src/site/resources/header.xml create mode 100644 src/site/resources/icon.png create mode 100644 src/site/resources/overview.xml create mode 100644 src/site/resources/site.css diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2a9fd24 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +*.iml +.idea +pom.xml.versionsBackup +target diff --git a/README-CHANGES.xml b/README-CHANGES.xml new file mode 100644 index 0000000..19989dc --- /dev/null +++ b/README-CHANGES.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/com.io7m.claypot.core/pom.xml b/com.io7m.claypot.core/pom.xml new file mode 100644 index 0000000..a8432ce --- /dev/null +++ b/com.io7m.claypot.core/pom.xml @@ -0,0 +1,57 @@ + + + + + 4.0.0 + + + com.io7m.claypot + com.io7m.claypot + 0.0.1-SNAPSHOT + + + com.io7m.claypot.core + + JCommander conventions for io7m projects (Core) + com.io7m.claypot.core + https://www.github.com/io7m/claypot + + + + com.beust + jcommander + + + ch.qos.logback + logback-classic + + + org.slf4j + slf4j-api + + + + org.immutables + value + provided + + + com.io7m.immutables.style + com.io7m.immutables.style + provided + + + org.osgi + org.osgi.annotation.bundle + provided + + + org.osgi + org.osgi.annotation.versioning + provided + + + + \ No newline at end of file diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractCommand.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractCommand.java new file mode 100644 index 0000000..2f4777c --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractCommand.java @@ -0,0 +1,104 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.JCommander; +import com.beust.jcommander.Parameter; +import com.beust.jcommander.Parameters; +import org.osgi.annotation.versioning.ProviderType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Objects; + +/** + * An abstract command. + */ + +@ProviderType +@Parameters(resourceBundle = "com.io7m.claypot.core.Claypot") +public abstract class CLPAbstractCommand implements CLPCommandType +{ + private final JCommander commander; + private final CLPCommandContextType context; + + @Parameter( + names = "--verbose", + converter = CLPLogLevelConverter.class, + descriptionKey = "com.io7m.claypot.rootDescription" + ) + private CLPLogLevel verbose = CLPLogLevel.LOG_INFO; + + /** + * Construct a command. + * + * @param inContext The command context + */ + + public CLPAbstractCommand( + final CLPCommandContextType inContext) + { + this.context = Objects.requireNonNull(inContext, "context"); + this.commander = this.context.commander(); + } + + protected final JCommander commander() + { + return this.commander; + } + + protected final CLPCommandContextType context() + { + return this.context; + } + + protected final Logger logger() + { + return this.configuration().logger(); + } + + protected final CLPApplicationConfiguration configuration() + { + return this.context().configuration(); + } + + protected abstract Status executeActual() + throws Exception; + + /** + * Set up logging for other commands. + * + * @return The command status + * + * @throws Exception On errors + */ + + @Override + public final Status execute() + throws Exception + { + if (this.verbose == null) { + this.verbose = CLPLogLevel.LOG_INFO; + } + + final ch.qos.logback.classic.Logger root = + (ch.qos.logback.classic.Logger) LoggerFactory.getLogger( + Logger.ROOT_LOGGER_NAME); + root.setLevel(this.verbose.toLevel()); + return this.executeActual(); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractStrings.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractStrings.java new file mode 100644 index 0000000..22c31dd --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPAbstractStrings.java @@ -0,0 +1,56 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import org.osgi.annotation.versioning.ProviderType; + +import java.text.MessageFormat; +import java.util.Objects; +import java.util.ResourceBundle; + +/** + * An abstract implementation of the {@link CLPStringsType} interface. + */ + +@ProviderType +public abstract class CLPAbstractStrings implements CLPStringsType +{ + private final ResourceBundle resources; + + protected CLPAbstractStrings( + final ResourceBundle inResources) + { + this.resources = Objects.requireNonNull(inResources, "inResources"); + } + + @Override + public final ResourceBundle resources() + { + return this.resources; + } + + @Override + public final String format( + final String id, + final Object... args) + { + Objects.requireNonNull(id, "id"); + Objects.requireNonNull(args, "args"); + return MessageFormat.format(this.resources.getString(id), args); + } +} + diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPApplicationConfigurationType.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPApplicationConfigurationType.java new file mode 100644 index 0000000..985c9a0 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPApplicationConfigurationType.java @@ -0,0 +1,34 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.io7m.immutables.styles.ImmutablesStyleType; +import org.immutables.value.Value; +import org.slf4j.Logger; + +import java.util.List; + +@ImmutablesStyleType +@Value.Immutable +public interface CLPApplicationConfigurationType +{ + Logger logger(); + + String programName(); + + List commands(); +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPBriefUsageFormatter.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPBriefUsageFormatter.java new file mode 100644 index 0000000..a44152f --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPBriefUsageFormatter.java @@ -0,0 +1,88 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.DefaultUsageFormatter; +import com.beust.jcommander.JCommander; +import com.beust.jcommander.JCommander.ProgramName; +import com.beust.jcommander.Parameters; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.Objects; + +public final class CLPBriefUsageFormatter extends DefaultUsageFormatter +{ + private final JCommander commander; + private final CLPStringsType strings; + + public CLPBriefUsageFormatter( + final JCommander inCommander) + { + super(inCommander); + + this.commander = + Objects.requireNonNull(inCommander, "commander"); + this.strings = + CLPStrings.create(); + } + + @Override + public void appendCommands( + final StringBuilder out, + final int indentCount, + final int descriptionIndent, + final String indent) + { + out.append('\n'); + out.append(indent); + out.append(" "); + out.append(this.strings.format("com.io7m.claypot.commands")); + out.append(":\n"); + + final var rawCommands = this.commander.getRawCommands(); + final var commandNames = new ArrayList<>(rawCommands.keySet()); + commandNames.sort(Comparator.comparing(ProgramName::getDisplayName)); + + for (final var commandName : commandNames) { + final var commands = rawCommands.get(commandName); + final Object arg = commands.getObjects().get(0); + final Parameters p = arg.getClass().getAnnotation(Parameters.class); + + if (p == null || !p.hidden()) { + final String description = + String.format( + " %-32s %s", + commandName.getDisplayName(), + this.getCommandDescription(commandName.getName()) + ); + + out.append(description); + out.append('\n'); + } + } + } + + @Override + public String toString() + { + return String.format( + "[CLPBriefUsageFormatter 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandConstructorType.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandConstructorType.java new file mode 100644 index 0000000..f4cb4d4 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandConstructorType.java @@ -0,0 +1,26 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +/** + * A command constructor. + */ + +public interface CLPCommandConstructorType +{ + CLPCommandType create(CLPCommandContextType context); +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandContextType.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandContextType.java new file mode 100644 index 0000000..e70fffc --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandContextType.java @@ -0,0 +1,30 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.JCommander; + +/** + * A command context. + */ + +public interface CLPCommandContextType +{ + CLPApplicationConfiguration configuration(); + + JCommander commander(); +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandHelp.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandHelp.java new file mode 100644 index 0000000..36480e7 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandHelp.java @@ -0,0 +1,62 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.DefaultUsageFormatter; +import com.beust.jcommander.Parameters; + +import static com.io7m.claypot.core.CLPCommandType.Status.SUCCESS; + +@Parameters( + resourceBundle = "com.io7m.claypot.core.Claypot", + commandDescriptionKey = "com.io7m.claypot.helpDescription") +public final class CLPCommandHelp extends CLPAbstractCommand +{ + public CLPCommandHelp( + final CLPCommandContextType inContext) + { + super(inContext); + } + + @Override + protected Status executeActual() + { + final var console = new CLPStringBuilderConsole(); + final var commander = this.commander(); + commander.setUsageFormatter(new DefaultUsageFormatter(commander)); + commander.setConsole(console); + commander.usage(); + + this.logger().info("{}", console.builder().toString()); + return SUCCESS; + } + + @Override + public String toString() + { + return String.format( + "[CLPCommandHelp 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } + + @Override + public String name() + { + return "help"; + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandRoot.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandRoot.java new file mode 100644 index 0000000..f142874 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandRoot.java @@ -0,0 +1,49 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import static com.io7m.claypot.core.CLPCommandType.Status.SUCCESS; + +public final class CLPCommandRoot extends CLPAbstractCommand +{ + public CLPCommandRoot( + final CLPCommandContextType inContext) + { + super(inContext); + } + + @Override + protected Status executeActual() + { + return SUCCESS; + } + + @Override + public String toString() + { + return String.format( + "[CLPCommandRoot 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } + + @Override + public String name() + { + return ""; + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandType.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandType.java new file mode 100644 index 0000000..b0c2773 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPCommandType.java @@ -0,0 +1,78 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import org.osgi.annotation.versioning.ProviderType; + +/** + * The base type of commands. + */ + +@ProviderType +public interface CLPCommandType +{ + /** + * @return The name of the command + */ + + String name(); + + /** + * Execute the command. + * + * @return The resulting command status + * + * @throws Exception On errors. + */ + + Status execute() + throws Exception; + + /** + * The result of executing a command. + */ + + enum Status + { + /** + * The command succeeded. + */ + + SUCCESS, + + /** + * The command failed. + */ + + FAILURE; + + /** + * @return The shell exit code + */ + + public int exitCode() + { + switch (this) { + case SUCCESS: + return 0; + case FAILURE: + return 1; + } + throw new IllegalStateException(); + } + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevel.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevel.java new file mode 100644 index 0000000..65b3c21 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevel.java @@ -0,0 +1,99 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import ch.qos.logback.classic.Level; + +import java.util.Objects; + +/** + * Log level. + */ + +public enum CLPLogLevel +{ + /** + * @see Level#TRACE + */ + + LOG_TRACE("trace"), + + /** + * @see Level#DEBUG + */ + + LOG_DEBUG("debug"), + + /** + * @see Level#INFO + */ + + LOG_INFO("info"), + + /** + * @see Level#WARN + */ + + LOG_WARN("warn"), + + /** + * @see Level#ERROR + */ + + LOG_ERROR("error"); + + + private final String name; + + CLPLogLevel(final String in_name) + { + this.name = Objects.requireNonNull(in_name, "Name"); + } + + @Override + public String toString() + { + return this.name; + } + + /** + * @return The short name of the level + */ + + public String getName() + { + return this.name; + } + + Level toLevel() + { + switch (this) { + case LOG_TRACE: + return Level.TRACE; + case LOG_DEBUG: + return Level.DEBUG; + case LOG_INFO: + return Level.INFO; + case LOG_WARN: + return Level.WARN; + case LOG_ERROR: + return Level.ERROR; + } + + throw new IllegalStateException(); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelConverter.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelConverter.java new file mode 100644 index 0000000..b49a336 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelConverter.java @@ -0,0 +1,61 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.IStringConverter; + +/** + * A converter for {@link CLPLogLevel} values. + */ + +public final class CLPLogLevelConverter + implements IStringConverter +{ + private final CLPStringsType strings; + + /** + * Construct a new converter. + */ + + public CLPLogLevelConverter() + { + this.strings = CLPStrings.create(); + } + + @Override + public CLPLogLevel convert(final String value) + { + for (final CLPLogLevel v : CLPLogLevel.values()) { + if (value.equals(v.getName())) { + return v; + } + } + + throw new CLPLogLevelUnrecognized( + this.strings.format("com.io7m.claypot.logLevelUnrecognized", value) + ); + } + + @Override + public String toString() + { + return String.format( + "[CLPLogLevelConverter 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelUnrecognized.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelUnrecognized.java new file mode 100644 index 0000000..d1566ab --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPLogLevelUnrecognized.java @@ -0,0 +1,35 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +/** + * A log level was unrecognized. + */ + +public final class CLPLogLevelUnrecognized extends RuntimeException +{ + /** + * Construct an exception. + * + * @param message The error message + */ + + CLPLogLevelUnrecognized(final String message) + { + super(message); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringBuilderConsole.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringBuilderConsole.java new file mode 100644 index 0000000..cd02266 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringBuilderConsole.java @@ -0,0 +1,62 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.internal.Console; + +public final class CLPStringBuilderConsole implements Console +{ + private final StringBuilder builder; + + public CLPStringBuilderConsole() + { + this.builder = new StringBuilder(128); + } + + @Override + public void print(final String s) + { + this.builder.append(s); + } + + @Override + public void println(final String s) + { + this.builder.append(s); + this.builder.append('\n'); + } + + public StringBuilder builder() + { + return this.builder; + } + + @Override + public char[] readPassword(final boolean b) + { + return new char[0]; + } + + @Override + public String toString() + { + return String.format( + "[CLPStringBuilderConsole 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStrings.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStrings.java new file mode 100644 index 0000000..2a13ad4 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStrings.java @@ -0,0 +1,36 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import java.util.ResourceBundle; + +public final class CLPStrings + extends CLPAbstractStrings +{ + private CLPStrings( + final ResourceBundle inResources) + { + super(inResources); + } + + public static CLPStringsType create() + { + return new CLPStrings( + ResourceBundle.getBundle("com.io7m.claypot.core.Claypot") + ); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringsType.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringsType.java new file mode 100644 index 0000000..9b46e36 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/CLPStringsType.java @@ -0,0 +1,54 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import java.text.MessageFormat; +import java.util.Objects; +import java.util.ResourceBundle; + +/** + * A provider of string resources. + */ + +public interface CLPStringsType +{ + /** + * @return The underlying resource bundle + */ + + ResourceBundle resources(); + + /** + * Format a message. + * + * @param id The string resource ID + * @param args Any required string format arguments + * + * @return A formatted string + * + * @see MessageFormat + */ + + default String format( + final String id, + final Object... args) + { + Objects.requireNonNull(id, "id"); + Objects.requireNonNull(args, "args"); + return MessageFormat.format(this.resources().getString(id), args); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/Claypot.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/Claypot.java new file mode 100644 index 0000000..cf4d182 --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/Claypot.java @@ -0,0 +1,217 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.core; + +import com.beust.jcommander.JCommander; +import com.beust.jcommander.ParameterException; +import org.slf4j.Logger; + +import java.util.HashMap; +import java.util.Objects; + +public final class Claypot +{ + private final CLPApplicationConfiguration configuration; + private final JCommander commander; + private final HashMap commandMap; + private final CLPStringsType strings; + private int exitCode; + + private Claypot( + final CLPApplicationConfiguration inConfiguration, + final JCommander inCommander, + final HashMap inCommandMap, + final CLPStringsType inStrings) + { + this.configuration = + Objects.requireNonNull(inConfiguration, "inConfiguration"); + this.commander = + Objects.requireNonNull(inCommander, "commander"); + this.commandMap = + Objects.requireNonNull(inCommandMap, "commandMap"); + this.strings = + Objects.requireNonNull(inStrings, "inStrings"); + } + + public static Claypot create( + final CLPApplicationConfiguration configuration) + { + final var strings = CLPStrings.create(); + + final var commander = new JCommander(); + final var context = new Context(commander, configuration); + + commander.setProgramName(configuration.programName()); + commander.addObject(new CLPCommandRoot(context)); + + final var constructors = + configuration.commands(); + final var commandMap = + new HashMap(constructors.size() + 1); + + commandMap.put("help", new CLPCommandHelp(context)); + + for (final var constructor : constructors) { + final var command = constructor.create(context); + final var name = command.name(); + if (commandMap.containsKey(name)) { + throw new IllegalStateException( + strings.format("com.io7m.claypot.commandConflict", name) + ); + } + commandMap.put(name, command); + } + + for (final var entry : commandMap.entrySet()) { + commander.addCommand(entry.getKey(), entry.getValue()); + } + + return new Claypot(configuration, commander, commandMap, strings); + } + + public int exitCode() + { + return this.exitCode; + } + + public void execute( + final String[] args) + { + final var logger = this.configuration.logger(); + + try { + this.commander.parse(args); + + final String cmd = this.commander.getParsedCommand(); + if (cmd == null) { + final var console = new CLPStringBuilderConsole(); + this.commander.setUsageFormatter(new CLPBriefUsageFormatter(this.commander)); + this.commander.setConsole(console); + this.commander.usage(); + logger.info("{}", console.builder().toString()); + this.exitCode = 1; + return; + } + + final CLPCommandType command = this.commandMap.get(cmd); + final CLPCommandType.Status status = command.execute(); + this.exitCode = status.exitCode(); + } catch (final ParameterException e) { + logger.error("{}", e.getMessage()); + this.exitCode = 1; + } catch (final Exception e) { + this.logExceptionFriendly(logger, false, e); + this.exitCode = 1; + } + } + + private void logExceptionFriendly( + final Logger logger, + final boolean isCause, + final Throwable e) + { + if (e == null) { + return; + } + + logger.error( + "{}{}: {}", + isCause ? this.strings.format("com.io7m.claypot.causedBy") : "", + e.getClass().getCanonicalName(), + e.getMessage()); + + if (logger.isDebugEnabled()) { + final var trace = new StringBuilder(256); + final String lineSeparator = System.lineSeparator(); + trace.append(lineSeparator); + final var elements = e.getStackTrace(); + for (final var element : elements) { + trace.append(" at "); + + final var moduleName = element.getModuleName(); + if (moduleName != null) { + trace.append(moduleName); + trace.append('/'); + } else { + trace.append("/"); + } + + trace.append(element.getClassName()); + trace.append('.'); + trace.append(element.getMethodName()); + trace.append('('); + trace.append(element.getFileName()); + trace.append(':'); + trace.append(element.getLineNumber()); + trace.append(')'); + trace.append(lineSeparator); + } + logger.debug( + "{}", + this.strings.format( + "com.io7m.claypot.stackTraceOf", + e.getClass().getCanonicalName(), + trace + )); + } + + final var causes = e.getSuppressed(); + if (causes.length > 0) { + for (final var cause : causes) { + this.logExceptionFriendly(logger, true, cause); + } + } + this.logExceptionFriendly(logger, true, e.getCause()); + } + + private static final class Context implements CLPCommandContextType + { + private final JCommander commander; + private final CLPApplicationConfiguration configuration; + + private Context( + final JCommander inCommander, + final CLPApplicationConfiguration inConfiguration) + { + this.commander = + Objects.requireNonNull(inCommander, "commander"); + this.configuration = + Objects.requireNonNull(inConfiguration, "inConfiguration"); + } + + @Override + public CLPApplicationConfiguration configuration() + { + return this.configuration; + } + + @Override + public JCommander commander() + { + return this.commander; + } + } + + @Override + public String toString() + { + return String.format( + "[Claypot 0x%s]", + Long.toUnsignedString(System.identityHashCode(this), 16) + ); + } +} diff --git a/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/package-info.java b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/package-info.java new file mode 100644 index 0000000..b4c157c --- /dev/null +++ b/com.io7m.claypot.core/src/main/java/com/io7m/claypot/core/package-info.java @@ -0,0 +1,26 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * JCommander conventions for io7m projects (Core) + */ + +@Export +@Version("1.0.0") +package com.io7m.claypot.core; + +import org.osgi.annotation.bundle.Export; +import org.osgi.annotation.versioning.Version; diff --git a/com.io7m.claypot.core/src/main/resources/com/io7m/claypot/core/Claypot.properties b/com.io7m.claypot.core/src/main/resources/com/io7m/claypot/core/Claypot.properties new file mode 100644 index 0000000..95356a7 --- /dev/null +++ b/com.io7m.claypot.core/src/main/resources/com/io7m/claypot/core/Claypot.properties @@ -0,0 +1,23 @@ +# +# Copyright © 2020 Mark Raynsford http://io7m.com +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +# IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# + +com.io7m.claypot.commandConflict=Multiple commands registered with the same name: {0} +com.io7m.claypot.commands=Commands +com.io7m.claypot.helpDescription=Show a detailed help message describing all available commands. +com.io7m.claypot.logLevelUnrecognized=Unrecognized log level: {0} +com.io7m.claypot.rootDescription=Set the minimum logging verbosity level +com.io7m.claypot.stackTraceOf=Stacktrace of {0}: {1} +com.io7m.claypot.causedBy=Caused by: diff --git a/com.io7m.claypot.example/pom.xml b/com.io7m.claypot.example/pom.xml new file mode 100644 index 0000000..f766654 --- /dev/null +++ b/com.io7m.claypot.example/pom.xml @@ -0,0 +1,49 @@ + + + + + 4.0.0 + + + com.io7m.claypot + com.io7m.claypot + 0.0.1-SNAPSHOT + + + com.io7m.claypot.example + + JCommander conventions for io7m projects (Example application) + com.io7m.claypot.example + https://www.github.com/io7m/claypot + + + + ${project.groupId} + com.io7m.claypot.core + ${project.version} + + + + com.beust + jcommander + + + org.slf4j + slf4j-api + + + + org.osgi + org.osgi.annotation.bundle + provided + + + org.osgi + org.osgi.annotation.versioning + provided + + + + \ No newline at end of file diff --git a/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXEmptyMain.java b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXEmptyMain.java new file mode 100644 index 0000000..3bec8aa --- /dev/null +++ b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXEmptyMain.java @@ -0,0 +1,47 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.example; + +import com.io7m.claypot.core.CLPApplicationConfiguration; +import com.io7m.claypot.core.Claypot; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class CEXEmptyMain +{ + private static final Logger LOG = + LoggerFactory.getLogger(CEXEmptyMain.class); + + private CEXEmptyMain() + { + + } + + public static void main( + final String[] args) + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(LOG) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(args); + System.exit(claypot.exitCode()); + } +} diff --git a/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXOthersMain.java b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXOthersMain.java new file mode 100644 index 0000000..dcc48dd --- /dev/null +++ b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXOthersMain.java @@ -0,0 +1,48 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.example; + +import com.io7m.claypot.core.CLPApplicationConfiguration; +import com.io7m.claypot.core.Claypot; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class CEXOthersMain +{ + private static final Logger LOG = + LoggerFactory.getLogger(CEXOthersMain.class); + + private CEXOthersMain() + { + + } + + public static void main( + final String[] args) + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .addCommands(CEXRed::new) + .setLogger(LOG) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(args); + System.exit(claypot.exitCode()); + } +} diff --git a/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXRed.java b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXRed.java new file mode 100644 index 0000000..d6216f2 --- /dev/null +++ b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/CEXRed.java @@ -0,0 +1,42 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.example; + +import com.beust.jcommander.Parameters; +import com.io7m.claypot.core.CLPCommandContextType; +import com.io7m.claypot.core.CLPAbstractCommand; + +@Parameters(commandDescription = "Paint things red.") +public final class CEXRed extends CLPAbstractCommand +{ + public CEXRed(final CLPCommandContextType inContext) + { + super(inContext); + } + + @Override + protected Status executeActual() + { + return Status.SUCCESS; + } + + @Override + public String name() + { + return "red"; + } +} diff --git a/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/package-info.java b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/package-info.java new file mode 100644 index 0000000..adad157 --- /dev/null +++ b/com.io7m.claypot.example/src/main/java/com/io7m/claypot/example/package-info.java @@ -0,0 +1,26 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/** + * JCommander conventions for io7m projects (Example) + */ + +@Export +@Version("1.0.0") +package com.io7m.claypot.example; + +import org.osgi.annotation.bundle.Export; +import org.osgi.annotation.versioning.Version; diff --git a/com.io7m.claypot.example/src/main/resources/logback.xml b/com.io7m.claypot.example/src/main/resources/logback.xml new file mode 100644 index 0000000..eb4b83a --- /dev/null +++ b/com.io7m.claypot.example/src/main/resources/logback.xml @@ -0,0 +1,17 @@ + + + + + + + %level %logger: %msg%n + + System.err + + + + + + + diff --git a/com.io7m.claypot.tests/pom.xml b/com.io7m.claypot.tests/pom.xml new file mode 100644 index 0000000..0701625 --- /dev/null +++ b/com.io7m.claypot.tests/pom.xml @@ -0,0 +1,69 @@ + + + + + 4.0.0 + + + com.io7m.claypot + com.io7m.claypot + 0.0.1-SNAPSHOT + + + com.io7m.claypot.tests + + JCommander conventions for io7m projects (Test suite) + com.io7m.claypot.tests + https://www.github.com/io7m/claypot + + + true + + + + + ${project.groupId} + com.io7m.claypot.core + ${project.version} + + + + org.mockito + mockito-core + test + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.slf4j + slf4j-api + + + + org.osgi + org.osgi.annotation.versioning + provided + + + + + + + + org.jacoco + jacoco-maven-plugin + + + + + \ No newline at end of file diff --git a/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/ClaypotTest.java b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/ClaypotTest.java new file mode 100644 index 0000000..4cfc60f --- /dev/null +++ b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/ClaypotTest.java @@ -0,0 +1,214 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.tests; + +import com.io7m.claypot.core.CLPApplicationConfiguration; +import com.io7m.claypot.core.Claypot; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.internal.verification.Times; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.AdditionalAnswers.delegatesTo; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public final class ClaypotTest +{ + private static final Logger LOG = LoggerFactory.getLogger(Claypot.class); + private Logger spyLog; + + @BeforeEach + public void setup() + { + this.spyLog = mock(Logger.class, delegatesTo(LOG)); + } + + @Test + public void noArgumentsShowsUsage() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{}); + + assertEquals(1, claypot.exitCode()); + final var captor = ArgumentCaptor.forClass(String.class); + verify(this.spyLog).info(eq("{}"), captor.capture()); + + final var argument = captor.getValue(); + assertTrue(argument.contains("Usage: cex")); + assertTrue(argument.contains("Commands:")); + } + + @Test + public void noArgumentsUnrecognizedLogLevel() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{"--verbose", "who-knows"}); + + assertEquals(1, claypot.exitCode()); + final var captor0 = ArgumentCaptor.forClass(String.class); + final var captor1 = ArgumentCaptor.forClass(String.class); + + verify(this.spyLog).error( + eq("{}{}: {}"), + any(), + captor0.capture(), + captor1.capture() + ); + + final var arg0 = captor0.getValue(); + final var arg1 = captor1.getValue(); + assertTrue(arg1.contains("Unrecognized log level: who-knows")); + } + + @Test + public void helpShowsDetailedUsage() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{"help"}); + + assertEquals(0, claypot.exitCode()); + final var captor = ArgumentCaptor.forClass(String.class); + verify(this.spyLog).info(eq("{}"), captor.capture()); + + final var argument = captor.getValue(); + assertTrue(argument.contains("Usage: cex")); + assertTrue(argument.contains("Usage: help [options]")); + } + + @Test + public void helpUnrecognizedParameter() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{"help", "--unrecognized"}); + + assertEquals(1, claypot.exitCode()); + final var captor = ArgumentCaptor.forClass(String.class); + verify(this.spyLog).error(eq("{}"), captor.capture()); + + final var argument = captor.getValue(); + assertTrue(argument.contains("Was passed main parameter '--unrecognized'")); + } + + @Test + public void commandCrashes() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .addCommands(CrashCommand::new) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{"crash"}); + + assertEquals(1, claypot.exitCode()); + final var captor1 = ArgumentCaptor.forClass(String.class); + final var captor2 = ArgumentCaptor.forClass(String.class); + verify(this.spyLog, new Times(2)) + .error( + eq("{}{}: {}"), + any(), + captor1.capture(), + captor2.capture()); + + final var argument = captor1.getValue(); + assertTrue(argument.contains("java.io.IOException")); + } + + @Test + public void commandCrashesVerbose() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .addCommands(CrashCommand::new) + .build(); + + final var claypot = Claypot.create(applicationConfiguration); + claypot.execute(new String[]{"crash", "--verbose", "debug"}); + + assertEquals(1, claypot.exitCode()); + + final var captor1 = ArgumentCaptor.forClass(String.class); + final var captor2 = ArgumentCaptor.forClass(String.class); + verify(this.spyLog, new Times(2)) + .error( + eq("{}{}: {}"), + any(), + captor1.capture(), + captor2.capture()); + + verify(this.spyLog, new Times(2)) + .debug(eq("{}"), captor2.capture()); + + final var arg0 = captor1.getValue(); + assertTrue(arg0.contains("java.io.IOException")); + + final var arg1 = captor2.getValue(); + assertTrue(arg1.contains("Stacktrace of java.io.IOException:")); + } + + @Test + public void commandDuplicate() + { + final var applicationConfiguration = + CLPApplicationConfiguration.builder() + .setProgramName("cex") + .setLogger(this.spyLog) + .addCommands(EmptyCommand::new) + .addCommands(EmptyCommand::new) + .build(); + + Assertions.assertThrows(IllegalStateException.class, () -> { + Claypot.create(applicationConfiguration); + }); + } +} diff --git a/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/CrashCommand.java b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/CrashCommand.java new file mode 100644 index 0000000..a16d86c --- /dev/null +++ b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/CrashCommand.java @@ -0,0 +1,50 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.tests; + +import com.io7m.claypot.core.CLPAbstractCommand; +import com.io7m.claypot.core.CLPCommandContextType; + +import java.io.IOException; + +public final class CrashCommand extends CLPAbstractCommand +{ + /** + * Construct a command. + * + * @param inContext The command context + */ + + public CrashCommand( + final CLPCommandContextType inContext) + { + super(inContext); + } + + @Override + protected Status executeActual() + throws Exception + { + throw new IOException(new IOException()); + } + + @Override + public String name() + { + return "crash"; + } +} diff --git a/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/EmptyCommand.java b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/EmptyCommand.java new file mode 100644 index 0000000..dac591c --- /dev/null +++ b/com.io7m.claypot.tests/src/test/java/com/io7m/claypot/tests/EmptyCommand.java @@ -0,0 +1,49 @@ +/* + * Copyright © 2020 Mark Raynsford http://io7m.com + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR + * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package com.io7m.claypot.tests; + +import com.io7m.claypot.core.CLPAbstractCommand; +import com.io7m.claypot.core.CLPCommandContextType; + +import static com.io7m.claypot.core.CLPCommandType.Status.SUCCESS; + +public final class EmptyCommand extends CLPAbstractCommand +{ + /** + * Construct a command. + * + * @param inContext The command context + */ + + public EmptyCommand( + final CLPCommandContextType inContext) + { + super(inContext); + } + + @Override + protected Status executeActual() + { + return SUCCESS; + } + + @Override + public String name() + { + return "empty"; + } +} diff --git a/com.io7m.claypot.tests/src/test/resources/logback.xml b/com.io7m.claypot.tests/src/test/resources/logback.xml new file mode 100644 index 0000000..eb4b83a --- /dev/null +++ b/com.io7m.claypot.tests/src/test/resources/logback.xml @@ -0,0 +1,17 @@ + + + + + + + %level %logger: %msg%n + + System.err + + + + + + + diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..b2f81be --- /dev/null +++ b/pom.xml @@ -0,0 +1,241 @@ + + + + + 4.0.0 + + + com.io7m.primogenitor + com.io7m.primogenitor.full + 5.0.0 + + + com.io7m.claypot + com.io7m.claypot + 0.0.1-SNAPSHOT + pom + + JCommander conventions for io7m projects + com.io7m.claypot + https://www.github.com/io7m/claypot + + + com.io7m.claypot.core + com.io7m.claypot.example + com.io7m.claypot.tests + + + + + 0.0.1 + 0.0.1-SNAPSHOT + 11,[14,15) + 5.7.0-M1 + 2.8.3 + + + + + ISC License + http://io7m.com/license/isc.txt + + + + + https://github.com/io7m/claypot + scm:git:https://github.com/io7m/claypot + scm:git:https://github.com/io7m/claypot + + + + + io7m + io7m + code@io7m.com + http://io7m.com + + + + + http://github.com/io7m/claypot/issues + GitHub Issues + + + + + io7m.com + io7m.com + https://www.io7m.com/software/claypot + + + sonatype-nexus-staging + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + + Travis CI + https://travis-ci.org/io7m/claypot + + + + + + org.osgi + org.osgi.annotation.bundle + 1.0.0 + + + org.osgi + org.osgi.annotation.versioning + 1.1.0 + + + com.io7m.immutables.style + com.io7m.immutables.style + 0.0.1 + + + com.io7m.blackthorne + com.io7m.blackthorne.api + 0.0.5 + + + com.io7m.jxe + com.io7m.jxe.core + 0.0.2 + + + com.io7m.junreachable + com.io7m.junreachable.core + 3.0.0 + + + com.io7m.jlexing + com.io7m.jlexing.core + 2.0.0 + + + com.io7m.jaffirm + com.io7m.jaffirm.core + 3.0.4 + + + com.io7m.jranges + com.io7m.jranges.core + 4.0.0 + + + org.immutables + value + ${org.immutables.version} + + + org.slf4j + slf4j-api + 2.0.0-alpha1 + + + ch.qos.logback + logback-classic + 1.3.0-alpha4 + + + commons-io + commons-io + 2.6 + + + org.apache.commons + commons-lang3 + 3.10 + + + org.junit.jupiter + junit-jupiter-api + ${junit.version} + + + org.junit.jupiter + junit-jupiter-engine + ${junit.version} + + + org.mock-server + mockserver-netty + 5.10.0 + + + com.beust + jcommander + 1.78 + + + nl.jqno.equalsverifier + equalsverifier + 3.1.13 + + + com.io7m.primogenitor + com.io7m.primogenitor.support + 5.0.0 + + + com.io7m.xstructural + com.io7m.xstructural.cmdline + 0.0.1 + + + com.github.marschall + memoryfilesystem + 2.1.0 + + + org.mockito + mockito-core + 3.3.3 + + + net.java.dev.jna + jna + 5.5.0 + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + + org.immutables + value + ${org.immutables.version} + + + + + + + + com.github.spotbugs + spotbugs-maven-plugin + + spotbugs-filter.xml + + + + + + com.io7m.minisite + com.io7m.minisite.maven_plugin + false + + + + + diff --git a/spotbugs-filter.xml b/spotbugs-filter.xml new file mode 100644 index 0000000..9997fe8 --- /dev/null +++ b/spotbugs-filter.xml @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/site/resources/claypot.jpg b/src/site/resources/claypot.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98383c3aac506235b5a02430b48cdf4a310dae4b GIT binary patch literal 200291 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�>Ux!YR_uUQ)<;+6+b< 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%0A4lkSY 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%0DdFIBqhd`xFGwwebsm}ERo-4 z9!@?JwbLV7Y^$wm^kSH*qwlpV0YsydYD^LgUI2F5iu73B*NTn-*i)(#Vnx86iOmAC z{{X7=ROBUUU8+)ll){JhSC8Z8UuWI^q2M;3;Qs*dWcRHu$r2* z&yDhMOB}i*W3>A!!DV}Y6xG@|>60z^#jt!8oDBU#Qs}zTJ25h_RAW7kpHTT$38n1S z+bdUh90?=CSO-12nyXJqi9x?a3yzQiJT>j^t(85O!TkW+t_6e2qk=no>VJXpe?r0K zsb0!S$vp?Yg-DkdeF`Dxa6Og$wxy;nFX&NkyUVj{-}t7BuEoWSB(2Q5XtX+Gb++&Mwfr$u znhImJGVsnBRt|7+Sz0xx?0cu(c{7mGT3I>h5^6Ff#>$P^)I21$TxNJG7U@d_{gzaJ z0beEhl;E35qv^Z|wv(f*_;;tKv2eG$BGEMnM23o%rW61HLnQ6ezE>_qC)wzE86x1) zev2deW%AC}shvN}EA>`8U7YJK`$Z>HSZ*ygr3*ytWB&k$U+S%K&No(eV#ycm$*=aS zqLSzQQ#%{~0MXa_tJ?AB6*kw|{gc2dX|xqV3e;a{q~%rlDik1sSQ^aEOM z^Cm+~BGELdWNqLtKZSL?kxK01c;)FGL%|&lKGzkM$g|7~Aa1DYAK6}RNj$TqvgaiT z)txJ+qDgHDACuo09okT@PaGx3NaS)~WwC_GNXUxl{{T?csLSYv#xrW?vh zaabV)f-}~Kje^q5K8<(QFud+4$D7UheTi^cxWPep-FBMBvQpsM( zxjGHyC=}b?BmT(#s^^!3D7&Uw%)ZF0j}K(J-zqK7pZleLs?J_4{U$i(r`c1R!yAxr zl-s3$vRCS?K0LA0Oz2)jYqGU^;ohJPsVKF}BOOCZ{Z&p*J)>A>gVSY7PY<;qUOyww z+qsUv)kJe8*?geiXv{S}k-WEZn4xNvw5j(BN?B0~9LI2RU9im_D`qmr+?zhS#yusrP?Z*qT6#zYR$4>1F7&; z`m3W8jjfo;KcfoOvE-t1RJhKh2LZ`J7~Z`cZBfUOG|GLF9F@EPjOpL9O>LG*BM2sJ zT0YNkQVEA>|^oPN!?v{+fRU7G+K zWWV+b{Z*Tid$N-*f0OR%1O65Lav7`=2Nml#0IX2mU>{a@x&^aIzZM!Jv@@%2L z{{TX-)l^R;I7O!FM)v7n>{YkuriIB5ZWhanml-Z11cfC}EP@(Q1Qi~eP)uZ!6^&@Q zk~40TxBXJTRZ>lZk|pC>E3T=~;Kg48b{>c8SI6tBCUtqaxoLkSSKmN^CTp!R{`zp7) zZ1lR77&0&xGJGX$Gw`hGr?EDuz%`5+{HB2Rr`suhm#jBv-Sm6kGIIE&49tMg_7){{ZzW{Z+|4(fc}M2ke$_MNhyV zlO!I;=#~1bFPVLsC?3=rUR*{c$rks@Qh~T=?bF>$9$uB3Vvj6|b_Sb{-j$dX>yNUT zjin8`(@HL-Nm1V*9#QRJEJIhJ_0?H!(fk1RPNq5EI{QB1J68;P8C(-EAE>#jL= zLrPPT&y4VG(!O#?8QB=kdk~Aof&Ty}&iOeOe=0vq*`<0~zb5H@w`oR$!rx(z+}6N|2+LrS#d_M#Lq~TTVReE>1mI}v%+aHq|HisrA*}NRHOOFuWVK^$IJ3%Je)rg zi@{DGzrv0mqotZQiZAHv{Kp=uqQnU#av}4X|oya zFS5X1v_ZLA&;SE-61DYthh_zA8%7@Vo@Yc1ubFn3Rxnj>4lBNBdEpe;y7zo|%pD zi;4G{sWNSAR8~~HI;CfGoe5`q!|r z{w(?Vnw z*C|p|l;KC=RfooNm9gZ^p&CrVwKo#nyeNoGI)FD*i&j*s^dsZbws6Zm^i>tBq_dJ` zs2{bzTGQc+?3LtABDX74Nm}_z&nfAO(PD|8$s#IM&2KrCsOPO}l@Qx~h_vg{91XOR zbFnz0iD=lkX`m&~j)kHc+z+S@ZbO0a+jF&LIV+;0_I0lbICR_=Ql&;%Ab<#LoxHkN zEa%A5Cr)YD1|vymFr+7w*c`YY8kCsb3tix9Np@LCvf?b&!NKyy*?GW6p)%8U3hI-V$CQ0c6#eK3;-{^OxZKx9F!ksWD80RDd_f~Jo z%=$&FIL(7Y@V3dPAfdZ9o{tD11JB{*e>%oXB=;t0oMX{%QDzKR6(A`HLP=7H#>2f# zst6*SEv`5=zN`)~Fvb7~ms2#eB(WND` zD7Kv)2WH}Zk=`4ce0e;#6V<_)LM<~ev0LQ2^RgOjmeQhf2G!e< zr5a{FJT7)?JTkpGWfEU49(8?O*Nx@Jo{ypN;rQDlwQbsS!OOGElJb}3u&Kk2E=maN z%O{5)B!z7{h7#?3(%r(4KDIm5W$~n^Q8)3t*h?2F_E_zACYFSFuauH9k7R*SKOMf1 zL(PiY8eV;G#z7t;*h<3IKsd*~x4}?NdpUf#%RH0q6Iy~QB--1Mm$?`z$UM0<&*NsS zjxB8K^L%c26qC_bio^*kPz8L^y`%PXUY1fB zgPgpa*ec)3xw1-sB3_S6#>a)?a(}wY{pU~4Q>YOc@g+K;hQP+%y4IL{l=S*C^FL0K z{G;0-CZcVka+tZtdON^-NF!|5TwHR-;LkdE=i|z)Wkzc@fC}0AoA6OxUsRYST8}9`I5l&<3e~QeIm5ab7+pNc+Dj@@&rUu}})LjQLk~IUWa%x?IbFi#9vuYw{N-l0sPcHSOVljh`1!FyHRED0YC{YRu z$9al4OyMW0j{g9CY`QXify#Rv z8mFKNM<~YGqyi4%IVXBx8bjDYPu9&sR%#;>V2>%cxv_)2RO87|8=nmIieoLI&#)uE zO7MK|7n-xw@cf<*nbuq{*HPTMT9UVhJ!PDn{{R^^@_t{1D5lZ$3&@UGIQuM8wbW+g z?)pZ@y>qV)P4r(lEw*Obzlib3QV{UYcEQbd;P7Og(UxB>DO6dU&ea~cPq&bKtJ%fl zaOmKkd(ezY1@&`v2D?-^ob#V2Wb6P@Er&6QKb|yK#_TE9thRb*G%WE=JIW#u1RufDXF zM&cy4G=5P|=D8f&E{Msq5~Q80Jd9|sPL$HNPzN2Wo-(#-;y~P8f(FS>YimP=nJ%YH z7w*&ffd2p)clzeKvA4xha!966i3=qu<*nm>%-LDG+GDs0PBC3Ek&BMVDKbS#z@XYJjE1^&ehQtbIV}cmGsHU?~18(N;J(R=>;P{3gOGQqpu%E z!Ka`06Tg*k%~Lv}TN;o9N80$-G+Jd>Qpw9}-nwxrW>fnyT}b|J4X7XC2jgCh6~yAm z_E&5NndFRhHF-KC8a8bpjHSF+pEI&LH5*$Xp(KjtX6Tz~z3_Wf71?ny@|wn|n+Rg_ z9rmNJv3StN+jQERLTHDGw04pb z2tMknC62H$R00blIK^iB7#SS98c1L`thTD81xogz@TQ*XZWGk&*ybPh3`V=-v%6III=Bl^u_2=9{B%YKKgOw{iAJnCX$j1pe zQ{8|4k(?uC$9T(NQf9j2v0e3$wKzFmXd!qh1L}@r&}=!Y(9f0s08ZLp{{T$zC)Toxh`ebDZOKNY=Gq6m0&F z_L%ZDW$hP>%dUkOjkuL9g(V=4d~K8L?SMVipThEK59FhZxUI*V_ZW2r+w#wW5px|1 zNpO{^fPuFrHcor|O?2bK@If`YCN-K)6LezlLwY17O$+fBr#W{!oD7qXFMW4LYEF(h zL*q@C4G6>5J8RmFNh+OkQG*R57)U!PbUA{j>;Di0&VwN5mU+`8k)4d{w(^eMb8+XGmSDG30AGN)!P&Aa}0p7^4Mmv!68G z(la}BhXX5dI6TVlTVz|JF}9Y4J!ix!_IL86qeb0>F68?sYNUkEp`M9S?r-`#+#|@4 zw1uVSqv2f>%h*>3mX(@eZ<0EbgPPqo{tjBdD7>fS!fV1`G4_J9fDIhiNSR}H?2F@N z?%a(ciC2henAEmbmly{b3h9qLQlHT{`?#Fv#m19=;Kh~892IgzUm_EX1f?6OljH!Y zTAj0W=`s(5muYw14aqT=40adD-?xxGvA#UBwPoZb83rfGi|NS4re?U7{AB_*1Iw_l zBlQ>gMITZ68mP^(0{N+D8=70WMRA4@2}nlDCmridForn(FKpMymQ3#4bd0xMYU_I8 zISwcaaYqOW`#xvmUdN9I+dgB;ojPVgaJzcE#7hok*8QM8_36Skk0T_hnPK~pCiI;Cv()* z*_Td@XF~Al(v?3pB78Rbtz+2-<5^B>sBui`J{{=WQlUk9GbK$nJ*1J4I`8fk%{I}j zQtaIHouv>YH1lOCjz=)(IOaa;&6WNQHqSk&2tY~{T~WpW+Z53>%W^)9rz_?pXP3%` zB!@8_0ec{lPV|igWHi@|rLGzjlbooER6b2E#)*d&WnQfvw4Xj&DGf>cATQ~X;Y<*a z5C%$sq{>c+OO4r^EIw3{Rg4l%WjQFCMOn+fko<0!8WQX_c|k6@`{L5Az@>v1%I;kn zx%?{EXCmFMezx*nONDAA^A&eKb?HS`nZ=S^wnEHp#e(YFQSu_SQe7BRJ#UckaXAEl zcG`xM1tyuN@Xt)}@@SoV*Kf*83?nTz)<-)1=DBiZlouHGbz#Eh`M!#ji8iBpbhO(2 zOPKg+QQw!gee}|jjr%m7NIBBzacjAy7X`9{;#g6_P&%5K#klXXu}LhN=+bm9nYvx? z5z)-Hqn8J;v(#6epDZy)`8|vnvSfUgk}mvG(+5vC;jE{^aRZ>udEP!wc`Ws$)bJFm zWu_BQn{NfeRnNV3WXm@rJQy*?6i!_y1lmx_pocs#2<6y-Dltct?!z;1#{U2t6Sr#^ z642GPY#$7x3d(!@Ygu@lTbp}1asH&_mN>^m!msVewLF4z5=Ntjlg-2bp9KV3Kz8`Bmb_{WYcRb1&Kz4l-jh!C<8UAON68>a6l&StCq-HhE)` zk;IcO5AgepP@O}oj+pllm6CDH(O3!u_XQ-^n(-%wP=1eV%%3U8BKCIcc4&72%s?q| zIUYv7ZK`y2Mplz68i$5<*~wa8jM~zn(2UTfPSK*Boae=VMEecYJ8-lk)ueU$F^t!z z<9@4~1x8y(CT|B8f5~Z_-KhNEi=i>`d(-@$<^kqB1_ckiRV&PxUVJ)N8ROHDpyy$ zMJS&=tEw94@%)8$R^_+>QjK&)o@PxIsm|r{M%&iu924wODpK+Y_*68O&4Dd=g8*P3 zeF=x41X6K<={Ql~H`qAxEhjc~C2TfCvN(bn~ET?0Un&BRR%)`|27kGEy{%_Mc+cZH2^w-ah$VW$pKjN}UP zvsC3s-z1WaGj_Av9tcUv8&_T*9!Yj_ITLHO`v9qQ@?%3q66tDfcR7Hpe*Wk6jd(ev zp^>lT^zp{vhH0|2T)KQd}FzcOT9*-GOm}F`Kr^+|o+@-s;smV)Q}HQ>h1Y zirpB5iZPQlni)@+wZD!sIeuqL(YmDZyWooWa!39kyyD5D1+BE*9D`NV|Ygnr2H#K z(GfH~Eba;pYl|W}v6{_-MiPOM?yf9|>P5Au{(~U(A0b&$dn($NM=MG@Y5l&hhoTclo3Vf19Hbgl)gSS%aKw#pv#;$ z&nf}|IP$JGcdeq!ZJzP~IL6h4l4gm}7YoFs9E|+xBLvEFXkv97qzo%Rs;lEf^J9rR zjzZ-x+Bn)IKqUv15~1BY`PR77gR-NQ$#7+Vf^noryK0SI zytDZR)Z#o<4U*%|1ff597|*`Dv;P3oj6T`Pj!9;6eWc3t*z%^&{{RG%66}H-IT#tv z$9=xa2|iWX9x#owf?V>>mt*T?zSapv+FO@7h~I#LKw!%PcGfYbGXfNTgx_+t2dK-nW-ru(PcO62Oc~_jN zwvs};Fi$`R{{a1zWP0Lao1RW>P==&ax*LKTqgkbDO!;X|x+;{EuM1kRNGHFvck8uI zDDtFRe5Ypy>gA=!Q{jxIw1kr0>FwUV4;?hEn0ZrDl1tGUY;3;~NE!A?+|}fDA~AFV z!A`{dX{Ti|Yji0$N%8IRP*m)P650?3NhIQpc0u%WPgw?Vbl&LLAOi|+&-SEmz zGD6km?i<&al6>-6(+Ke)v_}+Lv*{Sxd6^|^azS;)g>vUA7(4b9I7{T$K-%K$+-?_3 zGn#qWtjJx$RP=J7yyuJIs3)R-H-6M*(xW^*+0P!5T7vOr(stb|8sQxeIN51Yns9TK zsPB}Hm0mm)rEILysOZo*bD_@;bOo+G*_1gt?H#tANjs#I&5%9W70sS}r0b(h5pzo{W<$@oi6@!m6oL<5eRTLZ zX7>FZAF25mu}6w#8>(fp+?2SGFoA+|xv!`3qWJ9iPd_S@^o;uBFPq1G3p=ZoHQJHp zj;t3skzGWDJftlI6szAvmn{u8wrzYg;(W;KFeRibgU7L`--=TNokU@IK88q zHMW?R-NoBZq_=qS)OIUR?`h9n`uuBLapSo5XO-V%UB88TQX?gCBevr!!B4T3ljJL^ zIi)4Dj#$!V#>t{zl+v4%8K~?waMA$SezQ{K332GY*ijQr#at-qN&>%p3fUm}sQLS< zTWnRbR#oo(7ATz(+Wh931z$v-zo=4WCFsp$`c-QU7kUf3=_#>cCnJ=gl&k%2m84*$ z(q|&5`8g=w^2M47O6zrtqU5;jYf9R(h zP>*SlrKsQoN5wH(UdrUJPRZ#|Zr!E;ZAa^@^vzGk-?K}ITi>K_6ZL}#8dB1ft>ojK z3D{O{DL=`Ys;wd-4wB=Y_2fvtYC#z)1#9tkMv;Wuvz$1&Zn?$P64+et z$_0~!yx2G8r| zPL(UxVn<6+vygMOFOfx4Dma|phw^n@!MiH7`kO;dAzsk~1yu_ST)CS+B2a_ISK14G zT7RO*Y3?mKSYo-d)4@`R6;_0NwKV*dah&ZO2je+6dT+^c=S zKOtqt1Tt> z6rs>JbwktkHyx7^DSd6>w5M*_#wlax*`2K%95UA zjFVpbf{ju>HBHXko{Of2;I^sN!MmiU3o)I`fo^v|JDSfXXyaNQJWnGw3ruYnpe;_! zxxU(iD8p?9WUXV&R~IQ{>1^&;)E!=oi%@Y9o0z$Xw$QI1AaW07wEqCUYjxwzG}|U# zRuvgVM%hi$w?#KS5m;mwWFB7^8>YANaq^A7M>m0$$0r!}#=7R$77X;a8=S9y8Am&+ zuf?A@S(l%Q;>gomBlPp~;!H}}kffw%pOo%XTV$rGoN%?YT{Knolxqf^xJgqj9N}kT zn#OSaG-=A(v+55DFYvX$3@w)?En z)-f&!_K@RgQd9@lP}t|*YmSt2NiS!(u6`tB{W?0Aftu;PTf&Pa$FY&e){>ZHy_8DqfZ^&X_iZ*hnAA0rwQ*|$m&YS8Br5Cl>n@tDonUujjm(>O0Wi0kzY&UezT7?LnfKyc|WDj3!XirExbM9sY)2FacuhUGAcJkR&~G( zf_Lp*k%9A>@@%c#Ze-;s9_r|XPbVbV3`tV?jcjtgl8qqeu&f)iapQ5p8NeX*+M%%y z+l)D}fID>UNJu)OfI$f(q4@7b(jDy)lUO{<9!fu=t}ogKLP|~vIN!g%x*}yhhQJY= zjq{qeWwCT1t8I>Y)HZ07Yhs0+@_pT^Y^qmhxmMT(Bn;$rpdN*plCgzn%QQ4KvGWsB z2?`lK>o))sRII5)5!Cgoszy(+ik5fW9CV_n1RR&0wjUa#fM(>CW8ctws?f)I{fDQhlV8zILbR6`E#`Q%y417ytoW?`XL8Y#K@S9Js(q$M4OL{X)62Crs#r z+9X|SKdP%GIq8hj23KUX%2pBp$u#UqBu?2QH_MCzIDA7lhsOmifZGEVWAq*6Nk+~J;Mov@wNX<@6)veH^kUg69 z)ueNhF5BMa?_Bv)lA@yMq+G00-MLCBQifk}{{ZSW^Ildq^2_|Q*25&AgvOeg%nnUp zv9n%r9GyEWmmJEZvC75G1xB5fos?>vSaU_e`z(&c?_Rg`@?Ot3ni($7EOjQK`1uOv zhR)jMkE)VuIe7Vf50Vp!XqD^Hi9x`5ABd>O<79awuV_<};>f3MGR8-T-^#h346D(i zk|X5WWOXh6ipp50+e5TPKLx<01u|=%N=b~1mv7s4zeP>Rq{w*?+dj&X%jdOE$tBrI z(ObFN+AAst710dMXxVIpm2GIWKv1rQmAA3cQMy`6ALa@GZfn06lW2)T%>MS0Z zB^yjiPRO~JPHgiKcCDcU8BDF*q=hRW?02rH#*TSAV`xtMVui!H59`V42UO2W2UWm{8ACADwoT{zK{-5Cw}?9N920Bt{wcfvY2 zq}_}(;=Yk5uJrPYA7;&^9ZC>`p4GvT9g)&B+g-`Dp&**)aWzsbw)seS4pjs2sNxoA zXLM$gi54)H_lJ|@I#EKgn^$7nfD$V=6GT|;*L1poIk)XeIxdO3gpc^fU;VS6)-`f_ zWF@2^U&%DAD_|G4p_CC%k>9OFfS-yAz9x>qRR?OM0&Uf(>_=;$j zV7kpi)}&zn00^(fy(~Q@bLH%y$x7T&2^H0JbI=S~7V-A6y=RhoHph?bl4DC1kaJv9 zot==zTHsioX(0hZxTf}Z#w4_RJHa^dD+cV|F+$4I>v2CwyymBs6!HCy9?~c{D_2UT zl!uK6pQf2&Q-B=w`~^79(K3RvK2?dOfDd6;8T%o|x-BqlwjDRYyZndZrKj&xQOzKL z3WFsJQ`*Ll0zwd!fG~t7uowUVTepwKhc8IV81s3V7A5}xgMQ$ZnT<22<7w!xrFV;^-PA~N z2q9s#_$WdGy7J{tpPhN0MBkG&CHqfT4iD&*@yl{Yc=01n+Hcx1R;Qi%IOS!Kl=T5B zPcD47sLLOYc8)w!=D#D5_`So`+W2J{uFA_Rk%;a*-Z^>FP8HOiZI8~m@XfC#+dZi$ z&%|(wGhHpEFV{PS3v^W_+kcANMJZR-E^^>!aGro|jm>(Hlw|kW;bx1*_0iKDL-csR zTi%JNZP2V%%UzB#-IS!LmmUOisALYfApB{+#WFF?Nu=2KR+usMtOm}Pg(lx>w6v_c zg(+j{Gs?<(6@6d44=UiB;_dd?>S9kMc&AHtLi#}K9Ybbj*{3ghEt?!kpW!i{FL>%X zz}yas0F3+1ZN=SQ%s&SOB<*xYN#Xk(RNyD%dt0u~lW(46~?~xOH{WQ|4M;h#hhx$x4(_&DVbYYpV`;c?nJXGxBgt#cnZHzRbd8 z84=R(Xq2d|k`g*sYKmu{@<}2M5g$bURRx3-jFHzr`_;<0gd63veDrP5Qa>*-uI_es zWW|W*EJn&s9B_44z*h&C{fuid& zw2{u7X5v(Pvwo#(ca*%W5IZ(2hZl`6kQ<+T2V4_t3;m! z_%8)=sQ_b`d;UVHKkf?}yl(v*xdU8kT{SV3%xpOkYXMjvX1XH?wsOu+j)b?~Mb-p) zv0)*$-avge|Bg>KVK3q9=( zHe4VCD+eRrM|}xJ-J;8^;_2O82@VZDne4jQN$`>iagQ(ks~X|7bVatd%pU&$=*?!m zTo(Hpb~HH30~w8l1NQ+vnojOQuFc@lqJU-fxkNFR@n*&$=} zJ<{>qTe9u4rXa5fJAya((DUYNswd*anWpJKMV$j^jwH>rgyi!p))mYWJ_l;bQp)z( zqh)t@B-v0$m(m)VV*%ZzXZA7+7g6tZoSJ zOJZi!o98fR}NV?y`HWZDXkh6=D=={lKq`&$_O0(Lb&0PMpq-z zlsV(5_C#IcziNWhJif4}FcqG)Smp9c`W{d0<5BDjNp!8a;SDAACkRQ%!0(!@m0!U) zd#c+eBVL__bZ*|;t@ub8S9iaHyM z+P>AInP)|4{{UC;JTSm0`uM@kdGeFU+kGCE94ize+x(xSmNmp(M&qw3`0lBIdAB(j zHPhqe#`=3Q^6+L`trhJy?Y>hopvqF4dBKG3vW;uxa*a6jW8udf?lbHg4wjU;X~T;{ z=z9oKPQU}!qd$_kZ=<8c@TKziv`ldV*116!0P%P>JT(BGxb8@<@@Vf*L9J}!Z5PcQ zHef@MT@o5eUsSAa2i^^Fr}Sx>4jB`E#=e)bBuJTOnCy2_3YE&DFoH8&j#rz1N44Xx z{-aCmy?PqoM4JWgPdKFg1cXdwAzAiToG6d=llp7N{Z$@Iel@Z< zChSXel64*E`8L1N$r71 z#{U4WniE#2W};A_0o%Pp; znjyQ`kvYa{k|DFeg;MA)!=P@HNtG1KMxMJC2yI6kr*AIRi(5CoOwqK~ruAvjTuR5X z>J{=LvXm`RQI#@D&0WlZfJH~f(D|X7ul^%|m2XW)L1nj3U3^re^H&~i9k>~~@Yh6K zHA2v&wouM``PY}8d>tdwglTep9YLV@F>be|x0b+C{K&3o_|wn1bY(vxwG(czX%-_k zfDix!9V@FJjSOG49P-J1miTsd(2zNCTP${D@(%w1CAM}Vlfs0uvK{*a22;!B87?UP zn)9-FadVSv+0`E*@kmj-9DHt(NqBK$`Pe4N#(t=&ek4<&{{T@Se?O zM7phw9@XeP5qdd(RyTUo&OWHAemYwzWo&QxC7kY&QShSvMiskLDUjI!Y_y-#L@*^Z zDP(Rek9yS62PqYo!i`kO$yUY&K}e|hVx2TsCPGcL#aA)pNHv_iJag?0O`-~2x;Pji zHOD^=2+?G0ft_iJtegQ{nLHTFXtj}|yKuC}SSi3Y%l#^Yqe$gzWk&B{Lm;@FhsKA8 zinMJE_o9WUBPkr*io&a0P&QN1ifT)v?A>Pt{{Zn0e^}SEhBpQN4lJ{&GNV6G1S<-z zxMOVRmPA9$zqay7P_CF`X_(I?kqf%C3HGsF3N4t}@>Ro}x8gQ{yU%6H3`_OLg`U7#+3t-F`57>i6bO-q%eVA z)i4~ktnESpcQ$K(jWz{7_M_vY8P7U@8fu=1lQ2DFl}nMI^NRdy)5X#-$=Om!0PZVe zCD`?cf-zXl9T8-c7bG?^dsi%?bVDT*P2bu<8-b5~bG%k`tjKiMsg9ql;(m1x12tKf zVux2l#sjJO)I1H9{X!6PR>xN1#Qf-3C|^B^-1S3in4pCN%s}|;D2^IJmQkMLF#S3>4sJY#)_%F45;@ebLvP zN;a693i^vn6P>FxI|<0hu{fuE6$Ie6p}Edad~MpQ zPM*E!SW=b4{Y*#EGmXEHFPAHRqL}Ho-6R#2D`c|bkJkJ46~0LEsxVI5`!{WSz*O-M zQpcI5(G}4knG&9LSwKbyapW_%zPKkJjoNxUv1d|;86%u^m!f6$tF)-LR6u<`GSCQj zkb#q(k5SUL$NGe7rRd8ifj`{6l?MGAZ1&0Py6gQ)%xJN&Lk%csJ$F*dj}NOgkDax+_8yXlX#o)7Ni#^Y30?nT6$X$3EM(&wup!!yhc^ z)p{{~U#X4uO8s&sCHRFT1$|MThu>bGiG$%(x;)R+Jl~&kTRMZ$z}c<(Im!BohN4DD z3y8|_6jVC8qJKqa<;n8myE!~)-{i}W54f4bC$-$G#wsRY|*XPTY>+gFjQ2|7BuTpr^NuG2w zyh=;aSJfAY&?71{4j``^sBUt4*I$o`$=f{dCpwCxW)k0Ax4bsaR^qS+m3m26XO-I} zVAxrXwv)}`y?|CnMAB2e`Yur7=+`u-59Hmg27Cq5w=b?70r_>Ql@lb#U{Bg zMV;L*cePJy*z+m~eXx}!LpcZI{`*!gQKr#qEwpvtqXwO3Fghnm$>i+e&q-Ztcbg%WCn>a~D3qlt%}z9=`4*+d z6pRhMcW9TGGvF01KFU-Fdg@r^R*rd2Hf#JZRoZ$QL%hp`%92V7uu4h%DNc<2(bX1h z3t_!l8kcZw$uY`sfXjtAK3Nr+QEh0>xP$2S-R!?JPWX`ALP+H*C!3+~y&UBozKwL! zD?B=%uXH`pHhHeT)4Z!u4QLrKd;UhV07!y8&XUf($q2v!M6{WQNXqe$Y`*^}{y z(-P5mu{&zg#ne9PN_;?Y1y9E;o%CrQIDaPgarN%>^X|DWWRoH1vZA7_*JL3|k~#8b za+fJGx>h9sfUF$ty=s>e2}_=kqq=tPwgi(EUJ2;2-jmM-rpFH-B=-~pFy}%FQjka^ zzgnM`6X>~k`7x_zpJ|_W)0#df_dHuf$!iLEWdoff9%rUHR#_TysRlSSoRTS8#_4mq zTuQGql_Ek$2`8tzs}f0EO*22oiz97u)Zhs%kb-*StyWnmi^qeL+AOd_;vevR2)Am2PxLkvOzZw6uUEzLND zPK5J`kT9oIGs&Nga6C|1t}mn5$K+*xHA*&yx=sW}FRw7%Xz%5+;#Nl0ep8gO-O-on zyknM{u-4%*-AEb^p@|PEML|F%AwKFS!Wb{KhZmP8l+twD8EcJQ`6?u<3rrw5cIQqp z@u~5AMV3o7ogRPc67it?dfA%3qam{+04$Ga;McOWe4LYN&p?=z$U*w90s+9l#S&T` zHkbK2Bhd3!qRGZKqsm%*JChDE?Pmb&M&rG6&J?W=G}~7G&7ab{QZ|sA8;m8^N#~Ap z?KZG-dhdf=9C>B6==QMBt2bNVijq_&pFLA6sdWQ%tu5OG>v>?LDCd5LvExW~LduN!Q8`f0dg7cnW~r5% z^D_K05Vccrq+T|YGuySU@c#feut+=P(GDxKvh|}0*EU<4F0=lN2i6?^v9C`Qqs1Iq zV=he0FA%3Tqt4p4uKaE%9Fr?@-F=`!kgDp0V)`+YqAA(S1cEDd6lCPbj@-{TTvTwf zoX<6MQ6mec;0jhdZsZDZanhy6x*sLbn%-?sG;#;DpT@2#kqzvw%vs8aHP;=S@3Iy_ z$*lxDf(Rf3(xsp+)^(I)2g5DB9rRAN@)tg4i=!CsU%2adj ztzxXkPR#P)yv=Nr_Q&I0as8(!ur%YCaX6zY41JmmSAk$)))a0Lz(c1kklmh<%#AdkXjkbe7Mzg9#UW*(TL+A&+A+3)KMD(XX zwV;l-g!1B((8ky)Q5Y2~KsaeY;;04RSnx6DO@U6mt1qDS%E#kP5iOWDug|VNcKz{R zje2;xM?O-R`<$eLe(K(=!uBAkuD8%_iiWJwNv?)cudX8?ZBpQweAvcTqdC2tVYWz=;W#BfRXb;ObQ=O{XBfk5sLE1$HhnX| zIdbE<{n2YE(B_v=!*NbiLccX)PLCIIk#qiyx zMN(H0gfLRr&Hz%9eWegiz-^pV&+$|!w%I$xEj_5TcM5G&BtvrE^qG;uTMG#R1#3}4 z)43ZEalcP>YYa;5q2$SF)9A190>u(f3RifLzHb@$v72ec?i(kW!k)odN-(c1)mI&v z;!bj=ZCnt)+TPQVVOkzSd>7QgZL_)MNKQZ=c+cNl{sbT7=h^6ftu+@IN76YRTdpYNx%L7<2XoMG*1ZKJqi2@WOwR0_B$)2IoB2yhJ9W3) z5>n@c`$|VJB_M;&GnIpYGfyT-WW`wJO_$?*cr$X(9#LM7gWzYQrnb}fv8p9l8M0fR zb=O*IdGVe~ITDaLK`9v}L}zh(0G}nU3%8r6G{I743EfwcL#KX*!AgJAONs{tZ(F7-8hp$3lH)6UO4WYsovcteFwPf@IINQpy$oVUg-515&eVQ($fYsK^ zI?XI8s8SeKd?bfTPJNOSxFc-hnv#~8lTH$}aUU4{8Lyl_lD%nYkgKc}EWan!nB?%z zathF&sy)DBwsT*!n8%;wjPp+VNb4OKOHgi(DU_%LGNqLxlRYu-r2Kn9^V6m~)Si`> zOOXsnlF$w*ekz+z2n5zE!S<2Ryw&?;^icIz8Q{%h{6q4J7Uogo-~@#9!1B#FczGoE zD*pfm^8G^&I8qm&O3H9XLFjkuU72SbYLUT; zGRZ49{xRs;d@8qCuD6?o#Sc!38*#;DEi|FNGv|-Oyx2$NZZvxzD~(OQv|+l3igs>h z+hHq|vH|8NVrx8qreu_yu94r9_1qZos6|^dE1tEJF=cJGgar2k7_Vm^iyUf?na}3W zGx{oXZZA!FV7Odb_sw*usPu8R+t~WkV~}Jvq6s-0r@bjOIJTLu=_3|$(^|<$I;u5#<)C_I$MFdIy*4e5$MZO)URo389>Kc$2a8DG=!8O)9jYk znj#eI>$k3D2H0;5w2q}iy?J@OnL=M2J)XCP;lg;{T%L`8fitakdlFooDJ?0*lA@!I z_32`z6U6cxmPW{rNiHhdT8$3JXS$Z3V$8Q!&SmW+*eMBHUWnF)!{t(5249NeWt z@AwMA(W1X+Q*if)A{-$XnGLXml9jI+KH=W8lcj8Yc|8`J?!0-%T5*!5n{{D4r+n5{ z=FQwx7xHHOXwckRxK>;V}bcC`u_bU4uqSBj5gYU23ij&_enCzBkwxFb5&dg<$x?Ncq_H5~(yq@Z%-dF@?z@T$2S z4>uh|taz?Sm+MlFRN)0g){Q8tMr!3NWc{u$f}r}HNohmb9#zGbe6)JrJ~ai&^iA5B zQ?iPZgcO0fBN-LVm8Bh>*cU0<=y7wG>hhx@Yf4`#_5j~%&m1`>{T&(eaFSQCt@kcU zGA8>)#Dt&&jFZx}z>PNQBTfKklCNyOiYxF&Ox+_=jbCtFy?T z!4504$?>uO09BWiy&E!hWE%~NLyg0RhTTur4tqonzJ6?Yj&~;|q-46IP--o6 zdumfCXy9R{(}0vDbj@#Y!xzYyLne7H0EEc6Ttr#zEWFw|4~5Ws&$_vtV~;3wdMlo6 zsu>p7(J_5@)b#4(H2(nE!7Ep?k>o3%0&~l3?DDH0j^P$n^v=3XjgW*h;<$1$M^C=J zEdDpk-$%}PzF+k681gmc<;?L#!nA!4jfHtxRz~(! zc$ub?41QE$8!cE_Dz1;yytO~Un0~kVbI1MURp7A&=2r>10mqzZoRP9fuR+dNbw`UV zc+^shwlPnG6_+Ep#$-3qepOGDq?&ps8-!ru*2}*HuX1$v7WAFUQ-A*e5M=~(*=Lvg zXmr)1lQdjozh_GNQ$1;OiVZO!IO7UR9Flo(QGt>YPu*U7{nDe^gMZUOvOm$D^byCK z5<$Z+t@c19?Ut8;zg~j5Jotb0-`GN1*GGLkN*B&X-c|C4sJGDZq{ouMPcHcHPoZ5h zE>)$ql9F;o1t~I@bBci>Y?JP&XxSC@Kw+tPbt9C}m>(^56mDfJZoMn-@UlNtR@qCJ z9Hgjp>s?6sY>u=sE#U9otvfl{;*bv8(-9%b%%RwK-mvK%O39!z-2p5=U)sU0n1)UA5DId|H%!{j%gY!5cVZ$yy}Eqq6ZMZQz5+We>hdg&dUa+7Aatd7B*I-)G2R18uRg~{<|cf zWqdH87}Qty6^9#NDEHRu%AeU1#Sz)P&j}@IR(=&<)XUil2uYj#hlxUg`|DMjLU0_W zdG2vT%EO91`AIJlgNk1z>5W8c_+`(mkaOozDf${iSFLc}MgwWd6`O0(qHM>tew1O` z#lzXy$#?qZx^d-dDIEz~vpK!+?S~Xpmcje0t{y|_nac`$DR*8RMj(Q~KLK5s{E9i} z-rdMa^=?xM}RGb>#8Pv3AEF?UO1g1|gIRdrjnVZJY z-;u^i3ItY)nFDo5Sa}=$q4?EOqc-H3OxiEmXpa6`+ZCM~E{L15)Sy7gtsuRbPoj}6mlrhyl>Kqr z-(5?io7ig%XHu|FN-{eLc3vVSNn~?*b*v5hE82kM9Ml(qW4Hj!b7z$6jH8ooTeYU|!S8A%U*hiZH zXBovyMJHnyn*m0%YKA746Py#h9e^@qp|-uF)|iSmp}Mw*6OPLth^-(l&U@B(tj&BU z{Nl0muTu|I}a+!=3b7N_^z#; zJ;QDe-!7K;&D!H8&l$w!DQyJ-DIp`6j--^Roy}(P%6*TVVqR~$KEtDL+DA_++~l_< zzWa+`=8%!hwPfwe3Wz(LsE+jhD8Z{7{E1FA62IvUa8-iqAM#S1WPKXgc&jDAg#ti6 zS-{46jMU_Uc{E@Z+158*F=5rEH;XLTs(pAR8+%#bC&--FEU{bBugOZ8UQNGN z+a;9Aiu(rlzjda*kCCB4PVdOyjbcATturYVPt($I)k0D(xPy2*>G`_<0MlrvNgS$ zWQQS5eWzEmt-cDwr8tn)qjeLm{zsbSp6sW2-u2ZLA?%&` z5S{t*dUUS5UPDXr+Bv5M%dMD(r{E5{vrSt~+f3%vrKP7@SRkYxq#mCN>xY#G?B|{a zwo2jjAs+?^vv)~BLg&!Ail=bL5{HaUHg6I|(?Ax?oqIH_m>+&^x#I4k{T!z_L z9P0O=ZZYpQ%P%FhtsBP{#Py|7kR%5XfIcyJSn0-(yiZgj1@N~GWQLkka)5&_;{uK?_?KP%tEEOfk90@PHdIYDg z)ckoz<+uBd^2d$}hfi$bduI%FZP5sNA~~CMf|7p7_t&iQL3VhN$0<7nt`cg=ZMd~E zvX;*Lqhs*J4>VDt!6r>wI4gQ>23&}1ZKR;D#BgCJ9{SE+L{^GkG@oXTqPS5a<2E!n zEjK03PI5;?A0t>#Hk)R#@%FZEx?_bi;ExLE10}PZsDanYxt2)2j+w?$Tv@SOq}g=c zoiHIK9w|;Ux8IXflO^;9%fYZhEpd9gVmaxmkJGWld6O@u1F^TGH z)z8=3YBY{j#~`IaRi-4W*`8MVH0>X$?{cESZhU}VQid?C@$dOoQc253u>51QNYwh$ z<8F1NyK_v2+iWk84bo~7*2da>8wUgRo19Ltt~`mUL+z`R3OT}aj-FK#!tbzIVv8=T z;Pi`;@nmXNW3<>f_CWd4P~o#xI7_5wx0m=)p+j-C7OWDVWnoK0WN-4QrziNL;}n&% z9@n0gT3XdEOick}MgZgz9T`#giqbwLr~82M?xhTq5AC z2UOmq;sI1>EMe5Jv4G$nbxBfS_g zH~G)AT+@y1XrnTstwaFS4jdn0l=x(fH#;CyW5&FI)P zjmt|%(}{sSMm(0jt4*MNCOpr2;>@x+m2q;i5S?B;aDT zp9#V;dLKIOmA_|=6t6|ghIf=iax9rjQk40@IoMa5=VEzc;}hHc zFUVdr)a1(svAZ*NdQFyM{3H}}vgUF#T)rj;fholF{{T_*BjnyG_2|vwG`KTS;V+nj zg(wfJUc;9-+dgSy_~l4@evFppWh>`PfGC_}tvpYZOtVLXiAZe7Vtu;rYK*kG1#Q2T z4D%Ey9&d)#j2&8R>CY7?#*wA#jc;<-H^0jFIYH-L2tv7jsOgX^nMS1O>TmmTkD~SH z`0RE#?WLV<#FqVi3BWnsNFyJnxjg&$S_rl1`b9DUbn^{>8LyFgJyh)^D{m3f$txdM zY|(#WcKRUhvXsPy7Ktb{lQmH(bDlmsi&@;#Y|yXHb!&7Id)9BUpD?cFD<^vW4;)S( z)H7QvGNOkGz|L#3C(dP;C!#7uJZA!(7<5Ov+K_O1P+I#QAd*IQ+w@j1qpHP~)8cmc zQcKu_r(g)*G?6U|B&01NJpumOx6ry{8K)fN3}Bk5D<)556vBDVFimvC%402t;P`Uz) zUb#C}nZCtRayKL8QqY8#*I|!&sz4-vwwN}NDHj1d-awS5Bs~!Hv)Ik;^$- zvg;2|MnVTL1lOXm!YIP*kY>pf8@4`GJR|fp!>ZF481U2btlEmz6=h0wh7aWlD=i}> z<({9$HR9&hNmtuF98d6H;42n*eBcoENym# z$mviJGM@zXtmkXcC1gYK(Hs?)Ps+B8wQUm74La)EAf+vmYgHu1pxFkkN{EgXINE^e zLrTpSHu@OL*U-_pUoI$6wqM1qj;)&F+~~`ak~{8cPa8sb+UTWfjbm*5uRE4P4rIHH z{{W0@qaG&WnM!&Mh(+>A4G0&Okk@WYw958fAI*QdDZ~3x0{q zPK}g4kD`lF)sHIySP8=f! zv7SC=icUQmzL?@EN>Y;deD$trW8!Tbtr|6>Tr(vpL3=&=)>4VAW?vJi*?#9JsbfB{ z<_>?1YnD)?Z?8qF(R^S5g^!(cv??rYY6$60>mL2-CNR$5p2vNw>2zu=jl_ozLHF2b<0+=TPY3>m84?Wo{A;*{M+v!bB)#q>8^-lA+sI6$Z6S+ z9D+*E<6ZGoj#+jZ-12kCk&;a*l>|>WX>rE6kABt8@}%hLju!SXb4OjTt`;q+N?S&J zSKK_PY+#y2|999A5OKCfxWE7Ls?mA|r zx#V@|sJwVr+d6+p@J`2QOK)7^w6!ad#dD`BDo-)T!z%afTSE$o&y&fN^vxBt!(<_* z83;>fDM}Nu_ib9yfl1vsmgaqbl^8 ziE?t?Zn-vsn6X|`3Y$A6NlsCWcgXqHSy$y|m|CMl*6K_@N9S9cA*Ks97^UZ3Q3y^D zf^tUq&U#kOR8ldEyp5dez-g}PoeRXsme{VbYmEt~m|9igDNckt%d!sX!ayna_stWH zLw$}iyosYb(3iNnON*Ad@aD4hz2`Yg$WicC6s!}I)O8s?Lb>s-F5hQq;J@CMsK#;b4VjKqX}Pa-0+8k1FYLO!MO{SF)z&mu?l!Qe;3(sO>tHwuH8x zRJIZjaC(xE0mr+{R4CMoa#C6^Nt6=}wxK+QG?H=P;aN{{ljTI4Wn)oST4Y<+=~7Cj zNK>vX9&o2r0780g@5L%s4YZ7hjv6aYYl~yHE2B*|T6M?cy&Qcq9x6CF$4&S5ROFuq z`3{$T;Ua@8mI4G~>D1JoTM3AJZ-BCSxFTu^DM@U^u}cC+i*i zR*~bAQZuIxv}9VFiQFW!&u!gNq%}^GP{D0eV5^k&9@xm=bJnf+vTyO|ODg{WxP-rP zyV3ePZoZvv)2%Nf!)iHGyLb0iZ^g@cMJ%wbvY$87>xUKyYmK8c-Ol%MlAcr-6XBo| zdTs8lVc}$dyGBy-F|M{#wHFb6A-KASVCk(Uoj-4o14T_XQne(1)*a1j@c8(h&D$n9 za?ST%q zj|pG^0yFlFdCAW-ws-K3D0QPlzv@jJ=P|E~3%vMMz=1W0yVr&MTt^6&shbJdD4JgnBf;Md(_0SY2*0?lF(3 z2RWH*8B?Ggl6~Ilc^?|S%;9x$H{rp!GD2m-(~)7av;`rw4nj}yg<$#ijZ~A@ zNQ`l7@hqoRQ)(+gDLHlwD?EvkgxQTCL~Tk^)~$yxy18=ZQH%RJ zvEa6wGCnD4Yg`%9BwHh;N^2==Z>l`&n-nLP_dOo;B@Z4o9?omj_m}3+c52;HopD(p z_V`z~f;?cNj~C0xrIVZNrp%nQOiHk!%y$*tjcD>SN%FJNLY!GyUI)I3=&V~-7DLI5 z;c=IJvEG~)C9*S4E2a`W*Q8EE&M2>!-&*lWXybBndo@iN9$ergK$z)$q0P&UvE^9G zqV{TbsZa|GR?~no&)8$yae74TDkws|d+t#GFTwPp?tL{4L)s?8IYY(W~n`oWg)lJ+ff@&h_549 z<5Eu9)t*psNh59aV&QyUMXJ?()or1RU9BE6l;_n_yM7dA%Ao_E5Sx-wLY|O(V~MCQ z59!S!0xi*$TQ0V69LC#Y;aK?iB`?lrW^9qe_(!t{Ky}F>4y8aVa!Bi4&8VY=T-f$h zgf@;&KoXI#^R9HSXH1%cqCyRc+mv4ww@`;vGsrsEK1}Nzsq}aF{u9d!Ph{n(pUJSq zDcr$C=adhXb7hywE>S%k5dNPZ$1=ex?FKYtu-_;vMgn|?yw@~v%53e)+Y>{B;=B3Cygfbi) z6SpfNZ<7wqKY1L012 zTbC4bLjq9b!_B>0t?d+{-g#qWqz#2qjHN{WG3-tq#Zj!LLk=x3zVFf~b_S+!Q8q6OfZzWGpEM#vSN=2 zk1w`|r@@aSz)+B+^C*>d9(A4>s7b5Qzn6{W#+_`SUfPmT>S;oXvP!XCYH7;PJ~-r+ z7Dz3K+D(aw=1Z+Pf!h_%rOQ7T(bp&__`Lm~jb9y?F_)zBl_cXT=ml!=D5jCmA0f&9 zL%8vum31t#jPtB4d&MTyVQjReJi0`lqiv@nA>=5J2iRXQ-#%5Bj@s<6H7gxytB6BI z49r@dakAQ&>=W;$kvPk(4;zf(SHGeB7LdzDeB1LCZBq8hM#1R25&MT0wA_Yyl3KYo ztoebt{Q%bo>JN@4nZ6Zj(e&)CZl!F1J~i?3+C6BlEQ5Yms5atpo%gA3&0@D?G?~H1 zcON<~i%6{AK9FQ>nwIRM3Q7xjQQoG8e8rb(x;#!{NFBFrRr*XEVtk%#^T^$dT(eG2 z#v9-4&+4r?$L!{&#u6`B-Glgv2lMvi%$h4silFDxlg{U zlv?bU7kv@)dGev*s~IDqt#LF=qR2^!QdB|a{{Y&$VC=&pXQETPgll#_*H8+EMh8>G@7G=~NW zLXU2n^{9OVOmddpBb>CnXY+bgHjq;lVYj?wbF{EIhH?(nHmDMIc`dp&@Rm;9L88!8 z97kp69!gTm@>B=aK6Ey_3Vx2L;0A$`@sB-riEk}fAc*Qe*8v|tXbD1T*qTgcq`c69j?i+5<%Ez6kOX$A~|@o8VGy_`8_lKfx( z4kdaQzf?3MbeUzY^xg{SOn{-$vx z1j3R2$zQ6u@_CU@NTiq9NS&-CE_|O36qO{rzET-c1alq1#c?@DES$d1=t(H0V(>K- z)wnsW@<;v3zg20E4)hYq8tk$$d641&^%)=RmHMl`9yH{-{{Yd<@&aC1x8LKH{%yPwQ7EE4(-YwStJ%7#5% z&*mC$$CuE2i|i{AF(I{<8~`mOo-s+EUEE$a$JQ=Mq4M_wx;BAJf;+ z-emoitCtU?J(3{4f9}m^ll14>Ljb%$L%)t>y_GAk3@&bx6AD&5gG&8X#V;2uU2$hb ze1yG}%f|?>Y6lj{N6QSW^;N7hj@((N^-y|jrrda4t752@t#e5K0I*-`s=EEdc_BWT zlxjU8s>Q})(QlkmUs(zbD1teT2sroGb~(XCZ5;U_J9;aQjazFa2H!Yx`LeIoP0thU zqJOxTLpQY!qd~)wBmwV2t4RD$rigB2WbIdT$19AuJAFf45W^R=%%_q>@--XsH*z!B z{z0t%8tInuH`ou%FOU%#vpCvLwcAY1O+ig1B!b z0o0PO4D2#9+P6~HnV%co4ArGpoDa$G{{XW;s=5@c!NguRm~ON^rSx7C&D<# zFsYN)jUtGKZE}(@V88y!TYieSBuz3p^8#OlpddfLPohx%%2tHYncuB)`P58DvANn7eFj_30YZltKrnIdeiwt{_K&*mDQNtaBDof+oxLoNf1{Zm>+rc1Pj zG4FEi?%)N04tg3T6v<7N%NDkhk~vhoZN3d-ENjuKlQipZ5Tv^y$8h3`oKXY=xF)$J z53`~(*>1J*23IcVd>`Z*=bj{O8U2$@aSmTE)Oh~@sB1Tkdn=H)_kAr%-4A~>?MKFj zpYSq&TT3A2FaH2A(ea@?yb9z-OKq~RAu=3!ZWbL@RCnbkHKn2{mQ5jQnI*vDU_QO}!)CdBjH(N> zug1dW?u}mEqOMY+iBcgv)MSy8TRg=$IU{bHevw{ua;ZMgP2+HlQL$(bN4YnZeo?;L zDHGlkcxe81=Myc{5vT&5Ka#oddzB2ohRmJd+)7Fww$R zw%PzI3Q_Hlah#A2#|E}ijy)XQXOn2=NuRn4aeCylA45xWBvmO-cnBpyo?rrx=Jihf zJ*w3v`ZIB@ny&sK??briL07b2cj@8B|g(hTiD;BDQ#Zza0ce0dZufSX{1)T;vTy2`Rk-KrRzf3No~*-&X<%_ z5>k_~+zfm6#%ePw-=eTR@%B~tkHm(e`X@OyRF$e#&fMLxD{+#b9&jl*BN)z7K=Ro3 ztFCETEBkp{`Z6CzOYPwL=L&2ytGKmU1P&eFrr+-lupSXEo8ZE zbd0X4{h8jf()ZXmDdxf(@$Ir!wRjF0C;@JB0tp!-D@ek(^Xpu5$qQVcXMQD<{?l{x zb@Y&lZiaLp6C83sDGW2?H?on_mpwK(6|$0jbY(nJOP5UQXXCjckn}+Bt2%_1N=d@I z=kcqi&Q&D3DzWVviX{09g&a2)ONuH1Dl0xJHWxEpT zE7X#qDFKz>s~IPh^%x^yD+#G3aYtS*4b+*OY7Jv*)$d&+Y1y7D@l*?~G&xF2)r18O zyMT7AX6IbJGk8ZIE-yv}#k(VsMb9TEXZs(>+MVXNpb_qq=yP zkdl+q_Hs6&(OQND!efzOzafU5!F32FAfL0Gb@x}$W0GlKXUt}eO{nc5oJ}XKq@_&6 zv(8XMWn-nb*BZ}-K# z?uw3wTvF7M#4v!f)D4C|`)FCSEhbmTjqQOGfHqq!!!}KgxOr%JL2-h)72NYuo?M+U zQODXWx^GC`9e35CTO>?KJcU9zZKMxzJ!?OUB=(W2oFn_0WSOLyw#IUO?&!Et+E_}G zjPqc280ktrER(#9(q2|NPkEnqry^ibanp#qGafCF40&p+zVMjDoRO8k2hb1aAb>=?Cpelq6pi});|hgliAku{7UG@JtM90^cDQsZIZolOKS@l&nYzgddS*(qqSvk z8k<`%5o?ijl$FS3#?z0@IIi`UIMpV3zC>O}bVlAR%rfsd3QAIOk~-G-v${DYQ*nIQ}S#nJ_6~4FXS3jcY~&+eCMRo+8^j9GXqq8;gtCt!VkY zt%lawXE73edZ$^r7e!* z?yFyx*)K&Z>2_Oc$mS#rWYtDCLzNJZCFfJ(kWVqm1Xagf678WCS*8RBSs44O9%!db z)p*l!?KjAvvuzz;?o9HddT0?3%8Bd?zSmnzYJ}a|K zINaN>L!EoYa3MLTG)PoCe;`BaZ({1Pf`0nX9v*V#Gp1RV81aW@Oxboyl$0p*XEoU5 zk;apo7alqk7Nn?=?175O$vqoG8;iCKmf!IbqLnR5JpyV|Nfk9NT^E~GuJqhSWJG|r zlqD4lJNedziEPYP`R8t~L3NM5ZN&3HVt_fkB9YyH&v3XF*8ph`(Q$^uAq=a6Q$mw5Y-# zoSP=>P$gaLbD0Y$OH1bEQ0@NWv7SYTBwIJbhJHpF#`+*+v+B|k+S?^4P#nN@uJt7) zXOEH(9I2KmGvUF!MUfpuq&6~DxX+bg#m+5A>-l4fagseL$&=vAby*;|2=e=>#V9ot zWtq!0%=VRQo_S9?n^{jNz|Qn}GN^}#9#f*sxUI9}F#3u@M_z1aZ+&yAH%%Qs8d7nQ zzIr7vwm5;MP(76y3sRNK^{~>;E6e>(Uxbc~5vWo0UAaUw6^s%q38-0W>|AbV1xwwIHNtV^Yc?B_YJN5zyNMZ?MZeuqvoXc14N8q zjkd4SBJB9b8Y0}~2N=$J)mW%S#!{iU&S}^*Ma+a02ugFF;b<% z>svvX%~;HWqD~Kxt-3jBy`CA)6}#zftwe2(xTZ^$4T`<26TWLijPAe(e2OSn>=KekzLIEk3Q%$|PWw?|M1x5@mLJ825XLD=t7-7pqO9JtOhF;E~<_8mgIg%8Gxv^CgJ_CUh7s^hR8LwI`*@z1={jwK$6l#y$R zs@(tuyN|xBjT!Prs5Mes`p;wUuI1!I*}~QIcr~O7YAgR`DsaWxcyLzSM zV`S4LZMvzI&W@7ueW#E*`^9M-ux&dBbi%i)nONQN^Qc)M{gtp+so5XHr{_)1A7dJ? zR58tf`hInr%MPrhAm*ZAjQGhveJ_?P*;F-h{{R(#!X(uE(Fz*BbB^b=w&t;vlXgbe|CVDorks&~mPHB8-cj=ak74MvdDJnaP&Pb$aI%@mLaE7HPVDbt6aIB=X%Zq%F z(meG#MPc4P&ZQ!X<<1~hN|T-HmW1|JB(Rp$r6>-yuIP%Pt;R|c zFgtaoft6dF)QpVQ$yUtUZ%D37l2)Pt>r1hvLNVmL$;uXae6v8w_@5O>|{De-%%`Rr6x%;f0D8=>b`ZK#)?v7V7hmf~xx{90y7J=-?c{ zZtCjJ?i2UbC?Rree8k5NGOzvVIHWaWrlu_pAc9ANwadCoDpE*CH%~q5 zEV(!>8e_)gBYNSUgL-1nmfO=GuX!%VTUhgPUt=!MTu=~ z>(p@EXyCl^74=h$C}+Yo-)m*C}~2+eb_?b%5H zI`=468A^uu%C{qYZC&Xp_UQ9}Yr3{^mY~)=MAa9kW$MeMi?hI&TubkjrLNzdg#CPd z_^l(08dn_)l<#4qa9>^A<27)46ln0IM?|HqS0)ssrDK@|NJ`3+oDGP`$jxmjs4Z=i ziVH0N04GT4??a9a-ZUAyYHeZ|ipnH3xatofVPQ!g7)pU7esi%qZJbs)TFBF0gpc5xf#hB>rmgMRwVE8F?jr6y>SPH zSKSY8wHdQ5(a`LrCBy~CRziUZQNoE<3CS2va1I7n8;<%K{AXyzb+)a!-FO`Rtf{0# zw9aNi8+m-Lq;oAifh6Y%Ck0sRL^Y8`n@J}JBsSm{rP3Ns^*-S9F{NIk#~!GqzDgQO zl6kP4`)esU2^}kJvXoU;j%;|;?|p2L)_SGc`sL}i<$AD?(iW!MNJvU~N`gooK?z24 zzDE1k8;fy#*R#`vlX2no{{XTZQ44(8AWut5Wz{9vu8(C{D)!KzGlgyE-nr70U*OKz z$#7pH(=0ku(qD)?A`QlacsGkMLQrGNSyzC0h6*$8$ouQB4BYE5uC-C4YSN3#mE=(#*il_OEcw@;F(t^m-IgPCs>l3sB486bp%fRH?^ojj15 zOMm|W2dOWPemjic6H|%k+_=_gQBegcb)+fxlH*}1eeP|&l5v81XScq)Cgm?@jf*5B zC+wEH@U8`ePQM|YB_34Pm*YrVjE0M<#u9)NutG*Y@k=D+pctVU=BuR6anqat^^I2C zcyWH2r_7_soRk214EH^&I6RpZwsq#shZ^G)2B^F0&JSyER6Z{yBYz+1%wMW9^*F`*vT^jzMUXHRAn>MXVlH!7} zr-2C1l^+_iIojxbDceML({Z@##38hEa;Zy5#!U|#Y)d2QA)JjY7gOlQp8_+y>yUU!`mDKkK+lL5pGN(=g zK-(s|bNK%Nk2su=%A+?I(R+7|dSUgJ6*4n%W2lUilCnG38^I*Bwst~Ly|S-%?$t%FNv5G)He6k#X8ZHp2d7d)B-`HpiBkb-e7nrKu{eCtey@|&baw* zG2)RT&YYB(EZ*)8Aq+gN)0`;xs&Y|$QG!n^rKZEV*T z6rGZ8L~Zz}OG-+dKVWsPbvGGo^d*T-I_#Bk5j4~`T$Iy%?u?#ck`I-0+wvs%v#~}# z9yKYh#jX0~xeiBV){>T*R!Y6u+M<3J8<)0ikM%_^F=~<@-ri#9mSrK*Gxbg|F=QS zk$Bn`9vWOco0X1&v~q-1GFCj3mB-MtEjHAm^w;^7pSE+Fn{8A=NnOp8 zQ|7kxcGA)k+D~6+bMLI;o$P$l=!TyfT$vs-Ef+p z09QkLFiO}L=FO%9Y;)oF$1wx4YYXQivKJVQEG@}(z{(FQ2>QdWYdp;*XGRFhQlwZd zB2}v8CI_r7!ux#3D#qXLYo1(lK~L!Ef|rkx!9K|Qyp_vJIaq15=L9FIK4!ZyE+?Jj z&Ck%I@q@O8GvSbA-I5ZV>MXD;}GF&G) zrurIoK{m?Vnx@t=g=Er5Y=*p{ww9>w9-Go`ivIuy%=@#6B;j9ueukOyP9=HFsYH&I zqGY&&GmnKk6I3SY2}wOgT6V~K9o$xhlabP<9hE9&Lg?C5qm78Gmtu>eD+%Yo+cf4l?ybi>KdUMW{|i$6eOiY4XcaE#-^>EemvUf z-Lw=7{-p5J4Yxc#oYmpy#|S;1ra8&3&CgG8W_*^LRD`Ig<0RKA+o+=Fni11xiDKYf zHqw>7ADLM0E22IwNgS`rOHnSit`6H;-_(g6}zuw{;cKHz*10Th$ zzoLa1e9~_0$u&0%+g0k|>KFr_ORDMSqgcFdFOSjH8QfDKPY$HE=h365N|``hhwNxO zksBpnbw|YeA?5TVaMCv@jj2g1&MIXBd6L?ty+ai%G1k4jjc`jHKgcoUi$-fM>8x9H z;padH-&)2oW!n{vsWn3&bGW?w$)>R@Da%_#&YsnJl~?O}6ynNEwn5*wIHuvnS|PO8 zLc>{K*lZP*=fCQs;lE{mKSV{tiMRGn0+q0>V~0ZgR_Luw<3-v#q&&3@8i{zV^lKcE zTA_pdf11d_c}HC$XhSXjmm(F^WKYkPK(#PQ)LWbDU&vQ$zMXis?oH z+Xk8r$;fXUf;-en4KiJlR5Axzg1~vTlaP}@0?JmA%%QiH0H0Q`XasK)tmH)4ue%>7;1Vi?_31 zw(y69u?us=7;{#Aw?y52e6x2{jpI+jwRNkBZ~btD3I_K%io zToY<2Zd-C?deeJN<(rj`;^7eGtHuZi*kL@uSWf*j`ZMQ7NN{Rv(RgRcJa5?Q4yx1k zT}2J8Ee$b6y$TM>aUiYti6KhvIYtL4$7APOwJApB?7~$UabAnXhWy>~;`-)CN+l@( z64(VwJft1GigEDA-CUU<<5YL}`4p42=(Vra%SnvLYC{s(YbbriC?0H__vQO1%Ov}& z$(wwem8xgcVT>L$qfXK>4OMBmTV6ydcP6|C@Km;y&X7sm5<24|y-yx+$hk#ycphdf zm>&tW)A}j0t+V_`61UUrs{jMne%0FnODv!p!=y&l=(9=T4h)g&7YnL*$P7f&s`M6SY*^inL{gDN3KRseM8(0rX65;FYtya-4(T=UllnsV5V^ABik& zNmW?iPFSo~OKO!0BWj#fr733s@7I373}&^#N(!0J<*7?2*tc?~AcJ_NtY2lGGb5+Ej%rsshg{yZosy?I$Vp9KLp= zi?O4+?ezm~xw87*3c>d9pKv0pm99}DON_WkaVuWF#8gCz%P`d)vXm*Vs?Pq=?^tk@ z+11Y;7}v8sx$39myr<{gR^bGcr3&eq>y8Cfk;6YKN$y5_ebf$IomYpqwavOsc7#>q;Ql^iJJwOpMd7j$fTPQ#4x8*!(kHiTh2g>w$Sjc_O_wtAA2$BkLn97ksL{pj3k6D7$_#~#W@UAM(7 zsU(d2X(u{o%f2StWm~Qi?g?eaRHqcI{7!LRh8fyO<%sp z9*K8#4ugUcX-QhqSlf)YN~Z5AuvXlXl&Ee2s8CO{S-09_IX6hoe)*E1I_9k^B3TrW z!Rr|p=@-(RtQtqzFJg6Ues!`U=?!@E9TkZnrCp|DJwgraQYYT8BgeT2T+dBb=F8sf{F zl&S}2EDo++9QDO5e+N-t9D3BkP{IjHKeb zrAIWI$n1)o(!%+b-@lb>2crqbn2SnzD*$c>Q9z3>k+{XST-v=&wkAs~lY}^&rAn!u z)h1M9$X8P8Ihw}or@RzLVHqi9p@gUItWx;a`#NHtN3MrjPeold1<97&LgB@5keLo3 z@?$v9zpYiMM%fu;+oVojuPe}TW$62Crsa6c_MS(bXa4|M*>Q@+-)yDDlEihb$!b!Z zS@uBq)k-d18e^Kq{{SLhDy2ezu-p}go*d!R)C%UBQUOY)zJ&oJdIBM<;BOYjybO;+(lMPHSikA+H5x z&^Zd0Z~^#MR@*jF)r3>dHE&!NUkP)UD=8ae%Qc#f&yzZyR=^92Ys~*RKrrA}2+V&*f*)B+1K|MU_SlmXlwE|m0nNtUw zw$yVMA7o?~wnjBr9ELOvk54D~9SLil;vQ`yV z)hBQ^>qVjQ8A)ry7{yw4XEZ`gmZtfVN$4x0DCLtqak>s;m3ib;#Im5ei(NQjnQrLGJ=2C$>=M^zxYy%7w^xyHTHn~3BWaej8oX4P#e-HbkQdR8`1&75>INHpe54T<>kTa+Mz8PfLl-*DesSs zCw%~t!QTUM-_E2%bR}LYcF77Gewx+vQtV7LNy)(5Iqqm~gglDbD;&Lu=qoq2D>@T_ zd?>l=S&Y24R+ylT@%5{N%+9f@JA7<*uhHM!GT|Hx6c$@dG=h)^)fMGK47`VO=-(!E zml$+yHhm<@5}%<1?yo`^VGfbV=Gke5r6TnpRM`1cr(ont4K*DI&xR?O$(8Hng^oq# z1E-ZkcD5HoOYMoLl%dEfe4Hvy(Ue(Do226{N9YsR%Dm@=-i;PUy^NKk;*tk|G4QRU ziI3%Dt1gj<-Rcs910q9br}2ev3{A-W^{iwmMZU^a%Ea||U+Z+D?g@g5#RMJ}|-JVnP(Xeq}I!ZAevI2aofPLR>N846@b=4Tg zj(Is)du_ttUBaAJ2fl}nEJ|#*+ZQ450@R~Z7$nEZ`xTu8ID^bO_O0WtjM#T{s$EK! zTlj54n?b~_-1O>ODghY9X&I8yMZepFAx9hbtNut%ofURae0*|rJ!$^{CaLU~fP|L- z_zIP_M2jptd2|j@w@PiKfh#9%T3ktZ1t8$<(zA0Ki9B>kX?QKkwJk98?*akEs=E-F>Z5>R(9wh!}#a^-Z5 z;kJvVnmSmH6rs5l4cVg5;&i5v+LhA-ZRriOJkSO|+ZEFT zCRb#V;)%^^MBeObSx$1S?L{E5B_sjnDrBf>vAXlr_M}o0bp0tCY)|7&0}k4^<`kL{ zF>Ze<0Gb}qUdwf@CE$^agNnvZjU%^AoG=>==a+L?ay8>bT*%Kh2un&h_f^>vO%d^8 zTqesyEV89!;QOi0ag1%SP?X&xdEs9Ut~V(Rp_r<9&_c>V#y}&_ZnfoQ@;S?lPg4(z z!aU}6j|F&g%S}eTTwyknO1T>&B?NR>&vWzZN)c{WUTl$3;*I?dDV79eGr0gL9k=qX z=*NmYxyeb0O=1+3tqG8nsVWKtsX&sGobA7CeEQQRIx5$Qc0US37yWF6LQ;c^VJ;(? z10e6;lw@|=rcqK<%Z!@ZMtQ9Gqrl!Bw7Beex2fSEwGAsP3OM@3IRlrfi8~xpP>OXF zTxB_K&LHF8q~5FI-N0KE<84~wHd7W9QHB~>z$IOlMlcEJ4n=fh#s2_vCV3Qf60yMU z9$z?{tI=n*w&DU(r=NHOmV!q&Fjr*)oaZCUy=#&2R$&FnnqL+igLq3?8&B#bT;f<` zI@=3!Qos&#kfPdi%AwbDz6r)_o-M7jrN)&rpWH(>o2P*#DSA78!CDU>SlH(yIU57s zx}*6<(aR-L*qoT}H6f|qrW%U!l;RWtI8Jg>55Ys|XG#rwo ztNlo=Z3ZpQ(QUd~90e|wt@1JKEzB$=k>3KZ#^sH*FIqGGLnJdOxIXv)0Ft$9v0Qas z#k*o3ZRM}SLJHD3uyCB`uET%2x?I*hoDs(I>*(*^4B0IFH{cZc`gxT+;=xLAo!@ky z2|4!_AC^sJa-V*}TvV&*v1!dcW^;;D6LXxo_ekyu4nCz4842jyVC~D5V`{j@D@em6 zr6ij+tBWZ~X-p7Mm4V5Ol_=u}@uiYdjd30rLUyJ{K(x+-BIxYPgVGtA;9D#x0Epul zAsF9txy@8taoA*0i&R4DS1tC&5*t^EHgPCrj^OuE?}1#oam6LX$0TdB6TaqwK7baQ7BcvlYXF-}8$#azHoF=c$gN>@aY-Br_vD_ZnpmKU=Fx;rw* zc$sUt47&-^!>2g`L*6UBMM+#vM>d^EjvArp?xj(tax7#5Ho&9ejP)cxnZt1GEWKeN z*9?hryhVY~Q;rBlQbbEU=IxO4wQQ*w4Xs!^b*&aSqGc&bZILUNDpBO+Qq-fc>zb`1 zNo#(UxUC40HYLp~xt~}_6fFRCDX3mVY~Ef3)NPP=jvs1hje64zIO7}SCn{Wq;xf?-aO_Ch zr;ICRY^Xz#1A4x(sV=H&8!X%5BOoOs016V|t?icElj9QOp>*}8TPk_P zGVEx;t@Rah6%FHaZ2 zPani_{N`9#bTe#JiHHg)PbzWO6~#2%>L;&>sAAAMC5Q3gy7MZJTSftcxCeWN#sQSq_Xw5dP>v)ld6Pm7z5 zK8<|;02SoP-65M=LPN`2cG(G(w$HQ^<>y;JDMehgaxc@RDONXOi)Fc?xeNx&Xyhp) z8_^b|t$QOZTpt-KVk+?*Yrt&R)II{JR4(j-teCT*zS5zwXl?*NQBfWYR@FDJIDa+aA`JL zR#h&y=>@~g_lPo1Gf~Oil%q$@W?pSLDjh5IHhijRS=nrak+9o7RFoLoOs`#~HG)&u zdfpMXVUl!;ZPrf8AlF()D=W7hzMOWjI1&TCE-FOtyiJI6UE zeY07(nkiW)8DO}a91wS`XBLr3kI>&T&e-;iXVM4Q@i9)>9kEk;4T!xQ?m+5(>aa|P zxHJJH6|@HWBT~;X#`|qr**%UD#s>agRUyztH_Cy4P6jY(*a#?coNt4+Py75TiHr0j zk82xMdNZnGs2Dr^Dn>eKIP2x*Nw6NW-!gu!3<==Q236%)+cW{@1~cD1X#m006sX_~ z4EyK+jkB2uBf5q@bxv9udj$*JdYt_ zkMe7a6UhGngXvcXctvi~w%GCG#7at10ouH{W0rYypGQpQqPRrgES478LPsVmxkW7_ zoyfMsw;>4`6{>-oWSdb^2TIXKiE;t-go8?28g@m<-#D&$%8Nx#TPbqj{y)yE@vk!^ z?r;2^anw;E78+8V;yypPg6AiBN2A=8Aj_cqiYrA0iF~PUWSYM9By(A7#~! zp8DE3bd049u?Tu`X?H#u8~Ij?B7Vr=S*^Br8c6ni)oNF=Wf5r*h*k<~Si43oG+G6* zCNaq08&p|IeU)3)u?R}kM*dZ#Nog47wQMCzLTjS*W$dRh1!`JxoRj^u?a_RaW9ZC0 z($b`klr0&#CSSDMUa;D7j=ODH%&7Ef+G^CCjH7d0@@GU>*>hc;hgjVhQb%gfl^Qsz zA!kQzq^Sx>#Zr}-$rL-}BzTG`NF94tv1V-$EZQ7?LR&z|Cu+AkLPp8Ltt{xfKrS{x zG8*6gVO*JIqij*xF8hA19|;`>DV5SG7wh7X6cnrh=T@R*X0mOCBjFxu&)@D1t%u zcf|yc;XBIU_|gLNV|ge@Dm8{gTzf6n_t{v<#!Yjxsx34tAq~0gpyQirhUnER(RR@K zN;9f$?+9f_Cu;KiuOZbQ$AjUg`7^ONGoqox(zmOS@Ohn6R`#C9vQ(ubB`3HFP#@|V z)5FL3IX>Bs>REp!jvXURX>Hgew-K}lR@prKfDwR62OYNC;48KeQD>QxBWa8;Tt>Is zED~=Ci71_wX|YsCpR z`Z8@nsMT^`JY>3nR8pe1N}PLb%9MKbHKb$cnMwK_X}vjf)b|ux<2R2D9M7pE0jBaY zMmnAPQneMygHBpqn@+RVk+@@~k)iaZv6#0BaEN|G4X74Mf>QHJQogc@N47yD>Vb?` zI$tcgdOB5NjaJMZ>%GP3ijtR9%9f(riENM-H{9>JB%hJ4wG|y4%2JcEB0`ZOQ}U!G z;+9(Kzi8}{fKP7KY0@*Dw_>OvsHt_u7kot$;toQR3F|{bi%YTGc&nKFL^jggQEa4m zXy;R#bo;q_{AwW5yEVzW{{RM+!}i%-gHS28INR(P(iDNR`4SvTfzMBAO^o~f^~vNv z$}H&dzig1-TdZDgwrw;eHqsHy65s%>tn(D4o~i*OZ!Fe$emVDU!X6Y7J z?6d6_M&TGsWryL%`eLn=LPiz_dJ&q8Sw3C9!^!dg0H>3TdRiTDp4ymN#w)XmnQ19s zI+lPrLXbxP0Dk`fbu9B-8b(+#yR*BvFzgLi!FcwFB`&)KrA2TZ!WNQnNckG2`9{%{ z>NzN*O4Qe#E2^YQ)eSQ9Z3m*MD#*)W!l0!0^WU~>C6=ZB3zi4PQLkw(GHHv1c!^r% zu;SFF(1(%&lmN*4_a7?NWmmJE;FV}|sraI+dK_XLFyw~_N(#@g+I-3H@Trz`x*RZH zW^XH6pw9KnnN*9Evap4X%PgfQBqV)M26y+?T<>hzLC2zvcDv8%y^D^S4%g#p|VT`M{`z9vVng%{Mg5SYtQJ@MAG zS)39fyY~VJmgU+e?H3g092P zrg?9n#~FWbK*$kdxFb5W7Wvhb{=c;Y?dS?URsu5uElTuJZ|pWeYcefw6J zBBbqhZ{#(CJRe6pNkU$fIo>KD?oE16@mf5HesbB-JUP>lm#3pRu0*V)ZJO|Wyp2ys z*Z!S}I4)fp&Yt1)Nzi>_N?T8~IWdAyxQfpj;<-qEUVc*e@$^q$xHApNQOaS4(%{2^ zJr(6%jwv>_kDbocXLn^DU!%3DEV%rOb~nn@r0zy5rDbU3akpkg#I6oTv`0+4TvE_0 zz(+3X->qD8Z(?}0qP3=Uu9mgTWqP_(%zYr|Mld;ZRVbIiO zrL`3RH0y^P%JZzGvL(rl$$r#qdb3#ReJ5gD_WN^grGdr}01#z{+PMjg6s&U<#~v6ShJ*hiaOTX<0kGdWFB=pl z?UM3mt~4b@WwNHmz!ABwc*C5zGrC!RIB|%CSxRMx6C^1^9Ki!|RXC?5MB>TDFObq* z>Lg}UGBZ9KuKPRptBwgt@srVxPbv_P$rVga+advyWj2L)xaKE5&T8iwrN#7Rig0q~ zmcmA#DGfZA))3msJj1CqQ-obnII>Az^g~51N|>~~;8I)MsG8nY7@Uc@&GKO-O2dN) z_H)y=D`>`%$CiAgXpwlEc6UpiGi3S7Hch!oE|m>H*(srp)VSib9?%3BXTZeOIC%VV!MmkPVwj~uXmQbv0|YVI=^AVq{t>eWcMYTFG)XOo~l9d2e)DMMjp(lo!$2_rK zMa7c3p@w8iW%fDGFc}2*rQ)`eOs~`zCZvg75?zAymlUEolh-wun^L57ew8N~HX$nD z@8uVZjR#P*5(vd@;6m#VJijj?wgTvc`w0q+cMQr4V3j}Ln`3>e%6lzqLO+$@Ky679GNknsT0ui8yhgV`ilVgudS;(1 z(i(=$&s%CopAB3ZlZ2?{NzUL=1#+fpm*ZtlcCmG}wzk|Za|{vXnz-V7OdHjl7WL1N z9r{=3(Z^@SIgFjXoF8j`^`gQ<$VJV&_=!H&-ulsFNtwB}R<1Moxsp5i)`@JJrLr02 zms~12>T6i(5hcr^K7+rNGH$dxh^(l5_pGL*1bI>gXH#`%tORmznGja_UIGBKJK&;*Xp_(NeJl2!#SHiGG!7X)}4a@RK& zX3UPU3@8u^e!X(}9!zm6M%b}A?eu*Y;V%fS+G-07u@MO=0BoFBn~xl_%bfZ*oau0h zzF6#S$88`Wbn>p{8dQ#U%Va2lur{qD5+uoX8~0Yp8MZhn2~ANwj3v3TtY;%wq9OHy zu3Xn1Ng5=kk0??demBRyPK`e2S!W2dKs-1lJX%5 z96oLAj|Z(+71jyLyF`INFDq`nj+?ii%yD2+}m%Q3PYJJAC*6rfxuEmiZPocx6-;Xee62nIw zalX}&qeUY8g|ww@+ofwBjHFYaX~)z_1d7o!GG9#C{AnS69&me#nNG%)vwz|JfHOMY zzCb_18o|f$g>%W>ohmep`%>~pVPs%n8r>PoMhC2~We+V0Rx)v25LR-@+bS%)rTbaj z*0n+f@K%B-0gQ&qR7NV~^i2$w**nmLHgI6$BNZ}KTt-fe6Q1-Th>%N%Cv2K&q=v=Y z89B{5vRLVa@~9mB*rGzt$$bNY*r>cru&F+?kc?UOUTx@(vCG5zqw@EYKardM+>ebDa zl6jPpa&mg_*LvuTRC*#)Z?S_9hLn&2DI=8md5_06qgpWKOm@w(B5o3yygMbfQ5;Kc zEu$sn6eOe^^ankBsv|p%uevnJib`Bx)sby9fVW#Y=UzbO+XKja>qd@rO2K+V&|Zq# zP^2=ntx6yQ0o%U)bJP1PKBs?YM&}AkqT8ZxjMyG>;^S#`xlFkc^sjzEq6iorcSs{{ z^@o!Oky1ABvPTU0PiTkKcXuRRqF=diQsaIJIOPaH01OX@>8r(wM;pd0{!FKxX8!=e zt?I2+f4S)$HK_91qs@r)23{dN%1mcSCzO3ptdr-tt~^*{2I2H}`5siVKaqdk*%zko z6Wf~m4NP_M>PlN-OXe!T$Wa5Lu$+1CMp#F>7A%dfHgqSVpA;O@cR4zC;Nshhad9g` zo(CI^kHnp~r71Y|(VVfVciFLP?F2Q>ps)TEyjN8mZc?BT6}hf(=@ft;;&ed1yJFkT;8!P zhEOxM#Gh6+ebX| zyQa=R)cVf#t@RW*SBrw)X>Yc|d5#iolsg4oH8%Xo#k>qvg@BS6Qk0(P)g9;-~ z#CZZ9RzM0@PMzz+%-rP9SI3ftKcT*x&~^(%&jwzfjUsxKrJoTv0~>oM@BKB5r;(~` z+a@?S&Ls1k3DbIt*jAl~8O$I>V?If(Md#+UUOC9h@tSmL=75_B3JA~VQ! zF;YSjfUI&S%BSU;cDpX2HBX}HVc|u}*hjH0yda zKMY|f*Dev)JxJy*IIs!*Lb_oXV@{4)WuAR{IS8|5<13Rq?<4gYWRD0VM_FO^0Cg!LCkY2~q34S0Jg2b>oxWVxm~EyKroiPX z#=?S<(UEblNZi@e;dUlbB6xHL+X*C-nuPxVB$=!gCfS2(9tqyrahdwgYf;01IN=98 zxjDsdrlZjh$DEgUEw>Ud<{m1s;vXSb7xBjZoZdvh>?&(kja%JGi?$otK}E2CH?>3hG>cDt4sG(>6AB+C*1*CCT$+rKTy8ow!;$=z zEunbOWy_x8+IdK9?xLQF&uWQej3TeHp@Sw|uX+nJNyKmkrfQu?-COh&N6V7*JfEk* z^(z=$CEG2CR2ySzTGlXDqtds>3FUmI&Tk_wEDPhrwnn6Kz)~{eoKWlKTe!C?IF>}A zUc}+B(-1c&nbmH5g;U&!PmDjv(bXfzN`s()a1)BzbaJ}A67LRXP!2&OwR5lBb*)5d z(iVb1QigWi)`k|>Lxzf)B$a0)ed#r0O`%BAFz8m?qp|5jS_Jk;Fw2Tqp5ju5PmeZ125s<4}un#395=pRfLjB>smo49!D-_{!Sucq_p~9By%>NaskK$^s2p4mkO56 z3x^R4__{vWP+NpI=0bL_Kg)EuqtWowl)1EahXrlxvFO+ntlM+ z8L{JM6=Z<>!6U6pbTq7lpEL}N*CtGc@kDYSE;*XzyJP5XrSiyof8iDQn&xh#{{YFS zX$+>yQBpwl>QZw@rsRa*FQ9iB`kY<4ty0!A7XaY#80-_q;> z?KT0WC?TfI&r<1#$hu8mf;W)i>HK3{8Df)XTqUGcXIo;kvQP##=~!{ut>~;?8bY9B5UfU^Yi?l>R|+C9Il7Y(6lN zovK{yr2|;gR!&p^r1^EOc{^tCjTT8Z1Sx_*-yID{D|Bf{q+YbL7PXZF?%K3W$-y$N zbki)nTU%g^^~F~rcqCb@HaLuwsR;uZImY>^Zpui$+U~LK(;+v^GMNqMf8&aW(XN(^ z2U_ZO(#qQo0#prkLN;>FRA5?$X_GNnBN?u^EgbEIhA@$}3}c0agzrENCY1B5-g8YY z1fIy(loAdIs#-)07ObCjL84SObEzP0LJ&|ru3|gWLt~cP2V#2DTV%3M)fd)ew$?hD zQ<71!!CRxDczdOJ*=Ojp)3(*(c{!<`-;IYxul>jru#@3r5Ia|$^QP?d)&*8lH8z|r zyWzCiQq*t&86=+At>Kc<&yyW=Yj!Bpcx|Qa(WJ24MgqA*u4OA)*3wp|5UgV!*ihdf zEg0)d1b$qvAiSxpc$OqZTy-tZ{)hRWellbfvb8%giTl@(|V~A;h z!)a{_!rpCQskYBC2RjUf^~M1n>eC$4L}rVOsiQj7cLwInSn+w9Wkj|TkdS@&=m)rY z*IX4VIHv89O#=B+uzj4KQRRYvvaEw*;f9F}Lzj8JqAXZ}2zhcOtd9*Pc-sfQ2m`6X z$G?xr$yF3~c-WpxD!S(T0_}Ho>q-{d0=Xgrv-E5Zna2AJp8e@yO?GeOsH#zAMk_^Y zQdBwlzOmmNyI_yLx+Lpo6n4i9m~0_Usj{aJa7G3@)HNrxT9g&44=A}RNpWRMA)wG8 z@5(v@_Y8g1MJO!;ZzH$sM02VTWb(X#psrF0+#SELn$jD%+bX2Lo~rJ5(&3S)<2l$yfBP{kv7B!zMho(-K6V zRzg8kRiR4HjD>V5T9JgPb>%gbnvCTB&0^f~MSWPYi!KeRR|a|BTqQQZNNj=2?>NcW z9gme@+LZYHojh8_&+A3WsUMNzv8t_8)~9752<8g_q@@`d^6o`uw)ipWRLj>4c-3G0rOR>fs%`v)ajqScKZS+j?3Mr7YtL zAnt0b?HN8%(7_yd)6@R|!nFSYCDp)r!*E$z)IxhgyH^Cox-j@T<#j7RajjbP zXAiThxO2rTj+DGdlH9i(fP$A$&?JQwW1z1WBERx`nDI%)H`6+QPV0RQ#TJr=r@I2; zhloK^@r70r$H~(*PFPd5qgJ;-)_P7eO0~~oV?jA{==by66%PaS$XPK@Z4Z-i*7r9I zxmM&SDZ)#yV{dS$3^O8f#a)g33!YUX?)(^_?UL?xs(7om5tLs^u{k%69a$q8lH83o z*1e*#p@2nG$&VLXDn34JzroM^Ui7$BbS~GWTVsmN8sS>3I z`7*0=mmTN5j)@sH*Nr&GXPugH$uyBOq9Q3*Cgm(E=>Z8C=qsPdX~K^G017YUOz0aG zrrfB|?aT3FxZn;4K;{_kcdk4bP&f|A=hBS7hR7SzIOe1~3Jhb@IGU_KSp zZ_?pU6vwV15og9(Go;uw1GR%2tOKgRGUpn6&4|XYKSk+OC$drjLE#h;` zb6uQTM+=f}#Adx7LqRBDA;kTm-kfbPl#@dgsbx4TCml0dQ5MC5mKq*9GJyEa}&J5`}LuEq{{ZUq$`k~2<8)r%bAbj4%Ac0`4SmALM+fl19l zY$1kOBw2pWjQpdbZ?3YyO(3l zQs9jR9;*79QAi3(d)9s=T&DRWZ`7utiF|H|eLo?EsG-*uRz~GVY}Z$jjrNZ_#LpF} zF{R0*Hu{njm8`3B2SHn6=;iVsno|`(Z7F#|?8Q zI2AZk-Lp?Ar_!Pt1ZAz{jzsd4)Q!b$IZ`>X<8DZjb)wv_4JuNOz*bRqt()XkE+|%A zwo7dXig{9e&gPsZpG0KCI4fvroMAZ5I@Os6XWDRbq^SOGD3*{VY&M{~J#VylYf@6D zKB7lj#t@60qp{9Q9|mX0=32_ua-|%TT};U;9Wau$a*zUi>o&%T=qLzCQh?jNVK&*m zHSLxttrtf!)(Sat25SjAM}8>s*%f9(F(%4Hg>tQH*mfeiB;25=;g1+(l96agLkdIB z;Yw0)+CblW#otKMKmM51JuQoeD`j9T;QOkYP8%jNlyYcYQI^Y(Ovd<8 z1B@Rk%cDk$uDc$vw7U_*lh_*D4`r^5{rK-ncfoyUZktzHX>>zRrYRcEhcZdQN0lcw zfk%5D%6SNahPjSXK+Y;+zbh)WN6&kLaHUu2vFP{**o$ zk{g1fp64|WqWTBK-x;X@i&$CC!|$gQ0!mImB<^<`bj?@?@Ol%Ux`e<5#>mfaI(EQn zQs~Y0C!dd61RVisX~Mnpk*QBr7!u0K#mZ zNiU5500^(d*DU`4bN>J)tE5-27eL!;-m`1i8MX56WIRw0d{;EpveFvG&TDLO(MFuD zhQ_^$IY{{n%CIP5L&z=UjEZR#SS?L~F^_YJ{6%RF(K6Z<@OhJpk&Na=1azT{s$5_N zEmV>x9sRVL0dmz?fRbtOhGWxPW1mCK6BGem`rm9+o`K1?VxT3xj-JcF+EoP?si z64ret%I>g1K;A=N))g*Fi{h7LL%LBo!do8-e2C#eW9gvNqbU6p`2vj=YfZ6ja*kcA zHt$8%Y?qN7C8L#Ok<%2fVnsUf^lm99rg6P#7AM(Jo?GTBIM1C>i1#%LZHdZNflVtV zx*#qbK}sbuw7rg3Pr(qE2za3RbfSl1MC4;VX^1jF3Qz~3q&L{@ zk(1LEQ6ctQG*mMt>ewSY^sGFYaf!AF@|o6p2H2LOv@Z2Er|6pbmxp%8gS z2?OO`f3vY8IhNv;drZ)Ru@5qU9ZHgYoPVrSU9fc%7Y=z6CpA0pTC}0XIQeOpRO<{8;hEk>+`h^0a4qhVIjLRZ5B*VQXzHD=Wz=3o0ks>&!^* zIv%tr^2=SD#jJiimDfngU|$rM{cTSV2&k>nHp;r4v$#9?_O97NRY>B+nj3N|H>rW8`OrKC36Ig6`U!caer-|jV(=fN7Na%P9do74+45%evk@>{mynT`g0CAzW8 z^lAgDP*OUQ2_EX?!xuR@v(TGZV4{qB@?@DFG=`k!@IlWh&M}|Iuiafdlr(V4=Ik_< z(E>IQq=mRJgq$4jg0In2xv*b~Bhm^UPdMqah#46k`r7nI7MQt|n70mQ9#f5s9roti zagV;U#xOfTP3Mhi42C^0A!_MNzO-5ebvh;RFZmUL}J?4Owu$o3G(bWD}$50X>sFvv~(%O zc!e#cJb@`cRRB0JMmii+c`{AKkH>?Hlt%AFc2I5B<;sfeck;5yIZNYgq@?Tt+wU}> zs#iryZ;uqh8+Fdrr4^+v#pt(}5?^JBtQ0SiWR#K3*JH8U-I_B;jzu-su)^*RFTX}% zcSY9MAuY{)DU_E~zGM^4fw$wD-Yzp%x+9FD_A`U6uU0jeVm{D#xzFOQprfC>d+TQu z$Z~bE)ulN7#EmUmNg_?GVzk4BUI}Pj)OYt; zeq@3cvYaFU1^@!G$BAO7L!+))oZ|TuxtfI`rLfZ>MP1I|S9~y2O|#0$nLSZjxJ`M& z8w=fAV!AaRjAERa$>g&gu&ndCq0`EgY-mk@i!L^^|eP5`2A`XYyy{QkSEl>~?peCNoKWlsyDxL1TPW zzqVqN=!4drUm7{bQuuAfHVFw1Zhzlu&zC(!=vcV!T^LTJ^pn(=Fr^_4$7#%xGtgAY zE2hrOc$IRa8PxnrV)r4}R7fMRI0XDFTz)jx#hc2)w3f`)=Oj*hoB@(^itmJYEuKbM z{Eo=t>d-pp{ozK9!rm-=^p5h;?|rS zRJt*iNZW5?WhrjU9<~aJ=qptoG5kz9a-ZZG_MD(P^5P{4Ot(A2KU;mzN>fe8MPsEpW!@&6Y3M1Q?D*-){qH`}_*WG2 z@zOmkIKDD<76pd|B4~Yv<&? zvx^>CWWV5myxrS$CNXcFN!Zr-aZ}}IKbPbwE)}tokA(ob(`Z4?=RVb4@|`mW1sq(G zBUK^Coaa)>HPDyQ#VI$j)vw2K@U=JtdEYe|X(}rYgIUeZp{kkb4TX8a3tiHCa0;3ILCNF*kh<;yyFT>apZSM5FX2H|(+4()6N25LA?( zWk+n*8EPkAk8^q@U7UuI>gie#@fb+XFnsG34qH0qn~LJQBdpM8yzBB*rra$bYn@x4 zg>+9OBNY>Z7_#J($@E;G1|p$JAgHMTR!(MViGwu6N_u$|8NqaE_F&eKHxjIuRxyriWhwHpB-ZV9emD>H;Y$+wGx<(f;R zYcJo7%@k?Z+V+;Bwdccw*(--zP+ zb~W=R$$bzLE^!pwj(C9}`5Js#YAv#zal1I$%FyRH9R_+=Oe6GHL<{#&``qqe5Pa)p z8bmoD@vjMK?o@)Hs%{pxPbwZ=Qz0!j@Nd{XNbO1$WxkFGxxti|NHLuR^#umMOUBbj z=hN3@1MnpCAE9&kwXGvQOlI^ak=3P-h@{#>Qn8EdtqMNLPCe8nnOk8uQ6mS+f~ktK z+KRb?PJPu4g;vM$*--$N)w{QIYpXO#*yYAw4k(6K zj=AMEDoTN;U?wyF0Ops_W7+FZlKT}fij4ZYFz)>iDeF}kFR-Q^xX%NC!+`$)B<)R2 zFs3+aG>oNQ1BV?wgHF&>6cJw_{{VxmN#k`kcmmCAP{^sNz?ZJT;Pb*(SN|8dDxN#FsVoX8wzOoHhyw<*@i07ZlUo*CidO8=ZC01r zKn62|{X<{Z8%KDOV-7S?#kb{Z-GF zGE1VO(s7_IqU(wBIXx*~lgB?r!}Cw&syq0@HxIR5|^bNPm+i~1d*DOTA$r~Dby{-LGDUqiL_S0>u! zl@cO7*ZkS6aw&Zq!;jd(t8~OGCJX-n?2U8OzK(^*?2u)tZQ~H%+y1Q6{Jw|y{gMqm zBn{#`5B-^^a$bq3{fBkgML*)tf3r01UqQw{WIfI4iEUVj`S>=k)mh4Nin=XEKW8@a zK6UBKjO8%`QEa~9N`opOj$^nu>0V#TrzYDy7-LEaBLLMiuVuw0aHS4na0^Nw* z8tmcE34ImDE!VfckieF#{{Yo1^;djn7wqAb86d^7@}9QoNB-qss;iPSrfIA}yrDd% z(>Ejjp?|8d{p~-!UnEo_-#y}Q{pAP|Fs-?93jXLbH zSm4~n(i5)Q<)JBkvZWSO035@v+f-T`YM4}6E{ix8iJRocGC7JH14#UT0#4|D7Om*{{Sii)iCwn!C&gC0re+U+1z)PPjHBp@ zMb%M2y6IcdeK~_ABb;tqQ14qtaWQdenT5+qUR0v5Q-2+Pp{|uQWa7~nn?1rZzLFcG z{X=OK71-;Lhd$02FumhJ@GHG{!TnS0#gpZvOx<)j1}#N>0d? z*siKp(HuYOnw=tnMwq-WWW#j-0IF!T7Akaw_mn8Ycz61Si%fkh6LU@88CeD+gagzh z(PHdYJ*waqlo*cW`6SgQkeRIT!$@4cX}68N@~*oyYs>R9Myk(4!ouY~j-bnbTv%wyq=TG8=5I!c>&|83Q=_$Jqd$*!a~&D7OBEl2VjXuFBoT z=Io8gjPus4cQo0Oktt&PuV+d+AA}tRoimZ5nw|_;sh>y4-ZMm#$@{#I}bRUxs9V z3inO<5>j!~pgU%`$Txw%%Yyy1B%tz>$-drZy-X2O{H*f4tdob};y@)2tf|t1f_iPQ&1 zOG{7+1r73?s=0IKj8_<)-Y1JJznqPOPTF2FTZv?b>yt~N1ueEpQST=mE6s6l@{`f+ zbApe@1^E(s&r4l2^}$a|g5pr|2b>^*p7^e4WrjsjXG`(2`1_hF*98F?=?DtIPqHw2 z*0|o(S%z=gF}-gj;qiZPqDtIT^-zN{?~1Mo$r{ zXn226Qn)feYIfLHCy1orb{kfI(m8I87nvMxtcaa`xz7t|WHb&&-K(b_2xH%~pD&k_ zBdGLM?ve`uT)xgvPNuscdD(B#1oE9yd}W}W_6Dl$(Uf7uSz@#^bGN01$8}ySsmg*z z>Cb8$BP}vkX|LO(ruZAecnvB(snqIIiAnL2gbb_QoYx|otV6Ix)7HUXm~caN|T<|t~RRD zIrH3Q#k~p{o~$tmvYt_jt`1+ghnYkEn2dGEQOXcXiOvAr)oCL%k5;6V#{eo zbC*P85aLQluft(meVk^hQj~ugGi+GlllzcD?jq>m3U8ghQS6QDH7F;uXB_Ww(5r1p z5yIp?;+#8jc~rS8sI3k-=f>vtB&&=&S`{6Zlw5FOME0xr=at>)ho2veoMN`fL`y9^ zeutdrAdy{eHmLHs)U5OG84e#4nLNWd=}svnqH<1Bdk}RBWO5vjb~{xkW^zs|V|deE zj^`=o3C?;|IH_!vCmx9;%O%AqCp_bG%e^iiW9HMe0Y);S2o%ZKMXg0X!U+4QKqgC^ zm>};@KrYl}DM=V3Ju_0+(y{EFG`qt=q&#p2a1wF%)-Np@tZk9*aL(*WQ*r%aAZ`)Y z-Bh#1595&!CqrEtON6ppE%si=WhczM^na+cd+HP;|Y9n{RR1-0{|31no&Wjk20@ohM`adlv}q`kT#!2M8pquezb| zm*kCqyNS3+n7Pk>D#Sp%sVL<=z^tJKJCUUF%Nj`pktQs7?1t7B?+}5bcjx23>uO(_b3MZr}?6qr zU!`M~kAa*oWMk2fQHt40%$_z!$YTJGUFq0xA!W1%cBBbV)FcI{U>q6?6lEoA0DhX5 z%Hw^LP@p)lGB>OxFGhr19?=_oXk7#BMOjKg12n+| zQj$mmprApLayoBTfL)>h>x_=oNmvIY5=P!tOR6(&*o)mdV{g$*aVwG|q$Ni`KY*(m z-()-J`ekl5QL9FByAuEsIt}Om#UGD)09~}5v4iD66HPWwc}7k!YbPJ0Q(5502rnA` z^umNyh>2Qx)q{n5tD8P$g>SO)WBDC=KAmufhB36Qnk+V>r6mXe?OtvyZ!Eq^9T_I8 zjCwaMJ#7rgW7+7m{x#hdv~$VYED_obqZA9V(?Wo3a?vE!Buf|Pz^fo(Hbw!gXCl%o zlH_wN*EEXgPB7+HYA6TFP(m?Qkc`t-PYp|#gVELgCb?%xzw&J!k&)^d%9A9aC%tgZ z@@A-3(HoZvHE@YU&~YuNdfjL!zC7-8y?PAip?iBlN(bLU6D-jf2|y&)h(xWu2uzlV zBkQN}s*mnMmqEQ@v<;0&{fuW%KthgbGNQIrt~Vs}5>0UD%Ak(iP$5OjD21ie+SUsK{TKX3Zr^$VsnG4w1ywlJOSWQZv`LzO_=> zl%hy9PJ3yhm&q}2bZnRaV zUW=+e)-&&_71-SpnsD#FXb|K=i6K0sCV>WnqpkApaM0ros44cr*lm>x9GwD6%*N%T zAf+TBgo1t5(5BIgfk?gR=8#DZ50z@Cvo{(mX2t66U?h#|xf4V9mX@CwQbkLb(CW)u zdO91U1%#{a-l5KoI0iZjA2w3Le?=~AI0_?1MMv->+YQQV(1y=|(t za`bDQEYlYDWHoxaJjjT!rN=KRJgIfH1u4ZPTPq101Jvw1tCKw4aYs%VCo3u(NYrvQ z4fRS)=Ut4^A}eZeklSE%9XjokjnAD{7$~Ci9DSG;&QeL8x-fayYCf-TncZLJO2Q4qB$x&Wzo|d54+83bjux{>u-%8 zP&R}rY`%4=0I4K$5$u$VV+Z>yTsbfBk;mj=1|tivrV_CLTYNCN?O87 z0*G2sfz*3x!1AtH<7*>Obb7uXbu3Hd+A#~XOMIu~!cCRZ)WR0qqz-1vLD(NI-+gc6 z7rlxeCfmn|~?05hSiwe`J{ zHmz1)vzg-hDpGXx)VYaS!hZd|)zKV_(Tt$hnCcdvQ@HS>DyJyZ;V}{g?_Zp)6ONE)KeTex)gUxhq%_z z{Pz+kB^^kpzMFTBrMER3_6ECQCtF9AlN#jQSc9|SFbVMzqwY1b+Awi;H(mQE`ifhNzL-e?VhXiz8LVq8bwBC zsJKfdQY9&8%$n_ojRolQa(US&cF1=we8iQnHP;+TEgp2dmirmWy0V<$Wc#YrXvSGN z49k-wt1Y+6oc9zt#S*d3eIW7TKI({BBOOglvZSW zhZOcZVJT@R4J82g?^!uF?CHl94J0$VDIsIk+#uuHHPMDTwsLt{6lGCkHk@8Qvc7e< z1abV5`vJ#FRuXVjJ5y*^W47akvR~%ta8r%zDN3Ci!xgSUqBG&XR0lTM8{(!;(Qt6CzQj}k2vUw8xLbQEkp|!YvjP~tLUxm=4d1*gKuTq!FmK%622|M6) zsl>N!739g%ieatN(FP-qxJs6K0D4l%9&(_;kzs>udW)Qw7!uOyX$c+sipk=NmlLID zoTJX@5vg04*kz`I7tpA6qxxPh*rn&G$BJ7RT-|NJkjUn9s*if;#TL6cJc-6iqD86a z00qH~>t#n9Y*5HRbp^t|F|{VWA*cCU4!Mhx>FLT2255{ppvgBmSO^<#JJnGLc7yEz zp8Y8d6$NAiOapaR0m$h^3dPt{O`&}4b1S#HhZpE+qtTpOYA*PB!PzIulZA~=otDd8 z(%i#gVJy97|F-&PsxuIp4~@=}x*nQNb~r&75Zk6>BXC<4B2@?1D#X z*-Yk^G`cJEPD-+KTPJ2MP}4l>$ROvi6m*8x^h{adc#26`&OTL?nS1tKt=7@V2}sU+ zRx*)ESu)L_6|^}zsW|!8e3cc%io4tVCtc+qXpy(Rt~5-QGPf*vc?lIw2xg}UINF+s z2Vr2G=RRVZR0FgDw=QbqVr?N*r|;UD-(<J4>tWyjblh?Ndw zj=t*Q&*dy@M_xQmZ+#y|cs;>OZjiS}VTefzN=E#(!5nhV`Ol+S`3~*69$(P;Y267*8Yv=r*A<4RDr;Zdyy*X{C0FX^^^L~x^kk=dAu~Y~r zdeSYjqmP$lQ@X*{lzErm&a~ZjTEK);t{f);TVkcB=)Zuh>P=+h$yd_gZ{C`VduFl3 zpseQ&dwEm0OM=S!$aMbz>NW0QjX{5edAapAP-ET8ZYfJv`N^)nA4Up)WUMVp%9aoo z3c7Wwj2WEdsJB|CdcXu6_pRcr=5Eb(h6{~j8xc?`A%pCem!7-ONM>-HV9->1CG1iI zS9nV11Ne@UZa*9KqXkLSPOeyy_@!PLNXSa9vsbCYtC??!@%u_^(_-xzmD2Q(5MgjWGV} zIuAn2h|p^)74!Z>eV+am_|dIKoXe~L*&7Prk-ZStcN!xc)hMK8oLxu%0Gcx0X$Wx* zp}^uCNK#4^($k!IjDinigI&HK?^YRGaAzXKb;ZE&*3MmWN?1zy`Eo+@*S2wr`fql4 z99zcq-i7DF@Lgs!1cENECC1VLz!?LSlhkB?Z+ewAFUk5gju#ZM$Nu-CseX*@wt0@1 z@(BvUPIH5e{$HlLut{Z)Dm?!HGaRsFaI(Row9U&<+#}m9=;m?%0Ht;J6NJZT1I*%y z`ydSc*c+O2mlb9>{<2HN?IOt3zR0eh-5QfrPYyvOupd2c0aEtgmOK zm%@%X-Zi5$pFL@H#@4k0Ho^E;qXlU*&&g@BoqKSrD<3NB#&S)&E8=sED;YSgc#(80 zo70&IEB!Qa7a_wp7aUM6uLM$QJq=5G9lv*dsG%=P4YoH*m#|6cjQJYD;Yr#zSzS{k zV@GFG>DdjHviyiE4w97>FT*1l^2Wn{*d40}cxIobb>eZ)j-Owf-fY^DmH_mc#^4_q?iNZQPA0NzFC;76ssO@*i52+T3s%@Q= zP?s_{J+sr{U0yzHa!Ji>}fP*R%FY}Dvf!O^84DlOeHU?9za(VYSU0!mAVG}0lU zgdpYnx6k+A-yb`#C(g6y?ChL7&bjaFGO1s()@gmWt@^qk-4mJT3}qu32T54A4IgUE z(zc}`eD9pTy|9*Uwf0LdqvV6T3tkA|vH<1cVv(WG_sxQGCX4s+x$9zrUcw70JIp%T8f}-znACLpw zTF$|jVSz){JF+^9Q{;%`Lga}250h+3RE{TsyTNFev0fS}uP7^N-!-fsZeIKh4jFJf z!vE|yuJE(a*6G2y=>_lExBl}p0;+fZOEf6lo_IX$+cpw&=+`l?4Dn1V+3IGHwQbJGp;SWoSAf}EnLU=Y)LD_B9BNc6woS(a zT_v;B9ARVjO?*3IeG}AX9D!rl`?Zvl+zcPOdGW1n!HbK8@x&`(7A9c@ z1(tTWSJCxWqLNx|nzqre!5~f`4cc*t!Z$-z|4P$9@Y8#nRntvU=9}=Tc{E7pBc5r! zUMr8|r;|+|&=FDZ>$%L(e{I;mnmo0wt!h0C+dDtj&x^`l+#V5<0eYEe|D*3(6ckO5 zNN|VnNoK*HGzh4rplKVry-YsyQmKAZ*i8T9wJ>L>Fj&)dls39N5=Sg48cQio3Lnuz zNp{P0HB>jomDe}aN@RLnRHfU^BnUb-`tk@kPM+=1t0vf#)stDFtclBE1FjBXw8zX} zhKA|Ako|{3#T6uP{s;?{i5(z1Ed>5%8+;q)yFN<%AaYP)YydNwtQmnfB}YCdq@&c= zk3en2M=={T%KbuoS8Q_roUAh4I%M2P3N}a1&U@ZycBb2exHQ9_jhzWK5arhLyTYGx zFPBLE8MyV*Yh0m<*}&6B+EYo`JkxZxOO|ExtxGw3tt`MZ%(MS$A^z@!?$4uwW=TpO)umLbHZ4ucPn;IwGQ^vWYt>Hzh{E?}SQ2H4LJN^PSdw@Qr zpm5`YpX@Y|L2x=P)J59N+6qtEuNH^p$3|^tx%t(t-wDHoV^GQ(p85zH87NIi;rpEz zEf*tum3{d2m?wunOTC?^Te{|cNnHIwlAT&`gjtID!UIhU_<6X=mTO3=ixX>E@a%N4 zbT<8-=HY}D0ewG~9Qb=JtmvNnnd~sZURg(2wtJk}gSbI`WOAOBgk9M9q{nNUSPRsac;>ZLSrnq33E%3d$|(ZH@?QUcQ+?)S?)RjA7y zug-dSoUFO$)KG}#B|y?IrDs0TNQ`lTvb<+3JgMse1>|*g z)WF&wJX6-xW+l;trT+l^=1i|zqoK#S^WF(1M@!Vn4JA1ipWg<8y+JBh-_v(Qg`BFw zS*@le-E?C7F#3PCx|*DrUz{yFbLk6S(2GhMs?MevF;uhS)z@%c`fSC*(-kWEykE(g zUV0WuywIry>&OeVYOskP@IntC!~$-uU*^vLEpo_!K{OxKh}y33qZ++$3+APcf5dMl zKU7FflURHrC6F1u)$kD<}UUFm3nyy#mf~kHumL6U?X_kxCk9hBCM>E3fX!#mGb z8?4G1+iyAT4+YE&AW4u}*!Ix(x|f0l&T0DHk#^Rfz!vcIg6=%Rw2Xf+FkwGMN1U}9 zFPj4e7EPB;WcD&O9=6y=l_>@1{ip#Oy=$AXHexp$=lydg`PWJytr0KL8vLLyUor5f zRzkjR!NDTOb||$g$zb3ER5wyO>aF3#Kw%Zw`HlFG)@2AK62GZf zwMP1<)Xraz3RflQ%=A&VJCf^Dfq-~l^g#A73rj>n5v|RlE-mZO`gn_;#1l8&myiQ4 zgE~>x^zuJfGlnKQ4r!__uXA3(US{&&Ng8D+jA}^CobKq}JCL9b(-S zFp8O}!4yFKp?Ow;)M!BK)ruh(AgulsH6A0`&-SbDGqBFKnYd31GG6@|jXKHH9Yt4= z1K)(U)TgS{Gj0!z{1A%>ZQ}~y`vFG0 z=2`0i&wzKe%8$nSH#K+1*XepkcSaNBE+>jth%fv%{sRyc@$0pUi$2^l9J!yn?0rXE zY4smKy5QBymDE|c`Jt>r*+p^%4klACI-bqrJ_kv+fY>%pT#VhqUIWmFYEVGc{Y0K?08?o`RILyp4V`IhY}${$Hb ztJ2oG`^NH8D>Njh)QM=N!3~@~vgVrhJ4bYmB)<+CuAlrtX0&WBu0P7w&DQUOOdbSf zjeZaq6W}$ATe1B>o6h<17>z|~z8#X9x?>&RYCx~5dBq)&X8(+RWlt|4%WjH&rE2XQ zy}c7vos?GP*!ex8olGQ5Uu><}f-`R_=d4i*w*-%k*fd*S!EUj{O{umf4r7v$m{>O-*CC}SRwUjs!c?8HjLfv{ zzu4(LsLf5U(efs(go|l<8V_C4xS>N#Vyeo{M8h`=CbPW#dzDHHfAw?lA_64>3h_m+ z`;ati$=S-tzXBHlbG73~ow%@tz$virS#YRcJM{HX2DLwmLTB_M?qA;fm7X_kzIaAv z#V2Lsx~yV#$RV#E-jTk3OdJ;W^Tz1Jh5;a2D`8<*4aVYU=IJek2(!{c!x;7P{vs&v z3ASI|J3TqmE^~H$v|wL|Tvp-&*1EiG_Z>pZ=vN#lQnDppx4mJ zD}^x~QE9dvUt2paE!i;x$K+GsJbD*&)lBR;ryx|6VI4quvCFW|Bc=*lmR&>J&M!kO zx#xJLbSlSL$cUOBzwg=j2y_x!-ZB(9VA(472&wpz8<9XIp_&va+)kk3hYM-z!}To2+lr}&b`Mst0v?BHd{KU1 zsnhxVaG-cxP2-W&03cicBP8i27{ZE0y(@bTRY>|rhi2$AGSmBx1 z-)-=G01~(TjKgDKghyp^>2=rIidW}HweRi(NF~x3VPl0Baw%~D(vXB@T_O|OdQ!yD z&+M5-V)u&a*WnJ{GF6S)Zk1MlX8djcGU?uxHD`aC5gqXGfo4CCU8|nvn9E~C)EYvY zX;81igLcKzcIGmDJabmigTC`HESRaf$sUo+ukdR7fQ__Bve@5oeItU;=qZzztV?xu&9Y@;RGZv zS*C;D2; z8K&N=TZ1BWWB`)-%J{6VQR&6ke62<;QE+S{^J`1u#hM@9`inqm88hSLM0b1c`z(m1 z(d&e5kLj}fM6Jsr+AkM|fW!bYX`6Bzh=Q)_=>h zYoGCBO?dmyWp)$Nfj(K`gg1(((6+?+QwSKIbnAmDtS9uOg|Qr;;FdC#2DRN}PMm3c zHg-eWehM`iZb@Q>5PQ#rgxeWp7B+~bg9v^k6KyWq4!UdX>;PN*nE1~mrV>o(dD@R! zCB@PC2%!$Krj!oh(;~j+iy9LbCRvNdo@LjUs`2#}z<#Z>=q*)iBEji^Ns71&j4G87 zej0(Q4V#SA#1qHznqh+&To#ac`5Sr^O3<2!U7t4GguBN79SKjVtH9*c#7z<;fA$Gs zRauSP`#;%d;zBv{T;)ZIy&GltFXlhmV&%)L&4KHLK8)BGb(fBpq!^y1rNEWYQ_ipBuMvWDRP(A!dyHJTqJf^Xg0^+ zcRZCT@+4<=whFQ>P?jg0#Y14G;GHv7=^QU~%tujy1K9Qr*4KAxiK3!iY+dk(bBMr( zx7CttdD{tR41Oem7;Esfl_?0PLj;+_dN$D|e6l5s%|2Trm2rxF_(iE?vWe!ueFj|8 zZzF!0I!BhFLzil0Rx%YT6|>f`pRs(lZ`Mz0?|fUm9KIz8SUgQ_Z#1HB_Y1n;?dqg1 zFCLgk-5&AD5Yd;6!Ru-g^R25Up}o=C(2%GO0=`BYpd z)~&E=4iKB7cCeBD%GPNO?PQAin;k+YsY1NXl{^=VT^V}CP^YH#*~o;-CNx~P=}9?$ zPA}ph+)$&`g3I@N^y3KHwC=gF4A%!vnhKuolg%Hgs7u2qH2L5sS}M;p-%AALPsDFP zT4P6(DOrBQbV&CD%oP;I@(lVkwQ7ChQIjp;WCz95XJv`ot3nDBLj9W^5)T;#KUG9- z12%r1)*0%YHVu1iK^)h==orIAgn215rMCSnsgPd=1LVv#tgNl5$;8EWo>5wQJ5^pJ zih>BF7YG5iCcNBAXFSs3^}n)F;`cf}4rPH#_CIpp)OLD#tELs_`Suqvo0UA-?!anf z_M(f2kNzfx$V#91-~T!CeWqs7#`mc>di2x`cGu`%g#+MA=FJHA9EGLO<#PD#E<$_@```n^7plG$*b!j=r)F{RbQ3xtVStdqNI5wtj5 zvk<^Ne#ak@qwSUTv$0>1-O)Fr#$C+6YL`vp=Cv(ddjEkA{g0BH3Zw$7`p!Q;{jw#% zYMt`yU%?IKbG{0P+4q-kYf~CrYVhox^bd4iKjzZnFa<7IeX4OiEa8xN&Qvfuygji! zbX}X`JEMGo6?eXI{ywgakMzMO4;5=;2Z?8N5vZmM^GnxnwU7Mp4sA~b!fjL1+P zaLU{MYdCxj-IM>9*|BJ2O}AOYTE@hKe6}n6d$cWIN!MuLP`g^&L0e$&Da7P;TOxy> z%Feik)grl8-gm_m9K#Ufw22c+6&;?`Vwg%7FZGYUc(|Y5t)e4ds`>H*S&$R3vBN%SpdlhR)%|C#QCd;*yM$%W=Exeo z5Mo)hE)1c$=rc=>NUB&zVCZJ>NPORFW?_Zi_ zI2xsz9F?khk9QsTvr^(|Q!G<2+s-@65{g>tT?N+sBZByoPt$lv_Bk~ltk?WsME;)-x~sFzQg>M#-doT#(=+YSjl?6lLN!f155VOZ>-NasjSHZgvmozlTB>w& zhN0%nw|9>hcZW_~WaP0%xkd{bI!SVbtO1o7OiJI@Qxbi6D@OGLrB7EJYwVtVD?tAT zIA($9mZYX`0OF>QabkXFPZn}IPXZubTED7bqA8T#LG_`{d+7oK-LA2e8SP2RdJK4z zOJRMo`u7y#z74j0t-C+h{mnA}HVZCm6`-B!;7le*7Ok`j5}|2`f@ZV%Fj2WhPB4sh z?WROj+c-S>g`1Y(gtW6Zs$y4Qkvl4^$I{Ew6Qg~OO=a=8Fb zuKn0c50AI}WihyjxPU3O?S;3EzX{lj+xm5;-0X8@QrSpdpaB~)4*ltoi!qX9hx7L5H!mkl z<{k=PT+rFf!smWmlJ=<=&mxOsdt*NikNB(SQsF@=40fZG+g!Lc-D*74MQt>{G$C(` zBiF97C~Y1_(knE2C8gK6;`XTD=jQTskx=8t+MRb6sp{i1V=+g&8D@ z|E)a2K&w3w&k6Uj4bLVD1xf5l|8H!;9Jtp&?fs$$J0hm*PvybTvu{|nZjC$ZHCXB|^rr7}Z-Fp}E$kfN@ z1tZFdY8r)=m%pGnEOM3D2+3y>*)Mo!yRFn%+IbU0F-Rv?QIGlbq-w^gu=SVVTjXgu zIv#N;mq_65=k`SCk#^b(apUkfQ~OqVxHdhEgit^d5TCeLqXQN9SGFP3;MdYdawZsS zSkj0-dG6S(n^7H#9$+m!PLgv-X=g~^ zs^;L40WOKt0c^znfFQP7Z*d{%QSAn3SYB859y)Q0S->JTB5wGTB(!^g)`dK@tqJwo zsyB_#IouB&J$G~^)!{F@v?$`PrB@}(3~f{&0unViB#lPkn&SYz19nM9sdfJntD(*e z4}Hn=#c(7rQ65vJ#^a6$ldv35zm5|fA zU=dS)u3I9+MxQv?*OJMsAOh=%L>88|Vcu=WiU$o+T$a1TV~=S>ezpC|c8+>5VjR0; zI8;dDUK(v@0-|oppCt?X`?LW{C=yWKfGa9WL7(fo|`Rb2C9-bE_@oA{6>tu_Y8x#BMDH5if6+c{f*IT*8`9lLV@8>B2tV~ zyH~eh{XQXU-agSo5XmJWfLH_&fSv>(*~$U0oPi6H07mW*MJW3K?id8%L;yk)BLO5# z7$EKlN;L2mgGbsA@J$ZFSIj0Nkw-ZrwPGt6tpL;#&|r6H~drCc2q2{5%TvB!e6iqOYB z?=a4Wq+@t$Z7K0dNVfeKBA3>VelR`9MUClI5-uKBHGWHbyy{6m;TR%Qe#yAm^K~ypfKSQL#Qt5Ig7Ug zy+Q!BHbLPn01cRys4I%bARDV4y~M$6%jrK!T#l!ysmD)}^HJ=ZO23`-O9Ja30{~#$ zuKOyto**f`v{+}Dte*A|_<&fdT74)wb97{Ik9kp%aYUZ?_{e+9HC8;e$OFA01tgrK z7F6TeCanHp%E>|!Z+W2K7oA`|{)C=VgZI%P=`Iu7p-sH@%foW``0D<)InA9WLM%mp z*o)T)h5kV%Ppe9qkR2x?M`FG19|-d%;8`_@X(xgQ&Hjx?Rl-1C^znO3m4(kD4Z{Qr ziL6}^2T+m&7P1PH)46y{wWda)S43BA7&L~ z^pCIMqafh=icoqbtDjA|G%XCovG^fmrcf%7>w`kVxVJj0 zS~Z5koHE>bv_8ogj^f?0i|nn=eAZK@<*K)()#4{G=|xh9b*7J&@SqYdwGWg+?tZ5I z7CA-hx7dHNtdI+%PG=c~N5MB+{;5*Eiv{WYTxXz>Op@&#Rk7R6rtdA%<*>#6vI-2Q zvowTE^IbolSpa^h3laP^l(JaT3?qmXIDYJxcd%Ai|Hv#;1*|{EBW#!rps2udZ5k(~ ztH+;Rn*u<1hk)OQN|FUHoGQp69h3Mv@K+qq~#D~T= z(x>Yh77m9&rhT98YiIDdyd8!UN0wm_QbMiPL*TEneoV7toD5d%QxXDb&Wa%c*9FOk zD?9&_40*BD+~fSS?H82%d0NsR7@#c4%vCeGfd$fAZ9ldd+g6>}TD{zu!;9o4HoPlT z58%3B^(hT`B4tEPXktMKIl}_zcAfF0a;I%Mcfo+U**FdA*Vcr4%INpZ(~qE+8rn`Z zu30(iHc@iNR{Uye;$dm#_Eg2PBO3gY@cPRy{uxmU9zR^6-o1por`KOj3lqsCL!9x> zg_9wGw^5P!Fmq@mQa37|uckJ~ zTyk-azs*OKb*XEMLgS0bjN9?kaEy^l)M9ZNBib4cTx#rZ_{dE^;SzheTIG{lB}`H% zl2wx+(_BM(YLc@sZ;IiQN<*$8c6gx15Pq)lrYO`2R2~>!;cHk}SV6|M0gtvDT{cv0 zc*r_oB`9qF9{^00M>bTU$E9TpE+kLz*())`3%7lXAv9BLv3(~Q*T9FpHl~gX#i+tz zk^oYDd4weXG|2(%LouU`OZ8gZf98Vqkd1?o$QI|(N7rq~2pgz(h+VaFOF-Qn60i8)BZ_#3(VK&;H<5cop&*M@c~f%L`=#tN3^=|W^A z)`(;M9>dnyV^|_3s`sqI9UDDmy~D%Z*Z0qX| zA>@x(2ZN0b7e>=-*TL&{nMrLJaa9DYU(R+>=+L{^Ry*OR&8qCAaY3GBED~$ISAqAn z7lqJzjBv5wnUE>v`uf0OuGeAqe~nDvqdwM+r-NB%(R$pNn9`3^_w=QgLL z$>yfSku^oZJ9w~A*7~|JWr(hGQ0ZjdN!<6Ng422V_pC;xJV!6fDBu66`pQam^MK=@ z)C|!4D8O50$gsWF_4|2I?U<(9s9~ zT&h``tYNesj}Nte!T)(cUNp-%h!Ru7L5hV-+4{roztukPem|2GVk=&${ST1yd?ZiY z9sk4ov8wCR#1NwoUbjo#ni)M{ozJ^-cT3iQI7(b4+}rSVa0l7X&-J(p30n{Tk-i_3 z1gXPa=HwcgEeW;Q$80PHsOmTVkv@ksPl?b>^VHQv;lP>gB{jQ8q8F4Qa}v^FA!tG zo~-G%GeDIp1w-6GU2At#kglHPCBo2}+o$dE9I~AwS7goTG5&mQ?yTA+-C1b=HSzx3 z8Fr4ah~4Tb(~Z-;Wgq2%X>DP(nx<+?v8!@=8ANY?Aqjm3n{N$3zgl|z{*s< zp)+KMnL$)-w`oyqPUdk2>;ERTm0%VQbaAvGvo777mh}tCPenwq$=|dg<6Z==n@m+3 zr1;d1IMN|(u~h}<^k*1+>d)WIajZuXK6SaM$iNCoBNB$aU7;OqyY`jAIrEWFQkjp+ zV$UJ?1EZn^^>yh0X)j9la`TZ0pu_(#Qg%$V3tEHwx=ngsp}{(a+h*IB*vCKZ)PpbU z(zz1n*!*tdu8kWI#!T;V4Z?}oq=rlSv!Vg&fmg}6PQ%!doBnTPjD#9)u-PW#hP1E` z|F%PF5UwE$*|cIGuA_JKhcW8!lqLTsMT0CSaBYoeW5?b2zppj=5{~;V3=q>UJ&J9LF5yh@t&>w%!Fh0W5vCHVYa(c?8B=bwEk1)Y<__Nf%;W$If_Cs-K7O%_aKXMJwyo4V$q;Vkan;OPE~ZN zzX3~HAo!WzKe@mu1#`!#MlCh}PG8FXYBaYV^-1i7K+? zG}JKC2UZQ=iX=uN5-Q+F=(MFmp((xT)}X#0SH(`n=9rJBH9WQ0O4V>8F(Tu83Dxc$FR zU9zg$g!(Pc7l|lKC%nz5onm*% zU&i$MU8b&|&q}1ZN0d<9TRk3`P1`QB0V`d)Sv<1W%U!?4GV{bj|HbG#~@$IeQ6FH zzU-~U%r%)U*ciUh_468e7IR>rnhw|!1$Z;$vLBfH%Rkf_{ssF-_Nhnd@oF=Rf!uv{ z3ElCdPk&aTPW)t(-|)e#?T=H#-j3-RYNuc5T)a&?VEX#?;M)6HbXkoE>Gui`WUka$ zMDrqN$W}Bb-6UZZ@dpBH+f@$T7R{~;&kLz(g!?qh$Aj`|l|MRfI>2x3$DhW>0fnA- z4bmqZkL6X?aJ_x9v5tLL99<&heF1v7WwY*ABC^bOxkmeO8Tf`vXoR(A_!4HM`IpVP zxi4ErVy0?Jb-hRaj?JME@q211cBe7sM6i0fB*gT`Yqr@)Uait%| zA2J>jIL6Qp-8GoM{AA{x8pM#M#nAc7YN%PtItxQ$3Be)GzPon4a}CkZ45i3ps)R}j zZ%_8p{Voda79y2!uHNX^OQ1WEe$IBLgj(}eZLOlr`Kd&T@c2NhxC*e2;#fSy78hA?vu*9LqVcC8+iAe z9A5lH`t3oCr;({fB)b}Kx$QfgH6CTUqu;O9$wwwE_>P`9liWnR+0r9chQ(ZRJTs$} z?kH}kO5seLg0qnwDInmAWzgtcB$$uMcoL)`T6L{iLnGSPdeh#J?LnI*@zT&t!eVHV z?nsbed;YBzR6A`%Zn`m*n^(su7RLrMIGIY8;if^$TK=9X?OWcbxE4CFw$C#A)N+?q zY!2$URl`cXRXF2xDNC9KO$N~0iHHLv`<>>u2p7_x1WW@SM1ugi(Nwb75mh{UBS!Cy zK`Vfs4u$}|Bga2*^2r1hRVxFlq^8);1_aWo&YemDsluTELnt8+2#|$a=vD{|A;Xdp z+o?X`U?#LPTW=1Q9JEuA6NE!T(Nk!h2TXQ=bqd+PN@CozMR$)j>g92#lAV`Xlx*#DkK#68N8z~ACF!cf>?h?Ye z8$!&)9RlDPN8uadd^WyRNQeepl0;Mw!1@wORw9|h=m|FioV}cm2lRGcVt`SD>6{e9 z*+e0~VaM9GzC>w^M#G?NHUiF4tlfi5jEW8#z|IFG5Dg*D4?i@-SvwsVh&0JkCdPyVTvLkee?%AV zVV$t*8mqpRU;LVmNnW*nsxHfpevl_G$oCzM+F)AY$xJu_&t1sZj@2l)KRk#rB5gj9 zOqF9f6j#2OF|-@z(EI%QHuO&C!tWx$DJsyII?X5EH-}&T)y~Zq?Sx<4srdC`$A2S| z-*;C~uQqKFmjWr84v_t`k|F3km$#O{F{2FFb(+zr*6gE|m@T|{R+9GLl{-TD!4YkA z^boV%b>WJyNcnv8h|m*4;7G2exEB2l@>S$Nh8u+I>LZV^&&FN)594(_ihnje{u@fd z4)bYS;P_g-U6GMje3*;$xX`-LcJ9tl%NEeX$KFSu=&&S*r{?_!_-++E>$I#SGS;Ts zKAz&;rfq#z((!TqjT6MHpSDD>KpZ9&TX=apl>vX@FaG-k8NTQQ>-Bn$$0l$qJW_jJ66%$gDRvvD0>L@ z*mF?$8l~pMZudz3yo`Zg_upYxdq&H6_@@$pJpYWSczWW9l^;a=Hoo$DCJmz*eVd-4 zee`O^>QEggZJ%3(wIC}QlhUz)+d_Nl>fpB+BJrA*P!&NN3eNo$bq-3p z*ps`hK0xy4IZ#zv# zhS0;W?`9J4XAv|M>-&Vj=}bX)@MH%M_KTGq8JVspqotx?!$O~p7BI=yf=W zwx;oI4Gp>NR&;xnc1p+h>>>+|m($sF3eeWIuFjeRD zw0RUIqT3EWg89WGBpJnP7zf~PE#$I@`) z^JDQyFjOE9C`ns5loZ4|hj&Dy4dBd{6au{AU>0;jO~XQJ-X> zQO_0>*2QK6&ZzyO2SUiHovD4WlaDv}Lkk_VjFS4&n7F^v7PeL3O@1t62{l3C9SX9W z^iY|&3;O(ol2k&p;JO6y8vIxwZ^~L|)V5JMv=1Ve>`K7@qG}{BguS+KDIRd(yluqB zZcLDmCNV6JxWqVH&vwnWT4AbUL#NY|qQ*6^42NogZ|b#NT~dDtjA$-Y>W-DN0qg^v z8}Ny7tQ-nP2Ce{&fddS+vCmgfF>c?=80Cy-QU%Ip47SrIq{WjAG2wL#p&DKbQ4q^! zoGgM$@sK0LrbA-|sUWxqd$ID&a*H6uz#;FO5>)^M^#uqeW)lQBv$11)z`Vw)JRl8M zN9xMVK6+z#q#apB=$djnVdaLUqJXD=FmhP6g(2eugP_2h?wN1OBg!XBzW1{)W*DA+ zol<@queLf>;rs4u#-_|C>q*{)wIDE`h_+h3gtOt1*#}ne`S0&Lrs)AZEHhf)K0pk0 z-G6YNko+=(Ew8s7e=KRnIT${k%J;srTZ`iUQtwwgiEoQHxa(ipu0fTrQe3kHuMc`x zX$NWB+KYVOK~yu5Caywnvc4O=DxKoi@c^r>;SZNAYON;gtVy)&Tkm(jToIej*p~IQ zQB<@ID;~9Dw$4L`M%umKNj;@)oj}vRf5S49cr|}+&qK-x2n^#;O4_)71DX zw;TJH>}>I(Sz-}l3V*{j?0n-lSfJ_KX|Xjy;#-82F2B)#y`J$pq3sJyoEx9YB$i}{ zXL!p>%0rwEYgf=w)BkdK390kjb5(%q>H3pTsYdT;mPQz1Y|~{A;{Mh{9PcTG7SC;H zg~XHF{w1W$NK7S18$SH=eEOBOGNG3CzojKbrtXQjt19(-W#2rzj`~vmW&2OGI&en8 zH!YwVfgdXLY~o2@?nkW&+H;*}vlAW{(=L{NXYxeaciv^diPtioUYm-39iCXVXp`Li zIBABdf12$2feUt~lg!6?zf%%ej^a_j9~qsYl|j}>o|%6re4dltyjS!*3C(-ARkfqf z?IhqI=(5-mFr8yjsq;YXi5l$|y(=SSYui{@;Vv-NOBs|M`_^cG)b~;8p6kgY=dLF& z?OrOr`mEwc%G9S|pI&~OiYlR702+N_+rKHiE&Nz2q7>&}DO9!N{gZ!{H1DSBJF`#n zu4Ko25Doi8ik$D3Aug=`PAd5yraFxL;B#=4dO9yqD3_0UC%Lwt?KRI>}(~Hac zng)%W zDc?4w$}%z&vl=kdQF$Jdp0HU_#UB;MZB$of*(DzFEFzkrD|%izQF5e){%2PmnwHK= zQ`3XqMQlDYC2mndI%*An0%_`;5v{kpVtCWso*eThM?Ma?ASH_YF$ivu3GT)2D&beV zT!9XW1x)c^-(;fo^IqM@J?H#es8YrdJjTK4rSiGGCD=jKt{>ntjY~R6M#&Tp&$tpF zPVa)Et1bM3$JEjsxK(m+5y*OKjn%$i0Uv1n{AvD9nemHxlMK#PH10cIkl$ywa3Rb# zaB9Q=#j9-BtukFYqFx|PG<&3~FB;X8i0(=xA#rgPkix1DEy{}4UE_%Vm~`ryhD^!1 zb-ui2ti~p84y!93{i(K+)YZ7ctBj+wf1M1doh6#Lzl_jFk}~4Cm(GE)ZOoO0RXR>@SjJUvPd7|)&IDqN z7~jP_kR)+$nZy@`RM2vors)FtWHCU7=yXm(kr01lJoV5xD5Uc>&Upz@kedXgia|-i zvXX#jZ~!DlmjIn>OpTy={C5U80vpDtD2O`)*KnpgVZj>!Z)+le-&&G{Iu0Pm!un+k zI^i2^g7+glAC3ReA*|Tg0Si};LH|h6_K~;#R-a##nb~{$#d$%{l*E4Lk8+-V1kbh4 z>twes5CcAR}3{Ma@!;|znZzv3+l}07#>2{a(F}eN)j93 z3tnnY%uGua+OaBts4EWU=5IDYzRp}zrWVzFyfcidzIb3oNLV&5^o7>g7q=~xrT18I zI@JC0l`~`I!*F;ALbeNnhd9vy__h&p0$_0c-8{enEsK$VoF0YP!#wD|3&J8gfpW1- z#TLw^noc2BT%CJ?mB(SrFlQiqFtZCdU!}T|7(Gp1C5h`$AM|sXismArf&EumnUowP$q$5Oo2(Z@gJt2-KIKV&z%z~cw@RD8 ztCE8g{uQu7-f2IxY8eaOV&gu?ioPWHmT>qAzSIk!M_2hM&5O1A(W8?hW>dyz;=woX zuLQbigsrl=)b9(7Ru>&64@JybJ}L-@qexU~H>VZQjZ|tW*)qJ89=R2_)h9Q6vXHTd zDxZmO53S=74ozjLQ&DqW&1ZZSo%thAp`n{yA{# zfB$Rv0Iy2Q$5KhEp~7+5jdMq-jAMTidz+z}`?t-FN#3!-NSvmNQ)$~@e8iQw_#x$< z0?0ZUi|MFONj1tm5MaNra>jW_5;}Xu4~q&)8gsVTl59$3-@$FtMF(YtKjiidp{A$n zqoIpx>5%i`wLF3P4k-$@!ZwcmoG-&JALSqDE@Ycm>$lnPp3C!1=Ecp|%vY21k+N@> z1&xO{?NF5{v%LTOi%E28m&dck*@NVx6|;|>bJV;aJo-fo*pp_Vj;)fVRZ{1M>qfJE zfA8!1=o5bS^wM8?{1m(L^3~GxXr<7}nnwNA>5{})0^Wn9<{**zJCTbw7sJzLKQBIP zKHm~g&sMXV+HtLeG2vx#2) ze3(<*V9y=+wG#&@VDp2QfHypUJA2&AaKHSMjBl%ntMC+;t$PNTs$8KtRb@|1Q;G>jo`-#`=T0z_|{y@v4c zb|^R`+!z0ywXAWzXsZZnYO!+kpkFkDw(Mop=;m{=%v|3}UdP9ZkHuo|L(eLf@y^XM zritsplhLHD7^+G^OrcrL&;!`c3Am);ao^hiqO_R;QFrz8<*X#%nk`aVQb0@XPz2A)Z7eBo`yiq%Dr)y)3um96QnClClZ&^0rSVQL!{%dc;7cN!De3>6rp2&3uCzC^N=iZPf5kP zo09Z4B+Re*nTrM$Kz`>*fEZrNpXuTfv{mLpmD@?@VX6RH`!BA9jH(e zxd22Lgb#C9K`5b`yq*EAgk;>?G@xKbu|L~VPkkn(l`@F{kyd?a`do67rlb;8vUO@l z?Z+-?&mwU;H4H^1;1*`dAYz&jJ4P1|X&0bGa@Q<;ZJ6%|OOe#pkK{?`4aZG@G$f5B~|04;UZSjkq3})RfCe0#AHReH1M825Zy}pCn52B zGAr(Zd#*Mk22Ei@vQ{Whwx?tDopfAxaOOLaph{cpp@=$cynqf5bz16?@weK{&pFh> zaNp|PX>%f17nRm2oL9c%NrNs6NHzsm8nVyzJZy8YLx@F? z0biQ1lTqQS3elLd4cYIMZnC6VXKMg_IJEXnAZkppRZip?V;R9Dv3vhGbs&5Ys2^}n zseWhn$zijgEc&z9Uy$58VxTmIaQ;<4(=&BqZ@I%Egm{!R=2;OSkQAHcRbR3u^2!n4`N+&5u zqkVR;OB7*u58z~4c|&g07m}r;MVFMXz%kC z)Oxp2VqSnleC?AA6gTB03fvYhyXqGq#6DW_o=)?u7*!~ez@}yOV};g{0f7dhZHa3A z(wgmS@MAY^{+->PJ|QW>xYlFX5AnAW)bfx8gG7=xAoq=n#mg{S#4DoGz<0VM4<8{_3QgT(H$`}!%q zN!s2FS>Yp!KfEQ1FBOQLygrZ#Ojbd@U>~0uI32`lWMH+8jg;x!d^|&9#u(ndW5CR< z)NY&HDp|Z(ofa^${Vf+LPa3y(r-CHl6hf`8cT{CCWIITNXsf_uh-1nTLBSw25sE)C z_QjF8pR~l`hHaIQSGa4qFT!M|h4=_EGC$=Zs6fE0a4UH7`_`-Qp+fF2=$XQTG0H@= zz*M}#iur5P?zrQ`xP2N0gAvn|jP7eCPQf;a3v~{Aam^2L= zZFkgspMCFfo!IsnU!7>w`Ls9H0o%x|2 zFUDnPW1~20M~KE5gYI*LhdmtUSxaWL^8TIR+k?Jjh2l?xXA}%cTfp^6ZHTnbgyW<*u09v3;8F=4UgbFN`SQU$Cq`V)+Y7klw~$)yUZY1&#a# zt=^|3-~9!d!UgLJVcQbF=K6q~R`IieEw*kZkGhY4L7Qd7e;!v)l)tXmM(BH8xUMZ+ ztIe9Ufc1v?=I=7wyXvRC3k!SQ0w@GM-o1JfcZT_SV8EgE{6&mf_Fb(Z{Xk&Qz-sw` zKzv{0Mv?aj0S>ymLJiH1gi>j)bE$u-JdpTwrnhb>*;4soZk;!zX)Al zNhNm`Ib#Qw0qbeLsjK_*7nJA{7sn1 zbLO_T`VVJXHalbX9wI1ICjWx|kA)QJlT|lJt^%@N7w-RYFiv@w^&vtX-$P#EK3C8O zs74bvE78JQ0S1^|uYk|1ek*+P=hmy>p-egH79;Qt;EMmie~kMq2Fx#EJ2f1DEYY;O zDj@q8R8)r(Sh|n1re44t_{e>iIfDE#liCvLRw zJ>)&!2-81MdiwwmKF*Zc9{}9hWPJ$oPAr_b5q3F$GDc-jgZ>32`~_)5t#d|5Y;N`S z{kQZdvI1|Y9=mmMoB!3~zaTY$Cu}tV&jZcu*O|iqf)ubR|7~PxxqRGMU6^~Mvw4Ga zpDpMXc)ApQRRadpLhKc_8IPw;Yvzl67oGf>I z`$-q2v;LWsO!bZw9Hoy$eN*oOTywsh?P{q^nV)ohlzY9N7Az)4;%y^wdYgXLLXkdy z7ZPneSib%)g#OXtGv8x=g@ip6SZaS)J>|O7Q)3RF#Px&HoqjYx3kN_;dv-y%(uMI_ z;`Iujz>#kY;{{XQBFS%p3k3E1@7`|$fwDjkb^5Gytg&_0@D0yn4nfVrOf+BgOv2huS|bzlZ23;g%s5zs^%*x4E)0nFjNcbg2b zv@57?^Ut5z$-v$JHHkbTn+(xMW#K%KwmUvZz}|g_&jYow)Cn%AfjwQmeIge!KdF0$ z^JfO=HudjFHAJ1kT?u7T`arkqf4Tuxvv$EZ$m6Uwk}ZM5`Qbm*|8Fp~TDD#8N0od2 ze>M=-av}B*nFoGqTKR8J1G~$){wx5)kM^1TL#W8V>Qx75)Kq$S*UTmJksSxH9_Fsj zPJr+7#$-T+Az^s zDyPm;fc{fsNt|OT-|1KW1qBsIbdCee?e9~+?}I%)@lE%PB@S%!>QTj?7g%ecy;f^y za2P5wnSnXX^j_c5ie>5?y#P>Uq~JL$CAcGd4w7gwAn*?@EICrQgo^v>-4^P(70aq7*QULae`KVGeh`R?A~yesrYcxk98z!ECg^WFpY+VGXcKe|%d$OWeYoSMXbD(a0#`_J4G4j-dad_av<*9qbF7Wmc{J)K;9JX;KkD-tNDr_aSJ&)+!sFZNf z=)tdV|5TtIBt{}=kstOXa^;qIGErG*WfCVA|LJ&P%Y}9ztpvbA)JF$@UO*Q30B)() z71o^r4*muD0bqxq|EgsrWdK3lp~otL2S&vGlHk9lu6h|b;{ZR#?y=iFGV3{DIUNE| zpX{pw-$fU2;xcMJ`CUz))hCsJEe`=~M%k0CasQWBPmW9jC4IE;GgQ>6kZ=V+QM+2I z1yRv)vxiy?t!PJTU+GFe9H}TIEuxmtCZ%1buxK^LSBgiicD(97 z#=I4=r6RK&(zE zn@)$xSnAXb>FW%%WP4VNt=FhkS&E;XAmq@z0lf@TBxQtXK@6i}Z2B^kx{HIn-@jK; zn8C*P_4Ae3eMH!+rTS^Ls`<8Muhr2F??-(_{jJ_64LI91?-HH`iFEby|2bStE##0^{d5@w4)vadA4Rx(NV zk!BtC7X%=DzAkzw$(S^ctq$ROVqE%7@Mq!8E&>XVj zNQY`eW)3@gKKLt#7${g|4(-GtZ&nY3G1w1QUnqs8PypaS41yXZx5R80$~6p9P<(9a z6Bz0{SVNRFHEL)}e}Mq-O*rl>5{8^jZWZWN;}J zx7t}Cq|l7zs>Hm|>*zpt5#BEox~wH!8cn7U+hURp8I-nbtB|nDjS5CPrnxBQ))|dF zFF;j=xQd~dNQzn6S1vQ9f^LF0imiDuQ={?UXtAQ2r*gESC=q1Z#HD)6`1FRUk}=C_ z{`t)a?XLBB<#i2LBUBE0l%gKl%$-vJ-Nkvu7&F@p6J1wxk9r?@ z9mZSk#rYME{R*}YGoSsO8rKp7*Ei$Q5>kc8l}e5=l&=G*Fo$)N%NLngSd^-s@;a6b zd>)AgHAw@t7Bg^%^PnuPm+wgr6lAc|nwC;yX;-{Zg%v)-9HzM!E^!;1+T1lQT`8ED z7W%;`!9ti<1c%|_qaWTbRSp%>qvbb2`lXUVz)tPHCHh%w+M=8=&7tFMr-&34eps7G zH!7jFHn^<2p{2w$>P;w3j9wrWH-~6IksLc_V5TUy(<}9}F=cm3HacC9`HP!6eE``2 zzkDRbO~&t`;rcuKau{tXL2dJxFeWKeVUWvUE<)2!)Q+q|J#8NU%HXdjFuNJ5j5i%# zsu+!3_BBjQ5sB&PX%aDkWCcdgAfwP~NX)dNU$ZSb=CSD3Tuu4+^AYj{Q>U?#`~zZ|ggBxu;6;7%nNcsV*b*+v`U0=&X@O*+b{*6*;zPv<<6s~)#IdtvCePxS2gRYDM}bt( zQV=Q)ZoaU619wxSwBIya`1YIeSCGl;IMM_l8jP`UNUvWzS<*X1a0rlbyy{7s*>2of zjrWn$h_l(0R3)YgA=J>xO-CX5sJdgqENP2B1ckK7r6p2T*=mL?{+0{D>@RxGQ1(R^%#b8&!IKyK zUN2-H)l@5y9+sGsRfR#Mq*#m)sZko*$7)W{?bI^)j6%0n4grKY`Rt>Dz6{a}7Si>~ z7a7uZ0WUELCF2P-P;(wmP4FcV60^*(Q(z?Jiv1v5$L%0IP0}M3q!@>*vdQ35QZ{lR z{`S40G0f{XWFSFZm$?OmQ<1!sfdS_fj$%QcoKyv_-G|im%_s`Ln!QI?^rVULnKqYw zb!^Q5BSm)e{uMJv%hP$K)1>pkG|M7ymb-8niqQZBjb8YQ)dh{3>IL0@RPEQm*8uR<6#6Q;7VzO~fR3aF7 zN}VnVeLvp%Pe~wuSrV&U6r6r_JN*&J3qNjwWLj#0(U& z?)TH3^10kXGy%|wbI6T0OIM+rlrGl9x&4i{tJx->FaAHhr&BQHVdNZsn6<;w3LDYz~?Fc zAqC==#!SN!#uAY@fZ>8?EK7C}#~^{X)O0YyD`kow0Th?n4BKRZqc^}cZHBK)7^N%p z`@ruR)ef6)(I1XX*wTqaq^A~KpIWs^nu*>gEN1{nH7LVC7P!&CW9T&&0Kg=t76z(n zT!@Fyd@kas+qAtBkv`_xdj#my0!w9@P8Rs{`B%)KOuY=M7q7U{xqC@~VX~c{O2C1- ztwF7IUorFI$6yM9Sn~Wxbm4Avz>X5IPuelXHc5C6q9p-x_Z47s55)nQNb*7xwmBxN zT_YzB`u(ac)m^PnnPYeJR1>yrOBl6+{)ZLnRQ*OuY>W@oT5~T51l{<>{42oZQp(vL z5^T9~p%ekH2U%~lT1OOLIk8_V-Dp&k5j|&axY1l>mk{Wv*77dDA>${Y*-s4#%}?cs zrDHS8U0u{2DO|L02yHLZ@ga=Ko5N{LmlPoFrv~6{l~E1+VphOK0f3*Iqa&yI5QVr; zoeGm(pc9S&u#2i#FZ~JM+1_aJj!3Ckf-3=}S*B9KShr|*3Uw+vw-D%nwm?zoMzeId zkyCRNDJaapavGOvBQ6jC%w?cesDq0Dv>*|CN@rk*?nn@J!mb1$$z~1G>55Mx{v1tX z?GEEcgND-4e=`)kC5eRY0^sTZw3`qBo`aFRiNIL^#zAIzYOSC#g-{#=e?NfIUtJQO z6(FMgkO1I#AgHRKPBpEOx}6z;%o9Sm{Fy~#*Eb0^kf3c~#yc(KkTo!XoeOH}PX?fR zk{}YOgvNb2Nx_>kQmGrQShV($l%i0oPOV)p{NBy|9LN+i@g&FTPzAw z2!Pp>lJS(K*(|uPc!|~;EH9)!Qe0T|LCu#s^(Ar}hA`q;ffk-}lq`VF@-QRhb}pv5>O@*(&ar;&rqx&+X7DM7JYFvHBCx%UPKsnj$&zuX z9tu!~uFMt7n2|7LgcLTaLsVl71>$DI2_5gspRuzt<(ut7F|=vp$b1x6nM&XrYz*cq zV(0+A369T@8JJDTsTZ3okdf*6E{stVI#jmD zQazxY{LQ?Ll0Af%ot%D=J7dgKM2<%tjY;5{*VmPdW-4=(Ylq5FZly`?tAy)T4|09h z4e@=jMXKLuG#zk!3hUO(K8f!PUvi-*W)Uat^yKJ_C5U-**$=LFR$Wt2^JW**R_3p0 zkinUvx&gRJ&C;RsKni7@-1|6uqT@PCyDjBW;N4q4M?z1PULaU?(Y?*3D-mtm$8Rq1 zEb_wQS5fJxSXacZHDa!xU!~=35^a0o>ns$J4OGEDR4v&La<@nuhc<)Qg<+V*Ib^Qq zIS(POQJlAd3d?IHq&E2TzWezn^~gmRcNS<=3wnqe%<` zPeyT@VHMK(1D{%rcP?Yy=Tx%;mm+rjG2qf1rb4hdQ1vS-y&?yo;8)@_TSwCUH-4QK zK|DPEpPkAR=f<{zr2$+K>n=J|`L608s^WC9$rn8hEGW+A!?vu`6O+DB8skJYiUg2E zjn1rUPOwx!gcvT%AHGoCmb1xjRX#%&RI?{eT#S>q$$~7c*SaW?qb@(zmyx=ATBmM~ zv5em1yK?lf_Nx=qXHFzD7WF)%F|V=36o&g~?7c|Bb~PA86VmITL*O1Y4yRzfFl8bf zl8nJM!okgVh-zO2{I#H=YbGJkn5 zyztnauV9N=O2cf)F~8n!uP=#oeHX8!I?mnoYrb98BIl?iZFb552{RSP(;Q7`xY;?K zE=GA~34+f>{8JIukz^kj&h0fWmpLl!3<+^kf=GKEvRNm}PQP?pWaU3Q$dm!a0VUwn zX}gx(jWQ)pKuDo#otJ4qb(Z3rWjL7B& z*EXek&EmT4ZC<9GylVSS_-ku|eV&yn$KR8}5%?ma+VY9@&71P_UyfO}Q1?jMIf8@&i)IZKVf>HH`pB$iu=fy-|sI9R##0{bhCZdsUXSf15e zcd)Li;|-Hr_9=JBYi0UR{Bg((tnTYGuG4rF!53Igrh*HO@AS?3Ck=nLV;u2>q^ep*?E>3mO_DYVm&2_nTo4n}N^IBQ@Qbdo5vV^IOnNrndQ5cB~q!E92pfP8YGw(nY?cuEDI*~3Zv#ElqZlP<+u$?tkHJlif=5Sr6fEQiF(c7aKnQs8@mI0%kWLN=6GF**1CpR znT|rPOxW&}g;DX#ShvdxXO;GDDP%T?P#YT3dKktP{z#4u!?Z=Wa&kvk7#G3TC6OA+V3Ul znJ2wmc?EGn+ZHTim?@Oo&5C@6z!lFS$$*tjj%QO>e^BUW5UDoqu6aHaO#!$-P{YN{6lEyR=NeJLUCa#X!jl-Js zile=f8u%P6-8SX%j_cx_aVi|eWky%esx5AW_(=rEh2n`O4?7m89OhrKJqd8hO8fe|up2PMD5*#hU4~Y{sU2qxB2JPduLd z7i9Ds>YSTSO&dMat!_UyVs0PLT?}`)xEMa>w@h~wt#3fGgqXKBb7}}*zdhI*Q@%WC zs!ek9naf%I3kfL}oR$L|^F z>~>!`(<$TE8SP;TJn|bfS=-4i{kgb0Fh0-m8K&M(CoHy;NkoO0O_R==$Sj?py~CYS z{g#!SY`1hFCqbP$bcjekS7x1@Axw!PsbXZ&bL~%s1Whvr5O1yHntXC?)s#CapIB!z zYT->xQ2OKfpe{d;yu9CR>(ZjHf~3un7@g(dcdH%<@!FjrDf*a-F5KcFZGk_mL82Fo z6w;y4Tf;_>7tPq~VL+Mdc1+7^PkKF_GpkXEDxf%UyrTDcKRa3ni)PBP@t5=pV!?Jb zHG7@4mTMnj+v2NIZ)HrPou9Aqs0Cpuzs4_%&8665(+nP)rfxA_T0x3hHTV_#RT^EV z30#H1FFWaOb^3ycq6O$6UPwopnnPn|g~(00E%7BN)t}oNvnw+Z_d}~n>~V;_u2^qe zE2D~d+g%6sg!h0rhFoJ`Kkezy-T@SKqe;9@Kfgem6+Q?VI!H~Qm&W3jL3);nFL`cL<%et0i1Y7q(ZD7p2m4j-;XmK zcb`Lg2V9an!HRP>qmS!G*?vFqsJ5>_h^tXl@112seYkVod&EbA4zjA4vKVJr5qJ_( zkSpk^$xLNmsf~KnfE{Rs_N1jsrs$txc}GHKf>7;{uCT_24m)FjblNNwRd(c3Bps~2 zbw&%cgIeb9mf%6ok!tJYX})l#Pu$V9RWl!wXvy252?a?CX>TP0+xAWhSV`G!Pp9DL5Wbmr9wlgX_1ApKrIaT=6k_*o)I9Ey@G!N68SytcEau(Yd-8sE zT(^K6w!?lS=8tTC5nx8^pY~H5JuuN5rOnhKTbclg2x=E$mO17cAi5-2deJG7*3y`V zjJ~mhLJOi~7eVlV?=|!ruEbUIoczw%Go`ZGnQC~5|Lrl%(BW0EQjbP8qd42x8n!Re z-YK%ZmHxDDNDz+9LyHMBNBqXdqH)JwWTk$NZQ*ckTTM|SgZl)zvrM#ja>BV3#NMe= zXkb<}_6w4!bUI5--#42#NM)W>?L~jQ2nXRj3*C4#zrGB8esH*e`)Q5#v89&U>#*W! zIy-*-Y{5#xkX-*qH#P}fefKs-h*4Bz@r$j3p`SW$1Fa(U_D$TYlM+Ui(@ze8!k9h{ zGW(-Wg_1izP6{ER)22CQt8S7ZG$@lPew_5qpC_~9dh6ug?Epz(JVJ}r%+nWPC~D$_ z%{;I1!muvJj*kkR=x)e`g36yJT)*@x(JyKX9e37C0HIzH6I%^Ct;Hb55b z!H~$-Q{xec`R&}`CwkesRL~)m%{DUYHGGsc0!dUlOo<9>VP_!vYOTPwBJX>Ht8vRG zNA_Sb+ktoUFzeE5YU()yV}b0lQ=*M93hvNgV>U!`f8ws5WfF4lW-howWLkYFw?+p|Tq0`#^PT`A73hR8rW z2fg7T_g>5E53or^@l2}Rn^nrO;|ayq;%xEiKE>#2gn9 zax=B~W+XY}ftLF-h$&r?X`geE_tqn-9@e(~6d z`{3Xein-oF7uhgP%CH%A7|PXXP-r!cpIcQ&D7PDl(0bE`&>=!wh^og-Pp&y-^@18#7pVZtCq&(O?y&eWz zk6WA>=F%knXkAM1L69OS6EtJP@DX8~=g?VC(HL6#e4l5hmbi#R$vJTKsX0;r1ve&X z-|Md5e#3{FVVcOnR;tl#)!K7yU1@>x)WFMP#|X8(yH&v`CRE_RjO(pR3U>?n)!N+RZ8%#)*Mp-Q@z!TrSm{xXr98PNsH^ZJqR5hm2Q1D$5) zF??_BoXV>HvbKURUU4TXO|`Mfb(Y5js^b5C>0?>u7y43?q-EOtw7UpSVWqR$w@hOx zP}xp>GsD_xG0SIq2~F*f+_kKaJCADj&L<|nS`0W}I!yN2Y$+-(6PnNklZRx3=WEOk zTPoVi&?oe_@{@L^rs4;ohY>PyL&i!B$$I>YO}1nK@X5qSTpH(DMB`S>=YJGWt@$s4 z_c^4z-*x;%BAg7iA zJ7p9M54<><=qNmFG}qC#@snB7Zs`bfIs3d<4IZbM`-W;2Xv}T+m-v(*3sXk7XeSqi2TM_7C?G~nW@xjSDtdr* zoS7ByAvi`k3>Ue&10pj^?h3Rz58Q-O5v3g8e0v)q;qD!AN?SrA$*l{Qrf9$7MRRZE zHFHW=%pXhB%bKa;)-L!;7fJCM2bC?|^AujH^M7qktfxB94LYv|3f(KzMqt{B1bnc6 zULBUesARavJ>Ake!HTwOHHkl8D}Jttw#?^N%;Rt9@ z#?~vKIm^lJ9nB9bf%o&h^{hs~I)#+-ZM{&1Mw z)*XwtyY$r(@?4EvIyJ}Q>YTS)g&01rJ#}_qZ;Bb?Z89MCYDbAz6N?mk>?2xnNgbwJ zg)K?!Q6o$nm^KgvFb1vSTfK z$gi#>{Ow(+F+nCLVRO>$_u4nUSY!M(!3R<+QLVV^oy8xM>nRm}z$U-Pt!0F08GVH}W*)$k?uL}tk`^{2*#^>fGQ6(f_mV8%*PjOFZ zK4wiYzZOge4Vy9P?sU+_GE1UZ$W)s%Ci?1E;7iG8ZC~heo!d`wp^jmi+rnCyvCEJ}P)(trbFH`|W2c{R<(`+y zsXocz;fx~K;BAF(D3P)3MwYT`iw%^HUlw~t<+%+A%V?Ih7v>7@lug&3NI*5+4;MXd zOPW*`iWuqu+2ZB)RI2J>2A2nJ&iH5<)7@xe$@{mp8QYtwKnQGfv0bYXe%~?=eTwmm zA3rujD`FebkK&K2E%O;llx*793>};7r$ohlXZze%=oG}!7y_i)?51N3+vJza*m+(n zCbVh1P-q7-rhLyO{pd^lvCF1`a5VM8RE8F^0Je*?fXWSUG0W>#Uh@8MDY9!jCkg$P zxT1^Ms0^OklfiVU3P>iym)G~GBoEkLR{n^zLuubikT%XfJiJ?Y`gU5JDOzTd2C3p# z(lg3R$4yUsy$z@?ldCSS;9|h6=Ffa#*hvYM?72rxVbBDV-|kTDQstJrr}Alz+&{Hy3SuArp2+>LDlj|`uuh>^AFOHFdg(K8VE++7*?b_OxZIV#%kA+5-QruA6r^?#XHtZGj`Z^YO7N9~O%ePK$K1!{Y z+PG<3xvG78T&=?Q?-2c_1x_tVAd-KjN%V7!p-OJ=V_-4|TPCA7#5Z2JLP^emmQyXt zW1RCf-PSy43n^x&oiFR#Ej*8FGbnjraXLqz{rexHoHs9U^f}!)&}1Bw=||@Ys!L&SVGR?Dm#dO4royr*=&)py@KVbMLEA9?j;AYnBu1F z<3M9({o~Y61@wwjhsM&Y+2gqKR^3jfQ4oBtsI>7yu42s@Qh89U3Y(0INgBWR1sx@S zPe+&2CuUJSwJ@3wC&NBS6%Fc5pRy4x+m>jp@gc>9 z>ot;?91{2FnU2%sy$Rna_OKu?E)+M|cWn+TvDmb@sLolMmOn5j)hYrjo$tu#k%`BfGo%9WH7z%0^`w?^K6X6zG}A6=99i5wLe+ z`we5trh=|4L({{-se*SSuoNH7;d#EA#S|wIs=mbXi(YjRH8{_>l*q$C!)P!m|M&`( zl?o(Xeyi^t@18qu72`R(s3N+{VUm3aSFHFHbR^p`%TEAoIBa9H_T6ZZEvY&rt2gU# z`Y~wsWp-=(w{QZy1gXu5?{~Y=DxQbzHByMX#WKp!-0tTNIbqPjH+dCNM~E1Q%@4{TwfG6?Xg4JYfWlmcnMYy7VP_acxdUdD(9d zdV_QkfGNUxFH15Gku9C9(ZfBO7S{v|8*@ZgoU}2+XT99X5Zvp zX-RmOQYg(Svz=jo z-qr1^6`D9T7e8%h63g6_{VPlH^ph0CB`1GQ^FcK1R8jTq2i1*~ob{^Pw=#Og197Vh z!>e{B8_hQLymH@W$9R)Kdq&=_!#rJOjR(1NpZ*WL|zs;?*)7g^|%TsSMVLmBuwS1k14Zj_X& zw3wq^9O;)b+xx-IMR8^R{cV1JzpFySuj`!LCe-z=7f}0{GXuYXfma{v(xQB}9Bvim z%oR9|xp?Z_=Ye!o3`fbvwSp|Ns%KVh2wcM5$M!osN*=yrQ%;Rbvk>i3AQIhW(@&^z zvqV19q7@|}6*oC{x1U_J`Xfi$D3~H0?c-mN=;~#dZzq$$nZkWhh{!$lwOK5`_H;)f zwiJ`FV~z*m944>zkVhy5R#hv>GHrv#B%-?!?x5@$zIW(F39}q+W3JE&EKcVWD*3{I zyX6Hd$v*3d;T&nZh7oz+)!4TmTd$Jy&FM?11m3&7X43i`UeulPU10Y+(PncPsMGV2 zDLs*qbU2WGw-1#!`}XB%|Iu>F93e{;v#B9ZI+L&K0Nluf^L?_HD_$wT^s9sR#HLnzCF{-IqcV zWPkikfS~O2`PV)xP7K;+iaN1nO-CfoB^`AWQxgDN=j;EhysuO7Ci1lVq z{Kmi3Hkv1R5p%lcBS4qV>DRQP8CSls0eoN(A0O(GgV9^6*$KZyeY^}e+y~1IFleST z3hrn;t5we(&T^GAUgHi-+4ezQd2Fa&sa4I*n3D>8Uo@J?Ays;lI@XHnJIdH(qbhd@ zC1M@EN*h-5-`8O!IxAIv?Z_ZZnIw-YrA^_th?ja{eEi3w$GXqnlQIbvWf(ofR%ra%W&OChI7Dk0eFK z{5EE#fdkGk}M^4UzU%WC7k>3PG6MB_}4teG03>r-swru|iDJjK9j z-}a+BGwMrU$txEviTpP1iVO+f9QRLdlM%Blmqj7ygIs-BrP3C+a(W)cMIiJ_NH%QL zzkO|(nQw~{rd6KP0?M3Hf3TCN2HV(MkxJOV%FZd_O%Bo4dCOoYirXYu{0{2F3>Ny? z+C!e2^Ha708n90I0~o1zUfz0ltB>4@C6jS5rG#R0o-fx!eD=t_AF8hJW`#S$ zvsE#xqG^%WA|Chk!pK9VO|L^?OII7gPNz6C&N!}aCN7=Bu_9m^y!%ola@|Usj`R9l zb;1KTc|4G8=gf^|ELU9A2`!ctoq=gHy;toe8^tCcp}DDB%JlnjImj@> zmCb2?^7rfwds-Y!T_^TcYbpn7xmvEO&dF{hvO`0Qcz!#mAB|_sA4j6L`DXo`(QjGY7_g#*e?Rzqx>fC2=MlCO za#C@+Pu5GIxBE6we}fC~BBS%^u_l$WT04bBRlk1`EsN4^UjuY6o>r{_%rN8eC1L-I zJV*U!dYhoqm8?4a48~MEc;a>m?pcki^eU63kgN7lTC7o3!r=#J1Bad$NfdGUl=Vx~ z^IV)7*lW*ZE}+@;L@dQn#-E$xfqf1&iNH2t5C7z4mYjrLJ2J7FKbos|ywG?o0v|U7D3=IhI=KT!KCv3$1zQMbn7x48n zeTUWy?0vEGv(nC}Ptwkxzs^(It@KHAh?k5G&J9haok zqop>}_@k)#6K45}B?l{1@nmM<+0PDo>NtK&=HbafP4T&bO}qr16~nVa5$7F^tmMY) zQz-`8cIVDDCC-X|+~ZZdkHQYhg`*A?12JKYqC4ec$g0>wl&aOp?^`!y6g8^^p=Z@Q zjMHq~Um80r#G6wgAHQAYTy+vg(93@Kl)anQnsB~{#`cVUJjrWBS+26Ds7An1$)OdJ z7D46^p);v7N*^$IrDdO*B{xet6W2wxh+FOodd31`0P0vuM5xiFRsF?ZvusVyZ|5&ABsVJkO_FCDMy z>09iFwdpxIL>S@S_too5ri_B1cTv&5T8;dZieFcgahesE3RDV~o7I z5AIEZTOn>*zcfQW*-<^NCudhm$FU4AlaI9hKL95|*uE-Ml(`BZKhTc-$Zq~!kq?McZl$*VQJDd@k&STK{Q9f+H6grvBhWu9Tbd{;J4 zClb}0qUynmYgHj2*&4nc_y*PL532~GO??*{mJC5vhtZg zAg6p|dd3-^M0REH{wg?=iQ1x6n~an$dfsrTrzKh1y?hBYk0;4oOto&vl)t7?Ij+Q& z9(CBdR?|)L2Eix28wM!D#i7g&$F(UgLr#x9HP=V7gUSx)8&Xh7?0nBU?2ipT8VW(% zHGETKxj#YMcH-KC3#5g6=;IcJ%0u?rTz3#%&QwA8)^3?g?6T?IXLQrklH?cEfR%PN zE-H&tY1yMIUdX*EnNyw%T6ZHo{Og;7i#k-TS=6478n)Rg!27p}1;dh*p-S=|Rh#@# z8McYg3rA;N3zEV}!{{XV0c#z|n z-7;?JXoGQ#sTfL~#zKc$$w{Y1jVX3k(H#*v(DXo8os>u6?yYXjoN3T_R<@Q_?0}zX zTWy~7t)a#!y<1e>r%x$}^3o(bxKC5eb_4DeoW6}?r)5G;kk+?pZK@<^q&8K6usxH% zoofy~8RV3`mItEhOB7^V$y*MqZNEC4lvxq9Xj*HAjm);U`Cdw$lOS|fbH8u>>Uk*X z3C+uFvOB>WO5r6=MgTT`vNA~cQO%1@kQ_nMF>E?z-vZE?X#?HsF=dHbt5;)YeN zGT|x2+w3~_-Kp%N;}yo_^P~kcpKTxRYtNn+jqy7nH8rsZ5pKAxzgcxm071ff;)`pd zbj1|fB1=lGF1dtb3dy4REsm?9d!@mt2ELp0ElxR&Na#Uhm^3k ztncu=XOSk#KN2;&7RWB;zz9jk_3{2jN1j%FH;;uwNaOu=tDe8yT+5`O6Mt8a}o!KQug=4k?5~J=li^pe|mnm_H8hsLnq4OLk18VhUE)lbhE==a`BkCt^H`%N^jf^+*t2{ipUROn9 zSL)P9N}6e7Ju8#Q@;xSYc-}X*LtHK{NpV>ul4~rvoa9VlNJ8=cz5f6o0)nH=&y~xe^y$fE#*l&swvqa4uBoG)Z96i1?AK(z zpcY84nf*f}a^jC?3{_bi%yl@RkO?QSuRbtxbZ*@mCXLc9v;^60`$upOYWKV^4P*SD zXPxBv9+5wMy|V#=!vtp-+Pd@PP*je5IGo+c&#n?3lH#3pM4uyGHb&*M(~3((OpAa? zC{J3!=dB|}A7n(w)aFS!u6fIr%1A6sEkI(HKEhfL8%IyPT_mlxl!ny$&oLjyHPak2 zoSh?2o-l&HqWf#nmYW1(?1Z4XjmfU)`0&RYk;N|}Ss&t3bxr;o5){l(6^!JLmBE`L zx{2vvgqpb!FfNkkJR-wwN>YzO+Omsn(X^^Pn=OY#_{vP%h~{5h9@XvQ@soU|+2CgK zYw?LWb-LSZG0IcOl962*GRG36VGMK1_GX%gh;m;lZa3BGUT$AGu8#bEDvx9~nbd>w zn@W-Ol=4UE70-vt{M4oPbWb1P>*#5!^-^As;4;6gH^p&zepkr2#OlS0otfj(3y*VT zo$Jm=ZBiv|5Z$;)ZaZC8ar3Ql!Olu3=E*K5xu^JAkjf><1xf=u_OGPz{{T#la%Yj7 z%%{Z)>KP4Kg@M=KaXSWNiX{{TFX>k8&gBIo;An);iUYl|@3NhNC;$CX;> z?rxQxEuw8rSnN%LIdF~sRo#j_BWInOPEL&9iMo^4XL`G9%0b?_@=KJoZ;mP`rN(ob zqoYE{b{;fhG0;+M=ZTkIP-D$1I}Ft$st-kPZ~>bVnds<$x-4=LADwv-Y% z3Y$;`YW^?P9`KXztsLC;XTc>#7sL%h_3HSjY{?Q*{{Sk|SV$>tO3pce7#PSOe`?zl zc*m0_cYI8vUU9nBp`$-zuuW=R(E%*-Hr5+SDIr9j%1PTF3h2e-%R9ETWjxWstF~Uf z9Q3Wy@*_*tw&}l?bu^^5<`ahtY9Kb0kF$iF76_PAi4B<@_CKQBJeOcIyIF z>O_Sx4k6@EG36_DTLgpgHC$-}m9&x>T<19s37aw1wAzw{=degSWc#XX=?}L?J+D0} z&XUxNuxUs_Os8CJmCSphQg8?Yy0Cb%%MNmMjPm7%DRFydi4y%O_IVyzOOGR*C=9Hr zTl}jR3S;GD-L;inB*%uL>J*+(q@ZAt-{VSx%_TNVQx=vXxJg)FIo~Vg=mk|GcE{(H zQjkn_rKS)Nl;@xn(iPD9JI_xZ6G%`%ASm|(wKWiOzR8)FH)2LjvI$b3bODq0MO38f zktrnkF`GzCB_ybVPu^5%C&ah0%k7yrC)`=UONuAR44SvMvV9PGms5I*6%Gf}EhC^c zl;`Oe82dAK)h=`4^#v_!IZ*43>k~pv#(WeZrrUAn)RFXR-ja)x(O>v7648T+Zx5e%GyU#-Xx6%M;NYp zf-IHkh#}`0LF765=NnczFsVeCNk#17EI8(MHvzm;|PzASJ? z)9jxk$aARHk(z0E4$r!H%pnU6l0sEovV3D!al`i(%~fGBA&ZRUHkB;kwv*6-zs9n~ zJA6^DNHn<)xLKqwcNt2Yn2Jj(P#~yQnOaJP~NjX=Ybve04nlhFub~3r?ThzX2!D?kL z9;;5<^{nk7aAl`NTchZv1bK3huMlprjFX-I`q|A**@H~pbdp$pGg6fCczvALQqno) zc1ooUJc+AywJm&@Kp%Z`=g8o+ZH^qIj#9qpdxT9@anu^1qBK=LqS86}h)#CM?V93Q z6;kZ=d2(ER72DpZw!)TC4oX~UI|IxJ$HubFizY>A?(k=W6zWD}#O@0wi^WFzG&drwKWBDZxjf7Ua1dl}Abvps+@NU0aVQW_+tc z%(mj$<#9Lzr4LL=u+d|!_dDSyW9371fh%N!qY$LIAY~(^NBAs`lCZawwvw(~^{R{2 zFn_@@ZgKXQ4ynwiu09nKNtGEsj)wGPyfbvvNwi6pTWo-^f_j?6BtFN=mX5`{-)x#b z*6?QJ*;-TVfOqL!xh2I?I&s0xrp(_&>Dz|6y(<3zdn#KT{LO`Q$7-xt_^TFdw)mrO zWxHLD4i(7K5S-S{rM6&`Z$~J4OYzz3YF)HhXN(-A@~d(yC@-1sqpc-|9G_R zw1qh9%Tku2cQxok7Zh;h%_+Mf`Bv!4)tb{t%G(apW5h_nJDM936_lXb)0BX5*mbFj zDX})zrMNHvK6L0;vBPh@;-wBJBRR!Of~^fov`aB0vO~)qD!*vrS(hC z;S!g>#-ecgE;FLq{{V$@XrZ)nxON8}KKjb&)vMUNO*1JiElOBf$vF24c9|)Cjv9oo z5eac1sXte3g&~@*f{A!;2R!rOvQSdjGJdLiky7b97jB6?Im3VMpH!QK=_PSkA!RBV z&ycE%MCG)!Z`xajcKLG9>+uueHGnqnRTXZ`Tct(9@1r0!4Mnz++8a)CM^A-RmVz&5 zBKlD3VQIH2)oz@I%1KGWfyR30-&sfUogHzDgfH2~mnBPnLL8LSsKLu_wma8ij~%0# z%FRnc-Zh26wAycw#G7#(q1OTC!S_}f6njRnb)!SEaKh6X^vwM|HcJjIK&_N32tIpP zJhDn(i$=-{J4ZxmjuYEtMn%@;5yxCgIkCPE-CX|w9NAovUAfsU2)jEHGy)Jw$WGOo zgxR}sL}kZJSXu|emRfL(6qB8(xggEu+F-D|Kr6TfP;LUCw$5y&aDmSag% ziU%u7&$N^7sojgw0XlogAu&%cT%S6=Htm%cNa7q5UeV%F?o&Ych&nM%6423oYeE?$ z(a9ByHbjd9IIP)dc-m?iNe<(u=@Ic23}cc#wR}wh=r9{nBpLuI9jGY?JJOiMIdW;B zBw#h|1B$qq96uF&HmA@Ny^(gptM)+63NKTLNp>4vZ8mY0PQA` zX%=P?y>nQk$p({wRE(P(Bvz>qD%bC*{!p!B*rm`M)CC?Y@}N`}m6b=RumGIX5N6Uz zrxj$5Ql3=g*2_Y%Csmz=OqkHkG5OzFBkdo?vaOn4i3XcXX{sUYPDFr^Ks1{vM#$%0 zDm`m6RH%G}^BU4B%oypk0oJxkiEI_R6HHVg<7LE*{h?FKW1+apkH)d=zK2Y;?yX{| zmc^8ykyJ>7j#M^MLv^ca$+D6VQn#rXC_yyRupKne9cx&|iEIZPN))e&scx9k8oMVu z3YN=J5<*nrsqCice#1P2Caohj$4)vBFe_Hf(ipt{d)976q%~5CjYDN56)GXb{{Sdb z8|Z4|owHC<0iaZ>2FZAAblSQh6B#l3u!L5oeT@)PeO4S=y5_RvOr-e#aRIqz;I@eT@2($G^bB=x z8;YotB5*5}6|bW)tcQM)TlX~*doChrUVGG8VZo-D1`6}0BgI&u35?}Pz`!-6NRuPn zd;m!`p_vsj;1H|>-kL&egK|QiaO1hHDu`@*5;0Z^sWvo;c<2ZnDGZQhU{ezuE#0=H z*d#P@Su}<;ks&Q4?@b^pw=0fG0M#T*WOGlc$FrXGLM+zQ6(m$KqHTu26(b!01u=FQ zCp5q~7^J{38K*<&1GicPBO%NwL*8jIp_0~AdeRtXn<_mhNNkahAE6?tB3l-JmA1_> zBCT?gLx%=}gqWGO38g?Xp5k0q#)Kv@ZIY$zJJk|MGXYA$#UYYWAadg=pb1tXgN> zZw`P1l9+>~xrf-l++)Jy|C;MA!*VO#nD;plWP%d2I?TC`h-8s}LNt0C1B?V$Bi_ARjQQOk{&# z8j+4#YbQ9M2h6wbphT2bw-f;`!T?Tcgf_W8mfJhf#)>u8M~LA7&@rr7#lkkAMD#0v zLPbat?K0a#d{6;oPHCi(kxqs~OS+>c3ZjQ(W4AC*)}x46K|B-Iml4>ra)P_kXa{Wo z(Go)kP7PWyW7b#gR&5$4OGO}oSu;dPv;hLMWuemp=@Ic2 zAjOsS)$ue3pumh!N#dYsBmqh9OlU>Q3JTkN%IQr5bW6i)1Ep&do=({$J(Sawfg-ha zk%wIw`$zGvZrRlyitLw))N0Zgk_Js7q0>pJWtN5!SQ*KW5H_tMjF_@~>qH?&zkNsY zg=rqd`Uybn^&qp^6qp4kG}8b=b4*Nf(lJ`aQ7kixz`&|v6G94(O(d*rIBX?KIPPmV zrawY&ybzpbrLv4fx0A^U?60Qw2Ygu&pejKD6ym<^V#o2 zq$GyqlTa`y8VWysPx6Q3K;J_pf>lsj9z$m&ZC3?snKEgVgeT!$F;rm0B|qCVq{fhp za8#_+$75uOAqcGqBc(f>)^cT}HE3njpW_P6EtdKPr35B~KEkS3wSZ|hQi%F0xzoKg zM39u^`zHdM6iD|v)D$*xIW!D=0lX1c6hw&!SIUaENWu3Bd0!J*$?UlF849T=I9&i6 z#HU~;>)fg9R)~`#Wl0$)HL6BUkkhUq0Dx;miEM*%O5{2KCv#d=5o5?vNj%CFn*@nw zk`Mr>C~(_@r7#_}k|+UJ7s@v@fRC3oErY!@fUevwWkiIkts+|?U3j>6H9$Ln(Nm(6 z9Tz)eJgtqY7*Q&Lia;umO*8_aU{Fcm2{a5)Y$<@<_dpdbjAbRYvFvNwfdHzV3dwl4lqd|Ul@y1<;)RWsN`yyGdz>5^p)$QCr4?jT zOhFKW2I7XqGnRv&zM29*1RAeG_9}szLqeex06dtW0|d|k!&&V>1L5Pf0zJv@pbrFZ zK*f^Y*`NT)3ZMt^7Dnc!faTd_CmEuEk9?`XNi@KTlAcpd0~_@;`Xn+^b483@IRcQ; z;%ElIDWFsbCQUFFZGwAJunt+}pkdH?X#n~&pqx?yW+(~*kPnc7KoSuUHlPRUSVB6} z1Xizej_C%P8C**%kmg7|X^5JG1U3O8m4N+nT8^A#ZAfHX+t^M*RZIvuS9PqPYN~}~ zW3yJH)X_q*FIZ9UPJ+WGLWfgIg2zlrRz~!iDKcghf^m~sveK~xuA!F}8=j_(1YBO! z(J~l5t<7kRWIngXnQ)efa3Z}XLxhAh%Vld;26jl?>eKT*4vG!p=emb zlAv%w2cZ>=k+fN1k!QTyBQY-JXqypWe+74nnNMAcAS4Wg05kxjVKUwnVxmrdsYcg`u0JzDze9Kye9ur8cD?>=Xik$k^}ht-2$zla5ksq=xHNV%bRv zDOss(V~@!6JwZ=r`#R& zYit=3-U%x3*lA8H1F66S<9epV8b+7ZXhNKGOx=)#0;MTXoB#pTlZ}OAD`hGxr3G)V z`9`GH=@L<+gn&q`5;Kzy`^jx56gNVOvMxk|vUjY_QWYeVlR-2E0Y|WC7QsmRME?LN zP&d$NR(q5rM}Bp>Om^j?#E!RFQWEMvIRuYrZZ{ruaSI(pU?c;I+7Y58#ollsIL%vh zNu22cBVyK3|kmyLH*wP~%aHyT@7RyL0OT&rZ?FvcI-$ND4z{Y5^ zN(jrPZgr$Geh4ADq+>P&)9jH$2$9cqH7sHY9LmKAWTZCvMr&B3HYoZ^h6PhZja`nf z5l0=(M3He~D)uWUqQLQK4uSD7DXoc(CCR|XYj~q6G6rDObIk7HjV07(iq%lrLaIW*2K!h>x!00 z2DM6wY>RQlEbeK52piHUn6)>TMMxJ&DEcu-L-eAUg%X+oSC?u8cqbGLP1gcNCdQE) zA^qw~NJU{wbzc)mbSm2l&T&i{9ki9EsS?HVvN23lG?Ni-gSKb_5^cF)lZpgJxfw|6 zDcA|1^0+hSNC)gl0PW{Wg2{+-2?C{}lOB6cRFof^z)npjG7{}{z$pfrK=f55%2SIw z)~OKK)U5Y3$vl`sr^U) z0Mq2vLP@kl;?g$%07h*irN7}L=_$s&S*GJ(f4xI`i&0xG^Bd=3b5SNj+gg%#B`IZL zK1E?ebb~^!P5lG9OYDu%f4U*BHD$v0rhO``$k+Tm)KOk#`%FtjR$hYP8EJ8p0uQow z%GOk!loiZ3$!EP!Xwl-W$4tq%8R*ZcxaU7mU2ONuW|-0XTnFxYhf%xg>_urxJ`z>S zo@Z16_Ce(s-9stPF^9=@(Q=xCAMwA@V^r{N(`MGN^-YIa=9FPCGf$1vtV>EtfJ1 z22_^|5@b>q_9T&w-5w982p(jv7)ALmG&=O7x_ZV6R z6iN1WN{9ys1H#g^uvrsy%GU~g9_^e$(r;@$OUA7Wq97(>pfJteX)@k)Bq*N+11Uxn zJ)(T}#`P;3lD6n>N;*VW7yTRczX^5rozVB2ou=a(S0*#oTh+1UKL%S5xDc08tOK!7 zBx9ij5(p=oE;&L;KW31clCu4F{mkuGA6rY|`R#H^(S-1e(O-&OTjLeeg3w~bvt9J*mT%H-Zj?s0HyO_j z<+!wkXA2=CmpLjMgyljb2RU&@lA45hGp{&pz&1EF=%wi^Hp#_JA+PNB%PqD$6ZGuA z7&QEMBo|tBA7J73%1%g7Rz+%}qmE5GGIQmUHmK|*tGxQU@1;;yjb7MS7Qj`h=R zhjY{qEe3p`GNdrtMphGpm1GT-jPk3Oo*4NqP0}}>RTsr8W6gc&)vh>c#JxMiyVUz! z#x-){D#?AfJY-wvMv&rAhuc^HkP3!IGti8Jl5==v2`Im2Um}vTP1iny5_oQ#^i5;w z0mEBm+RYJj*|o@?;FT&mQ;@F=B&jM<*$4qjR>uOjemjqC87!&#Ihs64a^G$&XsmR^QFu4#yQsLUrS6L z<>o?pxso2pGFODe~-l&uT6;p{{X_M>y>k}Iuxg+G}@LP zQwmN}ppH!Ep$bMbnwa8~zu>o#D*i?qUxAma_XPD%9Hic1+pOAhdltsnc?&OGB{|EM z+Q7zA972wJ5_?v##_Gv)S4Nj%^di)At@bF|vx_<#NouWA8M$_CGj^D?&3z7j^c>|$ z4Jl`2r*cl;SQLx++b85pqNBpkMeTdUZZTcBBO%z<4Mk>VQ<76S6(B8wkWdOUo^D`L zq3n@^oDoD|+o8&7D=qq$(7#dI^bVlbdQXa4A6ZJ#?3o&h(`24regkO)ty#tv5E8O; z%d!=Wk&15{O371A(=GfY^nTF#+t9C6>Km4<;nlADKTt5HFSmCJ9I~{R8$pcw!L=== zI1*Hpry!-&lZ=|r<4z5_?7nU@Mmwf$99whH(_7rFdb-@sfn!$2V&!F2AgNMjl*cG} z4|3%w05!KT`loH{7^yr?o~+%te2eUV!yiLC=Bv$FkmW?Gv03ae|U=7#mjI5j@E{TOyC5_YkeTeu3!isGNmtzFcIbmS&QtVmR8+ zR)>(FGNdRZ_5>V)0R#&8+Lsc3MB~WPW`5`PvXJffPHFxw=nK}iu{QLFbgVmql{svn z?Y1zN2r2eXz^x#tX0CXf>Fmv9MnA!CM_o(CNE(AvJ*jMZM@s2bv~Ks?>*{JdD|KA0 zw2+Wgw-kG9Hv>6RLFI-wlHW+yQ&Ai7e}dND78^{f9~QKBxr2C1s%gsvr8w&xgahNW zQ}kKp_Hs!$J8e|)ap~BU@3Tns3DA~}W9cQPKQ7L+G{vEAT#*Xkq8B~Z+gFC$3FRSf zC0wrH;BvO3+ZEA<8`&8p_?DhGaLYa$; zQbM^>vXPRU;Nu`1jGR_-#?zvdty!wy?Hp8Z(A!Gf?mDvG_JVU)yv!RaVSy=$!KnpL zDehdU1bCyDnEhe4)zG6Q1@vcYnLVWa2(>NePHFp|ui~zT(N}$7!X#%2;BQv@MB5Q!BAZcWOQof> z@GACH-V&7qzCx0F)=`tiH)yFPk~%le7R7C6Pm4RHPDG`7Z*((vAc8Gz*H z&{FfG!fge7iFGO&IKyrZqO^udylzq=QHq*TIsX8L9)}mMAaJT58fS4gNa<}j{mJMu zpS{Ri0x&@!D>xx)Qm_(%xzB7?aKhTLJ^bXZ&c{)9OS5ciheX7-BYy6S&FZ41V6nZ}K3ym7q<)ZAZM6;Um$nJ8U;J^`v-H zWV){$s(57x2~$huN_olVBms)oENi1Ya=yxS!_baZkxbZi@1ze5w2rWm6}eyB{nqBR zIUk)o$V2Xg@;0(Du;%NrBLw3tUYkjpEQ``Pc3f4)mh@2K9}Kvr!>wet<_R zm=~Nh6g*?x7*sUARqKr1h;5q8lPsRHM+-3Oo?6 z%|9wEst$(KRrOEGlVhTO(;a2NLKJ@LmJGMUZN#8u3i(h=9)PdSKPqAll&GJoepCRc zO0o4%%7F!6FdtO>s2UhaTbtnu`BXBJ82C=DUr}EwMWi|ml&q+r^*yMeilNk`#R%{Kpwd`BG&femj1~N>9qNWuiLn@|!`zPs)-gq+BE|OF7MJ z6hjy&lfDgE3?>hiP>%p}(t(~J`A`8ce2oOr?fvux3O2O^-hd>cy03jEQY4#@w2p?P zpw3J<=xI<9vLuzNsUlk%pcNj5m?B0yML-Ty@~CF1i>f)t)jujoOdyV;c1ihF*_#$b zReoXlP$9x%sE??ARDdvsqxKKVoq$EcU*;c`AP_e93cjKFQ?L|GwSSm?RIFmiwkRC( zAC&_fq7s0|Dfv&knK^iU~pzJj#dz<5rmxkF&h}4E+u`@4=r*%Rdsh zx1+zgO(~&TpK!X~Crn^P2r%AlJ{yTy3mI?{M#)G~BoG199Aurd9FmNcL~ZD8s`Sqg zxVz~S!^BY-%fF-E zmXXB2L+&u}dxp)fD1L{ zRN-jT0<|)W#`m570P?z9RpP57Tj@jto{9BnBOeSBD@p$V*8c#&qyGR${{SY1!sZ5| z^t<%E;f1105%ngt)7paHV@li&7i6fE@+C(b<;1M}kfn4LJkKKw|gkRMaz6bC- ziu@e(GxU^`#QiC7)1vilfYcask`U_5bv@#`5uAjd8L$=6T&EeuL}4i7mm=pl%OrS{ zx*a2keuEq@8Y6&KjxS5mS1YBu^Ja2Pl*zU_^o6>Ikkoe&rvlKV6Of`gh6mO(FUu08 zbSZv0UAnTZ#jQ=m$9R$G{{WzPhrx?q4r6KSgjp6y5hgA7JyJy02P>TJEl4R-8zn?2 za~z7wZd{`oDxy+VCY_n*r-O@MrKb?e)>M6RD9Jh4Ltp{&sq!E9SYrK%%y>npEm~KL z8Y@&^fc%+f)K=N^a-MIXYD;T#ZvM(n)ew?WO_wEUqo+M6eHD25#7{`QQ>=7Gij}DB z8i``_ZM;R0(xJT<)zY8?r9mM;CzUBA6<~7Y5No3@Da#{iXv#B+g)uuWiq$-A^aQc! z-WFP2z2Ed!w|-6T(G-IyHtTPAZ+K+$D19nYG32~`Rbo_LOesgS#@dccVf`ZQb2xFp z{{Tk*4eJowI?mAi+m*rzbt`%lc@n~!OPD7a3gyR}N*$@>Tww@4#U090T@O7cUUfgZ zUt}q9K)0zhryGKe|z=rQJ$DA?gddwDsY&{`R=C z*=Yo?_^ETlS@$5;iSf+Xs_~J&nUL(<2+_I+(PvLfOxV_GGPOKijXm$BGtCB=FzSTFb=iW}<;_ooLkU&X^RE5;;)sgz{Tw zkb$~@7(1MWV&tvbRz!5EvX{UOU90tvr;fPPI_FNq)B22Q>G5t5V7=lr%hB0koTXr% zY=*(eCv!?Ixw|Sq@ITXJxAVtb)Glh_$q$C$Q%sP`j3g; zg4|xvS_;zr^HHZ(+h+buiG|24WshtlsUJk=^A+V-!8ziRUD>pnhDf*75ga^eL-#m1 zmfFDtYxp38+vwua1^t))M>qY|{tNdS_)o+SNDc~c15)s3O~};nEjme!IX$QfLW~*g zrL;I51dc#dg=I%!$_XPNon;p|#l*%kQIxE?YrCzzU%D5-{UpV~iI*)WV71vV4l=N? znXR`eYe6Ha32_I{+Q({b{{VIzUOO=A_kuXFprnmUr{q3eOw< z{{a39Hfwy0qh-! z%|fJI&(w~HS4#U9>9mOBA!~X!eA8Bl@vczZL1x~z+*xrhoc$LkHcorYIW7at99ZDmotzZz3<+ihr0I;krKzlsQ~bG}&}8e-Ho zTYWQ}kHZZe!w*F}L&z!7R)pR42ZVB$Zt{Urv+qb#icj%h1GQ~9@k$>=LGo@wI?2M% z?r`Xog%Fd(c{v%_{{Vx_r9b*#>NxKw`V9Rb<+`syZ%1OM6hft6vI+dzO9SLKsmT8T zwG#2K?nr6rmg1Mdk47b}M5ySO22SSyMgV=nmT%b~@H{`dU*vWBmyEk7(k|&8i5>%v z=?jt&?s4I$t$-DucUpco@BaWm@*m({{Tz5L#P3J_1;_nY#w{}^P1+8JpJZswQc~Rc zZiOYV(aszNSV&OVmr?=Vo;XVylb6w)(xIjnE?+hprxFBK?ub5WgfPN5vc0zfHFKkG-n zo-fK0itJf+B_>M9(Aukk-hn#1OmSk;?Sk{IwS*@umZ^j$N|M20PQBshDIBdWCph~# z`pL~kE*R=w*)6F~*U>q}i{+n!MnYiSf=MJF(4@+X?e#(;fBcE6p#VNz=AVUwJS)N z*B!GP;0^NY#<(7odJZfIHohTo5wzW4+S+|654g;U4oZyD)NoE+1FqpjlYmIZ51%FN znoV)y{T%hJ{T{f-!ksS*S8)qL+$=WP(^qd{b2(D7@>9)%-g&?vD+(hAl;G0f;;og* zNzymJPu(M|FIu06d`;7qX;U=a&q&!V&~EXtrW}}}^3c#&J1l|-9#vVdO%sZ?nX1Cm zJW}Hi6YW}0(u2@m-F2OCQ!p<2*54u6e2gU_KC-9TQEh5UKs=#foN}ZMlSN8$sl)w6 zYAWF)=hqhW_M6f?Q`Op6N8LXuSnU_7kgd{-fzK8@Zz(8OIN5&49?;nJ8ye%1QIkmO zi)|*#pg!7vls_6k$W;zyin58DQyYRsG9<~xC?OOOi09nNs5A=T%`_poAtsq2+jNuG zm=bXTBPOj7D=m2D9`jC2B162AwHn2vWCB{ip&)EyJ-~#W>sX^U%Du);=LWhWjAY1g z6zi3#nK^BX$^wY2eCRoQJ@+YY|{|0 zHU?-A&P)8eW|L*1f}H19T87OOMG?w@lSrx>+$RJrVJEq!g+wdYHHBmvv}VPazBqx7 zYE1}PSM?F~sc{{LkAERss+|hS$alup04k_xuE&nZY4-96rC?WX4X2-PI<(1XiYWoZ z@v9_v8b^jk^qA2y&CMxqbyiIpCPH2=A$b8*;}C4DJm)%z&2E($wk8f~k_Z`~1Eo8P zMI-@5Fkuv$2?z!#v1k$2fb5Zmg(!?vv5y=|ket#eWaFyI8LCK;5K5FjG{A7nd(r|@ zGkXoHSnPA*WKcT}+nc zL#U>iEeQl~R3T)H3YJm zq_Q=pbr%rzJ)x8V zvv|{&iPpL7AEK2CLfCm3*z&CeD1F9~bjMbK)Ow>)>dTVu`lnD_uQSvF6)NE^$qtl` zgPmlnAALlm+t||j5xweNL8#Xm%|m{;-4_ZvVn$TiOMJ4zbIQ^R$>l)F!bZa;p~=3+ zl>>Lxnxg*zc18aCsVM!mNRozo@cuY{_2*G=socjPLuRsS%T$*=#3bjK!E~V6Za$EDX_Mo|1WMkHl9tM4FrY%3bR>YZ z5KdC8gPJ)t(CIKN+)3Bk9f>jYX1UZB7UqA9BH43#Dqh7Z#tOHQR$T!DRx#b zdgEALS8g|LS$LXk`&*2e&b#V+g?$e)kB7Ji*~Z{iTYa;pF-Z`U^^UHes?M{Ws&4W% z0v|+#-JP83<_BBAZDHcBaHNE!B3#T!bHmQk;^j(Jm?Oi0w73bzY60Zn{5H-Ka`A z1CMrTDLCyioKx&?a=zZLS645$i^S>ICzc&@WSI+f^{jMJaYU${hWYJBCf%^A(Ee7c z)mMx9HC5MA-Dcj9<8G$qB5RIHO54YVpz4WODdkQMcEHC<(Kg+YNoZQ(b-Ui~FJ5m~ zNtX+Rm3WU!l=_`{)nge_)JloiZcl3IiuTAByxtyQG1&s_ADrMlTBEGeZ(w@h*~g#_fJ zsj?0>8)l*{u8rw6On(DV>L}JH^wU@SlXiJ;2{J9|l;Di>!x(XG1InciQSA|(g=rhA zGL<)D`yUbY-ic;I8arEGtWC@R02oEG)byq0! zTy9d9=6ppLQbNgBGP#a-$Pcd*t&i zwE}nZHKseg5h`Pw{-@Nss&D08SE#OcnWZ5fvv8K=mw9}-+$7_FI_ST$E9hltzuq+U z-ZkS--R9dT#$H*K4fV3~WP*}Xv=E_?NZ9lyvU8_pRiTNx+)cpU%=tdNUiE`3#aD~s z^K*0a=RDlo=Q+;xk0wvtpLVAIlpdWjb*Jb*WnZp$K^YV(!3$uBg9eV`>MG) zcEplh0IT+)nPiEk<=?I^S|GTmV%yx5wMJoTB&kSfo>Y=a$p90RTSYqAKgiK)2u(Mj z4>MHi85TBlyVvWBmT2#pEZdbSW-D(HL2)e;$QDABIe^aR&a#}_(P?`e*tn0xEi-J9 zW79hCP}(iB$uc3qx<11W_Bm)coF zjkuGPsVW<#K!8CTgIYp9$!wLo-Y*yHgV(J=cA0ayNg%y0W9xb62mvFRYb8p+0B(8# zTQfi55!X#us9v)pO1po!xn_?cQkl0ZQp{G~IR(VEo+$dvUyR=cRZkE^{8#V8YGs&-8D9&zC*X$uUdlT zaEWPX$G5R6TaLF8t-XelqC;ueY@7{+7T%cBOQUe~DB|Xa;LjBA8lzv_UWIR&rS2BS zoN6-OCPSsZMDm~#0p&aN6|NbmO4*KRIYyD0UHE~obrqg2p41xN{{VBfLFM&WGcHd( z9gGYPM%JQ~;A}7jX5`wY!6kNvZfZ?L?S-u@?fT-oD>4kWt*Vr>6%XK#6)k6wFA7lR z12`wni*-Y#b|GrI-E4OjF4jw&yL{-%=VDApl+&#%%_~U-C*BPT{R2t%TOeQN@ef+s z9^&r5zQ}^)mYAD%nDf^O5n~m5YC=|`rE-EuNITZhxjU0GmX?iQ(z}bCJlAb-{{TdA zzD>$~gNM3xyDL{Y?061Ma0G=cH`OV^6W0eNTVMipoR*UGL?YF;Vxx+jON(Mwl7qx8 zO&-Ri7R|A%w1h+`JyKZ<Ee*NP%6l4shcvvamhejK>#4l?@=7Tj$^qLQSL zLHCLxt6?W(_N&)A%UHP7on@=9SLdUop{Fi$-IS)%dW4r0NE;57ZMWGeeGpd-W2$7> zThedpTdS5f9r4<>u49HG9N*hZB=QA&O560CNfAcB~d} z55fGM`D#zAczDMzh0n>$jj@bU=PIi&jC-Q2lZwySFhahO1Ng)7rXn?#irgDkgJqK3 z$A;K68MY}Y&QXAAFp48oyqc3lg_qKTMsA(yqC>_7N)<^7lWZrEy3?XY^Ijb48SZLj z*y4s^X(u%%fn9VZ2NWV%U%E-^0j=PS+ba^5TwW`9qZTa&FEW85hQT6nq=wO1y_S!2 zb2tF=paZhkwn_7%#6M@1J5;iRzS>+)DW(k&vhCdDkSfz5p_8`KkF!p}Aq7V$9V%I* zSk>%}s7P&wh{~K;+NjO4%MFfIbg2eRHGq*!kz@?h8x>ALphulpN=*QWX_7soy+bsL z5ozJnnuctUSu+AsKs1Y@9%Q1o6~A*-krQZSzi9QVFkvx@c1;9XK6Jr}hgOrZr$mkz zxH#D!(WKDRqILz@N&ppBZY8H;@?H*anh-KA*D$lcdeDX@U&i^S79_ih(l8ZEjgH9q z64v3|)g&gy`R1k|=}iL^^e_nNKn4v2&@jmq1qy`( z&=e?x%xD42X-L5|0p}fU86=7VhELp^Z@mMdi`SG6ilT%vcJ<_{bOH*z6ZWW}u_auJ zyU|0ip0*X;rnbM)X*Z6alcH12ooEMS&p72*%Wae$zmW#Q+Pe zr70$WE7wJUNEFb>))1w+x1BK-8+>d4NT~u%auC8g&@v9^cj^MFk^;FVa+acVRFJG{ zWGMHdg<%x(k5f*CVG7Bh0ZNaZ30GgYi z33k?Nm7R!P0I#JL4HDaw&)5w0(pRm&%4h-%Y$ zkl{a`e;U##()2x2!V^|zMoW{_13^g0-CmlSX6I~EgWWjyh4zx}{ zm5mbST~7Z1Xnr-$-pgx3K<1?}j^nqT&20$T4117)T^$lLkpBQ|))SF&LnSPeSlL3% zAgNiaindG9D9Qp;n(0c6*hvq7F`80iNUzLynddkANAav5XGD4$6PiVaPV@*_0)Y}B z&}4zgpmr+CIgM0RlGy!}gp{9sZxm+w8B2e#H8N!+HesUT@@itNZP6-(29c9mk#;ef z{{T^%%1pF~hg{}YTFBKPsi0x=fl7qWHSIi)Md6W(+#Mw9iZ5W`A*&8X| zWgY5SqC;M4MGh8rppl!qs+uK_ZS3Ucw2C3JP1T0ms$xiopCjp2zjIkh?9x39ePoXG zkwG4kN_y3#OCT;!6=!)0|W?gF5~;29U*Jq^-o0<|txA ztQ3+l-jKtE5xo>U1W6qUqJqN(C3FCzk=tKkMT&+}E#QJcr(w|)^|eJ?3Z%lvP_3mH zB{az!jaaM7MRLZ(ss=> zfyidJ$yxZ-anY2eV24IJ(L{h;rU4YZ&?dymsw5ydJ!ydIJc8NS)U*kbP0T6)W~Pd< zCs&mpjWIC1icqEk4n|tLQ?Upt68x#yk0v7fiUuj_YVAW1AaL1Jtq*C;^qh@Y)E?11fVL@m(W5>Vc0f@qr+bLlHC< zhFjYeB_u>#ZU=A`RD{axsR~giHAxAvl9Wv{KnKo%JgNW+0PrMG0)fq`P+9I{oYMhz zmr0Eafto`M1}Ff-;XqhmoX`WtQdB^$W_2QN-vqght2S9=g>Oq~1g56NWA9}H0+1v~ zDOI~>0%|pzV?t!+pr8QChsKp`7*(U%KN^;{2=G9oh|dv<1Q7M9WgrQ_%}Zk$Om~$g zvn~qC?8h>qD&mfXq%sG3qJ~a>{J-TN#E|M@D#>J{NC-}ArYelYBt3zQ z)Xqalk8#pY=DFLmM1rH*B9aH9P9s}px?qf(9J=5_Ye%6Gk{&8J&0!~Hq(r_+dC%n^ z#+Rd2(48TnL?(b1O#&ZKXF#N6&>ausw}G14D2Btj=OIY}?{o@bH#p-n4f%c4>XAt(yP zS|zaZ-Q-RxSVa*IEU8r{i3R2~3|VTWWQidh>#9V^nTXFKGg~7o5uEk`8L5#-g_z+} z%l=WU`!rn)mZA+%#GG*Qb*&o`4WP{rGHEK&hP$3o6= zRGBPtnCM8@RglB204(B@01}<(u(8`?YGMlU!e|;H=Q-DUhFTz{tdeLg5zefNV;H)k zPW5RKCKK%%W^IF$MFpOw7J7iN6+nUzbCE!(I&+!;aMH?1-jxh=&@L+!fR&2`s0@mh z#y@V*6h5snu*$L|{hA39Rh$pAK*U#S82YpT%0;xNI27zCV5SRd=}y57oH(W-Aag*h zQ3@%bXmW`}3}&W>V$HZ*J!qh@!Xd5Gu%QTl8q7%qrket09jqXy+3!*V)ImrcC>SO( zQ`&*p1&=BPVO1Y)lm(0>Hc}4MiXq>8v`sNFy6$8TtxkkT%DE|DYMMeK-;|{jy;Tav z!B7vD`~2$*E&PGOh{bBbubW z5OU;|6TN7W43ApLIW@tLMBmk6*SDR^V_GvcqX>>;4wOjA3w94`12TICW8!sLzE6I7sR$P5#{A({p_2}4M zm=ZZrUan6jl_Td=1|&G~B0P7W`k*$Y&vh9>P7|8+e@*fJY_|GG2cMUZ;)$*y-&(XLQ$ax_IK2D4qh6Pj zE;Eu}Y+f`uMlbkBEbC23tBlp5D3*MqVaLv0v*x^vk0gqQx72RSkha@!a-`!K zuP@Kc^G=sY=<%^4k1BeQk7(?g@!r|%V}&7|k=4n+!S-@hDXb6mg(n8qiq6z=zwphw zh1y9FVG+HK` zbHYeKJ-4huj@n)m&ab#tEfQW-{&Tfw$l#)HN?9GgTo90x;UI#e=Usj#Cz^l3mRyS* zO{A(mpS9;?gr{oyN?4+K4)aXr&MNT@Q!lY?@!rq)LtyXI+75l?z+rnJ$5hf%T12 zjj>LAL*Aw{ZfvCCD(E-sMAsgQz?}9~(;;(YbB>w$)?FPnMzz6RF1x;>jU{L$sP3g* zJLbAPOn)wD{{Rg0{M?*i(b1O)G4$Poln|a&e`R(}tXSzDbRzTRvzIllq;mIpaC2oL zM-}8YHb2)7X z4P<_r^*k(JB(KrM=H*dbQNC+?{Cz!VQz=kM3C1hb@-i$@qs+mLZaa3D?Q9=&ukwvdbrj9w{{RvO`4#8LWt0^uTL3)kqYRQG zCqkF#U);u3d^$yX0RA<9KCiWeUJ@8z-X3JqbNK);aR?d?V5?6gd7&wOTKeoz!uf zwJ(-BIxWTEfRmLUJl8z<*C?#g*MtpzWH43`=S+w6qowP}oku_4l8B zX&XjTNo>KjWrJC8zV`cZ<-ZM^id5UU1wJcz=xe3I8CT@GGLAAQhhY8LN_|LQIiUPBaQsHc;tNNUm)W>5a;+Wh9;RR^6Gd z$C8?1=8}|vPkNZPofkBy+I<~3SEYD}nK3SNnr1=?04ZDhjdS^aOuTvwSbk287h8HX zX*)DjM~y8`$#G*TLES)}-sy@6@aBBg!i9LE?)W;%hsbgssIl3XVtDYKCpM_gWMoQzRXL`d-+*+2Gon-pI z+9UC-Wsi={6qK}O`nyb7Tzx29X1N?#1P+5Hp*FfSj+GqSsyKRJ$a+djy7=N%7GnsqxL2>Svzrd^s-9K|Fbe$_JOijFuxWF_0ue%o|-E<2$h9-^|TzRmtP zrKT-!^p}Q&ggWpe>YN(WjFFQ_wZZg;wz|+$PV*^S9Ab)+6(&eIuPu71f))@IMh5$j zeMFbpaeR6+oq5BiFHu}^UWRxoh z6;u`x#}@ClmC+TVY_(Z5HSTqn^4wW%f>5Ur*Eh7Jr?25yWy=W5jE%A5l-7n8`?HHl zY4xb9<3#aOxP&r0rc2v36Y$EJDo_g89QLedg-d48$xeV(>2FHQp3+LcwuOs~bX&=9 zV;h8&G~jYRG8LVU^{zDin9fVlX3{#^L?;6d9Hn^1PkJYg_Dm+%X1k;$v2dB|vl}6z z0*6h_W6`zQZuJ)5m;^a|k%sFTz|X`~r)y(sjdwsB6lMf=+yeudN(UsGIenS9yRkiO z#SKMcOO~xM5pR`(GOogsmoH|k8j9r3WYxSN*W6INF6nxc;5MV|pd|kQZEKGT%W~-o7&yBN#7+)t8=4(y7nvRhF)0LdZRJr6 z(T>{LyzQ!qh21?J^{gk?A-QRA=eQ}ZwdLbz<#=aynMJ>7jYFrFRdR%|p6(}f{OfpT zjQ;>>jIqu;Wo7)8V;%8YnXzTD$dCd+&r?dkGGVNHSp=UdFGD1wJ01&vNHTi$&1E>b zn`4w>wl{u9jItZqHBnTyXEvMAX4*@jAdhSP_o^gu9jLLE9FUG+4sqv7+Z`kY+WeQt zhSOm<>PFZe>LVBI6QnI?n7fLT8Kybbq7ncZ$*G)cW|5j@x@LvES{iCxSQyDFfkOoT+i_`z*kWTgM^d!d&AQF;(HHoBEl?#Rwb(#MF;ST=*Sl6ovuZ}>k86JqRC~)gPK9zTd2_U=q4m(1uG+E z9>TS7c_gvN+2?uQPs5L0v#g{(-L4aGBH$bZfGgU|l0GISjvb#Yqw-4F>fVL0$jQxW|+2noH=DRFq;HUPPWroa@HjU{!axM?;+?I6D6T7}pHt^JSEmR(pOd6mdrW zk%S3KdF48zliIhcH(Ltx<$Gro4fJR{8PnqLd`y>9%*=iAd#a*OX&BAYIYjWW%G(1#vK4k)n z&%i^BvcA{=8pqA@Tz?3f`1njlP0`6tsmB$S5>8Kg@uepFJ!s=eXlmr*(z&zd2K1K8 z;b^AMkhvF`r9}S#jJy4FT}l23)-a?>MRUMxFQGMyb~+SpQk-7hJJRSlkC8Vi$LObe zCyAm$ZF6KMJ1HegRxkx)1m^go&XeM;o3@P8%vmj{acKc~=212EUM>ZO2=Y9PyyZxs z@t256wL*E8Tp7UtXRUJi{zFTIduLaNDfX-gYyr3ptOG1J{&NepWSIzDQ0d8bAt#oc;Oi5-VL zz!~peKbf18;Ezwn!@4lnCoR_$`->!~=X&Bu^-`?>Cvu#Tn!Y1&v1V_pgUq6xmAMq{ zqJAYkkQa;E?ovrV3eHxT`QWT~n(rt8$~7 z$Bk(2WA#ZWZ?9^a*ogP$WEB!N=|e@u5)ooa)mOOoSb(T4e%T$84QGxP(p{NOOB7t0 z*BUm*4@T*>+XzZLHpg#ueGUk$5IhXid8bAj#!YgmavhGt+X6<$yzeI?$tpYid`c>e zG5di)Rz^uX`|BPgj6Xv8L#TL2pq$p!xdw0Ru*Q1IFBZD?eW!r={WZktqTkGK}gKJZAo=HGT z93W-1d-9}={0Xc)nf!2OxFGV)BT3eGHva%E%5}GsA-9TK3JCT>Qk*B@xfRRfT=Ay# z&YZAVrsLfen@nV;`3@qbsxvS9DO+jWE8m{G<7(b-@p`sriLP68O-8vRN?p z`Z=-f^Ld>6>L2GF5~)jLn?9%!+GbkZQA2JYXE;$R8>*94(RXJ>aI;ieH8Y6ywl_;5 zv^KuP4%Fb|$4a%4sc6rIBbUFp`)-8PGa_o+ zW1gn#MNp+78Cnzuz?1K*oaHF49fV?=*>LoG)liw%uEo|&GL|PsQX(nLa*rTrr46Fz z`NEf?-1ex28g#2%6a+_)Azm0s*+VC%>8z!#gka^QT%pJ}Xy`2{Av}R(<8_ZJxXDYS zIl;l~mX!=TeRX+D8bO4NFV3xegdo0!E>PCoDb>y5W!Mga+T9a22&9I$g=iPeUs8fJ;buSoqDd(+Ox)6yDpOO23I zo`>Pqv4#wjlC?o3vBkFR;eA00<9NABxk*wIN{+y7iuw#rFiI%#GF;t_VKk`Hi%y?w znBzYha(0PbmW@inZkE{m%!Ig-Fh_if!x!NubWieBh$vAUw}OS^J9X__N%Av?;yr3P zePf+j&cIY{4eTt7a+)CsQi_$h+M0i2rnDvb66B}Sl%+~rhY3jY^2Jh;Gn863ZWHkO z>tVV_yZYPBOkM&|g^)f69ZvPjk(DNBf!C^LWr&?9Ar+Me8V&goduK6z3#l z;MYtrMoO8-lgxa-6{5{)^v2Z;a<=M<&rQuG<8kSPytqw%Q6^RCk*N|v4RZs6cj;EK zH|*z@NPQBpJt@Yc0yWhk0FV?(=~eMd?#x`^`Yl%Imc4J_y=|P1V(L!o>T_AY$FkM> zAg>%had2FNIkb_2kfiQD9}16>oua-uKFk8;YGa2wh3BL;U2R09B$6;a#=Qt+d87E8 zvxf#kTyM>4E2>O*1*N>8pR2hYGg>H0D{RVAQhGNI9cai1)vT(=KzN9O*0ew#6j)Dhb@(qY~pcAKG!}Bikiq10&g2TDW86?Ul(v zQaO)N>-jR?Tkkxj6&&E7?5*P$(S+x{l?hk*vt0qOqm$aUP)Tgb&ybM(x*5wUSVVK~vEc2jt*X^AbR zy%nUWC=fuUjk}_{TRFE>Xrj?nnCay?ByHE-U9iboXEd?$+9)eqtU5x{LXdHa=t|X` z?@UHy_a5a+wgYNvHL*8iRRol5PE9chBcCJ_k1BL4*(S!J)HdiUgBo&!2P2dZst;UL zOAIFNNT|+G=tj_8Q@q*Av%YGil>{ZSc4JbKj}d7D8Tm?|b)u&GC#n5D-%oNq#d=yp$AICXHJ z%IuYRC>@8DU&Ho8%9llvR*g4ei^(EOeBgbe1ykW3iB3{wM^MkP%S)^=DG6Q(1R9An z%~hic)mKZ6zUkq$F-mN!ZeyBD6lG;|X%+V++wQJ-cZLw+71V$T`^7E}JBV}TrdPF3 z1hj?fGUr(k7=M>JWMF?crB**Kc-=@+@uM|n8K|^;{WURB=OifuB?}!5dN}f|iqXT9 z6UN9DscoDL;B?JxqadusG8dN?QkqTB3;K%Cu2wSVz*4`k>`@6VB!wiUXRRx+8kMbU z!pFE(2qW=Jqy%|+Q?ZY%j=5-%m)TGYK?(=oQIl$l$EIx@K6*zGZmmMTKBU2EK~AL| zSMIJi6&Ghj+p3At7u#lFD;AkXeN0;MX#|0I$=54XN%WHAs3g(=l_EJJW zSZqP~R5hZ5F%OhOT5a*wy(ys%N34p%7^6?GgN?2vU9z2 zJgM|(qArxJ#DiTCPH2~)qB$8kp<(+DR%Sd+xO%!g55KK=eoJp7N3r^JIXgMGUQRDM zQch28tGC64BiqSQNfdOu$WGqs?Qyk6N=SCY;NTqOR&6wC2SqM>#WzWWpZY_e)-~#4 zkM`sK5#{BV_a**VQ6Q2|aqg>eCy?QZ3iJ5ZZXZS1WzhZ_)~w8%{h80+(gw#XeQSk&=%q403GYd{a4Dr z?L_JEFgd&*gh(spI3| zwn%WxO_{etJ@J&ZaGd$qUyY0B$dQkmnJDo_rK@i2+HIwvzEG6p*RSX2Sh4(ZJghKt zk;B|g)JEZ{?pRqM%XAI@0FG-f78M15N4mclsQnctIn zJDMxmEuA&Ot0FY+oJ^Ndg{d6sCb?qyO4*)Q=zGL%Kxf=k!dL91`PMn7^2y1V_&BL@ zWok0HnF$LUel?s`x;p0eDQK}szg?Pw$R$fwRH61$TYPs>U9&8iz9`w$x*JZ#($?t7 z2nisheiih7501QatogqyE6UlD@k3cEL+gmr@{!km)!}*h{%O+b9;b!l-r1ACGk#?# zWY?KJp641vA6hOi>tJUBgiMx=e}ei%&yo3NTVF<#>|}nL^gIt8=E=?Uj~~v>Uy3!I zU#S|iK{1+8N#(}X?0H%K7}7kgVa-1c*|cv5aplRbP`_@cD@lp~_B zYbJHYS{fzQKJZ9T#V(O`NQ-r(rt2`C(i|uG#T>O#59%I6%Go2uEo#lK8;v2*k^$&?Qu92HD?;&b`#Ea& za(?+W$tzllGq=LLWSiSPylFuYQd~+`%9F6CNgWZ|6pZRpd_|vRQ&L4rE$EECUZY^N zgOiS;lXhM>aoZzpND?3M6s+%AOt~|2;J%Mt?(E#x8YPBK*&R(7F}$;1Nb|hByj2}T zE@XQZy{57gxuo#^9`YEqh8)zyrB7QtY(Oo8VUulW$}4<;AQ%=;kDktK=)M!@#TLXOHG* zw@9$@XI(XFfVhl26Sg)rrS{s>D1rQyR?2C?V^92>Ming9pdjy@a=4-pgjBjT@l;omj-VnS=V%Y$#$qRHg zga-1r6tX+_>wqi0ek$4KKgsCmy)$Biqx8&8B99GDyuTXY@a{<-$USx`AY-vUb>w*& zrIRJE^gWLk0*oB~hBu3&Z3HRSi%qL5C<)F~J^ui3u82dC%Q?~_?N>%-UE@lcN?DGe zgn*n9tmG5-){h?)(jjEz)rjjWjk@J=@tZ44fGH~}9aKpt`zhm6irF%8Y)iyy*$FFA zGB7!baQ#3!el&jOI%!pxE*)_v@*JiejPrb)+=Qg=l1|6rS;`GNDSlC-r8sqTXH>l| zM8&fAg0Q5xqA`QmQHm+MGRWG{=Zkt0*{yAgw+Ki?mlAvz6M>I;ttF>u&MQpiL8t!! zxf`RbY9|R@xoT+x7|)V{sGP6%ofzY5@*7*VtOE0}Q1DxdSW{{vrhWA;5|-K38A2T! zO`dd%eXb0qTuY^D_J=n>dsD|0o{miOa@#G|?L_MJGmRDsn{5GH=dmDus@+m&J8j09 zW{)g5`Q~*cwVaOJri2fn8~wp7$4b)XPB}-$rgEeaR%9<+7?*f@3(`=^y{9sx)Qab6 zwQT6?q-8fn$dh(>v4sRIBa-t66x8|Z&Om1sKc}}$%n*ME1qt;H-ua4CCowRNs#SYxKMI$0QhP5NA4yx&;%bYUico}~3@B_d-{V+j z$l|z1vf~9eY|=Ch&KKoDd|xSTm1VScz^tF*jUx+mS+&2U#EVix5mDi#0~;Os_N=%| zCrs?e9C%gCtrxA?|V(f9fBjZ;x9m zvh1Naw=9+Z}6Vt(h{# zqxg%d^pwQ8Zn!A`Ejwo;V^xzBaz>e0vpj6rG)Eq$xRSk0*>wPJ<_S(c^~paIkL)`k z<}8|$q6dh&$4u(i3$PH9uBQiXZq;5qGGl*{9#6+5_>p=_)ecOy-&A0gq>fTX;<_?P z(a8uaI-5vZ?e?8MF7p=H32&VtM;P~4BBb_g-zP}IcdlXY^mMTFx7Bh<((nu;bkWaZt4P=p zw^{%O+VKWP!?iWgy9z>vP;x~j-H)MLVNxVybk6iop~FPw!dWdP8=Pa9Rxyh;Zk3H2 zdAC3b_EnwmJ5|$NlXf_WkhP>ZeVp&^sefff5-+y^rN0dTD?9I+ow2m2)AUZOi)w-p zl!Ywd9rvz$v2tdZsco9>fVN$Atc1(UjmJXpaCcX_rA0+kDp@@vsr0p&TkOroTR}Xd zagWA=Q{9t{BGYP!snZ)s3EY!KrM4TJq-Glb0MZ)CW<#*;uBV+ldo?#Fv~3JZKfLE1 zbH}G{N>Nnhf_f!Kr4h#2ZfZRlq^>aBSb0lsYR|M!)~#cQ?8aHPL(SsE*{V@-#gYzl zn$zM&Z!73+Z{kdWGcMwrL%AW4c?y5b9FyF@e`Lic^$^DwNbVfEX&rYW(3Jcrq?MEqUJ*43UV!8y?vEs^Yzfev6B2CzT&twI?8} zHbu;FWk9v_tEfA~Y6)-~#4i*S$l zN0F9Sl3(S3htrLS&q{AVniWKhbTu?-$xw4A0|!4EwF@E5npBCTCuLWajtL&#Otz?t zc6P^l=uoqoSs5Pe-*2wftZ|t+vt9IV(uYuMST|V><(RTsQb`?1P^>dPQ;sjTbNP8b zJQA0-nbWeQ1$cJo{RYPs$(CAJqIn5&cFF5}e+@0iM(4eHUM@ZWToD6iVG2?9ZV~wRo-@@pkC5^Y;7*R($ ziSsq<{+yIF+py=}wG! zduF|SO0mT+q;*gCzw$I(l;;3ei4x`XS@>;da{Z~}x670^LX}wg4~#TCdvqwR=YsrE5AtOeeCH-iazljRl53UIIL1e1-T~2l zK1uIY2sz0`cFu1jGQ|fbb)A|VO($SONk~tIkJF0!Y&hfM;-lr~CzfVE#63*8F0DNK zocycC%{P{Ondo4~WzwZ6DM}|h)=c!F5;ao!&IsK3)^u+~jj{-PSEDSNL_Ow8 zV%+AVCn7_+&+?6J1^A$j(j$F!OBp8~RYfR;^`V}-fGZOO%58J@D=8-OOr>n?*^_(DM(Pt8W_@%RTgo^Rv?6j;5P-k7Qw(&8R2ZN^m|R zy_Jzcqr-Ul+?mQeOxCNtT$dRyWgz=o{)+IYH=2Bz?RfaOD`g@@&6ZgVpzn@@y;i8` zP;HSacNuxyb=X!-+1VJjuRrwT%RLd4|e9bhz@D6k(q)6m_PhyFk(QKMA!Z1t`D* zy$rb{f;4#eqVr1G$y)yaSIWO!T~~@!fOg;CUVInG`AGEP6$DYAnh=tLd)B;cvI+A2 z&RcL{wx=C=VF*fll4+!(Y08zew0I-JX!=Ss*DH%)$#vDOY9oB)*Jq7^!Cp?!BgyhU zSFd9}JMkH)Hd)rlPWwhXiNHOINUSpF=apkdm~iorCUOavY&L4U7oqaWEFFu1Gx&Wh^B|NE9xCbR<(QhKKt}kY(pg4smN8MRpj8_gqhc*eoPJ53% z>j(TBrK)FJY1G>Fa{}oC;mp`iFI|Z1ROzcR{G%=`!M!2044Cj_YDlP4i02_eDJLV( zHJ&w6G~}w8gTxkgH2eCApx=)jO{J#!u%W&VN8ejbzFY+azj1fcdX`&EFzmI9gzALhoInrEG$vnfbsd9Bl))97BVOm^$;E3rU$#<0i z{D1Z}q+cgSZj)@;(Q0A_ko=5Pl3i?tl?>pKThgPMyLNFtySCgkcBh*jGpP~ZSyD(H zGH`KQC`Tf;T(eFc6gjr{o>-7%5=qG!>0K~%sNy~8FQv{zB^RO#wx-o$>_4)^lG%UhTTk-RJU?d$h_}S9IGPHTzI=8 z={AqbZdq)sKjWIa~@pM{sD9cWiMi+M86vFe6x+ zWHu6!&w-4Oy15~Z@^U&kB^pDBS4&(=PGhWv1mK+QpM?@lx@M4SCNIQ&PMH&Y23*gz zjgM;I1~=J{k)Hnm6Es^(kuNT1l&ht7-7OpyY}T|zrX*PCkdU0MJMXx!AIY1OqtWr; zlCnYREZeT--MzEZ-&rNf6lm#6!c4ppr71@M(@^v&PhS#F z>wsD@k@~AujiMZgCsvaz@*i-niqV61#eG%qw5$+GP{;?lHBe|$L)&H2Q_UD4j3gb& z-n47kHapS|Hv?2h6ObQg#LJ2E9cw(cs04_DDpl;MING_f;o|L`GRbO+g!s*=1;)nxYr7ns(>UiJV%lnWi!muu zvG1$Momv(*Y_V!xK;qDpA$dvmvrz?XxwYCKxC;vPRtvItx6sDZ!APjXI!vA6r>Ne$g1t{VO># zqoDGnhZW$IgN)Fl>}~oB5+N$c2Xoq+ktsLO{@oQ)o+v_g$9m3AjbN?Njpv>Vyoyc^ zY2(>h7ZTUQsLHt97-dABb&UIyQ;|`UbbS=y=8m^oY%$i`C<+M}1o`(h&fS+4Y|>>% zX{HGA0NSM0Bc6RBIJ9)7q3BWH%DGBLcHXCt%J`#rR1=dpj_1Tlb6$D(Tv1z!B;@T~ ze-k<0TX$tT<9vE!g=I%M+j`P4;$9=Q@6Bw*EP8NGlUe6yI zY!n_%BQ@hToUy^WIJ+qbN;Axq0eAq1|D2?noH<;S2h(pow(;gfW7Ul#o@+LYV&>k7##$OW^2DXcP|dPdGz@o(Ax*_~?gCIA2c literal 0 HcmV?d00001 diff --git a/src/site/resources/documentation.xml b/src/site/resources/documentation.xml new file mode 100644 index 0000000..1ee34dc --- /dev/null +++ b/src/site/resources/documentation.xml @@ -0,0 +1,6 @@ + + +
+

User documentation

+

No user documentation is currently available.

+
diff --git a/src/site/resources/features.xml b/src/site/resources/features.xml new file mode 100644 index 0000000..6e09c09 --- /dev/null +++ b/src/site/resources/features.xml @@ -0,0 +1,10 @@ + + +
+
    +
  • OSGi-ready.
    • +
  • JPMS-ready
    • +
  • High coverage automated test suite
    • +
  • ISC license
    • +
+
diff --git a/src/site/resources/header.xml b/src/site/resources/header.xml new file mode 100644 index 0000000..4507597 --- /dev/null +++ b/src/site/resources/header.xml @@ -0,0 +1,8 @@ + +
+

+ io7m.com | software | claypot + +

+
+
diff --git a/src/site/resources/icon.png b/src/site/resources/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..002f65533ad61b12791867a5bf110ebb2b52a091 GIT binary patch literal 9851 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 literal 0 HcmV?d00001 diff --git a/src/site/resources/overview.xml b/src/site/resources/overview.xml new file mode 100644 index 0000000..117da78 --- /dev/null +++ b/src/site/resources/overview.xml @@ -0,0 +1,28 @@ +
+

+ + Build status + + + Maven Central + + + Codacy + + + Codecov + +

+ +

+ The claypot package implements a small API over the excellent + JCommander command-line parser that implements + defaults and conventions that are used across many io7m + packages. +

+ +
diff --git a/src/site/resources/site.css b/src/site/resources/site.css new file mode 100644 index 0000000..e4bb857 --- /dev/null +++ b/src/site/resources/site.css @@ -0,0 +1,7 @@ +p.shields a { + text-decoration: none; +} + +#header { + font-family: monospace; +} From 2b02694dc575aed9ad27c6f85cf7efbe7c2438aa Mon Sep 17 00:00:00 2001 From: Mark Raynsford Date: Fri, 26 Jun 2020 13:49:33 +0000 Subject: [PATCH 2/5] Update README --- README.md | 11 +++++++++++ pom.xml | 2 +- src/site/resources/overview.xml | 2 +- 3 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..abb3c44 --- /dev/null +++ b/README.md @@ -0,0 +1,11 @@ +claypot +=== + +[![Travis](https://img.shields.io/travis/io7m/claypot.png?style=flat-square)](https://travis-ci.org/io7m/claypot) +[![Maven Central](https://img.shields.io/maven-central/v/com.io7m.claypot/com.io7m.claypot.png?style=flat-square)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.io7m.claypot%22) +[![Maven Central (snapshot)](https://img.shields.io/nexus/s/https/oss.sonatype.org/com.io7m.claypot/com.io7m.claypot.svg?style=flat-square)](https://oss.sonatype.org/content/repositories/snapshots/com/io7m/claypot/) +[![Codacy grade](https://img.shields.io/codacy/grade/e6b8b59da8fb4d8383f26601bcc37d48.png?style=flat-square)](https://www.codacy.com/app/github_79/claypot) +[![Codecov](https://img.shields.io/codecov/c/github/io7m/claypot.png?style=flat-square)](https://codecov.io/gh/io7m/claypot) + +![claypot](./src/site/resources/claypot.jpg?raw=true) + diff --git a/pom.xml b/pom.xml index b2f81be..afe1933 100644 --- a/pom.xml +++ b/pom.xml @@ -26,7 +26,7 @@ - + e6b8b59da8fb4d8383f26601bcc37d48 0.0.1 0.0.1-SNAPSHOT 11,[14,15) diff --git a/src/site/resources/overview.xml b/src/site/resources/overview.xml index 117da78..8e5e75b 100644 --- a/src/site/resources/overview.xml +++ b/src/site/resources/overview.xml @@ -9,7 +9,7 @@ alt="Maven Central"/> - Codacy From 891102bd4148bf798c362ddbe0d5932f98e31593 Mon Sep 17 00:00:00 2001 From: Mark Raynsford Date: Fri, 26 Jun 2020 13:50:59 +0000 Subject: [PATCH 3/5] Add Travis CI configuration --- .travis.yml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..2377beb --- /dev/null +++ b/.travis.yml @@ -0,0 +1,21 @@ +language: java + +jdk: + - oraclejdk11 + - openjdk11 + +before_install: + - wget https://archive.apache.org/dist/maven/maven-3/3.6.2/binaries/apache-maven-3.6.2-bin.zip + - unzip -qq apache-maven-3.6.2-bin.zip + - export M2_HOME=$PWD/apache-maven-3.6.2 + - export PATH=$M2_HOME/bin:$PATH + +install: true + +script: + - mvn --errors clean verify site + - bash <(curl -s https://codecov.io/bash) -f ./com.io7m.claypot.tests/target/site/jacoco-aggregate/jacoco.xml + +notifications: + irc: "chat.freenode.net#io7m" + From d33aa78541cc21c6bedf5c69325e336108b58018 Mon Sep 17 00:00:00 2001 From: Mark Raynsford Date: Fri, 26 Jun 2020 13:53:59 +0000 Subject: [PATCH 4/5] Add Jenkins configuration --- .gitmodules | 3 +++ .jenkins | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 .jenkins diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..e8d95e0 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule ".jenkins"] + path = .jenkins + url = https://www.github.com/io7m/jenkinsfiles diff --git a/.jenkins b/.jenkins new file mode 160000 index 0000000..61a9d19 --- /dev/null +++ b/.jenkins @@ -0,0 +1 @@ +Subproject commit 61a9d198e8ee8559228dc6179cbe4ae6e9bef6df From 24a213bb76aedc3160fcfb5454766bbc8b889a7f Mon Sep 17 00:00:00 2001 From: Mark Raynsford Date: Fri, 26 Jun 2020 14:07:30 +0000 Subject: [PATCH 5/5] Mark 0.0.1 --- README-CHANGES.xml | 6 +++++- com.io7m.claypot.core/pom.xml | 2 +- com.io7m.claypot.example/pom.xml | 2 +- com.io7m.claypot.tests/pom.xml | 2 +- pom.xml | 2 +- 5 files changed, 9 insertions(+), 5 deletions(-) diff --git a/README-CHANGES.xml b/README-CHANGES.xml index 19989dc..d445360 100644 --- a/README-CHANGES.xml +++ b/README-CHANGES.xml @@ -1,6 +1,10 @@ - + + + + + diff --git a/com.io7m.claypot.core/pom.xml b/com.io7m.claypot.core/pom.xml index a8432ce..8ce3d33 100644 --- a/com.io7m.claypot.core/pom.xml +++ b/com.io7m.claypot.core/pom.xml @@ -9,7 +9,7 @@ com.io7m.claypot com.io7m.claypot - 0.0.1-SNAPSHOT + 0.0.1 com.io7m.claypot.core diff --git a/com.io7m.claypot.example/pom.xml b/com.io7m.claypot.example/pom.xml index f766654..4380481 100644 --- a/com.io7m.claypot.example/pom.xml +++ b/com.io7m.claypot.example/pom.xml @@ -9,7 +9,7 @@ com.io7m.claypot com.io7m.claypot - 0.0.1-SNAPSHOT + 0.0.1 com.io7m.claypot.example diff --git a/com.io7m.claypot.tests/pom.xml b/com.io7m.claypot.tests/pom.xml index 0701625..9cc9842 100644 --- a/com.io7m.claypot.tests/pom.xml +++ b/com.io7m.claypot.tests/pom.xml @@ -9,7 +9,7 @@ com.io7m.claypot com.io7m.claypot - 0.0.1-SNAPSHOT + 0.0.1 com.io7m.claypot.tests diff --git a/pom.xml b/pom.xml index afe1933..b138781 100644 --- a/pom.xml +++ b/pom.xml @@ -12,7 +12,7 @@ com.io7m.claypot com.io7m.claypot - 0.0.1-SNAPSHOT + 0.0.1 pom JCommander conventions for io7m projects