From f26445dc51be2e40a7d3ea90f8adafcb66448a53 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 11:30:28 +0100 Subject: [PATCH 01/44] CI: add `os: osx` build job - and comment out linux job matrix for now --- .travis.yml | 43 ++++++++++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 17 deletions(-) diff --git a/.travis.yml b/.travis.yml index 19e3eef9..d27b93e5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,26 +3,34 @@ version: ~> 1.0 # require the branch name to be master if: branch = master -language: python -python: - # https://docs.travis-ci.com/user/languages/python/#python-versions - - "3.8" - - "3.9" - - "3.10" - - "3.11" - - "3.12-dev" -matrix: - fast_finish: true +# # temporarily skip linux job matrix +# language: python +# python: +# # https://docs.travis-ci.com/user/languages/python/#python-versions +# - "3.8" +# - "3.9" +# - "3.10" +# - "3.11" +# - "3.12-dev" +# matrix: +# fast_finish: true -arch: arm64 -virt: lxd -os: linux -dist: focal -sudo: false +# arch: arm64 +# virt: lxd +# os: linux +# dist: focal +# sudo: false + +jobs: + include: + - os: osx + osx_image: xcode12.2 + language: shell # 'language: python' is an error on Travis CI macOS before_install: # Python package manager - - travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - bash miniconda.sh -b -p $HOME/miniconda - export PATH="$HOME/miniconda/bin:$PATH"; hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no @@ -39,7 +47,8 @@ install: - travis_retry conda create -n test-env - eval "$(conda shell.bash hook)" - conda activate test-env - - travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev} + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=3.11; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all From 2ba8e664f824c307fb9e7dccc618543003144ed3 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 11:58:25 +0100 Subject: [PATCH 02/44] CI: fixup f26445d --- .travis.yml | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index d27b93e5..cd9c9cf1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -48,7 +48,7 @@ install: - eval "$(conda shell.bash hook)" - conda activate test-env - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; fi - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=3.11; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry conda install -c conda-forge python=3.11; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all @@ -62,10 +62,14 @@ install: before_script: # limit parallel processes to available cores (error if pattern not found) - - sed -i '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py - - sed -i '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg - - sed -i '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml - - sed -i '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi + - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi script: # package From b1ae3c03868589e2454f79d6e362590e30980d6b Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 12:11:46 +0100 Subject: [PATCH 03/44] CI: fixup 2ba8e66 - remove `sed` commands for macos build - try refactoring job matrix, including linux jobs again --- .travis.yml | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/.travis.yml b/.travis.yml index cd9c9cf1..114d69bb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,25 +4,28 @@ version: ~> 1.0 if: branch = master # # temporarily skip linux job matrix -# language: python -# python: -# # https://docs.travis-ci.com/user/languages/python/#python-versions -# - "3.8" -# - "3.9" -# - "3.10" -# - "3.11" -# - "3.12-dev" -# matrix: -# fast_finish: true - -# arch: arm64 -# virt: lxd -# os: linux -# dist: focal -# sudo: false +language: python +os: + - linux + - osx +python: + # https://docs.travis-ci.com/user/languages/python/#python-versions + - "3.8" + - "3.9" + - "3.10" + - "3.11" + - "3.12-dev" +matrix: + fast_finish: true jobs: include: + - os: linux + arch: arm64 + virt: lxd + os: linux + dist: focal + sudo: false - os: osx osx_image: xcode12.2 language: shell # 'language: python' is an error on Travis CI macOS @@ -66,10 +69,6 @@ before_script: - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg; fi - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then sed -i '' '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi script: # package From 23bf91a1d21736f7e0fa0a7f8b24cae3dbe9cfbe Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 12:17:14 +0100 Subject: [PATCH 04/44] CI: fixup - remove linux jobs again, try finishing osx first --- .travis.yml | 35 ++++++++++++++++------------------- 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/.travis.yml b/.travis.yml index 114d69bb..9d6690c7 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,28 +4,25 @@ version: ~> 1.0 if: branch = master # # temporarily skip linux job matrix -language: python -os: - - linux - - osx -python: - # https://docs.travis-ci.com/user/languages/python/#python-versions - - "3.8" - - "3.9" - - "3.10" - - "3.11" - - "3.12-dev" -matrix: - fast_finish: true +# language: python +# python: +# # https://docs.travis-ci.com/user/languages/python/#python-versions +# - "3.8" +# - "3.9" +# - "3.10" +# - "3.11" +# - "3.12-dev" +# matrix: +# fast_finish: true + +# arch: arm64 +# virt: lxd +# os: linux +# dist: focal +# sudo: false jobs: include: - - os: linux - arch: arm64 - virt: lxd - os: linux - dist: focal - sudo: false - os: osx osx_image: xcode12.2 language: shell # 'language: python' is an error on Travis CI macOS From 7609f9b07e73787ece9c67ac424ced5c50f46b7e Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 13:35:16 +0100 Subject: [PATCH 05/44] CI: now try windows --- .travis.yml | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9d6690c7..cf2b94f0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -23,15 +23,19 @@ if: branch = master jobs: include: - - os: osx - osx_image: xcode12.2 - language: shell # 'language: python' is an error on Travis CI macOS + # - os: osx + # osx_image: xcode12.2 + # language: shell # 'language: python' is not available on Travis CI macOS + - os: windows + language: shell + before_install: # Python package manager - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - - bash miniconda.sh -b -p $HOME/miniconda + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe; fi + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then miniconda.exe; else bash miniconda.sh -b -p $HOME/miniconda; fi - export PATH="$HOME/miniconda/bin:$PATH"; hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda @@ -47,8 +51,7 @@ install: - travis_retry conda create -n test-env - eval "$(conda shell.bash hook)" - conda activate test-env - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry conda install -c conda-forge python=3.11; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.11; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all From 0b876985f14baabd1950a8ebefa466d5541124d9 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 13:45:29 +0100 Subject: [PATCH 06/44] CI: fixup 7609f9b --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index cf2b94f0..becd9970 100644 --- a/.travis.yml +++ b/.travis.yml @@ -35,7 +35,7 @@ before_install: - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - if [ "$TRAVIS_OS_NAME" = "windows" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe; fi - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then miniconda.exe; else bash miniconda.sh -b -p $HOME/miniconda; fi + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then ./miniconda.exe; else bash miniconda.sh -b -p $HOME/miniconda; fi - export PATH="$HOME/miniconda/bin:$PATH"; hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda From e9c28bcf03a141be6e862da0512607ffe34cfb97 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 14:29:19 +0100 Subject: [PATCH 07/44] CI: fixup 0b87698 --- .travis.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index becd9970..fd594370 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,15 +28,15 @@ jobs: # language: shell # 'language: python' is not available on Travis CI macOS - os: windows language: shell - + before_install: + - travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + - ./miniconda.exe /InstallationType=JustMe /AddToPath=1 /S /D=$HOME\miniconda before_install: # Python package manager - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe; fi - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then ./miniconda.exe; else bash miniconda.sh -b -p $HOME/miniconda; fi - - export PATH="$HOME/miniconda/bin:$PATH"; hash -r + - if [ "$TRAVIS_OS_NAME" -ne "windows" ]; then bash miniconda.sh -b -p $HOME/miniconda; export PATH="$HOME/miniconda/bin:$PATH"; hash -r; fi - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From 6ef407d47a0750650fbe91f4d7bbb4511ff94fae Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 15:06:42 +0100 Subject: [PATCH 08/44] CI: fixup e9c28bc --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index fd594370..44d2ca58 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,8 +29,7 @@ jobs: - os: windows language: shell before_install: - - travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - - ./miniconda.exe /InstallationType=JustMe /AddToPath=1 /S /D=$HOME\miniconda + - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath:1 /S /D=%UserProfile%\miniconda'" before_install: # Python package manager From 691c5e39fda9bd2aa1c8e81d2ed504139748b7e6 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Fri, 12 Jan 2024 15:10:48 +0100 Subject: [PATCH 09/44] CI: fixup 6ef407d --- .travis.yml | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 44d2ca58..25ba822c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -30,12 +30,20 @@ jobs: language: shell before_install: - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath:1 /S /D=%UserProfile%\miniconda'" + - conda config --set quiet yes --set always_yes yes --set changeps1 no + - travis_retry conda update -n base -c defaults conda + - travis_retry conda update --all + - conda config --set solver libmamba + # debugging info + - conda info -a + - conda list before_install: # Python package manager - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - - if [ "$TRAVIS_OS_NAME" -ne "windows" ]; then bash miniconda.sh -b -p $HOME/miniconda; export PATH="$HOME/miniconda/bin:$PATH"; hash -r; fi + - bash miniconda.sh -b -p $HOME/miniconda + - export PATH="$HOME/miniconda/bin:$PATH"; hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From 514d6fe7e51d859fd5e609634478c1fd7176d321 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 11:41:58 +0100 Subject: [PATCH 10/44] CI: try `miniconda.exe` again --- .travis.yml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 25ba822c..e1546261 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,14 +29,12 @@ jobs: - os: windows language: shell before_install: - - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath:1 /S /D=%UserProfile%\miniconda'" + - travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all - conda config --set solver libmamba - # debugging info - - conda info -a - - conda list before_install: # Python package manager From 36c107e8bd441ce16bec258d4d689d88cd9bf6d6 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 11:54:12 +0100 Subject: [PATCH 11/44] CI: try curl instead of wget - and remove install options --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index e1546261..5d061742 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,8 +29,8 @@ jobs: - os: windows language: shell before_install: - - travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda + - curl https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -o miniconda.exe + - start /wait "" miniconda.exe /S - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From fe538c9c920db5c08995469106786bd57c7b6b49 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 12:06:39 +0100 Subject: [PATCH 12/44] CI: try wget again ... --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5d061742..b465705f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,8 +29,8 @@ jobs: - os: windows language: shell before_install: - - curl https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -o miniconda.exe - - start /wait "" miniconda.exe /S + - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + - travis_retry start /wait "" miniconda.exe /S - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From 5145e49d52e5428f41b46142e9851e6ed5dcdfb1 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 15:19:20 +0100 Subject: [PATCH 13/44] CI: forget windows for now, try combining linux and macos jobs first --- .travis.yml | 47 +++++++++++++++++++---------------------------- 1 file changed, 19 insertions(+), 28 deletions(-) diff --git a/.travis.yml b/.travis.yml index b465705f..7e91ae86 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,38 +3,29 @@ version: ~> 1.0 # require the branch name to be master if: branch = master -# # temporarily skip linux job matrix -# language: python -# python: -# # https://docs.travis-ci.com/user/languages/python/#python-versions -# - "3.8" -# - "3.9" -# - "3.10" -# - "3.11" -# - "3.12-dev" -# matrix: -# fast_finish: true +language: python +python: + # https://docs.travis-ci.com/user/languages/python/#python-versions + - "3.8" + - "3.9" + - "3.10" + - "3.11" + - "3.12-dev" +matrix: + fast_finish: true -# arch: arm64 -# virt: lxd -# os: linux -# dist: focal -# sudo: false +arch: arm64 +virt: lxd +os: linux +dist: focal +sudo: false jobs: include: - # - os: osx - # osx_image: xcode12.2 - # language: shell # 'language: python' is not available on Travis CI macOS - - os: windows - language: shell - before_install: - - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - - travis_retry start /wait "" miniconda.exe /S - - conda config --set quiet yes --set always_yes yes --set changeps1 no - - travis_retry conda update -n base -c defaults conda - - travis_retry conda update --all - - conda config --set solver libmamba + - python: "3.11" + os: osx + osx_image: xcode12.2 + language: shell # 'language: python' is not available on Travis CI macOS before_install: # Python package manager From f66d3e3a77437b1b3e291f71d146b5df9a4fd08d Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 15:25:21 +0100 Subject: [PATCH 14/44] CI: include all jobs explicitly - as adding to build matrix not working somehow --- .travis.yml | 55 +++++++++++++++++++++++++++++++++++------------------ 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/.travis.yml b/.travis.yml index 7e91ae86..f2354406 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,27 +3,44 @@ version: ~> 1.0 # require the branch name to be master if: branch = master -language: python -python: - # https://docs.travis-ci.com/user/languages/python/#python-versions - - "3.8" - - "3.9" - - "3.10" - - "3.11" - - "3.12-dev" -matrix: - fast_finish: true - -arch: arm64 -virt: lxd -os: linux -dist: focal -sudo: false - jobs: include: - - python: "3.11" - os: osx + - os: linux + dist: focal + arch: arm64 + virt: lxd + sudo: false + language: python + python: "3.8" + - os: linux + dist: focal + arch: arm64 + virt: lxd + sudo: false + language: python + python: "3.9" + - os: linux + dist: focal + arch: arm64 + virt: lxd + sudo: false + language: python + python: "3.10" + - os: linux + dist: focal + arch: arm64 + virt: lxd + sudo: false + language: python + python: "3.11" + - os: linux + dist: focal + arch: arm64 + virt: lxd + sudo: false + language: python + python: "3.12-dev" + - os: osx osx_image: xcode12.2 language: shell # 'language: python' is not available on Travis CI macOS From 4846eb3dde889ae51b9f29c2cce850fb6af6154a Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 15:48:16 +0100 Subject: [PATCH 15/44] CI: now try windows again - found a typo in the choco install, try that one again now --- .travis.yml | 88 ++++++++++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 38 deletions(-) diff --git a/.travis.yml b/.travis.yml index f2354406..f4079fb9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,44 +5,56 @@ if: branch = master jobs: include: - - os: linux - dist: focal - arch: arm64 - virt: lxd - sudo: false - language: python - python: "3.8" - - os: linux - dist: focal - arch: arm64 - virt: lxd - sudo: false - language: python - python: "3.9" - - os: linux - dist: focal - arch: arm64 - virt: lxd - sudo: false - language: python - python: "3.10" - - os: linux - dist: focal - arch: arm64 - virt: lxd - sudo: false - language: python - python: "3.11" - - os: linux - dist: focal - arch: arm64 - virt: lxd - sudo: false - language: python - python: "3.12-dev" - - os: osx - osx_image: xcode12.2 - language: shell # 'language: python' is not available on Travis CI macOS + # # linux jobs + # - os: linux + # dist: focal + # arch: arm64 + # virt: lxd + # sudo: false + # language: python + # python: "3.8" + # - os: linux + # dist: focal + # arch: arm64 + # virt: lxd + # sudo: false + # language: python + # python: "3.9" + # - os: linux + # dist: focal + # arch: arm64 + # virt: lxd + # sudo: false + # language: python + # python: "3.10" + # - os: linux + # dist: focal + # arch: arm64 + # virt: lxd + # sudo: false + # language: python + # python: "3.11" + # - os: linux + # dist: focal + # arch: arm64 + # virt: lxd + # sudo: false + # language: python + # python: "3.12-dev" + # # macOS job + # - os: osx + # osx_image: xcode12.2 + # language: shell # 'language: python' is not available on Travis CI macOS + # Windows job + - os: windows + language: shell + before_install: + - choco install miniconda3 --params="'/S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda'" + - refreshenv; path + - conda config --set quiet yes --set always_yes yes --set changeps1 no + - travis_retry conda update -n base -c defaults conda + - travis_retry conda update --all + - conda config --set solver libmamba before_install: # Python package manager From 46615ecf721f41921f74f715e97d5539703ab0da Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 15:51:09 +0100 Subject: [PATCH 16/44] CI: fixup 4846eb3 - cut `refrenshenv` command --- .travis.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index f4079fb9..c4cc3124 100644 --- a/.travis.yml +++ b/.travis.yml @@ -50,7 +50,6 @@ jobs: language: shell before_install: - choco install miniconda3 --params="'/S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda'" - - refreshenv; path - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From 8db98d049ae93c49bb6671a2178a74ccb7df6e88 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 15 Jan 2024 15:59:40 +0100 Subject: [PATCH 17/44] CI: try `refreshenv` again - and put `path` in new line --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index c4cc3124..297f610d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -50,6 +50,8 @@ jobs: language: shell before_install: - choco install miniconda3 --params="'/S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda'" + - refreshenv + - path - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all @@ -75,7 +77,7 @@ install: - travis_retry conda create -n test-env - eval "$(conda shell.bash hook)" - conda activate test-env - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.11; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.9; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all From 5012e2bc1088cab446bbcbe81f053edfb90878b1 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 10:43:58 +0100 Subject: [PATCH 18/44] CI: try choco again - with commands from example scripts --- .travis.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 297f610d..5a64f229 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,9 +49,12 @@ jobs: - os: windows language: shell before_install: - - choco install miniconda3 --params="'/S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda'" - - refreshenv - - path + - export MINICONDA=$HOME/miniconda + - MINICONDA_WIN=$(cygpath --windows $MINICONDA) + - choco install openssl.light + - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" + - source $MINICONDA/etc/profile.d/conda.sh + - hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all From aa64a0b1799e91432d324196fe2549a93361c31b Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 11:14:36 +0100 Subject: [PATCH 19/44] CI: try installing from `.exe` again --- .travis.yml | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5a64f229..1f1dffa9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,16 +49,20 @@ jobs: - os: windows language: shell before_install: - - export MINICONDA=$HOME/miniconda - - MINICONDA_WIN=$(cygpath --windows $MINICONDA) - - choco install openssl.light - - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" - - source $MINICONDA/etc/profile.d/conda.sh - - hash -r - - conda config --set quiet yes --set always_yes yes --set changeps1 no - - travis_retry conda update -n base -c defaults conda - - travis_retry conda update --all - - conda config --set solver libmamba + # - export MINICONDA=$HOME/miniconda + # - MINICONDA_WIN=$(cygpath --windows $MINICONDA) + # - choco install openssl.light + # - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" + # - source $MINICONDA/etc/profile.d/conda.sh + # - hash -r + # - conda config --set quiet yes --set always_yes yes --set changeps1 no + # - travis_retry conda update -n base -c defaults conda + # - travis_retry conda update --all + # - conda config --set solver libmamba + + - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + - wait + - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda before_install: # Python package manager From ef23c955e7a563858c7b563db128c1b478a215b1 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 11:23:42 +0100 Subject: [PATCH 20/44] CI: try choco again, fixup 5012e2b --- .travis.yml | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/.travis.yml b/.travis.yml index 1f1dffa9..ee4d855d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,20 +49,26 @@ jobs: - os: windows language: shell before_install: - # - export MINICONDA=$HOME/miniconda - # - MINICONDA_WIN=$(cygpath --windows $MINICONDA) - # - choco install openssl.light - # - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" - # - source $MINICONDA/etc/profile.d/conda.sh - # - hash -r - # - conda config --set quiet yes --set always_yes yes --set changeps1 no - # - travis_retry conda update -n base -c defaults conda - # - travis_retry conda update --all - # - conda config --set solver libmamba + - export MINICONDA=$HOME/miniconda + - MINICONDA_WIN=$(cygpath --windows $MINICONDA) + - choco install openssl.light + - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" + - echo original PATH $PATH + - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/bin||') + - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/lib/mingw/tools/install/mingw64/bin||') + - echo manipulated PATH $PATH + - source $MINICONDA/Scripts/activate + - source $MINICONDA/etc/profile.d/conda.sh + - hash -r + - conda config --set quiet yes --set always_yes yes --set changeps1 no + - travis_retry conda update -n base -c defaults conda + - travis_retry conda update --all + - conda config --set solver libmamba - - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - - wait - - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda + # install via exe + # - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + # - echo 'downloaded miniconda.exe' + # - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda before_install: # Python package manager From 0757abfc59a74bbea1519f84bce3bb8725582187 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 11:58:29 +0100 Subject: [PATCH 21/44] CI: try another `choco` script --- .travis.yml | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/.travis.yml b/.travis.yml index ee4d855d..5ff90a8a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,21 +49,36 @@ jobs: - os: windows language: shell before_install: - - export MINICONDA=$HOME/miniconda - - MINICONDA_WIN=$(cygpath --windows $MINICONDA) + # - export MINICONDA=$HOME/miniconda + # - MINICONDA_WIN=$(cygpath --windows $MINICONDA) + # - choco install openssl.light + # - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" + # - echo original PATH $PATH + # - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/bin||') + # - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/lib/mingw/tools/install/mingw64/bin||') + # - echo manipulated PATH $PATH + # - source $MINICONDA/Scripts/activate + # - source $MINICONDA/etc/profile.d/conda.sh + # - hash -r + # - conda config --set quiet yes --set always_yes yes --set changeps1 no + # - travis_retry conda update -n base -c defaults conda + # - travis_retry conda update --all + # - conda config --set solver libmamba + + - export MINICONDA_PATH=$HOME/miniconda + - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` + - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts + - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - choco install openssl.light - - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" - - echo original PATH $PATH - - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/bin||') - - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/lib/mingw/tools/install/mingw64/bin||') - - echo manipulated PATH $PATH - - source $MINICONDA/Scripts/activate - - source $MINICONDA/etc/profile.d/conda.sh + - echo "folder $MINICONDA_SUB_PATH does not exist" + - echo "installing miniconda for windows" + - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" + - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" + - echo "checking if folder $MINICONDA_SUB_PATH exists" + - if [[ -d $MINICONDA_SUB_PATH ]]; then echo "folder $MINICONDA_SUB_PATH exists"; else echo "folder $MINICONDA_SUB_PATH does not exist"; fi + - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r - conda config --set quiet yes --set always_yes yes --set changeps1 no - - travis_retry conda update -n base -c defaults conda - - travis_retry conda update --all - - conda config --set solver libmamba # install via exe # - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe From 3355814f00148161914a3c5de0f4b4d36c44d64f Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 12:06:22 +0100 Subject: [PATCH 22/44] CI: install worked! now fixup 0757abf --- .travis.yml | 29 ++++------------------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5ff90a8a..b952f2f1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,41 +49,20 @@ jobs: - os: windows language: shell before_install: - # - export MINICONDA=$HOME/miniconda - # - MINICONDA_WIN=$(cygpath --windows $MINICONDA) - # - choco install openssl.light - # - choco install miniconda3 --params="'/InstallationType=JustMe /AddToPath=1 /D=MINICONDA_WIN'" - # - echo original PATH $PATH - # - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/bin||') - # - PATH=$(echo "$PATH" | sed -e 's|:/c/ProgramData/chocolatey/lib/mingw/tools/install/mingw64/bin||') - # - echo manipulated PATH $PATH - # - source $MINICONDA/Scripts/activate - # - source $MINICONDA/etc/profile.d/conda.sh - # - hash -r - # - conda config --set quiet yes --set always_yes yes --set changeps1 no - # - travis_retry conda update -n base -c defaults conda - # - travis_retry conda update --all - # - conda config --set solver libmamba - - export MINICONDA_PATH=$HOME/miniconda - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - choco install openssl.light - - echo "folder $MINICONDA_SUB_PATH does not exist" - - echo "installing miniconda for windows" - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - - echo "checking if folder $MINICONDA_SUB_PATH exists" - - if [[ -d $MINICONDA_SUB_PATH ]]; then echo "folder $MINICONDA_SUB_PATH exists"; else echo "folder $MINICONDA_SUB_PATH does not exist"; fi - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r + - python --version - conda config --set quiet yes --set always_yes yes --set changeps1 no - - # install via exe - # - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - # - echo 'downloaded miniconda.exe' - # - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=%UserProfile%\miniconda + - travis_retry conda update -n base -c defaults conda + - travis_retry conda update --all + - conda config --set solver libmamba before_install: # Python package manager From 7698e853ab0430ee2e521f7c346913f58385f09d Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 12:11:20 +0100 Subject: [PATCH 23/44] CI: fixup 3355814 - setting libmamba solver failed, comment out for now --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b952f2f1..c363679a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -62,7 +62,7 @@ jobs: - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all - - conda config --set solver libmamba + - # conda config --set solver libmamba # libmamba solver is not available somehow before_install: # Python package manager From 6adfb5cfb2ee54799e9a03eb972fc104b11ac5c4 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 13:44:31 +0100 Subject: [PATCH 24/44] CI: try `python=3.11` --- .travis.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index c363679a..b667055f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -48,7 +48,7 @@ jobs: # Windows job - os: windows language: shell - before_install: + before_install: - export MINICONDA_PATH=$HOME/miniconda - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts @@ -62,7 +62,6 @@ jobs: - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all - - # conda config --set solver libmamba # libmamba solver is not available somehow before_install: # Python package manager @@ -84,7 +83,7 @@ install: - travis_retry conda create -n test-env - eval "$(conda shell.bash hook)" - conda activate test-env - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.9; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.11; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all From 36ccf714601e2f8b77ac5d4ca8c99bfd825cad9b Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 14:07:31 +0100 Subject: [PATCH 25/44] CI: try updating matplotlib --- .travis.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index b667055f..2c574f31 100644 --- a/.travis.yml +++ b/.travis.yml @@ -53,8 +53,10 @@ jobs: - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - - choco install openssl.light - - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" + # - choco install openssl.light + # - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" + - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe + - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=$MINICONDA_PATH_WIN - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r @@ -83,13 +85,14 @@ install: - travis_retry conda create -n test-env - eval "$(conda shell.bash hook)" - conda activate test-env - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.11; fi + - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.9; fi - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - travis_retry conda update -c conda-forge --all # testing dependencies - travis_retry conda install -c conda-forge tox flake8 pylint pytest-xdist pytest-cov codecov - travis_retry conda install -c conda-forge networkx matplotlib cartopy sphinx + - travis_retry conda update -c conda-forge --all # debugging info - conda info -a From 5fc023a4a7ceb51d72a7e5863b72404018d6a2b4 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 14:09:36 +0100 Subject: [PATCH 26/44] CI: fixup 36ccf71 --- .travis.yml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 2c574f31..b1d0c0a8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -53,10 +53,8 @@ jobs: - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - # - choco install openssl.light - # - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - - wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -O miniconda.exe - - start /wait "" miniconda.exe /S /InstallationType=JustMe /AddToPath=1 /D=$MINICONDA_PATH_WIN + - choco install openssl.light + - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r From 022f22b07bd7f75739109f3b5b588cc25bcae231 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 14:33:19 +0100 Subject: [PATCH 27/44] CI: remove `matplotlib` preinstall --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b1d0c0a8..94da83e7 100644 --- a/.travis.yml +++ b/.travis.yml @@ -89,7 +89,7 @@ install: # testing dependencies - travis_retry conda install -c conda-forge tox flake8 pylint pytest-xdist pytest-cov codecov - - travis_retry conda install -c conda-forge networkx matplotlib cartopy sphinx + - travis_retry conda install -c conda-forge networkx cartopy sphinx - travis_retry conda update -c conda-forge --all # debugging info From 6f870772d844220cf91a8157e7184c7b3badf72c Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 15:12:47 +0100 Subject: [PATCH 28/44] CI: try installing everything via pip --- .travis.yml | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 94da83e7..10daf488 100644 --- a/.travis.yml +++ b/.travis.yml @@ -62,6 +62,12 @@ jobs: - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all + install: + # runtime dependencies + - travis_retry conda create -n test-env + - eval "$(conda shell.bash hook)" + - conda activate test-env + - travis_retry conda install -c conda-forge python=3.9 before_install: # Python package manager @@ -89,8 +95,7 @@ install: # testing dependencies - travis_retry conda install -c conda-forge tox flake8 pylint pytest-xdist pytest-cov codecov - - travis_retry conda install -c conda-forge networkx cartopy sphinx - - travis_retry conda update -c conda-forge --all + - travis_retry conda install -c conda-forge networkx matplotlib cartopy sphinx # debugging info - conda info -a From df33978e160732887eab678b503122f8fe5908ee Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 15:42:18 +0100 Subject: [PATCH 29/44] CI: try setting `WINDIR` manually --- .travis.yml | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 10daf488..b4a9f9a6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -53,6 +53,7 @@ jobs: - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin + - export WINDIR=%SystemRoot% - choco install openssl.light - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" @@ -62,12 +63,6 @@ jobs: - conda config --set quiet yes --set always_yes yes --set changeps1 no - travis_retry conda update -n base -c defaults conda - travis_retry conda update --all - install: - # runtime dependencies - - travis_retry conda create -n test-env - - eval "$(conda shell.bash hook)" - - conda activate test-env - - travis_retry conda install -c conda-forge python=3.9 before_install: # Python package manager From 73b1d27925d383ce895a229ced4a712dc3ed4084 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 15:56:36 +0100 Subject: [PATCH 30/44] CI: try the same but later --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b4a9f9a6..30395cea 100644 --- a/.travis.yml +++ b/.travis.yml @@ -53,10 +53,11 @@ jobs: - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - - export WINDIR=%SystemRoot% - choco install openssl.light - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" + - echo $PATH + - export WINDIR=%SystemRoot% - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r - python --version @@ -108,6 +109,7 @@ script: - travis_retry pip install -v -e ".[testing,docs]" # test suite + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then export WINDIR=%SystemRoot%; fi - tox -v after_success: From 0a8d058d613d0316ded81be93360b09acdfbe424 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 16:14:20 +0100 Subject: [PATCH 31/44] CI: just check WINDIR is set --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 30395cea..bfedcffd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -56,8 +56,8 @@ jobs: - choco install openssl.light - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - - echo $PATH - - export WINDIR=%SystemRoot% + - echo "$PATH" | wc -l + - echo $WINDIR - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r - python --version From 147a406858c077f2bb585ab774a997276a50ef0c Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 16:19:36 +0100 Subject: [PATCH 32/44] CI: check again --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index bfedcffd..81321c23 100644 --- a/.travis.yml +++ b/.travis.yml @@ -56,7 +56,7 @@ jobs: - choco install openssl.light - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - - echo "$PATH" | wc -l + - echo "$PATH" | wc -c - echo $WINDIR - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r @@ -109,7 +109,7 @@ script: - travis_retry pip install -v -e ".[testing,docs]" # test suite - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then export WINDIR=%SystemRoot%; fi + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then echo $WINDIR; fi - tox -v after_success: From 7bb42d16ef2cf64f9daecba3426281cbd416ff32 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 16:36:13 +0100 Subject: [PATCH 33/44] CI: different spelling --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 81321c23..f770a31c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -57,7 +57,7 @@ jobs: - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - echo "$PATH" | wc -c - - echo $WINDIR + - echo %WINDIR% - source $MINICONDA_PATH/etc/profile.d/conda.sh - hash -r - python --version @@ -109,7 +109,7 @@ script: - travis_retry pip install -v -e ".[testing,docs]" # test suite - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then echo $WINDIR; fi + - if [ "$TRAVIS_OS_NAME" = "windows" ]; then echo %WINDIR%; fi - tox -v after_success: From 3bb5ec1a58b44cd4beb256f62215928af6aaca4b Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 16:55:01 +0100 Subject: [PATCH 34/44] CI: try pip with no conda --- .travis.yml | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/.travis.yml b/.travis.yml index f770a31c..2c15ecdd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,21 +49,25 @@ jobs: - os: windows language: shell before_install: - - export MINICONDA_PATH=$HOME/miniconda - - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - - choco install openssl.light - - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - - echo "$PATH" | wc -c - - echo %WINDIR% - - source $MINICONDA_PATH/etc/profile.d/conda.sh - - hash -r - - python --version - - conda config --set quiet yes --set always_yes yes --set changeps1 no - - travis_retry conda update -n base -c defaults conda - - travis_retry conda update --all + # - export MINICONDA_PATH=$HOME/miniconda + # - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` + # - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts + # - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin + # - choco install openssl.light + # - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" + # - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" + # - source $MINICONDA_PATH/etc/profile.d/conda.sh + # - hash -r + # - python --version + # - conda config --set quiet yes --set always_yes yes --set changeps1 no + # - travis_retry conda update -n base -c defaults conda + # - travis_retry conda update --all + + - choco install python --version 3.11 + - python -m pip install --upgrade pip + env: PATH=/c/Python38:/c/Python38/Scripts:$PATH + install: + - echo "trying pip install right away" before_install: # Python package manager @@ -109,7 +113,6 @@ script: - travis_retry pip install -v -e ".[testing,docs]" # test suite - - if [ "$TRAVIS_OS_NAME" = "windows" ]; then echo %WINDIR%; fi - tox -v after_success: From d9a6d97df17cc62791cea7bb5295024e52c206f2 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 16:59:03 +0100 Subject: [PATCH 35/44] CI: fixup 3bb5ec1 --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 2c15ecdd..11ade1c4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -65,7 +65,7 @@ jobs: - choco install python --version 3.11 - python -m pip install --upgrade pip - env: PATH=/c/Python38:/c/Python38/Scripts:$PATH + env: PATH=/c/Python311:/c/Python311/Scripts:$PATH install: - echo "trying pip install right away" From be120dd8a179575fc2bb5f5eaccf79ce097229d1 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Mon, 22 Jan 2024 17:13:33 +0100 Subject: [PATCH 36/44] CI: set `WINDIR` globally --- .travis.yml | 22 +++++----------------- 1 file changed, 5 insertions(+), 17 deletions(-) diff --git a/.travis.yml b/.travis.yml index 11ade1c4..b5f7d745 100644 --- a/.travis.yml +++ b/.travis.yml @@ -48,26 +48,14 @@ jobs: # Windows job - os: windows language: shell + env: + - PATH=/c/Python311:/c/Python311/Scripts:$PATH + - WINDIR=C:\Windows before_install: - # - export MINICONDA_PATH=$HOME/miniconda - # - export MINICONDA_PATH_WIN=`cygpath --windows $MINICONDA_PATH` - # - export MINICONDA_SUB_PATH=$MINICONDA_PATH/Scripts - # - export MINICONDA_LIB_BIN_PATH=$MINICONDA_PATH/Library/bin - # - choco install openssl.light - # - choco install miniconda3 --params="'/JustMe /AddToPath:1 /D:$MINICONDA_PATH_WIN'" - # - export PATH="$MINICONDA_PATH:$MINICONDA_SUB_PATH:$MINICONDA_LIB_BIN_PATH:$PATH" - # - source $MINICONDA_PATH/etc/profile.d/conda.sh - # - hash -r - # - python --version - # - conda config --set quiet yes --set always_yes yes --set changeps1 no - # - travis_retry conda update -n base -c defaults conda - # - travis_retry conda update --all - - - choco install python --version 3.11 + - choco install python --version 3.11.6 - python -m pip install --upgrade pip - env: PATH=/c/Python311:/c/Python311/Scripts:$PATH install: - - echo "trying pip install right away" + - echo using pip install on windows before_install: # Python package manager From 2b9e72476b27bb8599041a4304eee9a7ad2193b6 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Wed, 24 Jan 2024 11:22:57 +0100 Subject: [PATCH 37/44] MAINT: fix `Data.print_data_info()` - remove printing `Dataset.file_format` for `h5netcdf` compatibility - alternatively introduce strict `netCDF4-python` dependency --- src/pyunicorn/core/data.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/pyunicorn/core/data.py b/src/pyunicorn/core/data.py index cd3a3c36..6007febd 100644 --- a/src/pyunicorn/core/data.py +++ b/src/pyunicorn/core/data.py @@ -387,7 +387,6 @@ def print_data_info(self): """Print information on the data encapsulated by the Data object.""" # Open netCDF4 file f = Dataset(self.file_name, "r") - print("File format:", f.file_format) print("Global attributes:") for name in f.ncattrs(): print(name + ":", getattr(f, name)) From 1601e2e6642370f281ce2d9f94113e875f65e630 Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Wed, 24 Jan 2024 15:01:14 +0100 Subject: [PATCH 38/44] TST: add tests for `nsi_local_clustering(typical_weight=3.)` --- tests/test_core/test_network.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/tests/test_core/test_network.py b/tests/test_core/test_network.py index 2b9c4ad1..4a4e1bbb 100644 --- a/tests/test_core/test_network.py +++ b/tests/test_core/test_network.py @@ -357,7 +357,6 @@ def test_nsi_degree(): assert np.allclose(net.nsi_degree(typical_weight=2.0), deg_ref) deg_ref = np.array([3.2, 3., 1.95, 1.65, 2.7, 1., 1.]) - assert np.allclose(net.splitted_copy().nsi_degree(typical_weight=2.0), deg_ref) @@ -630,16 +629,21 @@ def test_assortativity(): assert np.allclose(res, exp) -def test_nsi_local_clustering(): +@pytest.mark.parametrize("tw, exp, exp_split", [ + (None, + np.array([0.55130385, 0.724375, 1., 0.81844073, 0.80277575, 1.]), + np.array([0.55130385, 0.724375, 1., 0.81844073, 0.80277575, 1., 1.])), + (3., + np.array([-1.44290123, -0.764, 1., 4.16770186, -0.75324675, 1.]), + np.array([-1.44290123, -0.764, 1., 4.16770186, -0.75324675, 1., 1.])) + ]) +def test_nsi_local_clustering(tw, exp, exp_split): net = Network.SmallTestNetwork() - res = net.nsi_local_clustering() - exp = np.array([0.55130385, 0.724375, 1., 0.81844073, 0.80277575, 1.]) - assert np.allclose(res, exp) - - res = net.splitted_copy().nsi_local_clustering() - exp = np.array([0.55130385, 0.724375, 1., 0.81844073, 0.80277575, 1., 1.]) - assert np.allclose(res, exp) + assert np.allclose(net.nsi_local_clustering(typical_weight=tw), exp) + assert np.allclose( + net.splitted_copy().nsi_local_clustering(typical_weight=tw), + exp_split) def test_nsi_global_clustering(): From 4950cac7ae4cd0190b21f4f2958e642cf837439a Mon Sep 17 00:00:00 2001 From: fkuehlein Date: Wed, 24 Jan 2024 16:27:14 +0100 Subject: [PATCH 39/44] MAINT: introduce `climate.MapPlot` - remove old `MapPlots` - rename `CartopyPlots` -> `MapPlot` - clean up for most basic functionality - adapt `ClimateNetworks.ipynb` accordingly - add most basic test in `test_map_plot.py` - remove respective TODOs in init-files - adapt docs --- docs/source/api/climate/map_plots.rst | 4 +- notebooks/tutorial_ClimateNetworks.ipynb | 137 ++++----- src/pyunicorn/__init__.py | 1 - src/pyunicorn/climate/__init__.py | 3 +- src/pyunicorn/climate/cartopy_plots.py | 165 ----------- src/pyunicorn/climate/map_plot.py | 125 ++++++++ src/pyunicorn/climate/map_plots.py | 352 ----------------------- src/pyunicorn/core/__init__.py | 1 - tests/test_climate/test_map_plot.py | 51 ++++ 9 files changed, 239 insertions(+), 600 deletions(-) delete mode 100644 src/pyunicorn/climate/cartopy_plots.py create mode 100644 src/pyunicorn/climate/map_plot.py delete mode 100644 src/pyunicorn/climate/map_plots.py create mode 100644 tests/test_climate/test_map_plot.py diff --git a/docs/source/api/climate/map_plots.rst b/docs/source/api/climate/map_plots.rst index 415c618d..5ba17481 100644 --- a/docs/source/api/climate/map_plots.rst +++ b/docs/source/api/climate/map_plots.rst @@ -1,8 +1,8 @@ -climate.map_plots +climate.map_plot ================= -.. automodule:: pyunicorn.climate.map_plots +.. automodule:: pyunicorn.climate.map_plot :synopsis: spatially embedded complex networks, multivariate data, time series surrogates :members: diff --git a/notebooks/tutorial_ClimateNetworks.ipynb b/notebooks/tutorial_ClimateNetworks.ipynb index 2174ef44..cfb4de24 100644 --- a/notebooks/tutorial_ClimateNetworks.ipynb +++ b/notebooks/tutorial_ClimateNetworks.ipynb @@ -130,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 2, "id": "e793f1a2", "metadata": {}, "outputs": [], @@ -249,8 +249,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Reading NetCDF File and converting data to NumPy array...\n", - "File format: NETCDF4_CLASSIC\n", + "Reading NetCDF File and converting data to NumPy array...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Global attributes:\n", "description: Data from NCEP initialized reanalysis (4x/day). These are the 0.9950 sigma level values\n", "platform: Model\n", @@ -299,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 16, "id": "c5326b90", "metadata": {}, "outputs": [ @@ -308,7 +313,13 @@ "output_type": "stream", "text": [ "Generating a Tsonis climate network...\n", - "Calculating daily (monthly) anomaly values...\n", + "Calculating daily (monthly) anomaly values...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Calculating correlation matrix at zero lag from anomaly values...\n", "Extracting network adjacency matrix by thresholding...\n", "Setting area weights according to type surface ...\n", @@ -357,7 +368,7 @@ "id": "b443476e", "metadata": {}, "source": [ - "We finish by doing some calculations and saving them to text files." + "We finish by calculating some network measures, optionally saving them to text files." ] }, { @@ -401,10 +412,10 @@ "#\n", "\n", "# Save the grid (mainly vertex coordinates) to text files\n", - "data.grid.save_txt(filename=\"grid.txt\")\n", + "#data.grid.save_txt(filename=\"grid.txt\")\n", "\n", "# Save the degree sequence. Other measures may be saved similarly.\n", - "np.savetxt(\"degree.txt\", degree)" + "#np.savetxt(\"degree.txt\", degree)" ] }, { @@ -420,25 +431,11 @@ "id": "4ee5b44c", "metadata": {}, "source": [ - "`pyunicorn` provides a basic plotting feature based on the cartopy package and matplotlib that can be used to have a first look at the generated data. Also the plotting with the `pyNGL` package is still supported but not recommended, as it is deprecated and its development currently at halt in favor for the cartopy project. For plotting in pyunicorn with `pyNGL` an old tutorial can be found in `examples\\tutorials\\climate_networks.py`." - ] - }, - { - "cell_type": "markdown", - "id": "3ba76b85", - "metadata": {}, - "source": [ - "#### Cartopy" - ] - }, - { - "cell_type": "markdown", - "id": "80c32759", - "metadata": {}, - "source": [ - "For more info on and how to install cartopy please check out their webpage: https://scitools.org.uk/cartopy/docs/latest/ !\n", + "`pyunicorn` provides a basic plotting feature based on the `cartopy` package and `matplotlib` that can be used to have a first look at the generated data.\n", "\n", - "*Copyright: Cartopy. Met Office. git@github.com:SciTools/cartopy.git.* " + "> For more info on and how to install cartopy please check out their webpage: https://scitools.org.uk/cartopy/docs/latest/\n", + "> \n", + "> *Copyright: Cartopy. Met Office. git@github.com:SciTools/cartopy.git.* " ] }, { @@ -446,12 +443,12 @@ "id": "51440d40", "metadata": {}, "source": [ - "We start by creating a plot class, which later on we can modify by acessing its axes. " + "We start by initializing a MapPlot object, which we can then use to plot data." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "id": "b823297c", "metadata": { "scrolled": false @@ -461,14 +458,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Created plot class.\n" + "Created MapPlot.\n" ] } ], "source": [ - "# create a Cartopy plot instance called cn_plot (cn for climate network)\n", + "# create a Cartopy plot instance called map_plot\n", "# from the data with title DATA_SOURCE\n", - "cn_plot = climate.CartopyPlots(data.grid, DATA_SOURCE)" + "map_plot = climate.MapPlot(data.grid, DATA_SOURCE)" ] }, { @@ -476,45 +473,20 @@ "id": "422af668", "metadata": {}, "source": [ - "Now we add the network measures that we want to plot out via the `.add_dataset()` method, which takes a title and a network measure. The title will also be the name of the plot that will be saved." + "With `MapPlot.plot()` we can now plot some of our previously calculated measures on the given grid." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 19, "id": "056f3a92", "metadata": {}, - "outputs": [], - "source": [ - "# Add network measures to the plotting queue\n", - "cn_plot.add_dataset(\"Degree\", degree)\n", - "cn_plot.add_dataset(\"Closeness\", closeness)\n", - "cn_plot.add_dataset(\"Betweenness (log10)\", np.log10(betweenness + 1))\n", - "cn_plot.add_dataset(\"Clustering\", clustering)\n", - "cn_plot.add_dataset(\"Average link distance\", ald)\n", - "cn_plot.add_dataset(\"Maximum link distance\", mld)" - ] - }, - { - "cell_type": "markdown", - "id": "a76114b5", - "metadata": {}, - "source": [ - "Before plotting, we can change the plots by accessing `ax`, since cartopy is based on `maplotlib`." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "9a001877", - "metadata": { - "scrolled": true - }, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAESCAYAAACly0xlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gc1fWw3zuzVVpJq94s2ZZsy0XuNrYBNzAYTAktYCAGGxJCKIEEAl9CJwm9hO4AAQIhgQA/ejVgYjC2ce9dclOvK+2uts3c74+V1l6rWLLkBvM+jx9rZ+7MnHt3du6Zc08RUkqJgYGBgYGBgUE3UI60AAYGBgYGBgbHPoZCYWBgYGBgYNBtDIXCwMDAwMDAoNsYCoWBgYGBgYFBtzEUCgMDAwMDA4NuYygUBgYGBgYGBt3GUCgMDAwMDAwMuo2hUBgYGBgYGBh0G0OhMDAwMDAwMOg2hkJhYGBw1LBjxw6EELzyyiuH5Px9+vRh9uzZh+TcBgY/dQyFwsDAwMDAwKDbmI60AAYGBgaHi82bN6MoxnuUgcGhwPhlGRgcA+i6js/nO+jjvV5vD0pz7GK1WjGbzUdaDAODHyWGQmFwSLn77rsRQrBt2zZmz56N0+kkISGBOXPmtJrk/vWvf3HccccRExNDYmIikyZN4osvvohq8+mnnzJx4kRiY2OJi4vjjDPOYP369VFtZs+ejcPhoKioiOnTpxMbG0tWVhb33nsvXS2uO2XKFAoLC9mwYQNTp04lJiaG7OxsHnrooVZtfT4fd999NwMGDMBms5GZmcl5553H9u3bI20eeeQRjj/+eJKTk7Hb7YwePZq333671bmEEFx33XW8/vrrDBkyBKvVymeffdYlmZcvX86kSZOIiYnhT3/6EwB+v5+77rqLfv36YbVaycnJ4ZZbbsHv90ed4+WXX+akk04iLS0Nq9XK4MGDee6551pdq0+fPpx55pl89913HHfccdhsNvLy8nj11Vej2tXW1nLzzTczdOhQHA4H8fHxnH766axevbrDvrz88ssIIVi5cmWrfffddx+qqlJSUgLA1q1bOf/888nIyMBms9GrVy9mzpyJy+WKkndfH4pgMMg999xD//79sdlsJCcnc+KJJzJv3ryOB9nAwKAVhkJhcFi48MILaWxs5P777+fCCy/klVde4Z577onsv+eee5g1axZms5l7772Xe+65h5ycHL7++utIm9dee40zzjgDh8PBgw8+yB133MGGDRs48cQT2bFjR9T1NE3jtNNOIz09nYceeojRo0dz1113cdddd3VZ9rq6Ok477TSGDx/Oo48+ysCBA7n11lv59NNPo6535plncs899zB69GgeffRRbrjhBlwuF+vWrYu0e+KJJxg5ciT33nsv9913HyaTiZ///Od8/PHHra779ddf87vf/Y6LLrqIJ554gj59+nRa5pqaGk4//XRGjBjB3/72N6ZOnYqu65x99tk88sgjnHXWWTz11FOcc845PP7441x00UVRxz/33HP07t2bP/3pTzz66KPk5ORwzTXX8Mwzz7S61rZt27jgggs45ZRTePTRR0lMTGT27NlRil5RURHvvfceZ555Jo899hh/+MMfWLt2LZMnT6a0tLTdflxwwQXY7XZef/31Vvtef/11pkyZQnZ2NoFAgOnTp7N48WKuv/56nnnmGa666iqKioqor69v9/x3330399xzD1OnTuXpp5/mtttuIzc3lxUrVnRilA0MDKKQBgaHkLvuuksC8oorrojafu6558rk5GQppZRbt26ViqLIc889V2qaFtVO13UppZSNjY3S6XTKX/3qV1H7y8vLZUJCQtT2yy+/XALy+uuvjzrPGWecIS0Wi6yqquq0/JMnT5aAfPXVVyPb/H6/zMjIkOeff35k20svvSQB+dhjj7U6R0sfpJTS6/VG7QsEArKwsFCedNJJUdsBqSiKXL9+fadl3V/muXPnRm1/7bXXpKIo8ttvv43aPnfuXAnIhQsXtiunlFJOnz5d5uXlRW3r3bu3BOSCBQsi2yorK6XVapU33XRTZJvP52v13RYXF0ur1SrvvffeqG2AfPnllyPbLr74YpmVlRV1/IoVK6LarVy5UgLyrbfeam9YIvJefvnlkc/Dhw+XZ5xxRofHGBgYdA7DQmFwWLj66qujPk+cOJGamhoaGhp477330HWdO++8s5XDnBACgHnz5lFfX8/FF19MdXV15J+qqowbN4758+e3uuZ1110XdZ7rrruOQCDAl19+2SXZHQ4Hv/jFLyKfLRYLxx13HEVFRZFt77zzDikpKVx//fWtjm/pA4Ddbo/8XVdXh8vlYuLEiW2+EU+ePJnBgwd3SdYWrFYrc+bMidr21ltvMWjQIAYOHBg1hieddBJA1BjuK6fL5aK6uprJkydTVFQUtYQAMHjwYCZOnBj5nJqaSkFBQdT4WK3WyHeraRo1NTU4HA4KCgoOaA247LLLKC0tjZLv9ddfx263c/755wOQkJAAwOeff94lfxGn08n69evZunVrp48xMDBoG0OhMDgs5ObmRn1OTEwEwpPq9u3bURSlw8mz5YF/0kknkZqaGvXviy++oLKyMqq9oijk5eVFbRswYABAq+WRA9GrV68opaBF/rq6usjn7du3U1BQgMnUceDURx99xPjx47HZbCQlJZGamspzzz3XapIG6Nu3b5fk3Jfs7GwsFkvUtq1bt7J+/fpW49cyLvuO4cKFC5k2bRqxsbE4nU5SU1Mjfhj7y7r/dwutx0fXdR5//HH69++P1WolJSWF1NRU1qxZ02bf9+WUU04hMzMzsuyh6zr/+c9/+NnPfkZcXBwQHqvf//73vPjii6SkpDB9+nSeeeaZA5773nvvpb6+ngEDBjB06FD+8Ic/sGbNmg6PMTAwaBsjbNTgsKCqapvbZSedJHVdB8J+FBkZGa32H2gi7w7dlb2Fb7/9lrPPPptJkybx7LPPkpmZidls5uWXX+bf//53q/b7Wgm6SlvH6rrO0KFDeeyxx9o8JicnBwgrRyeffDIDBw7kscceIycnB4vFwieffMLjjz8e+S5a6Mz43Hfffdxxxx1cccUV/PnPfyYpKQlFUbjxxhtbnW9/VFXlkksu4YUXXuDZZ59l4cKFlJaWRlmNAB599FFmz57N+++/zxdffMFvf/tb7r//fhYvXkyvXr3aPPekSZPYvn175JgXX3yRxx9/nLlz5/LLX/6yQ7kMDAyiMRQKgyNOfn4+uq6zYcMGRowY0W4bgLS0NKZNm3bAc+q6TlFRUeTtG2DLli0AXXJu7Cz5+fksWbKEYDDYbljiO++8g81m4/PPP8dqtUa2v/zyyz0uT3syrl69mpNPPrmVxWVfPvzwQ/x+Px988EGU9aGtZaXO8vbbbzN16lT+8Y9/RG2vr68nJSXlgMdfdtllPProo3z44Yd8+umnpKamMn369Fbthg4dytChQ7n99tv5/vvvOeGEE5g7dy5/+ctf2j13UlISc+bMYc6cObjdbiZNmsTdd99tKBQGBl3EWPIwOOKcc845KIrCvffe2+ptteUtd/r06cTHx3PfffcRDAZbnaOqqqrVtqeffjrqPE8//TRms5mTTz65h3sA559/PtXV1VHX3PfaEH7TFkKgaVpk344dO3jvvfd6XJ62uPDCCykpKeGFF15ota+pqQmPxxORE6ItDC6Xq1uKj6qqrSw6b731ViTk80AMGzaMYcOG8eKLL/LOO+8wc+bMKKtUQ0MDoVAo6pihQ4eiKEqrkNh9qampifrscDjo169fh8cYGBi0jWGhMDji9OvXj9tuu40///nPTJw4kfPOOw+r1crSpUvJysri/vvvJz4+nueee45Zs2YxatQoZs6cSWpqKrt27eLjjz/mhBNOiJrMbTYbn332GZdffjnjxo3j008/5eOPP+ZPf/oTqampPd6Hyy67jFdffZXf//73/PDDD0ycOBGPx8OXX37JNddcw89+9jPOOOMMHnvsMU477TQuueQSKisreeaZZ+jXr99hWbefNWsW//3vf7n66quZP38+J5xwApqmsWnTJv773//y+eefM2bMGE499VQsFgtnnXUWv/71r3G73bzwwgukpaVRVlZ2UNc+88wzuffee5kzZw7HH388a9eu5fXXX2/l59IRl112GTfffDNAq+WOr7/+muuuu46f//znDBgwgFAoxGuvvYaqqhHHzbYYPHgwU6ZMYfTo0SQlJbFs2TLefvvtKIdeAwODTnLkAkwMfgq0hI3uH6r58ssvS0AWFxdHtr300kty5MiR0mq1ysTERDl58mQ5b968qOPmz58vp0+fLhMSEqTNZpP5+fly9uzZctmyZZE2l19+uYyNjZXbt2+Xp556qoyJiZHp6enyrrvuahW6eCAmT54shwwZ0mr75ZdfLnv37h21zev1yttuu0327dtXms1mmZGRIS+44AK5ffv2SJt//OMfsn///tJqtcqBAwfKl19+OTJG+wLIa6+9tkuyHkhmKcNhqg8++KAcMmRIZJxHjx4t77nnHulyuSLtPvjgAzls2DBps9lknz595IMPPhgJjd33O+vdu3ebYZeTJ0+WkydPjnz2+XzypptukpmZmdJut8sTTjhBLlq0qFW7tsJGWygrK5OqqsoBAwa02ldUVCSvuOIKmZ+fL202m0xKSpJTp06VX375ZVS7/cNG//KXv8jjjjtOOp1Oabfb5cCBA+Vf//pXGQgE2hw/AwOD9hFSdtGzzMDgKGf27Nm8/fbbuN3uIy2KQQ9SXV1NZmYmd955J3fccceRFsfAwGA/DB8KAwODY4JXXnkFTdOYNWvWkRbFwMCgDQwfCoOfJLW1tQQCgXb3q6p6SHwtusOxKHNP8PXXX7Nhwwb++te/cs455xySKB0DA4PuYygUBj9JzjvvPP73v/+1u793795dToB1qDkWZe4J7r333kgI6FNPPXWkxTEwMGgHw4fC4CfJ8uXLozI57o/dbueEE044jBIdmGNRZgMDg58OhkJhYGBgYGBg0G0Mp0wDAwMDAwODbmMoFAYGBgYGBgbdxlAoDjPnnnsuiYmJXHDBBQB4vV5OP/10Bg4cyJAhQ6Kczqqrq5k6dSr9+/fnvPPOw+fzAbBnzx4mT57MJZdcgqZpvP/++8ycOTNy3HXXXcdpp50W+Xz77bfz4IMPHqYeHhzFxcVMnTqVwYMHM3ToUDweDz/88ANDhgyhX79+3HvvvZG2X331FaNHj+bhhx8G4He/+x1z586N7C8sLOSBBx6IfD7xxBNZsmTJ4evMIeSjjz6ioKCA/v378+KLLwLwr3/9i1GjRvGvf/3rCEvX83TnvoBw0bgRI0ZE/r366qtHohtd5lA8JwCmTJnCwIEDI+Px29/+9vB3zuDHy5HMqvVTZP78+fKDDz6Q559/vpRSSo/HI7/55hsppZSNjY2yoKBAbt26VUop5U033SSfeuqpVn/fcsstcuPGjfKZZ56Rn376qayoqIjK2njiiSfK8ePHS13XpZRSnnTSSXLBggWHq4sHxaRJkyIy1tTUyGAwKMeMGSNXr14tQ6GQHDdunFyzZo2UUsoLL7xQNjU1yYsvvlg2NjbKN998M5L90OVyyVGjRsmf/exnUspwZsjExMQfRebDYDAo+/fvL/fs2SMbGxvlgAEDZHV1tTznnHNkIBCI9PnHRHfuCymlTE5OPmKyd4dD8ZyQMpzBdO3atYe7OwY/EQwLxWFmypQpxMXFRT7HxMQwefJkIFyYqKCgIFIv4YMPPogk8fnFL37Bhx9+CIQraSqKgslkQtd10tLSUFWVsrIympqaMJvNDB48mE2bNqHrOqtXr2bMmDGHuaedZ/369ZjNZiZOnAiEqz9WVlYSCoUYNmwYqqoyc+ZMPvroIyDcfyFEpODUhAkTWLRoEQBLlixhxowZVFZWArBq1SoGDx7cbgXQY4mWN/Ps7GwcDgenn346X3zxBVJKhBAdVhA9FunufXEscyieEwYGhxpDoTiK2L17N2vWrGHUqFFAuMJjQkICANnZ2ZHKjNdccw1XXHEF8+fPj5RwbplUly1bxujRoxk/fjyLFi1i/fr15OXlYbfbj0ynOsHWrVtxOBycddZZjBo1ivvuu4/S0lKys7Mjbfbt/5w5c5gwYQKFhYXExcWRk5OD1+ulpqaGxYsXM378ePr27UtRURGLFy/m+OOPP1Jd61HaG5OzzjqLsWPHcu655x5B6Xqe7t4XEC6Pvu+SR3dKsB8tdOc5AXDBBRdExmPf5SEDg+5iJLY6SvD7/Vx00UU8/PDDxMbGdti2b9++fPfdd1HbWhSKtLQ0xo8fT//+/XnqqafQNI0JEyYcStG7TSgU4ttvv2XVqlWkpaVx2mmndWhRmDFjBjNmzIjaNn78eBYvXsySJUu45ppr2L59O4sWLWLx4sWRdegfK1deeSVXXnnlkRajx+mJ+8LpdLJq1apDLOnho7vPCYC3336bwsLCQyWiwU8Yw0JxFCCl5LLLLmPGjBlRk19CQgIulwuAkpISsrKy2j3HhAkTIhPq+PHjGTJkCOvWrTsm3tCzs7MZM2YMOTk5WK1WZsyYgdfrjbxpQef6v2jRImpqakhOTmbcuHGR8Tja+99ZsrKyujQmxzo9cV/8mOiJ54SBwaHEUCiOAv74xz8SExPD7bffHrX9zDPP5LXXXgPCnvxnnXVWu+cYNmwYGzduZNeuXWRnZ6OqKjExMXz11VdHvYVi7NixVFZWUldXh67rLFiwgNGjR6OqKmvWrEHTNN54440O+z9hwgT+/e9/069fPwBGjhzJvHnzkFKSnp5+uLpySDnuuONYt24dJSUluN1uPv300yhT9o+Nnrgvfkz0xHPCwOCQciQ9Qn+KnHzyyTIlJUXa7XaZnZ0tFyxYIAE5ePBgOXz4cDl8+HD52WefSSmlrKyslJMmTZL5+fnyZz/7mfR6vR2ee/LkyfKCCy6IfL711ltldnb2Ie1PT/HJJ5/IwsJCOWTIEPm73/1OSinlokWL5ODBg2VeXp686667Ojze5/NJi8Uin3766ci2cePGyUsvvfRQin3Yef/992X//v1lfn6+/Pvf/36kxTnkdPe+UFU18rsaPny4fOyxxw6D1N3nUD0nJk+eLAsKCiLnuOSSSw5Xlwx+Ahiptw0MDAwMDAy6jbHkYWBgYGBgYNBtDIXCwMDAwMDAoNsYCoWBgYGBgYFBtzEUCgMDAwMDA4NuYygUBgYGBgYGBt3GUCgMDAwMDAwMuo2hUBgYGBgYGBh0m2OilofP5yMQCBxpMQwMDAwMjgEsFgs2m+1Ii/GT46hXKHw+H717946UozYwMDAwMOiIjIwMiouLDaXiMHPUKxSBQIDKykp2795NfHw8VX+84kiLdMTYYElgcMB1pMU4KjDGIowxDmGMcQhjjAM0BoKMfPEDAoGAoVAcZo56haKF+Ph44uPj8VnbL1/8YyfWYiFO/HT7vy/GWIQxxiGMMQ5hjHEwOJIcMwqFgcGPmd0b+hzUcXXpKrsrnD0qy7FIT41DzuAd3T6HgcHBsGDBAh5++GGWL19OWVkZ7777Luecc06bba+++mr+/ve/8/jjj3PjjTdGttfW1nL99dfz4YcfoigK559/Pk888QQOhyPSZs2aNVx77bUsXbqU1NRUrr/+em655ZYe6YOhUBxD9As2HGkRjhqOtbE4WIXhQGTVaIfkvMcaPTUObX1Px5KScaz9Lgz24vF4GD58OFdccQXnnXdeu+3effddFi9eTFZWVqt9l156KWVlZcybN49gMMicOXO46qqr+Pe//w1AQ0MDp556KtOmTWPu3LmsXbuWK664AqfTyVVXXdXtPhgKxTGES7Fg03xHWoyjgqN9LA6VArE/HpvA4jYKBh/Kcdj/uzyaFYyj/XfxY6Iz0YdSSoQQUdusVitWq7VV29NPP53TTz+9w/OVlJRw/fXX8/nnn3PGGWdE7du4cSOfffYZS5cuZcyYMQA89dRTzJgxg0ceeYSsrCxef/11AoEAL730EhaLhSFDhrBq1Soee+wxQ6H4qWGTPfs22p1J72Aeqpquo0mJWVEQQtDgDyAQhKROUNNJjbG1+vG1J6/HJgj4uj6BhHQdTerUBbzUB700BH0kWmLQpE5pkwuLYmJe+UZSrQ78WggNnaCuYxIK7pAfnxbEFWyiNuDFqphIszmwKmYsqsrJ6QMZl9wHm3r41rAtocN2qaOawzkOXf3dHE4FpKefEQZt4/P56JvroLyq4/F2OBy43e6obXfddRd33313l6+p6zqzZs3iD3/4A0OGDGm1f9GiRTidzogyATBt2jQURWHJkiWce+65LFq0iEmTJmGxWCJtpk+fzoMPPkhdXR2JiYldlmtfDIXiENOTb6oem6DhICbRQ0FLv3Z5ailpqscbCpBsdeANBfjtiv9GtR2SkMl6V1nk88TUfnxbtQ2Afo5UtrmrODt7GDV+Dwurt0faHZ+SB8D31UVckDOSTHs5k1P708eRDEBI12hsnuTdIT+uYBP+khE06A1kmjJY7VtHo+YmRrGTbEpiiWcZX7sXEKL17JNj7sX0uJMoDuzkK/c6bk69njRTKiZhYlD/EkJSx2Gy8rMFc2kI7X0D3NxYEfn7k9L1ZNriCegaHi1AQAvxzolXkROb2OabisFPg32fAUezdcOg8wQCAcqrNIoW9CHe0XZ+yAa3Tt6kHZEIxRbask50hgcffBCTycRvf/vbNveXl5eTlpYWtc1kMpGUlER5eXmkTd++faPapKenR/YZCkUX6e6P+3CZstuiKkEh1nf43kC8oQClTS5iTRa+q9rOgxu/iNqfbounwhdes53V5zhiTVbmbvs2qs3NA6dxcnoBK+p2UxCXjllRyY5xAqBLibLPJBvSdb6s2MROTw0bXOWsqttN79gkBsdn8PbuldgUE1+VbyLZGouvTxJLly4FYKB1AP2secQpDt513YVE0ksOZzs/ADCEqSTgppQ6YkikiUaC+Pglc4khgSA+TEErSq1CIVDIbwhWQWZuuG/VxSkA1APPZD0JwCbH//HXDZ+1GrMyX/Qa9t3rPua0zME8uPELfpl3PKOScllau5Md7hoArKqJeLMNKeHyvuPJsMe3OmdHHO574kjj10KU+Vxsb6zin8VL2NBQxp+HnsmgkcNRPT5mfPMMQsDL4y4jNzbpsMklZVjR319p9GlBpJTYTeE3wt0b+hxSpWK3KZaEQP0hO79BNPEOpV2FItKmOUKxOyxfvpwnnniCFStWHNUvJsekQtFTk/qRVA6OZhZVF3H98r1WhvHJfXGH/IxJzGVZ3a7I9op9Js/XdvwQ+fvMrELsqoUfanfwyKYveWTTlwDMHXMxY5J7s3FjXtT1akK1+KWfkmApT1Z/ELXP5VVokk0AFFgGMkQZxOn2U6hLbGBS6njmuxcw1j6KEx0TWLYrnl8wDRsO1A5ubYmORggT4Ye8BXub7Zbtin4IjMnd29+B7vN4LXev49SgQUVAeALZ4anhF4teAaAu4MGqmnhw+LnUB71saqhgh7uGwQmZfFy6jlq/hyRrLDGqBY/mb1fmw0FI19ClpLTJRarNQazJSrXfjZSSREsMJkXt8WtqUuf+9Z9T6W9ko6ucuqCX6RmDWO8qY09TPaMTc3ly9M8pa2pg5vf/ICT1qOMV4JWixSTZKli6dCmFCVmsc5Vy3nfPA/Dl1BtwWtr+fjvis9L13L72Q2bmjubmQaccsP0X5Ru5bc0HCOCCnFG8tXsFE1PzUYSCguCHmh2cmNqPvw4/O/LcMawVBp3l22+/pbKyktzc3Mg2TdO46aab+Nvf/saOHTvIyMholQAyFApRW1tLRkYGEE74VVFREdWm5XNLm+5wzCkUhhLQ85y94DnKmlx8OuU6AnooSpmYO/ZiBsVnYFctrKjbxYkN/fjb5q87PN9HpesASDel8f/Sfk+8EodJmKgv0VlZnsST1U+wzreBnyecw39d70aOO56ZXMz9bORbVvEJACWhUi7nb8SThuJTwAfL6sGarhGqOoGJnABNsKw2fI5YnB3K9r2pfp9P3lb7jw85I+1a/m5hfwUjmr1Kki515k2NJ9ESA8DvV7zNwuoiNKmTaImhLuClV0wifxl2Fv0cqQecqPdXwPbFhYemjbEdHt/Ct+7vqdFqWdW0lspQNafETaWfJY9PGj8nSU1kgef7qPaFtkGUBSuo0WoZZitEAOt8G7Ardp7JfpQh+0yIl3z/Elsaww+zRaf8AXMnlQ8pwayo+LUgdcHw9/F5+ca9+5Gc8OWjAAxNyKSsqYHqgCeyXwe2e6o5Pm4CQ/OOZ3xyH3QkNsVMpj2hS8rEmvoSSrz1jEvuw6S0/nw8+Rqc5phOHTs9czAjE3OY8b9neGv3CgA2N1QS0EMoQuDRAnxevoEyn4uQrnFN/0mwIY/0gu0Rn6KepLvPySOp7HRV4dq/r+7QkVXMDwWzZs1i2rRpUdumT5/OrFmzmDNnDgATJkygvr6e5cuXM3r0aAC+/vprdF1n3LhxkTa33XYbwWAQszns6zVv3jwKCgq6vdwBIGSLre4opaGhgYSEBFwuF/Hx8Sw/7Y9HWqQjxo50lT4V7Zu3Q7pGTcBDsbsGh8lGQXxa1IN9zOcPRP5OMNsYl9yXdFs8BXFpxJqsNAR9xJos1AW8bZrz/3HcL+gfl4YqFO7b8Blflm/Cr0f7I8QpDhp1N33MuUyNm8Ro+wiuK7m5DWkFxzMTMzZsxGLGyk5WE8RHgCYkEo0gU5hDIq3Do6xj6/AvDf8AopWEw0+L4rGvBQPCVotVdbv5z85lfFWxmXsLz6TQmdWhKb4j5aEtXIM8JHRSofhD6R2Uh/a+nQy0DqA8VEG95uL/pf2eJ6qepUnu9Q/JM/ehKLiDPEsfHIoDBYUMUxqZ5gwqQpV86f6Gs+JP45yEMzstb4sl50DoUlLtdxOjmnGY2892GNBD+LQQtb1iO/xtdIYXtn3H37d/x33DfsapmYO6fLyUkvWuMra7q3hu27dU+91MTRuA0xKD02Knzu+lMeTjq4rNTErpx86mWnZ6wprw6ZlDGJ2UyzXT4lCVztds3H8yPdAzoqscDsWip18S3SE/U756PDJnHApa5qXqFXkd+lCkjCrqtBxut5tt28K+ZSNHjuSxxx5j6tSpJCUlRVkmWujTpw833nhjVB6K008/nYqKCubOnRsJGx0zZkwkbNTlclFQUMCpp57Krbfeyrp167jiiit4/PHHjSgPA9jjreeRTfNIt8bzzp6Vke121cxV+Scyq29YM20I+vjT4NO4r1lRcAV9rKzbTX2giaDUGByfwYaG8qhzn5VVyDpXGcWe8Hr/L394HUn7+uco+3DW+zZxU+p1jLAPY9mueLYgOZlfUUEx6wgvfaTQm0t4gCe5GIA0+mInnoFMJIdCzFiRSKx0/HZ4pBWJ/Vm2Kz5KqfhstZnby19njH0kyWoiabZ49Db0964qEftez5qu4W+2nIzJbWjTitIiU7IpifJQBU41AZ/uZ5N/S6TNA5WP8besB3im+gXi1XiWN62kKLiDTFM6RYEdXJ54CWNjRlGvuVjqXUE/a1+cagJ5lj5dkrmzfR00qIg0W9wB21kUExbFRG2XpGibX/U7kV/1O/GgjxdCUOjMotCZxc96DQfCfkgNQR/1QS8l3rDz8lcVm1lQvY1RiTk0hYKk2+JYXb+HJdXFzCtPY0nNDs7PGckfB0/vgV4ZHCssW7aMqVOnRj7//ve/B+Dyyy/nlVde6dQ5Xn/9da677jpOPvnkSGKrJ598MrI/ISGBL774gmuvvZbRo0eTkpLCnXfe2SPKBBgWimOG+kATX5ZvZEnNDip8DZHJf6SzF349RIrVwYKqbWTY4in3NTA0Pou7hs4g0+7Eqpr4rmo7N654i4K4dP45/jKW1OzgL+s/5eT0gWTY4smNTWRCcl/+vv07vizfxJ6m+si1P5l0LWZF5ZRvwjfmlc7L+Ef9qwAMtQ1hrW99pG0WAyllUyv5z+RmzFhJoTcxhCe9dXzNVzzfbp9/y38QtG0KPpqUif2XRgCG59TwvWcJ/61/lwa9EYBhCdnM6nscU9MLotoejELR8fLLgdnNev6PPwNgxoaVGOJI5TjOpQ8j+I5/s5xof5bzuZNeDO7Wdfe34hwsnbV01Po9bGgopyHYRJ4jhYHxXV8nPtD3syuwhy/0//DoyPNb7VtYtZ0nNs/nj4OnMyKxF5Kwj5JZqPyvais7PDXEm23MK9/7mzk9YzCqonDTwGnoUqIjiTVZsCiH//2vKxYKdyBISJc4bZYDN94Hw0Lx48FQKA4x7T2MOvNA1KTOqfOfpCHoQwLTR4znu7Ur8GgBcuyJ7G6qi7RNUhOZ5pjCENsgkkxOnqp6niBBigM7+VPaTXj1JlJNydxb8RB+6aevuTfFwZ1R1+ttzqG/NZ8v3d8AYMLUZojlvqTQmxRyKGMbFqxUET6nhRiyGUgxK4jByRyejDhB7stCtY7d+ttUyYXohM3tx3Ee20Upg2R+JCIDwEYcDhJJohdZ/VIR25Ij5zlaFIwW5WIbP/AxjwFgEzZiFDvZpkxuSb+xy+fsSHkw9XMT2uZod39H+HCzm3VsZylV7OQSHmjlzKqjodCzzpg9pVQAuDUP5aEKyjIr2b5tOzZhIyAD1GsuarRaGrRGnGoCdVodNVodr+b8vcf9FTSp4dWbiFPD34NP9/Hf+ncRCOq0OpY2rSTP3Ic0cyqLvUujjl047WasqonNDRUUu6vZ6a3lhe0LSbbEclxyHxQhUIRgh7uGta5Ski2x/PeEX5Kwn29Iy3PGm+0jpqTjglgHevaEdB2TorC0ZgdbGivpE5vMUGc2i6qLSLE6yHOkYFNMkciVnME7kFKS8bc3ueG4wfzphGFhmarrcQdCjM1KaXWNQ+kLZygURw5DoTiEHKwpuwVd6rxZ/39YFStrmzaQGJPA0voVrdolq0nUaLX0s+SxLRB+WJgxESSETdjwSR9pphRS1RQadQ+7grtbncOpJhDQA3ibIyp6m3OpDFUxKfZ4PNKLQODzpLGU9wDIogCBgoc6gvhJJgcTFlRM6GhUsB03tcSSyByeajfqYl9FwCer8MiduOVW+sgUejEYG47m86r48NBIDTXsptK+he1NK7mSZ3GQ1Ob5jhTHh5zo6GzmO+pjlvCDdzmDrQUEZYhT4qYyIfa4do/trOWhpZ9mm07Qt/eB1pa15MfEqJx65rnnU+zfyfZAMbmWXmSY0mkwu3F7GykJlqIIFacST5IpiTRTCummNHqZs8k2Z6KIzvsntPBs9YvEKHZmJ10a2RaQQb73LCEkQ1SEKqkMVTUvZ0kadTfbA8XYhY0Lnefxz7p/U2gdzITY48gyZ3BPxQP8I+cZLF0s4vV41TOsaFrNuJgxXJfStolas+ioga73EcKKxuq6PVz5w7+YmTuaN3Yt56nRF7KmvoSFVdsZkpAVcTiNN9loCPm4u3AGd6/7hPHJfUm1ORgQl0af3m6m52Xj13Sqm3wMTnFGrnE4nOoNheLIYSgUh4juKBOa1Hjb9T4Qftvx6F6S1ERSs1KJrbYTlEHKQ5XUNDjx42EZ70cdr2KmkJOopQQTVmJxEkcy+RzHRhaQyQDyCWdTq6CIH/g/EsliDxuwEUcIP5UUkUJvXJQzmdks5T2q2Uk+Y9nOUgSCPMZSzS4SyUTFzHZ+wEkm2QykgiKq2cnJXEUhJ7XZz44m/wNNjEq2h60lG1jAazRQyfX8GwXlgOc9XIwMKTzP3od+ipoUntgs2fwi8aI2j9lfmehMPxKyArhKD2xi7qyi8S2vMYzpJJB24MaHGR2Nr3iBDXzDZGaTRQHzeQkX5WRmZzG2ZBYp5LZpCesO1ezGTQ0aQfx4CODnf7wMQAEncBznkUB6h6HKB4NGiJ2sZiMLqKQILw0kkskF3I2Ftq0QanYTWknXw2RbrEa1oTq2+4sZ1c/L27tXUB9swq+F8IT8ZNmdrHWVUulr4LoBUxidmEuC2c57JaspdlezvG43mtQJ6iE+mXwdydbOOQv3NIZCceT4UTpldtcycCjpzBuoROcjPqOQaYzlfKzE0kAVrviNLN9cTBYDqaGOFfyX3gzndG4giWwkkhgSiCEh4nuwk9VUs5vv+Bd72EgG+eQzBonOHjZG1tH3ZQ5P8TLXU8ZmJnARlRRhJ+wgV8CJjOZsVvEpXhpQUNnBSnIZRi8KUTHRQDUKKinkspNV7GQVTjIZzBQSyQQOPFnuu7+tydCcFSC/ZCwNVLGAV/k3t3Bxs8n++JDzsCoVZfpneORO6mTYKVZgQmOvQ52Kmd+k/JIB1n6Rbe3dB12V25kZ7JRCsf9521MwBjOVWLofPtbWNbvKvjJuYRGf8gRxJDOc09jNWv7HK8zgRvoxDltWPf6SA8tdTzlr+RInGQwlHIbnx8tOVrOcDxjKKRRyEpJwvosFvIaHOiopppEaMhkQ5dWTRh5JZHern/tSxU7W8AUlbKSO0qh9duKoYgfvcA8JpBMiiAkzKiaKWcnF3EdylgLNCsUy3mcT32HBjoMkYnFiI4508unNMAR7J8KW+zEns5Lnav/Bw7v/zEWmE8EEizw/8GzDi2xoKMcizPSx9Gaw52cU9g1HDF0/YEqP9d/g2OZHqVAcDRys05xE8h2vE0cKU5gdeetJpTcShe2U8h3haItkehGLk095AoC+jKKYsEkykSziSWMnqxjGqWQxkCqK6c94AN7lPnazLnLd3/AKzzEbgAW8Sgb9GMcFvM8D5DOWeso5lWswYWExbzGVK7Dh4F/8AYBdrOEc/kguw9AI8QyzsBKLQKGecopYzjLe53hm4lPHobaTTKotWiamtibBkcxAxcx8/sFr3MRpXEcG/Q+rUrFHfy/qs0Cwgo8BuIC7SCGXhopYlh3gPIdTCWr/Wg7A086+aPb9Pg6F7N+b6pFSskG7Hy+7SBNTscoqVvMZJ/NrzuD3XfLvWM83fMPLSDTsxLOVxUzlSv7FH9DROIGL8ePlv9xBDXtIpS8lbORUfsMUrsCOA4GCROd1bqEf4xjFGQe+cCf5hL+xlcU4yaAPIxnNWTjJIIVcrITf9p9gJgmkcwq/wYyVEAGaaMCPl3f4M6MZyUpRjkuuBWCo+mdMOPDIYjxolMoNLJZvES8GU6CGUzjv+z3uLuvHNbxGcSkUE7aSfE8JVmLx4yHTlEFIhnix9p/c/uVOEtQELnSei1VYsQoLqaYUbErHPhz701kHW4Ojn2NGoXj11VcZNWoU5v3SNR8MbU32IQI0UhN5gz5SVLCNFXxMASdQwkZyKKSanVRQhEIZ5WzDQx0z+B3V7MJGLLN5IrK08QXPkkUBAzieWvY0WwjWMJu/sYVF7GAlhZzEaVzPZhZSxhZCBNjDerIZRIAmKtiORohPeIIM+jOVK4khHoHCc1zBOfyRBNIQKFiw4yHsHJpBfwQCjSAAfjxUNU9OE5lFIll8wIOgvQFAtnI2FpJwikJM4sCOhW0lmwIYxETm8w9SyOVN7mjeNplTQ785LJP0IPVWdmtvYRfZ+GQ5jWyN7GvxNWmR/8fE4ejPeu0vNFFOjriQdGUq2/Tn6C0uoUEZyWIaO7WU48PNDlZSzHKu4RUEAje1fMZTLOdDcihkJ6tYyL8jxwxiMrE4aaCSL3g2sv1qXsJKDL/gkU7J35UxcjKbsc1KPYCr+d9Oghzf7Bt9Jc+yStVYKpqApuaWJlK4ihQgRfEwQG291JAgwtE5DVo4aViD3ACEc2e8IV7ALOKIF4MJynr8VCMwYdd3Y8bKWr4knXzO4g+YgzZ0QnwdfJEawo6uD1Q+zgQuosa6nC3+bYywDWVW0kxS1ZQ2HWD3ff6OyW3okkX5QMqHLiWbXeUdtjE4dBwzPhQt/CntJgbZCjo4IsyBLARuavkH15BJf5LIoYodVBK+WZPoRSq9qWYnIzidDPoj0TFhIZ60Hl8rBaikmATSI7kXPNSxlPeop4IksokjmTFjR1OzVPJPbowcZyWWSVyGjkYC6aTSGxt7J+c6SonBGTnvv/l/9Gc8GfQjm8HUUkKIANtYgh8PQ5jKm9xOBv04j9spYgXf8Toz+SuxONnMQj7jqVbyJ5LFZc1RDS1IJKVsIpMBKKiRNeFPeYIE0nBTh79Z4UgUo4gROSSIIcSK1klcWmiZQPZNbAWwiW9ZyH9w75eRoCX09FBMfj5ZxVrtjqhtcRSQpIzEI3dTLRcyWP0jsaJ3l85bpn/OHv1dhqp/xiZSO2zbe7SHncsPzVp1QLrYqb2BhheNJpoIF3iTzQpjDDkkKWNxiL446HdIagy4tI1skU9EPucoF7BbfxuAAcr1xIhemHDQZ4yvzXFo0DezWX+cXsq5nK2fg5lwYaY6SnmX+1BQyGMsafThe96kkerIsb/ieWKIjzwrAGbzZKf8S46U8tiZ+8Erd7Nb35uhNk7kY6cXHrkTs4jDRhoNcgvl8nMSxUhiRC9SxAlYhDNKgXNTi0BElsj8eNnFWj7hcTIpoIzNFHIyfjyEaCnzLQCJgkoaeaiYGczkyJJqdyOA5la/xELvYgDDh+IIcMwoFHV1dTidTm4Ubx70ubw08DlPs4s19GMc21jCdK6jF4OJJZEgfhQUvLiwEsMeNrCAV+nPeBRUgvioo2wfM6toniiDWLDTi8EkkoUJC3489Cac3OZ7Uz26DOJhJ3ayqZGLccsiamVLCJkC6FhIoq9yGY1yC6XyEwrVu3HJdQhU7GRTMLQXZetj8MkK1mt/Rm8jpFPFzLW8yiKTK2q7lDpCKOgyRIn+AeUyXOgrlnxO4lz6MorFvEMsTubzD4ZxKpo6FgvJrNTCCVYGKNcTRwH1rKFOrqBWrgQ0nGSioGIjDhNmdrGm+dxOPNRjIYZ08slnNMOYHvHv8OHmTe6gnjLsxNFEOF+DhVSGqfd2OEFlDWmiz+q91iQ/XuZyRXOUiR5ZA+/PeGZw4yF5wFfo89mtv4Ns/h7s9ELFhpttkTbD1L9gFa3D5joiJJtQsSDEgc35WUOaKF3fdSe81tf00KBvZrt8HoEKKEiCCFQkGuliGhXyS5IYj04TfmpoYk/k+DQxmQa5hf7qb7CJ7jl0hqQXBQuKMO2zzU0T5YSkG7fcHl7yE+PYoP8VgPFDz6Z0vR0VGyYc2EUmFpLxyQrW6XczQLmBBCU6++VW7TlGyNHsYg1nsTebq2yu9tLy4qCj8xo3UU8Zl/FYq8ytR5PlqSv3Q0h6CdKAXXS/hgO0XpL04SZEACsxmLFFjZMug+zS3yJEA6fKn6MTookGdDTiSMGEFTMWlvMRRSxlBDPYzlJsOLAS25xd14aKGZ0QqfQhkWxiiEcjyEtcZygUR4BjRqF48cUXmTVrFrdY3z3wQfuwjR/wUI8fNztZzQlcQhZ7LRzdeRjoUgN0FGEmKBtplFtxyY1YhJNafSk2kYadbBrl1qhJZl+ylbNRMJMqTkQCZfqn1MmVCFTMxJGunISChSZZTgObAIkJB0KaqWc1KjbMxGEVafRVLkMSan6j9OGTVTTIzbjldvxUYcJBHPl42ImXcOiojSzsIos6GV7hTxNTqJdrCVATkTFZjMMjd+CjAju5mIQNpxhKKpMAwQr9twzkRDIYwDe8BEA/jmNbc7VPExYUVALNJtoUcpnB76KWlyQ6T3JJ5HOuciHpStvRIW0xLuTgPe5jDxtIbrYwbWIhwzmNKcw+pA/9oGzETxUV+nwa5EYsJJGr/hwH+YiDCFM8XDTomyjRP8a9zxJNCwo2MsVpOMUIrCSB0AnhwSt3k6iMQNdD7NTfIEQTVpGEVSSxSw8r+wliKKAjMBMn8nGKYdhEeqtr+GU1KjGARCUGIQR1+mqK9VfQaCJPmUOSGIuX3VTr31MlFzJSfYQgjSiYaZTbcMn1qMRQKb8iT5mDwEQINx65i0a5mThRQL1ci4UEbCKTXOUCzCL8cN+u/QMzcVTK/yEJp6t2kMwpXE0uQ7s0lkeTUnGs4Je1VOuLKJUfkiwmECfCTstBXGjSj44PBQs18gdiyMXFWvool3KafhKNzc8njSAKKhUUUU8ZdZQSJMBu1hoKxRHgmFEoEhMTqaurI4N+DOUU+jCCGBI6PHY98/mSv5PFQAo5iX6MY6mpqcNjuotLX0+CMgQIa+FNlOHTK3Cxjr7KbKrld4Twkql0Pa1uy9tHUDbgoxK/rKZK/w4320gUo9FkizOdgkQjhI8m9k1eJVCwEk8BZhIIUEOiGENA1tLIpqi1/xj64GUHAGPUZxFCoVZfwW79LQrVu1ih3UiOciF1ethK0Vu9hGlaIQt4lZV8wvncSRYFfMBDnMLVlLGV7/g3PtwE8aETYiK/YBThOhBhZ9R/sZ5vIssgvRhMP46jkGmRt8WWB3d7b2Iy9GlUGG1PLnlU6N+wS3+DBDGEgHRhEWFTr4odm0gjXgzCQd5hLS98MBYKr76HDfqDwN7lC4BUMYlEMRwvJSQyigDVeClDlz7ilH4oWIghFyEEUuqUyy9IFhOwiL2/Q11qKM2WFU0GcMtt1MrlBKglJN3kqhc1K1qCrdqz1Ms1JIihNMiNDFRvwiqT2C3fRwBB6UIKnQa5t1hYLH2JFb3RCRIrcvDJSirk10we9ks860e2sur4ZS2Ncit1cjk+WcFg9TZUEY6KaZJlrNPuIVVMJFWqDOUUPuUJGqjkGv4ZWR7pKkdSuegpi9Xhwi+r2aQ9xlDlzygdFJRz6RsI4cEpClFFuH/t+c94qOdFrjYUiiPAMaNQtHwpV4nn2cVaPufpZidAiMHJWM4lndbOPSECfKmsoFouQsGKJESs6EuaMvGQyLuvQnE4qNYX4ZMVaDQh0VGJwSzikBLK5ReECK9JjlafQhHm5rY+GuVWArIWVcSgYsUr91ArlxEvBkc8xIep92EVbRey2q29S4PchECQr/6SGrmEDHEaoLNe+ysZyqmkKscjpYYQKtWhF7Bgp4EK0ulHCD87Wcs0rmr1NhjEx3f8m1pK2EM4rXcKvRnJDAYykcWm9tdZl4aujvo8hyeJJ61bD3kpJXv0/yNIAxnKKQhMWElG6WJioqMFr15CvVxHiQxb++IYQB9lFhaRGLXM0EKFPp9UMSmiKLQQkl5q5GLSlZNwyx1s1h5lgHojDvq2ssxIqeOmiAp9PjEim3RxMl52sUP7Fz4qcJBHinICZfpnqMSQo5yHQ/SLuqZsThx1sFYfTfrwyxqsIpVGuYly+RVxYgAN+kZO4xdkM5AilvMhDwMdp37vKoYF49DTomC0LH8aCsXh55iJ8igoKGD+/PnEkMBATsSMlY8IlzVOIJ2vxTwq5XwSxUj6qb9GSomPCnZqr+PTawhSB82Frarl9+zUX6efcjWJyogj16kukprnp6oo+q0pRZnQbvt0OYUV2o1IQpHJr8X03JajYB7hMrhbtKdwyfVRyoQmfbjkBiwikRiyyVHPpVFuZ5P2MGu02wEo4UPs9CJFmUCSGAnACVo4PbbG7wjgxUosO1nDD/wfhZxEJv0j16innH/yO0CSSQHJ9EKik0gm6/iaeTzXHEEyps2x2J/pXEd8FxM0SSlZo92GToh85UqK9JewiQwSxQhylNa1GtqiVP+EEv0D4kQBfZRf4JeVhPDgk+VYRCKV+reYRCxeuZuRps5FC7RHZ8ZhX6SUlOofU8cKHOThFCOJU/Lbdf7UZBN2cvDKXcTSJ8r6EsKDvdmfwEoKFlLYpIUn4zj6YxVpzf4MWQhUfJTjltsIShc1/AAIfFQwTL2Pan0hAVlDnjoHh2jb6z987bYn+M6MQ62+gh3y1chnGxkkySZO4TqchP0I8hjNDbzR4XkOhoPNYNpVRaSr98OPiZax0mQT9FzBVYMucMwoFOXl5Vx22WVsEV5U7OQqFzKCh1GwsEK7AWQ4yYqlOQ3zSu0mNLwADFZuwyqSqJOrCXsYm3GIPCwkt3e5o5KYxBB0wQyrCBNjTE/TVSPUAPX6VtsC1LJdb13Iy0IKIRoJlzAK0ovzcCrRBaQ81LOAV7ETRwkb0dGopYSL9kuqZSeeFqVvEBP5mhcBKCFs8h7JDBpN4Qyf7Y1FpjiNMhmuqLqAd6lRh3RqCcIjd7JBux8zic3KJxTrr9JLOYdEMRJVdC62vkT/iFL9IwAa5WbWancQQy5xoj9uWUSSGE1vdSYClQ3a/SwNXc1o9ek2LQOdoSv3hCb9lGqfUscKEigkSRlDkhiFIlonxpJSskK7AZ0gCRTiowyBiaGmuyNtbCKVWrmMODkAs3Aw1HQXQeliu/YiCWI4MaIXXnYQxIWZBGr0JThEPiliPAmikCbKCEoXVpFEtnrWQfW/K+OQqh7P2aHT8ONFa3Y4bSlUd7TSliLSkZLR1WfEj4Hwy856EsQQVGFDk74jLdJPlmNGoaitrSU2NpYTYl7CzXaK9FcQqLhkODnTcPV+zDgjk8dI9RHK5BeU6O9RJb9Fk15q5TJspOOjAhNxjDQ9fCS7dNjozpp+UDZgIg67yGKsaS5eWYJOkAr9K2rlUqwkM0T9I02U49LXUSo/oFZbQi/lXCwinFyqNPQkFmxYiKGaXUC40FcRy8ljdORaVmK4gTcoZgUf8BAQjtKIJxVdPQmTOPDacC/1HBLlKDZo99FECcu03zDWNLfDY/yymg3a/QAUqrdjEgcfhpkpTqOUjyKf+yizSFVOiGqjyQCNcjNOMZx6uToSkXIoCcpGNmgPEqCaBDGUbHEWfqraVCYAGuRGdAKMUZ8LK5PaP/BThZQy6n4K5x3xYmoOVTaLBNKUKezR38Mh86hhCSCIF4MIUEOKmIBTCRePiiEbRM9lmewMAiUqrPpYpEXJ+Kkvo4SkNxKB1oKKHUcbS98Gh4cuKxTFxcVcccUVVFRUoKoqixcvZv369cyZMwe/389ll13GnXfeCcBXX33FLbfcwsyZM/nDH8IZFYUQ3HbbbfzlL38B4Oabb6awsJDZs2d3eF1VVbFYLAghiKMfBepv0WQTdXIlZpLZpj2Ph2KSxHE4RSFJYgxZymlkiFMIUk8IN5lMxyXXE5AuPNLIztYZVmm3tNpmIp40MZEUcQLVciFVciEq1ojzXI1cQo22hHQxjWzlTBRUKimmkDwu5WHsOGiklq95gQ95mJncRzp5bOB/zOM5BnIil/EY/+GPbGUxY9RnMXVh3TyGnMjf2UrHb75SSoK4gXCOg+4oExC2Co01zWWH9m+q5AJ26K9RpX9LkjIWnyzDJytQhI0EMYgM5RT6cfUhc+KUUrJNm0sDmyOVXBWsJIsxhGgkRuS0OqZOX029XIVPVpIrZrJBux+LSKSv+gvsIqtV+0Qxkhq5jDQmR/qRKEZhUZNw6euwyQwUrAxQrqc7/g89wY+tcNrhTjF/tGESMYw1zY0oufX6Wrbqz5ClnIVLX3/A47s7lxm0psu/7tmzZ3PvvfeyYcMG/ve//2G1Wrn22mv5z3/+w+bNm/nkk09Yuzbs1Pf888+zcOFCVq5cidsdfmg7HA5ef/11Ghsbuy28KuykKMeToBSQrpxEb+US6uRyKvSvI299ilAp0z9ng3Y/W7SnwmvyYgQD1Bu6ff2fAqPUJ4gl7G+hYGWk+ggjTQ+RrZ5FjnIeo9S/EZIekAoWkmminCTGMkS9jWQxjpD00CgE6eRjJw6dEN/wMntYz8+5h2Gcyhv8iRe4lY1KBbH0ZhPf8Sq/J4gfoMuTkBCCMeozpImplOgfhuVrh7XanWzUHiBNTCZdnHzwA7UffdRLGGuay1jTXPLVX2InC6cYxgD1twxQryVdOYk40XEyKE36aNK7nvUvKBvZEHqAZdpvqGc1NtLJV35FgXIjw9S/YMZJgjIkKl+ET1axNHQ12/S/kyzGkaxMYJd8g3TlJPqrv2lTmYCwT45TFFIr9yYWF0LgEH3JVs9iqOluhpj+iBDiiCkTx4ecPzplooUfU79c+nq2ac+zLnQvAVnX6eNCNLBVe5YKOR+nGMZG/YFOHdfduaynWbBgAWeddRZZWVkIIXjvvfci+4LBILfeeitDhw4lNjaWrKwsLrvsMkpLo+u91NbWcumllxIfH4/T6eTKK69sJe+aNWuYOHEiNpuNnJwcHnrooR7rQ5csFOvXr8dsNjNxYjhCIikpidLSUkKhEMOGhc2YM2fO5KOPPmLo0KHouo4QAlVVI+v4VquVSy+9lGeffZZbb721xzqSrIwFIE2ZFLV9eegGBAqD1FtxiL4HdW5dhnDL7dhFBmbRcajqocRbd3hXqHQZCvunAIPVP7XKYNnyNp+jnosugzTqW0hjMhnKNAQKK/WbSBUT0QnSJLLZJupZr/8dP16aRDoL5eXYyaJQuQcQuNmGXWShYqdBbiKewWi0HeZ7oLEQQiVX+TkBvYaV2k2MUB/B3EZ6b7vIQkqN3urFBzFCncMqUrqc3Apgs/YEXnYxRnmm3Tb7j0NA1rFaC1fkjaVvOExT9Insl1ISoPXDerP2GKniRPqovwDALMuxk02KMr5DGb1yD35ZRaIY3tluHRLaux9+TBNuZzjcz4iuUqevxiXXo9GEhg8bqeQo51Mjl1Ksv4KCmWQxvs2kfS1IqeOS63DJjTRRioVEEsRgLCQTxEUyE9gu/96hHD0xl/U0Ho+H4cOHc8UVV3DeeedF7fN6vaxYsYI77riD4cOHU1dXxw033MDZZ5/NsmV7lflLL72UsrIy5s2bRzAYZM6cOVx11VX8+9/htPINDQ2ceuqpTJs2jblz57J27VquuOIKnE4nV111Fd2lS3ff1q1bcTgcnHXWWZSUlHDBBRdw6qmnkp29dx00Ozub//3vfwDMmTOHCRMmcNFFFxEXFxdpc8MNNzB+/HhuuKH7VoKQ9BKisc3EOQCp4gQq5Nds1MJx94PUWxEonUqHHNBdbNIfxU/lfnvC6WPzlauwiXRiDtM68OH23t6j/x8pTKS3ctEBnQYVYSZfvTJq22D1jyjSzgb9fhCSAuVG2Cf/Rro8mdXan9gpX8cvq8lUTidLOQMzCQhM1Okr8MrdbV6vM2MhhEJ/9Rr2aB+wSruZGHJpYg+JYgxpyiSCsoGQ9NBf/c2BB+MIMEC9jjp9bavtmvRRqn9OpjKNqqLoJZomvSLyt4diArIG9lEohBAEZG0kc2oLJhw4xTCkDOeJNMs4/FQT0BqwqHsdF5tkKUHZQEDWExQunGI4icrIHuz1wfFTjWyA6KWPo3UcgtJNif4BAkGmcioqdir0ryiVn+DVS7ASVritpNFHvRRNNqFJPwFqwn5cIg4rYcf6Mv0zLMJJrnIhNjJaWb46E+XR3bmsoaF7KcLb4vTTT+f0009vc19CQgLz5s2L2vb0009z3HHHsWvXLnJzc9m4cSOfffYZS5cuZcyYsPP6U089xYwZM3jkkUfIysri9ddfJxAI8NJLL2GxWBgyZAirVq3iscceO/wKRSgU4ttvv2XVqlWkpaVx2mmnYTa3H4s/Y8YMZsyY0Wp7amoqZ555Ji+99FLXJd6PADWs1/7KCPVhzGKv0qLJJlZovwMghl542YOVNDZqD5KtnN2hQiGlZIf+L6rlQgCylZ/hk+XUyRXoBAlnq4ynSP8HEo1Y8jALB0HpxkQsu/V3COFlmPoXFGFCSo0gjViEs1t9PZxJa8L+KasZpv7loNb4pdRp1LeSopxAqjieCvlVqzaqsDHK9Fh47VOG38KLtJfpo87CLjJwyyIq+AqrlkGqGv2m3JWx6KWeTZIcRVC68ckydsk3qdXCWTxj6dOmL8HRgEnEtuo3QKX8hnL5Kb04u9U42EVGS6AMcaKAJGWv06tX7saMEytprR7CeeocyvUvKdU/wcMO0pmOwMJqeQumkINY0YcmWUqAWhLFKJpkOT5Zyh7ePaj04j3NsZbQqadpUSqOxDi0+DCEpAeXXI+Z+CirXL2+hjL9M7KVs4lXBkaOy1LOxCJTcMttgKSXcg7V+iI2hR6lka0IFNLESVhEIh59B265nSzlDAapt2ASMd2Suafmss6wv/JhtVqxWruv+LlcLoQQOJ1OABYtWoTT6YwoEwDTpk1DURSWLFnCueeey6JFi5g0aRIWy15n7OnTp/Pggw9SV1dHYmLi/pfpEl1SKLKzsxkzZgw5OeEH8IwZM/B6vZSUlETalJSUkJXV9nrrvtx8881MmzatXY1sf5YtW4bD4aD36PB6eNCnULreTr/CFGLWzyU1z09MYvRaeUrdA+zYVsKAodnsWaeQOqQSq91Mhf4lDrEAC/GUlpRRWruZrOwM1OLT6TfGRIPcgpABxombqJQL2L79W5KZQGHsnbiqA/QdZkMlHEYYkLWYhZPSdTFYkmqp9+6hUi6gV342Nj5HEWaaZAkWdGqXj2JAv4G4Sq3EJIVwZgaj5G3pU8tDIdynaNNfS5x5S5usIU2YbdFRAvVlZry1JpxZQaqKrJEx25eWNxmzXcdbayJrSPTSQpBGNq7xY07ehsmXiSJspOb5W51n5/JYUvP81Jeao/qko5EiM7D4Nbat2cO4oWeib6TNPiXX5VG8JZ74IWuI3XAh+YUJ+K1rQDYwTFxJvVxDsKyJmPrJkT6ZbXqrfnXcp0QgkdL1AxiQdAIebwNNcjf5/foh9ivX3V6fuvI9eetMPfo9qbYAZdWbiStcwwgxhbHiONTmsGizTScmKUSwSSEGB2P7hJf/cpQLUPAQwMVHSx4gr18uVSUOhqVegTNz77VCePE2+Vi35nuGDx2DZeP/IyWvCVviJMr0L5pTIFvx1+VStj1En0Irq9dWcsqwm4ixx2HCGhnDnrj3AErX2yN9Ag5473nq1FbXCvoUWO3EPNRFcG0Cpn5u1MTo71KrMxPa5oi0MQ91oez3PYVKbei1FtTsJkLbHFjHtl4yCm4PW4qEXUOvtWApbP0GG1gXj5IUQDaFk3WZ81uPjX9pIqZ+brQSO0pSAFNWdAik7lMicu7fp96KNzJWh+IZkTaklnq5Gj1S6AvWrV1PclIK/iYdN9so7DcJn9wYqW8TK3JZ+sM79OvXj8SyvjiSA5Hfk1vuIAYXdv9EytbFIwa/R9laDyP6nUZW8hUAKIQnPm/diZRvl+QUygP3KT0A21t1J4qemsvE0iSEve1pVDSFgKLINVq46667uPvuuzsW8AD4fD5uvfVWLr744kjSrPLyctLSovPumEwmkpKSKC8vj7Tp2zd66T89PT2y77AqFGPHjqWyspK6ujoSEhJYsGABv/71r/nwww9Zs2YNQ4YM4Y033uCFF1444LlycnI44YQTeOeddxgxYsQB248ZM4b4+Hh2Ll8Ztb1FGw/f/K21vgTFScV6MAuo3xCPX1azXluPgyaSlbEU6R8AULNtE2PUC1m7dAtb9X+iYiXIUnpxHvmmsCnf2wBmYM/yfa+w1+QcKkvFQiq9GIlcISmXa9mqz4VIWOBSdmxxUKjcTtDnxFXadshee33KGtIU+ZG3tOnobaSlbYfVB5ufjfu3kdKOrtnYUhKO4OitXszO5W3fLi3XcZVa9utTISHpQaBSvM5DjhJo93tKZARb1m7Gz/1sWA12skhSRiPFGFZo/0JnKf2VFIJF4ayaLZN6V/rUQljGFMyksGt5m0066NNeDnTv7dvmYL6ncu0rdsu3iGcQDc25OCxLkyhUL4ykH84a0kTQp0TJWF8zlq36s2wSDdjJpEmWkKtchLI9iUb5f636tC70KE2UUiB+R9XaIlKUeqqLnGwN/ZN6VqFgQSLor/yabKU/TRvc9FEHU7+hL/Vd7FMUnfqeWtp0fO/FJmptnqfUVM/xa50AhLY52l2ZD65NiPq/LULbwj44+1a5bY/22mgle+8Df23b91XLdbQSe1T7tuRt6VN4ySP2kDwjZK1OuZzHhh+K6KX8LMpBN5/ToXmVLR1oWhEONffKUoRQ8JPEKHUS6g4rGlBRUsW2PVuol2uwkUYv5Vw8hFin/YGUdccTJ/LwFg9g947W46cKKG0O3uioTzU72h7XfenJuexA7N69OypTZnetE8FgkAsvvBApJc8991x3xetRuqRQmEwm7rvvPiZNmoSUklNPPZUzzzyTlJQULr74Ynw+H7NmzWLo0M4V1rn11lv55z//eVCCt4VfVuOXNcQr7Zc3t4oURpn2ltk24WCL/jSpYiLrtHuIFwPR8UXC7BL2S9LUWYQQOMUwxoinWK89SFNz/gUNN8X6a+SLK7tstttfIz+UCKEwzBQO7V0VugWpaeFEQCKHWNEHO9kHXAqp1ZYTK3pToP6WOn01JfrH5Kjnttm2j+kSGuQWNOklVvSNqg8xQn2AnfqbbNWfYQh3EKNkH9axOFKUyy8BaGAjQ9TbWK/9lTgxgJXaHxilPoYiLG2Og1MZxijxZDg0Wij49SpK9PfRCBAvCqjSvydVOT7SPkUcT5X8nhL5IW62kcrxaDJAiEZi6Uuc6Ee9XEesyKVRbiGke0HhoJ2cDwUd3Q8t/gVHm4NmeyGfXZVz3/P09O/Cpa+nXM4jTgykn9K5EGeziCdBtE4YFpIeNmj3k6WcQW/l4r1LwNJEghhCrVzOSFPPRRx0RE/PZR0RHx/fY6m3W5SJnTt38vXXX0edNyMjg8rKaH+/UChEbW0tGRkZkTYVFRVRbVo+t7TpDl12CW7LcWT8+PGsX3/guF+A6urqyN8FBQVoWs/lSFWJwS1/wCqTO1zT9ckq3HI71XIRjXJzZHu+cjUClVq5AisZ5CmXYVPaTkncWYRQGaj+lpXa3vLIDaxnjfYnMsWZpIjxmJWjO9FOqjgRu8gmVvTGI3dQrS+miRIyxXQcIr/dmha75FsEZT1DuIN4MSjik9Ie8WJAm5mVVWEnRmRTI2GH/hqDRM9FBx3N9FZmskN/gxB17NTeIE+5kiL9H2QpZ7abkKoFVViIFwNZE7odP9VkiRmUyk/IYDqb9IeaQ0YlTbKEcjkPMwlkKtOxiVlYRALl2pc4RD7xogC3LCJVOREvpcSJAhSTifLQl2jC1+kMokcDR5Ni0VH+iO9N9Z2W8VDlodBlkFL9YzSayFd+3amkcgeiSH+J/upviBP999sTTo4WogFdBg54b/cU3Z3LDjctysTWrVuZP38+ycnRmZ4nTJhAfX09y5cvZ/TosO/U119/ja7rjBs3LtLmtttuIxgMRnxG5s2bR0FBQbeXO+AYypTZGUwihiy1bceZcOXD7WzRnyTitQYkMoosdQYxohea9NEotzFCfahHkw2ZhIMx6jPUa5vYxlNhefCxR77NHvk2I8SDRzQc9UBkq2dH/raKFJIYQ0h6qNC/pkJ+TZMsJVWZhIIFC04SxBAUYUYlliD1NOmV7BZvkakcnFMTQIZyClaZxjb5HMu035Asr0bK4Ye1sufhpFFuo0h/CUF4vd3NduJkf8wk4pbb8MidnYpUihV5pMmT2S3fBMxskuE3wF3am/ioIEOcQr7yK2JFn0gkjy41dst3iWcgOep5JBAudheSHqr1xYBOjMjFLYsISTeSECn7WDyORqTUcFMMwFdqDCdrB2d5PFo4VIqEJv1Uy++p0X/AQT+ylfMwie47EAZkHWacbSgT0CA3YMJBX+VyBOFJbqf2JunKSe3WmPkx4na72bZtW+RzcXExq1atIikpiczMTC644AJWrFjBRx99hKZpEb+IpKQkLBYLgwYN4rTTTuNXv/oVc+fOJRgMct111zFz5syIL8gll1zCPffcw5VXXsmtt97KunXreOKJJ3j88cd7pA8/KoVif6SUePUSvOxgh/xXZHsf5TJ8eiVuikhXTiJG9ALCUQdOUXhIZBFCJdE0hPTQqVTwBSYSCTUvIqvHYCpgk4iN1F+o1ZdHnKdq5TI0fKSI8eQq57FVfw6/UkaeuDIqCudgSFSHUyjvZJ12Ly65gWXaXOLFQArUG7vbnaOGem0dHooolZ8AkMoUqvgGgDL5GQ7y6atczjbtBbKUGfSm42WHgGygljebP4WtgWaS8FFBH3EZTZTgZQ9l+uf4ZBl+qokhF9Cwk8XO0FtkKadjVhyE8CKEIEmMjfhwQNiL3yerjpqHvy41/FQQkHVIdAQKOkEcIh+BCT9VfKGuZLJWgJW9y44+3DTRQCIHdio/1LRnpTjUmTGr5AJ26+9gwoGHYuykY9GTcIg8VGGLhHF3NTJKYG6OkNuLLkNUyv/hkusw4YgqdKgToEh7CQ/FFKp3tptY7cfEsmXLmDp1auTz738fTit++eWXc/fdd/PBB2F/v/19DufPn8+UKVMAeP3117nuuus4+eSTURSF888/nyeffDLSNiEhgS+++IJrr72W0aNHk5KSwp133tkjIaPwI1Uo/LKaPdr71LIUgCxxFoXqndjIpImSsAJxhDIAO5XBVOhfEKKOWPLwUMRy7VosJDFM/WuHb9z1ZUdnuex9QxOlruOWxWiyCSsZSEJkitN6LEtiS82I3aVhN+4GuYkt2lPkKBdgF5k9co0jyVb5NAD54ipUYaNU/xQ72c3/sijhPSwikT7qJazX/kJG6d3s6xis60F26f+Hn0pCuCM5VFRicNAXnRCpyons1t+mSL5IijgeO1n0U36NQKWRrVhkIhbhRCeErgeplcuwaInoIkCiGB6lTEDYZ6NGX4ZPluNUur/mfDDUlGoUa6+RKEYgULGJNBwiv80lGVVm0yA38bnyLQ1yAwliCAIzhXoiNeymABsOktq4Ssccqsm+K+etLzMTkh78VBOSHqwiJSoj6oHIUE4hXZzEMu1aAHbo/6KXch6l2idkKCezTQ8njDpQfZz9MQsHGp5IiGlL1VuQ5ClzMBHtFNpXnQWElcOeKiF/tDNlypQOk2Z1JqFWUlJSJIlVewwbNoxvv/22y/J1hmNaofDJSiwkEsSFhWRcci2N+nbK+ZxYepMqJtNLOSdq/S+GXkdQ4nBuABU7Gk3kiPPYKd+kid0EqGW19ieGqH9q903eW3v0f10mHJTLzyjXPmOAciNpYgqNcgvxYuABj+0M4Ux648iu/zlZJgdNspwS/QOKtJcZYvpTj1zjSGIilhAezEoCDvLwKrux4GSX/ja1/ECCKERKSYzoRbqYxrLqB4nRhpGnhkvPl8iPqOMHkjkBPxX0Vmc2JwoTWMTeNdJkZSyV2jekqVOirh/PXj8WBTOoduwyCzPx4RwX7eCjnDgxoMfHo7PU1dajYCJG9IrqZ1sIoZIgwss4SXIMgnBa8FIFoA/f6ZsYp+ce0FLR0wrE/kW/unp+XQbZWvU5MQzBSioxohc+KqjX16DhJ0mM6dQSoRAqo9Qn8VOJSgxWkYSdTLbqz5AiJuCnFl0G2/Wdag8raXjZTSy5LNN+g1MMJ12chLkNB84WFKG22lanr2KbPpfBym3EKkdnDpmfKkf/DNWMlBJVVTHrqUg0VOw0ETa/pYkp5CjnYxUpJKhDyRFtRxIcDQghGKk+xhbtKWpZSaHpNnaH3qOczwhSR71cRaqY2OaxLTHjRzNxSj5OOYygdKMTpEYuwUQs8fSMQqEKO3nqHFKy/ZRt96LhpVFuQaKhS63NB9Cxgi5DhJrzORRr/0TFho9y8pRfEaIRO72IIRc/1ZGUxZ7sBnZs2xMuBKb/nXq5ilHKUzSwgVh6dRiJYRHJhGTTAR3u3HoRsSI3nHUTEKiYhRMFMxYScbMdi0xCw0O9XEcQV6sKqweDT1YgUNEJYCMd0c53G5RuTJlbyCm+oMuTXFv3S7wykMVswC6CWERC1NJDd5QIXYaok6tQsaBgJVb0Qe0B/4QWBCq9emURKN5bbdNOFnaRRUC6aJSbO63Yq8IS9fIVTruvYCcHPzW06T19AJKV46jTV+EVe0gTU+mtXtTlcwAkKiMYzJ8I4oLmQoB+WU2x9k9iRR4B6Tqo8xp0HyEPVWLyHqKhoYGEhARcLhcLFizgt2f/HzbScKhHT8had9FliDXa7QSbo/qzxc+IVwpwiGO3DO9m7W80yE0ADFcf6HaW0H3RpJ89+nsRs66HcOXYrpphj0ZK9I/QpJckZSyx9EEIgSYDbNQeoIlwIaAUjsfDLpxiGGXyExzkI9HxNDsd9lYuwa/XkGNqX7EOyDpq9eWE8JKqnIhVtG/ib9SKkSJEvBJ2qNNkAD+V6ATQZBMCU1Sodr2+Fh0/ScqY9k7ZIX5Zi0cWYxPpSHRUrPhkJQHqsZGGIiyEZCMSiSrsWHDilzX4KCddmXrgC3SSGn1J87q/wCbS0KQPu8jucKw06cPLbiwkYyEhSgmq0ZeRKIajCDO6DOBmB5r0kqiM6BF56/SVxIvB7SoptfpKnGLIQUVR7NBeJ1GMpEz/lARlKFZSSepCynW/XkO5/jU1fE+GcgoZYnqPKv/haUzikuuo0VdQy2JcLlePhWvuT8u8VPP3McS3k9iqoSlE8q+XHVI5jjaOGQsFwJlnnsm9asmBGx5jCJSIMgFQIt+nRAMb6QxRb4s8AHqP9nScKOgookC9ESn1sPm+i86YLn0DZfIzFMwEpIsQbiw4UbCiCDMSnYljT6doucpWLaxEWEjCpW3GpnQcMny0k62c2WpbizLhIJ9kMR6P3EEMWThEH04eO4slPyxioPp7GuUWvOwhRvbFT01kvXpfdBmiRP+QRGUE6cpJANTIH3BJHxKdJDE6KuJIl0GCojbKCS/q7bWNF1WnMhSfrKROX41AEKIJCwnEijzUDiazBn0TQdwEqCVTOTVqn02kN1egVJBoOJTwC0VIummigsFjk9mzrGeXXJLEWIRQ0GUAnRAmJQaXvpEAdTjIQ8cf8dFwyx0EpQsVa9giQD2NcismGbb+qMKOjg8NLwoJKMJCPAPwsJP6SL2W8GBKQqjY28yn45V7mp1NNQQmzNJJjJJFo9wKCPLGhNi5vG2FwimGUC/XkiRGt7m/IzxyB7niQirFNySLsezS3yaJzisUVfp3VPIVg5U/EqscODqpq4Tv83DunzjRn1ptcY9fw+DAHFMKxY8VIRTGmuZSpS9ih7430ZePCpZrv2WAcj0ATdKKS2+dgvhQEKCeGNGrU6GJ7SGEgpnOKxNuWcwm7REkWrhQFRINLxKJhx0AjFGeRQgFkyhno3Y3fZRZVOjzaWIPW+TjoMEo9W/HVH6EAzFEvR1N+vCJSgJ6DQ1sIEgjNfpScriYAvUGFGEmQQwhXg6mkW2YpINauQIL8VGheoow4VQKCelepACPKMIphiKlxEMx9fo6pNCxEFYq3LKILOWsLr9N2kRalDOgJn3s0d8lRzm33TfkAC6SxXFI2k7O1JZvhEk4iMOBCU+7SyIHS4sjsSIskSimBGUQTbIcl1xLg74VC8lYlQSsIpVEZW/FVTPxUdV5Q7KJGNG7lUIVK3q3qZT5ZBX1+hrC3uMtRmSBVaREHF/d+k6CuHDJOuJE/+Z7vnUK7RYUYcFKKrX6SlpCfzsTmRN++1fQRQAhTezS/0udXEm1PvSA1WgBGvWteNjNGPW5H22Yt0EYQ6E4ikhVJpAixlGmf06J/IiWMD8FG3FKPnbhIUE5fBYKtyymXl+DjobSnA9BwQpIdILEitweyZ+xMnQLIcK1D+JEAWliInv097GKZALUMki9hRhyCckmYF8P8XCWxyR1FBp+vHIPW/WnWan9njGmZ7st19GCEAortXAIWaqYiIk4cpWZJCrDSRIeGvfxGxBCEC/6E6/0R0qNOrm61YRlIZF61lMnl+MQ+TRRToO+hTRlIkHFhV9WoxP2rldlDB65AwuJ4VBCuQOv3IVFJGISccTRv1OThIIFs0hoV5mQUgfCJaJbcm8crVhJook9pKrHhyvW4kXB2qZFqIWuJoayidQOJ/uW0NhEZRRB6tEJROoLdUSsyCVW5CKlpFp+j5VkJBK33IqGD7vIilIEpZSUyU9xikI0/NTJFeQqF5GtnEWTrOjgSmFCMlxLZoB6raFM/AQwFIqjDCEUMpXTqNK+w0QsXnYR1BuPSJirQ/SNTEbhB75Ax49AQWDGww48+k5UEYODvIMKDZVSEi/6UyuXkyFOJU70I45BBBU3u/Q3gHDkiCJMrNb+QH/lt9hJI0FkEEd/turP4pLRJb4leqvy3Mc6/ZXraJSbKZfhEsYJouPETFJqVOrfomCmSl+IT6/CJtIQQiUkG3Aqw7CJcFGgJn0PFhLwshMzzsibtlfuQUfHSgohGvHJCmJEr+YQQD8SLRyGTS/q9FXEit5RVgQpJT7KqNYXUS7n0U+5ul15hVBw0I86fRUWkUgMubjZTkDWYRGJ2Ejvdh6T7uKWRVhJCy/BiRTsIhO7yESXIZoopU6uJEmMOiyyCBRU7DTKLZhELDr1ePU9QOcsikIIkhhFvVyLQCFODKCJkqjCXwCl8mMEgizlTALUIVAIyHpsIhO70n4UTEuCrFjRl+SD9KUxOPYwFIqjECEECia87KK3uIQkdcSRFikyOe/7FuQgrHCEpJsq+R3xDOp0cqOgdLNauyVi3s4RPyddmYqfKoLUky6mYBdZbNGeYK12JwBJjGOrHk7Scr54hIGmMwAo0T6iSZaTrk5mm/YCaWLij0qZAHAqhTgppJc8l/XaX6jQvyZTnd5u+136W6QqJyLR0fHjphiNeBwijwBm6vS12EUlOiHq9bWkionEKX2RUtKkVxCUjYREI8mm8ARpISGiXJqJo1ZfiYkYKuQ3SKlRwyIA+orZOEQ+a/U7iBcDsZAcSbl+oNofNpGKlWQ2ao8QpIEkMQqrSKVG/wGdAHnq7O4P5EHilSUomPFTjSSIg/zIPkWYiCUXiYZfVh8WHx4hBAkMxiU34JNVqFgJ0YjspEIBYb+ORBFWHqWUBGQ9ScpehcilbyAo6+mtXIoQAr+sRqJTLj/HIfMix+6LJn1UyG9IEIMIShcOpU+3+2pw7GAoFEcpvZRz2an/h+R91iiP1pBRk3CQykTq5EoCsoZ4pePQtM2hJ2lgA05GkK9cST3rmt+eFVRpp0ZfRgg3brYj2VvrpZYlkb8rt+81n2arex0ZD1dxoSOFEAoDlT+wUv8dcbKAqqK286pki7Op0L4iQR2KJpvoo16CEAqa9LFRfwCAGNmXBFFAljKDIC5qtZV45A4SxWg8FJEqTmxXDl1qNLIVl1xHjnI+DpnHbvkWxfIV8kS4Om9ANtBAONKnUL3zgMtjLn0DW/QnSRETyOOXCAS1/IBLrsVGeqSdlJIANfiaTe5xYsAh+23oUsNHOY1yK+nKlA7bBqUL62HIFhqSHtyymBCNJIkxUaGy1UXt1VNtG0360PDjkTvCtXSaqdGXUiuXkqdcgRCCkO6nTl9DkhhLupiGTUTXkajQ51OtL6KJchLEQLKU04hVe9750uDoxlAojlI0/OQo53XoFX80EU7JPKq5Yqi/zdA1TTbhkpsI4SZDTCdeDKCBTcSJfMwinj3aB1TL76MiXlqIFwOxkkKCKCRRGYEiuvbg/DHRMray3WLchGupKDaspOBlF35qsJGKThAT8eQo51Gsv4JX7kIiSVJGo2JFJ4BJxJIhplGhz0dgIl2d3Or8SWIUy/VrSOFEkpWxAMTJ/mzVnqVWLsVOFjT7QsSSR1A2Yu9gCT0kvWzRn2SYch9WJYk9oQ8o4xOQUKD8DtM+zr01cjGxog/xYjASjUa5GV0HRQ7och6KjmiSZVTr35OqTCJO9Dtg+3gxqNnHJIREIgkSK/ocMNFWZ3DpG5q/bwWBCGf37KZPgpQ61XIRDpGHTaRiEo5mn4lPCMoG8pVfR5xxBRCigaCsp4r/kSXOJCjLqdC+xstOPOykl3IeGeIUw1fiJ4yhUByluOQ6UkV0ciCzXae5/MdRSyw5eNlFHOHIAq8sISjrgbCSlChGkGSKDjcLSBdLQ+H19WQxgd7KTHbpb9AgN2MXmfRSzo3UWwHYoj3DSNulgPNwdOmwE5QuKvRv8FGJtTkFtE2koxNExY4ug2SIU4gT/TDbA5F7okFuwSt3YSMdh8ijUS+ihhVkKCexW3+bJDGGJDGGeAbRIDcyVPyFtfIOPLIYXfPT2zQTqYUnaJtyPBnqyZSEPqVGX4JKLAKBThCBikfuxskI+pp+EZHbLjLC4cIEI/4ZAH5ZQ6X+P6pC35GsHEe8GNhq4lexEUd/tusvMli5hUx1OgG9FptIbxU+Gc7aGU6zLgiXvo6P8VFctxKzjEeiRXJUxIl8Dha7yMQh8ju9jKcKK/Fir6xS6jTIjYRwd7n2xb6ELTL1JIjBB8zn0pVnhBAKJhmHQMUustBlkBL9IxRM5CozoxSDgKhDiiB9lcsJ4KJE/4AaGQ7NdFDAGPXZH90yo0HXMRSKoxSv3INDiU5sdSyk3nbLYmJFHwCCsqFTpuIi7UUGKL8lQdnraNhHuWxv3ZX9GKBeS6Cu7dDCHwMbtYeJEwX0Vi4ihAeJjl9WIVAI4Q3n9iCBen0N7mqdUMiMqtgp1T8lTTkRl1xHlfyONGUy8aKA7fo/QMIu+SYW1Um+aQ7V+iLqWM5Y9Tm2hZ6nkm+oDH1DOtNRMFEWmodNScWixJEghkVFKQSlm536GxSoN7SSva2kT1aRTI56Hg36Vsr0j6kVy0kSo9Hwo2JBoBInBpCtnkO5Pi+cFVdY6aNcyhb9adxaEf2UX0eqobbgk5X4ZCUJYjBNdRaSxFgkWqSdX9ZSrX/fqhKqLkM0yI3sdTJW94ksEQgEEg0bGXjlbhIZcVDfoxAKCWII9foaAtLVXJNibxSLWSS0m85cl0EkIQK48MrdYX+UTiSH6+wzwi2LqdQWUssPSAI4xXB0/KSIE1ql6HbrO9ioP4CVNPyyBpNwEKIREwk46E++MttQJgwAQ6E4aokRvSKZAVvIGtJ0VCe20mUQDzvRZThe3SQcpInW5vIWpJS49PU0spVGfStjlb2ZLoUQHdZdOdrHojtIICDrcctiBApOZSgxIrvNtr2Heli3pJoa+T0QIkkZTRJ7Exc1yVLq5ArSOIn+ygz26O/gZBhpyhRK9A/ZpD2OIiyMVp7BrW2nmDdwMghVWAlJX9iHReiRZSyXvhF/cwpu0z5Vcv2ymkr9f83ZPBVCsoF05RQSxbBIqGi80p84cQObtMeJETnhZQwRzjVSoX1DvDKQGHqxS/svueqFKMLMQPV3LA/dyBrtDhLEYNKUSQA06JsJES5+VS6/ZOyQMexZnoTY55FmFUl4pJWAdGFp9t9w6zupkYtIEScQI7LxUdnmpB6QddToS4lnUHe+SiBcPK0FKfXmpQuBn5rmpFYSiY5JONCkF1BQMCGEGTPxkSWlztDR78ItizERg0fuwitLaKKEQerNxIpcQtKDSbR9XIX8KvJ3g9xMvb6aAvWGDmtwGPw0MRSKoxQFCz5Z3qVKgUcaRZjJYBoCU4frqC5tI1vkE5HPVlJRjFsxQq5yAU2U4hRDqZILOsxvUCkXUCq2Ei8GkqO0TrVdoy/DTBJB6nAovSmQv6NSfsMm7TEUTPRVZ1Oiv88m7SEyldPJF7Oo01egShuqYiWg+6nSv8cl16MTQEElVvQnQE0kN0aCKESgkqmcTi/OQwgR8T+olgtRMCNQw/VWCBAjcmiilCZZjlWmUidXYyONIHXEiF64ZREV8ivSmBTOKCkK8MidVMuFOGQ+irSiCkskIsFKMn5ZQp2+s5XPQqIYSa1cjpQhhFSb80VAo9hEkyyJJJ8Kh0VDg9yITgiziCND6Xl/ACEURHOSLDsZEWVGSh0NLybF0dHhBySEh2Lt/3CKQhKbU2PrMki9XItVpOCTlTjIp1zOo0C9IaJEtKdMAKSLk6mVS/FTSbZyFr3E2d2S0eDHi/EUP0oJ0sARq7HeDTpyitNlkD36e7hlEQKVvsrlJIqRPepIdzg41DkuAtRiJZUQXqyktjupletf0g8bA5TrqZbfs0d/H7OII0uZsY+sklQxodnEH7b8pIupJDGGEvkh27TnSFGOp0FuZps+lzQxmRq5jCxxOoliOGu4rTnlNVhJx09Fc5rnML2VSyJWg32xi0xy1POBFvO9bF5MUCIZLYWuotFEkhxNUNThVIYhpY5D7ccq7WZQIENMw0Ya9aymjzKLZDEWRYm+X0wilhiRTaISS42+hCTGRr4fIRSSxVg0GWCn/iYWEU+QRlTdhkmJwyyTqZOr0Akg0UkQg3okWVtXEUKJsvh0FSl1yuWX2GQ4k26l/BZFtzTX01HIEmegYKaCLZTpn5OtnNmhErEvjWyJJFSrlgs7jP4x+Glz7M1YPxHylNlUyQVHWowewyerWK5dT4X8Cg/F9FEuI1k57phTJnQZolYuA8IP8aDeSJNegS57JupESp1d+n+JEdnUyCURf5S2qNYXE89gSvWPKdU/xi+rSBCFUW0sIp4y+QWW/XwbzEocfdRLGKBez279/5AEGareSy/lHBTMlMhP8FEZSTmdwemkiykAqMQy1jSXsaa5bSoT+6MIM6qwoAhzVHrseKWAJr0cF6upk2up0r9jt/42JdoH5CoXkqFMA8I1NQCsIvWA94tTjKROrsYtiyLbQtLNHv0d0pUpxIpcEhmKlRRUrNTKpVhIIlk5jhRl/BFRJrqDlJKd2pts0Z9EEiJNTKFaLqRBbsTDTiwkUyn/h4ci/FSzW3+bfuqvopZhDoRAwSH64hB9CMjaQ9eZnzgLFizgrLPOIisrCyEE7733XtR+KSV33nknmZmZ2O12pk2bxtatW6Pa1NbWcumllxIfH4/T6eTKK6/E7XZHtVmzZg0TJ07EZrORk5PDQw/1XKi9oVAcpZhELCZiWRq6mvWh+5FSO/BBRzFrtTsifzvFCFKUcUdQmoNHESaSleMA8MidrNb/SJX+HQHpokHfjC4DBzhDx8jmug0V+nxMxNJemWiP3IWOH4mOQGW46T4GmK6Lqh8B4cm4n/Jr8pQ5kW1V+rfs0d6jXP+SDdpDSIJkKz/DJtJQhZ0h6h/R8bJOuxsf4VwP5XyKKsNvtBqeyBJBd7EqSeSqF5LLeSSLCaQqk2hkO6liYqSNTaTRSzmfJlmCX9ZQr6+hXl+DJn2tzhdeChmJlWTq9JXU6+sQmHCK4VhEIk4xApPiIEbNIlEZSbIyGj9VUQrIsYRExy23YSeLNDEVjSbSxTRGqA+QpcwgUYxAx0e9XItXLyFHuYDt2kud+v4Cso5NoUep11cTK/qwR38/UlDOoOfxeDwMHz6cZ555ps39Dz30EE8++SRz585lyZIlxMbGMn36dHy+vb+DSy+9lPXr1zNv3jw++ugjFixYwFVXXRXZ39DQwKmnnkrv3r1Zvnw5Dz/8MHfffTfPP/98j/ThmCpfHh8fz3Hmvx9pkQ4bugyyXAsXBhujPofFLgn6jk0dcHnoRnTCN/4o5QlUpXuJiMw2/agaC10G2KI9Qy/lnEglzIOlQv8al9yICQdW0shSTkOIcA0TiU61XEi5Po989Vc47b0I+hSklIRwN1dmTaSJUvyyBqtIxSfLKNfnkaWcQTxD2KY/h5c9pIgJVMgv6a9ch1PZa9mQUrJZ+xuNbMWMgyANqMQDEgU7QSpJE1PopZzb7LzpjlSCDR+vAYIQXswi2ozvlzVoePHplSjCQqNeTKo4AZu6N1FSpb6AOrmKZHEcySKseFbL73Hpm0hXJ+MgD4mGW25v9uuwkBwzIOp+kFLSIDcQoB4pNXQZwqokE8KNQ/RtjpwYhEtuJKg3ItHJMkVXOD1W0KSPXfp/CVCPsDUQajLjoZih6r2YZDw79dfwUUkT5YwxPUW1vogAdc2F2LSoEN8WVoVuIY4C3Gynv3otGk00ys1kKWccgR52DU02sUL73TFdvlwIwbvvvss555wDhO/nrKwsbrrpJm6++WYAXC4X6enpvPLKK8ycOZONGzcyePBgli5dypgx4XTnn332GTNmzGDPnj1kZWXx3HPPcdttt1FeXo7FErY+/r//9/9477332LRp00GOxl4MH4qjGEWYGab+hc1aON10TFIIV+mxkehqfwart7BOuxeg28oEHH1joQgL+eqVaLR+a+4qcaIAFTsmYtmqP0tIr6dJlqI0V1C1kcpQ9V6C1NOY8Dm7PEVIQphJwEwcTZRiIx2JpF5fR4zIIk2Zwnb9BQYo19NH/QUClTLtC5LEmChlAsIPs4Gm37FH+4Ay+QmJYiSqjMXNLhRUdOKolN9Qp60iXTmJSv1/2EUGDtEfKylUyW/RpQ8PO+mtXIKFvU6SFpGEW+7CQR9ilGzs9MItt2Jjr0KRpkwiRZ5AufycrfrTgEJA1hAn+kcSTAkU4kU4I2tA1qE5N+Atc0bCjN1swyYySRBDgPCSmwUnoKAIlUa5lSp9ITEiF5OIARGOHGmrZPjRjips5CoX0ii3QNJKdpfsIFVMwoITRbGQr/yKHdrreOVuAJLFeDZpj5Jl2utr45bFxNIbIZTmMvIN2EQaucrPMYt4dmpvdinaxGAvDQ0NUZ+tVitWa9eegcXFxZSXlzNt2rTItoSEBMaNG8eiRYuYOXMmixYtwul0RpQJgGnTpqEoCkuWLOHcc89l0aJFTJo0KaJMAEyfPp0HH3yQuro6EhO7l4TNUCiOcqwihXRlKjv1fxPjvfBIi3PQVOnf9+j5gk1Hj3WiBbOIx0z334hiRHYkTHQAv2WL/iQZYno4vA8vdpHJdv15dEIU+M9kgHp6u+dy6RuJE/0RCKpZhFWkRRI1KcJEjnJZu8f2Us8mTU5ip/Ym1XxHGlMRmIEQMQwlRzkfN9sZqP4eC0ns1t6jgYU0splC5Q526m+RKk5s5cAakLXEqOH+WZVEpOxLmf4FmcpeC4EiVLLEDDqDRSRiaYrFpc9HKhoeuZM40T8qJ8b+yalU7KTtlwG0Qd9MeWg+qrCRqk7o1LWPFhQsVMmFxDdZKFTvaDXmSWIcLrkOXQbxyXKCuCL7GuU2SrSPULEToJoALkaoD2EW8XhlCZtCj+KjglRO2P+yP3nqVvcmZG3br6fRHwSWkZMTndTsrrvu4u677+7SdcrLywFIT4+2JqWnp0f2lZeXk5YWHRVoMplISkqKatO3b99W52jZZygUPwHSlalsC/2dMv0LrHIkNjKPqfS2AVlHhfwSgCx+doSlObaokt8xVP0zHrkDjSb8spIGuYleynnYRCp2EcLbwfEhPIAgQB0SDa++C5sanlxz1QsOeH2LcJKpTkfogkr5DTbSGajcjLk5vNFJ2LlPSkkFnwOQJc5EFTGRyAmxj6uWT1ZhEq2jGWJoO89GZ/FQTKIyCoEgVUzs8PcRkk2R5FItJd4VbEAIk4jDJpJplNs6lW77aKGJMrxyNwOU3yDbiEDapf+HAHUs167HhIMECgnKBsr0L6iVy0lkFPWsQaOJfOUKVmm3oGKLWNyylbPaTDJncGB2794dteTRVevEsUSXXvPq6+sZM2YMI0aMoLCwkBdeeAGAH374gSFDhtCvXz/uvffeSPuvvvqK0aNH8/DDD0e2CSG4/fbbI59vvvlmXnnllW5248dPmjiJlPxGdmlvsVa7C5+sPNIidYqd2pus1v5IvvIrxqjPkW1q/226K6Tm+XvkPEcrDfomtmsvRuosJCtjSVVOJEc9n1RxfCQld0fjEGxO6KQIlTq5mgA1bU7mB8Ih+tBPvYqxpucYaro7okzsixCCMeqzjFGfIVs9kwr9G+z0QhIEwKdXU6evQsPbqupoiMaDkmtfkvPd4WqlIqVDZcIti6iXK/dRFgR+qnAqg3Eqw0hRx+BQ+hLQj/Ic9/sRI7IZqN6MNW91mw6XWZxBAsMYqTzCYOWP+Khms/YEFfJrgrio5CsCVKGgUqJ/QK5yESPUR5q/0+eOCd+JrtATc1lniY+Pj/p3MApFRkY4X0lFRUXU9oqKisi+jIwMKiuj54VQKERtbW1Um7bOse81ukOXFIq4uDgWLFjAqlWrWLJkCffddx81NTVce+21/Oc//2Hz5s188sknrF27FoDnn3+ehQsXsnLlykjoisPh4PXXX6exsbHbwv+UiFf7k66cRKIYhYM8tmnP45bFuPQNNMnSIy1eK1z6RjaGHsIl1zHWNJckZfRBWVVC0n3gRscQlfoCqvSFHbYp07+gTq4kRzk/Ejq5LzaRjoedB7yWWSTglzVIqZEuTiJH/Jxd+pts0Z5hq/YspfqnNMnyVsfpMki5Po8t2jNs017ALYs71TchwjkmNOmjXq7H2lyMrE5fiUuuI1EZQaxoXYHSIfIIyDo8cicH6yMejojpGCklPllJ/D65JoRQMBMfdZ9JKTHJeOq0NQcly5HCKpKwkkq1XNRqn6pYsYk0TIqDPfJ9PGyjiRJi6Q3oKJjJUX5OoXIXfdRLSVemoggTQij4KCMoG1pf8BimJ+ayw0nfvn3JyMjgq6/2yVra0MCSJUuYMCG8PDdhwgTq6+tZvnx5pM3XX3+NruuMGzcu0mbBggUEg8FIm3nz5lFQUNDt5Q7ookKhqioxMTEA+P1+pJR4PB5CoRDDhg1DVVVmzpzJRx99BICu6wghUFU18qCwWq1ceumlPPvss90W/qeGiVjS1In0VS8jlj406lsxSSfF2qtU6POp19e2+uF75E5c+nq8suSwyanJJrboT5CgDGOY6c8HfR5dBqmTq3tQsiNPkhgdcRRsC7+soVFuJVeZ2apKpU9WUasvxycr0GWwnTO0vl6NXNpc48JMvvpL+im//v/snXd4HMXZwH+ze3c63amcei+WLduSLXcbF4rpxvQaCL330EJI8pGEEEISQggQIJQkJISWBEICBEw3GGxsywX3Kqv3curXduf746yTTrqTTrJkW0a/5+HB2pudnZ2dnXn3nbcwXrkBK1ns017EIzv9zinX/4uBSCYoN5ChnE+V/j47tScp9byBXd+MU9b7ykopvXlB9I14pHfzpUEvRCWMaDGZTlmFihUdjUZ9gzdrZgAX6BhlBirhXsPCITBQpFWHrKFJrsciMvr0awQTaZTr/Y51UEZkj3TeowGHrKFZbqFY/zt2fYvfb9HKFN8WV6qyhGS67VOmK79hpvoYycqJGBRLn0Rm4SL1iAuzPRxr2XDT1tbGxo0b2bhxI+A1xNy4cSOlpaUIIbjzzjt56KGHePvtt9m8eTNXXHEFqampPk+QvLw8lixZwvXXX8+aNWv46quvuO2227j44otJTU0F4Lvf/S4mk4lrr72WrVu38o9//IMnnniCu+++e1juYdA2FHa7neOOO47du3fz29/+ltraWtLSuvc/09LS+PzzzwG4+uqrWbBgAd/5zneIjOxOP3zHHXcwf/587rijb3KhMQZGCIUM9Rx2ak9iVbLwyA7q9VXEifkYRCQdepmvrCosRCtT6JSV2PVN3jDJBxjlUUqJk1oEKirmPurqfdpLxIiZpCpLDug6ijD2ybg6Wlnose3/l/f/Kw32gOUa5TqSxOI+2hxdumiS60kWpwxK06MII+Gk0Cp3YRXj/AwVo0U+qghnn/5XJB7CSSVFORWJB7NIQhFGwoglV70FKXXK9H/vzz/xDU7qMRGHk3pa5U5fnZFiElJKosjDqmbQqBdiFsmkKCcCoEkXzXIrBiKIEP7J78wikVa5G01moWAa1Dg1Chs1+mckKcf7HXfJZtrkHhRMRIspqPs9ZXrSQTFxYp7vbyEEFiWNVrmDKDk54DmHI2aRRLpyDmtZi4PgW6LhIhWbkk+1/h4aDkzK6ArmNVwcyFrW23NjOCgsLOT447vHb9cif+WVV/LXv/6VH/zgB7S3t3PDDTdgt9s5+uijWbZsGWZz9/h85ZVXuO222zjxxBNRFIXzzz+fJ5980vd7dHQ0H374IbfeeiuzZ88mPj6en/70p36xKg6EQQsUNpuNb775hpqaGs477zw/F5XeLF26lKVL+1pqJyQkcMYZZ/CXv/xlsJcfYz8GEUGCcgztFGPAyjjlSsrkmyRxPELpu+CEi1RMxNIst2ETU/FIb9bKMALvOXtkB+2yhBa5nVhlNp2yBotIY6sWWOOQII4hTMSTLE4hRsxCozNguW8b3YJE3+OBhAoVM04afH+7ZSudsgINB0nipCFtG4XJJFr0z4lSJ/f5LUKMI1e9GSklbeylSP8bYcRhxT9AlptWYpXZfvYPTlmPgQjfgluvryZOzKWNIpx6I1JKjCIah6zxGfSpwoRNTMMp62nU12ET03zxKzplJY36Wor5OyCYrN5NpMgN6R6l1DDKvirbVrmrX3dHrwYlvI/QEK3koesa1donmIjGoIQTLQoOa2PortD2AI36WpL7CUIVqUzApk8nVswOWuZIZzjWsuFk8eLF/Wo/hBA8+OCDfrYdvYmNjeXVV1/t9zrTpk1jxYoVQ25nfwzZyyMpKYnp06ezc+dOKiq61ekVFRU+9Up/fP/73+ekk07itNNCM9IrLCwkIiKCrNntALgdCpVbw0md0knl1nAScpxYYvzDH3c0GagrCvOVSZ3SidHsb7BkrzLS0WjAluqmrijMV39P6oq8RjTGcJ2ORgOpU/oulpVbw7HEenzujIGM5UrWWUnIcWKvNGKJ9WBL8Vdbh3JPsTmt7N6znYKCAvQtR2HK/4xs8yScvMdUUrCIdcjqaUHvyUkUmtxF+d5WwkUy0rwJo73Ad08S0HHQKNexY/P7jIs9BlfnetrZSfz4BObinZzTxfmowkjJOiue7HeorWgjIS6CqNQvyRQF1Oifkay04XGoI/KcgD7P6nB6Th1NBnJ3JWEsaMa9ORpjQTPS7MKDk7D9+/3RNW62171BfsYp2IviSZldhlm2kCCOxkMlHtlKzV6FRJFBmMVIR6MgdUrf8Wk06wPeU9vaFBLHuwe4pwlMmpbW4566Y2pIVOobPXTsw3ff46ZaMZo1YH+b9C3IKhWtwYk5bRtNRSrT5majktpdZv9zsmAjwRxBVcM2xk21IpG4pJ1wIokX36N+axoNttcJcyahCsuAz8leYSBnrhsTe3wtdjnAsTUz6HPScVHf2EznvvyAY0/HQ7Icj7M6g5YGN6bULdQXmZk6p+/8FmjsOWnAIztw00KUmEj11qiDMPYupmlCE2V77AO+T/mNN+5/n/q+S8HuqTcH830KeY5IcsHePs0IyoGuZWN0M6hImTU1NVgsFiIjI2lubmbRokW89tprXH311fzlL39hypQpLFq0iBdeeIGCgoKAdcTHx1Nf792Dveaaa/joo4/4xS9+wVVXXRWwfM9ImYqicJztz6NGBTncJOQ4qd1ropNKX5yCcu1tWuVOTCIGl2xGoBCvzCdWzEPpkTehJ14rcIEQArdsoUOWE63kA7DV8zAdlJIslpAmzkBRumVOTboAHScNQdNpr/fcwwz1N6zTbiNBHEu2+t1h7YMuEnKcvgnvcCSQZqKIdexlLdtYzmzOpEHEUCxfYqJyBy1yG04ayFIuxiiiaNTXEasM/PUYaj8061uJVoLbboTCQHU06Gsp0v8MgIUMphj+b1D1S6lRKZfh0VvIMlxCo76ONrmXNOWsAd/5hBwnJXvr6ZSVxIrZ/W6XuGUbAoUWuZ0YMSuo1kGXLuxyC0YRRQQ5XgNFWUer3IGJOMJEAkYZjVs045GtaDgwi0QUjLTIXVhFJmaR5LV90dZjEBYSlKNHVMsRMa6Yz3b/mmnqw37bWz1p0/ayXf6WOeozI5rk7lARSqTMA13LutalPbecT2Q/cSgmPPPmiEbsPNwYlIaipKSEG264wRsCWEpuv/12CgoKeOqpp7jkkktwOBxcfvnlQYWJ3tx333387W9/C/n6VqsV8S0OnWGvNHr3d3v47JtFIlXyPbLFFTSzmRgxi1p9OZri9CVz6k3PScQoolAJxyFrccoGOihlCj/Doqb0OU8V3uhq/cUM0GinTe4hSZxArVxOlrzEaygq9D7GcAeCvXJ0JRUD6KSVHGaTxzHsYS1WkckEcTN18ktSlFMwyxQUDDTp3+DQa0MymQ61HyTDk3ujP+KUudRLrwdLGIk06ut9KcZDQQiVNHE6O/TfUaN/RqJYjIdWdml/IEU5DZsyFY/eQbX8mEgxkWilewvHXmnEItLQcdHGPiIZH/Aa3tweAoFKjJjZ7+KuCBOxYhYuaadJbkSRBiQ6sWIObtrQ6KBJrkfTIV6ZTbhIoUnfhI6bBGWRr24dF5poI1bMpkmuI1YEV60fCLp0s7H8H4xXbgwqTAC4ZQcTxe1HpDARKsO9lo3hZSyXxygiOtUVMNx0hyxjr/ZnFMLooISJyp00yK/RcJCr3jRgvVLq1MuviSCHLfoDzDU8O+Q21mpfUiJfZo76R3ZqT6CKMOz7PTVmqr8LOWXyQATri8OBYHYTvflAXUeF9h9y1GsQKNjlZoxEYxIxtOlFGEQEUWJivzEaQukHKSWNcg1xB5iQLRQtR6espEb/lEzlO+zWnyFbubzfxS0QuvSwRXsAm5hOonIcBiKo0j+ggxI6ZRVumgkjganqAz4tXHSqi8YK3ZsDRViJCuKh0aAXEiUmDtlrQUqNZrkVHTcgcMo6nLKJSDEOVYQDXnulMBEPQLO+DZOIxUQsqjBh1zdjU4Z/kdKkg/XanUxLu5CwmhODllvruYl05RxShmgw3axv82kzD1cOZi6PMQ2FP9/ez/1RiC3FHXDxsIgMCgwPUK+tokYup1J/l2zlUrboP6dF30GU0tcYrydCKMQznzZZjKlHToWhkKgejUtrYIv2cwQGJqt30imrKdP+zS7tKfLUe4f0ZdR7kQ5LasJZagtYNhjBPCsOFZX6/5ig3oxBWNinvUysmAl4A1LZlOkYiaJV7kKXLqLFlID9FmxM9KYrMuRIEy5SkWg4qMYis9im/ZoZ6q8H9cwVYSBdOY+9+vM0auuYYfg1Geq5ADTpG9ijP0eUyGOn9hgmEUcYscQkZ1JbXkeYTKSTSjplOaBQqr/OOOUK4pWFAESLyTTL7cSJoeWlEELFJrpTf3fKatplMU4aSBYnASpif4ZYTTrRcREukn1lYWS+35rldgBy0qazvWonVpGNKvpuhY1XbiRWmTnk6xzuwsQYh5YxgWKU0rXA9lwk22UpnVRiIJwOWc409Zds0v6PDC4IGCCpJ0IoGDATI6YfcNuEDMNNCwkci5S692uTGbSzj13ak+Sqt6GI/odef1/5czJbaI51EJ3Z13WrsDT4l0CwOg+moNF1rXZZikGPwCAstOg7iRDjAn79e2QrAgP1+koilBzCxeCNxIQQmIjDrm8iQowfNi1RMNKUsyjRX2O8ciNu2USz3IpNDO6rPEbMJIx4nNTTphfj1Btopxg3zUQzlQgxjizlEjy04qQBhXY0vROnUocBizf7KSZylVso1f9FlJiCgfD9IbYlbtkyLLEVukKbJ4njaZP7kOi0U0yqOG2/rVN3uOp2uY94ZfhzhJRr/6VKvk+WuIx2itmnv0W6cjaR5NKgr0bFSqSSS7hIPiBhYowxBmJMoBhl9F4Ue/4t1YsI0xMpk/+gSP6ZPPlDCtRfsFt7CjPJfbJK9qZTVh5wvH4pJfHMJ1mcjKruV0czlQ7KyFPvo0h7kVrtc5LUE/rsXwdb8OcEEByCEUrZ3kJHMBfO4aanMLFNe5iZ6u98KnFdugKeoxLuEzQ6ZAVN+gaiRcGAAllvIsQ4JBr12mqilamYlO4+0KQz4NfsUDGJGK8HBSvJUM6nRH8dTXcMKlulEIIC9UF2aI9Rrv8XN82YSSJZnIxHtNIk12OXm4gSeSQqxxIh2kk3BB7fAgPfaPchMJKr3ESYSAgpsmYoRJCDiwYUTLSxF4UwLGTQqK9HweCXyl6iU61/QrISfEtiMEgpKdPfpEZ+zERxF+FKIk5WEyUmESEmIDBiIIp4ZcFh7e46xpHDmEAxisjRLfSXwWKRFgOcywp1Ppu1n6PjwCyymaLezx79WQzS2iePQk88tGFicPvdXXTKair0/9IkNwBgkVl4PG3YKMDGdHLVW7z1CxsNcg2a1kmMOtPnLdJbmAgkGOTlFfn+XZykkk1NnzL9sX17Tp+6u4SLQBqf4SBQfQ36GnKV2/Z/LbM/O2ZgI8KeWEQaZpJplpsJI35Qwp+UOi1yByZhwyUaadeL8H6ptxIm4tGlC6vIGjbD2USxGLvcRLxYyHjlWtZrdxMjZvhiToSCEAqT1Xuwy29Q8J7XIStIUo4hhulo0kGF/g7V+sdkEfzLP1rJZ6b4Hdu137JHfw4L6eQZfoAu3QgMB7TYSjyAwEMbFfrbGLGRqVyABGzKNL+yCcoiOmSFzw5BlxqdshI3dnTcaDhQCcMkYvoE/epio+c+QCFKTMQp65HozFQfxSAiaJcl6NKJC7vPbiVBXTjkextjjMHyrRUonLKRIu1F4sVRqCJ8v8X34W31rDtCa58qwplh+LXfsWRxKpX6e0xUbw16XqvcS4t8l5nKo/3W75ZtdMhS3NiJFXPRcbNFewAFM1bG0U4xnZRhZRzNbKOWFVRobzNdfZjJ6t3UaMsxy1J07XNa0TmZW4CBhYieGLXB70Xn5RX5hIou5mS2+GkshkNb0d/57bIUJ/VEiym0yl1YRDodssxnxBcIKaVv0VOESoyYQaesplFfT4pj4MBP7bIUl2wgSuSjKvs1EcJrYNjCDt++eJsspl0vwSIyAxpSOmQtwZxFXNgx7Y8CCqBgxEgURdqLTDBct98zooWwQdroCCGIETOA/f3ALt92hSrMpCtns0X7BS5H/wunQViJFbOokh8xXr0el2zmG+0+UsVS0tSzBtWmLpyykU3aj/2O6bio01cF3WI0k0AzW7HITJr09Ug8WEUO4SLZ5xpbo3+GJl3UyRVEicnEiXm0yT0U66/gphmBiVgxm0gl12cICmAhk2bH+ySK4wJee4wxRppvrUBhwkaucjMKJtbptwEKkUxgonpH0PgNh5KFHhvuzQOXC7SYSSQGYaVdL0aTjqA+/enK2WzS1votYD1xyDqK9b9jxIZFpFOu/xsnTaSqSylQf46UUCnfIU/xGl62y1Ka5WZvEjO5ha3aQ0Rg5gzu5r98ThK5TONU5mV2J9sJJkD0JCO/mAyAxO5jZduyBzwvVEZyC6Ra+4R2iqnS38cgLEjp6deLQxUWNNox4F8mXCRjJpGtm9cTGcRrwS3baJU7sYhMYgLsnXsTeTmRUkMIlQiRDcKrMenQS7GIDMJEtwBgFomDimURzRTWeW7HI9sJFym0yj1+9Q0WIQS6dPn6wi3bKNL+TJZyMVVbLQOen6qciUfvpFb/fL/tA2gE3moKhSLtz6Qr59KsbyFVOQOryKJVL6JUvhbUy0QRJpI4ngr9HYRUSVFOpZG16NJJJBMBnWr9U3QcxIgZlOivUMIrpIglxItjiGYyEWpgLaMQgrBtN2LAhVNvIEw5MAPrMb49XH311SGVe/HFF/v9/VsnUPRUbRuEdxKaqzxLq15Epf4ee7RnGa9e4yf5Hy50RV0MRH8LoCpMmGUSHlp9quNAhIl4MpQLqZYfkiJO7fN7i9xBgjiWOGUOmnRRw6eEixSEEJhJAgHjuc5X3ioysYpMEjw7eI8t5DGHnXzJX7mDa2yX8WXH1yRElPJZ2y6W5IWRE+H/lZ6RXxy0rbuMUUx0t/iVHQ1CRaZ6AVu1XxIr5mFWgmslujARi4umPgIFeLcEpkzNZ/vmPUgpiRS5vjHtkDU4ZN2AwbGiRB7Ncjs20W1/YBVZWEUW7bKUDr0Mi0inU1YxFA+FGDEbiU6iOI69+p9w63ZSlL5jKxTcsg0dl0+TuE17GA0nUaI70mV/CCHIVC6iRe7AKKIIl2mYGPwWT7O+jQa5GkUYSVFO9bsfm5pPqUdQqN3KVPEA4Wp3SmhdarhopFnz2s0kGRYDECvn0Ek1LXIbbbIIC2lkiUtAgQ6tjHZKiFcWYhaJvZvix0KPDWNBM3WbJXXUURdEoOi5vXi4eT6NcWh46aWXWLJkSdDU6k6nk/fff39MoOiiP2NGgJWGHCJkJpVyGa1yz6Ct0g8GgYSJ3hOClBIdRx+BSBEGMpTzKdL/RppyJmaREPAaSeIEdmiPeo04xbT9X4VuWuVuqvRl5Ks/BKBOfoGOk1i1b+CidllKrFbCbM4EwMV07oi/mThDLE2eLJIMiZS4ytjl2kNeuIWj4sZx/ZoPaXZ3smzxbcycWd+nzt70FCZGE0YRiRs7oe7aG4n0ukAGOaFqqwWbMg0pJVVyGWY9GUUYMQjrgEa44LWbCbbd0iUQdshypNSJUQfvAWQiBif1RIhxTFBuolT/By36TqKUSQOeq0s3nXotTupQhIpBWInZ71rbKndjIpY8w/cBBhQmuhBCEC3yAKjQ/4tEJ4bQ78spG9ilP0mKOI1s5bKAZaYo97NRv5ct8gHm0h3TpUmuJ0zEkWQ4jhZ9py+uhyrCadLWEyfm004xueptCCHY5vk18cpCdN3t06j0pvc85twcQSH/YDZnkttLKA5k9Byq4BzoXInkc7UUk/h2Jhc70vjLX/5CUlJSwN/q6upITk4O+FtPvhUCRSiBhhZ6bDg4j5XqgqCL7aFkpcEecpjlFrnTt+/ck2TlZDplFcX6y9jEVCLFRKwiy6+MEIIU5TR2608RJSYjMCLRaJHbyBAXYhSRuKSdMv0NskXfCdXb1zZgms8m4p7KH9PQ0MixCRN4ZNa5/GzLv3ivcSsAe1rrcEuNWanRfFbSyfPV79D6Hzcf7atkZnIsCvD86Qv5vLSGS6d2Gy6WGqxkegJPssHobT8B/buZjhTZyhW0U0wYA2sohFD6VQx0jQkhBMmcRCu7BrUt4aEVM/1PFBaRjls0h1xnT+KVBRRpfyZVnIVNnUKKsoRi/WUiZS5CKH2MYZ2ykQ5ZhoIBgQGTsIEUvmBQHtlJk76eZrmVLPU7vusMJRR7vFg4qHTpHbKcUv2fFKi/6HeOUBUT4+SV7JXP45HtGIQVKTU8tPniX0SKXJrketplCQ69gWgxjRa5HY/sxEkdZhIxiTga9bVEiokBjakDzWvfTHiNuj37eJfHuJzfhjz3DUVToaORqTVQbRgTKEY7BoMBTdOC/u7xeHxee/3WM5yNGu2YieAELTfoy9Xfy3kwVIfehDn9T5o9jdgCES5SmKjcTrpWzpfiMwxYSFSOwyy6JVObMpW5yrM4ZSNGIlGE0bvFIT+mWd9KJzUYicHUy3Cvq396Glfm5RXxSMpS/rjnCyKNZnQkz12Qz66GdIyqwucl1VhNBs7KnYxJVRACNlY3ctK4FJKsZlaU1pBoDWf9LsGmPcX86qxMFEWhRRlc6O2DIUy062WAxKpkIqXej5GvRlCVwyDpOSYUYRz0roQmO0d0e8+AlQRxHJXyf0TLyZiEDRvT6NTeIJsZ7Nu/BZfqEUSRwCqlpI+9h0OvQdMddIhyKrT/YlOmk61c6ounsdBjIyy6ic8G2bYokUe9XBVS2Tr9K5rkesYr14UUvyJWnYVLP592WUy0mMI+/SWixRQ06UIVJjQ68NBBOEailYm4aCKSSTipY4f2ONPUXzBBvR6P7MSw//mEIhyExxi4mId5nR8j0RGhxG8PwkDXUzGQxmRyPN5ttrHtk9FLTEwMNTU1QZOh1dTUEBs7sAfgES1QhBoCeTjOGym3w+HE/77iyZYzqGIXn+rLcGEnVswiVsxFFWG+iIT56o+wkoWCkTASsIpsnLIRKxlY5QR2e54jUTmak3Xvl1cgT42ptlSennOx7++aneOJxmv3MCmu79fNvLQE5qV5vwBPm5BB2bZsTkoy8+eilbzwSRxL0wpght1Xvj/biUCCBAwsTAzlOXZShV1uIlrPo1XuYZxyRUDj1np9DUnKCTTp32ASMVhFZoDauvGGeQ4NSfCvjD5lpYaHjhGNUWCXm4lTjsIlG2mTxVjJpo291LOLVCaRzzxf2Y/UTUTj72oppU6zvoMqPiRKTCJROY5YxZsLI9A25mCemyrCkHiCGiGDNwx4lVxGi76Dyerdg/IEq9I/xMo4ivVXcNFIq9yDpnSQKBZjEBEkimN9ZQ1E0CQ3kqGcj9Q1dmlPkqNeM6jthHK24caJk3YECjo6aogCRVffDWbu09Hx4CIMi18dY4w+pk+fzvvvv8/MmYEDny1btoxp06YF/K0nR6RAMVRBYriufTi+VMH6JIWJXCon4sHFu+IDivS/oOPEQCRGYtipPcl45QZc1GMkCgUjbfo+7Gxij3waDx2U6f/laf4AwF/k0xhDjDUwGCPKqTFp2EwWNjVXsjStgKaqOMpqAt8TBBckYGSECYB4ZR6x+izaZTEOWY/Xx9JfTeiRnQiEL2JhuyylWd9KmEjEJRsAcNGIke6FxENr0GtKvN43Ok46ZWXQ+AWBaJQb+tVmgTdHRLPcStgQtgHnesKpIo1M4vhQzWe79luimcpV/B//4/dYe7iZAn0EK7dspl5+jRRu8tTv+473934PVrBXCadCf4f0AK6jnbKaHdrvSFWWMkn9np8wEcocU0UG5WxiFqdzFBfyHx5GJbg2SBUWnNSToBxLmyyiRH+FCcpNfltD/bGLleSSwSe8wDzOQx3k9D7YeVMiaaHO7zkOto7Dca78NnLppZdy2223MX/+fE444QS/3z777DMefvhhnnjiiQHrOeIEikMpTIx0G8J0SVo/4aMHc90uTULX4mrAxDn6mbDfkLKLFWoNe7U/EyFySFAXoUsNi0hnnPJHhBAs9NhooZ4KtvEhz7Cs5WPOjD4t6HV7L/ShuIl2ccOEo7ngyxe4L++UfsuNpDAxUB9vZTmNrCFCmY8I4H68QbuLHOVa399WkUkHFT4DPRMxCNSgX8xSShzU0Cmr8OhtxMt4JDYMWIkRs0KOoNkqdxMlcgcMNNUstxItpg4pkmYt+7BiYycrmaiFU8UM3DSzl7VEEkct+8gKYBDZou+gWn6MSjg2UeCL6TCY8R1q2ZncwMs8RJo8vc/z6pDlZCjn+vKADPa9Pp+f+v1dxS7O1S+kvJfSwC1b0HAipMBDOxINVZoJJ4029hLJwLFGACaxiBLeo4IdOGglmVwsjJyNkJN29rGelBDbN0b/aJrGAw88wMsvv0x1dTWpqalcddVV3H///b75QErJz372M1544QXsdjuLFi3ij3/8I7m53c+gsbGR22+/nXfeeQdFUTj//PN54okniIgI7p5+xRVX8O9//5uTTjqJgoIC8vLyEEKwY8cOvvnmG5YuXcpVV1014D0cUQLF4SBMjCRaU/DJf6B7DxaSurdg0ZtjtCQW8H1Wyn9Q53kOiU4GeaB9TibT2MZGTFi4PHMGWuNipoX7exZ0Le5dgkPX/7uO9/6997k9jyebo8iNSMCta4QHCPI10lqJUMbXFBYzhcWgw0qlb5356o/Ypv2KJn09MWImkUouFpGGQ1QPaAysS416+SVWkU2sMhNdeGhp2oyZZN+E0y5LcMsWBApRIs/vq1pKHRBIPLTrZUQoE/q9npSad3EbgjCx0GOjlHLaaCKZ8ViI5rvkU8JGNvExEcRSRwlzOQcPLirZSbW+kyZ9I2aRxATlBhRh8quvP/p7N4KN/cLSKMKJYgaLSNQqyGKa3zjQ6KBRFhLPQr/rDxTevVPvpMxdwcQw//5NqUyi1Pg/CjqvoZId1KnjcVCDLl0YhQ2P7MBNM5EiF4TAgIUK/V2ukT/v93pdRBKHvamZTlopZxsvcAMmwrmc3xExxAi4vem6d7d0837LR1wXuZht5cNS9bee3/zmN/zxj3/kb3/7G1OmTKGwsJCrr76a6Ohovve97wHwyCOP8OSTT/K3v/2NcePG8ZOf/IRTTz2Vbdu2YTZ74wtdeumlVFVV8dFHH+F2u7n66qu54YYbePXVV/u9/ltvvcXf//533njjDbZu3YqUkuzsbG6//XauuuqqkLZGjwiB4kgRJAbMQ+ECBpHXIhi9F+/t23MGvPZ8zgbgo9I29lr+yVcdX7OS13ki9TfEGry+/J+2fc6VMZcA3Qt4sHq72vDV5hgsioVl3xhJNCRgFmF+A7enUNHidnBNzkJKI9dSvSeBpIQJfuUCEYrhZX/CxHCPLXX/frOHTlw00ahtJEadTpiIp12WYBVZvkBTPemQFbTLImLETJ9RoCIM1O8Nx8NGopgE6HhkBzalAE06aJTrUKRx/366GxUzEh2JTpyYS5X+IcnKCUG1FB2UB4x/EQoaHlqp9wpXPZjAURgws5LXqWMfX/MGpWxCVaYQTgqT1DsCtmcLn9JGI/M4FyVA5lTPHv929jYM7k3PMR/vyuE/1ZvIYprflmW4SEWV5oDCRH+atV9t/YC3ajay5tT7/I5fbJ7C60XbSI18jxWtX5Gm5ZPMBGZxxv4MpfuzAkt4T1nBHD2Dd6gLep3eWImjZo/XGyeRcdSyDxedVLOHccwa9BZIb3r2aYfeSZoxFYtiGfCjpD/6uu/bD6SJo5qVK1dy9tlnc/rppwOQnZ3Na6+9xpo1awCvduLxxx/n/vvv5+yzvfPxSy+9RFJSEv/5z3+4+OKL2b59O8uWLWPt2rXMmeO1NfrDH/7A0qVLefTRR4MaXYLXoD81NZWjjz6aJUuWMH36dBYtWjSoexh1AsVoFR4Gk+AqGK05HUQWDRwRsD8Gs8UQiJMzIziZa7iJa/ig9RPea/2QS20XIYRA9nAx6B3Suje6lLxVvpFfVX7AsdaFfNG+knRDGunGVG5NuD7gOa+VrOXS7HnkZxv52pID9UHiQBP65DbYraLBEGg/30gkAK3sYJ48Fidt1NOEW2+lU1biVBpwUEUix/kiaLplC52ynATlmD7XmFyQRckWN1X6hygYSVWWAqAK84Apuo1aBK1yF9EisJuphUzsfBPSvUqpUyuXE04qUcpklikrWKL3bS9APBmkMJE69pFOHjNZyjrFP2KlU9ZTqf+PWDGXaCWfDuxUsctvjPndS0Ez05v7fkEFG+89w7BnGTNxmd9iXGwx+yqzfc9tBds5mfOBwIJEsMBrK7/cwZQEm9+xjPxiduzeQZWnmipPDTfFX05RfST/5Td4cHHU/us0UEYdJSzQJ1DMBgwMnJq+i495jhkFM9i7uZRGKnzH/8djnMxN5PcS7g6EaDWK2ZYZfscGeudD4XDICDzctLT4z/1hYWEBA0gtXLiQ559/nl27djFx4kS++eYbvvzySx577DEA9u3bR3V1NSed1B3WPTo6mqOOOopVq1Zx8cUXs2rVKmw2m0+YADjppJNQFIXVq1dz7rnnBmxje3s7S5cuZdWqVSQnJ1NZWUlERARz587ljTfeIDo6NOPgUSdQHCyGQwAYbiKLLAG1C4EIVXDob5tgIE6NPJHXm97kZdfjnJKSx7iGOPLz9/nq7dmHXdfZ6tjBr2sfI8uYwVSzN8DQLudeALLDvEZ5tZ56CisFDtohaiM7lu/mzJxM4sMi+O32j7g7JZ35iUWU1Wf73W/Pewl1cjtQYSKUr7Pe17ByBSt4iU94nqfTfseuCm+CtK5JU0qNKvkRqWIJunTTIcuwiW4jTo9sRaLjls3UbVJQhIlk5SRatNBjKjhlvTc+QrDkHIDEjUOvxUUTJmWgiJKSqXoauxUnLtmEQGW1oS3g/TdQhpM2okjChIVWGqjTv6FdluCkAV26MIsksmUiRlnDPH0hcJ5fHX3ez17CRKDx31MAKNuWTXT2esJVEzEmCz9tW8jLxa9yQeZtvme5hzXM4/w+wkR/EVwBTh2fxgWTs8hI8y83ISYKs1pNu6GS786KZMeO8RztepB7q3/KjLgoUgxJbGtfxZKIkyj17OLLli9Y6rqrT/2BxpyDNnbxFTM2P8Q4wvkbdyJQ9z9fyS6+HlaBIhiBEu8NlTqKiScLgRjUe+rExPoDunLolO/MJMIQeEuwzeNN5ZiRkeF3/Gc/+xkPPPBAn/I//OEPaWlpYfLkyaiqiqZp/PKXv+TSSy8FoLq6GqBP8KmkpCTfb9XV1SQm+kdUNRgMxMbG+soE4v/+7/9obW1lz549aJrGtGnTqKur46KLLuKee+7hT3/6Uz+90ONaIZUaxRyOgkEoBJoQK+IVqB+43FCuM1TB4sL8JK5a/QGplmjmxmbxv8otnJ46lby8IjSps217Nob9hoJSSn5d+xjncT9p7jz2uTcAH5LsmcV3uBLaYRX/4G/ty9HRaaScmpa9aLjZvn2n75ovJhawyxjVj738yBJoTA1G7Xt9xiIezo3nurWv8G7LMi7IOIf/lVWT54lhu8GCECphegK1ni/pFBVYSMcpakEKOmU18YrX1bJDlpM4pZ7GrVkYRQQoOhIPop/w6l10yHKMIpomfT1RMq+PMaeUGg1yNYnKYprZRIycRaNcj0qYL8iUlJJmuRWTsNEpqziK4zDru2hkF4YAEVS7yGI6YViYicJGlmEkjHx9CjYKSCCLYjaSLWfwLr+jlXrm4f9VFaj/W3M6mBfWd8IMtvj78sF0/Q1cv2Y3V89fxxxms8dZhFbjITVpD5BNXl6RX12xMwPXCzCj3sPxx7diMrTTuCHbV/bMMPjDOp3T8uNp9zi97972HE6PPIW/NPydiebxbHFs56O2zzgl4gR+mHgX4Uo4ENz+qbA0Conkr9yBjkZMgcC52UAsaX5ailYa8ODGEMLY6MIrjAgEYkjz6IFqLBLIHvK5hxNlZWVERXX3Q7Dw1v/85z955ZVXePXVV5kyZQobN27kzjvvJDU1lSuvvHJE2/jmm2/yl7/8hczMTIqKvGuC0Wjkpz/9KaeeGnqo/CNOoBhtAsRgBAK3OrR4Ab0n1UDumkMVLKZEp3DnpOP5d9lG5sVl87eir/lr0SpunHAMz+5ZQXF7A1PNeVwRcwlF1o84IeI4zo3NpNZTgsNRR1ZrBkZDDXR661tAd/RDz/7ETQZMpKbs5E+tT1HU3oDD7aGmIYHsQcRcGCxDHUcDTaLeegXhRhMvL7iKK77+G+/KWpakX8275eXM9uQThoVSEokmkWh5BgAf8Q0GrLil3VeXkSjM5hbaZSmgoGAIKT14p6zGRBwdspQ05Ry/ZHguaccha3DTTJyYjyKMCN1IO6VEivHoeLDrm/fbYmhEiglodBItpmDARAoTaaGeo7W+BqY9+yaZXIpYxzzOxdYrUqeGG4nEg4vz+EmA/vMnL6+I4iSVQWaz70OGJYZlVdtYkiX4+YpniVai+GnNw/znmBuhR86P/oQJgO/Mj6O80UVOotmvbKdLJzPKyovf7CZ8XAbnZs4A4OKYCzgp4gR+U+dVbZ8ZuYSLYs4LUHNfdDT+zj04aedWXsJqbsdEDBOYzxreJJVJuHBSTzGt1BNDSsj9UcF2wojgtMyhp7Qfjm2QwV6vU++Ew8hQNCoqyk+gCMa9997LD3/4Qy6+2Buzp6CggJKSEn71q19x5ZVX+kJf19TUkJLS/RxramqYMWMGAMnJydTW1vrV6/F4aGxs7Dd0dl1dHRMn9k1oFxUVhdPpHLDtXYw6gWK0CQzBGKxmISO/mGaTjYw4+4BluwSG/r7Oepbr3a7BCBVCCC7LPorLso9izgfdKdM/qdlBdUcbk8Jy2eLYzg+qfsp0Wzp/WngpQhSRB6h1HeRW3YBNjWJrjwmg9zMuLDWRakzhWNMSdrf9naP+9AGXnxhGlkzv1/J4IK3BSI2lQNcNdC0hBLfkHsvt6/7Jj0+pokOL49O2fzHPOgvNXUeU6iDPHE5haRQna173yveVGl+0RQORgEDBQKcs53R9cZ/04oH2nttlMfHKfMwynma5iRgxEyklHlqI0XYxhcV+e/dN5LKHQqaymHCigNxediHd91nCJuJIC9onPfsmh9nUU0oR6xAIbCTTjp1Y0hDxXzDdlcYim4dgX+gDvUMDbU3s2ZxOZ9JmChK9C+bvZ13AfRv/w9qGEq+wt+olnpr9HR7d8TFvXua1RxlImACwmhSe/aSam05MIj6yux93boxEAreOP5EvipuZ3N79noWrYejo/CH1EWo8oRtirubfNFPHzby4/5l5w9EnkI0JC5XsJJcFZJCPElPInMjjQl7g05nS7zvSX/8PZftxKBwp6wFAR0cHiuLvvaaqKrrufanHjRtHcnIyn3zyiU+AaGlpYfXq1dx8880ALFiwALvdzrp165g925sY8NNPP0XXdY466qig105OTqaiooKsLP9UDM899xxz5/Zvi9WTUSdQDHbBOxwJVZgYaEI80POCCRaD0Vb0LPNSxnOUusv5U8Pf+Kh6BxnGNL4XdyM/qn6QszPzWJKST+aUEl/5qJVmYsaXU188ldkZzawri+53O2FxxDGkG9PwSA/1rXb+VvU1V+UsGLCNoU46B7p91Lu/Qrnu/LhxRBjCuHfjvzk5OY+78ibxn/KVaLqHc3MWIkQR4K23sDSKibqJGoN3kRJCIFABncl6YGPdnoahUmq0UUyU8CbmUkU4Ht1JvbYGIRTMIpF8jvUTJrz3EEFM6VlsYzkTmI8Jc0CD0y4PEkOv8PA9bRC6+qhrkYknk3gykUjK2IyDDpZmJPFo7ad8P/F7QfttsMJE2bbsPjYUJkWSGhPpO1Ywo5aXJs7C7nAxIdZB8sZIZsdmstK5lh31zUyOD80wLTxMpbHNw5c7WzlnjjfjZ+OGbGYmNxCr2Pj99i9o19u5xHYhEao3fLhVsfK71IcBsBlsIV0HIMJay/ntP8XUYwOwnSb+x+98f5/AdWwIf4aq/Xv6wRb4ItbRSgPT6T/OSyjvSVTWejbuiiEnbFyfa+poaHgwDpBGoIs6irGRzNyMDrY4tjM5bCJmpe+5Xe1q8zgPKw1FqJx55pn88pe/JDMzkylTprBhwwYee+wxrrnmGsD7vt9555089NBD5Obm+txGU1NTOeeccwDIy8tjyZIlXH/99Tz77LO43W5uu+02Lr744n49PI499ljee+89Fi70xlxxOBzk5ubS3NzMxx9/HPI9jDqBAvwHdJdb4eEuZBzoYjUaEEKQZcrgx0nfp8ljJ8YQTbgSzo+T7ubNlhe5Y9LxxM5cDngn2NMXullXVYTmbOGrvWbyUidR75GEiTAi1Yg+zxngq5omTk/NRhoUHt79OaU1Vs6KOg2XdKOKDixKaF4wI/E8hlKnEIKPj/8en9Xs4vXSQsZZ47gsex7/KC3EI3WMQvWN7zmZLRSV+huo1UudMH0Hu3HxNr/h1MgTOS/6TL9++LrUTLRnIxKNBCxMxDvJd9JKHWlkUhAwB0hPgWhOZguz5Ay+bF+OsfHU/W6O/pFhBQoTmEcZW2mhjihCj67ZSAUqRr6bmc9HrZ+xOOJoTEG2bwbTzz2F5Z6au27hwn8KjLeYibeYKduWzfGJEymLXIurTKPD4wlJO9HF6TNj2FDcAXjHOsC0pDj+fNTlLP34zxiJ4ucVz3Be7HEsiJjXT03B2enYzaftK5gX3kFq5/cRCDQ8lLKdKBK5lN/wHx5mK5+ypnMdN8d5A6oF0xZkMxN6eWoFond8mEAkmCMYZ8r2O9ZV3welLbTR4BfUrD/hu1kzYBHtKKjscOxiinmy77cjaV79wx/+wE9+8hNuueUWamtrSU1N5cYbb+SnP+0OkPaDH/yA9vZ2brjhBux2O0cffTTLli3zxaAAeOWVV7jttts48cQTfYGtnnzyyX6v/atf/YqaGu+eoc1m49577yUnJ4cLLrgAm80W8j0IKeUg0wkdXFpaWoiOjqa5uZmoqCjWLflRv+UPR8FiKIM+kJahRjWTpDmGoUV9CRYGezj60yM93FB+O+V3XthnUm7ckE3Ztmy2bRtHkasYVSg0eJq4bLZ30svIL/a1bfO2TF4t28wkFmFMc+KqMPE0lxNLOmEGN2EijGJ3KVfHXMrxEcf6PE563sdA1v/DRc/+DLX+spZ2fvr5Bi6YnMXi7BQ+2FvBeZOz+OhrMx9UbaO9KRmX7iKn9UpqKGITH2BK82CrmEQy45me7KJJs/Pbuid5Nv33WBXv129hxwZmhU9H6ZWH4pXSLUxkfp8EUsEmd4fupEPvYIdjFwsjjupXjb2DFeQwl4WZ3e6gPQX/nuc2UUUHds7OTMOhO3ms7im+n3A7JsUU8rvTFCGIaRt4KhvMsy62t/FU4XYuPMXAadMHb0fQuCGbH35aiFFRKFBmkG2Nw148kzdK97GWt8ikgHpKOSZmAidEHud37kB2OEXOYv7Y8GceSP4hN5XfRaohhdmey7CkCQorPuNkbiYMC8Vs5L/8muks4TiuGFSysKFud/RkMPOHXbNjU20Bf1vW8jHHRRxNuGIOeu2uZ9vqdDPhmTd9a8ZI0LUuLT/xrn69PBZ/8vsRbcfhxqjTUPRcYL5tROuugQsdhhiEgYlR3a5Mcn494uvu1N1dE4HYnoOatorZJovf8S4mT95HXGsdhfb/IuyLaVVLGS9v5Az9eOaktrC6vZBxpiy+aF/JFWU38vGEO7CZvKrggyVIHEjdGVFWnl+6kJ+v2Mjbu8uIMhl5Y3sxW6vbqXa0MDkqiR2tNUww7SLaNYW5nENsYxIS1Tf5Z5BOvBrHq03/4ov2lViEBbMSxhxL36Q/c5PMJBrK/SbxTZ1bWdfhxqKEMzFsArWeOmo8XiMvgcAojEh0vuncTEKyjc3VZpIZ71dvO3YmMJ/dfE2+lo1N7btVoOGhmI2oGDASRhp5QAuv29/grOjTmD5lcDprq2No30Xtbg9WY+BpMNsWwV/uHXwOk56kRlhYvcdFuxOe7vyEG+MySSefNbzJUZzP7Ixmflb2HAus8/Z7dHiFCc/+hHC9vTJmZzTz54a/s7z9S26LuwEp4YLIs3mj9b9kUkxko40zuKf7HpjBHbwOwG6+Jpf5IbV7uGwTQtk+zcsrQkpJjaOF5HD/sdJ13l1H5QCVAc8fyff4SMbhcCClJDzcO+5effVV/vCHP7Bzp9ejbtKkSdx2220+t9VQOCgCxbvvvss999yDruvcd999XHfddbz88ss89thj3H333Vx22WUh1zWcwkS9p4G1Hes5LerkYaszEKGoCHsT6D5rbQqJ9sBxAwK9VAfSVweqmSgsjfJNSrmT9rD1oyocHq9XRpcw0aUK7iIvr4hWdzTbW6pJNHv3th/+ahMpTgcNznZkw2Ti7GexQdlAZpqdxj0tRDDBd72EpHiEEFxgO5stju38+Jv/8MzcSw7oProYSN3d+16GilFVeGjxLMpa2lldUcfSCek07PYP4dzz2Ww0deLZE+HX3w+n/JQ/N/6d/LDJnBpxIi/b/8HlpTdQeOoP/c6fGDaBL9tXscAyj72ufehSp01rZWHEfJq1FrY5dhCmmJkR3jfLYIvWiku6UFHYxnKMhGPAhAcnDtoo4CRymEWdZxd7nEXEqjFsXt9Jp1zHpnon0SSRxXTmZ3Z21cjHrcsJV8KZas5n+/bBafbsEcHfjZ70tqWoausgM8qKSe0bffNA6BoPt86ZzLaSXYjwYn48eQG/3/k0319wMuWlZgyur8jPt5LcYGBduRUzEftTjsOHPI0RMydzk1+9z5YtJzLCzB9mXUS1o5T3ysp4p/V97om/DU/90RjS2vDs8W9LA+V00MznvBSyQNFzPAVisHPaQGWFEH2EiVDOOxBhYjjXpdHImWeeydKlS7nrrrv45S9/ycMPP8x1113HrbfeCsDatWu5/vrr2bdvH/fff39IdY64QOHxeLj77rv57LPPiI6OZvbs2Zx77rm8+eabrF69mgsvvPCQPbh4QxxLIk8auOAw0J/KPVT6mzAPpfDQRSA1rS51XixayZKUfOp2jcdsCD5xZ+QX09DpZMPecjLyvccum5pD0c44UhqXsL7OxhqDHV13YS+KI0qJo1ZbgU4aOh521kQzLbmTCncV18Vewdvuv5E6uYjKHUO7v8HsmcfOLB60UDHQMzsKaNjdfx0zXDqF+//d3f9R3JZ5AwAV7ioWWY9is74GXUoUIfzGYExnOB9V/4MzJkzD4XHx1Q7vpB6tRnHRrC5Dv77B1KJUr8B3Wia8XlrDeOagoWHASBlb6KSFcKJorpmJRFJOCwKBGyeJNJLKpP21eQWK5W0rKHOX85uFC9ixo/s6ob4voQgTXfQUKsIN6rALEz1x65IaKjk5I4Ud+gZeunA2d3/0AdfMncCPl7/IDTmnkLzVhWZegbPxOL7mX8zhLE7mJopY74sd8QHP0EkLBVHJfMd2EXbxMYsSxuOpM/JO6/u46xch6BuCHEDDhYsOruMZdDQaKCeBLCQ6bTQSSXzfhofAUD6UgjEYzbNb13i9pJAfn540cOEgHM7r0sFi48aNvgyiTz75JH/84x+54oorfL9fdtllzJ49m3vvvffwESjWrFnDlClTSEvzupKddtppfPjhh0gpvVbqISQcGUmEEOxy7uWP9X/i92m/GvHrHcji3ZzXTvR26zC2ZmAO1N3r383vsE/Zx1Ozv+N3vPfk0eJ2sLm2iV2NzexpbPWNj7RIC4+UbuBMvIZrCz023lMkGbObKS4MRyGMf4m/YxZxjNfD+aLaSl6Chxnh00g3xnDBm8v59wWC8u3jDug+hspIb89tTtKgtO9xr9rcxfT0GP5v/lSuWb2B1Q37qGhvItUSQ42jhfiwCDR0dAkxJgtfNldy/szxvgU9GL3V2Gas1FNGAl6Xs3SmUMxGxuHdZhEILPvTsdexmXTyfXU1eBp51f4vkg1J/HrhgiHNBxn5xWwx2ZjqsvuO9dfvPb9q0yKDv0+DESh70lOwDFMVZqfE0eRwsa6qHo+u88xp88l/9j+YVcGZ//iYMxPn8ffq97iE0ziWyxEorDTYcesZrNR/Q6wyk0p9DTfyZ+ZGt6FLnXpnG7a6k5gaDjGkUkcxiYwjbG4TzrXd9h4SSTO1ZDIdieR5rseEhWt4CoHSrzAxkJYChudDqet59OfO3hODUDAc4LpxuK9LBwOHw+FzU3U4HD4Pj54sXLgQhyN0u70RFygqKyt9Dw0gLS2NiooKzjzzTObOnctdd/UNLXuwGWfK5Lq4KwYu+C1huHzGl7et4OPW5dw4cT5dr2fZtuyAQlV93IfoTREsmReOxWjgk+JK2lwaBkXwvYmLKd7d/YIv0Y+mTd+MXe4gRplOvPAKG1N1GwCeOigETky9nP+r+QXvvHE0ZiWsTx6G3urv3nQtDKEsLL21E6EIEqGGTe8v8VlYUlPQ+pupobDcRpkbOjU3UkK6NZb58eN4v3IrGjqLEyfiiPPu15eVpbCjfnzQ+gK188vNNtLj65H1XiFhpcHOeE9Dvx4eXfk4opM28ELDf7ky9rukGJPZOYAg05v+nl3PL95Q1eJDFSD6QwjB/UdP5/tvFfFV+XbiLGZcmk7Z9y7k6bXb+cVXm3i66TMcUmMj7zOD03znlshXCSMGu/4N2cxiFyvZW2YkN95JvjwFFO8YiCCW1/gRV/I4NXxBIeuII51I4qmjhBI2cit/p5IdOOnASUfI7e89F/R2Oe0SOIaSAmCgODkQ+D0SQrDVvQNI7PNbqIyGdWmkmTRpEq+99ho///nPueiii3j99df7aCJee+01LrroopDrPGRGmddeey3XXnvtsNV3IF/+RmFkyv68Et9m+hMktrOCVuqZzZkhZS304OLTti/4Q/ojiA7BV/Uf4pE6NRWp6A3mPrEOWj0OciMTibd0cNr4dOo7HOhSkmgNp2xbl7V/t4dAApmcqU/3i4PQ89+6dPOnyl/QTiNPlP+Ha1O7t7Z6fhENJFSEwkDCxEBjs2+/DzyWBxL6dvM1bhzks5hvOjezp62OeXHZGBSFjPxijnaPZ0NTGQBm1bi/jZsHvG5vSlylzLHMpHC/yDjfE8U+djOewMFwutxNq9nN8ub/cUfCLcyaUsn27X3LDmUxGmyZLkZCmOiibFs2t03MxKqGER3XxP8tX88fT1vAbfPyeWtzHVtaqsg1jKfD468NMJNEhJJDtJjKIq1H+vF62Lb/nw7a8ODiHH7MCl4mDkEEcdipoYhCwrDyHX6BASMuur80d7OazXzMVE4gi+kYCQuYxbU3vcfdQN4owbZFBhsrB/zfq58cM6NP2a7fu3JoDIXhXpcOZ37yk59w3nnnsWrVKvLz83n00Uf58MMPfYGs1qxZw+bNm31Bs0JhxAWK1NRUKiq6Y8pXVFQwb97g/a4LCwuJiIigLMk76I2apGVFti8DZ0eaA3eUfyhmY4uKpcLsK9Oa04Ee5m8NHlZnxNhiwJngwlJhpjmvvc+1LeVetyAtTMfYYqBtfGefMhF7w3FHeVCdXhVSR3rfQR293UpHmoOwOhPuKA/OBLff74pT+NoZ6J46k5wjek+5ee2UNnb7M7u2RKHEupCdKjVswjTeQTH/w0aSbw/cuTYGw4Q2VlW7sMR6sKW4ydEt7ONLpjAfh9VNZJGFqJjFRBZZWBuzBuf4NVhEJgoqObqFDoMb1948HJPclG1LpCJeISK9EYBagBl29D0xaCYdZ4KLOcD2LO9XVpbS/bVVV+S9J2O4zsa655gyNZcwUojGzFviff5ldzGrzcqFExJJMCnUFWXimdFEMza/vpnqslNqsJKoddKsmNiydQaW/e0BMKtupkZUsaUthdTdYZQarLQoXmv8pqo4SAKLU5Jo1735V6DPcyptNOOpNKM3mjBMaMOzJ4KwuV5tQ89l3b3Xq5IX4Rp6ownTVO+i06WZMGR1+D0ngLLcOsJJIxyBSW+kijruL7mXxlgDtjadGtVMTVo4LZFRFEerVNfE055VS9hOk9/YK07yX2B63lNavff/5gILpUoVrqQ6KhQHtnIjxkbDfuPACHJPrfLdL0AcCi17S9nM/7gl62pMrSaKk1Sa8R+jsww1NJkFJs/+Zxvt7ceYlAYAmrH5PadWYWSLyf85mqTORHcLu4xRTHS3+D2nLqJ0NzMKtrKlLcX3TB2af5mUsGZijR1UOqMZb6mnsDmT3uRYvEl2OjUjQijsMUb5jQdQWeiYyF9r13Py+Gye2lLKzNQTeOCc8fyzdB21HZ1Eqx5YBYYJbRirdTJtE1BTdpIssgmTXkFMdyi4N0djLGjm8+0S07h1zLPNJZd0KhDMyJlOU0cDX+5YyeT8iSzcfCeRBR4UcxMa+5jLXDKYiqkyjPrGPRSnSbbu+YxJc7OJIBYTZopYx0IuRtmbEHDsdVGkdFC5NRxLrAd3p/f5JOR4570c3dI9jrfn0JHmoCC2knazoNmqUNww3vcsgz2nJoeLSJMRgyJQHR3k5Rf7yuwypvNWUxudHo1piTE0VcURHaFjdUjqrQO7xg7XujSaOfvss/n444/561//ytq1axk/fjxtbW189tlnvjI5OTksW7aMX/0qNHOAEY9D4fF4yMvLY/ny5T7jl5UrVxIXFxfS+f3FoTgcY06MJAfbhqLn10c7TVSzlzCsxJCCtdci3FM7sNBj4w1+zhJuJ4LuLysdjb0UUqNOoEF+TayYxTGaNyb9zIwmtjp2MC3cm0o70PZET74mid0fpAQMLV2ivUat/ByBioFI3NgRCP6S8TQr21fzSvNrRBjCeG/xrQesDg9kiBmqhmI4tpZ675lD32fxBBeTYkjikdRfkJdXRHmHnXSLjRW1e4hvOIVWrZX3K6rJYbbvvN5754G+Mqs6m3lzcwse6cZsP561agtztSiaqMRFJ+dkjPMLTlVYGkU1e1htfI47Em4h3hB4DhgozkAgettQ9MdIaiPAf0z0HgvHf/J7LsyYxfaWah6adhbRpnAcmpt7V67AiIEvOlZyGy+z2tBGvWc1dawgQRxLvDrPL6DZSoOdZn0ru/Q/cCN/Ij+1gVft/6JgdgEvf/kqZmHGrjczm7PZyidABOPEFWyXj3ABD+DBxdf8k2r2ciLXM5mjeYUfMYcz+Zhn94fuDieZCczgNL/3uOv6XdTqXxAhxmMRaZRpb5GiLMEgvAa9XW0OlP69i1DeQY+uY+gVltqtaXxRWsOJ41L9+jmU+A/DtS6NxaHwZ8Q1FAaDgd/97nccf/zx6LrOD37wg5Af2mBY07GOOeEz+wTvOZLo0iocLPxTEccwnjlBy/ZOL6yg8mdu4WqeJJIEPlY34ZR12MR0FKESxzwa5Xr+p+xgsh7BrjIXyeRS6MsL0a0qDbSPWmCuJTrTCqW2PkJFlnoJmfJiXLKRCvlfGuQaZqvPsLEsBgun8VTGPK4pu5U5H/yaU3ensTgrmQSLGaemcXpuOuGG4X0tRjKSq3uvNaBQ1ZMr+D0vee6i1lNHefV2PLrOxqYymquzibfAexVVfsIE9DXIC6S6/tcmO+GKmaImlZnEYBICKzasxDAjo5Etju0YhYH8sMkIIbBTzds8wgURSwctTAxEhqevFq43Iy1IhMK7x93CtV/8l0nxVl4rWctNucdiVo18Z3IWd67/FwD/4P9weMxkKd8lTMRTqf8Pkx7FCnUcHtoJE97FvUluxCamYZYRfNH+DtPMU3GXukg1pjDFnMdCy1y+qG4mgvNZyf8wEs1k8X0KZRGJtJHNTM7mhzzHdXzC8wC00cg0TsFh2stt8VdTp9Xzj5qXaaeJWNKZzRlEk+SLkKpJF7X65zhELRnK+cQp89ihPYpKOOlcyMquV6nUFnQLJBRbl97CBIBRVfsIE6FysNalbxsHxYbirLPO4qyzzhrRaySqCbToLUEjrYWKLvWQhJKDHfK154LU08o+UHjqkWAw6bkB8lhMh1JJhB7PZj7CxCSsSnfiGUUYiRfeZDUlog6btpPIXoZ8/VmQ792TwTelUUEXUyEEYSKOcfIqsrkcIQQrDXYWemwYhZEUQzLPLTiH3Ck1fFVWS6vLu/303be+4Htz8zg+2z8rY8801IcbPcNfByKGFL7Lb3ih/s9MUSz8MP9UrxV7GmzfDpMSHHjqhK+OLuEwkFAB3QJSutFNkiGRHWz3Ow+8wcxmhBfQoXfwdcdaFljn8Q0fcAb3cEpk4IyXR1IY5UB09d/1cTE8U/8ClmQT/y7byHkZM4itO4m/ZpzADyp/SpI2ia18iS4cWMlAxUylfJ8OvQxtv0HlOOUK6uRXJAtvDJ0aTy1O6WRl6xoWmudR2LGe0yNPYSL5rDTYsWob2CT/D0EYEifF+9vUqkwmQp9AG97gFV/zL2awhCWuh4gxtLK3MpPTmMWUtBpWdqxmr+sflLa3M46ZzPIcjRkbqqE7I2y4TCVHuYat+i/Ywa+YrN1LhJLjHVv9CBUQumdOKOVD4WCsS6OFq6++ut/fX3zxxZDqGXWRMruQUu7PF2GjVWslzhAbNPb/YGjVvW5ZMf0k6DkUE19eXlGf8MK92xGoXcMtZIQiWDRSQbX5M2YaptHYVk4C42gTfYPWSClpYy9O2UCDaGaWDOyqFegetPjQooYKofQJN1xYGsUjmQ/SXALtliJmMImMqcUAnD0pk3s+WkNJcxtXTJuA0sN97FAIFf5aoqg+VvYi3GtjE0yo6BYSsihwfZetda/znw0a47KrafF0UtLRTKYpg1L6apmC0fU8aurGs4JVTObooG22KBYyjOksb1tBA2Ucx5UUlvavAg9E14KysbqRcbYIos0mv98dQiUad4AzvRys5xZKLJJUUzIPpfwEKSV/KnmJ8qpiTooYhypUkowJnKBdwwlcw0phB2CCegO61AAdRRhpl6VU6u+SIBaRKI4BCdfGXs4jtU+QFzuJNeXrqPXUcXvFj5hheByAbOUyWuROjHoMCDeRymSa5VaMIooc9RpKtCdIJIfdrMJEOI1UsLY0zeedpQqVNGMqJ0YuRovV+Kp9Ne80/pbJHIOUsxD7P8KEEFhEGmmcQ6X+P3bI35LHD4joYVDdJVRA6M//2xod+WDR3Nzs93d7ezubN2+mra2NE088MeR6Rq1AAVCnNRBjsKEIBRUDqjiwADWduoMIxXrA9XQRTIUXKPNhKAwlvPBIqdv7S0nszSIouDzmYjaYN6HXH0OKR/RZ8BrlWqJFPpGKNxLkSux+X8f9XXvr9sHnVoAee79BvpasRgNPLZnPs+t2cslbn6PpkudPX0hsuHe7qacraSj2ExBYIApV09NTSxAoBbje2L2w9qep8GpnJlPrXMCHbZ+xpOREpkxowBw2gUg1MlAoi37bBBCGgwSyfTEmeratJ+mmVD5u/YwytiCRPk+PUOn5ruhIHB6N3uLpQGHpD4Uw2HMs9BwDXf03O6OZDGMaupT8tu5JjrMuwikDeygoQkWTLnQpsIpMctVbgG4hcF1ZFM2GFlrqWsnxHE8t/8SNA6dsJEzEYhRRxIm59JStbWIqAE7djplpGNRZTJRzyNYTWMfbNFHFydxEbK909KpQOTZiIfMss7ir/OfM02CvcOChjU4qaJN7ceE1Yp4gbkZKnQbtT0juQSD8xvRwxLEY48D597//3eeYx+PhuuuuY+LEiSHXM2oFih07xjNxv0lBVxKkA0UgcEtPvwJFfwZjobogDtVNsTJOJbtGG7hgDw6F4aqZCLY4tlHhrmK2ZQZktlJYGuW34HlkB0aiMYi+kf0GorA0KqAx4mDoqYIFfyGvakcOZ1tzOHsyrFGWs2xvBd+d6t+PocSdGC5jzN5+/z3/Nk1tCbkfVhrsTPccxZ86XyTLlI5jdxZQgoZOWkoiFVV9J47+2mrEjLuHK2J/QZA2ObaSaxzP3JRW37GhLCKzkgPvc+8xRg1olDmYuCKDYTBuwz37c11ZNCoLODnTihCCj1o/pcHTyN/5PrqIJUE/GpsyjXZZgkTHKKORogUz3REie25TFXjOp3HmauasPYs40tktJM36NhJVfw1Sb9rYQyu7qNE+IZxUog33c4rnFtbzP97mt1zF46wrjyCmV9gHs2LmdO5kA+9TI4vR8eCiFgUjUSKPTOVCwkUqHr2THRSynBeZx3lYsQXdTgvEmLBxaDAYDNx3332cdNJJ/PjHPw7tnBFu07AzkgukWRma0WPvSG+HkoMlQPS30CzIdJHr+SV/aXyZK2MuIcmY2GchbJIbiBV9YxUMZGDYRZbSQYlheKLZdWkpAgkFEzrn8vudn3KM4v0t1L3ckfLsGOj8gewprNjI41jCmo9mWmb3d35hxwbAK1AUUUgHLcSTSTITAtbTdY1WqROn1RI9QJCh06JOYa+zb8CuQ7FYdAkATxat4IHzMw6ojp4MpJHoSZc9TwwpFJZCLOegUk0De5jPSbQqk6jSP6RGW45Ew0wiLXInTmqxkk2MmEmEMp5IMaFHfUfTiBEXnUxgHrWqHfa7d0upo+FAoNIitxOjzACgSHuJKCYyxfAjNnkeIJI8X32zPcezgr+zgy/JpIA9tdG0EcW09HqaNDvRahTJ5GLhKxKI41x+xAq1Eh0NU48tToMSzln6fSznRTbxISdwHeOZS2Fp323Q3vTcHulNoABwHunBLYNvfY0xeMxmM263G6NxYJOCUSdQBEKT2rBtU/THwc5YGSqHo/tsvCGOS2Mu5FX7v7gz/paAoWxVYQpw5sGht+FhMAPXVq0Ne3O3Bmyg7aqBFpKeNFGJCUsfF9yRxKulWMIWPmEJ5/mOR6lRbKQQCUSTRDaz2Mf6gOd3IaXETBJlbOLEzOA+/Hl5RVRWd/DW1g1MnLyHXTsCCymBGMn3K9uTReOGzANO/BaKINGffUsXVi5mpjyTarmeVv0jNNoRCEzEESHGeftavomDetpkEWEygQZ9LU1yHWEk8B6TGS8kZWopnVoNtZ7PMBGNgoV6vsBMMlHkkaScQLn2H8LJoEGuJEU5BYBphgf82vOK+DVIwQc8RZo4mwhlPHb9Bf5Wvg07VaQwkUjimc2ZrODv1FPGsVoWX6mNuGULRuG9f++7NpMExvEy91DIO3zKnwC4iAeJJY0wAmuZA0XlDNTXXRQ7S4lRh665/DbT2dnJK6+8wvr164mIiGD69Ol85zvfYe/evSHXcUQIFM1aC5FqBLrUCRuilmEoBJrsqts6eWnTHq6ankui1dz3pB4Mh6HRwRQmBrvvn2ZMZbxpHOs7v0HWH+tXxiqyaZelWEXfIEEjSW/Dw4EmqU2OLUwKy/UTOELRSITSVzGkhtDiwRGKhseNgyIKYb9A4W3rTF98Tm8dLaR6DH42D/7ChE69/AqLyCSRCaxsX022KZNUY2APjpTwaJakTEEVyqANMQP193AIGmdN9I69oWSK7W8M9H72oWrdAAzCSoI4hgSO8R1zynraZQmKcJEpLqRCfxc732DXv8FrFOFNjFbPamxyElu1tQAomHHQiLY/aJiDajKU8zGJaNLEmThpYLK8l3AlOWBb4sV8wmQi0WIqtfJTPHobbbKIdqo4nuuYxklUspMveImTuJE3+D2p4gw8eictbCFOLKCdElYalrDQY8NKNEdxISt5lXmcTymbWcZTuHFww3631d4xVHoSyjvlYjK7qQmxtw8/KioquO+++3j//ffp6OhgwoQJvPjii8yZ43XZl1Lys5/9jBdeeAG73c6iRYv44x//SG5urq+OxsZGbr/9dt555x0UReH888/niSeeICIi+PZybW0txx57LPX19eTm5lJYWEhubi4PP/wwy5YtIyMjNE3eqBMoAg+qKCQ6Ljp9ku5ASW0GS6iTYIIljAXpCVz7zgre/s5Jw55k5mAIEMOVywPgxMjF/Kb875zFsX6ThZkkGmUhnbIKh6wiRVnq01jo0k2L3ImOi1hl1rC1pSeBxkfvvi12lfKG/b/8JvVB3+/95dkYzn4bSWJI9SXy6knvhW+XCvvY54t70BOJholYrCKLRGzMscZS4izjjab/kGJMZlGEf5rsvKhkfvTNf7C7OrGZwvvUB4NzDex5/GBqCQcSJg9EmAhGmIgnTHQn8UpSTgC8Qp1D1mIQETTLrezTX0SgME35NWGKjTptBaXy3xgIZ5xyI1FiIqKHJtdMImYRfKsqXllIvOJNGBUtJ2OXW1BlBBnqeUzTvNuVqUwii+m8I17BJqaxW38aULCQjlXJRMXs1w8LPUuYyRLcOGikjGp2ITDwuVKOUfFf8PoTLoJhwtxvHpnDmaamJhYtWsTxxx/P+++/T0JCArt37yYmplvj8sgjj/Dkk0/yt7/9jXHjxvGTn/yEU089lW3btmE2e/v60ksvpaqqio8++gi3283VV1/NDTfcwKuvvhr02vfddx9paWkUFhZSV1fHtGnT2LZtGzfccAPf//73+cc//hHSPYx4pMwDpXekzDtFaDfWxYEKFkPNJ7CppoEIk4mcmMiAv4eqneg5WWkmHdU1/IG7RmIh7Nnvj5X+lxxmk77fJ74nutRollswEet1jVPcuGUbMWIazXIrNmVawPqNZh23Y3B90TtqX39scWzj7eb3uTX+eqLV/vsnWP8Nx2Iy0EQqwjVfyO3BXLfN8yqz8Rrv9XdOg74Gq8hC011Y1e6vFCklzXILNqXAr1+/aPuKWEMMk8JyMe53487LK0JKyT9L1/P83hV8csKdAa/Vn1fUQLgMYPIMr3DR33UH0kgN5dm7ZBNtsohYZfbAhYOc3xq2FuGIxy2bKZNvEM8xpKlLfdsPPfHIdqTUaaeMCDHOF90SoEOWYxHpfc7Z5HmAXPUGwoW/dq1V7qZdFtMid9EsN5MslpChngPgy+DZGyklHtrYqT1BJ+XMUf/oK7dX+xOZyoUYA7ibD8Rsj4lnuWZEI1SORKTMH/7wh3z11VesWLEi4O9SSlJTU7nnnnv4/ve/D3jdPZOSkvjrX//KxRdfzPbt28nPz2ft2rU+rcayZctYunQp5eXlpKYG1oomJSXx5ptvcvTRR1NUVMT06dNpbW1l27ZtLFq0iKam4EkIezLqNBSDJVC2vGAEEh4qO+2khtsGfd1pScGjrg1FmAC8uULqh253cLC+oHv38SxOZxl/4Hx+2sdoUBEq0eTjks20ye3EMo1IZb/6ToJHdvpNdF1YYj00Vx64DUbvVNzgtcn5Te3jPJP2GJFq/14owQzuhosu471gKLEutIrAX/z90a6k0KrX+wSKYJhEnDfmCxto0/cSKcbjknasIhOD8N/3LiyNoooEmrDSYFuNxRCOioGyqnLCVAML48exsr77Hbvoqz/xwtxLiTaF+wkCHW5vAg+LMfTpqd0sMLXJQSV7G+yW40iGUAcwiRhixdCEia7zc+IX01xpQpcaNgr8NBs96ZAVbNV+4ftbIZws5UIsIoty7S2cNFBg+BnQLdQuV4txUkON/hnZ6qV+9UWKXCJFLsmc7Hd8ned2wslgsno3ivB/ng5q2K09zVTlATTR5id0ZCmX0CBXk8hiX4yLUFmjNsPgnOFGlJYW//kwLCyMsLC+Qsjbb7/NqaeeyoUXXsjnn39OWloat9xyC9dffz0A+/bto7q6mpNO6k50GB0dzVFHHcWqVau4+OKLWbVqFTabzSdMAJx00kkoisLq1as599xzA7axtbWV9PS+c4Gqqr4U56Ew6gSKQJN1qOqwoRBMmBjql9CBpLXuSjw2FA6lOj6CWMYzl29Y5peeuQtFGDGLeBzYUHpkIY0WU2mSGxFSxSLS/CbHrmREB0LAaH2ucv7c+HduiL2KSDVi0P02nMJEzzqDjfHe2olQcMkmmvT1JHKir/5gRIrx6LiJYiJRymRc0o4iTLTKvWh00C5LWGk4HgBdeojSGumkhXj7cQiszMpsAft0n5ai0dUdIvuU5Dx+9M1/OC5xIt/P7xbAL3zzMxKt4fzljEUhbxl2JRGDvoazPRmMEDHSAsRI0PVeKEIljMDCBECYjMdEHC7sqIQxQbkRF01U6x/RzJaA59Tqn5MgjqZV7goq6PdmlvokQMDnGC6SmajehiJUlF6RRQzCSgLHhixMdMpKVKx+3iUHg107swlXAvdDp+5NItnb/uBnP/sZDzzwQJ/yRUVF/PGPf+Tuu+/mxz/+MWvXruV73/seJpOJK6+8kurqasCrTehJUlKS77fq6moSE/23sQwGA7Gxsb4ygUhLS6O4uJjs7GzfMZfLxUMPPcQxxxwT9LzejDqBAsCub8GmeIOySKnzIj8nSTkJm+JNLNWfgNE1GRzIVshQhIkDESQOhEMx+fX2MZ+T2cIsuZBf1DzCFNcJvufTdyGTqD0mKSEUYoXXhqJNFtGuF6NiJUpMGlK7ei/Mgfr76foXsCgWjrYu8LV9oD4cCSEi0DWGS3Au0/9NpnoxG4UO2IOW65DldMoqVMxYRTYAJuFtg1kk0aR/g4e27vKU4lLH4aaZdK2VMKx+XjS5k/bg0rs/Ha8bvwjGL2J5zS7fsXs+WoOmS5KsZrY3NJMfP7R7Hi7tQ0/6GwcHYwwcCLp00U4ZVjJQhIkm1hEpcslRr/IrF898HJ5ajH1Ch4FGJ3HKUZhlMu2yiGgxZcDrDiQQmkVS0N8EAoes6bdMF723YA4nysrK/LY8AmknAHRdZ86cOTz88MMAzJw5ky1btvDss89y5ZVXjmgbTzzxRN566y0WL14MeD0+YmJiyMzMZNmyZSHXM6oEinfffRfAJ0yAd9GxiRlU6e9hlxvJUi4J+nL3nJADuSOF4hd/KIWJjnQn0dtHxyPrLbgpQsGihJOSvJv66qkBz9EIHCUQIELkgMjBIztokTvJzsmkZN3g+6IroFXPtvWkydPJD1Lv9E2Eh9MiEkioMI5vx9kY+taPLt3oOLGItAHLSnSixKSA++8AMcp0bzmp0U4JTtlAmyzGIlL5WinmGN2bm7ZLqNi9cwJ72+rw6BoGpVuzcvnx3vbXdzh4eUsRu24+jy9Ka/imppHI2hlB29fznQlfXILVMXg995EmSCTkOPu8F1Xah5TLfxNOGkYRSapyBvv0l5ilPt7nfJdsRsNBO93zoC8YndaBmUQQkiLtRVI4jQRx9LAbnoP3Q7FF34OdjWSp3xn2+g8mUVFRIdlQpKSkkJ+f73csLy+PN998E4DkZK83Tk1NDSkp3d5UNTU1zJgxw1emtrbWrw6Px0NjY6Pv/EA8+uijvq2ZhIQEnn76acaPH8/ixYsxDCJZ4uhYnfZzxhln8CDP9TmepB5HEscFNf7povfLHywJUqg4PBphqtLvNQ+VZgIGr53ob3Icjq/jG+Ku5pn6P3FWYjudtUcFKDHwxCQQuLEDQ3c37VqYA/VPFtMwiP5fi8NtEelNf8GtWuUuIkTocSAGwqO30yDXEKfMJULJQUp9vzFtAZ+z2We0WVgaxawMO8mGRHpbgUspWV1Rx9n/+pQL87KJNpvYZ29lV2MLRwd5zL3fmeqaeLJDdBcc6H0L9b053McBgF3fTLn8N+nifFLUk9mtPcMO7dGg5V00YcDCOK5CSt1vy0HFhI6bSJHLFPXH7NNfJkKMwzKAHc5QkGjskr8ngklUaP8jTT192K9xuLFo0SJ27tzpd2zXrl1kZXk9ssaNG0dycjKffPKJT4BoaWlh9erV3HzzzQAsWLAAu93OunXrmD3ba4/z6aefous6Rx0VaM71EhER4XMr7ezs5PLLL8disQz6Ho6oXN+DlZR7TgiFpVEUlkaxfXuO7z/wqqH0Ho4wZduyKduWTavTzf99to5Gh4vNtY2srqgLeI1QNBojES1wMMLESoN9wMlxqJNnz3ZEq1F8L+EmNnVu5V1+R7anhp5ORhqdA9aninAkGp2yig5ZMaQ2QfD7CcNCu97ep+2HkkZ9g+/fXc+q678ipcOv7EDPskGuxSYCe870RsGATvAcGXZ9Mx2UoRBGmyzCLVsRQvF+4coSn2ZjpcGORPKbstc5LeoU9uzs9pl/p2ITC//0Cbd/sJpXzjmWp5Z43U1/+dUmchnc1tZAgkLP9zoQXXNAKBzuwoQ3rfgX7NafxkAUKarXWHK8ciNz1GeYa3gWVfSNkxMhsslSLqGcf7NPexmP3kGd7vU6cNKICa8LsUFEECOm0SkrR6T9ijASxwLa2EmrDH1+7JRVfKP9bETaNNLcddddfP311zz88MPs2bOHV199leeff55bb70V8K5vd955Jw899BBvv/02mzdv5oorriA1NZVzzjkH8Go0lixZwvXXX8+aNWv46quvuO2227j44ouDenh08ec//5n09HSSk5OJiIggNzeXV155ZVD3MGo0FF988QVnnHHGsNfb29e5p6p++/YcPmldznlTo3DqGonmCKz7XYTse3O5ISmL9iIjK50fcuOs4JNfV56Pg8FILoJDNYj1z5IZRS7XkEwDG3mPFq0eq3oeKiYMhOatkKAcTbhoxyF3hqS6D0YgjZWdGsqrcqkIoi05FAtJrDKz398H0yZNdtIpy3HImv1ugf73aSLaF6vATDKNci0GrCiYfQK7lDpNcj1mkeLrf6/772YspGMT06jWPyBNPQtdajTIr3mTQrKYQVTjGRDh1QY6NQ/vVGzm5QVXYVIM0All26DD48Kimjg2qVvwCDVM91C0fYMVvkcD+/S/0iTXIzCSr/7Ad1wJIaKwRUljhvIIzfo2dul/wE0LYSRjJsHvoy1K5LFLe5pYMWfQnhihkK1eikGzovfRafXFKetpltsp0/+NHsKHyeHI3Llzeeutt/jRj37Egw8+yLhx43j88ce59NJuj5of/OAHtLe3c8MNN2C32zn66KNZtmyZLwYFwCuvvMJtt93GiSee6Ats9eSTT/Z77ddff5077riDH/3oR4wfP57rrruOhx56iHvuuYfOzk6uu+66kO5h1AgUpaWlrF271u9Y19ftcO3h9Uy007UInhi5mOYSeMP+X9r0Nn6zaIGvvMXg3ftdaj6Vsm3eY1es+iufXHOcL+31huoGsqMHnwBrKAxFmDjQCbJnn/VH77ZFEscxXE4lO/lAf5FoOR2V8EHpzMJFCq1yN5Eid+DCIfCZugdd8wTNhjlaFpP+UYgUkzEQjoMavAJF94Rtl6Uo0ogu3bhpwSVb6eRDhFCQUidCGYeGE5so8PvCVYRKBDm4sBMm4vcLE2726M9iEzNIVm/GLUyw3xtj+/YcIjLXMT4iwStM9MDu7uC0lHziwyJGNJDbkShIgNdOxiGrmazeg4m4gIHJQiFaySdSTKRa/5A6uYJM5Xy/300iBhMxOGV9vwGyhooiDMSr89mjPQtc2G9ZTToo1f+JxE0aZ1PBf4e9PQeDM844o98PZyEEDz74IA8++GDQMrGxsf0GsQrEI488wq9+9Stuv/12ioqKEELwne98B7PZzI9+9KMjT6CYNWsWeXl50CO/gJN6r4FZjz28Fn0nUcrQvAC6CLTHfkHm2QBs3x78vLy8In6YfyoV27sNZoQzgX9uKWZpAG3TYCfL6O3Bs6oeCmGid11DsbMoNiSRJs+iTluFTZnaZ982EFLqFBeaMeJ1gRxkNuygNMsthCnHdEUyHhWUrBtcpt0U9RRK9dcZr15HeIDQ313W8s36VqLFFO+CQR0m4vDQipOGoFsmDmoJw+v+6ZSNbNN+yTjlKmxKga9Mzyyv9pLpbK/7wqd96HofPm39nCRlTp/3o3e5nvT3bvTmcNnKGglK1lkp1/9FirJ0WARtRRhIVZcG/d0oIqjWPyFDnBtwC6U/PLIdDQdhInjMHotIJ1O5iF2ep5houC1ouXCRSqb4Du3sI14spEIfnQLFoWL79u0sWbKkz/EZM2awb9++kOsZNQJFQkICuu4/05tF3xCr/Q3OwdD7yzuUSaiwdAZzMnPY3mtbcRwFbG8+8DZ1pDmwVPR9aQ+HWAmB6g1VwLCQgUd8gFVkew36REHAci1yF7p0IRAkjzewa8820pQzD7DV3bTKPaQoS4a1f3r2wUj0e0KOk7qi0PPXRIhxNBFHs76NaCW/37Jd71JXumwTMXTqVbQTOAeLihmJhl3fzB79eQrUnwUNrNQ1Ztsw83WpGegWEjZ0buJ7CTcFPK9LmGjRWqlwV5Jn9n48BHs3gl33SEJKSTvFtMqdxOc4EHtV4pQ5A584DGQpl1EvV7BT+z0JLCZGmYUhxHxKHjrQ6PQJoeCNJxFGol8QrAgm0sA6NOkIKrQIoWBTpmIhDZVDl3RwtGK1WnE6+3rZbdiwgXHjxoVcz6gRKBwOB5GR3WGsO2VlQN/jYBNYIHTpQhkg4+WgF4H9LokeXNSwl7T96YAhtNgX/U14os46pEBGPTmYqtuBtBZdbVGEEYkO6Iggex66dCGl2+cy7KnSseINHTwcGoom/RsMWAOGGz6csVcOnFK4NynKEor0PxEl8wa9XRit5NMuS2iTRV5X3h44ZQPRIp9OqkkWJwV9F7ueu0vaadI9GKSJwlITczJbaPQ0YVWsvrDdvdnQuYlkQyKV7mo2dG7yCRRhdf2/xwcqSAyUFv5g0y5L6NDLaWLjfi1tBjZRgLEqjQw1cLj/kUARKoliMbHiKDZq9yEkxLNgwPMg8AfhHu15nNSSr/wfe/TniBNzSVPPJFWchobTlxskECZhw4QNTY5OG4pDSUFBAYWFhUyd6p1fNU3jl7/8JY8//ni/2yu9GTUCRUZGht/kt1f7E+OVG4JmygsFBzVYCC2LWqh0TToLPNGkMNHvtwOd1IYaZrmLQzEhBhMqAgW1MokY2mUJ4PWHNxKBECq69NAhywnvsdhbYj0YOiMYjv0JKSU18hMmKt874Lp6M9J9PpQQ5AYRToQYT6MsJE7M7fO7lDo67qDnW0UWjfoGWum2X3HLFgQqijASzRSq9GUDunGX6K+SrpzNStG9xbiZNcyMD+6Fss9VQpOniaimM5nBsRTuD7yppnUe0LsRCsEDsh08pJQ0yjU06ZswEsl49VoUTL5twug4F80j43jRLwYRToH6M0q014jRZ6EOMetzvvpDdmiPsVX/BSmcTqvcS5O+gZgAhslS6nhoCxonZYzQufPOO31bG6qqYrPZeO+993jssce4/PLLQ65n1AgUvZlq+OkB12ERwytM9GSVYRj2OHqRld5OSc3g9swPBwaagD2y3WuQCSgYadWK8IhWBCqdsoIw4tGkA4Po/vKypbiprYinVe5Gly6MIprIQcRXcOuttLILgUKt/JxoMbVProHRgC3FPaScJsniZLZrvyVGzEDppQ2wy80YRP+GxFaRRbPcjFvvQBUGnLKZRNWbmVIIQRt7aKOISMYHrUOi+TRCXWOkzrOOvPq7KAyits7k0oDHDamOERcoujiU2op2iinSXyRP/UEfDREMfTwMB2Eijk4qWa/fQYF4cEiGmqowk6/+iAb5Nfv0V5gkbidSTAxYVggFgzw4Bu9HOmeffbbv31lZWVRWDk0qHX0z6BhHHE1yI+HCa8gaIXKpl1+TpBwLQJSc5Fvw7PoWJBrhwquVChOxPgt2u74JycAGnW7ZSrX+EdXyY0AnThxFvDj6oO05B2Kk7SwC0VuI8PsNQ7/CWbssxSNbSVSO8x2z65v8yiSIY4NuX3VhJIpOWeV79h7ZQbNQMMixPfBgeGQrGcr5AYWJw4Fp6i+p0T+hQn+H8eq1Q6pDCEG8WEC8sgC3bOtXyzUS7qpjDJ0xgeIwQJcaTup8C+W3DYFCGN791HZZ5LeN1XPhsylT6ZDl2PVNJGMDurU1JhFLlfyQFE4JOMlIKamVy2mW2zBgZabyKAZl8JHghpve20HDqVYfqC6LSMNDOyZsAX8PhEs24ZFtRCv+eRwUwnxGcx7ZQYcswcBJQWrxEiYScMkmn0DRJNd5PUh6hB0Y6eitow273EKScsKhbkZQhBAkiGNp1f9MmfZvEsSxmJXQ7dp6YxxAUzbG4cWYQHEYoAiVMDk83imjEYkENN+eaKwIri2wiHQsIh2VOpp0r2bDLJKwiHQcsgaJB9FLXe6U9WzS7idJnECucvPYV81+osVU7HIzicI/m6BHdtIqvanKtf3/jhKTkXhok0XE7E/Y1hOjiKRDVlKrf4pEI005e0CVd7xYxF7tOTqpokOW4aGVCcqNIQtTPctlKR2UGAZvnTtUoeRQbHvo0o2KhQZ9Nenq2QOfcIhQFRO5ys0Ue15ns7yfWeIJVDE0m4oxRhdjAsVhQn8q6C7cjiNzIXTIamKV2XgzdYTmtSAdERiE1a+8Lj3Y2UysmO1X1q5vRWAgU71oOJs9LAQyWh3MQnUgYyJMJNCmf93nuEGE45GtIMAuNxEjZtEqdyKRxIiZfVTQHbKCVn0XNfILEpWjSVZODOn6JhHNJPUu7zWU6YPy0OrNUPthqNFfDwU6LqqlN/NjOoEFisNpjshQzqNZ3zImTHyLGPTos9vtzJkzhxkzZjB16lReeOEFANasWcOUKVOYMGGCn5vJJ598wuzZs/ntb3/rO/bggw8yZcoUCgoKmDNnzqACZ3ybqdwautGZS9pp1NeNYGuGDyf1hJGIi0ZkVyjFAajYEkaL3IlKGB7Zjl3fTFgANzSAMOL71Xocanrn5xgM/Y2JgeqzkE4H5X75VLpQMdOkbyRaTPF6bihTsClTA2p3PLIVAxGEk+IXUyAUFGEkVpl9QMIEDO7dGIhQnsehMMo0CCsJ4ljCCN5Xw9kPB4qqmFAw4NLth7opfRiOdWyMvgxaQxEZGckXX3yBxWKhvb2dqVOnct5553Hrrbfy2muvMWXKFBYtWsS5555LQUEBzz//PF999RXXXHMNbW1tbNq0ic8++4yNGzdiNBopLy/Hah19nguHgtQpnSFPGEaiiBKTR7hFB44uPWg4UAmjWW4N2TgydaoDz5bFOKhFl05vnArhIUbM6FNWCo1OvWqYW354MJgx0RshFKLEZOrkCiyk+xn6RSmhj50oZTIe2U6jtu6QjbkD6YeBOJziT2Qpl7BTfxxdagHzcoxkPwwFAxG0yWJimXGom+LHga5jq1evPtS3cFgyaA2Fqqq+tKZOp9Mbpa29HY/Hw7Rp01BVlYsvvph3330X8GbrFEKgqipSSqqrq4mPj8do9Kqq09PTiYmJGcZbOnIZzEQhhIJBHP6Cml1uIkpMpEXuJFpMGfiE/VRttWAUEUSIcV7PDyWFGGWmL7FVF27ZQo38hGw1sLvhaOdAF48UsYQ2vZgmfQN2fRNN+sZ+Y1CA18DVrm+iUV+HLr3ZSOvl1xhF5KDDLw8Xh9MiOpIIIYgTc6iVywP+frj1Q5wyFyn6H0+HggNdx2pqag5l8w9bhrThZrfbmT59Ounp6dx7773U1taSltad9TEtLY2KCm9q6auvvpoFCxYwdepUIiMjOfnkk9mxYwf5+fnccccdFBYWDs+dfAtIyOkbGnX047Wb0HFhEKFPhl190axvx0h0n6ipunTRKndTor9GpnJRwFDRRwIHOiaEUMhWL6WDMqJFATHKDGKUGf2e0yQ3ECFyUbHgppVGfR1uaSdL+e4BteVAOJzfjYUem99/B0q8WESL3Bbwt8OtH1rlbqJF/yHeDxUHso4df/zxh6rZhzVDMsq02Wx888031NTUcN555zFnTnA19dKlS1m6tDu5TGRkJBs2bOCzzz7jk08+4eSTT+af//wnJ598cr/XLCwsJCIigqzZ3tB4bodC5dZwn4ovIceJJcZ//72jyUBdUZivTOqUToxm/8iK9iojHY0GbKlu6orCfPX3pCtXgjFcp6PRQOqUvqFdK7eGY4n14O70ymiBXuySdVYScpzYK41YYj3YUvwl94HuKTbT5WvPkXJPVtmEas9j7559g7qn9OkdmGKaiZVuFFowUkHzviTfPVXWbydySiExRJOm2ID2g3ZPcPDGXmymy9fOA7knS+c8qrdsJn9q7oD3NKkgg22b15NfkEuYWVAvq0gUpyDoOGRjLy67b3sPl+cUpnttVFxbolBiXVhcnpDuqb+xN2lqBto2F0nj5WE9R5hlKo71B/l9SnLB3j5N7cOBrmNj9EXIQBZZg+CWW25h/vz5/P73v2fDhg0APP7443R0dPDjH/94wPMfffRRiouLeeqppwL+3tLSQnR0NM3NzURFRTHP+NyBNHdUkzW7fdDZJQ93SrU3iBKTMIoorCIr5POyZrfzzdq9RIl8QKddluCmhWhRAEjWa3cAMFP9/aA0H6ON4RoTmnSyW3+GCcpNIfeXQ9ZSrL9CpnIRFpE28AkjyOH+bgx38LJGfR1OGkhRTvE7PlA/uGUrjXId7XIfOi4kGnHiKKxiHCZiBp3bpT+csp4K/V1y1KuGrc5Q0GQn67W7fGtGKAx2Hetal55Pf4JwJfD70ql3ckP5HYNqx2hn0FseNTU1tLa2AtDc3MwXX3zBzJkzUVWVTZs2oWkar7/+OmeeGTgL5M6dO9m71ys+SinZsmULmZlHpjp6jIExCRtSShyydtDn1uhf7M8fYSJSycUmZmCX39CorwVglvrEES1MDCeqCPNmE6U8pPKtci/F+ivkKFcdcmFiNNBTiBiOrQ+rGIdDVg9Yzi3bqNE/Y6f2OLu0pynV/4mRSDKVi8hRrmWccjUu7FTob7NN+5U32d5+avTPkFIbUvs06aBI++thG4TrQNex3bt3H8zmjhoGLVCUlJRwzDHHMH36dI455hhuv/12CgoKeOqpp7jkkkuYOHEiS5YsoaAgcArqtrY2LrvsMqZMmcLUqVPRdZ3bb7/9gG9kjMOTDlmBR/ZVp3bRKndjUdKQAxgC9kbHSQtb6BlWUREqOk7q5dfMVB8d838fJB2yDAP+kQmllEipI6XEI9tp0jdSor1Gvf4lE5SbMIkxg+qhciB2FbX65xiJ9jsmpYaHDjpkGU5ZT6esZK/2HEYimajczkT1Vsar1xKrzMYgrCjCgEGEk6ycSI56FZFiIqX6vwBvKPVS/R+4aR3SvRXrL5OoHHPY2i4Nxzo20vz6179GCMGdd97pO+ZwOLj11luJi4sjIiKC888/v4+BaGlpKaeffjoWi4XExETuvfdePJ7Q3PEPlEHbUMybN4+NGzf2OT5//ny2bt064PmzZ89m1apVg73sGHj3EUcbKuEoQYJVSamjyQ6vqjVIMqhgtDV5VbPl+n+JV45CwYREo15fRY567YDJrY4UhnNMxCqz2aL9nCzlUpyyHheNuGnZ37cedOnCpkwjXlk4qO2pg8FofDd6MtiQ6zXyU7KVS3wxRBrlOur0z5EN+TTqbtw0ITCQoV4Y8qKeqV7AJs/97NRqMOwPa98idxIvjhrUvXTIClrkTsar1w3qvFBxyxYq9HfJUi4Z8hbNga5jM2f2zX46nKxdu5bnnnuOadP8M+/edddd/O9//+Nf//oX0dHR3HbbbZx33nl89dVXgDft+Omnn05ycjIrV66kqqqKK664AqPRyMMPPzyibYZhsKEYacZsKI5cGvTVuLCTII6hXe7rkx+iP6SUVMr3qNLfJ67HhJesnOTLDTHG4HHKeur0ldiUqYQRh1FED3zSGCETijYiFKFCl26q9PdppxSJTpSYRLxYdMC5L+z6Zkr01zFgpYNSAMYr1xE7iOR5e7TnSFJOHFT238GgSzfrNK9WO0+9jwgxzu/3odhQDJbB2FCUlZX5tSMsLIywsODa07a2NmbNmsUzzzzDQw89xIwZM3j88cdpbm4mISGBV199lQsuuACAHTt2kJeXx6pVq5g/fz7vv/8+Z5xxBpWVlSQleY3Un332We677z7q6uowmUY28d7hE6d1jAEJZGU9WpFSUquvIEmcgBv7oDUKaVMdpCmnYyWLROVYxqmXM069/FsnTAz3mAgT8aSrZxEhckaVMHEkvRuhoAgjaepZTFRvY5L6PVKUUzGKiAPuB5tSQIH6M58wEUEuRfpf0WVoKnOnbERgHDFhArz3nqN4tR/btUdp1NeP2LUGYn15JIWlUQH/W1/u9QTJyMggOjra99+vfvWrfuu89dZbOf300znpJP/keuvWrcPtdvsdnzx5MpmZmT6t/6pVqygoKPAJEwCnnnoqLS0tIWleDpTRrSf8lnG4Ba05EGrkx0SI8SjCSIdeQZwyd1Dnd/VFknIiDfparOrhpYI/WBxJY+JAGC39MNJRN4ejHxRhYq7hWd/fJdo/6KQSKwNvnbTLfSMqTHQRp8yhWv+QDkrZqz9PjHgGiQ7oA557sAmkoQjG66+/zvr161m7dm2f36qrqzGZTNhsNr/jSUlJVFdX+8r0FCa6fu/6baQZ01CMIo6kr7AGvZBkxRt7RGXwxpOpUzrplNXU6p+Rqpw23M0bNRxJY+JAGOsHLyPRDwnKIkq1f1Krf0GbLEJKnSZ9I2s9N9GuleORHRRrr7JLe5o6+RWRYuKwtyEQeeq93vaJY9mm/Yad2mPs0B47KNceDFFRUX7/BRMoysrKuOOOO3jllVcwmw9NxNkDZUxDMYroHchlNGMVWXhoQ5EGPAw8Cbbq+yjVXydKTMRFE+FhqdToTWSrl42KEOMjxZE0Jg6EsX7wMhL9YBHp5Kq30CTX0aR/Qzn/RUqvV9Y2+RBogW0ZRhIpdarlh6SIJaSr5+CUDRTrrxApcg9aG4abdevWUVtby6xZs3zHNE3jiy++4KmnnuKDDz7A5XJht9v9tBQ1NTUkJycDkJyczJo1a/zq7fIC6SozkowJFGMcEgQqblpwylpixPQBy3toxkEVOcpVmIghUWh0qt9eQWKMMQ4mBmEhQRwDeI0id2lPMtfwLG7ZgoaTWv1zPKINmxLYzXK40fHQpG8kSkxGlxrl+ltEiPEkiePp6Uo+mjjxxBPZvHmz37Grr76ayZMnc99995GRkYHRaOSTTz7h/PPPB7xxnUpLS1mwYAEACxYs4Je//CW1tbUkJiYC8NFHHxEVFUV+/siHQB8TKMY46GjShZNaosREGuTaoAml2mUptfpykpQTaJV7yFIu7mF0GTy2xRhjjDFyCFTixSK2eX5LinIyIGiVu2iTuw+KQLFHe4EOWY6BCDplFU1yAxpOUsVpCKGgydG5/RUZGcnUqVP9jlmtVuLi4nzHr732Wu6++25iY2OJiori9ttvZ8GCBcyfPx+AU045hfz8fC6//HIeeeQRqquruf/++7n11lv7td0YLsYEijEOOm5pp0XuYK3nJtKV84KW65SVgKBeX4lR2LAFSE0+xhhjHFyEUIhWplClLcNJHQ5ZQ7SYimeIQbAGQ4u+A4Egklzq+RLwakzGK9chxJFvEvj73/8eRVE4//zzcTqdnHrqqTzzzDO+31VV5d133+Xmm29mwYIFWK1WrrzySh588MGD0r4xgWIUYa8KHCBqtNFGERJvSN/+vibCRBz79L8CMFd91u+3I6UvDpSxfvAy1g9eDlY/GEUkDqrpkOVkKZewQbuXCEbWhqJTVrNTf5xZ6uPe3D2ymfHiBhShHrHCxPLly/3+NpvNPP300zz99NNBz8nKyuK9994b4ZYFZtQJFA5Zh11uIlk58VA35aDT0TjqHlcfdOmmTS8CwEIWpn5iHThlAwDZyqV9fjsS+mI4GOsHL2P94OVg9kOB+gs2az+hQVsNMGLp6zXpoFz/D7VyOeOUqyjSX8Quv2GW+jiqGBMkDydGnVjXKNdStj/e/LcNW+rg8l0cjkip46EDhXDcNKNg8gkOvWmSG5imPkSCckyf346EvhgOxvrBy1g/eDmY/WAWCcxQf8Mk5W5mq08Rrgy/F0G59jbbtd9iErHMVp+kWv8Iu/yGeLEgqO3VGIeOUSfWpypLSRFLDnUzDgl1RaM/2ZUuXLSwA51OdBx0yhrCRTphxPnKNOkbqZXLUQjD1ON4T46EvhgOxvrBy1g/eDnY/WAU0SMWUXWt5yYAZqtPoggTHbIMHadf0K0xDi9GnYYCOGL3ywYia/bo92yo1P+HhjdT31T1J5hFIhYyfL+7ZSs18jNyldvJVW8OmvznSOiL4eBI7wenbECTzgHLHen9ECpHSj94dO99xDCXNllEmyymSPsrOeo1h7hlY/THt3NlHuOQoEsPtXI5ADYxg3CRikD1ExoMWAkjln36i7ToOw9RS8cYLnTppkJ7e8jnu2kZxtaMMVowKFamq7+mibWU62/RqK9lono7ESLnUDdtjH4YdVseY4xeFGHASg7tFGGXG2nWd/SJrieEwjj1SrZ4fkEV7xPFpEPU2jGGg64kVkPlYEZfHOPwwiRsTFbvxUoGihjZLJljDA9jAsUYBw0pJe14PTzMpOGUtX2+OHTppkj/C9FiKqnK0kPRzDEOEaGk9g5EqAm3NnseQMNJtnIpNmXqwCcMgp5tH+kEYN8mIsX4Q92EMQbBmEAxxkGj59aGgwpixEzUHl8e1fon1OrLSVCOIUU55VA0cYxDxFCFia5zw3RJmsfmW8wD1bcWb7bF3fpTzFWGx7Av0HUW9mjHGGN8mxgTKEYRR4Ilu4IZHQcALWwnWk7FICwAlOn/IlJMIlEcO2A9R0JfDAdj/eDFvdeb16U/weQOXu/+w+P935G28B8p46FEe40okUeMMuNQN2WMQTAmUIxxUIkghxa2AVCk/4VJyp1Eicl4ZAcAE5Qbg/qXSynZp/2VBlYTq8XS6Glksvp9IsWEg9b+MUaG/jQLI0nX9YYqWBxpAsnhQqJyXFCX8TEOX8a8PEYRxvDRn6I5TTkLhW6BYaf+OPs8L7FN+w0Ae7W/BD1XCEEHFahYCQ8PJ44FWMka8TYfzhwJY6InKw12v/9CRYRrIZWbk+nvNeLCgUQedEFmpDhSxkO4SEUVXm2LQ9bQrG87xC0aIxTGNBSjiCMhvHCEko1ZT6Vjv3EmQD0rAYhkCi1swSWbg4bknmq4HwBjs47bMCYPHwljoj/6Eyp6CgF6Y2heAIWlUX5//5P7OZ5rSSNvKM077DgSx0MY8SMWPGuM4WVsRh5FpE4ZnWl5ezPF8ANSxOl9jndSSrZyBcX63ynT3sKub6ZDr8Alm/qUHcm+qNWXs9ZzE2s9N+GS9hG7znBwpIyJodBTi2GaOrR4FZfxKGnkHTFbF6NlPLTLUtwytGcmhDoWZnuUcOSJs2OMCtLVM0nnTEo8/6KWTwCBh1aK9ZcAaGY7tfIzDEQQLxaQpp550NqWqCwmXiyiWH+ZJrmeJHHCQbv2GINnpcFOltJBiSFwVFXo3zbjSBEmRhM6rv9v78zjq6rOvf/de58pJyfzSEICBGIgIYCEKVZBnFCUOtFqrRapvfaqqNW+anuvt/Jii7X0Wu6r9Kq3g61e6tQ6UUAxRVAhKCgyU2QKEDInJ8OZ917vH4ccEkhChpOR9eVzPuTss/beaz177bV+a3oWgqExPCM5jRQUkn5lhOlbZIr5BEQT1RTTZAT99WdpC9CUiH6Ll6qYydIW9tv9JeFFioaBhZxIPTTp1pDH4cOHmT17Nrm5ueTn59PU1MRnn31GXl4eY8aMYcmSJaGwRUVFFBQUsGzZstCxJUuWkJeXR35+PlOmTOHw4cM9T4lk0KIoCmbVQap6BaNNC8k2/Wu/igmJRDL06Wk9Fm6eeuoppk6dSlRUFMnJydxwww3s3996+wGPx8N9991HQkICDoeDm2++mfLy8lZhSkpKuPbaa7Hb7SQnJ/PII48QCAR6Ld4t6ZaguPPOO1myZAl79uxhw4YNWK1W7rvvPv7yl7+wf/9+Vq9ezc6dOwF48cUX+fTTT/nyyy9pbGxk06ZNrF+/nu3bt7Nz507efvttYmNjw5kmiaTP0YUHIUR/R0MikXSSntRjW7ZsCXt8NmzYwH333UdxcTHr1q3D7/dz1VVX0dR0esO3hx56iPfee4833niDDRs2UFpayk033RT6Xdd1rr32Wnw+H5s2beJPf/oTL730Ej/72c/CHt+26PKQx+7duzGbzVxyySUAxMfHU1paSiAQYMKECQDceuutrFq1ivz8fAzDQFEUNE1DCEFZWRmJiYmYzWYAhg8fHsbkDG1Kd8tWezMDzRa14gvilAI0+tax0ECzQ38h7RBE2qFz9LQeO7NXIBysXbu21feXXnqJ5ORktm3bxsyZM3E6nfz+979n5cqVXHZZcF7XH//4R8aNG0dxcTEzZszggw8+YM+ePXz44YekpKQwadIknnzySR577DEWL16MxdK7e6J0uYfiwIEDOBwO5s2bx+TJk1m6dCmlpaWkp6eHwqSnp3PixAkAFi5cSGFhIePHjycqKoorr7ySffv2kZuby4MPPsjWrVvDl5ohjj2+b7qtBgMDzRaJ6kWhdfN9yUCzQ38h7RBE2qFz9LQemz17dqfvVV9f3+rj9Xo7dZ7T6QSCYgdg27Zt+P1+rrjiilCYsWPHkpmZyebNmwHYvHkz+fn5pKSkhMLMmTOH+vp6du/e3ek4d5cu91AEAgE+/vhjtm/fTnJyMldffXWot6Et5s6dy9y5pzd5ioqK4ssvv2T9+vUUFRVx5ZVX8vrrr3PllVd2eN+tW7ficDgYURDs/vF7VEp3R5CW56Z0dwRJWV7sca1fJleticpD1lCYtDw3ZlvrmcV1J824akzEpvmpPGQNXb8lze5szREGrhpTm0uzSndHYI8P4HcHNVpS1tmZ5ui2SJKyvNSVmrHHB4gd5m/1+7nSZLEbWGxiSKUJuveckkd7W91Lx0vZ12BS7FjtartpOrSrkfLYF8nw/hCrEj+g0tSd52SxB48P1OfUV3nPFqUTe8a9BnuaZBlxmi49pxQfHDwrGq0IRz0G8JnmRFN8bZ6jCzfokJGR0er4E088weLFizuMn2EY/OhHP+Ib3/gG48cHN7IrKyvDYrGcNUUgJSWFsrKyUJiWYqL59+bfehtFdHHgd/PmzSxevJj3338fgGXLluFyuXj77bf58ssvAVi+fDkul4t/+7d/O+f1fv3rX3PkyBGee+65Nn+vr68nJiYGp9NJdHQ008wvdCW6Qwp7XABXrVyYA2CL9VJRcxibkopFieWo/he81JKqXkG0ckGH5waEGw0LiqL1UWx7D5kngkg7BJF2CFbkX+gPheqMtuhpPdZcL03WftPuBPLmeBw7dqxVPKxWK1Zrx72Z99xzD2vWrOGTTz4JTQtYuXIlCxcuPKuHY9q0acyePZunn36au+++m6NHj4bSBeByuYiMjGT16tVcc801Hd63p3R5yGPq1KlUVFRQW1uLYRhs3LiRgoICNE1jx44d6LrOq6++yrx5bfsN2L9/PwcPBuWjEIJdu3aRmZnZs1ScJ7Sl/s8XAsKFbnjZG/hPdgb+L75Rb7DfWI6HCnThI1O9lQu0e88pJgBMSsSQEBNwfueJlkg7BJF26Bw9rccOHDjQ6XtFR0e3+pxLTCxatIhVq1axfv36VnMMU1NT8fl81NXVtQpfXl5OampqKMyZ8zuavzeH6U26LGVNJhNLly5l5syZCCG46qqruO6660hMTOQ73/kOHo+HO+64g/z8/DbPb2xsZNGiRdTXB72kFRQUcP/99/csFZIhT4VYT5xyISpmHOQQr0zCTgn79WcI6mKDcdpjOJRR/R1ViUQywAlHPRZuhBDcf//9vPXWW3z00UeMGtW6LCsoKMBsNlNUVMTNN98MBBvoJSUlFBYWAlBYWMgvfvELKioqSE5OBmDdunVER0eTm5sb9jifSZeHPPoaOeRxmhEFTRzdFtnf0ehTfKKWXfovEOioWDBwY+Bj6tSpfP755wBkchsxag5WJRlFad9b4lDkfMwTbTHY7dDSk2dPnHANdjuEg84MefSUrgx5dDYe9957LytXruSdd94hJycndDwmJoaIiOA97rnnHlavXs1LL71EdHR0qDG+aVNwPyRd15k0aRJpaWn86le/oqysjDvuuIMf/OAHLF26tKfJPifn92CbZMCiCw8+amgSx9AJtgYM3FiII039NolKPLnqFdSLf5KoTpO+/iVA+y62+9JTpiH8qEr7E/yEEFSKT5hhjEXDwnr+gGAxCkEx3FYapKfPoc9///d/A3DppZe2Ov7HP/6RO++8E4Df/OY3qKrKzTffjNfrZc6cOfz2t78NhdU0jVWrVnHPPfdQWFhIZGQkCxYsaOWkqzeRgkIyoBDCwC8aOGS8hJtjBGjERBRWkmjiED5qcSijiVSiiVQjz/vty4cqQujUiC+oF3vx0wCAgoLAwEYq8epkHEoWEKyArYYgvYP9OnrSA3BmBe/DjYWzW6UGBo3UsJGXuYhbcBDPJ1oJI/VGPuUvzOP/UMo+oknha4r4B58SSRw6Pt7j18SSQjzDiSGFeNKxE4OCwj4+pjKw6VT6BU1KFEnqxdgZjqK0Pw1OCIGBBx0vTeIIdiUTqxJcgugWZdSKLxAigIGfAI1YiEdTbBj4sJKMhhWbkooJBybF3iWbdZVGcYQIhvXL0uuBQmcGC2w2GytWrGDFihXthhkxYgSrV68OZ9Q6jRzykAwYGsQB9un/iYoVAy9RZNNAcPJTBOnBQlTJkPsADEG8oppGcRgFjYPGCzjIopHDTNB+EaoEAQyhs02/D4AkZSaTRT5JjMJAJ4YUCjO8uIUbk2LG0qKX4Mxty1vSUmB0tIlYE3V8zWdsZzUeGokiiUhiQz0LAA4SUFAI4MOHGwfxuKhDw4wZG5UcJYZkYhlGLrOIIiGYLnSclFPFMRqoopyDeGkCFOzEcCU/REFFIPgbP+c4u0liJKqShYIZH9XUiKBPnxTlMjyUAyoqFhQUopQc6sR2TERhJgoXx0hT56FiRsWMiUgaxSEUVDTFjkdUMNJQqaMcF078eBAEqwoVDQ8NXMLtpJJ9lg27Q5VRTKNxmEx1Pn6lodUz7yqDdchjKCB7KAYRSVne0NrwoUiFsQEAAy/RyljqxT6SlJlkqvMRgKac9vI21G3RES0rPdOYRgJfO3r1fuHubjeEnyaO0CAO4BN1+Kg+9X8t6qkiKUObj4r1rIpFQWWUugCHMobJehTH2cMePiJlTCyHSt9kc6WXCNWGzVFHQOg0NJyaT2CDeo8FDRPX8GArEdCWiChlP8fZQy2leE4NuZmxcgEXcQ0PoqIRRSJWwtNyV9GII4040s4ZNo5hpDCaTPKJEgls02qpF/sI0MiEMZdTdygJGylnzSdKEhcToJ4ATViZh6q09poYp0wK/T1Hn9LmvQ10BILnuJ11vEAUCdiI4huB77Bd82MQAAxULKFhSJ+oxaLEdZimRHUGieoMdOGmwthAhnbjOe0gGXjIHooBSHutJCVC51N/Q99GphcxRICT4n28ohIrCaSppc72XgAAHRdJREFU1yEIsE2/nxz1R+w3lofCRnEBo7TvUWqsYbh6PfYIB35Pt7aiGXR01GpWInQKks52StQdOmrFd4aveJ+veB8/Xm7jKSKIbiVGqo0tVIvPUDBhZzgxah5mYrEQG+q6F8JAEDirsmuPZtu0tMO4cYdahdm7NwshBH7h567ji7ib/yGCqDav56SCfXxMDSeYyBziScdG7wq2nnCm2DPbjLC8Fx3lOQgO76invA58wd+p5SQ+XNQoAoFBvdiPXQk6dPKIMuzKcGKUfKxKIho2zEQxSx/ZSti1RXfErOyh6D9kD0Ufc64XtSPUeB8Xnej++f09sUsXXo4af0HFzAj1NrbpiwCFHPUhKsQGDum/p4atxCh52JVMppqeB8AlTnBQf5Ed+uOMVR/BrERjj/fhLO1dv/T9RXt5ZEpmPYYwUFuMm5fFVVJWYTB7QrAy9eh+bFrrCYFNAS8mRcOqBV/3XXWlxFoiSI+IZZfzJAu3/JklKf9OQUYmLuEiUg226nWho53y19EsNqo4RhTxWAmGEQh8uPHQyAn2ks8VCAzeYxk2ojEHrFixU61G4BIlZKv3dTjurygqCl1/rnnjaqHKcpaYAMi64J+sPbmb/9r7CVMjJnNJksAQdXiEh5ePf04jNUQQRQk7iWMYI5jENG46Z2XX37T1PtvjA2F5LzaZ6josq9QWLowmcy2bTHVEADGnjglhoCgquvCgKTb8wkmafhInZXhpwk0Df+UkI5jEXRkXtxqeamZrSbScoDrIkIKiF+mJeGgLU5oH/UT3N/85Mz59/WLWGttoFIfwUkGjfpB8dQkHjT+w33gGgFguxE4micrFrSaB2ZV0MtT5HDBWcMR4heHiBkYMGzMoBUVHeUIgOMwXeMhBIHDGrqG46XPitDh+nLyI12vf4r2GNfwg/nv869Rg1/gBaxkl9ft5eUsJds3CLmcpFyeNxmfoeHQ/QghMqoohwG6ykGx18L9HP2di7HBizDa8RoDxMWm8638F4RPsdJ7gW9E3oykqGxo/pd5oIM82jkprFddFzeHt6j+QaxtLqjmFUv9J/CJApGrHoTq4xJLNN+zTsKgWhLiEbcdicOHESxP7jE/Qtbs7FBPdteOUzHqcSX4uTDreZtiv6o7z5O41AFwcOQOA31Su4GSgjEncwigm48XFBK4a0L0RLWnv3Y0d5u/xexGOcqv5OTcPe5iVGLLPmEAtMGiIX83yyt+y07ObPNs47EoEfhEgQrVhd9ih8QLGMROtRVXVHD8pLAYeUlCEiXCLh95GJ8AFgXo8NCIwEAhcOIkmCQ8NlGojOlz61h0aOYzAQMOOm1J2GsEtdU04iFIuYJR6Jwf05yg31hGj5Laa8R2j5AHg4SR2ZfDtUNtR/hiWuo+flC0OfZ9gy8OqWKlyVTPVPpk3ne/wTOVzuAw3FlVjo38tGz4VjHIkkjBuJCZh8M30CSRYInnAdimJVgcOsxWL2vr1bvB7KPfU80DObLR2Kvbjrjq21x4jQjPz/cT5lHvq0RQVDZW3dldzdfQVxGoxjLKMJNWUjFVtex6LoihMyaxna0kMdmIo5Nug97wSaLbjlMz6VsdTU6qgnQ0gbeWX8A37EayKhTTTMHa791LpCXA9S9sd+hjI9FZF2t0yrDvxOf38ZpJlGUGBdxKzHN9AFzoWxYJHeGk0Gtll2cun7l8hBBz3n+DxlEc4XDqyVXylsBg4SEHRRQabcGiJgY6CSiPV7GEDxbzRbli7HksyI7mCHxJJHH9XP8Ip9jBMnUOTKMGsRHW42kIIPeiMqsVY+Ejtu5QZRVQbxbhwhY4HaKRWfAGGwKFk0cQRXJQQdWoGeTDM6fA+pRYY1k0r9A0d5ZPK2L9SGDkVBZV/er/mxZq1ZJiDIumty25HFwaHGqvIsMdh08z8hHFnXaPR76Eh4MWbEc9Ii96pOEWZbUSZO/bXMdwey3D76bg7HEmhvx+Y1nJinR840eY19u7NCv0dFBWnx4+7s3zzTFtOyaw/a2jjCG27Ut+7N4v36t9DVVS2ubezz3uAYYGpXM39g0pM9Gal2dMyradOuUZaRjDSEuy9yM8tAYJLKL1GgJlaOlet/ys1vuD7HxBn76Z6USBWiooBghQU7dDXwkEnwN/4OXWUMZJJXMhcLNip4BARRGHCQgoROPETQ9ClagA/JsytJkh1xAG2sIsi8pjdpphIZ1xoaRhAA9X8jaUYShxu4yReKvHo5diVDMqND4lR8lFQUdBwKKOxkYRJiUags09fBgR7FqKVcbjFSRQ0KsVGABTMxCtT8Is6DLwIBAHhxqtUk6JcRpSS3SpuZuV0V/Q+/deM5z+7buRe4Fz5pIpj2IjEQXyoVbai6jAbmj7FY7iJ1qK5NnoO2ZbRxGmxwGE0RSU7KrnD6zrMNhxmG0fCkorw0lzZNwuLM3sTmgXGuWx3+rz6DsN1hHl4MW+VvMdoyyieTH2cWC2Gbcdizn3iGZxrTkFvEw5Pmp2N/5nPqy3am8DbXRs15xkhBM/sL8IQgtdKtgGQ7UiixufivoR/IcWczLFu3UHSFwwpQdHeHIGWCrY/CgU/XhqowkokETjYyMuUsJPpzCeHiwjgZwMvITCwE80ePmIPH5HGWErZd2r9ucFEz0R2sItp3MAW/grANG7iCNup4BD38TJr+C9UNCZxNelntGxzuIgcLgJgN//gOHswYyWSeLKZQSHfDjnPaf5/s8kZOr95ohVAJvMxhE5wvreXJlGClyqajKMEaGSs9giRZKLjwS1O4KWaAA2kKdfiE/VEKiNxqCMxE42JyA7H1g2h4+Fk6PtkbTl+T3gWJ4UrP7RVCD9w4lFq9TpujL6OS2O/icfwsLahiGJX0F+ATbGyPP3pbt2vubJu8LpwHwqv06G2JjaGk44qrO7e26y3nR/GRCWzdc5PWvWadIWWlXd/liEt6cgbaPMKj3CKh3Ce1xbjxh1CFwbrTu7luLuOvxzdSoIlkuWTv0V2VBIptmi2Vh+Fst7fi0LSMwb1stH+fLGrOYaBQTzp1HAcD41EEEMdJ6ngEHWUEcB3yglMIylk4aYRDw24qceHByt2bDjQMOHHi06AeNJR0dAJEMCHHw8giCCGCKKJJ41YUvHiQmBgYKAA7/A0I7mQIwS33o0ikUzysRGFlUgMAtRTiZcmROifQRVHaaQGgFt4MuSoppmeehVsi65cs87YwQEj6FpWwUSWehdxyqR29+zo6zzRVsFqCAO38GAIgxLfMWoNJ37h5w81L/Nw0iLSTKn4hJ/h5rSz0tHWksfm42dWij1d5tlRGnpbVPQHLe3XFdu1l1/7W1h0l3A+7+4KteZ71vnc3PXZyxx31XLtsPHsayhn7rA85gzLJcnWekiq+V5tPbuWz0guG+0/Bl0PRX+9xBUc5nPepo4ynJSfqughiwISyMBGFGUc4ADF3MoviCcdE9bQvIXODEmcC3O+E//OtrtrH+RVIDh0EvSwF1w14KYBH66QIx4bDhQUFFRcOCnjayzY0DCTwOlt5Duq9LvzDAx0fLgBmBaIxIS51T18oo56sR+vqMBHDQGaEBhAcNhklHonZuV0AZOW56Z0d+sXuS/zRv7wSg75jlDUUEaNXstJfxl+4QdAVVQiFBuqomFTrCSbktAxWBh/OxdGTOjwuu0V0O0db84TPRF+W0uiz6pk9u7NGlSi4kSiSnqV0e7vPan4eitfhbOV30xDlouoLvZY9eQ59zSPRGhmbho+ieX7/8EJj5OVF32/zXDnen4tn9HHmrtHcZJ0n0EnKMKNwOAL/o6NKJqoRWBgIYJEMnEQTyVHWcuzocrtTObxSIfX18Jo4vbExJn3s3M6XCSx7YaNJJbRBD3ibTLVcQQ3EJ6XsbmwbG5NvMUvOM4eUhlDcM2ACXOgeYWAglPRiFXGE6tOwEICJuwdDoP0pZi4MKOWr72HKPEfp1av45jvOB9Xq4yxZDHcks4Ya1aHKx7CTcsWWmfyRFeu2bKSa1mID3Rx0VtiIly0Jx56xa5nz+EdsFg1E98dOY0T7jrWlu6h3u8h2mzDFfDx58PFTEsYSeWxMSSYmkL+Uc7FND2GL3o53pK2Oe8FRRUlFPMmWRSc8quv4MeDHw8emnBShgkLdmJwUoGdaKZwPQfZyigu7NO4htvNcncmd3VUca/nD0zgKiLid3JHyZ8AMCtm4kQGKWShE6CWUgL4CeBlJBdyPY8FTxbBj4FOPZU4cGDqwMFRZ23hx8t+PqGcgzThBARmbMSRxmimkMTIds+dlFHD2oYPeapiJ+Nt4xhpGUG2NYubY74ZcvjU15zZ3dtsh674GOnoGbYlLAYDFbEqyXVni4q2xES4hoqa6Y6tekugtWeHgc7DOVdQmJDFZf9Yzo9yLqPC3cDKks/53aHgttxzoi5nbMO/9HMsJefivBEUpexnF0V4cRHHMNLJJY0cEhnBfJ6gkiMU8WIo/DweQUUlliuJJfWs613I3L6MPgBanJ+zF031Ll1p+e/gA3bwAdRAopZAtV6DX/ip4BCqqZEF8bfRZLgwhEGKKZmRlkyceglvlO6kiqMc5PPQsMi3WcIwLmj3Xp2xRSVHeZ3/4DJ+wAy+hf3URk7FvMmWU59/4UXstK5gmiuI31evZJt7OxdHFjLCnEmCFodX+Njj2U+yKZEUc8crMXqDMysv5+gmDrQhrLrbY9Ne5TjQh0Bc1uBclHP1RnRVTHRXWPWXrZrtMFg43FjFg1+8QZ3PzWUpwfd9+f5/hH7/VsyNfDPmGgC2Dp1dB4Ys542gqOQwVZRgJ4YSdvIV7xPAxzhmchX3kkIWGYznVf6daJJwUo5OgB18iI6PWk4SwMtopnE5Q1Mp97QS+pN4nopAJf/0HmR940ZURaUiUAlAWaCCpyuW80zaUpJMiaFzX6v7G58rXxCtRjHDNpmNTZ8C8Do/Y07U5dwed0so7KqSCnbxDwx0ZjMHM2dvOOShkUZqqKeSD3mRMUxnHDNbhZnKDUzgKop5ne0Rz/NA0r+2ma5SfxkNRiNrGtZx0l+GqqjscO8mQAAVhRRTUFCoioraYp6M3x/Jdfz4nH4OwtUL0N6yzPOBZgHhpAn33ra7xLtjjzNtOpDF1GDEEIK/HvuSp/d+wOLx1zLKkUhaRAxPjL+WfftG93f0JN3kvBEUE7maiVyNQOChkSbq0PG3mmNgwc5krqWEnWSQjwJkks8X/J0SdgJwnD39k4BeIBzzDloWvKqikmpOIdWcwkzHRZz0l/H/qp6nVq9DQSHZlMSfa15lqv1CQEFTNJJMCUyzF5BjySbNMoxro6/Cr/t5vOLnvN9QxPsNRWfdM1K102gdzpWZia2Ob276jBeqf0eEYiNOi2VmxBTitFi+8j9Hg9GILgwUBYQATVGp9pfzw+iFQHBlRp3u5IS/lAA6cVoMN8RcxwHv11QEKkOrNrKtWTj1ehQUxlizqG+KDXkaNQg6mLJgw0zHDqR6k94arhjovRTtMdiGb4YyzQLwyfKn+af3IACmqsmo9RmUAWUdnHu+COcVK1awbNkyysrKmDhxIs8++yzTpk3r72h1ivNGUFRRwv/yaKtj97OSg3xGNEnsYB17+Cj0WzFvEEvqqdUPGVzCHdRRRmKLlRDnK50toC+b4OIyvtfq2PodkRzzB/dc8IsABfZJxGqx7HTvZp/nn9ToNVQHasmyjOSQ70irc+c4LifVnEKCKZ5R9lFn3S/bOppFiXejnfKa6DO86Agy7MOxKVZiTTEIIUg2JaEoCoYw2O3Zy2+rfofb8BCrxTDckoYJE197DxGtRZFnG8ccy+XYFFub8ya2NnVcqMnKrHdpFjjFpITtWpLu0ZXJr/+REpw7dUfJ3fyh5mUK7dOYGJHPMHPnn+OZXliHAq+99hoPP/wwzz//PNOnT2f58uXMmTOH/fv3k5zc90OsXWXQ+aH4kfJa6DcnFaf8PzjQCeAgvt2WoUBQzkFMWLERiYFONEls4jW+5O/cwx9R0aillD/zMAC38csOJ+31NeGelNlVOlM5hms9+8bGTfxPzUtthl027EmiR8ZgO27hmP8EB32HOeoroSZQC6d2iDQpGtFaNFbFglWxoCkm6vUG1jX+g3HWHCJVO27hYZz1Ai6OLCTBFN+l+HamIOsNMXGmfbsyGbG34jAQGKyTEcNNX9ohXHns+yX30jwjyqJYmGDLI8sykkzLcC6wZmNVLK122G2Llu+jFxfP8/1B6Ydi+vTpTJ06leeeew4AwzDIyMjg/vvv5yc/+UnY4t9bDDpB8cqI/wn9trb+Q/637vU2z4sgmkhiMdAxMEhnLLtZD4CFCKZyAyoaBgaH+JyTHGAUBUQQRTIjiSOddMaFddnnQGYgzVRvq6Da69nPUxXPIBB8M/oaanUndbqTEZYMRltGMdKSSbwWd86Cp15vwC/8RGtRmMO8+Vk4GIiVtURyJuEUrHW6k4AIoAudeFMcQggO+g6zz3uAvznfBeAKx6XYVTt2NYJ0cxp21U6cFoNNsRGltW5kuQ03dx9/sE8ExUTtKbR2GrE6Hr7Sf8qxY8daxcNqtWK1nr3E3OfzYbfbefPNN7nhhhtCxxcsWEBdXR3vvPNO2NMRbgaNoHjooYdwOBz889nd2BQbFiW4h4VJMWHGjEkxYVI0fMJHnV7PCX9pcJqcoobG4VNNKVwRdSlew4ddjcCsmLCrEVRWjSSWYVj6cdy7mY4q9u44rekpA6mC8xkBSt1OAoZOYHgcY51BQTAQ/Ay0RV/Y7lwOnc4XpB2C9KUd+uK9C4gAjUYjAaHTZLhw6vVUBCpxGS5q9TrchocmwxWaGwVgUkxsdX/Rq4LC4/EwatQoyso6mvUBDoeDxsbGVseeeOIJFi9efFbY0tJS0tPT2bRpE4WFhaHjjz76KBs2bGDLli1hiXtvMmia37feeismk4m3XvDgFm78IoCCgi6CTqrdhhuv4cMjPHiEF78I0GAE1xnFqNE4jXrKAuW8Uvtau/dI1BL4TfpTfZWkLhMOMTGQBEJXsagmRkYmBL+c3mJkUKepp8hKNIi0Q5C+tEPL9663xIVJMRGrxQKQSEKnzqkO1LDV3buurWw2G4cPH8bn83UYTghxlnv9tnonhgqDRlCMHTuW6Oho9ti2hfW6Qgh8wodbeIhQ+r+HoiPO1UNxPlWsskUaRNohiLRDkP6yQ2fLnr7o1bCrbc9pCDc2mw2bLXx1RmJiIpqmUV5e3up4eXk5qaln+0IaiAwaQdFbKIqCVbFiZeCoxvZeziMpGiOteh/HZmDi1waXA5/eQtohiLRDkIFuh640egbqUGZvYbFYKCgooKioKDSHwjAMioqKWLRoUf9GrpMMOkFxPrXCJRKJ5Hylu2V9Y8ALx8McmT7i4YcfZsGCBUyZMoVp06axfPlympqaWLhwYX9HrVMMOkEhkUgkEslQ5JZbbqGyspKf/exnlJWVMWnSJNauXUtKSs/9rPQFg0ZQ1NcHVz80Brz9HJP+w+XTaAzIIQ+QtmhG2iGItEMQaQdoGuR1xKJFiwbNEMeZDHhBYbFYSE1NJSMjo7+jIpFIJJJBQGpqKhZL+7sVS3qHAe+HAoJrfs+1PEcikUgkEgg2RMO5AkPSOQaFoJBIJBKJRDKw6dhPsUQikUgkEkknkIJCIpFIJBJJj5GCQiKRSCQSSY+RgkIikUgkEkmPkYJCIpFIJBJJj5GCoo+58cYbiYuLY/78+QC4XC6uueYaxo4dS15eHs8++2wobFVVFbNnzyY7O5ubbroJj8cDwPHjx5k1axa33XYbuq7zzjvvcOutt4bOW7RoEVdffXXo++OPP87TTz/dRynsHocPH2b27Nnk5uaSn59PU1MTn332GXl5eYwZM4YlS5aEwhYVFVFQUMCyZcsAeOihh3j++edDv48fP55f/vKXoe8XX3zxoNj6tzOsWrWKnJwcsrOz+d3vfgfAK6+8wuTJk3nllVf6OXbhpyf5AsBkMjFp0qTQ589//nN/JKPL9EY5AXDppZcyduzYkD0eeOCBvk+cZOgiJH3K+vXrxbvvvituvvlmIYQQTU1N4qOPPhJCCNHQ0CBycnLEgQMHhBBC/PjHPxbPPvvsWX8/+uijYu/evWLFihVizZo1ory8XIwYMSJ0j4svvljMmDFDGIYhhBDisssuExs3buyrJHaLmTNnhuJYXV0t/H6/mDJlivjqq69EIBAQ06dPFzt27BBCCPHtb39buN1u8Z3vfEc0NDSI1157TSxYsEAIIYTT6RSTJ08W119/vRBCCJ/PJ+Li4oTP5+uPZIUVv98vsrOzxfHjx0VDQ4O44IILRFVVlbjhhhuEz+cLpXko0ZN8IYQQCQkJ/Rb3ntAb5YQQQsyaNUvs3Lmzr5MjOU+QPRR9zKWXXkpUVFTou91uZ9asWQA4HA5ycnI4efIkAO+++y533HEHALfffjvvvfceENyBTlVVTCYThmGQnJyMpmmcPHkSt9uN2WwmNzeXffv2YRgGX331FVOmTOnjlHae3bt3YzabueSSSwCIj4+noqKCQCDAhAkT0DSNW2+9lVWrVgHB9CuKgqZpCCEoLCxk8+bNAGzZsoW5c+dSUVEBwPbt28nNzcVsNvdP4sJIc8s8PT0dh8PBNddcwwcffIAQAkVRUJSBvdNkV+lpvhjM9EY5IZH0NlJQDCCOHTvGjh07mDx5MgBOp5OYmBgA0tPTOXHiBAD33nsv3//+91m/fj1z5swBCFWqW7dupaCggBkzZrB582Z2795NVlYWERER/ZOoTnDgwAEcDgfz5s1j8uTJLF26lNLSUtLT00NhWqZ/4cKFFBYWMn78eKKiosjIyMDlclFdXU1xcTEzZsxg1KhRHDp0iOLiYi666KL+SlpYac8m8+bNY+rUqdx44439GLvw09N8AVBXV9dqyGP9+vX9kpZw0pNyAmD+/Pkhe7QcHpJIesqA38vjfMHr9XLLLbewbNkyIiMjOww7atQoPvnkk1bHmgVFcnIyM2bMIDs7m2effRZd1yksLOzNqPeYQCDAxx9/zPbt20lOTubqq6/usEdh7ty5zJ07t9WxGTNmUFxczJYtW7j33ns5ePAgmzdvpri4ODQOPVS56667uOuuu/o7GmEnHPkiNjaW7du393JM+46elhMAb775JuPHj++tKErOY2QPxQBACMH3vvc95s6d26ryi4mJwel0AnDixAnS0tLavUZhYWGoQp0xYwZ5eXns2rVrULTQ09PTmTJlChkZGVitVubOnYvL5Qq1tKBz6d+8eTPV1dUkJCQwffr0kD0Gevo7S1paWpdsMtgJR74YSoSjnJBIehMpKAYAP/3pT7Hb7Tz++OOtjl933XW8/PLLQHAm/7x589q9xoQJE9i7dy8lJSWkp6ejaRp2u52ioqIB30MxdepUKioqqK2txTAMNm7cSEFBAZqmsWPHDnRd59VXX+0w/YWFhaxcuZIxY8YAcOGFF7Ju3TqEEKSkpPRVUnqVadOmsWvXLk6cOEFjYyNr1qxp1ZU91AhHvhhKhKOckEh6lf6cEXo+cvnll4vExEQREREh0tPTxcaNGwUgcnNzxcSJE8XEiRPF2rVrhRBCVFRUiJkzZ4rRo0eL66+/Xrhcrg6vPWvWLDF//vzQ98cee0ykp6f3anrCxerVq8X48eNFXl6eeOihh4QQQmzevFnk5uaKrKws8cQTT3R4vsfjERaLRTz33HOhY9OnTxff/e53ezPafc4777wjsrOzxejRo8ULL7zQ39HpdXqaLzRNC71XEydOFM8880wfxLrn9FY5MWvWLJGTkxO6xm233dZXSZKcB8jdRiUSiUQikfQYOeQhkUgkEomkx0hBIZFIJBKJpMdIQSGRSCQSiaTHSEEhkUgkEomkx0hBIZFIJBKJpMdIQSGRSCQSiaTHSEEhkUgkEomkx0hBIZFIJBKJpMdIQSGRSCQSiaTHSEEhkUgkEomkx/x/TekYKlpw+8IAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -522,37 +494,48 @@ } ], "source": [ - "ax = plt.set_cmap('plasma') " + "# plot degree\n", + "map_plot.plot(degree, \"Degree\")\n", + "\n", + "# add matplotlib.pyplot or cartopy commands to customize figure\n", + "plt.set_cmap('plasma')\n", + "# optionally save figure\n", + "#plt.savefig('degree.png')" ] }, { "cell_type": "markdown", - "id": "33c0f03c", + "id": "b8feb1e0", "metadata": {}, "source": [ - "Now we can generate the plots in the current directory." + "Try plotting more measures if you like." ] }, { "cell_type": "code", - "execution_count": 24, - "id": "73aa161c", - "metadata": { - "scrolled": true - }, + "execution_count": 20, + "id": "8b67424d", + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created and saved plots @ current directory.\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Plot with cartopy and matplotlib\n", - "cn_plot.generate_plots(file_name=\"climate_network_measures\",\n", - " title_on=False, labels_on=True)" + "# plot betwenness\n", + "map_plot.plot(np.log10(betweenness + 1), \"Betweenness (log10)\")\n", + "\n", + "# add matplotlib.pyplot or cartopy commands to customize figure\n", + "plt.set_cmap('plasma')\n", + "# optionally save figure\n", + "#plt.savefig('degree.png')" ] } ], @@ -572,7 +555,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/src/pyunicorn/__init__.py b/src/pyunicorn/__init__.py index 2babe2f2..68036bd7 100644 --- a/src/pyunicorn/__init__.py +++ b/src/pyunicorn/__init__.py @@ -31,7 +31,6 @@ To Do ----- - A lot - See current product backlog. - - Clean up MapPlots class -> Alex!? """ diff --git a/src/pyunicorn/climate/__init__.py b/src/pyunicorn/climate/__init__.py index f620023d..ffe9da4c 100644 --- a/src/pyunicorn/climate/__init__.py +++ b/src/pyunicorn/climate/__init__.py @@ -41,8 +41,7 @@ from .coupled_tsonis import CoupledTsonisClimateNetwork from .havlin import HavlinClimateNetwork from .hilbert import HilbertClimateNetwork -from .map_plots import MapPlots -from .cartopy_plots import CartopyPlots +from .map_plot import MapPlot from .mutual_info import MutualInfoClimateNetwork from .partial_correlation import PartialCorrelationClimateNetwork from .rainfall import RainfallClimateNetwork diff --git a/src/pyunicorn/climate/cartopy_plots.py b/src/pyunicorn/climate/cartopy_plots.py deleted file mode 100644 index 4ffdd92a..00000000 --- a/src/pyunicorn/climate/cartopy_plots.py +++ /dev/null @@ -1,165 +0,0 @@ -# This file is part of pyunicorn. -# Copyright (C) 2008--2023 Jonathan F. Donges and pyunicorn authors -# URL: -# License: BSD (3-clause) -# -# Please acknowledge and cite the use of this software and its authors -# when results are used in publications or published elsewhere. -# -# You can use the following reference: -# J.F. Donges, J. Heitzig, B. Beronov, M. Wiedermann, J. Runge, Q.-Y. Feng, -# L. Tupikina, V. Stolbova, R.V. Donner, N. Marwan, H.A. Dijkstra, -# and J. Kurths, "Unified functional network and nonlinear time series analysis -# for complex systems science: The pyunicorn package" - -""" -Provides classes for analyzing spatially embedded complex networks, handling -multivariate data and generating time series surrogates. -""" - -import matplotlib.pyplot as plt - -try: - import cartopy.crs as ccrs - import cartopy.feature as cf -except ImportError: - print("climate: Package cartopy could not be loaded. Some functionality " - "in class MapPlots might not be available!") - -# -# Define class CartopyPlots -# - - -class CartopyPlots: - - """ - Encapsulates map plotting functions via cartopy and matplotlib. - - """ - - def __init__(self, grid, title): - """ - Initialize an instance of MapPlots. - - Plotting of maps is powered by cartopy and matplotlib. - - :type grid: :class:`.Grid` - :arg grid: The Grid object describing the map data to be plotted. - :arg str title: The title describing the map data. - """ - self.grid = grid - """(Grid) - The Grid object describing the map data to be plotted.""" - self.title = title - """(string) - The title describing the map data.""" - - # Initialize list to store data sets and titles - self.map_data = [] - """(list) - The list storing map data and titles.""" - # Also for multiple maps - self.map_mult_data = [] - """(list) - The list storing map data and titles for multiple maps.""" - - # - # Adjust cartopy settings, fine tuning can be done externally - # - - # Specify Coordinate Refference System for Map Projection - # pylint: disable-next=abstract-class-instantiated - self.projection = ccrs.PlateCarree() - - # Specify CRS (where data should be plotted) - # pylint: disable-next=abstract-class-instantiated - self.crs = ccrs.PlateCarree() - - # get spatial dims - self.lon = self.grid.convert_lon_coordinates(self.grid.lon_sequence()) - self.lat = self.grid.lat_sequence() - self.gridsize_lon = len(self.lon) - self.gridsize_lat = len(self.lat) - self.lon_min = self.grid.boundaries()["lon_min"] - self.lon_max = self.grid.boundaries()["lon_max"] - self.lat_min = self.grid.boundaries()["lat_min"] - self.lat_max = self.grid.boundaries()["lat_max"] - - # extent of data will also give extent of world map - self.data_extent = [self.lon_min, self.lon_max, - self.lat_min, self.lat_max] - - print("Created plot class.") - - def add_dataset(self, title, data): - """ - Add a map data set for plotting. - - Data sets are stored as dictionaries in the :attr:`map_data` list. - - :arg str title: The string describing the data set. - :type data: 1D array [index] - :arg data: The numpy array containing the map to be drawn - """ - self.map_data.append({"title": title, "data": data}) - - def generate_plots(self, file_name, title_on=True, labels_on=True): - """ - Generate and map plots. - - Store the plots in the file indicated by ``file_name`` in the current - directory. - - Map plots are stored in a PDF file, with each map occupying its own - page. - - :arg str file_name: The name for the PDF file containing map plots. - :arg bool title_on: Determines, whether main title is plotted. - :arg bool labels_on: Determines whether individual map titles are - plotted. - """ - - for dataset in self.map_data: - - # Generate figue - fig = plt.figure() - - # create map plot - ax = plt.axes(projection=self.projection) - - # make it a class feature, as to work with it from outside - # self.ax = ax - - # create some standards of plotting that can be adjusted - # before calling generate_cartopy_plot - # adjust size and plot coastlines and borders - ax.set_extent(self.data_extent, crs=self.crs) - # ax.set_global() - ax.add_feature(cf.COASTLINE.with_scale("50m"), lw=0.5) - ax.add_feature(cf.BORDERS.with_scale("50m"), lw=0.2) - - # Draw gridlines in degrees over map - gl = ax.gridlines(crs=self.crs, draw_labels=True, - linewidth=.6, color='gray', - alpha=0.5, linestyle='-.') - gl.xlabel_style = {"size": 7} - gl.ylabel_style = {"size": 7} - # plot data upon map - ax = plt.tricontourf(self.lon, self.lat, dataset["data"], - extent=self.data_extent, transform=self.crs) - ax = plt.colorbar(shrink=0.5) - - # plot main title - if title_on: - plt.suptitle(self.title) - - # plot subtitles - if labels_on: - plt.title(dataset["title"]) - - # save figures at current dir - file_extension = dataset["title"] + ".png" - file_extension = file_extension.replace(" ", "") - - fig.savefig(file_name + "_" + file_extension) - - plt.close() - - print("Created and saved plots @ current directory.") diff --git a/src/pyunicorn/climate/map_plot.py b/src/pyunicorn/climate/map_plot.py new file mode 100644 index 00000000..b050b259 --- /dev/null +++ b/src/pyunicorn/climate/map_plot.py @@ -0,0 +1,125 @@ +# This file is part of pyunicorn. +# Copyright (C) 2008--2023 Jonathan F. Donges and pyunicorn authors +# URL: +# License: BSD (3-clause) +# +# Please acknowledge and cite the use of this software and its authors +# when results are used in publications or published elsewhere. +# +# You can use the following reference: +# J.F. Donges, J. Heitzig, B. Beronov, M. Wiedermann, J. Runge, Q.-Y. Feng, +# L. Tupikina, V. Stolbova, R.V. Donner, N. Marwan, H.A. Dijkstra, +# and J. Kurths, "Unified functional network and nonlinear time series analysis +# for complex systems science: The pyunicorn package" + +""" +Provides classes for analyzing spatially embedded complex networks, handling +multivariate data and generating time series surrogates. +""" + +import matplotlib.pyplot as plt + +try: + import cartopy.crs as ccrs + import cartopy.feature as cf +except ImportError: + print("climate: Package cartopy could not be loaded. Some functionality " + "in class MapPlot might not be available!") + +# +# Define class MapPlot +# + + +# pylint: disable=too-few-public-methods +class MapPlot: + + """ + Encapsulates map plotting functions via cartopy and matplotlib. + """ + + def __init__(self, grid, title): + """ + Initialize an instance of MapPlot. + + Plotting of maps is powered by cartopy and matplotlib. + + :type grid: :class:`.Grid` + :arg grid: The Grid object describing the map data to be plotted. + :arg str title: The title describing the map data. + """ + self.grid = grid + """(Grid) - The Grid object on which the map data will be plotted.""" + self.title = title + """(string) - The title describing the map data.""" + + # + # Adjust cartopy settings, fine tuning can be done externally + # + + # Specify Coordinate Refference System for Map Projection + # pylint: disable-next=abstract-class-instantiated + self.projection = ccrs.PlateCarree() + + # Specify CRS (where data should be plotted) + # pylint: disable-next=abstract-class-instantiated + self.crs = ccrs.PlateCarree() + + # get spatial dims + self.lon = self.grid.convert_lon_coordinates(self.grid.lon_sequence()) + self.lat = self.grid.lat_sequence() + self.gridsize_lon = len(self.lon) + self.gridsize_lat = len(self.lat) + self.lon_min = self.grid.boundaries()["lon_min"] + self.lon_max = self.grid.boundaries()["lon_max"] + self.lat_min = self.grid.boundaries()["lat_min"] + self.lat_max = self.grid.boundaries()["lat_max"] + + # extent of data will also give extent of world map + self.data_extent = [self.lon_min, self.lon_max, + self.lat_min, self.lat_max] + + print("Created MapPlot.") + + def plot(self, data, label): + """ + Plot dataset onto ``self.grid`` using cartopy and matplotlib. + A simple setup to get a quick view of your data. + + The plot can be customized by calling additional matplotlib or cartopy + methods afterwards. It can then be saved via ``plt.savefig()``. + + :arg ndarray data: The dataset to be plotted on the Grid. + :arg str label: A name for the dataset to print as label. + """ + + # Generate figure + plt.figure() + + # create GeoAxes object + gax = plt.axes(projection=self.projection) + + # create some standards of plotting that can be adjusted + # before calling generate_cartopy_plot + # adjust size and plot coastlines and borders + gax.set_extent(self.data_extent, crs=self.crs) + # ax.set_global() + gax.add_feature(cf.COASTLINE.with_scale("50m"), lw=0.5) + gax.add_feature(cf.BORDERS.with_scale("50m"), lw=0.2) + + # Draw gridlines in degrees over map + gl = gax.gridlines( + crs=self.crs, draw_labels=True, + linewidth=.6, color='gray', + alpha=0.5, linestyle='-.' + ) + gl.xlabel_style = {"size": 7} + gl.ylabel_style = {"size": 7} + # plot data upon map + plt.tricontourf(self.lon, self.lat, data, + extent=self.data_extent, transform=self.crs) + cbar = plt.colorbar(shrink=0.5) + cbar.set_label(label, rotation=270) + + # add title + plt.title(self.title) diff --git a/src/pyunicorn/climate/map_plots.py b/src/pyunicorn/climate/map_plots.py deleted file mode 100644 index 56ea6336..00000000 --- a/src/pyunicorn/climate/map_plots.py +++ /dev/null @@ -1,352 +0,0 @@ -# This file is part of pyunicorn. -# Copyright (C) 2008--2023 Jonathan F. Donges and pyunicorn authors -# URL: -# License: BSD (3-clause) -# -# Please acknowledge and cite the use of this software and its authors -# when results are used in publications or published elsewhere. -# -# You can use the following reference: -# J.F. Donges, J. Heitzig, B. Beronov, M. Wiedermann, J. Runge, Q.-Y. Feng, -# L. Tupikina, V. Stolbova, R.V. Donner, N. Marwan, H.A. Dijkstra, -# and J. Kurths, "Unified functional network and nonlinear time series analysis -# for complex systems science: The pyunicorn package" - -""" -Provides classes for analyzing spatially embedded complex networks, handling -multivariate data and generating time series surrogates. -""" - -import os -import glob - -import numpy as np - -# Import Ngl support functions for plotting, map projections etc. -try: - import Ngl -except ImportError: - print("climate: Package Ngl could not be loaded. Some functionality " - "in class MapPlots might not be available!") - -# -# Define class MapPlots -# - - -class MapPlots: - - """ - Encapsulates map plotting functions. - - Provides functionality to easily bundle multiple geo-datasets - into a single file. - """ - - def __init__(self, grid, title): - """ - Initialize an instance of MapPlots. - - Plotting of maps is powered by PyNGL. - - :type grid: :class:`.Grid` - :arg grid: The Grid object describing the map data to be plotted. - :arg str title: The title describing the map data. - """ - self.grid = grid - """(Grid) - The Grid object describing the map data to be plotted.""" - self.title = title - """(string) - The title describing the map data.""" - - # Initialize list to store data sets and titles - self.map_data = [] - """(list) - The list storing map data and titles.""" - # Also for multiple maps - self.map_mult_data = [] - """(list) - The list storing map data and titles for multiple maps.""" - - # - # Adjust PyNGL settings, fine tuning can be done externally - # - - # Set PyNGL resources - resources = Ngl.Resources() - - # Define grid - resources.sfXArray = self.grid.lon_sequence() - resources.sfYArray = self.grid.lat_sequence() - - # Change the map projection - resources.mpProjection = "Robinson" - - # Rotate the projection - # Center in the middle of lonMin and lonMax - # resources.mpRelativeCenterLon = "true" - - # Set plot limits - resources.mpLimitMode = "LatLon" - resources.mpMinLonF = self.grid.boundaries()["lon_min"] - resources.mpMaxLonF = self.grid.boundaries()["lon_max"] - resources.mpMinLatF = self.grid.boundaries()["lat_min"] - resources.mpMaxLatF = self.grid.boundaries()["lat_max"] - - # Change the color map - resources.wkColorMap = "wh-bl-gr-ye-re" - - # Change thickness of geophysical lines - resources.mpGeophysicalLineThicknessF = 2.0 - - # Configure the legend - resources.lbAutoManage = False - resources.lbOrientation = "Horizontal" - resources.lbLabelFont = "Helvetica" - resources.lbLabelFontHeightF = 0.0075 - resources.lbTitleFontHeightF = 0.01 - - # Larger font for regional networks - # resources.lbLabelFontHeightF = 0.014 - # resources.lbTitleFontHeightF = 0.02 - - # Configure the contour plots - resources.cnFillOn = True - resources.cnLinesOn = False - resources.cnLineLabelsOn = False - resources.cnInfoLabelOn = False - resources.cnMaxLevelCount = 22 - - resources.cnFillMode = "RasterFill" - - # Make resources object accessible from outside - self.resources = resources - """The PyNGL resources allow fine tuning of plotting options.""" - - def add_dataset(self, title, data): - """ - Add a map data set for plotting. - - Data sets are stored as dictionaries in the :attr:`map_data` list. - - :arg str title: The string describing the data set. - :type data: 1D array [index] - :arg data: The numpy array containing the map to be drawn - """ - self.map_data.append({"title": title, "data": data}) - - def generate_map_plots(self, file_name, title_on=True, labels_on=True): - """ - Generate and save map plots. - - Store the plots in the file indicated by ``file_name`` in the current - directory. - - Map plots are stored in a PDF file, with each map occupying its own - page. - - :arg str file_name: The name for the PDF file containing map plots. - :arg bool title_on: Determines, whether main title is plotted. - :arg bool labels_on: Determines whether individual map titles are - plotted. - """ - # Set resources - resources = self.resources - - # Set plot title - if title_on: - resources.tiMainString = self.title - - # Open a workstation, display in X11 window - # Alternatively wks_type = "ps", wks_type = "pdf" or wks_type = "x11" - wks_type = "pdf" - wks = Ngl.open_wks(wks_type, file_name, resources) - - # - # Generate map plots - # - for dataset in self.map_data: - # Set title - if labels_on: - resources.lbTitleString = dataset["title"] - - # Generate map plot - cmap = Ngl.contour_map(wks, dataset["data"], resources) - - # Clean up - del cmap - del resources - - Ngl.end() - - # FIXME: Clean this up (Jakob) - def add_multiple_datasets(self, map_number, title, data): - """ - Add a map-dataset consisting of a title and the dataset itself - to the :attr:`map_data` list of dictionaries (pure dictionaries have no - order) and reshapes data array for plotting. - - INPUT: title a string describing the dataset - data a numpy array containing the map to be drawn - """ - if map_number > len(self.map_mult_data) - 1: - self.map_mult_data.append([]) - self.map_mult_data[map_number].append({"title": title, "data": data}) - - # FIXME: Clean this up (Jakob) - def generate_multiple_map_plots(self, map_names, map_scales, title_on=True, - labels_on=True): - """ - Generate map plots from the datasets stored in the :attr:`map_data` - list of dictionaries. Stores the plots in the file indicated by - filename in the current directory. - """ - for k, map_data in enumerate(self.map_mult_data): - # Set resources - resources = self.resources - - # Set plot title - if title_on: - resources.tiMainString = self.title - - # Open a workstation for every map, only wks_type = "ps" allows - # multiple workstations - - # Define own levels - resources.cnLevelSelectionMode = "ExplicitLevels" - resources.cnLevels = map_scales[k] - - wks_type = "pdf" - wks = Ngl.open_wks(wks_type, map_names[k], resources) - - # - # Generate map plots - # - - for dataset in map_data: - # Set title - if labels_on: - resources.lbTitleString = dataset["title"] - - # Reshape for visualization on the sphere - dataset["data"].shape = (self.grid.grid_size()["lat"], - self.grid.grid_size()["lon"]) - - # Generate map plot - cmap = Ngl.contour_map(wks, dataset["data"], resources) - - # Clear map - del cmap - Ngl.destroy(wks) - - # Clean up - del resources - - Ngl.end() - - # FIXME: Clean this up (Jakob) - def add_multiple_datasets_npy(self, map_number, title, data): - """ - Method for very large data sets (RAM issues) and useful for PARALLEL - code. Data is copied to npy files (titles still in the list) that - can be loaded afterwards. - - INPUT: title a string describing the data set - data a Numpy array containing the map to be drawn - """ - if map_number > len(self.map_mult_data) - 1: - self.map_mult_data.append([]) - self.map_mult_data[map_number].append(title) - - np.save(str(map_number) + "_" + title, data) - - # FIXME: Clean this up (Jakob) - def generate_multiple_map_plots_npy(self, map_names, map_scales, - title_on=True, labels_on=True): - """ - Method for very large datasets (RAM issues) and useful for PARALLEL - code. Generates map plots from the datasets stored in the npy files - and the list of titles. The data is sorted as parallel computation - mixes it up. Stores the plots in the file indicated by filename in the - current directory. - """ - # Set resources - resources = self.resources - - # Set plot title - if title_on: - resources.tiMainString = self.title - - for k, map_data in enumerate(self.map_mult_data): - # Open a workstation for every map, only wks_type = "ps" allows - # multiple workstation - - # Sort dataset, as parallel code will mix it - map_data.sort() - - # Define own levels - resources.cnLevelSelectionMode = "ExplicitLevels" - resources.cnLevels = map_scales[k] - - wks_type = "pdf" - wks = Ngl.open_wks(wks_type, map_names[k], resources) - - # - # Generate map plots - # - for ititle in map_data: - # Set title - if labels_on: - resources.lbTitleString = ititle - - data = np.load(str(k) + "_" + ititle + ".npy") - # Reshape for visualization on the sphere - data.shape = (self.grid.grid_size()["lat"], - self.grid.grid_size()["lon"]) - - # Generate map plot - cmap = Ngl.contour_map(wks, data, resources) - - # Clear map - del cmap - Ngl.destroy(wks) - - # Clean up - for file_name in glob.glob('*.npy'): - os.remove(file_name) - del resources - - Ngl.end() - - # FIXME: Possibly bogus method? - def save_ps_map(self, title, data, labels_on=True): - """ - Directly create a PS file of data with filename=title. - Assumes normalized data between 0 and 1. - - INPUT: title a string describing the dataset data a numpy array - containing the map to be drawn - """ - # Change the levels of contouring - resources = self.resources - resources.cnLevelSelectionMode = "ExplicitLevels" # Define own levels. - resources.cnLevels = np.arange(0., 1., 0.05) - - wks_type = "ps" - wks = Ngl.open_wks(wks_type, title, resources) - - if labels_on: - resources.lbTitleString = title - - # Reshape for visualization on the sphere - data.shape = (self.grid.grid_size()["lat"], - self.grid.grid_size()["lon"]) - - # Generate map plot - cmap = Ngl.contour_map(wks, data, resources) - - # Clear map - del cmap - Ngl.destroy(wks) - - # Clean up - del resources - - Ngl.end() diff --git a/src/pyunicorn/core/__init__.py b/src/pyunicorn/core/__init__.py index c95cf801..cecc4cc1 100644 --- a/src/pyunicorn/core/__init__.py +++ b/src/pyunicorn/core/__init__.py @@ -26,7 +26,6 @@ To do ~~~~~ - A lot - See current product backlog. - - Clean up MapPlots class -> Alex!? Known Bugs ~~~~~~~~~~ diff --git a/tests/test_climate/test_map_plot.py b/tests/test_climate/test_map_plot.py new file mode 100644 index 00000000..f28e8804 --- /dev/null +++ b/tests/test_climate/test_map_plot.py @@ -0,0 +1,51 @@ +# This file is part of pyunicorn. +# Copyright (C) 2008--2023 Jonathan F. Donges and pyunicorn authors +# URL: +# License: BSD (3-clause) +# +# Please acknowledge and cite the use of this software and its authors +# when results are used in publications or published elsewhere. +# +# You can use the following reference: +# J.F. Donges, J. Heitzig, B. Beronov, M. Wiedermann, J. Runge, Q.-Y. Feng, +# L. Tupikina, V. Stolbova, R.V. Donner, N. Marwan, H.A. Dijkstra, +# and J. Kurths, "Unified functional network and nonlinear time series analysis +# for complex systems science: The pyunicorn package" +""" +Simple test for the MapPlot class. +""" + +import matplotlib.pyplot as plt + +from pyunicorn.climate.climate_data import ClimateData +from pyunicorn.climate.tsonis import TsonisClimateNetwork +from pyunicorn.climate.map_plot import MapPlot + + +def test_map_plot(): + """ + Simple test for the MapPlot class. + + No sanity checks, only testing if it runs without errors. + """ + # prepare ClimateNetwork fixture + file = 'notebooks/air.mon.mean.nc' + # select subset of data to speed up loading and calculation + window = { + "time_min": 0., "time_max": 0., + "lat_min": 30, "lon_min": 0, + "lat_max": 50, "lon_max": 30} + data = ClimateData.Load( + file_name=file, observable_name="air", + file_type="NetCDF", window=window, time_cycle=12) + + # create MapPlot + map_plot = MapPlot(data.grid, "ncep_ncar_reanalysis") + assert map_plot.title == "ncep_ncar_reanalysis" + + net = TsonisClimateNetwork(data, threshold=.05, winter_only=False) + degree = net.degree() + # plot, with suppressed display + plt.ioff() + map_plot.plot(degree, "Degree") + plt.close() From 104db178c07d400580eeeb3978ad415793512f0f Mon Sep 17 00:00:00 2001 From: ntfrgl Date: Wed, 31 Jan 2024 18:37:01 -0800 Subject: [PATCH 40/44] CI: Refactor & debug build config - consolidate build matrix - remove `language: python` - macOS: force GNU `sed` - Windows: pass `$WINDIR` into `tox` --- .travis.yml | 209 ++++++++++++++++++++++++++-------------------------- README.rst | 11 +-- setup.cfg | 11 +-- 3 files changed, 118 insertions(+), 113 deletions(-) diff --git a/.travis.yml b/.travis.yml index b5f7d745..a4cba78c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,112 +1,115 @@ + +# ----------------------------------------------------------------------------- +# documentation & validation +# ----------------------------------------------------------------------------- + +# - https://docs.travis-ci.com/user/reference/overview +# - https://docs.travis-ci.com/user/build-matrix/ +# - https://docs.travis-ci.com/user/multi-os/ + +# - https://docs.travis-ci.com/user/build-config-validation/ +# - https://config.travis-ci.com/explore + +# ----------------------------------------------------------------------------- +# meta +# ----------------------------------------------------------------------------- + +# enable build config validation version: ~> 1.0 -# require the branch name to be master +# save Travis budget if: branch = master -jobs: - include: - # # linux jobs - # - os: linux - # dist: focal - # arch: arm64 - # virt: lxd - # sudo: false - # language: python - # python: "3.8" - # - os: linux - # dist: focal - # arch: arm64 - # virt: lxd - # sudo: false - # language: python - # python: "3.9" - # - os: linux - # dist: focal - # arch: arm64 - # virt: lxd - # sudo: false - # language: python - # python: "3.10" - # - os: linux - # dist: focal - # arch: arm64 - # virt: lxd - # sudo: false - # language: python - # python: "3.11" - # - os: linux - # dist: focal - # arch: arm64 - # virt: lxd - # sudo: false - # language: python - # python: "3.12-dev" - # # macOS job - # - os: osx - # osx_image: xcode12.2 - # language: shell # 'language: python' is not available on Travis CI macOS - # Windows job - - os: windows - language: shell - env: - - PATH=/c/Python311:/c/Python311/Scripts:$PATH - - WINDIR=C:\Windows - before_install: - - choco install python --version 3.11.6 - - python -m pip install --upgrade pip - install: - - echo using pip install on windows +# report outcomes +notifications: + email: + on_success: change + on_failure: always + +# ----------------------------------------------------------------------------- +# default jobs: Linux, all Python versions +# ----------------------------------------------------------------------------- + +os: linux +dist: focal +arch: arm64 +virt: lxd +language: generic +env: + global: + - ARCH=Linux-aarch64 + - SED=sed + + jobs: + - PYTHON=3.12 + - PYTHON=3.11 + - PYTHON=3.10 + - PYTHON=3.9 + - PYTHON=3.8 before_install: - # Python package manager - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -O miniconda.sh; fi - - if [ "$TRAVIS_OS_NAME" = "osx" ]; then travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -O miniconda.sh; fi - - bash miniconda.sh -b -p $HOME/miniconda - - export PATH="$HOME/miniconda/bin:$PATH"; hash -r - - conda config --set quiet yes --set always_yes yes --set changeps1 no - - travis_retry conda update -n base -c defaults conda - - travis_retry conda update --all - - conda config --set solver libmamba - - # debugging info - - conda info -a - - conda list + - | # install Python via Miniconda + travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-${ARCH}.sh -O miniconda.sh + bash miniconda.sh -b -p $HOME/miniconda + export PATH="$HOME/miniconda/bin:$PATH"; hash -r + conda config --set quiet yes --set always_yes yes --set changeps1 no + - | + travis_retry conda update -n base -c defaults conda + travis_retry conda update --all + conda config --set solver libmamba + conda info -a + conda list + travis_retry conda create -n test-env + eval "$(conda shell.bash hook)" + conda activate test-env + travis_retry conda install -c conda-forge python=${PYTHON} + + - | # install dependencies + travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm + travis_retry conda update -c conda-forge --all + travis_retry conda install -c conda-forge tox flake8 pylint pytest-xdist pytest-cov codecov + travis_retry conda install -c conda-forge networkx matplotlib cartopy sphinx + conda info -a + conda list install: - # runtime dependencies - - travis_retry conda create -n test-env - - eval "$(conda shell.bash hook)" - - conda activate test-env - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then travis_retry conda install -c conda-forge python=${TRAVIS_PYTHON_VERSION%-dev}; else travis_retry conda install -c conda-forge python=3.9; fi - - travis_retry conda install -c conda-forge numpy scipy python-igraph h5netcdf tqdm - - travis_retry conda update -c conda-forge --all - - # testing dependencies - - travis_retry conda install -c conda-forge tox flake8 pylint pytest-xdist pytest-cov codecov - - travis_retry conda install -c conda-forge networkx matplotlib cartopy sphinx - - # debugging info - - conda info -a - - conda list - -before_script: - # limit parallel processes to available cores (error if pattern not found) - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py; fi - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg; fi - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi - - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sed -i '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml; fi - -script: - # package - - travis_retry pip install -v -e ".[testing,docs]" - - # test suite - - tox -v - -after_success: - - codecov + - | # limit procs to available cores (use GNU `sed`, fail if pattern not found) + [ "${TRAVIS_OS_NAME}" = "osx" ] && brew install gnu-sed || true + ${SED} -i "/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}" setup.py + ${SED} -i "/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}" setup.cfg + ${SED} -i "/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}" pyproject.toml + ${SED} -i "/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}" pyproject.toml -notifications: - email: - on_success: change - on_failure: always + # install self (and dependencies, if on Windows) + - travis_retry pip install -v -e ".[tests,docs]" + +# run test suite +script: tox -v + +# report statistics +after_success: codecov + +# ----------------------------------------------------------------------------- +# modified jobs: OSX + Windows, newest Python version +# (inherit only 1st `env.jobs` entry) +# ----------------------------------------------------------------------------- + +jobs: + fast_finish: true + include: + - os: osx + osx_image: xcode14 + language: shell + env: + - ARCH=MacOSX-x86_64 + - SED=gsed + + - os: windows + language: shell + env: + - ARCH=Windows-x86_64 + - PATH=/c/Python${PYTHON/.}:/c/Python${PYTHON/.}/Scripts:${PATH} + before_install: + - | # install Python via Chocolatey + travis_retry choco install python --version ${PYTHON} + travis_retry python -m pip install --upgrade pip diff --git a/README.rst b/README.rst index 69a89cf4..61f2479c 100644 --- a/README.rst +++ b/README.rst @@ -78,10 +78,11 @@ Installation Dependencies ............ ``pyunicorn`` is implemented in `Python 3 `_ and -`Cython 3 `_, and is tested on *Linux*, *macOS* and -*Windows*. It relies on the following open source or freely available packages, -which need to be installed on your machine. For exact dependency information, -see ``setup.cfg``. +`Cython 3 `_, and is `tested +`_ on *Linux*, *macOS* +and *Windows*. It relies on the following open source or freely available +packages, which need to be installed on your machine. For exact dependency +information, see ``setup.cfg``. Required at runtime: - `numpy `_ @@ -154,7 +155,7 @@ please make sure that all tests pass. The test suite is managed by `tox `_ and is configured to use system-wide packages when available. Install the test dependencies as follows:: - $> pip install .[testing] + $> pip install .[tests] The test suite can be run from anywhere in the project tree by issuing:: diff --git a/setup.cfg b/setup.cfg index bc3701db..15a5671d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -65,7 +65,7 @@ dev = Cython >= 3.0 docs = sphinx >= 7.0 -testing = +tests = tox >= 4.3 flake8 >= 6.0 pylint >= 2.17 @@ -93,7 +93,7 @@ envlist = [testenv] extras = - testing + tests sitepackages = true changedir = {toxinidir} setenv = @@ -107,7 +107,7 @@ allowlist_externals = [testenv:style] skipsdist = true commands = - flake8 + flake8 src/pyunicorn tests [testenv:lint] skipsdist = true @@ -115,12 +115,14 @@ commands = pylint src/pyunicorn tests [testenv:test] +passenv = WINDIR commands = pytest --cov [testenv:docs] extras = docs +passenv = WINDIR commands = sphinx-build -j 8 -W -b html -d {envtmpdir}/doctrees docs/source {envtmpdir}/html @@ -128,8 +130,7 @@ commands = [flake8] extend-exclude = - .git, .cache, .tox, .ropeproject, build, - docs/source/conf.py + .git, .cache, .tox, .ropeproject, build, docs/source/conf.py extend-ignore = E121, E123, E126, E226, E24, E704, E731, F401, F403, F405, F812, F841, W503 per-file-ignores = From fdc95a254fb0fae2878f70327d81204507d35bb2 Mon Sep 17 00:00:00 2001 From: ntfrgl Date: Wed, 31 Jan 2024 19:39:11 -0800 Subject: [PATCH 41/44] CI: Fixup - set env vars in `before_install` phase - remove a layer of quoting in `sed` args --- .travis.yml | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/.travis.yml b/.travis.yml index a4cba78c..dd667b61 100644 --- a/.travis.yml +++ b/.travis.yml @@ -36,10 +36,6 @@ arch: arm64 virt: lxd language: generic env: - global: - - ARCH=Linux-aarch64 - - SED=sed - jobs: - PYTHON=3.12 - PYTHON=3.11 @@ -47,7 +43,9 @@ env: - PYTHON=3.9 - PYTHON=3.8 -before_install: +before_install: export ARCH=Linux-aarch64 SED=sed + +install: - | # install Python via Miniconda travis_retry wget https://repo.anaconda.com/miniconda/Miniconda3-latest-${ARCH}.sh -O miniconda.sh bash miniconda.sh -b -p $HOME/miniconda @@ -72,19 +70,18 @@ before_install: conda info -a conda list -install: +script: - | # limit procs to available cores (use GNU `sed`, fail if pattern not found) - [ "${TRAVIS_OS_NAME}" = "osx" ] && brew install gnu-sed || true - ${SED} -i "/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}" setup.py - ${SED} -i "/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}" setup.cfg - ${SED} -i "/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}" pyproject.toml - ${SED} -i "/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}" pyproject.toml + ${SED} -i '/nthreads=./{s//nthreads=2/;h}; ${x;/./{x;q0};x;q1}' setup.py + ${SED} -i '/-j ./ {s//-j 2/; h}; ${x;/./{x;q0};x;q1}' setup.cfg + ${SED} -i '/-n auto/ {s//-n 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml + ${SED} -i '/jobs = ./ {s//jobs = 2/; h}; ${x;/./{x;q0};x;q1}' pyproject.toml # install self (and dependencies, if on Windows) - travis_retry pip install -v -e ".[tests,docs]" -# run test suite -script: tox -v + # run test suite + - tox -v # report statistics after_success: codecov @@ -100,16 +97,15 @@ jobs: - os: osx osx_image: xcode14 language: shell - env: - - ARCH=MacOSX-x86_64 - - SED=gsed + before_install: export ARCH=MacOSX-x86_64 SED=gsed + before_script: brew install gnu-sed - os: windows language: shell - env: - - ARCH=Windows-x86_64 - - PATH=/c/Python${PYTHON/.}:/c/Python${PYTHON/.}/Scripts:${PATH} before_install: + - export ARCH=Windows-x86_64 SED=sed + - export PATH=/c/Python${PYTHON/.}:/c/Python${PYTHON/.}/Scripts:${PATH} + install: - | # install Python via Chocolatey travis_retry choco install python --version ${PYTHON} travis_retry python -m pip install --upgrade pip From 0040db9a41b4d9bd65cf74ae2fa9734bd54c8ee5 Mon Sep 17 00:00:00 2001 From: ntfrgl Date: Wed, 31 Jan 2024 21:10:35 -0800 Subject: [PATCH 42/44] CI: Speed up - Tox: skip package installation inside venv (packaging & Cython have matured) - Travis: avoid `brew update` --- .travis.yml | 34 ++++++++++++++++++++-------------- setup.cfg | 14 ++++++-------- 2 files changed, 26 insertions(+), 22 deletions(-) diff --git a/.travis.yml b/.travis.yml index dd667b61..e15e3d12 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,10 @@ +# This file is part of pyunicorn. +# Copyright (C) 2008--2024 Jonathan F. Donges and pyunicorn authors +# URL: +# License: BSD (3-clause) -# ----------------------------------------------------------------------------- -# documentation & validation -# ----------------------------------------------------------------------------- + +# documentation & validation ================================================== # - https://docs.travis-ci.com/user/reference/overview # - https://docs.travis-ci.com/user/build-matrix/ @@ -10,9 +13,8 @@ # - https://docs.travis-ci.com/user/build-config-validation/ # - https://config.travis-ci.com/explore -# ----------------------------------------------------------------------------- -# meta -# ----------------------------------------------------------------------------- + +# meta ======================================================================== # enable build config validation version: ~> 1.0 @@ -26,9 +28,8 @@ notifications: on_success: change on_failure: always -# ----------------------------------------------------------------------------- -# default jobs: Linux, all Python versions -# ----------------------------------------------------------------------------- + +# default jobs: Linux, all Python versions ==================================== os: linux dist: focal @@ -86,10 +87,14 @@ script: # report statistics after_success: codecov -# ----------------------------------------------------------------------------- -# modified jobs: OSX + Windows, newest Python version + +# modified jobs: OSX + Windows, newest Python version ========================= # (inherit only 1st `env.jobs` entry) -# ----------------------------------------------------------------------------- + +addons: + homebrew: + update: false + packages: gnu-sed jobs: fast_finish: true @@ -97,8 +102,9 @@ jobs: - os: osx osx_image: xcode14 language: shell - before_install: export ARCH=MacOSX-x86_64 SED=gsed - before_script: brew install gnu-sed + before_install: + - export ARCH=MacOSX-x86_64 SED=gsed + - export HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 - os: windows language: shell diff --git a/setup.cfg b/setup.cfg index 15a5671d..11af02c7 100644 --- a/setup.cfg +++ b/setup.cfg @@ -65,6 +65,7 @@ dev = Cython >= 3.0 docs = sphinx >= 7.0 + matplotlib tests = tox >= 4.3 flake8 >= 6.0 @@ -92,12 +93,13 @@ envlist = docs [testenv] -extras = - tests +skip_install = true +skipsdist = true sitepackages = true changedir = {toxinidir} setenv = PYTHONPATH = {toxinidir}/src +passenv = WINDIR, LC_ALL allowlist_externals = flake8 pylint @@ -105,24 +107,20 @@ allowlist_externals = sphinx-build [testenv:style] -skipsdist = true commands = flake8 src/pyunicorn tests [testenv:lint] -skipsdist = true commands = pylint src/pyunicorn tests [testenv:test] -passenv = WINDIR +extras = tests commands = pytest --cov [testenv:docs] -extras = - docs -passenv = WINDIR +extras = docs commands = sphinx-build -j 8 -W -b html -d {envtmpdir}/doctrees docs/source {envtmpdir}/html From 138a4454291a17e3e5f2e065a8a7c835d2922f94 Mon Sep 17 00:00:00 2001 From: ntfrgl Date: Wed, 31 Jan 2024 21:37:02 -0800 Subject: [PATCH 43/44] CI: Fixup - don't trust the documentation --- .travis.yml | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index e15e3d12..cf8b77cc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -91,11 +91,6 @@ after_success: codecov # modified jobs: OSX + Windows, newest Python version ========================= # (inherit only 1st `env.jobs` entry) -addons: - homebrew: - update: false - packages: gnu-sed - jobs: fast_finish: true include: @@ -105,6 +100,7 @@ jobs: before_install: - export ARCH=MacOSX-x86_64 SED=gsed - export HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 + - travis_retry brew install gnu-sed - os: windows language: shell From 562581f4918f7f394ced1cf4df75ba9e14db3629 Mon Sep 17 00:00:00 2001 From: ntfrgl Date: Fri, 2 Feb 2024 00:06:27 -0800 Subject: [PATCH 44/44] MAINT: Minor edits to `MapPlots` --- README.rst | 4 - notebooks/tutorial_ClimateNetworks.ipynb | 269 +++++++---------------- src/pyunicorn/__init__.py | 6 - src/pyunicorn/climate/__init__.py | 9 - src/pyunicorn/climate/map_plot.py | 36 ++- src/pyunicorn/core/__init__.py | 9 - src/pyunicorn/eventseries/__init__.py | 5 - src/pyunicorn/funcnet/__init__.py | 9 - src/pyunicorn/utils/__init__.py | 9 - tests/test_climate/test_map_plot.py | 55 ++--- 10 files changed, 127 insertions(+), 284 deletions(-) diff --git a/README.rst b/README.rst index 61f2479c..3eed7617 100644 --- a/README.rst +++ b/README.rst @@ -93,11 +93,7 @@ Required at runtime: (for ``Data`` and ``NetCDFDictionary``) Optional *(used only in certain classes and methods)*: - - `PyNGL `_ - (for ``NetCDFDictionary``) - `Matplotlib `_ - - `Matplotlib Basemap Toolkit `_ - (for drawing maps) - `Cartopy `_ (for some plotting features) - `mpi4py `_ diff --git a/notebooks/tutorial_ClimateNetworks.ipynb b/notebooks/tutorial_ClimateNetworks.ipynb index cfb4de24..d0650e42 100644 --- a/notebooks/tutorial_ClimateNetworks.ipynb +++ b/notebooks/tutorial_ClimateNetworks.ipynb @@ -13,7 +13,7 @@ "id": "677ae7d7", "metadata": {}, "source": [ - "The objective of this tutorial is to introduce climate networks and explain and illustrate their application with the __pyunicorn__ package. First some theoretical background for understanding general climate networks will be given and then some methods provided by `pyunicorn.climate.ClimateNetwork` will be illustrated. An introduction and application of coupled climate networks will follow. For a detailed discussion and further references, please consult __[Donges et al., 2015](https://aip.scitation.org/doi/10.1063/1.4934554)__, on which this tutorial is based. " + "The objective of this tutorial is to introduce climate networks, and to explain and illustrate their application with the `pyunicorn` package. First some theoretical background for understanding general climate networks will be given, and then some methods provided by `pyunicorn.climate.ClimateNetwork` will be illustrated. An introduction and application of coupled climate networks will follow. For a detailed discussion and further references, please consult __[Donges et al., 2015](https://aip.scitation.org/doi/10.1063/1.4934554)__, on which this tutorial is based. " ] }, { @@ -29,9 +29,9 @@ "id": "a56c11e0", "metadata": {}, "source": [ - "_Climate networks (CN)_ are a way to apply complex network theory to the climate system, by assuming that each node represents a varying dynamical system. Of interest is then the collective behaviour of these interacting dynamical system and the structure of the resulting network. This approach was first introduced by __[Tsonis and Roebber, 2004](https://www.sciencedirect.com/science/article/abs/pii/S0378437103009646)__.\n", + "_Climate networks (CN)_ are a way to apply complex network theory to the climate system, by assuming that each node represents a varying dynamical system. Of interest is then the collective behaviour of these interacting dynamical systems and the structure of the resulting network. This approach was first introduced by __[Tsonis and Roebber, 2004](https://www.sciencedirect.com/science/article/abs/pii/S0378437103009646)__.\n", "\n", - "Climate network analysis is a versatile approach for investigating climatological data and can be used as a complementary method to classical techniques from multivariate statistics. The approach allows for the analysis of single fields of climatological time series, e.g. surface air temperature observed on a grid, or even two or more fields. It has been succesfully applied in many cases, for example to dynamics and predictability of the El Niño Phenomenon \\[__[Radebach et al., 2013](https://arxiv.org/abs/1310.5494)__\\]." + "CN analysis is a versatile approach for investigating climatological data, and it can be used as a complementary method to classical techniques from multivariate statistics. The approach allows for the analysis of single fields of climatological time series, e.g., surface air temperature observed on a grid, or even two or more fields. It has been successfully applied in many cases, for example to dynamics and predictability of the El Niño Phenomenon (__[Radebach et al., 2013](https://arxiv.org/abs/1310.5494)__)." ] }, { @@ -39,7 +39,7 @@ "id": "05e76cc7", "metadata": {}, "source": [ - "## Theory of Climate Networks (CN)" + "## Theory of Climate Networks (CNs)" ] }, { @@ -47,7 +47,7 @@ "id": "fcc79d2d", "metadata": {}, "source": [ - "Climate networks (class `climate.ClimateNetwork`) are a typical application of _functional networks_, which allow to study the dynamical relationships between subsystems of a high-dimensional complex system by constructing networks from it. The package provides classes for the construction and analysis of such networks, representing the statistical interdependency structure within and between fields of time series using various similarity measures." + "CNs are a typical application of _functional networks_, which allow to study the dynamical relationships between subsystems of a high-dimensional complex system by constructing networks from it. `pyunicorn` provides classes for the construction and analysis of such networks, representing the statistical interdependency structure within and between fields of time series using various similarity measures." ] }, { @@ -63,13 +63,9 @@ "id": "30cd9555", "metadata": {}, "source": [ - "Climate Networks represent strong statistical interrelationships between time series of climatological fields. These statistical interrelationships can be estimated with methods from the `timeseries.CouplingAnalysis` class in terms of matrices of _statistical similarities_ $\\textbf{S}$, such as the _(lagged) classical linear Pearson product-moment correlation coefficient_ (CC). \n", - "\n", - "The CC of two zero-mean time series Variable $X$,$Y$, implemented in `CouplingAnalysis.cross_correlation`, is given by \n", - "\n", - "$$\\rho_{XY}(\\tau)=\\frac{\\langle X_{t-\\tau}, Y_t \\rangle}{\\sigma_X \\sigma_Y}$$\n", - "\n", - "which depents on the covariance $\\langle X_{t-\\tau}, Y_t \\rangle$ and standard deviations $\\sigma_X, \\sigma_Y$. Lags $\\tau > 0$ correspond to the linear association of past values of $X$ with $Y$, and vice versa for $\\tau < 0$. " + "CNs represent strong statistical interrelationships between time series of climatological fields. These statistical interrelationships can be estimated with methods from the `funcnet.CouplingAnalysis` class in terms of matrices of _statistical similarities_ $\\textbf{S}$, such as the _(lagged) classical linear Pearson product-moment correlation coefficient_ (CC). The CC of two zero-mean time series variables $X,Y$, as implemented in `funcnet.CouplingAnalysis.cross_correlation()`, is given by \n", + "$$\\rho_{XY}(\\tau)=\\frac{\\langle X_{t-\\tau}, Y_t \\rangle}{\\sigma_X \\sigma_Y}\\,,$$\n", + "which depends on the covariance $\\langle X_{t-\\tau}, Y_t \\rangle$ and the standard deviations $\\sigma_X, \\sigma_Y$. Lags $\\tau > 0$ correspond to the linear association of past values of $X$ with $Y$, and vice versa for $\\tau < 0$. " ] }, { @@ -77,7 +73,7 @@ "id": "70377c40", "metadata": {}, "source": [ - "#### Similarity Measures for Climate Networks" + "### Similarity Measures for CNs" ] }, { @@ -85,13 +81,9 @@ "id": "fadb2909", "metadata": {}, "source": [ - "By thresholding the matrix of a statistical similarity measure $\\textbf{S}$, e.g. based on the CC from above, the interellationships between time series of climate networks can be reconstructed:\n", - "\n", - "$$A_{pq} = \\Theta(S_{pq}-\\beta), \\text{ if } p \\neq q$$\n", - "\n", - "and 0 otherwise. $\\Theta$ is the Heaviside function, $\\beta$ denotes a threshold parameter and $A_{pp} = 0$ is set for all nodes $p$ to exclude self-loops. \n", - "\n", - "A climate network that is reconstructed using the pearson correlation from above is call _pearson correlation climate network_." + "By thresholding the matrix of a statistical similarity measure $\\textbf{S}$, the interrelationships between time series of climate networks can be reconstructed:\n", + "$$A_{pq} = \\Theta(S_{pq}-\\beta)\\quad \\text{ if } p \\neq q; \\qquad 0\\quad\\text{otherwise}\\,,$$\n", + "where $\\Theta$ is the Heaviside function, $\\beta$ denotes a threshold parameter, and $A_{pp} = 0$ for all nodes $p$ to exclude self-loops. A CN that is reconstructed using the Pearson CC from above is called a _Pearson correlation CN_." ] }, { @@ -99,79 +91,43 @@ "id": "9c64c013", "metadata": {}, "source": [ - "## Constructing CN with pyunicorn" + "## Constructing CNs" ] }, { + "attachments": {}, "cell_type": "markdown", - "id": "3027c7f8", + "id": "ff7f5d81-129e-4966-a7fc-a0d25aea87f3", "metadata": {}, "source": [ - "After establishing some basic theoretic background, we can use pyunicorn to try out some tools for climate networks. First, download the data set following this __[link](https://psl.noaa.gov/repository/entry/show?entryid=synth%3Ae570c8f9-ec09-4e89-93b4-babd5651e7a9%3AL25jZXAucmVhbmFseXNpcy5kZXJpdmVkL3N1cmZhY2UvYWlyLm1vbi5tZWFuLm5j)__ and copy it to the directory \"notebooks\" of this script ot change the path below." + "Having established some basic theoretic background, we will now use `pyunicorn` to construct a CN. We start with some imports and some specifications regarding an example __[NOAA dataset](https://psl.noaa.gov/repository/entry/show?entryid=synth%3Ae570c8f9-ec09-4e89-93b4-babd5651e7a9%3AL25jZXAucmVhbmFseXNpcy5kZXJpdmVkL3N1cmZhY2UvYWlyLm1vbi5tZWFuLm5j)__, which is already contained in this notebook's directory." ] }, { "cell_type": "code", "execution_count": 1, - "id": "35c8e273", - "metadata": {}, - "outputs": [], - "source": [ - "DATA_FILENAME = \"./air.mon.mean.nc\"" - ] - }, - { - "cell_type": "markdown", - "id": "543a9d17", - "metadata": {}, - "source": [ - "Now we will start with some imports and some specifications regarding the data set." - ] - }, - { - "cell_type": "code", - "execution_count": 2, "id": "e793f1a2", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", - "from pyunicorn import climate\n", - "from matplotlib import pyplot as plt" + "from matplotlib import pyplot as plt\n", + "from pyunicorn import climate" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "a1e3f614", + "execution_count": 2, + "id": "6f1a55f9-8560-484d-ab6a-17ba8b8cd67c", "metadata": {}, "outputs": [], "source": [ - "FILE_TYPE = \"NetCDF\"\n", + "DATA_FILENAME = \"./air.mon.mean.nc\"\n", + "# Indicate data source (optional)\n", + "DATA_SOURCE = \"ncep_ncar_reanalysis\"\n", "# Type of data file (\"NetCDF\" indicates a NetCDF file with data on a regular\n", "# lat-lon grid, \"iNetCDF\" allows for arbitrary grids - > see documentation).\n", - "# For example, the \"NetCDF\" FILE_TYPE is compatible with data from the IPCC\n", - "# AR4 model ensemble or the reanalysis data provided by NCEP/NCAR." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "766f7c90", - "metadata": {}, - "outputs": [], - "source": [ - "# Indicate data source (optional)\n", - "DATA_SOURCE = \"ncep_ncar_reanalysis\"" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "30518b4e", - "metadata": {}, - "outputs": [], - "source": [ + "FILE_TYPE = \"NetCDF\"\n", "# Name of observable in NetCDF file (\"air\" indicates surface air temperature\n", "# in NCEP/NCAR reanalysis data)\n", "OBSERVABLE_NAME = \"air\"" @@ -179,68 +135,32 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "24efb40c", + "execution_count": 3, + "id": "12e44ccb-ba25-4bf9-8170-ed12310b739b", "metadata": {}, "outputs": [], "source": [ - "# Select a subset in time and space from the data (e.g., a particular region\n", - "# or a particular time window, or both)\n", + "# Select a region in time and space from the data (here the whole dataset)\n", "WINDOW = {\"time_min\": 0., \"time_max\": 0., \"lat_min\": 0, \"lon_min\": 0,\n", - " \"lat_max\": 30, \"lon_max\": 0} # selects the whole data set" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6373f01d", - "metadata": {}, - "outputs": [], - "source": [ + " \"lat_max\": 30, \"lon_max\": 0}\n", "# Indicate the length of the annual cycle in the data (e.g., 12 for monthly\n", - "# data). This is used for calculating climatological anomaly values\n", - "# correctly.\n", + "# data). This is used for calculating climatological anomaly values.\n", "TIME_CYCLE = 12" ] }, { + "attachments": {}, "cell_type": "markdown", - "id": "ef63ac55", + "id": "9f54ffe5-02a5-47e4-a459-870e1e8afef6", "metadata": {}, "source": [ - "Now we set some values related to the climate network construction, the first being the threshold $\\beta$ from above." + "Now we set some parameters for the CN construction, the first being the threshold $\\beta$ from above, and create a `ClimateData` object containing our data." ] }, { "cell_type": "code", - "execution_count": 8, - "id": "b6cf01fc", - "metadata": {}, - "outputs": [], - "source": [ - "# For setting fixed threshold\n", - "THRESHOLD = 0.5\n", - "\n", - "# For setting fixed link density\n", - "LINK_DENSITY = 0.005\n", - "\n", - "# Indicates whether to use only data from winter months (DJF) for calculating\n", - "# correlations\n", - "WINTER_ONLY = False" - ] - }, - { - "cell_type": "markdown", - "id": "dc905586", - "metadata": {}, - "source": [ - "Now we create a ClimateData object containing our data and then print the information." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "4e49c74a", + "execution_count": 4, + "id": "baf245bd-2f3e-401d-bc1d-9943fee4bbf2", "metadata": { "scrolled": true }, @@ -249,13 +169,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Reading NetCDF File and converting data to NumPy array...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Reading NetCDF File and converting data to NumPy array...\n", "Global attributes:\n", "description: Data from NCEP initialized reanalysis (4x/day). These are the 0.9950 sigma level values\n", "platform: Model\n", @@ -285,26 +199,33 @@ } ], "source": [ + "# For setting fixed threshold\n", + "THRESHOLD = 0.5\n", + "# For setting fixed link density\n", + "LINK_DENSITY = 0.005\n", + "# Indicates whether to use only data from winter months (DJF) for calculating\n", + "# correlations\n", + "WINTER_ONLY = False\n", + "\n", "data = climate.ClimateData.Load(\n", " file_name=DATA_FILENAME, observable_name=OBSERVABLE_NAME,\n", " data_source=DATA_SOURCE, file_type=FILE_TYPE,\n", " window=WINDOW, time_cycle=TIME_CYCLE)\n", - "\n", - "# Print some information on the data set\n", "print(data)" ] }, { + "attachments": {}, "cell_type": "markdown", - "id": "2980a2c0", + "id": "2fade6f6-8457-436f-a52a-77464e92fd54", "metadata": {}, "source": [ - "Now we create a climate network based on Pearson correlation without lag and with fixed threshold." + "Next, we construct a CN based on the Pearson CC, without lag and with fixed threshold. Alternatively, several other similarity measures and construction mechanisms may be used as well." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "id": "c5326b90", "metadata": {}, "outputs": [ @@ -313,13 +234,7 @@ "output_type": "stream", "text": [ "Generating a Tsonis climate network...\n", - "Calculating daily (monthly) anomaly values...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Calculating daily (monthly) anomaly values...\n", "Calculating correlation matrix at zero lag from anomaly values...\n", "Extracting network adjacency matrix by thresholding...\n", "Setting area weights according to type surface ...\n", @@ -333,30 +248,38 @@ ] }, { - "cell_type": "markdown", - "id": "5e7b5963", + "cell_type": "code", + "execution_count": 6, + "id": "2cdee7ef-7d2f-46d9-83ed-c9253e0100c0", "metadata": {}, + "outputs": [], "source": [ - "Alternatively, several similarity measures and construction mechanisms may be chosen here." + "# Create a climate network based on Pearson correlation without lag and with\n", + "# fixed link density\n", + "# net = climate.TsonisClimateNetwork(\n", + "# data, link_density=LINK_DENSITY, winter_only=WINTER_ONLY)" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "b8c963fd", + "execution_count": 7, + "id": "e6bf3b44-193b-48c0-b7be-f056bd35d72c", "metadata": {}, "outputs": [], "source": [ - "# Create a climate network based on Pearson correlation without lag and with\n", - "# fixed link density\n", - "# net = climate.TsonisClimateNetwork(\n", - "# data, link_density=LINK_DENSITY, winter_only=WINTER_ONLY)\n", - "\n", "# Create a climate network based on Spearman's rank order correlation without\n", "# lag and with fixed threshold\n", "# net = climate.SpearmanClimateNetwork(\n", - "# data, threshold=THRESHOLD, winter_only=WINTER_ONLY)\n", - "\n", + "# data, threshold=THRESHOLD, winter_only=WINTER_ONLY)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5cdcfc8a-6448-4df3-b49f-f3e5d220f0f2", + "metadata": {}, + "outputs": [], + "source": [ "# Create a climate network based on mutual information without lag and with\n", "# fixed threshold\n", "# net = climate.MutualInfoClimateNetwork(\n", @@ -368,12 +291,12 @@ "id": "b443476e", "metadata": {}, "source": [ - "We finish by calculating some network measures, optionally saving them to text files." + "We finish by calculating some basic network measures for the resulting CN, optionally saving them to text files." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "4f568b0f", "metadata": {}, "outputs": [ @@ -407,13 +330,8 @@ "# Get maximum link distance\n", "mld = net.max_link_distance()\n", "\n", - "#\n", - "# Save results to text file\n", - "#\n", - "\n", "# Save the grid (mainly vertex coordinates) to text files\n", "#data.grid.save_txt(filename=\"grid.txt\")\n", - "\n", "# Save the degree sequence. Other measures may be saved similarly.\n", "#np.savetxt(\"degree.txt\", degree)" ] @@ -423,45 +341,24 @@ "id": "15af9941", "metadata": {}, "source": [ - "### Plotting" + "## Plotting CNs" ] }, { + "attachments": {}, "cell_type": "markdown", - "id": "4ee5b44c", + "id": "b26e5953-53c6-418a-b08b-509ad415081f", "metadata": {}, "source": [ - "`pyunicorn` provides a basic plotting feature based on the `cartopy` package and `matplotlib` that can be used to have a first look at the generated data.\n", - "\n", - "> For more info on and how to install cartopy please check out their webpage: https://scitools.org.uk/cartopy/docs/latest/\n", - "> \n", - "> *Copyright: Cartopy. Met Office. git@github.com:SciTools/cartopy.git.* " - ] - }, - { - "cell_type": "markdown", - "id": "51440d40", - "metadata": {}, - "source": [ - "We start by initializing a MapPlot object, which we can then use to plot data." + "`pyunicorn` provides a basic plotting feature based on the __[`cartopy`](https://scitools.org.uk/cartopy/docs/latest/)__ and `matplotlib` packages, which can be used to have a first look at the generated data. We start by initializing a `MapPlot` object:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 10, "id": "b823297c", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created MapPlot.\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "# create a Cartopy plot instance called map_plot\n", "# from the data with title DATA_SOURCE\n", @@ -473,12 +370,12 @@ "id": "422af668", "metadata": {}, "source": [ - "With `MapPlot.plot()` we can now plot some of our previously calculated measures on the given grid." + "With `MapPlot.plot()`, we can now plot some of our previously calculated measures on the given grid." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 11, "id": "056f3a92", "metadata": {}, "outputs": [ @@ -513,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "id": "8b67424d", "metadata": {}, "outputs": [ @@ -541,9 +438,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "pyunicorn", "language": "python", - "name": "python3" + "name": "pyunicorn" }, "language_info": { "codemirror_mode": { @@ -555,7 +452,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/src/pyunicorn/__init__.py b/src/pyunicorn/__init__.py index 68036bd7..93a9215f 100644 --- a/src/pyunicorn/__init__.py +++ b/src/pyunicorn/__init__.py @@ -16,7 +16,6 @@ pyunicorn ========= - Subpackages ----------- core @@ -27,11 +26,6 @@ Functional networks timeseries Time series surrogates - -To Do ------ - - A lot - See current product backlog. - """ from .version import __version__ diff --git a/src/pyunicorn/climate/__init__.py b/src/pyunicorn/climate/__init__.py index ffe9da4c..3ff47560 100644 --- a/src/pyunicorn/climate/__init__.py +++ b/src/pyunicorn/climate/__init__.py @@ -22,15 +22,6 @@ ~~~~~~~~~~~~~~~~~~~~ [Donges2009c]_, [Donges2009a]_, [Donges2009b]_, [Donges2011a]_, [Zou2011]_, [Tominski2011]_, [Heitzig2012]_ - -To do -~~~~~ - - A lot - See current product backlog. - -Known Bugs -~~~~~~~~~~ - - ... - """ from ..core import GeoNetwork, GeoGrid, Network diff --git a/src/pyunicorn/climate/map_plot.py b/src/pyunicorn/climate/map_plot.py index b050b259..1611f1aa 100644 --- a/src/pyunicorn/climate/map_plot.py +++ b/src/pyunicorn/climate/map_plot.py @@ -17,6 +17,7 @@ multivariate data and generating time series surrogates. """ +import numpy as np import matplotlib.pyplot as plt try: @@ -26,6 +27,8 @@ print("climate: Package cartopy could not be loaded. Some functionality " "in class MapPlot might not be available!") +from ..core import Grid + # # Define class MapPlot # @@ -33,28 +36,20 @@ # pylint: disable=too-few-public-methods class MapPlot: - """ - Encapsulates map plotting functions via cartopy and matplotlib. + Encapsulates map plotting functions via Cartopy and Matplotlib. """ - def __init__(self, grid, title): + def __init__(self, grid: Grid, title: str): """ - Initialize an instance of MapPlot. - - Plotting of maps is powered by cartopy and matplotlib. - - :type grid: :class:`.Grid` - :arg grid: The Grid object describing the map data to be plotted. + :arg grid: The `Grid` object describing the map data to be plotted. :arg str title: The title describing the map data. """ - self.grid = grid - """(Grid) - The Grid object on which the map data will be plotted.""" - self.title = title - """(string) - The title describing the map data.""" + self.grid: Grid = grid + self.title: str = title # - # Adjust cartopy settings, fine tuning can be done externally + # Adjust Cartopy settings, fine tuning can be done externally # # Specify Coordinate Refference System for Map Projection @@ -79,14 +74,12 @@ def __init__(self, grid, title): self.data_extent = [self.lon_min, self.lon_max, self.lat_min, self.lat_max] - print("Created MapPlot.") - - def plot(self, data, label): + def plot(self, data: np.ndarray, label: str): """ - Plot dataset onto ``self.grid`` using cartopy and matplotlib. - A simple setup to get a quick view of your data. + Plot dataset onto ``self.grid``. A simple setup to get a quick view of + your data. - The plot can be customized by calling additional matplotlib or cartopy + The plot can be customized by calling additional Matplotlib or Cartopy methods afterwards. It can then be saved via ``plt.savefig()``. :arg ndarray data: The dataset to be plotted on the Grid. @@ -100,7 +93,7 @@ def plot(self, data, label): gax = plt.axes(projection=self.projection) # create some standards of plotting that can be adjusted - # before calling generate_cartopy_plot + # before calling ``generate_cartopy_plot()`` # adjust size and plot coastlines and borders gax.set_extent(self.data_extent, crs=self.crs) # ax.set_global() @@ -115,6 +108,7 @@ def plot(self, data, label): ) gl.xlabel_style = {"size": 7} gl.ylabel_style = {"size": 7} + # plot data upon map plt.tricontourf(self.lon, self.lat, data, extent=self.data_extent, transform=self.crs) diff --git a/src/pyunicorn/core/__init__.py b/src/pyunicorn/core/__init__.py index cecc4cc1..e9c16302 100644 --- a/src/pyunicorn/core/__init__.py +++ b/src/pyunicorn/core/__init__.py @@ -22,15 +22,6 @@ Related Publications ~~~~~~~~~~~~~~~~~~~~ [Donges2011a]_, [Heitzig2012]_, [Donges2012]_ - -To do -~~~~~ - - A lot - See current product backlog. - -Known Bugs -~~~~~~~~~~ - - ... - """ # diff --git a/src/pyunicorn/eventseries/__init__.py b/src/pyunicorn/eventseries/__init__.py index e1e857b3..852fd1bf 100644 --- a/src/pyunicorn/eventseries/__init__.py +++ b/src/pyunicorn/eventseries/__init__.py @@ -27,11 +27,6 @@ To do ~~~~~ - Combine precursor and trigger coincidence rate to obtain one ECA measure - -Known Bugs -~~~~~~~~~~ - - ... - """ from .event_series import EventSeries diff --git a/src/pyunicorn/funcnet/__init__.py b/src/pyunicorn/funcnet/__init__.py index 857b20e2..e7e69dd8 100644 --- a/src/pyunicorn/funcnet/__init__.py +++ b/src/pyunicorn/funcnet/__init__.py @@ -16,18 +16,9 @@ funcnet ======= - Related Publications ~~~~~~~~~~~~~~~~~~~~ -To do -~~~~~ - - ... - -Known Bugs -~~~~~~~~~~ - - ... - """ from .coupling_analysis import CouplingAnalysis diff --git a/src/pyunicorn/utils/__init__.py b/src/pyunicorn/utils/__init__.py index c19a007a..9f22ed4d 100644 --- a/src/pyunicorn/utils/__init__.py +++ b/src/pyunicorn/utils/__init__.py @@ -16,15 +16,6 @@ utils ===== - -To do -~~~~~ - - ... - -Known Bugs -~~~~~~~~~~ - - ... - """ __all__ = ['mpi', 'navigator'] diff --git a/tests/test_climate/test_map_plot.py b/tests/test_climate/test_map_plot.py index f28e8804..cd6f5577 100644 --- a/tests/test_climate/test_map_plot.py +++ b/tests/test_climate/test_map_plot.py @@ -11,9 +11,6 @@ # L. Tupikina, V. Stolbova, R.V. Donner, N. Marwan, H.A. Dijkstra, # and J. Kurths, "Unified functional network and nonlinear time series analysis # for complex systems science: The pyunicorn package" -""" -Simple test for the MapPlot class. -""" import matplotlib.pyplot as plt @@ -22,30 +19,36 @@ from pyunicorn.climate.map_plot import MapPlot -def test_map_plot(): +# pylint: disable=too-few-public-methods +class TestMapPlot: """ - Simple test for the MapPlot class. - - No sanity checks, only testing if it runs without errors. + Simple tests for the `MapPlot` class. """ - # prepare ClimateNetwork fixture - file = 'notebooks/air.mon.mean.nc' - # select subset of data to speed up loading and calculation - window = { - "time_min": 0., "time_max": 0., - "lat_min": 30, "lon_min": 0, - "lat_max": 50, "lon_max": 30} - data = ClimateData.Load( - file_name=file, observable_name="air", - file_type="NetCDF", window=window, time_cycle=12) - # create MapPlot - map_plot = MapPlot(data.grid, "ncep_ncar_reanalysis") - assert map_plot.title == "ncep_ncar_reanalysis" + @staticmethod + def test_plot(): + """ + Check error-free execution. + """ + # prepare ClimateNetwork fixture + # (select subset of data to speed up loading and calculation) + title = "ncep_ncar_reanalysis" + file = 'notebooks/air.mon.mean.nc' + window = { + "time_min": 0., "time_max": 0., + "lat_min": 30, "lon_min": 0, + "lat_max": 50, "lon_max": 30} + data = ClimateData.Load( + file_name=file, observable_name="air", + file_type="NetCDF", window=window, time_cycle=12) + net = TsonisClimateNetwork(data, threshold=.05, winter_only=False) + + # create MapPlot + map_plot = MapPlot(data.grid, title) + assert map_plot.title == title - net = TsonisClimateNetwork(data, threshold=.05, winter_only=False) - degree = net.degree() - # plot, with suppressed display - plt.ioff() - map_plot.plot(degree, "Degree") - plt.close() + # plot with suppressed display + plt.ioff() + map_plot.plot(net.degree(), "Degree") + assert plt.gca().get_title() == title + plt.close()