From d4e54e9f35d532062533f1d369c159810b01d224 Mon Sep 17 00:00:00 2001 From: Even Rouault Date: Tue, 9 May 2017 15:28:09 +0200 Subject: [PATCH] Add mechanisms to reformant and check code style (#128) Use an internal version of astyle (astyle 3.0). Scripts taken from QGIS. astyle.options from https://github.com/uclouvain/openjpeg/issues/128 scripts/prepare-commit.sh can be used locally to automatically reformat edited files. Travis-CI will run scripts/verify-indentation.sh to verify committed files. --- .gitignore | 1 + .travis.yml | 57 +- CMakeLists.txt | 5 +- INSTALL.md | 6 + README.md | 1 + scripts/astyle.options | 11 + scripts/astyle.sh | 117 + scripts/prepare-commit.sh | 112 + scripts/remove_temporary_files.sh | 41 + scripts/verify-indentation.sh | 79 + thirdparty/CMakeLists.txt | 6 + thirdparty/astyle/ASBeautifier.cpp | 3659 +++++++++++++ thirdparty/astyle/ASEnhancer.cpp | 797 +++ thirdparty/astyle/ASFormatter.cpp | 7714 +++++++++++++++++++++++++++ thirdparty/astyle/ASLocalizer.cpp | 1092 ++++ thirdparty/astyle/ASLocalizer.h | 159 + thirdparty/astyle/ASResource.cpp | 833 +++ thirdparty/astyle/CMakeLists.txt | 28 + thirdparty/astyle/LICENSE.md | 21 + thirdparty/astyle/astyle.h | 1056 ++++ thirdparty/astyle/astyle_main.cpp | 3990 ++++++++++++++ thirdparty/astyle/astyle_main.h | 443 ++ thirdparty/astyle/scripts/opjstyle | Bin 0 -> 2404824 bytes tools/ctest_scripts/travis-ci.cmake | 12 + tools/travis-ci/install.sh | 4 + tools/travis-ci/run.sh | 19 + 26 files changed, 20242 insertions(+), 21 deletions(-) create mode 100644 scripts/astyle.options create mode 100755 scripts/astyle.sh create mode 100755 scripts/prepare-commit.sh create mode 100755 scripts/remove_temporary_files.sh create mode 100755 scripts/verify-indentation.sh create mode 100755 thirdparty/astyle/ASBeautifier.cpp create mode 100755 thirdparty/astyle/ASEnhancer.cpp create mode 100755 thirdparty/astyle/ASFormatter.cpp create mode 100755 thirdparty/astyle/ASLocalizer.cpp create mode 100755 thirdparty/astyle/ASLocalizer.h create mode 100755 thirdparty/astyle/ASResource.cpp create mode 100644 thirdparty/astyle/CMakeLists.txt create mode 100755 thirdparty/astyle/LICENSE.md create mode 100755 thirdparty/astyle/astyle.h create mode 100755 thirdparty/astyle/astyle_main.cpp create mode 100755 thirdparty/astyle/astyle_main.h create mode 100755 thirdparty/astyle/scripts/opjstyle diff --git a/.gitignore b/.gitignore index 98590ca7..a6f4eff7 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ cmake_install.cmake /src/bin/common/opj_apps_config.h /src/lib/openjp2/opj_config.h /src/lib/openjp2/opj_config_private.h +scripts/opjstyle* # Ignore directories made by `make`. /bin/ diff --git a/.travis.yml b/.travis.yml index d19eb5f3..78c638d8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,4 @@ -language: c +language: cpp matrix: include: @@ -6,20 +6,32 @@ matrix: compiler: clang env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release OPJ_CI_INCLUDE_IF_DEPLOY=1 - os: linux - compiler: gcc + compiler: clang-3.8 + env: OPJ_CI_CC=clang-3.8 OPJ_CI_CXX=clang-3.8 OPJ_CI_CHECK_STYLE=1 OPJ_CI_SKIP_TESTS=1 + addons: + apt: + sources: + - llvm-toolchain-precise-3.8 + - ubuntu-toolchain-r-test + packages: + - clang-3.8 + - flip + - os: linux + compiler: g++ env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release OPJ_CI_INCLUDE_IF_DEPLOY=1 OPJ_CI_PERF_TESTS=1 - os: linux - compiler: gcc + compiler: g++ env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release OPJ_NUM_THREADS=2 - os: linux - compiler: gcc + compiler: g++ env: OPJ_CI_ARCH=i386 OPJ_CI_BUILD_CONFIGURATION=Release addons: apt: packages: - gcc-multilib + - g++-multilib - os: linux - compiler: gcc + compiler: g++ env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Debug OPJ_CI_PROFILE=1 addons: apt: @@ -30,7 +42,7 @@ matrix: env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Debug OPJ_CI_ASAN=1 - os: linux compiler: clang-3.8 - env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release OPJ_CI_PERF_TESTS=1 + env: OPJ_CI_CC=clang-3.8 OPJ_CI_CXX=clang-3.8 OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release OPJ_CI_PERF_TESTS=1 addons: apt: sources: @@ -39,18 +51,8 @@ matrix: packages: - clang-3.8 - os: linux - compiler: x86_64-w64-mingw32-gcc - env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release - addons: - apt: - packages: - - gcc-mingw-w64-base - - binutils-mingw-w64-x86-64 - - gcc-mingw-w64-x86-64 - - gcc-mingw-w64 - - os: linux - compiler: x86_64-w64-mingw32-gcc - env: OPJ_CI_ARCH=i386 OPJ_CI_BUILD_CONFIGURATION=Release + compiler: x86_64-w64-mingw32-g++ + env: OPJ_CI_CC=x86_64-w64-mingw32-gcc OPJ_CI_CXX=x86_64-w64-mingw32-g++ OPJ_CI_ARCH=i386 OPJ_CI_BUILD_CONFIGURATION=Release addons: apt: packages: @@ -58,15 +60,30 @@ matrix: - binutils-mingw-w64-i686 - gcc-mingw-w64-i686 - gcc-mingw-w64 + - g++-mingw-w64-i686 + - gcc-multilib + - g++-multilib - os: linux - compiler: gcc-4.8 - env: OPJ_CI_ABI_CHECK=1 + compiler: x86_64-w64-mingw32-g++ + env: OPJ_CI_CC=x86_64-w64-mingw32-gcc OPJ_CI_CXX=x86_64-w64-mingw32-g++ OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release + addons: + apt: + packages: + - gcc-mingw-w64-base + - binutils-mingw-w64-x86-64 + - gcc-mingw-w64-x86-64 + - gcc-mingw-w64 + - g++-mingw-w64-x86-64 + - os: linux + compiler: g++-4.8 + env: OPJ_CI_CC=gcc-4.8 OPJ_CI_CXX=g++-4.8 OPJ_CI_ABI_CHECK=1 addons: apt: sources: - ubuntu-toolchain-r-test packages: - gcc-4.8 + - g++-4.8 - libelf-dev - elfutils - texinfo diff --git a/CMakeLists.txt b/CMakeLists.txt index a7dbe087..9017bbd5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,7 +24,7 @@ endif() #string(TOLOWER ${OPENJPEG_NAMESPACE} OPENJPEG_LIBRARY_NAME) set(OPENJPEG_LIBRARY_NAME openjp2) -project(${OPENJPEG_NAMESPACE} C) +project(${OPENJPEG_NAMESPACE}) # Do full dependency headers. include_regular_expression("^.*$") @@ -386,3 +386,6 @@ if(BUILD_PKGCONFIG_FILES) endif() #----------------------------------------------------------------------------- + +# build our version of astyle +SET (WITH_ASTYLE FALSE CACHE BOOL "If you plan to contribute you should reindent with scripts/prepare-commit.sh (using 'our' astyle)") diff --git a/INSTALL.md b/INSTALL.md index 368f5aec..b3b293dc 100644 --- a/INSTALL.md +++ b/INSTALL.md @@ -31,6 +31,7 @@ Main available cmake flags: * To build the shared libraries and links the executables against it: '-DBUILD\_SHARED\_LIBS:bool=on' (default: 'ON') > Note: when using this option, static libraries are not built and executables are dynamically linked. * To build the CODEC executables: '-DBUILD\_CODEC:bool=on' (default: 'ON') + * To build opjstyle (internal version of astyle) for OpenJPEG development: '-DWITH_ASTYLE=ON' * [OBSOLETE] To build the MJ2 executables: '-DBUILD\_MJ2:bool=on' (default: 'OFF') * [OBSOLETE] To build the JPWL executables and JPWL library: '-DBUILD\_JPWL:bool=on' (default: 'OFF') * [OBSOLETE] To build the JPIP client (java compiler recommended) library and executables: '-DBUILD\_JPIP:bool=on' (default: 'OFF') @@ -62,6 +63,11 @@ Note 4 : On MacOS, if it does not work, try adding the following flag to the cma You can use cmake to generate the project files for the IDE you are using (VC2010, XCode, etc). Type 'cmake --help' for available generators on your platform. +# Modifying OpenJPEG + +Before committing changes, run: +scripts/prepare-commit.sh + # Using OpenJPEG To use openjpeg exported cmake file, simply create your application doing: diff --git a/README.md b/README.md index ccdb2753..f703d0eb 100644 --- a/README.md +++ b/README.md @@ -49,6 +49,7 @@ The library is developed and maintained by the Image and Signal Processing Group * doc: doxygen documentation setup file and man pages * tests: configuration files and utilities for the openjpeg test suite. All test images are located in [openjpeg-data](https://github.com/uclouvain/openjpeg-data) repository. * cmake: cmake related files +* scripts: scripts for developers See [LICENSE][link-license] for license and copyright information. diff --git a/scripts/astyle.options b/scripts/astyle.options new file mode 100644 index 00000000..c92ea7f1 --- /dev/null +++ b/scripts/astyle.options @@ -0,0 +1,11 @@ +--convert-tabs +--lineend=linux +--indent=spaces=4 +--style=kr +--add-brackets +--max-code-length=80 +--break-after-logical +--pad-header +--pad-oper +--unpad-paren +--suffix=none diff --git a/scripts/astyle.sh b/scripts/astyle.sh new file mode 100755 index 00000000..603a1c94 --- /dev/null +++ b/scripts/astyle.sh @@ -0,0 +1,117 @@ +#!/bin/bash +########################################################################### +# astyle.sh +# --------------------- +# Date : August 2008 +# Copyright : (C) 2008 by Juergen E. Fischer +# Email : jef at norbit dot de +########################################################################### +# # +# This program is free software; you can redistribute it and/or modify # +# it under the terms of the GNU General Public License as published by # +# the Free Software Foundation; either version 2 of the License, or # +# (at your option) any later version. # +# # +########################################################################### + +for ASTYLE in ${OPJSTYLE} $(dirname $0)/opjstyle $(dirname $0)/RelWithDebInfo/opjstyle +do + if type -p $ASTYLE >/dev/null; then + break + fi + ASTYLE= +done + +if [ -z "$ASTYLE" ]; then + echo "opjstyle not found - please enable WITH_ASTYLE in cmake and build it" >&2 + exit 1 +fi + +if type -p tput >/dev/null; then + elcr="$ASTYLEPROGRESS$(tput el)$(tput cr)" +else + elcr="$ASTYLEPROGRESS \r" +fi + +if ! type -p flip >/dev/null; then + if type -p dos2unix >/dev/null; then + flip() { + dos2unix -k $2 + } + else + echo "flip not found" >&2 + flip() { + : + } + fi +fi + +if ! type -p autopep8 >/dev/null; then + echo "autopep8 not found" >&2 + autopep8() { + : + } +fi + +ASTYLEOPTS=$(dirname $0)/astyle.options +if type -p cygpath >/dev/null; then + ASTYLEOPTS="$(cygpath -w $ASTYLEOPTS)" +fi + +set -e + +astyleit() { + $ASTYLE --options="$ASTYLEOPTS" "$1" + #modified=$1.unify_includes_modified + #cp "$1" "$modified" + #scripts/unify_includes.pl "$modified" + #scripts/doxygen_space.pl "$modified" + #diff "$1" "$modified" >/dev/null || mv "$modified" "$1" + #rm -f "$modified" +} + +for f in "$@"; do + case "$f" in + thirdparty/*) + echo -ne "$f skipped $elcr" + continue + ;; + + *.cpp|*.h|*.c|*.h|*.cxx|*.hxx|*.c++|*.h++|*.cc|*.hh|*.C|*.H|*.hpp) + if [ -x "$f" ]; then + chmod a-x "$f" + fi + cmd=astyleit + ;; + + *.py) + #cmd="autopep8 --in-place --ignore=E111,E128,E201,E202,E203,E211,E221,E222,E225,E226,E227,E231,E241,E261,E265,E272,E302,E303,E501,E701" + echo -ne "Formatting $f $elcr" + cmd="autopep8 --in-place --ignore=E261,E265,E402,E501" + ;; + + + *) + echo -ne "$f skipped $elcr" + continue + ;; + esac + + if ! [ -f "$f" ]; then + echo "$f not found" >&2 + continue + fi + + if [[ -f $f && `head -c 3 $f` == $'\xef\xbb\xbf' ]]; then + mv $f $f.bom + tail -c +4 $f.bom > $f + echo "removed BOM from $f" + fi + + modified=$f.flip_modified + cp "$f" "$modified" + flip -ub "$modified" + diff "$f" "$modified" >/dev/null || mv "$modified" "$f" + rm -f "$modified" + eval "$cmd '$f'" +done diff --git a/scripts/prepare-commit.sh b/scripts/prepare-commit.sh new file mode 100755 index 00000000..63dac65c --- /dev/null +++ b/scripts/prepare-commit.sh @@ -0,0 +1,112 @@ +#!/usr/bin/env bash +########################################################################### +# prepare-commit.sh +# --------------------- +# Date : August 2008 +# Copyright : (C) 2008 by Juergen E. Fischer +# Email : jef at norbit dot de +########################################################################### +# # +# This program is free software; you can redistribute it and/or modify # +# it under the terms of the GNU General Public License as published by # +# the Free Software Foundation; either version 2 of the License, or # +# (at your option) any later version. # +# # +########################################################################### + +TOPLEVEL=$(git rev-parse --show-toplevel) + +PATH=$TOPLEVEL/scripts:$PATH + +cd $TOPLEVEL + +# GNU prefix command for mac os support (gsed, gsplit) +GP= +if [[ "$OSTYPE" =~ darwin* ]]; then + GP=g +fi + +if ! type -p astyle.sh >/dev/null; then + echo astyle.sh not found + exit 1 +fi + +if ! type -p colordiff >/dev/null; then + colordiff() + { + cat "$@" + } +fi + +if [ "$1" = "-c" ]; then + echo "Cleaning..." + remove_temporary_files.sh +fi + +set -e + +# determine changed files +MODIFIED=$(git status --porcelain| ${GP}sed -ne "s/^ *[MA] *//p" | sort -u) +#MODIFIED=$(find src -name "*.c") + +if [ -z "$MODIFIED" ]; then + echo nothing was modified + exit 0 +fi + +# save original changes +REV=$(git log -n1 --pretty=%H) +git diff >sha-$REV.diff + +ASTYLEDIFF=astyle.$REV.diff +>$ASTYLEDIFF + +# reformat +i=0 +N=$(echo $MODIFIED | wc -w) +for f in $MODIFIED; do + (( i++ )) || true + + case "$f" in + thirdparty/*) + echo $f skipped + continue + ;; + + *.cpp|*.c|*.h|*.cxx|*.hxx|*.c++|*.h++|*.cc|*.hh|*.C|*.H|*.sip|*.py) + ;; + + *) + continue + ;; + esac + + m=$f.$REV.prepare + + cp $f $m + ASTYLEPROGRESS=" [$i/$N]" astyle.sh $f + if diff -u $m $f >>$ASTYLEDIFF; then + # no difference found + rm $m + fi +done + +if [ -s "$ASTYLEDIFF" ]; then + if tty -s; then + # review astyle changes + colordiff <$ASTYLEDIFF | less -r + else + echo "Files changed (see $ASTYLEDIFF)" + fi + exit 1 +else + rm $ASTYLEDIFF +fi + + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached HEAD -- + +exit 0 + +# vim: set ts=8 noexpandtab : diff --git a/scripts/remove_temporary_files.sh b/scripts/remove_temporary_files.sh new file mode 100755 index 00000000..535cccec --- /dev/null +++ b/scripts/remove_temporary_files.sh @@ -0,0 +1,41 @@ +#!/bin/bash +########################################################################### +# remove_git_confict_files.sh +# --------------------- +# Date : April 2012 +# Copyright : (C) 2012 by Tim Sutton +# Email : tim at kartoza dot com +########################################################################### +# # +# This program is free software; you can redistribute it and/or modify # +# it under the terms of the GNU General Public License as published by # +# the Free Software Foundation; either version 2 of the License, or # +# (at your option) any later version. # +# # +########################################################################### + +# +# A simple script to get rid of QGIS related temporary files left in +# your QGIS source folder by git + +# Tim Sutton, May 2008 +find . \ + \( \ + -name "*.orig" \ + -o -name "*.prepare" \ + -o -name "*.sortinc" \ + -o -name "*.unify_includes_modified" \ + -o -name "*.nocopyright" \ + -o -name "astyle*.diff" \ + -o -name "sha-*.diff" \ + -o -name "*.astyle" \ + -o -name "sha*.diff" \ + -o -name "*.bom" \ + -o -name "*.bak" \ + -o -name "*.rej" \ + -o -name "*.orig" \ + -o -name "*.new" \ + -o -name "*~" \ + \) \ + -print \ + -delete diff --git a/scripts/verify-indentation.sh b/scripts/verify-indentation.sh new file mode 100755 index 00000000..120e1411 --- /dev/null +++ b/scripts/verify-indentation.sh @@ -0,0 +1,79 @@ +#!/bin/bash +cd $(git rev-parse --show-toplevel) + +export PATH=$PATH:$PWD/scripts + +if [ -z "$TRAVIS_COMMIT_RANGE" ]; then + echo "No commit range given" + exit 0 +fi + +if ! type -p astyle.sh >/dev/null; then + echo astyle.sh not found + exit 1 +fi + +set -e + +ASTYLEDIFF=/tmp/astyle.diff +>$ASTYLEDIFF + + +if [[ ! -z $TRAVIS_PULL_REQUEST_BRANCH ]]; then + # if on a PR, just analyse the changed files + echo "TRAVIS PR BRANCH: $TRAVIS_PULL_REQUEST_BRANCH" + FILES=$(git diff --diff-filter=AM --name-only $(git merge-base HEAD master) | tr '\n' ' ' ) +elif [[ ! -z $TRAVIS_COMMIT_RANGE ]]; then + echo "TRAVIS COMMIT RANGE: $TRAVIS_COMMIT_RANGE" + FILES=$(git diff --diff-filter=AM --name-only ${TRAVIS_COMMIT_RANGE/.../..} | tr '\n' ' ' ) +fi + +for f in $FILES; do + if ! [ -f "$f" ]; then + echo "$f was removed." >>/tmp/ctest-important.log + continue + fi + + echo "Checking $f" >>/tmp/ctest-important.log + case "$f" in + thirdparty*) + echo "$f skipped" + continue + ;; + + *.cpp|*.c|*.h|*.cxx|*.hxx|*.c++|*.h++|*.cc|*.hh|*.C|*.H|*.sip|*.py) + ;; + + *) + continue + ;; + esac + + m="$f.prepare" + cp "$f" "$m" + astyle.sh "$f" + if diff -u "$m" "$f" >>$ASTYLEDIFF; then + rm "$m" + else + echo "File $f needs indentation" + fi +done + +if [ -s "$ASTYLEDIFF" ]; then + echo + echo "Required indentation updates:" + cat "$ASTYLEDIFF" + + cat <= 1.2.1) to format python code +* Use "scripts/astyle.sh file" to fix the now badly indented files +* Consider using scripts/prepare-commit.sh as pre-commit hook to avoid this + in the future (ln -s scripts/prepare-commit.sh .git/hooks/pre-commit) or + run it manually before each commit. +EOF + + exit 1 +fi diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt index cb24b43b..b0b229c8 100644 --- a/thirdparty/CMakeLists.txt +++ b/thirdparty/CMakeLists.txt @@ -116,3 +116,9 @@ else(BUILD_THIRDPARTY) endif(LCMS_FOUND) endif(LCMS2_FOUND) endif(BUILD_THIRDPARTY) + + +#------------ +IF (WITH_ASTYLE) + ADD_SUBDIRECTORY(astyle) +ENDIF(WITH_ASTYLE) diff --git a/thirdparty/astyle/ASBeautifier.cpp b/thirdparty/astyle/ASBeautifier.cpp new file mode 100755 index 00000000..25b2e53f --- /dev/null +++ b/thirdparty/astyle/ASBeautifier.cpp @@ -0,0 +1,3659 @@ +// ASBeautifier.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#include "astyle.h" + +#include + +//----------------------------------------------------------------------------- +// astyle namespace +//----------------------------------------------------------------------------- + +namespace astyle { +// +// this must be global +static int g_preprocessorCppExternCBrace; + +//----------------------------------------------------------------------------- +// ASBeautifier class +//----------------------------------------------------------------------------- + +/** + * ASBeautifier's constructor + * This constructor is called only once for each source file. + * The cloned ASBeautifier objects are created with the copy constructor. + */ +ASBeautifier::ASBeautifier() +{ + waitingBeautifierStack = nullptr; + activeBeautifierStack = nullptr; + waitingBeautifierStackLengthStack = nullptr; + activeBeautifierStackLengthStack = nullptr; + + headerStack = nullptr; + tempStacks = nullptr; + squareBracketDepthStack = nullptr; + blockStatementStack = nullptr; + parenStatementStack = nullptr; + braceBlockStateStack = nullptr; + continuationIndentStack = nullptr; + continuationIndentStackSizeStack = nullptr; + parenIndentStack = nullptr; + preprocIndentStack = nullptr; + sourceIterator = nullptr; + isModeManuallySet = false; + shouldForceTabIndentation = false; + setSpaceIndentation(4); + setContinuationIndentation(1); + setMinConditionalIndentOption(MINCOND_TWO); + setMaxContinuationIndentLength(40); + classInitializerIndents = 1; + tabLength = 0; + setClassIndent(false); + setModifierIndent(false); + setSwitchIndent(false); + setCaseIndent(false); + setBlockIndent(false); + setBraceIndent(false); + setBraceIndentVtk(false); + setNamespaceIndent(false); + setAfterParenIndent(false); + setLabelIndent(false); + setEmptyLineFill(false); + setCStyle(); + setPreprocDefineIndent(false); + setPreprocConditionalIndent(false); + setAlignMethodColon(false); + + // initialize ASBeautifier member vectors + beautifierFileType = 9; // reset to an invalid type + headers = new vector; + nonParenHeaders = new vector; + assignmentOperators = new vector; + nonAssignmentOperators = new vector; + preBlockStatements = new vector; + preCommandHeaders = new vector; + indentableHeaders = new vector; +} + +/** + * ASBeautifier's copy constructor + * Copy the vector objects to vectors in the new ASBeautifier + * object so the new object can be destroyed without deleting + * the vector objects in the copied vector. + * This is the reason a copy constructor is needed. + * + * Must explicitly call the base class copy constructor. + */ +ASBeautifier::ASBeautifier(const ASBeautifier& other) : ASBase(other) +{ + // these don't need to copy the stack + waitingBeautifierStack = nullptr; + activeBeautifierStack = nullptr; + waitingBeautifierStackLengthStack = nullptr; + activeBeautifierStackLengthStack = nullptr; + + // vector '=' operator performs a DEEP copy of all elements in the vector + + headerStack = new vector; + *headerStack = *other.headerStack; + + tempStacks = copyTempStacks(other); + + squareBracketDepthStack = new vector; + *squareBracketDepthStack = *other.squareBracketDepthStack; + + blockStatementStack = new vector; + *blockStatementStack = *other.blockStatementStack; + + parenStatementStack = new vector; + *parenStatementStack = *other.parenStatementStack; + + braceBlockStateStack = new vector; + *braceBlockStateStack = *other.braceBlockStateStack; + + continuationIndentStack = new vector; + *continuationIndentStack = *other.continuationIndentStack; + + continuationIndentStackSizeStack = new vector; + *continuationIndentStackSizeStack = *other.continuationIndentStackSizeStack; + + parenIndentStack = new vector; + *parenIndentStack = *other.parenIndentStack; + + preprocIndentStack = new vector >; + *preprocIndentStack = *other.preprocIndentStack; + + // Copy the pointers to vectors. + // This is ok because the original ASBeautifier object + // is not deleted until end of job. + beautifierFileType = other.beautifierFileType; + headers = other.headers; + nonParenHeaders = other.nonParenHeaders; + assignmentOperators = other.assignmentOperators; + nonAssignmentOperators = other.nonAssignmentOperators; + preBlockStatements = other.preBlockStatements; + preCommandHeaders = other.preCommandHeaders; + indentableHeaders = other.indentableHeaders; + + // protected variables + // variables set by ASFormatter + // must also be updated in activeBeautifierStack + inLineNumber = other.inLineNumber; + runInIndentContinuation = other.runInIndentContinuation; + nonInStatementBrace = other.nonInStatementBrace; + objCColonAlignSubsequent = other.objCColonAlignSubsequent; + lineCommentNoBeautify = other.lineCommentNoBeautify; + isElseHeaderIndent = other.isElseHeaderIndent; + isCaseHeaderCommentIndent = other.isCaseHeaderCommentIndent; + isNonInStatementArray = other.isNonInStatementArray; + isSharpAccessor = other.isSharpAccessor; + isSharpDelegate = other.isSharpDelegate; + isInExternC = other.isInExternC; + isInBeautifySQL = other.isInBeautifySQL; + isInIndentableStruct = other.isInIndentableStruct; + isInIndentablePreproc = other.isInIndentablePreproc; + + // private variables + sourceIterator = other.sourceIterator; + currentHeader = other.currentHeader; + previousLastLineHeader = other.previousLastLineHeader; + probationHeader = other.probationHeader; + lastLineHeader = other.lastLineHeader; + indentString = other.indentString; + verbatimDelimiter = other.verbatimDelimiter; + isInQuote = other.isInQuote; + isInVerbatimQuote = other.isInVerbatimQuote; + haveLineContinuationChar = other.haveLineContinuationChar; + isInAsm = other.isInAsm; + isInAsmOneLine = other.isInAsmOneLine; + isInAsmBlock = other.isInAsmBlock; + isInComment = other.isInComment; + isInPreprocessorComment = other.isInPreprocessorComment; + isInRunInComment = other.isInRunInComment; + isInCase = other.isInCase; + isInQuestion = other.isInQuestion; + isContinuation = other.isContinuation; + isInHeader = other.isInHeader; + isInTemplate = other.isInTemplate; + isInDefine = other.isInDefine; + isInDefineDefinition = other.isInDefineDefinition; + classIndent = other.classIndent; + isIndentModeOff = other.isIndentModeOff; + isInClassHeader = other.isInClassHeader; + isInClassHeaderTab = other.isInClassHeaderTab; + isInClassInitializer = other.isInClassInitializer; + isInClass = other.isInClass; + isInObjCMethodDefinition = other.isInObjCMethodDefinition; + isInObjCMethodCall = other.isInObjCMethodCall; + isInObjCMethodCallFirst = other.isInObjCMethodCallFirst; + isImmediatelyPostObjCMethodDefinition = other.isImmediatelyPostObjCMethodDefinition; + isImmediatelyPostObjCMethodCall = other.isImmediatelyPostObjCMethodCall; + isInIndentablePreprocBlock = other.isInIndentablePreprocBlock; + isInObjCInterface = other.isInObjCInterface; + isInEnum = other.isInEnum; + isInEnumTypeID = other.isInEnumTypeID; + isInLet = other.isInLet; + modifierIndent = other.modifierIndent; + switchIndent = other.switchIndent; + caseIndent = other.caseIndent; + namespaceIndent = other.namespaceIndent; + braceIndent = other.braceIndent; + braceIndentVtk = other.braceIndentVtk; + blockIndent = other.blockIndent; + shouldIndentAfterParen = other.shouldIndentAfterParen; + labelIndent = other.labelIndent; + isInConditional = other.isInConditional; + isModeManuallySet = other.isModeManuallySet; + shouldForceTabIndentation = other.shouldForceTabIndentation; + emptyLineFill = other.emptyLineFill; + lineOpensWithLineComment = other.lineOpensWithLineComment; + lineOpensWithComment = other.lineOpensWithComment; + lineStartsInComment = other.lineStartsInComment; + backslashEndsPrevLine = other.backslashEndsPrevLine; + blockCommentNoIndent = other.blockCommentNoIndent; + blockCommentNoBeautify = other.blockCommentNoBeautify; + previousLineProbationTab = other.previousLineProbationTab; + lineBeginsWithOpenBrace = other.lineBeginsWithOpenBrace; + lineBeginsWithCloseBrace = other.lineBeginsWithCloseBrace; + lineBeginsWithComma = other.lineBeginsWithComma; + lineIsCommentOnly = other.lineIsCommentOnly; + lineIsLineCommentOnly = other.lineIsLineCommentOnly; + shouldIndentBracedLine = other.shouldIndentBracedLine; + isInSwitch = other.isInSwitch; + foundPreCommandHeader = other.foundPreCommandHeader; + foundPreCommandMacro = other.foundPreCommandMacro; + shouldAlignMethodColon = other.shouldAlignMethodColon; + shouldIndentPreprocDefine = other.shouldIndentPreprocDefine; + shouldIndentPreprocConditional = other.shouldIndentPreprocConditional; + indentCount = other.indentCount; + spaceIndentCount = other.spaceIndentCount; + spaceIndentObjCMethodAlignment = other.spaceIndentObjCMethodAlignment; + bracePosObjCMethodAlignment = other.bracePosObjCMethodAlignment; + colonIndentObjCMethodAlignment = other.colonIndentObjCMethodAlignment; + lineOpeningBlocksNum = other.lineOpeningBlocksNum; + lineClosingBlocksNum = other.lineClosingBlocksNum; + fileType = other.fileType; + minConditionalOption = other.minConditionalOption; + minConditionalIndent = other.minConditionalIndent; + parenDepth = other.parenDepth; + indentLength = other.indentLength; + tabLength = other.tabLength; + continuationIndent = other.continuationIndent; + blockTabCount = other.blockTabCount; + maxContinuationIndent = other.maxContinuationIndent; + classInitializerIndents = other.classInitializerIndents; + templateDepth = other.templateDepth; + squareBracketCount = other.squareBracketCount; + prevFinalLineSpaceIndentCount = other.prevFinalLineSpaceIndentCount; + prevFinalLineIndentCount = other.prevFinalLineIndentCount; + defineIndentCount = other.defineIndentCount; + preprocBlockIndent = other.preprocBlockIndent; + quoteChar = other.quoteChar; + prevNonSpaceCh = other.prevNonSpaceCh; + currentNonSpaceCh = other.currentNonSpaceCh; + currentNonLegalCh = other.currentNonLegalCh; + prevNonLegalCh = other.prevNonLegalCh; +} + +/** + * ASBeautifier's destructor + */ +ASBeautifier::~ASBeautifier() +{ + deleteBeautifierContainer(waitingBeautifierStack); + deleteBeautifierContainer(activeBeautifierStack); + deleteContainer(waitingBeautifierStackLengthStack); + deleteContainer(activeBeautifierStackLengthStack); + deleteContainer(headerStack); + deleteTempStacksContainer(tempStacks); + deleteContainer(squareBracketDepthStack); + deleteContainer(blockStatementStack); + deleteContainer(parenStatementStack); + deleteContainer(braceBlockStateStack); + deleteContainer(continuationIndentStack); + deleteContainer(continuationIndentStackSizeStack); + deleteContainer(parenIndentStack); + deleteContainer(preprocIndentStack); +} + +/** + * initialize the ASBeautifier. + * + * This init() should be called every time a ABeautifier object is to start + * beautifying a NEW source file. + * It is called only when a new ASFormatter object is created. + * init() receives a pointer to a ASSourceIterator object that will be + * used to iterate through the source code. + * + * @param iter a pointer to the ASSourceIterator or ASStreamIterator object. + */ +void ASBeautifier::init(ASSourceIterator* iter) +{ + sourceIterator = iter; + initVectors(); + ASBase::init(getFileType()); + g_preprocessorCppExternCBrace = 0; + + initContainer(waitingBeautifierStack, new vector); + initContainer(activeBeautifierStack, new vector); + + initContainer(waitingBeautifierStackLengthStack, new vector); + initContainer(activeBeautifierStackLengthStack, new vector); + + initContainer(headerStack, new vector); + + initTempStacksContainer(tempStacks, new vector*>); + tempStacks->emplace_back(new vector); + + initContainer(squareBracketDepthStack, new vector); + initContainer(blockStatementStack, new vector); + initContainer(parenStatementStack, new vector); + initContainer(braceBlockStateStack, new vector); + braceBlockStateStack->push_back(true); + initContainer(continuationIndentStack, new vector); + initContainer(continuationIndentStackSizeStack, new vector); + continuationIndentStackSizeStack->emplace_back(0); + initContainer(parenIndentStack, new vector); + initContainer(preprocIndentStack, new vector >); + + previousLastLineHeader = nullptr; + currentHeader = nullptr; + + isInQuote = false; + isInVerbatimQuote = false; + haveLineContinuationChar = false; + isInAsm = false; + isInAsmOneLine = false; + isInAsmBlock = false; + isInComment = false; + isInPreprocessorComment = false; + isInRunInComment = false; + isContinuation = false; + isInCase = false; + isInQuestion = false; + isIndentModeOff = false; + isInClassHeader = false; + isInClassHeaderTab = false; + isInClassInitializer = false; + isInClass = false; + isInObjCMethodDefinition = false; + isInObjCMethodCall = false; + isInObjCMethodCallFirst = false; + isImmediatelyPostObjCMethodDefinition = false; + isImmediatelyPostObjCMethodCall = false; + isInIndentablePreprocBlock = false; + isInObjCInterface = false; + isInEnum = false; + isInEnumTypeID = false; + isInLet = false; + isInHeader = false; + isInTemplate = false; + isInConditional = false; + + indentCount = 0; + spaceIndentCount = 0; + spaceIndentObjCMethodAlignment = 0; + bracePosObjCMethodAlignment = 0; + colonIndentObjCMethodAlignment = 0; + lineOpeningBlocksNum = 0; + lineClosingBlocksNum = 0; + templateDepth = 0; + squareBracketCount = 0; + parenDepth = 0; + blockTabCount = 0; + prevFinalLineSpaceIndentCount = 0; + prevFinalLineIndentCount = 0; + defineIndentCount = 0; + preprocBlockIndent = 0; + prevNonSpaceCh = '{'; + currentNonSpaceCh = '{'; + prevNonLegalCh = '{'; + currentNonLegalCh = '{'; + quoteChar = ' '; + probationHeader = nullptr; + lastLineHeader = nullptr; + backslashEndsPrevLine = false; + lineOpensWithLineComment = false; + lineOpensWithComment = false; + lineStartsInComment = false; + isInDefine = false; + isInDefineDefinition = false; + lineCommentNoBeautify = false; + isElseHeaderIndent = false; + isCaseHeaderCommentIndent = false; + blockCommentNoIndent = false; + blockCommentNoBeautify = false; + previousLineProbationTab = false; + lineBeginsWithOpenBrace = false; + lineBeginsWithCloseBrace = false; + lineBeginsWithComma = false; + lineIsCommentOnly = false; + lineIsLineCommentOnly = false; + shouldIndentBracedLine = true; + isInSwitch = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + + isNonInStatementArray = false; + isSharpAccessor = false; + isSharpDelegate = false; + isInExternC = false; + isInBeautifySQL = false; + isInIndentableStruct = false; + isInIndentablePreproc = false; + inLineNumber = 0; + runInIndentContinuation = 0; + nonInStatementBrace = 0; + objCColonAlignSubsequent = 0; +} + +/* + * initialize the vectors + */ +void ASBeautifier::initVectors() +{ + if (fileType == beautifierFileType) // don't build unless necessary + return; + + beautifierFileType = fileType; + + headers->clear(); + nonParenHeaders->clear(); + assignmentOperators->clear(); + nonAssignmentOperators->clear(); + preBlockStatements->clear(); + preCommandHeaders->clear(); + indentableHeaders->clear(); + + ASResource::buildHeaders(headers, fileType, true); + ASResource::buildNonParenHeaders(nonParenHeaders, fileType, true); + ASResource::buildAssignmentOperators(assignmentOperators); + ASResource::buildNonAssignmentOperators(nonAssignmentOperators); + ASResource::buildPreBlockStatements(preBlockStatements, fileType); + ASResource::buildPreCommandHeaders(preCommandHeaders, fileType); + ASResource::buildIndentableHeaders(indentableHeaders); +} + +/** + * set indentation style to C/C++. + */ +void ASBeautifier::setCStyle() +{ + fileType = C_TYPE; +} + +/** + * set indentation style to Java. + */ +void ASBeautifier::setJavaStyle() +{ + fileType = JAVA_TYPE; +} + +/** + * set indentation style to C#. + */ +void ASBeautifier::setSharpStyle() +{ + fileType = SHARP_TYPE; +} + +/** + * set mode manually set flag + */ +void ASBeautifier::setModeManuallySet(bool state) +{ + isModeManuallySet = state; +} + +/** + * set tabLength equal to indentLength. + * This is done when tabLength is not explicitly set by + * "indent=force-tab-x" + * + */ +void ASBeautifier::setDefaultTabLength() +{ + tabLength = indentLength; +} + +/** + * indent using a different tab setting for indent=force-tab + * + * @param length number of spaces per tab. + */ +void ASBeautifier::setForceTabXIndentation(int length) +{ + // set tabLength instead of indentLength + indentString = "\t"; + tabLength = length; + shouldForceTabIndentation = true; +} + +/** + * indent using one tab per indentation + */ +void ASBeautifier::setTabIndentation(int length, bool forceTabs) +{ + indentString = "\t"; + indentLength = length; + shouldForceTabIndentation = forceTabs; +} + +/** + * indent using a number of spaces per indentation. + * + * @param length number of spaces per indent. + */ +void ASBeautifier::setSpaceIndentation(int length) +{ + indentString = string(length, ' '); + indentLength = length; +} + +/** +* indent continuation lines using a number of indents. +* +* @param indent number of indents per line. +*/ +void ASBeautifier::setContinuationIndentation(int indent) +{ + continuationIndent = indent; +} + +/** + * set the maximum indentation between two lines in a multi-line statement. + * + * @param max maximum indentation length. + */ +void ASBeautifier::setMaxContinuationIndentLength(int max) +{ + maxContinuationIndent = max; +} + +// retained for compatability with release 2.06 +// "MaxInStatementIndent" has been changed to "MaxContinuationIndent" in 3.0 +// it is referenced only by the old "MaxInStatementIndent" options +void ASBeautifier::setMaxInStatementIndentLength(int max) +{ + setMaxContinuationIndentLength(max); +} + +/** + * set the minimum conditional indentation option. + * + * @param min minimal indentation option. + */ +void ASBeautifier::setMinConditionalIndentOption(int min) +{ + minConditionalOption = min; +} + +/** + * set minConditionalIndent from the minConditionalOption. + */ +void ASBeautifier::setMinConditionalIndentLength() +{ + if (minConditionalOption == MINCOND_ZERO) + minConditionalIndent = 0; + else if (minConditionalOption == MINCOND_ONE) + minConditionalIndent = indentLength; + else if (minConditionalOption == MINCOND_ONEHALF) + minConditionalIndent = indentLength / 2; + // minConditionalOption = INDENT_TWO + else + minConditionalIndent = indentLength * 2; +} + +/** + * set the state of the brace indent option. If true, braces will + * be indented one additional indent. + * + * @param state state of option. + */ +void ASBeautifier::setBraceIndent(bool state) +{ + braceIndent = state; +} + +/** +* set the state of the brace indent VTK option. If true, braces will +* be indented one additional indent, except for the opening brace. +* +* @param state state of option. +*/ +void ASBeautifier::setBraceIndentVtk(bool state) +{ + // need to set both of these + setBraceIndent(state); + braceIndentVtk = state; +} + +/** + * set the state of the block indentation option. If true, entire blocks + * will be indented one additional indent, similar to the GNU indent style. + * + * @param state state of option. + */ +void ASBeautifier::setBlockIndent(bool state) +{ + blockIndent = state; +} + +/** + * set the state of the class indentation option. If true, C++ class + * definitions will be indented one additional indent. + * + * @param state state of option. + */ +void ASBeautifier::setClassIndent(bool state) +{ + classIndent = state; +} + +/** + * set the state of the modifier indentation option. If true, C++ class + * access modifiers will be indented one-half an indent. + * + * @param state state of option. + */ +void ASBeautifier::setModifierIndent(bool state) +{ + modifierIndent = state; +} + +/** + * set the state of the switch indentation option. If true, blocks of 'switch' + * statements will be indented one additional indent. + * + * @param state state of option. + */ +void ASBeautifier::setSwitchIndent(bool state) +{ + switchIndent = state; +} + +/** + * set the state of the case indentation option. If true, lines of 'case' + * statements will be indented one additional indent. + * + * @param state state of option. + */ +void ASBeautifier::setCaseIndent(bool state) +{ + caseIndent = state; +} + +/** + * set the state of the namespace indentation option. + * If true, blocks of 'namespace' statements will be indented one + * additional indent. Otherwise, NO indentation will be added. + * + * @param state state of option. + */ +void ASBeautifier::setNamespaceIndent(bool state) +{ + namespaceIndent = state; +} + +/** +* set the state of the indent after parens option. +* +* @param state state of option. +*/ +void ASBeautifier::setAfterParenIndent(bool state) +{ + shouldIndentAfterParen = state; +} + +/** + * set the state of the label indentation option. + * If true, labels will be indented one indent LESS than the + * current indentation level. + * If false, labels will be flushed to the left with NO + * indent at all. + * + * @param state state of option. + */ +void ASBeautifier::setLabelIndent(bool state) +{ + labelIndent = state; +} + +/** + * set the state of the preprocessor indentation option. + * If true, multi-line #define statements will be indented. + * + * @param state state of option. + */ +void ASBeautifier::setPreprocDefineIndent(bool state) +{ + shouldIndentPreprocDefine = state; +} + +void ASBeautifier::setPreprocConditionalIndent(bool state) +{ + shouldIndentPreprocConditional = state; +} + +/** + * set the state of the empty line fill option. + * If true, empty lines will be filled with the whitespace. + * of their previous lines. + * If false, these lines will remain empty. + * + * @param state state of option. + */ +void ASBeautifier::setEmptyLineFill(bool state) +{ + emptyLineFill = state; +} + +void ASBeautifier::setAlignMethodColon(bool state) +{ + shouldAlignMethodColon = state; +} + +/** + * get the file type. + */ +int ASBeautifier::getFileType() const +{ + return fileType; +} + +/** + * get the number of spaces per indent + * + * @return value of indentLength option. + */ +int ASBeautifier::getIndentLength() const +{ + return indentLength; +} + +/** + * get the char used for indentation, space or tab + * + * @return the char used for indentation. + */ +string ASBeautifier::getIndentString() const +{ + return indentString; +} + +/** + * get mode manually set flag + */ +bool ASBeautifier::getModeManuallySet() const +{ + return isModeManuallySet; +} + +/** + * get the state of the force tab indentation option. + * + * @return state of force tab indentation. + */ +bool ASBeautifier::getForceTabIndentation() const +{ + return shouldForceTabIndentation; +} + +/** +* Get the state of the Objective-C align method colon option. +* +* @return state of shouldAlignMethodColon option. +*/ +bool ASBeautifier::getAlignMethodColon() const +{ + return shouldAlignMethodColon; +} + +/** + * get the state of the block indentation option. + * + * @return state of blockIndent option. + */ +bool ASBeautifier::getBlockIndent() const +{ + return blockIndent; +} + +/** + * get the state of the brace indentation option. + * + * @return state of braceIndent option. + */ +bool ASBeautifier::getBraceIndent() const +{ + return braceIndent; +} + +/** +* Get the state of the namespace indentation option. If true, blocks +* of the 'namespace' statement will be indented one additional indent. +* +* @return state of namespaceIndent option. +*/ +bool ASBeautifier::getNamespaceIndent() const +{ + return namespaceIndent; +} + +/** + * Get the state of the class indentation option. If true, blocks of + * the 'class' statement will be indented one additional indent. + * + * @return state of classIndent option. + */ +bool ASBeautifier::getClassIndent() const +{ + return classIndent; +} + +/** + * Get the state of the class access modifier indentation option. + * If true, the class access modifiers will be indented one-half indent. + * + * @return state of modifierIndent option. + */ +bool ASBeautifier::getModifierIndent() const +{ + return modifierIndent; +} + +/** + * get the state of the switch indentation option. If true, blocks of + * the 'switch' statement will be indented one additional indent. + * + * @return state of switchIndent option. + */ +bool ASBeautifier::getSwitchIndent() const +{ + return switchIndent; +} + +/** + * get the state of the case indentation option. If true, lines of 'case' + * statements will be indented one additional indent. + * + * @return state of caseIndent option. + */ +bool ASBeautifier::getCaseIndent() const +{ + return caseIndent; +} + +/** + * get the state of the empty line fill option. + * If true, empty lines will be filled with the whitespace. + * of their previous lines. + * If false, these lines will remain empty. + * + * @return state of emptyLineFill option. + */ +bool ASBeautifier::getEmptyLineFill() const +{ + return emptyLineFill; +} + +/** + * get the state of the preprocessor indentation option. + * If true, preprocessor "define" lines will be indented. + * If false, preprocessor "define" lines will be unchanged. + * + * @return state of shouldIndentPreprocDefine option. + */ +bool ASBeautifier::getPreprocDefineIndent() const +{ + return shouldIndentPreprocDefine; +} + +/** + * get the length of the tab indentation option. + * + * @return length of tab indent option. + */ +int ASBeautifier::getTabLength() const +{ + return tabLength; +} + +/** + * beautify a line of source code. + * every line of source code in a source code file should be sent + * one after the other to the beautify method. + * + * @return the indented line. + * @param originalLine the original unindented line. + */ +string ASBeautifier::beautify(const string& originalLine) +{ + string line; + bool isInQuoteContinuation = isInVerbatimQuote || haveLineContinuationChar; + + currentHeader = nullptr; + lastLineHeader = nullptr; + blockCommentNoBeautify = blockCommentNoIndent; + isInClass = false; + isInSwitch = false; + lineBeginsWithOpenBrace = false; + lineBeginsWithCloseBrace = false; + lineBeginsWithComma = false; + lineIsCommentOnly = false; + lineIsLineCommentOnly = false; + shouldIndentBracedLine = true; + isInAsmOneLine = false; + lineOpensWithLineComment = false; + lineOpensWithComment = false; + lineStartsInComment = isInComment; + previousLineProbationTab = false; + lineOpeningBlocksNum = 0; + lineClosingBlocksNum = 0; + if (isImmediatelyPostObjCMethodDefinition) + clearObjCMethodDefinitionAlignment(); + if (isImmediatelyPostObjCMethodCall) + { + isImmediatelyPostObjCMethodCall = false; + isInObjCMethodCall = false; + objCColonAlignSubsequent = 0; + } + + // handle and remove white spaces around the line: + // If not in comment, first find out size of white space before line, + // so that possible comments starting in the line continue in + // relation to the preliminary white-space. + if (isInQuoteContinuation) + { + // trim a single space added by ASFormatter, otherwise leave it alone + if (!(originalLine.length() == 1 && originalLine[0] == ' ')) + line = originalLine; + } + else if (isInComment || isInBeautifySQL) + { + // trim the end of comment and SQL lines + line = originalLine; + size_t trimEnd = line.find_last_not_of(" \t"); + if (trimEnd == string::npos) + trimEnd = 0; + else + trimEnd++; + if (trimEnd < line.length()) + line.erase(trimEnd); + // does a brace open the line + size_t firstChar = line.find_first_not_of(" \t"); + if (firstChar != string::npos) + { + if (line[firstChar] == '{') + lineBeginsWithOpenBrace = true; + else if (line[firstChar] == '}') + lineBeginsWithCloseBrace = true; + else if (line[firstChar] == ',') + lineBeginsWithComma = true; + } + } + else + { + line = trim(originalLine); + if (line.length() > 0) + { + if (line[0] == '{') + lineBeginsWithOpenBrace = true; + else if (line[0] == '}') + lineBeginsWithCloseBrace = true; + else if (line[0] == ',') + lineBeginsWithComma = true; + else if (line.compare(0, 2, "//") == 0) + lineIsLineCommentOnly = true; + else if (line.compare(0, 2, "/*") == 0) + { + if (line.find("*/", 2) != string::npos) + lineIsCommentOnly = true; + } + } + + isInRunInComment = false; + size_t j = line.find_first_not_of(" \t{"); + if (j != string::npos && line.compare(j, 2, "//") == 0) + lineOpensWithLineComment = true; + if (j != string::npos && line.compare(j, 2, "/*") == 0) + { + lineOpensWithComment = true; + size_t k = line.find_first_not_of(" \t"); + if (k != string::npos && line.compare(k, 1, "{") == 0) + isInRunInComment = true; + } + } + + // When indent is OFF the lines must still be processed by ASBeautifier. + // Otherwise the lines immediately following may not be indented correctly. + if ((lineIsLineCommentOnly || lineIsCommentOnly) + && line.find("*INDENT-OFF*", 0) != string::npos) + isIndentModeOff = true; + + if (line.length() == 0) + { + if (backslashEndsPrevLine) + { + backslashEndsPrevLine = false; + // check if this line ends a multi-line #define + // if so, remove the #define's cloned beautifier from the active + // beautifier stack and delete it. + if (isInDefineDefinition && !isInDefine) + { + isInDefineDefinition = false; + ASBeautifier* defineBeautifier = activeBeautifierStack->back(); + activeBeautifierStack->pop_back(); + delete defineBeautifier; + } + } + if (emptyLineFill && !isInQuoteContinuation) + { + if (isInIndentablePreprocBlock) + return preLineWS(preprocBlockIndent, 0); + if (!headerStack->empty() || isInEnum) + return preLineWS(prevFinalLineIndentCount, prevFinalLineSpaceIndentCount); + // must fall thru here + } + else + return line; + } + + // handle preprocessor commands + if (isInIndentablePreprocBlock + && line.length() > 0 + && line[0] != '#') + { + string indentedLine; + if (isInClassHeaderTab || isInClassInitializer) + { + // parsing is turned off in ASFormatter by indent-off + // the originalLine will probably never be returned here + indentedLine = preLineWS(prevFinalLineIndentCount, prevFinalLineSpaceIndentCount) + line; + return getIndentedLineReturn(indentedLine, originalLine); + } + indentedLine = preLineWS(preprocBlockIndent, 0) + line; + return getIndentedLineReturn(indentedLine, originalLine); + } + + if (!isInComment + && !isInQuoteContinuation + && line.length() > 0 + && ((line[0] == '#' && !isIndentedPreprocessor(line, 0)) + || backslashEndsPrevLine)) + { + if (line[0] == '#' && !isInDefine) + { + string preproc = extractPreprocessorStatement(line); + processPreprocessor(preproc, line); + if (isInIndentablePreprocBlock || isInIndentablePreproc) + { + string indentedLine; + if ((preproc.length() >= 2 && preproc.substr(0, 2) == "if")) // #if, #ifdef, #ifndef + { + indentedLine = preLineWS(preprocBlockIndent, 0) + line; + preprocBlockIndent += 1; + isInIndentablePreprocBlock = true; + } + else if (preproc == "else" || preproc == "elif") + { + indentedLine = preLineWS(preprocBlockIndent - 1, 0) + line; + } + else if (preproc == "endif") + { + preprocBlockIndent -= 1; + indentedLine = preLineWS(preprocBlockIndent, 0) + line; + if (preprocBlockIndent == 0) + isInIndentablePreprocBlock = false; + } + else + indentedLine = preLineWS(preprocBlockIndent, 0) + line; + return getIndentedLineReturn(indentedLine, originalLine); + } + if (shouldIndentPreprocConditional && preproc.length() > 0) + { + string indentedLine; + if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef + { + pair entry; // indentCount, spaceIndentCount + if (!isInDefine && activeBeautifierStack != nullptr && !activeBeautifierStack->empty()) + entry = activeBeautifierStack->back()->computePreprocessorIndent(); + else + entry = computePreprocessorIndent(); + preprocIndentStack->emplace_back(entry); + indentedLine = preLineWS(preprocIndentStack->back().first, + preprocIndentStack->back().second) + line; + return getIndentedLineReturn(indentedLine, originalLine); + } + if (preproc == "else" || preproc == "elif") + { + if (!preprocIndentStack->empty()) // if no entry don't indent + { + indentedLine = preLineWS(preprocIndentStack->back().first, + preprocIndentStack->back().second) + line; + return getIndentedLineReturn(indentedLine, originalLine); + } + } + else if (preproc == "endif") + { + if (!preprocIndentStack->empty()) // if no entry don't indent + { + indentedLine = preLineWS(preprocIndentStack->back().first, + preprocIndentStack->back().second) + line; + preprocIndentStack->pop_back(); + return getIndentedLineReturn(indentedLine, originalLine); + } + } + } + } + + // check if the last char is a backslash + if (line.length() > 0) + backslashEndsPrevLine = (line[line.length() - 1] == '\\'); + // comments within the definition line can be continued without the backslash + if (isInPreprocessorUnterminatedComment(line)) + backslashEndsPrevLine = true; + + // check if this line ends a multi-line #define + // if so, use the #define's cloned beautifier for the line's indentation + // and then remove it from the active beautifier stack and delete it. + if (!backslashEndsPrevLine && isInDefineDefinition && !isInDefine) + { + isInDefineDefinition = false; + ASBeautifier* defineBeautifier = activeBeautifierStack->back(); + activeBeautifierStack->pop_back(); + + string indentedLine = defineBeautifier->beautify(line); + delete defineBeautifier; + return getIndentedLineReturn(indentedLine, originalLine); + } + + // unless this is a multi-line #define, return this precompiler line as is. + if (!isInDefine && !isInDefineDefinition) + return originalLine; + } + + // if there exists any worker beautifier in the activeBeautifierStack, + // then use it instead of me to indent the current line. + // variables set by ASFormatter must be updated. + if (!isInDefine && activeBeautifierStack != nullptr && !activeBeautifierStack->empty()) + { + activeBeautifierStack->back()->inLineNumber = inLineNumber; + activeBeautifierStack->back()->runInIndentContinuation = runInIndentContinuation; + activeBeautifierStack->back()->nonInStatementBrace = nonInStatementBrace; + activeBeautifierStack->back()->objCColonAlignSubsequent = objCColonAlignSubsequent; + activeBeautifierStack->back()->lineCommentNoBeautify = lineCommentNoBeautify; + activeBeautifierStack->back()->isElseHeaderIndent = isElseHeaderIndent; + activeBeautifierStack->back()->isCaseHeaderCommentIndent = isCaseHeaderCommentIndent; + activeBeautifierStack->back()->isNonInStatementArray = isNonInStatementArray; + activeBeautifierStack->back()->isSharpAccessor = isSharpAccessor; + activeBeautifierStack->back()->isSharpDelegate = isSharpDelegate; + activeBeautifierStack->back()->isInExternC = isInExternC; + activeBeautifierStack->back()->isInBeautifySQL = isInBeautifySQL; + activeBeautifierStack->back()->isInIndentableStruct = isInIndentableStruct; + activeBeautifierStack->back()->isInIndentablePreproc = isInIndentablePreproc; + // must return originalLine not the trimmed line + return activeBeautifierStack->back()->beautify(originalLine); + } + + // Flag an indented header in case this line is a one-line block. + // The header in the header stack will be deleted by a one-line block. + bool isInExtraHeaderIndent = false; + if (!headerStack->empty() + && lineBeginsWithOpenBrace + && (headerStack->back() != &AS_OPEN_BRACE + || probationHeader != nullptr)) + isInExtraHeaderIndent = true; + + size_t iPrelim = headerStack->size(); + + // calculate preliminary indentation based on headerStack and data from past lines + computePreliminaryIndentation(); + + // parse characters in the current line. + parseCurrentLine(line); + + // handle special cases of indentation + adjustParsedLineIndentation(iPrelim, isInExtraHeaderIndent); + + if (isInObjCMethodDefinition) + adjustObjCMethodDefinitionIndentation(line); + + if (isInObjCMethodCall) + adjustObjCMethodCallIndentation(line); + + if (isInDefine) + { + if (line.length() > 0 && line[0] == '#') + { + // the 'define' does not have to be attached to the '#' + string preproc = trim(line.substr(1)); + if (preproc.compare(0, 6, "define") == 0) + { + if (!continuationIndentStack->empty() + && continuationIndentStack->back() > 0) + { + defineIndentCount = indentCount; + } + else + { + defineIndentCount = indentCount - 1; + --indentCount; + } + } + } + + indentCount -= defineIndentCount; + } + + if (indentCount < 0) + indentCount = 0; + + if (lineCommentNoBeautify || blockCommentNoBeautify || isInQuoteContinuation) + indentCount = spaceIndentCount = 0; + + // finally, insert indentations into beginning of line + + string indentedLine = preLineWS(indentCount, spaceIndentCount) + line; + indentedLine = getIndentedLineReturn(indentedLine, originalLine); + + prevFinalLineSpaceIndentCount = spaceIndentCount; + prevFinalLineIndentCount = indentCount; + + if (lastLineHeader != nullptr) + previousLastLineHeader = lastLineHeader; + + if ((lineIsLineCommentOnly || lineIsCommentOnly) + && line.find("*INDENT-ON*", 0) != string::npos) + isIndentModeOff = false; + + return indentedLine; +} + +const string& ASBeautifier::getIndentedLineReturn(const string& newLine, const string& originalLine) const +{ + if (isIndentModeOff) + return originalLine; + return newLine; +} + +string ASBeautifier::preLineWS(int lineIndentCount, int lineSpaceIndentCount) const +{ + if (shouldForceTabIndentation) + { + if (tabLength != indentLength) + { + // adjust for different tab length + int indentCountOrig = lineIndentCount; + int spaceIndentCountOrig = lineSpaceIndentCount; + lineIndentCount = ((indentCountOrig * indentLength) + spaceIndentCountOrig) / tabLength; + lineSpaceIndentCount = ((indentCountOrig * indentLength) + spaceIndentCountOrig) % tabLength; + } + else + { + lineIndentCount += lineSpaceIndentCount / indentLength; + lineSpaceIndentCount = lineSpaceIndentCount % indentLength; + } + } + + string ws; + for (int i = 0; i < lineIndentCount; i++) + ws += indentString; + while ((lineSpaceIndentCount--) > 0) + ws += string(" "); + return ws; +} + +/** + * register a continuation indent. + */ +void ASBeautifier::registerContinuationIndent(const string& line, int i, int spaceIndentCount_, + int tabIncrementIn, int minIndent, bool updateParenStack) +{ + int remainingCharNum = line.length() - i; + int nextNonWSChar = getNextProgramCharDistance(line, i); + + // if indent is around the last char in the line OR indent-after-paren is requested, + // indent with the continuation indent + if (nextNonWSChar == remainingCharNum || shouldIndentAfterParen) + { + int previousIndent = spaceIndentCount_; + if (!continuationIndentStack->empty()) + previousIndent = continuationIndentStack->back(); + int currIndent = continuationIndent * indentLength + previousIndent; + if (currIndent > maxContinuationIndent && line[i] != '{') + currIndent = indentLength * 2 + spaceIndentCount_; + continuationIndentStack->emplace_back(currIndent); + if (updateParenStack) + parenIndentStack->emplace_back(previousIndent); + return; + } + + if (updateParenStack) + parenIndentStack->emplace_back(i + spaceIndentCount_ - runInIndentContinuation); + + int tabIncrement = tabIncrementIn; + + // check for following tabs + for (int j = i + 1; j < (i + nextNonWSChar); j++) + { + if (line[j] == '\t') + tabIncrement += convertTabToSpaces(j, tabIncrement); + } + + int continuationIndentCount = i + nextNonWSChar + spaceIndentCount_ + tabIncrement; + + // check for run-in statement + if (i > 0 && line[0] == '{') + continuationIndentCount -= indentLength; + + if (continuationIndentCount < minIndent) + continuationIndentCount = minIndent + spaceIndentCount_; + + // this is not done for an in-statement array + if (continuationIndentCount > maxContinuationIndent + && !(prevNonLegalCh == '=' && currentNonLegalCh == '{')) + continuationIndentCount = indentLength * 2 + spaceIndentCount_; + + if (!continuationIndentStack->empty() + && continuationIndentCount < continuationIndentStack->back()) + continuationIndentCount = continuationIndentStack->back(); + + // the block opener is not indented for a NonInStatementArray + if ((isNonInStatementArray && line[i] == '{') + && !isInEnum && !braceBlockStateStack->empty() && braceBlockStateStack->back()) + continuationIndentCount = 0; + + continuationIndentStack->emplace_back(continuationIndentCount); +} + +/** +* Register a continuation indent for a class header or a class initializer colon. +*/ +void ASBeautifier::registerContinuationIndentColon(const string& line, int i, int tabIncrementIn) +{ + assert(line[i] == ':'); + assert(isInClassInitializer || isInClassHeaderTab); + + // register indent at first word after the colon + size_t firstChar = line.find_first_not_of(" \t"); + if (firstChar == (size_t) i) // firstChar is ':' + { + size_t firstWord = line.find_first_not_of(" \t", firstChar + 1); + if (firstChar != string::npos) + { + int continuationIndentCount = firstWord + spaceIndentCount + tabIncrementIn; + continuationIndentStack->emplace_back(continuationIndentCount); + isContinuation = true; + } + } +} + +/** + * Compute indentation for a preprocessor #if statement. + * This may be called for the activeBeautiferStack + * instead of the active ASBeautifier object. + */ +pair ASBeautifier::computePreprocessorIndent() +{ + computePreliminaryIndentation(); + pair entry(indentCount, spaceIndentCount); + if (!headerStack->empty() + && entry.first > 0 + && (headerStack->back() == &AS_IF + || headerStack->back() == &AS_ELSE + || headerStack->back() == &AS_FOR + || headerStack->back() == &AS_WHILE)) + --entry.first; + return entry; +} + +/** + * get distance to the next non-white space, non-comment character in the line. + * if no such character exists, return the length remaining to the end of the line. + */ +int ASBeautifier::getNextProgramCharDistance(const string& line, int i) const +{ + bool inComment = false; + int remainingCharNum = line.length() - i; + int charDistance; + char ch; + + for (charDistance = 1; charDistance < remainingCharNum; charDistance++) + { + ch = line[i + charDistance]; + if (inComment) + { + if (line.compare(i + charDistance, 2, "*/") == 0) + { + charDistance++; + inComment = false; + } + continue; + } + else if (isWhiteSpace(ch)) + continue; + else if (ch == '/') + { + if (line.compare(i + charDistance, 2, "//") == 0) + return remainingCharNum; + if (line.compare(i + charDistance, 2, "/*") == 0) + { + charDistance++; + inComment = true; + } + } + else + return charDistance; + } + + return charDistance; +} + +/** + * find the index number of a string element in a container of strings + * + * @return the index number of element in the container. -1 if element not found. + * @param container a vector of strings. + * @param element the element to find . + */ +int ASBeautifier::indexOf(const vector& container, const string* element) const +{ + vector::const_iterator where; + + where = find(container.begin(), container.end(), element); + if (where == container.end()) + return -1; + return (int) (where - container.begin()); +} + +/** + * convert tabs to spaces. + * i is the position of the character to convert to spaces. + * tabIncrementIn is the increment that must be added for tab indent characters + * to get the correct column for the current tab. + */ +int ASBeautifier::convertTabToSpaces(int i, int tabIncrementIn) const +{ + int tabToSpacesAdjustment = indentLength - 1 - ((tabIncrementIn + i) % indentLength); + return tabToSpacesAdjustment; +} + +/** + * trim removes the white space surrounding a line. + * + * @return the trimmed line. + * @param str the line to trim. + */ +string ASBeautifier::trim(const string& str) const +{ + int start = 0; + int end = str.length() - 1; + + while (start < end && isWhiteSpace(str[start])) + start++; + + while (start <= end && isWhiteSpace(str[end])) + end--; + + // don't trim if it ends in a continuation + if (end > -1 && str[end] == '\\') + end = str.length() - 1; + + string returnStr(str, start, end + 1 - start); + return returnStr; +} + +/** + * rtrim removes the white space from the end of a line. + * + * @return the trimmed line. + * @param str the line to trim. + */ +string ASBeautifier::rtrim(const string& str) const +{ + size_t len = str.length(); + size_t end = str.find_last_not_of(" \t"); + if (end == string::npos + || end == len - 1) + return str; + string returnStr(str, 0, end + 1); + return returnStr; +} + +/** + * Copy tempStacks for the copy constructor. + * The value of the vectors must also be copied. + */ +vector*>* ASBeautifier::copyTempStacks(const ASBeautifier& other) const +{ + vector*>* tempStacksNew = new vector*>; + vector*>::iterator iter; + for (iter = other.tempStacks->begin(); + iter != other.tempStacks->end(); + ++iter) + { + vector* newVec = new vector; + *newVec = **iter; + tempStacksNew->emplace_back(newVec); + } + return tempStacksNew; +} + +/** + * delete a member vectors to eliminate memory leak reporting + */ +void ASBeautifier::deleteBeautifierVectors() +{ + beautifierFileType = 9; // reset to an invalid type + delete headers; + delete nonParenHeaders; + delete preBlockStatements; + delete preCommandHeaders; + delete assignmentOperators; + delete nonAssignmentOperators; + delete indentableHeaders; +} + +/** + * delete a vector object + * T is the type of vector + * used for all vectors except tempStacks + */ +template +void ASBeautifier::deleteContainer(T& container) +{ + if (container != nullptr) + { + container->clear(); + delete (container); + container = nullptr; + } +} + +/** + * Delete the ASBeautifier vector object. + * This is a vector of pointers to ASBeautifier objects allocated with the 'new' operator. + * Therefore the ASBeautifier objects have to be deleted in addition to the + * ASBeautifier pointer entries. + */ +void ASBeautifier::deleteBeautifierContainer(vector*& container) +{ + if (container != nullptr) + { + vector::iterator iter = container->begin(); + while (iter < container->end()) + { + delete *iter; + ++iter; + } + container->clear(); + delete (container); + container = nullptr; + } +} + +/** + * Delete the tempStacks vector object. + * The tempStacks is a vector of pointers to strings allocated with the 'new' operator. + * Therefore the strings have to be deleted in addition to the tempStacks entries. + */ +void ASBeautifier::deleteTempStacksContainer(vector*>*& container) +{ + if (container != nullptr) + { + vector*>::iterator iter = container->begin(); + while (iter < container->end()) + { + delete *iter; + ++iter; + } + container->clear(); + delete (container); + container = nullptr; + } +} + +/** + * initialize a vector object + * T is the type of vector used for all vectors + */ +template +void ASBeautifier::initContainer(T& container, T value) +{ + // since the ASFormatter object is never deleted, + // the existing vectors must be deleted before creating new ones + if (container != nullptr) + deleteContainer(container); + container = value; +} + +/** + * Initialize the tempStacks vector object. + * The tempStacks is a vector of pointers to strings allocated with the 'new' operator. + * Any residual entries are deleted before the vector is initialized. + */ +void ASBeautifier::initTempStacksContainer(vector*>*& container, + vector*>* value) +{ + if (container != nullptr) + deleteTempStacksContainer(container); + container = value; +} + +/** + * Determine if an assignment statement ends with a comma + * that is not in a function argument. It ends with a + * comma if a comma is the last char on the line. + * + * @return true if line ends with a comma, otherwise false. + */ +bool ASBeautifier::statementEndsWithComma(const string& line, int index) const +{ + assert(line[index] == '='); + + bool isInComment_ = false; + bool isInQuote_ = false; + int parenCount = 0; + size_t lineLength = line.length(); + size_t i = 0; + char quoteChar_ = ' '; + + for (i = index + 1; i < lineLength; ++i) + { + char ch = line[i]; + + if (isInComment_) + { + if (line.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + + if (ch == '\\') + { + ++i; + continue; + } + + if (isInQuote_) + { + if (ch == quoteChar_) + isInQuote_ = false; + continue; + } + + if (ch == '"' + || (ch == '\'' && !isDigitSeparator(line, i))) + { + isInQuote_ = true; + quoteChar_ = ch; + continue; + } + + if (line.compare(i, 2, "//") == 0) + break; + + if (line.compare(i, 2, "/*") == 0) + { + if (isLineEndComment(line, i)) + break; + else + { + isInComment_ = true; + ++i; + continue; + } + } + + if (ch == '(') + parenCount++; + if (ch == ')') + parenCount--; + } + if (isInComment_ + || isInQuote_ + || parenCount > 0) + return false; + + size_t lastChar = line.find_last_not_of(" \t", i - 1); + + if (lastChar == string::npos || line[lastChar] != ',') + return false; + + return true; +} + +/** + * check if current comment is a line-end comment + * + * @return is before a line-end comment. + */ +bool ASBeautifier::isLineEndComment(const string& line, int startPos) const +{ + assert(line.compare(startPos, 2, "/*") == 0); + + // comment must be closed on this line with nothing after it + size_t endNum = line.find("*/", startPos + 2); + if (endNum != string::npos) + { + size_t nextChar = line.find_first_not_of(" \t", endNum + 2); + if (nextChar == string::npos) + return true; + } + return false; +} + +/** + * get the previous word index for an assignment operator + * + * @return is the index to the previous word (the in statement indent). + */ +int ASBeautifier::getContinuationIndentAssign(const string& line, size_t currPos) const +{ + assert(line[currPos] == '='); + + if (currPos == 0) + return 0; + + // get the last legal word (may be a number) + size_t end = line.find_last_not_of(" \t", currPos - 1); + if (end == string::npos || !isLegalNameChar(line[end])) + return 0; + + int start; // start of the previous word + for (start = end; start > -1; start--) + { + if (!isLegalNameChar(line[start]) || line[start] == '.') + break; + } + start++; + + return start; +} + +/** + * get the instatement indent for a comma + * + * @return is the indent to the second word on the line (the in statement indent). + */ +int ASBeautifier::getContinuationIndentComma(const string& line, size_t currPos) const +{ + assert(line[currPos] == ','); + + // get first word on a line + size_t indent = line.find_first_not_of(" \t"); + if (indent == string::npos || !isLegalNameChar(line[indent])) + return 0; + + // bypass first word + for (; indent < currPos; indent++) + { + if (!isLegalNameChar(line[indent])) + break; + } + indent++; + if (indent >= currPos || indent < 4) + return 0; + + // point to second word or assignment operator + indent = line.find_first_not_of(" \t", indent); + if (indent == string::npos || indent >= currPos) + return 0; + + return indent; +} + +/** + * get the next word on a line + * the argument 'currPos' must point to the current position. + * + * @return is the next word or an empty string if none found. + */ +string ASBeautifier::getNextWord(const string& line, size_t currPos) const +{ + size_t lineLength = line.length(); + // get the last legal word (may be a number) + if (currPos == lineLength - 1) + return string(); + + size_t start = line.find_first_not_of(" \t", currPos + 1); + if (start == string::npos || !isLegalNameChar(line[start])) + return string(); + + size_t end; // end of the current word + for (end = start + 1; end <= lineLength; end++) + { + if (!isLegalNameChar(line[end]) || line[end] == '.') + break; + } + + return line.substr(start, end - start); +} + +/** + * Check if a preprocessor directive is always indented. + * C# "region" and "endregion" are always indented. + * C/C++ "pragma omp" is always indented. + * + * @return is true or false. + */ +bool ASBeautifier::isIndentedPreprocessor(const string& line, size_t currPos) const +{ + assert(line[0] == '#'); + string nextWord = getNextWord(line, currPos); + if (nextWord == "region" || nextWord == "endregion") + return true; + // is it #pragma omp + if (nextWord == "pragma") + { + // find pragma + size_t start = line.find("pragma"); + if (start == string::npos || !isLegalNameChar(line[start])) + return false; + // bypass pragma + for (; start < line.length(); start++) + { + if (!isLegalNameChar(line[start])) + break; + } + start++; + if (start >= line.length()) + return false; + // point to start of second word + start = line.find_first_not_of(" \t", start); + if (start == string::npos) + return false; + // point to end of second word + size_t end; + for (end = start; end < line.length(); end++) + { + if (!isLegalNameChar(line[end])) + break; + } + // check for "pragma omp" + string word = line.substr(start, end - start); + if (word == "omp" || word == "region" || word == "endregion") + return true; + } + return false; +} + +/** + * Check if a preprocessor directive is checking for __cplusplus defined. + * + * @return is true or false. + */ +bool ASBeautifier::isPreprocessorConditionalCplusplus(const string& line) const +{ + string preproc = trim(line.substr(1)); + if (preproc.compare(0, 5, "ifdef") == 0 && getNextWord(preproc, 4) == "__cplusplus") + return true; + if (preproc.compare(0, 2, "if") == 0) + { + // check for " #if defined(__cplusplus)" + size_t charNum = 2; + charNum = preproc.find_first_not_of(" \t", charNum); + if (charNum != string::npos && preproc.compare(charNum, 7, "defined") == 0) + { + charNum += 7; + charNum = preproc.find_first_not_of(" \t", charNum); + if (preproc.compare(charNum, 1, "(") == 0) + { + ++charNum; + charNum = preproc.find_first_not_of(" \t", charNum); + if (preproc.compare(charNum, 11, "__cplusplus") == 0) + return true; + } + } + } + return false; +} + +/** + * Check if a preprocessor definition contains an unterminated comment. + * Comments within a preprocessor definition can be continued without the backslash. + * + * @return is true or false. + */ +bool ASBeautifier::isInPreprocessorUnterminatedComment(const string& line) +{ + if (!isInPreprocessorComment) + { + size_t startPos = line.find("/*"); + if (startPos == string::npos) + return false; + } + size_t endNum = line.find("*/"); + if (endNum != string::npos) + { + isInPreprocessorComment = false; + return false; + } + isInPreprocessorComment = true; + return true; +} + +void ASBeautifier::popLastContinuationIndent() +{ + assert(!continuationIndentStackSizeStack->empty()); + int previousIndentStackSize = continuationIndentStackSizeStack->back(); + if (continuationIndentStackSizeStack->size() > 1) + continuationIndentStackSizeStack->pop_back(); + while (previousIndentStackSize < (int) continuationIndentStack->size()) + continuationIndentStack->pop_back(); +} + +// for unit testing +int ASBeautifier::getBeautifierFileType() const +{ return beautifierFileType; } + +/** + * Process preprocessor statements and update the beautifier stacks. + */ +void ASBeautifier::processPreprocessor(const string& preproc, const string& line) +{ + // When finding a multi-lined #define statement, the original beautifier + // 1. sets its isInDefineDefinition flag + // 2. clones a new beautifier that will be used for the actual indentation + // of the #define. This clone is put into the activeBeautifierStack in order + // to be called for the actual indentation. + // The original beautifier will have isInDefineDefinition = true, isInDefine = false + // The cloned beautifier will have isInDefineDefinition = true, isInDefine = true + if (shouldIndentPreprocDefine && preproc == "define" && line[line.length() - 1] == '\\') + { + if (!isInDefineDefinition) + { + // this is the original beautifier + isInDefineDefinition = true; + + // push a new beautifier into the active stack + // this beautifier will be used for the indentation of this define + ASBeautifier* defineBeautifier = new ASBeautifier(*this); + activeBeautifierStack->emplace_back(defineBeautifier); + } + else + { + // the is the cloned beautifier that is in charge of indenting the #define. + isInDefine = true; + } + } + else if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") + { + if (isPreprocessorConditionalCplusplus(line) && !g_preprocessorCppExternCBrace) + g_preprocessorCppExternCBrace = 1; + // push a new beautifier into the stack + waitingBeautifierStackLengthStack->push_back(waitingBeautifierStack->size()); + activeBeautifierStackLengthStack->push_back(activeBeautifierStack->size()); + if (activeBeautifierStackLengthStack->back() == 0) + waitingBeautifierStack->emplace_back(new ASBeautifier(*this)); + else + waitingBeautifierStack->emplace_back(new ASBeautifier(*activeBeautifierStack->back())); + } + else if (preproc == "else") + { + if ((waitingBeautifierStack != nullptr) && !waitingBeautifierStack->empty()) + { + // MOVE current waiting beautifier to active stack. + activeBeautifierStack->emplace_back(waitingBeautifierStack->back()); + waitingBeautifierStack->pop_back(); + } + } + else if (preproc == "elif") + { + if ((waitingBeautifierStack != nullptr) && !waitingBeautifierStack->empty()) + { + // append a COPY current waiting beautifier to active stack, WITHOUT deleting the original. + activeBeautifierStack->emplace_back(new ASBeautifier(*(waitingBeautifierStack->back()))); + } + } + else if (preproc == "endif") + { + int stackLength = 0; + ASBeautifier* beautifier = nullptr; + + if (waitingBeautifierStackLengthStack != nullptr && !waitingBeautifierStackLengthStack->empty()) + { + stackLength = waitingBeautifierStackLengthStack->back(); + waitingBeautifierStackLengthStack->pop_back(); + while ((int) waitingBeautifierStack->size() > stackLength) + { + beautifier = waitingBeautifierStack->back(); + waitingBeautifierStack->pop_back(); + delete beautifier; + } + } + + if (!activeBeautifierStackLengthStack->empty()) + { + stackLength = activeBeautifierStackLengthStack->back(); + activeBeautifierStackLengthStack->pop_back(); + while ((int) activeBeautifierStack->size() > stackLength) + { + beautifier = activeBeautifierStack->back(); + activeBeautifierStack->pop_back(); + delete beautifier; + } + } + } +} + +// Compute the preliminary indentation based on data in the headerStack +// and data from previous lines. +// Update the class variable indentCount. +void ASBeautifier::computePreliminaryIndentation() +{ + indentCount = 0; + spaceIndentCount = 0; + isInClassHeaderTab = false; + + if (isInObjCMethodDefinition && !continuationIndentStack->empty()) + spaceIndentObjCMethodAlignment = continuationIndentStack->back(); + + if (!continuationIndentStack->empty()) + spaceIndentCount = continuationIndentStack->back(); + + for (size_t i = 0; i < headerStack->size(); i++) + { + isInClass = false; + + if (blockIndent) + { + // do NOT indent opening block for these headers + if (!((*headerStack)[i] == &AS_NAMESPACE + || (*headerStack)[i] == &AS_MODULE + || (*headerStack)[i] == &AS_CLASS + || (*headerStack)[i] == &AS_STRUCT + || (*headerStack)[i] == &AS_UNION + || (*headerStack)[i] == &AS_INTERFACE + || (*headerStack)[i] == &AS_THROWS + || (*headerStack)[i] == &AS_STATIC)) + ++indentCount; + } + else if (!(i > 0 && (*headerStack)[i - 1] != &AS_OPEN_BRACE + && (*headerStack)[i] == &AS_OPEN_BRACE)) + ++indentCount; + + if (!isJavaStyle() && !namespaceIndent && i > 0 + && ((*headerStack)[i - 1] == &AS_NAMESPACE + || (*headerStack)[i - 1] == &AS_MODULE) + && (*headerStack)[i] == &AS_OPEN_BRACE) + --indentCount; + + if (isCStyle() && i >= 1 + && (*headerStack)[i - 1] == &AS_CLASS + && (*headerStack)[i] == &AS_OPEN_BRACE) + { + if (classIndent) + ++indentCount; + isInClass = true; + } + + // is the switchIndent option is on, indent switch statements an additional indent. + else if (switchIndent && i > 1 + && (*headerStack)[i - 1] == &AS_SWITCH + && (*headerStack)[i] == &AS_OPEN_BRACE) + { + ++indentCount; + isInSwitch = true; + } + + } // end of for loop + + if (isInClassHeader) + { + if (!isJavaStyle()) + isInClassHeaderTab = true; + if (lineOpensWithLineComment || lineStartsInComment || lineOpensWithComment) + { + if (!lineBeginsWithOpenBrace) + --indentCount; + if (!continuationIndentStack->empty()) + spaceIndentCount -= continuationIndentStack->back(); + } + else if (blockIndent) + { + if (!lineBeginsWithOpenBrace) + ++indentCount; + } + } + + if (isInClassInitializer || isInEnumTypeID) + { + indentCount += classInitializerIndents; + } + + if (isInEnum && lineBeginsWithComma && !continuationIndentStack->empty()) + { + // unregister '=' indent from the previous line + continuationIndentStack->pop_back(); + isContinuation = false; + spaceIndentCount = 0; + } + + // Objective-C interface continuation line + if (isInObjCInterface) + ++indentCount; + + // unindent a class closing brace... + if (!lineStartsInComment + && isCStyle() + && isInClass + && classIndent + && headerStack->size() >= 2 + && (*headerStack)[headerStack->size() - 2] == &AS_CLASS + && (*headerStack)[headerStack->size() - 1] == &AS_OPEN_BRACE + && lineBeginsWithCloseBrace + && braceBlockStateStack->back()) + --indentCount; + + // unindent an indented switch closing brace... + else if (!lineStartsInComment + && isInSwitch + && switchIndent + && headerStack->size() >= 2 + && (*headerStack)[headerStack->size() - 2] == &AS_SWITCH + && (*headerStack)[headerStack->size() - 1] == &AS_OPEN_BRACE + && lineBeginsWithCloseBrace) + --indentCount; + + // handle special case of run-in comment in an indented class statement + if (isInClass + && classIndent + && isInRunInComment + && !lineOpensWithComment + && headerStack->size() > 1 + && (*headerStack)[headerStack->size() - 2] == &AS_CLASS) + --indentCount; + + if (isInConditional) + --indentCount; + if (g_preprocessorCppExternCBrace >= 4) + --indentCount; +} + +void ASBeautifier::adjustParsedLineIndentation(size_t iPrelim, bool isInExtraHeaderIndent) +{ + if (lineStartsInComment) + return; + + // unindent a one-line statement in a header indent + if (!blockIndent + && lineBeginsWithOpenBrace + && headerStack->size() < iPrelim + && isInExtraHeaderIndent + && (lineOpeningBlocksNum > 0 && lineOpeningBlocksNum <= lineClosingBlocksNum) + && shouldIndentBracedLine) + --indentCount; + + /* + * if '{' doesn't follow an immediately previous '{' in the headerStack + * (but rather another header such as "for" or "if", then unindent it + * by one indentation relative to its block. + */ + else if (!blockIndent + && lineBeginsWithOpenBrace + && !(lineOpeningBlocksNum > 0 && lineOpeningBlocksNum <= lineClosingBlocksNum) + && (headerStack->size() > 1 && (*headerStack)[headerStack->size() - 2] != &AS_OPEN_BRACE) + && shouldIndentBracedLine) + --indentCount; + + // must check one less in headerStack if more than one header on a line (allow-addins)... + else if (headerStack->size() > iPrelim + 1 + && !blockIndent + && lineBeginsWithOpenBrace + && !(lineOpeningBlocksNum > 0 && lineOpeningBlocksNum <= lineClosingBlocksNum) + && (headerStack->size() > 2 && (*headerStack)[headerStack->size() - 3] != &AS_OPEN_BRACE) + && shouldIndentBracedLine) + --indentCount; + + // unindent a closing brace... + else if (lineBeginsWithCloseBrace + && shouldIndentBracedLine) + --indentCount; + + // correctly indent one-line-blocks... + else if (lineOpeningBlocksNum > 0 + && lineOpeningBlocksNum == lineClosingBlocksNum + && previousLineProbationTab) + --indentCount; + + if (indentCount < 0) + indentCount = 0; + + // take care of extra brace indentation option... + if (!lineStartsInComment + && braceIndent + && shouldIndentBracedLine + && (lineBeginsWithOpenBrace || lineBeginsWithCloseBrace)) + { + if (!braceIndentVtk) + ++indentCount; + else + { + // determine if a style VTK brace is indented + bool haveUnindentedBrace = false; + for (size_t i = 0; i < headerStack->size(); i++) + { + if (((*headerStack)[i] == &AS_NAMESPACE + || (*headerStack)[i] == &AS_MODULE + || (*headerStack)[i] == &AS_CLASS + || (*headerStack)[i] == &AS_STRUCT) + && i + 1 < headerStack->size() + && (*headerStack)[i + 1] == &AS_OPEN_BRACE) + i++; + else if (lineBeginsWithOpenBrace) + { + // don't double count the current brace + if (i + 1 < headerStack->size() + && (*headerStack)[i] == &AS_OPEN_BRACE) + haveUnindentedBrace = true; + } + else if ((*headerStack)[i] == &AS_OPEN_BRACE) + haveUnindentedBrace = true; + } // end of for loop + if (haveUnindentedBrace) + ++indentCount; + } + } +} + +/** + * Compute indentCount adjustment when in a series of else-if statements + * and shouldBreakElseIfs is requested. + * It increments by one for each 'else' in the tempStack. + */ +int ASBeautifier::adjustIndentCountForBreakElseIfComments() const +{ + assert(isElseHeaderIndent && !tempStacks->empty()); + int indentCountIncrement = 0; + vector* lastTempStack = tempStacks->back(); + if (lastTempStack != nullptr) + { + for (size_t i = 0; i < lastTempStack->size(); i++) + { + if (*lastTempStack->at(i) == AS_ELSE) + indentCountIncrement++; + } + } + return indentCountIncrement; +} + +/** + * Extract a preprocessor statement without the #. + * If a error occurs an empty string is returned. + */ +string ASBeautifier::extractPreprocessorStatement(const string& line) const +{ + string preproc; + size_t start = line.find_first_not_of("#/ \t"); + if (start == string::npos) + return preproc; + size_t end = line.find_first_of("/ \t", start); + if (end == string::npos) + end = line.length(); + preproc = line.substr(start, end - start); + return preproc; +} + +void ASBeautifier::adjustObjCMethodDefinitionIndentation(const string& line_) +{ + // register indent for Objective-C continuation line + if (line_.length() > 0 + && (line_[0] == '-' || line_[0] == '+')) + { + if (shouldAlignMethodColon && objCColonAlignSubsequent != -1) + { + string convertedLine = getIndentedSpaceEquivalent(line_); + colonIndentObjCMethodAlignment = convertedLine.find(':'); + int objCColonAlignSubsequentIndent = objCColonAlignSubsequent + indentLength; + if (objCColonAlignSubsequentIndent > colonIndentObjCMethodAlignment) + colonIndentObjCMethodAlignment = objCColonAlignSubsequentIndent; + } + else if (continuationIndentStack->empty() + || continuationIndentStack->back() == 0) + { + continuationIndentStack->emplace_back(indentLength); + isContinuation = true; + } + } + // set indent for last definition line + else if (!lineBeginsWithOpenBrace) + { + if (shouldAlignMethodColon) + spaceIndentCount = computeObjCColonAlignment(line_, colonIndentObjCMethodAlignment); + else if (continuationIndentStack->empty()) + spaceIndentCount = spaceIndentObjCMethodAlignment; + } +} + +void ASBeautifier::adjustObjCMethodCallIndentation(const string& line_) +{ + static int keywordIndentObjCMethodAlignment = 0; + if (shouldAlignMethodColon && objCColonAlignSubsequent != -1) + { + if (isInObjCMethodCallFirst) + { + isInObjCMethodCallFirst = false; + string convertedLine = getIndentedSpaceEquivalent(line_); + bracePosObjCMethodAlignment = convertedLine.find('['); + keywordIndentObjCMethodAlignment = + getObjCFollowingKeyword(convertedLine, bracePosObjCMethodAlignment); + colonIndentObjCMethodAlignment = convertedLine.find(':'); + if (colonIndentObjCMethodAlignment >= 0) + { + int objCColonAlignSubsequentIndent = objCColonAlignSubsequent + indentLength; + if (objCColonAlignSubsequentIndent > colonIndentObjCMethodAlignment) + colonIndentObjCMethodAlignment = objCColonAlignSubsequentIndent; + if (lineBeginsWithOpenBrace) + colonIndentObjCMethodAlignment -= indentLength; + } + } + else + { + if (line_.find(':') != string::npos) + { + if (colonIndentObjCMethodAlignment < 0) + spaceIndentCount += computeObjCColonAlignment(line_, objCColonAlignSubsequent); + else if (objCColonAlignSubsequent > colonIndentObjCMethodAlignment) + spaceIndentCount = computeObjCColonAlignment(line_, objCColonAlignSubsequent); + else + spaceIndentCount = computeObjCColonAlignment(line_, colonIndentObjCMethodAlignment); + } + else + { + if (spaceIndentCount < colonIndentObjCMethodAlignment) + spaceIndentCount += keywordIndentObjCMethodAlignment; + } + } + } + else // align keywords instead of colons + { + if (isInObjCMethodCallFirst) + { + isInObjCMethodCallFirst = false; + string convertedLine = getIndentedSpaceEquivalent(line_); + bracePosObjCMethodAlignment = convertedLine.find('['); + keywordIndentObjCMethodAlignment = + getObjCFollowingKeyword(convertedLine, bracePosObjCMethodAlignment); + } + else + { + if (spaceIndentCount < keywordIndentObjCMethodAlignment + bracePosObjCMethodAlignment) + spaceIndentCount += keywordIndentObjCMethodAlignment; + } + } +} + +/** + * Clear the variables used to align the Objective-C method definitions. + */ +void ASBeautifier::clearObjCMethodDefinitionAlignment() +{ + assert(isImmediatelyPostObjCMethodDefinition); + spaceIndentCount = 0; + spaceIndentObjCMethodAlignment = 0; + colonIndentObjCMethodAlignment = 0; + isInObjCMethodDefinition = false; + isImmediatelyPostObjCMethodDefinition = false; + if (!continuationIndentStack->empty()) + continuationIndentStack->pop_back(); +} + +/** + * Compute the spaceIndentCount necessary to align the current line colon + * with the colon position in the argument. + * If it cannot be aligned indentLength is returned and a new colon + * position is calculated. + */ +int ASBeautifier::computeObjCColonAlignment(const string& line, int colonAlignPosition) const +{ + int colonPosition = line.find(':'); + if (colonPosition < 0 || colonPosition > colonAlignPosition) + return indentLength; + return (colonAlignPosition - colonPosition); +} + +/* + * Compute postition of the keyword following the method call object. + */ +int ASBeautifier::getObjCFollowingKeyword(const string& line, int bracePos) const +{ + assert(line[bracePos] == '['); + size_t firstText = line.find_first_not_of(" \t", bracePos + 1); + if (firstText == string::npos) + return -(indentCount * indentLength - 1); + size_t searchBeg = firstText; + size_t objectEnd = 0; // end of object text + if (line[searchBeg] == '[') + { + objectEnd = line.find(']', searchBeg + 1); + if (objectEnd == string::npos) + return 0; + } + else + { + if (line[searchBeg] == '(') + { + searchBeg = line.find(')', searchBeg + 1); + if (searchBeg == string::npos) + return 0; + } + // bypass the object name + objectEnd = line.find_first_of(" \t", searchBeg + 1); + if (objectEnd == string::npos) + return 0; + --objectEnd; + } + size_t keyPos = line.find_first_not_of(" \t", objectEnd + 1); + if (keyPos == string::npos) + return 0; + return keyPos - firstText; +} + +/** + * Get a line using the current space indent with all tabs replaced by spaces. + * The indentCount is NOT included + * Needed to compute an accurate alignment. + */ +string ASBeautifier::getIndentedSpaceEquivalent(const string& line_) const +{ + string spaceIndent; + spaceIndent.append(spaceIndentCount, ' '); + string convertedLine = spaceIndent + line_; + for (size_t i = spaceIndent.length(); i < convertedLine.length(); i++) + { + if (convertedLine[i] == '\t') + { + size_t numSpaces = indentLength - (i % indentLength); + convertedLine.replace(i, 1, numSpaces, ' '); + i += indentLength - 1; + } + } + return convertedLine; +} + +/** + * Parse the current line to update indentCount and spaceIndentCount. + */ +void ASBeautifier::parseCurrentLine(const string& line) +{ + bool isInLineComment = false; + bool isInOperator = false; + bool isSpecialChar = false; + bool haveCaseIndent = false; + bool haveAssignmentThisLine = false; + bool closingBraceReached = false; + bool previousLineProbation = (probationHeader != nullptr); + char ch = ' '; + int tabIncrementIn = 0; + if (isInQuote + && !haveLineContinuationChar + && !isInVerbatimQuote + && !isInAsm) + isInQuote = false; // missing closing quote + haveLineContinuationChar = false; + + for (size_t i = 0; i < line.length(); i++) + { + ch = line[i]; + + if (isInBeautifySQL) + continue; + + // handle special characters (i.e. backslash+character such as \n, \t, ...) + if (isInQuote && !isInVerbatimQuote) + { + if (isSpecialChar) + { + isSpecialChar = false; + continue; + } + if (line.compare(i, 2, "\\\\") == 0) + { + i++; + continue; + } + if (ch == '\\') + { + if (peekNextChar(line, i) == ' ') // is this '\' at end of line + haveLineContinuationChar = true; + else + isSpecialChar = true; + continue; + } + } + else if (isInDefine && ch == '\\') + continue; + + // bypass whitespace here + if (isWhiteSpace(ch)) + { + if (ch == '\t') + tabIncrementIn += convertTabToSpaces(i, tabIncrementIn); + continue; + } + + // handle quotes (such as 'x' and "Hello Dolly") + if (!(isInComment || isInLineComment) + && (ch == '"' + || (ch == '\'' && !isDigitSeparator(line, i)))) + { + if (!isInQuote) + { + quoteChar = ch; + isInQuote = true; + char prevCh = i > 0 ? line[i - 1] : ' '; + if (isCStyle() && prevCh == 'R') + { + int parenPos = line.find('(', i); + if (parenPos != -1) + { + isInVerbatimQuote = true; + verbatimDelimiter = line.substr(i + 1, parenPos - i - 1); + } + } + else if (isSharpStyle() && prevCh == '@') + isInVerbatimQuote = true; + // check for "C" following "extern" + else if (g_preprocessorCppExternCBrace == 2 && line.compare(i, 3, "\"C\"") == 0) + ++g_preprocessorCppExternCBrace; + } + else if (isInVerbatimQuote && ch == '"') + { + if (isCStyle()) + { + string delim = ')' + verbatimDelimiter; + int delimStart = i - delim.length(); + if (delimStart > 0 && line.substr(delimStart, delim.length()) == delim) + { + isInQuote = false; + isInVerbatimQuote = false; + } + } + else if (isSharpStyle()) + { + if (line.compare(i, 2, "\"\"") == 0) + i++; + else + { + isInQuote = false; + isInVerbatimQuote = false; + continue; + } + } + } + else if (quoteChar == ch) + { + isInQuote = false; + isContinuation = true; + continue; + } + } + if (isInQuote) + continue; + + // handle comments + + if (!(isInComment || isInLineComment) && line.compare(i, 2, "//") == 0) + { + // if there is a 'case' statement after these comments unindent by 1 + if (isCaseHeaderCommentIndent) + --indentCount; + // isElseHeaderIndent is set by ASFormatter if shouldBreakElseIfs is requested + // if there is an 'else' after these comments a tempStacks indent is required + if (isElseHeaderIndent && lineOpensWithLineComment && !tempStacks->empty()) + indentCount += adjustIndentCountForBreakElseIfComments(); + isInLineComment = true; + i++; + continue; + } + else if (!(isInComment || isInLineComment) && line.compare(i, 2, "/*") == 0) + { + // if there is a 'case' statement after these comments unindent by 1 + if (isCaseHeaderCommentIndent && lineOpensWithComment) + --indentCount; + // isElseHeaderIndent is set by ASFormatter if shouldBreakElseIfs is requested + // if there is an 'else' after these comments a tempStacks indent is required + if (isElseHeaderIndent && lineOpensWithComment && !tempStacks->empty()) + indentCount += adjustIndentCountForBreakElseIfComments(); + isInComment = true; + i++; + if (!lineOpensWithComment) // does line start with comment? + blockCommentNoIndent = true; // if no, cannot indent continuation lines + continue; + } + else if ((isInComment || isInLineComment) && line.compare(i, 2, "*/") == 0) + { + size_t firstText = line.find_first_not_of(" \t"); + // if there is a 'case' statement after these comments unindent by 1 + // only if the ending comment is the first entry on the line + if (isCaseHeaderCommentIndent && firstText == i) + --indentCount; + // if this comment close starts the line, must check for else-if indent + // isElseHeaderIndent is set by ASFormatter if shouldBreakElseIfs is requested + // if there is an 'else' after these comments a tempStacks indent is required + if (firstText == i) + { + if (isElseHeaderIndent && !lineOpensWithComment && !tempStacks->empty()) + indentCount += adjustIndentCountForBreakElseIfComments(); + } + isInComment = false; + i++; + blockCommentNoIndent = false; // ok to indent next comment + continue; + } + // treat indented preprocessor lines as a line comment + else if (line[0] == '#' && isIndentedPreprocessor(line, i)) + { + isInLineComment = true; + } + + if (isInLineComment) + { + // bypass rest of the comment up to the comment end + while (i + 1 < line.length()) + i++; + + continue; + } + if (isInComment) + { + // if there is a 'case' statement after these comments unindent by 1 + if (!lineOpensWithComment && isCaseHeaderCommentIndent) + --indentCount; + // isElseHeaderIndent is set by ASFormatter if shouldBreakElseIfs is requested + // if there is an 'else' after these comments a tempStacks indent is required + if (!lineOpensWithComment && isElseHeaderIndent && !tempStacks->empty()) + indentCount += adjustIndentCountForBreakElseIfComments(); + // bypass rest of the comment up to the comment end + while (i + 1 < line.length() + && line.compare(i + 1, 2, "*/") != 0) + i++; + + continue; + } + + // if we have reached this far then we are NOT in a comment or string of special character... + + if (probationHeader != nullptr) + { + if ((probationHeader == &AS_STATIC && ch == '{') + || (probationHeader == &AS_SYNCHRONIZED && ch == '(')) + { + // insert the probation header as a new header + isInHeader = true; + headerStack->emplace_back(probationHeader); + + // handle the specific probation header + isInConditional = (probationHeader == &AS_SYNCHRONIZED); + + isContinuation = false; + // if the probation comes from the previous line, then indent by 1 tab count. + if (previousLineProbation + && ch == '{' + && !(blockIndent && probationHeader == &AS_STATIC)) + { + ++indentCount; + previousLineProbationTab = true; + } + previousLineProbation = false; + } + + // dismiss the probation header + probationHeader = nullptr; + } + + prevNonSpaceCh = currentNonSpaceCh; + currentNonSpaceCh = ch; + if (!isLegalNameChar(ch) && ch != ',' && ch != ';') + { + prevNonLegalCh = currentNonLegalCh; + currentNonLegalCh = ch; + } + + if (isInHeader) + { + isInHeader = false; + currentHeader = headerStack->back(); + } + else + currentHeader = nullptr; + + if (isCStyle() && isInTemplate + && (ch == '<' || ch == '>') + && !(line.length() > i + 1 && line.compare(i, 2, ">=") == 0)) + { + if (ch == '<') + { + ++templateDepth; + continuationIndentStackSizeStack->push_back(continuationIndentStack->size()); + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, 0, true); + } + else if (ch == '>') + { + popLastContinuationIndent(); + if (--templateDepth <= 0) + { + ch = ';'; + isInTemplate = false; + templateDepth = 0; + } + } + } + + // handle parentheses + if (ch == '(' || ch == '[' || ch == ')' || ch == ']') + { + if (ch == '(' || ch == '[') + { + isInOperator = false; + // if have a struct header, this is a declaration not a definition + if (ch == '(' + && !headerStack->empty() + && headerStack->back() == &AS_STRUCT) + { + headerStack->pop_back(); + isInClassHeader = false; + if (line.find(AS_STRUCT, 0) > i) // if not on this line + indentCount -= classInitializerIndents; + if (indentCount < 0) + indentCount = 0; + } + + if (parenDepth == 0) + { + parenStatementStack->push_back(isContinuation); + isContinuation = true; + } + parenDepth++; + if (ch == '[') + { + ++squareBracketCount; + if (squareBracketCount == 1 && isCStyle()) + { + isInObjCMethodCall = true; + isInObjCMethodCallFirst = true; + } + } + + continuationIndentStackSizeStack->push_back(continuationIndentStack->size()); + + if (currentHeader != nullptr) + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, minConditionalIndent, true); + else + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, 0, true); + } + else if (ch == ')' || ch == ']') + { + if (ch == ']') + --squareBracketCount; + if (squareBracketCount <= 0) + { + squareBracketCount = 0; + if (isInObjCMethodCall) + isImmediatelyPostObjCMethodCall = true; + } + foundPreCommandHeader = false; + parenDepth--; + if (parenDepth == 0) + { + if (!parenStatementStack->empty()) // in case of unmatched closing parens + { + isContinuation = parenStatementStack->back(); + parenStatementStack->pop_back(); + } + isInAsm = false; + isInConditional = false; + } + + if (!continuationIndentStackSizeStack->empty()) + { + popLastContinuationIndent(); + + if (!parenIndentStack->empty()) + { + int poppedIndent = parenIndentStack->back(); + parenIndentStack->pop_back(); + + if (i == 0) + spaceIndentCount = poppedIndent; + } + } + } + continue; + } + + if (ch == '{') + { + // first, check if '{' is a block-opener or a static-array opener + bool isBlockOpener = ((prevNonSpaceCh == '{' && braceBlockStateStack->back()) + || prevNonSpaceCh == '}' + || prevNonSpaceCh == ')' + || prevNonSpaceCh == ';' + || peekNextChar(line, i) == '{' + || foundPreCommandHeader + || foundPreCommandMacro + || isInClassHeader + || (isInClassInitializer && !isLegalNameChar(prevNonSpaceCh)) + || isNonInStatementArray + || isInObjCMethodDefinition + || isInObjCInterface + || isSharpAccessor + || isSharpDelegate + || isInExternC + || isInAsmBlock + || getNextWord(line, i) == AS_NEW + || (isInDefine + && (prevNonSpaceCh == '(' + || isLegalNameChar(prevNonSpaceCh)))); + + if (isInObjCMethodDefinition) + { + objCColonAlignSubsequent = 0; + isImmediatelyPostObjCMethodDefinition = true; + if (lineBeginsWithOpenBrace) // for run-in braces + clearObjCMethodDefinitionAlignment(); + } + + if (!isBlockOpener && !isContinuation && !isInClassInitializer && !isInEnum) + { + if (headerStack->empty()) + isBlockOpener = true; + else if (headerStack->back() == &AS_OPEN_BRACE + && headerStack->size() >= 2) + { + if ((*headerStack)[headerStack->size() - 2] == &AS_NAMESPACE + || (*headerStack)[headerStack->size() - 2] == &AS_MODULE + || (*headerStack)[headerStack->size() - 2] == &AS_CLASS + || (*headerStack)[headerStack->size() - 2] == &AS_INTERFACE + || (*headerStack)[headerStack->size() - 2] == &AS_STRUCT + || (*headerStack)[headerStack->size() - 2] == &AS_UNION) + isBlockOpener = true; + } + else if (headerStack->back() == &AS_NAMESPACE + || headerStack->back() == &AS_MODULE + || headerStack->back() == &AS_CLASS + || headerStack->back() == &AS_INTERFACE + || headerStack->back() == &AS_STRUCT + || headerStack->back() == &AS_UNION) + isBlockOpener = true; + } + + if (!isBlockOpener && currentHeader != nullptr) + { + for (size_t n = 0; n < nonParenHeaders->size(); n++) + if (currentHeader == (*nonParenHeaders)[n]) + { + isBlockOpener = true; + break; + } + } + + braceBlockStateStack->push_back(isBlockOpener); + + if (!isBlockOpener) + { + continuationIndentStackSizeStack->push_back(continuationIndentStack->size()); + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, 0, true); + parenDepth++; + if (i == 0) + shouldIndentBracedLine = false; + isInEnumTypeID = false; + + continue; + } + + // this brace is a block opener... + + ++lineOpeningBlocksNum; + + if (isInClassInitializer || isInEnumTypeID) + { + // decrease tab count if brace is broken + if (lineBeginsWithOpenBrace) + { + indentCount -= classInitializerIndents; + // decrease one more if an empty class + if (!headerStack->empty() + && (*headerStack).back() == &AS_CLASS) + { + int nextChar = getNextProgramCharDistance(line, i); + if ((int) line.length() > nextChar && line[nextChar] == '}') + --indentCount; + } + } + } + + if (isInObjCInterface) + { + isInObjCInterface = false; + if (lineBeginsWithOpenBrace) + --indentCount; + } + + if (braceIndent && !namespaceIndent && !headerStack->empty() + && ((*headerStack).back() == &AS_NAMESPACE + || (*headerStack).back() == &AS_MODULE)) + { + shouldIndentBracedLine = false; + --indentCount; + } + + // an indentable struct is treated like a class in the header stack + if (!headerStack->empty() + && (*headerStack).back() == &AS_STRUCT + && isInIndentableStruct) + (*headerStack).back() = &AS_CLASS; + + squareBracketDepthStack->emplace_back(parenDepth); + blockStatementStack->push_back(isContinuation); + + if (!continuationIndentStack->empty()) + { + // completely purge the inStatementIndentStack + while (!continuationIndentStack->empty()) + popLastContinuationIndent(); + if (isInClassInitializer || isInClassHeaderTab) + { + if (lineBeginsWithOpenBrace || lineBeginsWithComma) + spaceIndentCount = 0; + } + else + spaceIndentCount = 0; + } + + blockTabCount += (isContinuation ? 1 : 0); + if (g_preprocessorCppExternCBrace == 3) + ++g_preprocessorCppExternCBrace; + parenDepth = 0; + isInClassHeader = false; + isInClassHeaderTab = false; + isInClassInitializer = false; + isInEnumTypeID = false; + isContinuation = false; + isInQuestion = false; + isInLet = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + isInExternC = false; + + tempStacks->emplace_back(new vector); + headerStack->emplace_back(&AS_OPEN_BRACE); + lastLineHeader = &AS_OPEN_BRACE; + + continue; + } // end '{' + + //check if a header has been reached + bool isPotentialHeader = isCharPotentialHeader(line, i); + + if (isPotentialHeader && squareBracketCount == 0) + { + const string* newHeader = findHeader(line, i, headers); + + // Qt headers may be variables in C++ + if (isCStyle() + && (newHeader == &AS_FOREVER || newHeader == &AS_FOREACH)) + { + if (line.find_first_of("=;", i) != string::npos) + newHeader = nullptr; + } + else if (newHeader == &AS_USING + && ASBeautifier::peekNextChar(line, i + (*newHeader).length() - 1) != '(') + newHeader = nullptr; + + if (newHeader != nullptr) + { + // if we reached here, then this is a header... + bool isIndentableHeader = true; + + isInHeader = true; + + vector* lastTempStack = nullptr;; + if (!tempStacks->empty()) + lastTempStack = tempStacks->back(); + + // if a new block is opened, push a new stack into tempStacks to hold the + // future list of headers in the new block. + + // take care of the special case: 'else if (...)' + if (newHeader == &AS_IF && lastLineHeader == &AS_ELSE) + { + headerStack->pop_back(); + } + + // take care of 'else' + else if (newHeader == &AS_ELSE) + { + if (lastTempStack != nullptr) + { + int indexOfIf = indexOf(*lastTempStack, &AS_IF); + if (indexOfIf != -1) + { + // recreate the header list in headerStack up to the previous 'if' + // from the temporary snapshot stored in lastTempStack. + int restackSize = lastTempStack->size() - indexOfIf - 1; + for (int r = 0; r < restackSize; r++) + { + headerStack->emplace_back(lastTempStack->back()); + lastTempStack->pop_back(); + } + if (!closingBraceReached) + indentCount += restackSize; + } + /* + * If the above if is not true, i.e. no 'if' before the 'else', + * then nothing beautiful will come out of this... + * I should think about inserting an Exception here to notify the caller of this... + */ + } + } + + // check if 'while' closes a previous 'do' + else if (newHeader == &AS_WHILE) + { + if (lastTempStack != nullptr) + { + int indexOfDo = indexOf(*lastTempStack, &AS_DO); + if (indexOfDo != -1) + { + // recreate the header list in headerStack up to the previous 'do' + // from the temporary snapshot stored in lastTempStack. + int restackSize = lastTempStack->size() - indexOfDo - 1; + for (int r = 0; r < restackSize; r++) + { + headerStack->emplace_back(lastTempStack->back()); + lastTempStack->pop_back(); + } + if (!closingBraceReached) + indentCount += restackSize; + } + } + } + // check if 'catch' closes a previous 'try' or 'catch' + else if (newHeader == &AS_CATCH || newHeader == &AS_FINALLY) + { + if (lastTempStack != nullptr) + { + int indexOfTry = indexOf(*lastTempStack, &AS_TRY); + if (indexOfTry == -1) + indexOfTry = indexOf(*lastTempStack, &AS_CATCH); + if (indexOfTry != -1) + { + // recreate the header list in headerStack up to the previous 'try' + // from the temporary snapshot stored in lastTempStack. + int restackSize = lastTempStack->size() - indexOfTry - 1; + for (int r = 0; r < restackSize; r++) + { + headerStack->emplace_back(lastTempStack->back()); + lastTempStack->pop_back(); + } + + if (!closingBraceReached) + indentCount += restackSize; + } + } + } + else if (newHeader == &AS_CASE) + { + isInCase = true; + if (!haveCaseIndent) + { + haveCaseIndent = true; + if (!lineBeginsWithOpenBrace) + --indentCount; + } + } + else if (newHeader == &AS_DEFAULT) + { + isInCase = true; + --indentCount; + } + else if (newHeader == &AS_STATIC + || newHeader == &AS_SYNCHRONIZED) + { + if (!headerStack->empty() + && (headerStack->back() == &AS_STATIC + || headerStack->back() == &AS_SYNCHRONIZED)) + { + isIndentableHeader = false; + } + else + { + isIndentableHeader = false; + probationHeader = newHeader; + } + } + else if (newHeader == &AS_TEMPLATE) + { + isInTemplate = true; + isIndentableHeader = false; + } + + if (isIndentableHeader) + { + headerStack->emplace_back(newHeader); + isContinuation = false; + if (indexOf(*nonParenHeaders, newHeader) == -1) + { + isInConditional = true; + } + lastLineHeader = newHeader; + } + else + isInHeader = false; + + i += newHeader->length() - 1; + + continue; + } // newHeader != nullptr + + if (findHeader(line, i, preCommandHeaders) != nullptr) + foundPreCommandHeader = true; + + // Objective-C NSException macros are preCommandHeaders + if (isCStyle() && findKeyword(line, i, AS_NS_DURING)) + foundPreCommandMacro = true; + if (isCStyle() && findKeyword(line, i, AS_NS_HANDLER)) + foundPreCommandMacro = true; + + if (parenDepth == 0 && findKeyword(line, i, AS_ENUM)) + isInEnum = true; + + if (isSharpStyle() && findKeyword(line, i, AS_LET)) + isInLet = true; + + } // isPotentialHeader + + if (ch == '?') + isInQuestion = true; + + // special handling of colons + if (ch == ':') + { + if (line.length() > i + 1 && line[i + 1] == ':') // look for :: + { + ++i; + continue; + } + else if (isInQuestion) + { + // do nothing special + } + else if (parenDepth > 0) + { + // found a 'for' loop or an objective-C statement + // so do nothing special + } + else if (isInEnum) + { + // found an enum with a base-type + isInEnumTypeID = true; + if (i == 0) + indentCount += classInitializerIndents; + } + else if (isCStyle() + && !isInCase + && (prevNonSpaceCh == ')' || foundPreCommandHeader)) + { + // found a 'class' c'tor initializer + isInClassInitializer = true; + registerContinuationIndentColon(line, i, tabIncrementIn); + if (i == 0) + indentCount += classInitializerIndents; + } + else if (isInClassHeader || isInObjCInterface) + { + // is in a 'class A : public B' definition + isInClassHeaderTab = true; + registerContinuationIndentColon(line, i, tabIncrementIn); + } + else if (isInAsm || isInAsmOneLine || isInAsmBlock) + { + // do nothing special + } + else if (isDigit(peekNextChar(line, i))) + { + // found a bit field - do nothing special + } + else if (isCStyle() && isInClass && prevNonSpaceCh != ')') + { + // found a 'private:' or 'public:' inside a class definition + --indentCount; + if (modifierIndent) + spaceIndentCount += (indentLength / 2); + } + else if (isCStyle() && !isInClass + && headerStack->size() >= 2 + && (*headerStack)[headerStack->size() - 2] == &AS_CLASS + && (*headerStack)[headerStack->size() - 1] == &AS_OPEN_BRACE) + { + // found a 'private:' or 'public:' inside a class definition + // and on the same line as the class opening brace + // do nothing + } + else if (isJavaStyle() && lastLineHeader == &AS_FOR) + { + // found a java for-each statement + // so do nothing special + } + else + { + currentNonSpaceCh = ';'; // so that braces after the ':' will appear as block-openers + char peekedChar = peekNextChar(line, i); + if (isInCase) + { + isInCase = false; + ch = ';'; // from here on, treat char as ';' + } + else if (isCStyle() || (isSharpStyle() && peekedChar == ';')) + { + // is in a label (e.g. 'label1:') + if (labelIndent) + --indentCount; // unindent label by one indent + else if (!lineBeginsWithOpenBrace) + indentCount = 0; // completely flush indent to left + } + } + } + + if ((ch == ';' || (parenDepth > 0 && ch == ',')) && !continuationIndentStackSizeStack->empty()) + while ((int) continuationIndentStackSizeStack->back() + (parenDepth > 0 ? 1 : 0) + < (int) continuationIndentStack->size()) + continuationIndentStack->pop_back(); + + else if (ch == ',' && isInEnum && isNonInStatementArray && !continuationIndentStack->empty()) + continuationIndentStack->pop_back(); + + // handle commas + // previous "isInStatement" will be from an assignment operator or class initializer + if (ch == ',' && parenDepth == 0 && !isContinuation && !isNonInStatementArray) + { + // is comma at end of line + size_t nextChar = line.find_first_not_of(" \t", i + 1); + if (nextChar != string::npos) + { + if (line.compare(nextChar, 2, "//") == 0 + || line.compare(nextChar, 2, "/*") == 0) + nextChar = string::npos; + } + // register indent + if (nextChar == string::npos) + { + // register indent at previous word + if (isJavaStyle() && isInClassHeader) + { + // do nothing for now + } + // register indent at second word on the line + else if (!isInTemplate && !isInClassHeaderTab && !isInClassInitializer) + { + int prevWord = getContinuationIndentComma(line, i); + int continuationIndentCount = prevWord + spaceIndentCount + tabIncrementIn; + continuationIndentStack->emplace_back(continuationIndentCount); + isContinuation = true; + } + } + } + // handle comma first initializers + if (ch == ',' && parenDepth == 0 && lineBeginsWithComma + && (isInClassInitializer || isInClassHeaderTab)) + spaceIndentCount = 0; + + // handle ends of statements + if ((ch == ';' && parenDepth == 0) || ch == '}') + { + if (ch == '}') + { + // first check if this '}' closes a previous block, or a static array... + if (braceBlockStateStack->size() > 1) + { + bool braceBlockState = braceBlockStateStack->back(); + braceBlockStateStack->pop_back(); + if (!braceBlockState) + { + if (!continuationIndentStackSizeStack->empty()) + { + // this brace is a static array + popLastContinuationIndent(); + parenDepth--; + if (i == 0) + shouldIndentBracedLine = false; + + if (!parenIndentStack->empty()) + { + int poppedIndent = parenIndentStack->back(); + parenIndentStack->pop_back(); + if (i == 0) + spaceIndentCount = poppedIndent; + } + } + continue; + } + } + + // this brace is block closer... + + ++lineClosingBlocksNum; + + if (!continuationIndentStackSizeStack->empty()) + popLastContinuationIndent(); + + if (!squareBracketDepthStack->empty()) + { + parenDepth = squareBracketDepthStack->back(); + squareBracketDepthStack->pop_back(); + isContinuation = blockStatementStack->back(); + blockStatementStack->pop_back(); + + if (isContinuation) + blockTabCount--; + } + + closingBraceReached = true; + if (i == 0) + spaceIndentCount = 0; + isInAsmBlock = false; + isInAsm = isInAsmOneLine = isInQuote = false; // close these just in case + + int headerPlace = indexOf(*headerStack, &AS_OPEN_BRACE); + if (headerPlace != -1) + { + const string* popped = headerStack->back(); + while (popped != &AS_OPEN_BRACE) + { + headerStack->pop_back(); + popped = headerStack->back(); + } + headerStack->pop_back(); + + if (headerStack->empty()) + g_preprocessorCppExternCBrace = 0; + + // do not indent namespace brace unless namespaces are indented + if (!namespaceIndent && !headerStack->empty() + && ((*headerStack).back() == &AS_NAMESPACE + || (*headerStack).back() == &AS_MODULE) + && i == 0) // must be the first brace on the line + shouldIndentBracedLine = false; + + if (!tempStacks->empty()) + { + vector* temp = tempStacks->back(); + tempStacks->pop_back(); + delete temp; + } + } + + ch = ' '; // needed due to cases such as '}else{', so that headers ('else' in this case) will be identified... + } // ch == '}' + + /* + * Create a temporary snapshot of the current block's header-list in the + * uppermost inner stack in tempStacks, and clear the headerStack up to + * the beginning of the block. + * Thus, the next future statement will think it comes one indent past + * the block's '{' unless it specifically checks for a companion-header + * (such as a previous 'if' for an 'else' header) within the tempStacks, + * and recreates the temporary snapshot by manipulating the tempStacks. + */ + if (!tempStacks->back()->empty()) + while (!tempStacks->back()->empty()) + tempStacks->back()->pop_back(); + while (!headerStack->empty() && headerStack->back() != &AS_OPEN_BRACE) + { + tempStacks->back()->emplace_back(headerStack->back()); + headerStack->pop_back(); + } + + if (parenDepth == 0 && ch == ';') + isContinuation = false; + + if (isInObjCMethodDefinition) + { + objCColonAlignSubsequent = 0; + isImmediatelyPostObjCMethodDefinition = true; + } + + previousLastLineHeader = nullptr; + isInClassHeader = false; // for 'friend' class + isInEnum = false; + isInEnumTypeID = false; + isInQuestion = false; + isInTemplate = false; + isInObjCInterface = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + squareBracketCount = 0; + + continue; + } + + if (isPotentialHeader) + { + // check for preBlockStatements in C/C++ ONLY if not within parentheses + // (otherwise 'struct XXX' statements would be wrongly interpreted...) + if (!isInTemplate && !(isCStyle() && parenDepth > 0)) + { + const string* newHeader = findHeader(line, i, preBlockStatements); + // handle CORBA IDL module + if (newHeader == &AS_MODULE) + { + char nextChar = peekNextChar(line, i + newHeader->length() - 1); + if (prevNonSpaceCh == ')' || !isalpha(nextChar)) + newHeader = nullptr; + } + if (newHeader != nullptr + && !(isCStyle() && newHeader == &AS_CLASS && isInEnum)) // is not 'enum class' + { + if (!isSharpStyle()) + headerStack->emplace_back(newHeader); + // do not need 'where' in the headerStack + // do not need second 'class' statement in a row + else if (!(newHeader == &AS_WHERE + || ((newHeader == &AS_CLASS || newHeader == &AS_STRUCT) + && !headerStack->empty() + && (headerStack->back() == &AS_CLASS + || headerStack->back() == &AS_STRUCT)))) + headerStack->emplace_back(newHeader); + + if (!headerStack->empty()) + { + if ((*headerStack).back() == &AS_CLASS + || (*headerStack).back() == &AS_STRUCT + || (*headerStack).back() == &AS_INTERFACE) + { + isInClassHeader = true; + } + else if ((*headerStack).back() == &AS_NAMESPACE + || (*headerStack).back() == &AS_MODULE) + { + // remove continuationIndent from namespace + if (!continuationIndentStack->empty()) + continuationIndentStack->pop_back(); + isContinuation = false; + } + } + + i += newHeader->length() - 1; + continue; + } + } + const string* foundIndentableHeader = findHeader(line, i, indentableHeaders); + + if (foundIndentableHeader != nullptr) + { + // must bypass the header before registering the in statement + i += foundIndentableHeader->length() - 1; + if (!isInOperator && !isInTemplate && !isNonInStatementArray) + { + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, 0, false); + isContinuation = true; + } + continue; + } + + if (isCStyle() && findKeyword(line, i, AS_OPERATOR)) + isInOperator = true; + + if (g_preprocessorCppExternCBrace == 1 && findKeyword(line, i, AS_EXTERN)) + ++g_preprocessorCppExternCBrace; + + if (g_preprocessorCppExternCBrace == 3) // extern "C" is not followed by a '{' + g_preprocessorCppExternCBrace = 0; + + // "new" operator is a pointer, not a calculation + if (findKeyword(line, i, AS_NEW)) + { + if (isContinuation && !continuationIndentStack->empty() && prevNonSpaceCh == '=') + continuationIndentStack->back() = 0; + } + + if (isCStyle()) + { + if (findKeyword(line, i, AS_ASM) + || findKeyword(line, i, AS__ASM__)) + { + isInAsm = true; + } + else if (findKeyword(line, i, AS_MS_ASM) // microsoft specific + || findKeyword(line, i, AS_MS__ASM)) + { + int index = 4; + if (peekNextChar(line, i) == '_') // check for __asm + index = 5; + + char peekedChar = peekNextChar(line, i + index); + if (peekedChar == '{' || peekedChar == ' ') + isInAsmBlock = true; + else + isInAsmOneLine = true; + } + } + + // bypass the entire name for all others + string name = getCurrentWord(line, i); + i += name.length() - 1; + continue; + } + + // Handle Objective-C statements + + if (ch == '@' && !isWhiteSpace(line[i + 1]) + && isCharPotentialHeader(line, i + 1)) + { + string curWord = getCurrentWord(line, i + 1); + if (curWord == AS_INTERFACE && headerStack->empty()) + { + isInObjCInterface = true; + string name = '@' + curWord; + i += name.length() - 1; + continue; + } + else if (isInObjCInterface) + { + --indentCount; + isInObjCInterface = false; + } + + if (curWord == AS_PUBLIC + || curWord == AS_PRIVATE + || curWord == AS_PROTECTED) + { + --indentCount; + if (modifierIndent) + spaceIndentCount += (indentLength / 2); + string name = '@' + curWord; + i += name.length() - 1; + continue; + } + else if (curWord == AS_END) + { + popLastContinuationIndent(); + spaceIndentCount = 0; + isInObjCMethodDefinition = false; + string name = '@' + curWord; + i += name.length() - 1; + continue; + } + } + else if ((ch == '-' || ch == '+') + && peekNextChar(line, i) == '(' + && headerStack->empty() + && line.find_first_not_of(" \t") == i) + { + if (isInObjCInterface) + --indentCount; + isInObjCInterface = false; + isInObjCMethodDefinition = true; + continue; + } + + // Handle operators + + bool isPotentialOperator = isCharPotentialOperator(ch); + + if (isPotentialOperator) + { + // Check if an operator has been reached. + const string* foundAssignmentOp = findOperator(line, i, assignmentOperators); + const string* foundNonAssignmentOp = findOperator(line, i, nonAssignmentOperators); + + if (foundNonAssignmentOp != nullptr) + { + if (foundNonAssignmentOp == &AS_LAMBDA) + foundPreCommandHeader = true; + if (isInTemplate && foundNonAssignmentOp == &AS_GR_GR) + foundNonAssignmentOp = nullptr; + } + + // Since findHeader's boundary checking was not used above, it is possible + // that both an assignment op and a non-assignment op where found, + // e.g. '>>' and '>>='. If this is the case, treat the LONGER one as the + // found operator. + if (foundAssignmentOp != nullptr && foundNonAssignmentOp != nullptr) + { + if (foundAssignmentOp->length() < foundNonAssignmentOp->length()) + foundAssignmentOp = nullptr; + else + foundNonAssignmentOp = nullptr; + } + + if (foundNonAssignmentOp != nullptr) + { + if (foundNonAssignmentOp->length() > 1) + i += foundNonAssignmentOp->length() - 1; + + // For C++ input/output, operator<< and >> should be + // aligned, if we are not in a statement already and + // also not in the "operator<<(...)" header line + if (!isInOperator + && continuationIndentStack->empty() + && isCStyle() + && (foundNonAssignmentOp == &AS_GR_GR + || foundNonAssignmentOp == &AS_LS_LS)) + { + // this will be true if the line begins with the operator + if (i < 2 && spaceIndentCount == 0) + spaceIndentCount += 2 * indentLength; + // align to the beginning column of the operator + registerContinuationIndent(line, i - foundNonAssignmentOp->length(), spaceIndentCount, tabIncrementIn, 0, false); + } + } + + else if (foundAssignmentOp != nullptr) + { + foundPreCommandHeader = false; // clears this for array assignments + foundPreCommandMacro = false; + + if (foundAssignmentOp->length() > 1) + i += foundAssignmentOp->length() - 1; + + if (!isInOperator && !isInTemplate && (!isNonInStatementArray || isInEnum)) + { + // if multiple assignments, align on the previous word + if (foundAssignmentOp == &AS_ASSIGN + && prevNonSpaceCh != ']' // an array + && statementEndsWithComma(line, i)) + { + if (!haveAssignmentThisLine) // only one assignment indent per line + { + // register indent at previous word + haveAssignmentThisLine = true; + int prevWordIndex = getContinuationIndentAssign(line, i); + int continuationIndentCount = prevWordIndex + spaceIndentCount + tabIncrementIn; + continuationIndentStack->emplace_back(continuationIndentCount); + isContinuation = true; + } + } + // don't indent an assignment if 'let' + else if (isInLet) + { + isInLet = false; + } + else if (!lineBeginsWithComma) + { + if (i == 0 && spaceIndentCount == 0) + spaceIndentCount += indentLength; + registerContinuationIndent(line, i, spaceIndentCount, tabIncrementIn, 0, false); + isContinuation = true; + } + } + } + } + } // end of for loop * end of for loop * end of for loop * end of for loop * end of for loop * +} + +} // end namespace astyle diff --git a/thirdparty/astyle/ASEnhancer.cpp b/thirdparty/astyle/ASEnhancer.cpp new file mode 100755 index 00000000..402aa16d --- /dev/null +++ b/thirdparty/astyle/ASEnhancer.cpp @@ -0,0 +1,797 @@ +// ASEnhancer.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#include "astyle.h" + +//----------------------------------------------------------------------------- +// astyle namespace +//----------------------------------------------------------------------------- + +namespace astyle { +// +//----------------------------------------------------------------------------- +// ASEnhancer class +//----------------------------------------------------------------------------- + +/** + * ASEnhancer constructor + */ +ASEnhancer::ASEnhancer() +{ +} + +/** + * Destructor of ASEnhancer + */ +ASEnhancer::~ASEnhancer() +{ +} + +/** + * initialize the ASEnhancer. + * + * init() is called each time an ASFormatter object is initialized. + */ +void ASEnhancer::init(int _fileType, + int _indentLength, + int _tabLength, + bool _useTabs, + bool _forceTab, + bool _namespaceIndent, + bool _caseIndent, + bool _preprocBlockIndent, + bool _preprocDefineIndent, + bool _emptyLineFill, + vector* >* _indentableMacros) +{ + // formatting variables from ASFormatter and ASBeautifier + ASBase::init(_fileType); + indentLength = _indentLength; + tabLength = _tabLength; + useTabs = _useTabs; + forceTab = _forceTab; + namespaceIndent = _namespaceIndent; + caseIndent = _caseIndent; + preprocBlockIndent = _preprocBlockIndent; + preprocDefineIndent = _preprocDefineIndent; + emptyLineFill = _emptyLineFill; + indentableMacros = _indentableMacros; + quoteChar = '\''; + + // unindent variables + lineNumber = 0; + braceCount = 0; + isInComment = false; + isInQuote = false; + switchDepth = 0; + eventPreprocDepth = 0; + lookingForCaseBrace = false; + unindentNextLine = false; + shouldUnindentLine = false; + shouldUnindentComment = false; + + // switch struct and vector + sw.switchBraceCount = 0; + sw.unindentDepth = 0; + sw.unindentCase = false; + switchStack.clear(); + + // other variables + nextLineIsEventIndent = false; + isInEventTable = false; + nextLineIsDeclareIndent = false; + isInDeclareSection = false; +} + +/** + * additional formatting for line of source code. + * every line of source code in a source code file should be sent + * one after the other to this function. + * indents event tables + * unindents the case blocks + * + * @param line the original formatted line will be updated if necessary. + */ +void ASEnhancer::enhance(string& line, bool isInNamespace, bool isInPreprocessor, bool isInSQL) +{ + shouldUnindentLine = true; + shouldUnindentComment = false; + lineNumber++; + + // check for beginning of event table + if (nextLineIsEventIndent) + { + isInEventTable = true; + nextLineIsEventIndent = false; + } + + // check for beginning of SQL declare section + if (nextLineIsDeclareIndent) + { + isInDeclareSection = true; + nextLineIsDeclareIndent = false; + } + + if (line.length() == 0 + && !isInEventTable + && !isInDeclareSection + && !emptyLineFill) + return; + + // test for unindent on attached braces + if (unindentNextLine) + { + sw.unindentDepth++; + sw.unindentCase = true; + unindentNextLine = false; + } + + // parse characters in the current line + parseCurrentLine(line, isInPreprocessor, isInSQL); + + // check for SQL indentable lines + if (isInDeclareSection) + { + size_t firstText = line.find_first_not_of(" \t"); + if (firstText == string::npos || line[firstText] != '#') + indentLine(line, 1); + } + + // check for event table indentable lines + if (isInEventTable + && (eventPreprocDepth == 0 + || (namespaceIndent && isInNamespace))) + { + size_t firstText = line.find_first_not_of(" \t"); + if (firstText == string::npos || line[firstText] != '#') + indentLine(line, 1); + } + + if (shouldUnindentComment && sw.unindentDepth > 0) + unindentLine(line, sw.unindentDepth - 1); + else if (shouldUnindentLine && sw.unindentDepth > 0) + unindentLine(line, sw.unindentDepth); +} + +/** + * convert a force-tab indent to spaces + * + * @param line a reference to the line that will be converted. + */ +void ASEnhancer::convertForceTabIndentToSpaces(string& line) const +{ + // replace tab indents with spaces + for (size_t i = 0; i < line.length(); i++) + { + if (!isWhiteSpace(line[i])) + break; + if (line[i] == '\t') + { + line.erase(i, 1); + line.insert(i, tabLength, ' '); + i += tabLength - 1; + } + } +} + +/** + * convert a space indent to force-tab + * + * @param line a reference to the line that will be converted. + */ +void ASEnhancer::convertSpaceIndentToForceTab(string& line) const +{ + assert(tabLength > 0); + + // replace leading spaces with tab indents + size_t newSpaceIndentLength = line.find_first_not_of(" \t"); + size_t tabCount = newSpaceIndentLength / tabLength; // truncate extra spaces + line.replace(0U, tabCount * tabLength, tabCount, '\t'); +} + +/** + * find the colon following a 'case' statement + * + * @param line a reference to the line. + * @param caseIndex the line index of the case statement. + * @return the line index of the colon. + */ +size_t ASEnhancer::findCaseColon(const string& line, size_t caseIndex) const +{ + size_t i = caseIndex; + bool isInQuote_ = false; + char quoteChar_ = ' '; + for (; i < line.length(); i++) + { + if (isInQuote_) + { + if (line[i] == '\\') + { + i++; + continue; + } + else if (line[i] == quoteChar_) // check ending quote + { + isInQuote_ = false; + quoteChar_ = ' '; + continue; + } + else + { + continue; // must close quote before continuing + } + } + if (line[i] == '"' // check opening quote + || (line[i] == '\'' && !isDigitSeparator(line, i))) + { + isInQuote_ = true; + quoteChar_ = line[i]; + continue; + } + if (line[i] == ':') + { + if ((i + 1 < line.length()) && (line[i + 1] == ':')) + i++; // bypass scope resolution operator + else + break; // found it + } + } + return i; +} + +/** +* indent a line by a given number of tabsets + * by inserting leading whitespace to the line argument. + * + * @param line a reference to the line to indent. + * @param indent the number of tabsets to insert. + * @return the number of characters inserted. + */ +int ASEnhancer::indentLine(string& line, int indent) const +{ + if (line.length() == 0 + && !emptyLineFill) + return 0; + + size_t charsToInsert = 0; + + if (forceTab && indentLength != tabLength) + { + // replace tab indents with spaces + convertForceTabIndentToSpaces(line); + // insert the space indents + charsToInsert = indent * indentLength; + line.insert(line.begin(), charsToInsert, ' '); + // replace leading spaces with tab indents + convertSpaceIndentToForceTab(line); + } + else if (useTabs) + { + charsToInsert = indent; + line.insert(line.begin(), charsToInsert, '\t'); + } + else // spaces + { + charsToInsert = indent * indentLength; + line.insert(line.begin(), charsToInsert, ' '); + } + + return charsToInsert; +} + +/** + * check for SQL "BEGIN DECLARE SECTION". + * must compare case insensitive and allow any spacing between words. + * + * @param line a reference to the line to indent. + * @param index the current line index. + * @return true if a hit. + */ +bool ASEnhancer::isBeginDeclareSectionSQL(const string& line, size_t index) const +{ + string word; + size_t hits = 0; + size_t i; + for (i = index; i < line.length(); i++) + { + i = line.find_first_not_of(" \t", i); + if (i == string::npos) + return false; + if (line[i] == ';') + break; + if (!isCharPotentialHeader(line, i)) + continue; + word = getCurrentWord(line, i); + for (size_t j = 0; j < word.length(); j++) + word[j] = (char) toupper(word[j]); + if (word == "EXEC" || word == "SQL") + { + i += word.length() - 1; + continue; + } + if (word == "DECLARE" || word == "SECTION") + { + hits++; + i += word.length() - 1; + continue; + } + if (word == "BEGIN") + { + hits++; + i += word.length() - 1; + continue; + } + return false; + } + if (hits == 3) + return true; + return false; +} + +/** + * check for SQL "END DECLARE SECTION". + * must compare case insensitive and allow any spacing between words. + * + * @param line a reference to the line to indent. + * @param index the current line index. + * @return true if a hit. + */ +bool ASEnhancer::isEndDeclareSectionSQL(const string& line, size_t index) const +{ + string word; + size_t hits = 0; + size_t i; + for (i = index; i < line.length(); i++) + { + i = line.find_first_not_of(" \t", i); + if (i == string::npos) + return false; + if (line[i] == ';') + break; + if (!isCharPotentialHeader(line, i)) + continue; + word = getCurrentWord(line, i); + for (size_t j = 0; j < word.length(); j++) + word[j] = (char) toupper(word[j]); + if (word == "EXEC" || word == "SQL") + { + i += word.length() - 1; + continue; + } + if (word == "DECLARE" || word == "SECTION") + { + hits++; + i += word.length() - 1; + continue; + } + if (word == "END") + { + hits++; + i += word.length() - 1; + continue; + } + return false; + } + if (hits == 3) + return true; + return false; +} + +/** + * check if a one-line brace has been reached, + * i.e. if the currently reached '{' character is closed + * with a complimentary '}' elsewhere on the current line, + *. + * @return false = one-line brace has not been reached. + * true = one-line brace has been reached. + */ +bool ASEnhancer::isOneLineBlockReached(const string& line, int startChar) const +{ + assert(line[startChar] == '{'); + + bool isInComment_ = false; + bool isInQuote_ = false; + int _braceCount = 1; + int lineLength = line.length(); + char quoteChar_ = ' '; + char ch = ' '; + + for (int i = startChar + 1; i < lineLength; ++i) + { + ch = line[i]; + + if (isInComment_) + { + if (line.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + + if (ch == '\\') + { + ++i; + continue; + } + + if (isInQuote_) + { + if (ch == quoteChar_) + isInQuote_ = false; + continue; + } + + if (ch == '"' + || (ch == '\'' && !isDigitSeparator(line, i))) + { + isInQuote_ = true; + quoteChar_ = ch; + continue; + } + + if (line.compare(i, 2, "//") == 0) + break; + + if (line.compare(i, 2, "/*") == 0) + { + isInComment_ = true; + ++i; + continue; + } + + if (ch == '{') + ++_braceCount; + else if (ch == '}') + --_braceCount; + + if (_braceCount == 0) + return true; + } + + return false; +} + +/** + * parse characters in the current line to determine if an indent + * or unindent is needed. + */ +void ASEnhancer::parseCurrentLine(string& line, bool isInPreprocessor, bool isInSQL) +{ + bool isSpecialChar = false; // is a backslash escape character + + for (size_t i = 0; i < line.length(); i++) + { + char ch = line[i]; + + // bypass whitespace + if (isWhiteSpace(ch)) + continue; + + // handle special characters (i.e. backslash+character such as \n, \t, ...) + if (isSpecialChar) + { + isSpecialChar = false; + continue; + } + if (!(isInComment) && line.compare(i, 2, "\\\\") == 0) + { + i++; + continue; + } + if (!(isInComment) && ch == '\\') + { + isSpecialChar = true; + continue; + } + + // handle quotes (such as 'x' and "Hello Dolly") + if (!isInComment + && (ch == '"' + || (ch == '\'' && !isDigitSeparator(line, i)))) + { + if (!isInQuote) + { + quoteChar = ch; + isInQuote = true; + } + else if (quoteChar == ch) + { + isInQuote = false; + continue; + } + } + + if (isInQuote) + continue; + + // handle comments + + if (!(isInComment) && line.compare(i, 2, "//") == 0) + { + // check for windows line markers + if (line.compare(i + 2, 1, "\xf0") > 0) + lineNumber--; + // unindent if not in case braces + if (line.find_first_not_of(" \t") == i + && sw.switchBraceCount == 1 + && sw.unindentCase) + shouldUnindentComment = true; + break; // finished with the line + } + else if (!(isInComment) && line.compare(i, 2, "/*") == 0) + { + // unindent if not in case braces + if (sw.switchBraceCount == 1 && sw.unindentCase) + shouldUnindentComment = true; + isInComment = true; + size_t commentEnd = line.find("*/", i); + if (commentEnd == string::npos) + i = line.length() - 1; + else + i = commentEnd - 1; + continue; + } + else if ((isInComment) && line.compare(i, 2, "*/") == 0) + { + // unindent if not in case braces + if (sw.switchBraceCount == 1 && sw.unindentCase) + shouldUnindentComment = true; + isInComment = false; + i++; + continue; + } + + if (isInComment) + { + // unindent if not in case braces + if (sw.switchBraceCount == 1 && sw.unindentCase) + shouldUnindentComment = true; + size_t commentEnd = line.find("*/", i); + if (commentEnd == string::npos) + i = line.length() - 1; + else + i = commentEnd - 1; + continue; + } + + // if we have reached this far then we are NOT in a comment or string of special characters + + if (line[i] == '{') + braceCount++; + + if (line[i] == '}') + braceCount--; + + // check for preprocessor within an event table + if (isInEventTable && line[i] == '#' && preprocBlockIndent) + { + string preproc; + preproc = line.substr(i + 1); + if (preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef) + eventPreprocDepth += 1; + if (preproc.substr(0, 5) == "endif" && eventPreprocDepth > 0) + eventPreprocDepth -= 1; + } + + bool isPotentialKeyword = isCharPotentialHeader(line, i); + + // ---------------- wxWidgets and MFC macros ---------------------------------- + + if (isPotentialKeyword) + { + for (size_t j = 0; j < indentableMacros->size(); j++) + { + // 'first' is the beginning macro + if (findKeyword(line, i, indentableMacros->at(j)->first)) + { + nextLineIsEventIndent = true; + break; + } + } + for (size_t j = 0; j < indentableMacros->size(); j++) + { + // 'second' is the ending macro + if (findKeyword(line, i, indentableMacros->at(j)->second)) + { + isInEventTable = false; + eventPreprocDepth = 0; + break; + } + } + } + + // ---------------- process SQL ----------------------------------------------- + + if (isInSQL) + { + if (isBeginDeclareSectionSQL(line, i)) + nextLineIsDeclareIndent = true; + if (isEndDeclareSectionSQL(line, i)) + isInDeclareSection = false; + break; + } + + // ---------------- process switch statements --------------------------------- + + if (isPotentialKeyword && findKeyword(line, i, ASResource::AS_SWITCH)) + { + switchDepth++; + switchStack.emplace_back(sw); // save current variables + sw.switchBraceCount = 0; + sw.unindentCase = false; // don't clear case until end of switch + i += 5; // bypass switch statement + continue; + } + + // just want unindented case statements from this point + + if (caseIndent + || switchDepth == 0 + || (isInPreprocessor && !preprocDefineIndent)) + { + // bypass the entire word + if (isPotentialKeyword) + { + string name = getCurrentWord(line, i); + i += name.length() - 1; + } + continue; + } + + i = processSwitchBlock(line, i); + + } // end of for loop * end of for loop * end of for loop * end of for loop +} + +/** + * process the character at the current index in a switch block. + * + * @param line a reference to the line to indent. + * @param index the current line index. + * @return the new line index. + */ +size_t ASEnhancer::processSwitchBlock(string& line, size_t index) +{ + size_t i = index; + bool isPotentialKeyword = isCharPotentialHeader(line, i); + + if (line[i] == '{') + { + sw.switchBraceCount++; + if (lookingForCaseBrace) // if 1st after case statement + { + sw.unindentCase = true; // unindenting this case + sw.unindentDepth++; + lookingForCaseBrace = false; // not looking now + } + return i; + } + lookingForCaseBrace = false; // no opening brace, don't indent + + if (line[i] == '}') + { + sw.switchBraceCount--; + assert(sw.switchBraceCount <= braceCount); + if (sw.switchBraceCount == 0) // if end of switch statement + { + int lineUnindent = sw.unindentDepth; + if (line.find_first_not_of(" \t") == i + && !switchStack.empty()) + lineUnindent = switchStack[switchStack.size() - 1].unindentDepth; + if (shouldUnindentLine) + { + if (lineUnindent > 0) + i -= unindentLine(line, lineUnindent); + shouldUnindentLine = false; + } + switchDepth--; + sw = switchStack.back(); + switchStack.pop_back(); + } + return i; + } + + if (isPotentialKeyword + && (findKeyword(line, i, ASResource::AS_CASE) + || findKeyword(line, i, ASResource::AS_DEFAULT))) + { + if (sw.unindentCase) // if unindented last case + { + sw.unindentCase = false; // stop unindenting previous case + sw.unindentDepth--; + } + + i = findCaseColon(line, i); + + i++; + for (; i < line.length(); i++) // bypass whitespace + { + if (!isWhiteSpace(line[i])) + break; + } + if (i < line.length()) + { + if (line[i] == '{') + { + braceCount++; + sw.switchBraceCount++; + if (!isOneLineBlockReached(line, i)) + unindentNextLine = true; + return i; + } + } + lookingForCaseBrace = true; + i--; // need to process this char + return i; + } + if (isPotentialKeyword) + { + string name = getCurrentWord(line, i); // bypass the entire name + i += name.length() - 1; + } + return i; +} + +/** + * unindent a line by a given number of tabsets + * by erasing the leading whitespace from the line argument. + * + * @param line a reference to the line to unindent. + * @param unindent the number of tabsets to erase. + * @return the number of characters erased. + */ +int ASEnhancer::unindentLine(string& line, int unindent) const +{ + size_t whitespace = line.find_first_not_of(" \t"); + + if (whitespace == string::npos) // if line is blank + whitespace = line.length(); // must remove padding, if any + + if (whitespace == 0) + return 0; + + size_t charsToErase = 0; + + if (forceTab && indentLength != tabLength) + { + // replace tab indents with spaces + convertForceTabIndentToSpaces(line); + // remove the space indents + size_t spaceIndentLength = line.find_first_not_of(" \t"); + charsToErase = unindent * indentLength; + if (charsToErase <= spaceIndentLength) + line.erase(0, charsToErase); + else + charsToErase = 0; + // replace leading spaces with tab indents + convertSpaceIndentToForceTab(line); + } + else if (useTabs) + { + charsToErase = unindent; + if (charsToErase <= whitespace) + line.erase(0, charsToErase); + else + charsToErase = 0; + } + else // spaces + { + charsToErase = unindent * indentLength; + if (charsToErase <= whitespace) + line.erase(0, charsToErase); + else + charsToErase = 0; + } + + return charsToErase; +} + +} // end namespace astyle diff --git a/thirdparty/astyle/ASFormatter.cpp b/thirdparty/astyle/ASFormatter.cpp new file mode 100755 index 00000000..b292305b --- /dev/null +++ b/thirdparty/astyle/ASFormatter.cpp @@ -0,0 +1,7714 @@ +// ASFormatter.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#include "astyle.h" + +#include +#include + +//----------------------------------------------------------------------------- +// astyle namespace +//----------------------------------------------------------------------------- + +namespace astyle { +// +//----------------------------------------------------------------------------- +// ASFormatter class +//----------------------------------------------------------------------------- + +/** + * Constructor of ASFormatter + */ +ASFormatter::ASFormatter() +{ + sourceIterator = nullptr; + enhancer = new ASEnhancer; + preBraceHeaderStack = nullptr; + braceTypeStack = nullptr; + parenStack = nullptr; + structStack = nullptr; + questionMarkStack = nullptr; + lineCommentNoIndent = false; + formattingStyle = STYLE_NONE; + braceFormatMode = NONE_MODE; + pointerAlignment = PTR_ALIGN_NONE; + referenceAlignment = REF_SAME_AS_PTR; + objCColonPadMode = COLON_PAD_NO_CHANGE; + lineEnd = LINEEND_DEFAULT; + maxCodeLength = string::npos; + shouldPadCommas = false; + shouldPadOperators = false; + shouldPadParensOutside = false; + shouldPadFirstParen = false; + shouldPadParensInside = false; + shouldPadHeader = false; + shouldStripCommentPrefix = false; + shouldUnPadParens = false; + attachClosingBraceMode = false; + shouldBreakOneLineBlocks = true; + shouldBreakOneLineHeaders = false; + shouldBreakOneLineStatements = true; + shouldConvertTabs = false; + shouldIndentCol1Comments = false; + shouldIndentPreprocBlock = false; + shouldCloseTemplates = false; + shouldAttachExternC = false; + shouldAttachNamespace = false; + shouldAttachClass = false; + shouldAttachClosingWhile = false; + shouldAttachInline = false; + shouldBreakBlocks = false; + shouldBreakClosingHeaderBlocks = false; + shouldBreakClosingHeaderBraces = false; + shouldDeleteEmptyLines = false; + shouldBreakElseIfs = false; + shouldBreakLineAfterLogical = false; + shouldAddBraces = false; + shouldAddOneLineBraces = false; + shouldRemoveBraces = false; + shouldPadMethodColon = false; + shouldPadMethodPrefix = false; + shouldUnPadMethodPrefix = false; + shouldPadReturnType = false; + shouldUnPadReturnType = false; + shouldPadParamType = false; + shouldUnPadParamType = false; + + // initialize ASFormatter member vectors + formatterFileType = 9; // reset to an invalid type + headers = new vector; + nonParenHeaders = new vector; + preDefinitionHeaders = new vector; + preCommandHeaders = new vector; + operators = new vector; + assignmentOperators = new vector; + castOperators = new vector; + + // initialize ASEnhancer member vectors + indentableMacros = new vector* >; +} + +/** + * Destructor of ASFormatter + */ +ASFormatter::~ASFormatter() +{ + // delete ASFormatter stack vectors + deleteContainer(preBraceHeaderStack); + deleteContainer(braceTypeStack); + deleteContainer(parenStack); + deleteContainer(structStack); + deleteContainer(questionMarkStack); + + // delete ASFormatter member vectors + formatterFileType = 9; // reset to an invalid type + delete headers; + delete nonParenHeaders; + delete preDefinitionHeaders; + delete preCommandHeaders; + delete operators; + delete assignmentOperators; + delete castOperators; + + // delete ASEnhancer member vectors + delete indentableMacros; + + // must be done when the ASFormatter object is deleted (not ASBeautifier) + // delete ASBeautifier member vectors + ASBeautifier::deleteBeautifierVectors(); + + delete enhancer; +} + +/** + * initialize the ASFormatter. + * + * init() should be called every time a ASFormatter object is to start + * formatting a NEW source file. + * init() receives a pointer to a ASSourceIterator object that will be + * used to iterate through the source code. + * + * @param si a pointer to the ASSourceIterator or ASStreamIterator object. + */ +void ASFormatter::init(ASSourceIterator* si) +{ + buildLanguageVectors(); + fixOptionVariableConflicts(); + ASBeautifier::init(si); + sourceIterator = si; + + enhancer->init(getFileType(), + getIndentLength(), + getTabLength(), + getIndentString() == "\t", + getForceTabIndentation(), + getNamespaceIndent(), + getCaseIndent(), + shouldIndentPreprocBlock, + getPreprocDefineIndent(), + getEmptyLineFill(), + indentableMacros); + + initContainer(preBraceHeaderStack, new vector); + initContainer(parenStack, new vector); + initContainer(structStack, new vector); + initContainer(questionMarkStack, new vector); + parenStack->emplace_back(0); // parenStack must contain this default entry + initContainer(braceTypeStack, new vector); + braceTypeStack->emplace_back(NULL_TYPE); // braceTypeStack must contain this default entry + clearFormattedLineSplitPoints(); + + currentHeader = nullptr; + currentLine = ""; + readyFormattedLine = ""; + formattedLine = ""; + verbatimDelimiter = ""; + currentChar = ' '; + previousChar = ' '; + previousCommandChar = ' '; + previousNonWSChar = ' '; + quoteChar = '"'; + preprocBlockEnd = 0; + charNum = 0; + checksumIn = 0; + checksumOut = 0; + currentLineFirstBraceNum = string::npos; + formattedLineCommentNum = 0; + leadingSpaces = 0; + previousReadyFormattedLineLength = string::npos; + preprocBraceTypeStackSize = 0; + spacePadNum = 0; + nextLineSpacePadNum = 0; + objCColonAlign = 0; + templateDepth = 0; + squareBracketCount = 0; + runInIndentChars = 0; + tabIncrementIn = 0; + previousBraceType = NULL_TYPE; + + isVirgin = true; + isInVirginLine = true; + isInLineComment = false; + isInComment = false; + isInCommentStartLine = false; + noTrimCommentContinuation = false; + isInPreprocessor = false; + isInPreprocessorBeautify = false; + doesLineStartComment = false; + lineEndsInCommentOnly = false; + lineIsCommentOnly = false; + lineIsLineCommentOnly = false; + lineIsEmpty = false; + isImmediatelyPostCommentOnly = false; + isImmediatelyPostEmptyLine = false; + isInClassInitializer = false; + isInQuote = false; + isInVerbatimQuote = false; + haveLineContinuationChar = false; + isInQuoteContinuation = false; + isHeaderInMultiStatementLine = false; + isSpecialChar = false; + isNonParenHeader = false; + foundNamespaceHeader = false; + foundClassHeader = false; + foundStructHeader = false; + foundInterfaceHeader = false; + foundPreDefinitionHeader = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + foundTrailingReturnType = false; + foundCastOperator = false; + foundQuestionMark = false; + isInLineBreak = false; + endOfAsmReached = false; + endOfCodeReached = false; + isFormattingModeOff = false; + isInEnum = false; + isInExecSQL = false; + isInAsm = false; + isInAsmOneLine = false; + isInAsmBlock = false; + isLineReady = false; + elseHeaderFollowsComments = false; + caseHeaderFollowsComments = false; + isPreviousBraceBlockRelated = false; + isInPotentialCalculation = false; + needHeaderOpeningBrace = false; + shouldBreakLineAtNextChar = false; + shouldKeepLineUnbroken = false; + shouldReparseCurrentChar = false; + passedSemicolon = false; + passedColon = false; + isImmediatelyPostNonInStmt = false; + isCharImmediatelyPostNonInStmt = false; + isInTemplate = false; + isImmediatelyPostComment = false; + isImmediatelyPostLineComment = false; + isImmediatelyPostEmptyBlock = false; + isImmediatelyPostObjCMethodPrefix = false; + isImmediatelyPostPreprocessor = false; + isImmediatelyPostReturn = false; + isImmediatelyPostThrow = false; + isImmediatelyPostNewDelete = false; + isImmediatelyPostOperator = false; + isImmediatelyPostTemplate = false; + isImmediatelyPostPointerOrReference = false; + isCharImmediatelyPostReturn = false; + isCharImmediatelyPostThrow = false; + isCharImmediatelyPostNewDelete = false; + isCharImmediatelyPostOperator = false; + isCharImmediatelyPostComment = false; + isPreviousCharPostComment = false; + isCharImmediatelyPostLineComment = false; + isCharImmediatelyPostOpenBlock = false; + isCharImmediatelyPostCloseBlock = false; + isCharImmediatelyPostTemplate = false; + isCharImmediatelyPostPointerOrReference = false; + isInObjCInterface = false; + isInObjCMethodDefinition = false; + isInObjCReturnType = false; + isInObjCSelector = false; + breakCurrentOneLineBlock = false; + shouldRemoveNextClosingBrace = false; + isInBraceRunIn = false; + currentLineBeginsWithBrace = false; + isPrependPostBlockEmptyLineRequested = false; + isAppendPostBlockEmptyLineRequested = false; + isIndentableProprocessor = false; + isIndentableProprocessorBlock = false; + prependEmptyLine = false; + appendOpeningBrace = false; + foundClosingHeader = false; + isImmediatelyPostHeader = false; + isInHeader = false; + isInCase = false; + isFirstPreprocConditional = false; + processedFirstConditional = false; + isJavaStaticConstructor = false; +} + +/** + * build vectors for each programing language + * depending on the file extension. + */ +void ASFormatter::buildLanguageVectors() +{ + if (getFileType() == formatterFileType) // don't build unless necessary + return; + + formatterFileType = getFileType(); + + headers->clear(); + nonParenHeaders->clear(); + preDefinitionHeaders->clear(); + preCommandHeaders->clear(); + operators->clear(); + assignmentOperators->clear(); + castOperators->clear(); + indentableMacros->clear(); // ASEnhancer + + ASResource::buildHeaders(headers, getFileType()); + ASResource::buildNonParenHeaders(nonParenHeaders, getFileType()); + ASResource::buildPreDefinitionHeaders(preDefinitionHeaders, getFileType()); + ASResource::buildPreCommandHeaders(preCommandHeaders, getFileType()); + ASResource::buildOperators(operators, getFileType()); + ASResource::buildAssignmentOperators(assignmentOperators); + ASResource::buildCastOperators(castOperators); + ASResource::buildIndentableMacros(indentableMacros); //ASEnhancer +} + +/** + * set the variables for each predefined style. + * this will override any previous settings. + */ +void ASFormatter::fixOptionVariableConflicts() +{ + if (formattingStyle == STYLE_ALLMAN) + { + setBraceFormatMode(BREAK_MODE); + } + else if (formattingStyle == STYLE_JAVA) + { + setBraceFormatMode(ATTACH_MODE); + } + else if (formattingStyle == STYLE_KR) + { + setBraceFormatMode(LINUX_MODE); + } + else if (formattingStyle == STYLE_STROUSTRUP) + { + setBraceFormatMode(LINUX_MODE); + setBreakClosingHeaderBracesMode(true); + } + else if (formattingStyle == STYLE_WHITESMITH) + { + setBraceFormatMode(BREAK_MODE); + setBraceIndent(true); + setClassIndent(true); // avoid hanging indent with access modifiers + setSwitchIndent(true); // avoid hanging indent with case statements + } + else if (formattingStyle == STYLE_VTK) + { + // the unindented class brace does NOT cause a hanging indent like Whitesmith + setBraceFormatMode(BREAK_MODE); + setBraceIndentVtk(true); // sets both braceIndent and braceIndentVtk + setSwitchIndent(true); // avoid hanging indent with case statements + } + else if (formattingStyle == STYLE_BANNER) + { + // attached braces can have hanging indents with the closing brace + setBraceFormatMode(ATTACH_MODE); + setBraceIndent(true); + setClassIndent(true); // avoid hanging indent with access modifiers + setSwitchIndent(true); // avoid hanging indent with case statements + } + else if (formattingStyle == STYLE_GNU) + { + setBraceFormatMode(BREAK_MODE); + setBlockIndent(true); + } + else if (formattingStyle == STYLE_LINUX) + { + setBraceFormatMode(LINUX_MODE); + // always for Linux style + setMinConditionalIndentOption(MINCOND_ONEHALF); + } + else if (formattingStyle == STYLE_HORSTMANN) + { + setBraceFormatMode(RUN_IN_MODE); + setSwitchIndent(true); + } + else if (formattingStyle == STYLE_1TBS) + { + setBraceFormatMode(LINUX_MODE); + setAddBracesMode(true); + setRemoveBracesMode(false); + } + else if (formattingStyle == STYLE_GOOGLE) + { + setBraceFormatMode(ATTACH_MODE); + setModifierIndent(true); + setClassIndent(false); + } + else if (formattingStyle == STYLE_MOZILLA) + { + setBraceFormatMode(LINUX_MODE); + } + else if (formattingStyle == STYLE_PICO) + { + setBraceFormatMode(RUN_IN_MODE); + setAttachClosingBraceMode(true); + setSwitchIndent(true); + setBreakOneLineBlocksMode(false); + setBreakOneLineStatementsMode(false); + // add-braces won't work for pico, but it could be fixed if necessary + // both options should be set to true + if (shouldAddBraces) + shouldAddOneLineBraces = true; + } + else if (formattingStyle == STYLE_LISP) + { + setBraceFormatMode(ATTACH_MODE); + setAttachClosingBraceMode(true); + setBreakOneLineStatementsMode(false); + // add-one-line-braces won't work for lisp + // only shouldAddBraces should be set to true + if (shouldAddOneLineBraces) + { + shouldAddBraces = true; + shouldAddOneLineBraces = false; + } + } + setMinConditionalIndentLength(); + // if not set by indent=force-tab-x set equal to indentLength + if (getTabLength() == 0) + setDefaultTabLength(); + // add-one-line-braces implies keep-one-line-blocks + if (shouldAddOneLineBraces) + setBreakOneLineBlocksMode(false); + // don't allow add-braces and remove-braces + if (shouldAddBraces || shouldAddOneLineBraces) + setRemoveBracesMode(false); + // don't allow indent-classes and indent-modifiers + if (getClassIndent()) + setModifierIndent(false); +} + +/** + * get the next formatted line. + * + * @return formatted line. + */ +string ASFormatter::nextLine() +{ + const string* newHeader = nullptr; + isInVirginLine = isVirgin; + isCharImmediatelyPostComment = false; + isPreviousCharPostComment = false; + isCharImmediatelyPostLineComment = false; + isCharImmediatelyPostOpenBlock = false; + isCharImmediatelyPostCloseBlock = false; + isCharImmediatelyPostTemplate = false; + + while (!isLineReady) + { + if (shouldReparseCurrentChar) + shouldReparseCurrentChar = false; + else if (!getNextChar()) + { + breakLine(); + continue; + } + else // stuff to do when reading a new character... + { + // make sure that a virgin '{' at the beginning of the file will be treated as a block... + if (isInVirginLine && currentChar == '{' + && currentLineBeginsWithBrace + && previousCommandChar == ' ') + previousCommandChar = '{'; + if (isInClassInitializer + && isBraceType(braceTypeStack->back(), COMMAND_TYPE)) + isInClassInitializer = false; + if (isInBraceRunIn) + isInLineBreak = false; + if (!isWhiteSpace(currentChar)) + isInBraceRunIn = false; + isPreviousCharPostComment = isCharImmediatelyPostComment; + isCharImmediatelyPostComment = false; + isCharImmediatelyPostTemplate = false; + isCharImmediatelyPostReturn = false; + isCharImmediatelyPostThrow = false; + isCharImmediatelyPostNewDelete = false; + isCharImmediatelyPostOperator = false; + isCharImmediatelyPostPointerOrReference = false; + isCharImmediatelyPostOpenBlock = false; + isCharImmediatelyPostCloseBlock = false; + } + + if ((lineIsLineCommentOnly || lineIsCommentOnly) + && currentLine.find("*INDENT-ON*", charNum) != string::npos + && isFormattingModeOff) + { + isFormattingModeOff = false; + breakLine(); + formattedLine = currentLine; + charNum = (int) currentLine.length() - 1; + continue; + } + if (isFormattingModeOff) + { + breakLine(); + formattedLine = currentLine; + charNum = (int) currentLine.length() - 1; + continue; + } + if ((lineIsLineCommentOnly || lineIsCommentOnly) + && currentLine.find("*INDENT-OFF*", charNum) != string::npos) + { + isFormattingModeOff = true; + if (isInLineBreak) // is true if not the first line + breakLine(); + formattedLine = currentLine; + charNum = (int)currentLine.length() - 1; + continue; + } + + if (shouldBreakLineAtNextChar) + { + if (isWhiteSpace(currentChar) && !lineIsEmpty) + continue; + isInLineBreak = true; + shouldBreakLineAtNextChar = false; + } + + if (isInExecSQL && !passedSemicolon) + { + if (currentChar == ';') + passedSemicolon = true; + appendCurrentChar(); + continue; + } + + if (isInLineComment) + { + formatLineCommentBody(); + continue; + } + else if (isInComment) + { + formatCommentBody(); + continue; + } + + else if (isInQuote) + { + formatQuoteBody(); + continue; + } + + // not in quote or comment or line comment + + if (isSequenceReached("//")) + { + formatLineCommentOpener(); + testForTimeToSplitFormattedLine(); + continue; + } + else if (isSequenceReached("/*")) + { + formatCommentOpener(); + testForTimeToSplitFormattedLine(); + continue; + } + else if (currentChar == '"' + || (currentChar == '\'' && !isDigitSeparator(currentLine, charNum))) + { + formatQuoteOpener(); + testForTimeToSplitFormattedLine(); + continue; + } + // treat these preprocessor statements as a line comment + else if (currentChar == '#' + && currentLine.find_first_not_of(" \t") == (size_t) charNum) + { + string preproc = trim(currentLine.c_str() + charNum + 1); + if (preproc.length() > 0 + && isCharPotentialHeader(preproc, 0) + && (findKeyword(preproc, 0, "region") + || findKeyword(preproc, 0, "endregion") + || findKeyword(preproc, 0, "error") + || findKeyword(preproc, 0, "warning") + || findKeyword(preproc, 0, "line"))) + { + currentLine = rtrim(currentLine); // trim the end only + // check for run-in + if (formattedLine.length() > 0 && formattedLine[0] == '{') + { + isInLineBreak = true; + isInBraceRunIn = false; + } + if (previousCommandChar == '}') + currentHeader = nullptr; + isInLineComment = true; + appendCurrentChar(); + continue; + } + } + + if (isInPreprocessor) + { + appendCurrentChar(); + continue; + } + + if (isInTemplate && shouldCloseTemplates) + { + if (previousNonWSChar == '>' && isWhiteSpace(currentChar) && peekNextChar() == '>') + continue; + } + + if (shouldRemoveNextClosingBrace && currentChar == '}') + { + currentLine[charNum] = currentChar = ' '; + shouldRemoveNextClosingBrace = false; + assert(adjustChecksumIn(-'}')); + if (isEmptyLine(currentLine)) + continue; + } + + // handle white space - needed to simplify the rest. + if (isWhiteSpace(currentChar)) + { + appendCurrentChar(); + continue; + } + + /* not in MIDDLE of quote or comment or SQL or white-space of any type ... */ + + // check if in preprocessor + // ** isInPreprocessor will be automatically reset at the beginning + // of a new line in getnextChar() + if (currentChar == '#') + { + isInPreprocessor = true; + // check for run-in + if (formattedLine.length() > 0 && formattedLine[0] == '{') + { + isInLineBreak = true; + isInBraceRunIn = false; + } + processPreprocessor(); + // if top level it is potentially indentable + if (shouldIndentPreprocBlock + && (isBraceType(braceTypeStack->back(), NULL_TYPE) + || isBraceType(braceTypeStack->back(), NAMESPACE_TYPE)) + && !foundClassHeader + && !isInClassInitializer + && sourceIterator->tellg() > preprocBlockEnd) + { + // indent the #if preprocessor blocks + string preproc = ASBeautifier::extractPreprocessorStatement(currentLine); + if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef + { + if (isImmediatelyPostPreprocessor) + breakLine(); + isIndentableProprocessorBlock = isIndentablePreprocessorBlock(currentLine, charNum); + isIndentableProprocessor = isIndentableProprocessorBlock; + } + } + if (isIndentableProprocessorBlock + && charNum < (int) currentLine.length() - 1 + && isWhiteSpace(currentLine[charNum + 1])) + { + size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextText != string::npos) + currentLine.erase(charNum + 1, nextText - charNum - 1); + } + if (isIndentableProprocessorBlock + && sourceIterator->tellg() >= preprocBlockEnd) + isIndentableProprocessorBlock = false; + // need to fall thru here to reset the variables + } + + /* not in preprocessor ... */ + + if (isImmediatelyPostComment) + { + caseHeaderFollowsComments = false; + isImmediatelyPostComment = false; + isCharImmediatelyPostComment = true; + } + + if (isImmediatelyPostLineComment) + { + caseHeaderFollowsComments = false; + isImmediatelyPostLineComment = false; + isCharImmediatelyPostLineComment = true; + } + + if (isImmediatelyPostReturn) + { + isImmediatelyPostReturn = false; + isCharImmediatelyPostReturn = true; + } + + if (isImmediatelyPostThrow) + { + isImmediatelyPostThrow = false; + isCharImmediatelyPostThrow = true; + } + + if (isImmediatelyPostNewDelete) + { + isImmediatelyPostNewDelete = false; + isCharImmediatelyPostNewDelete = true; + } + + if (isImmediatelyPostOperator) + { + isImmediatelyPostOperator = false; + isCharImmediatelyPostOperator = true; + } + if (isImmediatelyPostTemplate) + { + isImmediatelyPostTemplate = false; + isCharImmediatelyPostTemplate = true; + } + if (isImmediatelyPostPointerOrReference) + { + isImmediatelyPostPointerOrReference = false; + isCharImmediatelyPostPointerOrReference = true; + } + + // reset isImmediatelyPostHeader information + if (isImmediatelyPostHeader) + { + // should braces be added + if (currentChar != '{' + && shouldAddBraces + && (shouldBreakOneLineStatements || !isHeaderInMultiStatementLine) + && isOkToBreakBlock(braceTypeStack->back())) + { + bool bracesAdded = addBracesToStatement(); + if (bracesAdded && !shouldAddOneLineBraces) + { + size_t firstText = currentLine.find_first_not_of(" \t"); + assert(firstText != string::npos); + if ((int) firstText == charNum || shouldBreakOneLineHeaders) + breakCurrentOneLineBlock = true; + } + } + // should braces be removed + else if (currentChar == '{' && shouldRemoveBraces) + { + bool bracesRemoved = removeBracesFromStatement(); + if (bracesRemoved) + { + shouldRemoveNextClosingBrace = true; + if (isBeforeAnyLineEndComment(charNum)) + spacePadNum--; + else if (shouldBreakOneLineBlocks + || (currentLineBeginsWithBrace + && currentLine.find_first_not_of(" \t") != string::npos)) + shouldBreakLineAtNextChar = true; + continue; + } + } + + // break 'else-if' if shouldBreakElseIfs is requested + if (shouldBreakElseIfs + && currentHeader == &AS_ELSE + && isOkToBreakBlock(braceTypeStack->back()) + && !isBeforeAnyComment() + && (shouldBreakOneLineStatements || !isHeaderInMultiStatementLine)) + { + string nextText = peekNextText(currentLine.substr(charNum)); + if (nextText.length() > 0 + && isCharPotentialHeader(nextText, 0) + && ASBase::findHeader(nextText, 0, headers) == &AS_IF) + { + isInLineBreak = true; + } + } + + // break a header (e.g. if, while, else) from the following statement + if (shouldBreakOneLineHeaders + && peekNextChar() != ' ' + && (shouldBreakOneLineStatements + || (!isHeaderInMultiStatementLine + && !isMultiStatementLine())) + && isOkToBreakBlock(braceTypeStack->back()) + && !isBeforeAnyComment()) + { + if (currentChar == '{') + { + if (!currentLineBeginsWithBrace) + { + if (isOneLineBlockReached(currentLine, charNum) == 3) + isInLineBreak = false; + else + breakCurrentOneLineBlock = true; + } + } + else if (currentHeader == &AS_ELSE) + { + string nextText = peekNextText(currentLine.substr(charNum), true); + if (nextText.length() > 0 + && ((isCharPotentialHeader(nextText, 0) + && ASBase::findHeader(nextText, 0, headers) != &AS_IF) + || nextText[0] == '{')) + isInLineBreak = true; + } + else + { + isInLineBreak = true; + } + } + + isImmediatelyPostHeader = false; + } + + if (passedSemicolon) // need to break the formattedLine + { + passedSemicolon = false; + if (parenStack->back() == 0 && !isCharImmediatelyPostComment && currentChar != ';') // allow ;; + { + // does a one-line block have ending comments? + if (isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)) + { + size_t blockEnd = currentLine.rfind(AS_CLOSE_BRACE); + assert(blockEnd != string::npos); + // move ending comments to this formattedLine + if (isBeforeAnyLineEndComment(blockEnd)) + { + size_t commentStart = currentLine.find_first_not_of(" \t", blockEnd + 1); + assert(commentStart != string::npos); + assert((currentLine.compare(commentStart, 2, "//") == 0) + || (currentLine.compare(commentStart, 2, "/*") == 0)); + formattedLine.append(getIndentLength() - 1, ' '); + // append comment + int charNumSave = charNum; + charNum = commentStart; + while (charNum < (int) currentLine.length()) + { + currentChar = currentLine[charNum]; + if (currentChar == '\t' && shouldConvertTabs) + convertTabToSpaces(); + formattedLine.append(1, currentChar); + ++charNum; + } + size_t commentLength = currentLine.length() - commentStart; + currentLine.erase(commentStart, commentLength); + charNum = charNumSave; + currentChar = currentLine[charNum]; + testForTimeToSplitFormattedLine(); + } + } + isInExecSQL = false; + shouldReparseCurrentChar = true; + if (formattedLine.find_first_not_of(" \t") != string::npos) + isInLineBreak = true; + if (needHeaderOpeningBrace) + { + isCharImmediatelyPostCloseBlock = true; + needHeaderOpeningBrace = false; + } + continue; + } + } + + if (passedColon) + { + passedColon = false; + if (parenStack->back() == 0 + && !isBeforeAnyComment() + && (formattedLine.find_first_not_of(" \t") != string::npos)) + { + shouldReparseCurrentChar = true; + isInLineBreak = true; + continue; + } + } + + // Check if in template declaration, e.g. foo or foo + if (!isInTemplate && currentChar == '<') + { + checkIfTemplateOpener(); + } + + // handle parens + if (currentChar == '(' || currentChar == '[' || (isInTemplate && currentChar == '<')) + { + questionMarkStack->push_back(foundQuestionMark); + foundQuestionMark = false; + parenStack->back()++; + if (currentChar == '[') + { + ++squareBracketCount; + if (getAlignMethodColon() && squareBracketCount == 1 && isCStyle()) + objCColonAlign = findObjCColonAlignment(); + } + } + else if (currentChar == ')' || currentChar == ']' || (isInTemplate && currentChar == '>')) + { + foundPreCommandHeader = false; + parenStack->back()--; + // this can happen in preprocessor directives + if (parenStack->back() < 0) + parenStack->back() = 0; + if (!questionMarkStack->empty()) + { + foundQuestionMark = questionMarkStack->back(); + questionMarkStack->pop_back(); + } + if (isInTemplate && currentChar == '>') + { + templateDepth--; + if (templateDepth == 0) + { + isInTemplate = false; + isImmediatelyPostTemplate = true; + } + } + + // check if this parenthesis closes a header, e.g. if (...), while (...) + if (isInHeader && parenStack->back() == 0) + { + isInHeader = false; + isImmediatelyPostHeader = true; + foundQuestionMark = false; + } + if (currentChar == ']') + { + --squareBracketCount; + if (squareBracketCount <= 0) + { + squareBracketCount = 0; + objCColonAlign = 0; + } + } + if (currentChar == ')') + { + foundCastOperator = false; + if (parenStack->back() == 0) + endOfAsmReached = true; + } + } + + // handle braces + if (currentChar == '{' || currentChar == '}') + { + // if appendOpeningBrace this was already done for the original brace + if (currentChar == '{' && !appendOpeningBrace) + { + BraceType newBraceType = getBraceType(); + breakCurrentOneLineBlock = false; + foundNamespaceHeader = false; + foundClassHeader = false; + foundStructHeader = false; + foundInterfaceHeader = false; + foundPreDefinitionHeader = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + foundTrailingReturnType = false; + isInPotentialCalculation = false; + isInObjCMethodDefinition = false; + isInObjCInterface = false; + isInEnum = false; + isJavaStaticConstructor = false; + isCharImmediatelyPostNonInStmt = false; + needHeaderOpeningBrace = false; + shouldKeepLineUnbroken = false; + objCColonAlign = 0; + + isPreviousBraceBlockRelated = !isBraceType(newBraceType, ARRAY_TYPE); + braceTypeStack->emplace_back(newBraceType); + preBraceHeaderStack->emplace_back(currentHeader); + currentHeader = nullptr; + structStack->push_back(isInIndentableStruct); + if (isBraceType(newBraceType, STRUCT_TYPE) && isCStyle()) + isInIndentableStruct = isStructAccessModified(currentLine, charNum); + else + isInIndentableStruct = false; + } + + // this must be done before the braceTypeStack is popped + BraceType braceType = braceTypeStack->back(); + bool isOpeningArrayBrace = (isBraceType(braceType, ARRAY_TYPE) + && braceTypeStack->size() >= 2 + && !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2], ARRAY_TYPE) + ); + + if (currentChar == '}') + { + // if a request has been made to append a post block empty line, + // but the block exists immediately before a closing brace, + // then there is no need for the post block empty line. + isAppendPostBlockEmptyLineRequested = false; + if (isInAsm) + endOfAsmReached = true; + isInAsmOneLine = isInQuote = false; + shouldKeepLineUnbroken = false; + squareBracketCount = 0; + + if (braceTypeStack->size() > 1) + { + previousBraceType = braceTypeStack->back(); + braceTypeStack->pop_back(); + isPreviousBraceBlockRelated = !isBraceType(braceType, ARRAY_TYPE); + } + else + { + previousBraceType = NULL_TYPE; + isPreviousBraceBlockRelated = false; + } + + if (!preBraceHeaderStack->empty()) + { + currentHeader = preBraceHeaderStack->back(); + preBraceHeaderStack->pop_back(); + } + else + currentHeader = nullptr; + + if (!structStack->empty()) + { + isInIndentableStruct = structStack->back(); + structStack->pop_back(); + } + else + isInIndentableStruct = false; + + if (isNonInStatementArray + && (!isBraceType(braceTypeStack->back(), ARRAY_TYPE) // check previous brace + || peekNextChar() == ';')) // check for "};" added V2.01 + isImmediatelyPostNonInStmt = true; + + if (!shouldBreakOneLineStatements + && ASBeautifier::getNextWord(currentLine, charNum) == AS_ELSE) + { + // handle special case of "else" at the end of line + size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (ASBeautifier::peekNextChar(currentLine, nextText + 3) == ' ') + shouldBreakLineAtNextChar = true; + } + } + + // format braces + appendOpeningBrace = false; + if (isBraceType(braceType, ARRAY_TYPE)) + { + formatArrayBraces(braceType, isOpeningArrayBrace); + } + else + { + if (currentChar == '{') + formatOpeningBrace(braceType); + else + formatClosingBrace(braceType); + } + continue; + } + + if ((((previousCommandChar == '{' && isPreviousBraceBlockRelated) + || ((previousCommandChar == '}' + && !isImmediatelyPostEmptyBlock + && isPreviousBraceBlockRelated + && !isPreviousCharPostComment // Fixes wrongly appended newlines after '}' immediately after comments + && peekNextChar() != ' ' + && !isBraceType(previousBraceType, DEFINITION_TYPE)) + && !isBraceType(braceTypeStack->back(), DEFINITION_TYPE))) + && isOkToBreakBlock(braceTypeStack->back())) + // check for array + || (previousCommandChar == '{' // added 9/30/2010 + && isBraceType(braceTypeStack->back(), ARRAY_TYPE) + && !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE) + && isNonInStatementArray) + // check for pico one line braces + || (formattingStyle == STYLE_PICO + && (previousCommandChar == '{' && isPreviousBraceBlockRelated) + && isBraceType(braceTypeStack->back(), COMMAND_TYPE) + && isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE) + && braceFormatMode == RUN_IN_MODE) + ) + { + isCharImmediatelyPostOpenBlock = (previousCommandChar == '{'); + isCharImmediatelyPostCloseBlock = (previousCommandChar == '}'); + + if (isCharImmediatelyPostOpenBlock + && !isCharImmediatelyPostComment + && !isCharImmediatelyPostLineComment) + { + previousCommandChar = ' '; + + if (braceFormatMode == NONE_MODE) + { + if (isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE) + && (isBraceType(braceTypeStack->back(), BREAK_BLOCK_TYPE) + || shouldBreakOneLineBlocks)) + isInLineBreak = true; + else if (currentLineBeginsWithBrace) + formatRunIn(); + else + breakLine(); + } + else if (braceFormatMode == RUN_IN_MODE + && currentChar != '#') + formatRunIn(); + else + isInLineBreak = true; + } + else if (isCharImmediatelyPostCloseBlock + && shouldBreakOneLineStatements + && !isCharImmediatelyPostComment + && ((isLegalNameChar(currentChar) && currentChar != '.') + || currentChar == '+' + || currentChar == '-' + || currentChar == '*' + || currentChar == '&' + || currentChar == '(')) + { + previousCommandChar = ' '; + isInLineBreak = true; + } + } + + // reset block handling flags + isImmediatelyPostEmptyBlock = false; + + // look for headers + bool isPotentialHeader = isCharPotentialHeader(currentLine, charNum); + + if (isPotentialHeader && !isInTemplate && squareBracketCount == 0) + { + isNonParenHeader = false; + foundClosingHeader = false; + + newHeader = findHeader(headers); + + // Qt headers may be variables in C++ + if (isCStyle() + && (newHeader == &AS_FOREVER || newHeader == &AS_FOREACH)) + { + if (currentLine.find_first_of("=;", charNum) != string::npos) + newHeader = nullptr; + } + if (isJavaStyle() + && (newHeader == &AS_SYNCHRONIZED)) + { + // want synchronized statements not synchronized methods + if (!isBraceType(braceTypeStack->back(), COMMAND_TYPE)) + newHeader = nullptr; + } + else if (newHeader == &AS_USING + && ASBeautifier::peekNextChar( + currentLine, charNum + (*newHeader).length() - 1) != '(') + newHeader = nullptr; + + if (newHeader != nullptr) + { + foundClosingHeader = isClosingHeader(newHeader); + + if (!foundClosingHeader) + { + // these are closing headers + if ((newHeader == &AS_WHILE && currentHeader == &AS_DO) + || (newHeader == &_AS_FINALLY && currentHeader == &_AS_TRY) + || (newHeader == &_AS_EXCEPT && currentHeader == &_AS_TRY)) + foundClosingHeader = true; + // don't append empty block for these related headers + else if (isSharpStyle() + && previousNonWSChar == '}' + && ((newHeader == &AS_SET && currentHeader == &AS_GET) + || (newHeader == &AS_REMOVE && currentHeader == &AS_ADD)) + && isOkToBreakBlock(braceTypeStack->back())) + isAppendPostBlockEmptyLineRequested = false; + } + + // TODO: this can be removed in a future release + // version 3.0 - break erroneous attached header from previous versions + if (isSharpStyle() + && ((newHeader == &AS_SET && currentHeader == &AS_GET) + || (newHeader == &AS_REMOVE && currentHeader == &AS_ADD)) + && !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE) + && currentLine[currentLine.find_first_not_of(" \t")] == '}') + isInLineBreak = true; + // END TODO + + const string* previousHeader = currentHeader; + currentHeader = newHeader; + needHeaderOpeningBrace = true; + + // is the previous statement on the same line? + if ((previousNonWSChar == ';' || previousNonWSChar == ':') + && !isInLineBreak + && isOkToBreakBlock(braceTypeStack->back())) + { + // if breaking lines, break the line at the header + // except for multiple 'case' statements on a line + if (maxCodeLength != string::npos + && previousHeader != &AS_CASE) + isInLineBreak = true; + else + isHeaderInMultiStatementLine = true; + } + + if (foundClosingHeader && previousNonWSChar == '}') + { + if (isOkToBreakBlock(braceTypeStack->back())) + isLineBreakBeforeClosingHeader(); + + // get the adjustment for a comment following the closing header + if (isInLineBreak) + nextLineSpacePadNum = getNextLineCommentAdjustment(); + else + spacePadNum = getCurrentLineCommentAdjustment(); + } + + // check if the found header is non-paren header + isNonParenHeader = findHeader(nonParenHeaders) != nullptr; + + if (isNonParenHeader + && (currentHeader == &AS_CATCH + || currentHeader == &AS_CASE)) + { + int startChar = charNum + currentHeader->length() - 1; + if (ASBeautifier::peekNextChar(currentLine, startChar) == '(') + isNonParenHeader = false; + } + + // join 'else if' statements + if (currentHeader == &AS_IF + && previousHeader == &AS_ELSE + && isInLineBreak + && !shouldBreakElseIfs + && !isCharImmediatelyPostLineComment + && !isImmediatelyPostPreprocessor) + { + // 'else' must be last thing on the line + size_t start = formattedLine.length() >= 6 ? formattedLine.length() - 6 : 0; + if (formattedLine.find(AS_ELSE, start) != string::npos) + { + appendSpacePad(); + isInLineBreak = false; + } + } + + appendSequence(*currentHeader); + goForward(currentHeader->length() - 1); + // if a paren-header is found add a space after it, if needed + // this checks currentLine, appendSpacePad() checks formattedLine + // in 'case' and C# 'catch' can be either a paren or non-paren header + if (shouldPadHeader + && !isNonParenHeader + && charNum < (int) currentLine.length() - 1 && !isWhiteSpace(currentLine[charNum + 1])) + appendSpacePad(); + + // Signal that a header has been reached + // *** But treat a closing while() (as in do...while) + // as if it were NOT a header since a closing while() + // should never have a block after it! + if (currentHeader != &AS_CASE && currentHeader != &AS_DEFAULT + && !(foundClosingHeader && currentHeader == &AS_WHILE)) + { + isInHeader = true; + + // in C# 'catch' and 'delegate' can be a paren or non-paren header + if (isNonParenHeader && !isSharpStyleWithParen(currentHeader)) + { + isImmediatelyPostHeader = true; + isInHeader = false; + } + } + + if (shouldBreakBlocks + && isOkToBreakBlock(braceTypeStack->back()) + && !isHeaderInMultiStatementLine) + { + if (previousHeader == nullptr + && !foundClosingHeader + && !isCharImmediatelyPostOpenBlock + && !isImmediatelyPostCommentOnly) + { + isPrependPostBlockEmptyLineRequested = true; + } + + if (isClosingHeader(currentHeader) + || foundClosingHeader) + { + isPrependPostBlockEmptyLineRequested = false; + } + + if (shouldBreakClosingHeaderBlocks + && isCharImmediatelyPostCloseBlock + && !isImmediatelyPostCommentOnly + && !(currentHeader == &AS_WHILE // do-while + && foundClosingHeader)) + { + isPrependPostBlockEmptyLineRequested = true; + } + } + + if (currentHeader == &AS_CASE + || currentHeader == &AS_DEFAULT) + isInCase = true; + + continue; + } + else if ((newHeader = findHeader(preDefinitionHeaders)) != nullptr + && parenStack->back() == 0 + && !isInEnum) // not C++11 enum class + { + if (newHeader == &AS_NAMESPACE || newHeader == &AS_MODULE) + foundNamespaceHeader = true; + if (newHeader == &AS_CLASS) + foundClassHeader = true; + if (newHeader == &AS_STRUCT) + foundStructHeader = true; + if (newHeader == &AS_INTERFACE) + foundInterfaceHeader = true; + foundPreDefinitionHeader = true; + appendSequence(*newHeader); + goForward(newHeader->length() - 1); + + continue; + } + else if ((newHeader = findHeader(preCommandHeaders)) != nullptr) + { + // a 'const' variable is not a preCommandHeader + if (previousNonWSChar == ')') + foundPreCommandHeader = true; + } + else if ((newHeader = findHeader(castOperators)) != nullptr) + { + foundCastOperator = true; + appendSequence(*newHeader); + goForward(newHeader->length() - 1); + continue; + } + } // (isPotentialHeader && !isInTemplate) + + if (isInLineBreak) // OK to break line here + { + breakLine(); + if (isInVirginLine) // adjust for the first line + { + lineCommentNoBeautify = lineCommentNoIndent; + lineCommentNoIndent = false; + if (isImmediatelyPostPreprocessor) + { + isInIndentablePreproc = isIndentableProprocessor; + isIndentableProprocessor = false; + } + } + } + + if (previousNonWSChar == '}' || currentChar == ';') + { + if (currentChar == ';') + { + squareBracketCount = 0; + + if (((shouldBreakOneLineStatements + || isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)) + && isOkToBreakBlock(braceTypeStack->back())) + && !(attachClosingBraceMode && peekNextChar() == '}')) + { + passedSemicolon = true; + } + else if (!shouldBreakOneLineStatements + && ASBeautifier::getNextWord(currentLine, charNum) == AS_ELSE) + { + // handle special case of "else" at the end of line + size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (ASBeautifier::peekNextChar(currentLine, nextText + 3) == ' ') + passedSemicolon = true; + } + + if (shouldBreakBlocks + && currentHeader != nullptr + && currentHeader != &AS_CASE + && currentHeader != &AS_DEFAULT + && !isHeaderInMultiStatementLine + && parenStack->back() == 0) + { + isAppendPostBlockEmptyLineRequested = true; + } + } + if (currentChar != ';' + || (needHeaderOpeningBrace && parenStack->back() == 0)) + currentHeader = nullptr; + resetEndOfStatement(); + } + + if (currentChar == ':' + && previousChar != ':' // not part of '::' + && peekNextChar() != ':') // not part of '::' + { + if (isInCase) + { + isInCase = false; + if (shouldBreakOneLineStatements) + passedColon = true; + } + else if (isCStyle() // for C/C++ only + && isOkToBreakBlock(braceTypeStack->back()) + && shouldBreakOneLineStatements + && !foundQuestionMark // not in a ?: sequence + && !foundPreDefinitionHeader // not in a definition block + && previousCommandChar != ')' // not after closing paren of a method header + && !foundPreCommandHeader // not after a 'noexcept' + && squareBracketCount == 0 // not in objC method call + && !isInObjCMethodDefinition // not objC '-' or '+' method + && !isInObjCInterface // not objC @interface + && !isInObjCSelector // not objC @selector + && !isDigit(peekNextChar()) // not a bit field + && !isInEnum // not an enum with a base type + && !isInAsm // not in extended assembler + && !isInAsmOneLine // not in extended assembler + && !isInAsmBlock) // not in extended assembler + { + passedColon = true; + } + + if (isCStyle() + && shouldPadMethodColon + && (squareBracketCount > 0 || isInObjCMethodDefinition || isInObjCSelector) + && !foundQuestionMark) // not in a ?: sequence + padObjCMethodColon(); + + if (isInObjCInterface) + { + appendSpacePad(); + if ((int) currentLine.length() > charNum + 1 + && !isWhiteSpace(currentLine[charNum + 1])) + currentLine.insert(charNum + 1, " "); + } + + if (isClassInitializer()) + isInClassInitializer = true; + } + + if (currentChar == '?') + foundQuestionMark = true; + + if (isPotentialHeader && !isInTemplate) + { + if (findKeyword(currentLine, charNum, AS_NEW) + || findKeyword(currentLine, charNum, AS_DELETE)) + { + isInPotentialCalculation = false; + isImmediatelyPostNewDelete = true; + } + + if (findKeyword(currentLine, charNum, AS_RETURN)) + { + isInPotentialCalculation = true; // return is the same as an = sign + isImmediatelyPostReturn = true; + } + + if (findKeyword(currentLine, charNum, AS_OPERATOR)) + isImmediatelyPostOperator = true; + + if (findKeyword(currentLine, charNum, AS_ENUM)) + { + size_t firstNum = currentLine.find_first_of("(){},/"); + if (firstNum == string::npos + || currentLine[firstNum] == '{' + || currentLine[firstNum] == '/') + isInEnum = true; + } + + if (isCStyle() + && findKeyword(currentLine, charNum, AS_THROW) + && previousCommandChar != ')' + && !foundPreCommandHeader) // 'const' throw() + isImmediatelyPostThrow = true; + + if (isCStyle() && findKeyword(currentLine, charNum, AS_EXTERN) && isExternC()) + isInExternC = true; + + if (isCStyle() && findKeyword(currentLine, charNum, AS_AUTO) + && (isBraceType(braceTypeStack->back(), NULL_TYPE) + || isBraceType(braceTypeStack->back(), NAMESPACE_TYPE) + || isBraceType(braceTypeStack->back(), CLASS_TYPE))) + foundTrailingReturnType = true; + + // Objective-C NSException macros are preCommandHeaders + if (isCStyle() && findKeyword(currentLine, charNum, AS_NS_DURING)) + foundPreCommandMacro = true; + if (isCStyle() && findKeyword(currentLine, charNum, AS_NS_HANDLER)) + foundPreCommandMacro = true; + + if (isCStyle() && isExecSQL(currentLine, charNum)) + isInExecSQL = true; + + if (isCStyle()) + { + if (findKeyword(currentLine, charNum, AS_ASM) + || findKeyword(currentLine, charNum, AS__ASM__)) + { + isInAsm = true; + } + else if (findKeyword(currentLine, charNum, AS_MS_ASM) // microsoft specific + || findKeyword(currentLine, charNum, AS_MS__ASM)) + { + int index = 4; + if (peekNextChar() == '_') // check for __asm + index = 5; + + char peekedChar = ASBase::peekNextChar(currentLine, charNum + index); + if (peekedChar == '{' || peekedChar == ' ') + isInAsmBlock = true; + else + isInAsmOneLine = true; + } + } + + if (isJavaStyle() + && (findKeyword(currentLine, charNum, AS_STATIC) + && isNextCharOpeningBrace(charNum + 6))) + isJavaStaticConstructor = true; + + if (isSharpStyle() + && (findKeyword(currentLine, charNum, AS_DELEGATE) + || findKeyword(currentLine, charNum, AS_UNCHECKED))) + isSharpDelegate = true; + + // append the entire name + string name = getCurrentWord(currentLine, charNum); + // must pad the 'and' and 'or' operators if required + if (name == "and" || name == "or") + { + if (shouldPadOperators && previousNonWSChar != ':') + { + appendSpacePad(); + appendOperator(name); + goForward(name.length() - 1); + if (!isBeforeAnyComment() + && !(currentLine.compare(charNum + 1, 1, AS_SEMICOLON) == 0) + && !(currentLine.compare(charNum + 1, 2, AS_SCOPE_RESOLUTION) == 0)) + appendSpaceAfter(); + } + else + { + appendOperator(name); + goForward(name.length() - 1); + } + } + else + { + appendSequence(name); + goForward(name.length() - 1); + } + + continue; + + } // (isPotentialHeader && !isInTemplate) + + // determine if this is an Objective-C statement + + if (currentChar == '@' + && isCharPotentialHeader(currentLine, charNum + 1) + && findKeyword(currentLine, charNum + 1, AS_INTERFACE) + && isBraceType(braceTypeStack->back(), NULL_TYPE)) + { + isInObjCInterface = true; + string name = '@' + AS_INTERFACE; + appendSequence(name); + goForward(name.length() - 1); + continue; + } + else if (currentChar == '@' + && isCharPotentialHeader(currentLine, charNum + 1) + && findKeyword(currentLine, charNum + 1, AS_SELECTOR)) + { + isInObjCSelector = true; + string name = '@' + AS_SELECTOR; + appendSequence(name); + goForward(name.length() - 1); + continue; + } + else if ((currentChar == '-' || currentChar == '+') + && (int) currentLine.find_first_not_of(" \t") == charNum + && peekNextChar() == '(' + && isBraceType(braceTypeStack->back(), NULL_TYPE) + && !isInPotentialCalculation) + { + isInObjCMethodDefinition = true; + isImmediatelyPostObjCMethodPrefix = true; + isInObjCInterface = false; + if (getAlignMethodColon()) + objCColonAlign = findObjCColonAlignment(); + appendCurrentChar(); + continue; + } + + // determine if this is a potential calculation + + bool isPotentialOperator = isCharPotentialOperator(currentChar); + newHeader = nullptr; + + if (isPotentialOperator) + { + newHeader = findOperator(operators); + + // check for Java ? wildcard + if (newHeader != nullptr + && newHeader == &AS_GCC_MIN_ASSIGN + && isJavaStyle() + && isInTemplate) + newHeader = nullptr; + + if (newHeader != nullptr) + { + if (newHeader == &AS_LAMBDA) + foundPreCommandHeader = true; + + // correct mistake of two >> closing a template + if (isInTemplate && (newHeader == &AS_GR_GR || newHeader == &AS_GR_GR_GR)) + newHeader = &AS_GR; + + if (!isInPotentialCalculation) + { + // must determine if newHeader is an assignment operator + // do NOT use findOperator - the length must be exact!!! + if (find(begin(*assignmentOperators), end(*assignmentOperators), newHeader) + != end(*assignmentOperators)) + { + foundPreCommandHeader = false; + char peekedChar = peekNextChar(); + isInPotentialCalculation = !(newHeader == &AS_EQUAL && peekedChar == '*') + && !(newHeader == &AS_EQUAL && peekedChar == '&') + && !isCharImmediatelyPostOperator; + } + } + } + } + + // process pointers and references + // check newHeader to eliminate things like '&&' sequence + if (newHeader != nullptr && !isJavaStyle() + && (newHeader == &AS_MULT + || newHeader == &AS_BIT_AND + || newHeader == &AS_BIT_XOR + || newHeader == &AS_AND) + && isPointerOrReference()) + { + if (!isDereferenceOrAddressOf() && !isOperatorPaddingDisabled()) + formatPointerOrReference(); + else + { + appendOperator(*newHeader); + goForward(newHeader->length() - 1); + } + isImmediatelyPostPointerOrReference = true; + continue; + } + + if (shouldPadOperators && newHeader != nullptr && !isOperatorPaddingDisabled()) + { + padOperators(newHeader); + continue; + } + + // remove spaces before commas + if (currentChar == ',') + { + const size_t len = formattedLine.length(); + size_t lastText = formattedLine.find_last_not_of(' '); + if (lastText != string::npos && lastText < len - 1) + { + formattedLine.resize(lastText + 1); + int size_diff = len - (lastText + 1); + spacePadNum -= size_diff; + } + } + + // pad commas and semi-colons + if (currentChar == ';' + || (currentChar == ',' && (shouldPadOperators || shouldPadCommas))) + { + char nextChar = ' '; + if (charNum + 1 < (int) currentLine.length()) + nextChar = currentLine[charNum + 1]; + if (!isWhiteSpace(nextChar) + && nextChar != '}' + && nextChar != ')' + && nextChar != ']' + && nextChar != '>' + && nextChar != ';' + && !isBeforeAnyComment() + /* && !(isBraceType(braceTypeStack->back(), ARRAY_TYPE)) */ + ) + { + appendCurrentChar(); + appendSpaceAfter(); + continue; + } + } + + // pad parens + if (currentChar == '(' || currentChar == ')') + { + if (currentChar == '(') + { + if (shouldPadHeader + && (isCharImmediatelyPostReturn + || isCharImmediatelyPostThrow + || isCharImmediatelyPostNewDelete)) + appendSpacePad(); + } + + if (shouldPadParensOutside || shouldPadParensInside || shouldUnPadParens || shouldPadFirstParen) + padParens(); + else + appendCurrentChar(); + + if (isInObjCMethodDefinition) + { + if (currentChar == '(' && isImmediatelyPostObjCMethodPrefix) + { + if (shouldPadMethodPrefix || shouldUnPadMethodPrefix) + padObjCMethodPrefix(); + isImmediatelyPostObjCMethodPrefix = false; + isInObjCReturnType = true; + } + else if (currentChar == ')' && isInObjCReturnType) + { + if (shouldPadReturnType || shouldUnPadReturnType) + padObjCReturnType(); + isInObjCReturnType = false; + } + else if (shouldPadParamType || shouldUnPadParamType) + padObjCParamType(); + } + continue; + } + + // bypass the entire operator + if (newHeader != nullptr) + { + appendOperator(*newHeader); + goForward(newHeader->length() - 1); + continue; + } + + appendCurrentChar(); + + } // end of while loop * end of while loop * end of while loop * end of while loop + + // return a beautified (i.e. correctly indented) line. + + string beautifiedLine; + size_t readyFormattedLineLength = trim(readyFormattedLine).length(); + bool isInNamespace = isBraceType(braceTypeStack->back(), NAMESPACE_TYPE); + + if (prependEmptyLine // prepend a blank line before this formatted line + && readyFormattedLineLength > 0 + && previousReadyFormattedLineLength > 0) + { + isLineReady = true; // signal a waiting readyFormattedLine + beautifiedLine = beautify(""); + previousReadyFormattedLineLength = 0; + // call the enhancer for new empty lines + enhancer->enhance(beautifiedLine, isInNamespace, isInPreprocessorBeautify, isInBeautifySQL); + } + else // format the current formatted line + { + isLineReady = false; + runInIndentContinuation = runInIndentChars; + beautifiedLine = beautify(readyFormattedLine); + previousReadyFormattedLineLength = readyFormattedLineLength; + // the enhancer is not called for no-indent line comments + if (!lineCommentNoBeautify && !isFormattingModeOff) + enhancer->enhance(beautifiedLine, isInNamespace, isInPreprocessorBeautify, isInBeautifySQL); + runInIndentChars = 0; + lineCommentNoBeautify = lineCommentNoIndent; + lineCommentNoIndent = false; + isInIndentablePreproc = isIndentableProprocessor; + isIndentableProprocessor = false; + isElseHeaderIndent = elseHeaderFollowsComments; + isCaseHeaderCommentIndent = caseHeaderFollowsComments; + objCColonAlignSubsequent = objCColonAlign; + if (isCharImmediatelyPostNonInStmt) + { + isNonInStatementArray = false; + isCharImmediatelyPostNonInStmt = false; + } + isInPreprocessorBeautify = isInPreprocessor; // used by ASEnhancer + isInBeautifySQL = isInExecSQL; // used by ASEnhancer + } + + prependEmptyLine = false; + assert(computeChecksumOut(beautifiedLine)); + return beautifiedLine; +} + +/** + * check if there are any indented lines ready to be read by nextLine() + * + * @return are there any indented lines ready? + */ +bool ASFormatter::hasMoreLines() const +{ + return !endOfCodeReached; +} + +/** + * comparison function for BraceType enum + */ +bool ASFormatter::isBraceType(BraceType a, BraceType b) const +{ + if (a == NULL_TYPE || b == NULL_TYPE) + return (a == b); + return ((a & b) == b); +} + +/** + * set the formatting style. + * + * @param style the formatting style. + */ +void ASFormatter::setFormattingStyle(FormatStyle style) +{ + formattingStyle = style; +} + +/** + * set the add braces mode. + * options: + * true braces added to headers for single line statements. + * false braces NOT added to headers for single line statements. + * + * @param state the add braces state. + */ +void ASFormatter::setAddBracesMode(bool state) +{ + shouldAddBraces = state; +} + +/** + * set the add one line braces mode. + * options: + * true one line braces added to headers for single line statements. + * false one line braces NOT added to headers for single line statements. + * + * @param state the add one line braces state. + */ +void ASFormatter::setAddOneLineBracesMode(bool state) +{ + shouldAddBraces = state; + shouldAddOneLineBraces = state; +} + +/** + * set the remove braces mode. + * options: + * true braces removed from headers for single line statements. + * false braces NOT removed from headers for single line statements. + * + * @param state the remove braces state. + */ +void ASFormatter::setRemoveBracesMode(bool state) +{ + shouldRemoveBraces = state; +} + +// retained for compatability with release 2.06 +// "Brackets" have been changed to "Braces" in 3.0 +// it is referenced only by the old "bracket" options +void ASFormatter::setAddBracketsMode(bool state) +{ + setAddBracesMode(state); +} + +// retained for compatability with release 2.06 +// "Brackets" have been changed to "Braces" in 3.0 +// it is referenced only by the old "bracket" options +void ASFormatter::setAddOneLineBracketsMode(bool state) +{ + setAddOneLineBracesMode(state); +} + +// retained for compatability with release 2.06 +// "Brackets" have been changed to "Braces" in 3.0 +// it is referenced only by the old "bracket" options +void ASFormatter::setRemoveBracketsMode(bool state) +{ + setRemoveBracesMode(state); +} + +// retained for compatability with release 2.06 +// "Brackets" have been changed to "Braces" in 3.0 +// it is referenced only by the old "bracket" options +void ASFormatter::setBreakClosingHeaderBracketsMode(bool state) +{ + setBreakClosingHeaderBracesMode(state); +} + + +/** + * set the brace formatting mode. + * options: + * + * @param mode the brace formatting mode. + */ +void ASFormatter::setBraceFormatMode(BraceMode mode) +{ + braceFormatMode = mode; +} + +/** + * set 'break after' mode for maximum code length + * + * @param state the 'break after' mode. + */ +void ASFormatter::setBreakAfterMode(bool state) +{ + shouldBreakLineAfterLogical = state; +} + +/** + * set closing header brace breaking mode + * options: + * true braces just before closing headers (e.g. 'else', 'catch') + * will be broken, even if standard braces are attached. + * false closing header braces will be treated as standard braces. + * + * @param state the closing header brace breaking mode. + */ +void ASFormatter::setBreakClosingHeaderBracesMode(bool state) +{ + shouldBreakClosingHeaderBraces = state; +} + +/** + * set 'else if()' breaking mode + * options: + * true 'else' headers will be broken from their succeeding 'if' headers. + * false 'else' headers will be attached to their succeeding 'if' headers. + * + * @param state the 'else if()' breaking mode. + */ +void ASFormatter::setBreakElseIfsMode(bool state) +{ + shouldBreakElseIfs = state; +} + +/** +* set comma padding mode. +* options: +* true statement commas and semicolons will be padded with spaces around them. +* false statement commas and semicolons will not be padded. +* +* @param state the padding mode. +*/ +void ASFormatter::setCommaPaddingMode(bool state) +{ + shouldPadCommas = state; +} + +/** + * set maximum code length + * + * @param max the maximum code length. + */ +void ASFormatter::setMaxCodeLength(int max) +{ + maxCodeLength = max; +} + +/** + * set operator padding mode. + * options: + * true statement operators will be padded with spaces around them. + * false statement operators will not be padded. + * + * @param state the padding mode. + */ +void ASFormatter::setOperatorPaddingMode(bool state) +{ + shouldPadOperators = state; +} + +/** + * set parenthesis outside padding mode. + * options: + * true statement parentheses will be padded with spaces around them. + * false statement parentheses will not be padded. + * + * @param state the padding mode. + */ +void ASFormatter::setParensOutsidePaddingMode(bool state) +{ + shouldPadParensOutside = state; +} + +/** + * set parenthesis inside padding mode. + * options: + * true statement parenthesis will be padded with spaces around them. + * false statement parenthesis will not be padded. + * + * @param state the padding mode. + */ +void ASFormatter::setParensInsidePaddingMode(bool state) +{ + shouldPadParensInside = state; +} + +/** + * set padding mode before one or more open parentheses. + * options: + * true first open parenthesis will be padded with a space before. + * false first open parenthesis will not be padded. + * + * @param state the padding mode. + */ +void ASFormatter::setParensFirstPaddingMode(bool state) +{ + shouldPadFirstParen = state; +} + +/** + * set header padding mode. + * options: + * true headers will be padded with spaces around them. + * false headers will not be padded. + * + * @param state the padding mode. + */ +void ASFormatter::setParensHeaderPaddingMode(bool state) +{ + shouldPadHeader = state; +} + +/** + * set parenthesis unpadding mode. + * options: + * true statement parenthesis will be unpadded with spaces removed around them. + * false statement parenthesis will not be unpadded. + * + * @param state the padding mode. + */ +void ASFormatter::setParensUnPaddingMode(bool state) +{ + shouldUnPadParens = state; +} + +/** +* set the state of the preprocessor indentation option. +* If true, #ifdef blocks at level 0 will be indented. +* +* @param state state of option. +*/ +void ASFormatter::setPreprocBlockIndent(bool state) +{ + shouldIndentPreprocBlock = state; +} + +/** + * Set strip comment prefix mode. + * options: + * true strip leading '*' in a comment. + * false leading '*' in a comment will be left unchanged. + * + * @param state the strip comment prefix mode. + */ +void ASFormatter::setStripCommentPrefix(bool state) +{ + shouldStripCommentPrefix = state; +} + +/** + * set objective-c '-' or '+' class prefix padding mode. + * options: + * true class prefix will be padded a spaces after them. + * false class prefix will be left unchanged. + * + * @param state the padding mode. + */ +void ASFormatter::setMethodPrefixPaddingMode(bool state) +{ + shouldPadMethodPrefix = state; +} + +/** + * set objective-c '-' or '+' class prefix unpadding mode. + * options: + * true class prefix will be unpadded with spaces after them removed. + * false class prefix will left unchanged. + * + * @param state the unpadding mode. + */ +void ASFormatter::setMethodPrefixUnPaddingMode(bool state) +{ + shouldUnPadMethodPrefix = state; +} + +// set objective-c '-' or '+' return type padding mode. +void ASFormatter::setReturnTypePaddingMode(bool state) +{ + shouldPadReturnType = state; +} + +// set objective-c '-' or '+' return type unpadding mode. +void ASFormatter::setReturnTypeUnPaddingMode(bool state) +{ + shouldUnPadReturnType = state; +} + +// set objective-c method parameter type padding mode. +void ASFormatter::setParamTypePaddingMode(bool state) +{ + shouldPadParamType = state; +} + +// set objective-c method parameter type unpadding mode. +void ASFormatter::setParamTypeUnPaddingMode(bool state) +{ + shouldUnPadParamType = state; +} + +/** + * set objective-c method colon padding mode. + * + * @param mode objective-c colon padding mode. + */ +void ASFormatter::setObjCColonPaddingMode(ObjCColonPad mode) +{ + shouldPadMethodColon = true; + objCColonPadMode = mode; +} + +/** + * set option to attach closing braces + * + * @param state true = attach, false = don't attach. + */ +void ASFormatter::setAttachClosingBraceMode(bool state) +{ + attachClosingBraceMode = state; +} + +/** + * set option to attach class braces + * + * @param state true = attach, false = use style default. + */ +void ASFormatter::setAttachClass(bool state) +{ + shouldAttachClass = state; +} + +/** + * set option to attach extern "C" braces + * + * @param state true = attach, false = use style default. + */ +void ASFormatter::setAttachExternC(bool state) +{ + shouldAttachExternC = state; +} + +/** + * set option to attach namespace braces + * + * @param state true = attach, false = use style default. + */ +void ASFormatter::setAttachNamespace(bool state) +{ + shouldAttachNamespace = state; +} + +/** + * set option to attach inline braces + * + * @param state true = attach, false = use style default. + */ +void ASFormatter::setAttachInline(bool state) +{ + shouldAttachInline = state; +} + +void ASFormatter::setAttachClosingWhile(bool state) +{ + shouldAttachClosingWhile = state; +} + +/** + * set option to break/not break one-line blocks + * + * @param state true = break, false = don't break. + */ +void ASFormatter::setBreakOneLineBlocksMode(bool state) +{ + shouldBreakOneLineBlocks = state; +} + +/** +* set one line headers breaking mode +*/ +void ASFormatter::setBreakOneLineHeadersMode(bool state) +{ + shouldBreakOneLineHeaders = state; +} + +/** +* set option to break/not break lines consisting of multiple statements. +* +* @param state true = break, false = don't break. +*/ +void ASFormatter::setBreakOneLineStatementsMode(bool state) +{ + shouldBreakOneLineStatements = state; +} + +void ASFormatter::setCloseTemplatesMode(bool state) +{ + shouldCloseTemplates = state; +} + +/** + * set option to convert tabs to spaces. + * + * @param state true = convert, false = don't convert. + */ +void ASFormatter::setTabSpaceConversionMode(bool state) +{ + shouldConvertTabs = state; +} + +/** + * set option to indent comments in column 1. + * + * @param state true = indent, false = don't indent. + */ +void ASFormatter::setIndentCol1CommentsMode(bool state) +{ + shouldIndentCol1Comments = state; +} + +/** + * set option to force all line ends to a particular style. + * + * @param fmt format enum value + */ +void ASFormatter::setLineEndFormat(LineEndFormat fmt) +{ + lineEnd = fmt; +} + +/** + * set option to break unrelated blocks of code with empty lines. + * + * @param state true = convert, false = don't convert. + */ +void ASFormatter::setBreakBlocksMode(bool state) +{ + shouldBreakBlocks = state; +} + +/** + * set option to break closing header blocks of code (such as 'else', 'catch', ...) with empty lines. + * + * @param state true = convert, false = don't convert. + */ +void ASFormatter::setBreakClosingHeaderBlocksMode(bool state) +{ + shouldBreakClosingHeaderBlocks = state; +} + +/** + * set option to delete empty lines. + * + * @param state true = delete, false = don't delete. + */ +void ASFormatter::setDeleteEmptyLinesMode(bool state) +{ + shouldDeleteEmptyLines = state; +} + +/** + * set the pointer alignment. + * + * @param alignment the pointer alignment. + */ +void ASFormatter::setPointerAlignment(PointerAlign alignment) +{ + pointerAlignment = alignment; +} + +void ASFormatter::setReferenceAlignment(ReferenceAlign alignment) +{ + referenceAlignment = alignment; +} + +/** + * jump over several characters. + * + * @param i the number of characters to jump over. + */ +void ASFormatter::goForward(int i) +{ + while (--i >= 0) + getNextChar(); +} + +/** + * peek at the next unread character. + * + * @return the next unread character. + */ +char ASFormatter::peekNextChar() const +{ + char ch = ' '; + size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1); + + if (peekNum == string::npos) + return ch; + + ch = currentLine[peekNum]; + + return ch; +} + +/** + * check if current placement is before a comment + * + * @return is before a comment. + */ +bool ASFormatter::isBeforeComment() const +{ + bool foundComment = false; + size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1); + + if (peekNum == string::npos) + return foundComment; + + foundComment = (currentLine.compare(peekNum, 2, "/*") == 0); + + return foundComment; +} + +/** + * check if current placement is before a comment or line-comment + * + * @return is before a comment or line-comment. + */ +bool ASFormatter::isBeforeAnyComment() const +{ + bool foundComment = false; + size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1); + + if (peekNum == string::npos) + return foundComment; + + foundComment = (currentLine.compare(peekNum, 2, "/*") == 0 + || currentLine.compare(peekNum, 2, "//") == 0); + + return foundComment; +} + +/** + * check if current placement is before a comment or line-comment + * if a block comment it must be at the end of the line + * + * @return is before a comment or line-comment. + */ +bool ASFormatter::isBeforeAnyLineEndComment(int startPos) const +{ + bool foundLineEndComment = false; + size_t peekNum = currentLine.find_first_not_of(" \t", startPos + 1); + + if (peekNum != string::npos) + { + if (currentLine.compare(peekNum, 2, "//") == 0) + foundLineEndComment = true; + else if (currentLine.compare(peekNum, 2, "/*") == 0) + { + // comment must be closed on this line with nothing after it + size_t endNum = currentLine.find("*/", peekNum + 2); + if (endNum != string::npos) + { + size_t nextChar = currentLine.find_first_not_of(" \t", endNum + 2); + if (nextChar == string::npos) + foundLineEndComment = true; + } + } + } + return foundLineEndComment; +} + +/** + * check if current placement is before a comment followed by a line-comment + * + * @return is before a multiple line-end comment. + */ +bool ASFormatter::isBeforeMultipleLineEndComments(int startPos) const +{ + bool foundMultipleLineEndComment = false; + size_t peekNum = currentLine.find_first_not_of(" \t", startPos + 1); + + if (peekNum != string::npos) + { + if (currentLine.compare(peekNum, 2, "/*") == 0) + { + // comment must be closed on this line with nothing after it + size_t endNum = currentLine.find("*/", peekNum + 2); + if (endNum != string::npos) + { + size_t nextChar = currentLine.find_first_not_of(" \t", endNum + 2); + if (nextChar != string::npos + && currentLine.compare(nextChar, 2, "//") == 0) + foundMultipleLineEndComment = true; + } + } + } + return foundMultipleLineEndComment; +} + +/** + * get the next character, increasing the current placement in the process. + * the new character is inserted into the variable currentChar. + * + * @return whether succeeded to receive the new character. + */ +bool ASFormatter::getNextChar() +{ + isInLineBreak = false; + previousChar = currentChar; + + if (!isWhiteSpace(currentChar)) + { + previousNonWSChar = currentChar; + if (!isInComment && !isInLineComment && !isInQuote + && !isImmediatelyPostComment + && !isImmediatelyPostLineComment + && !isInPreprocessor + && !isSequenceReached("/*") + && !isSequenceReached("//")) + previousCommandChar = currentChar; + } + + if (charNum + 1 < (int) currentLine.length() + && (!isWhiteSpace(peekNextChar()) || isInComment || isInLineComment)) + { + currentChar = currentLine[++charNum]; + + if (currentChar == '\t' && shouldConvertTabs) + convertTabToSpaces(); + + return true; + } + + // end of line has been reached + return getNextLine(); +} + +/** + * get the next line of input, increasing the current placement in the process. + * + * @param emptyLineWasDeleted an empty line was deleted. + * @return whether succeeded in reading the next line. + */ +bool ASFormatter::getNextLine(bool emptyLineWasDeleted /*false*/) +{ + if (!sourceIterator->hasMoreLines()) + { + endOfCodeReached = true; + return false; + } + if (appendOpeningBrace) + currentLine = "{"; // append brace that was removed from the previous line + else + { + currentLine = sourceIterator->nextLine(emptyLineWasDeleted); + assert(computeChecksumIn(currentLine)); + } + // reset variables for new line + inLineNumber++; + if (endOfAsmReached) + endOfAsmReached = isInAsmBlock = isInAsm = false; + shouldKeepLineUnbroken = false; + isInCommentStartLine = false; + isInCase = false; + isInAsmOneLine = false; + isHeaderInMultiStatementLine = false; + isInQuoteContinuation = isInVerbatimQuote || haveLineContinuationChar; + haveLineContinuationChar = false; + isImmediatelyPostEmptyLine = lineIsEmpty; + previousChar = ' '; + + if (currentLine.length() == 0) + currentLine = string(" "); // a null is inserted if this is not done + + // unless reading in the first line of the file, break a new line. + if (!isVirgin) + isInLineBreak = true; + else + isVirgin = false; + + if (isImmediatelyPostNonInStmt) + { + isCharImmediatelyPostNonInStmt = true; + isImmediatelyPostNonInStmt = false; + } + + // check if is in preprocessor before line trimming + // a blank line after a \ will remove the flag + isImmediatelyPostPreprocessor = isInPreprocessor; + if (!isInComment + && (previousNonWSChar != '\\' + || isEmptyLine(currentLine))) + isInPreprocessor = false; + + if (passedSemicolon) + isInExecSQL = false; + initNewLine(); + + currentChar = currentLine[charNum]; + if (isInBraceRunIn && previousNonWSChar == '{' && !isInComment) + isInLineBreak = false; + isInBraceRunIn = false; + + if (currentChar == '\t' && shouldConvertTabs) + convertTabToSpaces(); + + // check for an empty line inside a command brace. + // if yes then read the next line (calls getNextLine recursively). + // must be after initNewLine. + if (shouldDeleteEmptyLines + && lineIsEmpty + && isBraceType((*braceTypeStack)[braceTypeStack->size() - 1], COMMAND_TYPE)) + { + if (!shouldBreakBlocks || previousNonWSChar == '{' || !commentAndHeaderFollows()) + { + isInPreprocessor = isImmediatelyPostPreprocessor; // restore + lineIsEmpty = false; + return getNextLine(true); + } + } + return true; +} + +/** + * jump over the leading white space in the current line, + * IF the line does not begin a comment or is in a preprocessor definition. + */ +void ASFormatter::initNewLine() +{ + size_t len = currentLine.length(); + size_t tabSize = getTabLength(); + charNum = 0; + + // don't trim these + if (isInQuoteContinuation + || (isInPreprocessor && !getPreprocDefineIndent())) + return; + + // SQL continuation lines must be adjusted so the leading spaces + // is equivalent to the opening EXEC SQL + if (isInExecSQL) + { + // replace leading tabs with spaces + // so that continuation indent will be spaces + size_t tabCount_ = 0; + size_t i; + for (i = 0; i < currentLine.length(); i++) + { + if (!isWhiteSpace(currentLine[i])) // stop at first text + break; + if (currentLine[i] == '\t') + { + size_t numSpaces = tabSize - ((tabCount_ + i) % tabSize); + currentLine.replace(i, 1, numSpaces, ' '); + tabCount_++; + i += tabSize - 1; + } + } + // this will correct the format if EXEC SQL is not a hanging indent + trimContinuationLine(); + return; + } + + // comment continuation lines must be adjusted so the leading spaces + // is equivalent to the opening comment + if (isInComment) + { + if (noTrimCommentContinuation) + leadingSpaces = tabIncrementIn = 0; + trimContinuationLine(); + return; + } + + // compute leading spaces + isImmediatelyPostCommentOnly = lineIsLineCommentOnly || lineEndsInCommentOnly; + lineIsCommentOnly = false; + lineIsLineCommentOnly = false; + lineEndsInCommentOnly = false; + doesLineStartComment = false; + currentLineBeginsWithBrace = false; + lineIsEmpty = false; + currentLineFirstBraceNum = string::npos; + tabIncrementIn = 0; + + // bypass whitespace at the start of a line + // preprocessor tabs are replaced later in the program + for (charNum = 0; isWhiteSpace(currentLine[charNum]) && charNum + 1 < (int) len; charNum++) + { + if (currentLine[charNum] == '\t' && !isInPreprocessor) + tabIncrementIn += tabSize - 1 - ((tabIncrementIn + charNum) % tabSize); + } + leadingSpaces = charNum + tabIncrementIn; + + if (isSequenceReached("/*")) + { + doesLineStartComment = true; + if ((int) currentLine.length() > charNum + 2 + && currentLine.find("*/", charNum + 2) != string::npos) + lineIsCommentOnly = true; + } + else if (isSequenceReached("//")) + { + lineIsLineCommentOnly = true; + } + else if (isSequenceReached("{")) + { + currentLineBeginsWithBrace = true; + currentLineFirstBraceNum = charNum; + size_t firstText = currentLine.find_first_not_of(" \t", charNum + 1); + if (firstText != string::npos) + { + if (currentLine.compare(firstText, 2, "//") == 0) + lineIsLineCommentOnly = true; + else if (currentLine.compare(firstText, 2, "/*") == 0 + || isExecSQL(currentLine, firstText)) + { + // get the extra adjustment + size_t j; + for (j = charNum + 1; j < firstText && isWhiteSpace(currentLine[j]); j++) + { + if (currentLine[j] == '\t') + tabIncrementIn += tabSize - 1 - ((tabIncrementIn + j) % tabSize); + } + leadingSpaces = j + tabIncrementIn; + if (currentLine.compare(firstText, 2, "/*") == 0) + doesLineStartComment = true; + } + } + } + else if (isWhiteSpace(currentLine[charNum]) && !(charNum + 1 < (int) currentLine.length())) + { + lineIsEmpty = true; + } + + // do not trim indented preprocessor define (except for comment continuation lines) + if (isInPreprocessor) + { + if (!doesLineStartComment) + leadingSpaces = 0; + charNum = 0; + } +} + +/** + * Append a character to the current formatted line. + * The formattedLine split points are updated. + * + * @param ch the character to append. + * @param canBreakLine if true, a registered line-break + */ +void ASFormatter::appendChar(char ch, bool canBreakLine) +{ + if (canBreakLine && isInLineBreak) + breakLine(); + + formattedLine.append(1, ch); + isImmediatelyPostCommentOnly = false; + if (maxCodeLength != string::npos) + { + // These compares reduce the frequency of function calls. + if (isOkToSplitFormattedLine()) + updateFormattedLineSplitPoints(ch); + if (formattedLine.length() > maxCodeLength) + testForTimeToSplitFormattedLine(); + } +} + +/** + * Append a string sequence to the current formatted line. + * The formattedLine split points are NOT updated. + * But the formattedLine is checked for time to split. + * + * @param sequence the sequence to append. + * @param canBreakLine if true, a registered line-break + */ +void ASFormatter::appendSequence(const string& sequence, bool canBreakLine) +{ + if (canBreakLine && isInLineBreak) + breakLine(); + formattedLine.append(sequence); + if (formattedLine.length() > maxCodeLength) + testForTimeToSplitFormattedLine(); +} + +/** + * Append an operator sequence to the current formatted line. + * The formattedLine split points are updated. + * + * @param sequence the sequence to append. + * @param canBreakLine if true, a registered line-break + */ +void ASFormatter::appendOperator(const string& sequence, bool canBreakLine) +{ + if (canBreakLine && isInLineBreak) + breakLine(); + formattedLine.append(sequence); + if (maxCodeLength != string::npos) + { + // These compares reduce the frequency of function calls. + if (isOkToSplitFormattedLine()) + updateFormattedLineSplitPointsOperator(sequence); + if (formattedLine.length() > maxCodeLength) + testForTimeToSplitFormattedLine(); + } +} + +/** + * append a space to the current formattedline, UNLESS the + * last character is already a white-space character. + */ +void ASFormatter::appendSpacePad() +{ + int len = formattedLine.length(); + if (len > 0 && !isWhiteSpace(formattedLine[len - 1])) + { + formattedLine.append(1, ' '); + spacePadNum++; + if (maxCodeLength != string::npos) + { + // These compares reduce the frequency of function calls. + if (isOkToSplitFormattedLine()) + updateFormattedLineSplitPoints(' '); + if (formattedLine.length() > maxCodeLength) + testForTimeToSplitFormattedLine(); + } + } +} + +/** + * append a space to the current formattedline, UNLESS the + * next character is already a white-space character. + */ +void ASFormatter::appendSpaceAfter() +{ + int len = currentLine.length(); + if (charNum + 1 < len && !isWhiteSpace(currentLine[charNum + 1])) + { + formattedLine.append(1, ' '); + spacePadNum++; + if (maxCodeLength != string::npos) + { + // These compares reduce the frequency of function calls. + if (isOkToSplitFormattedLine()) + updateFormattedLineSplitPoints(' '); + if (formattedLine.length() > maxCodeLength) + testForTimeToSplitFormattedLine(); + } + } +} + +/** + * register a line break for the formatted line. + */ +void ASFormatter::breakLine(bool isSplitLine /*false*/) +{ + isLineReady = true; + isInLineBreak = false; + spacePadNum = nextLineSpacePadNum; + nextLineSpacePadNum = 0; + readyFormattedLine = formattedLine; + formattedLine.erase(); + // queue an empty line prepend request if one exists + prependEmptyLine = isPrependPostBlockEmptyLineRequested; + + if (!isSplitLine) + { + formattedLineCommentNum = string::npos; + clearFormattedLineSplitPoints(); + + if (isAppendPostBlockEmptyLineRequested) + { + isAppendPostBlockEmptyLineRequested = false; + isPrependPostBlockEmptyLineRequested = true; + } + else + isPrependPostBlockEmptyLineRequested = false; + } +} + +/** + * check if the currently reached open-brace (i.e. '{') + * opens a: + * - a definition type block (such as a class or namespace), + * - a command block (such as a method block) + * - a static array + * this method takes for granted that the current character + * is an opening brace. + * + * @return the type of the opened block. + */ +BraceType ASFormatter::getBraceType() +{ + assert(currentChar == '{'); + + BraceType returnVal = NULL_TYPE; + + if ((previousNonWSChar == '=' + || isBraceType(braceTypeStack->back(), ARRAY_TYPE)) + && previousCommandChar != ')' + && !isNonParenHeader) + returnVal = ARRAY_TYPE; + else if (foundPreDefinitionHeader && previousCommandChar != ')') + { + returnVal = DEFINITION_TYPE; + if (foundNamespaceHeader) + returnVal = (BraceType)(returnVal | NAMESPACE_TYPE); + else if (foundClassHeader) + returnVal = (BraceType)(returnVal | CLASS_TYPE); + else if (foundStructHeader) + returnVal = (BraceType)(returnVal | STRUCT_TYPE); + else if (foundInterfaceHeader) + returnVal = (BraceType)(returnVal | INTERFACE_TYPE); + } + else if (isInEnum) + { + returnVal = (BraceType)(ARRAY_TYPE | ENUM_TYPE); + } + else + { + bool isCommandType = (foundPreCommandHeader + || foundPreCommandMacro + || (currentHeader != nullptr && isNonParenHeader) + || (previousCommandChar == ')') + || (previousCommandChar == ':' && !foundQuestionMark) + || (previousCommandChar == ';') + || ((previousCommandChar == '{' || previousCommandChar == '}') + && isPreviousBraceBlockRelated) + || (isInClassInitializer + && (!isLegalNameChar(previousNonWSChar) || foundPreCommandHeader)) + || foundTrailingReturnType + || isInObjCMethodDefinition + || isInObjCInterface + || isJavaStaticConstructor + || isSharpDelegate); + + // C# methods containing 'get', 'set', 'add', and 'remove' do NOT end with parens + if (!isCommandType && isSharpStyle() && isNextWordSharpNonParenHeader(charNum + 1)) + { + isCommandType = true; + isSharpAccessor = true; + } + + if (isInExternC) + returnVal = (isCommandType ? COMMAND_TYPE : EXTERN_TYPE); + else + returnVal = (isCommandType ? COMMAND_TYPE : ARRAY_TYPE); + } + + int foundOneLineBlock = isOneLineBlockReached(currentLine, charNum); + + if (foundOneLineBlock == 2 && returnVal == COMMAND_TYPE) + returnVal = ARRAY_TYPE; + + if (foundOneLineBlock > 0) + { + returnVal = (BraceType) (returnVal | SINGLE_LINE_TYPE); + if (breakCurrentOneLineBlock) + returnVal = (BraceType) (returnVal | BREAK_BLOCK_TYPE); + if (foundOneLineBlock == 3) + returnVal = (BraceType)(returnVal | EMPTY_BLOCK_TYPE); + } + + if (isBraceType(returnVal, ARRAY_TYPE)) + { + if (isNonInStatementArrayBrace()) + { + returnVal = (BraceType)(returnVal | ARRAY_NIS_TYPE); + isNonInStatementArray = true; + isImmediatelyPostNonInStmt = false; // in case of "},{" + nonInStatementBrace = formattedLine.length() - 1; + } + if (isUniformInitializerBrace()) + returnVal = (BraceType)(returnVal | INIT_TYPE); + } + + return returnVal; +} + +/** +* check if a colon is a class initializer separator +* +* @return whether it is a class initializer separator +*/ +bool ASFormatter::isClassInitializer() const +{ + assert(currentChar == ':'); + assert(previousChar != ':' && peekNextChar() != ':'); // not part of '::' + + // this should be similar to ASBeautifier::parseCurrentLine() + bool foundClassInitializer = false; + + if (foundQuestionMark) + { + // do nothing special + } + else if (parenStack->back() > 0) + { + // found a 'for' loop or an objective-C statement + // so do nothing special + } + else if (isInEnum) + { + // found an enum with a base-type + } + else if (isCStyle() + && !isInCase + && (previousCommandChar == ')' || foundPreCommandHeader)) + { + // found a 'class' c'tor initializer + foundClassInitializer = true; + } + return foundClassInitializer; +} + +/** + * check if a line is empty + * + * @return whether line is empty + */ +bool ASFormatter::isEmptyLine(const string& line) const +{ + return line.find_first_not_of(" \t") == string::npos; +} + +/** + * Check if the following text is "C" as in extern "C". + * + * @return whether the statement is extern "C" + */ +bool ASFormatter::isExternC() const +{ + // charNum should be at 'extern' + assert(!isWhiteSpace(currentLine[charNum])); + size_t startQuote = currentLine.find_first_of(" \t\"", charNum); + if (startQuote == string::npos) + return false; + startQuote = currentLine.find_first_not_of(" \t", startQuote); + if (startQuote == string::npos) + return false; + if (currentLine.compare(startQuote, 3, "\"C\"") != 0) + return false; + return true; +} + +/** + * Check if the currently reached '*', '&' or '^' character is + * a pointer-or-reference symbol, or another operator. + * A pointer dereference (*) or an "address of" character (&) + * counts as a pointer or reference because it is not an + * arithmetic operator. + * + * @return whether current character is a reference-or-pointer + */ +bool ASFormatter::isPointerOrReference() const +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + + if (isJavaStyle()) + return false; + + if (isCharImmediatelyPostOperator) + return false; + + // get the last legal word (may be a number) + string lastWord = getPreviousWord(currentLine, charNum); + if (lastWord.empty()) + lastWord = " "; + + // check for preceding or following numeric values + string nextText = peekNextText(currentLine.substr(charNum + 1)); + if (nextText.length() == 0) + nextText = " "; + char nextChar = nextText[0]; + if (isDigit(lastWord[0]) + || isDigit(nextChar) + || nextChar == '!' + || nextChar == '~') + return false; + + // check for multiply then a dereference (a * *b) + if (currentChar == '*' + && charNum < (int) currentLine.length() - 1 + && isWhiteSpace(currentLine[charNum + 1]) + && nextChar == '*') + return false; + + if ((foundCastOperator && nextChar == '>') + || isPointerOrReferenceVariable(lastWord)) + return true; + + if (isInClassInitializer + && previousNonWSChar != '(' + && previousNonWSChar != '{' + && previousCommandChar != ',' + && nextChar != ')' + && nextChar != '}') + return false; + + //check for rvalue reference + if (currentChar == '&' && nextChar == '&') + { + if (previousNonWSChar == '>') + return true; + string followingText; + if ((int) currentLine.length() > charNum + 2) + followingText = peekNextText(currentLine.substr(charNum + 2)); + if (followingText.length() > 0 && followingText[0] == ')') + return true; + if (currentHeader != nullptr || isInPotentialCalculation) + return false; + if (parenStack->back() > 0 && isBraceType(braceTypeStack->back(), COMMAND_TYPE)) + return false; + return true; + } + if (nextChar == '*' + || previousNonWSChar == '=' + || previousNonWSChar == '(' + || previousNonWSChar == '[' + || isCharImmediatelyPostReturn + || isInTemplate + || isCharImmediatelyPostTemplate + || currentHeader == &AS_CATCH + || currentHeader == &AS_FOREACH + || currentHeader == &AS_QFOREACH) + return true; + + if (isBraceType(braceTypeStack->back(), ARRAY_TYPE) + && isLegalNameChar(lastWord[0]) + && isLegalNameChar(nextChar) + && previousNonWSChar != ')') + { + if (isArrayOperator()) + return false; + } + + // checks on operators in parens + if (parenStack->back() > 0 + && isLegalNameChar(lastWord[0]) + && isLegalNameChar(nextChar)) + { + // if followed by an assignment it is a pointer or reference + // if followed by semicolon it is a pointer or reference in range-based for + const string* followingOperator = getFollowingOperator(); + if (followingOperator != nullptr + && followingOperator != &AS_MULT + && followingOperator != &AS_BIT_AND) + { + if (followingOperator == &AS_ASSIGN || followingOperator == &AS_COLON) + return true; + return false; + } + + if (isBraceType(braceTypeStack->back(), COMMAND_TYPE) + || squareBracketCount > 0) + return false; + return true; + } + + // checks on operators in parens with following '(' + if (parenStack->back() > 0 + && nextChar == '(' + && previousNonWSChar != ',' + && previousNonWSChar != '(' + && previousNonWSChar != '!' + && previousNonWSChar != '&' + && previousNonWSChar != '*' + && previousNonWSChar != '|') + return false; + + if (nextChar == '-' + || nextChar == '+') + { + size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextNum != string::npos) + { + if (currentLine.compare(nextNum, 2, "++") != 0 + && currentLine.compare(nextNum, 2, "--") != 0) + return false; + } + } + + bool isPR = (!isInPotentialCalculation + || (!isLegalNameChar(previousNonWSChar) + && !(previousNonWSChar == ')' && nextChar == '(') + && !(previousNonWSChar == ')' && currentChar == '*' && !isImmediatelyPostCast()) + && previousNonWSChar != ']') + || (!isWhiteSpace(nextChar) + && nextChar != '-' + && nextChar != '(' + && nextChar != '[' + && !isLegalNameChar(nextChar)) + ); + + return isPR; +} + +/** + * Check if the currently reached '*' or '&' character is + * a dereferenced pointer or "address of" symbol. + * NOTE: this MUST be a pointer or reference as determined by + * the function isPointerOrReference(). + * + * @return whether current character is a dereference or address of + */ +bool ASFormatter::isDereferenceOrAddressOf() const +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + + if (isCharImmediatelyPostTemplate) + return false; + + if (previousNonWSChar == '=' + || previousNonWSChar == ',' + || previousNonWSChar == '.' + || previousNonWSChar == '{' + || previousNonWSChar == '>' + || previousNonWSChar == '<' + || previousNonWSChar == '?' + || isCharImmediatelyPostLineComment + || isCharImmediatelyPostComment + || isCharImmediatelyPostReturn) + return true; + + char nextChar = peekNextChar(); + if (currentChar == '*' && nextChar == '*') + { + if (previousNonWSChar == '(') + return true; + if ((int) currentLine.length() < charNum + 2) + return true; + return false; + } + if (currentChar == '&' && nextChar == '&') + { + if (previousNonWSChar == '(' || isInTemplate) + return true; + if ((int) currentLine.length() < charNum + 2) + return true; + return false; + } + + // check first char on the line + if (charNum == (int) currentLine.find_first_not_of(" \t") + && (isBraceType(braceTypeStack->back(), COMMAND_TYPE) + || parenStack->back() != 0)) + return true; + + string nextText = peekNextText(currentLine.substr(charNum + 1)); + if (nextText.length() > 0) + { + if (nextText[0] == ')' || nextText[0] == '>' + || nextText[0] == ',' || nextText[0] == '=') + return false; + if (nextText[0] == ';') + return true; + } + + // check for reference to a pointer *& (cannot have &*) + if ((currentChar == '*' && nextChar == '&') + || (previousNonWSChar == '*' && currentChar == '&')) + return false; + + if (!isBraceType(braceTypeStack->back(), COMMAND_TYPE) + && parenStack->back() == 0) + return false; + + string lastWord = getPreviousWord(currentLine, charNum); + if (lastWord == "else" || lastWord == "delete") + return true; + + if (isPointerOrReferenceVariable(lastWord)) + return false; + + bool isDA = (!(isLegalNameChar(previousNonWSChar) || previousNonWSChar == '>') + || (nextText.length() > 0 && !isLegalNameChar(nextText[0]) && nextText[0] != '/') + || (ispunct((unsigned char)previousNonWSChar) && previousNonWSChar != '.') + || isCharImmediatelyPostReturn); + + return isDA; +} + +/** + * Check if the currently reached '*' or '&' character is + * centered with one space on each side. + * Only spaces are checked, not tabs. + * If true then a space will be deleted on the output. + * + * @return whether current character is centered. + */ +bool ASFormatter::isPointerOrReferenceCentered() const +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + + int prNum = charNum; + int lineLength = (int) currentLine.length(); + + // check for end of line + if (peekNextChar() == ' ') + return false; + + // check space before + if (prNum < 1 + || currentLine[prNum - 1] != ' ') + return false; + + // check no space before that + if (prNum < 2 + || currentLine[prNum - 2] == ' ') + return false; + + // check for ** or && + if (prNum + 1 < lineLength + && (currentLine[prNum + 1] == '*' || currentLine[prNum + 1] == '&')) + prNum++; + + // check space after + if (prNum + 1 <= lineLength + && currentLine[prNum + 1] != ' ') + return false; + + // check no space after that + if (prNum + 2 < lineLength + && currentLine[prNum + 2] == ' ') + return false; + + return true; +} + +/** + * Check if a word is a pointer or reference variable type. + * + * @return whether word is a pointer or reference variable. + */ +bool ASFormatter::isPointerOrReferenceVariable(const string& word) const +{ + return (word == "char" + || word == "int" + || word == "void" + || (word.length() >= 6 // check end of word for _t + && word.compare(word.length() - 2, 2, "_t") == 0) + || word == "INT" + || word == "VOID"); +} + +/** + * check if the currently reached '+' or '-' character is a unary operator + * this method takes for granted that the current character + * is a '+' or '-'. + * + * @return whether the current '+' or '-' is a unary operator. + */ +bool ASFormatter::isUnaryOperator() const +{ + assert(currentChar == '+' || currentChar == '-'); + + return ((isCharImmediatelyPostReturn || !isLegalNameChar(previousCommandChar)) + && previousCommandChar != '.' + && previousCommandChar != '\"' + && previousCommandChar != '\'' + && previousCommandChar != ')' + && previousCommandChar != ']'); +} + +/** + * check if the currently reached comment is in a 'switch' statement + * + * @return whether the current '+' or '-' is in an exponent. + */ +bool ASFormatter::isInSwitchStatement() const +{ + assert(isInLineComment || isInComment); + if (!preBraceHeaderStack->empty()) + for (size_t i = 1; i < preBraceHeaderStack->size(); i++) + if (preBraceHeaderStack->at(i) == &AS_SWITCH) + return true; + return false; +} + +/** + * check if the currently reached '+' or '-' character is + * part of an exponent, i.e. 0.2E-5. + * + * @return whether the current '+' or '-' is in an exponent. + */ +bool ASFormatter::isInExponent() const +{ + assert(currentChar == '+' || currentChar == '-'); + + if (charNum >= 2) + { + char prevPrevFormattedChar = currentLine[charNum - 2]; + char prevFormattedChar = currentLine[charNum - 1]; + return ((prevFormattedChar == 'e' || prevFormattedChar == 'E') + && (prevPrevFormattedChar == '.' || isDigit(prevPrevFormattedChar))); + } + return false; +} + +/** + * check if an array brace should NOT have an in-statement indent + * + * @return the array is non in-statement + */ +bool ASFormatter::isNonInStatementArrayBrace() const +{ + bool returnVal = false; + char nextChar = peekNextChar(); + // if this opening brace begins the line there will be no inStatement indent + if (currentLineBeginsWithBrace + && charNum == (int) currentLineFirstBraceNum + && nextChar != '}') + returnVal = true; + // if an opening brace ends the line there will be no inStatement indent + if (isWhiteSpace(nextChar) + || isBeforeAnyLineEndComment(charNum) + || nextChar == '{') + returnVal = true; + + // Java "new Type [] {...}" IS an inStatement indent + if (isJavaStyle() && previousNonWSChar == ']') + returnVal = false; + + return returnVal; +} + +/** + * check if a one-line block has been reached, + * i.e. if the currently reached '{' character is closed + * with a complimentary '}' elsewhere on the current line, + *. + * @return 0 = one-line block has not been reached. + * 1 = one-line block has been reached. + * 2 = one-line block has been reached and is followed by a comma. + * 3 = one-line block has been reached and is an empty block. + */ +int ASFormatter::isOneLineBlockReached(const string& line, int startChar) const +{ + assert(line[startChar] == '{'); + + bool isInComment_ = false; + bool isInQuote_ = false; + bool hasText = false; + int braceCount = 0; + int lineLength = line.length(); + char quoteChar_ = ' '; + char ch = ' '; + char prevCh = ' '; + + for (int i = startChar; i < lineLength; ++i) + { + ch = line[i]; + + if (isInComment_) + { + if (line.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + + if (ch == '\\') + { + ++i; + continue; + } + + if (isInQuote_) + { + if (ch == quoteChar_) + isInQuote_ = false; + continue; + } + + if (ch == '"' + || (ch == '\'' && !isDigitSeparator(line, i))) + { + isInQuote_ = true; + quoteChar_ = ch; + continue; + } + + if (line.compare(i, 2, "//") == 0) + break; + + if (line.compare(i, 2, "/*") == 0) + { + isInComment_ = true; + ++i; + continue; + } + + if (ch == '{') + { + ++braceCount; + continue; + } + if (ch == '}') + { + --braceCount; + if (braceCount == 0) + { + // is this an array? + if (parenStack->back() == 0 && prevCh != '}') + { + size_t peekNum = line.find_first_not_of(" \t", i + 1); + if (peekNum != string::npos && line[peekNum] == ',') + return 2; + } + if (!hasText) + return 3; // is an empty block + return 1; + } + } + if (ch == ';') + continue; + if (!isWhiteSpace(ch)) + { + hasText = true; + prevCh = ch; + } + } + + return 0; +} + +/** + * peek at the next word to determine if it is a C# non-paren header. + * will look ahead in the input file if necessary. + * + * @param startChar position on currentLine to start the search + * @return true if the next word is get or set. + */ +bool ASFormatter::isNextWordSharpNonParenHeader(int startChar) const +{ + // look ahead to find the next non-comment text + string nextText = peekNextText(currentLine.substr(startChar)); + if (nextText.length() == 0) + return false; + if (nextText[0] == '[') + return true; + if (!isCharPotentialHeader(nextText, 0)) + return false; + if (findKeyword(nextText, 0, AS_GET) || findKeyword(nextText, 0, AS_SET) + || findKeyword(nextText, 0, AS_ADD) || findKeyword(nextText, 0, AS_REMOVE)) + return true; + return false; +} + +/** + * peek at the next char to determine if it is an opening brace. + * will look ahead in the input file if necessary. + * this determines a java static constructor. + * + * @param startChar position on currentLine to start the search + * @return true if the next word is an opening brace. + */ +bool ASFormatter::isNextCharOpeningBrace(int startChar) const +{ + bool retVal = false; + string nextText = peekNextText(currentLine.substr(startChar)); + if (nextText.length() > 0 + && nextText.compare(0, 1, "{") == 0) + retVal = true; + return retVal; +} + +/** +* Check if operator and, pointer, and reference padding is disabled. +* Disabling is done thru a NOPAD tag in an ending comment. +* +* @return true if the formatting on this line is disabled. +*/ +bool ASFormatter::isOperatorPaddingDisabled() const +{ + size_t commentStart = currentLine.find("//", charNum); + if (commentStart == string::npos) + { + commentStart = currentLine.find("/*", charNum); + // comment must end on this line + if (commentStart != string::npos) + { + size_t commentEnd = currentLine.find("*/", commentStart + 2); + if (commentEnd == string::npos) + commentStart = string::npos; + } + } + if (commentStart == string::npos) + return false; + size_t noPadStart = currentLine.find("*NOPAD*", commentStart); + if (noPadStart == string::npos) + return false; + return true; +} + +/** +* Determine if an opening array-type brace should have a leading space pad. +* This is to identify C++11 uniform initializers. +*/ +bool ASFormatter::isUniformInitializerBrace() const +{ + if (isCStyle() && !isInEnum && !isImmediatelyPostPreprocessor) + { + if (isInClassInitializer + || isLegalNameChar(previousNonWSChar)) + return true; + } + return false; +} + +/** +* Determine if there is a following statement on the current line. +*/ +bool ASFormatter::isMultiStatementLine() const +{ + assert((isImmediatelyPostHeader || foundClosingHeader)); + bool isInComment_ = false; + bool isInQuote_ = false; + int semiCount_ = 0; + int parenCount_ = 0; + int braceCount_ = 0; + + for (size_t i = 0; i < currentLine.length(); i++) + { + if (isInComment_) + { + if (currentLine.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + continue; + } + } + if (currentLine.compare(i, 2, "/*") == 0) + { + isInComment_ = true; + continue; + } + if (currentLine.compare(i, 2, "//") == 0) + return false; + if (isInQuote_) + { + if (currentLine[i] == '"' || currentLine[i] == '\'') + isInQuote_ = false; + continue; + } + if (currentLine[i] == '"' || currentLine[i] == '\'') + { + isInQuote_ = true; + continue; + } + if (currentLine[i] == '(') + { + ++parenCount_; + continue; + } + if (currentLine[i] == ')') + { + --parenCount_; + continue; + } + if (parenCount_ > 0) + continue; + if (currentLine[i] == '{') + { + ++braceCount_; + } + if (currentLine[i] == '}') + { + --braceCount_; + } + if (braceCount_ > 0) + continue; + if (currentLine[i] == ';') + { + ++semiCount_; + if (semiCount_ > 1) + return true; + continue; + } + } + return false; +} + +/** + * get the next non-whitespace substring on following lines, bypassing all comments. + * + * @param firstLine the first line to check + * @return the next non-whitespace substring. + */ +string ASFormatter::peekNextText(const string& firstLine, + bool endOnEmptyLine /*false*/, + shared_ptr streamArg /*nullptr*/) const +{ + bool isFirstLine = true; + string nextLine_ = firstLine; + size_t firstChar = string::npos; + shared_ptr stream = streamArg; + if (stream == nullptr) // Borland may need == 0 + stream = make_shared(sourceIterator); + + // find the first non-blank text, bypassing all comments. + bool isInComment_ = false; + while (stream->hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + nextLine_ = stream->peekNextLine(); + + firstChar = nextLine_.find_first_not_of(" \t"); + if (firstChar == string::npos) + { + if (endOnEmptyLine && !isInComment_) + break; + continue; + } + + if (nextLine_.compare(firstChar, 2, "/*") == 0) + { + firstChar += 2; + isInComment_ = true; + } + + if (isInComment_) + { + firstChar = nextLine_.find("*/", firstChar); + if (firstChar == string::npos) + continue; + firstChar += 2; + isInComment_ = false; + firstChar = nextLine_.find_first_not_of(" \t", firstChar); + if (firstChar == string::npos) + continue; + } + + if (nextLine_.compare(firstChar, 2, "//") == 0) + continue; + + // found the next text + break; + } + + if (firstChar == string::npos) + nextLine_ = ""; + else + nextLine_ = nextLine_.substr(firstChar); + return nextLine_; +} + +/** + * adjust comment position because of adding or deleting spaces + * the spaces are added or deleted to formattedLine + * spacePadNum contains the adjustment + */ +void ASFormatter::adjustComments() +{ + assert(spacePadNum != 0); + assert(isSequenceReached("//") || isSequenceReached("/*")); + + // block comment must be closed on this line with nothing after it + if (isSequenceReached("/*")) + { + size_t endNum = currentLine.find("*/", charNum + 2); + if (endNum == string::npos) + return; + if (currentLine.find_first_not_of(" \t", endNum + 2) != string::npos) + return; + } + + size_t len = formattedLine.length(); + // don't adjust a tab + if (formattedLine[len - 1] == '\t') + return; + // if spaces were removed, need to add spaces before the comment + if (spacePadNum < 0) + { + int adjust = -spacePadNum; // make the number positive + formattedLine.append(adjust, ' '); + } + // if spaces were added, need to delete extra spaces before the comment + // if cannot be done put the comment one space after the last text + else if (spacePadNum > 0) + { + int adjust = spacePadNum; + size_t lastText = formattedLine.find_last_not_of(' '); + if (lastText != string::npos + && lastText < len - adjust - 1) + formattedLine.resize(len - adjust); + else if (len > lastText + 2) + formattedLine.resize(lastText + 2); + else if (len < lastText + 2) + formattedLine.append(len - lastText, ' '); + } +} + +/** + * append the current brace inside the end of line comments + * currentChar contains the brace, it will be appended to formattedLine + * formattedLineCommentNum is the comment location on formattedLine + */ +void ASFormatter::appendCharInsideComments() +{ + if (formattedLineCommentNum == string::npos // does the comment start on the previous line? + || formattedLineCommentNum == 0) + { + appendCurrentChar(); // don't attach + return; + } + assert(formattedLine.compare(formattedLineCommentNum, 2, "//") == 0 + || formattedLine.compare(formattedLineCommentNum, 2, "/*") == 0); + + // find the previous non space char + size_t end = formattedLineCommentNum; + size_t beg = formattedLine.find_last_not_of(" \t", end - 1); + if (beg == string::npos) + { + appendCurrentChar(); // don't attach + return; + } + beg++; + + // insert the brace + if (end - beg < 3) // is there room to insert? + formattedLine.insert(beg, 3 - end + beg, ' '); + if (formattedLine[beg] == '\t') // don't pad with a tab + formattedLine.insert(beg, 1, ' '); + formattedLine[beg + 1] = currentChar; + testForTimeToSplitFormattedLine(); + + if (isBeforeComment()) + breakLine(); + else if (isCharImmediatelyPostLineComment) + shouldBreakLineAtNextChar = true; +} + +/** + * add or remove space padding to operators + * the operators and necessary padding will be appended to formattedLine + * the calling function should have a continue statement after calling this method + * + * @param newOperator the operator to be padded + */ +void ASFormatter::padOperators(const string* newOperator) +{ + assert(shouldPadOperators); + assert(newOperator != nullptr); + + char nextNonWSChar = ASBase::peekNextChar(currentLine, charNum); + bool shouldPad = (newOperator != &AS_SCOPE_RESOLUTION + && newOperator != &AS_PLUS_PLUS + && newOperator != &AS_MINUS_MINUS + && newOperator != &AS_NOT + && newOperator != &AS_BIT_NOT + && newOperator != &AS_ARROW + && !(newOperator == &AS_COLON && !foundQuestionMark // objC methods + && (isInObjCMethodDefinition || isInObjCInterface + || isInObjCSelector || squareBracketCount != 0)) + && !(newOperator == &AS_MINUS && isInExponent()) + && !(newOperator == &AS_PLUS && isInExponent()) + && !((newOperator == &AS_PLUS || newOperator == &AS_MINUS) // check for unary plus or minus + && (previousNonWSChar == '(' + || previousNonWSChar == '[' + || previousNonWSChar == '=' + || previousNonWSChar == ',' + || previousNonWSChar == ':' + || previousNonWSChar == '{')) +//? // commented out in release 2.05.1 - doesn't seem to do anything??? +//x && !((newOperator == &AS_MULT || newOperator == &AS_BIT_AND || newOperator == &AS_AND) +//x && isPointerOrReference()) + && !(newOperator == &AS_MULT + && (previousNonWSChar == '.' + || previousNonWSChar == '>')) // check for -> + && !(newOperator == &AS_MULT && peekNextChar() == '>') + && !((isInTemplate || isImmediatelyPostTemplate) + && (newOperator == &AS_LS || newOperator == &AS_GR)) + && !(newOperator == &AS_GCC_MIN_ASSIGN + && ASBase::peekNextChar(currentLine, charNum + 1) == '>') + && !(newOperator == &AS_GR && previousNonWSChar == '?') + && !(newOperator == &AS_QUESTION // check for Java wildcard + && isJavaStyle() + && (previousNonWSChar == '<' + || nextNonWSChar == '>' + || nextNonWSChar == '.')) + && !(newOperator == &AS_QUESTION // check for C# null conditional operator + && isSharpStyle() + && (nextNonWSChar == '.' + || nextNonWSChar == '[')) + && !isCharImmediatelyPostOperator + && !isInCase + && !isInAsm + && !isInAsmOneLine + && !isInAsmBlock + ); + + // pad before operator + if (shouldPad + && !(newOperator == &AS_COLON + && (!foundQuestionMark && !isInEnum) && currentHeader != &AS_FOR) + && !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?) + && currentLine.find(':', charNum + 1) == string::npos) + ) + appendSpacePad(); + appendOperator(*newOperator); + goForward(newOperator->length() - 1); + + currentChar = (*newOperator)[newOperator->length() - 1]; + // pad after operator + // but do not pad after a '-' that is a unary-minus. + if (shouldPad + && !isBeforeAnyComment() + && !(newOperator == &AS_PLUS && isUnaryOperator()) + && !(newOperator == &AS_MINUS && isUnaryOperator()) + && !(currentLine.compare(charNum + 1, 1, AS_SEMICOLON) == 0) + && !(currentLine.compare(charNum + 1, 2, AS_SCOPE_RESOLUTION) == 0) + && !(peekNextChar() == ',') + && !(newOperator == &AS_QUESTION && isSharpStyle() // check for C# nullable type (e.g. int?) + && peekNextChar() == '[') + ) + appendSpaceAfter(); +} + +/** + * format pointer or reference + * currentChar contains the pointer or reference + * the symbol and necessary padding will be appended to formattedLine + * the calling function should have a continue statement after calling this method + * + * NOTE: Do NOT use appendCurrentChar() in this method. The line should not be + * broken once the calculation starts. + */ +void ASFormatter::formatPointerOrReference() +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(!isJavaStyle()); + + int pa = pointerAlignment; + int ra = referenceAlignment; + int itemAlignment = (currentChar == '*' || currentChar == '^') ? pa : ((ra == REF_SAME_AS_PTR) ? pa : ra); + + // check for ** and && + int ptrLength = 1; + char peekedChar = peekNextChar(); + if ((currentChar == '*' && peekedChar == '*') + || (currentChar == '&' && peekedChar == '&')) + { + ptrLength = 2; + size_t nextChar = currentLine.find_first_not_of(" \t", charNum + 2); + if (nextChar == string::npos) + peekedChar = ' '; + else + peekedChar = currentLine[nextChar]; + } + // check for cast + if (peekedChar == ')' || peekedChar == '>' || peekedChar == ',') + { + formatPointerOrReferenceCast(); + return; + } + + // check for a padded space and remove it + if (charNum > 0 + && !isWhiteSpace(currentLine[charNum - 1]) + && formattedLine.length() > 0 + && isWhiteSpace(formattedLine[formattedLine.length() - 1])) + { + formattedLine.erase(formattedLine.length() - 1); + spacePadNum--; + } + + if (itemAlignment == PTR_ALIGN_TYPE) + { + formatPointerOrReferenceToType(); + } + else if (itemAlignment == PTR_ALIGN_MIDDLE) + { + formatPointerOrReferenceToMiddle(); + } + else if (itemAlignment == PTR_ALIGN_NAME) + { + formatPointerOrReferenceToName(); + } + else // pointerAlignment == PTR_ALIGN_NONE + { + formattedLine.append(ptrLength, currentChar); + if (ptrLength > 1) + goForward(ptrLength - 1); + } +} + +/** + * format pointer or reference with align to type + */ +void ASFormatter::formatPointerOrReferenceToType() +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(!isJavaStyle()); + + // do this before bumping charNum + bool isOldPRCentered = isPointerOrReferenceCentered(); + + size_t prevCh = formattedLine.find_last_not_of(" \t"); + if (prevCh == string::npos) + prevCh = 0; + if (formattedLine.length() == 0 || prevCh == formattedLine.length() - 1) + formattedLine.append(1, currentChar); + else + { + // exchange * or & with character following the type + // this may not work every time with a tab character + string charSave = formattedLine.substr(prevCh + 1, 1); + formattedLine[prevCh + 1] = currentChar; + formattedLine.append(charSave); + } + if (isSequenceReached("**") || isSequenceReached("&&")) + { + if (formattedLine.length() == 1) + formattedLine.append(1, currentChar); + else + formattedLine.insert(prevCh + 2, 1, currentChar); + goForward(1); + } + // if no space after then add one + if (charNum < (int) currentLine.length() - 1 + && !isWhiteSpace(currentLine[charNum + 1]) + && currentLine[charNum + 1] != ')') + appendSpacePad(); + // if old pointer or reference is centered, remove a space + if (isOldPRCentered + && isWhiteSpace(formattedLine[formattedLine.length() - 1])) + { + formattedLine.erase(formattedLine.length() - 1, 1); + spacePadNum--; + } + // update the formattedLine split point + if (maxCodeLength != string::npos) + { + size_t index = formattedLine.length() - 1; + if (isWhiteSpace(formattedLine[index])) + { + updateFormattedLineSplitPointsPointerOrReference(index); + testForTimeToSplitFormattedLine(); + } + } +} + +/** + * format pointer or reference with align in the middle + */ +void ASFormatter::formatPointerOrReferenceToMiddle() +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(!isJavaStyle()); + + // compute current whitespace before + size_t wsBefore = currentLine.find_last_not_of(" \t", charNum - 1); + if (wsBefore == string::npos) + wsBefore = 0; + else + wsBefore = charNum - wsBefore - 1; + string sequenceToInsert(1, currentChar); + if (isSequenceReached("**")) + { + sequenceToInsert = "**"; + goForward(1); + } + else if (isSequenceReached("&&")) + { + sequenceToInsert = "&&"; + goForward(1); + } + // if reference to a pointer check for conflicting alignment + else if (currentChar == '*' && peekNextChar() == '&' + && (referenceAlignment == REF_ALIGN_TYPE + || referenceAlignment == REF_ALIGN_MIDDLE + || referenceAlignment == REF_SAME_AS_PTR)) + { + sequenceToInsert = "*&"; + goForward(1); + for (size_t i = charNum; i < currentLine.length() - 1 && isWhiteSpace(currentLine[i]); i++) + goForward(1); + } + // if a comment follows don't align, just space pad + if (isBeforeAnyComment()) + { + appendSpacePad(); + formattedLine.append(sequenceToInsert); + appendSpaceAfter(); + return; + } + // do this before goForward() + bool isAfterScopeResolution = previousNonWSChar == ':'; + size_t charNumSave = charNum; + // if this is the last thing on the line + if (currentLine.find_first_not_of(" \t", charNum + 1) == string::npos) + { + if (wsBefore == 0 && !isAfterScopeResolution) + formattedLine.append(1, ' '); + formattedLine.append(sequenceToInsert); + return; + } + // goForward() to convert tabs to spaces, if necessary, + // and move following characters to preceding characters + // this may not work every time with tab characters + for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++) + { + goForward(1); + if (formattedLine.length() > 0) + formattedLine.append(1, currentLine[i]); + else + spacePadNum--; + } + // find space padding after + size_t wsAfter = currentLine.find_first_not_of(" \t", charNumSave + 1); + if (wsAfter == string::npos || isBeforeAnyComment()) + wsAfter = 0; + else + wsAfter = wsAfter - charNumSave - 1; + // don't pad before scope resolution operator, but pad after + if (isAfterScopeResolution) + { + size_t lastText = formattedLine.find_last_not_of(" \t"); + formattedLine.insert(lastText + 1, sequenceToInsert); + appendSpacePad(); + } + else if (formattedLine.length() > 0) + { + // whitespace should be at least 2 chars to center + if (wsBefore + wsAfter < 2) + { + size_t charsToAppend = (2 - (wsBefore + wsAfter)); + formattedLine.append(charsToAppend, ' '); + spacePadNum += charsToAppend; + if (wsBefore == 0) + wsBefore++; + if (wsAfter == 0) + wsAfter++; + } + // insert the pointer or reference char + size_t padAfter = (wsBefore + wsAfter) / 2; + size_t index = formattedLine.length() - padAfter; + formattedLine.insert(index, sequenceToInsert); + } + else // formattedLine.length() == 0 + { + formattedLine.append(sequenceToInsert); + if (wsAfter == 0) + wsAfter++; + formattedLine.append(wsAfter, ' '); + spacePadNum += wsAfter; + } + // update the formattedLine split point after the pointer + if (maxCodeLength != string::npos && formattedLine.length() > 0) + { + size_t index = formattedLine.find_last_not_of(" \t"); + if (index != string::npos && (index < formattedLine.length() - 1)) + { + index++; + updateFormattedLineSplitPointsPointerOrReference(index); + testForTimeToSplitFormattedLine(); + } + } +} + +/** + * format pointer or reference with align to name + */ +void ASFormatter::formatPointerOrReferenceToName() +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(!isJavaStyle()); + + // do this before bumping charNum + bool isOldPRCentered = isPointerOrReferenceCentered(); + + size_t startNum = formattedLine.find_last_not_of(" \t"); + if (startNum == string::npos) + startNum = 0; + string sequenceToInsert(1, currentChar); + if (isSequenceReached("**")) + { + sequenceToInsert = "**"; + goForward(1); + } + else if (isSequenceReached("&&")) + { + sequenceToInsert = "&&"; + goForward(1); + } + // if reference to a pointer align both to name + else if (currentChar == '*' && peekNextChar() == '&') + { + sequenceToInsert = "*&"; + goForward(1); + for (size_t i = charNum; i < currentLine.length() - 1 && isWhiteSpace(currentLine[i]); i++) + goForward(1); + } + char peekedChar = peekNextChar(); + bool isAfterScopeResolution = previousNonWSChar == ':'; // check for :: + // if this is not the last thing on the line + if (!isBeforeAnyComment() + && (int) currentLine.find_first_not_of(" \t", charNum + 1) > charNum) + { + // goForward() to convert tabs to spaces, if necessary, + // and move following characters to preceding characters + // this may not work every time with tab characters + for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++) + { + // if a padded paren follows don't move + if (shouldPadParensOutside && peekedChar == '(' && !isOldPRCentered) + { + // empty parens don't count + size_t start = currentLine.find_first_not_of("( \t", charNum + 1); + if (start != string::npos && currentLine[start] != ')') + break; + } + goForward(1); + if (formattedLine.length() > 0) + formattedLine.append(1, currentLine[i]); + else + spacePadNum--; + } + } + // don't pad before scope resolution operator + if (isAfterScopeResolution) + { + size_t lastText = formattedLine.find_last_not_of(" \t"); + if (lastText != string::npos && lastText + 1 < formattedLine.length()) + formattedLine.erase(lastText + 1); + } + // if no space before * then add one + else if (formattedLine.length() > 0 + && (formattedLine.length() <= startNum + 1 + || !isWhiteSpace(formattedLine[startNum + 1]))) + { + formattedLine.insert(startNum + 1, 1, ' '); + spacePadNum++; + } + appendSequence(sequenceToInsert, false); + // if old pointer or reference is centered, remove a space + if (isOldPRCentered + && formattedLine.length() > startNum + 1 + && isWhiteSpace(formattedLine[startNum + 1]) + && !isBeforeAnyComment()) + { + formattedLine.erase(startNum + 1, 1); + spacePadNum--; + } + // don't convert to *= or &= + if (peekedChar == '=') + { + appendSpaceAfter(); + // if more than one space before, delete one + if (formattedLine.length() > startNum + && isWhiteSpace(formattedLine[startNum + 1]) + && isWhiteSpace(formattedLine[startNum + 2])) + { + formattedLine.erase(startNum + 1, 1); + spacePadNum--; + } + } + // update the formattedLine split point + if (maxCodeLength != string::npos) + { + size_t index = formattedLine.find_last_of(" \t"); + if (index != string::npos + && index < formattedLine.length() - 1 + && (formattedLine[index + 1] == '*' + || formattedLine[index + 1] == '&' + || formattedLine[index + 1] == '^')) + { + updateFormattedLineSplitPointsPointerOrReference(index); + testForTimeToSplitFormattedLine(); + } + } +} + +/** + * format pointer or reference cast + * currentChar contains the pointer or reference + * NOTE: the pointers and references in function definitions + * are processed as a cast (e.g. void foo(void*, void*)) + * is processed here. + */ +void ASFormatter::formatPointerOrReferenceCast() +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(!isJavaStyle()); + + int pa = pointerAlignment; + int ra = referenceAlignment; + int itemAlignment = (currentChar == '*' || currentChar == '^') ? pa : ((ra == REF_SAME_AS_PTR) ? pa : ra); + + string sequenceToInsert(1, currentChar); + if (isSequenceReached("**") || isSequenceReached("&&")) + { + goForward(1); + sequenceToInsert.append(1, currentLine[charNum]); + } + if (itemAlignment == PTR_ALIGN_NONE) + { + appendSequence(sequenceToInsert, false); + return; + } + // remove preceding whitespace + char prevCh = ' '; + size_t prevNum = formattedLine.find_last_not_of(" \t"); + if (prevNum != string::npos) + { + prevCh = formattedLine[prevNum]; + if (prevNum + 1 < formattedLine.length() + && isWhiteSpace(formattedLine[prevNum + 1]) + && prevCh != '(') + { + spacePadNum -= (formattedLine.length() - 1 - prevNum); + formattedLine.erase(prevNum + 1); + } + } + bool isAfterScopeResolution = previousNonWSChar == ':'; + if ((itemAlignment == PTR_ALIGN_MIDDLE || itemAlignment == PTR_ALIGN_NAME) + && !isAfterScopeResolution && prevCh != '(') + { + appendSpacePad(); + // in this case appendSpacePad may or may not update the split point + if (maxCodeLength != string::npos && formattedLine.length() > 0) + updateFormattedLineSplitPointsPointerOrReference(formattedLine.length() - 1); + appendSequence(sequenceToInsert, false); + } + else + appendSequence(sequenceToInsert, false); +} + +/** + * add or remove space padding to parens + * currentChar contains the paren + * the parens and necessary padding will be appended to formattedLine + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::padParens() +{ + assert(currentChar == '(' || currentChar == ')'); + assert(shouldPadParensOutside || shouldPadParensInside || shouldUnPadParens || shouldPadFirstParen); + + int spacesOutsideToDelete = 0; + int spacesInsideToDelete = 0; + + if (currentChar == '(') + { + spacesOutsideToDelete = formattedLine.length() - 1; + spacesInsideToDelete = 0; + + // compute spaces outside the opening paren to delete + if (shouldUnPadParens) + { + char lastChar = ' '; + bool prevIsParenHeader = false; + size_t i = formattedLine.find_last_not_of(" \t"); + if (i != string::npos) + { + // if last char is a brace the previous whitespace is an indent + if (formattedLine[i] == '{') + spacesOutsideToDelete = 0; + else if (isCharImmediatelyPostPointerOrReference) + spacesOutsideToDelete = 0; + else + { + spacesOutsideToDelete -= i; + lastChar = formattedLine[i]; + // if previous word is a header, it will be a paren header + string prevWord = getPreviousWord(formattedLine, formattedLine.length()); + const string* prevWordH = nullptr; + if (shouldPadHeader + && prevWord.length() > 0 + && isCharPotentialHeader(prevWord, 0)) + prevWordH = ASBase::findHeader(prevWord, 0, headers); + if (prevWordH != nullptr) + prevIsParenHeader = true; + else if (prevWord == AS_RETURN) // don't unpad + prevIsParenHeader = true; + else if ((prevWord == AS_NEW || prevWord == AS_DELETE) + && shouldPadHeader) // don't unpad + prevIsParenHeader = true; + else if (isCStyle() && prevWord == AS_THROW && shouldPadHeader) // don't unpad + prevIsParenHeader = true; + else if (prevWord == "and" || prevWord == "or" || prevWord == "in") // don't unpad + prevIsParenHeader = true; + // don't unpad variables + else if (prevWord == "bool" + || prevWord == "int" + || prevWord == "void" + || prevWord == "void*" + || prevWord == "char" + || prevWord == "char*" + || prevWord == "long" + || prevWord == "double" + || prevWord == "float" + || (prevWord.length() >= 4 // check end of word for _t + && prevWord.compare(prevWord.length() - 2, 2, "_t") == 0) + || prevWord == "Int32" + || prevWord == "UInt32" + || prevWord == "Int64" + || prevWord == "UInt64" + || prevWord == "BOOL" + || prevWord == "DWORD" + || prevWord == "HWND" + || prevWord == "INT" + || prevWord == "LPSTR" + || prevWord == "VOID" + || prevWord == "LPVOID" + ) + { + prevIsParenHeader = true; + } + } + } + // do not unpad operators, but leave them if already padded + if (shouldPadParensOutside || prevIsParenHeader) + spacesOutsideToDelete--; + else if (lastChar == '|' // check for || + || lastChar == '&' // check for && + || lastChar == ',' + || (lastChar == '(' && shouldPadParensInside) + || (lastChar == '>' && !foundCastOperator) + || lastChar == '<' + || lastChar == '?' + || lastChar == ':' + || lastChar == ';' + || lastChar == '=' + || lastChar == '+' + || lastChar == '-' + || lastChar == '*' + || lastChar == '/' + || lastChar == '%' + || lastChar == '^' + ) + spacesOutsideToDelete--; + + if (spacesOutsideToDelete > 0) + { + formattedLine.erase(i + 1, spacesOutsideToDelete); + spacePadNum -= spacesOutsideToDelete; + } + } + + // pad open paren outside + char peekedCharOutside = peekNextChar(); + if (shouldPadFirstParen && previousChar != '(' && peekedCharOutside != ')') + appendSpacePad(); + else if (shouldPadParensOutside) + { + if (!(currentChar == '(' && peekedCharOutside == ')')) + appendSpacePad(); + } + + appendCurrentChar(); + + // unpad open paren inside + if (shouldUnPadParens) + { + size_t j = currentLine.find_first_not_of(" \t", charNum + 1); + if (j != string::npos) + spacesInsideToDelete = j - charNum - 1; + if (shouldPadParensInside) + spacesInsideToDelete--; + if (spacesInsideToDelete > 0) + { + currentLine.erase(charNum + 1, spacesInsideToDelete); + spacePadNum -= spacesInsideToDelete; + } + // convert tab to space if requested + if (shouldConvertTabs + && (int) currentLine.length() > charNum + 1 + && currentLine[charNum + 1] == '\t') + currentLine[charNum + 1] = ' '; + } + + // pad open paren inside + char peekedCharInside = peekNextChar(); + if (shouldPadParensInside) + if (!(currentChar == '(' && peekedCharInside == ')')) + appendSpaceAfter(); + } + else if (currentChar == ')') + { + // unpad close paren inside + if (shouldUnPadParens) + { + spacesInsideToDelete = formattedLine.length(); + size_t i = formattedLine.find_last_not_of(" \t"); + if (i != string::npos) + spacesInsideToDelete = formattedLine.length() - 1 - i; + if (shouldPadParensInside) + spacesInsideToDelete--; + if (spacesInsideToDelete > 0) + { + formattedLine.erase(i + 1, spacesInsideToDelete); + spacePadNum -= spacesInsideToDelete; + } + } + + // pad close paren inside + if (shouldPadParensInside) + if (!(previousChar == '(' && currentChar == ')')) + appendSpacePad(); + + appendCurrentChar(); + + // unpad close paren outside + // close parens outside are left unchanged + if (shouldUnPadParens) + { + //spacesOutsideToDelete = 0; + //size_t j = currentLine.find_first_not_of(" \t", charNum + 1); + //if (j != string::npos) + // spacesOutsideToDelete = j - charNum - 1; + //if (shouldPadParensOutside) + // spacesOutsideToDelete--; + + //if (spacesOutsideToDelete > 0) + //{ + // currentLine.erase(charNum + 1, spacesOutsideToDelete); + // spacePadNum -= spacesOutsideToDelete; + //} + } + + // pad close paren outside + char peekedCharOutside = peekNextChar(); + if (shouldPadParensOutside) + if (peekedCharOutside != ';' + && peekedCharOutside != ',' + && peekedCharOutside != '.' + && peekedCharOutside != '+' // check for ++ + && peekedCharOutside != '-' // check for -- + && peekedCharOutside != ']') + appendSpaceAfter(); + } +} + +/** +* add or remove space padding to objective-c parens +* these options have precedence over the padParens methods +* the padParens method has already been called, this method adjusts +*/ +void ASFormatter::padObjCMethodPrefix() +{ + assert(currentChar == '(' && isImmediatelyPostObjCMethodPrefix); + assert(shouldPadMethodPrefix || shouldUnPadMethodPrefix); + + size_t prefix = formattedLine.find_first_of("+-"); + if (prefix == string::npos) + return; + size_t paren = formattedLine.find_first_of('('); + if (paren == string::npos) + return; + int spaces = paren - prefix - 1; + + if (shouldPadMethodPrefix) + { + if (spaces == 0) + { + formattedLine.insert(prefix + 1, 1, ' '); + spacePadNum += 1; + } + else if (spaces > 1) + { + formattedLine.erase(prefix + 1, spaces - 1); + spacePadNum -= spaces - 1; + } + } + // this option will be ignored if used with pad-method-prefix + else if (shouldUnPadMethodPrefix) + { + if (spaces > 0) + { + formattedLine.erase(prefix + 1, spaces); + spacePadNum -= spaces; + } + } +} + +/** +* add or remove space padding to objective-c parens +* these options have precedence over the padParens methods +* the padParens method has already been called, this method adjusts +*/ +void ASFormatter::padObjCReturnType() +{ + assert(currentChar == ')' && isInObjCReturnType); + assert(shouldPadReturnType || shouldUnPadReturnType); + + size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextText == string::npos) + return; + int spaces = nextText - charNum - 1; + + if (shouldPadReturnType) + { + if (spaces == 0) + { + // this will already be padded if pad-paren is used + if (formattedLine[formattedLine.length() - 1] != ' ') + { + formattedLine.append(" "); + spacePadNum += 1; + } + } + else if (spaces > 1) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces - 1); + spacePadNum -= spaces - 1; + } + } + // this option will be ignored if used with pad-return-type + else if (shouldUnPadReturnType) + { + // this will already be padded if pad-paren is used + if (formattedLine[formattedLine.length() - 1] == ' ') + { + spacePadNum -= formattedLine.length() - 1 - nextText; + int lastText = formattedLine.find_last_not_of(" \t"); + formattedLine.resize(lastText + 1); + } + if (spaces > 0) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces); + spacePadNum -= spaces; + } + } +} + +/** +* add or remove space padding to objective-c parens +* these options have precedence over the padParens methods +* the padParens method has already been called, this method adjusts +*/ +void ASFormatter::padObjCParamType() +{ + assert((currentChar == '(' || currentChar == ')') && isInObjCMethodDefinition); + assert(!isImmediatelyPostObjCMethodPrefix && !isInObjCReturnType); + assert(shouldPadParamType || shouldUnPadParamType); + + if (currentChar == '(') + { + // open paren has already been attached to formattedLine by padParen + size_t paramOpen = formattedLine.rfind('('); + assert(paramOpen != string::npos); + size_t prevText = formattedLine.find_last_not_of(" \t", paramOpen - 1); + if (prevText == string::npos) + return; + int spaces = paramOpen - prevText - 1; + + if (shouldPadParamType + || objCColonPadMode == COLON_PAD_ALL + || objCColonPadMode == COLON_PAD_AFTER) + { + if (spaces == 0) + { + formattedLine.insert(paramOpen, 1, ' '); + spacePadNum += 1; + } + if (spaces > 1) + { + formattedLine.erase(prevText + 1, spaces - 1); + spacePadNum -= spaces - 1; + } + } + // this option will be ignored if used with pad-param-type + else if (shouldUnPadParamType + || objCColonPadMode == COLON_PAD_NONE + || objCColonPadMode == COLON_PAD_BEFORE) + { + if (spaces > 0) + { + formattedLine.erase(prevText + 1, spaces); + spacePadNum -= spaces; + } + } + } + else if (currentChar == ')') + { + size_t nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextText == string::npos) + return; + int spaces = nextText - charNum - 1; + + if (shouldPadParamType) + { + if (spaces == 0) + { + // this will already be padded if pad-paren is used + if (formattedLine[formattedLine.length() - 1] != ' ') + { + formattedLine.append(" "); + spacePadNum += 1; + } + } + else if (spaces > 1) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces - 1); + spacePadNum -= spaces - 1; + } + } + // this option will be ignored if used with pad-param-type + else if (shouldUnPadParamType) + { + // this will already be padded if pad-paren is used + if (formattedLine[formattedLine.length() - 1] == ' ') + { + spacePadNum -= 1; + int lastText = formattedLine.find_last_not_of(" \t"); + formattedLine.resize(lastText + 1); + } + if (spaces > 0) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces); + spacePadNum -= spaces; + } + } + } +} + +/** + * format opening brace as attached or broken + * currentChar contains the brace + * the braces will be appended to the current formattedLine or a new formattedLine as necessary + * the calling function should have a continue statement after calling this method + * + * @param braceType the type of brace to be formatted. + */ +void ASFormatter::formatOpeningBrace(BraceType braceType) +{ + assert(!isBraceType(braceType, ARRAY_TYPE)); + assert(currentChar == '{'); + + parenStack->emplace_back(0); + + bool breakBrace = isCurrentBraceBroken(); + + if (breakBrace) + { + if (isBeforeAnyComment() && isOkToBreakBlock(braceType)) + { + // if comment is at line end leave the comment on this line + if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace) + { + currentChar = ' '; // remove brace from current line + if (parenStack->size() > 1) + parenStack->pop_back(); + currentLine[charNum] = currentChar; + appendOpeningBrace = true; // append brace to following line + } + // else put comment after the brace + else if (!isBeforeMultipleLineEndComments(charNum)) + breakLine(); + } + else if (!isBraceType(braceType, SINGLE_LINE_TYPE)) + { + formattedLine = rtrim(formattedLine); + breakLine(); + } + else if ((shouldBreakOneLineBlocks || isBraceType(braceType, BREAK_BLOCK_TYPE)) + && !isBraceType(braceType, EMPTY_BLOCK_TYPE)) + breakLine(); + else if (!isInLineBreak) + appendSpacePad(); + + appendCurrentChar(); + + // should a following comment break from the brace? + // must break the line AFTER the brace + if (isBeforeComment() + && formattedLine.length() > 0 + && formattedLine[0] == '{' + && isOkToBreakBlock(braceType) + && (braceFormatMode == BREAK_MODE + || braceFormatMode == LINUX_MODE)) + { + shouldBreakLineAtNextChar = true; + } + } + else // attach brace + { + // are there comments before the brace? + if (isCharImmediatelyPostComment || isCharImmediatelyPostLineComment) + { + if (isOkToBreakBlock(braceType) + && !(isCharImmediatelyPostComment && isCharImmediatelyPostLineComment) // don't attach if two comments on the line + && !isImmediatelyPostPreprocessor +// && peekNextChar() != '}' // don't attach { } // removed release 2.03 + && previousCommandChar != '{' // don't attach { { + && previousCommandChar != '}' // don't attach } { + && previousCommandChar != ';') // don't attach ; { + { + appendCharInsideComments(); + } + else + { + appendCurrentChar(); // don't attach + } + } + else if (previousCommandChar == '{' + || (previousCommandChar == '}' && !isInClassInitializer) + || previousCommandChar == ';') // '}' , ';' chars added for proper handling of '{' immediately after a '}' or ';' + { + appendCurrentChar(); // don't attach + } + else + { + // if a blank line precedes this don't attach + if (isEmptyLine(formattedLine)) + appendCurrentChar(); // don't attach + else if (isOkToBreakBlock(braceType) + && !(isImmediatelyPostPreprocessor + && currentLineBeginsWithBrace)) + { + if (!isBraceType(braceType, EMPTY_BLOCK_TYPE)) + { + appendSpacePad(); + appendCurrentChar(false); // OK to attach + testForTimeToSplitFormattedLine(); // line length will have changed + // should a following comment attach with the brace? + // insert spaces to reposition the comment + if (isBeforeComment() + && !isBeforeMultipleLineEndComments(charNum) + && (!isBeforeAnyLineEndComment(charNum) || currentLineBeginsWithBrace)) + { + shouldBreakLineAtNextChar = true; + currentLine.insert(charNum + 1, charNum + 1, ' '); + } + else if (!isBeforeAnyComment()) // added in release 2.03 + { + shouldBreakLineAtNextChar = true; + } + } + else + { + if (currentLineBeginsWithBrace && charNum == (int) currentLineFirstBraceNum) + { + appendSpacePad(); + appendCurrentChar(false); // attach + shouldBreakLineAtNextChar = true; + } + else + { + appendSpacePad(); + appendCurrentChar(); // don't attach + } + } + } + else + { + if (!isInLineBreak) + appendSpacePad(); + appendCurrentChar(); // don't attach + } + } + } +} + +/** + * format closing brace + * currentChar contains the brace + * the calling function should have a continue statement after calling this method + * + * @param braceType the type of the opening brace for this closing brace. + */ +void ASFormatter::formatClosingBrace(BraceType braceType) +{ + assert(!isBraceType(braceType, ARRAY_TYPE)); + assert(currentChar == '}'); + + // parenStack must contain one entry + if (parenStack->size() > 1) + parenStack->pop_back(); + + // mark state of immediately after empty block + // this state will be used for locating braces that appear immediately AFTER an empty block (e.g. '{} \n}'). + if (previousCommandChar == '{') + isImmediatelyPostEmptyBlock = true; + + if (attachClosingBraceMode) + { + // for now, namespaces and classes will be attached. Uncomment the lines below to break. + if ((isEmptyLine(formattedLine) // if a blank line precedes this + || isCharImmediatelyPostLineComment + || isCharImmediatelyPostComment + || (isImmediatelyPostPreprocessor && (int) currentLine.find_first_not_of(" \t") == charNum) +// || (isBraceType(braceType, CLASS_TYPE) && isOkToBreakBlock(braceType) && previousNonWSChar != '{') +// || (isBraceType(braceType, NAMESPACE_TYPE) && isOkToBreakBlock(braceType) && previousNonWSChar != '{') + ) + && (!isBraceType(braceType, SINGLE_LINE_TYPE) || isOkToBreakBlock(braceType))) + { + breakLine(); + appendCurrentChar(); // don't attach + } + else + { + if (previousNonWSChar != '{' + && (!isBraceType(braceType, SINGLE_LINE_TYPE) + || isOkToBreakBlock(braceType))) + appendSpacePad(); + appendCurrentChar(false); // attach + } + } + else if (!isBraceType(braceType, EMPTY_BLOCK_TYPE) + && (isBraceType(braceType, BREAK_BLOCK_TYPE) + || isOkToBreakBlock(braceType))) + { + breakLine(); + appendCurrentChar(); + } + else + { + appendCurrentChar(); + } + + // if a declaration follows a definition, space pad + if (isLegalNameChar(peekNextChar())) + appendSpaceAfter(); + + if (shouldBreakBlocks + && currentHeader != nullptr + && !isHeaderInMultiStatementLine + && parenStack->back() == 0) + { + if (currentHeader == &AS_CASE || currentHeader == &AS_DEFAULT) + { + // do not yet insert a line if "break" statement is outside the braces + string nextText = peekNextText(currentLine.substr(charNum + 1)); + if (nextText.length() > 0 + && nextText.substr(0, 5) != "break") + isAppendPostBlockEmptyLineRequested = true; + } + else + isAppendPostBlockEmptyLineRequested = true; + } +} + +/** + * format array braces as attached or broken + * determine if the braces can have an inStatement indent + * currentChar contains the brace + * the braces will be appended to the current formattedLine or a new formattedLine as necessary + * the calling function should have a continue statement after calling this method + * + * @param braceType the type of brace to be formatted, must be an ARRAY_TYPE. + * @param isOpeningArrayBrace indicates if this is the opening brace for the array block. + */ +void ASFormatter::formatArrayBraces(BraceType braceType, bool isOpeningArrayBrace) +{ + assert(isBraceType(braceType, ARRAY_TYPE)); + assert(currentChar == '{' || currentChar == '}'); + + if (currentChar == '{') + { + // is this the first opening brace in the array? + if (isOpeningArrayBrace) + { + if (braceFormatMode == ATTACH_MODE + || braceFormatMode == LINUX_MODE) + { + // break an enum if mozilla + if (isBraceType(braceType, ENUM_TYPE) + && formattingStyle == STYLE_MOZILLA) + { + isInLineBreak = true; + appendCurrentChar(); // don't attach + } + // don't attach to a preprocessor directive or '\' line + else if ((isImmediatelyPostPreprocessor + || (formattedLine.length() > 0 + && formattedLine[formattedLine.length() - 1] == '\\')) + && currentLineBeginsWithBrace) + { + isInLineBreak = true; + appendCurrentChar(); // don't attach + } + else if (isCharImmediatelyPostComment) + { + // TODO: attach brace to line-end comment + appendCurrentChar(); // don't attach + } + else if (isCharImmediatelyPostLineComment && !isBraceType(braceType, SINGLE_LINE_TYPE)) + { + appendCharInsideComments(); + } + else + { + // if a blank line precedes this don't attach + if (isEmptyLine(formattedLine)) + appendCurrentChar(); // don't attach + else + { + // if brace is broken or not an assignment + if (currentLineBeginsWithBrace + && !isBraceType(braceType, SINGLE_LINE_TYPE)) + { + appendSpacePad(); + appendCurrentChar(false); // OK to attach + // TODO: debug the following line + testForTimeToSplitFormattedLine(); // line length will have changed + + if (currentLineBeginsWithBrace + && (int) currentLineFirstBraceNum == charNum) + shouldBreakLineAtNextChar = true; + } + else + { + if (previousNonWSChar != '(') + { + // don't space pad C++11 uniform initialization + if (!isBraceType(braceType, INIT_TYPE)) + appendSpacePad(); + } + appendCurrentChar(); + } + } + } + } + else if (braceFormatMode == BREAK_MODE) + { + if (isWhiteSpace(peekNextChar()) && !isInVirginLine) + breakLine(); + else if (isBeforeAnyComment()) + { + // do not break unless comment is at line end + if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace) + { + currentChar = ' '; // remove brace from current line + appendOpeningBrace = true; // append brace to following line + } + } + if (!isInLineBreak && previousNonWSChar != '(') + { + // don't space pad C++11 uniform initialization + if (!isBraceType(braceType, INIT_TYPE)) + appendSpacePad(); + } + appendCurrentChar(); + + if (currentLineBeginsWithBrace + && (int) currentLineFirstBraceNum == charNum + && !isBraceType(braceType, SINGLE_LINE_TYPE)) + shouldBreakLineAtNextChar = true; + } + else if (braceFormatMode == RUN_IN_MODE) + { + if (isWhiteSpace(peekNextChar()) && !isInVirginLine) + breakLine(); + else if (isBeforeAnyComment()) + { + // do not break unless comment is at line end + if (isBeforeAnyLineEndComment(charNum) && !currentLineBeginsWithBrace) + { + currentChar = ' '; // remove brace from current line + appendOpeningBrace = true; // append brace to following line + } + } + if (!isInLineBreak && previousNonWSChar != '(') + { + // don't space pad C++11 uniform initialization + if (!isBraceType(braceType, INIT_TYPE)) + appendSpacePad(); + } + appendCurrentChar(); + } + else if (braceFormatMode == NONE_MODE) + { + if (currentLineBeginsWithBrace + && charNum == (int) currentLineFirstBraceNum) + { + appendCurrentChar(); // don't attach + } + else + { + if (previousNonWSChar != '(') + { + // don't space pad C++11 uniform initialization + if (!isBraceType(braceType, INIT_TYPE)) + appendSpacePad(); + } + appendCurrentChar(false); // OK to attach + } + } + } + else // not the first opening brace + { + if (braceFormatMode == RUN_IN_MODE) + { + if (previousNonWSChar == '{' + && braceTypeStack->size() > 2 + && !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2], + SINGLE_LINE_TYPE)) + formatArrayRunIn(); + } + else if (!isInLineBreak + && !isWhiteSpace(peekNextChar()) + && previousNonWSChar == '{' + && braceTypeStack->size() > 2 + && !isBraceType((*braceTypeStack)[braceTypeStack->size() - 2], + SINGLE_LINE_TYPE)) + formatArrayRunIn(); + + appendCurrentChar(); + } + } + else if (currentChar == '}') + { + if (attachClosingBraceMode) + { + if (isEmptyLine(formattedLine) // if a blank line precedes this + || isImmediatelyPostPreprocessor + || isCharImmediatelyPostLineComment + || isCharImmediatelyPostComment) + appendCurrentChar(); // don't attach + else + { + appendSpacePad(); + appendCurrentChar(false); // attach + } + } + else + { + // does this close the first opening brace in the array? + // must check if the block is still a single line because of anonymous statements + if (!isBraceType(braceType, INIT_TYPE) + && (!isBraceType(braceType, SINGLE_LINE_TYPE) + || formattedLine.find('{') == string::npos)) + breakLine(); + appendCurrentChar(); + } + + // if a declaration follows an enum definition, space pad + char peekedChar = peekNextChar(); + if (isLegalNameChar(peekedChar) + || peekedChar == '[') + appendSpaceAfter(); + } +} + +/** + * determine if a run-in can be attached. + * if it can insert the indents in formattedLine and reset the current line break. + */ +void ASFormatter::formatRunIn() +{ + assert(braceFormatMode == RUN_IN_MODE || braceFormatMode == NONE_MODE); + + // keep one line blocks returns true without indenting the run-in + if (formattingStyle != STYLE_PICO + && !isOkToBreakBlock(braceTypeStack->back())) + return; // true; + + // make sure the line begins with a brace + size_t lastText = formattedLine.find_last_not_of(" \t"); + if (lastText == string::npos || formattedLine[lastText] != '{') + return; // false; + + // make sure the brace is broken + if (formattedLine.find_first_not_of(" \t{") != string::npos) + return; // false; + + if (isBraceType(braceTypeStack->back(), NAMESPACE_TYPE)) + return; // false; + + bool extraIndent = false; + bool extraHalfIndent = false; + isInLineBreak = true; + + // cannot attach a class modifier without indent-classes + if (isCStyle() + && isCharPotentialHeader(currentLine, charNum) + && (isBraceType(braceTypeStack->back(), CLASS_TYPE) + || (isBraceType(braceTypeStack->back(), STRUCT_TYPE) + && isInIndentableStruct))) + { + if (findKeyword(currentLine, charNum, AS_PUBLIC) + || findKeyword(currentLine, charNum, AS_PRIVATE) + || findKeyword(currentLine, charNum, AS_PROTECTED)) + { + if (getModifierIndent()) + extraHalfIndent = true; + else if (!getClassIndent()) + return; // false; + } + else if (getClassIndent()) + extraIndent = true; + } + + // cannot attach a 'case' statement without indent-switches + if (!getSwitchIndent() + && isCharPotentialHeader(currentLine, charNum) + && (findKeyword(currentLine, charNum, AS_CASE) + || findKeyword(currentLine, charNum, AS_DEFAULT))) + return; // false; + + // extra indent for switch statements + if (getSwitchIndent() + && !preBraceHeaderStack->empty() + && preBraceHeaderStack->back() == &AS_SWITCH + && ((isLegalNameChar(currentChar) + && !findKeyword(currentLine, charNum, AS_CASE)))) + extraIndent = true; + + isInLineBreak = false; + // remove for extra whitespace + if (formattedLine.length() > lastText + 1 + && formattedLine.find_first_not_of(" \t", lastText + 1) == string::npos) + formattedLine.erase(lastText + 1); + + if (extraHalfIndent) + { + int indentLength_ = getIndentLength(); + runInIndentChars = indentLength_ / 2; + formattedLine.append(runInIndentChars - 1, ' '); + } + else if (getForceTabIndentation() && getIndentLength() != getTabLength()) + { + // insert the space indents + string indent; + int indentLength_ = getIndentLength(); + int tabLength_ = getTabLength(); + indent.append(indentLength_, ' '); + if (extraIndent) + indent.append(indentLength_, ' '); + // replace spaces indents with tab indents + size_t tabCount = indent.length() / tabLength_; // truncate extra spaces + indent.replace(0U, tabCount * tabLength_, tabCount, '\t'); + runInIndentChars = indentLength_; + if (indent[0] == ' ') // allow for brace + indent.erase(0, 1); + formattedLine.append(indent); + } + else if (getIndentString() == "\t") + { + appendChar('\t', false); + runInIndentChars = 2; // one for { and one for tab + if (extraIndent) + { + appendChar('\t', false); + runInIndentChars++; + } + } + else // spaces + { + int indentLength_ = getIndentLength(); + formattedLine.append(indentLength_ - 1, ' '); + runInIndentChars = indentLength_; + if (extraIndent) + { + formattedLine.append(indentLength_, ' '); + runInIndentChars += indentLength_; + } + } + isInBraceRunIn = true; +} + +/** + * remove whitespace and add indentation for an array run-in. + */ +void ASFormatter::formatArrayRunIn() +{ + assert(isBraceType(braceTypeStack->back(), ARRAY_TYPE)); + + // make sure the brace is broken + if (formattedLine.find_first_not_of(" \t{") != string::npos) + return; + + size_t lastText = formattedLine.find_last_not_of(" \t"); + if (lastText == string::npos || formattedLine[lastText] != '{') + return; + + // check for extra whitespace + if (formattedLine.length() > lastText + 1 + && formattedLine.find_first_not_of(" \t", lastText + 1) == string::npos) + formattedLine.erase(lastText + 1); + + if (getIndentString() == "\t") + { + appendChar('\t', false); + runInIndentChars = 2; // one for { and one for tab + } + else + { + int indent = getIndentLength(); + formattedLine.append(indent - 1, ' '); + runInIndentChars = indent; + } + isInBraceRunIn = true; + isInLineBreak = false; +} + +/** + * delete a braceTypeStack vector object + * BraceTypeStack did not work with the DeleteContainer template + */ +void ASFormatter::deleteContainer(vector*& container) +{ + if (container != nullptr) + { + container->clear(); + delete (container); + container = nullptr; + } +} + +/** + * delete a vector object + * T is the type of vector + * used for all vectors except braceTypeStack + */ +template +void ASFormatter::deleteContainer(T& container) +{ + if (container != nullptr) + { + container->clear(); + delete (container); + container = nullptr; + } +} + +/** + * initialize a braceType vector object + * braceType did not work with the DeleteContainer template + */ +void ASFormatter::initContainer(vector*& container, vector* value) +{ + if (container != nullptr) + deleteContainer(container); + container = value; +} + +/** + * initialize a vector object + * T is the type of vector + * used for all vectors except braceTypeStack + */ +template +void ASFormatter::initContainer(T& container, T value) +{ + // since the ASFormatter object is never deleted, + // the existing vectors must be deleted before creating new ones + if (container != nullptr) + deleteContainer(container); + container = value; +} + +/** + * convert a tab to spaces. + * charNum points to the current character to convert to spaces. + * tabIncrementIn is the increment that must be added for tab indent characters + * to get the correct column for the current tab. + * replaces the tab in currentLine with the required number of spaces. + * replaces the value of currentChar. + */ +void ASFormatter::convertTabToSpaces() +{ + assert(currentChar == '\t'); + + // do NOT replace if in quotes + if (isInQuote || isInQuoteContinuation) + return; + + size_t tabSize = getTabLength(); + size_t numSpaces = tabSize - ((tabIncrementIn + charNum) % tabSize); + currentLine.replace(charNum, 1, numSpaces, ' '); + currentChar = currentLine[charNum]; +} + +/** +* is it ok to break this block? +*/ +bool ASFormatter::isOkToBreakBlock(BraceType braceType) const +{ + // Actually, there should not be an ARRAY_TYPE brace here. + // But this will avoid breaking a one line block when there is. + // Otherwise they will be formatted differently on consecutive runs. + if (isBraceType(braceType, ARRAY_TYPE) + && isBraceType(braceType, SINGLE_LINE_TYPE)) + return false; + if (isBraceType(braceType, COMMAND_TYPE) + && isBraceType(braceType, EMPTY_BLOCK_TYPE)) + return false; + if (!isBraceType(braceType, SINGLE_LINE_TYPE) + || isBraceType(braceType, BREAK_BLOCK_TYPE) + || shouldBreakOneLineBlocks) + return true; + return false; +} + +/** +* check if a sharp header is a paren or non-paren header +*/ +bool ASFormatter::isSharpStyleWithParen(const string* header) const +{ + return (isSharpStyle() && peekNextChar() == '(' + && (header == &AS_CATCH + || header == &AS_DELEGATE)); +} + +/** + * Check for a following header when a comment is reached. + * firstLine must contain the start of the comment. + * return value is a pointer to the header or nullptr. + */ +const string* ASFormatter::checkForHeaderFollowingComment(const string& firstLine) const +{ + assert(isInComment || isInLineComment); + assert(shouldBreakElseIfs || shouldBreakBlocks || isInSwitchStatement()); + // look ahead to find the next non-comment text + bool endOnEmptyLine = (currentHeader == nullptr); + if (isInSwitchStatement()) + endOnEmptyLine = false; + string nextText = peekNextText(firstLine, endOnEmptyLine); + + if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0)) + return nullptr; + + return ASBase::findHeader(nextText, 0, headers); +} + +/** + * process preprocessor statements. + * charNum should be the index of the #. + * + * delete braceTypeStack entries added by #if if a #else is found. + * prevents double entries in the braceTypeStack. + */ +void ASFormatter::processPreprocessor() +{ + assert(currentChar == '#'); + + const size_t preproc = currentLine.find_first_not_of(" \t", charNum + 1); + + if (preproc == string::npos) + return; + + if (currentLine.compare(preproc, 2, "if") == 0) + { + preprocBraceTypeStackSize = braceTypeStack->size(); + } + else if (currentLine.compare(preproc, 4, "else") == 0) + { + // delete stack entries added in #if + // should be replaced by #else + if (preprocBraceTypeStackSize > 0) + { + int addedPreproc = braceTypeStack->size() - preprocBraceTypeStackSize; + for (int i = 0; i < addedPreproc; i++) + braceTypeStack->pop_back(); + } + } +} + +/** + * determine if the next line starts a comment + * and a header follows the comment or comments. + */ +bool ASFormatter::commentAndHeaderFollows() +{ + // called ONLY IF shouldDeleteEmptyLines and shouldBreakBlocks are TRUE. + assert(shouldDeleteEmptyLines && shouldBreakBlocks); + + // is the next line a comment + auto stream = make_shared(sourceIterator); + if (!stream->hasMoreLines()) + return false; + string nextLine_ = stream->peekNextLine(); + size_t firstChar = nextLine_.find_first_not_of(" \t"); + if (firstChar == string::npos + || !(nextLine_.compare(firstChar, 2, "//") == 0 + || nextLine_.compare(firstChar, 2, "/*") == 0)) + return false; + + // find the next non-comment text, and reset + string nextText = peekNextText(nextLine_, false, stream); + if (nextText.length() == 0 || !isCharPotentialHeader(nextText, 0)) + return false; + + const string* newHeader = ASBase::findHeader(nextText, 0, headers); + + if (newHeader == nullptr) + return false; + + // if a closing header, reset break unless break is requested + if (isClosingHeader(newHeader) && !shouldBreakClosingHeaderBlocks) + { + isAppendPostBlockEmptyLineRequested = false; + return false; + } + + return true; +} + +/** + * determine if a brace should be attached or broken + * uses braces in the braceTypeStack + * the last brace in the braceTypeStack is the one being formatted + * returns true if the brace should be broken + */ +bool ASFormatter::isCurrentBraceBroken() const +{ + assert(braceTypeStack->size() > 1); + + bool breakBrace = false; + size_t stackEnd = braceTypeStack->size() - 1; + + // check brace modifiers + if (shouldAttachExternC + && isBraceType((*braceTypeStack)[stackEnd], EXTERN_TYPE)) + { + return false; + } + if (shouldAttachNamespace + && isBraceType((*braceTypeStack)[stackEnd], NAMESPACE_TYPE)) + { + return false; + } + if (shouldAttachClass + && (isBraceType((*braceTypeStack)[stackEnd], CLASS_TYPE) + || isBraceType((*braceTypeStack)[stackEnd], INTERFACE_TYPE))) + { + return false; + } + if (shouldAttachInline + && isCStyle() // for C++ only + && braceFormatMode != RUN_IN_MODE + && !(currentLineBeginsWithBrace && peekNextChar() == '/') + && isBraceType((*braceTypeStack)[stackEnd], COMMAND_TYPE)) + { + size_t i; + for (i = 1; i < braceTypeStack->size(); i++) + if (isBraceType((*braceTypeStack)[i], CLASS_TYPE) + || isBraceType((*braceTypeStack)[i], STRUCT_TYPE)) + return false; + } + + // check braces + if (isBraceType((*braceTypeStack)[stackEnd], EXTERN_TYPE)) + { + if (currentLineBeginsWithBrace + || braceFormatMode == RUN_IN_MODE) + breakBrace = true; + } + else if (braceFormatMode == NONE_MODE) + { + if (currentLineBeginsWithBrace + && (int) currentLineFirstBraceNum == charNum) + breakBrace = true; + } + else if (braceFormatMode == BREAK_MODE || braceFormatMode == RUN_IN_MODE) + { + breakBrace = true; + } + else if (braceFormatMode == LINUX_MODE) + { + // break a namespace if NOT stroustrup or mozilla + if (isBraceType((*braceTypeStack)[stackEnd], NAMESPACE_TYPE)) + { + if (formattingStyle != STYLE_STROUSTRUP + && formattingStyle != STYLE_MOZILLA) + breakBrace = true; + } + // break a class or interface if NOT stroustrup + else if (isBraceType((*braceTypeStack)[stackEnd], CLASS_TYPE) + || isBraceType((*braceTypeStack)[stackEnd], INTERFACE_TYPE)) + { + if (formattingStyle != STYLE_STROUSTRUP) + breakBrace = true; + } + // break a struct if mozilla - an enum is processed as an array brace + else if (isBraceType((*braceTypeStack)[stackEnd], STRUCT_TYPE)) + { + if (formattingStyle == STYLE_MOZILLA) + breakBrace = true; + } + // break the first brace if a function + else if (isBraceType((*braceTypeStack)[stackEnd], COMMAND_TYPE)) + { + if (stackEnd == 1) + { + breakBrace = true; + } + else if (stackEnd > 1) + { + // break the first brace after these if a function + if (isBraceType((*braceTypeStack)[stackEnd - 1], NAMESPACE_TYPE) + || isBraceType((*braceTypeStack)[stackEnd - 1], CLASS_TYPE) + || isBraceType((*braceTypeStack)[stackEnd - 1], ARRAY_TYPE) + || isBraceType((*braceTypeStack)[stackEnd - 1], STRUCT_TYPE) + || isBraceType((*braceTypeStack)[stackEnd - 1], EXTERN_TYPE)) + { + breakBrace = true; + } + } + } + } + return breakBrace; +} + +/** + * format comment body + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatCommentBody() +{ + assert(isInComment); + + // append the comment + while (charNum < (int) currentLine.length()) + { + currentChar = currentLine[charNum]; + if (isSequenceReached("*/")) + { + formatCommentCloser(); + break; + } + if (currentChar == '\t' && shouldConvertTabs) + convertTabToSpaces(); + appendCurrentChar(); + ++charNum; + } + if (shouldStripCommentPrefix) + stripCommentPrefix(); +} + +/** + * format a comment opener + * the comment opener will be appended to the current formattedLine or a new formattedLine as necessary + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatCommentOpener() +{ + assert(isSequenceReached("/*")); + + isInComment = isInCommentStartLine = true; + isImmediatelyPostLineComment = false; + if (previousNonWSChar == '}') + resetEndOfStatement(); + + // Check for a following header. + // For speed do not check multiple comment lines more than once. + // For speed do not check shouldBreakBlocks if previous line is empty, a comment, or a '{'. + const string* followingHeader = nullptr; + if ((doesLineStartComment + && !isImmediatelyPostCommentOnly + && isBraceType(braceTypeStack->back(), COMMAND_TYPE)) + && (shouldBreakElseIfs + || isInSwitchStatement() + || (shouldBreakBlocks + && !isImmediatelyPostEmptyLine + && previousCommandChar != '{'))) + followingHeader = checkForHeaderFollowingComment(currentLine.substr(charNum)); + + if (spacePadNum != 0 && !isInLineBreak) + adjustComments(); + formattedLineCommentNum = formattedLine.length(); + + // must be done BEFORE appendSequence + if (previousCommandChar == '{' + && !isImmediatelyPostComment + && !isImmediatelyPostLineComment) + { + if (isBraceType(braceTypeStack->back(), NAMESPACE_TYPE)) + { + // namespace run-in is always broken. + isInLineBreak = true; + } + else if (braceFormatMode == NONE_MODE) + { + // should a run-in statement be attached? + if (currentLineBeginsWithBrace) + formatRunIn(); + } + else if (braceFormatMode == ATTACH_MODE) + { + // if the brace was not attached? + if (formattedLine.length() > 0 && formattedLine[0] == '{' + && !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE)) + isInLineBreak = true; + } + else if (braceFormatMode == RUN_IN_MODE) + { + // should a run-in statement be attached? + if (formattedLine.length() > 0 && formattedLine[0] == '{') + formatRunIn(); + } + } + else if (!doesLineStartComment) + noTrimCommentContinuation = true; + + // ASBeautifier needs to know the following statements + if (shouldBreakElseIfs && followingHeader == &AS_ELSE) + elseHeaderFollowsComments = true; + if (followingHeader == &AS_CASE || followingHeader == &AS_DEFAULT) + caseHeaderFollowsComments = true; + + // appendSequence will write the previous line + appendSequence(AS_OPEN_COMMENT); + goForward(1); + + // must be done AFTER appendSequence + + // Break before the comment if a header follows the line comment. + // But not break if previous line is empty, a comment, or a '{'. + if (shouldBreakBlocks + && followingHeader != nullptr + && !isImmediatelyPostEmptyLine + && previousCommandChar != '{') + { + if (isClosingHeader(followingHeader)) + { + if (!shouldBreakClosingHeaderBlocks) + isPrependPostBlockEmptyLineRequested = false; + } + // if an opening header, break before the comment + else + isPrependPostBlockEmptyLineRequested = true; + } + + if (previousCommandChar == '}') + currentHeader = nullptr; +} + +/** + * format a comment closer + * the comment closer will be appended to the current formattedLine + */ +void ASFormatter::formatCommentCloser() +{ + assert(isSequenceReached("*/")); + isInComment = false; + noTrimCommentContinuation = false; + isImmediatelyPostComment = true; + appendSequence(AS_CLOSE_COMMENT); + goForward(1); + if (doesLineStartComment + && (currentLine.find_first_not_of(" \t", charNum + 1) == string::npos)) + lineEndsInCommentOnly = true; + if (peekNextChar() == '}' + && previousCommandChar != ';' + && !isBraceType(braceTypeStack->back(), ARRAY_TYPE) + && !isInPreprocessor + && isOkToBreakBlock(braceTypeStack->back())) + { + isInLineBreak = true; + shouldBreakLineAtNextChar = true; + } +} + +/** + * format a line comment body + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatLineCommentBody() +{ + assert(isInLineComment); + + // append the comment + while (charNum < (int) currentLine.length()) +// && !isLineReady // commented out in release 2.04, unnecessary + { + currentChar = currentLine[charNum]; + if (currentChar == '\t' && shouldConvertTabs) + convertTabToSpaces(); + appendCurrentChar(); + ++charNum; + } + + // explicitly break a line when a line comment's end is found. + if (charNum == (int) currentLine.length()) + { + isInLineBreak = true; + isInLineComment = false; + isImmediatelyPostLineComment = true; + currentChar = 0; //make sure it is a neutral char. + } +} + +/** + * format a line comment opener + * the line comment opener will be appended to the current formattedLine or a new formattedLine as necessary + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatLineCommentOpener() +{ + assert(isSequenceReached("//")); + + if ((int) currentLine.length() > charNum + 2 + && currentLine[charNum + 2] == '\xf2') // check for windows line marker + isAppendPostBlockEmptyLineRequested = false; + + isInLineComment = true; + isCharImmediatelyPostComment = false; + if (previousNonWSChar == '}') + resetEndOfStatement(); + + // Check for a following header. + // For speed do not check multiple comment lines more than once. + // For speed do not check shouldBreakBlocks if previous line is empty, a comment, or a '{'. + const string* followingHeader = nullptr; + if ((lineIsLineCommentOnly + && !isImmediatelyPostCommentOnly + && isBraceType(braceTypeStack->back(), COMMAND_TYPE)) + && (shouldBreakElseIfs + || isInSwitchStatement() + || (shouldBreakBlocks + && !isImmediatelyPostEmptyLine + && previousCommandChar != '{'))) + followingHeader = checkForHeaderFollowingComment(currentLine.substr(charNum)); + + // do not indent if in column 1 or 2 + // or in a namespace before the opening brace + if ((!shouldIndentCol1Comments && !lineCommentNoIndent) + || foundNamespaceHeader) + { + if (charNum == 0) + lineCommentNoIndent = true; + else if (charNum == 1 && currentLine[0] == ' ') + lineCommentNoIndent = true; + } + // move comment if spaces were added or deleted + if (!lineCommentNoIndent && spacePadNum != 0 && !isInLineBreak) + adjustComments(); + formattedLineCommentNum = formattedLine.length(); + + // must be done BEFORE appendSequence + // check for run-in statement + if (previousCommandChar == '{' + && !isImmediatelyPostComment + && !isImmediatelyPostLineComment) + { + if (braceFormatMode == NONE_MODE) + { + if (currentLineBeginsWithBrace) + formatRunIn(); + } + else if (braceFormatMode == RUN_IN_MODE) + { + if (!lineCommentNoIndent) + formatRunIn(); + else + isInLineBreak = true; + } + else if (braceFormatMode == BREAK_MODE) + { + if (formattedLine.length() > 0 && formattedLine[0] == '{') + isInLineBreak = true; + } + else + { + if (currentLineBeginsWithBrace) + isInLineBreak = true; + } + } + + // ASBeautifier needs to know the following statements + if (shouldBreakElseIfs && followingHeader == &AS_ELSE) + elseHeaderFollowsComments = true; + if (followingHeader == &AS_CASE || followingHeader == &AS_DEFAULT) + caseHeaderFollowsComments = true; + + // appendSequence will write the previous line + appendSequence(AS_OPEN_LINE_COMMENT); + goForward(1); + + // must be done AFTER appendSequence + + // Break before the comment if a header follows the line comment. + // But do not break if previous line is empty, a comment, or a '{'. + if (shouldBreakBlocks + && followingHeader != nullptr + && !isImmediatelyPostEmptyLine + && previousCommandChar != '{') + { + if (isClosingHeader(followingHeader)) + { + if (!shouldBreakClosingHeaderBlocks) + isPrependPostBlockEmptyLineRequested = false; + } + // if an opening header, break before the comment + else + isPrependPostBlockEmptyLineRequested = true; + } + + if (previousCommandChar == '}') + currentHeader = nullptr; + + // if tabbed input don't convert the immediately following tabs to spaces + if (getIndentString() == "\t" && lineCommentNoIndent) + { + while (charNum + 1 < (int) currentLine.length() + && currentLine[charNum + 1] == '\t') + { + currentChar = currentLine[++charNum]; + appendCurrentChar(); + } + } + + // explicitly break a line when a line comment's end is found. + if (charNum + 1 == (int) currentLine.length()) + { + isInLineBreak = true; + isInLineComment = false; + isImmediatelyPostLineComment = true; + currentChar = 0; //make sure it is a neutral char. + } +} + +/** + * format quote body + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatQuoteBody() +{ + assert(isInQuote); + + if (isSpecialChar) + { + isSpecialChar = false; + } + else if (currentChar == '\\' && !isInVerbatimQuote) + { + if (peekNextChar() == ' ') // is this '\' at end of line + haveLineContinuationChar = true; + else + isSpecialChar = true; + } + else if (isInVerbatimQuote && currentChar == '"') + { + if (isCStyle()) + { + string delim = ')' + verbatimDelimiter; + int delimStart = charNum - delim.length(); + if (delimStart > 0 && currentLine.substr(delimStart, delim.length()) == delim) + { + isInQuote = false; + isInVerbatimQuote = false; + } + } + else if (isSharpStyle()) + { + if ((int) currentLine.length() > charNum + 1 + && currentLine[charNum + 1] == '"') // check consecutive quotes + { + appendSequence("\"\""); + goForward(1); + return; + } + isInQuote = false; + isInVerbatimQuote = false; + } + } + else if (quoteChar == currentChar) + { + isInQuote = false; + } + + appendCurrentChar(); + + // append the text to the ending quoteChar or an escape sequence + // tabs in quotes are NOT changed by convert-tabs + if (isInQuote && currentChar != '\\') + { + while (charNum + 1 < (int) currentLine.length() + && currentLine[charNum + 1] != quoteChar + && currentLine[charNum + 1] != '\\') + { + currentChar = currentLine[++charNum]; + appendCurrentChar(); + } + } + if (charNum + 1 >= (int) currentLine.length() + && currentChar != '\\' + && !isInVerbatimQuote) + isInQuote = false; // missing closing quote +} + +/** + * format a quote opener + * the quote opener will be appended to the current formattedLine or a new formattedLine as necessary + * the calling function should have a continue statement after calling this method + */ +void ASFormatter::formatQuoteOpener() +{ + assert(currentChar == '"' + || (currentChar == '\'' && !isDigitSeparator(currentLine, charNum))); + + isInQuote = true; + quoteChar = currentChar; + if (isCStyle() && previousChar == 'R') + { + int parenPos = currentLine.find('(', charNum); + if (parenPos != -1) + { + isInVerbatimQuote = true; + verbatimDelimiter = currentLine.substr(charNum + 1, parenPos - charNum - 1); + } + } + else if (isSharpStyle() && previousChar == '@') + isInVerbatimQuote = true; + + // a quote following a brace is an array + if (previousCommandChar == '{' + && !isImmediatelyPostComment + && !isImmediatelyPostLineComment + && isNonInStatementArray + && !isBraceType(braceTypeStack->back(), SINGLE_LINE_TYPE) + && !isWhiteSpace(peekNextChar())) + { + if (braceFormatMode == NONE_MODE) + { + if (currentLineBeginsWithBrace) + formatRunIn(); + } + else if (braceFormatMode == RUN_IN_MODE) + { + formatRunIn(); + } + else if (braceFormatMode == BREAK_MODE) + { + if (formattedLine.length() > 0 && formattedLine[0] == '{') + isInLineBreak = true; + } + else + { + if (currentLineBeginsWithBrace) + isInLineBreak = true; + } + } + previousCommandChar = ' '; + appendCurrentChar(); +} + +/** + * get the next line comment adjustment that results from breaking a closing brace. + * the brace must be on the same line as the closing header. + * i.e "} else" changed to "} else". + */ +int ASFormatter::getNextLineCommentAdjustment() +{ + assert(foundClosingHeader && previousNonWSChar == '}'); + if (charNum < 1) // "else" is in column 1 + return 0; + size_t lastBrace = currentLine.rfind('}', charNum - 1); + if (lastBrace != string::npos) + return (lastBrace - charNum); // return a negative number + return 0; +} + +// for console build only +LineEndFormat ASFormatter::getLineEndFormat() const +{ + return lineEnd; +} + +/** + * get the current line comment adjustment that results from attaching + * a closing header to a closing brace. + * the brace must be on the line previous to the closing header. + * the adjustment is 2 chars, one for the brace and one for the space. + * i.e "} else" changed to "} else". + */ +int ASFormatter::getCurrentLineCommentAdjustment() +{ + assert(foundClosingHeader && previousNonWSChar == '}'); + if (charNum < 1) + return 2; + size_t lastBrace = currentLine.rfind('}', charNum - 1); + if (lastBrace == string::npos) + return 2; + return 0; +} + +/** + * get the previous word on a line + * the argument 'currPos' must point to the current position. + * + * @return is the previous word or an empty string if none found. + */ +string ASFormatter::getPreviousWord(const string& line, int currPos) const +{ + // get the last legal word (may be a number) + if (currPos == 0) + return string(); + + size_t end = line.find_last_not_of(" \t", currPos - 1); + if (end == string::npos || !isLegalNameChar(line[end])) + return string(); + + int start; // start of the previous word + for (start = end; start > -1; start--) + { + if (!isLegalNameChar(line[start]) || line[start] == '.') + break; + } + start++; + + return (line.substr(start, end - start + 1)); +} + +/** + * check if a line break is needed when a closing brace + * is followed by a closing header. + * the break depends on the braceFormatMode and other factors. + */ +void ASFormatter::isLineBreakBeforeClosingHeader() +{ + assert(foundClosingHeader && previousNonWSChar == '}'); + + if (currentHeader == &AS_WHILE && shouldAttachClosingWhile) + { + appendClosingHeader(); + return; + } + + if (braceFormatMode == BREAK_MODE + || braceFormatMode == RUN_IN_MODE + || attachClosingBraceMode) + { + isInLineBreak = true; + } + else if (braceFormatMode == NONE_MODE) + { + if (shouldBreakClosingHeaderBraces + || getBraceIndent() || getBlockIndent()) + { + isInLineBreak = true; + } + else + { + appendSpacePad(); + // is closing brace broken? + size_t i = currentLine.find_first_not_of(" \t"); + if (i != string::npos && currentLine[i] == '}') + isInLineBreak = false; + + if (shouldBreakBlocks) + isAppendPostBlockEmptyLineRequested = false; + } + } + // braceFormatMode == ATTACH_MODE, LINUX_MODE + else + { + if (shouldBreakClosingHeaderBraces + || getBraceIndent() || getBlockIndent()) + { + isInLineBreak = true; + } + else + { + appendClosingHeader(); + if (shouldBreakBlocks) + isAppendPostBlockEmptyLineRequested = false; + } + } +} + +/** + * Append a closing header to the previous closing brace, if possible + */ +void ASFormatter::appendClosingHeader() +{ + // if a blank line does not precede this + // or last line is not a one line block, attach header + bool previousLineIsEmpty = isEmptyLine(formattedLine); + int previousLineIsOneLineBlock = 0; + size_t firstBrace = findNextChar(formattedLine, '{'); + if (firstBrace != string::npos) + previousLineIsOneLineBlock = isOneLineBlockReached(formattedLine, firstBrace); + if (!previousLineIsEmpty + && previousLineIsOneLineBlock == 0) + { + isInLineBreak = false; + appendSpacePad(); + spacePadNum = 0; // don't count as comment padding + } +} + +/** + * Add braces to a single line statement following a header. + * braces are not added if the proper conditions are not met. + * braces are added to the currentLine. + */ +bool ASFormatter::addBracesToStatement() +{ + assert(isImmediatelyPostHeader); + + if (currentHeader != &AS_IF + && currentHeader != &AS_ELSE + && currentHeader != &AS_FOR + && currentHeader != &AS_WHILE + && currentHeader != &AS_DO + && currentHeader != &AS_FOREACH + && currentHeader != &AS_QFOREACH + && currentHeader != &AS_QFOREVER + && currentHeader != &AS_FOREVER) + return false; + + if (currentHeader == &AS_WHILE && foundClosingHeader) // do-while + return false; + + // do not brace an empty statement + if (currentChar == ';') + return false; + + // do not add if a header follows + if (isCharPotentialHeader(currentLine, charNum)) + if (findHeader(headers) != nullptr) + return false; + + // find the next semi-colon + size_t nextSemiColon = charNum; + if (currentChar != ';') + nextSemiColon = findNextChar(currentLine, ';', charNum + 1); + if (nextSemiColon == string::npos) + return false; + + // add closing brace before changing the line length + if (nextSemiColon == currentLine.length() - 1) + currentLine.append(" }"); + else + currentLine.insert(nextSemiColon + 1, " }"); + // add opening brace + currentLine.insert(charNum, "{ "); + assert(computeChecksumIn("{}")); + currentChar = '{'; + if ((int) currentLine.find_first_not_of(" \t") == charNum) + currentLineBeginsWithBrace = true; + // remove extra spaces + if (!shouldAddOneLineBraces) + { + size_t lastText = formattedLine.find_last_not_of(" \t"); + if ((formattedLine.length() - 1) - lastText > 1) + formattedLine.erase(lastText + 1); + } + return true; +} + +/** + * Remove braces from a single line statement following a header. + * braces are not removed if the proper conditions are not met. + * The first brace is replaced by a space. + */ +bool ASFormatter::removeBracesFromStatement() +{ + assert(isImmediatelyPostHeader); + assert(currentChar == '{'); + + if (currentHeader != &AS_IF + && currentHeader != &AS_ELSE + && currentHeader != &AS_FOR + && currentHeader != &AS_WHILE + && currentHeader != &AS_FOREACH) + return false; + + if (currentHeader == &AS_WHILE && foundClosingHeader) // do-while + return false; + + bool isFirstLine = true; + string nextLine_; + // leave nextLine_ empty if end of line comment follows + if (!isBeforeAnyLineEndComment(charNum) || currentLineBeginsWithBrace) + nextLine_ = currentLine.substr(charNum + 1); + size_t nextChar = 0; + + // find the first non-blank text + ASPeekStream stream(sourceIterator); + while (stream.hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + { + nextLine_ = stream.peekNextLine(); + nextChar = 0; + } + + nextChar = nextLine_.find_first_not_of(" \t", nextChar); + if (nextChar != string::npos) + break; + } + + // don't remove if comments or a header follow the brace + if ((nextLine_.compare(nextChar, 2, "/*") == 0) + || (nextLine_.compare(nextChar, 2, "//") == 0) + || (isCharPotentialHeader(nextLine_, nextChar) + && ASBase::findHeader(nextLine_, nextChar, headers) != nullptr)) + return false; + + // find the next semi-colon + size_t nextSemiColon = nextChar; + if (nextLine_[nextChar] != ';') + nextSemiColon = findNextChar(nextLine_, ';', nextChar + 1); + if (nextSemiColon == string::npos) + return false; + + // find the closing brace + isFirstLine = true; + nextChar = nextSemiColon + 1; + while (stream.hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + { + nextLine_ = stream.peekNextLine(); + nextChar = 0; + } + nextChar = nextLine_.find_first_not_of(" \t", nextChar); + if (nextChar != string::npos) + break; + } + if (nextLine_.length() == 0 || nextLine_[nextChar] != '}') + return false; + + // remove opening brace + currentLine[charNum] = currentChar = ' '; + assert(adjustChecksumIn(-'{')); + return true; +} + +/** + * Find the next character that is not in quotes or a comment. + * + * @param line the line to be searched. + * @param searchChar the char to find. + * @param searchStart the start position on the line (default is 0). + * @return the position on the line or string::npos if not found. + */ +size_t ASFormatter::findNextChar(const string& line, char searchChar, int searchStart /*0*/) const +{ + // find the next searchChar + size_t i; + for (i = searchStart; i < line.length(); i++) + { + if (line.compare(i, 2, "//") == 0) + return string::npos; + if (line.compare(i, 2, "/*") == 0) + { + size_t endComment = line.find("*/", i + 2); + if (endComment == string::npos) + return string::npos; + i = endComment + 2; + if (i >= line.length()) + return string::npos; + } + if (line[i] == '"' + || (line[i] == '\'' && !isDigitSeparator(line, i))) + { + char quote = line[i]; + while (i < line.length()) + { + size_t endQuote = line.find(quote, i + 1); + if (endQuote == string::npos) + return string::npos; + i = endQuote; + if (line[endQuote - 1] != '\\') // check for '\"' + break; + if (line[endQuote - 2] == '\\') // check for '\\' + break; + } + } + + if (line[i] == searchChar) + break; + + // for now don't process C# 'delegate' braces + // do this last in case the search char is a '{' + if (line[i] == '{') + return string::npos; + } + if (i >= line.length()) // didn't find searchChar + return string::npos; + + return i; +} + +/** + * Look ahead in the file to see if a struct has access modifiers. + * + * @param firstLine a reference to the line to indent. + * @param index the current line index. + * @return true if the struct has access modifiers. + */ +bool ASFormatter::isStructAccessModified(const string& firstLine, size_t index) const +{ + assert(firstLine[index] == '{'); + assert(isCStyle()); + + bool isFirstLine = true; + size_t braceCount = 1; + string nextLine_ = firstLine.substr(index + 1); + ASPeekStream stream(sourceIterator); + + // find the first non-blank text, bypassing all comments and quotes. + bool isInComment_ = false; + bool isInQuote_ = false; + char quoteChar_ = ' '; + while (stream.hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + nextLine_ = stream.peekNextLine(); + // parse the line + for (size_t i = 0; i < nextLine_.length(); i++) + { + if (isWhiteSpace(nextLine_[i])) + continue; + if (nextLine_.compare(i, 2, "/*") == 0) + isInComment_ = true; + if (isInComment_) + { + if (nextLine_.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + if (nextLine_[i] == '\\') + { + ++i; + continue; + } + + if (isInQuote_) + { + if (nextLine_[i] == quoteChar_) + isInQuote_ = false; + continue; + } + + if (nextLine_[i] == '"' + || (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i))) + { + isInQuote_ = true; + quoteChar_ = nextLine_[i]; + continue; + } + if (nextLine_.compare(i, 2, "//") == 0) + { + i = nextLine_.length(); + continue; + } + // handle braces + if (nextLine_[i] == '{') + ++braceCount; + if (nextLine_[i] == '}') + --braceCount; + if (braceCount == 0) + return false; + // check for access modifiers + if (isCharPotentialHeader(nextLine_, i)) + { + if (findKeyword(nextLine_, i, AS_PUBLIC) + || findKeyword(nextLine_, i, AS_PRIVATE) + || findKeyword(nextLine_, i, AS_PROTECTED)) + return true; + string name = getCurrentWord(nextLine_, i); + i += name.length() - 1; + } + } // end of for loop + } // end of while loop + + return false; +} + +/** +* Look ahead in the file to see if a preprocessor block is indentable. +* +* @param firstLine a reference to the line to indent. +* @param index the current line index. +* @return true if the block is indentable. +*/ +bool ASFormatter::isIndentablePreprocessorBlock(const string& firstLine, size_t index) +{ + assert(firstLine[index] == '#'); + + bool isFirstLine = true; + bool isInIndentableBlock = false; + bool blockContainsBraces = false; + bool blockContainsDefineContinuation = false; + bool isInClassConstructor = false; + bool isPotentialHeaderGuard = false; // ifndef is first preproc statement + bool isPotentialHeaderGuard2 = false; // define is within the first proproc + int numBlockIndents = 0; + int lineParenCount = 0; + string nextLine_ = firstLine.substr(index); + auto stream = make_shared(sourceIterator); + + // find end of the block, bypassing all comments and quotes. + bool isInComment_ = false; + bool isInQuote_ = false; + char quoteChar_ = ' '; + while (stream->hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + nextLine_ = stream->peekNextLine(); + // parse the line + for (size_t i = 0; i < nextLine_.length(); i++) + { + if (isWhiteSpace(nextLine_[i])) + continue; + if (nextLine_.compare(i, 2, "/*") == 0) + isInComment_ = true; + if (isInComment_) + { + if (nextLine_.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + if (nextLine_[i] == '\\') + { + ++i; + continue; + } + if (isInQuote_) + { + if (nextLine_[i] == quoteChar_) + isInQuote_ = false; + continue; + } + + if (nextLine_[i] == '"' + || (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i))) + { + isInQuote_ = true; + quoteChar_ = nextLine_[i]; + continue; + } + if (nextLine_.compare(i, 2, "//") == 0) + { + i = nextLine_.length(); + continue; + } + // handle preprocessor statement + if (nextLine_[i] == '#') + { + string preproc = ASBeautifier::extractPreprocessorStatement(nextLine_); + if (preproc.length() >= 2 && preproc.substr(0, 2) == "if") // #if, #ifdef, #ifndef + { + numBlockIndents += 1; + isInIndentableBlock = true; + // flag first preprocessor conditional for header include guard check + if (!processedFirstConditional) + { + processedFirstConditional = true; + isFirstPreprocConditional = true; + if (isNDefPreprocStatement(nextLine_, preproc)) + isPotentialHeaderGuard = true; + } + } + else if (preproc == "endif") + { + if (numBlockIndents > 0) + numBlockIndents -= 1; + // must exit BOTH loops + if (numBlockIndents == 0) + goto EndOfWhileLoop; + } + else if (preproc == "define") + { + if (nextLine_[nextLine_.length() - 1] == '\\') + blockContainsDefineContinuation = true; + // check for potential header include guards + else if (isPotentialHeaderGuard && numBlockIndents == 1) + isPotentialHeaderGuard2 = true; + } + i = nextLine_.length(); + continue; + } + // handle exceptions + if (nextLine_[i] == '{' || nextLine_[i] == '}') + blockContainsBraces = true; + else if (nextLine_[i] == '(') + ++lineParenCount; + else if (nextLine_[i] == ')') + --lineParenCount; + else if (nextLine_[i] == ':') + { + // check for '::' + if (nextLine_.length() > i && nextLine_[i + 1] == ':') + ++i; + else + isInClassConstructor = true; + } + // bypass unnecessary parsing - must exit BOTH loops + if (blockContainsBraces || isInClassConstructor || blockContainsDefineContinuation) + goto EndOfWhileLoop; + } // end of for loop, end of line + if (lineParenCount != 0) + break; + } // end of while loop +EndOfWhileLoop: + preprocBlockEnd = sourceIterator->tellg(); + if (preprocBlockEnd < 0) + preprocBlockEnd = sourceIterator->getStreamLength(); + if (blockContainsBraces + || isInClassConstructor + || blockContainsDefineContinuation + || lineParenCount != 0 + || numBlockIndents != 0) + isInIndentableBlock = false; + // find next executable instruction + // this WILL RESET the get pointer + string nextText = peekNextText("", false, stream); + // bypass header include guards + if (isFirstPreprocConditional) + { + isFirstPreprocConditional = false; + if (nextText.empty() && isPotentialHeaderGuard2) + { + isInIndentableBlock = false; + preprocBlockEnd = 0; + } + } + // this allows preprocessor blocks within this block to be indented + if (!isInIndentableBlock) + preprocBlockEnd = 0; + // peekReset() is done by previous peekNextText() + return isInIndentableBlock; +} + +bool ASFormatter::isNDefPreprocStatement(const string& nextLine_, const string& preproc) const +{ + if (preproc == "ifndef") + return true; + // check for '!defined' + if (preproc == "if") + { + size_t i = nextLine_.find('!'); + if (i == string::npos) + return false; + i = nextLine_.find_first_not_of(" \t", ++i); + if (i != string::npos && nextLine_.compare(i, 7, "defined") == 0) + return true; + } + return false; +} + +/** + * Check to see if this is an EXEC SQL statement. + * + * @param line a reference to the line to indent. + * @param index the current line index. + * @return true if the statement is EXEC SQL. + */ +bool ASFormatter::isExecSQL(const string& line, size_t index) const +{ + if (line[index] != 'e' && line[index] != 'E') // quick check to reject most + return false; + string word; + if (isCharPotentialHeader(line, index)) + word = getCurrentWord(line, index); + for (size_t i = 0; i < word.length(); i++) + word[i] = (char) toupper(word[i]); + if (word != "EXEC") + return false; + size_t index2 = index + word.length(); + index2 = line.find_first_not_of(" \t", index2); + if (index2 == string::npos) + return false; + word.erase(); + if (isCharPotentialHeader(line, index2)) + word = getCurrentWord(line, index2); + for (size_t i = 0; i < word.length(); i++) + word[i] = (char) toupper(word[i]); + if (word != "SQL") + return false; + return true; +} + +/** + * The continuation lines must be adjusted so the leading spaces + * is equivalent to the text on the opening line. + * + * Updates currentLine and charNum. + */ +void ASFormatter::trimContinuationLine() +{ + size_t len = currentLine.length(); + size_t tabSize = getTabLength(); + charNum = 0; + + if (leadingSpaces > 0 && len > 0) + { + size_t i; + size_t continuationIncrementIn = 0; + for (i = 0; (i < len) && (i + continuationIncrementIn < leadingSpaces); i++) + { + if (!isWhiteSpace(currentLine[i])) // don't delete any text + { + if (i < continuationIncrementIn) + leadingSpaces = i + tabIncrementIn; + continuationIncrementIn = tabIncrementIn; + break; + } + if (currentLine[i] == '\t') + continuationIncrementIn += tabSize - 1 - ((continuationIncrementIn + i) % tabSize); + } + + if ((int) continuationIncrementIn == tabIncrementIn) + charNum = i; + else + { + // build a new line with the equivalent leading chars + string newLine; + int leadingChars = 0; + if ((int) leadingSpaces > tabIncrementIn) + leadingChars = leadingSpaces - tabIncrementIn; + newLine.append(leadingChars, ' '); + newLine.append(currentLine, i, len - i); + currentLine = newLine; + charNum = leadingChars; + if (currentLine.length() == 0) + currentLine = string(" "); // a null is inserted if this is not done + } + if (i >= len) + charNum = 0; + } +} + +/** + * Determine if a header is a closing header + * + * @return true if the header is a closing header. + */ +bool ASFormatter::isClosingHeader(const string* header) const +{ + return (header == &AS_ELSE + || header == &AS_CATCH + || header == &AS_FINALLY); +} + +/** + * Determine if a * following a closing paren is immediately. + * after a cast. If so it is a deference and not a multiply. + * e.g. "(int*) *ptr" is a deference. + */ +bool ASFormatter::isImmediatelyPostCast() const +{ + assert(previousNonWSChar == ')' && currentChar == '*'); + // find preceding closing paren on currentLine or readyFormattedLine + string line; // currentLine or readyFormattedLine + size_t paren = currentLine.rfind(')', charNum); + if (paren != string::npos) + line = currentLine; + // if not on currentLine it must be on the previous line + else + { + line = readyFormattedLine; + paren = line.rfind(')'); + if (paren == string::npos) + return false; + } + if (paren == 0) + return false; + + // find character preceding the closing paren + size_t lastChar = line.find_last_not_of(" \t", paren - 1); + if (lastChar == string::npos) + return false; + // check for pointer cast + if (line[lastChar] == '*') + return true; + return false; +} + +/** + * Determine if a < is a template definition or instantiation. + * Sets the class variables isInTemplate and templateDepth. + */ +void ASFormatter::checkIfTemplateOpener() +{ + assert(!isInTemplate && currentChar == '<'); + + // find first char after the '<' operators + size_t firstChar = currentLine.find_first_not_of("< \t", charNum); + if (firstChar == string::npos + || currentLine[firstChar] == '=') + { + // this is not a template -> leave... + isInTemplate = false; + return; + } + + bool isFirstLine = true; + int parenDepth_ = 0; + int maxTemplateDepth = 0; + templateDepth = 0; + string nextLine_ = currentLine.substr(charNum); + ASPeekStream stream(sourceIterator); + + // find the angle braces, bypassing all comments and quotes. + bool isInComment_ = false; + bool isInQuote_ = false; + char quoteChar_ = ' '; + while (stream.hasMoreLines() || isFirstLine) + { + if (isFirstLine) + isFirstLine = false; + else + nextLine_ = stream.peekNextLine(); + // parse the line + for (size_t i = 0; i < nextLine_.length(); i++) + { + char currentChar_ = nextLine_[i]; + if (isWhiteSpace(currentChar_)) + continue; + if (nextLine_.compare(i, 2, "/*") == 0) + isInComment_ = true; + if (isInComment_) + { + if (nextLine_.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + if (currentChar_ == '\\') + { + ++i; + continue; + } + + if (isInQuote_) + { + if (currentChar_ == quoteChar_) + isInQuote_ = false; + continue; + } + + if (currentChar_ == '"' + || (currentChar_ == '\'' && !isDigitSeparator(nextLine_, i))) + { + isInQuote_ = true; + quoteChar_ = currentChar_; + continue; + } + if (nextLine_.compare(i, 2, "//") == 0) + { + i = nextLine_.length(); + continue; + } + + // not in a comment or quote + if (currentChar_ == '<') + { + ++templateDepth; + ++maxTemplateDepth; + continue; + } + else if (currentChar_ == '>') + { + --templateDepth; + if (templateDepth == 0) + { + if (parenDepth_ == 0) + { + // this is a template! + isInTemplate = true; + templateDepth = maxTemplateDepth; + } + return; + } + continue; + } + else if (currentChar_ == '(' || currentChar_ == ')') + { + if (currentChar_ == '(') + ++parenDepth_; + else + --parenDepth_; + if (parenDepth_ >= 0) + continue; + // this is not a template -> leave... + isInTemplate = false; + templateDepth = 0; + return; + } + else if (nextLine_.compare(i, 2, AS_AND) == 0 + || nextLine_.compare(i, 2, AS_OR) == 0) + { + // this is not a template -> leave... + isInTemplate = false; + templateDepth = 0; + return; + } + else if (currentChar_ == ',' // comma, e.g. A + || currentChar_ == '&' // reference, e.g. A + || currentChar_ == '*' // pointer, e.g. A + || currentChar_ == '^' // C++/CLI managed pointer, e.g. A + || currentChar_ == ':' // ::, e.g. std::string + || currentChar_ == '=' // assign e.g. default parameter + || currentChar_ == '[' // [] e.g. string[] + || currentChar_ == ']' // [] e.g. string[] + || currentChar_ == '(' // (...) e.g. function definition + || currentChar_ == ')' // (...) e.g. function definition + || (isJavaStyle() && currentChar_ == '?') // Java wildcard + ) + { + continue; + } + else if (!isLegalNameChar(currentChar_)) + { + // this is not a template -> leave... + isInTemplate = false; + templateDepth = 0; + return; + } + string name = getCurrentWord(nextLine_, i); + i += name.length() - 1; + } // end for loop + } // end while loop +} + +void ASFormatter::updateFormattedLineSplitPoints(char appendedChar) +{ + assert(maxCodeLength != string::npos); + assert(formattedLine.length() > 0); + + if (!isOkToSplitFormattedLine()) + return; + + char nextChar = peekNextChar(); + + // don't split before an end of line comment + if (nextChar == '/') + return; + + // don't split before or after a brace + if (appendedChar == '{' || appendedChar == '}' + || previousNonWSChar == '{' || previousNonWSChar == '}' + || nextChar == '{' || nextChar == '}' + || currentChar == '{' || currentChar == '}') // currentChar tests for an appended brace + return; + + // don't split before or after a block paren + if (appendedChar == '[' || appendedChar == ']' + || previousNonWSChar == '[' + || nextChar == '[' || nextChar == ']') + return; + + if (isWhiteSpace(appendedChar)) + { + if (nextChar != ')' // space before a closing paren + && nextChar != '(' // space before an opening paren + && nextChar != '/' // space before a comment + && nextChar != ':' // space before a colon + && currentChar != ')' // appended space before and after a closing paren + && currentChar != '(' // appended space before and after a opening paren + && previousNonWSChar != '(' // decided at the '(' + // don't break before a pointer or reference aligned to type + && !(nextChar == '*' + && !isCharPotentialOperator(previousNonWSChar) + && pointerAlignment == PTR_ALIGN_TYPE) + && !(nextChar == '&' + && !isCharPotentialOperator(previousNonWSChar) + && (referenceAlignment == REF_ALIGN_TYPE + || (referenceAlignment == REF_SAME_AS_PTR && pointerAlignment == PTR_ALIGN_TYPE))) + ) + { + if (formattedLine.length() - 1 <= maxCodeLength) + maxWhiteSpace = formattedLine.length() - 1; + else + maxWhiteSpacePending = formattedLine.length() - 1; + } + } + // unpadded closing parens may split after the paren (counts as whitespace) + else if (appendedChar == ')') + { + if (nextChar != ')' + && nextChar != ' ' + && nextChar != ';' + && nextChar != ',' + && nextChar != '.' + && !(nextChar == '-' && pointerSymbolFollows())) // check for -> + { + if (formattedLine.length() <= maxCodeLength) + maxWhiteSpace = formattedLine.length(); + else + maxWhiteSpacePending = formattedLine.length(); + } + } + // unpadded commas may split after the comma + else if (appendedChar == ',') + { + if (formattedLine.length() <= maxCodeLength) + maxComma = formattedLine.length(); + else + maxCommaPending = formattedLine.length(); + } + else if (appendedChar == '(') + { + if (nextChar != ')' && nextChar != '(' && nextChar != '"' && nextChar != '\'') + { + // if follows an operator break before + size_t parenNum; + if (isCharPotentialOperator(previousNonWSChar)) + parenNum = formattedLine.length() - 1; + else + parenNum = formattedLine.length(); + if (formattedLine.length() <= maxCodeLength) + maxParen = parenNum; + else + maxParenPending = parenNum; + } + } + else if (appendedChar == ';') + { + if (nextChar != ' ' && nextChar != '}' && nextChar != '/') // check for following comment + { + if (formattedLine.length() <= maxCodeLength) + maxSemi = formattedLine.length(); + else + maxSemiPending = formattedLine.length(); + } + } +} + +void ASFormatter::updateFormattedLineSplitPointsOperator(const string& sequence) +{ + assert(maxCodeLength != string::npos); + assert(formattedLine.length() > 0); + + if (!isOkToSplitFormattedLine()) + return; + + char nextChar = peekNextChar(); + + // don't split before an end of line comment + if (nextChar == '/') + return; + + // check for logical conditional + if (sequence == "||" || sequence == "&&" || sequence == "or" || sequence == "and") + { + if (shouldBreakLineAfterLogical) + { + if (formattedLine.length() <= maxCodeLength) + maxAndOr = formattedLine.length(); + else + maxAndOrPending = formattedLine.length(); + } + else + { + // adjust for leading space in the sequence + size_t sequenceLength = sequence.length(); + if (formattedLine.length() > sequenceLength + && isWhiteSpace(formattedLine[formattedLine.length() - sequenceLength - 1])) + sequenceLength++; + if (formattedLine.length() - sequenceLength <= maxCodeLength) + maxAndOr = formattedLine.length() - sequenceLength; + else + maxAndOrPending = formattedLine.length() - sequenceLength; + } + } + // comparison operators will split after the operator (counts as whitespace) + else if (sequence == "==" || sequence == "!=" || sequence == ">=" || sequence == "<=") + { + if (formattedLine.length() <= maxCodeLength) + maxWhiteSpace = formattedLine.length(); + else + maxWhiteSpacePending = formattedLine.length(); + } + // unpadded operators that will split BEFORE the operator (counts as whitespace) + else if (sequence == "+" || sequence == "-" || sequence == "?") + { + if (charNum > 0 + && !(sequence == "+" && isInExponent()) + && !(sequence == "-" && isInExponent()) + && (isLegalNameChar(currentLine[charNum - 1]) + || currentLine[charNum - 1] == ')' + || currentLine[charNum - 1] == ']' + || currentLine[charNum - 1] == '\"')) + { + if (formattedLine.length() - 1 <= maxCodeLength) + maxWhiteSpace = formattedLine.length() - 1; + else + maxWhiteSpacePending = formattedLine.length() - 1; + } + } + // unpadded operators that will USUALLY split AFTER the operator (counts as whitespace) + else if (sequence == "=" || sequence == ":") + { + // split BEFORE if the line is too long + // do NOT use <= here, must allow for a brace attached to an array + size_t splitPoint = 0; + if (formattedLine.length() < maxCodeLength) + splitPoint = formattedLine.length(); + else + splitPoint = formattedLine.length() - 1; + // padded or unpadded arrays + if (previousNonWSChar == ']') + { + if (formattedLine.length() - 1 <= maxCodeLength) + maxWhiteSpace = splitPoint; + else + maxWhiteSpacePending = splitPoint; + } + else if (charNum > 0 + && (isLegalNameChar(currentLine[charNum - 1]) + || currentLine[charNum - 1] == ')' + || currentLine[charNum - 1] == ']')) + { + if (formattedLine.length() <= maxCodeLength) + maxWhiteSpace = splitPoint; + else + maxWhiteSpacePending = splitPoint; + } + } +} + +/** + * Update the split point when a pointer or reference is formatted. + * The argument is the maximum index of the last whitespace character. + */ +void ASFormatter::updateFormattedLineSplitPointsPointerOrReference(size_t index) +{ + assert(maxCodeLength != string::npos); + assert(formattedLine.length() > 0); + assert(index < formattedLine.length()); + + if (!isOkToSplitFormattedLine()) + return; + + if (index < maxWhiteSpace) // just in case + return; + + if (index <= maxCodeLength) + maxWhiteSpace = index; + else + maxWhiteSpacePending = index; +} + +bool ASFormatter::isOkToSplitFormattedLine() +{ + assert(maxCodeLength != string::npos); + // Is it OK to split the line? + if (shouldKeepLineUnbroken + || isInLineComment + || isInComment + || isInQuote + || isInCase + || isInPreprocessor + || isInExecSQL + || isInAsm || isInAsmOneLine || isInAsmBlock + || isInTemplate) + return false; + + if (!isOkToBreakBlock(braceTypeStack->back()) && currentChar != '{') + { + shouldKeepLineUnbroken = true; + clearFormattedLineSplitPoints(); + return false; + } + if (isBraceType(braceTypeStack->back(), ARRAY_TYPE)) + { + shouldKeepLineUnbroken = true; + if (!isBraceType(braceTypeStack->back(), ARRAY_NIS_TYPE)) + clearFormattedLineSplitPoints(); + return false; + } + return true; +} + +/* This is called if the option maxCodeLength is set. + */ +void ASFormatter::testForTimeToSplitFormattedLine() +{ + // DO NOT ASSERT maxCodeLength HERE + // should the line be split + if (formattedLine.length() > maxCodeLength && !isLineReady) + { + size_t splitPoint = findFormattedLineSplitPoint(); + if (splitPoint > 0 && splitPoint < formattedLine.length()) + { + string splitLine = formattedLine.substr(splitPoint); + formattedLine = formattedLine.substr(0, splitPoint); + breakLine(true); + formattedLine = splitLine; + // if break-blocks is requested and this is a one-line statement + string nextWord = ASBeautifier::getNextWord(currentLine, charNum - 1); + if (isAppendPostBlockEmptyLineRequested + && (nextWord == "break" || nextWord == "continue")) + { + isAppendPostBlockEmptyLineRequested = false; + isPrependPostBlockEmptyLineRequested = true; + } + else + isPrependPostBlockEmptyLineRequested = false; + // adjust max split points + maxAndOr = (maxAndOr > splitPoint) ? (maxAndOr - splitPoint) : 0; + maxSemi = (maxSemi > splitPoint) ? (maxSemi - splitPoint) : 0; + maxComma = (maxComma > splitPoint) ? (maxComma - splitPoint) : 0; + maxParen = (maxParen > splitPoint) ? (maxParen - splitPoint) : 0; + maxWhiteSpace = (maxWhiteSpace > splitPoint) ? (maxWhiteSpace - splitPoint) : 0; + if (maxSemiPending > 0) + { + maxSemi = (maxSemiPending > splitPoint) ? (maxSemiPending - splitPoint) : 0; + maxSemiPending = 0; + } + if (maxAndOrPending > 0) + { + maxAndOr = (maxAndOrPending > splitPoint) ? (maxAndOrPending - splitPoint) : 0; + maxAndOrPending = 0; + } + if (maxCommaPending > 0) + { + maxComma = (maxCommaPending > splitPoint) ? (maxCommaPending - splitPoint) : 0; + maxCommaPending = 0; + } + if (maxParenPending > 0) + { + maxParen = (maxParenPending > splitPoint) ? (maxParenPending - splitPoint) : 0; + maxParenPending = 0; + } + if (maxWhiteSpacePending > 0) + { + maxWhiteSpace = (maxWhiteSpacePending > splitPoint) ? (maxWhiteSpacePending - splitPoint) : 0; + maxWhiteSpacePending = 0; + } + // don't allow an empty formatted line + size_t firstText = formattedLine.find_first_not_of(" \t"); + if (firstText == string::npos && formattedLine.length() > 0) + { + formattedLine.erase(); + clearFormattedLineSplitPoints(); + if (isWhiteSpace(currentChar)) + for (size_t i = charNum + 1; i < currentLine.length() && isWhiteSpace(currentLine[i]); i++) + goForward(1); + } + else if (firstText > 0) + { + formattedLine.erase(0, firstText); + maxSemi = (maxSemi > firstText) ? (maxSemi - firstText) : 0; + maxAndOr = (maxAndOr > firstText) ? (maxAndOr - firstText) : 0; + maxComma = (maxComma > firstText) ? (maxComma - firstText) : 0; + maxParen = (maxParen > firstText) ? (maxParen - firstText) : 0; + maxWhiteSpace = (maxWhiteSpace > firstText) ? (maxWhiteSpace - firstText) : 0; + } + // reset formattedLineCommentNum + if (formattedLineCommentNum != string::npos) + { + formattedLineCommentNum = formattedLine.find("//"); + if (formattedLineCommentNum == string::npos) + formattedLineCommentNum = formattedLine.find("/*"); + } + } + } +} + +size_t ASFormatter::findFormattedLineSplitPoint() const +{ + assert(maxCodeLength != string::npos); + // determine where to split + size_t minCodeLength = 10; + size_t splitPoint = 0; + splitPoint = maxSemi; + if (maxAndOr >= minCodeLength) + splitPoint = maxAndOr; + if (splitPoint < minCodeLength) + { + splitPoint = maxWhiteSpace; + // use maxParen instead if it is long enough + if (maxParen > splitPoint + || maxParen >= maxCodeLength * .7) + splitPoint = maxParen; + // use maxComma instead if it is long enough + // increasing the multiplier causes more splits at whitespace + if (maxComma > splitPoint + || maxComma >= maxCodeLength * .3) + splitPoint = maxComma; + } + // replace split point with first available break point + if (splitPoint < minCodeLength) + { + splitPoint = string::npos; + if (maxSemiPending > 0 && maxSemiPending < splitPoint) + splitPoint = maxSemiPending; + if (maxAndOrPending > 0 && maxAndOrPending < splitPoint) + splitPoint = maxAndOrPending; + if (maxCommaPending > 0 && maxCommaPending < splitPoint) + splitPoint = maxCommaPending; + if (maxParenPending > 0 && maxParenPending < splitPoint) + splitPoint = maxParenPending; + if (maxWhiteSpacePending > 0 && maxWhiteSpacePending < splitPoint) + splitPoint = maxWhiteSpacePending; + if (splitPoint == string::npos) + splitPoint = 0; + } + // if remaining line after split is too long + else if (formattedLine.length() - splitPoint > maxCodeLength) + { + // if end of the currentLine, find a new split point + size_t newCharNum; + if (isCharPotentialHeader(currentLine, charNum)) + newCharNum = getCurrentWord(currentLine, charNum).length() + charNum; + else + newCharNum = charNum + 2; + if (newCharNum + 1 > currentLine.length()) + { + // don't move splitPoint from before a conditional to after + if (maxWhiteSpace > splitPoint + 3) + splitPoint = maxWhiteSpace; + if (maxParen > splitPoint) + splitPoint = maxParen; + } + } + + return splitPoint; +} + +void ASFormatter::clearFormattedLineSplitPoints() +{ + maxSemi = 0; + maxAndOr = 0; + maxComma = 0; + maxParen = 0; + maxWhiteSpace = 0; + maxSemiPending = 0; + maxAndOrPending = 0; + maxCommaPending = 0; + maxParenPending = 0; + maxWhiteSpacePending = 0; +} + +/** + * Check if a pointer symbol (->) follows on the currentLine. + */ +bool ASFormatter::pointerSymbolFollows() const +{ + size_t peekNum = currentLine.find_first_not_of(" \t", charNum + 1); + if (peekNum == string::npos || currentLine.compare(peekNum, 2, "->") != 0) + return false; + return true; +} + +/** + * Compute the input checksum. + * This is called as an assert so it for is debug config only + */ +bool ASFormatter::computeChecksumIn(const string& currentLine_) +{ + for (size_t i = 0; i < currentLine_.length(); i++) + if (!isWhiteSpace(currentLine_[i])) + checksumIn += currentLine_[i]; + return true; +} + +/** + * Adjust the input checksum for deleted chars. + * This is called as an assert so it for is debug config only + */ +bool ASFormatter::adjustChecksumIn(int adjustment) +{ + checksumIn += adjustment; + return true; +} + +/** + * get the value of checksumIn for unit testing + * + * @return checksumIn. + */ +size_t ASFormatter::getChecksumIn() const +{ + return checksumIn; +} + +/** + * Compute the output checksum. + * This is called as an assert so it is for debug config only + */ +bool ASFormatter::computeChecksumOut(const string& beautifiedLine) +{ + for (size_t i = 0; i < beautifiedLine.length(); i++) + if (!isWhiteSpace(beautifiedLine[i])) + checksumOut += beautifiedLine[i]; + return true; +} + +/** + * Return isLineReady for the final check at end of file. + */ +bool ASFormatter::getIsLineReady() const +{ + return isLineReady; +} + +/** + * get the value of checksumOut for unit testing + * + * @return checksumOut. + */ +size_t ASFormatter::getChecksumOut() const +{ + return checksumOut; +} + +/** + * Return the difference in checksums. + * If zero all is okay. + */ +int ASFormatter::getChecksumDiff() const +{ + return checksumOut - checksumIn; +} + +// for unit testing +int ASFormatter::getFormatterFileType() const +{ + return formatterFileType; +} + +// Check if an operator follows the next word. +// The next word must be a legal name. +const string* ASFormatter::getFollowingOperator() const +{ + // find next word + size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextNum == string::npos) + return nullptr; + + if (!isLegalNameChar(currentLine[nextNum])) + return nullptr; + + // bypass next word and following spaces + while (nextNum < currentLine.length()) + { + if (!isLegalNameChar(currentLine[nextNum]) + && !isWhiteSpace(currentLine[nextNum])) + break; + nextNum++; + } + + if (nextNum >= currentLine.length() + || !isCharPotentialOperator(currentLine[nextNum]) + || currentLine[nextNum] == '/') // comment + return nullptr; + + const string* newOperator = ASBase::findOperator(currentLine, nextNum, operators); + return newOperator; +} + +// Check following data to determine if the current character is an array operator. +bool ASFormatter::isArrayOperator() const +{ + assert(currentChar == '*' || currentChar == '&' || currentChar == '^'); + assert(isBraceType(braceTypeStack->back(), ARRAY_TYPE)); + + // find next word + size_t nextNum = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextNum == string::npos) + return false; + + if (!isLegalNameChar(currentLine[nextNum])) + return false; + + // bypass next word and following spaces + while (nextNum < currentLine.length()) + { + if (!isLegalNameChar(currentLine[nextNum]) + && !isWhiteSpace(currentLine[nextNum])) + break; + nextNum++; + } + + // check for characters that indicate an operator + if (currentLine[nextNum] == ',' + || currentLine[nextNum] == '}' + || currentLine[nextNum] == ')' + || currentLine[nextNum] == '(') + return true; + return false; +} + +// Reset the flags that indicate various statement information. +void ASFormatter::resetEndOfStatement() +{ + foundQuestionMark = false; + foundNamespaceHeader = false; + foundClassHeader = false; + foundStructHeader = false; + foundInterfaceHeader = false; + foundPreDefinitionHeader = false; + foundPreCommandHeader = false; + foundPreCommandMacro = false; + foundTrailingReturnType = false; + foundCastOperator = false; + isInPotentialCalculation = false; + isSharpAccessor = false; + isSharpDelegate = false; + isInObjCMethodDefinition = false; + isInObjCInterface = false; + isInObjCSelector = false; + isInEnum = false; + isInExternC = false; + elseHeaderFollowsComments = false; + nonInStatementBrace = 0; + while (!questionMarkStack->empty()) + questionMarkStack->pop_back(); +} + +// Find the colon alignment for Objective-C method definitions and method calls. +int ASFormatter::findObjCColonAlignment() const +{ + assert(currentChar == '+' || currentChar == '-' || currentChar == '['); + assert(getAlignMethodColon()); + + bool isFirstLine = true; + bool haveFirstColon = false; + bool foundMethodColon = false; + bool isInComment_ = false; + bool isInQuote_ = false; + char quoteChar_ = ' '; + int sqBracketCount = 0; + int colonAdjust = 0; + int colonAlign = 0; + string nextLine_ = currentLine; + ASPeekStream stream(sourceIterator); + + // peek next line + while (sourceIterator->hasMoreLines() || isFirstLine) + { + if (!isFirstLine) + nextLine_ = stream.peekNextLine(); + // parse the line + haveFirstColon = false; + nextLine_ = ASBeautifier::trim(nextLine_); + for (size_t i = 0; i < nextLine_.length(); i++) + { + if (isWhiteSpace(nextLine_[i])) + continue; + if (nextLine_.compare(i, 2, "/*") == 0) + isInComment_ = true; + if (isInComment_) + { + if (nextLine_.compare(i, 2, "*/") == 0) + { + isInComment_ = false; + ++i; + } + continue; + } + if (nextLine_[i] == '\\') + { + ++i; + continue; + } + if (isInQuote_) + { + if (nextLine_[i] == quoteChar_) + isInQuote_ = false; + continue; + } + + if (nextLine_[i] == '"' + || (nextLine_[i] == '\'' && !isDigitSeparator(nextLine_, i))) + { + isInQuote_ = true; + quoteChar_ = nextLine_[i]; + continue; + } + if (nextLine_.compare(i, 2, "//") == 0) + { + i = nextLine_.length(); + continue; + } + // process the current char + if ((nextLine_[i] == '{' && (currentChar == '-' || currentChar == '+')) + || nextLine_[i] == ';') + goto EndOfWhileLoop; // end of method definition + if (nextLine_[i] == ']') + { + --sqBracketCount; + if (sqBracketCount == 0) + goto EndOfWhileLoop; // end of method call + } + if (nextLine_[i] == '[') + ++sqBracketCount; + if (isFirstLine) // colon align does not include the first line + continue; + if (sqBracketCount > 1) + continue; + if (haveFirstColon) // multiple colons per line + continue; + // compute colon adjustment + if (nextLine_[i] == ':') + { + haveFirstColon = true; + foundMethodColon = true; + if (shouldPadMethodColon) + { + int spacesStart; + for (spacesStart = i; spacesStart > 0; spacesStart--) + if (!isWhiteSpace(nextLine_[spacesStart - 1])) + break; + int spaces = i - spacesStart; + if (objCColonPadMode == COLON_PAD_ALL || objCColonPadMode == COLON_PAD_BEFORE) + colonAdjust = 1 - spaces; + else if (objCColonPadMode == COLON_PAD_NONE || objCColonPadMode == COLON_PAD_AFTER) + colonAdjust = 0 - spaces; + } + // compute alignment + int colonPosition = i + colonAdjust; + if (colonPosition > colonAlign) + colonAlign = colonPosition; + } + } // end of for loop + isFirstLine = false; + } // end of while loop +EndOfWhileLoop: + if (!foundMethodColon) + colonAlign = -1; + return colonAlign; +} + +// pad an Objective-C method colon +void ASFormatter::padObjCMethodColon() +{ + assert(currentChar == ':'); + int commentAdjust = 0; + char nextChar = peekNextChar(); + if (objCColonPadMode == COLON_PAD_NONE + || objCColonPadMode == COLON_PAD_AFTER + || nextChar == ')') + { + // remove spaces before + for (int i = formattedLine.length() - 1; (i > -1) && isWhiteSpace(formattedLine[i]); i--) + { + formattedLine.erase(i); + --commentAdjust; + } + } + else + { + // pad space before + for (int i = formattedLine.length() - 1; (i > 0) && isWhiteSpace(formattedLine[i]); i--) + if (isWhiteSpace(formattedLine[i - 1])) + { + formattedLine.erase(i); + --commentAdjust; + } + appendSpacePad(); + } + if (objCColonPadMode == COLON_PAD_NONE + || objCColonPadMode == COLON_PAD_BEFORE + || nextChar == ')') + { + // remove spaces after + int nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextText == (int)string::npos) + nextText = currentLine.length(); + int spaces = nextText - charNum - 1; + if (spaces > 0) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces); + spacePadNum -= spaces; + } + } + else + { + // pad space after + int nextText = currentLine.find_first_not_of(" \t", charNum + 1); + if (nextText == (int)string::npos) + nextText = currentLine.length(); + int spaces = nextText - charNum - 1; + if (spaces == 0) + { + currentLine.insert(charNum + 1, 1, ' '); + spacePadNum += 1; + } + else if (spaces > 1) + { + // do not use goForward here + currentLine.erase(charNum + 1, spaces - 1); + spacePadNum -= spaces - 1; + } + } + spacePadNum += commentAdjust; +} + +// Remove the leading '*' from a comment line and indent to the next tab. +void ASFormatter::stripCommentPrefix() +{ + int firstChar = formattedLine.find_first_not_of(" \t"); + if (firstChar < 0) + return; + + if (isInCommentStartLine) + { + // comment opener must begin the line + if (formattedLine.compare(firstChar, 2, "/*") != 0) + return; + int commentOpener = firstChar; + // ignore single line comments + int commentEnd = formattedLine.find("*/", firstChar + 2); + if (commentEnd != -1) + return; + // first char after the comment opener must be at least one indent + int followingText = formattedLine.find_first_not_of(" \t", commentOpener + 2); + if (followingText < 0) + return; + if (formattedLine[followingText] == '*' || formattedLine[followingText] == '!') + followingText = formattedLine.find_first_not_of(" \t", followingText + 1); + if (followingText < 0) + return; + if (formattedLine[followingText] == '*') + return; + int indentLen = getIndentLength(); + int followingTextIndent = followingText - commentOpener; + if (followingTextIndent < indentLen) + { + string stringToInsert(indentLen - followingTextIndent, ' '); + formattedLine.insert(followingText, stringToInsert); + } + return; + } + // comment body including the closer + if (formattedLine[firstChar] == '*') + { + if (formattedLine.compare(firstChar, 2, "*/") == 0) + { + // line starts with an end comment + formattedLine = "*/"; + } + else + { + // build a new line with one indent + int secondChar = formattedLine.find_first_not_of(" \t", firstChar + 1); + if (secondChar < 0) + { + adjustChecksumIn(-'*'); + formattedLine.erase(); + return; + } + if (formattedLine[secondChar] == '*') + return; + // replace the leading '*' + int indentLen = getIndentLength(); + adjustChecksumIn(-'*'); + // second char must be at least one indent + if (formattedLine.substr(0, secondChar).find('\t') != string::npos) + { + formattedLine.erase(firstChar, 1); + } + else + { + int spacesToInsert = 0; + if (secondChar >= indentLen) + spacesToInsert = secondChar; + else + spacesToInsert = indentLen; + formattedLine = string(spacesToInsert, ' ') + formattedLine.substr(secondChar); + } + // remove a trailing '*' + int lastChar = formattedLine.find_last_not_of(" \t"); + if (lastChar > -1 && formattedLine[lastChar] == '*') + { + adjustChecksumIn(-'*'); + formattedLine[lastChar] = ' '; + } + } + } + else + { + // first char not a '*' + // first char must be at least one indent + if (formattedLine.substr(0, firstChar).find('\t') == string::npos) + { + int indentLen = getIndentLength(); + if (firstChar < indentLen) + { + string stringToInsert(indentLen, ' '); + formattedLine = stringToInsert + formattedLine.substr(firstChar); + } + } + } +} + +} // end namespace astyle diff --git a/thirdparty/astyle/ASLocalizer.cpp b/thirdparty/astyle/ASLocalizer.cpp new file mode 100755 index 00000000..083f68a2 --- /dev/null +++ b/thirdparty/astyle/ASLocalizer.cpp @@ -0,0 +1,1092 @@ +// ASLocalizer.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. +// +// File encoding for this file is UTF-8 WITHOUT a byte order mark (BOM). +// русский 中文（简体） 日本語 한국의 +// +// Windows: +// Add the required "Language" to the system. +// The settings do NOT need to be changed to the added language. +// Change the "Region" settings. +// Change both the "Format" and the "Current Language..." settings. +// A restart is required if the codepage has changed. +// Windows problems: +// Hindi - no available locale, language pack removed +// Japanese - language pack install error +// Ukranian - displays a ? instead of i +// +// Linux: +// Change the LANG environment variable: LANG=fr_FR.UTF-8. +// setlocale() will use the LANG environment variable on Linux. +// +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * + * To add a new language to this source module: + * + * Add a new translation class to ASLocalizer.h. + * Update the WinLangCode array in ASLocalizer.cpp. + * Add the language code to setTranslationClass() in ASLocalizer.cpp. + * Add the English-Translation pair to the constructor in ASLocalizer.cpp. + * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + */ + +//---------------------------------------------------------------------------- +// headers +//---------------------------------------------------------------------------- + +#include "ASLocalizer.h" + +#ifdef _WIN32 + #include +#endif + +#ifdef __VMS + #define __USE_STD_IOSTREAM 1 + #include +#else + #include +#endif + +#include +#include +#include // needed by some compilers +#include +#include + +#ifdef _MSC_VER + #pragma warning(disable: 4996) // secure version deprecation warnings +#endif + +#ifdef __BORLANDC__ + #pragma warn -8104 // Local Static with constructor dangerous for multi-threaded apps +#endif + +#ifdef __INTEL_COMPILER + #pragma warning(disable: 383) // value copied to temporary, reference to temporary used + #pragma warning(disable: 981) // operands are evaluated in unspecified order +#endif + +#ifdef __clang__ + #pragma clang diagnostic ignored "-Wdeprecated-declarations" // wcstombs +#endif + +namespace astyle { + +#ifndef ASTYLE_LIB + +//---------------------------------------------------------------------------- +// ASLocalizer class methods. +//---------------------------------------------------------------------------- + +ASLocalizer::ASLocalizer() +// Set the locale information. +{ + // set language default values to english (ascii) + // this will be used if a locale or a language cannot be found + m_localeName = "UNKNOWN"; + m_langID = "en"; + m_lcid = 0; + m_subLangID.clear(); + m_translation = nullptr; + + // Not all compilers support the C++ function locale::global(locale("")); + char* localeName = setlocale(LC_ALL, ""); + if (localeName == nullptr) // use the english (ascii) defaults + { + fprintf(stderr, "\n%s\n\n", "Cannot set native locale, reverting to English"); + setTranslationClass(); + return; + } + // set the class variables +#ifdef _WIN32 + size_t lcid = GetUserDefaultLCID(); + setLanguageFromLCID(lcid); +#else + setLanguageFromName(localeName); +#endif +} + +ASLocalizer::~ASLocalizer() +// Delete dynamically allocated memory. +{ + delete m_translation; +} + +#ifdef _WIN32 + +struct WinLangCode +{ + size_t winLang; + char canonicalLang[3]; +}; + +static WinLangCode wlc[] = +// primary language identifier http://msdn.microsoft.com/en-us/library/aa912554.aspx +// sublanguage identifier http://msdn.microsoft.com/en-us/library/aa913256.aspx +// language ID http://msdn.microsoft.com/en-us/library/ee797784%28v=cs.20%29.aspx +{ + { LANG_BULGARIAN, "bg" }, // bg-BG 1251 + { LANG_CHINESE, "zh" }, // zh-CHS, zh-CHT + { LANG_DUTCH, "nl" }, // nl-NL 1252 + { LANG_ENGLISH, "en" }, // en-US 1252 + { LANG_ESTONIAN, "et" }, // et-EE + { LANG_FINNISH, "fi" }, // fi-FI 1252 + { LANG_FRENCH, "fr" }, // fr-FR 1252 + { LANG_GERMAN, "de" }, // de-DE 1252 + { LANG_GREEK, "el" }, // el-GR 1253 + { LANG_HINDI, "hi" }, // hi-IN + { LANG_HUNGARIAN, "hu" }, // hu-HU 1250 + { LANG_ITALIAN, "it" }, // it-IT 1252 + { LANG_JAPANESE, "ja" }, // ja-JP + { LANG_KOREAN, "ko" }, // ko-KR + { LANG_NORWEGIAN, "nn" }, // nn-NO 1252 + { LANG_POLISH, "pl" }, // pl-PL 1250 + { LANG_PORTUGUESE, "pt" }, // pt-PT 1252 + { LANG_ROMANIAN, "ro" }, // ro-RO 1250 + { LANG_RUSSIAN, "ru" }, // ru-RU 1251 + { LANG_SPANISH, "es" }, // es-ES 1252 + { LANG_SWEDISH, "sv" }, // sv-SE 1252 + { LANG_UKRAINIAN, "uk" }, // uk-UA 1251 +}; + +void ASLocalizer::setLanguageFromLCID(size_t lcid) +// Windows get the language to use from the user locale. +// NOTE: GetUserDefaultLocaleName() gets nearly the same name as Linux. +// But it needs Windows Vista or higher. +// Same with LCIDToLocaleName(). +{ + m_lcid = lcid; + m_langID = "en"; // default to english + + size_t lang = PRIMARYLANGID(LANGIDFROMLCID(m_lcid)); + size_t sublang = SUBLANGID(LANGIDFROMLCID(m_lcid)); + // find language in the wlc table + size_t count = sizeof(wlc) / sizeof(wlc[0]); + for (size_t i = 0; i < count; i++) + { + if (wlc[i].winLang == lang) + { + m_langID = wlc[i].canonicalLang; + break; + } + } + if (m_langID == "zh") + { + if (sublang == SUBLANG_CHINESE_SIMPLIFIED || sublang == SUBLANG_CHINESE_SINGAPORE) + m_subLangID = "CHS"; + else + m_subLangID = "CHT"; // default + } + setTranslationClass(); +} + +#endif // _win32 + +string ASLocalizer::getLanguageID() const +// Returns the language ID in m_langID. +{ + return m_langID; +} + +const Translation* ASLocalizer::getTranslationClass() const +// Returns the name of the translation class in m_translation. Used for testing. +{ + assert(m_translation); + return m_translation; +} + +void ASLocalizer::setLanguageFromName(const char* langID) +// Linux set the language to use from the langID. +// +// the language string has the following form +// +// lang[_LANG][.encoding][@modifier] +// +// (see environ(5) in the Open Unix specification) +// +// where lang is the primary language, LANG is a sublang/territory, +// encoding is the charset to use and modifier "allows the user to select +// a specific instance of localization data within a single category" +// +// for example, the following strings are valid: +// fr +// fr_FR +// de_DE.iso88591 +// de_DE@euro +// de_DE.iso88591@euro +{ + // the constants describing the format of lang_LANG locale string + m_lcid = 0; + string langStr = langID; + m_langID = langStr.substr(0, 2); + + // need the sublang for chinese + if (m_langID == "zh" && langStr[2] == '_') + { + string subLang = langStr.substr(3, 2); + if (subLang == "CN" || subLang == "SG") + m_subLangID = "CHS"; + else + m_subLangID = "CHT"; // default + } + setTranslationClass(); +} + +const char* ASLocalizer::settext(const char* textIn) const +// Call the settext class and return the value. +{ + assert(m_translation); + const string stringIn = textIn; + return m_translation->translate(stringIn).c_str(); +} + +void ASLocalizer::setTranslationClass() +// Return the required translation class. +// Sets the class variable m_translation from the value of m_langID. +// Get the language ID at http://msdn.microsoft.com/en-us/library/ee797784%28v=cs.20%29.aspx +{ + assert(m_langID.length()); + // delete previously set (--ascii option) + if (m_translation != nullptr) + { + delete m_translation; + m_translation = nullptr; + } + if (m_langID == "bg") + m_translation = new Bulgarian; + else if (m_langID == "zh" && m_subLangID == "CHS") + m_translation = new ChineseSimplified; + else if (m_langID == "zh" && m_subLangID == "CHT") + m_translation = new ChineseTraditional; + else if (m_langID == "nl") + m_translation = new Dutch; + else if (m_langID == "en") + m_translation = new English; + else if (m_langID == "et") + m_translation = new Estonian; + else if (m_langID == "fi") + m_translation = new Finnish; + else if (m_langID == "fr") + m_translation = new French; + else if (m_langID == "de") + m_translation = new German; + else if (m_langID == "el") + m_translation = new Greek; + else if (m_langID == "hi") + m_translation = new Hindi; + else if (m_langID == "hu") + m_translation = new Hungarian; + else if (m_langID == "it") + m_translation = new Italian; + else if (m_langID == "ja") + m_translation = new Japanese; + else if (m_langID == "ko") + m_translation = new Korean; + else if (m_langID == "nn") + m_translation = new Norwegian; + else if (m_langID == "pl") + m_translation = new Polish; + else if (m_langID == "pt") + m_translation = new Portuguese; + else if (m_langID == "ro") + m_translation = new Romanian; + else if (m_langID == "ru") + m_translation = new Russian; + else if (m_langID == "es") + m_translation = new Spanish; + else if (m_langID == "sv") + m_translation = new Swedish; + else if (m_langID == "uk") + m_translation = new Ukrainian; + else // default + m_translation = new English; +} + +//---------------------------------------------------------------------------- +// Translation base class methods. +//---------------------------------------------------------------------------- + +void Translation::addPair(const string& english, const wstring& translated) +// Add a string pair to the translation vector. +{ + pair entry(english, translated); + m_translation.emplace_back(entry); +} + +string Translation::convertToMultiByte(const wstring& wideStr) const +// Convert wchar_t to a multibyte string using the currently assigned locale. +// Return an empty string if an error occurs. +{ + static bool msgDisplayed = false; + // get length of the output excluding the nullptr and validate the parameters + size_t mbLen = wcstombs(nullptr, wideStr.c_str(), 0); + if (mbLen == string::npos) + { + if (!msgDisplayed) + { + fprintf(stderr, "\n%s\n\n", "Cannot convert to multi-byte string, reverting to English"); + msgDisplayed = true; + } + return ""; + } + // convert the characters + char* mbStr = new (nothrow) char[mbLen + 1]; + if (mbStr == nullptr) + { + if (!msgDisplayed) + { + fprintf(stderr, "\n%s\n\n", "Bad memory alloc for multi-byte string, reverting to English"); + msgDisplayed = true; + } + return ""; + } + wcstombs(mbStr, wideStr.c_str(), mbLen + 1); + // return the string + string mbTranslation = mbStr; + delete[] mbStr; + return mbTranslation; +} + +size_t Translation::getTranslationVectorSize() const +// Return the translation vector size. Used for testing. +{ + return m_translation.size(); +} + +bool Translation::getWideTranslation(const string& stringIn, wstring& wideOut) const +// Get the wide translation string. Used for testing. +{ + for (size_t i = 0; i < m_translation.size(); i++) + { + if (m_translation[i].first == stringIn) + { + wideOut = m_translation[i].second; + return true; + } + } + // not found + wideOut = L""; + return false; +} + +string& Translation::translate(const string& stringIn) const +// Translate a string. +// Return a mutable string so the method can have a "const" designation. +// This allows "settext" to be called from a "const" method. +{ + m_mbTranslation.clear(); + for (size_t i = 0; i < m_translation.size(); i++) + { + if (m_translation[i].first == stringIn) + { + m_mbTranslation = convertToMultiByte(m_translation[i].second); + break; + } + } + // not found, return english + if (m_mbTranslation.empty()) + m_mbTranslation = stringIn; + return m_mbTranslation; +} + +//---------------------------------------------------------------------------- +// Translation class methods. +// These classes have only a constructor which builds the language vector. +//---------------------------------------------------------------------------- + +Bulgarian::Bulgarian() // български +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Форматиран %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Непроменен %s\n"); // should align with formatted + addPair("Directory %s\n", L"директория %s\n"); + addPair("Exclude %s\n", L"Изключвам %s\n"); + addPair("Exclude (unmatched) %s\n", L"Изключване (несравнимо) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s форматиран %s hепроменен "); + addPair(" seconds ", L" секунди "); + addPair("%d min %d sec ", L"%d мин %d сек "); + addPair("%s lines\n", L"%s линии\n"); + addPair("Using default options file %s\n", L"Използване на файла възможности по подразбиране %s\n"); + addPair("Opening HTML documentation %s\n", L"Откриване HTML документация %s\n"); + addPair("Invalid option file options:", L"Невалидни опции опция файлове:"); + addPair("Invalid command line options:", L"Невалидни опции за командния ред:"); + addPair("For help on options type 'astyle -h'", L"За помощ относно възможностите тип 'astyle -h'"); + addPair("Cannot open options file", L"Не може да се отвори файл опции"); + addPair("Cannot open directory", L"Не може да се отвори директория"); + addPair("Cannot open HTML file %s\n", L"Не може да се отвори HTML файл %s\n"); + addPair("Command execute failure", L"Command изпълни недостатъчност"); + addPair("Command is not installed", L"Command не е инсталиран"); + addPair("Missing filename in %s\n", L"Липсва името на файла в %s\n"); + addPair("Recursive option with no wildcard", L"Рекурсивно опция, без маска"); + addPair("Did you intend quote the filename", L"Знаете ли намерение да цитирам името на файла"); + addPair("No file to process %s\n", L"Не файл за обработка %s\n"); + addPair("Did you intend to use --recursive", L"Знаете ли възнамерявате да използвате --recursive"); + addPair("Cannot process UTF-32 encoding", L"Не може да са UTF-32 кодиране"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style е прекратено"); +} + +ChineseSimplified::ChineseSimplified() // 中文（简体） +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"格式化 %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"未改变 %s\n"); // should align with formatted + addPair("Directory %s\n", L"目录 %s\n"); + addPair("Exclude %s\n", L"排除 %s\n"); + addPair("Exclude (unmatched) %s\n", L"排除（无匹配项） %s\n"); + addPair(" %s formatted %s unchanged ", L" %s 格式化 %s 未改变 "); + addPair(" seconds ", L" 秒 "); + addPair("%d min %d sec ", L"%d 分 %d 秒 "); + addPair("%s lines\n", L"%s 行\n"); + addPair("Using default options file %s\n", L"使用默认配置文件 %s\n"); + addPair("Opening HTML documentation %s\n", L"打开HTML文档 %s\n"); + addPair("Invalid option file options:", L"无效的配置文件选项:"); + addPair("Invalid command line options:", L"无效的命令行选项:"); + addPair("For help on options type 'astyle -h'", L"输入 'astyle -h' 以获得有关命令行的帮助"); + addPair("Cannot open options file", L"无法打开配置文件"); + addPair("Cannot open directory", L"无法打开目录"); + addPair("Cannot open HTML file %s\n", L"无法打开HTML文件 %s\n"); + addPair("Command execute failure", L"执行命令失败"); + addPair("Command is not installed", L"未安装命令"); + addPair("Missing filename in %s\n", L"在%s缺少文件名\n"); + addPair("Recursive option with no wildcard", L"递归选项没有通配符"); + addPair("Did you intend quote the filename", L"你打算引用文件名"); + addPair("No file to process %s\n", L"没有文件可处理 %s\n"); + addPair("Did you intend to use --recursive", L"你打算使用 --recursive"); + addPair("Cannot process UTF-32 encoding", L"不能处理UTF-32编码"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style 已经终止运行"); +} + +ChineseTraditional::ChineseTraditional() // 中文（繁體） +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"格式化 %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"未改變 %s\n"); // should align with formatted + addPair("Directory %s\n", L"目錄 %s\n"); + addPair("Exclude %s\n", L"排除 %s\n"); + addPair("Exclude (unmatched) %s\n", L"排除（無匹配項） %s\n"); + addPair(" %s formatted %s unchanged ", L" %s 格式化 %s 未改變 "); + addPair(" seconds ", L" 秒 "); + addPair("%d min %d sec ", L"%d 分 %d 秒 "); + addPair("%s lines\n", L"%s 行\n"); + addPair("Using default options file %s\n", L"使用默認配置文件 %s\n"); + addPair("Opening HTML documentation %s\n", L"打開HTML文檔 %s\n"); + addPair("Invalid option file options:", L"無效的配置文件選項:"); + addPair("Invalid command line options:", L"無效的命令行選項:"); + addPair("For help on options type 'astyle -h'", L"輸入'astyle -h'以獲得有關命令行的幫助:"); + addPair("Cannot open options file", L"無法打開配置文件"); + addPair("Cannot open directory", L"無法打開目錄"); + addPair("Cannot open HTML file %s\n", L"無法打開HTML文件 %s\n"); + addPair("Command execute failure", L"執行命令失敗"); + addPair("Command is not installed", L"未安裝命令"); + addPair("Missing filename in %s\n", L"在%s缺少文件名\n"); + addPair("Recursive option with no wildcard", L"遞歸選項沒有通配符"); + addPair("Did you intend quote the filename", L"你打算引用文件名"); + addPair("No file to process %s\n", L"沒有文件可處理 %s\n"); + addPair("Did you intend to use --recursive", L"你打算使用 --recursive"); + addPair("Cannot process UTF-32 encoding", L"不能處理UTF-32編碼"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style 已經終止運行"); +} + +Dutch::Dutch() // Nederlandse +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Geformatteerd %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Onveranderd %s\n"); // should align with formatted + addPair("Directory %s\n", L"Directory %s\n"); + addPair("Exclude %s\n", L"Uitsluiten %s\n"); + addPair("Exclude (unmatched) %s\n", L"Uitgesloten (ongeëvenaarde) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s geformatteerd %s onveranderd "); + addPair(" seconds ", L" seconden "); + addPair("%d min %d sec ", L"%d min %d sec "); + addPair("%s lines\n", L"%s lijnen\n"); + addPair("Using default options file %s\n", L"Met behulp van standaard opties bestand %s\n"); + addPair("Opening HTML documentation %s\n", L"Het openen van HTML-documentatie %s\n"); + addPair("Invalid option file options:", L"Ongeldige optie file opties:"); + addPair("Invalid command line options:", L"Ongeldige command line opties:"); + addPair("For help on options type 'astyle -h'", L"Voor hulp bij 'astyle-h' opties het type"); + addPair("Cannot open options file", L"Kan niet worden geopend options bestand"); + addPair("Cannot open directory", L"Kan niet open directory"); + addPair("Cannot open HTML file %s\n", L"Kan HTML-bestand niet openen %s\n"); + addPair("Command execute failure", L"Voeren commando falen"); + addPair("Command is not installed", L"Command is niet geïnstalleerd"); + addPair("Missing filename in %s\n", L"Ontbrekende bestandsnaam in %s\n"); + addPair("Recursive option with no wildcard", L"Recursieve optie met geen wildcard"); + addPair("Did you intend quote the filename", L"Heeft u van plan citaat van de bestandsnaam"); + addPair("No file to process %s\n", L"Geen bestand te verwerken %s\n"); + addPair("Did you intend to use --recursive", L"Hebt u van plan bent te gebruiken --recursive"); + addPair("Cannot process UTF-32 encoding", L"Kan niet verwerken UTF-32 codering"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style heeft beëindigd"); +} + +English::English() +// this class is NOT translated +{} + +Estonian::Estonian() // Eesti +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formaadis %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Muutumatu %s\n"); // should align with formatted + addPair("Directory %s\n", L"Kataloog %s\n"); + addPair("Exclude %s\n", L"Välista %s\n"); + addPair("Exclude (unmatched) %s\n", L"Välista (tasakaalustamata) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formaadis %s muutumatu "); + addPair(" seconds ", L" sekundit "); + addPair("%d min %d sec ", L"%d min %d sek "); + addPair("%s lines\n", L"%s read\n"); + addPair("Using default options file %s\n", L"Kasutades selliseid vaikimisi valikuid faili %s\n"); + addPair("Opening HTML documentation %s\n", L"Avamine HTML dokumentatsioon %s\n"); + addPair("Invalid option file options:", L"Vale valik faili võimalusi:"); + addPair("Invalid command line options:", L"Vale käsureavõtmetega:"); + addPair("For help on options type 'astyle -h'", L"Abiks võimaluste tüüp 'astyle -h'"); + addPair("Cannot open options file", L"Ei saa avada võimalusi faili"); + addPair("Cannot open directory", L"Ei saa avada kataloogi"); + addPair("Cannot open HTML file %s\n", L"Ei saa avada HTML-faili %s\n"); + addPair("Command execute failure", L"Käsk täita rike"); + addPair("Command is not installed", L"Käsk ei ole paigaldatud"); + addPair("Missing filename in %s\n", L"Kadunud failinimi %s\n"); + addPair("Recursive option with no wildcard", L"Rekursiivne võimalus ilma metamärgi"); + addPair("Did you intend quote the filename", L"Kas te kavatsete tsiteerida failinimi"); + addPair("No file to process %s\n", L"No faili töötlema %s\n"); + addPair("Did you intend to use --recursive", L"Kas te kavatsete kasutada --recursive"); + addPair("Cannot process UTF-32 encoding", L"Ei saa töödelda UTF-32 kodeeringus"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style on lõpetatud"); +} + +Finnish::Finnish() // Suomeksi +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Muotoiltu %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Ennallaan %s\n"); // should align with formatted + addPair("Directory %s\n", L"Directory %s\n"); + addPair("Exclude %s\n", L"Sulkea %s\n"); + addPair("Exclude (unmatched) %s\n", L"Sulkea (verraton) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s muotoiltu %s ennallaan "); + addPair(" seconds ", L" sekuntia "); + addPair("%d min %d sec ", L"%d min %d sek "); + addPair("%s lines\n", L"%s linjat\n"); + addPair("Using default options file %s\n", L"Käyttämällä oletusasetuksia tiedosto %s\n"); + addPair("Opening HTML documentation %s\n", L"Avaaminen HTML asiakirjat %s\n"); + addPair("Invalid option file options:", L"Virheellinen vaihtoehto tiedosto vaihtoehtoja:"); + addPair("Invalid command line options:", L"Virheellinen komentorivin:"); + addPair("For help on options type 'astyle -h'", L"Apua vaihtoehdoista tyyppi 'astyle -h'"); + addPair("Cannot open options file", L"Ei voi avata vaihtoehtoja tiedostoa"); + addPair("Cannot open directory", L"Ei Open Directory"); + addPair("Cannot open HTML file %s\n", L"Ei voi avata HTML-tiedoston %s\n"); + addPair("Command execute failure", L"Suorita komento vika"); + addPair("Command is not installed", L"Komento ei ole asennettu"); + addPair("Missing filename in %s\n", L"Puuttuvat tiedostonimi %s\n"); + addPair("Recursive option with no wildcard", L"Rekursiivinen vaihtoehto ilman wildcard"); + addPair("Did you intend quote the filename", L"Oletko aio lainata tiedostonimi"); + addPair("No file to process %s\n", L"Ei tiedostoa käsitellä %s\n"); + addPair("Did you intend to use --recursive", L"Oliko aiot käyttää --recursive"); + addPair("Cannot process UTF-32 encoding", L"Ei voi käsitellä UTF-32 koodausta"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style on päättynyt"); +} + +French::French() // Française +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formaté %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Inchangée %s\n"); // should align with formatted + addPair("Directory %s\n", L"Répertoire %s\n"); + addPair("Exclude %s\n", L"Exclure %s\n"); + addPair("Exclude (unmatched) %s\n", L"Exclure (non appariés) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formaté %s inchangée "); + addPair(" seconds ", L" seconde "); + addPair("%d min %d sec ", L"%d min %d sec "); + addPair("%s lines\n", L"%s lignes\n"); + addPair("Using default options file %s\n", L"Options par défaut utilisation du fichier %s\n"); + addPair("Opening HTML documentation %s\n", L"Ouverture documentation HTML %s\n"); + addPair("Invalid option file options:", L"Options Blancs option du fichier:"); + addPair("Invalid command line options:", L"Blancs options ligne de commande:"); + addPair("For help on options type 'astyle -h'", L"Pour de l'aide sur les options tapez 'astyle -h'"); + addPair("Cannot open options file", L"Impossible d'ouvrir le fichier d'options"); + addPair("Cannot open directory", L"Impossible d'ouvrir le répertoire"); + addPair("Cannot open HTML file %s\n", L"Impossible d'ouvrir le fichier HTML %s\n"); + addPair("Command execute failure", L"Exécuter échec de la commande"); + addPair("Command is not installed", L"Commande n'est pas installé"); + addPair("Missing filename in %s\n", L"Nom de fichier manquant dans %s\n"); + addPair("Recursive option with no wildcard", L"Option récursive sans joker"); + addPair("Did you intend quote the filename", L"Avez-vous l'intention de citer le nom de fichier"); + addPair("No file to process %s\n", L"Aucun fichier à traiter %s\n"); + addPair("Did you intend to use --recursive", L"Avez-vous l'intention d'utiliser --recursive"); + addPair("Cannot process UTF-32 encoding", L"Impossible de traiter codage UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style a mis fin"); +} + +German::German() // Deutsch +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formatiert %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Unverändert %s\n"); // should align with formatted + addPair("Directory %s\n", L"Verzeichnis %s\n"); + addPair("Exclude %s\n", L"Ausschließen %s\n"); + addPair("Exclude (unmatched) %s\n", L"Ausschließen (unerreichte) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formatiert %s unverändert "); + addPair(" seconds ", L" sekunden "); + addPair("%d min %d sec ", L"%d min %d sek "); + addPair("%s lines\n", L"%s linien\n"); + addPair("Using default options file %s\n", L"Mit Standard-Optionen Dat %s\n"); + addPair("Opening HTML documentation %s\n", L"Öffnen HTML-Dokumentation %s\n"); + addPair("Invalid option file options:", L"Ungültige Option Datei-Optionen:"); + addPair("Invalid command line options:", L"Ungültige Kommandozeilen-Optionen:"); + addPair("For help on options type 'astyle -h'", L"Für Hilfe zu den Optionen geben Sie 'astyle -h'"); + addPair("Cannot open options file", L"Kann nicht geöffnet werden Optionsdatei"); + addPair("Cannot open directory", L"Kann nicht geöffnet werden Verzeichnis"); + addPair("Cannot open HTML file %s\n", L"Kann nicht öffnen HTML-Datei %s\n"); + addPair("Command execute failure", L"Execute Befehl Scheitern"); + addPair("Command is not installed", L"Befehl ist nicht installiert"); + addPair("Missing filename in %s\n", L"Missing in %s Dateiname\n"); + addPair("Recursive option with no wildcard", L"Rekursive Option ohne Wildcard"); + addPair("Did you intend quote the filename", L"Haben Sie die Absicht Inhalte der Dateiname"); + addPair("No file to process %s\n", L"Keine Datei zu verarbeiten %s\n"); + addPair("Did you intend to use --recursive", L"Haben Sie verwenden möchten --recursive"); + addPair("Cannot process UTF-32 encoding", L"Nicht verarbeiten kann UTF-32 Codierung"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style ist beendet"); +} + +Greek::Greek() // ελληνικά +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Διαμορφωμένη %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Αμετάβλητος %s\n"); // should align with formatted + addPair("Directory %s\n", L"Κατάλογος %s\n"); + addPair("Exclude %s\n", L"Αποκλείω %s\n"); + addPair("Exclude (unmatched) %s\n", L"Ausschließen (unerreichte) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s σχηματοποιημένη %s αμετάβλητες "); + addPair(" seconds ", L" δευτερόλεπτα "); + addPair("%d min %d sec ", L"%d λεπ %d δευ "); + addPair("%s lines\n", L"%s γραμμές\n"); + addPair("Using default options file %s\n", L"Χρησιμοποιώντας το αρχείο προεπιλεγμένες επιλογές %s\n"); + addPair("Opening HTML documentation %s\n", L"Εγκαίνια έγγραφα HTML %s\n"); + addPair("Invalid option file options:", L"Μη έγκυρες επιλογές αρχείου επιλογή:"); + addPair("Invalid command line options:", L"Μη έγκυρη επιλογές γραμμής εντολών:"); + addPair("For help on options type 'astyle -h'", L"Για βοήθεια σχετικά με το είδος επιλογές 'astyle -h'"); + addPair("Cannot open options file", L"Δεν μπορείτε να ανοίξετε το αρχείο επιλογών"); + addPair("Cannot open directory", L"Δεν μπορείτε να ανοίξετε τον κατάλογο"); + addPair("Cannot open HTML file %s\n", L"Δεν μπορείτε να ανοίξετε το αρχείο HTML %s\n"); + addPair("Command execute failure", L"Εντολή να εκτελέσει την αποτυχία"); + addPair("Command is not installed", L"Η εντολή δεν έχει εγκατασταθεί"); + addPair("Missing filename in %s\n", L"Λείπει το όνομα αρχείου σε %s\n"); + addPair("Recursive option with no wildcard", L"Αναδρομικές επιλογή χωρίς μπαλαντέρ"); + addPair("Did you intend quote the filename", L"Μήπως σκοπεύετε να αναφέρετε το όνομα του αρχείου"); + addPair("No file to process %s\n", L"Δεν υπάρχει αρχείο για την επεξεργασία %s\n"); + addPair("Did you intend to use --recursive", L"Μήπως σκοπεύετε να χρησιμοποιήσετε --recursive"); + addPair("Cannot process UTF-32 encoding", L"δεν μπορεί να επεξεργαστεί UTF-32 κωδικοποίηση"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style έχει λήξει"); +} + +Hindi::Hindi() // हिन्दी +// build the translation vector in the Translation base class +{ + // NOTE: Scintilla based editors (CodeBlocks) cannot always edit Hindi. + // Use Visual Studio instead. + addPair("Formatted %s\n", L"स्वरूपित किया %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"अपरिवर्तित %s\n"); // should align with formatted + addPair("Directory %s\n", L"निर्देशिका %s\n"); + addPair("Exclude %s\n", L"निकालना %s\n"); + addPair("Exclude (unmatched) %s\n", L"अपवर्जित (बेजोड़) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s स्वरूपित किया %s अपरिवर्तित "); + addPair(" seconds ", L" सेकंड "); + addPair("%d min %d sec ", L"%d मिनट %d सेकंड "); + addPair("%s lines\n", L"%s लाइनों\n"); + addPair("Using default options file %s\n", L"डिफ़ॉल्ट विकल्प का उपयोग कर फ़ाइल %s\n"); + addPair("Opening HTML documentation %s\n", L"एचटीएमएल प्रलेखन खोलना %s\n"); + addPair("Invalid option file options:", L"अवैध विकल्प फ़ाइल विकल्प हैं:"); + addPair("Invalid command line options:", L"कमांड लाइन विकल्प अवैध:"); + addPair("For help on options type 'astyle -h'", L"विकल्पों पर मदद के लिए प्रकार 'astyle -h'"); + addPair("Cannot open options file", L"विकल्प फ़ाइल नहीं खोल सकता है"); + addPair("Cannot open directory", L"निर्देशिका नहीं खोल सकता"); + addPair("Cannot open HTML file %s\n", L"HTML फ़ाइल नहीं खोल सकता %s\n"); + addPair("Command execute failure", L"आदेश विफलता निष्पादित"); + addPair("Command is not installed", L"कमान स्थापित नहीं है"); + addPair("Missing filename in %s\n", L"लापता में फ़ाइलनाम %s\n"); + addPair("Recursive option with no wildcard", L"कोई वाइल्डकार्ड साथ पुनरावर्ती विकल्प"); + addPair("Did you intend quote the filename", L"क्या आप बोली फ़ाइलनाम का इरादा"); + addPair("No file to process %s\n", L"कोई फ़ाइल %s प्रक्रिया के लिए\n"); + addPair("Did you intend to use --recursive", L"क्या आप उपयोग करना चाहते हैं --recursive"); + addPair("Cannot process UTF-32 encoding", L"UTF-32 कूटबन्धन प्रक्रिया नहीं कर सकते"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style समाप्त किया है"); +} + +Hungarian::Hungarian() // Magyar +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formázott %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Változatlan %s\n"); // should align with formatted + addPair("Directory %s\n", L"Címjegyzék %s\n"); + addPair("Exclude %s\n", L"Kizár %s\n"); + addPair("Exclude (unmatched) %s\n", L"Escludere (senza pari) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formázott %s változatlan "); + addPair(" seconds ", L" másodperc "); + addPair("%d min %d sec ", L"%d jeg %d más "); + addPair("%s lines\n", L"%s vonalak\n"); + addPair("Using default options file %s\n", L"Az alapértelmezett beállítások fájl %s\n"); + addPair("Opening HTML documentation %s\n", L"Nyitó HTML dokumentáció %s\n"); + addPair("Invalid option file options:", L"Érvénytelen opció fájlbeállítást:"); + addPair("Invalid command line options:", L"Érvénytelen parancssori opciók:"); + addPair("For help on options type 'astyle -h'", L"Ha segítségre van lehetőség típus 'astyle-h'"); + addPair("Cannot open options file", L"Nem lehet megnyitni beállítási fájlban"); + addPair("Cannot open directory", L"Nem lehet megnyitni könyvtár"); + addPair("Cannot open HTML file %s\n", L"Nem lehet megnyitni a HTML fájlt %s\n"); + addPair("Command execute failure", L"Command végre hiba"); + addPair("Command is not installed", L"Parancs nincs telepítve"); + addPair("Missing filename in %s\n", L"Hiányzó fájlnév %s\n"); + addPair("Recursive option with no wildcard", L"Rekurzív kapcsolót nem wildcard"); + addPair("Did you intend quote the filename", L"Esetleg kívánja idézni a fájlnév"); + addPair("No file to process %s\n", L"Nincs fájl feldolgozása %s\n"); + addPair("Did you intend to use --recursive", L"Esetleg a használni kívánt --recursive"); + addPair("Cannot process UTF-32 encoding", L"Nem tudja feldolgozni UTF-32 kódolással"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style megszűnt"); +} + +Italian::Italian() // Italiano +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formattata %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Immutato %s\n"); // should align with formatted + addPair("Directory %s\n", L"Elenco %s\n"); + addPair("Exclude %s\n", L"Escludere %s\n"); + addPair("Exclude (unmatched) %s\n", L"Escludere (senza pari) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s ormattata %s immutato "); + addPair(" seconds ", L" secondo "); + addPair("%d min %d sec ", L"%d min %d seg "); + addPair("%s lines\n", L"%s linee\n"); + addPair("Using default options file %s\n", L"Utilizzando file delle opzioni di default %s\n"); + addPair("Opening HTML documentation %s\n", L"Apertura di documenti HTML %s\n"); + addPair("Invalid option file options:", L"Opzione non valida file delle opzioni:"); + addPair("Invalid command line options:", L"Opzioni della riga di comando non valido:"); + addPair("For help on options type 'astyle -h'", L"Per informazioni sulle opzioni di tipo 'astyle-h'"); + addPair("Cannot open options file", L"Impossibile aprire il file opzioni"); + addPair("Cannot open directory", L"Impossibile aprire la directory"); + addPair("Cannot open HTML file %s\n", L"Impossibile aprire il file HTML %s\n"); + addPair("Command execute failure", L"Esegui fallimento comando"); + addPair("Command is not installed", L"Il comando non è installato"); + addPair("Missing filename in %s\n", L"Nome del file mancante in %s\n"); + addPair("Recursive option with no wildcard", L"Opzione ricorsiva senza jolly"); + addPair("Did you intend quote the filename", L"Avete intenzione citare il nome del file"); + addPair("No file to process %s\n", L"Nessun file al processo %s\n"); + addPair("Did you intend to use --recursive", L"Hai intenzione di utilizzare --recursive"); + addPair("Cannot process UTF-32 encoding", L"Non è possibile processo di codifica UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style ha terminato"); +} + +Japanese::Japanese() // 日本語 +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"フォーマット済みの %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"変わりません %s\n"); // should align with formatted + addPair("Directory %s\n", L"ディレクトリ %s\n"); + addPair("Exclude %s\n", L"除外する %s\n"); + addPair("Exclude (unmatched) %s\n", L"除外する（一致しません） %s\n"); + addPair(" %s formatted %s unchanged ", L" %s フフォーマット済みの %s 変わりません "); + addPair(" seconds ", L" 秒 "); + addPair("%d min %d sec ", L"%d 分 %d 秒 "); + addPair("%s lines\n", L"%s ライン\n"); + addPair("Using default options file %s\n", L"デフォルトのオプションファイルを使用して、 %s\n"); + addPair("Opening HTML documentation %s\n", L"オープニングHTMLドキュメント %s\n"); + addPair("Invalid option file options:", L"無効なオプションファイルのオプション："); + addPair("Invalid command line options:", L"無効なコマンドラインオプション："); + addPair("For help on options type 'astyle -h'", L"コオプションの種類のヘルプについて'astyle- h'を入力してください"); + addPair("Cannot open options file", L"オプションファイルを開くことができません"); + addPair("Cannot open directory", L"ディレクトリを開くことができません。"); + addPair("Cannot open HTML file %s\n", L"HTMLファイルを開くことができません %s\n"); + addPair("Command execute failure", L"コマンドが失敗を実行します"); + addPair("Command is not installed", L"コマンドがインストールされていません"); + addPair("Missing filename in %s\n", L"%s で、ファイル名がありません\n"); + addPair("Recursive option with no wildcard", L"無ワイルドカードを使用して再帰的なオプション"); + addPair("Did you intend quote the filename", L"あなたはファイル名を引用するつもりでした"); + addPair("No file to process %s\n", L"いいえファイルは処理しないように %s\n"); + addPair("Did you intend to use --recursive", L"あなたは--recursive使用するつもりでした"); + addPair("Cannot process UTF-32 encoding", L"UTF - 32エンコーディングを処理できません"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style 終了しました"); +} + +Korean::Korean() // 한국의 +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"수정됨 %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"변경없음 %s\n"); // should align with formatted + addPair("Directory %s\n", L"디렉토리 %s\n"); + addPair("Exclude %s\n", L"제외됨 %s\n"); + addPair("Exclude (unmatched) %s\n", L"제외 (NO 일치) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s 수정됨 %s 변경없음 "); + addPair(" seconds ", L" 초 "); + addPair("%d min %d sec ", L"%d 분 %d 초 "); + addPair("%s lines\n", L"%s 라인\n"); + addPair("Using default options file %s\n", L"기본 구성 파일을 사용 %s\n"); + addPair("Opening HTML documentation %s\n", L"HTML 문서를 열기 %s\n"); + addPair("Invalid option file options:", L"잘못된 구성 파일 옵션 :"); + addPair("Invalid command line options:", L"잘못된 명령줄 옵션 :"); + addPair("For help on options type 'astyle -h'", L"도움말을 보려면 옵션 유형 'astyle - H'를 사용합니다"); + addPair("Cannot open options file", L"구성 파일을 열 수 없습니다"); + addPair("Cannot open directory", L"디렉토리를 열지 못했습니다"); + addPair("Cannot open HTML file %s\n", L"HTML 파일을 열 수 없습니다 %s\n"); + addPair("Command execute failure", L"명령 실패를 실행"); + addPair("Command is not installed", L"명령이 설치되어 있지 않습니다"); + addPair("Missing filename in %s\n", L"%s 에서 누락된 파일 이름\n"); + addPair("Recursive option with no wildcard", L"와일드 카드없이 재귀 옵션"); + addPair("Did you intend quote the filename", L"당신은 파일 이름을 인용하고자하나요"); + addPair("No file to process %s\n", L"처리할 파일이 없습니다 %s\n"); + addPair("Did you intend to use --recursive", L"--recursive 를 사용하고자 하십니까"); + addPair("Cannot process UTF-32 encoding", L"UTF-32 인코딩을 처리할 수 없습니다"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style를 종료합니다"); +} + +Norwegian::Norwegian() // Norsk +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formatert %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Uendret %s\n"); // should align with formatted + addPair("Directory %s\n", L"Katalog %s\n"); + addPair("Exclude %s\n", L"Ekskluder %s\n"); + addPair("Exclude (unmatched) %s\n", L"Ekskluder (uovertruffen) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formatert %s uendret "); + addPair(" seconds ", L" sekunder "); + addPair("%d min %d sec ", L"%d min %d sek? "); + addPair("%s lines\n", L"%s linjer\n"); + addPair("Using default options file %s\n", L"Ved hjelp av standardalternativer fil %s\n"); + addPair("Opening HTML documentation %s\n", L"Åpning HTML dokumentasjon %s\n"); + addPair("Invalid option file options:", L"Ugyldige alternativ filalternativer:"); + addPair("Invalid command line options:", L"Kommandolinjevalg Ugyldige:"); + addPair("For help on options type 'astyle -h'", L"For hjelp til alternativer type 'astyle -h'"); + addPair("Cannot open options file", L"Kan ikke åpne alternativer fil"); + addPair("Cannot open directory", L"Kan ikke åpne katalog"); + addPair("Cannot open HTML file %s\n", L"Kan ikke åpne HTML-fil %s\n"); + addPair("Command execute failure", L"Command utføre svikt"); + addPair("Command is not installed", L"Command er ikke installert"); + addPair("Missing filename in %s\n", L"Mangler filnavn i %s\n"); + addPair("Recursive option with no wildcard", L"Rekursiv alternativ uten wildcard"); + addPair("Did you intend quote the filename", L"Har du tenkt sitere filnavnet"); + addPair("No file to process %s\n", L"Ingen fil å behandle %s\n"); + addPair("Did you intend to use --recursive", L"Har du tenkt å bruke --recursive"); + addPair("Cannot process UTF-32 encoding", L"Kan ikke behandle UTF-32 koding"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style har avsluttet"); +} + +Polish::Polish() // Polski +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Sformatowany %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Niezmienione %s\n"); // should align with formatted + addPair("Directory %s\n", L"Katalog %s\n"); + addPair("Exclude %s\n", L"Wykluczać %s\n"); + addPair("Exclude (unmatched) %s\n", L"Wyklucz (niezrównany) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s sformatowany %s niezmienione "); + addPair(" seconds ", L" sekund "); + addPair("%d min %d sec ", L"%d min %d sek "); + addPair("%s lines\n", L"%s linii\n"); + addPair("Using default options file %s\n", L"Korzystanie z domyślnej opcji %s plik\n"); + addPair("Opening HTML documentation %s\n", L"Otwarcie dokumentacji HTML %s\n"); + addPair("Invalid option file options:", L"Nieprawidłowy opcji pliku opcji:"); + addPair("Invalid command line options:", L"Nieprawidłowe opcje wiersza polecenia:"); + addPair("For help on options type 'astyle -h'", L"Aby uzyskać pomoc od rodzaju opcji 'astyle -h'"); + addPair("Cannot open options file", L"Nie można otworzyć pliku opcji"); + addPair("Cannot open directory", L"Nie można otworzyć katalogu"); + addPair("Cannot open HTML file %s\n", L"Nie można otworzyć pliku HTML %s\n"); + addPair("Command execute failure", L"Wykonaj polecenia niepowodzenia"); + addPair("Command is not installed", L"Polecenie nie jest zainstalowany"); + addPair("Missing filename in %s\n", L"Brakuje pliku w %s\n"); + addPair("Recursive option with no wildcard", L"Rekurencyjne opcja bez symboli"); + addPair("Did you intend quote the filename", L"Czy zamierza Pan podać nazwę pliku"); + addPair("No file to process %s\n", L"Brak pliku do procesu %s\n"); + addPair("Did you intend to use --recursive", L"Czy masz zamiar używać --recursive"); + addPair("Cannot process UTF-32 encoding", L"Nie można procesu kodowania UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style został zakończony"); +} + +Portuguese::Portuguese() // Português +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formatado %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Inalterado %s\n"); // should align with formatted + addPair("Directory %s\n", L"Diretório %s\n"); + addPair("Exclude %s\n", L"Excluir %s\n"); + addPair("Exclude (unmatched) %s\n", L"Excluir (incomparável) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formatado %s inalterado "); + addPair(" seconds ", L" segundo "); + addPair("%d min %d sec ", L"%d min %d seg "); + addPair("%s lines\n", L"%s linhas\n"); + addPair("Using default options file %s\n", L"Usando o arquivo de opções padrão %s\n"); + addPair("Opening HTML documentation %s\n", L"Abrindo a documentação HTML %s\n"); + addPair("Invalid option file options:", L"Opções de arquivo inválido opção:"); + addPair("Invalid command line options:", L"Opções de linha de comando inválida:"); + addPair("For help on options type 'astyle -h'", L"Para obter ajuda sobre as opções de tipo 'astyle -h'"); + addPair("Cannot open options file", L"Não é possível abrir arquivo de opções"); + addPair("Cannot open directory", L"Não é possível abrir diretório"); + addPair("Cannot open HTML file %s\n", L"Não é possível abrir arquivo HTML %s\n"); + addPair("Command execute failure", L"Executar falha de comando"); + addPair("Command is not installed", L"Comando não está instalado"); + addPair("Missing filename in %s\n", L"Filename faltando em %s\n"); + addPair("Recursive option with no wildcard", L"Opção recursiva sem curinga"); + addPair("Did you intend quote the filename", L"Será que você pretende citar o nome do arquivo"); + addPair("No file to process %s\n", L"Nenhum arquivo para processar %s\n"); + addPair("Did you intend to use --recursive", L"Será que você pretende usar --recursive"); + addPair("Cannot process UTF-32 encoding", L"Não pode processar a codificação UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style terminou"); +} + +Romanian::Romanian() // Română +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formatat %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Neschimbat %s\n"); // should align with formatted + addPair("Directory %s\n", L"Director %s\n"); + addPair("Exclude %s\n", L"Excludeți %s\n"); + addPair("Exclude (unmatched) %s\n", L"Excludeți (necompensată) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formatat %s neschimbat "); + addPair(" seconds ", L" secunde "); + addPair("%d min %d sec ", L"%d min %d sec "); + addPair("%s lines\n", L"%s linii\n"); + addPair("Using default options file %s\n", L"Fișier folosind opțiunile implicite %s\n"); + addPair("Opening HTML documentation %s\n", L"Documentație HTML deschidere %s\n"); + addPair("Invalid option file options:", L"Opțiuni de opțiune de fișier nevalide:"); + addPair("Invalid command line options:", L"Opțiuni de linie de comandă nevalide:"); + addPair("For help on options type 'astyle -h'", L"Pentru ajutor cu privire la tipul de opțiuni 'astyle -h'"); + addPair("Cannot open options file", L"Nu se poate deschide fișierul de opțiuni"); + addPair("Cannot open directory", L"Nu se poate deschide directorul"); + addPair("Cannot open HTML file %s\n", L"Nu se poate deschide fișierul HTML %s\n"); + addPair("Command execute failure", L"Comandă executa eșec"); + addPair("Command is not installed", L"Comanda nu este instalat"); + addPair("Missing filename in %s\n", L"Lipsă nume de fișier %s\n"); + addPair("Recursive option with no wildcard", L"Opțiunea recursiv cu nici un wildcard"); + addPair("Did you intend quote the filename", L"V-intentionati cita numele de fișier"); + addPair("No file to process %s\n", L"Nu există un fișier pentru a procesa %s\n"); + addPair("Did you intend to use --recursive", L"V-ați intenționați să utilizați --recursive"); + addPair("Cannot process UTF-32 encoding", L"Nu se poate procesa codificarea UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style a terminat"); +} + +Russian::Russian() // русский +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Форматированный %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"без изменений %s\n"); // should align with formatted + addPair("Directory %s\n", L"каталог %s\n"); + addPair("Exclude %s\n", L"исключать %s\n"); + addPair("Exclude (unmatched) %s\n", L"Исключить (непревзойденный) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s Форматированный %s без изменений "); + addPair(" seconds ", L" секунды "); + addPair("%d min %d sec ", L"%d мин %d сек "); + addPair("%s lines\n", L"%s линий\n"); + addPair("Using default options file %s\n", L"Использование опции по умолчанию файл %s\n"); + addPair("Opening HTML documentation %s\n", L"Открытие HTML документации %s\n"); + addPair("Invalid option file options:", L"Недопустимый файл опций опцию:"); + addPair("Invalid command line options:", L"Недопустимые параметры командной строки:"); + addPair("For help on options type 'astyle -h'", L"Для получения справки по 'astyle -h' опций типа"); + addPair("Cannot open options file", L"Не удается открыть файл параметров"); + addPair("Cannot open directory", L"Не могу открыть каталог"); + addPair("Cannot open HTML file %s\n", L"Не удается открыть файл HTML %s\n"); + addPair("Command execute failure", L"Выполнить команду недостаточности"); + addPair("Command is not installed", L"Не установлен Команда"); + addPair("Missing filename in %s\n", L"Отсутствует имя файла в %s\n"); + addPair("Recursive option with no wildcard", L"Рекурсивный вариант без каких-либо шаблона"); + addPair("Did you intend quote the filename", L"Вы намерены цитатой файла"); + addPair("No file to process %s\n", L"Нет файлов для обработки %s\n"); + addPair("Did you intend to use --recursive", L"Неужели вы собираетесь использовать --recursive"); + addPair("Cannot process UTF-32 encoding", L"Не удается обработать UTF-32 кодировке"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style прекратил"); +} + +Spanish::Spanish() // Español +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formato %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Inalterado %s\n"); // should align with formatted + addPair("Directory %s\n", L"Directorio %s\n"); + addPair("Exclude %s\n", L"Excluir %s\n"); + addPair("Exclude (unmatched) %s\n", L"Excluir (incomparable) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formato %s inalterado "); + addPair(" seconds ", L" segundo "); + addPair("%d min %d sec ", L"%d min %d seg "); + addPair("%s lines\n", L"%s líneas\n"); + addPair("Using default options file %s\n", L"Uso de las opciones por defecto del archivo %s\n"); + addPair("Opening HTML documentation %s\n", L"Apertura de documentación HTML %s\n"); + addPair("Invalid option file options:", L"Opción no válida opciones de archivo:"); + addPair("Invalid command line options:", L"No válido opciones de línea de comando:"); + addPair("For help on options type 'astyle -h'", L"Para obtener ayuda sobre las opciones tipo 'astyle -h'"); + addPair("Cannot open options file", L"No se puede abrir el archivo de opciones"); + addPair("Cannot open directory", L"No se puede abrir el directorio"); + addPair("Cannot open HTML file %s\n", L"No se puede abrir el archivo HTML %s\n"); + addPair("Command execute failure", L"Ejecutar el fracaso de comandos"); + addPair("Command is not installed", L"El comando no está instalado"); + addPair("Missing filename in %s\n", L"Falta nombre del archivo en %s\n"); + addPair("Recursive option with no wildcard", L"Recursiva opción sin comodín"); + addPair("Did you intend quote the filename", L"Se tiene la intención de citar el nombre de archivo"); + addPair("No file to process %s\n", L"No existe el fichero a procesar %s\n"); + addPair("Did you intend to use --recursive", L"Se va a utilizar --recursive"); + addPair("Cannot process UTF-32 encoding", L"No se puede procesar la codificación UTF-32"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style ha terminado"); +} + +Swedish::Swedish() // Svenska +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"Formaterade %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"Oförändrade %s\n"); // should align with formatted + addPair("Directory %s\n", L"Katalog %s\n"); + addPair("Exclude %s\n", L"Uteslut %s\n"); + addPair("Exclude (unmatched) %s\n", L"Uteslut (oöverträffad) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s formaterade %s oförändrade "); + addPair(" seconds ", L" sekunder "); + addPair("%d min %d sec ", L"%d min %d sek "); + addPair("%s lines\n", L"%s linjer\n"); + addPair("Using default options file %s\n", L"Använda standardalternativ fil %s\n"); + addPair("Opening HTML documentation %s\n", L"Öppna HTML-dokumentation %s\n"); + addPair("Invalid option file options:", L"Ogiltigt alternativ fil alternativ:"); + addPair("Invalid command line options:", L"Ogiltig kommandoraden alternativ:"); + addPair("For help on options type 'astyle -h'", L"För hjälp om alternativ typ 'astyle -h'"); + addPair("Cannot open options file", L"Kan inte öppna inställningsfilen"); + addPair("Cannot open directory", L"Kan inte öppna katalog"); + addPair("Cannot open HTML file %s\n", L"Kan inte öppna HTML-filen %s\n"); + addPair("Command execute failure", L"Utför kommando misslyckande"); + addPair("Command is not installed", L"Kommandot är inte installerat"); + addPair("Missing filename in %s\n", L"Saknade filnamn i %s\n"); + addPair("Recursive option with no wildcard", L"Rekursiva alternativ utan jokertecken"); + addPair("Did you intend quote the filename", L"Visste du tänker citera filnamnet"); + addPair("No file to process %s\n", L"Ingen fil att bearbeta %s\n"); + addPair("Did you intend to use --recursive", L"Har du för avsikt att använda --recursive"); + addPair("Cannot process UTF-32 encoding", L"Kan inte hantera UTF-32 kodning"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style har upphört"); +} + +Ukrainian::Ukrainian() // Український +// build the translation vector in the Translation base class +{ + addPair("Formatted %s\n", L"форматований %s\n"); // should align with unchanged + addPair("Unchanged %s\n", L"без змін %s\n"); // should align with formatted + addPair("Directory %s\n", L"Каталог %s\n"); + addPair("Exclude %s\n", L"Виключити %s\n"); + addPair("Exclude (unmatched) %s\n", L"Виключити (неперевершений) %s\n"); + addPair(" %s formatted %s unchanged ", L" %s відформатований %s без змін "); + addPair(" seconds ", L" секунди "); + addPair("%d min %d sec ", L"%d хви %d cek "); + addPair("%s lines\n", L"%s ліній\n"); + addPair("Using default options file %s\n", L"Використання файлів опцій за замовчуванням %s\n"); + addPair("Opening HTML documentation %s\n", L"Відкриття HTML документації %s\n"); + addPair("Invalid option file options:", L"Неприпустимий файл опцій опцію:"); + addPair("Invalid command line options:", L"Неприпустима параметри командного рядка:"); + addPair("For help on options type 'astyle -h'", L"Для отримання довідки по 'astyle -h' опцій типу"); + addPair("Cannot open options file", L"Не вдається відкрити файл параметрів"); + addPair("Cannot open directory", L"Не можу відкрити каталог"); + addPair("Cannot open HTML file %s\n", L"Не вдається відкрити файл HTML %s\n"); + addPair("Command execute failure", L"Виконати команду недостатності"); + addPair("Command is not installed", L"Не встановлений Команда"); + addPair("Missing filename in %s\n", L"Відсутня назва файлу в %s\n"); + addPair("Recursive option with no wildcard", L"Рекурсивний варіант без будь-яких шаблону"); + addPair("Did you intend quote the filename", L"Ви маєте намір цитатою файлу"); + addPair("No file to process %s\n", L"Немає файлів для обробки %s\n"); + addPair("Did you intend to use --recursive", L"Невже ви збираєтеся використовувати --recursive"); + addPair("Cannot process UTF-32 encoding", L"Не вдається обробити UTF-32 кодуванні"); + addPair("\nArtistic Style has terminated", L"\nArtistic Style припинив"); +} + + +#endif // ASTYLE_LIB + +} // end of namespace astyle + diff --git a/thirdparty/astyle/ASLocalizer.h b/thirdparty/astyle/ASLocalizer.h new file mode 100755 index 00000000..c62f3a1b --- /dev/null +++ b/thirdparty/astyle/ASLocalizer.h @@ -0,0 +1,159 @@ +// ASLocalizer.h +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + + +#ifndef ASLOCALIZER_H +#define ASLOCALIZER_H + +#include +#include + +namespace astyle { + +using namespace std; + +#ifndef ASTYLE_LIB + +//----------------------------------------------------------------------------- +// ASLocalizer class for console build. +// This class encapsulates all language-dependent settings and is a +// generalization of the C locale concept. +//----------------------------------------------------------------------------- +class Translation; + +class ASLocalizer +{ +public: // functions + ASLocalizer(); + virtual ~ASLocalizer(); + string getLanguageID() const; + const Translation* getTranslationClass() const; +#ifdef _WIN32 + void setLanguageFromLCID(size_t lcid); +#endif + void setLanguageFromName(const char* langID); + const char* settext(const char* textIn) const; + +private: // functions + void setTranslationClass(); + +private: // variables + Translation* m_translation; // pointer to a polymorphic Translation class + string m_langID; // language identifier from the locale + string m_subLangID; // sub language identifier, if needed + string m_localeName; // name of the current locale (Linux only) + size_t m_lcid; // LCID of the user locale (Windows only) +}; + +//---------------------------------------------------------------------------- +// Translation base class. +//---------------------------------------------------------------------------- + +class Translation +// This base class is inherited by the language translation classes. +// Polymorphism is used to call the correct language translator. +// This class contains the translation vector and settext translation method. +// The language vector is built by the language sub classes. +// NOTE: This class must have virtual methods for typeid() to work. +// typeid() is used by AStyleTestI18n_Localizer.cpp. +{ +public: + Translation() {} + virtual ~Translation() {} + string convertToMultiByte(const wstring& wideStr) const; + size_t getTranslationVectorSize() const; + bool getWideTranslation(const string& stringIn, wstring& wideOut) const; + string& translate(const string& stringIn) const; + +protected: + void addPair(const string& english, const wstring& translated); + // variables + vector > m_translation; // translation vector + +private: + mutable string m_mbTranslation; +}; + +//---------------------------------------------------------------------------- +// Translation classes +// One class for each language. +// These classes have only a constructor which builds the language vector. +//---------------------------------------------------------------------------- + +class Bulgarian : public Translation +{ public: Bulgarian(); }; + +class ChineseSimplified : public Translation +{ public: ChineseSimplified(); }; + +class ChineseTraditional : public Translation +{ public: ChineseTraditional(); }; + +class Dutch : public Translation +{ public: Dutch(); }; + +class English : public Translation +{ public: English(); }; + +class Estonian : public Translation +{ public: Estonian(); }; + +class Finnish : public Translation +{ public: Finnish(); }; + +class French : public Translation +{ public: French(); }; + +class German : public Translation +{ public: German(); }; + +class Greek : public Translation +{ public: Greek(); }; + +class Hindi : public Translation +{ public: Hindi(); }; + +class Hungarian : public Translation +{ public: Hungarian(); }; + +class Italian : public Translation +{ public: Italian(); }; + +class Japanese : public Translation +{ public: Japanese(); }; + +class Korean : public Translation +{ public: Korean(); }; + +class Norwegian : public Translation +{ public: Norwegian(); }; + +class Polish : public Translation +{ public: Polish(); }; + +class Portuguese : public Translation +{ public: Portuguese(); }; + +class Romanian : public Translation +{ public: Romanian(); }; + +class Russian : public Translation +{ public: Russian(); }; + +class Spanish : public Translation +{ public: Spanish(); }; + +class Swedish : public Translation +{ public: Swedish(); }; + +class Ukrainian : public Translation +{ public: Ukrainian(); }; + + +#endif // ASTYLE_LIB + +} // namespace astyle + +#endif // ASLOCALIZER_H diff --git a/thirdparty/astyle/ASResource.cpp b/thirdparty/astyle/ASResource.cpp new file mode 100755 index 00000000..f814bdf1 --- /dev/null +++ b/thirdparty/astyle/ASResource.cpp @@ -0,0 +1,833 @@ +// ASResource.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#include "astyle.h" +#include + +//----------------------------------------------------------------------------- +// astyle namespace +//----------------------------------------------------------------------------- + +namespace astyle { +// +const string ASResource::_AS_EXCEPT = string("__except"); +const string ASResource::_AS_FINALLY = string("__finally"); +const string ASResource::_AS_TRY = string("__try"); +const string ASResource::AS_ADD = string("add"); +const string ASResource::AS_AUTO = string("auto"); +const string ASResource::AS_AUTORELEASEPOOL = string("autoreleasepool"); +const string ASResource::AS_CASE = string("case"); +const string ASResource::AS_CATCH = string("catch"); +const string ASResource::AS_CLASS = string("class"); +const string ASResource::AS_CONST = string("const"); +const string ASResource::AS_CONST_CAST = string("const_cast"); +const string ASResource::AS_DEFAULT = string("default"); +const string ASResource::AS_DELEGATE = string("delegate"); +const string ASResource::AS_DELETE = string("delete"); +const string ASResource::AS_DO = string("do"); +const string ASResource::AS_DYNAMIC_CAST = string("dynamic_cast"); +const string ASResource::AS_ELSE = string("else"); +const string ASResource::AS_END = string("end"); +const string ASResource::AS_ENUM = string("enum"); +const string ASResource::AS_EXTERN = string("extern"); +const string ASResource::AS_FINALLY = string("finally"); +const string ASResource::AS_FIXED = string("fixed"); +const string ASResource::AS_FOR = string("for"); +const string ASResource::AS_FOREACH = string("foreach"); +const string ASResource::AS_FOREVER = string("forever"); +const string ASResource::AS_GET = string("get"); +const string ASResource::AS_IF = string("if"); +const string ASResource::AS_INTERFACE = string("interface"); +const string ASResource::AS_INTERRUPT = string("interrupt"); +const string ASResource::AS_LET = string("let"); +const string ASResource::AS_LOCK = string("lock"); +const string ASResource::AS_MODULE = string("module"); // CORBA IDL module definition +const string ASResource::AS_NAMESPACE = string("namespace"); +const string ASResource::AS_NEW = string("new"); +const string ASResource::AS_NOEXCEPT = string("noexcept"); +const string ASResource::AS_NS_DURING = string("NS_DURING"); +const string ASResource::AS_NS_HANDLER = string("NS_HANDLER"); +const string ASResource::AS_OPERATOR = string("operator"); +const string ASResource::AS_OVERRIDE = string("override"); +const string ASResource::AS_PRIVATE = string("private"); +const string ASResource::AS_PROTECTED = string("protected"); +const string ASResource::AS_PUBLIC = string("public"); +const string ASResource::AS_QFOREACH = string("Q_FOREACH"); +const string ASResource::AS_QFOREVER = string("Q_FOREVER"); +const string ASResource::AS_REINTERPRET_CAST = string("reinterpret_cast"); +const string ASResource::AS_REMOVE = string("remove"); +const string ASResource::AS_SEALED = string("sealed"); +const string ASResource::AS_SELECTOR = string("selector"); +const string ASResource::AS_SET = string("set"); +const string ASResource::AS_STATIC = string("static"); +const string ASResource::AS_STATIC_CAST = string("static_cast"); +const string ASResource::AS_STRUCT = string("struct"); +const string ASResource::AS_SWITCH = string("switch"); +const string ASResource::AS_SYNCHRONIZED = string("synchronized"); +const string ASResource::AS_TEMPLATE = string("template"); +const string ASResource::AS_THROW = string("throw"); +const string ASResource::AS_THROWS = string("throws"); +const string ASResource::AS_TRY = string("try"); +const string ASResource::AS_UNCHECKED = string("unchecked"); +const string ASResource::AS_UNION = string("union"); +const string ASResource::AS_UNSAFE = string("unsafe"); +const string ASResource::AS_USING = string("using"); +const string ASResource::AS_VOLATILE = string("volatile"); +const string ASResource::AS_WHERE = string("where"); +const string ASResource::AS_WHILE = string("while"); + +const string ASResource::AS_ASM = string("asm"); +const string ASResource::AS__ASM__ = string("__asm__"); +const string ASResource::AS_MS_ASM = string("_asm"); +const string ASResource::AS_MS__ASM = string("__asm"); + +const string ASResource::AS_BAR_DEFINE = string("#define"); +const string ASResource::AS_BAR_INCLUDE = string("#include"); +const string ASResource::AS_BAR_IF = string("#if"); +const string ASResource::AS_BAR_EL = string("#el"); +const string ASResource::AS_BAR_ENDIF = string("#endif"); + +const string ASResource::AS_OPEN_BRACE = string("{"); +const string ASResource::AS_CLOSE_BRACE = string("}"); +const string ASResource::AS_OPEN_LINE_COMMENT = string("//"); +const string ASResource::AS_OPEN_COMMENT = string("/*"); +const string ASResource::AS_CLOSE_COMMENT = string("*/"); + +const string ASResource::AS_ASSIGN = string("="); +const string ASResource::AS_PLUS_ASSIGN = string("+="); +const string ASResource::AS_MINUS_ASSIGN = string("-="); +const string ASResource::AS_MULT_ASSIGN = string("*="); +const string ASResource::AS_DIV_ASSIGN = string("/="); +const string ASResource::AS_MOD_ASSIGN = string("%="); +const string ASResource::AS_OR_ASSIGN = string("|="); +const string ASResource::AS_AND_ASSIGN = string("&="); +const string ASResource::AS_XOR_ASSIGN = string("^="); +const string ASResource::AS_GR_GR_ASSIGN = string(">>="); +const string ASResource::AS_LS_LS_ASSIGN = string("<<="); +const string ASResource::AS_GR_GR_GR_ASSIGN = string(">>>="); +const string ASResource::AS_LS_LS_LS_ASSIGN = string("<<<="); +const string ASResource::AS_GCC_MIN_ASSIGN = string("?"); + +const string ASResource::AS_RETURN = string("return"); +const string ASResource::AS_CIN = string("cin"); +const string ASResource::AS_COUT = string("cout"); +const string ASResource::AS_CERR = string("cerr"); + +const string ASResource::AS_EQUAL = string("=="); +const string ASResource::AS_PLUS_PLUS = string("++"); +const string ASResource::AS_MINUS_MINUS = string("--"); +const string ASResource::AS_NOT_EQUAL = string("!="); +const string ASResource::AS_GR_EQUAL = string(">="); +const string ASResource::AS_GR_GR = string(">>"); +const string ASResource::AS_GR_GR_GR = string(">>>"); +const string ASResource::AS_LS_EQUAL = string("<="); +const string ASResource::AS_LS_LS = string("<<"); +const string ASResource::AS_LS_LS_LS = string("<<<"); +const string ASResource::AS_QUESTION_QUESTION = string("??"); +const string ASResource::AS_LAMBDA = string("=>"); // C# lambda expression arrow +const string ASResource::AS_ARROW = string("->"); +const string ASResource::AS_AND = string("&&"); +const string ASResource::AS_OR = string("||"); +const string ASResource::AS_SCOPE_RESOLUTION = string("::"); + +const string ASResource::AS_PLUS = string("+"); +const string ASResource::AS_MINUS = string("-"); +const string ASResource::AS_MULT = string("*"); +const string ASResource::AS_DIV = string("/"); +const string ASResource::AS_MOD = string("%"); +const string ASResource::AS_GR = string(">"); +const string ASResource::AS_LS = string("<"); +const string ASResource::AS_NOT = string("!"); +const string ASResource::AS_BIT_OR = string("|"); +const string ASResource::AS_BIT_AND = string("&"); +const string ASResource::AS_BIT_NOT = string("~"); +const string ASResource::AS_BIT_XOR = string("^"); +const string ASResource::AS_QUESTION = string("?"); +const string ASResource::AS_COLON = string(":"); +const string ASResource::AS_COMMA = string(","); +const string ASResource::AS_SEMICOLON = string(";"); + +/** + * Sort comparison function. + * Compares the length of the value of pointers in the vectors. + * The LONGEST strings will be first in the vector. + * + * @param a and b, the string pointers to be compared. + */ +bool sortOnLength(const string* a, const string* b) +{ + return (*a).length() > (*b).length(); +} + +/** + * Sort comparison function. + * Compares the value of pointers in the vectors. + * + * @param a and b, the string pointers to be compared. + */ +bool sortOnName(const string* a, const string* b) +{ + return *a < *b; +} + +/** + * Build the vector of assignment operators. + * Used by BOTH ASFormatter.cpp and ASBeautifier.cpp + * + * @param assignmentOperators a reference to the vector to be built. + */ +void ASResource::buildAssignmentOperators(vector* assignmentOperators) +{ + const size_t elements = 15; + static bool reserved = false; + if (!reserved) + { + assignmentOperators->reserve(elements); + reserved = true; + } + + assignmentOperators->emplace_back(&AS_ASSIGN); + assignmentOperators->emplace_back(&AS_PLUS_ASSIGN); + assignmentOperators->emplace_back(&AS_MINUS_ASSIGN); + assignmentOperators->emplace_back(&AS_MULT_ASSIGN); + assignmentOperators->emplace_back(&AS_DIV_ASSIGN); + assignmentOperators->emplace_back(&AS_MOD_ASSIGN); + assignmentOperators->emplace_back(&AS_OR_ASSIGN); + assignmentOperators->emplace_back(&AS_AND_ASSIGN); + assignmentOperators->emplace_back(&AS_XOR_ASSIGN); + + // Java + assignmentOperators->emplace_back(&AS_GR_GR_GR_ASSIGN); + assignmentOperators->emplace_back(&AS_GR_GR_ASSIGN); + assignmentOperators->emplace_back(&AS_LS_LS_ASSIGN); + + // Unknown + assignmentOperators->emplace_back(&AS_LS_LS_LS_ASSIGN); + + assert(assignmentOperators->size() < elements); + sort(assignmentOperators->begin(), assignmentOperators->end(), sortOnLength); +} + +/** + * Build the vector of C++ cast operators. + * Used by ONLY ASFormatter.cpp + * + * @param castOperators a reference to the vector to be built. + */ +void ASResource::buildCastOperators(vector* castOperators) +{ + const size_t elements = 5; + static bool reserved = false; + if (!reserved) + { + castOperators->reserve(elements); + reserved = true; + } + + castOperators->emplace_back(&AS_CONST_CAST); + castOperators->emplace_back(&AS_DYNAMIC_CAST); + castOperators->emplace_back(&AS_REINTERPRET_CAST); + castOperators->emplace_back(&AS_STATIC_CAST); + + assert(castOperators->size() < elements); + sort(castOperators->begin(), castOperators->end(), sortOnName); +} + +/** + * Build the vector of header words. + * Used by BOTH ASFormatter.cpp and ASBeautifier.cpp + * + * @param headers a reference to the vector to be built. + */ +void ASResource::buildHeaders(vector* headers, int fileType, bool beautifier) +{ + const size_t elements = 25; + static bool reserved = false; + if (!reserved) + { + headers->reserve(elements); + reserved = true; + } + + headers->emplace_back(&AS_IF); + headers->emplace_back(&AS_ELSE); + headers->emplace_back(&AS_FOR); + headers->emplace_back(&AS_WHILE); + headers->emplace_back(&AS_DO); + headers->emplace_back(&AS_SWITCH); + headers->emplace_back(&AS_CASE); + headers->emplace_back(&AS_DEFAULT); + headers->emplace_back(&AS_TRY); + headers->emplace_back(&AS_CATCH); + headers->emplace_back(&AS_QFOREACH); // QT + headers->emplace_back(&AS_QFOREVER); // QT + headers->emplace_back(&AS_FOREACH); // QT & C# + headers->emplace_back(&AS_FOREVER); // Qt & Boost + + if (fileType == C_TYPE) + { + headers->emplace_back(&_AS_TRY); // __try + headers->emplace_back(&_AS_FINALLY); // __finally + headers->emplace_back(&_AS_EXCEPT); // __except + } + if (fileType == JAVA_TYPE) + { + headers->emplace_back(&AS_FINALLY); + headers->emplace_back(&AS_SYNCHRONIZED); + } + + if (fileType == SHARP_TYPE) + { + headers->emplace_back(&AS_FINALLY); + headers->emplace_back(&AS_LOCK); + headers->emplace_back(&AS_FIXED); + headers->emplace_back(&AS_GET); + headers->emplace_back(&AS_SET); + headers->emplace_back(&AS_ADD); + headers->emplace_back(&AS_REMOVE); + headers->emplace_back(&AS_USING); + } + + if (beautifier) + { + if (fileType == C_TYPE) + { + headers->emplace_back(&AS_TEMPLATE); + } + + if (fileType == JAVA_TYPE) + { + headers->emplace_back(&AS_STATIC); // for static constructor + } + } + + assert(headers->size() < elements); + sort(headers->begin(), headers->end(), sortOnName); +} + +/** + * Build the vector of indentable headers. + * Used by ONLY ASBeautifier.cpp + * + * @param indentableHeaders a reference to the vector to be built. + */ +void ASResource::buildIndentableHeaders(vector* indentableHeaders) +{ + indentableHeaders->emplace_back(&AS_RETURN); + +// sort(indentableHeaders->begin(), indentableHeaders->end(), sortOnName); +} + +/** +* Build the vector of indentable macros pairs. +* Initialized by ASFormatter, used by ONLY ASEnhancer.cpp +* +* @param indentableMacros a reference to the vector to be built. +*/ +void ASResource::buildIndentableMacros(vector* >* indentableMacros) +{ + const size_t elements = 10; + static bool reserved = false; + if (!reserved) + { + indentableMacros->reserve(elements); + reserved = true; + } + + // the pairs must be retained in memory because of pair pointers + typedef pair macro_pair; + static const macro_pair macros[] = + { + // wxWidgets + macro_pair("BEGIN_EVENT_TABLE", "END_EVENT_TABLE"), + macro_pair("wxBEGIN_EVENT_TABLE", "wxEND_EVENT_TABLE"), + // MFC + macro_pair("BEGIN_DISPATCH_MAP", "END_DISPATCH_MAP"), + macro_pair("BEGIN_EVENT_MAP", "END_EVENT_MAP"), + macro_pair("BEGIN_MESSAGE_MAP", "END_MESSAGE_MAP"), + macro_pair("BEGIN_PROPPAGEIDS", "END_PROPPAGEIDS"), + }; + + size_t entries = sizeof(macros) / sizeof(macros[0]); + for (size_t i = 0; i < entries; i++) + indentableMacros->emplace_back(¯os[i]); + + assert(indentableMacros->size() < elements); +} + +/** + * Build the vector of non-assignment operators. + * Used by ONLY ASBeautifier.cpp + * + * @param nonAssignmentOperators a reference to the vector to be built. + */ +void ASResource::buildNonAssignmentOperators(vector* nonAssignmentOperators) +{ + const size_t elements = 15; + static bool reserved = false; + if (!reserved) + { + nonAssignmentOperators->reserve(elements); + reserved = true; + } + + nonAssignmentOperators->emplace_back(&AS_EQUAL); + nonAssignmentOperators->emplace_back(&AS_PLUS_PLUS); + nonAssignmentOperators->emplace_back(&AS_MINUS_MINUS); + nonAssignmentOperators->emplace_back(&AS_NOT_EQUAL); + nonAssignmentOperators->emplace_back(&AS_GR_EQUAL); + nonAssignmentOperators->emplace_back(&AS_GR_GR_GR); + nonAssignmentOperators->emplace_back(&AS_GR_GR); + nonAssignmentOperators->emplace_back(&AS_LS_EQUAL); + nonAssignmentOperators->emplace_back(&AS_LS_LS_LS); + nonAssignmentOperators->emplace_back(&AS_LS_LS); + nonAssignmentOperators->emplace_back(&AS_ARROW); + nonAssignmentOperators->emplace_back(&AS_AND); + nonAssignmentOperators->emplace_back(&AS_OR); + nonAssignmentOperators->emplace_back(&AS_LAMBDA); + + assert(nonAssignmentOperators->size() < elements); + sort(nonAssignmentOperators->begin(), nonAssignmentOperators->end(), sortOnLength); +} + +/** + * Build the vector of header non-paren headers. + * Used by BOTH ASFormatter.cpp and ASBeautifier.cpp. + * NOTE: Non-paren headers should also be included in the headers vector. + * + * @param nonParenHeaders a reference to the vector to be built. + */ +void ASResource::buildNonParenHeaders(vector* nonParenHeaders, int fileType, bool beautifier) +{ + const size_t elements = 20; + static bool reserved = false; + if (!reserved) + { + nonParenHeaders->reserve(elements); + reserved = true; + } + + nonParenHeaders->emplace_back(&AS_ELSE); + nonParenHeaders->emplace_back(&AS_DO); + nonParenHeaders->emplace_back(&AS_TRY); + nonParenHeaders->emplace_back(&AS_CATCH); // can be paren or non-paren + nonParenHeaders->emplace_back(&AS_CASE); // can be paren or non-paren + nonParenHeaders->emplace_back(&AS_DEFAULT); + nonParenHeaders->emplace_back(&AS_QFOREVER); // QT + nonParenHeaders->emplace_back(&AS_FOREVER); // Boost + + if (fileType == C_TYPE) + { + nonParenHeaders->emplace_back(&_AS_TRY); // __try + nonParenHeaders->emplace_back(&_AS_FINALLY); // __finally + } + if (fileType == JAVA_TYPE) + { + nonParenHeaders->emplace_back(&AS_FINALLY); + } + + if (fileType == SHARP_TYPE) + { + nonParenHeaders->emplace_back(&AS_FINALLY); + nonParenHeaders->emplace_back(&AS_GET); + nonParenHeaders->emplace_back(&AS_SET); + nonParenHeaders->emplace_back(&AS_ADD); + nonParenHeaders->emplace_back(&AS_REMOVE); + } + + if (beautifier) + { + if (fileType == C_TYPE) + { + nonParenHeaders->emplace_back(&AS_TEMPLATE); + } + if (fileType == JAVA_TYPE) + { + nonParenHeaders->emplace_back(&AS_STATIC); + } + } + + assert(nonParenHeaders->size() < elements); + sort(nonParenHeaders->begin(), nonParenHeaders->end(), sortOnName); +} + +/** + * Build the vector of operators. + * Used by ONLY ASFormatter.cpp + * + * @param operators a reference to the vector to be built. + */ +void ASResource::buildOperators(vector* operators, int fileType) +{ + const size_t elements = 50; + static bool reserved = false; + if (!reserved) + { + operators->reserve(elements); + reserved = true; + } + + + operators->emplace_back(&AS_PLUS_ASSIGN); + operators->emplace_back(&AS_MINUS_ASSIGN); + operators->emplace_back(&AS_MULT_ASSIGN); + operators->emplace_back(&AS_DIV_ASSIGN); + operators->emplace_back(&AS_MOD_ASSIGN); + operators->emplace_back(&AS_OR_ASSIGN); + operators->emplace_back(&AS_AND_ASSIGN); + operators->emplace_back(&AS_XOR_ASSIGN); + operators->emplace_back(&AS_EQUAL); + operators->emplace_back(&AS_PLUS_PLUS); + operators->emplace_back(&AS_MINUS_MINUS); + operators->emplace_back(&AS_NOT_EQUAL); + operators->emplace_back(&AS_GR_EQUAL); + operators->emplace_back(&AS_GR_GR_GR_ASSIGN); + operators->emplace_back(&AS_GR_GR_ASSIGN); + operators->emplace_back(&AS_GR_GR_GR); + operators->emplace_back(&AS_GR_GR); + operators->emplace_back(&AS_LS_EQUAL); + operators->emplace_back(&AS_LS_LS_LS_ASSIGN); + operators->emplace_back(&AS_LS_LS_ASSIGN); + operators->emplace_back(&AS_LS_LS_LS); + operators->emplace_back(&AS_LS_LS); + operators->emplace_back(&AS_QUESTION_QUESTION); + operators->emplace_back(&AS_LAMBDA); + operators->emplace_back(&AS_ARROW); + operators->emplace_back(&AS_AND); + operators->emplace_back(&AS_OR); + operators->emplace_back(&AS_SCOPE_RESOLUTION); + operators->emplace_back(&AS_PLUS); + operators->emplace_back(&AS_MINUS); + operators->emplace_back(&AS_MULT); + operators->emplace_back(&AS_DIV); + operators->emplace_back(&AS_MOD); + operators->emplace_back(&AS_QUESTION); + operators->emplace_back(&AS_COLON); + operators->emplace_back(&AS_ASSIGN); + operators->emplace_back(&AS_LS); + operators->emplace_back(&AS_GR); + operators->emplace_back(&AS_NOT); + operators->emplace_back(&AS_BIT_OR); + operators->emplace_back(&AS_BIT_AND); + operators->emplace_back(&AS_BIT_NOT); + operators->emplace_back(&AS_BIT_XOR); + if (fileType == C_TYPE) + { + operators->emplace_back(&AS_GCC_MIN_ASSIGN); + operators->emplace_back(&AS_GCC_MAX_ASSIGN); + } + + assert(operators->size() < elements); + sort(operators->begin(), operators->end(), sortOnLength); +} + +/** + * Build the vector of pre-block statements. + * Used by ONLY ASBeautifier.cpp + * NOTE: Cannot be both a header and a preBlockStatement. + * + * @param preBlockStatements a reference to the vector to be built. + */ +void ASResource::buildPreBlockStatements(vector* preBlockStatements, int fileType) +{ + const size_t elements = 10; + static bool reserved = false; + if (!reserved) + { + preBlockStatements->reserve(elements); + reserved = true; + } + + preBlockStatements->emplace_back(&AS_CLASS); + if (fileType == C_TYPE) + { + preBlockStatements->emplace_back(&AS_STRUCT); + preBlockStatements->emplace_back(&AS_UNION); + preBlockStatements->emplace_back(&AS_NAMESPACE); + preBlockStatements->emplace_back(&AS_MODULE); // for CORBA IDL + preBlockStatements->emplace_back(&AS_INTERFACE); // for CORBA IDL + } + if (fileType == JAVA_TYPE) + { + preBlockStatements->emplace_back(&AS_INTERFACE); + preBlockStatements->emplace_back(&AS_THROWS); + } + if (fileType == SHARP_TYPE) + { + preBlockStatements->emplace_back(&AS_INTERFACE); + preBlockStatements->emplace_back(&AS_NAMESPACE); + preBlockStatements->emplace_back(&AS_WHERE); + preBlockStatements->emplace_back(&AS_STRUCT); + } + + assert(preBlockStatements->size() < elements); + sort(preBlockStatements->begin(), preBlockStatements->end(), sortOnName); +} + +/** + * Build the vector of pre-command headers. + * Used by BOTH ASFormatter.cpp and ASBeautifier.cpp. + * NOTE: Cannot be both a header and a preCommandHeader. + * + * A preCommandHeader is in a function definition between + * the closing paren and the opening brace. + * e.g. in "void foo() const {}", "const" is a preCommandHeader. + */ +void ASResource::buildPreCommandHeaders(vector* preCommandHeaders, int fileType) +{ + const size_t elements = 10; + static bool reserved = false; + if (!reserved) + { + preCommandHeaders->reserve(elements); + reserved = true; + } + + if (fileType == C_TYPE) + { + preCommandHeaders->emplace_back(&AS_CONST); + preCommandHeaders->emplace_back(&AS_VOLATILE); + preCommandHeaders->emplace_back(&AS_INTERRUPT); + preCommandHeaders->emplace_back(&AS_NOEXCEPT); + preCommandHeaders->emplace_back(&AS_OVERRIDE); + preCommandHeaders->emplace_back(&AS_SEALED); // Visual C only + preCommandHeaders->emplace_back(&AS_AUTORELEASEPOOL); // Obj-C only + } + + if (fileType == JAVA_TYPE) + { + preCommandHeaders->emplace_back(&AS_THROWS); + } + + if (fileType == SHARP_TYPE) + { + preCommandHeaders->emplace_back(&AS_WHERE); + } + + assert(preCommandHeaders->size() < elements); + sort(preCommandHeaders->begin(), preCommandHeaders->end(), sortOnName); +} + +/** + * Build the vector of pre-definition headers. + * Used by ONLY ASFormatter.cpp + * NOTE: Do NOT add 'enum' here. It is an array type brace. + * NOTE: Do NOT add 'extern' here. Do not want an extra indent. + * + * @param preDefinitionHeaders a reference to the vector to be built. + */ +void ASResource::buildPreDefinitionHeaders(vector* preDefinitionHeaders, int fileType) +{ + const size_t elements = 10; + static bool reserved = false; + if (!reserved) + { + preDefinitionHeaders->reserve(elements); + reserved = true; + } + + preDefinitionHeaders->emplace_back(&AS_CLASS); + if (fileType == C_TYPE) + { + preDefinitionHeaders->emplace_back(&AS_STRUCT); + preDefinitionHeaders->emplace_back(&AS_UNION); + preDefinitionHeaders->emplace_back(&AS_NAMESPACE); + preDefinitionHeaders->emplace_back(&AS_MODULE); // for CORBA IDL + preDefinitionHeaders->emplace_back(&AS_INTERFACE); // for CORBA IDL + } + if (fileType == JAVA_TYPE) + { + preDefinitionHeaders->emplace_back(&AS_INTERFACE); + } + if (fileType == SHARP_TYPE) + { + preDefinitionHeaders->emplace_back(&AS_STRUCT); + preDefinitionHeaders->emplace_back(&AS_INTERFACE); + preDefinitionHeaders->emplace_back(&AS_NAMESPACE); + } + + assert(preDefinitionHeaders->size() < elements); + sort(preDefinitionHeaders->begin(), preDefinitionHeaders->end(), sortOnName); +} + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * ASBase Functions + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +// check if a specific line position contains a header. +const string* ASBase::findHeader(const string& line, int i, + const vector* possibleHeaders) const +{ + assert(isCharPotentialHeader(line, i)); + // check the word + size_t maxHeaders = possibleHeaders->size(); + for (size_t p = 0; p < maxHeaders; p++) + { + const string* header = (*possibleHeaders)[p]; + const size_t wordEnd = i + header->length(); + if (wordEnd > line.length()) + continue; + int result = (line.compare(i, header->length(), *header)); + if (result > 0) + continue; + if (result < 0) + break; + // check that this is not part of a longer word + if (wordEnd == line.length()) + return header; + if (isLegalNameChar(line[wordEnd])) + continue; + const char peekChar = peekNextChar(line, wordEnd - 1); + // is not a header if part of a definition + if (peekChar == ',' || peekChar == ')') + break; + // the following accessor definitions are NOT headers + // goto default; is NOT a header + // default(int) keyword in C# is NOT a header + else if ((header == &AS_GET + || header == &AS_SET + || header == &AS_DEFAULT) + && (peekChar == ';' || peekChar == '(' || peekChar == '=')) + break; + return header; + } + return nullptr; +} + +// check if a specific line position contains a keyword. +bool ASBase::findKeyword(const string& line, int i, const string& keyword) const +{ + assert(isCharPotentialHeader(line, i)); + // check the word + const size_t keywordLength = keyword.length(); + const size_t wordEnd = i + keywordLength; + if (wordEnd > line.length()) + return false; + if (line.compare(i, keywordLength, keyword) != 0) + return false; + // check that this is not part of a longer word + if (wordEnd == line.length()) + return true; + if (isLegalNameChar(line[wordEnd])) + return false; + // is not a keyword if part of a definition + const char peekChar = peekNextChar(line, (int) wordEnd - 1); + if (peekChar == ',' || peekChar == ')') + return false; + return true; +} + +// check if a specific line position contains an operator. +const string* ASBase::findOperator(const string& line, int i, + const vector* possibleOperators) const +{ + assert(isCharPotentialOperator(line[i])); + // find the operator in the vector + // the vector contains the LONGEST operators first + // must loop thru the entire vector + size_t maxOperators = possibleOperators->size(); + for (size_t p = 0; p < maxOperators; p++) + { + const size_t wordEnd = i + (*(*possibleOperators)[p]).length(); + if (wordEnd > line.length()) + continue; + if (line.compare(i, (*(*possibleOperators)[p]).length(), *(*possibleOperators)[p]) == 0) + return (*possibleOperators)[p]; + } + return nullptr; +} + +// get the current word on a line +// index must point to the beginning of the word +string ASBase::getCurrentWord(const string& line, size_t index) const +{ + assert(isCharPotentialHeader(line, index)); + size_t lineLength = line.length(); + size_t i; + for (i = index; i < lineLength; i++) + { + if (!isLegalNameChar(line[i])) + break; + } + return line.substr(index, i - index); +} + +// check if a specific character can be used in a legal variable/method/class name +bool ASBase::isLegalNameChar(char ch) const +{ + if (isWhiteSpace(ch)) + return false; + if ((unsigned char) ch > 127) + return false; + return (isalnum((unsigned char) ch) + || ch == '.' || ch == '_' + || (isJavaStyle() && ch == '$') + || (isSharpStyle() && ch == '@')); // may be used as a prefix +} + +// check if a specific character can be part of a header +bool ASBase::isCharPotentialHeader(const string& line, size_t i) const +{ + assert(!isWhiteSpace(line[i])); + char prevCh = ' '; + if (i > 0) + prevCh = line[i - 1]; + if (!isLegalNameChar(prevCh) && isLegalNameChar(line[i])) + return true; + return false; +} + +// check if a specific character can be part of an operator +bool ASBase::isCharPotentialOperator(char ch) const +{ + assert(!isWhiteSpace(ch)); + if ((unsigned) ch > 127) + return false; + return (ispunct((unsigned char) ch) + && ch != '{' && ch != '}' + && ch != '(' && ch != ')' + && ch != '[' && ch != ']' + && ch != ';' && ch != ',' + && ch != '#' && ch != '\\' + && ch != '\'' && ch != '\"'); +} + +// check if a specific character is a digit +// NOTE: Visual C isdigit() gives assert error if char > 256 +bool ASBase::isDigit(char ch) const +{ + return (ch >= '0' && ch <= '9'); +} + +// check if a specific character is a digit separator +bool ASBase::isDigitSeparator(const string& line, int i) const +{ + assert(line[i] == '\''); + // casting to (unsigned char) eliminates negative characters + // will get a "Debug Assertion Failed" if not cast + bool foundDigitSeparator = i > 0 + && isxdigit((unsigned char) line[i - 1]) + && i < (int) line.length() - 1 + && isxdigit((unsigned char) line[i + 1]); + return foundDigitSeparator; +} + +// peek at the next unread character. +char ASBase::peekNextChar(const string& line, int i) const +{ + char ch = ' '; + size_t peekNum = line.find_first_not_of(" \t", i + 1); + if (peekNum == string::npos) + return ch; + ch = line[peekNum]; + return ch; +} + +} // end namespace astyle diff --git a/thirdparty/astyle/CMakeLists.txt b/thirdparty/astyle/CMakeLists.txt new file mode 100644 index 00000000..c2607170 --- /dev/null +++ b/thirdparty/astyle/CMakeLists.txt @@ -0,0 +1,28 @@ +SET(ASTYLE_SRCS + astyle_main.cpp + ASBeautifier.cpp + ASEnhancer.cpp + ASFormatter.cpp + ASLocalizer.cpp + ASResource.cpp +) + +if (CMAKE_VERSION VERSION_LESS "3.1") + if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set (CMAKE_CXX_FLAGS "--std=c++11 ${CMAKE_CXX_FLAGS}") + endif () +else () + set (CMAKE_CXX_STANDARD 11) +endif () + +# No warnings for astyle build +IF(NOT MSVC) + SET_SOURCE_FILES_PROPERTIES(${ASTYLE_SRCS} PROPERTIES COMPILE_FLAGS -w) +ENDIF(NOT MSVC) +ADD_EXECUTABLE(opjstyle ${ASTYLE_SRCS}) +SET_TARGET_PROPERTIES(opjstyle PROPERTIES LINKER_LANGUAGE CXX) +SET_TARGET_PROPERTIES(opjstyle PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/scripts) + +IF (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lstdc++") +ENDIF (CMAKE_CXX_COMPILER_ID MATCHES "Clang") diff --git a/thirdparty/astyle/LICENSE.md b/thirdparty/astyle/LICENSE.md new file mode 100755 index 00000000..cb356f64 --- /dev/null +++ b/thirdparty/astyle/LICENSE.md @@ -0,0 +1,21 @@ +### MIT License + +Copyright (c) 2017 by Jim Pattee . + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/thirdparty/astyle/astyle.h b/thirdparty/astyle/astyle.h new file mode 100755 index 00000000..54ef227c --- /dev/null +++ b/thirdparty/astyle/astyle.h @@ -0,0 +1,1056 @@ +// astyle.h +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +#ifndef ASTYLE_H +#define ASTYLE_H + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#ifdef __VMS + #define __USE_STD_IOSTREAM 1 + #include +#else + #include +#endif + +#include +#include // for cout +#include +#include +#include + +#ifdef __GNUC__ + #include // need both string and cstring for GCC +#endif + +//----------------------------------------------------------------------------- +// declarations +//----------------------------------------------------------------------------- + +#ifdef _MSC_VER + #pragma warning(disable: 4267) // conversion from size_t to int +#endif + +#ifdef __BORLANDC__ + #pragma warn -8004 // variable is assigned a value that is never used +#endif + +#ifdef __INTEL_COMPILER + #pragma warning(disable: 383) // value copied to temporary, reference to temporary used + #pragma warning(disable: 981) // operands are evaluated in unspecified order +#endif + +#ifdef __clang__ + #pragma clang diagnostic ignored "-Wshorten-64-to-32" +#endif + +//----------------------------------------------------------------------------- +// astyle namespace +//----------------------------------------------------------------------------- + +namespace astyle { +// +using namespace std; + +//---------------------------------------------------------------------------- +// definitions +//---------------------------------------------------------------------------- + +enum FileType { C_TYPE = 0, JAVA_TYPE = 1, SHARP_TYPE = 2 }; + +/* The enums below are not recognized by 'vectors' in Microsoft Visual C++ + V5 when they are part of a namespace!!! Use Visual C++ V6 or higher. +*/ +enum FormatStyle +{ + STYLE_NONE, + STYLE_ALLMAN, + STYLE_JAVA, + STYLE_KR, + STYLE_STROUSTRUP, + STYLE_WHITESMITH, + STYLE_VTK, + STYLE_BANNER, + STYLE_GNU, + STYLE_LINUX, + STYLE_HORSTMANN, + STYLE_1TBS, + STYLE_GOOGLE, + STYLE_MOZILLA, + STYLE_PICO, + STYLE_LISP +}; + +enum BraceMode +{ + NONE_MODE, + ATTACH_MODE, + BREAK_MODE, + LINUX_MODE, + RUN_IN_MODE // broken braces +}; + +// maximun value for int is 16,384 (total value of 32,767) +enum BraceType +{ + NULL_TYPE = 0, + NAMESPACE_TYPE = 1, // also a DEFINITION_TYPE + CLASS_TYPE = 2, // also a DEFINITION_TYPE + STRUCT_TYPE = 4, // also a DEFINITION_TYPE + INTERFACE_TYPE = 8, // also a DEFINITION_TYPE + DEFINITION_TYPE = 16, + COMMAND_TYPE = 32, + ARRAY_NIS_TYPE = 64, // also an ARRAY_TYPE + ENUM_TYPE = 128, // also an ARRAY_TYPE + INIT_TYPE = 256, // also an ARRAY_TYPE + ARRAY_TYPE = 512, + EXTERN_TYPE = 1024, // extern "C", not a command type extern + EMPTY_BLOCK_TYPE = 2048, // also a SINGLE_LINE_TYPE + BREAK_BLOCK_TYPE = 4096, // also a SINGLE_LINE_TYPE + SINGLE_LINE_TYPE = 8192 +}; + +enum MinConditional +{ + MINCOND_ZERO, + MINCOND_ONE, + MINCOND_TWO, + MINCOND_ONEHALF, + MINCOND_END +}; + +enum ObjCColonPad +{ + COLON_PAD_NO_CHANGE, + COLON_PAD_NONE, + COLON_PAD_ALL, + COLON_PAD_AFTER, + COLON_PAD_BEFORE +}; + +enum PointerAlign +{ + PTR_ALIGN_NONE, + PTR_ALIGN_TYPE, + PTR_ALIGN_MIDDLE, + PTR_ALIGN_NAME +}; + +enum ReferenceAlign +{ + REF_ALIGN_NONE = PTR_ALIGN_NONE, + REF_ALIGN_TYPE = PTR_ALIGN_TYPE, + REF_ALIGN_MIDDLE = PTR_ALIGN_MIDDLE, + REF_ALIGN_NAME = PTR_ALIGN_NAME, + REF_SAME_AS_PTR +}; + +enum FileEncoding +{ + ENCODING_8BIT, + UTF_16BE, + UTF_16LE, // Windows default + UTF_32BE, + UTF_32LE +}; + +enum LineEndFormat +{ + LINEEND_DEFAULT, // Use line break that matches most of the file + LINEEND_WINDOWS, + LINEEND_LINUX, + LINEEND_MACOLD, + LINEEND_CRLF = LINEEND_WINDOWS, + LINEEND_LF = LINEEND_LINUX, + LINEEND_CR = LINEEND_MACOLD +}; + +//----------------------------------------------------------------------------- +// Class ASSourceIterator +// A pure virtual class is used by ASFormatter and ASBeautifier instead of +// ASStreamIterator. This allows programs using AStyle as a plug-in to define +// their own ASStreamIterator. The ASStreamIterator class must inherit +// this class. +//----------------------------------------------------------------------------- + +class ASSourceIterator +{ +public: + ASSourceIterator() {} + virtual ~ASSourceIterator() {} + virtual int getStreamLength() const = 0; + virtual bool hasMoreLines() const = 0; + virtual string nextLine(bool emptyLineWasDeleted = false) = 0; + virtual string peekNextLine() = 0; + virtual void peekReset() = 0; + virtual streamoff tellg() = 0; +}; + +//----------------------------------------------------------------------------- +// Class ASPeekStream +// A small class using RAII to peek ahead in the ASSourceIterator stream +// and to reset the ASSourceIterator pointer in the destructor. +// It enables a return from anywhere in the method. +//----------------------------------------------------------------------------- + +class ASPeekStream +{ +private: + ASSourceIterator* sourceIterator; + bool needReset; // reset sourceIterator to the original position + +public: + explicit ASPeekStream(ASSourceIterator* sourceIterator_) + { sourceIterator = sourceIterator_; needReset = false; } + + ~ASPeekStream() + { if (needReset) sourceIterator->peekReset(); } + + bool hasMoreLines() const + { return sourceIterator->hasMoreLines(); } + + string peekNextLine() + { needReset = true; return sourceIterator->peekNextLine(); } +}; + + +//----------------------------------------------------------------------------- +// Class ASResource +//----------------------------------------------------------------------------- + +class ASResource +{ +public: + void buildAssignmentOperators(vector* assignmentOperators); + void buildCastOperators(vector* castOperators); + void buildHeaders(vector* headers, int fileType, bool beautifier = false); + void buildIndentableMacros(vector* >* indentableMacros); + void buildIndentableHeaders(vector* indentableHeaders); + void buildNonAssignmentOperators(vector* nonAssignmentOperators); + void buildNonParenHeaders(vector* nonParenHeaders, int fileType, bool beautifier = false); + void buildOperators(vector* operators, int fileType); + void buildPreBlockStatements(vector* preBlockStatements, int fileType); + void buildPreCommandHeaders(vector* preCommandHeaders, int fileType); + void buildPreDefinitionHeaders(vector* preDefinitionHeaders, int fileType); + +public: + static const string AS_IF, AS_ELSE; + static const string AS_DO, AS_WHILE; + static const string AS_FOR; + static const string AS_SWITCH, AS_CASE, AS_DEFAULT; + static const string AS_TRY, AS_CATCH, AS_THROW, AS_THROWS, AS_FINALLY, AS_USING; + static const string _AS_TRY, _AS_FINALLY, _AS_EXCEPT; + static const string AS_PUBLIC, AS_PROTECTED, AS_PRIVATE; + static const string AS_CLASS, AS_STRUCT, AS_UNION, AS_INTERFACE, AS_NAMESPACE; + static const string AS_MODULE; + static const string AS_END; + static const string AS_SELECTOR; + static const string AS_EXTERN, AS_ENUM; + static const string AS_STATIC, AS_CONST, AS_SEALED, AS_OVERRIDE, AS_VOLATILE, AS_NEW, AS_DELETE; + static const string AS_NOEXCEPT, AS_INTERRUPT, AS_AUTORELEASEPOOL; + static const string AS_WHERE, AS_LET, AS_SYNCHRONIZED; + static const string AS_OPERATOR, AS_TEMPLATE; + static const string AS_OPEN_BRACE, AS_CLOSE_BRACE; + static const string AS_OPEN_LINE_COMMENT, AS_OPEN_COMMENT, AS_CLOSE_COMMENT; + static const string AS_BAR_DEFINE, AS_BAR_INCLUDE, AS_BAR_IF, AS_BAR_EL, AS_BAR_ENDIF; + static const string AS_AUTO, AS_RETURN; + static const string AS_CIN, AS_COUT, AS_CERR; + static const string AS_ASSIGN, AS_PLUS_ASSIGN, AS_MINUS_ASSIGN, AS_MULT_ASSIGN; + static const string AS_DIV_ASSIGN, AS_MOD_ASSIGN, AS_XOR_ASSIGN, AS_OR_ASSIGN, AS_AND_ASSIGN; + static const string AS_GR_GR_ASSIGN, AS_LS_LS_ASSIGN, AS_GR_GR_GR_ASSIGN, AS_LS_LS_LS_ASSIGN; + static const string AS_GCC_MIN_ASSIGN, AS_GCC_MAX_ASSIGN; + static const string AS_EQUAL, AS_PLUS_PLUS, AS_MINUS_MINUS, AS_NOT_EQUAL, AS_GR_EQUAL; + static const string AS_LS_EQUAL, AS_LS_LS_LS, AS_LS_LS, AS_GR_GR_GR, AS_GR_GR; + static const string AS_QUESTION_QUESTION, AS_LAMBDA; + static const string AS_ARROW, AS_AND, AS_OR; + static const string AS_SCOPE_RESOLUTION; + static const string AS_PLUS, AS_MINUS, AS_MULT, AS_DIV, AS_MOD, AS_GR, AS_LS; + static const string AS_NOT, AS_BIT_XOR, AS_BIT_OR, AS_BIT_AND, AS_BIT_NOT; + static const string AS_QUESTION, AS_COLON, AS_SEMICOLON, AS_COMMA; + static const string AS_ASM, AS__ASM__, AS_MS_ASM, AS_MS__ASM; + static const string AS_QFOREACH, AS_QFOREVER, AS_FOREVER; + static const string AS_FOREACH, AS_LOCK, AS_UNSAFE, AS_FIXED; + static const string AS_GET, AS_SET, AS_ADD, AS_REMOVE; + static const string AS_DELEGATE, AS_UNCHECKED; + static const string AS_CONST_CAST, AS_DYNAMIC_CAST, AS_REINTERPRET_CAST, AS_STATIC_CAST; + static const string AS_NS_DURING, AS_NS_HANDLER; +}; // Class ASResource + +//----------------------------------------------------------------------------- +// Class ASBase +// Functions definitions are at the end of ASResource.cpp. +//----------------------------------------------------------------------------- + +class ASBase : protected ASResource +{ +private: + // all variables should be set by the "init" function + int baseFileType; // a value from enum FileType + +protected: + ASBase() : baseFileType(C_TYPE) { } + +protected: // inline functions + void init(int fileTypeArg) { baseFileType = fileTypeArg; } + bool isCStyle() const { return (baseFileType == C_TYPE); } + bool isJavaStyle() const { return (baseFileType == JAVA_TYPE); } + bool isSharpStyle() const { return (baseFileType == SHARP_TYPE); } + bool isWhiteSpace(char ch) const { return (ch == ' ' || ch == '\t'); } + +protected: // functions definitions are at the end of ASResource.cpp + const string* findHeader(const string& line, int i, + const vector* possibleHeaders) const; + bool findKeyword(const string& line, int i, const string& keyword) const; + const string* findOperator(const string& line, int i, + const vector* possibleOperators) const; + string getCurrentWord(const string& line, size_t index) const; + bool isDigit(char ch) const; + bool isLegalNameChar(char ch) const; + bool isCharPotentialHeader(const string& line, size_t i) const; + bool isCharPotentialOperator(char ch) const; + bool isDigitSeparator(const string& line, int i) const; + char peekNextChar(const string& line, int i) const; + +}; // Class ASBase + +//----------------------------------------------------------------------------- +// Class ASBeautifier +//----------------------------------------------------------------------------- + +class ASBeautifier : protected ASBase +{ +public: + ASBeautifier(); + virtual ~ASBeautifier(); + virtual void init(ASSourceIterator* iter); + virtual string beautify(const string& originalLine); + void setCaseIndent(bool state); + void setClassIndent(bool state); + void setContinuationIndentation(int indent = 1); + void setCStyle(); + void setDefaultTabLength(); + void setEmptyLineFill(bool state); + void setForceTabXIndentation(int length); + void setAfterParenIndent(bool state); + void setJavaStyle(); + void setLabelIndent(bool state); + void setMaxContinuationIndentLength(int max); + void setMaxInStatementIndentLength(int max); + void setMinConditionalIndentOption(int min); + void setMinConditionalIndentLength(); + void setModeManuallySet(bool state); + void setModifierIndent(bool state); + void setNamespaceIndent(bool state); + void setAlignMethodColon(bool state); + void setSharpStyle(); + void setSpaceIndentation(int length = 4); + void setSwitchIndent(bool state); + void setTabIndentation(int length = 4, bool forceTabs = false); + void setPreprocDefineIndent(bool state); + void setPreprocConditionalIndent(bool state); + int getBeautifierFileType() const; + int getFileType() const; + int getIndentLength() const; + int getTabLength() const; + string getIndentString() const; + string getNextWord(const string& line, size_t currPos) const; + bool getAlignMethodColon() const; + bool getBraceIndent() const; + bool getBlockIndent() const; + bool getCaseIndent() const; + bool getClassIndent() const; + bool getEmptyLineFill() const; + bool getForceTabIndentation() const; + bool getModeManuallySet() const; + bool getModifierIndent() const; + bool getNamespaceIndent() const; + bool getPreprocDefineIndent() const; + bool getSwitchIndent() const; + +protected: + void deleteBeautifierVectors(); + int getNextProgramCharDistance(const string& line, int i) const; + int indexOf(const vector& container, const string* element) const; + void setBlockIndent(bool state); + void setBraceIndent(bool state); + void setBraceIndentVtk(bool state); + string extractPreprocessorStatement(const string& line) const; + string trim(const string& str) const; + string rtrim(const string& str) const; + + // variables set by ASFormatter - must be updated in activeBeautifierStack + int inLineNumber; + int runInIndentContinuation; + int nonInStatementBrace; + int objCColonAlignSubsequent; // for subsequent lines not counting indent + bool lineCommentNoBeautify; + bool isElseHeaderIndent; + bool isCaseHeaderCommentIndent; + bool isNonInStatementArray; + bool isSharpAccessor; + bool isSharpDelegate; + bool isInExternC; + bool isInBeautifySQL; + bool isInIndentableStruct; + bool isInIndentablePreproc; + +private: // functions + ASBeautifier(const ASBeautifier& other); // inline functions + ASBeautifier& operator=(ASBeautifier&); // not to be implemented + + void adjustObjCMethodDefinitionIndentation(const string& line_); + void adjustObjCMethodCallIndentation(const string& line_); + void adjustParsedLineIndentation(size_t iPrelim, bool isInExtraHeaderIndent); + void computePreliminaryIndentation(); + void parseCurrentLine(const string& line); + void popLastContinuationIndent(); + void processPreprocessor(const string& preproc, const string& line); + void registerContinuationIndent(const string& line, int i, int spaceIndentCount_, + int tabIncrementIn, int minIndent, bool updateParenStack); + void registerContinuationIndentColon(const string& line, int i, int tabIncrementIn); + void initVectors(); + void initTempStacksContainer(vector*>*& container, + vector*>* value); + void clearObjCMethodDefinitionAlignment(); + void deleteBeautifierContainer(vector*& container); + void deleteTempStacksContainer(vector*>*& container); + int adjustIndentCountForBreakElseIfComments() const; + int computeObjCColonAlignment(const string& line, int colonAlignPosition) const; + int convertTabToSpaces(int i, int tabIncrementIn) const; + int getContinuationIndentAssign(const string& line, size_t currPos) const; + int getContinuationIndentComma(const string& line, size_t currPos) const; + int getObjCFollowingKeyword(const string& line, int bracePos) const; + bool isIndentedPreprocessor(const string& line, size_t currPos) const; + bool isLineEndComment(const string& line, int startPos) const; + bool isPreprocessorConditionalCplusplus(const string& line) const; + bool isInPreprocessorUnterminatedComment(const string& line); + bool statementEndsWithComma(const string& line, int index) const; + const string& getIndentedLineReturn(const string& newLine, const string& originalLine) const; + string getIndentedSpaceEquivalent(const string& line_) const; + string preLineWS(int lineIndentCount, int lineSpaceIndentCount) const; + template void deleteContainer(T& container); + template void initContainer(T& container, T value); + vector*>* copyTempStacks(const ASBeautifier& other) const; + pair computePreprocessorIndent(); + +private: // variables + int beautifierFileType; + vector* headers; + vector* nonParenHeaders; + vector* preBlockStatements; + vector* preCommandHeaders; + vector* assignmentOperators; + vector* nonAssignmentOperators; + vector* indentableHeaders; + + vector* waitingBeautifierStack; + vector* activeBeautifierStack; + vector* waitingBeautifierStackLengthStack; + vector* activeBeautifierStackLengthStack; + vector* headerStack; + vector* >* tempStacks; + vector* squareBracketDepthStack; + vector* blockStatementStack; + vector* parenStatementStack; + vector* braceBlockStateStack; + vector* continuationIndentStack; + vector* continuationIndentStackSizeStack; + vector* parenIndentStack; + vector >* preprocIndentStack; + + ASSourceIterator* sourceIterator; + const string* currentHeader; + const string* previousLastLineHeader; + const string* probationHeader; + const string* lastLineHeader; + string indentString; + string verbatimDelimiter; + bool isInQuote; + bool isInVerbatimQuote; + bool haveLineContinuationChar; + bool isInAsm; + bool isInAsmOneLine; + bool isInAsmBlock; + bool isInComment; + bool isInPreprocessorComment; + bool isInRunInComment; + bool isInCase; + bool isInQuestion; + bool isContinuation; + bool isInHeader; + bool isInTemplate; + bool isInDefine; + bool isInDefineDefinition; + bool classIndent; + bool isIndentModeOff; + bool isInClassHeader; // is in a class before the opening brace + bool isInClassHeaderTab; // is in an indentable class header line + bool isInClassInitializer; // is in a class after the ':' initializer + bool isInClass; // is in a class after the opening brace + bool isInObjCMethodDefinition; + bool isInObjCMethodCall; + bool isInObjCMethodCallFirst; + bool isImmediatelyPostObjCMethodDefinition; + bool isImmediatelyPostObjCMethodCall; + bool isInIndentablePreprocBlock; + bool isInObjCInterface; + bool isInEnum; + bool isInEnumTypeID; + bool isInLet; + bool modifierIndent; + bool switchIndent; + bool caseIndent; + bool namespaceIndent; + bool blockIndent; + bool braceIndent; + bool braceIndentVtk; + bool shouldIndentAfterParen; + bool labelIndent; + bool shouldIndentPreprocDefine; + bool isInConditional; + bool isModeManuallySet; + bool shouldForceTabIndentation; + bool emptyLineFill; + bool backslashEndsPrevLine; + bool lineOpensWithLineComment; + bool lineOpensWithComment; + bool lineStartsInComment; + bool blockCommentNoIndent; + bool blockCommentNoBeautify; + bool previousLineProbationTab; + bool lineBeginsWithOpenBrace; + bool lineBeginsWithCloseBrace; + bool lineBeginsWithComma; + bool lineIsCommentOnly; + bool lineIsLineCommentOnly; + bool shouldIndentBracedLine; + bool isInSwitch; + bool foundPreCommandHeader; + bool foundPreCommandMacro; + bool shouldAlignMethodColon; + bool shouldIndentPreprocConditional; + int indentCount; + int spaceIndentCount; + int spaceIndentObjCMethodAlignment; + int bracePosObjCMethodAlignment; + int colonIndentObjCMethodAlignment; + int lineOpeningBlocksNum; + int lineClosingBlocksNum; + int fileType; + int minConditionalOption; + int minConditionalIndent; + int parenDepth; + int indentLength; + int tabLength; + int continuationIndent; + int blockTabCount; + int maxContinuationIndent; + int classInitializerIndents; + int templateDepth; + int squareBracketCount; + int prevFinalLineSpaceIndentCount; + int prevFinalLineIndentCount; + int defineIndentCount; + int preprocBlockIndent; + char quoteChar; + char prevNonSpaceCh; + char currentNonSpaceCh; + char currentNonLegalCh; + char prevNonLegalCh; +}; // Class ASBeautifier + +//----------------------------------------------------------------------------- +// Class ASEnhancer +//----------------------------------------------------------------------------- + +class ASEnhancer : protected ASBase +{ +public: // functions + ASEnhancer(); + virtual ~ASEnhancer(); + void init(int, int, int, bool, bool, bool, bool, bool, bool, bool, + vector* >*); + void enhance(string& line, bool isInNamespace, bool isInPreprocessor, bool isInSQL); + +private: // functions + void convertForceTabIndentToSpaces(string& line) const; + void convertSpaceIndentToForceTab(string& line) const; + size_t findCaseColon(const string& line, size_t caseIndex) const; + int indentLine(string& line, int indent) const; + bool isBeginDeclareSectionSQL(const string& line, size_t index) const; + bool isEndDeclareSectionSQL(const string& line, size_t index) const; + bool isOneLineBlockReached(const string& line, int startChar) const; + void parseCurrentLine(string& line, bool isInPreprocessor, bool isInSQL); + size_t processSwitchBlock(string& line, size_t index); + int unindentLine(string& line, int unindent) const; + +private: + // options from command line or options file + int indentLength; + int tabLength; + bool useTabs; + bool forceTab; + bool namespaceIndent; + bool caseIndent; + bool preprocBlockIndent; + bool preprocDefineIndent; + bool emptyLineFill; + + // parsing variables + int lineNumber; + bool isInQuote; + bool isInComment; + char quoteChar; + + // unindent variables + int braceCount; + int switchDepth; + int eventPreprocDepth; + bool lookingForCaseBrace; + bool unindentNextLine; + bool shouldUnindentLine; + bool shouldUnindentComment; + + // struct used by ParseFormattedLine function + // contains variables used to unindent the case blocks + struct SwitchVariables + { + int switchBraceCount; + int unindentDepth; + bool unindentCase; + }; + + SwitchVariables sw; // switch variables struct + vector switchStack; // stack vector of switch variables + + // event table variables + bool nextLineIsEventIndent; // begin event table indent is reached + bool isInEventTable; // need to indent an event table + vector* >* indentableMacros; + + // SQL variables + bool nextLineIsDeclareIndent; // begin declare section indent is reached + bool isInDeclareSection; // need to indent a declare section + +}; // Class ASEnhancer + +//----------------------------------------------------------------------------- +// Class ASFormatter +//----------------------------------------------------------------------------- + +class ASFormatter : public ASBeautifier +{ +public: // functions + ASFormatter(); + virtual ~ASFormatter(); + virtual void init(ASSourceIterator* si); + virtual bool hasMoreLines() const; + virtual string nextLine(); + LineEndFormat getLineEndFormat() const; + bool getIsLineReady() const; + void setFormattingStyle(FormatStyle style); + void setAddBracesMode(bool state); + void setAddOneLineBracesMode(bool state); + void setRemoveBracesMode(bool state); + void setAttachClass(bool state); + void setAttachClosingWhile(bool state); + void setAttachExternC(bool state); + void setAttachNamespace(bool state); + void setAttachInline(bool state); + void setBraceFormatMode(BraceMode mode); + void setBreakAfterMode(bool state); + void setBreakClosingHeaderBracesMode(bool state); + void setBreakBlocksMode(bool state); + void setBreakClosingHeaderBlocksMode(bool state); + void setBreakElseIfsMode(bool state); + void setBreakOneLineBlocksMode(bool state); + void setBreakOneLineHeadersMode(bool state); + void setBreakOneLineStatementsMode(bool state); + void setMethodPrefixPaddingMode(bool state); + void setMethodPrefixUnPaddingMode(bool state); + void setReturnTypePaddingMode(bool state); + void setReturnTypeUnPaddingMode(bool state); + void setParamTypePaddingMode(bool state); + void setParamTypeUnPaddingMode(bool state); + void setCloseTemplatesMode(bool state); + void setCommaPaddingMode(bool state); + void setDeleteEmptyLinesMode(bool state); + void setIndentCol1CommentsMode(bool state); + void setLineEndFormat(LineEndFormat fmt); + void setMaxCodeLength(int max); + void setObjCColonPaddingMode(ObjCColonPad mode); + void setOperatorPaddingMode(bool state); + void setParensOutsidePaddingMode(bool state); + void setParensFirstPaddingMode(bool state); + void setParensInsidePaddingMode(bool state); + void setParensHeaderPaddingMode(bool state); + void setParensUnPaddingMode(bool state); + void setPointerAlignment(PointerAlign alignment); + void setPreprocBlockIndent(bool state); + void setReferenceAlignment(ReferenceAlign alignment); + void setStripCommentPrefix(bool state); + void setTabSpaceConversionMode(bool state); + size_t getChecksumIn() const; + size_t getChecksumOut() const; + int getChecksumDiff() const; + int getFormatterFileType() const; + // retained for compatability with release 2.06 + // "Brackets" have been changed to "Braces" in 3.0 + // they are referenced only by the old "bracket" options + void setAddBracketsMode(bool state); + void setAddOneLineBracketsMode(bool state); + void setRemoveBracketsMode(bool state); + void setBreakClosingHeaderBracketsMode(bool state); + + +private: // functions + ASFormatter(const ASFormatter& copy); // not to be implemented + ASFormatter& operator=(ASFormatter&); // not to be implemented + template void deleteContainer(T& container); + template void initContainer(T& container, T value); + char peekNextChar() const; + BraceType getBraceType(); + bool adjustChecksumIn(int adjustment); + bool computeChecksumIn(const string& currentLine_); + bool computeChecksumOut(const string& beautifiedLine); + bool addBracesToStatement(); + bool removeBracesFromStatement(); + bool commentAndHeaderFollows(); + bool getNextChar(); + bool getNextLine(bool emptyLineWasDeleted = false); + bool isArrayOperator() const; + bool isBeforeComment() const; + bool isBeforeAnyComment() const; + bool isBeforeAnyLineEndComment(int startPos) const; + bool isBeforeMultipleLineEndComments(int startPos) const; + bool isBraceType(BraceType a, BraceType b) const; + bool isClassInitializer() const; + bool isClosingHeader(const string* header) const; + bool isCurrentBraceBroken() const; + bool isDereferenceOrAddressOf() const; + bool isExecSQL(const string& line, size_t index) const; + bool isEmptyLine(const string& line) const; + bool isExternC() const; + bool isMultiStatementLine() const; + bool isNextWordSharpNonParenHeader(int startChar) const; + bool isNonInStatementArrayBrace() const; + bool isOkToSplitFormattedLine(); + bool isPointerOrReference() const; + bool isPointerOrReferenceCentered() const; + bool isPointerOrReferenceVariable(const string& word) const; + bool isSharpStyleWithParen(const string* header) const; + bool isStructAccessModified(const string& firstLine, size_t index) const; + bool isIndentablePreprocessorBlock(const string& firstLine, size_t index); + bool isNDefPreprocStatement(const string& nextLine_, const string& preproc) const; + bool isUnaryOperator() const; + bool isUniformInitializerBrace() const; + bool isImmediatelyPostCast() const; + bool isInExponent() const; + bool isInSwitchStatement() const; + bool isNextCharOpeningBrace(int startChar) const; + bool isOkToBreakBlock(BraceType braceType) const; + bool isOperatorPaddingDisabled() const; + bool pointerSymbolFollows() const; + int findObjCColonAlignment() const; + int getCurrentLineCommentAdjustment(); + int getNextLineCommentAdjustment(); + int isOneLineBlockReached(const string& line, int startChar) const; + void adjustComments(); + void appendChar(char ch, bool canBreakLine); + void appendCharInsideComments(); + void appendClosingHeader(); + void appendOperator(const string& sequence, bool canBreakLine = true); + void appendSequence(const string& sequence, bool canBreakLine = true); + void appendSpacePad(); + void appendSpaceAfter(); + void breakLine(bool isSplitLine = false); + void buildLanguageVectors(); + void updateFormattedLineSplitPoints(char appendedChar); + void updateFormattedLineSplitPointsOperator(const string& sequence); + void checkIfTemplateOpener(); + void clearFormattedLineSplitPoints(); + void convertTabToSpaces(); + void deleteContainer(vector*& container); + void formatArrayRunIn(); + void formatRunIn(); + void formatArrayBraces(BraceType braceType, bool isOpeningArrayBrace); + void formatClosingBrace(BraceType braceType); + void formatCommentBody(); + void formatCommentOpener(); + void formatCommentCloser(); + void formatLineCommentBody(); + void formatLineCommentOpener(); + void formatOpeningBrace(BraceType braceType); + void formatQuoteBody(); + void formatQuoteOpener(); + void formatPointerOrReference(); + void formatPointerOrReferenceCast(); + void formatPointerOrReferenceToMiddle(); + void formatPointerOrReferenceToName(); + void formatPointerOrReferenceToType(); + void fixOptionVariableConflicts(); + void goForward(int i); + void isLineBreakBeforeClosingHeader(); + void initContainer(vector*& container, vector* value); + void initNewLine(); + void padObjCMethodColon(); + void padObjCMethodPrefix(); + void padObjCParamType(); + void padObjCReturnType(); + void padOperators(const string* newOperator); + void padParens(); + void processPreprocessor(); + void resetEndOfStatement(); + void setAttachClosingBraceMode(bool state); + void stripCommentPrefix(); + void testForTimeToSplitFormattedLine(); + void trimContinuationLine(); + void updateFormattedLineSplitPointsPointerOrReference(size_t index); + size_t findFormattedLineSplitPoint() const; + size_t findNextChar(const string& line, char searchChar, int searchStart = 0) const; + const string* checkForHeaderFollowingComment(const string& firstLine) const; + const string* getFollowingOperator() const; + string getPreviousWord(const string& line, int currPos) const; + string peekNextText(const string& firstLine, + bool endOnEmptyLine = false, + shared_ptr streamArg = nullptr) const; + +private: // variables + int formatterFileType; + vector* headers; + vector* nonParenHeaders; + vector* preDefinitionHeaders; + vector* preCommandHeaders; + vector* operators; + vector* assignmentOperators; + vector* castOperators; + vector* >* indentableMacros; // for ASEnhancer + + ASSourceIterator* sourceIterator; + ASEnhancer* enhancer; + + vector* preBraceHeaderStack; + vector* braceTypeStack; + vector* parenStack; + vector* structStack; + vector* questionMarkStack; + + string currentLine; + string formattedLine; + string readyFormattedLine; + string verbatimDelimiter; + const string* currentHeader; + char currentChar; + char previousChar; + char previousNonWSChar; + char previousCommandChar; + char quoteChar; + streamoff preprocBlockEnd; + int charNum; + int runInIndentChars; + int nextLineSpacePadNum; + int objCColonAlign; + int preprocBraceTypeStackSize; + int spacePadNum; + int tabIncrementIn; + int templateDepth; + int squareBracketCount; + size_t checksumIn; + size_t checksumOut; + size_t currentLineFirstBraceNum; // first brace location on currentLine + size_t formattedLineCommentNum; // comment location on formattedLine + size_t leadingSpaces; + size_t maxCodeLength; + + // possible split points + size_t maxSemi; // probably a 'for' statement + size_t maxAndOr; // probably an 'if' statement + size_t maxComma; + size_t maxParen; + size_t maxWhiteSpace; + size_t maxSemiPending; + size_t maxAndOrPending; + size_t maxCommaPending; + size_t maxParenPending; + size_t maxWhiteSpacePending; + + size_t previousReadyFormattedLineLength; + FormatStyle formattingStyle; + BraceMode braceFormatMode; + BraceType previousBraceType; + PointerAlign pointerAlignment; + ReferenceAlign referenceAlignment; + ObjCColonPad objCColonPadMode; + LineEndFormat lineEnd; + bool isVirgin; + bool isInVirginLine; + bool shouldPadCommas; + bool shouldPadOperators; + bool shouldPadParensOutside; + bool shouldPadFirstParen; + bool shouldPadParensInside; + bool shouldPadHeader; + bool shouldStripCommentPrefix; + bool shouldUnPadParens; + bool shouldConvertTabs; + bool shouldIndentCol1Comments; + bool shouldIndentPreprocBlock; + bool shouldCloseTemplates; + bool shouldAttachExternC; + bool shouldAttachNamespace; + bool shouldAttachClass; + bool shouldAttachClosingWhile; + bool shouldAttachInline; + bool isInLineComment; + bool isInComment; + bool isInCommentStartLine; + bool noTrimCommentContinuation; + bool isInPreprocessor; + bool isInPreprocessorBeautify; + bool isInTemplate; + bool doesLineStartComment; + bool lineEndsInCommentOnly; + bool lineIsCommentOnly; + bool lineIsLineCommentOnly; + bool lineIsEmpty; + bool isImmediatelyPostCommentOnly; + bool isImmediatelyPostEmptyLine; + bool isInClassInitializer; + bool isInQuote; + bool isInVerbatimQuote; + bool haveLineContinuationChar; + bool isInQuoteContinuation; + bool isHeaderInMultiStatementLine; + bool isSpecialChar; + bool isNonParenHeader; + bool foundQuestionMark; + bool foundPreDefinitionHeader; + bool foundNamespaceHeader; + bool foundClassHeader; + bool foundStructHeader; + bool foundInterfaceHeader; + bool foundPreCommandHeader; + bool foundPreCommandMacro; + bool foundTrailingReturnType; + bool foundCastOperator; + bool isInLineBreak; + bool endOfAsmReached; + bool endOfCodeReached; + bool lineCommentNoIndent; + bool isFormattingModeOff; + bool isInEnum; + bool isInExecSQL; + bool isInAsm; + bool isInAsmOneLine; + bool isInAsmBlock; + bool isLineReady; + bool elseHeaderFollowsComments; + bool caseHeaderFollowsComments; + bool isPreviousBraceBlockRelated; + bool isInPotentialCalculation; + bool isCharImmediatelyPostComment; + bool isPreviousCharPostComment; + bool isCharImmediatelyPostLineComment; + bool isCharImmediatelyPostOpenBlock; + bool isCharImmediatelyPostCloseBlock; + bool isCharImmediatelyPostTemplate; + bool isCharImmediatelyPostReturn; + bool isCharImmediatelyPostThrow; + bool isCharImmediatelyPostNewDelete; + bool isCharImmediatelyPostOperator; + bool isCharImmediatelyPostPointerOrReference; + bool isInObjCMethodDefinition; + bool isInObjCInterface; + bool isInObjCReturnType; + bool isInObjCSelector; + bool breakCurrentOneLineBlock; + bool shouldRemoveNextClosingBrace; + bool isInBraceRunIn; + bool currentLineBeginsWithBrace; + bool attachClosingBraceMode; + bool shouldBreakOneLineBlocks; + bool shouldBreakOneLineHeaders; + bool shouldBreakOneLineStatements; + bool shouldBreakClosingHeaderBraces; + bool shouldBreakElseIfs; + bool shouldBreakLineAfterLogical; + bool shouldAddBraces; + bool shouldAddOneLineBraces; + bool shouldRemoveBraces; + bool shouldPadMethodColon; + bool shouldPadMethodPrefix; + bool shouldReparseCurrentChar; + bool shouldUnPadMethodPrefix; + bool shouldPadReturnType; + bool shouldUnPadReturnType; + bool shouldPadParamType; + bool shouldUnPadParamType; + bool shouldDeleteEmptyLines; + bool needHeaderOpeningBrace; + bool shouldBreakLineAtNextChar; + bool shouldKeepLineUnbroken; + bool passedSemicolon; + bool passedColon; + bool isImmediatelyPostNonInStmt; + bool isCharImmediatelyPostNonInStmt; + bool isImmediatelyPostComment; + bool isImmediatelyPostLineComment; + bool isImmediatelyPostEmptyBlock; + bool isImmediatelyPostObjCMethodPrefix; + bool isImmediatelyPostPreprocessor; + bool isImmediatelyPostReturn; + bool isImmediatelyPostThrow; + bool isImmediatelyPostNewDelete; + bool isImmediatelyPostOperator; + bool isImmediatelyPostTemplate; + bool isImmediatelyPostPointerOrReference; + bool shouldBreakBlocks; + bool shouldBreakClosingHeaderBlocks; + bool isPrependPostBlockEmptyLineRequested; + bool isAppendPostBlockEmptyLineRequested; + bool isIndentableProprocessor; + bool isIndentableProprocessorBlock; + bool prependEmptyLine; + bool appendOpeningBrace; + bool foundClosingHeader; + bool isInHeader; + bool isImmediatelyPostHeader; + bool isInCase; + bool isFirstPreprocConditional; + bool processedFirstConditional; + bool isJavaStaticConstructor; + +private: // inline functions + // append the CURRENT character (curentChar) to the current formatted line. + void appendCurrentChar(bool canBreakLine = true) + { appendChar(currentChar, canBreakLine); } + + // check if a specific sequence exists in the current placement of the current line + bool isSequenceReached(const char* sequence) const + { return currentLine.compare(charNum, strlen(sequence), sequence) == 0; } + + // call ASBase::findHeader for the current character + const string* findHeader(const vector* headers_) + { return ASBase::findHeader(currentLine, charNum, headers_); } + + // call ASBase::findOperator for the current character + const string* findOperator(const vector* operators_) + { return ASBase::findOperator(currentLine, charNum, operators_); } +}; // Class ASFormatter + +//----------------------------------------------------------------------------- +// astyle namespace global declarations +//----------------------------------------------------------------------------- +// sort comparison functions for ASResource +bool sortOnLength(const string* a, const string* b); +bool sortOnName(const string* a, const string* b); + +} // namespace astyle + +// end of astyle namespace -------------------------------------------------- + +#endif // closes ASTYLE_H diff --git a/thirdparty/astyle/astyle_main.cpp b/thirdparty/astyle/astyle_main.cpp new file mode 100755 index 00000000..e9d5c1a0 --- /dev/null +++ b/thirdparty/astyle/astyle_main.cpp @@ -0,0 +1,3990 @@ +// astyle_main.cpp +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * AStyle_main source file map. + * This source file contains several classes. + * They are arranged as follows. + * --------------------------------------- + * namespace astyle { + * ASStreamIterator methods + * ASConsole methods + * // Windows specific + * // Linux specific + * ASLibrary methods + * // Windows specific + * // Linux specific + * ASOptions methods + * ASEncoding methods + * } // end of astyle namespace + * Global Area --------------------------- + * Java Native Interface functions + * AStyleMainUtf16 entry point + * AStyleMain entry point + * AStyleGetVersion entry point + * main entry point + * --------------------------------------- + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + */ + +//----------------------------------------------------------------------------- +// headers +//----------------------------------------------------------------------------- + +#include "astyle_main.h" + +#include +#include +#include // needed by some compilers +#include +#include +#include + +// includes for recursive getFileNames() function +#ifdef _WIN32 + #undef UNICODE // use ASCII windows functions + #include +#else + #include + #include + #include + #ifdef __VMS + #include + #include + #include + #include + #include + #include + #endif /* __VMS */ +#endif + +//----------------------------------------------------------------------------- +// declarations +//----------------------------------------------------------------------------- + +// turn off MinGW automatic file globbing +// this CANNOT be in the astyle namespace +#ifndef ASTYLE_LIB + int _CRT_glob = 0; +#endif + +//---------------------------------------------------------------------------- +// astyle namespace +//---------------------------------------------------------------------------- + +namespace astyle { +// +// console build variables +#ifndef ASTYLE_LIB + #ifdef _WIN32 + char g_fileSeparator = '\\'; // Windows file separator + bool g_isCaseSensitive = false; // Windows IS NOT case sensitive + #else + char g_fileSeparator = '/'; // Linux file separator + bool g_isCaseSensitive = true; // Linux IS case sensitive + #endif // _WIN32 +#endif // ASTYLE_LIB + +// java library build variables +#ifdef ASTYLE_JNI + JNIEnv* g_env; + jobject g_obj; + jmethodID g_mid; +#endif + +const char* g_version = "3.0"; + +//----------------------------------------------------------------------------- +// ASStreamIterator class +// typename will be istringstream for GUI and istream otherwise +//----------------------------------------------------------------------------- + +template +ASStreamIterator::ASStreamIterator(T* in) +{ + inStream = in; + buffer.reserve(200); + eolWindows = 0; + eolLinux = 0; + eolMacOld = 0; + peekStart = 0; + prevLineDeleted = false; + checkForEmptyLine = false; + // get length of stream + inStream->seekg(0, inStream->end); + streamLength = inStream->tellg(); + inStream->seekg(0, inStream->beg); +} + +template +ASStreamIterator::~ASStreamIterator() +{ +} + +/** +* get the length of the input stream. +* streamLength variable is set by the constructor. +* +* @return length of the input file stream, converted to an int. +*/ +template +int ASStreamIterator::getStreamLength() const +{ + return static_cast(streamLength); +} + +/** + * read the input stream, delete any end of line characters, + * and build a string that contains the input line. + * + * @return string containing the next input line minus any end of line characters + */ +template +string ASStreamIterator::nextLine(bool emptyLineWasDeleted) +{ + // verify that the current position is correct + assert(peekStart == 0); + + // a deleted line may be replaced if break-blocks is requested + // this sets up the compare to check for a replaced empty line + if (prevLineDeleted) + { + prevLineDeleted = false; + checkForEmptyLine = true; + } + if (!emptyLineWasDeleted) + prevBuffer = buffer; + else + prevLineDeleted = true; + + // read the next record + buffer.clear(); + char ch; + inStream->get(ch); + + while (!inStream->eof() && ch != '\n' && ch != '\r') + { + buffer.append(1, ch); + inStream->get(ch); + } + + if (inStream->eof()) + { + return buffer; + } + + int peekCh = inStream->peek(); + + // find input end-of-line characters + if (!inStream->eof()) + { + if (ch == '\r') // CR+LF is windows otherwise Mac OS 9 + { + if (peekCh == '\n') + { + inStream->get(); + eolWindows++; + } + else + eolMacOld++; + } + else // LF is Linux, allow for improbable LF/CR + { + if (peekCh == '\r') + { + inStream->get(); + eolWindows++; + } + else + eolLinux++; + } + } + else + { + inStream->clear(); + } + + // set output end of line characters + if (eolWindows >= eolLinux) + { + if (eolWindows >= eolMacOld) + outputEOL = "\r\n"; // Windows (CR+LF) + else + outputEOL = "\r"; // MacOld (CR) + } + else if (eolLinux >= eolMacOld) + outputEOL = "\n"; // Linux (LF) + else + outputEOL = "\r"; // MacOld (CR) + + return buffer; +} + +// save the current position and get the next line +// this can be called for multiple reads +// when finished peeking you MUST call peekReset() +// call this function from ASFormatter ONLY +template +string ASStreamIterator::peekNextLine() +{ + assert(hasMoreLines()); + string nextLine_; + char ch; + + if (peekStart == 0) + peekStart = inStream->tellg(); + + // read the next record + inStream->get(ch); + while (!inStream->eof() && ch != '\n' && ch != '\r') + { + nextLine_.append(1, ch); + inStream->get(ch); + } + + if (inStream->eof()) + { + return nextLine_; + } + + int peekCh = inStream->peek(); + + // remove end-of-line characters + if (!inStream->eof()) + { + if ((peekCh == '\n' || peekCh == '\r') && peekCh != ch) + inStream->get(); + } + + return nextLine_; +} + +// reset current position and EOF for peekNextLine() +template +void ASStreamIterator::peekReset() +{ + assert(peekStart != 0); + inStream->clear(); + inStream->seekg(peekStart); + peekStart = 0; +} + +// save the last input line after input has reached EOF +template +void ASStreamIterator::saveLastInputLine() +{ + assert(inStream->eof()); + prevBuffer = buffer; +} + +// return position of the get pointer +template +streamoff ASStreamIterator::tellg() +{ + return inStream->tellg(); +} + +// check for a change in line ends +template +bool ASStreamIterator::getLineEndChange(int lineEndFormat) const +{ + assert(lineEndFormat == LINEEND_DEFAULT + || lineEndFormat == LINEEND_WINDOWS + || lineEndFormat == LINEEND_LINUX + || lineEndFormat == LINEEND_MACOLD); + + bool lineEndChange = false; + if (lineEndFormat == LINEEND_WINDOWS) + lineEndChange = (eolLinux + eolMacOld != 0); + else if (lineEndFormat == LINEEND_LINUX) + lineEndChange = (eolWindows + eolMacOld != 0); + else if (lineEndFormat == LINEEND_MACOLD) + lineEndChange = (eolWindows + eolLinux != 0); + else + { + if (eolWindows > 0) + lineEndChange = (eolLinux + eolMacOld != 0); + else if (eolLinux > 0) + lineEndChange = (eolWindows + eolMacOld != 0); + else if (eolMacOld > 0) + lineEndChange = (eolWindows + eolLinux != 0); + } + return lineEndChange; +} + +//----------------------------------------------------------------------------- +// ASConsole class +// main function will be included only in the console build +//----------------------------------------------------------------------------- + +#ifndef ASTYLE_LIB + +ASConsole::ASConsole(ASFormatter& formatterArg) : formatter(formatterArg) +{ + errorStream = &cerr; + // command line options + isRecursive = false; + isDryRun = false; + noBackup = false; + preserveDate = false; + isVerbose = false; + isQuiet = false; + isFormattedOnly = false; + ignoreExcludeErrors = false; + ignoreExcludeErrorsDisplay = false; + optionsFileRequired = false; + useAscii = false; + // other variables + bypassBrowserOpen = false; + hasWildcard = false; + filesAreIdentical = true; + lineEndsMixed = false; + origSuffix = ".orig"; + mainDirectoryLength = 0; + filesFormatted = 0; + filesUnchanged = 0; + linesOut = 0; +} + +ASConsole::~ASConsole() +{} + +// rewrite a stringstream converting the line ends +void ASConsole::convertLineEnds(ostringstream& out, int lineEnd) +{ + assert(lineEnd == LINEEND_WINDOWS || lineEnd == LINEEND_LINUX || lineEnd == LINEEND_MACOLD); + const string& inStr = out.str(); // avoids strange looking syntax + string outStr; // the converted output + int inLength = (int)inStr.length(); + for (int pos = 0; pos < inLength; pos++) + { + if (inStr[pos] == '\r') + { + if (inStr[pos + 1] == '\n') + { + // CRLF + if (lineEnd == LINEEND_CR) + { + outStr += inStr[pos]; // Delete the LF + pos++; + continue; + } + else if (lineEnd == LINEEND_LF) + { + outStr += inStr[pos + 1]; // Delete the CR + pos++; + continue; + } + else + { + outStr += inStr[pos]; // Do not change + outStr += inStr[pos + 1]; + pos++; + continue; + } + } + else + { + // CR + if (lineEnd == LINEEND_CRLF) + { + outStr += inStr[pos]; // Insert the CR + outStr += '\n'; // Insert the LF + continue; + } + else if (lineEnd == LINEEND_LF) + { + outStr += '\n'; // Insert the LF + continue; + } + else + { + outStr += inStr[pos]; // Do not change + continue; + } + } + } + else if (inStr[pos] == '\n') + { + // LF + if (lineEnd == LINEEND_CRLF) + { + outStr += '\r'; // Insert the CR + outStr += inStr[pos]; // Insert the LF + continue; + } + else if (lineEnd == LINEEND_CR) + { + outStr += '\r'; // Insert the CR + continue; + } + else + { + outStr += inStr[pos]; // Do not change + continue; + } + } + else + { + outStr += inStr[pos]; // Write the current char + } + } + // replace the stream + out.str(outStr); +} + +void ASConsole::correctMixedLineEnds(ostringstream& out) +{ + LineEndFormat lineEndFormat = LINEEND_DEFAULT; + if (outputEOL == "\r\n") + lineEndFormat = LINEEND_WINDOWS; + if (outputEOL == "\n") + lineEndFormat = LINEEND_LINUX; + if (outputEOL == "\r") + lineEndFormat = LINEEND_MACOLD; + convertLineEnds(out, lineEndFormat); +} + +// check files for 16 or 32 bit encoding +// the file must have a Byte Order Mark (BOM) +// NOTE: some string functions don't work with NULLs (e.g. length()) +FileEncoding ASConsole::detectEncoding(const char* data, size_t dataSize) const +{ + FileEncoding encoding = ENCODING_8BIT; + + if (dataSize >= 4 && memcmp(data, "\x00\x00\xFE\xFF", 4) == 0) + encoding = UTF_32BE; + else if (dataSize >= 4 && memcmp(data, "\xFF\xFE\x00\x00", 4) == 0) + encoding = UTF_32LE; + else if (dataSize >= 2 && memcmp(data, "\xFE\xFF", 2) == 0) + encoding = UTF_16BE; + else if (dataSize >= 2 && memcmp(data, "\xFF\xFE", 2) == 0) + encoding = UTF_16LE; + + return encoding; +} + +// error exit without a message +void ASConsole::error() const +{ + (*errorStream) << _("\nArtistic Style has terminated") << endl; + exit(EXIT_FAILURE); +} + +// error exit with a message +void ASConsole::error(const char* why, const char* what) const +{ + (*errorStream) << why << ' ' << what << endl; + error(); +} + +/** + * If no files have been given, use cin for input and cout for output. + * + * This is used to format text for text editors like TextWrangler (Mac). + * Do NOT display any console messages when this function is used. + */ +void ASConsole::formatCinToCout() +{ + // check for files from --stdin= and --stdout= + if (!stdPathIn.empty()) + { + if (!freopen(stdPathIn.c_str(), "r", stdin)) + error("Cannot open input file", stdPathIn.c_str()); + } + if (!stdPathOut.empty()) + { + if (!freopen(stdPathOut.c_str(), "w", stdout)) + error("Cannot open output file", stdPathOut.c_str()); + + } + // Using cin.tellg() causes problems with both Windows and Linux. + // The Windows problem occurs when the input is not Windows line-ends. + // The tellg() will be out of sequence with the get() statements. + // The Linux cin.tellg() will return -1 (invalid). + // Copying the input sequentially to a stringstream before + // formatting solves the problem for both. + istream* inStream = &cin; + stringstream outStream; + char ch; + inStream->get(ch); + while (!inStream->eof() && !inStream->fail()) + { + outStream.put(ch); + inStream->get(ch); + } + ASStreamIterator streamIterator(&outStream); + // Windows pipe or redirection always outputs Windows line-ends. + // Linux pipe or redirection will output any line end. +#ifdef _WIN32 + LineEndFormat lineEndFormat = LINEEND_DEFAULT; +#else + LineEndFormat lineEndFormat = formatter.getLineEndFormat(); +#endif // _WIN32 + initializeOutputEOL(lineEndFormat); + formatter.init(&streamIterator); + + while (formatter.hasMoreLines()) + { + cout << formatter.nextLine(); + if (formatter.hasMoreLines()) + { + setOutputEOL(lineEndFormat, streamIterator.getOutputEOL()); + cout << outputEOL; + } + else + { + // this can happen if the file if missing a closing brace and break-blocks is requested + if (formatter.getIsLineReady()) + { + setOutputEOL(lineEndFormat, streamIterator.getOutputEOL()); + cout << outputEOL; + cout << formatter.nextLine(); + } + } + } + cout.flush(); +} + +/** + * Open input file, format it, and close the output. + * + * @param fileName_ The path and name of the file to be processed. + */ +void ASConsole::formatFile(const string& fileName_) +{ + stringstream in; + ostringstream out; + FileEncoding encoding = readFile(fileName_, in); + + // Unless a specific language mode has been set, set the language mode + // according to the file's suffix. + if (!formatter.getModeManuallySet()) + { + if (stringEndsWith(fileName_, string(".java"))) + formatter.setJavaStyle(); + else if (stringEndsWith(fileName_, string(".cs"))) + formatter.setSharpStyle(); + else + formatter.setCStyle(); + } + + // set line end format + string nextLine; // next output line + filesAreIdentical = true; // input and output files are identical + LineEndFormat lineEndFormat = formatter.getLineEndFormat(); + initializeOutputEOL(lineEndFormat); + // do this AFTER setting the file mode + ASStreamIterator streamIterator(&in); + formatter.init(&streamIterator); + + // format the file + while (formatter.hasMoreLines()) + { + nextLine = formatter.nextLine(); + out << nextLine; + linesOut++; + if (formatter.hasMoreLines()) + { + setOutputEOL(lineEndFormat, streamIterator.getOutputEOL()); + out << outputEOL; + } + else + { + streamIterator.saveLastInputLine(); // to compare the last input line + // this can happen if the file if missing a closing brace and break-blocks is requested + if (formatter.getIsLineReady()) + { + setOutputEOL(lineEndFormat, streamIterator.getOutputEOL()); + out << outputEOL; + nextLine = formatter.nextLine(); + out << nextLine; + linesOut++; + streamIterator.saveLastInputLine(); + } + } + + if (filesAreIdentical) + { + if (streamIterator.checkForEmptyLine) + { + if (nextLine.find_first_not_of(" \t") != string::npos) + filesAreIdentical = false; + } + else if (!streamIterator.compareToInputBuffer(nextLine)) + filesAreIdentical = false; + streamIterator.checkForEmptyLine = false; + } + } + // correct for mixed line ends + if (lineEndsMixed) + { + correctMixedLineEnds(out); + filesAreIdentical = false; + } + + // remove targetDirectory from filename if required by print + string displayName; + if (hasWildcard) + displayName = fileName_.substr(targetDirectory.length() + 1); + else + displayName = fileName_; + + // if file has changed, write the new file + if (!filesAreIdentical || streamIterator.getLineEndChange(lineEndFormat)) + { + if (!isDryRun) + writeFile(fileName_, encoding, out); + printMsg(_("Formatted %s\n"), displayName); + filesFormatted++; + } + else + { + if (!isFormattedOnly) + printMsg(_("Unchanged %s\n"), displayName); + filesUnchanged++; + } + + assert(formatter.getChecksumDiff() == 0); +} + +// build a vector of argv options +// the program path argv[0] is excluded +vector ASConsole::getArgvOptions(int argc, char** argv) const +{ + vector argvOptions; + for (int i = 1; i < argc; i++) + { + argvOptions.emplace_back(string(argv[i])); + } + return argvOptions; +} + +// for unit testing +vector ASConsole::getExcludeHitsVector() const +{ return excludeHitsVector; } + +// for unit testing +vector ASConsole::getExcludeVector() const +{ return excludeVector; } + +// for unit testing +vector ASConsole::getFileName() const +{ return fileName; } + +// for unit testing +vector ASConsole::getFileNameVector() const +{ return fileNameVector; } + +// for unit testing +vector ASConsole::getFileOptionsVector() const +{ return fileOptionsVector; } + +// for unit testing +bool ASConsole::getFilesAreIdentical() const +{ return filesAreIdentical; } + +// for unit testing +int ASConsole::getFilesFormatted() const +{ return filesFormatted; } + +// for unit testing +bool ASConsole::getIgnoreExcludeErrors() const +{ return ignoreExcludeErrors; } + +// for unit testing +bool ASConsole::getIgnoreExcludeErrorsDisplay() const +{ return ignoreExcludeErrorsDisplay; } + +// for unit testing +bool ASConsole::getIsDryRun() const +{ return isDryRun; } + +// for unit testing +bool ASConsole::getIsFormattedOnly() const +{ return isFormattedOnly; } + +// for unit testing +string ASConsole::getLanguageID() const +{ return localizer.getLanguageID(); } + +// for unit testing +bool ASConsole::getIsQuiet() const +{ return isQuiet; } + +// for unit testing +bool ASConsole::getIsRecursive() const +{ return isRecursive; } + +// for unit testing +bool ASConsole::getIsVerbose() const +{ return isVerbose; } + +// for unit testing +bool ASConsole::getLineEndsMixed() const +{ return lineEndsMixed; } + +// for unit testing +bool ASConsole::getNoBackup() const +{ return noBackup; } + +// for unit testing +string ASConsole::getOptionsFileName() const +{ return optionsFileName; } + +// for unit testing +vector ASConsole::getOptionsVector() const +{ return optionsVector; } + +// for unit testing +string ASConsole::getOrigSuffix() const +{ return origSuffix; } + +// for unit testing +bool ASConsole::getPreserveDate() const +{ return preserveDate; } + +// for unit testing +string ASConsole::getStdPathIn() const +{ return stdPathIn; } + +// for unit testing +string ASConsole::getStdPathOut() const +{ return stdPathOut; } + +// for unit testing +void ASConsole::setBypassBrowserOpen(bool state) +{ bypassBrowserOpen = state; } + +// for unit testing +ostream* ASConsole::getErrorStream() const +{ + return errorStream; +} + +void ASConsole::setErrorStream(ostream* errStreamPtr) +{ + errorStream = errStreamPtr; +} + +string ASConsole::getParam(const string& arg, const char* op) +{ + return arg.substr(strlen(op)); +} + +// initialize output end of line +void ASConsole::initializeOutputEOL(LineEndFormat lineEndFormat) +{ + assert(lineEndFormat == LINEEND_DEFAULT + || lineEndFormat == LINEEND_WINDOWS + || lineEndFormat == LINEEND_LINUX + || lineEndFormat == LINEEND_MACOLD); + + outputEOL.clear(); // current line end + prevEOL.clear(); // previous line end + lineEndsMixed = false; // output has mixed line ends, LINEEND_DEFAULT only + + if (lineEndFormat == LINEEND_WINDOWS) + outputEOL = "\r\n"; + else if (lineEndFormat == LINEEND_LINUX) + outputEOL = "\n"; + else if (lineEndFormat == LINEEND_MACOLD) + outputEOL = "\r"; + else + outputEOL.clear(); +} + +FileEncoding ASConsole::readFile(const string& fileName_, stringstream& in) const +{ + const int blockSize = 65536; // 64 KB + ifstream fin(fileName_.c_str(), ios::binary); + if (!fin) + error("Cannot open input file", fileName_.c_str()); + char* data = new (nothrow) char[blockSize]; + if (data == nullptr) + error("Cannot allocate memory for input file", fileName_.c_str()); + fin.read(data, blockSize); + if (fin.bad()) + error("Cannot read input file", fileName_.c_str()); + size_t dataSize = static_cast(fin.gcount()); + FileEncoding encoding = detectEncoding(data, dataSize); + if (encoding == UTF_32BE || encoding == UTF_32LE) + error(_("Cannot process UTF-32 encoding"), fileName_.c_str()); + bool firstBlock = true; + bool isBigEndian = (encoding == UTF_16BE); + while (dataSize != 0) + { + if (encoding == UTF_16LE || encoding == UTF_16BE) + { + // convert utf-16 to utf-8 + size_t utf8Size = utf8_16.utf8LengthFromUtf16(data, dataSize, isBigEndian); + char* utf8Out = new (nothrow) char[utf8Size]; + if (utf8Out == nullptr) + error("Cannot allocate memory for utf-8 conversion", fileName_.c_str()); + size_t utf8Len = utf8_16.utf16ToUtf8(data, dataSize, isBigEndian, firstBlock, utf8Out); + assert(utf8Len == utf8Size); + in << string(utf8Out, utf8Len); + delete[] utf8Out; + } + else + in << string(data, dataSize); + fin.read(data, blockSize); + if (fin.bad()) + error("Cannot read input file", fileName_.c_str()); + dataSize = static_cast(fin.gcount()); + firstBlock = false; + } + fin.close(); + delete[] data; + return encoding; +} + +void ASConsole::setIgnoreExcludeErrors(bool state) +{ ignoreExcludeErrors = state; } + +void ASConsole::setIgnoreExcludeErrorsAndDisplay(bool state) +{ ignoreExcludeErrors = state; ignoreExcludeErrorsDisplay = state; } + +void ASConsole::setIsFormattedOnly(bool state) +{ isFormattedOnly = state; } + +void ASConsole::setIsQuiet(bool state) +{ isQuiet = state; } + +void ASConsole::setIsRecursive(bool state) +{ isRecursive = state; } + +void ASConsole::setIsDryRun(bool state) +{ isDryRun = state; } + +void ASConsole::setIsVerbose(bool state) +{ isVerbose = state; } + +void ASConsole::setNoBackup(bool state) +{ noBackup = state; } + +void ASConsole::setOptionsFileName(const string& name) +{ optionsFileName = name; } + +void ASConsole::setOrigSuffix(const string& suffix) +{ origSuffix = suffix; } + +void ASConsole::setPreserveDate(bool state) +{ preserveDate = state; } + +void ASConsole::setStdPathIn(const string& path) +{ stdPathIn = path; } + +void ASConsole::setStdPathOut(const string& path) +{ stdPathOut = path; } + +// set outputEOL variable +void ASConsole::setOutputEOL(LineEndFormat lineEndFormat, const string& currentEOL) +{ + if (lineEndFormat == LINEEND_DEFAULT) + { + outputEOL = currentEOL; + if (prevEOL.empty()) + prevEOL = outputEOL; + if (prevEOL != outputEOL) + { + lineEndsMixed = true; + filesAreIdentical = false; + prevEOL = outputEOL; + } + } + else + { + prevEOL = currentEOL; + if (prevEOL != outputEOL) + filesAreIdentical = false; + } +} + +#ifdef _WIN32 // Windows specific + +/** + * WINDOWS function to display the last system error. + */ +void ASConsole::displayLastError() +{ + LPSTR msgBuf; + DWORD lastError = GetLastError(); + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, + nullptr, + lastError, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPSTR) &msgBuf, + 0, + nullptr + ); + // Display the string. + (*errorStream) << "Error (" << lastError << ") " << msgBuf << endl; + // Free the buffer. + LocalFree(msgBuf); +} + +/** + * WINDOWS function to get the current directory. + * NOTE: getenv("CD") does not work for Windows Vista. + * The Windows function GetCurrentDirectory is used instead. + * + * @return The path of the current directory + */ +string ASConsole::getCurrentDirectory(const string& fileName_) const +{ + char currdir[MAX_PATH]; + currdir[0] = '\0'; + if (!GetCurrentDirectory(sizeof(currdir), currdir)) + error("Cannot find file", fileName_.c_str()); + return string(currdir); +} + +/** + * WINDOWS function to resolve wildcards and recurse into sub directories. + * The fileName vector is filled with the path and names of files to process. + * + * @param directory The path of the directory to be processed. + * @param wildcard The wildcard to be processed (e.g. *.cpp). + */ +void ASConsole::getFileNames(const string& directory, const string& wildcard) +{ + vector subDirectory; // sub directories of directory + WIN32_FIND_DATA findFileData; // for FindFirstFile and FindNextFile + + // Find the first file in the directory + // Find will get at least "." and "..". + string firstFile = directory + "\\*"; + HANDLE hFind = FindFirstFile(firstFile.c_str(), &findFileData); + + if (hFind == INVALID_HANDLE_VALUE) + { + // Error (3) The system cannot find the path specified. + // Error (123) The filename, directory name, or volume label syntax is incorrect. + // ::FindClose(hFind); before exiting + displayLastError(); + error(_("Cannot open directory"), directory.c_str()); + } + + // save files and sub directories + do + { + // skip hidden or read only + if (findFileData.cFileName[0] == '.' + || (findFileData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) + || (findFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) + continue; + + // is this a sub directory + if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + { + if (!isRecursive) + continue; + // if a sub directory and recursive, save sub directory + string subDirectoryPath = directory + g_fileSeparator + findFileData.cFileName; + if (isPathExclued(subDirectoryPath)) + printMsg(_("Exclude %s\n"), subDirectoryPath.substr(mainDirectoryLength)); + else + subDirectory.emplace_back(subDirectoryPath); + continue; + } + + // save the file name + string filePathName = directory + g_fileSeparator + findFileData.cFileName; + // check exclude before wildcmp to avoid "unmatched exclude" error + bool isExcluded = isPathExclued(filePathName); + // save file name if wildcard match + if (wildcmp(wildcard.c_str(), findFileData.cFileName)) + { + if (isExcluded) + printMsg(_("Exclude %s\n"), filePathName.substr(mainDirectoryLength)); + else + fileName.emplace_back(filePathName); + } + } + while (FindNextFile(hFind, &findFileData) != 0); + + // check for processing error + ::FindClose(hFind); + DWORD dwError = GetLastError(); + if (dwError != ERROR_NO_MORE_FILES) + error("Error processing directory", directory.c_str()); + + // recurse into sub directories + // if not doing recursive subDirectory is empty + for (unsigned i = 0; i < subDirectory.size(); i++) + getFileNames(subDirectory[i], wildcard); + + return; +} + +/** + * WINDOWS function to format a number according to the current locale. + * This formats positive integers only, no float. + * + * @param num The number to be formatted. + * @param lcid The LCID of the locale to be used for testing. + * @return The formatted number. + */ +string ASConsole::getNumberFormat(int num, size_t lcid) const +{ +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__BORLANDC__) || defined(__GNUC__) + // Compilers that don't support C++ locales should still support this assert. + // The C locale should be set but not the C++. + // This function is not necessary if the C++ locale is set. + // The locale().name() return value is not portable to all compilers. + assert(locale().name() == "C"); +#endif + // convert num to a string + stringstream alphaNum; + alphaNum << num; + string number = alphaNum.str(); + if (useAscii) + return number; + + // format the number using the Windows API + if (lcid == 0) + lcid = LOCALE_USER_DEFAULT; + int outSize = ::GetNumberFormat(lcid, 0, number.c_str(), nullptr, nullptr, 0); + char* outBuf = new (nothrow) char[outSize]; + if (outBuf == nullptr) + return number; + ::GetNumberFormat(lcid, 0, number.c_str(), nullptr, outBuf, outSize); + string formattedNum(outBuf); + delete[] outBuf; + // remove the decimal + int decSize = ::GetLocaleInfo(lcid, LOCALE_SDECIMAL, nullptr, 0); + char* decBuf = new (nothrow) char[decSize]; + if (decBuf == nullptr) + return number; + ::GetLocaleInfo(lcid, LOCALE_SDECIMAL, decBuf, decSize); + size_t i = formattedNum.rfind(decBuf); + delete[] decBuf; + if (i != string::npos) + formattedNum.erase(i); + if (!formattedNum.length()) + formattedNum = "0"; + return formattedNum; +} + +/** + * WINDOWS function to open a HTML file in the default browser. + */ +void ASConsole::launchDefaultBrowser(const char* filePathIn /*nullptr*/) const +{ + struct stat statbuf; + const char* envPaths[] = { "PROGRAMFILES(X86)", "PROGRAMFILES" }; + size_t pathsLen = sizeof(envPaths) / sizeof(envPaths[0]); + string htmlDefaultPath; + for (size_t i = 0; i < pathsLen; i++) + { + const char* envPath = getenv(envPaths[i]); + if (envPath == nullptr) + continue; + htmlDefaultPath = envPath; + if (htmlDefaultPath.length() > 0 + && htmlDefaultPath[htmlDefaultPath.length() - 1] == g_fileSeparator) + htmlDefaultPath.erase(htmlDefaultPath.length() - 1); + htmlDefaultPath.append("\\AStyle\\doc"); + if (stat(htmlDefaultPath.c_str(), &statbuf) == 0 && statbuf.st_mode & S_IFDIR) + break; + } + htmlDefaultPath.append("\\"); + + // build file path + string htmlFilePath; + if (filePathIn == nullptr) + htmlFilePath = htmlDefaultPath + "astyle.html"; + else + { + if (strpbrk(filePathIn, "\\/") == nullptr) + htmlFilePath = htmlDefaultPath + filePathIn; + else + htmlFilePath = filePathIn; + } + standardizePath(htmlFilePath); + if (stat(htmlFilePath.c_str(), &statbuf) != 0 || !(statbuf.st_mode & S_IFREG)) + { + printf(_("Cannot open HTML file %s\n"), htmlFilePath.c_str()); + return; + } + + SHELLEXECUTEINFO sei = { sizeof(sei), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + sei.fMask = SEE_MASK_FLAG_NO_UI; + sei.lpVerb = "open"; + sei.lpFile = htmlFilePath.c_str(); + sei.nShow = SW_SHOWNORMAL; + + // browser open will be bypassed in test programs + printf(_("Opening HTML documentation %s\n"), htmlFilePath.c_str()); + if (!bypassBrowserOpen) + { + int ret = ShellExecuteEx(&sei); + if (!ret) + error(_("Command execute failure"), htmlFilePath.c_str()); + } +} + +#else // Linux specific + +/** + * LINUX function to get the current directory. + * This is done if the fileName does not contain a path. + * It is probably from an editor sending a single file. + * + * @param fileName_ The filename is used only for the error message. + * @return The path of the current directory + */ +string ASConsole::getCurrentDirectory(const string& fileName_) const +{ + char* currdir = getenv("PWD"); + if (currdir == nullptr) + error("Cannot find file", fileName_.c_str()); + return string(currdir); +} + +/** + * LINUX function to resolve wildcards and recurse into sub directories. + * The fileName vector is filled with the path and names of files to process. + * + * @param directory The path of the directory to be processed. + * @param wildcard The wildcard to be processed (e.g. *.cpp). + */ +void ASConsole::getFileNames(const string& directory, const string& wildcard) +{ + struct dirent* entry; // entry from readdir() + struct stat statbuf; // entry from stat() + vector subDirectory; // sub directories of this directory + + // errno is defined in and is set for errors in opendir, readdir, or stat + errno = 0; + + DIR* dp = opendir(directory.c_str()); + if (dp == nullptr) + error(_("Cannot open directory"), directory.c_str()); + + // save the first fileName entry for this recursion + const unsigned firstEntry = fileName.size(); + + // save files and sub directories + while ((entry = readdir(dp)) != nullptr) + { + // get file status + string entryFilepath = directory + g_fileSeparator + entry->d_name; + if (stat(entryFilepath.c_str(), &statbuf) != 0) + { + if (errno == EOVERFLOW) // file over 2 GB is OK + { + errno = 0; + continue; + } + perror("errno message"); + error("Error getting file status in directory", directory.c_str()); + } + // skip hidden or read only + if (entry->d_name[0] == '.' || !(statbuf.st_mode & S_IWUSR)) + continue; + // if a sub directory and recursive, save sub directory + if (S_ISDIR(statbuf.st_mode) && isRecursive) + { + if (isPathExclued(entryFilepath)) + printMsg(_("Exclude %s\n"), entryFilepath.substr(mainDirectoryLength)); + else + subDirectory.emplace_back(entryFilepath); + continue; + } + + // if a file, save file name + if (S_ISREG(statbuf.st_mode)) + { + // check exclude before wildcmp to avoid "unmatched exclude" error + bool isExcluded = isPathExclued(entryFilepath); + // save file name if wildcard match + if (wildcmp(wildcard.c_str(), entry->d_name) != 0) + { + if (isExcluded) + printMsg(_("Exclude %s\n"), entryFilepath.substr(mainDirectoryLength)); + else + fileName.emplace_back(entryFilepath); + } + } + } + + if (closedir(dp) != 0) + { + perror("errno message"); + error("Error reading directory", directory.c_str()); + } + + // sort the current entries for fileName + if (firstEntry < fileName.size()) + sort(&fileName[firstEntry], &fileName[fileName.size()]); + + // recurse into sub directories + // if not doing recursive, subDirectory is empty + if (subDirectory.size() > 1) + sort(subDirectory.begin(), subDirectory.end()); + for (unsigned i = 0; i < subDirectory.size(); i++) + { + getFileNames(subDirectory[i], wildcard); + } +} + +/** + * LINUX function to get locale information and call getNumberFormat. + * This formats positive integers only, no float. + * + * @param num The number to be formatted. + * size_t is for compatibility with the Windows function. + * @return The formatted number. + */ +string ASConsole::getNumberFormat(int num, size_t /*lcid*/) const +{ +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__BORLANDC__) || defined(__GNUC__) + // Compilers that don't support C++ locales should still support this assert. + // The C locale should be set but not the C++. + // This function is not necessary if the C++ locale is set. + // The locale().name() return value is not portable to all compilers. + assert(locale().name() == "C"); +#endif + + // get the locale info + struct lconv* lc; + lc = localeconv(); + + // format the number + return getNumberFormat(num, lc->grouping, lc->thousands_sep); +} + +/** + * LINUX function to format a number according to the current locale. + * This formats positive integers only, no float. + * + * @param num The number to be formatted. + * @param groupingArg The grouping string from the locale. + * @param separator The thousands group separator from the locale. + * @return The formatted number. + */ +string ASConsole::getNumberFormat(int num, const char* groupingArg, const char* separator) const +{ + // convert num to a string + stringstream alphaNum; + alphaNum << num; + string number = alphaNum.str(); + // format the number from right to left + string formattedNum; + size_t ig = 0; // grouping index + int grouping = groupingArg[ig]; + int i = number.length(); + // check for no grouping + if (grouping == 0) + grouping = number.length(); + while (i > 0) + { + // extract a group of numbers + string group; + if (i < grouping) + group = number; + else + group = number.substr(i - grouping); + // update formatted number + formattedNum.insert(0, group); + i -= grouping; + if (i < 0) + i = 0; + if (i > 0) + formattedNum.insert(0, separator); + number.erase(i); + // update grouping + if (groupingArg[ig] != '\0' + && groupingArg[ig + 1] != '\0') + grouping = groupingArg[++ig]; + } + return formattedNum; +} + +/** + * LINUX function to open a HTML file in the default browser. + * Use xdg-open from freedesktop.org cross-desktop compatibility suite xdg-utils. + * see http://portland.freedesktop.org/wiki/ + * This is installed on most modern distributions. + */ +void ASConsole::launchDefaultBrowser(const char* filePathIn /*nullptr*/) const +{ + struct stat statbuf; + string htmlDefaultPath = "/usr/share/doc/astyle/html/"; + string htmlDefaultFile = "astyle.html"; + + // build file path + string htmlFilePath; + if (filePathIn == nullptr) + htmlFilePath = htmlDefaultPath + htmlDefaultFile; + else + { + if (strpbrk(filePathIn, "\\/") == nullptr) + htmlFilePath = htmlDefaultPath + filePathIn; + else + htmlFilePath = filePathIn; + } + standardizePath(htmlFilePath); + if (stat(htmlFilePath.c_str(), &statbuf) != 0 || !(statbuf.st_mode & S_IFREG)) + { + printf(_("Cannot open HTML file %s\n"), htmlFilePath.c_str()); + return; + } + + // get search paths + const char* envPaths = getenv("PATH"); + if (envPaths == nullptr) + envPaths = "?"; + size_t envlen = strlen(envPaths); + char* paths = new char[envlen + 1]; + strcpy(paths, envPaths); + // find xdg-open (usually in /usr/bin) + // Mac uses open instead +#ifdef __APPLE__ + const char* fileOpen = "open"; +#else + const char* fileOpen = "xdg-open"; +#endif + string searchPath; + char* searchDir = strtok(paths, ":"); + while (searchDir != nullptr) + { + searchPath = searchDir; + if (searchPath.length() > 0 + && searchPath[searchPath.length() - 1] != g_fileSeparator) + searchPath.append(string(1, g_fileSeparator)); + searchPath.append(fileOpen); + if (stat(searchPath.c_str(), &statbuf) == 0 && (statbuf.st_mode & S_IFREG)) + break; + searchDir = strtok(nullptr, ":"); + } + delete[] paths; + if (searchDir == nullptr) + error(_("Command is not installed"), fileOpen); + + // browser open will be bypassed in test programs + printf(_("Opening HTML documentation %s\n"), htmlFilePath.c_str()); + if (!bypassBrowserOpen) + { + execlp(fileOpen, fileOpen, htmlFilePath.c_str(), nullptr); + // execlp will NOT return if successful + error(_("Command execute failure"), fileOpen); + } +} + +#endif // _WIN32 + +// get individual file names from the command-line file path +void ASConsole::getFilePaths(const string& filePath) +{ + fileName.clear(); + targetDirectory = string(); + targetFilename = string(); + + // separate directory and file name + size_t separator = filePath.find_last_of(g_fileSeparator); + if (separator == string::npos) + { + // if no directory is present, use the currently active directory + targetDirectory = getCurrentDirectory(filePath); + targetFilename = filePath; + mainDirectoryLength = targetDirectory.length() + 1; // +1 includes trailing separator + } + else + { + targetDirectory = filePath.substr(0, separator); + targetFilename = filePath.substr(separator + 1); + mainDirectoryLength = targetDirectory.length() + 1; // +1 includes trailing separator + } + + if (targetFilename.length() == 0) + { + fprintf(stderr, _("Missing filename in %s\n"), filePath.c_str()); + error(); + } + + // check filename for wildcards + hasWildcard = false; + if (targetFilename.find_first_of("*?") != string::npos) + hasWildcard = true; + + // clear exclude hits vector + size_t excludeHitsVectorSize = excludeHitsVector.size(); + for (size_t ix = 0; ix < excludeHitsVectorSize; ix++) + excludeHitsVector[ix] = false; + + // If the filename is not quoted on Linux, bash will replace the + // wildcard instead of passing it to the program. + if (isRecursive && !hasWildcard) + { + fprintf(stderr, "%s\n", _("Recursive option with no wildcard")); +#ifndef _WIN32 + fprintf(stderr, "%s\n", _("Did you intend quote the filename")); +#endif + error(); + } + + // display directory name for wildcard processing + if (hasWildcard) + { + printSeparatingLine(); + printMsg(_("Directory %s\n"), targetDirectory + g_fileSeparator + targetFilename); + } + + // create a vector of paths and file names to process + if (hasWildcard || isRecursive) + getFileNames(targetDirectory, targetFilename); + else + { + // verify a single file is not a directory (needed on Linux) + string entryFilepath = targetDirectory + g_fileSeparator + targetFilename; + struct stat statbuf; + if (stat(entryFilepath.c_str(), &statbuf) == 0 && (statbuf.st_mode & S_IFREG)) + fileName.emplace_back(entryFilepath); + } + + // check for unprocessed excludes + bool excludeErr = false; + for (size_t ix = 0; ix < excludeHitsVector.size(); ix++) + { + if (!excludeHitsVector[ix]) + { + excludeErr = true; + if (!ignoreExcludeErrorsDisplay) + { + if (ignoreExcludeErrors) + printMsg(_("Exclude (unmatched) %s\n"), excludeVector[ix]); + else + fprintf(stderr, _("Exclude (unmatched) %s\n"), excludeVector[ix].c_str()); + } + else + { + if (!ignoreExcludeErrors) + fprintf(stderr, _("Exclude (unmatched) %s\n"), excludeVector[ix].c_str()); + } + } + } + + if (excludeErr && !ignoreExcludeErrors) + { + if (hasWildcard && !isRecursive) + fprintf(stderr, "%s\n", _("Did you intend to use --recursive")); + error(); + } + + // check if files were found (probably an input error if not) + if (fileName.empty()) + { + fprintf(stderr, _("No file to process %s\n"), filePath.c_str()); + if (hasWildcard && !isRecursive) + fprintf(stderr, "%s\n", _("Did you intend to use --recursive")); + error(); + } + + if (hasWildcard) + printSeparatingLine(); +} + +bool ASConsole::fileNameVectorIsEmpty() const +{ + return fileNameVector.empty(); +} + +bool ASConsole::isOption(const string& arg, const char* op) +{ + return arg.compare(op) == 0; +} + +bool ASConsole::isOption(const string& arg, const char* a, const char* b) +{ + return (isOption(arg, a) || isOption(arg, b)); +} + +bool ASConsole::isParamOption(const string& arg, const char* option) +{ + bool retVal = arg.compare(0, strlen(option), option) == 0; + // if comparing for short option, 2nd char of arg must be numeric + if (retVal && strlen(option) == 1 && arg.length() > 1) + if (!isdigit((unsigned char)arg[1])) + retVal = false; + return retVal; +} + +// compare a path to the exclude vector +// used for both directories and filenames +// updates the g_excludeHitsVector +// return true if a match +bool ASConsole::isPathExclued(const string& subPath) +{ + bool retVal = false; + + // read the exclude vector checking for a match + for (size_t i = 0; i < excludeVector.size(); i++) + { + string exclude = excludeVector[i]; + + if (subPath.length() < exclude.length()) + continue; + + size_t compareStart = subPath.length() - exclude.length(); + // subPath compare must start with a directory name + if (compareStart > 0) + { + char lastPathChar = subPath[compareStart - 1]; + if (lastPathChar != g_fileSeparator) + continue; + } + + string compare = subPath.substr(compareStart); + if (!g_isCaseSensitive) + { + // make it case insensitive for Windows + for (size_t j = 0; j < compare.length(); j++) + compare[j] = (char)tolower(compare[j]); + for (size_t j = 0; j < exclude.length(); j++) + exclude[j] = (char)tolower(exclude[j]); + } + // compare sub directory to exclude data - must check them all + if (compare == exclude) + { + excludeHitsVector[i] = true; + retVal = true; + break; + } + } + return retVal; +} + +void ASConsole::printHelp() const +{ + cout << endl; + cout << " Artistic Style " << g_version << endl; + cout << " Maintained by: Jim Pattee\n"; + cout << " Original Author: Tal Davidson\n"; + cout << endl; + cout << "Usage:\n"; + cout << "------\n"; + cout << " astyle [OPTIONS] File1 File2 File3 [...]\n"; + cout << endl; + cout << " astyle [OPTIONS] < Original > Beautified\n"; + cout << endl; + cout << " When indenting a specific file, the resulting indented file RETAINS\n"; + cout << " the original file-name. The original pre-indented file is renamed,\n"; + cout << " with a suffix of \'.orig\' added to the original filename.\n"; + cout << endl; + cout << " Wildcards (* and ?) may be used in the filename.\n"; + cout << " A \'recursive\' option can process directories recursively.\n"; + cout << endl; + cout << " By default, astyle is set up to indent with four spaces per indent,\n"; + cout << " a maximal indentation of 40 spaces inside continuous statements,\n"; + cout << " a minimum indentation of eight spaces inside conditional statements,\n"; + cout << " and NO formatting options.\n"; + cout << endl; + cout << "Options:\n"; + cout << "--------\n"; + cout << " This program follows the usual GNU command line syntax.\n"; + cout << " Long options (starting with '--') must be written one at a time.\n"; + cout << " Short options (starting with '-') may be appended together.\n"; + cout << " Thus, -bps4 is the same as -b -p -s4.\n"; + cout << endl; + cout << "Options File:\n"; + cout << "-------------\n"; + cout << " Artistic Style looks for a default options file in the\n"; + cout << " following order:\n"; + cout << " 1. The contents of the ARTISTIC_STYLE_OPTIONS environment\n"; + cout << " variable if it exists.\n"; + cout << " 2. The file called .astylerc in the directory pointed to by the\n"; + cout << " HOME environment variable ( i.e. $HOME/.astylerc ).\n"; + cout << " 3. The file called astylerc in the directory pointed to by the\n"; + cout << " USERPROFILE environment variable (i.e. %USERPROFILE%\\astylerc).\n"; + cout << " If a default options file is found, the options in this file will\n"; + cout << " be parsed BEFORE the command-line options.\n"; + cout << " Long options within the default option file may be written without\n"; + cout << " the preliminary '--'.\n"; + cout << endl; + cout << "Disable Formatting:\n"; + cout << "-------------------\n"; + cout << " Disable Block\n"; + cout << " Blocks of code can be disabled with the comment tags *INDENT-OFF*\n"; + cout << " and *INDENT-ON*. It must be contained in a one-line comment.\n"; + cout << endl; + cout << " Disable Line\n"; + cout << " Padding of operators can be disabled on a single line using the\n"; + cout << " comment tag *NOPAD*. It must be contained in a line-end comment.\n"; + cout << endl; + cout << "Brace Style Options:\n"; + cout << "--------------------\n"; + cout << " default brace style\n"; + cout << " If no brace style is requested, the opening braces will not be\n"; + cout << " changed and closing braces will be broken from the preceding line.\n"; + cout << endl; + cout << " --style=allman OR --style=bsd OR --style=break OR -A1\n"; + cout << " Allman style formatting/indenting.\n"; + cout << " Broken braces.\n"; + cout << endl; + cout << " --style=java OR --style=attach OR -A2\n"; + cout << " Java style formatting/indenting.\n"; + cout << " Attached braces.\n"; + cout << endl; + cout << " --style=kr OR --style=k&r OR --style=k/r OR -A3\n"; + cout << " Kernighan & Ritchie style formatting/indenting.\n"; + cout << " Linux braces.\n"; + cout << endl; + cout << " --style=stroustrup OR -A4\n"; + cout << " Stroustrup style formatting/indenting.\n"; + cout << " Linux braces.\n"; + cout << endl; + cout << " --style=whitesmith OR -A5\n"; + cout << " Whitesmith style formatting/indenting.\n"; + cout << " Broken, indented braces.\n"; + cout << " Indented class blocks and switch blocks.\n"; + cout << endl; + cout << " --style=vtk OR -A15\n"; + cout << " VTK style formatting/indenting.\n"; + cout << " Broken, indented braces except for the opening braces.\n"; + cout << endl; + cout << " --style=banner OR -A6\n"; + cout << " Banner style formatting/indenting.\n"; + cout << " Attached, indented braces.\n"; + cout << endl; + cout << " --style=gnu OR -A7\n"; + cout << " GNU style formatting/indenting.\n"; + cout << " Broken braces, indented blocks.\n"; + cout << endl; + cout << " --style=linux OR --style=knf OR -A8\n"; + cout << " Linux style formatting/indenting.\n"; + cout << " Linux braces, minimum conditional indent is one-half indent.\n"; + cout << endl; + cout << " --style=horstmann OR --style=run-in OR -A9\n"; + cout << " Horstmann style formatting/indenting.\n"; + cout << " Run-in braces, indented switches.\n"; + cout << endl; + cout << " --style=1tbs OR --style=otbs OR -A10\n"; + cout << " One True Brace Style formatting/indenting.\n"; + cout << " Linux braces, add braces to all conditionals.\n"; + cout << endl; + cout << " --style=google OR -A14\n"; + cout << " Google style formatting/indenting.\n"; + cout << " Attached braces, indented class modifiers.\n"; + cout << endl; + cout << " --style=mozilla OR -A16\n"; + cout << " Mozilla style formatting/indenting.\n"; + cout << " Linux braces, with broken braces for structs and enums,\n"; + cout << " and attached braces for namespaces.\n"; + cout << endl; + cout << " --style=pico OR -A11\n"; + cout << " Pico style formatting/indenting.\n"; + cout << " Run-in opening braces and attached closing braces.\n"; + cout << " Uses keep one line blocks and keep one line statements.\n"; + cout << endl; + cout << " --style=lisp OR -A12\n"; + cout << " Lisp style formatting/indenting.\n"; + cout << " Attached opening braces and attached closing braces.\n"; + cout << " Uses keep one line statements.\n"; + cout << endl; + cout << "Tab Options:\n"; + cout << "------------\n"; + cout << " default indent option\n"; + cout << " If no indentation option is set, the default\n"; + cout << " option of 4 spaces per indent will be used.\n"; + cout << endl; + cout << " --indent=spaces=# OR -s#\n"; + cout << " Indent using # spaces per indent. Not specifying #\n"; + cout << " will result in a default of 4 spaces per indent.\n"; + cout << endl; + cout << " --indent=tab OR --indent=tab=# OR -t OR -t#\n"; + cout << " Indent using tab characters, assuming that each\n"; + cout << " indent is # spaces long. Not specifying # will result\n"; + cout << " in a default assumption of 4 spaces per indent.\n"; + cout << endl; + cout << " --indent=force-tab=# OR -T#\n"; + cout << " Indent using tab characters, assuming that each\n"; + cout << " indent is # spaces long. Force tabs to be used in areas\n"; + cout << " AStyle would prefer to use spaces.\n"; + cout << endl; + cout << " --indent=force-tab-x=# OR -xT#\n"; + cout << " Allows the tab length to be set to a length that is different\n"; + cout << " from the indent length. This may cause the indentation to be\n"; + cout << " a mix of both spaces and tabs. This option sets the tab length.\n"; + cout << endl; + cout << "Brace Modify Options:\n"; + cout << "---------------------\n"; + cout << " --attach-namespaces OR -xn\n"; + cout << " Attach braces to a namespace statement.\n"; + cout << endl; + cout << " --attach-classes OR -xc\n"; + cout << " Attach braces to a class statement.\n"; + cout << endl; + cout << " --attach-inlines OR -xl\n"; + cout << " Attach braces to class inline function definitions.\n"; + cout << endl; + cout << " --attach-extern-c OR -xk\n"; + cout << " Attach braces to an extern \"C\" statement.\n"; + cout << endl; + cout << " --attach-closing-while OR -xV\n"; + cout << " Attach closing while of do-while to the closing brace.\n"; + cout << endl; + cout << "Indentation Options:\n"; + cout << "--------------------\n"; + cout << " --indent-classes OR -C\n"; + cout << " Indent 'class' blocks so that the entire block is indented.\n"; + cout << endl; + cout << " --indent-modifiers OR -xG\n"; + cout << " Indent 'class' access modifiers, 'public:', 'protected:' or\n"; + cout << " 'private:', one half indent. The rest of the class is not\n"; + cout << " indented. \n"; + cout << endl; + cout << " --indent-switches OR -S\n"; + cout << " Indent 'switch' blocks, so that the inner 'case XXX:'\n"; + cout << " headers are indented in relation to the switch block.\n"; + cout << endl; + cout << " --indent-cases OR -K\n"; + cout << " Indent case blocks from the 'case XXX:' headers.\n"; + cout << " Case statements not enclosed in blocks are NOT indented.\n"; + cout << endl; + cout << " --indent-namespaces OR -N\n"; + cout << " Indent the contents of namespace blocks.\n"; + cout << endl; + cout << " --indent-after-parens OR -xU\n"; + cout << " Indent, instead of align, continuation lines following lines\n"; + cout << " that contain an opening paren '(' or an assignment '='. \n"; + cout << endl; + cout << " --indent-continuation=# OR -xt#\n"; + cout << " Indent continuation lines an additional # indents.\n"; + cout << " The valid values are 0 thru 4 indents.\n"; + cout << " The default value is 1 indent.\n"; + cout << endl; + cout << " --indent-labels OR -L\n"; + cout << " Indent labels so that they appear one indent less than\n"; + cout << " the current indentation level, rather than being\n"; + cout << " flushed completely to the left (which is the default).\n"; + cout << endl; + cout << " --indent-preproc-block OR -xW\n"; + cout << " Indent preprocessor blocks at brace level 0.\n"; + cout << " Without this option the preprocessor block is not indented.\n"; + cout << endl; + cout << " --indent-preproc-cond OR -xw\n"; + cout << " Indent preprocessor conditional statements #if/#else/#endif\n"; + cout << " to the same level as the source code.\n"; + cout << endl; + cout << " --indent-preproc-define OR -w\n"; + cout << " Indent multi-line preprocessor #define statements.\n"; + cout << endl; + cout << " --indent-col1-comments OR -Y\n"; + cout << " Indent line comments that start in column one.\n"; + cout << endl; + cout << " --min-conditional-indent=# OR -m#\n"; + cout << " Indent a minimal # spaces in a continuous conditional\n"; + cout << " belonging to a conditional header.\n"; + cout << " The valid values are:\n"; + cout << " 0 - no minimal indent.\n"; + cout << " 1 - indent at least one additional indent.\n"; + cout << " 2 - indent at least two additional indents.\n"; + cout << " 3 - indent at least one-half an additional indent.\n"; + cout << " The default value is 2, two additional indents.\n"; + cout << endl; + cout << " --max-continuation-indent=# OR -M#\n"; + cout << " Indent a maximal # spaces in a continuation line,\n"; + cout << " relative to the previous line.\n"; + cout << " The valid values are 40 thru 120.\n"; + cout << " The default value is 40.\n"; + cout << endl; + cout << "Padding Options:\n"; + cout << "----------------\n"; + cout << " --break-blocks OR -f\n"; + cout << " Insert empty lines around unrelated blocks, labels, classes, ...\n"; + cout << endl; + cout << " --break-blocks=all OR -F\n"; + cout << " Like --break-blocks, except also insert empty lines \n"; + cout << " around closing headers (e.g. 'else', 'catch', ...).\n"; + cout << endl; + cout << " --pad-oper OR -p\n"; + cout << " Insert space padding around operators.\n"; + cout << endl; + cout << " --pad-comma OR -xg\n"; + cout << " Insert space padding after commas.\n"; + cout << endl; + cout << " --pad-paren OR -P\n"; + cout << " Insert space padding around parenthesis on both the outside\n"; + cout << " and the inside.\n"; + cout << endl; + cout << " --pad-paren-out OR -d\n"; + cout << " Insert space padding around parenthesis on the outside only.\n"; + cout << endl; + cout << " --pad-first-paren-out OR -xd\n"; + cout << " Insert space padding around first parenthesis in a series on\n"; + cout << " the outside only.\n"; + cout << endl; + cout << " --pad-paren-in OR -D\n"; + cout << " Insert space padding around parenthesis on the inside only.\n"; + cout << endl; + cout << " --pad-header OR -H\n"; + cout << " Insert space padding after paren headers (e.g. 'if', 'for'...).\n"; + cout << endl; + cout << " --unpad-paren OR -U\n"; + cout << " Remove unnecessary space padding around parenthesis. This\n"; + cout << " can be used in combination with the 'pad' options above.\n"; + cout << endl; + cout << " --delete-empty-lines OR -xd\n"; + cout << " Delete empty lines within a function or method.\n"; + cout << " It will NOT delete lines added by the break-blocks options.\n"; + cout << endl; + cout << " --fill-empty-lines OR -E\n"; + cout << " Fill empty lines with the white space of their\n"; + cout << " previous lines.\n"; + cout << endl; + cout << " --align-pointer=type OR -k1\n"; + cout << " --align-pointer=middle OR -k2\n"; + cout << " --align-pointer=name OR -k3\n"; + cout << " Attach a pointer or reference operator (*, &, or ^) to either\n"; + cout << " the operator type (left), middle, or operator name (right).\n"; + cout << " To align the reference separately use --align-reference.\n"; + cout << endl; + cout << " --align-reference=none OR -W0\n"; + cout << " --align-reference=type OR -W1\n"; + cout << " --align-reference=middle OR -W2\n"; + cout << " --align-reference=name OR -W3\n"; + cout << " Attach a reference operator (&) to either\n"; + cout << " the operator type (left), middle, or operator name (right).\n"; + cout << " If not set, follow pointer alignment.\n"; + cout << endl; + cout << "Formatting Options:\n"; + cout << "-------------------\n"; + cout << " --break-closing-braces OR -y\n"; + cout << " Break braces before closing headers (e.g. 'else', 'catch', ...).\n"; + cout << " Use with --style=java, --style=kr, --style=stroustrup,\n"; + cout << " --style=linux, or --style=1tbs.\n"; + cout << endl; + cout << " --break-elseifs OR -e\n"; + cout << " Break 'else if()' statements into two different lines.\n"; + cout << endl; + cout << " --break-one-line-headers OR -xb\n"; + cout << " Break one line headers (e.g. 'if', 'while', 'else', ...) from a\n"; + cout << " statement residing on the same line.\n"; + cout << endl; + cout << " --add-braces OR -j\n"; + cout << " Add braces to unbraced one line conditional statements.\n"; + cout << endl; + cout << " --add-one-line-braces OR -J\n"; + cout << " Add one line braces to unbraced one line conditional\n"; + cout << " statements.\n"; + cout << endl; + cout << " --remove-braces OR -xj\n"; + cout << " Remove braces from a braced one line conditional statements.\n"; + cout << endl; + cout << " --keep-one-line-blocks OR -O\n"; + cout << " Don't break blocks residing completely on one line.\n"; + cout << endl; + cout << " --keep-one-line-statements OR -o\n"; + cout << " Don't break lines containing multiple statements into\n"; + cout << " multiple single-statement lines.\n"; + cout << endl; + cout << " --convert-tabs OR -c\n"; + cout << " Convert tabs to the appropriate number of spaces.\n"; + cout << endl; + cout << " --close-templates OR -xy\n"; + cout << " Close ending angle brackets on template definitions.\n"; + cout << endl; + cout << " --remove-comment-prefix OR -xp\n"; + cout << " Remove the leading '*' prefix on multi-line comments and\n"; + cout << " indent the comment text one indent.\n"; + cout << endl; + cout << " --max-code-length=# OR -xC#\n"; + cout << " --break-after-logical OR -xL\n"; + cout << " max-code-length=# will break the line if it exceeds more than\n"; + cout << " # characters. The valid values are 50 thru 200.\n"; + cout << " If the line contains logical conditionals they will be placed\n"; + cout << " first on the new line. The option break-after-logical will\n"; + cout << " cause the logical conditional to be placed last on the\n"; + cout << " previous line.\n"; + cout << endl; + cout << " --mode=c\n"; + cout << " Indent a C or C++ source file (this is the default).\n"; + cout << endl; + cout << " --mode=java\n"; + cout << " Indent a Java source file.\n"; + cout << endl; + cout << " --mode=cs\n"; + cout << " Indent a C# source file.\n"; + cout << endl; + cout << "Objective-C Options:\n"; + cout << "--------------------\n"; + cout << " --pad-method-prefix OR -xQ\n"; + cout << " Insert space padding after the '-' or '+' Objective-C\n"; + cout << " method prefix.\n"; + cout << endl; + cout << " --unpad-method-prefix OR -xR\n"; + cout << " Remove all space padding after the '-' or '+' Objective-C\n"; + cout << " method prefix.\n"; + cout << endl; + cout << " --pad-return-type OR -xq\n"; + cout << " Insert space padding after the Objective-C return type.\n"; + cout << endl; + cout << " --unpad-return-type OR -xr\n"; + cout << " Remove all space padding after the Objective-C return type.\n"; + cout << endl; + cout << " --pad-param-type OR -xS\n"; + cout << " Insert space padding after the Objective-C return type.\n"; + cout << endl; + cout << " --unpad-param-type OR -xs\n"; + cout << " Remove all space padding after the Objective-C return type.\n"; + cout << endl; + cout << " --align-method-colon OR -xM\n"; + cout << " Align the colons in an Objective-C method definition.\n"; + cout << endl; + cout << " --pad-method-colon=none OR -xP\n"; + cout << " --pad-method-colon=all OR -xP1\n"; + cout << " --pad-method-colon=after OR -xP2\n"; + cout << " --pad-method-colon=before OR -xP3\n"; + cout << " Add or remove space padding before or after the colons in an\n"; + cout << " Objective-C method call.\n"; + cout << endl; + cout << "Other Options:\n"; + cout << "--------------\n"; + cout << " --suffix=####\n"; + cout << " Append the suffix #### instead of '.orig' to original filename.\n"; + cout << endl; + cout << " --suffix=none OR -n\n"; + cout << " Do not retain a backup of the original file.\n"; + cout << endl; + cout << " --recursive OR -r OR -R\n"; + cout << " Process subdirectories recursively.\n"; + cout << endl; + cout << " --dry-run\n"; + cout << " Perform a trial run with no changes made to check for formatting.\n"; + cout << endl; + cout << " --exclude=####\n"; + cout << " Specify a file or directory #### to be excluded from processing.\n"; + cout << endl; + cout << " --ignore-exclude-errors OR -i\n"; + cout << " Allow processing to continue if there are errors in the exclude=####\n"; + cout << " options. It will display the unmatched excludes.\n"; + cout << endl; + cout << " --ignore-exclude-errors-x OR -xi\n"; + cout << " Allow processing to continue if there are errors in the exclude=####\n"; + cout << " options. It will NOT display the unmatched excludes.\n"; + cout << endl; + cout << " --errors-to-stdout OR -X\n"; + cout << " Print errors and help information to standard-output rather than\n"; + cout << " to standard-error.\n"; + cout << endl; + cout << " --preserve-date OR -Z\n"; + cout << " Preserve the original file's date and time modified. The time\n"; + cout << " modified will be changed a few micro seconds to force a compile.\n"; + cout << endl; + cout << " --verbose OR -v\n"; + cout << " Verbose mode. Extra informational messages will be displayed.\n"; + cout << endl; + cout << " --formatted OR -Q\n"; + cout << " Formatted display mode. Display only the files that have been\n"; + cout << " formatted.\n"; + cout << endl; + cout << " --quiet OR -q\n"; + cout << " Quiet mode. Suppress all output except error messages.\n"; + cout << endl; + cout << " --lineend=windows OR -z1\n"; + cout << " --lineend=linux OR -z2\n"; + cout << " --lineend=macold OR -z3\n"; + cout << " Force use of the specified line end style. Valid options\n"; + cout << " are windows (CRLF), linux (LF), and macold (CR).\n"; + cout << endl; + cout << "Command Line Only:\n"; + cout << "------------------\n"; + cout << " --options=####\n"; + cout << " Specify an options file #### to read and use.\n"; + cout << endl; + cout << " --options=none\n"; + cout << " Disable the default options file.\n"; + cout << " Only the command-line parameters will be used.\n"; + cout << endl; + cout << " --ascii OR -I\n"; + cout << " The displayed output will be ascii characters only.\n"; + cout << endl; + cout << " --version OR -V\n"; + cout << " Print version number.\n"; + cout << endl; + cout << " --help OR -h OR -?\n"; + cout << " Print this help message.\n"; + cout << endl; + cout << " --html OR -!\n"; + cout << " Open the HTML help file \"astyle.html\" in the default browser.\n"; + cout << " The documentation must be installed in the standard install path.\n"; + cout << endl; + cout << " --html=####\n"; + cout << " Open a HTML help file in the default browser using the file path\n"; + cout << " ####. The path may include a directory path and a file name, or a\n"; + cout << " file name only. Paths containing spaces must be enclosed in quotes.\n"; + cout << endl; + cout << endl; +} + +/** + * Process files in the fileNameVector. + */ +void ASConsole::processFiles() +{ + if (isVerbose) + printVerboseHeader(); + + clock_t startTime = clock(); // start time of file formatting + + // loop thru input fileNameVector and process the files + for (size_t i = 0; i < fileNameVector.size(); i++) + { + getFilePaths(fileNameVector[i]); + + // loop thru fileName vector formatting the files + for (size_t j = 0; j < fileName.size(); j++) + formatFile(fileName[j]); + } + + // files are processed, display stats + if (isVerbose) + printVerboseStats(startTime); +} + +// process options from the command line and options file +// build the vectors fileNameVector, excludeVector, optionsVector, and fileOptionsVector +void ASConsole::processOptions(const vector& argvOptions) +{ + string arg; + bool ok = true; + bool shouldParseOptionsFile = true; + + // get command line options + for (size_t i = 0; i < argvOptions.size(); i++) + { + arg = argvOptions[i]; + + if ( isOption(arg, "-I" ) + || isOption(arg, "--ascii") ) + { + useAscii = true; + setlocale(LC_ALL, "C"); // use English decimal indicator + localizer.setLanguageFromName("en"); + } + else if ( isOption(arg, "--options=none") ) + { + shouldParseOptionsFile = false; + } + else if ( isParamOption(arg, "--options=") ) + { + optionsFileName = getParam(arg, "--options="); + optionsFileRequired = true; + if (optionsFileName.empty()) + setOptionsFileName(" "); + } + else if ( isOption(arg, "-h") + || isOption(arg, "--help") + || isOption(arg, "-?") ) + { + printHelp(); + exit(EXIT_SUCCESS); + } + else if ( isOption(arg, "-!") + || isOption(arg, "--html") ) + { + launchDefaultBrowser(); + exit(EXIT_SUCCESS); + } + else if ( isParamOption(arg, "--html=") ) + { + string htmlFilePath = getParam(arg, "--html="); + launchDefaultBrowser(htmlFilePath.c_str()); + exit(EXIT_SUCCESS); + } + else if ( isOption(arg, "-V" ) + || isOption(arg, "--version") ) + { + printf("Artistic Style Version %s\n", g_version); + exit(EXIT_SUCCESS); + } + else if (arg[0] == '-') + { + optionsVector.emplace_back(arg); + } + else // file-name + { + standardizePath(arg); + fileNameVector.emplace_back(arg); + } + } + + // get options file path and name + if (shouldParseOptionsFile) + { + if (optionsFileName.empty()) + { + char* env = getenv("ARTISTIC_STYLE_OPTIONS"); + if (env != nullptr) + setOptionsFileName(env); + } + if (optionsFileName.empty()) + { + char* env = getenv("HOME"); + if (env != nullptr) + setOptionsFileName(string(env) + "/.astylerc"); + } + if (optionsFileName.empty()) + { + char* env = getenv("USERPROFILE"); + if (env != nullptr) + setOptionsFileName(string(env) + "/astylerc"); + } + if (!optionsFileName.empty()) + standardizePath(optionsFileName); + } + + // create the options file vector and parse the options for errors + ASOptions options(formatter, *this); + if (!optionsFileName.empty()) + { + ifstream optionsIn(optionsFileName.c_str()); + if (optionsIn) + { + options.importOptions(optionsIn, fileOptionsVector); + ok = options.parseOptions(fileOptionsVector, + string(_("Invalid option file options:"))); + } + else + { + if (optionsFileRequired) + error(_("Cannot open options file"), optionsFileName.c_str()); + optionsFileName.clear(); + } + optionsIn.close(); + } + if (!ok) + { + (*errorStream) << options.getOptionErrors() << endl; + (*errorStream) << _("For help on options type 'astyle -h'") << endl; + error(); + } + + // parse the command line options vector for errors + ok = options.parseOptions(optionsVector, + string(_("Invalid command line options:"))); + if (!ok) + { + (*errorStream) << options.getOptionErrors() << endl; + (*errorStream) << _("For help on options type 'astyle -h'") << endl; + error(); + } +} + +// remove a file and check for an error +void ASConsole::removeFile(const char* fileName_, const char* errMsg) const +{ + if (remove(fileName_) != 0) + { + if (errno == ENOENT) // no file is OK + errno = 0; + if (errno) + { + perror("errno message"); + error(errMsg, fileName_); + } + } +} + +// rename a file and check for an error +void ASConsole::renameFile(const char* oldFileName, const char* newFileName, const char* errMsg) const +{ + int result = rename(oldFileName, newFileName); + if (result != 0) + { + // if file still exists the remove needs more time - retry + if (errno == EEXIST) + { + errno = 0; + waitForRemove(newFileName); + result = rename(oldFileName, newFileName); + } + if (result != 0) + { + perror("errno message"); + error(errMsg, oldFileName); + } + } +} + +// make sure file separators are correct type (Windows or Linux) +// remove ending file separator +// remove beginning file separator if requested and NOT a complete file path +void ASConsole::standardizePath(string& path, bool removeBeginningSeparator /*false*/) const +{ +#ifdef __VMS + struct FAB fab; + struct NAML naml; + char less[NAML$C_MAXRSS]; + char sess[NAM$C_MAXRSS]; + int r0_status; + + // If we are on a VMS system, translate VMS style filenames to unix + // style. + fab = cc$rms_fab; + fab.fab$l_fna = (char*) -1; // *NOPAD* + fab.fab$b_fns = 0; + fab.fab$l_naml = &naml; + naml = cc$rms_naml; + strcpy(sess, path.c_str()); + naml.naml$l_long_filename = (char*)sess; + naml.naml$l_long_filename_size = path.length(); + naml.naml$l_long_expand = less; + naml.naml$l_long_expand_alloc = sizeof(less); + naml.naml$l_esa = sess; + naml.naml$b_ess = sizeof(sess); + naml.naml$v_no_short_upcase = 1; + r0_status = sys$parse(&fab); + if (r0_status == RMS$_SYN) + { + error("File syntax error", path.c_str()); + } + else + { + if (!$VMS_STATUS_SUCCESS(r0_status)) + { + (void)lib$signal (r0_status); + } + } + less[naml.naml$l_long_expand_size - naml.naml$b_ver] = '\0'; + sess[naml.naml$b_esl - naml.naml$b_ver] = '\0'; + if (naml.naml$l_long_expand_size > naml.naml$b_esl) + { + path = decc$translate_vms (less); + } + else + { + path = decc$translate_vms(sess); + } +#endif /* __VMS */ + + // make sure separators are correct type (Windows or Linux) + for (size_t i = 0; i < path.length(); i++) + { + i = path.find_first_of("/\\", i); + if (i == string::npos) + break; + path[i] = g_fileSeparator; + } + // remove beginning separator if requested + if (removeBeginningSeparator && (path[0] == g_fileSeparator)) + path.erase(0, 1); +} + +void ASConsole::printMsg(const char* msg, const string& data) const +{ + if (isQuiet) + return; + printf(msg, data.c_str()); +} + +void ASConsole::printSeparatingLine() const +{ + string line; + for (size_t i = 0; i < 60; i++) + line.append("-"); + printMsg("%s\n", line); +} + +void ASConsole::printVerboseHeader() const +{ + assert(isVerbose); + if (isQuiet) + return; + // get the date + time_t lt; + char str[20]; + lt = time(nullptr); + struct tm* ptr = localtime(<); + strftime(str, 20, "%x", ptr); + // print the header + // 60 is the length of the separator in printSeparatingLine() + string header = "Artistic Style " + string(g_version); + size_t numSpaces = 60 - header.length() - strlen(str); + header.append(numSpaces, ' '); + header.append(str); + header.append("\n"); + printf("%s", header.c_str()); + // print options file + if (!optionsFileName.empty()) + printf(_("Using default options file %s\n"), optionsFileName.c_str()); +} + +void ASConsole::printVerboseStats(clock_t startTime) const +{ + assert(isVerbose); + if (isQuiet) + return; + if (hasWildcard) + printSeparatingLine(); + string formatted = getNumberFormat(filesFormatted); + string unchanged = getNumberFormat(filesUnchanged); + printf(_(" %s formatted %s unchanged "), formatted.c_str(), unchanged.c_str()); + + // show processing time + clock_t stopTime = clock(); + double secs = (stopTime - startTime) / double (CLOCKS_PER_SEC); + if (secs < 60) + { + if (secs < 2.0) + printf("%.2f", secs); + else if (secs < 20.0) + printf("%.1f", secs); + else + printf("%.0f", secs); + printf("%s", _(" seconds ")); + } + else + { + // show minutes and seconds if time is greater than one minute + int min = (int) secs / 60; + secs -= min * 60; + int minsec = int (secs + .5); + printf(_("%d min %d sec "), min, minsec); + } + + string lines = getNumberFormat(linesOut); + printf(_("%s lines\n"), lines.c_str()); +} + +void ASConsole::sleep(int seconds) const +{ + clock_t endwait; + endwait = clock_t (clock () + seconds * CLOCKS_PER_SEC); + while (clock() < endwait) {} +} + +bool ASConsole::stringEndsWith(const string& str, const string& suffix) const +{ + int strIndex = (int) str.length() - 1; + int suffixIndex = (int) suffix.length() - 1; + + while (strIndex >= 0 && suffixIndex >= 0) + { + if (tolower(str[strIndex]) != tolower(suffix[suffixIndex])) + return false; + + --strIndex; + --suffixIndex; + } + // suffix longer than string + if (strIndex < 0 && suffixIndex >= 0) + return false; + return true; +} + +void ASConsole::updateExcludeVector(const string& suffixParam) +{ + excludeVector.emplace_back(suffixParam); + standardizePath(excludeVector.back(), true); + excludeHitsVector.push_back(false); +} + +int ASConsole::waitForRemove(const char* newFileName) const +{ + struct stat stBuf; + int seconds; + // sleep a max of 20 seconds for the remove + for (seconds = 1; seconds <= 20; seconds++) + { + sleep(1); + if (stat(newFileName, &stBuf) != 0) + break; + } + errno = 0; + return seconds; +} + +// From The Code Project http://www.codeproject.com/string/wildcmp.asp +// Written by Jack Handy - jakkhandy@hotmail.com +// Modified to compare case insensitive for Windows +int ASConsole::wildcmp(const char* wild, const char* data) const +{ + const char* cp = nullptr, *mp = nullptr; + bool cmpval; + + while ((*data) && (*wild != '*')) + { + if (!g_isCaseSensitive) + cmpval = (tolower(*wild) != tolower(*data)) && (*wild != '?'); + else + cmpval = (*wild != *data) && (*wild != '?'); + + if (cmpval) + { + return 0; + } + wild++; + data++; + } + + while (*data) + { + if (*wild == '*') + { + if (!*++wild) + { + return 1; + } + mp = wild; + cp = data + 1; + } + else + { + if (!g_isCaseSensitive) + cmpval = (tolower(*wild) == tolower(*data) || (*wild == '?')); + else + cmpval = (*wild == *data) || (*wild == '?'); + + if (cmpval) + { + wild++; + data++; + } + else + { + wild = mp; + data = cp++; + } + } + } + + while (*wild == '*') + { + wild++; + } + return !*wild; +} + +void ASConsole::writeFile(const string& fileName_, FileEncoding encoding, ostringstream& out) const +{ + // save date accessed and date modified of original file + struct stat stBuf; + bool statErr = false; + if (stat(fileName_.c_str(), &stBuf) == -1) + statErr = true; + + // create a backup + if (!noBackup) + { + string origFileName = fileName_ + origSuffix; + removeFile(origFileName.c_str(), "Cannot remove pre-existing backup file"); + renameFile(fileName_.c_str(), origFileName.c_str(), "Cannot create backup file"); + } + + // write the output file + ofstream fout(fileName_.c_str(), ios::binary | ios::trunc); + if (!fout) + error("Cannot open output file", fileName_.c_str()); + if (encoding == UTF_16LE || encoding == UTF_16BE) + { + // convert utf-8 to utf-16 + bool isBigEndian = (encoding == UTF_16BE); + size_t utf16Size = utf8_16.utf16LengthFromUtf8(out.str().c_str(), out.str().length()); + char* utf16Out = new char[utf16Size]; + size_t utf16Len = utf8_16.utf8ToUtf16(const_cast(out.str().c_str()), + out.str().length(), isBigEndian, utf16Out); + assert(utf16Len == utf16Size); + fout << string(utf16Out, utf16Len); + delete[] utf16Out; + } + else + fout << out.str(); + + fout.close(); + + // change date modified to original file date + // Embarcadero must be linked with cw32mt not cw32 + if (preserveDate) + { + if (!statErr) + { + struct utimbuf outBuf; + outBuf.actime = stBuf.st_atime; + // add ticks so 'make' will recognize a change + // Visual Studio 2008 needs more than 1 + outBuf.modtime = stBuf.st_mtime + 10; + if (utime(fileName_.c_str(), &outBuf) == -1) + statErr = true; + } + if (statErr) + { + perror("errno message"); + (*errorStream) << "********* Cannot preserve file date" << endl; + } + } +} + +#else // ASTYLE_LIB + +//----------------------------------------------------------------------------- +// ASLibrary class +// used by shared object (DLL) calls +//----------------------------------------------------------------------------- + +utf16_t* ASLibrary::formatUtf16(const utf16_t* pSourceIn, // the source to be formatted + const utf16_t* pOptions, // AStyle options + fpError fpErrorHandler, // error handler function + fpAlloc fpMemoryAlloc) const // memory allocation function) +{ + const char* utf8In = convertUtf16ToUtf8(pSourceIn); + if (utf8In == nullptr) + { + fpErrorHandler(121, "Cannot convert input utf-16 to utf-8."); + return nullptr; + } + const char* utf8Options = convertUtf16ToUtf8(pOptions); + if (utf8Options == nullptr) + { + delete[] utf8In; + fpErrorHandler(122, "Cannot convert options utf-16 to utf-8."); + return nullptr; + } + // call the Artistic Style formatting function + // cannot use the callers memory allocation here + char* utf8Out = AStyleMain(utf8In, + utf8Options, + fpErrorHandler, + ASLibrary::tempMemoryAllocation); + // finished with these + delete[] utf8In; + delete[] utf8Options; + utf8In = nullptr; + utf8Options = nullptr; + // AStyle error has already been sent + if (utf8Out == nullptr) + return nullptr; + // convert text to wide char and return it + utf16_t* utf16Out = convertUtf8ToUtf16(utf8Out, fpMemoryAlloc); + delete[] utf8Out; + utf8Out = nullptr; + if (utf16Out == nullptr) + { + fpErrorHandler(123, "Cannot convert output utf-8 to utf-16."); + return nullptr; + } + return utf16Out; +} + +// STATIC method to allocate temporary memory for AStyle formatting. +// The data will be converted before being returned to the calling program. +char* STDCALL ASLibrary::tempMemoryAllocation(unsigned long memoryNeeded) +{ + char* buffer = new (nothrow) char[memoryNeeded]; + return buffer; +} + +/** + * Convert utf-8 strings to utf16 strings. + * Memory is allocated by the calling program memory allocation function. + * The calling function must check for errors. + */ +utf16_t* ASLibrary::convertUtf8ToUtf16(const char* utf8In, fpAlloc fpMemoryAlloc) const +{ + if (utf8In == nullptr) + return nullptr; + char* data = const_cast(utf8In); + size_t dataSize = strlen(utf8In); + bool isBigEndian = utf8_16.getBigEndian(); + // return size is in number of CHARs, not utf16_t + size_t utf16Size = (utf8_16.utf16LengthFromUtf8(data, dataSize) + sizeof(utf16_t)); + char* utf16Out = fpMemoryAlloc((long)utf16Size); + if (utf16Out == nullptr) + return nullptr; +#ifdef NDEBUG + utf8_16.utf8ToUtf16(data, dataSize + 1, isBigEndian, utf16Out); +#else + size_t utf16Len = utf8_16.utf8ToUtf16(data, dataSize + 1, isBigEndian, utf16Out); + assert(utf16Len == utf16Size); +#endif + assert(utf16Size == (utf8_16.utf16len(reinterpret_cast(utf16Out)) + 1) * sizeof(utf16_t)); + return reinterpret_cast(utf16Out); +} + +/** + * Convert utf16 strings to utf-8. + * The calling function must check for errors and delete the + * allocated memory. + */ +char* ASLibrary::convertUtf16ToUtf8(const utf16_t* utf16In) const +{ + if (utf16In == nullptr) + return nullptr; + char* data = reinterpret_cast(const_cast(utf16In)); + // size must be in chars + size_t dataSize = utf8_16.utf16len(utf16In) * sizeof(utf16_t); + bool isBigEndian = utf8_16.getBigEndian(); + size_t utf8Size = utf8_16.utf8LengthFromUtf16(data, dataSize, isBigEndian) + 1; + char* utf8Out = new (nothrow) char[utf8Size]; + if (utf8Out == nullptr) + return nullptr; +#ifdef NDEBUG + utf8_16.utf16ToUtf8(data, dataSize + 1, isBigEndian, true, utf8Out); +#else + size_t utf8Len = utf8_16.utf16ToUtf8(data, dataSize + 1, isBigEndian, true, utf8Out); + assert(utf8Len == utf8Size); +#endif + assert(utf8Size == strlen(utf8Out) + 1); + return utf8Out; +} + +#endif // ASTYLE_LIB + +//----------------------------------------------------------------------------- +// ASOptions class +// used by both console and library builds +//----------------------------------------------------------------------------- + +#ifdef ASTYLE_LIB +ASOptions::ASOptions(ASFormatter& formatterArg) + : formatter(formatterArg) +{ } +#else +ASOptions::ASOptions(ASFormatter& formatterArg, ASConsole& consoleArg) + : formatter(formatterArg), console(consoleArg) +{ } +#endif + +/** + * parse the options vector + * optionsVector can be either a fileOptionsVector (options file) or an optionsVector (command line) + * + * @return true if no errors, false if errors + */ +bool ASOptions::parseOptions(vector& optionsVector, const string& errorInfo) +{ + vector::iterator option; + string arg, subArg; + optionErrors.clear(); + + for (option = optionsVector.begin(); option != optionsVector.end(); ++option) + { + arg = *option; + + if (arg.compare(0, 2, "--") == 0) + parseOption(arg.substr(2), errorInfo); + else if (arg[0] == '-') + { + size_t i; + + for (i = 1; i < arg.length(); ++i) + { + if (i > 1 + && isalpha((unsigned char)arg[i]) + && arg[i - 1] != 'x') + { + // parse the previous option in subArg + parseOption(subArg, errorInfo); + subArg = ""; + } + // append the current option to subArg + subArg.append(1, arg[i]); + } + // parse the last option + parseOption(subArg, errorInfo); + subArg = ""; + } + else + { + parseOption(arg, errorInfo); + subArg = ""; + } + } + if (optionErrors.str().length() > 0) + return false; + return true; +} + +void ASOptions::parseOption(const string& arg, const string& errorInfo) +{ + if ( isOption(arg, "style=allman") || isOption(arg, "style=bsd") || isOption(arg, "style=break") ) + { + formatter.setFormattingStyle(STYLE_ALLMAN); + } + else if ( isOption(arg, "style=java") || isOption(arg, "style=attach") ) + { + formatter.setFormattingStyle(STYLE_JAVA); + } + else if ( isOption(arg, "style=k&r") || isOption(arg, "style=kr") || isOption(arg, "style=k/r") ) + { + formatter.setFormattingStyle(STYLE_KR); + } + else if ( isOption(arg, "style=stroustrup") ) + { + formatter.setFormattingStyle(STYLE_STROUSTRUP); + } + else if ( isOption(arg, "style=whitesmith") ) + { + formatter.setFormattingStyle(STYLE_WHITESMITH); + } + else if ( isOption(arg, "style=vtk") ) + { + formatter.setFormattingStyle(STYLE_VTK); + } + else if ( isOption(arg, "style=banner") ) + { + formatter.setFormattingStyle(STYLE_BANNER); + } + else if ( isOption(arg, "style=gnu") ) + { + formatter.setFormattingStyle(STYLE_GNU); + } + else if ( isOption(arg, "style=linux") || isOption(arg, "style=knf") ) + { + formatter.setFormattingStyle(STYLE_LINUX); + } + else if ( isOption(arg, "style=horstmann") || isOption(arg, "style=run-in") ) + { + formatter.setFormattingStyle(STYLE_HORSTMANN); + } + else if ( isOption(arg, "style=1tbs") || isOption(arg, "style=otbs") ) + { + formatter.setFormattingStyle(STYLE_1TBS); + } + else if ( isOption(arg, "style=google") ) + { + formatter.setFormattingStyle(STYLE_GOOGLE); + } + else if (isOption(arg, "style=mozilla")) + { + formatter.setFormattingStyle(STYLE_MOZILLA); + } + else if ( isOption(arg, "style=pico") ) + { + formatter.setFormattingStyle(STYLE_PICO); + } + else if ( isOption(arg, "style=lisp") || isOption(arg, "style=python") ) + { + formatter.setFormattingStyle(STYLE_LISP); + } + else if ( isParamOption(arg, "A") ) + { + int style = 0; + string styleParam = getParam(arg, "A"); + if (styleParam.length() > 0) + style = atoi(styleParam.c_str()); + if (style == 1) + formatter.setFormattingStyle(STYLE_ALLMAN); + else if (style == 2) + formatter.setFormattingStyle(STYLE_JAVA); + else if (style == 3) + formatter.setFormattingStyle(STYLE_KR); + else if (style == 4) + formatter.setFormattingStyle(STYLE_STROUSTRUP); + else if (style == 5) + formatter.setFormattingStyle(STYLE_WHITESMITH); + else if (style == 6) + formatter.setFormattingStyle(STYLE_BANNER); + else if (style == 7) + formatter.setFormattingStyle(STYLE_GNU); + else if (style == 8) + formatter.setFormattingStyle(STYLE_LINUX); + else if (style == 9) + formatter.setFormattingStyle(STYLE_HORSTMANN); + else if (style == 10) + formatter.setFormattingStyle(STYLE_1TBS); + else if (style == 11) + formatter.setFormattingStyle(STYLE_PICO); + else if (style == 12) + formatter.setFormattingStyle(STYLE_LISP); + else if (style == 14) + formatter.setFormattingStyle(STYLE_GOOGLE); + else if (style == 15) + formatter.setFormattingStyle(STYLE_VTK); + else if (style == 16) + formatter.setFormattingStyle(STYLE_MOZILLA); + else + isOptionError(arg, errorInfo); + } + // must check for mode=cs before mode=c !!! + else if ( isOption(arg, "mode=cs") ) + { + formatter.setSharpStyle(); + formatter.setModeManuallySet(true); + } + else if ( isOption(arg, "mode=c") ) + { + formatter.setCStyle(); + formatter.setModeManuallySet(true); + } + else if ( isOption(arg, "mode=java") ) + { + formatter.setJavaStyle(); + formatter.setModeManuallySet(true); + } + else if ( isParamOption(arg, "t", "indent=tab=") ) + { + int spaceNum = 4; + string spaceNumParam = getParam(arg, "t", "indent=tab="); + if (spaceNumParam.length() > 0) + spaceNum = atoi(spaceNumParam.c_str()); + if (spaceNum < 2 || spaceNum > 20) + isOptionError(arg, errorInfo); + else + { + formatter.setTabIndentation(spaceNum, false); + } + } + else if ( isOption(arg, "indent=tab") ) + { + formatter.setTabIndentation(4); + } + else if ( isParamOption(arg, "T", "indent=force-tab=") ) + { + int spaceNum = 4; + string spaceNumParam = getParam(arg, "T", "indent=force-tab="); + if (spaceNumParam.length() > 0) + spaceNum = atoi(spaceNumParam.c_str()); + if (spaceNum < 2 || spaceNum > 20) + isOptionError(arg, errorInfo); + else + { + formatter.setTabIndentation(spaceNum, true); + } + } + else if ( isOption(arg, "indent=force-tab") ) + { + formatter.setTabIndentation(4, true); + } + else if ( isParamOption(arg, "xT", "indent=force-tab-x=") ) + { + int tabNum = 8; + string tabNumParam = getParam(arg, "xT", "indent=force-tab-x="); + if (tabNumParam.length() > 0) + tabNum = atoi(tabNumParam.c_str()); + if (tabNum < 2 || tabNum > 20) + isOptionError(arg, errorInfo); + else + { + formatter.setForceTabXIndentation(tabNum); + } + } + else if ( isOption(arg, "indent=force-tab-x") ) + { + formatter.setForceTabXIndentation(8); + } + else if ( isParamOption(arg, "s", "indent=spaces=") ) + { + int spaceNum = 4; + string spaceNumParam = getParam(arg, "s", "indent=spaces="); + if (spaceNumParam.length() > 0) + spaceNum = atoi(spaceNumParam.c_str()); + if (spaceNum < 2 || spaceNum > 20) + isOptionError(arg, errorInfo); + else + { + formatter.setSpaceIndentation(spaceNum); + } + } + else if ( isOption(arg, "indent=spaces") ) + { + formatter.setSpaceIndentation(4); + } + else if (isParamOption(arg, "xt", "indent-continuation=")) + { + int contIndent = 1; + string contIndentParam = getParam(arg, "xt", "indent-continuation="); + if (contIndentParam.length() > 0) + contIndent = atoi(contIndentParam.c_str()); + if (contIndent < 0) + isOptionError(arg, errorInfo); + else if (contIndent > 4) + isOptionError(arg, errorInfo); + else + formatter.setContinuationIndentation(contIndent); + } + else if ( isParamOption(arg, "m", "min-conditional-indent=") ) + { + int minIndent = MINCOND_TWO; + string minIndentParam = getParam(arg, "m", "min-conditional-indent="); + if (minIndentParam.length() > 0) + minIndent = atoi(minIndentParam.c_str()); + if (minIndent >= MINCOND_END) + isOptionError(arg, errorInfo); + else + formatter.setMinConditionalIndentOption(minIndent); + } + else if ( isParamOption(arg, "M", "max-continuation-indent=") ) + { + int maxIndent = 40; + string maxIndentParam = getParam(arg, "M", "max-continuation-indent="); + if (maxIndentParam.length() > 0) + maxIndent = atoi(maxIndentParam.c_str()); + if (maxIndent < 40) + isOptionError(arg, errorInfo); + else if (maxIndent > 120) + isOptionError(arg, errorInfo); + else + formatter.setMaxContinuationIndentLength(maxIndent); + } + else if ( isOption(arg, "N", "indent-namespaces") ) + { + formatter.setNamespaceIndent(true); + } + else if ( isOption(arg, "C", "indent-classes") ) + { + formatter.setClassIndent(true); + } + else if ( isOption(arg, "xG", "indent-modifiers") ) + { + formatter.setModifierIndent(true); + } + else if ( isOption(arg, "S", "indent-switches") ) + { + formatter.setSwitchIndent(true); + } + else if ( isOption(arg, "K", "indent-cases") ) + { + formatter.setCaseIndent(true); + } + else if ( isOption(arg, "xU", "indent-after-parens") ) + { + formatter.setAfterParenIndent(true); + } + else if ( isOption(arg, "L", "indent-labels") ) + { + formatter.setLabelIndent(true); + } + else if (isOption(arg, "xW", "indent-preproc-block")) + { + formatter.setPreprocBlockIndent(true); + } + else if ( isOption(arg, "w", "indent-preproc-define") ) + { + formatter.setPreprocDefineIndent(true); + } + else if ( isOption(arg, "xw", "indent-preproc-cond") ) + { + formatter.setPreprocConditionalIndent(true); + } + else if ( isOption(arg, "y", "break-closing-braces") ) + { + formatter.setBreakClosingHeaderBracesMode(true); + } + else if ( isOption(arg, "O", "keep-one-line-blocks") ) + { + formatter.setBreakOneLineBlocksMode(false); + } + else if ( isOption(arg, "o", "keep-one-line-statements") ) + { + formatter.setBreakOneLineStatementsMode(false); + } + else if ( isOption(arg, "P", "pad-paren") ) + { + formatter.setParensOutsidePaddingMode(true); + formatter.setParensInsidePaddingMode(true); + } + else if ( isOption(arg, "d", "pad-paren-out") ) + { + formatter.setParensOutsidePaddingMode(true); + } + else if ( isOption(arg, "xd", "pad-first-paren-out") ) + { + formatter.setParensFirstPaddingMode(true); + } + else if ( isOption(arg, "D", "pad-paren-in") ) + { + formatter.setParensInsidePaddingMode(true); + } + else if ( isOption(arg, "H", "pad-header") ) + { + formatter.setParensHeaderPaddingMode(true); + } + else if ( isOption(arg, "U", "unpad-paren") ) + { + formatter.setParensUnPaddingMode(true); + } + else if ( isOption(arg, "p", "pad-oper") ) + { + formatter.setOperatorPaddingMode(true); + } + else if (isOption(arg, "xg", "pad-comma")) + { + formatter.setCommaPaddingMode(true); + } + else if ( isOption(arg, "xe", "delete-empty-lines") ) + { + formatter.setDeleteEmptyLinesMode(true); + } + else if ( isOption(arg, "E", "fill-empty-lines") ) + { + formatter.setEmptyLineFill(true); + } + else if ( isOption(arg, "c", "convert-tabs") ) + { + formatter.setTabSpaceConversionMode(true); + } + else if ( isOption(arg, "xy", "close-templates") ) + { + formatter.setCloseTemplatesMode(true); + } + else if ( isOption(arg, "F", "break-blocks=all") ) + { + formatter.setBreakBlocksMode(true); + formatter.setBreakClosingHeaderBlocksMode(true); + } + else if ( isOption(arg, "f", "break-blocks") ) + { + formatter.setBreakBlocksMode(true); + } + else if ( isOption(arg, "e", "break-elseifs") ) + { + formatter.setBreakElseIfsMode(true); + } + else if ( isOption(arg, "xb", "break-one-line-headers") ) + { + formatter.setBreakOneLineHeadersMode(true); + } + else if ( isOption(arg, "j", "add-braces") ) + { + formatter.setAddBracesMode(true); + } + else if ( isOption(arg, "J", "add-one-line-braces") ) + { + formatter.setAddOneLineBracesMode(true); + } + else if ( isOption(arg, "xj", "remove-braces") ) + { + formatter.setRemoveBracesMode(true); + } + else if ( isOption(arg, "Y", "indent-col1-comments") ) + { + formatter.setIndentCol1CommentsMode(true); + } + else if ( isOption(arg, "align-pointer=type") ) + { + formatter.setPointerAlignment(PTR_ALIGN_TYPE); + } + else if ( isOption(arg, "align-pointer=middle") ) + { + formatter.setPointerAlignment(PTR_ALIGN_MIDDLE); + } + else if ( isOption(arg, "align-pointer=name") ) + { + formatter.setPointerAlignment(PTR_ALIGN_NAME); + } + else if ( isParamOption(arg, "k") ) + { + int align = 0; + string styleParam = getParam(arg, "k"); + if (styleParam.length() > 0) + align = atoi(styleParam.c_str()); + if (align < 1 || align > 3) + isOptionError(arg, errorInfo); + else if (align == 1) + formatter.setPointerAlignment(PTR_ALIGN_TYPE); + else if (align == 2) + formatter.setPointerAlignment(PTR_ALIGN_MIDDLE); + else if (align == 3) + formatter.setPointerAlignment(PTR_ALIGN_NAME); + } + else if ( isOption(arg, "align-reference=none") ) + { + formatter.setReferenceAlignment(REF_ALIGN_NONE); + } + else if ( isOption(arg, "align-reference=type") ) + { + formatter.setReferenceAlignment(REF_ALIGN_TYPE); + } + else if ( isOption(arg, "align-reference=middle") ) + { + formatter.setReferenceAlignment(REF_ALIGN_MIDDLE); + } + else if ( isOption(arg, "align-reference=name") ) + { + formatter.setReferenceAlignment(REF_ALIGN_NAME); + } + else if ( isParamOption(arg, "W") ) + { + int align = 0; + string styleParam = getParam(arg, "W"); + if (styleParam.length() > 0) + align = atoi(styleParam.c_str()); + if (align < 0 || align > 3) + isOptionError(arg, errorInfo); + else if (align == 0) + formatter.setReferenceAlignment(REF_ALIGN_NONE); + else if (align == 1) + formatter.setReferenceAlignment(REF_ALIGN_TYPE); + else if (align == 2) + formatter.setReferenceAlignment(REF_ALIGN_MIDDLE); + else if (align == 3) + formatter.setReferenceAlignment(REF_ALIGN_NAME); + } + else if ( isParamOption(arg, "max-code-length=") ) + { + int maxLength = 50; + string maxLengthParam = getParam(arg, "max-code-length="); + if (maxLengthParam.length() > 0) + maxLength = atoi(maxLengthParam.c_str()); + if (maxLength < 50) + isOptionError(arg, errorInfo); + else if (maxLength > 200) + isOptionError(arg, errorInfo); + else + formatter.setMaxCodeLength(maxLength); + } + else if ( isParamOption(arg, "xC") ) + { + int maxLength = 50; + string maxLengthParam = getParam(arg, "xC"); + if (maxLengthParam.length() > 0) + maxLength = atoi(maxLengthParam.c_str()); + if (maxLength > 200) + isOptionError(arg, errorInfo); + else + formatter.setMaxCodeLength(maxLength); + } + else if ( isOption(arg, "xL", "break-after-logical") ) + { + formatter.setBreakAfterMode(true); + } + else if ( isOption(arg, "xc", "attach-classes") ) + { + formatter.setAttachClass(true); + } + else if ( isOption(arg, "xV", "attach-closing-while") ) + { + formatter.setAttachClosingWhile(true); + } + else if ( isOption(arg, "xk", "attach-extern-c") ) + { + formatter.setAttachExternC(true); + } + else if ( isOption(arg, "xn", "attach-namespaces") ) + { + formatter.setAttachNamespace(true); + } + else if ( isOption(arg, "xl", "attach-inlines") ) + { + formatter.setAttachInline(true); + } + else if ( isOption(arg, "xp", "remove-comment-prefix") ) + { + formatter.setStripCommentPrefix(true); + } + // Objective-C options + else if ( isOption(arg, "xQ", "pad-method-prefix") ) + { + formatter.setMethodPrefixPaddingMode(true); + } + else if ( isOption(arg, "xR", "unpad-method-prefix") ) + { + formatter.setMethodPrefixUnPaddingMode(true); + } + else if (isOption(arg, "xq", "pad-return-type")) + { + formatter.setReturnTypePaddingMode(true); + } + else if (isOption(arg, "xr", "unpad-return-type")) + { + formatter.setReturnTypeUnPaddingMode(true); + } + else if (isOption(arg, "xS", "pad-param-type")) + { + formatter.setParamTypePaddingMode(true); + } + else if (isOption(arg, "xs", "unpad-param-type")) + { + formatter.setParamTypeUnPaddingMode(true); + } + else if (isOption(arg, "xM", "align-method-colon")) + { + formatter.setAlignMethodColon(true); + } + else if ( isOption(arg, "xP0", "pad-method-colon=none") ) + { + formatter.setObjCColonPaddingMode(COLON_PAD_NONE); + } + else if ( isOption(arg, "xP1", "pad-method-colon=all") ) + { + formatter.setObjCColonPaddingMode(COLON_PAD_ALL); + } + else if ( isOption(arg, "xP2", "pad-method-colon=after") ) + { + formatter.setObjCColonPaddingMode(COLON_PAD_AFTER); + } + else if ( isOption(arg, "xP3", "pad-method-colon=before") ) + { + formatter.setObjCColonPaddingMode(COLON_PAD_BEFORE); + } + // depreciated options //////////////////////////////////////////////////////////////////////// + else if ( isOption(arg, "indent-preprocessor") ) // depreciated release 2.04 + { + formatter.setPreprocDefineIndent(true); + } + else if ( isOption(arg, "style=ansi") ) // depreciated release 2.05 + { + formatter.setFormattingStyle(STYLE_ALLMAN); + } + // depreciated in release 3.0 ///////////////////////////////////////////////////////////////// + else if ( isOption(arg, "break-closing-brackets") ) // depreciated release 3.0 + { + formatter.setBreakClosingHeaderBracketsMode(true); + } + else if ( isOption(arg, "add-brackets") ) // depreciated release 3.0 + { + formatter.setAddBracketsMode(true); + } + else if ( isOption(arg, "add-one-line-brackets") ) // depreciated release 3.0 + { + formatter.setAddOneLineBracketsMode(true); + } + else if ( isOption(arg, "remove-brackets") ) // depreciated release 3.0 + { + formatter.setRemoveBracketsMode(true); + } + else if ( isParamOption(arg, "max-instatement-indent=") ) // depreciated release 3.0 + { + int maxIndent = 40; + string maxIndentParam = getParam(arg, "max-instatement-indent="); + if (maxIndentParam.length() > 0) + maxIndent = atoi(maxIndentParam.c_str()); + if (maxIndent < 40) + isOptionError(arg, errorInfo); + else if (maxIndent > 120) + isOptionError(arg, errorInfo); + else + formatter.setMaxInStatementIndentLength(maxIndent); + } +// NOTE: Removed in release 2.04. +// else if ( isOption(arg, "b", "brackets=break") ) +// { +// formatter.setBracketFormatMode(BREAK_MODE); +// } +// else if ( isOption(arg, "a", "brackets=attach") ) +// { +// formatter.setBracketFormatMode(ATTACH_MODE); +// } +// else if ( isOption(arg, "l", "brackets=linux") ) +// { +// formatter.setBracketFormatMode(LINUX_MODE); +// } +// else if ( isOption(arg, "u", "brackets=stroustrup") ) +// { +// formatter.setBracketFormatMode(STROUSTRUP_MODE); +// } +// else if ( isOption(arg, "g", "brackets=run-in") ) +// { +// formatter.setBracketFormatMode(RUN_IN_MODE); +// } + // end depreciated options //////////////////////////////////////////////////////////////////// +#ifdef ASTYLE_LIB + // End of options used by GUI ///////////////////////////////////////////////////////////////// + else + isOptionError(arg, errorInfo); +#else + // Options used by only console /////////////////////////////////////////////////////////////// + else if ( isOption(arg, "n", "suffix=none") ) + { + console.setNoBackup(true); + } + else if ( isParamOption(arg, "suffix=") ) + { + string suffixParam = getParam(arg, "suffix="); + if (suffixParam.length() > 0) + { + console.setOrigSuffix(suffixParam); + } + } + else if ( isParamOption(arg, "exclude=") ) + { + string suffixParam = getParam(arg, "exclude="); + if (suffixParam.length() > 0) + console.updateExcludeVector(suffixParam); + } + else if ( isOption(arg, "r", "R") || isOption(arg, "recursive") ) + { + console.setIsRecursive(true); + } + else if (isOption(arg, "dry-run")) + { + console.setIsDryRun(true); + } + else if ( isOption(arg, "Z", "preserve-date") ) + { + console.setPreserveDate(true); + } + else if ( isOption(arg, "v", "verbose") ) + { + console.setIsVerbose(true); + } + else if ( isOption(arg, "Q", "formatted") ) + { + console.setIsFormattedOnly(true); + } + else if ( isOption(arg, "q", "quiet") ) + { + console.setIsQuiet(true); + } + else if ( isOption(arg, "i", "ignore-exclude-errors") ) + { + console.setIgnoreExcludeErrors(true); + } + else if ( isOption(arg, "xi", "ignore-exclude-errors-x") ) + { + console.setIgnoreExcludeErrorsAndDisplay(true); + } + else if ( isOption(arg, "X", "errors-to-stdout") ) + { + console.setErrorStream(&cout); + } + else if ( isOption(arg, "lineend=windows") ) + { + formatter.setLineEndFormat(LINEEND_WINDOWS); + } + else if ( isOption(arg, "lineend=linux") ) + { + formatter.setLineEndFormat(LINEEND_LINUX); + } + else if ( isOption(arg, "lineend=macold") ) + { + formatter.setLineEndFormat(LINEEND_MACOLD); + } + else if ( isParamOption(arg, "z") ) + { + int lineendType = 0; + string lineendParam = getParam(arg, "z"); + if (lineendParam.length() > 0) + lineendType = atoi(lineendParam.c_str()); + if (lineendType < 1 || lineendType > 3) + isOptionError(arg, errorInfo); + else if (lineendType == 1) + formatter.setLineEndFormat(LINEEND_WINDOWS); + else if (lineendType == 2) + formatter.setLineEndFormat(LINEEND_LINUX); + else if (lineendType == 3) + formatter.setLineEndFormat(LINEEND_MACOLD); + } + else if ( isParamOption(arg, "stdin=") ) + { + string path = getParam(arg, "stdin="); + console.standardizePath(path); + console.setStdPathIn(path); + } + else if ( isParamOption(arg, "stdout=") ) + { + string path = getParam(arg, "stdout="); + console.standardizePath(path); + console.setStdPathOut(path); + } + else + isOptionError(arg, errorInfo); +#endif +} // End of parseOption function + +// Parse options from the options file. +void ASOptions::importOptions(istream& in, vector& optionsVector) +{ + char ch; + bool isInQuote = false; + char quoteChar = ' '; + string currentToken; + + while (in) + { + currentToken = ""; + do + { + in.get(ch); + if (in.eof()) + break; + // treat '#' as line comments + if (ch == '#') + while (in) + { + in.get(ch); + if (ch == '\n' || ch == '\r') + break; + } + + // break options on new-lines, tabs, commas, or spaces + // remove quotes from output + if (in.eof() || ch == '\n' || ch == '\r' || ch == '\t' || ch == ',') + break; + if (ch == ' ' && !isInQuote) + break; + if (ch == quoteChar && isInQuote) + break; + if (ch == '"' || ch == '\'') + { + isInQuote = true; + quoteChar = ch; + continue; + } + currentToken.append(1, ch); + } + while (in); + + if (currentToken.length() != 0) + optionsVector.emplace_back(currentToken); + isInQuote = false; + } +} + +string ASOptions::getOptionErrors() const +{ + return optionErrors.str(); +} + +string ASOptions::getParam(const string& arg, const char* op) +{ + return arg.substr(strlen(op)); +} + +string ASOptions::getParam(const string& arg, const char* op1, const char* op2) +{ + return isParamOption(arg, op1) ? getParam(arg, op1) : getParam(arg, op2); +} + +bool ASOptions::isOption(const string& arg, const char* op) +{ + return arg.compare(op) == 0; +} + +bool ASOptions::isOption(const string& arg, const char* op1, const char* op2) +{ + return (isOption(arg, op1) || isOption(arg, op2)); +} + +void ASOptions::isOptionError(const string& arg, const string& errorInfo) +{ + if (optionErrors.str().length() == 0) + optionErrors << errorInfo << endl; // need main error message + optionErrors << arg << endl; +} + +bool ASOptions::isParamOption(const string& arg, const char* option) +{ + bool retVal = arg.compare(0, strlen(option), option) == 0; + // if comparing for short option, 2nd char of arg must be numeric + if (retVal && strlen(option) == 1 && arg.length() > 1) + if (!isdigit((unsigned char)arg[1])) + retVal = false; + return retVal; +} + +bool ASOptions::isParamOption(const string& arg, const char* option1, const char* option2) +{ + return isParamOption(arg, option1) || isParamOption(arg, option2); +} + +//---------------------------------------------------------------------------- +// ASEncoding class +//---------------------------------------------------------------------------- + +// Return true if an int is big endian. +bool ASEncoding::getBigEndian() const +{ + short int word = 0x0001; + char* byte = (char*) &word; + return (byte[0] ? false : true); +} + +// Swap the two low order bytes of a 16 bit integer value. +int ASEncoding::swap16bit(int value) const +{ + return ( ((value & 0xff) << 8) | ((value & 0xff00) >> 8) ); +} + +// Return the length of a utf-16 C string. +// The length is in number of utf16_t. +size_t ASEncoding::utf16len(const utf16* utf16In) const +{ + size_t length = 0; + while (*utf16In++ != '\0') + length++; + return length; +} + +// Adapted from SciTE UniConversion.cxx. +// Copyright 1998-2001 by Neil Hodgson +// Modified for Artistic Style by Jim Pattee. +// Compute the length of an output utf-8 file given a utf-16 file. +// Input inLen is the size in BYTES (not wchar_t). +size_t ASEncoding::utf8LengthFromUtf16(const char* utf16In, size_t inLen, bool isBigEndian) const +{ + size_t len = 0; + size_t wcharLen = inLen / 2; + const short* uptr = reinterpret_cast(utf16In); + for (size_t i = 0; i < wcharLen && uptr[i];) + { + size_t uch = isBigEndian ? swap16bit(uptr[i]) : uptr[i]; + if (uch < 0x80) + len++; + else if (uch < 0x800) + len += 2; + else if ((uch >= SURROGATE_LEAD_FIRST) && (uch <= SURROGATE_TRAIL_LAST)) + { + len += 4; + i++; + } + else + len += 3; + i++; + } + return len; +} + +// Adapted from SciTE Utf8_16.cxx. +// Copyright (C) 2002 Scott Kirkwood. +// Modified for Artistic Style by Jim Pattee. +// Convert a utf-8 file to utf-16. +size_t ASEncoding::utf8ToUtf16(char* utf8In, size_t inLen, bool isBigEndian, char* utf16Out) const +{ + int nCur = 0; + ubyte* pRead = reinterpret_cast(utf8In); + utf16* pCur = reinterpret_cast(utf16Out); + const ubyte* pEnd = pRead + inLen; + const utf16* pCurStart = pCur; + eState state = eStart; + + // the BOM will automatically be converted to utf-16 + while (pRead < pEnd) + { + switch (state) + { + case eStart: + if ((0xF0 & *pRead) == 0xF0) + { + nCur = (0x7 & *pRead) << 18; + state = eSecondOf4Bytes; + } + else if ((0xE0 & *pRead) == 0xE0) + { + nCur = (~0xE0 & *pRead) << 12; + state = ePenultimate; + } + else if ((0xC0 & *pRead) == 0xC0) + { + nCur = (~0xC0 & *pRead) << 6; + state = eFinal; + } + else + { + nCur = *pRead; + state = eStart; + } + break; + case eSecondOf4Bytes: + nCur |= (0x3F & *pRead) << 12; + state = ePenultimate; + break; + case ePenultimate: + nCur |= (0x3F & *pRead) << 6; + state = eFinal; + break; + case eFinal: + nCur |= (0x3F & *pRead); + state = eStart; + break; + // no default case is needed + } + ++pRead; + + if (state == eStart) + { + int codePoint = nCur; + if (codePoint >= SURROGATE_FIRST_VALUE) + { + codePoint -= SURROGATE_FIRST_VALUE; + int lead = (codePoint >> 10) + SURROGATE_LEAD_FIRST; + *pCur++ = static_cast(isBigEndian ? swap16bit(lead) : lead); + int trail = (codePoint & 0x3ff) + SURROGATE_TRAIL_FIRST; + *pCur++ = static_cast(isBigEndian ? swap16bit(trail) : trail); + } + else + *pCur++ = static_cast(isBigEndian ? swap16bit(codePoint) : codePoint); + } + } + // return value is the output length in BYTES (not wchar_t) + return (pCur - pCurStart) * 2; +} + +// Adapted from SciTE UniConversion.cxx. +// Copyright 1998-2001 by Neil Hodgson +// Modified for Artistic Style by Jim Pattee. +// Compute the length of an output utf-16 file given a utf-8 file. +// Return value is the size in BYTES (not wchar_t). +size_t ASEncoding::utf16LengthFromUtf8(const char* utf8In, size_t len) const +{ + size_t ulen = 0; + size_t charLen; + for (size_t i = 0; i < len;) + { + unsigned char ch = static_cast(utf8In[i]); + if (ch < 0x80) + charLen = 1; + else if (ch < 0x80 + 0x40 + 0x20) + charLen = 2; + else if (ch < 0x80 + 0x40 + 0x20 + 0x10) + charLen = 3; + else + { + charLen = 4; + ulen++; + } + i += charLen; + ulen++; + } + // return value is the length in bytes (not wchar_t) + return ulen * 2; +} + +// Adapted from SciTE Utf8_16.cxx. +// Copyright (C) 2002 Scott Kirkwood. +// Modified for Artistic Style by Jim Pattee. +// Convert a utf-16 file to utf-8. +size_t ASEncoding::utf16ToUtf8(char* utf16In, size_t inLen, bool isBigEndian, + bool firstBlock, char* utf8Out) const +{ + int nCur16 = 0; + int nCur = 0; + ubyte* pRead = reinterpret_cast(utf16In); + ubyte* pCur = reinterpret_cast(utf8Out); + const ubyte* pEnd = pRead + inLen; + const ubyte* pCurStart = pCur; + static eState state = eStart; // state is retained for subsequent blocks + if (firstBlock) + state = eStart; + + // the BOM will automatically be converted to utf-8 + while (pRead < pEnd) + { + switch (state) + { + case eStart: + if (pRead >= pEnd) + { + ++pRead; + break; + } + if (isBigEndian) + { + nCur16 = static_cast(*pRead++ << 8); + nCur16 |= static_cast(*pRead); + } + else + { + nCur16 = *pRead++; + nCur16 |= static_cast(*pRead << 8); + } + if (nCur16 >= SURROGATE_LEAD_FIRST && nCur16 <= SURROGATE_LEAD_LAST) + { + ++pRead; + int trail; + if (isBigEndian) + { + trail = static_cast(*pRead++ << 8); + trail |= static_cast(*pRead); + } + else + { + trail = *pRead++; + trail |= static_cast(*pRead << 8); + } + nCur16 = (((nCur16 & 0x3ff) << 10) | (trail & 0x3ff)) + SURROGATE_FIRST_VALUE; + } + ++pRead; + + if (nCur16 < 0x80) + { + nCur = static_cast(nCur16 & 0xFF); + state = eStart; + } + else if (nCur16 < 0x800) + { + nCur = static_cast(0xC0 | (nCur16 >> 6)); + state = eFinal; + } + else if (nCur16 < SURROGATE_FIRST_VALUE) + { + nCur = static_cast(0xE0 | (nCur16 >> 12)); + state = ePenultimate; + } + else + { + nCur = static_cast(0xF0 | (nCur16 >> 18)); + state = eSecondOf4Bytes; + } + break; + case eSecondOf4Bytes: + nCur = static_cast(0x80 | ((nCur16 >> 12) & 0x3F)); + state = ePenultimate; + break; + case ePenultimate: + nCur = static_cast(0x80 | ((nCur16 >> 6) & 0x3F)); + state = eFinal; + break; + case eFinal: + nCur = static_cast(0x80 | (nCur16 & 0x3F)); + state = eStart; + break; + // no default case is needed + } + *pCur++ = static_cast(nCur); + } + return pCur - pCurStart; +} + +//---------------------------------------------------------------------------- + +} // namespace astyle + +//---------------------------------------------------------------------------- + +using namespace astyle; + +//---------------------------------------------------------------------------- +// ASTYLE_JNI functions for Java library builds +//---------------------------------------------------------------------------- + +#ifdef ASTYLE_JNI + +// called by a java program to get the version number +// the function name is constructed from method names in the calling java program +extern "C" EXPORT +jstring STDCALL Java_AStyleInterface_AStyleGetVersion(JNIEnv* env, jclass) +{ + return env->NewStringUTF(g_version); +} + +// called by a java program to format the source code +// the function name is constructed from method names in the calling java program +extern "C" EXPORT +jstring STDCALL Java_AStyleInterface_AStyleMain(JNIEnv* env, + jobject obj, + jstring textInJava, + jstring optionsJava) +{ + g_env = env; // make object available globally + g_obj = obj; // make object available globally + + jstring textErr = env->NewStringUTF(""); // zero length text returned if an error occurs + + // get the method ID + jclass cls = env->GetObjectClass(obj); + g_mid = env->GetMethodID(cls, "ErrorHandler", "(ILjava/lang/String;)V"); + if (g_mid == nullptr) + { + cout << "Cannot find java method ErrorHandler" << endl; + return textErr; + } + + // convert jstring to char* + const char* textIn = env->GetStringUTFChars(textInJava, nullptr); + const char* options = env->GetStringUTFChars(optionsJava, nullptr); + + // call the C++ formatting function + char* textOut = AStyleMain(textIn, options, javaErrorHandler, javaMemoryAlloc); + // if an error message occurred it was displayed by errorHandler + if (textOut == nullptr) + return textErr; + + // release memory + jstring textOutJava = env->NewStringUTF(textOut); + delete[] textOut; + env->ReleaseStringUTFChars(textInJava, textIn); + env->ReleaseStringUTFChars(optionsJava, options); + + return textOutJava; +} + +// Call the Java error handler +void STDCALL javaErrorHandler(int errorNumber, const char* errorMessage) +{ + jstring errorMessageJava = g_env->NewStringUTF(errorMessage); + g_env->CallVoidMethod(g_obj, g_mid, errorNumber, errorMessageJava); +} + +// Allocate memory for the formatted text +char* STDCALL javaMemoryAlloc(unsigned long memoryNeeded) +{ + // error condition is checked after return from AStyleMain + char* buffer = new (nothrow) char[memoryNeeded]; + return buffer; +} + +#endif // ASTYLE_JNI + +//---------------------------------------------------------------------------- +// ASTYLE_LIB functions for library builds +//---------------------------------------------------------------------------- + +#ifdef ASTYLE_LIB + +//---------------------------------------------------------------------------- +// ASTYLE_LIB entry point for AStyleMainUtf16 library builds +//---------------------------------------------------------------------------- +/* +* IMPORTANT Visual C DLL linker for WIN32 must have the additional options: +* /EXPORT:AStyleMain=_AStyleMain@16 +* /EXPORT:AStyleMainUtf16=_AStyleMainUtf16@16 +* /EXPORT:AStyleGetVersion=_AStyleGetVersion@0 +* No /EXPORT is required for x64 +*/ +extern "C" EXPORT utf16_t* STDCALL AStyleMainUtf16(const utf16_t* pSourceIn, // the source to be formatted + const utf16_t* pOptions, // AStyle options + fpError fpErrorHandler, // error handler function + fpAlloc fpMemoryAlloc) // memory allocation function +{ + if (fpErrorHandler == nullptr) // cannot display a message if no error handler + return nullptr; + + if (pSourceIn == nullptr) + { + fpErrorHandler(101, "No pointer to source input."); + return nullptr; + } + if (pOptions == nullptr) + { + fpErrorHandler(102, "No pointer to AStyle options."); + return nullptr; + } + if (fpMemoryAlloc == nullptr) + { + fpErrorHandler(103, "No pointer to memory allocation function."); + return nullptr; + } +#ifndef _WIN32 + // check size of utf16_t on Linux + int sizeCheck = 2; + if (sizeof(utf16_t) != sizeCheck) + { + fpErrorHandler(104, "Unsigned short is not the correct size."); + return nullptr; + } +#endif + + ASLibrary library; + utf16_t* utf16Out = library.formatUtf16(pSourceIn, pOptions, fpErrorHandler, fpMemoryAlloc); + return utf16Out; +} + +//---------------------------------------------------------------------------- +// ASTYLE_LIB entry point for library builds +//---------------------------------------------------------------------------- +/* + * IMPORTANT Visual C DLL linker for WIN32 must have the additional options: + * /EXPORT:AStyleMain=_AStyleMain@16 + * /EXPORT:AStyleMainUtf16=_AStyleMainUtf16@16 + * /EXPORT:AStyleGetVersion=_AStyleGetVersion@0 + * No /EXPORT is required for x64 + */ +extern "C" EXPORT char* STDCALL AStyleMain(const char* pSourceIn, // the source to be formatted + const char* pOptions, // AStyle options + fpError fpErrorHandler, // error handler function + fpAlloc fpMemoryAlloc) // memory allocation function +{ + if (fpErrorHandler == nullptr) // cannot display a message if no error handler + return nullptr; + + if (pSourceIn == nullptr) + { + fpErrorHandler(101, "No pointer to source input."); + return nullptr; + } + if (pOptions == nullptr) + { + fpErrorHandler(102, "No pointer to AStyle options."); + return nullptr; + } + if (fpMemoryAlloc == nullptr) + { + fpErrorHandler(103, "No pointer to memory allocation function."); + return nullptr; + } + + ASFormatter formatter; + ASOptions options(formatter); + + vector optionsVector; + istringstream opt(pOptions); + + options.importOptions(opt, optionsVector); + + bool ok = options.parseOptions(optionsVector, "Invalid Artistic Style options:"); + if (!ok) + fpErrorHandler(130, options.getOptionErrors().c_str()); + + istringstream in(pSourceIn); + ASStreamIterator streamIterator(&in); + ostringstream out; + formatter.init(&streamIterator); + + while (formatter.hasMoreLines()) + { + out << formatter.nextLine(); + if (formatter.hasMoreLines()) + out << streamIterator.getOutputEOL(); + else + { + // this can happen if the file if missing a closing brace and break-blocks is requested + if (formatter.getIsLineReady()) + { + out << streamIterator.getOutputEOL(); + out << formatter.nextLine(); + } + } + } + + size_t textSizeOut = out.str().length(); + char* pTextOut = fpMemoryAlloc((long)textSizeOut + 1); // call memory allocation function + if (pTextOut == nullptr) + { + fpErrorHandler(120, "Allocation failure on output."); + return nullptr; + } + + strcpy(pTextOut, out.str().c_str()); +#ifndef NDEBUG + // The checksum is an assert in the console build and ASFormatter. + // This error returns the incorrectly formatted file to the editor. + // This is done to allow the file to be saved for debugging purposes. + if (formatter.getChecksumDiff() != 0) + fpErrorHandler(220, + "Checksum error.\n" + "The incorrectly formatted file will be returned for debugging."); +#endif + return pTextOut; +} + +extern "C" EXPORT const char* STDCALL AStyleGetVersion(void) +{ + return g_version; +} + +// ASTYLECON_LIB is defined to exclude "main" from the test programs +#elif !defined(ASTYLECON_LIB) + +//---------------------------------------------------------------------------- +// main function for ASConsole build +//---------------------------------------------------------------------------- + +int main(int argc, char** argv) +{ + // create objects + ASFormatter formatter; + auto console = make_shared(formatter); + + // process command line and options file + // build the vectors fileNameVector, optionsVector, and fileOptionsVector + vector argvOptions; + argvOptions = console->getArgvOptions(argc, argv); + console->processOptions(argvOptions); + + // if no files have been given, use cin for input and cout for output + if (!console->fileNameVectorIsEmpty()) + console->processFiles(); + else + console->formatCinToCout(); + + return EXIT_SUCCESS; +} + +#endif // ASTYLE_LIB diff --git a/thirdparty/astyle/astyle_main.h b/thirdparty/astyle/astyle_main.h new file mode 100755 index 00000000..057bd91d --- /dev/null +++ b/thirdparty/astyle/astyle_main.h @@ -0,0 +1,443 @@ +// astyle_main.h +// Copyright (c) 2017 by Jim Pattee . +// This code is licensed under the MIT License. +// License.md describes the conditions under which this software may be distributed. + +#ifndef ASTYLE_MAIN_H +#define ASTYLE_MAIN_H + +//---------------------------------------------------------------------------- +// headers +//---------------------------------------------------------------------------- + +#include "astyle.h" + +#include +#include + +#if defined(__BORLANDC__) && __BORLANDC__ < 0x0650 + // Embarcadero needs this for the following utime.h + // otherwise "struct utimbuf" gets an error on time_t + // 0x0650 for C++Builder XE3 + using std::time_t; +#endif + +#if defined(_MSC_VER) + #include + #include +#else + #include + #include +#endif // end compiler checks + +#ifdef ASTYLE_JNI + #include + #ifndef ASTYLE_LIB // ASTYLE_LIB must be defined for ASTYLE_JNI + #define ASTYLE_LIB + #endif +#endif // ASTYLE_JNI + +#ifndef ASTYLE_LIB + // for console build only + #include "ASLocalizer.h" + #define _(a) localizer.settext(a) +#endif // ASTYLE_LIB + +//----------------------------------------------------------------------------- +// declarations +//----------------------------------------------------------------------------- + +// for G++ implementation of string.compare: +#if defined(__GNUC__) && __GNUC__ < 3 + #error - Use GNU C compiler release 3 or higher +#endif + +// for getenv and localtime +#if defined(_MSC_VER) + #pragma warning(disable: 4996) // secure version deprecation warnings +#endif + +// for namespace problem in version 5.0 +#if defined(_MSC_VER) && _MSC_VER < 1200 // check for V6.0 + #error - Use Microsoft compiler version 6 or higher +#endif + +#ifdef __clang__ + #pragma clang diagnostic ignored "-Wdeprecated-declarations" // getenv, localtime + #pragma clang diagnostic ignored "-Wmissing-braces" +#endif + +// for mingw BOM, UTF-16, and Unicode functions +#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) + #if (__MINGW32_MAJOR_VERSION > 3) || \ + ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION < 16)) + #error - Use MinGW compiler version 4 or higher + #endif +#endif + +#ifdef ASTYLE_LIB + + // define STDCALL and EXPORT for Windows + // MINGW defines STDCALL in Windows.h (actually windef.h) + // EXPORT has no value if ASTYLE_NO_EXPORT is defined + #ifdef _WIN32 + #ifndef STDCALL + #define STDCALL __stdcall + #endif + // define this to prevent compiler warning and error messages + #ifdef ASTYLE_NO_EXPORT + #define EXPORT + #else + #define EXPORT __declspec(dllexport) + #endif + // define STDCALL and EXPORT for non-Windows + // visibility attribute allows "-fvisibility=hidden" compiler option + #else + #define STDCALL + #if __GNUC__ >= 4 + #define EXPORT __attribute__ ((visibility ("default"))) + #else + #define EXPORT + #endif + #endif // #ifdef _WIN32 + + // define utf-16 bit text for the platform + typedef unsigned short utf16_t; + // define pointers to callback error handler and memory allocation + typedef void (STDCALL* fpError)(int errorNumber, const char* errorMessage); + typedef char* (STDCALL* fpAlloc)(unsigned long memoryNeeded); + +#endif // #ifdef ASTYLE_LIB + +//---------------------------------------------------------------------------- +// astyle namespace +//---------------------------------------------------------------------------- + +namespace astyle { +// +//---------------------------------------------------------------------------- +// ASStreamIterator class +// typename will be istringstream for GUI and istream otherwise +// ASSourceIterator is an abstract class defined in astyle.h +//---------------------------------------------------------------------------- + +template +class ASStreamIterator : public ASSourceIterator +{ +public: + bool checkForEmptyLine; + + // function declarations + explicit ASStreamIterator(T* in); + virtual ~ASStreamIterator(); + bool getLineEndChange(int lineEndFormat) const; + int getStreamLength() const; + string nextLine(bool emptyLineWasDeleted); + string peekNextLine(); + void peekReset(); + void saveLastInputLine(); + streamoff tellg(); + +private: + ASStreamIterator(const ASStreamIterator& copy); // copy constructor not to be implemented + ASStreamIterator& operator=(ASStreamIterator&); // assignment operator not to be implemented + T* inStream; // pointer to the input stream + string buffer; // current input line + string prevBuffer; // previous input line + string outputEOL; // next output end of line char + int eolWindows; // number of Windows line endings, CRLF + int eolLinux; // number of Linux line endings, LF + int eolMacOld; // number of old Mac line endings. CR + streamoff streamLength; // length of the input file stream + streamoff peekStart; // starting position for peekNextLine + bool prevLineDeleted; // the previous input line was deleted + +public: // inline functions + bool compareToInputBuffer(const string& nextLine_) const + { return (nextLine_ == prevBuffer); } + const string& getOutputEOL() const { return outputEOL; } + bool hasMoreLines() const { return !inStream->eof(); } +}; + +//---------------------------------------------------------------------------- +// ASEncoding class for utf8/16 conversions +// used by both console and library builds +//---------------------------------------------------------------------------- + +class ASEncoding +{ +private: + typedef unsigned short utf16; // 16 bits + typedef unsigned char utf8; // 8 bits + typedef unsigned char ubyte; // 8 bits + enum { SURROGATE_LEAD_FIRST = 0xD800 }; + enum { SURROGATE_LEAD_LAST = 0xDBFF }; + enum { SURROGATE_TRAIL_FIRST = 0xDC00 }; + enum { SURROGATE_TRAIL_LAST = 0xDFFF }; + enum { SURROGATE_FIRST_VALUE = 0x10000 }; + enum eState { eStart, eSecondOf4Bytes, ePenultimate, eFinal }; + +public: + bool getBigEndian() const; + int swap16bit(int value) const; + size_t utf16len(const utf16* utf16In) const; + size_t utf8LengthFromUtf16(const char* utf16In, size_t inLen, bool isBigEndian) const; + size_t utf8ToUtf16(char* utf8In, size_t inLen, bool isBigEndian, char* utf16Out) const; + size_t utf16LengthFromUtf8(const char* utf8In, size_t len) const; + size_t utf16ToUtf8(char* utf16In, size_t inLen, bool isBigEndian, + bool firstBlock, char* utf8Out) const; +}; + +//---------------------------------------------------------------------------- +// ASOptions class for options processing +// used by both console and library builds +//---------------------------------------------------------------------------- +class ASConsole; + +class ASOptions +{ +public: +#ifdef ASTYLE_LIB + ASOptions(ASFormatter& formatterArg); +#else + ASOptions(ASFormatter& formatterArg, ASConsole& consoleArg); +#endif + string getOptionErrors() const; + void importOptions(istream& in, vector& optionsVector); + bool parseOptions(vector& optionsVector, const string& errorInfo); + +private: + // variables + ASFormatter& formatter; + stringstream optionErrors; // option error messages +#ifndef ASTYLE_LIB + ASConsole& console; // DO NOT USE for ASTYLE_LIB +#endif + + // functions + ASOptions(const ASOptions&); // copy constructor not to be implemented + ASOptions& operator=(ASOptions&); // assignment operator not to be implemented + string getParam(const string& arg, const char* op); + string getParam(const string& arg, const char* op1, const char* op2); + bool isOption(const string& arg, const char* op); + bool isOption(const string& arg, const char* op1, const char* op2); + void isOptionError(const string& arg, const string& errorInfo); + bool isParamOption(const string& arg, const char* option); + bool isParamOption(const string& arg, const char* option1, const char* option2); + void parseOption(const string& arg, const string& errorInfo); +}; + +#ifndef ASTYLE_LIB + +//---------------------------------------------------------------------------- +// ASConsole class for console build +//---------------------------------------------------------------------------- + +class ASConsole +{ +private: // variables + ASFormatter& formatter; // reference to the ASFormatter object + ASLocalizer localizer; // ASLocalizer object + ostream* errorStream; // direct error messages to cerr or cout + // command line options + bool isRecursive; // recursive option + bool isDryRun; // dry-run option + bool noBackup; // suffix=none option + bool preserveDate; // preserve-date option + bool isVerbose; // verbose option + bool isQuiet; // quiet option + bool isFormattedOnly; // formatted lines only option + bool ignoreExcludeErrors; // don't abort on unmatched excludes + bool ignoreExcludeErrorsDisplay; // don't display unmatched excludes + bool optionsFileRequired; // options= option + bool useAscii; // ascii option + // other variables + bool bypassBrowserOpen; // don't open the browser on html options + bool hasWildcard; // file name includes a wildcard + size_t mainDirectoryLength; // directory length to be excluded in displays + bool filesAreIdentical; // input and output files are identical + int filesFormatted; // number of files formatted + int filesUnchanged; // number of files unchanged + bool lineEndsMixed; // output has mixed line ends + int linesOut; // number of output lines + + ASEncoding utf8_16; // utf8/16 conversion methods + + string outputEOL; // current line end + string prevEOL; // previous line end + string optionsFileName; // file path and name of the options file to use + string origSuffix; // suffix= option + string stdPathIn; // path to input from stdin= + string stdPathOut; // path to output from stdout= + string targetDirectory; // path to the directory being processed + string targetFilename; // file name being processed + + vector excludeVector; // exclude from wildcard hits + vector excludeHitsVector; // exclude flags for error reporting + vector fileNameVector; // file paths and names from the command line + vector optionsVector; // options from the command line + vector fileOptionsVector; // options from the options file + vector fileName; // files to be processed including path + +public: // functions + explicit ASConsole(ASFormatter& formatterArg); + ~ASConsole(); + void convertLineEnds(ostringstream& out, int lineEnd); + FileEncoding detectEncoding(const char* data, size_t dataSize) const; + void error() const; + void error(const char* why, const char* what) const; + void formatCinToCout(); + vector getArgvOptions(int argc, char** argv) const; + bool fileNameVectorIsEmpty() const; + ostream* getErrorStream() const; + bool getFilesAreIdentical() const; + int getFilesFormatted() const; + bool getIgnoreExcludeErrors() const; + bool getIgnoreExcludeErrorsDisplay() const; + bool getIsDryRun() const; + bool getIsFormattedOnly() const; + bool getIsQuiet() const; + bool getIsRecursive() const; + bool getIsVerbose() const; + bool getLineEndsMixed() const; + bool getNoBackup() const; + bool getPreserveDate() const; + string getLanguageID() const; + string getNumberFormat(int num, size_t lcid = 0) const; + string getNumberFormat(int num, const char* groupingArg, const char* separator) const; + string getOptionsFileName() const; + string getOrigSuffix() const; + string getStdPathIn() const; + string getStdPathOut() const; + void processFiles(); + void processOptions(const vector& argvOptions); + void setBypassBrowserOpen(bool state); + void setErrorStream(ostream* errStreamPtr); + void setIgnoreExcludeErrors(bool state); + void setIgnoreExcludeErrorsAndDisplay(bool state); + void setIsDryRun(bool state); + void setIsFormattedOnly(bool state); + void setIsQuiet(bool state); + void setIsRecursive(bool state); + void setIsVerbose(bool state); + void setNoBackup(bool state); + void setOptionsFileName(const string& name); + void setOrigSuffix(const string& suffix); + void setPreserveDate(bool state); + void setStdPathIn(const string& path); + void setStdPathOut(const string& path); + void standardizePath(string& path, bool removeBeginningSeparator = false) const; + bool stringEndsWith(const string& str, const string& suffix) const; + void updateExcludeVector(const string& suffixParam); + vector getExcludeVector() const; + vector getExcludeHitsVector() const; + vector getFileNameVector() const; + vector getOptionsVector() const; + vector getFileOptionsVector() const; + vector getFileName() const; + +private: // functions + ASConsole(const ASConsole&); // copy constructor not to be implemented + ASConsole& operator=(ASConsole&); // assignment operator not to be implemented + void correctMixedLineEnds(ostringstream& out); + void formatFile(const string& fileName_); + string getCurrentDirectory(const string& fileName_) const; + void getFileNames(const string& directory, const string& wildcard); + void getFilePaths(const string& filePath); + string getParam(const string& arg, const char* op); + void initializeOutputEOL(LineEndFormat lineEndFormat); + bool isOption(const string& arg, const char* op); + bool isOption(const string& arg, const char* a, const char* b); + bool isParamOption(const string& arg, const char* option); + bool isPathExclued(const string& subPath); + void launchDefaultBrowser(const char* filePathIn = nullptr) const; + void printHelp() const; + void printMsg(const char* msg, const string& data) const; + void printSeparatingLine() const; + void printVerboseHeader() const; + void printVerboseStats(clock_t startTime) const; + FileEncoding readFile(const string& fileName_, stringstream& in) const; + void removeFile(const char* fileName_, const char* errMsg) const; + void renameFile(const char* oldFileName, const char* newFileName, const char* errMsg) const; + void setOutputEOL(LineEndFormat lineEndFormat, const string& currentEOL); + void sleep(int seconds) const; + int waitForRemove(const char* newFileName) const; + int wildcmp(const char* wild, const char* data) const; + void writeFile(const string& fileName_, FileEncoding encoding, ostringstream& out) const; +#ifdef _WIN32 + void displayLastError(); +#endif +}; +#else // ASTYLE_LIB + +//---------------------------------------------------------------------------- +// ASLibrary class for library build +//---------------------------------------------------------------------------- + +class ASLibrary +{ +public: + ASLibrary() {} + virtual ~ASLibrary() {} + // virtual functions are mocked in testing + utf16_t* formatUtf16(const utf16_t*, const utf16_t*, fpError, fpAlloc) const; + virtual utf16_t* convertUtf8ToUtf16(const char* utf8In, fpAlloc fpMemoryAlloc) const; + virtual char* convertUtf16ToUtf8(const utf16_t* utf16In) const; + +private: + static char* STDCALL tempMemoryAllocation(unsigned long memoryNeeded); + +private: + ASEncoding utf8_16; // utf8/16 conversion methods +}; + +#endif // ASTYLE_LIB + +//---------------------------------------------------------------------------- + +} // end of namespace astyle + +//---------------------------------------------------------------------------- +// declarations for java native interface (JNI) build +// they are called externally and are NOT part of the namespace +//---------------------------------------------------------------------------- +#ifdef ASTYLE_JNI +void STDCALL javaErrorHandler(int errorNumber, const char* errorMessage); +char* STDCALL javaMemoryAlloc(unsigned long memoryNeeded); +// the following function names are constructed from method names in the calling java program +extern "C" EXPORT +jstring STDCALL Java_AStyleInterface_AStyleGetVersion(JNIEnv* env, jclass); +extern "C" EXPORT +jstring STDCALL Java_AStyleInterface_AStyleMain(JNIEnv* env, + jobject obj, + jstring textInJava, + jstring optionsJava); +#endif // ASTYLE_JNI + +//---------------------------------------------------------------------------- +// declarations for UTF-16 interface +// they are called externally and are NOT part of the namespace +//---------------------------------------------------------------------------- +#ifdef ASTYLE_LIB +extern "C" EXPORT +utf16_t* STDCALL AStyleMainUtf16(const utf16_t* pSourceIn, + const utf16_t* pOptions, + fpError fpErrorHandler, + fpAlloc fpMemoryAlloc); +#endif // ASTYLE_LIB + +//----------------------------------------------------------------------------- +// declarations for standard DLL interface +// they are called externally and are NOT part of the namespace +//----------------------------------------------------------------------------- +#ifdef ASTYLE_LIB +extern "C" EXPORT char* STDCALL AStyleMain(const char* pSourceIn, + const char* pOptions, + fpError fpErrorHandler, + fpAlloc fpMemoryAlloc); +extern "C" EXPORT const char* STDCALL AStyleGetVersion(void); +#endif // ASTYLE_LIB + +//----------------------------------------------------------------------------- + +#endif // closes ASTYLE_MAIN_H diff --git a/thirdparty/astyle/scripts/opjstyle b/thirdparty/astyle/scripts/opjstyle new file mode 100755 index 0000000000000000000000000000000000000000..921a91c53ae83869aafb6d9d69d267945927f247 GIT binary patch literal 2404824 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

6N0;(?}W%k3=OW;=kmw`&)Do_Pn1MsK@ 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

)p}O@?PIatd_(7-+?$I$F7I*-NEf&#n{RP` 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 z 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�_^oO-yQIB^zWCf@hm@a*X1 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 _Iv)jO-2i?ckB)QH55Ix8JYY@7D~Q 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%0DGw5I%4@&xTv zzKC^4S;S2JH$)Awdb&yTbch-@l6{)nL%eK-^OP>+(!G0*gkIgP#UGnA2x=Q%>`Kbh z9PiKrSVw>8JkL7HTf$835DkKx2`@x&hryrE9il-EnO8=lxRK=@Mj0VqE~BM-MWU;` zeJuWw45j{J-&4*#CH_9Qzu{fq@K(U99ik`TP{Iol++n1=Pi)A%G7`mutq~!`k$Aa` zcsH`VlkMUC45hpU@D?0zJZ${T=UgyZecZzcJCgbS6oh?&|U>ScH#LcEyaczX%2jL`2( zSmC0?gUg8bDT%Y@p@-$&*YJj*Smb!8?91z<`Tc`+l(&SL+98?*hZ27wg8ZhulQv*~ zWh9CZx4hFN9$ZGe>sa1#_V8AQQh%}kEDw8H^1Hf+;XTOkR=}$rqUCTX;pI&%~x%|}MCHC+uhEm=FcqcgCo|gAcE>wT>n5iA2?uHj4$S+)wZgq6&Rj;k_eq?Ux1;6lWOxHm#Ey5uKE~hgSx0$`n5iA2o8VC5FGP^v zl=r6f*?6IJ$v{*Ln$xr1Ip7JZx_pZEf=c474T|@sJ-EZ z2=QWu%R_tNm60g^!U`9Jm&=Iv7KyX^+tTuGYj_Lb%}*EC#_VnU{g`!>H;Tdvw366JBcf-5A;VojO zc8K1ALkTZLkl&Q|opqU4Mxyv~YeYrj!DYm|i{*XQ9=^s<${T`Wwc~ATc`xEZ^|yqX z+9BG?@InOnO?kHxUKxqvcdc*-;pH;oy+STO^><^-yNTh&{aCp)L-H`9oALK8)=}OH zc(p@x7FIOz7b3`S%6nE__E$!tcx%fWNIbZVco#^VmG=aTe>3S4QafWvvnOB_3QxyxUmbr|sc045hpQC<4dZ)bgIn zh3an+Gqpq1(C|V8`AvBn3a^Yr@yk{?FT7kvyywW}r~cNmytNH)2#VE?cj#Wm-{)CJ zc}tk79il;4(ZpYfAipW^pxW%OjL`nq@(z=Da2fHwB5_vUJ{JE-hEjiVUtI3}tmNUj zJq_>rhPMJVbS>DO^@P39;-U4{1INo}e z_ZTizfAg5B9ip{xDB*<&@{1R@|6PZ9WrX&>R=Bb7avAX+FPESC`?Ed#We=FBya6cc zJtzM5=eN@RFBd9r5i_+z)XVTf1o=&QdkL?M(Eis77bPBCM!Zi+oRznS<=xlthM*`p z-YH#79{yk*bfyvzSt3tkza{jW75C%jxnyhq68r~WRn zhhH(2@)p2ba=bk)@10zz{^l`LJ4D?LFGP@Eytw_Z@X847f30wDi8GfG?|l+yihp6W)G57A>jk(KML}817)eg}uut&|U*&!OgmYqcbIz;X?q*yVp zx70Tv_0g@~T0S8G3-}2FUC-p8PD#$6KEcx=s^d{BidyK@p7N-5gIcyjG?U!Z4_3B~ zMJ>m7hxGej9<>!T=IIa(^{Blr3r;_Sc>SAr)b4{?_OHw}^Qc`QYJpRWXjK(oeZ%*i zr$aP%*L13$Xg$?;uD6z}L!dzQvL9ik2%HOYI@A^MD> zSo2Izg<7^lw4_ryRnN4$umz6oW{+BPsAW4u<2`CC<(dnf+CCn&c{Jwf5FOxAn=EQM z-VM|5KT-T@p6TUK%XWxXcTA`1nf4X6f>V3YqqYmwvK^wS9<_BvEpTc_d(^(7F;9o+ zIFH(Mw9fP`6FRl^J!-c>E&KlvHT0;RCTcm}g+=iT6y}<~9SF5-hbY`7ovOaI5Ve9+ zJJX}~2aS0;M8iF5@6bBanFda6YmeHaP|N<6xmF&vK-5B~wxH@qpkDO@p_c6sE$omz z(~hE+<8OcZ{U487BdBFNL}NT^U(?FanHHSdZXUH)Xw1_g+S8+UyQl?D?K_HJ%{4t2 zYS|9avYpeZx~4rvEp%#kdemA&E!!cQXbxp5@TDC(}%cC}k)np&>v`4BtV5>VsFSXCwwS|cA*Zr9ukw0*WxIF}IWqRzH zbckN2cjEde|8E_l7xthIQKkD~xkSD(Ijuh2vJ;Hg9VPY*<)JUgChfO&ye7Kf2ZHd% zWRr%O+96s7I^6(yIz-D>$v(~PA@1SNOm1D)lIOUd-Mfd&C8U5Ad-x?oDKB;<8z$M_gNOC$fT*m;@lO z_*XEL`da{Rmlq`u-|k>|I~(3SW@?9MF&s+r01@0_@aMC?i+^Tb8HwT>tr5#59$ZHL z?rnMJ+rtG6rMv+shC1HeE$=m4sQwl)Q#(ZM3@=287c-o{?SxlG==UY8aChP5GUB}% zinLvtGqpoB5-Xbc3lZcuM!=6<>E_{hlOno?{w=Ud5aeRc!pAcLr^p>OCH{AV|X_=yd})ke?#;l97=d0g8ZhuFD{q- z@<d@*zd6ghj^QnUH~+Hudva^z@3X9M5q;{(k%G2gxswMDgQRxS{ZJ8SxI5%TN7XX%Bze7A7h$?#Id%$9ojNm29IP=0fGI zfLA+2hZY_*%+wCiGB}j*LIn9`I?ltg?|#CxyAS^e!`d3Q0qxGyeO9PjOU zL<}p({M2q22!V3}P7cY|E#otMOd4%@A)`;a24=y9#y)Ey2d$@q1ls5py zSjW4&<-LXr)!!m!YKN$u;e`nD%XFNFcET$owEwlj-G!ISi1%i>{M6sP<=w{chM;Kt zy7)VKE937+tfRao%+wCiNUUh$FGP^vly~H}?5~W_{@3!}B=O)f;{8J6th~c4{y7Y# z{^I#Wd4l6zxTWFU&hS>is~w`ba46yBha8mOly~kol3yO7{jW9RbBTvO8`;_NhW79k zhEiTU0V&seL;P)Hc`xKb^*4{1+97ITcp-xP;>GQMg;z#s|7(TY3onXQio`YgT1JQF?SA&C~Oh1+95g{%c<|tAnw>=fIz-!A(yKTa@?>X`q*yUe zwbZ9EjJHI@uK*|=qO0vWf6FnD|A%N#OZPS% z{>u(g2NKoCeEKNo1_@Z;o)>&Z4(gQT{OJ=s9ik<4zB*Oax{I1V54qW+)*Nct4$*jz z+DciXoVyp?$D=ln#ylOO13YSzMXlh}exY?xd_B|4p_c6st!|c1)idoYYJpRG(4&U$ zJ5Psbsz+^IQ45{g(H^z0Xw1_gI?ki^oP;Om?wQv2sNDv&?Egd5(4!`KPdY>|(1lXd zw*#S;?GS}qq*K+m7Qzm>uqeLMqt+T~*$&YpkJ=hq89LK~Q#-_? z_7RPFIz+uaYLAIp;MD%E`VpvC{k2fbc8F?u)CP%K=+vI{sO<%{Y=>z2W?A1Fi(1Zo z*B|du`;o>x9io#xYOm5d!#Ah4iAU{TsAd1kTvLzQd7>6LwKuAMpsH_2KrP!Ln$skE zrfozmbZQrR)M`U5+aVh1QCmbSLuZ>0|_-0tUtjqz6U1fn$v{T-q?a7Z^mo(|ERPh_9w zb|jbZXC}gnX$9$XbicBbTtd1~WqbHCLn$wICFPZlx0U5Rp9^(US;9>15H&Nr5WyV= z)A1cqGvSqyD1O@tw-a72qoul3E(GOmXn7kM-W=@)${ixvU7oj*@%IhZQQiu8wL^3o zRzL9wSun5iA2`i2)G#ETiu-}=HUBlP@2|7iphl{W-M$@x2k z-%2iv8C#ml5wv5@*drFUxzl;l=*5 zoS!ZEo!-#op|0VrfLA+2Q{hm;%bQrrZ^}D$q2!lGqWD;A#ETLSE+gIzE$<|IcrQb# zzXkC2cD!{gZ$B5pPL;S8ZT;_cy#1@M?!>DI7|8Aws;E;qtKbeaWxmz1te` zm&Ak1i1#qd`?)>*f}xbR0N&M(cR$N}8yBj-dCb%f(Vm7EBFHaZB)@wKuZ%?T4_5e4 z;pH;oy+`7#{gUg7wo8^7S9=^*^%8UE4a=p32yQ}5BnhVw63V5|cw1eS=2=bfq?jXD} z62+fd;jY5VWyE`&0(tfRbn%+wCi#aPkAUx*;Tc#-^G zJfHoQ5&C^u%X@>wgUg8bGl{eEo@MdRW+?SH07cVz;_nCR8Q#{0w}_eAA({h+5?+WP zzbWsWcO}0(62+HTBNj_MxQuvrvb<$`_%cH&ZwQJhj<=QNJ)aBJ-x6kOhp3t1g$VM? zbh7^yUKyeNuN7`5yj(`Sm&)a*{x-C{jSMgDi_4AQ5r5BH*ZBJe>nLvpyxJi;4J(@X z3lZcu13|mMac( z+Bzl!>r`V_b%-8;C2DBD>JHJ9Z^26G5S?hx`E`zgJThu(=^mlOf7u~wNTT{6SfB2m zCIJiF^MV)1L7kGEKYfCyLln~a>Qq&0A!_Kf3uqk_U(a+P)Uq9-g+!oJ^-Md8THw^K^r+$c&eI_p<5BxsmOFH6 zyLr@Jp)pT~XityY?V^@*_aNUx5lDYaB9bU)PAHfPlxDakJ_uW&UiBF)Hd;`-3ztsUzuy_Q9Do6LZ|iyg}J70 zM?fvxA)51d_DtJ|T8?*NQGB6Ctv1xM9iovQwMDctbfyKTw!KGf290?-MD0Cl*NIx- z)IP2H5jfcW%sT~Y*$z?Vuk4w26}8Z*-RM!<0&3X~(KwIVa#|TYjdkDkdwbO0rZG>4 zXg`lyNz@8X?I(&~%{9FgYS|9aZ+~Xbw2!C-PVIh=+RjkRc8I2U)ar;@=+ydo)V`!K zPlsrLM{OppGkkO3DNQ5!01x<`4w>IbSOWPhk-J4EF*S>Kwmn(QOa z@<^@0SapZ!B9F+2w7j$v;11FD9+4R|rh5q5%B-!MbcimYcj7lu{@*%87n0Ph(*Nra z9rg#fbVrFjL%IKZvPpY-HLuAacTLp>p}#{k1rF&3$kQR3LMfruEjp!R_%oB;-z-`| zdRO-=8^{Hz3pLRm-osGJi(N^1g5#}ad5`2m-Bgw^Q#(Yf;by`M5!_)g9p4eHewle? zB#Ixg!u5rh%V?>Nl?y?6m)XM~f5*uwFIhS=f(LcEya zcI-WcS4N`v4=X%?;)rX@?L;1xi$i(4THbDkw*cP8?@Jyg|He9l_;cys%9R`m?@j;e%s>FlK$lpKt%1JsdH(2}|8A|;PK+(nV{`{-q z-PiCIF;hE4F&s*GAws;E;rxwXlKk=r{l0`XVvWRu%ZT?7%e&Yfe#TJB8-gNmyge-M ztz4-7mM~L0L|qIoM37&mV}H8{uZ%?T_g45|;pH;oy<6g}d1z;OcQU-#f0my+LGmze zmGSp0)=}OHc(p?`1}mEQ%bQrrZ^}F7MfO)lqIeI>dzZw6%ZT>}iL>&KwD^}Yl=@o$ z?|jF*_?ac6sP%d9UO`^|y$b+97Idcp-xPG9Blkt?73XSl%rS zZwQK}A4ncX{cQYwpLLYC#53JrnHzx>P5gxj@|*IGn8p6eNEB~xd9Rara2fG_Dsfic zGc5j@45j|!KA;>p-uHeoyxSVy3V5|cG#d^jybvK?%y4;_{k-ItN22&5Ys4oK4=y9# z9WC#R_V6W!Qr-f17dhURmiJsPRDbiBsU4!Gh8H5pFJ2_SO@&uRqWCQ$^XYmIzl=>TjVwmH7b%o*G#PF6dQ#(Y@!J&i~BFJyb``ojVUml6#Q>_tm zBpzHwyv;4|WA^ZIhEiVKkCp2!6n{6iyeD#@`db07c8Ka3UWg#SDQ`XDm60fZ-U>Gp zUM?fv)8+D0fB&+Fe=moL%3A<$(ea+ZZzcPkXSh&#^O&g}qW)OX#9xRYzj%@S_MgfA z%19KiZ+TCXcyJl@8yUZT`xC|yLZ;tL3%RL=$AAT#z!~I;SycO_jhp4CF zg$VMS^7a&78KM2J6&@h*;4T`g}n!&?CF1jjr12a|_iSVwvDn5iA232-R! z7b3_nUL?O0o{{|W2)c<1%!)_LK zG*_v)MZju@Xvb>UnjNC{LW%-(h`z9@1tygzJLBc5Q(IeG%r*uyEQb#BrtgfWU$BV7 ztm+V5gC$f$O^4{lCt;;@i1x8`lQ{n5gCW?vQ@}i=3;;b}iJh9imzu zwLzj*aB5F_)b@f}wnH@i+w_Cgx5lCtIJM(FYWTkMbcjy&sJ$x79Xhp5JZkqsE&EsI zntIgE6SbVX2YG{{UDLNCpqA|r&G{yss%I*BPdY>wdemw|E!!a)=}}umD}yI|j%|C7 z+6)@=bcot})UFe?(5Zb&VXk?mr$8;+A*y_xPSrE*Drz~mSHIDtwguF(9inj_wdJ%j zbfyKTwzo&^Z5s1*i1zcSl|(IYYClo@YM$w(P|J3Re)}q&s%P3q)Iz6rzejCnsAW4u zQ#@*QL@np`i2XcjU(%STLo~pnHj~yFzB#q^JZiT>E&KlvHSnkn6}7;rJx`ZLP2cv1 zTDC(}UXo5#-62;e8BjO5w4wn({9+r2GJ$##?lo$J+@(9P}`ZsMxyv5E8K;~@iWQoM6Q*KLk(?ad7B&F0(eV~H&|@^UBEiZo5xJ;5M6*3 zP5gxj?lAcC+20EukUI<>iQ?@n?-+>(myy38^Ociyh)%Qkr!$oL8-QZA@}4}I{gsg@-rVwzka%zz@xCQ-R^9;?|5%1ne+%Fp z;dsN34ev&VH;55Y#5$_h3cd9*nl%bS2 z0L5dDx3T3to(t9AB4%obXkEh#5#*QYI1lRzuZ%?TvsSpN@NyaPo+_80`n$#+{<#Py zDsKpi*^al!ZzVt0pW;I0En%kq8=|AIqKUr{L4H%-qe|?rj70HzmUpPcgUg8bd5N>~ z9&C9JF}%1BC^ud#*W0v@Odi%TycO_jhv*?Vl<-1?crnA};h}pazdRDfM_VJFlX!3$ z@vd)q@3Mz?GnD#U0B>){o3p$}aH0B}$4u=I{RW2;UWg#Sc#-`6Hc9f!BT@XY6|N_| zTt>Xd$mOU0F13e0EQE>58-QZ0M!oc%Kbl+{I2}K@a|)HE8x`*(YJ6Y;e`nDoAQ1; zQS$3}@32O!mUwU(@g8J(Ke30OGL-Tbz&pY57A)^AT&Vu$F;hE4yBl7JAisE#{O&Hi zG7`n#S>c|-%VorSr^H$P-NEwiXm|rqEONYK-#7k#$vVng#7ylFjmC;5{z3%#O?gM( z&Hl42slOp8I(#m9sJv%*cQL#r%+wCiLO7K0LIn9u zc^BR#`Q;JX|5_tri3gVv?;e(Sjy-&vp_DgAcZ=ozj<U1n_1rGhPMFTlH&~)7=IVAj`HR)Q#(W#U_}#uA%gtk zMe=*Wo$RlS(Eiu*j*)n98S#EBaaP{bEdJ>XrTzw>h#l|z`G$8J!&}5m?GU{QhZ0_h zAipW^n-e6zJVN_lYs4an2bU4=_Lg^+J$!+ols5!L+b`Vy*Ycjjh3an!Gqppsnc;;9 z^2>Cx{}o;tq5ZEFZY#W8M!Xlv<){AEx4at|UOb;Dk8r%h-ZlQd!aB-Z0k3w5PR5ER z{_;Z(%5Tbh@*V82jL`nq@{W*r=(CZxB+kk^z~UdvQ0gz9fRsbW8@^+BH!{3=%+wCi zOgNPALInB6i`)O+F8SpV+W%T3W=lM{jQrig@=mpfk1~|wr4CWsiiBYk3p<3X)Z8Lq zwL`RiHEhieQ3D}G0iG?qWL39fQhBm7T&_B`wYJ5qV=%+=7>9YrJmcw0EaEV$Iz%U7 z3Dr>3Av*mwSScN%tu0-^F^~??2a;K(JBdE$Uv`M*5Mj;dV{Ig00Y5>Y>zTxLihe?E z`UFphXrxDNkt~1c)VBAi&7d()hp4?r?K)A*@!cW){uen{lkF6!WjjQbx#`qF4yLQ9 z6`b0Q90ozejCnsAW4uQ#@*t_oPGA&!hGwjd?mm13YRo{0uH#ylOOAs)4m))~GzwT(P#_dqTCSLQbJs0|mjockt! zt?CD=`gSV$V>H z-R|eC*YQ^Jgy&_x?2=6yW@?9M2>jL!kf%d5iFjG53)8S^q3lZF5Fdg4vOuwFaWh9DEvPQf~ z%ZudmeA>@j-YNF*5r$G;?0d>X9dAR+JD3aA-wJs3-w@R?ybvK?%y2vQI>IX>Q9Q#6 zZzjB4M$tM&E)F$xwLSdfRh*pi7QkC_yo30yWZ9nNLgme4rgn(>Vnq{wA%Z&$yvQ9! z-|OTKgGZvcuH`*h;=yIa`z&8MNr$MX1zepii={PIW?KWL3uS9rOMc#oFLPxBDl!|xeNd9nX2&v(4NEbqNs zsQy;Ks~w{K3@>kDDZeT2e!?pwQT(eFK1$-jWyJfi#94W}Sl&GhZvnjZz7p3ay=?ql z!8*#D$4u=IjfX>tzYsxw@gn&he~sjqN9g~*wY(2WJh+T_f0sBb?-+}JEkmil0VsMq z-sNS(ySL#jVy1S8zJ@~yFGP@ErsF((JzDb1BT;;tHR3mk2bU4=ftGiXJ^YxVls5!L z;CQ=R-kZ5l{Vidpc8GR0ybwWtnT~mP6q;&OX*mL#e;GA1n9&R{VWumf_vn@K(U99irFaP{IoliFjG53)8SCU3lZcu<(*FVh=d>` zwEwk6yeaYEGUDCb@=mdbk1&+-=ICy*yxQ?Lw7i44Q2nidS35*?3@=2G-;}qG@X847 zf35Il!pmjEdx~6sgWdLhwLSdfS(vE21@I1yB@cu6t#tp(h02@9OzjZ$#fm2WLInB6 zi`)NR&i={>?SC!r$r2APBi?5v&dS@<@*ZS(15kvH_lcP%5C5=^@)j{uJ46q_p@bJA z$ZyK~z-5wO9-;lOHDad3gUg6_JTd{&p5KeVYiAhV!wqip~; z_BD*ve`W3<29yrb-&Smp(D5UqrzNv$;=c4b|FT0gg+%pX>mc_tuZ~<0fjjI+;yOh? z;Y%9xbchCc)Mm=^)7K5QJX9A37p!N9yNU5c{)TbJ!+SUTIkf?rOT$~nH~$ZY=`KB zr_!lW*)WSqE>KIUZXJA^zCq{WjjQ(pGc?bnYI$O zz^R?@QCkOU*$&ag9<_zEGK3#Gwe37=&(N5sL)6ZrHb&HPZg28&)sH~^*?SVyvK^w& zAJ3lYo}yN8YS(+zHiufaLp0W-wv1MW&NOgp-8^b<(U_-0)Wf4TNz_88wu0hUb4@RS zTDC*9>aldHu4!*k%eimz`#fqpK`q-MddQJ?3mWrui28ffrqeq2bRD94 z9;xvdtL_kO;t@GpMEL9ewW=SYnu^0oME5!LH9O(iq(jt%-ieDS|8E_ljYw)%;s14r zzMG1Z(;YDO4CN_q_j4$}mD~~C!9ikraTQ_N*4pEQcvQKk+h+nL5UrHBp z>E3-%La)Z`E?2uAb~e1&m6TUH-ieQ}jz;Q7)=}OPW@?9M9NbKJA%Z&${(Qc}7MISW_T;4o^*(oz@dZ}BE*Xs zZpXf481u?V6yIu%SoJ7>4wq51_P4wX?cqlZrMw03c3CF7;jWhVMlMu;^O&g}qK<|a zBDllAi`-#!6kZvL;;*dme!|OT#CscGIZ218jpg0W@CKk5;dpO&*!cSy>nLv#GqpoB z3M-oU3lZYQ497d_Y{@T=L~$p}J6__!WyJf9#98xjfyKX&q14|H6tUx7{E*?@$?%pi zQ~wRodvGY>g$VM?be!M!&XWA{NEBabjrdyP!DYm|o8^7e9!3nMyx4!1gC8Xi?JV!5 zT&Vt5z^fgimWG!%v6SDGx25pPNEE+sg?ANRE+gKnU1H?zE(8{PtV$BYo(kq;Vw z=dq6R<}p({M8mP7iN6p*e(@st9eyVJDTd}%wL`SA;e`nD%XFOIjfGc6qWCo{+)8-4jCjwN%TN7X*Yd7scyS+4 z9Fc8H#aLkTZLkYBt=exE)~^2;Mpe4;htb%_U;5pNUA z`;a|+n4y$607bAu{B2-)2XdkMTf|K55Y;lg5J7&Kj`L7Ucx5DtpRvN53NM!t?@4m` zslUJ3!{6_NiOL&-BEM32kK?zJ{m$cDsJtc2)DBS}tZ3pdM3CQ%+4kf%0L4H%-$wMW-JQBr6 zS|g@QJh+T_>ssF1?cp5^rT!McTl`7<{p()Cdzj(PW2Sb9euhH{FGP@Eyhwh3K1K4& zBT;<6HKLC2avAaVlgm&2{nj3S$56@}fMUMmJ=F5v!-eW^5i_+z)Wh&X1o>q;&TkLl zl@a>;yjHlc#DmL-_d$uX^6qYVI~(2*6#ah|eK!j(6EThPRvHt$*W@?A%Jvfx` zLIn9udEYxx^2;N%|FuSZE%D$o;@!>izG)95hEiTUpD2fpx1Hs^lnd403V5|c)Y9R(Mz8)n_AD%jKv3Zf1EmH@tWPQf~XJ_&f407S$R*k_@^+G^OrhA&pFt4?=-M^16u^F zc8K19Jqla1Lp1w%NiMU~zZbI>e8Rzy4pDoH`LaC>8Amb0a?jty)3z4#BCc|tR&|KB zF^tt6qU{(^Iz*pZv93bLkBr7*Mbcjz*oHpmUv`K_lc+wJ8{{5YERh8Z++imY*D1P8 zFVmQ(L)68iHeS?1r}hnOIJG}1=rzw2-*=u4QO=`woT!CP?QxIV9#G46h@QS9{op~) z_J*RCTGc@Mu5ViBDjS;niQ~Q|0 zT=Ps%f?Bpi^!aV+R6Wx@MJ;e@*L&19hg!BnG}fcGj8+EEEuC67kJ?)_=IIdi@Tg4^ zwVc~?t)TeTJkv{{mhBL&8lO(pGwm&E1*dkOM{OslWjjO0%{~@aHQ9D`Ga&B+(Y}F4`{n@)O)Uq9-7jMn_)>PCAPVH2W z+OIU`=@6aeQJX{SOlKN6wdNkRhoP4JD|2~|+DK6go!Y#rAAx$N$3QLHA$o6I_DtK0 zTF!lwU+z)c0BYF|(N!L`3at#CsqRsB@u>0}Q-R@@xek*xmatU8{x}z*&rgn((SUugOc{)V-{<2SVUuFxea7RiPa_Qc^QbMmG z+LS*wX%I9qyx5hL8~-l5wTo|N9d-O|)=}OPW@?9M7~D*FA%Z&${(QcpA9l3dVem*4 zZ)15!QAY3+!@c{yL|1u-Sp1V1O8v#Yr`+4|&bi6(HaEN#QcpTWAskA0Aws;E;dbod zQOqkNQGAXy;ysEZ@p2hOYg@}Z-5$CE%}{wgW=u4@Rl%BJ4Dmq zP{Iol^5%qBMxyvBE4;DravAZSD3_o5yUHH^dOb{3-U4`g&lZ0N@LS2xvq!m5 zdGna59irY?(ZpYfAisE#{PsSQ{gn~=|8Fht2@(%3Bi?5u&dR%=<=x-#2B28!{GEE8 z$-|$lqr64T)DBSz4kf%0L4H%-QXk1Lk3{hi)`+Ji9$ZGewJq;>dw3f|slOp8@_&fG zYpylChZx=xW@?9MB^*k4A%gre9p`uD5t3gXiQ@aL5w(Pu%ZT?#x%|}MukGPC45hrd z51?PQ7v6&{@7-Le{#L-N9ioEag$VIthRZ`icx5Dtf3m`TBpzHwy!T6-m3LRmyPM%H zfVayU;k|2&@%IPTQQkaeYKLen97_C!2=a>;$?w?Sl3yN);(aXdWQhlt5$`V&XXU-h z;$O{B>Tdvw(D5$4#_;ZCc#D{+9ij>xN_ZiH{4yQqp>nw7mq()b7Hh=M5)UpT-hD0a z2lntohEm=T6#f4cfA_S!*K?uzTf$835OpxT5J7&Kj(Ix>uZ%?TmsYrk@NyaP-YRic ze_L7J)`l1NW91Hi3Ga2IjlZ9=j`CK(s~w^ME1LKV5#%@J4SKP^G7`nRSl)3G4=y9# zuO!aOd!EHVpP|&>0(j>;-cPPJygM4+JZ5T#Xg(ZDcp-xP;zja1|1ilfkI?VSS|gT7 zJh+T_J6Yb>?co~?rMv+sdjBo{?qGQ@;X?Jdh?&|U${SvYAiqq>3-PH0nF}xutV#j;&RmR`9Sx0$Gn5iA2VOY_`Ux*;TDetgD*A7m)y#q)`B|J-5pThUQm-|`;Ih3anwyxJkk8D4(KLHSL2 zbHXblwEwlj8w;;K8#z%fKlOK&J^VF*iOP#7AmxhV9l&p;`(G|p-aKY%hp0DJH1QWA z$S+>p{`~a79ioR0l;koy{d+NM!E+o8d9u^MV%}p9Cozt*b^oxOuO*o4TFj%XF{?U6|G<)j zvARQ4mjR_i^t=^oCUpGB=q$O$2D@ht|Ip#T><|qhQGH^ik48dSFfxNyl&)t|(<%B1 z_t2Q9L$sMkZMdj~PVF^XkD6+SLoM4OntfS1RoPmJTF%|Op6^jx2Wr_4(ZwFMg|grU zr?#C(?HL;Lbcot{)W(Qf;M6{*RjqlZ_`dUWh(5nGovLTLr>KQa?Rt;e=1|Lah{k%< zmeI=KDUZ8n>gG{kQv`H%!0(Us44rA<)OPWxy+mW4 z4$E=egqD7Kl9FpTDC(JUz9!5{X{M2_9nM^)V6_IwnKE6N9{LS89LK~ zQ#;V3_CAeyIz)$h)TW49;MD%0_|;s~tD%D2VXP+mh}WxrnhtjH=neVm z4$-?8X6@QhMEL9ea*xOcB%*r=`qJ)uWzr#9K(pf(DF1IAqIsjJLzMe}9isa$fK|Gq zq-fG}1-JXD$8RM&%47HC`9tz+sINsIg8s38pZyqzXL$n+YCA<*99R^n%c?`?TY5)UpT-k&7S$~(&9U&&DFFZQ415p^WL@i~Tf55rpluXcz& zheHW3Z(=FGDevcdNPc-Fif^_?tdw|g8S(C8dEc{#?=zJ07Qj2@40&SG#qwUuh3an} zGqpq1-ta;M`NfOmx4rPn2>t)JR=6O%Tt>XNNSxK*mX>#0!yAA?{|(WYVaDH&Sx0$` zn5iA2%dnz}zYsxwQ{KzEu)i`A#XDQxu@Vn1Bi=71&dNL7;-AY<>Td{&DJ~C-&NjT; z8{QITYKQ0@IF#^01o=&Q-{~y*<&h}9+!|4lcyJlr;$?sXav%fMD#amn6K;pq=#JfP^th^^!{1X{U{S81d zY+dnp_L+uv3&UH)OzjYr;ZVX05#%@JE$=4z<&h{p+Zr)n;=yIayN%_2+8#c`P|6#E zqTYJK+tl)&%7yB02{W}r)X?xk1o>q;-aj-HUKxqvm#uJKc)5&t&ymYd{jFtrYa3qN zkCj(C-l1n0f1hU^<*k5MJ4A!9qKUr{L4H%-LA$cQG7`m&EblOh2bU4=D-vhr?PKwe zWGMBw0Nx4p#NX#mH@xc`-aKY%hv*47l<-0X`NfOm_lZuDUml^~m$gQO5)UpT-i<8p zWP5l&Ln&_nil*xeZ#~O<3>T`uMa7t#D)EGQMJ4k+cg!aGI zh@9|p8Sx$=m!JB(#2$XdP|6#CqT+aaTHZUkQ2i}prgn(B8(xSYzf8w@=q|i6Li=AU z+*{(zWyE`*#94VeTHa2EHw49q4I~c}PBH#|&pOIm!c6TD-2{gce<6bWro1=p%>K#< z?SCzAN#em}#QT%PS$RiU{3{ts{l)W%a^nWV8=q`=_b|K_@M?$Xb2yan@A==%eHcr%Xyc?$9f1>!+JkztGmhBM5$EQ>EO!pJDf>XQAqqYsy zvK^wkJZitu%HYYUQ#;V3_CAeyIz)$h)TW49=+yq8_|-hqtD%PHmt^?Ry&YbcjyysFi7*;hR%yMn5czL z?Ukw@sCv~O2DNO5=uLWGEmq%JidxQn*PrWA`-jFn9ikB)wGU{W=}Zewt+hw(DX3-t z%G?efwb7y$IJJ+eegx{7o(Q#UhiEaKUd=P@B5I*iyVj%D1Zvq1(M=w;rL;11raAXb zzL!TWqA^d0sNhkXC~CS#`H|wM_Vsk9$Pc z7ZL6d4fKe7k4wbuA!sYp@zkV4^d!9#uOaUL*dcm!D0PS`-DpRn@{P%9_2G)+V7%@q z1N0?ExZTgU$MTw}4V^)FW3oxZOzjXY#>wdh$kQQOyshlh+#cda{>?!wDu zv{X0Cg`m87%e#%?#lEN9wvp^EM-MRme#AP;TLG_jh(==d6MrE>yqMv3>?2#s9R`m? z@lKZaCW<4jEw>Z-qR5BJJIvyr!%*sP0lY=WyYLvpyPe_9W2Sb9=E9+b7b3XB;Lm4& z=WfHiG7`m?S|dJ}cyJl{yR+pD?cpm7rMv+sN{+XU<-L##)!!m!YKN$W;e`nCVutg# zh49Kq6wkB5?S+@ii1%_VR(gRow!9k|-VhXR8%rK8=x_XuSVwtFn5iA2Gq9qGzYsxw zQ{FT3?5~VO@s^hNGKmM55%0SaXU#*=;vdgY>M!=6<@t{H&7%$P=7zTdUhNRQ2!|40 z-o#RVQ{ET1mi+Qa6rX90ct_&FWyHI+<(*~^pJFKGEr9nq_rEu7W_eHHLiIO~nc5+0 zV0a;d{NhFKkQ)fEjL`poYlXKGUM?fvv*q$re{+_19m5-dBDay`;pC%?zt6Ic@)j{u zJ4DA}MH7D^g8Zhu$8E*_%19J%XnD_)cyJlLBLr}DJyfgb5-t`P` z2{W}r^cWmUcp-xPro4}BDf#7*C?05yC`&xJjCdPa-jY4MkD-(o_W|Ykj(1(ldo&lS zzZLLmhv+Xjl<-1?crnA};jb2wU&s5n6>ccJTt>WuU1SK7m$`ocuzEr7T8#*&Al z_^sq?^IL8d5f5-9ioYFDDf8}$ZyI!vAN`zN22&J%lm}HgUg8bABnT_j;07b3`S%DcF!q;+5ZZ!jL`nq3U?P?E+gKXU1 z^OkoT!<(bK#d4R;#NW|}8-G7y9p$ZnS35)_v7(8;5J7%Z-jSQLzcNDmU(0)w#DmL- z_X~-$@(#23=P;D|TLAA^$GfnX;oZ*g<}p({M04R#!V3}P7cY|ExtmFTd4%@A)`-s~ z9$ZGeJ6qn+9=^g*${TljLe=YB2 z5)UpT-ghO=%3HMf$1{}ri{}&NrcK4)HxD(un;YH=c(p_HA{GQMg;z#s z|7(S}5?(GNf6tc7PyNkV-gT;ZsYBFz3o-Z9LyWnzSVUoqfYlDsU@WJaTeCxS!Y1r2 z3eX|i#FC!J!H_3Avn9ofd5onVz&OrU>JY7Tn6DmeFgK~jtm+WG080|a>JHH>8v{@} zMCaRcUdSQq&0 zFKVGvyWFF;0o1Y`qN_Y=6TEVG(MeCsWdZuSXE!!cA z4@#%%neHcQfm6H9qlWK0PlxC(kJ@jt+@VuD(4+P~jd?mmhkDeeh+59wgZx3!u6d?c zLoM4OTH7<7s%I*BPdY@8dek~YE!!cQ=22@PY=L7N=u!Kg#ylOO6Fh2Vx#mKr*2trF zH`KC!Wo}cC+AvYexxM-;6y}<~9R{^*hv>}%)2ZrPOHnI0wR1gc|InDHLo~vp_5rOk zo{T!R)*iK|pqBkBb31s{MvGeL)IOpx*F4h`p_c6sEj}Qfs%P3o)N;HFi{fiNYE7V) z?GWAMQCmtYLuXoWYI}LqA{z5_hzcIHiJ}%bwI8c~1nO0P5!A9BqM!HAo@p;p3!U1% z9XzHqjodYvK^v&9HQ7f59;pU^t?m$A?-BWq7KC;J+#%Y_BNE|) zb9)Hd$}~Pa=@8vW@5GBx{@?x$(Y3v(LlpkM4$_6+6z&194I`aXCoc_P&W zg#HfEEI6baAWw&A*7~wfb9;!>`7;yYxwL}xIl5ojQZ6A~s3+{Y+99fMcp-v245s5dqWZ!sBT@W<6>cHCTt-WErd$ZhyVf55Q()KlUFp)4 zCpdqH@LP!uGq_NBE8x`*(EzM|;xBKW=nf<09Z*m1FnA=2H?X{CP#ke>xt+*Ma&ahc zFUxzl;Vn>2@>k}j@69^;6;apl<}p({L{s5V!V3}HVesd(zf;#^UKxqvW33S{N<6rX z{N2#Ih~<4u;=yIa`?thdd2h1#H#3y_TL7>AmAO@24e$PjH;5{DImM~L0MAuVAiOdX#h+T?uENV@#CxM$e(LX5mUnBz8-SwXc(2;S`1>L2 zC~pxnwL^3nzW+>&w{aCrU zweYsGyytVF`db07c8Ho8UWg#SDQ`33m60fZ+X}Z6UM?fvOXcz#?7lA=THZ#6w*cOH zdEq^;v+?&0)=}O(W@?A%G^}XiFGP@Eyhwge`{!@?D3lZcu<*hHgGD7=bE8IeOxr}(vl*>>3U26~j z*$pNtFXfDWgU9g>;kT0g&I~S8-U@iNLo@&@n)nM5`XG3a`_3L90SnyWqvW7YNzR`>!P6m{=22@P zYN1mb=u!Kg#ylOO6Fh2V2~*D93pVno-3_(uUzyv~qc%*`3Qp}6T8ElvdKlEQ9ilgP zPN%AGEk!MGYUg^?@O|g$5RLGteIUynIW%d8Q{q zE!!bl+&-PEXDWG5Iz-oc)S5so+abEiqqdY*hW2ZLW82H47SWieLsamnO%%1zsr^Xt zt9hmuK`q-M`gx~xs-9^tQOogen127sqqZZ|vK^uaJZd>nD>$_yJZhiOn5RQ@lt=Ap zT4(s?)M|UwZiZU6LsZYBHbm4yr#6GaT+_FGpqA|r&1#oURo^xfwH)ulqWBb#+AlQb z=@6aaQJYQcOlMkfYFl{J9)w!ZmF;#c!b&xBgGL-g$q z=~O+_9-q@9)J4AnNpFPw5qNaP4M?7k~K`q-MdcvbtpVed^F~}pe6l2vLqEkI0Z_x76PJlZ^ zTX;ksq%qw?&{k&ou1SaJbb2SAiSqx}Av%SmW|jV5hp1ayaOsW`dxmo3HnRJfydB<3 zcI?0Kg_3O2FjM~x(F8c88z4`IXu=A)!*F|ugZMKO;i;4d`W)S_{3$WjWxqkLPd&Vm zp_CW9l5&5?`*Rz^yRYFbVWxJ7Vz`;`LIighOviT^@p9&sktn{?8nK3!7s==Ow4b-U zi|yfO45hr-_mqczDS!2A$uE!4 z?@L%CmP$OhjCl95ymRg0JcjxoYu^H1S5dXS%gs`eRzxg_aA<|3rRfdCQd&$eDG8(( zdZCqzO`4pvp}CQqv?*AO6qHbk6;Y87G2Zx4QTw4{tr$YUrgG7OiWT@UpyGk5R6vMa z|My*MX7^J7yv0L=3SNii~LcZ6ic}OBw z&Drw3Frk_~)681lV6{P}$$W%-tp?||WZM98;BGFts+n9}YL4Gs7bg!ao1wcnx2SFiNv ze-;8CqkJVB_^#IOXZ8Df`16h9sYJ`SlPp@ssD4+7$PM#9l8lyb6;s+BqGfDRr(c55 zeq+AN{wDg>EB*OHL%tWQc}OLo)UyzJezXRlJcZjA0dIR;9JF%c86#eHRSjbg!UWr-Sw2( zuUtX=8!F;CH4n)KzGsAd9}Is!B&00gUb5I}_)ZS_Zjg*tzuin}cZiAuz67ED3OkK| zm9Jhw{2KyKRlbr9d^fVO;u8hOhI~I1@a6hM&$98V-z!E2`u(loSiS?~Yj=n`*rHCq zvd97Zjrn%KazR0_ApQ;cUZdt=*G3*!bGG)-5YlfHQdYlQ0qNOc_&)N1fbZylZ-y!D z4$%&3$nhlz?Ux@W{{55MuUtX=8!F;4H4n)K{hl21y(|3r3n69rVuz?@f-3jKkn9@C zWtCe+vUZ2)gFe~99irouDKl_~=rTB``!>;%PnkO|1?^Hr>osT(z?chbx|C?i9ipA@i<8=#j#ISA#J=lO&<-V9a);=O z6tpMNGVtW325mwL+Rt$Z1Zz?chbx`AlP9irFY8z;3j zU8ZQA2JJg3XdfY3a);;#DQLqKt=FJkkb?F%Tua#@s!Bn-3++t3$>@*sKPhNmAzJc1 zL`S5cH7Q!DLA%>?sMeF8L$u@$(S0M5ddnzUr$M_U1?>%7OW7e>lY;gL+8H(NHE5$# z(0)j?6?4NuneG)1#9%4bv1-bb|L4$-wKXnC{@ z2JudY7}HXqcJP|NLv&UO$Tt;4c8Feq$tCO`AU1|TIS(G=c8Dq<$=|^2|F<2YGC*zX z+}jS(2M=fEY(&YJp{Hu125Ft|p~%hXAC`{df;6VIJ49=!ZyNxm>=3Q_z0NR93{fOy zI^e5e4=BgRD}PiowatF9_D}nBwUDxW8I|$G!Ng$@h(zB}MsO1{OD)E-*i9q9KS!LfWZ zOlfzB>e!-AzXah7gC9D>sQazXFyu;q{sST34mA(S2EM;L8+-@12jR{mK=bmk1THL(N07f$z~F-|vP$zbB+D z-(IrF8@?k#zSWY^>bILI?GDi)0bhd9eubUb?;*-puk`1C8Ul}0zLE`m>$Uq?dw4bc z`P!jWqUFo@v!}y6wXI4-t{eZ4WVCz-$k*-=oyQh+`jsFS_8ap(?_treUg^)jE9ARM z%|o(*@6XhnE#I?4zUKsdOUbu$vfA&Kp@BUN3HWB1((Vx5N)0)_1fl)%L+$t0ooc^w z1@FHN6|q&#L$ZPIp&{R!!k_;oq^y2B$zq4$8-;w&m5f%uRZMAjh+d|K9AARaeubUb z!^^)>`;{yG`Tq`qhbmvm2EHHH?q~J;T=;YMyQoCVx0fvT7`_Wc6TWkluU_fTzY+p3Q}d8);QJjlXUlhL$oGtZFXsV0TTW4X=sqN{hkpr< z94cZ^%|o(*Z$-%WvGC{P zLdx>(B#SMEZ)wQ)^ODi(w~8t44$)}=UxLtng`L>LY06ix^ymK;0+%aa$p*e(QFFHX z9UJmJIpEt%7Rx@O`rUj`px>ti$MWrFO1ne!8Mdg?FF|O(G2hQTDEiea{rQiEd~a0q zkZj=lteUgsdud4jG9hL4%lTN($kUYXz<~kZNdeyh^0hlek5WU9FF|O(G2cfYQ2UiD z{rS&^ipZ;ZNH*|2J>+|T`11iFW%-tp?-s*%V#xQ?lF{ln!<2T1=%j!zL1@4HQ2RYe z`RbMa{2xN#Dau!}fp3>~KdawkLcSji_;!-T$d9UiI}Zr-`>^0xzEwL zLi>&RuDM_It5^E-MIqm-)jT8{`2JDN+48+Oq`z87S^f5s#chV~&LIKc69T^7OlfzB zwo^lnFF|O(G2iXKQu~!Fh<`&x>{9cPY~VX4|=6jU#)hmd9L*QcNE7`zzopwK~-(ex&cL#h+$@gl*wv<@ zZw;bcHy*z?;9DgrFVeFpcTz)+FF|O(G2c7;)qdp);@?maJJdWR8~7d_^8If3^Ls+d z^6e#y?$gyCMudE;C8O1EH&fajqC*0{1fl&3JB@#puU71zLE`m>$Uq?{k|Ih zeCW|-3M5Zy`*Ilcs;{qn=azrR%bl`DvU zLq%*=^N?)N@1Y^zo5G*}C8Ugg`INacRJjL+WEV>=tK2G*wL3)rp?WOY!X2X5?^DY) zOurwZ9xhCEWoL!AHZZh{O?CzKC^fK7vx2b_;5LaZ;YD0a*&%93LEE9t z-)qp0PC@%N(UMP@J1zz7Qbmhoc8K#|&|D$6r9?~a5bb;|S<`WfR%+1Jr=T55wB!!a z6)9*>Y6Eo|v%GA0b+Dhv)|>Xu}jOGO_OkDQJJgwUiyAsuZ-l(9RfhOAXq4QqaCawB&n;jz~dk zQnXHkb~lWMf&ay$0=)6tp*REoFyjO$yp0XlK+kGBM)l6to`_ zt>QqgWZ#RV8I!a)1?@^jD>X@e4`VK@X*JQ3J4BDY5+}7aJx$R%4ccc@(B4P1wDJ{ExALq=jCKgD;2HOpnWw3 zZ4A+pJ4D||L3ra);=U6toqJ7MYR! zN1j8qdixmBk~>6O|DDv^k&0$xlxzyxzi=&Ohv?!IwC!l;a{C`*C;w^H)t#{vMdlw&GtlMLqm^cgw8VQT~6yYxA$}T~gll*B++5dk9L&{}4LA z=-$n|O3d=E^@H20N)e}REE_EE8X+GWdWUjbC8F~ib+vSzCBVJ+!0co)E zD0?gZMOXFa4%4!5z7Grw@T}-Ynubv7&*vl=87~6mVo=VPceM|ccP-h4B>D1vg}(MCyN0^#>XW1!%ZKVGuE-SUGOK9td9Q*<`=D)@uz*=t z`yS1{z`&G_C_lX~Hw_o}utxVtuL_IOa;DpIHkJ;Bib@5hYr)Xn$JxABd3jZ(vyyzu zncdbUDj(BV-nFy*p20&5PqKC#VL(gvl;898A>~7M7SzLNbSTD@y=mC zcC_9pC}aoJ(+fsBwpC7>8}&fJFa$iGK?c{d0ZKfZ9(54KG;@{%o8G9ih{t3Iqe%k~ zXT4ecJp+fR3eW=%J3vK`86y+-*k87bozP}_NjTplKR32eX($;|)E|(KE1_NG8_IT- z+AR0jYBH%9vSd+J-$9{(*!B_O7;7O)4%db%oTzBDS|zTsSb89SMduXz9`GwQgjS8} zE*N2)Ir{HE*?-sXirP3HRGwm<`NfiJ}R|)lui1gD3Oh(u0*SWdz?%);8`}# z1uG$XDKwXVMO??d`RD22)P>ML!G%nL3kiH93PDfk&mT@b@_RpZZ@!ie^}dhbcWal% zE8E(99c{R8r17mYmdsdeJvf@TeJ4CPnwkxYdn+&lsOb7- z<;LvJ%C2YbE`>t!&;1;$0r1*aJ)S$Mvg@DaU4P0iLb3xsLdV{6s(9#M7f3gG5hlgIw8&%7@^B>EpopHWQyw zHn8>xOQe}ZaHZ{Vd*vcr*?kaxp+)BAYs*hLO!(&x&YuI_qr&BdV;8-zSjPL23quIn zTuGctsDou3Rwrni0}5;(kO8%8?oKHRQGDO>K~-h90_!W3(8Akl>KL zaqghssB6&IT#3X%25B2K!dx~ctIy7f>rya6J5UTgkB+}c(Vsu*6&dnWu6ng;i9RT9 zK}I|c9}a{u4IE2&Dpt#hZzmqkH1I!*7C7-0^4N6R^7JlDQmM`7C z1$xczK7|SX{Wn&Y%}P%w=w)yV`Au}XUH9g%iXG}O?eH9FlGYydw4Eqv!=545E=)tx z0lBzugx9pO+#s6^g(F(BOTWuDm4@65_+eI3iw3lsu_UT>B-E;YhOP`1{{qzRbhcex z{wqI$o5UR9-Eb^Sb2-w`soOE65J)`Jhn(^S_i+9^{odg>^qP#$_E}@-prBUfKpjm{ zbi#5+zWCN#iTTQI)YWRVz~XObU5xeLC&~NFrPSemEq%Wv3tGA~S;AfaNYT>g z_OFCh$r7rPC7hpDLdpJ>a7eO*&SVLLe^05y15fXlmcAv)0xfkXOZZY+3HAF|!pvj| zy~z?zO)KGD`&YuiQ_232Ea8#eDO&orWPRKIaCx$Xs9>EE<3meY3A6UEgkzH>WRfKu zo>szB1N+s|+ay`g(xu4~ZhtOCOP|`m5|+6VQX`{!7_)|05*eM(pNNdUY$GF|noI=3 zWv{=#`&Ba+v2igX)b?I~V#7Iff7!rr#9YJgJh=Yy(F{8g8IMFX)Z4?$45uzTFN(Gw zd^V&*kb2j^Z<`Q^%JOZm2^J@O=(V>fihh?69ce_Fr074#YOd0x=t(20N{a3^qRyn~ zHY4gziZ&ThZ&K81L<33DQX?w;eWG5|j3`QqPB5ZOQgnzBRV78cKL~A@<-rZZ@qNSK z;cJfmS@$_}qiv6(C3;%Q=0{5x|6cOnheQX-Txw3qTl@=S&-8Gzx7Ay z{#>TDQBTIMh4@1$*9iN|_VlV_-vf37W^g1AU5iJ8^|xV6@Air85+XZ>ssFigjqiWDdw7}t z=Xlh0`@!oV9kR6?1rEOxD`La1dK}`r`8)q0#+a*mhkp?(=fkhO50_{3;J;|bU8MJO zy8dlP&cO!Qhw)!!*WdEP&W@tFn;Je`3gSbyokmf)h@Q`nMinYH{8A+sQqpK7$5(oi zPD-vblK0H@B)3rV10(r*1tgow6s?z%o%oM+`Ya?${&T;#JL=?o_g`zziSipCMML(N z?K}im@Yzd=*w7heJKM&|H!fHn%=%%Ke=9--fxV8oSN$b7daI0;V|H;(v|`h-2UVW_=eUV~1>U>=QQ5V- z?8=whhiMId@jI~9jhIIsY3gWUl;sp$!w&bRI0m#SpNU z#&xYTt`TR!xPI{n+TSD{^L`|a-P&i43`4-z(ESoo%|o;=4FTUtRC6Rc4Q2|nTSE)t zW%j^x;RLoHd?KV`K~ZubI+#`D@Rf`io*SW}l$hZ+MwAjW{Md+klVj9Zj3^~Ox!j79 z!&i+FrNj*75XrzLgL`SR#3GY7lN24MdCi!X5*X}8%nxvk{-32b)1!y&oESiqGLC=G zh*HM!%|=v}q}6Uj-AP5957B-M)~6sDc<+6%K7vIUQ~mA%_`YHAeX#1%d9dnVIjb(E zRsZcbu~jc(KZ&h+3k=5}tWSi~Ojz|R4~tdXJ=MZk-5(~+)OWHPbgnrxXkMm4cb-Lq zUIM8abaIM#DrX;Tk)-HoBPvab-ozd?b5$ipe>S4dq-ci`btgsNH=^F8=z1d>NQ%}P zQEAeVUT8#BNzn`=>P(7GGNSIJ=-o!tn-uLiOtn#(oE87xh@zxun-wJ;>DP>CAX(Ox zMwChBsyCvP$@x5+D@o%Nn=1)8(uhivqBn44Li%`8^t2JB3=sWB)SJw8yAcf}MV~jK zl)-3?5oMC&)CERVniQ29QB_iOq7ii_MZ=7!J1KgeF+93MZ&LI-EBa$%B>kBY4J1Xk zSW$AVYJ(9)$y}>!t|X1QMwChBnruX+Nzn(4s46LX{ZL~7NzqeA)SVPmBAVG!@q`9{ctjRxP7QLX$Dtgg=fgOrI^*c1am?Hi8^;f5;IVPM8$bO)x)aTo7^D}{xb)zY%&7Nc zls49}b7i`9JoYhK$NxY&gq>sfRlhJ1R3>RBS018T?@g+w-iSJr`krS*rAd9CVgZw) zkyexpuHImH50BTK49T8`NDN0-KT@pY9!+q7E{~+Nb2q_FV@~;xYs_9YW}R!y+t`@x z+vCQ3ipCr_=9&2EH|CF^w8%ExU#n$!wgy7>{tzw)!@Ct3QH_FEAlcbz!TC~qCxNF z(#%erD%&-D!#vCpaKsA8Wp*)U5=@cDp>P;eO2s)bJ(YAC%~4Ki@6d!$0>kfYby*U+6~1nG37}cJOE>J zZLmw*U>&M}c6*nUzxyL7ZgA5A)Its&+FG~5gs(1pzH|Na<8p`K|1s?*{lQX@IW1M_ z`Jlut8_VtzC32@uIGp8k*rC@}TcvhWsgFCQjx0wHd9+uQ3Onl0H@zr5WPolB6+{O> z!{D&-@C`i4DrKP`$i6JnOL>P*GySALe=JlO_Y4ri{ouT0dq#U>LEeYXVBV1hSAQy3 zBWAy!KBcQq3T8_I^N+mVib|rfq%Dpv$ljsZcaNYs?i%v!6r8-X)@Wz#*kCKQ)+mQK zVUGUHT~Fh}KIZOF`w-iliAEPkQ@RjpeBP#lJ9v7V*{j+EhYI2mT$)&7G z`7Z{sA{Mv9%D5dq1gpZy*ZB}%maD-3>vOa4e{pU){vVV3DE_}7Hwph=lsg&!pOHHe z|BuTZkN-#Kj>i8N=H7?@i*jt2QSeA!C2YG`J3)#Gmowezp9<2&J5;Xyx|Te#vFr(T zLRNQuXbmp39SMy4?Lm6}_vZ{;?r^=vd5&~ZNx z8WK6qD0|}aiOk$vkohb>^H|LsRDmXNXPI{b)vw9+vR5(zYR}E!%W^0DoURB~zX5kv zwjTnBS9ZhD#Q)oBKY+$VwXZIFh2nVct+;Fb6J71tT#3*7V{H%$7&82-{P-yP^!i=A z0TX*;_;GhB_r^w`ntH<~f9egJI!>wP_k6M-|^{M8=9gDB6~gG0E{ zL%7*PIFbmZM400tT;mWZQV!>N2| zu+T%8N`wI-ybk8J7Nrh>B1JgNLm1&9oJ9m~l;yX12yY^_)`B8Mxc{ed3BPt)@9U`~ zLWT$(9>QG?fg(k?+C#Y3Ls&qBQX-t@AzbPZC{lzu9>Uok!V)4>5#c4Ty{9+?iWK1> z4`HZ>a3K*oiExL9@G?@X9w<_TzB^+*Yf(WHVILSk}*db7)2&Z`nQ$2*M zh)_j@zo70`55*3FB1L%V$FY3SX}z!Kb42JQ!Z$pGXHcH82ZwNnhj6Ed@D(C-6QRmO z_?APUNIA542ssbot3>D}!f_tL3Wq?EB8>MCCVL3qAi@9TdNg(jic!2!FXFmgk+;`+DvtLMIWf_YfXMdBz?b z!Z$pGTRnu|6QP?33p|7y90Enkp~^$3^$?yULN5^x_Yf931d0^lI1gczhwwKd3=rW# z)ZOY~ghQZ65uW&;SU%vi-q-Uy5h5%o=dbY)evR^sJwT)gH+cxRcnJR?LWT(C9>TQ_ zfg(j%<{@0@Aw*{bp_B-RcnD`Z1d0^lC=cNn4`CP)s)%qO>TdNg)FDu$2*2AB%Xc}g z_w^h}giaz{;UR2CdBz?b!u1})mpp_MiO@}iQV-!uhd_~XSl}Tn_7KJqp_d46g1N25 zOou>`A{_1^9N{6HLWBV#+~pxe4uK*?c<_gD2|JzE`+BAkflGn;OFe`hlxOS#B1O2y zL%7aEC?!IM2vavO}Oq5#IcMT#ExdgtbH%Aj0h)!XA{TdZ0)V?(z_NUAy)5tS16D zjq(?J2tRNL6e+@`9>V1w!j(kG5TV#ZXmAJ=DZ&&FVVZ|a^b1b3GBNi0~~BA&>HmJvf9Pdk9-Sgd2&_NrV+1!mSR0BIVHPA*}HbzD9&@ zB4j*-T8BW9B24rUPW2GJO@v+|Jc+tnJ&bY)6e+?#zZc72a9Z!{`2i6Ih;XxqFo5!m zJvfBhJ%lYD!jFj%;ckHZ`5wY84uK-&aIuHb>-Tv5PFDE zN`yyIcdLhE90Em(@XU8(`EyR|eLdTWP(_3rJcL~+&)9=Q_?Cxon}_fK5ju&m&_no= zL!d}Gtnd)(JcNgd&`pF99>QXWK#?M3JcJK>2!A9(FA;u?x?4RQ;SeZNgeSif%b#{y z@9TM*2m?g8)d}5@E83u*M-!qzE%TggG963wm1Ze6ycK|LZ^o? zk_bF)nIG#RG&ux{6k)1|aHfZFEDzHYiWFh+Te19gr}e&`3=v9+aI1&# z9Lh8H;1KTg5Vm;;ClaBG2(=!x>utT6o5%zpDmcQh*julQK^b+9~58-K)XY9ct{J=xF!$bHe5eA5Gp@-1z z5GYa(4IV;^hj0cFBAlbmALAi>!XZ$k2xC2j@g71c5i&&Bg}Pfk9P1D$QiS|BV)@^l z*86(Oh)_y|FL?-$p*&*`4&hc0;kzC}IT5Oeu-HSm(IHTz9BMs;RUX1QMCc^K5gx*M z4uK*?808_HLN^h1qV84?M>+(G6k*`&vHUMi>wP`v5}}s}*Let!pgdy_4&fFL z;Ts;pVj>I>q0&Rx><}nY4i|a|RUX1pB1AZ3oFC>P%yS47DZ()x!f_tL1w_aYVF&7N z^>CO&phyvRb;t52oYwn#K0$<1B7DX}xF6*idvFL}@(^zF5UPn#MTFTN!qpCeBIU5y zLs;e^WQov8gabT;ISzp$ML5DkILbpZeJIb^gG0E^L%7~UXd=P@5vF+voeqH_aGz_pzMfAJp_d3v9>N_Cfg(k?+(Wp+L-;fi28b}uLuhdb6e+?q524gU*g%8` zC)e}Oq3+fm#ybRx6yepIWBHp->wP^}5g|i_+dPE7qda2|4q>Z@aF>VhSt67Yq0U42 zu0x=Q2%qo}zTprkQVvZXLaT@Hc_IuD;aCr$ z${|ps2;)42i5|iih!FAA#AB$t)x&WPfg(kC?xtA&Pp9?1o-Yz1LxdYWgeOp*u?L56 z8xWp7^*uPZhU2Z~B*l-(OK+s@B4{kRDV8*clFnGNB$U*}k~2a{Wh^-%luV8#?+PU& zW63|L-k95))P=JCZ7BImEcsa|xj&YCEtG7DC0B)#FU6A8q2!aXSGjVE$fBN5qo9hLV?WbUJt-lspkj{wI|5#gZ?FlG|d*`cQIR zEU5`4xmZ#WO3sfZ6GBO8EO~z@IVqOBCdTjj>0zgK^8HZK6HC4j zO1>3K)`gO5V#)GQ(h^I`Ldkitc8)HdhD7ieAED9yHvE=kna&{~^K9o$1 zB?pI+qhiT!F@C3m*T3Lu`fwMWhi+xmV7Ui z+!aecA4X8q@1Juz zxF?i65=;I&lx&S9n?lJgv7{}OTp3F~9!f5bB_9hV3u4KMq2#n!^6pS_Y%KYg7{AlO z0kPx{p(KBu)4?x7$**I{H$%yfV@X#ixha-3Q-a$r{3i^3kK*{n06p%{AP>5r~iR#QTB z(0u+Hm+Dlc%72Qo_-Q)0gJ}fs>OpezNcH~wUCd%`%-MqP-c236Z0_CQU1a;CvtP5H zn49B%lB%-?HlNYimTTkhH)u||Kk0PbF_W&d@m}s$?G;GPG=vb#OUnj zT`pCGRQYo#^K`ZsQ?gGd+8?b*e>YmWEmbS$v7wAsZrT`sznnH=Ea{VbwWN_=?hBE7 zpISMC@T!#&(xaVLPN2kS<=a=gRL?=@`HxVxH?8cib!=hl89mg2?;D9rO6VUIe6@T!NQM2{!92|~S} zHHSB!<8Cok$xyNw!{jgvxg>i3fLtlmdxcz;J2pk{T_3_Lg{?{p^?oUZ?^N%9JjrJI z|D<>4)an{^zCZ(1@fN*4)S6@G!i4 zww{x&b= z`7`Y!<)u7N!8F~CpA)@)uoKUCM8~4x%dM@qec%n=LAn5!_u%q?xjb_m?F_GpS%BA@ zY??-`!5!e{Sm`qMX#t;-(kTf#(-^z~4xK4%e`&P-{C)Cvxc>at@o5O!s3H9wdFDMg z`=^c^(Nom%$dy(d`_tOx!ZGf2M;=3EBwBm17G_%ePo1f)ed*{o-paRq1~R-EXLaoH z_wZ|?wPDxoXc@UDTfEhGWhkS!+JkyQEZ*wfDB1H?Q_#LUkh2#_c5M40h6MMHz9Ov( z+ieHh&^B*f>{d_=eYhI%8B&~kHQ1&Z@LawV-mjPR{dJ^K7mG~1r0>(pNM6!6RA|A> z?vO0({K!)HlD=if&?1w=zXbSIH{Y`!r z9&@o9ZzE*hz=Q2Uaywh`CpIvHFCvfiZEmP@Q$aV*6tvF>*Ltb%xm!#k{(J6>yF(+( z0}0ScQ(vVvN66UuLNN+KO3A@44MXV9uNq`CjMVnremCFZn4fu$zO)KmXQYjp-2Am1 zC_BWP?EUS7qrz7RW~ZZTjM@9!2WvhFOE%r;bf%Ta2Zi+K$I4Go4c|Wa@6V>aeejKG z$Q!(U@GJj8?Si)tBI8@T50dH@ynXPY%cVcrXKvW|I@Xx?D#0$|3QLIl^Owrcv{wmo zIvE6=aZ87- z5(X8_yDGZSoHA87Q2Sn-`V{S|CN;Y$_-xM~2-_{+co8R2$J!S}j$QAX$VLwnQ9T%P z`%b@V@;np{Thx!41)vsCTNuXN{ESR0z%YCoNgoU{j6UM0NiRczAc&~0Yf12waXvnE z(~>QoK3_*w`3Uhpv4+0V^wr)_tfsdLKI3o(Tf?v1!t~agZYt|G!}@aqm&;PuZ2xEQ zYEFJG7Ec<<9Kvq~J}X2=8KYD&kAJEDQHB2ew*-NWH^86owm=6;?2K~pvR5`k7l&TU zayG9R3O~d!`s``QwiyY$`R>8_PhBQWRq#9|6w?lzCCR7Pkb$%h4RVjMxUuh%=u;m> z4l)`Xkc>_7Q>_ht_UA`|%^j_+3_-DZmRah53#UP~)p4i%B~ zUt#)LDOCBwR@8#&{c`J>{(ZRU^XHf!>#4L*Pnueq9Cjp4em|H4{czi~M;wo){ex|h zzp$qWPlRaV^Ci<4<4n?Uzd$l(LWN>G>&8fe~Hb1#-H+&Fh6X9|xE43Alv# zc`_qGUWZY$$nuOlTGIp_{rNx0&y;su>id;5E_;_~D9?DsIH0E=diAZ!jTu|X-{L2{ zzPwDi|E=F*=*{4D0I~C)0w`2deGsYwlfz;Q*~?%q8aPINB4p$^#1{fH6g-|6y#I%N6)m!0c&S-qJC~hqqNMh~706(sldiWOR5#zqAOj3oI*F16u^O)^_M2z=1KNV$<8{-5#!ucTmoPJ3-whCy&MTwPAgp z4>jD-h-a&PNgi8RFu)z@v_x|n>3WOlZ0q=#P8;F(=P#C@(%G)>g-QEwqFsi(=n@($ z!W$>!8-0Le!~I&J$MDMJxI$1U-gh7(XJa!>$}KkKfzZ!nW7R!-G*ykz zaS8Onun}|+HohQlT4A=|!G$L5?T9uPY{cU(v_x*37T|+RBO~|`yMkiW6-3|)jIn?D zSFDr^hOU;M^2RVekI>G8WGbg2gW3Z)^*YN_hqYjD#>ZYQkL>KvpZ3D5cooWh_$g{D z!cX-Z!T`X=vKF_|;Iu6&?3Bnjiv#&Ayve9YRb-e5fkp{Ic87FNcKvl21y#j&>tu^1*9Epj%0e z=_H=wKoS-66JeDx-|dJnE_F7JBG46<1`OZe1-?UKhxrxL0A8OAR62KI_ut#C$rY;O>zdLrTrVm6^SgOHW+)m*3v8r*`tz&NGqwM8 z^JkAFhG%1Fgyw{ySLnjkHECUVezO?us`&Y<8CZfu4SwtE%nq0P^A}k*;+O|`>1??~ zYek9?sOTPEJ=I-BB5VQ`xX<4=xj}}pD15w|7)-PjV2pmaPs>9I5gr_c{+%&7P_VaQ@;O9?}sXtWi7 zM;$NG(QHpVqwKcJPnGtLjqW_WXPIl`o8Zr-ABoPM&^S1F&LKM0dSv!3_Grl*TkOB@ zH5Mzu=@v77zlhf$!>*mR{zg*u=chBbwN@xsEOl$rPk{cj)1;#Xh2LBN+hGcq`FMZ+ zPZSF}4JwF!u52hY<-m@#N5Fo@Ah^Wh#2`W)j8Aw@W0ac+tU+%{eNZByS70gXIfw8A zmLbcN$Fj>XJ)>MzYk z3zp8d7C2imISZa-bu*Gi|x* zTzebpk%{w`b<{Mp*JibKH4iJxJaM8~5tY=CEgmzzsk#v#WIAfrsAxiaTkC|jRn@K8 z3AN2Nwok0eH8xC$w1bT2kLbb)wk|@weDT~$r9_)rFk^9f^s%U;c4Y~r(bQ;Gb7NyQ z>RjKJq3PB)fq6p%tQmjvk%a671BJFXW}8qis8I~mX3chFYueGQb=CC^?XB5pZhc#u zRRrrmEwJ#hcvFD#+od8ilD8n&#gl7nYHx|wKdhPwGop?(d_!#%(~`wcK$Xqag!QzVf^A=r{nFF0olK&^m|EFXw z7(ageMa=2*P2`)FaZJw4%*VS<&a~;g;Ye z(MIjfa9i|VS$6g|0W&!DP4$iKjfFVb`jxA4NvPU-_G}befJJJ82bIp7&oO{w9!*Dm zK^qh?U%Wz_v+j}-trGJsUIlefnJZhX8#Bm{L1itjur<*#?IxrwS3Xyk5`s0H(m#0^qTtC<|djFK$stYYpPr8t5=}^*Vkq0 zbD3-hVk$O!MB!w`7fu)lF%o6QYd>hMf$2$MwhOJxv@~;UknX%<9c4n5IQT1{Kex3u~uPgwLi0LRuNX1$yKjx%Z$Y=p={pblKFGyj5T_p zi+7jjjUAt<$T<%{W7m-zm9M5FP)!+3(?XV9B^-{JVMNLcFy2T{s)MSst<{Jk+Y&4h zP+_P-GIR=QgLVm^e0%ozXU5K(zhK7feR3p934^AXsp%|#adxTHCa(AYiYD!QX&ke!(||z&1B{;%pkJUYb)9?r3x+}?p|#!&6s3r zrT%Az=9i4#=rln`Pc)G!Z>Ew`s<_5Kwzn;l6T7fb40F{rt8A&0k%j5cX1cd6ZHDAU zr`>CLt6Rg;R-aUOVS>Fd;}owQ&&jqnVFZWDPRcB-N6cK0fk$Sy@z9*8JWRa3Bj&<- z*m}3+S`k6yS`n?N%4eJ!=yy>p-)Av}`dquJK9_B4WY}YHKN8?Bjph5qC0A{`aVC-} z)T*{ig^g5e8mckpTtSc1CV^lZ{2JO(uM}9{np|vFA;0q$pR;eh8vEG`H;j@s*%quP zV4_KP#@QR)in9m54OUnRE^^@7@Q==g~xXRtoD4mH#+`R z)eVSR#5hc^5BojB!L}ScP=O0-ZEwPi#nL=oHO2DFUHW}xe(wbnIpjshRd*@V>~Ik5;! zX=QUW2RdV(lS2P+mJ0W&41!tvOj?e1*hZ`kVV>GrSa@Uer5J{)UFqx{#G7lb@3UYw z0{)oZcY)(H%rN7WHjVUD`oS6m$sF9WP3?_3os#^#q$7g!Kaz!$P@U2hXsxBbrrEL9 zF^fDF@bcS`W;$axq2CZS|g)D&F|Gs%F*UZ zZwS>r^SOG$H`ZiJ{JJe>o%pBtT#HHJH;4H!4S`#Rt2AvZszy*M%bt>d#v%#A);6~{ z)N@YoVGiZ68Rvm#noBpoZZAF8&1t-LDJfBZC(DYaST)yHsb>+tM6KEY4XGB`fc0~H%_vfWfZYx99p{N^Jw4d5MpL2F)i#?P zPz{a8CJ=>zdWHBiHKy24YsqS8C86eL1%9wdghh7jYGWZVa+U=9#x86Kv#i-fWTQMYw!G>Z*|Kt(#$}3H+E+Bx*Gw(q*H-Lkz}MAI#Zqx=fCE|m8dw?A zaplpEJ7qB(9u4b`y833?Ubb+w+O85AV}I6fmDoVh(C6yA&s)V-QR6bcrs`!{QB+fn z4!&&JvZ+OeG4rp&P8NK22K!S^gY;@x@^K!3+V*EpXjW!*)Cg=1{hW}OlxYGF=Yl*Y zwtO*ig3cmI*SB$I?$V#thXlWa+!jX zxYc#&cO_Vh%VOQwIEy6;P5x>}oDg9>1v{c>>FS31l}+OqS#zCUwW_`$Ua*zlmLPG& z%*_H8!aX-}l!7xw#WXx##}Ei~St2W%UNoL&6EVNjgI{bsz!Z+-ekxhYV(`o9f!z)m zZB%XJ^2M-;HK#&{%B@v^VrsqNnQiFW+sYl+Hqm2F504aa4-WfsU(3&Qn!qCPtU=K zeiJ-l8Fm$}V{NR*G@eXq?ZxZDqwDJ?j7EEA@jnvODTuKPqeR&=(R%T428g#|lMDeD zSBEV_>LXq>@2}m0inH7_Mc1z6d!>xaGj>?e85fw8f`Qh_$h{6SmMAgnG2gG$~XO%n|~gr z(J;$HM?!clu{a||FOhM*rrwL8^1}X%C4E9n%#?7=*b>mb#VS!a2|~TXO|}Mv!WiAS z;}*LPmx1Xgr=-uV1+~KT)_E8^IVB~ZTh|F)RZt%5mGC>0F|FH2ndDhgg8f&vlk?ey z4K>#_6w_Deye;0gO>L*x`E!Go`E;DckqXlhV5Mv7*_^a2&u-G%hkL=|a3@WsGay`Q zbx)<#ZfL|om*4cpqE64B=?M+e_E{n)Q z!?=t(X^ebaip^qPh=U6>P2!Z4_{DJf-}u5gN~5xVHII1siN@K*)anNKeGIULM2y)B zezlUa;iwIBinHS}*DRtpVjzcOO*O0V1;p%zT?xkaTAs483$ZO0R&Y)IWd?#BIo%{O zg)x(C6q&|QD0+u#>*(Ehl8(dJ0(}%2>^Q3!I_hh*v0%UXNUq$fY#WCJgif5X;b#V$ zdptRyik7(>E<&HU7BH9mB}i@9%i$5ze(C&G=>_F_MS_MNnE;Bl1FE~O9;>e!RC(of zm;z}p`zlXzb9)qny4F^FBkY5RHF)ZV2q`pp*;6ojxT)!E(J{sQD%UR&`egyCMO)1n zU+vGJmzx&cJHFU~z}o;hV=TA6j&_ShgQCD@+ncCH&7o$3n3VVnab^$Rr5#fM&S?RD zzLdZQ8yZqrmZ=`+a1+$`dam|}{BXQYm8$c)dQ1t)E%4=u@?=_2q9-9*r{~tSAc!#r zvN~QT#{8Vq2bZp~zP8rQ&sXc3Eb|qn<3uLL)15>9HtPe`<_HGD0SY$?M>RO)-v#t;*S;*!2I! z+;%_(1u!PkmW4rL8jUcU%Tl&>E`euXsvjqr-o)?&f3kP7lp7`dl|TqJzLXkIPZwx> zDK(y+F3|W=YMkkuz8yhN$tQ)nWqMhU#sV*wo^^WYT1qO)nI0;S)ku5(Djv|8-wv5( z;KKka$IMh4>p;rreWq-s8|jKH97?=)vwwr7)^7<~N4kRDCE^A;4n&zP{MD`T_jrq$ z!H?l#6C&Jc?+~N0SGWU)n);REuw7qg{f9Y?pggobGO*)(Qt_A~e-QzPjWAb3#OGE< z)k%mI+4fW)!I+YvSBX`EYOZ62X-_SOCMKc3O%-@&SsbIAHem)mwH|}0mWs1VZsLL7 zhk=&?x*0-rDx}e$RvuAC*p3&+`kN8#;I%hNi(=Wq67&OpSElhrF}kaDU@m8CF%i?T z90zJrL8<#JP#Z5ORf}wuK`E?LhpCjY3o~w+l4R+qTBpArk9}3n*%$Y^O5zIYCYZMB z{8*2(o12O_zvclGGv9U%gF(;E`O!vJ3&wc%QchfJ*&t}fb z{H7#u>(IHYn?QQ{vh%@OxChyT;aZwyHA|<0ykPyWE)zC1udK&uNSn?qWig%3E`2l! zW7GhpRxl2C(y}I-t;IGCopijM6%l8&xADfnEjf$Ne8kKWCr>m>M$CtC#+3qFp#@^j zY3O?WN)}_*X^e$UFSI$%aC!EqvA1zuP1&_#hDyY&LaAR3^})KTy~Nv2DTOogaD`$z zDQgSlt$Bm^$_*7*v(HW!TbFv;dHE~`GqX-U*)A-}0n1`pE=#W3F(+D_NF2|+`nq|( z9stutDqW+AZh<=lcCPeSRYI2exlf zi7XTsom`ah3RG?iZn{j|zjZ2+TJl0InH4krkMs6|`NZ3nEsD|lwPthe*u>J{R|2+< zORVB#dcQYpuQC`w2_iu#YhnGA)+40^8^#Kc{iw%2%Zkf06R_&WpgMM+rliD8(F#() zQp_LqYU5O+f2<**ZyDz|*Q8{+87^p+By!6Vmce|krhQ{itJ<;pAz#0gFmUd`G6TyA z>`;o*wHk=Dy%y+PCDcQJD_uWM&j?!o_JVJsQH#$=I!-Tf2&XJEtqsk?WJEvLBH00a z?P!fsRKx@8P|kd0X!SZ{xIkw0p|_??AB{i1J>)h4@u}wC6(-<%fZYbNH?qK|1vkoY z-hjeY83tVEFrwfl70qszMSGYtJT(?_S71!VSxvK%7y#O4HjwUS71LsNUCVT4sFp=9 zFgNM7wXd+p^pkhGFkwkaZR@%coQqRl3$m@4J2Zk(4uL~M1_GTAV8vL^2=jOWPI#l* zxUs8dwVak>mTI|u#MK-JC3%-!p? zE;hJ@3LJ6AASyRKAbN%tc)Od;u7Nr8VILxmZ;6Y9K$+&TUV|XuF5vFz^t_exeSB`KoHtgi~Ik$cE@{Uy&-98?Ule$pGonX(@ zA#7=^uW3a^vJ8C?^Wc6$Iq$#WgWTJYF|s} z8Rq6wbDkbyjj;qdu|NncL20*uJt(>v=_#D!MAm?`B;36q=EQ|n(Gg=225s1lSyhdd zzZKc6>8cLhDgTo8dK@9rvdp-9u3S>=MeUdna0`{AylGn4InOgoBf2U{FSGW1z>2%Pn5w#xBJ$!FrTPNKQG@@kFpG{!$DJ{1M9=tKqw$38i-_h5^c<2dq!wR}J}1=EqJ*aK%bz}1-$7u7H}^T3BrH{20L=0WVyR#RVZG+sfK$sc8lS)SS& zRBepGVraJb1R&;Lvdpib<`!-Piz7w6yg>Yl73pl#)mwaww!6J;;A4I^iP|NR=~Qt} z+)8Zo01Xz|dr7d~S^QvI2LYD>Hy;lAi9l7C~Ls>~h zWNa$JP3tAtRTImXNYncnWulT*_|1ApB_E4QPT&vT6t5rCqmuLR)fh`uaEl~7FP{(~ zx2n%by`3@Q{en?^!(imyu@{*;@>^@7iYDCvSC%H;P{z35-g`uZ-`{8#@JTu>f`ygI zl%`0HD^s$n$f2A5sNTw?o*GTKFe-`a+fWw{F42h{g|)=3^|*JO&2Ej;mLx4Dce_Ic z9JUx)aR}j0oF}voqsT-jj-OnI|0eOjiFJ`1?J^L->%rLYfguoCQJgT8$%(1EiMcT( zAc*4gG(g6Lq2ypyR0CIrVcD19i4BuZt3(IXr#DPGO&;G6jkSLn9Q%?daM)--mCxZF z?H)zq(9JDk<_GQ#v){O8XTEc?Zd1#_P4feHRoQRu%LMx^UY9m$WJgEtSuz)Jdyx62 zx9FH3xQE7klM%#x$89aE^OfiF z?bUVI4{M5ML>#iGd(9rD zj277|a)L2B$NtpCD%lcki#nFr%X*$6swztMvDJ45lPR(=<3uHz{pUNYF@Z274>8BuxU)+yk! zmxzelcu|Xd74H>wtc;Sox=}|qf*%O>P@}R4)rI5Mh3KdzVtu{U!= zj4%q|#tVD8I_jv2ugLAXdTu-FIL}_UC(5G^@Yl><2kU6E7tP7`sH4H^l2#F~)khs_ zD`pW0y#x#RQOCK)vI;IQ6ua`4>7tHHOv>OQEKpB4nB}vmV^M6X?pmACyuSbybIev!LVqU4Kjrly)d=A*h*+s?0 zm6Bx3xB9XiCY?58QRw{ebh_L} z&B!)sN^%6Os6kniI1DbwLVbO%t)hnXYs&Z+S$+!&^ca*UoB4JyR()EY-6r3zg8a6g z_7faV^Ysg!*^0MUpW_#eO}85lf70@~c*J7|f}#C`wprb$KL7PlKIe48glNLpXzT=h zzbv{ea!*~t!xp4I-mT#!{^7&SmYjG*eVZ@Z2;~C z^%rq9sc33Zgmtrurdhnlpn|u|isNtPvr^r4b#jZVS4fn30VCxO%|0F3<>GkEVL0K} zC&4Xf#@!0IOJvl9v7^j0TBT3~&aIHSyvd8>inNT0nr3tn!tIqAL08J49CfAPVrp8J|8Pj-+O0$gQS@CG8^)d58F^ zD%uD9zV)LWAX~dY7wKdo{tmdmjs3JVw=k|wD#`Xm=HGk$t7|XD!?u*-ERL>->}DcD zT+I$#QD+(zQ_!@qOdAjX@58=pa451htsBqaxgoKbG5g?$_Gjif@{~@@TF=R@Tie`P zTc|%&FpXjNL>-r&__B_R*MCJnx0=tt+@`;m^=llk)1+s`hTvb`{^rXiy+1epPWFd{ zvdH3$m=uqP#3}ZE6UOF8xG)prp_0ILJKmS>CHfPcB}U5;mwV+NV@U~} zAc$t5$i+l1?(s549u+YC3H5DDd6S#;N59MqYLFC56BmuaoB%-}0zv*2mWp%vP*~yB zlTxpKq9{7~WN!M(bV7HTA{N8ZN=CeBc`mA$w>Ua)euYkt6Xl(pid-UfCqK>$sMc9( z8*ZwgKlkca_35q1Uz`Y-HRdLeJkoa-Ho4Fx^y-*MwkQ`=*Fsa&s(ar(!J}J1W}LXH-h#dupl8wbiD!wZYOhS|6z( zgx>b%e!u_!S(7~{|NqP+K+h*DzkT*z@3qc8=l__Q+AqZ7vFQBsi*wH{&Of(kEnjvV zS2upCNrOI_I#Rb0(;d7}+q{+Qr1lHYk*Ta)S^v%GBMYlG<8NI^3nSc%+)rxrbXV5wSB}Fm9OYn zc>E^&y7THE>6woSh|6|dU0&O;@6lWyHCO8Q$R&Ks!_9s9s-*19g`yL}l;H_8gvzYFkA1dS>gfdemlX z4@9*|Rn;Go@T2}gCR;_dad{WTqpr99li~|~<3p=k?XApWT{lJH+0pWq@s;lrT$V1X zZU3eFjE~=f-DexjpU>7@lg(poz~>fT<9oS(_r!Nbs^OedtM_qN&$Z{(u1~sf0e?qh zU`72$pttk~qjvda8ueT5RPF`G-)qc8+})RM*?i54kxP?qI_@f~-=B)~y5hB|cVebas+KTrJyNibWb2$w+R{pdz-<_F_-eULM-d&hpzlNfMx!{GP-!{K;4D0 z4H({A2e>W|vx?X;q) zxjbLxirVtwarPaD^K)04%WtT?);Ye%Mn`hu@+-I0p8ZNEPDXx7?YE!Q{WuxxytyX5^?36aBrpGw zT8<<&8;s{4zdN4yh?=VyPrl~g7)qMUb4mN9U*4`=xuy25QNuTPONo$_~lKA?g z>d5C2<$g12>p1>B;O737Z_o1LvK;Z0eSDsp@4xHoJ7?SGuH3O|kj>?JKB&LtSgU^h zZ-<=7{$20iG7Iyzbd7ujoOQ=o*Uu<-4@#C+_H?&+&Wz*+_?D4dWzpeIxVEMUR6k;s-vVXD^9Iv8z{PmBI>#xOY zzx!#_JC@N3&HISR@e|vPl{A;b!a_?W9lFMjf?t?yW(l{ z`qj3@D>uYz-6lQQTz*@hKU>AVTK`!wyJ$t<#@>P26BSQnJlL@voUAI|s#v+VQWKUtBx>dgObOdpqi%H}*ZyUQ5i~ zC4Rrea~`bEf1<>=0_O7Zwa4ctT~Wg`f31$QN{sIT%zA5m{u}4iF}_E4Fzhz@9^FK~ zpLh}973ipa$=@&FPW(HHIvjqiE#rvqHPnLPzxY1EMHjWLh+gQ=KVV(8^s1%Hu3732 zzj~BEpt!!XxM54Nd2`XXvFIBp`nMGQ+lp>}fbqs++YNb~ zQDL;&}g+EEm57?fVikhP5pIQ`` zL35$m&~#`XG!t^p^Ept0TbcrGg~}iIj$g9q&(hX@zV>W*UkqIiDX(tzI;WmMbxBoy z)xQk?B4olBWoJS97e2eT3~Hut!N`wu*ZrFe?@J){ycAjrT>;I2j8$Ko=~|fok#l_a z7*AisoZ$8QigDhCoyf1Yoi`Tk8=H3mWu$73!jDFO3Owg`yr9%K(fU^9d(d$r^;F)& zAFQS&oBo`2g2x<0P3JQ<2T^a=gBXtbL2S>>Ntg4GIWu?4d!Dc5He3s0c>E7^I|td{ z39>&zuP8;|6W&Ii2u6M})nwM}EBoI1DeHOkRn%R*j_oza*2nRskTNl^+{++!L{D78 zSXuQOS6rv+3A_2&Tt<(n=OV}$VlMY7;*R*n`#Jh&qeuH*N9t2=qgcJ`t%R09-suvg zU&f%UbvM4)7u0DE7D4KaYrE>7k8`{)QU7HSU88>4#Hf8Je2Q9X+ql)OFZyBb!d|oa z@S|EU<+V}kWAu59`AZV&EXCQS%*py^J)>95qkfo2=Zr6pGkmvB`srGH9uvO$YTe&; zVN=I1XprY=@P?h}vFOJuSxfL}+q!AjvAr2%*Nt(ay{sO6RL-&W(5~m_L7kA-r*E&{ z3~hwEp#=GfzWbGYaq!GB{_mZDIqH!ZM|@sy;fpzoJj9+NZ^Uklj^kQzt=cQWU+p(o zlSEJN%oOXoLx|Y%!AjIwXs*-FYMvi4;;s}6FqLO>eR4kT0s0X8o3-@Zbr0V=@wy)Q zgEm|1zksK{S`^QOPkqL%zSxfv49>^i9DU)uy5m}?)+OfEBX6}vOL}X+b1qpLe{w$g z8&$ZACismn?g_@BKl-39ZJJkgiupBUk6ysMYu@A3V=X<8JyBii)<2Ks@dMuF)i&}A z`S^WJUF-QhZFRQV{ulA8*E~cWBIgO-;E8<2HRZf9giOAV#63ry@_q0W=dKcf8c z`L1;HmTjbWfG-lH+OHcL`E5wGUz8x%=%ff5ciPa&vR`LMDOM`%JXeLjmO^6Z|moIBRTISlHWh| zN?i|aE6=_E^g=g6^{e=}d=sj_e{I^dW4}lMW{$J57rmhW`Z3mhCUUB()yhTFE}oJ2UM24f@(sS)b8Q=Z#_PS+_~Jh6*!UB) z0%~;cjhM`B^uB&YuS8AsNnhhQz4Du?`0WDxlIeba;|*`Vb#eW2L;saEMR68}6GBq8 zznCh{Cx%NY#({D8enQb!p-(+hRoCqV+V!6C*ISPA-Us$B#om(N;aOx?QJltHGrhSj z$Bp8u@-&J`9*+cliw7Vvh+!=r(pH;$((*bQW6U*^*;>jh9z6CMhpFNX%Xr;N;~)4y zQQZ0VdaRq@P!zvO><=wHreFDZ?V#L>b^J%3tM_u{)>G5OvVK+N%xODx8+9_TxvkT7 z*7F?Cu87xa5d5#>0=XZbjG@Z=uHWWbeRKont&@=KW#zfa<<+O*f1jv2XliW#4!;Ipud@jpXb0Ci_9mhkdW}Rc~p2oyYYV zJk74pL$51}yC380^Ihni2YG#7MSS`7c?G#JB^#hEko&+Us1st#s*&rGYjNLAjHf`f z!^mFBkl$KYe;rCIjL4{KGo)-IJ&Ad#k-i1Y`@E)YWqoebuke*ehMH^w8_Anz<(1J_ z%2|8vjX8DdTPmrlBbVp4Q1c=5=!1H59j%-@ug>8AcgB$q=go%{`BZ)?luD}lz;tab z=H(0BCsQ}&b6w$Y_^4m{H(t$Psrh9-jKSK3uBdgM+r)Yt+K*nc->gUQ=4-j`1Wypd z+L6a$ZPmkeTGORZ>hvBLhx>-})-6Fk)_L9oZG+U&2PMdSbVA{mz9<)S`tMkZS|-Nk zKppbxkNTBOP}pmv%k?RcYvHr|UG8t_c22(n6XUAC%C3ZBubjqMpVeWljMv3Bw87jb1c9$r_oj=(*^X z$YEk_BKEH?`Q)|c32M|k);W4np7S7mh`PIPMeNo^9r7fonIEpnXTHp5Dp6hboAYs8 z#Xx(}yJGZW$lk~P5B{iO_!4W8znG7@dakVTC1|WZXPMu-I=+8lBWx#RqQ}g= z^NsEYOdqGe(X}v^j|m-(a#r;z_iYL?)$1hsMZWMkay(X#Y9~QnC)P1~MOlyekUY)$ z+ge908pRRy{V9B|M_-1muor%tcaLR|{MOz4MNB+ejPy_RQYv}Wk?U7p9_JiuQ!AUlet2tfHoche2`?tM>F!dyxx< zwf6&*ldM(f)VBmx_hkK1r@F$Hy0xXO^HS)k%0HUiqPDmK3V*}?c-MixD3hSbuX!*> z&O6TQpE#caS(oa4Oj{A#iR37J)aQ`T{fZh!PpaFTR{e6XmGoKP8}(7d$ntUfi1wq` z!jIq|FDI*zT?s9M^xe7z(j4clH*#^0;eR<4tjMbB%73ExhpK(6! zAI6^dYvlLenGd`A;#m99^ZKrz+V?u@EGc;PC6!d|0j6uuBGyLIXEF4|d16j#B!3n2 z+LTxHTGAg$KT}Cn*{hkqACf=MnL1KQRT-v>@#I?J315s|efFFvY0ns=M$YB&dOj6O zB~^WJKIR--vx(+k{#;hO6V1J{9tqO-ZpgTlwUPlB`?J>_}6mg{yc zh+*x>{kP}zqZ3kh>@5sOu2c2tW7I@GWt>kXdTw3vUT{ty!)LE)?Ko%LV#J{?&l41U zp(}Ef>#}B{EBKV10;wyHqmA>>8TQP#{w1jT9OIlm+Y@11Ir)`~Jc!|UTraLCsF5G` zy*}%2*bcuU2JI!NS$y*U9E#k9KI;>{#It=Pd+NWxKAxcSAZ@A7_3C~*jXC#R`8*av+Decz%1Wt3{qfwI z#{76bhQ3C1Kuzs98N235AB;=1?$JBuSi5nYjQ(mbo2y1KB<80;<}0q1s~AUb=x2iT z(>eVLpA%#I#yR=AA&*A#u0<}5Gw*%tZ4O+I{&GF)q&<7oa}V{)@453{Yq6dfH;Pjp z_1n+kM>X!{tm&t*#5G}FdSjqo>kCFXc45{i=i1% zg7nwxA!L=0+SqIMgK=m#jz{~Psy%flNMC;rc@1hi@+E3lzv5WJz&Yhz7o)#}KQSjw zf%G}{6o$3^S-Vmvq;1Ku6h0-!jpSD_uYG0AoBk@7N~+3?#qYDF*N!^Ox1_F!OJAl! zsidlIrfX|4FW)9;qWO_Om(`Dn=0;hM1es%H&4;$tVGP#Acv40TYe#O^T*|B5^^h{k z=XJY^^ZOz1zphE18?P93betgj!a4ntSHJXA-QjP{>$h{czpi<%d>5oXd7O8gpok&& zvyJ)K54EL#5u3V$@p)6tc5w&ujo7HV*k>oh&{Jwo!oEi3-g|!@%)dt)fc@G zvgXd-l+-K9m!R_?`9fyAXGmB_JxA)7F@-*Lg|FHTA7W0vynfYsM*b6g%FExZuIlz! z2!;J+jAO5keqK_6^vtl zj2=-}O7Q8kd5|x1!?5-|*sK>5>*gf#CtvJMuBk^K<YwCVf*RE$;?+*GSks}Uli9DGz>m9jcSUdDtS?xx@ zD)R#QdgZ`jm@4bgaMDC_z)8-1lXiE9*5MeA=k?k2Z`+y{>tU$ZtO6Z{}O| z9-rW?`oPq<`I`rixzJA3K60yHjdGuupJ;C48S-T8gdb6>yidXhbLBXC&-}$cV?6pP zPx#Tn*tnt&iE;2a)>b@!TH}08e{wl_)g68|%U7&NJtpXGDEEE5Jm%LmU!$#Ei`vkpxk`}w zVlMoe!kpuY+*cBO(N|Fi&y_d6*w0frSG9FL^Ty}1o%vGMqYVmKuY0d)&*Pd5U(J=d zj$B3$M2yZW<9UMe{OPajArpP0&b*cA4!7uN*)ct?1FVdev{-lH)uUbK%@nD3w&T?|jTTwtgpDFXh9p6RDGOaU=%jQ@`CaLtoT5 z&t+mgjy#5_LDW)Rj`Mz6!nwJMepykDJ3)EldNQw$y?&NKjh=5pe`0+Bq>j)VeueGt zux5@W?c}o6=K^i2&w4~IyoN$X8)3^>oF{VZvv@vl-)S%GoX6N$y#}n$c+dXkNq%!0wHMVHds6gb`0x;G)gBC< z{5y*ijZy_$9*SB=?nBnT*2g%;(qqk{?-Ju?eI%c2!E22ABDtmy+SP|R zmM{qY%7qSlGG*tEr$F*JZnWoUTbu3++RF2|yqt^uQa{4pjpbSbn_aW6xxbiS?WjLN z*FgGgjP|qpc$F;-vX-SY*I ze8Cg>b}sV9uy%ba7wZvkBl!ehz7Iw|&4GHwh+BPOTfY-D1v0+8UK7n%ZY%aE^+w!b z!`Qq|^ZXf8tWRSs>8tbdd98UKxer@R)n1<(ORg_*9y}9`-F`Gj`Vqc(PhJUm57MWL zp&3wu=0oJZJ{6gO5V?d%Inh~L&nq0uJfVK@t5KKI;8K$6+Y=p z=r?b%-Y7>^o$44bNBWw_s1A<=eTp^LzY3Wj$JXjzDB{#N*R-Wf5X0JGjP^i+av9I_ zwcM6#K@4k0o-1pk9}!>ljB!MN{87nczRaz;ldqc3Z!%}EMGTP(&*e>6*N*nAPt-Qn zjNdiSUGrR95v#t2f7+2JY*hKxA-}Z^o`^f*`rVSpUeho8OucbU>96wY$@Ap(6*Y3t zbl+G4Ert?Qwex=X&7EtZPn-6F@t$ZL&2p$dZ8Xcp$63#x|Htzyd~T*M&uyL`Yb0qe za<7i)4QpdfqhG?OcQKde-aSZO_3VYzk*~*f?z}zbnt65qG7tLTn&Z3&owL?nC+g3A z%zLg;51r_10!-KTX>A(6zUY^B)F1WNAAJme<&7Q_J(pj;dm#C8{ye^B{h@8;8pRm3 zfaQPG-^fW^gT`U~?2pL5_&@De!r)kWoXB-y(S}P`WJoVn%BSksy*Ub9PeeEI8j$Kf8w4Iy0ssBbl6wk>pZWOcJx#Gj^jGj zhd6$Zv9iwTZ#5?Cn_%`{sD019M%3rL*yx@S`(5No-s;}VRPDJ!z3MT}xW{NC_KbWl z)4xX7NYu`}_&lN>V~YJFu50aBLoxELe)&D#52{NW>Ir${Ft^4ZdHPGn`V+m8kdIg# zhYivDQrM}=C_i4FgD3K;&SrVX^l|%ya{BG{o6AN2G}C7s_LY3{c&;ybuSZS9*#ESl zoHFJv`d;})eehW3-5$`sK5ARvt$)-`bj~_Qf95qj(bqnNH1Z5-{f#mDO1}&>Npp=0=fiJ zm%feVQ^*J34EUWJO9r=!h$Hv^S;*!7x59S;bNb`jRnT*x+0azhQb~>CaxLZ^KbksJ zb%pOIQUhG59f|+-#hA?56Ch)9K8Rt>_jsN4Le|ZTd3{dFYizMTQGLGNPLMUSKEDX5 z)4b|Oye5IA=94yG0GaPAA?56m@WI;2V;r$&Z)(H2=z-H1J8yq$>uFH%m_x^5C;U>M z^HIa_?N^w82BZ&jA>b zIL4B>wA616;&q7mGcNOy_lQ16jv}71bla=0hyS6!nT&bSo^i%L<5*wZ8zj&5&%8R; zC;Pw}c%J89KK+e4pXh6sW`1g?S+32CIki6`mb~W5dd=vYd#3(57jkDJj@A3A< zld-1_k4De%k9Ay)`ua)4mGAWlUn1Aqx2Ab+jM03&1Tr7i*u1I3d3im|Y4oi!iMiN& zr*N)}vLWMoqx|KyfTiY7$mV`&%RY=cH_Dy*m6ca}jq;)2S3xZ$kGW9h7a?rpi#pUdU(k9Tj0 z+UuA14P&#n%zxO9UW*<&ndjoMo>h%=9`qc@dg+t-IjpFZjhY17Puhuql8utB6!_P1LTw)V+A9M@koS!8~sY20Hc|TkYkFxQ3 zm-6cAgw)}@P^F>a)1KJ!0@^yPY}8}c(0KMzsg4 z%XIDYT%W(zL;C3FHt|`Cvf59O&%E+^ZVVAyVjSP6lwaFZp;S`Urt>l9*w2YiB>%ar zpKTfAiR3)N?~$OWw{hu%aT|*<8jCqe88NK+9?!RVedN=(Sj%<07R0c2RO8UTdF_Ov zSFCgNSQ}$=o}ipZf9(nVwa@fjdF?w^M$CITK0CXQd3mKDmpslzKBCX8k@LnYZ-T=A z@NX$|_NevO)&o$28a+ptBjZ)S{T99&zp~mg_v#8gReOKVnlal0#;>gQ^Bfqr^9j

giZ(-ka>*`uhiN^TyQ|dZHJ~8LKx{brysXswuJwH!lUA^+ev6O-KtbKwS*>~Rc zh$(8^%bb3A?l?gcsaxD)TB%zj`i8R=*NAKafJ_4%Jb;G@!}3S`^>SrB0hC%FORiR zo}w<(;FYYcejA^AoagE_?!3o1t$puC-l(Oz;u$K>zxk1GtX$-Nu7Y}>Z4>HwBunO+aP1mH)D_|#>SYS73G}QiL&~dAmegu&6G2@uQ{cjQ+33l zpVm}6%5*}mOEDHxNmD@eMV+r?tej;2ayj*;3RUG7vL1d%Z{~81__c5R%0i6rZ=pv&q^PI;YYklwK6^*%gsQ%JeFU$15~NR#m6u}PSlwgQrA)-`I6=zg zW98JZUF)naeM`_3DDT5I&eg3v2$3)^b zFX3wkWBt%>g0!s;b0VMfVXK`k&=m-0DftSiG)Rua!g0 zIj?=!qVGBxhi{I8ud_IQ`*r_^+v3rC;UjPO@Z_$?iJ+ zrxLX{k$l88t(<-;6L}D=OVlRM)ima%nA2C~tF_kuILu4bBQcJiH)iJ}U)pW7Z%!mP zc|6g7F&DXa-h3r!6|@ps1R2l8&F4SdD z8KX6F-8JKn+8t;0rVs2k0E{dArv~Q{Qm93v#|XNc;0>jeEyv=H?s$SgP)B-F8BFF{w|_< zJCWQON5tTGB6)*tl*|vXc_;J$6#Juj3qSsyv3av*AA$ZB`YiNskTUZ9KBNwLZ-?UV zo|%gc&?%7qg|A^pefEet{{m9q9?1P*CA0)u4E;HCAA|k{x(||1pAu_TolMpKM%d?; zvk${F5ucmI_6+M<(f3Jo+SB@=UwQr-*$N%%QMM6}_Fu>*_3B;qJRjiPT$+~~pe|?u zWG=^hu1nbQx|Ppb_;(+Fk6c78mNB;$S_P@oqmfUI>gwNQQ+@^111*NGgO)&f&)2o` zT`}exU4QyDQC&}fH;!swJQ^PpN~^t7t*!C-_apr~aQgf~{&u8)56xT}uls~YBRQ{! z2cXYE_NskuP0jl|AZuy<8|5whO6WGfUO&}X{X3HSHxGInl%fFTPQ`YoF+xF{6 zA$@V&=vw_P`eizQm(Rb?cRf6fdc&AKv@OpXXbaTHM{UI4z>Iyhi@7&K`fYsXQyp=b z7pWbp>eSA^;-h~fQ#tL+I|wa;yj~KDB8QO+byxlMekplRqr|o6m1fTXv8PQWhWwtK z(5nqG?#)B^Xm8jz)*`MG=iL9yS;T05nq6PU)&}Xn_h9eICvt!H@BF=m`&RUGwGNZN zMD2$8T=r9S{}cLy8s&H2-F)x$F1`o-ReJO5&3VuKH212#MX~$;@LlE4HRpR4wzq$6 zwEaeQgHPXDAwsIX$Km;{__6w%C-!-9v$(^ydYi@Snn!|K{_3axcb*)uoTKIFF+$|7LVuN}rti z=XHC{VeMv_!zN1NIssA>;O6v26EYipHKZxef~VwI-$63Zf5LjnQkaSaqYG< zmN)Vcx$ONm`}-&O{VPx$jp82hi~J=R?J?17<iu`_24tZ3<*wqDP`0uHBE%t@c;h7oNWre>{S3fIKJ8pZ~@BH8`2R_*7|kkhO^A zWz02-BkZeVKRouK<5S7?>$nD@&muP0w0Rpoh0jbCbLkEDfqy9ba)AB7vAGW)@6sQx z9d$&nDC_YE_6`!?TzC@ajqF8zy)M1RR+Ec^?1eiycf4y4Kd-^O$F6(p``%jS6X&5X ze5v+?Jduk$E_+kzhq|G$Uc)BVqgK(oxsR@U{^PP27juorv5LV;Xc45ni=i1%f{b_N zU$MV_`q;HsjjvgcAznL-sSPrY0q8{TV-eGvxmVoF_1@@u)Nfy(s(%yI32Dcih0VlR zYLsW=mv=MdzO9Vs>PQu8B!3k=VN-N}(Vy#}R8k|kg{=8GoY$bJ+%`xbw67njq(>v~ zJyX5<6z@+(UPRY6l%!qrFcnHARc$*TbB>jrX#VBTWwjkP$I3lyHGj;N{N_v9sF`zl zz7pqgXfN)^_J{qaT!QkoT=(VWx;&DHyz(T-T7{nL8HfG+`n|fG58FMQ2e0ydP=Y!k z>*84b_MLMPn`2{Bk7H%?{+7>q=kzJBapK(iIImoSB98F&tIX+(dLpLiUGIx4p(W5_ zC_(yRy`u)^)cBPT-;Kjq<#RqkRlBR0(@xxz)vJBy)R&-6Xd>~-o5wj(IqjI+{5j<+ z&h^{4By|}>#H~M(r>Lhn51Wy@@!|`ci;#`$Coyi;CsE(1W7u;(;?Pg$gSXlX&YN%R z9XURau`}%!Z(dVW){c|4uYZx7@Ws4a zFOQSeTfIiiSMGP>djFqjzIQl)*thI%2O3 z`Mh?~+tCk^EBh{Fb9+mem&blEmpNbJJkLe+r@rU?BVRQ~%bC-jzL^Vs)+hZ_K0)D| z{)BH~!?~O{@+n`~p2+v6tgm(=XYK>)N>JEUpMH9tpzt%+mDR3mW9360WjwBg)N4+2 zpL6-d+P^^JI!HdR)lNuReT{k~##11D%lq(T;>&FsoB7Cl$ZJ4~xW{^Sg{^j6#sA@V zVr=cynd_ZMjH{4Y2`z&3;bLe8lpu9^ZN$AM^2<~$CvBiUTLbNzs~Au8^AzP1WGwcn zI;=tTpZctm=&=H_rg0D0#8_F^owG+h*H`!ER8qB;OPSYab>9N1C(f01tUkx`q>`$7 zu3=s~<|_O)c6I8h?Y)!{!`hMCHt*Ied~h7s>{X1TSFDLS(vJPo z35ASy6C{tQUFD2JnOB`sudn>_`Ye+mdAxU9bLX_3pxi&#!$)Ha-x${3o70!*TWhN> z^@LC1OXNkLT+^3`qiWxMY9+J;S_~y9e9G-FWj<`_r}jG`{c&E~^G>P9>72PpP_wwJ zv0BGw{Igh#<3#<4+*JLD`S9O!W3uLPO(w?rsjPL8$NY)r)VR$-?q3_{?xzvIaj7r* z$=WCr*L&!LExaSt>e8o@V-$Nl>oebNzEIdd#`#QT>oV z){G}=piiE=ZrpLqV-R~w>|T`Vxq`lK2kL8g5g)Vh_u3dAeZS{NZe1goC zc3gK&KNA$sNyg{7c9i!TaZNenGwwL%Gl=UVm1FfO6LpGfC+t`Y$NH2YeTn)xAJ>=b zo~z&ZpMJ_Q{_rE>X1R7$^P8A$mQ(vhyTPNMo=5K)e_YemyjSBkUVT+2@+UeMxp1tF z1gY0O$NWaGMBLMulcJXTBfsbBH?KY;TF*F^GKhR9#@aNN>b_np&&W;qW-Zij z3<+8Vd0(wQFEdp;?9VnxTkcQF>U)fhDM2gBIr9+Lrt{`b|3gN*-hUGqc@19|Ft5Il z(O30(=%0G@!N#8>4xGyXpD_)GCj(!w!*g04cb>%?6nMQeeaxWRlQM5*UTSZ zwHT?Fd5m>^(Z5vAne%^xehxXW{scuWhFGkFjzSzMHT6pr}dsotQHRVJrNc#hk}P{Rq9r9kou3 zb6?GowqoC?)_W{pjWc{=SbP46*u?~?+nVKjiu0~}U$#E_6a4l?$e6?EA=jg4T#wvT z`zeo2oBA)WG6^~l3SF*O_vC5JnJf9?Sjr%3kQn~}5<{(Xkz}hwO8E%{W4LV(cF7 zx!20cTqB5$dcRs-)oaM}ynpn^e$kivpahvy`C>kN60Jp^Z}0c=>$AF)lP~tU#5j*D zVy^n7tTOUXfwUcaEyGd!Ozwa5MC86tlB)|IZgAx?? z7w0{XdyKk%Sk8GJhEK*SZ^RmM@@q44A%B8mUy$E%p2Ntye4UUo;ZMYx*JUZ|VcTAc zdrx9Kmb~l65IkbcX;T~euWoZH1#egde5oqsmd=X`L(aV z>d=1plo(4@xrNNRugdQpWK2=JXFj3sLt;*<$}-jPdB2f-E4=0{eA6#uvp1Y`&DbN( zC!X@yJ-?fWlu^XtT=+E6yes38AY~#R^QNwdJuwbqSnEye`SdcU%2}%f+27{F{EO<1 zK2u+UoHtidldvaW+&dEE=oxvP_uSfw(aVW(bMZ3l zHmid^g^c6Sqki+>$S?D49Ok&mFtwFKqyH>;0w@}BJTd&CvjpStuzd-|tu)m%60#{_S) z-Z+`KP**#a^8aJ)r@75*V(s#JhQB)Sc-Wsvo*L~5Q}D<9$6lj<^P#c&-ug9r-cPK# z?zJqMhd7$)wJ#Fn^$~SZR=@IoF~9P}ymHa^^2M>3LG-`8`Sq&)*gq5F{F-Q%L;0pa z)jTa@&fc!>hx#5d#WiXkwC%Zi^v~-!L9yo8_*`>NOptQUJN7+P=Z#z6<d8 zng+?IT;wpu&Rbv4m32LAg}NQ=M&Uy-yJU}+A|(&tB+9w=k+!Ga-5)5&`M|# zq~8}qGoU!kZ5yOq#IK(*R&RnqnhVW_rbF|f znUHg?&48SrQ_@x7rBFhNGzHSfye}?d{l(BrNkr%tJn-dXU5kK#)q zeY_YNOHLbYkn+kbg|2`?*J8$F$xmjzk-U1%SIGPNAY!|md2?u-=Fs@{)mUEyMf~zd zPNyP2mLIM~UK~Fb^{eW9w6(*nS`6mP7|r>7$T*GLShX3%a8yjz$Gplfny=`ssDrsR zm-3qX$Zg)M%4%Ob@+z|ka$a&i^f=Z>`!n=Le}o_QjC>0~`$oUC?_AU*{Cqa^_Jy(A z1I8TJRru8C8N>W&KXR5|FUo7T8bj4K?i6Rkr=8GeoW^HO!Vh&v-x))rxT<-J>$Ey= zZt~X`Ct^SHp^wIAzQl-KePRdx_s8hI7R2f$B0!~=asYWxu0ipZVi_~>W+SJ z&V1Pe`loJXgHPS^hOhQr=+E^yK9Sc4@>g>k@kHGsPq2>ESvmbR59UOl<=4;fS-sBb zXXMlK*t;6lKWs&u)tac&*yD)0Cnn@|-Mv}goEy&vebaya60Jk%K>Tr!x6w7(==wSX zzr1$xeu*B*b80;LU+vY%hcfwf8a*31P}Uxl&vC5Vi;eOT>&l0W^)Zjp#|gn_aNfu- zu1PVD=D6*$9v9?yy>ekjJGc~%Tv@U{Al+4t{rn~ z9<&vC@Z4OvW**{rw9onGF8WN}k#lpVZENM>>kMC?#Or`g#yTy^$f3IBO_1^-9235wUT=FRiaXCBn6Y}79?j&*H$u03Vt>w&c6doST%#23%GZLDci-O8yuUVp1A zL181t>QcXa)>>KPP*$0U?}2hYffKziFM~JFQLaN95r;9|2N}09>SOpTPp-rBYM%3$ zlxvo=c-CAB&ser&?L=)i>am2a+&}ZFUURLl#^Snj;a>;ih$GK~*Io2~PXUwuD6V#;mX!}_nEUN^33Lw^#aP0_r^yu9+6^YAG#o>I<5UGx0r zbqt+xeQDoZh_^tw&S{)W+SaDF8}*25aV%vJ{_CS_32L?vPb9Xy5A-2=N}ux_>bvXC z=RL8C^Oevd$apS>WNmc~N%h)^*iY1t zMd*A8QeT4HFRq8|6?0*o5@de$!|_CI$ZKxhlS0plK09B9to9;4>*rX#_CkX6zfn&G zZ}fP?WL)Zqb$dXbynmz5n64d<#t&<04Eh|oGoRXxeh4`n=7 zK=SC9J~FwAY;q#FJ22FlNjf*R(o7NYZUb|{;=;_ z?vLljA%Emc-OeXyT1on<-{!7SKe*;`6%;xXV{4^;ZOW4%_u}A*`Md_JSYHV(g0z1z zGy_VIvDh#AsNT>YdyYA4gVd+)=#?1je}Yy(&NX|kR6aq*8hfyQKLmwthPBUjeJ|Sg ziQ}`V_zc4Lr+uH>&oO-OI6jj|$W?3X`{cfl9pCGS?{r+vobt*vqN<)}z#H$ai}5+j zc;DkV173afJ#S^=dmPTid*5NdY7^IriORRaYdps4d+lPp-)_F*+|P;}=ee7TY$~bh zgYz-xSY77M&kX!*=VWSB)p;T{!iCzQPhC)g{A^6W%&F)3ntj;~+21K6hP5M)&H6-N zi1t~>lUBCL=WnJ`0Re@9_`6f&vATK6>%GL#GpUsMcb}NP0X43 zao#;blvg=(9d(dDp7B{O&g9%ajCv@S+skdJKlq|X_DEi5bE#cp2_Memyc6<1)@ZNx z-r$}rUxJit)T{cH*Ado{&wrKE7yUBEm5}^?E@{2P@2bC%*U+t=Mm;cIZQ@!(ymmzW z6KCeom@a|rKj$Xmhjlg%C67X5aZx*5izlKQWHn#Wkq^&PQHc*EfB1zS(y_nth)zY$7^x{pU8- zSj7y!Dlw)~4k3P5l>hfIO)*{b|b&Q?~Iqm9$ z{K`fDIwy~@i|WevEbAuuOxq2O_k17zCwSFoPICXM`)1@N&yoJ+K8*FeA8~0XkHMah ztdGZ|eeQRkj@&ucNA-)w>2YKC`hhL|vu3SXvZi}e-^R}M-D}o$uD@YT=QcleXnd^S zvU%%3>fAbT^TzI3vsU(ZZr-}FbD($2=JQ7;+g2>zvc7X;?=9WvzOH*9W17FQbL-aD zsi~%=p@F*o^*x>aO%!hJ9vJA}KG2#m=K5~j(%aS869kXWxc0df6~=;z4J;8{kzKbo^t-q%KC7*{*7|}N!N__??}0RK{?-3S#OUw9F82+^^sQb6B zoc};&eR{e6m6*SFw10i&`nl!&y2|>Va(%Fz|4L>3P`SSPin`vR5)XdOcP03n2xb2U zU--TBlKNh7>8cz0J9{_xc5Yr+TMD^-6}jMl$%>o0yLz|w)VcY)3#FaIP5JveH#gu< zWnYG0Bl?$b+q!kcn`8Prn()tDzGV{z!u=6{b~NF?XnMz%{()`RZR_6JZ4BZ6o+kX4 zbZps}xj({xunGUAOSkmj)P3EEL!p0C+2_@GFS%+ zr9rbPg`2O-8z}Ob%Ih}r6#l<>!L|Y255A5HUp1c>&79xUYd>(0?CSM~-nlXF z>z(7tzoe93(aWPm?}py)u3E0c{{C^~FP*n-W8N=ozgpjSit@gEoWB=kH*+in|MaH( z*<;B_7lhW)_=N2A!k#Ugx-aa$v3v7{Tl%^;U*Fe#-Lb(yPj7!$UuXZo%@@{p!3*0~ zEbrdBWn2IH?ia4_^LWdg0QQYgV?+TfDHCxA2N9myVjbX?vCDrtQab$+O_f6&-CW z=eMs}($-Nb8Z~uH&oPF&ZO>g@vT((UwksB93i25_I+ic%=z!(Q1uIGu`Aj|e>;@#J zbKS=7C7tX0w=_-~tedxNZku3=Yl`9T=;YFFZ=O!-+`LeI{oV66ZdrfBih<67dhHsP zvw&~@mQCz9U1M0nBls3{Z{Wu1B{v3Z@7DP|6L)MGAS=C{8|$2{8@XgJNWHv~Tv?A+ zs&Txk_t$-^xpq|eM(ZKx+ou-K?cI7!PwznYiauTu98)lQdVSB-LhI;GbLOP;u08L( zBAqt!lA@oTr2oe5k@H3`G1jc<-oC!OZ=hJSh6HqO+;}sif&QC|&aSSabKAg{+JF6A zBb{5j`?hS^=ta`ae{5{UdS6Kt_16)#|JQg06+5{o8`0FgxeMC1so?cQcmL)hyx7pYy}PT}u%%z>?!=mSV|RbStC^yAL(#h#{taZO zKI-2_5F1&tF^WxFy0&fXE-==;)eIJ!yKkaR%UGALShHZ&@++5KQ7~$6Te@KJ!sSJD zT(Jcs{k>h?v_cUp}W|&wRiJ%#f@8hO-K@M>gn$Hf5)9$H&I{y zU$dqV>LecJJg;~2`iC6zfTF zF$X;_D5gy-o{NAoiWSPt=HKk%^2>`kmle}4E6zQ)xb@az)~o{V;{4)5-U5NIcy4iP zac=SY;?>3Fyor24@zS`ucuhU}^=I4-X3bi+t#@NrgRQD{>p<76S@oCVv+FNvYcp%s ztlz%^; zeby}Q1m*Km`Tkyg+dH>xsSrMy4YPdD(cL3^fAE;utGaK#X-j|Cn09sg-2C0f`kt5n zA1*eJFM51TOOGPL+?(UaqqnJgdXLKok2&+V_4AZGa7}}h`08cNK$A2y%x~j|&OB9A zcuch;flNgIu?%y!toYePenIbby#p({c`fHlv<9UKHK#oDi7$QdlA`#>C-EN3zdUqw z?n{bd(&2}WP6D6w9}gXEnaSTc1zW*Oz;Nv2iyt11>6I^AKVXq9y|=5 z^AzOU_?xl6f;{-LGao*>8tehLgYO1+fu8{Pg8RV(;7`CK;FF*F@X^WhisF25CfE+H z25$tngLi_vz%PM&!NcGI@Y!b}56*lV^7HvS-{4&E$4n#I2p!0e=Lp1>d&r z;iEgimFpiqx*OaL?gQJq9zJ@=^9|&OFOzj$Pki8=;A*hv2IRo+fV;u%8<7KdY(@?| zX8^e?$OAYXJZC#{;OY+{2Y!6$;iE&~{{x4?4If4hJOZ}xamcwJAwKYpU^}?rqtp}p z8MqT%dKdA5?*sRP_kf4NBjBVf!H;1V?B9c3@YFw{9^l75Nj|`yPm}-tqWBQl$`{qX z0QPWQeGwc4zYY$8e+dqQ4}yol3qQj;*H;@j1a^SK;5zUS_!Y3_Qu+gI1<(8}{)2sB z54al~1n&Ze!27{ruyrr;;Pqe&Ulw^7Yz60i4tcN#>;c~m4uTJYL*N;oM;?3&cnG`` zY~eM+H^El$WnVxZyb;ZRv1wX+*_$qSXz2G76XJ88-cii$d`T_hR z*a7Yb`@rR2$6v4?+yj0SJOG|GO#I+FaPm_81LuMZ{v3PY_23}*eQ*eT`8Ti&?g9^i z{{^-z<9hfD?1H<&4)Eh(A2|J9?1Hz0d%%rl<}U@N#CYzK$IKJYu>PO#XIUGQ1pesCsu7+ecZUe51t z24{jF0at^+^DXRx9|U)UKLYoG{|O!h&-!cX%NIj00TZ|!oC|&)Tnpa*H^_q~) z;48pg;K#sy;NO4;!Rh}-o?cNDuLKjg1Dp%K16&L40(XFSg1f;lgZsd5fd|104k7q_1qZ>`{s6zhJHcV_8{i@EJ7CMJxIh08zrkC;cJRGm4>$}Cf-n7d z@&*13JP5w|N61~vI@k(+mF@Snk9@b;f#4}AS$>htUDm*8~p+W$Zf z>;e100dOaHH@FAtoDM$sLFB>ZU?2Dza3}Z%a1Zz(xF0z)9=4 zZ~QlP1^*iC0nh$_)CK$rI0P;_iX3=WapdSB@NRI@dioKZ4xVw!k)s{pOt24J4ekWH zz&+q^g8RYW1rLLJz)4-$1E+&O0Xx9yPe2}g8MqU?72E^f1MUZZ3LXZZ|3u`wd5;~O z4(;Q+s?chIvyTG^2>dxX48G$T_zCUvQKHJHHb!MWfN zxEA~rxC7h|?gpQ5F7jXk4}z}%{i6rBg9&`kdB}tR1+E3xPbJ^r4sZzk8aNF85Ih7< zI{(PgmVRDGfUV#Mz}4U$a69;2a2NQL7tj~rIp6_sIyiYNbp>aFcYv$G?}IzQ{tNII zybIh1ehEAX9s&Jg@Z#zC3tl_p$kBH2f{W=7@QvUg_7B9lzZNv`_ z-bg$zp&sD13-Aj(V-bA-&IBjlM7@@f5Ad>Ok@1Q2f=pmLtqd16>t#zJ~#vx zE071D4ITn#gDtnv&tNOK9c%~R1NMNQ0tdlwfkWV7a2PywCGy~8u;sP9jsjc3SA*@~ z0N4Y*4IBh_gG1nFz+v!S@DTWYu;o_j1h#@tS%p0Ke6R&P>B+3U$OcB3E0}uWd@qthI9sJutpS=tJ zz%$-W--7po+rjUFyTC8K4}ZZ~e~29TpC3W)H>lr7*_XiY+=U$YuOCMa?E3`$1fKax z&oVkOSWdZU=t| z?gkf~NgUuE;9>9{aPpgrqIfEK0Ox_L!P~&?;0M9o;K#vz;PkT|IeHL$4OqN|{R~Xt z6Q1_S(YfFPa4mQ}xC6Ww+zmcyGIpH@4}sqVTYj@Be)Z}23ns7~yaVh3PkjdY2YbLF z=fVBXKNG*f^TA1j#0O3X4}%?G|Fa%B+6Vp++zGBd`;nu2z)yku!Iozu56%TAy_Nn4 zr-S>z4zT4p$b&1vo#0Mz54Z>14}K9m4DJUfy^ZIU|z$4&2;N-WHw{yrFcp11B>;iXyL*NkjO>h`&c^-Dbv%pF3Ko2+_ya((6?*;q7 z{|0x0PkugrgYN|QgC7SEgJ(=Z{NrBj5or?PULZ0d~Qq;9Br~;2?M}I0PO7hrv@XpwGaS;H2MS9{{I=eP9Q8 z8`uYa1l$S!6SxPQF%7@L)!m}F)d%*qRUEmRL7@YiG_`sRqi(W#Vz@6YAco#SX4uiws4}ot1TmBc%M_?;>)@9@w>;QYfS#!w~ zxEtI9{t37r{4sbKJhKhE?_>W5r-N??JHTPE4}9S~Yh5Ke%oI@q%vvC;uMr z7lJdv84HOQoD1#%Uk&aCH-h`X4}k~4omb%Z`?)T`R`71H9ehGNcEL&DPH+~u2iyT3 z0N)870r!HF|2O*$I1`+FCHVrMa20mJ+2C&Q+$H1-yahZ2eiLl@0DZd@yI>#K4*nU~ z10Def!S8oq7i@Vs@q+Wf!{7xgu=_#k1Fg7(4>@ zgOhjjdJUWjei&R0UcL&y!ESIj_y%wv__yF8u;ps}{(brwYz5bW?cg7Qec-pjo#6f8 z9`Fg*;5YbU@G!UmoOB2K2{;}6FxUZp8SDdJu^PX@H-LM={{d09)=XiZx&>xD#v#KLhrFe+>?TKL&@uH@ynK z!4HFn!7qc8{*XLgOTNIx;A(I?xE=fqxC{IixEE~sb^Hbwfk(h~;N%Z+zW`@~-vd{J z-*`2CgZ~fQ4L*Mj`3ARxhrqkRmOtV?w3d8<{{^lFpWKOE@O*F=I1}6p?f?&f8`qJq zA@+N)75paH4t@{p0e=Jzg45R%FZeQW7+eV+0uOg#_ruh!8+q_mU_1Cmum`*y90U)5 zL*Q37kT39I@G!XeI^z8ZeBexQ54ak<2iy*x+JoQVVQ?R~pclK~O0eal?2lk8_z|!j z{2JH;ehVA~e+~|T&$%AI!4B{cxCU&wi{F0%wt~M2wu8S9_JH342f_QmA@HZ*FnHPx z$b+-MmXEQYg00|fU^}=I>;XRs4uby(4uMbEh&*^UcnEv}*z$3Hb_{F<*MRNdPOu03 zAUFtq3>*T#4i1Ayz(e4uK|0&-vbB1d%+>_@4;d42jC&_iJOt% zgFj#^xD;#$e;w=rZvY3uH-kgqXTV|b$y<;ITfvq;;e9x;6w+YgYO1=!0&*A;1dUs2NO69&H)dB zcYrOQ=6(RSf``F&@a%2KgR{Uv@EULkyc-+_hrvVO={F+(8Lks>I`~1b1H2pT1D|#i z`y<#7?g4jz`@ye(hr#{eq|fp`5;z?!wj&Qd59|Xk19yUp!9CzR!TsP6co_UUaME7n z!Rg>rZblxw9P9&M3GM_3z&+rH!2RH7!NcIUz)7Fu^&vPNJm(hV!P#IRxCz_|4uX5Y zJHY+m-++g~L*S&(^Stp|u6uAExEj0~+z#FW?gsaO`@pY&2f^Z2_Ny;Y4={ljfpfvj z!L{IR;12M1a5s1lxDWgmcn~}a^5$uA!RwF*zYDg5KLLBdXTF}gf$iWBxEtIL9s!Sl z3*La-pK_go?ciRp2Rr}{fi6;%}#71ecNRhd-p!Pg=H2^a+~!0-p@HF_kQpF-S6r8dhxlr@8@~G z&-d>+=X=h*7yT2u5DlZN(ex_((R0zA=%r{6dJQ`AZH_H<{Lzci)##Pz z7BqzJL_a}$(8)`&-^%$Rx)9xru0~tYE$ED8*rVH*V~=jQhw}cwcnDG+`rW(Pbi zHgql8j&4H-|Iy%p&b&s4qEpe8=p3{QU4~|Fz#pA~ZbP@A?dbPt+B^6?M}MK?(Lywc zE<_(iSEC_x3z}NbxI{;y#=9I(&`fk0nul&hOVHLAC>NdZBITl0=r*(oZASwe$$J~; zjp#V^9&{?Y37vy>qRY_0OZcN_q1(_oXgj(YP5Tq=u!;6VKS5`r<9|wmY^vw z&e)Ehkqor6A(u0&r!H=-Y*+fm;uj2rY&G>!3b z3_1Z_kFG@DL^q;4(d}p_+KGQ=+K2r85&WlNs}S9R&O=jA30o`CvFJuLAKi}5Lp#wGXxa|;N6-oAF0>Fe zeuh6f7F~%>K{ui$=yr55+KJYnX&+NAIsx5<7NR}qJaoh){LvhABRU=3j?P0n(G_S~ z3)h9{1oS<$5N${2p(&^0k7l78(JAP5v;^%$7o%yPaQ%u-K)0fW=x%f#x*uJMW=zH( zos4crXQG|x0yOPY+83RGZbA#u?dUx8J9H%)I1PVv9J(Dn7wtq#(X_vC+(jp#YtTaU zHFO^O4Z0F7&cz@76y1(io{qoh8TjwyI`&Nb(WbM))=V_zys%Y?)?O60)}uH5JZx=4 zjl!_ij&4NPX(vy#^566$x}lTyKp*%4zuoM| zbmNB>_uz+4v8W$9$=qjcK^q6{vv#9%2k*1w%a<3UnP|pA`>Z@Pn7Yp@LDvTMS(WIl zgZEjr=+r~@S=-RXhwrmG(ZHyER@xrg>F9mdBy_=#@Iwp6Itu+LhL&N^wIwH{|a0S%&s z=)}wRS@Y1@=t^`Ux)B{ci*nH%v=g0%ru~C?k4`|V&_dB-{L$~Oz#lbA@JA>AYM-?e zP5<>is|UU7=6%-ceOwQtyZgu=oyR&EMpvQ}%V}Tq3UntLLVM62bR_HL)cLd%x)hy> zhR_n$&0T0EYA&GOXcpRp=ApaMV$@)rtU$Lhp0}Xw=;vtWSB#Te_E}TW5IPUdTu7d1 z1=@t}MBCAfTdDuo}L+M^~ePMbrabf$l^b&>nQeZPcTk{Lo40M06(F zfG$LLp{vm_x&_UtAb<2C)c7aIWi%75Mf1>Bv;-abTk4OViq@j%p-t#+v>i=fyw4i^ z4bK;$5;~!ha?vx;N^}ldi&mjc zXf3)M?L-H6aK3N{<)Z0#(q8B+bRoJ9U5y5+s4qGi-HFaed(aoqk>9fKv6T9vZ=xmW zxV!gR%g_RJJz9!xLo3mC^f7escZ~C8^bmNQ zuUJLiXv@R+?d5$m6CJS{KlBu|1icuoL|34-=zHikv=ePdM?Atf>1H0Hm)a z37v-apjV(HS%=HeN$79Undm*}LbMazg67uZht5WO(6wkL>-NMa$rmj{OVFigC0dWx zqOYM%=q};?wDVKUS9C499^Hm+L-(TX=)^kev!8jrj&X-(K0`ie;fvUzU!k4oh)v{e zu`Z&M&~|jD{M|tL=!_4Dk1lLye4vl|`Yi4k8;u!#R;H0;w4r%u%Fp_&Iq0~H`>d7d zv|smGThOw*`mEjPiYNN4!AVKR##j5S3FwZG`>dI0*SCFEB|2hozqKBnG^XF$j?T*M zw|dZu8U0qKFUeRluiu)AHZAYB=AnD)`mNQd`BuNxgpU2J-)cvv{Iy$G$O{u|NtXe*kQoMiN%lhE8B`mGXl8d`}qqqXSwXcIboZ@;x0 zJrOlb?9fc~QFJQ09-V{kK$oF`ZpuNsdZ-^dvA5sqL@z?q{7J^0=mc~FT8IY1{nkRX z5?zm$?ZXd!0_{Zqi;hf5GDh{0FM0|(6Fm!Eh~9v%M%SZT(D%@tXcyXp=Jw-1D9N}U zorJDHXQGdy3(+^w)#&@^7W6B0Cu;1+A03L09GqknqLa|M=uET*U5IW(SEH9(v=_P* z-Hon8jf0YmSI|uK9W)OeWbC&}&_c8lU5?hGHE0vM6WxvOM~&1ZV{+1dD-$h2^UxZ! z1l@{OqWjTWG|PuST7vFIm!ifH?9fcK9nC|tlJQ5Up_S-Tv=*&Lo6vT2H#*eBKY$&Y ziOxgw(0a54-GNr3L;d)pIcO6)58aKfLXCs5Lo?AHG!M;5!5^K4R-&uWTC@>uLVM8N z=;%TC55*46L@Uuev=J>q_n?*N=)w4-`DhbbiS9<%p$79}51NS%J_vs_A1y)WqD|;i z=x%fyYNS#BA^WXyX!^nXtwPa5_FD_lYtWIy$rqi3Zaj3qH3$9Xu>ICbv}xpiYYRGc zH1W`DGxuAA4`uw1*>6oiM`i7|W}@xKkvE!sJb9xF#_hMZp|gLq-)cwqqJz^J2jj^D zUGd}n)>L#eItQ)H-ft~Kzd&n8Gk=QlM~^{Qljl#+E$A8OPIS`c)a#HW<7zY$y$Q`j z%dQ|Ex(Ho{E<@L&ORn5+ZAVw4o#^rs-lx1jUB&yTZ#M6vXI)Ku9L6|CC!ssgndtZE zLiBf~^l5bPksKEmFdood=u~vwEtHGCgRVsV3n>>p z8r_a=Mtjih=*SG(?N<5;y&Nq;=iEkp(Z8YV(SM=a(2NSoMNdHoA4R*M6VOl5LiFUt z^e_4xx*Gi>x&{3^x)V*iopRCf=t#!pJTwoz11&-CLn~3El5&Kj6OLwFqf=4&mu~-` zXL1)!Hhhd+<7V|8Kjk zBBa71KjTS1o@jj zuBG6|ss1I=^0VL}c(KZTmqy~}!wuU1Cn}#C^)H2|!H1~)+$gVt_YwbRD!(bp>)`45 z>)JO2p9G(x`u{fS-v*xrzgOkHWwwE|kD1IpUHAnt+(}S)7W{j-u6^?1J@9PR|5wrS zOX242d`3j&zF$VluY%{pN2~m@sDB-N3cOt9z8fO`A^0i}|2B9v{70&PX*9lRviAzV zP31mk0@?M4hvB;V$#<8gRPq@O)&JMg_@(d>@KTlgu8ibg1)l}i)*n6-ez@vCJsLj* zFNEvHUmLsxK34U=D(Ww9CoL*0uvg4M$(3j28_CYP>8yiU@S>OZTGMGqv+bsfB5Tk& zcP1xKO^(!~z|S;b9pKOrU8j;qB#D8iWPRbj5tyS1Z z%JSVGDW?Hm0e>fkza8N%@G)=hwJuh#EiejvRze&59 zLvD`NSMq$xw965@Tya{d}QwQ4h=TTk;Z}9LB z!X-al{Caq;2XBV2^57ltAiPk`-*jRz0Ht37x< z+_V4Tp8XH^?EizD{@1mCHhd%b>DIXdxb(k{m%+Egb?aOZ{()Eh;UN$IX82b4uVVVw zIZ=}S?SQBLd9U?F3~#mjU*>awb)gx44r(?k^Hk>jB!6U_V-SMIv z-sRz64gcPQH^4hRcnkbH58egu@Zjm3sCd;c2QKwHL2bu5(Rp43-|NB4;pWHs_N#{b z;JWw?@H7wJ0v`?M(kZ&WC#Oe_LtU(cBU|=be*l}`D*Y_$@vBZfWISZBUNm5rhP`Pi zb}}B4QzGLgAG?}edo9`eF;6Rx9xo(be>7ehb`^i6UUK}qNU@W6na=S~%B{w3$>)2m z$E4hw;_OyL%WcGNZyWWXKh3w|>^7&`1oPQUEqj(M=dPgMDJ zPTu051+T@wSmo;ZFT550LJWU4(mtiEJ9GK&kug&5k@KVNBlSKkTJIonO8-m09Z8^p z)*1>ZcEOW z&BGT&`(auz`A#$WW$6j2S2`DBSy|oInY@m)-=b)FIq-aVNad2#YmSY)Epdvm+l}3C zR6C!uPzbMppLkriwKj%79?7=`z7al%dPVY(@z8H~wRqX*l_AFe%HzAOCuQB9^#AJh zfUMk7UI+0~Pw2La#BpF;_?#0IX`cY=#u@N>X`kOIaikreh>p`7?6ywmwtjjdc2CFI zjXN=te=&C3ujsaZA^q~(TcYhPb-2Lk7s;zCjVwx4@2A_3x;&Oxs;j7?@=7aEh_*S^&6zMIf{P=d^en1 zEm42pzDR!s*q~@C?Y3@>A8$7}eI;QfP7Zd%f2D8lB6t=2Sv5{_ogGB{%i$w#PP{$| zuXedCgOPg9aOxp-m-X+@*L7R3%kd_tj4K(ZFF12U>{_w==S|(#UA#7*R_vtjZi}{y zc_`1YkPpjIw7m19JPV!!KVRj({7Ady<9G#J@-<&p%5ifRH_4|AyXn~Fi`}b=-R(|U z19sKeT|W@-4aH80C+*ZoUb9`h_;wQB3cnmaUIGuycX!`P^68_TIq({3$G4SoWPU#2 zw4=ny;)15NyxaP<8pn67owV?L__+D{>+4eZiEz3#nuogo1HLmpR<7?@$2Aa z@E@t%xm>l!V+g(go~@4S$_cl%KvyF-({iZ zceN8!cnIDKAFJ}K94`GV>)#&uGG3cW3uD${pR!LGV1snZt=-mnY8>B`NIz%8uY)se zqWz@IlLGimxUL<`;IF|mRe$$9O!5r6yjbNjSKYlHd0Xn+fZcb*nX20P&W_~S0w1xc z+bW3R=h4HyzdzB-084TD3*xBpHA#v@dtRMMoOtoNloLZi;e_9IP1z)IgcTh-u zs^AlE)1PP6!S8_U`XvNk4=;_0?;IGU9&PXrc$Lb}lXD*5LT8jX?HU-#GZPhw`$zK3 zcDc6y;iurQ?SJ@c_-r)~-{p~h3Bq^5cd11DMNVr5j*-^4Ln!zGU_)|YYc zLa{wjsjs_t#M^cr1;i=DE>XKlIc4xO;JWq*!l!ET5dV63zJ^Pl&E%N}Kc3g-L?zGJ zvE!$UIAWKm-KCs#8cOb0oyzM-yO%pL?EYu{m z1-zSm^+fBG)O8$emy)<{iUBXSSRMfui&*=65G$dB4<2E9{ESHKY-mOypD_)-$jvnmcm=$MKRpD z?h^kh_~1Lct&>z<7L8vAKLV~Bk0J7$2)D;$S!|vI<5B9VM zJ&)5zGY{|TwlI&@XQpFekAL_%@Sw__IF$o@?~4cMK-YqMI(%a=D`W|vn*ymzt7 zRpT+22G;XB_?K{P{VAspZr6XcQcm1_>>y6#-TLtsV50bzCBA-=`eeg1;Qc=S7&xDn zYmUy?>!TvR$z) z2>+?d=S6uP{5*J~^IIuD1iuJ=w(75(*S5iLg2x<3mHS=hF^miNg{r@_mvc%f@7mXI z+1TyDt|Q)VPh>dT?OKH0x_i5=lU2Lx9UE!aa`>z8nDs!)bMN_!o7AfYyMJJ(t9K*3 z170i+k^YO`mv4oSTcN*h>Vr>&>*8mO;l4VYZJcO)XM4`hFBhKW!HeN(9=rnHNB#`M zXnc2{(yl*zA6&P7H^RSxU#9xI3$ysQ!X>{6Dp&4H_rY`E9L}TVE6;^w9LqEG@I>WH zKjy+m!efp<(vQw1lSH-KsT8|h>|T^NBK@?%9uSge75sg;?)tV4-U8S4QwY8buIr~Z z_&f0PW6F2-FQj~v%5=hY?U)50e_!I`f%xackB28Zer3Z;>EKE5o29IfvW~ddyFPbM z0&LH-YU167{VVduKzj|?I@@WsT_bj>E4!@+RXb__-^I?yHtgnOcXpheEI}Z{JdW!U z_#TxHl-ClSx7pZDzu!AAX^$f8_F$K2+(>(rXR@I^rGrK;rQu`G??Z z;RjlmIy8Fb^H!0SlA zEBDpv;ln9EN9E3AF!nrahL43KQGa(IMB;Y~u;JSU4Z1|txiRQUofA}uAZapu9e+Ex9FT_6xe-}Pq&EMyo2ner-XFQ~T zPOcdqfa}Iz2fUm3+WNBqC*jZKVYGeS=Ky7%WyAO3KU3w-d9S;B;H>vW*!`F|(^Na( zIrc!2dX&R|0pA|O-;eNWc*?58^^`ms_}>rsKhJBkRark|?R&}@k7CzKoJGWmS=YtJ zeI`YU7dw*%c@Dc(^2We=D|SIAmb@)?vi=?MaJO|r5$gyf2;8Z*5@yrh|;dj*p)q!cz;ROU0MHLfLBQV zLvD@kgSxSjuXnE9r5MRCgNYP=wA;F0-iWQoT?6%ya`Umf`Z0Zfm%{Ib>-xJ2enw5) zxbj_M7a{TM;0xf1{3Xv2eC*@h*3-O>myA z@H_@jH2qb-)8_ z^y4(Zf$bCzo((U7->BB#=WJ9+`xL-mg6FE7aX4@tUk3jGo~d$WUpDCSLsagrtaP1G z&wBP2{x|U29R2_2ug^W!i@VH=R^si){&(`m!2FeY5qH1MWI|l|MBM(3*tz#M#NF&L4_S$aiPH`A0&%MDSybQhvPBo(3y^kgN2I2pL7pPqFP_8G$ zu7P!K*puDXcf2;oEA1e*ZO(kL>rcE-uxpBsw>i2lh@Hs=(r?zr-9M06?zNb>+x5rp zS?sj+hp&06+uEd-=X>5R%&tFtLY;nm1mOknnE6E>a+5;xtcPC@KT!L$u+BYzU52dl zlVaN^dAPI2OFn(XTl%zqzGN^_AA{@0doH{Ku3ImP;a_?9SHOR^F7bLM>kfKF!1{dq#hq*8zVB9&@}^u9pK7nV)cOZ$!tZd#)hu zpUwKQ75+T0%@QRa87uC2hvZR2oT=**#}Qr*&xK#Z>*zdj_I;(CYWN-S-71$dK8=oB zX`e>&IrUlgQKWq;lzg0Xjkme;diQ{b*vtBN`39aN7yEk@dx`xt*6y{26f1dVuz@4L zoufM*=EA4JIjxM=!`)*O|6=%bc%tzk^{jvwzz=jjS%+N(c8S&vsaJ?~?k@N}Qm-eJ zdfCr4`F>E_LGtP%-tPLu^HAcYvu^ak&y;vCDDj+j-9|ij7sY9(d@jfWFX-3xQkS1e z>_~sp=JIHY&9&tyacYxGyN3Cu7*pVIjkcy;s2C8-%;|EdE_*g zokuZoM!lr}Tt@|bBwROtYT%jhOv;Ij8|8eV(dCDz+&y2A{%nOGg8%s{Cr3H_%Q)|& z9+Tl=8RwrU^{~fQa%~a=-MNe7w0ri?u=~BfT?^o;@S$pX?m2|yQwHzZlz5yA55m8P zlUB68&gm6DUd!>1bupRvYkcJKjgoJH``pOsJ~DPbkYLxJcsIVR&!-Q5B|Oo*6aNf0 zGG@Vb=j*xfb3J%5{3JN1E7AJ6dwmkW0-o!^YuxxOZ&80`zoijgg#U1rE6)|Ry8gpd z?(VTm`F-$HJo3*tmFHyPiRP>L=fd+m{EOk)aNRtsfRBUItAUtC-_fySzcSpyc*bJQ1+)KpBxtGGl-{KcZ%Q>;E9gc;$IG*4A&i}s^J&G z)3J@TyL%oc{tfUcaNRo70-rNQf4{8@o`(MgYJ8t_AujRLbLm@nqV}}cf7T5tUykSI zkVVmb6#CwM+|*hBi8Bkk`(ny*4%t#p1^hj@bWfz7ZUEsm@HY5iDtDGQJANa47o6^k z`nx+!;@=AIgcl_%Jo)FzGQg!Cvi@Z?@|#bxo(_wxM{b_#?6yASbtF&U zdy#pP4{wD3B8ErT;Zpeb@KGvv_Z2066}$tUsJ(^Px&E9UM9Ww1V};^J202Odw#3QESMDFTy8JAaS477}AG{6!nDaxQb6-^2 zDI=Hu*x7A;#A`D@wm*FDM&smDz!vO|RLfDG!zzV0c3h|vR*e6C%rfE{a=aGL7YtZhe^a)cw5YQ zTk;>Bb9S*yKbQ6hcUxa3^T)tGwj3WmbBKkY4`>Q6g-=QCv8Ked-|3O|tAdvf z>9Go8_<0dt2VWWJ;X44;@^7=bw41Ddo&1)l{kh@?m2vIt;~XQSR_r>k+nd&7-Ap~q z=l`GGucShfZ#pLgQx5IXUbp1HH^E=SHqsuxm+eLs{~~xndQZaZL&>8&pX*2Xmwxhi z|NrIj7r&ct4RON!w&*RXN;xtQf0JsL#k=--V+gxxS^Q=n@gn(%-DZg-R?ax@z;4fv zdJ=vfSMmz5egyfgOuo9zFb}SXT_2o}7u)kCXBy*y-^i5frbv0oL+tS&af*m@?Fl{B z?^r*~W8&i6?yMowP8G!2HlfF=<8>sC?}ai}0;m(Gd_&35A!Pm!(i>D&v zqLn;+C-+#3r9NlI%`2Q9%~H+nU^Sb1N&UJ;~%?)%M+I)amwMP@UPT^a&>RxUOOS8pCg2 z+U@+LzFr~X9fqB*UTttg!zCZ{Le>U;YtySTHjt>#9M>iS(5NTJ(Tr6oq5pY!E@kyG~BK~ z>x{|uu${-V`aB>;H*tolc_{nkHSn+COH{6WF0&Cnm2!0TXoX(~*TwIH&xGsZXZ)P! zT|DCF!dv0Tsrf1QVT$2<;Imb(eBMpgzbt;smCJsPM-|cac3=~Y_hmlS5$6=_N@L<& z8CfSo@I@ZH4gMya!(X(&mFMHlLVjBdu4|_(_;$Fio$}!mA4ptJ$-fj{4o{T7jF&3b zr7du~9bVG6Lp^cc^C+ho9(b_F8mrdxD(4U=d33;s!xQBpJa94Rlki0SB|ICx8m?=H z0(cm{P%U5ioM#z)I={`kAci{|mJ&Y*Uk|?|hDSd~R1a^37sYUAV_5u~;b{-?o4_hp zox%EZ z2rq*-dXyi8?}TTn{>uHndY2!fa^-$sGyG5Z>&9^hd<#5L|H(KEupW$B)#H3V|7B$y z$_+y)lYi0(}P{2c`NzK`nMl$uMcl4 zapKm=X5yqh?9u;liIb@RrC$TT;J!HiiSn?=Km1yc_yzDH_({Zy^ox7{R{YE0*Le5` zU4LDE_3+L3XR7g)es6Ypsmhh_S?qv^@t+;Tod?M6`p@9L&+5eMhx9`>>qim%bzYmF zDE%PkKrcCSMB)??=WFbA^ROKLDLhdR;-(M=_#PxS0ai(FX-T#H357*_< z2bXemd1SC&JUWoa*ZMs2FXi4mc5=QG>34Pi7rtJ@rM^{^QwQhpWSIX_%8C1Ybv<#K zvD4M38UC6F?{M=tRL#@9w6XhtCf6MJ|5WAkqWzi;e+f>y(RwPMpD2L0!4u6Nsb?AM z(l_vjd2Mzo^_1~*Z?v3h;#|gW*N<1rQJx!UfS1A(t-n%E3p@yqS%0OBDY5H#A9fq# z?UdtH#$~KunmnYOT=-Y<{t3z{#V++R{kl*E&w%U3PaS-uhD#nH*0prFJ$?eejh;uw zjh_zU~7gM097xa6T5KLzjrJkjyMUjN|3;kxk^gdY#rjjww6EO?^vCGnf# zC2)qBGCrf{PaW`TIL)PS=ln_9F~EAT4Q`LmG^HKm#%Inid2X{tKR%1#Q{cMsSq`5I zKhXHB!EQyooiaWf;jd}(kovU3L-GCz#-~}#_hVtFJ8osc!*JcW$#?yA)sr=JwGNW{Teqv0+)0Cik+^W z+3>|4yZ|nF=-QzSUIN$6k0AV7xNd&b!*7G@+OZk_0$evgI^Yc+Ja7f$39g$z+3@e+ zy7^PU`Z8vXJAZPNc8;4r<;1xkJKg$T4X=Ug=1&7W1V7OHX~nKR-cFf6eem=r66Yb~ zCgVyz#{@r6Ir-R4!7kDKkvOHSJ4Nt(UYmtVyTn~r1c@^byFBb7=MnDx5Q!t}-^zhF zMfx}`#Hq(lH($Eo>or`;NoU=tgWL0Erc#bFU&JoAgf$mC%%k~AUn~1zGJi|4Givqu zRKfc^@~NYMo`HOd6Xzr4G!rM2a!%!Sr2X9I;UwP<;!K8r!@i?gqQoKR%5J#bt_?~( zluW%!w*sOP_FOm;h({Ec{am;fNR%3c%Mi4fvai9XY}P~!%v3m$}fNy z!gc*v24Ce7KM21Yu50Id)~i~$-OjE0c5Wfg>}Putet(PfcNhFhxNdz-FC`E7T(uu$ zUb}mn^0vgu#qK@qbjQnL_!f^mD&U(v{A=KKa9w*evW~q8x7)*996j%i8+UEQseDe~ z9wr^O7@nveS=2MDgyTB=9A2B*N;z@!xPUmzHF2c9%HRv(iH>_xPLOhz43slLUrqyY zYCXznfv?b%WA{INHC#7O(ywKI2(D}Q9M+R9aJ$`elsx0wy_h(Qp4Z2zAWk*hj#I3U zQ%9T`FY4E~5PUgYx4yN(--PGV#*y`vTnE-S^H<#0fzvEeuB^XV@XU=p7TZt?pJrc7 zN_*zRe-78RS1Iex9JpQ2Dt$eJ#2LRy-!Jv>32U1phJoM3pPg?U%z(g%4A?)0}qvYWO(#$tu4-T7Cok zG zAq}%d8CUV^A8~$yovz=@;HSfN{T_s8!*%^q4<8TLjf-YCzOEfQ;1}Vq8yA6JbDr)| zem4AKxNck&z%PIwXk3(I_o_!8)$q4G%4u-@4>T@XvHK@+bnVdx55sl+kx|Be9b7kV za^ZtF>&Hzo>x>Dv$IVXtxTzw}G1%$GO&$Cva9y4u_-MFp+_b?n;JR^R{>F)~Yo{!D z9{##K&sse+#lKhU_T$L=|gJeuJzd6d)P`X6ZAq+ic|4RLhskpu65 z|5#m@l<%1-g7?66hpF1v_0nS@6YhU48T6*L(Pv z!i(XF`bWk|6}%FjXnhb~2VVqFjcE^OtO*anrJnLV?vegae%Rj75Z(sg{d(f@EZn@w zF#L^)$D!~n_z(}C4<8QKwNEMB2iMJ~D)>0KSAR+#_1JY_muMZAanTI7;0Ky7UD##6 zkvJbIC;ev558=A;n*%R|>&8nF{0vQe$+H|@3iqn7*wtV+?#%<&Cxl%QcDnX&gXhB& zwZGl}<=l_(@XvzJg6q!r^Wih#L&!NY{*>?aDTPmgAFFcZdwr_l=fKCST)E#@2md+z zB$X@o)kE+SxVHYTzplT``5b@o*Ui5y_|H6eKKvw){7T_ce_ei6uD>q7I{48Z<%i%$ zc$D7;9}ho4Z9nCE^~?p_2Z!tWHw&Hv*Y$5cJQJ?#-%|Loa9#ga!B2qe`nL{#23*&E zA=h8mer@n0@z?dQc?-{vdhjgxFpvE5;ZlEHexxKkI=mzdCp~T-QD!_+ZM{ z^=}(|1YFm@=0etQxUPS*;QJ|G*T4DjB>Z*#TM8cn*X3UY&w%UNug>+?wO(PE~ z@c(*n^H#(7)}wv1;8K5Ge)+DyF27RvUp>mNf`8&sejWTP_zZRax;I&5{SLvU{dE1? z1|JF6^{=^z@0Ea`sK!_JYqH=nK6LT(;X^&*m%^ogbn&a;GJeOX&90I zo(_*WU-U(vOKgMZ!gb@%yp4SUkMgtNg&y(q;R`+Dm%^8O#IJ$}J>u8F8$9BN;O}_w zHuz3>rrN&Bb7N+O!*%033;r(tI-U>T4A=EvDSQiD*MC*;t#Doc)xp1k>-sMQ@AD|X z4ZhzazWG}|pY@hLeinQZTsMF6;aTu0YWphR3s?$27p_~MtKgTwk5c`W{m43ap$8Aa zFN9yC`YZd_ZSV)+y8O+>T;ITT`Dejv;kx|u;m^Z$`Io{scgG zCp=O9avt3V55qYOM9)v)^Wj1>x23MExlK_3+Ie@tffr;ktFA1OB#$f8Y+M{<{3L;ZnXX zegXVlkN9QqtsXq+mamIn5B~uFLuiXg`zrUxo8fPH#P5K6jjzBGr+;)qBlDpVF7?fgtIxoF%~p61JX7V$alg;yy781z#r*@1 z{Bq%cf$P?zVtAj2e+B#-c($6~ucG@}HSoRgMEz;k-}ToWms;W7_$T67l-b96XujR! zevh_te?rE@Q_(!K?&ACnJ6#_6@Wt>%7_&U^h<9@9Jp#1N<@%{}%Wq9{yeMQn+qBrvHxb=l6)81OK@PFM^-%QGPjmmWO{eT-r}t zfB3an>_r>;V;2;`BlT8@QB|4 zZ}W)X0{_IrzYCsnw*LNM`aO(u_+e`MDBnAm1K&mb(^S47x*it6_rlLqxtyf)w>|#h zBSQN7E!FT0_@X2n2CgHL=SS}6G{6`9u_yL-nv=`z?_ZGkE%5E{_E?{(<@=l;vJu_| zU%t(GPCF9c_kf+CtZ(T-?$`XO$9hgJpY*&-n~z!WH{qN=2E8#_I9`29Sh<_ct0iLUJ${4uL3Bk9+3smlle(t;t z-Uq)vhC3VF65qU^eV=yy@iYs58eBKO^5Ik9XQ=U&=Os(wC2-xitAZE9f2#T`pS!Gs z->4~H#!Cpk5Pp&BPy6_suQHT(?e(YwyEWK##M|wO3}0vcdw}Q1|Ea&vo&%o`kLfQd zFYdXNV(ivpr`s2-fY-u@s`)6-fz-fPc=$KMgYaRhzw#VPE4%`(Yxh3*LiiBXU%79c z@gTqJ13yva%6*Ys_>CUr7sE^7V^n|TzD5OH+BwlWAmg$IUIw44`YZP}8sXLOlT@zU z7jK2HgX`+o2Ytm?1am(Qr?_afklu7f1MT=+`3uK$YRi{Tfj@qJDMi+=@tgGc-t zcpY3(G!DVdwuw-=0CZr71`1QxETj>)N9ko=W^f)cPv>gB|dF`0M&Bu!{X2IG4%MVW(3KU(!yzArZLF!!w?G_+9XwaNT)9 z`fBdSt_y3w_dW+cR>P&9MXW1%^uw(t^{iFu>3kpGZ{$Q<>?&ma`L@TJCFc)KiXC$> zxiEVEP)B*8e*mNm&h>H zS9-)RgD>{rLAbQPE`B|Hkq2*vd-gwE`d=46@Hp#%2hWDf_|^Frz~_1JGPu|H4#H)8 z>*CkL=X&sF_#6-30lyZm9sg^*%g=^;m0tk&D!&Xa<&Rd!zcRmr@KO(650~{v=idx3 z@!%csD?E7M3D$EDo(-4vO;>&ae5MC4gU|5bL3k1TNVR>G^`RbK=;7ZCzsQ4kzzaNh zpqA@kkMgtO=X&r0_!RgAHGk!ID$3x~;Ww&W`TfWsybiu7hC7=$8N62y-w)pq!=JVf z5W<_`%dY8-{hnptz6kGt&$+hON{QLmON#941)ik+e${JDR?i3ITx5cCE+WOsc}ouK zNXd1**13L;n_pK(_bbIV*Ke06cE!Y7e0{I=$RPe0IFA#X`y!_y_W4*9cAfKk?cW)Q z*!h|xdDp?$F6gyZ5GKlh7vUjz+AY1-))@Xqgtx&r!AB%1{>g{f^_F%s*RsF3u-E!g z49|-2Ecm8dd#&!6_}@q3=fjsT>a{M7IZv7%IZrBuZ(ZDL4ULI^P$Yg8eBb2fg^L4*eT-vh;K5)ROK9^nn}S*v@k&tv#!5#9nH`ADzzR!sh{+4)O5bg>R@d92q;hnowO zc95}|>Wp=<%V52zd%V}WoOU-?Dt6MYg?97X{gYqEzUrD@t34*4FC+Ps!q-008~gjj zzS;<{f{&~1wUUzw5NYrIk@l{G*FPGL-T%AAcDKt9!MDK^9oMo5*+xB@*Y;Wqh;MF) ztH*W8kvsxV^Zk$Odab!J?RHHhk8F79`d+I)W*qiJ#&H3B%7$L+pcJ(praiEv-^<|H z8+)zHn0g**Cm?ys`j`FtUh6KCJU>$MlzzF*o=%3?HDI^=m0s%;x!(C&v6Ft;HrTF@ z*tKFesflrR5O%&LvGd~fgCch3lUxt}sn^Poa*tB%q}<`ra%G0!7-{c2lsM8pBcttIfZgu>z1GFl%X})%?!4%{DyO{Eq;TwWg2amd-kcij&cN<0 za){)md{1*Dyae8_a$irRA6muV7q$X1{os6&yVSc6K0Y~|@VRoScLwW730%IX+uRaY zANRYuB~Jc&?(_M>R(?!5XGYfNQsPWW30uQt{_RlW$awWd=U8wSV*z-fyzYS?&t6loNTPaU$KX=BnU4P=uJuGYm)p*HwNAk{i zmis{?*auO$#5g&&y!<+jEr-)iob8edNd9HmZ5SQ4evrIQ_cIo?=&r-NK)Qt)EK!-mcim_!$>HZZ}ij(w~N{6*2kz&dx{TbP%WOXY7mliPI1l z=lJM(TRQ8HaXRItV)uz+=iEmgD=VE{|L6GJ!+Bxr6U?LSzdcgFV&a70B~rhPs_3|o zyf2B?uL`@qX<_RHvCEIMdotSJ^^~{dB4__FQl7haDD`V5&ZF>0=`XWXi6i4?r88#5 zt_!u1-o*^PV!n4ZO@E)_V;Imt;cAuNO{St?1r-I4-XWFt$PQle3`uf3onK* zx;kw2@H*n}`)_1?Rluj0hOL&E@%3S3{>l26axLr1LFBnAF3+Duk6$6;jJY9fU1BQb zNS)7j=DHLw`E+1+(amA&NqJ-7Ji}KL$tUnU_YvV$G2GeU75{8_PI*{+9#a5+4X(ZZ zfxidW?T-iHO&;;<;pfiR`!~aLJ$MIvB7Ce`zpL!(+wBv0f%64;y2_RNDcSIBxE0f1 z;mCSW01w;}wyukrf2EQ2pbS3a*0BBiB9Zn_4n+Dp$a*w&QP?__@npUc*WcOBab5bM zfjG172wR^qU!rkZ?1>`dyM;LEcZIDR2NUO;xHzTJ<8>c#Hm?j@@2T}=-1wTDHj%d_ zUKZ=h%=?{vR`bleqVqWJd5?k@xxU8km+|qG@57UL<=9pJ4|X-!HT(~DA@Xa-E}z)u zc}jk9&zW=(&wN0CJ`vc+zP<;~hELUSsaFB((_FahUznFDc_{59{Z~$$%ds2E>q!5d zA03C)@B;V}l`GGiG{9egAE)w?sDBH*0X|#h?(-s2eiwYNNBQY5an0btbKpDRy8MdZ zIS=aRSvh<%JX6ijeeOcqv6^*C_+(z2mn!WT_dH7@aSE^-rN&V{Z_x@r*Ms-L^Wc+I zfA@GI?Ub>JaSzW`IrC%SxrYsd)wh8-i?KUj&DWQ2CoJvS0$&f;?IU)< z>oi>Ilg>I(3on%VJgDTMeE+AEliR>`H+G5YBfJ>C89tuZk$HYiv|TIUO`1H!zXsl@ z;gV+~d2WH*c{c0wY$MKY>`qnlP@ZElSr5W+`+L*2D{*M|f$s&C@?`yMTorbn%j#3? ze0ff#u#vorUS>Z8y8^X5-+7V#DTk*#tiOL-4KIM}#%lxo4EUun@ux@Px4`Gab@i3? zZw1`0udy_GJX7i`^~l)Fe)A)V*D-02T=)$5Ts03FtL|DXZ%dp~>{eqZK9O;7Wpo@= z!E4}$tK6xM?OzA4hU><22)&_>O;p;rguYiX<%CCVpd6eG>{}g_&9~j{8RW4wfu9V?Gt#N z&xgWKRQYvLo(=yHu514S_?sT(m%(52C_e~)+N1n>cmsTlnxFDKVKaO)Jkh!#?cV`! zf=^ZbeP`Ph6dq{gIs$%@%FC4c!+YV0=9~Bzz%$n9{mbAd!ZX$Q%6V_lFYxfMflu=AZ-k!)AEm}u&;Q}4z;*4^2hV~}QT=7I^0%~8#+zI}c*M_z z=fQR3r5Jv(ru=N;SFj$5|9tin%$dsZGWr{r*Vvl_*owWZe@km!`y0LOCI42+Z+=q0 zpV0?zf}enG{CL`zimQyf#-TdCJ`U zd$hd@h|@%z(bz@W^Rj4t%ZT$P+>Y~j;y6-XHF0i#D(?JQ%9;|}E{)jLVW(TqTj47` zcpv;WxNg17c$@L&!E@mfUw6DHhOdDSH~2TO-*{oPy((P)MC*|BYYn^-e_j0=;bm}L zzqZ2Xz$dEZ|0Y^~AAAu!QGeOythH;nIII zRUY@bXDO!+yB6%GsCLRa6@u@D>(<#eco?obuQ2~0h3NClf{Xu!YWXrAokOR*Ywr^l zV3$c8FFUDEIdDFD`ZEjO!g@CwekQNY z`q*`5U<*y+^buzfcK7i*(oVkR_5=~0@kbsvhfh|y8$ft2+~oP%MB`g{F?_!!PvI4= zzpfu@;NRnav|7G${Aq;$b%FkVKr6g@Z=d#as(tW{@Sm&kmCuJ|yu-c;T-VOItRFX# z-)Tv-!^YTlPCm&wa!Wl+iL;b;x+kWbrIB{7f`1QBRF3%9!F%Ak<8%m~!t?04YJ7Je zQpQ6Yd5(eqAbGwOm*>BnJjE`+I??$|*nZB*{3h1U_pP&Tid_zNP3yVOBlj2fD|XKP z-YmJpAa=6;z4Jq#y$@~fyE|r|#iv{sR=tZc?fhdTG7hhemM809<;Jl6{m|x+WwCLB zQM+dBzQb;UkGwKs?UKjZw_)t_x-QDwyGg(9r*GpN8P2v@G#}rKc0qRiSwEKjp7|;5 znHN{iS<&_^#;(4B>lG%5S)|y>ea6E^MdDRqx9$Vi?xf|>`o-DRV^`bm+6@hA?PUFX z)VI$m_h0uWw3BhwM?I@E_F2cP^_(4T&x{bqV7Q(Cw)+ysk@m>PZq+HS-P8AL?aHuQ zS?Jm=c~EO7>)-OZuHBUnY3&-ZtEzJCav#>(wPCk-jca$rBU-xv>%qb;uHD{8wRSn! z-L%8C`?yAHSBza*hikWSjn=LTyK7VWoOZsqR%=&}T}h^EH+QYpt_8bUlU=*>>a=#U z{uLFuc3JDRc3G@17hUh#C9T)m6<{}YnQQm?vs$}y?53=B?OuOQYgdC^Zli0r`gyIL ztbeC`>e|hJQES(MUFbi3_W7bY{iUd#a(^z1@tn^3um!t(UYj!%ySV!qxy>AFvC|#D zis4(~OVs(L+{decXMLae_#*SO20k91srtM71;QI$u08*SkHtR`mwNV5&oOZO{=qDz zo^kg%vi{8Z6n46L=EEn!b=MK4@G0;_=h2c!73)wj{A*cHOO!k~$4vfP^f+2ioQ$qM z?S5`Ed@?*yeWkrR;HSWK`?-M+_#PejSZpK5p{t_nVfLSRUIRWGY%Yt?6W;?U)1q6t252D}uibKT*w7*+(pge+ZwX za^=2jHM|`@M&-&rUjzIbxNf|)z`Nj6RexoluM3{R`G)TLA$>dhba35yXO7FY^@oqb z|5&wrW#6kDeiVGD%GLY-@F8$r`!~Q-;JWkf7Py>G>Ed_6zoUJosO2lylj$F^5AP8_ z2c8PowOB+MYv7qG zSJuZ?mmi{X<-T_x{6743?Ub>D^9J}?s=u;dp9_Bie!j}7gB&I#zhd|{c+9#7mye+-9Cx4=(R|uG;f)^t#qg~j{uS`gJ^X9nZ65xO zaHB`xf35HoxUT>D;A1@eGd|&S2_F8r@O%&dV)!%<{|flE9{x4(G7tYo_%aXwR`?1J z|33Hz5C4o$*&p!m&xJR8_!q->c=%Vqzw_{~fp>ZMH^S3;J^CL$0Jj`peDenBCGkX5eN}LG={R#J#B#%D$Y4AkHe<>$} z^afN5<`9`_X&ebjoeSu4G8RbyR%3Lu2E$VK?L8eycftd~b~% z-+@-{a}4dbuR~+Xb+17O%FV&&Zpi4O+_)UlPTh)@_KzsS_i|{u1SMWVC{BIF%{*C7) zNAz2pWB5xEo&`VS@cxARgi?M!{9HJfy-N9^h<_=(6Mj_;cOHbb$3J`*^ZCs9cKB&* zJJe(MALhxaY8>S`#%6dbXZIC$5r?ewH#&NCI@~KJX7V$a~!h% z34a)FW-0TBzV+Q}H;a8eUqPHNu+v?q*1!+?dB3$-Eyw3Pz$SS%!so!ps9d>DZiUZ< z>#h&_;Pc>#%D2}))``_{yB>4&^~nFbVGJtN_lvB5nQ;4g%c|Ho1J9RAeS*ZBmRL7aRlO)6_UV=YcvYCl`J$oMw$J=M!g)%iGd!rP%GqZnnG;S)ZJND!dAw z_lv~sF6Gq0PlQiSQv79|oDjP{G)tTr{nlNWMa!v-_CI_bJYD6=ec=EL4 z4zBCJ0{CY5Fg3pNd}0~=Y52=3_ic>i7lco~v_JOqGs^F0)Whe)$Eod*e5~CF(vHpW z-_Go}8e`(W5{cgdKjO0f*!zUEqkNu0+Bxtg`=js+Re$GsgtP1*yf1b+*!>c_0@Y5& z*OUP(r{9aQyB#~-`ceUZ2L4rioYvSlb=X}yt6#fc6@o8=pPMkOm!GL};>ay^$s-8A5dTE$ zQx?1)eja?4>hJWAbJL#pB~A-=n>BHScfmKp&r;)%hukuja?=07^S*Ge{uR4i?0&#* zh>t%8<~4DWlcMKeQeG)`JFn>1K95)hKjF&6^I!by;77uB^DYF>hU?m`4L%k=lUR{F z6Fg@VU?9%GPB&h&;fvvytMgCldr9m%RD|8{OZsDfZ^!3sa7%s4;X|%UoUia|xZi^} zz%AnI+M@-Yrtz14>w>4k&*61!d$5<7F{?5d0d| z-+c~7@~B`vI&~=5XFp*M*2kR}9P^XN{H!BR?&9?Q*6JO}o!GW$4Hi z$>$8syw{vEbX?Fsb?AhpDN~0|x^vKlL-TGLI_a#T6V4hsZpzS1?699Qbg&`Egg`s{ z9mJ90Jn&E6&*J?Fyq`AkrmK7qblCBJ_HdH@FPX+WDZJ#Zv|ppOzL!la#i$+Rym!(y z@*M(y_x&;HfrE^f%x9AJ4>rE``#&9Q)THc`Kkgjt|7Ni9UAOMW+L`w(NldCdADM#%q){IO!tF^xlvzYg;A`tHGB`Y`Sr z;zS#Emj8<+W4eEPlCe4I9J^UFXMyIAz9YqW-FNbbeq%|p|8>7npFEe>kGM^L{zd** ziIwF4bcpd`lK-QC(Vpc0c8IZwMhh74`}}tVj30dcN&N9o{~2!tjII>_vjOAYLH>sV zMrcr%kGDP=@;Y5bKmKBlfBm7xx+MP}4>f{53a|J1_Z({c)i;A9ZL;4w)VR~+-KR`{ zO}eqx-ecJ^Pp?Nyfu&-;aDh$$y7w>`wA` zCL3@0o=RF{8jqMq+m=TyOX37;N0R?{gN$XqC1y{GQJ-?y*D1ytcd}ggqD0x5l=uBX z#%I#--}$cpZ>q7x^xv0id}(I$`encWsZ^sQ#s7Y)an~UKE2+j`2KjlvbCCb#-y$k^6-C|Vzl|5O6HH%ZebrMo!^~m7Je&3$lYjl8 zWB)eO=s9#Ty>!^v?wQ7;BY4?y_%ZiiX1p@;R!&$)9rN5}#)qSLxhmuQKVD|sbJVGP zmFMVV{(hP9_tCuk>ge-(FEjp{`Pp#JOmb#FILoO1sYHHo(j7_9&obUTl}m)TCZGTA zEMwDYyxg2S`iogc<>^lc_@U18&)+x8XrDHhXPyfD5B<`3v0xneUFd)Dm&WG*WA8n{ zqbl0B@tLzb+3coo5)wj7LJ~p?p#_4J&_nONDNRHv(nLX|_a;q1q)C@1O`0@m(m_N- z1Vo642#A1)2;Va^&$G#nzAvxW`})Jf$KKDJ(^f`0p%-Pg~F@=q5*75T; zY-V#feW7{m_ifm+7I64ei`YNgux%|bK|6%{@N2T!w$9G>%O(miyad=fVv3E8B> zxcHH?Yh0iAFA3+|=Bi+(z8vY%Q0g>KHud zH^LH!EOvt=L&SR)q*08v(5}8ej2#dG@pKdMAMQLdEb3?2}M&usk~+DmIj7AB2^F zGdIJ;?ec7BxVTWBoeGzl)j76u2=F9A%t&M3MdqDVft}7N&R1l=F$|desVE1#0D;3y^+>PPP%sgUVMfOo1F}5O`l~;z^l2`1n$d2U|>npN(`Q({Z z(RpuGWWUDj<|ESB@%&;zCH8%OF`*LM7`IiP8l4~xRbulJ#KubOR>CxSYEGiKQ;Drh z6yH>0GYbkhGriESGL;vKh^1+4UC~c{0SrqKThiEy6mbYLpDN(Yp;U1`jSVlil>eB< zrd8Hu7BSKiGi_|ICEy2i&RXJEi><nhw$S-HM*v76Rvt}cKh{Masg0T`(5VvZj) zfT2*+(;Q-*A6w&?ZC4(GD|h-z%?+US+`^iS>I<%5y0FcMEtHMsvJhYRuoFId^a!q- z`@996t1C3ppRqw!TxYun{wtjVWw5^Ciui)YAja)Pb;DI2>a>sm)FF(kvj*R9Kpq8Uj`X@>R`isu5$oC`NDbh8B$Enh9C05n?l$a+ab8q17e(Y zm#++f*-WswdjKx_!QwKQogu&5CPD8$9U(5m)$DeJI00sD-v8~F<+{&L1hCHol2vp$8i=zt)=PY5V_W$#e%r==wCMpgM@KQ&VxwTm|6YkXvM%C&nIhf-#btYRm9A^EHH*$9|w zz`x(K#FP-0VT}k}9m1A}=olkD;ss$j!xE!H*(Pga@Pbe_H&jz@n1)<*uqD6;YVWbJ9aw@fZ-a|>d8rJ+&he&S3ii7tHVU@c)?~k6e_#&} zNjwQYN7=*%C);bApc_e^Lf}je%@d*a>~kU6OI^8^1+ZOy<8?~%PvT=C=NXoG;>*^_ z?)rmW>~gYacCp6ER*3bwF@>~+sUiEp5|?~n9RaS4G8gWjESML{Yv>^do8of@6mYiq zX{+NnxUIE`eSU1bz5W9~_M=^V;m6(=$87+9_Z4u*{gHDD2e8N=Vw7ciSXSm}tIjhg zELVuzPPWK)Qvg_q_xV-T_5ThRW5U?`R@+}g;i@B^y4hvhQ9FQhzPYA_vir^nd~GOu z=$B!Ga~FffsZcgNMC=Y_3&M0fahrM4CqC>KE@t|$t=791fUoRg8QcYmbT~eSO)hu! z`H-`t_Bs!I*i9k6^I>Cr#3>&(p5}|o_?8XH9{@`OwYXk+=xyv7vCS?q zCy0&ndjxKw6WbD~=toiC^N`9h*2254~S(k7p0;Vs`>tAjG@`wp)m?32dp4m{fqB z^bt1`*c~5nE`fdN5Z@GF&m3ZF0k*(bEGfW7!R0uSt#gXeiBLG=UIE#Oe@kSSUE*va zd*%{*64`Y>aiE~g{^Ejcoxhk|kj)Gb(+jcP0pe~!b~!*?EXWQ7ith@sJAqIZ_-;Vh3`H)5Ty)Ce{{XQ=-J&V(dYbSdh#XR##+K$5 zKPR)3xy6xWb|<&klFYu$BX$&L&+>@b#o24&!WY`66|V>SX`1#j1|L6vX!yob_q5vzxbgfTc2MXD#?!I7h6iQ$)$9o z$gbS%%FXV%**!OVSk4}nv#+_?*WBz0RrZ7`d$ycCTh6`}%D&IdzR%5G#K>O6$X=n! zUZKife#~Be%wAj0UR%z7aFG4rAp5CM_9MUSM}FDQbF-i4W}@vLd#JKE$o>CvgPhzIslKomlJ?g=|2;*yg?-Hho&}$UOX;_njzz&)q-#Kj7mTpXpN$64zT?tSVnf zdsvm-hxaF|u`QNZRSjNv5c{jan>6B5HTJ|N9#w<4-Ndx&Y^V^ctFwJV9IVbp`iLvl zPHq|Mf)L>_vVpdHy!zI?&gqOs{k(z9_ zpSV_&UGNi6YqEL%Vs<*a`s_*`F|h$# zoL4Msz^>&Ldm6B1`NV|=>_$FuzX7}^DJC~$x1z<0hHPz&*w>KVjS&|cvJJ7~VMBI5 zR!nWgw&WM98nH+D#r{TYdz`q`h&_oDj~cOE@nTwIHZ(!3Zp`*2h=YyU$O7U@V|K8B zc-)wcO%yYlup^0LZ4)-Jpg7!wohT@-Hepi>i6>3inL=V#Q#PZpSl^VLD=dyQWwVQj zYfa^=mQS0qc}2zSX6#Z?v7s4Tm?VxhV^@AleWfT*0o3j-%x}qdmKIxE zvZtlRnU-u%in!I14KE``w_^Lth=r}#=(1vaD|Wc7INOSiPZhUYv16%XY-={ToLJnN zohm1Gwr0~_5a(L6voDCdt=X*dVtgBRzPwn{hRv-YcC}#_D~R)L*!+s(UK@6$qL|p0 zEv_V%wPn{Ti9K!EvNUm_ExVB>?zd&DDvQbO*saQ9MLV{(irCkV-K`=nwqqNriihpk zFI5-7>y+7_>=MW>f$S2MG)hGC@_Kz~Q=hL3*JiH68 zKJa>&`p~515%Tapxcc~_eem>IFL^lIN|T1ctY3W|rNOIw@PXHL)u&;@G-cs+eD&$^ z1-yp}A3yaM{x1UBaI|FLJy8AGqtmBDfnNP6B>c7>((q!l`b40OE~N8I=OYVhOzHN; z0)+RO)raDL`b_6%V4~JPLrm$oi@0l;<}vvHy7Aqm^KV8p0PA%$+F59qq1}S^Alh?i zGtfRn>r+nWCkNUDv?*w7plyz}E7}2QN28sEb{X0&Xb+-2hc*N4L$p3GVEkwk(59fR zfwno?u4o6K9gTJt+GS|BpgoB89NG-D57GLR$N14EpiMzr18sA(UC|CeI~wgQw9C+L zL3K&@Mx}1?@q!=g?-LeTdel62^}<0c{G}8fcrN?TU5)+R98pe+{0c{G}8fcrN?TU5)+R9 zWsDzf0@@U`HPALk+ZF8qw4>3^Lc0v@7PJS^owM@{d9P`CKo|m2Kmm2t0G>3xC-K%h$kU_!(aQ;GY$CP zJ%}kiHxR>5&ZtjVfY!f=xF6!Yh^Ha$hu9}j>xqv;48M`0KJ^g~LVN@<#rF^~{LqW~ zBm`-Hoe_^mO#W9Ora8tQ#8iHF5hq~y9KqTj{1%J)q!_q4Vw!Wkj(8O6A0iG!Y!A`? zY9X$Vn8J5Qta}pt6oSDYG4OT7)Lw$!+CTijm-?&@)%aD6FEUJH%3npq)Lt7Rehu|I z5mS9+ATEOb-8r;B%3n0%;TV3g!LLW$0mBDJ>hPh6^XJq!5yRI-OzG`|cr5ad5!Xaq zIm$ad4G~j%&LECP{XN9gpX%q*;nR_yg}5%_tB6ToF}K!_LViEuc*Hjm4@BHCkJk4> zd>S#OKQgc8sr?Q{JQDRRpXQ?xMfO;g`~}3f5SK@s7~}0f9kKeo zW6-ohO!2*pcs7P-u{u1p$3loHe0jvLpnfT0x<}cAnEJy-13yCC5W}bE*YQz$nj@z8 zhax6_^9;NdF^%U}5L0@8K@2~?p+1G;bbRvva>`Fgf_MD+5L0`3&EVfcOzD}0n8uea z27d-|Hys@-S3t-26=HXy#-92_+y(i@1vO9Qy#q0&&$p1~sr+&vru3CS+#dZ+Mcf4O zHN;I3mo2RQ6-WFEVk*DIh^hR>71jD7sP|3MI1l1@#1j#3K&(}a{f3y@Z^>esq4-`y zOz|}>uK6zLZ#&|0i0>o*)6ysImC|~;KE#&Rn93^|F_l+c1HX*82l_vYco5=-Dcavb z#5u}%`;S9h5&4dYOCx>{F^!MA5YzSDDy#ib{lA8|9){nJ_!i=2sajtW@z;o{ev6jV zJjK@(F^z}o5!3bJf}v+G=5iv{y)#siO zo|V_>q5e=8@jBH1ftd0WSHU~~wGmT(nj@}-;TIyN^gTvQ?K`5P_DB6C9dTa_zXS0n zi2GF1`ss*8n#NS$>4>i)U#PO?Dg0H$RDO36Q+%DOXg%fMT~%XhA5Re{q5mS)y!96m zQ+eDl@O{K|y(?c`hcAl$x+5-ycs^okZ~GB9Mm|Rk9iIAMam19q4v5R5ezu|CXy~sZ zjzzt_ruJVLaWTYneQAZ5<_n7uQ+=L6Ozrm<#8m#z5cfy_{nB-OL5N2prt+MEnBw1t zn695+Aa04_3)j;AY9sEC_!QzAwY}qOhIkF~Rvpb#`)z}G7V^I!E{fN~y!EvHZRFoa zOyTb%zJvU=`dUx(lNt>)9*q9>HPrZB)Hi9QG3Dn2#FU?&jWtjCKZuz4Sxq#*6#bQN zs&O&IuOX)PHqF3W5mSAhM@;o|4RL<-=V+$=Q+HHgMS%I{fPx|4PJkz0E)zjl54wtq(yQfw&jq(TK+( z4r-Mr+NFK>jge8jth0(L9acy%66`r--9?$JB?|6Jq$6$H>OyfZ`V(Q;7Ag+M=frwu~ya{nU;tPnW{MhT-Kl#gT z;IfE+#PG3ww4T;G(hyVmcS9VF`mu`)U7_KC8dR)INg|Q~4G` zTpZ(TgINBAsr>x@hIe?!K#eJUEMgj8lMI}Sn68JN4Llifl8%n;L`>@)ClJ&1_7Y-> z?A#Hs%Nzg|Bs*Q$mp$YNOH=6Z5>xrbpg$TP?jepx|BT~t*Ln(H z2Qh_jZs3lHDZII!J@6&(_(vkn!11knC-3-1A*T4I8h9RJif=<#9li~gN8roexVwQ5 z8aTF_cl;F*S4MwB4ZP35_E)^a=R-{Om4tXW`dg2f{G02wzZl_JckQ3T4@XSl_amnE zcN1|(jIZviIy{Z1qY=~m*j%4BpEukz^z~oU{;Hz?cM(&57b2$g#`e&9O3z5d6#osx zl)l)Wh8}SO#g?1 zeS(YbUm(&n98>yV#?nc#MLl-j(*N5Dw+((GV)7R_Q2V3&CLyNwH4Sk`^miXIwFmS0jrqK&$eY^#4h;VT zVoL8r#FUGQZF7@o?{e4ch5 zc`85idB;!4Q+b)s&nk}8=^uvW_fMavnd{+u&>yvriw1s#nA%7BC>=lLuepIcBc}Wf zL`>~tK4NMgUm&LZCXCkp6EJ^u4crGYwU>j4sl7yv(c!7Re2kdd%SFW0UgE}TJ=K42 z1Mfsk;WG@r#5f(E+Dm7|bUj&tI1Te-?uWQx=!=Zk{-{3E4cr+q)yF2pZP0)41n=-g z44jUb!p}xb_xEQI-{jiiKYiY~bCQmq{5?cW{;o{Xe05B3!c>jBAfA9Y0r3XJRNp@D zYCY9=Ys7TDo`sm=KZTg$-#*|8{z$CYJU_y9Wm+G zBBuCuBc}8|LQLts`kwYj>m|<+Q~RwsTl3wiybx3W+=H0HUo!Yxh$;SrIocn^AN;;| z{7Hz(e|f}IpTiA)Dq`wC+YLRNr~Q+^K*Xdki#P%E*B&vYcQ#^5@9_EBAMra86TfVs z=BYhBMojIg{vyp&{f$RV^>-I>158h)#oqA^L`?B@T%!2|)Q?3>>Dz~x^sAS7>&@ru zXOO4o>%q&lp2my9h?6kBR)~WTcSBqf@%xBr{5po1(t8gvwV$9BI=(0jUl1{^NAE^V z;jbI|XNYP2yv0iGkK!MTnDTcJG3D7wLi-L>xe0Sb3cT+|Hgd&yBNb$e*dTU6Kp{L zR3CQ{Q+@ca(fOhJXoQ&R;~m75zR8HGJXa&8`nZgk$|D%wzm^{=&lJQIz6oNgj~$QI>kH&~;elr#^=?@zEtA;-EW9^U1 zvpwQl7=P^zny2y_f;a*BC5UM}d*1#Cb3eo*3{Us}36))PG}OYn#?ndfbR9d`rYse$}>XJ=NbEh$+9v5L0;f4y~v1Oh!!QQ4uleM=#^`}#aDgMidDL+3W zruuU1(&-@_gP8m^Moj)*LQMX88R5qn;kP5E{X91iQ-1Bcb^MgyV8oQ)l87n4?GRJ? zCL^ZweSnzK_Yq>s-vI+(Moj*K_juP&KE&j&C}Q$g6ETG!h?w$g?k_U;yP5kv{-^iz zEW`9rdGA9^<$VG%mG>`*sl0RT)#X9?tBaV*yA5J0pH~o5`HV2|2Z+hv3B=^@Tg2q= zCnLPr=bfGu#LcmPOhioiU4fYLyAg2`>aQC5r-t77nU0V2Wf8|>cym8kYvif?Mk1#1 z_!wf!|9`uG>8X*P=>0mq6kj*Q6yIFLl>VKD-hRL+UjuhT9F6%Oi9#`c2xVL^_*&mss0)wrtztt!4Ea~4-wP&vkNiBcMLJ*FYuU-pY(}{slWWU z`?Xpb{`(ntvJu~IgTG+l`-VQ@xK4ivmUkJ%l%K|kDgQ4bru;89^g9t#{(m-j-xJ>D z6^oekO%aD-db%O5i+B@aO3yw+f6mayp49P?{-5qoOUCe&o@$6`{b4BLXiVQi#8jRi zBc}LwBc}FhKjoc1H{v4buOecKzcFGOAD*|L>>WeD8u1$R-}TIxxGdtKh^f3LBOZ=?@Si$-XT<#wmqEN5F~xrlaYy9KKGosNA?}0N zlRpEmLi`fy{h#UZl)fm$G+(QRxH{^`8~WLZ8z6rJaWrCIrr-3S{#XTZPD=~gTAFWy z`t^vLBDUK!PvdtQVj3?dBJPR$$B3!@``LAPs-F^wY5k}-Vk)nRh-tlPuMz$R;`$h0 ziqQUVA&&LYnARhjA*TGSLQM0i!-%Q;&l&uE#5CWwJG6gFZ!}_>KNUutgz0I8n8J5M z9E-epKQkVAs{c)hY5x5LF^xw_zB)Y=e>uc7e`|-B#%#`bg|VSrLQL1o z|8{?9wZppSmO}pn5z}~m7;y#UeLmNE!qpJxK)y9%8Xra?ru|1t5Yzay$G{g2{S(AA zzL!0sK7XLiGj`iaxLN4X61+G2j=yE9`cpZ zzqvp5lEIt%U!#v}{}ldt`#U?Lp7QrLVj6!YA|8(EG53E4p3w2p{H7G*j;J@^-=Bp% z`8W4dn)_3qx1ZA7ueQYSzX36&|9Si2N}bgCq4v@maWv-VEyU#zoBLbM{iNppI&=S? zxnFM+`lsv12?O6iO#MCjluj?T_mMqosFYFq&HaOI4gGAyF_@oih^c-KA)bx=i>Gyb z)c}1ru1AwOz#){xBCqfztHhff2d~Q z7ZKC`9CLr&Kiyws?r${rAFjvvDF3?<(|Gw$_YeNl{c_LSFLc8wANyJF@{2}H<<%Q8 z&EHocru`M>{-YV^v_HCExPX}EV+mhro~~~b5mS3Ke;;8!@-49anfni)w;$-A?zg&? zs8deqGk-th0j7t_Bk8=(50%IB_OC=<(0c0c&)Z*a?k6|*uRd@8l(}EV+#hT1f2xS- z>yG7ZuHTvabT*x;zNyLfixOV-Zt-nuT}(^5%Xf|BKom zwZF!QDg29wsXvZKO!58G{XypbJ?231IbN`b0dm_)*FG5znqkk9H&r-y+Kcvc4UB0w_P~X6< z5$n5T#ug){`LelR5S6d!D?-D33End3hyOKQ{&fGFgqX(PmWZ{A zv4x0fz2$ko&+$*6riu_Rj%!#-^@{}&HYE!e$f7@y*ETm>wD&Y9P@d(xxdGJ z-fixOF`u8B@5`9a-=FtYL`?T@yAV@(9z$FO%QNtXE)UWtBBuH>pC6mQ zr}Dht|1jTgG4})fx4-ve{=SI$yw`kR%iK@#yywBKuso>zx*`5gf3M`ykGgzGZ$2+J zpN}^EN$Y7nxEo?x4>q5-n$MH}>F?v1zlW3C_&pHwdARvJb{3|O*2}gart8aT#I*hv zcuVK+1#Ew{5yvC$jhL=?vk;TN4F*1e_(u%C^=IurFXD5Ei8r4I@4l_|bU*jJ--|Jy z@A}`-;b}aHG;n^zbbY9A;DLzgdbvBc}GT9x=st1aUo#FY=!D zN7#IxZSIFOpKo`;@Z|p;1J6NBspc>yj#rxGiGpj{_0YdZW1>zY}@N{}IH)(O=zK+CRnL2XQp==6dfmpFJdaMxriw}TM+x9|GkKl5Z^&e>)(kDwf|V;&HIts z$WwXsL#$glV>=Pk_;DLCweP@2+CQZy3Nej`6%bSX)Im)7>57>8*HA-08F3X%|0zR% z6EUSPcVnF%8n2QOufg!&B2Gl?(?si|5hoy~@u>`AN`DQ+bU!=>F|DtkLQL(=)l~Z@ zf4LFAfbq3NO!Ym);I|w66@$;+O#7$sRS=W^AqKz1;IA0GPjl^$!dF2|{<|6c5`#Zt z@IEcP(^mvB`R``%lMVie!QVCbA}ziBH%3hUCmZ}GgTHI=Ia+z=zcFIU|3HJ^WbhXZ zK1XZs^p!_U=^JS9^9}xj!Lv5r=_`+z($~@8=NtTfgJ*5M)0cpl($~@8#~S>8gU4p= zG4q`AdY7Enf!Dj6sQ(0Cm^c5wgSr3gpZ-46qIEhy)L+*bco*Wwn8K~=wZ1Uo?-5h@ zdx%MY>tk>Kj}7d*LGz@yHhSxW5fg9zUZZQ1*3<7RKJWKM%;%Zr^9J+zMXk-+KaEer z5mS77w|J-b6k@uboBQt?f1>r#SbpaEjQM*a=K4$@3{Ssz@Vw`J=KBBh-bXgqPn}zJ zdg=Ps2=Ne1|0%?Dy}XB*`d8#O@9-}oru0AWd8GL~;x`OW^^v??`={qy&s#4r*9Xk? zXY>6H^Ld52{%XEY_q_M<%;#NEJ9YY_usqG@@8v=8d~FwEY9Ho$gtWBQZ!==5Gj9Jp8Gj);3Brt%zuxE$Alt^2fo6zVH}rZLU08Y8Cp z<6y*8-sbwdxt_Te^|XFqu78>9IiI3_Gp47{ex05+h|TA-$B|FO{5&|I^*d4j@j;Dg ze~7vMdmDMWKR16bId`uHVFeuJykopZAD& zdRrqtihROR%||1yftc=hM5H z{nL7RyOSDI`!nB{eHD3XPxBB{`nDjZ^_zdXz7cpz$4~Xu9C15rFXsDd8&7NfKrG+F zXEdhtR5x%3#FYMjx}GuB@V5#vjZb$GhhTd67vAL=gqYS-Q06fw#&c#@$d{LfJlp4% z;%sLR&Y~S2jXJRU_Up{j*q8~7*($xpS=@z>bAsG|B}jv7HiKhv3VuY_H@N#a(ED7I zH-L`daL$5z$rH?1vca!4I>MMNJLlzHjJYJ^TKtLR{g%}LzWF9th~fUh!2>tJxq#_u zaPG|vkOqWJVl4PAd6xNEzu8!D<0DcUIHx2?Ivj)3JV>&RPac4rLF2F|x! z0YSN+zYm;meR7&S{z{&26IehVe=CpMhRWj*m(+AkfkJhc%mIf(b{ytxAixpubv~l} zGj~%+L-6p10gTN8W|4uEH9kA2j54MR3Y6lwISsE;qZT@WY^3AU!5csse2`i=fR7wO=hehFr~cN&{dJZ zuIvYW_`*iU>HsTOuP{kJuK>qu|AYZnrnegq13kfgc0+yZ7&b?N?Bk5ej7b5g4p5{19{Si4tGJe?|l5j2G)_v=U-;?}8>7{KGb=#p^&n_!~)R z2@51QLt>y^L5los5DLDk0GK9k7aIcqC>6+pKopatDz>1<5JOmeH%Owzr+m$r%uHRN z+mb}3)74(4Bz)1Up!4U2;Ne1V;756DWKb;(i-pSz^pzj#aOLm=5U%;Fn1wlh0$m>d zQ+cjR{s3rBd2}ky9GhWe4o={QFLHJlC|7MriHb!RV2-)3L)MG&Zp%Ri9se)2d_ z-Vu6kvWHhmRi&F_*r&kP;nfRr*3iQjf_CMSf0*VQa5jXq-X30d0+;-Qd{aJnEn`zX zyh^0}gM3TA9h&TV4==N(iz=c!T*-sm@tNRl;R?o1N{vdM{KLXW!bXSS?hq4a-vf0U zzPerKg1Thk1EIYK_u!R}!d9Pu6D0{){eCHl03s9#0Rm~z7!<9RD z5PuDZ7v2m6ZAip&Drz+E6a!RmI6a6cJ>==2llhymz)uD4eGjh^tNFRSGL$%958MGS zK1;5(aut8CGAJ*A>i)k_W{r3!4}#9iojx!;z*iT8Dri-lYE;&a5AyFn=8TsFRaI|g z7SSpG=6Z0~5(GUwB2T-?8u3N`>NIdS98{A$%2-)FI=bI@8Mqtei-FtV;Ui&4&FbV2 z?rsaBLm>FdBa+3IRrHK6ei1}+&Haf-Bx6F+B3XBNt*bEEtiE*K1*lg&p*20p8U@$gDv}-v)cDNM9k)T~SytFn4E-TcD>FkYdVw{457VLd z0d+Vt^fa086;^@En6&SJ`XQ6PkP6P%Tg{;gRLYqXCModM`HuQsrhJ=qI3AOh52*M| z`X!mPeb(DB%}^hQ( zvtG>5R}=m|P>Vcth_)&hS5g<1VVxsJPldxom^3Vf0ZzMN3*;@FE}Fgv7_%o^^*nrQvj%q&(5H$k=8O zJkfUgRq)&lxHiPIsHc#l;AC6peRIdZ&ZjU-kc`4xp zdrVano(IwQUP5#>&t5wZYMub^4`q_siS*1_$GX+NY%mJrL6qzf>b5Zl8b$DNd&NKS z`cez{_8tv%51fvv(u-8;T;hwxFgo-F)d-JLUYuN6Tox0{*I|9m1JP=aP?d@1~e-&nJcq&Lc@#9~OefxIwIiTPPL(G7xR?2(z>gCEO=Y z??;a(L3F_*lpa}>(tIfv%)o2;ufW@aDeEd$C5&7NH>JVX#oh`~Ns%DPOClJ;dqIN! z5DRW%KFa`Am*~uL#xY8%Lwx>(*{4c=7f_D;7wXKw7)v3apN?X<4eX?#i~#d^ziu*E?z1~agf*W1o4z! z)|?OX3GhXA2T;EGH)=Bn@A=$I#vs!`zWiSV!5pmiIhY&Odq8>NZ`4^@oyx&=pBFb^ z5&a7C05@eiGY6SBU%I;Q`W)i{yzk!xQT<*1!5}^k zwgzLF2=Zlr6GROr@(%{d=NJc*4OJVvL4MW~#3R%LN|-}VnMybw@6+mAAoK~PjAvGK zW?6;(A=`P1W6UX?i@cyN`!^vnt1qmGyhfIDlq{x0Gz9gFo)DS3sI7HDSI2SiJDgs< z38KkTC?^j3?%R_h7P)07q`aA-ePTp8l zN)Di3aeQ%#YdQm{TbXoe3+UdC?}jiY*D<&VgJm%I;v^>Q3!sNOeuvA0OcIX+DwXKW zH3Ym;EA=Et9w>aJZVbwf9<}F!#-fyPp5x+p6b=H>1dlLFQ7PdXN6dN@E&>t%OG%D_~$z!iOO8gBg@Ad{5L_-JW;sIfU`YfwI(J z)htT6{n6363<~RksGUccC87J_k{kS+qa)mWsQ3qfXtYO|C80{_>)RiOU?p4tqD>y5 znNXz;_gxCtV5L3|%5VRwW>HF*=(`=J5lZ+FL_Rqv|5*|`1(w@_%lIyZQ9%jwfvA{A zm?fb~nC?5cK6*?CQ9F;&OsG;f^F0bHa?0%hP>%kqnnfvLH{S+DDgPi^=MiQ}Xhj%8 zf(Q6+TaED_2GMzsFiS#}aE$MvD=7R0L_RP<`}?X_>Y2VjKqu4r2W7Fps#%m0F7r)3 zhY3vwQA>|7OG1zJhlFnSbzDV{uY+iqN0=p{N_f!MbrC(z1<^W>&@54G)@^nEvm~@-6{z|LzI|&lR!MfIC=eC$2xVzt_vj&4-h7?+ zC&61ID?nHkMD;yFnIjgZG>OiUAED-D;0Jp&9%p#fRO%|uaWEb!k268J>0hW-BC@8W zsj~$vq^oepAi!zG?*2-{8N-MLxxiYKd zQg2ND)gLIccAGNmzf|VqhstaSStlhMizu_HrZSs5DzoKnWj;w;FC|-BD6{PiWwyVk z%#Kf#*?CQwPua&(xx273dmAXTueUOvy{pXr4ayuiqs+k{l{w_vAj2IltjyU`^d{rW8x6+h(j0HE^%Rgh?xbjT8lhCv#}w|}A^ zdhyCY*OU@fFa6ey;Ol(w_kKAGVn7!j)&~40)Ghon+)Hy;D{-Q{v>gTk=kp@`fvArxl&3mP zmZ!SuQ^^^2IQ8-(c}hwdE0XX5+=C|HcObm&$F4C@)iut+{rgYyk`q$w6F9sjuWQBR0+8+Ao!YR*3URpN;L7GI41ZYA zD!|EIUT3z4MPT_wHjyV%AxW)Beyty~J)SsEx4WFtUSx#4INL1Vs+YciR*-ZF8CLzd z8VgZG$dzrIiwF60CQq~=4U3R-d0QZV4O+0&4sqcfKX^1ME?EpLqN*&sBt8m87dI{8`LBDJ3YZjf8susG zC+OzVkybH#z;>8BMfCm(GVi!q3?l3+51GRT_j3{bR>0NTH}0cua6G8@B}mOH9%A{DErKC)N zGG!x`DYrmzFRW6g{AOh;>`|st7bQt+piC9H-6WdY58OqemuO#V7%G63# zrgk-D>K;{+dgqj>|D7@oZYk5Kw~{n&ElpzS3Cg5wg@TVsEb|4J!nxq)n)@^k35KyP z?tsd6?n*Fhw~%A8y*>osQEltSL1&yc2?~nGZA^tZ^6SwJAebMV4uP-pedq*CGkwb? zf+`-)CKIEdnU-uipR=epBV-Mv5v4DnEJ#j%V+sy91%6@*zF}>ZX3)#Z3>l-$utmxY z|3sM)$CVlRy)vT%VGa{ha9kl}CRA2tayw1AFCWj<)E%=|veEF7oIqE*T~Ed|lW7PRrsQ>3-?gK#>wpbx*Qtb><@`9^F(U;ap8 zCy!Lv#hZYQDb%q$jKnd8I)&_%rb}*Rx~3@ea$RM*byDV)x0LBVRhd_pEA!eBWqSOi z%56}gYgRl-to zJ5=NWF7KI2$!T2VQQiwGyOi9J6?vM=@it;Ptcpb5(?Q)I5W<2M+=3YUw664U$83YV6-=8kgX;QR~a;k>Wf9agxE(!2M;T3q3ZohQJm zC~za->rCDa>1_%}E-7bmN>U{!TyOb%aN+~fuz2}kxp2+pzcMD3d^7ynA=xtE0j8TU zRV`fSohpn;XZ#EJ^R`-0Zys{wq2&PPj<|SB>O3_6s z3CM2QI~ySXa&qBF-2^!GqFjwk{T+6eS*a_b=<=ikT!MbVG&w!%KH7o%rEw%et*zA*f zs6J!0%Q@geV&^Zs8wL#H?1iYNoIQK??49zRI&n4>J_A|V#V~Qu3G5{bLINMW2GZ2m z`$BZ7pInCUsmsB?Z|V#fpn_BPU4y7z2!gAwa`<9@rX3y`1BulR&kTh?D#vqbONZ~} zg4k2LPL*z>Ysq}S`4ki{41-l}<>dDSOx2Fko>W!r1(N=<*!B*PPFj8q+SGKIaq!eJ zvmk9Rbc)iMVtMz#(dEL7RY-z~8+Wv___q+GVuRBV`X#F~^r?zfAHi`)OHMi>rOMIH z;;`z(w}WsGe4VvrBdAnVQthpV%OPE-=`;?=X&*utaIE377J1qy&`ur4xy&F>tMooF zRe7jnDqn^QcGTc*s8!B`egi?3&Rse&M=gEIs=OL%-BDK~dzEfo1~NwjjeILF{1MzX z)hM`fDzpYiOO2wd^y<`)IofEHR=H+0C_890v}$W;C6107!D7-|&{`Z_5n5IAL#uIg zM`*7a0jQh$b!O$igb2YM8 zo(pZp@qtFH%1ga_Gsk+~MF*CZTjiyGT^Kx>P^YZQuh~GpRU>kp(^Rb%6>ZyBp)Qk^>9$gtS9XKRI~q1v7Af*~i%=}@0taX5f6oGEFpUs!cO#?3LxX7uae)_^qzGPhdN15rEY6s!R87zM|*5#3l;ql5$kEANxLR^aI6FV9$9Je<&YvNx|8% zdTSlQ&%i#C3K@Y*E6&JRy1oJaq|YEoZxnp9D17%pH*$901w~v?GBR^8QB1VpY*jg% z4w5A%qQ^qny9UeyNyvJbNV(pYv(I#S$=na;y1}=n4F2a02%UR&Bs~4fEAPE=JtEI| zxa`UhdEQ8eadwY9fLli=95C_XIJgEo$6Cp-8juD~urem-%IFHS1m{FK;QG3y(m8qT zQMdwv?nfD6Fu2f_AtlUxrYuONHG=Fs0osDgfs!!y{Ki1ctJ)8?hr-ERnM6sL7dV&A znax=eoJ=LcbpobHEL0Worot{=#0`OMBNY)c+Pv_Gg{mUny10`r;y%E>Z769ep)I+iWK?llz6zXHXfz9+Sh^T2-Zt*F%>E=10w1z*vMhu$m; zl2s=bza(4yxo=>}#7CZhl_lA}&&xUvkyAkD*RlbG$a-~Nkjo!#8N_)pA%(Ge0Gq(q z887p#iA(#ta@G}24j>{+WrU7^n^ou46@s&3Ku?12bSWz$!-qDOdCr&;%~?)3xeC7P zGszRM+UmSHp$TIpL3{{^dJx(lQ+c9AbtU8Dd`S$e?uZ~ zh@CljER=%EKhU$KMCRY6y~rD4XC8j}Q!QB!^bT)HZMlKY8OOsCbU~f;rdg1zrK0Z~ zk`-Ho-z-TrTT0bz5|>S`lziF2Sxg_RYEI_mAQ7eH3l7fWTrQ!7OBc?Pd_@JADZ;&U z1^7BEg9w?@d{G^E6ar^oA|^{!>(FI+iDsPj2Y#qWlP+C^sg_WlpL9X*hV;$`dcKr2 zP^@YSX}sz}n6p7rwg9s;lU3DSjeppWv*sW_3(N({s>FpUwhoU6HUiGxgYTcjVr{Al zZ^G9s(hkC*jB>#j9VoUnZwst+P!gDm#Aa;{9r-O-HDCd=1A4iX$TG;<9NyrMVd5jxvK#0l-V)s$hVT!U=(4)xO|u|bm-bI! zo({J)UzPIQ*2wDScw6%ag!#MMnoy9_ZH?07ZB4G+oYe-dHGG|&Woiq=ZO!+q;O0iMtKiRi4~w@o-+h7XVPH;pSb19` zn>7o%133|k0^q{$njTu3u1)h~m8jv&^+6o8HZ{n(=F4FwcX1f$WD8`%XPOK)pdJMK z>jf(}U9fV?3zi%cbIS{s94DFmA#~{A@RugSAX!4j%6OeYze7KHMLD+o8o`V)yr%@* zPhKp;d)huE!=Ta=s;rIH5Bfef+FzkNtFW?P zGcl*H3^u@mJDBG+TG@kDqg7qSK1I&5!e6Rf4jQeD)zfH|V`{V#P^0|-RMco!sAJt| zH_Bsdw2i94aaTyqYw&eWhA64g-YW>rc_^HnK#VIEj;PV@gNq4Y04G*?=$SG!Hrn-2 z>Qc`4!JorYGEcF((KhJASq;fvfj=3UtZua1dO|Hq_9^_ar+UKbMjJX9p2vYNo*S50 z$*NRiqwV?@OiyLla==t4)~nIJxdI)u1G*DQsL_@ORyi01%xGf08f~von3&2q<^#P_ zN@U(#NpOl9ZISI5$6lb1dAw+eZnTTbqnB$y-|_ZBjkbL_(|PrUS`US<%Bzlv8ttt9 zSe8YAFC#VcJgLcSctJA3F~#ew0xqU_m?K&|19fm zm}>D-z*QpNHAhCGUdaiZZ?!82Ps!i}ZwY)SZ%yRJoe;+wYvd5{F%Y;B9$p4vQLW#F z3~#oY!hMLm6XNrLUo17t6+PoR(A%scGxYqO?*M9VCLP!tynkxdD$kjGV9zfAb)9Ja z2stVl9?%8uwF00|%0ADZN*>Bu#eg|cngdq&Dt)WLV}UQ~(WoMgtoIrCdCB?>g7Z$m zy$xS=E0^bU7*gblYR{M9au=}AR(vZv45N|NCJD$eg`z? zAoNA}I#uIo`d}u6==X^nZ=_%T0RAwT#VT4?a5MQHYT#RomxIO%Rt=En21zW*STp%T zYT%F_yOhGF990Cinn%%GRl)GmXY`f{@MBl1&Y4{jWgiH^<%A>%AwB<;|2kqoq2QH_GlGYR{GD<;|4)#|iV~v3y(Hee)hfr{5NL z|MZ(WmXA=}x74!)^=7*Jw*2K89=8f^gWZ2tUk%5bAolI>b@u!Ql95v}zFamCT3(TV zUjQOb2Wbd&_YgQqhfxatw{1|HE$S%S-XViOSk1_G-x7J(iC)Xt&M<-slB1`>uV9tCtf zNn9#NYLs{H;qlO4l%^u^wLBV?E3G-la}PvKN8o#SG%`IbQtni6-{860Lp;NQo95wF zZODQ~QMk1p9&+&IAlTp$DJSX;Pj`Mx-pjUx>flF#KTR6_hNruTwKoo)!%O-mP6;dGa_E&72VO2$yA}20JSPJw0y(U{hF0~ z5GL(2pgzx}GnW%_R#9>O!p$onhrJkCY&BA zDcOltC)96mx;I;OJ_OHmfLrOsyL7XVuW-7*wAvR3C%ZtfpF~W(!s)(bby|qge+$(2 zlGc?b-@|nOU_E^uul`SfvZ@gsC*SZ4t$gPd>_#%x$J$CQTPUkCVC4qM?Uq&n)@w#mxeetEd}LzFSUNF%{|lp z%de=B|36*+4_n<%RA%HK{VI)nm3=%sw&u4%@ViGOhj9JkvU`WUXgA;kYr;w-e04oX z-s}TK?G{BFz#UsbIGswAzG&+HC~x81xkb$#AgT|7R$d|&*AONQq2G--0dxbJp0>4udkc6$f)&YbU4JIV5fuNWasV-Pb z#uG1p5+iidWmwynDYR+=-Pj|Mr%*EI+9Z^82l_29iA(9i)1jK(YsF79Ihzdpe2+$5 z;N?Kgv}T)V83}g*!0+?c$bBm;t{N=xhPF8lkLkGlXASZPz11Cv1Px`1Fazp6+_(+H zqR~^R5UtbSxQ(+VMt_*^@q?VvzuH7Er>M*i-5AgjS zUk^KAtlpp)L~;rKl9V7>bCKV|T{eVS+ZVzt0oghVBf(!16giP8d5z;x_+NnH63Hd_ zON!LJnJfbJZi4zL!=i)Vg{;G-ABp}CXV(E8)#a-(r`HkeOh5eB|I_<>?=f$ zebDFS@yb~0;AC4mtb;zKhGPU*wW0CpMBvPW;g?W{6yD zGko3RFLJ{vC)SclPW;g?V$Bts*EI-xA)7MG1&DfyE!7y*U<9f$u44f#Ldq9dh$2ze znZ9m*xIc%2Yq-3{I5t>k`s(9^g1U#$AP5QK3npxx>HA_21S4(8Izr-SY{3;LA!!jQ zx3E$P&c6#*8_|TTpKOv8&oa)Pnlr%g?0A4i-Gc5A&#+c-x1>8Pf>IH!CwEiEaQMgI z@|I!T8fafF3{L=y(hZxPb0@?4N)dj6K6$;X3?^4D|AQv694$*e`5alRL zlCRt0R+eP{KcaE+0xS#bVons%P@(+%4?**M&Pn9za&Q{qJP;SrpIOYsy|{>Hp2Zx# zAyhwsxieRY-sX%)gM+(Q#4&aF+X3LZ(c4ZyzH%Ay{F7Bc~nlxqHIV_?-fcLCJ;pk$a6W_;#Oo5i2(+R796d-N0pqBc2%-izbyOr@Y zV6L)7y{>~?tIn3Cpr6dntS4fj zT(`*w=dvF3D~fRYiJ0)MCt?@TV|E1A7nk?ND@bc~xO}ABPsBF9fOa+p0TXSG{X}dL zx+pT$GW=UjbSgC1PsE1f6Dw4v_T%4S2eqDvwZNoQ(2GF6a8N!GV~=hmRLBld^!w*A z?AralxcS%@2RvPe{=Ki?9*I#3@^x|fmctZ$ad0_(eQ-65N(kta1@`46$L{O-cyzLZ zlWpm+`uc&WcPd>)WG$`D|0{B1_w{44VIK?r!wzis_5IM_N>wvcMo=CfI=i@zy%Ab| z<0}ZU`^PEw;rKr}ihmQktvnzj%6;dk!tgUyL1ZFP55Owleg%TkG9t3=);c{%ECGtXeWER+0h#cD{6qW}|9h_`Shh-Cy z=mn^h9}V|?#Pam};IwVxlVk+Lf7XG;4ww;$`Q=FR>@P^R1RU@b>az2zIMF-&Rsw`UC^MGD-;Jkz*PvfkYcdt5<9fv{>8paa9D@iFrwB0zw+Vwlk3~ecE z9IKcNJM+Gxb}vUIb;Cr}yG%U`xBnQ3{yQj)_8iW<-zd5bmo$3s5$OOTOD+Tds4BhG zFiIj8e@kQnm$$qmNYMAywMCe_As_)r1)`>)9MilfRPjZ4^9oTl1k%hwqw3BE@s!$x zyrv=aX(FOkBWF}4jH{y&I>knOHL2E5U7B-Vb^QpBxqxqSI8TxjRfo#IQeWjp4*=-6 z4eKI_Sp3&en2ks7r$Oa)o$HK81-LUIyfZT1sg!q?X?aSZ_@%lExR|h--0k%i zcQF=KlP3YZC0smKrfTv@s<)(z=Lu9zIh|8V&H$^La`dWp!4CzxrcwXbf0;x4myjq8K2Kt|T-C4~63!anTO5vLOSYN4*IXZZEY5qt&o~?=Nbewf zZ@V_rhHe16=ipKkEM$w6&0QX2qsrM9^@mGmU6jZ+vp2hY^et?{(pt&`PqaCDo7wAk z$3!S&7vW}r+7K3Fl6_=vF88jzmh?bCLmX)h$GB&sYZK|2faW>UvXAV|;~tAlo}%(i zfOa_28qV)7KTR2L6Fv^;bU>Q>$lk*4ZTGM*PWU@OcLLG^KkhEy*^lC%jP>MfVs`=t>`WbC6ct>fcghuZZmrm-7)Pg zcoLxL0hrs&-sU$v&^QwYxznWz1sSg#aZGW*6Y2LPK*pxtH$6TPoz#1Kx}r zs?eNR?(=%n+*9+Q&r1jPOjewmxZZ*8E)Q|^hbkrmo=Zv~8lenw_aAA+vJvpEtXkx= zgx+E9lhx30KLmCztBSb8HKB5>I||k<(fkPfSDT~vfxQ#lkD;%VjQBfXaKUAj1vh%V zlii!JwIR}_0aYX{-J$FQd#AgPg8Ms?vdQaR>cEshH6+r#3l1imc`M-$~~iZ>*v zS~Ou%E=0I`Rz6GmX&=JhJSZJD(3F?V)N1vWn`uD5edcix-&k&SCJ@HcFZ5zD=0@8}?=-t|8IU9=&Ytys1s zo6GOIPR4=s0|-HwtLQ3b8l|;b%#PTx$`#^%uOFDX!784WDJ3df$lmioJ>Sy3iz^wV z<|I08KhqYn_e#*PZqU{XglDs8GvZ_mxv=|B^xjgEQ-RO_J5FhL8FaS7*$n((7LHE} z+Rx$)yiC9oD6;(XS4Mbv-6P7VFg>gkoIiNsT*S|>bgCHb;%jb&DwPb{bD8&2L7Q+d z^(5?~N{P;cCt!~}SK@xv5gF+6{Q_kqex}+%hpPR}KzKgao`J3|&tvRM{6c%X6vG}> z;+NV}b0<_KUQ%2HsxF1FO_6v-4d?=ozZL#>QF{?`)e@YDAtCWA4R^Ug&ov9#uo#}N zE#wy>*DYi?J>OW!9C~h8$W1)uNc`49&LO*rH?=3VEH-2k(_L>Pt43G8)RNds=AUD7 z<<5i6ki;L|VytUxPoOVAdZMG@)$Ilvf8W;;Lmt;6*t=+04t$NxF`_(} zGbi?RJ$_ypdk}iiLE=kq#?lhSjPF_u6-R;YUApua*FYDX{lqz40e@DU`FnKf(oI~S zZwXn1;KAa_j^Li+!pnw#BKSG+co5uOTw_|7T8iL7;_)N6hq&-P-X9R$S3D62P8V0& zWKUnCQ{;spT3Sze!zeP)ppS!uoET``nW(5C%{R`zg@GCWl*joXy!+Zl(iyaxg%MxQ4-g@G~!?!J= zyDgSEHood>#Wu_qW0;X}*FbvnSIO2CauuJ0Ipj~ww*6wJGhjyJVs2zFXAk!+RCQ{> zPjDb;K@g998L0=F;xy92AfEOKiEXkJp1$tIzabsdpluE=@7*ilX=t(g0tOtl4#C@O z$oD64edKP5`|bSr*6vksJ^+3;DX*9ra$DsluwQLl&&G8etKFN_p&_ z=zXD3X{F&K_wgo>FA1!&gUk17bQ->P4?c}81PG`mz}q_V+rUO0Bo?0 z8*x0WnlmcsS`Ndgij=7tfaVg8yviK%v}(@ypnE7b7M*$>&~^vT(<^O|k+X2nZ}%2Jq+VnOCzMjDFqahZa2e>|T87b%GUJU93 zF&uNV0Yiyj4j2Z`7COfgGo3l} z({3x3YRBynNC$mT2wC@c>VOtmo)EU9y%VZ>IhA- z5nu5Dd~Ff-@>NGby&SkK;aJfdsv6t@J_6Vz2M-vO->>SR^s7KXtpNU-!;vV&==??0 zbc}<-c^mjiha>SsNjy)gfwOP|1kg_oTmxEl@z>jczz*3FNie%2T#`fGGNKBg;QiIr ztmSyl0jL?StmV#7tK3;I`e5hZl)K@-k20?G#RZghSI8us8jC3Nm(2DeJi7BJm5tq< z5nL@N5Z{@10fh4v3Ex?6Jf;`GCXnx3Yi#S!0nmFfkXg*?LoPEF$#%qtkh@Rv}jy^f5wYDdOj$brROfK*(^y8y~ZtU`#r0oGdw>(JhG?W*CPbd01aHUVR2AK|6M&~SpqGg5>B3Su{)x9A z{e}^?$r5AH*GC<6XFP@OaTqcZb=WQAmaC?`3iGb`^bT0m2kyBT#Z*l`kBB;MA>0m& z`q(`W3REmtt5Ij%(?%l&Zz29;xV&pvR=EW_?{0=krMisZ>o(*Y2A2^hZ@hfrp0>v@ z7@!Q4cQ#z!jTDy-IqEC-M+tZXlW=}OMFX(BKJbmZHa2hO5Uv5JP5_qo2flL`fHiN2 zI@JkK55khRIDvn1*MYgQ)YJ$-lWbVO01zjyz5L;B7p}C56~Ncp97Dsdpgv(rt2hYg zeH*q^$crz&pek#uXs!bPo*ZV;HvuslaeRF-DrZo(B33jWlxqYoNvXw=w+Nzw)?w_H z(>) zbel;Ik>~J!CL$s3W5Ok~z2(5A^xl2Ko>U;_tLi%-dZuN*rmnzaHAfi;q~Aywgn1RI zF;8crhQgDX$}LqRxI4EEeP=oVw7MjQTV2u$)MQ~GPvVjfj0IlA$1z zN}oSM8F}igJF6SX5(LG&la#?T!GWejpHKctBS}v~my@T?$e~*3lr6*p2?){WlYb)A z>uyE6PfYlHwk{gXMFU0i0BSPlR~~u<2VF)KMB}cDE;KN@y$zX{KfYvFfOWng~zkgh;_BEJCNR%w}p|X6n{Qs5;I4 zH-PGU={i6?dtUtP%W%pxc*$ruC6zpaZ6xH}4X*1Ml@Hxu=`#H>s~D^%yOlx15DVcV z!gm-x{Z96G89UQaarwx}X~59dC)8G4;x|)S3bt z!8M;mg7ep{iowtNeByoN(E5BL>poY#OZ?1XgU|4!0GbPc_!utlSw`$w2$p(7WPulA z_?e@Gy4Yt>`44-T*}hy6wRPox+cONlej)jfdHSc%ht{K>PobrMjS*Nd9rLsYXry?s z%`mM1w!z?=iOYL#q{1_kpcQ&O+t$^q$TIB=F$PW_j#-8)=TGt)%Mfhvb-vVuQRVza zl^=+KjP+o&U->nr?hn<`)$pj?WaRu^{nQ#6{~i(CVKe+j@I|wcz`)`y4oBD&O%dDK$vHfbR2`^rJQhAUi9L8D@SoB`a8@-{!`LqiAX?gpfg;~x-bsN4!q=AlxLs`IcFtIW3Q>j1Tbx@=SN+Xwu}ii|12 zue}SczRM-BKGI{*XKBtD^m)E>_&PAeqJjR?7^IAZl~uH*vXR@CN_)4hlUo)4W}V+5 zR(@$^BBL6NLh*Hg%dyTbU6sHavcSG3oIQkuQUN|6{RM{}9Ayf{CvgJw(FNqM{!gYF?OWnewdrm`-nb&n6 zj{>oa7?2AP10$jlJ`r=E*hb0dsr~FhE6qHLPdRkPD$<2-J7dzr-Ij$+6dgu--(u*b z#-4-S^XpwZ3D6<`jC9V?y&pY1qYQ5MogtdT3{Pm;b zM)<|YajauawjrS9nWc62AK%omvUht%$sjfK@7s_2C^ESc4#K1cZKkKaW;eR4fy2c zftU^GKf+q)dgHi`eIO`K(fw1I$SGf)Q^QCoo_3=UHpa>*S#neyiFC1_l(dk zI$c;YO2(WniJ~a3%(1#CioO6Ii$bzu3&i)q7{L9lfMn(ZpNL6xcv@@hJ5>hnNvM!i ze#QdlKO_CUMW~W8KclN-#rClovZ}mBMvVIio`;@L5hy8AmJ6kReQO1ZFOWMHA!ea% zBc@adks5;a9~Zr!*iu|9|Kpd=(??_=&ri2NYmnL*VP*M$?lwdpK$jFb(-VSY3w*gC zP~Z9I;vD*Vg#1m#Gu)?Zzw#l-xA1H!iFZS@$p4L)miQ8b6JqRx<@kPELhR+QF$N4L zQ;dya{fM#l5M_LyMc#=qAg1jt9`@@R1Do#=1Y@qV6F!n_ zn5$i|l{O>jc6+`3cZ%xxy&|#Una%V@ofxbUQ#L<#nqpMRMjDP91upG9%dSzN>1W+O zvO1XkIoQFxGzAAdo8X~1REWS{l$4MEj5490qD5@khvO*iZB$GxK#94Cm5ZyW3Pq33 zo^K=*!bCfEZp8GcfzEM+|2I+HAf~WEl=M8C3%}v;-z0vn4T)sW_!pIN`@cyT*cU>EO83T2$QUa_ z(&(HF1saXGbcQBhgxE08mu{T?L6_e7-$ZqWBK|}%l=LKZhYkEUiIwPVkfDxCm2vn# zNyI!GBt~%m4{YM}#cNNLqMfn2^=@TMi{>!J91>xTN?UsLfv8)}*H5h$1j zJM&<@15p%PIhjbxZM41A6VbiI7a0F>N1)QGSX>ozxBjD1_?#62n?crJfsjktB{}y2&oiXQ& zqd-@>7N6ImVJ{+Tj&-ESSQm)PaT(F0VF8h`o~Chlorn@y3T5{+G$|p|Wki>_4)WM+ zvnS(0zfJ!4z9hO=eJR02G{?37CZlB(UJY61UI)gjM0CIOiEBv zCnXs3!a`J1GuQh3x@S2Efk4~)4?WXoHKo-I$Dql!^k)|NfA5*nAKTqO=ExYm270Y77wzE6wX}t6ZIIxQ;-;Ek-__+fSU3oF8w7S|~3ZHKRE34VC zG&4=Cb(KEM3yGUynEGt~HvzFYEwyI_@;j^|+WI9*UD#&X^G(YUh{lL{{T3F6FXZ|W z<-&t7QIjC>-xi}eFCvzr>Z3yV>0H!iA|>rsYfZC$m=8)1*U;TM0mDFXDo*`}c9z;e zvA{mTNx=}84B1<&0gRS1*M1UOsbY10LmlT7VZDkIMS!!iE+N3V-Mn!*w5md zh>U^rV(yB{J}!P^>Ty(6wV*$m>GMf@>_mtWTt`3P<3FQJzL(hFKZWNyH$lnT-+zG+ z>#c4PlP#k%Kh8!0p7cM5qloCR0wy{ImdI6wGt@q^(2*5~{7XWoXRUTxZN>hRKk|(^ z*bJt&|6y2}_PhRQ2&;)x@dMG2kY#q9j~dqZ?}5_HwQ-3ytW%&oQo_vAKX%|{2H$2b zKgPN-ALj1?yZRrw6chNnT*lztXr_1e2YQFN7BxO%5sPx7zRCo3f+4e&^|2|B*4N%0 zNY{wMD1e=Ix+EiipRVf8Nb^X#2pDA!!vgY-n9~uj{-SUBw@iw%zssa38#Zz;p7k{e zgCZP#YMT!|SOZM-vbC&>|3wh$KZ+i1cn=(ME%?NG?BZUp0ZJ{Lpe z3qe;_Ax4-;mQ zz|Wr9&oI9jV8QrOd=ao_zt$5)rv1mz>a@ku<0tFrTlc;ahv zJ6wN(F1{8|>gq4h#V7NyuPU*!)W6>fWPf<7`YIQqF+Nx{4=j% zjX^)#5A%BWhk9g4A7@e*)W6X!uxM%5(# zykfBqFxsj$87hV$=L-rJKg(Z^Dp>q${$NzW;dRaF(w#~?TkG5f|qyZkePmtpu(xx1{N1-aZ^_&Gn^_`68B@#l}S-7ku4 z$b-<_y`m5x&q{OmE=VU0A$OkyI{8j%?x*;JNOEE^cfa@1vcvfbY3}}~;Pk(Wh|^a` zKw#>z`AUAO){98>4||mvUmC!Sv3NLAn1SaZA^(h#+px=$d-myY-AYDoybSN$y~T7x zA2}osB3RH0T``;Q$jXi3efg(b7J51s*O44z{ydjI!&EP(Pr}N+<=*| zn=~9V`JfvV*=F*kcq}tHOOI_P&lZB2JoXaCV_e?ttY_Oy_~ABH3&D+S$hVicZ6;mN z(0@ZJRT}W8$$3j)%S@W&z=JA;su%HZN&vRZ`Np76P zkZ2kMZ|msM9Lr38+KMykOztzlM?9j(GLzCptQ^k+zTy!*mYJOT+|siL_}h=@vCQNZ z>?X4!)Th9&+8k{rw1I$`1do3Tw5mN5=b?|!k%&INSD@#AN_zfF=nJYoEur@@TvzSu z3<6IgOGa=x>^efj@c)m7c+rrfu4vf*|IyH9JJWFLC2FYhkQ($*#zSq^P$tfQ9?JNL z0mocDqM;@hvzCT56qKbwod2vrdg$PEA4{^zxPXRF4mujd`Og}rOB!Zw5Dok-Co2sX z0~*Bn&lxNmUE%ciHkFbIEA2q{`A1}j=-zdw*?*`kWu@3>(Xw0vc zS>x_+7va?7?n5~JRS<_Y?sl%GA2W_ckpB3VHST_lN&jL71|AMsoO zlt+Bkx-Wyu8HS#XN~YtJxOR{!NPJD_O^NtgoS{qpw> zKwriw7s_=4r3YzDjS;~Q(8UjZ=R<7%BXAk6tlywxsP%O~mWy7N$(BU~zd;v2^wLwx z-~;9he-UM<^^w4UsH~78_!+wRp#zi9G*C#9xU$B|Q0s$%0a4i)kKmW+;zv~e4O3T; zs$~|{g(GXmfVueDS{lz8riWfWWwvK%LbP7?xZt7>LvLBk!!Efd%h1ci+L*h|6_32^ z@u_Qrc&tHrIX(8E`~s4q_Tk@KxV&>Xs@j9{YnZ;Ovk3muhJ1^N+k^61Ok$@2QorM$ zu^8fO1hxj{oamAl5zY-Le*m@y<%byRHgaf51XP2tL~akt{V?g};!w2#)ZK=&4$2qM zv5JZpfRD8~&Y;{IOFvQZGN3g!oOMucgW8rnyb1h0a+n7nkGea9^7E&xXs!Ui<>=8I zYfw&aX~mTdRTYjavmR?uekR@0Qv!G;a+qT)E^AP(Ji*eF3cTGTdaOZt>c=QpmfW+z zhuNG=`vRQ1$(vY>{av&HZCe&FAbHu!nY)Gdf+BnFR#-finZ(j#n@Mks3hD~t`iAj! zyPC;Ncv?d}Kyb)X3-a|QZktK*9C(KZuqp`radHL;Y?;YB7Y*YO;hKQz1z^ieMtHFI z1HS44D2=d0Zkve@Fk6Qj1!%GjXEl=?kYj+yi+XQ_A#(1$jh)lA;?TY0z! z{6}(_2j5!6?3l@hI#x7Z6m}#oNvXxL%;fViR$K|d6UoV>$1;!0{6CN51s&jhXr@fL9`KVfO%iG9EeARWYAhmy)Iq-?H zHFMxgH!^dIuf>y6*35wiU#yu!cI@$QL2>NF<^2ia_RJvzUB`O}JYxgC-v!k(hv+!G z1_Od3#?mY@pe<9dLLEfsfgMZ-Ah>L`S;~ z!vs>tMzfUY&#esO2-4mGXgV1~t{|5e5Mq~T0i4%50sly#84lwsVdxUQg=R_}%Ykkt zgNgI)Mo5+tUG@Y{hXDTAp-@P8c8PwR7js4g-T>tX(wG`uqBL8>zY(CHBd(w8Q$P10 z{Op{AkD*DUl;2wYccskZ-Y&@2`;;oOSHy{9saAhzQ?5* z4TPafxyUq>1pL9sViYb(oG%|jvXt_^&RCHFPIM>~5}sYkU6$c-9s-+y(uy>u#)#mF z`uL$a-o$TXBXAb3tcU6uYP~kYa?!sFB;v3jUesHEUJ^q8qoE~L!yR1 z0@05?J`G;oDFJ+BKp(Vp)5*JEV-nu^K3Rh|Bww+cW_n_+0M*UMG$By$&X1E4j*->5eiUtuZGZ!jkQ zOm05_&t;M%_{@Vmc)TE;@CS z=POs1F-Ep>62MnXP;HERnqx@=q>7DZF~+!>%Ge2o zsX*J2Q3j&E4-sM;iIyWiXNLZDJ)k?$^PC&u59zL%dVM$Ccw`4p zN@|@?;Zfpgn))KLo#YZv+tgpH00~m(_Zddl)IYFAn3PR@4o~mYCmO&LqL|u&sU4W| z9O4<2dK&$9QciUT$gtE)n5ZO0sDAK_NiAT)lS@s2XI$#^Jn%%Suc2*x>e(~!#HzdS zWTf`a22Vlt0JK@DZ7}yrDz4b=E==uAPYLm?NKK=sqB~ z)N7a_B$bi09ZF5X_@7ix{fT(qHp2b$v4pQF^-$?k9MP_6P{h-`1xm=Eu^66QH*I&2 z=kiB%GbJIOpA(ej4l}~PhC$RiPm`(`6sC+?X^O%VR7i4*9IccwA4+osCAS`ld+7PC z=r`ID4}B^f&W=P4&!>l#k=#<(JwG0j+^I9dgN%ua7PB7iNh$;`w-KHbDw8`mLr{1a zolg~cmTj5|-G!%lh7C~^7fCv5p{>XgZl9ZjXL1VHyfSFhFPZFG=E^h_r1+fbk z%2?is^0CT&^s-d8!;_&7G=k7T;gumzN`=o2GLbXXH7{6w#jxs;#edY%7KT^pAClC?B(t>avTa`uij|H7la;bVc&-12 zm!ZC88V3ns1PM}@P8xlpEkjLUIu8kJDOpZBZ9*`nSIGl}u*V@-!l&CHiv5Cp@+cO^ zQXMQ+@GCL)c)Dn%&ZnsBSjHzWWvaq49O&dRc4LalHV@ER8fqy*PMQEM?hNP%p(h`O zQZT1aeu)aZKdSIeJf=zhlbIixRVqVOz>t&N-c4+kBNiwohOyAAZNUzT8r087tUZBl zPpkLwqU^%VQ`*rT(QTnLFT5p9KCYV_0BI>7usq(U>GBFQnM6zmd;S`yZ!% ziS|(# zjtsS()DIOO0P@O04GM}wKa-)dJp?DOqQF3M0vQ*b87h>7bBg6TJBt##Hyr;eY~r$f zJaXIL5T>a2Uk2eAv-xq>7^LVjR4$-SkExN<0%LyDc%V444#H5ZRaMA6>&oGVJxpK_7E1-v;^(pFgaf~Ks|A-qjj(>}-3 zB@H2r3`|5_l_Q0@3KTzgJs|uC+_<&C#NE%i%UBiWDSwD_@vz_`n1ZO5 zb$Jp8>$=vhv>SULp1h|Ner24Un&BCOv8rxWxZYy-LzJzw4hzaiZo%f0#Zv(P>o(@>v#F;D z-Klgp^K7MTQ@Wdb>Mn!3Io&NhA#vceq`Rf(Fl?}HYr0!`vb_sVC%RjEhPQybGu>@G zuTxJqy4!kcQBM!L+j)YhCynm*o;Rtd7u_8^F6!w|cSp|<>KQ1cRe8 z_d=)3?AU@KtC2&*{_u6YG+cn@iu4SDqFD-UiW$L;3q%C-Y$AL-^$DMK`>L=6HYy_P zij?jx&_{g4gjXtt%IZOl#%%R$T0bMDCp|$%cuP=H(q08=f(lD{>Nlj=g+X3RJWUg{ zCHm5Xyxs*RrQan>Vn`m;5RWNpiJ|PYY>8p?Kq4NLl;=Z1s#vQqoY!0p;YPBX<2FY| zm|k$n{*B(m$xu~M!6_c;;YShUKZ;Di{UsIiEvBg{Ib6IkBd<7=DXJDFXK`%a#ZXQ@ zQ2q57`VzUvGle!}=zM1EsuP-_K8HKyj*Dx!oO?2-OV8|O!jJ@xF<0@ZW=f=+gbW?NYjl@V>tx%u`9Nkf8gnPYE(}k7j4Sy2WBG>iUrkW(8}b zoUqK4AyP^6RK;=d3{zoyfwPN5!KPuqAZ0a+yCg#;L3FXQ*xIJ34P@+MHk)T*=oqG` zN z4uQCFqeJf}+(m%iPY_@^yc!7KZv(lE@L)t$N@8ys|)x~NDcMK6xIaY@MJGLim{o?#_z4;cOFpJL1iF}y zIk@|EW_pwZ?~aS2n`|EP*qwQd6#efw!IRbCp$LwX;0(2foKaE^H^^Z*pfbx~K3XHy zeV;*AC;IDNFt;&f5pM=U7kLr7gP{p_s1}%~LYDyg%~g}(QY7O-gaA8NQEvQgDrlKjMSQ%$$3Rf{BUbR$swzI-;A3EV64qi38}L6LxE())+|rTB zoTjMRAAuvYf^UekjC7G?s5Z%2wmD4JtVn?Q>w-WWQ}fkk=xV$A6p{>cCI&v#HQ{ID3% zB*h!yHyl`m-QV_8M)oQr&ttZq-7JoLB%Zl|*&j#n>~#_kW9Avt7NO?rpK+$@-pv_l zk=~rCKFp58=jP?nSZ_(4P~bH9=4Cn z=jUVN+MLk~^C$E947??0B)(G6j&N`RT8JAiEk$$ zUP<4m`J`WhM#Ef&iKH^Wo=*B^v`)8qp#ykE;%LLBPdZ5Y4D4ANW|ia2&OBtwWsXK- z+(zR2dF*7&{GP;?6G%+zM7^yrUvQZtvATAf>2O2uQPhS`#=^WuK&-ip$=KYQ^e3^p zc9}h~zv(tdWB3C-p?I)Gf2A$yrBg{i`Z4LZr;*-o9<@Jtn+e-HnDKS%!Gtv*jAt7m z*>_Ov^xK#t41j;zR}feA2-U6*9TNb~!sTU6`ranGP+dk}7K}Rm0A95Y=(enkA{5WQ zs|Oyes-u8Dv|*!VoBlv{4|@)Rj8|R5zaMQ_Ke%nZ1tpn%&y-3^=GpwZrclF>#%NsL zkC}?rTW5o{Hv)?UIcOHX|zXn5$Y`< zAKIwy%!F!+S(Ctw^i)k3kl&orS7=S;f7m&}2g2iG2@Kx@*57-qV|yPfr`H%R|pxu7O@{ zvHCg%z}dY3W~m|+3H@Ng0Q@0K*_S z8CiK!5V@9?Myy{RLTAkaTMo+RtTY+6gUsF z@+8)0a>E!-Z%0MufB}ga=x)-e^r|};_VsQ~er7rJyY-*g_VvTC%P4nGA_lk6A74js zh^HM}=IxOPALD6J74Dyyg$z%H2H^Zm_he5Abhx3v&^^Ud4)qfHE8SB)b;$XR?r9#? z9^rTCp6+>RHQe{;p5ftFze9hgd!}byLGb^edzL4472Nmfp6xkx2%HCW&+%Nz2ltND%%2~li_J5qbW8bf`G&1H9Lod@t_7ti_B5{*F1A)dQkFRlj?DxO%? zb#XKJa*8ieb^Q?gA)$WpwN+gkYycJ}zG14XiT*w`Tzm^v*M?sM%cXc6c(>~MOg>xUAbA)p?OqZl$Xl; z0k%$Yd3ktCf9y5(81Z-&Q4e@^U@11P4JP&`%QmmtyA*gQVEt^|H&#v;H4t$Nd;-v!0NjX;q_}zsqpZNU0R0qzC$t4z zLiH$MN$0?{G6I*BfDspL0xqdO-fKyh1XL~npDu&)E2S>9v)~4Rng-yv(UpfLs86m~ za34Se0&wZapuDuYJHv`Q1JH~Bd=L}j&@!qb+NPv@9iZ0(a5dCtXj#?yq$Pb6(1!td z{6~;3r$WbD+c^-+Xr1q4v;NgJA1mK0NjLPa-T`N(G04)!|>lNTC zs${q&y&KS*4jkJQbN0|g)$<)RhSLbXKuGL7b|)oG_4+wL-y`^*4f)1jLMCHZVRR3z zs)`N(o)ZIOZd|&-v*eA~bug~bYAR|3%&#;s)4^%(M(jh(XhWY+?XcygQh~K|a4r8P zN-wm!`n)OR`vZIa5j-Rh0d%V6&QCew7d+hu?v$RUsru!4f6egJ^u*aq9)|)sRo6Ze_)FoT$f*uR*-*E z&7KK-6RkEpGylLI5|@5<5$aD*ZsT@#1F3;3 ze8Or_F{g0!6PG43BA<@!#fcy`RHcVN+Y=x>NsHs|G4M;apz0l=|@&ka51mJhxgmhDt zA4^|>F9W&~fG@OxbTf6Vx+VPwAoa18Mfd7SO=Dpi)_w%Y^!`I z0(Lfw0Iw!Rs!AwP5pJZRo$8F`=x#voX3?N4D5@Wxq=vRv{pRBfJixDK;TVxJPwt@n zU+Gx>1nfU;=ajMNIb+l=u3b8+vKTE21264xxLsgG%A~iG`V)?lrT2^SfIL);76VcNw{s{mEJk)? z|J_erx~>=O&j22qg`!ilM4hb-UH#Qu3)XRUn++`1^I$jJbLdX= z$h`d}y4!k=z69a9%+D~-jRoM$qkDwM;6!jf-D5nz-9z{SZoOo99>BUo7t%e;Q+F#k zix~03Mia|o&#=$;9wew2CXdhJ@=if2d`ybbasuJu3xWXeLVnd$;PY*co=wNSzX_be z>i2clJZLlUz2wZM9wx<*ova)a_I_q zaQ-kaD18t-z<~yH`zlAg+TRDiTaAK)29Ic%1G{U zK4gme6%|(d2p?EqM#_9&@3j5_I@}M?F^1eB#D7%9gNsvCOU(RgA0p_#0FeI(G9W`e zJsXn2@>n2&sGP*iP%S7EBEfYS%zqSWh`XPXQ`8PL)Y?BVs&t1jMKvFT(4QDOB2#G6 zNT@r`N%t!Z4eWVIw45u}v+zg>A$$EE%0srBiT+coK^ty!v&x!#r1?fV;+JxMMxr4}(*4AKdYt*~tj6 zbrkLbp5fOJUYl*Li03wX;ncd+S2B+(fdr;@qPw@}D_CmkQ%v$OJfP#j8*X&!2XrnLDtB&i;}#~Y zfm?k3bzs2FF3``(2Vi!LxN(OD2*1sT8|Oi|S%IX$_prX)b~TV&l?8I^p>G8miI3lB zhcbT800MPi7N2#quyUH|ZH$E*bZVa!NFT(D>f0@hA<(j2Gp#@?WfzkKD_v7=_rZiR zVi31{#WdyDCPG=&RBpYS$&IfHgUP3i6hIS2M84*7+of+`=o{a~1x6-rWI~|*3h}Lb zMSRwcOkj7k-02pQq+_@t@H}o1w|v(?L14L75;&!$Fs;CIodx487Xo!#%Z-7^pB2cP z)FgE9Yl*nALP5W-ecNOv%c*XU~XcEsu7vVkT;kCoOZ1xl7tSo=8e5t%G zF+i**ybEIC6Q|L~x8N-g)igTcQ?!UxtFT*kmYz#U`C@g2b)XLjb}4o+KBX+YjPne=1uepUNb5?dIZyp z{etY~@q_49&8BE2D3*gytic5f+SBGD~6^5^2_| zfp@gb4+r7NjyZ2Oer?DM8;AyPZbyU6ZN7v};5f767)`0g-kzUFKiyfiO3@6$D=UPm@%92^J?aU(pWf|8;hWW zFgq2+E2?J4kvKwS*1Uwtq?v-vpi<^6Owba{Y(14x+AIe>Wz4$^lu_2)fd^XU%wx;& z8E&&nGPc^y6s$HXn%jmcqmtR{b4md1pVKz?gM^ zz;h`x0>i-*=I2xKa+cYvEY1~}k6{g(WL}?vw|2~3u!36V(Z{isVNOGMZL>%r9K|$? zqXg=jl`x#wGaG(^m7TdL6y26t1v^*u&9U3@2;WS78jqDtFS@Np=I`ux&F4C!^D>`8 z*VM%9QUWGozKhg0Gk>^?$(eaGNEt26pOi9MnokZ_Mk~`(Ng1upF{qt3=D4=#3e8vc zE2EwHO?OO8%qr11>uBa`tBj83-Fo<~2J@G07$eOi$V(UV1`G;w%#`1;_ieUAO6HpJ zNclXo6$ZBX=1}NdV4mrOheqc6KViTzuSViAlDXs-J_%#SqK=lBufvj;ny;apmzg)- zz!b~8<;4`!y!<0ZY4gTzWvn#ct%>(F%y$}LscM!Ritn|Utx?Ns&GkF*0aJ4?Y-zpu z`dUoh%;rep2J=*iGF~&sAzvHKVzJoLGl$&4xgN9NYCPsJ7bM{O2IkY~Dz}<_u&cAp z+=$L-yZP~S{34Lq25sjJvj;42r#ZBhGIp7bVRgIB&}rBcG3zhFH_yz^;ogUnr}#Ra zdBeo7^O?EV<5%*`XJH8k%@fGiA+yn!cxl{BIghWFn)L@``Dk8&UA=Agy`YSD%-m;{ zan#%xuZ&}6lYH1VG)qjzyJKc^w5eO>%Z!dtKg_^ez1UJ`g0Hw5zM8gS#UBZEmFZdTdw*FWL2 z1n2{^>HrRm9K-mgyB-+Z$iT?=%0b|(^0@5+54Sb?#@`l&D*AAv4;WvYhL7){!)M+2 z#cl+?pauAQkMQvqAwl7%z2PGT%x6>6r?)&6lSj`_{jY7PQEf$6w`BO_qgSA?9>C)f85B~9N zmTPuzV~xsP0G|f7$kiP3haj(2{x}>iajEj?RX|>=A~XBDYGuIrd0^MI^a&T$ZuAX7{8Xts%!ce6q#TfDuyu)RI*J4YjBZ z3AZ%V(i&Q>SH+RY;M&yUn%x&=#Fz2Eur$?nG<_D(l&Uq^X-T!y@*0L2%&x|+ny5eF zu-Pi;2uDfY>#Sj2g1tAQdIo~d;&9FGYP_zR`C%rLF110|X^A30{?wA@BC5H)SIJAr z6k4ekqW(YnOH9*2X9V30&)6NsBy03`cf7rgO=^5zY~5O-=nJiwUWe%WxHhZCEwoF@ z{Y!LzA;V4rV7&e-=x+U+VES8>nSijX0J439K}DqK+J^Xs8QzAULy+$0;pXu`EL{<@ zU7dl%Rai_NUtNhgP-|r%-4NFfMXiW^hq|TX-J$M@qpk6V8jNWBTe3xU;?cOChTQYG zbn5AXyy3rvDBnF9_o18JWl!lXllrG?bD6t(7eCX%M82V1D6#bxJK2dT_FJ?R zT#vHzfc>q-p6;;gf%)ts?6$0@K8APgiNcJk>27%Y8{YMeSSW~jrQ(m74$YwpvZ15v zb?C9G_#?W(r585((KhjRHT?Mwp|JRGi{e)VT}J_&!llcYF2i3G@Gi9r?)yH>b*y*- z=J-31pqng9N;5@UR0}HOOaGN|1(aD8_F1M1`%Efqm!gJx7x9HTOMfXu%|ErIJ&+-| zb|@-@{v9f>I8ax`#nBO_`x0V|4Ao`ORU|1pANXoqy7cLC%}z1=r4C`TsJ1|4kR^f{ zn*6CH?}2pA5n&N9OPkbju;*B846+vcH!$;KGN&UT+dX^t=v8u}!##V)==EwUrkmcM zc)-^+yC(Gf09Ur0I-!ABlc1w<7Ck!FGUc#aWU-4ovGxOV>Z5E9Uoevpr46Gi;u;L; zR7?5=NBT8LUUH;aC`_{@9xdYT*;_{M(MgY0cG|b7>gAD(Zz1ZxWmhX*dl54_l1hs8 zN)K$Tl6<_u@Ygy->tS@cBGBfn#FTOplL+~ixOOP&mD>GT9H?D|aM$dPu%~W}xCgv1 z;L`S#DdI%MV8fpxaZ%e*jN89jaiP5BPc2yuWEZX-imD{8e&S$REkhKK`E|YYbVSYp zzlKZKFI{3lO%Bn3_CsWfB@(Dg-}l%Pz@f8*$BH=OoeDW!K zQ@a#(T>TmLTvtz}n!9xrYDslao8sD`NVEN=4)N(5!Zur7MEq6QXp-u?Cn%UQ0jYBJ{fh$ z$0?)4ctG(CR*rYnWlQT(N9#k#J#pLCN*AV~YgJ`z)Pc{dY4=5hs%5hfxA7|eIUPbY}y|eeGa>IoXS|B8pARt{j2%(68D7`5{ z=)FkqO{&x=Dq=ud0wTox;8H@7B7%wq1O*fo1rY@mEQpHoz2}_S*_#CP|9tm(=I+j% z_nbM?&y?L=_n7G3&cxCea!2Keg$k1nbNN13ziNg-hT(aD-^|IdL5&|ck?^8ca=JQz z^#bGX3W0P4%=ew@(MB|Q!z&V1>SYLPi86I_&y#X?QkJ5fLEqnsNS>4{2&hE)_m84A zR!_=_DF;=bftK$MzlFw=auI;PFo60(d4~-ZVY1F~pG`ULNx3wMY$;lM->+!<-&fHt z-cgiE33rqkjo9LT$*#=qap|hp8D=07M2|bD@Sz=FW!u$->v9#F7KfqSL|qP5Z7K&( z%G=|z6mRl1vT4ECld^2Q)~>PE?mZw_|7MQ<6S7o&WQ}jEX1P9I+CvTK5aC%WT{ z^r)(lD)ka{_&J*%Wclt_bautJ+WtBhLqYU*rQuw~g@F!}_}1CcJ#xm-9N><3VW6We zzI3}uE{5>{&$$Z&oo4ZEwnyb+*aYy-TnvX4oiy}i*y}VyL6hin0Dqf{4^u1x< z%Ehn>;MeZLKxY_zhwZ#Qr5p;HG<*Q?`CJV96`c+A9kt77hPH;`4!}`2vnRSO5>3Y- zeec?1a>Y;;;D$LED3|D9r0)a!nOqFL03LA{20AL~`^a9Ci{V*-*W87H4o~_%v3KTT zcoX20cVSpU44>NXD>Sy&A~uvpc9q8AMN?MV)zc= z-*Yff8t9Cr?`L~=E{51!*u#MfZV$;QX*xgYyJ=t13?)omdIaD>hJkD<*evNP^bPc7 zH*IIOen`>TVc(y2Xs?{LcM+IZ8UZpIQ{5{1AsFu1#WjN)<9>iYGYlriFXl0xj%P~0 zMTfwAUQazOV1QBiA28qlhm%GT&~}6BHEICiiGuMSR>ny3%D9{4m@0H^%opidr-goH zgmwVioE$=t4{Vx5dc-v8E91)^rKo0!rBtV9kwU3e5dGIe%_<%$YEQ}+2p9^( z+*efxd^t%HeF92Ec#>!z9KXXnTxO{~3!zXgE&UdF*J5AES6jzF0}9>Tihz0=F(30n zwi*3&FibLz1WU$sv;1$sgStjlr?uzZ0g`cU)wu<7p}(ArGgXHxYim}RmX;2wZX}?M z=ZY3kQ8FF|X}VP0qs3819NIH3Ct_*A)tMbfGiTw$x}U-fW2TocMk!b zf&`o+0bM<9a|xg?WyjvWdmeNR5-^bjJmDFhOTdF*e&QYio(K}~2MOrmS(Hn_G%%;$ zLqLxp0Yy(hKrhecTmtB2Ge4XX?QyRAJzW z!mETbJLyJJ26%4flF}TwzPY6oJ%JiKz(W)x<&c_4QU-g<49Zy}76G?8w-m0EgM$+D z5(yaQX`%(ViFqH)S91%%T0Y^4V$|5LvPjBE&&XU-3jBj}Zg4rWgr$u15G6O}< zQl-DkgayrWhcR9vc~UmPg6@Mu(7thA>b+<>uI18!V&Bu=DMLhVzEDSQ*d465!?|h3 z^m$6Uy0euTh=fiM0d;A}f7<&k2V9wwrQXNE0N)(%H4a!Y6;mi=fp4yt&S|0RotCAF zTtvV;FB$Wmlr>Wis=gRb7I}YRj%DCz`w0Lk-Y?D*VA0e!RaK~U0OTz7JGO6qFM4G{ zb8zZml?+mr>VhR`-*&HbwDYC{jkmfq#qq6I9VzSobrq<)V z$?0m~e3n2XHS!(-2WcjM(<=eHF^I&kM!+9lXHuD^4y^#oUpj}c1Mvx_1irsHz?*V* zawswq*1$hrn*C$k1A^YY<-4P!y)c<`+6s}}xHS2&S_Zwd)a{obCoDwIMW;|k(NgjOYinmu;3m|z*KvXX45I!T)HbeMWkTG_6`cS?qK@SP5CdTm_{!>l z8K_-B=BtnYbGvz$dh zer)plS~#(wl5c(zh?bh=;1nd5PUrjjhxC{tiG4HDDb3MHC_S_h+}6%cO;_|h0vLz{ z3j~UC;SJMz%|Ij@3nJF}I$%BpVByU7T8OlRpQavB&rO%u924&v;zIdMuzU+N+x4l| zo9ZBRDT;V>1KZ%_4n%Ser;6T_pBu`ovr zkiq8k#So(Ka@sBGR4?i{u$=Za-lO3AhD*^-8R7KR^yq`{M#!Z3lAEPWZ?GM5Hel!3 zO$Qc#u(G+R3^Nc(I$oChi>@7COgpTuLsM?8H+A7%Kp+|r>OuLsV7{g6!7>aWoAAuO z?{BA&Q89*`D1@nsr2drg6hGZaQ!W z)nH5>LUo@q4YjPrGa{{rMlr&t5!a_ts2;@VVGdtxXzD^?C|XQ7RO)*W{3%>;HKS!g zdQQ%FEo^7HF!)UW{x`r+qBC=Il9xAYWFe(D!st{rYRCa~Su?`VKhDBm!(=(M>j71N zqX_P5=t$fjnx2fnor)g1j(W=;j>w*dleKWUGi%{~dis8sB8B`1l~pL8Y-+@7sVa2~ zC_CW-isVQWI!9^qh9A}{)Qu9fN<9b2rx?oIw0Tlij7^uNHE%ePFqn-!D77;*T*~zX z0!9o$zs)bf@uXyo%~B7#S*S zkHtJH3A8Nr_ckckJKUMaq1Mo2j{6loPUD*$emfv#HNxa7J(g7!F1XfUy2=*S>~QG_ zu-KfqocVRf0D<)Ejqkbep*uw2Y9p`%gssgX5R2*|H5e}fu&DkCwfg6D1TAy~jz1|& z-9H`p=fi1OrA7Ar>KqxYo5Le_N`&v22#+AL0uk9$fC$-O-5gF7?sf)~8N8Xx(N1Z7 zK*ei8*(|2dxb&!QS$=vxaKEC5qkP|npVsI{OtkeOcuq}ie_f&Z!sHdVXU(C;O07iI{bON%}eOUGK71a8W zg8Qib7SaLK*H;_^M64Eb0f^c=5Kt_F4wX})v(yhiAfSq7q1^AVPjuX7a(@^tpp@t5 zmMAl`RQea-xnBpIM-MKm6r`S{yN>0jMD16FKL+xFh)erLW+N?ArLG3~J-FbuiJJWZ zO`0BH$#zP|EVUFze0?=pf9VzJ8CPGuh%#^Jj5Gp&g0O}d0D=W#fs4zuUIbB4rs;|& zuJt0C!cTkbS?Zm+h@pXwv1^ukWH|f}YJc~jxy62UADMBFMqJTxJEI=X|3KOT6StXa z_a$@m(Fmdh%`53aJ733$&Icp~>r4v%2iz}4ip&6aqbhKB(lLU%7j(+V{+oY6LgxrE zl}{jmbFGUmkN2h_-|103U;l_(I+8HcJ_<$QtTUXOO_UAk>L}Hm{!Sza;KuC)Y?_Y! zGR*A;G5~$fK{YJMi)?!zCysrCB4jPJ4K$!90ex#CtizJbwPs;&1!B*{IqF~y-kzYl z&AZ;0dqSeAS*&97Z(t)aVY}!XvCEXu!ZU!mF(!GOFc`y0n@;DJc6E%LMJo9 zna#Qz%A~Eds$Q0V4?KI-jicb{8fjgGFWet&bm+bQu8|bHPpz2CK)iDVa_Pw;exzuZ zItj++7S4Ge6LmV8N>~ff_HZ}`2MpRAj=}LwazOpbH)MCw3xRxnB5!K;Ev7pg3)a8j zq;Sa$!o(PLxaJyWAQDyz5D>YT1FU=$umW|MP3L}*UC~8QE!Wmd|441U0MVYBz7ueL z+5t7<9nroDQb#`?C!XT>i;&%n)Y5B+v~5W*(eW*fTz6b}YU(M8N-YN!>KDka@)evf zVB3CaB$2R=?5MmnGKmAuPJ2_GK;4)F?ksh680yW3{M05LPRLSUe1?D%TKUZBs7QDz zmbHz+b!mY*G>^=xZv*@p8P;KWB&7_l3h*4&vzu(3kDwqxIcq$qk8&UY49R|2W2AQkznw3fS+UVuog&Q z7Y(LS=zh|xYcM#$i{fH%T33L3Yw&V_>sLfTpI~rXfPY|c5*8bL$|qSzwgcz0?F-7f z834ydQ*JOgL4#8raLHhBCcqCfcIhXcTFl`NJp{R~o>b~G9$`B$ovd0 zxXG`;QW_ZzwW5e3X9Ktks1j+4@2}FHYK|j5Yj2roWMQ=It^^dB2Tl8zoTGENb@EFXv;6y*V<7HEN(b;}QFB|g> ziJGRl1{kh}zzs26)RBQpcM3zIh+_87hD3?wpX78k^nNnm$f(O&=(9%Xb71@E9zsV( z5k(8FM*LbTErwKg{4`iQ(a`(Nd}E^~{4FWg9U4;nCj{Mx1tqsc(2r}~$3_vwtg(#M zv6%H~dJ&p$QdGJY>aMZ00o&qx2%Qu~6fG3GPjaMc-5tMKXQB6~`KCwN|A^{`Ob+dU zoXgo_p@mhg`}8OxVf=u3!sEyEsH+^XLg$I@>gnxkzPV9HwDb%ky#Urs+rb5AjI)X} zH;O1co#LTru1su8i zy9LRZ`Jvh$QuNYA-@2$+>mkmYGA4&=LQaPqQZZ$29pxds%vfpjklxGado`+|7EsR! z7zgGJIRwD2-#wA>YY;oK7|Z-W!T(y6EVR(>{;wo(XVe5O5Vi^bRO&GZn_46|ono-E z#GRaduoqAxTHa;}G8fx~05;fm>i%Q{I-H^X&?W8Gk)m9ekm;YL{av$EU(6kSd!i^d zl+XdSMJsbur;hE5y&B*4fcjk1ml^t4>eKd{WbsY}y|j40qPI`_K8l*4B*!P3?sFqz z+m6j8sgqQWQo+NJRbUWfa)pz=k65;JsGPo!bo%J972BT<3)u?I*F(l>Jt_nckOww} z@8c+nk88_U#Q^vuY7hHSEZ5LE`_4oiVn1>ubR_6!qoml9;ip-`xhQ%mD3!tiRn#Nt zc|&JGmO4Xgc;R_vB-#f^MGcv3AUBpmijN_flVzy`;P&O!eriqFzoA!P;zBR;#D!j( zc}R7jJS>s-XD!g}SFb|fsd#e8%|oOvU2ztc$ZPshF8>mFrH0VlZxVA?`YB!DtlxQ>o3s`50V4ksK2I zmYUWaNuS9dzpNA{$=mDpR)FbakOILGMjQa;V~{ibatv|}4r|hjTz#|s^u`D5F5);R zy};Es$A7yoPk(^mgOUsUvbTD09G(#?H4fkN)+)|1DprfbgY8`k;tMudA1MC!E2vcQ zxS5W*D7_v&T{YW*2mVh-6OLCvD&>Ly<7inL%s;`qEtSSN@f^&ssJG)Oj>)Yc|b1hLueKIfyfifB{ph$#Bj70X^v*29}Clcw- z@^?B<>JdB%C+IVBskal9gKz;w+#;+6dJ_9XcrU@Z!m_DHJPAATJV!2x;ql6fh6^YX zK@!u{ZWPTo8d<><&0wJZyDGITKsdT z7-^ptT;2%&2ee`(bLg^J6{rQPF_j3gaAYEpq3G3Am$d{;zWJw8lK`5PLjo*0KIT%I zpMAgzt*E*jun14GKJ1sJeuhostH5v6C4*U1Cy=O)jZhMd2bVwPF6L*{#^^$l?`{|K zF(BN>Ok%cMP`6t;um+GO^^aDGLR%6{5gQ^-^av)kz3@7S3&|`gyEA zHU(S$KHLcm!F@Vbtuu8@Jx$i{1?2=>K#?fgB?+k6e7B5h{{u;gb zLq)-|IkroY7=Ish@I@qlVc_vkr6!cdyGP&xibP2h`;PC>#L`qPW59# ztNu?>#}ptO&-!>YE2z6n%(|)Gp&`gvdkJwgj?LK+z5s8|v9>h@a>lH~O@_LThR{}X zx(y*Z5ig>F`6h=BT`32EenF#QS88-fS!|%f1#8?D8diXYUu(3h;p0HEhV&8+qak^? z+Gq{QPg72ac?@D278e!gm`IP1nEy1%UXLc6TOTu{-+`anp{|45xI(&hkef}0`lC7C zX`x0C|=9|7&@j574bOUz!N8_ za(C0)0yW(5kTrv1lfsYa>=}n04WtEmG9S^L)ZA`EISS7I&XeoWgmW9pjp*a-*9}GI zz(sT%MM{W%eNCFK1Nje}q)9rC7SQJ~^qHd3vkkggxgdSCkzAz!g~G_x-B#5CE!mI7 zn4oTppOuW4*b|Jr;Xp2e3yvL&KJ;LCbgXF_Xz9JM#<)&>52X^c5O>IX8v?kcQ*?TS zX-$FL(n)-VDgjfvvgUMK`fbpPl-DhtJZ(ut_Szsr9-*YA6Cy*=1Js#XUT>3}2Z4G7 zF1R|i0DAZn7^)K_@t+#>5Fi&CG*t~*wd047U*hwoLgv?{6?3C0JSzObjK`dU_mM(2T~#Wu&C8dbGn7N7+5Yu+HZ3T zkpfvjJKUtH%HSNJIaioCKXEwY-oZ<^$ap!5khUbpI;Q*+?DdKu)XZczFH_yAhi3OZ z0`I_yDIj<59CzVaGPOSgy;3L!|5B1UuGL@ee!P_o4$phDaC&pXa##!%G}6tJ_CO`W zNjB0QCn@G4)uTl8zYR3YAd{py0BtucGGcJ2F~N#HsEC5pVEJJ;s?}jdpVFdr6aOEiR3|WJ`5L7B!>iNsws~mip~h^WyI2*hZrHJR*N0fC-OLX@%&VzCpE}%#RN!+0lpWv;{+)A2eS8mkK}m!TT3prL`#@g}cV#Klu{ zA2MRETGs(q_j+Z|MDPo6k~+CFsq_0W)L;e(`ia4oHAAc7mH<5h{0>||ksQgicG#!3 z&%%2VPQ=ok<*&}d2)+|zLuxKzzRFM-E})28gk_MhLQ zdVn$zE}%$+l)#%M@e&`6bX(1Q&|iR)5}-Rm`&*;cq^Yl4S=J5BQr8H-15o*%okm)e z``i(Hh!B~@(3sN8Dw5wO5G0X*B>AOul8-6euUB4dic^_b{_oIzu$h^mT4U^}P)4fA zx5zj8snj}vE`;NV$dhxrM7F`(s=x~MIEd>NVcGu4QsrL9TO?Mh$&ky-`YC(hPgOOb zHzLncH=crjmG|G*hB0Y#D#Q9xzzO)_FELowo;8CEGcNeD%ht)7#V zl^^3cYpygj2UAP~@)ogwc@!RvSGdC3N)ig^%< zJY_{R@D669lw{RAO-rp5b z-Mg71z`+xau!fgjx57_?WT-l5d)IV~{Y;F{Beo4DMq_wqsBwU|FE0wZ!{-q|PvwTE zsevz|r`2$`1>6DDX#sT4Eg*zjKog7(;T1%_J35qk0AoL#v;ex}7SIhWnaT^nc5{S1 z0Vl;QcWw(P2jDJM8}vyF(Zg!_ZVQ+V$`ZJMA~{lfKA~ZB6}$)GL@W(U^d=(M%5&*O zWpv*Q_k^(g$s7rZN&ErtYSEGOFnRhNC?Pc{5|YXlX(QjX4XEvWLp9)JW4uCB^J0MF zpGr*x-ve-x0nVf$L;0Iv`COw>+cmlakiBxD)6^&E$?DuMnOn`EKLWD2rx7~WR4mBn z8das56)UWW%u^n!WyX(l#8krr_0MngS=PY=^MDD61L@gs+SMl*`p80NhGFjE~` ziL$5%Y3<>pa?*5xy0$@9!Amv;V-p>{^L9m%TBp#gDvLUCMxDu^EP)Fs5`~P$2*5YV z7`$2|1&Nwvkzx4(bWQ=SE)>s|0$GEA#=HiR9%j}ga-;w?w*}gd7B70y7>^GOS@*+9 zJ=ZHYnD+jRZZS1P#_MF7+0bh{)6{6p&wkfJ8WvC zwp<-$O@`w-OP-u_Wm9Kcfw*1~_W!faiW)W1z&loxME5hfxdvk2fRiGT875DShFb+o zdZtrFOi4n+n~mOTkLIptxW54BHN#DJ+%uFpPi@tU&hb~x^0zHKDm8yyh1UT)5z6R! z1!LJ?=->)OcxWu6(b0Gr01FiI(1

XEBw}+Ey}$sC9A=XKGw5vm(h30Y;nFK_ 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

t#J84y$Ry`IHGQ6C%CgZp&Yx@HstjyC)!NN zjUU4hNZF~_imLH$OxG!g6bq;tH(m>*nJPsj^E)(fN=sFebG`~%aGDGplxL;1(NT8h zQ)qSUDJ}$WlcCu7Jf))!`7<}77o>F4q1em@=nW~obSSCG=)Cb(N^c#?%xskeW8TYMulJmC`F zQ4}d@iyV)AISOy8EYkTNT9F%3<4Rgn^AG=Uk<~B#!Ri=K;*kPq9&aOP_uT+TvVfP;sj9Qb}d02 z-A`+}EuR8@s|H3J;#*O?GncMXs}s;Tax!a9*Gtcb89|BClUgh5BJx*y63)!7uoMyf z=fS3koclHOM3#UO(-;eMV+@AX5V?>Gh`%tIk&EYkh$}$g9bkg$veOu(ScN~y0A+b+ z6z6lmUpo}5@P;k`)-@ZC#~=~;M+m3`J16q-M^-D#ha42fp_P77j*TEy{6b1VS8-LK zb;^k$K7bt+4MuDOBH z;|nm}9rv-;@hs5&1sUxoU}25?u<9_)__!cy1=(~Fn{(OYkG@b7R7U6z9Y-Ex8_VaP zBfn(tj$^w>;fn z32=%_slEnBA{XRaEGU9JwF;*U(zexA8R z)>J9TL>-#sk+l>r6&0n5$U18K9ne$@Cj>a6YJ+5ubhW7+=5oX~bda#7*3ucOc6Xe7 z0MBwc4XC1s^n^x=yFf9&_W+(mN~WOF6*5(`jkt4xtSkYtDuhaNH&>61S5_;~cLI5y zsAR5)pzTy8pua)(Lm)>T)U>8FcvrP^lUDEx;6EIS=?>Yd4^S#7gc>Z4L)3?NhXLvw zF3T_nX@DELl(6nFOznuqL6O#nQd6xKm_cbKHEVC80BRs(*l zAVqhFY3i{px~_H?gsmXk(uYVO zODU@YRMo)|)t$NZ!WSUjIZgZPbEt2H*t;B#bDGuxXN+X3K|n?j?E?+YY1$7vkXuBm znfROMqUJR1#HR+`1Z10w@-$7B$l!ZW9I+`HR)TNEIpBJ2TE`}l>CCtOAM`f)n!9fU zM~}Re#vW)zL@uY;#L9JVwP2NU7OYZSusA1{;)2C_((+!$fR2sN9aIk&j+m;Y?wa~H zW}RW8*uJeZEa3Q245-_Htxv@OO@s zdj#d6i{JFD$FhbK^`@gqaTxU9mw@iP`URe6BU&CvatP(1i+^b*3OyORR3?y?L?zc1 z1U=9IC@WXx02$_>dPG&=kc|Jh2Cim`f(HQ4aVVBXzy7EqUI3$lM}h2cP@{l@DgNjC zrkXSk06s(t%NFPYDXRh}@%Z2Q&XJ^X67X-X7ER&w8-G0sHliftuZJLxFfECk=i~jj zey^Ywr_<&Xg*m~po&bKX zpc<#sJ~YA9WdwRgERL|;ggRc387`aFZY{KxP3!WiINiS#r}uB-^eOZwvA(I|ce1Vvau647`}5mHLX)N;|LMJ{ux0XeS1jU~7GrjS8`E<5ky~@A-h3 z?u;=%Yz9fcr5JPa;v4kSzKJsQbSA-IHFd=2(wBE;#UoS!Rhzyh;HdX zfs|z6K?`9`DyovI;le?GM2vAsf1r{zGeIZk)1pcMmZ#XAx`df2e(3Uhax%B zFCE3au6p29UN}2|zvyzLRPrKF%u)3>zP}-ykAQ#aa+n`0f%oQOepZ3Ekl$Z`U3YP5 z4OX-v6}5ZxMt?LL>4b(nAu zKz#`BW3Q37iDJ_2O1P*a(h~qpb)_|Yr+vAIt)*82TH{K~>q0TD>=*D6wx6l|c|b3_ z(i-k$zZ~bWjuZX_(6Nv-Ul)qWvhybz=?j4V3`q+-z&_By*3z+e!2ZXfbDqeziDE|D zZ*DbNO9PZ1g84R4%mh370|R#e)GY+_ZK9ZI_Vf4_iDd0=K;uF%-zJKgW8c%%zzYE_ z55c_FAG6qgF2!T9rPPyvo(;jg=Ml5Q{v*-A9{@V+!t%OM%qDxsUNrkjME^#JgE&BC z`c0vj7wv5W(Bcty;#3Dm2oLCP!PkXiKDV>lLP<3cYC0rKUKfh_*8a1&NxluBj)bMj z<(;3HpX?u-*6m0SW`oEfiSZ-?=O5BnOI_5S{{Ij<86pQ{i@Mmwu zN%ZX8Xj^;8`2hImmBa&?=prSwOo((tOf4W{RiJD;~KfsSX1=8j==xhNmmOx3v&g zB-O8gF1gb3(o4)TPc+_qRsocvC=OkC-Tud!x5qq}A4eyt1}xphJIJ)bHwI!}^n8TZ z##LKjogCb%z;_*jBLXwckRJ+UvV#UVN$4&nZ&1Ws_O$=r5SM|psUT6((nO#4Z}df( zMD~L8K|!LPtC(_3N$>fKhWGd#5t&I25@Q4qXk*sD6VYW|j90 z`iUf+4!lJHj+970wjHy>Tjc`kBO8Q4E{W5#en~E7pLh5BsP8GjraQQmaAqv>Q8;4v z5BR{*DnxH}AnD3xJkCaTVoF8CG(vyg3&Pt4NLKkyFc^X-&VLX1OF*Yxm}|Vzv5XD# zhWersNY_D#Z|W45WeZO&^F1(2;Zt46QZiU|T&7GRiB~Z@1UuNd59={*w+G(E;aG|J z-yyS$BOckPX9#-)ps9r2p`%~rPUyA(#B~v$>_<9FL0IeP2yA5aSK#Z{!9_#Q>)N-U z2mGo_VWth`k&Xj(Bics+pDI8J2(M`CPDtwMh+Wu@;0o{n>@nTYvcP{|4!Shw<%q%& zUaJi78U;DLHExyv;VF+5>|L=Q+PO3EJ~%q=%EkT%@N_y*MLBB4n{enk8{e8zpMQ%2 zP6uOwLucS7dXTj%k9*Pblcz~(mRa5vy~K!|eV5pa`2)n+q@ChO97be2?F@xet44na zIYwl6^gqXlyavEAA`8DyzcwOEi(ea&^*?01HX<8|UmKBEk(^^hT6y%}Y(zepgLq>^ zF71HF!3N<}X#|d_N5hTC#`s`^nvUoN4ivC)=41t1AnX{C2dja!6%jAGqz3S5rej2w zm;%xVi2kl1DGKV0&M#5ZjuAP6I{yaM+rs225X*!eBl7g4z)JwD=;Fmgcvm&KEAR%u z+PFC7!}HWfHHZc&2ZT{BiAusr6I7WJAk73}g-Z&cQVq!%k$;v2X*&qdJEQ_e2-(+n(peZ5P7?J?l#FU2DFl}G`V9$K3c@9 zjmVvVo_AqmMAn!Nz3(FS6C$C^IY#7P7>E}z`qf$Bmv6;M^z3Tvwf-R|*apiz4#|Ki zq%k6Q4aSG((ttHAh&x7Pwn?T7;J&1UvSN(LNsCM>697*ysKqfNhhQ@l$?YS+A9d8Y zMq~#kqk90o>Zovy$P3u1R;0fG^i4?G7?BMECIgoNT?hBpf4hX@Vgh1?f~lqNL>*k=y1O;=dpTaXl_fqn@jb z5!tkbAtr-#M?qp}=5vh5cvQb+v$1V(i^0IK?t;W$}fZ37?C;ntdm^^ zPz@J8o8(k@f-xemwgIUb2)$eq%O9SaF(S)hcC+sWYqHCf)EpynObtE8?Pb6pb~vsP zSqy`Ze0vw5*9o)l>2&y5o#hyj;}#&D&q4T~qa$z<1KTko7cJH;Wd8-&14BwTJTvVW zkxNnxr6gd!V-cbRgy$HM=V9732Hw%-$O2!$h*)ESgg(^R6zfa>T zAr6-$0_k=ho{Ui6K*0}8`LNhs0@e3Keu;_hFGPDf7%1>X2yffnKInTS{$fem(FoSC0Qgn9t@!h)QH z=l3Ixo%XD0z&8PV%Ec*SC1x)}fnT({;kgDrS)twr{vkQ%1YUU(@XL1UO8q>5`Vr8X z5FCROpuj73n?|^;L1|A%oD<*>Y5m4VVof|xA9%x#M!(=a1XTriZI`1ZOcW^a zVk-UwNjT9_^ooM?xa@#mp(zdh8`E{cCsh#k_1MwNB!Ozrw>bzKDKhP zXW@Z-ymo_oFS~0XM<4T9M89uq5#;GG{e{Z=K?#gmoexe&NO#8(C7rRyrB#p^zZ*kU zQLh?>zk3~6cbJ~s04^|P^EPnoSn1Ge6)3XxqG;*aq9(LVyZcpPctp`|FkW#KS-qr5 zXQY3E>4hz7$9jeJ4H!Q=EZwr@mySbn50*fp>KY&$Mb()tfABLP=dO-{f?|j*iXbaNtU%2k#9Rp8PYwj|2P3#jBP^f7W?8_5X49CGa*? zfBS3iGu?a0!Nna688cn;G|MPs;TKk+szxVgP|Ig>{d)8Xdv%YKk?lrHqeHmL#98?Fq;dmqoMn;LHNc`Wv z6Td@7NnkfvT%~alE?n6E1@W!}GV(Pdj{}u^bQN->V zaJOG0fv%=%yGnx8YF-5!qwNs~ijeVaPC!MD!MFd3%Fy;aJ?C{sO-Be57VV&Vc?PfD zhzu&y36aK=SeALCk)hpiBdSv!uJtVvt{jDr&8-CZHbC7xxF+Egk$atU;SvOo05;LX zqbivv;za5PR9$#*76M=DaU=*)+dO5R1~(Ya8sM8fj)YTK!fB49wqtWnwD9wC>kk?wDf-^$Hv zI;vKso@23Xb!Jk=1}EWm?ArL{F`U^r;0!_o<}^Nm);{B)wv2Rp-CYpYL)zM_!uzls z)|TvdASz>@!;PO#uhJ>7{NNPr0!zff|6a~IxEwJabFp%haa6;-PSSGBATMDXea3Nv zoG0?5K_=32!XOXRa?&8DFb|ROlR>^oh2@mCw69(mw1I9qZU zP#Fc>I#?bQhm`NoMaxKW-{=pA@?FvY!J|XicM>6_4O@i}in>cq84tGtZ)Z8Ga0r!5 zMt`^bUPldp>rf9VR`oS>a*@qA$vR#PCHwGOC3G6;!g!|`=QzMei}Cut{00#5gRdtn zf%90g;6r{FwBED<>O6BG6e{|e_}Vkrpcfnpl)U}%`? zQSe(oH7&hMHsW7g<4G6V*EIvfEuIw~I8q2mXq?`#Shk&scv^ zqOL{s9QKr4WNS)~9bnejvKfi9Cl5zY!Cd-WI4{DJc#N?(Cl4Pv3Szz_G6d!o?{wLP?r3 zZDl)GO$7XaM`5jI(A-il`_y6}E8m4my_43bY-+H`PQt4zWeS4{-DPZ3DSAtdnZk=XljJpfik|m z*{3r68}RRk_g$4>m1G-*!oG#rhekYf~}u8srTRNr%y5M{xzbK0(s#P%#hQt zdG%B7Fby||gTsf(vGvm1~tF51gVw#WkM?Bcp zPfV9&hfI?ACpAOTQ+g!jpbk0qDI#F&km8uecD@36FP_8=48hbPlP3fD8Lod=Bs`n2 zsY3=m12_bE;>o;lf$*(D)8noAZOH$AAz4C_(B zuUf);TZ;Gq!*!*BkvG@E{0|)OvVh!pqp!WulqtQ&`&BOB1s-Kf`%Kux|mn(_@H#&3NH-qGp@`dd_2rjDox_qs-=4FozdJ5)0swxQ8hb z^?%12ifM$QrWjO&IUZpd1o~i^1vTphtOnYe^)mbirGQM$N(WoB(rjy1nr+Q`_%Xkl z4*P?65UZH+1IgAm;m%v3iE1~j2R%w`&HDaWzxoY`i*ggmQYC3ATEOg0Q2N4vOL`QYwYp{<(AuwR z0lCRTFEIw%@59{&`Bgh0ed16fUe~NGXZh6_z+AnS7{t}A&)@7|Dx5$?~-2-NVa z^cuLRpVjL?^nPviDrQr?wmKN?{_#ZNf2&>x=10Zd4@W=ngzItcx)n@b^}6>rSKue& z;BZ57Z1wv6E}vTO;S^?MnCf+Cz^5qmYa)#h1U7HLXsg$HH@b@U-#yq?uS{2wo6sJi z`*#T+TgZZ4x_?ZhbpI;Ar7dkH?sBB^dsY)gW`7QU#ob2LT-77ipH8G4wv_y4Aj*HA zgT7o!k1t@U(QZ3jY}K8;68Sv`&I|D*&S30K)qM)_c3y<*n-&RoCTyzi{tWYdb^pc z8o{xZ1;UR+(VUzTuF3&2#6zDHR98}qpb(RR%=FObh)N|jwTw?aV%_5_sk^p$l~hgS zU*r|gOeJ*?X||OVlV~cb-7{SE5=8$5<{1iogW;G;>RXf^;~W}@%ir)Mt`$&MQcvMT z=~nnC3!st*>UVw8gKd23MmXL~KtyU_ivJUz>I}y|76`vbnGs6Tlxd4w`_$cl@AoLN zl~m0npLz_)i*cxyq6N(U?3_=n1N^Z^(OIi2shSsjYA=u@9=e4w(0(7TfcRYi5`Fq%7@KEyODycDx@rm@w zz-M}#XeGrrE&9?#cA+r+QxyJOt9SaCp-r)qzPf^=_R~PD@Jq1kU^8 zN&8r;TIL>PlcwL~lsSwElMA3acbGVZe_+5Gzs*^82I7hUE9K!Qqj(3W+!w&>0Bh#q z^dB3i9!}NeNO*S;hI%9li6xD7-n{@xQ$d*Tk$y*}8j{)k)6);q^B}x#Nm>`p4)Xp5 zU3CVMovna(S&B}POd4Vb`Lg4N^E2>2JdUJFbM`n-7ciXsL$LIZM@lQq_;{Otjs_5w z>cAR$xReGn+S~l|4)#booj~aAkwl2y{4?Vsj$JbM?*=}_a=gty=gPXOAmPP;mJPcoPl0mA_Z~p|J>PcoPyQvYszl-E0bTNZ+s!|znLbs5aG{}? z-NK{8wwr$*YiNAe0#uiy&Z+k=AYuz4EzP4-BH+V{<-N{pJGWlrvaUd!e;Z&bw}_m48nPb zp_0U-(``5ZymuQ)v^<<^5@MReWP6)`avlcW99Wk)Jgn8iZ2sw36)(gv5Jp>)xA|u@ zUPuXkHlPKBrO55(pFJ0f3DoS%bMA_ST$&!%?<)jCz~RKTFWLe2~pZ4M3TMrIhUEpI;iGd|Sb} zi}h*B-)#OVhiN8f7_jjkenqMcv-xK`;_f^I>|u-B%|EjdZK*I`0|~Uc z^4LAHgZxA?61W+R&n=ynYv>W?u1qAd=O^2XWXzNCO??bA7e0o)>&uWY8MmeQRC=vE zc&jneJux~u(iQUy&2VelW`|dn{I}8VTi6X!5dJ&i2?uajPPh_G-sm<^9}No}?v8`Q zCCIU(+dj3h>(#@_HZsiUb|fZNDfBHOc@cz)1YxwJ+o?hH=wbiLgYD?H(_N-B%|t1G z(J*p6rAJ%1)~LJ-E_MVu>oUv{I2Xo~c#I*K5$OC6fK-HQhDE|jgv|(a9X5G5O)O+b zpbX95^(=g*^wog+fD$Nf`tE8hR;8Ql_U5`g^X|ocnJRjn^%S%_iOmZI5_+RIkpU) z>bP6Z!zs+jFlAT>*P&48cyg*SRguqNwPpBqW1Q%L{ZS8=K@bz7BK)7;Dhs>dg7`@4 zI9R4vhLQ)LbM6_7q8CzoF6jhcaO5(A_FU5mz9^Rb?YXEETp`?&h3PZ+lCu?RspuI` z;vhyxBduH`He9v+3?a;oFas0*lx2ahFOXcw+D3a)cL%!6Z)=do%HxGyP_ zi1wR?P<#K3T|m~CDZN^a^TOLRP9_wjR-YD#&r;{?mq_vq5F>9QGx~EDGI+wFS-CPD z75q?M*g}<;g1^P7`V@AOAe0^O@-^kpk_ZX-7H8QT>1q z_c%|JQ@9C*A9apmet8<8ITqGglE!tG;3;QCHJliNH1`GIZ&;2VN2hQ;F!-yp?{3`2 zw*}aCi>m=ob^~>gO=R;+GNOF9YK* zh4PnqT7y22{Zd>dT}CXM0~DMULNz_TqUEJ>1abnp|m{&d6X3cR1kkz{GkF?V~&a3%qt z;c*xtJ&X>XbziH3xI78$6%Ut^U?v+<&{y*rkUjumyGIfsGS&{}@l836lL#n3=NRx) zmZQho!H6#zTVaL}_D@7s;L*w?gXv(BZ_PU6y9}U;ghin=oa|cwEf?R70kt43swji$ zU{T+FNaXz#-UrYi&$ouJ_tkvJQR4|u1(X~0&4V_rs1!@exgAhW6lMz;Y~*uhpesvw0-$@NFh9N+Z0#!v zjTiVaKu<+senBzV-nYJs*?{^Epbb%2?#b%xYl#W@n<@NjK!*sk#N-v$N2-H8eNU}J zf03Mv!2Od<;x#9QgWcc&-|V8umsDV7<8h8;gCl)8S1{{K5e)!0CnXw;P{#O%Pd1_C z03H%AMZP2%oZ#D0AFt9BV6);yq-}19#NOvC4DFU+o&&zpa`a$0_<-*Q)OC`O&49KN z*80cMZty|htIJGY90v4b)VIKMe2428-wH7e;xQE|N4vpCeYr0pZbji-ije5NjC6xb ze5D@;R0qzDETr!&lns`_XMKa}B4;`S>*L|9G}J(@wg%tuIn24qz`{(N{L`P23$F8Z z9A#d)M}fcK`KK<2<;|BNZ1Aw}fw$4oqM-Lc+8s}f))Sijt1pa7L)fRm{5zhlYaNcl zgTMP4y$g{A??nxRM<-j3wgfNwdVgYM)Bx1L!eK^Dk8XpGe;8JlB%Dsb2gGqSQKpoF z3I6&u5Y9vpW_cuuwOrRD-zW_h^v_<2jD8w~=PgO4$c>H3{&KSbt%LLXQK)n$B;k7h zu$v+JYdG)optNH@p^R(zKSVc+(Q|(%G{vM)Vy6EQR4LsTgI&*m={58#N`O_-V=|5^ zMWGWLS?^9kciFuO*e&t69@EzK6+fkq4!C`R54IeY!Xw(jDSmD~aVNuhj)kOyVsuH4 z*KBonq=ED-2x~kNb1&O)*EuDoMMpGZHtVnV{23kH@N(AwHoAFY71oUri$Cy$ z|6;PY!{m)_PE`pAT=c$JIQ%|2c68GTyIbpfIE5J*W^~i(4Zot$PUJY19dw1Cgw>92 z&WsNz+Q)dX9icK^MczH`=lW~?&3?5O3|W6=B4tuw1zg(FX5ucl(_Tb%uZsNfn)s{! zvR|FK#@`|OE6b?pG>bp67nz5R5LmaZjApA4!uP_967>=kBd7dN-G)8GDLrywsWInk zxY$v1`IZ2h!ueJ_iOm_588si~e&`&y4zWnM2w^j7Zuc3s+)T8P845)hT3|=F0M~6h zJP=*Cy?r{~8i|Tox21z!x24&x+tO^;ZO``#s6!BVoT0Q~*k;|fcHMxw2uDB20)#t7 z(VPj`2AvF~w1@T(RIl5%E)-C;fi(2cene&6_StX!s$XgyS+`BXcJm<+{VbR(D0CFVG3&O!vhr657f(_lPYu$sPk~VL_kDpV9Fy<-+cFDFn~vZ@D$37P?Dxh+k_9>*8tqWqi|Nx zpt;>U2Gngpa^g@eMGKhS@w$K-4S2Fg(OIk4ZKvi7sQEyi@X%bwK>K|-$a3<*KHXSyKcJ<%4FAVKNhoIx1ID2-SxWdbKlae*KHZNUAO&5%-62lGRk({cEd2d zx@ox>`r=8P!$Pp@wiCa`Yg-%64J{O2Bx>>(^24s%w#19)bOT|CNBRY@X6l93QqGPQ zkTeB^Me(F3AkN5~3s0JUlhbJr=&yqMu19~C0c-p==hP>_zX0~Fhp&v{9h@631OEls z6%VKX*f{lY>hWA%(hN)o3vn?eoDYEOfeLpgs<-lL_IFc&6ZoB`q;cNxI%i}OUW=Zyhb7T$T zdji;>9xkQ9j5egg?yCHV?{zcbfJdiXgxGc4%Ln{w6Nt;yphccRaHx?u9>%@9=|YIq>M1+nc{mx&fWAih!y`VY6;~sic8h z0BRG3&ARPLyhswYL4fXz!e-spkCG8M7tljd*sR;WcXL3oq@3pgy&Q$v-@wgZPrvKe z@JE0?^I*GfJEAN~^dOvnBE*+COkv)-?L59v{{V~3ip9fPEzG*@`#m9~EC`h>$y>L* zbFB&fW@6w+za6SX{Wz@G>w_T7FQ0LIybxs2M)$?uFZ8Kg#IruS@iQv(R z*X6&Tfj{S4cqhvrSTzsdB-Mslw_SS+@Fu`oTHLPNUf5wOjJ`ldTQtl{LaUfvx7`gj zmYQWYNKeEQB`mvcdk85N;%bmSiYMy2%B$X?W^LOXL z`DqJ@Dx3GwtlPfzCP=G6crT7*Z~pq_N5H!P9r55(C2fY=b=!fc@!UT_xNfdZEYlVn znpwAf65TboG+0$Urc@zz-S))W=F)~{z*||4w{9CmN1A+h0HCpiy;mpx=C4ormd*m< z5i2A7IJ4i}{8gfa&V6?k;I$rwk+$o$ZBfzE?tTgQP#h&JJiBiDV!MF)9k?IeAYIVX z!2eJRvh2-YHBO<+2E0N%CvQ1$N{{;h`-HncG8E-_EAY;EWQazK9-?WnGCC`r)(0mT zyT6WOo6g-J+;7>m=z*DL%a|-BB@Fgs&W#Z6t^ngLOQ+=;;SuI-%22$a@N+5?e)fa* zqxD0}H9>gYR2gqeH#MU}-hj%uHvlnRAuwa&gaE#;@&oGC(8i|dN9a46KllbYq%RiV z%(()6NArgxPou|MqY6q6ZYrQk)7zVqJa6wry{+K~!?d@xcUW(9Q-O|EusbC5<|cY; z*Vl(}9Y3L=1CEuzQ)fm3&z?!ZbW`a&??b@FDhKyMguXH(J(vyADo{TkqqMsirV9)3 zcJk03E`~NKiG``qH=WzykPy5i01eY!%cN=0b7l1e4y4b25AiEjK3E4dExkgJE9)x# zz7R?lNZS}h#_53`7;PX;GZ^mcD2h;QLO2dL31P`gLg=Q_?=MY(m4nZC0@H&$3#$Sj z1tpXA{;NRl+%W?C!zcn}?{)g;7}inXZ!rQThUtOVn5xRbybs${r3ZQNNCnOmXHXk? zHN~~1&wC_wP#=D33xRIRKL|}eCJ8==w;Bg9{J?lZe^v15sz}rjIFH1W_$ucu%p^g% z7C`QY>pY9dZ5Q}_?NWYK@E#1*o#z0(YGK`r9{l-m04al=0&OqhUA<%b6DYY&d9kkY z6oOR|#yq__hblxI;dhQ+rg_537(8 zVE30quGAiJ)4yRw6NwG(7R82$Kj!A`eG%8t!dzflyB~k#Bb%{LJ`1Ci)tW0 zq|Xh)<;kS4e0w3lNlC;qM$&FyXeQ$AUj*&PlX#T5lPb_&-wtl+x*pDzEEHakSgAC* zru>kv7Ist8!MPduE##b{cex@V>8P*DepmfKxG$i=QJ7aGB%SbG_|~VsCVU^D8BzF) zHv#|b>wq0Wzd@X{4A2XNC2nZ~pYshIO_IvT(31FnOAEE7~49ICJoCAvqy>x0-Yc^RDTHU%|gO zqp;DWF&zTxdcxcAZ)X%Xnso3E+@cI|&QE~O5SF-EO_~IlU-)toAHxO?JOamSQYFk( zh=?k{Ygvw`NnKy`YZ0vgb+K@~Catexf*A??9&(t(a6!aJr5R1S0X4M*vk3Upo*d0F zn)EJaO(nW(fq!_F9HU9!er)9I2ma$#a*QVZf#JU7sX`g%!4ngonAWH|Iv3QWYG7DR zl8#M;kw`zd0Qp*brIQ1Ah^{VQb~?dg>OSdh$Yz{?|3~C;Xg9x&W}0ETn`XG#5JwFK zG7pb@fmv6HWW+SX?Y0%fL1t8eUpyXFTxtG2#ih+t+=Xb^y(&;6MsfE+fTy^*H{opw zEkPxKC$U(p;&#F&Kc_UDt5_(!2~qSE_v?*5MF*!D@K)rMiB;S_-@ED<;Q@e#Mq#74 z!@k2Y6~gxeniYkO;+|ORQa6kYZN#A-8Q7IbZ(APUv}zVMU}2&`WQ65qz;dz_P>hCZ9gi|ms?vx zyWa$8UI)6H*J0UB7#{*zibuX>u3rZ-VqS;zPhQo%7$1yU`l-$z-OSJvFH&r01620n-&u zc!_fz`f)XgDc{hH8=-JdINx1|`F}`wmodmf+;mSd`R-{jE_E7Vo;@3`y8wrqG3qUA z!DG9c0d*8kzgk~9-W7A&+^M7sFM%_pK}iUcOOcKWG;EIIDb}<%T*|k?cJX4((*YFV z+GDX6>FD_W_ViRNo>u4MI>3cWMmv_NsKR4gegkT?v3OX+Z$dmNc`#rb?6 zEKVv3;lG?}hfzxTK`M$TaSS36mJ&$&8_E*C?99UyFmu?+0A9~>)X4AP{RU1Sx3F$H zk8!b5Tgq?G-HYKW?stfI{_HW>))sc%_g(-p>i!bA!{<{3I|E)HruTao?0o!Fqo)H5 z=X3jf1DqM=yaK`+OVVN7CAY^FaQ{w0__#h!c)P**&hpeO|_?wcvmninGE5<#- zY9YM@=jX67_~T`$Be`!YrecX*UToi2t^X{(Px`x`bHW1bN|gEUP4#yk+#> ztNjA^jf2A>a_lntQ7n>9^Kc3?GR!jim$d?lLZ2k(18PF#2uOAreFl14w6FJI$pR)y z1s>SySNV%p-Tn-&WTDm;?J0GfPbMykR%c+XS$;)(9f0=)pS;mUYy1lLg6*G$dqx4w z1{Q+%vUn1=GJ!kzk90$6*yInt$^_ilqwHZU3$~+xrrR#~RVN_5Evgk&u45?Ly3s3s z^*z|*fljlGu-pSSmbb$d?b!NuR9Ijv0s6FMs4|CchVU+ZpymX9Yk+LFXqZmAI+bil zKg3ZrM!v_vuq^{e~HKGDr)!~cq-&CgprY`Fs*t_wBPa($PHZXar^D*wsBm7hx9BxdGRh@Kb z-$oB7+sH7gvm;+XQRp{Beq*LYD#2(~=Z3-oMf(L0E;6bcc0m+yD`J_WD$*vqAlQ7# zD_a6C`jyr3Wh(V6TV(sMvg_hjY}y!jjla(HC$DLYKd~3d(7P`F#DvJKSbtGsv{_W? zKjM73Q+u`Z9;l|9@{aR1EM`tZN{nMV70BF&u4-t%Z@KMI9N^eocPI|NIKfrh;O$pD z@)2a+p`cH%L*c0OnaCdoR~16M;L5@h8yq|SDzKOH*rENSqrq_iXM!t#(XZ+O>4ir= zpR9wU&)DE9BqPcQ?kUi`;17CKt^v;%kiCYDLG{7U@q}IWa z;RS~`ZCDRxW;^E|(7Z0@C|F{HlVNw@V>CMm?md7eIJ%qQ9&H>@Gl0B|N4}7)gCiq0 zxY3vzU~oTy<^^{Mme}B=Zyd;)C#kE77T5$wcN5&Pxi}pUZ)rf~v)(#5GGc?9&$Ga& zN7#%fKV8kodgK7+z?chz;U=2d>L6tB(4hV&d7E4U)jP;P{NtA|Z$DzmoRbW5rAq&k zoT>6i1YaK+>kL%->oy{lQ0rCRHF8L(w9w2BUWqVXq@&-WDW@V~^mMS9aqw zmZh)~grMZZ#ro^TP5iIp_}_qeopG#m1}efAO{~+-gT{X}^0P z)}=6NZltN$-&loBx!%;fry)O_M4$Ypk`H0jaNR9Q`(D*u%9;PgXI}c0DfA{zF<0en zRbi{EIA!yajg{o(OAnz+Yf`^>0F3+Z!X73twp)f|;LJH>4DSNQfKM=adVVfW+*k&0 zmkjftYBC8sW%9OKQYU~pz!D!BVXPOKOg3+YH>waPEy_S(Y4%ccH+>);kh9I0`&9@Rl@*VeyC8|$^ z!t#%E+V~1?5-wTo?BvDF6^8_M;7iDC8|2nc-DWp=4)f4?TfILjpm;xXS4*QM{2~6S zUMq7yTudt?cRVM*G#dFjJn66Z^y1n_z`cC^m;8#+omur5 zo8=tJEq2s#8x$?!1pHIU>#>xE*nD`|FR@8^DJEUg<`smCX}hGw((k~9f@AT%@*QXo z{J+LVzXSg?#9Ni--0-<0Yb;~wlS@VHQ|QH(s;L>SD!iywEuVUUXakf2-{)w#&?ePT zcsdV+jQh3pM^uWHc9(cK#c;MAOVcPV+hebhdc2N9Juj&(!0?+%hi35weSmHT+ z)N73`cqx5aRdSEc$fY~nd03HUnYDs1uk^hRw`5l%K&J4bH`q3*QIzlB&-?tU|0@{E zS?|1PH!Qd9R-L#Xw=6As1*`8*GfGT2Ydi@>US!&&x(^rU`f>6*@PH^?UtO!wK`WDL z6d$GCjFOa{zBpWrRp<0%POnt1%KwT9koBuuhNM~ycVJ+`1FAaw zt74LTPq_ePoI)$fTsdH6(BkD>G0Nb2rp~mhvaiXfOHkKW`yF+?^k}i7BPr+LIot$t zRC2LR7~9?Jw(g4cW6V3&0j1bGN3^BbdSj5u$>=|o{NT;-^@US;iX*;wC2ED7TW%3c zg`C^8A?iU-ZYEEx>M}(`lUz~v*BKUbh1u%81d<}&|EKjon)&i3G|AsIphDY6Va0eL zx^Z7ogo7m)(c)VcAw^9@^+(=!Ojmq)(G(Ti^fqRe{s+|$bKO-{?b3k-tB~Q<=*wzn zG;3AW8mUx|16Lf?-cq9FMw4n%?Ktvg-;9$u=z?_J4O%qM=@RBY^#6Z%RnlC40Lz=~ zkUmdwtR_S==C#92AY64vD|uxbs8h0YC{e4^NphKSq@aDJI zGxCLBGvSFkF+BEDbx$k#g~3q0Wapj&dXLTRhC?qt$H#D1%n-)?J7HjTZVo6fNWiCaU*u@Gn|Oi)f)& z?g&0PbB-LQz$+?@4Cfk z(hk!;c?XQdy2)is`u+tG;-Llyp!}z*_QLLyysw|cP_FnJ29=Rsl+vV`i--&@jNury zvOQ?ms+|n1^gpBjG~5W(GvJy)LGw+fd6vNb&YkqeBGNS2v12=a=)7pi`C8}JG4Tz1|=HA z|3bC$;FLOoXm(0ZWRJ8#c*>-b{pg@0h_2`;GZn928^r&thX)!W6*HWPcuna4%(edM z9Mxmmq7|`fGJ654lA#C6=qk9}Tc$|kR7*ya`k%CTP1<1oJnw+(F}XMCdwjYVo6f|gA{o`8SG|1ML-A?=j?T)-=TF9|Ili4t6Dc%P( zd;2fydbl4bq7|%bCCm8+T>U~M--s6iz7F9Mek%JC>x*xM_@e98Z$yMcx8x-#EqE=5 z`!84$yRBCimw1)tF}?y&$-A1vS2<@m3YpU%e=sG?E3aKp$@#O8lGV<#**YbeXdu1f za3oDkN;FN9Fz=sA{;d>Nvd32hXW^q|Dhr)Kr>OvEO%MQwB0cHN6jOugRb6yAxj`hByz8DB} z%BfZO#`;@A2c6VJLIvL&@K z_ZB*(pFW1T-S$;3=B-~r6yL;?I39@7NV~@_gS7>&J1r8vSKy`e*tuFyz{dccv9O+x zFY`%Fgnj$Qw=rJ@#7RIrlkg-y0MFs6a8jDmb6W;Bu8>k0a2=2GkWgO4MHQ+2);?{d zv;o|U6vi;z1C(%YiOi2d@a~*Y4Pr(EpXPBGxDZvDSc5Q=+Su`oMq%OMo`I) zBW2!6McM)le1g~1sgrpYgz~kraIUl7d}L$!il|BI)EDD>r4iliR1|Od?kK`K4e2U{ z#_^uIzWknYzwqbynlt=4yGwq4J1IZs63^1{d`0=W&;&o#`rk25l|SOt!?93!Y=}1@ z{1%i^{y`6mBSM)u1J}b}X3pJZ<>x8=vk^bR0RHJE)XYI8V3swR%)ymtq#|VAQHMtA zO6HI@G;+5_=AG+*hmp5wWDeg9V`LBlZnC@}Jk0*&QQT<)W&4D2S;%avI=w1@x%WNh zsKa#p6h7piy5~*wNirAgDxiV~9+ipJcQLYk6`raKR7TLvj!0kax$_9j*bjYoTSpjDwLi`X<;$hAa zqzZJ@Jw5=uy>LEaq3{XfdOy`!x7G8GnhVIejDPM1c>i5s*_LwNJqFEsf^bnlrJ}HG zOS$MyoQt!A47?tohJ+<>y)8xgD$T)Bcly2^P=5=@Zc7RH(xAX1VlwdQmSeW1 z4RXpZdgOZ63Q zZo*1Hfh6IHl_T3yiu(@#W#ps-&m@N_Het#3mQubi?lyAT0`Gp69N92g&NmfuSP;$_ z;1exJSGv>zncK`p0&s_R7p*3%-;1h=Ob>f%k`}8b)nnD9T&$XmE{*VxBCMYn-p2^t zQ7IlRe0;qAn&n&i~ORg-|7GQca6vrAy3Cb#8v)Mmns0kw$2Moo4U#u_{m z+Xv7f!Vvx5YI5!k9MorYs{yY^PK+F*CROpyONu)H?{$?N zqb55K8ad;EPa`Krj!~0mF!o|WI8Ok7#&WcpPzR!F5|};&QL5Ab0!ZcaW}%KB6s`G( zNX@?wbwQn>;(B>DjKjP}VA7As16*~Efa>(mdjJ1JLVJ;rx2Z^&`2QneHfnVh*tw7r zGB;3yZpygX#x!MO{Lf7pC-AVFDkKuFL?t{4cOyZJ|5*Z;8&qImm^qo*@B=RnTh4nD z#Q2{j)DsEwUJ?n@q7t@6C5Z7qOW;Q=Rc2KbkZhvNs_{IeWPOijU1c@t3b|Pk%w4!@ z(ud38Qu_^{ZiFEPZhsEzaG5z#Y_2_PW zd#h<*Z~ntrb^Ce}Q-3k-Yr}VpRkyFbYHMp?HTF@WecgZnP5a7E7)kpo=M|)VWjs~j zo?I;Qrq&z#5vb8#rzAQxn_YY9YNR&w4l$%Q;)<4}KeaLY#szhU^Ohml^@VA*(s&ZT zgu4OSU1{o5wc*&%0^x52)!oh0j;lHV>19!~`$P9Oo2@u#uZ`czUFO}eInyspr4Y#$c4WGLw7X`>aOP4cU`p~@XsEF0Siwh z>7M3uAy?6#51Ez7hp|xw`5ma#@niqSO_6YHf=6~mFsEh7gRc5hP&#NCT`?0?L4FD< zb<)5YKGhqfp|M`0+?axkP;c9n#Tf+liC*0jZR{viVOuW_10{Xu&Xo2|PB!d!^|oHw z$@{&#GPdPg8r$;ue@C5g08u!KC(*^w$7}hndjm>x5zhXP4HQl!Zd<-fOMU7!z)o@C zWymQkuxa@w=D2DD;Rb*jM`6?QmAeC)1HRK8P#?k)xNZ5~9IV$Kor!=RuyB0KH{xj{ zVkz+DmgBX2cOiZpn>iZ+ZMATG%XcopuhVcC_|N1p4dG|u&1?D2VO2(A8bHqH$0IQ{ z9Mke;o_BOu6@h1v6C=m8e4m^)a#{oLdX*g0@>MUd*Cw1%z$aZL$FzJ;{p2bZg!2gS zCoD&|d{hW;@mIB*@iVuA?{vT38r2y&gyeOQQXWPI*?x3Yv6y~z8Cq;Vdh{WL7x)A{ zc|3^&SkAT|-SrTvosw{_Y@zTl;#N(b%JQi_h^5m6cuR672yE138*XktLbxBGJEE{r zlftchY6=rO4bV)&61Y{91&v(A7s7c4&?^>>SChGKxLU-=z_(eBrzRoPg(Bi8pkFN< zuO{7a$VbwUfQ(GSBWVbKijX}u`SM8<({$jO+pFI5F!?}>!UF2Kw|pTcaKM}E7?G>?<9j%k|5`(cb+Mu4Vybn%@behsJ@ z#Ou#Vndb5GLw?npj$DJ5e|Gr!T{k`BVw%T6iN>mjpO>QdF)3ctJu^= zOK9ZqJGJpL7)|pyc@pkI`V5z#;YoZE?zVYsztpcf!ZF7J;a3IK&Etjgel;4%WQ)c% zk82xakp`()1oUY#-iFt3L6~gwxI2$ug>xwNaZhBW**REhsp!B`8t_?ul8`Bk=I>-3cx>gVy zu!sge<-V`X70r=Iqieq-`l4$xt0Y~qf&G!tz+`lVplck3U#n}JLN>a_4Pr*ucy!h1 z+E5scu9ZFGQ!gUGRd^Cd!`7chvzPCoLMMYt?UY)nFj% zb0`6x#HsKazLzehE7k&4(Os~Y23o~qJSYsUYpq6W8BKt8B!iI)_XHzO*DCcvFBH~#@MKW{3cWC_yq@j>ODB_z$0BT=CpLh=xQ$imY`+2UQYTI zuCvCjfr%r)%A=ayoCb=;M7opy^E810e#rV+|eaLjTD@3nZ)#pl0@9V<_sHycK z(*y2WT5Pj={UhjN^+3`0#go{C?V@c~f2a*;Je;RlD10k%+pKbKaP*^7H4&Y`hc2QIKEl!0qv4Bo*d0F&1x1B zE75%s_?uVBG0keItC6z}_@1lem}d2ZD<;{$0{`nOIi^{ij`OlC2qy`JpNdE4ySEM` z%_^^rR~e^ULflN5^~}k?Qz|;%{EljmH@xGA7r6&7jsn+IUkML7>I57|L9V_$-Be$} zPMH6pV;a}~_|G<#&06Z|Rnt_~FJ!E``ugSGxS85{SWb9Y{K= zuOQ-VsxRIbFV&aKBuMqec&flG1dpx*Z*50{cqux5c=fg`9ZSa>nNt3YpWzg?nDoCJd1>+*1KWXztzKB^EdS{_xqcAm^-3OJrO!X-F( z5^rVvHPCJ*7TQ|Cv4aJ|?FH5KaFH}jjRF~E(YSgzc@LImkSjBRE+pf2cnt?(vi0yp zOl(~O<0ZJg?J)`nL)XI}JC4ZM4!8YeFmmBz%O$b&gK);TjYmA6hgnM}Nl~)fmWkc#e^AfVt5XCYz%r zanW&W*e~M=ArYFyN4OQ}jOhsgIxFJUAgQt3%kJ6)>B=(`p)Z z-zfo8rl#){fibciftgpbZL5H64g3X8`VLC-N;YVKlkf;rc53PETBh%G-%iul*2_fK zV`FX1E4d=uSoJIU@JDg|^q~z6s$a>=$=Vti@RRh@rz1d9`HVr*r1IhJG2Kt+7Dg3V z!s|9u>y7^g)NA_bTm&~7#{Kd}!?<((1vmw=SBXq<+X!d~j-@Y?`rb21vjYj_=8tcEo_hS>+$djY+}V|*+O ztzosXpO`YH0-a9=BNtu*mpBbujQj1L1N@dpp(o*44Rdhi68(J!%9o@uHmV@+Q%xPe z9DO7Pa~8n1LUH|s>bGXGUU z-m029sS7Tf?F-VKv0ilw8B9!>N2v1cw%*Pg8Fsq7v(a|Dgy?m<^d$_Y+ckOtYINJ} z8bpijcGXz}72AbSzr~YShW#en?dpKt$j&ctzG$IvCE~W*bQ1hcI7K$ z!YTp0A~`W~Ot;I2{FLZ62HyHAIi}l{UB}272z=C4a!j{tF-~HzAe>pi=Ua}R&7clQ zx2x*|NI}M~wYYkU%TR$2ZbwPft@bhKa-h0ybzPZq*)+nb!3c9Z!meY4(358Gzr!LJp2Q_^w-w4NTtL+tj$JJf zUM8rnP+mm^Iuyt_i^f$b-{Hcm^GM4apo__P5njW2V6qj;i^y#S`)hdCd5j{$&=pFP zcl{z`C)^H`!N`Swg4DPQ9>Q3ZKaFm?PB zI9k&Rjy>>5h2ov#psP9HD?vw33l`*Q!PN0T;7rL3kRH3nD_zYw->6sFw_lJ422&@6 zHu%+BAZ?2Es-w?fbcMp0s0c4!3cP|7OZkg;T(%!g=YXf+9O8-Z;J?=a-EdPoq(*@q;vKHRiE$qsD(A6_*f<14)UG!QHCy#Fp5D2FL3y5MC;%R^tvh zic}NGjTVhle1{iT_T+A0x>j7``C=6J5R*hd65>WK_11Kj*V{EjheEJlk6yePflZRnI=d0cc zWmez-1f0P38C|E|`}(W6={Tc&yzAsyoxpEIej_47(Umm(dkg z9~F<>`&}XMd(4P;O)mNtcIV&X`vC7CtF*O%Wds^G{~zW72l=Ox+n>eNNcDZ2F-b%Z zC#{FLnc#5q74X1+s!HMy2;m9eX>{72MNRoXN>@{yg!k{pY_%JD3j1zxZU3NQ_(=%$ z<&P8GELfmD_5&5z`44Kv3Y?pn>i7e93?BntV9g#Nxvv44&PCn=J-fqrKaCL5088ih zISJG7M+YbPDa66XHTnnz!OYd`2;l;kW;?2W^;cjF`~lMz#ty zdJ5)0xR)d$v<@Tg27l6=Khz6NU4x4>r-Z)2{;~#t(Ofe00fxg3F40^e^!FN=FVkE- zQ~|qd8vIRjR_HDaHX2-^xncVs*TSqET3WPk0-b8$h^1}&`?2G(fh(4-?Jr~k@jIWM z#VPpqmqI{-&X=$ZZr`9KEC~){JFe(vH!La6NmypK9~^|Glrs>t`R%)8L0UzJ_0;0_y=bW< zmSyb+&{A0}E7}jEC0#79x4(;)s?I26>e}|lFtTY-P2%=``xegvso|VKI3KA3kw=xP z-%!e-Ha3B$+^Fa!)V>3%1yv3qs!-A?YxalsV{+q0sWB5mzvB(m=KQL_@tU|sVQ)G- z)bi(d)J+2%dYFNMTpe}U z|F8<~Js*L)U)}FeV-CXnfHMjvpDK_KBC~tVgj0e1G!7w}>rBVl|Lp$GBv|tPfcIHs zxy2!LrZCEr;gt+CG`9%A6p?x}L5jDf zna+|JBp&+{6WtNtv@)F;l2;8`D656{(7*6pZ}CzAvm@ zWO?zlgg`wIMhM|ok6=9S>VhCP2$tuV^=z;-=IU4}f^=f6@O0Knna^~7#O!1CQ;bz} z;u1ZEu4X#HM*zJ*MeXZ}HP92i0DVYk^3_m_Cjc#^oW)lQ+=T5>+5a%{Z^iq{b!wpj z$?oPO_O0hFnoV?LrjJ73??GqGohqy012l&^edef!GZ+ySdT2Rn_L(&MLphjVY4{+` z38C;mFwdenZ|E_!S`BB@oIeysJJIkVnhS-_uZ4LI%_*VB=yxv7#X?&b!#t1XlA((m z5!SG!9hmdSO3S3oK5 zkiVRiXtG6Ou5%p;-#E<8kK<(6x^VhRXvBUe9fafmLYV1%_BaTiFp?e7zB~2Qkf@-9nsiqO+F;xS!yh{E1c%PB*wm!4 zAii+81(Hv!I^_4atweR$Ov-VGo9tzyJ%xp-3A(h=y?k>Id3P;9bWS__z~d7YWqF~V z=&nK$`xTY?pjdI-L*OLvXSVYYROKNJ!HtY5j$5aY5PO0VVXqo~--a1K*Oh=1)oV)r zP|f$z3Cjy+OZiX>K2Cx)kR2GE;expQb@2bg=&+$FS%a{AERHPnc5`q6xQ$WJ)~Xzmu;g#V2P(cC@c zQqFLidxXYO&Ip=&qFJbbW})#U#`+&*n7khP+Lbv@bxiU!o{|RxRjBG3bl`81y|_15 z=GZms&@af;tfvcL#vrTa6l_h*`a2O?pY>%T-4oERIa%upV2^HAj}CNMj%Y#;udL$5 zI;{{MgbsqBxei_n#s)te+QFH}d0^u~DcH=<=~Cj@skDp;n)dC0SNsF`57n-KgIN72 zQO$Ek54ck`?N5te73c^`(*cizG~LPHbjTlw@j1`OP->C&F^rZ3Rp3uhn%=qH_!w6d z+02tYI*jqGa;%RDw7^F(P@3L-1wLvuDg)y&w*fpL+Bf58zBCVAVUno|JztUQ)I%vX z4N3Jpf*AkN%Q*ZlaFTyo1vszEA135sk22F~M4$87tgfId`wb|=W^`Rh?xq;mTj}~J z6SmuP&2H#IHfV9Z1x0+!ahk$CjhRM7+j-f-C>3rT8`1*9< z{r&~db>1!ye7mT^L`y(kbwzX0beQDF6Le-^x)C!i|F{bv43PZbVYO&~9G*|H5Q_Pz zxIDoYb0lr1(~>XCQ`B9aYO@M-xf)z|(v^qYqUp4$*!%({?qN&H({I<}!Ocxtcdd>2IO!LHTez8O3B@kOclCvyQ7+=a5Rqh%LSuZD*Zm< zRQVcH5RV3`A3{~#;7LxVgz6NA(^E96(17JIFXgmKLZ~U^HF%cAoS%iY7>@XP1$I3X za1suBCP0Asuxh}CM-3#Y0s#bGe>fw!&?#0QlTGz}C4q@yqV5(s5tANW>`0R zV6NllfZsq$sAG)t;5*=alQ<9coM$@AQ{gOgR`+?XxlW(&AUR32V{wdg=jm`RAu?85 z=P*r-6BCf@ET_-m@_z0oMHGlp)N#*so|y+ieupXflLXOi^A^{59@xh&RjmYC)CV2#!n2zcAjp)Sm zs{!6`F1@n%W99c{8Via1cRc4A&e-vAP7~)`=XrAOm3;V)9OeTGvl@Dn_1pMP(@7FN z)48w?%r_Y`-|tb^C5dodP1h3EReM+{R|D7o!>vJg$&!W6t*E8yw{mW=PC7WuNlb%# zTd8M8#9{J+={jzXeEzlmhZHr_xvmX->||^g(1S!f*C`BbufIu>wu;Wt0!4FKu&gwY z-{>En35DZI{lmr+d3q}nZ}cDDwVFo=Wa~Wdgnk`7t%eOhf9aoUc)4LChF&q5uo(}f z%8A^>8^mz{C=q5SB=V?tfydipIv^t*E(Q9%g4-e1bw$q-U=DsFjo>`fxgOG+zs7`2 zfuo)~X$%vf+rI?#J%?M5dr)f)btm*4Ew2+YMOccmUZ!uJPtvXt_H!dt9fX@$MSl1> zde{oVhNRGjAKKu^zCCQFi$7L7?yD+}`~ijcX5eRab#Y8U1qU0?mf?rjNWeQW*gmW& zwlmt%P`1Jm*z2|AhhMgbhXHlO#vj<|2+BTfORFn3{s5z6lWYv6TD0VUw%?mBAhptv zi$X{fG1FP_B{A8Bau zC`G5oL0Wm61fK-_HUE>}k`xJ0Bq#4e)LWEw_(Rt_JXnM`c>*fi;tc=OKEp$`=PPKk zT4X!?A^d^|i)Y_YcRDH|liw;Skx;iH(vjI6ms?0rH6eQ+$XPEWAYEBUp2X(cth%`E zz*U*MzeNX;jeJ6rR_MZKC3l6#tW^itnf0w@r?u>0c4n{Sag;x6{}c=>vT{)01+%`~ zi?8Hl-SjNHX59q=iCHK2VId`}XDYT-WF=n2WTOzeSe6asdB-{|1Y9Sq>JE-K<+-_GLA|rFghYchn)jq4)in^s2ZWRb{=z4@zWJ zDvj?NWtH0nM%G#ESxLxhh84Q}S$|=vzhu_lw18@u)f~HJrq=C@YZ0+1o)0T~%B}k* zmRyy;?n`xHOQ`$GI@t2pEss?tRT7u?qJq%z8(S1<$a({_CMxS449%RZ7PHyAe>E>N z91`IjK)BiA-76Jo2$=oNi?f! z8%ATxSEQePh{bs4BcwM+3y#sqSPJOVk0JR_{)zSAgsl@$$%Sq&jXl2Gj7A;rZlGu z;GU##O;?qRV8EWR_b+_Wwp%LDQPwj?fMcV9}$q1^;$hSjVXA>&W(mcW2dhWL&|^!G(Gjv_D8~#6Y@A zyw?@Ph*9G0=JyFJ8Br;Y$FSR`}@TdL|(vNHs3tTh>Nck>5@F$?H?kMXFp3)+;h>F;D*;!{#+A)&4EC^)JKHSnLr z^|wyK;aAZb=c~II$D+=%WpeUu#bHBht}-9)ziIb}r@`Hr=i_>igmc=x^aJ4huFb_; zM$Hco1;@B=_z7`3uQ@|5fMd*`PK%nqs1!B-a2S3Kr^=zb5per)NV66-3gKAGqZrS7meYL6EYgW@ZeAncwwf`PTh2n- zbp|<{3_sSg{YB8MW#m*K`3&u~S73=4%lb+&mRgLCMKYZj%b-3nmQXx5T`Dh4UCJqA%YHknY+__>cS zy0s+Z)+o<11P5$AOJ-9bNyg7$DuuOF{WZq2iPdBwLu-U{8=fV?(zZyCIWd-pmcmll z_!;&M{8&pXYNEBQVJTQk3T_2RC}RBd-2y+>avr0Ggk*!fngW`&eD!LKW&7hXv^N;* z6ys-A1<;J8^vj>Ya`Xg_VL2@@1=;~m;sQ2>i`nXz9^4=BvF2anyw4y&qpyNrWCL}4 zA`VeGxqzOCgY{^SZL%s|W+Ec+W9#uCz6R1dkNC6%Q;x6NiKV}zoA3poZ#`JY;+dX+ zPmV=#Ii~^rc@>=15AaV_dqa3$G@+&NMAHx(i>gNvi&H~qgIF7+rq>cx>D(J3?B|is zAjP)>zvJIHXZa?b{t7)hXEN|P|H7%cycRgW%&P)9PyGvyZ@9HUuRo!rQzq!B8tB#1V8E|ABMZZy-G~O3QyU z0bSvPh z&O$WGEL?XgpxG78i9O=!uRl&R|p3Om` zO8bg$X{PhR6%&arAocZ#I$1UUhOjIrgj;$g>GuH7y^6DiRZLyyE9km#o(BG!$C2pi z0P}nXVm+t)EhZngg0#yc>HzC^L!|0EGv^x4&%iHx951cvG3SMjkk-H{b{flsC<3=& z@R}UKyaKzJ885fRCS;E47CS4k39+p|;Q@CT3W84!{!>m)=S!#?Gi9plsFS1CA{tpf zzKtiGoQchuLb083a=t$TW<9a}>Es+P%Lt22xj7~KW4PBqYzc182sY0*iY>pJvm1M9 z6K)b)ikmZOE~I4pSRIsfb7X+i$j3f;1vjVs%fK4{KhE9+&gSa>AAg^F@66oGm}{9~ zj3H4-l07LRLRpfENph_v$x=dOU&}g0Dc9a`8@ZMt3`yCAgpf87skBG*q5jY3d7bzB zeP@Q>_wo48<8kJ`U+1-)*E#2Pw%7Zd^Y&iG8m@*X^aT!M_?v0I`kv5}yMVjT%g>KD z_Jq!3+rPiLcmFN0XHV#5>`C^w@UEz;tahHzM@+A!hB7>%{~7^$z{?4KS5N31bK6Qo zqdlP%>?`!Q*3d#vXzruXx{ZdmdO|_=q;0)4>XV+(*!`e<(8~fp=Ly|#5>Pu0{oo1x zg`)L8q@f=@p_5oR`P*ygCr@Zw4(#Y*4V_1hZU^oW@5%BwN975%WMg<#m;5E@QWUrj z8oJ^Md9k(B-%&%BH+0+GfHE}X^M;#d=#-cT;w0DgI` z(%T!Vhm#}zJ{mW`8%qBU&@&nu>J60$f>K^MjP{29=Lhtx#!W_gEVF(Zn&}NaKt20w zXpT2@Pcz^KYG|Q1G#S@b`k(XC>k{#XX5lVH|MOltSl;!9?q_Wd^0J+*@`iq6$-m&G z^I)wv6utu7U@v_G8@!;^W)`dg8ivex*hW6r?M*oXm_5|C#p@vLv zn1*(ELx+hQuA!Ys;a)&5X=s->bQfGF{t+75?G0re2Q*Scd%U6VQ$aaOLwmiUQ;C2^ zYv^Nd=ns5>(mzH+`@Eq~Se|1wwBH*#whg#(8am(&y}t+0cny8x4Q1lfWc~>nI_M4U z$I%}DL=AoF4K?`<&?F5V@`hey8=I`5!`@K)=a9n78am<)y};J^iiSRe)~xp_8anC? z?ZZv8{;3)|<_(?ToOPOpj-%vhb<;KUxi|COGDp4>pPL&Yz>|ChDLFGd|gA|!ghZG^o(fePjBeM^?=^d z&|lurN6c-uhAwzRH?UlmYv`gkl!lK#`QO#h-`-GR*3k+LUGj#evc*L;bQvYjzF?(> z{_%!ZvaPJr(EngdbPuf7&=qg!Q;r>LG<4M)Izm@Kj)wk)4Nd~(S`Gc@4RzvjW1WU9 zUuYk`UF3gHL&_IQAhcdX9$%;!w($EmXvpgetz+N1QA0jos9Ik@xf+TC#1_6uL-D@Q zL*E11tf2&7Xh>~PzONxaWX1v7qM?8+sFW{s04Ev!`!$s6 z3!TI%C;tHrmG*_Yu%GxuLusI-*YKc*%Ah2=fbvrfrTaqtKLGBKhRXUvi{Q8QAJ$Mg zU+AZ;z#Y-h4ZhGA_Rybcs62FO4(OW z4b||4YS3QJYN#eC@jW^J_Zq6@3;l@mjQ(>Ps*T)cfbs_o)$xVyrG@;cp}M}%i{$|Q zq@jAg(2ZRIo!8JEzEET!pr18V-xs<}%3m~er!Ul;28^9jqx5w?{t)QocmrJ>fo3Y^{s(*Hxg zR3+@@sD==*=rrySA*Sc2C>vEP9?Q=AfNE!>#r@ootE|A3t$%|Xu4hfw7bHV$vO?OE zJ&6A2Kte+0*2ZxT*RrOa1G@R7O<;|l3f#DS z_?74o0^R-3WB#Y+0JkI`z8m=`_+Kaq{tduw%ZFe39`Jqr=P|md`VaPR zg~h2$zvHhwp~Q9XQ~h`6%#nfLoFeACGr4f#d!p9L!Q1 zfZLW2-xY7b0<#kCz&uJF2kvw}ybr@tV1~a0E}~bLfb%Bj&Ho>)|2O=bFk@4xz*WqL zZ`~67i~KJZ2Y-Fwn&!hdz&p7>Isdmy!Jh$Kk9_#U=zs&a`g`)l-caDi<--@k8RI}r z|DUj4H3zsQ`S3rme(&%v!3e500Jkk4em$CYprQZcHsC)F-06JyQJ6Xfn)+K~j;1aF z=fwsCv2UrLjS=9N`hVB?2d-j1{F7{5ixMhf)uHMG*EAn~eG>4e{9mj9J_EQO`S1-` zzq$UA>`{gSH!dH(78a6$?f%|4NT=oix5UA-FjB2`jONRU3fY=HT_a-q=Ii#KGk`JV_xU`Il&-jJUPT*Z9&Qp+I! zn}lO5zxu#6&4+&v(}}>Lgth4VRR(Z9^5Iuui4-`W@EhCLP~gVp!+%#E{Ff6F?_mCc zTapjohVB2ne<#a-1900MJXcm$>cg0T27La-8<>CKPCIz1U;iJ#|L(7P1o%t9dGT&d z^3S!HmAaShx0pW>VpJ+{6&<|rze@XE<=>9C*{VKpP4nW@8nXWylYTS$uYup9d+iK- zchcxSJnc|bWN$(G9JE4>9uCwP7ySg(4n)$kv6f%J%DbNFazr{bp+Ah5T*NW(fu6T#={AV*?0d1+<*D;4Z#0+!Y0h7RC21aZa|3T zA9o}0JrWY12Y(&l?#YW!;b7_CC11sqEO5EdoG0QeE~?i9^S&*>O5ThCKQK7`2h2U0 z-OqqIX=BB!ncS;ANcyDL!9tlNmw@(S8=B-%`v#NCpFtY0q_4s|ZjzJ%x>7!pdhCL~ z#OED_q!G}~Y!WMZI9g^PHMIgJ%M{QVnC>pN`%qxxQx=+`ei$&LUF`c6fE^m>jXr?9 zbAXxeV&9`_&kuaQM6mAx^P!EE7thJ-F!c=_O0N!o0tI{y^fx4t@~hjEss-XPXCwA+ zV6M8@x9ez2Q@Uv!S|1N6v;dNH0J>W~ zlK$ux0>Ol)SW}VYMWA1HNLZ(Z_|Hmyo0i(4@EDA8q+0})NA;7Pk^H2naW zy*9QG9cxx{CeE1$YNY&iNCcb$`kYN-B@dw;)J|-RWSn&?C=~~Gf;Zq3=E1ZZK0i`qt%|m(UtmKcdundeZJQuSKk~|G`f1AWg9)(Ft zV1JRK?+SJjFg)98)c6SY6&O+EnTvwW0%nzsH6?x+W)%1*@nI}uD1JB42W%26c^8N3 zxn*v6L9l0mIZv#fCMI9TN+A#~{AeA)`qDAQLokVZz!aFA=*KWf$rXU9;$rW@EIhC_ zu}MSWZ468+8>>smN*;j*6xfkm-`GnJp!+!_Qb!{=6lA5QVk*cqCIbDsL*lx*le=K$ z5U@%onEHrB8Mi+K-YR`ZNaP&_&Dp&2q=~=IDa6ji&TuO*-G4#j!zn_O z^QP>fKPZx5iai~e3NCgg#>GHV+ITcY@-_gbv5PH-o;UD);^;x5K?X2gTx?sm{bPws z&^?lOFfcE<*oQFU2WA%;0B0kyvw&G(V@-88<=lH!@;i@+fb~FsHP->A0kL9D$*k^HrDmY#BDOs+87_8zLzGKek;YhZ5<38x(ZsS_a^JUDDc^H) z)+wnc7FDx=f6I}Oa_iT?JX@$Z`h_TBx7Zl{wn#d^l)4$vVRF*9n3^5}{!5J$Y!Xl+m1}%}Mzli>R{4J; z_Nt4S#hGz($uW>z>_%mkLNK}SgyA$$z2uv)&RY>%)5Vni517^^pTKJEKE$?iG2<|{ z1gaH(1C5dZg4SO*q1+3^nR4aKExh!F}t{&7#-Y#IzNlp^DbsbbMRaYK7s~dRlxX%V6r=% zOVpOZ^_UN&A-24WnN|as2UM$sII9j~8@QNHF`@_l=YJ5E*%q;n*%;}$Qo5lo1Jg@= z2g`aEsON38l@f+|2gW4#!$30$v2WNIZ9j$hR?bR!5_74*AAy=!dMpQiwM}ECv}cDl zs%&Ab#&;n0V;6H7<659!u`t$w-yrski}{zc+SNLJsS1{;r1nL7DZKW(Y0L%W#Qy1GiolT)c)8585nQT#6RyTV(0P_!&dK*;HXSIM zeg}F6PI{^WU4tYtp=`~?Ucb~f=pc#3hG**u8!P=fXYpqAI)&FMflrffd@@eI(SHGi zqw^43$qk=_ymjdwtdTiIm;>~Do5V^EVPFajDs>R7)tE zh3;$6{F#@I{dysO)!9n1FrxV5e9a2sOS(5B{|J(Q-S;O~fPwh~zJFmxjHn89U6SaL zOK-nN{47*_i!D^E zG}SI_xe82AK8@LgAIYR56i87v@uaN9)-#Z%VRc#?WKD%MZ?c65T5qbP?po~5Z++I| zLYFt;LIg2?X#cgx3etZW z$0B|vw$Y~r47+M4loI*(LmGEQexis3gMoO!8IZ!s4IDN&39G;lA)Ni-4{#>(N8kX_ za6mEx+jl`?AoKGkB8%0DDC_=o9u6zkV>S+vmgRZ6@v0i9K9w=8(f6^SNFnQe(Bp?+ zxPeIi0ODsh@WT)81^En2*~j$HQTh4mLk$H!(m$Vc(m(w82`CK%nIU7Rki4*6OEf>E z1n#6TY7{<&~xHKmExmywnn*$*nIe=APtds1 z<29v;%#g^&6E$v@{P<>S5`*Ipq?pL*0`YoCBvkK$#zj8Y5Fx2h1ojQBYLGW_sDKK$%kpd}H4KthP*HGP11 z=OG~Tvv01B{8SiD%TIWrCfR`>vV#N}Fc5#heo=5$7i*GZ_(5b9v1Sg)fCeI0U^hRE z1jNa>obTt^oWZ24hlja1bNMdr2*V>{27?nndzWhA=7)oESiN=wUSbCBv-o$H{tpj# zI2(NPR1nTNuM2mbuR@`Ignueee1^3^z1szwLjPusRw>*<3oGe} zJPnZx)!|W~z0Bu;cWdL;f(`PdJoNh&(TfzXby%$aMyWP3Led-|HEzet2bB~D7jX^V zhzPZos3Vnel&S_(^qj_U3eGcTSn3ij-wtu zYB}myz!#IO~!oIUr@oLcG4j?)qEZ1CodKXF# zwc=YHM9<6T7xBy!xK{8OVpgaspg9dYZB|HHfm`9@fLVYLRg{Xo9jAf<+xXkK|$HrIGzrss{ci4E8(?=Qkw_NGK8oiH*=P)7C@ZmJ%FDhh%i2x;-4N<{L}Tl7D08_!vGMXic)p)Z`BVd{(btPGs^NKB-_*Qy3M2!_*x@K@ly{fxl(-r z>WHDf*GZ`_D2H8x`Y%xbXsD+-)Ng@uXFlo-*3;8g{L*7LvYy(l0oc!qkK7Cil5+9t z_`pX-b1mf_N7h-$@z$~RP__tUcK_5OOQR<_WBc>%Njinsq zvk?MQKiI|=LVhhITa|#_c)9`67eT6uPgby`u9Eh6zETLE@G|MRRy`Y-1qe|^Ze}c7 zRim&dz)uleVW!@{j;Z&rb-k}vl+gSHHdh<@Flha!!WV!kR+sWA5b~pHgML7jZ`Ti< z(E|D+#pEJV23;NAn&7(!L8_cjp3Ih3uq?6^Q7?mKkYOq3u=E7ca}EoOfLV&DrJ#P* zP-Dic|5W%@Q0C^L_GWGvm8H*hcr(|ITBxSr-EI7zJc{qhYz#TO@f4pVin^(ufQ)l_ zQUx|IO6TKDO4IUHwLbCc#g`0!3=XJP) zG2Csz-PWW%+~FP%&b1CVi#u-po~_awOxan4;M^9|(DUj5e;kBar30!_G@S zd1dpX7J0!Q>R5~J23^iXwpI%m}=M$%t?f( zq9~o#>-vE;Hv~yk3W}BVbXctVI5vzR_0A`4&W*J>&j!mYhQ&23extXE!@}~RVPz}z z5Ax6sh^G)F4}4muR#$_Y=@Y%*Eyy|Z3PtukaP?>GYN<7;;OH|Gm?a2NMM*jfo%BOj zq`))jo;3h>A-E|lSD(Ctv(uOzpra>qN{KjYm=Rsy5&aV|7Z9R~BB*mj@fiCWLwT!1 znQ|vKe;`Pq@QKtxo@I|H9&7*Fu=H|RT7sy9!@_){d&Wq>!&NmpNqb3gs0V{`yhF_= zod6G5tyDZ~)!eX@bXeX2(fR@`D;1AkbuK`C43uZCLCup`&lzgWXZ4>7^PbcS2$El; z&V1FQH;-!3jVn_EdQzM1mKv+$Fy9Ntt`0Mwke7L?IegS`uG$ldAm0^66n(5ijfe*w z5fi|)#1X+KEutyjo52A~SF0YM=y;7N`e1h(5e*#?yTNqU5#eZY6|a2!MSOI{$|R8P z+4wz@2bVkkE@j<>AO+xX&*P?+Vh%Uve#OuXYlE;6f*2r)VRqy$bkt`xPLvhNi#}0J zg}VdO7a^+1$Q29*Gs+nba3+E)CyybMr+Sw-E4Qdf?BuZ}t_5ZbLR3)%C9YPa{sG&v zlS>G7C8uOg0dqcvnr6?&^UaB)Ivu zGCf_=!FgZ(r@{|_Gb0Z-Z91a(4yk!Lp&sv)%1}^FEI^&DcDF%g&jw;4f|LxOtl&YU zze15k^@_8anJRSK#~xq~BSaOsnRK?Q(jLN20sI+3gz?D={sUpF70Kfgv7^=qbEo7b z8)7<&5LM(BVUsBAc0@KqaE0ZmGx8j*8E1_*5^r#7p*JwkAw(5Lh(yn$kT?e5R0NU8 zCo6apydbL;$=`r0{cR(xj3aCvFdra96}c&Fl{yPyg`e;oM8p{cS6m(i$yEWn4Yn4L z8EAwN3?Zs0LKN&o1uG!37J@5Lz6Y^dk^EP@{`#^&ZaV<;G(uF78^WThnttFw#BI%c zD~Lh#f6_Lemx2H3-n_1K!bQWuK$!^0o12 z@q9Jp%RDzMK1V%@mx_U-@dLlbLOFBJOF3#@Z$uo6XMg0)oHBg9I@lW5s;b2}B_DWF zcT?WXiNkZ$2e|GcaF?N*JbVM*>fnvVJqol9vq9U;!&G!j*q~|v*UrVwG`N|gtc~i! zI+DeyrrL&Ty7#fiBQQ_jHik*gaL}E-&@`$<m2+BP5#pZCVNA(dpZ)Opp(9LktS+o&$df23M4jJ62l6vJ;W`-7~i~X@UQRp{T zS3BtAhneT7=W?+3|3aLY-ON!NRjs}vB5cw*q(!X5U=>(rL|mdiZ3YV6Tt}ah#bMlE z$BE8UQKlCrz=lr6ag6t7PSQ0n8VTRzCR|3hD%95~D76Z>#xCw=7q?N(9ww=cF{$;| zbUJ}f@shyHwD;VXgl@Z`+X1>ws&B7;*sKumY073k8twHNZY~*P8t~+oa#i{W;p^_? z=E53~Oo*4<%z^T`>VP4FJ3;^DsAOF95SVTh7zZM_WqI=|yAW~9-fach@dR1;D-{oD zGh3~aA<0`D zj#eY7jLD)3FMyQy9ZAl_fGjRTS9qxx?xVZ_sQvvQ0_hFw8!nN}KcnmkUNRKYS{SY|& zUx&Mg!;Km%ff_U1Zhg-H=Zb>dXE6)G$rBzkk@{{5?vD(&Ti^S^`BOn|U1KlCq}>DD zCkt>FZjO5%5U!Q)Nip2p!2NFl?)$;{)OEOL#c)?l!Q^p@)VHhoByeV3hkH>BH;+U# zFx>9sY6mz^=jWcUp6xc2=Ot{f^GY0_LVXuV+uH)yejr>c-y34m_Ljujr2uymaE7kK zy(5OZDY#!Rz_^RB~vD2BTtxYrioejl7)T!;Ic815e6K2(7Ff8Z?L^4j@6AHzKk z+`kpzz7w1sufu&ghI<>hlcwgc?;+rveI0I}zK>GuoJTaO72sY6&coN?E*8VxG+9{> z6yW|7oW<_HcD~ESaQ6Ur?*iO4!TI2IxNnW&9tZA;1-SczbJ}&dYsPRd0r%SlxL1Jl z={nq_W4M{7p}woMhtgFa3@dCU*EIAnR6ZPMKRo7 z*jlXu+=s#W`*paN#&Gj^SGxk-#oFNhNrY?VdsPf~52W3%0QZC7eD*rrxiQ@1z&+J) zyQBX!a4yf!JzqWf>>!>Cc7;XcXtX>gY-z`YHe z-(H9NcR!EzkvpQeWx0Xjc75jRL1mRi$dm8+3NEkz=}jZT%fo7Y4DUc^cHR(teH>m{ z6=ZCp-!$M4h~M<79Mz*SvJnUj#PWh}m5Ac8tS^nQVUDm@AZSB=VL56Wjtd6T0y0^* zrIm@1#$#L^W=fG}JJOCrQhYl*TShe_ty(^5x5Y@~u`erAq*-PWrNWgUDLbFEmh)7o z4pxti^nrIzX0seMfCo?;8|fWQ&YKwN8M$h)5u9Pv%uzpH=9pwCy5_2VhN8Mdq1SJ1 z91Sg$9}k~duZoWGj*fewU)zWB=GfNpaaYHt+)4aIJ{`NbIzDd%PjfWTI`(pPoM$L{ zI22mP-g$K7$-em4L`Q7z)qg775Bk02=qSs%47$WX-FUW8V{g8p4ukSw9%{InyOt6zmXs@i#5ZqS4 zq|CDXFO##zIVwc=)dd5$+^BAxE0T(uYM22TaH_?_X1#hFxi>QcF=$Ob1FjmCtJWE= zu97@B);|UxM`2CE_a<1$*IOWxZ+84i+TYdG(7>81FBFP8ChbkC4-RCQWHyX~?1^k2>oG%O?QOd3qb?&3!A6- z@&YG^h{2l&BWpByX0{RcW`&a=lBRJBcESrkUyAn8?U5ER_7;c_$8oN}u;hQjN z_XOwIeB5v(YS_54w}b(hb!xyRa+(`{t@2A|m{P$yko6c^DKW3!C26_6Z@l#QzDT$M#l$7vGkwJfYeVtE67|%6ps=& z&lP@uf?WzNfQury_2bPvH&RMrE8=0L_u5vf^VmF5^7yY^3SAOy2XBtj;I81B<)2JUMTCX*!G$O=+$MDc`hpKX%xE>o;3+y%Io5Zq!B7h)8Nu1zE+ z#%y_Dx7KzMamW#|2t?cRixAyELp03R=x%glr07=D3X(CRcn;UMLj>=31pfnE!^iUK zW(tMTuv;TIS3PBzyBKCYpnajOg)=(4kKk$GeTMXBC!OvPw*K1b?9u6zZz`6Nt19di zC1)Du9JTj(RL9TSRy>*ga?}-$tiKqzzip`zUsJm`OefNpLC!9|H69_BTIj_KTw!qm&;CB#s>JZBR4PBnz%>V2Z=ESDJ z^W}T@OA6;46RHX6WAmhd4MXN--!fAisGsefP+#lp;>lGF4v3&yP61|CL=8p_MORLS zd`NJOq04d-T#Uq4U-2vJ25TJ)FtfpcG;w(NXJN_((V+KoVd z48bjJZ{|Um+YG+?EuBOZ-VP(8Cue49NivLYN5mrsK~W}&N9TN*8%DE`bJyTN2&5>n=v zq+?Is`fIW*9G?#iNRn~29p)h244FOB!Tv}x#E?8<-hd7@k}=9i-$Ko#Z>eepseMH8 zMufYMOR86$uHXc4>0R^Y&YtffI^b>W9c_}$QFDF-ygo_#Xbf%@xgB7Gt~^g> ze|uErDfnh5CE40m}zVjya9KfOm?3$y>^+lq^ z42*%}B2M}Tk`0WGOuxWR35t>(bJauNiYncu0AK-nv`o{lk7YI>6M3Gh?|E8?CpfE_ z0Z{Hj9=*Mplg*gOco^M%_C#?IHm?QR>JRXGGZ$bQs7I}KIwf!B!ciMkW0>JVaOJ3p zJoElo&`hmI!NBhQUed-aLI33_{q}#5VUJ*eY$lDoGvG%<{h42=RXD9Xx~LwpCCsKQ zMa*~@kfZ4mx&rT5qWI${_l)P}wuMIAp-Iu-%4kGB@qq z{)^E4V$$rc>B=TSwG)PJ4s_Ke`GtvC2#-b!!#Bq8Vd26v{+}8WY@R@k9Qaj)zv2*S zIX@U8T_fCy5K+9VVe4-~y*nV}D*P^#Inpz4jo6C}#-nXHHKJ|jiYf1_DDR!DqJK?N zEN@*!s;F%-#?q6E#;i+NXDLOc)BX=Nvg;2~$=-N!KN8h7Qmm--$+`?L{V7x%OpQ#k zsmdCvnWNUL0kGU0rT52FG|_WVNZ1~7LAY%P%Sv#YnyP6C7t*||UluyJclDpCl#Yfb z#=Lo1#^is5I^AiAmmxQ^SKh+38{!hgqX#jCxk<4H8BkOvuwl5f*o6!<@In-&?n9n4 z5pUaNJ1C}Xb;})X%JwZ#RN0QQ9pfl#8pt$L*mFmj-kzFBZ(rXEQr(E+1r%@pE7=)Q z$hM8$z$HADH#?V1Yb}j<^efHnex)LAhY2h->Q06-!+uA^G7~Ws{mMer&ekVc@bNyF zequ2(iV2|2;l!?*iI@o5gP@(KX%oJ|q==4s5%L) zG;B!L35D419YzW*#*{h>OiKM`j6wh+ir0%&2uKRQniN#H5pXjRWd4(92C*2?=pvm$ ze}J>a=XF|`LFA|>zC$Jl8yE}iDxChjSj-GlMiB}TMQ*o(OemswXG!tGq6ogFq5o8P z7jV^j=T*cE_KgsYp21N>b|B_Uc%ezSYpzNzBEpB5LNbkSlcDHo7ZT-)Zns%MrX5jd zpxX(*w?l|}d{r@iW_ z*47d-)xxwzCcNa6!f0j%nKn*lLAUp+2zv#;T@fDxxA~d;g&}r!0P*nXIOVP@{j(Bw z|B<8SbG~{~YwXROj=t-*XAtqNiI{<1m&7kZ>z_51CTEPRss&m>vHFon@; zNjWi#QcjhvAj=`5cq7;G8b)oWulN(VR(gZf{H0rz!bxdpFMPXHI3-#lMT7?H7f$4b?*9Nq04aR^T$;9yePmni=MHKIfnrK8c zaYW>R=-YfE_&R|i#v~Ji4tAbuT?C`im}H(@=Mf1bk{6rpHX^S&BIBRMH(wCkHtaY^ z84X93QzH5e*fL!rx*ykXt|A7;At7sgg-c7`I~ zyioB_UE#JnDivN1&OHUW=go(LJCbFk#ics0VX9J3xX(Ii{{YT=`q^1z+FW>;rTVAI zL}BBtF@p|(;8}Gtt(Wgdlck&DN--|G*kK1N*bD&d5L1?<`l69Nf~)Xw z;C@HAMxiqr-Q@kY8S0()=aacR7)z{NrS24Aco(4ma#Uwr>K6E)wnDtI$IC%OQN>W` zY3db&?}|t>obrCw_J%g-tS(FThm|6@s(ImokgjAQ;?a#dx@jLoVhTMO;)5tr4+Oy! zyGJ!{i=rvgsJS}QrB}*O(7&$_Ih09}84s2<(xRD?lw@ryNOdBLcb#^>TQWc2S%dEY zuF3#gU9l^(7-lp^e@9zA;M7Txo;ied<9d`^U9Fog*+q>+_}bWVYisZ*H}e*Rm+o0j zg|w<;V{MRFe@73Q4w+d9qcPAMJ?sesFXyY;OvKtY6o1IIFfiRn54!m0MqxK^B zf>VA+z+C>h*lg0PEcs+S%CD7_-+J|%o&-EF27TwrlCH^)?19en+mbS@O=YJpy9an# z;f9WqAim3KD(pT89i1;hyTTZcf^`xskMT1{eOnXq(@Tl`cPU?Hki1s(?#D&`3K5TY zj9HLzERTGrd;UR-A8o{Ag9~qEY*&hHjm{WpNFAf%d1vzM=j%c;RSc$&XQZ0rv6jm*T8$) z5i3gIHHv<%GN=?WoIlS~Q}7Kv+=(Y;xE8A`?Zz8s62THfudYXG0=y%!eWARcF|msz zTGE*m_y=K9fZ+CcP7yO2CevC>CRbGq3G)FtGaEDJL`h;!HLM_$i>PK$XSd<6>$LDE zfcp%=EmXc-mWIf9^c0Rd+WlQQRfgD=7$o#CQYBT|r1NgPn$d=D&-KW2d+Jwkfp{~w zB0^`Wg`wC0@3-t-;H{1S_L0m@cWV3}DmK_w&I}sH%=)Dgqu<`$&o_|$QpEwV8D{qa z@6ha*DrUDq7WD&lny{FSYU(qRP{@>GKM2ZEO?emTP(#%f)7p-Gg>17^*lFB!Fjgnz z$?UjZwbLEN7^XJCF!lzq**L=srKdhCGT{2ue=2+ci5(mgnjqs%@0vQAiGf^K$qG{?^s?#qnyZYApTVME zY_2vDzaT=tsa#_U_}7uS>PkP!R$F7%x_#xER4;*`|3D$w?UbE9BKDinV->p7*a;c4 zCFa`33VsG4qIlQ#*5^b@UB`!%I8<3PUbIV({TVhfj4-8Vl_tuYc@h!2^sLeY(aEBG zM{HI_=*)PjbcJCeQY?Ha=&_b)V-MBZ!hNO1!Y_`%tCL^A6=x#;M#LYy#5CSSTtdX$ za;W_T6LA?4OW605n{XP<0H*Wzr#if8?#>f9WfD; zQKu*EI{n;4G7q=l8*70RCgKt*xhUTF=BRI0W4Qj=F^C-Xl%$tC17H`3A2`BJT6z?F9mRO` zwocOerIUMPJeuFnhcRn ze|(=2%8d}ZB{w$_XAq%Va*H%+$!F2szA{;|b-$TlYvX#*DEb=+Rv3a(h9F1PK7*=# z$jJB}LUjk7>y#^M*6dB<)$SS7B!RikIQBZq=6`w04P)y(b#rgzcdHib$$Uh5S(0IP z*4FN2_1nnZhUTeUwHmh*@h_tP(-5EHo1kK4Sf$dyWd|3plK<;fA)e-VH_MMiy&|}6 z1N$k=?$#=0h`}sDG}#6K6RfnFywFDV;w%yFHp^{TP%OLU2Rq}9fVjOYP6Iv!sW3G65%t(RTVJx9^!>@^W| zH0V9le;USfu-)gDNXpAiNonK0YzWY|;t#jBU;_E-QXzcUS!Uh^_1<<=lzzp2gT{E+ zg2`%*D)tjJOHP+=BmzZr4pL0S9L&Bqyd(0HoNAwrE7b#c84|wZ(XQ~7ieD`_n=RCf zjM^%^2PqzNv@vUY=zg*+-u^8Y>hTWs-=ItxV;8UVsCdbsH+6N@NwR5xI~9wicZJ*C zl2jL*gB)(N@SCSTPDAtTlTHjqTAWxnjP|QcUABE4=`tv-RQ!(78beyc(eO=3S)VTr z80=nld4tp02g;ckeuV0j;ZAY5kAd@y!!7w^e)!3wO9k>1Hx^qg5Mpf>-HpCgJ=Zx2&P5;d z`iE$yB}~L7L?rNAEXgKfGa~ftImJZ0j|e^HmNXGt5TVE1Qe|b#{QwcC__c}DvNF_j zX*=XbM3goW+Y#|Nzw44_B6cG}kNsuJx}Be1i=~&9v7epfLUfY44OS{^mM-W3S8b5o z)^qxu>TqlY1{%pnKyt*8pv~#O9CagK4n1i|_91coHnNY2IH9D{@VVe(p>; zhoDrSooH8qRG9JDG8&^qJ9|Kn@)hA&EgFNq*={sWmz5{;;f<==Cdt5Tquo~!t#kRZ z;o+vV4-L@)L*zjsn&?$S)EPuOH;W|O@pdPO%tB^?A%msstS&ZiUkuno-xs!jjcmiR z!jQmwqghrNxHmd-c}c>rTg=)b%me+xjr$Lg>Z(bxMFV#iidfGNw`n2X%zZcsa1hmb z3kY*mcYMzyu+N|lf>!S>Jzye^AVQxNIAkJdJ~O!G;R_RS91)YRAmU3C@g-;NxDGZ) z73Liy-x#an${L%lfEcCIJ-P?TUkwi(`&#N{6T#V~o-G$DXHQwN3e-}c=hWY0qIbhw zuoBb=Eg;n(&O?int`=p=*|v?M!p+Vf&*V*=e=N1Ei$(9#rI%!CK!wjkzbc_e23TpB zD)GwBK~`cfMsipSGBT`^mswU9vkP>u!`WvtT%aA%Z?iF`UtNH&L)?IeQFssa^NrZ) zp_;9;tRh#6lTJH`ZYvD6gS@w{V&b1^Mxd)oKu)8=Ui4=gf_D?upU$znQ|WeFYi{!;RO}AfouGj%J3zeTjKDh&v&e zZ)W5hHu)mbzsExY{VtQDA&}q5h$w#CV_^Y-(?GHu0Rl;OZGj}v0{Nv62;|2!B8uMu zxl%yj*C4rq0D&aCwm=eSf&3^)wrYD9%CG1v%DNfBt&BYPhbf>+edM(cJ>Ohg42oR; zsqp>4Jd6-k6d^V88qCtu9pDfIw?^_vB+v9+J}YCNREsNdE-+aLQAH7y7*=gzvuBEl zwO4i0z6$*RZL{~6ARXk)Q`%-9C@~u*j+eMrFcBshQT$j+*r?IO5q`@QTy%kOjmm~3 zUDWt?jwLMmiE>fzlX)XZf z9fYVNH_ITR__da=3#fSz_6h*guxYc*-8u>4yx z+4D_?E&Tqpl$hJ|ouzR0eC%^g&)1rf)GC;bhlm<55VhM!IBmBVHoQ(#Ry~9VS9P;2 z0_`Zmv>jF#B)qSJowF3FXg5~yt7E`YdaLLn6 z?g+G_2$MT%>*S79lDo^uT}1Ul?QJ)ubu(D_r^0uFss(~{E$p?a0yZkOvaF;7QtdAF zQ=ojop=P%%)Xz`B<$8v?yNHJD*`QqFP>XUcQO;G`qMX+Nu?s=US+0qUz5f*`exAds zkiVDs3788Axc?RZnLY;5S-P!YPf}6bA~DGJ1fh**BnF{N!}nMBWe>IlS%!> zl-vw-08vi_DIBq#mY}|Igk=>kFN&RTvO6A>Z#&d%aXdB6`;T!Y`->&JN$g&Kx_q*BDOMShIlp z5J5LZ0_`Z`TE5)eHj-1iL{4GPI(Ri)dU1F5I$)Y)*}xq)udM} ztCL|V@33TpXt%>+TC98>BdM_WmkDSZ=#nDp_NkUN%y46RrT^gn0_Vm2+@OB25x&0q zj1*K)hq~mexP}Ko)Z>%B6`I%RM%0V5 zM_%98V&q+Kj$3qwPh6MHBn80aW7Db~_XZ9BNkm|(6}%I_wr;ba+gejmX^w77L6QE$dzhNvX<18f&eYtu{u=vpThty997BjTS&l~+VBmiZ z6>D{K{5L35X4}+e^fHa9p7$>lJsVTDYRM7jCJ^3@;Ep)F1O7Ry(CZ#X<8vEm7poQJ zHK-kDbuN(UUcd}Rh$@OgbwpKl{m>QVl=Ke1_H9^hbgE=M@VX}GzMx{=til}>W5J%K zZYe7o>O*}f^352j@$=2AoEX)E#EnLx+xh)xOWceHyEkT}Hjiz12&)Wm?lPQn99>$z z9;1uy0qY~C9pzYCRN5#PPu=?j; zeuSo>RU6?qJHi)%X{Doz>Go-vlVAZ`fH;ic&N=g}t;jbO4&%R!)Mk#0=LHYW{Q8_@{F zw4)r`h)5zv#MrP(&BjgpM$r9^>OTVaf0y>f;-u5PmR{`rUHn%KV@alm2Rb3bsy$N3 zG809&3$FU6>7#DM1Ztjo6U#z;lZpUyxk|nKIOcp0dhP;QI|M0wd2%MA!Sk@l)rz84 zUqohxi&eT){}+K7hY(eiL&4eV*3PKYR{_pL5V3s1_f*jBuT~_l)WK_QC?ISnFb5H$ zirgYB;Ry))2H;-^uCP1?LY^i+V)1DtVl$xrQ{hy+KdyifRTLrlKHXL4yEdX*B8W_R za`U}St4h{QcpFvauvn0r?}5M!N5FOX_%EtX=mu3^0XQ2$#PZ1sp4Gxgz7n4xZ&pCq z7GQQGL>0M3SU1c`JjVc@M{tGZ$v1h*1mdi&MxvYVqI2<{5Fx54f)XQY8O|d3MoR^{ z4YL8LS|a4_BeK=Zr;&a~Ao?Om`s_gRq))zu7d=+bmqn`EFlPeu7D7}}grvU}4#J3` zY;4J&3g-g98$r_N44z|fw))>t<{yaj2$DXLdD16edCW2P7Ffv_4I}>u$UkV9{z`QO z_I}e#qN&>zGyqjg1WBKEO6stB0d4Bd5kg(n(RMy4)9=Pag5$n3#aN=J7%8(D3GO9& zhGBzUvlO}X%wm)7->bt;R+%bu71;)&PaQ>QIHJf>D6+*+yNXnvXB6oS+tP~g^P;vQ zjEqr4Kqx{kt;nk&SfwWS(k-DOV%sA~Da(`F5~gE-S*@x8zxgsg6E#YT#BB+~fti31 zRg^=WvsKk6QF*ffEX9!a|j`-$SuO+pMtP&0bWFKh2^mX z@?8AZV~sZw-IkCxA7dawR8a&aexSO)fG-U#QJ#8;Z-pR2<;l(XQ|Kx2MGW8%_ObAV z>-)47xEUV=%t(Z&q8!n+7?!4U$90RH6QnX{EF<{=S;5FTIw=4UZ6E^SeG&QcRKHUk-LfOzds!t7}v)}SUe^v))= zT#y!7Xx5+v^82T_G})?xbJUkWW+~G0yGdAC`an&6a;&Q z0i1v!V)=x<`C1ssZ^R)t-;w--M--S12vJ3D5w>MKgzW|hm0-VDgZsYZH zxX++H3wMXfmUY5#o6RvudoDR0ZkhS=vcxu@<3m=*B&}Z3I6%Dzl;1nle1gk@_0rEO zaijN*V@#{D6|9Ga(n@t1;8Y{RU0WnB!Pti&nH3Qn|L=OpvX0c1Yz=o3YyirZ4mF=> zJ;6PgL}#mI?U7z*#0^3aqvV%o%)0SyFQYN7({sc&cusB=XU#VXb##)L2h1vjsG=x{ zkE$p21B-k<`qrakrNZ1oI|%&O2$Ba`xvt`8!czG zHi2g#K1b-Ss)guHhaJ!`OBt!7vAdmLzze3Dh?&q3-}D*=FKiu=eY;ax4?xF^JbH4% z5K%w9Xj$j02z4)qdMGF-In<8NHll8U@bhx74x_)1EgT^|2)lKM`BWeTslA8K?!ysLXp!+HU`MtGHU-bfz zS&Fp(Kl>`G5mu^`W!Y^RBPNqo|n`xPO+M{u@#xm1$&@_W& zji}D(r-qu;+)TFw>0AVz5P|$2VJFjlfXq^)&70{dy8m-WW9d!Z(O6(~&{QL=enU;C zo{+MyFKlgqLm#=5yI>oLQSj63)eF8pyP%_{+TS&WSpj^KL$2-0=fPG7tO z2X&o+Qrc*9hWbuWwkSXi_W?iW4ZDQ*Z>wPfzhRmO2JQWuiY(>#{@vvz8jVIABqi?l zF4i!-e@saKLv27>#z@h|?e=zo;4_5Saf*#EV<*O?SwihLz6+o%@s3T+r`T?9F;*#h ztVq$_o^J=fsA@#G-Clh#HP0u46U94Wn%&=)1S>iDo(f7`OEgWVmKYmbOU4$(_#&zt za=P6tq@>z8BCiJ12TsB=B4;4siW~6Zq&FmCm-;VIrvLS+Wxa+1m(NI-+Qmq{n4!Nm ztd3!w)W{eX#uQUk9kWeU(fgYo_|s$YqwKOyD!xEm!i{CYCLoP_iRwSgYZYHWQXZ;8 zXZg}jc)1UVUhbN02&7LykouAu;HdE#ytThA66yyXU9v#A&7l^{)D!A{R#JJ#Tf0(C z19y_~^_F+IPlHn}x6{h&>n-eX<7Q9H3L~Z*ZgRM91n2Dzw>`|SRO8Ta_8IC@4)uee ze8Qo&-ILj>1AJ?Gdiy0KQ z5#Rv?S6H4IFL{30>$9vc#28$Oe*kj@A*v{X62mHSxn-3xlz5@3|5UisyR=%o4WP?T z?*QUA?sbQECs5)57Hcm2w1?DaHgE_(jde{35PLvmaa}buUb=-Ed-&XB6E5qSFXsO`K?%_6#5WSuZiVJ#)Gh zR`q+ru^AQ&$v(+RZOMO~ERtz2SCCArqVn9BwX)q>B2X%(@!ts*c(hK&jm-?BR9cadl#QGo;&h z+$v@i$Wr9e9YEPzSt1J{`V}MEt^JJXb!-0)pu}_Q)IO=*+J6F2Z0*yZyIB1?)3Qq5 zAqC}Tcsgj8XeVpJG26$AFY!JO8=nVM1VL<^9#*s!(hqn7TacDY9iq+aKNa2w%u$4> zA|s0}8`l*<&KZFJAc!1!a#yftU>2(t85flDSVfnKShvAcT!|e82vJ2j6dO@3;9Pyg zxWwu@3bX;$iwIKl#wA8e9$+O!7c)nhT?wMwivCodARTrCy5eav*j_^r73oxkPLyTg zbCQ=#<+xd056p)MQAI|{>fc=;=ODl{2qH(G+^lY{!mN_92+q>f`zn9mkhBWh{SdGd z&WOd1HTYB88%j5;^+DAWL9%L`Zgy6$Fh>Qm8d2{Lu&h(>NCCSIW<2C9c4Wz#1#d~r zB2%0cY%qs=VI5}tRIdGe1kQsFH@#)jV7`G>mon=kx4~3eZ5j-lvTiVJ@OFcd_U$wn z)7-NZxpaeh0$eLq+-UUuD;u6uzfASnfm+>!QOG=0rJ%5`5NVQ?agA2zcFz|6-+U(EWM_1Dt{& za^%Ui(n%=f)rySe>v^r6My%T)*8;NzA*v`x8f0_0vZ@*%y=$dk179e|t`cJ#wv{eo zjtW|7wmLruh|*xY2|-k(ixWCg*0;$>-SlFZ!RtR2ZV60#gs38;WOdQ=kkbv|U<8pP zPi|JbqT61r$XFj!reT%DD%`9t0OlQpsG=On>S}s7>kFm3LfixVKcrS|Ff*a=6xNoj z(hOl+qbV1({qXg8^%M-3^3a*h+HYBx)`&T~IjXf5QyGN34o=3#`W;DugrrPM50Mtr z?tN8yNS5lZap+@$&!I+*Z*vy9fV*=fvGY#xO#x=+ny7wMsF?+h%>4&GADCvuu<|yG2Rvv3}u3iL|N)#zu)-Mqx+ctp;v6PmK=) zuBIqg&rH~@WUKvSStW=IBZ$4w+X@32i-;*WLKQWQ*ll84f!T`?Rb&*q>q9x81N;R+ zbWLkW4)iGh%q^t)fkieOyg*BwU9&O+H5@? z7GV-|P3|9%-nHIQJTsrkaYNPr+vJRc6(;v3N~Yg8QZlZ|Jr3bR-2`MN$CAlwa&N)p z78z#O~r zot1O3wz~U1>9cNgSVjOp1wm}bU0Y2>ZwAHH-5qj*dt(;zrsU|c6U!H zg+70!hkjVvZSV{pvQ_s3$mq|YiQ8yrluu4Z3jx4&Rm^BBozbsB`}|n1mAG7b12?0! zLE0Q4swhuq^l$yp6?5FLQJa6lB|n#|X5vd{y<$2bYd$YfUU z@jofM?~SN0MnXN~C_UkDF9PSE4!5{}`4J@UO^dJT>!a1!Ax3o>+|$m^lVt2N7Cyk&;fH#v%n%!2dG^z(qx2G{%<3?A=Z=7sO|@N_f%eynAA7tef@!)hUu23u4&! zO=$EH71)l>caxa4WS+~`3Y+n%a|Fjvr8{57#(FkM5!3m~l+$#+?KO_+9K@2!cu(8k zi`{xAG1usZfOG?b7#%%2dB%Hgz;li6TI0QOo+39lV=30#Opx8q_c(-Ka1w}FiskKm z`@#YSY|cO4Kl{Gve3?CGnyowEr?8%MI$z1X+xeQ(a5`Us-OiVCb>}PF8JeTMr<(c> zI>s>myCK~Ty_D!8|qXuTx;I=3hm-i7A33k=^NNEgm0r)T>PfEDb;o~^I$*(iK? zWv_M0cnjU0t;iNkxe@R(6g0YL`&2)0^|fR-c52U&qH=pS_}2=%H!>t=hwgNW^~HKTLhPszrd=gn+|9_^(y#s~@OZGo-WK z)S_FE-vO^ah%so8u%JPx=wCHC+sPYG;T$Z^5Bydd{fsIQ$KmwXWe^B2I|6EE9&(KFkKL$irgYB zgTkH#I2OSb7UQ#Ap~y2GCnMVykhm0>RR~c<5hBss0TPb^O!yGR!1IZYcapK)FjcwNn#EN-a`KjIR#9SZTVAWtfUGLI-W6h!EK-)P$}c|gIy`JH3YfYY8bkCPdcPkMi71JHiQC9 z;;YeKtLpnw-tJnx6)=w?L=_puNE>g1oSpz*L=ZXbfAW|;d1jo(oYF{i8`3;rmLWtH zMNnc`g&(u5TTS(E9Dv(s7&~G4k~3Rv z=>oKWJ6?$)h>r9dBCnSr=tZ37ZEp(O&FdW?ZGsS0WR$#y_CiiOfV~hzjy$=`&Smg4 ztx#mF*Cx*DXT-W0o({|$gs7q%$?)A!??prDX7~*7PKF7@X81Eq31Tz+vxbr3{zyNp zZik_tH68-j(5vq-hRzmY8@jX($I$J@vRK_*6<^*k73Ma%Cv6!VRkDF5Y zOYki-xpDdC+kEu5Whvu?vmZD(z1S03S^=^R2vWFoo1v1(J9VhnI=3aiL4FC$S%jz} zqg2wz`yl56z(PB1IqVSf7$kY_#w7^84@9C{Kh?ohA0etJLh5I356h}-O4F^M37~T7 zhd^xo)B#Iu{j}CF>W6#avQ_WrfqoM_ZzD)v={G}OU!hd=WOJI!ywx?x-M}0|h$=El zULQULIo|@jh#+$0$u-DUSbD8cWbB7GvzD2uyBWS=7e2&<;h`4Pw|BSsAk!{=<Np(RCt1GNtgg)iBi}unfa}qEVO!`$n+f4clY@u5Cn!H(qV_~{aS`r=H zSzzyN*lRip{6KcP+{op)+#H9!nSz&6M5APl%gu&ums_gslFL#QNV5ovudOD1WLFXA z-(%YbePpn)Ul2LqYoGOAfljX)Nb4a)6&WckTO}NYocj>j$&tgEdY<+~p6~Ek-$MoZ zyOF?5Mu;kkpv15$Gsd#MD$w732E1cl1WbkK4u0+Eyymq}!!R#yGmNO^FXJ`kcTzR3 zdHn++{=K$&*+&q=>NuFI8*0}e?gOPs|3^i@q^}J^(t|-Ty|DTLHJV{0xCZeun6yD~ zwxA8-$JsFkA#(^CM9NCoieYyR;vcfpAjsuRNSs%mjzJI|YY+mv24T{{j!6h)i3i0K z_WyDA9pF_JQMWU<=R!zA0)#*yv`7y{I?{WGgc1pz&=HU#O{x?@ib@d(NN;K=(xfOv zI-($gprE1@X`&!SQF&|cnKS1mf%pIK<@?S(Gqcv-)BBuBTdYtyvYn8k5FXW7G+LD| zBe%$>5UGI_te&81Uz{nf4I$JT57xZ!OKKIn#2g_8Xm+e&4+m#_I(CXoM6BamE4@t& zb30g^Xte5}KSe3ROAxf;k|M`KYN?hwWuyvxfqj>4-v~ix;hw*I)I%>H(b5I2ox7fu?2YwDC4_iu@Zb=A1@~ZkNjMiLQn{HzipDOQmXLQ7WmC zO_6(%R9J&#ubLSTYo4TL6N^2x^~{SsWH5_8YC~Gj@FTv|9|7soWbBQg{vOmf)9T45 z`jaUuEcKsYJuLHD61fH}-+d{S!?V_sQe@H1LLAoVZ|8OJmw|cx+;yvMdfm$8wdG*) z+H&B$-trR4?ct0)QYrXV4UfueeGUh4PsD(7xE>7InKKehlR0Dw%p5faMdr{LG)4A7 z+-7V4>?UI`gt+w6_=%g0Rqq8f8ERBTO~yQkpVQ)YlTqp`-DHrIS;pZe!~VWCDwiZU zu*pz%yUEc0tdXRUn+#gNK|A+@5T|uRRafOWvV0=>`n)e(mpBPV4bf-ZQk+xS9{7dp zdifhxA|kG;bg-kd4b0P)a+=+%Y@js?1WFyD$aO$X`)O6A&LMn1S@_8aSP%*{GUM`y06I=`<`PyI=Ynx)NdV55kW~lb`cE z#NXUC5+gT}Zi-C-dG!Ui=%s_X#sqUSWdFgFJ|yI7O|dCdm_nz@GHgK8`w|;!aR7dV zIaS8vmm84Xa<}%vYFiJ=j!f^scPV|ggw7?MM={EBO{IG_6O_uQ^~kDhDf?U!IdV}T zM>J26%&jGd8_Btr&1I-y`P?r7$+Dl(&Oh|GKoQyv|OG%bfv?L7vI{0~BmZ}Ll z1#5IMoMzVnwzG6HWWU0bK1<2fnxIptI7^*y#F`Y=&)A@{bSuoMG8Vr&OYdnf>?|$K zbY$s98T2_K{{!qd@TmTrX5JX>Qy8j^!W~UVRQqO+_Jhyhb|XBgk_0Jx*UMwj(?+*# zg-qgC0;>}qRg2OuDGt1p#_h=(`86Bpj8D%7A8hD=az2|1lpgcj1**_D zxk|O&-gE_7WZy3z|G479{)a4u>dsG-H}}1JWN)sw6=biv+A! zg=+upSj+^z1&@kF`emwteaP##yRMO)*g$ETm!^07A#ehZ3Jp!~5E{}lwI22z^nk%m z)4M?a!jmdVP=)3q^pt6<1_pL$a-YTj%fX{ULy7~^^!L*`G*{U`UC^E$LL`2nVsEbm z4}b>U2gW+cLSBZ{Mgnh=zbE4`)OaOfw>EEs^uFOcj4lyiK z)T%4cRUuM`=*1tm<2*ge=T;F%|NYON)zznaSF1#8QS1#8;JiyELx zVWZ{pX(d=ks@voSAvUMZA~r{$`D;9?7|;w1VJGjVee4p$GF7dIK*YBcb`qonUN7fj zCO08d)rtYD0UlKh(r>~HTuok6pp27?FUWQZY~=OjisN79jNEJWl-KQ3*#T zQw-d|MTkH@^pPaJ>u$S5wqI2%Wk;RE8R`i;tHl}+=5ru;ZmAHsaexB1nakUifeTq zGNr%;1d9f40duXWfVtL2NcGS@3^6{WKOzTtwn9f7v9@4#xmqA1AX*)o&pEgGZHSGO@_p z5Lqv`qaFN5w}W=6D)1e?^T3m-9i&pFn!kWjl_GBC zF0WQGQ}%#jW;vK*_Lj7Z*0?3X#w*>V z(rUc))X{3Zl+`p|Y9g7b@xpfz7go^xqsYe?L+IwxPR(8LkteORH%X&9x`vJ%IZ??G z-Ji#~(B~^EVp=2TtSY1eKqrZ+@C|s4Y={HwS6JfWNyV8U}w?{9wReKFcOp zk{!pE3UNq&`4@zGIr=Ok%RLW}-i|}d$&$?tOCLuYNKKNy{3M)i!nY4$n6=p@`si2= zCj$Ot%0_Ur{P^6!6Ku`=C?fPPEK=non0TJ>4?E3;lLV3e=@UocDlDlo7dv5H1DE<@ zN_0?`V28Ei56a4H+6+^DHsK#ypordVA;gs)s*z}{0*DZnKZ0-~{eDnMoQrC2oT6F9qBGduHZ`6f*NRG+3Fbrg}5r@=Zs#_~C{c z6xf;h8br?H;bNP)Bob`R`6wbPGY`VVnR$$zC^Nrglg`YokV=(T*oiZ<7H8&TcA(63 zgFsE)L7AORl$o34YZx=9>1rHdGT|{8p37Edl8I~61PrrN?RVp}o5gfX&<`bgUE2@ZIG*RvQGot#uQ-=jIE*o18 zra!YB)c4b`h=@Xt1LbL@6W@d3|2KS%V{XaHOFISLgqI8PsM%faNmW8;T^7k@sg|M;1VGGQX-|uEZc-Q zt(jQV=RcW}^%_D#$8)|w0jDuVH<70&Ir7@$SBTI?S!V^p5(BpicvM)F$=*Ic3gQ+S z27GL1x5#!|HEY$3H=Tj>!ILUU4+UtwoCLK^G_#0dP6xgKkIG~6huHWy?i~bT4Xk_d zs6fz%vmbJhBZrc!mG&gw7ylt?uvQ*xlwSq%7*DDsO`PPL*w7Vs8l6Fs`xi-v|GE_U z@hDG}$&P7djwvY_xE9%~y|9zM5hUB-!R!~m6!y<#Rg91P52T|fTt?whnw81cJd8Dy z?019RVrwSND}j872Zw<0t5T)m`$(1Ju-?JL=XA*uIJhG~59!Hyou8*ll^vF3>3^0gNzF|66NWw*M^;kr9TcbR=3)+xrxMF={TOPu9E zULVlD{A7GN$G)IPc~%$JGUM#na`?aWC?hITkMc-+^osV#^eAiKpOtIN5H{~O8FQ_| zEuCxB^mDROqi>Q`cL*j~mEBHOJ&!~4^ee_pj(X765|66iWD+3@QNuoxWQFs#fQ}MCl0YT0FM0fX4qLNis!CxJ6_pjmLp}g9l%N;aBBH{^ddx z(o75@`48uYZ<`7IO-UAzX@bvZIl>{roxpCyV55{MH;y9UG{U38M2)j*fAhRZuG{7B zPjG#}i$6e8gizn{k<1DAllWk*MJCUO0GWj+RgzZtoGRnk&=ogfvVoRSyF=GVEn6CD z=})G72VAd2xEy5B0p~+7PpIt(IAf(EfCNc8guw6MJK&Cy>|hpvT8AN4WwU zy3)LA4hArr39|f#JCX6EN)jYJ2wn10G)rfY~fNxdJGlGuBDT;g}Fw45mfuDjUw z!;>mW3zVkHuh~Fft`$SED)@WGo~#n+_3@~lj5;L>ONxBB64NQou3|jc049IVLBmJx z)<(fab*H*KhdGD@C1mG&0%=hOrBB}zn93-YMni5PiMa1hk)>DRXly3ma{Zpsx9j8^ z^^I2T33CwX`M%|4)c8iCDe@aMrH6D=YA>O+2bJeH)YX}#Q#~7o)FVj!sHLEg|76O3 zNSUQm$sH*5n;ARMZPxic-4t7Pt1q(bw6a@iJHAiRiD3utp%pyp8cpz2KS_&xFGK1J zEoBF<%O9D7M_p;g4tSg1Y`3~f%WenH?tmA=qo2>Jj>rz)e0apEM_r5wp6YKXc>5sr zkCw87_h07VQJ0jlBip9W9oxZE9hV(Et0P-4CtkuGuYagwZm-JbyN7>&ghv%~>e*0c zXu3eFvRkO{qunoSXK}q;4=ug4mO>`8dqTsEXK5KMau3{VX;JEEe{wNKuU*n&q@ zXc~?mkOT6e&0QkN*&6hd-Vg9Upl4`b?Lq%{Km(%!Pm`N#LkW2 z`?wYukBTm}NDu?N0Gg}gn%&$)D;~^oc+%Hwa#b~3X`y~XANN3XUsJVOe=tYV7elom_!D_gWrFR`9$cjZhUesV_D4gr&-nb(XPM$q6C)O zpOM=fTrRh2w5zYkR;ygp4$|eqXS5IYg3Vz_{V!_$v<$W0vRmcWvS(hfNs;we3z4jo z(9YO<0a3H-epdu?d?s$u2RdqMq^+Z-Dl$cFGNcx1DLZN_AeA9%&uTHIWoR)hyB#&% zVq{v2N|DZ%!!lmSg%F>Xtx`mBanmi2LX06I3Mb$QN7o#O_cSO0-|;eQuDMA zcGSi~Dnrzs)!IzU(ArpbJ8HVM$rQCs@&wwA<2p?vOa)7U#~bme0!}8Xjv;H%0dA57 zQG#SssvyJ-CJO+)7z!jS%^D!M8oA z4wAL>XBYQsYlY~j)!VbHmEiIUc(cIS)tj&c&aRZ*N~Ph}lrYomYLgtc05?hMDBF=p zgDs8k{oN5YF#S}ET_B>v5mO7gKC3A!u5{ofC&avT{O|EUKOJ z!ELM6+mR^wmyU#e?i2Iew@?cLBcbeeBushD5Q)RGTP|EAa6~0l4O5)@!k4A;Mg#o+ z&Vu|e935{DSSlZN4zSbM{2eR{IYxpz3yoT2kZQ3YCPEjWDlNH zNh&Cn6#KQ$U1G0h#~SvJ;M_>Z#x<+(|7XptX_!HOV-So-<$xN|(hZ8=fnD%V71cS0 zT?x!y>DV;krWtrQ;g8~-LC4!IKb9Y$u>14y<{&M1)hU0%kv}h3C1^db!p3Cv>cTOkPvjH_Ly9AK;VDI7JgAJ937LfI6xfa zj4}3RY`=5t6_!3G+q1o>!TYkkn6@96uS5&6f+n!XaG09I!ZQKqo$rXa@6m^akV||Be4rwujrfW$Y)seLDW6 zJl{@;yZ7)FzvH;fy%gI-2!~I+{yDyp5}(DvEGtNu6W(!)y#q018YIl$$lA!Pp~HHL z7evoa*fyy-02AQv7GPrN%DMpyh2Dm3a|_`<<-&(D-hOXF&htSv{CY!k;H%?7v} ziYyL%`R;8~i>TQal?SB@&N>PiLa2A=1N^+o?SMC~A;6*J>mr;;= z$M!YJe2L6SNn{T56Q@^2iOV|5=Y(608rI2pf>IEM=3RMZHvVxikQdXV;Tt1?ZWuNk`9DO6ra)U0Lj~#1 zdMHl)cdrUk9{?kb_*WEZ<-_(U(6(HwEyPT~Z(9_Ry*@VPyt`5`iCYcFO%|ZVhW3Wo zm*vi4s~X7H=}`aFp-6=6pQ1>5uYZDEybAciGbrKZ9H86`D}W?Jh_X5%g@+SBDDbzq zaY##m#Q?++$gvCg8$Lu7>4P9TaE4a6JS6faEL7?x?wC49-F2)Xh0@AMmEKelau=2FD;r z_~}O|yd@@l_&CtuR0;g_qwxeeHdTnZ2IoN1kH$O5-6*n~4Ng&0NtLT#QG~yfoDXf^ z4MsCd91b4+h#YUE0PY8$aM3BC-|(n%eVOV@4!Ul`J5bg>f!5QF<`j=z?Cq>mX_aF+ z)q){%FJ`7?z^s*-Eh1Nz0%wdIfaXQE1p&uAbV16^&{Wx@03hsGi7^(Wnmi>sTaGFS zd@ish2Is&ke6g&J6qlQU9ZH7>#9A>o%7wMT{0^)?pTi9Fc&`lk81x_yng={8891Ri zIk{C%_~%i{PslN6`4qY;KY%t-{^({Q*>Doz#0yuw&$ zAw91HpKdr@uN0@LWBx47Spob*!{OvnoOX_{QAJtLA>gMBhmuG{y^C(d+rzP{q7YOe zEslo!JA9+@g)YH9A8vxiqnfuo$*=T8hv{&3$G;LF_ys_v2&V2zD0qycByyUi z8vtr%q@(_hL+yIQv9}2RRUAnt1L|+26+Fu^1^sRvg5Ll%!F|K^UaqQSpxYi$ea1 z<7g2bwETdI*l;%rTAJf^3^O?7H2~GK;bB?a!h6E;(W|QYmYo3gu;KR9zn^x*G}rK0 zK$C3v+WSy`&e8Rn>P_SlKr0L!Isaq8R~*q)NO!>bFhM+eFttl4(jShT$3glYglp+Y zBJ#g*D0$>)gyD>Q0!;d?JdG;c1d!i3=8E<{3Q!Ee+~Gw&xQW0QbUy6|p$c%WMUe4c zL>6od@uJSt{h_%nu#OfkqW(jSyk(p{PpaNZ4g)lrVAdS0eOc0J ziAt-5z|L^i{Y?8*0Qd_QM=1Cm=XDew4s0zz4G30oxm+94i=8LdYUwV3l5J^*S33U~ zsHMjNdc&4>p&|Bu;UZnDd!)Xlc#43jBA& zQSA(KzHru^p*cZWF`&VtQdG4eaj5LxbI$0&x-BXNyt3h_c8@vNoq3LEJ*|QFO2-N4 zprV+4-+3CVG2C*E2Xl^Ln_fpKqHs<9NfXzD^l>_(=7hN-Cg|XO0sNxj*tJ3_%j5bd zn^yJ!B!PA!Ag+-YDd#G>CTu~u$N?ty_h)DRiLgWo(Jid zbVRKz#nmKQbN&II6=`BuA~kYWzV33Z9jl2&Kq_O1s%$Jmq41t`)p(-&m&U+58xE?6 z9*%M9MKU{&`^-wT4nx73Y?#!&_ybhNxz}yd`I!RJhla?hqSBeQHE>_UXi)WkApMw` z7+COFq?5b5T zG?B8iZu(Eb+?U@6?hLh}&b~4+aswu%-mC5dFCmj6LC9y3(1Z_yjwkN-Z|Znf0@Tcc z?R3^{6tlxT|GG6h8O%4H!?uOBFU38#PH4HMklFbRxqzHvuj+b66xAZ9K)?DN5$!=o zPxMTkuK$4HaDAsAE#mRwFoa6lw?JR}3=wWj=tqm>_r8h2 z2It0SpnqdT3{f>G5ndWHmGl0crr5VZ^n_axw=>#KtB5C5&MSJSol>#L2X^IWNZ8pI zQIh(|s^0Q(N}?6mU5$jzi`vx;yr$m6m-X;!6iBm)NCO8oJ2xQ`kvsMxOPSdsiit&iyD^Ml;zN);Ij#5y z1auCT+q{*0YtSk%F+WIgh8Pe~CN}boZJ{+b0;!WBW(+8^+xkvmMUK^u0CQ?)wuoY4 zA79H-R{TNQWQYL)t$`-QJHq$LhuZ(6Ae}eFfPgY_n(xR@n)nAu9t_Z)o%PI~@4Nn) zX6FYpE;Cz1F>$T0%sCyV$3R+n^9B7m3q8+Z5bJ`}!VoD&B8oXhgWmW+b9w_GYdA)k?lqZRC+JPIN33x^ znA@Ji4s3c@E+MEr7SdVnBxKGTIZ84ek^w>VpF)`P2XGH|DOCLJkOZ)&1wH*uha^9k zRi49E$-)0wosu#7U(Da@RDgj#6X1Q15K2f_y&@igt&zdy?5&a2Q0a-R4peWAkb|`~ z^7mf1c$fT)o{BUl#9!lez}D7C&)!IM+8X%^klq?81ghQ|Ay;c_WHeFr*2s0Z%Me2K z)<`cR>a7uS_JwZ7ueCK&r4O{Itr0&q4Xv$_DWp+vjm%}U+8PcwBW^*d zbq44KVpM^=wKX#LwgP_#@X!*swnla?aEmH%49){S9wn)_MiMW&MJyc462L)XPxaQw z&8@hJ1W3#DsNNcBklVux^u2%%AchK(+8U`_*~8(T4B%ZOUXvoNd{A2>g|@rJTEHJ# z6l-f_1J;p0gX3`v&|+$9WZ^NlxCG=*I@F(K7}7*IUYM^ilVnhE^Kp) z`Uuerpp>#`*4D_@6>iZKU_Ag$2;|s>=gmT#4NjH7Pd^$@ zkTW3vfx$VD^rP_(^4bVYzW1m@UBSoSw-|xAOgz9E~C+hk`KOkW9G=RCiI{EsSt31#7)w zwx{e-njXm>qoHXZu#*Pwf+jUk$rE|~8<2hm;hrH;vIUZ!$~CJ&^2XrCc08&XAfGfz zZ;gac0jVSil`K;Ftr71sx99{Z*$Q|^i{s}^vbIL1K?ie&0UvKTTxPAUk>)WT#d#0- zD#PJ=Wo?Z_y{`4_1%AYEIC-qC5zlPR`3d+f!=WTHTO;3Khm0zubQM5!@o?nL)=2Be zZb9`?76Md^U~b;5t&z@=9wl7|P$MI4ZH;uerlq?9>TRU0t&y4KJfbftp8#m8k+!x* zdY?q_34R~Y8e3X#jnr7~R??pWI%rGlt&weL7+CrepkHihy)|-lw+`ArfE)#_h(+nG zk*DahINo^x6|iBwHF6uRCM&NBsFn@ut&xZ5b{I|s)WwGN)=0zORr4)J0vcz-dTXS~ z#~NM;XsHeBt&!hR%Ba4`9f0;4*xDLdN5%a#oG%k(x@y&-Sz99)?}PLZ1X(DMWVS}u zoB*B^SY8Vk*4D_1U$yrY097NHON6yGGBqozY%4f-v?Nu3Vr`9l8UlPUun`uH^^9v6 zf|YUhLLH=yd^rcue1ciCwKekhA-5<+#UT~YCl;)0S_te6XFiNinNuBj9gAbOMuwi&f$a#W z8^J0rdTV3^dL@<~4QPTbt+z({k&mT%*CVPsoEL6H8SE8t*0>XIKxqGh~65hFjaFJ0gpEv)$Zx7 zkri)h&H&&O({b!>NAG4}Yh;aPF9vg?VVhpZY>jlWqWL*UU#26Pt&w%pw6g2K9~qA6 zb2KrJ>&O;O42{M1E*_O099L^=B)T-pZy8|K46f3P_a5rI`u?MJBmnPXI4Uie)7CXM zRdYrHpKLg)?PgAY*OgnElLCB;;gFud^kViH*Kmy8Ik%64`JG`0q!$xsy8go$frPY>m88OBah=FJR1z$1eV=6|uHPTFunTYJt?$5LMaWW&V?{0vPXb|I!oqD8u1_ zo}B~M*2oJ-(eBI!Ynfs4kTF1IoO?8y5RSu6kd7E4Yg6gWem8LUw$kt?kp9k03`|HC z>EvD)t#yZEExjn7fVc;wCbI{-BUb4Is10W8%xtqYvL?4y+YhAi>4|nKsEw4x?jq{F_{~*a&<4uqr7$RvjTO+j#Xim0b z*!94pqRzfD(b^i>5QZvH9)v0uNiRu1apy#{$63<`P;U#i(^#)h>pRBo;z1H z`+G1SJcFGv23I}P7Hg4gB~bM7WXOLtL*&VqwKY=qi5961ddFvoa5Msv_KD}hBP}uv z^x4l4;rdQLIxZe>-aI<7)`5QD86w=6(2o|$?@hL%{~hRejff%oxk0hEM!JS754)F@R!iSZ|GVKqt*XtqCZ>g6(-R*Id2hG0S@d8==e|2NVGuv#997KI)wPD!ED}YDEKOmsIHBre|!l5-*1*wT4 z1_YFejeK47N|o#Z(nv$h7*J-n^-V{Ars5Cgip*@YHBxt+Chi95xFH4vRBw$`eOnWM z0qMRW1_V@ZjeLl48+)C#45E(b*;%i*M#9Hxc2zK&WM-SKktx&}WDiUN34{Oyngu%`v}Eu=M8 z1vB9}Y!wLJ8ln8=t&tp+^wtRPdxTIzhOI}7l)Xt!1SVuSRD~5p<<8!MppYrBi+nl0 zdl4^pybJr_;q`xqTmELjP7&TP%Mj412!=PJiE}uW-S8$s?XVpN(m6aA@dSke6ER&9 z2J`f~K$k8f*Z}=Y0lV`ZL~e%HZ&d!ddOH-rzxir%YZ^{Ufm9mLi+F-^K3gv?8h8M` z1t)fdUU#!Xu}k55nZgmZ-W!Sucf`zCe$D!rU$c+#YtB`E&CQO4Dje~4DSo{Z&#!l1 z;n%zw{F=X(Ukmo~YvECTz4sfx7KINd@x?FlYe^S=rHtm+vbp?PzJ*^aPV#Hzul!n_ zZ3M}!E6uNs@%;L5D8Eu?^K0`4er@@RUt4eR>tp9@B)2V^U)wA3Ye#E-?F<`9*sd4& z^+^MM?M~*`o;UclcN4$%9p~3)xA=9yGm7NWV)^xX1AZOs#jitC_;q**zmDwT*U|6! zb?gbhj^`Oo;wQ@S>x;(xI@z0FUry!MSF8DT>T|q`MEK-&eg{d%7_$3iL4HR{3Qv)U zJdzTpNJKtK$xZ6U#cH`1Sk685E;3!-@K-{~Y;X?dTeK}07Pk||+f;dD zX(lS~-ED%eA}XNGr~}{pjqoEvTEPB7@(`>{m0YP#$u1`bfr|0MfMG)Z{ZRWpQ%&#^UIV?JL74y9MzdTZo?%n}et_c8I)> z5#_7ku%>)z5V>Ee}Z2PUuH_9WPUXs%&#V6_|?q8ujax0Y7xn=mWBA$dL6&oyp5ML z{usVGt~jI`+JUw(`f@ex53_d^N`9{9xltTNDRR%%()S6LfvaHZgC}S|ME#6rzwjc^ z)+NKGcmhOL)u_l`qB*jlO(7(01RSFb5Z+@0BobyXz&~t({;~in5qKCnMQQfzW%`#P zvMF3!8!?3>U04lIlHoeoLi}IYf?c|=1pEe|IR+ky_-MU7@}LQjs{o}M_*;^WyBLeW z4xYXTafDqS27KC3*aJlwwg#W5GUW!~KMjSol%8E0F&pDu0}Vd-8jgpPO6_fxrbBqS z#vKa=`~skI7VIa5qD-j>gkeVKe^iq!n*eS_6i%43*Ajrf`}Zj{LlnZE1`#1!k?^8$ zuB!A7>yFkZ$I-9BDYqA?7%~~ef_ZR8PCD9zg(lzw+e4Sp6ouujiGfIa8eOQJ+4&n6M20L}yek z+7IzU9}B7Iix4`);_8LU3eP5xXTB~0o?XigpeCH_lU(Hh&(2{hLMFnsr-i7^MD5ux zKcZ0`WmmKYq=b!mqh&`1Q^qe$BteulFAFYq4u0i7&~?uat`X zTH2Oh%ZBl5`3!!o*vPN{n#0>7xt;R6uJm@vLvSvV+arJCw^x>*M0THi!1f>+!FIoF zj(6dx?sd?#6^`m5C(|oAE5CXb=2!13{OZ$^UwxDL)o(Pv`p@OpfGzwQc$!~BZu9Ha zus2BAu(JFb-kM({UgOuuS^OHcieF@+PfS8N%CcKFtBF364i9D7C#e*bppkl(&m;|qO3(-1S<>XO5irx?p)7|a z9lk0tCNDTA@PD|=La;?Mh$}Be}j<1V;HL(AM$3F+Y`DeqV;m7h{e9=Yl zrF5`=5^-`~_dtcqkv2?sX(!o-l}iHz1kGG`}i~SJe8QAJq?F?^VH}$6Wt)NFYpB2 zr_@*qlb`6KG*jy2ra|FPaJXi1L>z6y=4rU@K0ZQ*qx=s)E(9p(FN$m&eKVM+>G(S6 zdkM`8q@Y17&^Lj3T3$pNFR_}F-q3}2jkN+t}eIZPyAdH!-;A`n%|4iao1)&p8gLx1%B~Hq; z4qXu5`p7LvX$*1PG;I&*2&+{PvSaU`>@^K+6$FYS7X&gO_m{XuxqClg)RMH>O}XC? zX{&ReqH5)Se<*rZ?oWohmHW)sx&MLih~2=B;|c14@cEa(ejEr;P+y9n&iw~i3nyhV3P_AWb?&eESEH4I)G#RJK4qy0q1EN$cQ3F<$W7f0uvs?)S?a-E=Y9mn75`I?uc_z}L*UsqJpLF6_}_%dXLaO+#s7E0|DlrCX!`S!d8r3!y%o27c~kPqFDs zDflVSV}`-=q1pI|1atnK*s1We3~hjOzMOg9W%!oN(}o;` zciX>kjwiFvJF+dz31kkPF@j(aS?|B8)vN&L+% zz65f?pu-rghMvNc9C5=fZUcE_(9wie$p!Qjg=%&QT!e4N81PDP1BGl%4OOIyr9xe`GkE2D~&%MVLD+E~z1P zkg={mF@}%yoJ(kffuH9bg$yt995Vav{Wte1G=ry6{l3K$w2U$#HzPh7j6s2<3)>%AkbgB7lP$0-QV#hsx^)@W z7>nR|Sl+(|uwq8CrULTDiy&15p=o;3MyS&|>qAJSv@C+{*Fg`))Cd;K_jAw590~rzg?z zF}fg@UI}QuEzNLu#|Ia+^Z`IeY-u{<=^5a71Lu}GXg>kEX2W#G(=*)hV}6f(0ywWAh|-%Yp}N|_v)%DMx;eQ6*x_`zUlj|w-@O)D$^ZR#9JU$lQSP8@M!Ge-TuB2%R1; z57!!m*n#6in4T=oN*IWBqNukA-u+peDCc=>$@L}97~oThLuF1!GFw%IKgRh|xJNja z09%_Lr&F4qiq6QKID9s_q)k0k3olh{%V>Rv; zn0??;#aqE0ofk0NWEF)06(^W0M--jZ^z?Av+Na}M7f@qcn&JM=f;gYS(%k{|v8Cz! zg=e(0IF13)fKg5aG|iS~c#^ZxIt;)FUJhujk>;a_p0}ObHlYygf%9QYQs@6g3fn5@ zr#NOPzXx{B;76fN@HsBecIODp#^e)VvZWR4I6BxC)c<%n-C*PfQp`gARF{+&d{WKx z&^ZUEp15tO15%sxMD|M&y{=6dpfIsNNMq6yRa-?qd-Aw)Vi?B6c_3{_PqbS;{+!=4 z+LeaWh0IO^^JF@FHA@AGcQLY1ksb~{_U|_ zd;olp;cy4PoR*su=M(picW{mY_>bv1v=%2ym&Dy(K^^}@w}5qJ^mTZ6a!M98IaS%t z^U}z(*WDs$q3rVmB3KrT>K2_Wndl*ux@IKFpFi?QvfPcIvHanW^N5fTFv@k<=@wPH zv@0j_*36f;W*?}kc6TdQ#%OOex=OBi_;V4n4q5##Twds?z5)G(tNIC~rLX$Z8<-ze zuZWL+W2$d~5H)qWrJ?M5#+}SCrt;D{k3gDnV z6u<`qK&?ImD_xH2J5gR-)z?A4ull^g6u`7A@Tx{g9Q2XGuER0f!lj!vk55BjmBOzl zK!{_!=p$0NFb{mM-fJ$YjcH8r9`zp>H6~uwO8$z~q1scygsR3MP&QDq9k@VBI$Qv` zdZSk<@us2TI%@QYQjrq1_QO=Coe;H4W8YauCpskk8^Ag(PeZz!W8XNK>pq6LyMyXP zB(b79IV3)8meC*LgSy1TLo*>E(#L$w)z_8 zKv}^xM;u@g+Atb<8a-57V;aVz>_oq&t+nb8L>Y=6t*o2tA4ge=eqGs`H1wlPMNd#R zm#miu+iB6WB^4c6zb`U5`W-n0Gk&B>JG|-_LXJnzS5A)lW0CXGiwL~`PHh8dz-YoYhP0R6W&}~?8|r7fa(aIeSNLWCpU zDCFR?kGvG-{|@Q#Hqp zGz-PUQS`5a&mxLG0t(IMa^XBYhqM^*7l}h5)tp|WCx`14l9Gel9C(Kedj6!~=61b~ zWdqhT1o+qtdgunc&=^;{**Z<<17DtAk6o;azgU|}WNqI;FjR@G==auz%L>@?(2$=zlT`&DLpk2g{#AwJrdf`*Is1Yb&^F%K1bo@8R zVzS&;Hz(O7;yKZ$P|_G5^7h4IDUFP5No8Vhn#NtjvgP;F(ECl>jA9QJ93(o3!3gpZq!B_>i)4JvE_9xcY6#BP*7X=fdeNKA(kUo^e`0g|SFM+~aTKKq$LP~|8f z;6or3TFtetnwpL8ASo-7{?P464EhmG`(f+H*KELLOhr*G&!_YLATeUUy^YLkavfhS z_&agX%i23LPrV5vDY&Xo_}`cQc;2eD`Q-Td|4s5UKY0!H`PygUxi zHQ9-wS3-UK#=|vaRy7=s|Dz86V|tUH;}I5TZ{$^uOEhjP#8;>PkT1s%gTO5G08Rx8 z7mj$W4kSu_u+YH=3kwIAq}fp6;8N6KxtbtaGPtUI^$`9A#7UFlj zPVh1kY!^rIt^ugA1?!c;MI0?W1rPaP z0{-(Jd3PV2zlcX6QiWOVT+>+^S9dz^5?r-=*Jma#4JEAP|!KPQM% z4#NJ*Fj>hvu)If6N3`g;z4Y4;^7ebBS1-)ydAKOEsF!MYB(gu zL@Rl(W4(t2WgBoh5RXEnl2>gF)9E4iku{(cth51y{N*c4QLySNH2wLDVU%C68XG^u zsIXv7I^UhY<7qm8K(2ZJgpvFI!nx1UF`L4f2B5+ez2DqjQ|zuLf82hF4Tn%m*7Q*NbsVw zBA)vAL7!O$)wFkKn0b6!s1KbU38Q*esP70e($++wesp?-``1DPmrQ|?{)a%JS609n zlD`|;tJT>dF!RU){Pz;n2I&XJT)q%Dekp~_uY@4Lfip^nNd>_*nCZECPPobq%dur>{;jk`$<3D9}UtNy6 zUub;|9U`eD&{UoK2?Lr**CKOLyy={F7@jXTtc^rC|cSV%tOuxj;m|X>=JwiKNoD6$CQ6LM$Z=F9q{EnK#vJ#&()Aq zIE&B1*9LHvVLedV@Gu-W+5x zyBYNG(6xZ`%TZd74;dSdConub6DZ=G06mluvLx_w7Dx4oR0i_i*dcgVTr}?9UKNu8 zz3gJb!#7h*?r_P_#l#7^p2hs&cpO+vUM+}Xk^;Y0l7BtmyD27<>qBTKoYO4G-GNuX13k7JQi-P=12hbE}wCnuUL3 zNz#=8)wSUC#U%e;sZ=BZ?{0BSG3mBjs~7`lss*PnCOvBDIJ^&hBXKAW{;m{cH8aWK z%zZ|C^EvP@jUL6(#pM1LtT9kpAXF;ar#KSSxe(7Rz`bVuN4tQ1K z1cXNylNB}a-^3~9;(;ex992xH4A{lQJ-Huf1$(A~ls{`_wDG;|mcJjj{NE$21^ct> zKUi!nIKXrQ|8lEc)`jv>u;=gpKN=pghOG5jL%H7nA7Qx58kVm?uUM!{hd$g_q#?`D zWn5D)I$Y*y0khR}^oCjY97D;ddXDjAR6WN+GE%)LG%(9l7*)>^24hGf!l-+Wzp!yi zN6S8elR8wZdya6-sLzmNE=cf?)pK-Qs8+jm&+$IaXK>%3dXCCCNyApvb9Abp2EDCR z&+!ZPdl^+dM}tMm>dtq8qQ1TbqON-mItr)e1vHzqkH9tVJ{BW%^c-{%oYiyif{bYr zb_6yFU$8~@90vlMgvmHuB{#vx?RbKYP@T4VjlS0g(I+ zKYtSEJj1$4X#5SfI|&Z%i$)NShINyWr>;l*Kn1%bpmGGW=T?*O`4qRHG9a4*YG=Xe zn}m0lxs{4Rz=vBL()hcEKT4cfLn}oU80pK`n1-_3s6bJuM_-vYl-B|A7ke&m6 z+2~Om-6S-BSNruha5pj~P>*gB8lBL3@&PYK9E!2_OE(GICuu!(fH%*eM>h$Du!ck# zA$tKIU~yEFKxKfN1UgS98qY_;qhhia>+4oA;e`oPOwMAt!wfKPu|*e?pU7ejFdEbH z$2s_Qk^I{T-%T+ooE0VL4>Y$NzZ zKviv67n8nQuzEw0jR%xSFnewllPrMwGQ?K_y>7wji%FHQw2B45Q!I`tCe2XCS;clh z`z<(qF&U4AH;%&v;8%!4aqurjxJ@z1jdKee(tm;bkl-9r&C$iA)Di7h0pKNx6QD;I zlgU^cV?FhOx5}VL7n3``Ydw8|56hrO7ZX2P8OjJb3;4ShM->w)19mZS&)EoC!Aie^ zq^A#K(BA3k0~?<|eW1@MgnJd%eb8#t`AIa_bfOfm^Xl~&FHbZ4Sgm$4%(~U4Bcr-~ zF1Y|k)jpSlF(d@Kbo+ch#my@`iEvUUEp_|+6iw$)a;yOfwX&i|_CwCM5+rLC%czKlB(7**|aq}7HfRuaZyv$@49`1B7?P%F4= zp!MxhZqXZ#uUde=9iz*x(mFyx9EX?!WUhs(d2YB`M)2)%ix42|@N6YU5=8w)U=oVa z={+3!ih`Z~Ro^#;QHB|6mOHo zjx)Ri($YXt6$V~IvokJ)%56ET(88i{ zclWY}s<3DcsrH1NjnCJ>vqX0g{|UE0uqdInw*>1i1fA<{0mRui*ZK%tgKb?u7Xt zGMDid#WXVZUouzr4t2u)KQh-!xQ-cWtl&>;8YR@b1dC)#tAsbO3>oWSONWGqm4LY9 zSCfS3n(zb#Al4(#!qO+9dJ|ZDl0rK;p(BMnD_e#ooOuf}+2p!$xXdEqdq0ruawljL z5@K+sEH+$z0n4O>S=h9Ujga3%+vJ3E-@t;esbQI(&F1phTpQxF7L%tWTpW5yno{Qab*q_ zZGHSfaMANr2uip@@n1-jC5gB56^qZ>R*Df2$?7WBt`pwD=eJ2MZB#fcK=IfjxOmJND~buI@WER>A>X2BRj^6@^Z zlOZINI2oI~#d`8b$aIx}8VDrb#hO&H+m2Yc{7A0!12HO#i4i@41vzQ#MUT2$htygu zTB&R8a{q<`k~o-r{+kuir38Hcmf|HYE`>ORI!Tf`Xm#<8_NWCMLP$?ywPjGy!a*!l zK;?%HWT_=k(3T;(+kn-wmX}3h?L`n9#~59BkPiEuB6o+wM7JQQ;B?$q1={YjYvM&z zABzntJ-F%=pQQgrKV!68ANO#9(I8#R)1QGEft*27xqy%UCfY(GL{F;T6JK z{y7iA64sJvw6H1ALsFYKgc9=!2azsi2u#eE%R-BEQijn*4eFk=#9OD~+J#er?rl&Z zWVMvyNT#XL&^Vn5bfbgH0}Df&SS*rN(lrl$(yga4tF$dFnZ)vFd5XR4Bxr;YvXhA1 zklI;C;{PTL8z?FlpF&1&+vE5zJ<})*!u!^0Y`#nWgs3D;YZ_$CfO7Hh<=bnl5B zSCy)X`Zs9Xy>N2XTbRv`lXEOZ6T^z%e7_&&>%@Kg6UcoJ3gXm9M)Hh-JxGX z>9!VyQfNf3&!-_E5t3d6(=9Fm!ntbngK$krFM??=)t1(26-62FrKA-+y7WciDsR&W zx+ZB`i0*;0A)U8F--hpZLbqUqUBJ+`L}402g?Zt3i6S&G4m*R2ULuxiQ`r0WVJu4JF6=yU%WNj2hqz^F z7#6no3mD7O$RlhSaVt?73`=?dV{O*^aF`S&>agBH#I4JE`{stRKI`pB+-9uz0dbqN z-dBj*g7x+xZY$Osvm1n$S?^y+<`PM)p%t3R5}nxiHie-x8}k#lH|u>&+`g=#C2{+) zaV~NDvk}Emlz5HBijr|OyUvdWVJf@MBjYr3ZS4phjT~t03cZS5vv?ofrV#JzUyV|k ze!IMdMeDBY+*yOu;T-R~i;d%Moqg0zbmq}iypMK%JNsx$JzoFP_FQKlU9r&FM}-f$ zi{E%3ZDMxzb?-`M^-IgKoqcpag8M6MeRnNcfi5rbMxU0VWEE<`gm(lwqmot0?DKw) zVQ|S>WDfPtE049624s%(?!bz7$%bT(@#ZGkMr1DPeU)SzlevudTas-;=E~m7kHK$B z=33r*XaGt!BXc8f%m%nOr^vPP7AA8GGPm|_A=y@BZsV=L4CXduj`#Yaz)2u;f;SB* zR1XOI@-PncI0s$HUy2%s?xDKh~)!oaK1a15RxW@bFK8Uc>PlYH|l*{YX zO)yU8qR^=$jBl{ZO5kMxPYSbr*TaDaTgr#IcU<8Z$e;zxUp0} z9Y7bodiEV5;v$@ss#S#0_D9 zI`iaViY1_1=Xi7raeaBrw1yz+hwTwOdVS1z;<~Zup=aQ|YqmvL{&8F*jAE5B9)0dm zQWkMMCIZDlbj%hHml52#_I?o)$heU*=R}~?;)$eWOs?ZrQv#PEN1h>&33)>$H)$i` zJ1KH))8R^a(#bl2_fTs!>=|(4c8qu8zTjM^i$rwNb;t+T0h|bQuZS82QHQ1zX~aX| z$tn>H&K+dpElTygPAZ&qEF$2XLsAo}3rnedJ}_P-{Sybr)8t6!ChX|x;HRyHx^vXw z(RqqY@BoVZhct|$a~3u%l71$=o2ZlRogQfyS|+DlC&XKD_SUtv$xWhtOP$3$e}TKqPiP}!Q)tD)TQLWmmXc9;lUKvMjMgrE-uh4%yOMG> z6xp*3Zt*@^1>i|GtwHc4n_L&d!mf1H3cH4jFgH9c@(Km4ciw7P$*Jnh2h>kL5TTWx zq*b>;xkEnCbu0=>baVl^I%fyn&Z1rW^o45;c1<>}Nvm_imDhsk>K0Ay_8qi_b19&k zT(oOD7>nd%1s_HDtlDrEV~BK zAqS1_=zf@tRYl3S{~4s5EKj$`*z!7n@1QX+a)*OW*UGS~s^(m=5~tsXd?Aj&0E3eW z5qK4^5ROHUvS8hFPz{=8u`qUeS&q+^GFb=*JIZdG)MsyBtVh)t#BA;@E=8&tM zd!2oB(M)GwuA20lzZ?B_<6jz>#QT~ewp@Zgha8vS5V(Sj-?kX0b@pw8xwG$Y{*7~z zncTZFr?Y0#RW0$p#*kEC#mt2}rF}N+R-3CIRYg!77QOQt;h?tEPM- z2R?kGG@1Z>CUGcD{KJv5BI+Ybif*!DD()&mmdVw?H(DGK^#?v>bM==0hqLd1lcILR zPG)y+3&O%t4vuoiAsvn)NK-jLsvza4avr^SfJZNP2qz$*^d?e7iV7%A1O&UNpkl?Y z*bAa4B4WexJ>lX%|9;>8e%Va&Jnx$~nM{(&WHR+CnulHbSwL^Pa3mKhBG1s$ z7Sx+el(ztB0`@A>DNL;)#fsOL){sXeW;@%^HPN;UBFU&n=bOt##xDYU&BayjU_fQLhIk0#^ye<%+QZnKpV5kD z_~z4|84F|fF#0PdSpkvN;lfjB&n;pP!Krv}MmGa+tq0B)dkFgH`u>>?ydSUuF0OLV z0cy|lc#igrcLCQP#^!vF7CXat8|^8!C}t0%uSct7ruka zs}R|qlIv*CCb5U$ltlph0T}9mTg4uN{tmtsJTKFL&2({_f8hTB=1u{C#1zdX=o0EhtBf~eH_B=+f958uzOrw<(2_-1pR`(0&#k;3%K?$Hm3{PrwrdT+H*YyzwY(L z=v)4Q=xLCCrQ{p5=UuUf;7*>*FeFOB8So>qhoJvE=f_Wg*92D2#Z_)+KtJz6{IgJ~ zTf2a34`Xu{&Y(S$Y0t+Xxb`r5`dNrhN8~(8enERqi9H0r+y-zBfO|dgjMzia|FTo} zL*R#iJ>}vmcLAVubeK95ar(Fmxb`qMr^j~MGlBNpyfkJHqp#%kbr~X);KJu=&jqoE z-~pb@ngAMkpk@bKmZ1MZ=i1}II|A$K;&|O1&@G!0{{`(C>;kSmjLn(8k@k$GJ%5AX zmJg$6Va=UhkI1c*3?j8iQ6@Q>;O)%-9s=;32bL6j2>KT~{fNI0>=PGPx%q%9T!1|j z5T}1~0oNYJ=G4H5BEvU^_AJH(k!ug5-#h}*I*4on7cNJ8Qp6sD9iL|Y0dQK$fK|mF zg8ng%GZXktz;az&urh0j*$rxB_uH5y^>G*B-{^oWoct z!#9HV?25C8(GRRblARIRhmu#*o;G3+!88tzZUQjT13QX61pW1#lBm1-c3?|fT;=`* zXesTif;hd|1zdX=n==iSB*Qn9_FS_fRz8eAcNi*9fOL|QU1?7*v4`N(SOTek2jGX4 z0sD(R1pURGpB@8V4p@qdtK6wnilMuH7;?Iy3%K?$Hs>T>o6PVHqCKyI;MN~TAK=@z zqY*iUl7nc^2(gFYUlEQydJ&essz*4OYUw_*30|;*UF#0!E*@cK)P08D6&jPWBV0ZRI z+X3wJz-3|&K|dbmVBMyE5!h=ku5tr_Zu=c_LlCDwcLCQP#^#K}`o#=iU)nQcRm>hn z|HUGxfXM1_;nlR~Zn1~p`yAgi18}VeZV`J3`giNw@YbU42W)_gtK6}G{`?bi=V;G( z7jW%iY|f)-pE7*CXiqWR2fO9N=$d$oQSX4%Bb3}udv=RG1eda3d=bD~9=KoZA?RPK zH^S4WfSqx1m3s(rJ}f5Gvk|8qBqv&3dl-vbb-o*!8EV>=H|*U0GCRcmF|$Kl@t7TI zA^%qk%GX-)qy+qI;b(@pQY|~gb%mMspPbCl^}?^#j*}7P@sB4f62oK6v*9>1#61+V zL$3?R#PBXPJH*}FvP0Z?EjyImgBnac|1)h&TO3Du)0`RlJQEXKYr$*Kh;y(dhV0O) z!J}u8+04*+{72Vgf+i~kvm*_5bMA$E6qvOV+`>R*^?M!2N7bN<+ZGsvdmN~&{zN|D zF?TYs(@K@8=s}8d)tiZo@`2kxTaaAOmK}N(gv<~ZyJd$MlNsU?x9re72t_$Dlo?th zAfq!wd@D9nUiQwm$6O4T9Xdcdr-d=sDRf3>hPX&BJM<<&&Yow6wg|{*dGf$}{~Hi} z9{$+S_8sUYaFiKht;-DYW;Z*;iGob~UrCO6zd10(e>^gi7~b&>4DmlZ#JkVT5bwDL z%0KcbF}&*;7~(%p7e@G*A>MZkl>h7y?}0Ky9QhBFe>^(Hs5>*nvG+jv&kpfEATz|# z??Cy_4sj%oOi2v?vqKyUXNEWe94P#O_{E&;5NB1!@%tbX!?=|2!+fFq^!hSuu?RPsjP;(5=7&ClV}sK2F(fRVI2WdqCwR!yY+#z<{wJljtlPsHSv};$Yr~eemTv zD~AYc${flW=1A)gR8u+C3oPElpNbMgnifezJD2e6kIUujV=y zQd2o8<$Q?H4{)BMX|HWpiZ2qWJkskN!y61%Syy8i#+)VAVde-fpW;*|+;SMsZnNBK z9`|bS+QoCHaz0V@MARraNtg%IZ#h;KJ;Oj=+`KL^vd*L2xPADb)cFpg504z=r`N9l zasV!$dYok)W^A#PJ%*uXW(&|4D=|4ish&gdT{thjxQtTK$LJsK{KX`Lt4)4-{U1Pl znC{M}xMY;v#>i+In_2u~8Lb9hy?Abc=G#FW)V)^id9M`T z2bOZTYYESSZ`p4%X6vtCM4$K~`v>2$A7{+b-#&)$C%kHW%a+c(P5*c^?o0Jgm|pUK zWn%Z>XO!3+C7wYiz2 zi#-d@Pn-w$EkhcTJ8~p-CQSdmqk}GjoT_)g*HY(P3Ze z)$xVKI8j?qMJYCw8#X(C;;7OFTW@$UR}UC4NCn1LvB!gPTm#1{%6a+dXSd<6JKBQ0 zA0XKhGnB8|O9CC0{Pg;6px*?SPvx*FKY)OG0M4eYZB+q?+h4|DjAD#8NP!=zbs^uDJssQ@3ZWE9^1bW&q&}* zWnuJt$9H9x|{EhzzkB6M{>cWY_V}3zCd$weq@5N z@jCAU&4Z@haIsW*>6m1vXd>oM)ou!%02jfr@f`oVO2$ zwQy&-FKALuO9q6WUjOq(OgO;hQ`EQY;CMBaBYAb%CcFR(Cz^Pmq8$0>k^3{|eBa@| z!1%>9T?0}FxO|ElO}s}@y%8J;Cz^PG@7Ylkxqt1z?M{n}HO&XI94?=tMicM8)J6m! zfD=tTP*L8k<&m3#d#>c(7i&5WhjNWs<0W4FX8ej%CkC^H_Yk^L|qLhig=)+yur>RbrWt4hgwCkVj2b{7cQTo#w1P! zV1ft}U~r;|2P(>`gFJH6YA2|eK7-4rsL{m9M0Ezi-{C|P4^)(sk9p)az(zmyi*`a>d=;;JFNR%k`4lypI8CaW zA+8OaXySp2a#}Ty+|w9Y^{9Tarcpp9!R1rbXyOF0nvLKhIMKud73G9+9=Yl72h_w? z7i-!N~CDm;(e`sEVTo!pWdzgW%u2T1rnXridm#7TRV zgt*FZqKOA8%1Qn_a_=k%sDqO(*3=P5CR{#6jV3;hP=gR01t*$#prU+ykwN1y2QBJB1oy*|FNA447GUp_kK}9TgT>2A*%crQ(#7DKNBI2sUi6$PXC?D>ZHv%GH!&y^@UNKub!oe#s>g>}H4AEXsNMS13y8>f8tDAe@|ZIq-(c zQGOsKZzaHIKEz9;*6LU_`V`11xP0nh9;dEphl5`c(hpdTJWx@7R3nenxwtRcb%~;y zAT@-`r>H367cHC&L}kK>X`<0HEsyjQm}`H@D(mKz$7CQg;qoa?Weas{n3degoTpfQ zxd-@8ICGw!-5u1ymax zIEg|y3o6PNv&UWC2J54(;%1)W;oua0rMDSkObtX07{qV?kOTDy;?qAR9Fy9>MHs!a|SN1=V(-BF4p0@^wR(*kt%nO^L35g z=*re=Zq@k^C(jk6X1KT##j}d4P+r) zK6OxIf#!!sUbV!=UeY^&zXMmOGRUk`!mi@1)yoDVbhAp><<4J?;|`C$E+!ALtH0dN zxQb%yM_%FjVS|{I8ii)msSb%N;Us&!S&cBHqI~~7kLpVM6I3mm&|uHvY#_OC`IN_5 z$geMcH)N6Tk1w23+CV#@P6JKn5m;BOoS%Ve95>WV>1r(N>4~0#*#Bkw%<;USvD>D}c;E57 zpo`VA!EWPgBKO5=+hB+Bb1*4Wtd6EmXIX~5&iR$D2{zqWy=Z`(c_nWy?1~N}y$idd zdtsYPdFlby{cFLv9?q-#D(^}JD`U&owKk1dZ660D4=$fla{X{$1ZO@%>)=EO&u^?> zU!uw1I0p~nt+pawNj(MR1-N|5Q`3YkM-UfiLYkpXQ({4Z?n@j6-e^8jR3e5*nzYR4sqwRv|;3 zZ1S<6f zY8*FbecTE+@PwbCFn5RLqaCjty$;J%?<7qWC&pB7H)yMOS-0{}qB5R%>Awmzcc1vd zrkLWTcm|{*d*dp%DRtA1n2GzM(~Z?=@mjD#mIJ*CoL3>$5=|AmumrVOcXKvl^{_pV zZgBY&qd5hdTWus;VinJlvA|ct{fhx(xZegcJc(OuunOLxxnb?qR!1>U#|x16N((1` zJocw$oD>5`edAg{?m8vrRmsTCfmnj4fXwjxMQetP{JkhXauv6FH$c0e^{F>n%h zJ7t+nJ;hpa0PI)baj{c_!8se$k-pyH- zi}K?}D;0W}npDawjAcmb9yn8eJd*O`PAlUs!?3Tul|U0|i;p`2|EF=+8slJ%^b!(e zw`Q$tOY7L}&Cz|1q8DjztnG{27;djUj@uP~WK*o+rPz-ty4w+>c1-17#f*fh2u{P7 zApF@9L@Pq`e? z;~6~)=nl=@lABn;*j4j4sPR_~Z@m~N;@m5FD!;_&lsEtyoK!6t=`f_C+#5O1hr=V6 zC8%~*dn?bZ4nX?B{_|E*{AmfJpd&raX^9nd@+0WB z;LK@p3woaBB5mJlrx~Ema8gb(N#G55^CNou|3@+PBPUfY@u{ByE|niKR`6#>mU3m!v%c$XK|1ic8w$ChbBQ^)dw? z%l8T(>*KleG#6U?7CSo;`!t-S&Do~dASsU$S#RKTq*h<7%)bC~8ZMvWk~XRMz_g<3r03ajb@+mH9le@G|g8KB5 zv=;zb8PA=kxq#X?-?y=51gdUS=hL=DbX*4`S?rHeiO(ExO|FB+T=FHBaVbV7uU6a zfP@~41>xn(dPKJt>Z z^MTBX=g!ky@a&uJtU~NII7xfay@m2k35|#Ji!Vw07?8K%@+mH9liT(*CSWc}`&S_9 z@i^{0&Be{WX-)~mUJfT|%LIQc-;{V}eL($qN!sm!bc4&MxTH;P5iI)10V()^JwE3hcuAWn3)z<-4rr*Wa_hUewgUhG5q)qPZ*HK268@s+w0{JnX zJ5O^lvTux|pTv9_oTM!ezGC^N#NMAUp?pc&O(2m0mrrp?o7@M{w(Pqk?IECyj_1zP zTzKruac)8EQaDLl9^b{%rbLCkSgCqR+7APH94?>Yk~X;qa6Oi};o`dX36O8%x#+)_ zBkd8+?})wZDVw%Dgp8$4iOyJ|f0fl2t84Wj(G)J9;*vJG?U3)Om!#bvyrJ=2^xrFx z_E2XMV&}t2zU5JBENx1(KNnCNE=l`AAp79*DK2S~TL-HJKDZ?9cY%Bw&qe>uvV6{C?m^_)wN9Uvf{buzgHsdY-bE& z3*aQ*@>DyPHYL8nLg>Mlq`d{m4!C@ZOWNeVjK!-PE=l_}An(O<(SI}T{>~}H{s|{( z%d`1d+LS1R8>QziNjv2k3m1iOr|5qTlL^)wOj%?uE;zxTH<)UW{=DUy}AwAg{-B(SI}TUe0HT{TWWuet9Df zVrf&N^Lc!H`jWJh4rBZWmrrp?o7^F|CZ4+_?Ka?bj^{4ZgOap*p`9t9Yn1uv_47a) ze+qZq{xy9ZV{8s6{68^z1uDMfhZ-_MsQ9yTUeFb&}nTf@ZtM!C|cz*Y`{hHogdIo~4 z=bEqV-Kp0M$7T*4v8})w{UHv^;A3x%^cr1p1dJbwv2V%MdhcjFz9@yd?EYr1)lVSq zoeiP{pZxo0=AHVBTx{lCOskALb#yFl{BFR6&uZNchZXShctOF8HM%r(yH6yp)ySmXHHhwzQ$F8x@sMt}_0E#Y<}y%w>cM5e<&+{u1gWg5lX1*GGs%?wUQ&7!3+HVfu4Ru$pa<-s1iNG-PJ3Qz{TjA$Jt8hqqD z{>Dos2-a&4Z~~)4#ZfO+@e<>gAg0q8l(2lsJJ|gUCFOG}!Jdbxu?V-=4fc9Yj=5iY zu+J7b=2ydmeHTL1d^J3H!^0za%&&$A`?tBA#~<-Hs{@ZqL=qr7{7MvR;uU3ZIO8$w zNi!8eEN)fdHE#Y@Vo%r*oYk!;s|)Ilhe~EkitOC9RIONA2Z26G#yyZ%CEMK&#drL( z84t1%MBP#!y5bgG`Q%?1!65P{xZenhWMbt`klZi}d)^drP~G5+Ns?&d_F6D$^OqPG z)&$b1Fk13~vOu>_oP?>m0?c>;?M{X<>HBR^yz4KFM`+SW08>5j`Q7t z3h?=Vp_FXsfbwmL${0JqqRV`cf|CMJ2K=Gk45c0dSQ7v@GBCM|{(%%qRmFJ^I(o_b z=ou023^>cBh@Fw&Xi4c!qrkgN*SZ>ap}=n|%%P|umP+daVrhL6%hVWqH;6kgC1ZcR z@4&05zq<+_R4KqR1aMyWc#>wB{b-Yd)$|J|wE7WHk65%B}C=VycvGnOmO#ew}VxQ>$(sj{PrGgn!E5UA3B_)mRVbMG)bi#e3@M zyD$dxa50j97VoPcMU~y-;mn#Ts-&D6u>VHA3fc}K_BC?EJpQTDbJhdSK}uSE0q6%f zQ?DPvxm2a6qP_>m=vK$j00z(^!o{k6?9`dED$Nh-2FK~gpGH}LnQ7bsjFp8hov8g%a0$fIVLbkIS`T zKA=~(0`mi~aMKx=?HDsY;m36pbAB2xd8tZprWmB4r8uQkHj0nvFCIb%hJ~dHucO5? z<4CV-K3dUzK^Wtaym}L#@CiL?In>PpYmvu%f~UtM_p5G#hZK4Q$C2yGaISM!EwY?V zz;}2YDIUY=?HtD?D)u}N{B@7RB2vjK(2WF#I9sm7IGLBhDd1;Zj)g}#p**d4J?c;h zv*U24c`MIvs|F`HzQNd*lW=uFbqTY(QU=a<>flU^bUQ$uJ?Z2>>f!2|<2+s!4<;!+ z4A3Y~+Q5sP+gjnvz=Y=jx+5k%_zK}IrF{E zss4#I?K40pWAF#fpnQ+h8>c`lS78iN;7q=gf2ZY#oENHE(^3FcjlqLx+F|Dw3^T;? zYXDsvgC`aVsNgYY=Xle6>l*8piLfJ zcGbgxzjP|Hk{&?x5kfM0@UAXpNN1fgFM;$S2wxW>sj`2UgpyyK4j9hp3&3>5J*UZ+ zcLEgg<$r0DPX?4qSi1AF=f8#VX}*7QAk-Mq8HBv#&8OOfHGFT3g63Yp`n$MF{u?<8 z*7ps4#q?HsBA`6NqB)u0rV6(79qg@DBCEp+KpR}xw7`bb%{S|SRv1kw{Rr^G9{8eE!Ldo;ZpNDf!Eq?(H6)B`8`EUk|y~Ee$DVtJd;MHA@GVpTW zNmL#&HUm&Q!X_`DwSx3o-?96x^Z-D^V$uR{_MIJLrDp(|6O-mgUxPb+Pc60A_1%EB zxze_s5zYbMiqe+z4Dgpdj%jCv^OSEwy5)QY{6~*t+8N=z?BiQ=(uRaD!+-|Pl&EP# z>fHu=-tpnf)P_?RcvFvK+CAZ%^p!tq^>hb5ybveW?Wkm7pYy$e=NyviOfZ*tY_Hd` zMCG6RsU>a$>ES{|%PHY6Rbb6~8Tbj06T2!*s^$HE7PHFEgQU<-#O1Z@37)wt{RI!9 zUX%uw>fxrm=5avL*1s41yI9@~__ZF#l!b75`SX)3=SJWoJ&tL+g)_?kA?`~>&#l1k z^f=TLUtYq__m@6w*}K7f%45fsmk<~DE4Q)4_dxoh5K$!yXT85uMa%gU_+==Q*hOSU z&W3o@NAER%fseFO0TT2%Lm@vjMiZSShGDQ zyO&6u%6fsVyY2a057G{gDCg6ZvuJA<_Y=dL2A=3-%j^~~7kTU(SQ4hP zZK;LIxHqs1w@{M){U9Cih@z2yDp`n!18+QMHNFPY2Og0cE$8jPJu7Wreh#>=xSMrJ zRfuJ`_YU*zJ>lqA(AVR8*C@;c~W{fCH6pnpQe1-4xO2D2>MqPQ!- zD_najB!MvrThMvQsb~OtJ5R(bz4)Bpnou-k*#p3w_Al&S#@P*w2%)uVp>(DH5eelE`mY5IH0*@G1 zRHAWbu<{;DyceW>9+54iO}ZoveKhDtCic;*=u);y7PY5>Lz`G)7m#lBh;fEKhb}kxYj7}bJ|z9gAkFoNafS*p z6q`(4!be2=Nz?63V#wk27=$rrUx| zLieFn5Ml~Q^*mynp+f8sntr|2*a4&)J>tcN3cFY67-r-|?PM_LUdmRlF2`q z^)6+rWFg)ks{f8Pv;#D&$P~?QwxE7?{9`RyB zh5c42_a@7J0nGOn8G8Khbsk)>fT zk1?Ei3x)a08>dHf8<4K|h|G~n7EX=uoChsu1n}t|$5Uo|O<}hV-;VZ3G_C@3-+!>h zhdeW5vI4|K7C{_j2!z=R=i|c$5WMVq0C@S#{!JR6aIYsmuqB5J)MV(Qzuh1s_kL zx2UIt7Uzh!WUhEi9~N)ftKu#HS-cg|X%tvlTf9~6#k=!H@mAj?-d#(?TeDBRwQq~J zPUTT#P=ri#iRktwmu@vzh?@u=s6cQ^R#Ik zH6_h>5#tv99-uE=I6{T$^17v9!yVawn#Wc80$>f>O~F+Cx+l;Te_-TSix!sl5EUJQ zf>J3-&FPmIj9ct7FC>Cf?QxW1v=NAbUmE$)s?HyQ;+=$~EpYMbuKBU!i zta=c&NCh4!C&Z<3#JLv{3vMAX(~puY*Y*p5wK^B|sdDY>7a;ZK_0hI;sDi_im+`Pu zxVKhYL3$DHHMnqNU?xSfY7ZDNS)LK0^o-WHYqQ*YnO8hXE*hnI9AP#MJP zaN!pJt`{Zn4QO?4?GL>Po$FS+8;a`(=AJLVkdJ~D=BMEfILZ`e4M{7W6o7cdt)$slML^+r!r$$uO|B5(l5j#q{X+aQgzGIxZ3+&m^C8 zH=dm(m(gP$z|9>v-N@lVdije^@Jq-ykfdn6wBjOmb7b0aMv5!XI5hBVB)3?r@cS zl|J`0rt2Wspu`)XXXx)xyBRhtB_AIw^V}Mou$1!kZ-btc@(q@X*KnP9SKKdNvd!b-U3*l#w#UV5KS(GY zMvK>Rig=x7iPt$SUYAnhU7sRe*IMFr-z8p;yXaMDd{n$Ef1brqlVY=Rip%4UL_0l7 z6z_@U49`D}yq2hdCr{=2uwwhK-;bJHG3(aKcmZ|t5QRY6!_Cl)jZ5tcu?$4Fg9|T* zCS{Nb%`qFHZ$RuY7cmc-uIRY|joY-OG{BQw$h2M9<^d5Yl_oz6Jt>u@oD(m<=NyJ+ zj1%wH1>()xDBkS-;>~$UytzM%cY74KqbZdZR26S=hImW*i?=jiyyfe}TlKhjcfBg! z+7HBAcUrvlm(8V?yK9TLp_6zU2a30;K)k=JAidN|KHXs$eZO9Z=+sIH`hfUB9Y*_+ zS}CNDNjR*(6+fb@AU-8!ux~QGA@53P*yrL6|3kbH(fPziRu%827UJb}6K~XT@kY-R zZ_HNl#vK-K{7La925+bMr0U{L?jqjQA>vJ&Cf@Yh#GA2ByxBX&n{!ya+qi9cO3J(+ z#G4<$a5g1nK`rqXH5PA4CwPr+&B9qM`lxPtIaZxd#z?(+?cCaioT(F%_qqxgTK`)H8ydng8mOKG7PCj z@^EC~-}GO2dPVrfLU80}a>~f(g#FIpiCUfVaI&oq`Ic}sXYN~CQK=8+M@AtDyuyWG z(zQ>+%6d-MY^@kh^WetM{R5jnk~~)MhPWkaph}m!fn7_rkKV(wrA1q?qUzKvt%|4C zYg`q#*<3D@dL?tMgTJDDQk(aKPP2F?wJ~$8gUwOcsV&AKK2+qg1dUJI3P15MCNNU3 z8M*+EL4X~E3%|(HxE)6k(p8#JT9-qcuU|&QahId2@M&CX`>p5j9t|S(xA^;!=xfYu z6+RzLy>4b}EKeaCf~m#e40f2MXlfie=b8jw03T5~{K#j~rToVRW=pm#%6xn-rw zEt`YU^vqu5pB-FUvr`DyIDs0VYy6JoI8Kf2xI^&QI93bUta0}#EWD_3C2nI=YwU3_ zo~m&zilU%dpKegBn@wRAaGIsQ4bR`K)JjB#nkAxDQpKAke~(aVvu+I$%BYbuA1fqk z9L0@zr)ELiZ~1leWu<^9t(qtIG|S3b3>jjVo2jOo(RmpIbDLL#f#*kqT4US5s?3O4Th>UT0S&Nr&sdD+*RMnKtvr)KaCKawOkJM`n zUrM#99hvWGe}mEd)~~FR->X@x9&7AbbxkfP95|&t^B|S9!TNCP0To+XgwKWwdIa z3g!S4Drj>9>O$IJ6T*FV9_mEea2s^mR6*TH%dtU!nx z*s&^Yk6vUnjfdBI(8OWrP)(H6YP1jRgC^u}ebdbinn?mH8$-T z6H3i^1buDVE1DHkw;nufgi3o||HMR8^j#)0WYTz*_NIx_t$Ep}y<nS(tRkHZehLkG9DvLL=g?Kl0gBJ+2c9gzs^h#9D^sAOS>awxV_w}iX2+Di5 zyH}&x^8VDdRiXhI3)4UBb)u&WJ!&KYzq z>qf(0Oa*F|afZJtH-^Vt#u@(laye#S6h65TZH-yF89w#dI39E9X87AFNX{(X41YIW zj@dPbPfH&q%S6LJ^h3fr?SWLS!hco&4J}Hm+E_3T7w*dvFDFPyH~#@=E(_5kTqtr4 z3piRCVM8jdQ){8N+=_^09;q~r4703gs;pDnL(~0;eylL*T2>aLb3f{bp+_|s*bfe(k+H(>S9|UUm93d52t**O<8)#8z40Yp_50Vl6cZ2 z-K`Wz13<|2NVlR;EonPTaI600379hnge5M?w7xPK5ZbEFV4wrddMn_)E+ry4l2uUQ zr*&`T7|t=^?|2-^mEpXje?MV4XMq3VacGY!%e%1fH#+hh?2Xn%RfChW8IiNWg0`g6 zPVfG(w-E>}J(4Jqx-Z9b*05u^jmM3$$Rd}@X?0wd>Zh(5n zU@o@`PjZUBWZ_&ulVUKJTZLyh5BIdDEe5nQ26MSpcpkQhu<%Ym5655*@WP9oy|sOc zXG*^e=y(j~KsUU?`8nCb-vK)7!Ln2;yvcdsQJnS!jBiT7#ZJ3fN)_JkY#od-9>~gjMPab>!HF$d?g=p)GIuvM}Z&zH%_u|=SD}pPtJG1e<6nk z7(Hc+HHZDFzUvP7(3+w#EyD&ihI7GG_)1^1?`$&ZfSZvLGesyJe6Q`asdNXNRai^% z;S7jm`qpASvsgO`c)qK~tf>n3_uY@)P7GZMXsxS4C4bfm(nEZMQ2RytVL*ps(gKh2 zwX0~Qj{|xyCe25o;XGf~6F%uU^;tl_#-s(F<;&dUsQoAwUAzGb0nVHySrrss<|~S& z;kq`WuOuXyH|PHZZQJ7e<$hF>>wxw4@GNOIxTGSy-}frk)$38f#<{qv!o?t=QIXm9 zlD{3u8W)YQkuX(EmY9Tp@pb;(68D01xG+)DGQ^<&chp5`f<6T4yTU}%Rx#ypdH?t4 zEYaT(eG;6>m?Rx*`DBSnIM08Lw(N#rUR{W7mY9TB`M*Uyk)&})q=pybNRG^N?eGKs z>Ss|N`5?^oNNncKD#Gw%{zqO!d9MSu$;DOKZ^y&J#K0q8IM{#!(MMb;zL}njnVE2f zK(VV(pFafQ>p~=z)(vMq^x5~H1O5Y0uZ%sXw3K1y7oEim zbP+HAI`MWJ?`3!mcXfi0JNBH((TN><4g~6sJ!_2Tu^D?_A;)IyxqBkxImZz`wNH-C z*mD4qbH|=T<@nOEXNwNt*s-|b|pZ#ay!r2@}xMR5e_i<$;t2LX*OzWT>+`8$ie%dyb;c?x1FQ^i(G7jy+G^ z1AH8?=^kD!hG*)jnZTC;+vMStkGCmHH!BL#0T7OOBr1s~P12Rhf%G8=-+82)QK*(= z$DY5YfTWsWDhf`Du+Z4^x!e4z4m9g3fYV({L~`VgJx?TBPJ7@zJdWhb9eb9^wwzJG zCwm;)KX5tT*mFcb zzZygM9H8F`H>7rV?AgA(l}>DmB;ib@a>t%J%Stx@)P%4|yJOFWH~H0VRNf6xZ%^7C zd!Fs;SJMdR0-6+)wqwsq$yRzXpp`LcJNA6wW-GlD(8DolJN8`G#G3XppyM&vjy*r! zY~k+!osGeE>{)$=RUT=^xiv3icI^37BMa9AR4)eGvFE{Qe#JATI{>;q2HUac=sFf2 z0ceZ|yJOGcO>stNA$k!ZUc_<{dSlNHYk+SCwzm)-G1bD3J)fHi(oqmzaY^3T^Qkd5 z`L6+;CTvcc9edtW%5TP=f#$df;0$cXp6Lb9n}XO{L}JFdW6$4kA$DZe+W^1*-#E#> zJuUsJ7daz9p!5lu?AcZsAo*t zjy(s>M)kf6r7#B2gqXA)dwy}XUo9ZK5YTc@+8ujtz8mLZE28(hlJ@-DvFCHuc>aMM z_wc4DWF^aaG4_08KJb&kzISnV?D_kZ_L2`=gQ1t6^|OpLXB?%1;=ieFl`U0@z6#P-IXr(KQ5fq!0z z6Jd_LvFDUwD34!3aISW9%x2yjduHQ`*Ga%Cy0|y?ELRCtwIQNgyO8NL&Gl%UxyGGSz|XiGZ|qqH7a#df=o*v&T_{P{dkp6~~Q6U2zIcl@HXtI{2)vcS1J=1SbP|TK-im_m0I2n6#el*tV znCVi+sj?$(LL#g6J=Z5FryuA;;UpCXE=fhko=jTCo*d1o=uC`sJJl%T@Yzvn&Dwr` zg)6mY9shLrb=zZ>zILtaCf%mh{E~GZ*I(mqv-1zDwW{;6E(<~3<{R9r)cM2&#yXv+ zB_jB#33jgWGy)&Cdj(&pw&iYZrd|?IWV%nw7mj>>9 zih-{z@&F!*)cM*X=ZT!ONFD>Qu)g&o+qd=phx-cjHDL#f+6VQ{*7E8+Qd})K~|HW8`p=20mU6 zQ@V32QR1KM39Ui&BncEj^iVnCh7O3HAb}vF2g^}G?>cuQdZGlPh#n$G7#W{I^k@kr zB6_$S4ZA%!T6K!N?`KWxA&=T3*9RRu|E%%(aAaRK>eCYUX?UQ`n^q;?RAF-R)L9GeP*I2fGiknXfY6p2dUr5>CS(990|Pnge=`Rm`MZ z!Q~NS?jDWp^4LahRLf-KL$0FpVWv-YjhBlNl{_G4BFaB=E{e5c)-wn+JUs?6?)s7O zGcgHLfatk!VTVnUT|ctwOCW0zd!LI$-eczM`jN-mLgRiHa@UVAwZM~8e0Yq~VLYz6 zK*}SyP{LjLL?l5>32wl38ScRdY`^&z63ygsC^)qjj(hUBcp|03z0cl&`+tNh!-YdM z%>Xx4#e8KWM7DH+NU<0?pwWJx>H*|N4=qJB#AjsTVZS9iYP5$W6Hz6&LL%Iy7z(CD z+i_rB_X-Z9vq1}f(hShO$B{2pf(tCdH!~Y0w>JZA+_-$7N`;DNz&uK&)u_*alX~9a zDBATg06s4Y*AbBKJ%p#dx!6(nAo2p7#)BpUCbmZd6rO%V4@~DEGMRv=G{DR^QA_F~ zvZ)J18d7JJnha&u_U?}A2DraRVQXg5xs@OEshfe!D1;gOZXl0(Xj58X(B-|c!Nn^;J}QJ-_3fCqdm3Qv;g5j%bWQSRs!qv!@%}=1>)CG{ ze2578PJ?zM-VmMxPRXWFP9ZuP1QsP8+Aen|6s^ z7*RgMtM+~ypQ`469Dkob?WjP{x~TbydtZRGEOkuW&kM4|o+YsBfUhzRSzi(#;ni58 z`SXZ9$nQtWwwvl4_*OyAJ zZ5hh7F$D#C7W!2qAT2$#6VZ}f-<+_aNDIH}hA_X1HOOO#ykXq`eb_Lj0-fzKL`Nc* zFDD${fwBLcKsI?OHLApMk057DPi{(3M}WKohtt_W^#+K8hH4}ZjJ=GCFsOQNej%Vf zIh3GIg8q}M(3EFl}!HlNZZdb!tLjH?Dlg!cKf-{R{NC?;V|9Dtbw+lYu(zfDj>4D3q-z* zp#vTq=~vBxwDr($iQ0bdr3_!aFs0)TVVVTVOm()4rdtN7JCM1BEx$^%VzF}-7X zzxorA4raTJN(0P%bFN>NMr5iBL_*XVr6xm}H6z)tngVX)QR4f#rziPUZy>`9p+<{Q zu;58t$kPDN@hDP!23AW zE7Z^3*T%0{1^xiaNq%7z>gP(J-7X8HhKG`0sGobUD(VeCrP56N?qeSo(Ry5;@d)ooHwD;w5 zR@?hdoNaqw*|jNf;d6>T!N)U3?3q}neVA)Hjo7n!t{CG~uVdJDD^%nu-!?pb>OJ*$ z%tjveNq6pKbpIQn7bK)JI1VUs%y&0>Je|RjK#^B0!m&V+T_I-2Ehwp*|z6H>1!eU#p zz~_89fLVa}oGm6nTsU%wC6(NaDO~W~gIoM-xJH5q2JYmQlem{tI&pPf(v($ky)t%Sng`XhJ#PBl z>M4jS+*LJ$pidS3RG}MY09p&V>tK&HCk5&rMqatwZ$vE);2kBd>aX zk1LuH`YHT9Pfi<(C)?`Tw{3#TCj2q}zKp@PdTzpYTHOi%g+E^pPuf<`VM7yCN2t>k z0HqNY+uZ88Ye<4(QRxiID??GhCOfDdyyUiF*_SX9gabh`@|uAa5#TFz$R zJIP@dBiABjuX^6S-6nGc_#2)c!?D%#uMJkux4_R|q{mjzu6?YYVmLqL;3UU3En7Vg zx@FoB_|@dZ?1@#CMyX@jqP7YR0>f0#)*%^FN15S9SLG0{o>1VyH4i86BSlavb$1UPqI2WDg($+>i7>kpyTu|=H`B zQoY=~yu;4Jmd96%ed-0spQaA!RHQt3AM2aC?(c(I!;ebxm5mDSOWNKWEO9r0Z4Y1#Nucxn z>m0>?qZ$NbMZan%beGvskf0(rCq6wsLG`8H?;cW$b-ThAOflAG1I3W}V^FpIY&GqD zwhbC=g!5dTyyzp-chlZx_c^M_V*jy#U;5GeskcF0jP_UKU?+-T1$McQ8ka%)`oWW}cxweYc463Byhy@LEMQ-G{#U=^w`If}(qi?HA+w}?AC6Q~!?u`_P11|T zo7(*VrF<7JV~^!Va_(h6B3VlRkFdWGU{8N@BDPs&S2GBx$6l9(|=F_h?M zlaV5I1uEQxIYrJW#w6oQuJ;<0+>)TqL}y8PujEoz;xizuOFZWn6(QpzQjTTjZG(Jf zu+IJjHM@}fzlfQV&)A98`bqlo2h7!c)U}!g{x4-K=fOJ}5h>vGKy{pvy!{yg^)1Dj z*VsAWkxE*y2g%gbfsrPe^c%qAIUwo@Na67QCH6u>+<9!fV3`j$uOC-2X!c}iMAj2!6_N_>OgZw_ELyvq|k|vJ$E!0UzzW4g+^{o zXxSq{o%&zN#LB76QymjjiMhJ@!wIT<*8fX>((jmtgs$H>0i6Q{*cedXztw+9Cze=J zi|G&@5-f#57-N_HuLR>nU%3%|+h%8Do)JAt(F0%Dq#v^fam_77RhiSsR-|k&t6zfp z`I5v+4#ruPBzUBf)}R*aS9R4SQ;log$g|(EqcpfR2XyTyjfZ)k#%qLBnK`$h0I$~f zqpQk-#Q&}k>CY^I#CPY>t1bUu0)h~Z3C-KV5a29$Y_62rW`>-PfvImw+9y;!npN6-_(sbte~9SZS-}kGFxQ)lMIUS{K+;d=5UR3T2+C zv<0R?NV?ZStx483u^N}-+b&G>qO!hz5X!2%b3cY>v~dwA7nL=mE3g(9&W&_HDrv-I zIh|Yjo8j*sHwmwFRnpswK-s5rFvMiR|5zvqDK$pNPK=x#?@uM&^$Jc*vi_@%86B4# zXmjD&gU1-hK$)jc;K3DRGeL>v;{V~q+<{xT64U#kEH_fS*N*@DiCO4foEM!K0xHUR zq@<2Lk?CZ85?vR^)i1b4$K~s}p`gsuH{N5)C4@1}MMnQ$%cbuvk763RYiWq#6~T;3 z_{vkKM=(v=vn~E>A~t#6`Tpwic<`&Is^Tz5ajU0UHNLl$Cb)_oC88i>EFzDGumz& z%Vm=l9Ds^ZY@CcN6Sv%o;|Wipsyz=yufv5KtVKl@v}EVIfacvXKS6HzekTeA70%)g zm~BjjKkb2$k!FW~v5~9_yxM^YZ(#YGgg2Umi=sIzws|Xt`_};K2p8@eOSot*&}~sX zbl{!lc%ZZ3D*XHgKK6#|%)3;KjC8aYCtTxBCVX1}xi<;VGYPN6^-%2gq8Nie0+olE zaIaXxkD_uETe4=YN%%XU7nrbnX?hkI8OgEq@ZQ*6wQcYyRNNXwf5)D@I@0$*Q><-g zZv^Avvh5NS&qv2X4C(#b9b5^<+Da=D6bmjUFQ`f>UMC3^D5ZE^R%m~x{itWfo4-C3 z(_~!mUHodIWW(nDa=*TXE9WEG{qJnlq_7?Vhg?-}U%hw4}#j z(|d5?0wBsD-BLQW30&k#T?|SGjbP*U)22KRclzEk-STlV+d>YXO5+t-zW}lQQA6uyFjlIH%(tdgdWRcbq*VHP-CTNS z4~X~EG4alEQ;U>J=egHKN~K@8wMD(5H%(TRzR=B4G7ub&lq1Jy+CLT8fIdm54_G)H z0_g+pt0Eq^aX^T>H6%2^pP2wkAJGZN^1M5JWN#j_BBb9mn1`$@={b2kWR*xCGY*$l z3BGQSe)AL@Mi(LBw)bK=So(sacVdSIRJQMF%U!dfKYcd#QA%HYD^`*PVM*i`NXVbc z+Pe?PvNubZO=GfloIr5pqczMhA!~AZ2(RvyWzj3UAh`D2_ZEE1qT`jOK>0`fTEW2YJeWgkbXMLu&=1|W&U)_hLCxlx8Y9E7T4)u2@Z!y-` zgRchy8ctXeH*=`US8EZzIY{Z5fbMYN_&L;oFZrNVu?6^cmt*HpFY|3gev->cKCp2@&(y-1Hdd8z6vfF7O*y%zXJmt&f7)`1GA z4&doKGN5`5?qjOS2RX57!e&x=)ue~i3|mb`O2Af=8yRq`$@nx>lgLeI3E{#oA$6~s z%x()_RYcc!p~&mR-D)xb7y5^=Qg;O2m7I43w$-F7HkkT`@JK*6$6#AcUMr1xT4r`0 zphbiwakrW@S)`SGTj+j354mvRYLbFQ1ES(3;IF$JubK?P!cI|f3ee9kT)3JH$*_4S zih?W)CwYjx3cI~(QtnNgOatIokwZ%@$5xYb58?F;X0{jbffwnq)g&F)yqG%;_?(OM z*lO~|Csxnhz_(qb$5xX~*J#BPp`QVM)a96J!a5MECV|;Nb={#AMxl+rtSQ>~5wVs( zM_T?5(H7JlC9&M0pzdg|6WDeO$^Z{*Q9tSq&Hn$LD6veXivl6h_@Q#@V_-kpBfk*VM#U_9@8)k#bq_f z;eTt`DmE;6Ks0d22%C$XmnAmpI zjnCeTez@_wK%FR43iR888=3S0Tz!dtmg`aBaos6AE-y`R@aOir<#B9#-Re9v{p-uC zacKJ2<2a1^pv(5J$7lIu8nFwa%sNfmzaHu8QzID3c}p{SY5UhI*rlNgPM_^xzkJKQ zAZq*9How}S>0eL%Y=fqM%{X9#rhmZX>``42&-@Aj2Tap^c=aSUo z&DUYPFCz&v>Xb|uZ^>Id8EO>I;L{GtfALlvDNFu~xBeD~iDtmrF~_G`-;DKSaN!>j zZ-MTAV~J{iL=Ja>$S;DL;pX?+QPY6TaZ$TK!;ChseFSR=fvkhOpNu~t8Yzb(RZw zCCx~4OVCl2s|iXy(rArJQ}TTzD|154>)$=tHP6br9Xeg(4$~yWQZ0 z4LYa$cLXvVf1cNRRCXkA83U6aeSm%<+0`H(0;AWAxk$eD_6qY&UrK zw~pe8&@TXg)#aFOko7^jLB3<6s?9r%DSMVd;0wI+h~|(>HPHZa@hUtnQiaF0s0my= z>o$jf;n+5ZT%Bs0!_7$3Hiz4A7)^vO+Z;Mr{l*6eS%@-=I&E|KCzei5W+b0fn8y{i zIsD)T^OBNn4o6^(WR(JFFt-~Q@Rp@|)gbkYJu;?5cG|l1X3rsMuE0>wvb`}ZR z=8$V-r8$%b?y&`0fvN34E#CZriJ-=A!fkWN*&^E<@}a724j<(qyMyAbpT?nW4sV(6 zSKTLI!U-;X1o3Wj*kglV_cs|dE)v91q2{n7R<)HtDO83t6ecV@ zw>dmg*^du{p&th28q#QuO5{T0;!{4yEc8u?oCYV&p|{qUvG#o^Nm?fCWL-q!|6%Vv zz`H84zwtZwhU5Z52nj{j0*HWg5Co-Kkd7#d0R<95ND%@;LK7hpii!dO6qFVe+b&>l zfC!cqv0+8sb=N|$tZl)vuI~DNK4;3k-$dQt^Z);!_x(TbvtPL1oH=vm%$YMYXU@!> z?+o`E*PAyKZ&YsrQAIqdmVvafic4j?ZJCLkwk_WokNtG?I8!-0Y4p1Xlf2r4f_?33 zNPGDPtYq~kp(E5fZWoHgFRxL}50PMf@WnGp9((zza4>#5!H_L@H`+5;gm=(vk)!@o zg3d2ohyD6Y)L3x4Zm(*(|KUP0mwZm!q;Al5+M&z~6Ho7N+dH4)8w+ z*Gn1qw&!*EfpFuLLs*;X@=wA|Q}(?A{EviNr~K~>NW3op zCfsk>$BzN_#;_mZ*LF!(e?TCA zSTCID*CkYxcG|GZDEV;`C?59u4M&esC)r_SPE+G*?}BbWpEDsgDh->;-NeMYg@e2Hu94&gwbj^Ng34dNa15^pkq%_MY+@ zpYAb9%0(lwKi=aRiC#+j-z=Pz^5=tuDM^^}O?zeFdiw0%u5aIhh;B*saE)-TV&Vy5 zw~@zPf~A?+xcw=q+o%TkTj%ZjL6phpI)&&;-7aUWm-60I%IkKqu6iD2-EHi5kR-{= zVSDKVl8NsDz*fY%VAyTkXNXLzN3f8Qxn%*siHgVO@l<;~+~$6TWvp(W`^4h-NUs*Z z&<@$wax?I|ziu^yJAvX;OTL)DrP>DUxTG3ib_ek^=JZct^fHMVr|EKUZ4Y7V1x)!V zvGQdy`U;3t(&qNu1O~%>Ql+9pNLnLg`}JUOiA1$^QRFho%RT!RB%3dBJbPa!GjU(D za9@Z_V{M$5_r#gtc1*Cjf4(0SS4k_ljuf1&)?x+MVi1ZLMA4oYiWJj?>LF5zBC3$) zR@Ma3WNAYONW?ENIEX)~!sVy8L9kx9{L^s}D4rqN=3Yr<{wN~yet@_#$8-i46|lm1 zXMjX`xqo{V*zuwTULl|*6t+ecOHKsGYlVQ93+OtqaWHV*8VgI_I8ckcP1Uud=JO=k zJ&ckz!eq4=MDcD0ZEio-!9zmDOA4w|<$gx#iY1=M^jDEiv&vme3HJ&S?>2}eH1Rd? z8_{l4CBCDJ7b$XIzZCp;OVr>hQBA1H5>a{~qiC|UI;Dd1Kc0{HjjT{!nxG|P`Mmt( zn-Fs+nO@fuOQqs<%cJb z*D8)(ty7x%fLF7TcEa`;NRs>5N+`d%XqdN2NYT9fUJnDig__{q5|JjPb9wn!U?}Q# z57~QIl8Mw|q8Gf0=ygoZyC|xr&fVRL%q7e77%!D7km${HT~=f6!ucQ#gp?OqL^*l6 z6E-61S;aLWK00bCAPmt-m*A~Lc1Q_wA0*w2imOk2;&e$#O<+KBld-_v?Ls&Vf-OQ4f4i}h=Z|jW%r;7{8@ev&Z{)4#^)cn74grpY`kJ4#-1oIHxHw6w|ucY z=P{oB*UP}uRO%&-XoDv36e*4^Q&PTugMvCDp6M>%1DT;Dv2gk8a;Agpoe+Rps?Kla>lsWns|iaTeh) zdOgMx9+fh8B;av`FHPA_KG}pbQ_dzIaYsj|B#}=p@ncfA6$9o)ZaU=6*3Kdgg8d&4hYA3%`ey#~l3?Y&M2|GU3om`v)j`PI+0=&-@*< z%2(E!|16pmLqD4^=uZGe&pH1FeYdku0a)pu1^Vo;AHJtihKm8nf`VRE$UO@c(lbR2 zZy}@j1^Q|Db7iB?FrVmooXf=zGp^2t@7Rs-2j+{mpdPhNzbnG)|q!{ zXd!YxUx8vb45(IKts$G|^$z;ndr;v$$H|O?*KI^@y_Y)@V@S^eakqE{haOB>Dr4#w zVw%)5Taxl_j;ir9`d$KAe)4xSj-}E?kitkgioc*LPxX0~hc@bY{2@!vnKBa3=n7lV zbGG8u9<^w|y!_k%n5|TB@)96L6hf#Qc82`lGyYMkwQWMYW}g2N-YfLnbqk^g|3Y-` z!*G>)z9_YxW#hfvOxXIKlSK)o#4;m27U{8j=68tC)k<*jG8E_jjaok;VB_TWi`agO z{K4!C8`(Zza9QR5)Dg&6iRAu_sCY*Fr|ty1w>TDZ-$u3Q$t?Ufx?SAQ5k-6XACm9A z9F2P?#!RT!tD(9J-45uK^N!*LX(KK(cq#uLt-M~1ITuFv@j=n+cqT1r|0X8?H`nO& zKFn^H4P3@ZIimqk8wq+Txmy8m;(|t)(jV-)+{Q*(57ko)Tz1H%0kL^pn2;$ru~QHb zEH70NY`T|L<1S3viYVBO6MABK=d9oxz_s{=B)o+s|Mt&8@&$9?#Va~0*B=k!UQ!*r zhs9v?3xMq-SYFGbvH4q%2UZq{cu9*P&3+eL)1?*g&K83mg`U&-Bw=uk#nvJOVJLR) zRwgTwe#gsQbTgrBhQXEl3AzWU7G7Fo zkhjzX@*yI5g-uK|GwN(W%=bR8w9%Q)7y^^id8p#;HoA!Hj#va(2=oXs8*LJzr1aWc zO_@6%+@7Xl^6Lx-{i{qnnBaxQj zkU?7TEl4LVI2G8wqFf#YP#8W0xG?;ue0M}gEewgDEHs6Nau~R0hrD~HFw8}4Dw{`k z$jzE*w_b$K+w~S8(sH&bulLTMkW+T(rs#+Y{rk6?_n#{6bv^am#8i*b!irQ4axR?)vNeE&X!`OV>pcP8i| zN|YrQF~1ydv-`-1$Ga3_^_hF#vsiswCu^ZkF^Y-2+}n|3pGyVH>lSp^(ZVEQH0yIS z*>ZnF6r*dje=^!fpEvnUa^B9Ma}&OeUOyADEfoJSnzuH@gz3K?>hAM3zZuKR9O8-p z-5Rld75^}Lri*6C3qG3y$Eo{8YcWFz&O8m69+%-aCE{!aeg6RB)^~;|R_l*8;N^Df zGqE8Vv7Z(q5PVRv27cR_>+quY@2qB3cRybo8@T;S;E!tjs)fKCcqPst3XW-f^TnX~ zM#Co#j^I^SfX3i=e+B`+)ij0QfyThke5d(*KpF!- zc?>iLUX}{{_nPL@uD~1k?^t2Au>TWi{-J5Q-2=RVOS?z-`G1b^$Gs52E${{~_(7-r z-44M2)bR1wBkhkGUOfWvPa2+z*X$O41>41ge`)-cy(0ME6%pLIALtED>XQ*XvnZnZ zI0o1J6Y&4mJO{D941BCr1Sfq2z5T3dGN%D=;Cpd;n1P4>T5hYapOZ z%o>F=8*Jd2gGle2n7nI2W&=C%J3JRC`w7_xhHU9Rq_Kg4|BMA*J{k+$j~~`MvO~`y zCdn|Eh_>wlS5p%;OiaP&u|U=$Ft9OQpFm8qA-lF;EYP|#7U;`oUu-Bm1*mmLcne^V^* zLq#kwZYj9cGpxJ5g%}&yeIyps@T6GGx%jc8BkMW@fi%NlNC%MFK)b)iVj8{}i}A1> zD5!7JT*HoT1C9O=iz&qZ2p7}6KVs5NntV128|d&=EU<@WGQ*Iaof!+HvbJr^ie=-gO&{?Z7jN_@v(W@5kgz%c@PegR(fHz@{Mk8us zmFT-TKpmMo9jRv{>c)g_yZI zE?P^mWh|mUEkSjuzar|hD$zZ15dB$)EHM8!qS7&pMrDXg(cv(p_}dlBK-daI-K!IN z&6o5Bv(Kk(L5YVT{<2@9`8#{k7q4N7LQO^df?uFHeJg&_9DKQ=J@~Bng?R6hmj`0x z51OhBXrK!{1J56JDeY+saaX;@BnVomrE_p?!&_kSXR?_{eKr0TtJOgp^$Erj|L;Km zWTUj_)TAB`p$poo0rm7&I={h9I2RpH%|a$`a`;4WZl~6~q&MyPT@iIw6y2;G(e2e4 zvrP0zM2(K3f43je9n@+J%B);}I-;(&(Y3e|XusqZyK`nZ$|td9L<|> zB6Yp+VhFFv6B(dBU48kr-iGf#1Il-Pftu-XM)f72?y4RyHoT95G6ip#rEs;X@~-$1 zsyaiR@}=^|z^U?^g0fR0wRopZUSluquJ--g2r&pm7dt{-tSRJh*mTEP~=y4~Ao^^ye!=7UxR8Ms+j(iYie?k10 zj>eVMn|bHOVAe~W@P(3N0sH`pt)dWk>hv)C=MPBslD6(F(mOc1gRmCsNWQ%Ddv8VT zz3p+&8Z(T=U{=9anjLcYRd&czpRz+T%nsRvvt??M9rDtNw61q6ukQ(5a!AWT?esm7 zOEWpQlz1MGyq(2&>=+KS!}TC849`YJ*&%;Rl^yOvd@8}hFcqsZh2ehr=I+$Ou%mqM zJD2ci`PP(7gq<>zr)Rfg|EgCU$9{!wVApHDoG!kjFa!jSiz z6^6W{tWe4{S;}1~-;+b$P=?YYm%^}U9Yp4q94t0nNd(c^Ay4&#vJjaamXm~FVfc5+ ziKibHhTLR^DWrVg1M0I`#$9t%xvYD{O)WQRPOu22dw*}%li4s*D@ zhKFRxbT$n%*IkdgC00(!VBMwy%dH=R_&79CD46V!o1_ZEFF~5hnR<4(M4f;r?FM@$9J{Z zbmR;1jey7wZ_Q>pU1R)VYPKADgO^7Fr%xc}27J#sd zC#--i+kH0T{qhlI>hr_k_5>S1&EWk%6$!INioeYn1(KRU#Srueep2ZHrP4}E3udge zMdr zHFAkG#ECQ$yj13OjiOhU^urpS>4(qHf&4*Bsl5^VzwlI%#(NA}`oT)GP}&c=|} zVjNUMob(W~E(~vFY90r4Z?)9JZE9LKlbSe5%@cu^Djs3#7Xw@?v{g?ly;iYLGVVGx ze*A145xT*^a{zAvj612pJeBgLGMnqwNMKjoi6aq=JpXj1`7>gEz$1s4GKCy1%2dk~ zW$?=fE>rUb=(kK=4}iVEyFu|N)#NO{)@Jm3Jdsq_s#os8J2ccZGA8TH2XMT?eOire zUB>4k5zjYTrpSWD$2ukT#zT@mGUSogmw-sNA=CaFy%8sRBcG*;C$;+90KOu$&>Lx` zJS_ugd2mqBm z1wd3*7{1Kn@r0+(@2}dZa)sZ;)8vRJQ#|6Nc+9LY{Di4_`qMwFrM}&!=AdU%6DO$) z0W4KKsMdcT;O9aM<#5OpQ&&?mu1&Nf?ZVR?7 z;}PW~WU)*!dr{8o0zf%`1z?opW89p>qpSP}t14%q@Pl$Vf}7$IC&goCOBIjQ_3sAw zg3zLPY{F7JCaPXM(%Ir21gv{XDv7UGOM%G1$zAn~C{gih--cyXJW{-bES4!|FU5O6 z02FTz04d&$s{2LBUZt@{SXP#g+As{P=INn06IP2;+oa*DVXoEy7F`Y9G|+XsJ!Z9n z@^uTAsCmm_REH~0Z-erc3zqA#XoR8}WxmVxXmp{{hV&z2NV`qLsclK46@9Io*T9;O z*v}eX>LY-ctKry_o-{^1g+R?9>s>vJEm!{CKu?lQT7G#yJ*@SITo^uvp?Tu7LXDlI zrSBtQ?9)*NUQ(W<;ecs|JEoE>H+!ip*k>(?tA3NU%-7biT6_@EC*4s^=B5+jHN0L`=GUFfM#ML( zi1?Nf@koM*9l#%IO%Rbd5i!S0W&Vp5S45JU`1`NaB4U|9K5D}#MDN2>rJ`rjm1yEy zU&5$Wzx$(Fjff}s#(OX|f1QzBH~~p;wK3rl0UR)MKq0(>pw};{Rc|4NFO_q zZUFiB)kS*mBiM%NRYjU!Rixr7B9$1CK1~oQ6Rj0_smy<|;`&U|E&i>u zw1_V|5j%qPM?6xooK~>$FHsM^4iRth855LOESL*Baf^{}1ESmDP^zR`eXicnx@l`u z?`~0!kz~304t6zZlf1r$?Omb%VKT>#c=@bU)4Zh3Cca;}>NJz)Z6o#;C2jHbd;q3m zIDPorj4CphtF|yxNp~1ocB6&0#t|n;_xhZG2IadD>!osCM0{n6B#KyoIVs@9ii=Q5 z`~3VlS`p_uMf5=QV|bh*AhXfKKA#b=s#L>1m-Q0W8HW%8@dRRN=d>DLLkP|ILR}%t z)f60_mh`MCK$a=cA5A#l$p5Oy@0X9)!bc?_Hz~m&FZC(Fi`6?U!Q1|}xw-^{T?zh) z=!$z{CD6uLs`720F%*(zc-u9#CF-LqA>KQtDl1GG9tJTyc~^!KjJQdEHB~iYg=)fE zMDf9UV);l_z8_U}Cli04i8rPG&{iYRQ4yJ$6!97_^$x&`6<70;zVN>@Ts}8k)Q0yE z-RJkQBBD}EC4J#DLKnGVef0S+M4YHzMj{&Za*?f<2l47D>1!i%mJEe|H=)d!bWA4F zjqp;>1-w{sQ84L8|HFA&2k89rQ5&v8^v!r;O(>s}XAs-T^J2y2!X)fdxmu_G(4~GH zDO3KCkQ&n;sl6~@1V&C)UMO3R&^mQ~Vd8gi??JUg~jx z7b~txCS?Sf^M{BKk2q1zL-Y(h)e4ef_)gS$mw^UD{m8iOAx^UC;iZztD#g{-q!vNl z1w$l*RxX=AAo`DZs%6u{W&R3Svd+ z9x%d)(%p)(Qn6W_X^NS*T;=q`SbvtOSu8WK)=Cu*gY8n#U-D_~a%-|3KQ8$7^Iw;! z^BzV^x+mgkpoX;p9wc$KauEZndA%NBf z=f21b&*5do=yWU8r6$#9My@h7c_U^W19^Eeid&|ZHNsudgZ8yyFcTTlNx)*=2+SpT zg6*qw&zF?ZJo05^f0VaXS-Ub80b<=C$&wX zwUr6tt3jMOUlR{?#G665ttxS;;?cZ=9@h16rX#L>FA7%eMBXLpo3~MGMfJJPjPfi| zPmWVjc*GKQ6w=n3TA$0D)ctDQ;f$3a!#=9!wqQRCj}(b&xrkDAc}3bfN0HLOqO(+^?2RH4`U#<^jU1)j=>nXc9)%{3+rB zj3`pg4CvqA#-!KPOd4Iy{5|gcj?icGpQ=`KD-d{%akvpZifQc2g&I zCTNOn0@E&JwYO%IKzE8PNd8&}EFu3(?#AQK~oQAu>WA(-_opXWgU#&)Y3=>_2-UuGpv5ig(37WwOF0bOn9p@270+F--+-BWvXkr`umj#Z#3b7T8O2J zM`!q#fXfs-da;JkS}e|?ksbD@BjBa-(1=u?+ptcZ55#fb2j0=Uw31HLf_rMidc^F& zvrLg6RIyBr7a$8&Un2*N=P}*uq6YpE;@ydZ3&pV2y~f(LQpGdFFEokfyL`@h2#NM! z5Tt>W)O@pJ%;udbiDuJ=t=YUQg~YIZXf(Y4`k-MS_2vm+KNU}c>6rf#Xpb7&mQIxA zpj%&+wp8)t^2U!>E$llWl-|q(0^G^uwl@>0do!SsbG`X5h?_^s#NKSiVb_~Yb-CWG!|2TvqEzv4s4rg99kYp3TtBeY z&`kg6A_izfE2!5RiZy4<{doC6j_1&GPOd0ENGI~J?0zha=I(T4~Wlr%m`)16>Yum zYSffGXk~b+|667l?d*~+LbBgDwO{uZ9AwY24}A2{=fbcY9QjfkD>LBEBR^3I$DUHf zO95Uq@1nW7#syd?RpkN~nu z$49WQ1Th?Pd|9n{@Y5T+wbu3gg742R28(%k5=Sy(V`B^n&=sX))tjXS9Ftm zi9xSS{Ti8=L2L$UXwfd6)8|g`J3)FFkF+3qQ*7rVYt7{~=yI@?BRs=Hm^-WWnkhm;PU#33Wn6RzSwkC{aphZ}Q8K0wiy#qu}fhYpT{u6y7UFDo;$9`QKOVtA$aUKWBK|H$85V}Q= zcQZKNd8s@Kd7b(_@CP4F_L}V0mZXU*^bd&PDKN_vIZ2m!T7WG09OhW-t@A)_@)C`24ISEteAI>~6J)y`-7e;Q zjI`;ENEb&UiU=1w=c82d;HvT`s@C$~z+N}1mOf$BvzN+iROj>k@is$W*NKz*1XP7b zIvN23(UpizADQZodr+QgS4lWG!kKFNF>zC^!?tTT zR(ib7oJW455;_*8>N#Y()HoJVm!8c`X{wpZnrh9#dMa~ukfxdkkInf=cZSGRKLsAT z;*xyA$P_^_)jWnQW~!S>5T=^W!)nDtsd^YaM5g*@uxRyURX2s$m;*tA$W&_ywW)3= zF*MaYy~=nfU-d>aGC4)2`a+Pdz$2B#nR47z)1UlJQ*HbcsD;j)4zKhK(KB3j8)Zkp7=90lrx^y3PWK?O)G&`?MV(@|RxWX(TH>(N@G@8=lkhC1vsN3ffF=G_ z)wYclP0HHNAS!HG+nKVi#5n(iVQ%%fQkFGpbuy*L0%-V@E_jY9_;U3|E7VxGlp97; zR1}Y$9CAKp2p2mIefe8*o?{hkT!C|KmZnC|bydDX{mHP_l5pP!7hh`iH%YRfB%W~C z=V?t48KyeVV!u2dsUrfSTb^)Os@e}g$2BP;!!!m&)-Vx90;yCOCOs~pzj0hDRlEsm zo=G1WrUOV*eSEft$&A9*FzKK(Oxn~|H%!GaOm~?9HR{zrGbcMJ&(mr1&0iWO9t%0* zV?7L?;_Bq&KjN-GJfaajKGL2{!!->&8j^;Ir$N#%&F86)J4^|qd<&6!F&;N?RA&{F zf~WarJa@k2e~y#l4y50YN0RCZ6{RS`r4rgKX3d*YrllxV6)67tS2YVP^~y(WXz`p; zG>yG8&_>ahnVG6lvI(USfCvU8;EZ*Ysy}QwAs>wV~1eUzZ8D zejR&CG;?nX=t2U9N-BZG5WV_2}jwc!{D zPdWfWs@?n}$vJU`5DV3EoP}3+uF>~GwI&wq=gsG_&;K;7AkFda4Zef%#9BcoEMaZm8|Ql0Q2i z=l^Ey`$64~xuO0!2=$6dbi|cl#0yB2&~?)>WSb_?SgJhMHIGkWEW4%|)=sd)+H%zm zrykTg(KZrP2T$UCWWUxzWXh%?!_|01WsyOpDbt2DZpz*~4ZoTY>ay;j7^E0LV=q@(Gl}JirfEafy@G{j0=t2Je9{3e zb<~eXQtDsp$C&}6qkcR($dqurAD1d#6gb8(M)k=Dzsn%wgw{uO=$cIXo9+=9?x}1Y z)aH&=nfAF>R)sNtX`gHJw{k(6sOBqbrc4*{*a0Kad>)?O@&#SKrcR8cm%$HDf;}l! zysPkhL)_O9Uk<|RcM*!YR1+EsC$(Yfs}Rq1v0uJXF(OkR0;g~_3_%V8^0MRh72leOh; zxiocpp;^v1i&MBJGqFx>c;Iq1wH++NDBmu*lqz1Nxxr){HNkhSxNN(w3F?N-Lh|~| zM@*`y37-3UT-@q6X1XS5#!S;g9!gwGLlca8NXo^S4IZkh&8f)9X#THJzu<+PQ>$tI z4$!)x#uTNAY4mih(zD==n;as|pY%qxqEM&q%2ZR7rB!;94cp#i!&dV*s7UjJ;B(bI zs2f$}bB#pCRei2o*#$V$FI6KU?I@FItkMky9w`(3hc3zAjhbRf_Lsb19znC)m6gVyy| zqvpOo@68d9Kn5NgwrcKc8a&io{|Pkkfqn(_L?6CXt$;*rU(>ln4gCI?L{YQ81F8B~ zqx~4P(t_A5T?^7}lsW82s_`aO)Pl0!s@8&-r0Q_7)HHV6cWu}f&4#PDp!q2mc;0#M z=)RHW^tS-{-hf92I|5WgYVBLG3idiwk!?CiWX5)b#+os0H(01^Q8||w=Fudz`Jw8S zQ=$?p$A)bQN=zTIl`~)2%2}$mq9OU6!E_)V^8yHv@e!`mJ_0W!U8k7!?=DF8R#vN@ zD-p8@&oV_$;v@7FfIh-g$l>=UNq?uLM-cx39_Jc3XF=3PX~ajM166m0ZnE$Z#AR5) zgxIL42Z;H1!a{y+GKgxS#@o2U1COvHAhmEVYhgGvt6tX)GOC4hKx1nmYFZD2Hr3EZ zwQx6RrHgQPi0L9FY8e7i7qQ`}7BtuDwQ!@##zxs}v!}RiN3A5d(#U0r`V=#Pq_gd| z;U(&Oc+M_7(7RQo;*QuG?$yO<;1s-G?c1b(alS$EQn8xB#Qwu1c7x&t!Zm{|7w#b8 ze&&Z{8`PN+&Uf)cBwS#^8`TCFmMy7Zwo!cp@QVfL@tf2K6EPcoQ+cKM%-*a%M{q6t zg`a=^dBH}Nas^uRAmz2JP=f$AycTyis0y_V@N^KKm%dTG1o)P^%ImjL{Qxj|jPe$2 zQk@|C2{^*9v~+%j>WP5g2Rsom9q@t-%y8^y!4`EjaBpprJdy3s3vN@7-hej??f)_& znLEB;DiQ_Urk*DDl=mkQ>%C~PuMpepiHZQa2*SN%Y3D&=&p%7}X1NkSN$l{w*O4~MmEr|rJNUS08dz8JhloABi`22_ za{GwbE;EOd_I*eD6|pULk0iFK)7g*2o^yl9@V+ZW%5q>^eubNqk(;AUC-&68?IO0H z!=6m+dDC#IGx)kvv?cb0pY9Q?D{*&X&#uI;jL^|JMdB5KLi<^9(EDi<6&tf6;6iz#18skIcfJg+Bb>K`uokq z_Itg^^zILd&E6t<$a2`Ph@J3*w1-lM{fXF|9hZs>4qI~tuoI6;DfT*SLt@7~qD$;7 z!70RE_R;MknZtG>_VQWMyWe-%-o%c5=Ni&_j_+V%$JL!jY*UB5l-NdtrN5Or{Z1ry z=BfBa9Q5#}E%BAa&N@v>@xH^(CwBG=>m|3hEbTI4=Y0CG13=%HUY>^sC>F=H#Sr4D<9*rF7i zO#~Sn_875~yKAjGthW-_DKFs&0O-MC>kvEj(D}rAP7h6po%ZdO#5Q%WTU-6&%F zIc!&Ar#F^1ndPu&6FcKZv6H0^JDk|!4O!$+;jotxd({NdWIw0hd}8N$<4K$4uqDJ^ z{liVfmOAW0V&{J-cBjH&R}i}(=T6e@b=VEWE_@I-)1z#MYz^H*?4m54o5MarY+0&k zvY*2~P3$!nJwgti!yY8IbY>~B@4MXIBX;rRyNE4yw4V{XoqlTZ)s2z5bT5me*k~B6dZAvbiao@he7tUbZj60_*kKcOFLaW9vEpzpHymqcl~o5&Z5mRS=$4yJu~cje@h(k3j9(HdrG)A((uE zHz>VFZLG=F!EvJ`(!sEU>U+FK6xHo@{6uiASp%e9kH?!y0=VeVs1r$xLlF|3+5%ak5R4oas;L}xg3jiR~{xXP#pFabjw30r&g%H8=o}N#Bpxv+JxcLAiD0#ea8bkw9ickv@I(!q1eKh`deQ=% ztU>GrKFed3GzMj}(1FbbtU>H4F6-K?CM!{kI6BJq)HpgWXv^vmmQ}0jQEUvY<8{g! zJq;xZS)?|d1ULarqHQ{gsT&23{W;S#7hHGl+F%XpyMxQZ)FCcEawsVmsX7Tt+PJQ1 zB0G2R&`h0%DM%OHqS+)*k8{y#z;0#J)M`*zTxCtA;~KC;?vc*ALu|>@G>kLY_ zed)~BNX>$tB|r_lgccwf@8kujgA>_Z_p8xGI%glFIpp8>cxK(#Nr~cHDf>lIvLt86 z6Oo3wo&%&5ot!N4+-j5%>pWKx2=q@vN7aSU5}mIFD5~34xaihCAflq82SzluKMZnm zqmFdf!^?Sxbp6ruh8UT|wy-!u9Tk#Na@*R5McQJn!=u8`MqRLUp+XffW<*CZAQ$S! zc9Q7hBA2-KiDDc^GCA!T3x<86@mz<3Mk|}_E=i0U);JzHDjqo~eQ52(=u6|#y^g>2 z9Ag$T<9O=F#f;W5R5+E17q#(nQq;>_T4y;Z=H+oTr6+Q%7zr^4<3s~BXmA)aK4NPP zZ&rlrfwqvH*nh|pKbbH+81XpveMkO|ll6YkGmNQeLV%Q>MI7Dg?ColRSg zxj?zp8g-SWVlwRiGeH;|&E;yTaAB-FEw(1cldygkNR?2xVz5e82k6?0!n(XhwSc<& zzyaZ+tbs$m{Z9oRtIhJ4_7#UJ8Lyy7y6qCB)FA1bOI0)U;Etfa7W|E`A!0Iz>y(pI za6DPeQHe@OwG7;YF!DNXQ1y^M^Sx2^g!;JU;v9on5pk6C+@#qOdM;OJFQP>4_^eV5 zjD)Kd*K614e2tyeJ?^GRmKqv!a}2Xop;uG9waR)mT%gzDQ|WOtdrOp1I!oNR;Fl@N zHCm~P^%T~6X=u|MqSVqmXiGL~#UgeS^EXAqz6OY-$GQrs9_@f^fm#Nnr>XiW{Ti=5 z2QB6{u#6#Cj@uO-J|C@eD*3<9xF(xD!q%4kNmU!uiux&@x7TKGvfEdUfho{a zNOB409#6|(YTy~egz&RS7IkZ#x5@dB>RJrs)P(0fXJIth{SGFB=fMouti`0k5rqh8 z6~8Fb+d{r%i!8nWWn>*-a81bc6}0pOBz{a`c_5WGpRXohsQlLi!*~wXp7%P!1EiAQ z5U5BTz&9-nkMAuDW6(TgVU+G|3q!~Mox*WI(*5lJqA6T7T{}6Nt~HIOYt3AjfGLZd zndWhH030y=q}OLxPa)Z?c6j1 zf%egSu7mU8#5Ig2Z)Of)CvV2>(4%8#DYTe5?TJvHE{XmqJKX8fe6DMCJz)wL&6NIM zP2L$pY+z$J&06Q_Ed2t|vc z)u(gUB*e!(dFpRrLTqAcPMtLG_-u4hl)^PjdiaZ@SwRgwm0glRnJD$rDshQ3)cE9! zEwQT9n26ajyBWsyZicZeHj}skly>4^{Ja~jSBBc6FSR`8xH616nPo05TKj9pyIcuk zovhp@Lpx!zRg#nSc5&E@R3KNT*Tg72kJGeYaMN!Fk@g|i#zb~r{5r>vd2xPbOXX$_ zw+a%i(0TIft7K&qumLWgZO!DiF~-dla}!C-l#V2uZP@6n!WIc(?CTNXm@`ASImi2U zn~_Pi)i~muqG`XLP4G^k=bVgrTF?LPs#CywtQ(I0_e-;}0bBrevyE+*8b)`!gP9#? zTnQdGk@r@2!|yZVSQq<#gtd$PfI!;Ce$c`gmLIY(toy?jM*fdj_`fc;86y7cVrvcj zpK-C{4z}?*&~f!>-^RW$`JXu0aXYC;S?y$3ai2RSIz@C4wVN#qGS(OTk8em4-TD7I z*zQHBcFfL?`_cmKqbr6o*yyO^3(p-uhSSPN<<`+0YaPvTu5=;{M~Lwl1-&fi915OqDx9lel`tXE(af=q=0xpi=2}N{lH+9@ z%{)4q`H7BZfps(s>1gV=4hfEC%q7-6aEgr+6P7Pm$7DB!Ut_&3w1Ar|3@_+r2a_|M+-hDJ zUPqu{u@zE!x-4t7(0MDu+6!ARkoLmp(GI}U_X+UAHd+{77~NRGBY(QE0{_z)U z4gBw2=yVHqt&9P79#?DYah+z?hR|=?xUn38w$YMiyF?$TeN}@Q-?bt|WLNti`()9Q zW*5g8T&(p!J-(#LTZ^GWEOZK~^Y}C|vppl)qSC$U7L^`$fmiQULGS#PMNa+tTyF^J z9Ur=wbsr}sMky<0-$+WXq4kR=A`P7e?praVXtYIz`&PsurLhr8h;^>ZLez;pD{+J! z@~bU(VzJZJAh^VKt>~h}mO3Ma4NCOD%$^nNuu-K$s%FjsGTOBwW3}G8Vf{6iSNVO)6ER zqlHna6}KT`OjZ53n1n^r#CH>yN2|YMr8sW;#<;32B4O_emwUB8C{4-wN$?3xKSsRW zvx1>0N6Tib6FXNT?z)O{o%GJ>qW+_OE2fnb8Q-_!Y=TsDLDY({Z^Z?~i~r4CD{evg zS9h(r$~NnJzwS6%m(S_nY+=z3Wnx39vWq2gAuwSdOZ9a??O{6OW8dA)q^~|Ja+36P z!tGs&W*~0&ik@9?=ZY}_I>}X$kFGt^XzvPomNq6=M>`3$2M)JVduKYhAey0+#&)G# zV|Jx1bh}c@s_aTx`J-b?Mhi@cBS0l zcBR}Hag_92Bjw~|MU`DCE8VV?a@m!_B~VCWOsg(FJwz*=#+bb;BCngG+!WiD65Fax4&7IqdCUi8<^!wcawfLhtS)0J?l%0kAaEj~<+^r?VqxPESb^razorMN=Q+ zcXE(DFRB#IuKGtlY&4NNA4sVwH<1G6fNGSG&`g79##wyw6s)(oyBaiK(Xia&fT}-|>E)_QE z>$T=liEGN2+BM}&yQUmXS}-!`N*F^w^)e@b;N#orr5G&Y*u*vEadu64yk1kzvTMrO z^wK6chLRpr4^trsa#?nwT~p5GnzEi=nEKLU<>_|EF-{}$BZPC<3QS7?!$MbUW)^q_ zH5APP%^J0x6zEr9(Km`&?$#Zc!;I;R;0&ZhkI8sCSfSPq(>(eH zS4Yheo8Iki*9F!^(2LMIH|M}zBR+=pcNSt4kGvnf_N+Z4O1(&8qwr$!in!_=m5!(S zvk0WJ#kkg{GYXVNXVXl`mpk9B%8jqL%sN7-viQCWw~66KOMt$=+`(+%+;b6MT{j%L z+rrusu15cYgM>K;N}sT1yxNM6iqn05jZu+(mwyw&+GV;~Aiavb*1|BA>nsfW$u($k zpCGnge+K=3T_$5M|NAcg|Kz)TcAo!_w#zyrkBZfH|9`x4?2HA{+mXaxeF3Kb~?Urm7;}B z^9#olU>z??Tw@&Rg5Y|wE@|AUy~H^SvLrbwl1#gJmqy-PW;8VF<+#xn5qWcCEK0B7 zU1oyfO3?wlJaUHY)MIQs3BAT~k-s-S^7pc|Uzcs&KD^hD?@rCJ4&FrT;KkN&t%ElS z1ErVeL=dSwFLI|aKw-y6n$GFE6EyeqVWH`zLPQyecz>Ul-<`1n$vLo;x!%W2lZ zyOIu`UV2S%@M24@I{U~SiZ%_DL=Il`&R+Vrod(U4lB2cErns^Xwu(o9xAJ!Qrq2*< zf|ao&!H1e>y)M3>H-%vutfpF~&X2$=`pDsldq~E^;=6k7%~Wxm7TU!bXo}3sFtXdp z0K?i@vX0ea%ce#ZHsU+U`lV*0y{E`?vf^>oH7bqvnc`lK5qBAgv`47Drnno1rP%6= zLh|B1mOo$IQ$+rH5Cw{PY30V-)0=l*+hSqp;WmM($fCOBo~|ael${iPN&D z7tiUKJ)?NerzTMy|%>PB26pStV|9LslyPgAZPrH;^_rNc^Wfi z>P%B&N)wmPz{NQ^aSa*1G07uL&eS5XF3F*OpwwwoQN>YtCQqK4lc3S;L=03Y7-}Qp zSyEI`R8U-yJ-J|R?nI4-qET7kW+;)6vghY!Ptyb@Qfot_D2U0NRRMN+YycBVCQZs^ zZs386E1sU4Jw;a)H8g3K$uVaZn*$@z#!<>i1=JpzK<@0E+-b!HQ;Vo~ofAcwmR(>% zIWvkU78DgrQc8>#PcFcssami=nnzU5>EkCC%#buQ=FBM0oiaXm`t+$f`&l_G2@{sg z$eod(257vvWSY)EH_cc(M2;+xab9 zs$$aA=~Kp|JmV)qKwaMH*+mnlPSG&hrZnM%YA!07k~W@fO0!_E2_*%Si`y3z^?{8e4f-aCYGM(Cm8I!fR1N8RFkGY} zG&~L6Iyam34E9ECv!+fb0`;rwNk@(!Fy2)?Xmw5KDA%EYKYQd*vPW~J4CuTiaUrs) zHI#|!)dC|hu>hJd5zL|}TcnQ1fHBSi@_W|oPrwU0s=+>vBT~SfZE<}g+yIMv#WTnx zAEd)9x-?V^{gaVCDFC|IqOb8)*r%i<%oE;8Nr+o=-g!F5@0A*MEU8BD@ca(jg0#ci z%fs~ELCp?F4uze>w28RUSHYD9BqF9FJ%`@`P;`RTiYnuEg*N5UQc84xW){suMuc51udJR>Zl z9LawB`uJNz|4A+e9A+jD4G)D2#)j91GokGE8GhRg$y5^sVK0P&~vkwQY4hKcy;Gj;}E0~05Hl9}D%Fm%{zj-?3ZP`#V37aPG007C_ z)KB)$OAqrBLVdy(m50KTFh4Bw+c&5x*+MNDs%n>(&Of!`5iOstIV)d`@RM-N4!=eE zH(}+WU|ey~GBa!*mc3gUHWP9DGpL^+T$mhYgo{O#aIj!D;X8>6OU_JQ6b|uEN%y;^ zhwlQypC>eBW^!;vxG=cj@Lz*zhd&D5^9~1pSP*Ut^Mm>*emy)VhP}eGf(!87J(z~? zo*)WWejgTB?h+PgYVudhkrZ}7C@DFdz6yU;atIZjlF=-D_h|S@{Qtst7w*9$|Bm|o z8d`W^L}EVnpFQ~OYJo@p+JHqET`{y(WxA>>A2rAj{zykW=Hh!c3 zw9nXmYz$PPV-F{Xy~k+jGLyqGA?qJ$+A>WIziWLqz~?UyFALxH`(~Kl7LN?Z`rXxu zLEFr5CU`dVPfhp7HiU@ybv7AoN)A~EzTdSTjL%A#p2I;VZBQ!oFdh$DACTe7p!VUg z_%o6whi@_Oa4=i{oYknaU{=T$FAWbWm=qkhAB8%?4!k*BRJlFe6%H*AhrEC;S|N0P zJBrWla|G72d~6eG;o42D* z%foATREC@14$E}g$t0a_jx~ytFCB^?cyuL?BIBHWgM~F+;)+ z{#GLCwk6Xx56mb*^)&M{GyDk+bs>W*{VWw^>=!BwxYRp@K{m9hpM<+1djjg?aCBv` zcELh4yM5u_a941O7!RaD|E}qurGgIO%JAb|VYAL*@35qENCD8SX}SaX)~z9VG~!W1 z!dz@#*c5OL`L=`N5Onq-L%N|#W(l1xMwbk~efk*Kgqaus!rqsmZLsqF6D;#%E0fpOJitiP-|0V*zs(%y2=vU?vSDb#sZ-K2TOZoj4R*(55^Mp3Lsa7gDs2aAbe(BMOa2L{24BOD}aZb`+- zqlQ;j{7N=q?+WCC6zCMcN>f%5VrXcnSpx_Jrq$g-?VX^k_)~T^5cF(~%?nUW|+F>W4?+;IvDJEFBSX0OS2^zn=ZwEe%vGC%%ly_VXni=iDBOmb-p;UZ*heRz>n$!OT<+j! zFKmhdw|9C_s~6@F+fi$)G+Ab{-#x=`k)gXWGGeO?!kx*OLbsr&p*XO9w-F8uBa;0V z(#>J3E`Sq2;ryV)?}Qcm{Rnpn#dkqhsSl4*`dME}-RT9}H~4_f&x z)yI&99IOR2W>x>OZotr>q6Yf$hjZy9TGGJUOyDpb92#sO&5;BeYo)8QTSwB*=4Qg4 z25Sg^so|A`k81b^!ry85TEhR-@FK$hPROR3D5a!Xc-3!;`%@BVmi#u&KS*=^RU+p% zgqLghYr?BE{5j#9f1A%Iq`4LJE#Uzkg7=-57oxxY_W!cHQ2$>PjKetcQPR%fDakTy z7VIL!=WOT^hF-Lx`x$x_q1G8CFdNJbRRoiloaZ-h0B`%PU>kV-Md*WyBsAL(f0KGW zsK3(GD@c9pH>g(z*Mquro~Z2K0VG)j_}3&^8T=6J49Ye27o@%^ff@p*h;ES)Ji|=(Xm~H-r!>5q@E|JP5506ZzcQ}4ObBUP{SJtAJOnS!k=k)4dE{Z#w2%Xjs1u-z1ZoFplqjP$$}>iw7J$YHg!yYQAy&j+ zX}!PO8C-S(eKgdhX!+t@KQiO)n{VNJ+_NP8H}=SB#!D zI+&gr)XT)m$@3*;WtC;K-u62;Km+a=q!pvW>FEc@6$di~x~lE-GdqPHp*uXsN=_M5 zk$0d(yWip?`+5PKu3Scds<^*-JP)C*T0rVk8FCpAkB9?4#bw^;{H3itOK9P$krE)MbUb#KU& z+UX}-^gfHm>DoK}fanxZAGGLel-lGAlMv_+E&6*;eM6=C$*fMi=izs_5#KeEx!RCi zoIFOqfvbsR=hZUr{0?~PnBRn%5M5-^c*R%dpJ>r*Ec$g%9mvBvM)UL`5wEXp?0e)T zF92(SSJT=ii*G%=7nE`^i*^=$qf+R?Eo>eWExuf-MPbGEuz8f`ZX36rajO#IKC^Lm zD772Cs5NGXGe?KbpO2EyI?hOPP^n!sQkx^;pR#d(qPCB>(tKjk?}?NSpHauKsswqZ z-`~;~Tl}YxVpmK#t8B#AN*z8DcHD)ju;Z3o*Kqqsl~gTk#8O{<6LyU88*XE6^3_rB z^E;(S{0`X2hw#p|V}$?C;ve-s(AdA1=;-B`T!qi6H-EAWtQK-^X z(i6Scq927)(9|$79=ubln9*Oyqjg)W19ZcBCiiEk`E)X?3-lQly&=V-Q-L03(SP=U zmaOXmeWgXeeyR!we~eX&j^TFQ2GbDzosB-s_AFhDsglx6)=OLB-L&70dDjPixW)gZ z)E=D)(S;U$XP|a}gcS(Mo{f2jjoFiA6A*pCqPNzF3tMT?`&+7Sv?7iJb-nsVnom51 zx80X!>5&>w$t#s058sUA7X9owlwI1$8^hLMn^3AHeVf)q+FFUFCYOW z@h#+#ys%RKug04u{67@VG%cESRKKB-^#xZ)=|DHN=yyH!Z8+>BygKgJ9-T)F3DezX z38K2C?(ehc53xE|-z*HA$AJ#bawZt$r-$eJy&L+qZLQa9Yy@}$y=E{=f%O6NYGw~Z zAM(pTLsoW|g#G=_jr@8{%%*h8@h0(`tkcGp=TM8ju?8C6NtSxLMSq0mn)wMD>k!*q z$?TstdbPC6)0vD#J-f*-s%V5o|B{N>a9^_o*C)g9WsqG4&_^x$U<;@ysChU%rkj@Z zf!~?DZcCz3Xm3k&v&BCo_|BHuhZbLz84J|s1jB4cweHEhp0Uw8YeGI}7C*D--N_VT zEVE+OPB_u(I$0h481Lu&hKyoHuiB`ukWn9BG{+nopJb98K~FR$j`Z^^eg`z&NjpWC zqMDW8L$6TD0zI9@luW;-)q!`i;dYDDC#$EaMJKl44i^1u)pMUE_)y9@z?QRqQmCloC<& z(H0$vPHUTI(ciNZeS#%Fz99FHV?H#}UUQSriW(RpDs`u1L>n8iK2(cK^ccW;=w%&8|UE&s^J8bMNKH5QD=E6jKE&63=^NIemMgQo5T5K`V|FGyy7)-C}J%c+t zT;#x0jKE(zBhwIRMp^V~4DpH24d}L_B*B+$Ey32>YDuuxww45IU$!PeZP#`QTI*X$K>H@#z;@l; zHbL8M-TME2&&;{M`@6Y8t^Ypz?DKhexw$#>cIM2PGiT1soHGkcW?D_TO;a8+D#FQv z4=VTtqiqxXLj~_4Sj6-gfPbUlJ1K94=tlwk2L*2cb!P;}v%eI16UTcb?*ox=2f)^> z--C0MJNCT(M{{V!9{YvcX5JW#8`au@CE@yth9s`hP@AbSH?K2C_60*(4+r(g3BI0C zGJXi);}m>%EY{~|Hj%$p;ax@-$)f?jMZtecQ=j1b6#UkZSf3*>!9P%Nn45LKq~Mng z+gv~t2|wcmkKz-SYD|s0h7+7p5RB0*BTw{M9<#CF_>udt8bQ~YlcDasp*il6`Lj?< zUT~7qQQ(USCjmMXo ziHl~U5>Q;&5}&*$Kh`0e4Hi0Hp;E}MuwM;Jv6GK$`UAtU7)~hYaPx^3{!x?KLy5(H zo-)NZl-18`75)MG$#yTA>g#X8nvn|TDUY-({0ZoEUAC#x$tq661DbS4JjU}ISQ~nEC*9J*ZQJON`aC;hiY1GVSMV<=bf*-Am0qbSt(2j>=P5#z;`K|K z1U2<7Tj~->p(i!rTa=er+0t@1INdk@9~hTTT6ZSfYh3a%D0rePkKE$+ z!^E>)GkgwRT*$-a&Y+A-x}MgFc_EK`^P%xXe6L&6Sn`pN`IaAv#oQ4hm;XQxVe{jj zKR9J~X~u72%H9bBK&6}hWar6e_(~qkgPJVr3G2Q{!H~$<&*9+AtJW;@m?pNdjA%h* zfZYo207`+_-!@8hbkCrWd`^t1&6s=_jm<|LYxc7*$NI94vy9Z3Vz(g z`cpW)42NrrCjAac;m-0k1^<~#iY(}?zfZv>u|}_(aQPon=DYMW6T|hig&^rzM^dJi zM^bU#$29=|@;R?azrSdPDE-FI@U=$iw@|?$ML0rB6ugVn#>HFVNT#%C3O2n5Y)1-{ zU(z_G|Ey_gF-Zm)Gt;;HyCE@5!m{%*CwQ+qj{`Md6Uo8OG>7|WTb!7nknPY6_dqhQ zw^envzqHEs+muPJGlx~UeG4<*ILkNl(&117Z52(4=$x*>H zBEh2b70x!+?YBE{4Qf8|&4UDX|Nx?At_$f~Y ze@4N-$cy#u$M}kl#Cbe=o^K{xJ6K?%T*$O%);a80 z>;0N7TI+WeoKY*WeqG@kp({8+MPlcj>v7v1i#=th)c6Tc{HAEqzfx)ldSs+Z1%GZ> zdh5ygv{~Wzg*p;P>m`L_Bj8n0N|`?>IFw=pzoX!-P=C4UodUytrK2TlTQ%R~`vTWt znc@UDC^%#ZcH#314!gikKcV1<(>oc0UsmvUq1o346AQcDZh&bgFYxW62=F;onKh|! zl)*Vua8+Si>JhJb3kRS}T3xK*e};Hj#PMx}^qFv^Ev;>^Q`Y{`u_$MDknk0(gA6zi z0>;Y?rY+U9KT@;=cw{*d*E3w*JsLSNHQEchUpHQLsYYXv^}~W+uBS%DKK#!GBFFC7caE zRPfKJ!pN?hJldn+aPAPiSHW+9M`yU~oS{Q6_9%tw0j1U`1;3i!@3WRt1!vSkTrO1j z*YhBbME79!l?r|xjn1?+RsC*FCc8YQY28D$2GNr(O3<5v>lCX(j!qJP;vVr~imL_JIhk6x0z&sSM z@YRLpA(DQKg1bO8-e{NWbQ#LZdd+a#VKKW{?xyotwb@t4EGV#bws6aq7g(H zWoK5}-<}dmqboJ_XJ~0P47EvfD0W-P3Vb;PU)EIE>3GG0gVj?e;$!M$HP%pAtgiA^ zzm91=$0jc+t>i~@4NfcTcpMfphnC22BlDj%^GRgBQ91zQmijt2=f}|ELR^0IN+?^n zUQ@qxcx?NA+f`plTXOwHr{dkfc5_HOB^^ptyX^!^T)NEHN6IY3sx8!8hil|Yn_X_l zNZNel(gwf^ULHim&H%^d}D}14>338RfU!deX`n)v5 zbI!k_iQ$|ldjFwd%)`hep|rXDO5aeZCQ$ILRPb-0JMHY<${ljQUK5~;)jRH@X!?qRb(uFjJP+I(g#pVwE1JLDw-8oD5-n5k0r(dghP%p@yxlj& z@dGpbNHaVi#BgC?ADY3{W;x}FbA1Z1@bZUTfB(TPFjmWH2f2E4we}t|t>g_%>q^_m z3&G`u9aHR=k8OMcH{YtwVO}?2kvD66k>5c)E_?&Z#Ivsl7mawzp8Hq(Nw@VOQirba z*>LJ@j_Fg=0xkQ~H0jUj0~wa6QgBo;Tcu#E$FP)4EO3e$3OuJNKY>8_Lse?1JFDoV}tvzU`A9-R{u%#kx8b&fac#gV%$nj(QzuoxZ=ac(H=Fuk{r) z#53&r?AI~ZWl{pihtL$oUdP0xni%bLQo-zW^*$VVz#PHDeiS)$rLWI*Th5AE)og{g zaQa2rfVW1VP9DkAH8EcZV%PhM$TwL99N(Oo#W!io$B-L*(a<`4tYJI5Zh>at`^F$LId^SpdPuDEL4G ze7b@gKwaGNSv+QsJz#M0_k^RIz$XI5H~K1{18RC-fFnIy6WT3$a})&$!LpbLA$XGYw_rz1KCv^WeQr`|9g$Pwx}KNrja-SL1=gFj+U_ zxWe6%3eGHia?hTiY?M70lSH_ZQ|+}?z7zMH2wX=KS4!|8>A|4|kqj|H!Qmkf!4nk> zxo+p4r@9hRT&hVx5pNUrwekTpY`DO2IdI&fINB0i{YJuy!u@;falzRR%@K;vf341m z&(Jj<9O6ScS*+lw&RU}2&;-DR=VJ;Ew}Bkqs}+1otRFoxM1|S!QFz7{n)y2wzLWeY z3`|^}S8%u`CFA`{!98hPAHly<@PATImIK=306y_%-_IW%p_aiSfKOF0PA9$DnU$Qc z;QzvbO;Ak430|k*M{#`N);IR2MZp=?dotxNg|}h%ffx6zh9f%i7LN;d>~@Vee{pML z{HrFKTzL~8OjvJky^M>65RaTP`X7AZt>BbdEQA-2_z}1lF2RXM>a_wk^=Zw`reNZ7 zrZ(4>Jf7FbAPvDX*VYVwz)Bw8^J(AKuW)5ZawF}rcLyC%R6tIOuEfi3K#zktxiYb<&-%J$I)+lFp=EG>}wRf zfyx9mmslLn*4Ov8HniH#tq0`w3hsKyW9K|xkc{(VD4B2=-6?e0&s_$QXt&y_L1|$_ zZNHsr*URTA!Nk#UIFP`tlv?>L$21p178`!9-s6c|VmN0(b=Y0w6;A!O{$ScDePB9h zvq}58Q((<$a9Jxqu}sFgGbwQ6pW$ha28Bfa-)L3Y9MUV zg6uX0r!93)E*}D4D1U-8n7_@h)c-BNPy-xJ4e;_LE#>fR<=}s3zfuD{M$sXZ_>lRV z+&;l6&RG}ES$+lF$5gL?FB$rM0xasUDReZH?Y$|>xe^91>d$GQCn(lHM?i2;<2_=j zZz>0gl*sZ56*|1ibj*Zmve57q!^usiqbRnV!_QMLM_t*zpU|(g-zK4TF27Ak00*R< z_vGjF+mzFHQHEP04rSD%mHKvK_1?D=zdD~m%q|(O=eGgAodApYc4D50<1o0K5>HP^ z7~InnYe{?f%Hiz^>4Uj;Lel$k?KHrP6DSXgW_WP|AcI`s84vg$_Tq%m{u{hFMf@|- z^U`2GlBn(ExE)TnN;xiW6P)AXHo=2m+-7Qyi`(?hl;h$ybLYCaP559Jx0yEB#cig& z%f)SG`E$iQ=O^mBSY%{TlXnEho#8uO(P;t9J=isGrscTiO>nMj-h}76=1q9cYu-#4 z^qMylb6)diLhftcOgW>{_xv7S0I&D@7*htl0M5i~wAh1Lx5Js3>vlNdIc|p&oa=Tt z;W=-I=Odw48~+V&yNTLPaG!!7fy&|b+5{g}<$L(8AhyLBwg@g&@S_1Lp})yIg6Apt z+XRbpLhv#LZ;60!RB&q$qeFtgt4{dpwSLDne1*}Xs>yM&?ZNEAj*gDr3}+SaGzPC= z{M+5F-=aS|i<1mk&{jb~i#adSh78PN_G3>$FwJJn%RExfBVrI4TS`NDq%!71{IFY?bO z{ZHuT%#_OTHJ5fe7k+6YxikJqN-E_t)Z@8T_@@oO@(&^QX;=wup&K$WQ^8FFuK|hs z1o(_;Hw8tf)_0%p{&jVmVP*Ap#s#<=+0}YJNLbU=eLc;P$Kxll#C-tGVllNpXO zroum3aY6GAc&M|zHr0b+d-WoG>{ zs`u6@p&lwAwx$ms`Id4*5l>)^gD?aWUxM4#NI+J{w=|`hIPYzkUKudHjm_P8-15q<#FU7magJ)y)wi2F0M#jxm@aS+gUL!v}qzE(Zj6&P-Dw2U4XH!51Z6M>8;(4FI z!Mh#7DI@GrE*CCvB<%D4JAUNocmuEOrvJ&STbe&|{3{Gj9|I?63+!0ikGcXoSt_Pu zr8>K9AH;YslJL9&{~c3{kCHrLOP$I*jsyCfhJg$~5bxl#WoL$z!4ZdooTH2EW5P6t z;q_=cmM=ISgm@~H8aOrqBv4a;xL(3nV!RCNoKlEoaU+h78~++-_E$7kBj%fVjr zAD;<|V|dr49v_~G zQ*eG(Bjsv5F8cWpd^|mbjeeLP9iPGPF9Ur$sy|hem}RR|cz?6HriRaHPa2JWOmlp` zDo#=b_Vcyk0|z*enbV#$Z=z!y5Ez~`Pb?T~{|&c*Q@9tfUZCsZwv_q;jxv2N{4k#0 z_zDX%HI1fb+q9wvmOba|X+wO6AMmTLbyugnizUh!orMWIvwo{TP}vJ9UoP0iq_;8xJS;xByv|g?E6E8(_HkR`mIn)mIgVMREO`K& z*VJY^>Zk{8wJY0G9T1SV>h>fImH3OQ0{atu;<90U$@xtQdpVwt+BF`6^{5sO$P(pM zb|bE!6;$F*SK=Bxf|l_&Hx-#blRNE~pvU16 zI}17=Fm}1U22T^aaCBT^k51T!yWGu+?Qu@lSp0qbG#{dti2K-}gp|b`Nd40(j{fcO z{x1GUkCC$Kk3e9GrUsXA74T(guzrI}R;T zlJ9f?jM*iN63L~wh)ch2PbMm-)g)@n5}c2hv4E*9GUGR$WezW@si~>6ol*%o(+F3k z>0ehlT`}29j_Ini9m%@NxwL{f z{1wIJGp1)$3f`0iK`Ep#XyH~}V;pYo%wJLR>8!9Phe{RIQ z6RY-ki)3+aM0zjq`K!m-Zb+dGaK6We;}-sx@s<_ebFOBI7S1avDiht+t8!c}J+Uz;zkEg34E z%hb!@sUgf{oT3Q;r9=ylGbY2C9DavLWg|h{OoQ5RJ}U+h#j!46&c%uML`urQ;SfHR z#~X1M$(-0{mR8sXfFU#nW&tFl!Xh+s6>=vB%MVx5{aA);oDkxuqn}q!$1O6t(%X@p zV9u$4w1brxt%LW*<3_CW6UNa{MCcei0v@*{H#v<2}i zhfmo`B7<>yGtfVt!xLK-H#b+@Z5waGFZ4bub+|OcEdq|Prmhtr6s@GoVBC+4Ixb#p zYY)ulnlLa8E+=ixTWy1;x_e1x$rdwZ6PEiLC$h;%!QMEvDXiAPotN2!S2LP z*o_}iMRpOS?(P)4$5i8PAU3$`gwSACTxao*csc#i0ojtoI3)RGlYHnoC3LaA^|jAn zXj}=vjVl!hf0JgnRD9g7_|B~<=TqFsltOiD(v5&dCo9oCo_NiMPr%-ut5)!Z6fN`)Ye&PAecxQ?4G3Q0ZF^TLW zsWLE=xqhK3*i-|LMevaR;*g?GJAo~uBtjzzK_WF!KthXPp>uDUaW?b{Je+HT{Op%x z?<24TznFN(^5De7C)j;`y-xgapz_3Nb-sLZb!>FSO5!jG@z}UB^~{sz$RawUA(;ZN zgHiJ!#*Mb$4BrCFhb@MC#L*{XoMz(5q8!I!ZkEIk*isB0D8g+)aX}9%>=JrF4QF>^ z=Gb<)UO>nI*gd#E#nV5mRJ^!&GhA?g=wjPy+m`ie9Y>hq?GvH2Y&9!O;42d{$s7;s z6c`k?A3+_1Q4h-zj6qGfm^!QsqvSNa>Ue!e&8dFKMDc^u9SjdI<-lXYL;S>o*^x}b zzj!j)JzZ#tn7!3R^jZs9$^xu6zsYrxzwc;#hVTx%Na^%*>`9ePoGI zKa$9c1)^TPR#rfhZ^1Q2hXQ9~o^#@!FH9$={8rY|;eGL{?ibBST;Q#+Es%M4P3-Po zW~&fe;uc8gB73PrLpE%zD6OsGJIK_S@-`I5|J3sH#nhl{A}-4oB zpJIKMh1m6YyOH$AiRSDoMWa$FBK}i3CmU{~rbo32Gq57=*a!Zyp6!N{b3FF!@o_Tv zA_J`6v&N2tk#vUShsBV{kr(p$p&ckkj#;qeao1dIOXvFt5Qt#F?2vdYmNvA(X0-!r zL|H+QDBPHWDHvOgqmUsQG-QW^#CNRuJS*`^sq8?pGAvndD}gYVUF_3G;eyjikRBZy zB^x?ME{G}|<=wl3vO;V$EAeLANTTDYA#wjdJ)wo`Ve?B=~_|*!{ck zRc7QcF!xe;SU1-rO3F@1U|ctKR({;3c3%Wx>=AJr7h;8H09@Me4GEZ0<1wS~suD)N zi6bN{yg^+>G*L5RT$qBAVj4s3Shwc-EvIba=s6#rXga*Caxl(55wgMbF+bo{Z2X%k zqTc<0{cENS7uJ+JJMA4m;9}G7x7S|&_pyDhIjaRDZg5NG8-!7RaC)IEpA#Q}@GItc zEhw-Z&D}kh%GQTejw7f7MU+QOn9&&tDE-w^m=I}cy z3V~8(AF`!AuyQ?z{{q|;??H3F{UY4A4G&I$^OHeRgA>MRC6a|fGqNkW5ByYIScPys z#Yq~-NA-5&cN%oux(2Fptc@j2v8e-1Zk!!tU;7>AuF>$8#pRb<9~zvr73S*#TrF?QYuT=DK5$Y|&R=WtZV?+_-LH zXiFE!8yIMI&YC0A9^&9U$R1oAFDZ10gAvAszj4gPfVnJ~H#+Q@v#&=(6)eKYRl<=n zv~ldcsEQarsr+n$?77&8Gehvdtc+qV)-A$a-MB9a#&)&=pMlvT@^TUQp5_$}Zy=$P zoSj)Rc{@3|^$_g1@B=g1Ylry7b1(&Rp1ov;T{2B_P#pUXkx8>E@kayPW4YJ#68B>% zxVS|+=@mC!b+94Xn!y6mgNQq%J#Q6;U@Au~P~U9oRY@Qs0gu3VZscUdSg%Pq97o1? zJj)nRAEVeTwr{2&Q+hT^4fqdE09YN=RIDb$TctPh>ip~$;+Cty{(%O6ibr*LQ7IcCsG32rxv#WIOa-M zLSwr>L>Q3L*bGg#1+Ph^a_A2SUL_;c9BYpjEdY^ckb=cjE^cC&vB>z%v^#AP66<8d zL0f`lmx0YXcG*I%BY}TI=dz0;fgmS1cGj%rTp8q-VA|22Yr>YxQ_hJe48_Igfh9Yj zo?cX8rWQfkK1)AXXB4({bqm^9hPu8h-{8fQ9J`ffgD-BLkIx!0ocxQVqNcliHjDMA zFsL5g)6J|KeKq(I$UMUYjN40D%E+_=0mSO#6rpiRoq=%M4)x0$RB%2cR*3}#rnj!o ze5mYfQ&wh`B6n+pCsZsg7gCh=Yg zv*&OS$alE=HGAj?khj9kQh#R!7m5?^?IOX4EBMQ4F#R4LtzbA5u`Ap<(?Rs{K8w_p z{i?Fd;%(~O2{AxM_hb9g#W%(3@(D`NiakNqnBb#hejA)Q#%@fwyD>zz^fHfC6xoD= zqsT5%a1_}q75sNZmbZs;cuXV-*IY4xvdrC};BVyfB6agdTqQ5;z#AvKPhw@kRpO4| zOEL8&MrvGhRZeO&DmY4w4GNA@<3R=g9jU>~M~_!~Wd8zhHHDqd8pD$ZcU_)Y4zGFF zEZ4kymY*Ix3kg?TJAiO(f2M-Je<*@p@vOsL?PA((2TA+!AZctWZ^eM7I2n&qa5#54 zk4hAbmns81K@yF}G(#4O64qIMgy{+&Jmp*J__Km)Yhs430`0XV8PK9Uq?PUG0C_KYQ0O2EU z^7TY~1TdvkQ$imBWRtTL9A%U96`YHKaFu<$s=vBG9a+$)jy7H*PGoIHH;a-J@ z2owA#1xI>Fl#WXJhNIJVrh+4wvZ{5OlF>3NdQ#!hiuNivQV|QBSm#@gGW22vN2dnK zey1iy$$p=L2P6AYs|U2i>Sii9d<{>$$`$<3P&oD&t7_9{6dY~*vkD%p@x#~n#zTj+ zY^6lOS@U+I!m}jF0fm1*j@!{NbGd0l`S<=EyRy_l{M6FX)1;d{+V>2j+ujaX-l3$Y zJx!B-`!q|GB5x^pFp8|X#aA62VG5bYHL0IoNeYzqFDf|N(r*-;t0h)9s8`*8$cX_T z_~!7-%HeuYOW=vDe>zI=4;73@UfwS&!LKMd+b=5<$A8*4E{_rAy%@pM6dZcwq|1ic z3WksPPN#n}_eBbhdLX2~n!7X!4!T3vSuFILru-7Fa-Gitf`iX^gr31rH`;6V*qOBr zwniN%(LdyuHOl~}vCn8qh72Yh553h_I>5mlo2<~(46(*`9#(jy9oF}}rVOZ$o=1*e z>s!lkm&JC<6&@Y7S_MaktwF)LhV2zij1JrD3XTrj?-d*!w!GUso>3t=QNaU8^KwlZ zFq)5RN^~@P6r8mlPrBVVov|L1M7Jq?@X;T$&KHf03JcHCl&sOeTj2vni=}pIYS!o% z*XL@7qhGEm1M1`G-><0|qtEG|!=W+3IUE`joWr3p!8^3_pQK#{6P&|?FsEye<_^c5 zxewyvlT-HJv{Yn}S@2z)1~bdd22Zu;ps@7@)fAe9AKaNRbL4U+On5G5!i48=G05S3 zS`mm&vey(Gon(JfaIQ%7R%bFCSKkJ&X z-Xj!MQpyz^oqIPbIBV|xRN+~3@8~;x?Ss#~?`W0*bMG}x$(noP@AQ=pm@Dki4Vs!Y z_c|3GX@_&KS5pSm$GJD{F5geLf~}4C$DFNAQgF1j`3lZ%jkEoJP0a8h!L8X# z3eWWaT$0Nddb9I|K53vYbW(BJQ1}Pv zG23mwcVM>&FZzOqM>lv=6`Y0UbqWuuz*@eb;0&S>{%3_pYajka-)Khd%syY?S=F>D zJgkN^drHAsH2agnKOoIs|B^>D?V6b0L*7y7PbGelSP5u|IQM>^8*`K{HQ{&VXs(^? z*yEZO`u8RHX$7YnAoN!X4KuU1Zzwpcw-dhX+x>vO9q~YRZ;4EaLPKQ8_GJo=P9P?& z)1+|Cr7FHb!I1@l1==-bU|mBV^f*Q9I$Xh#x=5tcH6`Rvf-h5W7VYj=_y?dJ>tDCY z3$ec~j2kcz+2Q*`be#GhZoWlPr zBTfJ(aGxfmWek~RJ z%VzfDl5cqgvK_;c8h2{q0BZkKQ$lL9!0QT*iVza~ghzctSp#vg!oz_exvo}lnp~`Z zokHJjc)qV0vxcWv;hCgkdxw78qnB<^#zCP`f}XA5oWrwAQ#0FOZSQD8w6+gz@lEF# zo=<67_V7??%N=@xlOadI8;-$XZqFamR>Co0{W&5c5S$|-0?mdwA|kNUgGWSQ>OmtS zaKs;1)CREN?=>aLf`_(xY7S(Qf1%u{e54QVoy)}o-dizQ?~YLO~ZcMM=ao!_^g7{Q-aV(6&mWotmB6Yb{I?G zJQ9A$_y1Om-_Vj-7!!%vKk&6ikyxzYXh$wna5VR|3eF%h_co6yydB=ANfuNL%mvh~NtpoZ%9bDn(M^q1RZV->l&5MT4C4f+m7p{bVO| z|60MJvt3H6e^+qm+?L>>Px@X(!DAJ?9=dKAuYk>7ph?kYuTXHb+3OV?t^Y0sN9$*w z+cgQtmI&PWAgwA`)cOXjW5em*C^eGCD68cgF=OXkyni%czR}~!X@wXKm z?eR}?gMY2yC?QDb5l{P`MVmcN!O>&NhxeAWfPeQNJq%1<`2=+tP%@Jmd;9NmB z$k92%;gH{Qgu@|tuy8m`%M}iX@PmZIA-_DL-HYzQc$8m0{3Aa$ zx%j1A6QcvSRKd}KTcP0Sz}4ple^tTJ@g%=IuSwBnf2rVTv;U^xXtVi0_8p7XPkx!M zN&k$ADJ~-9{iQq(wg1xjakmJP^q$^~^9&M;iuhD%iEzldk~JteBNi3O@|?mmHYjW%SHK^_4-)W)y6Afh z_`{kG67YvT|EnSv_MH7Fdd3qfs~@!r&*%rM`HI4$)pRO2tD3x@`06vNp)NLE;ZHMM zxZE2eHnj?lT)iSY->E4fI}`k+fnZ|!h=M~bIhNZM939I(1!p0D#!m+#&)Tn5cvw4; zzemAY)$CMw1`Q}H?Z5cyaVD3c6cj30orwEDMC7g|nwBA?xysio{8#FZoY0m5Q1Zz( zh31OrLA;8$=ftZ-!8!1{LDRDE`l`Ysc(o6J60dHB4u)5bNNYrQus}TW)nLR?C|wR z=zH7%C=o4FC<1Oo-Q)8yP2k?h%X83+Zt?y^S?o*iznB=Vv{)Fci}Q8JvmRjyJK^H6 zlTdRN9-Ry4D>!2vX7*JIk7mD3!5P^(@4u$-F#Hea@skP;Z%VN8=M|V61xLr^6AI2TCJ$*^6sb-HXCuY_{ktZH ztrJ)Ke9qx5R&aJzWS5IH5sHbAz{HWNRq%kDAZ+M+ni}2m{#e1$x^^l!XI;fV_ee+U z$`R0scpWsL6Epmc0i8&SQpF@hpPikn;H<0Uw<$cb+OtH9ri460q4FIChgVxERGw0B zhEQQGc`png4Bs@2RPa}EOSGfg%R1seQ&U3xIlC`VaK`FJO1-a`M=Ws6-xl+TIIPWq z1L0c~uFHktaxqw-FLtu(MV*gneq}`~6`avY!XL;1XJ57}Jj=Sxw4#@M6FJh>Xxac? zX31v;P33@&c-hw*20tSBbOlF(A2FpuQ^Md!0ey!lFBJAf!f8lY+h^Ir$Z%}x&s=F1ORTYc8u4&OCZ!0*f z2p71EcKX(-g@oasRw_8Ur@T|a(LE(AdP0+;6}_zBXbE;auiH1Bj&_sBibg3oTG12* zM=@HU;As7<=oU?iR`dl0M@tZ+pK4MRqizL9_uVN4=TdrE-NK#$9por2Rq$Ztp4JRe zG+tD26pddic(Cf`?#hYA#R|?*?uwB^5QU-&0U6#y1eYOGYOlX;`IO~#%U4dh{)Xi% zueo7)P55P1?TQ<(zTt`+SKU12iknv5eC_ffQ<68`IAz7ktFBF6y?n~SBe49xJc0`Y zwlHRi^a}wj5F_KP3(r|ud&SDDd;k^(+(57rA4;W`0a^HaMxYcxB7ssQj}O{{w2UAu zzHDYJ6o9e!aa5T1h8v{T%U9ia#fnwF?u@`7tc3{s&^0W9x+A$YunODrfmQg` z2UhW4S6t7U1_V|CED~6SdBVUdt}hZ;1qlNJs~~w*@&@oUYZ(w&g@qBeX2r@Hre{P? z84#!jIdjEJ$r{_iBB=bY44A?gDLLYxFg!|*U=sxA2sS}*j$ji6zt=bswA8h$C_D874Z+!kHqqSd-T!wqwzksqKivQG+nbC709X2m8C-8ib=I%% ztZ&@5gzvo#KhmE6F21YN7Syk|t2@Qc z_+~DHli_hia}P)o+^4`NYav_TJlY()2f6ToUSeDD7nJe}7m^Mpa82&`}QGz zaK$7JU5$8sg40Za*>=PofSVfp0@p0!?ap~h9ZFv*QP;Ya_KG(UxzM@10^Q#X78X*L zz-J^}MskA6aJ(6uU)V|#2XLQh4&S~JzQ0=GPp8#8u0x7(UT}0iBmAN5?{2NXH04GH zUZ%%wWUrQQn`&OZl`bfcFEfqa-OCHN7MYK2H?IvTGh>U)_t#d?-M#&$d2R?CW*!1J z@$dqU=o^qs1)cS_pkX7N_rpz|phs^s^}WsBw~}*$B_4#}kEa|X+F4^;8z3LX7aaJ4 z6sRV71mkgZyCVDn@e99wEljWUzMa7dXbyi<^(*QtYir@$^UQ5d#7waplLwMfVbo+X z^mrLs-U%=AwGYW}jfql{obG8x#7*lh8{qx;<@~gJ8tyl4{EOGKLtiZf-=pA1OssPc zr0x+s2WQGlni9U>V&J1cDR_T=>@9a{&bK=`yg#s#;+cYWM zLDRHykAh)D7~qP7RgU;?-%`d)Zo*e7TrilTz1yN-c@NGI)Y9pl3eI@<&00?XtFJx! zSei*UY7#8Q{$d8f_b3>*KKz?xf*)1zCYXqBpK%lY-KR-@=sUg@u@a@@+oxh@u3#+7mo$sC1eUMc@r)*=(Ki&Fea^rNj~y0{fj?(pnQ02nu-npbbh*L@m?fF|ZA}fWd<6eQ z!C6*5I=T4BA-?_46viSSRd8riBlzPAj#|h#OzSi$G)=Modlej-rdZKt1$z?{_=M^((`ch*KEuId>#t zR^$z4{OS#6{woY-_%^^`23W*k#yp|H%poZTGb9W!n2`cvFhio+#_)BppuKuDB8y*&#zNKlgH=UA>~l{pun>yYJ5K=)S+N*u*Ce_e;eeW3fg3*yVix){-sz zx0u7Ww_;y3W7-yb7JNdN+R>-r$59jQ=)7U(2W!jr2A?S8KGqvsOq^R!v47?KkW_9b z&7dDro8=OMx6v9E34MkAg4z1Qu$ z`+OX%_x{s8+3btIMZeLpcwgL92gfs9+eI+}Fs$nGRp!I(h$6AUu1j^m31ly#*A$u6 z?H8Ce?H@NcZ#f@>u14j6VW}0v7`*CWah@E)$SBga!t9}Wa){7k z1j7sNpg){DVxPnPLR=l!SXw^Jz|TQBLYPKaO1=&HF(}t%CD6UN8ML+kKjHst#4-PQ zD;(H2(H-&Gh`=|>)=8uV7jJ=|r9o){|CRWEaOK-&uC;s3sG`&0Uc5^GA=E>!n4Ius zpM3E@d;(GnT^64&{E;q*_!Freu9i`~ty?>7qBEtTBN3>hu-_KUg;6loYMaHAcn>_6 zj|GlZc7`+N(Vm955Og#SKK6kOHGUgRY6z3S$ba3wJSy4MgBTm>;Gr_N;mR7(5@yg9 z^zj8%Fuv;7NK8r><4nRvF!+Mcv(&n<2`~uDL>Bkvw5Y@Xb3?cH1P>(3fry=f+$l7W z;?GNMT?)VOgSdM?@*-^*RTQA1FbXb8rIvcXPjv=I#E*)8Kh49Z0zQ@BVRm&f5b^VHsdPh}PSx|pyZ%txaS`KW4}KVd z(&|*L6@-!&MM5M}34v!Y@8FWqiG~g*YwZuHDfPZsW1hJ#h^DFxwfQuvHX( zShr|_&&zJR_tje^q&D4~ODwo}a2D|f2V8i!#-p%eyp@>e zCDtk(`rqL_w<9)31Gro|4Ik$&%moG)K>?--P^e`SI}iw?z&>@6=Sv@uAUNJR{wDKv zUy5j8l{|vrnxBp-LGB0M7u_kf1?P;!RE(!OFYz|)cyO9_d-03rkamPHs{w@)Qj@EP z+ye?De$m|+?gkJCn%GqD*Ig_0r)@Ni2d5R-8&Sp`oZ!o$FPdRHcke>*8T^8=l}JlI zau8>`o=G$Y(+i!GeW)*_3nFPv3Q2>xv;es=QYRxILjzA55srqj*d^E*DyHN~K}uq5 z+dn}}uy*#y?K79>uAv)Y9J+B5&?&(nd>#hNM%bS2SHm)q_?YqXZt@lL zK&T@qQ8yxyo!4ik6F=8&KL;7s*d{c>L;5EI3L&gdisTrp%;tkMyOR#o1L2qmW)?n% zwWUqS>;ugP7mz=|vX!;=Qjy&xLZQaAD8J@`JfJd`1Eu z3p*^@b%{TA5vd%U!ODGrD@J=jz_$fs_bdaCA)>~s-Ii+M_6xy~*DSHMOU)5G&8HS( zY9Iuq{I9{VqK#lGBF|GYfb&ZIK@JB@UdatWW^dSrG^U>rZzN9|F7cQ6UG#xRcXdX27^@8L5V;T$I&T*Rv@Gjh%sIh_a1%?;w==p9?2>BSoSIy)4dpp_6a`N1O6 z0*A;;7X8jO3CY^zzA+-0$Aj}IFF3)`4c~_%cuM!~9+?IZsDSAHgCRDW**ROjOZHQl zIsyl05hASMFXX2!-;Ix^o+{gWW8EdFBOSV#V=cih_>%{}-R^I(^IK@KNTbbz^ zt|hI$E$ZHd1&AL7JqUmjOc?c5S0`q-@CL?r3C4Hod>7J1qn9Yo2+|`6I0eM1g+pbH zkcg8Ee}wsbJHxAB$Q%xc^($pKtvxe}L{_B|iD1TPm@1F3Pl~iDv6WR>OY~S=$8p^2 zq;1$$uvhMs#%7yrae-+N!44s7cB=@Aqt{N~a6!X*G82Fd6yfx7_@b@BnUr=IDz=<2 zpSsL90D@JET3`xRd8jqT3p_>92FIC%Zv5?Owi&@Oi(?a+X_TohLrmL|yKV#hShM>9 z`6R)n!7>-0M}A{{AF*Sg*12qPx5ThUY$(#{yXQe}VP%-&$N+SRCnFP`k5v=%pbOg> zC?9P*Afi{hdsSi)0N2T?i}n_`9Y|#e5Coo0wb?uD6T$VP5OSyPHYaEHYEVMg0DD&v zf8pi}ZBq(=*pu{}x$rLH0LtJ;zI-al5?J*q8#JmSQ83iiU1rrg%56P`1#ea$O_Zpa zP=gSjuy~9Y@=~qDey>Vm`e9FEUpuFXe^{lf4#Z-xO5D<#kqY;8+=WrJ;jfsD93lLa zbeq0H1VnW=SNOZ`2B?(5cqbTT!w;mPmA&|SEVPhio$PACRP$sV0>btTsW!u^&E2tT z(~GY^G}WffaEcsf?x-s=cOT-T+q)Uc3oX+1;8d(7-H2U_oZyi&g{x#!;kp>dg3XM; zG9Jtu8DG{dql@ygdS+gTF+S=uQBMT(c%uW7nE&v%#um5sAYSBZuiC=a^|QKQaST-t zi*Jxk$RSvAp1|)z{qI!nBfn!JaCsOSuMpPa#5hjM<9F=P{(3*OkCEnQxXNOGVfu#z z^ASguAO9M&8y1Xx$NVhV%O5SVy=DThyWsy5NJ14DPj(!)U*gcC%FI#0$+59P$O!e z4T}_zgxOu)>3?%uTf63Vb!YyYCBM#*Pxqav(!9^s+O-J3ruv^Ko!gN>q`YLU?M>)c zUMrifU{DM!z}bf|)=s+MyX=7D@tKSipGpKL6t;mO5Fcw4=1U#^Cl@ECdw7Y5IrVK- zW<^;17PE$~R%ntZ^^X_ECXCk&$o;G9ZI5=7o146TqrdvdDs#| z`BgWs6d{huGSJh``7Mu0EH=T!eQtiIuI<7Nnq!$&FD-Vr^b;#5dn( zzPJ}lx!aY-+q|YPyKNd4pvjNj(bn7g9c(3#mx{ayDoa(7OaZ*jk@k{Qs(;6iII^O-8fyKMfGKgX&3t;|~Y&M4!bzItu@O&N1q>^_b z4O?bckjphdnr1PviVAc5_pY6D{#N_*!X@ikDRq`<}d z^MO=d_}lb-yT^JVrp=ev_L+YjQe+NU=QaFl+Wai|dsIKRQxgk1G1t9L&m@GC1F!?K zAqr&nDa?L$hb90M6U@k%fbj-wglm|y06Dj%a|(Z$VD8{q&$r-l1cb&;Zig*zOLc-* zC$*Ww7j_6iz>5uaTjyi>=3sF);s-OIZlvDE0ZCT!dU;7E3EjwW zAw&d=7CUw`)HYDb^)r}161F7Jryjc%PiXcU^hdBjRuedlNLD6}#%3sU67SFi3(2T1 zcqmo5#VyXx>y;7`mh++*88E%aq!xkxHWo!pm0RV)#f(Ajly9m)|Q}f|615r4rhA#Ukl9g+eJ& zO6`<~U~h_Mii`1uI_aIZvbk%Aq;8LQHE+fw#V@+4bTa_`ZhpxAgSlm4lQxe$>D`A{ zM-f8)f|jNou$;7LpWWheGHa2Y&_j02t!}HxIiY%~Ob(9e6io1O1x^!;1>+7EL{`Nw ztu+m6SN$5l#mqVc%`@Lv8_cGHlh!W4I%nV|z)1U1W(xJvlM1te;rb zVmM&{Xl_XZ^ovh;NNs|l$>!V0;?^ZsibhEcNQd2MXDpD#7m6N7-F?!CU*2px9@3g? z^ot$a;wah^M$K%Ys~=!PcIVw+kJE&N=yijd-g-e-;r0_YpAM{6&cPJDd$ z+nHw7LUSFtJZ6e^nwx@IF>@U#T_iXC{p@BLw`gJdbwPtj5dR=fVUgBs(6QXm&90B! zTI4x3DBt~%9sHs&HM6SKxxsanbNlU4pW)VB)&!#ArMytbuxt78N~{W*xC8C)oCDtU zLKBt`78EkXE2n#jk>Pb6-UVsItT(Q%gszoUC3dnWGv4TO?q3^5Gm1N&Ek$(u2!n{C$u?2C~IE1hT${)fzjq^W~|+i8+yyWwQH zb{xu6nqfP1rkhEQ=)yg+h>1K&%zJW5FzYb;Ni(dk1EWxfVG!N9(XS$vr}vSa;3_-96`xstE-$dfE^NvWU@|hqKZfV$%&=>r~-2|*Ge^_z#6BVaTyS)kLSXV%$S_AA zyp^!KxOhM?2q!zP1AuB^(?)y&YtiJ3EhQKx)2B#8 zDB$^8qu9CIf|AiNu1+4+lY&cgTik_48D)JO?D^RDEyo>=nR9TYJiWsf9Iypdup;<% z3(REKr;xD@;HBM2fM#j?v6gf~%}cd{Q2l}=G%vA9L#WsWGbxxDGfQ^LF@z*;Aw&GsD^zyM7xs!PShh$KIMaK-DI^mgmdYT z_$+>s@eXkc+TOUM;of*HHx1Yh??a-KazS;xwqx1m+k&|i0q$mtZXZQQp(SiZZ4dtL z1{2oUnWt{|wIY8G92EJ&@WKqhetaEF;cHizO+8)D9so_|b0Rv6T{= z2dsfxaH4ebwBC%Na$6=&msp%*ge6W4BV3~H6zJgOZp=upj&Ic)8bWG!B|?qqjhO>; zqiuf#_Jo!QFR??qx>3C;f<0em_tz_it1wMK{yKj+JmUVS=+II$npv~a~^

^=Cbevgu8rZnU1q%nCim{Tb($FBZkg|)V0X#)J$hOPQWS~(34FY&{vtq?xw z&*@-UJqE3gds!TB>6CV4-)7vA3Wr6GsX>8z%`%GN{^?TWcK^C{ zMHM))hnP*);p{WH+Lk7W-&V}Bj?}ge+Y75!ecJ*#q(;BUR;2nOZjGC40!NavCd$zI zoi=w9+^D8!m+TN&GA$XH?5X5rp%qy;j6E8TiM-K_!Xkd{I(ICV@d;~fLHbwf+x~A@ zAFwl@tT0C{G)oqmDYA#akz!2~9?BvU767r`@uwXNnEz7?MF$51cVvqBculv{A5nZ8 zq;e_O5gbz_YSDSy=uCQ!=?chZn4h+C&rLx&HNZQz)1lVb9V^gbb1Bs;C_}De`1B@AkC$&E zt??+EfwfSTDBCfrLDa8+aViCzQFpDN{FBT1dkd+8<>Fu%0YgQoV=XW$E;A<-nc*dU zZscgKbyNZ(4fa5<(=VN_DEoguX}qL!#wd}wKB2r7XI(r7dz08ySx!3)udI!*E!(PA z$M9rfEaYS`?3!@si)FIYj(+l7VAy37L?_sT4|e*ZyUYtiw%~>~C7N6pD78nOBi}`3 z!&N){BDZZF86gO8;>5eZ=Fkdxc# z2cWlZ>s%m~bxbx|XVccM#jQ9q`Dn~sU14j@(OWQMq#6zX!GFO zRoDnpV%l~X-6dy)(2eNvH1Oe6`z2UqYs*g~vp%bY3; z^vPGolD5ur(P5!5NK;4@c@ZWqM#*V*H0ECC*7^NXkiExna05vd?hYwQQ`QRkhV_D5 zz|Kn?`^w59tNu{=^pCi4*XD_;Z*4msw$odJ(%6ErzgS>b;!^fbU4KLFVspY`Q*r(< z)$8zNu=KT*MXhgNzIDFSiruNIpCVk*TFp%$@DUaJ%u4($^wei@;V4}-%gr_I=ED^j z?W>WksKQe#BOla1T!ZQa_jQ{kTTDsCKHJf0%8~nH75WWjCxyz&<9|LF+8t@p9 z9}I4a@yD5h4Jl4!*4x6}Yq1ZLc_e(3Gv7t$cbaji^Ao5OfA5{o{N7qE8w`xiV!O1% zULNwEW6XD?IZX6L;62E9IY@Em56)fz5zuK~xV6MQ7ArbCbK%AQv(YW$9A$qGlzRIe zPAWQ0Ho8q;ADlc2_cRiTtp{$WI7YNMx%e0Sko|>3S#l?K%Q9Kifaz`&(SWnKzs63f z>R;R|Mcq}HVDgb#@~&;SIj1JDBVkh#Zs*P`Z}WC)hp0asM8|M8Q=7u!%alT?#7R?b z;+0PuJDgN-%k2!?RAcGV00Ytm)xQ!FY=b%6j^zHNvYQsqJGgu9s)ZKRXfEwT+6L3M z)>fZ2dzLw_%*-gV4|@`F)?%9ia>x>rlURdeEe*cKwsy3dRedIDt7n_SBKuwVJ@6RE z``gTz4R!|JT(p{_buWrGrK^-6Q(@G@08GWd!zRqxpE=k4#sMT!e+eQ2LU7VH$S8T^ zo#(M7i;|V6_V+L7mnrpCKQdL*p#->A(<{7_fV!5F;=~BMqJC=p5U+AZ7Lyywn48=> z<++0_Rn!x8!NkLU2YFT!v)AH6s}q0}T{tD)$}Q*kLU^p`aoZ{*Dq0X{yMdi-ZmKp% z7M*5Gs0g8c*EKs3|%wcu_- z^J>ZMR@2C~xV(F{xuF6J;Xj#UcAD$?Zf1=g`QPRkD!6^FGrT<5kg%IGq+@s!eo@Q8 z!EtZM4o=|=ahs8r$Iiu74~G(m!pM^!XaT1XbI6;E?vliHFdG)QV_!AeNe<5La^wge z_&P4}K^feL%R#n#qZHa3@7)NE2$%a{&bfDx(uaL)8(W>)N9K-oMgr!9Ts&mzd5WT)p56uQ8t&G@eL8U34 zN|!X48@8B{70&YF4I`OiBf;hEL(noz^>*_SQku$cB+93@sPV)-h z#t|`Y(~>Y|69(l4x|SIURq5xROcXJ_2Rt6QE0y^6(ruhUlsonU@3D%QcTK48O zHLPPVpS_w7^Z>{B;Tpzq;KCQSr({3iRXe$f-`J|g za53|fsyeO>FwToS!Yrv68QPdL=h5Bj!(m&tFko4pXYVpIypmt3gU*P3!Ggno9K^!1Xc7z@g9Mfadc< z7L>PeT7d7+e()JpmlAEM=LaqKTt{l_soP-p!*+p(`K`6B9X)eZL!$_+!Cy75%g+{R z2Uw*xr(`=kzF>1dg-CKUcApJ=hapBL&vY=ya0yDbLPuzWnGb6MtXSgX5VZoU<*C8f~Y0wFWvQ zUe26p7VX4o6KO+J zXdk|@2XXhDAXgXlP29S;6FlNpuB;H#8hxBxm~5!RLRnvh@9bp8d=v&4>NY5@li-so zC@HoQ$G{j!A(^vj$_Pd_nVHJRZvH|awjxX3|%bV)Dt8j)lwZIV{_p;gjI)32t zDH$IfAzS6kXWH(F*QDSb`S0YGTP~ue?L>>`HCDGFZoav83rRfOk+`4ny3(9zDx{TLEnwng>VD?Bn{fPJC!ar)jdvBscf~wFgPulT#yI?-G%B)}8z6Y0i z_f9dl)0#Eemf3Hc1;IHnjO;(+?g;!c&ak*o(O{dB$;erFM31WDX?MuMY*0F`Ehcay z$lrn1ZF-4!*N9OR;(4_#i0^5EmrXp5g6lopeScrYl4hk?GE4zfbw8D9=P01Ez869e z(=p*6&*Ej%RyWVM*h9&oRGn4W%;`3z6imfVn7Uwc%p8WZMZ2b>87HhbCFtNfg58>% z#QGEg2hX_H2+`BtYzr?$S+_>>ozmeD&%fHnT~^@s;XG&3I~mhuAqb6^4LrC{+Q;zN zrZrgydw2)X=4(< z;}NkNc3Ejf`Q!l+-UJlT1;AvZalREYC_#1ZRo!iLPHB7{D^)68GzoS54+j23D+@h3QmaG1*}zM(SK8W-{tL=(4#V?tzEJ2A;A;Mzx?EG*O}5YA=5NZ zI&CvFv+Y=Vc*M;mytD>FEya(}^dbkhLHxH;7zWlPp46^Zo*UNoy;(8%3?FqRt@e!A~N1tQ`K4`&*B6_qi#hAK5x1Vs&<7 zFS3GiGu?P$XML8pd12o%LP~=@&tv97nuW0{w`_boEGGqxkRsnHCQO<{_U#lVFM@AqE`~g8n}}1Y!6nM!7%^( z!Q;DdF9CNocq$*5**Ia~m+#AOT{xSj@q6@NOqU2qzd@mZXsEBp&GJ+ayif$U;B}~c z_Bb~0iz7u)eh=STpADvsrd+rZmL(oCCsFVIgxy*%Q$aq??{H-FmR7$Dq4qA9e=ARO zQ*Iru1Nl>p;FJ-YE6>KUS>^QlRzD-Nljqd8&P8IqZJk!%d`c&pNVeeQdovyuxlFvf(OYYe5EJ{G-Tq+s2I|VzKapcCa zx?a>y-8kZu?a1&lb4=Mx-i!#${36(fwwrI^5OHe7S!R4uceB~NwtA2G z&5-sf<`Fz@v7`8+YmeN@c*~C}D47I5ZblWuoRKP^0LpVFPru0pz{=wi3!M4Oxp*6g zpInvjBS#6m>Bmb}mwDcOCb`obR)kitWvPK?TC(OmXkrqrHWnV=; z+|IWBRs1ahK~Yf{oIJX@yN3ip<(JCL5IK*-RG6YiIU59YI%LRd6$b>tNk<3E*eti= zFcmw~wR^avPt%1{^5gau6EbQG}JQvTE4E}KMsitlkypx~E>#CFs` z{uCGZ09H)>y{7(>bsfjL=&iYExNqXkbfihvikTk0g^?1L) zz(ROg?3{iIeSWNIuW}G1E;ReJU%|hWKBeJ>hxw{f$es$$(f+Jb_`fn3SOzIKYQpbh zvAw-^N(asx)3wD9_qF{gtJHW+xFd)iuv0SXJEPL~{2r#%XQV9FGG7d0eQ1fdPSY)2 zqs1P~k+?%kelOqvrVG8L@P7)x21VM}2}gLWp9)BW1q#1g;r|?jG@$S3ihr5!82x$D ze>C$Ge2ao#)In^wKIAx)AJ^npSW1|X;9n`YI~MCp1@pAF(kf4wM+1aGJxsy#6#Q+1 z4_ELq1#gLf-)p1}A~JWo?^T11K^YmRRj*O_ofcG^rQq!f{w%?h6&&yKwQNX(=_Gir zg5lkIU8`e!!mAYiZ}Aw;9>atNO?Yr9__%=8)8q2P3f`A?Oiu9A3Vto^h?(Hm6#Q9m ziSty>M&DNOSB3&SN$Wm+hesW5hWp&G(!uasBRqTTrNoIdHysRLrn&!eJOYwp7P@)M zg(`9>1Ha<|F6T7Wo|wN#nk5*PI9M3vJ|8kF zslp$>#l!oDLfpv&CSDIKUQu#AuHancV!3@c`|6_Q-coR`a_sP_KUYr3 z$Lu|p*b!W%;4oSM!M7+l8YzKE>p$rc$OzFuc=1XP&!8ybYqbB-syH=1eXJ*T+k_a7 zOvS2n355eLX5xntZAe!Ap%uX}qRiNKleDY%42#){{T=-)gZz+x=&io^VbLc?KZ=6_M}A0a_U?hj@Z*qg9ZJ(RRz`X^rW z2!D-QM3>hhh`<*#y>m!X8j? zL@=_8r@!QJjdpRKf^&3{O!F&Ee-rD?%-}S(&p@PKR|ybxH2>f~`2K}~J=pCZDmV=6 zLGUXI*1#U{Dkp(Ggj6qkgril>RdBSbPbfH7Re860tfIua`YsQS5Q|dho0_u8f_G14 zrwQJnV*lZMXa{Lb$A8+_6NVreh1_5Mj0Z4o@H& zQkQM2bkdIOa6psph{xctV;`>g1T}O!DSpf9DqzcM!f8}+TdW|MUl3di2P=4TFw^lF z>+U<%*S#^0W%LA{hi{yy-4>-_p~5dX$;0mx_+n+(H_Lt| z?d-tsH~Xrx0yHu0aMcn*m5U4XH?@@pZi{7ECHOf7f8B!NL<}AU@LmOn5qAh4@~R(~ zFo+S=f)6WrKhy^F0H=bY0dg6>Q`15PneE=E;1u?Ty-+j~ZYM~(p8jA?x*qzPZ+xJ1 zxj>Vm>&qt;99dt8@!gt|g)z-lqd)2=RWuUJOOJT0BB7l~l@Z_YDIrxj5Etnx84c~k zq(5o%1L~Uo%K;Q-f&atayTD0ymGz?4-K0|i1R((wQHG!)A(^DBx~HcnPDXpW_smqL zU#aSz%tX)Kx4OEzyE64kJ$hzxy%8rtIOiuEP<|dCS4h05=Xeklxm-v>1Vsfz1mysF zMY#ztIjGzKzK%!l|NpJE_Fj9}uCA`#H6e-p6K5u?_G9g}zV$u--}hzBaOblg{V)3M zoy+n`BNv0q@*=|r1It48^U-(cXZ^p>ea{TP!0?%WnbAuEn!0!R8V*z7f7E>VKPHC$ z4w*;dXX6jAG1Ikw;CH;%Ot$00f6x39T*OxzO(yu^oa`fJpZ*I)HEbw(JvZd;YxH#e zXYq#NDLwo*VB8M_7?9kbyi?uvo%s15-l;!cwbiep#M5N(iAeJy6 z1gaPa(q1S!^DiGgIr@2JEs@^dX5RRf5!(;?d?U<%JvoE`;g{f!gUc1K6bCBjbi=Hk zlQhqYnA4w|C;!t3&f{}9Rc`MIvn1B`%Cc9{9gT8 z{@0QTKW6T*nK0k-%*XVcf^Q+`eC7M}qkOr~Hyks={&Xp*uQ!Wtb=u=ovgQTBr&P^w z@F^F}u=Nzq|BHru+VkfRA2+kXzG%AP@UNKX_`{scmmi7zq-Xq=9u7|C73QVZWcZYy zIi`5E_b$B#xy0jUntrcAlKs99>IYf91}R83 z&A8QTkkfy+S)1VW|JV!%r~g?q9Gd>KKd%YLpFZb!qZtm)@w6EZ&GCLSZp~5n{jy%- zuPc5J{(9?!>Ll^!vi-Btkhylb+w@&%B?y&8To)Yw1vCCA{C(HFV7L(E>eZ~i?fs)e zk9;Oc@T*0>hhx~Oe@N0;*^McMg2tI zEa32Wn&EdKN=MYI)DRzj5#Pu&{(AGff5u50Z#KhGuOkCX{=QzeAREq_WwUy1^77d) z>DdJ@UoykiWUdt>+aI&v5!=cIk zpJqHb*+{BoYLd)>Ds)b zV6Oi-dB=+vy%WfF|D^fR{}d{FWn*)Em@1isFS$V+L*7wy}8Pqq|gVEkdhzMPYUkM z)n+)nH$3rY%*OeQfG2v>41W$<*QdVt4kAv!E=*c=){%0#qmnP83hVw4{5bkv{_%n2 zvE(QJHCY*cKDh=T_W6QdwTBTMk%utVdRS$HTz1-*G5go_g`b80?v%DD`GmjtD@}E~ zoepW@x6OJ$7~iYR1)jGb{kUE|#Ms~y6l;K&FaLM_?%?H{X4tx%d;Nn|{SEh%c%M(C zEkJ65KOH4JZg}|Q^R^6{gwH=w)HnFg=W~vj!vUH}&dwtYG|ctnd8(P8Lg(qNW;}GB zrf%172$LV*^OBnW@ngds^QBlGM&>U6q6s+s?z`=oFGnxr&wrwGA*lrYv{^BjK^mqY zx{(?7&FJsK)t@lKj{#2ww3s^6{N*`c)f@7`1RcPiR%$(exz+pvc$7v3@eOq|{5Ww@ zFEnKN(`NW*yvPJ;?VV=$8-d}Enc@5BWc$MK!iyeDegkz*hF|d=%74rWyyvg=)IN%- z89Wgm`YH26x4XF&AN*szaFMFZZ~cvacI2-=Y^X>#N=}|(hLsL>^5Gva7jU0n5u{7C z&#GIQzt7@BxrdQ=x;e}SLkl*uzX4r}haQs5VIG6r+&C&;D z)L)w62pRQG^Qho0A2q`fw>|C5X-ozTHHTWO>`8W*A5F zBg`lgLgO!2e?x!3f5HPt)0=Ua)J+ResI zrD~zvUMt>oernR4oY-G3RomzHZ&cei$(wFkEw!4#3)OgM<9l@#`cvPuQ7Cji?tpny z@M#^dl@}%ooB4*@YUJ_u8#meM8;#eoZs7tJPv|78@8^yKadZ}7mb8B_8-R(-TQ7ZT(AdTYDu0Akg zEdo|W)_Sc}!#^)iBtVGfpNCi5rE+V3sd|K{XnZGLhl`Sl#5vNLy1rGa6xF}fis`42 z+Vr@Y{S{~-->OwGyK}V$w*$+p7Ej${cV@>#yw2?ScLJ=UWzr3P47T$TLte zBrb3`B5`2^!!J30l8;P`907;Ai9(X2r_JaO7#@1S@KFBzpRJ!23uS7=9fnas|NhYM z;THk8ck-dHzb|`2I&?pLL|H<&!3+3NvBR=&A%c#8p z`rmmKZ^G~Q-aGPw8(dXLWGcRUcy#2Zi>P-fzsf{MGc;!PMr?D>AH&} zr!hA23KSf^BmCp{T^#x0@Yu^QqUdtyAuqegGIKf~On<^lFOIB+$G-a_t1t$y`>u;4 z>*2BQyg0HM9(&P6B&LV%eZj?%a(L{@i^$9mUH80;D6AD4d+x=NMtJPoE{?RqW6!#X z9PrS+S6m!99~%4jFz$j^y=FQ1-><$s`OwI17o~UO9Z5E8>-B%BpMmKJKx^^gF_aeRcaI*SG$s18j zUR@@wwx3~oJ~KxV9oBTrRgLcbh(+03geTb|sJ@e zk#$u>RF(TdryQg#t3nD=|7UOD$*~?u- z<#qSWMdeUovC}<2*Pfs2DJH_7S_;SBY@s9WXYjss z&q2TEphu$yR$|_RL_Bra^d95dV_bWTYmad~<&bMV7}tv+hn{lrq&@e}-j*r4-Sct% zoAPn3ejcrK_duwsQ{`Tkz*9I?VvlkCn_^sh=y@g*JjMOedur!iRPpJYvDCv<+{;(o z)429DuBWZq^3?Igcg%E;aqT(h_nh;4&iSXCbAC_b+S9o9G_F03ODZuusS*eFG_F03 zYft0a)429DuBY!Q*mHM3>jcZTi+N%!H z5#IY24eV)Ldm7iC#CqH!fR%v&58M=6V%=Gp`Th!#q;d!=Zc{BXWBSQ~AmVBf7gKIDJ;N6he>hlU>hv0IwMFTc|N@x{05=}PBL`AoKcyw(i=6ndop02=qo z_dN^0WX&&D%UCYVPnhwaMuX@VCf}Ic`0>Zk>FG6(J^J?}&p!QF@=dQg(indE3x4gP z=FxRcb|o}%U{I&9yYD0lKZ$}^5-*1)0dB)9R0lN=gnz;)!g~ZLqp%h&qLDtZCEvf z8`V8JpMwiux~O0ApV3P1waE{o6}>DD7r$wK^BZ+?Wq!^KV-qz!@N3>}hW(z$e8>mP zu+_wvtM#{L94)Rf!QpRkmT%!7$?xCt3H;h6J-?s43>zeEbDxX5pK)AM@}CV2{Z{g( z4c+dQFTB;<;Wt_Sb_}=7@awJ^dhiRw`?i5w z^YI%#^XeCyVXNye&-E>4{KlbI>pAk{PnzNX$2&Wm`nnnZB{bPn4O6+9uQJ2m@R$SN z`Fb-P>O#z~{kZw<)0dkk@ngSYhQE>+Lc71iOQv%opZAii{xrX>F7FvL!@mP6oyP`^ zyqfzZ!UJvWpO+llyf1mvkN&-)8@~Lr=8gxG;BnucJ#?BBI%hVP5K z>#g?B{#_q2!#@^z*XZqfD*V~M>jpCnE*r7(oA%HCU9UI8IOY*|eZ>CRzw2ven8Jal zVKlJIH=Ncp6xks{p0trQ!{3a&>-F}}{=42~h98f->udJU{#`FTqo)8pCSrzJ`)B{I z^JW-qEaI+r*+2Vt{h1m5tH`@vc!!<}fA;S>Y=*xWdDnUSXaBA@n_-BJh#CHw{j+~p z;)nDU&>B4AuEX}v{#~nP__L9Bz1jZRzw3i$7&=?TyAnUFr^288yRI?ApN_n1)& z>$PV1laY6Q(EeHOdg)8qJNy0U^ZRt`o!!|kyQA;+j@xTX-{oLuY27?K-)vowX2xie zJ)O%Io3(bMP`pvM&Gy@1vvG4hU(zkDI~!(qw#l{|Y@5c`XoieF&vp}Nf23zy?Wms6 zd{jgu?Jh01H;ehY|H7_)sJCgc-L;NHtA~gA2zLJdiea;Fg-v*6^6O|r{PpBbBUhkz z_ZRN_O!CTe$+v|5?*aMm2b2Xqn%swG+r!siIdVnv!O$&YqT3g|EqSraGyQkmzbTKG zzaF?h{OZlkDF82O&$I=}WAqwK*w@`g{1j-0)iT$eYFJhvtH zJdQtyld>A{81v%foAKvms)nlkdAa`4QC~`{L+ZhQIH5=i~umv<{7;%GX|TdNg_4$Q8p^!%Xh|mHJ_N?Vg$JwluO1_`_O?2e1ej=~#rfB@fGc&xaPx zU)x>%i~I6G=d{&3K_&iPnK`T1h3rjzz(;AFWM-L`MM^8N>s8*hX|CHWb-YJK$VTizmu`zVQGcztwpq_qA6GyM0+ zUHe9!`R0+U_MJH|_97@wo{3Yk@fLW7?oV#OHFM=wQnk2WAKhr5nbvO~-jA*%KkmIA zmnAocSFTJp_~4iP@|g?CmTo@(W{`lm4@NJJ^1uwEHT}7(lb=q$3GX@6-e~{n35>$) zH_GP5L!*z&-@~IMzh`jHm$gohzRdI#AHE*%z4v5W&q;Nx#~?4}2^c*+da`{ctxe1% zNcP^1_MbcW#eai&Q^()9YDB+XSc&)c@eiv9@B;ZoUNw5=2a`9+56QQUCSSWYe4Y5| zq#H0Ih1YRXL%i}bp4ZDp*(Lb0lep((^26;7e8m|3_gM9d&$x1QB$HF&Xu*s5zSJ%->PhaIDAgSc~L(^38rw=7D!;n>pwRd`IUn z-KCG1;r|GA>{j7!qr*1}{~kW_{N&@q87gkP@;$$5_Jv{}ZE6;+dtR^_lO|&wW2! zr!RnLPTv3Z;qSXDx#G}Tk_YRFbD|r~99ThR)BrcjCclt3Ocz4ID@;M(j z!`(jS>VJ;>nC$b@I-~l1Jcu-!R^HUh=)>iGGZYQJbGNYaEEN@rGq{LolSpkicu-s%K|~-?%ov zZN}~J+l^7-x3{S9+YO!JH-6^hzoMW27@|8uU5q$f@gBW`uY!YDhid5Izs-#Q(sLOm zEG2&-`3KMmB>=|{`MCK#xWtc};ouT~$9wf#LQDL=n(^*S{Of;mLYb1mC4R&VcPw%C zv-*b4CH{N!y3i7jJ*cO*izVh3{`DW~CH7-VT&uL%bU&uV4M~1XU+u?@c=e{)r|rUt zjLUt>(5)3sBlUgMJiv~Pa(dUBAFS{ogEgOgSWkqp(UZetWZ9g_eGlpJ*Yy(;<<#ot ziJ?d*XR&JN*^hLR5MTVT-UGPaANn;#Xk4XzAJ^OYp;7S5;p;g$j(_6wdi>`u=Xjdq zB-{z}oY#YJTVGCoWGneocYvd|N7@%hzU{OMYx2TxnhXEOo?-)4q``}v?54({hC&2X>%y!;VEg?@CD`}rC}(Bb{O@R(kL(0)#t2Zi?Y z9y8wee%|?8dTJ5-`H1<=-%k?NvY~E2!pS9VzfaSYA2BAuTy3rn2TQpCA2;_fzM?3D zZ^)WqKMsu1F41b<@IgbBj6eAl_Ac}8w~iV-2@y~nlWxnhlGyJRaK;x{sbu@W@ z5)LfV=F6od(#TfwL;o`J+5$k+b4@Z@Kp&c%rVm^4@n(B)>lV5<^h${*d`r?oo2%j<2il;{N@E`OV)yj9&gp zz2tv5G6e7It-!zN>2SNg@5B0e4}qwX9!_65{K~7gMlPIw<;XJ+zg#hI zF5UNhL|^`Cf9d#`JIwf3V2@n z-^t+{)K0z8jE0v6cRc#v^s?D6|7SD!n;`B@EYYVGl7ma|S@W=u;S~>l>E3&jpZUV@ zv8&Du-+m<#Sy#||MZa9~{x1yw&{YqA;l0V9QmaGu^yQD~dB0<5=<$&&KA*fPc?K{g z;Umw-@Bi+P^zWY<(!3Ibmp`JX__NmfoHbW|9P2Z?sKGC|`u{LL*dO$6GZ^|HzVq%+ z>&O2E)>48A7_3FT^G)W;AIGxH&KtlD7ydaP*AxF)pWL}xr_4CmQ}V$tYiJmq>?3fB z;xFTeoWuIvo4n_L!A7g);?(XpT#QqrPK~kO{DgkfBRK9?BoD(YIy`nIHd|sCyzBZu z)>qgcKp=mDK7@P(`LyY`EoOv*~W-%d%yin=w(S)h{?p1xD)}M+N_oF^lR;po2wPh zy7gMQRJd?mx_yLk-BxW){k5KOGm9>$$OTPts}Fg1rp5!%gv_clJ0VnuyU(h-%bKcF zla1n5vC%Aglh0t`#@(Z(mN(+86>+zFN3N9y<+rOFZL9`E_4!5%t5>VK_0m?Ym9b}l z3q!{@vlQ#(c;_y6(B&~Yh-2h93!vBou8X}-9kBME8{jz0ZtfWWw>;+ZD-BngoX+K1 zh^<#hE95tUqda9FWvnx=>wcisf(93T!d2J?>y*X$V#mQJmH?1N!=l|3fB$2y8p2jOHKy6`1XZc~-> zozw2ZVs?IdE>T%+QecYemRnlPPS0j$+? zV7g=OyxRbi$TyX=ljS-jf>2n5Ck`PU=gCBxEw=yx?(v?W(3}yb1QmBFn_0|emd`-l zJ>kr*%w-mi<1-qYO(5Dd5>87DMdaS7Qbm;hiJcqs^@d1RC?cLhI(0xlqNr7ksLLrz zQ?7GsmXb7;n$8`gvfUE->4e_4>|*=C=4b1R%PA45prn3v-~$C0QdKS1$tR9mDb)qr zaC&jcS#VD;9ZxIj%^Y8tp35cL89tpP^g@ zz^1A3z<*9O&*kf4H|RC#ccv5TC0Ih##3A)Xd58X0JS$C>37n5Nt1V*Db?|o}vN-bgFRD$|Hd5#0ADk2-NIw%aY z0kc{-SiaiItj?{DInDvtP3@w5%M*A!Mbs#YOS`AUcvZ|g&Ucch(aKJFk1AE_Wqdre zI_MO_8>a#|Zqf6^;1PAh*l+Pn6^FJ7*d(;#X*YLB7$tX1+aI>tDjI9&Oca3zrm_Q? zHCkv_h2_XAkA%c|)|puWQJ-?$g(aV^Q|_!H?A;T!GO@cd8VJXw%AK+!hq&l+R^zQY zcGiI*B38%@g>s`^X!TsR8}oLM(Bn^SBnm9ngz3|RsHAEy3fci)CHW$xkGiFzG|gX$2hayc1L z%MQ3cZ=<(`^RN_xXwDALL(YYRtDfJ;w~9358PR%TrtCnnRUl#c z){c{zN;iwGO!HK+v08%~xSC)t0kxvFg*N0AS8pk^;La`1oXjOEuu&Qp+!}l#jmW1> zm6}Qq-i7w-&cL6zthXxCR};1TjxWjk6-)IwO6Aa=;2|B}oRft()J=mGGP&JSt{7QU zrJAiQWKJ6+Nhza=4R;+5v|JI6Ci-g<&G!0w>AV;ep$Uc@ULfCbTmNTLNvSH{hA4ha z!7=VSa|<~avLj>|PednxEt>GIl_T9~N zpdhwVsy2&og2wVDTXIHwk0;zy(1j&%z-4zlU4puc3HfO245xUW90?&QnFCe#pp>hu zCPaYDHZEk_Rers#ONTx`7W+JyUt4P+)?jqnkWi$}Bd?8~JVg3N(JgEi3uj>k{Y5po3(a%4dSd>)c!KYi@2Em8+nGES0K7)5y#3SaZz|hC4Zi5A|QU0dh9!z z$n4>yOwc9=fj6+_IE&j;@2WG!M>i2U;|^lw>ne2EL#1Yvb_Z)i+RQASnnYS-vsHuN zk<;-7YB?qY@Q;PCDq^-u~j&c&D%>XrKqLN1mOl% zJO~8T$Zr%gbCt<4m^YOv-y`B%0Qv+%`WmIZ(Wo_IYVNryJ&As`GJNyA3y-&194z&&|IIeua}XWZfg`pyHM4_`qfpkOj?-_t3zbIEvW z(w$p^{tud%oKSp$c0?PR^iE=3;0eGW(bI8TyHwQdw%;Q(>4hq=z80zi)5*1_+}R?A zYZu}jkgcU<-%0dJ&s}uA_pklxqm6lrUZ@HYCb(ZFYAPg++u=mzm zynlfW;Od1rcW!#&xCB*v)|Op7x{_N~TJ=(PaoL$!_U?Pxj)D+e!Gmx;5p|S_7ddqn zmtDm6qPPr%lV&rC=7nafSfP#uWRNIX{0!iVPN^e7Fjb-kco{c%&`S=F%3bZ6qCUdp z)JC{s{)tntLpbLVY9>Cz?97j-DfLUa7VxCg)fM5X0fMiW`w=UI|8Y8c(gKT+DmNME z`t)9L@(Nu7tI+>6`m6!`N*$oizJ?8lq$l%oxO@G689bI|Z2+e1rHSt-a3CVegTVEA zWN()dgAvp{_3Q|pQTCfrAk3^npc?;tiMg6tIN>0wt_-~(x-?PFx2uKCS>?IV`Z^UA z>;swqJe(PHp)gEp;r}d9Hf#zTU7fTONp}dXYF0; z#3m9mH?5*ohB0`b(kJRo2X!qyD&$~VRVw;AurueHiF;r{l>~&rf=blO!~QKWC2{%?M?v&xD3{c1`Y)1vlilXTXyywhh}9 z94iI`QL@}9Z6Sliq zgsc|2n-chVdfho~OGt)P_b8h8&xw&VT30Y&T!v<-K&gnmk12&g+yo52wMi@yFA4KJ zs!vMAAon(@n^foOs|_TK)sdwGQLlkFkW2!D_27a~x)x`G-!r~e+H%gHPpoOZ&hv}- zx<5&rLAL<*Jb~ne+e_uO0vsX8ne&y;&?ZN!J@EiZ3XScq)sze{(6aF9=))+Dn6t1>4W2A2M_R(sVVs*m7W+M zPahaZiWJVQ$H}7Y1AkNlYYpRr(@bY4?8FS8nTWyzXw{3Xd?G{@;P((OhZqhN6J5Ux zS(ae#q11#9DW_PeV*j*g`vB3E6dc}iqwGevn^?=Y@@j?g#D48Qgqe|bLga>aT_J5w zdoQi|c^pB9<#AS*v(q!c`SwQt8~)PC7E>uO2&32;Jzwv=;YGVz8J!lbr076g4k|AW zpFf?|2DwORJ7_H=)#-l>g{9-_4aS)QpRbkLIH+%v#otDJ^iN+wm1+_y6+!bjd5pzq z1!_LCFtfNY>pBawB6WS6aW}iKeUh~7=N$k8XHL3VL{%I{sFq*`7aLo}S*<_Vf_{K9 zKrH%oEkzI#A7vP?X88vS0EH?vTp+k&%&{(E6(K%f zu8U0#NepcTrrTEH94hV?$@#GX26?1cB~dYWq_Qi0C5_lVLJL zxqV1$Bfh$GMZy-9{I#x$A7Pa?E~G_-?U3qZ!!W~LfY4?2`F@uVUBB2!%}R#j>+$;sM}i1;gxT4(%K_^}RH zY$Ym4=Mp=0lsNo=zu&$7x(@rw%Z(WQF1#4M29Ioi|bv@y(2>m{+` z?TE_e5syUQEJbltsE=4M;!*|)+pMEoN9zR2Hh3|B9mJt`;Qk|$jH;S=D~wGE4uhbb z_X+WWQx@&*AZSM#LbN_nM1&PaF??KwvxkMSRIFogsS->jgDN6EVBo$y_?Q2^Pfk$t zPEIp`wmAgh{em1Q%L5jsprzaM0tlvFykL8*b4P};7fkN^An7asi-MvM#1P%E031dg z2`B)?dS#a4QEVB0BWpTO0d=AtG9 zoEB6bdLsfDx}ENe_^zeIuHG#Akm5e)dkrNe}7sy8Jh8u1^x(1c9ID)d8v!3Btl&Q4*n z)pN);WadUdWJXE)0ctS1!i=xq#Cov!Rq&F9!|ri2f+r$EIuvW}b=tMj!RWQg zPmo-bj+mB=?jtq~heIGI{t0asO3)Qc>m_nfET~blW38$!a=!D?ms`Q{E~ zc3iTBH?Sr}4W&ooXRXnkuC5^k2MWRk57QFq5{~l$K{w3-anmrYz*yI$9qY;#TkS?w z!!xvQu8&i{Fnb$tV@c;w$U=@vv}xbX-P=9qRw4T>r;By)`gXq*h^Y^o&2biAyQp=+ zu?%D$ft`p>nSZ8LbfpSYxmQiTPI3~H8xj=`m)2&fnb@ckXG6zPuojcynTj_;R#>I_ zOgS(mM1nsUXMLmtJop%*nh3O&SHuv3_zGqfQ{RD{_qBs=^5&ZYBDBrh5JOnCBCkL(A<+hnKUKEDHg`px3kz@| zo*~*rlcBVjX%^E`a9|*Lh4yroPMnjzgA5%>@dANEq1QRNwRP+ayyb#Xm!mTXQKh&q z%MWx&UrJ3?$fUOk-LEJ{?0@TAvyiVc5p=D*w3QQfK)2pb7zlt7;_OwK>kEqu(0}2s z=#Zg@Jdc5RhTRHtSY-E7g>&C=C789Rk((9nisZ`o_h-Plh3e?HjV%%73k!DTe%-iVQCK|@D zB&tZ!U7*v6rGW;=k_6nOCqeF4ir6jnuhvsT&6SGAm27RmGWqT?4t_8X*Ndh` zM*RfVGl6L{D^*l1_8Va{BmWkYg7;e&cBO_Hj^k68gD%T%8Tur;>*X2(wAGDF(P2#? zLXwN;>$NJJiK#I$M|e=54A9Gi0LKvV>Ueod1H=l9LsJi=H{9bJFbQUd6sv^`CPT!o zX^05jT`1-STiSydMS35y%%6!cw^vuBAy<)ZO{h212; zVG#w0E$N~pJ!#tr@aRaaHA;0beib4Vq7ZbexR-LRaX6Q>4@RF>KvFAUItaX(Rw%Y# zqN7yl7NmG5>h3gr>CWBW*)x?7{PJDfYk33K`JWE@oylF6@O>R|Ylu$>a1@4Y5?;bk z6CC^u40NepxvLeA!+CGm7g2NXlwJAqNTPBUWganU+bLi?7;Jf=;4W^yeZI5s<*L;~ zVQ01|3_n1e;FAkSPqAt~*4lV~wMTNNt+&WyJM8w zRobbyPw>`cNMlrS$Y7tx?WLiW0qlN1TfwII|LmIHM~RmTa@f$TtFyi7){DwM(= zVM0}VuVef9@lbXPEos2R?l?4igJpIOMM(MXdkhAPB?80ieoq3jB)5lb4W z$wW2~M|`jm^!g|QTEzOdDj}*fd&Mu^0gYG^@^{*#Fg5ANOo-(MBu2_b?|9iYyv1`485I|`xTv=D>$IXEMHVTG z03(Kiu!5@0=+m23Nm4Qc^TiERj7bsn*ur0wt$ZQDzNOP)bktqW&u0 zbHhHr5hLS2UU<<92K66FGbHP^c|)YSzAUl^9$cLflQEV`gnt55Fpo;YaILP@&av7* zj4ZAL9q-KqHxZ{V5c6epJSvjBgSf7#1b1ROi#`d+NFo?*@#w86mdH-(l-&Q>jSaSllRYTwdhQIJ}x=?g54`Aw9o!J%vq z!M0EsTcph$RWTXRFY@=?+{zMK!~qVWre~I>yJpn2mX6my7Y;)#W+%Fq;U+maDEDwQ zCn>KdDWF144faeK$Z``1)xj63l%A<3yrx@*plpmz)cJ|$=z|x}y1XX`y(&MLkpV=|LQTN!8Si>X85e){3ibg~Q^x z2#0SvF*CXi5KX*@V-)9T(sQVa$wrxSQEVOodv-{nR!J`!8h#>uQ{gibfxg9;Lb%33 z0zpzqUA)LOBd|XZr;i9=5cC%v!04*F9rEyU+-rym=k!w6MZdXaZBa!OcTDHuCC6+q zPly6jkpIc)R#gT=->OSgdGuDL4t>1HDz?qKgp**;_xt37+A_AA5o6U+)NeL3Z!LMh z&rNlNU(oxr*hI=;2-WLkvx`}D6-4$sd$R4+Q>ja=M@CGn+|zy`-^$VKqCzSw;-J4d z(P9Lwg@}D;y*glefrwSV4k6~_&hqiB3&aM%8ftN|)}hq+gmmapE-Cyvf14{EJiQK< zm&%>2>JM_lGDo%B#-9T#g;3GWKiRBl2Nd*_slrvI5q+N9oyd7T#Zy zKonc)-VlyDzde&RR(P-q*LKC@k+Y+ER4AH!asVjC+0k(;5#c|O0(QvQ2HFV|uAZwb zf!0kLx$0CBvH%8bB>D)q!3!*euD$ppMC1}$TBu#=S4&ZvBNZqqwGu2{jJ4$Q7Gxgl|O=zxUG*l5(+b)b5ty>Urzudi z%;f$RcPP2k1AJ$^m2eG9Nap~>3peekP0wblQZ~+LQEt6{;e0(qnVF?ZN3O~o0zNR& z%B6yox~5EY;rz@eOpUGO+u;z`Jqt97Q=RR|Z-ok{tAS%N(49A2&5#b;I3&fqQdAE` z?)f(79Sk)Hu9IcZH6k;?meQ86+X2wpub7BhcUuXajnnDIf!DlS)Ef2+GsEat)?nFa zr4c!G{@a+rg{uMdGAWpzS3c$HFY>y-`zmO@!PvhjESc&$yc&Kv^)EE8O*65ZTBbxaDAkqmRb)yyzXAm2*6%sS)3XzmEo zfSb3qo|;7OkHlJujX8n+1h!I=Sbb)>dnqKK$==+P@d7`2vX{G0QUzF^VNKf(;7L0( zd|Fc`-%g@dxz-^AC2rAcgjO($fAp(1LG~ybhOUFMQC=zhNN%KDDuFn;fo@CXLFli3 z2N%*q;sA>1GOVcz_WErq@=ds7fYia%S*5PrGxh0`sI+!poSs_;{mqXn_m~dKnMZ(? z#4Pjr^pfEZ2!JD*Lx7h&D%WcD{=R1?vt^7ES(Sy}UEq4^kp0@73e0GUoPk;Q zot2n`8F^LNfY}FH`kXj0a#YkI8cp6f4lm}R{T4f^8q8w-Q1tI=YwW+zrSvhv0mDN( zHNjQw-Llbm3Pe+47Ct-k1$MB{s9_wx&dw+tyk5mKQ4@7~*-5O`+RV=tze)d!vf@8@ z<}siej?XX0V|gYPqWIoDVHt*OND1nIuOG|INoWLn67)A2w=`|Y2(SlmS$McfMv1sU zP``o(5&w|NFrQz%BQrNQ4b7AJPW(1LzDKQj9ZgVfQCuF1(od|HOY}hbO3%WgJ99#6 z(?)?5Q4~ny6nk+v1A^^gD1ybMraFz=o@U%`J<)b{@)GOcs0cqo`p4Wvu~tS&@%14uPW=-6tCd-#72Xwm2=J0JK|jrsrWmM*v3Ao6H7_ z1_}ol4ofYG$VL`%Il@eM2yiA$mzrzLdJ&iF;1Y3g{ubelGo*<#p%ibGoe2AkQNqq> z5eV60-BH?Y44o8=()dhm2cc?gWNBob#qzM&OIc@m`Ha`R*G1fbJ{kEiYpP-Mu78f@ zSOrA$~9i;!)IlL0ql@zep+G)t3cLznra?6liJAp*sPy9T&ZX&WLDs8`WHrQrLd z7QS-q>Z2P zfgq&v&oqm07=tG8eF+DpU-t?5e)lnr6*K-6Yv3(I2AH5KU;-;y58rw`!etaa;KdEO7n+L|28zDdb--500g_;J)N#89a$G!@iS z?!@;*C0(p(r5{S25nQpvp7xMW8D|`hmE<O$8)x1XXCVne3o$h3LJ^$??otK{+igqJ^hE^5zii=38yH!lFkAT9%rI zzppJ;%U*7M6o1j0uj!q|1Lj3%%z7c`8kGR)GXM@M)U^yBi8VGA6MGS<a2IGHa5dvPsE#e*}35;vSf3&&V-qu4l%za`3I^Y$oJJ7(-ca_T@Kc5hcr zssmJ4HE>At246={jR6r+$xBiRHZl$!CJwpBU6w7Ne+GxhlIAWNRhf<62}ak)NKcjU zJoxJnEun*>ZLf;p%y} z4hG_GwN}fN;U@6OUF~<#QU@hlR`hWeCStlQGywF>5>DSKVGe<&q1++j>XUX{QDaQ5 zYp*kzkPG=r(XygCUawN$5qqJZB&LAF!m;Cf0wu-nYL}oO70(01sZ2O1!sfV=2%k6( z?aRu(cMv>QaR6pKHNiNbBU4Qd3mt4|u2sCNdmi`>TfOT{f7ahfxGR}zYuUuzcPok) z{W=1~tEdRk6SxVc*srg9g14SOpGw_)Gn5yU&4FeK$ezkPV`Cd(r2TG~ZXE%~R4ddz zs{i8){!qa=VC8L0CN4NioHw}@WNsWsd=6Q=z{MQPWOK@{>2U}KCpC3JiWm<(m({n2jwXC)!##`y&FBK9zD53F4zF_?G1;${`!QAIh;drHh!`$_a7Qb>oO+(UAM%WE~t{~ zxu#2cP);DiHS1;YXia<7)5XNB8Mgk*{*ylg)a*TkQ&!D1qimT)q%d5c}v3GtQ9dO zqfCpY!Nl@bRn=@H1unYHJaQogp@*$Lx0b(rX>T2fO8t7U?2PStaWjB_A;)I73}uO=zKl_H8tkzIRToB%PMcEWIX zU^hn8z6UcUBSrQmi%|t+lU`i-e8pJnU`s|);HC~kDm4c4Afs9xz*nK_!SMM$PPhr>8u1WUJ?Ibda>#AlUHt?F15~X@I$95DLXWI{Bof%FPV^UtZmI;YI zZ6OB_PE*5|`*gPrVjiF+v|N;qNK$?l=ibNkO&?o!vWXUQ0n5glqI1@KhYFZ!XE-*_ z%259hKR|^tBhcC&?}*5#tISoV9Or;|UTBOdG@yt(wUANp|L!X3D*=D#N&O%JkoL3* z*eIJD5 z2Wh9cU_5qe$vMrZqw6P6Q}v9;(;#!D+=`A=;h6Ou4(VyWib~RKx$Tk(!S+igsd38z ztZF5a%|#T*)Ts|%fhDN^sM_HpT2;bgFHK0FTbhHKmXtfKgRzUjXtItY6quAKFtd#d z*|y|NGa*PeDi&q-Txmy^8sA*pXyBm3dk2-Q+B(d1-W&F5i4$_DfH&fXToG_$so-yl zDET@9IJz=lt#cKNA3K2C<=lFsR?lxh5_^65^a<{lDt6jeRJof}Pjj!BAkmYOJShBk zIXgWApW@h-DipsgQ@I;-to`9y3c+O0~kF>YO5p zm6}|B`+ONW;=Q#D&A7HC%G-_}gX{LL-nZ&F!t5~yIR?9RPrA1msw zALoS>fb0hj6g7%Rz}bx6o??2lZa*6H5eUi|n9h8;7Ti@`3$N}lvaQM2S~_gSfc(oQ zTkuj?0jhou6d3r(MOrS*xzpL>y2Kn@sF5HTQ$PysRT?`LPx>#qWvaQ zurLJw4&@~d4TF!7qMGeh7F}r7&K2ODsp=wVQCo6AYV^hLSS}f*CRA+r69mT0+(~zN z=41kp+6G$4oTCQ>|6j}lO2j_JDhQyr0ov|%2w@R99lgWhDL7Xuud(@;5Fn~+90wvE z9>pB{0!Usol(4nZMyb`bBJ?m0GIJ=ite^%x4qlu+@O4ca4=IOntLbI0of1G0t8cOt zJBwv7Qoh4_cnSzYFNqCyq*|8Qz7mGG^FU+Br7EK+c7r-{%TEiGbMb^Ni4`At!rn=f z>!f6ui3e(zxnKweEV2+wp!XZHO7iE?&$fVO4@))3N5gG8{h+H}XdV2>T7!^v5rctu zhdbJ6e+i1B(3QpHr06*)E9kWAjEQEN^Elg{eaMaw^iNz0<3-SiV5|t(NydjjH~Lq^ z!0iz=;3Qd0fwsJE>6OO4ytlU-iFVPwCRh7;|M4hW2ciVogz>2eI}WvV|NuHFOEp7 zr|REPDZiI|k0s&!&k6V}mMo(n<1(ygJQs&=@w`BB{Rz5njHi9$cnP;C7Bv^k6-2?(Xqk8yJSQ8Phc-Ax$UKM8Bkajd&Sqitn#9(C>>PvS*bZUV?6MO{r z2rI?nBv`KHZ06|7vXkRuf#2XWZEh81#q9RHTU|v3w^>$=sAN_wDd*=)Djl16%k7+Y zhOb+wd_EFU0(Ibf`GHuzCL)#w%}#~hOHi;RCTvOeOS~>>zf>D9oZQGDT4%XF76`;j zX{W+qGm$*l0@Kq}-A9~i8dfH9<}tfKGeU~XSMwR z^CA(RUe4&R0Ml4GP3=;k4U%23RxFfRCFR;Gs>6Y2Uni?Ylp%O2md@R1!%S02)etXC zl?5CTwXljHJoJJ_p-M%3z0Q10$e?&oK`(*aBxEv{YpI(YN5zeN3P!|bi+4PdY0zvtgvIZ07HKKG$MO01%uLq zqSk>RK<#>AAzG@vF+DFaKVPcc!qu)&OgOxKuU}{HL1_0(rb3o9G`Xs#^;64e>!iG1 zyVPBK`49?B0hf1mda2pt+v}46qN9jpW`G@+-zPR2HJkRTpUNmqYY_ZgY<8q+25k0x z0eM*sIl17Uc3BW375&5GXmjvrCWR<;hR|a0)BasC2f%pjG89-2ILYK3bu8Qf{DPJX zOtNi^2P_87*)>2gWw1r`cW<<-GWQPqL}OSt%B9r;8@Lo3Tkwuhm>%NxyDT8mvo2dK z3GP`+aQM)>k8*4bZ=)m7mf%0Z&g=QLF;1V^;`o1tgA@?kR7_0V6G$pho89jr^&&Wy z#E*1&!+kq}Ny3<2fb$T*a`m66_F8IYs<*Xk03xAabd+P4@@8B>S!+(3iCIBw`^sXW7I; zIu7$e@mp8wj0sBkg#2UhAPT8^>;<(A1aViKO84AV+JgUGT7srhKpi!U>c3)&QDBaR zH6X6wx8aHv39^n_SLGUPz*eo%M;?a@x*pqYVrNuriwP&i26bW)Objll>d*0b0bECx z8JRCoe(3f#CqMU9?!#J_>J~>LDqsHZ35|bR;5EI{S~AQ)yD6* z%^rS{`AB#ov$#b1NYDhezf$AAE&}~u#WmHztQ0}j)hf!zoT1pXX9bdZ0h@JIT<S8>4W2A2M_R(sVVs*m7W+MPahaZV~{crop#h~#{^lVB1toKjZ6vPZN&qD4~9EY z!DqxkX3-+4n(2))y-JB{2uM45>SzWyIw*C@s`e?>ocgqN>d_S3-z_Y2zd}dw?-bKI zNRy+pxwWeNOR~QTS+2ez?h6>lhdD>eR8>X&IU9JGXY*q*vd(d|5ELz;>iG>1?~B(0 zn;s@{c3K8v1R}Gb8$jjD=kgbtZt<>mUMPS$TO@MCUffVZ&=aXcEg*idEmu9pg17h| zeHKeP7k3{1!qZaPY?h7sCd;}=yI3XtQi|1e5MmVWPi)i*3}Z-LWDb(upjZGL2V`H? zQimdIV%CEU;Nk25qft9V_ctjp8gTQ4;2Aq{6N*l=GxVCq>jmD}rMNGh^YBMW?R8G` zNk#$Uufn$I?a!g5@$_tlnLk-Hdcnqs)?)=9O^89|AMPYI69NM`oeQ+vy=L4qS+wI0 zDD6?|GC;m-cede){1)x+z;dC<`@!Qut0soh%Y23A%|d_J8B+$Dp@-$#iovsYKQD1O zu1*|=s$Z(YrKj|XCr9%$So&h|NwQU99nK)GA~9_)`w~x103gTzl7E1a(7D(B0?RTZPp_gP1eHCq|>gBdMc#+|jPTd|phyYqV3p-;8B1p&Z z3}I+h1oQ@%NsD>vQOay2MXoxDtaA*FhBC(&PGcy@ z!@t@Bs_`d25WuNl5`j=tQxahyUto1Z8ruhXvUhAMUR$eAW5b&TJuRH18UPt{ywws$RuIJG~n&(?gQbpDMJqd+sR9g!GERr+>y!qrn2t)OQQ<82=S#@F9v(i&?AqOVDc(g8ty_?#N$Js)CvlZUBIwDXUjm4b^y*bgeUAg~%} z=b3(8YR2`h!yN+)70ngPrhc`w6gW#XVymWA#C~mJ!-9-E$S;!<_MoNnEhRP9k-NXD z`blrUiN+zJwI7Mvh)XKOD@bqtlRO`RQYh$-WJL-jri{6ui447IzLvrIKNS{*f&L*% z&y&B)6kPoabo49Gze*gH>3dl*QF35PdI`co0Uc8`nf~dNNh&(qTd7A_cVAX&-&~}M zO{Lq{c%6h`l#30o!9+OqWoN+Nev{$|VHdr+40>o6eXqKyyWy9}()NN$p!4C0m%{Tx z`USfURfU7fu|=>&uC+$E{vz~GBtEm^mtN^0*@x9pv~Dmd#e@ffx55%z(Av*pHs>xb z%q@icWLalsC7a8fa(F84u2rG0(BZ2(PO3I1UT}wRr)@frvPFWY!naaK^6Mk1burqc zwoMRAH<}pV9_*O>#6)dibXc2$|Dv-Pvkw=H1+}r3I1oE|;G%=33Q(xTpz5uMN6o{- z3mSfIHPtJx5q*QzJqR8-OQ<)<`j|}rFkM;)vo$!+;;{}_Xhw#OWcwdheeR@Wc4W~2 zFOKT#8&)vE$PE=T(4Z%5uxQ#*d@Pl+JV!*atcqH0<&g@duSjl=#6v@LkNU#LsD}ff ztXmCZpMcEJTM=nc6Tir&$>OxZ>`bu?7@C6$4v2KN^SNQg$eiSm1;Q(GsfxlBz_P$5 zln23QXg2@!PHY4gSU6%Zo|8COHcoOzAyeroy)ga3q?J!+J`hri#)cv!6kc1u+|R<| zf+KLZx?51d(|g=sh=+Zx(aKsxmf#m~a#t0$`Kyfni9Otr?`^ zhk9vINUnVgakzV(;)u|9@?eyalguibmgc? z#}TOz2%j!9GbQ5CEqZq8#TB3i42jfW_`?^V%>R(kpPrpwT87MLd@LBkV9^)h%Va?j ztvyXgzYgx>>rtMURniA7J1N#qFQPCUZcHJKK%$WzEFuFD<(Wxv20}8H+ZEWQwqXDT ztD_2yu@l24hOO9YT`-k`1UFpA@-z-i0C=)Q!s5F5Nyo{ier-HaS~RF2-!?IJsUM5v zdFd62!=m~(ArgaPVawSS#F<3_4W;Nzs%R#C(kiyuY$n8fL~mdaHZ{XKa}6(TZE1=( zl(B}?o`uTloR~(W&0Veo2gx~yI4JBp0$o`3L^+_ky0C$?31_Y(*gAv^Q9^r4z3rDP zY9rSzs~n&iy2W(aL1q9+01R$2q_b#ETs}k8o(X~@u(i5Av)Aj?;8YdA;;I`_b;G`` zT4_y;ng%NWA|PqY{lT#|Qwn8(PsF6Dmd&{c&kJg;jeH`Fx$wn98YdQwUW*L~Lzet& z0WhhgD0E)vzbetX8>=7SbXD?mq&j+t>ZtOl9&6Mp642z4QE?9Jrc^Oz^E?GR{-J-T zPg{TblyX3`@PQoFU3#!YWTNROY`a7~t2CKfbO zLxS4PQwWewYYQnBVxgIh_gxs$`qwuC4RTGp=?7zZNqe0NdWb`gxvS-~1=+43vc*9+ zgRFFD<4XG{CrZ}Aoz~d`UNK8m!cS%onG#~EezzPgKA~h&{3j0QCL}}X*o4J*|(62tEum@I7 zhbn8LTd24IO~SLzm9X49LEnOs`ZFgobF-2sCJPQHm|s>&?EU6ut|0(WF2>QWy#9~mP(MI z6~cUI#A98g9v}V-d<=~n;FW+OhI$bEZ)AeFEma+eoaYi8FZe1laFN-%rDxrAg0T;@ ziskYKc-VPlNLBJpWK}_<#>yi}#mmRQM+d7`XuKUzM}rd268{$?Pe&Y>xB(6tk!QLp zl_0Pc?Cix}3?iMR0)ypCCI}Xca7H>4V$nfA+!s}1Jb-)*MVBsx$Nz?Xfj35DE!Wop z^O0cRC8G>MH4u;NHepb?O+gWeoU$6r3S7NMjUU=w2C+m@4FbY`FvF<{uszz1DTWRi zDA|YIVDfl%C=Lw)hP((kwyF9GS|7-cVuDW=rW^EFC>zO|J6te0fl^nk)BUMkJiZ3w z`z^HKL;dY*?VXzQJI!8~ZbPFHf``cL-+yK>C9F6q3{R||oV!u0tuZ>vTBprA^v`Jz z%7K?*fyUUlCbU>Evn!p0)g%?>HPF z?}h&`%xolNtZR%+MC8}@zwj{}m&9V|U<*O;t2<^1-Az!I(LiagW+7iiAq$xFJb$H@ zg7H{-dkAk{apS*b@ODIqw-rZ>GftXle>)%xegzyocS(4+3&=u*17f zM&P#Uotg}kr|5IaBh_he9cY$|MIx$V=~dt=cE1ILjbNcO6Od1f)_6rNEUjyoX;cLw zRMr)KBT~xvWO|dvPHOs_q?)eYX~TMU4Ry>*I29p73#lg6;kXMi4i|Ye5USkvsBKI! zt2o>OM_t>&``3zi%00@tskZ&ef#9Zw2p&lNPq?6bk*d({d3jV#GI3UQtD}DN%?gE} zqU%tpSV3k6DbhK2ftXpwE`eRFHHtc>q{0fbD*XTpqS{;rfRTtJV_t9>xTW>X>1G4@ z&fqFdDb$5hLk{c_d8xDNz!c@1;p^zmQz&;sm76dm2~+qB*ltHokncFsVl#CB62&eO zq1@#bTZ^>a<00~}9V8%3lwlUn2#IG|10}Qr+#8(&kOvj$knTF#BQZ;J4QhT38Jjz+ zs@!jM>6&YLvV^`Lsg##NAvor|S}^?@y%Pl(`-)-o&v3xM#6^c~+evXL--j3-jE0Xa ztuv2ffAsYUASUeDpkCT?r(E!OQI6T0O) zaUseBPh(GDPH+O9N5;HrdYA)pb{(nmC^oG+0@CFIj1S_%)s1}$38uN%E+bS2m}tV- zFQR;E-+OK`EGnh6QW0pP^A1u|Ksr%mwY@jv5SmGWXxml3AKINdni|y+B;ttuirJY{ zsWIfn(n)3odb#VIau!U1NN`$w7FHfUs~}Q2o~C0_orjpF4QOGbrGmKvkVxFWh~u`! zS}+|Ay$xH|=p)su5#NFun96;Qh!1l8;V(4}5EPa4eR$Xiw~$B0vr_8~~pLDTmq zzLO)g=yQ_x6vJ3brR5-%;da6qa&$)dDHP$cn#cxfMxo9#x+tK$=Ozm8EUw-;GgHIK zTgtPx(Kd#x0*o|@8>$(qs);WAAZ>G1L7qBb(fY*2BP;|AAaf6iWq?Hqk%nCx&$Mq! z+!Khb0Y$fjR#Fvp?1Fn7i7?xxDq+X`#38E0pq-x-60xgRA>@!W!un6>04vJLid;pDbNgRDp7ncZ;Age%k zZR8H2Y6?1FHGoGZpjKQHvCxg|p9@zq0)2O&sW*{Gsqzul%cXh(AqR{BmL`%( zoB%LKq!Id)wKxU(yqqr-1t;p(R__G7Az|5diKVg_~5YM*oE^FI8_W z)az6*geassv}J8{aBxrGnm)C3;tcZBnWQg^AhmZ~lncobvR5@Y^MI}~5a2RS5j|I) zx4SbM8(EW9#nn6u7FcdN9Ha`nsXz*^!y=F#{-b^5QkpHXwMWs%6<{K!3YQVw{qjmx z(H*Ckg+S318XfznlPacIh+~M0&uD%8Cbpa=rL2lw(dvwc&+!C9w*V z;H-k9*ccmSrTHOM!H_Fk`O-)tPh*>RSKCPSY=Z{?I0m#k%niEcySvcEaerI8R3wte zSd1EMwAB(fI;a?Cs3K&eyl5kb)%U%Qjv?NvaGEhlFPyw>j*}du9TeF?(F~28qP-=D zK_N9xFC8Bb{^vwu%j*mj=(nxDw%>CI@2g}-sl0U@`~L8)@Z;iJ^}1PnduLuE#*NAL z!NyRYN%d#qlJ)x$;wdS>#$snzu7fp`F4+TQKfv*@$^s-tidco-H^!J6E4aYv8G=M| z(TvwFM4xu44iE6-%K@mC@N9TGB<0b79Ms)@4kn{}ur36WtFts5i1w!K0C~m8*9X{9QXn~TJP%f}B%o2n&TFH1$ zoH!xXFiRk|Ts$BBllK&h%dz5_(mVV$-Uevjbl@I>&j*6dNLJPHj78Pvr2Ja(t_cOfZ7b^Uy?h9SVjE44fbmp&w@} zgQ56IS5>i)GcyPZIbiw;cjTCPr46j8))7|8S(gU%RC5(*$2Q8eRRBgn__$XfV1TPJ ze$Y;bslxA8MYu+Utj7reLE!--JGCblXZg)ZQo)?=tj}VIv^lT@rqO@-f1WLJk2xnbW_Thga7^<86jg{N7FU7q>DxYNz{4(M@+y&^)# zrgU5?)tC-`0~Ik$xVrFQL^= z7z<}ACWw{QO=5-RW!jRLmc<(qL<2Rve2AmyRLDOAm|5g?+*B4RN0Bbh6VZE>{{^qoF*i%Q5s8eHO~|wMvVyHy?aW)OK2?+y*v8Up+7yE7 z6u^?Ppuw4j30eVm1i-hHeW#s)mU=)BYtF0Q7gK(d6v2viyS7ynGarEVBL~kQh0HuSi z6Yy!MVA4>k7drtI&n7zatzz@9PEt-wE5y!t7>EKm$+gn@x;SwpZPQD{C;U^ZPZnF( zMGDz3W4mf;EYhMx0W&^BL9#Fa;T)W9bTosZLh43B}#FB!Q8YzX{Le)gVn8iVfx(q#l`o=XflRdMv+|ehshabLQ z6$?rly`O%D{$jO!fkXbG@sP$Sd<)j8t<4k2K2{~iaOV1j!lQbLpQug*gQ*#SrGpC^ zH5#A?TUlgJxH${k1M`4VLH=>{LLD~hQIs@5(}hJg)}@T~&zDw91SO>Ytw8FQenNj2 z{rz)G=&9x|9y`X?Y5+Ts+wp0>^0ZA1un>p=-oBWfMH5=#UF3VAy2Yj{pb{GWX#-%T zP*C7gKUZr=FaXc*mpO(|)nLs6NP^Zg4#ifmfy#bZ$KER}o)V_ll#%a?xwpn6Zg-RW>6ydz!EaQ0UP8^_1ET|5$*46`={b^g%+%Bho2{ku$ zJfTzUOaSQSrEW%}$+72s1TGLaL7WBEJIgfTs|vv3qNg5fPPlp0%t5>mZhV(X6KdTf zL)oy4qjWNmSEGb7kF5)db@+Gn19p@+N?+B6yM-7ZVl2TOH=!R5=k)pWjB2c!PSZ~u zp?6DYwBvHL1w{fxYg0g)#kJUWV-H@p4I>g3V_zNL3uKe;kYZyh z6X@%o_k$lTg55{4qmVx>&M6J1MGye5oMuo%Ja470Q^{VZ#%l3B0{l{X{RJq8Nh-J- zj_KgszW$?hFbCK-Z5!7TY_Qao(`foi|(ts^a$-N z=a&gcst>3i?>jxS;$gZ6#;;Ym*P@QB$O0do&So<(EUCt@N|A3!6R1u1sL~Zo`nwbZxzb1l)NSEu7k|0WhoX9rAu%ws!I6D?BG`OfH>7);z0<`NvmW@ z^yCW+4IS8!@N&-7cXZ%7Q(b1EeNOP-nSj5}IUuI2n2nxq$~zyv^^10@Fn%W|gnqOO zYkGMZguFaGb8>oi7N047c{RYg7Ym?v6o?Xcso@74xhhf_$C91&^Mh5My%d(_a`}Y7 ztmjx1?zxbl$55_H(Oah95itP0AROKi;y}%x<51DzsV!^@KpygJOj%13v8H$nq?t)= zM&j1_v#KaS9ykbNNs7Ho1_t~#1Q8-9Q3cZc)d?HCaaPJX@RM@$KnfA9Ibu!Cugx3>Y~`KDsDPiTu|bBbdukv_E|-%o zj|z^f{j%tssXJ4NlUEgk=w{ay~qWmeEFBA86_?{zBPdnU-pdiSGMUiZhvir;z1V};>+91IOK+2jA^V{!Q znfsBuY8UFkg1e9IJ=4>6OC(UWADJsxuFPblfZi=KHGZ*N{;5;r7lzm=jsKHg1rjQN z*^!;p`Q$#=SURu!k8`{%XnArIK_gz6r18Raz@hnOe9PS^7*1o+bH?|fCfn8NzpYu~4U}_IA}9?^P*8nG{RJE7&?5uh{OsEc{5f@ zD4<4Bqjhc!}>?c3m z(?wn~4g*uQ&PT)Z^bU53tQZl~D7MbX)j8I->j}8vq&1{RPVLl37^y}O_ z!riAZqU^uM(Y%|_%eyru;BYF4pdB2zb^;+b`fwG3K6zS3S}4F|7cr+LK&QlXmonTC zVu7u~lrXd;B{%UEE}w>RlA@sjM@^V9rdA#CBqWh?r38A!X{Bgq_Eeg$A3NC$eyX4# z>J)vjX{(>^`P$jQlb+7}}q zg@ZM__Y-c|P$_sJ^hxk!TR$A@#g4`H~ULg-yrK~8E>fb$jvVXVu?$Pu8r~Jp0?_bD22K?{+ zXU|_eefi}1;2HndK>qCM{`XJ6fBs_sd-*f@;r-`No`1jp^7+%p@?-KBPap5^zj*Ta z#WVTv0m{?y0WSypPoF&5fA)mM>NxTtBa4GvIOQ*WMQ{=LMUvwfZqQL`6HN-0>lw9ERrqU(bf=J{i75Vewj^w2PQ*>$oLQ!cOOW7^SvLUm?tuyvhObL zKUKO^03>Y_YYI%{VSDs!FMOYJVQTJ~mp=i2jYa9;gtdJso2%)nwgtjLR&{-CS|Ae2 z2HX#n;F}?Ja^-SINsOIIJ_`^E{a!IN3PaRS-}5lyNQm59;1wH}q4ONtJ&YiSJVywK zpTXf_nn~8El-nG6jYn` z6W)*OAdzxYfLD8m!pA{L%@pkv8%MFW{7wmUYZ6Xr|S zuFH#XXkNvn0%an$u0-ZbD(i$jCanyJuae%;MlBNPek^*cVImB>+0}Q z5%~)zBFCbH27ZUyz%K*!sX<8w94Wwo6)7A9ol73v==Y%@z{fy2h1%u)f}e-Uvn%gj zq)ibztWXb#J}X+vP`;0>8#vPf@-h25b=kzd#o}syzlXHf)iyWdebp;3N_3MCw^k#m zDiN!cWew9iq}&7!g~_=&gkC7O5fNing4QV_h%gq?9UkfLnd=G-K?SILG<4_*`uhHo-zm^T2Vdyx4O0Mt$ zEHuy&s%c$R47%YG%JI+B^?Qs0pt2ZZ9Z0iZ1X*cdVALTh|oB@K^-OgSY$mX%f z`vX*GzCrQ;^~)<5V>5QHvb|~Bn1&`9_T~L+34!XaZ&h zvp2p#hU;ug8SoVKU_dnnbR zJ&M)0Y?dHu@XK-K99?0W>S`bx7{ac5-brF1^PFJ2@th0V@IOAT#QB!b1OarIY>$q{ zlfe^*^L3@V+8tliCmsYsE>V_!1df;MmRhBvB`H0n94?Tit`+#%&!;-`4|0yr=tho9 zIg{3-7kelx7#<^tJwDQS!+q3%Y+ll2AgKasJH(w`g5shfa{1}-`1QddsGhrv$#^mu z;`u%;(AOEU%f;e%1+xTJUGgMJf`!9U{tVokW!RNebz5xdIchk;%92^Z;*p8V(50Ob_Azs!eQIp9PRp zh#Weaf^Zc(mC3%J2p8xysC&{o7a`A{5cIBFx!T{ok6-3jGvw7alUt_oCl_BQG8AU- z{{%BqvsuQWIOA>WqVM-0zh#G)6DRC?|KWV}_sQD>avLZ7Xt7{H+ps@Dp9{osA5d~* z;lP&6+Gmwg6oPIk(!UGXTWa9Nu{~{0z6WH#uKHhmSLimp8L1 z7{`Y#d~o4Rd=&Dsu+QF6`WaQMAjN~pH@a_AP!pcvM>9OAHe62`zMe#_ z9$^y(z49|cYH^b&TemE7?(oW4WDBt+ypf#HiUAAPkWEkYstN7BoiN9T-CnGI-~NH@ zTLetG`7EWTLb3PPO@OG!eSJZuzb|cmSj~dJhxLUWi-}x>>>KpAWWCn>e!1yp(aauH zW^zGnAMiiI;dF@^o60+#jtMuUC@2_Tj%<(I)7d}oa2^FeWvC?2u*bGnaD+w4U5)Y$ z$2o8jvDP1mIp2zWt;qH%B zBSg6>q&8rI(Ux65Bx8g)8suR0>E1>2kqY(!M@)!pu_s*&>x| zdOfBs(ZbQcR?*~D7K-7Q-CA^{134=TnHHqX(eMtP_E%q-;bd&JcQd?O;gP^b&MzGm zv^CvP5@`sszyZa2x)SC%QIp?_KZkMWjeR})G{3pQ0Ey7pfT1G~u&zkq5R~Ws`p{4F z1}=59y2JEX9Fz{}?n0M5pZ6wT05ZzKQYQ^C=Ng9mkX;jRmy7x3*AWy03wn^xvi1tcaJzgjq`Fg$SAF8Fg(EojUT?d zi1Ky8jGf!<^TkFyZ7oWWc-RY(bN4aDz?7pVn|8w0ym<`k=y+wFeM7I2OG2Z*Vj)IY zWOfH=aSWU1yKF{E%DIG>^R@n4M}mxrQ9pCNSm28qBn7ZL!dyJePGo7##KgF$K0V+;2K%Y|rGP)?*q(8$H#1z9^nwAmp@Q)Q<%3pW87(1gM+esfkfwIH35l_=`h}m-lm)2AlQ_125_{QR=FiB z2H_&+VoFLQ`aT!_dEYt!b>d#q-1);x;D^%8I|$bvjDi zOnXk6wN#Vkh|OE2NlAwV3UDZX6#Ky9e`(#M2r_USF}hUS`~7n8>j4~TXtCoP>=47d zP@q~DCYz0unk_b$1YX~-DUQ# z{DX%pM?)MwvALhzz`}rW0_&7d)~eKJx9c-rc@kIyn!L*haJ{l)xJHkvtU?ruLAAF(gJXTf`$DfX&2`s?@gHQ zUW$JnxPR_*f6Y1+9Br?fgQQ_mXf5uo%-}Ijy6ZBHlE0WA9wCapxInhqRv#%4QoC$M z>&bZc&GqEd^=A1Iz3;`y6sLd`g%t)<29IfR{66|&$~@7c=F_&v6adYXmIC{O=~(_&`{9?nyVyA^f-Ku<%1=Rn<3OtTZ&t%jE<`NA=wq<|^3mN5=^JD? z8%?9`&qSJ~>i~>m4GR+jav=Lllc!({G4wG2VEzya5-ZF{o(OSqPClbtNAQq*TU)OA zTVTrRm9?f3_14!Q>Lw7sBJ`eK{u8l&$8;fbA_-G~!MGqVm#|HknvCzW`I0h-Y(%L? zn%#>ySCpdUR26?Z()sRDatiaUt|gU<9*QB9z{F6t8in1-MY1LLlumwycYZzpG`eB8 zws2qlIwL`ltESkV8dcVg?W$FP!w-SuJOtHMDtt9xRLoYyeRBQ~8J75G$=+E)#{KYM z-*!qCXM}}7#!VzM)5U~HwwtQKAeEZzvlqN5l#PKVNMA;=*y&5jlzppQT*qK7<=6UHw}%!k}1Jei*$=Xr__E+xd;rV7?~L&c`{ z=U&92_=YC9V4Nw?De3!c#fI{Xj<3CdGtMH#Cpz>~*6R-TZT%UKZH!j5p$7;}Nhc93 z@aalGYCu`BFD~v{@Il-z&b#fAlMW;lR#4(V&4&-DIDw1_dg87wXMliEaz1B_ z9m0*A+~bn7s!dn{=$=q6RV)V(ad-S(ng@Z24<_KD(kl#KGc2k{#%-52*1sXPAWx!t zih0ulQs7EVHx#v?gz+_uBqQ}E-iUD3bR7Q|_)Mw1!&5YSULML+C1;LLHU#f-Tn$BO zTY@*!-;F$`g<{I2>xHY_?tAeIT5V#dJiG1f6i zbt_5_cDxVwE8zSio5wq40TbUk2&4l=Q(KM;fq#{rc7~4ZUp&IZdu)E?P*m?ZLWq%>A%i0c6+W>sf8HQ3V4=dQ zj{%;$INp(FMNa*)#s~8Z;Er7y!(W6%q?Q}JWS3Vo*uu!_wN0=z8!Yx5b8C=Qn4oYw z8I?(Ch~(O(*o)=M)Jbb2q&Pc)6TSJVI40Rj4Ku#-dd|ZH3YKCAZ&t+UkxhsFW1|AK z0IcYOY#q;4%eLq9kD#{Nyo6W2&{)a1-hE5`kY)ek;vAAHn6Nj1gnWOjpo zr~n$J6kI0WXB$G!CYmn3Ouw!tC^ExX@_RZwpFvu#%EUAIIoP-iDSL7)y{j?J96cs{ z^J*O8inLgJTm|D~(}a-w`5`l|O`q5Mk<2r@R4EbZl{>GGxKzv=^W7hY|^-r_yQRyRH*27YtIveKmeZ5Xn=mYpH3F@HN=?H zPwD^i+J>4>YnzxWWsrLQd|wk$frvhB=w9H6=zO3IyWD70a66r^eiVia|K%%9(m$kr zYI-q7jkeuAXqN-uvkv_=e5=<_?3EmN#R}6ujA}&>kgZ zu=wwnsKUfg>))hz=j3bxaNfxg15wfS5m_DJpD|Z#&vGsnz>mWmNZT6N&H__}V3=z$ zp3l*F5`R6I)YP|vhH2-zV%{k(q@wLO}~@c)+iW70Z$2ffSx+*Uf=GU;N+`-wrfEwTICrM>v~2mL2zt zm`nR{77T&evyo`@-Or^v>z=TpkPcSqS1Bs=<|bkncMJeFIc*MjQ>6)5&#I*kp+a#P z*f<6~Q&OdUD{u)h=eQ-9D(tYgAs%aPt;(-nP|O z^`ycpln{NlE$+E=n^_UhHc9>cdMH->3C^PNX9=SbViU}F+~TI8p6rw^Yw!Ibu|0$En3q?-!OlI z)MaPfOZpo?>PfbUep%s#xHR4o**xe+yjjU;p}J!@xD`R~r6qDd^2Cldl7` zdy@@G{5s)Mmh0~6L(&~N>Fs2{^wXVjBRvdET0uHz+h|eRa;hE_yZk%yC%gF?Y}H@f zRztM{I50w|el}|vztMHg=UjRT(=m_Wn%f-|+tYoC0^5T*- zEKxa$w@D~`JDshidGP-J#T^R1oFTth%zl>E8*S9oOFX2XE_Z+1A%&9kBTPr+Vdgle1q+e(*t# zDoz^jJ>H0ri52p$S{-Iog2CD~oJYj!kQtU@?$!ZW0pI~eu7ylT(#Uz8}7bs~RB9-_x23puXWVt`;A-d+E!RQ|DOd;oii6l0GGT}{3r=}s@ zi~0J^{1cK}TH$4qTXV@HQPpX$k^RUm7Y94_l)?`LL9NTPNe;TO#N815Nh$ZPRHB|# z(s|VyF>CA0O{nm18AUk~|``6ihH;$TXe< zpcAE?h~u{})t_^18oT{h1=Sw6pYGW*{Jllk9%F7f5S{S3_GGK_sR_YJfzV$fQ=SQ9 zCevo2cPnt!Vn49>I8D6(ARb+(5-FwibD+lEOEBlU=*PR6?TBi@xB^$7$>#C9%6oj$4IqrJ z$Hl>W{T&3!Vhx$a@)M>#+O{_h#*>-P=9}RX1;_X`93TvwoveZLn|Y!|(T z`Rzj3WAz|8*z>N^d?gduIY2>dW4#!pd+9>6(L7$O)UZCIWAOFG!h4|FrBd?Lr8 zN>Fq`FYnYNsMS&tJqjhP!>@c*hb*PGR*;K>1e~`GtMLNfFD+vkUr3rkJ|4du5sd@7 zu$hT?I57)(NnNl}O=JsLMoJcnmADmpF?Ud1yq*2}(rw88R5(@D&^s+h7zy&u{`CG6 zm8!%f_phSXSR?TX9_-}9>%;L7ugKiP@Q1l7ffFouFr3m8DP6<(61dJn#hKuw&Q|%d z?KCap^sWz*@74WsnZEO8fq2SX0_$kyz=-^ zE~Z<7+F2sllx6D_LU~{8&!j|7`P@RM&oA^nV8gQ-mSMXiOu4wMr}HH=?QeZj8x-;w z$SfI{UPz^-{&`CcfN^Yv*tY;dgs6%b>|uw^N|Kl^P&oiEd$N#SFYAchxn5J0ZXkx` zB*!&!T%Xxd33pTm%E=%@K(w1OAw|m$^6Bj-|@e zJq49EjG0FwJ3ksV$1-J3v3DGW)2~c__M+`egT&?Pa#mn;<$Rm>-F_S3UUha4@(JZb zoA>Oa(Ut2)6~CquJ9Q*eC0KxC657eFE%a5>#r%Jx7bkWYja}3&6{HQ7*4+m(A%@6K zx&T8QCgq3+z_Ntj5bZ>_Yv%nx{IKlT>lCz|;N4B zX0E6@jKe0^>HK2z)1tGP>d@Ri$uoH(w*b(hpBeEnLO| z!&;Y1n`}5we)pH@{ZxXnlDc*`ui%(XIZ#z6GQBUt=Xw^UB7%tqy!%a6A*}64@*0Ir zqF_W}6BMzbunCui<#z9xd4gJB^e&?n^fOYhO14a_&aHK{ zy>SHrKWMmAr&TC4gWs(z%&2{^yu&qQ8ib;udPAX4x~y=Rx}aVxD z&1Wg@sWMXLi$^XsXCuqrGU?5e39csuwlYqxThV1R_Vtk3`8nEY)?Sj|*aSS%PmVGx@ z)mS78$`_hBw4YQ!yOmcV4!siqe7lk(iC$r@N`Obvz%Yl8g4j0uw=u@gAL3`IUpYjm zGAxM~6_w?G>j_*8<^%}N|GVy(lWy=CjU{OM>Rwu%{kpBJom&O%?EydMTQUdN7Wb*! zIpOsqGv!y(bp*g)dcK$*n*#9DRBvw3Tmo^tOX52Iu1|%`s z1T;9_9TzBOo=mZfD+9Gpe`4)oCt`qmA;NdS9_`W*M09vPu{@DrZJ#ji<@p4Wxy18Z zDG>fiYV6P)^JnlGhv@D{*#aHM!ZprgoLdO!`Z%>oi9l(3C9W`)z-y)pywQaf*w!4& zK<<V z-o&q11vteBlM=1;rl{=5 zlak#(fLIhrM%#r~&gOl9f`-ab7oNB@xXowOd$2PyEP#_pL?a$&f#VXz$gYbPn9Q%?(dZ)=fA3U7We^9`*4M zg)83t>x-w)^8eg^Qx0YJPvQXVI&AreqqBpzkdpYD)9|bDzzu&g&kCD|p|c@uAOjMP zzF<*X{5T(NDb~WTyJ9W85j>MCpiRT-44ZDA0^gtSRKm-loQqI1+V@uMYdn^So5lPj zVSMKMy2XlkH1+^5Yp~*l<>-0@M5gE<;4^bU8;qoPm3QHOcY9(V{tpT@-kd~X%e<5G zSw-%X)OLK2$B+imE{U(F?_itWD4bBCh&?m`FCpS{Vgs0shn`bG1-0aka&%B zC&(eWaN}cX6&H7}IDEO6kXpEYoB0?b^C2B0?TBUzlJ{K+3Rxh}$|q<&^I}k^vAt9Q z)z<_YEgCK3^h&ve=wTXHco@@E*emC0s-YBNQr6FV0PZhV<#EN9GootTt;oM3TS+;d ztfF&f`Php2$F?+UUSany+;Hq3ud67ZK}3^z=O0PtOmRQ78N(#IAZp3cKkw$yRH6V4 zlRP-4XXy2T$#pbau?^HaRjYwfy+wxQv7=kNgehuDtJOMDh)S&;Z7214u8Gp%EK~$6 zn!XxqQI?Ph=Kc^1wHt4ck+v#O_CgSra*GK&J?g~wv_(C;0=$DRJ&7(6??IB zmay}E{NgdPN8Z`u<{3R#9>mENYTzmZzbB~3TtM1QMH5cEcGK1!l?y-?8=dW4?SS+% zg6K=C_GAb+c^hF?s)9@N9%-Y_0Viw_J~7~w3H7E^C$|CH0vb+UV2j78u-Iu2DH;Z8 zDdI8?uBn>F_eitk6A|nl$h58_OoMQxCuN;vLA-DO@liM9<2}3e3!MVcYFTKqgI0ts zUC|R#tYR~0riH7c|3sIe1*V~Sc22lfDVIoT7BMPQU6e%0SfL(;@5=%xEKv5(8(<$$ zi@DCZCx;)PRWyxry<>GD%u|S#IPixlXBEhcrQC;Q&b?w{okc+*4izb{43I&uu)8;PXNiunGUqRaUqfkkigc{~9@|-ZbK#Nq|FPs=( zR#C_;J&4sw*>$zZ@cg`-Q46tWvP!Z}&guAjQMm)|NC_10S?zA8(#Bn3wAqXAW{g6_ z34BT8CecZQAoY->s#vqo>1by>Q{LL-3~EE9%bplbf3)#Wsu_+ul)b{4M7Pub0(CT$ zjm)`U*03UGffI7Nm5$C=o<0j6-aHO)A-#{zN#rgTWrd9z&oj<-w2d(c!>8lZIsEMX zh>X)QEP`S`e+|u#^2}m22(g&zM0Xk~S)5+|<8Hl)Il3X>w3LmE{$;z#Z+;ID| zfnLMk#a1;oK%O0GC2M^!ve}|)<&Tuwtru><)zMN*Pp8o4xb@_U2P{f+?z1;?&TB>L$fakpdB}kJ(J%UF<{s=k< zgr=X8To7WWf`Z|v6?ALGPs==T_+-I0xq~Q|=0UWA^aCCJ{d@$ublTpcc8OR&Z*^t* zM$rQ=HvjS{rGD65h1tnsnvU)g@P}D9f>f4-n+Mjw z9mCp7Lj%Xa-WVx+e+rExkvAfkd*7yN_nO+GkWv<2Lk&}i03M*+dacOW@T57pF>Ce!jidEHA zL&_aK3`eCj5>QpIeMmg2VjehV_f}$k1;@#a&&CY<&$%N=KBsfkS)n=YIHv$HMeFA0 zW@mfEIsSr`twoPtQaV|?d6#fDz2*|<9`DD~zbDdw!gv9#sde%I56?3e)tyBgowAw) zqTf06=w9?I`O&>ZsGCjiN{teQEX8EK`FchcE&?!~s8Gb{bqH-+fHfCuI2qM7HHN$- z{*Ks5Qcq=hEyL^9w#Qjg2(cjT;NVZ~xn<&5vpl&>Z%4Zn`Ei@*)o#_?y43i2coY7V zWVoChJh+i*{JQzQY84;*Ln@6$T%B!yD_H7eo)glB?M;RkK?PGWgvOlLr>^BtF|ktx zhMDCN*~JU!7`8V&GvDHKLs62{iW+}-)<5OO5e8G<%-o37#FJ=r@dT(wcVLAc$Q5ll z{YBEEA*AxnsV-dlsudksS?UwWQbl}dWvPiA=0O~vC9zyVZ&Zg>J)qz6&}t`l;%gBu zZWXu*J9{-=RRhT#9!_U-;t6`mu#4W>oWXGIB}>-JS6BfaUip|}QCY7cTnd^+2wD{H zN-wJE11~cR~2C$6jZAjDxW87wAYw^nz{Oj zN;Q-bIpu@GOezu(A(>=nHB%)&()&xw(LwnE+|U_ne{Qvb5%w<6Y47i^G5JC=Gi;&v z+kEr+AxKx!x6KWM4_-4ugNJ8r+lHTc0&q9j_0NXL{W$`ub{DoLG`@z5tfGwvq>Zgq zFn^1Bxdk~Dlpr!OTre(1uP4Ir5nS%o3{3}?Uy?gsPZkbFJm2F*0E0W>F27hn|L!G}XBr^YX4;{LhsqcUHgEH{vfgOl}+mE9FM zq5fpG{Ir^0^F80pVH$5PXMD@N%atxnqza};YOXBOC?HtY-e{JEjU2R}Hj#sJpQX)_ zDtpkX@E%_Aw?8>2PHuhL`CSc$WwXymhFn|r%MZH@cv|FCP z4h(d=>(N^#-Q`$@Ow02&3Tko2k4C@os1L_d`WAn+%6fSO-a7t2CKVx<>Tq;U8{V`F zw>|kPG^4anCFIgZ`joA;rC5gppn?_-7PwP@(yZwh8>d2F8SZM5ff2q`GUz{@`jXeo zA;FIY9%sk+UwRC~B2CV3eJL-_{{7yC&Z?Lrt0hj&vsiW8A0rq48+Myq!5GzMiBR)u!Q835(c_Y6c~iUNG}BA&cau?b(lP^jiPUU{tytPM!IW(^MlZP)L!Bb=ENf?r?HuI32c7hg}7MVb7zXMkH7UEglL@=4HabHT)0 z1e%&dG4L!G(-_>*$!8Ol$UVK9Y1%Ji()I^p(jvL~etNlDu2X*8d$Dd$0ffaTVY!T5 zFjtPbKfo*=gaIK`Q0v-p%dU~w{e*yGwju^8rWR3=jwfh?HFLa^4)=W#0i(J#+aWo# zoAY9@S!$K%avk|1CML-wj`R(2v83#-&Ca^W-rP<ts`=aD`M3v4iZ z#}}f5U_vmTPb$id@_~W8(e^@z7nebA3L@rgcziNKNA$Df!w*tJrKWW|t8F98+%fm~ z2?;B6fo$VS#8M!kbXsuzr3tZVa;oiT8}}++2R(1*QgT7V5%_3>CA!+F7Oh02c})J% zJ#pdzYVuzD&&ev5;GFM9UNnRGgFs5jmMyyGQQ0^V#A*J|g}nOh=kZ|zWC!Wfz68CE zP{qq?gij4!Q#u+Jb@1MpciSs}otkr$u1O;&j}#stzl)(guOvs&08M(_PbPn$?NYlB z@WpBMS0Ub~?yHi^Xl1Zki8GQ@i?f-lQ87J0VpGFzcEa4{5fL*j#rHA#D8z4$oFb|G z({RWp)TV8Tfj*gd!k8&o-E?LL9s)C}U<|i^L@!{O`%&m3NSxxOt3~}n&0);D54=e} zdu12lsq2H6K&g}7BpGOdL33R6WTFOvwbDeS7_FwI_pn@zm>v>XJRwJDi)<3Eu?c`_ z&+TQORVI;J6GYeJo4?&5=Vz_87RrH*4H7K8bV}@dl^;j`W$1Wy!9`7{Xf%PnON9W9 zR-iT4`$^3XwobVGq1>T52ZFD#qp8IKh-Zi?DWZJ7A z&-v5RzKQ?Ex8}t!Ja;!{%LCNPa|_5{)c^|5P(0C9k>?1RcN%`p?!hZRSL=_AU%?_b z2cM=ng@^4PeA$GDN|1f_zCa5i3dI-ZW-(QcZxV<=`#wi_0y<9Y42V^k31A7*twcKF znQRrI#5qEH2Z&3{BntL8vrcy3qyfh0F3o_tcBGLsEK?G$qUEK2Sz%KOxS^LjA}-RQ z<}HUzRP4V)3gGP7c?=wPqwCAi!V@ZD%NtUJoVCEFW5K(4~v2q&byPzom zv3vRZ8Kx!3zXZ}oyHMyf9E|hYifXq6GlE9(_b@q(EKmPo=)`dC8GHR#`VBb+Bz*A`^-*jW)w@u3da(2^l z#Dc_YsWpLh>~FZ|p>kNSNU(Y}AMots3b&pP!4si%x48filoLR}!SkGd0*2}K9ZLs5v_ zPR=J77lkc*&ha{8ZzzWg@$F>lCyB*LK2P4Uch_Xm0qst=PoIyrX39-XQ()(}9!>WdUE64IJId^!h|gss}m- zeU09(H3Y$8s0&1gAMD%F()akLnW#1CeVo}`o?k{kFo(aqntw#WPwap4uY9Dfl0sNS zQ;jkI1^+vYZ}ro3CfC#7XRbEE6t4!JzR?!L+`C;)N&cq4%pET{x(8Xs=a;rI;1jrj zx?0_yTB0rV3&9*$OAo_{(lMv8^)|O^=%4w_WM!@u?RG z=_k@ShlFqO{?;61L<6PaNw5IMc-MS@#0RJw*OpYGof}5PJ-l7qt@;1=QiD{HWGX&< zZzwzT(@0Q!28X@8oZe0^=bNvHA3+RAjuZnu%VbWKyXHk^ZlSqo&ovhFeZ`tDefzpp z_f@P*MPO!hL=rLiHsfG>@`_XQXr0}Hq}8lDgn>r!DXlbp;;>kJ8m>uiXTc;z0I@}4 zf`6Wl-XH&}DpB*Ay?v?mgf@`O9YLGEchs9H2d_n5_9H{UYLj=KdVAl5dNX0m!#vym z6y$2{>Icwb#m}ohtIReqLrSVcXem29g2ZIUBnVo+2nR4Hid|CaAk> z9q)9sE2bwT3fo#@8^CD#BCo(fZDb)pAa2r@M1v>(?*!UH0w!)&k-ezx(Bb@&il!{K zaQ8ok%-Nq}{DaG_ZELbsbGtD%xXPse4x}23aPIuGRz#;j-tw1iRISnk+^sDy zsl*fEsQC;dA*Hn|crJ~14U;#`J0`Fo*&E~8kp>^E_e{Wh_nlQ55 znmGVNn2hS9>yPhIca5K3>frhGw=!E0-d+aR6+E<047rN%T#6gHg3@&qFMYebJ%rPN z`6!6v6gC!YMK3s25;C|45MU>y!$N%))Q7K= z`Yf}VUb7bxSw)D@tXQD~{gfUL_Z+@f0yg7sZ;ww$zm866KhU00|Kkh^{^<3=>12E~ zJpAwmD9)JK3KXJwKVyBe*et`$dB|#hH3Qqt=|&5rQhG$dQcRDSHXEzye6!vz$86;F zTW>&j6+!E-a=#Ff-frFq=8Lsb_sjW}>~=QxfgcwRXIlhfOkJmFjEF-VQJiiqHKIK6 z<`@Nvz@rHB4F_ty%n7N1^_+k9zd#Jw`i%GO?p>^pv zbXwl(dEr*F7Y2V`I^A?ZdK7&{nti~N-cl}hq^~(vIm1?YQeu>D^oKGV9uz^bKxuD@ zIlaikFA{~5&}O+pyVmEdhgp6I8){?X_!A<)WoZQ=>WA}V9wmE2b4&Ry<0FI%o3DTS z4A3G)RN~-YxTdJ+iig6cQykJkxkDCbN<}eo)?|T|ICbjQe0$0LXP3+C+q=z--4djf zEHq2#sAnrqbLj2N#+0t}hNQ$d$QW*%cdnpES5u60nMc|TzPxpXPAlycg?{{hR)bWe>UO3BIBM2D6*>t*NDvs zGU}qry4(AW5R8$LJNxr=6W2oR5cM`AZkiAIOSs8njHYLCp~N?=44V@Uu#XS})gt*&u(zeB!m+#Ui>P z&rp%0mA@Ognp)qTyWzsPtbzO2!qFwHR z!9-1=w(gQ<)=FF0F1@rD!kvV{2!EQ7Q%S+3kDkLI83-b(VL5ooV49P8p;;;p9}Yb_ z3LZ@k$48^d@c8}v(UHtfG3(X*OIs$yTPQD_mJ8{d`AWJusr)1ac!`M@q@C#1{jX`E zqNl_Pe=3V@e7G?@K6(hUo~+N@e}+DWv&}4Kf`&f54na*kLMOQO{6xCz)IRiQSWWQ* zUa3@YX`iNZSS#u_9e15EayfJtTz3giW@4nSlC#SAK8A7mbr%x^v?3j)Gnvq@IY;*%&3|SxauIc#kvEhxYsbwhWXm#r7RAvJs=YT^`N_;mb5u&cQ zPL+`Ho91ZJ8A4bx076Hvl-t=QDzjy{7B(|$VlaSYcn9CEZ-b zxk?FhhB|)^AVS16G1GBPY-FE>3t~0!t3NE{xTE#w<=x^+?bJaqq1_)C2bqL1KfqIQZfMBh83c{9 zPt(QG^m;~nK9asyIUqJ4c{dw3)a?TVq8UI@Yni}FQtX4e;6laA+7upRUY83poW@HNYscMlu_J4`g zv?%*&6Yp;~tN*Z_H~98>3{X9A(nl7Ga7kQZ9m{!f^Y$t1EGAGMwzm~*1Z#hAJY$Qm z{JjuU2FrpL(I4D@1EFK2)y;Bs4I|_=0Xxb`1J8puPG%(O*Qd2zy(fwq#rzL&kJ+1 z5zYPa$6%0YPvb>#ulANnj^ym_VvWy&B3+%t9>_&>Aw4=cJp3>EI8hz&S_*vm)l3O= z7F#frG>+8|hNQ4z-RP`!wB4CWHA`&c(=lP{_pzIc zR8xS5XU({r2?PIYl`d7ozJd{t%D=47?`R4%hJGPahyoHTOucxHR&RPIXIGMx9sToe z4ugTa-Z3j$Qhg6S*C&&)4`&;xa$$Cyf8%Gp`RLvP-MpI*<0@hzOY{lR+Nmijpm$U7 zDVD16*T7qZ^E79#(GXY~lw&hqrmYI35~;t!HgkxYlJ8M5*^2iw#vmfpZM2`XizUYN ztt#C)3d92AWcy*i_Q+XExz8=xnWd1+y{y?Zfk!IDBLi-xOOtae>-CZ5NPTQ zaplDMx1ox1A`xGeTqDUQDV^l5GFyxODoB!_VHLkjzpfPw3CU7V2Y1`LNERCq>1&p6 zFkVP(95-#gyo1-if{~@YIUBtn504Lzi$lx1J%u~|nvwCbfX}WO7?|Qvvh!6j z4VQIG^J0?bK@Z$Cafr(;;EW1kEZ*?=1GtsghcV0N1XWu0Z}ING&%S;^EtBp^4xRes zaP|W{Of6afb0s@3O(K~t7=>iV9%e0Dq#WJ)7cO8f*_3xWrus!;l`s6Qpy@j;UD9g_ zN9Gst3G6NLvZ}X)eOg>1az(b*rX1WnY{m86;bw7&y@*>jv|<_hI!x(|%HhP%O^=_S zSqObtC`({Kyc24p7;4QJv5$f=R@E_U`%lhWI=rFaKWu>~EelY2V4yP5>*;KBx4P+w zlBxFU@%lbx=>!CjlB_L5*1BHCW~B>m!7cChbZeH`$cqV-#ffLFKdgccRGB1L8K2t> zsc!sbL4#3w$YG6eBj1dF^*{&zi)9oe3UX)!vdKh%4LkbvvAb4ih;%i-L{BdFyS1`g zmtDfwR46dJ8J!^3#2|=m35(U;%^3fW$Yf}Ovx2QJ#wunzI~i+&UMU4I{qYbQpdk>u zij2}KMsj88GFD-Deyk`zE0k%Ix^8=5p!_LL$xZ%6S%j3qpj~&X0=Sl6z4LlYh(w!* zk%aG@HOkVEeQd4>Vzh&09cu4IfFp-#>yY*MR+genEVBCxm<}v^IT15=I$*>>zfA9^ zXPd8!+1@8Ke4Dwx&&$;iS=~R73A-6O4lBpfXCy2N#%luCPCLJ4^1Mg5o%l6Hz~+f_ zaIo^8#=yzwkfOX(Uo-T3 zGiP%65~IO8?VW1GYSy@=(nIbf9NgJ|9SwgzJw6)$FP$vL6CXsFJ&YT+z7bsnPTs*A z^D<=2s?VpqS<(+n0pnZW)W_hI9uc8~FX4TgB}-ZZPdW@|9n`~WlMMwGsYi3Br&O}w zvemA?mW43zbG8XmV#w^zxxgmqHOt4o)7kX26)wdwoe6escnG41z@bijx4U8T-s41L zUul9IRM=;P?FU!cLO9{B57y4Gpk;yS#fLR4$u`Ybc3x2RVuYNvBM!Aifw2umh}P*L zk_L@0iO0l|8^g&ZI!7-)Im&B7#wj8rk$%L7S!|#ptg@zA+s~#dM`siCbSfsbLCxcw zL*@0x#ZN`&(CI~!30YB&p13I-xyZZR+q*9)ht-7r)?+Tb-? zNmK6$b9Zt&{#E+Ad#$utoP11O_)~2UKmJuCMW3DO7C`v(+?G>KT3|K(=|wnhq*UY{Ne zT>>VL)k#T(Cc-LJA{r~*th6G=8=eekjNOZ6zRsK3?dEgATGiah#`egUHK~oyh9c$x zk?6CH%1*)huo2~TZFSkV<(QRQ&5}43`!bSgv_2zAQXApwh1M#F|6*IQX5r8)FlEN& zRa?r|*haa9tm0D(6|_{;9PBD<=?OuNeuiOwSG*GDQ1OSE1L~?a#xFx(A$nt;MJP_e zN^jx>*@LTp+^sik^O}0yXOqeDc8$hc1yRemqqcE$xfoYqY0mXC?+$Jl@2pYBXmo-8 zp*NWH9=g%m+W0NA%QMl?e1sM7UMP zd)7Jb+QR_iVBa=UANwq+=~-=4D5p?tXq!v}<_nRgxj{jK)7R6Qu_*9oPMaCdjQM7N zcQZ{Aa1wdnvR1NF>=-IB&6?yOZA&DraQ8jMyLXa3GWIR=rq3=hRO<>!E^*BzercOm zht?9atw(h*k=1x&(5_F}6j(g7|5%6FS^_IriX5#j9}Pnk3sto=9^Y8E#9P9KZogVc z8oKvP>Ju`m8IN6)H8Stxk7tlq>4EgCS@V-wPq>c`5cDUgeq7J4=*jgAh%X;qOBZ-^ zg6iyRc!OO1II>?sP$QYJ^f2_7(v9+qOE-U$binCsdii;FrC(YNeI1<(wjCmU899OT zmZw?6pJqD|`o_Rpwx@I;Qmd)WEb#RpK1};`PCtBHfA2b4_-GfcUq7LLcaqETJ z+N}A6(=@oG_KL-9fok!ncx5CfH3J*Y&hpWl{7fD7+-cXm?y_bY z47e_wk*oz8?AuJJ$}No1&2WBpdsM1fVE-JhN-k`d7=W(C1fuP)btkH@HpSyVJV$%t^pWKPb z{9`YSOK@1NcTqUH?;a(@7Xq{&ekcZLP2*&J6p@dVElehW*_F}pQmn0J(>EBXv97Ls zy+7|^C$Pml+-kBw4n53aGv+0SxHD+*_E5W~)Ma;emy`5*aF%WT?GD|!=F1xgWdaQ8 zp?*NiM68S3uk>+ndb3Zn)sI)pyNkt4TyM?F_9oInOpy#+f^mUa@wq*ZxE$;*2CJuF zIDNG&Ijpz7>!uVkDgM6C1^~E{Ml|UWX$6Tpc#%xx7N3L;6 zZ(uycb4d(cpl&Lk%$HK(Z3;H39xEIpd!k5zY96HT4~}G-dEA*E&D&RULU6R*p zeGdb|sQI_E*UuywJeo_kF$;C~33X3Y=%=N(YHUKkp~5P4LgYSU(;v1P>~YiBeXk{5x0UTT&_r;z@Jik`twabZhM9$;$lkJ!tB{0{G>Zzk>Q? zGxJP(JXqEa;OdjiZ&Bvr*e;2Qv!`Idf`GU4#q9j+?W}>kJY_GHhAiKx`1sueoup~!!oCcGtADX5B)uj8XLHyjflx9&Ua_C&J6m}&7pF%8uPxqJC`o1}c}1Xbxs z?*_3WVsMSz;TAF>?0oceJ^$a~Bu2X-a57-1iMyc2n)I?&;+pfub^i%&3MD*mmy5;n z%lzh(3$P!cgjEX|H5?cP*{pk2kRsW2xc=1_)4lDOVEJo?`1(`{5(38`b2>q3>@uq)JFUUG5h3d>6EL>8{t;; zC1d3Ps1y==G}Wx3n_XE1i{Fo`@uqB{CI`%&E(UF#f(uiu=<9#&rg!>GAFxCe0)!_G zQ#zTtBXUC!f<9-&uC)!&+ZMZVSrF+kK2+mT!#_pp33+kJArLn0M5r&Scu(wQ8ew#7 z7}E^Ta7DZzJL9(W{P+Oo@xj^YY`wfgWI ziWC%oLgt82HwCQR#S)-e4j_dK!cY4BMks^HtxZwLqsLSM7 zX@_Zr#s{W_4LCe_|N6~=0C3|9b4j0GP8e@+F*PB@WDG?R)8YD<%j9R66)5XZ(qB+|ZaL=UJ=-P^p9^Wfc6tfURfK)#Ycj z@lz0;HwEUb7KG|*LJS^p=H5?#T5qPSjhsHKy)vKY&wiAkV6W;^epOI6+ILf)EX7_p znJ1^m=cC~{%VrtK`&`;$dGqO!PpG+q@B|B%RWOYaVMC#HrtqqW9V^~Asr!4vx<3&z zo4P-&XU#p#M6a6MbHwKq1K)fr^^zUy)tK*tHewfv+3Pt{&7BAc`{p!PDAM4ah2kovY1IRKY`N-7T7_jUnXZ`ksZ~& zptS(;^DUvgXqx@+W@Y1-8j9p9FtYtaI+IcmE^$HKC(3ZeK^@;Lq$9ESudZK{wb;8M zs{c$r9Brb$trvQ=2P$z0Smxl+@^-eGZkDV6@zCEIL>QiW;i7ZzW6>p)jmS9w-^g19oA0x7c75jw(nrQ(A)_cBj8m5TZrMW`*)E5JZn2lmn?` zw4$q)(MtjH14Kln=71{`^&KHREoqxd;_gaZ_)xju~Wsj3M@?V~(kp zCTnS2+dCe_DL97A42BMjH-oy^U?8$#d=zU5dwXr$eWgT5R-D99kXY7UogTr9j?IxB zDL&|&RXJMOfF24S+qh880236A`7p4UW*ZyC7HWL#idU=!<2wquo}qYc^HmLs{k3ij zfDfgQ36)gYgIM!Kk&kg|i(_h}=j)-i2h#&p;?R0K-dfMAD3EFXeNh}SvXvp&jXmnFsV!w;V)Jm%%sc{c5RyeK66dSKBBeI z?2k({F$l-Gr(uUeJd{#R@HB3vb#ud2?6e{@fwWdw7?ng|dC+$Y1>2|qocTnKYDN%D z=s3)CXy=?QE?V;{gCLwf%RFrAQZP__g^rsF+D{!zBy2`vs*_z$?BQ2 z)~Lp)+zx*C^i#$yxJol){|Q_LR0t<1%fV=j>B86C>zuUw!n)zQnKoR7;kwMH zc0O!EiQ~}m6!Q$#kukaE{=VDb5E7BS6-egkPAhUIySh7Cju6bc2V+!0WN1R&0rtas1TCofABdF(1I@yM7-Co`*zleMMgckJ#{TqasZM~h%erJbnnaV^& z8~35xtN57AXkz)XdGo>IA$~jOcVYLsv>|2qgU#sFRK$ACK;D6?;yY;9GM9_R9|@jv zJwx6|zf)G``_LraDEqniC<@4;*54>ws>+`_ErehA;l6T#8Q*B0OUplR-Rv|T?mu9< zp`jn&h$xwbWCyF&^sByE$;}o%>V7Ycguf|kpQ=ZbY~lX*K*sNH|#c5A4Ac$diR;AM%H_<#rfsV3!Sx9pUjstemz3l<(-@#<~0g^+-k4)>gtc6V`eO-@}7r36R?n$k_y0 zmjBKEWC^Nde+n)?6T8>MEfte_B`e`u5+s}JqK=UHX?7%E_=6@NO#PL!Nm&PM4|5`q z-48>)YFV3(o-eu(6M{!YJfpDeBUjRn#g48|(9spIu_rkN=}L+qOyaR-qeuGi?KxGb z?@DdxfHDSV@iP=~Z)*=I!v|l_7MO6(0G4zCkvIF5Y}KFaCKDEgAeYPQ+q(^#_r}>n z>Wi_sNPJ*X>WCe@%IX%wCwM524Ma#$iCpj z=gKNeSU^hr0u-n;M4f;qxs0os=`@Jpk~q?p)kfArdtIP8yajMFPe1(x(_ct2U^ntkQ4fg?3P)7CVpfxh;nNV zP57!nuW|e9U$a#NsHZE&yL-qTXv>Gu&6SRdhv;#-XFdu3Aqy2q-bsm`lzYCxW&Y&m z^VKboeZjaUMqdhN02atUs|M^pW>4@IT>aANacNn)M1`EcKEFmJv+}vVmY(;?3v1!r zzNvmGcwf|t(eP>ix4Lz!Lisp7h`G1MS5bcwP;#e5@eyK+{vWR3+%=;z?^w8{{ka!) zY1;g%4yd)etUmGf)9FP113MB@jJ}&dDOA{TG(f+fwOfM$Eyl0#vCGw3O_!l&ia?wP*BVyHu0o4BD;A$&@tJkC}gf) z<7aRVXJ6)<%g+iFeCwic&3b!qBrRCt9&#($-KUZ+rPSW zuQJzBlZ+XCXZ~m9fz28f4R0q;pgKe1s9$F*j=H#(Ca7Bg2RF<hcYW*dBfk)Npr(0JjD1I2re>lXu zapf!ZFU@-4VB8K2Xzup|imEz#@lAJbW2xWD(4a$_6Vg%VXFFI&O?*Sxa;ML-A`9(3e2 zm3(!~L)+evF=#|E$WA;JXydga;qbYpbW%N}RET-A-a>Rd0ifrQ z<#5EGO1(&erdiE#Yn$}vnG3mL>^0%FA@#@GtZ=6Ylb1W|jd&9PsDtddo)XDk1d=2b zf8m-SX%9-{^xb*FJ{M!^9Mu716(px|F+hg#%}9xj%IL4^YWQDCm^fS%={=@!i7lJn zPcK(&CsYAb_McT|xbQ~Ia~L$~K2-)Qc*BFtLUzfr8G`Ij()_5$DbpuX3aRu;432Wc z%ad3uAT7JH(k8^$5;yYIY^$gbR^T-|A6`iSv!)7%wcP2ReyH$G@sM-_Pdp@2G=+b% z2cx$~c(1b!WsK%P3h7evgydi}m7ERTs_b^EP}uQXp^GK^5{7Ky3EtI7_*j`HA+$OS z`?_52!K7v^6TQcKKapTILD;V>>%-yZtG{HgNYj()$<=s5Jji*92NwP}v_VC~_4+ob zMYz}P!109P#Ian?$k$$Tx*YG4xx@v|aUS~=V)%#=cuB3|@(Olt`0%tUk?ST^hIFiIhvptiPifvjvS zpQTba89;&Vj9%nPwkAaaJ_nhbUdX=?J#_oUj=u-Fhj#Rf#J7otLiWs!FBKZa^>(Y? z$|E!!T;Jlhs;}4NmASP!RFla<^KfyjDT5%4NPhF-bbRy^|A()_#=lDI--1!diHtgV z+e$?dDxE_H3~+>5uw?l%IUHkiLcLc_y>lYQXnum+K}fTA-OdzI)#Vb+^04L7fwr*H zCG#ta5^T#5-9nm4Eu8;~AZe?hmsTCTm2m3~OU5g}MLArLtQ^nS*>B@>7Wy~ZqkOkQ_wPqX!kyRb%FdW(^(2t)XcjnEIR*QQ<|$|iPh-9}M~WCSEnUuHJXK{; zT=>m+z#nozx4r8*Dh@-Y`S{k16l^2c&0Or_SWeFUE_D2DgFl?vYR+A|UofQhu4v^4 zggO7tZv}3^Hb!Cjw&>;IoXTZm1B@3Dt;1k~GzM7-5j*VUzK7A?0ARkSe>w0lmZlTF z^29=z_*duMc4i<_rlAzY_W7cPkc=BG7s#cH##j`foWV0l+5Nm_LOBiPa4@!)JlWtl z=hAalL@^aGEq#eGRjD({AQRWO0H$*@N8m=oridT%*2~{R{D!ATgrrUNC?E48GQt@b zM0iI1`F#Cm{%O8Bo1up}OK7{Mbe!e32DW1hCaN_|MFeOG(q5HQ49d7Np~nC+$ujhMAQUa3C`J=A~Z7S`OAQf`UriR4!AZ~GPCYJ?TZqV zTX8j#n#ym$lkcZj|F~Okboqsc1pI%!noWNn;oHU^T{jR)*Fy+3yTWS)QTE%ajftdq zXoE^1jR$|~a8k&ANQTRtV1EFlbtL`$Tiz0C;i4u5Rtbp(1+lK|(xF(2%#^|vULu|% z`5K>V;y|!VT*wVZ)d2EMKQU_F5s{&LIV6ay=hEytWYfWE*pMz_Ra%BCS}t4xL!lY! z0w8`I3o5!o;qB_C!k*YycBwJz<>-KXT1H^~nDDqNE-id^H`0siB`NPxewLM-IE-iK z2j}DA1YHZAKGS>bx*bR`V2#PI{H%B`Z1v?FT{5-}T%@D-!hrC&y@A`ozGW50zo_K% z{>|+%IutfM3g`ROJ{PYAqk4;>tePl7~+~=2biD){wV)T^J4iDmNj3OrGL#>qZ&2}w=NOVcA0$&mzU!~_N&hT18&vDboihd( z1fR{?lGFj$?7J^|QJrMXR#)_kQ2%F+YG+Q-wa5UfU}M_JVs!Y|%{=5WiPN6#m!+(CMEd5WpDrO=!66p18Ej z^N}C=6onr4^N@L21YG&Lc+Lkqs(LGEG2k>a5m#p z;edMo<;00@vr1OB5Pv#>qLE zvUi>cd~LhH%Ec>sYrNr2NxA39F05xm6+RK`bd0UUwA3tXZv-7K9Q(WTq_Y*S4ikY( zJ3h_P$kz6HN0Y3zaAtMSUgh?qwK7qUn!iR6U}uYxIqR7OTa`J$2s1W6Mlty9lx=51 z8)V@I&(2Rj3^m4-k_9K%FCS22cRFL3g5bJBim-!k5*WrfKgmI0)Vu0Q!R2yZs@}|P z$f6K~p5pkj>`;SH-0QkrZ^jyVx&_a0kHN$Eko@&_BNs?{NmnCVH)*UEZ_-mflwe-r zwSqFLys4dcl4#V~Bt->r(+Us66~a&AyURrkTt3Y;+%9i#!KW8SQ3U-Vx2{OhKswM7 z+29zucAesnu;%!DRHt7pQ?Eb9Vp5#v2|xT4<`tqb^J=;P7)1VRdb1f{h@%jz85f~H zqBbh!EdQ}1nVBQ)Yb>bU;b=4sUb$u25h>NFI4Ba3k6xX$yeVn0&1SKI1UY>5g-p&|9^GAw6vl5)U&H-3Dx=@j6aFfw6dp&MhgeCpQJ{+g8bv_|ufEEZEh|Pk6UQNu|QJB6lLy z+3qrBTQBtzZOgT8)3`~K?73Uo>6p02AwL}+zdkseOxAZ7lko&sAsYhvbb7Df?jvK% zg5|!z9JEevN+T*pNah)^r#0mgBX;Yl*8F5oj;5GF9A*N_dF&7Pf9#lfJxD&Xud+mZ zMj=k0;nGTR$Yi>i%xC$KOYR*Ll3t#^2o&WlNN8x-xhJ*zL% z)m1aU`sy#m2KLu;jA`uX9kZAaP1Pp3ZUpC)`9lbPHUH>*=S18lSb(1=XYX{8Yfw!t z)g}>VyFhL?QB}eA?dD5LLCtQy#zz<8oBKJjUO}w-#oPpR4Pk;ZllQy?raE1kk!RY< zinoIM64ahoUhZ>qqK2Glzup?l}V2*@1EvHV*5GZgS zzaB#wKR$Gb)Nh}`=rng^=e+W?h-%x*FWtHPw=A~OP^_4D$t*{?XU0Ig>l?GQCGZhZ z56jOR$Ku$?n*5(n0OZf)fG#FZOc%`^Z%x9osiw_-6FgmUXi?^_q21RZbYDV|=0bb( zi6LIsER{K*{js4hFQ=%%pKre6Ez`Q&ELJG^{Z4j+*M!bChAI9oxr}AwHraEzZr7(E z==oq-khhOc_};(_V}+$2rt%!v{D*|_;rZpo?9=?l$uJFu>&-kpy`({6Nyw-98e(`n zbD?fZ&JKEJ0I-K+zO|!{Z$%_K+LD_o=?@>Y<=CP1{1b#WfG67Ohp02i08DjTH|&(C z9PkaloXSZ<#sOioQ7d@TD|5y@-bh`T>c)3-1FxrlOxA4RB3-cH1nHS$aGy+nu-v-l1WAC87UkB09?9DuS# zDUmUw{XGjRTF5pj87M_9R!@PiPWhZDZgIkvjQAk_j1|D3Q;)B0*%<*K$P!QN4tRFp zo!#M_e5Tvgi?$Fgv1sDi1dRX3RvbFk6xSycVs`twQ52IkT~~wY)64Czyfcj%qu}V3 z1n6$v!ydjX*1Z;s#Yk)h;oAE3Gifu+yl<)F`Gbsgn1)eEBBT0Js%~j4ayPTWg{s1c zB|nn1ltRwebf%)cWl5*&-DT@%nl3V+Sw*kiikzI;pl!da*&u-bql5ROvy+2i0sYsp z6+RT8d3)(^Wo=u0 z@h#|m#Nun=2lMqW)BCAkwpi?VH2cDb%wpmJ$BGrpHf2)1xI1$JYmaJ2ngYKE6*7(`cU* zZ=yLZ(2(&vNG!59Lq)koJ=(M(qx@)lEg`>e}=@+nZZ)Ud}Q8`9aXH(bJDzE{|<==c=mt z?40QEHAZRu9b)sF*&mzVmMeA+(VA~JNmGt_Abj#o9^hm63Vz)ZRsIv`VA!c4@)nXc zkiL_8GbGc|b-U(k5&GX;`6xxLQz>B*FWUq0rJQrD+Zku#P&S*kk*@AOBQuD?ug-C!vzgWY${q~yf4Wjza&K+|Xu-E~3@ zn^w1N^&Aa9HjBj?{x0rPV{x6vRAgz2=N(B4Dv-^kG{($BVL80N%E(XAB2)^Ld{n49 z$B^78eQUR?rH`72!+OQwNQ_*1Uo$z~zKlU)Dt(WjK@MJ0AHmjr?7yTAo!32x>P~wJ zO(bO9qN+pl9;d3i)M?{1qfx_sE!EGH`MNYmRvvus^K5!GTls(r`<+|KT9cKj*+6rM zbQxh0rD@n(GA>O1`EbKI1t0$I&)2_w2Cpi?>_`eu3@u^c0neP|W)T;%_mGgUJm*F(%%!)dJKvf#=UKKstN}Uc z;?|q0<^i^Dl!2xXVq&t*O_=MBz+meubFoW1Q+gTQtvIuLwptIt9zPtmb zyFwr(VbU3NJ&jGj@pjcYY3B->OG2~vZ#Q36a#Oqc8ZiN}5v;@X+k>epTOxo*=*ArH zVeN`$U@hSCc&pJ{8XZEzpLcXj7C=6g#>}Uki~kE=b6DC;ay5sg;w|Gy=F@s6@?uOE!POy#oA+Qd!m_~~G4m}Xao zP*a-OdoZB7S9C*abbsCa4#s9Z!y!THAvx!nh(&T;NUNhCts{|zpaC~i(%gQY-p@Xu z={zm_?8+&X>OQ~Q%Qxgs0+Zg!2=F4u6^0aJTO-me6I2Qb3)naeRE6_>9OGwOy8R0h ztt90*qsUVgNs=I+0}5*FVln5bB!^A=m}rwYf%M_Y5_8n4xZYZmH9~yhuw{`>?|3ex zW2K_i{yy=Zr`=H-jZEt+gr|*uu(b_-Rj5G7>Ycr>4#&T@L=rH4sTpKyLJB9m%B5*# zgK&E{cSV^;kB@8n*Nh=`KOiFYrOfcnqrVSFoVnq+Pn(*t3gv!Pqm7F?JwT77dDD(TBT~46bl7x&7{i zs9<)9euF~DGyslzocQOqdpn+sN_g(_-#(1a&d0|`;a~WN!vh(knE2D;B31YT6FyU% z703A&4$(dbuKBV*J2f}o`v}03H5pP&TL2O{z}(HE$9+d0kt-|tJH@`Lj?C~tl~xCf z4C)|ubjg}e81L+#i&>4&Q}rbt|0^)#w>6|SjmOv>lN)0~n!Gm2r8B>gX zaFLTAww+%aN}5)zKrFD_+JqvaAo>mkv{R7%XOei}$1_Gvi7NB4+#8}PDPK$~fiW&4_n4I2t8nM0kBu)F~JQ9BAxou1@(HzSj3~bjLoN zyqaqxDYCSO&qd5CAcW`V8DG>JWNwa4(Z`bQbAe4U<4T^Uf!z(3+2sVFGMTus7t4>i zyfN4JAvw`%GuS%z`bJq|tnh_aM118odN*d&Yy128#>Z$;6Vi*_O({{i7>F=|NF6c+3Rc3!&qIP8Bv%ll6-JeTx zVF_cUp5D36p4dv?F|!l|)kdq;lDw*44F!I2%gtK*Pz$v}TVSsRG4A{|*NW=FJA(vK zrDC)9Q%p}@EWV!2WJ1x_=ki^l82EWrj@yd>QY=3c!Hqx{F4ywnACPkE?AKx+Z@rqa ziUU2MKRvp;VHhyGdZgMUF{|4j(seq)d3}F2!K6T8|8g$+g}CS=befh>gED3RR)2EY zOvh^?0*XMp_A;rr5k(Og=*EzRD=(-7a^-mO2Q-k? zA@Xa}@_Ca>FVA4rIoDp3 zNdGDJAOM+`pWl`k^DdOFJSFBZd*w^-o16u!N2uJBVtmx6w`fQNzC#QuIiX`p{da|m zsNu-wQQ@`>^6z$rny0@!Jjy-_fbGuSKlaNjM`}H8I+j^@!P^bjp?bP!`VHMyIq9u*f}Uk+?T);516>%teMAU2vFbb+ zJ#TIccc|HRdjBcx$y2f?Drhp-rT1fb-6-YT@cFaG1xj$M+iu`z8@XBK9(J<3q7Yrp zE>J4PB)*}Mdj5Vtc)}u%!D$7mz*XsTd$P}6wKT0u;X%8 zjuJ94E^NKy(7UqIo@t6}-|%=iqA82}-H07?)C)H2p>BwbZ@F+eVBZG==kkPrcB_I* z@Ajn|V2bLE(+$wg^@Yfh0O3b{x92RW^dcN%8M__4boI8Nn1)NG_YrjbV!8YsfgI?5Mt7l@ekVs@ zkkt*;Xd#<~s6J!bL60JJ6<`JZiEp-k-da}=FnsWiTltRiBqi9^@>xSL$V5nV{`ubH z%|06$wX{Jw`XwO+Aw=3kAD2a8kwloWPu4=b{wpfG44bX-LQbItqKzdUiCT@;-4)VRb?2=IiVLv`WDw|y$ zFuVDD!sZUJ-Lo4C2ie8$?`yQaMJtO5l!22q9!n}DPz;TSxSuZWW|WhRo=LaWR>@_Rt5FHV%N{$?V2|$M?ZSN3=O#AK%O<5tCf#>1=xWc_#hw%;k8fQ8Tp5 z|I6N+07!P%b>c0cxPlPTKcM0=AO;dbGSzd3FwoOeGt)^=cc-f-At2ONch}5Rrn{?C zRXsi9Vn9F)pscGdh#Vq+R}oOTbU7k7D2NBgsvIs74gql&Sdl|k_Vc}d@ArQ7d)2RA zRrO@tV9Y1Ku2-+#`yJo=u=Fz=9FLI34){Rf`4QVue<$3YQ@3soy4kfoa(u^V?MN7% zPoze(n3lNVtzyBAKN1#GfB=l$T&Plt63?XM6LX0l*n9T!9vGibW!h9}Mp zY%=zUOtRuhjID_8e#}|0RR<+<=^QuB#ER%OyUB7?rea3&zf>`a!BiTQlpq<4%9Ds1 zolFF8{Xt*RpW?tAW-&R^bFhHn6A$bcHP3mXdK58FD!LD#j%p;!1dJ2SK1-p zzU?Odtjf7k4j#K2gg=tvo0MFJrH}#-G(m;CIa+^-0nW7OTj05<$zN}^VZhbqI=#!p zi?p9Z@CdY?9N#D?IIO4Jp(1$Op5)p_*u8*6ViI!mX8&s~IS->3xx?7Z3TikC4F zHs?x2El3;`Ycj_S8p;luC)8~6+^ZtPV^{DfxCjKFD2tQ-etfIbqYKStf84*Upr6Z0pl#1=;7_;q8E9Fh* zu#c9o4zNecxTr6jUq_7n$ovbfMU;tML+mN(zbLZ0h)z<}ADWKyRJ(i@QO&eF*HG68 z6`GN2+&rJh?oCO7XV*KeD<{0zD}R^tx4$tZSQ(HA^pdWvp!T!4{JD?=_>Y}dJ3K?& zg8hogQL@qB%O*M_E6>ggH-fjb8W^4*AcwTnUnqC-Iz_BMlqC=@d!7wwnZi-eWxn-5 z{)7uRp~hbt#4>_qkQ49KkMXEWz{&>Q+ME{RUTbykI!?mytuirkHjpV;oITbFYH0iG z;Fz;U4#P%S(6ZLeqVjDnN9$SQ*H;#&Hoc$?WWT5ldBbtAdk8g>Ti6D@3 zGSppYEYd6hcb!$#>9E({K2uH99$q-M+{kmKD2~)bj4Y5feclmz!CdlRw`+XKrF~^i!w5O zz)Y8(U+7}D^LE+xF8-(iA$q8r**U#h?=+Si-5bf_hPgJbe7SO60guZ^V@(1|zO24N zO$$ae?-Xb{YG=Ygf(IxlpixE#qJS%WpEA|##ov{rGE^h!*V&Bv|t%i z(FXbrZX+?kGI*KKAW%|Z!khh3JTGiBZ4^D|D#@I)Wk4<&F;{gID?&C{?ovXH+1|s( z5wp*e1=MF8g9@UaB4_SB%7ztF2E6MWZ^g7!+F|*@v-4qAipn(>LKg8om-eos z=5>8?qlI)Bw&WM9u!Fjxe&kIavn#UeDFJQ962qeA@ZoMvRaI1YWY;Ic3f4NBfG>XH zQ61e>6&Y`j=i_T80!tXD%Ux4}A`f-UOB|iBl3^>>F=rW z4;)xpxB_e5MQwL#t`1#xz#w&AG6xH3#w2^Y9_P0+` zN%yhl5qXa62-#s!VEzKmloiGT-Sw#A5DCBc14UnRAM()Zt+QGKDdrI z;B6?Ny~|#chXSblIr7XFPo7nSHV03$MGT6eitu?O@{ksS-T+dEY5=iyT?%jxbO&B& zPqmF076v6X>?g>`79l;YxUjK*y}2$8fw)X)cJ=*{b9LvLB-xpjJc{S4F4sD>@_glR z6{7rHvjb5YF*n!M&u=zcl$VB;!+iS{#Rn_@o-IY>Bnn=c%a~y{X7|W<=Y+9loOFF>6GhePujciKQndFNL)pBVU4QnX%Ep_i)^vhsw(p~%f z3JPnT8jNEt(Fh#@MQdJ?fUzju{T>Dp8D*_0IVP2Z6R`l~+e6v{F6h!Ysv~1XO$Mi$ zDv@<<`p85KdgR3v;-`I4TBljtjD+QzZev>+rBV93iA9|v0ND4DcS&g7S*SU6u|8A~ z=U~foYppty(7QpG$m7k3*2B3o6V+gx*$Mbj1CfQ&4fGq>$JUXxOQRU#tO(hV5+qx( zh@6`+nrFdf>9ZP@4?_2bN;xQoagc}6gU6OTw?_&nfwC$>!$xu#d|Ru~+^BCL--;uQ z)J*2k4qy&fy}-+t)Icc9nDmVCqTM>KabD|~l|PiomE$>QdlYGV^j9k5pu zF{V{RZ>c^4B+Qal)Uod>C5~t<(SQ~Dr}(TU2MYDyc`nM<(v1>!2Vpyv&Q@O~#-r;PGrnPoqxgohTta zP#hPhq785arH!me^N_UYVW{r*@!C?W$$j3Edk=9^`Y6P#WKLLGDsLdC_B6c+H$;*o z5OSpch}K?L-| z=5$Ol-~5>N=L9K;p5o3*q=o+O6w|W8I}UMv{RbCi&eI$EeDX-{jaV`Ya#wI2vdT*w zW~EbGI`jV)$+q;(yNGqCMGd=2)=`pA|7rOl^xp@&SpofZ2mbEy1jGWKJ69@QeKib# zjU_aeEqq&Qg0+MHZ>+suThdCSgNw*k9Z&RF(h|24w{o6QN7rzoh-fhxx5TW3Rt=G| zq;ot6q%CPTel}Md^!YWY!?`8AUy5i*IaT&#dQ+3H;l-okD8JcAS4 zRpBGTFZwwsZ3vxLiE%iQK8YQ?s9MdAB|jU5 z^DNVe*JIU!duDCs8pLgrqIdx9^$^= zy(CQ%)ry(0mcsIxyJITRDJTEX;N?^jsin4*CMxK`x?1ZXf}>PARqt4l-SXm?%)I9J zPJ$=Xj77h=Q!m9e<)y_ji8{HiUSFq#rW0$6t>&5f8n)7rMyqWZvy%x?7^_y+5!kVT z4D{tH%6Vem)>pupJtudixq&8VQyOP-xkv__20Xcff=W|K$0E7j z8REzB=5l@PBz|BS>AGBBoXOF#dTkknNb!Y<nn z(%i(|XV)eA<B{cNMT z(U!uf_Dm~H$j>Kf^62lh3?ApnP!11p_7hD)SHvOv6}kP2DuS>eudddY8?{b-<@{W; z-AN*adQO0DoFiI5HY-@edlZsiO0Z0(B@C3?#yi0?j|l$tYJIU;JzZbHtWHfgc2cVg zx9i3yDs%PvnMw!KwpuQ8j*+I-Mvc+_FXLy)^1Q3+Tb`qVdDyV=`eS;wP9rA24zo1EUKTs@OQdyic9tejDgG8(%;B#fS&tT|JyciP`U z2 z=G#>eH(sBwx0@>)B!D4ksSP46WLAR76AN4-86{^7N?7veEFui~uG3iCsL?M>t)WHm zDtvcS__4xg8fEyaAhE~~gAsxJTeFKdPtMmn8?802R2@iWj?{IjlJ@ZK3MhX1TnK#kXY!*IBdptqK`7Zv(Y{dQLO>4*5S2J5xPAn`wULGgwL3}Ptide8R3Gc zci47bI%sH!0$%#aSzU)1{VMJD4mkLT9Pj?PcMuN*`>pQa{9Da0a-erZ0|Z!RE_UrWEmrcBCg);_kVjfy6FV&%-6%W7O_U>^2{Uki;(0>{B4|7~)ux`o zWr;3dYO^bi`!>6&B?=+;jDS;1B;uj(IyW`rh@ry^ODoHrlj~Kkrcs`EJ05{JO0HO4 znA(Cok7to}B0+nq z5rD_U-0I@Bh$9ni;B%jc7=>IVRr8(*lKir#4P~9i@jckWapg)VO|l7lOiOkxL7M97 za^vL5tOsD8521<^9v<=-zbs?6jr!o_*$#nT-%@F%KYkIGukdyJ@ts)QRp{PMU`u#) z_OBFV*DzF1Q-DgheqoP@tsFfH1%D91MZGCPy4k`$SMDcDEQuMC+zBPVx#sJD{7(KS zsWk{t ziyJ4w$Fk^JSLqUe?MnyrNBo}?W|8aAl=ecwX`hDU#n zi=c5lqFOz*wm}Y`tFQJ|)62#;sPNl~wOZ@E8C^)(6HZw^2lZ)fQpk}pq8>CLv4=5J zG~MEaztnWIh|$iY>PBeyK<$BPrz)LlVsh$Nhr}8e)?j}#y zm(H{|Ru3z+%{S3O^{ME|B{4@gIUgtC7sMaJNVy=!+cCp{Tz9FFnOoW2K|GAT7v@9Mg%DIK(I%|A+cWQOi%K6pB=8Blr+n}T{ z>~~0oqbC>+<%8@7X&5$-YIPHKck(rmIeHp97*@|p=fGOCbGp^stahjfiJ2{2ncQt= zb+A;q-MPh{^{I|dSIVwq$0{)Huq-R0H?uv@!Up>6Zc02h`N)%mB!HqlyU}SkmZ8mx z>3|Qiw`B(6fzs9~?swX?g>l$qgo4&Feh-^DUy#~`7Cu6E*zC2wQfDE0ZCOcP8rYA?{dxgT8eL5djdXCrG4~ z-8vd-IXR9nLDKMdW@-52ti>Zv?R0ZvWtr7aT1qyZPd86BmTD_m6FGi>wBSq$zTlo) zjn_hUNAcj;>Dt*k`%zgf$=suOy7IaDQsw&T!cUU1gT`UJiR?e@;I(>v8NP9@-io?!_G<=$haWR-%mBw!WGdoDjQ0?+u3N(Nnaog8dGvos3HLtvpte3>Zm zT=`qhck^mg#b^%1;hm1oKuV{YfELFQBNbS`<(oI)3|2WEmPINvT3bG!dM7run*5ea zk@PE7<@y50Z%De7$5$d*dC|>U+s}#|+cU{r9LwyGG@a5OvNwrwS}JHjNI6=qTuZJmqWPh7o_w3mOb}bSaq?g% z96P1bnw2b{yLPI)Lel#r0w^?$#axm;xbl{_b6E9=U3lPB6WeLC)>@{jS8=9Q z+Ku-SEuWbi-obOLFtr}*?I&hBIUFI9)4sso5urqmk`|~2B*zW{EfBYIvYGh~2k;Ke zVah1IH+9ndDvQM4$*C#Uci}|#uIy2P>Lh7>$yphqFDp?gau7QRj9f<{ONOAAAI>cE zk*E3rCWXg+)~v&2gg`_!x=h8r4;vIk53~KQd~UtD24AN6qmUrW!@;vmWQCu)urGE?T@toPiS@zxs39YFg$7 z-PC*%of~K@v$VaC_>gw#(cO2`3B>NyOgCJX$0y^8LS+XT*#U`7K0DO9{Uw-xjy4OO zl%z;?+ofnLrNghBxtOLbt~5gh3BIIGQ&1+0;gg40Krw?A7+ey5Alo%1{Me#|rl`r? z?5@XRUyDV_7Np~@GRRY@T%&vxhE_Oi#>_hj8%YClJSiYBNEEb;WVo$>j zSC)D>u_GLlx&na;t3wB}t@^a{vn@$)6+5iiZ=JP#ws(g^lZUn$gkqW4%lfUwTP8ft z-pNxGRH_#*#}8 zdNmgGUXN0y%J3|+g`5c4;zna-dAhcCYNK|lenWi;CDt+n3oJ|_Wg!j16uM|ew-rEW zLym)*zdVdui0A3}z>$o|&5712rfj(u+w;?~mM%QaC!>6?7DJFMndbPB-JiWT#3WFv&+g-MQ_y)TF#sWc_itE0ZU0XR%PZ)bZ_GUv3k!a>$cWrH%V-%|rI3mRnPQvk2 zKetq0?^LbIkP}b&hV&J4I>}cw);)3=iJwr)D)rTd%6XzMOs#>>*Gb4=J%jZkrmOf% zw~#{b>TR!pkGky|2w?2F7xDl44V3La)LhQq-4br3sx6!QC^D3_;oUA^m;YXdtfJxc z?6uJ)?S6TQ)5@D!=MmS0*7z<~D`r9gWnTCi%?FhP*q7Z#9IGCko;@@%jcBWl#p+Zw zgL+vMM~t$SNZsY*;Q0&sASCi?u=%j{0jElqB*&!qY0(m&mHB+i{?a>h-2ZFYou<_O zVC##7mAiebh9roKA~_(q&*EXnrl)33JidB-_Au_}g4gAZMx!-aDww@`>J(#cAPa2&*_vRiUk!z=rFxEN= z^I2lUWuiTBgp3d$vOc9)ttYW7pB zkNUDKp0BoyRke{+^vHI}-Ur1Yibx_jqRnM)5xeddzI`vR5zu}rj1Hz~aUnbsOwG|L zB0n(g*AKB_#k;Exa@n<}_Ht5R24@{7qn@9F7ODoRK&!EtiR0zU+{9#A=I6Q$KM%1p^21!Rq5xqoOgLl+S!;Zv%aKiMdE(hV$8s2^yo)CnW5JN&&Ka z(X_-I!iMk4+FF?Q-zlRD1ft6|DHA&&t{Kuq#in??Byu^CP}Mz2I>*~I+H%OI*1Gd_ z#?;9tiK*=|#Kf4VCvl2LgdcYMQK~9ir{az(tvA1}Y%Y;6VNgSM7r5HVL`H%+#atm- zZ&=zBXdZaCB{G~XG$%MsJnM_>5R|r3rW3GUG1ZOM*__Xrws}%R)^Z zC+qv3YquLxQXVWBCE3Zb&C(-Qa}k>Rq93c-)M)odjXv02sA>|3!M1F*e+pw-CH+|x zvYbRtn-&~Tz6f_gSJMJACgkm_>o)4;UVfza$E0O~Qv~uxH^hhhXMSQaK`&fvJ%AUu~S6@~t&7QMBL& zN+K4J?Sv^kz`KcjJ(z&zdK+Q?tV40=M7w&nwlZ~{Tm(Dywe%0P9#Fo$=modjT&>oY zD3QULxvEH+qVs?Wjj9>8SwhcKs(c-#$M$eP1v#@=9mptoGuUK@aZr4s-i1%YVe6t0 zM5!s+Ad$+*CNYV}!yXR~JIXwItvu)%62a-H7sPpfF<)ei7;!r91)t&sIJIS zU!ad`lRYRuJB-uGg~kJONIa~NpKPqGRJ(ElqK`y=63$J;v~bQ8o-8V-j5WPno4(vZ zUW=f06S-x}<#-ogC;U~kYF-?XKBDS{1T^T}a|bvegY zaCv{KX3E|+2OUD2*yf{-#JCfOcB{J5XrplI zC~Xfj`Wv%!(K5&O=QzqRbO#Vj;$$P1l~N%^nUf=K*_qw(!$}}%>_-AUwLI@76{e#b zh?G&0Zgy2qkKqyd1Vgs!IxG zEtOT{L_eV{Kymnb z#53+BiXf^dWso@aq@a4E8jVgGc<8{Sewk8a+TgXmNOSngC&^J0AD}&OIpli_IJt=n3I-VL* znUiXLV$#qOze)>pDK$Ft8>k~U7v3v@&GrEY1CGsXEr!YWG*Fs4uk zC{!F3Q!%u4zd%w{vw~uk7R*vn6@3J1V#eeclQq!3Mb-OF? zz&Dvj$-wS(RDz0#p5&arBoy*Q~*>V-bJu^E;Wb!;( zc6e;5$9Ff{hhZ>MdOq8NPEGk%vy`kMr;IG0AnLM_a~-fy*Gy4Sv4FM_J+FdOZjmq5 zYu4M0!7(qW(PrnM1&>d`l1=rdwW}n*D(55df~v&#oNuUYcKlRCJltqg=TI`)AuNC+ zQlUECSYe7zmF?=BFKSV2Lj3Vv2~cx&D7*>De>&9)K+MNT3Nk>eH6}zc`w`jr5L!z< z=iMaWBZlx?hf*QrIRa;6rf?NTV&pI^#+6LkoMJKVqH-zy6G}xct-vx8un^#H$SH@Y zh`P3|-W0^_w|qwYT#~b#HRjl%`#duQ(p`Zg&WX-A9kFv;vdYF<;=G{Hyht*#NHF@S zY^vU|B{3ul1br!Wgok0oSvtF@=fDn?Bug)n)3E4+X3XLEUUV0jU8lO~H`H1UI)spG zPNEEdhpZy4AkDdZ70pZP%cpL&!e}thaoo!+mM4`rZmdC_wwTgdaA&NV|G*L|`cO^G z_7dH=l$jEG7-7s`hcgz0jw%zmq!Wv8!XBMHIniF7ucIWhXYuuAf?=3SU|OJHE>7Ex z6;&rm$}G6dc1ZvoTWc?NT5j+kV8?;1)L{bhM@_L|^ zJn{!%x18~qQF?LTzu_H&#jFDffOUmO>)`*2Kkyb|)5wRGsOb)uA_TtW>awg(^ zwKg7f;Bw?XBde93WmvuqqGCs9HK1mcb?6cX9SaI+~>$PR6yOTvZG$Jl(@zSQePftr+ z#Ox6HlG))ho~bZ%J_h}jI_KInm@BD6=#s!BhD3I9&odgT4dtYCs_1hF?w9~8Xc=Ef zh^i;G zuZ#m@CD_>QR)P*zjspRSpbbM2g~#=XYQd*@Ecom!i@Kf`sEjCa>vTx~-jYHIM78ZU z%TgH^Y<(;=$WS^Tku5F|5%N78#gvh*l+=@$2UnrOjCd|uyWrVo>YH+I@NxHJbqk{^ zp(mD6Cj|KZl-||6T^<#*Ni3(7L7;;l6WqpK1uc!9;xS@hEFDm3!%y)B zb>n5puM%|r9|7sAgoD^Y(4kyxc10=5PIay(VT z&hHe1W)BFr=`5Yjx}%pn)a6){Jx8=8tkg?Ey7qouY^9IxYLxI(ZM4}q>jYy_L-Ul0 zurkM4`!Rmf_LEJ8d9!P2*gJbKLN7L@0U6C|F2bC|D#ea47urf0XgL=J^ABP*pCpWq zo(-qEQjdn!Q%hS~T$at-M_SEQN9pjoQh9h{jk`0IJqKfaEm?(2ZGS{fz|6-tmklkX z0TNvnWyo84hAVAa4Q)EFECOfp8KDW=8yo>geWlu}ZL&*%^3K)DAPfk_ZzSqYw(V$w zdI323=wUhPqE&OpXC)e@Z11lsR zcdOtf*AIXKP(XKCxKD}ovZ?!0VjyNwbpZ04cN3b0CWoL!MH<`Be(-;FY+`1% zRK>+N#VAfm6&TO|h{fvVYagRCE2KH)o;3y5=jmIDMKGm7L|f++KFU;JVb^C-DX!ep z-nD-* zN)@Rb*L81naBOM@rX(&GWyiy-2b-H)@`5iSnEDL=9;PR@hsO^rp}b(r8M5ixqy%*! z&iX633+1lp;w;_V$W{)8i?ZtT(GCmP>ZVmx0>rO|Ft+Fy>f=0CGMu}fRBXsOUN_-N0eBpBAAwj$??D`1V2 zxB*9p(8pxrlO$j5zBnr5hA>>T-D)){^>~poBf^-ubSMaxI;W;(t=?I^=}!wtd3Cw# zD~I+l1D6P{Yz}Iz8--xR)sKSHnIkzmiCLliuGO*0Y2=M)+DW~JPQw(dD1^z6Q;IEp zZ$_A5b=bn@a1du$88y4Gy@Q+Lny`+;Q28o4^Y&MM+FB6o|_5iFN$6-2AU$|3T-stWvc^jNXq z4e}y6rcJ}Ua;Y+H3L}j)(mCs5xh?ojF#t=H;c3Kw9nLh;g6O~>UOWGD`*jqaL zwLCS?hZ_46+uW9gat=WFBdWEqo+ez(E%WRS=Wn{|baSlAtpKb{215*L?4JorA1pu98zn<1)P~+O2LF=tyr<{wQ3oi5V>)i;ZIk?>NfN&d8<)h(@C~H|H7ToW+-Cv`uq!WsWv2s~$A@XM zC@$}*zWB!@Y~MY1-Py636Vubqpcao0L(htcQ42}FIN5z?+b}^$PH*UAVY!N?AtphL zBL+6Zj4n-xwwjFa*UDJ|JsA&Bq7H&q?JkImfHVS^54b^f!77g(cCN+j+laQfgzPGGKCv_uLy8`|hoa4jXS&gZrjUuPP`=8C@iv1N0i zfVxw$t?S^tCaH`n>1GB>rjL0kgWUMrSExHehugQ%Bte%JbLP|x$|oEN%4nu1Wze9k zebq7vW)$R?h*7B`E#%)Hjo-lu^O)%&$e6kb96k5>OKG1OH(e2WrxX+kJ2Lxrut(f) zcS!)l5`XPAOvj-Eqv1pvRp(BlJI^M^!)vB|n)UOkts-zJmJotY)RRHtrOL0g-=kEG zg-cJqaV%2HaN>Jebgkf)%VR2nF`lCu>FxHh7#DqbYOv7l+`%g>!3~lm3MYqVD;kwt z$;GZoV2I9a_m5I+TbIRoy-CHHTB#nzxM4-3-z_XjD_^)x;gjft=^IO=vA>w9U0fQ6 z40jy8t!e4WR3F~DYrkz1rQ)-wQ{+{HAeMqCEf;jh+td?y1~Qm&n=aDVRH*fvei#w( zDSVG!A27v8tFW<}cFX0y4?LT!d_hStBh{8Uy5r*@5bO|xqT^|BAa-g;(EX8pXt}yO z7m&tAFX)$B;?9ZQWM?qJP;7CGkV!)hXAYvXyMw<&3kq(w^`rQ!#j+adW+L5sv@S_x zhDZcQVRk8hBf29y1RP3@)%IhHL@}}Z*F7%_0o>L`mECOFmQNrebXqmF zWR#E3E!HCb6hVI*4NP87;#xAS~$%z zzzXsJ-k+mX9<)_J&NBdVDQ94*hG-8jP9Z)cd$}PqRqN4^-o*8WGm&wQ(E7Bi6@grx z&wMpr>maa5l0cY!r(z7eOy=wdP%7bN!uELFak|>_c8i)l*y?rt2E5rC*jwZbpXA)+f*N~UxFN9-p8HhO zq9N$(TD*u}E|+^rb`_cBZfLZSGfLtNq!(9Wp<3%R1xuI(f?Kqpdv_^x2|9Bj$QpxI zS;vpUF)W>v(VUud_M)murkgOOzx4Li_e>Vv2P*CtOGhF4Vnudj8NevW%qwjGVp-x` zHaDrQ1d&QysA?N_li-vns=8=3?%WyW+;Un!a|d?s)j-fFs7Pn~hm%l?RkE_mUQkPb zcs|L4WKRsn=sS^e9!5$!#L-a|*EN{pz7KML!{= z3vuXRBr)~E3Tp7&dvD#t908{o~xnv)sL zP_re=-`Lxdc3=Z#6PWVhow8qgrnbtdw%M<2ThHI&Z1uERk9T%sH+fXdN&Ls;Y{t_$ zeUcuA<4A`%59^eH%3Q0rXD74@#JoGi&gR5vfZ8n0)*%V=;?|#@4>i1%7#O66EK7mW z%q@9HGd~Qv(L577>+F()%VDo6D%2fY=BYgiFHIt&l6XZ5FmqRAG?_hoyBmTY-Me7 zRAJL*pUR=LSlOgvo9?xj$%HJ&X$amEY)x+eF7%1D9f^m>FT`obUMvN1PZwn(j}yNb zbyJ~CZ8nhC=2WWeWtJHbej3{b`Pq+?DVSU7V=4oYol$_ zQiqfj5~E48g!c~ji~a8SF0~jSQ(KI3QrMVm=-FB(-Hlx4&K|d=e<3@zDSPh@O52Eu z_Vl|QNGYVC*zlWXulqPf@Hq=t&Sl-#<@JCno7u#GBTZ6?d(P5s9zi4gwwfLZAzvw_ zgZABQewDk;_beWqxqo&-h~|exTe;NX!RABP3T%{Iwb)VCo*}*rk$iF3tujLo3-#!s)tI8Ey{FP6={QQM+MQK|MPMe+V(fL@gGU+>Lyl zFRx;laLFKk7@U$$R_vgbUyJFUJelZ2u+&7 zdO5kLDJ%kq#2x+pEB#LFE$JQgJ zA&Gh}I>lIPesPAT7z`olu9?5aK>v$**0iV5c4>CGD~-08ViOY|&26pis%SpqvI}m> zA%Z4zzEyCquvCwSWEkc`WjyRSOi6?}DtGXa^Bf!?&_OD>w^=ppfy^6{NUxi?Ey;g< zY1p){M(EJOj#uUhS4gDNj&!r3vZPXlhgFZ<#dr1?d!Z7@s#``{iWYyt9I;nggba}r zlsmtYln?3VJSyj%9jsa?(bN9-rML>A(DCj__3ccHqW0Kb?tgdClVY`6#$l}qtwy2= zte^}jc23rHyf;(ObysMjR7{d(CC9gKv0)>rN(5d9b=UI%jpr|KD;gRKQ)u~JPfN>U zUmTSbaS1rCfQRWTGBL{zOS=~vor~x1j^$CJ1`ysIZ6DS}YSUjuOITC}^22+%#?98- zlvJC-ncZ%eq<85+D#QA;WOCvydq&TPw79FgZI6s@S06HII}qE1rEwUD+-^16mPawz z)jo~5ku%j!6XnWDs-zecih$%0#l#;Z8l=C^oqEhR@7PnBwIY|woXB}1Q*3W(nB-CO zi%rRu8o$LXB`S@Mqde{mY89v%-A!FVM<^9osaAW|ck1o01@%B+7!jr1Obu>Iubf=B zAmDol#Bm1Sa~s90Yp3ehl=g0{T(M*S#tK^mwq_Ha`d0Shzfp)#GWp{j=LWT~arbL# zR|FY-k>XY~DA5l9AM^7^yIBe3vsf&%#rLR)L}EQ`JbYlY2zk$b@eNSl1_&&x6ug+2 zQ#!eK_Fm!Gwx+C`?^i-|VIw2G_;c`L9$@GcEFr=101JoszV+ zDsJBQyFfJAfhvJ#n~i1eaRTQm?JF0{$f-K8oFoynQ7Z|wV-z5%&bT;RE_%ExSuE0- zsrKG28z}SPl&AJso5D3ERMSj)D)(pY>;rtZNO6Er(z~{t2{Ku?Dscq0T?MOL!fJ{u z>qG|V2Ssx0M_4NL!Fj>&sAR1R7VZDnc8^{(tFN@{DL;x+=`cT0PPc1k@5Yh^Ii9RX z4uNJ57pTBGG}`5Ji1=BX#DCFV<4}~bBy=dJjl-+Ii51#jp#)pR_0Z=1nCJcT)mw74 z+Okg8E^2(s;$F(|%`D558%cAJ1|eDZ8K-P8@i}xWF{+d#9^_C|7WEJ@1YLFqDU};h z-4SBP?)NQYzOL9|I;9hwV`VgY_%M*j=^WTa_chOQDzH*XPcAbsM=oy}XApJEU^nOd z35c~-bRj``LC#EVLvmT+=o#E1PaOxAt;HQjwxL|Y5A_~k4q;^#*cG-b{U@5K9@*wY z4;Jtv+&EwdEiX7%fzmOK)mBbwN=DwZnvqeHDoG+~-S{08@XdYSpvXz;hP~&^{IKCc z+y}oXb!GxVqBKR6UQSd)jt{chUz4?!r46JUBS2YXXeZ<*tl56Vlk&-$K+fL&E5?z5 zZAsDuv~X75X)+_ACp7eUvVBV}ZUaLqG9qi2Q)H3MSIZ50>Do$Ggzu%7Mko&1bGx&u zqIyN%*E+Di(LOD)J+qio_Q6cGnFOoPgev@MG;2(4FKG>ICsq}U*0nS^yG<5{=oOqu z-X2UiBK=nKh!TU0E`Pl`FU%J zmP};>S{q5QAC1>kdlqP{SX4Y7hs@xc6CjmRQ=x*=L!(E;y1hI1So`LQjFOR zwUx28ja4?H3p<61$-()YrGxFgMWX<&0iP;NW~wlxO}SIpB7_gpGHO>+6RtU=#h?zY zM7okwHIr^p099N<_J5Ic8cFVvBauUd->nt=Q)_6m@A1rD3kMI8E*!bwVVgVa;$QoE zmcE0pAQNWv)<7`;?w>-^19!DETTQnZ-b3bwAr<)}=hmBRST9qz6HDxtk$WYuTUS4O z70i*By1vZyd%nC+wfVCBxUE0sMWO6*~3x`%)GYq ziW^2K0UU`rxd4q6Kj%`X zJxN>=vGa+qdrr0>Kw%pS34~~nN_Z4@-P4WbQ=W2vT`cI#1_8-VW)A{&$0+&+HH49t z)T*vD+DU0sr=?p1W;QyKHp%sq!PVi-i*;?^#9k_q=~oHP)F##8*({g$A*q2{*_Bt3 zU$sf}8FSh1O?H#n9hS#UgwRAHo8V@lMiEolkGB*)-V#0D5{}vobgijP7zy1I!=;Mt zOcjLKd^pLmL)(U-IU|PeYt1Y zli!QuPCAau+rX&puphzJA6am-g=Y~dl+;H8wgnW$wtX8M5zg8~5GZYJ>_fh)z)nLe z1)LA~rceuy@^!1tlX_UXB2zZyjGA*M?(flyB5o4>1ip}J&m#zo<2-z@K4sjr>toTh0}5)!4u!`?~d zeu(%XKWcH`k;d9uqkY=uLluJqhc;GDQ7hXum~F)u-v0p?k4}}E*V9%3RlW7t#+uw# zDfFn1mLzfG6zhBKJz7Ty)tbGn$8U$dBzCxcL*uqklW`J@m+L2M8!H_oiyH?P+Mv_0 zf4+%X!0KkkN{nhcf#^=+7FaZf3+Q;8@OtL~x%t|xtDuP~h#UA#TVK!qEJchb2$i|pDf7xW3pPRm;? z9>X;3xrBw+X}$L|;6EZsHn)9!#+aMxzG9F{32mdjj%OlB$Il8N+3mBeKx zM@^sPI82i3SkA=gw|Vf!o{&+$EL^VILk2#mDojRbdNsily^S(!Lh<@#{9f=< zH!0X8VVD_ZNMiB#Sy$tr-`|9=p`wI0MZ-G`TrSB|r>-&iN_Kz0PrFyV$Rxj~J3FQY zFMKR=87M`U<8tU!$_gVFAWKeeb}zKWDqL5LCfU~MU&OK*UqzGJz!axTDV`JRIvhCI zyE3oT**;9ZW%BN~e_PfD^JsM$q(&L3IBT z>HcKEP-_be8p)m=?u`>FJ8E`hiM^P9ow>bpO_-@dU1;C@26|1i(omd`;}^2~Rd1G^ z2XyG7qhuNNPg$rj-ZHfxo>NV>-wlclLY6d;PRa4#23>3KlDYM_N1h2{Gv?WvXANkQ zZRIIAY%sHeNBzzya+oTTeL^g|jg|4Uba1yI;&zJ6J-bPH5h<(xO#tyD!$d~{!nUw) zP{ob^Kmleo%25E%9O6qU z{jQW}lNCuSG+G-unA-&B_IApNGcBa5rio1f!KJj9Ep=>pQ9~VzFlrwhHD$%o$IqEU z6W2yzv-j1oqbNW(iItG8I#1BW6;a{nhH~qPJajZ)}r^FtJ3r z#nCgBn1l3?cw%mll)5Q79DTQOaz~ciIC(ohG5*kRJ7bDW&8Rmjf?AGCOLk??WQPaE z+eby>PqmP1$@v7ewa(Ncmm=gX;muBr=oZrfOij@xQ6rBUUu~U?n8^V%J`%Xhhpj=G zCDSzL;m{+J4OS`E?rgo)S!i+zwnOKUj<8*fWtpPUik)zZY+Pv|#~$9sg0~24<1!n` zvGDj%B6E)VG#FDNnXSt%6RGnA65gx&Z2#hhJpj!{(Rrn|>In70(PinCmw2!f(XISI zEW#8W2u)WRQ$&TYQU!WBf!I|__ZGdfSw}zl(lm z)Wy>qiR@UPilJ*H+Njb6u?)64*=}{0K2m6&(g6j$9X+}qUuqaQlS0Pr&Dy$981H)l zHy!NNBOduwFXA~e%F{XW9w74ILw|@ee9{$HiF%$`s#Hqpf490-@ZTZEbWPJaP@UUU z;+1uLG}uWgL*JskB;^R<_a-)2*-cEsa^3kyAm6-=jD(W5Eb^eHx?1hK%5mZnH_|;)5Ix>a$1|pMc({x&&G}yF_Z`x z?_pv)w3t}vYMB){J4mHir>GAX64n1bgwu&JzrbQf^iX3uqnfS4GM#I1Wp^00xV2{q zW!aX6Md<$C?*#m`;J@ea1}cD>$rTGR>Sx>Q5@ZT7PcyCFdbEYk0Ca#y|Hx)IF0f6L zDD7={&eYWEy1Vs-Sm|72{cvw`JXhb7S^Hnh%`g?V`Od;iYB@lZiQ4X@k z5ot5AC>hP{cS`r51V`t*(7^t=6K}HJ6g(j=hHcwagU}i;T6c93Efgpt7Y(kLEQNyg zt;D%$9(f2A zAI0XvJha=u3SG24xY#!QoX3k&gwr?qnY3UgY(58O4IH&-zy#Ie3)PZf%FTAs^jNr< zPD*0M=rvpar+%Y=s3hhAp>w0W;YSQKy4CJzykivQ;|_ zwoyR%5=!dC9Y+#9ayh;`?Sq$&sTJu(RY-fpuW+mkH`dq|-7!^Xq099VnDz$S84)ph zpPJgISdu?Gha}AHerxPEd2QPgWfX?-ToJbLejq0iog}|NGyF_;+nzV@Ti>j|*Hd?@Z-&{}O$KL}jRlSHee^R!o#3l)r@ z+rprlW+~kPqf}6R5S22bwI8aQyICq!maCP+)%gX9$G2S=q2xxp3h)f_7{b(C)zmGP zW%ZX55@?*FfOW}o!gvX7S6WOV+xeIJACo*cfwAclDTSr_Or!0Wi6=vDF)@2-+3 zrEoOub7(`;)fLAQv$kD{;Y zNPe5Y?q)h{ejyPT5<_Lx$kBm#N$$Vn@%&M<9$SsGkq}5!thKhsH_Gr{ZU=sGSOf4`rOP2IF z)qXR3m{@9T!H*0z1s_Lpo9xU%H4>KK`Xx>f%zJR^VK0cCE#pZRexgUt{aKVup3z%X zn(~(8fQwl*9-I(4Pfa+`u{=r8!fY8UyMh9f&;AKWDkgk8jpJT%4;Kj=7;rGdtmw>d z!i+=j*Z=D!MfSjlS8$3e9j;EKi|y%phL>0-a?+eB@fn8u)<%WNjbsd5k< zAk*Ed1`K(MY`xgUQBb#FUqDL>7)C@Oh7dt3_HLjT6Ksz^-9YDHoRK-Kjyf3hT~ohW zIuN0s#>$hU;29B1WWF?tJ9YTb9$d1DPmUl2ng{C3z}M2)6l!!(Sd$5UJ>VH*}b9c;KwvZyzg+w_ZE z{+MD<7S_Y?lk7b?7?+3`QjMUF{w(*aELM)OO?MkM-2NrxH7zwPsGo-rib5v2+w~N?A$*wY4eo=0rIu%eSa~xv|zp{!V!-E0E@)W>}$bC7D5_^-)`S zFwap9n*u9C$E5cEbad3oO8}M0j(Yz$!3wP=>Wm!|RTSM;_s(cwBi$?~nzt_rcy?B*UvHd$QnzmH z4u07-hU-uE9?l3bh1VCg0x~{yDn1pBYyt*#@xJBi3F3!MIsL^v=nLXjR1q297y95C$FnwLs#h}Ae zN47+#)HFqva0a7d-KeY=DJND^&|x-RK~BTB=Ckyn41WoL6k| z{pm1q^7Wua)sQV45uumr@=K8T5i2mW4VxVV67=hIed!F5?lP0@TP>o4CuEYm+#aE}M~1d{GL`mhX#w71$fb>$i}Vfy@W}9eehoNP_ak7P4Zb>Mk`1 zL8XmO`Y~46>;J7IJ>hA;=1% za<+VsoqI#y>Wa!2S!26SojcqbMLerP#G^MC?KK}0j$tZEK4}-?4ru=yo9ppv8c@(S z$(=NCEvA#<2^3Mo*jc~q!AYN9BCn$Wsoi5H*8*JHt5sa!+p&(Lsa%Sb{nkA19y^H( z)7eKLN8>nM1ZM@-Up3O~8fO}Lv=3ZYo=^r+F_D7#rntyFp5H1$447a~?RqPFQhj^M zXBW&`vJFQkXLu+bEN-*7I$t^B%R^=ccQVigAvb|A>5}TqJl_AQx4I0PtkC}rU}7%( zT}RL;Y;>uy?8%=N3z;T3iM$bP>I}!)0OT-i*lGcSMuN6a%p-xrlU`iDnVsk4pc~y8 z{dpRUn(kRb1l;%l`?-@bnrRFM)NSMe zz}p#Vi{B!_wbB_M5331D6O8S06hT?=eMR$7Pf=6IUluh(7WR}CBSsYIkXV0GYWLZ( zTOEs`YYH5>FeycA=F|rCOm&BDln0T70_CU3dqz5LQ38seC>FD<>0;v-NA0#wXP7B_ zG-F&MKSXW&iN(CY)JRin2xOWzw-x0r81aC>EiQs|tD0YF!;XGdr8|LyOL2F%GO(F5tk%XqhIT1LdEgW68mp#St?=T z0;bcqN_r^$ik&GxXq1jkx}1I_l-NuD^$(!4Av&ouT(iI-6vKoUF1KzLUi8o-GhAO24*5g;ZB-XX?^nv~dzS z81-{Y_4Q8Dtt@-{XEgZRjMq^%V6S;df~jjB6k!BFmA+8uf+Po&z08TUIxcEWY@sx7c3AN@w5)&W>%OPUGwbw}~WOAQp-; z>_EYC`G70JLb}GamVcm$7l+qp5t&|W&l~BMkf37s7_9Ye-r`o`5h(VAthu!6DA&JK zC(k$13xo`*MB%c%jAf3(Xesxubn3T^!2YrbDWJ=ozfdh#j`}8FE4y#6+38o0Nwq+r z0_;>+6or5ib;Zn#?k7gi2XQVnJg0yPo#_HjDzHRmcECu9uIQ$6d9@*RdGKSSmWkvv zVBzYLS|UnqTAK@8@8+pjU$|~mHqV_zxJL(D>K21DCG?5w;mZ_h~AoLKCe^Nk> z_24#YOTlu8e+tr_uDfj^BGZqt<5N5}{fn%S3AqeaQVQ71pepSLA3+D_&O-C}#!9Dg z=sYs5dd28v2Pk()L`5xsLNV7o zf49yxTb+$l8!(a5>l9$ZyO&(!L4Dw)cT8d@^l4|r>o%C!9ZC5tkM9ICSZ_7gYp1B8 zFD&+yN|BmaKP1%SgEsBXr=G-I^gHcNb@pE$H;FWp64rsVE&iwQS|Ftsd@tqCRvN!k z-reK!+p-SqOs%bK*3P%9^;`AX zOmT7Wes-_ZSV436o$19=B`hUc$(Z>zXeb^(=wAdzoQAeH8MV0Czf*wJ@l7cT?{R*s z=9fq#{hrMJj40|hEkHlR7_S_0PquAFPj8w3!q2A_7s)3LSD!Vz8!!wlqOwEPB(0Mc z62IkAhDMs+iFZ^nvY4dhm5)n^_^8i`E({#6QoMu3dm;D*No8K`XH@-yZ`De|viAL+ zR-TVkrfibrK_V7*P=llA(L3TAb?`@+gSr0oBWH@XuN1Bnz%}`itwCx;-8E=ac^}6M zI?Q4Pou451a~XiUDnr~EDnk_8i!c~rMX?#3iy^-xmiH9u2EEukUlQ6jdcKupNEv}_ z)K*YubXm+GwTqZi_ObGLH`6v7v;v``Kr$zkaSND(R_!+lu!yYf6Onq=@VDkBYJb`` zktUIxG}*dvWN6S8!vvhrq{O}ri&je2t-9DKlxS(5IcC&Om+syTI=N=NRO_Pt)$^;G zhp2yj?!fv+`*f8JH#j_J*E_8%gDQ@rC($mQ%n4bkedGS>i(dT|2+JLt7ZC(6SV5}0 zN`oz5eYFJ4-lM1~rDz{#qM zgB1?HU;k` zG80(~IXc*zk5Nl(=6Eb%>~*$62+~YyMlWYsH^>4~A{wbTBsLIcHR%BQ(a!3mRRtT6pmkf9uLZ#m! z7|da_JWGDjRkoHG={T%NB06{qY1oy{T7A0%QM=d>v!A=lA|vI_%wLHr$y(hG`};_E zv-0%hH!n&pl#<^>&ak7Py%H^w%44@s2O@zp1+04Ia#((7e|OV6J!%vZHDsF8%`nQ= z*UHxjhWNTx@1}qt!EI!zh`kiB544upGZstGu(}ZVf&Q64_6}De5DV?Lte8D7sNiyg zq5*3w*K}GN^**fT5vlxwS%WUU^kRMRgUk<;Eabshb>wVPSUQQ&TTr56+a66;QNE|# z?ljjL5>gfler9~tzn6ASROajL=0R!cKi?Ddmm4!D6}_BcRE3gsCH=zFTw=6V~UjZ?^*hNo|J zofEaE=8h~%{3cyUnd{e8HM=WDlZLT8%XP7Kjq3i!Ig-uq-o1LZwvvALg7eJtO4AC{ zd%{vx*v7II=$K7U%@6OU5Ty}Jx{>imTOS^FW<7d0BX1^2B zZEv5B?|jk~JA%KJ_Tz77n~mjzV{OD-&#q0Q6GP{8cPW|hd%JbdyJI~+0hQ^xrCvvK zmuvD8e|esw!-tb8;*CtvPuGNEy*G}_vGlzCv$B!gcE`cXVGlc5TWQxpCsKRqn#E>w zWyd2fzw8ks`DOgS?{CIh0Avq}EuVj>{E#JJ+mbu**|EWw@QNnORQtKmP1ikId ztpAR&N#U!?H+nOXTqOjJqRmiyD_efgj&tYkk-nuT7B}Nk+|2sP84_y<{tq`!i@pClkS!89N_azsf&o}7l9;*MWe1-ejdAW=C>j6T33Mbxx0 zgn2ESZVZdOnx~Mtza}AZ7wBN8Y)n2+ASrO_h?~}IUb}E?el|t@Mza^k{luCn@g#Vg zFtRu3ZK`wgQ#VX_dSG*13p(u>IkyKn>nxqD?quDQcq0iQS}AXPd1F6(5vrMLXREby z$Lh7^daEsOu(w)mtf3tj3sWo2<~Hk>D}BBNc`Bp`VPtO*(=N|=B4SjOEREwbNC1Hn zUOhTJduU?1O0^=YQ`Pv7FQ_JoVW*jXSO|N+x-!jU1)CV z$qzlA8o_^O>gP9`t!32$F}Z`;YW7x<&^t9hQQ8aD5U`svNzbzVMk>rex;nK{Yb_%* zSpt7xv%E|G$m9zpV!2`-$ZH{Btzjx*DE8+aHX$I$Se|Y|&IF3VbOitknswJRYryRx$#wbIRTWG>m z`(`aQh-vraY&{9##9vC?B^G<_BI`(aj%;fRJu;D#R z&RU#h5bc_qJ|X{d7su@Wr2`SW|2}8;&yb+$+)wL2?)IdFprR#jYSKjRR4aI=vFMie zVeXDjPF9akJieQygMjVtmU>1-FuTZpKy`%fxDA3k(5_?MCt{C z5*is^CuTV}PA&KnN}Ou$#%8E2Oe{=IRwpMaDIz<%$3}3Zcj_XCEx*Lrmjz;*R2tvy zbfFo-N^|Yh4j9T(uilH6-C4bY#6rr`6;FlPsusUTyhpa5*z=mMurd0d71wE{vkU1d zX~ro};x#6yP0bBTmJwbAkB50-$c{<&Q7Y5_lca*WlgrK3YHew$-fp|T zAk|Lo6pK*ax2Fm|E-d&}oM{|MoI+^`7LoGkJh8Tts48&*fYhe$aH$L(h%P=cGkL5$ zd7U5861_9I?4}b>XvQ7M(06EJ9s!a^re-|i9=#=7dnZmT!1yv+#BL-pO67`< zC2BZ5J9(Y^A>1~J87>8xvV%&FWS`!*Tt_j+=J_cwEJ?OxzjB{33Q4d9 z3032W5%I(oHBnb<<1Fv^+a{J?R7|)@f^{fB-v#rNRfu9E5hQuED$b19X`r<@9t4%& zDH;p-foF4>)_j`i(RmtO1Oo_aIxTl9kTtRN1uE+JD7v*`sIn~EtPMk zU?i6ytk4%tV!G*F`!yy^lxVK!%TqH8<@ve!@+OHCJIsk_h|CTFVfiBumvz zf)@@(@<_&)D6j=Vj>)&8I=*R`<*iJeO!Jvu9ZAXaQz?n4&y>D?P5pU8A^N^=W`^ZB z$*vqqI}HnRS3GS@iB;O<6@th%+aDZTtu3{h$OUWkT1Ny_Y_X0daD`FEoissWKPFd+P6GY-K*ae?-5KlL3U+qsg*FWm}XAs3jH8`vcil;@_#=FCh^ZRY@j1iGh#fAl9j@ZxTyJX>ap?rJ} z;;-keNR^KnL!;Z(`dTN;Un(}8g%k5h0tRJwme-cY)K6I~#H*hFVIy~BQe8oe-Xucxl55k8FiQ2Rhm4(e>Bhrq*yIKs z%zt=NBT9RnP@rk9Q&0znpj4F02Uy5xZ7g-D+Km+yp>p;J_oU)Bse0q2C0cn&W~0Za zW{~;D|4!zcMKvya*uOU0w>Xmu(aNT3ecw0J?#Gq>*zT7$r^T0)jiYn(vkTahY42Hb zD4qE{B~uKVi`A=O5FZr0!~BGQP#phADrb#G{5yCjs>m_8HZdTB3ChV_Xoi~@v{Ey3 zVf4-jjTf##iDL=D8M!a2m^Fy(NU#RY3k^+&3X!=tXNk^;xo3;GsBAJwRqQgQ8j8}K zoIR1S<1M9Fk}TtNkMD(0dACT8&-ha4Xvj;7CFK8!epy87XR@cf-`k>O5vgj;mE~$1 ztwJ;Amwb2&^Px?DbaFxxPs`0qR6t;Z-8ft~Nt&!nJ=oqT+uWfpFeh|d!+6-7r@rOVcLC1Q>78o)Qz;_oYXCD zqM`I0*x!%gQP9QM5s_-Ts`LdA<%#{2ACK6a#F7)=LYy;XbsNH5M9Us|%wv3Nm`y_l z5HT|72S@N%ZbDAg{Orus6VjsTU>+M+Yiz%Sj_eIXM?90`V&3;>KGSWpAI9-OKPX9P zAKmS_?`=ewVLANz6Xi;(HcNa%(V06ubwhF%;wOi^{l}3%5N^5nO(}jPt!>7hlJ3dL z1~Ze>C$_HUM1c{AhsP5nRn{f#$~w-+euTb74oDPH-|8KSI-vS%_bXO92b|?VYr`Q}8z?uYOdT|OTN)@=31#-u zO(3wL2d7gU;+93Hq6dr^0PXB*b*o)UPfh(dj;8zu(VLRAOow)hTXM*ek&CMRhySG! zkuc=BHz;`;?3L~147oKEzjhC%3PmL6-`i><3yMLe$rD1uMjLH7 zai^w^X0-_zOjoE_tr&gj>kOq9Xf)f~;*OmAZ}hK4=HaVOH&^Rd)z8+~u7agv?dJ9R zspLO8ryH$h+A!y@sCYXv$xmOmRlAc}e6Bsu0p;`daJ1}cTNi~n8 zfpksOkfZ1=A4D~oZQx!k(vSw4=uValUUeRoLLtmhHMJJVgk~*`dY{4Tj9i2M(-7cw zMrKuy$Q?Rha7_%~o_3fT(686)XC|?0VcTS5tZRTeO4^(yb&#{nPUwk!LU zyHnEQP{sKyYRk@rnc1NE&Q?DC9^{({RC(q^V$^5#fzma2ohdkfdwHAI)ZC&8!BNR8 z@fxI}6hwaiB-=(@+?)}N8prJw*NwkHz8^mS&A%^y|JG{+?Ygy$>wn>$a^1t< zCHS@X3f}LJ1;hKlUaxz{d(zh}W?X;G2j#lo{jlKYzb<&UZwQ9>fB#41?@#&f>FXYp zas8L{x|jZyTyNLy&A9$Pe=XO&MbWOC%eem1zme-dtZ3KWoN@iZkIMDm|1m+k?wJ|a zU#-`DO3|)+X~y;U`MBKoZx!vjH)dSF^RsgO13xEd*L^7C`bYo0TzBa6f_B}PGOl0M z>-K&@uD9#H=bJJP*SDtE-R+C=xm~v-G`{FVDFCdcE!~igw+bGOn*omwAf+ zQ1J_jW5?z1;rxGaR{lOWC-_{&mn(+X|MsF>x3MJn9K{bRhSz`JDY@>|if>T-YsK*T zTW^-@_ni@Ztm2|#c>S{u%e+7O-^ulc6FN3Ls$;|BIyUU+*zostZ1@fx8~&w^4e!vg z;pF$p^Bh)O3-Fh9{40uI4)DSElJD_bdK$fS2A^?q~QM9UHzv$A)jy z@!J*um*STd?|+Hh&v1{9_bQ%Hyg~7n0RLIXhWGdZxu4;29nUB>6mM4iy#U{*+IySsr$A+KP@#hrpcYnE`;SL=ezFfzKuhFsL zeIKaLtN7zTEMvp#bUdxt3h-MxHk|ko`M%+-j^`9V6yR5NY&i3y@_obS>)7xP9UC5e zkX�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