From 1845f03c41114405691f7f91d745a8675b61c642 Mon Sep 17 00:00:00 2001 From: ClericalError Date: Wed, 14 Oct 2026 21:17:17 -0700 Subject: [PATCH] StemRoller: desktop stem separator, Android stems player, and server daemons - stemroller/: PySide6/QML desktop app and player for separating music into stems - android/: Plex music player that plays per-stem mixes, with Android Auto support, a graphic + parametric (Equalizer APO-style) EQ, and offline downloads - server/: stemserve (serves stems to the app) and stemd (separates the library on the server's GPU, with "Stem Now" priority requests) Co-Authored-By: Claude Opus 5.5 --- .dockerignore | 6 + .gitignore | 18 + android/README.md | 149 +++ android/app/build.gradle.kts | 71 ++ android/app/proguard-rules.pro | 10 + android/app/src/debug/AndroidManifest.xml | 10 + .../com/stemroller/mobile/DebugCapture.kt | 71 ++ android/app/src/main/AndroidManifest.xml | 67 ++ .../main/java/com/stemroller/mobile/App.kt | 134 +++ .../com/stemroller/mobile/MainActivity.kt | 97 ++ .../stemroller/mobile/auto/CarArtProvider.kt | 124 +++ .../com/stemroller/mobile/auto/CarLibrary.kt | 299 ++++++ .../com/stemroller/mobile/auto/CarTree.kt | 86 ++ .../com/stemroller/mobile/auto/HomeReach.kt | 74 ++ .../com/stemroller/mobile/cache/Downloads.kt | 228 +++++ .../com/stemroller/mobile/cache/MediaCache.kt | 448 +++++++++ .../java/com/stemroller/mobile/core/Net.kt | 73 ++ .../com/stemroller/mobile/core/Settings.kt | 99 ++ .../java/com/stemroller/mobile/engine/Dsp.kt | 266 +++++ .../stemroller/mobile/engine/StemDecoder.kt | 336 +++++++ .../stemroller/mobile/engine/StemEngine.kt | 519 ++++++++++ .../com/stemroller/mobile/eq/ApoConfig.kt | 138 +++ .../com/stemroller/mobile/eq/EqController.kt | 291 ++++++ .../stemroller/mobile/playback/MixPresets.kt | 43 + .../mobile/playback/PlaybackManager.kt | 760 ++++++++++++++ .../mobile/playback/PlaybackService.kt | 518 ++++++++++ .../com/stemroller/mobile/plex/PlexClient.kt | 253 +++++ .../com/stemroller/mobile/plex/PlexModels.kt | 220 ++++ .../stemroller/mobile/stems/StemCoverage.kt | 117 +++ .../com/stemroller/mobile/stems/StemIndex.kt | 85 ++ .../com/stemroller/mobile/stems/StemServer.kt | 196 ++++ .../java/com/stemroller/mobile/ui/Root.kt | 318 ++++++ .../stemroller/mobile/ui/components/Chrome.kt | 393 ++++++++ .../mobile/ui/components/Controls.kt | 370 +++++++ .../mobile/ui/components/Overlays.kt | 275 +++++ .../stemroller/mobile/ui/nav/Navigation.kt | 282 ++++++ .../stemroller/mobile/ui/screens/Common.kt | 404 ++++++++ .../mobile/ui/screens/EqFilterScreens.kt | 428 ++++++++ .../stemroller/mobile/ui/screens/EqScreen.kt | 166 ++++ .../mobile/ui/screens/LibraryScreens.kt | 547 ++++++++++ .../mobile/ui/screens/NowPlaying.kt | 507 ++++++++++ .../mobile/ui/screens/PlaylistScreens.kt | 337 +++++++ .../mobile/ui/screens/ProgressVolumeBar.kt | 243 +++++ .../mobile/ui/screens/SettingsScreens.kt | 407 ++++++++ .../com/stemroller/mobile/ui/theme/Icons.kt | 136 +++ .../com/stemroller/mobile/ui/theme/Theme.kt | 151 +++ .../app/src/main/res/drawable/ic_car_mix.xml | 10 + .../src/main/res/drawable/ic_car_shuffle.xml | 10 + .../src/main/res/drawable/ic_car_vocals.xml | 10 + .../main/res/drawable/ic_car_vocals_off.xml | 10 + .../res/drawable/ic_launcher_background.xml | 4 + .../res/drawable/ic_launcher_foreground.xml | 11 + .../res/drawable/ic_launcher_monochrome.xml | 6 + .../src/main/res/drawable/ic_stat_stems.xml | 6 + android/app/src/main/res/font/inter.ttf | Bin 0 -> 879708 bytes .../main/res/mipmap-anydpi/ic_launcher.xml | 6 + android/app/src/main/res/raw/keep.xml | 4 + android/app/src/main/res/values/strings.xml | 4 + android/app/src/main/res/values/themes.xml | 14 + .../src/main/res/xml/automotive_app_desc.xml | 4 + .../main/res/xml/network_security_config.xml | 9 + .../java/com/stemroller/mobile/CarTreeTest.kt | 90 ++ .../java/com/stemroller/mobile/DspTest.kt | 188 ++++ .../com/stemroller/mobile/MediaCacheTest.kt | 113 +++ .../com/stemroller/mobile/StemIndexTest.kt | 72 ++ android/build.gradle.kts | 6 + android/gradle.properties | 6 + android/gradle/libs.versions.toml | 42 + android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 45457 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 + android/gradlew | 251 +++++ android/licenses/Inter-OFL.txt | 92 ++ android/settings.gradle.kts | 23 + pyproject.toml | 47 + scripts/install-desktop.sh | 77 ++ server/Dockerfile | 8 + server/README.md | 126 +++ server/docker-compose.yml | 16 + server/stemd-requirements.txt | 73 ++ server/stemd.Dockerfile | 24 + server/stemd.py | 348 +++++++ server/stemserve.py | 454 +++++++++ specs.txt | 105 ++ stemroller/__init__.py | 0 stemroller/__main__.py | 5 + stemroller/app.py | 268 +++++ stemroller/assets/fonts/Inter-Bold.ttf | Bin 0 -> 420428 bytes stemroller/assets/fonts/Inter-LICENSE.txt | 92 ++ stemroller/assets/fonts/Inter-Medium.ttf | Bin 0 -> 417300 bytes stemroller/assets/fonts/Inter-Regular.ttf | Bin 0 -> 411640 bytes stemroller/assets/fonts/Inter-SemiBold.ttf | Bin 0 -> 419744 bytes stemroller/assets/stemroller.svg | 19 + stemroller/audio_engine.py | 307 ++++++ stemroller/catalog.py | 51 + stemroller/controller.py | 542 ++++++++++ stemroller/gpu_monitor.py | 77 ++ stemroller/jobs_model.py | 82 ++ stemroller/library_core.py | 107 ++ stemroller/player/README.md | 59 ++ stemroller/player/__init__.py | 0 stemroller/player/__main__.py | 5 + stemroller/player/app.py | 136 +++ .../player/assets/fonts/Carlito-Bold.ttf | Bin 0 -> 682468 bytes .../player/assets/fonts/Carlito-OFL.txt | 94 ++ .../player/assets/fonts/Carlito-Regular.ttf | Bin 0 -> 628032 bytes .../player/assets/fonts/Selawik-Bold.ttf | Bin 0 -> 44068 bytes .../player/assets/fonts/Selawik-LICENSE.txt | 91 ++ .../player/assets/fonts/Selawik-Regular.ttf | Bin 0 -> 44224 bytes .../player/assets/fonts/Selawik-Semibold.ttf | Bin 0 -> 44192 bytes .../player/assets/stemroller-player.svg | 10 + stemroller/player/config.py | 47 + stemroller/player/engine.py | 448 +++++++++ stemroller/player/icons.py | 104 ++ stemroller/player/library.py | 604 +++++++++++ stemroller/player/mpris.py | 171 ++++ stemroller/player/player.py | 601 +++++++++++ stemroller/player/plex.py | 275 +++++ .../player/qml/StemPlayer/Backstage.qml | 192 ++++ .../player/qml/StemPlayer/CaptionButton.qml | 18 + .../player/qml/StemPlayer/FormulaBar.qml | 51 + stemroller/player/qml/StemPlayer/Ico.qml | 15 + stemroller/player/qml/StemPlayer/Main.qml | 205 ++++ .../player/qml/StemPlayer/MessageBar.qml | 30 + .../player/qml/StemPlayer/OfficeButton.qml | 16 + stemroller/player/qml/StemPlayer/RButton.qml | 59 ++ stemroller/player/qml/StemPlayer/RGroup.qml | 30 + .../player/qml/StemPlayer/ResizeEdge.qml | 13 + stemroller/player/qml/StemPlayer/Ribbon.qml | 290 ++++++ stemroller/player/qml/StemPlayer/Sheet.qml | 501 ++++++++++ .../player/qml/StemPlayer/SheetTabs.qml | 89 ++ .../player/qml/StemPlayer/StatusBar.qml | 96 ++ .../player/qml/StemPlayer/StemChart.qml | 136 +++ stemroller/player/qml/StemPlayer/T.qml | 10 + stemroller/player/qml/StemPlayer/TaskPane.qml | 302 ++++++ stemroller/player/qml/StemPlayer/Tip.qml | 22 + stemroller/player/qml/StemPlayer/TitleBar.qml | 65 ++ stemroller/player/qml/StemPlayer/X.qml | 71 ++ stemroller/player/qml/StemPlayer/XCheck.qml | 24 + stemroller/player/qml/StemPlayer/XField.qml | 17 + stemroller/player/qml/StemPlayer/XMenu.qml | 48 + .../player/qml/StemPlayer/XScrollBar.qml | 18 + stemroller/player/qml/StemPlayer/qmldir | 25 + stemroller/player/sheets.py | 149 +++ stemroller/player/stems.py | 153 +++ stemroller/providers.py | 317 ++++++ stemroller/qml/StemRoller/AeroButton.qml | 84 ++ stemroller/qml/StemRoller/AeroComboBox.qml | 133 +++ stemroller/qml/StemRoller/AeroSlider.qml | 46 + stemroller/qml/StemRoller/AeroSwitch.qml | 43 + stemroller/qml/StemRoller/CaptionButton.qml | 31 + stemroller/qml/StemRoller/Card.qml | 26 + stemroller/qml/StemRoller/DashedFrame.qml | 25 + stemroller/qml/StemRoller/DropZone.qml | 98 ++ stemroller/qml/StemRoller/Elevation.qml | 21 + stemroller/qml/StemRoller/FrameOverlay.qml | 74 ++ stemroller/qml/StemRoller/GlassPanel.qml | 57 ++ stemroller/qml/StemRoller/Glow.qml | 18 + stemroller/qml/StemRoller/Icon.qml | 14 + stemroller/qml/StemRoller/IconButton.qml | 47 + stemroller/qml/StemRoller/LevelMeter.qml | 73 ++ stemroller/qml/StemRoller/Main.qml | 209 ++++ stemroller/qml/StemRoller/QueueItem.qml | 89 ++ stemroller/qml/StemRoller/ResizeEdge.qml | 13 + stemroller/qml/StemRoller/SettingsDialog.qml | 274 +++++ stemroller/qml/StemRoller/Sidebar.qml | 72 ++ stemroller/qml/StemRoller/StatusChip.qml | 28 + stemroller/qml/StemRoller/StemLane.qml | 147 +++ stemroller/qml/StemRoller/StripedProgress.qml | 63 ++ stemroller/qml/StemRoller/Theme.qml | 65 ++ stemroller/qml/StemRoller/Tip.qml | 18 + stemroller/qml/StemRoller/TitleBar.qml | 182 ++++ stemroller/qml/StemRoller/Toast.qml | 65 ++ stemroller/qml/StemRoller/TrackView.qml | 344 +++++++ stemroller/qml/StemRoller/Transport.qml | 192 ++++ stemroller/qml/StemRoller/Txt.qml | 10 + stemroller/qml/StemRoller/qmldir | 30 + stemroller/settings.py | 78 ++ stemroller/worker/__init__.py | 0 stemroller/worker/__main__.py | 289 ++++++ stemroller/worker/audio_io.py | 79 ++ stemroller/worker/backends.py | 251 +++++ stemroller/worker/cli.py | 106 ++ stemroller/worker_client.py | 112 +++ uv.lock | 939 ++++++++++++++++++ 184 files changed, 24648 insertions(+) create mode 100644 .dockerignore create mode 100644 .gitignore create mode 100644 android/README.md create mode 100644 android/app/build.gradle.kts create mode 100644 android/app/proguard-rules.pro create mode 100644 android/app/src/debug/AndroidManifest.xml create mode 100644 android/app/src/debug/java/com/stemroller/mobile/DebugCapture.kt create mode 100644 android/app/src/main/AndroidManifest.xml create mode 100644 android/app/src/main/java/com/stemroller/mobile/App.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/MainActivity.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/auto/CarArtProvider.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/auto/CarLibrary.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/auto/CarTree.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/auto/HomeReach.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/cache/Downloads.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/cache/MediaCache.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/core/Net.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/core/Settings.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/engine/Dsp.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/engine/StemDecoder.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/engine/StemEngine.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/eq/ApoConfig.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/eq/EqController.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/playback/MixPresets.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/playback/PlaybackManager.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/playback/PlaybackService.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/plex/PlexClient.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/plex/PlexModels.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/stems/StemCoverage.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/stems/StemIndex.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/stems/StemServer.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/Root.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/components/Chrome.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/components/Controls.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/components/Overlays.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/nav/Navigation.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/Common.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/EqFilterScreens.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/EqScreen.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/LibraryScreens.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/NowPlaying.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/PlaylistScreens.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/ProgressVolumeBar.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/screens/SettingsScreens.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/theme/Icons.kt create mode 100644 android/app/src/main/java/com/stemroller/mobile/ui/theme/Theme.kt create mode 100644 android/app/src/main/res/drawable/ic_car_mix.xml create mode 100644 android/app/src/main/res/drawable/ic_car_shuffle.xml create mode 100644 android/app/src/main/res/drawable/ic_car_vocals.xml create mode 100644 android/app/src/main/res/drawable/ic_car_vocals_off.xml create mode 100644 android/app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 android/app/src/main/res/drawable/ic_launcher_foreground.xml create mode 100644 android/app/src/main/res/drawable/ic_launcher_monochrome.xml create mode 100644 android/app/src/main/res/drawable/ic_stat_stems.xml create mode 100644 android/app/src/main/res/font/inter.ttf create mode 100644 android/app/src/main/res/mipmap-anydpi/ic_launcher.xml create mode 100644 android/app/src/main/res/raw/keep.xml create mode 100644 android/app/src/main/res/values/strings.xml create mode 100644 android/app/src/main/res/values/themes.xml create mode 100644 android/app/src/main/res/xml/automotive_app_desc.xml create mode 100644 android/app/src/main/res/xml/network_security_config.xml create mode 100644 android/app/src/test/java/com/stemroller/mobile/CarTreeTest.kt create mode 100644 android/app/src/test/java/com/stemroller/mobile/DspTest.kt create mode 100644 android/app/src/test/java/com/stemroller/mobile/MediaCacheTest.kt create mode 100644 android/app/src/test/java/com/stemroller/mobile/StemIndexTest.kt create mode 100644 android/build.gradle.kts create mode 100644 android/gradle.properties create mode 100644 android/gradle/libs.versions.toml create mode 100644 android/gradle/wrapper/gradle-wrapper.jar create mode 100644 android/gradle/wrapper/gradle-wrapper.properties create mode 100755 android/gradlew create mode 100644 android/licenses/Inter-OFL.txt create mode 100644 android/settings.gradle.kts create mode 100644 pyproject.toml create mode 100755 scripts/install-desktop.sh create mode 100644 server/Dockerfile create mode 100644 server/README.md create mode 100644 server/docker-compose.yml create mode 100644 server/stemd-requirements.txt create mode 100644 server/stemd.Dockerfile create mode 100644 server/stemd.py create mode 100644 server/stemserve.py create mode 100644 specs.txt create mode 100644 stemroller/__init__.py create mode 100644 stemroller/__main__.py create mode 100644 stemroller/app.py create mode 100644 stemroller/assets/fonts/Inter-Bold.ttf create mode 100644 stemroller/assets/fonts/Inter-LICENSE.txt create mode 100644 stemroller/assets/fonts/Inter-Medium.ttf create mode 100644 stemroller/assets/fonts/Inter-Regular.ttf create mode 100644 stemroller/assets/fonts/Inter-SemiBold.ttf create mode 100644 stemroller/assets/stemroller.svg create mode 100644 stemroller/audio_engine.py create mode 100644 stemroller/catalog.py create mode 100644 stemroller/controller.py create mode 100644 stemroller/gpu_monitor.py create mode 100644 stemroller/jobs_model.py create mode 100644 stemroller/library_core.py create mode 100644 stemroller/player/README.md create mode 100644 stemroller/player/__init__.py create mode 100644 stemroller/player/__main__.py create mode 100644 stemroller/player/app.py create mode 100644 stemroller/player/assets/fonts/Carlito-Bold.ttf create mode 100644 stemroller/player/assets/fonts/Carlito-OFL.txt create mode 100644 stemroller/player/assets/fonts/Carlito-Regular.ttf create mode 100644 stemroller/player/assets/fonts/Selawik-Bold.ttf create mode 100644 stemroller/player/assets/fonts/Selawik-LICENSE.txt create mode 100644 stemroller/player/assets/fonts/Selawik-Regular.ttf create mode 100644 stemroller/player/assets/fonts/Selawik-Semibold.ttf create mode 100644 stemroller/player/assets/stemroller-player.svg create mode 100644 stemroller/player/config.py create mode 100644 stemroller/player/engine.py create mode 100644 stemroller/player/icons.py create mode 100644 stemroller/player/library.py create mode 100644 stemroller/player/mpris.py create mode 100644 stemroller/player/player.py create mode 100644 stemroller/player/plex.py create mode 100644 stemroller/player/qml/StemPlayer/Backstage.qml create mode 100644 stemroller/player/qml/StemPlayer/CaptionButton.qml create mode 100644 stemroller/player/qml/StemPlayer/FormulaBar.qml create mode 100644 stemroller/player/qml/StemPlayer/Ico.qml create mode 100644 stemroller/player/qml/StemPlayer/Main.qml create mode 100644 stemroller/player/qml/StemPlayer/MessageBar.qml create mode 100644 stemroller/player/qml/StemPlayer/OfficeButton.qml create mode 100644 stemroller/player/qml/StemPlayer/RButton.qml create mode 100644 stemroller/player/qml/StemPlayer/RGroup.qml create mode 100644 stemroller/player/qml/StemPlayer/ResizeEdge.qml create mode 100644 stemroller/player/qml/StemPlayer/Ribbon.qml create mode 100644 stemroller/player/qml/StemPlayer/Sheet.qml create mode 100644 stemroller/player/qml/StemPlayer/SheetTabs.qml create mode 100644 stemroller/player/qml/StemPlayer/StatusBar.qml create mode 100644 stemroller/player/qml/StemPlayer/StemChart.qml create mode 100644 stemroller/player/qml/StemPlayer/T.qml create mode 100644 stemroller/player/qml/StemPlayer/TaskPane.qml create mode 100644 stemroller/player/qml/StemPlayer/Tip.qml create mode 100644 stemroller/player/qml/StemPlayer/TitleBar.qml create mode 100644 stemroller/player/qml/StemPlayer/X.qml create mode 100644 stemroller/player/qml/StemPlayer/XCheck.qml create mode 100644 stemroller/player/qml/StemPlayer/XField.qml create mode 100644 stemroller/player/qml/StemPlayer/XMenu.qml create mode 100644 stemroller/player/qml/StemPlayer/XScrollBar.qml create mode 100644 stemroller/player/qml/StemPlayer/qmldir create mode 100644 stemroller/player/sheets.py create mode 100644 stemroller/player/stems.py create mode 100644 stemroller/providers.py create mode 100644 stemroller/qml/StemRoller/AeroButton.qml create mode 100644 stemroller/qml/StemRoller/AeroComboBox.qml create mode 100644 stemroller/qml/StemRoller/AeroSlider.qml create mode 100644 stemroller/qml/StemRoller/AeroSwitch.qml create mode 100644 stemroller/qml/StemRoller/CaptionButton.qml create mode 100644 stemroller/qml/StemRoller/Card.qml create mode 100644 stemroller/qml/StemRoller/DashedFrame.qml create mode 100644 stemroller/qml/StemRoller/DropZone.qml create mode 100644 stemroller/qml/StemRoller/Elevation.qml create mode 100644 stemroller/qml/StemRoller/FrameOverlay.qml create mode 100644 stemroller/qml/StemRoller/GlassPanel.qml create mode 100644 stemroller/qml/StemRoller/Glow.qml create mode 100644 stemroller/qml/StemRoller/Icon.qml create mode 100644 stemroller/qml/StemRoller/IconButton.qml create mode 100644 stemroller/qml/StemRoller/LevelMeter.qml create mode 100644 stemroller/qml/StemRoller/Main.qml create mode 100644 stemroller/qml/StemRoller/QueueItem.qml create mode 100644 stemroller/qml/StemRoller/ResizeEdge.qml create mode 100644 stemroller/qml/StemRoller/SettingsDialog.qml create mode 100644 stemroller/qml/StemRoller/Sidebar.qml create mode 100644 stemroller/qml/StemRoller/StatusChip.qml create mode 100644 stemroller/qml/StemRoller/StemLane.qml create mode 100644 stemroller/qml/StemRoller/StripedProgress.qml create mode 100644 stemroller/qml/StemRoller/Theme.qml create mode 100644 stemroller/qml/StemRoller/Tip.qml create mode 100644 stemroller/qml/StemRoller/TitleBar.qml create mode 100644 stemroller/qml/StemRoller/Toast.qml create mode 100644 stemroller/qml/StemRoller/TrackView.qml create mode 100644 stemroller/qml/StemRoller/Transport.qml create mode 100644 stemroller/qml/StemRoller/Txt.qml create mode 100644 stemroller/qml/StemRoller/qmldir create mode 100644 stemroller/settings.py create mode 100644 stemroller/worker/__init__.py create mode 100644 stemroller/worker/__main__.py create mode 100644 stemroller/worker/audio_io.py create mode 100644 stemroller/worker/backends.py create mode 100644 stemroller/worker/cli.py create mode 100644 stemroller/worker_client.py create mode 100644 uv.lock diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..f4a18b9 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,6 @@ +# Only server/stemd.Dockerfile builds from the repo root; keep the venv and APKs out of its context. +* +!server/stemd.py +!server/stemd-requirements.txt +!stemroller/*.py +!stemroller/worker/*.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..762fb91 --- /dev/null +++ b/.gitignore @@ -0,0 +1,18 @@ +# Python +.venv/ +__pycache__/ +*.pyc + +# Android / Gradle +android/.gradle/ +android/.kotlin/ +android/build/ +android/app/build/ +android/local.properties +android/captures/ +.idea/ +*.iml + +# Built and third-party APKs (publish builds as GitHub Releases instead) +*.apk +*.aab diff --git a/android/README.md b/android/README.md new file mode 100644 index 0000000..30cb5e5 --- /dev/null +++ b/android/README.md @@ -0,0 +1,149 @@ +# StemRoller for Android + +A Plex music player for the OnePlus 15 that plays the stems stemd separates on your +unraid server: per-stem faders, mute/solo, karaoke-style presets, a master volume drawn +over a Plexamp-style waveform seek bar, a 10-band graphic EQ plus Equalizer APO-style +parametric filters with per-device profiles, and an +iOS look in Black, Dark or White (flat colours, no gradients). + +## Install + +`../StemRoller.apk` is a release build signed with the debug key, ready to sideload: + +```sh +adb install -r ../StemRoller.apk +``` + +## First run + +1. Start stemserve on the unraid box (`../server/README.md`). It serves + `/mnt/user/Music/Stems` on port 8765. +2. In the app: **Library → Connect** (or Settings → Plex). Enter the 4-character code at + plex.tv/link, then pick the **Music** library (`/media/Music/Actual music/Flacs`). +3. Settings → Stem Server should say "Online" with a song count. The default address is + `http://192.168.86.2:8765`. + +Stems are the norm: stemd on the server separates the whole library on its own, and the app +checks stemserve for new stems every minute. So the exceptions are what's marked: songs show +**NO STEMS**, and albums and artists show **NO STEMS** or **7/10 STEMS** until they're done. Those +songs play the original file from Plex, so the whole library works in the meantime. + +Hold any song, album, artist or playlist for: **Add to Front of Queue**, **Add to End of Queue**, +**Download** (or Remove Download), **Add to Playlist** (a playlist can go into another one) and, +while any of it lacks stems, **Stem Now**: stemd on the server separates those songs next, ahead +of the rest of the library, and they switch to stems within a minute or so of finishing. + +The tabs are Library, Playlists, Search, Downloads and Settings. Library's home shows **On This +Day**: albums released on today's date in earlier years (or, on a quiet day, the few days either +side). **Downloads** lists albums, sorted by download order, artist or release date. The +**Equalizer** is in Settings. + +The Equalizer has the 10 graphic bands plus **Parametric Filters**, as in Equalizer APO: peak, +low/high shelf, low/high pass (6–48 dB/oct), band pass, notch and all pass, each with +frequency, gain and Q, on both channels or just left or right, and switchable one by one. +Drag a filter's handle on its curve, use the sliders, or tap a value to type it. Each +profile has its own manual preamp; anti-clipping adds whatever else the curve needs. The +Filters page's ••• menu pastes an Equalizer APO config from the clipboard (AutoEQ's +`ParametricEQ.txt` for your headphones works as-is) and copies the profile out as one. + +The seek bar's waveform is scaled to each song's own range (its loud moments fill the bar, +its quiet parts sit low), and the mixer's level meters follow what's audible at display rate. + +## How it fits together + +| Piece | What it does | +|---|---| +| `plex/` | Library, search, playlists (create/add/remove/reorder/rename), artwork, play reporting | +| `stems/` | stemserve's index; matches Plex file paths to stem folders by suffix + duration | +| `cache/` | Sparse block cache: streams with HTTP ranges, seeks anywhere, keeps what it fetched; downloads are pinned copies | +| `engine/` | One decoder thread per stem → sample-locked mixer → EQ (auto anti-clip preamp) → master → limiter → one AudioTrack. Gapless | +| `eq/` | Profiles (graphic bands, parametric filters, preamp), linked to output devices (speaker, wired, each Bluetooth headset, USB DAC); automatic or manual; APO config import/export | +| `playback/` | Queue, shuffle/repeat, audio focus, mix presets; Media3 library session for notification, lock screen, Bluetooth and Android Auto | +| `auto/` | Android Auto: browse tree, voice search, home-network probe, artwork provider | +| `stems/StemCoverage.kt` | Which albums and artists have stems: a slim list of every track's path, matched to the index | +| `ui/` | Compose, hand-built iOS components; per-tab navigation stacks driven by predictive back | + +The EQ's anti-clip preamp is the negative of the curve's highest point (evaluated on the +actual biquads), so a full-scale signal at the boosted frequency still peaks at 0 dBFS. + +## Android Auto + +Built for the 2016 MX-5's Mazda Connect retrofit: an 800×480 screen with touch disabled, +driven by the commander knob (turn, nudge, press, Back) and the steering-wheel buttons. +Auto draws a media app's screens itself; the app supplies a browse tree and buttons, so +that's what is shaped for the knob (`auto/`, `playback/PlaybackService.kt`): + +- **Four tabs** (all Auto shows): Playlists, Albums, Artists, Downloads. Away from home + Downloads comes first. +- **Shallow and short.** Every list of songs starts with **Shuffle all**; lists longer than + 40 split into A–Z folders (big letter tiles), so the knob never has to crawl through + hundreds of rows. Albums are a grid (the art identifies them); everything else is a list. + Songs with stems say **Stems** under the title. +- **Now playing:** previous / play / next stay put (and the wheel's seek buttons work). + Beside them, in priority order: **Vocals** on/off (karaoke), **Mix** (cycles Full → + Karaoke → A Cappella → No Drums → Rhythm → No Guitar → No Bass), then shuffle and repeat; + whatever doesn't fit beside the transport goes behind Auto's overflow button (on the + Miata's 800×480 all four fit). The current mix + shows on the artist line ("Black Sabbath · Karaoke"), since a button press gets no other + feedback. Songs without stems just get shuffle and repeat, and say "No stems" in the lists. The same buttons appear on the + phone's lock-screen controls. +- **Voice:** hold the wheel's talk button: "play Paranoid on StemRoller" (a playlist, + artist, album or song; artists shuffle). There's no keyboard while driving, so Auto's + search button is voice too. +- **Offline:** in the car the phone is on mobile data and Plex/stemserve are LAN-only. The + app probes them (1.5 s, re-checked on network changes) and when they're unreachable reads + library pages from cache only and lists **only songs that will play** (downloaded, or + fully cached); downloaded songs carry Auto's downloaded mark. Art comes from a local + `content://` provider fed by what downloads already cached. + +### Setting up the car (once) + +Auto hides sideloaded apps until you allow them: + +1. Phone Settings → search "Android Auto" → scroll to the bottom and tap **Version** ten + times → OK. +2. ⋮ menu → **Developer settings** → tick **Unknown sources**. +3. Plug into the Miata. StemRoller is in Auto's app launcher (the grid of icons). + +Download what you want for the drive while on home Wi-Fi. + +### Testing without the car + +Google's Desktop Head Unit runs Auto on the desktop. `config/rotary.ini` is exactly the +Miata: 800×480, touch off, rotary controller on. On the phone: Auto developer settings ⋮ → +**Start head unit server**; then: + +```sh +adb forward tcp:5277 tcp:5277 +~/Android/Sdk/extras/google/auto/desktop-head-unit -c ~/Android/Sdk/extras/google/auto/config/rotary.ini +``` + +(It needs libc++, which this host lacks; here it runs in the `dhu-headless` podman image.) + +## Display + +The app asks for the panel's fastest mode at its full resolution (1272×2772 at 165 Hz on +the OnePlus 15) and Compose renders at that vsync. The footer of Settings shows the active +refresh rate; turn High Refresh Rate off to let the system choose. + +## Build + +JDK 21 and the Android SDK (`local.properties` points at `~/Android/Sdk`): + +```sh +JAVA_HOME=~/.local/opt/jdk-21.0.12.1+1 ./gradlew assembleRelease # app/build/outputs/apk/release/ +JAVA_HOME=~/.local/opt/jdk-21.0.12.1+1 ./gradlew testDebugUnitTest # stem matching, EQ/limiter maths, block cache +``` + +The cache and index tests stream real stems from a stemserve on `localhost:8765` and +are skipped when it isn't running. + +Debug builds include a hook for screenshots and back-gesture testing in the emulator +(`app/src/debug`); release builds don't. + +## Limits + +- Plex can't hold an empty playlist, so new playlists start from a song, the queue or a + selection. +- Streaming needs the LAN (Plex and stemserve are plain HTTP on 192.168.86.2). Downloads + and anything already streamed play offline. diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts new file mode 100644 index 0000000..d9a530a --- /dev/null +++ b/android/app/build.gradle.kts @@ -0,0 +1,71 @@ +import org.jetbrains.kotlin.gradle.dsl.JvmTarget + +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.compose) + alias(libs.plugins.kotlin.serialization) +} + +android { + namespace = "com.stemroller.mobile" + compileSdk = 36 + + defaultConfig { + applicationId = "com.stemroller.mobile" + minSdk = 33 + targetSdk = 36 + versionCode = 1 + versionName = "1.0" + } + + buildTypes { + release { + isMinifyEnabled = true + isShrinkResources = true + proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro") + // Personal sideload build: sign with the debug key so it installs without a keystore. + signingConfig = signingConfigs.getByName("debug") + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 + } + buildFeatures { + compose = true + } + packaging { + resources.excludes += "/META-INF/{AL2.0,LGPL2.1}" + } +} + +kotlin { + compilerOptions { + jvmTarget.set(JvmTarget.JVM_17) + } +} + +dependencies { + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.activity.compose) + implementation(libs.androidx.lifecycle.runtime.compose) + implementation(libs.androidx.lifecycle.process) + implementation(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.compose.ui) + implementation(libs.androidx.compose.ui.graphics) + implementation(libs.androidx.compose.foundation) + implementation(libs.androidx.compose.animation) + implementation(libs.androidx.compose.ui.tooling.preview) + debugImplementation(libs.androidx.compose.ui.tooling) + implementation(libs.androidx.media3.session) + implementation(libs.androidx.media3.common) + implementation(libs.androidx.palette) + implementation(libs.okhttp) + implementation(libs.coil.compose) + implementation(libs.coil.network.okhttp) + implementation(libs.kotlinx.serialization.json) + implementation(libs.kotlinx.coroutines.android) + implementation(libs.kotlinx.coroutines.guava) + testImplementation(libs.junit) +} diff --git a/android/app/proguard-rules.pro b/android/app/proguard-rules.pro new file mode 100644 index 0000000..7c714e8 --- /dev/null +++ b/android/app/proguard-rules.pro @@ -0,0 +1,10 @@ +# kotlinx.serialization keeps its generated serializers via its own consumer rules. +-keepattributes *Annotation*, InnerClasses +-dontnote kotlinx.serialization.** +-keep,includedescriptorclasses class com.stemroller.mobile.**$$serializer { *; } +-keepclassmembers class com.stemroller.mobile.** { + *** Companion; +} +-keepclasseswithmembers class com.stemroller.mobile.** { + kotlinx.serialization.KSerializer serializer(...); +} diff --git a/android/app/src/debug/AndroidManifest.xml b/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 0000000..b77fef7 --- /dev/null +++ b/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,10 @@ + + + + + + + diff --git a/android/app/src/debug/java/com/stemroller/mobile/DebugCapture.kt b/android/app/src/debug/java/com/stemroller/mobile/DebugCapture.kt new file mode 100644 index 0000000..71a09f0 --- /dev/null +++ b/android/app/src/debug/java/com/stemroller/mobile/DebugCapture.kt @@ -0,0 +1,71 @@ +package com.stemroller.mobile + +import android.app.Activity +import android.app.Application +import android.content.BroadcastReceiver +import android.content.ContentProvider +import android.content.ContentValues +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.graphics.Bitmap +import android.graphics.Canvas +import android.os.Bundle +import androidx.activity.BackEventCompat +import androidx.activity.ComponentActivity +import java.io.File +import java.lang.ref.WeakReference + +/** + * `adb shell am broadcast -a com.stemroller.mobile.CAPTURE -p com.stemroller.mobile` + * writes files/capture.png: the current activity drawn in software. + * + * `... -a com.stemroller.mobile.BACK --es phase start|progress|commit|cancel --ef p 0.4` + * feeds the predictive back callbacks the way a system swipe would. + */ +class DebugCapture : ContentProvider() { + private var current = WeakReference(null) + + override fun onCreate(): Boolean { + val app = context!!.applicationContext as Application + app.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks { + override fun onActivityResumed(a: Activity) { current = WeakReference(a) } + override fun onActivityCreated(a: Activity, b: Bundle?) {} + override fun onActivityStarted(a: Activity) {} + override fun onActivityPaused(a: Activity) {} + override fun onActivityStopped(a: Activity) {} + override fun onActivitySaveInstanceState(a: Activity, b: Bundle) {} + override fun onActivityDestroyed(a: Activity) {} + }) + app.registerReceiver(object : BroadcastReceiver() { + override fun onReceive(c: Context, i: Intent) { + val a = current.get() ?: return + val v = a.window.decorView + val bmp = Bitmap.createBitmap(v.width, v.height, Bitmap.Config.ARGB_8888) + v.draw(Canvas(bmp)) + File(a.filesDir, "capture.png").outputStream().use { bmp.compress(Bitmap.CompressFormat.PNG, 100, it) } + } + }, IntentFilter("com.stemroller.mobile.CAPTURE"), Context.RECEIVER_EXPORTED) + app.registerReceiver(object : BroadcastReceiver() { + override fun onReceive(c: Context, i: Intent) { + val a = current.get() as? ComponentActivity ?: return + val d = a.onBackPressedDispatcher + val p = i.getFloatExtra("p", 0f) + val e = BackEventCompat(p * 600f, 1300f, p, BackEventCompat.EDGE_LEFT) + when (i.getStringExtra("phase")) { + "start" -> d.dispatchOnBackStarted(e) + "progress" -> d.dispatchOnBackProgressed(e) + "commit" -> d.onBackPressed() + "cancel" -> d.dispatchOnBackCancelled() + } + } + }, IntentFilter("com.stemroller.mobile.BACK"), Context.RECEIVER_EXPORTED) + return true + } + + override fun query(u: android.net.Uri, p: Array?, s: String?, a: Array?, o: String?) = null + override fun getType(u: android.net.Uri) = null + override fun insert(u: android.net.Uri, v: ContentValues?) = null + override fun delete(u: android.net.Uri, s: String?, a: Array?) = 0 + override fun update(u: android.net.Uri, v: ContentValues?, s: String?, a: Array?) = 0 +} diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..0a98b57 --- /dev/null +++ b/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/android/app/src/main/java/com/stemroller/mobile/App.kt b/android/app/src/main/java/com/stemroller/mobile/App.kt new file mode 100644 index 0000000..a73a093 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/App.kt @@ -0,0 +1,134 @@ +package com.stemroller.mobile + +import android.app.Application +import android.content.pm.ApplicationInfo +import coil3.ImageLoader +import coil3.PlatformContext +import coil3.SingletonImageLoader +import coil3.disk.DiskCache +import coil3.disk.directory +import coil3.memory.MemoryCache +import coil3.network.okhttp.OkHttpNetworkFetcherFactory +import coil3.request.allowHardware +import coil3.request.crossfade +import com.stemroller.mobile.auto.HomeReach +import com.stemroller.mobile.cache.Downloads +import com.stemroller.mobile.cache.MediaCache +import com.stemroller.mobile.core.Connectivity +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.eq.EqController +import com.stemroller.mobile.playback.PlaybackManager +import com.stemroller.mobile.plex.PlexClient +import com.stemroller.mobile.stems.StemCoverage +import com.stemroller.mobile.stems.StemServer +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import okhttp3.Cache +import okhttp3.CacheControl +import okhttp3.Interceptor +import okhttp3.OkHttpClient +import java.io.File +import java.io.IOException +import java.util.concurrent.TimeUnit + +class App : Application(), SingletonImageLoader.Factory { + lateinit var graph: Graph + private set + + override fun onCreate() { + super.onCreate() + instance = this + graph = Graph(this) + } + + override fun newImageLoader(context: PlatformContext): ImageLoader = + ImageLoader.Builder(context) + .components { add(OkHttpNetworkFetcherFactory(callFactory = { graph.imageHttp })) } + .memoryCache { MemoryCache.Builder().maxSizePercent(context, 0.2).build() } + .diskCache { DiskCache.Builder().directory(File(cacheDir, "art")).maxSizeBytes(512L * 1024 * 1024).build() } + .crossfade(false) + // Debug builds draw the UI to a software canvas for screenshots, which can't take hardware bitmaps. + .allowHardware(applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE == 0) + .build() + + companion object { + lateinit var instance: App + private set + val graph: Graph get() = instance.graph + } +} + +/** Hand-wired singletons; there are few enough that a DI framework isn't worth it. */ +class Graph(app: App) { + val packageName: String = app.packageName + val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) + val settings = Settings(app) + val net = Connectivity(app) + + /** Library calls: cached on disk and served from there when the server is unreachable. */ + val apiHttp: OkHttpClient = OkHttpClient.Builder() + .cache(Cache(File(app.cacheDir, "http"), 64L * 1024 * 1024)) + .connectTimeout(6, TimeUnit.SECONDS) + .readTimeout(30, TimeUnit.SECONDS) + .addInterceptor(offlineFallback) + .addNetworkInterceptor(cacheable) + .build() + + /** Media ranges; MediaCache is the cache. Long read timeout covers server-side Opus transcodes. */ + val mediaHttp: OkHttpClient = OkHttpClient.Builder() + .connectTimeout(8, TimeUnit.SECONDS) + .readTimeout(90, TimeUnit.SECONDS) + .build() + + val imageHttp: OkHttpClient = mediaHttp.newBuilder().readTimeout(20, TimeUnit.SECONDS).build() + + val plex = PlexClient(apiHttp, settings) + + /** Is Plex/stemserve answering? Asked by the car UI before every browse. */ + val reach = HomeReach(mediaHttp, settings, net, scope) + + /** The car's Plex: identical, except that away from home it reads the disk cache without trying the network. */ + val carPlex = PlexClient( + apiHttp.newBuilder().addInterceptor { chain -> + val req = chain.request() + if (reach.lastKnown || req.method != "GET") chain.proceed(req) + else chain.proceed(req.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build()) + }.build(), + settings, + ) + val stems = StemServer(apiHttp, settings, app.filesDir, scope) + val cache = MediaCache(File(app.noBackupFilesDir, "media"), mediaHttp) { + settings.cacheLimitGb.value.toLong() * 1024 * 1024 * 1024 + } + val eq = EqController(app) + val playback = PlaybackManager(app, settings, plex, stems, cache, eq, scope) + val downloads = Downloads(app, settings, plex, stems, cache, net, scope) + val coverage = StemCoverage(plex, stems, settings, app.filesDir, scope) + + private companion object { + /** Plex sends no cache headers; store everything, always revalidate. */ + val cacheable = Interceptor { chain -> + val resp = chain.proceed(chain.request()) + if (resp.header("Cache-Control") == null && chain.request().method == "GET") { + resp.newBuilder().removeHeader("Pragma").header("Cache-Control", "public, max-age=0").build() + } else resp + } + + /** On network failure, answer GETs from the disk cache if it has them. */ + val offlineFallback = Interceptor { chain -> + val req = chain.request() + try { + chain.proceed(req) + } catch (e: IOException) { + if (req.method != "GET") throw e + val cached = chain.proceed(req.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build()) + if (cached.code == 504) { + cached.close() + throw e + } + cached + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/MainActivity.kt b/android/app/src/main/java/com/stemroller/mobile/MainActivity.kt new file mode 100644 index 0000000..8c4f579 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/MainActivity.kt @@ -0,0 +1,97 @@ +package com.stemroller.mobile + +import android.Manifest +import android.content.ComponentName +import android.content.Intent +import android.content.pm.PackageManager +import android.os.Build +import android.os.Bundle +import android.view.View +import androidx.activity.ComponentActivity +import androidx.activity.SystemBarStyle +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.runtime.mutableIntStateOf +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.lifecycleScope +import androidx.lifecycle.repeatOnLifecycle +import androidx.media3.session.MediaController +import androidx.media3.session.SessionToken +import com.google.common.util.concurrent.ListenableFuture +import com.stemroller.mobile.core.ThemeMode +import com.stemroller.mobile.playback.PlaybackService +import com.stemroller.mobile.ui.StemApp +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch + +class MainActivity : ComponentActivity() { + private var controller: ListenableFuture? = null + private val openNowPlaying = mutableIntStateOf(0) + private val notifications = registerForActivityResult(ActivityResultContracts.RequestPermission()) { } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + val g = App.graph + lifecycleScope.launch { + repeatOnLifecycle(Lifecycle.State.STARTED) { + combine(g.settings.theme.flow, g.settings.highRefreshRate.flow) { t, hz -> t to hz }.collect { (theme, hz) -> + val light = theme == ThemeMode.White + enableEdgeToEdge( + statusBarStyle = if (light) SystemBarStyle.light(0, 0) else SystemBarStyle.dark(0), + navigationBarStyle = if (light) SystemBarStyle.light(0, 0) else SystemBarStyle.dark(0), + ) + window.isNavigationBarContrastEnforced = false + applyRefreshRate(hz) + } + } + } + if (intent?.getBooleanExtra(EXTRA_NOW_PLAYING, false) == true) openNowPlaying.intValue++ + setContent { StemApp(openNowPlaying.intValue) } + if (Build.VERSION.SDK_INT >= 33 && checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) { + notifications.launch(Manifest.permission.POST_NOTIFICATIONS) + } + } + + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + if (intent.getBooleanExtra(EXTRA_NOW_PLAYING, false)) openNowPlaying.intValue++ + } + + /** + * Asks for the panel's fastest mode at its full resolution: on a OnePlus 15 that's + * 1272x2772 at 165 Hz. Compose then renders at whatever vsync that gives us. + */ + private fun applyRefreshRate(high: Boolean) { + val d = display ?: return + val modes = d.supportedModes + val maxPixels = modes.maxOf { it.physicalWidth * it.physicalHeight } + val best = modes.filter { it.physicalWidth * it.physicalHeight == maxPixels }.maxByOrNull { it.refreshRate } + window.attributes = window.attributes.apply { + preferredDisplayModeId = if (high && best != null) best.modeId else 0 + preferredRefreshRate = if (high && best != null) best.refreshRate else 0f + } + if (Build.VERSION.SDK_INT >= 35) { + // An explicit rate, not CATEGORY_HIGH: OxygenOS maps the "high" category to 90 Hz. + window.decorView.requestedFrameRate = if (high && best != null) best.refreshRate else View.REQUESTED_FRAME_RATE_CATEGORY_DEFAULT + window.frameRateBoostOnTouchEnabled = high + } + } + + override fun onStart() { + super.onStart() + // A connected controller keeps the session service bound, so playback starts it in the foreground. + controller = MediaController.Builder(this, SessionToken(this, ComponentName(this, PlaybackService::class.java))).buildAsync() + App.graph.eq.refreshRoute() + } + + override fun onStop() { + controller?.let { MediaController.releaseFuture(it) } + controller = null + super.onStop() + } + + companion object { + const val EXTRA_NOW_PLAYING = "now_playing" + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/auto/CarArtProvider.kt b/android/app/src/main/java/com/stemroller/mobile/auto/CarArtProvider.kt new file mode 100644 index 0000000..1de0d9c --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/auto/CarArtProvider.kt @@ -0,0 +1,124 @@ +package com.stemroller.mobile.auto + +import android.content.ContentProvider +import android.content.ContentValues +import android.graphics.Bitmap +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.Typeface +import android.net.Uri +import android.os.ParcelFileDescriptor +import coil3.SingletonImageLoader +import com.stemroller.mobile.App +import okhttp3.Request +import java.io.File +import java.io.FileNotFoundException +import java.security.MessageDigest + +/** + * Album art for Android Auto, which only loads `content://` artwork. Serves a local copy, + * filled from the art the phone UI already cached (downloads warm it at 600 px, so offline + * downloads have art in the car) or, failing that, fetched from Plex once. + * + * Also draws the A–Z folder tiles: without art, Auto puts a warning triangle in their place. + */ +class CarArtProvider : ContentProvider() { + private val dir by lazy { File(context!!.cacheDir, "car-art").apply { mkdirs() } } + + override fun onCreate() = true + + override fun getType(uri: Uri) = if (uri.path == "/$LETTER") "image/png" else "image/jpeg" + + override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor { + if (uri.path == "/$LETTER") return letterTile(uri.getQueryParameter(LETTER) ?: "#") + val thumb = uri.getQueryParameter(THUMB) ?: throw FileNotFoundException(uri.toString()) + val file = File(dir, sha1(thumb) + ".jpg") + if (!file.exists() || file.length() == 0L) fill(thumb, file) + if (!file.exists()) throw FileNotFoundException(thumb) + file.setLastModified(System.currentTimeMillis()) + return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY) + } + + private fun fill(thumb: String, file: File) { + val g = App.graph + val tmp = File(dir, file.name + ".tmp") + val disk = SingletonImageLoader.get(context!!).diskCache + for (px in PHONE_SIZES) { + val url = g.plex.artUrl(thumb, px) ?: continue + val snap = disk?.openSnapshot(url) ?: continue + try { + snap.data.toFile().copyTo(tmp, overwrite = true) + } finally { + snap.close() + } + if (tmp.renameTo(file)) return trim() + } + if (!g.reach.lastKnown) return + val url = g.plex.artUrl(thumb, PX) ?: return + runCatching { + g.imageHttp.newCall(Request.Builder().url(url).build()).execute().use { r -> + if (!r.isSuccessful) return + tmp.outputStream().use { out -> r.body!!.byteStream().copyTo(out) } + } + if (tmp.renameTo(file)) trim() + } + tmp.delete() + } + + /** A big white letter on a flat dark tile, readable at a glance on the 800×480 screen. */ + private fun letterTile(letter: String): ParcelFileDescriptor { + val l = letter.take(1).uppercase().ifEmpty { "#" } + val file = File(dir, "letter-${l.first().code}.png") + if (!file.exists() || file.length() == 0L) { + val bmp = Bitmap.createBitmap(LETTER_PX, LETTER_PX, Bitmap.Config.ARGB_8888) + val c = Canvas(bmp) + c.drawColor(Color.rgb(0x2C, 0x2C, 0x2E)) + val p = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = Color.WHITE + textSize = LETTER_PX * 0.55f + textAlign = Paint.Align.CENTER + typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD) + } + val y = LETTER_PX / 2f - (p.descent() + p.ascent()) / 2f + c.drawText(l, LETTER_PX / 2f, y, p) + val tmp = File(dir, file.name + ".tmp") + tmp.outputStream().use { bmp.compress(Bitmap.CompressFormat.PNG, 100, it) } + bmp.recycle() + tmp.renameTo(file) + } + return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY) + } + + private fun trim() { + val files = dir.listFiles { f -> f.name.endsWith(".jpg") } ?: return + if (files.size <= MAX_FILES) return + files.sortedBy { it.lastModified() }.take(files.size - MAX_FILES).forEach { it.delete() } + } + + override fun query(uri: Uri, p: Array?, s: String?, a: Array?, o: String?) = null + override fun insert(uri: Uri, values: ContentValues?): Uri? = null + override fun delete(uri: Uri, s: String?, a: Array?) = 0 + override fun update(uri: Uri, v: ContentValues?, s: String?, a: Array?) = 0 + + companion object { + const val AUTHORITY = "com.stemroller.mobile.carart" + private const val THUMB = "thumb" + private const val LETTER = "letter" + private const val LETTER_PX = 256 + /** Comfortably sharp on the 480-pixel-tall Miata screen, and what downloads cache. */ + const val PX = 600 + private val PHONE_SIZES = intArrayOf(600, 720) + private const val MAX_FILES = 2000 + + fun uri(thumb: String?): Uri? = + if (thumb.isNullOrEmpty()) null + else Uri.Builder().scheme("content").authority(AUTHORITY).path("art").appendQueryParameter(THUMB, thumb).build() + + /** The tile for an A–Z folder ("#" for numbers and symbols). */ + fun letterUri(letter: String): Uri = + Uri.Builder().scheme("content").authority(AUTHORITY).path(LETTER).appendQueryParameter(LETTER, letter).build() + + private fun sha1(s: String) = MessageDigest.getInstance("SHA-1").digest(s.toByteArray()).joinToString("") { "%02x".format(it) } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/auto/CarLibrary.kt b/android/app/src/main/java/com/stemroller/mobile/auto/CarLibrary.kt new file mode 100644 index 0000000..6221a53 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/auto/CarLibrary.kt @@ -0,0 +1,299 @@ +package com.stemroller.mobile.auto + +import android.net.Uri +import android.os.Bundle +import androidx.annotation.OptIn +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata +import androidx.media3.common.util.UnstableApi +import androidx.media3.session.MediaConstants +import com.stemroller.mobile.Graph +import com.stemroller.mobile.plex.Album +import com.stemroller.mobile.plex.Artist +import com.stemroller.mobile.plex.Playlist +import com.stemroller.mobile.plex.Track +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +/** What a pick or a voice request turns into: a queue, where to start, and whether to shuffle it. */ +class Resolved(val tracks: List, val start: Int = 0, val shuffle: Boolean = false) + +/** + * The browse tree Android Auto draws. Auto renders everything itself, so "designing for the + * Miata" means shaping this tree for an 800×480 screen driven only by the commander knob: + * four tabs, shallow folders, Shuffle as the first row, A–Z folders instead of long lists, + * and grids only where the art identifies the item (albums). + * + * Away from home (Plex and stemserve unreachable) everything comes from the HTTP cache and + * only songs that will actually play offline are listed, with Downloads as the first tab. + */ +@OptIn(UnstableApi::class) +class CarLibrary(private val g: Graph) { + private val plex get() = g.carPlex + private val pm get() = g.playback + + private class Cached(val at: Long, val tracks: List) + private val trackCache = object : LinkedHashMap(16, 0.75f, true) { + override fun removeEldestEntry(eldest: MutableMap.MutableEntry) = size > 24 + } + + private suspend fun away() = !g.reach.reachable() + + // ---- tree ----------------------------------------------------------------------- + + suspend fun root(limit: Int): List { + val tabs = listOf( + tab(CarIds.PLAYLISTS, "Playlists", MediaMetadata.MEDIA_TYPE_FOLDER_PLAYLISTS, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM), + tab(CarIds.ALBUMS, "Albums", MediaMetadata.MEDIA_TYPE_FOLDER_ALBUMS, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM), + tab(CarIds.ARTISTS, "Artists", MediaMetadata.MEDIA_TYPE_FOLDER_ARTISTS, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM), + tab(CarIds.DOWNLOADS, "Downloads", MediaMetadata.MEDIA_TYPE_FOLDER_MIXED, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM), + ) + val ordered = if (away()) listOf(tabs[3]) + tabs.take(3) else tabs + return ordered.take(limit.coerceAtLeast(1)) + } + + /** Children of [id], or null if the id means nothing to us. */ + suspend fun children(id: String): List? = withContext(Dispatchers.IO) { + val away = away() + when (id) { + CarIds.DOWNLOADS -> songs(CarIds.DOWNLOADS, tracksOf(CarIds.DOWNLOADS), shuffleRow = true, showArtist = true) + CarIds.PLAYLISTS -> playlists(away) + CarIds.ALBUMS -> albumsTab(away) + CarIds.ARTISTS -> artistsTab(away) + else -> { + val (kind, key) = CarIds.split(id) ?: return@withContext null + when (kind) { + "playlist" -> songs(id, tracksOf(id), shuffleRow = true, showArtist = true) + "album" -> songs(id, tracksOf(id), shuffleRow = false, showArtist = false) + "artist" -> artistPage(key, away) + "albums" -> albumsFor(away).filter { CarTree.letterOf(it.title) == key }.map(::albumItem) + "artists" -> artistsFor(away).filter { CarTree.letterOf(it.sortTitle) == key }.map(::artistItem) + "search" -> searchItems(key) + else -> null + } + } + } + } + + private suspend fun playlists(away: Boolean): List { + val all = plex.playlists() + val shown = if (!away) all else all.filter { p -> runCatching { tracksOf(CarIds.playlist(p.ratingKey)).isNotEmpty() }.getOrDefault(false) } + return shown.map(::playlistItem) + } + + private suspend fun albumsTab(away: Boolean): List { + val albums = albumsFor(away) + if (away || albums.size <= CarTree.FLAT_MAX) return albums.map(::albumItem) + val recent = runCatching { plex.recentlyAdded(CarTree.RECENT_ALBUMS) }.getOrDefault(emptyList()) + return recent.map { albumItem(it, group = "Recently added") } + + CarTree.buckets(albums) { it.title }.map { (letter, list) -> + folder(CarIds.albumLetter(letter), letter, CarTree.countLabel(list.size, "album", "albums"), + MediaMetadata.MEDIA_TYPE_FOLDER_ALBUMS, art = CarArtProvider.letterUri(letter), childStyle = MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM, group = "All albums") + } + } + + private suspend fun artistsTab(away: Boolean): List { + val artists = artistsFor(away) + if (artists.size <= CarTree.FLAT_MAX) return artists.map(::artistItem) + return CarTree.buckets(artists) { it.sortTitle }.map { (letter, list) -> + folder(CarIds.artistLetter(letter), letter, CarTree.countLabel(list.size, "artist", "artists"), MediaMetadata.MEDIA_TYPE_FOLDER_ARTISTS, + art = CarArtProvider.letterUri(letter)) + } + } + + private suspend fun artistPage(key: String, away: Boolean): List { + val id = CarIds.artist(key) + val albums = if (away) downloadedTracks().filter { it.artistKey == key }.let(::albumsOf) else plex.artistAlbums(key) + val shuffle = if (tracksOf(id).isNotEmpty()) listOf(shuffleItem(id, "Shuffle artist")) else emptyList() + return shuffle + albums.map(::albumItem) + } + + /** Away from home, the library is what's downloaded. */ + private suspend fun albumsFor(away: Boolean): List = + if (away) albumsOf(downloadedTracks()).sortedBy { it.title.lowercase() } else plex.albums() + + private suspend fun artistsFor(away: Boolean): List = + if (away) { + downloadedTracks().filter { it.artistKey != null }.distinctBy { it.artistKey } + .map { Artist(it.artistKey!!, it.artist, it.artist, null) }.sortedBy { it.sortTitle.lowercase() } + } else plex.artists() + + private fun albumsOf(tracks: List) = tracks.filter { it.albumKey != null }.distinctBy { it.albumKey } + .map { Album(it.albumKey!!, it.album, it.artist, it.artistKey, it.year, it.thumb) } + + private fun downloadedTracks(): List = + g.downloads.records.value.values.filter { it.done }.map { it.track } + .sortedWith(compareBy({ it.artist.lowercase() }, { it.album.lowercase() }, { it.disc ?: 0 }, { it.index ?: 0 })) + + /** A container's songs, minus those that can't play right now. */ + private suspend fun tracksOf(container: String): List { + val now = System.nanoTime() + val away = away() + // Home and away lists differ (away keeps only what plays offline), so they cache apart. + val key = "$away|$container" + synchronized(trackCache) { + trackCache[key]?.takeIf { now - it.at < CACHE_NS && it.tracks.isNotEmpty() }?.let { return it.tracks } + } + val all = when (container) { + CarIds.DOWNLOADS -> downloadedTracks() + else -> { + val (kind, key) = CarIds.split(container) ?: return emptyList() + when (kind) { + "playlist" -> plex.playlistTracks(key) + "album" -> plex.albumTracks(key) + "artist" -> if (away) downloadedTracks().filter { it.artistKey == key } else plex.artistTracks(key) + "search" -> searchTracks(key) + else -> emptyList() + } + } + } + val playable = if (away) all.filter { pm.playableOffline(it) } else all + synchronized(trackCache) { trackCache[key] = Cached(now, playable) } + return playable + } + + // ---- picks ----------------------------------------------------------------------- + + /** Turns a tapped row into a queue. */ + suspend fun resolve(mediaId: String): Resolved? = withContext(Dispatchers.IO) { + val pick = CarIds.parsePick(mediaId) ?: return@withContext null + val tracks = tracksOf(pick.container) + if (tracks.isEmpty()) return@withContext null + when (pick) { + is CarIds.Pick.Shuffle -> Resolved(tracks, shuffle = true) + is CarIds.Pick.Song -> Resolved(tracks, tracks.indexOfFirst { it.ratingKey == pick.trackKey }.coerceAtLeast(0)) + } + } + + /** + * "Hey Google, play … on StemRoller". Prefers a playlist, then an artist (shuffled), then an + * album whose name matches; otherwise plays the song hits. Away from home it searches downloads. + */ + suspend fun resolveSearch(query: String): Resolved? = withContext(Dispatchers.IO) { + if (query.isBlank()) { + val dl = tracksOf(CarIds.DOWNLOADS) + return@withContext if (dl.isEmpty()) null else Resolved(dl, shuffle = true) + } + if (away()) { + val hits = offlineSearch(query) + return@withContext if (hits.isEmpty()) null else Resolved(hits) + } + val r = plex.search(query) + r.playlists.firstOrNull { CarTree.matches(it.title, query) }?.let { p -> + tracksOf(CarIds.playlist(p.ratingKey)).takeIf { it.isNotEmpty() }?.let { return@withContext Resolved(it) } + } + r.artists.firstOrNull { CarTree.matches(it.title, query) }?.let { a -> + tracksOf(CarIds.artist(a.ratingKey)).takeIf { it.isNotEmpty() }?.let { return@withContext Resolved(it, shuffle = true) } + } + r.albums.firstOrNull { CarTree.matches(it.title, query) }?.let { a -> + tracksOf(CarIds.album(a.ratingKey)).takeIf { it.isNotEmpty() }?.let { return@withContext Resolved(it) } + } + if (r.tracks.isNotEmpty()) return@withContext Resolved(r.tracks) + r.playlists.firstOrNull()?.let { return@withContext Resolved(tracksOf(CarIds.playlist(it.ratingKey))) } + r.artists.firstOrNull()?.let { return@withContext Resolved(tracksOf(CarIds.artist(it.ratingKey)), shuffle = true) } + r.albums.firstOrNull()?.let { return@withContext Resolved(tracksOf(CarIds.album(it.ratingKey))) } + null + } + + private suspend fun searchTracks(query: String): List = if (away()) offlineSearch(query) else plex.search(query).tracks + + private fun offlineSearch(query: String): List { + val q = CarTree.norm(query) + if (q.isEmpty()) return emptyList() + val dl = downloadedTracks() + return dl.filter { CarTree.norm(it.title).contains(q) } + + dl.filter { !CarTree.norm(it.title).contains(q) && (CarTree.norm(it.artist).contains(q) || CarTree.norm(it.album).contains(q)) } + } + + /** Results for Auto's search screen (voice input; there's no keyboard while driving). */ + suspend fun searchItems(query: String): List = withContext(Dispatchers.IO) { + val container = CarIds.search(query) + if (away()) return@withContext songs(container, tracksOf(container), shuffleRow = false, showArtist = true, group = "Downloaded songs") + val r = plex.search(query) + songs(container, tracksOf(container), shuffleRow = false, showArtist = true, group = "Songs") + + r.artists.map { artistItem(it, group = "Artists") } + + r.albums.map { albumItem(it, group = "Albums") } + + r.playlists.map { playlistItem(it, group = "Playlists") } + } + + // ---- items ----------------------------------------------------------------------- + + private fun songs(container: String, tracks: List, shuffleRow: Boolean, showArtist: Boolean, group: String? = null): List { + val rows = tracks.map { t -> songItem(container, t, showArtist, group) } + return if (shuffleRow && tracks.size > 1) listOf(shuffleItem(container, "Shuffle all", group)) + rows else rows + } + + private fun songItem(container: String, t: Track, showArtist: Boolean, group: String?): MediaItem { + // Stems are the norm, so only the exceptions are marked. + val noStems = g.stems.index.value.size > 0 && !pm.hasStems(t) + val subtitle = listOfNotNull(if (noStems) "No stems" else null, if (showArtist) t.artist else null).joinToString(" · ") + val extras = Bundle().apply { + group?.let { putString(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it) } + if (pm.playableOffline(t)) putLong(MediaConstants.EXTRAS_KEY_DOWNLOAD_STATUS, MediaConstants.EXTRAS_VALUE_STATUS_DOWNLOADED) + } + return item( + CarIds.play(container, t.ratingKey), t.title, subtitle.ifEmpty { null }, CarArtProvider.uri(t.thumb), + MediaMetadata.MEDIA_TYPE_MUSIC, playable = true, extras = extras, + ) { setArtist(t.artist).setAlbumTitle(t.album).setDurationMs(t.durationMs.takeIf { it > 0 }) } + } + + private fun shuffleItem(container: String, title: String, group: String? = null) = item( + CarIds.shuffle(container), title, null, Uri.parse("android.resource://${g.packageName}/drawable/ic_car_shuffle"), + MediaMetadata.MEDIA_TYPE_PLAYLIST, playable = true, + extras = Bundle().apply { group?.let { putString(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it) } }, + ) + + private fun playlistItem(p: Playlist, group: String? = null) = + folder(CarIds.playlist(p.ratingKey), p.title, CarTree.countLabel(p.trackCount, "song", "songs"), MediaMetadata.MEDIA_TYPE_PLAYLIST, + art = artOr(p.thumb, p.title), group = group) + + private fun albumItem(a: Album) = albumItem(a, null) + + private fun albumItem(a: Album, group: String?) = + folder(CarIds.album(a.ratingKey), a.title, a.artist, MediaMetadata.MEDIA_TYPE_ALBUM, art = artOr(a.thumb, a.title), group = group) + + private fun artistItem(a: Artist) = artistItem(a, null) + + private fun artistItem(a: Artist, group: String?) = + folder(CarIds.artist(a.ratingKey), a.title, null, MediaMetadata.MEDIA_TYPE_ARTIST, art = artOr(a.thumb, a.sortTitle), + childStyle = MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM, group = group) + + /** Plex art, or a letter tile so Auto never draws its missing-image triangle. */ + private fun artOr(thumb: String?, title: String) = CarArtProvider.uri(thumb) ?: CarArtProvider.letterUri(CarTree.letterOf(title)) + + private fun tab(id: String, title: String, type: Int, childStyle: Int) = folder(id, title, null, type, childStyle = childStyle) + + private fun folder( + id: String, title: String, subtitle: String?, type: Int, + art: Uri? = null, childStyle: Int? = null, group: String? = null, + ) = item(id, title, subtitle, art, type, playable = false, extras = Bundle().apply { + childStyle?.let { putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, it) } + putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + group?.let { putString(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it) } + }) + + private fun item( + id: String, title: String, subtitle: String?, art: Uri?, type: Int, playable: Boolean, extras: Bundle, + more: MediaMetadata.Builder.() -> Unit = {}, + ): MediaItem = MediaItem.Builder() + .setMediaId(id) + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(title) + // Without a display title Media3 gives Auto the artist as the second line, + // and the subtitle ("Stems · Artist", counts) never shows. + .setDisplayTitle(title) + .setSubtitle(subtitle) + .setArtworkUri(art) + .setMediaType(type) + .setIsPlayable(playable) + .setIsBrowsable(!playable) + .setExtras(extras) + .apply(more) + .build(), + ).build() + + private companion object { + const val CACHE_NS = 120_000_000_000L + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/auto/CarTree.kt b/android/app/src/main/java/com/stemroller/mobile/auto/CarTree.kt new file mode 100644 index 0000000..7ec30a0 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/auto/CarTree.kt @@ -0,0 +1,86 @@ +package com.stemroller.mobile.auto + +import java.text.Normalizer + +/** + * Media IDs for the Android Auto tree. Containers are `kind:key`; playable rows carry the + * container they were picked from, so choosing a song queues the rest of its list after it. + * The container goes last because search queries can contain anything. + */ +object CarIds { + const val ROOT = "root" + const val DOWNLOADS = "tab:downloads" + const val PLAYLISTS = "tab:playlists" + const val ALBUMS = "tab:albums" + const val ARTISTS = "tab:artists" + val TABS = listOf(DOWNLOADS, PLAYLISTS, ALBUMS, ARTISTS) + + fun playlist(key: String) = "playlist:$key" + fun album(key: String) = "album:$key" + fun artist(key: String) = "artist:$key" + fun albumLetter(letter: String) = "albums:$letter" + fun artistLetter(letter: String) = "artists:$letter" + fun search(query: String) = "search:$query" + + fun play(container: String, trackKey: String) = "play|$trackKey|$container" + fun shuffle(container: String) = "shuffle|$container" + + sealed interface Pick { + val container: String + data class Song(override val container: String, val trackKey: String) : Pick + data class Shuffle(override val container: String) : Pick + } + + fun parsePick(id: String): Pick? = when { + id.startsWith("play|") -> { + val rest = id.removePrefix("play|") + val bar = rest.indexOf('|') + if (bar <= 0 || bar == rest.lastIndex) null else Pick.Song(rest.substring(bar + 1), rest.substring(0, bar)) + } + id.startsWith("shuffle|") -> id.removePrefix("shuffle|").takeIf { it.isNotEmpty() }?.let { Pick.Shuffle(it) } + else -> null + } + + /** (kind, key) of a container id such as `album:123`. */ + fun split(id: String): Pair? { + val c = id.indexOf(':') + return if (c <= 0) null else id.substring(0, c) to id.substring(c + 1) + } +} + +object CarTree { + /** + * Lists longer than this split into A–Z folders: turning the commander knob through a few + * dozen rows is fine, through hundreds it isn't (and Auto stops long scrolls while moving). + */ + const val FLAT_MAX = 40 + + /** Recently added albums shown above the A–Z folders. */ + const val RECENT_ALBUMS = 12 + + /** "#" for anything that doesn't start with a letter; accents fold to their base letter. */ + fun letterOf(sortTitle: String): String { + val c = Normalizer.normalize(sortTitle.trim(), Normalizer.Form.NFD).firstOrNull { it.isLetterOrDigit() } ?: return "#" + val u = c.uppercaseChar() + return if (u in 'A'..'Z') u.toString() else "#" + } + + /** Items by first letter, "#" first then A–Z, each keeping the incoming order. */ + fun buckets(items: List, sortTitle: (T) -> String): Map> = + items.groupBy { letterOf(sortTitle(it)) }.toSortedMap(compareBy { if (it == "#") "" else it }) + + fun countLabel(n: Int, one: String, many: String) = "$n ${if (n == 1) one else many}" + + /** Loose title match for voice requests: case, accents and punctuation don't matter. */ + fun norm(s: String) = Normalizer.normalize(s, Normalizer.Form.NFD) + .lowercase() + .filter { it.isLetterOrDigit() || it == ' ' } + .replace(Regex("\\s+"), " ") + .trim() + + fun matches(title: String, query: String): Boolean { + val t = norm(title) + val q = norm(query) + return q.isNotEmpty() && (t == q || t.removePrefix("the ") == q.removePrefix("the ")) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/auto/HomeReach.kt b/android/app/src/main/java/com/stemroller/mobile/auto/HomeReach.kt new file mode 100644 index 0000000..8febada --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/auto/HomeReach.kt @@ -0,0 +1,74 @@ +package com.stemroller.mobile.auto + +import com.stemroller.mobile.core.Connectivity +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.core.await +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.async +import kotlinx.coroutines.coroutineScope +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.drop +import kotlinx.coroutines.flow.merge +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import okhttp3.OkHttpClient +import okhttp3.Request +import java.util.concurrent.TimeUnit + +/** + * Whether Plex or stemserve answers right now. In the car the phone is usually on mobile + * data and the LAN addresses just time out, so the car UI asks this first (a quick probe, + * remembered briefly) and goes straight to cached data when home is out of reach. + */ +class HomeReach(http: OkHttpClient, private val settings: Settings, net: Connectivity, scope: CoroutineScope) { + private val probe = http.newBuilder() + .cache(null) + .connectTimeout(1500, TimeUnit.MILLISECONDS) + .readTimeout(2000, TimeUnit.MILLISECONDS) + .callTimeout(2500, TimeUnit.MILLISECONDS) + .build() + private val lock = Mutex() + @Volatile private var checkedAt = 0L + + private val _home = MutableStateFlow(true) + + /** The last answer; true until a probe says otherwise. Changes as the phone joins or leaves home Wi-Fi. */ + val home: StateFlow = _home.asStateFlow() + val lastKnown get() = _home.value + + init { + // A new network (home Wi-Fi in range, or lost) invalidates the answer; ask again once it settles, + // so the car's lists can switch over without anyone browsing first. + scope.launch { + merge(net.online.drop(1), net.unmetered.drop(1)).collect { + checkedAt = 0 + delay(1500) + reachable() + } + } + } + + suspend fun reachable(): Boolean = lock.withLock { + if (System.nanoTime() - checkedAt < TTL_NS && checkedAt != 0L) return lastKnown + val ok = coroutineScope { + val plex = async { answers(settings.plexUrl.value.trimEnd('/') + "/identity") } + val stems = async { answers(settings.stemUrl.value.trimEnd('/') + "/api/info") } + plex.await() || stems.await() + } + _home.value = ok + checkedAt = System.nanoTime() + ok + } + + private suspend fun answers(url: String): Boolean = runCatching { + probe.newCall(Request.Builder().url(url).build()).await().use { it.code < 500 } + }.getOrDefault(false) + + private companion object { + const val TTL_NS = 20_000_000_000L + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/cache/Downloads.kt b/android/app/src/main/java/com/stemroller/mobile/cache/Downloads.kt new file mode 100644 index 0000000..6ce64f2 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/cache/Downloads.kt @@ -0,0 +1,228 @@ +package com.stemroller.mobile.cache + +import android.app.Notification +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.app.Service +import android.content.Context +import android.content.Intent +import android.content.pm.ServiceInfo +import android.os.IBinder +import coil3.SingletonImageLoader +import coil3.request.ImageRequest +import com.stemroller.mobile.App +import com.stemroller.mobile.MainActivity +import com.stemroller.mobile.R +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.core.Connectivity +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.playback.PlaybackManager +import com.stemroller.mobile.plex.PlexClient +import com.stemroller.mobile.plex.Track +import com.stemroller.mobile.stems.StemServer +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.cancel +import kotlinx.coroutines.channels.Channel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.serialization.Serializable +import java.io.File +import java.io.IOException + +@Serializable +data class DownloadRecord( + val track: Track, + val keys: List = emptyList(), + val stems: Boolean = false, + val done: Boolean = false, + val error: String? = null, + val added: Long = System.currentTimeMillis(), +) + +/** + * Offline copies: the track's stems (or the original file) fully fetched into + * [MediaCache] and pinned, plus the metadata needed to browse them with no server. + */ +class Downloads( + private val context: Context, + private val settings: Settings, + private val plex: PlexClient, + private val stems: StemServer, + private val cache: MediaCache, + private val net: Connectivity, + private val scope: CoroutineScope, +) { + private val file = File(context.filesDir, "downloads.json") + private val _records = MutableStateFlow(load()) + val records: StateFlow> = _records.asStateFlow() + /** ratingKey -> 0..1 for queued and running downloads. */ + private val _progress = MutableStateFlow>(emptyMap()) + val progress: StateFlow> = _progress.asStateFlow() + private val queue = Channel(Channel.UNLIMITED) + private val cancelled = HashSet() + + init { + repeat(2) { scope.launch(Dispatchers.IO) { for (key in queue) run(key) } } + // Resume anything interrupted last time. + _records.value.values.filter { !it.done && it.error == null }.forEach { enqueue(it.track.ratingKey) } + } + + fun isDownloaded(ratingKey: String) = _records.value[ratingKey]?.done == true + + fun download(tracks: List) { + val add = tracks.filter { _records.value[it.ratingKey]?.let { r -> !r.done && r.error == null } != true && !isDownloaded(it.ratingKey) } + if (add.isEmpty()) return + update { m -> m + add.associate { it.ratingKey to DownloadRecord(it) } } + add.forEach { enqueue(it.ratingKey) } + context.startForegroundService(Intent(context, DownloadService::class.java)) + } + + fun remove(tracks: List) { + val keys = tracks.map { it.ratingKey }.toSet() + synchronized(cancelled) { cancelled += keys } + val gone = _records.value.filterKeys { it in keys }.values + update { m -> m - keys } + _progress.update { it - keys } + scope.launch(Dispatchers.IO) { gone.forEach { r -> r.keys.forEach { cache.unpin(it) } } } + } + + fun retryFailed() { + val failed = _records.value.values.filter { it.error != null } + update { m -> m + failed.associate { it.track.ratingKey to it.copy(error = null) } } + failed.forEach { enqueue(it.track.ratingKey) } + if (failed.isNotEmpty()) context.startForegroundService(Intent(context, DownloadService::class.java)) + } + + private fun enqueue(key: String) { + synchronized(cancelled) { cancelled -= key } + _progress.update { it + (key to 0f) } + queue.trySend(key) + } + + private suspend fun run(key: String) { + val rec = _records.value[key] ?: return + if (rec.done) return + try { + if (settings.downloadsWifiOnly.value) net.unmetered.first { it } + val t = rec.track + val entry = stems.find(t) + val sources = if (entry != null) { + val q = stems.effectiveQuality(settings.stemQuality.value) + stems.prepare(entry, q) + entry.stems.map { PlaybackManager.stemKey(entry, it.file, it.size, q) to stems.fileUrl(entry, it, q) } + } else { + val part = t.partKey ?: throw IOException("No file on the server") + listOf(PlaybackManager.plexKey(t) to plex.partUrl(part)) + } + update { m -> m + (key to rec.copy(keys = sources.map { it.first }, stems = entry != null)) } + sources.forEachIndexed { i, (cacheKey, url) -> + val res = cache.acquire(cacheKey) { url } + try { + res.pinned = true + res.downloadAll( + progress = { got, len -> + val f = if (len > 0) got.toFloat() / len else 0f + _progress.update { it + (key to (i + f) / sources.size) } + }, + cancelled = { synchronized(cancelled) { key in cancelled } }, + ) + } finally { + cache.release(res) + } + } + if (synchronized(cancelled) { key in cancelled }) return + if (entry != null) stems.peaks(entry, PlaybackManager.WAVE_BUCKETS) // warms the HTTP cache for offline + plex.artUrl(t.thumb, 600)?.let { url -> + withContext(Dispatchers.Main) { + SingletonImageLoader.get(context).enqueue(ImageRequest.Builder(context).data(url).build()) + } + } + update { m -> if (key in m) m + (key to m.getValue(key).copy(done = true, error = null)) else m } + } catch (e: Exception) { + if (synchronized(cancelled) { key in cancelled }) return + update { m -> if (key in m) m + (key to m.getValue(key).copy(error = e.message ?: "Download failed")) else m } + } finally { + _progress.update { it - key } + } + } + + private fun update(f: (Map) -> Map) { + synchronized(this) { _records.value = f(_records.value) } + val snapshot = _records.value + scope.launch(Dispatchers.IO) { + synchronized(file) { + runCatching { + val tmp = File(file.parentFile, "downloads.json.tmp") + tmp.writeText(AppJson.encodeToString(LIST, snapshot.values.toList())) + tmp.renameTo(file) + } + } + } + } + + private fun load(): Map = runCatching { + AppJson.decodeFromString(LIST, file.readText()).associateBy { it.track.ratingKey } + }.getOrDefault(emptyMap()) + + companion object { + private val LIST = kotlinx.serialization.builtins.ListSerializer(DownloadRecord.serializer()) + } +} + +/** Keeps the process alive while downloads run, with progress in a notification. */ +class DownloadService : Service() { + private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main) + private var job: Job? = null + + override fun onBind(intent: Intent?): IBinder? = null + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + val nm = getSystemService(NotificationManager::class.java) + nm.createNotificationChannel(NotificationChannel(CHANNEL, "Downloads", NotificationManager.IMPORTANCE_LOW)) + startForeground(ID, build(0, 0f), ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC) + if (job == null) { + job = scope.launch { + App.graph.downloads.progress.collectLatest { p -> + if (p.isEmpty()) { + stopForeground(STOP_FOREGROUND_REMOVE) + stopSelf() + } else { + nm.notify(ID, build(p.size, p.values.average().toFloat())) + } + } + } + } + return START_NOT_STICKY + } + + private fun build(left: Int, fraction: Float): Notification { + val open = PendingIntent.getActivity(this, 1, Intent(this, MainActivity::class.java), PendingIntent.FLAG_IMMUTABLE) + return Notification.Builder(this, CHANNEL) + .setSmallIcon(R.drawable.ic_stat_stems) + .setContentTitle(if (left > 0) "Downloading $left song${if (left == 1) "" else "s"}" else "Preparing downloads") + .setProgress(1000, (fraction * 1000).toInt(), left == 0) + .setOngoing(true) + .setContentIntent(open) + .build() + } + + override fun onDestroy() { + scope.cancel() + super.onDestroy() + } + + companion object { + private const val CHANNEL = "downloads" + private const val ID = 7 + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/cache/MediaCache.kt b/android/app/src/main/java/com/stemroller/mobile/cache/MediaCache.kt new file mode 100644 index 0000000..98a94f1 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/cache/MediaCache.kt @@ -0,0 +1,448 @@ +package com.stemroller.mobile.cache + +import com.stemroller.mobile.core.AppJson +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.serialization.Serializable +import okhttp3.OkHttpClient +import okhttp3.Request +import java.io.File +import java.io.IOException +import java.io.RandomAccessFile +import java.nio.ByteBuffer +import java.nio.channels.FileChannel +import java.security.MessageDigest +import java.util.Base64 +import java.util.BitSet +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit +import java.util.concurrent.locks.ReentrantLock +import kotlin.concurrent.withLock +import kotlin.math.min + +@Serializable +internal data class Meta( + val length: Long = -1, + val bits: String = "", + val pinned: Boolean = false, + val access: Long = 0, +) + +/** + * Disk cache for stems and original tracks. Each resource is a sparse file filled in + * BLOCK-sized pieces with HTTP range requests: reads block only on the bytes they need, + * a background prefetcher fills the rest in order, and seeks (FLAC without a seek table + * bisects the file) fetch out of order. Pinned resources are downloads and never evicted. + */ +class MediaCache( + private val dir: File, + internal val http: OkHttpClient, + private val limitBytes: () -> Long, +) { + private val open = HashMap() + private val refs = HashMap() + private val catalog = HashMap() + private val prefetchPool = Executors.newFixedThreadPool(6) { r -> Thread(r, "media-prefetch").apply { isDaemon = true } } + private val trimPool = Executors.newSingleThreadExecutor { r -> Thread(r, "media-trim").apply { isDaemon = true } } + private val _usage = MutableStateFlow(Usage(0, 0)) + val usage: StateFlow = _usage.asStateFlow() + + data class Usage(val cachedBytes: Long, val pinnedBytes: Long) + private class CatalogEntry(var bytes: Long, var access: Long, var pinned: Boolean) + + init { + dir.mkdirs() + trimPool.execute { + dir.listFiles { f -> f.name.endsWith(".meta") }?.forEach { f -> + val m = readMeta(f) ?: return@forEach + val id = f.name.removeSuffix(".meta") + synchronized(this) { + if (id !in catalog) catalog[id] = CatalogEntry(bitsOf(m).cardinality().toLong() * BLOCK, m.access, m.pinned) + } + } + publishUsage() + } + } + + /** Opens (or reuses) a resource; pair every call with [release]. */ + @Synchronized + fun acquire(key: String, url: () -> String): CachedResource { + val id = idFor(key) + refs[id] = (refs[id] ?: 0) + 1 + return open.getOrPut(id) { CachedResource(id, File(dir, "$id.data"), File(dir, "$id.meta"), url, this) } + } + + @Synchronized + fun release(res: CachedResource) { + val n = (refs[res.id] ?: 1) - 1 + if (n > 0) { + refs[res.id] = n + return + } + refs.remove(res.id) + open.remove(res.id) + res.close() + scheduleTrim() + } + + fun isComplete(key: String): Boolean { + val id = idFor(key) + synchronized(this) { open[id]?.let { return it.isComplete } } + val m = readMeta(File(dir, "$id.meta")) ?: return false + return m.length >= 0 && bitsOf(m).cardinality() >= blocksFor(m.length) && File(dir, "$id.data").exists() + } + + fun isPinned(key: String): Boolean = synchronized(this) { catalog[idFor(key)]?.pinned == true } + + /** Unpins a download so normal eviction can reclaim it. */ + fun unpin(key: String) { + val id = idFor(key) + synchronized(this) { open[id] }?.let { it.pinned = false; return } + val f = File(dir, "$id.meta") + val m = readMeta(f) ?: return + writeMeta(f, m.copy(pinned = false)) + synchronized(this) { catalog[id]?.pinned = false } + publishUsage() + scheduleTrim() + } + + /** Deletes every resource that isn't pinned or in use. */ + fun clearUnpinned() { + trimPool.execute { evict(keepBytes = 0) } + } + + internal fun submitPrefetch(task: Runnable) = prefetchPool.execute(task) + + internal fun update(id: String, bytes: Long, access: Long, pinned: Boolean) { + synchronized(this) { + val e = catalog.getOrPut(id) { CatalogEntry(0, 0, false) } + e.bytes = bytes; e.access = access; e.pinned = pinned + } + publishUsage() + } + + private fun publishUsage() { + synchronized(this) { + var all = 0L + var pinned = 0L + for (e in catalog.values) { + all += e.bytes + if (e.pinned) pinned += e.bytes + } + _usage.value = Usage(all, pinned) + } + } + + private var trimQueued = false + + private fun scheduleTrim() { + synchronized(this) { + if (trimQueued) return + trimQueued = true + } + trimPool.execute { + synchronized(this) { trimQueued = false } + evict(limitBytes()) + } + } + + private fun evict(keepBytes: Long) { + val victims = synchronized(this) { + var total = catalog.values.sumOf { it.bytes } + val out = ArrayList() + for ((id, e) in catalog.entries.sortedBy { it.value.access }) { + if (total <= keepBytes) break + if (e.pinned || id in open) continue + out += id + total -= e.bytes + } + out.forEach { catalog.remove(it) } + out + } + for (id in victims) { + File(dir, "$id.data").delete() + File(dir, "$id.meta").delete() + } + if (victims.isNotEmpty()) publishUsage() + } + + internal fun readMeta(f: File): Meta? = + runCatching { AppJson.decodeFromString(Meta.serializer(), f.readText()) }.getOrNull() + + internal fun writeMeta(f: File, m: Meta) { + val tmp = File(f.parentFile, f.name + ".tmp") + tmp.writeText(AppJson.encodeToString(Meta.serializer(), m)) + tmp.renameTo(f) + } + + companion object { + const val BLOCK = 64 * 1024 + const val ON_DEMAND_RUN = 8 + const val PREFETCH_RUN = 32 + + fun idFor(key: String): String = + MessageDigest.getInstance("SHA-1").digest(key.toByteArray()).joinToString("") { "%02x".format(it) } + + internal fun blocksFor(length: Long) = ((length + BLOCK - 1) / BLOCK).toInt() + + internal fun bitsOf(m: Meta): BitSet = + if (m.bits.isEmpty()) BitSet() else BitSet.valueOf(Base64.getDecoder().decode(m.bits)) + } + + /** One cached remote file. Thread-safe; readers block until their bytes have arrived. */ + class CachedResource internal constructor( + val id: String, + private val dataFile: File, + private val metaFile: File, + private val url: () -> String, + private val cache: MediaCache, + ) { + private val lock = ReentrantLock() + private val changed = lock.newCondition() + private val bits: BitSet + private val claimed = BitSet() + private var raf: RandomAccessFile? = null + private var channel: FileChannel? = null + private var failure: IOException? = null + private var unsaved = 0 + private var prefetching = false + @Volatile private var lastRead = 0 + @Volatile private var closed = false + @Volatile var length: Long = -1 + private set + @Volatile private var pinnedFlag = false + var pinned: Boolean + get() = pinnedFlag + set(v) { + pinnedFlag = v + saveMeta() + } + + init { + val m = cache.readMeta(metaFile) + if (m != null && dataFile.exists()) { + length = m.length + bits = bitsOf(m) + pinnedFlag = m.pinned + } else { + bits = BitSet() + dataFile.delete() + } + } + + private val blockCount get() = if (length < 0) Int.MAX_VALUE else blocksFor(length) + val isComplete get() = lock.withLock { length >= 0 && bits.cardinality() >= blocksFor(length) } + val cachedBytes get() = lock.withLock { min(bits.cardinality().toLong() * BLOCK, if (length < 0) Long.MAX_VALUE else length) } + + private fun channel(): FileChannel = lock.withLock { + if (closed) throw IOException("closed") + channel ?: RandomAccessFile(dataFile, "rw").also { raf = it }.channel.also { channel = it } + } + + /** Total size, fetching the first run if it isn't known yet. */ + fun size(): Long { + if (length < 0) awaitBlock(0) + return length + } + + /** Reads up to [size] bytes at [pos]; -1 at end of file. Blocks on the network if needed. */ + fun readAt(pos: Long, buf: ByteArray, off: Int, size: Int): Int { + val total = size() + if (pos >= total) return -1 + val n = min(size.toLong(), total - pos).toInt() + if (n <= 0) return 0 + val first = (pos / BLOCK).toInt() + val last = ((pos + n - 1) / BLOCK).toInt() + for (b in first..last) awaitBlock(b) + lastRead = last + val bb = ByteBuffer.wrap(buf, off, n) + var at = pos + val ch = channel() + while (bb.hasRemaining()) { + val r = ch.read(bb, at) + if (r < 0) break + at += r + } + return n - bb.remaining() + } + + /** Starts filling the rest of the file in the background, from wherever reading is. */ + fun prefetch() { + lock.withLock { + if (prefetching || closed) return + prefetching = true + } + cache.submitPrefetch { + try { + fillAll(fromBlock = { lastRead }, cancelled = { closed }) + } catch (_: IOException) { + // A reader that needs these bytes will retry and surface the error. + } finally { + lock.withLock { prefetching = false } + } + } + } + + /** Downloads every missing block on the calling thread. */ + fun downloadAll(progress: (Long, Long) -> Unit, cancelled: () -> Boolean) { + fillAll(fromBlock = { 0 }, cancelled = cancelled, progress = progress) + } + + private fun fillAll(fromBlock: () -> Int, cancelled: () -> Boolean, progress: ((Long, Long) -> Unit)? = null) { + size() + while (!cancelled()) { + var run: IntRange? = null + var waitFor = -1 + lock.withLock { + val count = blockCount + if (bits.cardinality() >= count) return + val start = fromBlock().coerceIn(0, count - 1) + var b = bits.nextClearBit(start) + if (b >= count) b = bits.nextClearBit(0) + if (b >= count) return + if (claimed[b]) { + // Someone else is fetching here; look for a free block after it. + var c = b + while (c < count && (bits[c] || claimed[c])) c++ + if (c >= count) waitFor = b else run = claimRun(c, PREFETCH_RUN) + } else { + run = claimRun(b, PREFETCH_RUN) + } + } + run?.let { fetch(it) } + if (waitFor >= 0) awaitBlock(waitFor) + progress?.invoke(cachedBytes, length) + } + } + + private fun awaitBlock(b: Int) { + var waited = 0L + while (true) { + var run: IntRange? = null + lock.withLock { + if (closed) throw IOException("closed") + if (length >= 0 && b >= blockCount) return + if (bits[b]) return + if (!claimed[b]) { + run = claimRun(b, ON_DEMAND_RUN) + } else { + val before = System.nanoTime() + changed.await(1, TimeUnit.SECONDS) + waited += System.nanoTime() - before + if (waited > TimeUnit.SECONDS.toNanos(60)) throw failure ?: IOException("timed out waiting for data") + } + } + run?.let { fetch(it) } + } + } + + /** Claims up to [max] consecutive missing, unclaimed blocks from [b]. Caller holds the lock. */ + private fun claimRun(b: Int, max: Int): IntRange { + var end = b + val count = blockCount + while (end + 1 < count && end + 1 - b < max && !bits[end + 1] && !claimed[end + 1]) end++ + claimed.set(b, end + 1) + return b..end + } + + private fun fetch(run: IntRange) { + var block = run.first + try { + val start = run.first.toLong() * BLOCK + val endExclusive = if (length >= 0) min((run.last + 1L) * BLOCK, length) else (run.last + 1L) * BLOCK + val req = Request.Builder().url(url()).header("Range", "bytes=$start-${endExclusive - 1}").build() + cache.http.newCall(req).execute().use { resp -> + var skip = 0L + when (resp.code) { + 206 -> { + val total = resp.header("Content-Range")?.substringAfter('/')?.toLongOrNull() + if (total != null) learnLength(total) + } + 200 -> { + // No range support: the body is the whole file. + resp.body?.contentLength()?.takeIf { it >= 0 }?.let { learnLength(it) } + skip = start + } + else -> throw IOException("HTTP ${resp.code} fetching media") + } + if (length < 0) throw IOException("server sent no length") + val body = resp.body ?: throw IOException("empty response") + val src = body.byteStream() + val tmp = ByteArray(BLOCK) + while (skip > 0) { + val s = src.skip(skip) + if (s <= 0) throw IOException("short response") + skip -= s + } + val ch = channel() + val lastBlock = min(run.last, blockCount - 1) + while (block <= lastBlock) { + val blockStart = block.toLong() * BLOCK + val want = (min(blockStart + BLOCK, length) - blockStart).toInt() + var got = 0 + while (got < want) { + val r = src.read(tmp, got, want - got) + if (r < 0) throw IOException("connection ended early") + got += r + } + val bb = ByteBuffer.wrap(tmp, 0, want) + var at = blockStart + while (bb.hasRemaining()) at += ch.write(bb, at) + lock.withLock { + bits.set(block) + claimed.clear(block) + failure = null + changed.signalAll() + } + block++ + if (++unsaved >= 32 || block > lastBlock && isComplete) saveMeta() + } + } + } catch (e: IOException) { + lock.withLock { + failure = e + changed.signalAll() + } + throw e + } finally { + lock.withLock { + // Release whatever this run didn't deliver, including blocks past EOF. + for (b in block..run.last) claimed.clear(b) + changed.signalAll() + } + } + } + + private fun learnLength(total: Long) { + lock.withLock { + if (length != total) { + length = total + val count = blocksFor(total) + if (bits.length() > count) bits.clear(count, bits.length()) + } + } + } + + private fun saveMeta() { + val m = lock.withLock { + unsaved = 0 + Meta(length, Base64.getEncoder().encodeToString(bits.toByteArray()), pinnedFlag, System.currentTimeMillis()) + } + runCatching { cache.writeMeta(metaFile, m) } + cache.update(id, min(bits.cardinality().toLong() * BLOCK, if (length < 0) 0 else length), m.access, m.pinned) + } + + internal fun close() { + closed = true + lock.withLock { changed.signalAll() } + saveMeta() + lock.withLock { + runCatching { channel?.close() } + runCatching { raf?.close() } + channel = null + raf = null + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/core/Net.kt b/android/app/src/main/java/com/stemroller/mobile/core/Net.kt new file mode 100644 index 0000000..d92e006 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/core/Net.kt @@ -0,0 +1,73 @@ +package com.stemroller.mobile.core + +import android.content.Context +import android.net.ConnectivityManager +import android.net.Network +import android.net.NetworkCapabilities +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlinx.coroutines.withContext +import kotlinx.serialization.json.Json +import okhttp3.Call +import okhttp3.Callback +import okhttp3.Response +import java.io.IOException +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException + +val AppJson = Json { + ignoreUnknownKeys = true + coerceInputValues = true + isLenient = true + explicitNulls = false + encodeDefaults = true +} + +class HttpException(val code: Int, message: String) : IOException(message) + +/** Runs the call on OkHttp's dispatcher; cancelling the coroutine cancels the request. */ +suspend fun Call.await(): Response = suspendCancellableCoroutine { cont -> + enqueue(object : Callback { + override fun onFailure(call: Call, e: IOException) { + if (!cont.isCancelled) cont.resumeWithException(e) + } + + override fun onResponse(call: Call, response: Response) { + cont.resume(response) + } + }) + cont.invokeOnCancellation { runCatching { cancel() } } +} + +/** Awaits the call and reads the body off the main thread (big bodies stream from the socket). */ +suspend fun Call.awaitBody(): String = withContext(Dispatchers.IO) { + await().use { r -> + if (!r.isSuccessful) throw HttpException(r.code, "HTTP ${r.code} from ${r.request.url.host}") + r.body?.string() ?: "" + } +} + +/** Online / Wi-Fi state, for offline fallbacks and Wi-Fi-only downloads. */ +class Connectivity(context: Context) { + private val cm = context.getSystemService(ConnectivityManager::class.java) + private val _online = MutableStateFlow(true) + private val _unmetered = MutableStateFlow(true) + val online: StateFlow = _online.asStateFlow() + val unmetered: StateFlow = _unmetered.asStateFlow() + + init { + update(cm.getNetworkCapabilities(cm.activeNetwork)) + cm.registerDefaultNetworkCallback(object : ConnectivityManager.NetworkCallback() { + override fun onCapabilitiesChanged(network: Network, caps: NetworkCapabilities) = update(caps) + override fun onLost(network: Network) = update(null) + }) + } + + private fun update(caps: NetworkCapabilities?) { + _online.value = caps?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true + _unmetered.value = caps?.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED) == true + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/core/Settings.kt b/android/app/src/main/java/com/stemroller/mobile/core/Settings.kt new file mode 100644 index 0000000..bf0db38 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/core/Settings.kt @@ -0,0 +1,99 @@ +package com.stemroller.mobile.core + +import android.content.Context +import android.content.SharedPreferences +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import java.util.UUID + +enum class ThemeMode(val label: String) { Black("Black"), Dark("Dark"), White("White") } + +/** iOS system tints, light then dark variant. */ +enum class Accent(val label: String, val light: Long, val dark: Long) { + Music("Music", 0xFFFA2D48, 0xFFFC3C44), + Pink("Pink", 0xFFFF2D55, 0xFFFF375F), + Orange("Orange", 0xFFFF9500, 0xFFFF9F0A), + Yellow("Yellow", 0xFFFFCC00, 0xFFFFD60A), + Green("Green", 0xFF34C759, 0xFF30D158), + Teal("Teal", 0xFF30B0C7, 0xFF40C8E0), + Blue("Blue", 0xFF007AFF, 0xFF0A84FF), + Indigo("Indigo", 0xFF5856D6, 0xFF5E5CE6), + Purple("Purple", 0xFFAF52DE, 0xFFBF5AF2), +} + +/** How stems travel from stemserve; Opus is transcoded (and cached) server-side. */ +enum class StemQuality(val label: String, val detail: String, val fmt: String, val kbps: Int) { + Lossless("Lossless", "Original 24-bit FLAC, ~30 MB per stem-minute", "flac", 0), + High("High", "Opus 256 kbps per stem", "opus", 256), + Standard("Standard", "Opus 160 kbps per stem", "opus", 160), + Saver("Data Saver", "Opus 96 kbps per stem", "opus", 96), +} + +class Pref( + private val prefs: SharedPreferences, + private val key: String, + initial: T, + private val read: SharedPreferences.(String, T) -> T, + private val write: SharedPreferences.Editor.(String, T) -> Unit, +) { + private val state = MutableStateFlow(prefs.read(key, initial)) + val flow: StateFlow = state.asStateFlow() + var value: T + get() = state.value + set(v) { + if (v == state.value) return + state.value = v + prefs.edit().apply { write(key, v) }.apply() + } +} + +class Settings(context: Context) { + private val prefs = context.getSharedPreferences("settings", Context.MODE_PRIVATE) + + private fun string(key: String, def: String) = + Pref(prefs, key, def, { k, d -> getString(k, d) ?: d }, { k, v -> putString(k, v) }) + + private fun bool(key: String, def: Boolean) = + Pref(prefs, key, def, { k, d -> getBoolean(k, d) }, { k, v -> putBoolean(k, v) }) + + private fun int(key: String, def: Int) = + Pref(prefs, key, def, { k, d -> getInt(k, d) }, { k, v -> putInt(k, v) }) + + private fun float(key: String, def: Float) = + Pref(prefs, key, def, { k, d -> getFloat(k, d) }, { k, v -> putFloat(k, v) }) + + private inline fun > enum(key: String, def: E) = Pref( + prefs, key, def, + { k, d -> getString(k, null)?.let { s -> enumValues().firstOrNull { it.name == s } } ?: d }, + { k, v -> putString(k, v.name) }, + ) + + val plexUrl = string("plexUrl", "http://192.168.86.2:32400") + val plexToken = string("plexToken", "") + val plexUser = string("plexUser", "") + val plexMachineId = string("plexMachineId", "") + val musicSection = string("musicSection", "") + val musicSectionTitle = string("musicSectionTitle", "") + val stemUrl = string("stemUrl", "http://192.168.86.2:8765") + val stemToken = string("stemToken", "") + /** Plex path prefixes that matched the stems index, newline-separated. */ + val stemRoots = string("stemRoots", "") + + val theme = enum("theme", ThemeMode.Black) + val accent = enum("accent", Accent.Music) + val albumColorNowPlaying = bool("albumColorNowPlaying", false) + val highRefreshRate = bool("highRefreshRate", true) + + val stemQuality = enum("stemQuality", StemQuality.High) + val cacheLimitGb = int("cacheLimitGb", 10) + val downloadsWifiOnly = bool("downloadsWifiOnly", true) + /** Downloads page order: 0 download order, 1 artist, 2 release date. */ + val downloadSort = int("downloadSort", 0) + val keepStemMix = bool("keepStemMix", true) + val masterVolume = float("masterVolume", 0.85f) + + val clientId: String = prefs.getString("clientId", null) ?: UUID.randomUUID().toString().also { + prefs.edit().putString("clientId", it).apply() + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/engine/Dsp.kt b/android/app/src/main/java/com/stemroller/mobile/engine/Dsp.kt new file mode 100644 index 0000000..6cb6ea4 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/engine/Dsp.kt @@ -0,0 +1,266 @@ +package com.stemroller.mobile.engine + +import kotlin.math.PI +import kotlin.math.abs +import kotlin.math.cos +import kotlin.math.exp +import kotlin.math.log10 +import kotlin.math.max +import kotlin.math.pow +import kotlin.math.sin +import kotlin.math.sqrt +import kotlin.math.tan +import kotlinx.serialization.Serializable + +/** ISO octave centres for the 10-band graphic EQ. */ +val EQ_BANDS = floatArrayOf(31.25f, 62.5f, 125f, 250f, 500f, 1000f, 2000f, 4000f, 8000f, 16000f) +val EQ_LABELS = listOf("31", "62", "125", "250", "500", "1K", "2K", "4K", "8K", "16K") +const val EQ_MAX_DB = 12f +const val EQ_Q = 1.41f // one octave + +/** Equalizer APO's filter types; [apo] is the name its config files use. */ +@Serializable +enum class FilterType(val apo: String, val label: String, val hasGain: Boolean, val hasSlope: Boolean = false) { + Peak("PK", "Peak", true), + LowShelf("LSC", "Low Shelf", true), + HighShelf("HSC", "High Shelf", true), + LowPass("LPQ", "Low Pass", false, hasSlope = true), + HighPass("HPQ", "High Pass", false, hasSlope = true), + BandPass("BP", "Band Pass", false), + Notch("NO", "Notch", false), + AllPass("AP", "All Pass", false), +} + +@Serializable +enum class EqChannel(val label: String) { Both("Both"), Left("Left"), Right("Right") } + +/** Slopes offered for low and high pass, in dB per octave. 12 uses the filter's Q; steeper ones are Butterworth. */ +val EQ_SLOPES = listOf(6, 12, 24, 36, 48) + +/** One parametric filter, as in Equalizer APO. Gain only matters for peaks and shelves. */ +@Serializable +data class EqFilter( + val id: String, + val type: FilterType = FilterType.Peak, + val freq: Float = 1000f, + val gain: Float = 0f, + val q: Float = 0.707f, + val slope: Int = 12, + val channel: EqChannel = EqChannel.Both, + val on: Boolean = true, +) { + /** Whether it changes the sound at all (a 0 dB peak or shelf doesn't). */ + val active get() = on && (!type.hasGain || abs(gain) >= 0.01f) + + /** Its biquad sections at [fs]: [b0, b1, b2, a1, a2] each, normalised by a0. */ + fun sections(fs: Double): List { + if (!active) return emptyList() + val f0 = freq.toDouble().coerceIn(1.0, fs * 0.49) + val q = q.toDouble().coerceIn(0.025, 100.0) + val g = gain.toDouble() + return when (type) { + FilterType.LowPass, FilterType.HighPass -> { + val lp = type == FilterType.LowPass + when { + slope <= 6 -> listOf(firstOrder(fs, f0, lp)) + slope <= 12 -> listOf(Biquad.design(type, fs, f0, 0.0, q)) + else -> { + // Butterworth of order slope/6, as cascaded sections (plus a first-order one when odd). + val n = slope / 6 + (1..n / 2).map { k -> Biquad.design(type, fs, f0, 0.0, 1 / (2 * cos((2 * k - 1) * PI / (2 * n)))) } + + (if (n % 2 == 1) listOf(firstOrder(fs, f0, lp)) else emptyList()) + } + } + } + else -> listOf(Biquad.design(type, fs, f0, g, q)) + } + } + + private fun firstOrder(fs: Double, f0: Double, lowPass: Boolean): DoubleArray { + val k = tan(PI * f0 / fs) + val a1 = (k - 1) / (k + 1) + return if (lowPass) doubleArrayOf(k / (k + 1), k / (k + 1), 0.0, a1, 0.0) + else doubleArrayOf(1 / (k + 1), -1 / (k + 1), 0.0, a1, 0.0) + } + + fun applies(left: Boolean) = channel == EqChannel.Both || (channel == EqChannel.Left) == left + + companion object { + /** The 10-band graphic EQ as peaking filters, ahead of the parametric ones. */ + fun graphic(gains: List) = gains.mapIndexedNotNull { i, g -> + if (abs(g) < 0.01f || i >= EQ_BANDS.size) null else EqFilter("band$i", FilterType.Peak, EQ_BANDS[i], g, EQ_Q) + } + } +} + +/** What the engine needs from an EQ profile; null means bypass. */ +data class EqParams(val filters: List, val preampDb: Float) + +/** A biquad section, transposed direct form II, double state per channel. */ +class Biquad { + private var b0 = 1.0; private var b1 = 0.0; private var b2 = 0.0; private var a1 = 0.0; private var a2 = 0.0 + private var zl1 = 0.0; private var zl2 = 0.0; private var zr1 = 0.0; private var zr2 = 0.0 + + fun set(c: DoubleArray) { + b0 = c[0]; b1 = c[1]; b2 = c[2]; a1 = c[3]; a2 = c[4] + } + + fun reset() { + zl1 = 0.0; zl2 = 0.0; zr1 = 0.0; zr2 = 0.0 + } + + fun process(buf: FloatArray, frames: Int, left: Boolean = true, right: Boolean = true) { + var l1 = zl1; var l2 = zl2; var r1 = zr1; var r2 = zr2 + for (i in 0 until frames) { + if (left) { + val xl = buf[i * 2].toDouble() + val yl = b0 * xl + l1 + l1 = b1 * xl - a1 * yl + l2 + l2 = b2 * xl - a2 * yl + buf[i * 2] = yl.toFloat() + } + if (right) { + val xr = buf[i * 2 + 1].toDouble() + val yr = b0 * xr + r1 + r1 = b1 * xr - a1 * yr + r2 + r2 = b2 * xr - a2 * yr + buf[i * 2 + 1] = yr.toFloat() + } + } + // Flush denormals so a silent tail doesn't cost CPU. + zl1 = if (abs(l1) < 1e-25) 0.0 else l1; zl2 = if (abs(l2) < 1e-25) 0.0 else l2 + zr1 = if (abs(r1) < 1e-25) 0.0 else r1; zr2 = if (abs(r2) < 1e-25) 0.0 else r2 + } + + companion object { + /** RBJ Audio EQ Cookbook coefficients, [b0, b1, b2, a1, a2] normalised by a0. */ + fun design(type: FilterType, fs: Double, f0: Double, gainDb: Double, q: Double): DoubleArray { + val a = 10.0.pow(gainDb / 40.0) + val w0 = 2 * PI * f0.coerceAtMost(fs * 0.49) / fs + val alpha = sin(w0) / (2 * q) + val cw = cos(w0) + val sa = 2 * sqrt(a) * alpha + val c = when (type) { + FilterType.Peak -> doubleArrayOf(1 + alpha * a, -2 * cw, 1 - alpha * a, 1 + alpha / a, -2 * cw, 1 - alpha / a) + FilterType.LowShelf -> doubleArrayOf( + a * ((a + 1) - (a - 1) * cw + sa), 2 * a * ((a - 1) - (a + 1) * cw), a * ((a + 1) - (a - 1) * cw - sa), + (a + 1) + (a - 1) * cw + sa, -2 * ((a - 1) + (a + 1) * cw), (a + 1) + (a - 1) * cw - sa, + ) + FilterType.HighShelf -> doubleArrayOf( + a * ((a + 1) + (a - 1) * cw + sa), -2 * a * ((a - 1) + (a + 1) * cw), a * ((a + 1) + (a - 1) * cw - sa), + (a + 1) - (a - 1) * cw + sa, 2 * ((a - 1) - (a + 1) * cw), (a + 1) - (a - 1) * cw - sa, + ) + FilterType.LowPass -> doubleArrayOf((1 - cw) / 2, 1 - cw, (1 - cw) / 2, 1 + alpha, -2 * cw, 1 - alpha) + FilterType.HighPass -> doubleArrayOf((1 + cw) / 2, -(1 + cw), (1 + cw) / 2, 1 + alpha, -2 * cw, 1 - alpha) + FilterType.BandPass -> doubleArrayOf(alpha, 0.0, -alpha, 1 + alpha, -2 * cw, 1 - alpha) + FilterType.Notch -> doubleArrayOf(1.0, -2 * cw, 1.0, 1 + alpha, -2 * cw, 1 - alpha) + FilterType.AllPass -> doubleArrayOf(1 - alpha, -2 * cw, 1 + alpha, 1 + alpha, -2 * cw, 1 - alpha) + } + val a0 = c[3] + return doubleArrayOf(c[0] / a0, c[1] / a0, c[2] / a0, c[4] / a0, c[5] / a0) + } + + /** |H| in dB at frequency f. */ + fun magnitudeDb(c: DoubleArray, fs: Double, f: Double): Double { + val w = 2 * PI * f / fs + val cw = cos(w); val sw = sin(w); val c2 = cos(2 * w); val s2 = sin(2 * w) + val nr = c[0] + c[1] * cw + c[2] * c2 + val ni = -(c[1] * sw + c[2] * s2) + val dr = 1 + c[3] * cw + c[4] * c2 + val di = -(c[3] * sw + c[4] * s2) + return 10 * log10(max(1e-30, nr * nr + ni * ni) / max(1e-30, dr * dr + di * di)) + } + } +} + +object EqMath { + /** Combined response of [filters] on one channel, in dB at each of [freqs]. */ + fun response(filters: List, freqs: DoubleArray, left: Boolean = true, fs: Double = 48000.0): DoubleArray { + val coeffs = filters.filter { it.applies(left) }.flatMap { it.sections(fs) } + return DoubleArray(freqs.size) { i -> coeffs.sumOf { Biquad.magnitudeDb(it, fs, freqs[i]) } } + } + + fun logFreqs(n: Int, lo: Double = 20.0, hi: Double = 20000.0) = + DoubleArray(n) { lo * (hi / lo).pow(it / (n - 1.0)) } + + /** + * Anti-clipping preamp: the negative of the curve's highest point (manual preamp included, + * louder channel), so a full-scale signal at the loudest frequency still peaks at 0 dBFS. + */ + fun autoPreampDb(filters: List, manualDb: Float = 0f): Float { + val f = logFreqs(512) + val peak = maxOf(response(filters, f, true).maxOrNull() ?: 0.0, response(filters, f, false).maxOrNull() ?: 0.0) + return -max(0.0, peak + manualDb).toFloat() + } +} + +class Equalizer { + private class Stage(val filter: Biquad, val left: Boolean, val right: Boolean) + + private var stages = emptyList() + private var shape = emptyList() + private var fs = 0 + private var params: EqParams? = null + private var preamp = 1f + var enabled = false; private set + + fun configure(p: EqParams?, sampleRate: Int) { + enabled = p != null + if (p == null || (p == params && sampleRate == fs)) return + val rateChanged = sampleRate != fs + fs = sampleRate + params = p + preamp = dbToGain(p.preampDb) + val designed = p.filters.flatMap { f -> f.sections(fs.toDouble()).map { it to f } } + // Coefficient changes (a slider drag) keep the filters' state; a different layout starts fresh. + val newShape = designed.map { (_, f) -> Triple(f.id, f.channel, f.type) } + designed.size + if (rateChanged || newShape != shape) { + stages = designed.map { (_, f) -> Stage(Biquad(), f.channel != EqChannel.Right, f.channel != EqChannel.Left) } + shape = newShape + } + designed.forEachIndexed { i, (c, _) -> stages[i].filter.set(c) } + } + + fun process(buf: FloatArray, frames: Int) { + if (!enabled) return + if (preamp != 1f) for (i in 0 until frames * 2) buf[i] *= preamp + for (s in stages) s.filter.process(buf, frames, s.left, s.right) + } +} + +/** + * Peak limiter on the master bus: stems pushed past unity or an EQ boost never clip. + * Instant attack, ~120 ms release, ceiling just under full scale. + */ +class Limiter(private val ceiling: Float = 0.985f) { + private var gain = 1f + private var release = 0f + + fun setSampleRate(fs: Int) { + release = 1f - exp(-1f / (0.12f * fs)) + } + + fun process(buf: FloatArray, frames: Int) { + var g = gain + for (i in 0 until frames) { + val l = buf[i * 2]; val r = buf[i * 2 + 1] + val peak = max(abs(l), abs(r)) + val need = if (peak * g > ceiling) ceiling / peak else 1f + g = if (need < g) need else g + (1f - g) * release + if (peak * g > ceiling) g = ceiling / peak + buf[i * 2] = l * g + buf[i * 2 + 1] = r * g + } + gain = g + } +} + +fun dbToGain(db: Float) = 10f.pow(db / 20f) +fun gainToDb(g: Float) = if (g <= 1e-6f) -120f else 20f * log10(g) + +/** Master slider taper (same cubic curve as the desktop app). */ +fun masterTaper(v: Float) = v.coerceIn(0f, 1f).let { it * it * it } + +/** Stem slider: 0..1 with unity at 0.8 and +3.9 dB at the top. */ +fun stemTaper(v: Float) = (v.coerceIn(0f, 1f) / 0.8f).let { it * it } +fun stemUntaper(g: Float) = (sqrt(g.coerceAtLeast(0f)) * 0.8f).coerceIn(0f, 1f) diff --git a/android/app/src/main/java/com/stemroller/mobile/engine/StemDecoder.kt b/android/app/src/main/java/com/stemroller/mobile/engine/StemDecoder.kt new file mode 100644 index 0000000..04347e4 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/engine/StemDecoder.kt @@ -0,0 +1,336 @@ +package com.stemroller.mobile.engine + +import android.media.AudioFormat +import android.media.MediaCodec +import android.media.MediaDataSource +import android.media.MediaExtractor +import android.media.MediaFormat +import android.util.Log +import com.stemroller.mobile.cache.MediaCache +import java.io.IOException +import java.nio.ByteOrder +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.locks.ReentrantLock +import kotlin.concurrent.withLock +import kotlin.math.min + +/** Single-producer single-consumer ring of interleaved stereo float frames. */ +class FloatRing(capacityFrames: Int) { + private val buf = FloatArray(capacityFrames * 2) + private val cap = buf.size + private var readPos = 0L + private var writePos = 0L + private val lock = ReentrantLock() + private val notFull = lock.newCondition() + @Volatile var eos = false + + val availableFrames: Int get() = lock.withLock { ((writePos - readPos) / 2).toInt() } + + /** Blocks while full; returns false if [abort] became true first. */ + fun write(src: FloatArray, off: Int, len: Int, abort: () -> Boolean): Boolean { + var done = 0 + while (done < len) { + lock.withLock { + while (writePos - readPos >= cap) { + if (abort()) return false + notFull.await(20, TimeUnit.MILLISECONDS) + } + if (abort()) return false + val free = (cap - (writePos - readPos)).toInt() + val n = min(free, len - done) + var w = (writePos % cap).toInt() + val first = min(n, cap - w) + System.arraycopy(src, off + done, buf, w, first) + if (n > first) System.arraycopy(src, off + done + first, buf, 0, n - first) + writePos += n + done += n + } + } + return true + } + + /** Copies up to [frames] frames into dst; returns frames copied. Never blocks on data. */ + fun read(dst: FloatArray, frames: Int): Int = lock.withLock { + val n = min(frames * 2L, writePos - readPos).toInt() + val r = (readPos % cap).toInt() + val first = min(n, cap - r) + System.arraycopy(buf, r, dst, 0, first) + if (n > first) System.arraycopy(buf, 0, dst, first, n - first) + readPos += n + notFull.signalAll() + n / 2 + } + + fun clear() = lock.withLock { + readPos = writePos + eos = false + notFull.signalAll() + } + + fun wake() = lock.withLock { notFull.signalAll() } +} + +/** MediaExtractor's view of a cached resource. Retries brief network trouble before giving up. */ +class ResourceDataSource( + private val res: MediaCache.CachedResource, + private val onClose: () -> Unit = {}, +) : MediaDataSource() { + @Volatile var failed: IOException? = null + private set + @Volatile var closed = false + private set + private val closing = AtomicBoolean(false) + + override fun readAt(position: Long, buffer: ByteArray, offset: Int, size: Int): Int { + var attempt = 0 + while (true) { + try { + val n = res.readAt(position, buffer, offset, size) + failed = null + if (n > 0 && attempt == 0) res.prefetch() + return n + } catch (e: IOException) { + if (closed || ++attempt > 8) { + failed = e + throw e + } + Thread.sleep(250L * attempt) + } + } + } + + override fun getSize(): Long = try { + res.size() + } catch (e: IOException) { + failed = e + -1 + } + + override fun close() { + closed = true + if (closing.compareAndSet(false, true)) onClose() + } +} + +/** + * Decodes one stem on its own thread into [ring]. Seeks are sample-accurate: frames + * before the target are dropped by presentation time, so every stem of a track resumes + * on exactly the same frame. + */ +class StemDecoder(val name: String, private val source: ResourceDataSource, ringFrames: Int) { + val ring = FloatRing(ringFrames) + private val prepared = CountDownLatch(1) + @Volatile var sampleRate = 0; private set + @Volatile var durationUs = 0L; private set + @Volatile var error: Throwable? = null; private set + /** Generation whose data is in the ring (or that hit EOS). */ + @Volatile var readyGen = -1; private set + + private val seekLock = Object() + private var pendingGen = -1 + private var pendingFrame = 0L + @Volatile private var released = false + private val thread = Thread({ run() }, "stem-$name") + + fun start(gen: Int, frame: Long) { + seek(gen, frame) + thread.priority = Thread.MAX_PRIORITY - 1 + thread.start() + } + + /** Blocks until the stream's format is known. False on error or timeout. */ + fun awaitPrepared(timeoutMs: Long): Boolean = prepared.await(timeoutMs, TimeUnit.MILLISECONDS) && error == null + + fun seek(gen: Int, frame: Long) { + synchronized(seekLock) { + pendingGen = gen + pendingFrame = frame + seekLock.notifyAll() + } + ring.wake() + } + + private fun seekPending(current: Int) = synchronized(seekLock) { pendingGen != current } + + fun release() { + released = true + source.close() + synchronized(seekLock) { seekLock.notifyAll() } + ring.wake() + } + + private fun run() { + var extractor: MediaExtractor? = null + var codec: MediaCodec? = null + try { + extractor = MediaExtractor().apply { setDataSource(source) } + val trackIdx = (0 until extractor.trackCount).firstOrNull { + extractor.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true + } ?: throw IOException("no audio in $name") + extractor.selectTrack(trackIdx) + val fmt = extractor.getTrackFormat(trackIdx) + val mime = fmt.getString(MediaFormat.KEY_MIME)!! + sampleRate = fmt.getInteger(MediaFormat.KEY_SAMPLE_RATE) + var channels = fmt.getInteger(MediaFormat.KEY_CHANNEL_COUNT) + if (fmt.containsKey(MediaFormat.KEY_DURATION)) durationUs = fmt.getLong(MediaFormat.KEY_DURATION) + // The FLAC extractor already decodes to audio/raw, whose pass-through "decoder" + // echoes whatever encoding it's told without converting, so keep the extractor's. + var encoding = AudioFormat.ENCODING_PCM_16BIT + if (mime == MediaFormat.MIMETYPE_AUDIO_RAW) { + if (fmt.containsKey(MediaFormat.KEY_PCM_ENCODING)) encoding = fmt.getInteger(MediaFormat.KEY_PCM_ENCODING) + } else { + fmt.setInteger(MediaFormat.KEY_PCM_ENCODING, AudioFormat.ENCODING_PCM_FLOAT) + } + codec = MediaCodec.createDecoderByType(mime) + codec.configure(fmt, null, null, 0) + codec.start() + codec.outputFormat.let { of -> + if (of.containsKey(MediaFormat.KEY_PCM_ENCODING)) encoding = of.getInteger(MediaFormat.KEY_PCM_ENCODING) + if (of.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) channels = of.getInteger(MediaFormat.KEY_CHANNEL_COUNT) + } + prepared.countDown() + + val info = MediaCodec.BufferInfo() + var scratch = FloatArray(8192) + var gen = -1 + var inputDone = false + var outputDone = false + var firstOut = true + var nextFrame = 0L + var dropUntil = 0L + var lastInputUs = 0L + + while (!released) { + synchronized(seekLock) { + if (pendingGen != gen) { + gen = pendingGen + dropUntil = pendingFrame + ring.clear() + extractor.seekTo(pendingFrame * 1_000_000L / sampleRate, MediaExtractor.SEEK_TO_PREVIOUS_SYNC) + codec.flush() + inputDone = false + outputDone = false + firstOut = true + } else if (outputDone) { + ring.eos = true + readyGen = gen + seekLock.wait(100) + } + } + if (outputDone || released) continue + + if (!inputDone) { + val inIdx = codec.dequeueInputBuffer(2_000) + if (inIdx >= 0) { + val ib = codec.getInputBuffer(inIdx)!! + val n = extractor.readSampleData(ib, 0) + if (n < 0) { + source.failed?.let { if (durationUs > 0 && lastInputUs < durationUs - 2_000_000) throw it } + codec.queueInputBuffer(inIdx, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM) + inputDone = true + } else { + lastInputUs = extractor.sampleTime + codec.queueInputBuffer(inIdx, 0, n, extractor.sampleTime, 0) + extractor.advance() + } + } + } + + val outIdx = codec.dequeueOutputBuffer(info, 2_000) + if (outIdx == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) { + val of = codec.outputFormat + if (of.containsKey(MediaFormat.KEY_PCM_ENCODING)) encoding = of.getInteger(MediaFormat.KEY_PCM_ENCODING) + if (of.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) channels = of.getInteger(MediaFormat.KEY_CHANNEL_COUNT) + if (of.containsKey(MediaFormat.KEY_SAMPLE_RATE)) sampleRate = of.getInteger(MediaFormat.KEY_SAMPLE_RATE) + continue + } + if (outIdx < 0) continue + if (info.size > 0) { + val ob = codec.getOutputBuffer(outIdx)!!.order(ByteOrder.nativeOrder()) + ob.position(info.offset) + ob.limit(info.offset + info.size) + val bytesPer = when (encoding) { + AudioFormat.ENCODING_PCM_FLOAT, AudioFormat.ENCODING_PCM_32BIT -> 4 + AudioFormat.ENCODING_PCM_24BIT_PACKED -> 3 + else -> 2 + } + val frames = info.size / (bytesPer * channels) + if (scratch.size < frames * 2) scratch = FloatArray(frames * 2) + toStereo(ob, encoding, channels, frames, scratch) + val start = if (firstOut) info.presentationTimeUs * sampleRate / 1_000_000L else nextFrame + firstOut = false + nextFrame = start + frames + val skip = (dropUntil - start).coerceIn(0, frames.toLong()).toInt() + if (frames > skip) { + val myGen = gen + if (ring.write(scratch, skip * 2, (frames - skip) * 2) { released || seekPending(myGen) }) { + readyGen = gen + } + } + } + codec.releaseOutputBuffer(outIdx, false) + if (info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) outputDone = true + } + } catch (t: Throwable) { + if (!released) { + Log.w("StemDecoder", "$name failed", t) + error = t + } + ring.eos = true + readyGen = Int.MAX_VALUE + } finally { + prepared.countDown() + runCatching { codec?.stop() } + runCatching { codec?.release() } + runCatching { extractor?.release() } + } + } + + private fun toStereo(ob: java.nio.ByteBuffer, encoding: Int, channels: Int, frames: Int, out: FloatArray) { + when (encoding) { + AudioFormat.ENCODING_PCM_FLOAT -> { + val fb = ob.asFloatBuffer() + if (channels == 2) { + fb.get(out, 0, frames * 2) + } else { + for (i in 0 until frames) { + val l = fb.get(i * channels) + out[i * 2] = l + out[i * 2 + 1] = if (channels > 1) fb.get(i * channels + 1) else l + } + } + } + AudioFormat.ENCODING_PCM_32BIT -> { + val ib = ob.asIntBuffer() + for (i in 0 until frames) { + val l = ib.get(i * channels) / 2147483648f + out[i * 2] = l + out[i * 2 + 1] = if (channels > 1) ib.get(i * channels + 1) / 2147483648f else l + } + } + AudioFormat.ENCODING_PCM_24BIT_PACKED -> { + val base = ob.position() + fun s24(idx: Int): Float { + val p = base + idx * 3 + val v = (ob.get(p).toInt() and 0xFF) or ((ob.get(p + 1).toInt() and 0xFF) shl 8) or (ob.get(p + 2).toInt() shl 16) + return v / 8388608f + } + for (i in 0 until frames) { + val l = s24(i * channels) + out[i * 2] = l + out[i * 2 + 1] = if (channels > 1) s24(i * channels + 1) else l + } + } + else -> { + val sb = ob.asShortBuffer() + for (i in 0 until frames) { + val l = sb.get(i * channels) / 32768f + out[i * 2] = l + out[i * 2 + 1] = if (channels > 1) sb.get(i * channels + 1) / 32768f else l + } + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/engine/StemEngine.kt b/android/app/src/main/java/com/stemroller/mobile/engine/StemEngine.kt new file mode 100644 index 0000000..1aa372c --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/engine/StemEngine.kt @@ -0,0 +1,519 @@ +package com.stemroller.mobile.engine + +import android.media.AudioAttributes +import android.media.AudioDeviceInfo +import android.media.AudioFormat +import android.media.AudioRouting +import android.media.AudioTimestamp +import android.media.AudioTrack +import android.os.Handler +import android.os.Looper +import android.os.Process +import kotlin.math.max +import kotlin.math.min +import kotlin.math.sqrt + +/** One track's stems, decoding in sync. Built off the main thread, then handed to the engine. */ +class TrackSession(val token: Long, val names: List, val decoders: List) { + val sampleRate get() = decoders.first().sampleRate + val durationFrames get() = decoders.maxOf { it.durationUs } * sampleRate / 1_000_000L + internal var gen = 0 + internal var framePos = 0L + internal val target = FloatArray(names.size) { 1f } + internal val current = FloatArray(names.size) { 1f } + internal var mixVersion = -1 + + fun error(): Throwable? = decoders.firstNotNullOfOrNull { it.error } + + internal fun ready(need: Int) = decoders.all { d -> + d.error != null || (d.readyGen == gen || d.readyGen == Int.MAX_VALUE) && (d.ring.eos || d.ring.availableFrames >= need) + } + + internal fun finished() = decoders.all { d -> + d.error != null || (d.readyGen == gen || d.readyGen == Int.MAX_VALUE) && d.ring.eos && d.ring.availableFrames == 0 + } + + /** Re-targets decoders; only valid before the session is handed to the engine. */ + fun startAt(frame: Long) { + gen++ + framePos = frame + decoders.forEach { it.seek(gen, frame) } + } + + fun release() = decoders.forEach { it.release() } +} + +/** + * Per-stem RMS of short blocks as they're mixed, stamped with their track frame, so meters can + * show what's coming out of the speaker now. Reading the newest level instead runs ahead of the + * audio, and moves in jerks: Android's mixer drains our buffer in bursts (about 5 a second on + * deep-buffer outputs), so writes, and with them fresh levels, arrive in clumps. + */ +class MeterHistory { + private val tokens = LongArray(CAP) + private val starts = LongArray(CAP) + private val values = FloatArray(CAP * MAX_STEMS) + private var head = 0 + private var count = 0 + + @Synchronized fun clear() { + count = 0 + } + + @Synchronized fun add(token: Long, start: Long, rms: FloatArray, offset: Int, stems: Int) { + tokens[head] = token + starts[head] = start + System.arraycopy(rms, offset, values, head * MAX_STEMS, min(stems, MAX_STEMS)) + if (stems < MAX_STEMS) java.util.Arrays.fill(values, head * MAX_STEMS + stems, (head + 1) * MAX_STEMS, 0f) + head = (head + 1) % CAP + count = min(count + 1, CAP) + } + + /** Fills [out] with the levels of [token]'s block playing at [frame]; false if there's none. */ + @Synchronized fun read(token: Long, frame: Long, out: FloatArray): Boolean { + for (k in 1..count) { + val i = (head - k + CAP) % CAP + if (tokens[i] != token || starts[i] > frame) continue + if (frame - starts[i] > STALE_FRAMES) return false + System.arraycopy(values, i * MAX_STEMS, out, 0, min(out.size, MAX_STEMS)) + return true + } + return false + } + + companion object { + const val BLOCK = 256 + const val MAX_STEMS = 8 + /** ~5 s at 48 kHz: well past the AudioTrack's buffer. */ + private const val CAP = 1024 + private const val STALE_FRAMES = 8192L + } +} + +/** + * Mixes a [TrackSession]'s stems into one AudioTrack: per-stem gain (ramped), EQ with + * anti-clip preamp, master gain, then a peak limiter. All AudioTrack calls happen on the + * engine thread; the public methods just queue commands. + */ +class StemEngine(private val listener: Listener) { + interface Listener { + fun onEngineState() + /** [token]'s audio is now what's coming out of the speaker. */ + fun onTransition(token: Long) + fun onEnded(token: Long) + fun onError(token: Long, message: String) + fun onRouted(device: AudioDeviceInfo?) + } + + /** Where playback is; position = frame + (now - nanos) while [running]. */ + data class Snapshot(val token: Long, val frame: Long, val rate: Int, val nanos: Long, val running: Boolean) { + fun positionMs(now: Long = System.nanoTime()): Long { + if (rate <= 0) return 0 + val f = if (running) frame + (now - nanos) * rate / 1_000_000_000L else frame + return f * 1000 / rate + } + } + + private class Segment(val writtenStart: Long, val token: Long, val frameStart: Long) + + private val main = Handler(Looper.getMainLooper()) + private val lock = Object() + private val commands = ArrayDeque<() -> Unit>() + @Volatile private var released = false + + private var session: TrackSession? = null + private var next: TrackSession? = null + private var wantPlay = false + private var track: AudioTrack? = null + private var trackRate = 0 + private var written = 0L + private val segments = ArrayDeque() + private var drainUntil = -1L + private var drainDeadline = 0L + private var drainToken = -1L + private var waitingSince = 0L + private var errorReported = -1L + private val eq = Equalizer() + private val limiter = Limiter() + private var masterCur = 1f + private val ts = AudioTimestamp() + private var tsValid = false + private var tsQueried = 0L + private var tsFrame = 0L + private var tsNanos = 0L + private var out = FloatArray(CHUNK * 2) + private var tmp = FloatArray(CHUNK * 2) + + @Volatile var eqParams: EqParams? = null + @Volatile var masterGain = 1f + @Volatile private var mix: Map = emptyMap() + @Volatile private var mixVersion = 0 + + @Volatile var snapshot = Snapshot(-1, 0, 44100, 0, false); private set + @Volatile var playing = false; private set + @Volatile var buffering = false; private set + /** Post-gain RMS per stem in short blocks, for the mixer's meters; see [levelsNow]. */ + private val meters = MeterHistory() + private var meterSums = FloatArray(CHUNK / MeterHistory.BLOCK * MeterHistory.MAX_STEMS) + + private val routing = AudioRouting.OnRoutingChangedListener { r -> listener.onRouted(r.routedDevice) } + private val thread = Thread({ loop() }, "stem-engine").apply { start() } + + // ---- commands (any thread) -------------------------------------------------------- + + private fun post(cmd: () -> Unit) = synchronized(lock) { + commands.addLast(cmd) + lock.notifyAll() + } + + /** Replaces whatever is playing with [s], which must already be prepared. */ + fun load(s: TrackSession, play: Boolean) = post { + dropAll() + session = s + wantPlay = play + resetOutput(s) + publish() + } + + /** The track to continue into gaplessly when the current one ends (or null). */ + fun queueNext(s: TrackSession?) = post { + if (next !== s) next?.release() + next = s + } + + fun setPlaying(play: Boolean) = post { + wantPlay = play + if (!play) track?.pause() + publish() + } + + fun seekTo(ms: Long) = post { + val s = session ?: return@post + val frame = (ms * s.sampleRate / 1000).coerceIn(0, max(0, s.durationFrames - 1)) + s.gen++ + s.framePos = frame + s.decoders.forEach { it.seek(s.gen, frame) } + resetOutput(s) + publish() + } + + fun stop() = post { + dropAll() + wantPlay = false + publish() + } + + fun setMix(gains: Map) { + mix = gains + mixVersion++ + } + + fun release() { + released = true + post { } + } + + /** + * The meters' levels for what's audible right now, into [out] (one per stem). False when + * nothing is playing, so the meters can fall. + */ + fun levelsNow(out: FloatArray): Boolean { + val snap = snapshot + if (!snap.running || snap.rate <= 0) return false + val frame = snap.frame + (System.nanoTime() - snap.nanos) * snap.rate / 1_000_000_000L + return meters.read(snap.token, frame, out) + } + + // ---- engine thread ---------------------------------------------------------------- + + private fun dropAll() { + session?.release() + next?.release() + session = null + next = null + drainUntil = -1 + track?.let { it.pause(); it.flush() } + written = 0 + segments.clear() + } + + private fun resetOutput(s: TrackSession) { + track?.let { it.pause(); it.flush() } + tsValid = false + written = 0 + segments.clear() + segments.addLast(Segment(0, s.token, s.framePos)) + drainUntil = -1 + waitingSince = 0 + meters.clear() + errorReported = -1 + } + + private fun loop() { + Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO) + while (!released) { + while (true) { + val cmd = synchronized(lock) { commands.removeFirstOrNull() } ?: break + cmd() + } + try { + step() + } catch (t: Throwable) { + val tok = session?.token ?: -1 + dropAll() + wantPlay = false + publish() + main.post { listener.onError(tok, t.message ?: t.javaClass.simpleName) } + } + } + dropAll() + track?.release() + } + + private fun idle(ms: Long) = synchronized(lock) { if (commands.isEmpty()) lock.wait(ms) } + + private fun step() { + val s = session + if (s == null || !wantPlay) { + setFlags(false, false) + publish() + idle(100) + return + } + s.error()?.let { e -> + if (errorReported != s.token) { + errorReported = s.token + wantPlay = false + track?.pause() + setFlags(false, false) + main.post { listener.onError(s.token, e.message ?: "Playback failed") } + } + idle(50) + return + } + if (drainUntil >= 0) { + drain(s) + return + } + val need = if (written == 0L || buffering) PREFILL else CHUNK + if (!s.ready(need) && !s.finished()) { + val now = System.nanoTime() + if (waitingSince == 0L) waitingSince = now + if (!buffering && (written == 0L || now - waitingSince > 60_000_000L)) { + track?.pause() + setFlags(playing = false, buffering = true) + } + publish() + idle(5) + return + } + waitingSince = 0 + ensureTrack(s.sampleRate) + val t = track!! + if (t.playState != AudioTrack.PLAYSTATE_PLAYING) t.play() + setFlags(playing = true, buffering = false) + + val n = mixChunk(s) + if (n == 0) { + if (s.finished()) endOfTrack(s) else idle(2) + return + } + eq.configure(eqParams, s.sampleRate) + eq.process(out, n) + val m = masterGain + rampGain(out, n, masterCur, m) + masterCur = m + limiter.process(out, n) + var off = 0 + while (off < n * 2 && !released) { + val w = t.write(out, off, n * 2 - off, AudioTrack.WRITE_BLOCKING) + if (w < 0) throw IllegalStateException("AudioTrack write failed ($w)") + off += w + } + written += n + publish() + } + + private fun endOfTrack(s: TrackSession) { + val nx = next + if (nx != null && nx.sampleRate == s.sampleRate && nx.error() == null) { + // Gapless: keep writing into the same AudioTrack. + segments.addLast(Segment(written, nx.token, nx.framePos)) + session = nx + next = null + s.release() + return + } + // Let the AudioTrack play out, then hand over. + drainUntil = written + drainToken = s.token + drainDeadline = System.nanoTime() + (written * 1_000_000_000L / max(1, trackRate)) + 1_000_000_000L + } + + private fun drain(s: TrackSession) { + val (presented, _) = presented() + publish() + if (presented < drainUntil - 64 && System.nanoTime() < drainDeadline) { + idle(10) + return + } + drainUntil = -1 + val nx = next + if (nx != null && nx.error() == null) { + session = nx + next = null + s.release() + resetOutput(nx) + main.post { listener.onTransition(nx.token) } + } else { + val tok = drainToken + dropAll() + wantPlay = false + setFlags(false, false) + publish() + main.post { listener.onEnded(tok) } + } + } + + private fun mixChunk(s: TrackSession): Int { + if (s.finished()) return 0 + var n = CHUNK + for (d in s.decoders) { + if (d.error != null || d.ring.eos && d.ring.availableFrames == 0) continue + n = min(n, d.ring.availableFrames) + } + if (n <= 0) return 0 + if (s.mixVersion != mixVersion) { + val g = mix + for (i in s.names.indices) s.target[i] = g[s.names[i]] ?: 1f + s.mixVersion = mixVersion + } + java.util.Arrays.fill(out, 0, n * 2, 0f) + val stride = MeterHistory.MAX_STEMS + val blocks = (n + MeterHistory.BLOCK - 1) / MeterHistory.BLOCK + if (meterSums.size < blocks * stride) meterSums = FloatArray(blocks * stride) + java.util.Arrays.fill(meterSums, 0f) + for ((i, d) in s.decoders.withIndex()) { + val got = d.ring.read(tmp, n) + if (got < n) java.util.Arrays.fill(tmp, got * 2, n * 2, 0f) + val g0 = s.current[i] + val g1 = s.target[i] + s.current[i] = g1 + if (g0 == 0f && g1 == 0f) continue + val step = (g1 - g0) / n + var g = g0 + for (b in 0 until blocks) { + val end = min(n, (b + 1) * MeterHistory.BLOCK) + var sum = 0f + for (f in b * MeterHistory.BLOCK until end) { + val l = tmp[f * 2] * g + val r = tmp[f * 2 + 1] * g + out[f * 2] += l + out[f * 2 + 1] += r + sum += l * l + r * r + g += step + } + if (i < stride) meterSums[b * stride + i] = sqrt(sum / (2 * (end - b * MeterHistory.BLOCK))) + } + } + for (b in 0 until blocks) meters.add(s.token, s.framePos + b * MeterHistory.BLOCK, meterSums, b * stride, s.names.size) + s.framePos += n + return n + } + + private fun rampGain(buf: FloatArray, n: Int, from: Float, to: Float) { + if (from == 1f && to == 1f) return + val step = (to - from) / n + var g = from + for (f in 0 until n) { + buf[f * 2] *= g + buf[f * 2 + 1] *= g + g += step + } + } + + private fun ensureTrack(rate: Int) { + if (track != null && trackRate == rate) return + track?.let { + it.removeOnRoutingChangedListener(routing) + it.release() + } + val minBuf = AudioTrack.getMinBufferSize(rate, AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_FLOAT) + val bytes = max(minBuf * 2, rate * 8 * BUFFER_MS / 1000) + val t = AudioTrack.Builder() + .setAudioAttributes( + AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA) + .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC).build(), + ) + .setAudioFormat( + AudioFormat.Builder().setEncoding(AudioFormat.ENCODING_PCM_FLOAT).setSampleRate(rate) + .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO).build(), + ) + .setTransferMode(AudioTrack.MODE_STREAM) + .setBufferSizeInBytes(bytes) + .build() + t.addOnRoutingChangedListener(routing, main) + track = t + trackRate = rate + limiter.setSampleRate(rate) + val routed = t.routedDevice + main.post { listener.onRouted(routed) } + } + + /** + * (frames presented since the last flush, at nanoTime). Timestamps are polled every + * half second, as AudioTrack recommends, and extrapolated in between. + */ + private fun presented(): Pair { + val now = System.nanoTime() + val t = track ?: return 0L to now + if (t.playState != AudioTrack.PLAYSTATE_PLAYING) { + tsValid = false + } else { + if (!tsValid || now - tsQueried > 500_000_000L) { + tsQueried = now + tsValid = t.getTimestamp(ts) && ts.framePosition in 0..written + if (tsValid) { + tsFrame = ts.framePosition + tsNanos = ts.nanoTime + } + } + if (tsValid) return min(tsFrame + (now - tsNanos) * trackRate / 1_000_000_000L, written) to now + } + return min(t.playbackHeadPosition.toLong() and 0xFFFFFFFFL, written) to now + } + + private fun publish() { + val (p, nanos) = presented() + while (segments.size > 1 && segments[1].writtenStart <= p) { + segments.removeFirst() + val tok = segments.first().token + main.post { listener.onTransition(tok) } + } + val seg = segments.firstOrNull() + val s = session + val rate = if (s != null && s.decoders.isNotEmpty()) s.sampleRate else trackRate + snapshot = if (seg == null) { + Snapshot(s?.token ?: -1, s?.framePos ?: 0, rate, nanos, false) + } else { + val running = playing && drainUntil < 0 || drainUntil >= 0 && p < drainUntil + Snapshot(seg.token, seg.frameStart + max(0, p - seg.writtenStart), rate, nanos, running) + } + } + + private fun setFlags(playing: Boolean, buffering: Boolean) { + if (playing == this.playing && buffering == this.buffering) return + this.playing = playing + this.buffering = buffering + main.post { listener.onEngineState() } + } + + companion object { + const val CHUNK = 1024 + /** Per stem, decoded ahead of the mixer. */ + const val RING_SECONDS = 3 + /** Frames each stem must have before (re)starting output. */ + const val PREFILL = 8192 + const val BUFFER_MS = 120 + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/eq/ApoConfig.kt b/android/app/src/main/java/com/stemroller/mobile/eq/ApoConfig.kt new file mode 100644 index 0000000..ac64d22 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/eq/ApoConfig.kt @@ -0,0 +1,138 @@ +package com.stemroller.mobile.eq + +import com.stemroller.mobile.engine.EQ_Q +import com.stemroller.mobile.engine.EqChannel +import com.stemroller.mobile.engine.EqFilter +import com.stemroller.mobile.engine.FilterType +import java.util.Locale +import kotlin.math.pow +import kotlin.math.sqrt + +/** + * Equalizer APO's config text, the format AutoEQ publishes headphone corrections in + * (ParametricEQ.txt): + * + * Preamp: -6.2 dB + * Filter 1: ON LSC Fc 105 Hz Gain 6.0 dB Q 0.70 + * Filter 2: ON PK Fc 2300 Hz Gain -3.1 dB Q 1.41 + * + * Also understood: "Channel: L" / "R" / "all" lines, BW Oct instead of Q, and the older + * type names (LS, HS, LP, HP, PEQ ...). Other commands (GraphicEQ, Delay, Copy) are skipped. + */ +object ApoConfig { + class Result(val filters: List, val preamp: Float?, val skipped: Int) + + private val TYPES = mapOf( + "PK" to FilterType.Peak, "PEQ" to FilterType.Peak, "MODAL" to FilterType.Peak, + "LS" to FilterType.LowShelf, "LSC" to FilterType.LowShelf, "LSQ" to FilterType.LowShelf, + "HS" to FilterType.HighShelf, "HSC" to FilterType.HighShelf, "HSQ" to FilterType.HighShelf, + "LP" to FilterType.LowPass, "LPQ" to FilterType.LowPass, + "HP" to FilterType.HighPass, "HPQ" to FilterType.HighPass, + "BP" to FilterType.BandPass, "NO" to FilterType.Notch, "AP" to FilterType.AllPass, + ) + + /** Null when the text has no preamp or filter lines at all. */ + fun parse(text: String): Result? { + val filters = ArrayList() + var preamp: Float? = null + var channel = EqChannel.Both + var skipped = 0 + for (raw in text.lines()) { + val line = raw.substringBefore('#').trim() + if (line.isEmpty()) continue + val colon = line.indexOf(':') + if (colon < 0) continue + val cmd = line.substring(0, colon).trim().lowercase(Locale.ROOT) + val args = line.substring(colon + 1).trim().split(Regex("\\s+")).filter { it.isNotEmpty() } + when { + cmd == "preamp" -> preamp = (preamp ?: 0f) + (args.firstOrNull()?.toFloatOrNull() ?: continue) + cmd == "channel" -> channel = when (args.map { it.uppercase(Locale.ROOT) }.toSet()) { + setOf("L") -> EqChannel.Left + setOf("R") -> EqChannel.Right + else -> EqChannel.Both + } + cmd.startsWith("filter") -> { + val f = parseFilter(args, channel) + if (f != null) filters += f else skipped++ + } + else -> skipped++ + } + } + if (filters.isEmpty() && preamp == null) return null + return Result(filters, preamp, skipped) + } + + private fun parseFilter(args: List, channel: EqChannel): EqFilter? { + var i = 0 + var on = true + when (args.getOrNull(0)?.uppercase(Locale.ROOT)) { + "ON" -> i++ + "OFF" -> { on = false; i++ } + } + val type = TYPES[args.getOrNull(i)?.uppercase(Locale.ROOT)] ?: return null + i++ + var freq: Float? = null + var gain = 0f + var q: Float? = null + var slope = 12 + while (i < args.size) { + val key = args[i].lowercase(Locale.ROOT) + val num = args.getOrNull(i + 1)?.toFloatOrNull() + when { + key == "fc" && num != null -> { freq = num; i += 2 } + key == "gain" && num != null -> { gain = num; i += 2 } + key == "q" && num != null -> { q = num; i += 2 } + key == "bw" && args.getOrNull(i + 1)?.lowercase(Locale.ROOT) == "oct" -> { + args.getOrNull(i + 2)?.toFloatOrNull()?.let { bw -> q = (sqrt(2.0.pow(bw.toDouble())) / (2.0.pow(bw.toDouble()) - 1)).toFloat() } + i += 3 + } + // "LSC 12dB Fc ...": a shelf or pass slope in dB per octave. + key.endsWith("db") && key.removeSuffix("db").toFloatOrNull() != null -> { + slope = key.removeSuffix("db").toFloat().toInt(); i++ + } + else -> i++ + } + } + val fc = freq ?: return null + val defaultQ = when (type) { + FilterType.Peak -> EQ_Q + else -> 0.707f + } + return EqFilter( + EqController.newFilterId(), type, fc, if (type.hasGain) gain else 0f, q ?: defaultQ, + slope = if (type.hasSlope) slope.coerceIn(6, 48) else 12, channel = channel, on = on, + ) + } + + /** The profile as an Equalizer APO config: preamp, graphic bands as peaks, then the filters. */ + fun format(p: EqProfile): String = buildString { + fun n(v: Float) = String.format(Locale.ROOT, "%.2f", v).trimEnd('0').trimEnd('.') + appendLine("# ${p.name}, from StemRoller") + appendLine("Preamp: ${n(p.preamp)} dB") + var channel = EqChannel.Both + var k = 1 + for (f in EqFilter.graphic(p.gains) + p.filters) { + if (f.channel != channel) { + channel = f.channel + appendLine("Channel: " + when (channel) { EqChannel.Left -> "L"; EqChannel.Right -> "R"; EqChannel.Both -> "all" }) + } + val head = "${if (f.on) "ON" else "OFF"} ${f.type.apo} Fc ${n(f.freq)} Hz" + when { + f.type.hasGain -> appendLine("Filter ${k++}: $head Gain ${n(f.gain)} dB Q ${n(f.q)}") + !f.type.hasSlope || f.slope == 12 -> appendLine("Filter ${k++}: $head Q ${n(f.q)}") + f.slope < 12 -> { + appendLine("# 6 dB/oct ${f.type.label.lowercase(Locale.ROOT)}: APO has no first-order filter, so this is a gentle 12 dB/oct one") + appendLine("Filter ${k++}: $head Q 0.5") + } + else -> { + // Steeper slopes are Butterworth: one APO filter per second-order section. + val order = f.slope / 6 + for (j in 1..order / 2) { + val q = (1 / (2 * kotlin.math.cos((2 * j - 1) * Math.PI / (2 * order)))).toFloat() + appendLine("Filter ${k++}: $head Q ${n(q)}") + } + } + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/eq/EqController.kt b/android/app/src/main/java/com/stemroller/mobile/eq/EqController.kt new file mode 100644 index 0000000..bed24fa --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/eq/EqController.kt @@ -0,0 +1,291 @@ +package com.stemroller.mobile.eq + +import android.content.Context +import android.media.AudioAttributes +import android.media.AudioDeviceCallback +import android.media.AudioDeviceInfo +import android.media.AudioManager +import android.os.Handler +import android.os.Looper +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.engine.EQ_BANDS +import com.stemroller.mobile.engine.EQ_MAX_DB +import com.stemroller.mobile.engine.EqFilter +import com.stemroller.mobile.engine.EqMath +import com.stemroller.mobile.engine.EqParams +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.serialization.Serializable +import java.io.File +import java.util.UUID + +enum class DeviceKind { Speaker, Wired, Bluetooth, Usb, Hdmi, Other } + +/** An output route, identified by type + product name (BT addresses are anonymised). */ +@Serializable +data class OutputDevice(val type: Int, val name: String) { + val id get() = "$type|$name" + val kind get() = kindOf(type) + val label: String + get() = when (kind) { + DeviceKind.Speaker -> "Phone Speaker" + DeviceKind.Wired -> if (name.isBlank() || name == "USB-C to 3.5mm") "Wired Headphones" else name + else -> name.ifBlank { kind.name } + } + + companion object { + val SPEAKER = OutputDevice(AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, "") + + fun of(info: AudioDeviceInfo): OutputDevice { + val kind = kindOf(info.type) + // The built-in speaker's product name is the phone model; one speaker profile is enough. + val name = if (kind == DeviceKind.Speaker) "" else info.productName?.toString().orEmpty() + val type = if (kind == DeviceKind.Speaker) AudioDeviceInfo.TYPE_BUILTIN_SPEAKER else info.type + return OutputDevice(type, name) + } + + fun kindOf(type: Int) = when (type) { + AudioDeviceInfo.TYPE_BUILTIN_SPEAKER, AudioDeviceInfo.TYPE_BUILTIN_EARPIECE, + AudioDeviceInfo.TYPE_BUILTIN_SPEAKER_SAFE -> DeviceKind.Speaker + AudioDeviceInfo.TYPE_WIRED_HEADPHONES, AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_LINE_ANALOG -> DeviceKind.Wired + AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLE_HEADSET, + AudioDeviceInfo.TYPE_BLE_SPEAKER, AudioDeviceInfo.TYPE_BLE_BROADCAST, AudioDeviceInfo.TYPE_HEARING_AID -> DeviceKind.Bluetooth + AudioDeviceInfo.TYPE_USB_DEVICE, AudioDeviceInfo.TYPE_USB_HEADSET, AudioDeviceInfo.TYPE_USB_ACCESSORY, + AudioDeviceInfo.TYPE_DOCK, AudioDeviceInfo.TYPE_DOCK_ANALOG -> DeviceKind.Usb + AudioDeviceInfo.TYPE_HDMI, AudioDeviceInfo.TYPE_HDMI_ARC, AudioDeviceInfo.TYPE_HDMI_EARC -> DeviceKind.Hdmi + else -> DeviceKind.Other + } + } +} + +@Serializable +data class EqProfile( + val id: String, + val name: String, + val gains: List = List(EQ_BANDS.size) { 0f }, + val devices: List = emptyList(), + /** Parametric filters, after the graphic bands. */ + val filters: List = emptyList(), + /** Manual preamp in dB, ahead of the anti-clip one (Equalizer APO's "Preamp:"). */ + val preamp: Float = 0f, +) { + /** Everything the engine runs: graphic bands as peaks, then the filters that are on. */ + val chain get() = EqFilter.graphic(gains) + filters.filter { it.active } +} + +@Serializable +data class EqState( + val enabled: Boolean = true, + val automatic: Boolean = true, + /** Picked by hand; wins over automatic switching until cleared. */ + val manualId: String? = null, + val defaultId: String = "flat", + val antiClip: Boolean = true, + val profiles: List = listOf(EqProfile("flat", "Flat")), + val seenDevices: List = emptyList(), +) + +/** iOS Music's EQ list, approximated on ten octave bands. */ +val EQ_PRESETS: List>> = listOf( + "Flat" to listOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f), + "Acoustic" to listOf(4.5f, 4.5f, 3.5f, 1f, 1.5f, 1.5f, 3f, 3.5f, 3f, 2f), + "Bass Booster" to listOf(5.5f, 4.5f, 3.5f, 2.5f, 1.5f, 0f, 0f, 0f, 0f, 0f), + "Bass Reducer" to listOf(-5.5f, -4.5f, -3.5f, -2.5f, -1.5f, 0f, 0f, 0f, 0f, 0f), + "Classical" to listOf(4.5f, 3.5f, 3f, 2.5f, -1.5f, -1.5f, 0f, 2f, 3f, 3.5f), + "Dance" to listOf(3.5f, 6.5f, 5f, 0f, 2f, 3.5f, 5f, 4.5f, 3.5f, 0f), + "Deep" to listOf(5f, 3.5f, 1.5f, 1f, 3f, 2.5f, 1.5f, -2f, -3.5f, -4.5f), + "Electronic" to listOf(4f, 3.5f, 1f, 0f, -2f, 2f, 1f, 1.5f, 4f, 5f), + "Hip-Hop" to listOf(5f, 4f, 1.5f, 3f, -1f, -1f, 1.5f, -0.5f, 2f, 3f), + "Jazz" to listOf(4f, 3f, 1.5f, 2f, -1.5f, -1.5f, 0f, 1.5f, 3f, 3.5f), + "Late Night" to listOf(4.5f, 3f, 2f, -0.5f, 1.5f, 1.5f, 2f, 3f, 3.5f, 4f), + "Loudness" to listOf(6f, 4f, 0f, 0f, -2f, 0f, -1f, -5f, 5f, 1f), + "Piano" to listOf(3f, 2f, 0f, 2.5f, 3f, 1.5f, 3.5f, 4.5f, 3f, 3.5f), + "Pop" to listOf(-1.5f, -1f, 0f, 2f, 4f, 4f, 2f, 0f, -1f, -1.5f), + "R&B" to listOf(2.5f, 7f, 5.5f, 1.5f, -2.5f, -1.5f, 2f, 2.5f, 3f, 3.5f), + "Rock" to listOf(5f, 4f, 3f, 1.5f, -0.5f, -1f, 0.5f, 2.5f, 3.5f, 4.5f), + "Small Speakers" to listOf(5.5f, 4.5f, 3.5f, 2.5f, 1.5f, 0f, -1.5f, -2.5f, -3.5f, -4f), + "Spoken Word" to listOf(-3.5f, -0.5f, 0f, 0.5f, 3.5f, 4.5f, 4.5f, 4f, 2f, 0f), + "Treble Booster" to listOf(0f, 0f, 0f, 0f, 0f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f), + "Treble Reducer" to listOf(0f, 0f, 0f, 0f, 0f, -1.5f, -2.5f, -3.5f, -4.5f, -5.5f), + "Vocal Booster" to listOf(-1.5f, -3f, -3f, 1.5f, 3.5f, 3.5f, 3f, 1.5f, 0f, -1.5f), +) + +/** + * EQ profiles and the current output route. In automatic mode the active profile is the + * one linked to the route (else the default); a hand-picked profile overrides that until + * the user goes back to automatic. + */ +class EqController(context: Context) { + private val file = File(context.filesDir, "eq.json") + private val am = context.getSystemService(AudioManager::class.java) + private val main = Handler(Looper.getMainLooper()) + + private val saveTask = Runnable { + runCatching { + val tmp = File(file.parentFile, "eq.json.tmp") + tmp.writeText(AppJson.encodeToString(EqState.serializer(), state.value)) + tmp.renameTo(file) + } + } + + + private val _state = MutableStateFlow(load()) + val state: StateFlow = _state.asStateFlow() + private val _device = MutableStateFlow(OutputDevice.SPEAKER) + val device: StateFlow = _device.asStateFlow() + private val _active = MutableStateFlow(resolve(_state.value, _device.value)) + val active: StateFlow = _active.asStateFlow() + + var onParams: ((EqParams?) -> Unit)? = null + + init { + am.registerAudioDeviceCallback(object : AudioDeviceCallback() { + override fun onAudioDevicesAdded(added: Array) = refreshRoute() + override fun onAudioDevicesRemoved(removed: Array) = refreshRoute() + }, main) + refreshRoute() + } + + /** Where media would go right now, for when no AudioTrack is open. */ + fun refreshRoute() { + val attrs = AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA).build() + am.getAudioDevicesForAttributes(attrs).firstOrNull()?.let { setDevice(OutputDevice.of(it)) } + } + + /** From the engine's AudioTrack routing callback: the authoritative route while playing. */ + fun onRouted(info: AudioDeviceInfo?) { + if (info != null) setDevice(OutputDevice.of(info)) else refreshRoute() + } + + private fun setDevice(d: OutputDevice) { + if (_device.value == d && d in _state.value.seenDevices) return + _device.value = d + val s = _state.value + if (d !in s.seenDevices) update(s.copy(seenDevices = (listOf(d) + s.seenDevices).take(24))) else publish() + } + + // ---- edits ------------------------------------------------------------------------ + + fun setEnabled(on: Boolean) = update(_state.value.copy(enabled = on)) + fun setAntiClip(on: Boolean) = update(_state.value.copy(antiClip = on)) + + /** Automatic switching on clears the manual pick. */ + fun setAutomatic(on: Boolean) = update(_state.value.copy(automatic = on, manualId = if (on) null else _state.value.manualId ?: _active.value?.id)) + + /** Picking a profile by hand overrides automatic switching. */ + fun select(id: String) = update(_state.value.copy(manualId = id, automatic = false)) + + fun setGain(id: String, band: Int, db: Float) = edit(id) { p -> + p.copy(gains = p.gains.toMutableList().also { it[band] = db.coerceIn(-EQ_MAX_DB, EQ_MAX_DB) }) + } + + fun setGains(id: String, gains: List) = edit(id) { it.copy(gains = gains.map { g -> g.coerceIn(-EQ_MAX_DB, EQ_MAX_DB) }) } + + fun rename(id: String, name: String) = edit(id) { it.copy(name = name.ifBlank { it.name }) } + + fun setPreamp(id: String, db: Float) = edit(id) { it.copy(preamp = db.coerceIn(-PREAMP_RANGE, PREAMP_RANGE)) } + + /** Adds or replaces (by id) a parametric filter. */ + fun putFilter(id: String, f: EqFilter) = edit(id) { p -> + val clean = f.copy(freq = f.freq.coerceIn(FREQ_MIN, FREQ_MAX), gain = f.gain.coerceIn(-FILTER_GAIN, FILTER_GAIN), q = f.q.coerceIn(Q_MIN, Q_MAX)) + p.copy(filters = if (p.filters.any { it.id == f.id }) p.filters.map { if (it.id == f.id) clean else it } else p.filters + clean) + } + + fun removeFilter(id: String, filterId: String) = edit(id) { p -> p.copy(filters = p.filters.filter { it.id != filterId }) } + + /** Replaces the filters (and the preamp, when given): an Equalizer APO / AutoEQ import. */ + fun setFilters(id: String, filters: List, preamp: Float?) = edit(id) { p -> + p.copy(filters = filters, preamp = preamp?.coerceIn(-PREAMP_RANGE, PREAMP_RANGE) ?: p.preamp) + } + + fun create(name: String, from: EqProfile? = null): EqProfile { + val p = EqProfile(UUID.randomUUID().toString(), name.ifBlank { "Profile" }, from?.gains ?: List(EQ_BANDS.size) { 0f }, + filters = from?.filters?.map { it.copy(id = newFilterId()) }.orEmpty(), preamp = from?.preamp ?: 0f) + val s = _state.value + update(s.copy(profiles = s.profiles + p)) + return p + } + + fun delete(id: String) { + val s = _state.value + if (s.profiles.size <= 1) return + val rest = s.profiles.filter { it.id != id } + update(s.copy( + profiles = rest, + defaultId = if (s.defaultId == id) rest.first().id else s.defaultId, + manualId = s.manualId.takeIf { it != id }, + )) + } + + fun setDefault(id: String) = update(_state.value.copy(defaultId = id)) + + /** Links [device] to [id], unlinking it from any other profile (one profile per route). */ + fun link(id: String, device: OutputDevice, on: Boolean) { + val s = _state.value + update(s.copy(profiles = s.profiles.map { p -> + val others = p.devices.filter { it != device } + p.copy(devices = if (p.id == id && on) others + device else others) + })) + } + + fun profileFor(device: OutputDevice) = _state.value.profiles.firstOrNull { device in it.devices } + + private fun edit(id: String, f: (EqProfile) -> EqProfile) { + val s = _state.value + update(s.copy(profiles = s.profiles.map { if (it.id == id) f(it) else it })) + } + + private fun update(s: EqState) { + _state.value = s + publish() + // Slider drags update many times a second; write once they settle. + main.removeCallbacks(saveTask) + main.postDelayed(saveTask, 400) + } + + private fun publish() { + val s = _state.value + val p = resolve(s, _device.value) + _active.value = p + onParams?.invoke(paramsFor(s, p)) + } + + fun currentParams(): EqParams? = paramsFor(_state.value, _active.value) + + private fun resolve(s: EqState, d: OutputDevice): EqProfile? { + if (!s.automatic && s.manualId != null) s.profiles.firstOrNull { it.id == s.manualId }?.let { return it } + return s.profiles.firstOrNull { d in it.devices } + ?: s.profiles.firstOrNull { it.id == s.defaultId } + ?: s.profiles.firstOrNull() + } + + private fun paramsFor(s: EqState, p: EqProfile?): EqParams? { + if (!s.enabled || p == null) return null + val chain = p.chain + if (chain.isEmpty() && p.preamp == 0f) return null + return EqParams(chain, p.preamp + if (s.antiClip) EqMath.autoPreampDb(chain, p.preamp) else 0f) + } + + companion object { + const val FREQ_MIN = 10f + const val FREQ_MAX = 22000f + const val FILTER_GAIN = 24f + const val Q_MIN = 0.1f + const val Q_MAX = 20f + const val PREAMP_RANGE = 24f + + fun newFilterId() = UUID.randomUUID().toString() + } + + private fun load(): EqState = runCatching { + AppJson.decodeFromString(EqState.serializer(), file.readText()) + }.getOrElse { + EqState( + profiles = listOf( + EqProfile("flat", "Flat"), + EqProfile("speaker", "Small Speaker Tune", EQ_PRESETS.first { it.first == "Small Speakers" }.second, listOf(OutputDevice.SPEAKER)), + ), + ) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/playback/MixPresets.kt b/android/app/src/main/java/com/stemroller/mobile/playback/MixPresets.kt new file mode 100644 index 0000000..55ac7d5 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/playback/MixPresets.kt @@ -0,0 +1,43 @@ +package com.stemroller.mobile.playback + +/** A one-tap stem mix. [build] returns null when the track lacks the stems it needs. */ +class MixPreset(val label: String, val build: (List) -> Map?) + +object MixPresets { + val FULL = MixPreset("Full Mix") { emptyMap() } + val KARAOKE = MixPreset("Karaoke") { n -> if ("vocals" in n) mapOf("vocals" to StemSetting(muted = true)) else null } + + val ALL = listOf( + FULL, + KARAOKE, + MixPreset("A Cappella") { n -> if ("vocals" in n) mapOf("vocals" to StemSetting(solo = true)) else null }, + MixPreset("No Drums") { n -> if ("drums" in n) mapOf("drums" to StemSetting(muted = true)) else null }, + MixPreset("Rhythm") { n -> if ("drums" in n && "bass" in n) mapOf("drums" to StemSetting(solo = true), "bass" to StemSetting(solo = true)) else null }, + MixPreset("No Guitar") { n -> if ("guitar" in n) mapOf("guitar" to StemSetting(muted = true)) else null }, + MixPreset("No Bass") { n -> if ("bass" in n) mapOf("bass" to StemSetting(muted = true)) else null }, + ) + + /** Drops stems left at their defaults, so mixes compare by what they actually change. */ + fun normalized(m: Map) = m.filterValues { it != StemSetting() } + + /** The preset [mix] matches for these stems, or null for a hand-made mix. */ + fun current(names: List, mix: Map): MixPreset? { + val m = normalized(mix) + return ALL.firstOrNull { p -> p.build(names)?.let { normalized(it) == m } == true } + } + + /** The preset after the current one (a custom mix goes back to Full), skipping ones these stems can't do. */ + fun next(names: List, mix: Map): MixPreset { + val usable = ALL.filter { it.build(names) != null } + val i = usable.indexOf(current(names, mix)) + return if (i < 0) FULL else usable[(i + 1) % usable.size] + } + + /** True when the vocals stem can't be heard (muted, or another stem soloed). */ + fun vocalsSilent(names: List, mix: Map): Boolean { + if ("vocals" !in names) return false + val v = mix["vocals"] ?: StemSetting() + val anySolo = names.any { mix[it]?.solo == true } + return v.muted || anySolo && !v.solo || v.level <= 0f + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackManager.kt b/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackManager.kt new file mode 100644 index 0000000..0b6cab0 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackManager.kt @@ -0,0 +1,760 @@ +package com.stemroller.mobile.playback + +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.media.AudioAttributes +import android.media.AudioDeviceInfo +import android.media.AudioFocusRequest +import android.media.AudioManager +import android.net.wifi.WifiManager +import android.os.Handler +import android.os.Looper +import android.os.PowerManager +import com.stemroller.mobile.cache.MediaCache +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.core.StemQuality +import com.stemroller.mobile.engine.EqParams +import com.stemroller.mobile.engine.ResourceDataSource +import com.stemroller.mobile.engine.StemDecoder +import com.stemroller.mobile.engine.StemEngine +import com.stemroller.mobile.engine.TrackSession +import com.stemroller.mobile.engine.masterTaper +import com.stemroller.mobile.engine.stemTaper +import com.stemroller.mobile.eq.EqController +import com.stemroller.mobile.plex.PlexClient +import com.stemroller.mobile.plex.Track +import com.stemroller.mobile.stems.StemEntry +import com.stemroller.mobile.stems.StemServer +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharedFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asSharedFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.isActive +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.serialization.Serializable +import java.io.File +import java.io.IOException +import java.util.concurrent.CopyOnWriteArrayList +import java.util.concurrent.atomic.AtomicBoolean + +/** Display order and colours for stems, matching the desktop app. */ +object Stems { + val ORDER = listOf("vocals", "drums", "bass", "guitar", "piano", "other", "instrumental", "mix") + private val COLORS = mapOf( + "vocals" to 0xFFFF7AB6, "drums" to 0xFFFFB547, "bass" to 0xFF7C8CFF, "other" to 0xFF4CD07D, + "guitar" to 0xFFFF8A5C, "piano" to 0xFFB48CFF, "instrumental" to 0xFF3DD6C6, "mix" to 0xFF8E8E93, + ) + + fun color(name: String) = COLORS[name] ?: 0xFF8E8E93 + fun label(name: String) = if (name == "mix") "Original Mix" else name.replaceFirstChar { it.uppercase() } + fun sort(names: List) = names.sortedBy { ORDER.indexOf(it).let { i -> if (i < 0) 99 else i } } +} + +/** One stem's fader. [level] is the slider position; 0.8 is unity gain. */ +@Serializable +data class StemSetting(val level: Float = UNITY, val muted: Boolean = false, val solo: Boolean = false) { + companion object { const val UNITY = 0.8f } +} + +enum class RepeatMode { Off, All, One } +enum class SourceKind { None, Stems, Original } + +@Serializable +data class QueueItem(val uid: Long, val track: Track) + +/** Waveform data for the seek bar: per-stem envelopes from stemserve, or Plex loudness in dB. */ +class Waveform(val stems: Map?, val loudnessDb: FloatArray?) + +@Serializable +private data class SavedQueue( + val items: List = emptyList(), + val unshuffled: List? = null, + val index: Int = -1, + val positionMs: Long = 0, + val repeat: RepeatMode = RepeatMode.Off, + val mix: Map = emptyMap(), +) + +/** + * Owns the queue and the [StemEngine]. Everything public is main-thread only; the UI + * reads the flows, and PlaybackService mirrors this into a MediaSession. + */ +class PlaybackManager( + private val context: Context, + private val settings: Settings, + private val plex: PlexClient, + private val stems: StemServer, + private val cache: MediaCache, + private val eq: EqController, + private val scope: CoroutineScope, +) : StemEngine.Listener { + + val engine = StemEngine(this) + private val main = Handler(Looper.getMainLooper()) + private val queueFile = File(context.filesDir, "queue.json") + + private val _queue = MutableStateFlow>(emptyList()) + val queue: StateFlow> = _queue.asStateFlow() + private val _index = MutableStateFlow(-1) + val index: StateFlow = _index.asStateFlow() + private val _current = MutableStateFlow(null) + val current: StateFlow = _current.asStateFlow() + private val _playWhenReady = MutableStateFlow(false) + val playWhenReady: StateFlow = _playWhenReady.asStateFlow() + private val _buffering = MutableStateFlow(false) + val buffering: StateFlow = _buffering.asStateFlow() + private val _shuffle = MutableStateFlow(false) + val shuffle: StateFlow = _shuffle.asStateFlow() + private val _repeat = MutableStateFlow(RepeatMode.Off) + val repeat: StateFlow = _repeat.asStateFlow() + private val _source = MutableStateFlow(SourceKind.None) + val source: StateFlow = _source.asStateFlow() + private val _stemNames = MutableStateFlow>(emptyList()) + val stemNames: StateFlow> = _stemNames.asStateFlow() + private val _mix = MutableStateFlow>(emptyMap()) + val mix: StateFlow> = _mix.asStateFlow() + private val _master = MutableStateFlow(settings.masterVolume.value) + val master: StateFlow = _master.asStateFlow() + private val _waveform = MutableStateFlow(null) + val waveform: StateFlow = _waveform.asStateFlow() + private val _durationMs = MutableStateFlow(0L) + val durationMs: StateFlow = _durationMs.asStateFlow() + private val _messages = MutableSharedFlow(extraBufferCapacity = 4) + val messages: SharedFlow = _messages.asSharedFlow() + + private val listeners = CopyOnWriteArrayList<() -> Unit>() + private var unshuffled: List? = null + private var nextUid = 1L + private var tokens = 0L + private var loadJob: Job? = null + private var nextJob: Job? = null + private var currentToken = -1L + private var nextToken = -1L + private var nextIndex = -1 + private var nextEntry: StemEntry? = null + private var currentEntry: StemEntry? = null + private var pendingPositionMs = 0L + private var failures = 0 + private var scrobbled = -1L + private var duck = 1f + + init { + eq.onParams = { p: EqParams? -> engine.eqParams = p } + engine.eqParams = eq.currentParams() + engine.masterGain = masterTaper(_master.value) + restore() + scope.launch { + while (isActive) { + delay(10_000) + if (_playWhenReady.value) reportTimeline("playing") + } + } + } + + /** Surfaces a message wherever messages show (toasts on the phone, the player error in the car). */ + fun report(message: String) { + _messages.tryEmit(message) + } + + fun addListener(l: () -> Unit) = listeners.add(l) + fun removeListener(l: () -> Unit) = listeners.remove(l) + private fun changed() = listeners.forEach { it() } + + fun positionMs(): Long { + val snap = engine.snapshot + val pos = if (currentToken >= 0 && snap.token == currentToken) snap.positionMs() else pendingPositionMs + val d = _durationMs.value + return if (d > 0) pos.coerceIn(0, d) else pos.coerceAtLeast(0) + } + + // ---- queue -------------------------------------------------------------------------- + + fun playTracks(tracks: List, start: Int = 0, shuffle: Boolean = false) { + if (tracks.isEmpty()) return + val items = tracks.map { QueueItem(nextUid++, it) } + if (shuffle) { + unshuffled = items + val first = if (start in items.indices && start > 0) items[start] else items.random() + _queue.value = listOf(first) + (items - first).shuffled() + _shuffle.value = true + load(0, 0, true) + } else { + unshuffled = null + _shuffle.value = false + _queue.value = items + load(start.coerceIn(0, items.lastIndex), 0, true) + } + } + + fun playNext(tracks: List) = insert(_index.value + 1, tracks) + fun addToQueue(tracks: List) = insert(_queue.value.size, tracks) + + private fun insert(at: Int, tracks: List) { + if (tracks.isEmpty()) return + val items = tracks.map { QueueItem(nextUid++, it) } + val q = _queue.value.toMutableList() + q.addAll(at.coerceIn(0, q.size), items) + _queue.value = q + unshuffled = unshuffled?.plus(items) + if (_index.value < 0) { + load(0, 0, true) + } else { + requeueNext() + changed() + save() + } + } + + fun removeAt(i: Int) { + val q = _queue.value.toMutableList() + if (i !in q.indices) return + val removed = q.removeAt(i) + unshuffled = unshuffled?.filter { it.uid != removed.uid } + _queue.value = q + val idx = _index.value + when { + q.isEmpty() -> stop() + i == idx -> load(i.coerceAtMost(q.lastIndex), 0, _playWhenReady.value) + i < idx -> _index.value = idx - 1 + } + requeueNext() + changed() + save() + } + + fun move(from: Int, to: Int) { + val q = _queue.value.toMutableList() + if (from !in q.indices || to !in q.indices || from == to) return + q.add(to, q.removeAt(from)) + _queue.value = q + val idx = _index.value + _index.value = when { + from == idx -> to + from < idx && to >= idx -> idx - 1 + from > idx && to <= idx -> idx + 1 + else -> idx + } + requeueNext() + changed() + save() + } + + fun clearUpNext() { + val idx = _index.value + if (idx < 0) return + _queue.value = _queue.value.take(idx + 1) + unshuffled = null + _shuffle.value = false + requeueNext() + changed() + save() + } + + fun toggleShuffle() { + val q = _queue.value + val idx = _index.value + val cur = q.getOrNull(idx) + if (!_shuffle.value) { + unshuffled = q + val upcoming = q.drop(idx + 1).shuffled() + _queue.value = q.take(idx + 1) + upcoming + _shuffle.value = true + } else { + val orig = unshuffled ?: q + _queue.value = orig + _index.value = orig.indexOfFirst { it.uid == cur?.uid }.coerceAtLeast(0) + unshuffled = null + _shuffle.value = false + } + requeueNext() + changed() + save() + } + + fun cycleRepeat() { + _repeat.value = RepeatMode.entries[(_repeat.value.ordinal + 1) % RepeatMode.entries.size] + requeueNext() + changed() + save() + } + + fun setRepeat(mode: RepeatMode) { + _repeat.value = mode + requeueNext() + changed() + } + + // ---- transport ---------------------------------------------------------------------- + + fun play() { + if (_queue.value.isEmpty()) return + if (!requestFocus()) return + _playWhenReady.value = true + if (currentToken < 0 && loadJob?.isActive != true) { + load(_index.value.coerceAtLeast(0), pendingPositionMs, true) + return + } + engine.setPlaying(true) + holdLocks(true) + reportTimeline("playing") + changed() + } + + fun pause() { + _playWhenReady.value = false + engine.setPlaying(false) + holdLocks(false) + pendingPositionMs = positionMs() + reportTimeline("paused") + changed() + save() + } + + fun togglePlay() = if (_playWhenReady.value) pause() else play() + + fun next() { + val q = _queue.value + if (q.isEmpty()) return + val i = _index.value + 1 + when { + i < q.size -> load(i, 0, _playWhenReady.value) + _repeat.value != RepeatMode.Off -> load(0, 0, _playWhenReady.value) + else -> { pause(); seekTo(0) } + } + } + + fun previous() { + if (positionMs() > 3000 || _index.value <= 0) { + seekTo(0) + return + } + load(_index.value - 1, 0, _playWhenReady.value) + } + + fun skipTo(i: Int, positionMs: Long = 0) { + if (i in _queue.value.indices) load(i, positionMs, true) + } + + fun seekTo(ms: Long) { + pendingPositionMs = ms.coerceAtLeast(0) + if (currentToken >= 0) engine.seekTo(pendingPositionMs) + changed() + } + + fun stop() { + loadJob?.cancel() + nextJob?.cancel() + engine.stop() + reportTimeline("stopped") + currentToken = -1 + nextToken = -1 + _queue.value = emptyList() + _index.value = -1 + _current.value = null + _playWhenReady.value = false + _source.value = SourceKind.None + _stemNames.value = emptyList() + _waveform.value = null + holdLocks(false) + abandonFocus() + changed() + save() + } + + // ---- mixer -------------------------------------------------------------------------- + + fun setStemLevel(name: String, level: Float) = editMix(name) { it.copy(level = level.coerceIn(0f, 1f)) } + fun toggleMute(name: String) = editMix(name) { it.copy(muted = !it.muted) } + fun toggleSolo(name: String) = editMix(name) { it.copy(solo = !it.solo) } + + fun resetMix() { + _mix.value = emptyMap() + pushMix() + } + + /** Karaoke and friends: set every stem at once. */ + fun applyMix(m: Map) { + _mix.value = m + pushMix() + } + + private fun editMix(name: String, f: (StemSetting) -> StemSetting) { + _mix.value = _mix.value + (name to f(_mix.value[name] ?: StemSetting())) + pushMix() + } + + private fun pushMix() { + val m = _mix.value + val anySolo = _stemNames.value.any { m[it]?.solo == true } + engine.setMix(_stemNames.value.associateWith { n -> + val s = m[n] ?: StemSetting() + when { + anySolo && !s.solo -> 0f + s.muted -> 0f + else -> stemTaper(s.level) + } + }) + // The media session shows the mix (artist line, Vocals/Mix buttons), so it needs to hear about it. + changed() + save() + } + + /** True when [track] would play without the home network: its stems (or, lacking stems, its file) are fully cached. */ + fun playableOffline(track: Track): Boolean { + val entry = stems.find(track) + if (entry != null) { + return StemQuality.entries.any { q -> entry.stems.all { cache.isComplete(stemKey(entry, it.file, it.size, q)) } } + } + return track.partKey != null && cache.isComplete(plexKey(track)) + } + + fun hasStems(track: Track) = stems.find(track) != null + + fun setMaster(v: Float) { + _master.value = v.coerceIn(0f, 1f) + engine.masterGain = masterTaper(_master.value) * duck + settings.masterVolume.value = _master.value + } + + // ---- loading ------------------------------------------------------------------------ + + private fun load(i: Int, positionMs: Long, play: Boolean) { + val item = _queue.value.getOrNull(i) ?: return + loadJob?.cancel() + nextJob?.cancel() + nextToken = -1 + engine.queueNext(null) + _index.value = i + _current.value = item + pendingPositionMs = positionMs + _durationMs.value = item.track.durationMs + _waveform.value = null + currentToken = -1 + if (play && !requestFocus()) return + _playWhenReady.value = play + holdLocks(play) + _buffering.value = true + if (!settings.keepStemMix.value) _mix.value = emptyMap() + changed() + save() + loadJob = scope.launch { + var session: TrackSession? = null + try { + val (s, entry) = withContext(Dispatchers.IO) { open(item.track, positionMs) } + session = s + if (!isActive) throw CancellationException() + currentToken = s.token + currentEntry = entry + applySession(s, entry) + engine.load(s, _playWhenReady.value) + session = null + failures = 0 + scrobbled = -1 + reportTimeline(if (_playWhenReady.value) "playing" else "paused") + loadWaveform(item.track, entry) + prepareNext() + } catch (e: CancellationException) { + session?.release() + } catch (e: Exception) { + session?.release() + _buffering.value = false + _messages.tryEmit("Couldn't play “${item.track.title}”: ${e.message ?: e.javaClass.simpleName}") + if (++failures < 3 && i + 1 < _queue.value.size) load(i + 1, 0, play) else { + failures = 0 + _playWhenReady.value = false + holdLocks(false) + } + changed() + } + } + } + + private fun applySession(s: TrackSession, entry: StemEntry?) { + _source.value = if (entry != null) SourceKind.Stems else SourceKind.Original + _stemNames.value = s.names + val frames = s.durationFrames + if (frames > 0) _durationMs.value = frames * 1000 / s.sampleRate + pushMix() + changed() + } + + /** Opens every stem (or the original file) and waits for the decoders to know their format. */ + private fun open(track: Track, startMs: Long): Pair { + val entry = stems.find(track) + val sources: List> = if (entry != null) { + val q = qualityFor(entry) + stems.prepare(entry, q) + Stems.sort(entry.stems.map { it.name }).map { name -> + val f = entry.stems.first { it.name == name } + Triple(name, stemKey(entry, f.file, f.size, q), stems.fileUrl(entry, f, q)) + } + } else { + val part = track.partKey ?: throw IOException("Plex has no file for this track") + listOf(Triple("mix", plexKey(track), plex.partUrl(part))) + } + val decoders = sources.map { (name, key, url) -> + val res = cache.acquire(key) { url } + StemDecoder(name, ResourceDataSource(res) { cache.release(res) }, RING_FRAMES) + } + try { + decoders.forEach { it.start(0, 0) } + for (d in decoders) { + if (!d.awaitPrepared(45_000)) throw IOException(d.error?.message ?: "Timed out opening ${d.name}") + } + val rate = decoders.first().sampleRate + if (decoders.any { it.sampleRate != rate }) throw IOException("Stems have mixed sample rates") + val s = TrackSession(++tokens, decoders.map { it.name }, decoders) + if (startMs > 0) s.startAt(startMs * rate / 1000) + return s to entry + } catch (e: Exception) { + decoders.forEach { it.release() } + throw e + } + } + + /** Plays a downloaded copy if there is one, whatever quality it was saved at. */ + private fun qualityFor(entry: StemEntry): StemQuality { + val want = stems.effectiveQuality(settings.stemQuality.value) + val f = entry.stems.first() + if (cache.isComplete(stemKey(entry, f.file, f.size, want))) return want + return StemQuality.entries.firstOrNull { cache.isComplete(stemKey(entry, f.file, f.size, it)) } ?: want + } + + /** Builds the next track's session now so the switch can be gapless. */ + private fun prepareNext() { + nextJob?.cancel() + nextToken = -1 + engine.queueNext(null) + val i = upcomingIndex() ?: return + val item = _queue.value[i] + nextJob = scope.launch { + delay(4_000) // let the current track's stems get a head start + var session: TrackSession? = null + try { + val (s, entry) = withContext(Dispatchers.IO) { open(item.track, 0) } + session = s + if (!isActive) throw CancellationException() + nextToken = s.token + nextIndex = i + nextEntry = entry + engine.queueNext(s) + session = null + } catch (e: CancellationException) { + session?.release() + } catch (e: Exception) { + session?.release() // the normal load path will report it + } + } + } + + private fun requeueNext() { + if (currentToken >= 0) prepareNext() + } + + private fun upcomingIndex(): Int? { + val q = _queue.value + val i = _index.value + return when { + q.isEmpty() || i < 0 -> null + _repeat.value == RepeatMode.One -> i + i + 1 < q.size -> i + 1 + _repeat.value == RepeatMode.All -> 0 + else -> null + } + } + + private fun loadWaveform(track: Track, entry: StemEntry?) { + val uid = _current.value?.uid + scope.launch { + val w = if (entry != null) { + stems.peaks(entry, WAVE_BUCKETS)?.let { Waveform(it, null) } + } else { + runCatching { plex.loudness(track.ratingKey, WAVE_BUCKETS) }.getOrNull()?.let { Waveform(null, it) } + } + if (_current.value?.uid == uid) _waveform.value = w + } + } + + // ---- engine callbacks (main thread) --------------------------------------------------- + + override fun onEngineState() { + _buffering.value = engine.buffering || (loadJob?.isActive == true) + changed() + } + + override fun onTransition(token: Long) { + if (token == currentToken || token != nextToken) return + scrobble() + currentToken = token + nextToken = -1 + _index.value = nextIndex + _current.value = _queue.value.getOrNull(nextIndex) + currentEntry = nextEntry + pendingPositionMs = 0 + scrobbled = -1 + val item = _current.value ?: return + _durationMs.value = item.track.durationMs + _waveform.value = null + if (!settings.keepStemMix.value) _mix.value = emptyMap() + _source.value = if (currentEntry != null) SourceKind.Stems else SourceKind.Original + _stemNames.value = Stems.sort((currentEntry?.stems?.map { it.name }) ?: listOf("mix")) + pushMix() + loadWaveform(item.track, currentEntry) + reportTimeline("playing") + prepareNext() + changed() + save() + } + + override fun onEnded(token: Long) { + if (token != currentToken) return + scrobble() + currentToken = -1 + // Normally the next song was queued for a gapless switch; if preparing it failed, try again now. + upcomingIndex()?.let { i -> + load(i, 0, true) + return + } + _playWhenReady.value = false + holdLocks(false) + pendingPositionMs = 0 + reportTimeline("stopped") + changed() + save() + } + + override fun onError(token: Long, message: String) { + if (token != currentToken) return + _messages.tryEmit("Playback stopped: $message") + currentToken = -1 + val i = _index.value + if (i + 1 < _queue.value.size && ++failures < 3) load(i + 1, 0, _playWhenReady.value) else { + _playWhenReady.value = false + holdLocks(false) + changed() + } + } + + override fun onRouted(device: AudioDeviceInfo?) = eq.onRouted(device) + + private fun scrobble() { + val item = _current.value ?: return + if (scrobbled == item.uid) return + val d = _durationMs.value + if (d > 0 && positionMs() < d * 0.5 && engine.snapshot.token == currentToken) return + scrobbled = item.uid + scope.launch { plex.scrobble(item.track.ratingKey) } + } + + private fun reportTimeline(state: String) { + val t = _current.value?.track ?: return + val pos = positionMs() + if (!plex.signedIn) return + scope.launch { plex.timeline(t, state, pos) } + if (state == "playing" && _durationMs.value > 0 && pos > _durationMs.value * 0.9) scrobble() + } + + // ---- focus, locks --------------------------------------------------------------------- + + private val am = context.getSystemService(AudioManager::class.java) + private var resumeOnGain = false + private val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN) + .setAudioAttributes(AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA).setContentType(AudioAttributes.CONTENT_TYPE_MUSIC).build()) + .setWillPauseWhenDucked(false) + .setOnAudioFocusChangeListener({ change -> + when (change) { + AudioManager.AUDIOFOCUS_LOSS -> { resumeOnGain = false; pause() } + AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> { resumeOnGain = _playWhenReady.value; pause() } + AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> { duck = 0.25f; setMaster(_master.value) } + AudioManager.AUDIOFOCUS_GAIN -> { + duck = 1f + setMaster(_master.value) + if (resumeOnGain) play() + resumeOnGain = false + } + } + }, main) + .build() + + private fun requestFocus() = am.requestAudioFocus(focusRequest) == AudioManager.AUDIOFOCUS_REQUEST_GRANTED + private fun abandonFocus() = am.abandonAudioFocusRequest(focusRequest) + + private val noisy = object : BroadcastReceiver() { + override fun onReceive(c: Context, i: Intent) { + if (i.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) pause() + } + } + private val noisyRegistered = AtomicBoolean(false) + private val wakeLock = context.getSystemService(PowerManager::class.java) + .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "StemRoller:playback").apply { setReferenceCounted(false) } + @Suppress("DEPRECATION") + private val wifiLock = context.applicationContext.getSystemService(WifiManager::class.java) + .createWifiLock(WifiManager.WIFI_MODE_FULL_HIGH_PERF, "StemRoller:stream").apply { setReferenceCounted(false) } + + private fun holdLocks(on: Boolean) { + if (on) { + if (!wakeLock.isHeld) wakeLock.acquire(4 * 60 * 60 * 1000L) + if (!wifiLock.isHeld) wifiLock.acquire() + if (noisyRegistered.compareAndSet(false, true)) { + context.registerReceiver(noisy, IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY), Context.RECEIVER_NOT_EXPORTED) + } + } else { + if (wakeLock.isHeld) wakeLock.release() + if (wifiLock.isHeld) wifiLock.release() + if (noisyRegistered.compareAndSet(true, false)) runCatching { context.unregisterReceiver(noisy) } + } + } + + // ---- persistence ------------------------------------------------------------------------ + + private var saveJob: Job? = null + + private fun save() { + saveJob?.cancel() + saveJob = scope.launch { + delay(500) + val snap = SavedQueue(_queue.value, unshuffled, _index.value, positionMs(), _repeat.value, _mix.value) + withContext(Dispatchers.IO) { + runCatching { + val tmp = File(queueFile.parentFile, "queue.json.tmp") + tmp.writeText(AppJson.encodeToString(SavedQueue.serializer(), snap)) + tmp.renameTo(queueFile) + } + } + } + } + + private fun restore() { + val saved = runCatching { AppJson.decodeFromString(SavedQueue.serializer(), queueFile.readText()) }.getOrNull() ?: return + _queue.value = saved.items + unshuffled = saved.unshuffled + _shuffle.value = saved.unshuffled != null + _repeat.value = saved.repeat + _mix.value = saved.mix + nextUid = (saved.items.maxOfOrNull { it.uid } ?: 0) + 1 + val i = saved.index.coerceIn(-1, saved.items.lastIndex) + _index.value = i + _current.value = saved.items.getOrNull(i) + _durationMs.value = _current.value?.track?.durationMs ?: 0 + pendingPositionMs = saved.positionMs + } + + companion object { + const val RING_FRAMES = StemEngine.RING_SECONDS * 48_000 + const val WAVE_BUCKETS = 256 + + fun stemKey(entry: StemEntry, file: String, size: Long, q: StemQuality) = "stem|${entry.key}|$file|$size|${q.name}" + fun plexKey(track: Track) = "plex|${track.partId}|${track.partSize}" + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackService.kt b/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackService.kt new file mode 100644 index 0000000..71b7e6a --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/playback/PlaybackService.kt @@ -0,0 +1,518 @@ +package com.stemroller.mobile.playback + +import android.app.PendingIntent +import android.content.Intent +import android.os.Bundle +import android.os.Looper +import android.util.Log +import androidx.annotation.OptIn +import androidx.media3.common.C +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata +import androidx.media3.common.PlaybackException +import androidx.media3.common.Player +import androidx.media3.common.SimpleBasePlayer +import androidx.media3.common.util.UnstableApi +import androidx.media3.session.CommandButton +import androidx.media3.session.DefaultMediaNotificationProvider +import androidx.media3.session.LibraryResult +import androidx.media3.session.MediaConstants +import androidx.media3.session.MediaLibraryService +import androidx.media3.session.MediaSession +import androidx.media3.session.SessionCommand +import androidx.media3.session.SessionError +import androidx.media3.session.SessionResult +import com.google.common.collect.ImmutableList +import com.google.common.util.concurrent.Futures +import com.google.common.util.concurrent.ListenableFuture +import com.stemroller.mobile.App +import com.stemroller.mobile.MainActivity +import com.stemroller.mobile.R +import com.stemroller.mobile.auto.CarArtProvider +import com.stemroller.mobile.auto.CarIds +import com.stemroller.mobile.auto.CarLibrary +import com.stemroller.mobile.auto.Resolved +import com.stemroller.mobile.plex.NotSignedInException +import com.stemroller.mobile.plex.Track +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.drop +import kotlinx.coroutines.guava.future +import kotlinx.coroutines.launch + +/** Rides on a MediaItem from the library callback to [StemPlayer.handleSetMediaItems]. */ +private class PlayTag(val track: Track, val shuffle: Boolean) + +/** Marks the items [MediaLibraryService] gets back from playback resumption: just resume the saved queue. */ +private object ResumeTag + +/** + * Presents [PlaybackManager] to Media3 so the notification, lock screen, Bluetooth + * buttons, Android Auto and other controllers drive the same queue the UI does. + */ +@OptIn(UnstableApi::class) +class StemPlayer(private val pm: PlaybackManager, scope: CoroutineScope) : SimpleBasePlayer(Looper.getMainLooper()) { + private val onChange: () -> Unit = { invalidateState() } + private val items = HashMap() + private var error: PlaybackException? = null + private var errorAt = 0L + + init { + pm.addListener(onChange) + // Auto has no toasts: a failed song shows as a player error until something plays. + scope.launch { + pm.messages.collect { msg -> + error = PlaybackException(msg, null, PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED) + errorAt = System.nanoTime() + invalidateState() + } + } + } + + /** "Karaoke", "Custom mix"… for the playing song when it isn't the full mix; null otherwise. */ + fun mixLabel(): String? { + if (pm.source.value != SourceKind.Stems) return null + val p = MixPresets.current(pm.stemNames.value, pm.mix.value) + return when { + p == null -> "Custom mix" + p === MixPresets.FULL -> null + else -> p.label + } + } + + private fun mediaItem(item: QueueItem, label: String?): MediaItem = items.getOrPut("${item.uid}|$label") { + val t = item.track + MediaItem.Builder() + .setMediaId("${item.uid}:${t.ratingKey}") + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(t.title) + // The mix rides on the artist line: in the car it's the only feedback the mix button gets. + .setArtist(if (label != null) "${t.artist} · $label" else t.artist) + .setAlbumTitle(t.album) + .setTrackNumber(t.index) + .setDurationMs(t.durationMs) + .setArtworkUri(CarArtProvider.uri(t.thumb)) + .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) + .setIsPlayable(true) + .setIsBrowsable(false) + .build(), + ).build() + } + + override fun getState(): State { + val q = pm.queue.value + val idx = pm.index.value + if (items.size > q.size * 2 + 64) { + val keep = q.map { it.uid.toString() }.toSet() + items.keys.retainAll { it.substringBefore('|') in keep } + } + val commands = Player.Commands.Builder().addAll( + COMMAND_PLAY_PAUSE, COMMAND_STOP, COMMAND_PREPARE, COMMAND_RELEASE, + COMMAND_SEEK_IN_CURRENT_MEDIA_ITEM, COMMAND_SEEK_TO_DEFAULT_POSITION, + COMMAND_SEEK_TO_PREVIOUS, COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM, + COMMAND_SEEK_TO_NEXT, COMMAND_SEEK_TO_NEXT_MEDIA_ITEM, COMMAND_SEEK_TO_MEDIA_ITEM, + COMMAND_GET_CURRENT_MEDIA_ITEM, COMMAND_GET_TIMELINE, COMMAND_GET_METADATA, + COMMAND_SET_SHUFFLE_MODE, COMMAND_SET_REPEAT_MODE, COMMAND_SET_MEDIA_ITEM, COMMAND_CHANGE_MEDIA_ITEMS, + ).build() + if (error != null && (System.nanoTime() - errorAt > ERROR_NS || pm.playWhenReady.value && !pm.buffering.value)) error = null + val b = State.Builder().setAvailableCommands(commands) + .setPlayWhenReady(pm.playWhenReady.value, PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST) + .setShuffleModeEnabled(pm.shuffle.value) + .setRepeatMode( + when (pm.repeat.value) { + RepeatMode.Off -> REPEAT_MODE_OFF + RepeatMode.All -> REPEAT_MODE_ALL + RepeatMode.One -> REPEAT_MODE_ONE + }, + ) + if (q.isEmpty()) return b.setPlaybackState(STATE_IDLE).setPlayerError(error).build() + val cur = idx.coerceIn(0, q.lastIndex) + val label = mixLabel() + val playlist = q.mapIndexed { i, item -> + MediaItemData.Builder(item.uid) + .setMediaItem(mediaItem(item, if (i == cur) label else null)) + .setDurationUs(if (item.track.durationMs > 0) item.track.durationMs * 1000 else C.TIME_UNSET) + .setIsSeekable(true) + .build() + } + val state = when { + error != null && !pm.playWhenReady.value -> STATE_IDLE + pm.buffering.value && pm.playWhenReady.value -> STATE_BUFFERING + else -> STATE_READY + } + return b.setPlaylist(playlist) + .setCurrentMediaItemIndex(cur) + .setPlaybackState(state) + // Media3 only allows an error alongside STATE_IDLE. + .setPlayerError(if (state == STATE_IDLE) error else null) + .setIsLoading(pm.buffering.value) + .setContentPositionMs { pm.positionMs() } + .build() + } + + private fun done(): ListenableFuture<*> = Futures.immediateVoidFuture() + + override fun handleSetPlayWhenReady(playWhenReady: Boolean): ListenableFuture<*> { + if (playWhenReady) pm.play() else pm.pause() + return done() + } + + override fun handlePrepare(): ListenableFuture<*> = done() + + override fun handleStop(): ListenableFuture<*> { + pm.pause() + return done() + } + + /** Items come from [PlaybackService]'s library callback, which tags each with its track. */ + override fun handleSetMediaItems(mediaItems: MutableList, startIndex: Int, startPositionMs: Long): ListenableFuture<*> { + val tags = mediaItems.map { it.localConfiguration?.tag } + if (tags.firstOrNull() === ResumeTag) return done() + val picks = tags.filterIsInstance() + if (picks.isEmpty()) return done() + val start = if (startIndex == C.INDEX_UNSET) 0 else startIndex + error = null + pm.playTracks(picks.map { it.track }, start, shuffle = picks.first().shuffle) + return done() + } + + override fun handleAddMediaItems(index: Int, mediaItems: MutableList): ListenableFuture<*> { + val tracks = mediaItems.mapNotNull { (it.localConfiguration?.tag as? PlayTag)?.track } + when { + tracks.isEmpty() -> Unit + index >= pm.queue.value.size -> pm.addToQueue(tracks) + index == pm.index.value + 1 -> pm.playNext(tracks) + else -> pm.addToQueue(tracks) + } + return done() + } + + override fun handleRemoveMediaItems(fromIndex: Int, toIndex: Int): ListenableFuture<*> { + for (i in toIndex - 1 downTo fromIndex) pm.removeAt(i) + return done() + } + + override fun handleMoveMediaItems(fromIndex: Int, toIndex: Int, newIndex: Int): ListenableFuture<*> { + // Media3 moves a range; the queue moves one at a time, which is all controllers send in practice. + if (toIndex - fromIndex == 1) pm.move(fromIndex, newIndex) + return done() + } + + override fun handleSeek(mediaItemIndex: Int, positionMs: Long, seekCommand: Int): ListenableFuture<*> { + val pos = if (positionMs == C.TIME_UNSET) 0 else positionMs + if (mediaItemIndex == C.INDEX_UNSET || mediaItemIndex == pm.index.value) pm.seekTo(pos) else pm.skipTo(mediaItemIndex, pos) + return done() + } + + override fun handleSetShuffleModeEnabled(shuffleModeEnabled: Boolean): ListenableFuture<*> { + if (shuffleModeEnabled != pm.shuffle.value) pm.toggleShuffle() + return done() + } + + override fun handleSetRepeatMode(repeatMode: Int): ListenableFuture<*> { + pm.setRepeat( + when (repeatMode) { + REPEAT_MODE_ONE -> RepeatMode.One + REPEAT_MODE_ALL -> RepeatMode.All + else -> RepeatMode.Off + }, + ) + return done() + } + + override fun handleRelease(): ListenableFuture<*> { + pm.removeListener(onChange) + return done() + } + + private companion object { + const val ERROR_NS = 10_000_000_000L + } +} + +@OptIn(UnstableApi::class) +class PlaybackService : MediaLibraryService() { + private var session: MediaLibrarySession? = null + private val graph get() = App.graph + private val pm get() = graph.playback + private val library by lazy { CarLibrary(graph) } + private var buttonsKey = "" + private var rootLimit = 4 + private val onChange: () -> Unit = { updateButtons() } + private var homeWatch: Job? = null + + override fun onCreate() { + super.onCreate() + val player = StemPlayer(pm, graph.scope) + val open = PendingIntent.getActivity( + this, 0, + Intent(this, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP).putExtra(MainActivity.EXTRA_NOW_PLAYING, true), + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, + ) + session = MediaLibrarySession.Builder(this, player, Callback()) + .setSessionActivity(open) + .setMediaButtonPreferences(buttons()) + .build() + setMediaNotificationProvider(DefaultMediaNotificationProvider.Builder(this).build().apply { setSmallIcon(R.drawable.ic_stat_stems) }) + pm.addListener(onChange) + // Auto loads every tab up front and keeps them; when home comes into (or out of) reach the + // lists change (everything vs. what plays offline), so tell it to load them again. + homeWatch = graph.scope.launch { + graph.reach.home.drop(1).collect { + val s = session ?: return@collect + s.notifyChildrenChanged(CarIds.ROOT, rootLimit, null) + for (tab in CarIds.TABS) s.notifyChildrenChanged(tab, 1, null) + } + } + } + + override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? = session + + override fun onTaskRemoved(rootIntent: Intent?) { + val p = session?.player + if (p == null || !p.playWhenReady || p.mediaItemCount == 0) stopSelf() + } + + override fun onDestroy() { + homeWatch?.cancel() + pm.removeListener(onChange) + session?.run { + player.release() + release() + } + session = null + super.onDestroy() + } + + // ---- buttons --------------------------------------------------------------------- + + /** + * The now-playing buttons beside previous / play / next. On the Miata's 800-px-wide screen + * Auto shows one or two of these and puts the rest behind "more", so the order is the + * priority: vocals (the karaoke switch), then the preset cycler, then shuffle and repeat. + * Songs without stems just get shuffle and repeat. + */ + private fun buttons(): List { + val names = pm.stemNames.value + val stems = pm.source.value == SourceKind.Stems + val list = ArrayList() + if (stems && "vocals" in names) { + val silent = MixPresets.vocalsSilent(names, pm.mix.value) + list += custom(ACTION_VOCALS, if (silent) "Vocals on" else "Vocals off", if (silent) R.drawable.ic_car_vocals_off else R.drawable.ic_car_vocals) + } + if (stems && names.size > 1) { + val next = MixPresets.next(names, pm.mix.value) + list += custom(ACTION_MIX, "Mix: ${next.label}", R.drawable.ic_car_mix) + } + val shuffled = pm.shuffle.value + list += CommandButton.Builder(if (shuffled) CommandButton.ICON_SHUFFLE_ON else CommandButton.ICON_SHUFFLE_OFF) + .setDisplayName(if (shuffled) "Shuffle off" else "Shuffle on") + .setSessionCommand(SessionCommand(ACTION_SHUFFLE, Bundle.EMPTY)) + .setSlots(CommandButton.SLOT_OVERFLOW) + .build() + val repeat = pm.repeat.value + list += CommandButton.Builder( + when (repeat) { + RepeatMode.Off -> CommandButton.ICON_REPEAT_OFF + RepeatMode.All -> CommandButton.ICON_REPEAT_ALL + RepeatMode.One -> CommandButton.ICON_REPEAT_ONE + }, + ) + .setDisplayName( + when (repeat) { + RepeatMode.Off -> "Repeat all" + RepeatMode.All -> "Repeat one" + RepeatMode.One -> "Repeat off" + }, + ) + .setSessionCommand(SessionCommand(ACTION_REPEAT, Bundle.EMPTY)) + .setSlots(CommandButton.SLOT_OVERFLOW) + .build() + return list + } + + private fun custom(action: String, name: String, icon: Int) = CommandButton.Builder(CommandButton.ICON_UNDEFINED) + .setCustomIconResId(icon) + .setDisplayName(name) + .setSessionCommand(SessionCommand(action, Bundle.EMPTY)) + .setSlots(CommandButton.SLOT_OVERFLOW) + .build() + + private fun updateButtons() { + val s = session ?: return + val b = buttons() + val key = b.joinToString { "${it.sessionCommand?.customAction}:${it.displayName}:${it.icon}" } + if (key == buttonsKey) return + buttonsKey = key + s.setMediaButtonPreferences(b) + } + + private fun onButton(action: String): Boolean { + val names = pm.stemNames.value + val mix = pm.mix.value + when (action) { + ACTION_VOCALS -> { + if (pm.source.value != SourceKind.Stems || "vocals" !in names) return false + val v = mix["vocals"] ?: StemSetting() + val anySolo = names.any { mix[it]?.solo == true } + if (MixPresets.vocalsSilent(names, mix)) { + // Muted on their own: unmute. Silenced by a solo elsewhere (Rhythm…): back to the full mix. + if (v.muted && !anySolo) pm.toggleMute("vocals") else pm.applyMix(emptyMap()) + } else { + // Muting a soloed vocal (A Cappella) would silence everything; go to Karaoke instead. + if (anySolo) pm.applyMix(MixPresets.KARAOKE.build(names) ?: emptyMap()) else pm.toggleMute("vocals") + } + } + ACTION_MIX -> { + if (pm.source.value != SourceKind.Stems) return false + pm.applyMix(MixPresets.next(names, mix).build(names) ?: emptyMap()) + } + ACTION_SHUFFLE -> pm.toggleShuffle() + ACTION_REPEAT -> pm.cycleRepeat() + else -> return false + } + return true + } + + // ---- library ----------------------------------------------------------------------- + + private inner class Callback : MediaLibrarySession.Callback { + private val scope get() = graph.scope + + override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult { + val commands = MediaSession.ConnectionResult.DEFAULT_SESSION_AND_LIBRARY_COMMANDS.buildUpon() + ACTIONS.forEach { commands.add(SessionCommand(it, Bundle.EMPTY)) } + return MediaSession.ConnectionResult.AcceptedResultBuilder(session) + .setAvailableSessionCommands(commands.build()) + .setMediaButtonPreferences(buttons()) + .build() + } + + override fun onCustomCommand(session: MediaSession, controller: MediaSession.ControllerInfo, customCommand: SessionCommand, args: Bundle): ListenableFuture = + Futures.immediateFuture( + if (onButton(customCommand.customAction)) SessionResult(SessionResult.RESULT_SUCCESS) + else SessionResult(SessionError.ERROR_NOT_SUPPORTED), + ) + + override fun onGetLibraryRoot(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, params: LibraryParams?): ListenableFuture> { + // Auto says how many tabs it can show (4 on the Miata's screen). + params?.extras?.getInt(MediaConstants.EXTRAS_KEY_ROOT_CHILDREN_LIMIT, 0)?.takeIf { it > 0 }?.let { rootLimit = it } + val root = MediaItem.Builder().setMediaId(CarIds.ROOT).setMediaMetadata( + MediaMetadata.Builder().setTitle("StemRoller").setIsBrowsable(true).setIsPlayable(false) + .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED).build(), + ).build() + val extras = Bundle().apply { + putBoolean(SEARCH_SUPPORTED, true) + putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + } + return Futures.immediateFuture(LibraryResult.ofItem(root, LibraryParams.Builder().setExtras(extras).build())) + } + + override fun onGetItem(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, mediaId: String): ListenableFuture> = + Futures.immediateFuture(LibraryResult.ofError(SessionError.ERROR_NOT_SUPPORTED)) + + override fun onGetChildren( + session: MediaLibrarySession, browser: MediaSession.ControllerInfo, parentId: String, + page: Int, pageSize: Int, params: LibraryParams?, + ): ListenableFuture>> = scope.future { + try { + val all = if (parentId == CarIds.ROOT) { + library.root(rootLimit) + } else { + library.children(parentId) ?: return@future LibraryResult.ofError(SessionError.ERROR_BAD_VALUE) + } + LibraryResult.ofItemList(pageOf(all, page, pageSize), params) + } catch (e: Exception) { + LibraryResult.ofError(sessionError(e)) + } + } + + override fun onSearch(session: MediaLibrarySession, browser: MediaSession.ControllerInfo, query: String, params: LibraryParams?): ListenableFuture> = scope.future { + val n = runCatching { library.searchItems(query).size }.getOrDefault(0) + session.notifySearchResultChanged(browser, query, n, params) + LibraryResult.ofVoid() + } + + override fun onGetSearchResult( + session: MediaLibrarySession, browser: MediaSession.ControllerInfo, query: String, + page: Int, pageSize: Int, params: LibraryParams?, + ): ListenableFuture>> = scope.future { + try { + LibraryResult.ofItemList(pageOf(library.searchItems(query), page, pageSize), params) + } catch (e: Exception) { + LibraryResult.ofError(sessionError(e)) + } + } + + /** A tapped row (by id) or a voice request (by search query) becomes the whole queue. */ + override fun onSetMediaItems( + mediaSession: MediaSession, controller: MediaSession.ControllerInfo, + mediaItems: MutableList, startIndex: Int, startPositionMs: Long, + ): ListenableFuture = scope.future { + val first = mediaItems.firstOrNull() ?: throw IllegalArgumentException("nothing to play") + val query = first.requestMetadata.searchQuery + val r: Resolved = try { + if (query != null) library.resolveSearch(query) else library.resolve(first.mediaId) + } catch (e: Exception) { + pm.report(if (e is NotSignedInException) "Sign in to Plex on your phone" else "Couldn't load that: ${e.message}") + null + } ?: run { + pm.report(if (query != null) "Nothing found for “$query”" else "That isn't available offline") + throw IllegalArgumentException("unresolved ${first.mediaId}") + } + MediaSession.MediaItemsWithStartPosition(r.tracks.map { tagged(it, r.shuffle) }, r.start, 0) + } + + override fun onAddMediaItems(mediaSession: MediaSession, controller: MediaSession.ControllerInfo, mediaItems: MutableList): ListenableFuture> = + scope.future { + mediaItems.flatMap { item -> + val r = runCatching { library.resolve(item.mediaId) }.getOrNull() ?: return@flatMap emptyList() + r.tracks.drop(r.start).take(1).map { tagged(it, false) } + }.toMutableList() + } + + /** Bluetooth / Auto "play" after the app was killed: the queue is already restored from disk, so just resume it. */ + override fun onPlaybackResumption(mediaSession: MediaSession, controller: MediaSession.ControllerInfo): ListenableFuture { + val q = pm.queue.value + if (q.isEmpty()) return Futures.immediateFailedFuture(UnsupportedOperationException("no saved queue")) + val items = q.map { MediaItem.Builder().setMediaId("${it.uid}:${it.track.ratingKey}").setUri("stemroller://resume").setTag(ResumeTag).build() } + return Futures.immediateFuture(MediaSession.MediaItemsWithStartPosition(items, pm.index.value.coerceIn(0, q.lastIndex), pm.positionMs())) + } + } + + private fun tagged(t: Track, shuffle: Boolean) = MediaItem.Builder() + .setMediaId("track:${t.ratingKey}") + .setUri("stemroller://track/${t.ratingKey}") + .setTag(PlayTag(t, shuffle)) + .setMediaMetadata(MediaMetadata.Builder().setTitle(t.title).setArtist(t.artist).setArtworkUri(CarArtProvider.uri(t.thumb)).build()) + .build() + + private fun pageOf(all: List, page: Int, pageSize: Int): List { + if (pageSize <= 0 || pageSize == Int.MAX_VALUE) return all + val from = page.toLong() * pageSize + if (from >= all.size) return emptyList() + return all.subList(from.toInt(), minOf(all.size.toLong(), from + pageSize).toInt()) + } + + private fun sessionError(e: Exception): SessionError { + Log.w(TAG, "car browse failed", e) + return when (e) { + is NotSignedInException -> SessionError(SessionError.ERROR_SESSION_SETUP_REQUIRED, "Sign in to Plex on your phone") + else -> SessionError(SessionError.ERROR_IO, if (graph.reach.lastKnown) "Couldn't reach Plex" else "Not downloaded – connect to home Wi-Fi") + } + } + + companion object { + private const val TAG = "StemCar" + private const val ACTION_VOCALS = "stemroller.VOCALS" + private const val ACTION_MIX = "stemroller.MIX" + private const val ACTION_SHUFFLE = "stemroller.SHUFFLE" + private const val ACTION_REPEAT = "stemroller.REPEAT" + private val ACTIONS = listOf(ACTION_VOCALS, ACTION_MIX, ACTION_SHUFFLE, ACTION_REPEAT) + + /** Tells Auto to show its (voice) search button. */ + private const val SEARCH_SUPPORTED = "android.media.browse.SEARCH_SUPPORTED" + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/plex/PlexClient.kt b/android/app/src/main/java/com/stemroller/mobile/plex/PlexClient.kt new file mode 100644 index 0000000..43b263b --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/plex/PlexClient.kt @@ -0,0 +1,253 @@ +package com.stemroller.mobile.plex + +import android.net.Uri +import android.os.Build +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.core.HttpException +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.core.await +import com.stemroller.mobile.core.awaitBody +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import okhttp3.HttpUrl +import okhttp3.HttpUrl.Companion.toHttpUrl +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.io.IOException + +class NotSignedInException : IOException("Not signed in to Plex") + +/** + * Plex Media Server and plex.tv calls. Library reads go through [http], whose cache + * answers from disk when the server can't be reached (see Graph). + */ +class PlexClient(private val http: OkHttpClient, private val settings: Settings) { + + val signedIn get() = settings.plexToken.value.isNotEmpty() + private val base get() = settings.plexUrl.value.trimEnd('/') + private val token get() = settings.plexToken.value + + private fun Request.Builder.plexHeaders(withToken: Boolean = true): Request.Builder { + header("Accept", "application/json") + header("X-Plex-Product", PRODUCT) + header("X-Plex-Version", "1.0") + header("X-Plex-Client-Identifier", settings.clientId) + header("X-Plex-Platform", "Android") + header("X-Plex-Platform-Version", Build.VERSION.RELEASE) + header("X-Plex-Device", Build.MODEL) + header("X-Plex-Device-Name", "$PRODUCT (${Build.MODEL})") + if (withToken && token.isNotEmpty()) header("X-Plex-Token", token) + return this + } + + private fun url(path: String, vararg params: Pair): HttpUrl { + val b = (base + path).toHttpUrl().newBuilder() + for ((k, v) in params) if (v != null) b.addQueryParameter(k, v.toString()) + return b.build() + } + + private suspend fun get(path: String, vararg params: Pair, start: Int? = null, size: Int? = null): MediaContainer { + if (!signedIn) throw NotSignedInException() + val req = Request.Builder().url(url(path, *params)).plexHeaders().apply { + if (start != null) header("X-Plex-Container-Start", start.toString()) + if (size != null) header("X-Plex-Container-Size", size.toString()) + }.build() + val body = http.newCall(req).awaitBody() + if (body.isBlank()) return MediaContainer() + return AppJson.decodeFromString(PlexResponse.serializer(), body).container + } + + private suspend fun send(method: String, path: String, vararg params: Pair): MediaContainer { + if (!signedIn) throw NotSignedInException() + val body = if (method == "DELETE") null else ByteArray(0).toRequestBody(null) + val req = Request.Builder().url(url(path, *params)).plexHeaders().method(method, body).build() + val text = http.newCall(req).awaitBody() + return if (text.isBlank() || !text.trimStart().startsWith("{")) MediaContainer() + else AppJson.decodeFromString(PlexResponse.serializer(), text).container + } + + /** Pages through a section listing; Plex caps a single response on big libraries. */ + private suspend fun all(path: String, vararg params: Pair): List { + val out = ArrayList() + var start = 0 + while (true) { + val page = get(path, *params, start = start, size = PAGE) + out += page.metadata + start += page.metadata.size + val total = page.totalSize ?: page.size + if (page.metadata.isEmpty() || start >= total) break + } + return out + } + + // ---- server ------------------------------------------------------------------- + + suspend fun machineId(): String { + val req = Request.Builder().url(url("/identity")).plexHeaders(false).build() + val body = http.newCall(req).awaitBody() + val id = AppJson.decodeFromString(PlexResponse.serializer(), body).container.machineIdentifier + return id ?: throw IOException("Not a Plex server") + } + + suspend fun musicSections(): List = get("/library/sections").directories + .filter { it.type == "artist" } + .map { MusicSection(it.key, it.title, it.locations.map { l -> l.path }) } + + private val section get() = settings.musicSection.value + + // ---- library ------------------------------------------------------------------ + + suspend fun artists(): List = + all("/library/sections/$section/all", "type" to 8, "sort" to "titleSort").map { it.toArtist() } + + suspend fun albums(sort: String = "titleSort"): List = + all("/library/sections/$section/all", "type" to 9, "sort" to sort).map { it.toAlbum() } + + suspend fun recentlyAdded(count: Int = 20): List = + get("/library/sections/$section/all", "type" to 9, "sort" to "addedAt:desc", start = 0, size = count) + .metadata.map { it.toAlbum() } + + /** One page of every track, sorted by title. Returns the page and the library's track count. */ + suspend fun tracksPage(start: Int, size: Int): Pair, Int> { + val c = get("/library/sections/$section/all", "type" to 10, "sort" to "titleSort", start = start, size = size) + return c.metadata.map { it.toTrack() } to (c.totalSize ?: c.size) + } + + suspend fun album(key: String): Album? = get("/library/metadata/$key").metadata.firstOrNull()?.toAlbum() + + suspend fun albumTracks(key: String): List = get("/library/metadata/$key/children").metadata.map { it.toTrack() } + + // Not /library/metadata//children: that leaves out compilations, singles and live + // albums (an artist with only "The Best of Kansas" came back empty). + suspend fun artistAlbums(key: String): List = + all("/library/sections/$section/all", "type" to 9, "artist.id" to key).map { it.toAlbum() } + + suspend fun artistTracks(key: String): List = get("/library/metadata/$key/allLeaves").metadata.map { it.toTrack() } + + suspend fun track(key: String): PlexItem? = get("/library/metadata/$key").metadata.firstOrNull() + + /** Title search inside the music section; used to give stem-only entries Plex metadata. */ + suspend fun searchTracks(title: String): List = + get("/library/sections/$section/search", "type" to 10, "query" to title).metadata.map { it.toTrack() } + + /** Plex's own loudness analysis (what Plexamp draws its waveform from), in dB. */ + suspend fun loudness(trackKey: String, samples: Int): FloatArray? { + val streamId = track(trackKey)?.media?.firstOrNull()?.parts?.firstOrNull() + ?.streams?.firstOrNull { it.streamType == 2 }?.id ?: return null + val levels = try { + get("/library/streams/$streamId/levels", "subsample" to samples).levels + } catch (e: HttpException) { + return null // not analysed yet + } + return if (levels.isEmpty()) null else FloatArray(levels.size) { levels[it].v } + } + + suspend fun search(query: String): SearchResults { + val hubs = get("/hubs/search", "query" to query, "limit" to 12, "sectionId" to section).hubs + fun hub(type: String) = hubs.firstOrNull { it.type == type }?.metadata.orEmpty() + return SearchResults( + artists = hub("artist").map { it.toArtist() }, + albums = hub("album").map { it.toAlbum() }, + tracks = hub("track").map { it.toTrack() }, + playlists = hub("playlist").filter { it.playlistType == "audio" }.map { it.toPlaylist() }, + ) + } + + // ---- playlists ---------------------------------------------------------------- + + suspend fun playlists(): List = get("/playlists", "playlistType" to "audio").metadata.map { it.toPlaylist() } + + suspend fun playlistTracks(key: String): List = all("/playlists/$key/items").map { it.toTrack() } + + private suspend fun libraryUri(keys: List): String { + var machine = settings.plexMachineId.value + if (machine.isEmpty()) machine = machineId().also { settings.plexMachineId.value = it } + return "server://$machine/com.plexapp.plugins.library/library/metadata/${keys.joinToString(",")}" + } + + suspend fun createPlaylist(title: String, trackKeys: List): Playlist? = + send("POST", "/playlists", "type" to "audio", "title" to title, "smart" to 0, "uri" to libraryUri(trackKeys)) + .metadata.firstOrNull()?.toPlaylist() + + suspend fun addToPlaylist(key: String, trackKeys: List) { + send("PUT", "/playlists/$key/items", "uri" to libraryUri(trackKeys)) + } + + suspend fun removeFromPlaylist(key: String, playlistItemId: Long) { + send("DELETE", "/playlists/$key/items/$playlistItemId") + } + + /** Moves an item to just after [afterItemId], or to the top when it's null. */ + suspend fun movePlaylistItem(key: String, playlistItemId: Long, afterItemId: Long?) { + send("PUT", "/playlists/$key/items/$playlistItemId/move", "after" to afterItemId) + } + + suspend fun renamePlaylist(key: String, title: String) { + send("PUT", "/playlists/$key", "title" to title) + } + + suspend fun deletePlaylist(key: String) { + send("DELETE", "/playlists/$key") + } + + // ---- playback reporting --------------------------------------------------------- + + suspend fun scrobble(trackKey: String) { + runCatching { get("/:/scrobble", "key" to trackKey, "identifier" to "com.plexapp.plugins.library") } + } + + suspend fun timeline(track: Track, state: String, positionMs: Long) { + runCatching { + get("/:/timeline", "ratingKey" to track.ratingKey, "key" to "/library/metadata/${track.ratingKey}", + "state" to state, "time" to positionMs, "duration" to track.durationMs, "hasMDE" to 1) + } + } + + // ---- URLs ----------------------------------------------------------------------- + + fun artUrl(thumb: String?, px: Int): String? { + if (thumb.isNullOrEmpty() || !signedIn) return null + return Uri.parse("$base/photo/:/transcode").buildUpon() + .appendQueryParameter("width", px.toString()) + .appendQueryParameter("height", px.toString()) + .appendQueryParameter("minSize", "1") + .appendQueryParameter("upscale", "1") + .appendQueryParameter("url", thumb) + .appendQueryParameter("X-Plex-Token", token) + .build().toString() + } + + fun partUrl(partKey: String): String = "$base$partKey?X-Plex-Token=${Uri.encode(token)}" + + // ---- plex.tv sign-in ------------------------------------------------------------ + + suspend fun createPin(): PlexPin { + val req = Request.Builder().url("https://plex.tv/api/v2/pins?strong=false").plexHeaders(false) + .post(ByteArray(0).toRequestBody(null)).build() + return AppJson.decodeFromString(PlexPin.serializer(), http.newCall(req).awaitBody()) + } + + suspend fun checkPin(id: Long): PlexPin { + val req = Request.Builder().url("https://plex.tv/api/v2/pins/$id").plexHeaders(false).build() + return AppJson.decodeFromString(PlexPin.serializer(), http.newCall(req).awaitBody()) + } + + suspend fun user(token: String): PlexUser { + val req = Request.Builder().url("https://plex.tv/api/v2/user").plexHeaders(false) + .header("X-Plex-Token", token).build() + return AppJson.decodeFromString(PlexUser.serializer(), http.newCall(req).awaitBody()) + } + + /** True if [url] answers as a Plex server with the current token. */ + suspend fun probe(url: String, token: String): Boolean = runCatching { + val req = Request.Builder().url(url.trimEnd('/') + "/library/sections").plexHeaders(false) + .header("X-Plex-Token", token).build() + withContext(Dispatchers.IO) { http.newCall(req).await().use { it.isSuccessful } } + }.getOrDefault(false) + + companion object { + const val PRODUCT = "StemRoller" + private const val PAGE = 1000 + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/plex/PlexModels.kt b/android/app/src/main/java/com/stemroller/mobile/plex/PlexModels.kt new file mode 100644 index 0000000..9c85978 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/plex/PlexModels.kt @@ -0,0 +1,220 @@ +package com.stemroller.mobile.plex + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.booleanOrNull + +// ---- wire format (Accept: application/json) -------------------------------------- + +@Serializable +data class PlexResponse(@SerialName("MediaContainer") val container: MediaContainer = MediaContainer()) + +@Serializable +data class MediaContainer( + val size: Int = 0, + val totalSize: Int? = null, + val machineIdentifier: String? = null, + @SerialName("Metadata") val metadata: List = emptyList(), + @SerialName("Directory") val directories: List = emptyList(), + @SerialName("Hub") val hubs: List = emptyList(), + @SerialName("Level") val levels: List = emptyList(), +) + +@Serializable +data class PlexItem( + val ratingKey: String = "", + val key: String = "", + val type: String = "", + val title: String = "", + val titleSort: String? = null, + val originalTitle: String? = null, + val parentTitle: String? = null, + val grandparentTitle: String? = null, + val parentRatingKey: String? = null, + val grandparentRatingKey: String? = null, + val index: Int? = null, + val parentIndex: Int? = null, + val duration: Long? = null, + val thumb: String? = null, + val parentThumb: String? = null, + val grandparentThumb: String? = null, + val composite: String? = null, + val year: Int? = null, + val parentYear: Int? = null, + /** Release date, "1975-11-14", when Plex knows the day. */ + val originallyAvailableAt: String? = null, + val addedAt: Long? = null, + val leafCount: Int? = null, + val playlistItemID: Long? = null, + val playlistType: String? = null, + /** Boolean in current servers, "0"/"1" in some older ones. */ + val smart: JsonPrimitive? = null, + @SerialName("Media") val media: List = emptyList(), + @SerialName("Genre") val genres: List = emptyList(), +) + +@Serializable +data class PlexMedia( + val id: Long = 0, + val duration: Long? = null, + val bitrate: Int? = null, + val audioCodec: String? = null, + val container: String? = null, + @SerialName("Part") val parts: List = emptyList(), +) + +@Serializable +data class PlexPart( + val id: Long = 0, + val key: String = "", + val duration: Long? = null, + val file: String? = null, + val size: Long? = null, + val container: String? = null, + @SerialName("Stream") val streams: List = emptyList(), +) + +@Serializable +data class PlexStream(val id: Long = 0, val streamType: Int = 0) + +@Serializable +data class PlexTag(val tag: String = "") + +@Serializable +data class PlexDirectory( + val key: String = "", + val type: String = "", + val title: String = "", + @SerialName("Location") val locations: List = emptyList(), +) + +@Serializable +data class PlexLocation(val path: String = "") + +@Serializable +data class PlexHub( + val type: String = "", + val hubIdentifier: String = "", + val title: String = "", + @SerialName("Metadata") val metadata: List = emptyList(), +) + +@Serializable +data class PlexLevel(val v: Float = 0f) + +@Serializable +data class PlexPin(val id: Long = 0, val code: String = "", val authToken: String? = null) + +@Serializable +data class PlexUser(val username: String? = null, val title: String? = null, val email: String? = null) + +// ---- app models ------------------------------------------------------------------ + +@Serializable +data class Track( + val ratingKey: String, + val title: String, + val artist: String, + val album: String, + val albumKey: String? = null, + val artistKey: String? = null, + val index: Int? = null, + val disc: Int? = null, + val durationMs: Long = 0, + val thumb: String? = null, + val partKey: String? = null, + val partId: Long? = null, + val partFile: String? = null, + val partSize: Long? = null, + val codec: String? = null, + val year: Int? = null, + val playlistItemId: Long? = null, + /** Set for tracks known only from the stems index (no Plex match): play this stem folder. */ + val stemKey: String? = null, +) + +@Serializable +data class Album( + val ratingKey: String, + val title: String, + val artist: String, + val artistKey: String? = null, + val year: Int? = null, + val thumb: String? = null, + val trackCount: Int? = null, + val genre: String? = null, + /** "1975-11-14" when Plex knows the release day. */ + val released: String? = null, +) + +@Serializable +data class Artist(val ratingKey: String, val title: String, val sortTitle: String, val thumb: String? = null) + +@Serializable +data class Playlist( + val ratingKey: String, + val title: String, + val thumb: String? = null, + val trackCount: Int = 0, + val durationMs: Long = 0, + val smart: Boolean = false, +) + +data class MusicSection(val key: String, val title: String, val locations: List) + +data class SearchResults( + val artists: List = emptyList(), + val albums: List = emptyList(), + val tracks: List = emptyList(), + val playlists: List = emptyList(), +) { + val isEmpty get() = artists.isEmpty() && albums.isEmpty() && tracks.isEmpty() && playlists.isEmpty() +} + +fun PlexItem.toTrack(): Track { + val media = media.firstOrNull() + val part = media?.parts?.firstOrNull() + return Track( + ratingKey = ratingKey, + title = title, + artist = originalTitle?.takeIf { it.isNotBlank() } ?: grandparentTitle ?: "Unknown Artist", + album = parentTitle ?: "", + albumKey = parentRatingKey, + artistKey = grandparentRatingKey, + index = index, + disc = parentIndex, + durationMs = duration ?: media?.duration ?: part?.duration ?: 0, + thumb = thumb ?: parentThumb ?: grandparentThumb, + partKey = part?.key, + partId = part?.id, + partFile = part?.file, + partSize = part?.size, + codec = media?.audioCodec ?: part?.container, + year = parentYear ?: year, + playlistItemId = playlistItemID, + ) +} + +fun PlexItem.toAlbum() = Album( + ratingKey = ratingKey, + title = title, + artist = parentTitle ?: "Unknown Artist", + artistKey = parentRatingKey, + year = year, + thumb = thumb, + trackCount = leafCount, + genre = genres.firstOrNull()?.tag, + released = originallyAvailableAt?.takeIf { it.length >= 10 }, +) + +fun PlexItem.toArtist() = Artist(ratingKey, title, titleSort ?: title, thumb) + +fun PlexItem.toPlaylist() = Playlist( + ratingKey = ratingKey, + title = title, + thumb = composite ?: thumb, + trackCount = leafCount ?: 0, + durationMs = duration ?: 0, + smart = smart?.booleanOrNull ?: (smart?.content == "1"), +) diff --git a/android/app/src/main/java/com/stemroller/mobile/stems/StemCoverage.kt b/android/app/src/main/java/com/stemroller/mobile/stems/StemCoverage.kt new file mode 100644 index 0000000..7c30cf2 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/stems/StemCoverage.kt @@ -0,0 +1,117 @@ +package com.stemroller.mobile.stems + +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.plex.PlexClient +import com.stemroller.mobile.plex.Track +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.serialization.Serializable +import java.io.File + +/** How many of an album's (or artist's) songs have stems. */ +data class Coverage(val total: Int, val withStems: Int) { + val none get() = total > 0 && withStems == 0 + val partial get() = withStems in 1 until total +} + +/** + * Which albums and artists have stems. Plex albums carry no file paths, so this keeps a slim + * copy of every track's path (fetched in pages, cached on disk, refreshed every few hours) and + * matches it against the stems index whenever that changes. Until the first full listing + * arrives [ready] is false and nothing is flagged. + */ +class StemCoverage( + private val plex: PlexClient, + private val stems: StemServer, + private val settings: Settings, + dir: File, + private val scope: CoroutineScope, +) { + @Serializable + private data class Slim(val k: String, val al: String? = null, val ar: String? = null, val f: String? = null, val d: Long = 0) + + @Serializable + private data class Listing(val section: String, val at: Long, val tracks: List) + + private val file = File(dir, "library_tracks.json") + private val lock = Mutex() + @Volatile private var listing: Listing? = null + + private val _albums = MutableStateFlow>(emptyMap()) + val albums: StateFlow> = _albums.asStateFlow() + private val _artists = MutableStateFlow>(emptyMap()) + val artists: StateFlow> = _artists.asStateFlow() + private val _ready = MutableStateFlow(false) + /** True once the whole library has been listed and matched against a non-empty stems index. */ + val ready: StateFlow = _ready.asStateFlow() + + init { + scope.launch(Dispatchers.IO) { + listing = runCatching { AppJson.decodeFromString(Listing.serializer(), file.readText()) }.getOrNull() + settings.musicSection.flow.collectLatest { section -> + if (section.isEmpty()) return@collectLatest + val l = listing + if (l == null || l.section != section || System.currentTimeMillis() - l.at > STALE_MS) refresh() + } + } + scope.launch(Dispatchers.Default) { + stems.index.collectLatest { recompute() } + } + } + + /** Lists every track in the library again (every few hours). */ + suspend fun refresh() = lock.withLock { + val section = settings.musicSection.value + if (section.isEmpty() || !plex.signedIn) return@withLock + val all = ArrayList() + runCatching { + var start = 0 + while (true) { + val (page, total) = plex.tracksPage(start, PAGE) + all += page.map { Slim(it.ratingKey, it.albumKey, it.artistKey, it.partFile, it.durationMs) } + start += page.size + if (page.isEmpty() || start >= total) break + } + }.onFailure { return@withLock } + val l = Listing(section, System.currentTimeMillis(), all) + listing = l + withContext(Dispatchers.IO) { + runCatching { + val tmp = File(file.parentFile, file.name + ".tmp") + tmp.writeText(AppJson.encodeToString(Listing.serializer(), l)) + tmp.renameTo(file) + } + } + recompute() + } + + private fun recompute() { + val l = listing ?: return + if (l.section != settings.musicSection.value) return + if (stems.index.value.size == 0) return + val albums = HashMap() + val artists = HashMap() + for (t in l.tracks) { + val has = stems.find(Track(t.k, "", "", "", partFile = t.f, durationMs = t.d)) != null + t.al?.let { albums.getOrPut(it) { IntArray(2) }.also { c -> c[0]++; if (has) c[1]++ } } + t.ar?.let { artists.getOrPut(it) { IntArray(2) }.also { c -> c[0]++; if (has) c[1]++ } } + } + _albums.value = albums.mapValues { (_, c) -> Coverage(c[0], c[1]) } + _artists.value = artists.mapValues { (_, c) -> Coverage(c[0], c[1]) } + _ready.value = true + } + + private companion object { + const val PAGE = 1000 + const val STALE_MS = 6 * 3600_000L + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/stems/StemIndex.kt b/android/app/src/main/java/com/stemroller/mobile/stems/StemIndex.kt new file mode 100644 index 0000000..6c13aea --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/stems/StemIndex.kt @@ -0,0 +1,85 @@ +package com.stemroller.mobile.stems + +import kotlinx.serialization.Serializable +import java.text.Normalizer +import kotlin.math.abs + +@Serializable +data class StemFile(val name: String, val file: String, val size: Long, val mtime: Long = 0) + +@Serializable +data class StemEntry( + val key: String, + val source: String, + val duration: Double? = null, + val samplerate: Int? = null, + val model: String? = null, + val finished: Double? = null, + val stems: List = emptyList(), +) { + /** "Artist/Album/01 Song" -> "01 Song" etc., for stem-only browsing. */ + val title get() = key.substringAfterLast('/') + val folder get() = key.substringBeforeLast('/', "") +} + +@Serializable +data class StemIndexFile(val version: Int = 1, val tracks: List = emptyList()) + +/** + * Maps Plex file paths to stem folders. The stems folder mirrors the music folder, so the + * source path relative to the music root identifies a track; Plex reports absolute paths + * as its container sees them, so the root is unknown up front. + * + * Matching tries every suffix of the Plex path, longest first. A suffix that is only a + * file name, or whose duration disagrees, is accepted only under a root prefix learned + * from an earlier, longer match, so "Intro.flac" in one album can't grab another's stems. + */ +class StemIndex(val entries: List, roots: Collection = emptyList()) { + private val bySource = HashMap(entries.size * 2) + private val learned = LinkedHashSet(roots) + + init { + for (e in entries) bySource.putIfAbsent(norm(e.source), e) + } + + val size get() = entries.size + val roots: Set @Synchronized get() = learned.toSet() + + /** Returns the entry for a Plex part path, learning the path's root on a confident match. */ + @Synchronized + fun find(plexPath: String?, durationMs: Long = 0): StemEntry? { + if (plexPath.isNullOrEmpty() || entries.isEmpty()) return null + val path = norm(plexPath) + for (root in learned) { + if (path.startsWith(root)) bySource[path.substring(root.length)]?.let { return it } + } + val parts = path.split('/') + for (i in 1 until parts.size) { + val rel = parts.subList(i, parts.size).joinToString("/") + val hit = bySource[rel] ?: continue + val deep = parts.size - i >= 2 + if (deep && durationMatches(hit, durationMs)) { + learned += parts.subList(0, i).joinToString("/", postfix = "/") + return hit + } + } + return null + } + + private fun durationMatches(e: StemEntry, durationMs: Long): Boolean { + val d = e.duration ?: return true + if (durationMs <= 0) return true + return abs(d * 1000 - durationMs) < 3000 + } + + companion object { + /** NFC, forward slashes, no extension, lower case. */ + fun norm(path: String): String { + var p = Normalizer.normalize(path, Normalizer.Form.NFC).replace('\\', '/') + val slash = p.lastIndexOf('/') + val dot = p.lastIndexOf('.') + if (dot > slash + 1) p = p.substring(0, dot) + return p.lowercase() + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/stems/StemServer.kt b/android/app/src/main/java/com/stemroller/mobile/stems/StemServer.kt new file mode 100644 index 0000000..62c6569 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/stems/StemServer.kt @@ -0,0 +1,196 @@ +package com.stemroller.mobile.stems + +import android.net.Uri +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.core.HttpException +import com.stemroller.mobile.core.Settings +import com.stemroller.mobile.core.StemQuality +import com.stemroller.mobile.core.await +import com.stemroller.mobile.core.awaitBody +import com.stemroller.mobile.plex.Track +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.int +import kotlinx.serialization.json.jsonArray +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.io.File + +sealed interface StemServerStatus { + data object Unknown : StemServerStatus + data class Online(val tracks: Int, val transcode: Boolean) : StemServerStatus + data class Offline(val reason: String, val cachedTracks: Int) : StemServerStatus +} + +@Serializable +private data class StemRequest(val paths: List) + +@Serializable +private data class ServerInfo(val name: String = "", val version: Int = 0, val tracks: Int = 0, val ffmpeg: Boolean = false) + +/** Client for server/stemserve.py: the stems index, stem file URLs and waveforms. */ +class StemServer( + private val http: OkHttpClient, + private val settings: Settings, + private val dir: File, + private val scope: CoroutineScope, +) { + private val indexFile = File(dir, "stem_index.json") + private val etagFile = File(dir, "stem_index.etag") + private val refreshLock = Mutex() + + private val _index = MutableStateFlow(StemIndex(emptyList())) + val index: StateFlow = _index.asStateFlow() + private val _status = MutableStateFlow(StemServerStatus.Unknown) + val status: StateFlow = _status.asStateFlow() + private var transcode = false + + private val base get() = settings.stemUrl.value.trimEnd('/') + private fun roots() = settings.stemRoots.value.split('\n').filter { it.isNotEmpty() } + + /** When the index was last checked against the server (epoch ms), 0 before the first check. */ + private val _checkedAt = MutableStateFlow(0L) + val checkedAt: StateFlow = _checkedAt.asStateFlow() + + init { + scope.launch(Dispatchers.IO) { + runCatching { + if (indexFile.exists()) { + val parsed = AppJson.decodeFromString(StemIndexFile.serializer(), indexFile.readText()) + _index.value = StemIndex(parsed.tracks, roots()) + } + } + // stemd on the server separates new music around the clock; look for its new stems + // every minute. Unchanged indexes cost one 304. + while (true) { + refresh() + delay(CHECK_MS) + } + } + } + + private fun Request.Builder.auth(): Request.Builder { + val t = settings.stemToken.value + if (t.isNotEmpty()) header("X-Stem-Token", t) + return this + } + + suspend fun refresh(force: Boolean = false) = withContext(Dispatchers.IO) { + refreshLock.withLock { + try { + val info = AppJson.decodeFromString( + ServerInfo.serializer(), + http.newCall(Request.Builder().url("$base/api/info").auth().build()).awaitBody(), + ) + transcode = info.ffmpeg + val etag = if (!force && etagFile.exists() && indexFile.exists()) etagFile.readText() else null + val req = Request.Builder().url("$base/api/index").auth() + .apply { if (etag != null) header("If-None-Match", etag) }.build() + http.newCall(req).await().use { r -> + when { + r.code == 304 -> Unit + r.isSuccessful -> { + val body = r.body?.string().orEmpty() + val parsed = AppJson.decodeFromString(StemIndexFile.serializer(), body) + _index.value = StemIndex(parsed.tracks, roots()) + indexFile.writeText(body) + r.header("ETag")?.let { etagFile.writeText(it) } + } + else -> throw HttpException(r.code, "stemserve answered ${r.code}") + } + } + _status.value = StemServerStatus.Online(_index.value.size, info.ffmpeg) + _checkedAt.value = System.currentTimeMillis() + } catch (e: Exception) { + _status.value = StemServerStatus.Offline(e.message ?: e.javaClass.simpleName, _index.value.size) + } + } + } + + fun find(track: Track): StemEntry? { + val idx = _index.value + track.stemKey?.let { k -> return idx.entries.firstOrNull { it.key == k } } + val hit = idx.find(track.partFile, track.durationMs) + val learned = idx.roots.joinToString("\n") + if (learned != settings.stemRoots.value) settings.stemRoots.value = learned + return hit + } + + /** Format the server will actually send: Opus needs ffmpeg there. */ + fun effectiveQuality(q: StemQuality) = if (q.fmt == "opus" && !transcode && _status.value is StemServerStatus.Online) StemQuality.Lossless else q + + fun fileUrl(entry: StemEntry, stem: StemFile, quality: StemQuality): String { + val b = Uri.parse(base).buildUpon().appendPath("file") + entry.key.split('/').forEach { b.appendPath(it) } + b.appendPath(stem.file) + if (quality.fmt == "opus") b.appendQueryParameter("fmt", "opus").appendQueryParameter("br", quality.kbps.toString()) + settings.stemToken.value.takeIf { it.isNotEmpty() }?.let { b.appendQueryParameter("token", it) } + return b.build().toString() + } + + /** Asks the server to start the Opus transcodes now, so the stems are ready when we need them. */ + fun prepare(entry: StemEntry, quality: StemQuality) { + if (quality.fmt != "opus") return + scope.launch(Dispatchers.IO) { + runCatching { + val url = Uri.parse("$base/api/prepare").buildUpon().appendQueryParameter("key", entry.key) + .appendQueryParameter("fmt", "opus").appendQueryParameter("br", quality.kbps.toString()).build() + http.newCall(Request.Builder().url(url.toString()).auth().post(ByteArray(0).toRequestBody(null)).build()) + .await().close() + } + } + } + + /** + * "Stem Now": asks stemd (through stemserve) to separate these songs before the rest of the + * library. Returns how many it queued: the ones with no stems yet. + */ + suspend fun stemNow(tracks: List): Int = withContext(Dispatchers.IO) { + val paths = tracks.filter { find(it) == null }.mapNotNull { it.partFile }.distinct() + if (paths.isEmpty()) return@withContext 0 + val body = AppJson.encodeToString(StemRequest.serializer(), StemRequest(paths)).toRequestBody("application/json".toMediaType()) + http.newCall(Request.Builder().url("$base/api/stem").auth().post(body).build()).await().use { r -> + if (!r.isSuccessful) { + val msg = runCatching { AppJson.parseToJsonElement(r.body!!.string()).jsonObject["error"]!!.jsonPrimitive.content }.getOrNull() + throw HttpException(r.code, when { + r.code == 404 -> "stemserve needs updating for Stem Now" + msg != null -> msg + else -> "stemserve answered ${r.code}" + }) + } + } + paths.size + } + + /** Per-stem RMS envelopes (0..1 of full scale), [buckets] values each. */ + suspend fun peaks(entry: StemEntry, buckets: Int): Map? = withContext(Dispatchers.IO) { + runCatching { + val url = Uri.parse("$base/api/peaks").buildUpon().appendQueryParameter("key", entry.key) + .appendQueryParameter("n", buckets.toString()).build() + val body = http.newCall(Request.Builder().url(url.toString()).auth().build()).awaitBody() + val stems = AppJson.parseToJsonElement(body).jsonObject["stems"] as JsonObject + stems.mapValues { (_, arr) -> + val a = arr.jsonArray + FloatArray(a.size) { a[it].jsonPrimitive.int / 1000f } + } + }.getOrNull() + } + + private companion object { + const val CHECK_MS = 60_000L + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/Root.kt b/android/app/src/main/java/com/stemroller/mobile/ui/Root.kt new file mode 100644 index 0000000..f2889ef --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/Root.kt @@ -0,0 +1,318 @@ +package com.stemroller.mobile.ui + +import androidx.activity.compose.PredictiveBackHandler +import androidx.compose.animation.core.AnimationSpec +import androidx.compose.animation.core.animate +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.gestures.detectVerticalDragGestures +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.statusBars +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.Stable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.key +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveableStateHolder +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.drawWithContent +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.input.pointer.util.VelocityTracker +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.stemroller.mobile.App +import com.stemroller.mobile.ui.components.Hairline +import com.stemroller.mobile.ui.components.LocalBottomInset +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.OverlayHost +import com.stemroller.mobile.ui.components.Overlays +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.nav.NavStack +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.nav.StackHost +import com.stemroller.mobile.ui.screens.AlbumScreen +import com.stemroller.mobile.ui.screens.EqFilterScreen +import com.stemroller.mobile.ui.screens.EqFiltersScreen +import com.stemroller.mobile.ui.screens.AlbumsScreen +import com.stemroller.mobile.ui.screens.AppActions +import com.stemroller.mobile.ui.screens.AppearanceScreen +import com.stemroller.mobile.ui.screens.ArtistScreen +import com.stemroller.mobile.ui.screens.ArtistsScreen +import com.stemroller.mobile.ui.screens.DownloadsScreen +import com.stemroller.mobile.ui.screens.EqScreen +import com.stemroller.mobile.ui.screens.LibraryHome +import com.stemroller.mobile.ui.screens.LocalApp +import com.stemroller.mobile.ui.screens.MiniPlayer +import com.stemroller.mobile.ui.screens.NowPlayingScreen +import com.stemroller.mobile.ui.screens.PlaylistScreen +import com.stemroller.mobile.ui.screens.PlaylistsScreen +import com.stemroller.mobile.ui.screens.PlexAccountScreen +import com.stemroller.mobile.ui.screens.QualityScreen +import com.stemroller.mobile.ui.screens.SearchScreen +import com.stemroller.mobile.ui.screens.SettingsScreen +import com.stemroller.mobile.ui.screens.SongsScreen +import com.stemroller.mobile.ui.screens.StemServerScreen +import com.stemroller.mobile.ui.screens.StorageScreen +import com.stemroller.mobile.ui.screens.Tab +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.IosTheme +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Job +import kotlinx.coroutines.launch + +@Composable +private fun Screen(route: Route) = when (route) { + Route.Library -> LibraryHome() + Route.Artists -> ArtistsScreen() + Route.Albums -> AlbumsScreen() + Route.Songs -> SongsScreen() + Route.Downloads -> DownloadsScreen() + Route.Playlists -> PlaylistsScreen() + Route.Search -> SearchScreen() + Route.Eq -> EqScreen() + is Route.EqFilters -> EqFiltersScreen(route.profileId) + is Route.EqFilterPage -> EqFilterScreen(route.profileId, route.filterId) + Route.Settings -> SettingsScreen() + Route.PlexAccount -> PlexAccountScreen() + Route.StemServer -> StemServerScreen() + Route.Quality -> QualityScreen() + Route.Storage -> StorageScreen() + Route.Appearance -> AppearanceScreen() + is Route.ArtistPage -> ArtistScreen(route.artist) + is Route.AlbumPage -> AlbumScreen(route.album) + is Route.PlaylistPage -> PlaylistScreen(route.playlist) +} + +private fun rootOf(tab: Tab) = when (tab) { + Tab.Library -> Route.Library + Tab.Playlists -> Route.Playlists + Tab.Search -> Route.Search + Tab.Downloads -> Route.Downloads + Tab.Settings -> Route.Settings +} + +/** The Now Playing card's position: 0 hidden, 1 fully up. Driven by springs, drags and back swipes. */ +@Stable +class SheetState(private val scope: CoroutineScope) { + var progress by mutableFloatStateOf(0f) + private var job: Job? = null + + fun animateTo(target: Float, velocity: Float = 0f, spec: AnimationSpec = spring(dampingRatio = 0.88f, stiffness = 380f)) { + job?.cancel() + job = scope.launch { animate(progress, target, velocity, spec) { v, _ -> progress = v.coerceIn(0f, 1f) } } + } + + fun snap(v: Float) { + job?.cancel() + progress = v.coerceIn(0f, 1f) + } +} + +@Composable +fun StemApp(openNowPlaying: Int) { + val g = App.graph + val theme by g.settings.theme.flow.collectAsState() + val accent by g.settings.accent.flow.collectAsState() + IosTheme(theme, accent) { Shell(openNowPlaying) } +} + +@Composable +private fun Shell(openNowPlaying: Int) { + val g = App.graph + val c = Ios.colors + val scope = rememberCoroutineScope() + val overlays = remember { Overlays() } + val holder = rememberSaveableStateHolder() + val stacks = remember { Tab.entries.associateWith { NavStack(rootOf(it)) } } + var tab by remember { mutableStateOf(Tab.Library) } + val sheet = remember { SheetState(scope) } + val sheetShown by remember { derivedStateOf { sheet.progress > 0.001f } } + val current by g.playback.current.collectAsState() + val density = LocalDensity.current + val navBottom = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + val statusTop = WindowInsets.statusBars.asPaddingValues().calculateTopPadding() + + val actions = remember { + AppActions( + openNowPlaying = { sheet.animateTo(1f) }, + closeNowPlaying = { sheet.animateTo(0f) }, + selectTab = { tab = it }, + showInLibrary = { r -> + sheet.animateTo(0f) + tab = Tab.Library + stacks.getValue(Tab.Library).push(r) + }, + showInSettings = { r -> + sheet.animateTo(0f) + tab = Tab.Settings + val st = stacks.getValue(Tab.Settings) + if (st.entries.last().route != r) st.push(r) + }, + ) + } + LaunchedEffect(openNowPlaying) { if (openNowPlaying > 0 && g.playback.current.value != null) sheet.animateTo(1f) } + LaunchedEffect(Unit) { g.playback.messages.collect { overlays.hud(it, Sym.warning) } } + + val bottomInset = navBottom + 50.dp + if (current != null) 64.dp else 0.dp + + CompositionLocalProvider(LocalOverlays provides overlays, LocalApp provides actions, LocalBottomInset provides bottomInset) { + BoxWithConstraints(Modifier.fillMaxSize().background(Color.Black)) { + val heightPx = constraints.maxHeight.toFloat() + val sheetDrag = Modifier.pointerInput(Unit) { + val tracker = VelocityTracker() + var y = 0f + detectVerticalDragGestures( + onDragStart = { tracker.resetTracking(); y = 0f }, + onDragEnd = { + val v = tracker.calculateVelocity().y + if (v > 900f || sheet.progress < 0.7f) sheet.animateTo(0f, -v / heightPx) else sheet.animateTo(1f, -v / heightPx) + }, + onDragCancel = { sheet.animateTo(1f) }, + ) { ch, dy -> + // The sheet moves with the finger, so track the finger in screen terms. + y += dy + tracker.addPosition(ch.uptimeMillis, androidx.compose.ui.geometry.Offset(0f, y)) + ch.consume() + sheet.snap(sheet.progress - dy / heightPx) + } + } + val miniDrag = Modifier.pointerInput(Unit) { + val tracker = VelocityTracker() + var y = 0f + detectVerticalDragGestures( + onDragStart = { tracker.resetTracking(); y = 0f }, + onDragEnd = { + val v = tracker.calculateVelocity().y + if (v < -700f || sheet.progress > 0.3f) sheet.animateTo(1f, -v / heightPx) else sheet.animateTo(0f, -v / heightPx) + }, + onDragCancel = { sheet.animateTo(0f) }, + ) { ch, dy -> + // The sheet moves with the finger, so track the finger in screen terms. + y += dy + tracker.addPosition(ch.uptimeMillis, androidx.compose.ui.geometry.Offset(0f, y)) + ch.consume() + sheet.snap(sheet.progress - dy / heightPx) + } + } + + // The app, which recedes into a card while Now Playing is up. + Box( + Modifier.fillMaxSize() + .graphicsLayer { + val p = sheet.progress + val s = 1f - 0.075f * p + scaleX = s; scaleY = s + translationY = statusTop.toPx() * 0.55f * p + shape = RoundedCornerShape((14f * p).dp) + clip = p > 0f + } + .background(c.bg) + .drawWithContent { + drawContent() + val p = sheet.progress + if (p > 0f) drawRect(Color.Black.copy(alpha = 0.4f * p)) + }, + ) { + key(tab) { + holder.SaveableStateProvider("tab:${tab.name}") { + StackHost(stacks.getValue(tab), holder, active = true) { route -> Screen(route) } + } + } + Column(Modifier.align(Alignment.BottomCenter).fillMaxWidth()) { + if (current != null) MiniPlayer(onOpen = { sheet.animateTo(1f) }, dragModifier = miniDrag) + TabBar(tab, navBottom) { t -> + if (t == tab) stacks.getValue(t).popToRoot() else tab = t + } + } + } + + if (sheetShown) { + Box( + Modifier.fillMaxSize().padding(top = statusTop + 6.dp) + .graphicsLayer { + translationY = (1f - sheet.progress) * (heightPx + 40f) + shape = RoundedCornerShape(topStart = 14.dp, topEnd = 14.dp) + clip = true + }, + ) { + NowPlayingScreen(onClose = { sheet.animateTo(0f) }, dragModifier = sheetDrag) + } + // Predictive back slides the card down with the gesture; release to dismiss. + PredictiveBackHandler(enabled = sheetShown) { events -> + try { + events.collect { e -> sheet.snap(1f - 0.3f * e.progress) } + sheet.animateTo(0f, spec = tween(220)) + } catch (e: CancellationException) { + sheet.animateTo(1f) + throw e + } + } + } + + OverlayHost(overlays) + } + } +} + +@Composable +private fun TabBar(selected: Tab, navBottom: androidx.compose.ui.unit.Dp, onSelect: (Tab) -> Unit) { + val c = Ios.colors + Column(Modifier.fillMaxWidth().background(c.bar)) { + Hairline(color = c.barBorder) + Row(Modifier.fillMaxWidth().height(50.dp)) { + Tab.entries.forEach { t -> + val on = t == selected + val col = if (on) c.accent else c.tabInactive + Column( + Modifier.weight(1f).height(50.dp).tappable { onSelect(t) }.padding(top = 5.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Icon( + when (t) { + Tab.Library -> Sym.library + Tab.Playlists -> Sym.noteList + Tab.Search -> Sym.search + Tab.Downloads -> Sym.download + Tab.Settings -> Sym.gear + }, + col, size = 26.dp, + ) + Spacer(Modifier.height(2.dp)) + Txt(t.label, Type.caption2.copy(fontSize = 10.sp), color = col, weight = FontWeight.Medium) + } + } + } + Spacer(Modifier.height(navBottom)) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/components/Chrome.kt b/android/app/src/main/java/com/stemroller/mobile/ui/components/Chrome.kt new file mode 100644 index 0000000..42a0882 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/components/Chrome.kt @@ -0,0 +1,393 @@ +package com.stemroller.mobile.ui.components + +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxScope +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.RowScope +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBars +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.lazy.LazyListState +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicTextField +import androidx.compose.foundation.text.KeyboardActions +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.runtime.Composable +import androidx.compose.runtime.compositionLocalOf +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.drawBehind +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Shape +import androidx.compose.ui.graphics.SolidColor +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.platform.LocalFocusManager +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import coil3.compose.AsyncImage +import com.stemroller.mobile.App +import com.stemroller.mobile.ui.nav.LocalEntry +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlin.math.ceil + +/** Height of the tab bar plus mini player, so lists can scroll clear of them. */ +val LocalBottomInset = compositionLocalOf { 0.dp } + +const val MARGIN = 20 + +/** + * A navigation-controller page: large title that collapses into the bar as you scroll, + * back button titled after the previous page, bar background only once content is under it. + */ +@Composable +fun Page( + title: String, + modifier: Modifier = Modifier, + grouped: Boolean = false, + largeTitle: Boolean = true, + state: LazyListState = rememberLazyListState(), + trailing: @Composable RowScope.() -> Unit = {}, + leading: (@Composable RowScope.() -> Unit)? = null, + overlay: @Composable BoxScope.() -> Unit = {}, + content: LazyListScope.() -> Unit, +) { + val c = Ios.colors + val nav = LocalNav.current + val entry = LocalEntry.current + val idx = nav.entries.indexOf(entry) + val backTitle = if (idx > 0) nav.entries[idx - 1].route.title else null + val top = WindowInsets.statusBars.asPaddingValues().calculateTopPadding() + val collapsePx = with(LocalDensity.current) { 40.dp.toPx() } + val collapsed by remember(state, largeTitle) { + derivedStateOf { !largeTitle || state.firstVisibleItemIndex > 0 || state.firstVisibleItemScrollOffset > collapsePx } + } + val under by remember(state) { derivedStateOf { state.firstVisibleItemIndex > 0 || state.firstVisibleItemScrollOffset > 0 } } + val pastHeader by remember(state) { derivedStateOf { state.firstVisibleItemIndex > 0 } } + val bg = if (grouped) c.groupedBg else c.bg + + Box(modifier.fillMaxSize().background(bg)) { + // Settings-style (grouped) pages are laid out to fit the screen; they only scroll if + // something (a big font size, say) makes them overflow. + val overflows by remember(state) { derivedStateOf { state.canScrollForward || state.canScrollBackward } } + LazyColumn( + state = state, + modifier = Modifier.fillMaxSize(), + userScrollEnabled = !grouped || overflows, + contentPadding = PaddingValues(top = top + 44.dp, bottom = LocalBottomInset.current + 28.dp), + ) { + if (largeTitle) { + item(key = "__largeTitle") { + Box(Modifier.fillMaxWidth().height(60.dp).padding(start = MARGIN.dp, end = MARGIN.dp, bottom = 8.dp), contentAlignment = Alignment.BottomStart) { + Txt(title, Type.largeTitle) + } + } + } + content() + } + NavBar( + title = title, + showTitle = if (largeTitle) collapsed else pastHeader, + showBar = if (largeTitle) collapsed else under, + backTitle = backTitle, + onBack = { nav.pop() }, + leading = leading, + trailing = trailing, + bg = bg, + top = top, + ) + overlay() + } +} + +@Composable +fun NavBar( + title: String, + showTitle: Boolean, + showBar: Boolean, + backTitle: String?, + onBack: () -> Unit, + leading: (@Composable RowScope.() -> Unit)?, + trailing: @Composable RowScope.() -> Unit, + bg: Color, + top: Dp, +) { + val c = Ios.colors + val titleAlpha by animateFloatAsState(if (showTitle) 1f else 0f, tween(160), label = "title") + val barAlpha by animateFloatAsState(if (showBar) 1f else 0f, tween(160), label = "bar") + val bar = c.bar + Box( + Modifier.fillMaxWidth().height(top + 44.dp).drawBehind { + drawRect(bg) + drawRect(bar.copy(alpha = barAlpha)) + drawLine(c.barBorder.copy(alpha = barAlpha), Offset(0f, size.height - 0.5f), Offset(size.width, size.height - 0.5f), 1f) + }, + ) { + Txt( + title, Type.headline, + Modifier.align(Alignment.BottomCenter).padding(bottom = 11.dp).widthIn(max = 220.dp).graphicsLayer { alpha = titleAlpha }, + align = TextAlign.Center, + ) + Row( + Modifier.align(Alignment.BottomStart).fillMaxWidth().height(44.dp).padding(horizontal = 6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + if (backTitle != null) BackButton(backTitle, onBack) else leading?.invoke(this) + Spacer(Modifier.weight(1f)) + trailing() + } + } +} + +@Composable +fun BackButton(title: String, onBack: () -> Unit) { + val c = Ios.colors + Row(Modifier.height(44.dp).pressFade(onClick = onBack).padding(end = 8.dp), verticalAlignment = Alignment.CenterVertically) { + Icon(Sym.chevronLeft, c.accent, size = 24.dp) + Txt(if (title.length > 14) "Back" else title, Type.body, color = c.accent) + } +} + +// ---- inset grouped lists ---------------------------------------------------------------------- + +/** One UITableView inset-grouped section; [rows] are drawn as one rounded card. */ +fun LazyListScope.section( + key: String, + header: String? = null, + footer: String? = null, + separatorInset: Dp = 16.dp, + rows: List<@Composable () -> Unit>, +) { + item(key = "$key.header") { + if (header != null) { + Txt(header.uppercase(), Type.footnote, Modifier.padding(start = 36.dp, end = 36.dp, top = 18.dp, bottom = 6.dp), color = Ios.colors.label2) + } else { + Spacer(Modifier.height(18.dp)) + } + } + items(rows.size, key = { "$key.$it" }) { i -> + val last = i == rows.lastIndex + val shape: Shape = when { + rows.size == 1 -> RoundedCornerShape(12.dp) + i == 0 -> RoundedCornerShape(topStart = 12.dp, topEnd = 12.dp) + last -> RoundedCornerShape(bottomStart = 12.dp, bottomEnd = 12.dp) + else -> RoundedCornerShape(0.dp) + } + Box(Modifier.padding(horizontal = 16.dp).clip(shape).background(Ios.colors.cell)) { + rows[i]() + if (!last) Hairline(Modifier.align(Alignment.BottomStart).padding(start = separatorInset)) + } + } + if (footer != null) { + item(key = "$key.footer") { + Txt(footer, Type.footnote, Modifier.padding(start = 36.dp, end = 36.dp, top = 6.dp), color = Ios.colors.label2, maxLines = 6) + } + } +} + +/** A table cell: optional icon, title/subtitle, grey value, then chevron / check / custom accessory. */ +@Composable +fun Cell( + title: String, + modifier: Modifier = Modifier, + subtitle: String? = null, + value: String? = null, + icon: (@Composable () -> Unit)? = null, + titleColor: Color = Ios.colors.label, + chevron: Boolean = false, + checked: Boolean = false, + centered: Boolean = false, + trailing: (@Composable () -> Unit)? = null, + onLongClick: (() -> Unit)? = null, + onClick: (() -> Unit)? = null, +) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + Row( + modifier.fillMaxWidth().heightIn(min = if (subtitle != null) 56.dp else 44.dp) + .background(if (pressed && onClick != null) c.cellPressed else Color.Transparent) + .then(if (onClick != null) Modifier.tappable(onLongClick = onLongClick, interaction = src, onClick = onClick) else Modifier) + .padding(horizontal = 16.dp, vertical = 8.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = if (centered) Arrangement.Center else Arrangement.Start, + ) { + if (icon != null) { + icon() + Spacer(Modifier.width(14.dp)) + } + Column(if (centered) Modifier else Modifier.weight(1f)) { + Txt(title, Type.body, color = titleColor) + if (subtitle != null) Txt(subtitle, Type.footnote, color = c.label2, maxLines = 2) + } + if (value != null) { + Spacer(Modifier.width(8.dp)) + Txt(value, Type.body, color = c.label2, modifier = Modifier.widthIn(max = 200.dp)) + } + if (trailing != null) { + Spacer(Modifier.width(8.dp)) + trailing() + } + if (checked) { + Spacer(Modifier.width(8.dp)) + Icon(Sym.check, c.accent, size = 18.dp) + } + if (chevron) { + Spacer(Modifier.width(8.dp)) + Chevron() + } + } +} + +/** Settings.app-style coloured rounded-square icon. */ +@Composable +fun SettingsIcon(vector: ImageVector, bg: Color) { + Box(Modifier.size(30.dp).clip(RoundedCornerShape(7.dp)).background(bg), contentAlignment = Alignment.Center) { + Icon(vector, Color.White, size = 19.dp) + } +} + +/** Section title with an optional accent action, as in Apple Music ("Recently Added"). */ +@Composable +fun SectionTitle(title: String, action: String? = null, onAction: () -> Unit = {}) { + Row( + Modifier.fillMaxWidth().padding(start = MARGIN.dp, end = 12.dp, top = 22.dp, bottom = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Txt(title, Type.title2, Modifier.weight(1f)) + if (action != null) TextButton(action, onAction) + } +} + +@Composable +fun SearchField( + value: String, + onChange: (String) -> Unit, + modifier: Modifier = Modifier, + placeholder: String = "Search", + onSubmit: () -> Unit = {}, +) { + val c = Ios.colors + val focus = LocalFocusManager.current + Row( + modifier.fillMaxWidth().height(38.dp).clip(RoundedCornerShape(11.dp)).background(c.fill).padding(horizontal = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Icon(Sym.search, c.label2, size = 18.dp) + Spacer(Modifier.width(6.dp)) + Box(Modifier.weight(1f), contentAlignment = Alignment.CenterStart) { + if (value.isEmpty()) Txt(placeholder, Type.body, color = c.label2) + BasicTextField( + value = value, onValueChange = onChange, singleLine = true, + textStyle = Type.body.copy(color = c.label), cursorBrush = SolidColor(c.accent), + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search), + keyboardActions = KeyboardActions(onSearch = { focus.clearFocus(); onSubmit() }), + modifier = Modifier.fillMaxWidth(), + ) + } + if (value.isNotEmpty()) { + Box(Modifier.size(18.dp).clip(CircleShape).background(c.label3).tappable { onChange("") }, contentAlignment = Alignment.Center) { + Icon(Sym.xmark, c.fill, size = 12.dp) + } + } + } +} + +// ---- artwork, tiles, rows ------------------------------------------------------------------------ + +/** Plex artwork through the photo transcoder, sized to the device's pixels. */ +@Composable +fun Artwork( + thumb: String?, + size: Dp, + modifier: Modifier = Modifier, + corner: Dp = 6.dp, + circle: Boolean = false, + placeholder: ImageVector = Sym.note, +) { + val c = Ios.colors + val density = LocalDensity.current.density + // Round the request up so nearby sizes share cache entries. + val px = (ceil(size.value * density / 120f) * 120).toInt().coerceIn(120, 1440) + val url = remember(thumb, px) { App.graph.plex.artUrl(thumb, px) } + val shape = if (circle) CircleShape else RoundedCornerShape(corner) + Box( + modifier.size(size).clip(shape).background(c.placeholder).border(0.5.dp, c.separator.copy(alpha = 0.6f), shape), + contentAlignment = Alignment.Center, + ) { + Icon(placeholder, c.label3, size = size * 0.38f) + if (url != null) AsyncImage(model = url, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxSize()) + } +} + +@Composable +fun EmptyState(icon: ImageVector, title: String, message: String, action: String? = null, onAction: () -> Unit = {}) { + val c = Ios.colors + Column(Modifier.fillMaxWidth().padding(horizontal = 40.dp, vertical = 70.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Icon(icon, c.label3, size = 56.dp) + Spacer(Modifier.height(14.dp)) + Txt(title, Type.title3, align = TextAlign.Center, maxLines = 2) + Spacer(Modifier.height(6.dp)) + Txt(message, Type.subhead, color = c.label2, align = TextAlign.Center, maxLines = 6) + if (action != null) { + Spacer(Modifier.height(16.dp)) + Box(Modifier.clip(CircleShape).background(c.accent).pressFade(onClick = onAction).padding(horizontal = 20.dp, vertical = 10.dp)) { + Txt(action, Type.headline, color = Color.White, weight = FontWeight.SemiBold) + } + } + } +} + +@Composable +fun LoadingRow() { + Box(Modifier.fillMaxWidth().padding(vertical = 40.dp), contentAlignment = Alignment.Center) { Spinner(size = 26.dp) } +} + +@Composable +fun ErrorRow(message: String, onRetry: () -> Unit) { + if (!App.graph.plex.signedIn) { + val nav = LocalNav.current + EmptyState(Sym.server, "Not Connected", "Sign in to your Plex server to see your music here.", "Connect") { + nav.push(com.stemroller.mobile.ui.nav.Route.PlexAccount) + } + } else { + EmptyState(Sym.warning, "Couldn't Load", message, "Try Again", onRetry) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/components/Controls.kt b/android/app/src/main/java/com/stemroller/mobile/ui/components/Controls.kt new file mode 100644 index 0000000..939a9b9 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/components/Controls.kt @@ -0,0 +1,370 @@ +package com.stemroller.mobile.ui.components + +import androidx.compose.animation.animateColorAsState +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.combinedClickable +import androidx.compose.foundation.gestures.detectDragGestures +import androidx.compose.foundation.gestures.detectTapGestures +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.offset +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.composed +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.draw.clip +import androidx.compose.ui.geometry.CornerRadius +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.drawscope.rotate +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.hapticfeedback.HapticFeedbackType +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.platform.LocalHapticFeedback +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlin.math.abs +import kotlin.math.roundToInt + +/** Tap target without a ripple. iOS dims or highlights instead; [pressed] reports it. */ +@OptIn(ExperimentalFoundationApi::class) +fun Modifier.tappable( + enabled: Boolean = true, + onLongClick: (() -> Unit)? = null, + interaction: MutableInteractionSource? = null, + onClick: () -> Unit, +): Modifier = composed { + val src = interaction ?: remember { MutableInteractionSource() } + combinedClickable(src, indication = null, enabled = enabled, onLongClick = onLongClick, onClick = onClick) +} + +/** Like [tappable] but fades to 35% while pressed, as iOS buttons do. */ +fun Modifier.pressFade(enabled: Boolean = true, onLongClick: (() -> Unit)? = null, onClick: () -> Unit): Modifier = composed { + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + val a by animateFloatAsState(if (pressed) 0.35f else 1f, tween(if (pressed) 0 else 220), label = "press") + this.alpha(if (enabled) a else 0.35f).tappable(enabled, onLongClick, src, onClick) +} + +@Composable +fun IconButton( + vector: ImageVector, + onClick: () -> Unit, + modifier: Modifier = Modifier, + tint: Color = Ios.colors.accent, + size: Dp = 24.dp, + box: Dp = 44.dp, + enabled: Boolean = true, + onLongClick: (() -> Unit)? = null, +) { + Box(modifier.size(box).pressFade(enabled, onLongClick, onClick), contentAlignment = Alignment.Center) { + Icon(vector, tint, size = size) + } +} + +@Composable +fun TextButton(text: String, onClick: () -> Unit, modifier: Modifier = Modifier, bold: Boolean = false, color: Color = Ios.colors.accent, enabled: Boolean = true) { + Box(modifier.height(44.dp).pressFade(enabled, onClick = onClick).padding(horizontal = 4.dp), contentAlignment = Alignment.Center) { + Txt(text, Type.body, color = color, weight = if (bold) FontWeight.SemiBold else null) + } +} + +/** UISwitch: 51x31, green when on. */ +@Composable +fun IosSwitch(checked: Boolean, onChange: (Boolean) -> Unit, modifier: Modifier = Modifier) { + val c = Ios.colors + val track by animateColorAsState(if (checked) c.green else c.switchOff, tween(200), label = "track") + val x by animateFloatAsState(if (checked) 1f else 0f, spring(dampingRatio = 0.75f, stiffness = 600f), label = "thumb") + val haptic = LocalHapticFeedback.current + Box( + modifier.size(51.dp, 31.dp).clip(CircleShape).background(track) + .tappable { haptic.performHapticFeedback(HapticFeedbackType.ToggleOn); onChange(!checked) }, + ) { + Box( + Modifier.padding(2.dp).offset { IntOffset((x * 20.dp.toPx()).roundToInt(), 0) } + .size(27.dp).clip(CircleShape).background(Color.White) + .border(0.5.dp, c.thumbBorder, CircleShape), + ) + } +} + +/** UISegmentedControl with a sliding selection. */ +@Composable +fun SegmentedControl(options: List, selected: Int, onSelect: (Int) -> Unit, modifier: Modifier = Modifier) { + val c = Ios.colors + val pos by animateFloatAsState(selected.toFloat(), spring(dampingRatio = 0.85f, stiffness = 500f), label = "seg") + BoxWithConstraints(modifier.fillMaxWidth().height(32.dp).clip(RoundedCornerShape(9.dp)).background(c.fill).padding(2.dp)) { + val segW = maxWidth / options.size + Box( + Modifier.offset { IntOffset((segW.toPx() * pos).roundToInt(), 0) }.width(segW).fillMaxHeight() + .clip(RoundedCornerShape(7.dp)).background(if (c.dark) c.fillStrong else Color.White) + .border(0.5.dp, if (c.dark) Color.Transparent else c.separator, RoundedCornerShape(7.dp)), + ) + Row(Modifier.fillMaxWidth().fillMaxHeight()) { + options.forEachIndexed { i, label -> + Box(Modifier.weight(1f).fillMaxHeight().tappable { onSelect(i) }, contentAlignment = Alignment.Center) { + Txt(label, Type.footnote, weight = if (i == selected) FontWeight.SemiBold else FontWeight.Medium) + } + } + } + } +} + +/** + * UISlider: 4 dp track, white 28 dp thumb. [detent] snaps near a value (with a haptic tick), + * e.g. unity gain on stem faders. + */ +@Composable +fun IosSlider( + value: Float, + onChange: (Float) -> Unit, + modifier: Modifier = Modifier, + fill: Color = Ios.colors.accent, + track: Color = Ios.colors.fillStrong, + detent: Float? = null, + enabled: Boolean = true, + thumb: Dp = 28.dp, + onRelease: (() -> Unit)? = null, +) { + val c = Ios.colors + val haptic = LocalHapticFeedback.current + val current by rememberUpdatedState(value) + val change by rememberUpdatedState(onChange) + Box( + modifier.height(maxOf(thumb, 28.dp) + 8.dp).fillMaxWidth().alpha(if (enabled) 1f else 0.4f) + .pointerInput(enabled, detent) { + if (!enabled) return@pointerInput + val t = thumb.toPx() + fun valueAt(x: Float) = ((x - t / 2) / (size.width - t)).coerceIn(0f, 1f) + fun snap(v: Float): Float { + if (detent == null) return v + return if (abs(v - detent) < 0.025f) detent else v + } + var start = 0f + var acc = 0f + detectDragGestures( + onDragStart = { start = current; acc = 0f }, + onDragEnd = { onRelease?.invoke() }, + onDragCancel = { onRelease?.invoke() }, + ) { change, drag -> + change.consume() + acc += drag.x + val before = current + val v = snap((start + acc / (size.width - t)).coerceIn(0f, 1f)) + if (detent != null && v == detent && before != detent) haptic.performHapticFeedback(HapticFeedbackType.SegmentTick) + change(v) + } + } + .pointerInput(enabled) { + if (!enabled) return@pointerInput + detectTapGestures { o -> + val t = thumb.toPx() + change(((o.x - t / 2) / (size.width - t)).coerceIn(0f, 1f)) + onRelease?.invoke() + } + }, + contentAlignment = Alignment.CenterStart, + ) { + val density = LocalDensity.current + Canvas(Modifier.fillMaxWidth().height(thumb)) { + val t = thumb.toPx() + val h = 4.dp.toPx() + val y = size.height / 2 + val x = t / 2 + (size.width - t) * value.coerceIn(0f, 1f) + drawRoundRect(track, Offset(t / 2, y - h / 2), Size(size.width - t, h), CornerRadius(h / 2)) + drawRoundRect(fill, Offset(t / 2, y - h / 2), Size(x - t / 2, h), CornerRadius(h / 2)) + if (detent != null) { + val dx = t / 2 + (size.width - t) * detent + drawLine(c.label3, Offset(dx, y - 7.dp.toPx()), Offset(dx, y + 7.dp.toPx()), 1.5.dp.toPx(), StrokeCap.Round) + } + if (c.thumbBorder.alpha > 0f) drawCircle(c.thumbBorder, t / 2 + with(density) { 0.5.dp.toPx() }, Offset(x, y)) + drawCircle(Color.White, t / 2, Offset(x, y)) + } + } +} + +/** A vertical UISlider for the EQ: centre-detented, value in -1..1. */ +@Composable +fun VerticalBandSlider(value: Float, onChange: (Float) -> Unit, modifier: Modifier = Modifier, fill: Color = Ios.colors.accent) { + val c = Ios.colors + val haptic = LocalHapticFeedback.current + val current by rememberUpdatedState(value) + val change by rememberUpdatedState(onChange) + Canvas( + modifier.fillMaxHeight().width(32.dp) + .pointerInput(Unit) { + val t = 24.dp.toPx() + var start = 0f + var acc = 0f + detectDragGestures(onDragStart = { start = current; acc = 0f }) { ch, drag -> + ch.consume() + acc += drag.y + val before = current + var v = (start - 2f * acc / (size.height - t)).coerceIn(-1f, 1f) + if (abs(v) < 0.04f) v = 0f + if (v == 0f && before != 0f) haptic.performHapticFeedback(HapticFeedbackType.SegmentTick) + change(v) + } + } + .pointerInput(Unit) { detectTapGestures(onDoubleTap = { change(0f) }) }, + ) { + val t = 24.dp.toPx() + val w = 4.dp.toPx() + val x = size.width / 2 + val top = t / 2 + val bottom = size.height - t / 2 + val mid = (top + bottom) / 2 + val y = mid - (bottom - top) / 2 * value + drawRoundRect(c.fillStrong, Offset(x - w / 2, top), Size(w, bottom - top), CornerRadius(w / 2)) + drawRoundRect(fill, Offset(x - w / 2, minOf(y, mid)), Size(w, abs(y - mid)), CornerRadius(w / 2)) + drawLine(c.label3, Offset(x - 8.dp.toPx(), mid), Offset(x + 8.dp.toPx(), mid), 1.dp.toPx()) + if (c.thumbBorder.alpha > 0f) drawCircle(c.thumbBorder, t / 2 + 0.5.dp.toPx(), Offset(x, y)) + drawCircle(Color.White, t / 2, Offset(x, y)) + } +} + +/** Apple Music's Play / Shuffle buttons: filled rounded rect, accent glyph and label. */ +@Composable +fun PillButton(text: String, icon: ImageVector, onClick: () -> Unit, modifier: Modifier = Modifier) { + val c = Ios.colors + Row( + modifier.height(50.dp).clip(RoundedCornerShape(12.dp)).background(c.fill).pressFade(onClick = onClick), + horizontalArrangement = Arrangement.Center, + verticalAlignment = Alignment.CenterVertically, + ) { + Icon(icon, c.accent, size = 20.dp) + Spacer(Modifier.width(8.dp)) + Txt(text, Type.headline, color = c.accent) + } +} + +/** Capsule chip, accent-filled when selected. */ +@Composable +fun Chip(text: String, selected: Boolean, onClick: () -> Unit, modifier: Modifier = Modifier) { + val c = Ios.colors + Box( + modifier.height(32.dp).clip(CircleShape).background(if (selected) c.accent else c.fill) + .pressFade(onClick = onClick).padding(horizontal = 14.dp), + contentAlignment = Alignment.Center, + ) { + Txt(text, Type.footnote, color = if (selected) Color.White else c.label, weight = FontWeight.SemiBold) + } +} + +/** Small capsule tag, e.g. "STEMS" next to a track. */ +@Composable +fun Tag(text: String, color: Color = Ios.colors.label2, modifier: Modifier = Modifier) { + Box( + modifier.clip(RoundedCornerShape(4.dp)).border(1.dp, color, RoundedCornerShape(4.dp)).padding(horizontal = 4.dp, vertical = 1.dp), + contentAlignment = Alignment.Center, + ) { + Txt(text, Type.caption2.copy(letterSpacing = Type.caption2.letterSpacing), color = color, weight = FontWeight.Bold) + } +} + +/** UIActivityIndicatorView: eight spokes stepping round. */ +@Composable +fun Spinner(modifier: Modifier = Modifier, size: Dp = 20.dp, color: Color = Ios.colors.label2) { + val t = rememberInfiniteTransition(label = "spin") + val step by t.animateFloat(0f, 8f, infiniteRepeatable(tween(800, easing = LinearEasing), RepeatMode.Restart), label = "step") + Canvas(modifier.size(size)) { + val s = step.toInt() + val r0 = this.size.minDimension * 0.22f + val r1 = this.size.minDimension * 0.46f + val w = this.size.minDimension * 0.09f + for (i in 0 until 8) { + val a = 1f - ((s - i + 8) % 8) / 8f + rotate(i * 45f) { + drawLine(color.copy(alpha = color.alpha * (0.25f + 0.75f * a)), Offset(center.x, center.y - r0), Offset(center.x, center.y - r1), w, StrokeCap.Round) + } + } + } +} + +/** Downloaded marker: filled circle with a down arrow, as in Apple Music's lists. */ +@Composable +fun DownloadedMark(modifier: Modifier = Modifier, color: Color = Ios.colors.label2, size: Dp = 14.dp) { + val bg = Ios.colors.bg + Canvas(modifier.size(size)) { + drawCircle(color) + val w = this.size.width + val sw = w * 0.12f + drawLine(bg, Offset(w / 2, w * 0.26f), Offset(w / 2, w * 0.7f), sw, StrokeCap.Round) + drawLine(bg, Offset(w * 0.32f, w * 0.52f), Offset(w / 2, w * 0.7f), sw, StrokeCap.Round) + drawLine(bg, Offset(w * 0.68f, w * 0.52f), Offset(w / 2, w * 0.7f), sw, StrokeCap.Round) + } +} + +/** Download progress ring. */ +@Composable +fun ProgressRing(progress: Float, modifier: Modifier = Modifier, size: Dp = 18.dp, color: Color = Ios.colors.accent) { + val track = Ios.colors.fillStrong + Canvas(modifier.size(size)) { + val sw = 2.dp.toPx() + drawCircle(track, this.size.minDimension / 2 - sw / 2, style = androidx.compose.ui.graphics.drawscope.Stroke(sw)) + drawArc(color, -90f, 360f * progress.coerceIn(0f, 1f), false, Offset(sw / 2, sw / 2), + Size(this.size.width - sw, this.size.height - sw), style = androidx.compose.ui.graphics.drawscope.Stroke(sw, cap = StrokeCap.Round)) + } +} + +/** Animated "now playing" bars used in place of a track number. */ +@Composable +fun PlayingBars(playing: Boolean, modifier: Modifier = Modifier, color: Color = Ios.colors.accent) { + val t = rememberInfiniteTransition(label = "bars") + val phase by t.animateFloat(0f, 6.2832f, infiniteRepeatable(tween(1100, easing = LinearEasing)), label = "phase") + Canvas(modifier.size(16.dp)) { + val w = size.width / 4.5f + for (i in 0 until 3) { + val h = if (playing) (0.35f + 0.65f * abs(kotlin.math.sin(phase + i * 1.9f))) else 0.3f + i * 0.15f + val bh = size.height * h + drawRoundRect(color, Offset(i * w * 1.6f + w * 0.3f, size.height - bh), Size(w, bh), CornerRadius(w / 3)) + } + } +} + +@Composable +fun Hairline(modifier: Modifier = Modifier, color: Color = Ios.colors.separator) { + val px = with(LocalDensity.current) { 1f / density } + Box(modifier.fillMaxWidth().height(px.dp).background(color)) +} + +@Composable +fun Chevron(modifier: Modifier = Modifier) = Icon(Sym.chevronRight, Ios.colors.label3, modifier, size = 14.dp) diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/components/Overlays.kt b/android/app/src/main/java/com/stemroller/mobile/ui/components/Overlays.kt new file mode 100644 index 0000000..8cadcbc --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/components/Overlays.kt @@ -0,0 +1,275 @@ +package com.stemroller.mobile.ui.components + +import androidx.activity.compose.PredictiveBackHandler +import androidx.compose.animation.core.Animatable +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicTextField +import androidx.compose.foundation.text.KeyboardActions +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.Stable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.SolidColor +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +class SheetAction(val title: String, val destructive: Boolean = false, val onClick: () -> Unit) + +class AlertSpec( + val title: String, + val message: String? = null, + val confirm: String = "OK", + val cancel: String? = "Cancel", + val destructive: Boolean = false, + val field: String? = null, + val placeholder: String = "", + val onConfirm: (String) -> Unit, +) + +class HudSpec(val text: String, val icon: ImageVector?, val id: Long) + +/** App-wide modal UI: action sheets, alerts and the HUD. */ +@Stable +class Overlays { + var sheet by mutableStateOf>?>(null) + var alert by mutableStateOf(null) + var hud by mutableStateOf(null) + private var hudId = 0L + + fun actions(title: String?, actions: List) { + sheet = title to actions + } + + fun prompt(title: String, message: String?, initial: String, confirm: String, placeholder: String = "", onConfirm: (String) -> Unit) { + alert = AlertSpec(title, message, confirm, field = initial, placeholder = placeholder, onConfirm = onConfirm) + } + + fun confirm(title: String, message: String?, confirm: String, destructive: Boolean = true, onConfirm: () -> Unit) { + alert = AlertSpec(title, message, confirm, destructive = destructive, onConfirm = { onConfirm() }) + } + + fun hud(text: String, icon: ImageVector? = Sym.check) { + hud = HudSpec(text, icon, ++hudId) + } +} + +val LocalOverlays = staticCompositionLocalOf { Overlays() } + +@Composable +fun OverlayHost(o: Overlays) { + o.sheet?.let { (title, actions) -> ActionSheet(title, actions) { o.sheet = null } } + o.alert?.let { spec -> Alert(spec) { o.alert = null } } + o.hud?.let { h -> Hud(h) { if (o.hud?.id == h.id) o.hud = null } } +} + +/** UIAlertController(.actionSheet): grouped buttons over a scrim, Cancel apart. */ +@Composable +private fun ActionSheet(title: String?, actions: List, dismiss: () -> Unit) { + val c = Ios.colors + val shown = remember { Animatable(0f) } + val scope = rememberCoroutineScope() + LaunchedEffect(Unit) { shown.animateTo(1f, spring(dampingRatio = 0.9f, stiffness = 500f)) } + fun close(then: (() -> Unit)? = null) = scope.launch { + shown.animateTo(0f, tween(180)) + dismiss() + then?.invoke() + } + PredictiveBackHandler { events -> + try { + events.collect { shown.snapTo(1f - it.progress * 0.5f) } + close() + } catch (e: CancellationException) { + scope.launch { shown.animateTo(1f) } + throw e + } + } + Box(Modifier.fillMaxSize()) { + Box(Modifier.fillMaxSize().graphicsLayer { alpha = shown.value }.background(c.scrim).tappable { close() }) + Column( + Modifier.align(Alignment.BottomCenter).fillMaxWidth().navigationBarsPadding().padding(horizontal = 8.dp, vertical = 8.dp) + .graphicsLayer { translationY = (1f - shown.value) * size.height * 1.1f }, + ) { + Column(Modifier.fillMaxWidth().clip(RoundedCornerShape(14.dp)).background(c.elevated).heightIn(max = 560.dp).verticalScroll(rememberScrollState())) { + if (title != null) { + Box(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 14.dp), contentAlignment = Alignment.Center) { + Txt(title, Type.footnote, color = c.label2, maxLines = 2, align = TextAlign.Center, weight = FontWeight.SemiBold) + } + Hairline() + } + actions.forEachIndexed { i, a -> + if (i > 0) Hairline() + SheetButton(a.title, if (a.destructive) c.red else c.accent, bold = false) { close(a.onClick) } + } + } + Spacer(Modifier.height(8.dp)) + Box(Modifier.fillMaxWidth().clip(RoundedCornerShape(14.dp)).background(c.elevated)) { + SheetButton("Cancel", c.accent, bold = true) { close() } + } + } + } +} + +@Composable +private fun SheetButton(text: String, color: Color, bold: Boolean, onClick: () -> Unit) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + Box( + Modifier.fillMaxWidth().height(57.dp).background(if (pressed) c.cellPressed else Color.Transparent) + .tappable(interaction = src, onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Txt(text, Type.body.copy(fontSize = Type.title3.fontSize), color = color, weight = if (bold) FontWeight.SemiBold else FontWeight.Normal) + } +} + +/** UIAlertController(.alert), optionally with one text field. */ +@Composable +private fun Alert(spec: AlertSpec, dismiss: () -> Unit) { + val c = Ios.colors + val shown = remember { Animatable(0f) } + var text by remember(spec) { mutableStateOf(spec.field ?: "") } + val focus = remember { FocusRequester() } + LaunchedEffect(spec) { + shown.animateTo(1f, spring(dampingRatio = 0.7f, stiffness = 700f)) + if (spec.field != null) runCatching { focus.requestFocus() } + } + PredictiveBackHandler { events -> + events.collect { } + dismiss() + } + fun confirm() { + dismiss() + spec.onConfirm(text.trim()) + } + Box(Modifier.fillMaxSize().imePadding(), contentAlignment = Alignment.Center) { + Box(Modifier.fillMaxSize().graphicsLayer { alpha = shown.value }.background(c.scrim).tappable { }) + Column( + Modifier.width(280.dp).graphicsLayer { + alpha = shown.value + val sc = 1.15f - 0.15f * shown.value + scaleX = sc; scaleY = sc + }.clip(RoundedCornerShape(14.dp)).background(c.elevated), + ) { + Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 18.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Txt(spec.title, Type.headline, maxLines = 3, align = TextAlign.Center) + spec.message?.let { + Spacer(Modifier.height(4.dp)) + Txt(it, Type.footnote, maxLines = 8, align = TextAlign.Center) + } + if (spec.field != null) { + Spacer(Modifier.height(14.dp)) + Box( + Modifier.fillMaxWidth().clip(RoundedCornerShape(7.dp)).background(if (c.dark) c.fill else Color.White) + .border(0.5.dp, c.separator, RoundedCornerShape(7.dp)).padding(horizontal = 8.dp, vertical = 7.dp), + ) { + if (text.isEmpty()) Txt(spec.placeholder, Type.subhead, color = c.label3) + BasicTextField( + value = text, onValueChange = { text = it }, singleLine = true, + textStyle = Type.subhead.copy(color = c.label), + cursorBrush = SolidColor(c.accent), + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done), + keyboardActions = KeyboardActions(onDone = { if (text.isNotBlank()) confirm() }), + modifier = Modifier.fillMaxWidth().focusRequester(focus), + ) + } + } + } + Hairline() + Row(Modifier.fillMaxWidth().height(44.dp), horizontalArrangement = Arrangement.Center) { + spec.cancel?.let { label -> + AlertButton(label, c.accent, false, Modifier.weight(1f)) { dismiss() } + Box(Modifier.width(0.5.dp).height(44.dp).background(c.separator)) + } + AlertButton(spec.confirm, if (spec.destructive) c.red else c.accent, true, Modifier.weight(1f), + enabled = spec.field == null || text.isNotBlank()) { confirm() } + } + } + } +} + +@Composable +private fun AlertButton(text: String, color: Color, bold: Boolean, modifier: Modifier, enabled: Boolean = true, onClick: () -> Unit) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + Box( + modifier.height(44.dp).background(if (pressed) c.cellPressed else Color.Transparent).tappable(enabled, interaction = src, onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Txt(text, Type.body, color = if (enabled) color else c.label3, weight = if (bold) FontWeight.SemiBold else null) + } +} + +/** The square "Added to Library" style HUD. */ +@Composable +private fun Hud(h: HudSpec, done: () -> Unit) { + val c = Ios.colors + val a = remember(h.id) { Animatable(0f) } + LaunchedEffect(h.id) { + a.animateTo(1f, tween(150)) + delay(if (h.text.length > 40) 2800 else 1400) + a.animateTo(0f, tween(250)) + done() + } + Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + Column( + Modifier.widthIn(min = 150.dp, max = 270.dp).graphicsLayer { alpha = a.value; val s = 0.9f + 0.1f * a.value; scaleX = s; scaleY = s } + .clip(RoundedCornerShape(16.dp)).background(if (c.dark) Color(0xFF2C2C2E) else Color(0xFFE5E5EA)) + .padding(horizontal = 20.dp, vertical = 20.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + h.icon?.let { + Icon(it, c.label2, size = 44.dp) + Spacer(Modifier.height(10.dp)) + } + Txt(h.text, Type.headline, color = c.label2, maxLines = 4, align = TextAlign.Center) + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/nav/Navigation.kt b/android/app/src/main/java/com/stemroller/mobile/ui/nav/Navigation.kt new file mode 100644 index 0000000..71c67bf --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/nav/Navigation.kt @@ -0,0 +1,282 @@ +package com.stemroller.mobile.ui.nav + +import androidx.activity.BackEventCompat +import androidx.activity.compose.PredictiveBackHandler +import androidx.compose.animation.core.AnimationSpec +import androidx.compose.animation.core.animate +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.SideEffect +import androidx.compose.runtime.State +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.key +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.compose.runtime.snapshots.Snapshot +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.SaveableStateHolder +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clipToBounds +import androidx.compose.ui.draw.drawWithContent +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import com.stemroller.mobile.plex.Album +import com.stemroller.mobile.plex.Artist +import com.stemroller.mobile.plex.Playlist +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.cancel +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +sealed interface Route { + val title: String + + data object Library : Route { override val title = "Library" } + data object Artists : Route { override val title = "Artists" } + data object Albums : Route { override val title = "Albums" } + data object Songs : Route { override val title = "Songs" } + data object Downloads : Route { override val title = "Downloads" } + data object Playlists : Route { override val title = "Playlists" } + data object Search : Route { override val title = "Search" } + data object Eq : Route { override val title = "Equalizer" } + data class EqFilters(val profileId: String) : Route { override val title = "Filters" } + data class EqFilterPage(val profileId: String, val filterId: String) : Route { override val title = "Filter" } + data object Settings : Route { override val title = "Settings" } + data object PlexAccount : Route { override val title = "Plex" } + data object StemServer : Route { override val title = "Stem Server" } + data object Quality : Route { override val title = "Stem Quality" } + data object Storage : Route { override val title = "Storage" } + data object Appearance : Route { override val title = "Appearance" } + data class ArtistPage(val artist: Artist) : Route { override val title get() = artist.title } + data class AlbumPage(val album: Album) : Route { override val title get() = album.title } + data class PlaylistPage(val playlist: Playlist) : Route { override val title get() = playlist.title } +} + +/** A screen instance on a stack. [store] keeps its loaded data while it stays on the stack. */ +class Entry(val route: Route) { + val id: Long = nextId++ + val store = HashMap() + val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) + + companion object { + private var nextId = 1L + } +} + +/** + * One tab's navigation stack. [progress] is how far the top entry has come in: 1 at rest, + * 0 fully off to the right. Pushes animate it 0→1, pops 1→0, and the predictive back + * gesture drives it by hand. + */ +class NavStack(root: Route) { + val entries = mutableStateListOf(Entry(root)) + var progress by mutableFloatStateOf(1f) + private set + internal var scope: CoroutineScope? = null + internal var holder: SaveableStateHolder? = null + private val busy = Mutex() + + private suspend fun animateTo(target: Float, spec: AnimationSpec = PUSH) { + animate(progress, target, animationSpec = spec) { v, _ -> progress = v } + } + + fun push(route: Route) { + val s = scope + if (s == null) { + entries.add(Entry(route)) + return + } + s.launch { + busy.withLock { + Snapshot.withMutableSnapshot { + entries.add(Entry(route)) + progress = 0f + } + animateTo(1f) + } + } + } + + fun pop() { + if (entries.size <= 1) return + val s = scope ?: return removeTop() + s.launch { + busy.withLock { + // A tap queued behind another pop may find nothing left to pop. + if (entries.size <= 1) return@withLock + animateTo(0f) + finishPop() + } + } + } + + fun popToRoot() { + if (entries.size <= 1) return + val s = scope + if (s == null) { + while (entries.size > 1) removeTop() + return + } + s.launch { + busy.withLock { + // A second tap on the tab while the first is still animating lands here after it. + if (entries.size <= 1) return@withLock + // Drop the middle silently, then slide the top away. + while (entries.size > 2) dispose(entries.removeAt(entries.size - 2)) + animateTo(0f) + finishPop() + } + } + } + + /** Removes the top and resets progress in one snapshot, so no frame shows a half state. */ + private fun finishPop() = Snapshot.withMutableSnapshot { + removeTop() + progress = 1f + } + + private fun removeTop() { + if (entries.size <= 1) return // the root never leaves + dispose(entries.removeAt(entries.lastIndex)) + } + + private fun dispose(e: Entry) { + e.scope.cancel() + holder?.removeState(e.id) + } + + internal suspend fun backProgress(p: Float) = busy.withLock { if (entries.size > 1) progress = 1f - p } + + internal suspend fun backCommit() = busy.withLock { + if (entries.size <= 1) { + progress = 1f + return@withLock + } + animateTo(0f, tween(180)) + finishPop() + } + + internal suspend fun backCancel() = busy.withLock { animateTo(1f, spring(stiffness = 600f)) } + + companion object { + /** Critically damped, like UINavigationController's push. */ + val PUSH = spring(dampingRatio = 1f, stiffness = 420f) + } +} + +val LocalNav = staticCompositionLocalOf { error("no NavStack") } +val LocalEntry = staticCompositionLocalOf { error("no Entry") } + +/** + * Renders a [NavStack] with iOS's push/pop: the new page slides in from the right while + * the old one parallaxes left by 30% and dims. During a predictive back swipe the same + * animation follows the finger, and releasing commits or springs back. + */ +@Composable +fun StackHost(stack: NavStack, holder: SaveableStateHolder, active: Boolean, content: @Composable (Route) -> Unit) { + val scope = androidx.compose.runtime.rememberCoroutineScope() + SideEffect { + stack.scope = scope + stack.holder = holder + } + val moving by remember(stack) { derivedStateOf { stack.progress < 1f } } + + BoxWithConstraints(Modifier.fillMaxSize().clipToBounds()) { + val w = constraints.maxWidth.toFloat() + val n = stack.entries.size + val visible = if (moving && n >= 2) listOf(stack.entries[n - 2], stack.entries[n - 1]) else listOf(stack.entries[n - 1]) + for (e in visible) { + key(e.id) { + val isTop = e === stack.entries.last() + Box( + Modifier.fillMaxSize() + .graphicsLayer { + val p = stack.progress + translationX = if (isTop) w * (1f - p) else -0.3f * w * p + } + .drawWithContent { + drawContent() + if (!isTop) drawRect(Color.Black.copy(alpha = 0.18f * stack.progress)) + }, + ) { + holder.SaveableStateProvider(e.id) { + CompositionLocalProvider(LocalNav provides stack, LocalEntry provides e) { + content(e.route) + } + } + } + } + } + } + + PredictiveBackHandler(enabled = active && stack.entries.size > 1) { events -> + try { + events.collect { e: BackEventCompat -> stack.backProgress(e.progress) } + scope.launch { stack.backCommit() } + } catch (e: CancellationException) { + scope.launch { stack.backCancel() } + throw e + } + } +} + +// ---- per-entry loading ---------------------------------------------------------------------- + +sealed interface Load { + data object Loading : Load + data class Ok(val value: T) : Load + data class Err(val message: String) : Load +} + +class Loader(private val scope: CoroutineScope, private val fetch: suspend () -> T) { + private val _state = mutableStateOf>(Load.Loading) + val state: State> = _state + val value: T? get() = (_state.value as? Load.Ok)?.value + + init { + refresh(showLoading = true) + } + + fun refresh(showLoading: Boolean = false) { + if (showLoading) _state.value = Load.Loading + scope.launch { + _state.value = try { + Load.Ok(fetch()) + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + if (_state.value is Load.Ok && !showLoading) return@launch + Load.Err(e.message ?: e.javaClass.simpleName) + } + } + } +} + +/** Data for this screen, fetched once per stack entry and kept while it's on the stack. */ +@Suppress("UNCHECKED_CAST") +@Composable +fun rememberLoader(key: String, fetch: suspend () -> T): Loader { + val entry = LocalEntry.current + return remember(entry, key) { entry.store.getOrPut(key) { Loader(entry.scope, fetch) } as Loader } +} + +/** Per-entry state that survives the page leaving composition during transitions. */ +@Suppress("UNCHECKED_CAST") +@Composable +fun rememberInEntry(key: String, init: () -> T): T { + val entry = LocalEntry.current + return remember(entry, key) { entry.store.getOrPut(key) { init() } as T } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/Common.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/Common.kt new file mode 100644 index 0000000..881d954 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/Common.kt @@ -0,0 +1,404 @@ +package com.stemroller.mobile.ui.screens + +import androidx.compose.foundation.background +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.App +import com.stemroller.mobile.stems.Coverage +import com.stemroller.mobile.plex.Album +import com.stemroller.mobile.plex.Artist +import com.stemroller.mobile.plex.Playlist +import com.stemroller.mobile.plex.Track +import com.stemroller.mobile.ui.components.Artwork +import com.stemroller.mobile.ui.components.Chevron +import com.stemroller.mobile.ui.components.DownloadedMark +import com.stemroller.mobile.ui.components.Hairline +import com.stemroller.mobile.ui.components.IconButton +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.MARGIN +import com.stemroller.mobile.ui.components.Overlays +import com.stemroller.mobile.ui.components.PillButton +import com.stemroller.mobile.ui.components.PlayingBars +import com.stemroller.mobile.ui.components.ProgressRing +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.Tag +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch + +enum class Tab(val label: String) { Library("Library"), Playlists("Playlists"), Search("Search"), Downloads("Downloads"), Settings("Settings") } + +/** Things any screen can ask of the shell. */ +class AppActions( + val openNowPlaying: () -> Unit, + val closeNowPlaying: () -> Unit, + val selectTab: (Tab) -> Unit, + /** Switches to the Library tab and pushes [route] there. */ + val showInLibrary: (Route) -> Unit, + /** Switches to Settings and opens [route] (the Equalizer) there. */ + val showInSettings: (Route) -> Unit, +) + +val LocalApp = staticCompositionLocalOf { error("no AppActions") } + +fun formatDuration(ms: Long): String { + val s = (ms / 1000).coerceAtLeast(0) + return if (s >= 3600) "%d:%02d:%02d".format(s / 3600, s / 60 % 60, s % 60) else "%d:%02d".format(s / 60, s % 60) +} + +fun formatMinutes(ms: Long): String { + val m = (ms / 60000).toInt() + return if (m >= 60) "${m / 60} hr ${m % 60} min" else "$m minute${if (m == 1) "" else "s"}" +} + +fun songs(n: Int) = "$n song${if (n == 1) "" else "s"}" + +/** + * Stem / download status for a track, read reactively. Stems are the norm once the server has + * worked through the library, so the badge marks the songs *without* them (and only once the + * index has loaded, so nothing is flagged before we know). + */ +@Composable +fun trackBadges(track: Track): Triple { + val g = App.graph + val index by g.stems.index.collectAsState() + val records by g.downloads.records.collectAsState() + val progress by g.downloads.progress.collectAsState() + val noStems = remember(track, index) { index.size > 0 && g.stems.find(track) == null } + return Triple(noStems, records[track.ratingKey]?.done == true, progress[track.ratingKey]) +} + +/** "NO STEMS" / "SOME STEMS" for an album or artist, once the whole library has been matched. */ +@Composable +fun StemFlag(cov: Coverage?, modifier: Modifier = Modifier) { + val ready by App.graph.coverage.ready.collectAsState() + if (!ready || cov == null) return + when { + cov.none -> Tag("NO STEMS", modifier = modifier) + cov.partial -> Tag("${cov.withStems}/${cov.total} STEMS", modifier = modifier) + } +} + +/** Apple Music list row: art (or track number), title, artist, badges, and a ••• menu. */ +@Composable +fun TrackRow( + track: Track, + onClick: () -> Unit, + modifier: Modifier = Modifier, + number: Int? = null, + showArt: Boolean = true, + subtitle: String? = track.artist, + onMore: (() -> Unit)? = null, + leading: (@Composable () -> Unit)? = null, + trailing: (@Composable () -> Unit)? = null, +) { + val c = Ios.colors + val pm = App.graph.playback + val current by pm.current.collectAsState() + val playing by pm.playWhenReady.collectAsState() + val isCurrent = current?.track?.ratingKey == track.ratingKey + val (noStems, downloaded, progress) = trackBadges(track) + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + val textStart: Dp = (if (leading != null) 44 else 0).dp + if (showArt) 68.dp else if (number != null) 52.dp else MARGIN.dp + Box(modifier.fillMaxWidth().background(if (pressed) c.cellPressed else Color.Transparent)) { + Row( + Modifier.fillMaxWidth().heightIn(min = if (showArt) 64.dp else 48.dp) + .tappable(onLongClick = onMore, interaction = src, onClick = onClick) + .padding(start = if (leading != null) 8.dp else MARGIN.dp, end = 6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + if (leading != null) { + Box(Modifier.size(36.dp), contentAlignment = Alignment.Center) { leading() } + Spacer(Modifier.width(if (showArt) 8.dp else 0.dp)) + } + if (showArt) { + Box(contentAlignment = Alignment.Center) { + Artwork(track.thumb, 48.dp, corner = 5.dp) + if (isCurrent) Box(Modifier.size(48.dp).background(Color.Black.copy(alpha = 0.35f)), contentAlignment = Alignment.Center) { + PlayingBars(playing, color = Color.White) + } + } + Spacer(Modifier.width(12.dp)) + } else if (number != null) { + Box(Modifier.width(32.dp), contentAlignment = Alignment.CenterStart) { + if (isCurrent) PlayingBars(playing) else Txt("$number", Type.body, color = c.label2) + } + } + Column(Modifier.weight(1f).padding(vertical = 8.dp)) { + Txt(track.title, Type.body, color = if (isCurrent) c.accent else c.label) + if (subtitle != null) Txt(subtitle, Type.subhead, color = c.label2) + } + if (noStems) { + Spacer(Modifier.width(6.dp)) + Tag("NO STEMS") + } + when { + progress != null -> { + Spacer(Modifier.width(8.dp)) + ProgressRing(progress, size = 16.dp) + } + downloaded -> { + Spacer(Modifier.width(8.dp)) + DownloadedMark() + } + } + trailing?.invoke() + if (onMore != null) IconButton(Sym.ellipsis, onMore, tint = c.label, size = 20.dp, box = 40.dp) + else Spacer(Modifier.width(14.dp)) + } + Hairline(Modifier.align(Alignment.BottomStart).padding(start = textStart)) + } +} + +/** + * Two-column album grid, laid out as rows so it can live in a LazyColumn. [subtitle] replaces + * the artist (or year) line; [badge] draws over the art's corner. + */ +fun LazyListScope.albumGrid( + key: String, + albums: List, + onClick: (Album) -> Unit, + onLongClick: ((Album) -> Unit)? = null, + showArtist: Boolean = true, + subtitle: ((Album) -> String?)? = null, + badge: (@Composable (Album) -> Unit)? = null, +) { + val rows = albums.chunked(2) + items(rows.size, key = { "$key.$it" }) { r -> + val coverage by App.graph.coverage.albums.collectAsState() + BoxWithConstraints(Modifier.fillMaxWidth().padding(horizontal = MARGIN.dp)) { + val tile = (maxWidth - 16.dp) / 2 + Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) { + rows[r].forEach { a -> + Column( + Modifier.width(tile).padding(bottom = 18.dp) + .tappable(onLongClick = onLongClick?.let { { it(a) } }) { onClick(a) }, + ) { + Box { + Artwork(a.thumb, tile, corner = 8.dp, placeholder = Sym.album) + badge?.let { Box(Modifier.align(Alignment.BottomEnd).padding(8.dp)) { it(a) } } + } + Spacer(Modifier.height(6.dp)) + Row(verticalAlignment = Alignment.CenterVertically) { + Txt(a.title, Type.subhead, Modifier.weight(1f, fill = false), weight = FontWeight.Medium) + StemFlag(coverage[a.ratingKey], Modifier.padding(start = 6.dp)) + } + val sub = subtitle?.invoke(a) ?: if (showArtist) a.artist else a.year?.toString() ?: "" + if (sub.isNotEmpty()) Txt(sub, Type.subhead, color = Ios.colors.label2) + } + } + } + } + } +} + +@Composable +fun ArtistRow(artist: Artist, onLongClick: (() -> Unit)? = null, onClick: () -> Unit) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + val coverage by App.graph.coverage.artists.collectAsState() + Box(Modifier.fillMaxWidth().background(if (pressed) c.cellPressed else Color.Transparent)) { + Row( + Modifier.fillMaxWidth().height(60.dp).tappable(onLongClick = onLongClick, interaction = src, onClick = onClick) + .padding(start = MARGIN.dp, end = 16.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Artwork(artist.thumb, 44.dp, circle = true, placeholder = Sym.person) + Spacer(Modifier.width(14.dp)) + Txt(artist.title, Type.body, Modifier.weight(1f)) + StemFlag(coverage[artist.ratingKey], Modifier.padding(horizontal = 8.dp)) + Chevron() + } + Hairline(Modifier.align(Alignment.BottomStart).padding(start = 78.dp)) + } +} + +/** Play / Shuffle pair under a header. */ +@Composable +fun PlayShuffle(onPlay: () -> Unit, onShuffle: () -> Unit) { + Row(Modifier.fillMaxWidth().padding(horizontal = MARGIN.dp), horizontalArrangement = Arrangement.spacedBy(14.dp)) { + PillButton("Play", Sym.play, onPlay, Modifier.weight(1f)) + PillButton("Shuffle", Sym.shuffle, onShuffle, Modifier.weight(1f)) + } +} + +/** + * The long-press / ••• menu for anything playable: songs, albums, artists and playlists all + * offer the front or end of the queue, download, and add-to-playlist (playlists included). + */ +class MediaMenu(private val overlays: Overlays, private val app: AppActions) { + private val g = App.graph + private val scope: CoroutineScope = g.scope + + fun show(track: Track, extra: List = emptyList(), allowGoTo: Boolean = true) { + val dl = g.downloads.records.value[track.ratingKey] + val actions = buildList { + addAll(queueActions { listOf(track) }) + if (dl == null) add(SheetAction("Download") { g.downloads.download(listOf(track)); overlays.hud("Downloading", Sym.download) }) + else add(SheetAction("Remove Download", destructive = true) { g.downloads.remove(listOf(track)) }) + add(SheetAction("Add to Playlist…") { addToPlaylist(listOf(track)) }) + if (track.partFile != null && g.stems.index.value.size > 0 && g.stems.find(track) == null) add(stemNow { listOf(track) }) + if (allowGoTo && track.albumKey != null) add(SheetAction("Go to Album") { + app.showInLibrary(Route.AlbumPage(Album(track.albumKey, track.album, track.artist, track.artistKey, track.year, track.thumb))) + }) + if (allowGoTo && track.artistKey != null) add(SheetAction("Go to Artist") { + app.showInLibrary(Route.ArtistPage(Artist(track.artistKey, track.artist, track.artist))) + }) + addAll(extra) + } + overlays.actions("${track.title} — ${track.artist}", actions) + } + + fun album(a: Album, extra: List = emptyList(), allowGoTo: Boolean = true) { + val have = g.downloads.records.value.values.filter { it.done && it.track.albumKey == a.ratingKey }.map { it.track } + val total = g.coverage.albums.value[a.ratingKey]?.total ?: a.trackCount ?: Int.MAX_VALUE + collection("${a.title} — ${a.artist}", have, have.size >= total, { g.plex.albumTracks(a.ratingKey) }, null, stemmed = stemmed(g.coverage.albums.value[a.ratingKey]), extra = buildList { + if (allowGoTo && a.artistKey != null) add(SheetAction("Go to Artist") { app.showInLibrary(Route.ArtistPage(Artist(a.artistKey, a.artist, a.artist))) }) + addAll(extra) + }) + } + + fun artist(a: Artist) { + val have = g.downloads.records.value.values.filter { it.done && it.track.artistKey == a.ratingKey }.map { it.track } + val total = g.coverage.artists.value[a.ratingKey]?.total ?: Int.MAX_VALUE + collection(a.title, have, have.size >= total, { g.plex.artistTracks(a.ratingKey) }, null, emptyList(), confirmDownload = true, + stemmed = stemmed(g.coverage.artists.value[a.ratingKey])) + } + + fun playlist(p: Playlist, extra: List = emptyList()) { + collection(p.title, emptyList(), false, { g.plex.playlistTracks(p.ratingKey) }, p.ratingKey, extra, confirmDownload = p.trackCount > 50) + } + + /** For songs already in hand (downloads with no Plex album behind them). */ + fun tracks(title: String, tracks: List, extra: List = emptyList()) { + val have = tracks.filter { g.downloads.isDownloaded(it.ratingKey) } + collection(title, have, have.size == tracks.size, { tracks }, null, extra, + stemmed = g.stems.index.value.size > 0 && tracks.all { it.partFile == null || g.stems.find(it) != null }) + } + + /** True when every song is known to have stems, so there's nothing for Stem Now to do. */ + private fun stemmed(cov: Coverage?) = g.coverage.ready.value && cov != null && cov.withStems >= cov.total + + private fun collection( + title: String, downloaded: List, allDownloaded: Boolean, load: suspend () -> List, + playlistKey: String?, extra: List, confirmDownload: Boolean = false, stemmed: Boolean = false, + ) { + overlays.actions(title, buildList { + addAll(queueActions(load)) + if (!allDownloaded) add(SheetAction(if (downloaded.isEmpty()) "Download" else "Download the Rest") { + withTracks(load) { tracks -> + if (confirmDownload && tracks.size > 20) { + overlays.confirm("Download ${songs(tracks.size)}?", "“$title” will play without your server, stems and all.", "Download", destructive = false) { + g.downloads.download(tracks); overlays.hud("Downloading", Sym.download) + } + } else { + g.downloads.download(tracks); overlays.hud("Downloading", Sym.download) + } + } + }) + if (downloaded.isNotEmpty()) add(SheetAction("Remove Download", destructive = true) { + overlays.confirm("Remove Download?", "“$title” will no longer be available offline.", "Remove") { g.downloads.remove(downloaded) } + }) + add(SheetAction("Add to Playlist…") { withTracks(load) { addToPlaylist(it, skip = playlistKey) } }) + if (!stemmed) add(stemNow(load)) + addAll(extra) + }) + } + + /** Front of the queue (right after this song) and the end of it. */ + private fun queueActions(load: suspend () -> List) = listOf( + SheetAction("Add to Front of Queue") { withTracks(load) { g.playback.playNext(it); overlays.hud("Playing Next", Sym.playNext) } }, + SheetAction("Add to End of Queue") { withTracks(load) { g.playback.addToQueue(it); overlays.hud("Added to Queue", Sym.addQueue) } }, + ) + + /** Has stemd on the server separate the songs that lack stems ahead of the rest of the library. */ + private fun stemNow(load: suspend () -> List) = SheetAction("Stem Now") { + scope.launch { + runCatching { g.stems.stemNow(load()) } + .onSuccess { n -> + if (n == 0) overlays.hud("Already has stems", Sym.info) + else overlays.hud(if (n == 1) "Stemming next" else "Stemming ${songs(n)} next", Sym.waveform) + } + .onFailure { overlays.hud("Couldn't queue: ${it.message}", Sym.warning) } + } + } + + private fun withTracks(load: suspend () -> List, then: (List) -> Unit) { + scope.launch { + runCatching { load() } + .onSuccess { if (it.isEmpty()) overlays.hud("Nothing to add", Sym.info) else then(it) } + .onFailure { overlays.hud("Couldn't load songs: ${it.message}", Sym.warning) } + } + } + + fun addToPlaylist(tracks: List, skip: String? = null) { + scope.launch { + val lists = runCatching { g.plex.playlists().filter { !it.smart && it.ratingKey != skip } }.getOrElse { + overlays.hud("Couldn't load playlists", Sym.warning) + return@launch + } + val keys = tracks.map { it.ratingKey }.filter { !it.startsWith("stem:") } + if (keys.isEmpty()) { + overlays.hud("These songs aren't in Plex, so they can't go in a playlist", Sym.info) + return@launch + } + overlays.actions("Add ${songs(keys.size)} to Playlist", listOf(SheetAction("New Playlist…") { newPlaylist(tracks) }) + lists.map { p -> + SheetAction(p.title) { + scope.launch { + runCatching { g.plex.addToPlaylist(p.ratingKey, keys) } + .onSuccess { overlays.hud("Added to ${p.title}") } + .onFailure { overlays.hud("Couldn't add: ${it.message}", Sym.warning) } + } + } + }) + } + } + + fun newPlaylist(tracks: List, onCreated: () -> Unit = {}) { + overlays.prompt("New Playlist", "Name it; you can add more songs later.", "", "Create", "Playlist name") { name -> + scope.launch { + runCatching { g.plex.createPlaylist(name, tracks.map { it.ratingKey }.filter { !it.startsWith("stem:") }) } + .onSuccess { overlays.hud("Created “$name”"); onCreated() } + .onFailure { overlays.hud("Couldn't create: ${it.message}", Sym.warning) } + } + } + } +} + +@Composable +fun rememberMediaMenu(): MediaMenu { + val overlays = LocalOverlays.current + val app = LocalApp.current + return remember(overlays, app) { MediaMenu(overlays, app) } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqFilterScreens.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqFilterScreens.kt new file mode 100644 index 0000000..e109d5f --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqFilterScreens.kt @@ -0,0 +1,428 @@ +package com.stemroller.mobile.ui.screens + +import android.content.ClipData +import android.content.ClipboardManager +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.gestures.detectDragGestures +import androidx.compose.foundation.gestures.detectTapGestures +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.PathEffect +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.StrokeJoin +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.rememberTextMeasurer +import androidx.compose.ui.text.drawText +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.App +import com.stemroller.mobile.engine.EQ_BANDS +import com.stemroller.mobile.engine.EQ_SLOPES +import com.stemroller.mobile.engine.EqChannel +import com.stemroller.mobile.engine.EqFilter +import com.stemroller.mobile.engine.EqMath +import com.stemroller.mobile.engine.FilterType +import com.stemroller.mobile.eq.ApoConfig +import com.stemroller.mobile.eq.EqController +import com.stemroller.mobile.ui.components.Cell +import com.stemroller.mobile.ui.components.IconButton +import com.stemroller.mobile.ui.components.IosSlider +import com.stemroller.mobile.ui.components.IosSwitch +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.Page +import com.stemroller.mobile.ui.components.SegmentedControl +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.section +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import java.util.Locale +import kotlin.math.abs +import kotlin.math.ln +import kotlin.math.log10 +import kotlin.math.pow + +// ---- formatting and slider mappings -------------------------------------------------------------- + +private const val F_LO = 20.0 +private const val F_HI = 20000.0 +private val RIGHT = Color(0xFFFF9500) + +fun hz(f: Float) = if (f >= 1000f) String.format(Locale.ROOT, if (f >= 10000f) "%.1f kHz" else "%.2f kHz", f / 1000f).replace(".00 ", " ").replace(".0 ", " ") + else "${f.toInt()} Hz" + +private fun signedDb(v: Float) = (if (v > 0.005f) "+" else if (v < -0.005f) "−" else "") + String.format(Locale.ROOT, "%.1f dB", abs(v)) + +private fun freqToPos(f: Float) = (ln(f / F_LO) / ln(F_HI / F_LO)).toFloat().coerceIn(0f, 1f) +private fun posToFreq(p: Float) = (F_LO * (F_HI / F_LO).pow(p.toDouble())).toFloat() +private fun qToPos(q: Float) = (ln(q / EqController.Q_MIN) / ln(EqController.Q_MAX / EqController.Q_MIN)).coerceIn(0f, 1f) +private fun posToQ(p: Float) = EqController.Q_MIN * (EqController.Q_MAX / EqController.Q_MIN).pow(p) + +/** Rounds a dragged frequency to what a person would type: 3 significant figures. */ +private fun tidyFreq(f: Float): Float { + val mag = 10.0.pow(kotlin.math.floor(log10(f.toDouble())) - 2).toFloat() + return (Math.round(f / mag) * mag) +} + +private fun summary(f: EqFilter) = buildList { + if (f.type.hasGain) add(signedDb(f.gain)) + if (f.type.hasSlope) add("${f.slope} dB/oct") + if (!f.type.hasSlope || f.slope == 12) add("Q " + String.format(Locale.ROOT, "%.2f", f.q)) + if (f.channel != EqChannel.Both) add(f.channel.label) +}.joinToString(" · ") + +/** Sensible starting points, audible but mild, for a new filter of each type. */ +private fun newFilter(type: FilterType) = EqFilter(EqController.newFilterId(), type).let { + when (type) { + FilterType.Peak -> it.copy(freq = 1000f, gain = 3f, q = 1.41f) + FilterType.LowShelf -> it.copy(freq = 105f, gain = 3f, q = 0.71f) + FilterType.HighShelf -> it.copy(freq = 8000f, gain = 3f, q = 0.71f) + FilterType.LowPass -> it.copy(freq = 16000f, q = 0.71f) + FilterType.HighPass -> it.copy(freq = 30f, q = 0.71f, slope = 24) + FilterType.BandPass -> it.copy(freq = 1000f, q = 0.71f) + FilterType.Notch -> it.copy(freq = 60f, q = 4f) + FilterType.AllPass -> it.copy(freq = 1000f, q = 0.71f) + } +} + +// ---- response curve ------------------------------------------------------------------------------ + +/** + * The EQ's response, log frequency across, dB up. Left and right are drawn separately when + * some filter applies to only one of them (right in orange). [nodes] are drawn as numbered + * handles; [highlight] gets its own curve in the accent colour. + */ +@Composable +fun EqCurve( + chain: List, + preampDb: Float, + enabled: Boolean, + modifier: Modifier, + range: Float = 18f, + bandMarkers: Boolean = false, + nodes: List = emptyList(), + highlight: EqFilter? = null, + labels: Boolean = false, +) { + val c = Ios.colors + val freqs = remember { EqMath.logFreqs(200, F_LO, F_HI) } + val left = remember(chain) { EqMath.response(chain, freqs, true) } + val right = remember(chain) { if (chain.any { it.channel != EqChannel.Both }) EqMath.response(chain, freqs, false) else null } + val own = remember(highlight) { highlight?.let { EqMath.response(listOf(it), freqs) } } + val text = rememberTextMeasurer() + val labelStyle = Type.caption2.copy(color = c.label3) + Canvas(modifier) { + fun y(db: Double) = (size.height / 2 - (db / range) * (size.height / 2)).toFloat() + fun x(f: Double) = (ln(f / F_LO) / ln(F_HI / F_LO) * size.width).toFloat() + val step = 6.0 + var d = step + while (d < range) { + drawLine(c.separator, Offset(0f, y(d)), Offset(size.width, y(d)), 1f) + drawLine(c.separator, Offset(0f, y(-d)), Offset(size.width, y(-d)), 1f) + d += step + } + drawLine(c.label3, Offset(0f, y(0.0)), Offset(size.width, y(0.0)), 1.5f) + val grid = if (bandMarkers) EQ_BANDS.map { it.toDouble() } else listOf(50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0) + for (f in grid) drawLine(c.separator, Offset(x(f), 0f), Offset(x(f), size.height), 1f) + if (labels) { + for ((f, l) in listOf(100.0 to "100", 1000.0 to "1k", 10000.0 to "10k")) { + drawText(text, l, Offset(x(f) + 3.dp.toPx(), size.height - 14.dp.toPx()), labelStyle) + } + drawText(text, "+${range.toInt()}", Offset(3.dp.toPx(), 1.dp.toPx()), labelStyle) + drawText(text, "−${range.toInt()}", Offset(3.dp.toPx(), size.height - 14.dp.toPx()), labelStyle) + } + val main = if (enabled) c.accent else c.label3 + if (own != null) curve(own, ::y, if (enabled) main.copy(alpha = 0.35f) else c.label3, 1.5.dp.toPx(), fill = y(0.0)) + curve(left, ::y, if (highlight != null) c.label else main, 2.5.dp.toPx()) + right?.let { curve(it, ::y, if (enabled) RIGHT else c.label3, 2.dp.toPx()) } + if (preampDb < 0f && highlight == null) { + val net = DoubleArray(left.size) { left[it] + preampDb } + curve(net, ::y, c.label2, 1.2.dp.toPx(), dashed = true) + } + for ((i, f) in nodes.withIndex()) { + val sel = f.id == highlight?.id + val cx = x(f.freq.toDouble().coerceIn(F_LO, F_HI)) + val cy = if (f.type.hasGain) y(f.gain.toDouble().coerceIn(-range.toDouble(), range.toDouble())) else y(0.0) + val r = (if (sel) 11 else 9).dp.toPx() + val col = when { + !f.on -> c.label3 + f.channel == EqChannel.Right -> RIGHT + else -> main + } + drawCircle(if (sel) Color.White else col, r, Offset(cx, cy)) + if (sel) drawCircle(col, r, Offset(cx, cy), style = Stroke(2.5.dp.toPx())) + val label = text.measure("${i + 1}", Type.caption2.copy(color = if (sel) col else Color.White, fontWeight = FontWeight.Bold)) + drawText(label, topLeft = Offset(cx - label.size.width / 2f, cy - label.size.height / 2f)) + } + } +} + +private fun DrawScope.curve(v: DoubleArray, y: (Double) -> Float, color: Color, width: Float, dashed: Boolean = false, fill: Float? = null) { + val path = Path() + v.forEachIndexed { i, d -> + val x = i / (v.size - 1f) * size.width + if (i == 0) path.moveTo(x, y(d)) else path.lineTo(x, y(d)) + } + if (fill != null) { + val area = Path().apply { addPath(path); lineTo(size.width, fill); lineTo(0f, fill); close() } + drawPath(area, color.copy(alpha = color.alpha * 0.4f)) + } + drawPath(path, color, style = Stroke(width, cap = StrokeCap.Round, join = StrokeJoin.Round, + pathEffect = if (dashed) PathEffect.dashPathEffect(floatArrayOf(6f, 6f)) else null)) +} + +// ---- filter list --------------------------------------------------------------------------------- + +@Composable +fun EqFiltersScreen(profileId: String) { + val eq = App.graph.eq + val c = Ios.colors + val nav = LocalNav.current + val overlays = LocalOverlays.current + val context = LocalContext.current + val state by eq.state.collectAsState() + val profile = state.profiles.firstOrNull { it.id == profileId } + LaunchedEffect(profile == null) { if (profile == null) nav.pop() } + if (profile == null) return + val chain = remember(profile) { profile.chain } + val preamp = remember(profile, state.antiClip) { profile.preamp + if (state.antiClip) EqMath.autoPreampDb(chain, profile.preamp) else 0f } + val clipboard = remember { context.getSystemService(ClipboardManager::class.java) } + + fun add() { + overlays.actions("Add Filter", FilterType.entries.map { t -> + SheetAction(t.label) { + val f = newFilter(t) + eq.putFilter(profileId, f) + nav.push(Route.EqFilterPage(profileId, f.id)) + } + }) + } + + fun import() { + val text = clipboard.primaryClip?.takeIf { it.itemCount > 0 }?.getItemAt(0)?.coerceToText(context)?.toString().orEmpty() + val parsed = ApoConfig.parse(text) + if (parsed == null) { + overlays.hud("No Equalizer APO filters on the clipboard", Sym.info) + return + } + val what = listOfNotNull( + "${parsed.filters.size} filter${if (parsed.filters.size == 1) "" else "s"}".takeIf { parsed.filters.isNotEmpty() }, + parsed.preamp?.let { "preamp ${signedDb(it)}" }, + ).joinToString(" and ") + val skipped = if (parsed.skipped > 0) " ${parsed.skipped} line${if (parsed.skipped == 1) "" else "s"} it doesn't understand (GraphicEQ, Delay…) will be skipped." else "" + overlays.confirm("Replace Filters?", "Loads $what into “${profile.name}”, replacing its ${profile.filters.size} filter${if (profile.filters.size == 1) "" else "s"}.$skipped", "Replace", destructive = false) { + eq.setFilters(profileId, parsed.filters, parsed.preamp) + overlays.hud("Imported $what") + } + } + + Page("Filters", grouped = true, largeTitle = false, trailing = { + IconButton(Sym.ellipsis, { + overlays.actions("Equalizer APO / AutoEQ", buildList { + add(SheetAction("Paste APO Config") { import() }) + add(SheetAction("Copy as APO Config") { + clipboard.setPrimaryClip(ClipData.newPlainText("${profile.name} EQ", ApoConfig.format(profile))) + overlays.hud("Copied") + }) + if (profile.filters.isNotEmpty()) add(SheetAction("Remove All Filters", destructive = true) { + overlays.confirm("Remove All Filters?", "The graphic EQ bands stay as they are.", "Remove All") { eq.setFilters(profileId, emptyList(), null) } + }) + }) + }) + IconButton(Sym.plus, { add() }) + }) { + section("curve", header = profile.name, footer = "Tap a numbered handle to edit that filter. Right-channel filters are orange. Paste an AutoEQ ParametricEQ.txt (from the ••• menu) to load a headphone correction.", rows = listOf { + Box(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 10.dp)) { + val nodes = profile.filters + val tap by rememberUpdatedState { o: Offset, w: Float, h: Float -> + val hit = nodes.withIndex().minByOrNull { (_, f) -> + val dx = freqToPos(f.freq) * w - o.x + val dy = (if (f.type.hasGain) h / 2 - f.gain / 18f * h / 2 else h / 2) - o.y + dx * dx + dy * dy + } + if (hit != null) { + val f = hit.value + val dx = freqToPos(f.freq) * w - o.x + if (abs(dx) < 40f * context.resources.displayMetrics.density) nav.push(Route.EqFilterPage(profileId, f.id)) + } + } + EqCurve(chain, preamp, state.enabled, Modifier.fillMaxWidth().height(170.dp).pointerInput(Unit) { + detectTapGestures { o -> tap(o, size.width.toFloat(), size.height.toFloat()) } + }, nodes = nodes, labels = true) + } + }) + + section("preamp", header = "Preamp", footer = if (state.antiClip) "Anti-clipping adds ${signedDb(preamp - profile.preamp)} on top, so the total is ${signedDb(preamp)}." else null, rows = listOf { + Row(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 4.dp), verticalAlignment = Alignment.CenterVertically) { + IosSlider((profile.preamp + EqController.PREAMP_RANGE) / (2 * EqController.PREAMP_RANGE), { v -> + eq.setPreamp(profileId, Math.round((v * 2 - 1) * EqController.PREAMP_RANGE * 10) / 10f) + }, Modifier.weight(1f), detent = 0.5f) + ValueLabel(signedDb(profile.preamp), 76.dp) { + overlays.prompt("Preamp", "In dB, −24 to +24.", String.format(Locale.ROOT, "%.1f", profile.preamp), "Set") { s -> + s.replace(',', '.').replace('−', '-').toFloatOrNull()?.let { eq.setPreamp(profileId, it) } + } + } + } + }) + + section("list", header = "Filters", rows = profile.filters.mapIndexed Unit> { i, f -> + { + Cell("${i + 1}. ${f.type.label} · ${hz(f.freq)}", subtitle = summary(f).ifEmpty { null }, + titleColor = if (f.on) c.label else c.label2, trailing = { IosSwitch(f.on, { on -> eq.putFilter(profileId, f.copy(on = on)) }) }, + onLongClick = { + overlays.actions("${f.type.label} · ${hz(f.freq)}", listOf( + SheetAction("Duplicate") { eq.putFilter(profileId, f.copy(id = EqController.newFilterId())) }, + SheetAction("Delete", destructive = true) { eq.removeFilter(profileId, f.id) }, + )) + }) { nav.push(Route.EqFilterPage(profileId, f.id)) } + } + } + listOf<@Composable () -> Unit> { Cell("Add Filter…", titleColor = c.accent) { add() } }) + } +} + +@Composable +private fun ValueLabel(text: String, width: Dp, onClick: () -> Unit) { + val c = Ios.colors + Box(Modifier.width(width).padding(start = 10.dp).pointerInput(Unit) { detectTapGestures { onClick() } }, contentAlignment = Alignment.CenterEnd) { + Txt(text, Type.subhead.copy(fontFeatureSettings = "tnum"), color = c.accent) + } +} + +// ---- one filter ---------------------------------------------------------------------------------- + +@Composable +fun EqFilterScreen(profileId: String, filterId: String) { + val eq = App.graph.eq + val c = Ios.colors + val nav = LocalNav.current + val overlays = LocalOverlays.current + val state by eq.state.collectAsState() + val profile = state.profiles.firstOrNull { it.id == profileId } + val filter = profile?.filters?.firstOrNull { it.id == filterId } + LaunchedEffect(filter == null) { if (filter == null) nav.pop() } + if (profile == null || filter == null) return + val f: EqFilter = filter + val number = profile.filters.indexOf(f) + 1 + val chain = remember(profile) { profile.chain } + val current by rememberUpdatedState(f) + fun put(nf: EqFilter) = eq.putFilter(profileId, nf) + fun number(title: String, hint: String, initial: Float, set: (Float) -> Unit) = + overlays.prompt(title, hint, String.format(Locale.ROOT, "%.2f", initial).trimEnd('0').trimEnd('.'), "Set") { s -> + s.replace(',', '.').replace('−', '-').filter { it.isDigit() || it == '.' || it == '-' }.toFloatOrNull()?.let(set) + } + + Page("$number. ${f.type.label}", grouped = true, largeTitle = false, trailing = { + IconButton(Sym.ellipsis, { + overlays.actions("${f.type.label} · ${hz(f.freq)}", listOf( + SheetAction("Duplicate") { + val copy = f.copy(id = EqController.newFilterId()) + put(copy) + nav.push(Route.EqFilterPage(profileId, copy.id)) + }, + SheetAction("Delete Filter", destructive = true) { eq.removeFilter(profileId, f.id) }, + )) + }) + }) { + section("curve", footer = if (f.type.hasGain) "Drag the handle: sideways for frequency, up and down for gain." else "Drag the handle sideways to change the frequency.", rows = listOf { + Box(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 10.dp)) { + EqCurve(chain, 0f, state.enabled && f.on, Modifier.fillMaxWidth().height(190.dp).pointerInput(Unit) { + var startPos = Offset.Zero + var acc = Offset.Zero + detectDragGestures(onDragStart = { o -> startPos = o; acc = Offset.Zero }) { ch, drag -> + ch.consume() + acc += drag + val cur = current + val p = ((startPos.x + acc.x) / size.width).coerceIn(0f, 1f) + val gain = if (cur.type.hasGain) (18f * (1f - 2f * (startPos.y + acc.y) / size.height)).coerceIn(-18f, 18f) else cur.gain + put(cur.copy(freq = tidyFreq(posToFreq(p)), gain = Math.round(gain * 10) / 10f)) + } + }, nodes = profile.filters, highlight = f, labels = true) + } + }) + + section("type", rows = listOf( + { Cell("Type", value = f.type.label, chevron = true) { + overlays.actions("Filter Type", FilterType.entries.map { t -> + SheetAction((if (t == f.type) "✓ " else "") + t.label) { + put(f.copy(type = t, q = if (t == FilterType.Notch && f.type != FilterType.Notch) 4f else f.q)) + } + }) + } }, + { Cell("On", trailing = { IosSwitch(f.on, { put(f.copy(on = it)) }) }) }, + )) + + val rows = buildList<@Composable () -> Unit> { + add { + ParamRow("Frequency", hz(f.freq), { number("Frequency", "In Hz, 10 to 22000.", f.freq) { v -> put(f.copy(freq = v)) } }) { + IosSlider(freqToPos(f.freq), { put(f.copy(freq = tidyFreq(posToFreq(it)))) }) + } + } + if (f.type.hasGain) add { + ParamRow("Gain", signedDb(f.gain), { number("Gain", "In dB, −24 to +24.", f.gain) { v -> put(f.copy(gain = v)) } }) { + IosSlider((f.gain + EqController.FILTER_GAIN) / (2 * EqController.FILTER_GAIN), { + put(f.copy(gain = Math.round((it * 2 - 1) * EqController.FILTER_GAIN * 10) / 10f)) + }, detent = 0.5f) + } + } + if (!f.type.hasSlope || f.slope == 12) add { + ParamRow("Q", String.format(Locale.ROOT, "%.2f", f.q), { number("Q", "0.1 (broad) to 20 (narrow). One octave is 1.41.", f.q) { v -> put(f.copy(q = v)) } }) { + IosSlider(qToPos(f.q), { put(f.copy(q = Math.round(posToQ(it) * 100) / 100f)) }) + } + } + if (f.type.hasSlope) add { + Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 10.dp)) { + Txt("Slope (dB per octave)", Type.subhead, color = c.label2) + SegmentedControl(EQ_SLOPES.map { it.toString() }, EQ_SLOPES.indexOf(f.slope).coerceAtLeast(0), { put(f.copy(slope = EQ_SLOPES[it])) }, + Modifier.padding(top = 8.dp)) + } + } + add { + Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 10.dp)) { + Txt("Channel", Type.subhead, color = c.label2) + SegmentedControl(EqChannel.entries.map { it.label }, f.channel.ordinal, { put(f.copy(channel = EqChannel.entries[it])) }, + Modifier.padding(top = 8.dp)) + } + } + } + section("params", footer = when { + f.type.hasSlope && f.slope != 12 -> "Steeper than 12 dB/oct is a Butterworth response, so there's no Q." + f.type == FilterType.AllPass -> "An all-pass changes phase around its frequency, not level, so the curve stays flat." + else -> "Tap a value to type it." + }, rows = rows) + } +} + +@Composable +private fun ParamRow(title: String, value: String, onValue: () -> Unit, slider: @Composable () -> Unit) { + val c = Ios.colors + Column(Modifier.fillMaxWidth().padding(start = 16.dp, end = 16.dp, top = 10.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Txt(title, Type.subhead, Modifier.weight(1f), color = c.label2) + ValueLabel(value, 110.dp, onValue) + } + slider() + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqScreen.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqScreen.kt new file mode 100644 index 0000000..c6cf804 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/EqScreen.kt @@ -0,0 +1,166 @@ +package com.stemroller.mobile.ui.screens + +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.StrokeJoin +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.App +import com.stemroller.mobile.engine.EQ_BANDS +import com.stemroller.mobile.engine.EQ_LABELS +import com.stemroller.mobile.engine.EQ_MAX_DB +import com.stemroller.mobile.engine.EqMath +import com.stemroller.mobile.eq.DeviceKind +import com.stemroller.mobile.eq.EQ_PRESETS +import com.stemroller.mobile.eq.EqProfile +import com.stemroller.mobile.eq.OutputDevice +import com.stemroller.mobile.ui.components.Cell +import com.stemroller.mobile.ui.components.IosSwitch +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.Page +import com.stemroller.mobile.ui.components.SegmentedControl +import com.stemroller.mobile.ui.components.SettingsIcon +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.VerticalBandSlider +import com.stemroller.mobile.ui.components.section +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlin.math.abs + +fun deviceIcon(d: OutputDevice): Pair = when (d.kind) { + DeviceKind.Speaker -> Sym.phone to androidx.compose.ui.graphics.Color(0xFF8E8E93) + DeviceKind.Bluetooth -> Sym.headphones to androidx.compose.ui.graphics.Color(0xFF007AFF) + DeviceKind.Wired -> Sym.headphones to androidx.compose.ui.graphics.Color(0xFF34C759) + DeviceKind.Usb -> Sym.usb to androidx.compose.ui.graphics.Color(0xFFFF9500) + DeviceKind.Hdmi -> Sym.airplay to androidx.compose.ui.graphics.Color(0xFF5856D6) + DeviceKind.Other -> Sym.speakerWave to androidx.compose.ui.graphics.Color(0xFF8E8E93) +} + +private fun db(v: Float) = (if (v > 0) "+" else if (v < 0) "−" else "") + "%.1f".format(abs(v)) + +@Composable +fun EqScreen() { + val eq = App.graph.eq + val c = Ios.colors + val overlays = LocalOverlays.current + val state by eq.state.collectAsState() + val device by eq.device.collectAsState() + val active by eq.active.collectAsState() + val linked = state.profiles.firstOrNull { device in it.devices } + val profile = active + val nav = LocalNav.current + val chain = remember(profile) { profile?.chain.orEmpty() } + val preamp = remember(profile, state.antiClip) { + if (profile == null) 0f else profile.preamp + if (state.antiClip) EqMath.autoPreampDb(chain, profile.preamp) else 0f + } + + fun profileMenu(p: EqProfile) { + overlays.actions(p.name, buildList { + if (device !in p.devices) add(SheetAction("Use for ${device.label}") { eq.link(p.id, device, true) }) + else add(SheetAction("Unlink from ${device.label}") { eq.link(p.id, device, false) }) + if (state.defaultId != p.id) add(SheetAction("Make Default") { eq.setDefault(p.id) }) + add(SheetAction("Rename…") { overlays.prompt("Rename Profile", null, p.name, "Save") { eq.rename(p.id, it) } }) + add(SheetAction("Duplicate") { eq.create("${p.name} Copy", p) }) + if (state.profiles.size > 1) add(SheetAction("Delete Profile", destructive = true) { + overlays.confirm("Delete “${p.name}”?", null, "Delete") { eq.delete(p.id) } + }) + }) + } + + fun profilesSheet() { + overlays.actions("Profiles", buildList { + state.profiles.forEach { p -> + val links = p.devices.joinToString { it.label } + add(SheetAction((if (active?.id == p.id) "✓ " else "") + p.name + if (links.isNotEmpty()) " ($links)" else "") { eq.select(p.id) }) + } + add(SheetAction("New Profile…") { + overlays.prompt("New EQ Profile", "Starts from the current curve.", "", "Create", "e.g. Sony WH-1000XM5") { name -> + val p = eq.create(name, profile) + eq.link(p.id, device, true) + } + }) + profile?.let { p -> add(SheetAction("Manage “${p.name}”…") { profileMenu(p) }) } + }) + } + + // One screen, no scrolling: profile management and presets live in sheets. + Page("Equalizer", grouped = true, largeTitle = false) { + section("enabled", rows = listOf( + { Cell("Equalizer", icon = { SettingsIcon(Sym.sliders, c.accent) }, trailing = { IosSwitch(state.enabled, eq::setEnabled) }) }, + { Cell("Anti-Clipping Preamp", trailing = { IosSwitch(state.antiClip, eq::setAntiClip) }) }, + )) + + val (icon, tint) = deviceIcon(device) + section("device", header = "Output", separatorInset = 60.dp, rows = listOf( + { Cell(device.label, icon = { SettingsIcon(icon, tint) }, value = linked?.name ?: "Default") { + overlays.actions("Profile for ${device.label}", listOf(SheetAction("Use Default") { + state.profiles.filter { device in it.devices }.forEach { eq.link(it.id, device, false) } + }) + state.profiles.map { p -> SheetAction(p.name) { eq.link(p.id, device, true) } }) + } }, + { + Box(Modifier.padding(horizontal = 16.dp, vertical = 8.dp)) { + SegmentedControl(listOf("Automatic", "Manual"), if (state.automatic) 0 else 1, { eq.setAutomatic(it == 0) }) + } + }, + )) + + if (profile != null) { + section("editor", header = "${profile.name}${if (state.automatic) "" else " (manual)"}", rows = listOf { + Column(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 10.dp)) { + EqCurve(chain, preamp, state.enabled, Modifier.fillMaxWidth().height(64.dp), range = EQ_MAX_DB + 3f, bandMarkers = true) + Spacer(Modifier.height(6.dp)) + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) { + profile.gains.forEachIndexed { i, g -> + Column(horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.width(32.dp)) { + Txt(db(g), Type.caption2.copy(fontFeatureSettings = "tnum"), color = if (g == 0f) c.label2 else c.accent, align = TextAlign.Center) + Spacer(Modifier.height(2.dp)) + VerticalBandSlider(g / EQ_MAX_DB, { eq.setGain(profile.id, i, it * EQ_MAX_DB) }, Modifier.height(124.dp)) + Spacer(Modifier.height(2.dp)) + Txt(EQ_LABELS[i], Type.caption2, color = c.label2, align = TextAlign.Center) + } + } + } + Spacer(Modifier.height(6.dp)) + Row(verticalAlignment = Alignment.CenterVertically) { + Txt("Preamp", Type.footnote, Modifier.weight(1f), color = c.label2) + Txt(if (preamp != 0f) "${db(preamp)} dB" else "off", Type.footnote.copy(fontFeatureSettings = "tnum"), color = c.label2) + } + } + }) + } + + section("profiles", rows = listOf( + { Cell("Profile", value = profile?.name ?: "—", chevron = true, onLongClick = { profile?.let { profileMenu(it) } }) { profilesSheet() } }, + { Cell("Parametric Filters", value = profile?.filters?.let { f -> if (f.isEmpty()) "None" else "${f.count { it.on }} on" } ?: "—", chevron = true) { + profile?.let { nav.push(Route.EqFilters(it.id)) } + } }, + { Cell("Presets", value = "Flat, Bass…", chevron = true) { + val p = profile ?: return@Cell + overlays.actions("Load Preset", EQ_PRESETS.map { (name, gains) -> SheetAction(name) { eq.setGains(p.id, gains) } }) + } }, + )) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/LibraryScreens.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/LibraryScreens.kt new file mode 100644 index 0000000..91fbdb9 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/LibraryScreens.kt @@ -0,0 +1,547 @@ +package com.stemroller.mobile.ui.screens + +import androidx.compose.foundation.background +import com.stemroller.mobile.ui.components.ProgressRing +import androidx.compose.ui.draw.clip +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.gestures.awaitEachGesture +import androidx.compose.foundation.gestures.awaitFirstDown +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyListState +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.runtime.snapshotFlow +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.hapticfeedback.HapticFeedbackType +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalHapticFeedback +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.App +import com.stemroller.mobile.plex.Album +import com.stemroller.mobile.plex.Artist +import com.stemroller.mobile.plex.Track +import com.stemroller.mobile.cache.DownloadRecord +import com.stemroller.mobile.ui.components.Artwork +import com.stemroller.mobile.ui.components.Chevron +import com.stemroller.mobile.ui.components.EmptyState +import com.stemroller.mobile.ui.components.ErrorRow +import com.stemroller.mobile.ui.components.Hairline +import com.stemroller.mobile.ui.components.IconButton +import com.stemroller.mobile.ui.components.LoadingRow +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.MARGIN +import com.stemroller.mobile.ui.components.Page +import com.stemroller.mobile.ui.components.SectionTitle +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.TextButton +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.nav.Load +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.nav.rememberInEntry +import com.stemroller.mobile.ui.nav.rememberLoader +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.flow.distinctUntilChanged +import java.time.LocalDate +import java.time.format.DateTimeFormatter +import kotlinx.coroutines.flow.filter +import kotlinx.coroutines.launch + +@Composable +fun LibraryHome() { + val g = App.graph + val nav = LocalNav.current + val c = Ios.colors + val menu = rememberMediaMenu() + val token by g.settings.plexToken.flow.collectAsState() + val section by g.settings.musicSection.flow.collectAsState() + val today = remember { LocalDate.now() } + val albums = rememberLoader("albums:$section") { g.plex.albums() } + val days = remember(albums.value, today) { albums.value?.let { birthdays(it, today) } } + val ready = token.isNotEmpty() && section.isNotEmpty() + + Page("Library") { + if (!ready) { + item("connect") { + EmptyState(Sym.server, "Connect to Plex", "Sign in to your Plex server to browse your music. Stems come from stemserve on the same box.", "Connect") { + nav.push(Route.PlexAccount) + } + } + } + val rows: List> = listOf( + Triple(Sym.noteList, Route.Playlists, null), + Triple(Sym.person, Route.Artists, null), + Triple(Sym.album, Route.Albums, null), + Triple(Sym.note, Route.Songs, null), + ) + itemsIndexed(rows, key = { _, r -> r.second.title }) { i, (icon, route, value) -> + LibraryRow(icon, route.title, value, last = i == rows.lastIndex) { nav.push(route) } + } + if (ready) { + item("dayTitle") { + Column { + SectionTitle("On This Day") + Txt(today.format(DateTimeFormatter.ofPattern("MMMM d")), Type.subhead, Modifier.padding(start = MARGIN.dp, bottom = 10.dp), color = c.label2) + } + } + when (val s = albums.state.value) { + Load.Loading -> item("dayLoading") { LoadingRow() } + is Load.Err -> item("dayErr") { ErrorRow(s.message) { albums.refresh(true) } } + is Load.Ok -> { + val (onDay, week) = days ?: (emptyList() to emptyList()) + if (onDay.isNotEmpty()) { + albumGrid("today", onDay.map { it.album }, onClick = { nav.push(Route.AlbumPage(it)) }, onLongClick = { menu.album(it) }, + subtitle = { a -> onDay.first { it.album === a }.let { "${a.artist} · ${yearsAgo(it.years)}" } }) + } else { + item("dayNone") { + Txt(if (week.isEmpty()) "No albums in your library came out this week in any year." else "No album birthdays today. Coming up and just past:", + Type.subhead, Modifier.padding(horizontal = MARGIN.dp).padding(bottom = 12.dp), color = c.label2, maxLines = 3) + } + if (week.isNotEmpty()) { + albumGrid("week", week.map { it.album }, onClick = { nav.push(Route.AlbumPage(it)) }, onLongClick = { menu.album(it) }, + subtitle = { a -> + week.first { it.album === a }.let { b -> + val verb = if (b.date.isBefore(today)) "Turned" else "Turns" + "$verb ${b.years} · ${b.date.format(DateTimeFormatter.ofPattern("MMM d"))}" + } + }) + } + } + } + } + } + } +} + +/** An album's anniversary: its release day this year, and how old it is then. */ +private class Birthday(val album: Album, val date: LocalDate, val years: Int) + +private fun yearsAgo(n: Int) = if (n == 1) "1 year ago" else "$n years ago" + +/** Albums released on [today]'s date in earlier years, and, for slow days, the three days either side. */ +private fun birthdays(albums: List, today: LocalDate): Pair, List> { + val all = albums.mapNotNull { a -> + val d = a.released?.let { runCatching { LocalDate.parse(it.take(10)) }.getOrNull() } ?: return@mapNotNull null + if (d.year >= today.year) return@mapNotNull null + val anniversary = d.withYear(today.year) // Feb 29 falls back to Feb 28 + Birthday(a, anniversary, today.year - d.year) + } + val onDay = all.filter { it.date == today }.sortedByDescending { it.years } + val week = all.filter { it.date != today && kotlin.math.abs(it.date.toEpochDay() - today.toEpochDay()) <= 3 } + .sortedWith(compareBy({ it.date }, { -it.years })) + return onDay to week +} + +@Composable +private fun LibraryRow(icon: ImageVector, title: String, value: String?, last: Boolean, onClick: () -> Unit) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + Box(Modifier.fillMaxWidth().background(if (pressed) c.cellPressed else Color.Transparent)) { + Row( + Modifier.fillMaxWidth().height(52.dp).tappable(interaction = src, onClick = onClick).padding(start = MARGIN.dp, end = 16.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Icon(icon, c.accent, size = 26.dp) + Spacer(Modifier.width(14.dp)) + Txt(title, Type.title3, Modifier.weight(1f), weight = FontWeight.Normal) + if (value != null) Txt(value, Type.body, color = c.label2, modifier = Modifier.padding(end = 8.dp)) + Chevron() + } + if (!last) Hairline(Modifier.align(Alignment.BottomStart).padding(start = 60.dp)) + } +} + +// ---- artists -------------------------------------------------------------------------------------- + +@Composable +fun ArtistsScreen() { + val g = App.graph + val nav = LocalNav.current + val menu = rememberMediaMenu() + val artists = rememberLoader("artists") { g.plex.artists() } + val state = rememberLazyListState() + Page("Artists", state = state, overlay = { + val list = artists.value + if (list != null && list.size > 30) SectionIndex(list.map { it.sortTitle }, state, Modifier.align(Alignment.CenterEnd)) + }) { + when (val s = artists.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { artists.refresh(true) } } + is Load.Ok -> items(s.value.size, key = { s.value[it].ratingKey }) { i -> + val a = s.value[i] + ArtistRow(a, onLongClick = { menu.artist(a) }) { nav.push(Route.ArtistPage(a)) } + } + } + } +} + +private fun letterOf(s: String): Char { + val ch = s.trimStart().removePrefix("The ").firstOrNull()?.uppercaseChar() ?: '#' + return if (ch in 'A'..'Z') ch else '#' +} + +/** UITableView's section index: drag down the letters to jump. */ +@Composable +private fun SectionIndex(titles: List, state: LazyListState, modifier: Modifier) { + val c = Ios.colors + val scope = rememberCoroutineScope() + val haptic = LocalHapticFeedback.current + val letters = remember { ('A'..'Z').toList() + '#' } + val firstIndex = remember(titles) { + val m = HashMap() + titles.forEachIndexed { i, t -> m.putIfAbsent(letterOf(t), i) } + m + } + var last by remember { mutableStateOf(null) } + fun jump(fraction: Float) { + val l = letters[(fraction * letters.size).toInt().coerceIn(0, letters.lastIndex)] + if (l == last) return + last = l + val target = letters.drop(letters.indexOf(l)).firstNotNullOfOrNull { firstIndex[it] } ?: return + haptic.performHapticFeedback(HapticFeedbackType.SegmentTick) + scope.launch { state.scrollToItem(target + 1) } + } + Column( + modifier.fillMaxHeight(0.62f).width(22.dp).padding(end = 2.dp) + .pointerInput(titles) { + awaitEachGesture { + val down = awaitFirstDown() + jump(down.position.y / size.height) + while (true) { + val ev = awaitPointerEvent() + val p = ev.changes.firstOrNull() ?: break + if (!p.pressed) break + p.consume() + jump(p.position.y / size.height) + } + last = null + } + }, + verticalArrangement = Arrangement.SpaceEvenly, + horizontalAlignment = Alignment.CenterHorizontally, + ) { + letters.forEach { Txt(it.toString(), Type.caption2, color = c.accent, weight = FontWeight.SemiBold) } + } +} + +// ---- albums --------------------------------------------------------------------------------------- + +private val ALBUM_SORTS = listOf("Title" to "titleSort", "Artist" to "artist.titleSort,year", "Recently Added" to "addedAt:desc", "Year" to "year:desc") + +@Composable +fun AlbumsScreen() { + val g = App.graph + val nav = LocalNav.current + val menu = rememberMediaMenu() + val overlays = LocalOverlays.current + var sort by rememberInEntry("sort") { mutableIntStateOf(0) } + val albums = rememberLoader("albums:$sort") { g.plex.albums(ALBUM_SORTS[sort].second) } + Page("Albums", trailing = { + TextButton("Sort", { + overlays.actions("Sort By", ALBUM_SORTS.mapIndexed { i, (label, _) -> SheetAction(if (i == sort) "✓ $label" else label) { sort = i } }) + }) + }) { + when (val s = albums.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { albums.refresh(true) } } + is Load.Ok -> { + item("gap") { Spacer(Modifier.height(8.dp)) } + albumGrid("albums", s.value, onClick = { nav.push(Route.AlbumPage(it)) }, onLongClick = { menu.album(it) }) + } + } + } +} + +// ---- songs (paged) -------------------------------------------------------------------------------- + +private class SongPager { + val tracks = mutableStateListOf() + var total by mutableIntStateOf(-1) + var loading by mutableStateOf(false) + var error by mutableStateOf(null) +} + +@Composable +fun SongsScreen() { + val g = App.graph + val menu = rememberMediaMenu() + val pager = rememberInEntry("pager") { SongPager() } + val state = rememberLazyListState() + val scope = rememberCoroutineScope() + fun loadMore() { + if (pager.loading || (pager.total >= 0 && pager.tracks.size >= pager.total)) return + pager.loading = true + scope.launch { + runCatching { g.plex.tracksPage(pager.tracks.size, 200) } + .onSuccess { (page, total) -> pager.tracks += page; pager.total = total; pager.error = null } + .onFailure { pager.error = it.message } + pager.loading = false + } + } + LaunchedEffect(Unit) { + if (pager.tracks.isEmpty()) loadMore() + snapshotFlow { state.layoutInfo.visibleItemsInfo.lastOrNull()?.index ?: 0 } + .distinctUntilChanged().filter { it > pager.tracks.size - 40 }.collect { loadMore() } + } + val subtitleTotal by remember { derivedStateOf { if (pager.total > 0) songs(pager.total) else null } } + Page("Songs", state = state) { + if (pager.tracks.isNotEmpty()) { + item("buttons") { + Column { + subtitleTotal?.let { Txt(it, Type.subhead, Modifier.padding(start = MARGIN.dp, bottom = 12.dp), color = Ios.colors.label2) } + PlayShuffle( + onPlay = { g.playback.playTracks(pager.tracks.take(1000), 0) }, + onShuffle = { g.playback.playTracks(pager.tracks.take(1000), shuffle = true) }, + ) + Spacer(Modifier.height(12.dp)) + } + } + } + items(pager.tracks.size, key = { pager.tracks[it].ratingKey }) { i -> + val t = pager.tracks[i] + TrackRow(t, onClick = { + val from = (i - 200).coerceAtLeast(0) + g.playback.playTracks(pager.tracks.subList(from, (i + 800).coerceAtMost(pager.tracks.size)).toList(), i - from) + }, onMore = { menu.show(t) }) + } + if (pager.loading) item("more") { LoadingRow() } + pager.error?.let { e -> item("err") { ErrorRow(e) { loadMore() } } } + } +} + +// ---- album & artist pages ------------------------------------------------------------------------- + +@Composable +fun AlbumScreen(album: Album) { + val g = App.graph + val nav = LocalNav.current + val c = Ios.colors + val menu = rememberMediaMenu() + val overlays = LocalOverlays.current + val tracks = rememberLoader("tracks") { g.plex.albumTracks(album.ratingKey) } + val detail = rememberLoader("detail") { g.plex.album(album.ratingKey) ?: album } + val a = detail.value ?: album + val records by g.downloads.records.collectAsState() + val list = tracks.value.orEmpty() + val allDownloaded = list.isNotEmpty() && list.all { records[it.ratingKey]?.done == true } + + Page(a.title, largeTitle = false, trailing = { + if (list.isNotEmpty()) { + IconButton(if (allDownloaded) Sym.check else Sym.download, { + if (allDownloaded) overlays.confirm("Remove Download?", "“${a.title}” will no longer be available offline.", "Remove") { g.downloads.remove(list) } + else { g.downloads.download(list); overlays.hud("Downloading", Sym.download) } + }) + IconButton(Sym.ellipsis, { menu.album(a) }) + } + }) { + item("header") { + Column(Modifier.fillMaxWidth().padding(top = 8.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Artwork(a.thumb, 264.dp, corner = 10.dp, placeholder = Sym.album) + Spacer(Modifier.height(16.dp)) + Txt(a.title, Type.title3, Modifier.padding(horizontal = 32.dp), align = TextAlign.Center, maxLines = 2) + Txt(a.artist, Type.title3, Modifier.padding(horizontal = 32.dp).tappable { + a.artistKey?.let { nav.push(Route.ArtistPage(Artist(it, a.artist, a.artist))) } + }, color = c.accent, weight = FontWeight.Normal, align = TextAlign.Center) + val meta = listOfNotNull(a.genre?.uppercase(), a.year?.toString()).joinToString(" · ") + if (meta.isNotEmpty()) Txt(meta, Type.caption1, Modifier.padding(top = 4.dp), color = c.label2, weight = FontWeight.SemiBold) + Spacer(Modifier.height(16.dp)) + PlayShuffle(onPlay = { g.playback.playTracks(list, 0) }, onShuffle = { g.playback.playTracks(list, shuffle = true) }) + Spacer(Modifier.height(16.dp)) + Hairline(Modifier.padding(start = MARGIN.dp)) + } + } + when (val s = tracks.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { tracks.refresh(true) } } + is Load.Ok -> { + val discs = s.value.mapNotNull { it.disc }.toSet().size > 1 + s.value.forEachIndexed { i, t -> + if (discs && (i == 0 || s.value[i - 1].disc != t.disc)) { + item("disc${t.disc}") { Txt("Disc ${t.disc}", Type.headline, Modifier.padding(start = MARGIN.dp, top = 18.dp, bottom = 6.dp), color = c.label2) } + } + item(t.ratingKey) { + TrackRow(t, onClick = { g.playback.playTracks(s.value, i) }, number = t.index ?: (i + 1), showArt = false, + subtitle = t.artist.takeIf { it != a.artist }, onMore = { menu.show(t, allowGoTo = false) }) + } + } + item("footer") { + Txt("${songs(s.value.size)}, ${formatMinutes(s.value.sumOf { it.durationMs })}", Type.subhead, + Modifier.padding(start = MARGIN.dp, top = 14.dp), color = c.label2) + } + } + } + } +} + +@Composable +fun ArtistScreen(artist: Artist) { + val g = App.graph + val nav = LocalNav.current + val menu = rememberMediaMenu() + val scope = rememberCoroutineScope() + val overlays = LocalOverlays.current + val albums = rememberLoader("albums") { g.plex.artistAlbums(artist.ratingKey).sortedByDescending { it.year ?: 0 } } + fun playAll(shuffle: Boolean) = scope.launch { + runCatching { g.plex.artistTracks(artist.ratingKey) } + .onSuccess { g.playback.playTracks(it, 0, shuffle) } + .onFailure { overlays.hud("Couldn't load songs", Sym.warning) } + } + Page(artist.title, trailing = { IconButton(Sym.ellipsis, { menu.artist(artist) }) }) { + item("buttons") { + Column(Modifier.padding(top = 6.dp, bottom = 18.dp)) { PlayShuffle(onPlay = { playAll(false) }, onShuffle = { playAll(true) }) } + } + when (val s = albums.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { albums.refresh(true) } } + is Load.Ok -> albumGrid("albums", s.value, onClick = { nav.push(Route.AlbumPage(it)) }, onLongClick = { menu.album(it, allowGoTo = false) }, showArtist = false) + } + } +} + +// ---- downloads ------------------------------------------------------------------------------------ + +private val DOWNLOAD_SORTS = listOf("Download Order", "Artist", "Release Date") + +/** Downloaded songs gathered back into their albums. */ +private class DownloadedAlbum(val album: Album, val records: List, val released: String?) { + val added = records.maxOf { it.added } + val done = records.count { it.done } + val failed = records.count { it.error != null } + val complete get() = done == records.size + val tracks get() = records.map { it.track }.sortedWith(compareBy({ it.disc ?: 0 }, { it.index ?: 0 }, { it.title.lowercase() })) +} + +private fun artistSortKey(s: String) = s.trim().lowercase().removePrefix("the ") + +@Composable +fun DownloadsScreen() { + val g = App.graph + val c = Ios.colors + val nav = LocalNav.current + val menu = rememberMediaMenu() + val overlays = LocalOverlays.current + val section by g.settings.musicSection.flow.collectAsState() + val records by g.downloads.records.collectAsState() + val progress by g.downloads.progress.collectAsState() + val usage by g.cache.usage.collectAsState() + val sort by g.settings.downloadSort.flow.collectAsState() + // Release days come from the album list (served from the HTTP cache when the server's away). + val albumInfo = rememberLoader("albums:$section") { g.plex.albums().associateBy { it.ratingKey } } + val info = albumInfo.value.orEmpty() + + val albums = remember(records, info, sort) { + val grouped = records.values.groupBy { r -> r.track.albumKey ?: "name:${r.track.artist}|${r.track.album}" }.map { (key, rs) -> + val t = rs.first().track + val known = info[key] + val artists = rs.map { it.track.artist }.distinct() + DownloadedAlbum( + known ?: Album(key, t.album.ifEmpty { "Unknown Album" }, if (artists.size > 1) "Various Artists" else t.artist, t.artistKey, t.year, t.thumb), + rs, known?.released ?: (known?.year ?: t.year)?.toString(), + ) + } + when (sort) { + 1 -> grouped.sortedWith(compareBy({ artistSortKey(it.album.artist) }, { it.released ?: "" }, { it.album.title.lowercase() })) + 2 -> grouped.sortedWith(compareByDescending { it.released ?: "" }.thenBy { it.album.title.lowercase() }) + else -> grouped.sortedByDescending { it.added } + } + } + val byKey = albums.associateBy { it.album.ratingKey } + val allDone = albums.flatMap { a -> a.tracks.filter { records[it.ratingKey]?.done == true } } + + Page("Downloads", trailing = { + if (albums.isNotEmpty()) { + TextButton("Sort", { + overlays.actions("Sort By", DOWNLOAD_SORTS.mapIndexed { i, label -> SheetAction(if (i == sort) "✓ $label" else label) { g.settings.downloadSort.value = i } }) + }) + IconButton(Sym.ellipsis, { + overlays.actions("Downloads", buildList { + if (albums.any { it.failed > 0 }) add(SheetAction("Retry Failed") { g.downloads.retryFailed() }) + add(SheetAction("Remove All Downloads", destructive = true) { + overlays.confirm("Remove All Downloads?", "Frees ${"%.1f".format(usage.pinnedBytes / 1e9)} GB. Songs stay in your library.", "Remove All") { + g.downloads.remove(records.values.map { it.track }) + } + }) + }) + }) + } + }) { + if (albums.isEmpty()) { + item("empty") { EmptyState(Sym.download, "Nothing Downloaded", "Hold any album, artist, playlist or song and choose Download to play it, stems and all, without your server.") } + return@Page + } + item("summary") { + Column(Modifier.padding(bottom = 14.dp)) { + Txt("${albums.size} album${if (albums.size == 1) "" else "s"} · ${songs(records.size)} · ${"%.1f".format(usage.pinnedBytes / 1e9)} GB · by ${DOWNLOAD_SORTS[sort].lowercase()}", + Type.subhead, Modifier.padding(start = MARGIN.dp, bottom = 12.dp), color = c.label2) + PlayShuffle(onPlay = { g.playback.playTracks(allDone, 0) }, onShuffle = { g.playback.playTracks(allDone, shuffle = true) }) + } + } + albumGrid( + "downloads", albums.map { it.album }, + onClick = { a -> + val d = byKey.getValue(a.ratingKey) + if (a.ratingKey.startsWith("name:")) g.playback.playTracks(d.tracks, 0) else nav.push(Route.AlbumPage(a)) + }, + onLongClick = { a -> + val d = byKey.getValue(a.ratingKey) + val extra = buildList { + if (d.failed > 0) add(SheetAction("Retry Failed Songs") { g.downloads.retryFailed() }) + if (!d.complete) add(SheetAction("Cancel Download", destructive = true) { g.downloads.remove(d.records.filter { !it.done }.map { it.track }) }) + } + if (a.ratingKey.startsWith("name:")) menu.tracks("${a.title} — ${a.artist}", d.tracks, extra) else menu.album(a, extra) + }, + subtitle = { a -> + val d = byKey.getValue(a.ratingKey) + when { + d.failed > 0 -> "${a.artist} · ${d.failed} failed" + !d.complete -> "${a.artist} · ${d.done} of ${d.records.size}" + sort == 2 && d.released != null -> "${a.artist} · ${d.released.take(4)}" + else -> a.artist + } + }, + badge = { a -> + val d = byKey.getValue(a.ratingKey) + if (!d.complete) { + val inFlight = d.records.sumOf { (progress[it.track.ratingKey] ?: 0f).toDouble() } + Box(Modifier.size(30.dp).clip(CircleShape).background(Color.Black.copy(alpha = 0.55f)), contentAlignment = Alignment.Center) { + if (d.failed > 0) Icon(Sym.warning, Color.White, size = 18.dp) + else ProgressRing(((d.done + inFlight) / d.records.size).toFloat(), size = 20.dp, color = Color.White) + } + } + }, + ) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/NowPlaying.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/NowPlaying.kt new file mode 100644 index 0000000..58e04e6 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/NowPlaying.kt @@ -0,0 +1,507 @@ +package com.stemroller.mobile.ui.screens + +import android.graphics.Bitmap +import androidx.compose.animation.AnimatedContent +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.animation.togetherWith +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.background +import androidx.compose.foundation.gestures.detectDragGestures +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.produceState +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.runtime.withFrameNanos +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.geometry.CornerRadius +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.graphics.luminance +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import androidx.compose.ui.zIndex +import androidx.palette.graphics.Palette +import coil3.SingletonImageLoader +import coil3.request.ImageRequest +import coil3.request.SuccessResult +import coil3.request.allowHardware +import coil3.toBitmap +import com.stemroller.mobile.App +import com.stemroller.mobile.engine.MeterHistory +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.core.StemQuality +import com.stemroller.mobile.playback.MixPresets +import com.stemroller.mobile.playback.QueueItem +import com.stemroller.mobile.playback.RepeatMode +import com.stemroller.mobile.playback.SourceKind +import com.stemroller.mobile.playback.StemSetting +import com.stemroller.mobile.playback.Stems +import com.stemroller.mobile.ui.components.Artwork +import com.stemroller.mobile.ui.components.Chip +import com.stemroller.mobile.ui.components.Hairline +import com.stemroller.mobile.ui.components.IconButton +import com.stemroller.mobile.ui.components.IosSlider +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.Spinner +import com.stemroller.mobile.ui.components.TextButton +import com.stemroller.mobile.ui.components.pressFade +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.LocalPalette +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlin.math.exp +import kotlin.math.max +import kotlin.math.min + +enum class NpPanel { Art, Mixer, Queue } + +/** + * A solid colour from the album art, pushed dark (or light for the White theme) so text + * stays readable. One flat colour: no gradients. + */ +@Composable +private fun albumColor(thumb: String?, enabled: Boolean, dark: Boolean): Color? { + val ctx = LocalContext.current + val c by produceState(null, thumb, enabled, dark) { + value = null + if (!enabled) return@produceState + val url = App.graph.plex.artUrl(thumb, 120) ?: return@produceState + val res = SingletonImageLoader.get(ctx).execute(ImageRequest.Builder(ctx).data(url).allowHardware(false).build()) + val bmp: Bitmap = (res as? SuccessResult)?.image?.toBitmap() ?: return@produceState + val rgb = withContext(Dispatchers.Default) { + val p = Palette.from(bmp).generate() + (p.darkVibrantSwatch ?: p.vibrantSwatch ?: p.dominantSwatch)?.rgb + } ?: return@produceState + val hsv = FloatArray(3) + android.graphics.Color.colorToHSV(rgb, hsv) + if (dark) { + hsv[1] = min(hsv[1], 0.65f) + hsv[2] = hsv[2].coerceIn(0.18f, 0.30f) + } else { + hsv[1] = min(hsv[1], 0.22f) + hsv[2] = 0.96f + } + value = Color(android.graphics.Color.HSVToColor(hsv)) + } + return c +} + +@Composable +fun NowPlayingScreen(onClose: () -> Unit, dragModifier: Modifier) { + val g = App.graph + val pm = g.playback + val base = Ios.colors + val overlays = LocalOverlays.current + val app = LocalApp.current + val menu = rememberMediaMenu() + val item by pm.current.collectAsState() + val playing by pm.playWhenReady.collectAsState() + val buffering by pm.buffering.collectAsState() + val duration by pm.durationMs.collectAsState() + val waveform by pm.waveform.collectAsState() + val names by pm.stemNames.collectAsState() + val mix by pm.mix.collectAsState() + val master by pm.master.collectAsState() + val source by pm.source.collectAsState() + val device by g.eq.device.collectAsState() + val profile by g.eq.active.collectAsState() + val eqState by g.eq.state.collectAsState() + val useAlbumColor by g.settings.albumColorNowPlaying.flow.collectAsState() + val quality by g.settings.stemQuality.flow.collectAsState() + var panel by remember { mutableStateOf(NpPanel.Art) } + val position = rememberPlaybackPosition() + val track = item?.track + + val tint = albumColor(track?.thumb, useAlbumColor, base.dark) + val dark = tint?.let { it.luminance() < 0.5f } ?: base.dark + val c = if (tint == null) base else base.copy( + bg = tint, fill = if (dark) Color.White.copy(alpha = 0.12f) else Color.Black.copy(alpha = 0.06f), + label = if (dark) Color.White else Color.Black, + label2 = if (dark) Color.White.copy(alpha = 0.62f) else Color.Black.copy(alpha = 0.55f), + label3 = if (dark) Color.White.copy(alpha = 0.25f) else Color.Black.copy(alpha = 0.2f), + fillStrong = if (dark) Color.White.copy(alpha = 0.22f) else Color.Black.copy(alpha = 0.12f), + separator = if (dark) Color.White.copy(alpha = 0.14f) else Color.Black.copy(alpha = 0.1f), + ) + val env = remember(waveform, names, mix) { envelope(waveform, names, mix) } + val bottom = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + + androidx.compose.runtime.CompositionLocalProvider(LocalPalette provides c) { + Column(Modifier.fillMaxSize().background(c.bg).padding(bottom = bottom + 8.dp)) { + // Grabber; dragging here (or on the art) pulls the sheet down. + Box(dragModifier.fillMaxWidth().height(28.dp), contentAlignment = Alignment.Center) { + Box(Modifier.size(38.dp, 5.dp).clip(CircleShape).background(c.label3).tappable(onClick = onClose)) + } + if (track == null) { + Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { Txt("Nothing Playing", Type.title3, color = c.label2) } + return@Column + } + AnimatedContent(panel, Modifier.weight(1f), transitionSpec = { fadeIn(tween(180)) togetherWith fadeOut(tween(120)) }, label = "panel") { p -> + when (p) { + NpPanel.Art -> ArtPanel(track.thumb, playing, dragModifier) + NpPanel.Mixer -> Column { + MiniHeader(track.thumb, track.title, track.artist) { menu.show(track) } + MixerPanel(names, mix, source, master) + } + NpPanel.Queue -> Column { + MiniHeader(track.thumb, track.title, track.artist) { menu.show(track) } + QueuePanel() + } + } + } + Column(Modifier.padding(horizontal = 28.dp)) { + if (panel == NpPanel.Art) { + Row(Modifier.fillMaxWidth().padding(top = 14.dp), verticalAlignment = Alignment.CenterVertically) { + Column(Modifier.weight(1f)) { + Txt(track.title, Type.title3) + Txt(track.artist, Type.title3, color = c.label2, weight = FontWeight.Normal, modifier = Modifier.tappable { + track.artistKey?.let { k -> app.showInLibrary(com.stemroller.mobile.ui.nav.Route.ArtistPage(com.stemroller.mobile.plex.Artist(k, track.artist, track.artist))) } + }) + } + Box(Modifier.size(32.dp).clip(CircleShape).background(c.fill).pressFade { menu.show(track) }, contentAlignment = Alignment.Center) { + Icon(Sym.ellipsis, c.label, size = 18.dp) + } + } + } + Spacer(Modifier.height(18.dp)) + val badge = when (source) { + SourceKind.Stems -> "${names.size} STEMS · ${if (g.stems.effectiveQuality(quality) == StemQuality.Lossless) "FLAC" else "OPUS ${quality.kbps}"}" + SourceKind.Original -> "ORIGINAL · ${track.codec?.uppercase() ?: ""}".trimEnd(' ', '·') + SourceKind.None -> null + } + ProgressVolumeBar( + position, duration, env, master, onSeek = pm::seekTo, onVolume = pm::setMaster, + played = c.label, unplayed = c.label3, centerLabel = badge, + ) + // Transport. + Row(Modifier.fillMaxWidth().height(84.dp), horizontalArrangement = Arrangement.SpaceEvenly, verticalAlignment = Alignment.CenterVertically) { + IconButton(Sym.backward, pm::previous, tint = c.label, size = 38.dp, box = 72.dp) + Box(Modifier.size(80.dp).pressFade(onClick = pm::togglePlay), contentAlignment = Alignment.Center) { + if (buffering && playing) Spinner(size = 34.dp, color = c.label) + else Icon(if (playing) Sym.pause else Sym.play, c.label, size = 52.dp) + } + IconButton(Sym.forward, pm::next, tint = c.label, size = 38.dp, box = 72.dp) + } + // Bottom row: stems, output route, queue. + Row(Modifier.fillMaxWidth().height(48.dp), verticalAlignment = Alignment.CenterVertically) { + PanelToggle(Sym.sliders, panel == NpPanel.Mixer) { panel = if (panel == NpPanel.Mixer) NpPanel.Art else NpPanel.Mixer } + Row( + Modifier.weight(1f).pressFade { onClose(); app.showInSettings(Route.Eq) }, + horizontalArrangement = Arrangement.Center, verticalAlignment = Alignment.CenterVertically, + ) { + Icon(deviceIcon(device).first, c.label2, size = 16.dp) + Spacer(Modifier.width(6.dp)) + val p = profile + val eqLabel = when { + !eqState.enabled || p == null -> "" + p.name.equals(device.label, ignoreCase = true) -> " · EQ" + else -> " · ${p.name}" + } + Txt(device.label + eqLabel, Type.footnote, color = c.label2, weight = FontWeight.Medium) + } + PanelToggle(Sym.queue, panel == NpPanel.Queue) { panel = if (panel == NpPanel.Queue) NpPanel.Art else NpPanel.Queue } + } + } + } + } +} + +@Composable +private fun PanelToggle(icon: ImageVector, on: Boolean, onClick: () -> Unit) { + val c = Ios.colors + Box( + Modifier.size(40.dp).clip(RoundedCornerShape(10.dp)).background(if (on) c.label else Color.Transparent).pressFade(onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Icon(icon, if (on) c.bg else c.label2, size = 22.dp) + } +} + +/** Big art that eases back when paused, like Apple Music. */ +@Composable +private fun ArtPanel(thumb: String?, playing: Boolean, dragModifier: Modifier) { + val scale by animateFloatAsState(if (playing) 1f else 0.82f, spring(dampingRatio = 0.62f, stiffness = 260f), label = "art") + BoxWithConstraints(dragModifier.fillMaxSize().padding(horizontal = 28.dp, vertical = 8.dp), contentAlignment = Alignment.Center) { + val side: Dp = min(maxWidth.value, maxHeight.value).dp + Box(Modifier.graphicsLayer { scaleX = scale; scaleY = scale }) { + Artwork(thumb, side, corner = 12.dp, placeholder = Sym.note) + } + } +} + +@Composable +private fun MiniHeader(thumb: String?, title: String, artist: String, onMore: () -> Unit) { + val c = Ios.colors + Row(Modifier.fillMaxWidth().padding(horizontal = 24.dp, vertical = 10.dp), verticalAlignment = Alignment.CenterVertically) { + Artwork(thumb, 64.dp, corner = 8.dp) + Spacer(Modifier.width(14.dp)) + Column(Modifier.weight(1f)) { + Txt(title, Type.headline) + Txt(artist, Type.subhead, color = c.label2) + } + Box(Modifier.size(32.dp).clip(CircleShape).background(c.fill).pressFade(onClick = onMore), contentAlignment = Alignment.Center) { + Icon(Sym.ellipsis, c.label, size = 18.dp) + } + } +} + +// ---- stem mixer ---------------------------------------------------------------------------------------- + +@Composable +private fun MixerPanel(names: List, mix: Map, source: SourceKind, master: Float) { + val pm = App.graph.playback + val c = Ios.colors + // Live meters, every display frame, showing the block that's audible now: quick attack, + // ~130 ms fall, timed in seconds so it looks the same at 60 and 165 Hz. + val levels = remember { mutableStateListOf() } + LaunchedEffect(names) { + val raw = FloatArray(MeterHistory.MAX_STEMS) + val shown = FloatArray(names.size) + var last = 0L + while (true) { + val now = withFrameNanos { it } + val fall = if (last == 0L) 0f else exp(-(now - last) / 1e9f / 0.13f) + last = now + val live = pm.engine.levelsNow(raw) + for (i in shown.indices) shown[i] = max(if (live) raw.getOrElse(i) { 0f } else 0f, shown[i] * fall) + if (levels.size != shown.size) { levels.clear(); levels.addAll(shown.toList()) } + else for (i in shown.indices) if (levels[i] != shown[i]) levels[i] = shown[i] + } + } + Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(horizontal = 24.dp)) { + if (source == SourceKind.Original) { + Box(Modifier.fillMaxWidth().padding(vertical = 8.dp).clip(RoundedCornerShape(12.dp)).background(c.fill).padding(14.dp)) { + Txt("No stems for this song yet, so you're hearing the original file. stemd on your server separates new music on its own; once this one's done, the app picks it up within a minute and plays it with stems next time.", + Type.footnote, color = c.label2, maxLines = 5) + } + } else { + Row(Modifier.horizontalScroll(rememberScrollState()).padding(vertical = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + val current = MixPresets.normalized(mix) + MixPresets.ALL.forEach { p -> + val target = p.build(names) ?: return@forEach + Chip(p.label, MixPresets.normalized(target) == current, onClick = { pm.applyMix(target) }) + } + } + } + names.forEachIndexed { i, name -> + val s = mix[name] ?: StemSetting() + StemFader(name, s, levels.getOrElse(i) { 0f }, enabled = source == SourceKind.Stems, + onLevel = { pm.setStemLevel(name, it) }, onMute = { pm.toggleMute(name) }, onSolo = { pm.toggleSolo(name) }) + } + Hairline(Modifier.padding(vertical = 10.dp), c.separator) + Row(verticalAlignment = Alignment.CenterVertically) { + Txt("Master", Type.headline, Modifier.weight(1f)) + Txt("${(master * 100).toInt()}%", Type.footnote.copy(fontFeatureSettings = "tnum"), color = c.label2) + } + Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Sym.speaker, c.label2, size = 16.dp) + IosSlider(master, pm::setMaster, Modifier.weight(1f).padding(horizontal = 8.dp), fill = c.label) + Icon(Sym.speakerWave, c.label2, size = 18.dp) + } + Spacer(Modifier.height(16.dp)) + } +} + +@Composable +private fun StemFader(name: String, s: StemSetting, level: Float, enabled: Boolean, onLevel: (Float) -> Unit, onMute: () -> Unit, onSolo: () -> Unit) { + val c = Ios.colors + val color = Color(Stems.color(name)) + Column(Modifier.fillMaxWidth().padding(top = 10.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Box(Modifier.size(10.dp).clip(CircleShape).background(if (s.muted) c.label3 else color)) + Spacer(Modifier.width(8.dp)) + Txt(Stems.label(name), Type.headline, Modifier.weight(1f), color = if (s.muted) c.label2 else c.label) + val pct = (com.stemroller.mobile.engine.stemTaper(s.level) * 100).toInt() + Txt("$pct%", Type.footnote.copy(fontFeatureSettings = "tnum"), color = c.label2, modifier = Modifier.padding(end = 10.dp)) + if (enabled) { + ToggleBox("M", s.muted, c.red, onMute) + Spacer(Modifier.width(6.dp)) + ToggleBox("S", s.solo, Color(0xFFFFCC00), onSolo) + } + } + IosSlider(s.level, onLevel, fill = if (s.muted) c.label3 else color, detent = StemSetting.UNITY, enabled = enabled, thumb = 24.dp) + // Live level under the fader. + Canvas(Modifier.fillMaxWidth().height(3.dp).padding(horizontal = 12.dp)) { + val w = size.width * min(1f, max(0f, (20f * kotlin.math.log10(level + 1e-5f) + 48f) / 48f)) + drawRoundRect(c.fill, Offset.Zero, size, CornerRadius(size.height / 2)) + drawRoundRect(color, Offset.Zero, Size(w, size.height), CornerRadius(size.height / 2)) + } + } +} + +@Composable +private fun ToggleBox(text: String, on: Boolean, onColor: Color, onClick: () -> Unit) { + val c = Ios.colors + Box( + Modifier.size(30.dp, 26.dp).clip(RoundedCornerShape(7.dp)).background(if (on) onColor else c.fill).pressFade(onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Txt(text, Type.footnote, color = if (on) Color.Black else c.label2, weight = FontWeight.Bold) + } +} + +// ---- queue --------------------------------------------------------------------------------------------- + +@Composable +private fun QueuePanel() { + val pm = App.graph.playback + val c = Ios.colors + val overlays = LocalOverlays.current + val queue by pm.queue.collectAsState() + val index by pm.index.collectAsState() + val shuffle by pm.shuffle.collectAsState() + val repeat by pm.repeat.collectAsState() + val upcoming = remember(queue, index) { queue.drop(index + 1) } + var dragUid by remember { mutableStateOf(null) } + var dragOffset by remember { mutableFloatStateOf(0f) } + val rowPx = with(LocalDensity.current) { 60.dp.toPx() } + Column(Modifier.fillMaxSize()) { + Row(Modifier.fillMaxWidth().padding(horizontal = 24.dp, vertical = 6.dp), verticalAlignment = Alignment.CenterVertically) { + Column(Modifier.weight(1f)) { + Txt("Playing Next", Type.headline) + Txt(songs(upcoming.size), Type.footnote, color = c.label2) + } + QueueToggle(Sym.shuffle, shuffle, pm::toggleShuffle) + Spacer(Modifier.width(8.dp)) + QueueToggle(if (repeat == RepeatMode.One) Sym.repeatOne else Sym.repeat, repeat != RepeatMode.Off, pm::cycleRepeat) + if (upcoming.isNotEmpty()) TextButton("Clear", { pm.clearUpNext() }, Modifier.padding(start = 6.dp), color = c.label2) + } + LazyColumn(Modifier.fillMaxSize()) { + items(upcoming.size, key = { upcoming[it].uid }) { i -> + val q: QueueItem = upcoming[i] + val dragging = dragUid == q.uid + Row( + Modifier.fillMaxWidth().height(60.dp).zIndex(if (dragging) 1f else 0f) + .graphicsLayer { translationY = if (dragging) dragOffset else 0f } + .background(if (dragging) c.fill else Color.Transparent) + .tappable(onLongClick = { + overlays.actions(q.track.title, listOf( + SheetAction("Play Next") { pm.move(index + 1 + i, index + 1) }, + SheetAction("Remove from Queue", destructive = true) { pm.removeAt(index + 1 + i) }, + )) + }) { pm.skipTo(index + 1 + i) } + .padding(start = 24.dp, end = 8.dp) + .animateItem(placementSpec = if (dragging) null else spring(stiffness = 900f)), + verticalAlignment = Alignment.CenterVertically, + ) { + Artwork(q.track.thumb, 44.dp, corner = 5.dp) + Spacer(Modifier.width(12.dp)) + Column(Modifier.weight(1f)) { + Txt(q.track.title, Type.body) + Txt(q.track.artist, Type.subhead, color = c.label2) + } + Box(Modifier.size(44.dp).pointerInput(q.uid) { + detectDragGestures( + onDragStart = { dragUid = q.uid; dragOffset = 0f }, + onDragEnd = { dragUid = null; dragOffset = 0f }, + onDragCancel = { dragUid = null; dragOffset = 0f }, + ) { ch, d -> + ch.consume() + dragOffset += d.y + val qi = pm.queue.value.indexOfFirst { it.uid == q.uid } + val first = pm.index.value + 1 + if (dragOffset > rowPx / 2 && qi < pm.queue.value.lastIndex) { + pm.move(qi, qi + 1); dragOffset -= rowPx + } else if (dragOffset < -rowPx / 2 && qi > first) { + pm.move(qi, qi - 1); dragOffset += rowPx + } + } + }, contentAlignment = Alignment.Center) { Icon(Sym.grip, c.label3, size = 22.dp) } + } + } + if (upcoming.isEmpty()) item("empty") { + Txt("Nothing queued. Use Play Next or Add to Queue on any song.", Type.subhead, Modifier.padding(24.dp), color = c.label2, maxLines = 3) + } + } + } +} + +@Composable +private fun QueueToggle(icon: ImageVector, on: Boolean, onClick: () -> Unit) { + val c = Ios.colors + Box( + Modifier.size(36.dp, 30.dp).clip(RoundedCornerShape(8.dp)).background(if (on) c.label else c.fill).pressFade(onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Icon(icon, if (on) c.bg else c.label2, size = 18.dp) + } +} + +// ---- mini player ---------------------------------------------------------------------------------------- + +@Composable +fun MiniPlayer(onOpen: () -> Unit, dragModifier: Modifier) { + val pm = App.graph.playback + val c = Ios.colors + val item by pm.current.collectAsState() + val playing by pm.playWhenReady.collectAsState() + val buffering by pm.buffering.collectAsState() + val duration by pm.durationMs.collectAsState() + val position = rememberPlaybackPosition() + val t = item?.track ?: return + Box(dragModifier.fillMaxWidth().height(64.dp).background(c.bar).tappable(onClick = onOpen)) { + Hairline(Modifier.align(Alignment.TopStart), c.barBorder) + Row(Modifier.fillMaxSize().padding(start = 16.dp, end = 8.dp), verticalAlignment = Alignment.CenterVertically) { + Artwork(t.thumb, 46.dp, corner = 6.dp) + Spacer(Modifier.width(12.dp)) + Column(Modifier.weight(1f)) { + Txt(t.title, Type.subhead, weight = FontWeight.Medium) + Txt(t.artist, Type.footnote, color = c.label2) + } + Box(Modifier.size(48.dp).pressFade(onClick = pm::togglePlay), contentAlignment = Alignment.Center) { + if (buffering && playing) Spinner(size = 22.dp, color = c.label) else Icon(if (playing) Sym.pause else Sym.play, c.label, size = 28.dp) + } + IconButton(Sym.forward, pm::next, tint = c.label, size = 28.dp, box = 48.dp) + } + // Hairline progress along the bottom edge. + Canvas(Modifier.align(Alignment.BottomStart).fillMaxWidth().height(2.dp)) { + val f = if (duration > 0) (position.value.toFloat() / duration).coerceIn(0f, 1f) else 0f + drawRect(c.accent, Offset.Zero, Size(size.width * f, size.height)) + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/PlaylistScreens.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/PlaylistScreens.kt new file mode 100644 index 0000000..d2623d8 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/PlaylistScreens.kt @@ -0,0 +1,337 @@ +package com.stemroller.mobile.ui.screens + +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.background +import androidx.compose.foundation.gestures.detectDragGestures +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.zIndex +import com.stemroller.mobile.App +import com.stemroller.mobile.plex.Playlist +import com.stemroller.mobile.plex.SearchResults +import com.stemroller.mobile.plex.Track +import com.stemroller.mobile.ui.components.Artwork +import com.stemroller.mobile.ui.components.Chevron +import com.stemroller.mobile.ui.components.EmptyState +import com.stemroller.mobile.ui.components.ErrorRow +import com.stemroller.mobile.ui.components.Hairline +import com.stemroller.mobile.ui.components.IconButton +import com.stemroller.mobile.ui.components.LoadingRow +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.MARGIN +import com.stemroller.mobile.ui.components.Page +import com.stemroller.mobile.ui.components.SearchField +import com.stemroller.mobile.ui.components.SectionTitle +import com.stemroller.mobile.ui.components.SheetAction +import com.stemroller.mobile.ui.components.Spinner +import com.stemroller.mobile.ui.components.Tag +import com.stemroller.mobile.ui.components.TextButton +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.nav.Load +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.nav.rememberInEntry +import com.stemroller.mobile.ui.nav.rememberLoader +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +@Composable +fun PlaylistsScreen() { + val g = App.graph + val nav = LocalNav.current + val c = Ios.colors + val menu = rememberMediaMenu() + val overlays = LocalOverlays.current + val lists = rememberLoader("playlists") { g.plex.playlists() } + val queue by g.playback.queue.collectAsState() + LaunchedEffect(Unit) { lists.refresh() } + Page("Playlists", trailing = { + IconButton(Sym.plus, { + // Plex can't hold an empty playlist, so new ones start from songs you have. + val now = g.playback.current.value?.track + val acts = buildList { + if (queue.isNotEmpty()) add(SheetAction("New Playlist from Queue (${queue.size})") { menu.newPlaylist(queue.map { it.track }) { lists.refresh() } }) + if (now != null) add(SheetAction("New Playlist with “${now.title}”") { menu.newPlaylist(listOf(now)) { lists.refresh() } }) + } + if (acts.isEmpty()) overlays.hud("Play something first, or use “Add to Playlist” on any song.", Sym.info) + else overlays.actions("New Playlist", acts) + }) + }) { + when (val s = lists.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { lists.refresh(true) } } + is Load.Ok -> { + if (s.value.isEmpty()) item("empty") { + EmptyState(Sym.noteList, "No Playlists", "Hold any song, album, artist or playlist and choose “Add to Playlist”, or + to make one from your queue. They sync with Plexamp.") + } + items(s.value.size, key = { s.value[it].ratingKey }) { i -> + PlaylistRow(s.value[i], onLongClick = { menu.playlist(s.value[i]) }) { nav.push(Route.PlaylistPage(s.value[i])) } + } + } + } + } +} + +@Composable +private fun PlaylistRow(p: Playlist, onLongClick: (() -> Unit)? = null, onClick: () -> Unit) { + val c = Ios.colors + val src = remember { MutableInteractionSource() } + val pressed by src.collectIsPressedAsState() + Box(Modifier.fillMaxWidth().background(if (pressed) c.cellPressed else Color.Transparent)) { + Row( + Modifier.fillMaxWidth().height(76.dp).tappable(onLongClick = onLongClick, interaction = src, onClick = onClick).padding(start = MARGIN.dp, end = 16.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Artwork(p.thumb, 60.dp, corner = 6.dp, placeholder = Sym.noteList) + Spacer(Modifier.width(14.dp)) + Column(Modifier.weight(1f)) { + Txt(p.title, Type.body) + Txt(songs(p.trackCount), Type.subhead, color = c.label2) + } + if (p.smart) { + Tag("SMART") + Spacer(Modifier.width(8.dp)) + } + Chevron() + } + Hairline(Modifier.align(Alignment.BottomStart).padding(start = 94.dp)) + } +} + +private class EditState { + var editing by mutableStateOf(false) + val items = mutableStateListOf() + val removed = mutableStateListOf() + var dragKey by mutableStateOf(null) + var dragOffset by mutableFloatStateOf(0f) + var saving by mutableStateOf(false) +} + +@OptIn(ExperimentalFoundationApi::class) +@Composable +fun PlaylistScreen(playlist: Playlist) { + val g = App.graph + val nav = LocalNav.current + val c = Ios.colors + val menu = rememberMediaMenu() + val overlays = LocalOverlays.current + val scope = rememberCoroutineScope() + val tracks = rememberLoader("tracks") { g.plex.playlistTracks(playlist.ratingKey) } + var title by rememberInEntry("title") { mutableStateOf(playlist.title) } + val edit = rememberInEntry("edit") { EditState() } + val list = tracks.value.orEmpty() + val rowPx = with(LocalDensity.current) { 64.dp.toPx() } + + fun commit() { + val original = list + val target = edit.items.toList() + val removed = edit.removed.toList() + edit.saving = true + g.scope.launch { + runCatching { + removed.forEach { t -> t.playlistItemId?.let { g.plex.removeFromPlaylist(playlist.ratingKey, it) } } + // Replay the new order as "move after" calls against a simulated server list. + val sim = original.filter { o -> removed.none { it.playlistItemId == o.playlistItemId } }.toMutableList() + target.forEachIndexed { i, t -> + if (sim.getOrNull(i)?.playlistItemId != t.playlistItemId) { + val id = t.playlistItemId ?: return@forEachIndexed + g.plex.movePlaylistItem(playlist.ratingKey, id, if (i == 0) null else target[i - 1].playlistItemId) + sim.removeAll { it.playlistItemId == id } + sim.add(i, t) + } + } + }.onFailure { overlays.hud("Couldn't save: ${it.message}", com.stemroller.mobile.ui.theme.Sym.warning) } + tracks.refresh() + edit.saving = false + edit.editing = false + } + } + + Page(title, largeTitle = false, trailing = { + if (!playlist.smart && list.isNotEmpty()) { + if (edit.saving) Box(Modifier.size(44.dp), contentAlignment = Alignment.Center) { Spinner() } + else if (edit.editing) TextButton("Done", { commit() }, bold = true) + else TextButton("Edit", { + edit.items.clear(); edit.items.addAll(list); edit.removed.clear(); edit.editing = true + }) + } + if (!edit.editing) IconButton(Sym.ellipsis, { + menu.playlist(playlist.copy(title = title, trackCount = list.size), extra = buildList { + if (!playlist.smart) add(SheetAction("Rename…") { + overlays.prompt("Rename Playlist", null, title, "Save") { name -> + g.scope.launch { runCatching { g.plex.renamePlaylist(playlist.ratingKey, name) }.onSuccess { title = name } } + } + }) + add(SheetAction("Delete Playlist", destructive = true) { + overlays.confirm("Delete “$title”?", "This removes it from Plex for every app.", "Delete") { + g.scope.launch { runCatching { g.plex.deletePlaylist(playlist.ratingKey) }.onSuccess { nav.pop() } } + } + }) + }) + }) + }) { + item("header") { + Column(Modifier.fillMaxWidth().padding(top = 8.dp, bottom = 16.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Artwork(playlist.thumb, 230.dp, corner = 10.dp, placeholder = Sym.noteList) + Spacer(Modifier.height(14.dp)) + Txt(title, Type.title2, Modifier.padding(horizontal = 32.dp), align = TextAlign.Center, maxLines = 2) + if (list.isNotEmpty()) Txt("${songs(list.size)} · ${formatMinutes(list.sumOf { it.durationMs })}", Type.subhead, color = c.label2) + Spacer(Modifier.height(14.dp)) + if (!edit.editing) PlayShuffle(onPlay = { g.playback.playTracks(list, 0) }, onShuffle = { g.playback.playTracks(list, shuffle = true) }) + } + } + when (val s = tracks.state.value) { + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(s.message) { tracks.refresh(true) } } + is Load.Ok -> if (edit.editing) { + items(edit.items.size, key = { edit.items[it].playlistItemId ?: it.toLong() }) { i -> + val t = edit.items[i] + val id = t.playlistItemId + val dragging = edit.dragKey == id + TrackRow( + t, onClick = {}, + modifier = Modifier.zIndex(if (dragging) 1f else 0f) + .graphicsLayer { translationY = if (dragging) edit.dragOffset else 0f } + .background(if (dragging) c.cellPressed else Color.Transparent) + .animateItem(placementSpec = if (dragging) null else androidx.compose.animation.core.spring(stiffness = 900f)), + leading = { + Box(Modifier.size(24.dp).clip(CircleShape).background(c.red).tappable { + edit.removed += t + edit.items.remove(t) + }, contentAlignment = Alignment.Center) { + Box(Modifier.size(11.dp, 2.dp).background(Color.White)) + } + }, + trailing = { + Box(Modifier.size(44.dp).pointerInput(id) { + detectDragGestures( + onDragStart = { edit.dragKey = id; edit.dragOffset = 0f }, + onDragEnd = { edit.dragKey = null; edit.dragOffset = 0f }, + onDragCancel = { edit.dragKey = null; edit.dragOffset = 0f }, + ) { ch, d -> + ch.consume() + edit.dragOffset += d.y + val from = edit.items.indexOfFirst { it.playlistItemId == id } + if (edit.dragOffset > rowPx / 2 && from < edit.items.lastIndex) { + edit.items.add(from + 1, edit.items.removeAt(from)) + edit.dragOffset -= rowPx + } else if (edit.dragOffset < -rowPx / 2 && from > 0) { + edit.items.add(from - 1, edit.items.removeAt(from)) + edit.dragOffset += rowPx + } + } + }, contentAlignment = Alignment.Center) { Icon(Sym.grip, c.label3, size = 22.dp) } + }, + ) + } + } else { + items(s.value.size, key = { s.value[it].playlistItemId ?: it.toLong() }) { i -> + val t = s.value[i] + TrackRow(t, onClick = { g.playback.playTracks(s.value, i) }, onMore = { + menu.show(t, extra = if (playlist.smart) emptyList() else listOf(SheetAction("Remove from Playlist", destructive = true) { + g.scope.launch { + runCatching { t.playlistItemId?.let { g.plex.removeFromPlaylist(playlist.ratingKey, it) } } + tracks.refresh() + } + })) + }) + } + } + } + } +} + +// ---- search ------------------------------------------------------------------------------------- + +@Composable +fun SearchScreen() { + val g = App.graph + val nav = LocalNav.current + val c = Ios.colors + val menu = rememberMediaMenu() + var query by rememberInEntry("q") { mutableStateOf("") } + var results by rememberInEntry("r") { mutableStateOf?>(null) } + LaunchedEffect(query) { + val q = query.trim() + if (q.length < 2) { + results = null + return@LaunchedEffect + } + delay(280) + results = Load.Loading + results = try { + Load.Ok(g.plex.search(q)) + } catch (e: Exception) { + Load.Err(e.message ?: "Search failed") + } + } + Page("Search") { + item("field") { SearchField(query, { query = it }, Modifier.padding(horizontal = 16.dp, vertical = 8.dp), "Artists, Albums, Songs") } + when (val r = results) { + null -> item("hint") { EmptyState(Sym.search, "Search Your Library", "Find artists, albums, songs and playlists on your Plex server.") } + Load.Loading -> item("loading") { LoadingRow() } + is Load.Err -> item("err") { ErrorRow(r.message) { query = query.trim() + " " } } + is Load.Ok -> { + val s = r.value + if (s.isEmpty) item("none") { EmptyState(Sym.search, "No Results", "Nothing matches “${query.trim()}”.") } + if (s.artists.isNotEmpty()) { + item("ah") { SectionTitle("Artists") } + items(s.artists.size, key = { "a" + s.artists[it].ratingKey }) { + ArtistRow(s.artists[it], onLongClick = { menu.artist(s.artists[it]) }) { nav.push(Route.ArtistPage(s.artists[it])) } + } + } + if (s.albums.isNotEmpty()) { + item("alh") { SectionTitle("Albums") } + albumGrid("al", s.albums, onClick = { nav.push(Route.AlbumPage(it)) }, onLongClick = { menu.album(it) }) + } + if (s.tracks.isNotEmpty()) { + item("th") { SectionTitle("Songs") } + items(s.tracks.size, key = { "t" + s.tracks[it].ratingKey }) { i -> + val t = s.tracks[i] + TrackRow(t, onClick = { g.playback.playTracks(s.tracks, i) }, subtitle = "${t.artist} — ${t.album}", onMore = { menu.show(t) }) + } + } + if (s.playlists.isNotEmpty()) { + item("ph") { SectionTitle("Playlists") } + items(s.playlists.size, key = { "p" + s.playlists[it].ratingKey }) { + PlaylistRow(s.playlists[it], onLongClick = { menu.playlist(s.playlists[it]) }) { nav.push(Route.PlaylistPage(s.playlists[it])) } + } + } + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/ProgressVolumeBar.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/ProgressVolumeBar.kt new file mode 100644 index 0000000..2e03bd0 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/ProgressVolumeBar.kt @@ -0,0 +1,243 @@ +package com.stemroller.mobile.ui.screens + +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.gestures.awaitEachGesture +import androidx.compose.foundation.gestures.awaitFirstDown +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.width +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.State +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.derivedStateOf +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState +import androidx.compose.runtime.setValue +import androidx.compose.runtime.withFrameNanos +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.CornerRadius +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.hapticfeedback.HapticFeedbackType +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.input.pointer.positionChange +import androidx.compose.ui.platform.LocalHapticFeedback +import androidx.compose.ui.platform.LocalViewConfiguration +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import com.stemroller.mobile.App +import com.stemroller.mobile.engine.masterTaper +import com.stemroller.mobile.engine.stemTaper +import com.stemroller.mobile.playback.StemSetting +import com.stemroller.mobile.playback.Waveform +import com.stemroller.mobile.ui.theme.Icon +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import kotlinx.coroutines.delay +import kotlin.math.abs +import kotlin.math.log10 +import kotlin.math.max +import kotlin.math.pow +import kotlin.math.sqrt + +/** + * Playback position, refreshed every display frame while playing (165 Hz on the OnePlus 15). + * Read it inside draw lambdas so only drawing, not composition, follows it. + */ +@Composable +fun rememberPlaybackPosition(): State { + val pm = App.graph.playback + val pos = remember { mutableLongStateOf(pm.positionMs()) } + val playing by pm.playWhenReady.collectAsState() + val current by pm.current.collectAsState() + LaunchedEffect(playing, current) { + while (true) { + if (playing) withFrameNanos { } else delay(200) + pos.longValue = pm.positionMs() + } + } + return pos +} + +/** 0..1 loudness per waveform bucket for the current mix: stems weighted by their faders. */ +fun envelope(w: Waveform?, names: List, mix: Map): FloatArray? { + if (w == null) return null + w.stems?.let { stems -> + val anySolo = names.any { mix[it]?.solo == true } + val gains = stems.keys.associateWith { n -> + val s = mix[n] ?: StemSetting() + if (anySolo && !s.solo || s.muted) 0f else stemTaper(s.level) + } + // Scaled to the full mix's range, so muting a stem still shows as quieter bars. + return shape(mixDb(stems, gains), mixDb(stems, null)) + } + w.loudnessDb?.let { db -> return shape(db, db) } + return null +} + +private fun mixDb(stems: Map, gains: Map?): FloatArray { + val n = stems.values.maxOf { it.size } + return FloatArray(n) { i -> + var e = 0f + for ((name, arr) in stems) { + val v = arr.getOrElse(i) { 0f } * (gains?.get(name) ?: 1f) + e += v * v + } + 20f * log10(sqrt(e) + 1e-6f) + } +} + +/** + * Loudness to bar height, relative to the song itself: its loudest moments (99th percentile) + * fill the bar and its quiet tenth sits near the bottom, over 6 to 24 dB, with a curve that + * pulls the middle down. Modern masters barely move in absolute terms (a few dB from verse to + * chorus), so an absolute scale draws nearly every song as a solid block. + */ +private fun shape(db: FloatArray, ref: FloatArray): FloatArray { + val audible = ref.filter { it > -60f }.ifEmpty { ref.toList() }.sorted() + if (audible.isEmpty()) return FloatArray(db.size) { 0.28f } + fun pct(p: Float) = audible[(p * audible.size).toInt().coerceAtMost(audible.lastIndex)] + val hi = pct(0.99f) + val span = (hi - pct(0.10f)).coerceIn(6f, 24f) + val lo = hi - span + return FloatArray(db.size) { 0.05f + 0.95f * ((db[it] - lo) / span).coerceIn(0f, 1f).pow(1.8f) } +} + +/** + * Plexamp's seek bar: the track's loudness as bars, played part in accent. The bars' + * height follows the master volume, so the volume is drawn over the progress. + * Drag sideways to seek, up/down to change volume, tap to jump. + */ +@Composable +fun ProgressVolumeBar( + position: State, + durationMs: Long, + envelope: FloatArray?, + master: Float, + onSeek: (Long) -> Unit, + onVolume: (Float) -> Unit, + played: Color, + unplayed: Color, + centerLabel: String?, + modifier: Modifier = Modifier, +) { + val c = Ios.colors + val haptic = LocalHapticFeedback.current + val slop = LocalViewConfiguration.current.touchSlop + var scrubFraction by remember { mutableFloatStateOf(-1f) } + var adjusting by remember { mutableStateOf(false) } + val vol by rememberUpdatedState(master) + val dur by rememberUpdatedState(durationMs) + val seek by rememberUpdatedState(onSeek) + val volume by rememberUpdatedState(onVolume) + val volScale by animateFloatAsState(0.14f + 0.86f * masterTaper(master).let { sqrt(sqrt(it)) }, tween(90), label = "vol") + val guides by animateFloatAsState(if (adjusting) 1f else 0f, tween(150), label = "guides") + val shown by remember { derivedStateOf { if (scrubFraction >= 0f) (scrubFraction * dur).toLong() else position.value } } + val shownSecond by remember { derivedStateOf { shown / 1000 } } + + Column(modifier.fillMaxWidth()) { + Canvas( + Modifier.fillMaxWidth().height(56.dp).pointerInput(Unit) { + awaitEachGesture { + val down = awaitFirstDown() + var axis = 0 // 1 = seek, 2 = volume + var total = Offset.Zero + val startVol = vol + var lastStep = (startVol * 20).toInt() + while (true) { + val ev = awaitPointerEvent() + val ch = ev.changes.firstOrNull { it.id == down.id } ?: break + if (!ch.pressed) { + when (axis) { + 0 -> seek((ch.position.x / size.width).coerceIn(0f, 1f).times(dur).toLong()) + 1 -> seek((scrubFraction * dur).toLong()) + } + break + } + total += ch.positionChange() + if (axis == 0 && (abs(total.x) > slop || abs(total.y) > slop)) { + axis = if (abs(total.x) >= abs(total.y)) 1 else 2 + if (axis == 2) adjusting = true + haptic.performHapticFeedback(HapticFeedbackType.GestureThresholdActivate) + } + when (axis) { + 1 -> scrubFraction = (ch.position.x / size.width).coerceIn(0f, 1f) + 2 -> { + val v = (startVol - total.y / (size.height * 4.5f)).coerceIn(0f, 1f) + val step = (v * 20).toInt() + if (step != lastStep) { + lastStep = step + if (v == 0f || v == 1f) haptic.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick) + } + volume(v) + } + } + if (axis != 0) ch.consume() + } + scrubFraction = -1f + adjusting = false + } + }, + ) { + val env = envelope + val barW = 2.7.dp.toPx() + val pitch = 4.6.dp.toPx() + val count = max(8, (size.width / pitch).toInt()) + val gap = (size.width - count * barW) / (count - 1) + val maxH = size.height + val minH = barW + val frac = if (dur > 0) (if (scrubFraction >= 0f) scrubFraction else position.value.toFloat() / dur).coerceIn(0f, 1f) else 0f + val cy = size.height / 2 + if (guides > 0f) { + val g = (maxH * volScale) / 2 + val col = c.label2.copy(alpha = 0.5f * guides) + drawLine(col, Offset(0f, cy - g), Offset(size.width, cy - g), 1.dp.toPx()) + drawLine(col, Offset(0f, cy + g), Offset(size.width, cy + g), 1.dp.toPx()) + } + for (i in 0 until count) { + val a = if (env == null || env.isEmpty()) 0.28f else { + val from = i * env.size / count + val to = max(from + 1, (i + 1) * env.size / count) + var m = 0f + for (k in from until to.coerceAtMost(env.size)) m = max(m, env[k]) + m + } + val h = minH + (maxH - minH) * a * volScale + val x = i * (barW + gap) + val isPlayed = (x + barW / 2) / size.width <= frac + drawRoundRect(if (isPlayed) played else unplayed, Offset(x, cy - h / 2), Size(barW, h), CornerRadius(barW / 2)) + } + } + Spacer(Modifier.height(4.dp)) + Box(Modifier.fillMaxWidth().height(18.dp)) { + val tnum = Type.caption1.copy(fontFeatureSettings = "tnum") + Txt(formatDuration(shownSecond * 1000), tnum, Modifier.align(Alignment.CenterStart), color = c.label2, weight = FontWeight.Medium) + Txt("-" + formatDuration(max(0, dur - shownSecond * 1000)), tnum, Modifier.align(Alignment.CenterEnd), color = c.label2, weight = FontWeight.Medium) + Row(Modifier.align(Alignment.Center).graphicsLayer { alpha = if (adjusting) 1f else 0.95f }, verticalAlignment = Alignment.CenterVertically) { + if (adjusting) { + Icon(if (master <= 0.001f) Sym.speakerSlash else Sym.speakerWave, c.label2, size = 14.dp) + Spacer(Modifier.width(4.dp)) + Txt("${(master * 100).toInt()}%", tnum, color = c.label2, weight = FontWeight.SemiBold) + } else if (centerLabel != null) { + Txt(centerLabel, Type.caption2, color = c.label2, weight = FontWeight.Bold) + } + } + } + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/screens/SettingsScreens.kt b/android/app/src/main/java/com/stemroller/mobile/ui/screens/SettingsScreens.kt new file mode 100644 index 0000000..692abf6 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/screens/SettingsScreens.kt @@ -0,0 +1,407 @@ +package com.stemroller.mobile.ui.screens + +import android.content.Intent +import android.net.Uri +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicTextField +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.SolidColor +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalView +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.text.input.PasswordVisualTransformation +import androidx.compose.ui.text.input.VisualTransformation +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.stemroller.mobile.App +import com.stemroller.mobile.core.Accent +import com.stemroller.mobile.core.StemQuality +import com.stemroller.mobile.core.ThemeMode +import com.stemroller.mobile.plex.MusicSection +import com.stemroller.mobile.stems.StemServerStatus +import com.stemroller.mobile.ui.components.Cell +import com.stemroller.mobile.ui.components.IosSwitch +import com.stemroller.mobile.ui.components.LocalOverlays +import com.stemroller.mobile.ui.components.Page +import com.stemroller.mobile.ui.components.SegmentedControl +import com.stemroller.mobile.ui.components.SettingsIcon +import com.stemroller.mobile.ui.components.Spinner +import com.stemroller.mobile.ui.components.section +import com.stemroller.mobile.ui.components.tappable +import com.stemroller.mobile.ui.nav.LocalNav +import com.stemroller.mobile.ui.nav.Route +import com.stemroller.mobile.ui.nav.rememberInEntry +import com.stemroller.mobile.ui.theme.Ios +import com.stemroller.mobile.ui.theme.Sym +import com.stemroller.mobile.ui.theme.Txt +import com.stemroller.mobile.ui.theme.Type +import com.stemroller.mobile.ui.theme.palette +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +private fun gb(bytes: Long) = if (bytes < 1e9) "%.0f MB".format(bytes / 1e6) else "%.1f GB".format(bytes / 1e9) + +@Composable +fun SettingsScreen() { + val g = App.graph + val s = g.settings + val nav = LocalNav.current + val user by s.plexUser.flow.collectAsState() + val token by s.plexToken.flow.collectAsState() + val sectionTitle by s.musicSectionTitle.flow.collectAsState() + val status by g.stems.status.collectAsState() + val quality by s.stemQuality.flow.collectAsState() + val keepMix by s.keepStemMix.flow.collectAsState() + val wifi by s.downloadsWifiOnly.flow.collectAsState() + val theme by s.theme.flow.collectAsState() + val hz by s.highRefreshRate.flow.collectAsState() + val usage by g.cache.usage.collectAsState() + val eqState by g.eq.state.collectAsState() + val eqProfile by g.eq.active.collectAsState() + val view = LocalView.current + val mode = view.display?.mode + + // Everything on one screen: no footers but the last, one line each. + Page("Settings", grouped = true) { + section("servers", header = "Servers", separatorInset = 60.dp, rows = listOf( + { Cell("Plex", icon = { SettingsIcon(Sym.server, Color(0xFFE5A00D)) }, value = if (token.isEmpty()) "Not Signed In" else sectionTitle.ifEmpty { user }, chevron = true) { nav.push(Route.PlexAccount) } }, + { Cell("Stem Server", icon = { SettingsIcon(Sym.waveform, Color(0xFFAF52DE)) }, chevron = true, value = when (val st = status) { + is StemServerStatus.Online -> "${st.tracks} songs" + is StemServerStatus.Offline -> "Offline" + StemServerStatus.Unknown -> "…" + }) { nav.push(Route.StemServer) } }, + )) + section("sound", header = "Sound", separatorInset = 60.dp, rows = listOf( + { Cell("Equalizer", icon = { SettingsIcon(Sym.sliders, Color(0xFF34C759)) }, value = if (!eqState.enabled) "Off" else eqProfile?.name ?: "On", chevron = true) { nav.push(Route.Eq) } }, + { Cell("Stem Quality", icon = { SettingsIcon(Sym.gauge, Color(0xFFFF2D55)) }, value = quality.label, chevron = true) { nav.push(Route.Quality) } }, + { Cell("Keep Stem Mix Between Songs", icon = { SettingsIcon(Sym.speakerWave, Color(0xFF5856D6)) }, trailing = { IosSwitch(keepMix, { s.keepStemMix.value = it }) }) }, + )) + section("storage", header = "Storage", separatorInset = 60.dp, rows = listOf( + { Cell("Cache & Downloads", icon = { SettingsIcon(Sym.externalDrive, Color(0xFF8E8E93)) }, value = gb(usage.cachedBytes), chevron = true) { nav.push(Route.Storage) } }, + { Cell("Download on Wi-Fi Only", icon = { SettingsIcon(Sym.download, Color(0xFF30B0C7)) }, trailing = { IosSwitch(wifi, { s.downloadsWifiOnly.value = it }) }) }, + )) + section("display", header = "Display", separatorInset = 60.dp, + footer = "StemRoller 1.1 · stems by stemd on your server" + (mode?.let { " · ${"%.0f".format(it.refreshRate)} Hz" } ?: ""), + rows = listOf( + { Cell("Appearance", icon = { SettingsIcon(Sym.paintbrush, Color(0xFF007AFF)) }, value = theme.label, chevron = true) { nav.push(Route.Appearance) } }, + { Cell("High Refresh Rate", icon = { SettingsIcon(Sym.phone, Color(0xFFFF9500)) }, trailing = { IosSwitch(hz, { s.highRefreshRate.value = it }) }) }, + )) + } +} + +/** A Settings-style row with an inline text field on the right. */ +@Composable +private fun FieldCell(label: String, value: String, onChange: (String) -> Unit, placeholder: String, secret: Boolean = false, keyboard: KeyboardType = KeyboardType.Uri) { + val c = Ios.colors + Row(Modifier.fillMaxWidth().height(46.dp).padding(horizontal = 16.dp), verticalAlignment = Alignment.CenterVertically) { + Txt(label, Type.body, Modifier.width(96.dp)) + Box(Modifier.weight(1f), contentAlignment = Alignment.CenterEnd) { + if (value.isEmpty()) Txt(placeholder, Type.body, color = c.label3, align = TextAlign.End) + BasicTextField( + value, onChange, singleLine = true, + textStyle = Type.body.copy(color = c.label2, textAlign = TextAlign.End), + cursorBrush = SolidColor(c.accent), + visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None, + keyboardOptions = KeyboardOptions(keyboardType = keyboard, autoCorrectEnabled = false), + modifier = Modifier.fillMaxWidth(), + ) + } + } +} + +private class PinState { + var code by mutableStateOf(null) + var id by mutableStateOf(0L) + var error by mutableStateOf(null) +} + +@Composable +fun PlexAccountScreen() { + val g = App.graph + val s = g.settings + val c = Ios.colors + val ctx = LocalContext.current + val overlays = LocalOverlays.current + val scope = rememberCoroutineScope() + val token by s.plexToken.flow.collectAsState() + val user by s.plexUser.flow.collectAsState() + val section by s.musicSection.flow.collectAsState() + var url by rememberInEntry("url") { mutableStateOf(s.plexUrl.value) } + var manual by rememberInEntry("manual") { mutableStateOf("") } + val pin = rememberInEntry("pin") { PinState() } + var sections by rememberInEntry("sections") { mutableStateOf?>(null) } + var testing by remember { mutableStateOf(false) } + + suspend fun finish(newToken: String) { + s.plexUrl.value = url.trim().trimEnd('/') + s.plexToken.value = newToken + s.plexUser.value = runCatching { g.plex.user(newToken).let { it.title ?: it.username ?: "Plex user" } }.getOrDefault("Plex user") + s.plexMachineId.value = runCatching { g.plex.machineId() }.getOrDefault("") + sections = runCatching { g.plex.musicSections() }.getOrNull() + sections?.singleOrNull()?.let { s.musicSection.value = it.key; s.musicSectionTitle.value = it.title } + g.stems.refresh() + } + + LaunchedEffect(token) { + if (token.isNotEmpty() && sections == null) sections = runCatching { g.plex.musicSections() }.getOrNull() + } + // Poll plex.tv while a PIN is showing. + LaunchedEffect(pin.id) { + if (pin.id == 0L) return@LaunchedEffect + repeat(300) { + delay(2000) + val p = runCatching { g.plex.checkPin(pin.id) }.getOrNull() + val t = p?.authToken + if (!t.isNullOrEmpty()) { + pin.code = null + pin.id = 0 + finish(t) + overlays.hud("Signed In") + return@LaunchedEffect + } + } + pin.code = null + pin.id = 0 + pin.error = "The code expired. Try again." + } + + Page("Plex", grouped = true) { + section("server", header = "Server", footer = "Your server's LAN address (port 32400).", rows = listOf( + { FieldCell("Address", url, { url = it }, "http://192.168.86.2:32400") }, + { + Cell(if (testing) "Testing…" else "Test Connection", titleColor = c.accent) { + testing = true + scope.launch { + val ok = runCatching { g.plex.probe(url, token) }.getOrDefault(false) + testing = false + if (ok) { + s.plexUrl.value = url.trim().trimEnd('/') + overlays.hud("Connected") + } else overlays.hud(if (token.isEmpty()) "Sign in first" else "Couldn't reach Plex at that address", Sym.warning) + } + } + }, + )) + if (token.isEmpty()) { + section("signin", header = "Sign In", footer = pin.error ?: if (pin.code == null) "Enter the code at plex.tv/link while signed in to Plex." else null, rows = listOfNotNull( + { + Cell(if (pin.code == null) "Sign In with plex.tv" else "Get a New Code", titleColor = c.accent) { + pin.error = null + scope.launch { + runCatching { g.plex.createPin() } + .onSuccess { pin.code = it.code; pin.id = it.id } + .onFailure { pin.error = "Couldn't reach plex.tv: ${it.message}" } + } + } + }, + if (pin.code != null) ({ + Column(Modifier.fillMaxWidth().padding(vertical = 18.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Txt(pin.code!!, Type.largeTitle.copy(fontSize = 44.sp, letterSpacing = 8.sp), weight = FontWeight.Bold) + Spacer(Modifier.height(10.dp)) + Row(verticalAlignment = Alignment.CenterVertically) { + Spinner(size = 16.dp) + Spacer(Modifier.width(8.dp)) + Txt("Waiting for plex.tv/link…", Type.footnote, color = c.label2) + } + Spacer(Modifier.height(14.dp)) + Box(Modifier.clip(CircleShape).background(c.accent).tappable { + ctx.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("https://plex.tv/link"))) + }.padding(horizontal = 18.dp, vertical = 9.dp)) { Txt("Open plex.tv/link", Type.headline, color = Color.White) } + } + }) else null, + )) + section("token", header = "Or Paste an X-Plex-Token", rows = listOf( + { FieldCell("Token", manual, { manual = it }, "Required", secret = true, keyboard = KeyboardType.Password) }, + { + Cell("Use Token", titleColor = if (manual.isBlank()) c.label3 else c.accent) { + if (manual.isNotBlank()) scope.launch { + if (g.plex.probe(url, manual.trim())) finish(manual.trim()) else overlays.hud("That token didn't work on this server", Sym.warning) + } + } + }, + )) + } else { + section("account", header = "Account", rows = listOf { Cell(user.ifEmpty { "Signed In" }, icon = { SettingsIcon(Sym.person, Color(0xFFE5A00D)) }) }) + val list = sections + section("library", header = "Music Library", rows = when { + list == null -> listOf { Box(Modifier.fillMaxWidth().padding(16.dp), contentAlignment = Alignment.Center) { Spinner() } } + list.isEmpty() -> listOf { Cell("No music libraries found") } + else -> list.map { sec -> + { Cell(sec.title, subtitle = sec.locations.joinToString(), checked = sec.key == section) { + s.musicSection.value = sec.key + s.musicSectionTitle.value = sec.title + } } + } + }) + section("signout", rows = listOf { + Cell("Sign Out", titleColor = c.red, centered = true) { + overlays.confirm("Sign Out of Plex?", "Downloads stay on this phone.", "Sign Out") { + s.plexToken.value = "" + s.plexUser.value = "" + s.musicSection.value = "" + s.musicSectionTitle.value = "" + sections = null + } + } + }) + } + } +} + +@Composable +fun StemServerScreen() { + val g = App.graph + val s = g.settings + val c = Ios.colors + val overlays = LocalOverlays.current + val scope = rememberCoroutineScope() + val status by g.stems.status.collectAsState() + var url by rememberInEntry("url") { mutableStateOf(s.stemUrl.value) } + var token by rememberInEntry("token") { mutableStateOf(s.stemToken.value) } + var busy by remember { mutableStateOf(false) } + Page("Stem Server", grouped = true) { + section("addr", header = "stemserve", footer = "stemserve shares the Stems folder that stemd fills (port 8765). The app checks it for new stems every minute.", rows = listOf( + { FieldCell("Address", url, { url = it }, "http://192.168.86.2:8765") }, + { FieldCell("Token", token, { token = it }, "Optional", secret = true, keyboard = KeyboardType.Password) }, + { + Cell(if (busy) "Connecting…" else "Save & Connect", titleColor = c.accent) { + s.stemUrl.value = url.trim().trimEnd('/') + s.stemToken.value = token.trim() + busy = true + scope.launch { + g.stems.refresh(force = true) + busy = false + overlays.hud(if (g.stems.status.value is StemServerStatus.Online) "Connected" else "Couldn't connect", if (g.stems.status.value is StemServerStatus.Online) Sym.check else Sym.warning) + } + } + }, + )) + section("status", header = "Status", rows = listOf<@Composable () -> Unit>( + { Cell("Connection", value = when (val st = status) { + is StemServerStatus.Online -> "Online" + is StemServerStatus.Offline -> "Offline" + StemServerStatus.Unknown -> "Checking" + }) }, + { Cell("Songs with Stems", value = when (val st = status) { + is StemServerStatus.Online -> "${st.tracks}" + is StemServerStatus.Offline -> "${st.cachedTracks} (cached)" + StemServerStatus.Unknown -> "—" + }) }, + { Cell("Opus Transcoding", value = (status as? StemServerStatus.Online)?.let { if (it.transcode) "Available" else "No ffmpeg" } ?: "—") }, + ) + listOfNotNull((status as? StemServerStatus.Offline)?.let { st -> { Cell("Error", subtitle = st.reason) } })) + } +} + +@Composable +fun QualityScreen() { + val s = App.graph.settings + val q by s.stemQuality.flow.collectAsState() + Page("Stem Quality", grouped = true) { + section("q", footer = "For streaming and new downloads. Opus is made once on the server and kept there; 256 kbps is about an eighth of the FLAC size.", rows = + StemQuality.entries.map { e -> { Cell(e.label, subtitle = e.detail, checked = q == e) { s.stemQuality.value = e } } }) + } +} + +@Composable +fun StorageScreen() { + val g = App.graph + val app = LocalApp.current + val s = g.settings + val c = Ios.colors + val nav = LocalNav.current + val overlays = LocalOverlays.current + val usage by g.cache.usage.collectAsState() + val limit by s.cacheLimitGb.flow.collectAsState() + Page("Storage", grouped = true) { + section("usage", header = "On This Phone", rows = listOf( + { Cell("Downloads", value = gb(usage.pinnedBytes), chevron = true) { app.selectTab(Tab.Downloads) } }, + { Cell("Streaming Cache", value = gb(usage.cachedBytes - usage.pinnedBytes)) }, + )) + val limits = listOf(2, 5, 10, 20, 50, 100) + section("limit", header = "Streaming Cache Limit", footer = "Streamed songs stay for replay and offline use, oldest first out. Downloads don't count.", rows = listOf { + Box(Modifier.padding(horizontal = 16.dp, vertical = 10.dp)) { + SegmentedControl(limits.map { "$it GB" }, limits.indexOf(limit).coerceAtLeast(0), { s.cacheLimitGb.value = limits[it] }) + } + }) + section("clear", rows = listOf { + Cell("Clear Streaming Cache", titleColor = c.red, centered = true) { + overlays.confirm("Clear Cache?", "Downloads are kept.", "Clear") { g.cache.clearUnpinned() } + } + }) + } +} + +@Composable +fun AppearanceScreen() { + val s = App.graph.settings + val c = Ios.colors + val theme by s.theme.flow.collectAsState() + val accent by s.accent.flow.collectAsState() + val albumColor by s.albumColorNowPlaying.flow.collectAsState() + Page("Appearance", grouped = true) { + section("theme", header = "Theme", footer = "Black is true black for OLED. No gradients anywhere, by design.", rows = listOf( + { + Row(Modifier.fillMaxWidth().padding(16.dp), horizontalArrangement = Arrangement.SpaceEvenly) { + ThemeMode.entries.forEach { m -> + val p = palette(m, accent) + Column(horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.tappable { s.theme.value = m }) { + Box( + Modifier.size(78.dp, 140.dp).clip(RoundedCornerShape(12.dp)).background(p.groupedBg) + .border(if (m == theme) 3.dp else 1.dp, if (m == theme) c.accent else c.separator, RoundedCornerShape(12.dp)).padding(8.dp), + ) { + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Box(Modifier.size(40.dp, 6.dp).clip(CircleShape).background(p.label)) + repeat(3) { Box(Modifier.fillMaxWidth().height(18.dp).clip(RoundedCornerShape(4.dp)).background(p.cell)) } + Box(Modifier.size(24.dp, 6.dp).clip(CircleShape).background(p.accent)) + } + } + Spacer(Modifier.height(8.dp)) + Txt(m.label, Type.subhead, weight = if (m == theme) FontWeight.SemiBold else null) + } + } + } + }, + )) + section("accent", header = "Accent", rows = listOf { + Row(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 16.dp), horizontalArrangement = Arrangement.SpaceEvenly) { + Accent.entries.forEach { a -> + val col = Color(if (c.dark) a.dark else a.light) + Box( + Modifier.size(32.dp).clip(CircleShape).background(col).tappable { s.accent.value = a } + .border(if (a == accent) 3.dp else 0.dp, if (a == accent) c.label else Color.Transparent, CircleShape), + ) + } + } + }) + section("np", header = "Now Playing", footer = "Paints the Now Playing screen in one solid colour taken from the album art.", rows = listOf { + Cell("Album Colour Background", trailing = { IosSwitch(albumColor, { s.albumColorNowPlaying.value = it }) }) + }) + } +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/theme/Icons.kt b/android/app/src/main/java/com/stemroller/mobile/ui/theme/Icons.kt new file mode 100644 index 0000000..d3f03e4 --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/theme/Icons.kt @@ -0,0 +1,136 @@ +package com.stemroller.mobile.ui.theme + +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.size +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.ColorFilter +import androidx.compose.ui.graphics.SolidColor +import androidx.compose.ui.graphics.StrokeCap +import androidx.compose.ui.graphics.StrokeJoin +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.graphics.vector.PathParser +import androidx.compose.ui.graphics.vector.rememberVectorPainter +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp + +/** + * SF Symbols-flavoured glyphs on a 24-unit grid. Each layer is a path that's either + * filled (stroke = 0) or stroked with round caps, like SF's regular weight. + */ +object Sym { + private class Layer(val d: String, val stroke: Float = 0f) + + private fun icon(name: String, vararg layers: Layer): ImageVector { + val b = ImageVector.Builder(name, 24.dp, 24.dp, 24f, 24f) + for (l in layers) { + val nodes = PathParser().parsePathString(l.d).toNodes() + if (l.stroke > 0f) { + b.addPath(nodes, fill = null, stroke = SolidColor(Color.Black), strokeLineWidth = l.stroke, + strokeLineCap = StrokeCap.Round, strokeLineJoin = StrokeJoin.Round) + } else { + b.addPath(nodes, fill = SolidColor(Color.Black)) + } + } + return b.build() + } + + private fun f(d: String) = Layer(d) + private fun s(d: String, w: Float = 1.9f) = Layer(d, w) + private fun circle(cx: Float, cy: Float, r: Float) = "M${cx - r} ${cy}a$r $r 0 1 0 ${2 * r} 0a$r $r 0 1 0 ${-2 * r} 0z" + + val play by lazy { icon("play", f("M7.5 4.9v14.2c0 .82.9 1.32 1.6.88l11-7.1a1.05 1.05 0 0 0 0-1.76l-11-7.1c-.7-.44-1.6.06-1.6.88z")) } + val pause by lazy { + icon("pause", f("M6.2 4.5h3.1c.45 0 .8.35.8.8v13.4c0 .45-.35.8-.8.8H6.2a.8.8 0 0 1-.8-.8V5.3c0-.45.35-.8.8-.8zm8.5 0h3.1c.45 0 .8.35.8.8v13.4c0 .45-.35.8-.8.8h-3.1a.8.8 0 0 1-.8-.8V5.3c0-.45.35-.8.8-.8z")) + } + val forward by lazy { + icon("forward", f("M1.6 6.8v10.4c0 .8.88 1.28 1.55.84l7.95-5.2a1 1 0 0 0 0-1.68L3.15 5.96c-.67-.44-1.55.04-1.55.84zm11 0v10.4c0 .8.88 1.28 1.55.84l7.95-5.2a1 1 0 0 0 0-1.68l-7.95-5.2c-.67-.44-1.55.04-1.55.84z")) + } + val backward by lazy { + icon("backward", f("M22.4 6.8v10.4c0 .8-.88 1.28-1.55.84l-7.95-5.2a1 1 0 0 1 0-1.68l7.95-5.2c.67-.44 1.55.04 1.55.84zm-11 0v10.4c0 .8-.88 1.28-1.55.84l-7.95-5.2a1 1 0 0 1 0-1.68l7.95-5.2c.67-.44 1.55.04 1.55.84z")) + } + val chevronRight by lazy { icon("chevron.right", s("M9 4.5l7.5 7.5L9 19.5", 2.4f)) } + val chevronLeft by lazy { icon("chevron.left", s("M15.5 4l-8 8 8 8", 2.6f)) } + val search by lazy { icon("magnifyingglass", s("${circle(10.5f, 10.5f, 6.75f)}M15.6 15.6l5 5", 2.2f)) } + val note by lazy { icon("music.note", s("${circle(6.5f, 17.5f, 3f)}M9.5 17.5V4.2l9 -1.7v12.6${circle(15.5f, 14.8f, 3f)}M9.5 8.2l9-1.7", 1.9f)) } + val noteList by lazy { + icon("music.note.list", s("M3 6h11M3 11h11M3 16h6", 2f), s("M18.5 17.2V5l3-.8", 1.9f), f(circle(16.4f, 17.6f, 2.4f))) + } + val library by lazy { + icon("square.stack", s("M6.5 3.8h11M4.5 6.8h15", 1.8f), + f("M4.2 9.6h15.6c.94 0 1.7.76 1.7 1.7v7.5c0 .94-.76 1.7-1.7 1.7H4.2c-.94 0-1.7-.76-1.7-1.7v-7.5c0-.94.76-1.7 1.7-1.7z")) + } + val sliders by lazy { + icon("slider.vertical.3", s("M6 3.5v17M12 3.5v17M18 3.5v17", 1.8f), + f(circle(6f, 14.5f, 2.6f)), f(circle(12f, 8f, 2.6f)), f(circle(18f, 16f, 2.6f))) + } + val gear by lazy { + icon("gearshape", f("M19.14 12.94c.04-.3.06-.61.06-.94 0-.32-.02-.64-.07-.94l2.03-1.58c.18-.14.23-.41.12-.61l-1.92-3.32c-.12-.22-.37-.29-.59-.22l-2.39.96c-.5-.38-1.03-.7-1.62-.94l-.36-2.54c-.04-.24-.24-.41-.48-.41h-3.84c-.24 0-.43.17-.47.41l-.36 2.54c-.59.24-1.13.57-1.62.94l-2.39-.96c-.22-.08-.47 0-.59.22L2.74 8.87c-.12.21-.08.47.12.61l2.03 1.58c-.05.3-.09.63-.09.94s.02.64.07.94l-2.03 1.58c-.18.14-.23.41-.12.61l1.92 3.32c.12.22.37.29.59.22l2.39-.96c.5.38 1.03.7 1.62.94l.36 2.54c.05.24.24.41.48.41h3.84c.24 0 .44-.17.47-.41l.36-2.54c.59-.24 1.13-.56 1.62-.94l2.39.96c.22.08.47 0 .59-.22l1.92-3.32c.12-.22.07-.47-.12-.61l-2.01-1.58zM12 15.6c-1.98 0-3.6-1.62-3.6-3.6s1.62-3.6 3.6-3.6 3.6 1.62 3.6 3.6-1.62 3.6-3.6 3.6z")) + } + val ellipsis by lazy { icon("ellipsis", f(circle(5f, 12f, 1.9f)), f(circle(12f, 12f, 1.9f)), f(circle(19f, 12f, 1.9f))) } + val plus by lazy { icon("plus", s("M12 5v14M5 12h14", 2.2f)) } + val check by lazy { icon("checkmark", s("M5 12.5l4.5 4.5L19 7.5", 2.4f)) } + val xmark by lazy { icon("xmark", s("M6.5 6.5l11 11M17.5 6.5l-11 11", 2.2f)) } + val shuffle by lazy { + icon("shuffle", s("M3 7h3.2c2.4 0 3.8 1.3 5.3 5s2.9 5 5.3 5H20.5M3 17h3.2c1.2 0 2.1-.35 2.9-1.1M14.3 8.1c.8-.75 1.7-1.1 2.9-1.1H20.5M18 4.5L20.5 7 18 9.5M18 14.5l2.5 2.5-2.5 2.5", 1.9f)) + } + val repeat by lazy { + icon("repeat", s("M4 11.5V9.5A3.5 3.5 0 0 1 7.5 6H20M17.2 3.2L20 6l-2.8 2.8M20 12.5v2A3.5 3.5 0 0 1 16.5 18H4M6.8 20.8L4 18l2.8-2.8", 1.9f)) + } + val repeatOne by lazy { + icon("repeat.1", s("M4 11.5V9.5A3.5 3.5 0 0 1 7.5 6H20M17.2 3.2L20 6l-2.8 2.8M20 12.5v2A3.5 3.5 0 0 1 16.5 18H4M6.8 20.8L4 18l2.8-2.8", 1.9f), + s("M11 10.6l1.4-.9v5", 1.7f)) + } + val speaker by lazy { icon("speaker.fill", f("M3.2 9.2h3.1L11 5.3c.4-.33 1-.05 1 .47v12.46c0 .52-.6.8-1 .47l-4.7-3.9H3.2a.7.7 0 0 1-.7-.7V9.9c0-.39.31-.7.7-.7z")) } + val speakerWave by lazy { + icon("speaker.wave.3.fill", f("M2.2 9.2h3.1L10 5.3c.4-.33 1-.05 1 .47v12.46c0 .52-.6.8-1 .47l-4.7-3.9H2.2a.7.7 0 0 1-.7-.7V9.9c0-.39.31-.7.7-.7z"), + s("M14 9.3a3.8 3.8 0 0 1 0 5.4M16.6 6.8a7.4 7.4 0 0 1 0 10.4M19.2 4.3a11 11 0 0 1 0 15.4", 1.7f)) + } + val speakerSlash by lazy { + icon("speaker.slash.fill", f("M2.2 9.2h3.1L10 5.3c.4-.33 1-.05 1 .47v12.46c0 .52-.6.8-1 .47l-4.7-3.9H2.2a.7.7 0 0 1-.7-.7V9.9c0-.39.31-.7.7-.7z"), + s("M15 9.5l5 5M20 9.5l-5 5", 1.9f)) + } + val download by lazy { icon("arrow.down.circle", s("${circle(12f, 12f, 9.25f)}M12 7.5v8.5M8.5 12.6L12 16l3.5-3.4", 1.8f)) } + val queue by lazy { + icon("list.bullet", s("M8.5 6h12M8.5 12h12M8.5 18h12", 1.9f), f(circle(4f, 6f, 1.5f)), f(circle(4f, 12f, 1.5f)), f(circle(4f, 18f, 1.5f))) + } + val person by lazy { icon("person", s("${circle(12f, 7.8f, 4f)}M4.5 20.5c0-3.7 3.4-6.2 7.5-6.2s7.5 2.5 7.5 6.2", 1.9f)) } + val album by lazy { + icon("square.stack", s("M6 3.8h12", 1.8f), + f("M5 6.8h14c.94 0 1.7.76 1.7 1.7v10.8c0 .94-.76 1.7-1.7 1.7H5c-.94 0-1.7-.76-1.7-1.7V8.5c0-.94.76-1.7 1.7-1.7z")) + } + val waveform by lazy { icon("waveform", s("M3 10.5v3M6.6 7v10M10.2 4.5v15M13.8 8.5v7M17.4 6v12M21 10v4", 2f)) } + val headphones by lazy { + icon("headphones", s("M4 15.5v-3.2a8 8 0 0 1 16 0v3.2", 1.9f), + f("M3.5 14.2h2.6c.66 0 1.2.54 1.2 1.2v4.2c0 .66-.54 1.2-1.2 1.2H4.9c-.77 0-1.4-.63-1.4-1.4v-5.2zM20.5 14.2h-2.6c-.66 0-1.2.54-1.2 1.2v4.2c0 .66.54 1.2 1.2 1.2h1.2c.77 0 1.4-.63 1.4-1.4v-5.2z")) + } + val phone by lazy { icon("iphone", s("M8.2 2.8h7.6c1.1 0 2 .9 2 2v14.4c0 1.1-.9 2-2 2H8.2c-1.1 0-2-.9-2-2V4.8c0-1.1.9-2 2-2zM10.6 5.6h2.8", 1.8f)) } + val usb by lazy { icon("cable.connector", s("M8.5 3.5h7v6.5h-7zM12 10v10.5M10.5 6h.01M13.5 6h.01", 1.8f)) } + val server by lazy { + icon("server.rack", s("M4.5 4.5h15c.55 0 1 .45 1 1v3.5c0 .55-.45 1-1 1h-15a1 1 0 0 1-1-1V5.5c0-.55.45-1 1-1zM4.5 14h15c.55 0 1 .45 1 1v3.5c0 .55-.45 1-1 1h-15a1 1 0 0 1-1-1V15c0-.55.45-1 1-1z", 1.8f), + f(circle(7f, 7.25f, 1.1f)), f(circle(7f, 16.75f, 1.1f))) + } + val refresh by lazy { icon("arrow.clockwise", s("M19.5 12.5A7.5 7.5 0 1 1 17 6.8M19.5 3.5v4.4h-4.4", 2f)) } + val grip by lazy { icon("line.3.horizontal", s("M4 7.5h16M4 12h16M4 16.5h16", 1.8f)) } + val info by lazy { icon("info.circle", s("${circle(12f, 12f, 9.25f)}M12 11v6M12 7.6v.01", 2f)) } + val warning by lazy { icon("exclamationmark.triangle", s("M10.3 4.2L2.8 17.6c-.75 1.33.21 2.9 1.7 2.9h15c1.49 0 2.45-1.57 1.7-2.9L13.7 4.2a1.95 1.95 0 0 0-3.4 0zM12 9.5v4.5M12 17.2v.01", 1.8f)) } + val paintbrush by lazy { icon("paintbrush", s("M14.5 4.5l5 5-7.8 7.8-5-5zM6.7 12.3c-2.3.3-3.2 2.5-3.2 4.2 0 1.3-.5 2.4-1 3 3.7.6 7.4-.3 7.7-3.7", 1.8f)) } + val gauge by lazy { icon("gauge", s("M4.2 17.5a9 9 0 1 1 15.6 0M12 13l4-5", 1.9f), f(circle(12f, 13.4f, 1.7f))) } + val externalDrive by lazy { icon("internaldrive", s("M3.5 13l2.4-7.2c.27-.8 1-1.3 1.85-1.3h8.5c.84 0 1.58.5 1.85 1.3L20.5 13v4.5c0 1.1-.9 2-2 2h-13c-1.1 0-2-.9-2-2zM3.5 13h17M16.5 16.3h.01", 1.8f)) } + val airplay by lazy { + icon("airplayaudio", s("M6.3 17.4a8 8 0 1 1 11.4 0M8.9 14.9a4.4 4.4 0 1 1 6.2 0", 1.8f), f("M12 14.2l4.5 6.3h-9z")) + } + val playNext by lazy { icon("text.insert", s("M4 6.5h9M4 11.5h9M4 16.5h6", 1.9f), f("M15.5 13.6v6.8c0 .5.56.8.98.52l5.1-3.4a.62.62 0 0 0 0-1.04l-5.1-3.4c-.42-.28-.98.02-.98.52z")) } + val addQueue by lazy { icon("text.append", s("M4 6.5h16M4 11.5h16M4 16.5h9M17.5 14v6M14.5 17h6", 1.9f)) } +} + +@Composable +fun Icon(vector: ImageVector, tint: Color, modifier: Modifier = Modifier, size: Dp = 24.dp) { + Image( + painter = rememberVectorPainter(vector), + contentDescription = null, + modifier = modifier.size(size), + colorFilter = ColorFilter.tint(tint), + ) +} diff --git a/android/app/src/main/java/com/stemroller/mobile/ui/theme/Theme.kt b/android/app/src/main/java/com/stemroller/mobile/ui/theme/Theme.kt new file mode 100644 index 0000000..865c24c --- /dev/null +++ b/android/app/src/main/java/com/stemroller/mobile/ui/theme/Theme.kt @@ -0,0 +1,151 @@ +package com.stemroller.mobile.ui.theme + +import androidx.compose.foundation.text.BasicText +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.Immutable +import androidx.compose.runtime.remember +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.ExperimentalTextApi +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.Font +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontVariation +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.LineHeightStyle +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.TextUnit +import androidx.compose.ui.unit.sp +import com.stemroller.mobile.R +import com.stemroller.mobile.core.Accent +import com.stemroller.mobile.core.ThemeMode +import kotlin.math.exp + +/** iOS semantic colours, flattened to solid values for each scheme. */ +@Immutable +data class Palette( + val dark: Boolean, + val bg: Color, + val groupedBg: Color, + val cell: Color, + val cellPressed: Color, + val elevated: Color, + val fill: Color, + val fillStrong: Color, + val label: Color, + val label2: Color, + val label3: Color, + val separator: Color, + val bar: Color, + val barBorder: Color, + val accent: Color, + val red: Color, + val green: Color, + val switchOff: Color, + val scrim: Color, + val placeholder: Color, + val thumbBorder: Color, + val tabInactive: Color, +) + +fun palette(mode: ThemeMode, accent: Accent): Palette = when (mode) { + ThemeMode.Black -> Palette( + dark = true, bg = Color(0xFF000000), groupedBg = Color(0xFF000000), cell = Color(0xFF1C1C1E), + cellPressed = Color(0xFF2C2C2E), elevated = Color(0xFF1C1C1E), fill = Color(0xFF1C1C1E), + fillStrong = Color(0xFF3A3A3C), label = Color.White, label2 = Color(0xFF8D8D93), label3 = Color(0xFF48484A), + separator = Color(0xFF2C2C2E), bar = Color(0xFF000000), barBorder = Color(0xFF262628), + accent = Color(accent.dark), red = Color(0xFFFF453A), green = Color(0xFF30D158), switchOff = Color(0xFF39393D), + scrim = Color(0x99000000), placeholder = Color(0xFF1C1C1E), thumbBorder = Color(0x00000000), tabInactive = Color(0xFF757575), + ) + ThemeMode.Dark -> Palette( + dark = true, bg = Color(0xFF1C1C1E), groupedBg = Color(0xFF1C1C1E), cell = Color(0xFF2C2C2E), + cellPressed = Color(0xFF3A3A3C), elevated = Color(0xFF2C2C2E), fill = Color(0xFF2C2C2E), + fillStrong = Color(0xFF48484A), label = Color.White, label2 = Color(0xFF98989D), label3 = Color(0xFF5A5A5E), + separator = Color(0xFF3D3D40), bar = Color(0xFF1C1C1E), barBorder = Color(0xFF38383A), + accent = Color(accent.dark), red = Color(0xFFFF453A), green = Color(0xFF30D158), switchOff = Color(0xFF48484A), + scrim = Color(0x99000000), placeholder = Color(0xFF3A3A3C), thumbBorder = Color(0x00000000), tabInactive = Color(0xFF808084), + ) + ThemeMode.White -> Palette( + dark = false, bg = Color(0xFFFFFFFF), groupedBg = Color(0xFFF2F2F7), cell = Color(0xFFFFFFFF), + cellPressed = Color(0xFFD1D1D6), elevated = Color(0xFFFFFFFF), fill = Color(0xFFEFEFF0), + fillStrong = Color(0xFFE3E3E8), label = Color.Black, label2 = Color(0xFF8A8A8E), label3 = Color(0xFFC4C4C7), + separator = Color(0xFFD8D8DC), bar = Color(0xFFF9F9F9), barBorder = Color(0xFFD1D1D6), + accent = Color(accent.light), red = Color(0xFFFF3B30), green = Color(0xFF34C759), switchOff = Color(0xFFE9E9EA), + scrim = Color(0x55000000), placeholder = Color(0xFFE5E5EA), thumbBorder = Color(0xFFD1D1D6), tabInactive = Color(0xFF999999), + ) +} + +@OptIn(ExperimentalTextApi::class) +private fun inter(opsz: Float) = FontFamily( + listOf(400, 500, 600, 700, 800).map { w -> + Font( + R.font.inter, + weight = FontWeight(w), + variationSettings = FontVariation.Settings(FontVariation.weight(w), FontVariation.Setting("opsz", opsz)), + ) + }, +) + +/** Inter stands in for SF Pro: the text cut below 20 sp, the display cut above. */ +val InterText = inter(14f) +val InterDisplay = inter(32f) + +/** Inter's recommended tracking for a size, like SF's size-specific tracking. */ +private fun tracking(size: Float): TextUnit = (size * (-0.0223f + 0.185f * exp(-0.1745f * size))).sp + +private fun style(size: Float, line: Float, weight: Int) = TextStyle( + fontFamily = if (size >= 20f) InterDisplay else InterText, + fontSize = size.sp, + lineHeight = line.sp, + fontWeight = FontWeight(weight), + letterSpacing = tracking(size), + lineHeightStyle = LineHeightStyle(LineHeightStyle.Alignment.Center, LineHeightStyle.Trim.None), +) + +/** The iOS text styles, in points-as-sp (a OnePlus 15 is about as wide as an iPhone Pro Max). */ +object Type { + val largeTitle = style(34f, 41f, 700) + val title2 = style(22f, 28f, 700) + val title3 = style(20f, 25f, 600) + val headline = style(17f, 22f, 600) + val body = style(17f, 22f, 400) + val subhead = style(15f, 20f, 400) + val footnote = style(13f, 18f, 400) + val caption1 = style(12f, 16f, 400) + val caption2 = style(11f, 13f, 400) +} + +val LocalPalette = staticCompositionLocalOf { palette(ThemeMode.Black, Accent.Music) } + +object Ios { + val colors: Palette @Composable get() = LocalPalette.current +} + +@Composable +fun IosTheme(mode: ThemeMode, accent: Accent, content: @Composable () -> Unit) { + val p = remember(mode, accent) { palette(mode, accent) } + CompositionLocalProvider(LocalPalette provides p, content = content) +} + +/** BasicText with iOS defaults: label colour, single line, tail ellipsis. */ +@Composable +fun Txt( + text: String, + style: TextStyle, + modifier: Modifier = Modifier, + color: Color = Ios.colors.label, + maxLines: Int = 1, + align: TextAlign? = null, + weight: FontWeight? = null, +) { + BasicText( + text = text, + modifier = modifier, + style = style.copy(color = color, textAlign = align ?: TextAlign.Unspecified, fontWeight = weight ?: style.fontWeight), + maxLines = maxLines, + overflow = TextOverflow.Ellipsis, + ) +} diff --git a/android/app/src/main/res/drawable/ic_car_mix.xml b/android/app/src/main/res/drawable/ic_car_mix.xml new file mode 100644 index 0000000..ee88a99 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_car_mix.xml @@ -0,0 +1,10 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_car_shuffle.xml b/android/app/src/main/res/drawable/ic_car_shuffle.xml new file mode 100644 index 0000000..64a1a62 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_car_shuffle.xml @@ -0,0 +1,10 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_car_vocals.xml b/android/app/src/main/res/drawable/ic_car_vocals.xml new file mode 100644 index 0000000..4373c32 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_car_vocals.xml @@ -0,0 +1,10 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_car_vocals_off.xml b/android/app/src/main/res/drawable/ic_car_vocals_off.xml new file mode 100644 index 0000000..a12cfb1 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_car_vocals_off.xml @@ -0,0 +1,10 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_launcher_background.xml b/android/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..2a3ae6b --- /dev/null +++ b/android/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,4 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_launcher_foreground.xml b/android/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 0000000..050a023 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,11 @@ + + + + + + + + + diff --git a/android/app/src/main/res/drawable/ic_launcher_monochrome.xml b/android/app/src/main/res/drawable/ic_launcher_monochrome.xml new file mode 100644 index 0000000..99073b7 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_launcher_monochrome.xml @@ -0,0 +1,6 @@ + + + + diff --git a/android/app/src/main/res/drawable/ic_stat_stems.xml b/android/app/src/main/res/drawable/ic_stat_stems.xml new file mode 100644 index 0000000..48f8404 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_stat_stems.xml @@ -0,0 +1,6 @@ + + + + diff --git a/android/app/src/main/res/font/inter.ttf b/android/app/src/main/res/font/inter.ttf new file mode 100644 index 0000000000000000000000000000000000000000..4ab79e0102bbe0ffa1ed879b13e52ac8c6487833 GIT binary patch literal 879708 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 z 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

R*jRJ1?^iQ`xYAuqn>-7iqg^r+ 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

!+-?iHy`H`{?S!=5pudjt1=3|0 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⁣dUi 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

=;034=|=!0qfLoVZ{M)EKH3o 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 literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/mipmap-anydpi/ic_launcher.xml b/android/app/src/main/res/mipmap-anydpi/ic_launcher.xml new file mode 100644 index 0000000..8fde456 --- /dev/null +++ b/android/app/src/main/res/mipmap-anydpi/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/android/app/src/main/res/raw/keep.xml b/android/app/src/main/res/raw/keep.xml new file mode 100644 index 0000000..182cb23 --- /dev/null +++ b/android/app/src/main/res/raw/keep.xml @@ -0,0 +1,4 @@ + + + diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..78b8845 --- /dev/null +++ b/android/app/src/main/res/values/strings.xml @@ -0,0 +1,4 @@ + + + StemRoller + diff --git a/android/app/src/main/res/values/themes.xml b/android/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..f986874 --- /dev/null +++ b/android/app/src/main/res/values/themes.xml @@ -0,0 +1,14 @@ + + + + diff --git a/android/app/src/main/res/xml/automotive_app_desc.xml b/android/app/src/main/res/xml/automotive_app_desc.xml new file mode 100644 index 0000000..e64f442 --- /dev/null +++ b/android/app/src/main/res/xml/automotive_app_desc.xml @@ -0,0 +1,4 @@ + + + + diff --git a/android/app/src/main/res/xml/network_security_config.xml b/android/app/src/main/res/xml/network_security_config.xml new file mode 100644 index 0000000..74a3cc5 --- /dev/null +++ b/android/app/src/main/res/xml/network_security_config.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/android/app/src/test/java/com/stemroller/mobile/CarTreeTest.kt b/android/app/src/test/java/com/stemroller/mobile/CarTreeTest.kt new file mode 100644 index 0000000..0d2ee7c --- /dev/null +++ b/android/app/src/test/java/com/stemroller/mobile/CarTreeTest.kt @@ -0,0 +1,90 @@ +package com.stemroller.mobile + +import com.stemroller.mobile.auto.CarIds +import com.stemroller.mobile.auto.CarTree +import com.stemroller.mobile.playback.MixPresets +import com.stemroller.mobile.playback.StemSetting +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class CarTreeTest { + @Test + fun picksRoundTrip() { + assertEquals(CarIds.Pick.Song("album:123", "456"), CarIds.parsePick(CarIds.play("album:123", "456"))) + assertEquals(CarIds.Pick.Shuffle("playlist:9"), CarIds.parsePick(CarIds.shuffle("playlist:9"))) + // Search queries can contain the separator; the container is last so they survive. + val q = CarIds.search("AC|DC: Back in Black") + assertEquals(CarIds.Pick.Song(q, "77"), CarIds.parsePick(CarIds.play(q, "77"))) + assertNull(CarIds.parsePick("album:123")) + assertNull(CarIds.parsePick("play|456")) + assertNull(CarIds.parsePick("shuffle|")) + } + + @Test + fun splitsContainers() { + assertEquals("album" to "123", CarIds.split("album:123")) + assertEquals("search" to "a:b", CarIds.split("search:a:b")) + assertNull(CarIds.split("root")) + } + + @Test + fun lettersFoldAccentsAndNonLetters() { + assertEquals("E", CarTree.letterOf("Éric Serra")) + assertEquals("#", CarTree.letterOf("2Pac")) + assertEquals("#", CarTree.letterOf("!!!")) + assertEquals("B", CarTree.letterOf(" black sabbath")) + assertEquals("#", CarTree.letterOf("")) + } + + @Test + fun bucketsPutNumbersFirst() { + val b = CarTree.buckets(listOf("Zappa", "ABBA", "2Pac", "AC/DC", "Björk")) { it } + assertEquals(listOf("#", "A", "B", "Z"), b.keys.toList()) + assertEquals(listOf("ABBA", "AC/DC"), b["A"]) + } + + @Test + fun voiceMatchingIgnoresCaseAccentsPunctuationAndThe() { + assertTrue(CarTree.matches("Paranoid", "paranoid")) + assertTrue(CarTree.matches("The Beatles", "beatles")) + assertTrue(CarTree.matches("Motörhead", "motorhead")) + assertTrue(CarTree.matches("AC/DC", "acdc")) + assertFalse(CarTree.matches("Paranoid", "para")) + assertFalse(CarTree.matches("Paranoid", "")) + } + + private val six = listOf("vocals", "drums", "bass", "guitar", "piano", "other") + + @Test + fun mixCycleSkipsPresetsTheTrackCantDo() { + val labels = generateSequence(emptyMap()) { m -> MixPresets.next(six, m).build(six) } + .drop(1).take(MixPresets.ALL.size).map { MixPresets.current(six, it)!!.label }.toList() + assertEquals(listOf("Karaoke", "A Cappella", "No Drums", "Rhythm", "No Guitar", "No Bass", "Full Mix"), labels) + + val two = listOf("vocals", "instrumental") + assertEquals("Karaoke", MixPresets.next(two, emptyMap()).label) + assertEquals("A Cappella", MixPresets.next(two, MixPresets.KARAOKE.build(two)!!).label) + assertEquals("Full Mix", MixPresets.next(two, MixPresets.ALL[2].build(two)!!).label) + } + + @Test + fun customMixIsRecognisedAndCyclesToFull() { + val custom = mapOf("drums" to StemSetting(level = 0.5f)) + assertNull(MixPresets.current(six, custom)) + assertEquals("Full Mix", MixPresets.next(six, custom).label) + // Faders left at their defaults don't make a mix custom. + assertEquals("Full Mix", MixPresets.current(six, mapOf("bass" to StemSetting()))!!.label) + } + + @Test + fun vocalsSilence() { + assertFalse(MixPresets.vocalsSilent(six, emptyMap())) + assertTrue(MixPresets.vocalsSilent(six, MixPresets.KARAOKE.build(six)!!)) + assertFalse(MixPresets.vocalsSilent(six, MixPresets.ALL[2].build(six)!!)) // A Cappella + assertTrue(MixPresets.vocalsSilent(six, MixPresets.ALL[4].build(six)!!)) // Rhythm solos drums and bass + assertFalse(MixPresets.vocalsSilent(listOf("drums"), emptyMap())) + } +} diff --git a/android/app/src/test/java/com/stemroller/mobile/DspTest.kt b/android/app/src/test/java/com/stemroller/mobile/DspTest.kt new file mode 100644 index 0000000..060f249 --- /dev/null +++ b/android/app/src/test/java/com/stemroller/mobile/DspTest.kt @@ -0,0 +1,188 @@ +package com.stemroller.mobile + +import com.stemroller.mobile.engine.EQ_BANDS +import com.stemroller.mobile.engine.EqChannel +import com.stemroller.mobile.engine.EqFilter +import com.stemroller.mobile.engine.FilterType +import com.stemroller.mobile.eq.ApoConfig +import com.stemroller.mobile.eq.EqProfile +import com.stemroller.mobile.engine.EqMath +import com.stemroller.mobile.engine.EqParams +import com.stemroller.mobile.engine.Equalizer +import com.stemroller.mobile.engine.FloatRing +import com.stemroller.mobile.engine.Limiter +import com.stemroller.mobile.engine.stemTaper +import com.stemroller.mobile.engine.stemUntaper +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import kotlin.math.PI +import kotlin.math.abs +import kotlin.math.sin + +class DspTest { + private fun gains(vararg pairs: Pair) = EqFilter.graphic(List(EQ_BANDS.size) { i -> pairs.firstOrNull { it.first == i }?.second ?: 0f }) + + @Test fun flatOrCutsNeedNoPreamp() { + assertEquals(0f, EqMath.autoPreampDb(gains()), 1e-4f) + assertEquals(0f, EqMath.autoPreampDb(gains(3 to -6f, 7 to -12f)), 1e-4f) + } + + @Test fun singleBoostIsCancelledExactly() { + assertEquals(-6f, EqMath.autoPreampDb(gains(5 to 6f)), 0.1f) + assertEquals(-12f, EqMath.autoPreampDb(gains(9 to 12f)), 0.15f) + } + + @Test fun overlappingBoostsAddUp() { + val p = EqMath.autoPreampDb(gains(1 to 6f, 2 to 6f)) + assertTrue("got $p", p < -6.5f) + } + + @Test fun manualPreampCountsTowardsAntiClip() { + assertEquals(0f, EqMath.autoPreampDb(gains(5 to 6f), manualDb = -6f), 0.1f) + assertEquals(-3f, EqMath.autoPreampDb(gains(5 to 6f), manualDb = -3f), 0.1f) + } + + /** A full-scale sine at the curve's peak must not clip once the auto preamp is applied. */ + @Test fun preampPreventsClippingAtThePeak() { + val g = gains(0 to 9f, 1 to 9f, 2 to 6f, 8 to 4f) + val pre = EqMath.autoPreampDb(g) + val fs = 48000 + val freqs = EqMath.logFreqs(256) + val resp = EqMath.response(g, freqs) + val peakF = freqs[resp.indices.maxBy { resp[it] }] + val eq = Equalizer().apply { configure(EqParams(g, pre), fs) } + val n = fs * 2 + val buf = FloatArray(n * 2) { i -> sin(2 * PI * peakF * (i / 2) / fs).toFloat() } + eq.process(buf, n) + val settled = buf.copyOfRange(n, n * 2).maxOf { abs(it) } + assertTrue("peak $settled at ${peakF.toInt()} Hz", settled <= 1.01f) + assertTrue("too quiet: $settled", settled > 0.95f) + } + + private fun at(f: EqFilter, hz: Double) = EqMath.response(listOf(f), doubleArrayOf(hz))[0] + + @Test fun shelvesReachTheirGain() { + val ls = EqFilter("a", FilterType.LowShelf, 100f, 6f, 0.707f) + assertEquals(6.0, at(ls, 20.0), 0.3) + assertEquals(3.0, at(ls, 100.0), 0.3) + assertEquals(0.0, at(ls, 5000.0), 0.1) + val hs = EqFilter("b", FilterType.HighShelf, 5000f, -4f, 0.707f) + assertEquals(-4.0, at(hs, 19000.0), 0.4) + assertEquals(0.0, at(hs, 100.0), 0.1) + } + + @Test fun passSlopesFallAtTheRightRate() { + for (slope in listOf(6, 12, 24, 36, 48)) { + val lp = EqFilter("lp", FilterType.LowPass, 1000f, slope = slope, q = 0.707f) + // Two octaves above the corner, a Butterworth is down ~slope*2 dB, and -3 dB at the corner. + val drop = at(lp, 4000.0) - at(lp, 8000.0) + assertEquals("slope $slope", slope.toDouble(), drop, slope * 0.12 + 0.6) + assertEquals("corner $slope", -3.0, at(lp, 1000.0), 0.3) + val hp = EqFilter("hp", FilterType.HighPass, 1000f, slope = slope, q = 0.707f) + assertEquals("hp slope $slope", slope.toDouble(), at(hp, 250.0) - at(hp, 125.0), slope * 0.12 + 0.6) + } + } + + @Test fun notchAndAllPass() { + assertTrue(at(EqFilter("n", FilterType.Notch, 60f, q = 4f), 60.0) < -40) + assertEquals(0.0, at(EqFilter("n", FilterType.Notch, 60f, q = 4f), 1000.0), 0.1) + for (hz in listOf(50.0, 1000.0, 15000.0)) assertEquals(0.0, at(EqFilter("ap", FilterType.AllPass, 1000f), hz), 1e-6) + assertEquals(0.0, at(EqFilter("bp", FilterType.BandPass, 1000f, q = 0.707f), 1000.0), 0.05) + } + + @Test fun channelFiltersOnlyTouchTheirSide() { + val f = EqFilter("l", FilterType.Peak, 1000f, 6f, 1.41f, channel = EqChannel.Left) + val eq = Equalizer().apply { configure(EqParams(listOf(f), 0f), 48000) } + val n = 48000 + val buf = FloatArray(n * 2) { i -> (0.25 * sin(2 * PI * 1000 * (i / 2) / 48000.0)).toFloat() } + eq.process(buf, n) + val l = (n / 2 until n).maxOf { abs(buf[it * 2]) } + val r = (n / 2 until n).maxOf { abs(buf[it * 2 + 1]) } + assertEquals(0.5, l.toDouble(), 0.02) + assertEquals(0.25, r.toDouble(), 0.001) + } + + @Test fun parsesAutoEqConfig() { + val text = """ + Preamp: -6.4 dB + Filter 1: ON LSC Fc 105 Hz Gain 6.0 dB Q 0.70 + Filter 2: ON PK Fc 2300 Hz Gain -3.1 dB Q 1.41 + Filter 3: OFF HSC Fc 10000 Hz Gain 2 dB Q 0.7 + Channel: R + Filter 4: ON PK Fc 500 Hz Gain 1 dB BW Oct 1 + GraphicEQ: 20 -1; 30 -2 + """.trimIndent() + val r = ApoConfig.parse(text)!! + assertEquals(-6.4f, r.preamp!!, 1e-4f) + assertEquals(4, r.filters.size) + assertEquals(1, r.skipped) + assertEquals(FilterType.LowShelf, r.filters[0].type) + assertEquals(105f, r.filters[0].freq, 1e-4f) + assertEquals(-3.1f, r.filters[1].gain, 1e-4f) + assertEquals(false, r.filters[2].on) + assertEquals(EqChannel.Right, r.filters[3].channel) + assertEquals(1.414f, r.filters[3].q, 0.01f) + assertEquals(null, ApoConfig.parse("hello")) + } + + @Test fun apoExportRoundTrips() { + val p = EqProfile("x", "Test", List(EQ_BANDS.size) { if (it == 2) 3f else 0f }, preamp = -2f, filters = listOf( + EqFilter("a", FilterType.HighShelf, 8000f, -2.5f, 0.71f, channel = EqChannel.Left), + EqFilter("b", FilterType.HighPass, 30f, slope = 24), + )) + val back = ApoConfig.parse(ApoConfig.format(p))!! + assertEquals(-2f, back.preamp!!, 1e-4f) + val freqs = EqMath.logFreqs(64) + val want = EqMath.response(p.chain, freqs, true) + val got = EqMath.response(back.filters, freqs, true) + for (i in freqs.indices) assertEquals(want[i], got[i], 0.05) + } + + /** eq.json written before parametric filters existed must still load, or profiles are lost. */ + @Test fun oldEqSettingsStillLoad() { + val old = """{"enabled":true,"automatic":false,"manualId":"abc","profiles":[{"id":"abc","name":"XM5", + "gains":[1,2,3,0,0,0,0,0,-1,-2],"devices":[{"type":8,"name":"WH-1000XM5"}]}]}""" + val s = com.stemroller.mobile.core.AppJson.decodeFromString(com.stemroller.mobile.eq.EqState.serializer(), old) + val p = s.profiles.single() + assertEquals("XM5", p.name) + assertEquals(0, p.filters.size) + assertEquals(0f, p.preamp) + assertEquals(5, p.chain.size) + } + + @Test fun limiterHoldsTheCeiling() { + val lim = Limiter().apply { setSampleRate(48000) } + val n = 48000 + val loud = FloatArray(n * 2) { i -> (2.5 * sin(2 * PI * 220 * (i / 2) / 48000.0)).toFloat() } + lim.process(loud, n) + assertTrue(loud.maxOf { abs(it) } <= 0.9851f) + val lim2 = Limiter().apply { setSampleRate(48000) } + val quiet = FloatArray(n * 2) { i -> (0.5 * sin(2 * PI * 220 * (i / 2) / 48000.0)).toFloat() } + val copy = quiet.copyOf() + lim2.process(quiet, n) + assertTrue(quiet.indices.all { abs(quiet[it] - copy[it]) < 1e-6f }) + } + + @Test fun stemTaperHasUnityAtTheDetent() { + assertEquals(1f, stemTaper(0.8f), 1e-6f) + assertEquals(0f, stemTaper(0f), 1e-6f) + assertEquals(0.8f, stemUntaper(1f), 1e-6f) + } + + @Test fun ringWrapsAround() { + val ring = FloatRing(100) + val src = FloatArray(140) { it.toFloat() } + val dst = FloatArray(200) + var next = 0f + repeat(20) { + assertTrue(ring.write(src, 0, 140) { false }) + val got = ring.read(dst, 70) + assertEquals(70, got) + for (i in 0 until got * 2) { + assertEquals(next, dst[i]) + next = (next + 1) % 140 + } + } + } +} diff --git a/android/app/src/test/java/com/stemroller/mobile/MediaCacheTest.kt b/android/app/src/test/java/com/stemroller/mobile/MediaCacheTest.kt new file mode 100644 index 0000000..096d55f --- /dev/null +++ b/android/app/src/test/java/com/stemroller/mobile/MediaCacheTest.kt @@ -0,0 +1,113 @@ +package com.stemroller.mobile + +import com.stemroller.mobile.cache.MediaCache +import okhttp3.OkHttpClient +import org.junit.After +import org.junit.Assert.assertArrayEquals +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Assume.assumeTrue +import org.junit.Before +import org.junit.Test +import java.io.File +import java.io.RandomAccessFile +import java.net.URI +import java.net.URLEncoder +import java.nio.file.Files +import java.util.Random +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit + +/** + * Streams a real stem from a locally running stemserve (server/stemserve.py) through the + * block cache and checks every byte against the file on the share. + */ +class MediaCacheTest { + private val stems = File("/var/mnt/unraid/Music/Stems") + private lateinit var dir: File + private lateinit var src: File + private lateinit var url: String + private val http = OkHttpClient.Builder().readTimeout(60, TimeUnit.SECONDS).build() + + @Before fun setUp() { + val up = runCatching { URI("http://localhost:8765/api/info").toURL().readText() }.isSuccess + assumeTrue("stemserve not running on :8765", up && stems.isDirectory) + src = stems.walkTopDown().filter { it.name.endsWith(" - vocals.flac") }.minBy { it.length() } + val rel = src.relativeTo(stems).invariantSeparatorsPath.split('/') + .joinToString("/") { URLEncoder.encode(it, "UTF-8").replace("+", "%20") } + url = "http://localhost:8765/file/$rel" + dir = Files.createTempDirectory("mediacache").toFile() + } + + @After fun tearDown() { + if (::dir.isInitialized) dir.deleteRecursively() + } + + private fun expected(pos: Long, len: Int): ByteArray = RandomAccessFile(src, "r").use { f -> + f.seek(pos) + ByteArray(len).also { f.readFully(it) } + } + + @Test fun randomReadsMatchTheFile() { + val cache = MediaCache(dir, http) { Long.MAX_VALUE } + val res = cache.acquire("test|vocals") { url } + assertEquals(src.length(), res.size()) + val rnd = Random(42) + val pool = Executors.newFixedThreadPool(4) + val jobs = (0 until 64).map { + val len = 1 + rnd.nextInt(300_000) + val pos = (rnd.nextDouble() * (src.length() - len)).toLong() + pool.submit { + val buf = ByteArray(len) + var got = 0 + while (got < len) { + val n = res.readAt(pos + got, buf, got, len - got) + check(n > 0) + got += n + } + assertArrayEquals("at $pos+$len", expected(pos, len), buf) + } + } + jobs.forEach { it.get(60, TimeUnit.SECONDS) } + pool.shutdown() + // Past EOF + assertEquals(-1, res.readAt(src.length(), ByteArray(10), 0, 10)) + cache.release(res) + } + + @Test fun downloadPersistsAndSurvivesReopen() { + val cache = MediaCache(dir, http) { Long.MAX_VALUE } + val res = cache.acquire("dl|vocals") { url } + res.pinned = true + res.downloadAll({ _, _ -> }, { false }) + assertTrue(res.isComplete) + cache.release(res) + assertTrue(cache.isComplete("dl|vocals")) + + // A fresh cache over the same directory serves it without any network. + val offline = MediaCache(dir, http) { Long.MAX_VALUE } + val again = offline.acquire("dl|vocals") { "http://127.0.0.1:9/unreachable" } + val buf = ByteArray(4096) + val tail = src.length() - 4096 + assertEquals(4096, again.readAt(tail, buf, 0, 4096)) + assertArrayEquals(expected(tail, 4096), buf) + offline.release(again) + } + + @Test fun evictionSparesPinnedAndInUse() { + val cache = MediaCache(dir, http) { 1L } + val pinned = cache.acquire("pinned") { url } + pinned.pinned = true + pinned.downloadAll({ _, _ -> }, { false }) + cache.release(pinned) + val loose = cache.acquire("loose") { url } + loose.downloadAll({ _, _ -> }, { false }) + cache.release(loose) + // Trimming runs on the cache's own thread; give it a moment. + val deadline = System.currentTimeMillis() + 5000 + while (cache.isComplete("loose") && System.currentTimeMillis() < deadline) Thread.sleep(50) + assertFalse(cache.isComplete("loose")) + assertTrue(cache.isComplete("pinned")) + } +} diff --git a/android/app/src/test/java/com/stemroller/mobile/StemIndexTest.kt b/android/app/src/test/java/com/stemroller/mobile/StemIndexTest.kt new file mode 100644 index 0000000..1d436e7 --- /dev/null +++ b/android/app/src/test/java/com/stemroller/mobile/StemIndexTest.kt @@ -0,0 +1,72 @@ +package com.stemroller.mobile + +import com.stemroller.mobile.core.AppJson +import com.stemroller.mobile.stems.StemEntry +import com.stemroller.mobile.stems.StemFile +import com.stemroller.mobile.stems.StemIndex +import com.stemroller.mobile.stems.StemIndexFile +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assume.assumeTrue +import org.junit.Test +import java.net.URI + +class StemIndexTest { + private fun entry(source: String, seconds: Double = 200.0) = + StemEntry(key = source.substringBeforeLast('.'), source = source, duration = seconds, stems = listOf(StemFile("vocals", "v.flac", 1))) + + private val entries = listOf( + entry("Artist/Album/01 Song.flac"), + entry("Intro.flac", 60.0), + entry("Other/Album2/Intro.flac", 90.0), + entry("Beyoncé/Lemonade/Hold Up.flac"), // decomposed é, as some filesystems store it + ) + + @Test fun matchesThroughUnknownContainerRoot() { + val idx = StemIndex(entries) + val hit = idx.find("/music/Actual music/Flacs/Artist/Album/01 Song.flac", 200_000) + assertEquals("Artist/Album/01 Song", hit?.key) + assertEquals(setOf("/music/actual music/flacs/"), idx.roots) + } + + @Test fun rootLevelFileNeedsALearnedRoot() { + val idx = StemIndex(entries) + assertNull(idx.find("/music/Flacs/Intro.flac", 60_000)) + idx.find("/music/Flacs/Artist/Album/01 Song.flac", 200_000) + assertEquals("Intro", idx.find("/music/Flacs/Intro.flac", 60_000)?.key) + } + + @Test fun sameNameInAnotherFolderDoesNotCollide() { + val idx = StemIndex(entries, listOf("/music/flacs/")) + assertEquals("Other/Album2/Intro", idx.find("/music/Flacs/Other/Album2/Intro.flac", 90_000)?.key) + assertNull(idx.find("/music/Flacs/Elsewhere/Intro.flac", 90_000)) + } + + @Test fun otherFormatOfSameTrackMatches() { + val idx = StemIndex(entries) + assertEquals("Artist/Album/01 Song", idx.find("/data/Artist/Album/01 Song.mp3", 200_500)?.key) + } + + @Test fun durationMismatchRejectsAGuess() { + val idx = StemIndex(entries) + assertNull(idx.find("/data/Artist/Album/01 Song.flac", 120_000)) + } + + @Test fun unicodeNormalisationAndCase() { + val idx = StemIndex(entries) + assertEquals("Beyoncé/Lemonade/Hold Up", idx.find("/MUSIC/Beyoncé/Lemonade/hold up.flac", 200_000)?.key) + } + + /** Every entry the real stemserve reports must map back from a Plex-style path. */ + @Test fun realIndexRoundTrips() { + val body = runCatching { URI("http://localhost:8765/api/index").toURL().readText() }.getOrNull() + assumeTrue("stemserve not running locally", body != null) + val index = AppJson.decodeFromString(StemIndexFile.serializer(), body!!) + val idx = StemIndex(index.tracks) + val deep = index.tracks.filter { it.source.count { c -> c == '/' } >= 1 } + for (e in deep + index.tracks) { + val ms = ((e.duration ?: 0.0) * 1000).toLong() + assertEquals(e.source, e.key, idx.find("/data/music/Actual music/Flacs/${e.source}", ms)?.key) + } + } +} diff --git a/android/build.gradle.kts b/android/build.gradle.kts new file mode 100644 index 0000000..132ad8d --- /dev/null +++ b/android/build.gradle.kts @@ -0,0 +1,6 @@ +plugins { + alias(libs.plugins.android.application) apply false + alias(libs.plugins.kotlin.android) apply false + alias(libs.plugins.kotlin.compose) apply false + alias(libs.plugins.kotlin.serialization) apply false +} diff --git a/android/gradle.properties b/android/gradle.properties new file mode 100644 index 0000000..91035ed --- /dev/null +++ b/android/gradle.properties @@ -0,0 +1,6 @@ +org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8 +org.gradle.caching=true +org.gradle.configuration-cache=true +android.useAndroidX=true +android.nonTransitiveRClass=true +kotlin.code.style=official diff --git a/android/gradle/libs.versions.toml b/android/gradle/libs.versions.toml new file mode 100644 index 0000000..28d839c --- /dev/null +++ b/android/gradle/libs.versions.toml @@ -0,0 +1,42 @@ +[versions] +agp = "8.13.2" +kotlin = "2.2.21" +composeBom = "2025.10.01" +activity = "1.11.0" +coreKtx = "1.17.0" +lifecycle = "2.9.4" +media3 = "1.8.0" +okhttp = "4.12.0" +coil = "3.3.0" +serialization = "1.9.0" +coroutines = "1.10.2" +palette = "1.0.0" + +[libraries] +androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" } +androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity" } +androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" } +androidx-lifecycle-process = { group = "androidx.lifecycle", name = "lifecycle-process", version.ref = "lifecycle" } +androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" } +androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" } +androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" } +androidx-compose-foundation = { group = "androidx.compose.foundation", name = "foundation" } +androidx-compose-animation = { group = "androidx.compose.animation", name = "animation" } +androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" } +androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" } +androidx-media3-session = { group = "androidx.media3", name = "media3-session", version.ref = "media3" } +androidx-media3-common = { group = "androidx.media3", name = "media3-common", version.ref = "media3" } +androidx-palette = { group = "androidx.palette", name = "palette-ktx", version.ref = "palette" } +okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" } +coil-compose = { group = "io.coil-kt.coil3", name = "coil-compose", version.ref = "coil" } +coil-network-okhttp = { group = "io.coil-kt.coil3", name = "coil-network-okhttp", version.ref = "coil" } +kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" } +kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" } +kotlinx-coroutines-guava = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-guava", version.ref = "coroutines" } +junit = { group = "junit", name = "junit", version = "4.13.2" } + +[plugins] +android-application = { id = "com.android.application", version.ref = "agp" } +kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } +kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" } +kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } diff --git a/android/gradle/wrapper/gradle-wrapper.jar b/android/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..8bdaf60c75ab801e22807dde59e12a8735a34077 GIT binary patch literal 45457 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 c82=K%QXLKFx%@O{wJjEi6Y56o#$)Bpeg literal 0 HcmV?d00001 diff --git a/android/gradle/wrapper/gradle-wrapper.properties b/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..2a84e18 --- /dev/null +++ b/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/android/gradlew b/android/gradlew new file mode 100755 index 0000000..ef07e01 --- /dev/null +++ b/android/gradlew @@ -0,0 +1,251 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH="\\\"\\\"" + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/android/licenses/Inter-OFL.txt b/android/licenses/Inter-OFL.txt new file mode 100644 index 0000000..9b2ca37 --- /dev/null +++ b/android/licenses/Inter-OFL.txt @@ -0,0 +1,92 @@ +Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION AND CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/android/settings.gradle.kts b/android/settings.gradle.kts new file mode 100644 index 0000000..7a1fd1f --- /dev/null +++ b/android/settings.gradle.kts @@ -0,0 +1,23 @@ +pluginManagement { + repositories { + google { + content { + includeGroupByRegex("com\\.android.*") + includeGroupByRegex("com\\.google.*") + includeGroupByRegex("androidx.*") + } + } + mavenCentral() + gradlePluginPortal() + } +} +dependencyResolutionManagement { + repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) + repositories { + google() + mavenCentral() + } +} + +rootProject.name = "StemRoller" +include(":app") diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..fc5bdd1 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,47 @@ +[project] +name = "stemroller" +version = "0.1.0" +description = "Drag-drop stem separation (Demucs + RoFormer) with a 240Hz Material x Aero UI" +requires-python = ">=3.12,<3.13" +dependencies = [ + "PySide6>=6.10", + "numpy>=2.0", + "soundfile>=0.13", + "sounddevice>=0.5", + "torch==2.14.1", + "triton-rocm", + "torchvision", + "demucs @ git+https://github.com/adefossez/demucs", + "audio-separator[cpu]>=0.30", + "audioread", +] + +[project.scripts] +stemroller = "stemroller.app:main" +stemroller-worker-cli = "stemroller.worker.cli:main" +stemroller-player = "stemroller.player.app:main" + +[tool.uv] +environments = ["sys_platform == 'linux' and platform_machine == 'x86_64'"] +# torchaudio has no build matching torch 2.14; nothing here needs it. +override-dependencies = ["torchaudio ; sys_platform == 'never'"] + +[tool.uv.sources] +torch = { index = "pytorch-rocm" } +triton-rocm = { index = "pytorch-rocm" } +torchvision = { index = "pytorch-rocm" } + +[[tool.uv.index]] +name = "pytorch-rocm" +url = "https://download.pytorch.org/whl/rocm7.2" +explicit = true + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.metadata] +allow-direct-references = true + +[tool.hatch.build.targets.wheel] +packages = ["stemroller"] diff --git a/scripts/install-desktop.sh b/scripts/install-desktop.sh new file mode 100755 index 0000000..32d76b5 --- /dev/null +++ b/scripts/install-desktop.sh @@ -0,0 +1,77 @@ +#!/usr/bin/env bash +# Add StemRoller and StemRoller Player to the app grid (and "Open with" for audio files). +# Re-run after moving the project; `--uninstall` removes all of it. +set -euo pipefail + +ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +APPS="${XDG_DATA_HOME:-$HOME/.local/share}/applications" +ICONS="${XDG_DATA_HOME:-$HOME/.local/share}/icons/hicolor/scalable/apps" +DESKTOP="$APPS/stemroller.desktop" +ICON="$ICONS/stemroller.svg" +PLAYER_DESKTOP="$APPS/stemroller-player.desktop" +PLAYER_ICON="$ICONS/stemroller-player.svg" +# stem-on / stem-off from older installs; library separation now runs on the server (server/stemd.py). +OLD_BIN="$HOME/.local/bin" + +if [[ "${1:-}" == "--uninstall" ]]; then + rm -f "$DESKTOP" "$ICON" "$PLAYER_DESKTOP" "$PLAYER_ICON" "$OLD_BIN/stem-on" "$OLD_BIN/stem-off" + echo "removed $DESKTOP, $PLAYER_DESKTOP and their icons" + exit 0 +fi + +for bin in stemroller stemroller-player; do + if [[ ! -x "$ROOT/.venv/bin/$bin" ]]; then + echo "missing $ROOT/.venv/bin/$bin; run 'uv sync' in $ROOT first" >&2 + exit 1 + fi +done + +mkdir -p "$APPS" "$ICONS" +install -m 644 "$ROOT/stemroller/assets/stemroller.svg" "$ICON" +install -m 644 "$ROOT/stemroller/player/assets/stemroller-player.svg" "$PLAYER_ICON" + +# StartupWMClass / file name match QGuiApplication.setDesktopFileName("stemroller"), +# so Wayland groups the window under this entry and shows its icon. +cat > "$DESKTOP" < "$PLAYER_DESKTOP" </dev/null && update-desktop-database -q "$APPS" || true +command -v gtk-update-icon-cache >/dev/null && gtk-update-icon-cache -q -t "${ICONS%/scalable/apps}" || true +command -v desktop-file-validate >/dev/null && desktop-file-validate "$DESKTOP" "$PLAYER_DESKTOP" || true +rm -f "$OLD_BIN/stem-on" "$OLD_BIN/stem-off" + +echo "installed $DESKTOP and $PLAYER_DESKTOP" diff --git a/server/Dockerfile b/server/Dockerfile new file mode 100644 index 0000000..7ecf439 --- /dev/null +++ b/server/Dockerfile @@ -0,0 +1,8 @@ +FROM python:3.12-alpine +RUN apk add --no-cache ffmpeg +COPY stemserve.py /app/stemserve.py +ENV STEMS_DIR=/stems CACHE_DIR=/cache PORT=8765 PYTHONUNBUFFERED=1 +EXPOSE 8765 +# Unraid shares belong to nobody:users. +USER 99:100 +CMD ["python", "/app/stemserve.py"] diff --git a/server/README.md b/server/README.md new file mode 100644 index 0000000..d7bac41 --- /dev/null +++ b/server/README.md @@ -0,0 +1,126 @@ +# stemserve + +Serves the StemRoller stems folder to the Android app: an index of every separated +song, the stem files with HTTP range support (so the phone can seek and stream), per-stem +waveforms, and optional Opus transcodes so cached songs take ~1/8 the space. + +One Python file, standard library only. `ffmpeg` is optional; without it you get FLAC +only and no waveforms. + +## Run it on unraid + +The stems live at `/mnt/user/Music/Stems` on the server (`//192.168.86.2/Music/Stems` +from the desktop). From an unraid terminal: + +```sh +mkdir -p /mnt/user/appdata/stemserve/cache /mnt/user/appdata/stemd/state/queue +chown -R 99:100 /mnt/user/appdata/stemserve /mnt/user/appdata/stemd +cp -r /path/to/stemRoller2/server /mnt/user/appdata/stemserve/src # or copy over SMB +docker build -t stemserve /mnt/user/appdata/stemserve/src +docker run -d --name stemserve --restart unless-stopped -p 8765:8765 \ + -v /mnt/user/Music/Stems:/stems:ro \ + -v /mnt/user/appdata/stemserve/cache:/cache \ + -v /mnt/user/appdata/stemd/state/queue:/queue \ + stemserve +``` + +or `docker compose up -d --build` in this folder (Compose Manager plugin). + +Check it from any machine on the LAN: + +```sh +curl http://192.168.86.2:8765/api/info +``` + +## Settings (environment) + +| Variable | Default | Meaning | +|-------------|----------|------------------------------------------------------------| +| `STEMS_DIR` | `/stems` | The StemRoller library output folder | +| `CACHE_DIR` | `/cache` | Opus transcodes and waveforms (safe to delete) | +| `PORT` | `8765` | Listen port | +| `TOKEN` | empty | If set, requests need `X-Stem-Token` or `?token=` | +| `INDEX_TTL` | `30` | Seconds between rescans of the stems folder | +| `QUEUE_DIR` | `/queue` | stemd's Stem Now folder (`stemd/state/queue` on unraid) | + +## API + +| Request | Returns | +|---------------------------------------------------|-------------------------------------------------| +| `GET /api/info` | track count, whether ffmpeg is available | +| `GET /api/index` | every finished song (ETag; 304 when unchanged) | +| `GET /api/peaks?key=K&n=256` | RMS per stem in `n` buckets, 0..1000 | +| `POST /api/prepare?key=K&fmt=opus&br=256` | starts the Opus transcodes in the background | +| `POST /api/stem` `{"paths": [plex file paths]}` | Stem Now: stemd separates these next | +| `GET /file/K/.flac[?fmt=opus&br=256]` | the stem, with `Range` support | + +`K` is the song's folder under the stems root, e.g. `1970 - Paranoid/1-02 - Paranoid`. +The app matches Plex tracks to it by path: the stems folder mirrors the music folder. + +## Run it anywhere else + +```sh +STEMS_DIR=/var/mnt/unraid/Music/Stems CACHE_DIR=~/.cache/stemserve python3 stemserve.py +``` + +# stemd: separate new music on the server's GPU + +`stemd.py` keeps the stems library up to date. It walks the music folder, separates every +track whose stems folder has no `.stemroller.json` yet (BS-RoFormer SW 6-stem by default, +like the desktop app), and writes them in the layout above, so stemserve and the phone pick +them up within `INDEX_TTL`. Once it has caught up it checks for new music every 30 minutes. +Nothing runs on the desktop. + +It writes the same layout the desktop app's old library mode did (`stemroller/library_core.py`), +so the ~300 tracks already done on the desktop are skipped, and a track interrupted +mid-way (`docker stop`, a reboot) is redone from scratch next time. + +## Run it on unraid (NVIDIA) + +Needs the **Nvidia-Driver** plugin (Apps tab). The image builds from the repo root +because it uses the `stemroller` package. Copy the repo, or at least `stemroller/`, +`server/` and `.dockerignore`, to `/mnt/user/appdata/stemd/src`, then from an unraid terminal: + +```sh +mkdir -p /mnt/user/appdata/stemd/models /mnt/user/appdata/stemd/state +chown -R 99:100 /mnt/user/appdata/stemd +docker build -f /mnt/user/appdata/stemd/src/server/stemd.Dockerfile -t stemd /mnt/user/appdata/stemd/src +docker run -d --name stemd --restart unless-stopped --stop-timeout 60 \ + --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=all -e NVIDIA_DRIVER_CAPABILITIES=compute,utility \ + -v "/mnt/user/Music/Actual music/Flacs":/music:ro \ + -v /mnt/user/Music/Stems:/stems \ + -v /mnt/user/appdata/stemd/models:/models \ + -v /mnt/user/appdata/stemd/state:/state \ + stemd +docker logs -f stemd +``` + +The first track downloads the model (~700 MB) into `models/`. Each scan logs how many +tracks are left, and each track logs its name, how long it took and how many times +realtime that was. + +Separation runs one track at a time at low CPU priority, and the model is unloaded between +passes so the VRAM is free while idle. It can share the card with Plex transcoding; if +VRAM runs out mid-track, that track is retried on the next pass rather than marked failed. +Tracks that fail (corrupt files, over 40 minutes) are listed in `state/failed.json` and +retried when the file changes; delete that file to retry them all. + +**Stem Now** (hold a song, album, artist or playlist in the app) jumps the queue: stemserve +writes the request into `state/queue/`, and stemd separates those tracks next, after the +one it's on (or within 5 seconds if it's idle). Requests run oldest first, and survive a +restart. stemd matches the Plex paths to files under `/music` by their artist/album/file +tail, so the two containers don't need the same mount points. Tracks in `failed.json` are +skipped here too. + +To update after changing the code: copy the files over again, rebuild, then +`docker rm -f stemd` and repeat the `docker run`. + +| Variable | Default | Meaning | +|--------------|------------------|------------------------------------------------------| +| `MODEL` | `roformer_bs_sw` | any id from `stemroller/catalog.py` | +| `DEVICE` | `cuda` | `cuda`, `cuda:N` or `cpu` | +| `RESCAN_MIN` | `30` | minutes between scans once caught up | +| `FP16` | `1` | half precision on the GPU (`0` for fp32) | +| `OVERLAP`, `SEGMENT`, `SHIFTS` | `0.25`, `0`, `0` | as in the desktop app's settings | + +`docker build --build-arg TORCH_INDEX=cpu ...` makes a small image without CUDA for testing. diff --git a/server/docker-compose.yml b/server/docker-compose.yml new file mode 100644 index 0000000..ab8bed2 --- /dev/null +++ b/server/docker-compose.yml @@ -0,0 +1,16 @@ +services: + stemserve: + build: . + image: stemserve:latest + container_name: stemserve + restart: unless-stopped + ports: + - "8765:8765" + volumes: + - /mnt/user/Music/Stems:/stems:ro + - /mnt/user/appdata/stemserve/cache:/cache + # stemd's Stem Now folder (create it owned by 99:100 first; see README). + - /mnt/user/appdata/stemd/state/queue:/queue + environment: + # Optional shared secret; set the same token in the app (Settings > Stem Server). + - TOKEN= diff --git a/server/stemd-requirements.txt b/server/stemd-requirements.txt new file mode 100644 index 0000000..8ba6935 --- /dev/null +++ b/server/stemd-requirements.txt @@ -0,0 +1,73 @@ +# stemd's Python deps, pinned to match uv.lock (torch and torchvision come from the CUDA index; see stemd.Dockerfile). +# Regenerate: uv export --frozen --no-hashes --no-emit-project --no-header --no-annotate \ +# | grep -vE '^(torch|torchvision|triton-rocm|pyside6|pyside6-addons|pyside6-essentials|shiboken6|sounddevice)[=@ ]' | sed 's/ ;.*//' \ +# | sed 's#^demucs @ git+\(.*\)@\(.*\)#demucs @ \1/archive/\2.tar.gz#' (no git in the image) +absl-py==2.5.0 +anyio==4.15.1 +audio-separator==0.47.0 +audioread==3.1.0 +beartype==0.18.5 +certifi==2026.7.22 +cffi==2.1.1 +charset-normalizer==3.5.2 +click==8.5.0 +cloudpickle==3.1.2 +cython==3.3.0 +decorator==5.3.1 +demucs @ https://github.com/adefossez/demucs/archive/2883f3db65617d6d178c6ed10d869dc14e44e59b.tar.gz +diffq==0.2.4 +einops==0.8.2 +filelock==4.0.12 +flatbuffers==25.12.19 +fsspec==2026.9.0 +h11==0.16.0 +hf-xet==1.7.0 +httpcore2==2.13.1 +httpx2==2.13.1 +huggingface-hub==2.1.1 +idna==3.20 +jinja2==3.1.6 +joblib==1.6.0 +julius==0.2.8 +lameenc==1.8.4 +lazy-loader==0.6 +librosa==1.0.0 +llvmlite==0.50.0 +markupsafe==3.0.4 +ml-collections==1.1.0 +ml-dtypes==0.6.0 +mpmath==1.3.0 +msgpack==1.2.3 +narwhals==2.26.0 +networkx==3.7 +numba==0.68.0 +numpy==2.5.3 +onnx-weekly==1.24.0.dev20261005 +onnx2torch-py313==1.6.0 +onnxruntime==1.30.0 +packaging==26.3 +pillow==12.3.0 +platformdirs==4.12.4 +pooch==1.9.0 +protobuf==7.36.2 +pycparser==3.0 +pydub==0.25.1 +pyyaml==6.0.3 +requests==2.34.2 +resampy==0.4.3 +rotary-embedding-torch==0.6.5 +safetensors==0.8.0 +samplerate==0.1.0 +scikit-learn==1.9.1 +scipy==1.18.1 +setuptools==84.0.0 +six==1.17.0 +soundfile==0.14.0 +soxr==1.1.0 +sphn==0.2.1 +sympy==1.14.0 +threadpoolctl==3.7.0 +tqdm==4.70.1 +truststore==0.10.4 +typing-extensions==4.16.0 +urllib3==2.8.0 diff --git a/server/stemd.Dockerfile b/server/stemd.Dockerfile new file mode 100644 index 0000000..29592c3 --- /dev/null +++ b/server/stemd.Dockerfile @@ -0,0 +1,24 @@ +# stemd: separates new music into stems on the server's NVIDIA GPU (see stemd.py). +# Build from the repo root, since it needs the stemroller package: +# docker build -f server/stemd.Dockerfile -t stemd . +FROM python:3.12-slim +RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg && rm -rf /var/lib/apt/lists/* +# cu126 runs on NVIDIA driver 525 and up. TORCH_INDEX=cpu builds a small GPU-less image for testing. +ARG TORCH_INDEX=cu126 +RUN pip install --no-cache-dir torch==2.14.1 torchvision==0.29.1 --index-url https://download.pytorch.org/whl/${TORCH_INDEX} +COPY server/stemd-requirements.txt /tmp/ +# Everything is pinned, so --no-deps keeps pip from swapping torch for a non-CUDA build. +# gcc is only for diffq, which has no wheel. +RUN apt-get update && apt-get install -y --no-install-recommends gcc libc6-dev \ + && pip install --no-cache-dir --no-deps -r /tmp/stemd-requirements.txt && pip check \ + && apt-get purge -y gcc libc6-dev && apt-get autoremove -y && rm -rf /var/lib/apt/lists/* +COPY stemroller/__init__.py stemroller/catalog.py stemroller/library_core.py /app/stemroller/ +COPY stemroller/worker/__init__.py stemroller/worker/__main__.py stemroller/worker/audio_io.py \ + stemroller/worker/backends.py /app/stemroller/worker/ +COPY server/stemd.py /app/server/ +ENV MUSIC_DIR=/music STEMS_DIR=/stems STATE_DIR=/state MODELS_DIR=/models \ + TORCH_HOME=/models/torch HF_HOME=/models/hf NUMBA_CACHE_DIR=/tmp/numba HOME=/tmp \ + PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PYTHONWARNINGS=ignore::FutureWarning +# Unraid shares belong to nobody:users. +USER 99:100 +CMD ["python", "/app/server/stemd.py"] diff --git a/server/stemd.py b/server/stemd.py new file mode 100644 index 0000000..911c203 --- /dev/null +++ b/server/stemd.py @@ -0,0 +1,348 @@ +#!/usr/bin/env python3 +"""stemd: separates every track in the music library that doesn't have stems yet. + +Runs on the server next to stemserve. Walks MUSIC_DIR, and for each track whose folder +under STEMS_DIR has no marker it runs the separation on the GPU and writes the stems with +the same layout and marker as the desktop app (stemroller/library_core.py), so stemserve +and the phone pick them up as they land. Once caught up it looks again every RESCAN_MIN. + +"Stem Now" in the app goes through stemserve, which drops a request (a JSON list of Plex +file paths) into QUEUE_DIR. Those tracks are separated before the rest: between tracks +during a pass, and within a few seconds while idle. + +Settings (environment): + + MUSIC_DIR /music the music library (read-only is fine) + STEMS_DIR /stems where stems go + STATE_DIR /state failed-track list + QUEUE_DIR STATE_DIR/queue "Stem Now" requests from stemserve + MODELS_DIR /models model weights, downloaded on first use + MODEL roformer_bs_sw any id from stemroller/catalog.py + DEVICE cuda cuda, cuda:N or cpu + RESCAN_MIN 30 minutes between scans once caught up + FP16 1 half precision on the GPU + OVERLAP / SEGMENT / SHIFTS as in the desktop app's settings +""" + +import glob +import json +import os +import shutil +import signal +import sys +import tempfile +import threading +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from stemroller.catalog import MODELS_BY_ID # noqa: E402 +from stemroller.library_core import (MAX_SECONDS, SOURCE_RANK, duration, is_done, is_share_error, # noqa: E402 + iter_tracks, signature, write_track) + +MUSIC_DIR = os.environ.get("MUSIC_DIR", "/music") +STEMS_DIR = os.environ.get("STEMS_DIR", "/stems") +STATE_DIR = os.environ.get("STATE_DIR", "/state") +MODELS_DIR = os.environ.get("MODELS_DIR", "/models") +MODEL = os.environ.get("MODEL", "roformer_bs_sw") +DEVICE = os.environ.get("DEVICE", "cuda") +RESCAN_S = float(os.environ.get("RESCAN_MIN", "30")) * 60 +FP16 = os.environ.get("FP16", "1") not in ("0", "false", "no", "") +OVERLAP = float(os.environ.get("OVERLAP", "0.25")) +SEGMENT = float(os.environ.get("SEGMENT", "0")) +SHIFTS = int(os.environ.get("SHIFTS", "0")) +QUEUE_DIR = os.environ.get("QUEUE_DIR", os.path.join(STATE_DIR, "queue")) +FAILED_PATH = os.path.join(STATE_DIR, "failed.json") +QUEUE_POLL_S = 5 # how often an idle stemd looks for Stem Now requests +SHARE_RETRY_S = 5 * 60 # stems folder unwritable: try again this soon rather than at RESCAN_S +MAX_CRASHES = 2 # GPU crashes on one track before it's given up on + +stop = threading.Event() + + +def log(*args): + print(time.strftime("%Y-%m-%d %H:%M:%S"), *args, flush=True) + + +class Failed: + """Tracks that didn't separate, keyed by path, retried once the source file changes.""" + + def __init__(self): + try: + with open(FAILED_PATH) as f: + self.data = json.load(f) + except (OSError, ValueError): + self.data = {} + + def skip(self, path, sig): + e = self.data.get(path) + return bool(e) and e["sig"] == sig and e.get("tries", MAX_CRASHES) >= MAX_CRASHES + + def add(self, path, sig, msg, crash=False): + tries = MAX_CRASHES + if crash: + e = self.data.get(path) + tries = (e.get("tries", 0) if e and e["sig"] == sig else 0) + 1 + self.data[path] = {"sig": sig, "msg": msg, "tries": tries, "at": time.time()} + os.makedirs(STATE_DIR, exist_ok=True) + tmp = FAILED_PATH + ".tmp" + with open(tmp, "w") as f: + json.dump(self.data, f, indent=1) + os.replace(tmp, FAILED_PATH) + + +class _NoProgress: + """Stands in for the worker's socket; per-track progress isn't worth a log line.""" + + def send(self, *_, **__): + pass + + +class Separator: + def __init__(self): + import torch + from stemroller.worker.backends import DemucsBackend, RoformerBackend + + self.torch = torch + self.model = MODELS_BY_ID[MODEL] + self.device = torch.device(DEVICE if DEVICE == "cpu" or torch.cuda.is_available() else "cpu") + if DEVICE != "cpu" and self.device.type == "cpu": + log("WARNING: no CUDA device visible; separating on the CPU (slow). Is the container " + "running with the nvidia runtime?") + self.backend = (DemucsBackend() if self.model["family"] == "demucs" else RoformerBackend(MODELS_DIR)) + name = torch.cuda.get_device_name(self.device) if self.device.type == "cuda" else "CPU" + log(f"model {self.model['label']} on {name}, torch {torch.__version__}") + + def run(self, path, tmp): + # Imported late: worker/__main__ sets ROCm env defaults, harmless here, and owns Job's + # parameter rules (overlap, fp16, ...), which must match the desktop's. + from stemroller.worker.__main__ import Job + job = Job({"id": "stemd", "file": path, "model": MODEL, "out_dir": tmp, "segment": SEGMENT, + "shifts": SHIFTS, "overlap": OVERLAP, "fp16": FP16}, _NoProgress()) + if "file" in self.model and not os.path.exists(os.path.join(MODELS_DIR, self.model["file"])): + log(" downloading the model (first run only)") + job.cancel_event = stop + stems, sr = self.backend.run(job, self.device) + # Backends return (channels, samples); the writer wants (samples, channels). + return {name: audio.T for name, audio in stems.items()}, sr + + def release(self): + self.backend.release() + + def is_fatal(self, e): + """CUDA errors other than OOM poison the context; only a fresh process recovers.""" + if isinstance(e, self.torch.OutOfMemoryError): + return False + return isinstance(e, getattr(self.torch, "AcceleratorError", ())) or "CUDA error" in str(e) + + +def separate(sep, failed, path, dest, sig, label): + """Separate one track into dest. Returns True if it was written. + + Raises on a stop request, an unwritable stems share, or a GPU error that needs a restart. + """ + rel = os.path.relpath(path, MUSIC_DIR) + dur = duration(path) + if dur is not None and dur > MAX_SECONDS: + log(f"{label} skip {rel}: {dur / 60:.0f} min long") + failed.add(path, sig, f"longer than {MAX_SECONDS // 60} minutes") + return False + log(f"{label} {rel}" + (f" ({int(dur) // 60}:{int(dur) % 60:02d})" if dur else "")) + t1 = time.monotonic() + tmp = tempfile.mkdtemp(prefix="stemd-") + try: + stems, sr = sep.run(path, tmp) + meta = {"source": path, "size": sig[0], "mtime_ns": sig[1], "model": MODEL, "samplerate": sr, + "duration": len(next(iter(stems.values()))) / sr} + write_track(dest, stems, meta) + except BaseException as e: + if stop.is_set(): + raise # Cancelled; the track is redone next start + if is_share_error(e): + log(f" can't write to {STEMS_DIR}: {e}; pausing") + raise + if not isinstance(e, Exception): + raise + msg = str(e).strip().splitlines()[0] if str(e).strip() else e.__class__.__name__ + if isinstance(e, sep.torch.OutOfMemoryError): + # Something else (Plex, a game server) may be holding VRAM; try again next pass. + log(" out of GPU memory; will retry next pass") + sep.release() + return False + if sep.is_fatal(e): + failed.add(path, sig, msg, crash=True) + log(f" GPU error: {msg}; restarting") + sys.exit(75) + failed.add(path, sig, msg) + log(f" failed: {msg}") + return False + finally: + shutil.rmtree(tmp, ignore_errors=True) + took = time.monotonic() - t1 + log(f" done in {took:.0f}s" + (f" ({meta['duration'] / took:.1f}x realtime)" if took else "")) + return True + + +def resolve(plex_path): + """The music file a Plex path names, or None. Plex sees the library under its own mount + point, so this takes the longest tail of the path (folder and file at least) that exists + under MUSIC_DIR, and prefers the best format when a folder holds the song in several.""" + parts = [p for p in plex_path.replace("\\", "/").split("/") if p not in ("", ".", "..")] + root = os.path.realpath(MUSIC_DIR) + for i in range(len(parts) - 1): + path = os.path.join(root, *parts[i:]) + if os.path.isfile(path) and os.path.realpath(path).startswith(root + os.sep): + break + else: + return None + folder, name = os.path.split(path) + base = os.path.splitext(name)[0].casefold() + try: + same = [f for f in os.listdir(folder) if os.path.splitext(f)[0].casefold() == base + and os.path.splitext(f)[1].lower() in SOURCE_RANK] + except OSError: + same = [] + if same: + path = os.path.join(folder, min(same, key=lambda f: (SOURCE_RANK[os.path.splitext(f)[1].lower()], f != name))) + return path if os.path.splitext(path)[1].lower() in SOURCE_RANK else None + + +def serve_queue(sep, failed): + """Separate every Stem Now request, oldest first. Returns whether any track was attempted. + + A request file is deleted once all its tracks are done, so one cut short by a restart + picks up where it left off (finished tracks are skipped).""" + used = False + while not stop.is_set(): + reqs = sorted(glob.glob(os.path.join(QUEUE_DIR, "*.json"))) + if not reqs: + break + req = reqs[0] + try: + with open(req) as f: + paths = json.load(f).get("paths", []) + except (OSError, ValueError, AttributeError) as e: + log(f"stem now: unreadable request {os.path.basename(req)}: {e}") + paths = [] + todo = [] + for p in paths if isinstance(paths, list) else []: + src = resolve(p) if isinstance(p, str) else None + if src is None: + log(f"stem now: not in {MUSIC_DIR}: {p}") + continue + dest = os.path.join(STEMS_DIR, os.path.splitext(os.path.relpath(src, MUSIC_DIR))[0]) + if is_done(dest): + continue + try: + sig = signature(src) + except OSError: + continue + if failed.skip(src, sig): + log(f"stem now: skip {os.path.relpath(src, MUSIC_DIR)}: failed before ({failed.data[src]['msg']})") + continue + todo.append((src, dest, sig)) + if todo: + log(f"stem now: {len(todo)} track{'' if len(todo) == 1 else 's'} ahead of the rest") + for i, (src, dest, sig) in enumerate(todo, 1): + if stop.is_set(): + return used + if is_done(dest): + continue + used = True + separate(sep, failed, src, dest, sig, f"[now {i}/{len(todo)}]") + if stop.is_set(): + break + try: + os.remove(req) + except FileNotFoundError: + pass + return used + + +def run_pass(sep, failed): + """Separate everything that needs it. Returns (tracks done, whether the GPU was used).""" + t0 = time.monotonic() + todo, total = [], 0 + for path, dest in iter_tracks(MUSIC_DIR, STEMS_DIR): + if stop.is_set(): + return 0, False + total += 1 + if is_done(dest): + continue + try: + sig = signature(path) + except OSError: + continue + if not failed.skip(path, sig): + todo.append((path, dest, sig)) + log(f"scan: {total:,} tracks, {total - len(todo):,} done or skipped, {len(todo):,} to do " + f"({time.monotonic() - t0:.0f}s)") + if not total: + log(f"WARNING: no music found in {MUSIC_DIR}; is the share mounted and readable?") + + done, used = 0, False + for i, (path, dest, sig) in enumerate(todo, 1): + used = serve_queue(sep, failed) or used + if stop.is_set(): + break + if is_done(dest): # a full pass takes days; the desktop or a Stem Now may have got there first + continue + used = True + if separate(sep, failed, path, dest, sig, f"[{i}/{len(todo)}]"): + done += 1 + return done, used + + +def idle(sep, failed, seconds): + """Wait for the next scan, separating Stem Now requests as they arrive.""" + end = time.monotonic() + seconds + while not stop.is_set() and time.monotonic() < end: + if serve_queue(sep, failed): + sep.release() + stop.wait(min(QUEUE_POLL_S, max(0.0, end - time.monotonic()))) + + +def main(): + for name, path in (("MUSIC_DIR", MUSIC_DIR), ("STEMS_DIR", STEMS_DIR)): + if not os.path.isdir(path): + sys.exit(f"{name} not found: {path}") + if MODEL not in MODELS_BY_ID: + sys.exit(f"unknown MODEL {MODEL!r}; pick one of: {', '.join(MODELS_BY_ID)}") + # docker stop sends SIGTERM; stop between (or inside) tracks instead of dying mid-write. + signal.signal(signal.SIGTERM, lambda *_: stop.set()) + signal.signal(signal.SIGINT, lambda *_: stop.set()) + try: + os.nice(10) + except OSError: + pass + try: + os.makedirs(QUEUE_DIR, exist_ok=True) + except OSError as e: + log(f"WARNING: can't create {QUEUE_DIR} ({e}); Stem Now won't work") + log(f"stemd: {MUSIC_DIR} -> {STEMS_DIR}") + sep = Separator() + failed = Failed() + while not stop.is_set(): + try: + done, used = run_pass(sep, failed) + if done: + log(f"pass finished: {done:,} tracks separated") + if used: + sep.release() # hand the VRAM back while idle + idle(sep, failed, RESCAN_S) + except OSError as e: + if stop.is_set(): + break + if not is_share_error(e): + raise + sep.release() + stop.wait(SHARE_RETRY_S) + except BaseException: + if stop.is_set(): + break + raise + log("stopped") + + +if __name__ == "__main__": + main() diff --git a/server/stemserve.py b/server/stemserve.py new file mode 100644 index 0000000..dbe7703 --- /dev/null +++ b/server/stemserve.py @@ -0,0 +1,454 @@ +#!/usr/bin/env python3 +"""stemserve: serves StemRoller library stems to the Android app over HTTP. + +Stdlib only; ffmpeg is optional and enables Opus transcodes and waveforms. + +The stems folder is what stemroller.library writes: + + /Artist/Album/01 Song/.stemroller.json + /Artist/Album/01 Song/01 Song - vocals.flac, ... + +Endpoints (all GET unless noted; add ?token=... or X-Stem-Token when TOKEN is set): + + /api/info server facts + /api/index every finished track (ETag / If-None-Match) + /api/peaks?key=&n= per-stem RMS envelopes, 0..1000 + POST /api/prepare?key=&fmt=opus&br=160 start transcodes in the background + POST /api/stem {"paths": [...]} "Stem Now": stemd separates these Plex files next + /file//[?fmt=opus&br=160] the stem itself, with Range support + + is the track's folder relative to STEMS_DIR, e.g. "Artist/Album/01 Song". +""" + +import email.utils +import hashlib +import json +import operator +import os +import shutil +import signal +import subprocess +import sys +import threading +import time +import urllib.parse +from array import array +from concurrent.futures import ThreadPoolExecutor +from http import HTTPStatus +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +STEMS_DIR = os.path.realpath(os.environ.get("STEMS_DIR", "/stems")) +CACHE_DIR = os.environ.get("CACHE_DIR", "/cache") +PORT = int(os.environ.get("PORT", "8765")) +TOKEN = os.environ.get("TOKEN", "") +INDEX_TTL = float(os.environ.get("INDEX_TTL", "30")) +QUEUE_DIR = os.environ.get("QUEUE_DIR", "/queue") # stemd's request folder, shared with it +MAX_BODY = 8 << 20 +MARKER = ".stemroller.json" +VERSION = 1 +FFMPEG = shutil.which("ffmpeg") +OPUS_RATES = (64, 96, 128, 160, 192, 256) +PEAK_RATE = 2000 # Hz the envelope is computed at; plenty for a few hundred bars +CHUNK = 1 << 20 + +_pool = ThreadPoolExecutor(max_workers=max(2, (os.cpu_count() or 2) // 2)) +_locks: dict[str, threading.Lock] = {} +_locks_guard = threading.Lock() + + +def log(*args): + print(time.strftime("%H:%M:%S"), *args, file=sys.stderr, flush=True) + + +def _lock_for(path): + with _locks_guard: + return _locks.setdefault(path, threading.Lock()) + + +# ---- index ------------------------------------------------------------------ + +class Index: + def __init__(self): + self._lock = threading.Lock() + self._scanning = threading.Lock() + self._at = 0.0 + self._body = b'{"tracks":[]}' + self._etag = '"empty"' + self._count = 0 + self._by_key: dict[str, dict] = {} + + def get(self): + if time.monotonic() - self._at > INDEX_TTL: + self.refresh() + with self._lock: + return self._body, self._etag + + def entry(self, key): + if time.monotonic() - self._at > INDEX_TTL: + self.refresh() + with self._lock: + return self._by_key.get(key) + + @property + def count(self): + return self._count + + def refresh(self): + # One scan at a time; callers that lose the race use the previous result. + if not self._scanning.acquire(blocking=self._at == 0): + return + try: + tracks = [] + for root, dirs, files in os.walk(STEMS_DIR): + dirs[:] = sorted(d for d in dirs if not d.startswith(".")) + if MARKER not in files: + continue + entry = _read_marker(root, set(files)) + if entry: + tracks.append(entry) + tracks.sort(key=lambda t: t["key"].casefold()) + body = json.dumps({"version": VERSION, "tracks": tracks}, separators=(",", ":")).encode() + with self._lock: + self._body = body + self._etag = '"%s"' % hashlib.sha1(body).hexdigest()[:20] + self._count = len(tracks) + self._by_key = {t["key"]: t for t in tracks} + self._at = time.monotonic() + finally: + self._scanning.release() + + +def _read_marker(folder, files): + try: + with open(os.path.join(folder, MARKER), encoding="utf-8") as f: + meta = json.load(f) + except (OSError, ValueError): + return None + key = os.path.relpath(folder, STEMS_DIR).replace(os.sep, "/") + stems = [] + for s in meta.get("stems", []): + name, fname = s.get("name"), s.get("file") + if not name or not fname or fname not in files: + continue + try: + st = os.stat(os.path.join(folder, fname)) + except OSError: + continue + stems.append({"name": name, "file": fname, "size": st.st_size, "mtime": int(st.st_mtime)}) + if not stems: + return None + # The stems folder mirrors the music folder, so the source's path relative to the + # music root is this folder's parent plus the source's file name. + src_name = os.path.basename(meta.get("source") or "") or os.path.basename(folder) + parent = os.path.dirname(key) + return { + "key": key, + "source": f"{parent}/{src_name}" if parent else src_name, + "duration": meta.get("duration"), + "samplerate": meta.get("samplerate"), + "model": meta.get("model"), + "finished": meta.get("finished"), + "stems": stems, + } + + +INDEX = Index() + + +# ---- transcodes and peaks --------------------------------------------------- + +def _resolve(key, fname): + """Absolute path of a stem file, or None if it escapes STEMS_DIR or is missing.""" + path = os.path.realpath(os.path.join(STEMS_DIR, key, fname)) + if not path.startswith(STEMS_DIR + os.sep) or not path.lower().endswith(".flac"): + return None + return path if os.path.isfile(path) else None + + +def _cache_name(src, tag, ext): + st = os.stat(src) + h = hashlib.sha1(f"{src}|{st.st_size}|{st.st_mtime_ns}|{tag}".encode()).hexdigest() + return os.path.join(CACHE_DIR, tag.split(":")[0], h[:2], h + ext) + + +def transcode(src, br): + """Path of an Ogg Opus copy of src at br kbps, transcoding it first if needed.""" + out = _cache_name(src, f"opus:{br}", ".opus") + if os.path.exists(out): + os.utime(out) # for LRU-ish cleanup by mtime + return out + with _lock_for(out): + if os.path.exists(out): + return out + os.makedirs(os.path.dirname(out), exist_ok=True) + tmp = out + ".part" + t0 = time.monotonic() + subprocess.run([FFMPEG, "-nostdin", "-v", "error", "-y", "-i", src, "-map", "0:a:0", + "-c:a", "libopus", "-b:a", f"{br}k", "-vbr", "on", "-application", "audio", + "-map_metadata", "-1", "-f", "ogg", tmp], check=True, timeout=600) + os.replace(tmp, out) + log(f"opus {br}k {os.path.basename(src)} in {time.monotonic() - t0:.1f}s") + return out + + +def _envelope(src, n, duration): + """RMS of src in n equal buckets across `duration` seconds, as 0..1 of full scale.""" + raw = subprocess.run([FFMPEG, "-nostdin", "-v", "error", "-i", src, "-map", "0:a:0", "-ac", "1", + "-ar", str(PEAK_RATE), "-f", "s16le", "-"], + check=True, capture_output=True, timeout=300).stdout + pcm = array("h") + pcm.frombytes(raw[:len(raw) // 2 * 2]) + if sys.byteorder == "big": + pcm.byteswap() + total = max(1, int(round((duration or len(pcm) / PEAK_RATE) * PEAK_RATE))) + out = [] + for i in range(n): + a, b = i * total // n, (i + 1) * total // n + chunk = pcm[a:max(b, a + 1)] + if not chunk: + out.append(0) + continue + ms = sum(map(operator.mul, chunk, chunk)) / len(chunk) + out.append(min(1000, int(round((ms ** 0.5) / 32768 * 1000)))) + return out + + +def peaks(entry, n): + folder = os.path.join(STEMS_DIR, entry["key"]) + first = _resolve(entry["key"], entry["stems"][0]["file"]) + sig = "|".join(f"{s['file']}:{s['size']}:{s['mtime']}" for s in entry["stems"]) + out = _cache_name(first, f"peaks:{n}:{hashlib.sha1(sig.encode()).hexdigest()}", ".json") + if os.path.exists(out): + with open(out, "rb") as f: + return f.read() + with _lock_for(out): + if os.path.exists(out): + with open(out, "rb") as f: + return f.read() + t0 = time.monotonic() + jobs = {s["name"]: _pool.submit(_envelope, os.path.join(folder, s["file"]), n, entry.get("duration")) + for s in entry["stems"]} + body = json.dumps({"key": entry["key"], "n": n, "duration": entry.get("duration"), + "stems": {name: job.result() for name, job in jobs.items()}}, + separators=(",", ":")).encode() + os.makedirs(os.path.dirname(out), exist_ok=True) + with open(out + ".part", "wb") as f: + f.write(body) + os.replace(out + ".part", out) + log(f"peaks {entry['key']} in {time.monotonic() - t0:.1f}s") + return body + + +# ---- HTTP ------------------------------------------------------------------- + +class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + server_version = f"stemserve/{VERSION}" + + def log_message(self, fmt, *args): + if os.environ.get("VERBOSE"): + log(self.address_string(), fmt % args) + + def _authorized(self, query): + if not TOKEN: + return True + return TOKEN in (self.headers.get("X-Stem-Token"), query.get("token", [None])[0]) + + def _send(self, status, body=b"", ctype="application/json", headers=None): + self.send_response(status) + self.send_header("Content-Type", ctype) + self.send_header("Content-Length", str(len(body))) + for k, v in (headers or {}).items(): + self.send_header(k, v) + self.end_headers() + if self.command != "HEAD": + self.wfile.write(body) + + def _error(self, status, msg): + self._send(status, json.dumps({"error": msg}).encode()) + + def do_HEAD(self): + self.do_GET() + + def do_POST(self): + self.do_GET() + + def do_GET(self): + url = urllib.parse.urlsplit(self.path) + query = urllib.parse.parse_qs(url.query) + path = urllib.parse.unquote(url.path) + if not self._authorized(query): + return self._error(HTTPStatus.UNAUTHORIZED, "bad token") + try: + if path == "/api/info": + INDEX.get() + return self._send(200, json.dumps({ + "name": "stemserve", "version": VERSION, "tracks": INDEX.count, + "ffmpeg": bool(FFMPEG), "opus": list(OPUS_RATES) if FFMPEG else [], + "stemNow": os.access(QUEUE_DIR, os.W_OK)}).encode()) + if path == "/api/index": + body, etag = INDEX.get() + if self.headers.get("If-None-Match") == etag: + return self._send(304, headers={"ETag": etag}) + return self._send(200, body, headers={"ETag": etag, "Cache-Control": "no-cache"}) + if path == "/api/peaks": + return self._peaks(query) + if path == "/api/prepare": + return self._prepare(query) + if path == "/api/stem": + return self._stem_now() + if path.startswith("/file/"): + return self._file(path[len("/file/"):], query) + return self._error(404, "not found") + except (BrokenPipeError, ConnectionResetError): + pass + except subprocess.CalledProcessError as e: + self._error(500, f"ffmpeg failed ({e.returncode})") + except Exception as e: # keep serving; report what broke + log("error", self.path, repr(e)) + try: + self._error(500, str(e) or e.__class__.__name__) + except OSError: + pass + + def _entry(self, query): + key = (query.get("key") or [""])[0] + entry = INDEX.entry(key) + if entry is None: + self._error(404, "unknown key") + return entry + + def _peaks(self, query): + if not FFMPEG: + return self._error(501, "ffmpeg not installed") + entry = self._entry(query) + if entry is None: + return + n = max(16, min(4096, int((query.get("n") or ["512"])[0]))) + self._send(200, peaks(entry, n), headers={"Cache-Control": "max-age=86400"}) + + def _prepare(self, query): + entry = self._entry(query) + if entry is None: + return + fmt, br = _format(query) + if fmt == "opus": + for s in entry["stems"]: + src = _resolve(entry["key"], s["file"]) + if src: + _pool.submit(transcode, src, br) + self._send(202, b'{"ok":true}') + + def _stem_now(self): + """Hands a list of Plex file paths to stemd, which separates them before the rest.""" + if self.command != "POST": + return self._error(405, "POST a JSON body: {\"paths\": [...]}") + n = int(self.headers.get("Content-Length") or 0) + if n > MAX_BODY: + self.close_connection = True + return self._error(413, "too many paths") + try: + paths = json.loads(self.rfile.read(n) or b"{}").get("paths") + except (ValueError, AttributeError): + paths = None + if not isinstance(paths, list) or not all(isinstance(p, str) for p in paths): + return self._error(400, "expected {\"paths\": [...]}") + if not os.access(QUEUE_DIR, os.W_OK): + return self._error(503, f"stemd's queue folder isn't mounted at {QUEUE_DIR}") + if paths: + # stemd reads requests in name order; the dot keeps a half-written one out of its glob. + name = f"{time.time_ns()}-{os.getpid()}-{threading.get_ident()}.json" + tmp = os.path.join(QUEUE_DIR, "." + name) + with open(tmp, "w", encoding="utf-8") as f: + json.dump({"paths": paths, "at": time.time()}, f) + os.replace(tmp, os.path.join(QUEUE_DIR, name)) + log(f"stem now: {len(paths)} track{'' if len(paths) == 1 else 's'} queued") + self._send(202, json.dumps({"queued": len(paths)}).encode()) + + def _file(self, rel, query): + key, _, fname = rel.rpartition("/") + src = _resolve(key, fname) + if not src: + return self._error(404, "no such stem") + fmt, br = _format(query) + path, ctype = (transcode(src, br), "audio/ogg") if fmt == "opus" else (src, "audio/flac") + self._serve_file(path, ctype) + + def _serve_file(self, path, ctype): + st = os.stat(path) + size = st.st_size + etag = '"%x-%x"' % (st.st_size, st.st_mtime_ns) + start, end = 0, size - 1 + status = 200 + rng = self.headers.get("Range") + if rng and rng.startswith("bytes=") and "," not in rng and self.headers.get("If-Range", etag) == etag: + a, _, b = rng[6:].strip().partition("-") + try: + if a: + start = int(a) + end = min(int(b), size - 1) if b else size - 1 + else: # suffix range: last N bytes + start = max(0, size - int(b)) + except ValueError: + return self._error(400, "bad range") + if start >= size or start > end: + self.send_response(416) + self.send_header("Content-Range", f"bytes */{size}") + self.send_header("Content-Length", "0") + self.end_headers() + return + status = 206 + length = end - start + 1 + self.send_response(status) + self.send_header("Content-Type", ctype) + self.send_header("Content-Length", str(length)) + self.send_header("Accept-Ranges", "bytes") + self.send_header("ETag", etag) + self.send_header("Last-Modified", email.utils.formatdate(st.st_mtime, usegmt=True)) + self.send_header("Cache-Control", "max-age=31536000, immutable") + if status == 206: + self.send_header("Content-Range", f"bytes {start}-{end}/{size}") + self.end_headers() + if self.command == "HEAD": + return + with open(path, "rb") as f: + f.seek(start) + left = length + while left > 0: + buf = f.read(min(CHUNK, left)) + if not buf: + break + self.wfile.write(buf) + left -= len(buf) + + +def _format(query): + fmt = (query.get("fmt") or ["flac"])[0] + if fmt != "opus" or not FFMPEG: + return "flac", 0 + try: + br = int((query.get("br") or ["160"])[0]) + except ValueError: + br = 160 + return "opus", min(OPUS_RATES, key=lambda r: abs(r - br)) + + +def main(): + if not os.path.isdir(STEMS_DIR): + sys.exit(f"STEMS_DIR not found: {STEMS_DIR}") + os.makedirs(CACHE_DIR, exist_ok=True) + INDEX.refresh() + log(f"stemserve on :{PORT}, {INDEX.count} tracks in {STEMS_DIR}, ffmpeg={'yes' if FFMPEG else 'no'}, " + f"token={'on' if TOKEN else 'off'}") + server = ThreadingHTTPServer(("0.0.0.0", PORT), Handler) + server.daemon_threads = True + # As PID 1 in a container, SIGTERM is ignored unless handled; docker stop would hang. + signal.signal(signal.SIGTERM, lambda *_: sys.exit(0)) + try: + server.serve_forever() + except KeyboardInterrupt: + pass + + +if __name__ == "__main__": + main() diff --git a/specs.txt b/specs.txt new file mode 100644 index 0000000..8259529 --- /dev/null +++ b/specs.txt @@ -0,0 +1,105 @@ +STEM EXTRACTOR FRONTEND DESIGN DOC +2026-10-08 + +== OVERVIEW AND GOALS == +A single-window desktop app that takes dropped audio files and splits them into stems (vocals, drums, bass, other) using Demucs on a local GPU, including AMD via ROCm on Linux. The UI pairs Material's layout and motion rules with Windows 7 Aero's glass and gloss, dark by default, and every animation and meter holds frame rate at 240Hz. + +Goals: +- Drag-drop to finished stems in 2 clicks or fewer. +- Sustained 240fps (4.17 ms frame budget) during idle, scrolling, playback and active separation. +- Linux first (Wayland and X11), AMD and NVIDIA GPUs, CPU fallback. +- Python backend so the separation logic stays hackable. + +Non-goals: +- A DAW. Editing is limited to solo, mute, gain and export. +- YouTube search or download in v1. +- Light theme in v1 (tokens allow it later). + +== VISUAL LANGUAGE == +Material supplies structure (8dp grid, elevation scale, type ramp, motion curves). Aero supplies surface (frosted glass, top gloss highlight, soft glow on hover). Glass is reserved for chrome (title bar, sidebar, dialogs) so content stays crisp. + +Material x Aero mapping: +- Title bar, sidebar: elevation 0 to 1. Glass: blur 16px, tint #10141C at 70%, 1px inner white border at 8%. +- Cards (tracks): elevation 2, radius 8px. Top 40% gloss gradient, white 6% to 0%. +- Buttons: filled and tonal variants, 40px height. Glossy pill, cyan glow on hover. +- Dialogs: elevation 3, scrim 50%. Glass with stronger blur (24px). +- Progress: linear indicator. Win7-style green-to-cyan striped bar, animated. + +Dark tokens: +- bg: #0B0E14 (window background) +- surface-1: #141924 (cards) +- surface-2: #1C2330 (raised cards, menus) +- glass-tint: rgba(16,20,28,0.70) (chrome) +- primary: #3BA8FF (Aero blue, actions) +- accent-glow: #5FE3FF (hover glow, focus ring) +- success: #4CD07D (done state) +- error: #FF5C6C (failures) +- text-hi: #E8EDF5 (body) +- text-lo: #8A94A6 (secondary) + +Stem colors: vocals #FF7AB6, drums #FFB547, bass #7C8CFF, other #4CD07D. + +Type and motion: +- Type: Segoe UI Variable if present, else Inter. Ramp 12 / 14 / 16 / 20 / 28px. +- Motion: Material standard easing cubic-bezier(0.2, 0, 0, 1), durations 100 / 200 / 300 ms. No animation over 300 ms. + +== LAYOUT AND COMPONENTS == +One window, three regions: a glass sidebar (220px) for the queue, a main pane for the selected track, and a bottom transport bar (64px). Minimum window 960x600. + +Components: +- Drop zone: empty-state card filling main pane; dashed glow border on drag-over. +- Queue item: filename, model, status chip, striped progress bar, cancel. +- Model picker: dropdown (htdemucs, htdemucs_ft, htdemucs_6s); toggle for 2-stem vocals mode. +- Device picker: Auto / GPU name / CPU; shows free VRAM. +- Stem lanes: one lane per stem with color strip, waveform, solo, mute, gain slider, export. +- Transport: play/pause, scrub bar, time, master level meter. +- Settings dialog: output folder, format (wav/flac/mp3), segment size, shifts. + +User flow: +1. Drop file(s) onto window. Each becomes a queue item. +2. Separation starts automatically with last-used model and device. +3. On completion, stem lanes appear with waveforms; audio plays in sync. +4. Export all, or per stem, to the output folder. + +== 240HZ PERFORMANCE PLAN == +Budget is 4.17 ms per frame, so the UI thread never touches audio decoding, inference or file IO, and live glass blur is limited to static chrome. + +- Rendering: GPU-accelerated scene graph with vsync on; no fixed 60Hz timers. Animations driven by frame callbacks with delta-time, never step-per-tick. +- Blur cost: chrome glass blurs a cached snapshot of the window background, refreshed only on resize. Content never sits under live blur. +- Waveforms: precomputed min/max peaks (e.g. 512 samples per bucket) in the backend, uploaded once as a texture or vertex buffer. Zoom picks a mip level; no per-frame recompute. +- Meters and playhead: read from a shared ring buffer, interpolated per frame. +- Progress updates: backend sends at most 30 updates/s; UI interpolates between them. +- Isolation: Demucs runs in a separate process so GIL and GPU stalls cannot block the UI. +- Verification: frame-time overlay (dev flag) showing p50/p99 frame time; target p99 under 4.17 ms on a 240Hz panel during active separation. + +Note: Wayland compositors set the refresh rate; on X11 mixed-refresh multi-monitor setups the app may fall back to the lowest rate. + +== TECH STACK AND BACKEND INTEGRATION == +Recommended: PySide6 with Qt Quick (QML) for the UI, plus a separate Python worker process for Demucs. QML's scene graph renders on the GPU at display refresh, supports MultiEffect blur and shaders, and keeps everything in Python. + +Alternatives considered: +- PySide6 + QML (pick): strong 240Hz fit; native GPU scene graph, Python end to end. +- Tauri + web UI: good fit; needs Rust shell plus Python sidecar; WebKitGTK on Linux can be choppy. +- Dear PyGui: strong fit; fast, but Aero glass and Material polish are hard. + +Backend contract: +- Worker: demucs.api (or audio-separator) in its own process using ROCm or CUDA PyTorch; torch.cuda covers both. +- IPC: JSON messages over a local socket: + start {file, model, device, two_stems} + progress {id, pct} + done {id, stems[], peaks_path} + error {id, msg} + cancel {id} +- Audio playback: decoded stems streamed via sounddevice in a third thread with its own buffer. +- One job on GPU at a time; queue the rest. + +== MILESTONES == +1. Worker process: Demucs on ROCm, IPC protocol, CLI test harness. +2. Shell: window, glass chrome, tokens, drop zone, queue with progress. +3. Results: peak generation, stem lanes, synced playback, export. +4. Polish: frame-time overlay, hit 240fps p99 target, settings dialog. + +== OPEN QUESTIONS == +- Frameless custom title bar, or keep the system one? +- Include UVR models (MDX, RoFormer) alongside Demucs? +- Package as AppImage, Flatpak, or pip only? diff --git a/stemroller/__init__.py b/stemroller/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/stemroller/__main__.py b/stemroller/__main__.py new file mode 100644 index 0000000..ac99fd1 --- /dev/null +++ b/stemroller/__main__.py @@ -0,0 +1,5 @@ +import sys + +from .app import main + +sys.exit(main()) diff --git a/stemroller/app.py b/stemroller/app.py new file mode 100644 index 0000000..db944e5 --- /dev/null +++ b/stemroller/app.py @@ -0,0 +1,268 @@ +"""Entry point: Qt Quick window, providers, controller, dev frame-time instrumentation.""" + +import argparse +import json +import os +import signal +import sys +import time +from collections import deque + +HERE = os.path.dirname(os.path.abspath(__file__)) + + +def _env_defaults(): + # Basic style so every control can take the Material x Aero skin. + os.environ.setdefault("QT_QUICK_CONTROLS_STYLE", "Basic") + # Native Wayland on GNOME; X11 still works if forced. + os.environ.setdefault("QT_QPA_PLATFORM", "wayland;xcb") + # Threaded render loop: rendering paces itself to vsync off the GUI thread. + os.environ.setdefault("QSG_RENDER_LOOP", "threaded") + + +class FrameStats: + """Frame stats for the dev overlay and --bench. + + - frame time: sync + render work per frame, timed on the render thread. + Hooks are only connected while the overlay is visible (a GIL hop per frame). + - cadence: intervals from a QML FrameAnimation (one tick per presented + frame), pushed in batches; a gap over 1.5x the vsync period is a miss. + """ + + def __init__(self, window, refresh_hz, render_hooks=False): + self.refresh = refresh_hz or 240.0 + self.intervals = deque(maxlen=20000) + self.misses = [] + self.work = deque(maxlen=20000) + self._window = window + self._sync_start = None + self._pc = time.perf_counter_ns + self._hooks = False + if render_hooks: + self.connect_hooks() + + def connect_hooks(self): + from PySide6.QtCore import Qt + direct = Qt.ConnectionType.DirectConnection + self._window.beforeSynchronizing.connect(self._before_sync, direct) + self._window.afterRendering.connect(self._after_render, direct) + self._hooks = True + + def disconnect_hooks(self): + if self._hooks: + self._window.beforeSynchronizing.disconnect(self._before_sync) + self._window.afterRendering.disconnect(self._after_render) + self._hooks = False + + def _before_sync(self): + self._sync_start = self._pc() + + def _after_render(self): + if self._sync_start is not None: + self.work.append((self._pc() - self._sync_start) / 1e6) + + def push(self, intervals_ms): + self.intervals.extend(d for d in intervals_ms if 0 < d < 250) + + def miss(self, dt_ms): + self.misses.append((time.monotonic(), round(dt_ms, 2))) + + def reset(self): + self.intervals.clear() + self.work.clear() + self.misses.clear() + self.t0 = time.monotonic() + + def summary(self, last=None): + def pct(seq, q): + a = sorted(seq) + return a[min(len(a) - 1, int(q * len(a)))] if a else 0.0 + iv = list(self.intervals)[-last:] if last else list(self.intervals) + wk = list(self.work)[-last:] if last else list(self.work) + budget = 1000.0 / self.refresh + missed = sum(1 for d in iv if d > budget * 1.5) + return { + "refresh_hz": round(self.refresh, 2), "frames": len(iv), + "fps": round(1000.0 / (sum(iv) / len(iv)), 1) if iv else 0.0, + "interval_p50": round(pct(iv, 0.5), 3), "interval_p99": round(pct(iv, 0.99), 3), + "interval_max": round(max(iv), 3) if iv else 0.0, + "work_p50": round(pct(wk, 0.5), 3) if wk else None, + "work_p99": round(pct(wk, 0.99), 3) if wk else None, + "missed": missed, "budget_ms": round(budget, 3), + } + + +def main(): + _env_defaults() + ap = argparse.ArgumentParser(prog="stemroller") + ap.add_argument("files", nargs="*", help="audio files to queue on launch") + ap.add_argument("--frame-overlay", action="store_true", help="show p50/p99 frame-time overlay (F12 toggles)") + ap.add_argument("--bench", type=float, default=0, metavar="SECONDS", + help="record frame stats for N seconds, print JSON, and quit") + ap.add_argument("--bench-delay", type=float, default=2.0) + ap.add_argument("--bench-out", default="") + ap.add_argument("--screenshot", action="append", default=[], metavar="PNG@SECONDS", + help="grab the window to PNG after N seconds (repeatable)") + ap.add_argument("--size", default="", metavar="WxH") + ap.add_argument("--autoplay", action="store_true", help="start playback as soon as stems load (dev)") + args = ap.parse_args() + + from PySide6.QtCore import QTimer, QUrl + from PySide6.QtGui import QFontDatabase, QGuiApplication, QIcon, QSurfaceFormat + from PySide6.QtQml import QQmlApplicationEngine + from PySide6.QtQuick import QQuickWindow + + fmt = QSurfaceFormat.defaultFormat() + fmt.setSwapInterval(1) # vsync: pace to the panel (240Hz), never a fixed timer + fmt.setAlphaBufferSize(8) # rounded, translucent window corners + QSurfaceFormat.setDefaultFormat(fmt) + QQuickWindow.setDefaultAlphaBuffer(True) + + app = QGuiApplication(sys.argv) + app.setApplicationName("StemRoller") + app.setOrganizationName("stemroller") + app.setDesktopFileName("stemroller") + app.setWindowIcon(QIcon(os.path.join(HERE, "assets", "stemroller.svg"))) + + font_dir = os.path.join(HERE, "assets", "fonts") + if os.path.isdir(font_dir): + for f in sorted(os.listdir(font_dir)): + if f.endswith((".ttf", ".otf")): + QFontDatabase.addApplicationFont(os.path.join(font_dir, f)) + families = set(QFontDatabase.families()) + ui_font = "Segoe UI Variable Text" if "Segoe UI Variable Text" in families else \ + "Segoe UI Variable" if "Segoe UI Variable" in families else "Inter" + + from .audio_engine import AudioEngine + from .controller import Controller + from .providers import FxProvider, IconProvider, PeakStore, WaveformProvider + + audio = AudioEngine() + peaks = PeakStore() + controller = Controller(audio, peaks) + + engine = QQmlApplicationEngine() + engine.addImageProvider("icon", IconProvider()) + engine.addImageProvider("fx", FxProvider()) + engine.addImageProvider("wave", WaveformProvider(peaks, controller.peaks_path_for)) + engine.addImportPath(os.path.join(HERE, "qml")) + ctx = engine.rootContext() + ctx.setContextProperty("app", controller) + ctx.setContextProperty("appSettings", controller.settings) + ctx.setContextProperty("jobsModel", controller.jobs) + ctx.setContextProperty("audio", audio) + ctx.setContextProperty("uiFont", ui_font) + ctx.setContextProperty("devOverlay", bool(args.frame_overlay or args.bench)) + from PySide6.QtCore import QObject, Slot + + class StatsBridge(QObject): + stats = None + + @Slot("QVariantList") + def push(self, intervals): + if self.stats is not None: + self.stats.push(intervals) + + @Slot(result="QVariantMap") + def summary(self): + return self.stats.summary(last=int(self.stats.refresh)) if self.stats else {} # last ~1s + + @Slot() + def reset(self): + if self.stats is not None: + self.stats.reset() + + @Slot(float) + def miss(self, dt_ms): + if self.stats is not None: + self.stats.miss(dt_ms) + + @Slot(bool) + def setHooks(self, on): + if self.stats is None: + return + if on and not self.stats._hooks: + self.stats.connect_hooks() + elif not on: + self.stats.disconnect_hooks() + + bridge = StatsBridge() + ctx.setContextProperty("frameStats", bridge) + engine.load(QUrl.fromLocalFile(os.path.join(HERE, "qml", "StemRoller", "Main.qml"))) + if not engine.rootObjects(): + print("failed to load QML", file=sys.stderr) + controller.shutdown() + return 1 + window = engine.rootObjects()[0] + if args.size: + w, h = (int(v) for v in args.size.split("x")) + window.resize(w, h) + + screen = window.screen() + stats = FrameStats(window, screen.refreshRate() if screen else 240.0) + bridge.stats = stats + # Render-thread hooks need the GIL; only attach once the event loop owns the + # GUI thread (Python calls that wait on the render thread would deadlock). + if args.frame_overlay or args.bench or controller.settings.get("frameOverlay"): + QTimer.singleShot(0, lambda: stats._hooks or stats.connect_hooks()) + window.screenChanged.connect(lambda sc: setattr(stats, "refresh", sc.refreshRate() if sc else stats.refresh)) + + + if args.autoplay: + audio.loadedChanged.connect(lambda: audio.loaded and QTimer.singleShot(300, audio.play)) + + if args.files: + QTimer.singleShot(0, lambda: controller.addUrls([os.path.abspath(f) for f in args.files])) + + if args.bench: + def start_bench(): + stats.reset() + QTimer.singleShot(int(args.bench * 1000), finish_bench) + + def finish_bench(): + s = stats.summary() + s["worker_state"] = controller._get_worker_state() + s["misses_at"] = [(round(t - stats.t0, 3), d) for t, d in stats.misses if t >= stats.t0] + out = json.dumps(s, indent=2) + print(out, flush=True) + if args.bench_out: + with open(args.bench_out, "w") as f: + f.write(out) + stats.disconnect_hooks() + app.quit() + + QTimer.singleShot(int(args.bench_delay * 1000), start_bench) + + for shot in args.screenshot: + path, _, after = shot.rpartition("@") + def grab(path=path): + # grabWindow blocks on the render thread while holding the GIL, so the + # render-thread hooks must be gone first. A hook call already in flight + # can still be waiting for the GIL after disconnect; yield to the event + # loop for a few frames so it drains before blocking. + hooks = stats._hooks + stats.disconnect_hooks() + + def do_grab(): + window.grabWindow().save(path) + if hooks: + stats.connect_hooks() + print("screenshot saved", path, flush=True) + QTimer.singleShot(100, do_grab) + QTimer.singleShot(int(float(after) * 1000), grab) + + signal.signal(signal.SIGINT, lambda *_: app.quit()) + # Let Python see SIGINT while Qt's loop runs, without a fixed-rate redraw timer. + keepalive = QTimer() + keepalive.start(500) + keepalive.timeout.connect(lambda: None) + + app.aboutToQuit.connect(stats.disconnect_hooks) + app.aboutToQuit.connect(controller.shutdown) + rc = app.exec() + del engine + return rc + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/stemroller/assets/fonts/Inter-Bold.ttf b/stemroller/assets/fonts/Inter-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..9fb9b751e5b2441054f6eef670da7b3f53a3505a GIT binary patch literal 420428 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 45vPrwCj8&%8F=IDq-RRM%sJ98 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 L5}tH>=cfK2^)otM literal 0 HcmV?d00001 diff --git a/stemroller/player/assets/fonts/Carlito-OFL.txt b/stemroller/player/assets/fonts/Carlito-OFL.txt new file mode 100644 index 0000000..8d6b170 --- /dev/null +++ b/stemroller/player/assets/fonts/Carlito-OFL.txt @@ -0,0 +1,94 @@ +Copyright 2013 The Carlito Project Authors (https://github.com/googlefonts/carlito), with Reserved Font Name "Carlito" + + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/stemroller/player/assets/fonts/Carlito-Regular.ttf b/stemroller/player/assets/fonts/Carlito-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..427b95989fee609ab683d800ad00e22a4b14ecad GIT binary patch literal 628032 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 #fYpHQa`n*^|QQW%}hgk@JQn(feDK@>V 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

J12!vt* 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�Nl}ebGbJdMY}G9W6aZl0 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 ZHo5ls%hPLA4S5`$B4d#}O3iSx{{Z{*BKiOT literal 0 HcmV?d00001 diff --git a/stemroller/player/assets/fonts/Selawik-LICENSE.txt b/stemroller/player/assets/fonts/Selawik-LICENSE.txt new file mode 100644 index 0000000..ac8fdb9 --- /dev/null +++ b/stemroller/player/assets/fonts/Selawik-LICENSE.txt @@ -0,0 +1,91 @@ +Copyright 2015, Microsoft Corporation (www.microsoft.com), with Reserved Font Name Selawik. All Rights Reserved. Selawik is a trademark of Microsoft Corporation in the United States and/or other countries. + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/stemroller/player/assets/fonts/Selawik-Regular.ttf b/stemroller/player/assets/fonts/Selawik-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..736bac3c210abb56f305c0c2307da8e002cd6c91 GIT binary patch literal 44224 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%0D^JQ?{Y$~!6w0xUqoi9A$ZgI>oGBchM! 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 XNW;VIpK^;^3QYQX?pdM-b7B7j$H*n$ literal 0 HcmV?d00001 diff --git a/stemroller/player/assets/stemroller-player.svg b/stemroller/player/assets/stemroller-player.svg new file mode 100644 index 0000000..494827d --- /dev/null +++ b/stemroller/player/assets/stemroller-player.svg @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/stemroller/player/config.py b/stemroller/player/config.py new file mode 100644 index 0000000..15550af --- /dev/null +++ b/stemroller/player/config.py @@ -0,0 +1,47 @@ +"""Player settings and saved state: ~/.config/stemroller/player.json.""" + +import json +import os +import uuid + +CONFIG_DIR = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "stemroller") +CACHE_DIR = os.path.join(os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache")), "stemroller", "player") +PATH = os.path.join(CONFIG_DIR, "player.json") + +DEFAULTS = { + "plexUrl": "http://192.168.86.2:32400", + "plexToken": "", + "plexUser": "", + "musicSection": "", + "sectionLocations": [], + "stemUrl": "http://192.168.86.2:8765", + "stemToken": "", + # The unraid shares, mounted here; files play straight from them when present. + "stemsDir": "/var/mnt/unraid/Music/Stems", + "musicDir": "/var/mnt/unraid/Music/Actual music/Flacs", + "stemRoots": [], + "volume": 0.8, + "keepMix": False, + "showMixer": True, + "gridlines": True, + "zoom": 100, +} + + +def load() -> dict: + cfg = dict(DEFAULTS) + try: + with open(PATH) as f: + cfg.update(json.load(f)) + except (OSError, ValueError): + pass + cfg.setdefault("clientId", str(uuid.uuid4())) + return cfg + + +def save(cfg: dict): + os.makedirs(CONFIG_DIR, exist_ok=True) + tmp = PATH + ".tmp" + with open(tmp, "w") as f: + json.dump(cfg, f, indent=1) + os.replace(tmp, PATH) diff --git a/stemroller/player/engine.py b/stemroller/player/engine.py new file mode 100644 index 0000000..15beb84 --- /dev/null +++ b/stemroller/player/engine.py @@ -0,0 +1,448 @@ +"""Streaming playback: a decoder thread reads every stem ahead of the playhead in chunks, +and the PortAudio callback mixes them with per-stem gains and the master volume. + +Nothing is decoded whole, so a song starts as soon as its first chunk is read (stems sit on +the network share) and memory stays flat. The callback never takes a lock: chunks travel +through a deque tagged with a generation number, and a seek or a new song bumps the +generation so stale chunks are dropped on the floor. +""" + +import collections +import json +import subprocess +import threading + +import numpy as np +import sounddevice as sd +import soundfile as sf +from PySide6.QtCore import Property, QObject, QTimer, Signal, Slot + +CHUNK = 8192 # frames per decoder read +AHEAD = 1.5 # seconds buffered ahead of the playhead +BLOCK = 1024 +LATENCY = 0.15 # roomy: Python shares the GIL with library loading +RING = 64 + + +class SfReader: + """libsndfile: FLAC, WAV, AIFF, Ogg, MP3.""" + + def __init__(self, path): + self.f = sf.SoundFile(path) + self.sr = self.f.samplerate + self.frames = self.f.frames + + def read(self, n): + data = self.f.read(n, dtype="float32", always_2d=True) + if data.shape[1] == 1: + return np.repeat(data, 2, axis=1) + return data[:, :2] + + def seek(self, frame): + self.f.seek(min(frame, self.frames)) + + def close(self): + self.f.close() + + +class FfmpegReader: + """Anything else (AAC/ALAC in .m4a and friends), decoded by ffmpeg to float stereo.""" + + def __init__(self, path, sr=None): + self.path = path + info = json.loads(subprocess.run( + ["ffprobe", "-v", "error", "-select_streams", "a:0", "-show_entries", "stream=sample_rate:format=duration", + "-of", "json", path], capture_output=True, check=True, timeout=20).stdout) + self.sr = sr or int(info["streams"][0]["sample_rate"]) + self.frames = int(float(info["format"]["duration"]) * self.sr) + self.proc = None + self.seek(0) + + def seek(self, frame): + self.close() + self.proc = subprocess.Popen( + ["ffmpeg", "-v", "error", "-ss", f"{frame / self.sr:.6f}", "-i", self.path, "-vn", + "-f", "f32le", "-ac", "2", "-ar", str(self.sr), "-"], + stdout=subprocess.PIPE, stdin=subprocess.DEVNULL) + + def read(self, n): + raw = self.proc.stdout.read(n * 8) + usable = len(raw) - len(raw) % 8 + return np.frombuffer(raw[:usable], np.float32).reshape(-1, 2) + + def close(self): + if self.proc: + self.proc.kill() + self.proc.stdout.close() + self.proc.wait() + self.proc = None + + +def open_reader(path, sr=None): + if sr is None: + try: + return SfReader(path) + except (sf.LibsndfileError, RuntimeError): + pass + return FfmpegReader(path, sr) + + +class Source: + """One song: one reader per stem (or a single reader for the original file).""" + + def __init__(self, names, paths): + self.names = list(names) + self.readers = [] + try: + for p in paths: + self.readers.append(open_reader(p)) + sr = self.readers[0].sr + # Stems always share a rate; if one didn't, resample it through ffmpeg. + for i, (r, p) in enumerate(zip(self.readers, paths)): + if r.sr != sr: + r.close() + self.readers[i] = open_reader(p, sr) + except Exception: + self.close() + raise + self.sr = sr + self.frames = min(r.frames for r in self.readers) + + def read(self, n): + """(stems, frames, 2) float32; fewer frames near the end, none at EOF.""" + blocks = [r.read(n) for r in self.readers] + m = min(b.shape[0] for b in blocks) + return np.stack([b[:m] for b in blocks]) + + def seek(self, frame): + for r in self.readers: + r.seek(frame) + + def close(self): + for r in self.readers: + try: + r.close() + except Exception: + pass + self.readers = [] + + +class PlayerEngine(QObject): + playingChanged = Signal() + bufferingChanged = Signal() + volumeChanged = Signal() + durationChanged = Signal() + ended = Signal() + failed = Signal(str) + + def __init__(self, parent=None): + super().__init__(parent) + self._src: Source | None = None + self._sr = 44100 + self._frames = 0 + self._gen = 0 + self._gen_start = 0 # frame the current generation starts at + self._queue = collections.deque() + self._produced = 0 + self._consumed = 0 + self._eof = False + self._seek_to = None + self._to_close = [] + self._cond = threading.Condition() + self._alive = True + self._playing = False + self._buffering = False + self._ended_flag = False + self._stream: sd.OutputStream | None = None + self._gains = np.ones(0, np.float32) + self._gains_cur = np.ones(0, np.float32) + self._volume = 0.8 + self._master = self._volume ** 3 + self._master_cur = self._master + # callback-owned + self._cb_gen = -1 + self._cur = None + self._cur_off = 0 + self._pos = 0 + self._underrun = False + self._mix = np.zeros((BLOCK * 8, 2), np.float32) + self._ramp = np.zeros(0, np.float32) + self._ring = np.zeros((RING, 4), np.float64) + self._ring_i = 0 + self._thread = threading.Thread(target=self._decode_loop, daemon=True, name="decoder") + self._thread.start() + # The callback only sets flags; this turns them into signals on the GUI thread. + self._tick = QTimer(self) + self._tick.setInterval(100) + self._tick.timeout.connect(self._poll) + self._tick.start() + + # ---- decoder thread -------------------------------------------------------------- + def _decode_loop(self): + while True: + with self._cond: + while self._alive and not self._to_close and self._seek_to is None and ( + self._src is None or self._eof + or self._produced - self._consumed >= AHEAD * self._sr): + self._cond.wait(0.25) + if not self._alive: + return + closing, self._to_close = self._to_close, [] + src, gen, seek = self._src, self._gen, self._seek_to + self._seek_to = None + for s in closing: + s.close() + if src is None: + continue + try: + if seek is not None: + src.seek(seek) + block = src.read(CHUNK) + except Exception as e: # unreadable file mid-song: treat as its end + print("decode error:", e, flush=True) + block = np.zeros((len(src.names), 0, 2), np.float32) + with self._cond: + if gen != self._gen: + continue + if block.shape[1] == 0: + self._eof = True + self._queue.append((gen, None)) + else: + self._queue.append((gen, block)) + self._produced += block.shape[1] + + # ---- GUI thread API ----------------------------------------------------------------- + def set_source(self, src: Source, start_seconds=0.0, play=True): + """Replaces the playing song. Takes ownership of [src].""" + if self._stream is not None and self._stream.samplerate != src.sr: + self._close_stream() + with self._cond: + if self._src is not None: + self._to_close.append(self._src) + self._src = src + self._sr = src.sr + self._frames = src.frames + k = len(src.names) + if len(self._gains) != k: + self._gains = np.ones(k, np.float32) + self._gains_cur = self._gains.copy() + self._restart_locked(int(start_seconds * src.sr)) + self._ended_flag = False + self.durationChanged.emit() + if play: + self.play() + + def clear(self): + self.pause() + with self._cond: + if self._src is not None: + self._to_close.append(self._src) + self._src = None + self._frames = 0 + self._restart_locked(0) + self._cond.notify() + self.durationChanged.emit() + + def _restart_locked(self, frame): + frame = max(0, min(frame, max(0, self._frames - 1))) + self._gen += 1 + self._gen_start = frame + self._queue.clear() + self._produced = self._consumed = 0 + self._eof = False + self._seek_to = frame + self._ring[:] = 0 + self._cond.notify() + + @Slot() + def play(self): + if self._src is None or self._playing: + return + if self._stream is None: + self._stream = sd.OutputStream(samplerate=self._sr, channels=2, dtype="float32", blocksize=BLOCK, + latency=LATENCY, callback=self._callback) + self._playing = True + self._ring[:] = 0 + self._stream.start() + self.playingChanged.emit() + + @Slot() + def pause(self): + if not self._playing: + return + heard = self._heard_frame() + self._playing = False + if self._stream is not None: + self._stream.abort() # instant; what was queued but unheard is decoded again below + with self._cond: + self._restart_locked(int(heard)) + self.playingChanged.emit() + + @Slot() + def toggle(self): + self.pause() if self._playing else self.play() + + @Slot(float) + def seek(self, seconds): + with self._cond: + self._restart_locked(int(seconds * self._sr)) + self._ended_flag = False + + def set_gains(self, gains): + g = np.asarray(gains, np.float32) + if len(g) == len(self._gains): + self._gains = g + + @Slot(float) + def setVolume(self, v): + v = max(0.0, min(1.0, float(v))) + if v != self._volume: + self._volume = v + self._master = v ** 3 # cubic taper: even loudness steps along the slider + self.volumeChanged.emit() + + def shutdown(self): + self._close_stream() + with self._cond: + self._alive = False + if self._src is not None: + self._src.close() + self._cond.notify() + + def _close_stream(self): + if self._stream is not None: + try: + self._stream.abort() + self._stream.close() + except Exception: + pass + self._stream = None + if self._playing: + self._playing = False + self.playingChanged.emit() + + def _poll(self): + # Wait for the device to play out what's queued, or the song's last moment is cut. + if self._ended_flag and self._playing and self._heard_frame() >= self._pos - BLOCK: + self._ended_flag = False + self._playing = False + if self._stream is not None: + self._stream.abort() + self.playingChanged.emit() + self.ended.emit() + return + b = self._playing and self._underrun and not self._eof + if b != self._buffering: + self._buffering = b + self.bufferingChanged.emit() + + # ---- audio thread ----------------------------------------------------------------- + def _callback(self, outdata, frames, time_info, status): + gen = self._gen + if gen != self._cb_gen: + self._cb_gen = gen + self._cur = None + self._pos = self._gen_start + mix = self._mix[:frames] + mix.fill(0) + start_pos = self._pos + filled = 0 + g1 = self._gains + g0 = self._gains_cur if len(self._gains_cur) == len(g1) else g1 + ramping = not np.array_equal(g0, g1) + if ramping and len(self._ramp) != frames: + self._ramp = np.linspace(0.0, 1.0, frames, dtype=np.float32) + q = self._queue + while self._playing and filled < frames: + if self._cur is None: + if not q: + break + item_gen, block = q.popleft() + if item_gen != gen: + continue + if block is None: + self._ended_flag = True + break + self._cur, self._cur_off = block, 0 + cur, off = self._cur, self._cur_off + take = min(frames - filled, cur.shape[1] - off) + seg = cur[:, off:off + take] + if ramping: + r = self._ramp[filled:filled + take] + w = g0[:, None] + (g1 - g0)[:, None] * r[None, :] + mix[filled:filled + take] += np.einsum("kt,ktc->tc", w, seg) + else: + mix[filled:filled + take] += np.tensordot(g1, seg, axes=(0, 0)) + filled += take + self._cur_off = off + take + if self._cur_off >= cur.shape[1]: + self._cur = None + self._gains_cur = g1 + self._underrun = filled < frames and not self._ended_flag + self._pos = start_pos + filled + self._consumed += filled + m0, m1 = self._master_cur, self._master + if m0 != m1: + mix *= np.linspace(m0, m1, frames, dtype=np.float32)[:, None] + self._master_cur = m1 + elif m1 != 1.0: + mix *= m1 + outdata[:] = mix + if filled and len(q) < 3: + with self._cond: + self._cond.notify() + peak = np.abs(mix).max(axis=0) + dac = time_info.outputBufferDacTime + if dac <= 0: + dac = self._stream.time + self._stream.latency + r = self._ring[self._ring_i % RING] + r[0], r[1], r[2], r[3] = dac, start_pos, peak[0], peak[1] + self._ring_i += 1 + + def _heard_frame(self): + """Interpolates the frame at the DAC from the per-block timestamps.""" + if self._stream is None or not self._playing: + return float(self._gen_start if self._cb_gen != self._gen else self._pos) + if self._cb_gen != self._gen: + return float(self._gen_start) + now = self._stream.time + ring = self._ring + played = ring[(ring[:, 0] > 0) & (ring[:, 0] <= now)] + if not len(played): + return float(self._gen_start) + last = played[np.argmax(played[:, 0])] + return float(min(self._frames, last[1] + (now - last[0]) * self._sr)) + + # ---- UI reads ---------------------------------------------------------------------- + @Slot(result="QVariantList") + def snapshot(self): + """[position seconds, peakL, peakR] for this frame.""" + pos = self._heard_frame() / self._sr if self._src is not None else 0.0 + if not self._playing or self._stream is None: + return [pos, 0.0, 0.0] + ring = self._ring + played = ring[(ring[:, 0] > 0) & (ring[:, 0] <= self._stream.time)] + if not len(played): + return [pos, 0.0, 0.0] + last = played[np.argmax(played[:, 0])] + return [pos, float(last[2]), float(last[3])] + + def position(self): + return self._heard_frame() / self._sr if self._src is not None else 0.0 + + def _get_playing(self): + return self._playing + + def _get_buffering(self): + return self._buffering + + def _get_duration(self): + return self._frames / self._sr if self._src is not None else 0.0 + + def _get_volume(self): + return self._volume + + playing = Property(bool, _get_playing, notify=playingChanged) + buffering = Property(bool, _get_buffering, notify=bufferingChanged) + duration = Property(float, _get_duration, notify=durationChanged) + volume = Property(float, _get_volume, setVolume, notify=volumeChanged) diff --git a/stemroller/player/icons.py b/stemroller/player/icons.py new file mode 100644 index 0000000..cb670f1 --- /dev/null +++ b/stemroller/player/icons.py @@ -0,0 +1,104 @@ +"""Office-style ribbon icons: flat, two-tone, drawn from SVG at whatever size QML asks for. + +image://icon/[/] — the colour overrides the dark-gray ink (for white-on-green chrome). +""" + +from PySide6.QtCore import QByteArray, QRectF, Qt +from PySide6.QtGui import QImage, QPainter +from PySide6.QtQuick import QQuickImageProvider +from PySide6.QtSvg import QSvgRenderer + +INK = "#444444" +GREEN = "#217346" +BLUE = "#2B7CD3" +RED = "#D13438" +ORANGE = "#E8912D" +LIGHT = "#FFFFFF" + +# Each icon is SVG body markup on a 32×32 grid; {ink} is the main colour. +ICONS = { + "play": f'', + "pause": '', + "stop": '', + "previous": '', + "next": '', + "shuffle": '' + '', + "repeat": '' + '', + "repeat_one": '' + f'', + "volume": '', + "mute": f'', + "vocals": '', + "vocals_off": f'', + "mixer": f'', + "queue_add": f'', + "play_next": f'', + "playlist_new": f'', + "playlist_add": f'', + "delete_rows": f'', + "refresh": f'', + "plex": f'', + "database": f'', + "server": f'', + "sort_az": f'AZ', + "sort_za": f'ZA', + "filter": '', + "sigma": '', + "search": '', + "lightbulb": '', + "grid": f'', + "freeze": f'', + "headings": 'A B12', + "pane": f'', + "zoom": '', + "chart": f'', + "styles": '', + "info": f'', + "account": '', + "options": '', + "back": '', + "close": '', + "minimize": '', + "maximize": '', + "restore": '', + "save": '', + "undo": '', + "redo": '', + "excel": f'', + "dropdown": '', + "sort_up": '', + "sort_down": '', + "left": '', + "right": '', + "plus": '', + "normal_view": '', + "page_view": '', + "break_view": '', + "function": 'fx', + "check": f'', + "cancel": f'', +} + + +class IconProvider(QQuickImageProvider): + def __init__(self): + super().__init__(QQuickImageProvider.ImageType.Image) + + def requestImage(self, id_, size, requested): + name, _, ink = id_.partition("/") + w = requested.width() if requested.width() > 0 else 32 + h = requested.height() if requested.height() > 0 else w + body = ICONS.get(name, ICONS["grid"]).replace("{ink}", "#" + ink if ink else INK) + svg = f'{body}' + img = QImage(w, h, QImage.Format.Format_ARGB32_Premultiplied) + img.fill(Qt.GlobalColor.transparent) + p = QPainter(img) + p.setRenderHint(QPainter.RenderHint.Antialiasing) + QSvgRenderer(QByteArray(svg.encode())).render(p, QRectF(0, 0, w, h)) + p.end() + if size is not None: + size.setWidth(w) + size.setHeight(h) + return img diff --git a/stemroller/player/library.py b/stemroller/player/library.py new file mode 100644 index 0000000..d5918fb --- /dev/null +++ b/stemroller/player/library.py @@ -0,0 +1,604 @@ +"""The library as a workbook: Plex data cached on disk, refreshed in the background, shown as sheets.""" + +import json +import os +import random +import re +import threading +import time + +from PySide6.QtCore import Property, QObject, QTimer, Signal, Slot +from PySide6.QtGui import QGuiApplication + +from . import config +from .plex import PlexError +from .sheets import ALBUM, ARTIST, PLAYLIST, SONG, Sheet, SheetModel, fmt, fmt_time, fold + +BASE_TABS = ["Songs", "Artists", "Albums", "Playlists", "Stems", "Queue"] +_SONG_NAME = re.compile(r"^(?:.* - )?(?:\d{1,2}-)?(\d{1,3})\s*[-.]?\s+(.+)$") + + +class Library(QObject): + tabsChanged = Signal() + sheetChanged = Signal() # anything about the current sheet: data, sort, columns + sheetSwitched = Signal() # a different sheet is showing: selection and scroll start over + statusChanged = Signal() + toast = Signal(str) + _done = Signal(str, object) # worker results, delivered on the GUI thread + + def __init__(self, cfg, plex, stems, parent=None): + super().__init__(parent) + self.cfg, self.plex, self.stems = cfg, plex, stems + self.player = None # set by the app; the queue sheet reads it + self.tracks, self.artists, self.albums, self.playlists = [], [], [], [] + self._by_album, self._by_artist = {}, {} + self._tabs = [Sheet(t, "songs", []) for t in BASE_TABS] + self._tabs[1] = Sheet("Artists", "artists", [], ARTIST) + self._tabs[2] = Sheet("Albums", "albums", [], ALBUM) + self._tabs[3] = Sheet("Playlists", "playlists", [], PLAYLIST) + self._tabs[5] = Sheet("Queue", "queue", []) + self._current = 0 + self.model = SheetModel(self) + self._status = "" + self._progress = -1.0 + self._busy = False + self._done.connect(self._on_done) + self._cache = os.path.join(config.CACHE_DIR, "library.json") + self._load_cache() + self._rebuild() + self.model.set_sheet(self._tabs[0]) + QTimer.singleShot(0, self.refresh) + # stemserve rescans every 30 s; pick up newly separated songs while open + self._stem_timer = QTimer(self, interval=120_000) + self._stem_timer.timeout.connect(self._refresh_stems) + self._stem_timer.start() + + # ---- data ------------------------------------------------------------------------ + def _load_cache(self): + try: + with open(self._cache) as f: + d = json.load(f) + if d.get("section") == self.cfg.get("musicSection"): + self.tracks, self.artists = d["tracks"], d["artists"] + self.albums, self.playlists = d["albums"], d["playlists"] + except (OSError, ValueError, KeyError): + pass + + def _save_cache(self): + os.makedirs(config.CACHE_DIR, exist_ok=True) + tmp = self._cache + ".tmp" + with open(tmp, "w") as f: + json.dump({"section": self.cfg.get("musicSection"), "tracks": self.tracks, "artists": self.artists, + "albums": self.albums, "playlists": self.playlists}, f) + os.replace(tmp, self._cache) + + def _work(self, tag, fn): + def run(): + try: + self._done.emit(tag, fn()) + except Exception as e: # noqa: BLE001 - shown in the status bar + self._done.emit(tag + ":error", e) + threading.Thread(target=run, daemon=True).start() + + @Slot() + def refresh(self): + """Data → Refresh All.""" + self._refresh_stems() + if not self.plex.signed_in or not self.cfg.get("musicSection") or self._busy: + return + self._busy = True + self._set_status("Calculating: Plex library", 0.0) + + def fetch(): + def progress(n, total): + self._done.emit("progress", (n, total)) + return {"tracks": self.plex.tracks(progress), "artists": self.plex.artists(), + "albums": self.plex.albums(), "playlists": self.plex.playlists()} + self._work("library", fetch) + + def _refresh_stems(self): + self._work("stems", self.stems.refresh) + + def _on_done(self, tag, result): + if tag == "pin": + self._poll_pin(result) + elif tag == "token": + self._signed_in(result) + elif tag == "sections": + self._sections(result) + elif tag == "progress": + n, total = result + self._set_status("Calculating: Plex library", n / total if total else 0.0) + elif tag == "library": + self._busy = False + self.tracks, self.artists = result["tracks"], result["artists"] + self.albums, self.playlists = result["albums"], result["playlists"] + self._rebuild() + self._set_status("", -1) + self._work("save", self._save_cache) + elif tag == "stems": + if result: + self._rebuild() + self.statusChanged.emit() + elif tag == "library:error": + self._busy = False + self._set_status("", -1) + self.toast.emit(str(result)) + elif tag.endswith(":error"): + self.toast.emit(str(result)) + for s in self._tabs: + if s.loading: + s.loading = False + self.sheetChanged.emit() + elif tag.startswith("playlist:"): + key = tag.split(":", 1)[1] + for s in self._tabs: + if s.sid == f"playlist:{key}": + s.rows, s.loading = self._song_rows(result), False + if s is self._tabs[self._current]: + self.model.set_sheet(s) + self.sheetChanged.emit() + elif tag == "playlists": + self.playlists = result + self._tabs[3].rows = self._playlist_rows() + if self._current == 3: + self.model.refresh() + + def _stems_only(self): + """Without Plex, the library is the stem server's index: artist/album/song from the folders.""" + tracks, albums, artists = [], {}, {} + for e in self.stems.index.entries: + parts = e["key"].split("/") + artist = parts[0] if len(parts) > 2 else "" + album = parts[-2] if len(parts) > 1 else "" + m = _SONG_NAME.match(parts[-1]) + title, index = (m.group(2), int(m.group(1))) if m else (parts[-1], 0) + ak, rk = "stem-album:" + "/".join(parts[:-1]), "stem-artist:" + artist + tracks.append({"key": "stem:" + e["key"], "title": title, "artist": artist, "albumArtist": artist, + "album": album, "albumKey": ak, "artistKey": rk, "year": 0, "index": index, "disc": 0, + "durationMs": int((e.get("duration") or 0) * 1000), "thumb": "", "partFile": "", + "partKey": "", "codec": "flac", "plays": 0, "addedAt": int(e.get("finished") or 0), + "stemKey": e["key"]}) + albums.setdefault(ak, {"key": ak, "title": album, "artist": artist, "artistKey": rk, "year": 0, + "tracks": 0, "thumb": "", "addedAt": 0, "genre": ""})["tracks"] += 1 + artists.setdefault(rk, {"key": rk, "title": artist, "sortTitle": artist, "albums": 0, "thumb": "", "genre": ""}) + for a in albums.values(): + artists[a["artistKey"]]["albums"] += 1 + tracks.sort(key=lambda t: fold(t["title"])) + return tracks, sorted(artists.values(), key=lambda a: fold(a["title"])), \ + sorted(albums.values(), key=lambda a: fold(a["title"])) + + def _rebuild(self): + """Derives stems flags, groupings and the base sheets from the raw lists.""" + if not self.plex.signed_in or not self.cfg.get("musicSection"): + self.tracks, self.artists, self.albums = self._stems_only() + self.playlists = [] + for t in self.tracks: + e = self._entry(t) + t["stemKey"] = e["key"] if e else "" + t["stems"] = len(e["stems"]) if e else 0 + self._by_album, self._by_artist = {}, {} + for t in self.tracks: + self._by_album.setdefault(t["albumKey"], []).append(t) + self._by_artist.setdefault(t["artistKey"], []).append(t) + for lst in self._by_album.values(): + lst.sort(key=lambda t: (t.get("disc") or 0, t.get("index") or 0)) + for a in self.artists: + songs = self._by_artist.get(a["key"], []) + a["songs"] = len(songs) + a["stemSongs"] = sum(1 for t in songs if t["stems"]) + for a in self.albums: + a["stemSongs"] = sum(1 for t in self._by_album.get(a["key"], []) if t["stems"]) + self._tabs[0].rows = self._song_rows(self.tracks) + self._tabs[1].rows = [dict(a) for a in self.artists] + self._tabs[2].rows = [dict(a) for a in self.albums] + self._tabs[3].rows = self._playlist_rows() + self._tabs[4].rows = self._song_rows([t for t in self.tracks if t["stems"]]) + for s in self._tabs[:5]: + if s.sort: + self._apply_sort(s) + self.model.refresh() + self.sheetChanged.emit() + self.statusChanged.emit() + + def _entry(self, t): + if t["key"].startswith("stem:"): + return self.stems.index.by_key.get(t.get("stemKey")) + return self.stems.find(t) + + def _playlist_rows(self): + return [dict(p, kind="Smart" if p["smart"] else "Manual") for p in self.playlists] + + def _song_rows(self, tracks): + rows = [] + for t in tracks: + e = self._entry(t) + rows.append(dict(t, stemKey=e["key"] if e else "", stems=len(e["stems"]) if e else 0)) + return rows + + # ---- tabs ----------------------------------------------------------------------- + def _get_tabs(self): + return [{"title": s.title, "base": i < len(BASE_TABS)} for i, s in enumerate(self._tabs)] + + def _get_current(self): + return self._current + + @Slot(int) + def setCurrent(self, i): + if 0 <= i < len(self._tabs) and i != self._current: + self._current = i + if self._tabs[i].layout == "queue": + self.update_queue() + self.sheetSwitched.emit() + self.model.set_sheet(self._tabs[i]) + self.tabsChanged.emit() + self.sheetChanged.emit() + + @Slot(int) + def closeTab(self, i): + if i >= len(BASE_TABS) and i < len(self._tabs): + del self._tabs[i] + cur = min(self._current, len(self._tabs) - 1) if self._current >= i else self._current + self._current = -1 + self.tabsChanged.emit() + self.setCurrent(cur if cur != i or cur < len(self._tabs) else i - 1) + + @Slot() + def back(self): + """Backspace: closes the drilled-in sheet and returns to the one before it.""" + if self._current >= len(BASE_TABS): + self.closeTab(self._current) + + def _open(self, sheet): + """Opens a drilled-in sheet after the current one, replacing what was to its right.""" + for i, s in enumerate(self._tabs): + if s.sid == sheet.sid: + self._tabs[i] = sheet + self._current = -1 + self.setCurrent(i) + return + cut = max(len(BASE_TABS), self._current + 1) + self._tabs = self._tabs[:cut] + [sheet] + self.tabsChanged.emit() + self.setCurrent(len(self._tabs) - 1) + + @property + def sheet(self) -> Sheet: + return self._tabs[self._current] + + # ---- rows ----------------------------------------------------------------------- + @Slot(int, int) + def activate(self, row, mods=0): + """Enter / double-click: play a song from here, or open an artist, album or playlist.""" + s = self.sheet + if not (0 <= row < len(s.rows)): + return + kind, r = s.row_kind(row), s.rows[row] + if kind == SONG: + if s.layout == "queue": + self.player.skipTo(row) + return + songs = [x for i, x in enumerate(s.rows) if s.row_kind(i) == SONG] + self.player.play_tracks(songs, songs.index(r)) + elif kind == ARTIST: + albums = sorted((a for a in self.albums if a["artistKey"] == r["key"]), key=lambda a: a.get("year") or 0) + self._open(Sheet(r["title"], "albums", [dict(a) for a in albums], ALBUM, sid=f"artist:{r['key']}")) + elif kind == ALBUM: + self._open(Sheet(r["title"], "albumSongs", self._song_rows(self._by_album.get(r["key"], [])), + sid=f"album:{r['key']}")) + elif kind == PLAYLIST: + self._open(Sheet(r["title"], "songs", [], sid=f"playlist:{r['key']}", loading=True)) + self._work(f"playlist:{r['key']}", lambda: self.plex.playlist_tracks(r["key"])) + + def rows_for_play(self, r0, r1): + s = self.sheet + out = [] + for i in range(max(0, r0), min(len(s.rows), r1 + 1)): + k, r = s.row_kind(i), s.rows[i] + if k == SONG: + out.append(r) + elif k == ALBUM: + out += self._song_rows(self._by_album.get(r["key"], [])) + elif k == ARTIST: + for a in sorted((a for a in self.albums if a["artistKey"] == r["key"]), key=lambda a: a.get("year") or 0): + out += self._song_rows(self._by_album.get(a["key"], [])) + return out + + @Slot(int, int) + def queueRows(self, r0, r1): + tracks = self.rows_for_play(r0, r1) + if tracks: + self.player.add_to_queue(tracks) + self.toast.emit(f"Added {len(tracks)} song{'s' if len(tracks) != 1 else ''} to the queue") + + @Slot(int, int) + def playNextRows(self, r0, r1): + tracks = self.rows_for_play(r0, r1) + if tracks: + self.player.play_next(tracks) + self.toast.emit(f"{len(tracks)} song{'s' if len(tracks) != 1 else ''} will play next") + + @Slot(int, int) + def playRows(self, r0, r1): + tracks = self.rows_for_play(r0, r1) + if tracks: + self.player.play_tracks(tracks, 0) + + @Slot() + def shuffleSheet(self): + """AutoSum's spot on the ribbon: shuffle everything on this sheet.""" + tracks = self.rows_for_play(0, len(self.sheet.rows) - 1) + if tracks: + self.player.play_tracks(tracks, random.randrange(len(tracks)), shuffle=True) + + @Slot(int, int) + def removeRows(self, r0, r1): + s = self.sheet + if s.layout == "queue": + for i in range(min(r1, len(s.rows) - 1), r0 - 1, -1): + self.player.removeAt(i) + elif s.sid.startswith("playlist:"): + key = s.sid.split(":", 1)[1] + items = [s.rows[i] for i in range(r0, min(r1 + 1, len(s.rows)))] + + def remove(): + for it in items: + if it.get("playlistItemID"): + self.plex.remove_from_playlist(key, it["playlistItemID"]) + return self.plex.playlist_tracks(key) + self._work(f"playlist:{key}", remove) + + @Slot(str, int, int) + def newPlaylist(self, title, r0, r1): + keys = [t["key"] for t in self.rows_for_play(r0, r1)] + if not title.strip() or not keys: + return + + def make(): + self.plex.create_playlist(title.strip(), keys) + return self.plex.playlists() + self._work("playlists", make) + self.toast.emit(f"Created playlist “{title.strip()}”") + + @Slot(str, int, int) + def addToPlaylist(self, title, r0, r1): + keys = [t["key"] for t in self.rows_for_play(r0, r1)] + p = next((p for p in self.playlists if p["title"] == title and not p["smart"]), None) + if not keys or p is None: + return + + def add(): + self.plex.add_to_playlist(p["key"], keys) + return self.plex.playlists() + self._work("playlists", add) + self.toast.emit(f"Added {len(keys)} song{'s' if len(keys) != 1 else ''} to “{p['title']}”") + + def _get_playlist_names(self): + return [p["title"] for p in self.playlists if not p["smart"]] + + # ---- queue sheet ------------------------------------------------------------------ + def update_queue(self): + q = self._tabs[5] + q.rows = [dict(self._song_rows([t])[0], pos=i + 1) for i, t in enumerate(self.player.queue)] + if self._current == 5: + self.model.refresh() + self.model.set_playing(self.player.current_key(), self.player.index) + + # ---- search, sort ------------------------------------------------------------------ + @Slot(str) + def search(self, text): + q = fold(text.strip()) + if not q: + return + rows = [dict(a, _kind=ARTIST, type="Artist") for a in self.artists if q in fold(a["title"])][:50] + rows += [dict(a, _kind=ALBUM, type="Album", album="") for a in self.albums if q in fold(a["title"])][:100] + hits = [t for t in self.tracks if q in fold(t["title"])] + hits += [t for t in self.tracks if q not in fold(t["title"]) and (q in fold(t["artist"]) or q in fold(t["album"]))] + rows += [dict(r, type="Song") for r in self._song_rows(hits[:2000])] + self._open(Sheet(f"Search “{text.strip()}”", "search", rows, SONG, sid="search")) + + @Slot(int) + def sortBy(self, col): + s = self.sheet + desc = bool(s.sort and s.sort[0] == col and not s.sort[1]) + s.sort = (col, desc) + self._apply_sort(s) + self.model.refresh() + self.sheetChanged.emit() + + @Slot(int, bool) + def sortTo(self, col, desc): + s = self.sheet + if 0 <= col < len(s.columns): + s.sort = (col, desc) + self._apply_sort(s) + self.model.refresh() + self.sheetChanged.emit() + + @staticmethod + def _apply_sort(s): + col, desc = s.sort + key, _, _, kind = s.columns[col] + if kind == "text": + s.rows.sort(key=lambda r: fold(str(r.get(key) or "")), reverse=desc) + else: + s.rows.sort(key=lambda r: r.get(key) or 0, reverse=desc) + + def _get_sort_col(self): + return self.sheet.sort[0] if self.sheet.sort else -1 + + def _get_sort_desc(self): + return bool(self.sheet.sort and self.sheet.sort[1]) + + # ---- formula bar, status bar -------------------------------------------------------- + @Slot(int, int, result=str) + def formula(self, row, col): + """What the formula bar shows for a cell: the value, or a formula for the row's action.""" + s = self.sheet + if not (0 <= row < len(s.rows) and 0 <= col < len(s.columns)): + return "" + r = s.rows[row] + key, _, _, kind = s.columns[col] + if kind == "stems": + return f"=STEMS(\"{r.get('title', '')}\")" if r.get(key) else "=FALSE" + if kind == "time" and r.get(key): + return f"=TIME(0,{int(r[key] / 60000)},{int(r[key] / 1000) % 60})" + if key == "title": + k = s.row_kind(row) + fn = {SONG: "PLAY", ARTIST: "ARTIST", ALBUM: "ALBUM", PLAYLIST: "PLAYLIST"}[k] + q = r["title"].replace('"', '""') + return f'={fn}("{q}")' + v = r.get(key) + return "" if v in (None, "", 0) and kind != "int" else str(v) + + @Slot(int, int, int, int) + def copyCells(self, r0, c0, r1, c1): + """Ctrl+C: the selection as tab-separated text, like copying from Excel.""" + s = self.sheet + r0, r1 = max(0, min(r0, r1)), min(len(s.rows) - 1, max(r0, r1)) + c0, c1 = max(0, min(c0, c1)), min(len(s.columns) - 1, max(c0, c1)) + lines = ["\t".join(fmt(s.rows[r].get(s.columns[c][0]), s.columns[c][3]) for c in range(c0, c1 + 1)) + for r in range(r0, r1 + 1)] + QGuiApplication.clipboard().setText("\n".join(lines)) + + @Slot(int, int, int, int, result="QVariantMap") + def stats(self, r0, c0, r1, c1): + """Average / Count / Sum for a selection, like Excel's status bar.""" + s = self.sheet + r0, r1 = max(0, min(r0, r1)), min(len(s.rows) - 1, max(r0, r1)) + c0, c1 = max(0, min(c0, c1)), min(len(s.columns) - 1, max(c0, c1)) + cells, nums, kinds = 0, [], set() + for r in range(r0, r1 + 1): + row = s.rows[r] + for c in range(c0, c1 + 1): + key, _, _, kind = s.columns[c] + v = row.get(key) + if v in (None, "") or (kind != "int" and not v): + continue + cells += 1 + if kind in ("int", "time", "year") and isinstance(v, (int, float)): + nums.append(v) + kinds.add(kind) + if cells < 2: + return {} + out = {"count": cells} + if nums: + is_time = kinds == {"time"} + total = sum(nums) + out["sum"] = fmt_time(total) if is_time else f"{total:,}" + avg = total / len(nums) + out["average"] = fmt_time(avg) if is_time else f"{avg:,.1f}".rstrip("0").rstrip(".") + return out + + def _set_status(self, text, progress): + self._status, self._progress = text, progress + self.statusChanged.emit() + + def _get_status(self): + return self._status + + def _get_progress(self): + return self._progress + + def _get_sheet_title(self): + return self.sheet.title + + def _get_loading(self): + return self.sheet.loading + + def _get_sheet_id(self): + return self.sheet.sid + + def _get_layout(self): + return self.sheet.layout + + def _get_columns(self): + return [{"title": c[1], "width": c[2], "kind": c[3]} for c in self.sheet.columns] + + def _get_counts(self): + return {"songs": len(self.tracks), "stems": sum(1 for t in self.tracks if t.get("stems")), + "stemIndex": len(self.stems.index), "stemOnline": self.stems.online} + + tabs = Property("QVariantList", _get_tabs, notify=tabsChanged) + current = Property(int, _get_current, setCurrent, notify=tabsChanged) + columns = Property("QVariantList", _get_columns, notify=sheetChanged) + sheetTitle = Property(str, _get_sheet_title, notify=sheetChanged) + layout = Property(str, _get_layout, notify=sheetChanged) + sheetId = Property(str, _get_sheet_id, notify=sheetChanged) + loading = Property(bool, _get_loading, notify=sheetChanged) + sortColumn = Property(int, _get_sort_col, notify=sheetChanged) + sortDescending = Property(bool, _get_sort_desc, notify=sheetChanged) + status = Property(str, _get_status, notify=statusChanged) + progress = Property(float, _get_progress, notify=statusChanged) + counts = Property("QVariantMap", _get_counts, notify=statusChanged) + playlistNames = Property("QVariantList", _get_playlist_names, notify=sheetChanged) + + # ---- Plex sign-in (File → Account) --------------------------------------------------- + pinChanged = Signal() + + def _get_pin(self): + return getattr(self, "_pin_code", "") + + pin = Property(str, _get_pin, notify=pinChanged) + + @Slot() + def signIn(self): + def start(): + return self.plex.create_pin() + self._work("pin", start) + + def _poll_pin(self, pin): + self._pin_code = pin.get("code", "") + self.pinChanged.emit() + pin_id = pin["id"] + + def wait(): + for _ in range(300): + time.sleep(2) + p = self.plex.check_pin(pin_id) + if p.get("authToken"): + return p["authToken"] + if getattr(self, "_pin_code", "") != pin.get("code"): + return None + return None + self._work("token", wait) + + def _signed_in(self, token): + self._pin_code = "" + self.pinChanged.emit() + if not token: + return + url = self.cfg["plexUrl"] + + def finish(): + if not self.plex.probe(url, token): + raise PlexError(f"Signed in, but the server at {url} didn't answer") + self.cfg["plexToken"] = token + self.cfg["plexUser"] = self.plex.username(token) + secs = self.plex.music_sections() + return secs + self._work("sections", finish) + + def _sections(self, secs): + if not secs: + self.toast.emit("No music library on that Plex server") + return + # The phone uses the "Music" library; prefer the one at Flacs if there are several. + pick = next((s for s in secs if any("Flacs" in l for l in s["locations"])), secs[0]) + self.cfg["musicSection"] = pick["key"] + self.cfg["sectionLocations"] = pick["locations"] + config.save(self.cfg) + self.toast.emit(f"Connected to Plex — {pick['title']}") + self.statusChanged.emit() + self.refresh() + + @Slot() + def cancelSignIn(self): + self._pin_code = "" + self.pinChanged.emit() + + def _get_signed_in(self): + return self.plex.signed_in and bool(self.cfg.get("musicSection")) + + signedIn = Property(bool, _get_signed_in, notify=statusChanged) + diff --git a/stemroller/player/mpris.py b/stemroller/player/mpris.py new file mode 100644 index 0000000..930d344 --- /dev/null +++ b/stemroller/player/mpris.py @@ -0,0 +1,171 @@ +"""MPRIS on the session bus: media keys, the desktop's media controls, and KDE Connect on the phone.""" + +import hashlib + +from PySide6.QtCore import ClassInfo, Property, QObject, Slot +from PySide6.QtDBus import QDBusAbstractAdaptor, QDBusConnection, QDBusMessage, QDBusObjectPath + +PATH = "/org/mpris/MediaPlayer2" +ROOT_IFACE = "org.mpris.MediaPlayer2" +PLAYER_IFACE = "org.mpris.MediaPlayer2.Player" + + +@ClassInfo({"D-Bus Interface": ROOT_IFACE}) +class _Root(QDBusAbstractAdaptor): + def __init__(self, parent, window_raise, quit_): + super().__init__(parent) + self._raise, self._quit = window_raise, quit_ + + @Slot() + def Raise(self): + self._raise() + + @Slot() + def Quit(self): + self._quit() + + CanQuit = Property(bool, lambda self: True) + CanRaise = Property(bool, lambda self: True) + HasTrackList = Property(bool, lambda self: False) + Identity = Property(str, lambda self: "StemRoller Player") + DesktopEntry = Property(str, lambda self: "stemroller-player") + SupportedUriSchemes = Property("QStringList", lambda self: []) + SupportedMimeTypes = Property("QStringList", lambda self: []) + + +@ClassInfo({"D-Bus Interface": PLAYER_IFACE}) +class _Player(QDBusAbstractAdaptor): + def __init__(self, parent, mpris): + super().__init__(parent) + self.m = mpris + + @Slot() + def Next(self): + self.m.player.next() + + @Slot() + def Previous(self): + self.m.player.previous() + + @Slot() + def Pause(self): + self.m.engine.pause() + + @Slot() + def PlayPause(self): + self.m.player.toggle() + + @Slot() + def Stop(self): + self.m.engine.pause() + + @Slot() + def Play(self): + if not self.m.engine.playing: + self.m.player.toggle() + + @Slot("qlonglong") + def Seek(self, offset_us): + self.m.player.seek(self.m.engine.position() + offset_us / 1e6) + + @Slot(QDBusObjectPath, "qlonglong") + def SetPosition(self, track_id, position_us): + self.m.player.seek(position_us / 1e6) + + @Slot(str) + def OpenUri(self, uri): + pass + + def _status(self): + s = self.m.player._get_status() + return "Playing" if s in ("playing", "buffering") or (s == "loading" and self.m.engine.playing) else \ + "Paused" if self.m.player.current() else "Stopped" + + def _volume(self): + return float(self.m.engine.volume) + + def _set_volume(self, v): + self.m.engine.setVolume(max(0.0, min(1.0, v))) + + PlaybackStatus = Property(str, _status) + LoopStatus = Property(str, lambda self: {"off": "None", "all": "Playlist", "one": "Track"}[self.m.player.repeat]) + Rate = Property(float, lambda self: 1.0) + Shuffle = Property(bool, lambda self: self.m.player.shuffle) + Metadata = Property("QVariantMap", lambda self: self.m.metadata()) + Volume = Property(float, _volume, _set_volume) + Position = Property("qlonglong", lambda self: int(self.m.engine.position() * 1e6)) + MinimumRate = Property(float, lambda self: 1.0) + MaximumRate = Property(float, lambda self: 1.0) + CanGoNext = Property(bool, lambda self: bool(self.m.player.queue)) + CanGoPrevious = Property(bool, lambda self: bool(self.m.player.queue)) + CanPlay = Property(bool, lambda self: bool(self.m.player.queue)) + CanPause = Property(bool, lambda self: True) + CanSeek = Property(bool, lambda self: True) + CanControl = Property(bool, lambda self: True) + + +class Mpris(QObject): + def __init__(self, player, engine, window_raise, quit_, parent=None): + super().__init__(parent) + self.player, self.engine = player, engine + self._root = _Root(self, window_raise, quit_) + self._adaptor = _Player(self, self) + self.bus = QDBusConnection.sessionBus() + self.ok = self.bus.isConnected() and self.bus.registerObject(PATH, self) and \ + self.bus.registerService("org.mpris.MediaPlayer2.stemroller_player") + self._last = {} + player.changed.connect(self._changed) + player.mixChanged.connect(self._changed) + engine.volumeChanged.connect(self._changed) + engine.playingChanged.connect(self._changed) + + def metadata(self): + t = self.player.current() + if not t: + return {"mpris:trackid": QDBusObjectPath("/org/mpris/MediaPlayer2/TrackList/NoTrack")} + artist = t["artist"] + label = self.player._get_preset_label() + if label and label != "Full Mix": + artist = f"{artist} · {label}" # the mix rides on the artist line, as on the phone + md = { + "mpris:trackid": QDBusObjectPath("/stemroller/track/t" + hashlib.sha1(t["key"].encode()).hexdigest()[:16]), + "mpris:length": int((self.engine.duration or t.get("durationMs", 0) / 1000) * 1e6), + "xesam:title": t["title"], + "xesam:artist": [artist], + "xesam:album": t["album"], + "xesam:albumArtist": [t.get("albumArtist") or t["artist"]], + } + art = self.player.plex.art_url(t.get("thumb"), 600) or t.get("_cover", "") + if art: + md["mpris:artUrl"] = art + if t.get("index"): + md["xesam:trackNumber"] = t["index"] + return md + + def _changed(self): + if not self.ok: + return + now = { + "PlaybackStatus": self._adaptor._status(), + "LoopStatus": self._adaptor.LoopStatus, + "Shuffle": self.player.shuffle, + "Volume": float(self.engine.volume), + "Metadata": self.metadata(), + "CanGoNext": bool(self.player.queue), + "CanGoPrevious": bool(self.player.queue), + "CanPlay": bool(self.player.queue), + } + diff = {k: v for k, v in now.items() if k == "Metadata" and _md_key(v) != _md_key(self._last.get(k)) or + k != "Metadata" and self._last.get(k) != v} + self._last = now + if not diff: + return + msg = QDBusMessage.createSignal(PATH, "org.freedesktop.DBus.Properties", "PropertiesChanged") + msg.setArguments([PLAYER_IFACE, diff, []]) + self.bus.send(msg) + + +def _md_key(md): + if not md: + return None + return tuple((k, str(v.path()) if isinstance(v, QDBusObjectPath) else repr(v)) for k, v in sorted(md.items())) diff --git a/stemroller/player/player.py b/stemroller/player/player.py new file mode 100644 index 0000000..12af211 --- /dev/null +++ b/stemroller/player/player.py @@ -0,0 +1,601 @@ +"""The queue and the mix: what plays, where its audio comes from, and how loud each stem is.""" + +import hashlib +import json +import math +import os +import random +import shutil +import subprocess +import threading +import urllib.request + +from PySide6.QtCore import Property, QObject, QTimer, Signal, Slot + +from . import config +from .engine import Source +from .stems import COLORS, sort_names + +UNITY = 0.8 # stem slider position for 0 dB (the phone uses the same taper) +WAVE_BUCKETS = 240 + + +def stem_taper(v): + return (max(0.0, min(1.0, v)) / UNITY) ** 2 + + +# One-click mixes, as on the phone. A preset is a function of the stems a song has, or None +# when the song lacks what it needs. +PRESETS = [ + ("Full Mix", lambda n: {}), + ("Karaoke", lambda n: {"vocals": {"muted": True}} if "vocals" in n else None), + ("A Cappella", lambda n: {"vocals": {"solo": True}} if "vocals" in n else None), + ("No Drums", lambda n: {"drums": {"muted": True}} if "drums" in n else None), + ("Rhythm", lambda n: {"drums": {"solo": True}, "bass": {"solo": True}} if "drums" in n and "bass" in n else None), + ("No Guitar", lambda n: {"guitar": {"muted": True}} if "guitar" in n else None), + ("No Bass", lambda n: {"bass": {"muted": True}} if "bass" in n else None), +] + + +def _setting(mix, name): + s = mix.get(name, {}) + return s.get("level", UNITY), bool(s.get("muted")), bool(s.get("solo")) + + +def _normalized(mix): + out = {} + for name, s in mix.items(): + level, muted, solo = s.get("level", UNITY), bool(s.get("muted")), bool(s.get("solo")) + if abs(level - UNITY) > 1e-3 or muted or solo: + out[name] = (round(level, 3), muted, solo) + return out + + +class Player(QObject): + changed = Signal() # track, queue, play state + mixChanged = Signal() + waveChanged = Signal() + toast = Signal(str) + _loaded = Signal(int, object, object) # token, Source or error, track + _wave = Signal(int, object) + + def __init__(self, cfg, plex, stems, engine, parent=None): + super().__init__(parent) + self.cfg, self.plex, self.server, self.engine = cfg, plex, stems, engine + self.library = None + self.queue: list[dict] = [] + self.index = -1 + self._unshuffled = None + self.shuffle = False + self.repeat = "off" # off | all | one + self.mix: dict[str, dict] = {} + self.names: list[str] = [] + self.source_kind = "" # stems | original + self._token = 0 + self._loading = False + self._wave_raw = None # {"stems": {name: [..]}} or {"db": [..]} + self._scrobbled = False + self._pending_seek = 0.0 + self._queue_dirty = False + self._loaded.connect(self._on_loaded) + self._wave.connect(self._on_wave) + engine.ended.connect(self._on_ended) + engine.playingChanged.connect(self._on_play_state) + engine.bufferingChanged.connect(self.changed) + engine.setVolume(cfg.get("volume", 0.8)) + engine.volumeChanged.connect(self._save_soon) + self._report = QTimer(self, interval=10_000) + self._report.timeout.connect(self._tick) + self._report.start() + self._saver = QTimer(self, interval=1500, singleShot=True) + self._saver.timeout.connect(self.save) + self._restore() + + # ---- state ------------------------------------------------------------------------- + # The queue can be the whole library, so it lives in its own file, written off the GUI + # thread and only when it changes; the small state (position, mix) saves often. + QUEUE_PATH = os.path.join(config.CONFIG_DIR, "player-queue.json") + QUEUE_KEYS = ("key", "title", "artist", "albumArtist", "album", "albumKey", "artistKey", "year", "index", "disc", + "durationMs", "thumb", "partFile", "partKey", "codec", "stemKey", "_cover") + + def _restore(self): + st = self.cfg.get("state") or {} + try: + with open(self.QUEUE_PATH) as f: + q = json.load(f) + self.queue, self._unshuffled = q.get("queue") or [], q.get("unshuffled") + except (OSError, ValueError): + self.queue, self._unshuffled = st.get("queue") or [], st.get("unshuffled") + self.index = st.get("index", -1) if self.queue else -1 + self.shuffle = bool(st.get("shuffle")) + self.repeat = st.get("repeat", "off") + self.mix = st.get("mix") or {} + self._pending_seek = float(st.get("position") or 0) + if 0 <= self.index < len(self.queue): + QTimer.singleShot(0, lambda: self._load(self.index, play=False, start=self._pending_seek)) + + def save(self, wait=False): + self.cfg["volume"] = round(self.engine.volume, 3) + self.cfg["state"] = { + "index": self.index, "shuffle": self.shuffle, "repeat": self.repeat, "mix": self.mix, + "position": round(self.engine.position() if self.engine.duration else self._pending_seek, 2), + } + config.save(self.cfg) + if self._queue_dirty: + self._queue_dirty = False + slim = lambda ts: [{k: t[k] for k in self.QUEUE_KEYS if k in t} for t in ts] if ts is not None else None + data = {"queue": slim(self.queue), "unshuffled": slim(self._unshuffled)} + + def write(): + tmp = self.QUEUE_PATH + ".tmp" + with open(tmp, "w") as f: + json.dump(data, f) + os.replace(tmp, self.QUEUE_PATH) + t = threading.Thread(target=write, daemon=not wait) + t.start() + if wait: + t.join() + + def _save_soon(self): + self._saver.start() + + def current(self): + return self.queue[self.index] if 0 <= self.index < len(self.queue) else None + + def current_key(self): + t = self.current() + return t["key"] if t else "" + + # ---- queue --------------------------------------------------------------------------- + def play_tracks(self, tracks, start=0, shuffle=False): + tracks = [dict(t) for t in tracks] + if not tracks: + return + self._unshuffled = list(tracks) if shuffle else None + if shuffle: + first = tracks.pop(start) + random.shuffle(tracks) + tracks.insert(0, first) + start = 0 + self.shuffle = shuffle + self.queue = tracks + if not self.cfg.get("keepMix"): + self.mix = {} + self._load(start, play=True) + self._queue_changed() + + def add_to_queue(self, tracks): + self.queue += [dict(t) for t in tracks] + if self.index < 0: + self._load(0, play=True) + self._queue_changed() + + def play_next(self, tracks): + at = self.index + 1 + self.queue[at:at] = [dict(t) for t in tracks] + if self.index < 0: + self._load(0, play=True) + self._queue_changed() + + @Slot(int) + def removeAt(self, i): + if not (0 <= i < len(self.queue)): + return + del self.queue[i] + if i < self.index: + self.index -= 1 + elif i == self.index: + if self.queue: + self._load(min(i, len(self.queue) - 1), play=self.engine.playing) + else: + self.index = -1 + self.engine.clear() + self._queue_changed() + + @Slot() + def clearQueue(self): + cur = self.current() + self.queue = [cur] if cur else [] + self.index = 0 if cur else -1 + self._unshuffled = None + self._queue_changed() + + @Slot(int) + def skipTo(self, i): + if 0 <= i < len(self.queue): + self._load(i, play=True) + + def _queue_changed(self): + self._queue_dirty = True + if self.library: + self.library.update_queue() + self.changed.emit() + self._save_soon() + + # ---- transport ------------------------------------------------------------------------- + @Slot() + def toggle(self): + if self.engine.duration: + self.engine.toggle() + elif self.current() and not self._loading: + self._load(self.index, play=True, start=self._pending_seek) + + @Slot() + def next(self): + if not self.queue: + return + i = self.index + 1 + if i >= len(self.queue): + if self.repeat != "all": + return + i = 0 + self._load(i, play=True) + + @Slot() + def previous(self): + if not self.queue: + return + if self.engine.position() > 3 or self.index <= 0: + self.engine.seek(0) + return + self._load(self.index - 1, play=True) + + @Slot(float) + def seek(self, seconds): + if self.engine.duration: + self.engine.seek(max(0.0, min(seconds, self.engine.duration - 0.25))) + else: + self._pending_seek = seconds + + @Slot() + def toggleShuffle(self): + cur = self.current() + if not self.shuffle: + self._unshuffled = list(self.queue) + rest = [t for i, t in enumerate(self.queue) if i != self.index] + random.shuffle(rest) + self.queue = ([cur] if cur else []) + rest + self.index = 0 if cur else -1 + self.shuffle = True + else: + if self._unshuffled: + self.queue = self._unshuffled + keys = [t["key"] for t in self.queue] + self.index = keys.index(cur["key"]) if cur and cur["key"] in keys else 0 + self._unshuffled = None + self.shuffle = False + self._queue_changed() + + @Slot() + def cycleRepeat(self): + self.repeat = {"off": "all", "all": "one", "one": "off"}[self.repeat] + self.changed.emit() + self._save_soon() + + def _on_ended(self): + cur = self.current() + if cur and not self._scrobbled: + self._scrobbled = True + threading.Thread(target=self.plex.scrobble, args=(cur["key"],), daemon=True).start() + if self.repeat == "one": + self._load(self.index, play=True) + elif self.index + 1 < len(self.queue) or self.repeat == "all": + self.next() + else: + self.engine.seek(0) + self.changed.emit() + + def _on_play_state(self): + self._report_state("playing" if self.engine.playing else "paused") + self.changed.emit() + self._save_soon() + + # ---- loading ------------------------------------------------------------------------------ + def _load(self, i, play=True, start=0.0): + """Opens queue[i] off the GUI thread; a newer request makes older ones moot.""" + if not (0 <= i < len(self.queue)): + return + if self.engine.playing and self.current(): + self._report_state("stopped") + self._token += 1 + token = self._token + self.index = i + self._loading = True + self._scrobbled = False + self._wave_raw = None + track = self.queue[i] + if not self.cfg.get("keepMix") and start == 0.0: + self.mix = {} + self.engine.pause() + if self.library: + self.library.model.set_playing(track["key"], i) + self.changed.emit() + self.waveChanged.emit() + self._pending_seek = start + + def work(): + try: + src, entry = self._open(track) + self._loaded.emit(token, (src, play, start, entry), track) + except Exception as e: # noqa: BLE001 - reported, then skipped + self._loaded.emit(token, e, track) + threading.Thread(target=work, daemon=True).start() + + def _open(self, track): + entry = self.server.index.by_key.get(track.get("stemKey") or "") or self.server.find(track) + if entry and "_cover" not in track: + track["_cover"] = self._cover(entry) + if entry: + stems = {s["name"]: s for s in entry["stems"]} + names = sort_names(list(stems)) + paths = [self.server.local_path(entry, stems[n]) or self._download(self.server.file_url(entry, stems[n]), stems[n]["file"]) + for n in names] + return Source(names, paths), entry + return Source(["mix"], [self._original_path(track)]), None + + def _cover(self, entry): + """The album folder's own cover on the music share: art for songs Plex doesn't know.""" + root = self.cfg.get("musicDir", "") + folder = os.path.join(root, os.path.dirname(entry.get("source", ""))) if root else "" + try: + pics = [f for f in os.listdir(folder) if f.lower().endswith((".jpg", ".jpeg", ".png"))] + except OSError: + return "" + if pics: + pics.sort(key=lambda f: (not f.lower().startswith(("cover", "folder", "front")), f.lower())) + return "file://" + urllib.request.pathname2url(os.path.join(folder, pics[0])) + # no picture file: the art embedded in the song itself, pulled out once by ffmpeg + src = os.path.join(root, entry["source"]) + out = os.path.join(config.CACHE_DIR, "art", hashlib.sha1(folder.encode()).hexdigest() + ".jpg") + if not os.path.exists(out) and os.path.exists(src) and shutil.which("ffmpeg"): + os.makedirs(os.path.dirname(out), exist_ok=True) + subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", src, "-an", "-frames:v", "1", "-vf", "scale=600:-2", out], + stdin=subprocess.DEVNULL, capture_output=True, timeout=20) + return "file://" + urllib.request.pathname2url(out) if os.path.exists(out) else "" + + def _original_path(self, track): + """The file on the music share when it's mounted, else a download from Plex.""" + pf = track.get("partFile") or "" + local = self.cfg.get("musicDir", "") + if pf and local and os.path.isdir(local): + for loc in self.cfg.get("sectionLocations") or []: + if pf.startswith(loc.rstrip("/") + "/"): + p = os.path.join(local, pf[len(loc.rstrip("/")) + 1:]) + if os.path.exists(p): + return p + parts = pf.replace("\\", "/").split("/") + for i in range(1, len(parts)): + p = os.path.join(local, *parts[i:]) + if os.path.exists(p): + return p + if not track.get("partKey"): + raise OSError(f"No file for {track.get('title')}") + return self._download(self.plex.part_url(track["partKey"]), os.path.basename(pf) or "track") + + def _download(self, url, name): + d = os.path.join(config.CACHE_DIR, "files") + os.makedirs(d, exist_ok=True) + ext = os.path.splitext(name)[1] or ".bin" + path = os.path.join(d, hashlib.sha1(url.split("X-Plex-Token")[0].encode()).hexdigest() + ext) + if os.path.exists(path): + os.utime(path) + return path + tmp = path + ".part" + req = urllib.request.Request(url, headers={"X-Stem-Token": self.cfg["stemToken"]} if self.cfg.get("stemToken") else {}) + with urllib.request.urlopen(req, timeout=30) as r, open(tmp, "wb") as f: + while chunk := r.read(1 << 20): + f.write(chunk) + os.replace(tmp, path) + self._trim_cache(d) + return path + + @staticmethod + def _trim_cache(d, limit=4 << 30): + files = [os.path.join(d, f) for f in os.listdir(d) if not f.endswith(".part")] + files.sort(key=lambda p: os.path.getmtime(p)) + total = sum(os.path.getsize(p) for p in files) + while files and total > limit: + p = files.pop(0) + total -= os.path.getsize(p) + os.remove(p) + + def _on_loaded(self, token, result, track): + if token != self._token: + if not isinstance(result, Exception): + result[0].close() + return + self._loading = False + if isinstance(result, Exception): + self.toast.emit(f"Couldn't play “{track.get('title')}”: {result}") + self.changed.emit() + if self.index + 1 < len(self.queue): + QTimer.singleShot(800, lambda t=token: t == self._token and self.next()) + return + src, play, start, entry = result + self.names = src.names + self.source_kind = "stems" if entry else "original" + self.engine.set_source(src, start, play=play) + self._push_mix() + self.changed.emit() + self._load_wave(token, track, entry) + self._save_soon() + + def _load_wave(self, token, track, entry): + def work(): + w = None + if entry: + st = self.server.peaks(entry, WAVE_BUCKETS) + w = {"stems": st} if st else None + if w is None: + try: + db = self.plex.loudness(track["key"], WAVE_BUCKETS) + w = {"db": db} if db else None + except Exception: # noqa: BLE001 - no waveform is fine + w = None + self._wave.emit(token, w) + threading.Thread(target=work, daemon=True).start() + + def _on_wave(self, token, w): + if token == self._token: + self._wave_raw = w + self.waveChanged.emit() + + # ---- mix ----------------------------------------------------------------------------------- + def _push_mix(self): + any_solo = any(_setting(self.mix, n)[2] for n in self.names) + gains = [] + for n in self.names: + level, muted, solo = _setting(self.mix, n) + gains.append(0.0 if (any_solo and not solo) or muted else stem_taper(level)) + self.engine.set_gains(gains) + self.mixChanged.emit() + self.waveChanged.emit() + self._save_soon() + + def _edit(self, i, **kw): + if 0 <= i < len(self.names): + n = self.names[i] + self.mix[n] = {**self.mix.get(n, {}), **kw} + self._push_mix() + + @Slot(int, float) + def setLevel(self, i, v): + self._edit(i, level=max(0.0, min(1.0, v))) + + @Slot(int) + def toggleMute(self, i): + if 0 <= i < len(self.names): + self._edit(i, muted=not _setting(self.mix, self.names[i])[1]) + + @Slot(int) + def toggleSolo(self, i): + if 0 <= i < len(self.names): + self._edit(i, solo=not _setting(self.mix, self.names[i])[2]) + + @Slot(int) + def applyPreset(self, p): + m = PRESETS[p][1](self.names) + if m is not None: + self.mix = {k: dict(v) for k, v in m.items()} + self._push_mix() + + @Slot() + def toggleVocals(self): + """Karaoke switch: vocals off, or back to the full mix.""" + if "vocals" not in self.names: + return + self.applyPreset(0 if self._preset_index() == 1 else 1) + + def _preset_index(self): + m = _normalized(self.mix) + for i, (_, build) in enumerate(PRESETS): + b = build(self.names) + if b is not None and _normalized(b) == m: + return i + return -1 + + # ---- reporting to Plex (play counts, "now playing" on the server) ------------------------------- + def _report_state(self, state): + cur = self.current() + if cur: + pos = self.engine.position() * 1000 + threading.Thread(target=self.plex.timeline, args=(cur, state, pos), daemon=True).start() + + def _tick(self): + if self.engine.playing: + self._report_state("playing") + cur, d = self.current(), self.engine.duration + if cur and d and not self._scrobbled and self.engine.position() > 0.9 * d: + self._scrobbled = True + threading.Thread(target=self.plex.scrobble, args=(cur["key"],), daemon=True).start() + self.save() + + def shutdown(self): + self._report_state("stopped") + self.save(wait=True) + + # ---- QML properties ------------------------------------------------------------------------- + def _t(self, k, default=""): + t = self.current() + return t.get(k, default) if t else default + + def _get_track(self): + t = self.current() + if not t: + return {} + return {"title": t["title"], "artist": t["artist"], "album": t["album"], "year": t.get("year") or 0, + "art": self.plex.art_url(t.get("thumb"), 600) or t.get("_cover", ""), "durationMs": t.get("durationMs", 0), + "codec": t.get("codec", ""), "key": t["key"]} + + def _get_status(self): + if self._loading: + return "loading" + if self.engine.buffering: + return "buffering" + return "playing" if self.engine.playing else ("paused" if self.current() else "") + + def _get_stems(self): + any_solo = any(_setting(self.mix, n)[2] for n in self.names) + out = [] + for n in self.names: + level, muted, solo = _setting(self.mix, n) + out.append({"name": n, "label": "Original mix" if n == "mix" else n.capitalize(), + "color": COLORS.get(n, "#8E8E93"), "level": level, "muted": muted, "solo": solo, + "audible": not muted and (solo or not any_solo), "db": 20 * math.log10(max(1e-6, stem_taper(level)))}) + return out + + def _get_presets(self): + cur = self._preset_index() + return [{"label": label, "usable": build(self.names) is not None and self.source_kind == "stems", "active": i == cur} + for i, (label, build) in enumerate(PRESETS)] + + def _get_preset_label(self): + if self.source_kind != "stems": + return "" + i = self._preset_index() + return PRESETS[i][0] if i >= 0 else "Custom Mix" + + def _get_wave(self): + """0..1 loudness per bucket for the current mix: stems weighted by their faders.""" + w = self._wave_raw + if not w: + return [] + if "stems" in w: + any_solo = any(_setting(self.mix, n)[2] for n in self.names) + gains = {} + for n in w["stems"]: + level, muted, solo = _setting(self.mix, n) + gains[n] = 0.0 if (any_solo and not solo) or muted else stem_taper(level) + size = max(len(a) for a in w["stems"].values()) + out = [] + for i in range(size): + e = sum((a[i] if i < len(a) else 0.0) ** 2 * gains.get(n, 1.0) ** 2 for n, a in w["stems"].items()) + out.append(_norm_db(20 * math.log10(math.sqrt(e) + 1e-6))) + return out + return [_norm_db(v) for v in w["db"]] + + def _get_queue_info(self): + return {"index": self.index, "count": len(self.queue)} + + track = Property("QVariantMap", _get_track, notify=changed) + status = Property(str, _get_status, notify=changed) + stems = Property("QVariantList", _get_stems, notify=mixChanged) + presets = Property("QVariantList", _get_presets, notify=mixChanged) + presetLabel = Property(str, _get_preset_label, notify=mixChanged) + sourceKind = Property(str, lambda self: self.source_kind, notify=changed) + wave = Property("QVariantList", _get_wave, notify=waveChanged) + shuffleOn = Property(bool, lambda self: self.shuffle, notify=changed) + repeatMode = Property(str, lambda self: self.repeat, notify=changed) + queueInfo = Property("QVariantMap", _get_queue_info, notify=changed) + keepMix = Property(bool, lambda self: bool(self.cfg.get("keepMix")), notify=mixChanged) + + @Slot(bool) + def setKeepMix(self, on): + self.cfg["keepMix"] = on + self.mixChanged.emit() + self._save_soon() + + +def _norm_db(db): + """Loudness to bar height, as on the phone: -34 dB and below is a stub, -6 dB and up full.""" + return max(0.06, min(1.0, (db + 34) / 28)) diff --git a/stemroller/player/plex.py b/stemroller/player/plex.py new file mode 100644 index 0000000..19b1f32 --- /dev/null +++ b/stemroller/player/plex.py @@ -0,0 +1,275 @@ +"""Plex Media Server and plex.tv calls (standard library only; call from worker threads).""" + +import json +import platform +import urllib.error +import urllib.parse +import urllib.request + +PRODUCT = "StemRoller Player" +PAGE = 1000 + + +class PlexError(Exception): + pass + + +class NotSignedIn(PlexError): + def __init__(self): + super().__init__("Not signed in to Plex") + + +def _track(m: dict) -> dict: + """A Plex track as the player's flat dict.""" + media = (m.get("Media") or [{}])[0] + part = (media.get("Part") or [{}])[0] + artist = m.get("originalTitle") or m.get("grandparentTitle") or "" + return { + "key": str(m.get("ratingKey", "")), + "title": m.get("title", ""), + "artist": artist, + "albumArtist": m.get("grandparentTitle", ""), + "album": m.get("parentTitle", ""), + "albumKey": str(m.get("parentRatingKey", "")), + "artistKey": str(m.get("grandparentRatingKey", "")), + "year": m.get("parentYear") or m.get("year") or 0, + "index": m.get("index") or 0, + "disc": m.get("parentIndex") or 0, + "durationMs": m.get("duration") or media.get("duration") or part.get("duration") or 0, + "thumb": m.get("thumb") or m.get("parentThumb") or m.get("grandparentThumb") or "", + "partFile": part.get("file", ""), + "partKey": part.get("key", ""), + "codec": media.get("audioCodec", ""), + "plays": m.get("viewCount") or 0, + "addedAt": m.get("addedAt") or 0, + "playlistItemID": m.get("playlistItemID"), + } + + +def _album(m: dict) -> dict: + return { + "key": str(m.get("ratingKey", "")), + "title": m.get("title", ""), + "artist": m.get("parentTitle", ""), + "artistKey": str(m.get("parentRatingKey", "")), + "year": m.get("year") or 0, + "tracks": m.get("leafCount") or 0, + "thumb": m.get("thumb", ""), + "addedAt": m.get("addedAt") or 0, + "genre": ", ".join(g.get("tag", "") for g in (m.get("Genre") or [])[:2]), + } + + +def _artist(m: dict) -> dict: + return { + "key": str(m.get("ratingKey", "")), + "title": m.get("title", ""), + "sortTitle": m.get("titleSort") or m.get("title", ""), + "albums": m.get("childCount") or 0, + "thumb": m.get("thumb", ""), + "genre": ", ".join(g.get("tag", "") for g in (m.get("Genre") or [])[:2]), + } + + +def _playlist(m: dict) -> dict: + return { + "key": str(m.get("ratingKey", "")), + "title": m.get("title", ""), + "tracks": m.get("leafCount") or 0, + "durationMs": m.get("duration") or 0, + "thumb": m.get("composite") or m.get("thumb", ""), + "smart": bool(m.get("smart")), + "updatedAt": m.get("updatedAt") or 0, + } + + +class Plex: + def __init__(self, config): + self.cfg = config + + @property + def base(self): + return self.cfg["plexUrl"].rstrip("/") + + @property + def token(self): + return self.cfg.get("plexToken", "") + + @property + def signed_in(self): + return bool(self.token) + + @property + def section(self): + return self.cfg.get("musicSection", "") + + def _headers(self, token=None): + h = { + "Accept": "application/json", + "X-Plex-Product": PRODUCT, + "X-Plex-Version": "1.0", + "X-Plex-Client-Identifier": self.cfg["clientId"], + "X-Plex-Platform": "Linux", + "X-Plex-Platform-Version": platform.release(), + "X-Plex-Device": "Desktop", + "X-Plex-Device-Name": f"{PRODUCT} ({platform.node()})", + } + if token: + h["X-Plex-Token"] = token + return h + + def _call(self, url, method="GET", token=None, headers=None, timeout=20): + req = urllib.request.Request(url, method=method, headers={**self._headers(token), **(headers or {})}, + data=b"" if method in ("POST", "PUT") else None) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + body = r.read() + except urllib.error.HTTPError as e: + raise PlexError(f"Plex answered {e.code}") from e + except (urllib.error.URLError, TimeoutError, OSError) as e: + raise PlexError(f"Can't reach Plex: {getattr(e, 'reason', e)}") from e + if not body.strip() or not body.lstrip().startswith(b"{"): + return {} + return json.loads(body) + + def _url(self, path, **params): + q = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None}) + return f"{self.base}{path}" + (f"?{q}" if q else "") + + def get(self, path, start=None, size=None, **params): + if not self.signed_in: + raise NotSignedIn() + extra = {} + if start is not None: + extra["X-Plex-Container-Start"] = str(start) + if size is not None: + extra["X-Plex-Container-Size"] = str(size) + return self._call(self._url(path, **params), token=self.token, headers=extra).get("MediaContainer", {}) + + def send(self, method, path, **params): + if not self.signed_in: + raise NotSignedIn() + return self._call(self._url(path, **params), method=method, token=self.token).get("MediaContainer", {}) + + def all(self, path, progress=None, **params): + """Pages through a listing; Plex caps one response on big libraries.""" + out, start = [], 0 + while True: + page = self.get(path, start=start, size=PAGE, **params) + items = page.get("Metadata") or [] + out += items + start += len(items) + total = page.get("totalSize") or page.get("size") or 0 + if progress: + progress(start, total) + if not items or start >= total: + return out + + # ---- server ------------------------------------------------------------------ + def music_sections(self): + dirs = self.get("/library/sections").get("Directory") or [] + return [{"key": d["key"], "title": d.get("title", ""), "locations": [l.get("path", "") for l in d.get("Location") or []]} + for d in dirs if d.get("type") == "artist"] + + def machine_id(self): + mid = self._call(self._url("/identity")).get("MediaContainer", {}).get("machineIdentifier") + if not mid: + raise PlexError("Not a Plex server") + return mid + + # ---- library ----------------------------------------------------------------- + def tracks(self, progress=None): + return [_track(m) for m in self.all(f"/library/sections/{self.section}/all", progress, type=10, sort="titleSort")] + + def albums(self): + return [_album(m) for m in self.all(f"/library/sections/{self.section}/all", type=9, sort="titleSort")] + + def artists(self): + return [_artist(m) for m in self.all(f"/library/sections/{self.section}/all", type=8, sort="titleSort")] + + def playlists(self): + return [_playlist(m) for m in self.get("/playlists", playlistType="audio").get("Metadata") or []] + + def playlist_tracks(self, key): + return [_track(m) for m in self.all(f"/playlists/{key}/items")] + + def album_tracks(self, key): + return [_track(m) for m in self.get(f"/library/metadata/{key}/children").get("Metadata") or []] + + def artist_tracks(self, key): + return [_track(m) for m in self.get(f"/library/metadata/{key}/allLeaves").get("Metadata") or []] + + def loudness(self, track_key, samples): + """Plex's loudness analysis in dB (what Plexamp draws), or None if not analysed.""" + meta = (self.get(f"/library/metadata/{track_key}").get("Metadata") or [{}])[0] + part = (((meta.get("Media") or [{}])[0]).get("Part") or [{}])[0] + stream = next((s for s in part.get("Stream") or [] if s.get("streamType") == 2), None) + if not stream: + return None + try: + levels = self.get(f"/library/streams/{stream['id']}/levels", subsample=samples).get("Level") or [] + except PlexError: + return None + return [float(l.get("v", -60)) for l in levels] or None + + # ---- playlists ----------------------------------------------------------------- + def _library_uri(self, keys): + mid = self.cfg.get("plexMachineId") or self.machine_id() + self.cfg["plexMachineId"] = mid + return f"server://{mid}/com.plexapp.plugins.library/library/metadata/{','.join(keys)}" + + def create_playlist(self, title, keys): + c = self.send("POST", "/playlists", type="audio", title=title, smart=0, uri=self._library_uri(keys)) + items = c.get("Metadata") or [] + return _playlist(items[0]) if items else None + + def add_to_playlist(self, key, keys): + self.send("PUT", f"/playlists/{key}/items", uri=self._library_uri(keys)) + + def remove_from_playlist(self, key, item_id): + self.send("DELETE", f"/playlists/{key}/items/{item_id}") + + # ---- reporting --------------------------------------------------------------- + def scrobble(self, key): + try: + self.get("/:/scrobble", key=key, identifier="com.plexapp.plugins.library") + except PlexError: + pass + + def timeline(self, track, state, position_ms): + try: + self.get("/:/timeline", ratingKey=track["key"], key=f"/library/metadata/{track['key']}", state=state, + time=int(position_ms), duration=track.get("durationMs", 0), hasMDE=1) + except PlexError: + pass + + # ---- URLs ---------------------------------------------------------------------- + def art_url(self, thumb, px): + if not thumb or not self.signed_in: + return "" + return self._url("/photo/:/transcode", width=px, height=px, minSize=1, upscale=1, url=thumb, + **{"X-Plex-Token": self.token}) + + def part_url(self, part_key): + return f"{self.base}{part_key}?X-Plex-Token={urllib.parse.quote(self.token)}" + + # ---- plex.tv sign-in ----------------------------------------------------------- + def create_pin(self): + return self._call("https://plex.tv/api/v2/pins?strong=false", method="POST") + + def check_pin(self, pin_id): + return self._call(f"https://plex.tv/api/v2/pins/{pin_id}") + + def username(self, token): + try: + u = self._call("https://plex.tv/api/v2/user", token=token) + return u.get("username") or u.get("title") or "" + except PlexError: + return "" + + def probe(self, url, token): + try: + self._call(url.rstrip("/") + "/library/sections", token=token, timeout=4) + return True + except PlexError: + return False diff --git a/stemroller/player/qml/StemPlayer/Backstage.qml b/stemroller/player/qml/StemPlayer/Backstage.qml new file mode 100644 index 0000000..3b35403 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Backstage.qml @@ -0,0 +1,192 @@ +import QtQuick + +// File: Excel's backstage view. Info, Account (Plex sign-in) and Options. +Rectangle { + id: bs + property var win: Window.window + property string page: "info" + color: "#FFFFFF" + + Rectangle { + id: side + width: 190 + height: parent.height + color: X.green + Column { + width: parent.width + Item { + width: parent.width + height: 64 + Rectangle { anchors.fill: parent; color: bm.containsMouse ? X.greenHover : "transparent" } + Ico { x: 22; anchors.verticalCenter: parent.verticalCenter; name: "back"; ink: "#FFFFFF"; size: 30 } + MouseArea { id: bm; anchors.fill: parent; hoverEnabled: true; onClicked: bs.win.closeBackstage() } + } + Repeater { + model: [["info", "Info"], ["account", "Account"], ["options", "Options"]] + delegate: Item { + required property var modelData + width: side.width + height: 40 + Rectangle { + anchors.fill: parent + color: bs.page === parent.modelData[0] ? X.greenDark : im.containsMouse ? X.greenHover : "transparent" + } + T { x: 26; height: parent.height; text: parent.modelData[1]; color: "#FFFFFF"; font.pixelSize: 15 } + MouseArea { id: im; anchors.fill: parent; hoverEnabled: true; onClicked: bs.page = parent.modelData[0] } + } + } + Item { width: 1; height: 20 } + Item { + width: side.width + height: 40 + Rectangle { anchors.fill: parent; color: qm.containsMouse ? X.greenHover : "transparent" } + T { x: 26; height: parent.height; text: "Close"; color: "#FFFFFF"; font.pixelSize: 15 } + MouseArea { id: qm; anchors.fill: parent; hoverEnabled: true; onClicked: bs.win.close() } + } + } + } + + Item { + x: side.width + 40 + y: 24 + width: parent.width - x - 40 + height: parent.height - y + + T { + id: heading + text: bs.page === "info" ? "Info" : bs.page === "account" ? "Account" : "Options" + font.pixelSize: 38 + font.weight: Font.Light + color: X.ink + height: 56 + } + + // ---- Info ---- + Column { + visible: bs.page === "info" + y: heading.height + 20 + width: parent.width + spacing: 18 + Row { + spacing: 40 + Column { + width: 360 + spacing: 8 + T { text: "Now Playing"; font.pixelSize: 20; color: X.greenText; height: 30 } + Prop { k: "Title"; v: player.track.title || "—" } + Prop { k: "Artist"; v: player.track.artist || "—" } + Prop { k: "Album"; v: player.track.album || "—" } + Prop { k: "Plays from"; v: player.sourceKind === "stems" ? "Stems (" + player.stems.length + ")" : player.sourceKind === "original" ? "Original file" + (player.track.codec ? " (" + player.track.codec.toUpperCase() + ")" : "") : "—" } + Prop { k: "Mix"; v: player.presetLabel || "—" } + Prop { k: "Queue"; v: player.queueInfo.count ? (player.queueInfo.index + 1) + " of " + player.queueInfo.count : "Empty" } + } + Column { + width: 360 + spacing: 8 + T { text: "Properties"; font.pixelSize: 20; color: X.greenText; height: 30 } + Prop { k: "Songs"; v: library.counts.songs.toLocaleString(Qt.locale(), "f", 0) } + Prop { k: "With stems"; v: library.counts.stems.toLocaleString(Qt.locale(), "f", 0) } + Prop { k: "Stems index"; v: library.counts.stemIndex.toLocaleString(Qt.locale(), "f", 0) + " songs" } + Prop { k: "Stem server"; v: (library.counts.stemOnline === true ? "Online · " : library.counts.stemOnline === false ? "Offline · " : "Checking · ") + settings.get("stemUrl") } + Prop { k: "Plex"; v: (library.signedIn ? "Connected · " : "Not connected · ") + settings.get("plexUrl") } + Prop { k: "Media keys"; v: bs.win.mprisOk ? "On (MPRIS)" : "Off" } + } + } + } + + // ---- Account ---- + Column { + visible: bs.page === "account" + y: heading.height + 20 + width: parent.width + spacing: 14 + T { text: "Connected Services"; font.pixelSize: 20; color: X.greenText; height: 30 } + Row { + spacing: 14 + Ico { name: "plex"; size: 40 } + Column { + spacing: 4 + T { text: "Plex Media Server"; font.pixelSize: 15; font.bold: true } + T { text: library.signedIn ? "Connected to " + settings.get("plexUrl") : "Not connected"; color: X.inkSoft } + } + } + Rectangle { + visible: library.pin !== "" + width: 420 + height: 150 + color: "#F3F3F3" + border.color: X.ribbonLine + Column { + anchors.centerIn: parent + spacing: 6 + T { anchors.horizontalCenter: parent.horizontalCenter; text: "Go to plex.tv/link and enter"; font.pixelSize: 14 } + T { + anchors.horizontalCenter: parent.horizontalCenter + text: library.pin + font.family: cellFont + font.pixelSize: 54 + font.bold: true + font.letterSpacing: 10 + color: X.greenText + } + T { anchors.horizontalCenter: parent.horizontalCenter; text: "Waiting for Plex…"; color: X.inkSoft } + } + } + Row { + spacing: 10 + OfficeButton { + text: library.pin !== "" ? "Cancel" : library.signedIn ? "Sign in again" : "Sign in to Plex" + primary: library.pin === "" + onClicked: library.pin !== "" ? library.cancelSignIn() : library.signIn() + } + } + } + + // ---- Options ---- + Column { + visible: bs.page === "options" + y: heading.height + 20 + width: Math.min(parent.width, 640) + spacing: 10 + T { text: "Connections"; font.pixelSize: 20; color: X.greenText; height: 30 } + Opt { id: oPlex; label: "Plex server"; key: "plexUrl" } + Opt { id: oStem; label: "Stem server (stemserve)"; key: "stemUrl" } + T { text: "Folders"; font.pixelSize: 20; color: X.greenText; height: 40; verticalAlignment: Text.AlignBottom } + Opt { id: oStems; label: "Stems share (played directly when mounted)"; key: "stemsDir" } + Opt { id: oMusic; label: "Music share"; key: "musicDir" } + Item { width: 1; height: 8 } + Row { + spacing: 10 + OfficeButton { + text: "Save" + primary: true + onClicked: { + oPlex.save(); oStem.save(); oStems.save(); oMusic.save() + library.refresh() + bs.win.closeBackstage() + } + } + OfficeButton { text: "Cancel"; onClicked: bs.win.closeBackstage() } + } + } + } + + component Prop: Row { + property string k + property string v + spacing: 10 + T { width: 110; text: parent.k; color: X.inkSoft } + T { width: 240; text: parent.v } + } + component Opt: Column { + id: o + property string label + property string key + function save() { settings.set(key, f.text.trim()) } + spacing: 3 + width: parent.width + T { text: o.label; color: X.inkSoft } + XField { id: f; width: o.width; text: settings.get(o.key) || "" } + Connections { target: bs; function onVisibleChanged() { if (bs.visible) f.text = settings.get(o.key) || "" } } + } +} diff --git a/stemroller/player/qml/StemPlayer/CaptionButton.qml b/stemroller/player/qml/StemPlayer/CaptionButton.qml new file mode 100644 index 0000000..f1ee733 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/CaptionButton.qml @@ -0,0 +1,18 @@ +import QtQuick + +Item { + id: c + property string icon + property bool danger: false + property string tip: "" + signal clicked() + width: icon === "pane" ? 40 : 46 + height: parent.height + Rectangle { + anchors.fill: parent + color: cm.pressed ? (c.danger ? "#F1707A" : X.greenDark) : cm.containsMouse ? (c.danger ? "#E81123" : X.greenHover) : "transparent" + } + Ico { anchors.centerIn: parent; name: c.icon; ink: "#FFFFFF"; size: c.icon === "pane" ? 16 : 24 } + MouseArea { id: cm; anchors.fill: parent; hoverEnabled: true; onClicked: c.clicked() } + Tip { target: cm; text: c.tip } +} diff --git a/stemroller/player/qml/StemPlayer/FormulaBar.qml b/stemroller/player/qml/StemPlayer/FormulaBar.qml new file mode 100644 index 0000000..67c3784 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/FormulaBar.qml @@ -0,0 +1,51 @@ +import QtQuick + +// Name box, the ✕ ✓ fx buttons, and the formula of the active cell. +Rectangle { + id: fb + property var win: Window.window + height: 30 + color: "#FFFFFF" + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.ribbonLine } + + Rectangle { + id: nameBox + x: 4 + y: 4 + width: 110 + height: 22 + border.color: "#C6C6C6" + T { + x: 5 + height: parent.height + width: parent.width - 20 + text: fb.win.multiSel ? (fb.win.selBottom - fb.win.selTop + 1) + "R x " + (Math.abs(fb.win.curCol - fb.win.anchorCol) + 1) + "C" + : X.colName(fb.win.curCol) + (fb.win.curRow + 2) + } + Ico { anchors.right: parent.right; anchors.rightMargin: 4; anchors.verticalCenter: parent.verticalCenter; name: "dropdown"; size: 10 } + } + Row { + x: nameBox.x + nameBox.width + 10 + height: parent.height + spacing: 12 + Ico { anchors.verticalCenter: parent.verticalCenter; name: "cancel"; size: 14; opacity: 0.35 } + Ico { anchors.verticalCenter: parent.verticalCenter; name: "check"; size: 14; opacity: 0.35 } + Ico { anchors.verticalCenter: parent.verticalCenter; name: "function"; size: 18 } + } + Rectangle { + x: nameBox.x + nameBox.width + 92 + y: 4 + width: parent.width - x - 6 + height: 22 + border.color: "#C6C6C6" + T { + x: 6 + width: parent.width - 12 + height: parent.height + font.family: cellFont + font.pixelSize: 14 + color: "#000000" + text: fb.win.formulaText + } + } +} diff --git a/stemroller/player/qml/StemPlayer/Ico.qml b/stemroller/player/qml/StemPlayer/Ico.qml new file mode 100644 index 0000000..e0303f3 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Ico.qml @@ -0,0 +1,15 @@ +import QtQuick + +// image://icon/[/], rendered at device pixels. +Image { + property string name: "grid" + property string ink: "" + property int size: 16 + width: size + height: size + source: "image://icon/" + name + (ink ? "/" + ink.replace("#", "") : "") + sourceSize.width: size * Screen.devicePixelRatio + sourceSize.height: size * Screen.devicePixelRatio + smooth: true + asynchronous: false +} diff --git a/stemroller/player/qml/StemPlayer/Main.qml b/stemroller/player/qml/StemPlayer/Main.qml new file mode 100644 index 0000000..f71af52 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Main.qml @@ -0,0 +1,205 @@ +import QtQuick +import QtQuick.Controls.Basic + +Window { + id: win + width: 1440 + height: 900 + minimumWidth: 960 + minimumHeight: 600 + visible: true + title: (player.track.title ? player.track.title + " - " + player.track.artist : "Book1") + ".xlsx - Excel" + color: "#FFFFFF" + flags: Qt.Window | Qt.FramelessWindowHint + + readonly property bool maximized: visibility === Window.Maximized || visibility === Window.FullScreen + function toggleMaximized() { maximized ? showNormal() : showMaximized() } + + // ---- selection: the active cell and the anchor of the range ---- + property int curRow: 0 + property int curCol: 0 + property int anchorRow: 0 + property int anchorCol: 0 + readonly property int selTop: Math.min(curRow, anchorRow) + readonly property int selBottom: Math.max(curRow, anchorRow) + readonly property bool multiSel: curRow !== anchorRow || curCol !== anchorCol + property string formulaText: "" + property var selStats: ({}) + function refreshCell() { + formulaText = library.formula(curRow, curCol) + selStats = multiSel ? library.stats(anchorRow, anchorCol, curRow, curCol) : ({}) + } + onCurRowChanged: cellTimer.restart() + onCurColChanged: cellTimer.restart() + onAnchorRowChanged: cellTimer.restart() + Timer { id: cellTimer; interval: 0; onTriggered: win.refreshCell() } + Connections { + target: library + function onSheetSwitched() { win.curRow = win.anchorRow = 0; win.curCol = win.anchorCol = 0; win.refreshCell() } + function onSheetChanged() { cellTimer.restart() } + function onToast(msg) { messages.show(msg) } + } + Connections { target: player; function onToast(msg) { messages.show(msg) } } + Connections { + target: sheetModel + function onModelReset() { + // new data under the same sheet: keep the selection, inside the rows that exist + var last = Math.max(0, grid.rows - 1) + if (win.curRow > last) win.curRow = last + if (win.anchorRow > last) win.anchorRow = last + cellTimer.restart() + } + } + Component.onCompleted: refreshCell() + + // ---- view options ---- + property bool showMixer: settings.get("showMixer") !== false + property bool gridlines: settings.get("gridlines") !== false + property bool headings: settings.get("headings") !== false + property int zoom: settings.get("zoom") || 100 + property bool mprisOk: false + readonly property bool inPlaylist: library.sheetId.indexOf("playlist:") === 0 + function toggleMixer() { showMixer = !showMixer; settings.set("showMixer", showMixer) } + function setOption(k, v) { win[k] = v; settings.set(k, v) } + function setZoom(z) { zoom = Math.max(50, Math.min(200, z)); settings.set("zoom", zoom) } + + function openBackstage(page) { backstage.page = page; backstage.visible = true } + function closeBackstage() { backstage.visible = false; focusGrid() } + function focusGrid() { grid.forceActiveFocus() } + function focusSearch() { ribbon.focusSearch() } + function selectAll() { anchorRow = 0; anchorCol = 0; curRow = Math.max(0, grid.rows - 1); curCol = Math.max(0, library.columns.length - 1) } + function copySelection() { library.copyCells(anchorRow, anchorCol, curRow, curCol); messages.show("Copied " + (selBottom - selTop + 1) + " rows") } + function sortCurrent(desc) { library.sortTo(curCol, desc) } + function sortColumn(c, desc) { library.sortTo(c, desc) } + function newPlaylist() { plDialog.open() } + function addToPlaylist(name) { library.addToPlaylist(name, selTop, selBottom) } + + // ---- playhead, read once per frame while playing ---- + property real playPos: 0 + property real levelL: 0 + property real levelR: 0 + function seekTo(s) { player.seek(s); playPos = s } + FrameAnimation { + running: engine.playing + onTriggered: { + var s = engine.snapshot() + win.playPos = s[0] + // meters fall back smoothly between peaks + var k = Math.exp(-frameTime / 0.12) + win.levelL = Math.max(s[1], win.levelL * k) + win.levelR = Math.max(s[2], win.levelR * k) + } + } + Connections { + target: engine + function onPlayingChanged() { var s = engine.snapshot(); win.playPos = s[0]; if (!engine.playing) { win.levelL = 0; win.levelR = 0 } } + function onDurationChanged() { win.playPos = engine.snapshot()[0] } + } + Timer { interval: 500; running: !engine.playing; repeat: true; onTriggered: win.playPos = engine.snapshot()[0] } + + // dev hook: --eval runs JavaScript against the window + property string devEval: "" + onDevEvalChanged: if (devEval) { try { console.log("eval:", eval(devEval)) } catch (e) { console.log("eval error:", e) } } + + Shortcut { sequence: "Ctrl+F"; onActivated: win.focusSearch() } + Shortcut { sequence: "Ctrl+Q"; onActivated: win.close() } + Shortcut { sequence: "Media Play"; onActivated: player.toggle() } + Shortcut { sequence: "Ctrl+Right"; context: Qt.ApplicationShortcut; enabled: !grid.activeFocus; onActivated: player.next() } + Shortcut { sequence: "Ctrl+Left"; context: Qt.ApplicationShortcut; enabled: !grid.activeFocus; onActivated: player.previous() } + Shortcut { sequence: "Alt+Left"; onActivated: library.back() } + Shortcut { sequence: "F1"; onActivated: win.openBackstage("info") } + + Column { + anchors.fill: parent + TitleBar { width: parent.width } + Ribbon { id: ribbon; width: parent.width } + MessageBar { id: messages; width: parent.width } + FormulaBar { width: parent.width } + Item { + width: parent.width + height: parent.height - y - tabs.height - status.height + Sheet { + id: grid + width: parent.width - (pane.visible ? pane.width : 0) + height: parent.height + focus: true + } + TaskPane { + id: pane + visible: win.showMixer + anchors.right: parent.right + width: 330 + height: parent.height + } + } + SheetTabs { id: tabs; width: parent.width } + StatusBar { id: status; width: parent.width } + } + + Backstage { + id: backstage + visible: false + y: 32 + width: parent.width + height: parent.height - y + } + + // New Playlist: an Office dialog + Popup { + id: plDialog + modal: true + anchors.centerIn: parent + width: 380 + padding: 0 + onOpened: { plName.text = ""; plName.forceActiveFocus() } + onClosed: win.focusGrid() + background: Rectangle { color: "#FFFFFF"; border.color: "#7A7A7A" } + Overlay.modal: Rectangle { color: Qt.rgba(0, 0, 0, 0.12) } + contentItem: Column { + Rectangle { + width: parent.width + height: 30 + color: "#FFFFFF" + T { x: 10; height: parent.height; text: "New Playlist" } + Ico { anchors.right: parent.right; anchors.rightMargin: 8; anchors.verticalCenter: parent.verticalCenter; name: "close"; size: 18 + MouseArea { anchors.fill: parent; onClicked: plDialog.close() } } + } + Column { + x: 14 + width: parent.width - 28 + spacing: 8 + T { text: (win.selBottom - win.selTop + 1) + " selected row(s) go into a new Plex playlist."; color: X.inkSoft } + T { text: "Name:" } + XField { + id: plName + width: parent.width + onAccepted: okBtn.clicked() + } + Row { + anchors.right: parent.right + spacing: 8 + bottomPadding: 14 + topPadding: 6 + OfficeButton { + id: okBtn + text: "OK" + primary: true + onClicked: { library.newPlaylist(plName.text, win.selTop, win.selBottom); plDialog.close() } + } + OfficeButton { text: "Cancel"; onClicked: plDialog.close() } + } + } + } + } + + // frameless: resize from the edges + ResizeEdge { visible: !win.maximized; edges: Qt.LeftEdge; x: 0; y: 6; width: 5; height: parent.height - 12 } + ResizeEdge { visible: !win.maximized; edges: Qt.RightEdge; x: parent.width - 5; y: 6; width: 5; height: parent.height - 12 } + ResizeEdge { visible: !win.maximized; edges: Qt.TopEdge; x: 6; y: 0; width: parent.width - 12; height: 4 } + ResizeEdge { visible: !win.maximized; edges: Qt.BottomEdge; x: 6; y: parent.height - 4; width: parent.width - 12; height: 4 } + ResizeEdge { visible: !win.maximized; edges: Qt.LeftEdge | Qt.TopEdge; width: 8; height: 8 } + ResizeEdge { visible: !win.maximized; edges: Qt.RightEdge | Qt.TopEdge; x: parent.width - 8; width: 8; height: 8 } + ResizeEdge { visible: !win.maximized; edges: Qt.LeftEdge | Qt.BottomEdge; y: parent.height - 8; width: 8; height: 8 } + ResizeEdge { visible: !win.maximized; edges: Qt.RightEdge | Qt.BottomEdge; x: parent.width - 8; y: parent.height - 8; width: 8; height: 8 } + Rectangle { anchors.fill: parent; color: "transparent"; border.color: X.green; border.width: win.maximized ? 0 : 1 } +} diff --git a/stemroller/player/qml/StemPlayer/MessageBar.qml b/stemroller/player/qml/StemPlayer/MessageBar.qml new file mode 100644 index 0000000..ab7dd45 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/MessageBar.qml @@ -0,0 +1,30 @@ +import QtQuick + +// Excel's yellow message bar, for notices. +Rectangle { + id: mb + property string text: "" + height: text ? 32 : 0 + visible: text !== "" + color: "#FFF4CE" + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: "#E6D9A8" } + Behavior on height { NumberAnimation { duration: X.easeMs } } + function show(t) { text = t; hide.restart() } + Timer { id: hide; interval: 6000; onTriggered: mb.text = "" } + Row { + x: 12 + height: parent.height + spacing: 10 + Ico { anchors.verticalCenter: parent.verticalCenter; name: "info"; size: 16 } + T { height: parent.height; text: "NOTICE"; font.bold: true } + T { height: parent.height; text: mb.text } + } + Item { + anchors { right: parent.right; rightMargin: 8; verticalCenter: parent.verticalCenter } + width: 22 + height: 22 + Rectangle { anchors.fill: parent; color: xm.containsMouse ? "#F2E2A6" : "transparent" } + Ico { anchors.centerIn: parent; name: "close"; size: 18 } + MouseArea { id: xm; anchors.fill: parent; hoverEnabled: true; onClicked: mb.text = "" } + } +} diff --git a/stemroller/player/qml/StemPlayer/OfficeButton.qml b/stemroller/player/qml/StemPlayer/OfficeButton.qml new file mode 100644 index 0000000..1c77b69 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/OfficeButton.qml @@ -0,0 +1,16 @@ +import QtQuick + +// Dialog button: gray with a border; the default one outlined in green. +Rectangle { + id: ob + property string text + property bool primary: false + signal clicked() + implicitWidth: Math.max(80, t.implicitWidth + 24) + implicitHeight: 26 + color: m.pressed ? "#CCE4F7" : m.containsMouse ? "#E5F1FB" : "#FDFDFD" + border.color: m.containsMouse ? "#0078D7" : primary ? X.green : "#ADADAD" + border.width: primary ? 2 : 1 + T { id: t; anchors.centerIn: parent; text: ob.text } + MouseArea { id: m; anchors.fill: parent; hoverEnabled: true; onClicked: ob.clicked() } +} diff --git a/stemroller/player/qml/StemPlayer/RButton.qml b/stemroller/player/qml/StemPlayer/RButton.qml new file mode 100644 index 0000000..37bfcca --- /dev/null +++ b/stemroller/player/qml/StemPlayer/RButton.qml @@ -0,0 +1,59 @@ +import QtQuick + +// A ribbon command: large (icon over a label) or small (icon beside a label). +Item { + id: b + property string icon: "" + property string text: "" + property bool big: false + property bool checkable: false + property bool checked: false + property bool dropdown: false + property string tip: "" + signal clicked() + implicitWidth: big ? Math.max(44, lbl.implicitWidth + 12) : (icon ? 22 : 6) + (text ? lbl.implicitWidth + 8 : 0) + (dropdown ? 12 : 0) + implicitHeight: big ? 66 : 22 + opacity: enabled ? 1 : 0.4 + + Rectangle { + anchors.fill: parent + color: b.checked ? X.checked : ma.pressed ? X.pressed : ma.containsMouse ? X.hover : "transparent" + border.color: b.checked ? X.checkedBorder : "transparent" + } + Ico { + id: ic + visible: b.icon !== "" + name: b.icon + size: b.big ? 32 : 16 + x: b.big ? (parent.width - width) / 2 : 3 + y: b.big ? 4 : 3 + } + T { + id: lbl + text: b.text + font.pixelSize: X.fsUi + x: b.big ? (parent.width - width) / 2 : (b.icon ? 23 : 4) + y: b.big ? 38 : 0 + height: b.big ? implicitHeight : parent.height + width: b.big ? Math.min(implicitWidth, 90) : implicitWidth + horizontalAlignment: Text.AlignHCenter + wrapMode: b.big ? Text.WordWrap : Text.NoWrap + maximumLineCount: 2 + elide: Text.ElideNone + lineHeight: 0.95 + } + Ico { + visible: b.dropdown + name: "dropdown" + size: 10 + x: b.big ? (parent.width - width) / 2 : parent.width - 12 + y: b.big ? parent.height - 13 : 6 + } + MouseArea { + id: ma + anchors.fill: parent + hoverEnabled: true + onClicked: b.clicked() + } + Tip { target: ma; text: b.tip || b.text } +} diff --git a/stemroller/player/qml/StemPlayer/RGroup.qml b/stemroller/player/qml/StemPlayer/RGroup.qml new file mode 100644 index 0000000..9c7a11c --- /dev/null +++ b/stemroller/player/qml/StemPlayer/RGroup.qml @@ -0,0 +1,30 @@ +import QtQuick + +// A ribbon group: its commands, a caption along the bottom, a rule on the right. +Item { + id: g + property string title: "" + default property alias content: row.data + implicitWidth: Math.max(row.implicitWidth, cap.implicitWidth) + 12 + height: parent ? parent.height : 92 + Row { + id: row + x: 6 + y: 3 + height: 68 + spacing: 2 + } + T { + id: cap + text: g.title + font.pixelSize: X.fsSmall + color: X.inkSoft + anchors.horizontalCenter: parent.horizontalCenter + y: parent.height - 18 + } + Rectangle { + anchors { right: parent.right; top: parent.top; bottom: parent.bottom; topMargin: 4; bottomMargin: 4 } + width: 1 + color: X.ribbonLine + } +} diff --git a/stemroller/player/qml/StemPlayer/ResizeEdge.qml b/stemroller/player/qml/StemPlayer/ResizeEdge.qml new file mode 100644 index 0000000..73891d1 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/ResizeEdge.qml @@ -0,0 +1,13 @@ +import QtQuick + +// Invisible edge/corner grip that hands resizing to the compositor. +MouseArea { + property int edges: 0 + property var win: Window.window + hoverEnabled: true + acceptedButtons: Qt.LeftButton + cursorShape: edges === (Qt.LeftEdge | Qt.TopEdge) || edges === (Qt.RightEdge | Qt.BottomEdge) ? Qt.SizeFDiagCursor + : edges === (Qt.RightEdge | Qt.TopEdge) || edges === (Qt.LeftEdge | Qt.BottomEdge) ? Qt.SizeBDiagCursor + : (edges & (Qt.LeftEdge | Qt.RightEdge)) ? Qt.SizeHorCursor : Qt.SizeVerCursor + onPressed: win.startSystemResize(edges) +} diff --git a/stemroller/player/qml/StemPlayer/Ribbon.qml b/stemroller/player/qml/StemPlayer/Ribbon.qml new file mode 100644 index 0000000..14192ee --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Ribbon.qml @@ -0,0 +1,290 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Tabs on the green strip, commands on the gray ribbon below. +Column { + id: rib + property var win: Window.window + property int tab: 1 // 0 = File (backstage), 1 Home, 2 Insert, 3 Data, 4 View + readonly property var tabs: ["File", "Home", "Insert", "Data", "View"] + function focusSearch() { tell.startEditing() } + + Rectangle { + width: parent.width + height: 28 + color: X.green + Row { + x: 0 + height: parent.height + Repeater { + model: rib.tabs + delegate: Item { + id: tabItem + required property int index + required property string modelData + readonly property bool file: index === 0 + readonly property bool active: rib.tab === index && !file + width: tl.implicitWidth + (file ? 30 : 22) + height: 28 + Rectangle { + anchors.fill: parent + anchors.topMargin: tabItem.active ? 2 : 0 + color: tabItem.active ? X.ribbon : tabItem.file ? (tm.containsMouse ? "#0E4B2A" : X.greenDark) + : tm.containsMouse ? X.greenHover : "transparent" + } + T { + id: tl + anchors.centerIn: parent + text: tabItem.modelData + color: tabItem.active ? X.greenText : "#FFFFFF" + } + MouseArea { + id: tm + anchors.fill: parent + hoverEnabled: true + onClicked: tabItem.file ? rib.win.openBackstage("info") : rib.tab = tabItem.index + } + } + } + // "Tell me what you want to do": here it searches the library. + Item { + id: tell + width: 260 + height: 28 + function startEditing() { field.visible = true; field.forceActiveFocus(); field.selectAll() } + Ico { x: 12; anchors.verticalCenter: parent.verticalCenter; name: "lightbulb"; ink: "#FFFFFF"; size: 16 } + T { + x: 34 + anchors.verticalCenter: parent.verticalCenter + visible: !field.visible + color: "#FFFFFF" + text: "Tell me what you want to listen to..." + } + MouseArea { anchors.fill: parent; cursorShape: Qt.IBeamCursor; onClicked: tell.startEditing() } + XField { + id: field + visible: false + x: 32 + width: 220 + anchors.verticalCenter: parent.verticalCenter + placeholderText: "Song, artist or album" + onAccepted: { library.search(text); visible = false; rib.win.focusGrid() } + onActiveFocusChanged: if (!activeFocus && text === "") visible = false + Keys.onEscapePressed: { text = ""; visible = false; rib.win.focusGrid() } + } + } + } + } + + Rectangle { + width: parent.width + height: 94 + color: X.ribbon + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.ribbonLine } + + // ---- Home ---- + Row { + visible: rib.tab === 1 + height: parent.height - 2 + RGroup { + title: "Playback" + RButton { + big: true + icon: player.status === "playing" ? "pause" : "play" + text: player.status === "playing" ? "Pause" : "Play" + tip: "Play or pause (Space)" + onClicked: player.toggle() + } + Column { + RButton { icon: "previous"; text: "Previous"; tip: "Previous song (Ctrl+Left)"; onClicked: player.previous() } + RButton { icon: "next"; text: "Next"; tip: "Next song (Ctrl+Right)"; onClicked: player.next() } + RButton { icon: "stop"; text: "Stop"; onClicked: { engine.pause(); player.seek(0) } } + } + Column { + RButton { icon: "shuffle"; text: "Shuffle"; checked: player.shuffleOn; onClicked: player.toggleShuffle() } + RButton { + icon: player.repeatMode === "one" ? "repeat_one" : "repeat" + text: player.repeatMode === "one" ? "Repeat One" : "Repeat" + checked: player.repeatMode !== "off" + onClicked: player.cycleRepeat() + } + } + } + RGroup { + title: "Karaoke" + RButton { + big: true + enabled: player.sourceKind === "stems" + icon: player.presetLabel === "Karaoke" ? "vocals_off" : "vocals" + text: player.presetLabel === "Karaoke" ? "Vocals\nOff" : "Vocals\nOn" + checked: player.presetLabel === "Karaoke" + tip: "Mute the vocals (V)" + onClicked: player.toggleVocals() + } + } + RGroup { + title: "Mix Styles" + Grid { + columns: 4 + rowSpacing: 3 + columnSpacing: 3 + y: 4 + Repeater { + model: player.presets + delegate: Rectangle { + id: sty + required property int index + required property var modelData + readonly property var s: X.styles[index] + width: 82 + height: 28 + opacity: modelData.usable ? 1 : 0.35 + color: s.fill + border.width: modelData.active ? 2 : 1 + border.color: modelData.active ? X.green : (sm.containsMouse ? "#8A8A8A" : s.border) + T { + anchors.fill: parent + anchors.leftMargin: 5 + font.family: cellFont + font.pixelSize: 14 + font.bold: sty.s.bold + color: sty.s.text + text: sty.modelData.label + } + MouseArea { + id: sm + anchors.fill: parent + hoverEnabled: true + enabled: sty.modelData.usable + onClicked: player.applyPreset(sty.index) + } + Tip { target: sm; text: "Style: " + sty.s.name + " — " + sty.modelData.label } + } + } + } + } + RGroup { + title: "Cells" + RButton { big: true; icon: "play_next"; text: "Play\nNext"; tip: "Play the selection after this song"; onClicked: library.playNextRows(rib.win.selTop, rib.win.selBottom) } + RButton { big: true; icon: "queue_add"; text: "Add to\nQueue"; tip: "Add the selection to the end of the queue"; onClicked: library.queueRows(rib.win.selTop, rib.win.selBottom) } + RButton { + big: true + icon: "delete_rows" + text: "Delete\nRows" + enabled: library.layout === "queue" || library.sheetTitle !== "" && rib.win.inPlaylist + tip: "Remove the selected rows from the queue or playlist (Delete)" + onClicked: library.removeRows(rib.win.selTop, rib.win.selBottom) + } + } + RGroup { + title: "Editing" + Column { + RButton { icon: "sigma"; text: "AutoShuffle"; tip: "Shuffle everything on this sheet"; onClicked: library.shuffleSheet() } + RButton { icon: "sort_az"; text: "Sort & Filter"; dropdown: true; onClicked: sortMenu.popup() } + RButton { icon: "search"; text: "Find & Select"; tip: "Search the library (Ctrl+F)"; onClicked: rib.focusSearch() } + } + } + } + + // ---- Insert ---- + Row { + visible: rib.tab === 2 + height: parent.height - 2 + RGroup { + title: "Playlists" + RButton { big: true; icon: "playlist_new"; text: "New\nPlaylist"; tip: "A Plex playlist from the selected rows"; onClicked: rib.win.newPlaylist() } + RButton { big: true; icon: "playlist_add"; text: "Add to\nPlaylist"; dropdown: true; onClicked: plMenu.popup() } + } + RGroup { + title: "Queue" + RButton { big: true; icon: "play_next"; text: "Play\nNext"; onClicked: library.playNextRows(rib.win.selTop, rib.win.selBottom) } + RButton { big: true; icon: "queue_add"; text: "Add to\nQueue"; onClicked: library.queueRows(rib.win.selTop, rib.win.selBottom) } + RButton { big: true; icon: "play"; text: "Play\nSelection"; onClicked: library.playRows(rib.win.selTop, rib.win.selBottom) } + } + RGroup { + title: "Charts" + RButton { big: true; icon: "chart"; text: "Stem\nChart"; checked: rib.win.showMixer; tip: "Show the stem mixer pane"; onClicked: rib.win.toggleMixer() } + } + } + + // ---- Data ---- + Row { + visible: rib.tab === 3 + height: parent.height - 2 + RGroup { + title: "Get External Data" + RButton { big: true; icon: "plex"; text: library.signedIn ? "Plex\nAccount" : "Connect\nto Plex"; onClicked: rib.win.openBackstage("account") } + RButton { big: true; icon: "server"; text: "Connections"; tip: "Server addresses and folders"; onClicked: rib.win.openBackstage("options") } + } + RGroup { + title: "Connections" + RButton { big: true; icon: "refresh"; text: "Refresh\nAll"; tip: "Reload the Plex library and the stems index"; onClicked: library.refresh() } + Column { + y: 4 + spacing: 2 + T { text: "Songs: " + library.counts.songs.toLocaleString(Qt.locale(), "f", 0); height: 20 } + T { text: "With stems: " + library.counts.stems.toLocaleString(Qt.locale(), "f", 0); height: 20 } + T { + text: "Stem server: " + (library.counts.stemOnline === true ? "Online" : library.counts.stemOnline === false ? "Offline" : "Checking…") + color: library.counts.stemOnline === true ? X.goodText : library.counts.stemOnline === false ? X.badText : X.inkSoft + height: 20 + } + } + } + RGroup { + title: "Sort & Filter" + Column { + RButton { icon: "sort_az"; text: "Sort A to Z"; onClicked: rib.win.sortCurrent(false) } + RButton { icon: "sort_za"; text: "Sort Z to A"; onClicked: rib.win.sortCurrent(true) } + RButton { icon: "filter"; text: "Stems Only"; tip: "Songs that have stems"; onClicked: library.current = 4 } + } + } + } + + // ---- View ---- + Row { + visible: rib.tab === 4 + height: parent.height - 2 + RGroup { + title: "Show" + Column { + y: 2 + XCheck { text: "Gridlines"; checked: rib.win.gridlines; onToggled: rib.win.setOption("gridlines", !rib.win.gridlines) } + XCheck { text: "Headings"; checked: rib.win.headings; onToggled: rib.win.setOption("headings", !rib.win.headings) } + XCheck { text: "Mixer Pane"; checked: rib.win.showMixer; onToggled: rib.win.toggleMixer() } + } + } + RGroup { + title: "Zoom" + RButton { big: true; icon: "zoom"; text: "Zoom"; tip: "Ctrl+scroll on the grid"; onClicked: rib.win.setZoom(rib.win.zoom >= 150 ? 100 : rib.win.zoom + 25) } + RButton { big: true; icon: "grid"; text: "100%"; onClicked: rib.win.setZoom(100) } + } + RGroup { + title: "Window" + RButton { big: true; icon: "freeze"; text: "Freeze\nPanes"; checked: true; tip: "The header row is always frozen" } + } + } + } + + XMenu { + id: sortMenu + Action { text: "Sort A to Z"; icon.name: "sort_az"; onTriggered: rib.win.sortCurrent(false) } + Action { text: "Sort Z to A"; icon.name: "sort_za"; onTriggered: rib.win.sortCurrent(true) } + MenuSeparator {} + Action { text: "Filter: Stems Only"; icon.name: "filter"; onTriggered: library.current = 4 } + } + XMenu { + id: plMenu + Instantiator { + model: library.playlistNames + delegate: MenuItem { + required property int index + required property string modelData + text: modelData + onTriggered: rib.win.addToPlaylist(modelData) + } + onObjectAdded: (i, o) => plMenu.insertItem(i, o) + onObjectRemoved: (i, o) => plMenu.removeItem(o) + } + } +} diff --git a/stemroller/player/qml/StemPlayer/Sheet.qml b/stemroller/player/qml/StemPlayer/Sheet.qml new file mode 100644 index 0000000..0a4369f --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Sheet.qml @@ -0,0 +1,501 @@ +import QtQuick +import QtQuick.Controls.Basic + +// The worksheet. Row 1 is the frozen table header; data starts on row 2. Past the data the +// sheet carries on as empty gridlines, as Excel's does. +FocusScope { + id: g + property var win: Window.window + readonly property real z100: win.zoom / 100 + readonly property int rowH: Math.round(20 * z100) + readonly property int headW: Math.max(30, Math.round(rowNumW.advanceWidth + 12)) + readonly property int colHeadH: 20 + readonly property var cols: library.columns + readonly property int rows: table.rows + readonly property int padCols: 26 + property real extraColW: 64 * z100 + + function colX(c) { + var x = 0 + for (var i = 0; i < c && i < cols.length; i++) x += cols[i].width * z100 + if (c > cols.length) x += (c - cols.length) * extraColW + return x + } + function colW(c) { return c < cols.length ? cols[c].width * z100 : extraColW } + function colAt(x) { + var acc = 0 + for (var i = 0; i < cols.length; i++) { + acc += cols[i].width * z100 + if (x < acc) return i + } + return cols.length + Math.floor((x - acc) / extraColW) + } + function ensureVisible(r, c) { + var y = r * rowH + if (y < table.contentY) table.contentY = y + else if (y + rowH > table.contentY + table.height) table.contentY = y + rowH - table.height + var x = colX(c), w = colW(c) + if (x < table.contentX) table.contentX = x + else if (x + w > table.contentX + table.width) table.contentX = Math.min(x + w - table.width, Math.max(0, table.contentWidth - table.width)) + } + function moveTo(r, c, extend) { + r = Math.max(0, Math.min(r, Math.max(0, rows - 1))) + c = Math.max(0, Math.min(c, cols.length - 1)) + win.curRow = r + win.curCol = c + if (!extend) { win.anchorRow = r; win.anchorCol = c } + ensureVisible(r, c) + } + + TextMetrics { id: rowNumW; font.family: uiFont; font.pixelSize: X.fsSmall; text: String(g.rows + 40) } + + // ---- column letters ---- + Rectangle { + id: colHead + visible: win.headings + x: g.headW + width: parent.width - x + height: visible ? g.colHeadH : 0 + color: X.header + clip: true + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.headerLine } + Repeater { + model: g.cols.length + g.padCols + delegate: Rectangle { + required property int index + readonly property bool sel: index >= Math.min(win.curCol, win.anchorCol) && index <= Math.max(win.curCol, win.anchorCol) + x: g.colX(index) - table.contentX + width: g.colW(index) + height: g.colHeadH + visible: x + width > 0 && x < colHead.width + color: sel ? X.headerSel : X.header + T { + anchors.centerIn: parent + text: X.colName(index) + font.pixelSize: X.fsSmall + color: parent.sel ? X.greenText : X.ink + } + Rectangle { anchors.right: parent.right; width: 1; height: parent.height; color: X.headerLine } + Rectangle { visible: parent.sel; anchors.bottom: parent.bottom; width: parent.width; height: 2; color: X.green } + MouseArea { + anchors.fill: parent + onClicked: if (index < g.cols.length) { win.anchorRow = 0; win.curRow = Math.max(0, g.rows - 1); win.curCol = win.anchorCol = index } + } + } + } + } + // the select-all corner + Rectangle { + visible: win.headings + width: g.headW + height: g.colHeadH + color: X.header + Rectangle { anchors.right: parent.right; width: 1; height: parent.height; color: X.headerLine } + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.headerLine } + Canvas { + anchors { right: parent.right; bottom: parent.bottom; margins: 3 } + width: 10 + height: 10 + onPaint: { + var c = getContext("2d") + c.fillStyle = "#B4B4B4" + c.beginPath(); c.moveTo(10, 0); c.lineTo(10, 10); c.lineTo(0, 10); c.closePath(); c.fill() + } + } + MouseArea { anchors.fill: parent; onClicked: win.selectAll() } + } + + // ---- row numbers ---- + Rectangle { + id: rowHead + visible: win.headings + y: colHead.height + width: visible ? g.headW : 0 + height: parent.height - y + color: X.header + clip: true + Rectangle { anchors.right: parent.right; width: 1; height: parent.height; color: X.headerLine } + // row 1: the frozen table header + Rectangle { + width: parent.width + height: g.rowH + color: X.header + T { anchors.centerIn: parent; text: "1"; font.pixelSize: X.fsSmall } + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.headerLine } + Rectangle { anchors.right: parent.right; width: 1; height: parent.height; color: X.headerLine } + } + Item { + y: g.rowH + width: parent.width + height: parent.height - y + clip: true + Repeater { + model: Math.max(0, Math.ceil(parent.height / g.rowH) + 1) + delegate: Rectangle { + required property int index + readonly property int r: Math.floor(table.contentY / g.rowH) + index + readonly property bool sel: r >= win.selTop && r <= win.selBottom + y: r * g.rowH - table.contentY + width: rowHead.width + height: g.rowH + color: sel ? X.headerSel : X.header + T { + anchors.centerIn: parent + text: parent.r + 2 + font.pixelSize: X.fsSmall + color: parent.sel ? X.greenText : X.ink + } + Rectangle { anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.headerLine } + Rectangle { anchors.right: parent.right; width: parent.sel ? 2 : 1; height: parent.height; color: parent.sel ? X.green : X.headerLine } + MouseArea { + anchors.fill: parent + onClicked: (m) => { if (parent.r < g.rows) { g.moveTo(parent.r, 0, m.modifiers & Qt.ShiftModifier); if (!(m.modifiers & Qt.ShiftModifier)) win.anchorCol = 0; win.curCol = g.cols.length - 1 } } + onDoubleClicked: if (parent.r < g.rows) library.activate(parent.r, 0) + } + } + } + } + } + + // ---- sheet ---- + Item { + id: sheet + x: rowHead.width + y: colHead.height + width: parent.width - x + height: parent.height - y + clip: true + + Rectangle { anchors.fill: parent; color: "#FFFFFF" } + + // the empty sheet: gridlines everywhere, under the cells + Item { + anchors.fill: parent + visible: win.gridlines + Repeater { + model: Math.max(0, Math.ceil(sheet.height / g.rowH) + 2) + delegate: Rectangle { + required property int index + y: g.rowH + (index + 1) * g.rowH - (table.contentY % g.rowH) - 1 + width: sheet.width + height: 1 + color: X.grid + } + } + Repeater { + model: g.cols.length + g.padCols + delegate: Rectangle { + required property int index + x: g.colX(index + 1) - table.contentX - 1 + width: 1 + height: sheet.height + color: X.grid + } + } + } + + // row 1, frozen: the table header with its filter buttons + Item { + id: headRow + width: parent.width + height: g.rowH + z: 2 + Repeater { + model: g.cols + delegate: Rectangle { + id: hc + required property int index + required property var modelData + x: g.colX(index) - table.contentX + width: g.colW(index) + height: g.rowH + color: X.tableHead + Rectangle { anchors.right: parent.right; width: 1; height: parent.height; color: "#FFFFFF"; opacity: 0.5 } + T { + x: 4 + width: parent.width - 26 + height: parent.height + font.family: cellFont + font.pixelSize: Math.round(X.fsCell * g.z100) + font.bold: true + color: "#FFFFFF" + text: hc.modelData.title + horizontalAlignment: hc.modelData.kind === "text" || hc.modelData.kind === "stems" ? Text.AlignLeft : Text.AlignRight + rightPadding: hc.modelData.kind === "text" || hc.modelData.kind === "stems" ? 0 : 2 + } + // the AutoFilter button: sorts this column + Rectangle { + anchors { right: parent.right; rightMargin: 3; verticalCenter: parent.verticalCenter } + width: Math.round(15 * g.z100) + height: width + color: fm.containsMouse ? "#F0F0F0" : "#FFFFFF" + border.color: "#A0A0A0" + Ico { + anchors.centerIn: parent + size: Math.round(12 * g.z100) + name: library.sortColumn === hc.index ? (library.sortDescending ? "sort_down" : "sort_up") : "dropdown" + } + MouseArea { + id: fm + anchors.fill: parent + hoverEnabled: true + onClicked: { g.win.curCol = g.win.anchorCol = hc.index; filterMenu.col = hc.index; filterMenu.popup() } + } + } + MouseArea { + anchors { fill: parent; rightMargin: 20 } + onClicked: library.sortBy(hc.index) + } + } + } + } + + TableView { + id: table + y: g.rowH + width: parent.width + height: parent.height - y + model: sheetModel + clip: true + boundsBehavior: Flickable.StopAtBounds + reuseItems: true + columnWidthProvider: (c) => g.colW(c) + rowHeightProvider: (r) => g.rowH + interactive: false // the wheel and the scrollbars move it; dragging selects + ScrollBar.vertical: XScrollBar { id: vbar } + ScrollBar.horizontal: XScrollBar { id: hbar } + Connections { + target: g.win + function onZoomChanged() { Qt.callLater(table.forceLayout) } + } + + delegate: Rectangle { + id: cell + required property int row + required property int column + required property string display + required property string align + required property string cellStyle + required property bool playing + readonly property bool bar: cellStyle.indexOf("bar:") === 0 + color: cellStyle === "good" ? X.good : (row % 2 === 1 ? X.tableBand : "#FFFFFF") + Rectangle { // data bar + visible: cell.bar + x: 2 + y: 2 + height: parent.height - 4 + width: cell.bar ? (parent.width - 4) * parseFloat(cell.cellStyle.slice(4)) : 0 + color: X.dataBar + opacity: 0.85 + } + Rectangle { visible: g.win.gridlines; anchors.right: parent.right; width: 1; height: parent.height; color: X.grid } + Rectangle { visible: g.win.gridlines; anchors.bottom: parent.bottom; width: parent.width; height: 1; color: X.grid } + Text { + anchors.fill: parent + leftPadding: 3 + rightPadding: 4 + verticalAlignment: Text.AlignBottom + bottomPadding: Math.round(2 * g.z100) + horizontalAlignment: cell.align === "right" ? Text.AlignRight : Text.AlignLeft + font.family: cellFont + font.pixelSize: Math.round(X.fsCell * g.z100) + font.bold: cell.playing + color: cell.cellStyle === "good" ? X.goodText : X.cellText + text: cell.cellStyle === "good" ? cell.display + " stems" : cell.display + elide: cell.align === "right" ? Text.ElideLeft : Text.ElideRight + renderType: Text.NativeRendering + } + // Excel's green error triangle, here marking the song that's playing + Canvas { + visible: cell.playing && cell.column === 0 + width: 7 + height: 7 + onPaint: { + var c = getContext("2d") + c.fillStyle = "#217346" + c.beginPath(); c.moveTo(0, 0); c.lineTo(7, 0); c.lineTo(0, 7); c.closePath(); c.fill() + } + } + } + + // selection: range fill, green border, fill handle + Rectangle { + id: selBox + parent: table.contentItem + z: 50 + visible: g.rows > 0 + readonly property bool range: g.win.selTop !== g.win.selBottom || g.win.curCol !== g.win.anchorCol + x: g.colX(Math.min(g.win.curCol, g.win.anchorCol)) - 1 + y: g.win.selTop * g.rowH - 1 + width: g.colX(Math.max(g.win.curCol, g.win.anchorCol) + 1) - x + 1 + height: (g.win.selBottom - g.win.selTop + 1) * g.rowH + 1 + color: range ? X.selFill : "transparent" + border.color: X.green + border.width: 2 + Rectangle { + // the active cell stays clear inside a range + visible: selBox.range + x: g.colX(g.win.curCol) - parent.x + y: g.win.curRow * g.rowH - parent.y + width: g.colW(g.win.curCol) + height: g.rowH + color: "#FFFFFF" + opacity: 0.6 + } + Rectangle { + x: parent.width - 4 + y: parent.height - 4 + width: 7 + height: 7 + color: X.green + border.color: "#FFFFFF" + border.width: 1 + } + } + + MouseArea { + parent: table.contentItem + z: 60 + width: Math.max(table.contentWidth, table.width) + height: Math.max(table.contentHeight, table.height) + acceptedButtons: Qt.LeftButton | Qt.RightButton + property bool dragging: false + function cellAt(m) { return [Math.floor(m.y / g.rowH), g.colAt(m.x)] } + onPressed: (m) => { + g.forceActiveFocus() + var rc = cellAt(m) + if (rc[0] >= g.rows) return + if (m.button === Qt.RightButton) { + if (rc[0] < g.win.selTop || rc[0] > g.win.selBottom) g.moveTo(rc[0], rc[1], false) + ctxMenu.popup() + return + } + g.moveTo(rc[0], rc[1], m.modifiers & Qt.ShiftModifier) + dragging = true + } + onPositionChanged: (m) => { + if (!dragging) return + var rc = cellAt(m) + g.moveTo(rc[0], rc[1], true) + } + onReleased: dragging = false + onDoubleClicked: (m) => { var rc = cellAt(m); if (rc[0] < g.rows) library.activate(rc[0], 0) } + onWheel: (w) => { + if (w.modifiers & Qt.ControlModifier) { + g.win.setZoom(g.win.zoom + (w.angleDelta.y > 0 ? 10 : -10)) + return + } + var dy = w.pixelDelta.y !== 0 ? w.pixelDelta.y : w.angleDelta.y / 120 * 3 * g.rowH + var dx = w.pixelDelta.x !== 0 ? w.pixelDelta.x : w.angleDelta.x / 120 * 3 * g.rowH + if (w.modifiers & Qt.ShiftModifier) { dx = dy; dy = 0 } + table.contentY = Math.max(0, Math.min(table.contentY - dy, table.contentHeight - table.height)) + table.contentX = Math.max(0, Math.min(table.contentX - dx, Math.max(0, table.contentWidth - table.width))) + } + } + } + + // #GETTING_DATA: what Excel shows while a query runs + T { + visible: library.loading + x: 4 + y: g.rowH + height: g.rowH + font.family: cellFont + font.pixelSize: Math.round(X.fsCell * g.z100) + color: X.cellText + text: "#GETTING_DATA" + } + // a cell comment when there's nothing to show + Rectangle { + visible: g.rows === 0 && !library.loading + x: g.colX(1) + 30 + y: g.rowH * 2 + width: 300 + height: note.implicitHeight + 16 + color: X.note + border.color: "#B2B2B2" + Rectangle { x: -30; y: 6; width: 30; height: 1; color: "#000000" } + Text { + id: note + x: 8 + y: 8 + width: parent.width - 16 + wrapMode: Text.WordWrap + font.family: uiFont + font.pixelSize: X.fsUi + textFormat: Text.StyledText + text: !library.signedIn ? "StemRoller:
This workbook isn't connected yet. Go to Data → Connect to Plex and sign in with the code." + : library.layout === "queue" ? "StemRoller:
The queue is empty. Double-click a song on any sheet to play it." + : library.status !== "" ? "StemRoller:
Loading the library from Plex…" + : "StemRoller:
Nothing on this sheet." + } + } + } + + Keys.onPressed: (e) => { + var ext = e.modifiers & Qt.ShiftModifier + var ctrl = e.modifiers & Qt.ControlModifier + var page = Math.max(1, Math.floor(table.height / g.rowH) - 1) + switch (e.key) { + case Qt.Key_Down: g.moveTo(ctrl ? g.rows - 1 : win.curRow + 1, win.curCol, ext); break + case Qt.Key_Up: g.moveTo(ctrl ? 0 : win.curRow - 1, win.curCol, ext); break + case Qt.Key_Right: if (ctrl) { player.next(); break } g.moveTo(win.curRow, win.curCol + 1, ext); break + case Qt.Key_Left: if (ctrl) { player.previous(); break } g.moveTo(win.curRow, win.curCol - 1, ext); break + case Qt.Key_Tab: g.moveTo(win.curRow, win.curCol + 1, false); break + case Qt.Key_PageDown: g.moveTo(win.curRow + page, win.curCol, ext); break + case Qt.Key_PageUp: g.moveTo(win.curRow - page, win.curCol, ext); break + case Qt.Key_Home: g.moveTo(ctrl ? 0 : win.curRow, 0, ext); break + case Qt.Key_End: g.moveTo(ctrl ? g.rows - 1 : win.curRow, g.cols.length - 1, ext); break + case Qt.Key_Return: + case Qt.Key_Enter: library.activate(win.curRow, 0); break + case Qt.Key_Space: player.toggle(); break + case Qt.Key_Delete: library.removeRows(win.selTop, win.selBottom); break + case Qt.Key_Backspace: library.back(); break + case Qt.Key_A: if (ctrl) win.selectAll(); else return; break + case Qt.Key_C: if (ctrl) win.copySelection(); else return; break + case Qt.Key_V: if (!ctrl) player.toggleVocals(); else return; break + default: return + } + e.accepted = true + } + + // A new sheet starts at the top; fresh data for the same sheet keeps its scroll position. + property real keptY: 0 + property bool switching: false + Connections { + target: library + function onSheetSwitched() { g.switching = true; table.contentY = 0; table.contentX = 0 } + } + Connections { + target: sheetModel + function onModelAboutToBeReset() { g.keptY = table.contentY } + function onModelReset() { + if (g.switching) { g.switching = false; return } + Qt.callLater(() => { table.contentY = Math.min(g.keptY, Math.max(0, table.contentHeight - table.height)) }) + } + } + + XMenu { + id: ctxMenu + Action { text: "Play"; icon.name: "play"; onTriggered: library.playRows(g.win.selTop, g.win.selBottom) } + Action { text: "Play Next"; icon.name: "play_next"; onTriggered: library.playNextRows(g.win.selTop, g.win.selBottom) } + Action { text: "Add to Queue"; icon.name: "queue_add"; onTriggered: library.queueRows(g.win.selTop, g.win.selBottom) } + MenuSeparator {} + Action { text: "Open"; icon.name: "right"; onTriggered: library.activate(g.win.curRow, 0) } + Action { text: "New Playlist from Selection…"; icon.name: "playlist_new"; onTriggered: g.win.newPlaylist() } + Action { text: "Copy"; onTriggered: g.win.copySelection() } + MenuSeparator {} + Action { + text: "Delete Rows" + icon.name: "delete_rows" + enabled: library.layout === "queue" || g.win.inPlaylist + onTriggered: library.removeRows(g.win.selTop, g.win.selBottom) + } + } + XMenu { + id: filterMenu + property int col: 0 + Action { text: "Sort A to Z"; icon.name: "sort_az"; onTriggered: g.win.sortColumn(filterMenu.col, false) } + Action { text: "Sort Z to A"; icon.name: "sort_za"; onTriggered: g.win.sortColumn(filterMenu.col, true) } + } +} diff --git a/stemroller/player/qml/StemPlayer/SheetTabs.qml b/stemroller/player/qml/StemPlayer/SheetTabs.qml new file mode 100644 index 0000000..30decf1 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/SheetTabs.qml @@ -0,0 +1,89 @@ +import QtQuick + +// Worksheet tabs. The first six are fixed; opened artists, albums, playlists and searches follow. +Rectangle { + id: st + property var win: Window.window + height: 26 + color: X.ribbon + Rectangle { width: parent.width; height: 1; color: X.ribbonLine } + + Row { + id: nav + x: 6 + height: parent.height + spacing: 2 + Repeater { + model: ["left", "right"] + delegate: Item { + required property int index + required property string modelData + width: 18 + height: parent.height + Ico { anchors.centerIn: parent; name: parent.modelData; size: 12; opacity: na.containsMouse ? 1 : 0.6 } + MouseArea { + id: na + anchors.fill: parent + hoverEnabled: true + onClicked: library.current = Math.max(0, Math.min(library.tabs.length - 1, library.current + (parent.index ? 1 : -1))) + } + } + } + } + + Flickable { + id: flick + x: nav.x + nav.width + 8 + width: parent.width - x - 8 + height: parent.height + contentWidth: tabRow.width + 40 + clip: true + flickableDirection: Flickable.HorizontalFlick + boundsBehavior: Flickable.StopAtBounds + Row { + id: tabRow + height: parent.height + Repeater { + model: library.tabs + delegate: Item { + id: tb + required property int index + required property var modelData + readonly property bool active: library.current === index + width: lbl.implicitWidth + 28 + height: st.height + Rectangle { + anchors.fill: parent + anchors.topMargin: 0 + color: tb.active ? "#FFFFFF" : tm.containsMouse ? "#E5E5E5" : "transparent" + } + Rectangle { visible: !tb.active; anchors.right: parent.right; y: 6; width: 1; height: parent.height - 12; color: "#C8C8C8" } + Rectangle { visible: tb.active; anchors.bottom: parent.bottom; width: parent.width; height: 3; color: X.green } + T { + id: lbl + anchors.centerIn: parent + text: tb.modelData.title + color: tb.active ? X.greenText : X.ink + font.bold: tb.active + } + MouseArea { + id: tm + anchors.fill: parent + hoverEnabled: true + acceptedButtons: Qt.LeftButton | Qt.MiddleButton + onClicked: (m) => m.button === Qt.MiddleButton ? library.closeTab(tb.index) : (library.current = tb.index) + } + Tip { target: tm; text: tb.modelData.base ? "" : "Middle-click or Backspace to close" } + } + } + // ⊕ new sheet: here, the search box + Item { + width: 30 + height: st.height + Ico { anchors.centerIn: parent; name: "plus"; size: 16; opacity: pm.containsMouse ? 1 : 0.6 } + MouseArea { id: pm; anchors.fill: parent; hoverEnabled: true; onClicked: st.win.focusSearch() } + Tip { target: pm; text: "New sheet from a search" } + } + } + } +} diff --git a/stemroller/player/qml/StemPlayer/StatusBar.qml b/stemroller/player/qml/StemPlayer/StatusBar.qml new file mode 100644 index 0000000..1043a11 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/StatusBar.qml @@ -0,0 +1,96 @@ +import QtQuick + +// Ready / Calculating on the left; Average, Count, Sum; view buttons; the zoom slider is the volume. +Rectangle { + id: sb + property var win: Window.window + height: 24 + color: X.green + + T { + x: 10 + height: parent.height + color: "#FFFFFF" + text: library.status !== "" ? library.status + (library.progress >= 0 ? ": " + Math.round(library.progress * 100) + "%" : "") + : player.status === "loading" ? "Calculating..." + : player.status === "buffering" ? "Buffering..." + : player.status === "playing" ? "Playing" + (player.presetLabel && player.presetLabel !== "Full Mix" ? " · " + player.presetLabel : "") + : "Ready" + } + Rectangle { // progress for Calculating, like Excel's + visible: library.progress >= 0 + x: 190 + anchors.verticalCenter: parent.verticalCenter + width: 120 + height: 8 + color: "#FFFFFF" + opacity: 0.9 + Rectangle { width: parent.width * Math.max(0, library.progress); height: parent.height; color: "#9FD2B4" } + } + + Row { + anchors.right: parent.right + anchors.rightMargin: 10 + height: parent.height + spacing: 18 + + Row { + height: parent.height + spacing: 18 + visible: !!sb.win.selStats.count + T { color: "#FFFFFF"; height: parent.height; visible: !!sb.win.selStats.average; text: "Average: " + (sb.win.selStats.average || "") } + T { color: "#FFFFFF"; height: parent.height; text: "Count: " + (sb.win.selStats.count || "") } + T { color: "#FFFFFF"; height: parent.height; visible: !!sb.win.selStats.sum; text: "Sum: " + (sb.win.selStats.sum || "") } + } + Row { + height: parent.height + spacing: 2 + Repeater { + model: ["normal_view", "page_view", "break_view"] + delegate: Item { + required property int index + required property string modelData + width: 24 + height: sb.height + Rectangle { anchors.fill: parent; anchors.margins: 2; color: index === 0 ? X.greenDark : "transparent" } + Ico { anchors.centerIn: parent; name: parent.modelData; ink: "#FFFFFF"; size: 16 } + } + } + } + // the zoom slider, wired to the master volume + Row { + height: parent.height + spacing: 6 + T { color: "#FFFFFF"; height: parent.height; text: "−"; font.pixelSize: 16 + MouseArea { anchors.fill: parent; anchors.margins: -4; onClicked: engine.volume = Math.max(0, engine.volume - 0.05) } } + Item { + id: track + width: 110 + height: parent.height + Rectangle { anchors.verticalCenter: parent.verticalCenter; width: parent.width; height: 2; color: "#FFFFFF"; opacity: 0.8 } + Rectangle { x: parent.width / 2 - 1; anchors.verticalCenter: parent.verticalCenter; width: 2; height: 8; color: "#FFFFFF"; opacity: 0.8 } + Rectangle { + x: engine.volume * (track.width - width) + anchors.verticalCenter: parent.verticalCenter + width: 6 + height: 13 + color: vm.pressed ? "#E0E0E0" : "#FFFFFF" + } + MouseArea { + id: vm + anchors.fill: parent + anchors.margins: -3 + hoverEnabled: true + function set(m) { engine.volume = Math.max(0, Math.min(1, (m.x - 3) / (track.width))) } + onPressed: (m) => set(m) + onPositionChanged: (m) => { if (pressed) set(m) } + onWheel: (w) => engine.volume = Math.max(0, Math.min(1, engine.volume + (w.angleDelta.y > 0 ? 0.03 : -0.03))) + } + Tip { target: vm; text: "Volume" } + } + T { color: "#FFFFFF"; height: parent.height; text: "+"; font.pixelSize: 15 + MouseArea { anchors.fill: parent; anchors.margins: -4; onClicked: engine.volume = Math.min(1, engine.volume + 0.05) } } + T { color: "#FFFFFF"; height: parent.height; width: 40; horizontalAlignment: Text.AlignRight; text: Math.round(engine.volume * 100) + "%" } + } + } +} diff --git a/stemroller/player/qml/StemPlayer/StemChart.qml b/stemroller/player/qml/StemPlayer/StemChart.qml new file mode 100644 index 0000000..e8c4dd4 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/StemChart.qml @@ -0,0 +1,136 @@ +import QtQuick + +// The stem faders as an Excel column chart. Drag a column to set its level; double-click +// for 0 dB. Below each category: M(ute) and S(olo). +Rectangle { + id: ch + color: "#FFFFFF" + border.color: "#D9D9D9" + readonly property var stems: player.stems + readonly property int n: stems.length + readonly property real unity: 0.8 + + T { + id: title + anchors.horizontalCenter: parent.horizontalCenter + y: 6 + text: "Stem Mix" + font.family: cellFont + font.pixelSize: 17 + color: X.chartText + } + + Item { + id: plot + x: 34 + y: title.y + title.height + 18 + width: parent.width - x - 8 + height: parent.height - y - 52 + + // value axis: fader position, 0 dB marked + Repeater { + model: [0, 0.25, 0.5, 0.8, 1.0] + delegate: Item { + required property var modelData + y: plot.height * (1 - modelData) + width: plot.width + Rectangle { width: parent.width; height: 1; color: modelData === 0.8 ? "#A6A6A6" : X.chartLine } + T { + x: -32 + width: 28 + y: -7 + height: 14 + horizontalAlignment: Text.AlignRight + font.family: cellFont + font.pixelSize: 11 + color: X.chartText + text: modelData === 0 ? "-∞" : modelData === 0.8 ? "0 dB" : modelData === 1 ? "+4" : (40 * Math.log(modelData / 0.8) / Math.LN10).toFixed(0) + } + } + } + + Repeater { + model: ch.stems + delegate: Item { + id: cat + required property int index + required property var modelData + readonly property real cw: plot.width / Math.max(1, ch.n) + x: index * cw + width: cw + height: plot.height + + Rectangle { + id: bar + anchors.horizontalCenter: parent.horizontalCenter + width: cat.cw * 0.62 + height: Math.max(1, plot.height * cat.modelData.level) + y: plot.height - height + color: cat.modelData.color + opacity: cat.modelData.audible ? 1 : 0.22 + border.color: dm.containsMouse || dm.pressed ? "#404040" : "transparent" + Behavior on height { enabled: !dm.pressed; NumberAnimation { duration: X.easeMs; easing.type: Easing.OutCubic } } + } + T { // data label + anchors.horizontalCenter: parent.horizontalCenter + y: bar.y - 16 + font.family: cellFont + font.pixelSize: 11 + color: X.chartText + text: cat.modelData.muted ? "Muted" : !cat.modelData.audible ? "—" : cat.modelData.level <= 0.001 ? "-∞" : (cat.modelData.db >= 0 ? "+" : "") + cat.modelData.db.toFixed(1) + } + MouseArea { + id: dm + anchors.fill: parent + hoverEnabled: true + cursorShape: Qt.SizeVerCursor + function set(m) { player.setLevel(cat.index, Math.max(0, Math.min(1, 1 - m.y / plot.height))) } + onPressed: (m) => set(m) + onPositionChanged: (m) => { if (pressed) set(m) } + onDoubleClicked: player.setLevel(cat.index, ch.unity) + onWheel: (w) => player.setLevel(cat.index, Math.max(0, Math.min(1, cat.modelData.level + (w.angleDelta.y > 0 ? 0.02 : -0.02)))) + } + Tip { target: dm; text: cat.modelData.label + ": drag to set, double-click for 0 dB" } + + // category axis label and the M / S toggles + Column { + y: plot.height + 4 + anchors.horizontalCenter: parent.horizontalCenter + spacing: 3 + T { + anchors.horizontalCenter: parent.horizontalCenter + font.family: cellFont + font.pixelSize: 12 + color: X.chartText + text: cat.modelData.label + width: Math.min(implicitWidth, cat.cw) + } + Row { + anchors.horizontalCenter: parent.horizontalCenter + spacing: 2 + Toggle { label: "M"; on: cat.modelData.muted; onFill: X.bad; onText: X.badText; tip: "Mute " + cat.modelData.label; onClicked: player.toggleMute(cat.index) } + Toggle { label: "S"; on: cat.modelData.solo; onFill: X.neutral; onText: X.neutralText; tip: "Solo " + cat.modelData.label; onClicked: player.toggleSolo(cat.index) } + } + } + } + } + Rectangle { y: plot.height; width: plot.width; height: 1; color: "#BFBFBF" } + } + + component Toggle: Rectangle { + id: tg + property string label + property bool on: false + property color onFill + property color onText + property string tip + signal clicked() + width: 18 + height: 18 + color: on ? onFill : tgm.containsMouse ? "#F2F2F2" : "#FFFFFF" + border.color: on ? onText : "#BFBFBF" + T { anchors.centerIn: parent; text: tg.label; font.pixelSize: 11; font.bold: tg.on; color: tg.on ? tg.onText : X.inkSoft } + MouseArea { id: tgm; anchors.fill: parent; hoverEnabled: true; onClicked: tg.clicked() } + Tip { target: tgm; text: tg.tip } + } +} diff --git a/stemroller/player/qml/StemPlayer/T.qml b/stemroller/player/qml/StemPlayer/T.qml new file mode 100644 index 0000000..305c8fc --- /dev/null +++ b/stemroller/player/qml/StemPlayer/T.qml @@ -0,0 +1,10 @@ +import QtQuick + +Text { + font.family: uiFont + font.pixelSize: X.fsUi + color: X.ink + renderType: Text.NativeRendering + elide: Text.ElideRight + verticalAlignment: Text.AlignVCenter +} diff --git a/stemroller/player/qml/StemPlayer/TaskPane.qml b/stemroller/player/qml/StemPlayer/TaskPane.qml new file mode 100644 index 0000000..b4b2df7 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/TaskPane.qml @@ -0,0 +1,302 @@ +import QtQuick +import QtQuick.Controls.Basic + +// The "Format Mix" task pane: what's playing, a sparkline to seek with, and the stems as a chart. +Rectangle { + id: pane + property var win: Window.window + color: "#FFFFFF" + Rectangle { width: 1; height: parent.height; color: X.ribbonLine } + + Item { + id: head + x: 1 + width: parent.width - 1 + height: 40 + T { x: 14; height: parent.height; text: "Format Mix"; font.pixelSize: 17; color: X.ink } + Ico { anchors.right: parent.right; anchors.rightMargin: 34; anchors.verticalCenter: parent.verticalCenter; name: "dropdown"; size: 12 } + Item { + anchors { right: parent.right; rightMargin: 6; verticalCenter: parent.verticalCenter } + width: 24 + height: 24 + Rectangle { anchors.fill: parent; color: cm.containsMouse ? X.hover : "transparent" } + Ico { anchors.centerIn: parent; name: "close"; size: 20 } + MouseArea { id: cm; anchors.fill: parent; hoverEnabled: true; onClicked: pane.win.toggleMixer() } + } + } + + Flickable { + id: flick + x: 1 + y: head.height + width: parent.width - 1 + height: parent.height - y + contentHeight: col.height + 20 + clip: true + boundsBehavior: Flickable.StopAtBounds + ScrollBar.vertical: XScrollBar { policy: flick.contentHeight > flick.height ? ScrollBar.AlwaysOn : ScrollBar.AlwaysOff } + + Column { + id: col + x: 14 + width: flick.width - 34 + spacing: 10 + + // ---- now playing ---- + Row { + width: parent.width + spacing: 12 + Rectangle { + width: 128 + height: 128 + color: "#F2F2F2" + border.color: "#D9D9D9" + Image { + id: art + anchors.fill: parent + anchors.margins: 1 + source: player.track.art || "" + fillMode: Image.PreserveAspectCrop + asynchronous: true + cache: true + sourceSize.width: 256 + sourceSize.height: 256 + } + Ico { visible: art.status !== Image.Ready; anchors.centerIn: parent; name: "excel"; size: 48; opacity: 0.25 } + } + Column { + width: parent.width - 140 + anchors.verticalCenter: parent.verticalCenter + spacing: 3 + Text { + width: parent.width + text: player.track.title || "Nothing playing" + font.family: uiFont + font.pixelSize: 16 + font.bold: true + color: "#222222" + wrapMode: Text.WordWrap + maximumLineCount: 3 + elide: Text.ElideRight + } + T { width: parent.width; text: player.track.artist || "Double-click a song to play it"; font.pixelSize: 13; color: X.inkSoft } + Text { + width: parent.width + visible: !!player.track.album + text: (player.track.album || "") + (player.track.year ? " · " + player.track.year : "") + font.family: uiFont + font.pixelSize: 12 + color: X.inkFaint + wrapMode: Text.WordWrap + maximumLineCount: 2 + elide: Text.ElideRight + } + } + } + + // ---- the sparkline seek bar ---- + Item { + id: spark + width: parent.width + height: 46 + readonly property real dur: engine.duration > 0 ? engine.duration : (player.track.durationMs || 0) / 1000 + readonly property real frac: dur > 0 ? Math.min(1, pane.win.playPos / dur) : 0 + readonly property var bars: player.wave.length ? player.wave : [] + readonly property int n: bars.length ? bars.length : 80 + property real hoverFrac: -1 + Rectangle { anchors.fill: parent; color: "#FFFFFF"; border.color: "#D9D9D9" } + Canvas { + id: sparkCanvas + anchors.fill: parent + anchors.margins: 3 + property real frac: spark.frac + property var bars: spark.bars + onFracChanged: requestPaint() + onBarsChanged: requestPaint() + onWidthChanged: requestPaint() + onPaint: { + var c = getContext("2d") + c.reset() + var n = spark.n, w = width / n, h = height + for (var i = 0; i < n; i++) { + var v = bars.length ? bars[i] : 0.12 + var bh = Math.max(2, v * h) + c.fillStyle = (i + 0.5) / n <= frac ? "#217346" : "#A9D08E" + c.fillRect(i * w + w * 0.15, h - bh, Math.max(1, w * 0.7), bh) + } + } + } + Rectangle { // playhead + visible: spark.dur > 0 + x: 3 + spark.frac * (parent.width - 6) - 1 + y: 2 + width: 2 + height: parent.height - 4 + color: "#C00000" + } + Rectangle { + visible: spark.hoverFrac >= 0 + x: Math.max(0, Math.min(parent.width - width, spark.hoverFrac * parent.width - width / 2)) + y: -22 + width: hv.implicitWidth + 10 + height: 18 + color: "#FFFFFF" + border.color: "#BEBEBE" + T { id: hv; anchors.centerIn: parent; font.pixelSize: X.fsSmall; text: X.time(spark.hoverFrac * spark.dur) } + } + MouseArea { + anchors.fill: parent + hoverEnabled: true + function f(m) { return Math.max(0, Math.min(1, (m.x - 3) / (width - 6))) } + onPositionChanged: (m) => { spark.hoverFrac = f(m); if (pressed) pane.win.seekTo(f(m) * spark.dur) } + onExited: spark.hoverFrac = -1 + onPressed: (m) => pane.win.seekTo(f(m) * spark.dur) + } + } + Item { + width: parent.width + height: 14 + y: -6 + T { font.pixelSize: X.fsSmall; color: X.inkSoft; text: X.time(pane.win.playPos) } + T { + anchors.right: parent.right + font.pixelSize: X.fsSmall + color: X.inkSoft + text: spark.dur > 0 ? "-" + X.time(spark.dur - pane.win.playPos) : "" + } + } + + // ---- transport ---- + Row { + anchors.horizontalCenter: parent.horizontalCenter + spacing: 6 + PaneButton { icon: "shuffle"; checked: player.shuffleOn; tip: "Shuffle"; onClicked: player.toggleShuffle() } + PaneButton { icon: "previous"; tip: "Previous"; onClicked: player.previous() } + PaneButton { + icon: player.status === "playing" ? "pause" : "play" + size: 40 + tip: "Play / Pause (Space)" + onClicked: player.toggle() + } + PaneButton { icon: "next"; tip: "Next"; onClicked: player.next() } + PaneButton { + icon: player.repeatMode === "one" ? "repeat_one" : "repeat" + checked: player.repeatMode !== "off" + tip: player.repeatMode === "off" ? "Repeat" : player.repeatMode === "all" ? "Repeat all" : "Repeat one" + onClicked: player.cycleRepeat() + } + } + + // output meter, as a pair of data bars + Column { + width: parent.width + spacing: 2 + Repeater { + model: 2 + delegate: Rectangle { + required property int index + width: parent.width + height: 5 + color: "#EDEDED" + Rectangle { + readonly property real lv: index === 0 ? pane.win.levelL : pane.win.levelR + readonly property real db: 20 * Math.log(Math.max(lv, 1e-5)) / Math.LN10 + width: parent.width * Math.max(0, Math.min(1, (db + 48) / 48)) + height: parent.height + color: db > -1 ? "#C00000" : db > -9 ? "#FFC000" : X.dataBar + } + } + } + } + + // ---- section: Stem Mix ---- + Row { + spacing: 6 + height: 24 + Ico { anchors.verticalCenter: parent.verticalCenter; name: "dropdown"; size: 10 } + T { anchors.verticalCenter: parent.verticalCenter; text: "Stem Mix"; font.bold: true; font.pixelSize: 13 } + } + + Rectangle { // "comment" for songs without stems + visible: player.sourceKind === "original" + width: parent.width + height: noteTxt.implicitHeight + 16 + color: X.note + border.color: "#B2B2B2" + Text { + id: noteTxt + x: 8 + y: 8 + width: parent.width - 16 + wrapMode: Text.WordWrap + font.family: uiFont + font.pixelSize: X.fsUi + textFormat: Text.StyledText + text: "StemRoller:
This song hasn't been separated yet, so it plays the original file. The server's stemd will get to it." + } + } + + StemChart { + visible: player.sourceKind === "stems" + width: parent.width + height: 250 + } + + Row { + visible: player.sourceKind === "stems" + spacing: 8 + T { height: 22; text: "Mix style:" } + Rectangle { + width: 150 + height: 22 + border.color: pm.containsMouse ? X.green : "#ABABAB" + T { x: 6; height: parent.height; width: parent.width - 24; text: player.presetLabel } + Ico { anchors.right: parent.right; anchors.rightMargin: 5; anchors.verticalCenter: parent.verticalCenter; name: "dropdown"; size: 10 } + MouseArea { id: pm; anchors.fill: parent; hoverEnabled: true; onClicked: presetMenu.popup() } + } + } + XCheck { + text: "Keep the mix for the next song" + checked: player.keepMix + onToggled: player.setKeepMix(!player.keepMix) + } + } + } + + XMenu { + id: presetMenu + Instantiator { + model: player.presets + delegate: MenuItem { + required property int index + required property var modelData + text: modelData.label + enabled: modelData.usable + checkable: true + checked: modelData.active + onTriggered: player.applyPreset(index) + } + onObjectAdded: (i, o) => presetMenu.insertItem(i, o) + onObjectRemoved: (i, o) => presetMenu.removeItem(o) + } + } + + component PaneButton: Item { + id: pb + property string icon + property bool checked: false + property int size: 32 + property string tip: "" + signal clicked() + width: size + height: size + Rectangle { + anchors.fill: parent + radius: pb.size / 2 + color: pb.checked ? X.checked : pbm.pressed ? X.pressed : pbm.containsMouse ? X.hover : "transparent" + } + Ico { anchors.centerIn: parent; name: pb.icon; size: Math.round(pb.size * 0.55) } + MouseArea { id: pbm; anchors.fill: parent; hoverEnabled: true; onClicked: pb.clicked() } + Tip { target: pbm; text: pb.tip } + } +} diff --git a/stemroller/player/qml/StemPlayer/Tip.qml b/stemroller/player/qml/StemPlayer/Tip.qml new file mode 100644 index 0000000..3417b7d --- /dev/null +++ b/stemroller/player/qml/StemPlayer/Tip.qml @@ -0,0 +1,22 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Office-style tooltip: white box, gray border, after a short hover. +ToolTip { + id: tt + property var target + visible: target && target.containsMouse && text !== "" && hoverTimer.done + delay: 0 + timeout: 6000 + padding: 6 + Timer { + id: hoverTimer + property bool done: false + interval: 600 + running: tt.target && tt.target.containsMouse + onRunningChanged: if (!running) done = false + onTriggered: done = true + } + contentItem: T { text: tt.text; font.pixelSize: X.fsSmall; elide: Text.ElideNone } + background: Rectangle { color: "#FFFFFF"; border.color: "#BEBEBE" } +} diff --git a/stemroller/player/qml/StemPlayer/TitleBar.qml b/stemroller/player/qml/StemPlayer/TitleBar.qml new file mode 100644 index 0000000..e3a6b08 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/TitleBar.qml @@ -0,0 +1,65 @@ +import QtQuick + +// Excel's green title bar: Quick Access Toolbar, workbook name, account, caption buttons. +Rectangle { + id: bar + property var win: Window.window + height: 32 + color: X.green + + DragHandler { + target: null + grabPermissions: PointerHandler.CanTakeOverFromAnything + onActiveChanged: if (active) bar.win.startSystemMove() + } + TapHandler { onDoubleTapped: bar.win.toggleMaximized() } + + Row { + x: 6 + height: parent.height + spacing: 0 + Ico { name: "excel"; size: 20; anchors.verticalCenter: parent.verticalCenter } + Item { width: 10; height: 1 } + QatButton { icon: player.status === "playing" ? "pause" : "play"; tip: player.status === "playing" ? "Pause (Space)" : "Play (Space)"; onClicked: player.toggle() } + QatButton { icon: "undo"; tip: "Undo — previous song (Ctrl+Left)"; onClicked: player.previous() } + QatButton { icon: "redo"; tip: "Redo — next song (Ctrl+Right)"; onClicked: player.next() } + QatButton { icon: "dropdown"; tip: "Customize Quick Access Toolbar"; width: 16 } + } + + T { + anchors.centerIn: parent + width: Math.min(implicitWidth, parent.width - 560) + color: "#FFFFFF" + font.pixelSize: X.fsUi + text: (player.track.title ? player.track.title + " - " + player.track.artist : "Book1") + ".xlsx - Excel" + } + + Row { + anchors.right: parent.right + height: parent.height + T { + anchors.verticalCenter: parent.verticalCenter + color: "#FFFFFF" + text: library.signedIn ? (settings.get("plexUser") || "Plex") : "Sign in" + rightPadding: 14 + MouseArea { anchors.fill: parent; cursorShape: Qt.PointingHandCursor; onClicked: bar.win.openBackstage("account") } + } + CaptionButton { icon: "pane"; tip: "Show or hide the mixer pane"; onClicked: bar.win.toggleMixer() } + CaptionButton { icon: "minimize"; onClicked: bar.win.showMinimized() } + CaptionButton { icon: bar.win.maximized ? "restore" : "maximize"; onClicked: bar.win.toggleMaximized() } + CaptionButton { icon: "close"; danger: true; onClicked: bar.win.close() } + } + + component QatButton: Item { + id: q + property string icon + property string tip + signal clicked() + width: 26 + height: parent.height + Rectangle { anchors.fill: parent; color: qm.pressed ? X.greenDark : qm.containsMouse ? X.greenHover : "transparent" } + Ico { anchors.centerIn: parent; name: q.icon; ink: "#FFFFFF"; size: q.icon === "dropdown" ? 10 : 16 } + MouseArea { id: qm; anchors.fill: parent; hoverEnabled: true; onClicked: q.clicked() } + Tip { target: qm; text: q.tip } + } +} diff --git a/stemroller/player/qml/StemPlayer/X.qml b/stemroller/player/qml/StemPlayer/X.qml new file mode 100644 index 0000000..26ecee1 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/X.qml @@ -0,0 +1,71 @@ +pragma Singleton +import QtQuick + +// Excel 2016, "Colorful" Office theme. +QtObject { + readonly property color green: "#217346" + readonly property color greenDark: "#185C37" + readonly property color greenHover: "#2A8754" + readonly property color greenText: "#217346" + readonly property color ribbon: "#F3F3F3" + readonly property color ribbonLine: "#D5D5D5" + readonly property color hover: "#DCDCDC" + readonly property color pressed: "#C6C6C6" + readonly property color checked: "#C6C6C6" + readonly property color checkedBorder: "#A5A5A5" + readonly property color ink: "#444444" + readonly property color inkSoft: "#666666" + readonly property color inkFaint: "#9A9A9A" + readonly property color white: "#FFFFFF" + readonly property color grid: "#D4D4D4" + readonly property color header: "#F3F3F3" + readonly property color headerSel: "#D2D2D2" + readonly property color headerLine: "#BDBDBD" + readonly property color selFill: Qt.rgba(0, 0, 0, 0.09) + readonly property color cellText: "#000000" + readonly property color tableHead: "#70AD47" + readonly property color tableBand: "#E2EFDA" + readonly property color good: "#C6EFCE" + readonly property color goodText: "#006100" + readonly property color bad: "#FFC7CE" + readonly property color badText: "#9C0006" + readonly property color neutral: "#FFEB9C" + readonly property color neutralText: "#9C5700" + readonly property color dataBar: "#63BE7B" + readonly property color note: "#FFFFE1" + readonly property color menuBorder: "#C6C6C6" + readonly property color chartLine: "#D9D9D9" + readonly property color chartText: "#595959" + + // Excel's cell styles, used for the mix presets. + readonly property var styles: [ + { name: "Normal", fill: "#FFFFFF", text: "#000000", border: "#D4D4D4", bold: false }, + { name: "Bad", fill: "#FFC7CE", text: "#9C0006", border: "#FFC7CE", bold: false }, + { name: "Good", fill: "#C6EFCE", text: "#006100", border: "#C6EFCE", bold: false }, + { name: "Neutral", fill: "#FFEB9C", text: "#9C5700", border: "#FFEB9C", bold: false }, + { name: "Calculation", fill: "#F2F2F2", text: "#FA7D00", border: "#7F7F7F", bold: true }, + { name: "Check Cell", fill: "#A5A5A5", text: "#FFFFFF", border: "#3F3F3F", bold: true }, + { name: "Note", fill: "#FFFFCC", text: "#000000", border: "#B2B2B2", bold: false } + ] + + readonly property int fsSmall: 11 + readonly property int fsUi: 12 + readonly property int fsCell: 15 // Calibri 11 pt + readonly property int easeMs: 120 + + function colName(i) { + var s = "" + i += 1 + while (i > 0) { + var m = (i - 1) % 26 + s = String.fromCharCode(65 + m) + s + i = Math.floor((i - 1) / 26) + } + return s + } + function time(sec) { + if (!(sec > 0)) sec = 0 + var s = Math.floor(sec), m = Math.floor(s / 60) + return m + ":" + ("0" + (s % 60)).slice(-2) + } +} diff --git a/stemroller/player/qml/StemPlayer/XCheck.qml b/stemroller/player/qml/StemPlayer/XCheck.qml new file mode 100644 index 0000000..33b7967 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/XCheck.qml @@ -0,0 +1,24 @@ +import QtQuick + +// Office checkbox: square box, green tick. +Item { + id: c + property bool checked: false + property string text: "" + signal toggled() + implicitWidth: 18 + lbl.implicitWidth + 4 + implicitHeight: 20 + opacity: enabled ? 1 : 0.4 + Rectangle { + id: box + width: 13 + height: 13 + y: (parent.height - height) / 2 + x: 2 + color: "#FFFFFF" + border.color: ma.containsMouse ? X.green : "#7A7A7A" + Ico { visible: c.checked; anchors.centerIn: parent; name: "check"; size: 12 } + } + T { id: lbl; x: 20; height: parent.height; text: c.text } + MouseArea { id: ma; anchors.fill: parent; hoverEnabled: true; onClicked: c.toggled() } +} diff --git a/stemroller/player/qml/StemPlayer/XField.qml b/stemroller/player/qml/StemPlayer/XField.qml new file mode 100644 index 0000000..525150b --- /dev/null +++ b/stemroller/player/qml/StemPlayer/XField.qml @@ -0,0 +1,17 @@ +import QtQuick +import QtQuick.Controls.Basic + +TextField { + font.family: uiFont + font.pixelSize: X.fsUi + color: X.ink + selectByMouse: true + selectionColor: "#B7D7C4" + selectedTextColor: "#000000" + leftPadding: 5 + rightPadding: 5 + topPadding: 2 + bottomPadding: 2 + implicitHeight: 22 + background: Rectangle { color: "#FFFFFF"; border.color: parent.activeFocus ? X.green : "#ABABAB" } +} diff --git a/stemroller/player/qml/StemPlayer/XMenu.qml b/stemroller/player/qml/StemPlayer/XMenu.qml new file mode 100644 index 0000000..9a4abfe --- /dev/null +++ b/stemroller/player/qml/StemPlayer/XMenu.qml @@ -0,0 +1,48 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Office context menu: white, gray border, icon gutter on the left. +Menu { + id: m + padding: 2 + delegate: MenuItem { + id: mi + implicitWidth: Math.max(200, lab.implicitWidth + 56) + implicitHeight: mi.text === "" ? 7 : 26 + enabled: mi.action ? mi.action.enabled : true + contentItem: Item { + T { + id: lab + x: 28 + anchors.verticalCenter: parent.verticalCenter + text: mi.text + color: mi.enabled ? X.ink : X.inkFaint + } + Ico { + visible: mi.action && mi.action.icon.name !== "" + name: mi.action ? mi.action.icon.name : "" + size: 16 + x: 4 + anchors.verticalCenter: parent.verticalCenter + } + Ico { + visible: mi.checkable && mi.checked + name: "check" + size: 14 + x: 5 + anchors.verticalCenter: parent.verticalCenter + } + } + background: Rectangle { + color: mi.highlighted && mi.enabled ? "#E0E0E0" : "transparent" + } + arrow: null + indicator: null + } + background: Rectangle { + implicitWidth: 200 + color: "#FFFFFF" + border.color: X.menuBorder + Rectangle { x: 25; y: 1; width: 1; height: parent.height - 2; color: "#E7E7E7" } + } +} diff --git a/stemroller/player/qml/StemPlayer/XScrollBar.qml b/stemroller/player/qml/StemPlayer/XScrollBar.qml new file mode 100644 index 0000000..813b910 --- /dev/null +++ b/stemroller/player/qml/StemPlayer/XScrollBar.qml @@ -0,0 +1,18 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Office scrollbar: flat gray thumb on a light track. +ScrollBar { + id: sb + policy: ScrollBar.AlwaysOn + minimumSize: 0.04 + padding: 2 + implicitWidth: 15 + implicitHeight: 15 + contentItem: Rectangle { + implicitWidth: 9 + implicitHeight: 9 + color: sb.pressed ? "#7A7A7A" : sb.hovered ? "#A6A6A6" : "#C2C2C2" + } + background: Rectangle { color: "#F0F0F0"; border.color: "#E0E0E0" } +} diff --git a/stemroller/player/qml/StemPlayer/qmldir b/stemroller/player/qml/StemPlayer/qmldir new file mode 100644 index 0000000..343710a --- /dev/null +++ b/stemroller/player/qml/StemPlayer/qmldir @@ -0,0 +1,25 @@ +module StemPlayer +singleton X 1.0 X.qml +Backstage 1.0 Backstage.qml +CaptionButton 1.0 CaptionButton.qml +FormulaBar 1.0 FormulaBar.qml +Ico 1.0 Ico.qml +Main 1.0 Main.qml +MessageBar 1.0 MessageBar.qml +OfficeButton 1.0 OfficeButton.qml +RButton 1.0 RButton.qml +ResizeEdge 1.0 ResizeEdge.qml +RGroup 1.0 RGroup.qml +Ribbon 1.0 Ribbon.qml +Sheet 1.0 Sheet.qml +SheetTabs 1.0 SheetTabs.qml +StatusBar 1.0 StatusBar.qml +StemChart 1.0 StemChart.qml +TaskPane 1.0 TaskPane.qml +Tip 1.0 Tip.qml +TitleBar 1.0 TitleBar.qml +T 1.0 T.qml +XCheck 1.0 XCheck.qml +XField 1.0 XField.qml +XMenu 1.0 XMenu.qml +XScrollBar 1.0 XScrollBar.qml diff --git a/stemroller/player/sheets.py b/stemroller/player/sheets.py new file mode 100644 index 0000000..14f519c --- /dev/null +++ b/stemroller/player/sheets.py @@ -0,0 +1,149 @@ +"""The workbook: every view is a sheet (columns + rows) shown in the Excel grid.""" + +import time +import unicodedata + +from PySide6.QtCore import QAbstractTableModel, QByteArray, QModelIndex, Qt + +# Column formats: how a value is shown, aligned and summed in the status bar. +# text, int, year, time (ms -> m:ss), stems (count of stems, shown TRUE/FALSE-ish), date (unix s) +COLUMNS = { + "songs": [ + ("title", "Title", 300, "text"), ("artist", "Artist", 190, "text"), ("album", "Album", 230, "text"), + ("year", "Year", 64, "year"), ("durationMs", "Time", 64, "time"), ("stems", "Stems", 70, "stems"), + ("plays", "Plays", 64, "int"), + ], + "albumSongs": [ + ("index", "#", 44, "int"), ("title", "Title", 320, "text"), ("artist", "Artist", 200, "text"), + ("durationMs", "Time", 64, "time"), ("stems", "Stems", 70, "stems"), ("plays", "Plays", 64, "int"), + ], + "artists": [ + ("title", "Artist", 280, "text"), ("albums", "Albums", 70, "int"), ("songs", "Songs", 70, "int"), + ("stemSongs", "With stems", 90, "int"), ("genre", "Genre", 200, "text"), + ], + "albums": [ + ("title", "Album", 300, "text"), ("artist", "Artist", 200, "text"), ("year", "Year", 64, "year"), + ("tracks", "Songs", 64, "int"), ("stemSongs", "With stems", 90, "int"), ("genre", "Genre", 160, "text"), + ("addedAt", "Added", 96, "date"), + ], + "playlists": [ + ("title", "Playlist", 300, "text"), ("tracks", "Songs", 70, "int"), ("durationMs", "Length", 80, "time"), + ("kind", "Type", 80, "text"), ("updatedAt", "Updated", 96, "date"), + ], + "queue": [ + ("pos", "#", 44, "int"), ("title", "Title", 300, "text"), ("artist", "Artist", 190, "text"), + ("album", "Album", 230, "text"), ("durationMs", "Time", 64, "time"), ("stems", "Stems", 70, "stems"), + ], + "search": [ + ("type", "Type", 70, "text"), ("title", "Name", 300, "text"), ("artist", "Artist", 190, "text"), + ("album", "Album", 230, "text"), ("year", "Year", 64, "year"), ("durationMs", "Time", 64, "time"), + ("stems", "Stems", 70, "stems"), + ], +} + +# Plex row kind -> what a double-click does +SONG, ARTIST, ALBUM, PLAYLIST = "song", "artist", "album", "playlist" + + +def fold(s: str) -> str: + """Case- and accent-insensitive form for search and sorting.""" + s = unicodedata.normalize("NFKD", s or "") + return "".join(c for c in s if not unicodedata.combining(c)).casefold() + + +def fmt_time(ms) -> str: + s = int(round((ms or 0) / 1000)) + h, m = divmod(s // 60, 60) + return f"{h}:{m:02d}:{s % 60:02d}" if h else f"{m}:{s % 60:02d}" + + +def fmt(value, kind) -> str: + if kind == "time": + return fmt_time(value) if value else "" + if kind == "year": + return str(value) if value else "" + if kind == "int": + return "" if value in (None, "") else str(value) + if kind == "stems": + return f"{value}" if value else "" + if kind == "date": + return time.strftime("%Y-%m-%d", time.localtime(value)) if value else "" + return "" if value is None else str(value) + + +class Sheet: + """A tab: its rows, columns and what the rows are.""" + + def __init__(self, title, columns, rows, kind=SONG, sid=None, loading=False): + self.title = title + self.columns = COLUMNS[columns] + self.layout = columns + self.rows = rows + self.kind = kind + self.sid = sid or title + self.loading = loading + self.sort = None # (column, descending) + + def row_kind(self, r): + return self.rows[r].get("_kind", self.kind) + + +class SheetModel(QAbstractTableModel): + """One sheet for the QML TableView. Roles: display, align, style, playing.""" + + ROLES = {Qt.ItemDataRole.DisplayRole: b"display", Qt.ItemDataRole.UserRole + 1: b"align", + Qt.ItemDataRole.UserRole + 2: b"cellStyle", Qt.ItemDataRole.UserRole + 3: b"playing", + Qt.ItemDataRole.UserRole + 4: b"bold"} + + def __init__(self, parent=None): + super().__init__(parent) + self.sheet: Sheet | None = None + self.playing_key = "" + self.playing_pos = -1 # for the queue sheet, where the same song can appear twice + + def set_sheet(self, sheet): + self.beginResetModel() + self.sheet = sheet + self.endResetModel() + + def refresh(self): + self.beginResetModel() + self.endResetModel() + + def set_playing(self, key, pos): + self.playing_key, self.playing_pos = key, pos + if self.sheet and self.sheet.rows: + self.dataChanged.emit(self.index(0, 0), self.index(len(self.sheet.rows) - 1, len(self.sheet.columns) - 1), + [Qt.ItemDataRole.UserRole + 3, Qt.ItemDataRole.UserRole + 4]) + + def roleNames(self): + return {k: QByteArray(v) for k, v in self.ROLES.items()} + + def rowCount(self, parent=QModelIndex()): + return len(self.sheet.rows) if self.sheet else 0 + + def columnCount(self, parent=QModelIndex()): + return len(self.sheet.columns) if self.sheet else 0 + + def data(self, index, role=Qt.ItemDataRole.DisplayRole): + s = self.sheet + if s is None or not index.isValid(): + return None + row = s.rows[index.row()] + key, _, _, kind = s.columns[index.column()] + if role == Qt.ItemDataRole.DisplayRole: + return fmt(row.get(key), kind) + if role == Qt.ItemDataRole.UserRole + 1: + return "left" if kind in ("text", "stems") else "right" + if role == Qt.ItemDataRole.UserRole + 2: + # Conditional formatting: "Good" for songs with stems, a data bar for stem counts. + if kind == "stems" and row.get(key): + return "good" + if key == "stemSongs" and row.get(key): + return "bar:%.3f" % (row[key] / max(1, row.get("tracks") or row.get("songs") or row[key])) + return "" + if role in (Qt.ItemDataRole.UserRole + 3, Qt.ItemDataRole.UserRole + 4): + if s.layout == "queue": + return row.get("pos") == self.playing_pos + 1 + return s.row_kind(index.row()) == SONG and row.get("key") == self.playing_key and bool(self.playing_key) + return None diff --git a/stemroller/player/stems.py b/stemroller/player/stems.py new file mode 100644 index 0000000..8be6e12 --- /dev/null +++ b/stemroller/player/stems.py @@ -0,0 +1,153 @@ +"""stemserve's index, matched to Plex tracks by path (a port of the phone app's StemIndex).""" + +import json +import os +import unicodedata +import urllib.error +import urllib.parse +import urllib.request + +# Display order and colours, matching the desktop separator and the phone. +ORDER = ["vocals", "drums", "bass", "guitar", "piano", "other", "instrumental", "mix"] +COLORS = { + "vocals": "#FF7AB6", "drums": "#FFB547", "bass": "#7C8CFF", "other": "#4CD07D", + "guitar": "#FF8A5C", "piano": "#B48CFF", "instrumental": "#3DD6C6", "mix": "#8E8E93", +} + + +def sort_names(names): + return sorted(names, key=lambda n: ORDER.index(n) if n in ORDER else 99) + + +def norm(path: str) -> str: + """NFC, forward slashes, no extension, lower case.""" + p = unicodedata.normalize("NFC", path).replace("\\", "/") + slash, dot = p.rfind("/"), p.rfind(".") + if dot > slash + 1: + p = p[:dot] + return p.lower() + + +class StemIndex: + """Maps Plex file paths to stem folders. + + The stems folder mirrors the music folder, so the source path relative to the music root + identifies a track. Plex reports paths as its container sees them, so the root is unknown + up front: every suffix of the Plex path is tried, longest first. A bare file name, or a + suffix whose duration disagrees, only counts under a root learned from a longer match. + """ + + def __init__(self, entries=(), roots=()): + self.entries = list(entries) + self.by_source = {} + self.by_key = {} + for e in self.entries: + self.by_source.setdefault(norm(e["source"]), e) + self.by_key[e["key"]] = e + self.roots = list(dict.fromkeys(roots)) + + def __len__(self): + return len(self.entries) + + def find(self, plex_path, duration_ms=0): + if not plex_path or not self.entries: + return None + path = norm(plex_path) + for root in self.roots: + if path.startswith(root): + hit = self.by_source.get(path[len(root):]) + if hit: + return hit + parts = path.split("/") + for i in range(1, len(parts)): + hit = self.by_source.get("/".join(parts[i:])) + if hit is None: + continue + if len(parts) - i >= 2 and self._duration_ok(hit, duration_ms): + self.roots.append("/".join(parts[:i]) + "/") + return hit + return None + + @staticmethod + def _duration_ok(e, duration_ms): + d = e.get("duration") + return d is None or duration_ms <= 0 or abs(d * 1000 - duration_ms) < 3000 + + +class StemServer: + """Client for server/stemserve.py. Files come from the local mount when it's there.""" + + def __init__(self, config, cache_dir): + self.cfg = config + self.cache_dir = cache_dir + self.index = StemIndex(roots=config.get("stemRoots", [])) + self.online = None # not checked yet + self._index_file = os.path.join(cache_dir, "stem_index.json") + self._etag_file = os.path.join(cache_dir, "stem_index.etag") + try: + with open(self._index_file) as f: + self.index = StemIndex(json.load(f).get("tracks", []), self.index.roots) + except (OSError, ValueError): + pass + + @property + def base(self): + return self.cfg["stemUrl"].rstrip("/") + + def _open(self, url, headers=None, timeout=15): + h = dict(headers or {}) + if self.cfg.get("stemToken"): + h["X-Stem-Token"] = self.cfg["stemToken"] + return urllib.request.urlopen(urllib.request.Request(url, headers=h), timeout=timeout) + + def refresh(self): + """Fetches the index (ETag-cached). Returns True if it changed.""" + headers = {} + if os.path.exists(self._etag_file) and os.path.exists(self._index_file): + with open(self._etag_file) as f: + headers["If-None-Match"] = f.read().strip() + try: + with self._open(self.base + "/api/index", headers) as r: + body = r.read() + etag = r.headers.get("ETag") + except urllib.error.HTTPError as e: + self.online = e.code == 304 + return False + except (urllib.error.URLError, TimeoutError, OSError): + self.online = False + return False + self.online = True + data = json.loads(body) + self.index = StemIndex(data.get("tracks", []), self.index.roots) + os.makedirs(self.cache_dir, exist_ok=True) + with open(self._index_file, "wb") as f: + f.write(body) + if etag: + with open(self._etag_file, "w") as f: + f.write(etag) + return True + + def find(self, track): + hit = self.index.find(track.get("partFile"), track.get("durationMs", 0)) + if self.index.roots != self.cfg.get("stemRoots"): + self.cfg["stemRoots"] = list(self.index.roots) + return hit + + def local_path(self, entry, stem): + root = self.cfg.get("stemsDir", "") + p = os.path.join(root, entry["key"], stem["file"]) if root else "" + return p if p and os.path.exists(p) else None + + def file_url(self, entry, stem): + path = "/".join(urllib.parse.quote(p) for p in entry["key"].split("/")) + return f"{self.base}/file/{path}/{urllib.parse.quote(stem['file'])}" + + def peaks(self, entry, buckets): + """Per-stem RMS envelopes (0..1), or None.""" + url = f"{self.base}/api/peaks?" + urllib.parse.urlencode({"key": entry["key"], "n": buckets}) + try: + with self._open(url, timeout=30) as r: + stems = json.loads(r.read()).get("stems", {}) + return {name: [v / 1000 for v in arr] for name, arr in stems.items()} + except (urllib.error.URLError, TimeoutError, OSError, ValueError): + return None diff --git a/stemroller/providers.py b/stemroller/providers.py new file mode 100644 index 0000000..a8fd826 --- /dev/null +++ b/stemroller/providers.py @@ -0,0 +1,317 @@ +"""QML image providers. Everything here renders off the UI thread and is +uploaded once as a texture: no per-frame CPU work, no live blur. + + image://icon// Material icon tinted, sized by sourceSize + image://fx/backdrop/x/ window background (aurora) + image://fx/glass/x// blurred + tinted snapshot of the backdrop + image://fx/glasscrop/x///,,,/ rounded glass sheet + image://fx/shadow/// 9-patch elevation shadow + image://fx/glow/// 9-patch hover glow + image://fx/stripes/ progress stripe tile + image://fx/noise dither tile + image://wave///x///[/] +""" + +import threading + +import numpy as np +from PySide6.QtCore import QByteArray, QRectF, Qt +from PySide6.QtGui import QImage, QPainter +from PySide6.QtQuick import QQuickImageProvider +from PySide6.QtSvg import QSvgRenderer +from scipy.ndimage import gaussian_filter + +# Material Icons (Apache 2.0), 24x24 viewBox. +ICONS = { + "play": "M8 5v14l11-7z", + "pause": "M6 19h4V5H6v14zm8-14v14h4V5h-4z", + "stop": "M6 6h12v12H6z", + "skip_start": "M6 6h2v12H6zm3.5 6l8.5 6V6z", + "close": "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z", + "minimize": "M5 11h14v2H5z", + "maximize": "M18 4H6c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 14H6V6h12v12z", + "restore": "M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z", + "settings": "M19.14 12.94c.04-.3.06-.61.06-.94 0-.32-.02-.64-.07-.94l2.03-1.58c.18-.14.23-.41.12-.61l-1.92-3.32c-.12-.22-.37-.29-.59-.22l-2.39.96c-.5-.38-1.03-.7-1.62-.94l-.36-2.54c-.04-.24-.24-.41-.48-.41h-3.84c-.24 0-.43.17-.47.41l-.36 2.54c-.59.24-1.13.57-1.62.94l-2.39-.96c-.22-.08-.47 0-.59.22L2.74 8.87c-.12.21-.08.47.12.61l2.03 1.58c-.05.3-.09.63-.09.94s.02.64.07.94l-2.03 1.58c-.18.14-.23.41-.12.61l1.92 3.32c.12.22.37.29.59.22l2.39-.96c.5.38 1.03.7 1.62.94l.36 2.54c.05.24.24.41.48.41h3.84c.24 0 .44-.17.47-.41l.36-2.54c.59-.24 1.13-.56 1.62-.94l2.39.96c.22.08.47 0 .59-.22l1.92-3.32c.12-.22.07-.47-.12-.61l-2.01-1.58zM12 15.6c-1.98 0-3.6-1.62-3.6-3.6s1.62-3.6 3.6-3.6 3.6 1.62 3.6 3.6-1.62 3.6-3.6 3.6z", + "folder": "M20 6h-8l-2-2H4c-1.1 0-1.99.9-1.99 2L2 18c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V8c0-1.1-.9-2-2-2zm0 12H4V8h16v10z", + "download": "M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z", + "check": "M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z", + "error": "M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z", + "refresh": "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z", + "add": "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z", + "music": "M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z", + "volume": "M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z", + "volume_off": "M16.5 12c0-1.77-1.02-3.29-2.5-4.03v2.21l2.45 2.45c.03-.2.05-.41.05-.63zm2.5 0c0 .94-.2 1.82-.54 2.64l1.51 1.51C20.63 14.91 21 13.5 21 12c0-4.28-2.99-7.86-7-8.77v2.06c2.89.86 5 3.54 5 6.71zM4.27 3L3 4.27 7.73 9H3v6h4l5 5v-6.73l4.25 4.25c-.67.52-1.42.93-2.25 1.18v2.06c1.38-.31 2.63-.95 3.69-1.81L19.73 21 21 19.73l-9-9L4.27 3zM12 4L9.91 6.09 12 8.18V4z", + "headphones": "M12 1c-4.97 0-9 4.03-9 9v7c0 1.66 1.34 3 3 3h3v-8H5v-2c0-3.87 3.13-7 7-7s7 3.13 7 7v2h-4v8h3c1.66 0 3-1.34 3-3v-7c0-4.97-4.03-9-9-9z", + "chip": "M15 9H9v6h6V9zm-2 4h-2v-2h2v2zm8-2V9h-2V7c0-1.1-.9-2-2-2h-2V3h-2v2h-2V3H9v2H7c-1.1 0-2 .9-2 2v2H3v2h2v2H3v2h2v2c0 1.1.9 2 2 2h2v2h2v-2h2v2h2v-2h2c1.1 0 2-.9 2-2v-2h2v-2h-2v-2h2zm-4 6H7V7h10v10z", + "delete": "M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z", + "upload": "M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z", + "equalizer": "M7 18h2V6H7v12zm4 4h2V2h-2v20zm-8-8h2v-4H3v4zm12 4h2V6h-2v12zm4-8v4h2v-4h-2z", + "expand": "M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z", + "layers": "M11.99 18.54l-7.37-5.73L3 14.07l9 7 9-7-1.63-1.27-7.38 5.74zM12 16l7.36-5.73L21 9l-9-7-9 7 1.63 1.27L12 16z", + "zoom_out": "M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14zM7 9h5v1H7z", + "speed": "M20.38 8.57l-1.23 1.85a8 8 0 0 1-.22 7.58H5.07A8 8 0 0 1 15.58 6.85l1.85-1.23A10 10 0 0 0 3.35 19a2 2 0 0 0 1.72 1h13.85a2 2 0 0 0 1.74-1 10 10 0 0 0-.27-10.44zm-9.79 6.84a2 2 0 0 0 2.83 0l5.66-8.49-8.49 5.66a2 2 0 0 0 0 2.83z", +} + + +def _hex(c): + c = c.lstrip("#") + return np.array([int(c[i:i + 2], 16) for i in (0, 2, 4)], np.float32) / 255 + + +def _to_qimage(rgba: np.ndarray) -> QImage: + """float RGBA [0,1] (H, W, 4), straight alpha -> premultiplied QImage (copies).""" + a = np.clip(rgba[..., 3:4], 0, 1) + out = np.empty(rgba.shape, np.uint8) + out[..., :3] = np.clip(rgba[..., :3] * a * 255 + 0.5, 0, 255) + out[..., 3:] = np.clip(a * 255 + 0.5, 0, 255) + h, w = out.shape[:2] + return QImage(out.data, w, h, w * 4, QImage.Format.Format_RGBA8888_Premultiplied).copy() + + +class IconProvider(QQuickImageProvider): + def __init__(self): + super().__init__(QQuickImageProvider.ImageType.Image) + + def requestImage(self, id_, size, requested): + parts = id_.split("/") + name, color = parts[0], (parts[1] if len(parts) > 1 else "ECEDEF") + w = requested.width() if requested.width() > 0 else 24 + h = requested.height() if requested.height() > 0 else w + svg = (f"" + f"") + img = QImage(w, h, QImage.Format.Format_ARGB32_Premultiplied) + img.fill(Qt.GlobalColor.transparent) + p = QPainter(img) + p.setRenderHint(QPainter.RenderHint.Antialiasing) + QSvgRenderer(QByteArray(svg.encode())).render(p, QRectF(0, 0, w, h)) + p.end() + return img + + +# ---- backdrop / glass --------------------------------------------------- + +BG = _hex("1D1E21") +GLASS_TINT = _hex("242529") +# (color, cx, cy, sigma as fraction of the larger side, strength) +# Kept faint so the window reads as neutral dark gray with a hint of Aero colour. +BLOBS = [ + (_hex("3BA8FF"), 0.10, 0.05, 0.30, 0.14), + (_hex("7C8CFF"), 0.62, 0.18, 0.22, 0.06), + (_hex("5FE3FF"), 0.92, 0.95, 0.26, 0.07), + (_hex("FF7AB6"), 0.02, 0.98, 0.18, 0.025), +] +# Aero-style diagonal light beams: (offset fraction, width fraction, strength) +BEAMS = [(0.18, 0.025, 0.035), (0.30, 0.06, 0.025), (0.74, 0.04, 0.02)] + + +def _backdrop(w, h, blur_px=0.0, crop=None): + """Analytic aurora; blurring a gaussian blob is a wider gaussian, so the + 'blurred snapshot' is exact and costs the same as the sharp one. + crop=(x, y, cw, ch) renders only that window-space rectangle.""" + big = max(w, h) + cx0, cy0, cw, ch = crop or (0, 0, w, h) + x = np.arange(cx0, cx0 + cw, dtype=np.float32) + y = np.arange(cy0, cy0 + ch, dtype=np.float32) + img = np.empty((ch, cw, 3), np.float32) + img[:] = BG + for color, cx, cy, sig, strength in BLOBS: + s0 = sig * big + s = np.sqrt(s0 * s0 + blur_px * blur_px) + amp = strength * (s0 / s) ** 2 + gx = np.exp(-((x - cx * w) ** 2) / (2 * s * s)) + gy = np.exp(-((y - cy * h) ** 2) / (2 * s * s)) + img += np.outer(gy * amp, gx)[..., None] * color + # beams run along x + 0.55 y = const + d = (x[None, :] + 0.55 * y[:, None]) / (big * 1.55) + for off, width, strength in BEAMS: + s0 = width + s = np.sqrt(s0 * s0 + (blur_px / (big * 1.55)) ** 2) + img += (strength * (s0 / s) * np.exp(-((d - off) ** 2) / (2 * s * s)))[..., None] + return img + + +def _round_alpha(h, w, r): + a = np.ones((h, w), np.float32) + if r <= 0: + return a + yy, xx = np.mgrid[0:r, 0:r].astype(np.float32) + 0.5 + dist = np.sqrt((r - xx) ** 2 + (r - yy) ** 2) + corner = np.clip(r - dist + 0.5, 0, 1) + a[:r, :r] = corner + a[:r, -r:] = corner[:, ::-1] + a[-r:, :r] = corner[::-1, :] + a[-r:, -r:] = corner[::-1, ::-1] + return a + + +class FxProvider(QQuickImageProvider): + def __init__(self): + super().__init__(QQuickImageProvider.ImageType.Image) + self._cache: dict[str, QImage] = {} + self._lock = threading.Lock() + + def requestImage(self, id_, size, requested): + with self._lock: + hit = self._cache.get(id_) + if hit is not None: + return hit + img = self._make(id_.split("/")) + with self._lock: + if len(self._cache) > 48: + self._cache.clear() + self._cache[id_] = img + return img + + def _make(self, p): + kind = p[0] + if kind in ("backdrop", "glass", "glasscrop"): + w, h = (max(1, int(v)) for v in p[1].split("x")) + r = int(p[2]) + crop = None + if kind == "glasscrop": # x///,,,: a rounded glass sheet (dialogs) + crop = tuple(max(0, int(float(v))) for v in p[4].split(",")) + crop = (crop[0], crop[1], max(1, crop[2]), max(1, crop[3])) + if kind == "backdrop": + rgb = _backdrop(w, h) + noise = np.random.default_rng(1).random((h, w, 1), dtype=np.float32) + rgb += (noise - 0.5) / 255 # dither the dark gradients + else: + rgb = _backdrop(w, h, blur_px=float(p[3]), crop=crop) + rgb = rgb * 0.30 + GLASS_TINT * 0.70 # glass-tint rgba(36,37,41,0.70) + # glass sheen: one broad soft highlight along the top-left + ox, oy = (crop[0], crop[1]) if crop else (0, 0) + hh, ww = rgb.shape[:2] + d = (np.arange(ox, ox + ww)[None, :] + 1.4 * np.arange(oy, oy + hh)[:, None]) / max(w, h) + rgb += (0.035 * np.exp(-((d - 0.08) ** 2) / 0.004))[..., None] + if crop: + r = int(p[3 + 2]) if len(p) > 5 else 12 + hh, ww = rgb.shape[:2] + rgba = np.concatenate([rgb, _round_alpha(hh, ww, r)[..., None]], axis=2) + return _to_qimage(rgba) + if kind in ("shadow", "glow"): + if kind == "shadow": + color, sigma, alpha, r = np.zeros(3, np.float32), float(p[1]), float(p[2]), int(p[3]) + else: + color, sigma, alpha, r = _hex(p[1]), float(p[2]), 0.9, int(p[3]) + m = int(np.ceil(sigma * 3)) + 1 + n = 2 * m + 2 * r + 2 + mask = np.zeros((n, n), np.float32) + core = _round_alpha(2 * r + 2, 2 * r + 2, r) + mask[m:m + 2 * r + 2, m:m + 2 * r + 2] = core + blurred = gaussian_filter(mask, sigma) * alpha + rgba = np.zeros((n, n, 4), np.float32) + rgba[..., :3] = color + rgba[..., 3] = blurred + return _to_qimage(rgba) + if kind == "stripes": + h = int(p[1]) + period = 2 * h + xx, yy = np.meshgrid(np.arange(period) + 0.5, np.arange(h) + 0.5) + phase = ((xx + yy) % period) / period + band = np.clip(np.minimum(phase, 1 - phase) * period - h / 2 + 0.5, 0, 1) + rgba = np.zeros((h, period, 4), np.float32) + rgba[..., :3] = 1 + rgba[..., 3] = band * 0.22 + return _to_qimage(rgba) + if kind == "noise": + rng = np.random.default_rng(7) + v = rng.random((256, 256), dtype=np.float32) + rgba = np.zeros((256, 256, 4), np.float32) + rgba[..., :3] = v[..., None] + rgba[..., 3] = 0.025 + return _to_qimage(rgba) + img = QImage(1, 1, QImage.Format.Format_RGBA8888_Premultiplied) + img.fill(Qt.GlobalColor.transparent) + return img + + +# ---- waveforms ------------------------------------------------------------ + +class PeakStore: + """Loaded peak pyramids keyed by job id. Shared with the controller.""" + + def __init__(self): + self._data: dict[str, dict] = {} + self._lock = threading.Lock() + + def get(self, job_id, path): + with self._lock: + entry = self._data.get(job_id) + if entry is None or entry["path"] != path: + with np.load(path) as z: + levels: dict[str, list] = {} + for key in z.files: + if "/" in key: + stem, k = key.split("/") + levels.setdefault(stem, []).append((int(k), z[key].astype(np.float32))) + entry = {"path": path, "sr": int(z["samplerate"]), "base": int(z["base"]), + "levels": {s: [a for _, a in sorted(v)] for s, v in levels.items()}} + with self._lock: + self._data[job_id] = entry + return entry + + def drop(self, job_id): + with self._lock: + self._data.pop(job_id, None) + + +class WaveformProvider(QQuickImageProvider): + def __init__(self, store: PeakStore, paths_for): + super().__init__(QQuickImageProvider.ImageType.Image) + self.store = store + self.paths_for = paths_for # job_id -> peaks_path (or None) + + def requestImage(self, id_, size, requested): + p = id_.split("/") + job_id, stem = p[0], p[1] + w, h = (max(1, int(v)) for v in p[2].split("x")) + t0, t1, color = float(p[3]), float(p[4]), _hex(p[5]) + path = self.paths_for(job_id) + rgba = np.zeros((h, w, 4), np.float32) + if path: + try: + entry = self.store.get(job_id, path) + levels = entry["levels"].get(stem) + if levels: + rgba = render_wave(levels, entry["base"], entry["sr"], t0, t1, w, h, color) + except Exception: + pass + return _to_qimage(rgba) + + +def render_wave(levels, base, sr, t0, t1, w, h, color): + s0, s1 = t0 * sr, max(t0 * sr + 1, t1 * sr) + spp = (s1 - s0) / w # samples per pixel + k = 0 + while k + 1 < len(levels) and base * 2 ** (k + 1) <= spp: + k += 1 + lvl = levels[k] + bucket = base * 2 ** k + edges = np.linspace(s0 / bucket, s1 / bucket, w + 1) + starts = np.clip(edges[:-1].astype(np.int64), 0, len(lvl) - 1) + ends = np.clip(np.ceil(edges[1:]).astype(np.int64), 1, len(lvl)) + ends = np.maximum(ends, starts + 1) + # reduceat spans starts[i]..starts[i+1]; trim so the last pixel stops at its own edge + view = lvl[:ends[-1]] + lo = np.minimum.reduceat(view[:, 0], starts) + hi = np.maximum.reduceat(view[:, 1], starts) + valid = (edges[:-1] >= 0) & (edges[:-1] < len(lvl)) + lo = np.where(valid, np.clip(lo, -1, 1), 0) + hi = np.where(valid, np.clip(hi, -1, 1), 0) + + mid = h / 2 + amp = mid - 1 + top = mid - hi * amp + bot = mid - lo * amp + # at least 1px tall so silence reads as a line + short = bot - top < 1 + top = np.where(short, mid - 0.5, top) + bot = np.where(short, mid + 0.5, bot) + rows = np.arange(h, dtype=np.float32)[:, None] + 0.5 + cov = np.clip(np.minimum(rows - top[None, :] + 0.5, bot[None, :] - rows + 0.5), 0, 1) + # brighter toward the centre line, like a lit glass bar + shade = 0.55 + 0.45 * (1 - np.abs(rows - mid) / mid) + rgba = np.empty((h, w, 4), np.float32) + rgba[..., :3] = color + rgba[..., 3] = cov * shade + return rgba diff --git a/stemroller/qml/StemRoller/AeroButton.qml b/stemroller/qml/StemRoller/AeroButton.qml new file mode 100644 index 0000000..a1a78b3 --- /dev/null +++ b/stemroller/qml/StemRoller/AeroButton.qml @@ -0,0 +1,84 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Glossy pill, 40px. variant: "filled" | "tonal" | "text". Cyan glow on hover. +Button { + id: b + property string iconName: "" + property string variant: "filled" + property color tone: Theme.primary + property int pillHeight: 40 + readonly property bool filled: variant === "filled" + readonly property bool tonal: variant === "tonal" + readonly property color fg: filled ? "#FFFFFF" : (variant === "text" ? tone : Theme.textHi) + + implicitHeight: pillHeight + implicitWidth: Math.max(pillHeight, row.implicitWidth + leftPadding + rightPadding) + leftPadding: text.length ? (iconName.length ? 14 : 18) : 0 + rightPadding: text.length ? 18 : 0 + font.family: Theme.fontFamily + font.pixelSize: Theme.fs14 + font.weight: Font.DemiBold + hoverEnabled: true + focusPolicy: Qt.TabFocus + opacity: enabled ? 1 : 0.4 + + contentItem: Item { + implicitWidth: row.implicitWidth + implicitHeight: row.implicitHeight + Row { + id: row + anchors.centerIn: parent + spacing: 8 + Icon { + visible: b.iconName.length > 0 + name: b.iconName + color: b.fg + size: 18 + anchors.verticalCenter: parent.verticalCenter + } + Txt { + visible: b.text.length > 0 + text: b.text + font: b.font + color: b.fg + anchors.verticalCenter: parent.verticalCenter + } + } + } + + background: Item { + implicitHeight: b.pillHeight + Glow { + radius: Math.round(b.pillHeight / 2) + opacity: (b.hovered || b.visualFocus) && b.enabled ? (b.filled ? 0.55 : 0.35) : 0 + } + Rectangle { + id: base + anchors.fill: parent + radius: height / 2 + color: b.filled ? b.tone : (b.tonal ? Theme.alpha(b.tone, 0.16) : "transparent") + border.width: b.variant === "text" ? 0 : 1 + border.color: b.filled ? Qt.lighter(b.tone, 1.3) : Theme.alpha(b.tone, 0.35) + + // Aero gloss on the top half + Rectangle { + visible: b.variant !== "text" + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 1 } + height: (parent.height - 2) / 2 + topLeftRadius: height + topRightRadius: height + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, b.filled ? 0.32 : 0.10) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, b.filled ? 0.06 : 0.0) } + } + } + Rectangle { + anchors.fill: parent + radius: parent.radius + color: b.down ? Qt.rgba(0, 0, 0, 0.18) : (b.hovered ? Qt.rgba(1, 1, 1, 0.07) : "transparent") + Behavior on color { ColorAnimation { duration: Theme.fast } } + } + } + } +} diff --git a/stemroller/qml/StemRoller/AeroComboBox.qml b/stemroller/qml/StemRoller/AeroComboBox.qml new file mode 100644 index 0000000..f3dc9be --- /dev/null +++ b/stemroller/qml/StemRoller/AeroComboBox.qml @@ -0,0 +1,133 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Tonal glossy dropdown; menu on surface-2 at elevation 3. +ComboBox { + id: control + property string iconName: "" + property string subRole: "sub" + property string caption: "" + property int popupWidth: 280 + textRole: "label" + valueRole: "id" + implicitHeight: 36 + hoverEnabled: true + font.family: Theme.fontFamily + font.pixelSize: Theme.fs14 + + background: Item { + Glow { radius: 18; sigma: 4; opacity: (control.hovered || control.visualFocus) ? 0.3 : 0 } + Rectangle { + anchors.fill: parent + radius: height / 2 + color: control.down || control.popup.visible ? Qt.rgba(1, 1, 1, 0.11) : (control.hovered ? Qt.rgba(1, 1, 1, 0.08) : Qt.rgba(1, 1, 1, 0.05)) + border.color: control.popup.visible ? Theme.alpha(Theme.accentGlow, 0.6) : Qt.rgba(1, 1, 1, 0.10) + Behavior on color { ColorAnimation { duration: Theme.fast } } + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 1 } + height: (parent.height - 2) / 2 + topLeftRadius: height + topRightRadius: height + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.08) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.0) } + } + } + } + } + + contentItem: Row { + leftPadding: control.iconName.length ? 12 : 16 + spacing: 8 + Icon { + visible: control.iconName.length > 0 + name: control.iconName + size: 18 + color: Theme.accentGlow + anchors.verticalCenter: parent.verticalCenter + } + Column { + anchors.verticalCenter: parent.verticalCenter + Txt { + visible: control.caption.length > 0 + text: control.caption + font.pixelSize: 10 + font.weight: Font.DemiBold + font.letterSpacing: 0.6 + color: Theme.textLo + } + Txt { + text: control.displayText + font: control.font + width: control.width - 64 + } + } + } + + indicator: Icon { + x: control.width - width - 10 + anchors.verticalCenter: control.verticalCenter + name: "expand" + size: 18 + color: Theme.textLo + rotation: control.popup.visible ? 180 : 0 + Behavior on rotation { NumberAnimation { duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + } + + delegate: ItemDelegate { + id: d + required property var modelData + required property int index + width: ListView.view ? ListView.view.width : control.popupWidth + height: 52 + highlighted: control.highlightedIndex === index + hoverEnabled: true + contentItem: Column { + spacing: 2 + leftPadding: 4 + anchors.verticalCenter: parent ? parent.verticalCenter : undefined + Txt { + text: d.modelData[control.textRole] + font.weight: control.currentIndex === d.index ? Font.DemiBold : Font.Normal + color: control.currentIndex === d.index ? Theme.accentGlow : Theme.textHi + } + Txt { + text: d.modelData[control.subRole] || "" + visible: text.length > 0 + font.pixelSize: Theme.fs12 + color: Theme.textLo + } + } + background: Rectangle { + radius: 6 + color: d.highlighted ? Theme.alpha(Theme.primary, 0.18) : (d.hovered ? Qt.rgba(1, 1, 1, 0.05) : "transparent") + } + } + + popup: Popup { + y: control.height + 6 + width: Math.max(control.width, control.popupWidth) + padding: 6 + transformOrigin: Item.Top + implicitHeight: Math.min(contentItem.implicitHeight + 12, 420) + contentItem: ListView { + clip: true + implicitHeight: contentHeight + model: control.popup.visible ? control.delegateModel : null + currentIndex: control.highlightedIndex + spacing: 2 + boundsBehavior: Flickable.StopAtBounds + } + background: Rectangle { + color: Theme.surface2 + radius: 8 + border.color: Theme.outline + Elevation { level: 3; radius: 8 } + } + enter: Transition { + NumberAnimation { property: "opacity"; from: 0; to: 1; duration: Theme.fast } + NumberAnimation { property: "scale"; from: 0.96; to: 1; duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } + } + exit: Transition { NumberAnimation { property: "opacity"; from: 1; to: 0; duration: Theme.fast } } + } +} diff --git a/stemroller/qml/StemRoller/AeroSlider.qml b/stemroller/qml/StemRoller/AeroSlider.qml new file mode 100644 index 0000000..9f69301 --- /dev/null +++ b/stemroller/qml/StemRoller/AeroSlider.qml @@ -0,0 +1,46 @@ +import QtQuick +import QtQuick.Controls.Basic + +Slider { + id: s + property color tone: Theme.primary + implicitHeight: 24 + hoverEnabled: true + background: Rectangle { + x: s.leftPadding + y: s.topPadding + s.availableHeight / 2 - height / 2 + width: s.availableWidth + height: 4 + radius: 2 + color: Qt.rgba(1, 1, 1, 0.10) + Rectangle { + width: s.visualPosition * parent.width + height: parent.height + radius: 2 + gradient: Gradient { + orientation: Gradient.Horizontal + GradientStop { position: 0; color: Theme.alpha(s.tone, 0.7) } + GradientStop { position: 1; color: s.tone } + } + } + } + handle: Item { + x: s.leftPadding + s.visualPosition * (s.availableWidth - width) + y: s.topPadding + s.availableHeight / 2 - height / 2 + width: 14 + height: 14 + Glow { radius: 7; sigma: 4; color: s.tone; opacity: s.hovered || s.pressed ? 0.6 : 0 } + Rectangle { + anchors.fill: parent + radius: 7 + color: s.pressed ? Qt.lighter(s.tone, 1.2) : s.tone + border.color: Qt.lighter(s.tone, 1.4) + Rectangle { // gloss + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 2 } + height: 5 + radius: 3 + color: Qt.rgba(1, 1, 1, 0.45) + } + } + } +} diff --git a/stemroller/qml/StemRoller/AeroSwitch.qml b/stemroller/qml/StemRoller/AeroSwitch.qml new file mode 100644 index 0000000..7ef846e --- /dev/null +++ b/stemroller/qml/StemRoller/AeroSwitch.qml @@ -0,0 +1,43 @@ +import QtQuick +import QtQuick.Controls.Basic + +Switch { + id: sw + hoverEnabled: true + font.family: Theme.fontFamily + font.pixelSize: Theme.fs14 + spacing: 12 + indicator: Rectangle { + implicitWidth: 40 + implicitHeight: 22 + x: sw.leftPadding + y: parent.height / 2 - height / 2 + radius: 11 + color: sw.checked ? Theme.primary : Qt.rgba(1, 1, 1, 0.10) + border.color: sw.checked ? Qt.lighter(Theme.primary, 1.3) : Qt.rgba(1, 1, 1, 0.16) + Behavior on color { ColorAnimation { duration: Theme.med } } + Glow { radius: 11; sigma: 4; opacity: sw.hovered ? 0.35 : 0 } + Rectangle { + x: sw.checked ? parent.width - width - 3 : 3 + anchors.verticalCenter: parent.verticalCenter + width: 16 + height: 16 + radius: 8 + color: "#FFFFFF" + Behavior on x { NumberAnimation { duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 2 } + height: 6 + radius: 3 + color: Qt.rgba(1, 1, 1, 0.6) + } + } + } + contentItem: Txt { + text: sw.text + font: sw.font + leftPadding: sw.indicator.width + sw.spacing + wrapMode: Text.WordWrap + elide: Text.ElideNone + } +} diff --git a/stemroller/qml/StemRoller/CaptionButton.qml b/stemroller/qml/StemRoller/CaptionButton.qml new file mode 100644 index 0000000..8d06f99 --- /dev/null +++ b/stemroller/qml/StemRoller/CaptionButton.qml @@ -0,0 +1,31 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Win7-flavoured caption button; close turns glossy red on hover. +AbstractButton { + id: b + property string iconName: "minimize" + property bool danger: false + implicitWidth: 46 + implicitHeight: 30 + hoverEnabled: true + focusPolicy: Qt.NoFocus + background: Rectangle { + radius: 6 + gradient: Gradient { + GradientStop { position: 0; color: b.danger && b.hovered ? "#F0645A" : (b.hovered ? Qt.rgba(1, 1, 1, 0.14) : "transparent") } + GradientStop { position: 0.5; color: b.danger && b.hovered ? "#D8392B" : (b.hovered ? Qt.rgba(1, 1, 1, 0.07) : "transparent") } + GradientStop { position: 1; color: b.danger && b.hovered ? "#C42B1C" : (b.hovered ? Qt.rgba(1, 1, 1, 0.05) : "transparent") } + } + border.color: b.hovered ? (b.danger ? "#FF8A80" : Qt.rgba(1, 1, 1, 0.14)) : "transparent" + Rectangle { + anchors.fill: parent + radius: parent.radius + color: b.down ? Qt.rgba(0, 0, 0, 0.2) : "transparent" + } + Glow { radius: 6; sigma: 5; color: "#FF5C4C"; opacity: b.danger && b.hovered ? 0.5 : 0 } + } + contentItem: Item { + Icon { anchors.centerIn: parent; name: b.iconName; size: 16; color: b.hovered ? "#FFFFFF" : Theme.textHi } + } +} diff --git a/stemroller/qml/StemRoller/Card.qml b/stemroller/qml/StemRoller/Card.qml new file mode 100644 index 0000000..f48f833 --- /dev/null +++ b/stemroller/qml/StemRoller/Card.qml @@ -0,0 +1,26 @@ +import QtQuick + +// Material card (elevation 2, radius 8) with Aero top gloss: white 6% -> 0 over the top 40%. +Rectangle { + id: card + property int elevation: 2 + property bool glossy: true + radius: 8 + color: Theme.surface1 + border.color: Theme.hairline + border.width: 1 + + Elevation { level: card.elevation; radius: card.radius } + + Rectangle { + visible: card.glossy + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 1 } + height: (parent.height - 2) * 0.4 + topLeftRadius: card.radius - 1 + topRightRadius: card.radius - 1 + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.06) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.0) } + } + } +} diff --git a/stemroller/qml/StemRoller/DashedFrame.qml b/stemroller/qml/StemRoller/DashedFrame.qml new file mode 100644 index 0000000..607c224 --- /dev/null +++ b/stemroller/qml/StemRoller/DashedFrame.qml @@ -0,0 +1,25 @@ +import QtQuick +import QtQuick.Shapes + +// Static dashed rounded border (geometry built once; only opacity animates). +Shape { + id: s + property color color: Theme.accentGlow + property real radius: 12 + property real lineWidth: 2 + preferredRendererType: Shape.CurveRenderer + ShapePath { + strokeColor: s.color + strokeWidth: s.lineWidth + strokeStyle: ShapePath.DashLine + dashPattern: [5, 4] + fillColor: "transparent" + PathRectangle { + x: s.lineWidth / 2 + y: s.lineWidth / 2 + width: s.width - s.lineWidth + height: s.height - s.lineWidth + radius: s.radius + } + } +} diff --git a/stemroller/qml/StemRoller/DropZone.qml b/stemroller/qml/StemRoller/DropZone.qml new file mode 100644 index 0000000..457629d --- /dev/null +++ b/stemroller/qml/StemRoller/DropZone.qml @@ -0,0 +1,98 @@ +import QtQuick + +// Empty state: card filling the main pane; dashed border glows on drag-over. +Item { + id: dz + property bool dragging: false + signal browse() + + Card { + id: card + anchors.fill: parent + anchors.margins: 24 + radius: 16 + color: dz.dragging ? Theme.alpha(Theme.primary, 0.08) : Theme.alpha(Theme.surface1, 0.72) + Behavior on color { ColorAnimation { duration: Theme.med } } + + Glow { radius: 16; sigma: 8; opacity: dz.dragging ? 0.55 : 0 } + DashedFrame { + anchors.fill: parent + anchors.margins: 10 + radius: 12 + color: dz.dragging ? Theme.accentGlow : Theme.alpha(Theme.textLo, 0.35) + } + + MouseArea { + anchors.fill: parent + cursorShape: Qt.PointingHandCursor + hoverEnabled: true + onClicked: dz.browse() + } + + Column { + anchors.centerIn: parent + spacing: 16 + Rectangle { + anchors.horizontalCenter: parent.horizontalCenter + width: 88 + height: 88 + radius: 44 + color: Theme.alpha(Theme.primary, dz.dragging ? 0.28 : 0.14) + border.color: Theme.alpha(Theme.accentGlow, 0.5) + scale: dz.dragging ? 1.08 : 1 + Behavior on scale { NumberAnimation { duration: Theme.slow; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + Behavior on color { ColorAnimation { duration: Theme.med } } + Glow { radius: 44; sigma: 8; opacity: 0.35 } + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 3 } + height: 40 + topLeftRadius: 41 + topRightRadius: 41 + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.18) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.0) } + } + } + Icon { anchors.centerIn: parent; name: "upload"; size: 40; color: Theme.accentGlow } + } + Txt { + anchors.horizontalCenter: parent.horizontalCenter + text: dz.dragging ? "Release to separate" : "Drop audio files here" + font.pixelSize: Theme.fs28 + font.weight: Font.DemiBold + } + Txt { + anchors.horizontalCenter: parent.horizontalCenter + text: "or click to browse · MP3, WAV, FLAC, M4A, OGG, OPUS and more" + color: Theme.textLo + font.pixelSize: Theme.fs14 + } + Row { + anchors.horizontalCenter: parent.horizontalCenter + spacing: 8 + topPadding: 8 + Repeater { + model: ["vocals", "drums", "bass", "other"] + Rectangle { + required property string modelData + height: 26 + width: chipText.implicitWidth + 28 + radius: 13 + color: Theme.alpha(Theme.stemColor(modelData), 0.14) + border.color: Theme.alpha(Theme.stemColor(modelData), 0.4) + Rectangle { x: 10; anchors.verticalCenter: parent.verticalCenter; width: 6; height: 6; radius: 3; color: Theme.stemColor(parent.modelData) } + Txt { id: chipText; x: 21; anchors.verticalCenter: parent.verticalCenter; text: parent.modelData; font.pixelSize: Theme.fs12; color: Theme.textHi } + } + } + } + Txt { + anchors.horizontalCenter: parent.horizontalCenter + topPadding: 4 + text: "Separates with " + (app.models.find(m => m.id === appSettings.modelId) || {label: ""}).label + + " on " + ((app.devices.find(d => d.id === appSettings.deviceId) || {label: "Auto"}).label) + color: Theme.alpha(Theme.textLo, 0.8) + font.pixelSize: Theme.fs12 + } + } + } +} diff --git a/stemroller/qml/StemRoller/Elevation.qml b/stemroller/qml/StemRoller/Elevation.qml new file mode 100644 index 0000000..c1b02bc --- /dev/null +++ b/stemroller/qml/StemRoller/Elevation.qml @@ -0,0 +1,21 @@ +import QtQuick + +// Static 9-patch shadow: no runtime blur, one textured quad. +BorderImage { + id: shadow + property int level: 2 + property int radius: 8 + readonly property real sigma: Theme.shadowSigma[level] + readonly property int m: Math.ceil(sigma * 3) + 1 + readonly property int dy: Theme.shadowDy[level] + visible: level > 0 + z: -1 + anchors.fill: parent + anchors.leftMargin: -m + anchors.rightMargin: -m + anchors.topMargin: -m + dy + anchors.bottomMargin: -m - dy + border { left: m + radius; right: m + radius; top: m + radius; bottom: m + radius } + source: "image://fx/shadow/" + sigma + "/" + Theme.shadowAlpha[level] + "/" + radius + cache: true +} diff --git a/stemroller/qml/StemRoller/FrameOverlay.qml b/stemroller/qml/StemRoller/FrameOverlay.qml new file mode 100644 index 0000000..4c9a9a1 --- /dev/null +++ b/stemroller/qml/StemRoller/FrameOverlay.qml @@ -0,0 +1,74 @@ +import QtQuick + +// Dev overlay: p50/p99 frame interval (and render-thread work with --render-hooks). +// While visible, the heartbeat bar changes every frame so the window renders at +// full refresh and the numbers describe real 240Hz cadence, not idle frames. +Rectangle { + id: o + property var s: ({}) + property real acc: 0 + property var batch: [] + property real beat: 0 + width: 236 + height: col.implicitHeight + 24 + radius: 8 + color: Theme.alpha(Theme.surface1, 0.92) + border.color: Theme.outline + readonly property color good: Theme.success + readonly property color bad: Theme.error + + onVisibleChanged: frameStats.setHooks(visible) + FrameAnimation { + running: o.visible + onTriggered: { + o.batch.push(frameTime * 1000) + if (frameTime * 1000 > 1.5 * (o.s.budget_ms || 4.17)) frameStats.miss(frameTime * 1000) + o.beat = (o.beat + frameTime) % 1 + o.acc += frameTime + if (o.acc > 0.25) { + o.acc = 0 + frameStats.push(o.batch) + o.batch = [] + o.s = frameStats.summary() + } + } + } + Rectangle { // heartbeat: moves every frame + anchors.bottom: parent.bottom + anchors.bottomMargin: 3 + x: 8 + (parent.width - 16 - width) * o.beat + width: 24 + height: 2 + radius: 1 + color: Theme.accentGlow + opacity: 0.6 + } + Column { + id: col + anchors { left: parent.left; top: parent.top; margins: 10 } + spacing: 3 + Txt { + text: (o.s.refresh_hz || 0).toFixed(0) + " Hz panel · " + (o.s.fps || 0).toFixed(1) + " fps" + font.pixelSize: Theme.fs12 + font.weight: Font.DemiBold + font.features: { "tnum": 1 } + color: (o.s.fps || 0) >= (o.s.refresh_hz || 240) * 0.97 ? o.good : Theme.warning + } + Txt { + text: o.s.work_p50 === null || o.s.work_p50 === undefined ? "frame time measuring…" + : "frame time p50 " + o.s.work_p50.toFixed(2) + " p99 " + o.s.work_p99.toFixed(2) + " ms" + font.pixelSize: 11; font.features: { "tnum": 1 } + color: (o.s.work_p99 || 0) < (o.s.budget_ms || 4.17) ? Theme.textHi : o.bad + } + Txt { + text: "interval p50 " + (o.s.interval_p50 || 0).toFixed(2) + " p99 " + (o.s.interval_p99 || 0).toFixed(2) + " ms" + font.pixelSize: 11; font.features: { "tnum": 1 } + color: Theme.textLo + } + Txt { + text: "budget " + (o.s.budget_ms || 0).toFixed(2) + " ms · missed " + (o.s.missed || 0) + "/" + (o.s.frames || 0) + font.pixelSize: 11; font.features: { "tnum": 1 } + color: (o.s.missed || 0) === 0 ? Theme.textLo : o.bad + } + } +} diff --git a/stemroller/qml/StemRoller/GlassPanel.qml b/stemroller/qml/StemRoller/GlassPanel.qml new file mode 100644 index 0000000..a5f2638 --- /dev/null +++ b/stemroller/qml/StemRoller/GlassPanel.qml @@ -0,0 +1,57 @@ +import QtQuick + +// Aero glass for chrome. Shows the window's cached, pre-blurred backdrop +// (refreshed only on resize), so nothing is blurred per frame. +Item { + id: root + property real offsetX: 0 + property real offsetY: 0 + property int blur: 16 + property real topLeftRadius: 0 + property real topRightRadius: 0 + property real bottomLeftRadius: 0 + property real bottomRightRadius: 0 + property bool gloss: true + property bool innerBorder: true + clip: true + + readonly property var win: Window.window + + Image { + x: -root.offsetX + y: -root.offsetY + width: root.win ? root.win.width : 0 + height: root.win ? root.win.height : 0 + source: root.win ? "image://fx/glass/" + root.win.fxW + "x" + root.win.fxH + "/" + root.win.radius + "/" + root.blur : "" + asynchronous: true + retainWhileLoading: true + cache: true + smooth: true + } + + // Aero gloss: top highlight band + Rectangle { + visible: root.gloss + anchors { left: parent.left; right: parent.right; top: parent.top } + height: Math.min(parent.height * 0.5, 30) + topLeftRadius: root.topLeftRadius + topRightRadius: root.topRightRadius + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.07) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.0) } + } + } + + // 1px inner white border at 8% + Rectangle { + visible: root.innerBorder + anchors.fill: parent + color: "transparent" + border.color: Theme.outline + border.width: 1 + topLeftRadius: root.topLeftRadius + topRightRadius: root.topRightRadius + bottomLeftRadius: root.bottomLeftRadius + bottomRightRadius: root.bottomRightRadius + } +} diff --git a/stemroller/qml/StemRoller/Glow.qml b/stemroller/qml/StemRoller/Glow.qml new file mode 100644 index 0000000..eba8187 --- /dev/null +++ b/stemroller/qml/StemRoller/Glow.qml @@ -0,0 +1,18 @@ +import QtQuick + +// Static 9-patch Aero hover glow; animate `opacity` only. +BorderImage { + property color color: Theme.accentGlow + property int radius: 20 + property int sigma: 6 + readonly property int m: Math.ceil(sigma * 3) + 1 + anchors.fill: parent + anchors.margins: -m + border { left: m + radius; right: m + radius; top: m + radius; bottom: m + radius } + source: "image://fx/glow/" + Theme.hex(color) + "/" + sigma + "/" + radius + opacity: 0 + visible: opacity > 0.001 + z: -1 + cache: true + Behavior on opacity { NumberAnimation { duration: Theme.fast; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } +} diff --git a/stemroller/qml/StemRoller/Icon.qml b/stemroller/qml/StemRoller/Icon.qml new file mode 100644 index 0000000..444d47f --- /dev/null +++ b/stemroller/qml/StemRoller/Icon.qml @@ -0,0 +1,14 @@ +import QtQuick + +// Material icon rendered once per (name, color, size) by the icon provider. +Image { + property string name: "music" + property color color: Theme.textHi + property int size: 20 + width: size + height: size + sourceSize: Qt.size(size * Screen.devicePixelRatio, size * Screen.devicePixelRatio) + source: Theme.icon(name, color) + smooth: true + asynchronous: false +} diff --git a/stemroller/qml/StemRoller/IconButton.qml b/stemroller/qml/StemRoller/IconButton.qml new file mode 100644 index 0000000..eec3326 --- /dev/null +++ b/stemroller/qml/StemRoller/IconButton.qml @@ -0,0 +1,47 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Round icon button; checkable variant used for solo / mute. +AbstractButton { + id: b + property string iconName: "music" + property color iconColor: Theme.textLo + property color activeColor: Theme.primary + property color hoverColor: Theme.alpha(Theme.textHi, 0.08) + property int size: 32 + property int iconSize: 18 + property string tip: "" + property bool glow: true + implicitWidth: size + implicitHeight: size + hoverEnabled: true + focusPolicy: Qt.TabFocus + opacity: enabled ? 1 : 0.35 + + background: Item { + Glow { + radius: Math.round(b.size / 2) + sigma: 4 + color: b.checked ? b.activeColor : Theme.accentGlow + opacity: b.glow && (b.hovered || b.visualFocus) && b.enabled ? 0.35 : 0 + } + Rectangle { + anchors.fill: parent + radius: width / 2 + color: b.checked ? Theme.alpha(b.activeColor, b.down ? 0.34 : 0.22) + : (b.down ? Theme.alpha(Theme.textHi, 0.14) : (b.hovered ? b.hoverColor : "transparent")) + border.width: b.checked ? 1 : 0 + border.color: Theme.alpha(b.activeColor, 0.6) + Behavior on color { ColorAnimation { duration: Theme.fast } } + } + } + contentItem: Item { + Icon { + anchors.centerIn: parent + name: b.iconName + size: b.iconSize + color: b.checked ? b.activeColor : (b.hovered ? Theme.textHi : b.iconColor) + } + } + Tip { visible: b.hovered && b.tip.length > 0; text: b.tip } +} diff --git a/stemroller/qml/StemRoller/LevelMeter.qml b/stemroller/qml/StemRoller/LevelMeter.qml new file mode 100644 index 0000000..7f0e178 --- /dev/null +++ b/stemroller/qml/StemRoller/LevelMeter.qml @@ -0,0 +1,73 @@ +import QtQuick + +// Stereo peak meter fed per frame from the audio ring buffer (via Main). +Item { + id: m + property real levelLeft: 0 + property real levelRight: 0 + property real holdL: 0 + property real holdR: 0 + implicitWidth: 150 + implicitHeight: 22 + + function frac(v) { + if (v <= 0.000001) return 0 + var db = 20 * Math.log(v) / Math.LN10 + return Math.max(0, Math.min(1, (db + 54) / 54)) + } + onLevelLeftChanged: holdL = Math.max(holdL, frac(levelLeft)) + onLevelRightChanged: holdR = Math.max(holdR, frac(levelRight)) + FrameAnimation { + running: m.holdL > 0.001 || m.holdR > 0.001 + onTriggered: { + var d = frameTime * 0.35 + m.holdL = Math.max(m.frac(m.levelLeft), m.holdL - d) + m.holdR = Math.max(m.frac(m.levelRight), m.holdR - d) + } + } + + Column { + anchors.fill: parent + spacing: 4 + Repeater { + model: 2 + Item { + required property int index + readonly property real level: m.frac(index === 0 ? m.levelLeft : m.levelRight) + readonly property real hold: index === 0 ? m.holdL : m.holdR + width: m.width + height: (m.height - 4) / 2 + Rectangle { + anchors.fill: parent + radius: 2 + color: Qt.rgba(1, 1, 1, 0.07) + } + Item { + width: parent.width * parent.level + height: parent.height + clip: true + Rectangle { + width: m.width + height: parent.height + radius: 2 + gradient: Gradient { + orientation: Gradient.Horizontal + GradientStop { position: 0.0; color: Theme.success } + GradientStop { position: 0.72; color: Theme.accentGlow } + GradientStop { position: 0.88; color: Theme.warning } + GradientStop { position: 1.0; color: Theme.error } + } + } + } + Rectangle { + visible: parent.hold > 0.01 + x: Math.min(parent.width - 2, parent.width * parent.hold) + width: 2 + height: parent.height + color: parent.hold > 0.95 ? Theme.error : Theme.textHi + opacity: 0.85 + } + } + } + } +} diff --git a/stemroller/qml/StemRoller/Main.qml b/stemroller/qml/StemRoller/Main.qml new file mode 100644 index 0000000..6c4974f --- /dev/null +++ b/stemroller/qml/StemRoller/Main.qml @@ -0,0 +1,209 @@ +import QtQuick +import QtQuick.Controls.Basic +import QtQuick.Dialogs +import StemRoller + +Window { + id: win + width: 1440 + height: 900 + minimumWidth: 960 + minimumHeight: 600 + visible: true + title: "StemRoller" + color: "transparent" + flags: Qt.Window | Qt.FramelessWindowHint + + readonly property bool maximized: visibility === Window.Maximized || visibility === Window.FullScreen + readonly property int radius: maximized ? 0 : 10 + function toggleMaximized() { maximized ? showNormal() : showMaximized() } + + // Glass snapshot size: refreshed only after a resize settles. + property int fxW: width + property int fxH: height + Timer { id: fxTimer; interval: 150; onTriggered: { win.fxW = win.width; win.fxH = win.height } } + onWidthChanged: fxTimer.restart() + onHeightChanged: fxTimer.restart() + + // Per-frame playback state, read from the audio ring buffer. + property real playPos: 0 + property real levelL: 0 + property real levelR: 0 + FrameAnimation { + running: audio.playing || win.levelL > 0.0005 || win.levelR > 0.0005 + onTriggered: { + var s = audio.snapshot() + if (s[3]) win.playPos = s[0] + var k = Math.exp(-frameTime * 10) + win.levelL = Math.max(s[1], win.levelL * k) + win.levelR = Math.max(s[2], win.levelR * k) + if (win.levelL < 0.0005) win.levelL = 0 + if (win.levelR < 0.0005) win.levelR = 0 + } + } + Connections { + target: audio + function onLoadedChanged() { win.playPos = 0 } + } + Connections { + target: app + function onToast(msg, kind, folder) { toast.show(msg, kind, folder) } + } + Component.onCompleted: Theme.fontFamily = uiFont + + FileDialog { + id: fileDialog + title: "Add audio files" + fileMode: FileDialog.OpenFiles + nameFilters: ["Audio (*.mp3 *.wav *.flac *.ogg *.oga *.opus *.m4a *.aac *.aif *.aiff *.wma *.mp4 *.mkv *.webm *.mka *.wv *.ape)", "All files (*)"] + onAccepted: app.addUrls(selectedFiles) + } + + Shortcut { sequences: ["Space"]; enabled: audio.loaded && !settings.opened; onActivated: audio.toggle() } + Shortcut { sequences: ["Home"]; enabled: audio.loaded; onActivated: { audio.seek(0); win.playPos = 0 } } + Shortcut { sequences: [StandardKey.Open]; onActivated: fileDialog.open() } + Shortcut { sequences: ["Ctrl+,"]; onActivated: settings.open() } + Shortcut { sequences: ["F12"]; onActivated: appSettings.frameOverlay = !appSettings.frameOverlay } + Shortcut { sequences: ["F11"]; onActivated: win.toggleMaximized() } + Shortcut { sequences: [StandardKey.Quit]; onActivated: win.close() } + + Item { + id: frame + anchors.fill: parent + + // window background: placeholder until the aurora texture arrives + Rectangle { + anchors.fill: parent + radius: win.radius + color: Theme.bg + } + Image { + id: backdrop + anchors.fill: parent + source: "image://fx/backdrop/" + win.fxW + "x" + win.fxH + "/" + win.radius + asynchronous: true + retainWhileLoading: true + cache: true + opacity: status === Image.Ready ? 1 : 0 + Behavior on opacity { NumberAnimation { duration: Theme.slow } } + } + + TitleBar { + id: titleBar + anchors { left: parent.left; right: parent.right; top: parent.top } + offsetX: 0 + offsetY: 0 + onOpenSettings: settings.open() + } + + Sidebar { + id: sidebar + anchors { left: parent.left; top: titleBar.bottom; bottom: transport.top } + width: 220 + offsetX: 0 + offsetY: titleBar.height + onBrowse: fileDialog.open() + Rectangle { anchors { right: parent.right; top: parent.top; bottom: parent.bottom } width: 1; color: Theme.hairline } + } + + Item { + id: mainPane + anchors { left: sidebar.right; right: parent.right; top: titleBar.bottom; bottom: transport.top } + clip: true + + Image { // dither the dark gradients behind content + anchors.fill: parent + source: "image://fx/noise" + fillMode: Image.Tile + cache: true + } + + DropZone { + anchors.fill: parent + visible: !app.selected.valid + dragging: drop.containsDrag + onBrowse: fileDialog.open() + } + TrackView { + anchors.fill: parent + visible: app.selected.valid + } + + // drag-over affordance when a track is already showing + Item { + anchors.fill: parent + visible: opacity > 0 + opacity: drop.containsDrag && app.selected.valid ? 1 : 0 + Behavior on opacity { NumberAnimation { duration: Theme.med } } + Rectangle { anchors.fill: parent; color: Theme.alpha(Theme.bg, 0.82) } + DashedFrame { anchors.fill: parent; anchors.margins: 24; radius: 16 } + Glow { anchors.margins: 24 - m; radius: 16; sigma: 8; opacity: 0.4 } + Txt { + anchors.centerIn: parent + text: "Drop to add to the queue" + font.pixelSize: Theme.fs28 + font.weight: Font.DemiBold + } + } + + FrameOverlay { + visible: appSettings.frameOverlay || devOverlay + anchors { right: parent.right; bottom: parent.bottom; margins: 12 } + z: 100 + } + } + + Transport { + id: transport + anchors { left: parent.left; right: parent.right; bottom: parent.bottom } + height: 64 + offsetX: 0 + offsetY: win.height - 64 + } + + Item { + anchors { horizontalCenter: mainPane.horizontalCenter; bottom: transport.top; bottomMargin: 16 } + width: toast.width + height: 48 + Toast { id: toast; maxWidth: mainPane.width - 48 } + } + + // window edge highlight + Rectangle { + anchors.fill: parent + radius: win.radius + color: "transparent" + border.width: win.maximized ? 0 : 1 + border.color: Qt.rgba(1, 1, 1, 0.12) + } + + DropArea { + id: drop + anchors.fill: parent + keys: ["text/uri-list"] + onDropped: (e) => { + if (e.hasUrls) { + app.addUrls(e.urls) + e.acceptProposedAction() + } + } + } + + // resize grips (compositor-driven) + Item { + anchors.fill: parent + visible: !win.maximized + readonly property int g: 6 + ResizeEdge { edges: Qt.LeftEdge; x: 0; y: 12; width: parent.g; height: parent.height - 24 } + ResizeEdge { edges: Qt.RightEdge; x: parent.width - parent.g; y: 12; width: parent.g; height: parent.height - 24 } + ResizeEdge { edges: Qt.TopEdge; x: 12; y: 0; width: parent.width - 24; height: parent.g - 2 } + ResizeEdge { edges: Qt.BottomEdge; x: 12; y: parent.height - parent.g; width: parent.width - 24; height: parent.g } + ResizeEdge { edges: Qt.LeftEdge | Qt.TopEdge; x: 0; y: 0; width: 12; height: 12 } + ResizeEdge { edges: Qt.RightEdge | Qt.TopEdge; x: parent.width - 12; y: 0; width: 12; height: 12 } + ResizeEdge { edges: Qt.LeftEdge | Qt.BottomEdge; x: 0; y: parent.height - 12; width: 12; height: 12 } + ResizeEdge { edges: Qt.RightEdge | Qt.BottomEdge; x: parent.width - 12; y: parent.height - 12; width: 12; height: 12 } + } + } + + SettingsDialog { id: settings; parent: Overlay.overlay; win: win } +} diff --git a/stemroller/qml/StemRoller/QueueItem.qml b/stemroller/qml/StemRoller/QueueItem.qml new file mode 100644 index 0000000..690603c --- /dev/null +++ b/stemroller/qml/StemRoller/QueueItem.qml @@ -0,0 +1,89 @@ +import QtQuick +import QtQuick.Controls.Basic + +ItemDelegate { + id: item + required property string jobId + required property string fileName + required property string modelLabel + required property string status + required property real progress + required property string stage + required property int index + readonly property bool selected: app.selected.valid && app.selected.id === jobId + readonly property bool active: status === "running" || status === "queued" + + width: ListView.view ? ListView.view.width : 200 + height: active ? 84 : 66 + hoverEnabled: true + padding: 0 + onClicked: app.select(jobId) + Behavior on height { NumberAnimation { duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + + background: Rectangle { + radius: 8 + color: item.selected ? Theme.alpha(Theme.primary, 0.16) : (item.hovered ? Qt.rgba(1, 1, 1, 0.05) : "transparent") + border.color: item.selected ? Theme.alpha(Theme.primary, 0.45) : "transparent" + Behavior on color { ColorAnimation { duration: Theme.fast } } + Rectangle { + visible: item.selected + x: 0 + anchors.verticalCenter: parent.verticalCenter + width: 3 + height: parent.height - 20 + radius: 2 + color: Theme.accentGlow + } + } + + contentItem: Item { + Column { + anchors { left: parent.left; right: parent.right; top: parent.top; leftMargin: 12; rightMargin: 6; topMargin: 10 } + spacing: 6 + Row { + width: parent.width + spacing: 8 + Icon { + anchors.verticalCenter: parent.verticalCenter + size: 16 + name: item.status === "done" ? "check" : item.status === "error" ? "error" : "music" + color: item.status === "done" ? Theme.success : item.status === "error" ? Theme.error : Theme.textLo + } + Txt { + width: parent.width - 16 - 28 - 16 + anchors.verticalCenter: parent.verticalCenter + text: item.fileName + font.weight: item.selected ? Font.DemiBold : Font.Medium + } + IconButton { + anchors.verticalCenter: parent.verticalCenter + size: 24 + iconSize: 14 + iconName: "close" + glow: false + tip: item.active ? "Cancel" : "Remove" + onClicked: item.active ? app.cancelJob(item.jobId) : app.removeJob(item.jobId) + } + } + Row { + width: parent.width + spacing: 8 + Txt { + width: parent.width - chip.width - 14 + anchors.verticalCenter: parent.verticalCenter + text: item.status === "running" ? item.stage : item.modelLabel + font.pixelSize: Theme.fs12 + color: Theme.textLo + } + StatusChip { id: chip; status: item.status; progress: item.progress } + } + StripedProgress { + visible: item.active + width: parent.width - 6 + value: item.progress + active: item.status === "running" + opacity: item.status === "running" ? 1 : 0.35 + } + } + } +} diff --git a/stemroller/qml/StemRoller/ResizeEdge.qml b/stemroller/qml/StemRoller/ResizeEdge.qml new file mode 100644 index 0000000..73891d1 --- /dev/null +++ b/stemroller/qml/StemRoller/ResizeEdge.qml @@ -0,0 +1,13 @@ +import QtQuick + +// Invisible edge/corner grip that hands resizing to the compositor. +MouseArea { + property int edges: 0 + property var win: Window.window + hoverEnabled: true + acceptedButtons: Qt.LeftButton + cursorShape: edges === (Qt.LeftEdge | Qt.TopEdge) || edges === (Qt.RightEdge | Qt.BottomEdge) ? Qt.SizeFDiagCursor + : edges === (Qt.RightEdge | Qt.TopEdge) || edges === (Qt.LeftEdge | Qt.BottomEdge) ? Qt.SizeBDiagCursor + : (edges & (Qt.LeftEdge | Qt.RightEdge)) ? Qt.SizeHorCursor : Qt.SizeVerCursor + onPressed: win.startSystemResize(edges) +} diff --git a/stemroller/qml/StemRoller/SettingsDialog.qml b/stemroller/qml/StemRoller/SettingsDialog.qml new file mode 100644 index 0000000..e79d9e8 --- /dev/null +++ b/stemroller/qml/StemRoller/SettingsDialog.qml @@ -0,0 +1,274 @@ +import QtQuick +import QtQuick.Controls.Basic +import QtQuick.Dialogs + +// Glass dialog (elevation 3, stronger 24px blur, 50% scrim). +Popup { + id: dlg + property var win: null + modal: true + focus: true + width: Math.min(parent.width - 64, 640) + height: Math.min(parent.height - 64, content.implicitHeight + 120) + x: Math.round((parent.width - width) / 2) + y: Math.round((parent.height - height) / 2) + padding: 0 + closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutside + onOpened: app.refreshCacheSize() + + Overlay.modal: Rectangle { + color: Qt.rgba(0, 0, 0, 0.5) + Behavior on opacity { NumberAnimation { duration: Theme.med } } + } + enter: Transition { + NumberAnimation { property: "opacity"; from: 0; to: 1; duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } + NumberAnimation { property: "scale"; from: 0.95; to: 1; duration: Theme.slow; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } + } + exit: Transition { NumberAnimation { property: "opacity"; from: 1; to: 0; duration: Theme.fast } } + + background: Item { + Elevation { level: 3; radius: 12 } + Image { // stronger-blur glass sheet, pre-rounded, rendered once per open/resize + anchors.fill: parent + asynchronous: true + retainWhileLoading: true + source: dlg.win && dlg.width > 0 + ? "image://fx/glasscrop/" + dlg.win.fxW + "x" + dlg.win.fxH + "/0/24/" + + Math.round(dlg.x) + "," + Math.round(dlg.y) + "," + Math.round(dlg.width) + "," + Math.round(dlg.height) + "/12" + : "" + } + Rectangle { // Aero gloss + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 1 } + height: 48 + topLeftRadius: 11 + topRightRadius: 11 + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.08) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.0) } + } + } + Rectangle { + anchors.fill: parent + radius: 12 + color: "transparent" + border.color: Qt.rgba(1, 1, 1, 0.12) + } + } + + FolderDialog { + id: folderDialog + title: "Choose the stems folder" + currentFolder: "file://" + appSettings.stemsDir + onAccepted: appSettings.stemsDir = decodeURIComponent(selectedFolder.toString().replace("file://", "")) + } + + component SectionTitle: Txt { + font.pixelSize: 11 + font.weight: Font.DemiBold + font.letterSpacing: 0.8 + color: Theme.accentGlow + topPadding: 8 + } + component Hint: Txt { + font.pixelSize: Theme.fs12 + color: Theme.textLo + wrapMode: Text.WordWrap + elide: Text.ElideNone + } + component Segmented: Row { + id: seg + property var options: [] + property string value: "" + signal picked(string v) + spacing: 0 + Repeater { + model: seg.options + AbstractButton { + id: sb + required property var modelData + required property int index + readonly property bool on: seg.value === modelData.v + implicitWidth: 84 + implicitHeight: 34 + hoverEnabled: true + onClicked: seg.picked(modelData.v) + background: Rectangle { + topLeftRadius: sb.index === 0 ? 17 : 0 + bottomLeftRadius: sb.index === 0 ? 17 : 0 + topRightRadius: sb.index === seg.options.length - 1 ? 17 : 0 + bottomRightRadius: sb.index === seg.options.length - 1 ? 17 : 0 + color: sb.on ? Theme.alpha(Theme.primary, 0.28) : (sb.hovered ? Qt.rgba(1, 1, 1, 0.07) : Qt.rgba(1, 1, 1, 0.03)) + border.color: sb.on ? Theme.alpha(Theme.primary, 0.7) : Qt.rgba(1, 1, 1, 0.12) + Behavior on color { ColorAnimation { duration: Theme.fast } } + } + contentItem: Txt { + text: sb.modelData.t + horizontalAlignment: Text.AlignHCenter + font.weight: sb.on ? Font.DemiBold : Font.Normal + color: sb.on ? Theme.textHi : Theme.textLo + } + } + } + } + + contentItem: Item { + Item { + id: head + anchors { left: parent.left; right: parent.right; top: parent.top } + height: 60 + Txt { + anchors { left: parent.left; leftMargin: 24; verticalCenter: parent.verticalCenter } + text: "Settings" + font.pixelSize: Theme.fs20 + font.weight: Font.DemiBold + } + IconButton { + anchors { right: parent.right; rightMargin: 14; verticalCenter: parent.verticalCenter } + iconName: "close" + onClicked: dlg.close() + } + Rectangle { anchors { left: parent.left; right: parent.right; bottom: parent.bottom } height: 1; color: Theme.hairline } + } + + Flickable { + anchors { left: parent.left; right: parent.right; top: head.bottom; bottom: parent.bottom } + contentHeight: content.implicitHeight + 32 + clip: true + boundsBehavior: Flickable.StopAtBounds + ScrollBar.vertical: ScrollBar { contentItem: Rectangle { implicitWidth: 4; radius: 2; color: Qt.rgba(1, 1, 1, 0.18); visible: parent.size < 1 } + background: Item {} } + + Column { + id: content + x: 24 + y: 12 + width: parent.width - 48 + spacing: 12 + + SectionTitle { text: "OUTPUT" } + Segmented { + options: [{ v: "beside", t: "Beside" }, { v: "folder", t: "Folder" }] + value: appSettings.outputMode + onPicked: (v) => appSettings.outputMode = v + } + Hint { + width: parent.width + text: appSettings.outputMode === "beside" + ? "Stems go next to the original, in “ - stems”." + : "Stems go to a folder per track inside the stems folder." + } + Row { + visible: appSettings.outputMode === "folder" + width: parent.width + spacing: 8 + Rectangle { + width: parent.width - browseBtn.width - 8 + height: 36 + radius: 18 + color: Qt.rgba(1, 1, 1, 0.05) + border.color: Qt.rgba(1, 1, 1, 0.12) + Txt { + anchors { fill: parent; leftMargin: 16; rightMargin: 16 } + text: appSettings.stemsDir + elide: Text.ElideMiddle + } + } + AeroButton { id: browseBtn; variant: "tonal"; pillHeight: 36; iconName: "folder"; text: "Browse"; onClicked: folderDialog.open() } + } + Row { + spacing: 16 + Txt { text: "Format"; width: 80; height: 34 } + Segmented { + options: [{ v: "wav", t: "WAV" }, { v: "flac", t: "FLAC" }, { v: "mp3", t: "MP3" }] + value: appSettings.exportFormat + onPicked: (v) => appSettings.exportFormat = v + } + } + Hint { width: parent.width; text: "WAV and FLAC are 24-bit (WAV switches to 32-bit float if a stem would clip). MP3 is 320 kbps." } + AeroSwitch { + width: parent.width + text: "Export all stems automatically when separation finishes" + checked: appSettings.autoExport + onToggled: appSettings.autoExport = checked + } + + SectionTitle { text: "SEPARATION" } + AeroSwitch { + width: parent.width + text: "Half precision on GPU (about 2x faster on the RX 9070 XT, same quality)" + checked: appSettings.fp16 + onToggled: appSettings.fp16 = checked + } + Row { + width: parent.width + spacing: 12 + Txt { text: "Segment"; width: 80; height: 24 } + AeroSlider { + id: segSlider + width: parent.width - 200 + from: 0; to: 7.8; stepSize: 0.1 + value: appSettings.segment + onMoved: appSettings.segment = value + } + Txt { text: appSettings.segment <= 0.05 ? "Model default" : appSettings.segment.toFixed(1) + " s"; width: 96; height: 24; color: Theme.textLo } + } + Hint { width: parent.width; text: "Demucs chunk length. Lower it only if you run out of VRAM; 16 GB fits every model at the default." } + Row { + width: parent.width + spacing: 12 + Txt { text: "Shifts"; width: 80; height: 24 } + AeroSlider { + width: parent.width - 200 + from: 0; to: 5; stepSize: 1; snapMode: Slider.SnapAlways + value: appSettings.shifts + onMoved: appSettings.shifts = Math.round(value) + } + Txt { text: appSettings.shifts === 0 ? "Off" : appSettings.shifts + " passes"; width: 96; height: 24; color: Theme.textLo } + } + Hint { width: parent.width; text: "Demucs random-shift averaging: small quality gain, each pass adds a full run." } + Row { + width: parent.width + spacing: 12 + Txt { text: "Overlap"; width: 80; height: 24 } + AeroSlider { + width: parent.width - 200 + from: 0.1; to: 0.9; stepSize: 0.05 + value: appSettings.overlap + onMoved: appSettings.overlap = value + } + Txt { text: Math.round(appSettings.overlap * 100) + "%"; width: 96; height: 24; color: Theme.textLo } + } + Hint { width: parent.width; text: "Segment overlap. RoFormer models always use at least 75%." } + + SectionTitle { text: "STORAGE" } + Row { + width: parent.width + spacing: 12 + Txt { text: "Stem cache uses " + app.cacheText; height: 36 } + AeroButton { variant: "tonal"; pillHeight: 36; iconName: "delete"; text: "Clear cache"; onClicked: app.clearCache() } + } + Row { + width: parent.width + spacing: 12 + Txt { text: "Keep up to"; width: 80; height: 24 } + AeroSlider { + width: parent.width - 200 + from: 1; to: 40; stepSize: 1; snapMode: Slider.SnapAlways + value: appSettings.cacheLimitGb + onMoved: appSettings.cacheLimitGb = Math.round(value) + } + Txt { text: appSettings.cacheLimitGb.toFixed(0) + " GB"; width: 96; height: 24; color: Theme.textLo } + } + Hint { width: parent.width; text: "Cached stems make re-opening a track instant. Oldest entries are pruned past the limit." } + + SectionTitle { text: "DEVELOPER" } + AeroSwitch { + width: parent.width + text: "Frame-time overlay (p50 / p99) · F12" + checked: appSettings.frameOverlay + onToggled: appSettings.frameOverlay = checked + } + } + } + } +} diff --git a/stemroller/qml/StemRoller/Sidebar.qml b/stemroller/qml/StemRoller/Sidebar.qml new file mode 100644 index 0000000..6dc8899 --- /dev/null +++ b/stemroller/qml/StemRoller/Sidebar.qml @@ -0,0 +1,72 @@ +import QtQuick +import QtQuick.Controls.Basic + +GlassPanel { + id: side + signal browse() + + Item { + id: header + anchors { left: parent.left; right: parent.right; top: parent.top } + height: 52 + Txt { + anchors { left: parent.left; leftMargin: 16; verticalCenter: parent.verticalCenter } + text: "Queue" + font.pixelSize: Theme.fs16 + font.weight: Font.DemiBold + } + Rectangle { + visible: list.count > 0 + anchors { left: parent.left; leftMargin: 76; verticalCenter: parent.verticalCenter } + width: cnt.implicitWidth + 12 + height: 18 + radius: 9 + color: Qt.rgba(1, 1, 1, 0.08) + Txt { id: cnt; anchors.centerIn: parent; text: list.count; font.pixelSize: 11; color: Theme.textLo } + } + IconButton { + anchors { right: parent.right; rightMargin: 10; verticalCenter: parent.verticalCenter } + iconName: "add" + tip: "Add files (Ctrl+O)" + onClicked: side.browse() + } + } + + ListView { + id: list + anchors { left: parent.left; right: parent.right; top: header.bottom; bottom: parent.bottom; margins: 8; topMargin: 0 } + model: jobsModel + spacing: 4 + clip: true + boundsBehavior: Flickable.StopAtBounds + delegate: QueueItem {} + add: Transition { + NumberAnimation { property: "opacity"; from: 0; to: 1; duration: Theme.med } + NumberAnimation { property: "x"; from: -16; duration: Theme.slow; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } + } + displaced: Transition { + NumberAnimation { properties: "y"; duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } + } + ScrollBar.vertical: ScrollBar { + policy: ScrollBar.AsNeeded + contentItem: Rectangle { implicitWidth: 4; radius: 2; color: Qt.rgba(1, 1, 1, 0.18); visible: parent.size < 1 } + background: Item {} + } + + Column { + visible: list.count === 0 + anchors.centerIn: parent + spacing: 8 + width: parent.width - 32 + Icon { anchors.horizontalCenter: parent.horizontalCenter; name: "upload"; size: 28; color: Theme.alpha(Theme.textLo, 0.7) } + Txt { + width: parent.width + horizontalAlignment: Text.AlignHCenter + wrapMode: Text.WordWrap + text: "Drop audio anywhere to queue it" + color: Theme.textLo + font.pixelSize: Theme.fs12 + } + } + } +} diff --git a/stemroller/qml/StemRoller/StatusChip.qml b/stemroller/qml/StemRoller/StatusChip.qml new file mode 100644 index 0000000..bdc8722 --- /dev/null +++ b/stemroller/qml/StemRoller/StatusChip.qml @@ -0,0 +1,28 @@ +import QtQuick + +Rectangle { + id: chip + property string status: "queued" + property real progress: 0 + readonly property color tone: status === "done" ? Theme.success + : status === "error" ? Theme.error + : status === "running" ? Theme.primary : Theme.textLo + readonly property string label: status === "running" ? Math.floor(progress * 100) + "%" + : status === "done" ? "Done" + : status === "error" ? "Failed" + : status === "cancelled" ? "Cancelled" : "Queued" + implicitWidth: t.implicitWidth + 16 + implicitHeight: 20 + radius: 10 + color: Theme.alpha(tone, 0.16) + border.color: Theme.alpha(tone, 0.35) + Txt { + id: t + anchors.centerIn: parent + text: chip.label + color: chip.tone + font.pixelSize: 11 + font.weight: Font.DemiBold + font.features: { "tnum": 1 } + } +} diff --git a/stemroller/qml/StemRoller/StemLane.qml b/stemroller/qml/StemRoller/StemLane.qml new file mode 100644 index 0000000..3dd66b0 --- /dev/null +++ b/stemroller/qml/StemRoller/StemLane.qml @@ -0,0 +1,147 @@ +import QtQuick +import QtQuick.Controls.Basic + +// One lane per stem: color strip, solo / mute / gain / export, waveform texture. +Item { + id: lane + required property int index + required property var modelData + property string jobId: "" + property real viewStart: 0 + property real viewEnd: 1 + property int waveW: 100 + property int waveH: 60 + property real waveX: 0 + property bool anySolo: false + property bool solo: false + property bool mute: false + property real gainDb: 0 + signal soloToggled(bool on) + readonly property string stem: modelData.name + readonly property color tone: modelData.color + readonly property bool audible: anySolo ? solo : !mute + height: 92 + + Card { + anchors.fill: parent + clip: false + + // color strip with soft glow + Rectangle { + x: 0 + width: 4 + height: parent.height + topLeftRadius: 8 + bottomLeftRadius: 8 + color: lane.tone + } + Rectangle { + x: 4 + width: 24 + height: parent.height + gradient: Gradient { + orientation: Gradient.Horizontal + GradientStop { position: 0; color: Theme.alpha(lane.tone, 0.14) } + GradientStop { position: 1; color: Theme.alpha(lane.tone, 0.0) } + } + } + + Column { + id: controls + x: 18 + width: lane.waveX - 30 + anchors.verticalCenter: parent.verticalCenter + spacing: 6 + Row { + spacing: 6 + width: parent.width + Txt { + width: parent.width - 3 * 30 - 12 + text: lane.stem.charAt(0).toUpperCase() + lane.stem.slice(1) + font.pixelSize: Theme.fs16 + font.weight: Font.DemiBold + anchors.verticalCenter: parent.verticalCenter + } + IconButton { + size: 30; iconSize: 16 + iconName: "headphones" + checkable: true + checked: lane.solo + activeColor: Theme.warning + tip: "Solo" + onClicked: lane.soloToggled(checked) + } + IconButton { + size: 30; iconSize: 16 + iconName: lane.mute ? "volume_off" : "volume" + checkable: true + checked: lane.mute + activeColor: Theme.error + tip: "Mute" + onClicked: { lane.mute = checked; audio.setMute(lane.index, checked) } + } + IconButton { + size: 30; iconSize: 16 + iconName: "download" + tip: "Export " + lane.stem + onClicked: app.exportStem(lane.stem) + } + } + Row { + spacing: 8 + width: parent.width + AeroSlider { + id: gain + width: parent.width - 52 + from: -24 + to: 12 + stepSize: 0.5 + value: lane.gainDb + tone: lane.tone + onMoved: { lane.gainDb = value; audio.setGain(lane.index, value) } + // double-click resets to unity + TapHandler { onDoubleTapped: { lane.gainDb = 0; audio.setGain(lane.index, 0) } } + } + Txt { + width: 44 + anchors.verticalCenter: parent.verticalCenter + horizontalAlignment: Text.AlignRight + text: (lane.gainDb > 0 ? "+" : "") + lane.gainDb.toFixed(1) + " dB" + font.pixelSize: 11 + font.features: { "tnum": 1 } + color: lane.gainDb === 0 ? Theme.textLo : Theme.textHi + } + } + } + + Rectangle { // waveform well + x: lane.waveX + y: 8 + width: lane.waveW + height: parent.height - 16 + radius: 6 + color: Qt.rgba(0, 0, 0, 0.22) + border.color: Qt.rgba(1, 1, 1, 0.04) + Rectangle { + anchors.verticalCenter: parent.verticalCenter + width: parent.width + height: 1 + color: Theme.alpha(lane.tone, 0.18) + } + Image { + anchors.fill: parent + asynchronous: true + retainWhileLoading: true + cache: false + smooth: true + opacity: lane.audible ? 1 : 0.28 + Behavior on opacity { NumberAnimation { duration: Theme.med } } + source: lane.jobId && lane.waveW > 4 + ? "image://wave/" + lane.jobId + "/" + lane.stem + "/" + + Math.round(lane.waveW * Screen.devicePixelRatio) + "x" + Math.round((lane.height - 16) * Screen.devicePixelRatio) + + "/" + lane.viewStart.toFixed(3) + "/" + lane.viewEnd.toFixed(3) + "/" + Theme.hex(lane.tone) + : "" + } + } + } +} diff --git a/stemroller/qml/StemRoller/StripedProgress.qml b/stemroller/qml/StemRoller/StripedProgress.qml new file mode 100644 index 0000000..7e6dcde --- /dev/null +++ b/stemroller/qml/StemRoller/StripedProgress.qml @@ -0,0 +1,63 @@ +import QtQuick + +// Win7-style green-to-cyan striped bar. Backend sends <= 30 updates/s; +// `shown` eases toward `value` and the stripes advance per frame by delta-time. +Item { + id: root + property real value: 0 + property bool active: true + property real shown: 0 + property real phase: 0 + property int barHeight: 6 + implicitHeight: barHeight + readonly property int tile: barHeight * 2 + + onValueChanged: if (value < shown) shown = value + + Rectangle { + anchors.fill: parent + radius: height / 2 + color: Qt.rgba(1, 1, 1, 0.07) + border.color: Qt.rgba(1, 1, 1, 0.05) + } + Item { + id: fill + height: parent.height + width: Math.max(root.active ? root.barHeight * 2 : 0, parent.width * Math.min(1, root.shown)) + clip: true + Rectangle { + anchors.fill: parent + radius: height / 2 + gradient: Gradient { + orientation: Gradient.Horizontal + GradientStop { position: 0; color: Theme.success } + GradientStop { position: 1; color: Theme.accentGlow } + } + } + Image { + visible: root.active + x: -root.phase + width: parent.width + root.tile + height: parent.height + fillMode: Image.Tile + source: "image://fx/stripes/" + root.barHeight + cache: true + } + Rectangle { // gloss + anchors { left: parent.left; right: parent.right; top: parent.top } + height: parent.height / 2 + topLeftRadius: height + topRightRadius: height + color: Qt.rgba(1, 1, 1, 0.28) + } + } + + FrameAnimation { + running: root.visible && (root.active || Math.abs(root.value - root.shown) > 0.0005) + onTriggered: { + root.shown += (root.value - root.shown) * (1 - Math.exp(-frameTime * 10)) + if (root.active) + root.phase = (root.phase + frameTime * root.tile * 2.5) % root.tile + } + } +} diff --git a/stemroller/qml/StemRoller/Theme.qml b/stemroller/qml/StemRoller/Theme.qml new file mode 100644 index 0000000..41b8353 --- /dev/null +++ b/stemroller/qml/StemRoller/Theme.qml @@ -0,0 +1,65 @@ +pragma Singleton +import QtQuick + +// Design tokens: Material structure (8dp grid, type ramp, motion), Aero surface. +QtObject { + // dark gray tokens + readonly property color bg: "#1D1E21" + readonly property color surface1: "#26272B" + readonly property color surface2: "#2F3034" + readonly property color glassTint: Qt.rgba(36 / 255, 37 / 255, 41 / 255, 0.70) + readonly property color primary: "#3BA8FF" + readonly property color accentGlow: "#5FE3FF" + readonly property color success: "#4CD07D" + readonly property color error: "#FF5C6C" + readonly property color warning: "#FFB547" + readonly property color textHi: "#ECEDEF" + readonly property color textLo: "#9B9DA3" + readonly property color outline: Qt.rgba(1, 1, 1, 0.08) + readonly property color hairline: Qt.rgba(1, 1, 1, 0.06) + + // 8dp grid + readonly property int u: 8 + + // type ramp 12 / 14 / 16 / 20 / 28 + property string fontFamily: "Inter" + readonly property int fs12: 12 + readonly property int fs14: 14 + readonly property int fs16: 16 + readonly property int fs20: 20 + readonly property int fs28: 28 + + // motion: Material standard easing, nothing over 300 ms + readonly property int fast: 100 + readonly property int med: 200 + readonly property int slow: 300 + readonly property var ease: [0.2, 0, 0, 1, 1, 1] + + // elevation: blur sigma, alpha, y offset per level + readonly property var shadowSigma: [0, 2, 4, 8] + readonly property var shadowAlpha: [0, 0.35, 0.45, 0.55] + readonly property var shadowDy: [0, 1, 2, 4] + + readonly property var stemColors: ({ + "vocals": "#FF7AB6", "drums": "#FFB547", "bass": "#7C8CFF", "other": "#4CD07D", + "guitar": "#FF8A5C", "piano": "#B48CFF", "instrumental": "#3DD6C6" + }) + readonly property var stemIcons: ({ + "vocals": "music", "drums": "equalizer", "bass": "speed", "other": "layers", + "guitar": "music", "piano": "music", "instrumental": "layers" + }) + + function alpha(c, a) { return Qt.rgba(c.r, c.g, c.b, a) } + function hex(c) { return c.toString().substring(1, 7).toUpperCase() } + function icon(name, color) { return "image://icon/" + name + "/" + hex(color) } + function stemColor(name) { return stemColors[name] || "#9B9DA3" } + + function time(sec, tenths) { + if (!isFinite(sec) || sec < 0) sec = 0 + var m = Math.floor(sec / 60) + var s = sec - m * 60 + var ss = tenths ? s.toFixed(1) : Math.floor(s).toString() + if ((tenths && s < 10) || (!tenths && s < 10)) ss = "0" + ss + return m + ":" + ss + } +} diff --git a/stemroller/qml/StemRoller/Tip.qml b/stemroller/qml/StemRoller/Tip.qml new file mode 100644 index 0000000..33129ec --- /dev/null +++ b/stemroller/qml/StemRoller/Tip.qml @@ -0,0 +1,18 @@ +import QtQuick +import QtQuick.Controls.Basic + +ToolTip { + id: tip + delay: 600 + timeout: 4000 + padding: 8 + contentItem: Txt { text: tip.text; font.pixelSize: Theme.fs12 } + background: Rectangle { + color: Theme.surface2 + radius: 6 + border.color: Theme.outline + Elevation { level: 2; radius: 6 } + } + enter: Transition { NumberAnimation { property: "opacity"; from: 0; to: 1; duration: Theme.fast } } + exit: Transition { NumberAnimation { property: "opacity"; from: 1; to: 0; duration: Theme.fast } } +} diff --git a/stemroller/qml/StemRoller/TitleBar.qml b/stemroller/qml/StemRoller/TitleBar.qml new file mode 100644 index 0000000..569c9d1 --- /dev/null +++ b/stemroller/qml/StemRoller/TitleBar.qml @@ -0,0 +1,182 @@ +import QtQuick +import QtQuick.Controls.Basic + +GlassPanel { + id: bar + property var win: Window.window + signal openSettings() + height: 52 + topLeftRadius: win.radius + topRightRadius: win.radius + + // Drag to move / double-click to maximize via the compositor (Wayland-native). + DragHandler { + target: null + grabPermissions: PointerHandler.CanTakeOverFromAnything + onActiveChanged: if (active) bar.win.startSystemMove() + } + TapHandler { + acceptedButtons: Qt.LeftButton + onDoubleTapped: bar.win.toggleMaximized() + } + + Row { + anchors { left: parent.left; leftMargin: 16; verticalCenter: parent.verticalCenter } + spacing: 10 + Rectangle { + width: 28 + height: 28 + radius: 8 + anchors.verticalCenter: parent.verticalCenter + gradient: Gradient { + GradientStop { position: 0; color: "#5FC8FF" } + GradientStop { position: 1; color: "#2A7BD8" } + } + border.color: Qt.rgba(1, 1, 1, 0.3) + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 1 } + height: 12 + topLeftRadius: 7 + topRightRadius: 7 + color: Qt.rgba(1, 1, 1, 0.25) + } + Icon { anchors.centerIn: parent; name: "equalizer"; size: 18; color: "#FFFFFF" } + } + Txt { + text: "StemRoller" + font.pixelSize: Theme.fs16 + font.weight: Font.DemiBold + anchors.verticalCenter: parent.verticalCenter + } + Rectangle { // engine status + anchors.verticalCenter: parent.verticalCenter + height: 22 + width: st.implicitWidth + 26 + radius: 11 + readonly property color tone: app.workerState === "ready" ? Theme.success + : app.workerState === "busy" ? Theme.primary + : app.workerState === "crashed" ? Theme.error : Theme.warning + color: Theme.alpha(tone, 0.12) + border.color: Theme.alpha(tone, 0.3) + Rectangle { + x: 9 + anchors.verticalCenter: parent.verticalCenter + width: 7 + height: 7 + radius: 4 + color: parent.tone + } + Txt { + id: st + x: 20 + anchors.verticalCenter: parent.verticalCenter + font.pixelSize: 11 + font.weight: Font.Medium + color: parent.tone + text: app.workerState === "ready" ? "Engine ready" + : app.workerState === "busy" ? "Separating" + : app.workerState === "crashed" ? "Engine restarting" : "Starting engine" + } + } + } + + Row { + anchors { right: parent.right; rightMargin: 10; verticalCenter: parent.verticalCenter } + spacing: 8 + + AeroComboBox { + id: modelPicker + width: 240 + caption: "MODEL" + iconName: "layers" + implicitHeight: 40 + subRole: "note" + popupWidth: 300 + model: app.models + currentIndex: app.models.findIndex(m => m.id === appSettings.modelId) + onActivated: appSettings.modelId = currentValue + anchors.verticalCenter: parent.verticalCenter + } + + AbstractButton { // 2-stem vocals toggle chip + id: twoStem + readonly property var model: app.models.find(m => m.id === appSettings.modelId) + readonly property bool applicable: !!model && model.stems > 2 + anchors.verticalCenter: parent.verticalCenter + checkable: true + checked: appSettings.twoStems && applicable + enabled: applicable + onToggled: appSettings.twoStems = checked + hoverEnabled: true + implicitHeight: 32 + implicitWidth: twoLbl.implicitWidth + 40 + opacity: enabled ? 1 : 0.4 + background: Rectangle { + radius: 16 + color: twoStem.checked ? Theme.alpha(Theme.stemColor("vocals"), 0.2) : (twoStem.hovered ? Qt.rgba(1, 1, 1, 0.08) : Qt.rgba(1, 1, 1, 0.04)) + border.color: twoStem.checked ? Theme.alpha(Theme.stemColor("vocals"), 0.6) : Qt.rgba(1, 1, 1, 0.10) + Behavior on color { ColorAnimation { duration: Theme.fast } } + } + contentItem: Row { + leftPadding: 12 + spacing: 6 + Icon { + name: twoStem.checked ? "check" : "music" + size: 16 + color: twoStem.checked ? Theme.stemColor("vocals") : Theme.textLo + anchors.verticalCenter: parent.verticalCenter + } + Txt { + id: twoLbl + text: "Vocals only" + font.pixelSize: Theme.fs12 + font.weight: Font.Medium + color: twoStem.checked ? Theme.textHi : Theme.textLo + anchors.verticalCenter: parent.verticalCenter + } + } + Tip { visible: twoStem.hovered; text: twoStem.applicable ? "2-stem mode: vocals + instrumental" : "This model is already 2-stem" } + } + + AeroComboBox { + id: devicePicker + width: 250 + caption: app.vram.valid === true && appSettings.deviceId !== "cpu" + ? "DEVICE · " + (app.vram.free / 1024).toFixed(1) + " GB FREE" : "DEVICE" + iconName: "chip" + implicitHeight: 40 + popupWidth: 300 + model: app.devices + currentIndex: Math.max(0, app.devices.findIndex(d => d.id === appSettings.deviceId)) + onActivated: appSettings.deviceId = currentValue + anchors.verticalCenter: parent.verticalCenter + + HoverHandler { id: devHover } + Tip { visible: devHover.hovered && app.vram.valid === true; text: app.vram.text || "" } + } + + IconButton { + anchors.verticalCenter: parent.verticalCenter + iconName: "settings" + size: 36 + tip: "Settings (Ctrl+,)" + onClicked: bar.openSettings() + } + + Rectangle { width: 1; height: 24; color: Theme.hairline; anchors.verticalCenter: parent.verticalCenter } + + Row { + anchors.verticalCenter: parent.verticalCenter + spacing: 2 + CaptionButton { iconName: "minimize"; onClicked: bar.win.showMinimized() } + CaptionButton { iconName: bar.win.maximized ? "restore" : "maximize"; onClicked: bar.win.toggleMaximized() } + CaptionButton { iconName: "close"; danger: true; onClicked: bar.win.close() } + } + } + + Rectangle { // separator to content (elevation 1 edge) + anchors { left: parent.left; right: parent.right; bottom: parent.bottom } + height: 1 + color: Theme.hairline + } +} diff --git a/stemroller/qml/StemRoller/Toast.qml b/stemroller/qml/StemRoller/Toast.qml new file mode 100644 index 0000000..ba10f16 --- /dev/null +++ b/stemroller/qml/StemRoller/Toast.qml @@ -0,0 +1,65 @@ +import QtQuick + +// Material snackbar on surface-2. +Item { + id: t + property string message: "" + property string kind: "info" + property string folder: "" + property real maxWidth: 800 + width: Math.min(maxWidth, row.implicitWidth + 32) + height: 48 + opacity: 0 + visible: opacity > 0 + y: shown ? 0 : 12 + property bool shown: false + + function show(m, k, f) { + message = m; kind = k; folder = f + shown = true + hideTimer.restart() + } + Timer { id: hideTimer; interval: 5000; onTriggered: t.shown = false } + states: State { when: t.shown; PropertyChanges { t.opacity: 1 } } + Behavior on opacity { NumberAnimation { duration: Theme.med; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + Behavior on y { NumberAnimation { duration: Theme.slow; easing.type: Easing.BezierSpline; easing.bezierCurve: Theme.ease } } + + Rectangle { + anchors.fill: parent + radius: 8 + color: Theme.surface2 + border.color: t.kind === "error" ? Theme.alpha(Theme.error, 0.5) : t.kind === "success" ? Theme.alpha(Theme.success, 0.45) : Theme.outline + Elevation { level: 3; radius: 8 } + } + Row { + id: row + anchors { left: parent.left; leftMargin: 16; verticalCenter: parent.verticalCenter } + spacing: 12 + Icon { + anchors.verticalCenter: parent.verticalCenter + name: t.kind === "error" ? "error" : t.kind === "success" ? "check" : "music" + size: 18 + color: t.kind === "error" ? Theme.error : t.kind === "success" ? Theme.success : Theme.accentGlow + } + Txt { + anchors.verticalCenter: parent.verticalCenter + text: t.message + width: Math.min(implicitWidth, 640) + } + AeroButton { + visible: t.folder.length > 0 + anchors.verticalCenter: parent.verticalCenter + variant: "text" + pillHeight: 32 + text: "Open folder" + onClicked: { app.openFolder(t.folder); t.shown = false } + } + IconButton { + anchors.verticalCenter: parent.verticalCenter + size: 28; iconSize: 14 + iconName: "close" + glow: false + onClicked: t.shown = false + } + } +} diff --git a/stemroller/qml/StemRoller/TrackView.qml b/stemroller/qml/StemRoller/TrackView.qml new file mode 100644 index 0000000..e9eef17 --- /dev/null +++ b/stemroller/qml/StemRoller/TrackView.qml @@ -0,0 +1,344 @@ +import QtQuick +import QtQuick.Controls.Basic + +// Main pane for the selected track: progress, error, or stem lanes. +Item { + id: tv + property var win: Window.window + readonly property var sel: app.selected + readonly property string status: sel.valid ? sel.status : "" + + // Lane model only changes when the track or its stems change, so per-lane + // UI state survives the frequent selectedChanged notifications. + property string stemsKey: "" + property var stems: [] + property var soloState: [] + property var muteState: [] + property var gainState: [] + property real viewStart: 0 + property real viewEnd: 1 + property int waveW: 100 + + function syncStems() { + var key = sel.valid && sel.status === "done" ? sel.id + ":" + sel.stems.map(s => s.name).join(",") : "" + if (key === stemsKey) return + stemsKey = key + stems = key ? sel.stems : [] + soloState = stems.map(() => false) + muteState = stems.map(() => false) + gainState = stems.map(() => 0) + viewStart = 0 + viewEnd = Math.max(0.01, sel.duration || 1) + } + onSelChanged: syncStems() + Component.onCompleted: syncStems() + + readonly property bool anySolo: soloState.indexOf(true) >= 0 + readonly property real span: Math.max(0.01, viewEnd - viewStart) + readonly property real duration: Math.max(0.01, sel.duration || 1) + + function zoomAt(fx, factor) { + var t = viewStart + fx * span + var newSpan = Math.max(0.25, Math.min(duration, span * factor)) + var s = Math.max(0, Math.min(duration - newSpan, t - fx * newSpan)) + viewStart = s + viewEnd = s + newSpan + } + function pan(dt) { + var s = Math.max(0, Math.min(duration - span, viewStart + dt)) + viewEnd = s + span + viewStart = s + } + + // ------------------------------------------------------------- done + Item { + id: doneView + anchors.fill: parent + visible: tv.status === "done" + + Card { + id: header + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 24; bottomMargin: 0 } + height: 104 + Column { + anchors { left: parent.left; leftMargin: 20; right: actions.left; rightMargin: 16; verticalCenter: parent.verticalCenter } + spacing: 6 + Txt { + width: parent.width + text: tv.sel.fileName || "" + font.pixelSize: Theme.fs20 + font.weight: Font.DemiBold + } + Txt { + width: parent.width + color: Theme.textLo + font.pixelSize: Theme.fs12 + text: [tv.sel.modelLabel, tv.sel.deviceLabel, Theme.time(tv.sel.duration || 0, false), + tv.sel.elapsed > 0 ? "separated in " + tv.sel.elapsed.toFixed(1) + " s" : "from cache"] + .filter(s => s && s.length).join(" · ") + } + Row { + spacing: 6 + Icon { name: "folder"; size: 14; color: Theme.textLo; anchors.verticalCenter: parent.verticalCenter } + Txt { + text: (tv.sel.exportedTo ? "Exported to " : "Exports to ") + (tv.sel.target || "") + + " · " + appSettings.exportFormat.toUpperCase() + font.pixelSize: Theme.fs12 + color: tv.sel.exportedTo ? Theme.success : Theme.textLo + anchors.verticalCenter: parent.verticalCenter + } + } + } + Row { + id: actions + anchors { right: parent.right; rightMargin: 20; verticalCenter: parent.verticalCenter } + spacing: 8 + AeroButton { + visible: (tv.sel.rerunLabel || "").length > 0 + variant: "text" + iconName: "refresh" + text: "Re-run with " + (tv.sel.rerunLabel || "") + onClicked: app.rerunSelected() + } + IconButton { + anchors.verticalCenter: parent.verticalCenter + size: 40 + iconName: "folder" + tip: "Open output folder" + onClicked: app.openTargetFolder() + } + AeroButton { + variant: "tonal" + iconName: "layers" + text: "Export mix" + onClicked: app.exportMix() + } + AeroButton { + variant: "filled" + iconName: "download" + text: "Export all" + onClicked: app.exportAll() + } + } + } + + // timeline ruler + zoom hint + Item { + id: ruler + anchors { left: parent.left; right: parent.right; top: header.bottom; leftMargin: 24; rightMargin: 24; topMargin: 12 } + height: 22 + readonly property real waveX: 248 + Txt { + anchors.verticalCenter: parent.verticalCenter + text: tv.span < tv.duration - 0.01 ? "Zoomed · Ctrl+wheel to zoom, Shift+wheel to pan, double-click to reset" + : "Ctrl+wheel to zoom" + font.pixelSize: 11 + color: Theme.alpha(Theme.textLo, 0.8) + } + Repeater { + model: 6 + Txt { + required property int index + x: ruler.waveX + (ruler.width - ruler.waveX - 8) * index / 5 - (index === 5 ? width : index === 0 ? 0 : width / 2) + anchors.verticalCenter: parent.verticalCenter + text: Theme.time(tv.viewStart + tv.span * index / 5, tv.span < 20) + font.pixelSize: 11 + font.features: { "tnum": 1 } + color: Theme.textLo + } + } + } + + Flickable { + id: lanes + anchors { left: parent.left; right: parent.right; top: ruler.bottom; bottom: parent.bottom; leftMargin: 24; rightMargin: 24; topMargin: 6 } + contentHeight: col.height + 24 + clip: true + boundsBehavior: Flickable.StopAtBounds + ScrollBar.vertical: ScrollBar { + policy: ScrollBar.AsNeeded + contentItem: Rectangle { implicitWidth: 4; radius: 2; color: Qt.rgba(1, 1, 1, 0.18); visible: parent.size < 1 } + background: Item {} + } + + readonly property real waveX: ruler.waveX + onWidthChanged: waveTimer.restart() + Timer { // debounce texture re-renders during window resize + id: waveTimer + interval: 90 + onTriggered: tv.waveW = Math.max(10, lanes.width - lanes.waveX - 8) + } + Component.onCompleted: tv.waveW = Math.max(10, lanes.width - lanes.waveX - 8) + + Column { + id: col + width: lanes.width + spacing: 8 + topPadding: 4 + Repeater { + model: tv.stems + StemLane { + width: col.width + jobId: tv.sel.id || "" + waveX: lanes.waveX + waveW: tv.waveW + viewStart: tv.viewStart + viewEnd: tv.viewEnd + anySolo: tv.anySolo + solo: tv.soloState[index] || false + mute: tv.muteState[index] || false + gainDb: tv.gainState[index] || 0 + onSoloToggled: (on) => { + var s = tv.soloState.slice(); s[index] = on; tv.soloState = s + audio.setSolo(index, on) + } + onMuteChanged: { var m = tv.muteState.slice(); m[index] = mute; tv.muteState = m } + onGainDbChanged: { var g = tv.gainState.slice(); g[index] = gainDb; tv.gainState = g } + } + } + } + + // click / drag on any waveform to seek + MouseArea { + x: lanes.waveX + y: 0 + width: tv.waveW + height: col.height + cursorShape: Qt.IBeamCursor + enabled: audio.loaded + function seekTo(mx) { + var t = tv.viewStart + Math.max(0, Math.min(1, mx / width)) * tv.span + audio.seek(t) + tv.win.playPos = t + } + onPressed: (e) => seekTo(e.x) + onPositionChanged: (e) => { if (pressed) seekTo(e.x) } + onDoubleClicked: { tv.viewStart = 0; tv.viewEnd = tv.duration } + } + + // playhead (position interpolated per frame from the audio ring buffer) + Rectangle { + readonly property real f: (tv.win.playPos - tv.viewStart) / tv.span + visible: audio.loaded && f >= 0 && f <= 1 + x: lanes.waveX + f * tv.waveW - 1 + y: 2 + width: 2 + height: col.height + color: "#FFFFFF" + Glow { radius: 1; sigma: 3; opacity: 0.8 } + } + + WheelHandler { + acceptedModifiers: Qt.ControlModifier + onWheel: (e) => { + var fx = Math.max(0, Math.min(1, (point.position.x - lanes.waveX) / tv.waveW)) + tv.zoomAt(fx, e.angleDelta.y > 0 ? 0.8 : 1.25) + } + } + WheelHandler { + acceptedModifiers: Qt.ShiftModifier + onWheel: (e) => tv.pan(-(e.angleDelta.y || e.angleDelta.x) / 120 * tv.span * 0.1) + } + } + } + + // ------------------------------------------------- running / queued + Card { + visible: tv.status === "running" || tv.status === "queued" + anchors.centerIn: parent + width: Math.min(parent.width - 48, 620) + height: 236 + elevation: 2 + Column { + anchors { fill: parent; margins: 28 } + spacing: 12 + Txt { + width: parent.width + text: tv.sel.fileName || "" + font.pixelSize: Theme.fs20 + font.weight: Font.DemiBold + } + Txt { + text: tv.status === "queued" ? "Waiting for the GPU · " + (tv.sel.modelLabel || "") + : (tv.sel.stage || "") + " · " + (tv.sel.modelLabel || "") + color: Theme.textLo + } + Row { + spacing: 12 + Txt { + text: Math.floor((progressBar.shown) * 100) + "%" + font.pixelSize: Theme.fs28 + font.weight: Font.DemiBold + font.features: { "tnum": 1 } + color: tv.status === "running" ? Theme.textHi : Theme.textLo + } + } + StripedProgress { + id: progressBar + width: parent.width + barHeight: 10 + value: tv.sel.progress || 0 + active: tv.status === "running" + opacity: tv.status === "running" ? 1 : 0.4 + } + Item { width: 1; height: 4 } + AeroButton { + variant: "tonal" + tone: Theme.error + iconName: "close" + text: tv.status === "queued" ? "Remove from queue" : "Cancel" + onClicked: app.cancelJob(tv.sel.id) + } + } + } + + // ------------------------------------------------ error / cancelled + Card { + visible: tv.status === "error" || tv.status === "cancelled" + anchors.centerIn: parent + width: Math.min(parent.width - 48, 620) + height: errCol.implicitHeight + 56 + Column { + id: errCol + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 28 } + spacing: 12 + Row { + spacing: 10 + Icon { + name: tv.status === "error" ? "error" : "close" + size: 24 + color: tv.status === "error" ? Theme.error : Theme.textLo + anchors.verticalCenter: parent.verticalCenter + } + Txt { + text: tv.status === "error" ? "Separation failed" : "Cancelled" + font.pixelSize: Theme.fs20 + font.weight: Font.DemiBold + anchors.verticalCenter: parent.verticalCenter + } + } + Txt { width: parent.width; text: tv.sel.fileName || ""; color: Theme.textLo } + Rectangle { + visible: tv.status === "error" + width: parent.width + height: msg.implicitHeight + 20 + radius: 6 + color: Theme.alpha(Theme.error, 0.08) + border.color: Theme.alpha(Theme.error, 0.25) + Txt { + id: msg + anchors { fill: parent; margins: 10 } + text: tv.sel.message || "" + wrapMode: Text.WordWrap + elide: Text.ElideNone + font.pixelSize: Theme.fs12 + } + } + Row { + spacing: 8 + AeroButton { variant: "filled"; iconName: "refresh"; text: "Retry"; onClicked: app.retryJob(tv.sel.id) } + AeroButton { variant: "text"; tone: Theme.textLo; iconName: "delete"; text: "Remove"; onClicked: app.removeJob(tv.sel.id) } + } + } + } +} diff --git a/stemroller/qml/StemRoller/Transport.qml b/stemroller/qml/StemRoller/Transport.qml new file mode 100644 index 0000000..287dd91 --- /dev/null +++ b/stemroller/qml/StemRoller/Transport.qml @@ -0,0 +1,192 @@ +import QtQuick +import QtQuick.Controls.Basic + +GlassPanel { + id: tr + property var win: Window.window + readonly property bool ready: audio.loaded + readonly property real dur: audio.duration + bottomLeftRadius: win.radius + bottomRightRadius: win.radius + gloss: true + + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top } + height: 1 + color: Theme.hairline + } + + Row { + id: left + anchors { left: parent.left; leftMargin: 16; verticalCenter: parent.verticalCenter } + spacing: 10 + IconButton { + anchors.verticalCenter: parent.verticalCenter + iconName: "skip_start" + enabled: tr.ready + tip: "Back to start (Home)" + onClicked: { audio.seek(0); tr.win.playPos = 0 } + } + AbstractButton { // glossy round play/pause + id: play + anchors.verticalCenter: parent.verticalCenter + width: 44 + height: 44 + enabled: tr.ready + hoverEnabled: true + opacity: enabled ? 1 : 0.4 + onClicked: audio.toggle() + background: Item { + Glow { radius: 22; opacity: play.hovered && play.enabled ? 0.6 : 0 } + Rectangle { + anchors.fill: parent + radius: 22 + gradient: Gradient { + GradientStop { position: 0; color: "#6CC4FF" } + GradientStop { position: 1; color: "#1F7FE0" } + } + border.color: Qt.rgba(1, 1, 1, 0.35) + Rectangle { + anchors { left: parent.left; right: parent.right; top: parent.top; margins: 2 } + height: 19 + topLeftRadius: 20 + topRightRadius: 20 + gradient: Gradient { + GradientStop { position: 0; color: Qt.rgba(1, 1, 1, 0.45) } + GradientStop { position: 1; color: Qt.rgba(1, 1, 1, 0.08) } + } + } + Rectangle { anchors.fill: parent; radius: 22; color: play.down ? Qt.rgba(0, 0, 0, 0.2) : "transparent" } + } + } + contentItem: Item { + Icon { anchors.centerIn: parent; name: audio.playing ? "pause" : "play"; size: 24; color: "#FFFFFF" } + } + } + Txt { + anchors.verticalCenter: parent.verticalCenter + width: 118 + text: Theme.time(tr.win.playPos, true) + " / " + Theme.time(tr.dur, false) + font.features: { "tnum": 1 } + font.pixelSize: Theme.fs14 + color: tr.ready ? Theme.textHi : Theme.textLo + } + } + + // scrub bar + Item { + id: scrub + anchors { left: left.right; leftMargin: 16; right: volume.left; rightMargin: 24; verticalCenter: parent.verticalCenter } + height: 24 + enabled: tr.ready + readonly property real frac: tr.dur > 0 ? Math.min(1, tr.win.playPos / tr.dur) : 0 + Rectangle { + id: track + anchors.verticalCenter: parent.verticalCenter + width: parent.width + height: scrubArea.containsMouse || scrubArea.pressed ? 6 : 4 + radius: 3 + color: Qt.rgba(1, 1, 1, 0.10) + Behavior on height { NumberAnimation { duration: Theme.fast } } + Rectangle { + width: parent.width * scrub.frac + height: parent.height + radius: 3 + gradient: Gradient { + orientation: Gradient.Horizontal + GradientStop { position: 0; color: Theme.primary } + GradientStop { position: 1; color: Theme.accentGlow } + } + } + } + Rectangle { + visible: tr.ready + x: scrub.width * scrub.frac - width / 2 + anchors.verticalCenter: parent.verticalCenter + width: scrubArea.containsMouse || scrubArea.pressed ? 14 : 10 + height: width + radius: width / 2 + color: "#FFFFFF" + Behavior on width { NumberAnimation { duration: Theme.fast } } + Glow { radius: 7; sigma: 4; opacity: scrubArea.containsMouse ? 0.7 : 0.3 } + } + MouseArea { + id: scrubArea + anchors.fill: parent + hoverEnabled: true + enabled: tr.ready + cursorShape: Qt.PointingHandCursor + function seekTo(x) { + var t = Math.max(0, Math.min(1, x / width)) * tr.dur + audio.seek(t) + tr.win.playPos = t + } + onPressed: (e) => seekTo(e.x) + onPositionChanged: (e) => { if (pressed) seekTo(e.x) } + } + } + + // master volume: monitoring only, never baked into exports + Row { + id: volume + anchors { right: meter.left; rightMargin: 24; verticalCenter: parent.verticalCenter } + spacing: 6 + IconButton { + id: muteBtn + property real restore: 1.0 + anchors.verticalCenter: parent.verticalCenter + iconName: audio.volume <= 0 ? "volume_off" : "volume" + tip: audio.volume <= 0 ? "Unmute" : "Mute" + onClicked: { + if (audio.volume > 0) { + restore = audio.volume + audio.volume = 0 + } else { + audio.volume = restore > 0 ? restore : 1.0 + } + appSettings.masterVolume = audio.volume + } + } + AeroSlider { + anchors.verticalCenter: parent.verticalCenter + width: 112 + from: 0 + to: 1 + value: audio.volume + onMoved: audio.volume = value + onPressedChanged: if (!pressed) appSettings.masterVolume = audio.volume + WheelHandler { + onWheel: (e) => { + audio.volume = Math.max(0, Math.min(1, audio.volume + e.angleDelta.y / 120 * 0.05)) + appSettings.masterVolume = audio.volume + } + } + } + Txt { + anchors.verticalCenter: parent.verticalCenter + width: 36 + text: Math.round(audio.volume * 100) + "%" + font.features: { "tnum": 1 } + font.pixelSize: Theme.fs12 + color: Theme.textLo + } + } + + Row { + id: meter + anchors { right: parent.right; rightMargin: 20; verticalCenter: parent.verticalCenter } + spacing: 10 + Column { + anchors.verticalCenter: parent.verticalCenter + spacing: 4 + Txt { text: "L"; font.pixelSize: 9; color: Theme.textLo; height: 9 } + Txt { text: "R"; font.pixelSize: 9; color: Theme.textLo; height: 9 } + } + LevelMeter { + anchors.verticalCenter: parent.verticalCenter + width: 160 + levelLeft: tr.win.levelL + levelRight: tr.win.levelR + } + } +} diff --git a/stemroller/qml/StemRoller/Txt.qml b/stemroller/qml/StemRoller/Txt.qml new file mode 100644 index 0000000..9016117 --- /dev/null +++ b/stemroller/qml/StemRoller/Txt.qml @@ -0,0 +1,10 @@ +import QtQuick + +Text { + color: Theme.textHi + font.family: Theme.fontFamily + font.pixelSize: Theme.fs14 + renderType: Text.NativeRendering + elide: Text.ElideRight + verticalAlignment: Text.AlignVCenter +} diff --git a/stemroller/qml/StemRoller/qmldir b/stemroller/qml/StemRoller/qmldir new file mode 100644 index 0000000..1bf5301 --- /dev/null +++ b/stemroller/qml/StemRoller/qmldir @@ -0,0 +1,30 @@ +module StemRoller +singleton Theme 1.0 Theme.qml +AeroButton 1.0 AeroButton.qml +AeroComboBox 1.0 AeroComboBox.qml +AeroSlider 1.0 AeroSlider.qml +AeroSwitch 1.0 AeroSwitch.qml +CaptionButton 1.0 CaptionButton.qml +Card 1.0 Card.qml +DashedFrame 1.0 DashedFrame.qml +DropZone 1.0 DropZone.qml +Elevation 1.0 Elevation.qml +FrameOverlay 1.0 FrameOverlay.qml +GlassPanel 1.0 GlassPanel.qml +Glow 1.0 Glow.qml +IconButton 1.0 IconButton.qml +Icon 1.0 Icon.qml +LevelMeter 1.0 LevelMeter.qml +QueueItem 1.0 QueueItem.qml +ResizeEdge 1.0 ResizeEdge.qml +SettingsDialog 1.0 SettingsDialog.qml +Sidebar 1.0 Sidebar.qml +StatusChip 1.0 StatusChip.qml +StemLane 1.0 StemLane.qml +StripedProgress 1.0 StripedProgress.qml +Tip 1.0 Tip.qml +TitleBar 1.0 TitleBar.qml +Toast 1.0 Toast.qml +TrackView 1.0 TrackView.qml +Transport 1.0 Transport.qml +Txt 1.0 Txt.qml diff --git a/stemroller/settings.py b/stemroller/settings.py new file mode 100644 index 0000000..03f434a --- /dev/null +++ b/stemroller/settings.py @@ -0,0 +1,78 @@ +"""Persistent settings exposed to QML as plain properties.""" + +import json +import os + +from PySide6.QtCore import Property, QObject, Signal + +CONFIG_PATH = os.path.join(os.path.expanduser("~/.config/stemroller"), "settings.json") + +DEFAULTS = { + "modelId": "htdemucs", + "twoStems": False, + "deviceId": "auto", + "outputMode": "beside", # "beside" the source file, or "folder" (stemsDir) + "stemsDir": os.path.expanduser("~/Music/Stems"), + "exportFormat": "wav", # wav | flac | mp3 + "segment": 0.0, # seconds; 0 = model default + "shifts": 0, + "overlap": 0.25, + "fp16": True, + "autoExport": False, + "frameOverlay": False, + "cacheLimitGb": 8.0, + "masterVolume": 1.0, # slider position 0..1 (cubic taper in the audio engine) +} + + +class _SettingsBase(QObject): + def __init__(self, parent=None): + super().__init__(parent) + self._values = dict(DEFAULTS) + try: + with open(CONFIG_PATH) as f: + stored = json.load(f) + for k, v in stored.items(): + if k not in DEFAULTS: + continue + want = type(DEFAULTS[k]) + if type(v) is want or (want is float and type(v) is int): + self._values[k] = want(v) + except (OSError, ValueError): + pass + + def save(self): + os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True) + tmp = CONFIG_PATH + ".tmp" + with open(tmp, "w") as f: + json.dump(self._values, f, indent=2) + os.replace(tmp, CONFIG_PATH) + + def get(self, name): + return self._values[name] + + +def _build(): + # Qt only sees properties and signals present when the class is created, + # so generate one Property + Changed signal per default up front. + ns = {} + for name, default in DEFAULTS.items(): + type_ = type(default) + sig = Signal() + ns[f"{name}Changed"] = sig + + def getter(self, _n=name): + return self._values[_n] + + def setter(self, value, _n=name, _t=type_): + value = _t(value) + if self._values[_n] != value: + self._values[_n] = value + getattr(self, f"{_n}Changed").emit() + self.save() + + ns[name] = Property(type_, getter, setter, notify=sig) + return type("Settings", (_SettingsBase,), ns) + + +Settings = _build() diff --git a/stemroller/worker/__init__.py b/stemroller/worker/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/stemroller/worker/__main__.py b/stemroller/worker/__main__.py new file mode 100644 index 0000000..9b29a38 --- /dev/null +++ b/stemroller/worker/__main__.py @@ -0,0 +1,289 @@ +"""Separation worker process. + +Connects to the UI's local socket and speaks newline-delimited JSON: + + UI -> worker start {id, file, model, device, two_stems, out_dir, segment, shifts, overlap, fp16} + cancel {id} + release {} drop cached models and free VRAM + quit {} + worker -> UI hello {devices[], torch, hip} + vram {device, free_mb, total_mb} + progress {id, pct, stage} + done {id, stems[], peaks_path, samplerate, duration, out_dir} + error {id, msg} + cancelled {id} + +Runs one job at a time; the UI owns the queue. +""" + +import argparse +import json +import os +import queue +import re +import shutil +import socket +import subprocess +import sys +import threading +import time +import traceback + +# Fast MIOpen kernel selection: avoids multi-minute first-run tuning on RDNA4. +os.environ.setdefault("MIOPEN_FIND_MODE", "FAST") +os.environ.setdefault("TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL", "1") +os.environ.setdefault("MIOPEN_LOG_LEVEL", "2") # silence workspace warnings + +PROGRESS_INTERVAL = 1 / 30 # doc: at most 30 progress updates per second +MODEL_DIR = os.path.join(os.path.expanduser("~/.cache/stemroller"), "models") + + +class Conn: + def __init__(self, path): + self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self.sock.connect(path) + self.lock = threading.Lock() + self.rfile = self.sock.makefile("r", encoding="utf-8") + + def send(self, type_, **payload): + line = json.dumps({"type": type_, **payload}) + "\n" + with self.lock: + self.sock.sendall(line.encode()) + + def __iter__(self): + for line in self.rfile: + line = line.strip() + if line: + yield json.loads(line) + + +class Job: + def __init__(self, msg, conn): + from stemroller.catalog import MODELS_BY_ID + self.id = msg["id"] + self.file = msg["file"] + self.model = MODELS_BY_ID[msg["model"]] + self.device = msg.get("device", "auto") + self.two_stems = bool(msg.get("two_stems")) + self.out_dir = msg["out_dir"] + self.segment = float(msg.get("segment") or 0) + self.shifts = int(msg.get("shifts") or 0) + self.overlap = float(msg.get("overlap", 0.25)) + self.fp16 = bool(msg.get("fp16", True)) + # audio-separator expresses overlap as a divisor of the chunk (step = chunk / overlap); + # RoFormer's windowed overlap-add wants at least 4 (75%). + self.overlap_int = max(4, round(1 / max(0.05, 1 - self.overlap))) + self.cancel_event = threading.Event() + self._conn = conn + self._last_sent = 0.0 + + def check(self): + if self.cancel_event.is_set(): + from stemroller.worker.backends import Cancelled + raise Cancelled() + + def report(self, stage, pct, force=False): + now = time.monotonic() + if force or now - self._last_sent >= PROGRESS_INTERVAL: + self._last_sent = now + self._conn.send("progress", id=self.id, pct=round(float(pct), 4), stage=stage) + + +def gpu_marketing_names(): + """gfx arch -> marketing name from rocminfo (torch reports a generic name on ROCm).""" + names = {} + if not shutil.which("rocminfo"): + return names + try: + out = subprocess.run(["rocminfo"], capture_output=True, text=True, timeout=5).stdout + except Exception: + return names + arch = None + for line in out.splitlines(): + m = re.match(r"\s*Name:\s+(gfx\w+)\s*$", line) + if m: + arch = m.group(1) + m = re.match(r"\s*Marketing Name:\s+(.+?)\s*$", line) + if m and arch: + names.setdefault(arch, m.group(1)) + arch = None + return names + + +def pci_address(props): + bus = getattr(props, "pci_bus_id", None) + if bus is None: + return None + return f"{props.pci_domain_id:04x}:{bus:02x}:{props.pci_device_id:02x}.0" + + +def sysfs_vram_paths(props): + pci = pci_address(props) + if pci is None: + return None + base = f"/sys/bus/pci/devices/{pci}" + total, used = base + "/mem_info_vram_total", base + "/mem_info_vram_used" + return (total, used) if os.path.exists(used) else None + + +def enumerate_devices(): + import torch + devices = [] + if torch.cuda.is_available(): + names = gpu_marketing_names() if torch.version.hip else {} + for i in range(torch.cuda.device_count()): + p = torch.cuda.get_device_properties(i) + if getattr(p, "is_integrated", False): + continue # skip APU iGPUs (e.g. the 9800X3D's gfx1036) + arch = getattr(p, "gcnArchName", "").split(":")[0] + devices.append({ + "id": f"cuda:{i}", + "name": names.get(arch, p.name), + "arch": arch, + "total_mb": p.total_memory // 2**20, + "pci": pci_address(p), + "_sysfs": sysfs_vram_paths(p), + }) + return devices + + +def vram_loop(conn, devices): + import torch + while True: + for d in devices: + try: + if d["_sysfs"]: + total = int(open(d["_sysfs"][0]).read()) // 2**20 + used = int(open(d["_sysfs"][1]).read()) // 2**20 + free = total - used + else: + free, total = (v // 2**20 for v in torch.cuda.mem_get_info(int(d["id"].split(":")[1]))) + conn.send("vram", device=d["id"], free_mb=free, total_mb=total) + except Exception: + pass + time.sleep(1.0) + + +def resolve_device(choice, devices): + import torch + if choice == "cpu" or not devices: + return torch.device("cpu") + if choice != "auto" and any(d["id"] == choice for d in devices): + return torch.device(choice) + best = max(devices, key=lambda d: d["total_mb"]) + return torch.device(best["id"]) + + +def run_job(job, backends, devices, conn): + import numpy as np + import torch + from stemroller.worker.audio_io import save_peaks, write_stem + + device = resolve_device(job.device, devices) + backend = backends[job.model["family"]] + os.makedirs(job.out_dir, exist_ok=True) + try: + stems, sr = backend.run(job, device) + except torch.OutOfMemoryError: + torch.cuda.empty_cache() + raise RuntimeError("Out of GPU memory. Lower the segment size in Settings or pick CPU.") + + if job.two_stems and "vocals" in stems and len(stems) > 2: + rest = [a for k, a in stems.items() if k != "vocals"] + stems = {"vocals": stems["vocals"], "instrumental": np.sum(rest, axis=0)} + + job.report("Writing stems", 0.94, force=True) + out = [] + for name, audio in stems.items(): + job.check() + path = os.path.join(job.out_dir, f"{name}.wav") + write_stem(path, audio, sr) + out.append({"name": name, "path": path}) + job.report("Building waveforms", 0.98, force=True) + peaks_path = os.path.join(job.out_dir, "peaks.npz") + save_peaks(peaks_path, stems, sr) + duration = next(iter(stems.values())).shape[1] / sr + meta = {"source": job.file, "model": job.model["id"], "two_stems": job.two_stems, + "stems": out, "peaks_path": peaks_path, "samplerate": sr, "duration": duration, + "device": str(device), "finished": time.time()} + with open(os.path.join(job.out_dir, "meta.json"), "w") as f: + json.dump(meta, f) + if device.type == "cuda": + torch.cuda.empty_cache() + return {"stems": out, "peaks_path": peaks_path, "samplerate": sr, "duration": duration, + "out_dir": job.out_dir, "device": str(device)} + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--socket", required=True) + args = ap.parse_args() + + try: + os.nice(5) # UI first; the GPU does the heavy lifting anyway + except OSError: + pass + conn = Conn(args.socket) + conn.send("booting") + + import torch + torch.set_num_threads(max(1, (os.cpu_count() or 4) - 2)) + from stemroller.worker.backends import Cancelled, DemucsBackend, RoformerBackend + + devices = enumerate_devices() + conn.send("hello", devices=[{k: v for k, v in d.items() if not k.startswith("_")} for d in devices], + torch=torch.__version__, hip=torch.version.hip) + threading.Thread(target=vram_loop, args=(conn, devices), daemon=True).start() + + jobs: queue.Queue = queue.Queue() + current: dict = {} + + def reader(): + try: + for msg in conn: + t = msg.get("type") + if t in ("start", "release"): + jobs.put(msg) + elif t == "cancel": + job = current.get("job") + if job and job.id == msg.get("id"): + job.cancel_event.set() + elif t == "quit": + break + except (OSError, ValueError): + pass + # UI went away or asked us to quit: no point finishing work nobody will read. + os._exit(0) + + threading.Thread(target=reader, daemon=True).start() + + backends = {"demucs": DemucsBackend(), "roformer": RoformerBackend(MODEL_DIR)} + while True: + msg = jobs.get() + if msg.get("type") == "release": + for b in backends.values(): + b.release() + continue + try: + job = Job(msg, conn) + except Exception as e: + conn.send("error", id=msg.get("id"), msg=f"Bad job: {e}") + continue + current["job"] = job + try: + result = run_job(job, backends, devices, conn) + conn.send("done", id=job.id, **result) + except Cancelled: + shutil.rmtree(job.out_dir, ignore_errors=True) + conn.send("cancelled", id=job.id) + except Exception as e: + traceback.print_exc() + shutil.rmtree(job.out_dir, ignore_errors=True) + conn.send("error", id=job.id, msg=str(e) or e.__class__.__name__) + finally: + current.pop("job", None) + sys.stdout.flush() + + +if __name__ == "__main__": + main() diff --git a/stemroller/worker/audio_io.py b/stemroller/worker/audio_io.py new file mode 100644 index 0000000..87c0611 --- /dev/null +++ b/stemroller/worker/audio_io.py @@ -0,0 +1,79 @@ +"""Audio decode/encode and waveform peak generation for the worker.""" + +import subprocess + +import numpy as np +import soundfile as sf + +PEAK_BASE = 256 # samples per bucket at mip level 0 + + +def _source_channels(path: str) -> int: + try: + out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "a:0", "-show_entries", + "stream=channels", "-of", "csv=p=0", path], + capture_output=True, text=True, timeout=10).stdout + return int(out.strip().splitlines()[0]) + except (OSError, ValueError, IndexError, subprocess.SubprocessError): + return 0 + + +def load_audio(path: str, samplerate: int, channels: int = 2) -> np.ndarray: + """Decode any ffmpeg-readable file to float32 (channels, samples).""" + # ffmpeg's -ac upmix treats mono as centre and spreads it at -3 dB per side; + # decode mono as mono and duplicate it so stems keep the source level. + decode_ch = 1 if _source_channels(path) == 1 else channels + cmd = ["ffmpeg", "-nostdin", "-v", "error", "-i", path, "-map", "0:a:0", + "-f", "f32le", "-acodec", "pcm_f32le", "-ac", str(decode_ch), "-ar", str(samplerate), "-"] + proc = subprocess.run(cmd, capture_output=True) + if proc.returncode != 0: + lines = [l.strip() for l in proc.stderr.decode(errors="replace").splitlines() if l.strip()] + reason = lines[-1].split(": ", 1)[-1] if lines else f"ffmpeg exited with {proc.returncode}" + raise RuntimeError(f"Could not decode the file ({reason[:160]})") + data = np.frombuffer(proc.stdout, dtype=np.float32) + if data.size == 0: + raise RuntimeError("file contains no audio") + data = data.reshape(-1, decode_ch).T + if decode_ch != channels: + data = np.repeat(data, channels, axis=0) + return data.copy() + + +def write_stem(path: str, audio: np.ndarray, samplerate: int): + """Write (channels, samples) audio. 24-bit unless it would clip, then float.""" + peak = float(np.abs(audio).max()) if audio.size else 0.0 + subtype = "FLOAT" if peak > 0.999 else "PCM_24" + sf.write(path, audio.T, samplerate, subtype=subtype, format="WAV") + + +def compute_peaks(audio: np.ndarray) -> list[np.ndarray]: + """Min/max mip pyramid of a (channels, samples) signal, mono-folded. + + Level k has PEAK_BASE * 2**k samples per bucket; each level is (n, 2) float16. + """ + lo = audio.min(axis=0) + hi = audio.max(axis=0) + n = -(-lo.size // PEAK_BASE) + pad = n * PEAK_BASE - lo.size + if pad: + lo = np.concatenate([lo, np.zeros(pad, lo.dtype)]) + hi = np.concatenate([hi, np.zeros(pad, hi.dtype)]) + lvl_lo = lo.reshape(n, PEAK_BASE).min(axis=1) + lvl_hi = hi.reshape(n, PEAK_BASE).max(axis=1) + levels = [np.stack([lvl_lo, lvl_hi], axis=1).astype(np.float16)] + while lvl_lo.size > 64: + if lvl_lo.size % 2: + lvl_lo = np.append(lvl_lo, 0) + lvl_hi = np.append(lvl_hi, 0) + lvl_lo = lvl_lo.reshape(-1, 2).min(axis=1) + lvl_hi = lvl_hi.reshape(-1, 2).max(axis=1) + levels.append(np.stack([lvl_lo, lvl_hi], axis=1).astype(np.float16)) + return levels + + +def save_peaks(path: str, stems: dict[str, np.ndarray], samplerate: int): + arrays = {"samplerate": np.array(samplerate), "base": np.array(PEAK_BASE)} + for name, audio in stems.items(): + for k, level in enumerate(compute_peaks(audio)): + arrays[f"{name}/{k}"] = level + np.savez(path, **arrays) diff --git a/stemroller/worker/backends.py b/stemroller/worker/backends.py new file mode 100644 index 0000000..ea888e4 --- /dev/null +++ b/stemroller/worker/backends.py @@ -0,0 +1,251 @@ +"""Separation backends. Each returns ({stem: float32 (channels, samples)}, samplerate).""" + +import gc +import logging +import os +import random + +import numpy as np +import soundfile as sf +import torch + +from .audio_io import load_audio + + +class Cancelled(BaseException): + """Raised from progress hooks to abort a running separation.""" + + +class DemucsBackend: + """Demucs with batched segments. + + demucs.apply.apply_model runs one segment per forward pass, which leaves an + RX 9070 XT mostly idle waiting on MIOpen host overhead. Batching 8 segments + under fp16 autocast measured ~110x realtime vs ~31x for the stock loop. + """ + + BATCH = 8 + + def __init__(self): + self._model = None + self._model_name = None + + def _get(self, name): + if self._model_name != name: + from demucs.pretrained import get_model + self._model = None + torch.cuda.empty_cache() + self._model = get_model(name).eval() + self._model_name = name + return self._model + + def release(self): + self._model = self._model_name = None + gc.collect() + torch.cuda.empty_cache() + + def run(self, job, device): + from demucs.apply import BagOfModels + + job.report("Loading model", 0.01) + bag = self._get(job.model["id"]) + sub_models = bag.models if isinstance(bag, BagOfModels) else [bag] + weights = bag.weights if isinstance(bag, BagOfModels) else [[1.0] * len(bag.sources)] + job.check() + job.report("Decoding audio", 0.03) + wav = torch.from_numpy(load_audio(job.file, bag.samplerate, bag.audio_channels)) + job.check() + + ref = wav.mean(0) + mean, std = ref.mean(), ref.std() + 1e-8 + mix = ((wav - mean) / std).to(device) + length = mix.shape[-1] + + passes = max(1, job.shifts) + max_shift = int(0.5 * bag.samplerate) if job.shifts else 0 + padded = torch.nn.functional.pad(mix, (max_shift, max_shift)) if max_shift else mix + + # Work units for progress: one per segment per model per shift. + plans = [] + for sub in sub_models: + seg_len = int(min(job.segment, float(sub.segment)) * bag.samplerate) if job.segment else int(float(sub.segment) * bag.samplerate) + stride = max(1, int((1 - job.overlap) * seg_len)) + plans.append((sub, seg_len, stride)) + total_units = sum(passes * len(range(0, length + max_shift, stride)) for _, _, stride in plans) + done_units = 0 + + def tick(n): + nonlocal done_units + done_units += n + job.check() + job.report("Separating", 0.05 + 0.88 * min(1.0, done_units / total_units)) + + self.fp16 = job.fp16 + job.report("Separating", 0.05) + estimates = torch.zeros(len(bag.sources), mix.shape[0], length, device=device) + totals = [0.0] * len(bag.sources) + for (sub, seg_len, stride), w in zip(plans, weights): + sub.to(device) + out = torch.zeros_like(estimates) + for _ in range(passes): + offset = random.randint(0, max_shift) if max_shift else 0 + piece = padded[..., offset: offset + length + max_shift - offset] if max_shift else padded + res = self._split(sub, piece, seg_len, stride, job.overlap, device, tick) + out += res[..., max_shift - offset: max_shift - offset + length] + out /= passes + for k, wk in enumerate(w): + estimates[k] += out[k] * wk + totals[k] += wk + sub.cpu() + for k in range(len(totals)): + estimates[k] /= totals[k] + + out = (estimates * std.to(device) + mean.to(device)).cpu().numpy() + return dict(zip(bag.sources, out)), bag.samplerate + + def _split(self, model, mix, seg_len, stride, overlap, device, tick): + """Overlap-add over fixed-length segments, BATCH segments per forward pass.""" + channels, length = mix.shape + n_src = len(model.sources) + weight = torch.cat([torch.arange(1, seg_len // 2 + 1, device=device), + torch.arange(seg_len - seg_len // 2, 0, -1, device=device)]).float() + weight /= weight.max() + out = torch.zeros(n_src, channels, length, device=device) + sum_weight = torch.zeros(length, device=device) + offsets = list(range(0, length, stride)) + use_amp = device.type == "cuda" and self.fp16 + batch = self.BATCH + i = 0 + while i < len(offsets): + group = offsets[i:i + batch] + chunks = torch.zeros(len(group), channels, seg_len, device=device) + for j, off in enumerate(group): + piece = mix[:, off:off + seg_len] + chunks[j, :, :piece.shape[-1]] = piece + try: + with torch.no_grad(), torch.autocast("cuda", dtype=torch.float16, enabled=use_amp): + res = model(chunks).float() + except torch.OutOfMemoryError: + if batch == 1: + raise + torch.cuda.empty_cache() + batch = max(1, batch // 2) + continue + for j, off in enumerate(group): + n = min(seg_len, length - off) + out[..., off:off + n] += weight[:n] * res[j, ..., :n] + sum_weight[off:off + n] += weight[:n] + i += len(group) + tick(len(group)) + return out / sum_weight + + +def _progress_iter_factory(job, lo, hi): + """Stand-in for tqdm inside audio-separator: reports progress and checks cancel.""" + + class ProgressIter: + def __init__(self, iterable=None, *args, total=None, **kwargs): + self.iterable = iterable + self.total = total if total is not None else (len(iterable) if hasattr(iterable, "__len__") else None) + self.n = 0 + + def __iter__(self): + for item in self.iterable: + self.update(0) + yield item + self.n += 1 + + def update(self, n=1): + self.n += n + job.check() + if self.total: + job.report("Separating", lo + (hi - lo) * min(1.0, self.n / self.total)) + + def close(self): + pass + + def __enter__(self): + return self + + def __exit__(self, *exc): + return False + + return ProgressIter + + +class RoformerBackend: + def __init__(self, model_dir): + self.model_dir = model_dir + self._sep = None + self._key = None + + def _get(self, job, device): + key = (job.model["file"], str(device), job.overlap_int, job.fp16) + if self._key != key: + from audio_separator.separator import Separator + self._sep = None + torch.cuda.empty_cache() + if not os.path.exists(os.path.join(self.model_dir, job.model["file"])): + job.report("Downloading model", 0.01) + sep = Separator( + log_level=logging.WARNING, + model_file_dir=self.model_dir, + output_dir=job.out_dir, + normalization_threshold=1.0, + amplification_threshold=0.0, + use_autocast=device.type == "cuda" and job.fp16, + mdxc_params={"segment_size": 256, "override_model_segment_size": False, + "batch_size": 1, "overlap": job.overlap_int, "pitch_shift": 0}, + ) + # Separator picks "cuda" (current device) on its own; honour an explicit choice. + if device.type == "cpu": + sep.torch_device = torch.device("cpu") + elif device.index is not None: + torch.cuda.set_device(device.index) + sep.load_model(model_filename=job.model["file"]) + self._sep, self._key = sep, key + return self._sep + + def release(self): + self._sep = self._key = None + gc.collect() + torch.cuda.empty_cache() + + def run(self, job, device): + from audio_separator.separator.architectures import mdxc_separator + + job.report("Loading model", 0.02) + sep = self._get(job, device) + job.check() + + captured = {} + + def capture(stem_path, source, stem_name): + captured[stem_name] = source + return {stem_name: source} + + inst = sep.model_instance + inst.final_process = capture + inst.output_dir = job.out_dir + # audio-separator reads with libsndfile, which rejects many MP3s (big ID3 tags) and + # FLACs with one damaged frame; ffmpeg decodes both, so hand it a clean WAV instead. + job.report("Decoding audio", 0.03) + os.makedirs(job.out_dir, exist_ok=True) + mix_path = os.path.join(job.out_dir, "mix.wav") + sf.write(mix_path, load_audio(job.file, inst.sample_rate, 2).T, inst.sample_rate, subtype="FLOAT") + job.check() + mdxc_separator.tqdm = _progress_iter_factory(job, 0.05, 0.93) + job.report("Separating", 0.05) + try: + sep.separate(mix_path) + finally: + os.remove(mix_path) + + two_stem_model = len(job.model["stems"]) == 2 + stems = {} + for name, source in captured.items(): + key = name.lower() + if two_stem_model and key != "vocals": + key = "instrumental" + stems[key] = np.ascontiguousarray(source.T, dtype=np.float32) + return stems, inst.sample_rate diff --git a/stemroller/worker/cli.py b/stemroller/worker/cli.py new file mode 100644 index 0000000..7179d5f --- /dev/null +++ b/stemroller/worker/cli.py @@ -0,0 +1,106 @@ +"""CLI harness for the worker: spawns it, speaks the IPC protocol, prints progress. + + stemroller-worker-cli song.mp3 --model htdemucs [--device cuda:0] [--two-stems] [--cancel-after 3] +""" + +import argparse +import hashlib +import json +import os +import socket +import subprocess +import sys +import tempfile +import time + +from stemroller.catalog import MODELS_BY_ID + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("files", nargs="+") + ap.add_argument("--model", default="htdemucs", choices=list(MODELS_BY_ID)) + ap.add_argument("--device", default="auto") + ap.add_argument("--two-stems", action="store_true") + ap.add_argument("--shifts", type=int, default=0) + ap.add_argument("--segment", type=float, default=0) + ap.add_argument("--overlap", type=float, default=0.25) + ap.add_argument("--fp32", action="store_true") + ap.add_argument("--out", default=None, help="output root (default: a temp dir)") + ap.add_argument("--cancel-after", type=float, default=None, help="send cancel after N seconds") + args = ap.parse_args() + + out_root = args.out or tempfile.mkdtemp(prefix="stemroller-cli-") + sock_path = os.path.join(tempfile.mkdtemp(), "w.sock") + server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + server.bind(sock_path) + server.listen(1) + + t0 = time.monotonic() + proc = subprocess.Popen([sys.executable, "-m", "stemroller.worker", "--socket", sock_path]) + conn, _ = server.accept() + rfile = conn.makefile("r") + + def send(**msg): + conn.sendall((json.dumps(msg) + "\n").encode()) + + pending = [] + for i, f in enumerate(args.files): + jid = f"cli{i}" + out_dir = os.path.join(out_root, hashlib.sha1(f.encode()).hexdigest()[:10] + "_" + args.model) + pending.append(jid) + send(type="start", id=jid, file=os.path.abspath(f), model=args.model, device=args.device, + two_stems=args.two_stems, out_dir=out_dir, segment=args.segment, shifts=args.shifts, + overlap=args.overlap, fp16=not args.fp32) + + job_started = None + n_progress = 0 + cancel_sent = False + rc = 0 + conn.settimeout(0.2) + buf = "" + while pending: + if args.cancel_after and job_started and not cancel_sent and time.monotonic() - job_started > args.cancel_after: + send(type="cancel", id=pending[0]) + cancel_sent = True + print("\n-> cancel sent") + try: + chunk = conn.recv(65536).decode() + except socket.timeout: + continue + if not chunk: + print("worker exited unexpectedly") + rc = 1 + break + buf += chunk + while "\n" in buf: + line, buf = buf.split("\n", 1) + msg = json.loads(line) + t = msg["type"] + el = time.monotonic() - t0 + if t == "hello": + print(f"[{el:6.1f}s] hello torch={msg['torch']} hip={msg['hip']} devices={msg['devices']}") + elif t == "progress": + n_progress += 1 + job_started = job_started or time.monotonic() + print(f"\r[{el:6.1f}s] {msg['id']} {msg['stage']:<20} {msg['pct'] * 100:5.1f}%", end="", flush=True) + elif t == "done": + dur = time.monotonic() - job_started + print(f"\n[{el:6.1f}s] done {msg['id']} in {dur:.1f}s ({msg['duration'] / dur:.1f}x realtime) " + f"on {msg['device']}, {n_progress} progress msgs ({n_progress / dur:.1f}/s)") + for s in msg["stems"]: + print(" ", s["name"], s["path"]) + pending.remove(msg["id"]) + job_started, n_progress = None, 0 + elif t in ("error", "cancelled"): + print(f"\n[{el:6.1f}s] {t} {msg}") + pending.remove(msg["id"]) + job_started, n_progress = None, 0 + rc = rc or (1 if t == "error" else 0) + send(type="quit") + proc.wait(timeout=10) + sys.exit(rc) + + +if __name__ == "__main__": + main() diff --git a/stemroller/worker_client.py b/stemroller/worker_client.py new file mode 100644 index 0000000..b118041 --- /dev/null +++ b/stemroller/worker_client.py @@ -0,0 +1,112 @@ +"""UI-side owner of the separation worker process and its socket.""" + +import json +import os +import sys + +from PySide6.QtCore import QObject, QProcess, QProcessEnvironment, QTimer, Signal +from PySide6.QtNetwork import QLocalServer, QLocalSocket + + +class WorkerClient(QObject): + stateChanged = Signal(str) # starting | ready | crashed + hello = Signal(dict) + vram = Signal(str, int, int) # device, free_mb, total_mb + progress = Signal(str, float, str) # id, pct, stage + done = Signal(str, dict) + failed = Signal(str, str) # id, message + cancelled = Signal(str) + crashed = Signal() + + def __init__(self, parent=None): + super().__init__(parent) + runtime = os.environ.get("XDG_RUNTIME_DIR") or "/tmp" + self._sock_path = os.path.join(runtime, f"stemroller-{os.getpid()}.sock") + QLocalServer.removeServer(self._sock_path) + self._server = QLocalServer(self) + self._server.newConnection.connect(self._on_connection) + if not self._server.listen(self._sock_path): + raise RuntimeError(f"cannot listen on {self._sock_path}: {self._server.errorString()}") + self._sock: QLocalSocket | None = None + self._buf = b"" + self._proc: QProcess | None = None + self._quitting = False + self.state = "starting" + self._restart_delay = 500 + + def start(self): + self._set_state("starting") + proc = QProcess(self) + env = QProcessEnvironment.systemEnvironment() + pkg_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + env.insert("PYTHONPATH", pkg_root + os.pathsep + env.value("PYTHONPATH", "")) + env.insert("PYTHONUNBUFFERED", "1") + proc.setProcessEnvironment(env) + proc.setProcessChannelMode(QProcess.ProcessChannelMode.ForwardedChannels) + proc.finished.connect(self._on_finished) + proc.start(sys.executable, ["-m", "stemroller.worker", "--socket", self._sock_path]) + self._proc = proc + + def send(self, type_, **payload): + if self._sock and self._sock.state() == QLocalSocket.LocalSocketState.ConnectedState: + self._sock.write((json.dumps({"type": type_, **payload}) + "\n").encode()) + self._sock.flush() + return True + return False + + def pid(self): + return int(self._proc.processId()) if self._proc else 0 + + def shutdown(self): + self._quitting = True + self.send("quit") + if self._proc and self._proc.state() != QProcess.ProcessState.NotRunning: + if not self._proc.waitForFinished(1500): + self._proc.kill() + self._proc.waitForFinished(1000) + self._server.close() + + def _set_state(self, s): + self.state = s + self.stateChanged.emit(s) + + def _on_connection(self): + sock = self._server.nextPendingConnection() + if self._sock: + self._sock.deleteLater() + self._sock = sock + self._buf = b"" + sock.readyRead.connect(self._on_ready_read) + + def _on_ready_read(self): + self._buf += bytes(self._sock.readAll()) + while b"\n" in self._buf: + line, self._buf = self._buf.split(b"\n", 1) + if line.strip(): + self._dispatch(json.loads(line)) + + def _dispatch(self, msg): + t = msg.pop("type") + if t == "hello": + self._restart_delay = 500 + self._set_state("ready") + self.hello.emit(msg) + elif t == "vram": + self.vram.emit(msg["device"], msg["free_mb"], msg["total_mb"]) + elif t == "progress": + self.progress.emit(msg["id"], msg["pct"], msg["stage"]) + elif t == "done": + self.done.emit(msg.pop("id"), msg) + elif t == "error": + self.failed.emit(msg.get("id") or "", msg.get("msg", "unknown error")) + elif t == "cancelled": + self.cancelled.emit(msg["id"]) + + def _on_finished(self, code, status): + self._sock = None + if self._quitting: + return + self._set_state("crashed") + self.crashed.emit() + QTimer.singleShot(self._restart_delay, self.start) + self._restart_delay = min(self._restart_delay * 2, 10000) diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..7a80afd --- /dev/null +++ b/uv.lock @@ -0,0 +1,939 @@ +version = 1 +revision = 5 +requires-python = "==3.12.*" +resolution-markers = [ + "platform_machine == 'x86_64' and sys_platform == 'linux'", +] +supported-markers = [ + "platform_machine == 'x86_64' and sys_platform == 'linux'", +] + +[manifest] +overrides = [{ name = "torchaudio", marker = "sys_platform == 'never'" }] + +[[package]] +name = "absl-py" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/4f/d79676ab82f2e42fc3611618139f13a9c4c31d0cff4b486982047679a802/absl_py-2.5.0.tar.gz", hash = "sha256:0c996f25c0490700fadabe6351630f6111534fa0ae252cc6d2014ea3b141135f", size = 118119, upload-time = "2026-07-03T10:57:48.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/0a/a10b45aab35b175aded078a462dc8d0c698f5b13946e7cb0869097b78bb6/absl_py-2.5.0-py3-none-any.whl", hash = "sha256:0f17b89f2a4eaaedc4f28c622998aa690564b3012a396a4ffad0821007fe03ba", size = 137410, upload-time = "2026-07-03T10:57:46.735Z" }, +] + +[[package]] +name = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "audio-separator" +version = "0.47.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beartype" }, + { name = "diffq" }, + { name = "einops" }, + { name = "julius" }, + { name = "librosa" }, + { name = "ml-collections" }, + { name = "numpy" }, + { name = "onnx-weekly" }, + { name = "onnx2torch-py313" }, + { name = "packaging" }, + { name = "pydub" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "resampy" }, + { name = "rotary-embedding-torch" }, + { name = "samplerate" }, + { name = "scipy" }, + { name = "six" }, + { name = "soundfile" }, + { name = "torch" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/91/349d3d5ce762ed9cdc4b8eb41094a0ba365e199e930240c45962dc1b568f/audio_separator-0.47.0.tar.gz", hash = "sha256:08ec182cdd856fe7b70e0ec18a625fb49cde35be102203a6d0b12da6abfcbc35", size = 365635, upload-time = "2026-08-27T02:15:31.893Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/ba/24b4a5d2147acf35012758c3de7d910399a55a8a4aa74f7a039af530a00d/audio_separator-0.47.0-py3-none-any.whl", hash = "sha256:756f3b620d78e581a117c6b6d96fe4f0eafc3432ab2824cb11532b4868bfd9a8", size = 433592, upload-time = "2026-08-27T02:15:30.181Z" }, +] + +[package.optional-dependencies] +cpu = [ + { name = "onnxruntime" }, +] + +[[package]] +name = "audioread" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/4a/874ecf9b472f998130c2b5e145dcdb9f6131e84786111489103b66772143/audioread-3.1.0.tar.gz", hash = "sha256:1c4ab2f2972764c896a8ac61ac53e261c8d29f0c6ccd652f84e18f08a4cab190", size = 20082, upload-time = "2025-10-26T19:44:13.484Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/16/fbe8e1e185a45042f7cd3a282def5bb8d95bb69ab9e9ef6a5368aa17e426/audioread-3.1.0-py3-none-any.whl", hash = "sha256:b30d1df6c5d3de5dcef0fb0e256f6ea17bdcf5f979408df0297d8a408e2971b4", size = 23143, upload-time = "2025-10-26T19:44:12.016Z" }, +] + +[[package]] +name = "beartype" +version = "0.18.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/15/4e623478a9628ad4cee2391f19aba0b16c1dd6fedcb2a399f0928097b597/beartype-0.18.5.tar.gz", hash = "sha256:264ddc2f1da9ec94ff639141fbe33d22e12a9f75aa863b83b7046ffff1381927", size = 1193506, upload-time = "2024-04-21T07:25:58.64Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/43/7a1259741bd989723272ac7d381a43be932422abcff09a1d9f7ba212cb74/beartype-0.18.5-py3-none-any.whl", hash = "sha256:5301a14f2a9a5540fe47ec6d34d758e9cd8331d36c4760fc7a5499ab86310089", size = 917762, upload-time = "2024-04-21T07:25:55.758Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" }, + { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, +] + +[[package]] +name = "cython" +version = "3.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/d8/4981ef716ad0e3ff0d3ef383aefc6b03c4a88dee33b272bf8e0d833001ca/cython-3.3.0.tar.gz", hash = "sha256:eed0d93fbca7087f143b42c34b05a825849bdf17f101572c2105acfa49aa88b8", size = 3727515, upload-time = "2026-08-22T05:16:39.493Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/4e/6b1c5a4e6bbe1726104de007aa2fdf01a3e2e386b4ec93c7be5f5085d53f/cython-3.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:428fafed98ea26927000a287b4dfc9ef07339f56656a5329a34eaa593f79a4f8", size = 3412225, upload-time = "2026-08-22T05:17:12.281Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e8/aa7b4f3a28d6e8117c76e2cf78a0df7a503486cdf7243c5b53200c9533a1/cython-3.3.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:311a016369adfd1e0015c4f9819168fc0e518451d7efb4435c30d65a3a26d52b", size = 3265110, upload-time = "2026-08-22T05:17:52.577Z" }, + { url = "https://files.pythonhosted.org/packages/bf/77/67b0b24e45073a699610e50f00c18474ff9b09ea29ecc95083bdf5e60acd/cython-3.3.0-py3-none-any.whl", hash = "sha256:9b24b5c8cd536946b62086fcafee6d5509d3f549f72d553d2336af87ffbe0da1", size = 1349151, upload-time = "2026-08-22T05:16:36.741Z" }, +] + +[[package]] +name = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[package]] +name = "demucs" +version = "4.1.0" +source = { git = "https://github.com/adefossez/demucs#2883f3db65617d6d178c6ed10d869dc14e44e59b" } +dependencies = [ + { name = "einops" }, + { name = "huggingface-hub" }, + { name = "julius" }, + { name = "lameenc" }, + { name = "pyyaml" }, + { name = "safetensors" }, + { name = "sphn" }, + { name = "torch" }, + { name = "tqdm" }, +] + +[[package]] +name = "diffq" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cython" }, + { name = "numpy" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/fd/4c58807bf855c5929ffa6da55f26dd6b9ae462a4193f5e09cc49fbbfd451/diffq-0.2.4.tar.gz", hash = "sha256:049064861e974ebf00d0badab8b324c775037371419eda3150985b9d477b5bd2", size = 157139, upload-time = "2023-05-05T12:39:43.089Z" } + +[[package]] +name = "einops" +version = "0.8.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" }, +] + +[[package]] +name = "filelock" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/e4/34efcb869715cf299e47d1ac7b2624d2bcb6f2d3dffc2f0abe8417f65ab2/filelock-4.0.12.tar.gz", hash = "sha256:cf42711a7ac791818b299fab0332a088c65aeeefa36290de98db92c434303b0c", size = 253880, upload-time = "2026-10-05T13:17:43.677Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/a1/b047e1c486a2c66283633b7dbb73872ca16ca1ce6a426f70d4d037fc8e1c/filelock-4.0.12-py3-none-any.whl", hash = "sha256:5f17ee83ecee8a6f3e389c75822fb70a1c2f0506b99438a6dffa1d56793588c8", size = 111732, upload-time = "2026-10-05T13:17:42.361Z" }, +] + +[[package]] +name = "flatbuffers" +version = "25.12.19" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/cd/9be253869fc42e764de7f3dedd6969af7d44ff9c3375214a3442a6f3fc08/fsspec-2026.9.0.tar.gz", hash = "sha256:0f08147951c8cb31d844c3547d631053b127863b60be04cf06e121333ee0e2fe", size = 333545, upload-time = "2026-09-18T17:50:42.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/c0/a98505f18594f1bce828bb159cec0fcf9860562f1a2c85913409fc8f3d9e/fsspec-2026.9.0-py3-none-any.whl", hash = "sha256:8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f", size = 221738, upload-time = "2026-09-18T17:50:41.341Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/27/06d899ea7bd721d272f84aac98bdb238de98af4cc767a69056d967d68c71/hf_xet-1.7.0.tar.gz", hash = "sha256:d406ec79053c0871817f700c2ac8c36ba0d87f9c34b7458b0f0063bb218b0466", size = 985689, upload-time = "2026-10-06T20:18:43.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/4c/2bf3b66c215d409655f28de1622393dde04c9461280d48c7924bb3b2decd/hf_xet-1.7.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2814a6e999d13464c4d679b788cc5d784eb5a4edfc638a31f10e9a11ab531ef8", size = 4212180, upload-time = "2026-10-06T20:18:32.292Z" }, + { url = "https://files.pythonhosted.org/packages/6c/dc/03a21b89f118664a0926ff25b0f8e44a519bf22724a6a8fc7a9abbc188b6/hf_xet-1.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0a9e802f33bf50c851abe45fc5380e61f959e2d369647d6742b79ad9d6c27cab", size = 4418814, upload-time = "2026-10-06T20:18:37.888Z" }, +] + +[[package]] +name = "httpcore2" +version = "2.13.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "h11" }, + { name = "truststore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/f3/1db7aa2bc2524062192bb0e0323969492d1883152a232fe36eea65f4e35c/httpcore2-2.13.1.tar.gz", hash = "sha256:e0aa977abe17e69a3b820a24542a6fa88702676d83880b8d194dcd18408e5103", size = 68071, upload-time = "2026-09-23T07:47:22.372Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/ba/a4568248771ce81957bfb7cc600264a40fbcda092391ee1c415c50be4bea/httpcore2-2.13.1-py3-none-any.whl", hash = "sha256:e1e05d4f25f7d7d496bfb96748f6f4b67657b03da069b3a68c36069f3db73d0a", size = 83423, upload-time = "2026-09-23T07:47:19.365Z" }, +] + +[[package]] +name = "httpx2" +version = "2.13.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "httpcore2" }, + { name = "idna" }, + { name = "truststore" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d5/44/474bef2a0e9d90f1715d32cb98b0738695ca17ba324095fb2497ed7fbd59/httpx2-2.13.1.tar.gz", hash = "sha256:e48744a19e3af5ee48313d0ce5fe941d5422fae5705ea922a4aabf94d7800dfa", size = 100405, upload-time = "2026-09-23T07:47:23.052Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d8/9c/6fe8931fd9f381042a9e4c7d5a7b4cbf7016b252bec0c99a49fce42c3326/httpx2-2.13.1-py3-none-any.whl", hash = "sha256:6dff50fabc270ee5fd25d845d0b078ed20564579744d6d962850975996d2f9a4", size = 95597, upload-time = "2026-09-23T07:47:20.995Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet" }, + { name = "httpx2" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/58/542f21ca4af36c79b157280abc1874cd0d8dedd45a8a3554759a859abe02/huggingface_hub-2.1.1.tar.gz", hash = "sha256:c56285bb7047ff1fe510f23be0705934fb3fd43afda75543341e6574a7e79630", size = 1037212, upload-time = "2026-10-01T12:32:34.793Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/23/885b3a3b510c305f1d84421913935e19b6a48b93d173a0541674c1e88c2a/huggingface_hub-2.1.1-py3-none-any.whl", hash = "sha256:d76fa1d8e6a59e01f012b1d88da604c099c7a0f2e26b1cc7d708f0a4283bd2a2", size = 838033, upload-time = "2026-10-01T12:32:32.91Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "joblib" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cloudpickle" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d5/1d/537ab090f302b838943a1b56497dd53059b9a9b46a074936470173a2e207/joblib-1.6.0.tar.gz", hash = "sha256:2ccc96785b12046c08fd6d55839c12857831b54a3c1673ffadd2f04bfc4eda03", size = 327903, upload-time = "2026-08-31T09:39:04.122Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/53/84099323c2ec4be98d935f63c033ac4151ee83836ca1050ede3b3aadf155/joblib-1.6.0-py3-none-any.whl", hash = "sha256:3dbbf9f6e4b592a2357b854608e980fe6390d131d7a82f011a377ef2ebef7aba", size = 306115, upload-time = "2026-08-31T09:39:02.298Z" }, +] + +[[package]] +name = "julius" +version = "0.2.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/c6/5c2aea2b11ead1680bb5b17c996def31f8ccade471cada37cdb93855e06f/julius-0.2.8.tar.gz", hash = "sha256:d691e651200930affea4f6c849c26e95fec846087281ae3d1a7757eac90253d5", size = 48081, upload-time = "2026-06-03T16:05:34.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/43/efdb0bcb07c47826fa55857cec0deb743f74cd83b6ba5ec9e413505a72e6/julius-0.2.8-py3-none-any.whl", hash = "sha256:6891235cbc355e629d839f87489bff8ca46e57a0e7cc35abb909c7a2aa538c25", size = 21819, upload-time = "2026-06-03T16:05:33.443Z" }, +] + +[[package]] +name = "lameenc" +version = "1.8.4" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/98/ced7da98fb0c149e80d3a5a97546b5abcec6a06f4187cc8842a737107487/lameenc-1.8.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00d619c0a617f66feccbbd2fa9ed3857958ea503f9fe0038cb8b1d950b8b6452", size = 247546, upload-time = "2026-06-27T14:58:55.928Z" }, + { url = "https://files.pythonhosted.org/packages/48/03/1d153252a5aa9093a461b3d013b1e8d383806f6c8c59c7f65c6928197aaa/lameenc-1.8.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_34_x86_64.whl", hash = "sha256:18ba38c49759e217dd6fecf56ef92eab2a24f0a0d87ae4c3564ce4748d75b166", size = 247480, upload-time = "2026-06-27T15:02:59.079Z" }, +] + +[[package]] +name = "lazy-loader" +version = "0.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", hash = "sha256:2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167", size = 18438, upload-time = "2026-09-21T21:31:32.982Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", hash = "sha256:77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056", size = 8791, upload-time = "2026-09-21T21:31:31.632Z" }, +] + +[[package]] +name = "librosa" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "decorator" }, + { name = "joblib" }, + { name = "lazy-loader" }, + { name = "msgpack" }, + { name = "numba" }, + { name = "numpy" }, + { name = "pooch" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "soundfile" }, + { name = "soxr" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8e/c1/ce66b20953b7370421dd13d22b4e04e401346c824ceacb9f4e722eec84dc/librosa-1.0.0.tar.gz", hash = "sha256:73ed480d4022e436e85dfa6f6b06ff38a259b9210039ac99939cd64854b61a57", size = 377965, upload-time = "2026-08-11T15:37:37.013Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/14/0b2e4cc8017796dc8f69de740708601832c1e8d5377166eedb4db0a92264/librosa-1.0.0-py3-none-any.whl", hash = "sha256:5910a6c0e1b2e494b92758c1615a7acbd0515a2315e138927ba2982f2af88857", size = 294628, upload-time = "2026-08-11T15:37:35.455Z" }, +] + +[[package]] +name = "llvmlite" +version = "0.50.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", hash = "sha256:f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4", size = 194522, upload-time = "2026-09-29T18:44:46.782Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/72/22b6449e15bec4cc86c62b659e6c625ab777d01e87aaec717ecef440f87a/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d501e5103076b9a14be885d2574dc2f6793171aa54a853d1244e011d476f1399", size = 59696588, upload-time = "2026-09-29T18:43:04.763Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/9b/e422a865e1d5d57d0e509b4e0bf1c1a70a7f6382c29a5aa428df994c8bc8/markupsafe-3.0.4.tar.gz", hash = "sha256:2e9ad7dd851bf45fab9f75cbff4cb493fee9979e8d8c7c9c3ee119022518edd6", size = 153777, upload-time = "2026-10-02T23:07:22.29Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/a7/aeedb5140afa41fc74c225e9184ab96723a6e873b6ee1c9fede7283456d8/markupsafe-3.0.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e124f974786f831d6043728e38296969d3579db8896fe004682f5758e613581", size = 22985, upload-time = "2026-10-02T23:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/0c/fe/fb1e79be0fea60aa32602ebefc9c35a82bb42b4df157285ab7dfec12341a/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c9a7f43c0b202b334cc9184af09bb8f21d3a209e038efaf106936fb69e6b026e", size = 23048, upload-time = "2026-10-02T23:05:04.479Z" }, +] + +[[package]] +name = "ml-collections" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b8/f8/1a9ae6696dbb6bc9c44ddf5c5e84710d77fe9a35a57e8a06722e1836a4a6/ml_collections-1.1.0.tar.gz", hash = "sha256:0ac1ac6511b9f1566863e0bb0afad0c64e906ea278ad3f4d2144a55322671f6f", size = 61356, upload-time = "2025-04-17T08:25:02.247Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/8a/18d4ff2c7bd83f30d6924bd4ad97abf418488c3f908dea228d6f0961ad68/ml_collections-1.1.0-py3-none-any.whl", hash = "sha256:23b6fa4772aac1ae745a96044b925a5746145a70734f087eaca6626e92c05cbc", size = 76707, upload-time = "2025-04-17T08:24:59.038Z" }, +] + +[[package]] +name = "ml-dtypes" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/72/307d7c4bd0600601c7133fba5cb78af7db968152951c1cd473abb1cda782/ml_dtypes-0.6.0.tar.gz", hash = "sha256:5e60251d32ced5598972e4d5e06a2f044341f9291402551a3f6f0ec44f9299b0", size = 3032327, upload-time = "2026-08-13T14:14:40.215Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/f9/7d76c1eae866f5d4636401b31b6d6dd90e4b4ced1fa7cfdfcca9c60e4bd3/ml_dtypes-0.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b4a480aa8fd54a1805b8ac10f3f91763926a74f73c0c364c10f9231854f4170", size = 409890, upload-time = "2026-08-13T14:14:04.248Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "msgpack" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/e7/bb605a7bab2d8425a64b3fa762b39dc1bf1c7e3f11ba6fb5413d6db0ff8c/msgpack-1.2.3.tar.gz", hash = "sha256:32edb81a2b5eb7cd7c9d941b2bfbbb082fd2cd09e0e725930316af6b708db186", size = 196517, upload-time = "2026-09-29T02:33:52.276Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/cf/9c2e4d6c179529d5bf4a64cff76fa581486569e9fbdd35bd98f51cb624bf/msgpack-1.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede33b2892ceb976283e009ad12fa1834cfdf1f9c43ee9c97849fc588d00a618", size = 472998, upload-time = "2026-09-29T02:32:06.69Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/ce191fb87e2650d0166b34c437e499ee4a7f9db9c1eb164f41725eb6160e/msgpack-1.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eaf7e82249837e3aa97297b34a0bb9ff562027381631e057cea6e1367f10b438", size = 469003, upload-time = "2026-09-29T02:32:13.663Z" }, +] + +[[package]] +name = "narwhals" +version = "2.26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/68/5351e34623d253423240ea7de3f8fc74fa8ab14b1ab3c0ec4ac8997413c9/narwhals-2.26.0.tar.gz", hash = "sha256:6b9cadca82f375c7e4cf584fdc86ca25da54827307a9c58f94547ee6104b82dd", size = 686970, upload-time = "2026-09-08T13:32:08.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b5/1b84b2c784db76d69442334bc8b8748c840f13ca53be086f4f250ad4a0bc/narwhals-2.26.0-py3-none-any.whl", hash = "sha256:29326d74f107c347fd1009bd58e38d9f7c7c5b51e6de97bc93dbc325d9038b54", size = 474034, upload-time = "2026-09-08T13:32:07.159Z" }, +] + +[[package]] +name = "networkx" +version = "3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/76/3af777226b63a5e64a6b36b1ec5855c14e2b94a37096d4760e595fc43511/networkx-3.7.tar.gz", hash = "sha256:fd77a511bd90f39f3d016351345b52cf5319b813bdca01de3f755d3cca62e96a", size = 1866482, upload-time = "2026-09-21T16:45:16.974Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/cd/fe58041e9011f307c490e3e17dd48cc516448f7c698a3f2d9d9d65d7e6a8/networkx-3.7-py3-none-any.whl", hash = "sha256:e3fd2c13a7814cee3746340d8d7f8598a67f16a58bf47fb7f8793fab6efca1b0", size = 2142205, upload-time = "2026-09-21T16:45:14.609Z" }, +] + +[[package]] +name = "numba" +version = "0.68.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/cd/e8280f9ffa30fea9fabc5341223701231fcc5d53a31f51419d42d4bec3a6/numba-0.68.0.tar.gz", hash = "sha256:8a781de54b980b98f43bff7f1093701b5f07c80d031c7cfa8a87493d8bf73f2d", size = 2855363, upload-time = "2026-09-30T15:05:44.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/40/2211b4ff48cccfb21d4c38fb56788d7a975189883efb8d549be9d51aba7d/numba-0.68.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51fe913a70fe9a7a0b193757ff977a9e96c82ae936ae388aec8990814fffdf9d", size = 3888027, upload-time = "2026-09-30T15:04:57.698Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" }, +] + +[[package]] +name = "onnx-weekly" +version = "1.24.0.dev20261005" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "protobuf" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/0a/9ec51b427873ff93789a047976c81d5038f40f609ebc5def5cd03d290cd5/onnx_weekly-1.24.0.dev20261005.tar.gz", hash = "sha256:52f04c2cd104864f55746748f643d6897862b9c4a9d63051403de48c085a8ceb", size = 6043577, upload-time = "2026-10-05T00:55:21.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/d3/4f2d6d63ca219123a59b510ed7e86a78c2ce6fcd6bb16fb0e8bdbb95c1a8/onnx_weekly-1.24.0.dev20261005-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d408c6a7a0cc726d6acf5e192f9eebc92b4be3ee2ce863e6d1dcde5ba7065262", size = 8888994, upload-time = "2026-10-05T00:54:55.518Z" }, + { url = "https://files.pythonhosted.org/packages/8e/cf/6b6b799a18b413d2da53fc33bab748b33b79898908f1cfcdb8d9492690a8/onnx_weekly-1.24.0.dev20261005-cp312-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:904e7fa976bb7cea847373b4f36ed9e809152f5cc004e0eda5f984bd47bec23f", size = 7320795, upload-time = "2026-10-05T00:54:58.016Z" }, +] + +[[package]] +name = "onnx2torch-py313" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "onnx-weekly" }, + { name = "torch" }, + { name = "torchvision" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1e/bb/6301c1ea4c8f8859aff60d2d58a038fd68f9cdb507d1c60776d4e3b93b1f/onnx2torch_py313-1.6.0.tar.gz", hash = "sha256:d27b54c7e170f12ad252fe186e6cab8f3cade8ee4e596682acc5a3afddadb753", size = 49594, upload-time = "2025-04-11T03:52:32.88Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/14/bb49cfba5020c99ec37efcf64bb79f9793c1068992feffa81bcad9e10c92/onnx2torch_py313-1.6.0-py3-none-any.whl", hash = "sha256:03b1cc771f93941cc221635547e97dd7823dffc05f052057e51c6a45fbacba70", size = 81251, upload-time = "2025-04-11T03:52:31.179Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.30.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "flatbuffers" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/35/e7f862dbacbc99fadd9b14a614e49c99bf0f35fd9927a82f096e3de33531/onnxruntime-1.30.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fa688e7891a6aa206636fe7372e27ee75fd17713289f6b4fc7b190e0a7de9328", size = 23585654, upload-time = "2026-09-10T16:31:26.65Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pillow" +version = "12.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.12.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/a1/d5f9002a70298c64a789779077d8dd90c10aa1f47fe40c86802df874f2a6/platformdirs-4.12.4.tar.gz", hash = "sha256:63743c02414e755de4e31b8f68125c1407495b86c5a006e203c01ff8b9924250", size = 60010, upload-time = "2026-10-07T23:30:32.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/ba/223e00b885e960edd5d4b4d178c88acce019bd5b83786093681b8c393492/platformdirs-4.12.4-py3-none-any.whl", hash = "sha256:78bfb9db2a8471ed7eebe3c3c932da413911042994e699b384fbb4493fa872d7", size = 32596, upload-time = "2026-10-07T23:30:30.825Z" }, +] + +[[package]] +name = "pooch" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "platformdirs" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/43/85ef45e8b36c6a48546af7b266592dc32d7f67837a6514d111bced6d7d75/pooch-1.9.0.tar.gz", hash = "sha256:de46729579b9857ffd3e741987a2f6d5e0e03219892c167c6578c0091fb511ed", size = 61788, upload-time = "2026-01-30T19:15:09.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl", hash = "sha256:f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b", size = 67175, upload-time = "2026-01-30T19:15:08.36Z" }, +] + +[[package]] +name = "protobuf" +version = "7.36.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydub" +version = "0.25.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326, upload-time = "2021-03-10T02:09:54.659Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327, upload-time = "2021-03-10T02:09:53.503Z" }, +] + +[[package]] +name = "pyside6" +version = "6.11.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyside6-addons" }, + { name = "pyside6-essentials" }, + { name = "shiboken6" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/fe/968844def58150a41568b505edca0d68df6901b20ea4222ccb0c069cc703/pyside6-6.11.2-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:dc6d03990489a5085842770718392ef5de36352d8f608d9a9fe03e60af4d7b66", size = 572120, upload-time = "2026-08-18T06:37:30.298Z" }, +] + +[[package]] +name = "pyside6-addons" +version = "6.11.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyside6-essentials" }, + { name = "shiboken6" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/cd/ce470e20f68901f4dfa5f742d6a3a58ba865684a232e4b87d5a1a2179cc0/pyside6_addons-6.11.2-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a8b00956925fbdeffc7052cf933506391289f35ac4f3f71a0a167ec195cd47b4", size = 175062576, upload-time = "2026-08-18T06:35:45.583Z" }, +] + +[[package]] +name = "pyside6-essentials" +version = "6.11.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "shiboken6" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/1a/84a84bbc75835ee88abdcb66eb875b8e1a21834af9b833bc1893f2c1bfaf/pyside6_essentials-6.11.2-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:aaf9f25f0f324874085fa5b26a610318db8a8e243cf85bb3e5400595191c7778", size = 80108947, upload-time = "2026-08-18T06:36:40.637Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "resampy" +version = "0.4.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numba" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/29/f1/34be702a69a5d272e844c98cee82351f880985cfbca0cc86378011078497/resampy-0.4.3.tar.gz", hash = "sha256:a0d1c28398f0e55994b739650afef4e3974115edbe96cd4bb81968425e916e47", size = 3080604, upload-time = "2024-03-05T20:36:08.119Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/b9/3b00ac340a1aab3389ebcc52c779914a44aadf7b0cb7a3bf053195735607/resampy-0.4.3-py3-none-any.whl", hash = "sha256:ad2ed64516b140a122d96704e32bc0f92b23f45419e8b8f478e5a05f83edcebd", size = 3076529, upload-time = "2024-03-05T20:36:02.439Z" }, +] + +[[package]] +name = "rotary-embedding-torch" +version = "0.6.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "einops" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/7e/8dbb4a950a99ec2f459ec1eb73818c519b56a1fee8a9a98f7a57460a0d5a/rotary_embedding_torch-0.6.5.tar.gz", hash = "sha256:a3623274c559e0215922edc7cd14068d5a64dea1ca469e1ecd642b293ee8af78", size = 7114, upload-time = "2024-08-20T20:52:44.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/1a/d78ef65d18ed5b9b8d04e68c69ef393adecc36f189186e250089ed432d7d/rotary_embedding_torch-0.6.5-py3-none-any.whl", hash = "sha256:96c0b27b688820cbde652dd7869cf035b4f653eee53ddaf78133cf7cdd4aab19", size = 5454, upload-time = "2024-08-20T20:52:43.266Z" }, +] + +[[package]] +name = "safetensors" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" }, + { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" }, +] + +[[package]] +name = "samplerate" +version = "0.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/9c/6a13fbc59b1ceaef194a53d3aeafa983057133fb13660c423854184eafa7/samplerate-0.1.0.tar.gz", hash = "sha256:75ef725e6cd9c4545569caf4c47147beab7b53b2c36e5122e8c285d348f88847", size = 4044998, upload-time = "2017-02-24T00:01:56.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/3c/4c1aa376332d18e708dcc3289e4dbdd2c508bcac1b8eb1b35b73092fa00f/samplerate-0.1.0-py2.py3-none-any.whl", hash = "sha256:f55e5c9d0a8ba3c82a53b7d9c34a2d145439c61166a7f310efaec88f2781b8f8", size = 4028658, upload-time = "2017-02-24T00:01:44.947Z" }, +] + +[[package]] +name = "scikit-learn" +version = "1.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "narwhals" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/eb/eaf5e07fcc0da7149b0e084f24e54edd7441b9a89ce7e034032ae97fe3a0/scikit_learn-1.9.1.tar.gz", hash = "sha256:629cada3e33e2b9bf376cdc7614a47a4140b8aedc1d836579e359736fbd82977", size = 7786908, upload-time = "2026-09-10T18:34:04.679Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/57/a50162f3d29feb979ab6347c6debda506dfb525bcff3c50dd17606651c7e/scikit_learn-1.9.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5d7b18a5b9dca241a74695f3275fa4c895a9dadc72b3d8df5fa9d1083c9b83e", size = 9166043, upload-time = "2026-09-10T18:32:49.343Z" }, +] + +[[package]] +name = "scipy" +version = "1.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/64/ff35eb9e54894cf471ff4716abd3c81eb0a0626869217ce3e6ba4ccf17d7/scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f55fa87b6c612ecd6b058f167c53231b1d14e412efe361d3d6e38b3631c73218", size = 35344199, upload-time = "2026-08-21T23:24:07.844Z" }, + { url = "https://files.pythonhosted.org/packages/91/4c/075e4f66471bac101141ac739e9e135549be1bae584571bd03a530c056e1/scipy-1.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2924a03db38dc2e848bca2fe9f077dafb891480b91a00a0963a8cf86dfc31c1", size = 37480330, upload-time = "2026-08-21T23:24:19.608Z" }, +] + +[[package]] +name = "setuptools" +version = "84.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" }, +] + +[[package]] +name = "shiboken6" +version = "6.11.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/9a/f41bea4316d0c1bec4800842dcb4bd8fd3e29d6a79c496bc32e1aec42583/shiboken6-6.11.2-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:7a7a0a72a9ed26c9bf77d42246b1c736486befb8f31aa2fb29957ea4cdd1c1c2", size = 272435, upload-time = "2026-08-18T06:37:13.397Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sounddevice" +version = "0.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ec/db/0c890e2d9aab9ba284021efc02e1d3aebfecab1b611762d7434602209bcf/sounddevice-0.5.6.tar.gz", hash = "sha256:8ec9fbfde2e32f020b167e348f3ab3bac6625a5f15af524d790108ac7147a410", size = 1120094, upload-time = "2026-08-17T07:55:05.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/1f/62eef605172bddc1017508469a12f75bc7c4194ece35c734f822795f53b1/sounddevice-0.5.6-py3-none-any.whl", hash = "sha256:de099612311ad81e55d31ccbd83f43ea6bf4d87b48f9b6ea55a1fbcde0eee4e0", size = 32793, upload-time = "2026-08-17T07:54:57.507Z" }, +] + +[[package]] +name = "soundfile" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, + { name = "numpy" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", hash = "sha256:ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11", size = 47842, upload-time = "2026-06-06T08:58:47.869Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/d1/5e338af9ca6ed0786cd5bb03f6d60de1c325728c1189014f3b59aae7403c/soundfile-0.14.0-py2.py3-none-any.whl", hash = "sha256:8ba81ae3a89fd5ab3bef8a8eb481fbbe794e806309675a89b4df48b8d31908a8", size = 26799, upload-time = "2026-06-06T08:58:33.269Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a2/70fd4432b924684c372df8b0a45708c36c057ef3596c9eb53e0a806b980b/soundfile-0.14.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:1e38bac1853412871318e82a1ba69a8be677619b56025bbfcccdb41b6cafe82d", size = 1315963, upload-time = "2026-06-06T08:58:41.716Z" }, +] + +[[package]] +name = "soxr" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", hash = "sha256:9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44", size = 173067, upload-time = "2026-05-03T00:15:18.214Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1", size = 240413, upload-time = "2026-05-03T00:14:59.363Z" }, +] + +[[package]] +name = "sphn" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/94/0957f866030d6071bcfd285977ff3652bacf85e663a634d3172cf47055a7/sphn-0.2.1.tar.gz", hash = "sha256:3b19b1fece67d979d84080458bed545d1f55ddc5abac6ca5deae2672a184c7fe", size = 33477, upload-time = "2026-01-07T12:00:32.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/ad/7fd6ed543362033671e706b9abecd24ba9cd8ac967a9f420e8d515017b94/sphn-0.2.1-cp312-cp312-manylinux_2_24_x86_64.whl", hash = "sha256:27527d82ae2db9fbd8b7cbd787160e5d8002d385c785d217bd1c6fed32c37b06", size = 18101967, upload-time = "2026-01-07T12:00:14.575Z" }, +] + +[[package]] +name = "stemroller" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "audio-separator", extra = ["cpu"] }, + { name = "audioread" }, + { name = "demucs" }, + { name = "numpy" }, + { name = "pyside6" }, + { name = "sounddevice" }, + { name = "soundfile" }, + { name = "torch" }, + { name = "torchvision" }, + { name = "triton-rocm" }, +] + +[package.metadata] +requires-dist = [ + { name = "audio-separator", extras = ["cpu"], specifier = ">=0.30" }, + { name = "audioread" }, + { name = "demucs", git = "https://github.com/adefossez/demucs" }, + { name = "numpy", specifier = ">=2.0" }, + { name = "pyside6", specifier = ">=6.10" }, + { name = "sounddevice", specifier = ">=0.5" }, + { name = "soundfile", specifier = ">=0.13" }, + { name = "torch", specifier = "==2.14.1", index = "https://download.pytorch.org/whl/rocm7.2" }, + { name = "torchvision", index = "https://download.pytorch.org/whl/rocm7.2" }, + { name = "triton-rocm", index = "https://download.pytorch.org/whl/rocm7.2" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "threadpoolctl" +version = "3.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/dc/6c58154c1c65f758ea979e7139cb76993a9cfc662d14e9be3c4a667cfb77/threadpoolctl-3.7.0.tar.gz", hash = "sha256:61348cfb77d53b9242e0017029244b559b810c142ced65b4e21eeca1843959a7", size = 31961, upload-time = "2026-09-15T15:46:20.263Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/3f/f88a53f60a472b46f4023f56d204dd7de33d34c5d2acbfa0d70a674e639e/threadpoolctl-3.7.0-py3-none-any.whl", hash = "sha256:cd8b60b5641b45c67bbf73c64c843235fc2d8a480c87389f52f5dbee893b86be", size = 26362, upload-time = "2026-09-15T15:46:19.168Z" }, +] + +[[package]] +name = "torch" +version = "2.14.1+rocm7.2" +source = { registry = "https://download.pytorch.org/whl/rocm7.2" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton-rocm" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/rocm7.2/torch-2.14.1%2Brocm7.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fc35e48fd83329f5d60ab925951d138edb5a6fce84323600703637fbc693541c", upload-time = "2026-09-30T21:43:07Z" }, +] + +[[package]] +name = "torchvision" +version = "0.29.1+rocm7.2" +source = { registry = "https://download.pytorch.org/whl/rocm7.2" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, + { name = "torch" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/rocm7.2/torchvision-0.29.1%2Brocm7.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c087dd2da541ea44064d955d993cbe8e8b52db436747cc690d7c6a05ff0cb94b", upload-time = "2026-09-30T15:46:43Z" }, +] + +[[package]] +name = "tqdm" +version = "4.70.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/ea/b2a5bd54b28a324dae8211928b2d730b6547500342c7e6c6dea08bd0a485/tqdm-4.70.1.tar.gz", hash = "sha256:cefd0eca11b2a37a3aee776544d4f4ae913f02688135b5556b8788dfa474afc4", size = 171846, upload-time = "2026-09-11T07:25:16.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/03/921a3d3c75785aca9ebfbfcabfbc3a1be12e2ab5265deb026d55a5a3f83e/tqdm-4.70.1-py3-none-any.whl", hash = "sha256:c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73", size = 80199, upload-time = "2026-09-11T07:25:14.599Z" }, +] + +[[package]] +name = "triton-rocm" +version = "3.8.0" +source = { registry = "https://download.pytorch.org/whl/rocm7.2" } +wheels = [ + { url = "https://download-r2.pytorch.org/whl/triton_rocm-3.8.0-cp312-cp312-linux_x86_64.whl", hash = "sha256:6318e6faa21395632defa13c57fa84fce5c42a79c531159911f227e599422eba", upload-time = "2026-09-02T00:55:39Z" }, +] + +[[package]] +name = "truststore" +version = "0.10.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/a3/1585216310e344e8102c22482f6060c7a6ea0322b63e026372e6dcefcfd6/truststore-0.10.4.tar.gz", hash = "sha256:9d91bd436463ad5e4ee4aba766628dd6cd7010cf3e2461756b3303710eebc301", size = 26169, upload-time = "2025-08-12T18:49:02.73Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +]

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�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 z zx}~_Q?4r3~K;9A)JEqhNS~7dkT=Rt##iji0U0bRB;N8>SnR$3b=Smw6fqnp^{tdub z9?@*b3#v#?>qLZm8p_#X;d$VBLHysbs1H=mhTuG&7ew>oV8Sw>n~^IFG>I$CSO?_= zVIh9?HxxR$*tUSMW!_-br0iF>=iUyJv+!;X> zCa1-YQVRsKjcHjyVd8nzEj^L{XhYvw^)6gUN@~`1;PD9)j}IEvJvcrnt6yrZS_>Pl z%wM~?^SB|MIu6P)!%!bUj>Y$J!j4{%8=M(C`Q*?cCniq$tdYpdgl>*CSIjI<+c0k6 zjJzQuH_#sA9;2(x&mT@7N*5tf158Nlfoy8Jpo5^Xqw2?=CF z4Z6=J;4^^kpJ?O2(LOBOjZ>yL)V&Kub#n>{)vwmR8$#7g|D+@})gSTNx0Po;cfD5)sek12v6u44&AmEK`p#$8fSL_f z=C)8uetmQK>XG9HO{_og`iFt{P7EIH$L@zzIKV&llruOXKJ?;tH892I4%{J+D&Vkoj(2b~)0jl>Pe=Hmhq@X}QZ{`ObjxGf4 zaq)9@AcR9PQt~yUmV)L^q_SjTm{>AP`Ab>zU*#;TrkwpjInL@T#}#EAQdYCY4UU)E8fC5*6-EvU$eLo6T5TaG2fz zJrCOwWErp%eXy1p^drAowEs!e71Q`Wd6Q)Wl)PGAQj4l$M3c{zpU)g)k#Ap~dt<`o zJ(hlB*1Y-k+sfZ9vm+b7QCaz!@LwKrBnkQuTts1$J=EAg75ot?{9u;-xG5H(RR51q9Uzs8R30 zfsfae?-iG1EF1lf{Q92a>igfT4C_SB-0!*RPH`pN`uf7RWC zp3%t;*`y^y2V4%JC`}v!;vUv8?4)Slv56ZR=2NZO@sXq)4AEPp~CgS8dzYDD_zV z1}wT{l{GOjaXH|PUHU=grtfT5*9ecLoQge(5*phZpobrIq1Aioy!0bsu@`5;n&zc9 zc%euWlt73SQbwU4NFBgCNDY+GvQEI4ql`w}BjV#tMqfQG3|;6EOc82fNtVi4mMoIT z_|uRSW|qrWS#AE$e+=wD%AbzEvE_eMa9l`d#S!z~R32nXM>BrNGRlJwFFWnW9Pj&y zV;Al_+@$^4BdiI+kw8OT059de8(>921Q$weaO)Ppq8cN(gz7*!Tq1aRIZK0TCPC_? z4Ujm8#orn7Ev3Sbs3($FG)Z24y11C<=(?!H?~9vcqgJvKHL0|sflE*^i& z0yF@f9pfaEQV^uKp~=2TaG4B~pFv^)kiq^8u=oq!KK|Z0LSP_|>ucZ4S8XgA9E57< zXbov(K0Y0Mz);fp2z`o$LcJPm}*49{{q@;iVDTZ_Q7wm01-*M^zZ z_#ghITcLP~!O9~g{DV8UZ{Ha!T3A`fb!o~uM?-P`=ZalCdQNQX*hN3sE^K@z{@4Z> zs1k0HP!2nm4!9=S$7e8apGs-C--u1igh!w?jNUsm61{9u&B0sfk8&C)h#G}%v1mR= zd?~CBAACCX%?Ee?b^&2bNqV-Fn|9J{zU5ZCFUnU>HnX< z)yWKmkUUQX-FpFQ2$2kGSLpzraZEi)KkywJklG!_eFO<^#W1ph!^biELy z{(fje>TM8tY%)G=533A1{pp*RDFbUle3^KX*yJTFMJ7h94!$sugC!Ic5Q+wRL@dEr zYnIuPWJ!ch3l7_oh1_Q0_gGM2?KOSpKAq{@x3#wt40><9!8;e9KpA4W zzBmv*I&U8YOh5#P5CMKz0`GVWDFh8D2j7GoOFadS$E-Jl#UV#5lSgIqN@>6jFtJ6;szZPp8 zK_uSpnEGjw0jxPYqG}mgFCAF&&Jrb(-J>7;D#kg!ryu3qCK(kzw&-*lmSjw8*K}4@ zrAq3c>Qx8R8K)eU^16K7D@mRu3$^VvV?z9JofHzH)e`i);RsQJNc4bEb=1T_&^js} z)14B#j(d6%zFj6HBs9{%YxR3ng?8Q|EyO-twV`#mjakGiN0dh^*RkOJqPO5rHZnB+}3ZtWR`UwNy?V%r-M$i#^2p$%{~r1b;@tr_1R;V1v>8UJgEG+#^)4U zF1HF(?mYcdxf2!m`8MZzYU{@8=Yi9wqhC=Md&jcLO!C%OMM%AORt8j>G7)B|E>uxp zrEVnHN%Bk-fimDIKoy1V#&aH3($01+GA$L4EN9FLFJZ^y@F z^n9&F{l+~z=dGfWIpOBY*;y^>*LQSfDdj6t*aNH zP>%HO5mUlLnZ@^D4R2Ci7`8<|7-;$NpO2)Ay1c*k&Au$<7ClKb$ss9NGwt_S>~{?8 z(db}~o01S00_`I<8qE+uD8LJpI#J5y;SBN=92<4B8SBdH+2gKY4mL)rZ5dv&)!17^ zbGr6gytH5WZS6W{+&6B~!*%Ankw+#>I1+g;Y}LaRuzO=c_af%8HMbYrA%_@+Vf5?2Y~2a%1kKPe$*Xd&w_+b@y^Dr8hp(2er?yw?Aaz z_`o$^kE9Cvk64FeqrO=axM1a!XGiZSf24>r540YR0tLJVCfAF3T#DIwUE-G|l=>sF zL}oqif8)15wB$m0Dl_jH6lw^~3MDF#*K_Vrwry|%})Y_IY5Gat63m37`hmsaMb-jzZ&EtdVW*z_kZCro$TeBG)_!pLUzxto!hi(+@VQ_ z26d}fORSn$HN8@~l(-mJq)hOgC$I#g)^k|B+QU#rAwFbF%S?|$b$rU}Bhd%*BsUC~ zcC;XE3Tz}Z17=_wOoGM`o!j#QgB1k6J5iq%Oxd}$Afyv7ywOm@~#v89gLNr=4 zpB~d|*PPaC{>l}9 ze-KqYA+tg4%(~S>HWcJ-4)7O$^^FeMYqt8I-z|Tr9QvyEx5}|YgX=f$uZ(<2#*XCO za7@AD4RzmsGFvWguK&cHzjGiews!T`Yi8TQl$o%!WV*f&Tp8trgQ{c8zpNEfR|pRU zKPGFv`fr2wZ|uAgJ8ywa3Z|*yWT2jj+qH;LH%g4^(F_SP{D!Bw$>M0DH$1wpoM%t) zm;(P8+UTjzgNEvU9IQ8F(E^)?LCb0iP6)A*MT;3UuMQ3f-yA)a$&|?dL|cO2od?{U zC2wq*+%u!c+HT*y(Iu__@Nc(&%=&uuYtgZw@IQXB>jpI#k&>+w&W1&`KfK6MQT(z+ z*W_t~9rakO(pwtdtKIC0jxKWdck7NyFaKZC%ie{gO@>|B9}33sCi@bBlq4kIz_vy9 zUEHU1u?tW}PN(ayC*tWQ* z_`Bm$t4`v5hk5@IpcFK)7)+ug))FDa*`q^EUdRw4Qv+Rw0VZz>gr+{c^tZ(dJ9HB8 z3Z)UjXEqZ*L}Bnt>N?(JY}KS6Cax)DQ@>yO!;0IJ4qkqm=;$TBW&8W{g9pyAq{9(^ zJdQl9d~=51;qQCV{nG|?(H%aA$9FRU)rWLc8#|Ts9h)__jLZzFRPzxMqbcr;4F10X z5Gz1`57O3E)sNrgJIKw;rkLWxjm9KXe2@>3htFDI3rF6kC>Z8{@fJ3MLg2n-!wQ8ac zIMm`OLu|zbelcIkW+y6lzCCu+`1HEsiJv~>x_jl$rONYf;Xjr3Pa**U2|37ubDwuMfz$6-WCuv#!?$XpOcGWD4ve7Xx8^lfaJEn?TK zZQ5e%A#uSTv#BeTj@T5Z+2MQ!o|ukosn%9D(A(JBn(ha{2Eiv7HcW4QXDT4p^6xcE z|HJ3}@Y=m=rw*Yw5|NIT6aqvcDF28=SU5l;`Z4(68mNVY+-{Q5wcO-m&Nlt{W95;` z^Dl4`-TJ8V$P$*gcNI~Ig-zd9U8CGoiFEF==iQA)D((K%=_2U1kf?OLYT_^iw2%z= zo%|x?C|jI6$&*l3gSvRb)mca`fA37;~$mqG(gE9U16;kU-E254%*2|BdfA`oK3tb*LC( z7Fzj!tJ27S;rqR0%eO1!e`pU^EI{f)iXEmTk(VI z__K3ImDf(1y5?N<#BmGC$IdxBZrY2J7e3=>>+#a+`B#t_T@+@Z&vcKI4Q$7V2}BlZ z3@GMJ1{{zXrTNDJV?5|?)bZQGUCY+Nwhao{V0JiLVIW*0>6DDKbD&cc2Hb6ixR`mp z^2&YDPKjde&q}}7J6};gVePMopEh){LuD9cqT@)k8z`je`+LIv=HiT_0Twv?gC?s4 zB&LP2nWTGzT9y-$EMPoM57H$;3qvjp*qxwyvuZ^`+VORvP|5^Is!WgXaX=Wp>ceWy zCsx}gE;^XCd`Q3L9d8ekq8gTWv+BHl@bdTO)qL$b;oPhdbB`@8s>|&b+)n)0Rb@oy zsHz9+*2D7yvODmu0^Y%7*Y!e9o|bs)fVWO6!?9b zojIMzOu3PUnFS7k>H+>tKxkmMfNpI)D1|Wshy0kI5q%MXLv(a9ePvely9*Y7y>sxg?2OvHyyZEWOI=g; zGuOAkkCQK#ot-^&rt)RO@QDjQu3P)}rI!cQ738lPn7?|^pf%7M5lrmersXMsZf^`{WW9A`m&N4`&eF#Xl^V(J>KhOLP<1We$xm`Rg+c$6 ztWWfS4+KwOpymxB#w4Q(R^q1X*+8Q%ory}wx)jwVDm2(XEFcVilV(&>ZT8LGOALFi zd3cqJy7zKtDY0hfkIS-F^zzkp zu9GgzDcLj8!OHu^${DA|k3Th|@STVT`rzpTvoPlVOiN? zq8aTk-^$xGUmN+s)(}IcPC_`aftxj$h0vIg$A@7lGt9y!e(-cRu(MfD$xR`=r*kCP zFTmZ@aa_RY?B<9&iCeP6*xFl596xufowWZ9@xkId^AQ6->hi9Vl?}V|R^(+e(A7@n!Lyf;EG3SLcHr3Rb~<$?w)P?42%< z$`KRq=IlfrGetUE*hM|v?Og0#9=(f3gfjO~h6ySvc>RR7NTwh{xe9eisma9=XoQNhiiJd_)vn9sdZ)N90XGbnNjknuMF5;w#$ z(q=ia7dsuBXjOS3=&HQ0hyGmkSfs+I`9Nzd^3P&ykx9`54h~MVqPJdRo3B)+CAKZ) zk>*}vSYk1-mX_GSNW&cJrP^}EC2PN_v--;B@a(FmQ?|}o&L%a~NV}AbEuYL;@lV%L zXBUl|x_D9A!mPt=lik%rN~qPeYjbK|rw|L^Yut+*$WxW9%v=$IP%;_&zhM&+MFe3P zy)z8%P6613$k`W;I#7kc_{6uO8DjFM4cFPd_pV*Lr|v@S?ARqGk#9w4PnE4QK_6Ga zpK@#1;7)H)9@*7kCYgXy$mi)b)SM2O+U`gJ;^XD!@9y6Qi4z0_PMBxvL*s_CXUlYn zrF9P$51Y;g|EP=#9MpCBo71a4SvzOPjyZF8>~Nj`VAGWE4zXVv4m!I{dwccTj}}}! zTvc=MVD*y2L=)hMH7yhCkO@cf6u~+z0$FS_kiSaFRfuaq3)mxYWU8fI#{zLMFil3) z6H^UFEnf54;^Jw_u^-uv_8iAWpRS#|ef!)wJ9lXQ&XIgdu@Q$_LQ)hKfX^uR_y15v z-2xf)8|J}fR1e%0{pYrQ`?lf7m91wJo6D#n%mr=}p~?sN?0e-y@XSnHP5sv7>(cmS8ic=r zP)%dN?|;EjRh?PT^um3RoLcDMq8WjdMg~VKn#x$(oYY%;%~v-Xk0rFg&Au3PmE~TP zzEsyZj0osA74+S}>6iW|JvY%mgVX;A;3|DHc|K(5X$<3+#h-^NYuFy)F4Jk=XngTc zS@jqEQ&#;2QQwlrf3c^TC+Ppl19g1xEQcYc1kWh-N#g^_MLi=(E>w!j2+!af_;wLg zxM29|rr-o$#N!w6(Fw-RN;gey5DqV+&QKKx{{3&L)tP)3IWD{aub%4vT=`mjUfTsY z?ewJQiFi)n&%4}+_Id+6Kqx$ew4FqIHPN^i78KG&L3jc61@1IW2Eh^;=VgCz7lM!| z>#EsDq>mR$>FeA=y|u5CTRoOE9^b7b;&L{p|MSaoRiDF_Z5+ICgwmrSeDqQeW40%kq?mmD7Pc_2mKj z;xCLiV{Jt~UIyH~2|XA(;5Y}a5j0~kq4^Q9gq*zs2x+Jq!Cc0#fOjESQB%r42lj37 z{h`6Zl@=187Gb?;fz4z2v`D#?Q&}g)2rnqt!Avy5=P}7XjcI?t|g3Fo7&sm%ThTH z-rnBdTEJME=q5c7?;w)olyDw|1MYaYTzVj-fIsP7xr%)`um|oZg&=tza?5Bn-|48I zC-6L%KYxFdo=*yW0j~l4hi{ud|Hz+TVb=0QX$|22{EpzSAd+RGJQdIX;?GYDCGrwE z8qYuR@6WJ*$d%%Ac>XtkJ}!)utK|qh|E$7=D7jJ|f#+ZNv)cYdJpam{*9r&Z-O|7D z{2PB>!ByT+bPS4=2)iUlUgnivss8ainK3tXOX`Ipj?{LQ0t@eMn+W!-P&E>G~ z8*jFNofKY2IXjg5q48T`Ih7NSFE`T72>Y=W>=kwxH0X?S|Ag+4wu>33WEd^NhGuu9UI>`*$nYamZZN^1Fcj+zNI^xC?qV0``j$ zCK=m1DZGcVCD^ZkZBqNUN$uZSmL%_%HvsmVv7D(7YeYZL{4`*{1NNj!&nMM#XN6zo zS@K6Xc-Zmt*oek&HSIN@!DiJ}=p(E*T%3SInWzcz^OR%}W-4TkMhd)U@8G{g)+xGW zArLE>;l##IEzFp7>y9T6Nxlp~X+nC_h*!obFr}`1!!yG=Jv9Ham;-2`^0v``s?$CrNu*(#2FcWxJl6M8}nH3({Uj` z9S`OHrD`4voQ|0b4#yJvuBPD|@#`m%hAHmqLz)PpupfKkTbLUXbVkUD0y$m1jFan# zM98DuR~3f_!PZ)K&^X{j$w>=^pbOH>N<8f?=z|6JEytf7%k+79`h@&^_ObL!y{+Op zI6i(b{a_71J8~@A3DImsyE@HA5h^QcU)jvwl4tSuabm)bPFkx`)UHI^*>Ew-QsXY+ zF6ND2a(vHWUP4}8f<8YVDbCQie9_oAno--=CP5Z6w!g*DelGH?kq?d^>`#cFYzHr7 z^~eUJgj_`^lGPd_IgIq626w#(@K?0~fzF+@d+h zj2YyhbTRb^{Q=%qcDz4ZfTT{d1?wsG6YsSev-cb6J?K1Isg(X9Pv-qBK7(%JNQT`w z6q5;8u*0o{VQDn>5qYN#9S0wI>%C1MP)(vLY7i}k%a}rKT9SiQbH=&Boe~VElqk41 zN4juk!5a`we8E7DK`V6@$sulgG&$J2CUOu~G>&hg-;_UR?(;B7!sk&9`-ArdI7&qK z3@%fo<-tNh`9ENfBeyvU?!!gI-Z1kSzlAAE)(Qx_G8HoavQY2VJ^&s#Jo66P^b2(E z;A{=`DT~CkKxCL9tmrS9VPD{RorCk>jMYO1tM7N05^_k2ao)%fmdMJcvQ|GaqhL&Nw!!1z-C5261U(5C)l zt$;t7sRP5C2!Qp_(7~ZR{E_$pL{JNW1R$-^E1!tO6T|a)NuTS3T7Su)>X61XHKomh zdG}Goa&rlEc}!MW+aAPn%2SE;foATtxl6B2T>@gc4B|A%&lgW=8>*T0BZ$S$fmnI; zgJDPaZa}u%30V%Yka`ldkqL(0Bm1MkvOQcyESk8D+8O>uB9fswy99=aHxg&2zmqXJ zree`MRg1;p``K8QHgBi$ta5teYszrtU+=RkYTfy$yA$em6p(|(tZtZAP&vMF6dXOt zsN&Mg*%{Z*i%_pQQ@pD#zhGj|K9e(Ur&lD^E>OOHk@aA<)f;ii#K4_%mFJah`yVLr zcR2pTkkTWiFiUpzk1>b6ka%xRR9;#>|QjK48a`uTN?ooc#R) z;cBc)#Z}ecqThg!4=f#Us7?(`huHjD;z}{(-2TaHe*b;7ZgJ~zaVxJLwX9XXmYjj> z|F`EY$@$)`!Da3I#t*)AZ&C4}nwmkwsvdFPa`QEvw}>{s0eAoZADp);s)}=KYjcaM z?%f<-shL-L^FN)pFox5W3A#y|V?tj9AZ}EXB0C2$8`%vv&&MGoDjp_eIRoA&6kkLT zO$&(WrFGNig@*LXoynihMl0Lkngtz~9rH8kN?y2`adSc@f?tGE@|_+E*-?!y2#4pb zjjXZ3&iLOHCG>ijio&Y_eh#<TMzZ(+4CaG9fi3F)Jx61};{eJB8x%9WPI3M+EElWqs{o*kWXVMhtdO znPSz+^A3hCGm`)WK@XVKNnt>mND&?ivWRS=u&HxTJ(vni(YEfgmlCIVeZY3Gz}qbG z;~DL;*OfZ2ao1|TdxY&bO>poG> zXrJJ$g*imAk@b+Xy&>t%Rpq-5Z4gdw2g4vo~ zW?&`ALtmk*)=ZSYf!#Tr?4NY!4s=ZIJaJ2;C>VGqcEP%|7siY|o3XxXQ?FPgwe7j8YDw1R3A3-1mtUD(d9|YAs%!uF#fz6_oEtho7_Sv*}bLNE!W6q?nT)b32;OM+t3m4s*JNMS2g}2~3f_#gvn7qvj1nd7a2wMDezct6no{)d%XZY^|H!O&SrbeA;sS6~HHlEii<(8g}+ zH~hY&;D!m}otIux%L<|!j4F>?Ru<~4meTn|$Ylc3JvcB2iB@HULDrzA z(2DH~*XQT2FGRZh{0+=Gf5Q;dGsd>5UT=Z25I|msuSOYW1yCq7O%5EWoE(|p;pXV= zA(Us)=k1FSF{CnZV9hKsadZD)q^4fD^eyig~yG{qI}s&ReGs zKe%!ILH)CPMW==z(Z+7H(aX>Va>zqsCe^h>BB{Vdao&Vz-UP0(H#PyWnV*LlES+Mx z(wW_P=ck{P4yO-G10P(!@jyJ;@T2HNv=Sb&u99A=0J2V`{Kh;20cXJxOpAjGs(C2( zZ#XAaG@Ju3t%YtkSW3aZa>`t@%l9}zTn?d`V5eKb3dCpRJJLkJo^J(1IV-i?nO3mR z*%4_ZD6P|+1+H6E-QN~f_tyk_(FhZdt1#vuu9Tvr0VqcU)~p=HcfV91cLR(x*3DqT z2Bw!g${PT~kwDn0?tkReg}(0wtQUuok*_)IA$v{I%XTP76PCl+aqbMpgniNq_7A@1 zwbi>D7aAd-hh7+08l+>B_8r_aL|P%HHoSl;FbqxQLQZH$_p^N7GgfdyEA-=)4Eg?` zsS+mKMB8-Fy(Iia+t4d~)%NqYref$T%1OZ}7ovF+xac%*QjRvf2Tq8arS~`Z`x^}F zy5W5}fBy!5{{~yl-&ZPYq%`5KKsKwpe?nN*yun7ne%9P(WiX_no=T;TT@*+sP2Xz_ zb~X(OAovf<6Z-Q6?~e;(4O?dH()EZ6}IUb+Lz(Iw9W1p-efm4S`oHc)Op|V)eov|_CDB=n_7QR`I74VFTW=m zePOWWf=0alw!otKyiiTW9A~jRyMbMaV=E@8^FmB$Y9IEt8}bwtF6FCmDc=PDuiC>H zjS$v}U&?yu|KrY(gEUupw#OOL&a{9Pl2nf!1fqkg-y%_pWf$sgKrv`YoJn#FrmW@+ zX`QFC^*<}K*vfV69=oS>P&(ivw3CH)-u)l6gK#{wlf_mlvwmjlm8qs?FgECmybf)I zXud+5I?Y!M0wms}ZFwPo|22RAHN6K;M`4q!fK5_|{a+_y|A)&EE@ozKN2S*r62zC; z?@zJ!zECdPDKCFU-+zwpj~c#5{2Js1+_FUf%SY>@#48Q)((CMZrSoSj!JZ|2pI@mcW=K-bp$;wTYSl}4RBxxNq>Xz)KJlDP&fri*Lqqomixy@y!r z^_Oj~UQ<524BVU73+)}QZQ=C_X|2Y|%F4NrXe8BA_V{iQ>-$j1&j(u+&;2(;D^m9`k5t;Q3~15 zh35-@SI&=NPb=0#L%z7GT>boW{PP8HdUxpaeWGNsA>P|70Cd#YC%Oz~xIkrxjc21#muxS4c z*t6Hbp8a@d7kN#6y!hPp>uT9oVf%gpwr^YTwU*>sOwLdoA{iX0m~5-;SN5%9#mfFw ztb`S>Quedrk?LbHD_*1QVn)=0`3a|<73v-_-L%)LMV?R zcUP$tn%F`SyE7TuREgir)@M!5|2Se9#9=P3n%lGpefA(WKQAseFE2JWKR*_~#bZ~l ztXJQ}<<&pTi|dn@*C&q7?CPAFi2iXOb<8I#Bzk~IiUbA}_@WyH-cb#iG7_aC+ku0f zLmPY3IM^VBgJ-Meqkxku`1BfE{2HrP7QLn{#B|$uiFql1zeM?R8lJ^;5QPKq4>%3~ z0B<3R#i|+mlkgg6M7auAnK5#Ut+HpfI%}P+brncQ=94lEB=}Y0aX2=J$bsI_)>>Bx z?I9(a(OKt0Nyvj)&^$`MQS{{#VjTB~j#ZH$f9%I4ACfiu3v z-jEKk9Z!xB<%9UCZe2Qc* zA$be-WW@9f3(gv*#4p-4Aii%{P(j}OJsEwHI|gQvV-VzU_o<9^k?U#K`V077i5OV zhD4__cC2b&W^77WNI?Pq&?j~Y&Mn3sb`<_371(OY*F*{KR?^0qkE!n90}VCE*vWn>PXb39#m8 zt~cOovPQ}R3?Y&&`tT}NrYGcg0sFZX><##utdSc5`^5+|`I=mVugN+N`xUU}z9t9Y zYjT>O<9;)iGx?hAgRjZ+(rMI5IxaI`6Y#;utcM&e{sP&izu|5U9Qm;!l0RCrJsWp( z5JX(s5}@9)*yK9F7k#O`VS+Ri<~W;kN-Xi4(AbaP$R!D(oZtRhM@3A9T_aLDU7v9Q zhgK$3v!&8e$mRAzSA7`n$Iw7{YubiPyHq~UTxZBC?@av3Bnos;cOf^4-3e9hu+Fy; z*L5e9EoIy99A!O~w~yXY#(*@`4mJX6$BlB6yE4%l?U**=am{w@eB+Ldf^Pga4%&%v z8wcrg)mBX{)9Pz#-GqUP#r6$HS-?@&Rk?js`Sj=p!UQs;)KyxnIRt6MKrf^o11bcn zm0)1xDnV|mq-YL42_Y;7B2iBk>vorQyZVmZEvYNzQ({!oYPPu+EC|**A$GunuGV_fIt3NV9S;PDTE3XxDB&vEp z{1Syy8yHcA+@K&gS0=PkE^=iNO;MSI?zQ~BoS+lP3e_#7y=){H0 zzR!%F!IPBd#(G6WdX8g7^o{Xb`n`VEYjda!|M%#bGoojHepI&mE#}a*Yu7+XJBN{{ z_ORw_&?Hny5k_;0!1q;arPWwf2}sjtrCUe@f$un(<z43CJRX&=NRk9#5a2)B-jS~;{Q99|;2!c0cDthE!F!Iz8@ zd>VtNc+iJxNs|umR=&A2d-fgXzI!)wr@xeMcF(@KtFUm_&Dny8^fnjT z%**UIEirLgzsxCZ&f85qG+pUk`r(GHX ztxxaB@D4pY^z6|stYb4ydrXRj8m1gYeH-W8W6^0NORw9tcm0;R+39IHb03c^=fs~k zlvmV!&t@h?MfIg~=RoNkV(o52GigdhH>J^u(7g+O%c2DQcAf8x6A_i&3NWO zrpZPE5W(Kn9w|L=A5|L^wsUgE#-oKpl?3fOU4(&O62dwl?&FW)8z(M)a@&&0>l+I9 zu@n2GbF5G~Bzh_}Y<|O6tUx)!&KDOe$sC_E@>0!RRM}G~)aTn;;pPzpb!x>7qzcs9 zSZm=HrL)oM79xGDfY^J1%AS64c8xwduXk*#(vcIuEc9l#usW`L2mj~ha>@M9bk5=p|{#8Q^`&AD^m zG{n=mh$kk0LFgARC|Xvm4hi~_T#QAx1UNnq9Cg6aSMV1m=*RgZ)t|M4HPRqBGtpkk zaI|yKX(6dXxv&&@DsC6 z0JL(k;+L%0+MprwgL2ZsUlY!wfynC@02fw|sBj4nI#^H)JqivFWlw%G`ooFczU;FR<|#g`qc2%?Afq6=}w$b{!o5Ae;&QuIP|SI-v<5B zH~9$qW{u2l{z89!lAEKgq{Ds;$ppDEk=heH#u(=@Hrxg)g|!BWWU_6bl=E-b*2Bi# z#+{}D&b@Z1#45m6O9A-AMDVK&q|Ey!eha2KPF@v(;!kgmt!1ocOv5hY>|oc1NB8d^ zJ)H1eSUPm%{Fc+CIHh-SObX5066uV5U2_La?Jqo`hXkavvSm0ZB69;}Z6K#>IGb77 zSm|b9mLOTfLYlzn3`1wEF*Jq95hNHU3|?e=!??)5x2bx(0)={CnqrrMqrS%FS zFI&zWu8ci?x^(Dh^nZcWO$yU|%rzywxy0~a*+z{rk+zx3IQa>fJYLv)!*>)H?-*XP zy|{RL$$+tA2c(W0Cv|6dFaZwpm#G8BVlNhj1aXBFsreQo(v^HUd`Yt#jIdW3-Y(d6 z;UI5%#FQrAc>2T>Qm0r7Mb;dIJaUJ44Y;nF9O7X}HiDq@nP-4g%pt(sO_K=$UE6o{ z@pgB0uowK9zs{Z;eT^Q@YG>3d=OOiBIfnZWbutpE$GAH@n_Ttm=$-kq#}CfQ9qDvB z?B;@)g%cBBwDPHr8#~KBbBIsI$f4qj#q&$XceAo{3zOrM^<40UM>1y@jtCJ>OUA*|pq#b+9%lGZADBnwR5%x9lE7n#=(xrottvVLF zAuTVKR7os@Ce`3IPwI9r(|fZ6fU0bTqSKN$JC;s!mD;dVLpt^8)2TyDjQEx0S^t$Z zyHAIZJ~5%4dJ``2`xn0wztbXWRhaNRyxQQeu4ZBLB-I%_1aSKVf&lQP`ZsrHBgft* z_%Jj0FyahkgaS*!&$~=LG@&@WED8%>2y_V|?@?Ow$&qOP9SjSNxu^ zgFoVJ*<14u+yS2?Aj`L3JEV4}!=(no15Q=4sDV_BZInSOMnnl~3c?#E;|hgtT>}Gr zyj)%2KnFtu1(v{7!cm@qm)%B>D<~TorF=i8a?u1SBje6asrp7uFMbdJNvJ$FLD6Q`3rSuboxQsEy||#_rRmdOs+e~^v8$hB zCpZ0txe)YcygasgXkvM|Z&zpg2%oMqlZRGo;@G0X)R|oZyV!Mz2ro}ATqJw55ec51 z-GjO%jGcC=eCDO;qY}b8yL5MrA3goj%!*6Xl#-%Fu|0gE+Bzk8cTQM1WXM8&=YT$K zVtV$7T}V8$kH-lA9WqT<0XK?LMtn-_k8lei48$?zzeKz@g&1f^(TvPH8e^_Rjg;%x zjtQZ`?YjDPbw_ektxQ*MSP`judhmmzy8OZg(~#MYf;W+m0U_X&jsv8?a@b^cnYo=VRUsU<|&h4Mho_^=ls;a1pqMSL^lQvz z@n?m^Y1GmG7dw-!x!VP-+QLGhRlVDB>JC;2DLGdsGw2TLEbwUOa)j0i}Yr;~E)WbKPeGyfIeDb^KyA|n|u&Pts zH3$mNA4tTY0&F*&3bc+&BGK7Ou!6#l=!`&mu0D%ouN+|OKWzB(rO%+)RYK(h54(z~ zm+&oyr}1r#pInEXH3YgNl zMXs+;=T1H$z9F4EYT$_Ep}I}-i(yocNrRhksNp^K{ZBZs)8Tspb}s#R7i_5xjt)3hAwN3vf_;%<7R}!vkb%kwdJtF21^e-~{iKk>N#g%AlcR=g0Sqv$2WjXn@idC1SV)L4B(>uD9F;KWFzHCt=SO~q{*v~@yRECAn;+&P z*|VXnH1wCNB5^)7Z8GM9x#&7{BgZhE-eK)u1!BJhd9vYW1x$6(;*CmH|^ zUmi>YU|JW{C{lRH;{OFu5=*9D%V6; z+IXlRAZ^oGz<8k+n=|Lwz}k$F4=Iq>CzPj(gF06O`&B8(XZs$gYMIXGTh68>Ayw7LFzO8eXN0rGwyF zZH5+O_8ZW$*-bUr*(ndsfvT#NBfI6ecd-v}>D+PW zPN|ChW2M{FX^y((vev(C$V#OxU-t&XF5(RuQcUY0eNJ1Z<6R#Ef zb?y?jWJp$a3GP9MffsRKQkCSzd3^w#d3YKOI_Cj6yy-sOcA>n~>|Cg#aMC>yWHzqfD@v_U*zi-TarOCvhQ z#&+x!8w>86-mq4@6cHR05fKzj1~9Slp}39301q4JnQ~N4^oDIu;_1B%cz`HuBnXg8 zxU_}Q2jZCw;f8QDgTdLw&eqw{*4@rMAka~3!@c^EahB3jMM9jxL?<%2YAY`9UF795 zZUk`Z)G;nj^RI@A*@Nr)i1$sHsbl4Xv9c3#^wwY;%v^p(rST$1AB-1G53HETLQDb1 zoNb4z&&^?ldT1j_d~|lfm;o!&GDgvU9jbGyc**|P`^rzO?Wgbb27B~ShJLC1sO7scB`#DoEu>)uU12f7Z8I4ZA!`oEZUUI@s{%8+1mV6a8zla9 z3inV~)8;H`;!QWFif8QFRV1Yp`35XaAHU>szsQ*67ZZC$rxJH8Mg&ZLUdr?l@Qs?& zEuvRfWjUMMHKJEHWrb<}@O4#>`2&9yFfL*4Y|nv=r+EhL841 zzMACloMD+Xj!kfNA8igV)VsR5!i|IrAK1F+S~e?{Tg@^jLZ5+~U0uu;$BK(KPUE=D zQ8{dat8SM;@Bpd>a|}YqfG)~0HoZym;Cm!KXlv*Ta-BIsApuTCU(gAD-o`pe49Pe2 z9AfuOA` z2+-k?rjJ?!L~oM+0LkX*^VErjUa2dXD%==~K<=dl16KB+Amf6e4uOXo-~2I&&RM&S zjq~+!=;n|*oMz5UeS*y)ohCU_Ie?<*1Gq^140AnLmF;j(1&%_LXpoOOWINzeijxEh z+FayxhEN23hQ_ov^35?K6sih!;WSh2P^wcc+q~eA&lZ=GxY)EY)sx2_Sv6;U`#P7r z@Sdq*y_esak;*bk~-TDGi{ubrP&kY9ZJ5etipwTtRjD!055iz_X+wqpgQES8)T zX#JfldBM-fg*3OAZP)}P6(tPlNVp{!C`hgoHk6qhvYXa0+p*58VWcEkhC(u~tXTIF z?a7xbZR(mVBva=~trqWtj2VrOqVTQBG8>&o}U70PQ}iz6aRy0DmrwWzzBR3)!M z-Ny;Ir9|{`NLL4ry?Zm#$cvZb@9Gv7VQ;$_5%>|W5O5iZdW?!1}d z5#;C;?2&W*!!KSR;SuQQ;OAKaIVX{!xxVcK6Wfha-d0|o-!35_u#f+I-hQOGS<<6@ zcfnWhWe3Tksd-GXU58pcsKS1WhQ@dt?|yTq?rN}vk*keTRMYX(k$v&v zTW_B|`_`K;7L6EDR8%U>`slT5AAS7VYai{Zsj6DGe34R5x|$}uC|4l#Z>IdGO(J5UQ9pdSp9g1~ zY#lDpz+>d4QG^9;0VM`49bVE}fb$m5xN6LVq3#Rd24^+rD&sj<1J#_Xz5VC)mU32k z??-2fx(06_7*~H2bxg$k>I`1+5{98|HGLg11QO<8L<}|zI(9&$#3IWxn`fx2tnmY^ z4_G58O`-{0sJ92sUV>L>d*nXHLV?HyW4;(T2^i#T%u4X-OjekjRG8Rr(2Ex~?>rw; zF}s>QEmf^x){!ZlBKq_WpSfz;#4aV}nZ>$oz-bJ4HyQYb2}_?3rrU@Ohm)@4;-t~a zRlphAS~#V^-x~d)yvMpyoCSeD@h=_yxMrYps{*Rm3VBPZ1>MlES-Sa!vcXfz z-;rj;PEHN!-n&cJm_@z2ghll1IAC(zveEqtZFF{}nG=_Bek2;CfnR(Dy*|zz3U)^| zPc9VgAOf7s(E&IgwWc}tQGET-^x{?u_U_n& zrQ)la(&Y4_(Zh!SP015CDt}*jYV^|_&(LmtBD*Kg-J{vQ{7rdzS=O{zphqo&r^Wz3 z%F#YlZ_|{c-LTfQNY&0ciwis+G}~&Mf%zJT)uvS*ca^DdQi4xIAnuPv9``Y9>rb<0 zozvPV4`q3s=-cq+hMJlU*!Zr%c+Yu9#mhl>l6alZGdu8lFdH?(3iR^;p@^Y{gnP)B2r`HQ~kWUu*2K$1ck4! zSh$C%O#1=NbuZ}d7eQ_Vmj@x=x3Pnvq%VVUgQmLb-)P#yD36l~b#Dx?@k_%-Vl2_@ zyFz_iA8#hK_xBF*2_feITN}u{Ud+ol%?)y{>e^^D6Pq2@Aa<}%N>0qUeR};_``PAht*mrGT+Ne=!X=7x0xHK#6__o)+-7qe+!-|TSl=V}p_H4+A>79|)I~p52 z^?9aA--(;Q4LP16SAv(+M9<`HCP;<&1??b?xss4;t`$b6XHpLu<~C3!;ZHqn!yMeS zDZ9F}i$nL0j*fhIUisNu-@f|ru$?1QhmROAptMw)88>fO()k*?oW0;>tovrk?_19EVB?o&+;1q+Y@)aI^Z19Xx-3;lc8eM<=}VOiGznQ!*fZ> z>|lnch$`&XWQ8~AL1BY`#8faO6qgJM#W5|oG1-vCCxpE?Z0{&cg>y{yiuJ2LGHmCl z)ZxQZQ%Xy<7vkm?V=5?jSubnb+SvtsDnzHJM`J30zt)LAuy3^AAjZK$jx~2zk(eBf zQI0iodI$_z7nT|RTv|rIfzKV4?-pKpzF&>&BNo9e=02(x<}ChMc}oKamoBUymc=&C9fCH}Bd{Ay*r zOm(f1J`xpeTatUzk9%STu@u9Y{$Iv0lG2;5LN)B5Y}VIb@A~E&>7zTF-g|G;9Zrur z`H4z2OFY~UDiqtJ2Qfz2guj#jQCykFNY?1xNpEYlytWL;EKkf&tp%sHHAy7h3 zs81;FGM&_ENM22fXiM>^(2TbXNu?2`gByOfh{X;2#bVii`*!BEeLI>(d{uwtRq-8` zBI&fDg79Y!#Z`-E|I9JPRaYplOTDrC>$C`Hwg4Zjyb5ui%6Bxvk*m9@{9u$v>TSR~ z8R5<9r}ECcJi>-8)E}hW5`)D^l<#bWH?P0pBgvbW?_z{EtG`0IC3*4oyBgum%1=>l zvEE_=>hETRo0o5V*zgUD;qdO3;K-?WOG5k-%0tzy;@_-(z*#tl_k0vw-pP>1LmU1m zxa7tA2fKxZ`iXvl93E+eo8vE3G<+lV=I~w?;e!Eh%i&QL;lN+)z|w(Vv=QE{e|g}a z&p7^Yu(N<)kaCrM!r(rkjj;%?P;Q`qeF5)d5grNp_Tg}BR~G8;rreTOaX8FN7U0n+ z@5bS9#IXR6Z1_^rb9jP9_*C@&9*65K!i$yHr12tLl(l`0@MiRHf+rf`lKK1?hx%FzcFZE zg{KgI}ejRKX`MCO$C%nVo+~9{0_W%}-4`ty@y+Bvn0U`?NX!l(yhU)^u^c}D( zw@~)Mt+bV<4~Gl$v?xu73P-kf=b)qcA?Eh~2h?F$z53XPT@cy;yAJj3IvLt0f$0=-c=(=UljKFFnu&YuJ?B=9T zhfR~zZ$vusOcT&~{L6KClp=r}cA>*#SD&-KbU^9>9p3H@hZf)qCScaG6H-sm5gEQ! zB_7^Fyl&FaHQnK2(9fy2h8Xm7qT9q?+Qd0No5cB@!t3(8)xXW_Ey5se1FgJ-p89U8 zf{v&JQN9YJ*IeP_=HWTDQ^6J+fCyx9)L=_f}SK_a9MG#FA#SfT*0# z-6JBpO990tX;yVzR^Ot66V?+; zJp7_Mckf#p+oNN6NPB&0y)GpIf| z{vH&n;%LC0Jj~Py&3#Ox*YTJG;h?-OpS4!tU2!(HNmVt??J}Jo@D){HeEfcS7n2M}t!lc?<^9kyM1o zAUvvDYMw@t<_YA7-i?%W|M64YbzsO=@gF}`Yo#ng|M63*6*@m7n>-3nx@dv2OF&8H z-4;4BXL2F~t2bRkX2vWC?&SA8n(4?^&DkwIEhU9TXXfgiW8I(Zh1^7^ymW1{J5OJK z%yvO>V5ijB*c=>NB^U`3lwNN<)d5p?Y=qD ziHXrs{rXua%q`F(Tu-Zic-W;&^5tB(&&?A?Fg{J95G zqT+|2T$L~&Gp0{wO5Yxd2@#R;dg~>l29(=dJB*DhnZIyY{1^vo`x&XDmejZ6+G^kdcxRqx|eN>jBh`3?uQ_wCTGgBx_(e7a(7Z?Q9()Lb4s1%Q_HTv0qOgScz% z>^%<8+Q)YrP-Go2rEl5#qbs^hAD=XIOJO{6PUZBC%}%#nIVQMkRb{k(bH&1^M4#N< zHJh&vXS;?(L<}1g+Xu2H(G&mFO0j$%;C>EO&tbCK8V83K5SHG?a$&r21 zrajE@%jxH??-`LeC}Z}MDqeMsUTl%2O3n)2SrqQ4J~@9BN>^D$FMUzRRz72nm|$9V~AOL4ENFBA8g^ku1l z-{){JfeM$-n!z*0z3i&yHp;Iy!kIa|Kj0@c$OoidV-a2??iIK3`oX+v{mse`L;Ke_ zeC;FQH+lQ(EW-0q|N9)i-Ut`X@oR!_Fv6R)KTUi>JkQH-vE43oXMt2rI^o_b6+1Yu@bTv~zUOlq^Q4lk zX0xSI^kXmZTuSo%$!wL}^4#Rg% z^9|o=!7s+|@SA^!@9U&*Eqo8Xgsw_+AK$6-7vD?m&{>^!t^A_;eY5e%Z2V38g2npR zO8>M_e-Y|m!0T7%C)Mw5sQ-+G?+O3j7VBRxjkNInFns?3uV0qj@FDz%Tf~2hMf?+ikJ?{#JtTgBR|@!fi?rK9{h8ng%k2C4TiCa6nYCOLY^>6_*osFp03QU4aUb#fM=#;%dD*= z>j}sd!w@k>WOK1`maMGAQYW1w?ld$XrC$G`Boe;p3QXlu+AzlY7>fnzt`*)cAFW3e z#)$PP$WI;6C#F}gU_NRk!}3QJjLOLxke8a5sEovV#1D3#n)o3F=f*;$ zxt%F2VeTqVM7L#aFd?KiLK&RsBqw|18Io)#2o4Smj*r9@UXGr29vT}PvDDq#P3tPV z=*&4I_CJ<)#|2FVX0`A-4BVyHKccvm6*z=&;2iQ7Re(#cG}`M37`+dlHs^;K$?`Nn#D zdqPB^D*VCA{G!`np-iMawM7}xRHlF9SGv{6p%ViCh@W{o(Bc87j`HgIa%x9B+xRoJ zL&zEKfTl8&EtKi~7iA91KZ+h&FI@ik4f-w$Ps=|_wRk3-L@>{(U^;_}!v1@}CrvQ9T>m_P! z9?~;I<{0TEt&O0y!MPCTB|K{;;F;ph0);4j1kbaM><#prLS1DY?%M$lxothkj_2p= z8Q2zA8QFQ*d#Gm&o}t7{aRBx=DHhHDmg0M5Wb}$mPgneUrKi&$QhWYKMux^VBO)>_ zEixjb!%`9- zrD$xLNc{lO5!)r)nCQkFNhET?5-H+hAj)CXI#IZlhng1@$`Nx5s5za)iuNB)R@QKO zq@{`74S#6fq0F&YQzIhM(jp>KjlT)sGfIirPUr^waaP6iU?oem5}ff&k}zyniYHsv zxbpGNcf$tVTY>LqC^*-ktdUaB$ic&(%rMRwo1|&4(s0t-qWMo5QPXDUli1lfC7ZS31&q{~FSr!f=iAqP! zKd@%Bh0Gr&tfPDtS{>$tHThOk9=uRHrbXIBD8-RR*PdC6R!B;y(+PITALz9eh))vA^|3!$Jp5!TyWv z(%${&FYL)4$Z~TB<_`K!T&TJI=P5b!VOP2TpXbE)uWT#We&s6ud3i@!K|$WQad`zp z#w%$%c5wPPerGLfaDTSe1N7DjskmE$zsJLO$eU+;zd}09--C{tRLyNs%N+P~IG*R| zeiK8mFQACcA51Mj9e4Ph(EMFQazzXyZcbsJisLZ4*z&}2d~`)&J#s2NA!otPA1ENI zBcL6!8pD`~H3@-V43Vy|$Rd^nmOTy1au0BFx-2CdQ?8G=tbq2dp z?3pojF&%jVoVbTRLnIs$2Ze;lp1GICPPx2cVA0l#qgH&etp4}ty6j;Wm4BqK?IQ+7 zu6b>IMEsELZ&Z}Ov2DoepLcXu&i0J$Elp-gy>M@ye5d$2@Og05 zVL?S`9uOANTp5F#5zTJ;5J790*#R9%H;k0n9y(xw>47K#L<=KS&qJEhFibpHb3fr& zYV_P_=}vv;=y_48&&1#N6c308YCh1fj<#{W~#(rAsBFJ(Ex|IeEaxw&~tuILS!a$QbD=W2}u$=se8Z`A)j@ z=hA{9@|^l4=3;2=`||}uE-2Vy)v@~mH2lA56OIOtXj6Ol_bCNKbnE{>W+n@5G6DQ@ z&p2+bZLn~nqb|<4xDvF483A||5Yxc(1~OAXDCd{ZC^9A>BWNU2+95euXlN9ZBWmx* zKa(0YFS@?7bO$VxdMx37jd;+r=7adUXj`XC&Nk7j^&iwUKnq6|HhyLO&;Lccx(s8x zf4FMDGqhVP9(ZKCU${PP^McR@1H0ZehR3#%^j$r~F*OHu+VN|BE3#BHaLe+NU9<|K5 zK2e@iSny}9^pf&@t$4_HF>|>vq~JVr;SCb~z5xCHC++D{YMIL)VY>B03VxrWy{mjj zy=&2)@UXE#GgL0Yx&q%YB#{*y(L<5CD5heQVo+1lsG6-U7-m<&HNZ(mg03ja+pjJx zNH`0I!TRU)P`aqRk$Rj~RVC4;U zetZHP5;zWs>qe?r_;O<&X4qI`$0hb$3Mw;1VX77?k!3q|bCi&iEI1J9(7>-c7K*4F z1LJBEE;-x!ncC@6bSGbVL%O(^MGk%stp+z_FB6XkC$|IVQr(|mA4!l))&9d>hT`}P z{ZHfluWdQF=KV+FV&hZ+BVl=k?#oG&fQ29u1n6RF&Ck|Zx>%p2Qb0VutRY*a0E;9X zaN58a5Dw@+=DW~_j{)^Rjo?55U8m_v9`Cp^-Ozs|v4-q{o@3!NE%Oi2{dWC>)kcPP zM)z4{eG(0c+JALOO#Q#n_&fN`pFAe?T?4#a+aSphEw(Psi1!iFg57Z|L#qYX&!@Kt zlPWDu#{I>#UNF-lV%%^_8YYRGYHp|-j;5VDm2cFDn;It7+)$U6ho7sP!3`^M6TW?& zZ$kfvx%YsNvUvW-pMA>RrRUN^Aj##@2rZC=&^dbVkPt{Av;?GsbRqN_T0%#p7g0nI zL{zXMAflol3nCy`uwX%ylH8Nud-i!Qxg>{vzQ6K+{n6xd`^>XDJ3Bi&J3BkW1tMUJbc$tvwwL%a|3%vB_lta&&-e#T z4fzApA8tsesjuFdudRl6xWE}WFdelMPM{^pod3%>xfenL-M>(Qlc@>E>E54ihXRfO=pt6b48Oq7s`G>JC`fBLyAC}-j17y zXam~Bc1*WagTH++>eO^4v_ra*xB`0B9!ERU52c|_?SRIZ;}3W{A>`rVhsb9h2oq0J zjT)mEAmR`R98&ZH0|P?>LxO|MGWv-)-TEv~MaC{27Y1cq61Anb(hRYmQ|e1b@qK#= zG3IlvFJSu6Mt}om%Y5pri_&OL+@C{9ISkxw;kJ zTCm_&Vc)(Q&eCyCJ=+y04Qw9aIRA8S!njwtHikX!1)&3U-9pJ=G{IrSgwy6DS$qqm zJ%dh4&)i%*vqAS>hiC4to}o^9=HcoY>ZE6$Ri8oM>;OHA+VgVt3~LZQ^LFvf2EC5z z^l|kJb<#6mSIqM&db)1jgZ-a1PIq>)058XXmtM=d@>!@N6)D7U<&HK|G^6{VLZ9 z7W_;oGE98d#XrXP*lWb^FR16bs@ge+!$T93-;&Bn6y3= z3yqXFVJhM!Kv-MYXyc&LzKEXt5pPo%jZOPIhWdaFwE1D`kUq`R&m)DFh~UHsqBB~0 zPC9I;|L`)^J+iE$VL$vHC_guZLL*W>4ErCRF|;`)?UMFTKZN(nIwGZv1_Qy`s7|n% zy=Q23%Gj|Kn-kFqKSi+GB5|9wl4?U%EY=H=))YyBeo0unNgQqaPBBMB28@RvDU(a= za5Y9<<@hT?w9NujO{FxRnkgCvAcBP>Ht$djs6c&s_^14)eLMB+HU7M!Z%7t?9M|jx zk@ru+Eqva^*Glg3UOr;-N&9Z}Rdnhry@OGvcY@7s5<2{7j_h9YH}AH6uQ*uDf(Wt! z-+LNuVC_WiF041m_D3NTV0S|h4g`?qmJWPCYC!{s*g|Rv0f9#SOn&egCZqlqz9~7aPiabi>`v+n# zB75XiCTO{jh)S+<__)kA<1(KN=u*)}9BH&@#c|68RI3!thHfuAC&V#4runLAmt3M# zHLsFO^r~e}0(Nge&sm2#BMHGaNB}7NU_+j~42z1HxDfe4&2K1|`7I*R3En6q*y6wo zU>DL9F`n8E2~GppB4M~OW~dhVWAsX5kdy=!J^D$`DA`Zdy~e#cD(dtUYC6#jR(h^} z@>oQOfCS?9^6_FqaDZ1$pPEKl@MIoDGfNb-23oujkJ=hThrVW9F|ojEh=^P4!0p?z zFlqWvrM}WPae;wxr4g|~K`8oZ`lM3f_G>}06~)w-^8R@uUQ#68Ln2px6&Sh(!!jVMJMo$<1&I*cy)EkgQQ1H_7By znp_$$eIed1O_V;8AXY)s3OLG2>?3&D+!2feK}R4G=p_Wzk8u;Fx7EHdm>-coQU|Ji z*x~a87kIq`HYpYMhaN z7=HZmBL-3r97yRMUMk5D>u z>NIj>r_Lirh}+b6N3&*+ejCM_!JTt7Yd)&N|o<+e&#idc~l=KqfFYUl9gEwSk zY@pY-ji6UMcN$^;jWrvso*j)EMvL32idpP6wf!0Vp`Lwoo1IcSN?nWb58h!;G4I#KpC}lE%`jvH`oqQ#3L|h2;x!e(*$OGD1-U>F5qlYDlX)g) zK*}n~2;xH2P$ny!Kq)zJh(Z#px^?5>|5Ov9I_fs4+n|0ujikE&Q$$UKQq&0RuEC?);oSs9B5jAwveXXqqwb&aWA2xR{@^x-hAMC93iD>&Y>ZjgwZcOr~Y80x!cc zFHOIzj+5*5UA9DLNqU{4!PpIRlL@EF?izPN2Xdpk2hec3x|t}ChIXpw=TEWw8S)%h z{GqP;%k}M7uGqg2_k46&+-1M=1(e_^;$pT+Tx_4IPO{I0OslAmN2G-3m(bPU&l4A> zL?kbvYOzM8;{%y#z+{5h%P+{!pZ0+j&9Go8#v(};oXJ*c(0=97Fea!MhvldjaF?KJ z`(n4FEbb(obDvbdMEB6Yqk>?3-Ov#srEq5e&35JcX)+&jg~A{hV3tNFVLE{-U_L4> zk`}9tOP7joNQ+Bn+HK++RFCLXkC%{aYY53Bb;ZFf5_FM1i|K*8u{1sCut_FW1Evfl zLqNM|z*x~h9H}lzth}9WWujSyg`m8-jrLaJTS!%lb?B)2oQ}H}{38Q}KDM6lca+gC zT0@38G%Mk)CEmv6qw#V3*WJ zMF)va2H{TGHN>&I3(4M5=p$qT#V3Rrwy7YMnfb_)&nVwuZ%M`_G`doh=VufdDRY&rF%h*W4FkGp6q>W(&06o@&*Jc+=hZwkI*}k^t0c9pqQi}{kCu*O08mIMp1ftQO3@l+9%|= zIj$;V-f7FqlHPBdmDTo{tkRcvvaEJgQ1=-sX`7{H zs%jMDuV<)uf6%&t1J@1OzFqs&YC&o7z=6e7S~PGU%WS(nvu)c_pBj9AdfY}#Xim@Q_{SED6d4am0dn$Ktg!A8ec z0$$7S5o@#Z#J`G*Euz6-a5K0ClX9-th()oYR{MVW7+dM6nH@WIif}2rtt=MLIpIRq zJghGB?Yr!|7O=0xbNGv};yOL{ySHI4Yzd7#3i`wKZb#hUDGN z84i1KSd}M~Cq#RKV94|$uHI_dLa>R$ffW)eVbUo`sD#jMJY|R?^o3tBT@y}lfXYa( zDGLSAARVvZLazP_^lo~?R)>J0$`oM9{5NPg90o^Q5$&o$bc0GMM6^W{T#B{FRSFS_ z+akEXFmxWC=tcabJdsHFbLELdy4aiKiMisiJbOU997-wDvYq&<>y#q)dg6r<_NT>R zBNjO)7lBNN44ncVAZ-|#w6X0$5IpRzvBj!#2!o4w5HJ9wJdj2lMJ<7D0Sha#YsE%e zVfT<@zy$Dhz@_e$mP3fko2kv%WRFdM77^vsH=Uczkq54laF~>6@Pv#Hp2wXQO-huDGYL25MaNMD z_ZYhZPlY23GSWg(m=kSD#U}(S#49%&O6%-3#c!2yk8a4rN}jfVuB<3fKTe7~A#oFg{S)=m`SfHytHY~EbfK>c_wOJoh_s+U>)xhgIOQr4!| z#JXa=(wIs(s-Mhf4S*+nlZ^9#C;6rN3(ah)<c*NToHbG&Mt7Q* zWbuUXz`+eT-f?gP12d{6=K(1P&Y#7Vz&-Y0HVQ6A9B08; z$3T_~;0$XV%CL555)1V%ehki>+Q>Dhp)7BDtu$Jk!pX6zBwxDfz*#WXbJR`vqHfRw z*hA6?sGD2Ih$z~Tv5qrQo6^_;=hCQC@+Nj3Rp*yRok|Mo#XiHfQ-_>37msY-9+=Fz-~!bs%sGXLz&a!{9h~I^zagaCuD_a?TJJ z;gp+6paY&bd6pQBMt7sTpV^-h&Ji`>%mqqIA9DsdR63ya$JbaCr^x2l)XmcJ(y27? zRof%~1=byAOT9hVxY3?~_OPltdp&9G1t5D5+5?5qCvNAEN0bhb4zcs=sI^hAu{;RV z7Q8jS$C6vYA38{AZ)-!d$-^B(fawG~!D2TC7Q%!VVF8qoBMBBj3e*jcLP^Fp2`@nj z2Nn50KTksh--=OM1p1+fM~J0JKS#A;{~iBcqhE3d68QIC*mYPv%=#YQ^};>kv!i8~ zwdgAV$JRyL{8;3ap2y$(oLr+^4QpN#V#5nl#+}?s_3Lf zu!{O2$t3oB%9`8I{CBBkg@s^`Y_{k2ZMK_1gD)&p%hcU!mVFXE$YQ(kU=IMa2fNhF z+qcy$0F=Sqlg7RRhXzizYYL!`rjoB-vH#ws6SJ-p;Q0$| zEK8)_Fe85P4(fc!865SxVh!og{|HfH`apuy+eINVQuzeo?3q^ zZ1n~**5j+y5(P^=EO(Dgn`Rai%)H;<^hW*q_ic&xU8SZCk5Djr*1VJTO>d#FReiFn z=ro62e-T=iQ~M7190}~@ zqI{Xu*kyU4i2EEa;CG7JorbFTzbj971<%~21efJL;twv%L!}-r%cGggezCgZQkU>; zT+;`4%OT*Z_lwOD5jV|6IU-BDEH8Xa`Bw3+OZWrgW|!sX#8+IFzt2{>EWa$i>9YI_ z@vO`8-^DUls~i|1XI_dt9mSMWU_Q(gq?pey)|l1n~R zo+s6_Dn9VtKPDX)Cc`5_WJl;0nM;^o#0$bR8q70~gSi8`{Ts~h;w=qEJfhVDb=7%o zX)g4)^&x4C^KmktAk4WN&;Q_w3mXQvJY2G-1&8ih3%OW^MWIh(A}u+I%@c7T(*(yc z$vBL0UVyy*Hx?j&uBAZx3`Ab@e_KQUX)zjQKP|RBBeu1l{y$un#0atTOJZmH$(QUW zU5w$M4!SbebWNh%GayXWn3Vr7R&R;Uv;I$rc4DivZR`Ijy#~#bd(3mm%lE{a|H`L- zIbbB6o>gg%n?N;0OZECu9`=~>nqvLx@VJ<6f?bsS#xVcN{l+S-jezlDyZ;rY5so-p zYxT5#%p5f);gGI_2GhX-KDdTorz&sI7Zd%iop9yQ&BJ#Q>M(KH?#l<)OMfu2MgXX4hT9 z*A?fwEN|nQZfu(Pz$N?~af-|G0$pFIicg{VhfDaauE&ub(Dk*d^_&xrxUA=Ww!mfi zW$~oT@-M{KU6%hY{_Uz9`h`pUpCyv$U5%i0nU6ywjuemJmA>qu!MLj*Gc$eix zxVz^Hexo$mW%={EK3Iu9T)%j}nto9g<`?nnYBISh%$@%N=6CT*HT^=bhwtTLob(G= z4<4gmq;vfuhwB%;YSf@DUX7Rav~`RZ*T>{ z)jp8jsaW=_jRk1?r}$-Mxk6C9jq0J6XxRMcTH-<$hL- z*Op^feYjV(4^?>-{rt-T-J>HYV$N=s{nAN9S&GwXBm z`n0k2u9Y?{UixxCt5yT(2e@yR4omx#2STh7HUo@J8T*ir!DeYQ%5Mp=CKLYjceK~t!>xL z70QF*al_JT_HNy#Z(h#&Gra!IsQ(txrc!)QogkTx_@33r@e9=K78={M*MN3iGgnHR zhsO^~tJT}qrcYi@@f$ksPIWs`U1yw3rpFGgPGq)e%8JacZPR)+jSF>8?=Njme51I6 zpxBdvE*iZkhMCnC8R<=DGTp6axYFaq6P$_f0=1A39Ya@OtGA(48`>(ZvfY(Nw+a%& ztDr<fIiE%pH-Mfg!H0XBu+LVOz@GNSyQRpsxjW8we)4ty|X7}K?PQ2$L~ESo~H z3Pi1bnsZ46W13bD^GKMe!AMnLoazCd8jOx7uZQ|XG7e*ixCnY*cw7W6>IK@`3&Z@E zyq-2X%v@d%y2<-X_3Tx9%3tz&959P{^b7|n2!>)XOyl)*(drRRydDs_q8{`sjl)2O za(r^C;f%JFG~Sj2=1JZb=wE>|@EKqvy60eU;}G@cJ)Q1T`B*vHq(O6x74>rfZyWD$ zx(8|aInli;%q=#xdLO85j-OT!U^sqgvjRV~)tlne{2#NT> zfjg%==+&FU?9_2y=L+XaFt^y<>h*x8y*bWWJ%Fi-bJ>3|(FgOk-qqStk5p|-gE4&$ zx@$1^)R#0EC%(k0!d5!fa|@TttM+S`+LNu|_-OUq5`3!SLp)cZM{pXx=?bPor{FL{ zs=}117_YjYygVYCxlOjGg+p6^e_!$mT zA1Yv~woP+O$>;Szx8eAexvHl^|IuKo)iV*ac#-&>Vg3=nv%wm_i|&AREt_~u6yCNr zXKxD6^0uAj42K~(L-nHVN5WwZ#%VmO)^kgA*I=CHHOH?a{t9@R@Tx3lIE-Nz+UlUw z)CCO1aWQQv$45n&1}+<&@BvNbGrV8Zbeb-zh7ZBq=P(62%#!Lb;EQtolGA->HJnNA zA!;e`K|KQT4q%9Pgkz|W(_P~ohp+_ij4t~@e$%uW?`ZS-u5g97&79;6hvE3?bDtGz zFitcbjke46T#nzGYJ9}RN%c-8fUDZ0!)q2Mu`1!7$&7HIV)J+B^zb=J=`*c#=q>x6lahb{X-y06^Q zVGX96AESE6wtiHOs0>*g2DLVzN8aOA@84aJwwWVl-m#v@BpGc-7Pkh<1hsEXY=}DSJ!Z; zR{s#xpUvxcz@$~LA24Z%6B#Rxq7Xbb2j&VI;mS`}-W_DE97mpI5K&K&UM>&_byH2M;Hq~DSr(n4y@vXR> zzk5^NT#avWN>K^sR@uX9JW1owlG916hwD-r4&}Pxji!6*Gn^)?pd(H%hmWOth%#lRl}Cox@er`jSHQY&g#y4^M*Y{+ zY&MlYdr!j$?hn-NQN)DoU0xpN@kCjC*?xw%@SJPmW&1h%0haS$xowG$Pe+c0LwDpb zkPRmI(s4TzU_L+|7K%X!7%c`J>RAaqpXBtrp^ahL!>aX^{fO9yPCZVJUPViu3T;h z<9)8CTZ7+v%7{6McY_F5?8A;}?XaP|9cTGNy#FL`hhQ-$uq7qB@p6(Wybj0|gHw4q zJaBi+XKIt%+fWb3OKZz{t`J_^lr+={TioMd2p?l?dAsUpt=(cZ8?uJzL54YMcbi5J znt!|;`%)?wp6BI-7_V}>AhlKYs2YtqjB*8a(z|gQ45ByP`BLXKZT9f`hL-&(-8D7` zEVn0`{$NX;%476$gX!*64POq=@zUULvDz9uWN*1$lG7le8eT&Qru<#t#Q?)$QAg!@ zU3RnV4{@#G4%(l=X?jzAow*YX^jdda{sdHkxg~^aFwjHFVL-2PyC}6K%&mr3aoJtS z85)Bk-~nF2Z$8JUoMeSweh;o>j``VA&eqCN=S@M@>U7c}d7V!0{_S|TN}UfXl@niT zI6QKclMHlf>lPbc9e=?5$oX%B&VMdoc)LD&{YI0W?CY2h_3`d#UjL{1yX~vh-xNd{ z#pwgR2)uYx_>sR`wfq+RrK!%QkOQN5ow^<+c5+pxE(g9rouK(A8f{UhQ#r@YR2LRHzixaBhFdH(|&g<0W7^}zMoee&<^LKSQ#^S5J z%hzzyg+wb5AzkRIPQQ^HwvsFYjkEb$uEDN@Mxea(8W#bC)X=TZt3NZ zyqwC*;i>Cs`x>7yrc8xOTf=rPN1C6b*p&(Ly@cJiPhBIDi|Hb|=6LP;Vmk*0Hp1p?;lF?{qB$dlQ z^Ko{_^z^d3(h**MM}vpjOz?y|UnAvTwQ~HX@^U@P?QN}G*R!&q?{IjdGgQt4J zsD8zumH$y*t`yK2nc{(hIPs|Li%*&}+j%>KK;LjqyLg>;{j1U!vfzQ(f#Xg{<6U)& zhWkIwTZ6rPE?qmoaVg73Jx^0P&-`OFU02&tJ!NmByo<3;dHFYGEh_4Fs^_{^k2aT_ z%Jus7Ifi=lIrfdPi`R2h8q8jmvvI}*Vo8HB+BiFs25b8Qoad30ewA*S2%$D;qX@)I zaeTC7dMGtZ2<1nYhK@2fCaHFUz@7IS{GICxIUce_j3qq5n}lt+CP$=jT{q+Ha+phxhXD_6K!12WLY(OXaV#IV59F`# zDGGb==3(q{=*}B%IpKs<%i@hlhN37Tew0KhxDo$GkP&Iapa4)Z8z^q0lq5;GvwGU+ zp6_qWoqa9+RqCNy?L-pP3&|sWs(dd{?35H+qi~9+hYNIYyv60A0s_fJ1DQQ=uS`ZO zvW!IBk&%(sNNX*tUxI;79O=G0T_r}4pC|-}Z-oo0JRYDC7b*j(X*Mq@r)|4I^E3M| zH(ZxzU6{G}!i4d|TJ?zj1B3I9&*I{=+O?rji>P9ysHs4ajc z(O7K7UX|KtydbvHctLEX^8(^0(74JL`1P0t+#|dSZr&#mpIF$d5#whux24I+k?MWsrruaShlQ#3s8&6tix?MutmXLf zF~V5W7;zr>0_{H(F=`;#7djXGEttWxN4@}>v=f#7*6;;9?bA1+9)szFtMvXV;IDnZ zqy=L9sHk0 z1B`#Z+5m&^am7l(kL0_0+*dzeyC$Yz(<*jHwa7Q3*C`rI*QgC)iDHtxjCBy3Gz4(~ zI@>y6R?$p=8Yzpoc4m-;(VlJ|hyiHGLHrs+nz3hSXdoilht>?O8CF9JB3e0hg60$E zB5eXgf0L-s11r)e^lv(#la@Zge&fo=Um1GTsnakrcY57A{YE^gzWNdV5iLZ*TRMdG zfn)*2!lU#OkOt%lkj7le07qji2GuG?jjFiStQgsBUJqm_iBEo}iz+xZG#Lsp7+CZp zy@NvVs{RgWc1z=Z#obLZcoC0bRdT0Kajf-hw^-z66*gw?6=c3xru%RqX!$<9>;iLA`-p6X6L;C}G@IUZ= zIc>Q{ThU+4RrFWmL!6OowD%Bj!JaovU{?2?& z11@2?r|}zZ$d+oEHe>y|3&~EJD`=~EW^kUeKJ_jyPel=Virz0Gfn!x24a3MPT3axD|G*TNuE`Es} z!4=#LCZaLdInv~wUS32UFJCVNG;pSoyEBbQjBuv^dd0H0{y6@J0_2Rt_U|{*T5GcJ z)er=JHG$tTj^E!d@%z6*D@wMbBP9B~{@D_B(!bE^!9U;vMGJD6j~iA$ZBhCktbbVf zi0_Fw(j5B-2}Bra`EpgMI%d-_X0-p|{8KSz;ID0l^-`2+0iHvttNI++ZBr~#6yo`o zYv(SbQC{wMz{{a20=^jK(TH;Jr#Czr+S9kH&xiNIeZ+iCjju}c4UH|U0#2M-H6IFP!6%N z1$fRZLjq4BzuOT{tQ?_OP;g}riC-vO1wly&(SnK8M;F%qSRd$nd6x9S3=7NSUxSSH zL@gCr)FE#un-Y{i1SYp`39DOg%8mSN`=%l78i#-N#}iX|KbAx9EG&wI!c94!<^+B z4pb+#O*m+KBS(`Uaz&dpK|cwU#*Ro!?7^Tg(|(A%jaJ$Zv7++5ko1DS4{F_`QlDep zXxD9Y3nE%zIANoOn_!x?pJu zl6e^U7)y}0owV#lm=7E4`jGk0{%N0jf_2SV)M3kN^@MWy9d#W0_1xl%liy_Brgs>= zn#Kb-xPv}Itk9ouW4|kBHGYL=I$tY?Gnm0+8dMy@c?NKPQF#q`1PN)~j?@Qd(zb%q zQ6a!D6c%u2S`PyS?SjK0&xByB2?A1lE{Yk-0i7Rb*u3#C$U88~Y>tUEdW6-nSa@u> z=p^(m#eyJsJnUPN{G$ESy+6-Jx)|2jK0w;}w|Zgi!i8%mUtIj&JvQd_K7YK-Br5Ftb5V+W&DF`wpv0MxUHt_}n zLf>JH$`X1qA)$6$j3pu*A&~<7eZ7TxtezWg$RhP0IaH@28XaxyX)hma)v}V&R+)1p z{%F)VHOX5P=WYIV*{=0ZuAFpv&GK)SNMFhO#!g(ib=KUuo1ZXsS7>hEDkwNys!Y^{$=yLQg zRImuGY|uL~StQc%5Fd=96N@4exX7~JC**a|`V<)+Rs(s~5K$K*iz9v0! za_XKN0UMAw=+NQcXKz@v_Uor!Q4jw5i~8&-vH!HgIq#8-8>Dtt0)T%M#RdsPG?E}6 za1a9Lh!A6_4Ty%B@wl>%of6>aWN5sekS4m9wVLgtulaJva76 z_L=9o{dT*z+cWClhhA2{-L(*IF+^*QEBQ3KMFK6Odl6F5aNjV8&l38RkN!mQ{$L;M z4TcZE(v9w*XNXh`-ZDtCVGfelDA@f_x44Z3-NIxUie_@TIExa{GqZn?)dZVMjKLtI z3lyCM?1jDsQr|Er6bX?ys&T3kW!k0wwfDIC>*kgBcd1OamEK{W7A&|hIrG5eVS7dz zdTst`;VxG5<>#3Db~kTP+JDYdO?YwaxurASn$Twr%~Ie#Pwft$qwj^<0`3yTMMfYL zv;mhOxc(2`;s!0Dr`0b`g6Q#2X&mi{w&-NLA`6x%%SQcaoI(EfXO^;g#lpE8@3SSp zY~J+ag1$Y{hOAQU>h{auur|-e)SafDX5Ef=+;Do{+(lEeW}O@{?2VP9U+a^6a>?_^ zgE=GSoqDToKA$$l(t8fcs=$>D!$8bYo!CdyT$-Y08)kzZfr3?-r{zHO4q%E{t0qD& zB8-jLJHDlvVxVF6uj|^WKOQ-+-rBT{ zMPFQWt2^^6+4s(+6N3}h_4(+ma{0kZ!=z@Vb#taY%bI;zaFsRN-@VmTd(UaVsP{6Z zi~G2G-UJ< z96kh62UbK)#9N~+eq{dikMoCYZ-kXgwpx(mkphXs68inIM{EP@@CR&&-`}-=_8sf6 ze8-OE(xKt(ZTp44E`MQHhTEsvzh6Ip`U=#q$@5n*MiIgUjr8sTB=EWiBBWiI%^e>y z6^PySkqPEfop#v34VyD))m#LI*}^bH9AAfkbb6X$Gs9XH?C;CvV+4z!AT?a#BNP#r z>M48#4B&fyzXrB%gSdX%gEfEeSXH>4b?@#|*IcWEb<>;04+AD%-zWWE>brHrhOOe7 z?5+}gZ{6QKW}mS4#zb@peD{R9O_^nAf_-GDfXMQ=JgFc{90JUOrxkQsK?GNWL0@Lk z35sv4nec(48L#<3JusWd#*CVr;bVjV?Kn4|oN0pZ+sfv2%;X~$TXZ{-&i#1Aq zWNs^0En2VMSGP&8+7B9Q1M2s9uhaq&psJBavbAfar@3j1Gu0d4!YngN_BG zGZC7vpU!`y)EdVjq>+sdJvDLXfIAI)*Pk>wSo)<=p9W7%3BB{RDQQdo*gXdZ4o^RK zP!2D-IdWqCQ5|d7)BnuvDo=k@e`=d9aHAvIFMu!274VZUESY)_Jt4t`nr1H;XQ+?# zRdjsSxylb*g=mTBqJWi^!PgyXcM!MY(hPu9uXvDQgLJ78f);#3t^5vIAn^>ARth<# zkg2_Kw4a`l-pFPqE$Dxgd2hI)&Qi5z6umHhFn(s+=BC$rtbvGhyU2Iw%0n_ojdKG$yk18tvWR zWr;l#>x)8aa(#p;iH!-RXq5HDdZeZ>ec_Kw;Q@nD%fyd1>aBk4BBUw0YL?rggVXpK~Bxemx+o-=KlD-e0nGNkPH##aMqZ z2Jn`YgV5J-iZB;O);6d%5R;_Z&;WqgnLS7b$vIdAa7ZK~*ruk53E^Tm4~E4%$Whb4<^>;Tf@aKjp9Va&pkm^@Bhs4i81 z69aw`17yVdqo|Iwex5*G-}3b{)J*GVC_Bm9z?rw)L^+AR!%psJMl3x!je5*5b=^ zua@m(%KB#4*@&Ox-+|Rry*KmulgsCn5RTXUVy%8A=s9kp1xFS-H({P49J01jaYn+q=#z;0=51dd z_v+M<`-ctNKe9_3wLgn$HE>|7HUkGDD5sbBXNlXW#Y6Xw9KLT@4Jr1~Pknmy!oMCk zLS&@RC<)+?+QJG=o|-L@$gqcS+*q}ca7dIOaw?Z8DAVOm1WdAspC=Z8cN{_n>p`vo z!H(&&YM9Mh9fEdVnC=9J;Q$o2Ul_02Lhb0-nA%p_ekGZcp;gGiNEOL=rU4Ly`AScqUKX7C{ta+zak>2@R<8dxnS0Q53lhk|^e4NsWOg8pZa zc;QnphvZ!q7>WZO0u?x-Rg$al?FJ!;1!-F&1m(3N6e0|e{M?rI8I*|Hp%DiJ ziEoUY*VW(q%2!_go#y5*{&d!iPfiV4(6(q@Ve$H)_F2&{$k`{XnH`p@>WP=s(&ew_ zA05B%>;D{n;R=QVJemu>7=XSv5So!)0J@bZ#07d|UkV=97E??m0f_5e$dY=-)vJRL z3v`M{w{b~5)P5Va(J}@FJLZ~p^qd+S$2WK2Z^w-Leo<0k<`did_1!flb4ALMu;vl* zZThxVXPZR2J?HP*IrMGH5@%PVtyqXe~1(}CeZv2lUP#P>Py`}RctEVS<k}mQ7(7?GAz82wvmY-D{LTM+cZNyc|rzWOJ`q zCpxN*8Otc5d19klUyS3zPhUj2U^iIlD!DH6DXn=hNyNrb%mUdlZ(A?xGv}VXzWtdS zQ=fQieyC5M)3y=GlXF+h9MwL&!H}6v)upF=nzciQVBh@#`_xq{9_$L3dug$s)cLtC zQb<7l!C{~72$*s(!6SP!?`JyXbP)O(3@sXY#vxCjCqUs;uu@TGaaf>eoznW4t52a2 z#0(3G2ti^SUvCd2wV_Cw`qa>6MXDvm7g7X!aO#pjXF_A3=(Y0mb_<)V?J<9|o4wJ! z&$fIsbM8-5e5X$sHp?wwZ0__VrVRc3Gu{5ex#R$dSF<>U}KWH*MP>{t$gE+d;AclIFXk5J{!YSFF86o zigX!;%XiEPNOv+CV&d>A6KD=LLed$_r-%5tbq?BUI`vU!1>gwX|>dhs}&a=9SgyaU6~^X1K-t<)`Yp0V&>}~CL3)X z__{Y83*CtQBRaOV#MkH)xplX#9Tq<}vE{&lE!(E2%Lhm79X4$5h?1xwecWGlGoF4) zS{gEJUt=tKy?bNvgU-Nx%H$^@>lg8{%q;uSKs*?Wxz^FvF3uX@@8xO0p&E-1qZO_@ z?1xAffY9%H2e{-DI5!RJG_WH40IPlC7F&f`-fhY%Ss~D6F-lI6| zN03!jGoqx3y$ilwBLxKRot3pP{8IeAW0#q4?5DvE+lSQgjH=ZkzJG3tuT7ly-AemA z<`pxt7IqAtc>jFB^hGOr_e@-{^SgH=*Y5FDR`>*UpV!OnK$);c3?49}D5Dq}Ao@E+ zoi1-AzbvJjAgIXgLg(@7N^L9ccn<&GIPE!Em$2g|k9H?G@Xi$Q&LKG)bV@>=rl3&p zP7Qxp%q*UwL5a3T!74B7JQNQb8m0snQe3;lddHYT#xpGcWYQ$_AD37E9Vl#588*0W zG)k&k=Fi-i+AGezZoRQZ z&$DeFZ|zi5Jl!XsoH!{je^Gv`Zp`T4uy5nqt=h(u$ejp!7lTd_!gQOvJIH{X+2EpX zN8&JVVnHNDHYl{<$e0>r>g9Ggt`RuV#aayzt{>Qgk0^hE1Ug7kGmN(06qp|QWndq0 zB1vVNoz``3175uKk7W}+SfP%WcG{P*5sOajezsuxe)rp^!XMS?6VJ|@^2Q7|PxkKq zw>{O7&+i;RYu<#Bb6*|~l!vPAWjFM#Hc35*Xdw>fYgnT&L6AKP${>kt*i3c%J0Er~ z!E>daehF6p`rKyf4=bXk-jxeD*rp+=X~t_wE->3Mik6MiBz4uwXGR>Kv0~5@8O=s_ zl7AR|asByU&wn(1_@LbPSbzJka`tNVbm-G#bLR943r}m%rjw;thm3urUoKj(BO#=9 zo5n5HvIKB5BcBWf#}L51u`MYy1m17Se{?nVf)+AN-S zLpT`Vwg6=E1DnOgMeEjfO=OcI6CBLDWflEjf9vWV_W78nw!fx+F#hd1CoV;w4a^%p zcxIo>m$t3{>+?5{%b6vM_Vl!kuqL$qY50bITW8m4p3%2;6I)=sb@lWOCo$jV5!%{XN0T1aT`<6&YLE+%k_r-wZ2p|4xrl%R zBLKE&f~fc87fkmheC;4-EeJZE~QL_t9Tpd@Y|ILl;XXb)28Q>haA3!X zY1D10Q+~>jQ7oo;r>KbDb4N@#%uMQo!()36Y|&WHw5XRWA>-O;Ld^Lh@4t>xQbF>y^)q>dMQ+G&;_qyqy{q?_uMfdBg0uNI6c zy1zdE<*DffV|Vo(leT*_dw?;h;A4&tRBwn3;u8s?4qGKO4<>P71{(?r!iDfq9UqIC z$Xa!G5QvO0!N?W((NnwoRNfePCG_v~G@BN-wx~IGS zQ&bL|7O35&JJ46c1)P=CLJsumXC*m8&nUlWIx9&{iAMZ#C{9+cU1BxFwpvh9TH#D5 z&hVXRI6i31onJ4$b)}$Kovs$V{mba2GiRP(#>~%W_S*gCi5+{E4Eax~da1?nMzi-$ znAmQnlP(-fx-gAn*(CcgeH@4B;|N(Rcg8y5Db%wiaG%WXz#VoEDUTZnGPvOtmU)zV z3Z7=OADt@0wuj7P+~z}}{@H{~Hj#O#DeP_auDYi0RXJM?XE*Ja?4Pphss+_^dekrb zL8-0$gn2Tw+mS#>Nx!(rpg_vi0v(GXt~(50Fp0)RR+M?d?AJXAN^dt zrY)#(PmAZKsDHzmFC?!HOYrxLsqyu%?2tjOUzAke*GE3)?%i*2 zr{YGXPmM`78(wttEm*@Ac3acA^V+WVMe;}=t*?8r{{DdZVG-c31D9!5Q^EQR`C05qnFqHy5_`9P*_QXKRRtvM<>rncGF=uxYVKin09>AcdYt-tyXiqvhc zMwzX9KbN{Nb@b)$*pgqj&A8BUXYJ|T=IzPH4_Pf=__JbC~Qs0BMAY;ElqTsRjCYPQ(;fxCt5j9 zMzeCOv4xJbxca2;hbs(gI!uNwAQ-+65w(J1f@Ab^Ei$mt0*7-gu8@-nkng`zVPs1+ zYiBC(=0L``fIE|0ytZuDm*d8Ky?^AMX5ZUCt>3<8%}x!6k4=~-XFn3;Yc1?MdW~5B zcX9MCCU5MNI-#_CNFZy+aznzNcwt2JjyEwJqA(BV7kxP$>I>~`HV-W2kS62`tjM&U z!&XmPF_|8)>I@}jgoP|Phzar7`T+U*!SyMLtAHa|I`(IgbSCbNGx9j}09$$3FqMj< z*%Ua^=mHQ&)6!^gdzYu{=5C+($Kb(#Ox&JZmu+WVn0Wf@?CAcTdrrE`CiLvmKPLNY zdCZII*M~BXZy0pr#-I(yGY>KAi>IewnB8xEcHy(HzrKG>_WFLaFHG0?k;`lJDUwd% zXny1D9L&cszvf{2a63NVymQ?j%TrvGUtE-?1XdEyWL|c%LXcS{=Z0ZU?(i{n>Wv>Z zcAVjc;kOHWzZy5;t7i(%Ph}(ej2^XnV1vO2$1WRl_Ra=%YlHO<){i^{q$FXJIz>K@ zIpU99u2o32d08TnQUvxZxKWT1kDNw40Lf1p_;Cpj7)U44aHP(7DKt=o<=G$nkc!oi z+Ym%DcgKp%3@aOE22MVMg26YNZoKu&+c$2!{mbj$iL27GvsCx&0Rytd$dKq;z7P3cy%wd;Ve_plTpVIgh(5kJWWmeo*^ouYW5oZ&z=BQdOxZ8uMuULc5P3Ea zWU3LECw|eUf!ub@nwm-mDY834Y+@HqhrPjgpqCM=S3I@_(i47%f*wd@M1h$uBjW@e zqmcVha0+J*>Y{#(l~W@zBx7Q&-@Y@{p4l%b1@}G-?OVt%J`$$2>1qQ1HiymQBSV0Y zfc@WRwi>jv@qh|ihq)Ugn87`iDTWa6v;jzyu8JdC&8OHQcd~nsn#$mZ&s7$8cf(M~ zB^*s7l`Nh243-_ng@%q-0g89vl8&1pn(%@x!sUy$299@tDfu>!a(dU*8!$omHcG5l z*X$n~9TQ_U`+9gF*9@||aAS;ah9OHHNe2i;sCX^O{6l*H_^6TSFi_#|zyI{X5o-sF zF`!XcpCKQ-VC@j0B&7DwipfphH|zLu_SMfUxpmF9N?Y|o{_)pM##d!|P+Cd7m*`Ko z!2=pHlh=vOVxPmM3&aoYFZ60|;`~5&!q#p!|ldhYV zS!>6)@3r>%-MjZ~=~mww)vJq~{ah>iCmY<32Jc!bZhUV1;zG|uN`pq@1tyFu`xPEI z&4egn#&HufK~>WRz8>z47)$~dA%oFmFwTKflSzI+i|u9M zQPW$Vx;Xfq9r+iR+-B1Tj~g*6ug75asW&Tr=bbMCqeS`ai=&<$)@j{DpU%BT_3NLH z%P}Ok>to;856Xr&tdvQ%L>?^?IyE-EPVNREJ~(s;sSILIA0MA!pCBZUadtP*uygV^ zxVZfnHkfxRrm1+AnB91P4;4rIh!EdPQ$ zu@!IFkj7m>Mn0X>XyqkPvj3y6PLP;L@NbEaiLwOxduwTKp@ImJEW+KfXU2Sin6Xrt zH?dcCY?X1Eiz7FEM@=WDtYpLC-Mg=fN}EnEe{4DLmp5YYti#7PZ~py5by8W|uI#UI zv$ns!qiDwpao$npuKw-)%mPc3tiG+s#KuOhp7!)n={ftM-UGU~9v&5EdFDxyei*|{ z>?_VgcG0=-D4S=j5fV1shoAdu_RKItrQ=_SnTq3IIB0+)1-7UH#_1`}Y7*-+{d_nk zIwTMoFOj8>n_)Dk$p7kiIH}6{@Se27ei^-|yz<28L4!xFD|tHP>C$zh24_4m=9MXZ z()+GV3lCX+=-D;+^}Mu<)y~fvHag;{G~~pBx%(QV9-FiEQeNH%Tjw52ZLn|df)hie zqY=cdV0E$n$o>YHdaFuT?`dN-bN|t1BCf9ylI1 zkZxABl%cfz9FSb&OpxrFn|KbSJQ?_~Rn^bCtdQ-MA+R>3mxFOAoCCIL9TyX4^~e9w z?liNJc9$e?puRdG6R)<93I;22O~FsWGE5>^b3p>5rZmpP-X1;bttEq2CjFMYa?s+pMm-wcU|e>;agmYZdS^~(B=2PnCuH^-XR(a!mp!(= zm>jUDY;CJ%!zbE0tX200JXcoOx;eX{TAH;kEE5g|&4((!7 z!`t>4dVtea9b)($I*~@#&DzxS_xBZzOs8uUXrs}UO2x{hy4D*>BxSic6lcsqQ`+)p z^>D`_>R{UFM?>0VaMA+~v(qJ5h7Fo;o7T;mG;EL%51g!=#vXjHRj&E!yO|{I)DEX6 z8tu)b==>9frN&7sGBmxg*3^mc5<#)y4G}YrvEF!-6rRm(7RQD{L9G zzfDAJ1cUrNy7T<=98 z$m|UxKPioLLK6j55%ywHDS+pgq`(enoP$u=@F&+MW4aM6REw90!Xf}G;vx-FSwy^t z=NYyzFE5}O>J=IiOc_vpebAz(pV<#7+-uYc6O;UL7t|`@f9Jn{>o#%ul&;SoSUqjl z>H{x0e^HJizQss&8yjvv!KSDy#jd3r)Th}nbvqks$NeglbmsJgWkLK1=T!ben#~=uKDG4Ic3k5-EPKLO*8kPevEr&*=@usBcJCfYLPcIW8K&ub%y?MyQW|N6B(BAxoF{F;En9|kSv4&< zH9jUWCUM&3T{}OXo*2_GrgoFy>8m@3#5RnnH~-n>ewnog7O(1Q?c24%DX;kWl1=0SDwln--#tyfE>-;Y9S$o>1am3pv;jcIuee#7hx!udP%%0e~l5$PmGxG(7q&Bx?aEn18 zUwWNZ8t!Tu&;gTf?Q%{tQW!ILkD{%r6_mB>7j?zGdF&_>RY?ksdG8sL%V=E7+QJ!_(05cbvRIQRl^0(j&lnj(Htbo;I%kK_S$EK}j5iy~S zBWfiF%h@Hn5JllWJ2`&9nQ7DBp}9osTobhEA;dx50IRyR;Ccuibe5o7a4Ge#et*Z0@8&37sFq20d&mKUXkg<`XT@;#wDLup-f}j{RC^CpY z4tTN8gYz~#KpUrWODmaNapq<&W<9=+PBi-^Mt#M4Uy;R{trNa{{c7!&IKhX&_;~QC z0sUUh6dRQ65<>=kI(qC|qwKfEkdd$E=YE`Szm1mASBNU<9Zp~PCDL%~##5}B+6^dB zo)X!U^9;Wmg!@lyuDV`2qHdJ-oI0iDOcrte+g<9*mO(cO7vN)xn0ga3-dFxaIwzb zoqBBesON^gcv1}Yp3u8(R@BtE?X0zWxKF=gwrs@VaglRh8Gik_VSO@N#7|DmRD(S` z55_vSyX+740q!9hlp@}Dx)3v7Ifu1Vk1GJ<7+*E<8@FM2Y!)(ku<-|!bB~%R=TOH6 zOq?EgC)VxB58-?1_M~u)*2uD>DDSP6e=7()RwQHtofE{Dg=jGunSgTwiXmPWLI(y+ zm;iSJEA$zE*gM>OJ>YLn452A9zPPK;wHD}in(@n~7hyZ97ioTkSYiSKpq%iN1ca%e zNEOx;B>L5U`Llasi~K*u=A-Tv{w3MZ<=vC)?~Qy|s2nZ%Ku)5cM?Gz(W)b;H?h+rN3GZKs~=)W6pD=-j3gnzX1YL(rO!V`g>i zJhLmC`ALfgby^aiX0h(#X5bSdWZV3qAPf!Fl1TSK`Wk8%sLkYBR#>;R`@{3Zu!e9c0-arOIvKs0BI4LA;vl=F6 z$DQpM7h&lYm*215h`<dL+49AF}okDaZ7WbILg~2vISP11B z(2GGjgt-U4Ks5xYh7y^f&XL0rM{^F>n`Y5TOfX%E!)$@mum(dK6`o|+++wW$_|M>l z&@kMM9Z~>BS~6ylQm;8v1=4rqAjxkxebrgk-j>|n@10)xG5sPv|$P8qXhdW(z2Na?#81c46(qytysYBfzG}{SDS}{=u8fS?*y}}pH=q4&V!p>ovf~HgBykqiFGa~HgGlz7{Tb#QFx2bWr#+na)ZYtGFNMLDqW~f8D?Hy z=Zn?rguROLC>UgK$2;;F`p%~D?-aXi8sgv^kV~HGM2swc@5exK)bSlPBPJPgjL1!? z4dfV6sotz?RpTUjcI%$&JbY``y5M z&n^Ajax?NdbrbGp9`*hD+i$P=A7eF-tyf=&ykYrb*}=OZQtvZA{!+BYXXBSscCiMZ z+Hv#OKIcOg|IFksxA?5y@ZC2ULw>i5@~}YX2%u9XGc#Z*z>W(7*T5B>$R0*Tf*j!7 z@8tS8S^-ykp(E9ct1g0`{dEM?d1C zlNmp6-*HF3i-S31oCF;FaTf=-C+Gqn>yDgq*j|$gl<(mNvrJ?UlYtf>3+XD@={Rrk zJc)V;QB{GBmFq3cp@Xqy_^%!dcA$0tfO`B}DT8gZ)#_A_BUgG%>QR9pA*oz0J$7=y zuRC@EP57weo`5lEp=Bi6%4>uwdG(X@M5e~pG$Ol5h9gGi0 z`^HH`E;!DS%e9&2d8CNbW#rOWIr4E;WR)^R6``)+9=PtRjs9+g;;LgnU|Ha#T z07P|c|KoRV+oefo5fs^7U_qL6ML|%ipn?riRKNyyv13DHi?O%(VvWYAY4%j3=`ZD_ zzjRZ4DetA5yu=jQ%l~uc?!uy&Ct!iuutT|;^MXbRHwLmYhuaWu$&H*cr-L%ufjv(KdI+C=#)Z9>@9|9-l@Y0dj< zmak{OdZ4jyv2n*{*l~c0ee54J8T4GBpCN&X{VwU211M6D6nfcje2#HRJjYwD)(+?JXvyDmV}4LQuP41nr|TBs#=M@Szx{5Y zG9)@udv2DqbJ_JdJKeWjpR*I2kz>DwmW-*(QE!Xyn52Bs3vF~OpUkYX+ zFDJK~jvA)Ka~?`&OxlKp*+m;ziG~?UkUoW z##}@+y95Ft-n*wqCC*@cl1u=frcE_dY$Ux*VV6u zhgz?X;cd90w}JJwT<&@0uq^p2M zPyd;8hDRLIneB#$;a|n<_+#-5c|Ax_b&6*^F3dSm4e~*4rr-XBW7hb;>pB0q)jL04 z<^ANPOHcc(yR>=v3yVG9^;ud!e}90u>YlB4PZ~Yr-r8lKY}cY-v5DGtsd4N*4Fl)g zxe@hqKe#*#W9$u|1ElNVAb)tGAfCehD`K1p?1A-0Yu;P%_6-bF46u_(h+qLo764Pp z3aJ8UIWpncYzFDJb;&WOVpG?C%1(a5PTOm2{elAfMpi`P;0CwctZ%=~&NXTq$R;KF zd1NH@Nb|a~VkK_}$vyFChY7Vo9}foy3JVoQWG;kuCIL}}wjy?jP*j$IMgw9`ob7@K z2&~8#Z6jXPu5Da6BO8-z8Ab~FE6|ql;6=!w4ytt}SyC6$Dg`$;E~KG}@E8cvI3UfP zvKly02#R+mX$_)~2T5xX6*8EaVDp@ut+HAmOYt|4fA1;nB{@lZ?y)!DSu;1|?aYSt zY;VvxZTa!bFL^K+61-me==kyN)3lN7SpBZ!Vl4v%m&O#dG|WZYNKUISIT;VdHoPNY z&Eg`gh2}&88XzEJpTdPY#YL!dEyw4ri(JP^AHd~0>I{XO>w;a!eG=DYCTLBUE{UhL zm*pPXb1y&j&e}P>-s&~yR(6+iL0i75`nDud8;OZ3vt~{3`tT*!9u5I<(Z8YESm~G= zBE$)4LT%2t1Z1x32B4%^>gg^T-HfXRH^pr=v~>}d6Efl`UO_kue^>aHB|LnXCs#YApiyj zAT5vN%tpvwz5mshju(!rtAp!e?4(I!wH<8QqaRKkHGbj87xL~rp0H~3rdN@vP#b&a zt+(D;oS#47kpcO610FfJW&GUGZmTA4y?55^M-1ohzu%~R%>r@qEXgNhl^1Yst}4I8 z`E~;2fIEqAD-@Tds^2_`50t9_eNM_#!RNol1;}QCE@x4ETQ1MPKS00E`ttISt;j|S zJ3#|o_b6bnAL2a;C{O1ws4{k5m)}wJoAw@IPV-Cp-qZY2tDH7g;b)U5A$lDmlrKCB zZC{H$6Ueo$sT$lCt zZV|rZ*LluxD$i+v@-RP8d8`fO0LM8bjy>>OVME(>UY_#>q|?EewJSPw0X^~#lB@7qs*_pjU5$$q-i*8O6s&$iX8wwksu>HY_pvSo{Q?ScC>`<6!^UAy*C z_RgxaXVFCTiMNs3uID><-vZV{*Ll8kx~}Itci-}|ew}C#%CD1641N8f^}5oex??On zaG^EdIcTvTzZs1o&chk|Cvu|Y59P!Z1k=!FkpX2Ca-!AYyf9eV3>L0E_3N^T%+Sz` z$Q3_nPay&6mu%=SyR5xJJEvQB|I7xnUskh!z0`YpO3L)!FKJ<`HMj42)+Hy`_56NP9-XV2gjWuWAU1jRfN&)s2sk zbC)G!y!hEWYo3_A;>-O_w5|Fsu3vNH@VdkHU)k`$JwNQemnqw^oepYv{mi+yiAK;z z$L#r(SS|c1 zJ4TA$i8J8HR_H6l=0y8=yUW~;PQhWaSPYlBkN`uNC?<06im%`s%;0<@}%+CNUbr-i-__(6pBPT8(9_Nskx^BHZ>BGyYhcUg-= zy<8W8PS}lhmNUz|7Z#irZd4gCVSzvO*SvK}W+Xs-vX_}7k2e_Q_R zxwF5m*u820-C|p`%X}~-+TSlamrE^<_8}cQ=m^L z#8-A@T@^km&J+xUA>e}o|C5tDiK(Zw=vPha>L#wr&0RHd@@ms-G0i9TeZ6AE*QT@k zlSj{-a%$?dGgGEkB=0%l@jFljF6wx4@OSJ1cYD}0#SfiM}oz}JE7ZE z&_Y7>5a&b-yM-|!(i#@iEhab!*%1uXQls8d=el&n?rcOCCZR)8hGe;-yKg*sT zm`-KV$?lJSw9%IL!`~1604IS9OYaBdQ|gB+rElm*8^s;{0OFX8(j8H}T|aJ4{rjB# zxY;PMi=}!$N~s^vlOPMc4xZg1KT6{KDCK&7TOV?Th*Wx}J{qDPx? z1RdTvh{pkSBHRNaaY!eG3#AigAC9<3t%$ZGWIz(lz(mHg!TT#l1OkB%IgHJadYSn4 z^6#~!LoZz#&!!+ED1$wz4VuWx*ehBh1i)DKmi-_0xADS5z*(#Z&a*2v*i_+64p8Zm zO1W>GQ2H1cE!)<7!4EOTttY4APi#&{dz?GV{ac=8S&bSVz0 zScFzC8tOZEqOBa%xlo$FDM?6~VGWD!7Tq@X?wG^y_v+qW!Pl|HIGn#W6<#hAw;htD z&w>y~NJd9!0n3bRWF z&5`c@;nKE`ma_3|3^JWfd4Ai<{!K%JEQ|LP4S8binsrByu47*8a_6Al=IGoqeSY5p zn%)E69s$cJB4;Bl!1c>PQ1^fU0tOnnQ7Agk5ku=>@^}*KG^V>Xz{W?@q#7LE&_if> z)6?|eIBtJVPgfjSov@S22i=P@=fApc(?93`yJ^OxgJMGiJIPa5%FOgP`T#K=%GCAQ`OjyWN2CF%P z3wP~`VD5LqZGccCQUjs_3|QwW84?^1*yr^vgsVE>Poy^sDGfV# znEh~R)#wuMD4)&)yWVwBi`ytRRTaw8Y1QM21KR!KUFYm~jxLa-({9FR?_jC+6{t`Y z4r!6{deF@Rt^l7>7wCW(f81C@*aFC2a6UV-F=fbuBCPST*3^hp8^YDG0W&L1D^Zjv zrH3<0tQC?0@Cj1eFhcj};A0*#79^)#WDBP6{%Fy>j}K6)lz(iQa(}hbIRQ*}(l%OvrD!Ce>p;2NV9);UecTGURYh0_8CXgnR`{WpGUaxrqd;kOhNT zFbP_b;MfG3;*e_kt{U(+OcW9ProD3P!|5|VJWAhI&vs`kwB?4BsgGRP^2;5OfBSj! zg~JQamNX6Iy2O8!5N-<`0U8_Je`j;JJX8yOn4Mq8Z+<Rl4 zPKuZ6{<{Gmz>z$K>-`Ni(7))q!DF}vI7zDx16`J%fl2kwbi4;=i_v=|Qg-P2beHR` z=On3L+|Az)`QwUe<@G|=qw)^y=^dIMJK3^c@Dh5TQYYl)^q`mMeb8?)^+Y78aBO%>beuXs9|%^(7V78+MYsuKWve=jLyaowznsu6 zq5gi1@{d}(SWSU`A^stNLLn1@8v$rqr>qkbg|t_|L6X(`kG-drBsb((<;V|s}LKfzJGMh(YGc|dJ7*POgXx3kE-t9%-%EZ-MDeDJ}0jC z5#hJ=5czq?X9VBhvm&H>j2o^iU$kDg>DTGLJjQw7aJ2Qlfj#edE(OoQw+$*i&&%Pr zA&tt>Z+c$2&w1T#eCu_*pRUt=1Cn&1emv)~^@jT>NB5~5sOD&=0cSxw+t1!`w8P=Y z(Qy-aAATDm`1{^)v;%8SzwS1)^*XhKuSL}JqVxSckG{$P;z4<*j^)I35S@URhR!=@)J`}j<@8lr`&)lR^?1)B(0!YJ9T%e9w>EPt0|Iu?Q1`8vJ@`*A zr|i5*Ih&&#StmdZdJgXK*5}k2*F9&D{>k4@?~Q~!0N)AZzJLBgztLJ{Kb4pMiFUTx zJGRQ6yd9Vo#_sxkR6zItMxUs0r~X^rhflOX-R&&zp75vT@jR8M_ZbiB&l@pO^?s{4 zH?;q9Yx`jtLu?+k|MFET4||L%@%k?7?~~{0?{nDea34A5sDG~asr|6uQT-}Lgts5h z;eF7788Rn`s`v^2?a<}$8}>rnABp^V949Xh|J6~RpRKIY*~(y;^^hrlP(Bm>C~g=5 z_z+RZazJszR==nl;)Wr8!9YOX4oYFFiZVGtrd;vgw)3`w`DdQKeS_Z>@6}%)dxH6F zWt+4gF5dI)YWB{SeYafRxaTtSKC)@^Z9J-7`D7m?gpywOqDHiN1)5X=tfCua0e2)(r?ddA;7Kyi@jz$5 zfk_Ku1a{0A;*$)rctHmRz zCy9L_Ps2ISzCw6TSCO_ooXrCiQ6+>xlK3Q64p5bktU@@pCeYY81}6yFwa$c&+&Fd4 zhO*A*Y+K&mvgPfq?2FhjIsL}OR2`l)@h;wvYOPT;sPBP$sb>IpN{%&U_}Vg@+0<4FRyE; z8#Hat?RA6jrMzyJebJs7L+WPN4Vt>=_Q`|rWk~%lmbZ6$S^ez#fm83ey>1}Bl-2KM zb<+pc@7P{9c-qYRL3KNJ)D5bidBYWEpFU{H&K>nsXmI_m+oue!$M9h`OtOCmc>?F;slmd!%Ic9}3- z^O8o1BlUS8VIH_4A`wqWqqN5u+wtm4+r`8>x508+3*6Yug52#~R45g5I z&I`a>p;*Tc^GT2S$;MLlO&`=Cuu3kwQElawXCuvg9YmPJ6=)%3Z45Fg&DsmvZQ63} zKMmzSvzWcdSdS|O@_~mR96n-MLBX;S;Bkk=9_&RR!(kKzHPWL7hk}6|OkY^Bw zo4^((c;IYI8D~NwXA$YIlnJOFm$43IfeyU`g0>ReiP)yBlt<|QCGc$4Ht1vw3!NEQ zBuB?WBL~BD{mxvj>j+xC4BNDwG+gShIsYOMpsRae8j!$iBYGGk&N@1b&82?gGK;tP2hqaBO zn~a!ccvOn?G%W#O#1O_wTZ8OP&?}xp4yUBFUdEVm!5lZ4fOUtN;Nd2FE8dj#65P&; zLk3+9fo=zneA}2kVnlZK@ZqSiSWFmBU-6G#kgtWRV_P-|*co%Io*oKxL?jZ%9eo0U z@($sjK;9B16Isqr-?O1pYR4d#c4+bPAr-k}tNT{W zIf{9)qNPbXCO#(_RLs=opY(ar{F7r|h(adXFjVzJ8@dAV?G@75AJKOTvRUv56$dCey^Md6#Ak7CbbyJ{sSD&shprZ9W-*fxcvj`b> zRHXKkNj;B{@^9!&qxKq$V=KqhOx8~R_ebriiL*;zXO?z7G+brJ=M2xT9oujC(57Pa z_dnWt*@t9G)dTJh>UG^UO}E2e(|E6$u#&YXlcaT63CJIW{NZ5Nq@+`*8QGnH-GP8e z8;?*!YE!v2(#o@1FxYu1GKvHPZczxM!#NbUF=@xA4%@x?w*0cW8N>VCJ!Qzw4eRm? z=1XBa62|l?>yr|5N8&JirnMh)pd38h$yQ!W1I>g=d~oB2K(QLIkUIul32#rQGS;1~ z9aCGcJ@CU7?ZV`S($`qz+@o_Uvc^~SA5qpsE>(=kKA~LhDg7IL%*@Hq_b8muq3=$l zMIo6FZ7MKOQ0>@|$U*_7US@;!Z9_jalWz|ht=k4pxT9@D?rA@>+g9%_o5Dc61AUaIF!V}2$Hz|tXoo*VR}eo z_$S@dJW9H|dDOmrTJv5~$VB8Wct;wo+z)7Nm=K*4>F*7Q1Y{c!L=xb)Z!dk=f}(s0 zV^5JECbFV}yQQUOWB?&yA{+|B7|5Q^F7NqR`*;6{1>?poj4aW<{`d|z**`GK>vie76DEuGJPBlo`ud~P^?fr*NeX4y}z`DPvT`FafkKX?U ziz$_&wcYnM-KRalHsOO!Ikxg1R-jF}XBi)lr=>OQG}ex)e2_zPXn|J2o@qG;YGBVL zn@kdm#QJ`_b>PALU@~4K6upAswDpmOv4;l*|k> zjT`bf93qi)c!cUXOc2g;(1-{ufxC#su$e8se&MRIOKb*GIUxNmIjiy4si<4c`7CAG zVt1{P-QqQ8h4u2i$#yd=s$899e%)-hz^x8H0S{ z?OU&G8l1Z_Hf`L2afMAUufBD9{-ObyRjF=D$fobM)IE|vH(_~x?ZI)^9;~^uT5q4B zKpg-b5tc-&54EZ^GQ!W7wg$>PgRKEmm-5_W;zLW2#PUcOkhxskn&UE^nuXRWjsQlN z21gnSnqHpU*1qPq+x?Vxu|3sy)=(=;dRL{oOZA7E51?hO&6baT&BwS_%##KxF_6b> zd}VgQ9*MPsIikmVi}O*;C>R5LWo(SxW<@I{gCJ0AwGS>F_3^&vaqW_rCw{Kw^zYA} zu!r*ZHi~7^WF-xcs%Nkmlc7Oi`6>pJB2BjYi{EO!b933VVi~jC$t)L+di#)g51P0> z2S|T1z@U*Cwn#kN$o`(2tMwAU70VvK%g6iZ1?{6d^=EGA1F=HKDg$?cV2N_*gKt1< zA0(TB3z_1Ud%S&)USN@jScI6zp6uUW>nncl=)(cwh&WP=0oN)g+URH81!L5hNPrc7 zcmgyfa^neXFohw(*|FxvJG!s7EiRC#2#hOF40(V(a_cd+Y0sW7fipq>=h#0Km$f|n zKN%04dP(CUvD{Zy&-e74v-&0bhwKCGa$+LurbXhN`7B6`U}rGz!uc2nx-=2D*;y5EXs;F7*9CE zEGW8;&z3;M%tK?L_;vQ`t+yUqw@&Q0dEeHp`!;i4b(r1HUIY%?M)EH^Pu_HJ&sQ90 zQ&aQ{KWpz5zU5=D86;P*Fa;?IJ^JwHv&05gBu@uw8GDkQ&_j@y?HoPC+kd-OB@Jm= z+D1=ee~8S(v|!jA7}Mtl&VF^y4TTU_49I#mZs*Pyw6C^l-`=u!ubcKC7VL&sVqL74 zZ}Rx>Q91`H+FmQ}x7R9`+i(A7=T4&e4Re4} z6wqFa7Ng#wqUZ(-)tw z16?xh--~H24?z+S6?*a6l7O1AIwZ=o0LoR8)X5$X>^z_zk3b1-bMPLFbf$)7~0b&vySLFJf!=eDg++pfS^ebc(A?X%E55;E~Ybs=t<>HhjFcr-|1*yQNU6FnDu35 zHvO1Azw*NmwViCLPR})3v=q(hS=KgJf;quvQO5+a0w2KK;G018;ufQ%FW24apqJog zpecCS*t@ldx3Jr;Q9tVtyINbZj+j`Hjr6VIOMcNbJK+jE92G6jxz;6HYDeYyJ^3=b3@A#Z0u!K)R z0NTrFKMw-khwA;;&#dKRjD?HJEASym)l{K`Hh?y|Y3ll09Z?>~g~J+`5_n+Uv0IPq zeT$zZ#e}7xT_fzSiV#nA=2)m9Yd}-1Pfl%8)9uI3{$Ajv#m1GGJeYmJHSTiO7RfCSda}hRo3F%{cM3}B za*vBB<7gjhopV~PGvGSS9qtM9^%}FO3@|;$`O!;b zCr=s83U5E~@zWy~)@ZN4+C4ox>CqQUd=3V%PuY%#PQRx;HhlepiU-9vcChfuyrIPG zn6OiOL@5Ur+du|h0#*iNH1v%FjtDaT@nz0vnVaYq?Ht$LX}8K%94Shn2>7@2St;ci z?Gg4S$%I-wuWwU}ri{ZrY!x2S4az;7?jSP2DmW}1DIt)X(_P_`f>?t+W$Zu?=I+jw zaXtMao&E3^o~vsATuwr3Rj{=H0zlZZ>#B6E2p)8dBwA{x0lo`rI2tN9suQIOr_f@YgSn%4aXTI$8iPw|~Q&+C4msI;Z>|HJTI)oYTsjKjK}=hBcFwI*o`6s={y-EsKOKm>m{3r z2wujGc6<^$;w&l@;QgX-{0lc^IV2^AdBKYFXA@Xwl0{$KI8_ zboh(`i;9XC4VYzrN$T1Byf|c8@BVY2LE4(Rd6`Xv^XC>8&db-19LMaP3x;_=>(WMd)2xulmVmQeliqlb+uoGj3>*A|!ImVL`a;TaRT%N)rU5v+$a1V~y zdr%h6H4D=AqDhmAiY8CK_96Zh;RgkoKgloQm!$G*C?JTeeR$S}f@EuzU#g`2_NLSD~2iVA*uel0W7YxRL`>;^-~RR+xdhK^V4EScECI!US|M zjzv)gWXz^yS`HnAU{3@(Y)x(eY%uyj6VCp^%FSD6HZFx5xUf%hKT}cX`gbm+WG1D{ zhxRo1ui1Uag0$=cb9iY)J{xLG%I=GH+Uw-gnup;&KEG0UJ8`BB#39(-Z&Vot0r5hF zD3u`HnDiDw9&iwkn=CbHvuB(ws(WlyRGj+0{arD7ZFp>Kc(>SCkOg$P4|KT*x_JF1 zT@0>DAt<0zsCOu;1wP3|7qg{t7&m1X;y@Z*6$4MOKe%u!V_O$4-n40Pzsz3!b2Bs1 z|D~SG_U>Ei*|>l1=wi8&s||AsC(=818T)N@jf?85(l;-5 z@0nL-F_-u1(_21#aG}Sty&0@q^H*tka|b+EICg*sO({O7PHTtIXI~+Uuc%})NFnnw z-V8!OVRc8RS?I) zKMPH6FeYrE#oyY-9BF0g*;ILM4Uho`Z%{MzR-`oF5i&S^QGDkSeJdt!sfbJS6gQ3< z*k$ufb(hsPHZFPQVt7pR=S74Chr;QdKM#!)qXlM90s0&sqbsLh}jq^AYufHrw8x+pe9q zQhUSGyC)fqHG7_xPm3|yQP@f=?eE~7Z{wYx;+?JbPIsV8$Q@b=$%+KX3i^cAm&6u6 znPBns^Ye3Rp_G?H^0(RyR)5L9ylU)`qxT)2FyYX>cdH*9Iih{9{pa3$SupdZ`D;(K zzpqVfSp%P~L-%qSr;f%b*=39rK1P%@kj5xTn;2>-58XJsQ*uS8&db($=YGfT&M9E1 z27L;bkF|s;)1e7e(Kwy+gj1M!Zy45nC~|Xhxfp^C#NSGiZzQl^iAi9;A^fg@oYpto zM5a{Ou&~+lOsRYfQ;2;bG)vVFo4}z!9Nlgov5KX~3>UYs%<&BFeE>ahy%fuwaPnD84gK88$V=$*;HLT zY~soVqagbvodTLT)jLn>2NoYsPa2D>> zF)7nYVvNH4c98OV5u{CmjM6Fx%`*qp7Lyb?l7W=0scuGALH*)Qn;Ua`XZFj@?DhB2 zDVgQA5^p1Dn3-7AM#HQ=`5{hldN|wX0Y=?x0~;%*yjR1#MkLXt9hL zofM2AAwX6z8L?;bpdkX{NQm)4@_l0^Wm>8MyD&1R7~WlfK*C)7(O?jw=h0mie8q@UF3K^qW-s{19Ct7n`?3&U?`CcgW)rPG3Jxie^^q zha$X+92nE8=Q(6?%vGVB&UU7xsGO6~q1zBR!AQ6-023f8N+Fw0j zap|BXMYqq)?bWU6oKOGM+`hoi6&glOH#J?D8#i)IY5#`&xtlE`>$Si8bsm<}Yhd;8 zcxdTu?F>Vc0^UU=z;K z9Caig3`7S0ZegOLA~pelPg3TPK@{;lCft!bxC2>`n5&iSpQ<9Mz~WQx4uvb0PB;@1 z;{eVSn$sN&6;Kql38VKXg>m>p7o2%(2@kb(vC+Ytumh<=2n(STiuiy#5AY^?5Ltyt z_rgvJzqdpPSjZ#X4q@M$xh%SWx3cJ4GpZ)7T{~$)hH?4fv9amC*1)$Q(^Il`1hg8vCxCQg`q`?Ra1h)a_6wzrkI69f)Fh%r7 zM1P!OKO(i{?$)ZFRas@e9%a*h>;g9@wfiB+ zB~KY%5j>r%%FPI&mdhm=ECz!u7fz^bn`nYG?EZfKt)hu9qT~%En?P)^7ewva_w0WT z?eDYM@QRj{aR0~JLtkax4=X0KkCRW^zkyu+7yQKxLcD$4MhMBxU-5SS7wue!gUH+L z-B?u}_z+OIy@8q>2)^1nZR#c^YOXj;3r7j`djQ^d74P#D5;*s@8WpnE;fQfv7y|=^ zU=IP4+}M8H9pG?0k4_c(+x-;HWD|RnRZ4S4=UJ+X?md+@7SE zjxO!GdA5276jSXiE1jDOTr*_%=0>#T6#DBXIIIN7Da!kM6X_FS|H!o8I>ZFiwvt`m z?#4`8w`yN*HmF(?YeJWoX)CF_;C%;C#{tyQS+EF&oT_~wdD0orP!P}wxLhCtP|Dhl z?6{WjE+PKDl+#e?%sRI!vvk@#H{$ASFvt`Lr4|brvHH3L*J}UUl+8?@x_D$NPUPL{ zr6lg3XG=`6&QsRDB@U||I;w|%NqoF-FE684u5WyF_?-9%E5t(3#+iS?&{)tO= zZYwCr>z1Jw5A7B)w!HVSu$Sd;&6$aLWFke~$K|8it?K8Xlq1dy71GEz@#M@309X3# zz!7Z{&(bW_(2+Rh7QYy?9}a}=qPGHMaO`A3pbNwr*i`jAFW`1uZnj@bDHynDNzLRn z>)c0|CHI;5C&WZG)2 z5A#AU@iW@5SoAe)=-hGIz0@bMxe0vwSPFBmF{!*ac3&)5(-Xj@`Le#j-8=P zqU$B>Vw9q&8);|=&A=`O*92NsNuLtn2S_spfrB57qUtt}KPZO1D+HN6yLIgx5fTBO zuiFX{BI&YsIc$Y|!-5jajnvnfHtMG?TQWVlIM{7Pl$+$`*WENCG__zrL}YOe%x1@K zpKn}oG$x{-wm4g!;2{qg($M#kk2p6l^wdh=SZ&J*# za{+gRy$SoU0OK!2P~C8in`G@|HP|2sjEW-y&Ea7o!M;9T9%SxpHOg?~v?K8lKTZd@ z?sTM}b}rqt6ekA5{vpm|g2!t}s?aoITqslB47^ht^tU^p~!bVhlw zsU~;YJpaIdi?5c~CD{)Jg!DU7{>YkR7PvdL+?JDxI9916R_Q@DTmgNgWg&JX| za4+xQ!7$dPo6@a|($vWlGKL}0AO|*u1P4h0CO1=nTa%xUyJYlW9!Ay#?kHi3cNMyI z>DsN{iz(jBAS;IY&MYvLnF0b$^}fu_A4T0fU>+wG7aIpHQYMwpm^P(;^2G7A)nlth zS5^!kHl%FOz>?y^f;^o2o7KBl&-B#fq{R5x?$LlZo4ffz-=+Wggd^)H=PmkSgv98; zQxE{mS-q88NFi&x{9=xSRh{>AlWIrLDeX!!XAS(F_S!kDp=SJ?*(^RIEzbVvTsCL? z_&E&;>1lDE4Qx(L?c9d=jMO;!@SNG>$IqQZg*@k=O!eHE422SZe_}RksKp)ph*#a_ zHjE$N&=8lAn$Y|W6{~5OnV6QIpglEo>eQjp**Wsnq4o7cV|w?w_I~;FsY7jjbEWt6 zD_Pe*(697mm&@zx%cJ{bN0m*X&pzU3bitODEf{|f)oKy{^&CVdH}EEZtmUrYqc)*} zk1^noT>t@yGKY5!@$_(mUl3agoX1kPPBf;N)ErbLO$O^}h1${P1YonbcR+9ej(GR> z_xAVofz?bOkH|D7P>D>-z=Ihn{)&H!2_YfSdlXw*q>0%gO$ZUm@HbqWs-0wGm0z?& z-fXaT=kqmwx7(G%TRj&K_gq|4$ad7SqW-@xDP%F@#eF++pP$I?ZmiAQ;90Q2z0vN@ z;%c==e`VF3AaY~N9HJfkXhNqu3a*9qdvQW1X(TJ^r@dWGbDT97LH`a{G$_sUbq+>{ z$aVp{6eS1n0o<7w5Oyy-LYNCZUO%+84Bv^{7s(01T}ekqT>m_dZiGkAM@9l7nxGOO zJZWZI$|v^sPm9s)loGz|$~3)g6-sc+DCEEh6dX7LFi6@%iJJqjg+gKtnbX8_3(ndK zSCBQCPkFLsI2;0$un+TIwOX4iA}ZErrB3KMbLDM)5_+#YF+WP#-#s`WyncF=PkN8u zy?LF$xS6yuDuPag&U^-Rf>MG29Ne7m#|#cXhb=9|VA9-=Jt<`=roZ2^lR^t2lWxbe z8~C#!{8?`_6BCO+9MJkOv@KhTw&CcIKJt^wM}NeKiT${Mi&;z=OO~ z451G1sQ?Qh7av?PC=Y`uCK9PH6ytVjQ8iDMtv9yoL=u{bhz z^5Db~>vydhvnavRTiL&+Tc9bnN4if`?cAi!ew4lpZJ8_|Zpl+GV^{lBpA%$!PlM_~ zAz_g_r$(TUe8czLa|1clHO4kQrgRkVT zbT=}0ya=zL(-g4<_U-s#Zk4DIa72p&W{M|n_6C?5U=Bxb5dUEg2XiE+jGh*pPnW!a(u<{TV{)e zQY=x2aFAq5GCY~|5g4%0%WLw)?$KA}&q@mV%sX)S|Jl2p9z?VnhGOnBci2)e?A)(O zeiua|Umj&=;$vY+OC{Wgo>!0+T)i3{J7Kby{Mq3H^ZFE&5c`oo6E}0Z_zE@p>?A=d zl)#%e(1!vbCCs33ehWl{)1L61WM+k*j%bJ@mr(>qsKVod*h&W}4IPp)5+PSkax(L+ zQ{HgW)Po^xT5sD4N82W}Yg-32fWL|hc;TEp5P=YufVL6CARi(Lfv~)x2=~rW+uF!Q znJ;c67d5YyWUPv}Pp6wp`z|@!H@U5SI-LHxxrIfJCJ^z=PU2yxuwrreAKZ^vZ?4n} z=+p`RVBbz?rh|gU4k?&{jm}BI#pXArxDZf#18>x6_@$$bQ`)uhMjBEZbt0ObL_{`E zv=M=U3am)&sc7m1_oCj$HcC>Gsv9Xu&1|LQA@iG4of8m*bhJ~zJe+2j0xyw87(wmK zDIrk+BSzR6(H$0jS(pN|zCkroA|*FB&KKQ~g40cPD-R4rHWPT-!o#}4&g|z4_rALk z(UC#`3-D}hlg^KH`3iC_IbB)1#m&yAR}JU_#o{(;)UaN|3oR*b>!h*TGmbT{u8WIH zHji(Nj~hODfmY>U0G!T$-hKnM-yj&>490rFO;z0})2oX1t8Qv}5ZWK!t!rpVaG)i~ z@;_+5)P99`*!~$<_T48=_PVb54jv#eU!@bgDs~J#;b0toRb3Dx;ed8airJFH8iNdL z8NyZw3gZfd@%1qxTOc2JS~Spabs$B6N_a2lcgcJ6^bfQ{X#)nNr4AS%_HcYrUT1Nd zZ*eNFrKT1;KU-Ry?Gjb>3tAn*9Qlf5HpF6%gbQ&unI%MJ_=FH)UWpHbTH|T-kW_f)C3-*6SH+_=m5*wv^AoiQO96tToEw>Y zTMgzGYNqous74Bu)!9eetYL;;<>kG44H=@il~Ve>jC8{IjFRnA0O(~D%>11<#Fd-< zTnrv*h?RgPh}mAYU({aRB*Rh`pnc=^0LatsU5@qHJI(03ajNE3vfpw#=Y&T!4gfj)$t_({ul z<#=0rkS(pl_DDFck+)}hKwN&(^29jhxM}vLwQ+-n9EJf;cu*TFh6#y+pWu*w2)iCm zqP_t5U#oluxDLs$axDR1WO(q+R0Kj|(@o1D`W;XB0TSaIVRk}d{GA7lSP={bPzt2= z2N$Jv@18b1e3JOYtVV6@jIP#*E}te=i2FyCqkY4)L81|F@pEz&V1NKJ@HW7-)=@A# z3{ZZ|ul*V)!dVb&m7P3a`-y)m0a+NcD@Y>NC*WW4&KE8Vy;0 zl$Iw2wA4rj_w9o4TcIxN|5m8S_dws0S{Ae<$>+gKyYcxDKvqGD+~7fh5OMgab;M^R zI4NJX*K8K|$>)E6OyPDac5NmyjJ<(;5r6IZgyt^GrO#BK-%hK8PzCDGlb_aF)M9d+ z>uZ2xk;&2ln=Eu&sQ%oE0K7I3LXKDur%Bu8PCG2J)3yyXGWnI7^TfyQ*0#$}vo%`d zufKA=sLnn?d$z>~yI;k%*MG|+x`+?|mgkInYW_y^)t*93u+1a0dF5|Ak$pSUe(JYf zdfeS_J5i3}?ta^)Kfs!Q&{S=G%O>dV*Tos33;zqTKlV?5WPj7tZ}w^nb-D$~cWA$> z39uOL*6Bu?h{+F-Tz(8B4iOCr@Ry|le0hUx9o`X(9k$?*4kED-ut?6lPzpt%FeUKe z>w>uyQW&5k_%b0F$!>{3QxaL1t&qESq1QTat>gqwCYz}#K-ElPi2=Q)^bEHmeCw9# zxB^R7eKO2Zy|%BEfABO;&93w6lVF&+Gu(ep_L$y@p0l=~<5IJS+^BtTSPQ$18J=l} zcZS4sBY;(q7$uSz+hkz^xB~Exl#<-}00W7ts63+wk1%U>{+kGtql>(45oR|_*tj?EZ0BsDrs+h3T|x40;$Z&4vn-_f^7z0GUp)`a-p3GOp?A}CGU zkyKoml9Hb<4o)g6NJ-7lhwVB`{;MT=TNP}EIJa?%fUp1$0CrT$ zFNOYjco=FSv3VGVkm=O|{ToOl{NIOA>RcuOfgSyEiI@xQ@Tzv(E_7yaQF`h-591)av$!CQe(gJ?lu5z7 zC0hPu|6Y5c<$1`aju;^35(8u(QM+c%gthBx*R8HuXa8}+>U9%uT{C{&y79Mi`h8)) zr2T;ST7!GfW^S?sP3`teEk=H=SMxfMndpoVTjYX1kF0OKu04-S2KNm6$8-<$gbc@u zxD59f>{4`mNI4AiWY;^Gu8smVvVRJKx=(5MZ=ss; zTC?Joar(FFCiZMjQc6xvN>Yw?JUcZxJ3Be0ul7wvW3QVc+TWmxUQ*7o^y+M4Wtsmo4kuRYMxVh_}Y zix0Q##+rYy<;UMHIAo^_t!v&Y-!49iN0!X;UEzIV#T@Nx?S1WE*Txi2m*2IFUl-7&i+_4n%#=mU zAKx<2H@j874Roe_uF-tW{ZZaL=b*Oc&U54<6Q4U1x$C|4>)+cMbvE^B7WViB7WR~U zn{{|r)^O{P9b?Aq0NGGi7yDb%1ngr*J)Zp>x$p_=qR%++ebv99ulx(<`?bgA?JWaUn)zgxyGZjyk8895NF~8E3k46h<4Re@)=36h zewsinv_IguOHLAJ3I(YgB_P=Xx6!@`IVbDKS2ly z4)AM@W->UX5q~Q)I8A{NpoS(llJ-?7XXUYKcC;Y`DDgkLhD(8Lsqk`QH5Ov&>KX&#B_vzC}fSbBpaw1&(xj zGN_}ynL(zRq=JGSsfGFJ$@v9DAJ+U|`#-g^mivILcktEZU}TAa`xI-P_#Lakx@P4) z5-g%)j1=9?3$sLE0N}X%(`1N>Lc8DrCSVswH1Y4`+H3xA{FLOp{Meq|6Z$0J|4aNP zZeRuGfY8tYb3vgs5cY!pUDtIE?HwIv_VsjgbN37Zvc|*B&D&#`F(ck=Qe-mK$_7){ zkZ@0fhZE;oBwAyBbbz8G6&iNziugJ+lkU!Avv?=ZK!Vyug~d62eVw`qSsR( zhe$z3?ct7TW&kmpw~5B5pIxO)*sHy{Rd0V4-WTEeK0Mz(sSu6RjqjtxJ%;A0XGKX{ zv5K0vmtM%4JK=px@jf>pneQz&BX~RvnizI6J>UcJNzfM@jl2%3g+6CcLk-QBUiohH z1eUV-%#tR0`+)=6o5zmf{pEQ7#sA;$_cv3x486a6BTE}s{p~AP)+}><|F!<|%R;#F zIk=vazF3&#hXQf}|HutRQy1_i4$X0f1Nxh}B&b8{($mc0_JuK9NA5UrhUE+%)K~IS zin6ozF3A`+ECVt}nEZ0fZ@i9lPNP_2j(Q!S63=!fz@P@+JA?^dbRaP_EHc!(S^}`+ z>7phqwc3NDw#M3*N$$A=2j)EZfc$cH);_9h2`O8wd5L^Ts#U(j9&F|H1v{`Wh*hWY zAVVcmTR07s{z{-Bk`OHEQrw&NarUvVN!^w2elX>|@kU+dKb3*aeh zU=uP3qo`h8i0GAhqV9P#Rzx6n$KzeE&E!YfIK&Y_uU8B4#7)=Hr_cH0YVfnM0+1sR|N)3Ddsx2 zkn%II^#garRzEgc)pWBWNZJ!+u_8aHBWX{HL5DVQF;G8Rlh~lmUbw5Kdw%DrzFC&8 zX&wue=(4^U<0|6f%aSMLTnz~b508wEOs>w3iV6!&Ko|IYXw+Un-YcuHm-=wlgwZQ0 zIT?a>cLn?xK3B{_#1e9J0>S(wr0;|XOb8G62{yoA|ZbvW21%? zm4$klJNJ$WE15iYK=F_O-w63%{kx?~wQStT;t3_gyIXokSfq)prnGo;d2Xsrr^PCH znf4DuqhJyG@$t;)hCMkPUB}^d-msj5`(1B#z=q8s4>&ZI4#=}Gi&F`K^N|b?9Eb=1 ziNS^wICMh+EmacU?aTYlDK1?;=$8BDovMoOyL$A9{(XlQ_U;oE(m7w*mN03^z`411 zZQk|p_~2Oqd21KejxXt3lN&Z+0OBp>@O$@0U>>Y2)?l3=P%00Cl2{OEH*<13@m)|7y^Tu4{lB$J$2#2sS`5X*YwHg*}KdVA)l6lw96TLmw7Ba z*gtjR=wgr3s^VuMV2QwxAJPu0pTJk$#c2aYw4#J8F@(@|K+n)z3?0xZ3PgoUvLg~k zMIp~%Xy>3nZ!hj01cad#aSuN<&!B11li2d$BLJ%SE@a=ksF6)l^0P)K7j&62Y$Y(1R9W*B7WKwf)& zI!B^;l01uqejR&=2wy@~SJ0;d#VT`1vi+9cb0pq4jo+t{&eL4}{iWDE$g^q^Sae(b`mWG6g5ne)+qqYq;+uTq3Fyboad z2I#kL1{;9jQJ$g#I22Rp1f&p51p_)p!eKg;B>>&{)*vAEABO=OE3l^_hYGONZWs+W zvakbqLPxY2jnX(lGD>jO^rQzdWPHcKv5ZZB^-&yfl$_{~R8dLz{WH$N7l`y;ZmKn4Yn@3CEYxiP~`XVyQVU_bC$&;1(0w#$f zw03}xB=;;yUm{6eA}jaz3kmk?=HD$6hkQC92^mfvLeX%vbo`x5hsSU=k6xCGtPz{H zG$zG1zTK~PCeIv^@M7tFJ$1y=J)NFpwowDxvPV$+PD&TFGwP>Uq@lv?G`f1)0wk`G z1v*R*BM3E*cm}RWE>|4+4Z2Yh1F#5;BMl}3;uzA_K!_Bbo;M44FESBh(Op*z+b$K7 zL?jCTJ3Sh4ob#o0quhxeYRVXR4p-xec_-Qqc9e z4PKVc^Yw@`V)j=Sgv~6eTu>LgrFgAaruQ?bi%9=Q@!avI2;2zw`lAwN?s4uJT-R-l-PcX>SML8xe z5jO5PmoM6cl1yCRbhjtcSwOh~bYb~{1%5Cwt4 zrz{@`WnesUHbM31d{emw4mp`JB_dBifK%vVm|Nh>oW=1hA2vS0nnx_PY>G*aN%Gn{ zr&G@+{X1LuzKweBQSi`$^&8;O%yIls@B=g>2Y)h_9dnZ!0Qd#A zO*XnwK-OQ%^piqQVo;j?CyxS4?0CwV^XHGAz9IXMUsmsow4}sHD`0Ds1gODpnL{V7Tr_eBvI9-7S#EIOF+rft@)Zp+6;C3i;PI8a9?okopVXhf;+?_BJ+NJf5 zfi<+xpyTh_VOI;-;YC}wE^6Goxv^hnX1{)!y=TNnMI^*WM#VR?*eF{}4E54A)lM6; z6iaUCq11dDu~gg9KVNv$V{|>~oSr&PUzrwk(}=h#MMXvsbP*m4-cPa+v}WS5wiSZx zbd#JsIi5I6!pbq=t*&Q%@M+aT=pJc9`si3&WOw;TtIai&k9fkhyBJuq)!I$+HtjXwP7Lk^%?qV(bsvEAtRglG3`KP3xw)|U^GBkJyauM6a^2}fG{Nh{cGV3H>x-Ff44dD32WeRg&R7& z+WhRcrg3oLr$zSMxq58BvZ6Gcm(zCXmT~>c>5}$|Vb~n2HO}fje1_E$ry0u|EY<|8 z`>^R2E2X%D?{cQRx24Lk0(6bN_A?|`?pqN{9ds41nc>?!*zy=8CvT@E!UG_5syKWdjwAL-iVzEj$J_DgG~ zOj&(?;zR5W?em-*7OIgFO>x4XwDdN-gE8%%V*{X@yp|5L3Rb8ic``YX$hw03Kf#C~ zjAe8pf~yPDWS{2t&x#K}ta#ISzwwQV4=#;-!zh1pb>;SX4ZBwTa&^`14YO}w$0zQt``yOLEzOVEVe}->ORlnu_h4b?FVl3qyR=)}$ zf5GSYJ(U0cx&$vkY@8szAZ@_Japn<)^z|3wswt;mim&*BefPH)E=U{f$#@qaHsV>l z%g`48fZdydHc=BDApz+QK`?q&((6)w;&qU1e8scc>F>T1qc3Q?qzxLGwO}*z1t#|* z{4j(q4W+#N0?r>H20Gb*bFcC48ccmwB@7A-=Q3+;amuI`CnbvmN2XM4T}8tr%v2F$HrLGly&~Wc>riS+@;I zRpKC+L2#rF9S?(IlCKH_IS*oWX{i`ye}#oQz^Mjl{d)UXuIE2HX`|N@O4$$LNziLD z$_A3*Y6w-0%Kjj;AXVz`QmHHcR$69%x$t@jE^o-UPNFzJ{~wGM(kyi_R(l_Rd+klf z3Zz}9n5A?>79R^vBanns2NGI6TFu6RXl#V=XEbunzUWFLa_zDIrk9qc18%K_5gwax z%5d~8FG))+DM=+1w*HCQMBx>=S<1wG4nX8$pPXI@G++kc$B_^MSymv3O@f^27&kfu z7*Pkofe1=$k0mETfb39Y8*CqKK+eYXZJ6=lJx3HcVhmoRN!=VDpJJJ`G$DROeIpy8 zdm^3lXgmzWgnaLt(}(=xtki(5no$Zc#w4s*vj=mG8l zco_Na-J!3wVwZ0=t=NaR-TKrI=YE)f!_*po^r#V`+iphtM(4zGeu957Uv+|Xk@LqN zF>steN-q4-aeo2$Cz-HscAxm`*B#w=u3O;TIsbI2@B5C*JI4~`f8b-ArK;jk!!KN) z#A){+9+&VafC;h3C(5=+Cc&M zTBVXytE5%BlT>c0RPNec>Q*V+`~7>K>;2x0^yj`m{~nLum&bGGT-Q10^?F_BI@k3+ z|F6OGhYZaaG$>=}kokjihDJpVHDC&w{d4vy_bnKtH6wCn;%AM0Jj`3i;v+4zL98cR ze>BHT_V>JRU&q7jSAP?~6K3qYtzBmyb0`)JZwVV82dLn(^Fsn=#8U{dYNky?4N5ATvZ3CNcZ&jyziaH zZ%;u*onMCg!-rRg&+)YNhI{h~AAIHq?>~Iu-hcS(Q>vn$r<3QjcN2G(J&a9ruqlHV zrt77~uu4_$g}q1oIYTPGkaLDq*uz*=%^B{eU)bT<=;@^9cy2v*%#K#E z@6y=5<_7xux0sXR>;0;37MQ+Cf9t1F!@3vOyVxxIVo;3rh5_vC%=6*j{LL&}XkYc4 zWjfsNFL<FUaqEm^|?pI3a)@MQQ4Dovt4cJw`&}0&;1`^o`$Nq|Hd?) zTYI8;qspGslWt(%|FIYR^Zs8vf1Qyz_KdY&^p3#>=I8osU>>!9emV7vyLes#eDyR_ zCTLsS=DERsUcRZg?zhj2q&h0qlfA&w74-xWw%)cB;!JV!7v4&sdp* zjv(PXN2XCpZQJNDwbQe$NGg7&xbV1{B`!gV?|(M#WKk@9%|i5;?_Xb3aM!yVl?rNI zzxiO#*ry&+wLCvRsGP-ax9{GL=5vl?z0WZ>F)X%~+2h1ttw-588%&0Ex39$+Rp0c! zMIo6h>QOoR0TorJnLCgXsjG*2eu~$#odFZ4bI)=e*`7|!?J;xUnOJAP_kQKvV`jb& z^W)9TY!ha_h-2>Y3g*st^p@Cj<}d!`Hve;N=FHpS@``5#?}b*pGx=@$ZMi+O-_^-` zgX=58-T1%qrFVVhf9~~}x19&Q^W01AcRIOh#`?_a^uI8di8hU8ro+L8imR;qE3R_Q zzvmtmc+Wk??j%o3Pnh>n?2f5){j$$*_r7YoFRk38;=RvO){C*bi9ftaRd~him4`e< z-ggPVt>TJbx|(pFg|2?PRYjO*y*Jytg4$A_*q(F(^05aeU*+UYZ9d_^F>hZpTu&{| z-j0Ngz|3xnZ2iC*ou;aZ{pM)H=BKVkc1@{?`F-`hjvEDgYAwi#iCd_0=Uz8>@O5)m zE{u!G@vP78-+#`{qeiWq+rR%3W!@RH)Naoq{Q!CU?U~IL+kDqhv90tB6sL#AnS>c_>JR0+R`(L;>_9yH-+u01%`S8O$ zM-`_WpLjlWz5Y9MkCW5#@@B2hyL!!@bm$t;@}KO`Dr02R9^#V3kXV84Rx;1ZQ00yq%{THf*J8cFRS+ zsv3Gu>>Ju|z~CX5#tbntHJFlB5j8ZvTlC<;#+Fpa*H&|PAG>~f(^J06sc!(OrP)i= zr=2%mF5{pUqjC<1y-wU=4`!PwX!e&?SdC#8k30Bq5Q%)Y|5Ib(@!BZ&xXOdjOyF8T*hBvqf@9%aE2W_$b2JPayf* zzrS0xWLFcny3jJbrW@aS$#LPOct&Z3 zlrbdERE6V)WDHt1B&z$+q1~f~sC#WYAEnJT*&SoIZX#q@Y#ePad)cmKM&sF z{&X?#?=`@Fug!DeMwvdp-FR*TEq*x59$Eg#w0oaR+3{Zs-zp2UpHp9Zl6C05_N3|W zb8%V!P3=iD5BkEU53EFUjn<@gucrRYd&4zB&vJiZzc=Xnu)8Bn*Dswx_A7%=+nKir zlg+9paGLGt?Vgw#eYi@k|L85xn!$ZyVq;_a4RlRVPR|+Dvdf^sog)VgM&4A%hk8Hl z=z8n{l;V3oHRThZzOEtBc2)9fejjM%@{Vd_>YWVFF%#!(9L)8tmi5&;8Hfww2?}Z$ z#D=_QtMF!~irqA;YFyAXvrNBH&4shuP2>8*%W}sKnlNDyi)Ym$U)$O=4nEW``|X_M zv$F{uZp<-YSpIx7TVtk!4qVKvj`ABT+4~&>S+-QQwAT#Y|HeYIOn&X*|)UU zb>E&t=UZs**Hp(5{jNKXd<>IppM9-OA!6broyh^NI+zpSm?hfmBQ0lhv~#to7mQtP zwVjM+QA_i7YRyhzAO~Sq*MR_1Nvfw-Vgmk;1eA`E7Y~ z58Y)KvL)KKrJ>wdoiAn{1Di%MVrnh$XAgza-UQBF zNcFXRXiDtVEMJMGav;w-?o~I~eKCL3kHZ_34+&Y%zS@K6*`8c}8u+bP<+{!48Sn&s z2`8)S88!RM{QXyKPg|#*9e=myaox%L5%tusCHR-U{<`|!s=BzWutus~4#so;$~QmV zZC0or>zg?G(s#zap)KuC>#mwL%vn>ByoQjf-l?kJ278*I>7lCnR7q5?s3xivGS@d* z?|IV*K6%n7+T2&`m@1*oUR&DPy;T?N@2V}e8(IEo=&Flu&q~O~4cLdPL9eJfwGX-i zd)2p&MLzJt#Kf@$wBxW@$#UfGvfKSN*8QK;_UFB2R_`>dZvQWzF(#)|G|m63KaRg_ z@EucLG;(tIzE&4^J!vKbZ2O|?m@XyrJqcD)IC$CfE6EfE#_p=x&($L(&7@hoR!ytF zD$&s2JxKqc*>IPZsDA>P%bjCAp1)|zn8k}p#j(?d4+wC6x9t9zPi8E?>z&r$ zsHMX)1}slqIkX4b&aufq7sUQ*5>r61Ow7+DaU5o~LREF18A{q39bUg(>+0#M>`rK2 z(acYwVb311=IdYn9!#rCNkIP*(+4ygF=E&oix*#ZfA)sQo!>{g&CSR@L9`YU#OBJz$sZKWsm9 zt^RMo{+nx2eVtH^+SzMSRg3XUmW=PvqelnF<>{ASu^>(L=@j0R>#JIW=`w9#bj|WO zRekRR|Hkz=eb;j(n;+h5?w>xhhdC!#Fz2MDRL^RqZ=N4C^Md6^mo3@Y(2XgN$}!WN zvaX`KV0MTa-MUrF7PP?{G;GAKes!w0os4SKs(mYan_YVgKKt{!=GJo5iv!iG&6z#x zRlh<#uyD$PRnY_M-xAn!z^W!I*6WeOnZNV>_dmF2WR4#{q}!WswjVuy{LsiZRd3T- z)7F}*|H;}rH@!Ku;4e}XEJ_)RS`JCcG1D@|%%DuH6~J8epjttsans4{ zHeX5OSG7(1Htt?gED&kWtlPHVeR}%EZslE*^Hr0udUZn^qh@~P`Xx(#u=*|=IOvAH zCZ7YnWsXPKzLdSheQP|Lv{y|ERymriik{;9m@!o1gzFvpHLD|W{^1SqvroD1e_}V*Be9J)i=6gf-l51tHn>tL5 zznes{dpu?cr#s%O{#tso_k*>3wCe1vN>2J5{8J?MPp*~C78_bo)^c@J6FS{Hf7)qSGY$fSuSKR)riUzfSg?PLevq&Gi0CY#JOJKc&g z(E34^+x$qI4J=jAhfdXbG`UQC_s^(({+%RfD+U0Gd$9GD)bji5bYbLatthUA`&hFHy>%cyf zQq5Pjn5FG~&#~OGhPl4Hsw+cu_sIJ!Be@I17NZDAhf)+X1i6w~w7 z$}$DOKcLR_MNxXp=zPHu^~Dj#l!_Fq@XQvkmoKz3I^me2+v%OCb=R5g?O^vru?W)N z6UFzOb$8XzIUZXmXB0~!{>~a%`~BMQHRt$>zgul=8#}5|D%V*|KPvsg^rJH2@pt=$ z!+ib1G@|T@jdr(i&mMbARrU=%I|Mers9RTOamD_%g>|-S$ECv%&pR~5`?YJSBVF2Q z^wC>5$`MYFS*<5n&*&|(YbZ)$z4tNhy@{CuX7tT2Xl#E;*A!Jfx~r=8v0+r4NmPo2{e~TL|9<$+leet-v2f};_usO5Ytd~K zk%lY2yyN!c%S=(@S4O?%{042TDvIrJcBp@p$sW__HJ|vSqx$?&|0rH1G&C>1)2@+~O@@-DE)#_`Re&C zeX&%|??sF4P!+>G=48MPXJew-*VMKpoBBQ@+f5srD)iY_;00USHJSi58{GA12DDwX zCYNTwIn8cgQ-Hg0)bWFLm3u0EpMNxOq~{;Z8)3gTGvritUs~1hn=w;;%o!o4qpGkCNk?s*li!s$LzJp@y+(J5T88_IbL<%@h$doCr7zz?`oo4wbxpe{$A%w`&l`6eY5GO;f9$m z8Y<)d(n{Yh4-DNUte`YMp=al)^rAg!rainzTe8NAW+ht~I}Q5Nwu+e}Wm=@yy!!bX z2CkZWK1bzWPiyji%bL$$t4d1RQS1{{oBBlqX&c*`ZU$;W_1xNQ5yel7d0$R7KP_h$ zsQGTIJz!^lDw3DBich=s^7v2UuN>X1Q-l7kQazW=Oo?CCJ*e|!dvTiC8A^G-;k)fa z^$F%7b&3sdO67$;+|Q0n@odq4^yz9G99T#AET4l0g6R@$*Pr)Gu&!%WZ$))1El-VK z^WgS1Nu#F}Y%iEnV@ImtX-O02Z2Iudy`GAP=3F+ar+;fI-f!q1!mnvFqu+d4rs?nL zZ`80(ZSyS@qu;*T{toolbyTZYJ<`^u-n;YO)X`&eHY^{*RX4n}mAxOrV1aU@xx!S{}3eR??_L@mD2Y(z%}5eQQEm%FwLnpopZHg!;AY-M5%l zz`d-c0{I>0UN*4rW&PjY%X$}?jW^9sU;ca9wno;f!D)Gy^;cb*jUE+U7xn2HBhHA4c^-NUfYnped ze`)As&xAE8FRokc+rmuwu1h`qKYCpwr;m)EvS!xe`>r0;YtY&2s`$#Oy?3}4QwJM5 zvbYXiFHQLQJ$H72U4vz<3!^gUPA>2T)cg{>i|Ir?m>t-o;wxRe-C4fQv+8RyjrFyy z)vMA-&*R1PhjkTGpQaDH(V2_%JO;%~z5O2Q?LA2M7whf!Y}&-HSH*jtx}NL3kCDzT zU0H|6(mQ+Qm)&MJ`!d_B6I>4Yeyzmqc-z3Ej| zKr@QpgLT6!=Ba$wj6Ln}gfG8ynTO_J#Rte*UoFdYco|t#jtyQ%3%+moQ8*lU+g1-dyZqucYzv8Aa4LR&3%q%IE&z9epR$KgYl zcWpjobf@7=V?}m%U0^M+`v1v2HGO2X;ksL~y1*VE<+fg{ThQ5CUH7ifD7S8*uid5k z?lQTo&RBIEx1Jkr)lp{-sh1BC-cLWE_gibYMpNIU4dY;vml>M2_Y`)>G|ePshgsl# z?)1H?4*TD9Z|iz}Qbx6C-a-{vDU&D-ik79mu zs{5n1P3XQjtgGWdZt6XqhxWR5=;EsU8uHiktD&7=zWRyTz^t4z?vh`As!R=jIN%tE^z@k=UWn z4{%FVO`HQ|+c}Ju2I%ZleeS5t$F4sk&5rY$Y-3G8AHJKh?SlLu!L?%%gzk4%~ek(yZVx!!^qoPp&0IhhsfVu-ZdutH@cp|&S$)b9JVV9oM*_3zX1Dg z&i^Yoe&XGP(NrF2+|4U;17A&K&N+1#lfgRvBUI zeBq9j2(?nBugLOI?DkHID|_pG(YV{A5Y&avH}mU2Je*_!;XB22csrtn_k*u`_g zemu5bXIJ9<6(Zz8C(plgfHZb?l3D*YyGYBm{2|liGG{Nf|C~7Gr27ht`#*`%aX!DY zuS|{KMOp|^zlZZ~=~d0!_&@X?Z{&CB3;f3YGqR<&iQ^u?yUMuNbFYuVhtQh5^QU)( zd)};y;|!JS{}Ns0dip-c{U1|MQ@?wxjH`*`2TA!qqyXJ+C~%a6acgofwi#aVyH&>* zaxZWluI|)r$}W6;wPs5SbGuS(x2`|VleqtPBz%yEJH3HyA3vzr7Pd|}=P90v@P zVLP4oVV~=Z%X-#DP~Zr_E{C@WilGeN_46cdxru}OAbbsP!!Lf!xiEN{IOF{CvN=8q zJI`YDc#F`pNPi%GOgO*Orw#bG`7vpZ8e1HTYU15??y)pB$9|iBAdS)Uf;qNwrLh&~ zz29nH6)pqyQQN>~pJ*{}Y!zd84YZ)2~D3 zBFX-%I6KSTj;)lZdnC%#HJ#&Sg=r@_SISa%Fm=#i>XhAZL#VGBXk)mOsI$<<2zUXg zuLeBLIocR*+8C~vyzBln4)R>#=vqYlpQ#VwIwwhMX9R5tY;nB9@6O}MJ1xBeI#IuJ zNT%HuS%h6TK&7c8lYT#buHUr{|8d$DvypQj_xCk0?tPqVhMYaPUvM28@Q0J8A8pKU zWD?)u-A21UEub52SLsdt*PJ)!=F`5M@A`<}sbAzeX8`(NN6+iD<4X7)O#R=%JY#lw zdyejed8MT!}x$`3i1T*oE9M`+fPJJfnX-O@++&{VwqvYyUoZAHiJ>i}_u8 z10Ja1zKZ`n!bah~4g7w2$3Pi8?(9$b&5|_Q(CyEC7kmFs`A*@TkYXMFkKa4LxhC#! zigP=^16T4}n2Y;Ah~s+(1K;F+tmQXhRW%OES2%UAKCX9pS2*SJ>UR+JGRJ;+0L;6q z4cGmcpZ9r2hGH`~%7EW0=W@T_9KVWu^2xayeZ7(UAbjUL?|2;d5a7BVgZJ@c6L}xZ zw>S$NUUYzafwZSBQb67KO4mEM%cP@YHg$`1`&^1^I(at}9q$6q2+wU7({{A$(wWl2 z@srH75+%a%xy*3xlCjRI(vwM}184(Ic7M!smMJ4?_w{lg;XHBe_Si)B=M9yPb{|w# zzuZBdZ`zl261hL0$*r!x$wST)vZ2-`$oNujb9_vnVO2k0N11Ppm8&Q}>kRh0BUTpB z@0CgZPvW<8KF`f0b`G0w{7w@;R&9h+%NCpE@{aW*?3XQ8Dcmhtx-M|79FI}oaPR&m zvnk87-S^7un#bx#=JkHT{hovEbL0VcJbCmn`Gvn4ep74uttj#~ig&_Mp3$T9k6cb! zyIekl*ZmyEHM|IK!mEDQgl~l{@SmjlyH!H|b(ZA@>i{-%l;zGC^o)_|?nK#9h2v)# z>p0G{TOwm!ZkgivMW#5L$rNjcEQJBqr!qoqm$BAbejDGR9K6HtcOLbHyJafR))wbv zp6f5=RqgQ}b%x1R&ZRt?w@9KjM23#vH_4hNNqVq^S?lfNOk~bg+r7V91I73= zo%M-p;$QCzH)(V-$K7PSu0uK#mLWYH&q-Hnl=QZ)l^)hGnPMV6z_mP%>p#{#>F4b!32-;0TB~I(V^!;L@A&`2HK^M?8CDA! zX@$vf-HPAjdNNegZ*A3=Wb0yRN8hx;DH&En8L1DzYcj~HM;iYzZQ1Ls2E0dGFfa3K zSqi<>_i`hoLKdw1U(xZ6jB*{7QSSXR(#?DpH}y5wEx6&5?AEyZsQ=xM|Da6ZJDQ{1 zk4c8RC24-ee<$Z3mJEIm2br*19Xa=dd{FzKd~ngz@_{=}+6MHJB=?taRED}=AfI;1 z4o6FQ822tFW@7lWFPJDg{B4)4B$X2{U@4%9`Q$FGpYyHR+**l~sV ziRNEGscfU~X=%U|ey2=-K7F2c-MNEoaBq?QwV#vyjWT6_mEXOENzc!*UrHwXU-|v6 zKJqIZ_4BJq!z?&Et#Ms{_wzFDZrNX}o6Yl8GXG5eZ{*d`Wpuk6$RT$lwJ4yA%rdy= z$_#k@H^bhnu)jXeO+{}z^@hoq%>(ah{#OqAE%CrIKN4nnh8)?&rL%$7=_*$O%+x@I| z43IkwI^!%=$Hukm*fqvIs*kJc&!*1(8oJ>^W5ss8-1HClVNCOVAJlWY@O$sS2FFUT zr)s>fdaTYrer4W2)%eHb?6ItxV^!ymLs9>?$BzDJoTzFniR-I5mQy`;Q*(^QKel4> z-8ygl)$w~{DZc(d(;lks6Fk2k-}IT={o)6_d$?bw58U(vucKdguMgXA`ljvvX9xG! z-xr)``hKhWZcRFy3-xQ7{!eordngZvwT27zC+cUtpV?)F@=`6cN_Gv`8RXYT|5nXD zt?Irjf1j1z$5hq7bb+xDY)avJ*XyUStGd6MHvVni7b&l6O_}{eJGdS@ocRoB*nM8~@tFP`bN{#x$)*im-F`OtL%Y>(t+}W64W*h1Y zZK-eF>RO`O+T#p&VgtuUk4bNbM@l61(o}=vb=AsG2(H0*d;k}yZ)`SDH+b3b7v3uy zYP?rAocCV2OE;I*4(lxDxC(RL^q1BCl6L`PM9vPf$aWpvpDW<}_8yWX(xmgAPqO8;lSORfzKnj* zUAS#czmDnOvFOLKifK2~_SU^<51-L2ZRQG?ce{Cynm%L3wB6G=w?P`a&HJ8rrkga>TMBB$k$#R`Z~A^szh~{;q%(c6 zRq3n7s_7r)oxja~KIxO?H>05D^J+h*{%6#F2bUlReKq^Os-Hjly68(Na82XB+(#ZJ zBWovZ(GNI|k#VMfj<#hN`}yYmYx1P3FW&S&+0VY|)8akwn|FbE&sDugYrGTecUu8v zqGjlzmRLqvGu47ai${A z^uwC>iLWp8Wm~tg0bIGfAA8YW0Pg9PCjZQQB-a}9@gx6z_=r3Ykf^|3+!NEsZSK{6 z=~avOps63&HgeC*@2l=C^URo~s}9^l`ALJ=W z;rI7(+U1`zMrOdTPs@Gu5iO*RG{p9!oA%FTY7FhCuV{A{^Bywcr&w!cm?wSp_w38M zSPsBDgwNm_X4b@dLY7#MnKjPL-7@ljrag8(Kg#ubh_~D-l7-fDJj3)YI=`XqdRnHt zcvsOLdlq(yRHot5@~U_lO5h>CzZqfO$i{GvABRI6(<-Y71x}y&6@J3cZ-LEyxcR^r z5i764{TGaYmw-v86@|bqi$;DW-^sAg=ipNB`vp0_vPQci9@v%8EOV?ha+woa!A#@| z;z_vLBZ*b$XC#ra?L<~dC$i=;QK!>h1k)Zh@LRQzRi)u}Tb4E`zgzW@K|53?`I(A) zDWnp1j}MPo0s1r~0r4st!Lx}qTyyAE9pLqeEB96&d^i_0(jbPHzbgf|d z+L^)70)IB_hCN`?nB!b9_qPztJ^m5Cg2}+l+KRVe0<-~BHtqy|+bj93S!EFZC?GG+ zw8G`S+P1x7J`!`kbx-Tl7tQ&y`YS*}OOI<-N%tD~gtj*H*%ro2g8 zXRH}B;dk{(;$5pAk&f(NnZo-%*8J|8u}1FSRK_okn&;{Fo+UPbWI-zTcPD+yhPE=w z8tVOqzQS13-@|XhXr16q(3fzG%l-Pwtiv$&k#Fyjr~Alr^Zb7xZpu-u%4lmVbMq;o zjL(a%q^{AMI`4JZjveUYAFVwf$B7jH5kQ!g2`s$ejVRVZ;Q4Yig&0VJEZ7Wtfwa_; zgxZHV^ixC&cIB-hCt#3mazmV z3pT@EIL^jM0V4GrK-zj?u#XMM2oEAWi17M^*N=ci$Q5ajA<~ez4T;;3c)=4P8w#Nm zu!C2RG$OoF3?u5va4a2P81%uzTb05&u& zfL(AziNEm4F;5f*h!B-#P# zkPjtL3drn%tR52~8w!E*Jx+-9OomJ_e)RT=2IBR~0QB}kb}!`iMsDwLNPtwx73mWO z@qoTQ=*}B02xpKyWofj zRRkFv2Jt|;!TC@EhehI$8Hda`WX5H|X4nhmP$4oT6ygB;hvY#q9E8&%Lqnhxux%*E z!#Exm0Wpvw67K+H#%~5>4o?*sfsG@2L$b)oFp&gwC+vn}fQ(Tg5DUZ|wF-)Wu*;Bj z* z$w1h2!lv(~I!*jk;-_*hm2;`YPbL1<#J`&GtI>7!36U9uUy}_5Pz0qwytDua1!Sis zLK@@%angvBb_7m|%nXDuK;O(H$bx)8=S=j>M9)m*%|hNRU-F6FDXh&zus^N2GKne&Qa z9~^_zA{jvt4GEA6*-!w;%RpWR@-mP&A9?eUHy?QmngZ^^2$4+EW=;gsWfqEDn*=A= zaC)!E^?9%rcEdp^7pmZZoGj91#fdBm1>D7)TY|jo5Sk*rfoofu37dfQOG&@yeYsaX!cSc_JHP#7 z2q50=nXn0V!!eON91so(kPL+1LE1aeeFwVlI4QCz0HR?cVBaQe+f)K&fUZpyB6kKu zB*a4sWI;Zl=T7w86$XUeh5WnFe^)W=1LWTw2k7418xkQ6a)5Z7iMRQH$UQM&+!G@A z20|nxL6*pUL4e%*b^vzYhfVikQz0@7iGP1C5OzQI-cQ*5gl!20(r+RCmd(Jq2SOkQ zl0~+L19`GF16DyHl)`C|ZN%Fa3yF{?@*wfH$1{8!2)p0_oDg}4_^pwbBO`$h%?s3vRJ`u3xacn6jelhWj2`k2?;v+zs zCjtT4PsBhnWI`Tnh23xv%IWrYKnO%b0w8xMa(8l#JF$N!HtfXyCxamZ;sAM1Wdm`Z z+6%;aia1XTVC&P75DzJk1^KW;>0a6d#jp>E|I%r?+KKyeIH2=oY!7WrEU!~(~E zD;Igs0lP&GBJX`{ejnNI8-G4v^ZUqu|1g{sIfRZwq0k!=Aq{e16BGk751khI039Dh zLjq*LDky|qZ~#t-91aB1A13{W_&?;@K8%4R$bx*>0egY#`>;afqhN@DL?G=)r2Pne z9|r;YK1ScisgMl?Pz0rL1Wt(@LC+EN96`^K6xc2D_ofgDNl-3qg#(3vtw#?4wtgZ& zx=%>=328n#2*mxQLgX0oKjr+Vr2i}c2>*=m&j|kn?~wH!Vc#V|4io{loFvW3NJs{B zo-7pkJ|2+w17Saq=7$oIe-Y8Dv)kKr#JQ$gJeN2YKEsK$drhC`o3=kRn$8?iFS6 zU34o)6rvP;B+60Fhu}_$as@&d#6S|HLoRHF5-5Y?qTCK39y5iMI~8(aE0n@IVUPv(}G=iI4&LK)m_~;H0PqK@bUvkOBFC-Ui5NfSd-{-w+#u z(Ho53VDtu~H#iltp#X}Y6pp|tQH=s23}PS&(jgZ%i)xGx`b1Qd5>ZW)ArtbTSk%RF zfX-&v+AIxnfa_{TSTpQtX2Q6xOM)OAVu84qWWXvYgk5j|PKXK-Ku_~5AYBXmEz00H zRETOB3=x3dme|q~TUugE%dJof#0zym7{oy;)};4d`vXSyY=C$cA!J zVNIb>RNF|17uAmAc4>gU?M{knkIwe!3=aZihm)p*141AI;vfmq0r?##LI&)DeWE&% zHX;&`9gzZAa8gv~03dy5?C4w|std5H?R6D%MAW5wMfJzF{)Yh@Vnd)%)Ih=p zRfrl~Dk^S=s3F7~nlEZtv8ecTQNve>8i9QYVWLJQi@GcvHUs)cBY*T(QHh&Gjp2A~ z9FTTgDBw>D25cFRe}V&!iMkwnCUSlvHe5lvD{vS`iR`S{WRHa;OkBJrF`50!TYO8M2@Nih=mk(VyyoP>6wv zfE}s%Pz1ZrWd?C)!~^MPa1GZ)0>`{!Ra#TvcxI5OSuh)&vp0+4Rjkqz0D0-BMa@CS z++a8;YJL)AKpyOXQaA<`q81=;A^H}c6qOkc$v~V;!mkYhoX}8Q)0f3r>i-4L!FZ_jYW#BM?$WZORgLCu#4>1mfJ?8;HL-j^V*D;QYPBzYjYK9dKCG z{m9vZo-HRuJ&-MC!%(#qecOn?jj#tJp+wYn-0kSwf&7P(MLjIARn#NFK)fQ-73IQd zQIAf9lcFA51=#U;s;FY(J<$|)iQ1Vc>d8=1CCDf_CF-e7qMpY84A-#>cNcPZasJtO zD1c+4o5vCSPzL3qb_YTPBtSakK@pTexu_QcAp#O09rB|6!)`bN6{6k=ffz`JY}gFD;RsZSIuHUekPO+d8Fs@FQSXLBD&)deD1!=7 ze~W-*$OGciZc*=rKmue#5gZY9Fc4xO9X3N5RET;%0+9OwW#B`u>tn9<<5D;+>Ih*+ zQh+jW1f54tiTb+(f*}m{!C@e8{!aX(0nik%^=NO12f~gL_6cF1#K9^+_c3H2%Yc)j zK1J`R6aVXchP=;^|5+gv!#*e%MVmq$$FAe~a6;4<$#6i_m+`Py)K`RkMLOCI>O?l+ z{sZ?PxL+gZn=~M=%1K|&xqp%;|3vP$S)ynIsP7KKNl_;Qf#Z{0=Skw6M8?TYPy*;X zNt*8ifV}%Y7LoxO-xmOSzAppx{6P92GN2Gj;kc-OMFR5vMZA9<6Ll&T_KEtD^gr$Z z(*3kb)Xx!c08WcKjSZ(ai~1#A)UQRN&YTcckptLUfy~NiK)xpsIPZ-XEeAy_HZWEx zkT2Q_fDAY++Ob)*GZxB4y9z|RV}SG2=QTUG=zvqAYbC%A(X|^yWt>|i@w+aArK7-kP6vQ07Xy=N8ps`W`Pg}F^~l5kPDlk1j^vJ z=t}}10umupbO_}kBvo{C2XKwe6Tlp!r+EQzzni0@1?8bd7$Cm|@>?LkMJ^z}1@c=U zzr}H=5Zy8u(9tpuk|7iFM29*c3`ie(3{Hz~6$IpIE7G?{f9u_FM0A@#z_vD|ZNvR& z!}&I(2}4F0@xl^-bYTU6jbY`Y+ajxNG)#nSD1=ft!D2wDQ zAO&(^2OJR{E)WLskPi7!0*9eObcawtUI*lLKwbyrbvPxuBl0>TuOsq0BCjLzI+npn z(Vc>!HzY$2Y=wP*{Snw75e*X|8w#NmPKfS|{hhJDGx|ECuQU2OqpvgRx}dKMVO_AZ z3p%@?vkN-AptH+y(Om-|0+8D^16Dy19Doy|BLji-k;slr2hv9(KXMJmlI$D76=tRhbO;8Nz zh%Oi1106lk(IXnTh922~j2^q-0GtrrGZ4Zc29h8h@?i&*!D-RG2=7IBFT#5f-iz>F zC2$xjME4E_!g^=HX4nga^*$-OPcTG493(>yY=zx$OmtrdghK*kKmqK6Bcl5Wpu1lp zWI`U0wjXKx9fWexF{F2_W80?SP3)m5Z9hU|`D8vG?F5L&D?;iw_uuAlR z2uOeuD1!>ov4Md6SklF&LIISD9!Q#jxxn!tbPvKm2)hR%cW_gf2%BIBa6T>=kRO)_ z8IS|{P%L^#B$SIDimstqK)PW~p*L&=^u?1lJ^|9RXq#s!TMNkT-L?^^U8tek}j7oxZAns-15G#6g5QGBZiP=yn zdJKBT3SjrxNFd!<(v3sbxIEEGq)9q1dVG%P2`Qp4j{tN|EEatQI56Ha27?pd?GD%r2jG-&HM+ua{5g^_}!4L+~K-`CtfVdA80P!9whYHaT zhd=`4K@niz!^n6f5D0rD0%9Nmu%T#^=tsp*3U0pW$3r0vu)Ub;DvpF$ApD68I3;=~ z*SIrF^po+B4qRJFBA}~;@TVLQ44I;z#{YCK6hN8iXOO)s0E$IFi~B6HpC#V2gguA< zIpRHcK=kvGfX?SLARn-IcN}2zZsP8)5d8w@UnqvXa6t5)48VpL6JVFJUO6SY6n`mcUtI;KMZX>bgzZZd{RVRPHwD7p#C>yz=&~%) zZ>7Tt(Qk8oZKS$2z1)`6Kiv9vSzrdC+ zkntsQzf6YRqQ4>z?Kyp7v*>@siT>IFdqsc4dD?TjoO9(lkPn5T{}~GC{wHz14T3Du z-=Xt6;(WJH^hwU0B<)FLevi)YN%#E$(LZqhhgE=WKO7eQuXxd?VnzSR`5!s{DFb%- z;rQohz&_e%`ZV%SqxWp3Po3twgR^@46wBld7h>) zQ8Z&ZmTVGBB|#3H6idfKKH#?!p+qc)`Ho&Dl#Aue5X%)UmYaBPj%yKCI~aC}RVQ04 z+G^HC6UC~_*L!J?S@jCV3L?CIiC7H^#A=ueTg3_v0>XnU#A=iUC&X$T0O8OZNZ%Ma zjfvZsI8E}QSgfW^VTV{3$3U4_%~Hg=gmjE&SeKCIk~BcxC7WP}SRv7X%^`c?0Gt%7 zc{*Twi$I8g1lTQBOWc;}kORbTN&J??4;2W7Jm9!hGH^Yu_Q7$nT00;N;$Sl%tMw76 z5UUNc+7!ZGI3`wDZ^#s@tpM`dBCj2`wvQDnJP<;lNURRQfSiuWVs+xWIvo^?@d>MQ zI3TwRa=J`}G*|_tVs#CLEZ8d+^=d2fn6S|UU{|+P;Cwf9c1L!1WJe(*3i;HHt*A1w zs1sY!v5*6V_dr(<()BnZR!_ouBBv+%dTte~mjejzg}*m;_f8P2Pc-aSPE0P8i*@NlI4BnNN~?d7SObCq*#ih4fF0B;t=M=d zfD*9=B4Z$F24=w~u?7V}A|Q7V{U{=J7D=wumNapTma(iQTq_I()(zyCP}X{U$y1;l zweTl`&(8;9IP&>5-xW&p`z;wE*ZKVp;_UVNozhbd`~5CH{ax4ZcT19L=l2Kjx%$O^ ze=P}BH~Rf`@Ne<^1M$D?_g|z!)n|TxU5U1|-ybBkxg9>+>Pw&%>-RU}JUL}wOJmMY z@cFsO#?~~ypN}+KBrb!n?7<<0TDCk#1ZfDM%m0Q!Yn&&4F$JjFy zyXIo`U(JqvJCv0;vVy|XztPiFAf*fa;aRQtvf z!<@U;PCd|;>$82KZM(TAncSm=(pS3j|Ez>L$nR?3vp)(q_t0nAP+Ok4!{cmgGUa;P zI&+78G176TBXus?Odf|~mAOveoi}&c#2rTtB;bz5Dib$U&Pq-=M?wT)=iiBLT)V+n zx-O)*%9^RXPo^Tzl$mM#HM+0o*x2FA=b5|Go^Jbe|`BL zD)aHpBjjpghe|t`&hZ@nn^N;fQbHvhS@TG-(9Xey_T4l0bTQJ*Gu(lveBKS5=Tv;Y=Y1h}+t^^v`bxx~#R(<9jrB%C&8w;@=iKWWh<=~8x#%%I^R%$HN{tdW zgEQA+!`a+4cQdQT@m!8gngn8AkGp_(%5>zJk{oK6*Ry3Olk=u5jN|Vd>^0?{^_|4@ zmH7)C&d88&aZOsq2!Oc^#gdNuc8DrZco zo=U7x8FrowlbZ`{OXpHf%u~=A{YK6L-rMFmFz;}46~4O`ioWyDWb&N+Hjhp2)YM$_ z3dd0+u>X0A@k*teVGj)jyQO#8g)skQIR;smXqry~M)lRin;i`k`s5+?# z)me2>T~(y&rn;*r6|H(mzUrxZsov67^-+CQKNX`cRsGcfX{TbjgOzHa8YEsdSjDL! zYN)hV!&JN)u12VlDuM4IUdFfI5_vk_Bro^Lel5^2tdiB0 zYKpo_rKqWDnwqXs)zxZ-x<;j`nQE4rt-pcbl3b**$z*Qx7OmUQGp z^NZCIIjyqQQgwq`rgGGBb)#CLa@9?0rMg+IQn#qp(n+mRd1|d%r`D@{wLxuEx2ghl zo4Q@yp*E>I`6lVzYO}gW-K*|Xh3bB_MLnRls%`2)wO#E{52=UMBdSO}DiP{2d0RcM ziq#YHj+Dt;YNvWqm8hrWSM{`dM(tA1s^`@6YPWhp?NKkPz3L_PvU)|8s#n!(>UFhG zy`lE2H&vN>OTDe$Q3uq!>Tl{jbx^&p4yg~+VfCTJxQLeX2fFpR42Q z3-zV?N}W*uP+zNWRJn9k|5V?q?`SV|QQxZ{)W6gz^`rVp{j5%_U!<%0Rh>~4s#1BB zmjd<~pPJPY$rn8x+R0aW+&Vzl;@4q@uC43v4X}%JU0qKH>H4~XZm5HGBi&dx(M|Qm zx|zO2hfrU*Mjn?9y1Be32jpG85!6zL>Q=h7Zll9=TfVBj64e57dM7U>&E2=%IR;j@QFk<5?_GdZbR! zqx5BZv`&<0Jw|%yv3i_N(&P06eYu{fuh5h9WSy+9l%9HuzDmx>ah;;4>S=nqPSscI z8TuNXCcX4bJxkBl>3WWytLNzqJzp=-3w5US*4N4*MhxF)Mfr95dYz>g>BV}9&eluy z4SJc*(aZIXdWFu_H|dr7X1z+^qF3uRI!~|F>-2io;^*rPtX$uyZ`JI;Wj2;(h3`_(C>cd~#S$%O%73EUViJuxeSgtvXhqb&*xqs%HgR^{ob0Lo3*7 zB=M}!Z_F=UhAgm}SWT^qt!CCGR*2QyYGJjsLiwI+YpabFX0^52S?&2!SqH15)yaym zI$K?=u2v+C$>COaKC>Hb^{{$cy{z6=AFHp`PexcV)}>Z|`NbMw#aaWcLDpa^jq3DzjTUYX1 zkSW($Q>?436l^Z|#ofCnokX>+JYx*l7#k#- zb&}4Ouq+7`7eatQNQg;DFQky(+sQxzq>)Z~LV6`VK!A{5f&c8zyt^ku{@?HW;Aid5 z?!MXG*_qkd*>ayxeIfP5)R$8Cr@ox}O6serucf}8`bO%Tsc)seoq8bkoz!smD@}r~a6FBK4=#pHqKH{S{v6yeRee)IU=HO#RFIFWjR4cj`Z>|E8WyJ(YSI zew4NW-dkD3;CI;=WAIz7@Z+0`X=a$u8d(!-W-Y9hEoMvDQnrjOXDirY>~MAjJCdzr zM|u75w#(7%7IP2qrL zS;)FrH_Nde*2_+1r?J!78SG4U7F);qSe_MFk(F4)*0ZzO26hhH$j)WwvGds`wwYbP zwy+D?RH=AISY>HjQrr8XeWpiu~+spQ`{p@P?Ty~9jIeQ+vmR-lLXU}Ihc)w>i zvKO$MyvNuJ*^AiC?8WQ=yM?`ky_DU`UdCR|Ucp|;Ud3L`Uc+9?UdLX~Zewp?Z)9&` zZ)Uf%x3IUex3Ragcd&P|cd>V~_ptY}_p$f053moi53vukkFYA6X9w9G>`rzU`zZSu zyPMs^?qwfmpJ1P4pJJb8_p#5g&$7?4&$BPEFS0MO``MS-SJ+qC*VxzDH`q7Xx4cK# zx7h>iJM6pcd+ht{2keLJN9@P!C+w%}XYA+fLG}ywOZF@FYxW!VTlPEld-f1}m_5S& zz#e6fvB%jT*%Rzf?9c2k?62%^?Ce&@S^FXAcAIOl>( zuDIrg`@E4i@n+t_Tlr$XgfHdG_;S92AI1;oNAM&0N`4eSnjgcDxvpnQoyqo8E5AWrt^3(X~{0x33KZ~#9eLT+# zyvR#D;_La@d;>p+Z{+9l^Z5CE6W`1);9K~Gd@J9^FX9*Tem=l2;g|Bu_~rZxzMT*9 zG9Ti@e1uo{4!)C*@-coT-^IuIZa%>$`4qp3PxBc*%jftWzL)Rg`}x)Ux%?XbJbo>| zj$hB8&u`#2@)z)%_zU@q_|5#q`~bg&zl6V(-^yRcU(R2_U&&v^U(H{`Ukm=F7kIDr zZh~J4dL4f~zm30vzmdO*znS08-@@O@-^Sn0-@)I>-^Jg}-^1U_-^bt2Kfpi8Kg2)m z{eypmSG}d)GH*Gb_f~j^d56QRK1X;*!mqy`#qZ#E^1Jv)`N#O({2qQU|2Y2y|0Mqu z|1`gke};dSe~y2ie}R9Ie~I7Ezs$eFzskSHzs|qGzsbMFzs(=u-{Ifo-{arsKj1&) zKjJ^;KjA;+KjS~=5At8|U-Dn^U-RGa-}2w_-}8s~!~7Bc2mUC3j6cr*$e-YU;(z9U z;eX|S;Q!?R;{WzE|BuJ`f8n)YxNGoTReA&M(;(UNi>TV(JB^;C1R;qCYFm8;xKWz zI6@pLR*Iv<(Qt|BW8l%_-ksiE-WR;ji(|yGqD`z4$BA}vyjU$x5GRV0ycTb<_W|)7 z?`UzdSmPbzeNJ?UweU;ypZ4D8z27_5Tjjmldkw5DUIzZXKYCAicY|;6JziOKic>^d zWJDmcA{1SsTjWHK=oP1W@AUHC4c=#AozWytgO?|65vPkYyqAbG#aUvV=o5MGMp#GO zE()UP-7HGp3%yr@fBiOiC*)1uyWmZ#d&GKiw%8!f5gWz1;yiJ_*d#WK3&a+2q1Y<6 ziHpR=qF)S%OT?w(GI6=MLTndqhd^4DRzl*v0F@tNiij^64PQv z%!)a&N9+~*#C~zLc&@lcJWpIJt`pab=ZhP}jp7C3ChJWZZ1 z&yZ)zv*bG2C-br(i?Spmxn76Ru%6WNE-XZUlcgc^+kIB2`J@Q`parp`PN%<-HX?dUgjQp(pocz4}g8ZWVlDuDj zS$;)+Renu=U4BD;Q+`W+TRtGaBfl%ZC%-R$Ab%)-B!4V_B7Z7>CVws;l)sR_l)sX{ zmcNm|mA{j}mk-H@NA;>x)oJQ< zb%r`qou$^PK9yGmRa7MvsrBk?wLzVuHmY;gdFp(%No`gas4eP3wN-6X7paR?zZy`N zs7uvl>T-33+O7swSq-USHKHnNhuWz|)tI_c?NZ}vx0+CsYD!(Drqzs^RdZ^O+N<`d z{pxD3lp1M|Dr>3>V@h>>Spy~bwJ&sUZP&AZdET+FITTnuT-y6 zuU4;7uT`&8uUEIJH>fwNH>o$P+tpjtTh-gt+toYNJJq|?yVZNtd)52Y`_%{32i1qv zht)?^Rn4n|>JD|Mx=VdjeN5f0?os!ukE>6pPpVI;PpkXXXVhoa=hWxb7t|Nkm(>00 z%jzrYtLkg&>*^coo9bKY+v)-J9ra!HJ@tL{1NB4oBlTnT6ZKQ|Gxc-zp!$XSrTUfn zwfc?vt@@q%y?RJJtR7K+P>-s|)Z^-p>IwBH^=I`L^;h*b^>_6T^-uLL^>6hb^8%e>6B)gYoVo9T5F?y-Kd*%vu@F?da+)jm+EDDxn7|U(}(LL^pSd{K1v_0 zkI~2KHoZz8r`z@MdbK`5pXfcTPtwoPC+ju3L$B4H`V^hk86D`X4t1CA);Zmyd-bXM zG<~{0L!YV7((81e&g+6M>XMH1dVRLupwH18^||^yeZJnLH|q=Z7JZ@Ks<-Kj^u@Yg z59mwurTQ{`xxPYg*MqvOhxD)>(G|Tz@6@AuOkb&Y>2bYVPv}WKrLWS{dPdLcIlV{k z)%)~*eYJkBzD7S!U#qXv*X!r&8}yC(1^OoaLj59rvwpEYpl{JH(J$4v>X+%4>sRPk z>R0Jk>(}Vl>euPl>)Z4j^c(e?^qckV`Yrmc`fd8{`W^b6`d#|n`aSx+`hEKS`UCod z`a}A|`Xjok=k-B-hrUzar9Y}artjAG=zI0Y^(XWv^{4cw^?mv?`m_3T`t$k=`iuHY z`hNXo{T2OH{Wbk{{SEz1{Vn}%{eb?C{;vL>{=WW!{-OSn{;~dv{;B?%{<(fo|3d## z|4RQ_|3?2-|4#p2KcpYlkLW+>NA+X+as5aAg#MHMv;K?ztNxq*yZ(p%r~a4zxBid* zuYOWLrJpvQX)udS$}q!?Fw!WajWNDyG)<=2w3t@2*eo$i%`&sxtT2a}!_5)qNVC!$ zWsWw-m}5zg zbDBBboMFy1XPI@T&*V+P6ivxQX1zJvY%u4Tjpkf)o;lxaGMmi>W{bJdY&F}=Mdo7D zZwAaI=2CN+x!hb~wwpmyHbZ9EjF^hqVRo8PGiI(dyUe)RZ6?g5nKD&(8;=DX&5=KJOc=7;7-=EvqI=BMUo=I7=?^9%D! z^DFaf^BeP9^E>l<^N@MiJYxP}9yO1d$ITzj6Xs9m&*m@YujX&&@8%!opXOiY-{wE& zzvfBvlzH0s{04uKpYoZ{ec?-A`Pw(W?>G8QezV`=xB83yCH_)>nZMj$;UDH7?jPYF z>96#U@{jh9@sIV}{8j#Oe!G9XzuG^+KhZzQe~y2$zsB$I*ZQ6QDSq0|_<^7GL%+-K z_H%xZ-|L_1pXQ(LpW&bBpXIOf`~19L@QZ%QkNoxi+5QIq9Dk#Ku793?zQ4)e>|fw- z@h|kZ`rG`A{EPj5f55-Qztq3XzudpV-|i3kWq-&Y_DB4Rzr)|@kNRW&mHsY&+~4g_ z_>=yWf0aM&&-k+kdT`&awV^{?@t=U?kz=U?wX-@n1X(ezD^P3$ZW&&^hR z7oFTWIZ@dq`*xRyrza;w-_UerPet}o^4!E&I#Vc07ZytxmeMW^(s39d9CX_-Q^NF2 zsn6v@=<*>9F~5(>_4N?kM`3|NS5Kytr|0W{nag@#zj1@#_*P%?5#)_hJg!y^;K2P80-S_DrOL+1QPddzC$HQVAVgsWd`o4$0 z@1gH{sQw2($QI zPX^0p0+z4L60)A0Ul<;n9-iC1W4yA@6h_Pxx{6)Q^dQb`tiT{NO497$lQIGtFmKrB`uk`@SWAtq@zFU`(P zPsq~L%-HzkL?eX>rlYE(3=Mh)n-FDa(5Wd=h6cSrOj1C~hM6uLEs~}%O`})DCS-aY z3?v1wh;0g64}^7}WO}py`ox&7uhY`;PY{Upby{X3>RXUbt?$eTi>5Q9UCG{TXQnBE zsxzb3yYcDFG}f`krGvocJIrxX6k-f`Hr+`L4to5v>#cJw4l+ddfao2>ZK81u`qHlsvbRVwtc4ItUt{#id=sqAtwN1sNUHZoS3uFQ;) z!pu^qveca1jw9i`wCqLob|hJ_BhDGgY6Lroy!Y6=m>fPl4F zAI363#9Ay)i?VTAlIp4HGDlDMpsxO9kym1~%;B8_QEu zWtf4iao{S+Wb@+Ong+>~5I2M|Zel)U6PP?4n}ER(=Oeq6LTW?k+5m!FTy)-?t05aX z6fmV0#QBMe!!B`ttzwXLLKu>|2uWQa5i+H)kDos}Ik_uUn%L>^hNzW+c-W*6wR1Xz zIn`>suta3QDLS3abuT&}o0KW!`KHlH(D|E44mUZ@YT7h92bR!15`rk0F@7flpYUGh;mj6iC|qsur3<30_7Jd9}SO8sYv;;Wq@-A zq!YbJ9!o{~9xb>`2`xAX1Ao)ZczI?NNxy0Lm^A_$DNJZpB6Jjzpob*rA!$GAKopXq zzyV8VY0inrj0jQx1Npnzrkb8dR)s`jr!E@hE@b5p&7^duFHCJ2owO9rM5ThdVEgo} z9dxlJ!8l#rVoRNI0TzyJ2bn&x)iu`5!T`ooXE!yko0`{6F|q~HUz!=NYB;~Y^UN0i9L=|uM&bqvK17?AQ~Z56Ws3KHZ~$0O``5G#Nj z5hhpiFRqV{xY$h_;$k;$`r>%HaV%3plQvT#E4@V4c?qrZbcoB0bQl#(ekj8R_ep5 zOL=16JehZS$0A@-6N|*Usn5ai9X7obGkqU6xzvZYK|pqHric?*5D@;pSf^4weaMPI zIxEY_#j;#y)l8|k&y?$HS{F@br!&0lEO@8(QQ@XTQruz8=OsX1sjHE&*p(`SO;L79 zHWC{bL=u|efhe_DrWONZ+F1fX8jQh=2$n!oxz0&(i9RY}$yH0M;p~eo1Rxq=0R3>(IW;m>Xch2}TE|{I3+*N6I@j3GHhq(%&@VN8+4~3icEwggsz|_3DHV|B2M!{NZiod#Yb%yefM|V84Je6 zt=SN;QQNN3db_Z}86s>z1P$WW&_K~bveb*Uh5397bZ5LWGc&eueHV!_oO~Tof})+W zVVPI#93I|1#m20xj1eo1Iab0sJ&0TZIab$VFyGSrM}iQ<9F0q2usidJy^zO`9m%pe z|4M3FESN#q>uQ0pUNDRetu8p&cO@GGLbqHAhTzQ1YmHiDEKPYOL6N3iM$ z**J7ljMw#dCR-5WHI9M>3ymGEb4#?oEoF;hymMwI9r)wU40drG22gx9qq$ajJum1k zI6&KKUChV2>qVdel;K)Y%dkyJ0=-Efp9G2yaD)vD5rbwr?oS7~4Bzbp*Zm!-%zzVb z1Ox&~>4p_oE-*FG_a&#+KwZXRY!zUBfbJSFS13K^ z9a?adLXuikZ<$g&@u2S-1cdT&;)fLy@f;es08_unlTktg7t%@HqLl&$DUr66^(PZ6 zr%75lQJ7pgq1_eHm_)b+24@^LAR>!4A_7M_S~KLbY%-SG5dAK&Ldx;UO3Vpi4&^FD z_c5#nXpFkz5alhz<##%OCI3|G ziRlE#bmhc!onv4Pg~f4Fg^?gmA(OU5CT*!JV$-%OV7u+H;Y_kg*+|T|D*Ty4v`r9C zl-)EE-87Qj)N9oKnNl}V2dM$n>1o_qnciKV7#SL$0b>T|y;(Q!p(KE1I*W~HrOe^E z>G67jfP5=KUk{(P1Y@)D2xYpnVm3(x$F|UjI3zaeCN|7b<9ldJS3k>ZNR3aVy<7!Jat3Ij?R;f0qrP`pDU{G5Y3|Lqh+OnD!pJC+huVY8O5nBVaDOT$375kIR zY+{m#s*OEMwD}dHCkIreV-i@+qdE$sEZ-k@7jm6n0dmoF31MLYhQ8eiW&1%Hv8!Xj z4$%CA&9$_=8kK{%+V$RC4YPl83oYKL=_Pgt^K*T9_wKUmR<<|fTSsAyy{La|(dIFJ z;n>dI<<#cUvDD@n^fhE@fgDA7vuSr_XL3^m9Z9g^ff5sue<&jL5|N)M>c&xw$X^tZ zx{1)snu%z~HHxe1Lw8JsYjVg(w@O57_oxruFA@0wqNt$AZGj81EKTECT1RJ#p>TaB zqSIUuqVoaBjhZ4Pw^4|0BXB~KEuG1M6MA_6v?E!FTPol#b_4|wlI+?(&MnjC2 zdOF0-BnV^69Jwq+&jL7j;&hr~X?r(BV;a7r^mu(iUfU2Ye#l4t7LpMj;@%6SJE}uS zOhqTHVl+QnTgPi2wruvO>n~)V8Vl|cYs}kAw-#r$b%M<$Vaq6ACXHaqK*29 zTtg9U*hfhCOq9>DArJw+(~1Qjsf@$sbcK9l6uMqE5imSHIa7fnZ&)Pb#}P0|7AN9Z ztR<0R?G~rkBHECSXsI8OBRC@KB%+Pvh?e6~E?`$f6I1X{!M_C210q&{Q+GsLm=UcL zBihQ0XuTNGX^4pYS`oQKBXYz=q%IEH=j0qR z!!imN^sVKP#72S>qewd|5v>y<+F^-ky%5pfLqs-ogiB*^NyMT<8k2TVB3chbxUU5J z5>CfJm`hEKjw$%J)9%8ipw)cRYIWoOCR#+B2oc${5p5q`Tn)tT@M(aJT?Q za%AXeRwiFCS68MdJKfq`fk9{8C>c3B3Q`EB@{Y+lSad>)ni<>YB6?yhF62I(-68B( z5X|nKgh1h^vpb~w)`nwnG6C`}2FRa*^Kuh5QW@JhItvl$FwX91B7E2uAF;YR4K)V} zHxgEt?juSUZzL=ZP{WfjV?uE~Rhb@}9I@3o;z9(e+&K*HTZ?a|0+ST#~>{NsH^~<3fo#C~0Z3 zB1&7fpf*a>qx+{u9g&+UMj6t&U7>FVlx%snGHv^8lPXuumB#^Sq4XG5am1gPoQ>mh zYJAQjQM<<`T*Ti!H$FQyHNGDb^~l(su@OgETP!Zp3`ZrVC-=oDn#$m&KyNR64W`5$_N~pzz$@(%;Z#MVrXuByfRCD$~MnVkCi8Oj#m~WlO{uj9(48f z`3YwB!HEk^b0RFuz+J1S1wF@Tuvs-4!3tvbi|+8)tgh@X9Hd3gw#-HFi4yvS6 z&__p6IDVy|>rkk>7U>gXofC7rr^SQ|h~x6AvU_TFKg`&o+&KeQuNcB$7=sZEU^29M zJ1~H~H4BYm0J}aGx)Ot37{IQBP27zEIQT6DldBD;Ft`c>m{o1!3Yawv6*x+gxXq>Ylp`{i}PT`Qz6C5ZFX>ec2ps-qY8l?RS4{;LSRP~0z0Y@*inVRjw%FpREK8bQ5~v{>JVVE z$IZ|%gCaDlHr*O!II2VSQH4+AQKd5Rs1DUewU&XSIuws8V8>CV0<}>E{PCzlBWWxF zUoGYuvtU%A9f>)`cJ7c-9eT#70%{sns1KEi{f<;mojxNIle>}YZ7e|_3p)B>dQ2Y+ z5!c%&(Wh1h>0?3U`b37Mj|Cmq+lZr2tpL%-!bBe%Mf%tn(x+A&d*@1H?_3ml))lYM z$ren~&%!=gvhFK1Z(Xr^)Q&>7Wg(nHp0XMcX=Y;ynpx1%4AWzpS%_$6qeQb>8Kjv7 zk!FbuOEU{Pn%Rh>S*-xk%)&%78%3Jg7}Bg(9BJlCBh6eCY37R8X=cGB%`6<#%zcG~ zamDJ>w2?47ReCh!`AZ8$cJJI--t&Cim~24Fwflg&V^A?-F4Y|PmpS@I-j z)1h|zB{oNaDKbXZ;beajz#6C+w$Y4C>>S!YJX#sv)##!_!*?q7ZK33id^mF0d zlpEkKxH9G7Y2=eGbT9>7=pYNa@IV^CIHcWuY2R+~!D0vw$?T%|-qEpHxW^0 zINVv>TnVzc9}r}5(*#12TynsX=L*VUI_N3<9`_C4ge2}s07lJ|A$J_yjd18P=u{6fcm)7LM4QKLi=YelOM%$5OvQsQa2^L8bhLREgfy%n z-mC){B{`(-z;QTNA8l?yKC1N)9d`g@y&>Mb3qoR-5Vth|#{Pup{{&@>kjaoJBg&St+9;6^ojkiaZPTb2azE-Au@4^SY#HI za3Vt~Ns)<@5+XxM3q^(!trY;LuLHMgXpRBke^_{7UbZ_4xC5$`6LuwXx)Q~LOiv;Q zkGsa$+@aX)VpkKLkWG{g6IfvRQO^N;FbQBYTzg@@v+^3Z7bZ^!fb-Dqm)P{?`i4kc z41A;@`H;6bc5Na(A!SLNf-1-%a7nciEe@<_;}@}S)S+EoLqaZ8m%7xY&cMa1aeLH$ zVFPL@mh5mS)^#I?09^8dcI2A-;zf-EaeRuP%plJJ0d_wADqYKg3lMIIDJLDeoR<0% z0LhZ>*mGPGYsO|2uuaXS116t$jyWwF80>H36sXO*HleDz=C5SWN7;3Vf?j*MEBsM(Po@?Ir z%pPTmP9CX2xjH^L{^*3$GX|WFpl?b^LPp8f<&tg4Ar+cym-iCg=t*|4C)tgj zBprGXU-Q5-x&fyZlSGDB3oMOV>UZT5mGxpD7bn=(X_{PXog*>9Y9f1|A2m^Kae^z8 z1%NLRL|%fcWAy=o+h2~CYG-w7c|cO9tdOK|ORkm!tCA!>xW`q;mqyCB)GtycGwWjn zssU>z8At5Rl?9Y*sb6tQV9D2q9d0pU8(Zo(dlDrVv^hvNGr(qAH?@_du?5v)li)f` zy<2d-#Q}6T#sSv3O^gnwG?R_WVpX+k8pMb=CB;DUgD^=?*hh=;!Xhfk$zgH~i2Iu- zpV4*@{5qlS&4mQMLXzsG1vMp$;Uq{+?MgPatBxA9KoVPbvZ>w4rgkU02WQOd-Rn-G z2IoN{Cs_|1IJY^?^^?+ZLEzG)IKp}9L{442p;%o|0Z7U-oSlxp$&}z^bRB@B%?SYM z(_A~HoXG1*wj2(E*T3pXQm6;SgbP~w64xna1g7`=K$1M8-V0D#Cue2otM*a#@bc7;Ap2yIrL1VOFRO$5ADlE zF|Rw1c&*j&9!Y&F2cS+EVLB2imZnlTwf!uw53aI$LE&f!2x^J$sQeW1z_XIR%_j< zSa{|_ zX5qb;I*>5^z!z6%QUL0#1MiF=f~L3~4g;LNpbH8PTw2SdML*P-yyxjiz3@J-`>rY8 z2yxJ2aBbBNX}FZbz#nUUqGL0Tx9r}DOJ4%Tz+(%$HnpT>ZU+X^UCQ{dE7$7oO+jMk zGZN;o#1V1JYa2Lm(Pzmy^c#mgSzqm&dd{KW)V7D7QBOUGzBw{(8(zmrR`hIH@mE+n z{?>gpj6!ncvt$urj&Pe(3qJbaIaHJ5DO%&Z$;vJG6U+xM2DxFtg4sG(r85buCk^|8 z^A1H&>BAmuo+Iz*4FqWAGBnAmi2T`Z9yNe zr|T*40>0;&OZ*<#j&lc#;JhOULC+yeeEK4}#P505CBECLgQxP`_61y>&A^j+)01Vl z*8s_RRYFzlJk4<5&v~vP!+E6B89G4>bE5UA0*v^AOkvT6b1E}0`uq0rVhx(Y2i}x^~!AEUKNKNe>vdurE|rcAYrN6` z$$Z?t8sR?3^ua}8d+r}EsUVWB&|VA}hj%k3e0S#-2uhc@;g&9rR0a=QL$}=q2C#`6 zA;@fe<%HfSuy& z6Rx3h4-Pu^Dj%`3y(b69jD{H;S{Y^_I>RX#@#t~Nyd?;o*U9L9U<KL!I?#7`-xscO zpa6%&ks)z-h-d$S4pg4b^wX9g^gr$|eILIrh+CA_yheJ!BR*DfhID@@#QVe6$fk5^ zAHFXF{U?0L@jxG}KTGtbomaSrgx_U}p4lkkyX;eW4r?}FSTr$*QM||u2UD@ZS-eyW z7CRw;H&^Wax44=(>=q7PhQUoJN~0%GBDyCY(G}{5u24sGg*u{V3?h6A0JOa8Dwvv% z6ac%L;pQE(LYCg&D&`|K4UaTTfH8*=u%L}gakim$QM*S;F_=@Z9Bjs5IkyRfQMUtx z1?|=hA*_IIvsJ)>T{r@S@!7p_2&IBw?HJoJyT8#Dfh*^5z-OctYlXTfp~)q{TNQIN zpkXbI;p#JknWfkLMI#$y1|Fg2^EC6Z=Aug1K3dx zLPt3WW3@>2pgIOa$SDapkmJht_2MN^cq{?SgVu5FPNSNJC5szj2-9?{0p|0@q)ko5 zvD!4gRAN^;lpdp{e7w&Fhpq`No$5-{sjhTaS2G;ro*f%5+xZIAu)>Y6?c19$GGX87 zDDP^5A%Lyp;Yk<=(A926PpICWpb<8gE7Rq1JK^nWNdjQt+qQw6bi>Vw8C#V-Q{9}1 z14>sUz}@_GfV=$=qR0kx+bf{==7MKq?_1l@O2$35p@URs@Uu;R%Yu ziJLeI=WXIB9LkBKa9GEkC4u|0s9A$z3740>UG-Dm88`;x4v)E0|8!=?9z>g&++913 zlBTzivUHs+OLJM4ba$5Kv@GfHEX{3M(&bs2tP zq?ag*^sY*gZhRK$Mam+*uTrF!DU0;ZN|9cuEYf=`MS7{SNbjx`>Aq!=?pqe=zGaaV zU6CFXEYceiMY@Msq_-rB@mzq9|ADS2-A{IDh*zB<9j&a8-oFm<)J|VFT1)9HSy$Qk z`4)PHD?%#`ZcRG5gj=|zc&R@Ty^a@Azan~%CZhgD^tJ`~2rPrc_fDQckvn+@yo8Tz z1n?N3%+a%ASv+W%&XNt3#S=^b_cd8_wLCPr$DMq{ugH?h(n}p#x>=v4oAOz@37@4K z?^(L6nI&5@OP3(C#IISp?3ks?j#;|on59dOS-Sj~rOS+2y3ClR%ZyoioGgo4ES-(H zm@JhnU2e?MTP|68uqsRMzGdmfsVprevb2=Q(hFf(vShMk*<|UFh%6r4OlR>B5QH@S z(jg#lxVX_M(qSa>}OGF4ALcMY@|^#KTKaKK|ZuA;36o z7wMhXB5_ZVxTZ+lQlxv;MY>mAqOLDN`mElSCg)gjm4U~n z_F>&Y^sI?<&syap0q#VC1u>7v1Sd&{N1+;IcT41fih1iToTihHo>>g9nklU<6x&+yU1p=!~oH= z22wFiFzqy?}q1H?WO`A<{6%NHr+5h@r>Tp)R>!^(*eCD8^muklEWsTE9n7E*#Rx< zgF;Eg9H(ong_@C8z5y-Q0y@MBdX=6l>)URRm=SJt!b z>m?v~)i(jbPGbUsUm8e2umhNY;AJld(InXo0)xsf9=s;U?lGk3RjkeheNCv^;9t2*o`3ufc10`f2#Z(Er!}9)w?=yw|&zKj3-n z3eS7$3jVvNA7$fDKlIc^kVAP-KfxbhS3La$=JH1%AL8EU;Qw2_TjAH@&v@#ACm&yw zZ74kTr6(Vb)5VARW2qY!-7bF3|B~9f=(ajO&$IaA+C+-#tKoa_%r}oA8t6oQ2)!Wuz8fa_Vc(>Pl!N#h%@RI&&xUzcEz~GLy1Kawmi&mHKfnQAY zhKJjSR<2rA^#-b5p}lwz=vWxcudOz8RNDr3tgSBUXkXR7YHc;u(Kd2NYT0rxU#KoE zv<(jC=NBz2yND+32tG}w}BtE{7%T2ozK=(qJ%R}>0VU}f7#TlK!pRd&K92Ty8f zDwKvxRZ;3+RZXoP*m7w<6kd6tzpc7?GbF7WSlL$Xv9X?kfwp-p4J|qek_c+6rfq)O zmb`Cse;ZKaK)J1IHun!gN}J6yHr8!p-GeI!2L=XK0=24*h2g5VrN8QJw1rmzymDjp z7#llgWBKk@Z`hW&n|nh810&^uYQvg=0qVg(+X(chJwLFv$~)RhZB@3q41JP?&HYu` zp0BF*Jd6N*GPt%X9JzrKZ6ot?DBor?ZFg5<^X=cN94rl2`N^vwv(R>+?Eus@pXRH9 zLKpN8ZeCg5GSJ^Xuxg;Ky6(b$$XjXYLQPp)l^s=GSaZ-@gu|==Y|pm?yR_%a)kQ-) zstv=?kg7a+ZB=))+155gx0p8sMWDUw1_x}B!J=!e={TsHy+SE}@~Rr+_#F!wsS&X> ztbryJpzDKer339{JE)G>-by1V*UZYN0IvwYu?I z42W7CQQCk8!_e^R;=*9tfx))wVj$bv>XMF)Tl?qPNO9o!YEz|s-`eWZj*S=eZ@dr_ zSFVEer7nG0$Go?su&sZ7$&x~~p`5QSUSmZLSSvr@V*j+lpK8Mj7>m^E&HeLM4uM?x z12Do+ZR^Ra+TpV}4*X#A?I$3~Hg^DevL4#M9#R($*8dp7dCyzg4n!_gy)zFsG&DFV zT;Ac$dy7h2`>RXZ^KGSSGq7J%JFr~7ZSZ4sot_? z<#E8?E1-|d*Q~7`)-m5;!^45zHawzZK4rrrJLZ`US9Z*E8y?j$FKl>p$Go)RF&*>D zhR1fyYa6cV0BRupt6~r+-QLz&ZMfV@%i3y3B6CG8^D4|-o5(z&mN|`?Z5>{wY={2Y@ObE-4Oc_|Y^?^v{ORf&SU> zWays_J3HD=cY<_EN84ca@WD1vdJTh?C(003J1x(qJF2Iwsh$Gzm;q5(4;=ff0@+^f zX}5~~|F;CN4-+3~U6_%28XA@_0}7uCx@$%CFet`AovwDp z<{Q0y)i1269O!IsYdie_;5=<%v9?acR~7B~xO7`}(CUQ$br1o zv<8$m)DJCaj|Qs(Mth;Sf@C$U!C8qF21nYf941vzcC1id3Gu-J&<}@xQ--F2{%?=U zJuBOxh6wrzfvW}ZJxe9f5UY{}C=nP84h#n~$RRBOjAc7p*+!(`FKNkLx5>TT`sY&#t$bldtxmqKf&S>URE(;J75X=?ggLeC z^nuR#bi*=`+r9<4TUKsfkegqS8-JU`cjy;|j_Rpvk_FjcTe4n-aF2Id;e{f_hh?^t^MvoYBJ z3m02@TRnDqd(X;M34U2MK#5{{{Leurh~>UlusO&te4FM`Ns zh&0&91sw+)T*?-RxReWRne~vh)t0f5ZMKY!Tx84G$i*FZfHo{ZtRG@9w?k~8V$0Y_ z#g?&=9kz^(>~!raLTuEv%f`lByKL-A*Df2|<=SOq}P1)c|G&#d9Q)G@E8Ib?Y2 z7W{8B?(tHdSDZh-;pPiq32}2j!6#YxZso-Z11slGv`P1>>%9iH?&jgGR1(%;0|V9zw7&AJOH9?r( zF66%zmXM-0DE#aVp#P5J8E_X`X~MD^TekqGS@#0(v)%`OX#EWQRrV2<>?`L1ACZp$ zAD3?c*UOE-O>#4EtK0_MF82eAZOGew?IFOS_Ibcj_7%XZ>Pq0%YBF$&Lh96g3aM6$)N{ZW)LP&M^&jAW)lT47YBz9?+5_CH@u0P> z5g%Pk*8-;MRA4<_AJ|Yg0v@581M_qqFs#GCR{CgQfkr%ad)*$`QFj4$)5ijj*T)0@ zqW=OsQJ)ArSq}i7rcVP7)kA@!HA$c?G!ItOl+zuL0Ma^}x5x zTfleBd%%y)$H1Ltx3C@Q7-2bsox#9MotuHTI@5r6J9h)`aqa;=?VxNpZ#wIMn;n!5 z=N;!A;Fr!m;Lpy_!gjSgQdsW!F7D-i;(h}B-2E^3U%I9^P@lUS2QY@!s*k6TB0E zCwj};6QI6@KoGNk2o|Fh~oLE;@=N zxRb;j@u(OghKtc+jJQfn7IzBOv#8%7G4|Z6$6h4Hj~YATLNWfLv&UT`UJ?4-F{tOJ zTsUIvCE|9*mo7eg?1f_X#TQxRU9;)+W%T&qog@8-6x(G<0c%cZ4gJ3j4TY2c?UpC!E+1 zIN-z+fRHvN(j{RccqZgBIwE8$a>PmxhfzV@>A7R3KD zu$6oZU=QgNTTcQ$*%M)*TYS6NKVODA9oi}NbT0*&0qH0o>66p5fraejw0J+>m4>kV z5ZULk)cKj|87E~<%8(g7;oQvmS(%w#GhDdA8Er~jUq1KEIwNCOM$gRM8GRF6`%IJ3 z6%J=mYv2}V4A1DAc}8jY3rZ={=xeK;H8-OH+&H+t2;CD0T}{oHl+h$(X2$%C^o-n$ ztr=l*nd?e5oRmS1;<|?J$VXSc>l*MVW+>Swok3|kdDkgn(Oq;wE|vZwD@sWak;(B_ z<>|;LWqFaE2sOJL_xuQzu!LXYoyvxaOiK{1;YH+%vVxI$WjPgHM;2AYjps!+#;zjh z)s+23OgRoSBA=J#$6uGtgLuE1(vgK_B@c(zvO250K2tQW(!UDNnmwPg3d)zunx#4N zsIMt9EixotXQW?bL;N+-k=cBrykWF<K>bUZgQEV8q>l5#_G2Un}b-=U^-Wu>>K;UU-Y z0Ax!=qj_1%_|u58HbxPN*0z5}qz=!$Bj+c^{g2IWYT;s*QBe-VzY;4;jQ4?D9ZJ1) zAorXd$U$IR+_q9F?M4k8CkfPw@}s?_Hi#ssnAp!P#?UcvMI9T+v7* z>i5T-6Q6V9sPC}HpiNCRMlMaXlE~|cAtU!CULW{XWwm-S{%MK-MJB~xRYynr`qBEO zI{AwIDRlMibF^$nz9lVw%Ur(HMoLE172m1m+ymF+kKe1l1C6>PSrv^k{czFtF40~q z)!D03pM&r?@D!KauX=E;}}k@?&SrqoU@d+0N43#!PJV7x@f+H{+lhc5;-Pc=p>s%mM!=kuOST zSP!uEEBS{Z@(u3!av7avE+b$2jL7aX9%*zP`LGQ4fG#8VACP!C;e)LcNKs^ZIdv5< zqN$JbYU0y}a_=~8H6*L6J;+h z%?|G)yuvySm(i#jaru%*Li9X{;vQis)WYdc`Y ziE#AC`V;-B^NagWccY87H3zifqhU!b?!#$h9_jVZ6w3uA#}b^&rUL&q zaVoaqj8RaBPmr2AI6ORsWHA%#E*=uEi5cPzu~WQgC0RF%kFcU_o^^)xi1m#%&f0DL zVy&`&wtuzWRGu1SZO}b+PuUo&eT+Q9YwWd^=~#R7i0tOA^ES%SSogFGV@u08Xn`%~ zRJ7ifz6&;JnY%>;;LZ5g7l;-TE1S^5TRN9~Av2kA1^5nga?w{H-`PTvHnRzHDcK364+k-;-^oN0ytrBR`ng=s($JS>$u` zB97&_ztYD={-gUu_UN~Zcj|YFrS0ELF>jyC&~+i?}YH3gr^rq7V3|2-%oIS8o2`Z zobCJ)xx)P?j*U1rBbPi#ya|anA@QcEgzn~(8o)6-4Kct_4^fX960qJRwo`$$BM2II4Vj4m`fe_O~ZM_NU z+Kl7l(kDbuZysW>!nGswT!rJGppmPH$qFwuGS91v(v*t(OvZhR^ag~41nyO&w<8Z- zA?MqaPJ})VZ_l`FWJkwRrKOm=i%HM`E?YIqj9vybtfF1 zadbiax<<0}u{ifYYL3IX7mnUI`rtSoM_>5=1?PV7?~n5%(6I<%7e|Kal{l}%^+v=b z3C|%JM{UrJaBhmS&`k8gion+#OZ0NOAeXx0=mxqwj$?83z;PT7O2IIke}jJ{vM_mo zz}h%*zCBAN>nyBbJW3y}yXfO|FI}YjV4dO#dWybIU$1Y_Q}r$SR(+ekOW&g((Tnvm z{i0s3SLl`cRlP>9)9dvH{ZGA7zoobOb(H=>Z`WVzZ}hi%xBgD=)j#T=^sjoq{!JGf z%h*O4V;tie&m@^-lVWO_+9uW1HH}O&bAq|q%*0B?$IRnqp;=~LG|SB=zvD$T!c*yR9 zRjp6*O4g@%CF^pmVVy2ksy3>P*sKO&?djXo+;#1`EQt3u!9RiW=uzKZvG zJ?MwL9`s)(U;^SJ6EY$3v1w&miBC)i(@}hCPB*8Ef15MR8RBzumN`rO$6R186x(<$ z=60;Vl;SJrGUqa}%emaSTzu_}cgBlvoWD6!#JA1@XMy<6S>!Addz>ZC67jwBvh#}A z>+E)RiyxgIvHtQWx0YK={Nkp%^~JAln%h`J+}3WPCEda9V9Rw+bI-6m_bm5ptCl;_ zz0OK?=edtqjopRrLhDHPIrllMsk_2mVKsACx+|^b9v+_6!b|aLTj^Mf8L+Zw<)xMF zUGLps<#=~{_gHz}-@U(ELGO8QsTJ~;d&{ks-b!zk)yjLtd&N46R#I9=dvAMNtU~Wc z??-s(`;udFNR3(l&8aRnzK)WpI8g+mI56`ogkLE)If@wkraYFe1!3I@ln z3(hGRU2sXkxPl1B2RYxG9CLDs-P0R^+x89*SF6_>u1l zrbnsRxnOqT)XH7K+=BUqnT44JPZE}K`Gw_OAyU=7up?4^d%+@pTCEC}7S1Smsc=rg z>Vma}4;E}Je6(Oo!G{H(70v*Ed%>=PJq7y;7Z(&4E-qAsNrlS_Q*oq0!&KZaKkoVZ zPb8Y7lz*R>=8K=gSW5i3`te&;SXj6Yv5IPJg{yuDU08zMp{FBwBvS-lQQ;*T)` z5v-GMZZ(uy@>r{b93qEUL#QsXPLt2d#n#nwiG1DqE3KKgZl^W#)^t0~?rqJm2igOz z*X_IQnbsRv5C4v}9_!)vNypxA@0U$z4ZJ*3wNve6Q`JlLlFewnx@=Bs(dALPzOFBi zrus&q$b*^--lz(xqajud5 zoNJwH8zB4oPRj~kf%7W zIj_mVSO=aYPo>&Op6MRpHkD_)*=|sdaF21j$cx;bZjrpg?duMdS5eI*r?}_1Bjt_m zW$u;oR`+^$nw;+5?cO8rb7#AA3^8Mr!l24EypzKY>(HZ6MSkVXN zZ~)wKVvsmP^h7K6j5q=9*K6W_@dnD`b531M^YJ;x$%*Q)yFTm(sjSb~_CM5L)L-n?wBN&iRh_I(w%1V0YrjUjKJ3@A(__5-8SU|~|4nvc|4jQjRI>U( z6{{@l;;>aqvK-Zlc5$fIWIyUCvLAIcwb!Z*wb!bUc5$d1Us*11w$JH}xXN8&xdw5;lNBbhwBd~-NwZyIM2GvV$*d44sK#3oz74}FxtLwQ-+@*Rb zm1#YU%CtV4%CtU*%CtV0%CsJVGQCTWrd<>I0#QeJS=WD~ zvaYYA9TEC^+WDYwpq&r;MwI@`^iAFk-VOQ|?sE!8v0Li8-M5IvhLM9+bRtkw6^9tk~{_DJZ5u}9)#JnFWE-X8sw_k;I?e%kxV`&mEZ{pS6q7bVFgsh>^KNf;j` zxk;{GLN=qHC!5hrVJ|aqoWXVWGh!(3WO@=-G0CdO_HZ@Z!}YYE$(qiVu!;6FS-W8a z!(~@_4%{j7Je1|(M3<&X_17dFrjV`ta^O7_Vp|0z`ZRVwXvQbF47q{6h@Nwp$NfR_8z(~!k( zCpDa`LY>D}F`jlisoQC{le&v`JE>V}FYIKt#zqJ=kF90CHabZ?!Z!0H+ssq6^GQ98 zolgzb0^LYAQVU@}&DA2dndfQelUm9)vz+!ksTH*6Nxe*ap44jE^Q2y-Jx^*4?RiqK z(Vi#u2JLxLYuUQqq+LyFJ?&~z|79EdlJ+yH?`c1i*0hsJyR?%D1p+&nbS>J+r0ZZO z(@I^>ylh_9^=UtoZb18)bVJ(Dq#MzGCf%5JGU+2|50h>}wyImu9wwbmdzf@5+QX!~ z&>kk;mG&^{ZnTF<52Za!`b^rxq=%8M>a%F~lD>p?FX>IRd&v~gz9mygwrARr?U^F7 zJ=2@^Dw*TGTrb!3BMUSqkOi9lWP#=++Mi@jru|7~AX%dsMAm3dA!{^)X&;g~mG&W- zp|lUl495J;a-Q#^uX-E+`#<6lYvEnrGcd+oxd#vAGo8ccY&7z zs{?BT8e&m=@R**cT`cs$fzumGlPFV%mdELDxG(wu6gKC+@R3R19TfgZQ+Lh0j_f>+jqh4 zQR)ECBSRyDMIqopx`#v6x?n%ZP$}OLMe5#Y#rv(=K@`anHifrTB6@vx3}Mjv9sX>8Q{kl%CV$ zB-+BKbEpUSkF$l1g;alBksL`5XIV*=AJ3}+|3&9PC>T;XHW#;DR zy`I}Dw=lObsxP;xPgUffn_B8RGSxl!N!}~LPvTrK>%4<;!OjSknYk~sI7?+EWu<1N zWi`#pjA{zLPA<17@JkKdj6j0R?H9Yw9gsUDcUbOuxfkS)$sM0NF?V9l_S^x18D+VF z86|g};-4$Qdf@j*+@|K6c>1uT+S~4oHex~7wnwZC$CT7=|geBnR$Z( zi-XJa`UjVj%NrD2j_W=ZxRhW@*2I|0J3U56sgPTl3oHvPi}%YL?qB7N4D1c;&6*N~ z_L$4N2=|&&xeM0I8=H4k-Xw&mm*}8re{g@^^?BFRIk-O>Gdc&C$6xt$-Ypg7?BV7G zR>fT2oq2bn*5uUX&CHuwQ7VItD|dPK=RF*39&DcXIAIx=9W3VpYkZfLAEgfL%sCe< zpK~?k1lHv(39N(L6xfuvfH3NU5Bn~#wR#5~TLT}Jb31~=^Ool=&)JjrdftYdeR*%^ zy`T39+$&`{!QsKNsMWRwuMbYj`!a8L@G8_!OAg#+weszx=2(+_3chk+F7HQjNYn7F zF;R!SydT!QKX@l<lco_$4?p-=!8mzjl6u{3iM7Ssn9p^TYXV^4sV4%|9o< zYktqH?)f)@J}G~2{u$s*%O9P8N&dL}3Hg)3pO!y8e|A<;{@nce`A_CA%6}<;Oa9WV ze);=At2F?py5Ev7f3f}m@#H?ZDm`{GU zQ;!07dLM0}$-02*i(ozE^%Pi6b67!KKa0{&J)Kyu1Yxul7uehG=zj)7&-y05hUN~rw39Ri_Vw{)ZSVbJ)rLRlhl)g28b^1r?pQrCg z{|0VN`Z~yz;RcGrtJ3#o^Z@=6UX`(goe1>HSb{6VS1I9D;Z<4pN#7>CgG|-UkxIkoP8OmbsFk5qB4HuwC!hq zl3|xAGhL=Q1T;{1gvi;F*&wq?W_mzn<_1zpB4-QfCkl6I6IztnKC>&ZCyu^>VWITQ zljwjOoOwnlJuoJej_Y$mxtXIgM-$?>B$P{z&bd=UYeQ=@$KjYj6wZ@`}9-^{sm6<(YP>k7=se3IRw%%y=D;boaGWv&h{BNy73 zxd(0w#*b?=_k=d$8b@ejmICj?%+E5nXYPVOk1j(S15aaoNn^~^(%SQB^efP}Lf>Xp zU>%J;`6`n+)aO{0)ernu-2Whn!mN%=lOJ4G_pBnEA%(VO0NSHrq0!u`jt>qGjYfNM zf#1fWogE(Yy$qFOdj8;9#`97koh&F;+M$N3tG&hC+ht9X}vx_=eC$UkTI$?l(a zN%kNLljsxP8{V5e9ByRxMd7_^6LK2(=|P+y4X4G@<#V&ILLQ%&eLv;2-?C*-qI{== zsO;;>C;Jw{n9II1dnR4^A>fbj{?m%d#8KyEFJSj@_TxA&$zFozA10T*JbO9t6*}Nv z&)yIU2eaYRhFtdB*>4l#c)x^$bM`0M+d}O_?X$lmWNLTG`NvS#sLS5(Q#lgpbSV#V zTzaB#!zdTXMbAX#)b@E%B*|#r!M7wVhjF7aF&%!s`tmuo!^3exjFN5p3GSUcVjuu(wvuaR_Ck@&Cl7Gvn6Ls zXf^8d4+FzmW(S(K%+C4DZ`*UW=j_Va1Gg`yI9G+{hu7pLh5F{EhSrAX)Wo4T*ECM< z!SI7L1BZ?@s5tj1O5_1J*aTc|EB_pinAhuA;@dr!9Y2ADCl!5aR04cD{PY33)G%Cb zQEpK&KE<6#f$oTN$ z+=-#u)V~R>&7DHMolsBAu1yWC4)qN64K~I++wH-|$aT!N@+Tkg|kXU}NnjONAi zO#FOQUgMIP8_eC%yiMLKc|9=m(LZlc-syS6^G4=fgxLU|55Tzpmb`~C!k$T^KUyP7jqvN9YqQ4h*C55ymz&I-1Pm zqZ={iIfq9`6F^PIIB6P2N;iU{(b8Hz*5b_LrqWT#!LIa{S2e0 z?HD)hDj7YIKRJw|X#B+eGW1T+r$`UwmeijUxISqg>Pmgu;DYdCJ|0JoX9n`a>jJIN zgT4yAzK(*kq-!#HDXaBQe+1v>nZ$1ObS;PHk(((uO^hXsiVyA?shHnS=_V5hUau0?drIdwt zP!6L;S%o@u84%+X^n|yDKMH@2{`!vaH)xrEX(?KomMJakwM37gWp-MFmO-ot>4CLS zx8l{1v+P+yVx2@X*6`DcT*WJLjc$zg(8Vp)_(U)0x^ z>B~e@tbo2vG}E*6ED_Li^xs8LKcpWLM`^6k7DsDZqg{yg(9emsSQEWcwAU}|mqk}v z6)n19UG!#gELKEs6~|*$^rxb){(PB7OL)R7; z(kf^%)-*DW#5mIwYrC(&YKUIqO4G+2FRn8E%n4$GImw(PCYn>sU~!EZYpxU5nj7(s z*SoMX;&w61+-0VV+2$TIQ_L~5&AsA&^LO)*m}?#}kBW!PBC|-$!>a1#V!q=#DdI6F z-N_bDV_o$z;#sV%?jROpef4qTIcFGFi?6_L6Cqx5ZC8m`vCew4c+GvseOIjaQoTlE zV^X7}Mq(@0T?fQ_wDwwj!0#~qS90IvzT%_g0a#=HF`maQ{5+1}=Mm=T;ox~R6ZyJ1 zo=RKTQ1$Z`{MH8${?;;xMuDUCpVmCakE_hnUiiWxeo>?eLv_2^aI#4Fjvn-`S?4^K`NJnx+n*p=9lzKB2TYGDY3bH*eDZa(N~8&|HQ05H~efn+c%*YW@m( zqL~Q#8gq^4XeOCSqOG|WC0L>aWBnsm{@*Nu{Kn$OT$;ObX>N|ve2-|4T>&%2F(}is zMPqX>N_I;w+4Z<&XLHF8aLKMuy9Kag2>S(qRI(i|*$zr}XVBO^AUvlVO1a`vuCSNj z7h#-Vo&7>%SHW*01v?9hMUoS7A|eGl41`Ex8*pI*8$>egHxR~s%iScjyBSttU={C( zH1}QDhK6m_6|Ps$t0!uC^}YHc*K6Q40Nv1Q2s#axQ;RJ}!*cS4mxQKPD7GK}9l#FT zPi?jz1^bzXRhT10ZML7I*nUij<@hxj*+v7ljpl3{o!B;V**4O!pQ9Ii$wJz&g#`H> z)D74|nzM!EvW29vg|uS}X~y-R#dad~jT&!4W@}OUW{vkDv&~37P2>H~Y&l9#*V9Ey zwx9ZJKTX+w>a+bcWy|qx#% zEUFp5&AYWZ7H{+R%yFit$YAU0%+_^;>1+N1KG|3Ywy|SOe{&)@WL-AfRb#d&n=Pt6 zTT~%il+6}pvqiOHi)v`5ncGAQa|hl8p2v38$jmS^u#1qat1Vksfth7yVYvjg7S7KL5Y*$%qS2=7~S!`E1Y**Q(b`=nYElP2VWPFPf z)^AIYV#}g82Uu1T;css`O@OaB*gt5|n>H=6m-&ydOk<{L&wBK&(?6Lsyyt#6p@m(3 zpf%OE;wOXmP+N~N{{|oRFYrB6WA~^$lgf+ON3=DUedj8?hg%LOw01JB3B^y$d5rM} z#-kaN3B}!nzb(>@f$IpZ$?Us>@o3U7_7N@5WL&5526s7{)6xlkmh~o~Y{hsf$A3hah`lje6yZtgMFdUzsQ~fyod2<#zn=H>U$WE zCe$}YeujLj$R1z{xVjZXG1xkfj z$7#VXS?FPT)RPqIT1I-;fF)07Y{^J(Wx?}hdIX`NcamFXBO~iEtBDpj(sM-L0=Fj; z=g%0T?N15SH0D1ou}j)4A#`>Vx-Qdu8TS*K3z@#2L+#^G{TRD5ho73@lCMr=&WYHA zXIWoxDH<&EamRqX7kImBkF@-Qa$EkO@XW1rqU}cNd7xo_GUGq!DaaopBS?m5yAc*K zLx%augbqIo=W?rnb>e;Q>Rh=N@eflR9DYV_HpSe{FH8A3IiKY15b@ElchuRC$cu7=4Slk!YJsqufQb?8=J;}&6qFBFT3sN5O+WPF}wHpoYD$HjzV1M|}u*?z5Oh?WDGGl%I(OwVAPP8MoyWL(I& zfKdFx^rGLsqB}CZlJR-=-S8XoM=mB584AF7`bLKETiRl@Hifc=|kZJ&o z>yR6IDC2#M&oS~-(6=*v2O~c(J%i~h8JiHQ?o3Z-WNXr6nfA-l6sB)syr1y~MlP9p zGSQOjN%3nB64b)?h2k7epGU59+-F6LavG8Z!ELcaU8e3xrWXo}Uf4q7yM zEywCwj@390`vK#>2{DU8cno6(V}Q{1<2IXU=ot^Zl44bU#;~YlTseT|@HYK!9W2{f9uwr^ z<$=&IjfEVO7g+NPoDU}uN1ep{>siC~>|4MiqgGB^Xl~`4%XkhUjiG>fggmxtMPn;D zh}u^0CE_-Z`1U*+L)r6~e-UdN#o9)(wowjg8%6R!(m9HCj$)moSm%RgCHO^*LzzF6 zC5N))P?j0W+J>^Wp`^{4jhQjan#owic&AT0=$Bfv31uJd39uarwj*mhbAIM=;?Hz1 z@iWCAh?D}M8A#*Dvq;kVz(Z7J53RwRlZFtQ>3K~cUwbm=#$=X1lksNa%MqNe z5uBnC%pbui8o?)&)zhQba<48`$NKQpA=fjbNVjq`;edLR|0+bVZ zJLgGPmidtJ66W+}`fJAP2-T@fpUXHxH$^JA%*g3{$1#j|6I!q7&wyVON*gmw7~7)H zYgrSRUchwF;LB##i$sez%mUy#^B>^)5(Gz1V#$?^&ogdg?9DixP;AAluVt-b&NGDa z6sG4eE@7O-_#WNGdX4d)j2j81ZK1ZeUa;_OH){gZ3z!bd05~raja~7@6hn#eomfw_ zoWwFK8J}m|#@L&2I-%HVVYb6s#hhmd_xUiXd|^!-{98x&75# z_V7;xIEGt5%$|Z)=djFOjJGo0$#^@XABSt0=CX=eUeY;(@lwW{8S64~yQ60^eFvfW zi0QF}>R6^ZjhH7UJvTAl!07jjZeg1HEtoAPnbCx3aj13UUXWeKDFS^VBuK7eecU}f?_GmVgD-q3asUBvWImK@5VhLR-Og6mPnIR4^i);yVgN3bOK z&8(-010+l5o|~0sJ_6m1G}uKPs)+B~ox^esDY*udA?A-_ZCnfCUPwFY5Ylihr=mWm z>l;G*J*Foxtr%08vySmP#?{OpNr+w(P!8cZbme$*D$u6T6Ku_RG9&i^q=4V!yq@)hFPio>#`5Uj&H91jWBtJQJ=2dHV{7LBOnmEOjvJ@N?#jL=v-}Vr zxxMR3XmOtbbIVk6Mi57G?IBNQ`fH!Vq2A_NUuC+IDHrJvehGvxEkN1jQ`PW6aA9>Q#rh(94E@SDoPxNGmV)Oe`n${8aIJ= zs@3R+H^>RR!w|pdJE9{4BE#vLeu;0?r*{|An~V9IIR9dbLMQy_`%{nrKQh_(i0tHh zBuGUs@OI*z@$ZTyod`*Ddu4x=I{adB^RFvMiUtgKJIY!oiY8I7A&=F>R z!=2-EorMse<|S_zf8YN~2TH*Cu%HzpIX)*4w!~5*<9rHV+oKuO(yt*#?-{{Y5g~m( z-q+1B^{;$eir(Mxe$577 z;zd5gU7#oNSMoOX2Bo2zmr`+p@$WIN;BD*ly~rx-sfu)#s6Vr$)+))@xSJk6a@OHf zRjsBf^C1?x{F8|JRZnqw;2b-g@7J&Jz7?d0OMHdG2g#grkl_v{SOw`xP?L_gnWw{A z783F=dd3@K!R0m<{1}&>gMURx|6cVX3oo(tVF>j({Cx>{!hSx%DelM8++xNt%aiFP zEUK@gG_jbDe<1F#HS%XZP0oyzUZ}rzddoOe~02New{7y@fFM0l%Aq!c+lULdX^A~75yJm_IENd5Q~I5I$kI;93|vc z)aR`u7jUX3L;ifU8dPti{V0v!PS%82`#l(Z$7(WC0co)upD(YQr>oAGj$(}|_4a=EH};#>8q zd{2x~BRmKdg@tMYg7_0}wY6=_6ypjnuTe&t3M@j`JWrMdVh z-lyht#j!qsTCW=GEL+xTF4u4W%cdD4OPW`k9bbwodt&8#5U~`;&lZ>52{sGOjJ{lC z53b)Yp>gIr50C7M@_Zj4+fQQHQoqARM8{Sg50}C!^pvEh3JLZqmk$X65@#>ycn;%)x?+mSeXB9s^XgI zegzC6kJ|MS86mq$J;3FF%zW=6|ec?Fh9?J>Tb1s`s){W-OG+on52E{JOO&zR|= zUSnMQljvXeDz0^_pmi-D%d+81?ppc%YS;=?toIPPevh>BxJA`Rdp?!T?EYE*Z%5jQ6{|@n*OYRJ-JJ?^vaU*T$Z&I%lv53k<21nyeocNsZ=XPUp;1F#} zLU&?qS@H6|WK?flxE1toY5A1LB;dO|t`>-SRBO2$=M^;H61{K4MEe8mH#w#ZK2bYl zYb%NS0{VB@?}0=bm+y&0W*6^|>hSyOkrl=3s!R|6D;wXhkA{!-uS>7#-{geRY-e$O%{vW=#m&wEbvbaV-ymvqTJH+@0N$9cQ|d)d;^qp>4_=-O#KKKHvh-|=7P5CJsyV#fC5wgPdE(noaHk5x|X1zmACC}Us=!f1|dJ!EDlFp47W1|%NKe|Kos-!;}3&qk=$=I3XI2_KTFXmI0 zipIYj|9zhm9gP>yiyRY`iSnY?xC8unv{z;xF(yG2k3uf>c~}XAF-gsSu{)Q9Es0w! zbXkcwpUIJTBh#?LrWyVpAdmYsnNf<}|o{Ls>MV39be)n`b`s^9PKhf_0VYNnDt^zf$=6+J4yhc921WOQ`k>nJ-*WM<=2NKX#79>d=gT5Fc;3j1gb7ftj4QO@_*OAd=D6_4=^V9fAtqj zPn3!j`8$;dQ;G)IFzg{(%Rg3DZS?*LeS5=*sKPmrP)htzqU#k2+1+ja? zja|#Eor=jEZmPQHbGYyK=j!{Pti=vPeNA&6ksl(MHII$FiHhH$N2|SS`Xfz$<}Wgd z`UbHTHWZh#>yG}+_#NoIOUE{yOG1_z2OX%s^75s3DDPEMPBd;cl|M{!k?jeJYGe(O z^$B4rxL^sM8!Yi`TTUq6mpuOv}f4_U&{9elcoi?wsUe}-f zfTQi~p}p_vPfG=jEh`&e(%PTs`kzFZs;;6*AsGto%Z?LEN_Bx5-($z+nIaRI_>10y z-YFjYomryKk5}SscEZ)~Rq_wV%|ZD=RCRq&rk*Psn69g}&WdV_@=q&r0Q=1J;F`=Z^Ky6iXa*2B+YoP285Q*Of zU)75G1B*)4_1S^xsz5qApHYF=;b%qmCFrb^a8>4_bpJ&B9C4E}LZz3HPfJN5YWZ~J z`zQ~-PHMb)~vK7vYt5KvTNm{_c?s$ z-~SGWFRqE2B3~t5|KV3s+=uU})B3fC#9A>^tP@{~RaTOk{j(5yMf$fr`dhv2X2^CUD*-xrAs*}A)bx~dH<*K{tYp+lzsQ&irYJj@jUaPK9SJ+>w z`_=vSS8A@BYwuDIsYmUv)#K_p`+N1g+Ga=8cHKa=)@izl8m61-=IUIXr}NZEjW5Wn zQMynUsta^`-CkX&JL#_KBKm^78iTLKAFnQ>Z^WxB@OAk9YP`NcU!bni7wL=C)%p^B ziJCxPidTQd7l3Y46Y2Z!YAU|}{(!m}Unlyzx=qj1^VIG5+WVvG4*j@(T-~Lg)K9AE z`11QAbvM5J{+zl8-+W)GX3^K))dTdkcQqGZd*7@cr0=<_$LV|S>Ir;d?%(QZy-jad z&)`e$U#Ug-Zu>s9ME`2EdKuqdudUYM8|!t|W_(?}nR>_Mo3Q%Ov^H(jr{);bR{h7c zH|^CIrlaYuw$qo^)z|bzb@i<|*_^C)n}KGa`p%qUCaOL3{dC=gzMrmJ(AUp(rsFy( zI?G9SvUNUv{am-Cub<<4kDZ<4bZdO~e28x640DF*4$ha(m%5{~%h{(pIls6<_rbT$ z`{)zh{_fxPJ?=y9Bl^GYLU*y=cyj~{9 z>+SV6x!wS8kje9gdP7an8|Do&A@5Rej0t;Vy|Jd1ca3+0Y3<$QO*8GiJG?tgSMM(G zF4N7s+nZ&&d-r;COfT;NZ?5U>&GY7&S`ZBw@n!e0#{z_kF zHxrZlCHFJeBo9a)XeJ41?S++g$5)(>6@7#yju!**RhU8eB8(;e3TKJy#m&H5;F^kC z;Vf|*tXjdUUkCjLY`YO`djsfyicO$53w$R>Y!UB*-YW2AGx0CDMq-=z0=NUt5oMTt)*HgJ)>`XCGi$xIS!7yoTknYm z*8A3WQQP{;+6Da9`WCp``b9Lcew9sxBaf6v3R^annV_@eu|moovIoBW(^DP~>?_X$ zXM`Lf3aHKkeUrRNgymE@6}~sin?c_qZv%Y?zU_){WXZe0nU3%JO4McZ!FfbJB3${X zd`uYmxLgFzv+_AnS1yrDMV5R)E(86dd=b9OlZU$?1zQ?7&jdbu8)4fsNN7HZ9Zf__WB1>d*jyTGjyU&urq`Z4em`H5&DKb6}+ ze<8m>*zNLL(7WaLp!drCpo?Wh*tW1O;o8#nKquKrqN$yXug}`3ZTkvo|HbYH`UHHr z*|PiFCxJfM9svG8dobwJ?9+s?Pq)tlJ<7g9q}bza`qC!qW$>@Drvh)br-O61Jrj4C zWzQ04*t6~DKrgYEAk-Fni%7EHwci!m-iohBC)w}YABYUp@Vz}z~5)@ zgUo*WH_*k(6-O#hCE@#N$tqc7s}z+Yl&Y<2gM%6$bUjs1^hLcN63tXtwFJMlYAp)Y zQR*ns04+fq@fTH~P#RTR)fW7AsvSbLSNLAK>YzFxR7cejoKC6}IGt5zQ3q`XN~}6o z9SgdLIu3MC)f03tg>QVR-l{kB^ii-ibv(Wfu2f&u7j!>`+*AEke{cq>fzUii4MM0> z)TKhIF=~vk)n)23ajF`t#)?kra&@^#QRCD&(VW^O(Bsu)(0@~Z6Qk4=d|lh7R!XE% zD+NR=1$Y&F4aWZsHL{4Z6Zm1p}r6&sO@S8WOk~ZkpEJBDMIQiwM(>6U*qe-QhlSohwoms7rsBJ zpWwSsp)6@sHNt31TS987ZP7w2t-!}mxY}qVPSlQeg`+*441S7EfqX4pOVri1bsf;D zI#q;pU0oNx^>jVxsjusUZlD{86x~p#fo_DaV@Z94J`(ax@rA}De80DuI7v6x%|!vV z$D$#%$0CPXV$hv*XJ8lIMRd?zbyv}oT4m8&_s~5=XWdKp0>21fiyy9g>)zsIeY`#% zoW8m*B++I=vY+k;$rJPm;vC&y_ZP?M3-P`1Jbkgg7YG4M z)lMucmrN09Gjs6bl+M~aRdJ} zOB`V&zN?mMY@$(#-;$?FPXQxvfCAcH4;hZh>1U>bS?aU4-X$b-RjYZa4Q> zk?Hnuj}r~to^Fw-?e=#2h$iUg4HS+$$UOyN2fJqo>7MDHDZ=hBcNpli+_S+y$2~{X zbXh?kLgJ9qo=5#y#J?2r?JDs9oL5+$$04D)+CTC%ThGiu*VBI>=n_ zP7|(sn|qr`a&LF<6dCSa?sU<@z1zJ9oSE({ailxjeE?zSx^tob@9rbexzJq*T;wi7 zN}qL~MH&~oixK}N?h^2ycb^9b{ZWKk<*vdVUv^&sz1m$3dX2kAq`9xTuY-QWT?_h6 z_f632-Sxl??gr7y{inN8hp%C$ySv<7 z!lHhyQ0Uic(8e>OzUO!z=p+wyte4`Yh!n4uS4$YLwukl+ec!qw;MMo)iz2U~*AR$) zusEK2z@iTIfFaYx>mr(>AB^6S*TXvwVbKo;e}FdtItO|K#j)NXZxA@>6T=sMV&J9T zr9yjSJmfj`jKR6an*^D^dDj82_pV1gZ}4uwU2gJj5)Hhm9{ND}txim=l> z^!L2mJ@l-o4=tK`)4k~kHN%?$yvMr-VP|@?L~Zn{?}f}9Zw~Z4;5`7}x!zpR=wSmN z^&UeU9`_zc9G>u=0{x8l3~+(B0Cz#3TO^^+y%ec?!FvHR%e)uCS?R3;=N}%Pl=rIl z8t6B?H$boT)`}M1o8Ft?tn=`lOzNFO{#|b?d_VR+27jkV&*E!uH{$%Ahp#bvd%V4f z33~0qqF%d5r(V0rre3=^f_m*Dn|ke{fO_r1MX!B;XqY@Oc_4bxQZ_~3y)zorF6hBK z+=Fk39{kDp2GIaGg}(ei(1XMopwAS;M4C7YJ$ncJ`l-O1(VH(sZ+<3LM9qS0B%Tsa z3nQL^t0fk|+1$TxCa7oMjQjM>xHsR7d-Kh>AK#37@Gg4rjYVVY2rE;xu(GTy^trpE z@9v@R-V^=xURE!0npI?70eU=o^A7jsL+H&<0_R%v>2tVG--!G4eYj8G2z~n5=&9d} zo_#~^**8GX{xMMtefr0RYdv8-Ax^iRwEh8lwe`9<+Ijxa?rZzWp;k4C@WmOUg&FwIqn9Lz)v z6~pA&@?4R|{eFw)DnvHsDsBZ%lhdH*HhG&U;(mV-`u%r;e;0cH621TFB17IS?*?ZE zMgkca3Csh3KE?w!#siOn^BBehIXoVaJRb0PJP_vbfEPC&@OV5B#&}@0@OUH;#z+9; z9J#i14B+t?Ak1R`4`YC>@O@9dCz^2YzX|vLC3^p#g0l@{fSl4Xz;@8zVkFS6WF$ai z0EsbxKwsR#NFW0v0RxU>J0b_OFBmfOs6b-Qr9Su#FgEZoHaG%(`X+W0alU<|js7lX zW%`P2j22D;eX@Nr^bEi_Asgd_fzUGuqlF~n`zO#e#>nO|Ml!}27W>Ns*&$j5pFS zpOl1NGL1KmDj9FoQniFrGTxw(Mi3*7uxO}Ss#cJs@kTcuZ#3ocMpukC3Pode3`QLd zOU4^C(nyILX>`LF19h%C4x@{1Ji4${QJE3NP|R9IM-*pZ?rMPO%HxV4#uaEU)nJS( z>hQRtA&)E0<8j4VJg!LP5rxI$ha-9Xa3qf(j^y#fkvx9TYJplHu8bQ+SQtMn#n>P= zahj1T8Doa+B31ntV}>LiGqmF|LmtKq-ylWbs&6q`*sXSpCh9x&9XNY1 zerSU6!w;Z;#3;gG6tNHV&+2E;zo=h8|EhikyS)iS4v$A27DgR)!KsIlhQ%Wdi5b2$ za2n}G;55c~qb0^0M<8qy-2@yObtLnsV>pjGy7Q>xLX0|E|9|AY4V;a2{{R2E?yoa5 z#u($AGh=4X-I#=sBuQ3sCM(G$$%;vm8Y@Xivh5_5>Liuwtd(w*Bsr2TnO16%D9LtX z+ioPak|arz%>ViMoS8AAw)W=t{r-QyxgO8!?p*V^uIqFAetoXbjkwrqi}vUx>jJTl zr2-kH6i82{K+aGKq*N)8?n-rBu2e^Ns|Tv%45c@^E2VLTQW}@annEmfY6@9XQ^;B> zja;QP8Y`udtCU7qDUDpEG#V?Vk!wk%5mp)_PHo~$(N`&rxHZd~#r}QPeWIJJUt~@F zB5SEPPPFD)bGZw(jI60;WG(f^7)$DnQcLQMwn}g0qBp8=|2b60V5K_3N_FHa)e%;z zqq9;SCo9#_NvV#`N_Cv9RL2QQb)2kJM;lbfhbWD$Xph!Pd*mwZ(Mf5Kvz7MfqqN7_ zN_+HC+M}`39=S?;gq8NlRobJm(jK`=do)(sBUfpUu+kp6N_#X$dsrwCsXb0t+T%2( zJ;F+RoU63QiAsB%tF*`IN_(89w8tq*dz32eF#^?btmt63uv>_;?3QSc4oZ7mgx+W? zJe0=qsD*aujk9DOD!)o~ahcK;SK6o8r--piT?|m_Vw_SJ<~fc zbLVpra=t)&1eEs3LwkHF3eX18Q&>`)W4v8uSQslCTpj+&Qu;y!ZNK4VuZG{>M zC^eF&)JOx=$SG)m&TeOMyn8Cj#8t|qg;FNRDrHirlu4FSCNZTH9q;*8o%{ie(6+EI{?cGs?b3L3Ft_pOpTA`GIogsn^Or4o?T>bSgCR#Q znUm$Y^!mtO>z~P-@Uxc5oj0F8lMv6V7wQ8uS#taTtpERsyJQWkS!QMp%WL0obnQFl zwa;tcU`XxJp)GNfC1+{VoTh6t6YT5qID2-}ocv<7wNokTT)1BTCYOeV zwR@Sv4lP+T*{@AOdPA8m<@?Gdy-mBL*PN@pauJQUz{m4+_eiQO$=FR+f zed?$GKWkY1--~myrm988vGm>#*BLc_Q~PHBWSfpPne*z$o?oBI8RzOREvMu!$l5@jGdWhCdEmJ14JOKTpRp|9mpL7w#V?IV zXE)DSMt+Q6WKL#p0_W2)Qs&+h8cbA2#hJf&$tuiPov|WwLdJ@tEjb6XT4!$jv86#W zvpFG9lQM$Itf@c8H|6!*^A|1+XCI0U+;fq~GB!2Hl}l!JdVTD|;++}qvuw}Unz21| zROaLmS7c_V7w*AzYQHRNUnXRYXW5svJZpJ)Z)WGrrzNGmrCW_2O1oU^cB2D5`|+Qn zGIpgG!Z|mq>wjaZy|3J6ZIBD^!J8af8nnvp&5_DMWO`G+$~(w6s(Y&~hb)$~%~0Pq zkS-`U(yks}Lhe*?x~>#YmtzekrpqQ-CZ$UvS;oi^t6gLmu}BxwdlSfM)vq!?tjiIJ z59v4g!T;6#58NiN#c-vCV9uq zjq>`;jp?lnd3|i_*d4}_5cgCvJY1t8{MMs=krybQP+r}kb-iJHh%HDO=NpmLu zFV9u-ALH0-!@2E@Go)J|S6A_0m9*e_q&lU|#Z~D_UtE#bwdK0*(mm~O)k*zzo?RC& zi@2|VyBYe^+?Qvi1qny;ygW+(rrlRvfr}NmSi$%EM%86CZjGZ6$RpL2oUi2Fs`$oU z^US;vM>TFK4rG#U8Kui&C~Z)Zzr!&eq0k0xWgVTD5}SqPgkG9^PunQpRr1- zlj^KZh@}X{appo;#FG$uRvve;wOQ3w_;wZlSB?+G%yufw#?kiXPbx$P^Ja5+&T)ik z(hjNrxsMR24TTS?EBLjFC*-?Y{cx*&H}&j}o>`qTg1D6Ss}#Rh;9{lvKUY2V71fE_ zcacwSb>SI%RwvXOxYD1^PCVPGgc2jLTgS0YKUqRP8Q&G8f4#>Y-mgv(;>6$TDrbN7 z9QRdN4>JDoEkh)Dvjj0EK`13?(Uc&zBxtFWa4&*kA|ZUWamCuebG*)blU`h-I_aAD zXbv=zceI}3*NxoqukaS3`7zJ6Po|-RU)#K|9pH``KY3LK&zTA8N}esQeEn$^gW^0} zT?*m(;yhoR=cC4;-j#9QqV~$MGT#5JD^&{l(JN*At#wnTPw((6>tgQ)!v1v?{wmer zLlyW?1wK@P4^@cFA9>EYyW_7P)xA{~vFA{{dJlKshkEgg(5xUdD+tXBLbHPJgSUuv zw9s3}SEqIQ8h8yh!e8MHcvGySrPw-JT&$yZYaQQ;*NJQuBI}4hufd`4lkw?L_+=2M zGa*1MI#^xh%F)%b4~xa`@!#p(MgHeuF`6f>;z_G`(kh;`N;H)JDdTWm8u%su-AJ5E zsF(9~^lF$73&p*BPEYXe_i7#CROkY?ihK2Cgk4RZuD@QLz(3-&(zsXTlFH_oq<3>R zJO~c~v#Od8!y_;k=D}kyA0CGVGHr`n-Ict_OR$Ew@#{}=kHzp5JOfKX-nRdAaarc7NnB3ia#93vc@8em!R0x)JO`KO;PMZB2XAj|;bf^lzk z8w2aZ_(ye>QBAzjKnKcE(}kH>2nz|HMF+oDmKA+038TK&7V^H2tIG+aa`N+pD6p>J z%#Cmp+ziaSLY|wlo`*yEtt>B7)^7L;zJ`6|sNC6RoC=#e+ZHf`V{KXLG$1BtLqlTn z8^qp%|3u2GZ>RidDs0L-C3&YL@08@7lDtz=l_SryJ^Y=Lyi<~QO7c!g-f0f+l;oX~ zyi<~QN~%~~ujJ>wlDt=v_e%0!Ng?l6#oem7TNQV!;%-&ktqLEkUt&ogq&ES41z$tj z2dlVS6?d!RZdKf^%05(@rMO!acdO!VRotyg6v@x$@~4%IO>u^xiW`}Xc^?1Jc*VC#4nBb^)KgG?-7U7)~8Gn zN6opg3{qGIDJ+8&mO)D8WRW_H>ZiiJzC|R%9qsV5!v1Q)e5ZW@gt<3=r<+?H!l>e+)K+ar02B;8keOQR!g0CNL zTY5*>mj7y~zeI?ysTcaM)x`i0TiwG}_psGHY;{k@2<-JEW5p%un1K!Ni8eoY^7s#) zJpOMz`HN!gVR7~)EY>y3a!tqG*VwO#zdU`Mr;qdWah_gUwesne#eGBL9#0<^ zZGZ6eKgZvHnY}GFTYa1RkpC;&8=X{}0*~hZ@p}G$$UaZ|e_Z+h@jpAhAH=edDU>q3 z&Z02bH-Yk<+*?{0DJ%?GLvf^q@$*vc;i>f=Qs%wzDk=7-Qte5!cNDaC6speVS++Ix zHu}r#GvhP;k%Ybrz68eDrB9NeJ)khIhKX#-$Nx_2b1A?m;yJzjc^l8rQV16 z)@Y+9XniJVS0;O+2-u4O7>o_deaagY7uw2JsxsJnf9f##Q4$E~Mmg_i_!#H%w zIPFnD-)S$yTG+(#-{2kiJG=|;!Taz5Y=#eE3w#7y;bZs&J_Blv&<5kso#SMkmU%LC zX8$yxCeb{H<9^lSu!zTD5s!1bP%3jC9Wf3aF%AoP92W98ANe0v@;G$GICRB0-{&0f z1ayaQ7p3?ayy-92NWAGR-gFjkI?KT7GTwr>fs)(!1pWb7ImV}erDJ>sSUbk&uoJ$3 zUGODf@flcr#vZ`xGxowaZ~(r?I+yiyEvskY1GDgfL)z>dj?rhe^^(?93d`mdD6rKg@s_>mz_|7bRXBNIQOZ38b%83W%#Dj9; zK{@fDoOn=9JSZm~loJoii3jDxgL2|QIq{$z-$~&+DSRiTVc%-hacOVBoA4IA4VzHO zCN#aM6_>m-jB#9qM;zyGBktBX3i62SgN0RuFBz`1`AJTWq@tqX4 zZgW)q-)_!*1*lAMR{h*fe+2sz+ta}ItkX<) zu|EUu25d>RQx97s6K+TIm&5J?J zi$TqcLCuTt1T2IUEP^LtF<=SQX|;dVKE`(bDIModAvN9r=nxkj;!Xv$hOajg=1t&=l(HQU1S9litSu zoglU8Qnoy|wG67@IgonwFKkzW)T-OqZU?@2U~{E)tGstwyQb>2D=`J_b4b7PT-aW9 z+SU06pSu)zPnY*}c~9)Iln)Et*9}gG^PwEZz&v=Sx+>!YXpc`{`2S4&yaL}PI(N)9Crn3!pOH1iyNvw1jQl%6{+%HIPLO|BkbhT@e^-!ySCD@v$iEZh-wAPr&{-Q`f(16n zx+xcYkO7&H1q~n@8bS^>J~HbpA7sbQ`YZ}BYpkiZvogXm87pq(pM$vD@FQB zk-k!-uN3JkMfysSzEY$kSxZ|%I;tQYRgjJ8OHqRDtDKh2>a<9T@!S%KwQQ+fCDUjnX*59^tssq7V2xH`jaFfeR$+}+kxnZ~ zr z+Dwr)Q>4ulX){IIOp!KIq)qB|pf$9Cws1VOgA<@VoCqD@BjO*rX;_k%{eXVu6|1-sV)e8BhQw3cySNd4x$GVUkCf zWfAj<6IKQgFD&AK)fk$9A5MjCwEKv&{WbJr{|f43Z-krRW=H^jg2g%xol$P_ zKIn>aQdAZxDvK0#3MuLoQq(EbN>@@VT}iEUCAHF(s#bbi^=#|Y>P_g5+16)lvER@h z<$P}`M|YI-y`>!8QEm&+!2%nc>Nb?ZK}z8u+M}FrFXeoDDR=guMZSjp)u%Y$(XQzL z`M*(}MQY7*FC%Xs1(yTyz?}eB!$i0SrjW8pi73JZiZFp9OrQu8D8dAaFo7aWxP+BU z__&0NOSrf%!#a4i`V><4Dei0BZv(u}{u|hcZ?gY3WdnZf!;eY%S)}|dUtjil2H#wG z6dr^5@HjjH!~-Aq@e%I6H{mU`QJ}gK%ba#;;(664UCSlUFi6)H`B|cvpPH6`wFN)Ez>O2{l9W(P#W_)m!{^`iWnw$q}9AahAT` zT7X{OZ)j~8L#{wORrcN1Cev%Xzjgzo#r;NmmOk3Uv?|#zH|yuge$D#%^lR>;-z@tw>(lAQe4c&>J(q{+chg&Wy#AojZs%1d;1#A=;3?0QA&T_F~;eP4RoCmH)onNjdRp^ zb^T;dUgKOfUR{4RUfm!yUfrd#H?EO1KesgFkMxT58H?!snrHlp{;dJydD)xQctQ4N zHD072YsmPE6|o}5DyxOn!dNYPuo^GXYqg89M)p)S*2+Gr#yZ*m)OeMir#Bnx>1TSI zvC+E2y2E(Gy4$+jcvJQ>HQu6!>3zoAvTv#JH`%w;ct`dvHU2L9kQ(pOhx94qJvm;T z@qz3yYJ4nvj2fTNV|1Odjb5U!8{1{iP-Ca;6KZ@xpU{tuU2?oSW4HCW^|`T^UY}nZ z-^f0m#&`7Y)Qto5<#bFT`)`_t?73;0^wTUfEjwg~%nW)*US(#=9+75C*%#70PWFW~ zTg$$X<_WSFq}f6Ce>6{)Js-`^vgf0DsvMWj>>~R)nq~BG+-aUcf5xxPp0f9%dA9SN zD@>36i5cd3^hs=JULgA+nnUGCDCR|sfzr|(P9MWl%&X{E*u$)(=ip#7K@Y)e%vtpH zn{GZ!pT7Iem*r@7=3DgFTWtPaj%H`RCr1x4Kaiu@nVaQkcIL-&d=T?9+5gVmL7%%f z&7HEhowpAgWdArz zm;K``Lyl=@nX)&W<;c~z@nw^y=d$d^v^kuu(YAVOEvqEwlJ1Zi4 zu30fTj-6E^$FZ|o$}u&p7>#WYQubK5L+1JeKDo3-k zPLtzeSZB$;W>#-GE{1is>}6(ovX_~4j_hS-^^?8KtaIgPc2<9FHe+DKMK?Gdx`SNg z{4Zxf59kN7MOS|~4+g+*U?7|igJ3X}!v!z|E(BUjiHl$u&}vH1YD(~3Nn8pQFamxH zBjGX_1((BUxB|w&l`s~@!Fad|CcxEj4NQR>;6}I!rozo|D?A7f!5nxP9)Y>=D9nS$ zU_Lw!3*ZS@2q{Fq%8WXe{V|Jvt_!H0ySkQt@(1J`n3$!8=RX{5;K`TT-8%T2V zxS%zepf#Cz5&i-zVHKWwh~b{C|L9!L7$b3=>lt4p&ZvTMeKy<= z4*>B)e+Y;lj3*Ljbiuej4<3X0@Hi|0;)PDU(1{m}Iw)HR#u*tTt`kl=VWhtUe}{MB zJ@^1N!-ueiFP9&&-3p(;KVTbt3fti`*a4rzPWS@$z}K)BzJY!4E$oNy-~iul1!!;< zj0gOeRvB@FcQ$xugLgJ~XJZ=h-o|ve1MY;oU;-(KW zARAi2aX`Fc9FI7oc*ITOlz9qt1;Uw8JK`qcY!c3l+7UNS2f7?m#0 zhzfB=FO%Q3;|_7q!5!x`z%2*27||>4?10Y!f2U`CoF4UYXE%HW__>=2S->;WCqC}x zKqJV7#*hbo2tW{;LLqQpw-`bYh6qF<1}%a2b$MTU%*Wk+a4uW`L*PQFfD!Op7ztD0 z2DlM!f~i1QySKotkO0ESeE=Q=!pJ3zT*8Rn>v2ZaiZg;%oc`l+`i;lwH6HhwfWOgS zJnnOW@Su;l>gzxc@Hk^t#p&f8XC$h)?{{!5TnCfkdf*utT`Eo=?YM6m+z!MadO^qO z10DB$3fti`koU!J8LuhMcua9dV~R5tQ(Rm4e`U!d+ocdH|7%MhLg+tI@-!g?iT(eh zrB4Up{ZE!a8abs#PN|VoVn@X_QlUmF)JTOIsZb*oYNSAoTvB_KoVy!zhd7Xv{o5th zJW7|xaA!U|4h!H3SO}zgRa%kj*0p_Sjz`sYME2NthVx5d8B~F61t;5+EQjYgUI8xv z{Zv$+ik0lIg4IyJea)wE+edWm%&rPBYFQj3zB5hsscdJX0LMYMez1{bqG9AsOp z3brHQw=fb&FaNPp>sU$`Sz^)F?k7vF8@T3ZB^Q>^&nms@ms}p2$wM=FXeN(5)k8CR zXeJNMicaqdi9wnEDZt}z&co-gmx$r2El3qTLu=)rhi>xFO&+?*Lo<1lTppUqLo<13CJ)Wzp_x21lZR&V&`chh$wM=FXeJNM=)rhi>xFO&+?*LpOQo zCJ)`@p_@E(lZS5d&`ln?$wN1J=q3-{vM$JhYaF z*7DF=9$L#oXUUSwqvY}^xjafPkCMxy~rR4I^cOLrAL*IGmI}d&5q3=BOork{j^bcVRd<0wJ z6Zi*ggHK^Qd@4ovgGp6TONALLvMNLEf2lr zp|?ErmWST*&|4mQ%R_H@=q(Su<)ODc^p=O-^3YozBLfenbPCu{qD&G*Qja3=JEv!FMe4Sm3azHkm;&;0+cX7Cou6RFQ`Yc33;~tN}e0Urdz!R_#Qm_b~gvIa_EP+44 z)9?%|g=b+IRKaubXIKu;!wPr-UWC8EN>~M};U!o@Ywnj}ZFRX$joN=fGyn4%-ujyP zNS%CmfAPbui&gZzS*5Szxzn0>6_&*+EQ?k2x>-f9n^phQnpi)`vsF_ItAhb1SYQLS zfd;jKh7U5tDkGC^7NA)TY6p#mKrN`z2&e^Rur*s(So&HwVE5v?^p2ue*G)8P)d6Yhc;fF?HYfqNkd)b5&#fV5#Q zhNpnEVN!==J`2<%nN{!{{27)5*0@PMlKBF>2!8?6i@6F`!%MIRw(=f~j$(eo{y$(F zY{wei$@UA_1z*B$_zJ$}x4rNU?Bn=b*bm>q0r(z>=QQbxTf}dR_-thW@mX21IassA zVXHAvk7-f%(dw|=*-qQA9n`aY4&3{QuL65G_cd_Ox~~HbXbVPM_|Y!}P52%6f6-S0 z+WNW8pcIY)+KRcyLJMe#Tg0`xF9@|QBTwYF4nRC}I|6OpT;iEa+dh{zZ!T^7Xgyhe z)GrRCyLuMysw3)ZF5~x6a5)gy7-2W=QbxHG;TpINckhB3Knv)fRkuSKqP|K{b}*Yq zoDp;5F7bjHJmSpU5og|x^cM?3+c};383PE*BfeS?u8ee>{(2!>d3Ip`RIy6c1NCK} z{D*lnj{X&6N=;im(#H{BGwz@zH};?pTTr#(BmVpDV}CB&N8vG;50AqWu!QTE!m~hp zXReDlqr@KiBJw)t-{kl$_!PFoXFzjiT& zbua7HPkV0Ug=0r)E11P$jkbaL88&O%n4e*v&Va*ujvmy*dUKYxw8rUbG}n9REA&3J z@)@EpVm8P{`e>K{l`s{iLlPbU=2X*{a{U^8gT6`MY)18MwCmYt4KoDoXj~)52pVCd zxzU!nA-ftq%%IVSSqFv~ml~su2}Y$c)tJt_0S_4Sj77#$V}-HC*uWeCo0$n1J(edU#H zk2mvJw=)Y^pJ0Yrw>L{!pJ=vX-N9_f`XsX>>yBoZE5{AJ((HcaxY1XdJ;zGd`b@ld z%;n4+(1G5Q?SygqY5l_Hl(Ww66*f2ZJ^QS%)k=l0R@hqbNmporz3F3Xps?k!Z&Lc$ zohD3qoU>I}a%(-EKDPR&x7iD7&M&ArUzXlB%&T!PC+(h9Uh{kFx~+^~jJaI%JM-+x zV{&43f9v6z?TYl)rYVs8-DZ?=xpi9AY;R0&na@a_XSSmBwr|aLWX*eQOdsOSuF zn&YuG_pRAB7*+Fp^V3^OD)s)gTWenW`mA@@x;#fTy``j6$CPxYJa5iVUzf>TN%DE+ z*mQE6UE{CWd(y{@|DS&EsWtbhxjxW5ecr7J7dpPCpZmu2Hgj5fo5y@~(%mMEXeYP9 z8ux3%*Xoo$Z}q6zGRnEU&Kj29I-}FujGFrzW75aWYLvc?5%lEscFq6QK9BK9&H1(I ztnC{cM$Cfh?EVEvbt}!Q)eE(kV0oG@cyK17hFN^ir zj0>)bK70w*s6QxS-Pb2$>N&plto!*ovp(0?oppa-FV^Rg%W7hPZxCzx8?$b#*7Ol( zpPs+0@jBMIYJI9&pRU%8oUxqm?#MTeD}N|+WN4h>$T-u(8NvG3&ZVq-I>T9?ss8H} zweGCeUDWzltaY^~w;e<$b=;M@4w9Z|Bif1+n7M}z%A_<)`G!wqa@;`V2|u}OfhZKk zBFwx#C8AU`7cE3OZl9VxD|=D)%Ir04VyQ7I%h_s+1bSn zJ2!kKXF;Q-4f;a*KVw5-;&d*QRm!n`2{XE z`7gLBefvNCoPnR=rk39aztZv-ncptILw+ajtn*B=jb*-sqmhiQsNA5=Q4cO{x+}k9(_NeoHywaG z#EpW@xX_k25F)@Ct?5wCt(U(*%bIH#$G%`ozD(N!zvrrgdE`>#)s^zxaq?XLE#R;D zPv&vrh`AK_ue4k8jJzMSkQLlha8GcBa;+&>3>R)VD|~JE+QKn~YYW#l{iMx)&JGi9 zenGz5R1ajy4&PLAm;A}5zko{|WqJ5|RxO0#524~ASdzLlWW}aUA zZhN6~uk$8nyK}a;Rc`mOue1MPFLsj7Tb%92*)y&4?K7CsW4isAbGP$X^=^7#T97af z_TW9`yXt`{L3}pYvF2DKY|Z?catW+dZ(me%UH`y-={InE&6%E*<>@n&`*JV8BZDQB zrhJ|rS2NyV<4S32yt@So#0!- z4j!mo_*GsV!FQ)Iw&Bgp7<-FxtC28nGo~50W2@c47Xv*wl$_*Vk))^7Oz}rCOWY@B zi~Gd`?yu#216_sYpU*b^bRD^VnaI)?>q|4wVkWKC`dap1!d`qye<`zf%~SLdPH_C8 z#s7eMj#$mF?SvZ~P=E1HR=+pHw-1O0M|()kJ-NG0A!JogIa^aYoD>jIX zz}_D&{;;~{Sl(bd;~Rc~W&5SRn^x<4Xtlmq|3=@Zf2;4;zoXUgLp;eFf$jyvkJ&C7 zG+7$xarA|&m?zPmV?Sa)YR|Lh+Y9U`>=g6AJZV2|KVv^@FSY+iBx=vhoi=D8i z*|*zw*mv18?0f8c?WBF5J==c3zTci@&$R!@lZ_RP?E<^$&vCOLM-(wf%xAQp{@mHg z+%UUnL%rMiO3p{gTrjkxcB+{W_Iu}`%cSkD=IYD}^PT;mz0CR6IgpM>8u3G;%+&B% z4f{&Nw$!lOG)L$~h0H*7Ch3fM)vfcbLDpbW(HW$%UyHrs8?jG(EB1@; z!~yZWI4G*ghBZxR!Zee~Zf&OPbTyyb(_MxiZeVWam|mhc(@XVZP&mixE%cUpEB!b* z^Bj8Tc)gu|g5F*~QSYFig!(yI@1&oich*nUyXe2tyXvRuF?Xi>M|T$Q=aMe!{ur6E z-k+9H?*N1Gup^lh*8OSHuBrQDM(%ole0#3<$5-fje|(Rw_s5s%dViXdeM?r{lBpX+UMJY?7?=q zeStm1zR(_OUt|xnFSdu+2miRUpp@qFecUO;b-71j&Zi?Tn5waQv;y=1Mi zUbePa-&*^bi|c^(y>(E|#>HG*x}1ZHUK?5TyNEbZIq#Iy%qew_ahf~FI>$S$oi?M>Tlt1?QiGr;P2$` z;_v1!^Y`@k_V@Mo_Yd@!`-l36`$zak`N#Oj`zQLZ^-uQS=)c83&3~u=9{)`LZ2v?4 zx&Hb7h5n8H#r~)L%lymzFZx&e*ZS9U<}Lp_{`dV`{Ga%@`*#X0x`q4yGk5-pEB@X7 zz5f0Fg8`i>lQRO@f!u&UP!K2%bPGfSrGXZK)`50`4uMXAE}SU~^bGV4^bPb63=A;C zE_NF8WuwS`#Y}bGtkan#yNr42dXUq;XT49aoGtXpxsMsE=P*q&pOxY zZ=GiiAcr4jU2I)yRiG6wVQ#$NGAG{U%#L@NHJW}&7g$5A3$3BnMb;SWN^7h&&KhrB zWlgZIwkBHFSd*;ZS=U;X)^*lo>w0U7b%UHekGb=1mUHIOlj--&mp9G2-I`AMtd*b_ z3$UGI)5y#?j$O+!s~BZz-ts?+%s*cLo;Z z-%~i(zc<(}&@;bx{>I?J!i->-K%ZbT&_91$aBkuI{{4YLfhEBu!55ppBf}^^JHI&a zTtTbA&|uH}A%xh<{P{)xKt`~C;L`jt`OEXC6m|{{4UEcf9T=N`Ft{NwQHCf_X5hvW z|6XjLbZH^aJQRG$za5K+@>4y%5u6^J?th;%jJl=HXfaf4{*9DZ?V}58&J5(tSoWng zb|Nlg14pH$jZGIzTbf!_+Sz^hrB95SBCg?TsX}5>d#C?PE6CixCKT0XxS zm?@VgSglQVa-Do$GjO9^nylyC=DKrZ0xV5daBgGGIW0=~2Zsy8pXbkuq~m}Q>>KPG zL2m`IGNX02b`UKT>=Lc#1JN9=X~8vYaZf&rMQEv|NgwVqwB|0Be_wiO(v`D)>&|W= zCtzvPmb0>6ApPWTVC}sTK0rvnA+*Rcbr!!3FvoOYd0=^@o=@_`T40{goAj4^T&cpd zN!JMB7r2xEW?OUC@Q?M6ZPH$7d22Xx=xn*ayb14=xAd^HJ^VeIAjlsMqbyvu3_HXj}ORg&3UuQ7`f!N z6I$cdoI7-WU=x#6FJDfYQBxcmv<9~2wI)8L#vE1j(cJ6l`a2|B#I1m5e=pkpG^O*C9 zGuL@k?agFmjI-2v)>-CMInOzNc9uKO zJ1d+QoEM$HI4hl1&T8i+XN~i+v({PXyyCp-tan~>HaM?48*9~w^R~0e`J3|&%io=M zo%fvgoe!K3oh?5&+U$Jd{KNUk+3I|(_O>~n%9xfr_t4Ua@++rS@5}h%W|3w$W7X^+W$&Y$GqFT+utN&5L7E3z2YaEghXqFmCk3YlX9OPz zE(k6Sw8tjtibc{ZxPdaYb+99L$$&t4U|3*8V02)7U{YXmU@A2rD}&vFd4UB z0&@ckf;$3>gZuN{z*6$Vm4UT^4S}};?*_I6wgs4hICPMfx<{!&_;+n(Ux$BJ@1^U_ ze#)vpT5ZF>tE#B6s@2T{>y&f%I_*5JPCegNr=RE6DdK0nvk+8C~5*Zm!#ySzYtoCO+Z*+NZezH%O1_e7Are z)rHJ$+S5JL?d6{3F7xSbkv3*tpY67F zkC$`4${Amo@3oWL!R_dt?4Crw>{FQewF`5-c6Cp4PiMB*?rz*=$z@!_dIuiJJ3Df9mE{4_cQ0|VCH`v;$BGa?xAwtS9iFa_tpK( z=eQN_2%qcz)*b0S;PWYexy&8q%WyAuN4sO(tK4zS1UufH;LBt#*op2nzAX1z_xH>Q z`#ZPN*T9|ZUhiJ#%a-*@_~#V&X7>j7CU>fPqs#aZ?yX1h-P@Qo_I7u=dnfb8-sR44 z@0N4M(u;gGGra!I-Q>RGzU%(o-N^i{>zUQ{b^4UQ?QWn?`78EAc9px$-R^$szVB=3 ze(tVtcQUi%XdT5Jwx*hyyVN9I)(ePys-r zxu2)?*3YQ{P_gk}i;Gm&8CO$|X~uZDrnR9)?U5GR02={oI`kH7lD}Ha;6>%)mvXId zR@d`&BeYW4Uz*m6>(CRSZSoiSt%U#Bq1NBBHni!+NJc8=7cF1@cPI(+ezRb#e`aBjyP^)#7_5bp)rgALpyF&HuW% zzr=c4)djssO@QPwB> zRn%zD!}44!pIeUGf?0l@F;%?An2;_*z8$`N6W7VBHFdT8I%d@W zZ#8Fk2KQ-n)buD*qpUC4rDmz;s-xDJQ}<2{ysV2~YCnrxS^AUuGy1c%a9O3ltTX$P z{<{8#{-#|ZnuK%0twWnadqNL~mWRfM5}_W1S2)zZ_&_MT_?6;!ix(9yFHROeTrA^c zWBcZ#*5*@(Pffn8)4!iu{pUn((e9!H#ddK{aY1oOaqHraMT?7;6}?!rwrFF~J4IWH zwijJnG=(=e_09AlVf1eOWA^_+KM_mjf_$0O@n;zmG!+vx6%#aBKO|!`DN2{V!2T|4 z7i;Q+csflq;XN1YPpNlZrdRR4D|zFWXxH;H-)q+Cuj=b--(9|q{-k033|}q{O$yx@ znjV^oA1w?m4ZRq8CG=Kkb7(uhb};OQbHjz<(s0{wr*QXh@9==|(D2Cc_;6*YeW-J& zd#G2aUuY01VI;oWJk(mgwf3DJ;H~rZ0_OB6)C-wWzK`2ig!#>)js7Z9&`b2|(irRL zQ<00Mk}tw)4)%y>`NO+}Zwb!`&koNEFAhH!ULD>LekZ&&yfeHnqDQhK{zy2|BGNw6 zCDJ3(H!>(PJTf{mF)}4GEs_jp@Z1IAXt+hV9d>NX(3a4S(B81%d|tRX+&tVa+&Nqp z?h_su9u^)Io)DfKPK56XKMT64=Ch=Y6*_Hg2(MMb zBD`Ma%iTKK6PtwCYr-YQzRs+0Z_t`JOMjF0#2I`qD!?U;FaCFl`?MUbDdRj%*6w6< zrcd>~MgwE8G0M2!xJ~9T939 z{bKHW6Fs}K)Yt25m5b&u>eG87SO0)sO8Jc1)L(Qk1{%Y}$tvY`Cneu0${3yL4KcuY z%lMo44P!L@gE_=LHNFuej048^^gvWOd}upcQc`Fq5OYJ+Nrd*mUf2iwf%+IiL<^IP zgn7TP3FLxd7swgHS&$7mkPFnFgvrChK`4MiD26aZ0i78}Z-<*h3upzcp)F8D5pEA1 zpd)mG&d>$ALN}leAzTLJ;^Cgq3wlEz=nMUzKMa6@FbK+F2n>Z`FdQz05ik-)!Dtu* zV_`f@fQc{(u7ygN3{&7nm~>+av}whl1S@F$4IwGufhik z=NB$1Twb`QaAV=Sg`X7eD%@XW7G)O&i=suXiaHc^W#;mJMdd}87L6&IRCHs}^rD$X z4;L*gT1sB|O3_+dX_RXDeBQQ@+}m4)jIHx+Iv+)=o zW^(K_+HvS%KXG3tH;%H765n<5F>>5+YvQ;bZcpsi$v?ZY?n;c-$=`ah?j>U}rO171 zJx8tYS8HMs=ZQb89~6dk2RDpx$8Z-?g%R!+?m*L5}6*kCo(JYP-I?YA;%9#=0_Gqo{l^hc`>pE z-(tz+ivpv3O~^b$xRHgCC6Q&36_M4ES0WoDn>eGkk@q88BikdpB6~Tbwvhu-J?ciY zqj>^RD7VpqXgFFLZ53@NeCchpW3)@Od$eb?PqaVhdPI9i`$Y#vheU@*M@Gl+1;ZB| z5gi>JADtAP9Gx1S7M&5DDKet_Vj`M|-Wg3sXGb57&W|pNKF!&=(FM`P(WTMl(UsA) z(GAhJqVI~#=)2J^(QVP4(LK@qF%h$4S+U$$khs9yrONVMT4VcuWebrN-4)#%JwT%X zH$pSUY^dhmCYUvF1UG_-f6u9>L;&iWulHHr{fPDM!B(xmeEou;nuC zOcBO<&ZnhJPOM9GYjpdMxg4YY3$c*#_;6d^K~r}y)g3H#2Up!8OWmQdx{QX36mYg^gB^dfXiFXEOX7H3vH3E%fTwugdYQM{LORN|zO^mhhmrbt zpRjX0@1u#9SXtflo|NvxDbMd@6vrpk=#85hrO{$U#xo6%lKc`%@Vh9vHyIx?qT<0H zwFd9!ebY8~fUwDn6~;>N@%GWeXf)b9+B(`k+9}#KS{CgU?He5sEsqYXjS(X7!!w8C zNc4dtV}l6BHpMo_w#9bE_LYdE$BS4ocW)7E8|x739P7q^_<5data+?;tbMFgtZS?+ z)+^RGHXv3W8x|W88yy=Tn-rTIn;M%In-QBCdq6a8wxro}%~m#hrP&+J-fgzE*^Xv= zVh_jW#}>t&jy)H9F}5bQKK4fJ9iHQp*pArl*uL1o60;R!MG2u%x)8q@+bj+ma3?olClv z^eE|F(ywG-$&ixaB_m75luRhOwq#1lEhW=S?kSnY|BWaaT{6C8Qpx0!sU_1&W|Yh< zd7xx&$%2x_B}+?|m#i#VTe6|#t&(?3wv=ou*;%ruWPdZ!%oe({ou)0i^O=u4*V#cY z3f=jfeiXX1leWIP^96k=bZ3{3D{1dRIYFBb+DFmuqXp|hc1zZS?N+SIZORqefl!Lj z4utsUFg7Cl7ulpXXE!~Xb>}PkH0!hwIf4B>K6D=KL^`m()IN!Ig-zOVzNV*!PRo&# z+22b`W1Ti6lt#`s%nqbG`{)s^)28GU)|c6xS&y<$WqrBLmq6N>{EGDzHszM}p8Ge} z@4K5=f9Sr$dW%cjLTju0ch>W*;jACGE@Az=H5!+zY0s?FY_#?RJ^fm;I};PVTUKSm&^R4ei(NvKbwc z{Yls?Gwd_1bJ@R^Hf{IVXIcH(|2?hS?zMYc=doW&JGZ1QOJ@re@ql%Kv)^4WY}))h zZQp0jwLRLl+qD0A#-_Bl`&t)sG!;EQ%lh6v&l=CsjkJ!NNvoA}W$SeNCe->LX~ELp zx|;k=>i!?pfKaP`Cb_T7cQaMKn@zs^uxLn5_&C=;MO{pQ@P1wdl`77cttptBa;vpf z6j?jS8;i+_vqVSP7D9Bgzqh{^#4!=Ix7#~~meDU`2GDp796P_h*pL zXUxfXg!N+?kF#Esfo98Cl7U^5@m$8AS+B@=f%RW9u!%EX%XpvlhZ!HT{wU)k)*okl z%=)VgEXR!RG7hk=&ZwqonVD&_wliJU8JQWZb21yT&dY4Vx;V3#bvTn;JhNG5GuFq* zUJRLSGmmHetIS`q?w8q*bwy?c>nk#^kXDm8Rh-5+!u=Rk=4NplJ=a%h8CpXvUn|jC zQO_ku2Cmd@Q)2_K(bj1j=|QyXsQLY`>wU+#i@LHWsBw6T67BPJ2_RdZ*f&$EHE;@? zrcR;L&N+d*cf&^;{F7(st}z~D-BUb9Kc<@JpsdQ%L-oq5+iFTI*~av3EZ#3_O09gO zfRd}W+`8vb$z?X@UC!n?&fq!zTmDen4o8)Qss)a0h4p=1`>XoC5~l4{+Gl$F;EC@2 zkA}^^@=Ur2)z!g7se|dJ4->~=C)^-~6OeX$s+FQJZNI&~Dw#SH2w zR*9K}$;;vaS&t^>P%rVmm`4ch6i@31^aJ#BK4|n4tBwA~K&{9aWQ^CM*cjJnr!uPZ zRIRJ54bghZ+7PV|p|?*PX?$bG5SqtHPoL_X z=Ukvq^9i4=-|GwVMRPWz06(Jt*|*lWp7CNd#(z4j*5*g7wZGxB)aIzz-=NNF8;spH z3SXsm=bu_{hgxvSx>IS#k#~}wkE|7{ZH4v|EzN4{jWki*v$$VzdGV#iV~Qsg-&j1o zcqVnE3yYT)zeug=Tg97;w-@gzJ{WRCxuL>PX{c?e6Lo>TLj$NqA4#owW$2dBjL_`R zJnGAy3#|@qptfvlXlH0&SV!Uc!(kL%dsJo*l;t3F+i3Lo6jWL={7`rS%4`Kn?2YjI z;ccj|BkCPcQ$r#nP*T^TpYB98%|$CMi>!>Sk8Fx;iR_5%jf!XnN~ajxwOzC`c55H> z%&_RF=mf0OMD!jk)A`XQXp}Y4jo6@{pbPfLOw>jYJF^vbXV+NISU>E`OJifOEpLoX z$F6)hwlKC7>+zM?TUd_UV|%a~U2MKWtiZMkTLwik&yUq!Jr%M#=1wd02AK zm8`~!d#7Y87TmsOdb6x%{$}B3Et<7&)}>jGW__CtYBs#t=w=g}O=&i*S+dzf%@#C! zy4i|mYq4G5Z?>)3ZmdwdG^eznw4}6kX~)uTrM*h~mkuc%Q98Et+R~||cb3j7om;x7 zs0H;Lor=0q(sB@V}UB@j&cT(%}P|^G&>Zo@Y?Jw4gGm3Mm#f}!YC~jBW zskmEFF10tsMJ1%dQz>Pr*(CL?qIO@_*k-C4+d^$7UxZqy9HynJ>ni}>b|LoqaD3LudgQb^9obmo-TTe z^TYr~jTx(VY9=X3q>T zAVENqfB{q#R4^+>1k5?-gb}l36%2?uqabEM%vmvDK$sy(9LyQG@9MRC4thN2`|iEZ z^MC&6Tff@1tGcUJt?ubvUDf?Xun><}6|4!?vPR=)S)bvY3mMU_=jywru9NHHdb+-D zPe!;$x>4>3&V{G268SWDx;uk&;uY>nRwV0Mm+@|*o9^y*_qcmmo&1P<)Xik({EN(s zml^UeGb{cL=Eg5@U${kXv0LJnx^LV%_iY%4Io<&9O!(|(GhpRfNbWr?F3i?l9<4~v zhYRDc$#2`mps9h;!DY#WKB|?tWUm8zUO-I$K1Jam-ywfIKr3y>n!ff$JXn7?)08-k}Jy9 z<|@26S2tHLS3lPv*D%*8*ErWC*EH8G*F5#b|4*Kn7bM`WJ!1%bgtc)6{jc9W23ium;=V+MBYu zb~%1)Q)*qVcBDTPUx(A^p4|`nI4O zSWi*dZcXg>LQJ-z-^z9*M!77 z`&Zh(+N*7D%)M4^|6faNo@z{7ljpCw{+cc;TeEHby?%fHhUox*$@|ys{`+^lB>Hdp z|61aozD?KG{?}6c=Ki<;#J)xUmiqVh{HGiy$0%4dD-CB8IvJNJsHDngO`larpOxlz zGQORDKf91VyO2Jc^aOulJA9MHX4S;9Z)JP>t!y!iW#7tHHBGjg#q?WB7QU63ek-x; z+ic5hx8_@^t!zc+qv)0;mX*!w%y)%vC8pm>Ov{qL=G$z`l9qj&ZJDjrl$9-4q-O#- z7yX`Vms(VHR^jvPg3c-E+=9+S+ZQaE#iWd;NhysDL8B5AjX*fF#pH9PP((u_dd@c=T{Pg793u*Xb8orc<%(fzZZW_LvhV#`Y+Y8e0!Zc+3niR&b2^qg8 z9G!-jrr~92czGILk%m{M;ZV>ISXbnzU6mykWAv2U672kMTFz+QQTKp9W;~l02?Obc;d2z-xA*8`pLJ^ zt`d(9lF;;*6tg|yI*Sj)t9izxZ0#-L)s~|mUT^VgQt;|zY)~$Ff-=H&Ji(AX2J-C$ zw}+&=Jte2Z=i_RJ&&TT>-b)I;nv4xQNS?5x#AQ4<8OLu_@|c0#oo;9=eYwRfUOtwc5ueL{~dFG|xzLI|XYWl70tJ=OU-}207wj6NeCKCdVT-rF{c6}ue@4At1XQbagk$(GR`t3~lmS@)l2~Xc9yu%EUoMtHT z@%(}pD~VMn@Wglthovb8rlsh?qK4*R;;YOd#3OSz-;Ou;q&e?RbKV&H0FIEqIjp*x)fr*#J+#TfUN&7D*|$ zSW3A{;*;#9@~yp$aFxBBlnFf9HHg>RD~WHiS4n<5M)EVZ&6at(xa@tUlnPc!Dfx{? zovR4%;JM>cpLJ=@YQo6TJM3M0XO*LOIF_Y%);fA8+2lq_S;vt=eU40PPEE)|O~_B( zk|~b*kcaw^hx*Vu>cf_=CVi~klJsiZg>bd)Dy3{U*@E4Q_!`??%Gw^p*V~>_)^Z$C z79Zf)sZF@r)gfHPb4F#qb&0RxS);PY`o!0}2I(FfrlpQg^Pj-Co4cCrO*Sr>KpW^STKK1Ii#d_v0rU{H zXX~`{Tf+73JK2`|o_MueOSsO_f0V5zoD@7KIfLg3R|hXh*HQyM(LFd!&pvZxD{<34?6Md_cI)d`QYf z^AX`x#tx~2`HXNfqlnbgd`x_T`Gojd^C|I7=56fNl5s|tjAg5M6nns&*@N`;6hkj__B%!P7Ra}2 zg47d&)Dr^P+SmYpz!KsK69e*dM3A4qCinyPIFE1F2j>%?99%%WI=GOnbqX#b>>ON7 zxMgq&VV6Mavo?_WYzn9k=fE=wmj`DNE(^{kPZXR(*phc`xMVzSJuB5U=4??~aZdWV z+MI|ltivKFrMlWa#Fp3ChY45PN7&kU`zYa9`<}2-KO8fuN`jzuCpRYLhaNJJ8}+jY(N=nh>9CO3BmF z6ceAo)6&GR8W7)P8WN7<$!S4RGrJ4vYwRGx)pjuH<7Fh49@&xjSi39nb#^!66YcJV zf7pS9ci4kSUvCd4&K*s{33e#qRJ$kXYwcddH`#p&#|8CBS!4esTpiE~j^Gx=s{?9| z-%33v1x=|*>wsFZuMMP345%C4OU?0HYL4Gx6Fe4c;IUW$j};4au^S1uVE7^^>JV7M z{epn7V<5Jg5Qt@d4C)g893*UQZID_Z5L=B4nv=7cYf1VV*NSkpD2Egk4-Y-%fC?38%WYd7iS!EBnfP+ICE+r8!dZH(F`|dAk!P8u$6AZ@ zbG2!OPQ+JuE*HAS6jbvwYEbyB`57_b`JLGaR~DO9lQz31 zHm4>wwDi(u~!z$%8Jdhw5+VyP1D43Su86nBTZRaR+f>OnzXE}SW)wd9kWU7;nVlsqE1TI_(z3Fdon;&^+b<(vg?(gpmT$BDW_Fg} z^J*)JX<3PBS&8X>C8lL1ru&r?~Rl1=-VyEgHu z9LzrZ4&B$xl_x3Z=5FNajk&qDn%k-5s zjw-pWWLnAdB@0TvDOpwWQ+{e`-O|RTC8h04`wAmJ+L!HLHmvOMveU|LEW54j@v^7V6;U$x?%Q%(?pXEb%Nv$AWsOt2 z@=mOB>R!H0`Oxyi%P%Rvs{ESrTUn{}MEO(Y&zFD5N~BN97nd(D|E7F(>!5Yqx^C+R ztTxKG?$o+BtBOXnKC1OCZ6fB_wQtj@&FD5`+FaM>gSKtj9^3YVwyP_qS3FcPv*PKB z7b{+_c%$N-iVrGQRIG1jnESSEyOHgVYIj1rY3&=fZ`%HV_D8nAy8Zh0zjtWZu}`PC zQ^QWJI<@V5VdqP>+|;GneRtl!>A^0Qrn0EAQ{`@zdsZG=IlS`t%F&f$D#uk$uDrYQ z#maXpS5*E~6;~xyb*mayHLGe})wZf*)z($pRUJ?@yy}RmSE?3QRV{gA$>&QJR_Cgd z>IT(~s+(3ieqaSASN$sJiOsS2k|q$=mX;%uF+n+1>1G z!2!X=!Bxy~zR$&f>Em|v@z!ofw+nNc&UEK9|K)m~*n78I$a@ribAN`T!)br%<3aTC zp7ikn^zo=dAI~ZIyksToCjZReURtlT8Ee_MC>_A6_Pq*yd^mG2uP&WYI-6OSpOt=H z`hB|Uxn5bp2TRDtX=-)@-G%2 zyzGnRSFz7)_@)<}wR|SwwB_3@-+uYP<<~C1Z257^k6D&yPYoeiW|#iD^wFh{FCDk^ zTG`67ez4Wj&z63)l;?k~*m7ydCC@Iov+B;uzdYHt>g2^AS6x`OYt`VY+Lfy+S1f(0 z^0vy-%2tclFJ4)hEGac+k^lO{g}W~7ws5b7yL_?y(+j>Hu;7X#7LPn{#NzgY$|jX9 zD*wfp)|`Rc)M>k@qM~AJV=6`g=i-hBcUUep>9DxN!VaHw__)LS?T$639qnoRN!z$$ zj}E7`YtycMJI>?suhE^2-fVnQ;~Sf{Y}!gbw|W)kwc3wxA`_R|74fuq&e)Z~ZNV(J zGW;_7mFJl6!J4S6ayv@?>|bvCEJk1VVP5zy=w3X{ZBee0CpK5tTIpN=D+iNXK7r2) z$kX}w=g}kX%QB2UM|c3FD<6#|I@!>e5SZXmMi;IsPVzYhi2c179Rk^H&2nz#m5()xOrOfiN#|{ zzauR{SUg?7jlW~o-g~TgDTzO1ZNR(o#0{RW`aSbLXEO8i@qb(|Q^iUnc^1n$X23Bj zYX0A^KDje`GP)~HSoZMce^>|b-&bwk&Dw=~@W}63p_-4%qQ|1r=!rNVFN}-hX3^?6 zj_bsgantDM^jXTEyPM-y(en5k=14b>*08?e#duycg)5?%tC5gvlv>Q~-rbB~B!3hm z`0sGf;63w(Z)LZ%yVyZor|e{RjDEBO?L+oq`v|jxzYM)QJE&*>48ouVGk}}0mS<>i zTyT7F0yBQ)NhB`>v%>xPYuD1XawWV?sA=?*Ywm7!Q`}T$=&lZS<=#jUqo1`I`>eyr z=Me5V4&{F19^7r*lY5N^1c&$*!2#w-M){9ojQ?mx_>WCC*cQP`+cH>XTLr6q zyWksJ9#q*buD0#!>ez0s*lx|^(|2`wyPGSuySp-bwi|3Ob%)x^++p@|H{9Onj<+|t z6XY31cAPuO-sUc~x4X-H2RGV2<|f(4-EDS;yWKwF?yyg~JMBz2&A#itvR}D1%$oi# zboTo&v_FIq>uq*2yZC0oK;O|HX7*tn&Jc4bZ(3;?9OSn#=lfD$!d&-qb5q!fwpHq z+)Dea+vLl9YrnJKB^nS7^oRN({$ziaKii+<&osk>BYcHz6MW{|vs$N-DGr?ZICz;g zJLPtkyURZ1rrX)>Zu_*m$3Elk4X)&w`n63x#+SDb%FKAI+M%ws-NUu< z<$kB&W8a*2Nsly>xSRTz?_#&&KA&gIyMIt_k8(UEpONVXj7uNK-IwFJ_wot%uRaZ4 zv3t6-mab9$F;Znx-IN}u7myBtqoQ~34z``mG%^;`K-yfgC+ z-`$)S9BXR_Z`n)SzV>=|fL-cV1ua>J)F;^44-19`2l{RO0KY?cc6big-RJUjoe6%| z;I?p??;G43Ob_l3o(-q+q@AU#Zdm5`bH>?V6Ib&&uH<)iyZQtCfo_;Th&N~*><)5A zxue~&emlRn-=3@b3*0UKM1PX|)P3oGWo1<0ck~1OZhlX{hwqn*{So0=!R`K3S#=d` zaQpb({m@_(Yo&(!gWbi!I6ufA>5uY*gZqN}<1YRJp0M7>U+B;G=kY}K{?S*_!lK^M zJ4L;Uwkz7UXzQXrNvEW9vSrdSUKB4c>X)oYzDZUVZC|uaQQxBOMLmmpBt4TJ$u3Ek zWUHiGT*WN+W%0^*ar{LxG#Qe#;o0qd3yFvO4LN^o~AAx+YsE zeUiROzhs+a+hn_BduGM=PX;7ABs(TMB?FV4<2BqT9nU?Vb&S)G<6h9@WK#TXG9{Us zR3z=}_Wm0`-+$~siN3LQ;;-TrrggN!Txe#PFYWTMQFt4_$p(i>SY$4+znRCw+U5(} z%xr5r*#2Q1%NxAxg<)NLzg-sAvkSudVFUA(T@elo&kQf;x6(7bnd{W>wD9!sjPTO% zvT#Z`)qfB^>Ob@!g^#&y!pFlI;jHkfaCZ1~_?BB9z7xL7dVpu$w&8Q(d;T52z<(ZY z5q1bWhHv{X{AaA{`qY2vzY6vZKC!3xg-Ls}uk9Gl^zZuj{QKrAGbY^6UmWgXZ!s&) zDq9>53I~Tf_)BeHe--bB?8ZAJ2l{z_6K)f37w#DD6b=k|OJulfxLde;&?;OWt_Z&gR|l7dYr=J5wSO@DHvB34HT>P} z5^i#P1^Y$D{SaBVEDEDI@=+4ij_O23QG=*q)F`+txIDPa-xoD?XR@mA-Qd%xUQ|Dr z<{$PCxgVp*U+o|9*F<&wwf<3moqx<!MV7PD8%8&E2 z{CKyUzsJ9ov}HZ*`N;*zg~>(9Imx+pyKud~H!8O0yCLD0;YvT+KM)Ry8i!kjYyAZO zlx-4zANCA?u#LkX&BNgz=F#xaaA?#d+%szCC;Hibl7HGy_Rsj6{j>Jd$c5WR&BN`Z zT-ZOV6%GhygnLCT{4M@Df2*J3pAUP5-}$NG&*mZC3i(L5(ck7@uv>(`u|{#Lpu}_! z@@7EL+FTu65$^3@^tbz${2hLdzthhR_la8CZT!o2TR+d9?grU2{VVn?|EiznU*mV! zPwsbqbN}If@pt*x{U!c>Ki$6(b_rM6&!WKJ?cd}*2lAGKt$4FR@AQ2JBUlB`8x#CW zSudQ-W4-W;$*ak0$?M4*$(zZ@h`C~unZt4~vsUg49x?YbV`Vy{9S<;Pv1;>SJI6g@-*TVXx7`B!o?B?&cVF8N+!yvkx5$3v7Tb^A68ni; zY8Sb6_Qx=`KZQB_b66{QoE1Qot~zKO+~kk8Q~WVJ8?D$h;XZ0p?xHs19%^&$ptj)t zY0Drst+<0)5*U-`?rACaPRr~ja~d-SPG`Qr8O#t-=xh>u|JR6khKa zhxhwRx07EIzT%gLpZVoR-l*2g^yaNaeN11|FT5eVF}x`p8;%RdhZDky<^}VjdCAN% zbIr?Uo_Qr)5Plwh5q=qd6)p_F4i|;_urw?S%fr@To3L$I5uO~LVmg`5W=qr6Y?EB( zS0tAvHzn7Hlfud2&EYNKt>$ubg?ZLIXI@RNNUln*4j%{~3?K4U;ltr0W|>)TR+w*+ zE0ZzFHQ}q_YvJpDS@=ZwWcWt-rd?y#+I6f2z9?Olbwju$Txw6Yr-mhA!?0a)V{&;? zmXxzDhq2P=>7+Diovw|QXQk;=(>{)C#hx`g&nJzd%4l)YF#aL_D4rjE5`7wd7JVLl z5q+7|i&jRfk|xo_Xll|pX_hod>L+!h=i+OkY0>oPmgv@Kax^|Jkrh8lb5@A8NLnWQ zCasc^B+v62yZ+_zcbmvtPI~_1yH$9j3eQuJH>@1UvpSBBPw{8)gpN@>lSAIp za*Vv6CD}Xb7IlyMMV+Evya%v-)FPbVIodMXDry&1M6IK( zqc&0BXxn5T)~db0eA<)aPvcK=Hm+x{v)9HA;)Zek_^tT;_yg8N&y8P+UyWajUyt8l zRrK5OJMp{md+`g2_a`JtQpDP%7Ocf-$vUKxnl(wIa!2Jx#uZ^vTps;UcnbOS+`hT} zbNjJU`mo&a+=$%axn8-xxvg{Cr1a$1bMIWgl!3Wj;&!?1dCp}qYny7b)~Pw~E7iA9 zedzXgheS&X>-3J`DLC>TC3!!LzR5=3V{1|B^^d_ez$=ag5l6A6b zuW0Y|+350&be@c!J~>>T625|`h4YN?XsJo;`k)!lxw|I$Emvt?xA*Y;>1%is+;zeA z!Hx0PJXL)r&lF$1*&CbIr0;CX-q`d*?$@Gyb z_@WbP1x05Rotcg{`({95HVY|TGLCrp`=jxCiFhiC#SqX!VlXm=YWdK7J|L?vj2 z63e#RDbYBzy%N2PZUG(G&h04U20|?FN$R9T-=p$-9-^<&Eft>6VYu2(i58(y25GS>{vk3b}FzdIAuyI?1{JsgN+32nQVFE)M=8P4Xn|l1@ne)=JbJ7W+<_ja1W%yHE5Qfo2}-a4 zJy8iN(UX*5BYLvpBJ>o6Cjc9Bs^X*%Pg9)q!|93>d!L~=sn?l`I}bfeaTCz97551$ zeF;wNe6HfEP$>g$1$w^Xq;3}|(cS2UN;Ct#NQv%2FIJ*o(P>KjJt})?AYO<*sKmwSLrUBXeOQTBqmL+YjLJSBu7f_V z#FePD2jZrv><^-!QSq~xr0>B;Vr#}xwYAkIKED?2?~LS;eFI~t#>)Oc{+?Lb2QaQ`Y_XF5J*Z0@Sk=L+N)%7u+4>6Oue`QK zk#n<^_CRnVDs=@pPus>ya1u%%3v$l3*jixhme)Bca{iXTe?o8yD*F?EIToeQ1jcxI z5vsyU5o1df#(jCvxMIek_>jO@u(4$dt4WM4R~R2Qwzb0g5@Xva!7XT8Mb3k^LSY=) z*mjDX+iZJUivF)k^ zbJ1>!9Mg6yg{LtY+g;(^+=f*ZDa>3jtgTR_&wD9>l>COej9=j+Ge`SWYBDNW>}JE9 zZAG@Rx8lT)#74r|u&?4||N9lV6y0BOhoT1*xC|YpxWmu`3tWyKq`2Ye!3Aza4^iCl zsBBBP38Xx@6HqB5jD^D$C&%E30&*;jRNP7Er~k^DTy}(TL48=`D&n)mRdX~bvEA1!gD~X?@u?KNY11dIxK>S+l3-UXGwOuK`87h4bf%y9sitmVCsc`qlu;wd8 zuIpL(m6HB`xSBWwL(pp!xdyk_Dsqi)uTy+W^m-)_Uz7R)caw}2KLfe0OnnRg^5XyE zPr$tHXv+|KB;)I^UMNYptBUW5`C(`ujp*WZ9<<`d>Q(TA~O(JJ!DurWW3nwc_kWv zzMw<{(H9jjKK7F0#rNhY{$zA6%ws!ZlUEe(A{zUeBEJP$U7Hddfxe;m3iQnaZBX$K z2tGsKR=l+RodQy~cNOkR8rHX_m}2yOg*%nTexR^c&9LG%C3qSAsDRXezT(86C7&R+ z{6ul$JD(O1yGotFi61Q}AT}1?1=d9wEBzsey}wjgDW&J2uTZi5LWQ+c#(u4E|J2w; zim8h(R)X4SrDE!#RSNf6nK!7&IEP)T1ZC(l#oUN4SGXT*>6&1e`>cc99 z)z8MRE+EIk8if@+#;z@}2f9viZP04Pi#^vXekb%>B@p|5r*I$G*zXk?Gq67>!ASH+ z#Y{qfQn+7i?9Yn)R1ZuQezS2W zLYarkK0toM$?v6e@nW-s0AKTBk3-;4eCcfTFeQ|B4OhZ*QSm?FO&C#N0y;+Ej ze7@ojLN8F9M1r8KLhtEdV}J=L~m5wujoyR+klQ$!T=qw_#IK{d+-C%iHa8=pQL#4 z*~y9*U%pxK{ZOeBby)=u9QxsPsJ)^+4wg*?)~zbc8;^EcQ;dVkIrMv2+3vr5cxxNu%+A7yHa{a<{H;n77B)6fo-}NE=c63MB ziTEYxE-;Gto#+v83i18WGvO@a73kTDj2FspW5Lr`axRwZ8jqjKxkHE~UA7Ch4tj+W z<7e(lC0>DErI^;}7$uVQs};FF=B`o94D?#X;Jfa6#U6v+sK{?7cast}LdEV7O53GB zz?7rXmtY2?Vt4v2ls=LE03&UZeggSjBKM^PxyL1cZ-kIObJ7Q3zCgv+AmidZuOmh7 zZOb@XI+oS}6}yA&kKUn#VjrwZw=eD8i#WX#q5 zq0U=S1)*a7935j_4NelN(q3-NWqOC9PK=!4c%Og9wYP3ep_ zP>gK9q2ez>8x`n^Hdf4)Xp;i6ou&o4qs~zitU7!D00s^ z%queH9hL&;Gk+P{2HJwOu|n}<&~^pzXBi(%*$%~rLTTTQuq8-4b_J<7$nWoPE0B8O z+hNZFtI=MHTxW+;S78lo4br}KAoT$MAS&$?z6Gg=fKP?n7WfsFItjnS_KN(i2>Tbn zhr$7h+Y6OG2KjB4wt;rwE+*Vb5nm1mDv?EZR@^dFwhNK?n)E9~F*+EqK_ou48|+S8 z{Ah?0iGK}+JxLe8kb3M*9mM|oC~}P)?yLCwP^lk8;tTsL^0!XTUvmDFYq;=0MXs&F zgWzED*Fz6cf@$cXihmeAOz{t)!xcGR!^4#bLxdv~e>FN%@sFUR6n_nRgc8YdaHQg| zMUPVaqv+9!zYaY{@sFX$D*k%(IK@AX9A874tB9cY!}pu_>5GQL%;aC&+Ok42AoZNa`SM6ZV7$ zm8co|km9A?vJddH(MJ?7HjsUQe;R#E@nVn175@x6L-AspClvoI`lMn%MQ19JLuVD( z78QFz)Et$43v%9){XvvNWgmi^!(_V<)k2>uFaUjC38XGB6xa)WQHffhFDd>ObdKU> z8*|}h+ITBEPw}$7R|@n(UoG$*`kLaUZ(lF)Gx~;N#IA1^*no=PgAu#FU0@^nj^f2H z-c`KR{XIqIJB05S_znF)3I0SsRE+rKM~aN^hVvEE9sO95vEJ|##fYt>KS0KG!_O3R zHM&5Nah>q<0(+xhC|+#&rQ&Z#zf!!|b)n+#K)+VJ*m#lR??e|XUhG|2U>~$fiCUsd z6uS+&RPpqUjM)h?CnEhjx}5%!zFMK!)6s7fHway+$o=YYmExs8S1a}`bdBPrZ{>If zKMh@{cU$Q@;3&=hMX`lE6Sn1CVN)(_Q6@NFnN%8n*)K!uF757&n zY+hm%e+pVh@u#6J6_1@uc2eT@D7F@2e6?gS>`J^NI#h|bME6wUtx%3hA?|_F_d?tY zJwS1p()*!@C^7wBGD?X@phqb2ap;k76!}j?Z&Tt9D19l!ozdr&cmO&_@%Tu| zT);09QT#yQErX_nzAt%;xTJB+3du;6W42^IalR|z_$tBPiPUR>l6-`I4&RV|G%EXm zgfbwmHK?n{*ixqPaT2~2%qxBSX zFj`*;4o4d(hW^YqRDuzxv=a<{mv5}dn0LO3VopMvDl-0^Z>E@&QLziiIC#E=V({C1 zOGU=T^Q{zfDvEOp!MP}g7R+^MsUqXb`7*^!M#~i$^Ub$b%)MwEMaEY1Z54ALTA|2z zYrdUg?nm1zGX9$1LNU|P4vLHu=Q}Fq0ko4MW3>6sioyT#TPnfRD968G-bA}9!Bc2A z#frT--UJyd%y(C;*uIA%V~6>kij{uorN}s9zPBRt{_`@w>eEJy@}&_&UgVUS9kgth8@u z#fcB@qF8C`AjOG44pywRdsoGYt#(sn9$$WUMaJ{;LlnC|I#hAeS9>Tj?<~*xO>ok0 zdntApy0;?ZdHH=5nU9v=S8>vx`zcm@QuYB(wk_KQdmbv=0w?>C@?ft*4^rGnRE{^W zW6(ns86V6as@SX1!xR}W%nw)WHR$1rI}#nC$eg3RY!_r~F)!N!nSYd*^59NIr3~0f z=uwJ04Lw@1lhI=ocRG5kVsA!|Q`{No@rukV%AcUf7-arL#ZE&{Qe-?bf3jllLZyBn zW0QHQ6Uh9dywn3^oH8%_2KziJ`vVzc%b%&(7tpg58F$N{t=JdQa}*he%S%6j%+1M5 z-++wC<@ED)ue(BE@}%UaZ)+(MuE=Z_1BW?0e{?ii|(yFH`LM=;exx zMdigtAaii?Vi#~V()ZvNqt`0-WAr-3EkUnW>?i0Aid%}_ zsK`8;{7s5mhmKY3kLWl>#+>rw75fu9L6LE&y!aE?pHcB4ka4NJ_zlQCs=W9L$QX0} z7R6Pfw<@k0oubGbiu_b1kb2#&_@mJ~6f1ef&wy2`CNI7PM#_pmfz0p7iw}Wmg5Isj zoR0iGifM}8tH|7w{C$dPhTg9P(#8iA(;OAwfy@s@u=2`HX_Qjv>_{7gmW)Z}L=rWAcjk-0Vb*@`JcpH}Q9^clsR zhCZtV=b_IjMvkrL6}iuxmtzSG$5{SFMeaH0UsBAO=o}@u5S^=-v(T57;39OMV$Mci zQRIGg{#C`CgTAK7ee3+|ia8g3LkUKsZz|?9^esj17v|;I1G4~qN0Ix7`F9n25GuzZ zxGw1Xiai+pKyh7BImW;qf_|j9Zs>f)9*W9w1#Ti3$bg?4$m-3a0Jp!##dey><*>ko>Paz83o+WnIvWBK`?6)QIQMUnCS z{I7}?d;F%zcz^zP#Y-Rkq4;CbKNT;1v_bL5p&J!1eY8pO#~V2eO)2LI8NV#$yii(~ zgf?hBXiPfCRB1CPA^jq>4BC@^1-b=vB^~>eb_4n|yc4DWO8b+JFO&{|o$0&n(7`Yi zAETb7d%-aBKaU=ySo*CLKNjpt^f1NJZ>5JTmVPT80mo35W1>{HbqaCnT6(Gy%J-)! z{%iDfB^-^Op?LhU^h`y@^-9lD{9^QMMaHp8&ry6Odafe(K}*k5JpEECHUb&5DZN1P zOVJAz8RsayNMS9#DV2JRAwS1R>D6$PF@}CD9Sb*;egk?7U`z7?It{3cjFFT+0FM*T zqcdO@ar(D(Hat!IWb_$$jQ~Bf zB_v`ij-^tL4;iN{#qUesATITN6W(I`m!q89N;$8YXHm{+f}u?5drBhyBmD=-Rp&J?(LdA~QK*kD7KZmc_<}y_J7?LYd=~qawZ>jVpB-fyoKwrsNTB-C6 zcquE;Co*OOF6b>oT>C@_=ULm z#;=N%e)&zY;-|kWa$l(Q4@K@xmHw&7J)hDIN^&E*QAx0E8O<&$Vr=0jv>w!_J|vbk zP@<<$wk1UPM_D6iOdKC6Yoa8jXj3I=jW&bk=#lQIy|CuOp~ za_UeEmGTfhgSJtk=h3!GBKxmUqDqvu2@$p`Yp*0yUwl-Ee?YszR>Y+a-JvJ>KS6uJ z*2F(Y`zVRnpfB_zoqj9ZMoFZt+bYpSbUP)Qif*qY*rlw$l86lkD2do|2PMJ2WjiWK zU34cU;utF%sKoeK+0IHd4c$eFrlW&kFm<~H-BpPuqq`~5cyxCq#vjUtz)$>QCsv;CF+1a29Hyp9_SNFv<3R4B4e&) zGhr5aI-^f1(N^d)O4JU0R*5Rm=ai^5`hpT|jlQTva;(3kM19dYO0+FHS4s9kzfuy( zyHH7FdtbvM<~^Q-u2d4)#( zmn(_bfa6Q>C!kltRrqj%UZceHMfq4IR|_4dMY%SlR(^Hup| z;5f>OO&)}Yh>Klkz!SueKxZnsQRplshd-C&heB>7iocaVPn-c3I#6Qzwl)4E#1&|)$lR0Gb(NU@Ze3rA@q^a1 zO^AL#v5^qBMQNuHm!kNB5Vt{lE74MPuoC@((qBUK9eN}jMZ6lto~^NCZW?;ClDiwd zMafO)vfL>-e56gN+F%zUw+~9&gxoL`pKZhWCU+Q09fjPX=x8N(06Ip= z9f)41cKjf}OX9M|ir=Zwh$l-St(|~s5`lAmi z(M#x)O0E}*p9ne5Clzc*$Zd^2t>ieKD)18_O~+p<#AhU(<3Y&vL^($ZxjyJzCD$8$ zS;_T7Uscld*N8)!{yK5U4Mg8ia=V~!D>1gLct^=?kJ45lw;j4diJnE*E4dSlp-4(@ zS2Ti{{G1EgZL8$)k#-}M+-~SmN^W=bcwigJ7AQ6pa+GV|P|0;in<}{;=mAP@XY@!V zHv}CGS5x*{l)4E?G5V8|^XSh?PSSr-a@Qun#VGQy6 zQ2MHJ9C6w2cqLkbPJl_IAC68|q9agg&)uZcKb6>Bh^2k^0^5sQp!dTA#P>xXgolYA zggyd~5|{curo_jhk1O%X=nQy*Jg1@@vz0T6Ux9Ky7vgKtrm0v5dv||x0CXckEQi&fzs{q@?(vGFDoVe6| zg%XS1egJ&Ei2kdJm1GTy-wVlFG*OD^!>Za)O!_*su2Qr&S|1vc{w>-Rnh|H)Rpro{ zIQyt-t0cdm9hKx)v=eNN&(rp*KG2sq?W*br+YzU4syL@q9YFjIbQl~=oc2}WH&ysh zjy6@%-$Kl`s$Nl|x6t{3eR5@}l!2msP};wQ?bV7?MzgLe@iuOgN zoi~yHcXTY=N+0cq;`c%#=~I;=`n&ozB`5a09quFl;i$BM{!actKURu{pr62J+cm|+bs&&ZVkHK5CjA^=s&9`dG&A?V|eGuhZMaP)f z)C%KT$1>~Iy0Xw6W6F3IXc^;*fvH_5sC|s7V~UbGMaReykPMTHXH1@$JzEYKCsm4a z@#z0+>U7Y6;r;q`>(;hyK3}U=7!KNH=Yc!zxWj;c{rmObe!FeA>DISf-#%OS?$xtL z_pRD?ZQHfWmYq9w?65`qb`|+H`8KV~%SuaHwQSL>X_Lma8rEvqpnko&#dT^IB|glB zIX-oWn|HG1^~-Jj^7=xX#yxuVXxyfkYh2!|&DOoj8}~?Kz1qv?UOgnCv6DP$EGMar z>+^*Ze%-KFFk@paJ7D8nJ7Der{yK(NRr_LR{aqj5RmapfI z9x!0zh+37un@yP8j+SsVIsYX6k{t#_b1Mf-BRYcrH_RO{4H-S4a@vLgqg~|)PAR4* z=YYMV`FLAB(|JILIyN+Rh~cfAHVlsCTy((Dh-cl}VRjEL8fuX(SHFJ!xTtxj9=3;V zzK-X0r#AS{?c;r`+x>eU*-tdTX8(WPevNH-8|!~)Q>_{sC)MV7-M;&qjW^4) z&c3gC{;jWS_7$%+qy9slyR-K4F4+9Pw?%w0cTP>7asSj;8@?5P&Dxvvvv;XIHy-k@ zbbM-@egC&z#HZ{tzwPoDpQ@=RZ#jMXpX*R-K~{&NPPX+ww`H?Do&Ohkw)~HIX4dSh z%Rl9jcI66nHtp3nYueX9+Ls+(0Ie*FeTMXfqnm;RM$(~!4h z*&azGzdOg-8;*D*zH!5X zKc?Dg8>R=tH;#zrUu_5e@k~(b=&SfMv~j*|vXKi|@h$b6`87WAd-1>fMB(q`U;QyV zF7f66Y|H=tcW%_i2LJL|)84NLYNb7_zRN+qX*1tV^A>z}v%KoVl6SLXVPk{MeOPk4 z{^^$0m)+*ROy13WInB%Osv4jEd*01_+O!j&wmG)G6UI#chX3mrVY{38cDmi&)9tE{ z|9!ig`8eCf$7Q?09W~pn@pZPlnXk)sB^UKopO@{{_&he-?C*tNVZUU1w&uF0wkaQw zuZ2Hy)x(g)eD@B@5v>OJ5w)i{=B|$ zO_e)|YpS|j!E+QCZ>(i1EgUt~tBV^C!sG@@LC@?25VPCe?EcW=_9 zaU+iH#`!?BO+|TkuF2cAYg67!V{OW31@&%w=ZJx)?6AvqhaIzU#>U(2@W&<$xo*V9 zTkPO-?;A62$lWg`!dEosHLRo+n;s?*6wtjnp>Tc8Ye~w07f* z93yOJMMcpaE2=OXn@xRkUI9bxYH-ylZ#QwS2=~^~(Rv{J2=_ z#*OX2cfz(D11E0Y4I368a=E?j-?}0^csJYSZ@m$9x@Pd7du-MvHGPu$6!y;gDErK@ zdj6)h(Xr7AQ*O2y(8mOhUnJ3JEaIZ@V#8ZFM*csny$75XRnj-yr@L?8nYoj5U~(d- zVHiP$D-tEBL`efPqC`o81PLPuA|P1>R0K?@h^T|E3EW-N`sfDps=KSMfkj|l-E|*f zZqNI#I^BKyh8cOk?|q)%uIrh)r|ZHnE;l$m6$8(Qo zEIVAc{^M1vKVDb=__B=SxsL|YpBLj!pAq9;Sp3P}>o*VDVE%mKxcT#KgEwDy_h)d4 zFrIi(>`tYlGR8kL8GDx^gcc|8&J50j$LrC(4T_g;#;Zsc2vwVj<6&cO7)o7?jeWbe z<)yfzXJw=%C13>|MaNk83W~C-d-Sa8o|S>aQG&Z;Yl{)$v0YmRlqDA=9Bge(`$nu- z8+)g!UT02^TpRXexjBmV0K5#(2F}f1Rd4D&+xRGz5@*OhiC3zFyJJLSTb9FynE@N7ROzH#;~$d% zYegwfS5dFrselS!ht zt-ySxrD^5qsgj%Y%n>%#@yIy}>Buo;c|3Pe;{Hrq;f4FnZ%F6REXGtb4 zdP^MFJI4^`J_aW&@$7t@ty<@7d2|)8uQlL|>8iHMIZ?bEX4J_d>e&+A_0)`XRWB{U zLaGW>oT=369x5%t@Rs&b)!&^E9Ugz&`~YX`u{?(lKU!aRn9r8!`Q~}^(bK2RLoY1; zbPqA0@SZp!jN1lpx_C<;Y3na1F+k#w^^7vbGAf0V zmXhGpRruB7JUBqb(4iKl<;6t`)NFCFy3Xt(zWPK|KlHHq8#7LLMY8aj=gfflt>@jR z&1b&-hxt_FAyF-oM1ttX--gUKrs3PE5TO&Ls4g&Y+(EO2o)$!Op#`8fM28sfhXI_I zlL37Qjabp$>xgBGvbH$3&?X`5x3K=Z*@XqL3w4&gHuh5Jx|SeitY;XXjnRCbcPg(& z=z69x>q-f;T`Y=(!QBq~fU|1DG(_CH8_i8_80gB)QDD-7Fp!e}5U@ZAPjhf^9CBxe z@_xi`)4>bVu^+%84_o6~@+G!Ot}*r*IgSCZW_sXRx5wd;Wt^2tIS!xBPU8x|3APc2 z;CDWyi@zg@YHTcHhv}P{UjPG|-$RiMxhL-RqJK|IYjJRZpQ%vd5V02W zGf5np@y;Fj)!aI$(X7?6zY+#G>=lS^*f_A?gnx_J!rjs555k}xF$#=1I5+I&L#i}1vJHtlWS591D-)mal@wu?=X^M&#h{9p1shtP&$ z$S24&0A9-@=?9qlAPsySl)wEFoqQcH0H#xmFyteXd(t@?46WToCq4%b4Oq`hADQC} z#J#1tpFRY7J`KK#JZ1aPqX{s$yTRcj)cHw1)e|oaL@}l(idb*#s5n8^HoO+lFUbii zl>8Jj)!??s^LNE>)OG(CKN;^Y$<9uP%*xKo&dbe7&q_yN0eGab6yg8!6?X8{l%^EJ zI6xplgG{0Sc+=8~Q_|8(Q$)X-*VIKlAMCm4q0K@u|F}(@3w&6!cC&eN&Gt8sANRcb z(o2@SIj*bX8#6aBP5j%8XW6zMdza_PHVw#Y>U6$i9H{mg=4?}s(dutbZd3e2@{T;A6OEpi`wzYvn9!yTDQcCSPC+3-a6KWThnW6}D8A#<(wl z-F3b*gj`{9GRXwjGTt!XKXgd6J+Tj0zr0sFzqfDghpSe9a{G$oH>l<+^^$$&ne-RL zxbNtSaPz0zw;sC9{P~sR=D7_sURnF_1J9e^-%0#QIRA$4dv_4ce3v6C`J6nH=5y@3 zkoVmyj9rLO$SJ2O2w z5m(+WqDx%JiZjFRyma+-UEm{DzxMM{_Pw`t8jKq;+P?bEib4#F7E4*bFfDLrmGLd- zyhMT7C2kGnF$ae1BRS7@5G>p_S#G8guSgiSgHN)&U>%7YAkQZcz>2a-2~V@ z&*AqnQ5NFxh~)PgQbeU1+&22l=BLs4{pG*MnJd&w@65}X^?Y=O|N8ZZ18Jh)}r z63X*;|02(KRqpqvx_Q163`et2{qU*Izh45~lU@BVk%UKY)pPe&lakKR*of3+G3| zL_0sw)1E%iB|fFnUxxF9hwb(0DmHEGaKoc&+BhxTwyH|O%@O~B&6m=6TuVHDyy*we zyMYzzt>-$c4+mfr5q~~xPN8`r8xDX!jkvu&p~S$FIw~NL@pt|%%Lw{A?#klo(6b!{ zW@n2qB&Xy&+hG-l%PIKCUARD}s(Q5hhNlnbdB}OTDfh^E-1jxJf5<$$#L}OKNImoO z5Y{s)+mP>ro@A@T0}P+8=81z>$LCR|gUG7zsng+qGsX@l6P;64U{X_TA!t)4z@`=% zrA%S`cePD%FAQtX`}0BX<4c!Xl-CmV-MgC=^ACHe`SW z;SjWAv>|~Bk`aDhD{UF`6%XFxh3^71MLx+u{eI?+M)MT}2`t{g_y8TQ5W*Kg4S-Kj zI{DixFt>z9osPfgQ@n<%>qShmVvctuC<%P~NQv%;w{G2i{N_*7&;R&RU=}c*qwZ>odH9}t z9#+=`Rz3LHTuD25Ug28=O>su*v2)|Fo=W9FYj+l7H{V$fw037P_VXR#Kx=mv?`IOG zwL6RV-xf?OcNXvG7R*6xik)lVx{uJhyeBP~7Vazzb1~-{91sDXN9G#PJWl)-^IXii z1~!b0yAq5Qccr_J=Lf#~9Ef)J`9=C#GBmg+i21tc&9UTJjGw$K;%YA=<+Oi*bl#z83~pn~Z4>Q%h4-5;BBIb>f`vF+jelRQv5PM&c>lT88YhM`l z1%{213xauF`@^sa3>zgUgkdQsg!jn>8<`u@h&Z{UTNH}B!yhf>hggWSpeZ^2Oy~jf zu-o1NP0>;`#BK$Sp;!pN!@16$ccqTecH=h{%4>l2Dz8D4;9NDo1;_m))(04ee%fX} z8?FzU{{Wae_AN=6@5~n^j4LNC6EOG6`3HiczJ6!3r5?;?J=pvobGmvl%R-*RINO{S zp__cbU?J;D3G-d^;z%8b@8q~(PAP4|VVd6s%;+FY+>Yis5is8arl*&DYBoNJ5illT z+Ol0PVa_zSkAOigwOZ}^)~@C);V?>uIZPb0*RB|G_dJI!z@FTN^={`oFwc*E>c6~} zol(|;=!+_XI2fnRXCw|mo!2P?nT+&nJ=&pE*7`QSY0;~o^^H|=$)|$Kr49O82CQ{yC z0B<&52#-T=s1>X?UW=wTerYf1H}3ua<-LWBgHKND03Pv?uZv7bbqXvvnVQyOq=)^W zFdpHKnj~V)|Ehm5|5wBu($^e1bbb{AJ>Wf_m*w3lU*9 zg&)on!9d=P50Q7uBy&39Z~fg1dG~6>Igz-K&yT-@m{Uc>c?*X*rM&Y?Fo-$jw*W)( zPJZib^NAKMPej;B$XUJVqSTg0DP9!l>UcOmts)I|~M9*RgZLY)T`;f}z#h_DwiUz6J9G z!$kPXNxpjKvm8354q%w5b|+v+4%sjfa>&|?Af2P~4DV^Hyw`jQVE)E(=#(Re(xFN% zokB58-h(>EH8Q5byvuqBRB`s7{PL1VB4h#N(6r{$+FvkliqgT~R)IeiIYJHa56h&6 zI!bC_*KlG&9K1^kicKh~!BbLEje3*x;0;JEe(iscZ@zKi=HvfOKl$NRS8dq3b%Wma z{Kp@{l}NbYJNgOYX%PqP$xrZ61TPZIuYrpN36Eh4fk7 zU%dQt;9+&*7p8_lx~ZCHuikZq_#$v~(=+PZe>bz_ni}CZ#ka7gBn(jgzypjE-6JY_ ztr*8zcZ!^dwT8hMr^N3fVc_p@<|kW3yd7~iDbK+LgFJ_iLt#J@@VSAg2r97<1Bu0D z9J!Jza@karTmeB2G8PTzyLmCkR}z)PlvKKx)2&>_->CEk^eIhI;ELa`6lpz zdimF8?4Lc|_Xn1!w+A{06!pOXn2`1bz5(PIV=wh8q78foWW%#>z%$Wv8W|_ppOoZ; z*cc7@bDRhZR|=vr(w9ORDQ!}89};1)KUJb<&n$0+;kCCYRUI_`&$U-{pVrfytj_<& zR9?V6yHs6MpLW^iqO{&--=;sPhyP@jTe#4EFwf9FF%EheaPugI{x%rl2&6g{oNsZ5 zNAVyF*ZO#IM&of6IiBY}v}28BytfotL|#{-&SlOeWD6|ne$tARp5$XmYlEE9`%0M5d>FIV(`0D$ThO9XeM4VQ zG>O};qxw?rg|QyLDcPnKiF37{?l*#A;E#*~V@{;? zxnLfOpfApfx4#WTel(AaV}oD#w+78`6qq6djpPXO-q?bOH>?ehG6*O^AenECucohR@8m_L|+lg)E&M`CFWC z_x#_9>sx@Ky3MH;&uqK@225%lsJ zi(A;#$5-4+yaby8FB2BqAsc{P6!C;HSgkJa#x?$q3qE^YZMJ92qvZ9nRGb zSHWi*M3y|Ja6iAt?&mHxmz{9X^#!qfz{PDLY*62O*@{+(;Umn+EtELpFwV!Jvdw#Ta z`i}Y4O-J#~xtBaQ=eh^F(#uy4zY{NC#QfeeuQ@QN(^=gDKaxC`^PI72CEf8|vJpnn zT~5LvkM0pUkLw;lKKM*NTbM_wl;1+^e1J}QqhUE{l2)*t0Bf&>n@Zz612h>px76ZkDA4E<;l2XW?eJ2f`(@SkzF(p|jIa$etDTN5BCy68@BrYg3 zODlu9x||QMB_j|1@L?nzpAhYlv-{zRbsw!>{n5JhAFp2hv6BP;g8Ar~)8?bkAH7X@ zkG~?kx5;$)a~ps=jLDtTw!HaW&x44rFbrhz zWy)`YYc~$!yjCes4Lw?P)iuxNXCnF{hUNL=GKDJgQM{}U8_$387b*z9Y2ysa;i{v9 zGHG}WQk|4KE7c-z=+SlvZkI|hzW7U6WPF5!BAkb06+_c!G902iRyIS(jN`}qbIQwv z(y2pPRe4n#RF0>oCVLfFZ0?|TO}Fk<{Qs0L%@#cJzB4(EI{KD8F4`Rj`dCa&zu~v9 zNPXL+&av$h?$bI-uER3=b;5FuJ33E!7 zHgxD-g}^}0&TL^GI%jg8GorEu7zZDmp-sO8WBggPl`yWe7`86xswnuNb{c2M;jemC z`VN-UINNu?Q>pavIN5g=zV2F~urEkUDZ^QV?Y?ug~oq2q< zE$x--TQ5h0!TrnGE4Bxut_KYrUvSu7#NDNOBz?l_PaX_@3-#Ueqtnm@)A0geI<*Lc z+*L_KU*~8rv@ZK>L1*x}an={TzB{;1@{~|LOAC9<^GcZ3&o#reOfR-6xJR5RoJ)h~27OZBeA<`|T~~>Je*-JFb4aoG!5A7~4wGL@ zTqd9)0TU%I2$)7Wk3e(_FfxZUY##6T5(ZIyf{79bM7%r3f|ni58SWYQiH4CB!^{-zF*9u&hvb>39(=OQ6SaFEpO4 zh^tmcEwIOO+?O?o0sz{}z#bUeCP=*KKw8;jRd*&lEF zWcl(>w!J8>{OcFu$``EsZG;oHn1QE`n1QXpk$e_MfMdLp!5%_fQE*qG>}^ijMynRv zYeIE{0E@3EHrR7w7k8Exr=S9gs%lY7E6gKb+;GF^N6ZuAqNnb<>lyPc&%3KXT(|Dy zhQQbAZ=PCr>yy$h)sOJGT|%^jZ|u$pnaX(a-J4D;hqfd!lnM+1^KC(uEocq z&5SP&B&G^UnLz`8C$FZ6S5r(L!Zx`%S!hp_+`icGk`u~WjW^3%X<$VH{s&$W{!mjX zmv!~%DeGs9pNplvIlFBctxa5XX}4*-z#Ct^Y{%I9+XTMWjz8FL;pMkJ8Mr%sFWJ=a z`FdUlebd1M^|G$37>5Y;rg)Ok1N1xs3}NBNPFXla^86(hjHjVRpz;0`yd#yDm4Ug_ zi&HAP#~@wWU3H6PAS)?YZ(CYS1zr>E4LZ*CUDhsfZI``KRNH0Fpv{6V5r&b9$i>UuDmoxF>a zP!C_B^hZ~e6|~8aQU(1PLThbVs(7h(xe$`6L zEP=hQ)p=3PrAfnHt%Dgqm7Sq=u=eYymb!w(CN`Hq!HX>cj`wF27oneHWl@*nF8E?0 z@{y}zv8y75J@GXexK_iPQ;I@%TO4%H%&Mw}V6{slnF^j+Lq;VOB$o}?vMavVKkk0P z{OZ7d(dNZH|EP&K{Rdv3Soiv#4R6g`h_m_g+8*6h^{&`kSBSfA-tfAZ{P(|zaj&jh z^!2&7?h^?QKOo}o-);VM_*wI(ZQupagU;ni@N=?~BfZVIBhfjd-cGK{eE9h+Pj60E zS_&PsZds_9CU?Aj(%{mglNKgBZo5N__{@AOC6y$|(Yx<{nk2}QKd#&LS+~GF>g6JE zT>WnM+I9PFzC6itq`{ISyCUTXe6_$AvK}z(ciQ0awClI14f`tcx3pH*{HK);5q2HZ zgYpt+e&~T_<=YnKA^TavY!}h+oEXHDY&G!|`;^?aDEX03@*RTKQYm5R4xx}=lI=R_ zBeo46I=kp8;H;lvUk;rYTB*_8k9o6^YgdHRI>bLPOQ?oknGaTnN8Y0i%gxEw^ed8t zGDIUM5e}__v^fL413dWqc>Kd7reMQ8;>wf~gs;$p2_9=8VmQ^~6y zmR4HnElsP0h{Z53gVo>vKK<9}d$vs9@Xndj~+iRDpzms(|yA&CKSQS zKd#*WLHErsn9rNPI(AI-ZwkDko*B|`^}zM8)_`+1cZxdlO(=_+k;4W# z*j1r^3CQ2~=-_5jUwER&a4QH=NwI^UJmR3klDz z+kUieUC%o&*?#Mo)j#BZ{o?2ws{1Xya`1%SnN?NCcddGP#*Akc+_2>KnIooDC$&qy zX!6z>%U@l{XP?)?=lTvyZtUSR>-Nos!60t(k4PBQe1ax8*O&)(^j;xlOZabhM*VG? z`?rW8NqbiQmShFvhBF=oH^>3!yDTgAh5Day?&UnEZQOj7VpeeNG5hWLeMQO-a$UCF zO24J~+4iD!k(|N&{2jt2dMt{+$M!M(CY)c8Aq-Z5Eu({PR)M8$ez9*8%rBigwQrl7 zjs6+QL4F|y>7&-v^g(lj3fQ|;`A_UZa>biSy$mQujbJXAjaS}wb?t%cuGxL9_qPe=m$?gHT|Q&$eZdWM>+Ky^Lg_o2SSEQoQstq(B`fC(t2&)qfj;J)6ORGgO8g4Xx^jkE_cwqA< zD^~w)>zOlKA9`r(uf%w>{xiMbZ{OK(7OT^K)zI+T{D<#YbIZ;h;t%hie~fX1Eylfa z(2~SofG`kD6DqZ|ElK=O*rR4+5?1aI`A_0rxEwi zZ@|mgM;fR3`K(|ZJg`&wXT&+EhmLjq7QDR7^;_a)`P=Q{{wTk-`riRYjw53XH(AxCH2bj$PST7Od;BK|nu zp8y&mwH@-dgo+f|>SofCx$PG{wDBPD8*ACBe&pN-WKe_Y-^BM{!}q-u8;8Y2Y6tr@ z4wH!~w0DZQl8Dd!Fg?@()Y>rdrW&9f>+lFqMm$-Mx<}9)cgt@6&MDwT3X3>dW^{e4 z^T3v_BRLG6C-dBKmn3h!AS05B+n}lG^uVsv#&6kWb|AhOGRjw!RA!F3b%o~xFi3|U zom6#iEYL#DL~|GYO>~D&Mis<#e{4!pJPNrG&XvS0#EMYpESr|VAf`nTN?=89YmnzJ zpf#^+5r8i=X{lr^a&kf{wKd5Sgeey-7i-{MP1KbBQA{^GXc?n6k9y7g?_0+|6?^*h z`IEL*U3%zGe>!A(n*Jn41wQjkx!2)ezPk`#<19Cy^!P!y42q#z=#kQ*L>LxADarA1 zhDXT|88Q*3jKimvn4w5&IwZ~cqvp@sj!!wdeEE~L$G4g1vp0UfNBgMhqS=p3o%+aZ z?aiikd%oZ3eD5d374nsy{;D+6<76#+&=O^)>+5vw;jg1T4=z27LB7bhRAv|kmSev( z0+V0CeIFkM8*=o1kw-byrb!JLAPA5p6l3IiYG=oVne&%)nA z%x0g2ap@X~5BaDiK4+DmT9}7?{1WDjh^#>jTNix%H?=Si`lr%7ka0hYw^&Yv{T9Ce zv`9SRzX#vgzx7?KLIyY55Pz3&;&9U`zvLx8uXu|CxsgZy&ukp%4MP<`mwm@*&!xI z!Vo?#`us~dAGt>iL$L#i^Y`{Xy6GH-^LEu6{aZo$pr^(6k!#1deqxwM`5d)$M%*wh zoi!IsE8n6sBEJ>&j9^`mGd2ujG-2yf)aG-*`QMOzbRR;cS)A9Sp?jdJ#A*tBQ0$?I zjb(4lRLW>7Xp@}<*i1?kOE2S|fv9$a;f0n=kc!lI8sd;j3{miA3rNqu8zF&?l6-vO zh2vT>O1!?8a#EYR^bBMWB;}c<>cYSl`p?q8N{NZ%2-(~Nb{6%G=KhKBk~*0}!OSiA zAG0}gs~GueR+dneP_GGm_NKTvXHb_egR(`{TY)bT*WWzgZ~Gtobbz+#TxakY&&@H1 zH+jG8-p_8EzXxc@eH}?tv%M?({W`S)5=SrjOYP~l`plWHPt|rb&3*Cr(|IX15$2Q{*^@`kLvmeyYn$cIKz^>%lTE^q?I&TjN1Ml-NVIgp1VYau z=-mrEaS7<1LpD=J67KLpws2)VBtY*1H4B#p(Agoh=%r?wzRy1D*t<(! zZr6)De)^H=Q&T=Q&tKHPylh}E^Jn$E`jPpnf5NC9Jw{FNi%SAsn@q8Mw_7rqyvLWlX|w-NM{Fhm;(vrVz`nOwB#h1|*8uqKA#+{rO=esi>EuWNj;c0Bl9 zwqY=*bxwK%E>S7<7bSR+)EnibAjdO1m2w>6%yu1>6gn%PiOPyT1qFS|M8&6p&(wNt zzFF93-oU~0FBV@kZ42zfH;_T%*^F0Bl9YUZZc=;<0u?Y%5xtVxlqiU8ldNKP&^VaA z3H$7#kHx*oqTi4Y=XLK{TWKzWb0#oM&0pTXYEM?KKd>xtpL(suub$p4KR+f~A_nkE z1TE>zx?o^q$k=qqnPnKFH_rndG(pbeqPLuf><9U+Gm7jt9yt&3tDI;1FXIE-NybP+ z=79{s-ni!ZZ75G$vdF!zyTsuZ)=n~C;(S(lIur)>xPi5g1Rtcpa|i1(3&M!@DAtzi zLQ`f~a@}&q!n#gTNS?#1l@f<0up$Fb44~4k7|#S$r4^@DX`bRNDXlys&A*vnA2+`? ze|P4@XD^A5U;Olh`MLQ*iDVsp|5CGeV4qqqUSBG@o4=?3EUl4TWUrBV7Wm`eagQ|K z1Fn_gW3dN2ZpT|eJ15>M_o?;0#5{OPf?^LJi!XVes6BgP=1UlQ2N~ar+K(q@ngxR^ zFkqtA4|t!W+5qvfx{_fcYXic0beHHJx=%JO*l*h+|C!%lFaJoj0oZTU)p1l7r~krf z2m93FJN)_{dYu~Q7%@nF3+SGqpzmBf*aN;7*VIEBn!5G8 zp&I`K>*jCs8UG%iqceU-1Z^Y?ojZnsuc;*%%HNSNJC(n*Fi#L>M>H7twLlAJp6y~| z#MxX9UxNzp)vdpF}H9Rn?}*5({ea1(JuPQI>+f zVQG}b(MT>mz7z4{D3v0`UgCS&LyrvK*Lq;0a(|gG|mMfhMowZW(Z4vhr=+ez#=-HF*-njkn z+<97I(vNQHrKeKwkL>`96T~IoLmCq8vO#2(0&i1>lfYBzG-Qg>jXDnn0M4JVC*!QY zlWzonM#QbMLMRnID|;3dQgdIWT$IaOx8-<*-_deBR+8fp&O0=EC{0w6PS>-#I#H88 zNb%9EC$1m1dhdv7t1i81(XtJ>PjuLEbnHc2*NuBBK5g`R|Fn&ReOF8wpL^MY{%dou z+Bb|vs!rhglF1mlj%KrBxWF-5vn98C4apUD4 z^7=Vv<2(lFEY6y2f_|$MqD~{2i1nQE_MZ3&g#nJx3Vs zokGU@I=FXsk2^RT#_8X?_d~Vdjks-pa*zMV8K*~~oc%yl)Y=coIcxuDKlC|r+_e^W z+)wVYJ*PMBjOgu}Gt-_E^_SbCjpI&P>KgB2!y{G+AC=83p7*SA!#Fd*!r2_Fm)f{N zZcJ0lgYd?^&OArSFKf@^8oyIPw+DONyV-{KmDuAnzXM+x$MEj&1ilZ_20E>`h!4)^ zvFTwLXWIc^$cTN-Kj>xp(hwOz4mV3ixFo|A>Pg4~V=`r1w1H$8?~)85e{NAm2o6Ia z;~ZfKSt?hPm8h1MbXMUe%&6+4W}#DYMn)e^1~1e{EE#d_YDY#qInI_5xAnbtlavwt z=J#KtFSUh4d{S|H2#Hy}dtJAPg@pRW?zST#BvuTNLL#V8jbw)LBV=q3R?wOfbw8hQ*3gO)=|GU6Z8eaH#Y z>d0uAG91rv7|45$m-1F9g9cpQug@hl)m=KZttdlF_^ga1lol#IM2`enSjYjLsw%fs zWrLH2Yeq50b850E#i61yQB6b4$B@+RSzS}iF+xLpJnP8yV>cff`R_%GmfkLfZLiyI zZhOgdE5;w*JgVsAVmaWRhoPqdgk7rYyURGR=^= zmnkx3GeB-4E(5Z7P0Z1Ca<^zBGFAV^50)+eXw#gA{;5gNJe{06XwC552k*aU)|Nqo zw`6Y-`qNJdZS$Z>1<#y6_(Wmt-~*>#eEzE&UR=ER!~*anubpWGnZ$Z*KGP^{9K8Bv zaGZ33%J9%*-^y{=a)X_DNRI)Y<>$f(J;rmp=4fZnLHpnuA009dJ!XBgy?fmGCh4(P zf;hUyceuu{aLwO=GEIpFVYoB=1>)Y(o+AwRP9fvaV;1h6-Qy09&|_YZ-`Nky0)~ey zh;xra##-ZN$qsYip~vL>&|}vA(V9qC(709Wq;{D(}q?fGmI|Xi$ z_IF8-$#GwaJs$WzxOUc4P@pzE=_!VXo~j2vtfx-ut6*o-`CoAiVwGR#pyOYTizrE0 zt3n%TC{!Fa#VRgQy_P8Ow`&0ohku-_5``_?96Ibp1$5Za1ycqBaolCu2)vM`=wJp% zE{D~rQp8}>mflDyq4TajG;7VkwDcp5iD~^CZrJ?6vZWt9GV_i>1Mir%cmKicA(IQA zfQRSL1rrBvMpEh1X494f3r;Lv^y1vFo`3NaXb=ZJ#acmwe#95P+0CoeF0v*^?PB#} z+b3a=`%0_K zEfeJ4*~Bgn?%mSAEU7U5piW$K$A`<7et2;9wjqPJ-f-Uo4}oh64(ngo9a8@%f8yXf z%)rs7%=26J-uRm(HyxjU@}=WvK^pK6^M>)V%|DPgk18*qXMie>a$7Klf$VYd7+~&a z9pIKd`*5#!!Qfv1cqj~=OXNV<=Mpzyv;!o?41#e8TO&%^TA2g3WJFFBBf`&@OPS(y z!Mpa0rz^3s#nTmd%DbqgBu7>oH>re`rj4Y&d%gUxCkv< zT^{Jk5YqOjzNhof3ZAa&u)oync7NT_@b&J4|LOch&i1+Uw+$S)ZT^CtIfpy_Z}v8! zAAVAJwmq<;+t_)FkI$d`@}e6jcDobiCCRrLpkrsqw<4vzGRWT_@11y*5_Ba`OGzd- zG8|Ay&9)K)kfER`K$8qg(03|Z;S;G#L3t@AC@OE4TIr<}3;DbWaLs~~5(cB!dfh~t zij`U#KW;(`IQGQib-??I%kS8DfB$Q9p2+NNepA^&V*cQe%lA$dxotaQIepDq@q6So zJxMD`6-&)=l{a72ZFp56A&wW5YEDxZs{e|^`er<5(|W0=Na;u!%_&$1dbo@B?ecOd zpP5=Nz*xrnJ61+B7DW|-%qf(GQCVJ?pOKnKuLt4n9m~mJ(Lbw#H-X>YF|x8++m0J1 zC9Yag(j_6IQ%ZG3_N9iW#my;SFvFwm(zJg4pG-=M*eB9Yv`?%TufQfy&d)?gZ*^u{ zfyd!%m>X>zIW{srL3*?^-ECDl&-NDJciQmuU1xrJg8<)UThR3#wwE!VrAG-*gXg#G zXGeb`3B{#9@uZcZdm7}SwMr>%{i(V1XLLBWmVW%*98G?y*?X&)e@VdI?J zt|7O%eA%WCmoEEo(+v#+QWG1Gq^AzL-)sJl15rZYp zb}u?+@aXu$q_V&)XWf)uB(A|??dyWI{>NoDy4r*843Y*UPY|~*v-D$wKPe3Y1iDdc z6OVP;3bF)CIsoYv zp(n~CPa4ixWrd-?xny(U_W9o$;YV!HfE5oM4EUS_rVbm~v#M{`E**!PwbO@gTXORE z5r=JE&W@!w?NB=ekJ^`ogNORNweRco=Gt=CbE^SvQz3hBZ|b7Q+2go-lTF4l3HH{N z5jGj$af5OTFjGS9E!IDqh@b6wV3W;`0+SYmfsXixedj`78`p24i=K)6ZS%<(iaA>N zYo?AUn>i2WQMq_!DTrhx*vtenJ2Mp`S z7#KeuJVukY!?(P6)2#u9z}Vr`VO@tgK=(Nmsd>F(iZ2EcTYhd)GG%p(KLATQ;KSnu z(sV+8OvvJ)nHIig{TN=Qar|3pX=x*{N?H$|k8u4^iHozb1hJg|DZd{%g}+ziuOUNV z{NM&Y1)>*;4A2WsF*EGB901TN*Snt z4AnjFsLKO_1xtwf(LN3AR#%)WcMiuIt!sQ!Khm`!>c`x?vFYRZ{kI1XgtR?k-a}kg z@(|wjVjhC;$1_Xvk~zY=5xi8R3=lhp9&H19#y+5o zx>(vz`hNe&dC>4G+B}ef<9IT@NOIAdYc9fjM5}Wt@$oiFP(056Y-LtI4FB*&x{%`u z!8Cj!h?%0q#DINTo{ku(O|Od-rSGK|4d^uhn^4oEyTw7}B}w$;k$m5Uycvi^w#rUc zUOv4x7{*uEem-sxqJ3Mf}AJithqvWY(MmjVB3#;9Jm#i$a*jK zq0r;6%_Zbak+$(b+y}FjBC1x%%uxA0hyp#lwlh7%FYLOT6rdb7ErmV7Q0t+06VS!w zl^4bGqNpx9_}%Iif8Ra+i91F&ee8Yl&TF?89;rMNXjbPZ?AbVV(^a@5s_6J)>~dV{ zU02_y9^CrOgdMg`KagS&>h&Zk(6<@?KxQ=ENe1FP6`~TYBdU#R{S$G2G?ZejJ1090 zMqU9J2oGk)`c!WW?pt1UhP+Es7y?s(bu^9LW>X<@J!nQZqNqqwx^!;euBfu8vaAGC z7nYY~q*lhGR0`Kh#3SemEU%SVs+MV8fYCZd!_(k&EygohrJ0$+TUD|Cm063h>>-!m zz45X7HD>SId-sGh^;YdQb7YY40ZCj`{hJ^A8ds=!!Y^lC!@a zYCe`eZVafAZ;sbHie9l3c8oR0iIfSqt4jlvH$nHQfqXwA+R$5mFFShIJ$_0|i#85j z*ccpVe<;(~ID_)1AnnQD%Jai_jv%G;UAo7~@$L5fcwY}ZWsm!=Q#-rhgY)ckf7ihu zzGj4@g7cH#R?gq7;9AXg0QNjMKkkF0g7EA=XZ(G&a2GrC1jplEw#Q);IP<^2=A=bi#PA0k9P_gC;vaw*w@(}C!AetVjf{Xy~N!e_h!;$ckZjepW5TEU*-{g`_Xf;576TA(mR`LivY#*W2t4Aio4 z63R&!iNA;4n+!is92I-VqDY7ezR?v5MfVsWK~sxoF1XMu&rh)tvK>*4Kr8^Cx(Obuh4f!kjmAxLh$D1VjYqzw7AQXnad z{2Wq(l29E`D4_7!Pd)*XJ=*7`BF%e=SV zV~{5s@EO#lD_4rAt-fXjS2A>JW1Gz&Cb07kbbo6S-XFLEyc);USqZVc+ zYZsyP?9t`ot{1nfEG?$^5!TyTbhf=6Ev}d9VV(Ep|1VY^Z~M`HnE*j|ni@_B(o^O@ zPYw8@Lft_;g?`kxHxHGu$>yOJZ!_<(-UJM6fE~)SQYR8mxyE-XGS6AUlMN-|w+l;$ zGCcBJ<+$%AF(c|cJEPAJAG~WGw&`eo#JCsHo(g4T^S|_R{RX9|wf7*QSt&V^Sel!D zw?PCnE5mvZvPcv~q=1yNv2Xc$DU*|`@~__gZNu8Hwl9C}megP6Z@FR9OE2zNyH7KJ z6fZ4%FKLrdk3J*RjkS;5FlGMxZ@m7&o?CX@vgHp8Y#a~jUn-rHG5(RsNWey|-u5D#SSqa@)s3#G)t&`|vMJjDqB+6`T-ZBtQX>A=> z-O*dzFl#_razVnV9%acfEw8D4#n^eVcdF|2Egd?AE{=7eo{xJAvc>&n&=pkY$ssN@ zD3{K64OGVqxTSb(7wviT_=TIQ6mEWioYEAoZWkjP8*3h)``Dk3-L`ny0d-#h&)f#y znm_g3_XEAv=Wf|?AM?xx+>!7t@Dd~}?oNBp;2+@USm;-0oMY`PIaYuidn?usQwF)q zglAi2tbbHK6d@c?IP&NWKMZX=P+k-3fhlGfMHG@_XFw%gsPOa{2}AN>wUezKhI;_n!l5jpboagPgp(PBKaJ#PgJwvE+}HL6m%&; z#}XjV79`}C)tq9=a5#qL29%YR!lHofLu7aOBqMS!Y(Ya<{jt&Bl3?WeMfc7CAJCTY zX{(I#UzH81nuBbPLKlraZn;Vh6Y1(;Hx7~4(ltUUEvBX(LBi6(j7Hcf*oPA~WDSvo zb)xXRmZq&tTB0rb+M)DJsZj1Z1{0Jst?9i^vX>AJhr8W!WrDs+9cQM{E1goG7DoV4 zUJ656vL_FzE|xo;jX}LmIt|0&;NZzXjt0nqqn^m`)>eoLOHQE%(P1$}-z?sem58Y+ z;J9S8u{k~K@U#s}S3KC*nAGY3Z-dQ<7UpI>U$4d49()XD7u#i7phYGfX`pW%@ySFMJGvYoH69d)!iMZekewYPdHy0` z${Sz_sR)qq{zUu&E|awK>Woq^%Pk9S*^i^zAv;+$h=FP^UG&84N8g<~AUWTc*0pry zkqwKN9yn&!s@LB*<=ywigJb*Z>fK)Lo;%IibhxofqA_eY5AM{+7}zEePfUf?tz$Xu zgn}p^yzHrHMHC#c)<^k{(iO_ejSoFG0{WufI!(lC9uF32r5LmX$DCGKR$P>ymzkEB z5MwCqMSFShP=Me1n(a0U`d_!~injV-Qw1@vB`W+^#y&4Zj^n)mcuw?us;%J{pJ10X zN4(1!0kbm_M!A{iA-e?9lkLj@Ixm%rcT~R*BPh%@gT6v}V!lj2r0v%Cu!A1J?w0fOxC?h0 z=iS3^!oR)K`gRxK`fczVcqSI=qu{l}vJExB`g_iF@WF#XG69zqcyQ+EvUqkQ<81`JVLuni1_)#PH;Zjpl%h*QYUR#cD zA&7@<47<^B%=y4JH&#p|JNE#RjdKs$$~_=lS@&Wb@*tXC<@E$%@QzS)y()7Ud98+heiO$A~GF~11?Z}~N@eo}%m32T%tmBW}dZWLd040rO|T6uN%9csqVeYc}r&4TPZuvSZTLr zrTJB*4eXN3F+cT^#w%Zm!a(Q*H+G_>N1>!s97o4DiBBUKfNO4Qd2vc|43a6h_a@RP zNP@vLLK3W8UY>wJm3H}u&(0ln`_=bv>QnXXhvuSQmv-uNd5>A@=)hrh^kqv&F1R;E zED2Q9bs5yJQ~N$7b0MEJJhp@&M?Q55Pl-kH6?{3kW0OM%EQq7qASr-bM?KxW!Ei#! zOplL?@hZt8nKF>AY$#v@q&WA;U{e4F#Qg{PPp$dyWIr>F zBQHwi@%T#E2}^BwwiC3_vkLzCyE#!!pk4qxCweO?fWi0AG$)~^J!)@7{AQDy5S*7_ zBj$bC9IW;Y!oXG=7Yai>D&Mt5Pmf3*ttTFZdrBz$4j|rjAs(f70I@leN3)Puxo6eN z#`25u3lhq*2gcmCO#kHksNsEeeK#84;*BuO-;3$~&jJ*v_-;%W^7IH0-TM1p`S)7- z`|J&&Z;sOMC&<6|qQ5VG+x2^#0sLK~GnNkz%T<2Vxp+k;JS?b8jDdEDMRRElCxO%T zk#bZA?!#Tr<1y;7cL?SbAjhkqZ2>!}(^8~zH*~zuneQW3EMi|!CLax$AkLa`XsT0e zPXk89B6I)BSwlyqH9ql#O^UKrD|`3p+^2sJ^%{}7WYd7&;_E>64)Yz0Hn%MkQ+F)t zGU)Oy9flMCV4adb|4Fm_HdNDt~S;)A*g@3VNrQ_%qkyPyAN$CyfXB6Zg0v zJoD$}p*&*oXCCt>{g(I>Fs<{aQVRYY&b%jaJ=1(;#JmCU=jtE~`19^?7`}(lc{BKI zux!_0cRTO+L3hCrnF`So{T;u3jcQxHwrTLgQui3s^o7WY9{X%8yqsJHOb)C}Sq6+K z2N~%x)GLL0Hlg7o)+>vEMIC%7;2r0Wl9Dr# zBYwgEvF}OI?ul#XZZBwiVp-k(DUBN@ELhXHVoLpPz4o02^H)xvwS4qrYXXVtnPoFJ z&I(kh&65{ySRe3%DM+6%{+*TO{-iRznc#BN4n0Z>DI}*3a<058CD~cYU{JE`Cx^Dl z^Ou4r$l_L2FA~SR-YHR_5U!$3=aQm)ICLGCqZ7V~^yNBh3}1e_;pu02be(lJh7us? ze%u|pVmCdSu66q$r(yrCJw&rr#Ortu<<8h8+q{>MUD!kW57;i*>Ot-$5(%R1AuJj+ z;lcrz{~eTdj?jbSXIkhQDHe7K_{)x~8$}A-^fb-tiYTBxDleH^t>po;Y{VI192~+=Vr$Z`!g;aA3q* znh2VPk8>o5q9XPxt+EMwJ^5Hq5pqWo)36@!7hFvAte+%2B@=|M37v=PpeE})I6!#V zOy-h=EGY;v-XDvSwzTr@96yN&^te}obEWP`X%{!TPslogEo-z1R&d8z1|NK`!}I(R zYoK`jdVfYbZtD4HA6-uQ{RWwshHfpUOhI317{Lt@i?SWSe9LL;fJIxK3zV<^?b{X= zWM@*H1Jd>pxVL=3GHpL7<6UcwX1wYTN#iwi7o%IU#bG;YcH9?f*ox*iD82-`6eu_N z6RGzuoEUKT<055|qYbuE#chK<8dTN-vdA|zEPmxbH~}#nv``S{*PN{MwB$q|xOUqrsyVAD&SAoV(`vPC4NkhYXYR!&7C?KQTBz$*@S@HgMhKhKcTz zM(&}5C+69q$afYTAE8{c(Up8>j03%u`vPPTzNsUp&ytmkpewjHaSEKxh%{jXVU@u3 zVcR@t&=viCSL7|z`?&jl6kDoBmTCGkXU+N5qe?YhuMONXYS+-g+sCV`&mUB88FSa* zK|99>R^yv8Uw9gLD(uZiG8O3NO7}Jt4Ml(R(WwawFB|7FQoDY1&o>PX-|ShiW8lCY z3%H2XsUAh6&?gU@P1_DEdU@`=6N_aXDd3 zx5W>%br%AU1R)DlCG7=`5mtvr&PPm4MGqy#TyNdAq${e+GN>+ADGDtw!%L3z|FA6W zha8cB99EqlB=hR8?}lZpj(Kow$)U&EkDVHo;QBU^Sn}cPdxxFAD}w4l`tsQ!`cmF8 ze2+HWUE}V0P_`F%pNQv=2jM9`AotHWg8)sGd5{Q z4AT#?WNs9A>U*&uI8L!6YyN+^=ka#1$9-iX;|{#9)=ekZJTKehh}$`IV%fHU?X!?v zXFh8rcO}kui3w3~qkQDoqK#I|IKKKeRXeKI4ikxZE|A(0}{~xW5Jlg*+Xid4lt<7_xw5B4d*5WXX=(YpTmvD>6!xw$#&D(%XvdW;@i+&S)MZIopNw5F8w-R;|T&!2Ep z`wmyvE+n}NnE`zcSpqrWk`-=w#Wpx zjkquB_*(0o6lt>r;cr#GjtaldmVYdFgYfHHfWIvSK8WWXVs~(UM;98tD?AW&maLO@ zo&A<4UY>IOxBo?5=Nqx%+WOmuM_PNe`=(CaS1Z1sym#WnJ`7Gn&wCGSRZEws z*K3IJlMM?au>RXVUuKdzIAENdblc!7ZmYfX-0tMv=kDBZ{_Z~W z+5P*qf;msmOrH7l9Jx>C*qAdx+_i7?2N`$nIfHTP1-0}TU3F~_Nw60b#inu1BX=b< zk5-2}`c&@ehCV5Iu3k_C0dt2%h0IS6g~ja_9sR9dQ21gdmDm22h)+B~+rg$ms(GCztY!tHTl6LIs{uI|MsHg{(DK>7X?D z(>k4stY0RV|C`x^Wf!d7 z1A3ukEJ%TM9}ZhGcXbUDL2J8Y!4az+Rvyw}h+lcnJ)gr4=}i4PWVBlq1qs~Gg6`~f zfP>~}WiLyLscf1WRA8E-3bb038|lsnbv0>%k2A`a+TrlTR(E!--KgoU)^-@Ol-I?w zcPQ{Dse6EVUyhSq%;T_&UE_T2X`JdbYMs7_3y#6B!wz36Q7==_fzr@C4NMZ5&B(6~ z)`41Fw`}=&Y%r@-!#WBPpl}9fXITvp(<;glAw@nmqTAt38LF#7n=$Bv8xuoYFQgwa z)17)>dzu5To+{{gMoH;fla3V z?3NwW!g98|sioDgW|~!AGkA;Ducmge-7tXKTb{ErHf6UO+2Im=%yBFA1AQ)H^;bOW zlP>?EM@zuQsqhOZ?D40tj1_mHdl$Qxd8L%5&VLy1kH;TSyj9i%RQlL7+e5ft&=wBVY0RFHMB!RBOXK;^gqy zwRbuaTE^2>)RBu`xmqZ>Xaf|FQUHpM8iqyH2n1w|ROT*(;1YCJdt!rFHSLipuF(0- z&*CruH^_w1WXo~JVizleP4)#8O6TV9)$5?wEjl6s20tg$k!Zv;lhowcPo_0Uksr{R zsmXDlP&y*!Q_TPx(*oy{>?ci>X2^!C?)mZ~PX zTXL-ZImyo;B6({cX@vQs$pn@((KjiOPC#7Gg2EZrP5PsoQ7~P||pD z{l(=~$-YawOn!2K`j2ZSmZ<8Zsy^_MZ8kseu;;eb(-gb>6_evliGDpoDqSUu8sO0d zM<;dZ6PH|7-uv2%)zjM^8K`4swPfNo0hl5jA7dU(r}&t4STL?4YSDlVRkig1QpI?D zmKGz_tMNTlh0>|O3wdn0gr17huyYYdsyWDnf&OMK=_=ws)>Ys?(p6UNI&waOdDvgm- zgbEs}S_*s189`RWEGeBxQK%CZpp&{~7CUb_qml;?{AwlilrvQTAU<5WPrUq>j~3i0 zGX7x3$D2QyTUV~y)}+_Ie(!<@E6l#)0dun2`}#?fXN2K!k-r*Em0$ovAfS2%ji$i{ zBpaa>r_v+oh|?z{5}%x%Opi(@DTyiFP<6|)5zpOL;Vl||7_<~oQ;EsGXG9z@_=EY~ zjSD{di}_R2wpA;)B8hA=aOhj{;DUQ!SIf+0GbT?$FhD4Cnonx)L5EdRFU71(beTXJ z6ZKHDkCA|7W_iSgl9!X7irmmjQEBy3tgNw`jZ{{ag;i6h<4s#e%}{d>e^u~!_PS|{ zH$C`*`Tm?2mppNz;(@H$bEd7EQ2*%e9rNDEzH58CNn@uCxUsV1pi@(Kj=KA%_LtO8 z8rWxOR@<_>Z>--#flJ^Dc|^EYkrk1h<$*g#>mYQzKEmZsZk#!k2USbPv=x{XN>{wK z+6JAeaMMG2q#cz^xsWBGFGfbXm9(~H%dS=zv-X}@4<{5R^Lvuwh1S<~$sewxr^vB9 zUSBP*?_y=Be{hHP*;#lo9^9bCVh`dV9)cyRaLrL1o$s-nAVS{vi7Lb|wIFYk%f)FI zi;HDflS;0>wfl=}6_u4$D9OE`jl2BfzE}0mZ+k^{zoG>fPg&>xHG1jd(%9qZfjdsN{K>$p;V%fN>9df%-OBVimw0%8Sd2J0a98-wBo(MUbo+QfhF~ zfRwHDY%u>X+{#lL=e^dj>WxLKXK#Oc&TF?m^w6SBd)MAFaq!Gu8*ZAvQy;bRSl#5q zOIJKuo|yRB-kV;S^~lEA3wAstY^PEJoVWn?RvHwIQ{y8A3s(9NXG#sv#y!3bl{Ac13UKW&@gG%e7*eq zr+WG4Uku&1a%laaejTev47q0cgu5T;T6AxEx6wm;j~zB@?ub4^`wZ_p>$(lhFDILS zP!D)!Kw-4?mk0ZK(DIRmjJC) z)H((7Q5Z@C)T>a@f8w2n%8oSjN{fd#4^?1acH zl(3YXLgDVhap|e6?*K;MSQus&9r#s$b218d$4wd;cUOajn~mKp$(F3m4!gJ;mG;+6Z7E9lB)H6Nuk6c+~3QcuKxW$Fnd7nX67&fOr@aS~s%ATrN{ z@@!8U3h?i#TrT2=9_@;otFKe8>P-MMV+DE6zlnHt80s*|L(>g!q3i3ESkLAciA{rmB)FooGWk|kMDE>aZFY4B%U1fP$aiPrrk@WX^l%Aqzl8l(hY`n;G z0Zqb}`}Ey1V)YT;o-4alj_Y{!s;_o0J#lm5v9z@d zc0E%*?T;&N-#G6j^R25F*6ph9Gx5%=)a>3pI@R2>U%lJnvsu?%UQx8=*N+R&u50$s z8Mfq$mzGYx_QtKV>+c@@)#VdLcI;9=Nn@GN&iqN;2wlmtiSC8yqCjOlkWIK*@tq2l z!7eE!i)lh+6Lluxv`=cXM0xrw4@y%8)4}hNg+o@d{U8LvUiIM60bUP_#lTg2&7TDN zh0S*gwD}AJNHf9ZEuw*Qp3ynNAH=jVaXO5GFrR3rb3q9~b2F0VHu5kG_6* zh}ITJR%I^r7;uDDM!48yF{S=%ulYZY=oFXleNR&JJ=i{|t5)}UX22d<2At6gTX~4> z6vBPCF%>ZfjKfdSMHDE5WmfxOt0n}$O(Xel{T6q|NtlA>q;-1}$gW?h7Bm5#gIR(pQV#oitTX0ZC}APn-W{~Qj}{0`$2@8Gk|d|u*%w=x+Y z>=oWnQpe%!r%~OPYp+m!wGOLt^>1?RPnv>0dTCadrtpn{4!g*$!@@L}J{sza`~aiX zJMi5C1-C%RUR2q8NO!^1NA?Y>b#upD8 zwWzTO7q_~?9>RC6HZWb0^U8d28}BXAX*u%+#+fga2);n>8qpH;rr&}u`rsd!^Jbzk z^9BDF_jnP(7nG~-{FeDb_GxqHlMMo2EU@QizPK@b&y`~2-9He70bj_Tc&>SxpJaT9 zFC;!xyUlzW$`@7-gsYBGnyekAN+V5ax#G~qjT_74`LnE1PB0{&C%MF+*AR&jicE%u zZxJCk@`|~OOepcXv>LABoJZenKh(xYLO2pD5{o# z{KXM}N7V_L`ZA@AR?q3B*;yIsspz@GbvAh-&x*3TQqG->uTWAPEZP53lFw!FJSmR^Z6jEU%ZCi^dx zx&dJBkAspx%`Ba|$quN$SVG}s>h%l+R`yUfu>*reCt+LKC~eA$sr?0Aani8M>^rs= z4fC=DZ++3V0JWm~7A(B0vFj!IWnXm2ubbV;e}5P9-~}e!xA~5H)rXtzujz2lp}|)b z4Xg{iK^so?$`5#VvlcdGp)vy>z(rDqJp2 z1T3JKn1Znv?7blN8YMRDVnghJ1yN&<*ki#GqiA9h6BAR6(G;H)qb5G-?Mb5C;rBhW zdkY4i_xa=ZzJ9#Got@o1bLPyMGp8al2nCWou)&Ze1*GcXp*j4Cba~dgdf;3}-DJ`v zh$BsqBt^l_KsHm_hA4%P7X{T}7b0q<6T-vg&}qvzNJlYW6Zc&`d$v*zK5@eKZz5@V z+j84?n6azZ<}PRFc}w~%pGdyY#BT&mlbxSvmwfPa|J8@u9saSk+o2PHX5IcAp)1tZ zfXEYNZx^}+@qGB;eeCQ{HIKCSdaP$DF70-B;F~uMV9|5nYnMy0>U#gp*bW@;b$PzS zFIT`xK63&dj~@;CbEsYTu4(PxJ)#{m?0mjU|DW{swYBg7-#(j5f1!uf##DegpPx4NpB=cZ z4O=nLJT$aU!p_1xU9B#ZkQ7Bd=7ZY7|N_@c25(5n~QsBvhuivX= zp3L*ay};X7<+HYIeuqWK$8D{z-qy#6=Zi5y+hQN1-~;gJ1Rn?lhllh64|WAP0Ax35ld zF640ptbKlK!RfNrYPUPrNbPpVT6WMF#tWR+h!&@H7-|vNY5m` zM9(y7bgR=I?eQVf0Bv)pZM&|`U86;+{aNR>ZkJaOz!QLjxVJ{JAuL2wBa2WmjbfWL zMW(4hE5u$W<%+GkHucg*Z99AQwpgRz>ud3KC;ir1TWA++>mPY`us_tk*SU^swY#ii zw2O62?{Znkweae~*F`(otu(wk_$9TA{Y1>6mUmDeOO)VY+T1#MSZ604AqI7f9PF}o zX`j)a@7!nT`3@S5t`w=(gFOyOR{9uGcsp51x3j8 z6*@SiHwZP8<xjC^v5oCe(zb0$2f0in3PQ%q z+RugtsWUybe>To8q$35g9nWUWs=)mQX~Y#Plee-1&S$d&6h$bPX-~I}RmnCfo-J^3 zO`EgF@r&BAUN9cu0_}o6I@R76K>uwq$!#&_dZZf<_ccOo%Q{27MZ%s-rjB}2J#%QN zII+2o+=&7Q#H^ejI$sppJR+iLc;SV`p-sahGsB9`^Fzl=BGbdennskso)+5olO+Wo z52nnv18yuRxG|7@`(P)#pZm`E@$cqvBVZSB2|fgQ1M9U|x`*F&z>6S?&U&T_0k(!q z7kFK<=|rnz_SD~4&pO~`Jzd}hY~N}S^HBD!1~CuCIE)&^?7qOa1~c&(4dzm|t*&M#69khcRiNNA-pGby(Qw7W!+rj~3OUww5&!jn-E%@bF@ z%a^mF4|c~t9vR*&VUPTj9P`N&^E2O%ibSjHHvo9Rp+SF)G?6Q2WGj~GyA{~N=WUb5)7pg4yBl!OtL$u z!w}=Is_EqO7YT{HakjXQlg2}r9l7c(@j;e&lN)rkOi7c4@dP6eK;n`BnE&Xsfx#=R z1KZ5&#W!w}lG1y8x0JV8iwk@>4@<~wl#Hl^EY5vGqJmmH}=|N8PJ>0kh|Cv z?$tQeb5FgV-PwBEJ^+HbXomWt#AiaJdRY-(P_(hYjcd>?shy+lXA;CbuE2|NQ zhm~moJ!jO95lp8(F`b`Z<3Z`W^BcA0KVRxHaIO^O8M zrhkqIvYQ=;;fVHzkL6r6XI}y9it0zj149EEi!`qIZ1j8vzk3L>8%#L z3iN?WdVmE515Fm4_Eqar{;EK&4r@)xkXf%!VY{ZjHtR=zu2ZpF7{9{U&bH$;x?=etv~Sxt$#_a z=g`{M+SfCjq#ga8@BL2N>1-GL1pNg+8SxK(@-S>0SX1Y{V$acF`>}-!Y+~J_{h#lK zOpDk>d;25DM*KiLSEEsTe+P~rfAquqXf4scYIMU|YL?|L))H;4okXs7FD#}U`vx14 zMPH>M`hMI0gucd@DKP&J-QS6^i8yYv^PH)?D6O(V$%Td)y} zMP?goFci-90h}3t=R?Yep*}`9MeOG$V2K_kjGN@Azz=w)uzw*k5zH35MrXP<1YZPSP+$NPPB&f3Uqk}AM3<-Vb$y01Qlyvt{MjdcKbs9+?X1f0&p{_`T<9Zmi-G=6wLVcZ5e z2$|4>u^Sm`<3i6_C-$SE&~%9srMSCZTtc83QT-7O(j9oAbRZ#iKNDh~*n=FHYBG9R zUaO3!)54=uBcJZuuj{Ho86Ep|asZezaYW}X;hugA8%Od**7*|o$S<7=Q>iuE9-~mK42hCM2N1q^n99}%cd0Q{-Lxxk#pko#tp0Vn{)$43+ z?6{MsIlVX!IN;-l9X_0rm}9YqF~@@cVI^SAXzj$$L_2f@uIE0qS@0}-FR+O1H>XUwxt-s+fWOOk?kwkb3|IMkY}%{S z^Dj>2FSGBK&7KW?lJEsVP9{hG8X4MUSxzJ4RzupraKT_Ut8Va;5LGzTr)}v~hN~6# zKf+Cb8(1^Y{fcBFDNj4W;5Iw~P7ArDSrN~HDuvRSs%{|-;LFA0EzFuB$6l7BAKX_| zzQ~IbpH--txKoj4)qHQ*ZMX|xh-mDzPi3`0ND1T>O8TuRLN}5D?Jg;;u^6SM5{f5L z@OO+g#u{r03-OCKM{B`B?rx;HkE7tAxb!9}1&*kw9PZyVLr#D%4O~6^gE6e8ir;zu z5eh*yIDeicA2`6TpI>rg{`?zD3O}Ad|6_LEwleS~*7y4#Sl=^e_`V;$=lfndvXq&s zE-=&5BL4UJDt^C6et!FQf*l@3Dzdl+^20X4+Ius{ekZf@{t zmfSquumDt(3hx1dD0e~>u?+pQQcZgBr5akDt}LpkFf^#BuuZP0(B{wZ6y9f|^CKor zkUI93$=~CRKYwLxqR~N1hHX!|B=JERfnEvJ$`+@Ds2X76ehpgq_V2RLCkC4^K)Q zmdDmfejT_vWpJ>Hj%$}C4 z$`yhp&KpaN0mwUmQ={}krz2hv!V|IY8f0>Wa6_dnBQuRf(L(ZJFc?LWEyEC0*OCog zVJ@I3(b)gq(a?~xi~O(8gw3E{baZeq5>F>aCt6~H>jl??_B}`ng8Dt!>U-Bd3SIc?E zBdqc3ud~KSjPvj}fA96z`Fr@=(D=cxhDCQaZMw7Q!Jn#+{wK|4B?Rq0n9C3;J}VXm z1q>U8q;W{;qfcQ&xr^Bh1CQC?&&>@c0w^{OpbON8A)ALtF9sM5TTk0o(Eom~?Kr*j zVm~mD`L;>kJewW&mP^xoV<`vD9b@Bd-@b5q`t>!%*QcM_Q_&GwA3wap9y@l7U%GOQUrz5>!BSF~``f$j z&7FI1*Jb`^D!&G@1^*ug9L)u+iK@T!E|6yQxPRfSzW1NiWv2hNPnDsXo{_2?!_Me^MB#h*p2KQj zOr+YBsy~D}lgFwWKu-AQ{zezPNr~=v6^Qc={2^Yp#(_Wdb-|zL+e-A+@JM|fIO6`U zc$5-6fJbI>zpKv2#B1=o_I1H0Jy$Ig&(-iMyW$?tb-}CXyGZoa@cVFI7yOF8@F;cQ z`Juk9c&5I}=c2EMZ|dv7H}`kNw@Y6Q@6=bvyEKdY(^`Zq?~id~{4#81v_`SFz5w2k zC?#hlhLYuhbq2%4eneZfNSCYGM&Y$!4oxy^UJDuinL?h{IF|0+iQp8h&>#_ysamnk z&f2@0UzS6LY|BOcpB2|<4cR(G4&j$q@7>QodgTKDXun)_jWr(RRq;{Mp1aG+|1K^4 zyL{Q*JxL!`cn#oJu3h72PM>CN0Vd$Y+QWWy7jZ%Ga}Pq5Bo-Nr!T}J6pu z6{Z@B)VfhpR9r$rfYB|yfyK;dd)GaILIQ+mEecAZ(ZtMhH~v<1OYeGaaj`ApJLWb1 z^6TWGIjx^cFh==gMe|GYlk$Pq2E!h+caO=oYB+|C3g2%qw6^uOU9|I!F=Fi`F>MXj z$v0G+iOyO{fRyxzJ!+q|$PR?MJ~HOPANv_jO#Z|a^%D~&L3dS!(jz6o-%of4i}R8Y z_8_g3>pnRWYB4$Bkb&>B7ude{ZTGs3T)S|=x(3~v53irrFfpM~3Njf-Dz_hGy!39X z=>-M(4W}Jkcx%wa_}E5`EeX#Ou4N$uo&qdh*u8*lv_QFO7!95+&NMM1xB>EtqF89x zr-C-<>xp0rlZgTwh)-LZs6m0MHQp|RRw}b>ty!Pj%#;7;4&TpuY}mPT13wJOkvF^j z+U1}26fc>L^OGijny@k{CP?!F1xR$L!fP3`Fzi&2KM@Seg#2m27A0g*`QwAS7|PN( zL>TZC_?D_7H>dktSho^9C*K0|@oWz^D1+ZzFaj5lDT75E3Ggi`J;~LM4kR(zP*H*6 zhTw!^A#$S3TIlPGcL$l>P2^FDz&8KP0D8aGY%${xi(-_A&1&4^DRa8=!k$wPc5PG4 zwo3^Cy`hEqCS^Mdydh7${}B%pYMF1;#XS9cPHaHJDcv*;umnMWknTs2u+At{1?NEo zyN$*<2ul$VQ3gJXumC`)FjLZM`r&DUXPG^1HB9^VbjLtTvy*JzUEYR$`6-`#qv{5q zbOT0$Hs7#+13ayi1xX# zr{sf&7!57OnuJ_oNECFEnw3mN%qa>6j!#S#K`;QBs94Yl=)+5ZYy$4!=i~&qvg!kN z_pa?Dxz!!+{s{ofmzUYnY?8d&Hb|of#GYP-&2#t(sM3TF59QOaz|RZcaqb?CQ!o(+ zPLL#%#^NX-UW&wU&OW$+M5_k9uigW?*FfPzOpy6`5F!ySNSX*Mvj!pL4%j3}@9k*K zdVkJmuw5VVb=`O5S5@V!=?~;hwlG_eyy)IN+gyM>3a=n|`8BbQgC)dGE`M-2*O$_1hJ>WL}=^pk~Rn=u%F5m#aG*B*dvp7BCn52<4-X{;m zYPM67S@MJAXE9Hhv*uY zwcLIhpZgE~g*%h#1hRRIf!}2c|`JM7|7ICraA`ad-c3-Ue zf} zH1cNh*Hvp-<%5fcCfm0^m}Y2j{~8ZxS%xN{tF4&FyLeXsaZTuTpt1vRM)quq!j&ad z6BTnR*yclSbE42zoWo}<6Yr#QLUPHs{Ew=$C1Wr2sjBMprkry7FLs${?kahrnY;qk zgi6zzW9(Zo_L($x^+}8wJV|XQaH7M5y%p`y*|lcB)T}4D4l>|+U1tYArB>Tvh9jUv zdOOnDVKD%DN<mhXR4|2R0nmg^iWEwCG0poIcJC!DLI2*!r??zaA2m;b%;w02eUG^bzP!ihM#HX@KR?o?5)!*l#A@~TyK%X?79!*7JPM*=`#MlSFvA5zq zF=!|G0XrI|MT?9iiNPsBh)o^)nYXtjc?Wq1`uWf%0d1BW);`G6E<#{$#h=0#eV9Co z4f}@q@?XETeObkZmF(MB0vfed{`Ag=e;JzC4%yz=UNnELfDJGV60nf~X_8)7|1Dr6 zTDXjM4^VLZtORgLvf@FLB=!*SNia_aI`H)L4Dj@iHOIveZ)CbSLkO`0!zTX&7Nt-C za@FRo10rzYR)F_WMjJ$7OYmh!e2WR2fu{PzCJAy-hKg_laKNxINeZ)s#YBeVmJoBC zCD7tQTc(3KJ0KA}n%SWlmej6yL$7X1z7r_hcddNdZz@t(Ylzz3ynLKoK^90*ZotIpTR9{nHP@X&f*=nC1VAE+2nY`jM1Ow(31;G{ z?_PptG~o|ZXm$WtS*e6$%IvdOeOLKdpTMiO!*UM|F8NDai~}gl7nAaEKFNW69Vhs< z5g`CZwE)>eWvC?!Xh+5LQGOuPP(T>3xvo-?&jb<69vK#DPh<;)V;l;aVmZNgHz6@y z=(?L_Vl6?_P36+9WJT1JGV$K zvw}6dVao+Kxcsoz6QjeppTZg=-L;<-MmrLs*Wk8Hp-Lpv66Fi^e~i%oSdgd_#!z!; zY@)fbA4!LZ^|!<(LIe|aAD}E$@Lim2)X7!+yuX=WzR9|*TKeo)hZ(QpmyeZ|9g&}5 zwsZ2x#y8h3c|YG4CTDG5vS_2WXVz4x?*Wzs_ql-0R-khNNXzePrRRECW z89L8t^afo!!XOJI6LR~Qj6`n+6I8c$wKJxKLcSdIMs?VzzNEjOsQTxiH@n6esx+%k zZQ$TK1*ZGRiZArd2M$2rTxL6<(cR3q7MbO-wsl?$-<>PyE_|QOp>>}2=_b%!-e=n? z_J5lXx+}Xmo$x-Z<~xLE-9xUg3IJ091p&O)ALY9 z1&76A$!tnVghPU8_d)njL)K7VEO5CX0uoB|AkvciNtPy=q?;2)O3LtQ62ZtKluan; zu%MuxGY%PkK6~V~QJ?ddj*&7Q>T`yA1~aG6ST*lo#U-E5yHpV24p615Q_lSB26pY5KI>b=*cM01C_9`0G< z3}gB{Ql(I!A|k61-QiBfK>o*D`ez{owSHn81jWek5M&(i_Ci*7RYLM?sxL}5hr~Fl z?nv5H`@+;IfD+QFOy@$%TgUnB!@m5+QQwTFzK59Qv<;663B zHA<13dv?YA_Z9`dz?yvM$yz?0-8w6PeaM=;@FIWv@~+)qP2Ibu__H}m*R^*RO}j;S zDF9uQelrZ1fdvI8YuMx%I4N}FbT*M?S4@zIB8VcUUPL(6o$y4h6e)~_kvJkOC_3Au zyn1#8Ee4^Hw0!FV|EWZ6=>wjr0nOOf^DJraUVe>*Rp)EKFAjW>HMPTfbGDsv$_F%< z_4DQ&s;yw?B-UmIcI$~4gRj)`gbzedvawUhuU6ikgk7-#K&FVu3c?x{8Ux`sVsGz% z5(o8Ip*;ZYl2Z-De=AOW>1t4uIr$kOPo{PxG)9q!WpL5|_-11rfC z!)hvwJ&9+q&435IL?#CSEgx}9V=B%T=_Kz25@tJFW21q)uuv3u?FcLb-^y5G@d6&i z@5RTZHi%1)Ml-9fUGV9~&g336SIx zrDaH@?(gfR!V(G0lLaM|#2BG^gIg1saG?Sb7C2Z~D3$?^s?O`s@;mLku+mW_PvIFw zeXzj^m6U{rxKD^->?`}t7SWLWS`!ieX{;|w3EbS1!w18YEHnj#nvLKmNsGv%Je zpU<6tt8~G>VWI8!Z``}TSH$Rp_nCLY?hA*kJG5{0;KlvYy+YS9!@dJdT|0J1FV@ZW zf$amug^ly-{a-;UoGlb?tBJ?|`R>J>z_iOZzg`+S%?hu2rmDYlps= z8SU^x3(ZJ5XhKd&eSD9&?ilAIt~80vheBEyZwFe zm8R?9NtC~?8+c`iluD8_W!?`)rUW4fz)=L5kw|hu*9;_R)UD`Eg%v#=o^_#;sIL+o z6`C5Bif4qR#JR)dAAk&P6iiDl2H5h2qXA62BvyhkITJomng?WGeD1Bq3tpeJZ2F4h z)2j5PBE9MA)MIXtU72^#B9vLd2lZa$JvsK4+{fIpGb zFWAiP@a|6kW!??dMK-A8T>PUqaFkROxt3dlzej-AAu9syjY#MtL?%)|rvW`AGU-kR zQAkW?wL~UHC4x11nv955i*VC;69ra-Z8!C^h%E-p8ZrT43(f|FC?U?ueb#<4=l8ct z*2(oYy}EZ}!RGyM&G~#?=?gEEmhO2WbmpBMcbV*C89R)*?`VNKm|Rlnh&Y`F z_2aGeB13~Qra%^`M?TaV6DlsEM5BGDuy3iDr1W&xF;zYIjr~%%U|Lbh%snMfubTes zqWt^?wFks+@M?aKzb2<7(1^ahJgsshjSuTupBH!^(3mLy%lFEc_IW~HVMUFDn1Is- ze$qTaJP>0N#x{`;Mk6#aCS-jKGW+^?A$1eYlOEM?&qh*f;hFSscMzMY9{dR~PoZb8 z#~ckAH)HPlqG^SNn4sszPYpSk@b;1OKgaax(Qjyc{=0#DRwWG_lAE19zN}ZP?A-oc z8ZIe4yg6-1w~)|2BN`4Z=_cl5H0C4RIUnBerNDe>)*)IY_W7_cl3MeDBZXr=7=?3qOP~xblEjG>(y#(=LBYqXPKa92n*S{ua`%PDjXy5ZJg;a(#$1hR1LUG6f=`B}&dj z)M{4j&Bz%+x5P`Ti4qT*5Tyk@4)n!H05BBH6mzDpG9>Ve$VwpH1Z*K=B@>Q^kL=h# z3qEnpGSX5K<1IKlga(^^CFFh5lR_pWnjF&zD<6r0I-1}mY{!>A;~|+s_@Ih>auq9!X^U}S{Aq9FDw3hRnF`uj;u>xvzmW(p;`T_r$_EN zyJ$~Vj@4k;v5Z@1Zl2v?@s#`puL&4wzor^U0aE8$HK&3d60`^*fOxDZ>00SG#?YkK zor3HP*!7F{+EehNVWhCuvwGN-*sMpTR`%wD6IA6$-s-5z^kAdfA2Gc&R{|cvlNaL2 z#FOF4=4hw6)!G-b-F3DvV(aQ`Uo3rJXZsTAojThKAJKoQYkwi^QFr`IYcy6!_8bNqDj2(|(_z7X3cZwUATAea0V0 zyWrE&uH6Ue6<5jM^ILVE;oq=bhQi~MBr&@Og1*Nzt1XFzqa0vVWLR`~bVyKuKWdgi z>#R#+GV-E}95?<*g$^U7MTW9hW=;G9EdKuToUPx?o%_vJ@skJ38`;5a+YYi$_}Ip< zgQ1nI!>!i0Scl3=ehPo^Q&B!wEiB*jUoCMi2g+5TK|P)-p88Gd#HU;jP{&2Yqgs^7T3%W&)@q{`;r>y zLGWJcpDEUmfYYPUrGK5% zMcdmwR@OAfi?MG*C*Te`wMYXsb%X_Q_wdPo|Q+(u-_%a6^H+a3SfvjnI3Ou~3-puwUxOM{U1Ml~OY- zFay;~cXvYpNY^b>93+}$8n9(Tm=Rm1UG^psFi2_Jq~){U^8ZXbKBPy5D= z(cNFRZMgl{i)UZlHGsCySDGb#c)DP7S0B&Er{)fw{fxIyd9j=KtcBy|Y+t!xcA?lr zp@6OVOFfKr7(&rlSf560^ANC^aO1&pB#>oFkRsM2DQQKbG8mO4vb5UQB^gSr0M{ic zklJA096q%2gu38$t$c298&ndOuT-~CUN0}V<#s_m;WDEq_!RA%Bx43(0%1op>)8}> zY{Z;qLh0@}Yg4f@99x3|DNjcr>;bqZAR*4AowIeO1)hbOt|JZp?9a=}KA%0~qZQ*F zWer-d7{3W6r*o9|k1%=V3eJxn;rEO6vIcqQ^QXK#@z$A_egGW$K0Z&Z$s=eWy^f}D z67ajUFJdRPwWN&;YXJRWXCGhFw|X$_?C`a$9<1BhA!n({7`uh!EVCcZq7FGr7mbCA z&qdAxkvEG^aFw&j=p)7+VsdIa(=|#N*tPZWjduzP?rhxoN7|vVl8K@;Ti%E@NBCDe zTC`gH*TEN=p?Ftm<35w9E?ec;vW2^J9j5vb=)w%h5M77}P=G`JFhYLP68+#j9N#M6@|R!yPeai`%xBl3(XdjOk1`Puv7AOn92XlWcP%>_h3wJ?;h0Yg!+kiP4uI9P5gA+PkWCZ6MvsU5oUib(U0D~kU@V_NBbhS zq|Wxm(!c6#Um~5Wv%T;U{g=A-r@cgnr-(h~e2z=|GSmKY`_`|{IO_A^K;1gry(w)av-hYAr z%HIyue*4LrEoX^qnJM-t? zDL;BNucU3eV*W+#!i{V+FE8QMqIe^pZg{r33X3qWYFc%b@(gi{DmpWYd{ln+el0ZMe`B2-BmcG7!EGL4J^fDVSbX zkNvxIUen7@&*(BcZ~Vj;M?5=qPWKs4Tu#sH^6!%i*TlxIBc>#k{c@y9n`2)WA9(4& zuHS#(gWe!QVD>{F{+Gd>Uw2z%JxboaN}uC~N0_t)1jft$m^VoLEy2w=a^h zNjje6?7x`3RA>7VyRCw7CiX1t`Gt?@ztpwAkT13VMUea zVuI)McCWJmtlyiw{oE+ulKJ%;HA+Zml+4@C&5zG%U{hw=ddP>X7ysRSaQO6j?7eQo z6D`Rp(ecB88_l+Wh$%=Q4M|fUglbX3TblCqLzgXKOE;39K1S5b($eoGNnNb5_L?z} zOoSa?vY=*+?!_byx6PoGYMKs%jE`*6swWA>s>9SEY{l}(;=4_acS|5aIC}0 zCORTaugc(KF_{q82q!jzSyNa$V+NY)Zhw}o?5&eGrjKZupZ(e)9EOx?(JswUATXDkG6es%X+nM+m&Dx{;EnZz-SQh1eggC&x+Dpj0s?H zf#O+B_IOsMmyILa=bq~JxXFIMVIn*T+iAI(z!E@7dAMH-e8i(_*aP`^xmo_&)x^Oa5P zWOaK)Ftnua&~W~IjN3Fkw}f!`IA9STpYRJtG%E?Q$czg!@@U~~8kcyWfO1kw(R^Td{ytt-pC^Qm>kdJ*=O{z zeP+AF{>82I0S;Rtwqq4wNl>AlAzxv`K>TJ>PR(!1Ms*y{w_UP2C1|u-w?`pq^@T?v zDzlM{UTp>}?bK^!?-6s% zZh~lW?Ux`}oH{h?0jNC%nT2N_@y`(zhJwR~(L%he< z$~?CEHh+e_cAJ-NhPQbnyKVd0cAj11DfA9rt#-sagy$g4ydWb#Us>&dOT;Qi%i!R# zBFsy~<)9yU2?)t3B9Aoc(d=HNF@YiiRwU%-%wsFQ;UgEm`t0ySlhX4_2JRgDmG)}x z?LXtpw7k=^0@p@un$UY;CqNmCcH9l1FiJ!0NKzCnrUG_xZK+X+3At9=--|UC$i8=- zkV@s9Qr9U_XbaZfsh}JV&d`Zjao~XB{0!a)KJ>rFlLRKU?3`c^mNWClihLCRpIG+cN7Z zP&o7?lE`l^EZZXOBQT5C&@QEwnyXJ5WIZ$hS}Pb+siFYH02b>g2}Up0eD;ym?~gWd z$Q|9Y0|2O$&6VqTZ+8?qXq+K$ARq{$`+v?^i~)jQ(z^dd;7r3s8~JxTF4SPaSv!|N ztle)HeOz}nZRBcjrR|p!lpszyEp|0LAM{E(4$KjqakO({2xKAGb7G8kG}O+CiQ1u2 zlh=~yoEZ10b0R`m>OLo$?Z-oAKQP+Qi6=B2(uus%4joEay!hp)_{v7{O~w3yeoT}t zO3u7Xc@tlqspM4eocZd+yi4;i1k7Pe-dXuKa1%*&D}n?3yeUr=>3K1g3LgJ`%jZmrT72ErKYi>!m_4{dVu@`E5 zO!*3M>wHX~^L>Cn!Lzg8p6{Rq%sJw>wDxxJ5!KfPa!!(L{ph$KjQEjpKO*_0rlA6n zinyP4uYOaxa%{(fCn_tSn9p*qTp`@gn;u}6n<3fV0zYA6CfZy_a3Y0+20!F!f*(s0 z@W`TF#QhZTw>1fgzpd*d(Z}!~-0O^YiTxkqUA9&-@&Eo_Y>n-Sij~typs3-@xJNGQ^u=$jCYhgjPvFBbC1M@3T&!bAn_gaCfnEWz=6HKdi4fEg-scij(u2jn@!^n@ zi+N%tiyvN4FkHU!=H`*Rha#Qho4jCb&%V#%m3SxZ0pOF8H@HZhF*af{>@hYzK5&i- z_JI=#Zt#wGjj^%A;0Ut8hVU>9v?ojwU?}hK0U8+E92k%b5OYHY3zK|IA-cQMhs@rJ9kWdtmwnagcV#vkvhDaEQ5d}sD!W)V7-~bW-D5fMpR7-*K zHAp)o!20eC2ns|b@eqEX4tS};Oli$SFgswQ_%#hSJ6M>ZnC$;ouubJF{{b8D2`S8I zBYdiVKp|l=c*>-#7xZPMTuKz1gVhH%gUAqjXb$GtH8e+p3Ogvk8J6QwD=dd58~C%B z9dX%PD`me*7I*U6wUa!__OtvNiyQsyv!nSNg|a%VdHvNXTgvexnCqCBd^o^IVRv zqa(%RXaP9NP;AfCIjg>-ABlW;s!Y)p*uehL7rx97Me9(oj)>MFanM5HM@}bjgzLmV zs1(_w%E|g|P{)u{l;nkIkXb9Nmph`QSMJ4^=H>K~%Mn zojZ=Qh4WTZ*+lk=C|YQ{$(D+ug(Uw}i9BwRq%$ykV9yk8edOK;2O@~Dl5r$RNJI$% zr{Z`G!i$t5fG__zi;%Y*4p1iSCSVTGXaj#5H-qw}XiMRYHyc#SCvDuabo_*4x%q12^KaKOA71C?#C(CRd{F+ z;zs>^V6}3tD@}Lq@ZdB7M-C4$yC|gF(TcbFv#)uCM|RQh=hlWDO#RCt4hdu0g=IT) zwhW#!u<`nRz?INt8O?w*MQToQM)77@F*QhtMgj$Zs=_r+MVyfXR1%oM11Qc&0GrVS zrJ!Swmdl4MS){TSM`&o!N!O16BVi;)fRS+8)aTS0V1%j*M$&jW+-OhpyZmy&HyiUx z+I{#|=3~7^jXsq>DKOp1#@1RH0hPu%dd4%*(gf9VhZBFW)yR3?<;!zdbPHYh{Z{3|uA!6Ul22#0Saf}Jrx#!D+q=>H z=jEMijt?lsem0lSQ0J&fM@#WLd?lnaiJj&vg>**r-V8EK5%B6mXG)k_gf}U)E!Z=_ zOG$=y9A7Q*W|0yAvT-`4Zy{e~WQl#Bk9wV@d3_sSJib%=?os?@h-@q5it)p@Wmm5T zE){8NO@eyZco2wbj654%vpT~fFQ-RBKiQ;F6wrGLJFWzA@M@lfOLz3 z6BUBf55lQWlmWmalcc1m0CSYTC<=lU05GQ@ILAzQC6fyd_4VWsE1JzAqHZASA!^1p z81WOe+yKFH?~iR>7d>|8wWxe^${X`$6keIGp7AVuuEi52i+ewJqkKU{_rh*$#?<9K zrhodX?-xh%^1bA6b9&XfDaW4mzI@4j{GoBfrh0OdpI`IAYsO4@dAi4|>{*{x`g#8d1e&FsM8WI@b=j-Lpydam6klzOfI(t<|lspMn zJVTIsK{p*@JQyBq@rf7(k%=it(G!))(Mw)`_Sx5$OfUH~`A~5Fz`?VE4<>)MZhGIz znVFOKn>YMt+m63Bm=Esv+P<`L_E@j#*SscnZ@heu*Iw2|$?%_fc=)h`+L^l^VC)DO z!zeNhpa3jn?tr^Dlv!gy?%1!1`=RWX$a-in^c5OJQvHMoZVbgr09DuuAo4&C4~v#7 z3``kWiW2dI{luP8S*xpjHRtCQ)|#I^$Iq~~3O~mrz6SBFPsp#?f{To$Mab2XRa9y$ zk||sqbTARHO+g$*eQD-NxHM3;;Z8@)@Z(8BhGN7_Plh2DtJ6(pBCwU@fx^G%J8oH@XjtNKAdI;gTiVxa+}>L^1{T~kyYRz5;%wj-w}dd4wxViMI2F-tk9YNKsY#QX>eoc3i`+>Y2&=fzDZEOta{jS z;beql94=j*4}$pQ2hd`r*m$csAj4{Q*Rm(0gaKJHb=PP(?xed0E(8V1+pkn?j?Rqo z@oVeVBKyRN<13O!Mm6xQAAUrAyu3Pm|8ax+PNO=sk8-#C*<&yJdhSq-XT=!{niu#! zv;$q%Ba2N`Bt`QH-wQA*AEtx^gKv*DNoZM6 ze2{@Yl<+SdsV50;v#DujQ+&+qPu7UPPoKOK<1eh|zaLK>XT5=ch_fy_RrGw($s*eo zHu%%Cclosv2nCCBPvt(Jdoq`GqxVTz$Oc;HWQl2$^$fBM7(D@>Ng9pK0&#~}N~2L8 z$ZZHV4Utd^b*Y&!#kiDggfbj)HAuPYMMg1D7d9{Qh0?0j;ru1UE63SEX~mDS_WX3! zzwuA@uJ~m9_)oY8>#}+My3PEk+<#dGzrpHPEUS>O&b&Np*4z0NTW02O)95P$xcv<4 zDn;s@)gzvHxF;|-4`1+Rn41-~Go&9ktRgHLsKdzFL5JUcC}MU+7I3li4Hl`sQlymR zq_|jfpxHm3etJ`}J(C4;M2N-Y+~BOSl48wF2cOQwFMkO+!?lHEQqx-7UdCST(TaCX z{uoLCr4^0hZNHaXG;hd|Lw#}& z9Fnska)W+`0oFGGs|nf?cyGZ^4TmF;wK&TS!C}(?su8<{o0~m7sjmK`YUU*75WB_i zrs|tK8z8+nY zlcS;}DY;>C!?cw8NeOY3yC>Fyhek$(5qXH+B9K_BD^-U;ngC^+@Qa-L%?#3Iq9uq@ zYh+rGhQMkG`eZHsv2#~`Oy0dpmRIdc{_#qUgi-^t?N#QUzck8rQ?^DG>fr7dyoJVWY$4mC`=p(e^;3ydxjT$8-A*e7jBePL@ zqx962qy|Y1lItfX#K&PGV(>at#T1+rX%h70TcqiUq9q$-#S~Z+E5ts0u-##7S}uH% z51&~Qt%meWizOsIlUYO3PsNXQiu10*4{uU%#! z1d7i;i zgd%9XJ7_Efr|LM8y<;#)*z=I^Lh|5)3MB-A5`s{qkBBA!EahWa`TzKfn1E3;MF{ zrV*uYuC}dOez|1gt~PUIuhx7PtTYj=8#QbjD$Ac2%Oh-CimOWbWVV_#-6fOJ-Dq+zz!eBJtiThC!^7b2fmAeL=rS0(7lt8< z0b{oUYbU{Qu+k+o1gjw_F(Ec4Dl()|Xd`oAtbe?pH|h&Ai^Jh0-AJMVZBvk3W8uT4 z8Ic8tf-ox%zv>R#Q;m`q&6&RbZN_V^efUSaGBw@yU9aJde6O$pukX6@Rp!xC4O;K=R_3aI99s1)V{p&ryOJZ zl0N*6y?ghTwpc$Qcl#4Oqj6!E4kY|i{7Hgg2F{F;pxXMf;R~$|h1d<^_MWGy-VwNGoC())87#I|85=sAE5D|G9Ppb3Z(z_}`nuUQ0f;On$7iMyi-G<Z#`BC}jBzFW9-1QdabQ-z zlw_v38z0AR>i$?JB$9d&VGum%5Uf!%g5xkIB!DtOG=K;RnM=etYNR~OKFCH5@yJwj zW}v?{AS2L|wj~8KM2BD2guJ840TKEdlQlCT(PRn`?wrUL5|Wu|3PwH)tPt`~WDHZA zpkC|Ue|AunS4KR4$<2M(0i;?&%A4{yYew#4UE6fZ9XPj?666F0HyM`MwQXBlPxkcU ztFyZxqvhdey0YG_j4S!~PhXhRA~)f|=j~UHL`ocG-%A1UzaTU;m$mtrvdOSr>T%!L z+xNGsUdnR*;OyEjl`{{{qy?xw5;5F}p0`0S}A;;w~{l-E5XIU9@KR9FM zy)9u?QSU5T{B~4T*yekyW=uUfcI?SdFPmRs9scz%*6~#{Q~5e^6=Zoe0HI1r?ih-UU8){VZYc;1CzrDVnsCr@ z0q!wM{h?M=>_=Ek&QKiCP)jr-D;3@0?_zRx2W8-JL4Gp&4cOc4{Sm+t9})}gc8JxD zh(eRHp*g^yLx>_=@*!#0Kn6(W4Sxus1UI-p>75ooU|wr^?uDqT$OF|Is`z!JM@p{R zP<rDKI-8=T})VF<`r=Ey! z9^X8@afAAl>j~jX1}Tokne~#!TF5`NRAhr8T~@R77^Fm_&^gUrmAX<3#@MNZrw%zEd`r5W!IL1)J~SnS*;pmuW41;@+k~6YxT_U_OChoMDhmp zkJ(>raEWVq&?aTzbJc9j0MN?TnuW$zFa@Ma$2G%{cM2?BQe0>dSb&TuFY(=E|BfIpQVv<5`+*85 zkCerQq!_O5$nHg9Pb(9JC{(IRZP5 zHwRk%1L6X$q&Z?Hp)d;85?G3f0O=}Zzrmy+O9wng^hFmEpf2l@Fep8ze9+0(!yD$! zK6T+Jo9H#Rd)DOkm6cxRUNhQtnvp!tAYBX!?|Xc?ElK{o&#>e*Q*Eu-P;OCH=k#c| zXn<{mnscVnpeM32aB{~#kxSZe9XehwX!r88D$R)qaDfhq)T}u780KM_NysKmrGbc@ zjp#$&@$83sLp|i}?H%SFipWm0)jx*RLje$qF+`XOAX|_?L7FoB z^0QRRt=Z^v-3ReG=UDzZws=7I^Sm7Pv&}q@6%QL+-Cq99c6`uK`6rv1BM^g08?k7c zV;o^pOjcBozZ;zY=s2$^{c%Xc%z{TCm`$YSwpbGrzf`*PN)uNfqf*7D01Uj48B53c0bFJXw{y!@@3c3v(( zgGm{!R^hh>&*PBQQb|5ZutrC!%#=#`8Ntju<9x?pM;i-{50ml`lBhM&Oq`bcs$G)n z`^Scw&58c8ejY?7Rx{{bH7?L3gcQO4LDr0fMCF6+af$KP9bIz9 zzP(oVe=zZ5!zuUZEXHl$=bV%_U!TP&wO`XXAPdd zdPr3deb|z}{!Q6C$m?1I4^6cf#*rW`i@=WJ`Ap44{+#Z|@tm*}7@#v~tG)?d84hll zgp+GJX$QdJJT!gE5+B&<429s?zTUE@2lE^YS(FrD9;UGvIxx_mFd)2%j8ga1RIHQq z)O4r_G+7)+(|VCqmMxl2qJBo&v0=2qfOSVg{kPQ$k5xT}0y)FP$s1H9#BsR?AI7%M zD1U2M>q#x!t{6P}<`GZh;kBJt@}uPm3MM+H^CZ3iul)khOi~l%a)$Ba+*`S4$!5c;cK$ zUVEAnjgi%cI4>l3D&g#nBX)qLKLTj^%&6^AnAWNt>`X zx?)^Wq$8qp2k0HzLa5~ma9v1SnksY%1a=k68m&+oCRzQHsMHur@QBJXwEbG0iJOq| z4vO7P?5Ca+oA1bEmV>Pn}u*!ip)A3NuG_n09PL-pO(Ej>LL}ys~Q6g-L{G z305lg1m@HOwp~OPBYQL^m1Jo+`!Y()4^aSiHW<=CdeDM-!X3)f*V6|#cwm+IyJ0c{ znu249bFMiPlO8lfUir=C%O{x^yy+WmR^6)A3jP6WSfTh-b1%#?@-?b$@Xk1?Lsr`` z*uapT2B&Z`HPGt{BqWiA5tsyUT?HzTNR}r(We}aU&A!4-9TJ{fZ4_#264?(Ep+T`I zsAXVxo{)PjdVh}LwEM2S0js+8D#>ZHI^|eD#m`op?v}PPd)f8b3%(2-eSGqW1-;hg zIK<_5GJFZdH`K{=|k32*K`Fyh%O zGZKrkP-Vt+CJMcF#X*ni{8y&Fs}RJE{nd|uo*3D zKRYvL#{^%u$TQO?A0G`$o_;3M&3D3%oSA3Gzp!R{&-op;&6&PNKEL9*yu!k~=Te6f3ar8ouvwEvz7n+E}zDG%I61f?AvGk;QnQUKoj6tqPCvCcLqR3hZywmFmEKw zCCN(G=T39r(Rb0HK*S$J1VupkSLZIu7$!$XQ~`F=j6@b(YbUk+hrQEf;;v(?_wJ)@ zct)3h?5J$Kvb`hirhoHYw7K3dug>iNIN^)|MvPpr*yDwN7VWBN1?EM?hCaeu1gsZ* zJta@X@RPyS0&x}^VOVjXN_-{Zz+~gJm*aP-Z=|()e(rFju&3wJenroXrYwm_BxW!Z zNB<|At<9+%Y!<;MP+jN~3le^a%?ioK+Eiad!Z!?Rl39hfR=U6HSvh~%OPzKvoyBI_ z<}0&#yG>utT>MR7&e6Gf)0P)?E9zCoPI*(~@&qNzu25E( zAoxQD&^IAj7F<>HlF;3eEZBv}nHF{;s4MJS(G0o!%eHgukIJ{-uGF?6KQHzU&k%bN z-lxe{slZR56hrweJW#WnXak-yG9sx+tPxrLhw2V8!AQFi86Ff99OHvT1(GAg zU+LUvw56=+2IOALug@AZgLS{cyT|o!QuJ2d?2nce?A~3l;Dz0RU}WQdILdyptq6;H z?#hbgAJ5r!ylCZ%hnKCWB%A<7@U&F$AqR})r2!r-16XV_?rK1CUwN7Ua>b1~yN)d*AXk#XNS0QE z&UOOE{~u-4jraM_EC4bp;_&Y8K5}IDuA@i)v7+{{$5|w@ZnxmC^IMQo-vAAL1$@o2 zuO+*TD&`VuLP^ObHwMRALcJrcf-a8GkX3Pp4*H6%5%TIi)^)qOkmS|-?{0^Dcn;5< zj4>JwPm6rX8!+Z#@x5gjon>d@`boUkXm|$6lWL@6xSlV*w`xM)%kaHi^luYI-(f|^ z{zCoR_M-0_alK4jZ&%OR{~oTlht*ec!SVkkUgnB%otGVDy>=gI{b*hWtP?N8Bsh7Q z9si~-a8G#5p7#>V<=R}(be_U?AV zkDa%P{Mq>K#D8aj|0>|~If38o*3=)G1$?LZ>mt5S;N`4TdY_pLZ`ZtYpKJbm_qpc3 zhyKMizpAmhs zX7~mkIfqVExkb6_cn86763 z_-+y3x59mhNj>!I7ODS9q~RpoYe~ezu}DcD1)+uXv%&$HRN*-)&dV{NE(G{cCRLYC zq%N0+Qt$5lv)rT1L6&$?hnK?1!THJZ3VDv)k%AH^BQ7-HIHXYNV)@AR!#ze@Vn_8j ze0~0quJh(~9WtNaJ9Fjs#4*N`#!(aRUO7|7rp@QK`ppju3}4Wf-=066cpd6t0RDF| zo){_jq`Mp0C3N^B2t-&U;LZWckqjfTpv4g}hn%Y{1UR;J5SYCeVDFDd8itDQ7=aJI z#Yi#!LFOnyY5{ONYl=J)nQ(H%?*wa8%GU(n(exmwiQsOQSCG?n?%b|91=kPdOgGKW zJ;d*=pFW>O_FWJj7(TBbt2b|2*_kVMr;TKlY}EAISI*Sbuvo|ZY|GN;hjB4KJN^*! zSJMvjw*vk#&&Q*BI8jB8AO@OCT(gL4Tm2rs)W3i6+ zZOf|TKEOt>?D*rMYpjc0U%4s2hbWEXv~EaOhqiUfP33XWD7B5(pdSzD0sDC=MV+J$ z16_V^rg2u``$X~mhY#rcd8rMq=i~a1ztsNzllXp(MW}<6DY*XguXO#Il%@`XKGJCT zMSQQ6MyNBfPK<_MMgNQJ7i8;u9^Ze{zDs#{em#8uUH{%*ouIbE_dmpU?fpaX{XgRS zM(Lnhrrg5!KgIVlR;+GNyzu=m`p%5Rn2@AZ~ul@9oYu6a+l&HbD@8_Cd zwP(sl^!HuEGY7#~Ycl*|zlNen+A}Me3Anm~Yro=|wc)%duTv)|S-AGwKd-R>;P4e( z`~9ESr0;;wf8*L8_G^m$ednc{xbH7q`wy;_Y2z!?VA;sJs%7dDT>I00pJNPVatd(1 z7uWv6wJjPxw`ljhA=Rj3)emv#@PfeyF_ozAU^09OZ=O`xcuVxc2=T#guu9hpkyY7( zz!yqxYp&G>f1}Q@Sx^-PtMjxbPU9k#|6np{N?KZfoZN^LI?irOB(K@cn)>dW-4vC%{Jzh*GcdrIb>IK{`Tu^|#hJO!J?A{9J?A-3o&Vh8DVv(d zOm45+`C{3&idl!o7AngV*5w|2J-%bvgz<>6)gC^sF=N4cNy_p}$d4IcJ+m+!rz7a= zG}yfk!M?J_i{Lk7Sk>ZYTqV-=LX8)Jn=vy&q$#nV?l*reUfPY&M->m>qKzO5M{zDb zioGF0UW7O#;L+8@nOr_3f*0jlRonyxM+ezek`tK2fPe7F83P4jC_t6r|JuQe5fbdBGujvIEB z4T@|no85ZP@)hT6W`0_5fF%W{>P+eXe=K=J^hK zj`^-rTBP5}b9sN~=A4hfW(udyQl{-T^d6Uw6jK$bOy=YM8`9*7atE$tySrP8Z=pLxP8( z(ZCSnAXt7QEHkzWk9?yloqMbe42rJD+Boce*5K(~o{U~% z({$2U-nW7Rc1%31yzlOox^8B{+_;f*N?Xs@)IYg!_1meVi$~8;iZB2)2(2*_R z-#4+jm^8DyDQ!M@y}jp2i)X?nS-?WJCWCca>v z#)i7PrL5-W9MuJjR~KC_uB+s&sA_IW|Lb`u_hl+5!BQeFvPtqH5&gI>kykzCM`&NrnjR(Wds@0BX$=a1QIm7GjohYw{s2i_wEpo{12(d5}w~Zt9xGBq??0S7dll!;Wo~*LAk# zI*RMY?YsHIK0?V_7q_eiE#%%T#C59r!!5<+$iKAY{J^s>JKmK$VDtus5#ctBp&KrRL8+SL+sE+$+Awt4A$c zf$I;z_5bDj*AM^O`xlMR$G|`E{{#20*8lYWg?U`6H0n&6!$O)+$o8l{(H^19AbTMj zeJb3T#z3ts=fXOr9|#jcG`%3!hYmKcS6E^jM`40t99~_T(OV` z*At3bw*~328Evni1GNaRtF8v`*!ECV5%U{WXhnw# z0X~+ZUMrHHWjEfY#JevBM~Mn+VLgNd_|FtHE}aS4S?Pu23P&f#L=TA~W8i+i9&T`o zPh)A$(9<#a!n(oFIa(%va59*KMWv030L-Be)a@ilP?hVjt(Vobe4yg6u!Hgd@&|BC zT#F=oDrrjShioV7_b!XSQtzFyp&@2zjf1}5+I!brsG9qH^VF68hQsNm1>+~4>J%RR zn{x3{ww5&%?rRAcJZ#&^!`oJ@TV33c8of|yWS_I=pz+>!ZOxa;^}TaHyf8m7JJnQs z|9?HO_G)Wpc!_y_a^;u*TK4tD`Ohis|5P4S?imnf*lY~<6DOQ|;=<}l50q3Nn@+sr zC%AWS;&<{xz3=40RKVOh>~J60b-)&K*pWW4R=^xM?4dret$_W&VaNNxsNBaKcA^h# zY3C%JNxK3*tS3QBzfkXPU*Hagy%Y@2`g`!-WG}r`UC)s&aNBl*G7}^h$;Qd<#uWzc zP;-)vyQU(~%^BxY8Hr@V=?MXmjcIn@V%8TcOalb&G-20*nhfECjNJ4+ev}bzO-P0Y zvv_HgE`Hgnc_&c0DW!2{jwBtJIZkfeW;I@t21Oz1ALvJEs#K)N6kQ45rLVAUm#m;E0o~RRoO#`VOT+^)Vg;Xl$%d)JKb+Ahz5j>JIBl>NK`zw#&Keod> zN&AhtLVOs-dgDzGy7(X~-Wq6ML>G?t7usKMa{D}-$B<(UfE-Jr_=wbBft3*lMO-@* z=zzDDhu$bw8em=|{;|DXZBq~jLCJErWo4lQFI&q_6*J|_;&*r1u6+6SPVqZyS+uLa z`*!uhuhw=!cPwR*Qxe(*%$vYGq&8_gxJC3IJr_VS8trKQ`LhxJY*#MZMP!-o_q4~$J;O8R#vvH9PO`OP(aTM7VvpuF|1Q65KrFa zSW5-wzlkR;W6dTrC#gl+i`A;VfFX&7(Gp{m#eVQ-+N@lp`bA;8a7qr8ZV7r=d8&OS z6BRg~l4PoktB=8hqWJ@&X&GiW}=DM|`^ z{ez!=Qi7j6B^CeWoy(tzPndrY$$pkGUp7pdEHwaG+dB#j!?ck2pc>{YW|}Wb4QA>) z*3(wVd8Us7{Lp&*T-DnYZYhxMzQeMhTkEOMvMAZmZi}*?9TxsX@8NyKhvj;&P8vx3$Am)k zhx|At!N~pNRZAW?EV$9Fnt=;oO&brsOI_i3;eGKdj_(zY*A>DG_0&nvuo=9b-=34Y zm`lr~XGDMV-%t$rp_~-X>$}S9yGr+R^|`E$7d?;A@aGt}tJ3{exb}2cIV&8W1gG~j znfSED>yG`KasSe{2qkO17JNS9^?cL^A9^04;m^^|N4z~IY>{@dTHgP=U0YZrZ;yUI zN!lr31qHFksJ)CL`9yG4)sMQ=SSt!v1OAH(`}6#AKbtf!A^#-|$D z(D4KNN75v!WGuoWvvTg1uVBnkk2V|iK>y17_!$>iLt`o*=LA>FvB%^n zk(a|tL+L(x+oQrC*kcGg5W(yIM12dvF}dFM6D&tk!^)DnE~(D{@O>JiOBOvZ#)#M7 z|2Oo!N5vHOn3Mzh0&K->bzg|t-R(;?=+j&kE+Nx5?Hj4S3;rLqhdG)7O8>fSg7`n> zX)>Pfl6u0g7emTroW#|;W6?4$BeBw?3X=h|0cnW`agSjn$A=)|jf6xxR>kvt@kZn|&-eudAd%Bvz+@LRV1=j>)eMD~n&wx}%^gsDfN1^zZIYBxv>Xp#fSg{i;enSZ*9^zf-KUYBiN%0533+u?O zlzbQ{cQ#m38dQ}db@%1sLSUf5|H%F7U0~5DZt5sRwP)^Qc~8G*xbl?pw^P8qXT6Z* zA$1C`SI9=KJ?BZU*E>SzptAUI?h1WbmLr(4!Hk<^AW+DbT`2@Fa;2XBYmU{B=|YURX%8fnz=5m?`V z_5^3XAUA}Lw;sAEqcBxXJ{gFLVY3O&2k`+AAP2!%;G9VjSGr=&s18N&IkNwv3}pf_ zI@WLkBxNK=p)m3_CWTh~DDHy~n_3-PI^`FZG*_u&HzuE$+@ZWWmz`FOQ-*!t&Yar6 z{kC2CSNr#8LV2sjzRGO1`XC|kQR!4q=npfj+}BJ-4u&R zuK5W0Ue91VkFXue{3FUd)O`hd>{jTp@9usgw|10?ht8g*c|lp|yjMWy?TB@&CEgXA zF9KOe7&3-3*`OR&4mYrA{2w;0K{?E(E$sT)q#RGbkU8bIRclaZ+57SN`SJ02dGVG{@!;vx$MO>5^7G>o^2~<(__(~h zxOn2Mtb3sr=KymSXjTN6wU9QA?q)Q+ zOe*5>0pk0^J!$w*c%~qID%$W54eK#hSuX$Da^O)@J7}%ZnQmo`lTV&n(-W zo;rS5cx74Z?)0(g!^4WF5HIi;>@+6B3y*9#gkH80-vf4t!)V|4w3~Pr_7*GP?gASQ zz3LZ&My0h>!`CHBLW)^E3C_g<8|0Ste1ZW*pGl6P;Da) z;CM$LuHfF)DwzQLXPs=VASUe1u`w@FsoN{T8^4^|3gb8c}rD4)y&2dm5%Xq<# z2&fQfjRa*KS1)qCA9+adO$cTy1VL+x+0fs!p^ty;{Gl{VY&36TA1Z?^eG@lJThTXn zIwLJE=imc~%Wo#6xCVg?fS6orP8Kf>t5*ioU;q0xgWvPu||DTa83I64SMW+ZJ2%?}HvaE6wc zm(Zy6mMO08asZ!KN&c60OF zKTTfT!rX%M<6}bRD`)2U#V2?#V3qW;wGe$ifY;SR`1i4=pB8wo3jzLa4b=xP|$O_VllfXFPu zP73H@)g@tI)Sw>W;nJxi$~RY=o3AqOBS)AweN(gp38wpu=w_ZxoKJp0^Y zm-DV`O0rtA@c)uV*YnQv9-iI&y9S?Lg?WXK*%as1h(#@LG*s-Z&7L~GWkOc-_$fKH z`zspXpf%Nd?5a)Bx9K!Gy`~N0r_*TpxH-_cftk=dATBLzP0-i>c-$bAy{j>UV3@1x z)NC+T#f8;!>8{313~PL&dDbKIT+X{SPMXj(etgq}No!oryDUCGtND$_yB#yUTCtzT ztT}5!3ys;{iUvMra*y>!`>@Q*2;svsB;bqZ4?inC6IJ? zCM>&943XSPvV@SpqoT=X9V{}UjFOlMuKw8dKHfg?BSkI>Q{%DYO;ZoY98p@Q&MqI7 z(hwP)oR=fA^0`&h%ZDar;BJ+ld}5w-v8!A4%5FAS*(H}1MMY)~2-6#!3zL#27Z(i* zjq-_eHu$fZFj3vZm;+53=D-mY&`&5f6&Q37-D_bC!)-;rtOJe#LZDD@niYu9cMh%&2sz-vL}w}2&B;}# zb>TO@wTKS^<%a|O@DX)WaC9~}B50u~I+qE~&f-)-bQTLeJz-V=&8}yFXIDf#y-|NBO(C-aTv%b6>4c>a0i7v+CmdkwujSp31;pMr*>Z}MLB z%>mKP0)^=VvD6<|fS~ zgqPP=Pg~Y|pOoaLR;QBx*<|Ty_+($jqJ||A_6ZYpdM&~tV4vvph=QiT`vmdH{Qa=Xjqc7tETbG#3|@a*H3IsvLB~c ze8EAAwYUc?flDAa8b|7LVI>)jL$PWFK{V28fs;=jz}#Aq2|>exhxPaO_JqlJAPdwv zb0sM0TPfJPYR#f1hCombkX4w&P$y%N^pIP*utoQspLMvTd2V@W*(}e8hW~L6HtvtC%f{Q23lpI^SL zxoLT8bF;X9{%b2&zdmo?>#JA3KJURZP0eS|v^1Sj=b~J^!JKtI*rl#Qfhq;`f)O=H zBcw{*mgOXR?$`C)hM89dj}ZFVv-rl%%vPW@?V$n)6T(AdW5pYiF9Opqj|&ZnjSUHp zAzYX+RlFg7u7y{pQ2!Jrj~l!O@|lO&2pV%JhIt%l%Xe<%MfR<}Bv#_^Y8!Yptqd=e z0(E8b9Q6VOe_mJ}R8%|@f(Y2Ks)WFah=-TzB(H`s!l~4GWS_QQW6`}29w{9^zDE8) z@sNDmQnR<;XZ|1due^$C72gH8bPNDpbKy3eV4z`@(*}@wTeWc+Mt-#LAa28n(*Y?h zESm{e>FH0F9Qkz7qEC;o*EK^rI+p%<-P-qCx$7|Sd=mAO&dfz1>kS081i5U(0=Ib6 zqa}(Q79M1Y3S_-sXpxaFgx&KzdtI%%EkZ9AAe%--r(xGsrAtlLRi1)_pY2SZTeuyz{-sE%JsmK)bt6;m6O||s^%6I#AnAC zPb8eJOu08#)+8<}*mCmNo8Di!fXGtIjAp3tx~KH zQ%1+dL`8xz^>8u>VJysntSjQYeb8f~EEoiC%z-(N;1NSr_ML_ap$zG^0|G=W5%EHr zIQ{{G1N$V@0B{`ZTzD=mV7TXixG_&HS@`t4c~38FdU9-ZsQU;X(^C!iJ~w~!`qF(Jd2WYw&2m=-j2?3yWKW~ZbLjWD?k932onCY1!G zSUbny(@8$K1HnHc0t=!}Bls-VJq$93sSylSTV6<{$?{%9l2wT9xJX*61qG3cf&!Tk z6&W}(Xr!;VtFxM`M^D3s1w*$(ZC8RGOI$eec8rVjA#+1oN;E97$R8j!l^#iOop-o0 zcU`*s=m!?R@JnmswSD_PZdh>T^t2VpqnFoCYaOjkYLq%NQ#Za@AK-JMU&Li)>(5CS zm5_SuiRPgJ?-R-#3*QG&0q+vGxVk|mtr~@Kr}runb`3X1m8@J zVN}Zrsuy71=qNvGCzCgUE!5|ZB~5JmPJM3W_v=14E-A;_aSVn$W07RwHuW9Qy8 ze{l4luSxDouzcj!FmY}>-UaX4`L1SwyalIpI95Djp& zbm8%wi?f^mc%&jD^gfG>Jxvg~U6E#q7bOY?pHHi4ugO{D<-@j_hyD-e%v= zM1!a^-{f^>O3mV{kc|fjQN-VoCd(<<%@q|RsF=#%S$|siJ9?#yzbmli?+SbHcLfvy zDc6R-0~q|>zyVAc5H&E$&)3t##YqTY0Xl<~zXO3)**gnWp;(1o+#M*b%H74!+PHs7 zRc+>&mf!<{Cl}^#Dt}1Ve{pd34Dab7dFd0R=BlcxlN@x$fx7TP>HV@QhgX`E^6C-s z_h!VK3@);Ma9~&@?|Y-PREp9*hFjb~VUY=8;z0a(r*qB+ppyaMU$c1_LeN5~K=s?H zg}18!%{=&(P{0Mt?>oL$Ve%o#h`*obK(B!=PLwl(gpqo+&s@}q032P1k1c~JN|Wb! z8Xh^L^O!ZGa81#fCnr@@Oe(Ibl9pxGdcH(x+I_s;T%3rM!bGBbp>tNFZ@wk=;;C0( zJ~Cy0mHAg`PHA$X``-QsmDgCUt}-`oiqw31=Y!|QZ>}4hTNpkdIHQ8Krc5By1tCyc zC3MN~3`2eXd0<$TD;bp>z3G?K9#47ygEtHmnzw;ly{pg0P!QM?6j zB-22;HN62*V=$h*vZ_!dvy*GqtereG+cVNR(6jp3F=-Y1ensHydROf-Svxjrg<|Am zC~lP;F^1$PmuJfEhnQu!t8={v2s7N)B*f>Vokren{7lPL&om0LQzYaE2T?37^8O3x z?~8H8ln1gv2g_E9=iCOaDBWxuUjpPDq3!a5p!q+y>SVtM-OIBkPIWiVtU-FEqICte z^+tzBUfVsfvZ7>CMWwj4Xl&%bu*Br0gU6)YUyoIhKfKv|V99-~sb=ED8M6wDaL5ad z(ke;I*LfE1K;XnJL+*`b4Z=apCrCsAzvtu<#qjQaMrSqB&kF(obi={$Y78Wu!VO1F zU)OcPVS#5J?%z<}u;uK;jPX_SKa}m*{LiQ6u9yisi3JI!G#cA^81g~dFL4UG3Klec z$g)@>+LfP&Y0SYT2N8nkcG!Juw0&;pVrYQNT(65^bRdOJz3Mc*xWU{KgJ3_u>?;s=Ee*fWX{MmXBQ5QW0Y z(ZkKr+sQj9#7%49R`1C0Lt&g^jW#B5jc0c)>1Ui%8WGR&(tK}jS~zKCn)q24X6jt& zFjr1Op~(SBld)?t7%GAuXc_ZG+XB=Q7b~*Y@T2ZbQGfS@RhS@UB=*t6h&cmR7@<*N zbmm6ryc*9qGyR*&w=C%GFH*5ShA73~D?cj7mDE>Ih~vQmfrliFP#fnqV`!bP1V~fV zyRZ6FH5cP%u$T#28(0h4$2zV`Lo9X48=$)m77+i5xOylzKxI{l3z!`mPiR0S9K#Y> zeFO`^SZKyj|^HCq*l3*@_Vfqem(0Ex2)d3H_c4rb;9r=(_pmSa(FvWv^n> z)jYa-RPt}CvRU`y+y}-M+bnwvUG@P@=@m<&KrPbA?r8PBD^WzUZ@HqXgoI7#ioH-MV=V36>cB6P$ibC7OKOkEfOjZPU1Tz+M zaU6g#z~&}8Yas)L;DjV8Ps;c5q`a)e4xk_<_R_0s$RgLED=6JSk=V-Wxdocl_=v%y zj&lLaCf9rF&RAFhAW+a^VFR*_#s}G8w{_ox>Wr5y%@BK77IUM zanuSzo&fYzg zuus3oQvB#CEM86%>B?!8)Mhak)1Zh~Sza~5a32tzZ8_)N?p(^l9!M=km()HL5*wIv z-q#+8pQH8)kV7TzuI`B14|dQ%LAk*XYAqWbBwF>5#1{%L!kQbloSB$8zVhr**}p|v zwqhpC4Y$XSO^ag-%)1^)FQj>i1^o`g*g&sf8lc9o2O zU>nKsgVSu-K3JDMa!0uP`nqdrBSPb&wh-U_MGC>9M1P=+as2o~v1@>n^FWWvBjs*^ z$Rp!c{PeZ+vz`5%9Q~YU6ArhAEzC$;IPw-g$Bo6Oc~@u9w4p<%1;G~zIK|>6k4_k8sG654g7{RdtXE1zf);RH61HXryX@|?HOBG^C% zy9e_DfF(0*i@@6ldCh0bmEB?@Y}Z?)Ra4kX&DwfpqlU7<)WB=1Q2Q)Dqw>^KA3}VI zlilo|2Nm&Vtjj$N*GmgoLL{C4=nVVt!tdXD;)&nCd0|Rj-IOV_>ZF!yZ@hW!)8D;u zZOi60YqvbO=KcrJJ#Zo2xKW%u$k4o?+<^d!WM{bH*!5B)OnkkajLt^TNlWx>h?iB` zXgy6K8i8bllSyWS%^>CHp_7@zkkl!&df?QYsZ0#2U}pm#T(g+wWIEQ$Kfx#Igv4j8 zVF~Y+VIsMkWMP;>kWZ2Q^HKe^KN8<0?pwKc8DDEu|KCu*LCAXwE1c6k(q9-!sEz?3 zjU1n#$;7xrUWSLTJjal!QAYWCK-3478ANbr4|g7Cl<_#DYM9aZfvrio8~t`*dDRUL z-&By&ah12d5OgH~>!F`ejke)BYvDr&(3o5G5_EL{TL`kxBYNjj=s9vqR9^s{0Ii@9 zfnDGV6BaY->=zO25kUk4miZ*Q=W~FV-#E80H=q<)t4*vVYy9Ml@fGdQY~Axz_<{xd z*i+J~R_2_TH#Ba{n7Bn7*33q>jlz3$o6sa?N{Ru#gN3zEh4C=n>P!qn1TdtIk=uYX zmWoC|*aPqKDtA&CX_|sWV(Y*Q1en_7JsznJ|GN}b^UdIg|N8csTWvL};PG;n&)ZrsjTT@01O^hF!S)aV7c3hRC)_Gdq?6rK(XbcjtUiu4^ z=N`gxS2Z>)gyt9o7)_%C6oOj>{ScvwVXT5dz~V#7a7Y03@L>@8v;GtlmNYS{Nf6h4 zBj+cP5KSDP9(H;6CC%fS*%Jz<&7V>Ftx_beRKDKy*whnJ%YF5OqD}FmvhRIDvw7*q z;`+MWdy;`0TEluO5FhE#p za`b}NgPSXDTgxzncdb(ET)}8$3Ro)3DkUL5giZD-$*TGq`P zkyv0#D~Jnc4{g2{G;CW#D>)sgXUGWbK|g4|mOcemo+lY3F=Ygapb&eBb|03amWYDo zXdyXD7smdku&y^PwB1^w$9okfKYz%6g9i2s^AGbf;tp&~jE~FEN_4HaQ^Js1%-1onrTu?_G5eA`2K;Jl@BgY z%-FVI*^&Dvrlb^?jvfswAnI$gq`^FTU?y>|vcwt2ipI)OgAJ2qmLOHojf%(fm4qTs zBh80#fad^bM?@R;V6ZyodyUQ|V#=%pu*Y5RLe;@3aj~6elwaagRz6&@Z))C*8F{%g zXG+bfODo2{Q0maNEJQ<#!cNPn0PthHhg_3weBPB1+MPNhqh0G}_FYskhW z*CI-A#rs(Eprh&&)l!>IsUTt#%2)7ZO(kjKZ%z1Zob-tMCOhFn#4YHqDUhVNhg~@+#6p7?V4v&f*91ErK zpn-$jTu3Z$Gu=Gurz%n-Q~3tCbrhL&ncQS zx1eC|?Ba2gYceu$t8Ph|Wy)IQtaGVLORY^zoR*SS=c037m~EPsvNR(mX56@#m<(2L z8a_NVWyG+t>bhu>MrdCGpAvyR0I{;o9kn+WW^H+NVU6|n4y&JM8H(~udmZZ+C*A3V-aoNM= zC+@91KJD$(xeN8W+Ps2Uv!$j7>xPWnzC0;o+dW0AVPQ4#+~zm_n;n^CN-CU~oMPDv ztFRZI<9h+|^I&sHk`(L(xOG9@O&&WqJxSXQN+yD7fUf%vTft({EQK&F1Ps^}q^89s zRy{@8x#|P76;2}>fBY)i3b`|8UTgu8pnk%C zm=)fm{5)*mLE@3FqR;S;Rz9{9JS z{YYLODp@=8N8>Yss!Oi;^?9^X_{==3Va4@)b;5(F5_OTcPc###}qy2oqcXBwaRP6Ns5a6$KIM^CH z@EL$_^c6>zTBLgT>Lq_|IVckK79Mq)pc9f zZP>nJ{rU$vM!9JBGH;jUcF_OXk=ymeptr=X4+asEcLWmk5>LoB?>%*D@7_}n@5{;W z_gUEZzl0{_^3$(wI}v}*gtMVU(Zkh$#Cpk15h10M!kOo2TOwWN;A%As?l zD-jJL4~Kz4z*}4{M~>`JWOBLO(+@ekdR!U;x!j3eN0;+@u)Ekv)MG!lk1B=j%17d1 zo7*Qu6}rjBxry?a=KdSSbrG?vCZcj)FXVZ!K8S^UEZQ_&6}r(}acNs`VVasf&nih% zv*+DOl2*^$Vn^o;k2W1RvUut4z{;|EmN}0_Bu*MOJSJ}B{N?x8gcY?+Z8WSyYcnus zF9V0c0&=0Lg0#C9h+zboFfgE>pAQnbStJf54O5p=4|$SBD%LYbwweo%J-FHcvbGC#mN&=ODCRnm{aZ-m^dsZW5t-5A+g~hDb+EinemyE zT?~d<`P1*Gxu$-+g*ghKet1I`=BCQRAmfs?QX3cLF({XCRS^;F+9Dyt^=cXkPk2v! zVHIUWJ~V!>!e!HvE2+C5B-K*|V>&fe65G1?F~@et;-QI?`emk@jw>g`@W16Wq+M{B zS{vj$IN3irYSF8X>*_l-W9FsKxsUc{75=#dJp1J8qfYb|d)*;dU%Vw(pDOc`ysFr^ zx28|uFFC%we5E+d{NdW=%h$rQbi`>b;BRDJKB9cZkjc{K=KfT@{Q5v*11p06A#k*1=N}c1zE+Z1v*3 z@&P$x@aV$Qbe*?*xZ9Q__NMZ@zs_ZR*rMHeYaN>_g9qoPq)sB*6UdgXd&b#!UqgOt zmW5Wog#FhanPbPB#u>3{ahJAA&+aG_! zp?}e#mAhZ9UR4_wy?ojHaV-T+Cs&t_NiHoMoivRW5}h?on0Ghy01{OPZgNDj09(13 zDiEVx<^f$Ok`DIw=ns5#f*W(QBwtVkVvDjW z#H5T2hi%JJ*H2@Da^8JuL(}%Qtdy~tnW&<8IzF~pD;Gvp>4*5Ma~YcGm|H`E~`nI;p*UgZ}yC~<*6|V85s#NsjPl%{u--`g6dz|5KQ%8t=zi2?Y)p2oA#8SPW>aRtrpiHcXQo%~EFD`SYbK2|P0Tl} zo)I2%-?G@`j3xOKS7%GCU;d%{_r6xmcGkqk)|REFfSJO&!#_<@9A9^Frcn-D24yRL z!h9pU8cuu!v$enK;4eUeLkThGRoPPy(bLq1W5dVtRkwK6!6sUDqsNVt;t`Q)t;?Q7jSK#G~RV@CpA}oFQA$NZ!?}ZSTL|_TiF`K3ei2>TF4*;y&{=cJ+Roh%`oPg?GiBViC&z=W(BK&T+xTTG7S)qv-N(TN{(_ z!wE+HT+{hDJ13ooUy*(J8V{FmD_;v=6Ol1wyD2vQJAv@LTdVbP=Wu-SV~MyfHarw+|T?xwqidCsP|)(7Lqe-zxv_f2ugPb^grC z5w)vl%sMP%xRr1PF~zL&u~86zH+0OHq4+cKfALMNr%w4VRxGq*4DW!Ol@X^{j&xav zV|B*m5zi#+;E4&B(4dMauEHA&qE}X{iC63=t zE4)Yj1VH!a`}{q;zeW1M&imk1bmf|Bcu(EGcwce@5z=WNlriId_H$0>FWOz* zc-YkcpxyeXqy92pzq&uEepgHVSaEjo_q1F8HVM+GKJU*!f3d!Shq}M1zyIL%Z)#=LW9R+poj+N|r#JpP+-nzq^jCkOZ+~e%=zX-akwO?=a<@_G~eJ%4}r!vR!A4F=cn@WNxFjpz^EEvr`P$+rja1gCavijUG%$O^!>CPaiQXGImgGXhbMNQuXiW z5n>F%1=5|lyQ3Dbptsq+)<$(-Dv$#jzEK=$Ft z9Q4eg9??#Ceo;+zp3&eTQ63d{ovY}gv7M#3e^b((;iBAC9;GdFY)Z0QkaBMDc43iL zop*=An6c4ir4zD7C&k5u@mZT(T{^vNdSQOnqzRMKOiANMkB>`?OH7C#HY60GU~Om6 z%kB&Y^_juDnbV*ibNU-IEH>Iq_f74cr&|iLO!v(v?9Y48S^u}IpnDDUS`QAi9-Iz! zt%vcD2Uj2xYNN24d8=z8p&xTY`XJ_}okL-F;hO7cV2DNzD#>YXnlrnq zGA}nPE8enFRxE2;-Mo6?g4vC88mCRIoK-ceq&T-CuOcfaD<^w`DK&0<{P@1B#{Vu? z&Hu$Z`roap9!u=!=(|{AU2E;<&+cZe{jXQvoz@`u#lX%Vw6EZt33oJsM$swucYeAg zN``p@b1}B^C-GY~}$-cpStK7{%dF zT(k4k+vaOK8s9>d;S{cy#%DKve9PZ0lp!ANMYmTXQNYPW17*CP<3Z z{Dd+5f&ad$$q*F{<Bl#Hl%K6$~Fh>+gD4owz0?cC&mY@PGBy4sOZdi}9*U`3pcq+m=SJXv7xI|}MbF+x?<*U4S?hX*Y>oHZlPc_!mx$IS33pCy ze)~0bHPUO=wI~U9nU4XkGDcSR>f4*Gb&%cCKcsxi{)pxnM9`Lixf(uTv8jO#Eq>bz z%g#3oYD6Y2BU}8Jw@*EJ`mIK_W*SO#4>(%aj%1A!ORFBc&#D6LnLmkFNw!sr`2)@S zs%;fwyj#|zXIJzu2(n}(2!fgt%LjITvM^1=CX;R zz;v{pZ)U1||IJLIg4D;3AI(?IO6LN>K^VYC&KIou-yEe%7}uOrepH{{0Y{ zPKX>FIXG$%vh79qM<5=MpR*s(adbDjyFi8qD|d!J*to;v7Gx+^je>|?k?J5;Rr7%F zMsQ)TC!ZAexjg%%d9Ir#|DhMy3rCMVckxI`37c42S~BTxVyouL?QQZsw}#1exA%)5 zy|};jz>6;)s6F`n_IVYxW%c!CwUu*~vORlf{8x2;r~eu8dcw6n7*CxrLBjo+p5w=7 zhznKOG}Zj?S$qlF`SLXG$Km| z`&wM2o^j$LKD(l@9_QiYNQ>M%pTYkGfpEgZWqr|$Gv~j& zwWwmx^V2r`*P4#b_{{~?FDN&%wZ7zJ0`XKz&j0#-`QWj`CkV|D9?^eNtEWZ z^f=^63ydYd2PRws(LAQ{6+8uGwszBjkiuOJ2n*SsaKXbHJ&aL<29f+X2m$}0Skz&A zAQUt_G2p)DBbAyP#LW%wr=8D9T%06}x0R&Di8<%f-WNCH@s+e4NsjLA?v6=2(ymzA zb-4I{->$CTuV4LkyPdZ@8#DtD6$d_pbgEl=tGClzcb-WX!K!^2`pKkf^8#^ugA(Jh z@cXTBHWjziuh@1amd3I37RGS^gxIi+KrB(vEOi*2nS@~^Pb1`e?ap@#6BnrfVG%uL z%(b-%osVrh*QI~lo>NsL@9J=80hZRjY_Fx_Ec6z32=;sH z?m@lPL@@LdSus3(8`$OVw|Xp8Vj9Hl+6MMcJA0?WynyD830N;5S?A7~VzVM-H*#I7 z!w73%7~>;{chBLZFq$&W9d9B<yLRYGD04+~i#~Rk!Cz|D$}_Aa2zzVgcQ}24Uhsaz^Q-)kCo@7^rV5d->lQ$K* zC{Dm3#SnYH7j40?cnY2)-DQMdil-R!Dq%rjR4f?KKlfYGe&vITPiuyjhKnCGnFoiD z9q8!#hP1!k)p6k1aP#0M@q_Tvp*5dYC=iIDcHu9;A&KLFh?6d04WVxZ4h9FDxCDn^ zDIQY(Y0^T8tiV0hO+uV3#A$)M3kV#tn{+K)O_H514hRFn8;j#9hYwt%*4 z)c(7n8JO)@`VSQ``j3cRc+Y09*!G`M;sJH5U?G9LLYn2SN$RNU+nTh$qfW(4{Bx5z zN*w_fML6J=fjJ-?(0}ZA!G+HO^*@{7KmlDR6v*Nnsj@BoN3dn^9_Tp;Ul*CbWv7vj zI(t*X`;T*l?^jqNn1%)Q^K?P593r+x4@z;L9p;S;0)38`f&CLjZX?)zzI4$G)LR=iPNpDc|wG2567gRNbtuqOGrdxkx9?7F-yZaY<`w*>;PV-_Q(z9iYDBSL<@M!OFZ)&1-VWd{c8> zHxPSAd%?(an_BCQwGdQYgw5z$TPM!3$4*3lyZ8X>ZoSz(2LEQO6T`sgSwB}RAc`Ty z^}$MK!C-E2uI7dlL#8?%%>n0abvgnME)~QDg(nh2X3ODH^i4#2vd8_)5zA&%TDZ4~SuDSjx05AEi;G=H)Z#*QEr$J|^M zXX$h6ympQJ%4_S^Ut8Hei7+m)PD2CTkuC`};B^}%txgZ45M(fA=WF;CNQHqXC76R9 zSQ&WlR=^DQV5pN|j`m=vlVDE0VK_r;z(-Mg&h}uSi3D@811kexM|HZ|gP~4>x!HrE zPJ+4jhS9iK+Vi#t11%(6eC)u=EOq*-Fwu5A%TSKm^Xmiqi*QDhq=7$)&WJUCTAhj0 zsyy^B!X>~W0P_Uwk_x+|!fpXp#$jG|U}pfMIz4*Ui6!`%@Thi*{5Wo~+6zb?hP;J5 z_1kBSY`NsUq~l)kP>Zrr@@Vc@jG`bsTZBh78{`uZ3TQ9LJYO8PKQDqqM$|1~_bbcr z4_mWDX=V4fD9avQ!dA0YOO)koHU3dn;3w_ny3S*|^Pq8};7YN*heqG{XG1)M8V7CfvrRQG#9NP-IIu*y9g{(C!K)Ub=XaQ51rPTsoe$J z2Fk|_q7Y5@BJHl5f6$J)C>@hdP(OrM@Xr5O-T`5a9_-`JUeS)csLSlArt`BKKaCJ# z3WO(V57vgHSgb%oP+&;|{*thEkT}}r`^1&vYC>MK@%D>yI@Q&MzeWf(1yM9!+mwx} z2pR$)P%@ANwL@VT1?tnyk2SJ+IrXev9t(JP-!y{$DfqVwBJZE%Zt3F5+ZTB+Z+@x~ z%`4DX(Wb9d2D40MeB2!*bof@IoPPU7-fc7NTf|i$K_=k)FLi9-UyJD4IByVrO66}M z4wMlXnM*pjpE*QNM7Cf_DCX2<_I(&^$V4&eNC3-|7SSl#%Qa&+D~jE` zCm5IRHX?|lMJvQf*~>ppp-OENw`lLseDCx?cG2mb|Hm$ReKP#en#DbRJNAqu_?SQe zddrEi3Xv$%9hx5Qg@bwTdS53*nIf1P|iiGLLoS|CeIk8j{7UUj; zif&z%*WO-A)wRoOQNFuQC)iqdj~S%%oc*N8T-GGxuFg#G@pSI*+FvINNWn#878DGw zfetSONe&4k6`VWbumr)i24Se!sT((BVNuIB9g=iwn4jOU4($*>KRo)TWl@K4qup;v z_hafySO1(4Q!!A07dVE5jG~e56FrrsS)fS3xr}@EBVHKLFCeT2`1|@8J)FH=y;aO8 zaJL=If`F40MAig^U@z=$FZJ`2*Qz+$q9`6P&m7_>E&2m>;0`!i`E`hiHNX*y3>i2= zh)p=kLV+Iwyae?33G@r}ba!#S1CB_vZo$mRRhdC#{a_uz+b>yh%b+m>vRybLisL@Q z?e?pFL;m>3A$}OMX`Q}$t@a|Y)n0&BEPAkmq}O)DbVN!Yi8ne%NbgA?t3a&#J<34q zDma@At_UgtNjsCN5CX@CIf&9LO0iPN&P(qpIrOWs%MU0Od{OReX^n*Qi zORJQ#Q|z&&>Qh={w(aPjqUu4f9FV)jg41>L0JEp~ofWr^Vd4$5uel#^)b}V$I2r{X z=#&Q1$uXcmLgsi<)ENZsfP`L8ILA9^5fNGwAEBc^hCd_zL=WnL6)8&x*r{b4gt`@=5J4(09eMWQ#y`asT3j7+VaLRb7!essSve9$ zCyY)?jERqlkBc2KYQ(7Mk*f4xRjWDZ1Xt$jfxQ7yzsi7G5&_uy3DDsW(UlLxDn1%q zKQ#D_2%0?aDdZhqa%SbOii%y8RXZyxc2?!gotuL{@tE>P9ZS0P!wi-*Lp)r^l4o=% zTa*OlO+5HuOGg;HC_Tw8vZGXRcSXhSDpazwK0CL*J~zAGe3K>BDR0)HhC1;uRk57C zpp1JFUz9g*eakK?nNr>s{71T%?lHEm1nW4jGTj#(WcZNb!-lFuYO!$|*dKXx)PZ%iGqC^BV6u+?#ULsV-1XRr!k*3>x;;EjW(4?# zAWvtN*9Z@XH$@!O1N>iaZ`@2FQVYig8;gzq3sUbR`4G4m%Mu@y>#xRz}Z z*P53qi_A+w)4J<3lH|@6p(C@69!?0!L*{yBT51I?#L_%yJ`S27_lr`UG*e0II4^!7)phJQ2Z~?dE$UZSJ-3>%gD?!-zmUiaCb7mlu&EI!7xZXTK zye`re24~Sl5yl z)9G~uE-pxnibz#1?k-4C2k$itVjk{JG`&CveJ4%`pAygu13?p;m2?$H^8^(^^LI?% zCl%69^MA2n>cmYA9_ zT<*+OmR#q!`M5|j9K6VF2vOKY=IkgsAZ__9ZznIwfFq-Ve}N^K-V>2wg`$bYS>scZ znJ~A0&g_}fr__{}7FSQK&d(iRlvR{wO3qBljE{>R5fvE`HZXt^3!sZSVKf`<3*w`( zIOsv0YfImueeaHFq(vGYZhr~$Oa2xpI=*rhHe?ZGVyQX+hYDKb{t)=+4ykyLCz%kYML}(@H;WTKjLsB5o+=x zu~aNwr1Y13@y&dC5xb7}A+KX6@V=UVBHR?h1Gj7JTo<)kt%KIVhpvm38Zn&RwVKb# z$JhyL&Ft*aql61&j!oiu8(c`Thm&TJ`7~khSMfZ)5mp0$i-ddY4b88JVG{s;VuY|O z=ez@~20SBq<_c)_5l~#rMZ!Y}j{R*PQ+#aoF*21=k^blxRw2VxkN8uB6ywPVK(=I| z$lnw~TMQcH5X6Q+rE;_PW=4{MSO@x?nNxiAkFFHJS?6=zRf)-&COg@!d? z{)nqZ_GTEDAj>Ci$+#-@QlnqM_f7emEo z%~_fu?YFMBa0A5VBKk8Bl2T-X3J(o|{6Y?c_7OG6Ob3 z4VRhA{^l!3Dk~3P!K+8Alw){L@m<8e!pQJG=t6}cVT5UD5Jm_?g}4bM*5{EDB`Di^ zAr6H3f$1Q+4-h>l?~>db;s1xZ_kfP-NZN*P-!!9$MmeXEG>9MpN+g3wA`2U^Kp>RJ zAP^ZOK!}_%2$O@!IDlqH2i7)duD+-G-jPPqV87pazyF-y zyCBq4(_LL%U0qdOU4=UUsaEUHPH)!EPj-RrhM%`eFR*HMT08DG|4r@AmZq3)*YN*qx6UXo>8z5VmLWdeQ_&i zVa%de6y}soA>=_+?UzflCZE?f1EKy~e%Zi@`racWjsW#vIQ_OT<*jmeHbmtQYHvU#Z9rcO%$e z)Xq(3J+&97vmUI+bnQjfbGmkx@PsbmM)jjy;c1fo4o}pC)5UCORm|s?~r0`LeS8&IH+4dqI0)8WCz5(Camo z&@((SHEvDlM--&3u|oJlEk+C(e4muHnQL|o{OWu!Oy!+KI4?nS6-mxfs|DG}z>j{| zIWd+M;t%2vcM_D3P~cFo3-;extoASTP4_QXO`({#JMBsGT0(H(@&z34xO^FpE*o6F zKuq#I84v!3B7j2oG2$ZHfYR?;p4jK^*sJU`n0vQ)|KS?k+|-X@rkgK)3}A;bM7l7+ z&fPM(2~(VzuxEl!~Nyx{ZM_^x2b39`)%MK4*YrFa0)TRe(*3Zx{T4Y1vI!q z1@gRaU`~!TIF{~?Js|zbPG4nXq-}N&Hb#T7KsXDgP?fw7z!@GjwBg*)r4{;JaSxn1 zwXF`6jzasqwnkxVgggJI?5BnX+&V$ILe8CDdG zHQapQ?pr|Md6r@tBkuvnx$7Bi(H&+_7;?@Km*b|INuUF8N17p?2o&yflgZ?6;t8U0 zwh=WDkOfLhhdG0sujytFID{8I#2|YQX?vv!HT24_$#@ilzy`qeXp9FxHQkJ3Je;V` z(HQ!8{-`K}@jxNWiTf(#vYKwvd3L&rMjLa86+@a1Mk`m1LMY_!8yvF#hxPRHNu78qB1ZC8lgY$VZ4j zmgh0aYHiOS`0pV7CFhdF*M8i7e7m-VO~wyqL4O$d`PwV8Rk?<)QEiEkSWcx2QG%Pv z7@VA*z=-_2JYKB;7{b8|EKnK2_|F4qD8Rxoww}5eIDr#OLHW^jSg_Gaz{^6TqeeC1 z@*~F~*gnHUH5bCO*2p*Sg(!Ch{gzxtaagIeR9I_qDea&^(s>M0DjRQVdD;Q3cKv!t zk9>CM=1q2xjbd#5daV}KU`E+z&~!(i025B*3@crcUT<)XCd#Q72z6(C3?JKj8khISFwW z5l-`U<#+e-MtYL~?+Bj=c#gf8r#|0$zq{Jh@!s*y9rO0`%F6QJA27cb92pt>d&iKd zDEomL^VU0PoHT#&@yKBF>->}U!I9)IG3XC}$z&d5Yv709OZe}O&lBi#oRgyXnalQW zs37m$p98+Hh-*TpaUAVK>FtV(_5ukT#6>%QXX2uLy|~pS{Qi5izba!Pn)buorB*K6 zn~A@=Y!8tj7+mxd$9{3y-b!5Svb~#F>9QReqFuIExTYtogcjfmpY@{VvV9l5_;rE* zqoV${qtUvv*TuJ8!oS7#x@^B9e&DkGWAS5`?LSE#uG*FRBsZ7sU8EOWws)1RF5A12 zn$&c@N_X+H%k~};oJua>dr7#lbJ3pVnje(jQlLxtKKJOSFTI3!(SJYbEtl>6#XnrO z4-gS(>7t*3QfHU#+4pGQEKhI=zs-oT;;x{^s__W>+G<;($oOQ|Y+YQZp0EaCSi%F=ZtRQu`8?SNT ziH8`f+ju;^#?h3EA29iFEW_k$1J?%=+H`7ziNG#MOxnHde@m~@sq(<7P4@?A^&8H&zvJcG;!Pb! zGU(Zu=6K-~Dt2hvKib3Y(H<_QH-*RZV>A1N$0%X{)y0D~+J7c5cJOau+KFyLdwq|# zzsDXmr69XPR~@FS1ID3OB#>Ug^@uAR&&KWD#P3|T_Z7=swhu*q7m{<0`zes%cyrOd zT59dGeZ2^U)CK%D3Wj&lzW*NZugVCpY6=hiBHv|uGZ9w`F5p9?B$w@R>>HQutq}3! zs-JG+T$k;0#Tu9G6|U*bD#hPj!mk%^yKLVj{_L{-QE{Ei_SeN%T(-Z(bbX}J`m!sc zejYY%|5$v-Wj{Z`E#`tg&@XhosZl>l7s=(iC|#vcm;H1z^r^=EbQeE#3E#ue?;6AR zGW4Lv?O9Tm%YJ%GUM}1F+@qhqlIjw^pLEe>dw&tOVpIN920(VXY9A=IbJ?CPrMPV0 zj1o1j`q?HebJ>2})p~LL;^`*(MFSdg{o;BPncNuWd-3mKeiEO?k9!aX>v}N+bfiL^p;k@d5C%a$-d|Fs&C)cpuHOK^hP&qULn2D z;o&3a@VdXkAN|i(CIFr?R-ykQ{4mBH#@kox?LF`Vy76}4`AF?_#5{D!bjP(4JfHAN z_U-?4I4*6GY?%qv!ALwv$@Bp@5=|Iw$S{#xt>=35!-Z?ZT#xVAdh|61L??CYo!+(o ze0#;N%rra_8J9q3CJ*v_UR67K55hwd@q1^FHYrw0|WeKqW-G zS)g_h74YmL;4MOIW)y{+@HN2AB>stn6&!7WJ)jet1<`XmJzWPvD1bRz*{a_VbFej~ zPxgITLsl#HJX_(Y=)Rpg_a8fa(@Ea{GwA;-qD_OGod!Yj9639iuH!$QdtN0y!+Y-6 zv2*`1xtmTHxI6XjM0JC4@|ckiv?-C<$_9j$o@qc(^2s{rMS01rnbFbSbbm9zYC-5c zZb!kH_+6k8TExZElh>wWC{32O(Ws4nZG=Q#Ba~=u!DknRI}%n8^$nWxEk2j#;#DR1 zmOdx`W~TtxkZ%n}M}Mi>P~;L=133plDcIZ}X7{mK_||pyCNe|#QhppZi?|(0b$E&h z7vHI3VSoP}p0glJ9|!$^C5&aWC^vzq_fLB+m0-*h>tOB(lXMuV5saz6AK4)y(DUIRD`WGKgHW)qw-mNI~k<$zhh#{&K9aRxqp`C1k5wW<<6 zHt4>Rua#p=S~SO6(LDR|vGE;F_gEc2C%QL=xz1KLodb={@zeVO495>+*5ik#7_}S9rV*2~q7QoAw=)~8pZiDN4 zLR~>~V7N`U(|By!TgnjL4|E&ekEg4C>h&KTrb$2Lpv58LcZU53 z*;K_Q>ijMS1J<={;yFhw#(haGQ%Gs(T1oOjTVK)eGO;vL}t`r~xhdB-6v!8@~RZ^%#bIq3WP z7vUE^Hgl3Q9ERg(?0vRfhjF6mER0>J=W_gZHsK2n_^I zqmL!(`;yBq8q2Al|GMg@5zHU=gdu*{$GYPRrV&2ZMXBlB0rOwZ%a7?abOpolDXkmJ zj-YZb2c71gihlU{%w9Lvf^-coyX(%9R4AxAzr(*pbT;_inV%ZNTo?arvZffz^dzUV z-Vb1!jMV}1sxx0x_+t5*j?(*aTGPfb*V)TW$3j0Hc|W+@_XC(FIK%prH}J83GHAH2Nk5Q1@&?|I17=0je(KI+*t5Xd)p?wUD5#b+mT*g- zSMB&F^Wrf4jMQO%t1Z!CoYuW@Ki7q~o8X+M4V79F&c;}PX@c_zz+6L)!URU|j-ay& z20yYi4(qI+HHNJcRvPqj0b6@Ry2j~6{i^1#-op>bwh`2>-ZsWl&3AC6Sl3<$PqI|M zbKql=ZA|zPO%1#pY8icZZ|zOFLR|;Dy}JSPC}MN?z2NiQrX(1wpKilDV0Q8OIrlRG z{Ui|%h!!H7?mC;oaijJ=y#EJ{{YM09eLMB(JU@TvXCIlC0mfK2VIMnb=v60)P}IMc zg@+PEgDQgtW2ygIcyi?k;#(1S^XUI8R21j3$Z211Z3J^2kQ~P8Ormv&;Qj0UTxVnX z+#Na;;Xu1*B!_{&9CN?U_}puu>4~lD+6jl<95>!>8V%eC-emqw+s|pT4LV|dKMB+i zQAS`5SBCd-8{uonH*fTj;Jyn;@R2e18_4lEf`9f89UuHnG^y6|MJ`)JYPWezu5Dhs zpW$2hjZ5I#{kluT;6I%|t{Uqzu*tkZ5%DtO?h?dn9Oe>hC(hP;5@#Fhvjua?<+$iD z*K2DV_fvaa8!CE{&O!YMHZzCe`f4+*hwC#PW2<9$zZ$*+Dv7H&4Y6M87vt9(RW>}HSL=*v?nO0f$xcP27RXRah&B3@jl0q!(vaE z@fBlFj3Jp~wBPY^YUg-S-!#6lpJ`0)Z$mrBOCQU5uMl2KlpOSlyP12z5I&}$x^Xp3 zoABAITis@PjAQie#r3|s<#WeF9~Z}?-!)8ny#t9VU+hV7Jb)dtSPdtzHIQC ze%kYKN@{OP@0(%)JD!j8Gt=+K^mf8mZ~sMDTMy6i(%Y}Iwt73xhC06_r$O5$YhOYz zb>9VE3@|z@#%`d8)P7a_i#S{T9OIX9ntp}%Xzm098RBm6w|^s;>q4Xs0~t~W1A5i@ zMQJQyaTC1u*8ZZ)8EG@{0I%S0zBbfOvchQpO)=U@F3I_NJNo>}kP^VHPLJY!I(_%Q zj_)?=^AG2C&X+n4cO31F#=6eNHN_t=Z*%^GROR$^0Yl@eckAY2pRLa&9pCNC=kkH^ z-QG?5&jL~S`659t!ru5w_=eM`ar{wF`xxzxc>$hiA{I8mp#u8V_naRgulSx%;oq$Q zpMKBrM?0ry>n7jjXE;Bft@tkKLf{$>JC(yWkVT+zA1Bx<;ljOPNq-=mMCuoGamNqL zQ`ajXw~Y2Xblu@-uY;%gm+I{_CO_lRj}u}Z2-pAS%kBp{{Dma)3q^8`B@ak&my`bu>l{z{PkH>dl52V7?%^e z?~8Pe#&Tk7BN(tw6FEWn)!mbD{B%9bS=ZQ$9Ijj+k*f8z!QZq7yq)iLy}hZNKs)*b zhv;)|ASckL(|7CTM8o!aIe~UAC-kwJ$_afeSLY|@Xvm3I^|f?y#`3vvIidIOkQ4ar z@BEqn6Q74x$H22D0`z0cWC1e?#qeR?wPE{Sfeyovs}5Nk1)`cWV;IBg@E zzyN2%AJ*Q0IobrK-rt0M!~4&a-4< zfoDNAmFuJOw`d^Vgd9eDe(kRk-XvjtzSrTQHgg_#$ZPory&Zp3d!3%;_KMza=viYR z$68Q7im%>o$akUv6{+r$p+7+BJLW1If2AgtSNm4|y{`RV5QBiPor8YLsa@9l`9d4W+uuNYTT@hB`1@q<@x_iczhW^!?Q(cV|sNT zv0?1+t>$ye+?VGpIX`JqQRX1)2e;Tu9;>$uOKd)W*o66|3oD);HTL9;vSXcWeJA94 zXkBUPh!>FDZ?}Yc@I+y}ThnVd4KR2?)Yn#yLcEVfz*}*=>&CW{^~~YISll3sc-KaW z9W8hsz8wXQrFBj)SEC00oW% z=yj`Zjev=v-<=db0iXUMV$}fniOvPGk6;16KK%($q+1TzN5_@+2i9^G`cci7zT^7^ ze5wC_S^u3r$6UY*-*KL*{jLd5?WON<7<`9DbOi%kR>`OeLZ9k*;gq;HUMJZpwi|MR z&jbHPuVANJuzIoY*eS*|iRf1G)~Sj*7m7FeW-xQePZFJ!DU-V3)Q~I^i4Wkom463~;9cW8pc%AA z+LubOc?FIx&NIjbjGtn*{!`wq(7pd9^%j1QBOX#5@hbX1pnL28fN{Y8q4%e@Z`vRA zL;VS1f6))eM;orTug%o)(T3~zAQKk8i1>37(8oA~z~S~)5Q zIlhmxB1yi=Zkb~FULT^@%n0BiI(R8d+XU&GfHNiR#nuF!uyHEskXnXMB#|D{@U-t;}L0Yrk|S|d@P=B$eV+XO}@S+ z3V{mBNC}XvQd$NrP{76wr@njQ+s`km!c$MVX}6h&+Yl~~z!ziGLh*)qEzYA~Ag#$$ z3wr617MxGwut(RKMjNsb^@#u_EQff+d+7f=>FC(JVlxz}(Uy>47{vUw@3ixLA7ky} z)Fsk7^Htyi9Z|={aofRhi3BeDfD6&jN9dZ_Stp?hB;pU)kyyb^H4}-r9+4wwdwCIc zynMWn%)psO?#?tK(ZCt`9i2`pP&18oP|E&{bptL~GX0?WzgRV#X2i=x9BHckqiDk9c4eg& zqLYO7pN_{wtl6EWc!0m2Q};+Q=2CoaZ~8f~drnD|V${0^p85Tsj>mQg#$m|Oq-<(f zdWI*{jOm-w`6E6jHjF+bk&jwIxtXDVCAKgjn}fJ0AryuQDbH-!P-)BuSiFb)Djl## z^|KSz=W#&tvl7{Ok*$i3Pgxj;y(krtu8KqEe}8nktTJS;CFE46qmvCJG(l4XN60{p zpIznlozAhfZq4YP3~=@BxX2Jpb?w!FcZ#h=`xy?8_WC#&4qxPGua7O^?O1E{Pw+QM z&O+U~zdnew$-oBF+^7G;v`cd7QeUBgLAMo|QC2DV7 z*Is|8!222E=%?O??$l3-eP_K7o5M$Ocz^U?=R+oVxC$KO*7=O69WD*xu6@9BW^EC4 z^9lW*_5q)UK&ayxABwzCT8mr&Nl4`ai{*i^{!df!R6m>#^!r$x8@%fINCu&P@2{a) zq9=N(uZj-YM3s}E{2{NFbzew}mQ&v!J%q{PDY# z$@P2uj`R02JEX%&pGb(25E9({F^I{{pS|6n-DbXA`>}irXD`0t(3fRWleyw==*vu4 zBYnasPmyka5&^`~j=4+Nr444lC@FbB0Ob!rRXR4yFhG?nMcJKfH<^hHP{LX7lg1_- zbi0U;jov`y`Y}7{vCIJulEQK%x?=@$>BRKKCdU8kC=P8p_Y9dzJfgILsRU#UGfDcy zVI<9tj5a<+0biz_sV>LgG+wY1ibxBb5`S*!U)+sLMkUDx-(c5S0_<*3%_<|`L} zKYah<-jlWyUKrnfD6O9`l<;CdDX($bVKtTUdV3i5kH=i7K7{W);JZ_)=J@9He>xTn zN#+KXq(YKkC^Dc~&OjCRFjttV8UpfqK?gGG&~QNKk8?AM_9|4 znAo_q)VLH(ERAyD@tkjgDe_MH2S00fnesEsu@90~exyCVV|mAlalc=D`3JWB#GOAy zpRJR6FB||gF)!EnGl~V3XTh#d60$S3+Bg_bRvC&Wf0xm}RIpO3eY#FE?`HAInN4EgBD;3peD$eJYT8SC^k z`p8#@otKf~EsArhZY+Cb!;Ix6Z>(MV$ujvF>A~d#$~GNZQdV}P`k8f=r_2|WW!L>n zFO;u;DabSS>555brj0o{yYIM+6{R!R9^O$lYvcS$b54%Y=Sp!VKVz*_x!G^DM&viG zz#Kz_7@r(cj(J5#hJ~W$8nWxcMH0e7%zRdHVp>{E zf~fm0($guk2IbX|{ZN(+vk`weq5b=?+>2FwxOC44$rr;OXX2g|1Hetxr1k!vhr}%rqAX-uRZqtx7uURizAm_nD80q0L+TDKA`>;A(nEC1i;G@ z*bLkx(&7Mrp%O4qn=7y;c!b3ZKQpEjp`u)olHI}*n_%UZZAJ=5igp1NT3~75An2-r zfgEMZ%vJodY1)Yi3r~+;@YzGN*mpJml$+acAGSZVRr~GKe(la9J;rQ*aPHfS9=bAf z7yHBWiM94Gy-oYHU!JPg{lg^F&X#1K;mG_6k&iOF6?3j%*o;xXf?wd6R+~LVwBqi z42D?+(5%2(dSM1smdJpqxnH}x|D^Wo){XW<_ShzR}dqV`pn>P>*TB<8Cd(B+rK$XE4@$Egr6d6Fy^a0L5~0-PFURk=@7^|Z-1tUkr7C@sK|;q zAdELi^$o~mNMPYuOtA=wKn)KeD}q2DMTZK1B@<2ZoUgb}R1)$HKyvYrMu?3L3&Gd{ zwsI4F(gz_$IluoTGXEJKGZ||@yJE(=9Zl->W#9G`ZMpl z$KQW{-8HJJ3788W-cM;xUGw&9CnCib1_cN-7R7>3e%>*hp6VAJ$C!<);1G zIaa*svBx$^XNIv??bScN{r(?HxqYntwSB7=(fv2}8f5x@tW%UQhLitP0CM7moyOmg z?#7A)acNFgH}HXR2Thxc^RUb?EDgueArzfH&CRsHgB9fG!)0O=i=xCfDDq0aQDkZ- zJ&H1-!>yafMLtr>tE#wW+b`=sda`QMu^|J!T6%}}h*|yI!@v1Y{p_&xM~(T&?%hYk z$BMH>`Ka0b*(dD74t+iqyf#(ap%lW)?E|TetnzqZsh~m}CICKGFi8cOTUFIKUNHf# z`3)m?6wtHaYt5h%Sj_aoh4L)Hb<4E^4?W0dWWxjWq+t!t0^xd1x zck8xw`?Vjm9n!n@ZEE{*Uw*jm?UWi{cX|G{(s`ReUeNal_S_zb&L%G?>04l&v>kztMx^;O8t^nkF73ykxRHG4#oyn|9@ z5Sgf)p5gRM254`!aS&-tn`4Vg_6>VCZD>-?)GprA<&2!IBl9IX7`x?)V@#(@PM-LotFS)XLwJ1rWdBB*jrG z$|mx=caikeq*$_ksmmTb!Q3`i{zv=A^B;eF_}9Gy&z%{!1ol-zSk!9mn-5b@YiG4P z&m?NKrdfBov_5w2PI>!VpLE4_BCXdvtx(>D`S>G4vAY*gr}SJ@&6PwG+(L|76eNJK zC+mb#DCUDEY#Kv3sQ)nc8Q^F2QJ|bLsN9_4Igc4hROMY)p5C9ctJ~$v-4Exl`FV?0 zsO&kit$EyCU*$??YwIbW90XptQ^7tx3%ptjodo0vwV7e*MEQuw1vmit)WGbxn3zbf zwm>$LpFnSvnB68x6f#nikj^9_K7=w^wia8HYQl&wATDfak;s^(nv9xCoN=Is>1tR8 zs-Hsbf-1(f$Q0VKsR`mN+sLgWM&(UEJ!xv*sFJEXdxCf0*<3Pe;}&bP*neRD^}nf5Insi-)TqZ|qvKdQJW z>eRZbP0N>W-nfph!Ene<0dtL{>~vw|Y=bHT(MYNcEdYp}H;`lyS7(OF*&-5k>e`nO zDMs=HT6}_Bm2tW^qFl(tFYL>+n-nZFl-0qBtJJp@HG<)L8TtzzY$nxQ8@)&E;JK5GV<^t zOP>Bn6bf`i7>aq~awCH;8!t^udQEypkSbbet@JfY5EJh!dw$}#*XNy_)3M{a|DKKh z`RahO9`jcWD3cN&joR|@vX5$u54|z21C*MtcEuiRtG$ZqycNfDx2`JPF%o!)LJ9QX zGT`TjlR>X2BlzO@CZ&>FS(9);)A>YoF!bY>We31;2n+F#3W&nj{1U9bbcKh4GPu$( zI1BqW5c!aGnaa6}ZDXt1|Phs2P@mdOt>XMt=rCTn-Dr>%z{O?NR zmgem#EZChN94Hmv`QU-<2k>9E;Rk>YqIiN|5{2#hKJ|%-MipiS)RTRozDtlo4VsX$ z*CB5ca6FJ*Rf+7#&`c^Enk2RnPTpb&V7`&UGF#je5PB(OG6&apU2bMG&@fR*j7x}* z_v2bJRLCVR*=LYkqO=wk4#>Y<>zzqR5QOGl_l#wDlhx+(TN-S^j<%C=e`5M zee$D@%lW4w^Lnq->?clYH5>L%KRF_nFmEoPDTlUP!Qsl^9?KUo5w7FgHNLlvsY1_M3o7j%*<0xxn zye&c+TG=`8;Hp&zN8VQ%*D_^Ux!IhyrmEZcg$u`b+q5>rWDW_>Elp{qC3GEa4M}7z zgQ<>AK8k4kiTTBl4M;8pSm%(I(1ZlyX=7DrxkNe}ibNRWD6bOW>*HpUB_W2zP~~;( zOfs=`1)|Opckm|Ui`cVpt$I-^yEyyE)rpfnKD6ZJsnSJtQOVS@i4Y^PfgEXJ^lDdEpWu~X(Us!v{kY{aEuh%3OT1Exd7ESYy@^6HY+g3rX&0~ z1A(&)r9ZUpb4-8e+F@n42g@E#5W)`q=}f1P;9K0E>R-tK#V2LCrhmk=r6m-&3&eIYFu0_ zDNPDLJg}N6?SjZ-iCxI|Uw|dZ1gWVfoTpv7xe9a>|jFQ_+ZO`h&}(A zu6-0WFgdAh*Oc_ZKlLA9HD_K`xIE+Ov!3Q%vi!>3z?*ZKEi}Sx>e`}hX8%5z0cJD< z_oY9mfuMm+7@z4Kh`HkBz0?deBmzW(0FnG=5Ox}B$?L8MOb?fE#JeL!?ze-o04;{+ z;|HYxSpP8&h=_1&Ot>w=78jRbHIX^zDB{3PBT~Jv3DYe6;8dK>%NaN!3-;vq>K0`U z>=nLoQ};eNHQ5N`w3N>l?#aVJc~=-S*!_^%TzyP>B_e-smqB!3W_yB*@u~OV576Ht0=A%>qq57QlnYNe2ucgq391U8lnqC#>ZkBS5R2D8_xSpuQf$EK zm7_OAKWY2^*n7;&`jS^zN}JHu?xEq`tb_AfH|s7fy!N<#v){HQV>b>6?zHryUCqj> zcID)>S+wVe*CTRPW_!!?y!`r?^>Tl-R@fv)j#|8L^drz`Fz1EZJb3}dd?|?k*H9;h z?)$ZMx+(7X9I?YT{d4k630FX!25{hwh1w{2IqF#_z`SFN+LXmFm2{gwW`6H~ ztc~q-aO{Ab0cE|0VhVlNj-I=v^UwtUjP`RM+0LHzJi11+db-UxJ*}*CY}weZ*?)$& z&Fz$woEbw^_R2xKGR!$zn3w79j+vpBHn^hy(>Cmc1WeeaSB`4~byKAh6paBDkU_!C z00aaDQRR{_N7PFM>VA*}Qj`Xr8~xC|LR=TlYPGSsHfIv`;b-luUs>C>VgyemNH-KDc!~V66x%O zcouAMX~RPWrblHd5kd|k8~#(nFV9z#OYb5n+qZ?)FNyn4{oq%ui%sMH4PXW-P5W4{ zo}sT~OqDcIo4@Yh2hSCcPnc13-}C|UrSY#3hIa4SK644o0{q7)=1W-&J-vmHo|zIF0)yBvN}Ns@ zs5(^ik;*G0_f&XLfV&BzsRc_UODTp2t6BU}Pen0x$u!oi@)C1aM4D1MB!DE-IMbJcR;-OB3Wy{6b&#ci5XxOvF7 zIW0OD=Vf*271TWItK!XrNxnXe3!#^lClTG%OeoQBkK!Ot6;i+}Q5y}@l5mHoC?@2? zHkon;!uTWP!!l#*!0-X&t4TrnYy;i^%FPVswK$rYdA)?XdK~Vg9l-V@2an^Y^zt6f zbB~lne~Vf6=h^F8dofFzU_Zw$YMsUIq(jr&JFY`laeC(i_dowXwM}==o;ts6oAPP- ztKD8v%3hvv^y5iGk1hLDv`u?rMDmDZrPCfPIy`pE?M=x`zT6R{%@u78@QN48PRBtg zkz!9Lb)ulczENeeZzOpd%2z=!(S5)KqHhth=Wss@ykTVG)Wec3^cTQz?qS$?As!xW za-Lb-;d+8wJ-|wLqjX8ii^U|6d(YwF=89N=l=a@HpM5sR)f`#MflZqZ{N`$&ImGMp zpi})@=?d9fU~mm~CeAPwoTQo%76c#^<6;au)MQeMF~d;`aZLj-000si*LWu&a-#XQ zpos*L6OE-N!J~wkz+Fb!-~A&cz5_@y>(?ZbU%!$m{m!4i^6IPoN=o`oKEG)58{^-R z`j=)*n8so{_3M&7f6T@mOwsP{Sld6RbN5Lj3LhRa;qb_QIdMbiJTmwQ_aHcw;UAtX zOtJsR@U8!cpGwf_G2cJ2wvr0e26>9jC9w+Y_dF z1dHH)5SUb`uENzt(&}v~#(_(kuxKf`vgq&wlRiGW=)zRx74w3U()n%L%$L4kziN+$ z?*3xYsEwq>m*%aWaeVlwJSg$NsgD0q5eJmy8DNR0B#23PEWs7rbe17;WEs90G(-xK zA+dgtHYn<-WTeI6hLlW7E7vA*o(2Z^ z2ud2=$k;vG~$WHT;H_6u6S$PeK6#3mcrr9{Nm+VV_*nrVOl>^EDs#ll_wYL-vE_ zi_Srhbm((#$}MQGMY=BTYm3GlArGN*G31zsLoF;bz!qKK<|)F~z~JN-p+E^wppXZ- z%UB^v2G|O;tlX=~n{rQwwoW8+vNU)LQASX=j57jEI0G{b9nU6#;b448R%T;9YZ69v z^-Z$$OU&Px`ucj7*Luc-zDYj4ThBa_vM;=azh7eL53jQ09&(56sj0r+@@})&{W$}6 zrPY+qY40cRGI`Hm#f}Zw&^v2WKl?;^LOAAGt@V_TV}Ha5hzmkkHVap9Zd*{z&IdLL z)G!D>s3w&_9@|7wxZfYL!Qrkk3}H)bTzsO%$K(;w(vPw<)19ZW+YPg;P6xACt4~Wd zZOUu6mVCW+_DemNwyGSo_QZ*G53%X?4^Asrv~{FM1$_VVrccWH+_$(@$`hM69w7ay z2E>E?n=cce(w*3P-K}DwJF(CZ)Sp0IO4?3X7;2Lmv|&-|eK7oHtiZ|fR_BF|p{p^j zb{RHwy>rfh$<6c+LJUP@cwk&moN+(KAb)sy z-hF50?)j)>(kF)t_jP>RekZACR7AfvljpYCBIn-`cy`L67mKOo_~q4c|-2cODOnKE}3-tdfA9G zJ5b3YZ^xMtW!FznIx_$Lr8x&DZ8`Pgi%)N#bTDV>`}1kPaXF1S@!D6kpK2yS4v9VPQJfOnv{~|U?!OHatU^YnS4=cY zo50_NPz=%ylCa6?1rWcr;MXrmMo2NQXcDq>t3v`rc(MJ!3v^|K7yw+hkn21_WETBw z$L(og5O`+$2QOTH@q-Uuy!`w}Vt!#^q2^auP*5mF2Y<#|TUn{LDOS7kS@7rD`?1<0 zw%E#AiKR6^CtO+`yy6}0iQrY25+rZiI~bM;<7&SXD^&qEJ>xSyP%%efp7@Il4T{ON zz=i_0V4@=OQ$kF_HA%NJLHNLEYxr>{3XvP{Gw1_}94>I{B zrU<6G2Qd_80#BlzQe1v9GuiPSU`nym6P>>6>KpLM`Xsk*k!bOYx5lSfEj}I|sCfgO zNB6gwbQ6;vD#bz+l9wfo3yC!TsztKu_qbnQxpMLGEvyHifS;C)1qiVN<>o_OB-i2ImP?NqlXw}>-#)JzmL`-TTI zvHDD)_vR(aHC?WUGF8DHkm}A*OCE;dym|9zF>^Hob1EOpx=ier}&p82&uNOrj+_E%x1C*o2ixVI%mC5EN7kHiwF zilj~?%fxZ^7|T2g%Zx||%m@4dP1JyNZ~;DsUo*}YZ-o*-2NSdTSt)eIgu9+}<8*?o zbKD_d3MyMs-R_7qL1U4z^Ey2H#;|icdv94d@O4&EFn4n4)WHSpsy91y;>69MI8k}y z)Wj#oHot%VV4p#Gb4KRR>O|X0NQW&M2Nl8_(m5rw4bL_ST^WY3Q%C{`4K6GsT|mrk z)~s1jvp_`8Ifo?Z=sCqCyu9uQ)}6(__I|;cWty#;#gDG694*cm!1igSukRXrs7RKz zSgms6kYQ6e9u$A}urdK_m?F$RWAPEe#h@u2fl&~z(sEK`u(4sA^GgTVdxdVGF*gxy zf~269pTQ$^P7)|7R>0f|GB-1X35m4!e%^YGTj&Zx42yPm7{$8!A5-sg)NNs|99R)3 z02`m%%n7>D%zj++_|c=)OzYC)@s|@01x_p-y<$}1qg%FIdrRA*{oH#XyIQ^?JLiQx z5A9nb9^Ap)wf}l=DR16kY+hDozrcjp^>em8CB152`(Xa?toB)ciPqgShJhSdm!Y^5 zd>%4~?tUj`dM21486%tVyI);Ygu$9|x&nqPvi=GfK^m}l1co;P4j89TaVOIzi5Yjq z@o~WcsFvB9wc;)pvf=)RSHvle?ud8hZXZ>UH|^A_yz5TYw8H!ulTJ?^ zS(vvyH#&Id3oq;p-hTF+G{42vv6E+6cgn@57cV}Vlzygi=i6h(ytQNTGwDf37cV(o zB=5A&nmlG|%Oe{%;lIrr>7JD8rhca)AP2XT$wF7*A^jxq3k?!YQit}5&1Ds(%J8y^ z^r^BF5h)|r3BqwbFh_#?o+%S29aFh}|1uBNy&Y@l@Y3W?lnk>4iqF$Z+>gwZ@&byVI zS@r6qiLb0WQSxrdiB&I8yi<@iXUvG%R_mMx$IMHYFSGP{V}{O-i<^}@dQPgC>VK$q zQ`y*Q%Qn>>@;_F)em?tBi!NVZd(408$q6~V+3!6bm~?8Xf9a`7gSu&~*U$+kby{kL z>Q(43IxTnTI}IK<(Zmc|B4)*)CAEqTTMg|rn#jnC=%#}?=tw5{sDbW?XdOw0cpRig zE+;qOurFPLalk2x)7699K@EtRkrKp-X&ARQ3uz>DNZpI7QpV(` zbaFmh;(p9y%CjISr?WlzFQ}>&ifXw*&}DPxEF*FfneBI_5B`d-Oh7b)bP03~q)OYo zvKy-2!Jm$Tu9Xm?+*pQQ2!f&5Hsb+FfDMd`35?|tUWR?jLl)@l<-sEX>wb9Q>}P8Z zyqiCBRQ}ZQ)5Novzx?>}=66Do*z=Xu(`IacsGR%@WNStt=Y%TXz#8j*!XoS!FX)1) z2+4urE|81U5w}8tp}9uvF`ZYCrTCtg;02e6FSkPD@mNC-k0KjMDXQ5emeky;u9lg7 z>yaZ{Bx?=c5@_qz*Psvr^d!uEj&c%qYzVx@-fjrHhly$Nh6A3?M^bQNp~k`gD=L+U z5R(-6^Gp>;ku8x@O1w181eS^5Euyd-z>2tBhg6mupXX+Vd3gcN5U-HnAgYq;(+nee z`dWNZsy(!2n3&>+cc4}Y|9AfPYY)s>Qa)(!6HDhUSo*|1=U{b`Y~@I92jER1?i68W!A(OUar~tz zR451MA!LL6U;IB(1EDiP-{=1$j~;(@BuD<|^w~52_{W*Erd@kfyOKK06;&VRIlwnNJc_U0GtE$G=ryKtfF@Znt%u_EW&V>?M9 zcYd0+Vbq=igsg;0<#!&fk68KtqrIrdf$oH?>ZDiHhD^eNND>-qgCH4}6K?uiw`v&` zLA8jfEIr-y#T%8S(^3(*5y0(kx}+k5oQ&}<_=BS@t)1RTo<4EqxP{$=ZS8En-PV)^ zWhUEFZOOAQ?cH-}cAMs@&D&%Km#yjMi^kv{6;&Naj&9LwcFDx{VGj&SKkU^iIX!>u z;t~Bem-X#izPay+#bfi+lUsQmPQU;Du=W#6X7_3_W<*E6KUcwb`Vr<6D@@bRGj|9* z(F2MQkGmuZsQ+S|Ub+!UYGMHoEptqnVqBfAi-w=_7}rR=Wv8`MYfCfNe6s@}!WwdG)o*oy{ro2;eZb-@biuvbCE_W!}-lk$Eo8PmOyZMo3 z5qTR1XiE>hm7o9CA@Q(%B;qhJH&J*NF^VHFHy?P0dpr|i@q~%#P>?PBU?B<4Jr3Nm zr>8kwZFihFJm50-Orj+umcPQ`QYMg0eAz@nIDS|)zHIQ`v&xL^qt~1*dQyAw+Pmj` zx87XVX@2p8Gpy1#U3;#*bGXevH0`nO8vNXc5|>}v(q{aV69?X>%YWI5y-0UF$SVOq z4@L1IToFagCtw!219?CzKlJJOf-*m4kl?gU3ga(V2 z>T3Is}&&{>?S0wctYN4n%UOj*&fEyKuyB03)U`sF(V}!PZ3(*fZ zw=mQYpiPggGPnzre4#KMEPI)EZS!P5OB-7a^F1xGu#U;U?ft!V$50#z`Sz`aJNxzC zT_jGrdqC_{aBlS2W2N?I#Xggc6bw5z!u~8K2Ap6YNk=$s5r;@iZ5Wq0J1JQQVDy6b z6cEE70^yw#Tc&N4sSH74JaWGn>NS0E*6`Rlw%x3|c3|-EU2N6p5)b!$DyLZ|s@1l=Y zm~cmYC&6v@>!6R@YynU4C|_iK`@aQ&=Zj?i+<)J^HbKwJ$o%2Ir##}d3FOFULJ7hG z6zDd7@H@Ntcp%Q4m_k4Leeh%~ zJ_dxaT*cx#DMLBNZFt;fo9X6y01kOxE}PzLiFm|>IGjR~>+=Oz@Jt{Z-q#1oU4WqA z&AiQCSWVg-I0Yqc?y4-nP(axm+Kw0Y9scla_pE;Fw4c`x>EELthK$B5cIK&FvX=MG zD(lC}|C!mQbtds@G3zTX2R>oKm`p$J(+h$qKq!su1C3Ay)#!n7sDMhyP>L$?4G6Qb zAP@J3EhaZfbb}AcCI-EEFp7k8iAfLSK7;DNepbaR3=YdWhaT~qBaSAG42R;Nl<+oP zeP4(PY!%tOudT3Wx1vCsxZE0Qq=FjDaL)sQT$<1_&2f}_< z)eGrjcsM&GgHv?49_PeeQ>>SDe78AkU+B{%wU_U6nT56i@$N1C(^UUU>Gy3spvmm& zgrVt4_V=XCQ3sT> zs4Oj(Fdtv~O~CSC{uHq>A8$DgXQ~%MnCfW{vzI8|J-A(XyKcVEt&fP#>)@}`Iyq5n zUUO|`=Uzl)+~Hs~yFx!zgedsKfC?^fMKPKJW@3245JgZ>*4%^~3Xoz}i`>$p-#?{+?_hx-+S_*z$(&$p}WfKx5#p6)=LyBTIOn@BKgZv5j`sV+L+0j6M|` z^(n)B%lkBHCOF=x>ErU+3#yF0Y~Vq8xK%cn|Bknk$^_)jS5d2;K1XmIe-ETm?sfd0 zir?SoV|1V~kk?Raf;T=Q2i zS{9QD_gP%spsm~BAAE82C8|ERV%WH)=jP|q+~ok{^U2TO3u7{p<=;; z3g@5eUmVrDPv5L7z#lfc5(-?9Kka_t?=hqH-#m8+#3bW+i)n3ZzcZyHR-%QlQTNZZ z6WmZh-py1AK}FV4rKg8zf{#En!37HcG~S7-Dqnlu9g{#z*YU5u#KGO&%|&qS#gp4B zhB!wej>VU`D*?l|fFm^)u2lGgK^QL+88`Y9OoXG6rWz;O$k2h~JDtA`Ghz&Ja4Vhd zZ+I@bys+qr@_@79kKf&PM!WWu*Qe*seQr6y!cT6wdo28H^fy)IZ!GnZ`W$)e#@ycP z#!1^ho%JZoxN6T=uGr_i%UT_n`N>Xc`~K;l?99=eJ@z5B8-m2@K&$|r)Z zNjZuhXj1TiR^I_$c(QD$EoM`gp&xOxjO$2TNlFzXJ{RL&f8zY}FCF<8dwp0~&o;?f zctUw6iTz89r9WcjZ~Z?xaQO3H7$1AagqH|7fx;=W0De$#5^gbInv>cz!NUzMoaljO zl@6>Ja;GD*-`PC$Bnnz$xTdCKV&%FHgU-hBVKdOCQTMqN&7<8q2G!C}nfS`i%wUL*%q5m+RFW&8TY#l+p$IofQBZ0Q$63ZL`i zA@Yx7=kPmN>4K#*m#$y%>AIAD-P-pLAJSvtpy&3q zSn|-poew>niX3ss5lz3|O%Jbv8woUDwzo+}g#`!%3h8@ArSx6e><-tV~9%DgIhSn_5)glzQ z36O^nh;+WjC=fS*j0(m+4z*a^=#))^obf{lQx`DgZAgg>>Kfg72+oCV&;e;si{LoWU|io(iQez ztbFj~zP+am)>eowU|huF0@q~3_QVK1GrL9U(GwzWyhNoE85$uaWuY$l0zVMd0^Ehg zs1*4b5gry2WNGH*3109fvd7EYMv;ZAWfSjdv?SeFv@+Rx;(A!S&b~l1|v~yc+VQnvC@AWeF z3-L$<@AC)h6Z)0D*BZ5}-wNmTu>jwZ!~dk?z|uIqk*8Pr2)1@C-H1lxgk}S{<0960 zgsVdG!x_v2YlDOQeVcjn=gx2i5qTRucdmQ)jDI+EF!txTJ;SR@@zQ>l0*${Zzd*<1Ss!tbte^6chk5L`E z{lv-xd!C&za@_t=m0vxq#lpiAyZN6BhVLusKkwuYjL+}A5qClN-oZjbrZp(Q*Nq%i z2;&#A%oM+Y?MB<)Tkys!OT`4YiiD6TD_xHwxDBy+y2Hn2GfCU4COpxuaR6T`wZI_=L&0v3h6IWX z6Gg=x=B6kiLJD}|-4I1Z#SS#%btB9t9jPE8i2Jkx0!S7Cv3kt7QbztLXAG52RT*uL z5sKTj>u1ie5nn#Tp0kf`VIbO^EjDL$0j61IT!k#t@MyyRlGv3n_Gr&BUbqmr6awEQ z;2R3-7&@e`oaG8`Zd^G7ie#8b1&B0v=x8K<03J$O8dM+;($Wxukpbn097jYTZ8;J}o!wsokFWFRTtjp6;(M%*hU2^m6hW}FmL z&y(A77~vwkC*;Uc3a}^nmga#(Fn>%Yp$M*R=%(4p$xKMjNXE@!ySA-c+TucSNd}*t zr&*!QJ6;e_j6Y6js;s3!xvSIdtZ?L!3lCZ69C-}cYmZ*MaH!wpnKLKXd`Ew4+u4NE z?@t+7Jm>w>{c?-Oj!IgtXYbSUcQ0SDYsi3sL-q|BIB@X3gX@ZBhej?R`_Q93x^(HW z&-AP#u^+Ypm-+e1F4WOg<+u3n&`{)6B$pNP4yfvP6eY(<8{3a8-Si*aLwO_C>jdxCZAz*A=~1k`+o!cec<$lGSQ4RGfq2F zCg@VW?)`2C>}&~7GQmQsIClHjm6cy_-*Ka|^2Uy_YX-X8=eiGA{ZCx$X0IAuymDah zMkXJ7iYXg6YImPHrqyiRpTD=TaBn{QY1GbDszy7}9&`S!u3gE(6X!;G&_NTT3Zu28+9SAOflf#4XtN z1nGqMQ>POm@RaTWG7O#2Fpf=DHk~DF&t6%Za9>1Nd)tP~sJ9t`ECYG(9g6Q59-5wT zXXisQ&J{({zQvhp}F7fFg`hXe22U2zrb&TwnL7^nuXA7W@xJP><2dp zl#2^720&gI4IhZUdi+WtLl*%4OUvyY#DCb)!%&5xNZ)#s!xi+ZxNf7*|T zBel1-e4|N-7ScrRhX)?+$G)`BuQ{b8o!OLh4qmKyTOm<#sE+a$vPbEpXn?F+m`5LLIq`aXdiB>AXH+xR+= z++84#gNLfuX{6xd_Z#${$d^7XB73MUG+;?ecKC($#tcWJo;cB8@DGi#DrP85Fo?J_ zATY>rJC?#kf9;r0N>WJV#5GZ8LKEo?z>gQT2c?QuF}nukXlmb0Sy`LVcoD#{e0*9s|hS6P~2%QZvd5E{bEt>8?0frRyLsAqNM&SW`yfrd0Dls^aUmpWg zvyQ1_ZyHbV>MSxmot5+ho1e}Od3xY>((#Z@Q+3>@Zw@)u`j4aO0|%z#Pn|?PSk*SC zboRMvQ_s$tIkN4R$Jj;wIbig8)YF#F!_OD+UaP>)JI@0)5%hw8KyJH~No~1IN@*;U{J1L0%C2hJxh$7lpU?@T*){u{c9^Ji9v?s)%?!kQMhY#V1uo5W z55<#~a7cBEFQSO|L>x$Nu>I*4%w!UaurOFhNm7fTA%V+`V>^xRpyI)#h?g}@6jXGr zQb>5+ckAI0NEIE0mqV#-l5Fu&Eu&io2U?opWRGN#?%+v&x64gd(PEq%#!atH#r2i( z+(P&CL7O*RezB_fY~|}SW_`BfhdZ-wom_pk$HV2_cH~ENdA4ugMcE5CRjpX2tsXGD z#o(;24-77oo|trL%hoR!uyL%g?>B7Ro9k9&RtyeESbVsD?$I7g3Lk#%xrZOx%3h5K z>J{6f?{G|O1?aR9GTRDm8LwXvUC88^0GLLI{6Wkz@|!TR(h-1V2yYM=doQtt)jxqR zQjluGOso{6S$9Q}hQpBuhr@N8p04Pj9JtyJlvlcC_WkwZn#(gTt(Y^pqUw{mFYny- zd{m}(rBBb!{nksKhl1TUeg4CY%WGJc_Wbf44?VO!c-xJKERQ|^$|-HR>>;t~6Y>TX z2P~(HCY~cgO$D#|>9PZ1k}BN;z}8chN_R741)|%r&T?DmUs$VR61!Mbe}6&nPxMcW zi;apznmf8kw#HdJaJnL93lF`ZY{3g}jTNPY3~L$^DA3vNdYzf_JT<0#(x~b0O&>M6+}cjgKXm%Cc2m1lKI;dhLG%6hD~ArvcyY{2A3nN| zd1$xyJ^JBG<6fLb{K{j8l;MzpvE+x~d9p}hit%kmnMFb&1Em4DlVSZ0UqfKSPZh_f zne>5J|24-4xd_prUV~{ce)MobDi`C?oGhpD2NQIuNd|)Bb8^)s)0U9`4{z@Q7-f~U zkH7bAlinK%B$=5clL858B%}`MAt8+#N=O1E6h#O{1cH$g=}mMI8%7AIsEB=wy1MJS zMJ#K_MOSxS*S4s;x=7}o|8wp;Gns_oy8rL{e(r{udF#3No_p^p&pD?Z3_#adV=+rG zN$DEQ)Eq9k4Y>sN2tS-Q38uKLkhnMl=5S^XAADDaI+khBLmr%tzic=9;RdmHdB zQRveWi8UBL`HV2q5G5WnS$!sQWMVRGC_wq@C&KdoQ&?hyzU%U;}j&1q}Mf&(+Fwk;{t7PW88 z%iGxAzA-<4qn0owFD&{gR{ib#6B@Fe^oQ>HVDs$CHTxSv0!-F5;`BK;&kS90X7S=P zD?(@93>^!6V71$&+2H3!Y}Bus^ThkU6dJjG)L zc44LIJKS&hh!({}mZ6>Pe|st7&gk2MHMuI=uB|iVtU2C);M>EN!{6-fpT2j-v1xmz zlZ=EtSz+9kHv@DTyuPQfCLBjjE7$(Y^&ud=Nd$&2BL$$={I6Oz39{8d8^Xa&& zE|U83DgJ!We?j%&?}hwE*Ne^gWQgesVn4C(6nuoa5338ytX`gwf8e)6*rp!r4Yxi- zjTK-U0k=R_ZHH!n+;PaQhclpN_zC3JgOMA4KEa3i$QXl%RiTWT5HlAVqN68R$^Cs9 z5g`HNwVw7ygC3M2rR{( z>1YQbSkSjFbyyS{o9RDm)aa;S#2p)BqRgYof*2Vb31}2D4R{im#>Li7j1*E^AvG}8 zWeEl*l14+>%N-{dw4YeKq`$4Le@W{M?cm(GZ27E~mf7O^W$&KoJ@H0I#~b)KxAcxf z_jr5XbBLYyJ+^P(F^mPcYKRXAzp1tu%+l})!KwFaXP#Hs?0}tc9JlDl={#bpXiRaR z;ab;u1AEbNUl#6zzZyLR=oGHQZ}mI6j(*eqiq7Xa?uoj6j^lVf9jEh#`p&hu3l9qn#(z*EJKPXrw#Z}o5dd8F*)eg(xg_2ZttuH$$<9p`jlzUu9y zytZi1DE`~2Q#r93=m({i`_!g6uUC8d^}0U{+a6n{N~oK1=AX1K9QYQG$8({Bc%w|VXiy;Ep#N5{(XUrw3&Znq zz2}?%@p{}(*VFSnU>BqJ0iNM#x9WQt{eO1R508r+$m#zxr+*U0;SK)2KkLuKIsQDk zl|K*X4ZptZJkgKy^nR6$1bDyNz^{kS%bI8$#Si#zhwg^ouoa?xbD_(DzXVmB&fkyg zd7WjI>MUdZr8ul-l)qrF#!gKD$r0jwc{UA&tOY+J&R5T2DwFg%?X~cm?l^GoiY%r*|SIc?&tk~xt_gp^S!%2-F@=bzimE!Xy2bU-K(8_>Ev1M?8zN3a2%mH&5$Ai9pSMZGFEoA2l)xn5ZHqpi6TIvW06B-H5wKt#92(iaIsLj zYzEs9xuz&}xt=H4X&}-i2*{B+*-Fr>)?@9DYZrI#XWozZ|E0(8rLcW>_C7SNx_{T2 zd&aR}5B!mx9y|Ud%Q$=AODz4q?mz86cxLk_hwnoh=1l0LzT5+G{)bm~F2#QIq7g zm$r%GA=@1B6y6ibzLJZiN!XWStz$&ILO@v`NTbb=4N0n!SR*h&0kR6=Sx-6dN?0Nn z9gA(<)4pu?j4>yYZ+Yd0EwA3fz8W_>zi@WStXt=|+{$^PO54NEtG~wTqCNsBQ$|X7 zPM{@+1+uF5-rLH8v@gGTPw9Dgv-ai1Pqho!C$|fml~N@Uex5X;Qh3Ii0YH7CB|-J{ zGRDTB*cWgZCVL^W0gzWV3X{pEz76;5K|9?Ob#fX@ZiwdqAg9VC4rX?pFfblBR?W;=HJ#eC{6kjS=pU|E;bzQ}3I(F*BDjZu~LC5YNeqBFXv7v13@q1R6uWwyb zw)%MgnzA*bkNcq$_pU8lW6N?s#INGx*JAsVRAIjhHH?5ICdCBOH~!rQRuR_1X32A0 zNaW))OBVLbgO9Lr``Fks4+m-AX&roq@)KcTJWq;`O+%Rz9juQsGz>vL5q8w6IXEpX;+$*>+G7n(SktcUt};H@8o#X_a?xV}kEl>V)r z1rpML?`QSv)wBBb&{h`<+vO+a*8x)thc2Fm7?N6RwE=4n6^sO|48A~$-If^yR@lQ7 z(s3zc4+TbJE+R4jIu6jY%~+vm>6DemIQ_p=p3xeHlpKc1&I~Nx854&!)BQVhJFaI5 z)U|rnw3U@>Kf^z)e2eyTR<;GU_Vl8>ydwG=I9iZbn4e!bv5-AnpdTx6exC1TliB3$ z7`>Y9+T+^e__;g1v@|`9{45V0?!IFcfJd&>TbKc%k3l4eF_K{x9j`*i2+XP4#H*XQC-yH(5) zYx!6F#LczZ7vZbEJzRTVt?H6B=3@SKs;Gg=~ z5B$?H_M%V(Ix^Kj&=DiFSbaxFg@zC{fR;HC@gcCp5H&o{TN{Gj#1^s{Q;Zx&pK?bI zlFct{L=iP|F(IlZCNM^C0ncSLyaf}$@rDE>-P31)lrut$e*XeXe5tUdQ~Sk*3);(z zme;<>B8Rrp@C|F&Qdd{9u(hIY+U6Rx`CYA7`Zvjss`p|6T<DQJHg)Q z|AY2vdGysSEms+9wa;HVuBsuSiQxeu(w(B;fYx7`Ib(k7bjy^7MVswwqjq~nVd%KX z;IJZ$*=jW4cBKgPfH#7X3=Ez#FMY_EziW3xhX6c+94~~cN9b)l;!Wan6#j?0sRn8M z%gkJ*{psXsI5^AMH?eM9dQ`)m^FFx4Plbi2@wR7oxkmxXX zK9CNvM@WWN&NUGatXqxDMI_fg^Ah@fH@NDKIEj z^%$L!gQN{$MI)R*_}8hBn~heMv3r}R*2Q-EZrY`tWf^2}db?jcd%XYpW7nVT-}Cu_ z#Qk6F!Nb?vH!IJfjV7`>hlRow0J)4z&R1H{DC?rXFPu?;g&{u-!NOo)CO>%?#6|i5 zFVJ$pT~o-aqN?n~uD*(OlS@`L`j5YG;EO#|N>-1Xu;AFjhRrW++O@P|U3Kw-9A71N z&u9BOpQu=zwzayWf5D}D5RIzSXDC!lgm}_Z%mGAIZG2o%AZ-zp6$WwywkgJef?^vE zh>h{d@n$Xq>$o&G>J$f5&FxUUp>Xp{D+lQt_}!47@>+HXgt(}b_8cGB?S4SM|F3+E zTf|DKP>F@?W#Kb(H0<@5JD81nytlX(mw5;tA%QaXM?Mj0rVz%G-Kf3w@cqF-4?L{B zBUXy05MU3NZ367$NL$jbC4o!i^apX#meYiyZ*Lg2RcExj0Y%10r;6H2H{ScJrI-S z9Jb)hVCY5$Y5A)QU)s3F&+j_U0u~mZk)fTV8@p`h#g+D_+~#9^c08Yt;z~lpX}=mj z9uAT7&(3|OYn8Y6^5OTm&qXD)ixrF?ul))jy7OJjy}eg;JwuqkMB4>%wEZ#2p;5v_ z&MlO=7_&p7JPYW#W|BNPJODOZ5-;JcjtYz#6fZf)kfGMGGGj?r$xN%8XA$&oD(@;S z?J6%{Syr~PJfplkBcr^+cA>DdxTv$Ru(PPRv#_fqEw!X1HI4KD@XNQtw_=Sr8WQAZ zLhFF)keyYXKXCpv`GT|)SU;fJ3g~**Z?8*<)CV0}m6T(j3k-ELwdhf-i_&BruR98W z9{~yzmN(1=o_-ykF>Ha2NST4|z*2De1z>Jyj!&3OL1q-v(dURVD369(xDrLKLhl8nM^s9K99_r_0D>&uNp|x!PMZ96lzJLDEyD+>faejz$rN4_h zV%Uih-o>(!Tq}@G`WM?TcmH#rMqz^VK6vThv)?vCc%Z&CyKSa1)f z^{^8oybob{D8O0!lZ$vk?|1ut;9W%f3N%mT>pg#$Ao6#iKOspCJ2BF`D0xRNN8-$smtmxb%QjQi{OnUVGu16)q53$r>`}C_b+RH5c%sbSD=05$nV#xEx^5+@p zQM{iVv#*t|YPkGykhKHF7A={n^t^t>XXx_`LOOq50@@CNl}d|oX`hb?%q5aQBo38h zbQA5VbU;66*;JM+b{x8C@y!Po-gId3&Aboo|6~iqD#?I+AdWGnT#2kU zfNuzJZQxfku4HX^4{MC)nLUYPB}=@sBm=o1EFLmj;Tx8b>t*sXPN=SK&I%GOx0N?t zlj|kkIjU?q7JTeUh>1^EehQ>8qB5ysA>v`kf`{#<2ZIEQ0MrWb7P!So7VJA zui7@3mW2?oLM-B+C{Ci(YK`zjj6@&-exQCyh>(yFY!BAK5p0Sehir-*a)+&tP|IN< zz9=i8DwIFg096c#gKT66$j-8q>ZJo>Jv9T=T++(wQ zW@~>~yk_jg((Ff`ZwWmT$!u)BcIv$L@XXtL<{lAWnEcsoEmh3`7%<_m_N+1iS-=cr z)Fpp-1V%*PJm7pFLm;2(jHWt*FmVUgn_*{$%ybo{L$S=!Qg`^YWPK1i_#d=)S%Q{D z!wcM)rcA(I94|bj8s1E4(crmcq*o5!0FOCF5|qYAj}EdBI2ix=kVnCV#e+70+O*Ep zc|*NW;wgfs5B+EnW%x0@;tF1VjS~5&#DX zJ3~+|kO+WcE=Au_rD*OUgZUVou8Xs}K^b>S$a@;jgT;r~l-=yhM`hvO0U^DlrKJRa z(zT8+6f`cq#gF0mz$NE5K^%BpKB@gm{eUc8!a;op8xO9A{TlNx5eqQ-jb~hRKO*bd z7U@DG=%Tn4viMRpWr8FMYBS_tE|;q$ye6WwF9k8uVlwPn*?BE_Ghrn5GMmE?zi6WT zs9bpGA$1VnGZ9xrGuM(pCKdwjQD~!u4v~c|M@tQ@FPOe)^Q!h~sacy?_oCJf2Co}Y zzPdfLV0wJDpZv|}wAr=wv*MfMV?C?dI@&*qEsgazJ~KY1*b>J3p-+1b{Sb=y`D(sv z6;Yj}VDJuBAqQjxs}G@oVXgwFk++erLa+og6tfHm;uqyjROH(Ur6gJo-NT7G3^j5L zCE4jEv;~Z1d;j{~hdS3^ryZ6ni?gla6{9-d{cCnnyWDr{s*qhb-LWREti~K$VXk6L zhOAOSv~8BpXrm1$@OFP8lhc?8t_M>~OD;EiBC^c~#1Pjg;2KU1_J3U;(9M)uNUu*) zLL5?^#wV)p+TIouw?!u>M@J_mffdmwFUoz|8|V|?AEkf!`%$R^zbOAGyw;cbl6il4 zAB1r2%b|W@3~ev3Ie2i*wfpv6TUJz5hTtK&@5m;fo+Gz!^4WO%@_AEy>gUa?_n9(} z=wSor!K;s|@51jpom&5xzE#znCO(YNtp_AyIB`-?mN-so6mrer7%ss0F=QKnINDD8 zPE+#}fkCEVUXsd<*{~85PzoPrtthf_;><-`=hsK~cF5nD6R+OLs}3Og zKp#DYJ{m1l@Da%ehv<>J$h@P-o4`6;VI5)PiX27YY9DW?tE1UyHiVyi3eZ zES{;VwwGsj z@GR(i#_%Fvb#5aH^!es@c#xvBrA3@9sWmDw|9Wi4e!#igH(C@SX;{!Xe zgjgG{otoWFBcB6cYBbZOPW>{t6-Y<5hLeUK7D5_28L+`66k{};ODLbJ*#bU6<#?Li z#3g+l8`m#xo6x)3GpBZXym@B6wOH;uy3VKjjtMM!;M4R;%Nu@E+d4&O6ylRJ+M{T5 zpis!iB!dh~$b1ZWg3C2B+1aRBFe8w61DpZ(296>2B*+}h6LsqIg|9W3H8fo*Q@X8v z!rbQ0-lVL?=&gnqwexu^y0vH6q=M37?Ro+TvVlDLjJ+NF5bLy9kY{2vrYO}qN4O`K zgqP4)q{UGw)r(jUCJZ$Nn|Y~U{$4U8>vaivo(psX>RAvOIu)4%rz7igt{XRMdU12d z_Bp9JzS7qD4P$y2sE6Vb=a0?gM3r_Y7)OoKe!)t+3$%@5qQGn==$F-?&EIKzLr5V+ z2kHqdapGjGBwVII%~|NXx(;DRk5E22P8UyJME!s)tsqfb?HlLU6xG`q5K%EcN`1H6 z({r-6M@%d+CD42o66FWk8bb$c9acUL*@SI`-3iWMO7{#$6Q(0PO!PMLgNyAL6%j55 z+!2Ow(u5!mU(sI;3pz~#XAw0(6QCKfH4D>xM#~;aW133a+P147T&-Pfl*J{o+CGE% zUftVEbYPC2(avJs_%CeIP8+E0z_0f&GZ+>f`n7yUOw{@;7S@89&jvJ%vy5lD?3i9a zieSY-`X1;ySZZd{C#<<7esJc3B{L`}$f;Q}SOukEv&CQzmTY&owBCK+gLf|KxZ{C) z)pzf^5A~-%ec%BW#)61`o7MKNw!+?vadYTXZsRu6m}R()nWB#wWdIB(Zq`=#$NJ3} zwRKTI#$3Nqo4P#>^`Eo;(rOS1-aTngSC&J%=U7y%ub3HtrcmPZC~c?>?HPdQxMEkCY}M6k7Xv`2~oC2)eAhJ{*D@k!L=>l$O=-@ z64`dv-M%Og)cW{-`Q!EXaNO<3dVvonhfgK*Hi5zlCLXN)KYu7Zci49*^ zF({&JTDUyFY{7=L+7XYQ`Kgsr%d}$)A*&=b26}G)D5H3R+*dj=y_{qg^BgX-6cIE#$9;)cE#M4{k zq8fcdSYuvD2MwRLiT6WBa-u2SobJ{OMrQQ+k-acvmmg0n_@JDYpe>)W#u&D!%Dp32 z6OIS!49!$+YWv73)w>qYs_=+lhzH} z9ippp9c#0_?QaZwj`mk)>%uG62yx&+$VSf_eh>LI&gl~m#%hcFkJ$AvR|!bs z(tjMXD|km}L_Omq*8)#9sL4i7rUPQ}jPQg6y&|bDgFu+ISyP(tXs=pVU9-OO$kM{x z*v(G`l;)Ham6jG%8y0qkZ+&h}`t;4!FsiTJ7d!hZ?fKwQ&65fm=FG@|b!d>zXk@;3 z>zTy10Xxtp1St-+g4w@ z!LY$=LQzpcAW&#CvWk5-Ffn+qd~*BJP0O||Ye8h`zkdFv-zX%!P zcZRcqk8^f;dSFS#kf6{s95yg+@=c$v9o+Jfwmdi}*tO*cB5K?~dp>q!TV2Yn2Y&te zPx^~{4QI8)%!kiwkAF4kw1oO0wl4XM?OVvNKf=GtAS~Ouwn7*k_>|sl6G7)qD8fBx z8^-J!!QPIGhuVg@v0b}KyQWu(T`o@3C=CMI-3mF!6VLMzQu&H%_D~=%Qmb_#2Wuk) zXb5oR_6_2ubBCiAC1=cmNYYN?qV3T$_iVp;`H`*nD5Y@epJFSt{cMxAS)4}icmXuu zuKoq$cN4t>atCO3EY+cSkuIy#7cQ%FrxToIhzxWI@*Jh4%kjgNI*!S3m!53}Zc3ec zD=Br_6Rf(s5QP`XM>nt?^gN3;dpfmjE+b!AvV%Pi+38)wOfY6M*|BYYEP4BO?af|; zs$C0>@f3U*>#50D2Oq^d9>P0D2_~VG_iQereh~4GMo`Hns0v8yI+DH96gxUHI1pez zJ;=&Alc~}=Pw=5HhhgEN*ncn?P##csc$#ewuI^=?i`Py|i}&>2?x&{Rwm700{HZg>2Un-2hvfKq_)Q8*Pl~>Je7q%&c!2ZNUiHtg(>ml&jE~@pgo0$C#ZW=Y zhHyycXxb13AWsrZgt6r_(t=%tLt#J=N5eogvK1FLUfr;=Y;5=5gOz0!G5Km!ZRy;G z{N|Xm;ztREnKeKZU>tsmwc=*1uW>>?@1gN{8I5`mPhhNUq8DOUg9Q!2{FKR9YNJ9i zji#U^Q&1w=^Ed_Q0>^F^Mty?nFjOeq3DwetQO$2cMfHY_^A_}WtC^WoCuDW5*wM1; zhK=GhOWIhaYD`=}U~T>6nVnVU_`K-Rev#F+P1DwtrW=jaKUZNadkk*_?>nB;8SjBk zLC!Ji9`pyil}-f*-NVp5!2z!Bp=8pe>Kj0p8fv?+bxl*CF)AQ9Dkc*eM{D~+MOmz- zr1AcE8}B&)ox{`FAE=>2d&?k15%9M`ub0ciLa7>pTs|$h)ll;Rt0B`4AX81C_7%HV z`xhpCJDatg=MF6(t$T4Tio& zvvM24!xv1tdTns%N8<0Nccj^lg&Wsb6)ajjZURDW@t?={;o5WTN##Lq-%CPNdbu!F zXcMjx?&obg8qG$>C^4gz9zP$*8-`GW9NGh|ND2w}3=i?_L6!{3!<%_~upZ1p32Z(_ zh#5U5W{EFT{Fy;k3`<6_&?puj5*ofFka-50(_A=65Ym&CX8y%_@cy zU0t{;BlUZE1@2j}sw)-ui(lxMU6Y!XGfsPM>at~16N{|!w^NranVOWJf9ajZtCvl+ z6i<@g(T@~ddRISE%>LZ4bV*}kK|x~Uk|m8v`9u50*?JoFN4B+jBLnPa;iauOM| z;rj}Zk(h^=R08ZJ8yJc=ZRbym=7*HnO&6{LT~{d)_Ql8v5h6JJ?pP#gAEgx?7$?v! zwh??%Y&0RBDON$IV9xTHD9=HgDjv#tQZ<_gu1ap~xq4~-H9b2DQuDUlzhf|F~5m~-$f*_noL&7=Prz&JyHyKygt zRb!9q!@WoNy^;K0e~<`<;x{9=zGLK}by+gCBmGSU^0UhM-I ztgmaYN}aj==FM~0r5f{rrwPpFAAt&4I1E&?E_O0?S!JvM5=`67c@NS9HjVxW(fRFpT{ih0L zf<+vXvf728Y>@xP+SOR>ISyF~(~Wol+z#1*WJn1-j}d9aSCpzUnoN{xh#G`yiM0Rm zZ7?)sjjwMK+t=VduU;(n=Ba1s@n?DdJ;c z%FY4+fkaPyu);6Ch>!2+@Rk2|^wwoXRaLa)$bS>p@O}x@EqJ=6DvE%Pm-UZIEDHfD zmi!5d6IU~&3-wD-3KU)qs_dh8rD4Rbj7OA`vpZREcgHWCed@^)_;Lu^Zg$YNP@g$u zMFVXk^Z|TAT(|>m&|%1NbXhm)mmngDaoPsEi!w%B-d#kVtIJpor%&%UH~OA&(8n#o zdf(~L^I^P&Ne(`v&ND*WlAu9e-oMUkfM@XYgC8}}4_)Z!L5~r8kl@nJ9$atwWrte_ zYKY5rjPGw8G%g+NL(q762hscWP6Ul`v5nM;&THUS^Meadr*W_+DOuCyJ;_nsPUbtp z>2!6ZgH8csT>;}}2qXlDd_dbjIGeyXB8ub{6n6ed|mWJdP+~#vk^%? zg;032Vxz|(FL6*H{F`1L$QLSvun->?OqOA(NZ+r_Zg8j2tCylIk0> zrd1hJy*5ZwwU-@pUfq_Qlrd)Z+T@hRmM*Q`u>kOX{?GIqh<*d0Ed~z&W)M(I8BSHu zuX?JDVW1zPc~oRXs42|!U(hcNo#7+Wzr-=^hmr4C10)urM96jOcNluYh&X(gy6{Cp z0qvBX_$i5P1|TrtQUvB%k=;QefdL-KoW}>ACXE|1gfLND(}bl|{1$UadvttR*?9bk zCdU`$RiKWH{1_c~{2@-uK^NQvAJh6QY?Lob$fF7#i513PflH{D;a*Wy-OHl3`FMCs z2!w7l8L5vG6O3a`V@F4Z#)icX?PcE|X>?e|ZQ-{>;nbt&Kr$#*S>n6~GL{!XN(Z{?8xTtB9VIc*^r3 zbkC4yIq0Ka`N7x<@}h>q#+c2*^~|(tm@D-x6Bfvq#1o*+>U*Fb3CZ$tF;~5v z&)WZ^IED18b(NLts;aN8th}~5ySh3%tGZe~Ue;AnL6Hj;6pNqih|d2g$`oq(>T$3bbljTp zY0B1x2X-e;ncN4QJ`-+3yyHb-ybvTfq#wd~$C9WoNL_>S10XRZzsl`!3h|qd)GI zr!>xL0(~u7Ez^J$4sxz4z}diY?{9!vZKMEl7@dMxkaLdfy99ZybtE0Wuw5A?nv&qCIs5x+ zz>mD&I1sW<`dkgTsHcd5-q|Yu!S16Xd$u#)j)DXtU^pjxEZ|X4_qhWBxMrYm95E42 zbGF-=A$VPSQ z=(Z8hh}EzIQwqOG$l2t-a|w|^jv=^@9C=X`vO(cImtO&=I|q#gG9ki=l0!08x2=%7 zcwxJ9gg9|WFu6LyLsTsxCM`I>eWEcgF=xjOEn`b#O4=u=hNQgS9{C#|&&5TH{H$r} z%6-P*)kX8!q*R}kJHU?vvGQu|D?>fdMMN00AJ&X}cJV$#PG3;hy3`TfAfQyo{3UiHV8% z+j{2YHa27>W+qn?4+C>TjtUcy@PNhF<0H@J+;$hOpQ~gU2QgxKjSf@6CY-e#;c4bL=Fy^Y;W6} z><6LAag5C46lcI4jREKfq*kP5VFg%GQD~1u6e?K+l~xS6Lcv42^g!ons~mb7(dclo z1O^4TyiR5doV`X%X1KweW3;X8e(kmHd)QmYx?g|2`?zMYz5V{V`|dmU{wbPo&jH_c zkNs}QP-8gH1yL{qmMMckoB7%R=EU!!09>b0Eb6S@hkq#)pg|Se% z;t-lZF!)TZdB%nfGsfoSjg@D!t7gtz-NLM?NyR#!^~wjdzpHoQ`J(1J2J%4~|C0UP4ee!WG;ce2TJ-+|0m%nFglusmNs}mq~ zk)_T4S3cTo;BDJi*fXAlz2C&gI@~>JgpY2w4RtXVg(X=s4SHmf!RE8%j>tO5YgkzS(RU!0v$T%3_*)xK(8pA;9D)IDR?xCthvzf??V$Lz!)^r!V)v>YYEp^jl+8d7$UzKQ!#TV>{AwNA1 z`RPT6{Pd!0zLv;G#TQWDHqhyJzoP!)hpH#&ZA54~^_O5utfObG=g4tcKBfKb#q49r z{qL-~?%c72V_Cn|K9P^k+FfgD%$e92U%Pu2#+6-aRVD(fL~$w(9gJi)D8Tq|CRCyE zcazJZUHVE z9ZmRXq%DQC3h9hnfni4EL1%5)Wx+D2)IRxcUe!|h{OEc6LZhQYCl<#q>JEvH4#}f70~dV< z`kC^aCi1!RLpkM~qw2~l=Sb5fzHls|@7;|X&h;f6%lQKfKY1^U_`Q5bd{bUtQ+&g& z88dd_Rd`pO?R9A?_8ZkY}N8_smVSGtu)xV%#sQyKAe1XvLx{@Snh6UgpgOJC2IgKXI zHrTV6w2iEwU^09#^1zWPpFm#*N;bxsO?7U8U^cR1ikj`sv%7!$obtrpy@y$d_BrO0 z0Gidwm(xtN63s%?575f**J{+s_GW6UAZWAbQ>@cw>G$I|zh9f>XsiAOZRKBRO%&zZ z?FA~$4zk~^p;p$M4#uEafQtrj1&O*ZQL$*UzBp`JHT}dj^4`0}9 z1u{G`A|%Ka<704kP_UU9oJJyedE6yT+n(poXx|>R=H=xTC(q&lWD{@VSGdm2M4Lly-k2b@UjA~HsMMR4gcW_ zf2d8FEawVs8aV&_zqQZrN1G`7o7MKXGuNAp7HMy#k1s79pE7CEzO<6!j8y9+J_kK) zuWNJcC$Mih*0{8YaLW8o^N!XY)&>q_jpI^~j!$=ND&%Sm4e=90Lx7Owp9I-~WK@K@ z4peuAKB0^lY#y_hl@+Drrlb|5;s2HS0rPjK7N+9=_!SpdHfB#&etfJc(8tr$%QrG& zbfh<8Hhq*jLwagdgqH{Y=Nldt9vvFs85WM*PKeKY+`d4Kg3PHt0#8LoiWIKI=Y)Sc zMO&*~s(Vb0+VbI{EeL!B)dMZ^TXtWJl}k^gJj~&|S@3gXC7~TmY{e$b^n3$oCj8gK zPK*?ZFJ*=sLv6Y5epJGCQpXoB0O&gp64lK@D<16f%O#zMLdp3#0O$90rp@n{$Xzh(l*Tn7xQa9XNJ9 zC}c@Tk7{o{_#mFY8_$31|M&BQjT8cc=MU`O%c9%nzkl|RyL#N8f9Wdu4??nX4y%c? ze+g*{?=l2V{882{VpTwjI3&iI{v+7P{ku-!(;nyHZ-1_mg$G zGiT=FDVHkn4w1iO0`DWJgRpAxcc7OTy#t1693nHRFBQOrWfEwkTg>|1WCXO`)xN{c_%&PkKsSD+wGJA;FfXx&9I)@jZZ@0Vt8dO@$a5_a zs04G$&A`-3Rt^Y_QQWglQ_g*w=x0YVGARZlL`P$=?Wg0Jq46ik({>O{a}E9Vqo< zZ~@7(BcDfdnFNy==`0<|Wikyqtbj{jRA^iG=2>hDb}vY(8kJB~V2a7|UMVNk7U#^H zmYiCjIk)8d$ne-$%UE-2i!~u3HgYV;$JiZ|yR~;9YnpY0;bY0|-|qffXTp68wTpOC~6n5EpSNb{J6}@k*;1ov-H(P;r$y;#GiBz$q0oW>iFQ zAYy*Nc;rSjxI=! zuI^}_T-_8B7$?718j}k|(%k8#ZPnA_;|dbYax-hGESuF>kcoU+14rde+S`Wpf>9{p zJe(5^DHxSoAQK1p!(xrm8Lp;7r{*(qOjJY|;zy0l=oI{6&Lyh!4GZo!3++rGm|J&A zT(;d@xT312yQcf(HK*oU3U8P-qs-d0tsp*fRJn36ZBf&d)syboee+K{B9?`e?b^_` zsIGWdP<;?Geh&OWdWFZjCJ9@K&L{jRKun<#Bf~1PXY0ACfqn#Re-p3?Org33U@HXL zVDxlXQ#)}RM4i;jua_0J=}I>sjw~qN6qFJe=86p`q%+h-OBfAL4w~&44IS@CaYw|X z6gK;X9FsX~hFTeK4qDoNdHn1u`Bj)An1W=*Hdt0kHI4$i4xUEG zK^{SJ2Pi{4m{x=~gsT8d2n4VLHKq_ti|xTb-h{{_2jCj$b3XXgH71K82L=Vs0EW=8 zfk%5M%wM{G{nEub9=nV33ks(tSmZNOnD*fW#8s_3Iw`#cG1m?AYJXct?R^&QeNg=X ze%>f&OuRQVHDn?oWU~XZ1#&TLh^khw%@YWl$HXhNT~IAGe_!rdgZtktz!_x{Xb#b8 z%W-TWYL1zYmhGYI*0K(%+&V9#G-~m*o?VALKg!BqB=_C5Dy?M7q_U)v!>dEK-|{)d z!!w%-JoEK9y76pAayd}!k*|rPncf; z8%Ed=%@}>wdw59m1<6CI&qxbKE}(S$6YS+OqEZm0IW&V?zWH~wz~nNEXJ)&9&kUsN zwA5TyG!FbGhQ#Euf;36oDoLTyc?IKTBsz6`*-B^CKL(F4n`{d6ORdx{vCOy--_*%f z#_+(glkM88Ml@O+=#swCehwZ9MAV(b3KT%{C96ej4Mb`zVo>BEvVdtwst`$HfzL5G zC^8}_CO9S@#Tp&%^c?2|rf4o=-C!r{@+k0uuI@?56|jH*wb`lb&N=f1r2ejUEfNMC z>G9cgB=A`_W=_3(&H!=X5$S2|jQSU@k^My9srj7sgO831q5)>dP?QLB7DptvBaZm@ z7z%R76y#N8kw+;iPB6&xevPxyB1v}iAcKs!?Ev#<>XDq*da_e z+=RJG1B!WTd*$-jcl9rN?7Q}%6n0tcJK9TgVze{<91JLgd4iKdF?Hd;!0L-#7Jdr| z0F=UlmJ}dK5<=sV&C(I)J(T|u3r283z0zK`t&^>F%mmZ;wNr!Qf<3(>d}GI}e;ub! zhq0-)RSOrWawk(#(&=@aNA6bNg{|;feFO+S=1;;(AZS98Rc!p#7=a;2EeyPcby43C^aKN( z!v?xG#PudkNXhiw-WfQmF*iDLjhy7Pefn=DK2_^i-NWmm&~3!Qr;R&h-marMCCh#hqax9ZPQA z+9)a;S&P;e7e}GxtgO6T`#FW0`{SK5&(HF_;RMgmk|7icr`&q*$L45B0T2hURfzyk zgRAzHvbAJ5v$g!tUBmOX1Qg~Y#18&0p1sB8;?WfmET-Tnz9wBEdyB-^+t3iqddD|n zxe;=@s9wF4(^{*>FKveK2| zL`KYPpY}8KE#)_{VAZbSqiThz8n$apd0K*Dj+78CP7@w3F${Mb3JL%-LfK9-#*a-- zh>MMO&wAqJlo^4X(RUG=+PpN7E`?#A3wCRxdwXq<4aAchC zY)jOZi1*o#{Lk#W_Z>?({_eGF-#MOqEaxQ_(SMwUpVgMYc%IXc*tl!@w4I;@`(c&l zZy#lUg!@`|a(?nL84+mDY6%1mpX)d*X~`rsK`DWm4B9q!6U3i;DnMN#=1@_QXUkwv zz-NjGq2J-5-$A%?g9l_ozvRStO1OZ30$g&!pof(lz>mDFYE=l|C+Fm1A7QOUbtPg_HK5Lg5c|YVW=Pi;9RRLw{jI zg*!kbvw(AP_4M=%^b8D%bf&3g$mMLNXp?Yf4(UtD>{qgkoXf9Y(B3(5Z}jMg`?WW0 z?{}|YD>ptf=V=t^e9vlSaat1XOS9#V?FHB?1BGO(1t4k4O5-p`V0JqaL^-Q8v3w(C4zpL*`x)YsHw>T6Tqc?VzQkH78NeeLRfoB#dqE&Erm+TZgn z*_U5e?+`VQx8NK31zyjw@#2%rfsJ=R@7*%;d8J&`ls^Jbh}@I7{^#-qF%TFpRsA%C zet(PKHT?Hyt$2WdNK^3^X*UE)XP!t%UOyrh7-@ttU&UK&PoM4Ymv-AC@vJU9YdxN2 z7{u*kzoYb;coUTgfMlma z0kWCrShI+5o=1dj^Nc-(527*N4Lty+9(U&2J#w)Vs13si~gTN&jwn6*zAbVB^q*ImL_on-I+kHhoN|Sa*}ONpI37^ivCaJH&fk!(5#w!(1y%M5036GwiZy|uv!BN zy5uZ?bIMae8CywiBbWYMsV*$k3!1AAz(6?>%ZdTn+&XJuHk#mm8fiv&f}6Kh4Vm$qLl)H&|H!nDQ`Iqsl$jzCN3^N zI*fQ>EL}$d>;Gm|R}mIiRm!@`D^`}4uB<2r78p2S!UB{2jW;`R>6jzYR!XGn^rm2I z)7>fDosXg&!C;y`3JU?C-4PFRpL{`T$DTrd+juU|L_$`?Ly*=PpJYtIwBf;yPVLc* zS`PRVw;ek9Tidyt*1V`cPRGcf#1EUkXK~q0)DCJh?N0(*_vygwi+v8fK%Y}~8%WUZ zvX{WlK1x7Mo=}M8P`7km#QRb5jzi}a@S?&LBroEQ5Q91gGkBlX)VVB6nN(=djWHK)U| zt^|>oOrfCq;GsY&RurCjkRhQo9j4GfL2SbWCo7%*aAY~Jxoy@*5*Vim?AWXw4O9<>8Y5$x!jV7+f3U+vb)v{&r&u}>Wu zNV-_b#jGweHXzI4FP{<(hM{<*7ftF&?2xAvPbvdCrYP3tC1wct#5*M-x{ z!SjU=aa-tThPW+|%NDs_VL&s64pfN`-llEW#<33V$S0rBoPdAtm%xYZEQ54z)#}i`eP(_!PJg0jLBWrP6l5LOg?K@UH zWlG7h<9n>xld|&*^W|S2SvzsY^t^S4|4}?Px1c0-JmJ;Qe_dLY_D}m<^v}TopW*mr z=oPWj2iin60@Z-C2M*&F@Pw^SI;UL=f2^kvX65+y$ut{CKqP!Sk%oE8!PKF)I$+yV z)1`A9+g^R^jGqmUrJ>*29I4-41sZ^>(rExz*ny#jEOHCx%V)Yw$LC8b=F1j7Up^Z+ zeEED47D9Y}6xVwRMK!0%{|i?UDEu!m|1^;1LA-z6_TtbK;Qgy}74cfj+U}`(U!2sY z*b9ZbNUyTSla5Sa7Cq+$yh&v6BdM^B+xw=O10*~(9z}@xOw6WvNj5I6>-YQiMO2Im zi1wAms!4Z!ckda4p-*8m=1_lYf6%62Yo>Rg?hWkg40DR!L6R&u#K|rYioh=LemP)J zGDboITOdau8GY~~${ZNBZ{P2Vt3}x_+CQ>PoASuX@4lNchbeu?0!L%pVf$K}2Ytj( zh_f0ghlfK2z{`dtD2&VCZBe*tJ0a7NlF-(1B;7mG;At5%xwS(3wodGjJ!Z9o&umBK z>$QA!6!<952B#|@$5liA+h4Xub*R@@u zW*>z$6MNI;e0%8wb*#NteGTUg`2L!HzxtYE-iwz$R?gbD7_Q-KI(n5{Y7~9_BWhV=FKP83Sl9KvoDcK5_Xdd;)0*d{MF;kG9yrjs|3K$KFc|8t0EO_WAp1F6qn)INKlC?~(5XkrfF8U)#4pQe?RjRT6E z)3Q+hT>RKD79wScFz+#47}ZHa`E%~$fqM)t#wElFI#Dt7RVNEe-&UNI;6{^W37i3M z9QNg4l33kkRfD^%8t=B9uuxq-Wra>XO>oMkMT5#3czdDRDt_#7R5EzSqWg#G_UJSo zBW9r5j+C9e%sL5PGkF_qJWPR9tqX^GR@fnh$VZPR@o;p^=$Pm+?!|2=`OOariAc9$ zU?T;M`5k=x=T`_EV~;)hDEb_(8M_)j|K$V^J%u zWl*AcsHsFQH6E}$OqKeN0jO70soeO&==S{zYF68Dm1d~Um3x_1L;Hf@Xb4^o_iD(^iDj87l_kTr8B<$|Ux#NwaXb|9-LO?U%LVg*o~7Z(_b$#|+viE9klano8W~Dz+?&t z4nW45!H7>ndGM*^)EFrBA(87I@p%VyX8HZWs86B6JaA| zY7DJYCSz zM4JNk0`rEyxuY zMP^QBI5Xmz+rqYLf2Ie2_@Vx2^wDNskhNeT>#Tw8IW|hvdd$~^U7Pme`ugChOM`k;9`%UfB z)}&@bwQql~dP@1>IRFTtPA}>xnGAkHq)^N)Wm$TjE1I`dHlznHqs0YYKc{Z&@|Z*l zkqO2KSLK0V9b!qYV@eha_0<95QVpw>Q~NgbHE!&Fs$}Yvu&QNK%Dt5@HXdL8*j0<} ze%tg7+t}1yvZ!P4T(yH(&jb%UE*xlH-{^0$}7r9gRb}TCCZql}XV|x4U zMav#veuDV)Tku^C=R4F+9D(l^%ZQ+cPWc(iRqu%HL zBnFa2Pv5X%ddkF!De^4DKsK*xWkqQz)Zci&Rn}wwRMK(rzQtMylem8OW8giF4Kja#_^S8jJlGS;df(49G(`l_YD851)@jTR%%63g?)@oK72k13lRV0dPhV;=D9WfP8z*5mV6bx)`Y>kiB- z>yF&iE9NvDRp0&k>#q$R>lzztGhTinIq-gqLafv&z6v}quUdu*>WHs}>ww!7 z-SN)4;Sjy!a1&AmENrM|i`kHq32-ff{|vF8{qdVK>0geYcTf&91^C5;;?c`&H+Ogc z(>r&4@uYPyqrh=)e@(tcMT4EO5#h)zvVF7cw>fpT^7?Gv|A}J1_@Fcv*Zh#}8+HvU zpqnW6iv7K`gbBOFeNvDV{NwK1jr;a(-AecMuzqHe>3!kW5IV38lbt(|xsjb-1XpNJ zAL|!;ZRs`K~BG56HsLw=myLs*1CHpjrYqP zUsyfm(%srLzuP=&XD&YW?TJUIj|SU_n&ZT5)I|iZ6OHf;2L?z6aFLl3E&lCMys-u} ze%z1yo@6JHZ}xHMPq1_mzzlZ*SB(l9SBy0TaKcQP8<`GIB?9#@L)z_`T9@D5RCY~E zQtr%@#=H$P%dVN1JfEE`oZOX`mTAqIu_P^x=xwt9QC=(WLZ3R~c8E8Bu}u2u(s8rp z7M(Zm1i&jyZoxb-TBB*^ny9y=Rx)E5B^r3g3_;s6!8PQSzw=Si|1r5`ph|l3QlH&! ze;j>LAh(DK;u*Zw;JwVAY+s5U9l?0^rF=(c!fY`ErLw1j7VsBslvj-Bz;CwSqpG(v zrLY$3SFmSAwe_~{a#b#So;H@A8~c|2ORWU?I)y5(qZ5S$&|OXk=q|{e*4WMpWk@n zm$x;ae(08;Jo@x8rZB%7{(8&JA8sNxI|`~EP(H=m5QSq+8g%hbq3$7Nm(64&dHXZ5 zq)Bd8f?xVR;?tQ^U!Rj(UoUBh75r0uZf;#&ZZ1@1^fN3kN-$qLb&nE@odVt#T5%F< zfHRq>kyrqKO7Nw-pB6uQ8in27P+%2y*Ow!OgL*VdG-PggSh|2JB0xU&c!W^6>3F(a zAERFd&FBi3S(BVs(DX(JY#O{0Z`Rd7{$!Hx5k?UaMk4c|_BWz}?I!ZO>)F18V*e0r z+u?PPg!knEX_BFpj|ay@jEF(Vx-wb>ZcajrxDSoHF^9bb|L1p(^k;0cZO{=Ap$O`N6`V`m4mRZm+bGv@62YAzxATbup;-ov5Oqto z{v2qQgm3sGw93JVTfCbIN8xY!7xxeUhy9h2cG^Y{Kq556>khg1ihCtS>L|e#T=yW? z5$wE_>nOo$hRMM#&k^<+T14AupBaqug5AOCk>drVD7{fl+wOUFkCZK#I(l4iLG)}& zZ!~#pRzUjvB1d{7X1{wnZRc)%R{Q?`YZ~fvoY|F_ zV8#10*(K-_ct2H0iMZ1HLxa7&gh&QZ95=Ec6jjFi{bbkcSxVc^_S+u3t-WUImV;ZS zy1jmK$Fy0ikFVSE==y2pHCfKKBcId^rstFTAM~-FLaKDp)abMTN+C4^QFQBb0>;lM zt_$+)2{dB-X)FOE!QLEiH3jjp3^V{Fi9vN6N`GHU9!c4%977rJ*0q$Ws>#a2MmIHN zyEUw8Pt(gYcU(0$+1V!hJiN<*w6*_Tf9m5otUs&Tb~aqU@A`)Bs;(Qls@&hYWOm!8 zGn@APdP{RfO}6`3&S1}Bw)hgyLh=C5dci3%yrD>I5BIjSp*aTCA$YLRRqcPxN$ZSG z56X{j)MjjIIeX~(Krh~hdb?QP|7p9bTPIhy?p?a!?nNaNN(S3yL)9<)uhjJrPb+l% zKsdJKq3D7CkG%VV?`r%X|Np$M^Z(UkvT8Aznp&({wfrfWuIqVS=g;fB z&biKO=WqxL{*eSXYYzPJK>bD^RBj|cW0rXOBuH80*@xR;gY|Bb48Q;ybi z{?qx3e{Rje>geB((sQ^8=AXlta}Lknnf;w}fBzi5e3^e8)4XecIQQ5eqnslH6Jq#g zZv6|a;B|ZOc?*10X_`iQpU55;9-lcBezww#<;cCVH*{bg|&u}ks)BYj* z7q;BbSQGSn#xLUvjUbdq?G5 z(BtUHBQG&$Er{xNc*4njPds%&_wI)se`>$+Da0WDU|njQZw&hn+tu$Y%lxl&_vh7P&oe(sKdNsuuHty* zpNDcyWAZ~TPD9y3+-fpq8nNh5nZTpV4|woxd;k4Ec6WdG&pHY9qX%>jDtW-HS0(o4 z|Kc|%{?|_XH(b{TCiS1wx4&6`)%kY}7$2WCF1LMs4gdS=%L=Zq1I}x%4z71jOyu|z z;$FGo{Db3p>bL7}4cUI)a()LI9G<+l`@XEOhq-ge#`pIEKi&V=S--yvTR&%S_g^!a zA58x9pH5d;2`b5?zl6IcasT6_ys4o>d-zfIPT}~*zUhs-uX%5 zIEZTXVtNivjto*}g0@31?|g1^K1k#_wk53~*a@dMby zXd7ufk209CUGR-Jt9oJwJ zYEh5gty<#|_mh@_)-tW_Fs_xf|DKk;9m`p4dy8#vv+a2<;WV3VZ~NQ6u2p+p^EjR# z%D(W&^vyii*7s4{kZ~)W?eS08PZR3_=FMrHZ!Tqh{)3kNf26%EgUx#+jPJ2(XVkxE zJM0I4OUsvkC!g~x@p`hKb`<`X>5lXMcaQsZ{Z)G%U$Fo7!2tH>*|-{WaT(jJC(j1* z^O5I(wzrja1AIm!SpV(9Sk5?(OHA8$|5?Uj-~3y8lJ8m!kZ`M)$X!~c`~I{rb+-j3fd9CzaW6>GkX{KH+0`~0-Ie6Lo^h~Us4|92+w z{08Pb4(rJurm(HcQNlj(O>3H;ZkzjewCAy0w)5Z7Ll*E#^vVCjR&}i3IY%aUWbTm6 z|3Ry$JAhT@X86O7ZlP_yd)kKW)BkMvPnN^(BbnA?|9ttpGbPh~N-~2(vn|iV4FBh3 z=&xm`{zbxcIp1GZ4AU7hZf7wpz}GT1I3y2$qaDU~MW&DMgW#}z`X7dQGQoTq&#``= zlR|hwYng^~S1^5*)mg%<5aI^sw>)D$=aYq?T+8FF!`8g2N%FAD*ea`3Q%e<|!iV^@ z&C?8j@bfTSgGPLWpWFCp15rz!32pJNWO@gx|K!)xQbj#^`gs}a&*v$UL5x4s#xJwO zZ;P4H5$!)tDbywH<1O2n?ycim_66f_Vm<4B&EF0kS$qBIme+#o{4eu5=JUtx zhh-Jd`&-4ctui~9Xl^)Qy5qe6{o{UJe^nUzkx2RRicJpHD@QswL|E8Iy|6SIN zbH{yrj#sgN_)4*qeI&7^!OjS#^=qHUvqD<)wCDX}*z%UnXFqD!_{aFdwzQKN9;NdS z{7jlZ)BY;<1>UjN@w5707{B#D=Jo6NtJdSnzpD2?$MnnZ{}>?Te zpO{l++yQQ2owdc_`~HA0tuYAdkt^YBPAMZ%&I-i&? zbMC{Cc7$=ut=eykxsLCh8;SRrjC4Mfk>(Gw$nvj6&H~pFR&(n)uJsz@EWcewtQxK@ zCK6{Q`z6QI;BX~rhZ5%@hUB&VcKX+ugSp1!`iEbuS94vT?fU1xePoO^ob=CvX$v?P zTwp&#n|_si^B3yBmwKM#I_@F92UGs<;5u?uaGO?gd`jkc;al1^Oy+l)OZnsITNt*_ z`)9*LDf@T!?f;cL^cl2%FSWeZHhi36KC<~vdM5Bd2HFn3W0oEg&3iDCK{{tn{>h8N2~ z^DNFS(t~N4_9)ifc*^iQ5dSk`z97T=YscWZ^i1h#ZkM@6Plhk?xh$1rKEH94ALU;I zI&1lyohjovZ;o^Bl^8#7@OtcEnaeve1_b+{HuAaleF)0%Hz1kz7TUXvvh`Bpa(&P9 zrAy3)mT&&(&kNx@cbue~pUcW1|JZS?CMmgC)o28xAm(Lr=VttyFvG0}nL(VVC z%Sal84v$!{(qNOcVoGHGvz%# zGw&Hor7UQwh3Fg}}!CH7HSU+IjeFz-V-vp%xJ@P* z3;E2wCv#D47IEINh+{(+xz{?Ba<#Hn?`qk>WB8J-1;of?{~spfjm0wGI6+bwrW$8U zsvgX59rGDqDD#P#rB<~3X2b-?=X2bj@249V1@q7M%jlDt?#VUXFO>7=O_rf%r3^NP z$}nT93^j(!9OF?r&!;bz>G}ehZd}Lb?`D~0+=j>a%M9NV_Rky0Hw|NH+e(IQ)4H$R ziqmlyGK{%$opG^T&v3>6AC^H~w?EqmmD7!IN!EwUsX8Dh>mOK82eGW(aFk5(>AjL; zgs>iJut82Tcp7&5w9!MZAb*Z=m@HM_$P&b>jr?YFBcG9tvKTl1U#a6mIn{nmPIVrT z)9vjH@0aQJMGQOh{nZ#upYB}C{=G(~*xQ)CNpd*9J=Ok{@x`PUN{)TAoaE2*_^~7B zv^xTi%Z`JtksX{jM!Jrqavqt=F>JhZn~c}DNrkaT9%i_LB7=NBMO@-;BPcddWRu=NRYd->(_THZFA!-E&w#_3z$i_hBZ^~-dY*0TQ4u57cqb?Eh#H?Xcf z=6{O+5AizG<=4$Q{AQ=Sy3y?>GkwlkoIji;>;GXoP7>OWTMXC#m7B@6N=HSq+Vu^P z+y9UzYhB;i4z%pC6Iix(Q)$Nl=7VM2+0I)lk72FL{Uv)R*H1fGudV9ZhxVgV$Mwcq zpZQs>IqC>!o17 zongr3e!r3S`*7&D;UiwcXMR>?f1$3^X(0sSL2`E zD-NEQb00O>M-aT9+OmcFnvf@a?aN>;ZQ1X%-S7M3US0dWua3iTmfi1n@b6`HykGU# z`%vxomj2y+qV{`99OJlt|AW2r#55C)c|Exbzui}1nTYujl*Oh;{1`ekCeQka^eN!F#w9NMYs}B8MW_$lq z`#Si`&|h9%PP?L5wqSoX*ZBD@HSDh|{C)P{w!`nA^V`Ai8T|dq?|Z>@U*r1Mw0<8G{R{p!3C3sqGQ8eC?GO13 zt^O;{<5%lrTCaE7=W$-&ny(LK{)!mZ*{WYV&S!ZfpX$fwwEg>?zbKF(&KLTzu2$Gn zRlnf9hJxU}vcj*&FYnLSUAXp%=R6E%m5OT9lcBG5dM!h6zVWP&bAxw%f8)4vLxrZQw!~Co1PpkI2 zb6m-%TnWcHj(h%fy?rX5%R{;E{I<+>PT-oR8`mNS6YpTIJtoN{Kb_BMwV5W9t@kC% zqI}!uZfp0+o#W!rNMaY!+yV%brj2bIDNj?ah*dR>j?Jq9h~c3!QWZj#={A8Muo+5x*a$ zy?om-)bAgq&T9Yj>G#P7`&~PHUW1?0w$Etr82mW(Q{Mr7Uu~a9lfEuH2jkc-H**Xc z%KExd(w#?`9w3wb{yD#YDfs#3`0KBeVBaXmCBOg4|Lh0*wAkkVa4hiaXg`j2I3@&- zZA;l#USv7__2eH{{AFZl`ro(Qk-EGTh)4#~M|Ls1u*;If1k-yrW$9jCEZ96<7ao)QU*XdWb z$(^M6+v-jk>Al2paA~le!S85??^pJRY=e82^oQly7xNDJ3B228gB;_YFT(<7upUnj zrVV8{&K)D;{Ck9c{~Y~ZY5sQ&pSx7+Em_TV4}X}$b;Tq(j5a0lxhgcuxz1lDli1&r zIVJ`BF^E6G;`60v)5k%&-)~^&%NWu>;d8n)m^Op5AJBKRS)zT$-7WiB)=B>UO?$U; z-IMFDD?6Tk0*)8#!&CWOqz5t1{(LXriF0){ze)ASsas{z&v2$B&~I@IWv>p-|6Jy2 zUt+MHU-<02=cBHfI*K-TK?Yq#`naf0Td=&GJXEjE*rSE4tfpOBCxm5bYV~qQ%@c@XmZyvam zYfi@o6oUD|w6zSgnBIt6P$9CHS5WPZVSEypw{IHmWqdG}!~aX!XtkPtt2X*BNzu>a zOMH*%xp8A;W5Zy9)C6C+waf66H`IH=AI(I z^K0qga%9scV(ep9a~vYu(t9y{nMD3;&Sbv7tVEn zsRzx;ZE2^Iw+sz!L&p7gi2lBV`7Yz6H`7M{xnO=>&0|o+eAeCX;~A&E=C9%B^ZD!9 zk5PwetS62Q!Z*(Ye?S@B{{Hv~_+|WUT1%c$h-N$qxx{CkHBY7>dFT_Umj*r;>+lQv zV5;85cU4tuzk&LmXJpck5S)Hb%Kh!&j|a7-2lM!8!EGeR_}ipH<7`s>Qy|NQpR=3Ur?ZTOCP{(h89 zf8}6p^I820b^Knwk32wM`e45u)Wv_A&sk6-y}B-9z&s-dC8$Czc5;LdK`fGxg<`O5 z=0-GgG>F6qq#+;WpsYpP>`){k6Gb4d&3@sy2uD29QGg26p^09oFc6cT6>*8lFWm=`Dm>47~w_BjeE$V81u$Ry-}JR!8>AnHAcdJiJjL6kX& zSeI(ITTY2(0>4!uk8TlezvPBLJ2Wf|vi-b{6SP_UF)&SbjH5756 zOxFw)ppjSJxQIatazH)ZsHYqCbfaAN2qb_q-Sbd}8tmkCLm?P}G|-Ola@1m%NDu1k zL47@F%VFtQk9zDDIXoQkApP(HRG<#Tj38!21QI}<5rx3w4RkBM=r-2 zFh5d2+(_a^5;u~#N9CbRq!(p+?Gfo6fdotf^LjI{ca2CC=~3~ZTomP^XipUFiE0u# zIt=9N6NwREJ@u&;>6-)c_9bs$^7bWfG9l%p1n{IR=>a3mrdrC?sa-Fz(( z`#$X1 zfQe{O?|^J9#~M)YKmoA_Qg$F^2U2!m9hyX9!w?7RjHS-lGEiqMbq=D=L9s|e7K%}g zjc67b90`_Xa3+dSg$C>q8A5$SsBcIH3Q>+)P<9Aq<4BJqJ+2b#P$x2U1X7TL5|BQ0 ztH`iaQ2#K0yh&tu49GW}dWYwO*u#lCoVX(*k%%j9Lzhj z9=k;*gdi3f$Pt-Hy%RTyq(&hg>BvPX)}vA6EEk1n;GvO8px$$cb55SfB!-iSHz^gA zn?$)ul$%7kb18RjBodK^e3YXWyF@03A`Y~5GO;F?p$0oerVw`uai3UQ|pcM5T* z5I2puX%!;pnTSR*NS{jj)EJ~72PIf1a()uBPz=hQPn`4XMbfD|eL2=(lm8dWhywX9 zApZsAzn~f$MWzvNS^+3Otqx6`HiTgW(vXjG5PLdpncmFlbS_FkS_Ww|T+qH5DQ&0T z;S8fuBQncJ8)oem$qWH;Gs%~k31VlKpbE7h&xPc{+w za)_O?Rb)PK=SO1`50uUpxtub&l+UGnu0KxsT*~KCKDP?%Q7>`@<*%Up0;U(%isWJO z2&5nfB_PjY+P`>@$d#cYSH&YutZ#3BXMd2JEOLA}>f@3quX$nq7Er;u2M#45}Nv92TSx+;-n=_1#Y=lTkf zBHCBPbWtwIQ$&45HJ~p4p$9jHirf?q^4*k*EEJ#=)u=aum+n%R=SA9 z2&90zR_3Dwv~4Bzt!zXym!n~zo;#`M&I&N^PU4qRe`y?&LHyEMQ1@M>AjVzfyNeii z5n~lGR*`pAxyaqrc{g?5O_{r?@9uS=Tv;wQiQE&4Xb|@v>b$2$=t>Dd=-p8lqd3VG!ifg zOg~~G0=q;it3)2H6?tqq%CQa&VBX{8dz^faQ}*!;6rw_;inJ=qRZ*^LEB4TB9S!oW zrjFIwAn)oj(1z9Z*eUX)i%5(>3Nn$85>%lUTd_x^nmVfEkPPas&I4_%UXP7v5_yVv zYbdjZwmusI$~;S%XDRb6WuB$Xvy^$Z5;fR_-6CttKz(Z|yO#Q%D?llipoJpO7mK`* ziG0wm7b-+vED~8yyqB^;+g>K-%WFhlNkpSaO#&$YY8YZb`m1Tk0cBq;2X(zl-5bI| z-q)hhAW~Z`@;YsKo%yfRme+~@Mktv7265lWKpvK3J?cf?%o3@K5P3_Gj-4WJQ_nkL zppEshbn!Qfyq7QXeiY(CzV~xciuGvZQq)BZXx|6q`5+bK`JfoI>w}FT&WDjm1k)cj ziF`!4kEnCwR*{b@QG-p`E%HeSqCmV)i1$er3Q!7Seo}`<5cktCj6fRlQGzNoV3)`y z6A_3*GO|$*>i#Sj#i#(w^BFNeBj#peZjM0;GC|zU#NE6O#NABXEtK0rxh-{|+!o4h zrQBA^ZB0ZPa!`bFPEFF7ib>Hlj&n2l2n0glrU|3~Nx2ogzC!5QTUoBLjIL&dy4auSoxjcwZ6ws|u_a z`8o_apbg(J{taonsACs(?4pic)Uk^?c5M>*R*(y(zoV}2YDK;ufqapsNRc0?^M@Ld zA1V7Ib^b`cA1U_}<$j`FKP4dx#i+(cG>Pnv0P}X!j@@Ob!yb{JDf4p*GDUs~MFp7m z3uS)I19|o&A|1PUYCUPcQSWc%^l7@F{@)Wox!?Wqdiq0>=?e)%3`*#uBJTcZkiNf$ zC-|g-@-6E`NdhLJmZyUF?+tfRBg$Z&nS^xYin8KF*&{?bDZ=A=!TXr`Rl9O4MR|py z0>!AndTd0Ks7}P{6bZ_8qFkp;$Fu=h#(RPNJl#a8SQ z)s6Vwh~164x=lhhib1|^^=J~+JruD>K{kp}0pfHgPWNU};jEV)A&5deXjhLc6rdE< zs6!*je^?k|kcc$opa|un4re?f4r@dmk&awY=MmMSdM0D1s3S=~lC~UKh%%7($a*j@ zQV@<dkm>+S!|S_NJXtVW6E+v@?o!M&*EZ zM$yiw8j$a36H!P+1`1G)8f*e_`Vgm29B5--=0(%4=t59uzbI6RIwl^eqUe)Q$5PL+ z%fbAZe3Xdl9|4x3KWPI(5seW@K{|3leFL*l0G4AQ)AS+mXnK%m5P1d>W3Y=zB!YSd zSBe_KH2nf<$U0GRldxOV&=8c08b-e1qzxzDh-@%#B8Z?TEr=HQiU82Sm ziW-|QDxpBsxL9lzbv*e_p!^9N(IhI7v=h@sjV}{*67!OZMV*`@>XbZDrzZ0>OU6%2 z5OsPQ$eTjUGiyanAm2n6k=V(P+-T=nOrITtHU4w9upEp}D)Qfij&-6Y=Zl)ca!e@~ zl}7q`nWCnKg5mk$C=``WjP!a@7f|N~)u3G$G@uc?MNK32v@k>=4x2a5l8~{&!Dauq|exiJ)&lYAr{HV1m$Ozf$}qH%gn845;cqEm=%ghkbhPJ zQjm^p=Knp{h3i9e=d<(GRvrESv+X>GGZ^I+%n=UqujDaQP(G<2)jiU<)L2G z4Jl|4b>l8k#nGZ}P7`%YCTQcWq%9}LZCRpL5PJpn+)lZYd{K9}pbaZ&-^y|{iz*Ef zb=L?{t0F+TRa-^fT`Q_ATGTz{zlYfO(zg3zP$jCoK-B%jy`MY}l!$sT3YDTNh*?o5 z>Y;E{i+Y%N4>SLf5umM=2_W{P#Ct3kq&=RAouaDJv0l^@%zI+DsMV>c7sWM)s;0iD zBC$r))6t@yG0`My&2lu0TI+%#*9GdiU82?{pa>g9J)Z)`U!ZL-WPn&Nl%ocXqFyu+ zg+yea0OhDbqp0;JqL7FT6rdb6XcYC5i6|r@0|h8Y4H`wgY$6JY$Up(gQG-TNub7BJ zA~H~ba@3$vRE>!!Bq9SWBiAnK)pD?`8%WPPm2A2U$^f0}LeBYA!##!sP$0rmYvnV<5(e)ZEDG=LbpLqI*d6G1(@DZhKCsGq|T zk2F+(c)yVEmr2+p>emENeorJQ_nV+x)ZQdygEssghV`QMMTy#+rx<()Y8KS$D zfO*|(uv2t+2%->=RIu#frC5(fG>h&*Jw2$WM*DkdV1^9KFvK7cX~;nl%CQa&*d_W16A_5RB;=tC zHKKc#f@L}~3&p5L9U9RrIx-T8$ON$?%drl`jwJR`CL%!Wqmq$WQk%J0QwvT}HK9uQ0j6US+Qw_@XX%^j=Hug;gvHF%` zJsL$vyNE#wh!W1`0vEV~H0- zycpueq=9%b#ET(b4DtFCuYVjSArED!!A{WwLJ$ku&vlU=P>S_v6g|*I3{pV*2h#q5 z)Hjg&VyQ2d`eG>;OMS7-i=~~h)EP^igQ#;5bq-2KHkO09gEpc`^x!azKnij|`N72I zKCB*0`60v~5(~-?$v`oxLHQxgqT`qsmxL@7paPVQqwG-14vjzpC_6L{%TbAXP<~h# zVvvYTFn`z@Y!W?O5Dw}Xo(k$1P94Kb!7>bQ1TjWLVgyoJl!Mx)pArH$@i5lz_9Up=yBq0mMsK!P#iyj?` zL}Y@xN3X#q>=r$SvSTPaCLXDv{FnliqZYJb4DB0B`^QFuc8sMRW3y3+3Q$i%3{sGT z<=82D9K&(dqK^+pEYd-_53bL^Y#5pAc1t=GNY8*C#I+F$Ah(!|8L0!qk zsK9!VH@QjlX)Yo$0x6*UX?sMU9*Ss8LM7@%pFy58$a6+L$d^JrDHR~znae>tCXj!k z3CePRSf}Qr1XXCjF41SzdF0Kb9eKM%FRBy0I0HG@D*DQF(fPC`pEh#6sIN`}`L3Z&*U&z$1$9BO=q1El z!uS&6ELo0P(MyT5bhqeht3(%4_PQ{nA{Ugot^(9|-6jz8x@OVKLJ*4tFmG9t=pq+| zqHl-+ac`uKn=(P1n@Uj)^4>(=V)7P;BOcUMOdEt?j#_NR9?>g9 z5s48X)=J8+%m*>=Ohg)TP=rd+rNk?(7kwA;@1hN>$g_$vtC+vapC-@U31|>q#`HZI zSR?x0Xwml(znuEYH;R5B47A}v%05Va4^rQQRj7rZzDINgc`GPaLA;7OY!dzOBv9sI z$~;_#HK5GHlzBuz{zno(U5}9OkwOsrkqVIaky?#*T+Onrrry=mxtcmxZxsFHPSMrLs0R6;V%}3M z)6+>H?lbX71?%gX9FS)X<7*nRTlBLrs1?07Q}lD8@Q1YNIr6Pz-a5wDk?;9f6oYm? zUymlyFC?NIdqlrT-WStA`ub2rA{NAXDFIcYUyeYb=vM^UqH7q|(REmC=IPaE& z_Pv*ZI??avif$+n{XvoF4{6Isv1k_kF~g5{ivA=O#n>wPQ|kV-LG-2(XcYZfn&{0Y zsBiN|(OY(j=AM+^RxWxw8skw3;(QSW#&;0=OWN}#@xLqr^L8eoQ8f38^w-g-7yS)& z?n(yfyLOBImbC9e5P=v}3O@)3dA=_d-DILf^bh3ufj0j@+7Fcdk(fVH=TDUTDGj9W z4nrI=&>;HfI?=zBi~g0EdlFI9hUwozupHF?TO;;}-b?wtd7!?%O#faZx;Y-iZzkWq zP{e}t{S5bS6y3sdwGg+ZP7DdbRxwny7&;wAXcoip-mlz%bo5biudPs=y2kj^mqjRws2lF02uG@^zbTPOFGrE+D!S$1IXt@|+p<;B6 zKs=b&Ee6TRLLQ1xik)I~Pe229ixHlNU1Ide7vr!Is2Ah#T$Er9Hi9w{F2X@w5nIJL zf@L^@I7g&olNddT(=!jHSSQAjG4O|*&?H7A`6J06N&d)e6r)*;qnJLbPK;hGTdxsF zMGlsuT8!QyAXe{WWMQiqQG!S$paczK9GxykAKKU_8cg@i7lUgCBbxN+CNcU=65|*_ znHa|wi4hZtN-_8?r7<80tj7T?+W_huK>2~8puT}MV#J1ka)V-!4B9@ZN{qqe8BCnP z8Db0}&yYNjkMnCIj(Ks3C;%~r3Npd`Vd02JKFYCGjNu8$0OKQQ&xk@XMrMmK%0w8V z5Qjvhg1n=0P$0%}0^%J<{^O`So@I@15MwlHqbtPV9Mu?;k7hB(Qf_Q1n9q5qk-+jK zl%P?JaVCg4t`c?FCC2gO=X}#ReiL?y66th>6!4ZlUcV?>CdjS+Pj*!2&LK=QSEAI@ zd=ixDF`k0fasHg2sn&5Von>;{xFN~HS_$SidCx(0+qfmezIwi zwsFmK64Kko4gTh5S=+cNQT*LuYkrII@7l&~i88yijXQFf=|98XkLfbrw(QE2F6QjE z^niq#d2QpJNH1y|58*jPtJ=m7l5n%VuFlfS+}4(UFwZ7xTPG@1A}s%X-hN$&NFVF; zw(%~cvo(Y1he{W#xNSU)@q63GyUJjzT2A2SaoKW(%wwz0VteFBqzsl=8N^nIlvGk? zFg#i2GG_+4BH5PnC^MU>>A~FNWIn@8(&q8k9)ISXK#p0=%aRM26DI?R>c>5f)C(!m zUq({XU{a=$bB1Kd5avygiEkz3wsU2heSx4kw=A2DFzZDnKnz^*~@74Neynk2I zS+ppUWtmG$4_qS`Qlmd7lBJr*FoRai2`=?Tq+KjC`PXmN91QqlYyvs_wE4l(Vb+qJfAd@!EBWhVw(lOvZ0Tjy`t)*M+3 zrxSH9wfS2jl2-Z4*}BF3t?TEV$Qnpycm}QV^G3>_k&_RI5W~E`Zi_)IyRUVx`e*gF zx8?%5jP_j^+;gV!uV44&O#AIEmH$(oNYdOt$PrRo^xz~vf8{jEoexxuyIZ##cI z%;>P!%p_$#ZTNF-`dcWs!}MIH{W8hqygays{b_^0mi&1BKKSSUkVCq^eJAqo9NO#e z%QMlwAOEu!`RmVL3)w`vRL)}P@6q!(CjD8-vR-}aBk{!+AVwMgpw zYf29L{y(l`zug^c?zn^#`L+)Jx4&G9TE`Cjm+y7H$R&#X_c3`?UYFNoI`6?Tc!9O0 zY~?6dc`BefsStIL>Z}e{q3RITMIEZbR9Dqa@fKcQqji`%Tt%oOR8Msz-?m4oUaGf> zQb(&ks;`RXIRnS2V^xgmuLh`rDpn0rgVhifr-n+g8m5M;5puK|sYa>eRJRdHhO;Ks;JT+CFuhP{8YMPp^GSmz;Q_WJD>OwVJU8J(q95q*6%)8Yu zQS;QLDo4$ie(ExHxyqGe)D>!hS}1!|o?4_9t1DH$x=LNGu2BVQiCU_zRfXz0wM>px z*Q+9RgSt`Oq>9ze>K1jYTCQ$WE7a|(MBSlQsykJwx=XE6cdIgWkGfagr^?m+yjS!= zRiPeI535I1rFv9i)MN6tdR$ehC*&Qeleg4r^`xri?*;d&r`0oRje1tCRnMt)>Us5o zdQq)cFR7Q+E2>7lsy3+CRIPely`kPzb?Pnkwt7d^t9R9V>V4IqK2RU3kJLu>vHC=P zsy3<5)Mm9sZB?JEZECw}R9~na>Pxj#eWkuu->6;EUwx~-Q{Ss58K8bpKdPV9ZuPVJ zMg6MwaI(lh<`V5`I`QVu{R8P1d_CQ8JHGdX0Woul2uk^mBTheqO(zU)1aM zOLCEZS-+xd^s9P!dz^+)`r z=|=sr{zQMOH|fvxX1zsk)t~Eadb@7aU+5kBOTANnrN7qS=w13-{hj_^H|ZbrkNPLQ zTmP(o(ZA|F`ZqaI@72HSX1!1E*DdlL&*u|EaXj45>#-OyOv5s4If+-PI)-a_M!@J~ zgct`IosENyP~#B)y}m}6(N+AvJnqIfT{ce_>~4e`J&ePQ!;J{z2&1QQq!DQxW%M$7 z8&Ss5MjxZE5pDD{jxmlkVvPRA0ArvLYYdW;jlsqcBhDCV3^RrsBaD&8C@!^5G2)HU z#u)j{7;7XLx^Z_^+u6#gK?vAlTmEkY}{hpYAiQyGgcV48zsga#!8+od8bio+-0mX z?l#IeugW#<8|W=<4vQ^ zc*}U(c*m$W-ZkDc-ZvVI4~!3ukBp7R$Hph}gz>4dNhTVf8JmqQ##ZBVp1Qcr*e+)o zjm8(o4&zH>r}35XwegLy%lOv#&iLMFGJY_AG=4I68$Zk0#xKUN#vbE0X_haHy}V_% z+1O|7H(E?Fm0V|PllP{XrpfzLO~-Ui&kUHI%nZ-WRhHE9%1%0k2E9YN?FVkU5_$*nZ3;@^Jue=+1HFV`$C@!_e{+C2 z(2O+)nS;$CW}G?H9A*wTN0=kcQRZ=GygAw&V~#Zw%yH)N<_Tt^d7?SqJjqNlPc~06 zPc@Ux)6CP&Gt3n8Oml)c(M&bZGS4>8F(=8n=DFr%|Cudjnt7f%)jZ!!H!m=!nbT#8 znPJW_XPUEwr^lI@=7qA$oNZoYW|?!$x#q=Ywt0y;&%D&kG3WCJHk@~yelyw)r>^GUPXe9C;jyg4zmuoBCI2< zp4O38q;-_l%j#`KSw~xatiDz>Pc^;MI>tKIin01z1FV5otTo6QYz?vEtfAI0Yq&MS z8flHPjxSGpw1`EGyHx(3)*sWMx@%thv_3 zRYQk)-_gvwZvL#U27Fu*ICP~ z>#ZW|2J1%aCac)G*}BEL)mm=dX04#_r+}w7Ea9n1w_7FF9o9@LK)&tgqR)zJD^|1AbRcSqHJtn_ek6Tr8sDw#Z>j~+`>z%``)zX8$pu_3E zc+#r2p0b{{p0U*R`q}!$`qkQF{l*iOJnMHct!BB;+Q$=u_ggJ; zuPwHcPW1nd;VDlEwjom`U3%N5ZP~W%*skr_0kP$I=_2RLP8lnqJm;p9JZXo>we~@F zXZv6~)IP-SVjpUU*$7b3hfhRsoWwZa)+#xQn}wAFVEU1*-7@v_9^zMcCvk% zeY$;yonoJ9Pp~K2srFg++4ed1B>P-@vOUF4v(K}q+UMKp_67Ddd%B%r&#-6Ov+PX! zLVLD-k)37FvFF+s+u8Od_B{JiJI9`HUuIu!=h|1;3+#naU$$SdYwTC;4fbnxt^K2Rot8Ax;U49u zJK;_b=P>7RC&D?x>FFHlL^?+~y`0`olykJx$LZ@tJN=wvoMW9Br@u468R*11gPg(6 z5GT$V>I`#+J0qNt&M4@0{c$IVU@(IHx+v&S}o+ z&KXXMbEY%FndqcCXE|p(=Qxv`bDhb~6erC&&zb6+@1#2yIMbZzPKGnXnd!`OGMx*Z z+0I2ymNUnh>s;()JC``~oJ*Y?XTEcpbGei2T;VKm7CL#(B4@F4rIYVmpG#JR&+>D=j*I(Ip%oV%Se z=N{)?=RT+0x!-xfdC;kF9&#Rb9&sw2N1ex<$DJzY31_wQq*LuYb=Er1 zIqRI~ofn)Jo%PO3&dbg#PL1=bv%z`IsdZj=-f-S@>YTTnx1D#Kdgoo|J?DL=!TG@X z(D}&O=zQ#a;(Y3Caz1l5J6oKs&gafHXS>treBtbHzI1jvUpZep-#ELRZ=LU)@0}*+ z2j@rUCug_wv-6AdtFy=X&Drbx?le35oc&IV-*N70*KkeOa&6afUDtC1ZYMXyJ;?3s z9_)s?hqztbL)|d9tJ}@(?uNTP+{4_%-3a#xx2Jog8|fb9_Hui>QSQ-hAGfa??e=qz zagTLl-2UzWcc2^V4sr*(L)p5>nHp5sn(&vhreQ`|K7Ja?*lzMJk| z;7)U=yBY2bccweb&2%qxXS)}QTm2SR!m3y^&ja%R@ahJN+x`pm_?lSj!x5&N0z0tkNEp~5qZ*gyRm%F#QE8N@N z688>wrF*Aa>fYt9a_@G_+4;%jJw8t)?Mp9=dN>~cVBQ{bl1Btxi7n~xHayp?gsZYx7K~#eZzgzt#jXU z-*(?|>)m(V_uTj02KNK^L-!+hqx-S@iTkO$$^FdT>~3+lx}Uq--0g0o`-Qv1{nFj( ze&v4ce&g*e+KqP(NMK0IUjD=*sX=N;o6>&1Bey#d}pFV-964fck3ao$jGm^a)T;f?f0dB=J2 z-e_-(H`Yt=#(BqkCwPh8iQahcBrnN3**nEM)l2qH^G^59@KU@py$Rk#FV#ECJKHRPTH*-Mhe>=1uo9ycyn1Zg9Ozz017Iy^nYY>7 z;%)Ul_qKW4y+-c~Z-@7#x6}K|``Y`)+vR=hedm4eHF-aHKYBlTyS<;iU%X$vJ>GBL zUhj9W+1uys_gVrHPyrn<0%pJp*a0Wt2E0HZ&?yiSI4ICLaBv_ra7ds_;Lt!=plhI8 zpnD)Z&?9hI;P601;D|uaz>$H-z)^u-f!=|rz|ny|fxdz0K)=8-fnx(Pf&PI3fq{Y8 zz@Wh3z>q*(U}#`iV0d6eU}Rua;J841V02(iU~C{EFfMR>;DkV8;KacAz)69mz{!DA z0;dL&1E&Q}51bK537i?25SSQ94V)D?J8({5QsCUcuP9{(|_Dn2_gFXm=Gaios zbhj+qW682KCY@wN5ClnBAVGtGB{`GKk!zxCviFfavYWln1e9|)*=zPp_THVn?<2d} zB%5Tj_ZfTtcT{&nl6Sw2{RvgCj#pK$-h1`xRaNuAI<&ghk@cF@vyQF4HLzZ{Zd-S( zyVe`lH(H;yzRCJ#>vPuUtuI(#w7$jqR_oiWZ@0d~`jYjX);;UHtY2k)xAi^NueN@T z^=qwPXZ?EXH(0;X`c2kvwtkECz1DBFew+2%t>0mNpY=Pf-(`Kj^}DU#WBp$1_gTN+ z`UBP(5$$&ieD#U$Fk7^%K@lT7Sv<%hq49{;KuYtiNvk4eM`Of6Mxc^|!6R zWBpz0?^%D}`UloOwEmIxkF9@V{Zs3oS^wPn7uLVD{+0Dp*1xv?jrG&kzqNkG`dRDe ztbb?yy!8v#FIxZJ`X%c>SpU)bPu737{)_crt^a2Ick6#x|I_+k*8jGC*?QZ0$IjSe z_P9M^XYHJwwd)l^a+n%v!?KykiUa%MKQ}${5jD6OA%zlskUi*Fa`|TzB1NK+h zAGE*PF4*Vnud$cy5802~PuL%}KVpBa{iJ=~Ua>FOtM*6jqV3qO?b*J)W|!=;U9s2g zkJ%r$pRzw;KW%@~zGzqNnq9X8JG3MFlKqT**?!i3&VJthl>LHz#lC94XkW8mvaj1W z>`&V-+Z*<#{fhl{_Sf6rV1LHGX>ZvLd)sc>J9f+7wfF3OyKTQ}-?BUQfqiIq?IZg& zyJsKUeS2WPZr`@=*mvzW>~FL`Yk!md&GzT)&)Z+Hzi5ApRqeG8_ZrPXzh!f@yVpHz z-I}Z(G@8BcVZOTEYrWo@tZMS$uw8WO!6b)4C}CLS&@GzK71%9N=!BB)gjLQ*$oU9; z$**d;YDM9yhII|O9Ve`5{hHRVY5iI$SM40_H!S|`cMrSATrnyN!l<~eupo|#HHD>t zsK^6yqM|eu6(h;7Y5khkuW|jN>nWZZ<0<-%4BQV)C>@L{TEC+8D_XCj?N_w@ind?T z_A93Sdj9#w!S+srx>IyQcd{DtR59!aI{u>4qiA5JXVLXNsaJ8NyyIqTt-d0wl(Miv%z%9N6! zP{s)zHy3O-deRXma;Jhfxc1G-P#G;`Mzg}CAEEGEK8)Kbx-vwBIz(3}96CC5M_I`+ z>Dn(x`=v7)%1nZ#OuDjIU0JNIB&{pnx*=&P7xo9e!^!aIxZUX<&S;ooI&C^~bkZH^ zLgeVAYgZyiC%vvrQWwhl&YH}YN|RsI*$bo#&N{;&DZC=omFy)Dma91Ho_#4bra#*sY^URtIkY<)s%K!%4f_bDe@%- zo-M9whuw<(Owv22P&AT$Mprr^8hlbX5lHTD~rV;G1b%*J)c*HWKYx2rCzIbi(^cm8A{t}w|cGPwkk|d2j%IYjG_}Q;6$Dd%F{u4Iw(&E6=?lH z>jz4dK#8Yf>le!tmscJ8vS~eLme4TJdO1$3gS#&8^%}3YD8l*=+<7@+B}!&Wp^DOq zl9XXFU|!O|x|d^tFwN8>je&r1tST`FM2ur5E%HoSdHHbR-2&{GZPsl<6K zaYbJi=b|rs3^uIfo@*Q(HLwDaalnl@UM>H8tU;Vma3eIhmHC8Cuy`<=z+f=>!Y-k& zeek&t5aeL|Qv+_nix>r#)O!AfRKq?#oE`xhgX=hX0PlIU^(>$ z2c5>CFZ2m?feU36;2=(SWm$xDij2FWgo>^xAB382CdU^!3wlqKG&s;ZZ@q3Al*{B`auufhP$(pl2(m9%>$o%b>~ z2ujpvh>H=fZa0owlh=h3(s3`GxZW7#ZV(UWZ^)8zLs|I-vvTeRZ31R*j4sH3kt@SfePWl%<#uPY@Gzp_7=Xu%{9_n{4XMR6~ui?6y(q zPDLkeO_>Cf$CMLIi0!866IU$*Z%x&cin8lE z`JH$bKx-mRq3-)b-S3BvvX~>ig_$N2t}N%&OSzr9-M#(nPFL*;*Dp`DRF}4xC#+V| z*OrQ4D{dR)74dM*h;?5Q%C-+vqinC+$56M8q3%0E^+kl@dw{s9Sk+W4>pF(IQn;?- zXEslswC{^aQS{eDy!@b?Ymr>c+&pUZ`m4J)X(5@|U3KuUox?vf#SU02zuP+8TXk~S z0q-5##~k!~-CM0Wjwcl0Np_+vl^0r;irGD|g}s-W-o23uMaT8>dkM*$NQdA$*}c`{ zrbUwLmWqf96A1}16wxHUSV<_tnirvR!}?lopN44jZ-Q`*M8D3>9C`O zb(Ns5>5Wd5ZY0BXY0a-e}my1$F^ZCQMoC~iPYHnw@eYO{H8lx>r&w3U_G z%u2GRyAc#eSTDhRIOXxS3O?yL#+dQB=b$-J`ts&>r?rt7bBD+rTzY#W50e-(z{@o~S=?r=FPf$dixpcwpUOgT@*#}^|DN{=-@wiX(CIxo6-g`Tpm zrhW>WwL5GEb6lnYijOkp;>MFaw^V0fnwsU9Eo~=7&;iZhUc?#Hl{B!P z25M;_V1Nnh*P|@D$=qLb%TDfq1($z!TE}qW?TBFLwmgJ-WL|?q@K7i=5zC{uHg(w9 zWm#b4&U%~eF7x$lcf`=- zX_cJ|mL{zqvRZ?>G@-EyB;OTx4a^lyH@u@8j?h=B74_zXX5kUvH3UTSW#PvTNqJ5T zT);Xm^<;!%;38estyn2ANR_mqXLnOOr>^dtG)(WD#O{i8P9oU@!x<+Xh}5Eul)zD0 z_Y7q(+ci?_i{Ax1q;js?GMwO-MXr2tA7eM5bF^kckvCtq-$fT&{?}B1dTBxOgItgG zB>zgzOmDY+yia-(=K;(pZaJLlDZAx+DUMky=X(jqU=Jn5Wl_aUD5t1N8>&egu0`1% z4F$H_>l7ZRyW~arV{XDeen8u}W}z(UOq6scOFC-N{!Um@>IgMJoyyE!t9Q^i+}Z9N z!{1EjnmyJRpNrCFnHMb&R74D9y@TicQ9naW92sHTqz=!4S+3Sa0SAER`g9 zMK#x5I-^i29k7(<2D~X8jLPcBA|zV|$9Sg2%Yem+H+2YkQ-;kT&jdo1sj|*cS!bwh z(v>sHN~BQpL(Mnqgy;y!o)R%sB1X={0E8MaqZmR}U^7q2hzwx^IHzX^2_G5ymDNb^}n5|e`&$#Nsvayyi);L!kei*m9>d-^rnHr23+94X5Wcr(C!`P~i;>il*Ne$yk z4KbMzGlm(kPQ>%_#w`%YL^+Loi~+lCIg z+pHCCCzQ+ImJRmpSp2b_*4ffSuTUN3p&ojLa@Yl%eQlx{Z>x3l=|}e61iR=BV-4t` zSh&8Pznk7>E0aXptnn=A;g>I-9H>fW671$h9r=-$yK9DvT=pv&2Iqqp9`>YqMBGY2*6%I+{fFEtJh8aym--OpX$#~yop zqdk7LoqMUhchH!)y5F9-dMv&MPdCU>RI{!ewD!`68sbR8frm&;r2e5u)k~y)qNpUZ z7^%M~QgsuFm(_{%#5FQaRmB|>$(|hf;#P@t?;cgf{Sv7UAd2c!>b8)Ln5WCQr~7Cx z@bf%oCAzK!zBnI1ZqXFJx{Z8s8^H;!wzN}*6S{e~$0YORNCoa7o;=Q z5h_!ujpD0|#h3GL^jG^Mvw;36KGmbXo~!%fJVSXm*Whz*{!Q5wdcYou3kCMK_;e!O zWk-529O-U5l4BT@6Pby`jR>#0+9q;f3|R5V?j1097@^2qq#m?LMLyC4`bb?uksj1X z>Kcmlz&;YfJ5jBi-G&I{_DC#pJFN~5r(5b9(~w6wt3b2UJ#OL3n-pg7-3D>~zR-%h+0M^OVqv}XE{E;46M{;EC zMD=p6Pl_hnhI(40AEVECFw>O6v6*z9P)pAvBDJm~Jv53`Cr5I41V4%PO%H@3-CsrO z?v3<(B2sHR(sPPP&nKdwjNKYtbQr(Wp6JCsePuVX1K{lu`S9v)?wHkOzcH8`2s50~ zaAa)r4FS&4L?5a|g^r2BVFNphUVKh~!)e=Mt=A z5SAy7_S;kVw@0V26X<)R#m&ONYNJ-L8wYv z*cz%{m9;r#Vhn~;+a$<&Z zs_f^zFaAPUJW4k)!r?$- zIwK6S;h@K-Y5=%0!b<+Abqpm!Y5^eE#a#pL3&Qnmr`drUT@^K=2Ltg)d?7hoZWqgS(>THSi1)$6YE z-h2uM9l24Q$^Jg15T^2OcYsYNQl^gEcQ`VA*fxc@Vt+SJwGi}gcM(iU)&A}z*QKzH zn+eD#49GvmeYr!5wAy?7eMBZ1V}Ey6@kw87!OCq~+8q?0QLLP93rdd9C>92$nq91z zC_a7E>b1K&)EpBR5ux&G6Yg8Wcie(2g6K{FT)VBqPHUICHOoLxJ2|tBEqu#lF<`Rh z2)fmROOxx(D`>J86QtVasT5{ST1?QJLa8=1>2$gwO*=EvnkG)~-#yxABF|||GbYLH zim_QxvW)@y@C2f)0h8+gh@?89!~#3zqB141%&&_3jdeK6?s+ee+dNSxkj zzuw+q%2F{?WDZv)dfht)#cTs^3i0-$j@>v$U)smF5a;fg$uZqA@M6+eGyIVbYvQal zqtHU!bxoMz{+qJWLsK>$i6+eHa1>lj#-u5y(*x7AQ>oEu(n35$O_(}90zYBE?5!_W ziyFlx(F&p>{C;)1b*G7yA1)Y8QH3K~6xaP!%tdRvp;KW_Qf|EY+MwO(oJzBZB+ZTT zO#QEi+7xYmm@m z;Phx8(go^i0LKv+A6G?}7?^!+0O_E6z&)7X3k+e#OhWFc*FI?3a+i(cGHzMvao|;+ z;#8EMOBEszeLCv2OfFR`y1HPxwdxEsE}vI4c3M44lo%7A#s%lwbc0yG(`xg|gF8Fn zG|N8^z-Ryh=0@de@gbqI5{a4}5vS=`maIgOW=EvRPKnUmsQfHEC_M8INDlObY6j|N ze&Ap~A`71*&N5t7DNbOFOi^6Fn!?ags1!%4`S$AJ;Gma3fgnRoo}oj z!|Kg%OVE^HM*=K{l(#DZ&ejOpmjI_e1idQ3EeUYyK#2zuz`;)t7FP<6BzR2%tg4iF zECEhM2pUKL_bx%VCBU*v5Zo*jyurb=tl3DIk7Ma292v8`mLnnyA}!8@K$lXA&daJw zQ7)s4J-|6x_LB@+!Ks{B0f@}9IbaG{vZgbBS=A}3mI7jPVl$ZHDeXh$(%OgM5$!_> zquPg2Guu&2*^Z;aq!i^@-IiHJK(mT~W)%Sq1p&<}0-99>G^+?`RuRywBA{7CK(mT~ zW)%U=Dgq)W0-99>G^+?`RuRywBA{7CK(mT~W)%U=Dgv5S1T?D%XjZq6&8%+6v$_pT zblpr0GZfKTrF1gNWLCG6Sw&Sdt6Ij)>UKP^dV5VK9xcAA&|MAB21sSfYOIxr4L1gJ`@xB#KmQFTv|rQQQ=uGo~+3Prs+qp zt(Gj;67!aeB~h9MZ+;Xm3r~>-6q->iMKc1KW|D4bMv&5sqDr&4jL?igp;;<}XhtB@ zj3P|4xPa1(V5J#Fg=Q2Jn#IM1W?Wim#!;ae7f)zLV47wG8=7$~Aq*EwqG_5@7Qwth z#1V%sG~%ZREc-S`HjaR0=jDjU1F)$lCYd7}Q>4qz%vmc=LnX5y?a#1~O8nTS4U)#O z9l`EM0a?_<^8!4&0~ALBZW7Ao(h+ARZfsBwLQ%T3KU}-#8XeQSM;a(yo7S5V2W(FI^EmY zU}5vc(WX{_eJd-kuHHo@Zc#k5FnV>zES_1w9!S*2@#z8E$#dAB^vJ{#a0Yq`K05&f zvCbN-XNA>J7N0W^viksst)+#X7VMiAJ>`L~38vG$B<#}OZ@<;<&j@_0)p@Ejm5(HhLC-Tw2q@>8W87uUZKzz|H8so?G%64_AJ zYNdIGl6teIUb>VF#}Vfy&UBU8d!QeOgCm~cH9VPOxF>wFCJrWdO&nzInp{W&EK^#l7HvA> z!)6GVWNvBv_I|sMcg&F3*3NeKj$jto9(G2e8EWFIcWaI}v(s)Ibm`aPyAI zW0WS3ftzH(kI;0hyW2h_ zu|4j?AuX6aIdpM7#Q`0{xIH;saXmQ?a6LIRL8y|e4mkB(p`4^cPf2|_H^2=^(c4}< zoWlhJnh|usoMhr&fU0phivcW}$5D42-bOGwN1W=eBToPj3fh_+Texd-UJ7FCHdQXZ z;69Ex==AW+^>tc(d07WoB-z*D;5r<)r-xg}7q#w-;|{R2>&weK*H?D&%M zFJPG(U;Mm)g{{|jlk6#L6q0(aCKB|zeh64?JF zRj(p?aByVWR!s$!Y*OY)(?T^HSW1Xil~zSFs#?^fL_3*!XVO~ABu?YP9xba_$#9WQ zW4MK=hH65w?^;v-epEVDm0Z(r0ydC6G9ywb%^%xlJAB zPOYQ6V};nbiyIZDm8`U2D4s+xG$9rYg;RoIs>Fg}iX?)eDMm0%jaV==AuSlDiu&FZ z6v0p+77T?|FicU|)#>PUV<*tUE`a$cUkj@xPjuc%g^LD4Y@*Q^JVMNC_4h zO-YN4NlJ-~CXI@WCXy9^+t)7d8s-cD{>R2k^1M6e>r;^H%>#hbH zUyAh>xh1_Jn=0$4uweU<S<0r#>1-)U9}(WK%7Ek$E8>v zMp*zn@NJyPLBt>#KM=aNUmsalFM^}sjDtfzu;NspY5Z_|grbfpDlIz)N02Fn48yAUYLEALzAbs-=3Grr}6S>0%;L z+R|FOt7{2r7muhTX#<-YbTh=t?g@hv|fiw}l=NC;>UQBUix&Zi6K;b1k9ZMz%ufLd=;=4L= z9!Sc{N=S-Va&ZoJC24$k$CcnK3gzdMhg9jzWR9R3q-B+H!9Ld-q1=4(#3_ZPmP|Wd zF-afilb1cIk|TX~)7^BXo8+b@NotQYD_z2Km}FRZ-ok*sjbVVC+sf#;rJ3%OCr!oA zG?Wo#NismXf}f@*&e05BY@*Vf?5F2Ixqq(vP~Rc=38CrbLJD6!P4#f3rF1b_1huPc z>8`FNsG$YY*h=ZHmeO4&p+s-H_z6}DJw3@2 zFn)o=pp+N>R_(PnBq&^ z3QrZ&MM8QI377N8_`@8jg6XBt4-$q$?-HiMMXZF+0VJ#qAYDg!Pn%76xrjT~+~~;F zPEL97P9!J3566e}=BQ9jqi~pOF4jqrnthG&PnSiTyA6pbMbjRgXVOCq#`lE zDN47ISXM@C@$zg74twVgBr#^0`7>Eihw3u{LQ%g zJularH3uOKEyA@GU((=|_rM=ZKGF6u^A??*aQZ0}gU1%9HgVD!K7m0xr*xWJZh_xT zA#wGggn^WJpXqsgfMbe2BIm(6j6L06TqntSuugnD^iVrVj@Eg<>6<*qNjLPUEK^HL zo4Q=9DMIr8M`S5s-p7YiBbDAgM_Xc^(mg&eR=nX)F(1Ad#M2-Jy@acZPRi;j;#@E( zrh9y0SSMvr74_k3nU*30BzgoWQ&@D5FIaSsZvg2A>)CjZukxW=#z*X@EAfWj?5C3y zvw^QXyv48JIF2tC;l3k;pz^>LUu&ed_?1U)@%g9@pUUIo3p|~5@X5Shx4~x(NUlwV zqKetmjQ4)*xkd(iq>GN;AjX*l4BQ}L%h zjmx&jIDH-8yf$^vY#f=N5ztim= z#aVje8RtGyR31d&X|T}6m4^|ahtf-*?X2mu!?hro+S73>0)K7~=U4qk2O8-J^jRDQ z@!<4<6!axs<$(goMT+2d0{c~ZT>`}h#51?(==HFJN2TrNv^;4*a;`&Pjo=DS6%U2! z-oHFj5hQCqJq+mJyBUWzzqtiL^$|B->B>wwa@iWg<^v3{3C|Gn`2Yel$Oja7{;q5y zZ`(1GIW!dUJ`&_V0TdtW@|5CQg;BYov?U+(^c4q9IC^y`rz z#&5=}_087><%p8ZYoP}|;zNql*Y`udydNebThq0F@_iAEU-1dYgFe!}r}Wj6SG+@# zdY;nLi=x~u`cxic^=kF;!+}KQAu}$fN{2mpR11q;5#XCE^#08>W5QCN(K%VXgwizq z1WKgu#3Ow|9qAM5NS{zg`Wb^rJ_P_R&qIZ&$)o_xE#u{#u!5)G-wJBcR1Y6%ID|1L z5m?X`r?71}%~3j|)EL$jDTl)tDaVIE66F&hDM&{%im(OUMor+tF0KGcynh>)P+C%J zx4qlHJHtirnw518NoPcjt4342;iN<*PEH`f)p$uRaYJ@yugnHhs?_3-a zN~AN>B4pt}$diwdg$kjZ8#^+0fSGa#nQ{n?TGVz#9m5b}C4mb$T)w(4k3jLU1St=# z!~HIbn#PueXBc5oUo~JopGn))T3nhf%9l!Lr=#fxt>(*nHe9+^w0f(nsJFU`Yio13 z#@%l>8?;_Q4Nu9z*Ug)=5;>%AbTn?wVhV6{-0Wf=psRUBPpRIDJA=dJRic8Ye0b4(M#OwCPG5h!`r#MEiQ-a@iQ=*j-zC9&S<$R+5X$y)eJ#1=?cf>= zUmoLI|9WSJE}|WG58~S>Mg10%r_aeeUCTVx-JY&#p6YN<*EUaexuC5s!KbIS*A`0|Nl!1O%CD0e2fqs!P(C@1R`en*Mzq1nP7b*k&-b$cfstokI zD}lbZ4D`KapzkdMRdj)VP%zMMNCf&0Gth5I1ZFLekN-i}tL|63)R(8uNEa*1*Y98Z za%-nr5^JgGsdeR<&$sAjxFWIA@M@Cf60dMo@#=UY{W@Nx0?JvA3J*b$kEeBj-Eb#^z<>Kr;iyueaz_T z$H_d=Vnxqzv05sgK5q2%TP~h{u*%c#zIpn^DNnZ&o^B;P{X&?hmW-#Cji(=p@Z{QN z(UVI+2zB|@OF(eA@N5Kn83{fYg2~;Y>AV=h#VNBD=-cc--)0B;F}6V8W(RV43FS?F z=0d=-YzO+C*Fd=^P_7A-TLOJo9q7C2K;Kmd`t_o~^h-Yr8R(Z&0{xt3pj;Lxmj%jQ zfv8KIH0e0>EpVW3fdhRD9H?0m= za}4l}1Og>b$%LDv&3%+JRO8#x*vwKvym5nN24Eyp0X%PL@9d>=XC*jx2i=C`X-qmh%Y-4n4HchZNRcnb zI_)O%@ba*~Kq<&QYGAiY2+M!#$p#RH99ZS^#%c8hdy_sNf7U0X}+1EeK!=CRQ5d z!O4~~+9+k}4k%8MdEt=Q(`qv>gTCPJBtB@)P&c?NGExBe^HI*mMa?{d59-Zpf|U}B}_`f`zD2PX_?0ou1Z%;C8z73O-d6pJd7ia`ZTf+@Of7{RFKO& z&BI6OhUVczql?uTFU>_)za{IMZ#1gI#?>e3t}fZGZtLB8IAu6)I%X}=jJor6b-U*3 zC06KF{ajh~CS5U8KtA35n0%{@zt;#8-w4Fgqmys;T6g-VAIKv~nANnqJ^JXQwtz^mgyt$*6d9y)UK@48pO`)%2 z5`ZtJ;<~H?cqZyHKrbrE2YC}EK>Bd5)9B$sG(FU%PR#53V!m{WqaVf!htMiDVN)Gg zM)v-0wHxKzD9yUQRy`pfH69vLaeG0;{UJAljeNzxl8dDJd(m)Er31AAsm%SL$ zMY05e5oKp4Zda4l@EJgM+U< zl9egLL9=o@P*u)6Chr!#t4PB%y9zH*KGRq%a%Kq=l6}U(-V3qCs@i)H-vki?7$W@!>$?QR*X#W$@ov zX6&7J@E1dWrT_g1{wC@7XTCr8l}sl4nM~&G&*XmkouAKk-uaogKaCvCd*_#OU&(&v zonMmN+|MB&ar|xfAIy9q^9B61_)on3m0$kFac`{t_D}rs&zki759EGf;)~G{=EslOos58*76hDUX1VUuf#Z~-u_9&`-=(Qi7&>u-+?#1VZ`IlbV82U@Yk8E!37Vh2H7>+;Q_%ZywifyuEbp+%U5_%+!~I`=Dce zt9D^HwlXYi?Oqs;uPmQiK6ha_u~OK1bK=a|OszgVT`z2H)lSCG)N3b?Pt=Fw_3L*E z!W!UY_UfJcDn(b~NK*cg?( zFwCwDC(aMg);FlV;bZl>7Fa6m6oy~EI?O)t%KeXw&DO(aILwC|=Y|uHZ(jSl4HRCw zw^0~gy^5rZn@fdZg<_S>&BBS4Mvp#%B!vpYBIOsU32A}6*h;tC(j|XUbt7dhqg|NxyM1F7dN)9E;X)gZY*z}+bj$(zO;e7 zC8CRV<-%}sWjI|we?K!W(>w)mxwZ^;S*|sPva}2&9SGcd0)75Ne@vJhXJBIpY82+MBa8nTZfnw6uI~^GPuA{L0DrcsSf? z1Q&)2D;PqdFr2SHOCv)BGc;Tv=o+8}p07n9T416SK!YYaK3uGC74B^nhKnHEh2g1{ z=dN#@WOsti4-IEq%XcmePp>@p;>L3?N#fEuq@U*WGb<;VQ}r7gC#O!;hhvS}aPd5e z99XM%GEYAX_!*8phPjw{{OZOD$sx#9yN4M@vkOn2TShe#2R~3gRe>Z^?j}ZZ3H`r> z)X~X$mnl5SWKJ)G$n|07>HA}2V=RSdS28D=@$mY_@YHgx5Dw?SezVJ9xmscCN8kJ2 zG5kU1)0tYWMie-Mys^f~nW^)`?>fKqHDK?@FvhdzFAU$aaxzBYdqHms-?wryLE-yX zPO=m(t(@d2{J_ddp2DwMIhmyJgDWRf6n^!}$ux!MS3nJ+|1iG=N-q~yhhyJB(sE(A zlFEE6&U{TWFQhV`h%976n+@vqwpgbABA6w@lp6B#z*1mO5rIMq>ru?wubNBDnRLtZ4pm25Dr&~ zXNxPtkDecX6!Pdm6fS{dA1RQ_jmk19_Wx@Mu;YcHYo_>QE*}!d4V@=Xa${%14JbvL zMK493cPrzs6xO)sYrrOW!iUuaw9g}ZOX-=%eu$Uq;OXVci9dFh###bBFn~wa*@Cb% zDi?<3mDTq=bzxZfe-#B|H&J{YQ3wwC*rK31!YnwM9Y_`QJTf4O&$+MC_T(v-&id? zg$12@KQ4(t8c)SA|2Uw_$ck+jnZ$=VZ);g+3!4AJ@RO!BroK+s78y7X4%tlcMd*)J zqGB|BPkrO+64unhQ=6+N#j!Jx+v-T}wWX^gxwVm8Q#Xz8!5a0I;m6LW3z$l#!C+hof=}`>!E8$|IH|epbmMcr=Qv7mmQ~P-d3ixB^4ON~2^zrlOXwHZ(I+~aSmqCKF zBKELOAmOK1hb2h)v+t7r9MFxOIXx_+%=0V5bp)RxDuy6;A;KbTsP)1MG4$|LAoG=# z`pGR8$PFq(kxx?@ioCq?CbVH4u?@tqwj;K= z^5&SNy@HseeI1n>quj5javb{xD#x+UP&tm>q&7no+oCop(x5gevQ2GLq)BC-L1c%@ zP^3j=D6&gsD6+@>3J}}peo?H={i4{b+%JmV;(k%A!~LSz0r!hyhuklUbwT5&;t4!r zXm}ABuSv9uXpe|a#fCLN$5?9-r80eqQkemlp$sbXIx2r6#(J9}u5m}ARO7BhsrVbf z^9e!ujS{5-pOq*T_$HKnI>z_S3^BgXNtB9zUZPa|3#j?D;QOLPslc~LlnQ(+%6>A& z_iYR@zHgT(75@&2Qt>aL<|hT;cS@8B+>VuP$mL`8T-^qV{{)KEU>*pWOaq?WPI{j4_-*@rs#ZwpOFWMI;znq!O*eHJ% z8JUYC|5L_~WhOG2;N(MNUwRQ+h%ap@{1JlRn#!1j&83qMQ__!5eLgdmz4)c(buEcK u*yiTNh1c`D`A_Gc%|4x7%@=Z$b5FiC_RhBrv)_#sK6o>?lg|V}=Kla5n}5>) literal 0 HcmV?d00001 diff --git a/stemroller/assets/fonts/Inter-SemiBold.ttf b/stemroller/assets/fonts/Inter-SemiBold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..47f8ab1d68144fc004b310d65d95180d502b449b GIT binary patch literal 419744 zcmeFa3!GI`|3AL=Wv#vUndyF&N^?JR&Y3gGOlrF5u2M-Q2}wvisU*pzo)AJvsN6yq z5>F)wUFZq9lvI*?;z_84BuQrf-=EK(Gv}O{GnY!9=lgs8&wB0m{_M~Ctj}6|?e$r= zv)0~16GGGgn48=K?$0U<68T|9P7lZgvEbQkKJC!o_D zI_k13hvZr}2{mA@5LJ^eyXfjs2v;5cGjX;r8-Cr;nb{NH5qj2YVVp5)*rgX;l6TIS zOd+ps3jgNAz^L24(P&%`!*%+wE60p`yjpJ)*HeVZ*)e?N#TV7cEgU1{lhB*<-IW)O z8&&0>)$S4U{Q;0~GUB2uFKybU>j(15(r-53Bo&$tA5nQ;wpoN+zyMq@nipT>0H zOaq~eod!Y~g@%hP)lD1dGkw5hGZ|RZ%mn()05Hc41Dl$s0GpdFfvwCQz+PrAU~jV@ zu)jGHc$Ik-@M?1maIASP@H%rM@MaTtXFg)$uFb{f3&5Amw}I=;{{X)=zX$F%e**3^ z_W}1yJZNc1q(@efRe;rHbzn_d3s^_i1D+ro1G8inFeF33usj)fibOhP3)uo#Alm>> zlkI`sWH;a$@(kda@=V}avJdcFc`oogc^+_>yc{?};$GzAayD?jd`4)hzB&PzrqX~} zsspgIIvv#4&YtZ6yW{V{lEvU2Z7I7C>z#0 z*1Nz>7RrY8f%O4!mvs>MyY;&;Y-tY_nti#Axa@8AHsIIxx8U!x_kjM{{#j^_aH;~U zIn{*WoZvJ7-Oy(;eitlkK2XIHx$sXXjK0`RufDkk3v#rya0^(-GL&=?v`V zbOZKudIHaMkmt@>&RM{|PG8_T&N;yI9OS$+(isgL@7x5u#kn1Lhl4wH?sJ|6E_F~^ zob?V$zO%{M0{q1J1o(yX4e)y(O0Tb%tU*ZC#_r~1AD{_ewF`&=JNc#@T50Z&Rg z3FuGq0|QAYGfAfr#JzR{vZ1ko75Mzg5G-iZYE#$?c zP|w}`k4s075ce>yyz-*a{}3~;{Ku955R+N6CYGXZ5vV;Hq9(>!EG#-NDLOAJIxjCe zzbZCE4)vT+s6jRHF%AcmE*6WI!PS}Guk8d)`aE=SGT>)0M?#lGcuUw~nJ_xG@7F{u z>v?7mV4pL40wJx6q>IA1cqZi1dn06Z8k5m4eRjsw^!n-j;2Nh7&iFjDQ^sgejnjvwcPMfL`8+UlW%?dS4bH5Z zJ}}O8&1jO|3l3+v0yvdED!o_cgklZX7gMCu)0duEm>z(e1UC?&`{AIg!RgPX-;>@n zeR=xZ>CMwyr*BQ4NiJhqv5wj4;^(6mr=fuTDW$X12MfLLO1k5-2MqXB zbQJB7cQHSAMa+e87sg&CqTO93x$e)%;U`LR!MoIbwEKi20+Xm?R*>0{7*LTPQ4=Cl@# zD=k|}u(HprWI%UfNe*&8u4I??|GPNu;qqg0pYr_O0dD(PNww3xm?Df z@Y&5&7k5Ju)zg!U!A3Fk@g?~lDi?*j)RS{t;T|dxBw=0CB@&Rdc)utW;l!W4dWUkK zN`Uti$||#NUVK=(a(|8T+$B*uLb~VYu}|Hz#>joR zeGun0?)MSN__Mn%au1>w`S5*BjF&0g7Jp4w?jRh!qI~zWDD6?PDJtoA?AQF%k-Kzv z^ef#O#Ks>>d-6wuk(`VT|xnTq_QCC=UKe&*eu`z`WeMOh&u zK3++n=ML#ROG~?hOY=%|+-~kyg=Lf}Px@%vgwk=vamr}ps5f&|zj%EaN2Q~jTt7N} z#~P}%HIhb``uvspxqB-mcEm!JPeDbh-OJ-8BBeW?dwj2`o%UK}ipTvSacsvYWye;d zB~Iy)a;cwF)FY{6pS@%Z?$#JiYJ_$_j!;K>PF(JfR15B^)M%+99q!JGBog_%pC;lS zIq$D54Us-Z`KfTU@aN5y zR3zs9vm%Mo{_eigyckZ3N4uE0aMOfHG&V1iD4LUvuc=}*l_WctWE|_YdqV{plFIZS zQKnCkN9pojQHVtT?&i|mvfFX@h0@aCV0J80wo3X}JTG4y;(`cOx=dF32}V>L^V$8N zA{Fjz+;x6=QttER`IhGw&CRlAt;!1>?-xI}8t+%RtFmTeasLZ(9OcNTa&gB?xo0b)Ur-=P0p8qIamZBPtoZ=Q4|45aHs~V-m-BVH@kB37gx$)Pry+N+`szVq0GnM~Q zEN+4xQ`s6^uKzv%L{G2e%t9hfm{UjHOS8_!`5)6~bGK6%`oD>fiF8%^=e4c$gxvp> z@byQo6a8lu@k?}epYgcf{7q!Ukw}tw(HRT(rxG%C+5ebFr|#1w^d9kLWS0Mk0~Q5v zAF5o)XkHY{H}I%qO+m4~BOofSe@iQKSC!^PInnkqwom6i8kLAp?y}Nz=@Gxb@0_S* zE*-mjs5I}d;*_5P`u8r{P91fezM~FVVL-1Is!;4W3LLLlQSdU{fI2P86{iuGjes`+*p76bl)k(YYzlkM8 zD?IxG%*Yq4#DTe^g12#?R26JNcoVCa_F^3)RxSyNwM!2Oi`P9Riz)?M3%)COqTs25 z=L$YASW@tH!OI1&!o5*|Rc6AHU&w9pOY4yRp1r}winAkH2UQ2LAH*>Y2im2ASvcn6 zz=)(^LD3njE;!YRQ!Wb74=6ypf&38#m=nddE~?>hkjF`4I#we+Dc%$hh_}S|;uX!O z-61~5I?FlQ`Pw{fuQo>eNjs#yYW!~ep}k`|W?Aws^|1y{=_fe#o#uKItVo-u zpXR*lY|w{cHQ*l9ZJM&smTT5IXiqhHA1qT-_tV-bb%$t5h&EP}nZ$?hM8*{yia43* zb3lVQLFlAMZA4FBmrLA5&^HJa{6S3tb)UNe64yYkoBOmn6a5!m&2c|di%`}{ZYEN* zUKk`Nx8e8_{~a1?n!8-x@BXT0V$5!+mm&WOj^&uGmPlE5wZL5q?la&%1MV|IA?_9O zT^t)Y=4-4!adwePB|Ex5$gb`#dB6Lk++6s*{Gf1(`Wf@+%9!EKLA=+!drMN09#tw3Be5!XzVrH<|%#I;BEa3@0Z9B7^b$u7z&Tp=8} z$Xz7AKz!S9eCb|;xMo_1+-vOjaBRS_3Hjt8hKX_=BsSpuKF(WRx|@ksAUDCXV+&Z@{t1 zUF}qN=QuS`vZ|R$?s~*|x$J^t366J>!yDXIRzBitiK8{gIS6sKLVT@!es{eu+g+d3 z4&|XbLQF)6E^3jTKyU3l$ZyWjU;Hctm#=UMHyqvJe+JGy z;NJ`9dC;*KVVAgre6dKpAv$PdwXtG= zb~jdBpNkdOv&B%<2TzL;SZm!+T%`}yZxuJ{v-Bs$qrC3=39P$bES@yFVtw@jUQ_)n zuc=;+)zs6(Dzll{Ol&gyVHNad^9S<>@quh08;C8k5!NSv$m^3ol1;HP`D0$0{3)+Y z{!C@7Z1K4Ys-XBng;iK=Q!Q12_)-m21I1VBe09F~T3x6v6#r3IsDFqZyefDnRs!o{ zw{?|umDpolZCx#Xu*Ot^wzwa{89ezq1{i^V=`skK!6V!dXq7W=KAte?aI z>i|{)|7KUQtB6B(b-R}M!>()B7p|Ra=V`j#-|ny3_PO@?nqyyRU!+yBZ?tdGs@rqy zd0KsYk-bPe(SE^xL2GEQuvch}>{a$Et+AsVrJdv?J5{wNSQVVDrO_H-E!~;q+^S_b z_d5@2S#A*LCw6=B4KO^TK&~ zc?Egx^19?z&#MdnlH9NJdgSdd!}ZBm3EkBE1TOEpV{!R4^Y8Rr-hc=da~_&Msce@w zDDRTILvU9x5>@Q-QBjm~&2d-t^ON)T=Xb~(#ZOD+jm__xcVphod6V<*$?ui-K;FZ7 zPvkw7_gvl*xR>)@&3hy7-TZ!e8}kR|56s(|KRoaA{L%TNp!Z$C%`pENS@F0`l7`(>FkEuA)^QWSIyaGq7 zqWZA_{iHX=CFm)ABrX-7U>m?#tvzbVr?m;%1o4G7Uwcbz(>})TltS!I`BAvoozhsV zqo?WZwU+t-eSkKA>P_uj{ds+fcAdUdU#s0fJ5{uMXs3!c&8Tafu03G%HTr66jr)!1 z+FRI#@`1JvyHF15mT}lPtT&*YC;ExzsphGAL$kBlS#LzUMD)hA14M5sYsp&r$yB%M z&1gS{ehPMCWa;@-hw9B$uFBO|P_0xey`?%$ou(IHZ^i(<71gJDYc*I6*4wC| zYN*~;4OheU)6^(6N^eJXtKQy{meRY>E(^UYc3F(nyHO3Rcek#!uGP=5##`g{9@amt zf9gH0TdZ63Ue@i_?fRM6ck!Iwo9bNsEbB$ix0%!l$1@HLreweS+OkzsOFv1NxM(V4b>CO!O-_AqML;CB^Y-hIq z2G!B}n^Z^ZYn|7fH}toix16{1cb%`D9r`-wd*^$7gR{rkqrdO$b@u8Tou8eb^-az% z&M*3A=Xd9K{R8K)b6DTv6gq|ahdy+>^{qa`XXqc%E(`tRq@GDV^-oatCgW(0^4DH; zMLFyP*HQEn=Zj8gvHvA{qOE>YJSyHoS$sjOrqvb)uv2QRI7}r{J5QUa-HCoYc1>xQ zQ5&vZgEstQZ9MIr(w^tixe2AStM)6k>iUUPM)genBDgI5VmLp_>s@-bez!hVKU1Hk z&(Zr*Yp-95)_w{6mg;ZmS5XPpZ>18f-$8q=5CVIx^oOz6>U8~i;|ybf{s--~G92m` z7`3QhV5HJ6DeOC`8FP-y;jC7+G}MzL1o=|ns!+k^RcJuRAZId-fVBY zM&;gEZFV!e8UHrVFwZd7&@L_D&gQ4q1*FroB^UF4>RSl* zc?+!KU*_G`BI`x-Uh5@mg*hGeu-1Hpb|abdU$m?jAlDwYwC&?SB zCn6_OS(i6aS(mraJ|sDb_8ZAtX}^)Y4W<7odAoC~bE~}5x!t*4-sL>#%#c&a66C$k zBhDjos`Hrhn7q$`eMX&T+nUzLaxeIp4^6WI6H~=LhEpxxm@y?32$rzdFCl=bYc1-{rrYKb=42VxR8Q zG(>`)s+CY(~CFHY1n8ULL@K*?6{)^LYQ@0$9ZattQ*Ub!-olXcwV2jV)m# z?IP5Ef(;DT+v-E$&ektMDelkZegc>Ko4MRSK)Va|2f4(*$R++2F7Ye4#J|fW{wpf+ zMvzNmAxlXs)BZgyy$wW4mY>peuYpU1OYqA#YB9ygh7on^}y9i}H+C?bq)BZtu0__}>4aipINwjlN zHldw^vK8$dlx=9|plnM!2jywBb5Nc~I|t zRUX-%I+bisbs^hRr_&BW)y>ItGF1<rHWGKaf| zeBfGC>;ex5o(Mb@crLIc@N(eQz#9}I@NQruhin%5%Us}4U~Ay>z}JEA0(%4dNpIj# zRC`c>u6isks6zb{yI>&HKbRb>8LS^{OcKF#;)H4+n+rBA3g0PoY_37*SlqDC+#_^t zL*z#M4X#tDiRXgNBh(R|$ArcNTZe#0=`uqVx?l&$P$@sZQgJK}b`1>)_6qh34h#+s z4h;?ujt-6sP6$p4-Wi-4oF05MG%GkeI6t^BxDfS4v*6O;^5E*=+Ti-&=HSP{ZNVME zUBRD%2ZDz~ddQB{Eqsoce#GA6Ew8j~c%?mJ;jyJTQl6qEBmQX@J(ZYe;pI|nIi8y! zH$tdUD4$w{hN1KGnEi?sXb{dYEp;@81 z@}ms-M+3D?KZa)ik0nbH7I=^#3@(E~|M~Yo>OD!dV?c;iwB<9}FFh zOK%9dvJPY&rVxJJZ*$1*!5A0v$2)(Mw9moGi+8~(Ww>U+ zSVvNC|8*{~%U{*MB|X_+J4^Vtlit9tsCIt?(7j7Le-nRZuzzCb4+U2ya)BMk;)0z* z4ao&|#kx>x)CJchcK+_cHU4J)7XG$rUz3Et6LA7RC2$7<$K?FIz3{Y;O1XVO&t(QHbpAELOn(0ay@R6I z1>g4Xqng0KfoiYJL;g?w+xg0bFxw1n2(AoasD7j_o1a_! z)2iSqwgi?%*9{$!%dSo?xGcDg-~B=F|7eW7+>>25yJ32Iuz%Wj*{Ole*?zRTE3?DY z;%Db&7i71~?vl1QyGM4P>;c(>vd3oMlYL3{lI$z8M}fXE`{wM);5?B1aP||~Ph~#` zpO>>=&3+^M-L(DL8?(1&f1dqy_WnR}plSAZ*?Y71XCDfPfWmdnK>a{tJd!}5X`p$a zb)ZAAdtftKkgkDVf#HFEX@>#>ah?P>I50FYAut-8rCA~{9Ou#Cjt-1V7vN6{+!>gf zUNbN~@MyXUEQgyNm>*alSPkC7^yI)&oL7UpIB9fo=&t^671ylD^#Q4BQ{4? z#ui4F6Wc0<22ifC<9egCO$S5h2W>##fM$3B+#?GJ~%P8 zDxTDB$laBQeLwxtCVD-0&D48Bt z;FO^$=$)pFrjnL2E@c9pbA9Ae?u45}nClCk4^H)zsVUP_9?h-pxts|(yK;7rOZh2f zHgLXoow5+;h}%I_%F>kODXW=>>y))PcBQOO*_`rmU~0;?^w}vpQb-;p|iK~fxbz68}cwcT9*Ber|q)thlmO3+aR_ff;1*wZumqB7p z>f5Os;JYO_D=qBxO41sVOZ_x0HLYQAR_b=Xq7pSLbx-QP)Pt#oX=a))t$JEr_@t&c zP4iROw1Tue9B?_ka(bn;OKZpHE?JXudgYpFJ#tNQ!Peb2AidAOGR?4 zOkbEjA$@+hcDQ!>B*x|7O--Mk{wUrCH6Ol9)0c;9=S)ano4y*yT3AStL+vp)I5&M8 za9R5L^v!(rF>}y52Ipqz;P0T8k|lPf|HL$1!=)ccKTJLudTzT6JJXljE@yUVa%gf! zlhEXx*%?(cYV%bC;^fRGzl==qLmmyPSw;(@J(tnetNSxLWngR(T$7vUIU2EKh6(8! z^&4EyZ10@W+dCKI&W!6(=WQXE(I3b8-c`mBstJqS7CL7P%NUU{hBv@Yr({ga zn3ypo<2D>KaZCfw%2`b=V*%XUqVwX6Wf{vNeV_2o@Xp-4keRU(ZVk?Fdp;T4>!oIF z$XXBF!u0mKbIE0Gt~(bzzRLKNsCub{S?e>lXY35!oRyv%&JEW~%?)Q1W)u?bZ$ekG z&g18XLl1l0j6E6qvcJwaNMSrq#3#31Zo5nq&X-v|w_SK==Bt!mcH6Udgm+@>y(6=3 zgqO20H!nOllXIGK966s#`A!E>nSOc(nc>K@@y?lfnFU07A>iN63lT3Bxq|*DGP~gD zk=ZBniSYLDc0B)~f$#Pg6S%InORvvzqBUe1SlWWJI4F51^YnHw{=W`54@>(HRkpzzAf z?=ts>SB7rPN)Fu!6mTkYKT&j@d5C$Kzrxv@!MYRto5^7&i)OO|MCa@ZHp83|dNnj( zmDM4uYhZX*udIGq1GAcz;tZx)psdk3yLe`3LfFol6mAl1mU~6koj9h3Gs$I5_qWA7 z4`zD8Yr<7?cIEoA=I0#9S{Sa{WN&30%?(B6!k>me&03wcHft?WF%Bi+NE}&By;QQV zl8$Vw$oFH+FTwFsiF;DsGvV@I^nAj5j?kSShQqwoPvJ3CW-xzsAnPz@ui$dF!F?QY z;p@XI!&AulZMdrb+TjiU2I2EzYZG%8`kUko_Gji^;Sc3>rT$I0s=pcacKmHI-_jy% z``hLm@OSr9JJj9Z8*>)tV~jS$Kg>VE&!c#Z)~CQtgPVyFF~+z4#r|dfmHsu}IIeh9 zx5vNFe-NX$$=PPM4b?#iN@`N{nj~j%+ZZ`L1Ye^BvR0BOCMy zt_U{6_-1sVLtr6BIjwn|GZ5#N%UKsJrh6F}E80C0JSDd?IG}9~454^z`)eOa$ zW;l;^9tAZHBbW&o$IJ)KV;-jF2OhXXIJ1ra9ZFn=5p-NlJLG@)$l&*=U{ZuAh&L? z3Hm6Rp^fN6gt$l13_bg{+*cSJ?4E-o*gIU6Mpf|+ZTS#yd_{fw;BDdB!6`WtFq^R# zy|09>1vfyGID}!s$i!bWW2e+e*;y%3Bd(UZHFO|kIk-9#Fx;=ziJk&5ppzcle z>RRg6a}A2xGgLqa_3v{=*If{)*CJ=HzmHnzlF${QQK7M+8*^HtEP;8-xLr;XBLT#EJv7pE~^jv63=;hF>p*KSBhBk(_hCUB{9r`Y`Hzzr?KXj<> zf*g^fa*}gu=G4z=oRgjtAPe=v<}}S|p3^#~L;25(`z(`k?#!8*Gd<@~)I+m#=7*=` zEX-M&vm7n-+MM+{n_+R=!q-!uoqP2^x z{C0Q)xEsP-n(Re=#_c(-sg>P>xDJL3(Hq7%1wG-0xv9B+OkA)T-m>MkLS8O98uW1U12b_LMtW0O}OE18Sc$Ck{KdBVr5kCS98 zc^X#2x0fA64Xmi`C2Gkl$xC9e`EVV&*WqKTX#XNZt|SUxUt zRkn&?EUaA}>l+$2uN z3f!&YOsvBFQuLNz$*)9TxkK(0{p5FYw>SqYau160Ec3X-ySi9R%yp9#SgTy-Q zY!PC;ZP=#x0PA))i4W}$><`6fPIafA*ygL}t0#8SI$rTDt>hKo)7k;CJE?n8cd;j_ z4_2Z7fM@d{KbsTz+2r!GvGHsgiJ)wZCsduEP(Geet_brg@kacds`GPdj_1@GPo)js zVtoSEKexpbJq=H;9iCi!QBQWj^E(O8uZuWUo-R)Z2Wz7t*Lb-VyWuhjRiCQQVb3o6PbHSe{=ZPfw6iSK1rNrSbxK_%QA|O|x+!$P943wC6v5R7zT!)g172Mc|u|aMC=Y9D;I2%!(d|aNe zqXXs1;_@U>o^}X{_1!xm|DF6!q{{E*_aaU1lDk0fMmbAEIm4T-vF>|6;yNII1O10A z#I77T?3uy(Z_rr%E$Y(xZ&3p)z>~qRqN)f#R)SX*Nhp`qLDxX(tjndd21+O1xQx}| zjYJ;GXa}KGN7V`4vCgWq=%BjbZQ)9FRoz62>aNZJ-9z;dZLyZTrzlXp)S2M)M#*l* zB|8Hp`&#Vw8Haa?H&)lF>p|b3ZUB9wx)JnvHD0t)6VwFJQvDM)pu+~RniA{M??9DF zZyj&I_RyZ~p$Y8aLD33p)~AaWu!@=ReF(PElx?Fn+eRkaMu=^r4y|R!{wAzu2a;{r zY#TOgqcv!(Z5K&c-QH1{Y$qmGw;vLg^@nv>NUU@JQ&h!T_d=0uxt1%cV$D0=m(5n> zgB7h8RcHmguH|^V{t(tBVO=$Z&#CFu6xEzsPA!q`)OKovuH)1J zT^F`jjcrfD_WUBrhpve**#f=yc-w4&)!70~Sl~l!fd*D~UMi}w9iGB=Xt5oJ*bb|) z9U5Fy+H89U+n&L;SBGt{3EN&#zkjVGH!L1=eQ^ zEMN;fiECDktxlJ>NxbWvZBNQOB;I(=7O2Z9atdg&Ln)`pX`(4xV{Nv^#%ztX*%}+O z9oCRkE7xG#tHHKsv!%6ROEcKg0`dja%^K`&C3KRd1-XXS*xqC%>@6wA-W=H54(#{( zM&b?ZG4|Gw?X3~pTSKpW~HQOZCt-&UJs*ma;>ZyKs%YQw#Nt3Oy0o$R;cG!yT@Km-#lkL!CJ3N`~ zu&$b-?uO0Zi*EpAvo)Te9#9XU)*zc~$u`+s%}_H$n60rUTVpC)W3HuP=aXSov8uri zt6MdM&emwLHCk+q7F(mu)@WGgSm%g5wn>9+(qWra<=SLYj7>UhlZtK9VVkUNZ?Uo0 zlr2-)AK4!X#rB!R_L;%*!Sn7gMuTLY?-e=lix*lU)#D+}?p1@Rf7_B3NhLhNTmi>bXy-xg6rvCC9bT^VP(f57)vLIXQp zL62wpDWdT`0w8K&#HdeTr1t@6+FHiPnDZ1N`miK3lrfp{Bi2)e(8PXcx-aHGNhl{W zJyN{NsiM1hlhZkseeYxB7$v=*K|_5@IGIqtiqN>9Y1#{;Y4n~TO&>{!UIig`R|7vL zv`%L1!&t!Bn^4iamo(*-%(3*`(a)t&oaa_2mgIZ4xU^drv+uQxs|htO2?jqA^A_Tm za~RRD2R)n6*vPn@P{*EVAiWkuLun(-CRDdEa!#U0OdRa0hA+KkN0apS56v9UG}(}* zw(8#jza_LgF<#2pgYjZQwVKdko$?Z0LJ!}CdWSW<#i$64-w90Rfk{$F%flrvNaTi}vc{8e-uzjry)4AqL;N%dkw_yB=o~cpQy@F(z&c)7l z$Plf!Ahdp^c&+EPmaKCGV!u{@1NU_%^RFRPoWpi2zPo(BuibP<7-7KIKAk0pvt%-J znz3YvCBJ6Ls>GMQh&Guv&(`XIrgiz6{xzXFgk@f%PzKwz{u=W+4dPCwuO>9OB&cUu z{&v!1bfGVcn4C-Id6aM1=Lt!TOS{FIHGazSL*gs0)35_&AY}N78=0(aIU|QMY7uQT zCN#$}vMrc5G0hfdtYsN4xB7ET|HSwWTD_c<3t;O5~3a>l#JdTb!Xp!gnCm(PPs9K`HvBrhX^IhOP%Qxn9tAAJcnqV zQ*Ml9evoBeVf;7yE@FI}aXO*-CZX!c*q+cB&HPz}`dNe+DFU^N7zYrF&4u_fiFO^) z#!ZFjyJ?(<8pmZkNPL~2j#i`a63FZ$)I2_?N?Xd>o-9O-s=vtc3mLgw8Ltya{Q2d5X~U_x^wp;|>~oJ6Q~V_Z+RsqJH&P1dJ* zt;1@jUtz4mxI&+Sdw*Gf0{A&`^!u3qKI0lfu}z;1{whMTjrnsJ{fr+nzD}qQVtNVF z&oJ%bY_e|6Yl&7f{R(3h#ua~lOR*EJ-^ZNy8P^bsZGY~g*a^ip=FegDGk(bUI-x#@ z=_O1*!!)Dm*+mPgNhFsL%#I+hOl}1vKV^(*!IAefa@m&mxP{BV3;l`Kx-y4bL+t_P{DV23 zeQ^%xml4PCF`x56zk}&9g}o6=JEFDwn8P_^oXqq*Mox)Qo9W$*TL@JK(;qSNJxWf4 z-i0~;Bs9ES>PfVg%zU!%{uu6G zeP>+@4c}U`81E*uKW6+0xZCr!UuIu?-N?wK9s=Ys@-u1?Z8Rn{$1y&{coX9cLSrrC zRzi8I1r5Oa35lcMWl@atS!Oq54dNIzNXA&hGDC>ghp^;$(x8toqAAT2IECXm&EwI> z*K|&a@iT=rbwbI#S$P@jpT_tZA@txb^f642;drOBZ!*)#oQ7nM@efYJ9~|!=eD5cd zq*Ag~L8ZXdWVzCo+0Db^`NHXFP{c z`<(TEPWlb*C4xg`;115EJ4i;~M6_9jjybhZH}=vr@1zVtxeC`s7=q>s7-pzAW5372_=_6yhVX%FZXJbPWf-*==ZSZ zdpJg~B<$s|x$Mi|q|@)`{J)=N7BT-}4)ri|<}p2wX)a^>K2GyKPX9g*yN_jl;d``M z!!Ax|9pamHNFGQfe|r&vqkqQqXCw)lWL~GRsy*XrgmMCF`;7H}#yN8pam+`VKZ`ZY zV&5(_qSQO0|4v9XXGiqhfi$`V;)`Q?M;?22V#)KkHt0wrO5-8sPhkEHtlSkDct=LVL)k;kyla!Ni|A3!FJaR~bkVfi5}e=%zw!a9er&LKRKeFig=nl_)Y z598w=ZLI_U8A5#o>lwkL;1R632c=wd=&pfeK@LBW8qBZ4sY<4JF?Obr^>xhWC$5d+ z)OI7(JbQnTe2s@lKalcjG~-B4^GJ?yB;UnIkI#28lJ8=q+z0s=NQ1tJQ@Ds_8gq=V z5l4HCQ}P<~Te3_`qP4T-FyO^3nQx_m&bKf=MyiNTCR$&_ny=>A$8dTUGG{b%u4Ybu z<_sj-IFFy^0OEkAJ35c!?NWsF9M5O^0uFmVr{{dW$MZRC3K|kkf1bMjnHUFsK3LU%RQQPvbCBi%z26Nd6wa_t<@*m*u}_o zn$9hSet;#%aGJ+(n)CSHvk395ad%oW^Jg-DG;#1Wkq`Q4;v1aX`swU@i17|W;}XV` znDYoBcI^W7&Ws}^<^v3_jrG}_2G1(zGR-ZBK7;8=gxV&IT+t&X)H5+NhcQ0S^IXI9 zD@?agn2FThAzExzOQ}z&4g||2{%%C2@=%R4NqLpQ;gu9nraEt z&k>rJGRtGgF>;$LuVeZaMz1IHE!Y3wTBuLZPrDp=mxm;So)vM1Fpg&&!}tfw|KZUj ziM|9RHSEAfsD(tMy(X+p`hiT7BwAI_Xg58i9>~K?&tu%jn)i_;T0Nu+2uZUJhuzM; z+gb86raxnP7NL<$h@J)`%Xeh^?a1?=9jPSi9oZ^BSD3fcKd0GCv^zwnF+GIkhp_w* zmLEd$Xic7m%m}sxhvG%6L9sX#3+fGMMmtFQM>CFOJtLW3M5w)1gs4gMmQ3fXLh$pI z3(mO|i*X*s3nXn`3)_WL(uFws`Anbh(R>$e7;oUXZeZUVSTpxRQKymqWY#~P)7+4A zY&W5q!t~vY2MO_vfch53=NZ>C|9V2?D#={Tu_QB&WNgJam=LubP=ANzJ( zZ#QWU_680+iSZr}Ij?SGdIV!TLTw0#>c*U_2#u4O9?v@2D)pC`X4^y?hf=K{V7!~d z&ST_}0`iv1{I$$k&$yd=Xer!&-Oad#aXq1NJ=4FCq;{B6s2%3mujbUA&e)leXVkSn zIED8!Ud;T#MKo$Bo!c_Z`BO<7$*ou`#=(TfNlbTP{aZL~|75xqYnaM(d&cpMqnYpZ zn!FbIdk(doQ`>;hsKFf0Lt`QHO>X!5vWB*Vun|b=Udz~+Y|VIx`EPO$XAbp>;`oZ*&&;7& zG6M8XJCE;9EarV%S}x*8vhMfZH|;zg#Q^SiQHf&e0*{KOuh^#yBJ##$w|jZthKRmv zJxawYr0-M|#XKjLUp9@ms{a`GhIE<{D)(1j`Vt4kS0rb~eb*qISgs6iqX@sOcOgf= zfDp;WNQeaIq9+sY6PuffNdM?NN>hYymP&A`g{H@r?oqJ!3WgmPk7GIdj z^};h}DC0PaoxeST^trp^o(-ih@+&SEV3?6_1K-vPTAN|+&NF9at$^n(QjH0g= zG>Q15Hh)1>DY}Ys$u8-?Bq5sMpk7Ca>%EDf@Fib_+9onYQQbtEOMicW1wZZu zK!*N-$S9U=$>q`1Bgzjk~zIPq% z#}Mz+L;>lm2}QaSd6(v;mSn}$di0Lzn4jC+UFi^OA2?lpzfyXq3rKwj~A%ACcCzWpH1V!uVA z0i6^5+`%XrzpLb14){f5gY_L{zMXh)?YbQ6 zny(_pYl@~Xo?qToeA`@(WV!vX<7ZE0r?2dx5a_*}fud-t(Cr~B4%1&SOyPxiX zSVivJu~#MOxISFM*@9?@Xbe$a#Z+7j6^qA7P@NE|*XYh8bp#2yJwR1Bn>Te0}(R5@)?sWR(`QlpY+7{nay@1=^@Vtp!4mzD15 z{9Yw=Rba75XuH=1Vgo-&f%!S2{6w2r&L}maJrLV-y^fHq1Y%Jc=sJ)4N z2b9h(B;B*!?;^Zn-E2=09mU+gmS|t3?%cmtZJFAN?x{@wA`kbyVhOvLDkfr|R53G3 zbdCuf<^Go`E`Qu3#S`_$?bL_u;L=*kxL>5)y2B#uqWN2t;Mku#jOR{UL0=!@W892i z>^uNpPb8$DJJ6luo)^^$4#!aV8~GNJeH5jSuDzezAwnfSN75SgMI6O;7wyeP{NpVl z!u{VrmsMjS<;nl$)N}mhq>qyqUpEoUeK-1T>eBWUR}wmx4t?zR92Y~px}uSMG=1^j z-c_`e#rwvzPw^h{SJXEuE~oKcD{ zuWl8mm1ajbQQExL&6}}vpDXqU;lA%)7<)}LW;WLY<7Nv>%EVvCwIzxkTuFDHGGPe|za!FJYL3rckXS3y{1y4|oXO#MnZ$KvqI7U*o^7N5HR82I zVkpU_>qNQ|$tC6`P9N)i$X)J!N&m{a_j+O7PLa6q4+UBC!H7<89+|IrM8aCbkhvBb z&}RUZ=1ye)7)bPmYm79TKpOXtFM}rjAqJ#uc{KK7u>}3S__E;Mi7&1%aff;_P`JYV zk$wZ+Wo#PZ6RD}#`ilG(;vefJMfX&{Wd8>m?sSdf^c3BLy8`=v%D<<^?pCBMW=v45 zqtrd&KY&MzeL;A$gEXJ+?v3RW?Y>cxllYoL^W7G1OK?v=Ckj<|$w?%AL_DgqLL8#F zS6Uo?Ij9LmS0v|+DLgLP*~pLgo<%OabE%w+_fB|Ka@Ld?(Jx5 zpqSty5OWcoL+KX7{U0UWrIau)rz1}nJ%UzcCpY@h}7S9F4aT-+hRV-h$3q|5(Rg+C*nqU?w^r=fg__{_jS)N?qA+j z5&5#tkx=l@h|0LHyQ`xAKu`=ZSKioWdsLdJ7(K-v+{&PR^8T$!BoPsHzmHJy=SbOg zS9<)yIc_i_QF>m8{CL$~iMh&12=DApht$Xj&s|H`mHkCy_d-O{7Y$!hBF1N;yUv}0 z6+yM|-wfG#Eu`bh(zRJhPRZ+tMmKJB;&DsXR%L~a=qL(R#{Ugbsn}YeD9l7Udu1=a zKNwkq;>jHu7IOU;A0{#$i{~D{E3Zy0s~1zbcw;_&8nzn;2f(>>LY6{j%2S;S;;!~=a6vTsN~E=!sxM!=`R~S zBhEspkMF&?;u7W&X>n#7<_jy$D|BvpyOLQ-# z|HVus1s=~$mEre)o*iF$c@JBS<8)K?E7lvcTFovkovuiNe|qtlOyQ7tvXfT-3j;8NrG){nwsDIGXmqn=1WJQZxn8xoWq2lzaTCik{Q) zPr=_E!~blJ{TH-Pyte#T`bQ=DFAh<$J4=sbms|9|nZNrfMdNdCrO`&=!6*m!Gd%X{ z{~ql=R+Q$}MduP@!(+dr;uwxiRV01Krsar3yWhqIDSC%X953NT?7Ny03J8|qdEz4f z=B4E7mgJNkotKm-@0vm)w-2VGuB5ix||C1Hh5wWu!Wkge<#U`pj60BxBf<2ODq~v(9i|T;mr9NJ7 z<;qYbOmvl@`*MVbbE&<8F@DELVl`j<{N8b!?TPeUjxoWdg1fUzvHnjoDq)*Pa9eUT)}4$B&k z?)`g-6Z3a-@eUcZLv9+5;`Q8kyG(rBghZ9(#9YViOH5QpxLNUc6%#hzqxg#2EO&eH zW#tKf%f-D>3wsie=!c!#MZYM;jEd{I zNWh~$N9IV5TEUS7EU`DeTKQokJ1Jo~vHM~gl@+S!eH@;5l6Q*k!oaGo;_*#c8vagx zTwVTmMqG)w63x_9BG~`5NaR}$N1DhIZFPd+JkwBqiyGq_-9eT>)nCFo{xSR|$t*+3 z|3ul-#X~|Dw5IS$@wS*Q-W9vVtC~;SBEHnN>St>U^mE_>`nhmH{XG3*J){rSZ`Jel z+x0v2v-P|5yY&J3z4{~Yo29>}57Xb*KhkIFpXk5nPwKzwhxL_up<(H7;EU2eeS?u~ z)Ydl|b&an2Cq{SU5?o(qTx(<**BLh$EsXKTQlpiz#rVXy+W5>k2<~CiHfESUv#K%I ztZr5}o-u=FQ)7YI%xq;WHrtqOjOAuKv%9gv>}mEg)|!3HtBtqKYs_nmUFM_aqsDG? zmO0DVV?Jp1}t~}YiOyhW-XL$5cbhlL8FGd>8Q1%=2SUf&Nm;B3*-XxLAgjSHmA!a z@&$9Id|9qCAC|Al*UTs6>+%irN%^kaWX_RWoi zZN4D)%7f-h@((4=HOf|1&G%GwRm0q(>ZwNNR^?YY<`*hgH8cOC@>L7-TUDUinY&d- z)ydqada9o0esz{Q%luXKRej9^>TGqR`J4Kux<#I(Zc~$Gx>~Fj%Ph;blBM5jVx`L* zE8ohO&8(JIOL>ab+Uh9ttaGdZvb8nH8YJ6VyR2REG;5D_P`0xU*+TZT4ZExCXZNxn zmk--d+VkWddy&0F{%kL`UzESvE9@2WH~Uq4jXY?-VZS5)wAb02lwp5hf2e%+ZhMca z;s{5mYL4zyRn?v94(`lp=rmLrP7|kz%5<`wY?b9ScbY4|)6Qw9vYpOOXBBWxcTQJ9 zr;pQ5g`D%8^Hi=g$Qh)XIwPG?>SSlMGg_VEjCXETdCu+56xGJL*SS}9bnbKRQ=Odq zof)dL^N{nf>h3(|%u+p^InEr_%bDjqtIl-(Am`uC zI(3n=$=RfaJ6oNt>PqK(XTKWZ9CQw<>wWcn_0$bMzb{+e=sU%irzRw|OKPVkCUsBh zu5L=|k<>%ooYW_&FTNS5Yrn%X+X;y`oOH!k`nrj}_$pIBaUJLz;50Ew+yT53uA#UK zP7`;-l1*6hTF`I7p6kJ$*MojfYy`bYd;ofj_z?6~@d@b9;OdDT;v3+1aGLlYt{&=u zUHC4PPpc{dS~aaU=sNh8d^N4EmJhnQ)?75yPSx6hZm*3Mrgp719`pq5pP(mdNR@V{ zc9*E5P0{Gf<#%fjiCWsj+QXn9(dIzUJnd=VeC;jaXm4xpibmQxZIejVHftY=+SZxBy@TEXU%l$2cLR3EmzQ<@ zQvFhK3e{7fZ`W@ZA$_tw8NPSmJJBKiPMyBs)d%Y&|I))YNZ*9S!-Gi2s~ zpKIodJhQ3URMbZ8-%Rv0Pccy%&E{rv@J}^QMW_~L3vgPREfK1~EC8pKi7!W*tIk!+4J$B4$%4uKwPP6U0Ed6T%@ zyxDvR@@SbvU22(tXqkZX&F6ssGXEtynv2XuLYa%r7a+ORTne2pnlB=*W#%&QUozhY z{~hyPaMqdY#9(v1`5#fm++pqzKJy#%8*!$&)BFxH-<#hl4TuP7j!**mrj=_$P*#o5Z`U} z$wsn~=p!4;#^MxegGC)`gGC0lzMxyl*1$HhjVO?9Wn0mOT4K>nc90!J8`)WQ2EU8! zB8JG*<>{iY>?XT`(_MClB-&|6_K-aw*;Doum&jhSm*_12A^#z=k~|e$aE|9ME&+T+s96Jlx~c@@d5WjC=<8tb7)@NG=kW z%EfXq?s|z_B6`Ue((RTD<%yHgLyN8eN-ROO7&Cy zfM=`zqLVsDog>ax=c=njk{Ye974_A1>Uz;u-KcH^JwZ(n7gPTUH2P1#JJcOw0QI6o zKTESTQOBxcRTI^%>Q)U=lloF3o%&M1)>dm^8>_9zuuii&Lh>Bz9C0D_t3ab)B~0|I z&=y!fSwD$d*3Z^2p!Zw93d1^J9T3UZZ`N-@SqH6y;2*LMiA?Jc>#%5I{b~IvnpuTb zp~$gZ%N5ORfj?k#&@(edwk>U+kam)tEHt}{T}7C7RU7TTUB|8ix~`3HN!lma4MaWr zL^}<1x*Y&NXoo@P+Ra2Q`xHA*RI~H#Ho~#n+HFN6`!u_~NVPlI9Yt-slifvBwNJOZ ziU#Nf_7#@h&psPr``hOW-M+xSK!of;_8`y~+82R8#2zAQ*caQEh&20BdnoA3?8`($ zdzd{;DEo4IIApH0QTN(c+1Db}IQs_BH`)_LvVD_%3uGqQQ-p2bZQm_?_C5Agkz(Ix zPZKBE_uCJGGu@scPPAv*k0ID8=|iLro9&QTlU+a-?85Tz0O_-TyL)zVf#IM zgUGbsw>OF=_9lB1=nw1%y+u^FKeRst|0DY&;2wLA(5TldO!RssXyqtT%ds2> zw9i2e>?AwMBH5|pR1wOl>Y(*R&$x!jc4|4bL|3PdQwNA%vN(hK$D$hbk0H~>X(Jk< zmyEuX)4}P8u;?X&-^b|#oqe6YqNCH#=?4ya%#JA8L=mOFiSD!IOiJ}fTZB;O>~cl++oqpzlGpvA6S?GI_Jumwfv*%SGDdl_3x18;jzLjjR@~u(| zeXsjoXU}RM@3R-SJIBB4ThFf_`aWd;*FKRJ-}<(3&D(w3+1}yX$(3N!E2^;Rm58wE zmFB{xS3<(3SDFi(UO86S^ooN`-%rU)KPUYhY-~*{!m{s1b9*B8y)EtgJnVaqw|@0w zF|hQ{VY|OFi0#2jiQ-o-!tS@R`X{o!3tPVS(sdVC&n`)^Clie+zqV#o|9gTKoZN@t-a&{s0z#3_Jb-?EXAy_vd2wKcQq|@y}5l z^-1+fWso{oeUI&r;btOu`kxHPIR02n#1l~botVa(Npa;HFGNcA*CN+R2HNeqm zfF{IcAxhwAlt3F)L0hdI>tj#_y4FJ@2aDbdteoF3~Pk{8AODqW3~+PVdFt ztfN|#aPHCWQBISp;51ah6!zbXHqg)pQ4UmeyE7%sEBh2r$1UE zO+QaRj}Xq+&u5R&6`Ir)X;N2YOI?wNuDFpi-h{e10(J3cwr|mIQI6JcMPpcKjQhFH z=_rj0q|zuwY0P8Kv--2_nP00n((CArbg4I5O1;ri>Ww4O8($Fqm-<&qy1q%@#C3kH z|G>6TAkC!$Nk@UGSlgPRDMuJOYQ#?uQyMn3P$TWD)kvn1so2$OMCg!K=#Vx_o^iC% zmLr84Ia#Wa0;xt$LXC7(g2r)ZlDuj)B6LVb9UXEq3WPe>I2G-2veX``QGAHr7)(D_ zjov7sH>;m=l2je7P#v_F#sE}D1F1Ulr0Td_s*X#f>d2OQLzU{Hu~Zk0rMhS=)kR~e zE=;4+s8nvKqcK#}#q%hK1G++$x?;H06%D1XNJmk8sbm{pp(xU%qBveEiX%}JTe+j} zjPKAA+l*~WzOmid&Ym5pi+t3@F1B~0F)TF39=3lpeq?*Ev6t>lg!ghw9iq|a=VwpA46rAN8aWy@65@aJ&3yI(NPnq7dPoIw zs#G97qyjlrDv%yhft)H8$Z_Uub2jItKaw^5k*tLR8D$Cu(!vx9q`g!iIVg|>XM71A za*@;_5vfCRqz;Kl9nwwekQ1a1=^}MVH>pETkUHd8sY6bXI;0&sp+6)BqVjnrS#^ep*_;=3{*tKZpwBuyE)rJjkK3)q`g!l?WGzy zPO6a>qL)|cE!9X1sYaTjMz$zH`&;{4rO^HkWfG9eBo}3}UCBq8>{K*+7y2Yk>XU5r z$sY8HP$uo9GHEN7NjIrXPLRr^n^YzzNM&+t9c7Xyl}QtnNdv6#Y^M<_A{Uj?QL2=t zQlEq!7A5F3aSE~ZYg9^WrM1%rtrC!0C0A;dOteZ@6hb$rn{teEBD%$qx}}xWEk{Y+ zQXq9phSV+1q;ApBEdx*j7ob~Isau*$-BKiVizao8PwJL7=$0$cLN$t|6y+lni-uwu z%m3bhVo8&VCA*Gd(WPQZmx`sOR4hkI#gZ-+i(e`hT`CqIisd1txibshVoBX%OWhK# zqgx8B*J7ELM^)p-@gqDjTlxQ=3Je3)YCA{9$JsaV=d#nMhHmSU+`a-?EuOAq}w z+^JA3r%A=q6vd(`K}-yKk$iL)DFLZoa#1g~l8<^x!>Ue4!=yi zFGo31YMAqVxxQSsg_1en=l2EJ7J9}Iz5Ys`R5h7W)#Qp^f9!I4{Rva(nQWtN7b~Js-}rlHJMV?6!`A)(Yq~GO%qg26urTS z0aqgQOe;nV?o&>ZdZvlgGnrD)WJo1bP)ErWNF`IiNCKJ@Ju`=Ee$qFWIC%;^lP~p* zT1U^MOFg4XJ(DK&OuBE8Z;^5|V-7FzUqaicQrl=!+o--3Xd6vxnEnQFbEa}bDo99jSm(=&$FYPs4hsDL= zvGd35S(9FO*^oE2_0(|3ys6>MEtfWVxJ7Z^)V!(9n-opSn_6@CzvVM?L-zXYSjN!0 zOV+}gC2voDkGwspCHPX_p5RMjso8V*XZpzcmW;)}ZOL6x-|?CI>sc(hFSV}k_u75w zGk?vJX`Qy}tZ|uEdZz=ao_@1f8WsPV|No_9GR9Odi!;XLuE_eR<{oobGKa>#J-F% zp)TU{Uo9D9#4qHx$5Q$3z`FhC1rsuMrfhGDE8{{{7(SGZa(Kc;k8vmWPp}wWzV;SAkm;9?GYbq^V z^O`hkTtfQ%ig*;qbI#wmG+35OeGvnkbArh2Vv*mPi?u-H7O~ZED{-DbCL&nn?PqUsVmyH=4kH}3gNqSc4TmeKFOvDBPbd}izv3um1|4Ad@}bFzn!%cxUCzRT<>${6>-U5GoY zy}LSgOv;it$YLN25lU(~q-9+r^7)}{TIPmSizQmBR68VEo|@W8roK!`5u!*zu~7e# zD_E!_Yidc6M^b04{%vv1(KVl`{3Py*d~k)Z$i8x-A9PwF`{uvXA?TuI`^~EiDCA|sDhFtCFUgXW5+`(i*YA)89Jwl`&%=A{$lB6EsSK9PUD{G;+BG!Z<7I{4r_(ts|_fZqoxzbb|iff)p z+RfpZ>X^&iz#`L5gjOA!8)Ysb$CG0yW9geSEk(6#rHsC|hRmxM>wfeKWhCjjr`Oh# zdlGWZtO54WE64h;tp850ylURdQ%QutOnI^2WzQC#^%Hy8Z}h}dsm8n!m-!+ty;fV2 zam!*}x+c!XdGBWHwq(qh$^VOeW&Fozw%W08Gv1Xn^NVDH|0-jC(BsLtI-5{MDE$aU z9M_)X#9O*F^&iQY_BMB*6H0OQ{?SYqc|2Lhf0c2a2}a|q&(GC~Z|pNa0`bl+y(TPq z<+}2^a=P}dQsm2Lq{7gi=MIPsX1cg$5%Y}=es{(1+(U?CT*WX~Cr6uWlB4aPA<5Ml zMgw{6@{VPw;+QgyDdU(jjw$1qhRI>ZiODMN;vL^n$%i=CQe`k#7OTGVQuh3fGrycV zJK=oBNCa1{egdDuM((BN3a>nHg@oLWkVTBfOz~8NL0ps)7o{SujMnnMxToqE=qKYu z93x|y|CawLuaFrU$sRNlLco9cT%osk_8TOxiA#7JsyNUh*})#oLiLW;?8 zMfzO~^F2d+)#L|@6pxb&MjMqdk8_jyChy@^EVVp2lTc=IMKRK7pwS`uGWT>fJ*N%% zpXw_!TX2_Kl2!5wEn-Zh*I?ps7JEmNTVhtB46TCvP?IM+!x6>zn1d9WvL^$%Y*KRUu)7fA@9v6;=ufnFh1gcKNdMWnXvaJXE|@e8W1^@ z(Gq1MS2&SeHIa0k$c(Cqq}xPhN=1SK}U<+S#z{3BjRXLPU=0nZrGzle*M))*IvoL4ExY4@eT_+ zgS>Pg2Yg5l_z3Fc1k$UN^eQF2N=dI$B~zKCbYu=-M@FtXYOCNaSO?UA+B@*B(vi7n z9htS!kv_1Fj5l|b|Mdv}^$7p<2>2{62n~s$A)*f8eur?sL%81|-0u+XcL?`8g!>)B{SFcJ1NS^c)EwOR z5bk@3sA0Kx=0DK3xQzbJVC;8>G8Zb98B7V7NT@T^&Tt}}1a~Vlv_<5b>UKqYI~nCn zE;CJLC^?jfSw?v>VLS+rz@xx>la0rKa&63pIq)RRg{RloXs0!x5aQlx~ojL+q;0^Wc(DNmV{ydiKITn-NsTYfb!8CCxZV}u+dD}79r0fC`vH$Z!%en$?&YH?gBP9}WQVFo!a^n2pG zrZwjt4vKs3q5k+6XDKCyN{OLTVyKiDDkX+WiJ?+rsFWBgC5CF-ZDOd_X5cKP#8fFU zRZ2{ia+XqJs+5>2C8kP=sZwI9^!MKjrCFr*ue=vocjZ%mU6G9G0SLl0Ahq-v$#y!n zj{a3Lp(jaM6*RDu^9=`PCQGn4qQ<=ayQD41)1;K^e&$A6?=O-ilZ zxQETK1$OZLd)NhgAerl0cTuL(=Kx61)O;SXI{XW7ck@J(AM?Z zWI1Op=gj4txtueXbLMi+Tz<%z%QS911B z&R)scD>-|DvnM!voU>PQ_DarP$=NG8`yY{q54H;G&C7?{7cy^0c%C9n{VSA11w053 z!Nc$fJPNbmahMHHFiWBvoB}K%gX|y`nTck!@&4euKuK%=V`H=c5r8q>r^{-MTPTa(?P2$)l zahWR3ev`%ZEc$LfEPxkaAuNIfyacbn5_lDs!E#suZ@`;SZKYwyc*0V{mhrGc zTgFqGQyU$yx30y4od9>jT@ZyhEPz*_ZeE~$6?GnEBtaQTP(~7zkpyKVK^aLR=Xxw9B92ojwtz6If53x zZcdOXf6!HHA0_Yqm$t>H{I(H3gU>A*ZxatI!Q^KfYIsMM7PH@!;dDU$Xs)Z&|6CAAlyu-BL@2!beQVXrBQzN}qTPt~} zR1cNvp;A2*swZkG6zbtM)fK7Q3dQOv?GCwe_mC@h|D!8ks*F0Q9$kqJTqX5jsy=;- z?dm#}t9QA2m#cTVdZ87?)k{TuP(6Ev)Quij?<(yNx%yud@4rpOzD9i3Rk8=-Un*L9 z2x?k|`r_ZM6aNQPZz}#>8UM%p>bhk=YCtFey!qFv0G(|EOt66dHS)ITg*;pp{JI)4 zdQiO4ud}@xzJP789q_BkQ;`aDjurg|xDjrG zKf^6>E0h6mc+$tg?JyqhfC+FXOr-afH<2?QJ4jf!)$m0=zmdPht=>t-~Rz0z&~LFdq<;zNA9s4tvvexZk3~L+kq=_deA&}fLS88G-N`m1 zU*v}p@o-yb&jF#C<#1_dTHbl`{{@Cy!$<(BkT}xV8D^ zKDMX9{XpLk{TK;71`ohY_$$!EsaF8KoccrXFwonn)7z=j+o?YWBJA1l1kmHD)8nbr z+|4Qm=9P}wf!c))0Q!@7=F=y8BZy@1F-R(J7FSV=R1?&ZouBJ zv2D`(P`W(w*>CRGBcGL%&&tVX52 zFlIzPEGHk9lMla-Vu zc1)uk)4l-O32i%|RJHFZWf#B=a3kCVe}-G&Rw#qpU>w{Ilo*{7qf=sZN{mj4VdO7H z-bpYvJKFe~&z+PyQj_ufgo&~>8$by1p)p*WtU^^+p{lD){vTysg|eD#JP9zxd)QTDwKDXMXiSVu0nlRp}wmu zt_!VIh3c+CbywLxP|B|a?$hBu9qtqTRpmpO`+C5sa3PeyNSFgJBok@JLPu(as}IS~ z71jB(l!4^BE2z6GsJknuyDO->E2z6G z4%MeZRSUI8`KVB?RW$m$buhpL3q()513pNDbjW~A$btrt4Gkd&8bK~F0;c#O06_>r zJ~V~`2m^ibN+Cp`2%17OXbwj}3pf&5f|%pb3R*)OI2zhQJ7^EbKnGydOkvbaISx9( z@z5DgfG*G#7->^Z1V-eQlYxGIdH^%%0nDHWFoPbz40-^?*upROk-W=TLd{6V9=7Wn z%^<#v`m{?uy$99}$%p94dC2D4ZLZhmIvvu%Asrmj!66+S(!n7eeAmF;z(`3N@smdU zq>J&2(X`0FdF+uExr`RMj25|!7CBCf9H&K&(;~-dk>j+;aa!a!)}I)2D#iLM#riA7 z`YXlyE5-UN#riA7`YTmGg^lnTd=6j0m+%cRa|7$Il$Jd~%buWRPw4dK5sL}^pTM}C zPH(pU5qu1v05vo%e?r>h)Nr)?30nRHEq{WRKS9f%pyf}{@+WBd6SVvZTK)tre}a}j zLCc?@9Gu=SgEC0sijy5 z2`q#J7D56GA%TTZhJ{dug;0itP$vAN(QAh`rfkM3oA_n{F`El*OxcW6Hsh4dIAt?V z*^E;*Zd^{W*Lm=a}=c6<71Q2G%AOW+y20 zinpUDw;esX?I_!E%66QxEylA&-$Xm+oki^=;BoSYRSXT``_F>+Rn zx+6~A5vT5mD|58QN{CqzAx0EJj3|T{Q3x@j5Mo3j#E3$O5rq&V3L!=mLX0Sc#7HH5 zNg+lRLX0Ye7*z-{su0rlLsALp8t7nv2^KKRM0dak>3}a5JrlB^0c1l%$bm+X3uizd zI1A2(zHkoohjU>741^0|5DbPAxCkzWOJE3G3Pa&JC4|qUkTDK!hw*R+On^H9uRF$F zFbVDk+Ajl-JH}-A3rvA~VJh4Q)8KxX4l^JI55PPiJ`Lg%Pf8(!_%w)5<3%7&4dT=w zPK}pgF%Y)~acdB_#!`3>m@#BvBvN+EhDLp-G%;u+dq?a&MNB8 zD(cQE>dvY<{Ya&>+@-YKrL^3o^eIK@Q;O1p7t?|l(}EXMx0X@2meIE)W?z+HYgJYE zFNylJiuzQ{rV)Ki#kAhV^f5*0V~WzpBey21*i!1)QtH@J`kA8iGezlViYiGB z#iu>ajFkO+GO|NIQxshk)it(tFaRB_TVR6&K1c_YnvM$7QIR?-QqP8lkOPe%7tVk_ za2A{mec>GF59h)F7zijheGm)=l$?GMTnv}M5V#bE!hKxZG@u1Rr$y0eQFK}qofbu> zMbT+dbXpXh7DcB;(P>e1S`?iYMW;p4X;E}q6rC1Dr$y0eQFK}qofbu>MbT+dbXpXh z7DcB;(P>e1S`?iYMW;p4X;B^f$QS{rQ3EwhL8h}k>o zh1ey>{JYveF%y3uB~VXhU=d|FS7Sd9hiia*;EaVE;6}I!##4f^cF?|2v~Lvc8%6s@ z(Y{f%Zxrntbx13R^l?ZRhjejXhd1EOWLGSxuFhMWZ!NsdHa(AwmzObKUgjf?eZ(== zRR-2ohOZynT!U{mJONL_TzCqe0rG*5^Y}=2-@CA$UXehu42{i`6AC_`@Vcb%{6dM+ zRk@MH!Hub&RVg1ZpuUI~qM>R+_#aZ2 z3;#pv7x*8Fs+)ulQgyTNFr;q5x6tG2w|EkIQ{5#!DL2OJ&u3b5eEe+H+6lit+6mID z@`-p=Ry0?5^wD}r-^yp=#V1!gTlnwM&KI70v_W|8>8ni=-g>lq@zZmjHWlAIL$&Gn z;~Aqps^gDGnsiA8jh=%y&aQf{^vj$t{W3Qe{%rIX_^`P~KN62MBlVv6 z#=K20Hf9<#_5RXF^SQ!TjXps7Xg*K+XdWzmG?xm0Gx`I@x2CF>W`G zxCHbi!e5KNRQPMrU&B*Np}x#4GK=&TW-GImzEb#T(O2P@J^Fg{Uh`i4ee-_ve*GW9w~GD&UR5gee+o}3 z`iH`YivAJaQ)cTQ3%@D)r^0WFzEOBg(Lcju$^!j!;m2A3Qus&Fw+R0z`nUK;c|-pW zpD1tZ+l3z#eV6cqqVE=dQ1l=1gYt#G7vCq}==;oX&2J3_Pba$!RrobAsB$dLu<&1E z8)?F4iNQlrczMpkH%Wofz$&x~ja=RxkjQx0$U{D&r z5$UETyhNC`@DgGAd?6pUv#+tQz|8Qq@U<|rgf|GYf$#%iW(z+MW<%lk*~}4MAIv=A z@!9kXPY-5LcziZP!sD~qRCsPMTjH}}hIy3m^=uw3d_9}(gog(67~$*L>>zwSnVB8H-&J^S0zcU&}rj)GRu8rs0o&=%T3dpHI{U)1Vie4*ZYC@p#&E@w4aRWzWU)wyQk|55dDg{?Hx;@&{h^ zTs&~Q+8lTi=E76(G>|Ve@`Xme(8w3`fw=g`b2ZXQBaO5V;GeJoK7^0q6ZjN1GPmY4 zK0k*q;Vak#U&Chj2DZSruob?8ov;gb!w;|reuTa76YOJlkpe2531fixE@um}RI`O6xZ}`-6@u=tO^I?JF8a_yaENBBq1NjPXb}qi` zT!TDibcOCfI^(;}HArWJbjEj`YxIUb!2O#h90~l7$^YQF*~N<(UVP=uE7v9u+Js}D z0)%A~mR$l{;9DTx@gU{mIm)$n!1q9$JL!-CTqC}pTqheELJl;7T<}8xg3uTWfb%*{ zpb#QZ1WlnCvhD)Fnu7W?oFc=Sazy!DxCIV^gOoF>13Z#+q zFpx$LY2=Vb4rzp!CKunbE`DTP{3N;fM{@Cwa1Hoab@4^y`X<9)fc%5E9~WOguJ3Eu4Bvn_FL8_4QWvkJ zEZCt4ttnvy3e zT%M$Gv7=m`q;OSAAx~1cJW1j5B!$b96fRFvxI9Vm$G2E>XkDHp+_~@+JPpr4B~a>R zYelVF`^@8W950??e;!_7|3X*<2@uZ?h#8NI;T66wfmcC1PyS0YNUQk$O^y?@NY_D~ z8N9!tm303rtt2yue@_eft6L{p8redf!e|I5~@dZumtE!KIo zO8;A0Em~@x@~OY|8p8fdnVmfpE@S(05VM6#`Me7L1jB&x@`trrN71^77K_>7zu0Qs z!7=rr zaiN<$S}qUWweXP^?|Fb{Yx0Nv!Fn>=)rhi>xF zO&+?*LpOQoCJ)`@p_@E(lZS5d&`ln?$wN1J=q3-{=)rhi>xFO&+?*LpOQoCJ)`@p_@FOr5D;sJX7J(a(QSc5AEckojkOYhj#MNP9ECH zLpynBClBr9p`ARmlZSTl&`uuO$y0BGad113wkm0>lD23k5AEckojkOYhj#MNP9ECH zqvaY*%QcvmYcMU>U|O!hv|NK}xdzj64W{K9Ov^QxmTNFA*I=!&5=L)%=q(Su<)ODc z^p=O-^3Yozddov^dFU+-3#XuUjIFOSyC zqxJG=y*yekkJihh_3{pSVjml}y7j96>3#B%^p$aN>y`3Wv5fy+4l7_Ktb#Y73R10? zD|{E!eS(A5%R}RNXgm*%=b`aDG@ggX^U!!68qd={g^lnTd=6j2SFj1bhRyH|Y=LiK zD|`n#VHfO%A7Bss2z%it*a!QG^Q01HOg+q)dYCcwFk|Xr#?-@%sfQU;4>P777EhWm zt{!GwJQgmW}H9FIDeRN{xIYGVPgiw-~pHi&%%6I058Boco7ys0$zfbVKKY{ zOW;*l3a`O3SPm;-C9Hxk;Vak#Tj4v{2HRl=d=GozN7xHL!9MsI$S;iZhfVT{Nxm@C zfP5h>4)TH72=c%W)LrOh554T6mp$~d$JoDk?@i4UOCGw}LpOW&DL~xY#JznU&ufB_t4@V zTHHg6dpuh`7^}uZk9+8G4?XUo$33369*kAvG2bH0e2XyiEyB#V2s7Uz%zTS5^DV;6 zw+J)eB8+bL(Cr@cF2c;a2&3OU^t*?C_t5Vi`rSjnduVqL?JnvwY~Ek&H9npBMZMt+ z=mTfMS#UP=1rPcG&wczq*~2^uyF}>xd$|6|@E4c@_rg@T52nHWz>_=*&!Ayh{qO9N zUd?sU8e&=fXT8yR%pdum?-N-5tNR3)$*J~$Q=uogPz=nqQ<-b0l806Duu2|Q$-^pn zSS1gu`=AEYVEu})pAQy1&h#X5DdPF<{1 z7wgo;I(4y5U93|V>(s?MO^s@t#pl`37w9d(s?Mb+JxetWy{3)Wte= zu})pAQy1&h#X5DdPJjF82r7fw>LtupFJZQN3A52ln2lb-Z1fVILn~o6dI_`9OPGyb z!ff;sW}}xd8@+_t=q1cXFVVNd4)`8+!Y+>BPR{IhOuT=Eap5%%R3gcICX}6O+wSeNoI&?!mrOLHPf2 z`7DOh_}^Z9Qm54&Ju#@ym`_(C<}zbByFAMj#d>zJo?WbG7wg%@dUmm%U94vp>)FM6 zcCnsatY;VN*~NNxv7TM5XBX?)#d>zJo?WbG7wg%@dUmm%U94vp>)FM6cCnsatY;VN z*~NNxv7TM5XBX?)#d>zJo?WbG7wg%@dUmm%U94vp>)FM6cCnsaV>zq<6dl&H%Pjs9 zW?jv~igvN0U94!=*o-3B%I9~m4YtD$_#Srg+iv&)_VE2j*b6_wKKL2P=UCM)R<(;& z?P68CSkO0I~cbKcs(-0-~j$94leTtXC<#2_v{IEX1t2y6rxCY2;SlKRCwu_bR zVr9ELNm0Vn6D2%7QNq&`C0N~U{%s#2ZHOG*qV2%?cCo%)tZx_V+r|2JvA$CyUkY>K zHTwB6>QJu^9gto=E76(3_Qp23*ki|zhj}hSm*~v*4}3SyL?{{U&Chj2FP#B zLoHz*Y6=-$*AG#5@jH7z+21P?mkgB z@wU4?8ZT(kvbCTV(OR;!*E(z6^_E&MZHd;G8D$r1^Rz2r1dN3;mm&_P+Ls(Nx>S9I`#;P+eipmZN9uK|P|k)Z6Qw_3nBvBdGV~9c~xvSL!45v3i+4 zQJ=zF*dEsB==1c2`VxJWzLqzxeZqUyw&{BeUc$q>nvc5Vl3}BaL6?g4s7o)o?lOJS zrI%hk!YI3RO#5T>DXcr_(^(&@m$UAuKg#+zeGcnRdL`@Q_2*c3))%opL0@v|m}A=O zD_9?+SF!G(uVa0z{yyuD`bR^Dm0n>C9XkA)tM$(>A9=~8#*|^#TslnOEZ5uQdiU_r zSC7>9T{Cj%aAVjAz8Knd;@X_+N{3%=WLfd>%x%f^^EYEK~R{gmo^=TQ^pS+bx z9A~$w{+y8dKkt4`efF#V99DfF>r&sj4tXADbM^O8)#t7L%p6{QeRETvv{dr` zYd+06spB&~;M3tcnx;N!>Ew4>Iz#L?=BAEI=gqU?deg_HKC`OhHEU<;J8x4<-S@=m z^Hd)nXqnpYRHq9rK2p~`A@!L)IrW*#yT3*Fd3gC2pTX+zYtq;3lG<ocicRpl&S2J5qZxvcv#qd=wqpgHS)K9N(; z@pWX~-`9=xxxSvP2l)E1K95>f<(*4|SmRlRbtAdP8w%U_IAKlHvCfg}6Xp6;xo&8W zVt-Ft+_5X;q1YCwahfgiOfUN?)~DN7vhHnP&iV}bUtQ%|%+FPoljQnj)|%WBpPiI0 z@_TpsIw*QdJEgsHtkRKfi;`x_*zhUoe9u&J6+g9WJ{}~SC=uS0+FWU&v{YItsl0t+ zR(aOEtYum6XKiVqWbSQ{+u-5sn;VYL%4pEC!SmVE8a|lSq(Qd^RoPEBT$tH6t9^sM zSv@i@&g$P_XoHQ}%d#%d8rxuOgFV?B8m?;)&Cbf+ncci$M#C))o99@Kw5&ty$B*gvOBqb|8EvM+BqET?~?0l7UDC7I+}#64t_d$iCfeD+UbR7DGw@y^$YV%|2XC(hZ5|5ixB)VG4r#e7R+{|Lnh zbqI9|b>Yk!*JLnPHzeTOFuc>tFtDh!;KIh+LY*6LV}GRa`GiB>$p3^8+H(hr5@3(o zcnJH}h+m*}^)bBnD}Q51lx>B$=cxQS)KX*Qkz(J`Vqa(y_^bbux8m}RchB)(sj$Qz zaX#MZoIgE(dT@yhtuaSjt~im5$Ssju3Pu*JE?C|8%XWL&J5+H(`5~vV7TgqE99$Y) zAKbuo58<)N)6EO49@cf%-PU9FefHbj*M7y}?QMCy&8?BIA#--c+uO8IZ;tJ44zzk& zqpf?a+4eMh9eaDRw~sl>xDH9|AR5?ChhK3sj=fWTf6H*ie#p5C`@D-5kV^$mEWCxVh?E=oGn7BJ%;=kNYxFBazZMc;CjUh?yFh&RUFORql1(2 zH-DFYmp)0qTaW7Z=#%xoV5{BBsE!sKLQOJ5iSgv}Oy#dixl*A#s63=R?3^yn8|bd6 z{<(anuC6o3FH$nJ`P#ztGkGuZ3T-vpE3p?>YAe&vs=kW8iX9wtVDUdJucKM@uN@R8 zcz)f*KTiIB1hKtO$*k`xd28Wg^w!H*4D3*R!9)K1J!A++Rv)oeNek>gbn!>zF-LI+ zQ}Foy9hU8OZ3jeMul5tO&mZMV-U;-~zx>F}N@m`|K(G22j>7A@ zHOqS3dcvAx&9$Dkp0VP*FY{UJdFuu1MQfq;H*10Q9LIIxxJg#jnr!{Wy4SkTnr2P6 zW>_(+!g|np*m}q+w`N*@<;q4WjjVjD@vjLpKbw)7&Gt9U!~fRa%DXhTF&BS_{XOr{ z+{L>ynUQZN9fh}L?sp94x1K>cJCpKrp*hGLOes2zGS`Q)G?tS0XG+u*%HREzt0%3etV&AP{glNSl(E0t z@7V8(k{0Yl`?Fd3M%ki#t87)iQ?@DFl^x3W%1&jMvRnB<*`xfZ>{WhJ_9;Ir`;{cs zu&Qdjewv3FR7KY@W3&$1 zv06v%IIWX*JnH8Jt&7%G>!zKkour+tb=OYOnmIF_zdGgIpF_E*{liCooj*0L&KC^E zgT9HHu=Y}zofsdFV~;fU(^4lzo@^dzkud?Lw^hX^{W1|{t7BAp;zgP^}p+j^mY0geW|`o zUx6}vU0rd7&>uPJbb&WN`x|TP}jvqR zt?||!)9sZrh)?+KRW^YWW+Kw*P5P``5LC ze!ZeKDONiCH_sqi#Z+q;?yelmo0gw2=a^6Ow9r%L(>xor#C+9UDxMB9mzyihmF6n* zb#tTnqq&#&81FNGHusA+8S@@vO}xLDr++edey7N8D&Es;A7Qt!kF;CbN7={NZS8h; zd%Kn0+HPYXO*wC`bWHE}f9Y&$vmwffe$8+B)BIWf9KYY6?{DI7>Tlt1-_Wm&-)ko7yFm`SNK=^*RW^3{{#O={*C@G{hR$;6}9O`&j0Vi`8T2X zcldYv_xkq-w1CCqI$437fIpBQXcFiVXc}k{XccH1=n&`>=n^=IJ;j0EfwKbr0s{gA z10`47hZZo%ww_EdW>s{iV*5)27{g?8BwcXlb@y_(f9L|5X+1K>Ue&#u5 zfAd^(fO(#IJ~jMM^D^^FvlOj(1y8;GiKpGJ;kmb~%@I8Dc9D6pd5Jm1ywn_NUT2On zN1J2J>&>y|4d#vJP3Fz!pUqp$GV?ZboO!!B-n>J+i<~!+-zDBa&NFhi^7iq`=3mSy zw9jgD^kP1?bF<0RW_)jU3*S+-&83zrTB7tQ81CO3=oxq{I6QcB>aw86k8UW8}sWugMc3*z!+l-zfj^SvbLYfKfo%$~|KZ|{B#4pu* z*uu8bf}8ydYxk-Crxlgn6V?A%oqfDr%uhV~r_|Xup6?^z<~sYtcdp7W)OPi?1}FGY z_5K=VEw0}P%oIx=R%_l?juY2w1SW_jZw>oCsogg+z>>Fwee0_CsZB}$;N^<$&-LdP zrSgCt>=*1;gx(5bWj3v~wS#D(;7LvE#6Z(*j%md)d=j3x7L(MHOI}~jGNk$}rhiXr z$?MMEezkiyQWLP`wP&yB7f4j(> zPMy6LHDdLWiz3LKz;EJ;Eo#l`C70CVx0?MLb*o%*i4A^B?Ki2h>rrNk{en;9atJsz8c}Fmp@&x z^Rf>tjn3znt7?A9-F;wb)RSKZRR6+t@!UmPThOYR*RX*4(9;J1Vs_>cTH;4*F$au3Q?S&~ik6 zOZ|@)?oF@PHTDSmT6?5@ojuAPZI7|9x5wHy*f-iY**DvNwr{a-wae_=>~Z$(_IUda zdxCwZJ<-0)o@C!`N9}v;$@X9DDfYegR4j>Uwf6V}_DuV)b~#Ih{h={gk-(oFO?wn#?3WJ$GQc`tGepQ)-qRa$LjDYwv|z+GteG zl0ytMtQ!MXqw{N)9Lhq&17$%gc%MGMr|oC#N;_`Pv!Au++Y9XH?7!L1+b`G)?HBDu zcEWzie%W4ZzhW=3U$vLoui4A&<@O4DrM=32-Ck|KVOQC2+H35$?6vmW_PQE1V!vm< zZ~w#ofaRa|2Kz(%Bl~0fQ+wkf-#)Rww7;@Hvp=`LkXxJVuSHJFnSEesNc)vtqxVJr zuyZCJSQ?TOvg_sqJLjqcOT$k5idX9DG*`p>l@k9TY@92xa7JO@lm&KT-$b!)V%Rp1 z`R4|k2ln~rVcEQdU9-x+CTRHI31(1cKf$WmLdo7kJ7-{tWMhXEV1u*_v<>z_VGj+C z2;Ll=7@QV-IQVpMVW1;6Np~!gKEbuLscnOuu}jVmlmvzbt_q9@j0xNv7#EmG56H4$ zk6>h~kQ>&k6*DB}(WwtioI;W$6 zrE+y161@|t-jKt!n^4JxpDSA(+i{#U$8t<3-O1od{4A$|)6mIr8adfKk)P*NoYQ@( z6L5k&nICfUc{0Dina4TKaQZlBI*WXo6ZYv&6Q|ILI7L3gY3ej{j&NEzEuH4hQBG^0 z>9lcf^$62_jh%=IVU+MJKddAoKu}1PEW^m z@Ymz?;;H|$oxYCe^mEQ}V$K8AcUIx_cg}SNIOjR%I|H2yok7k8-0c=;uv6k(>|BDE zfFaJM&QRxa=Q8IC=Nq5xlsZ@W9OqBYFy~>PPsYpD&TwCvbB!~?8R=Z_jCQVd#yDer z>CO$#jm}NJ4CfZ-R_A8t&rX>y(;4U7?%d|f68%cV=XmEX=MLviXQDH~!54{hcRjIt zk2Bf%i!;TU>fDQ;f@u!#j&Nq+jbMed-1&#|zVm^z!TG1N&iT8uM))Og-g4e^*5aF> z%6imFIGdc!&ezUIz6Q>>&Jt&<^RDxu^Re@Z^Qp7Z`ONv;`NH|q`O4Yp>~;1yKRdgf zADo|@UCxircg{9vyR*aj-r4UY8K=<-H>#&v!GD*=gnx;~;COr>L%~V?I!w;mTetRk{|Cp4dywt9QrA~*el&bp^2mpR|2^wzKG0g$=z_vJ-8>+~CF$5efcSToyDrT0iJTnp;}Yr1ef zyf1z=d7m+zi`&JTId0;3MmGwVN&8Dx+i)CuqHvS=MU0j3A6w-5N7lMJMIXjH8TdsF ziT^H)fjD0|JSg@HA33sBRpscRYF{n>kG=TIsX04)RO>F*hIt?UT4tDpz^Iz0o}&Jw z`^9$ZcxN!74u=u!V`7E+llW9m;TWxONa2;NuN1!%?gB+G99}qveH3hjZdH1Ncx;-VH>WL z`%W_Z(u+2VUg*cM7FWrAJABdBZ^(VFc`kiyH`7P`47TK(a$hg=e0to< z=&^nl%aZivyr-D`=#jgg9_=|;o~y-m3m-w4<+te**l{DEdpbi9Qf22*D?OiKh$%|x1+7`ZFxU=xF!o`K73ZsR+NUum?$0qv< zvzk;j+0bNOlf_M9O&)6^@?<0Hu6ld(>BFZdU-aoeM6do!N=|r3cwZB%Np_R`Ce53) zZPGbBKfEZsG`u>zF8o1wV|a7;mhgD)+|WK@rYG+y(Y|2&E1oqnMJ>q4q((f8oS@2_ zpvs(}ivA&yqbX6Ehy}K{ncG;W;zCvOxX=080(q~Cv;_CNj5}V*yq?z?uX#gzQ(IGW z@8WK>XLa*e#Bz(mn+qotPAQy8990%BEL>VxRk*(Jlfuo!+Wv?W$%zz1T147Mx{!^XuxDYP!v2MWC<()e-Ij%I#a*jEX#ws!q~-IxRDo8Y6k-?j zQzHCkGDm+oC1@qj2denh`dZ1sQVA&$?38(oXth4{ERji(X^{sbb0YI2FGW^F)+{v*;AwyWfb{~B1Nr=Iu@N&)T^jp(V(Ksi$)aPSTw$9a#1Xj#&zdMnnqehI$+1P zF5FnSrEqsdVSjF60kj3A;?K`ND(zcEfV4WA_h!HaspIjf{-k7#Y`ie}PqyRp2jZ zQqUqYtnnVoT158V(=N+i^mAz)#n{vtw2@-`>t=zQ`Sw%?;7;Z^Ra|3G%w^0rWY}Wkgk{!i`gbQks#&U6zfQH>hJb!vyOD4#_qv3YjItaOH-_= z!7rx#nPN@LG?H>=i8ZrU#*>4l@NHsbGOfr=YWLZEdoc1Cwfwxu^OOXO+I~@F2`x(% zdEJVvriEEg&A&0SiEp3K0&I!wi0p~%=i6>dfL7$t8ssV#txpcELK8|uE5)XDXi2H) zSk$Gcdr>jpyHP%R6`fVozi435#e5$?>olb3%A(;#qv#K}X{W{%-CQ)TXd-RZG`>$N zno=~qsJ!UWqB%vCe1EKHZqdA==Zjt{T3WP<*kVa%L;-JcW7AJloTAF2=l&0G?*V5u zvHs!DWRe^v3y6Sv&e=r)5fM?bUPZ;Oh+PpC8}^31_l7i4u_1`PgV+VJVMoP| zuuGG=*sq=c^X5I-d%gGm?(g5>^UQa4l1V1-OmdQUW|G?HYNyw}Ui(h%hqa%Pl4|YT z+J&{tYQL%diIh}pe=i2b7RA=Z_J)T-(PGD9O|ib%z1Yim)#7Hwt&9DNyA<~-?nhex z;vU6;#e<52i$@nvD4s?ShA$2+o>ClEJimBp@#^C6;+Wz%lN5h0nd0@uQN>$|cNXs{ zK3IIbIF;0Uiw_r{EIw0wsrYK~t>UcWC&f9YsyL@Ozqq8>RQ#d%Ysr-2Qp-}?QU}_C zuiW`QQ@Qv3J~pOh@tfjL#orke(4y43)V|cQR8y)ibuab83Z8qUyJ$6cN3_>yVl;_6 z{>ik!9B*2D$yCW(6ir+1oPXwCt}3oFHQYU~%Y8+g($>X=#by7~mP?F(p%wC`N470{ zu<0JcbPrLwhZgA`TBdtwm+ql`x`*0y51f&--~ZF+GIwQLnI4=0dzuZokH5zB#K-xD z*@&&g^b9^sDW*kla#Zs*mxgtXom{L+PH&xBCy-cUFDaYlO<+kMx<$SqZ?pp3y?o-~fyj{6}d5`kI@5+&wS{B z5h5EC|ABeY0pmpa5FQ(EN_bq%xs&^mnHm8jM>Z$^6C;fS#*px9l>0m1K@4&~GmAQ4 zOvx66C&pV6o)m9IcydfnAY)9nAv`tacPsj;#pi@`TYN^?*y0Pq`7Ib*7%gn^CE~1cpp77_gjluj0PRdUH*p5 zi4Wt;qx<81qGO3&5j_wOjE*DrOng@~xW&6B;)#DEPo{t4dJ*xYKZ$4k?W4Vj4`YPd z@OX!4Z{lZhPjX|tV>E#HIozF$jQdCX5I>LcYop^`B7QHqgL#CzmtCWMiC@T=wz2W< z(SF1)VszWh@gC9s#4l!?+byyDI!8Q3jE@fE{jcwtm@z+7<2#~z6l;p zctCU%e_hS<`0ddj@&3^;{<@OUapM@ZvagIzkFVls{WeCh>=&KG^-Z4p|HT7>SAAEm zzH;5IO0T=Ex$fR$*5FF`5bN{Jd$SJpJrg8}nR=Tbj*e zEQIMB{}KOTXk(@rFN>RuO$H`|36Ds)2T#sPE+!n2+)8*?!gW5Gm`oykAbE)J@q}l# zWJIh8i=nD#)kcKdRBb~zuxcRTaaG3= zo?3OP+%=i4%-?ut^+4WEbd9;e+-+X7iCx34Ys_2|F!u2?oJt@ad zl;i&^J7nW<(qF=K1dfct`lEUL)jwOMhOt*_ng0J$qMQF;t(*TlWeQB8*#}dU_XGt) zOc(AGt}wf#9=f5y4ZIKN_~6FiNpnIl1s}x-d=xL4G59E6Gvla}H_dqQqnU~LCFb%~ zng)DVQ-j}w-cMZT+p9@7fOKzU?Heig)LKy?gt|2rluR%6%Ny zPR{3l_X=gB(EiIvv&?T~O@5dB!2F>6vH8>T=jX4?kI0Y1NBU^~nfwgArk~^+^2_o+ z4ZaanN@ymHiyQOAA&BHvIP3K8$cFo+HB|Lroo8N(_sll~F zd6K%2=ciFTHQmdz(sQ-1*1lK!S?&DV6}3MVO)=p~C(pfWui}>6x9-LB%#h+q#k09P zy}me>JJSb?Q+P(1S^SWD(8W9#{8|cm+UUT2W_Rv8w=L~b8p!?Sv8B_vx4g16g8RyQ zN{^PF;qLLB(kI+GE-U@OU1JOG`8snK*t6WX+>d*`1IkBmpEs<0G52_5%6FFU=T7d0 z^6T8ieNkS>9o)}#L0!wbwd-o?y4Lls+q$lQ-GI77>W;2ErS9Ci%j<^M-BLH9?%}$r zb<^wK;@)*`-IBWRxC@Qz+thcgFW2{|->iPS`rYdHs~=oHwEm3x3+u10A60*Q{k`>% zS9itF(YJa#JT3$9bR1DV6ranv_&Tnw9);IsLiL0H=A-_u`qzArPx5W?Vi)sW^S$zY z^V?Oo#e0*lE^`)c#jgyWP0qg8@YsvTwkq}5cDCc_5$c*=VY;PW-u|hVSFbI*rXI!J zXx9tO9;p{&KtiP2_qoyBhwo>Uxt|d#GtC3y1u_rf z2YS~$%ovqf=8?2-vXO zx7(XN%>L#8-adG=In|tPt}~;!rpP>wN#=N@P9JD@%@Q5wjF-r zYMZz9whR8^UUp-^b<4ue4X$tL-Q|+K#bf?alTsJKjEGpR!Z!)Akwr zyq#vJ+t=+|_I>6ce_%i2OBQqNT-#v3vp?F^+!j{_ErV7;Yewq#XdacnW3Ur*kq-$D z4UP#;3eE{G#$q;NhwJS&cYEUDKHMGQj^tW+GBc4+b*H)0xh7uju3$#8&UG2(#<&S?qPxdU zVs`Sw?h!Yck@GJyE?!2+zs#ukHy9iLsr%f`b@SYOx4?bvR=RJ(FwF6_iD$xR|7irQ z+zUzH)4a-P-9^#j^m;fa{wiJ&FOHYStNd$8d*0;VE4engF1eoj$dSnt+$p}4OiPw0 zP06a{o8&w02Y*O@O#WWgqRLkl_PMokYv){f@pYSOB;_@{U&KN@<;k5j)=X1Z z%66~>+rb)ahkI}G=IV1iYm;kbu4Ss<;Oh(dn-oeS&rI^4S;D#QmGxAAP5=IbeDb&K ztz5~k`bYZrAJI1z{e$@wmF+gieyzl0E4oy+BQf$-(j=CpW$XPR`{O!*=O!&1#jC^v zVvL*rmnB&WN0Bc3YrcP^{o{D`nAf7ORgeF#IsQ4-n7DbJzpnMybeY+jZR=ml_peJB z4)B+C|GM3OUuKx|{LkC|*X{qOrRm(-|C)DIDzR*7wq>^4yi`gnTaoc7x@C!Fd9yOJtg=*Mx>RDCm-U;MW?PoD zY-zS-w$_|iwp^E93FKPzYpy=EsOpr;-%~3(t)kN_Is@%ev1AsLJenrCG$#2pCOI{h zCJhkH|L$+oOecZ-Wkn#XEf)X(VTZibKV(g-bc9Z zo|Jnu4H>6GoRRZ{Po&|KX~@i2Ql3h~scHCh8a|VT&!*vXX(;~FlX5Sl;frbbQW`Sa ziuCDe_;MP~NW)js@YOVYEe&5!!#C1!W*Xu_An#jg_;wn;lZNl6;d^QLej3h7!w=H% z!!%@+7I|lZeAC3gOv5>8_*ELtO~ZL<*qDa%)36~87pEb= zx#V4th6~ehQ5r5u!=-6>3gL;lQ_~P{HF3Pvgm|k7@m3QKOT)9$@a!}^Ck^pmv-G?) zJUuwgQi zw{}bT4dI=xuPlvrmUwiagk~E_;Y}$)ywcJJ;$^&JQnvOc@g~bz5U;YdYEo#`$%vp< z)(L6|SMml!_87?0(QXe(cYDg3jy4}RIof=@%F%jBp{*t(!u4gHu&czyADoQj8I^TR zKYFLz**aNj>m}WGk@R3ki3dBS@&2+7BcOuhHhhe-^l4H$xj=I9zCzhcDCxEh;ZnOM zDWh#$S<2jLNpGL-WpJ8uIN@@81nZ2oM-p$cL(+9-q)T5(m%f@Vm3=kY*JUYhW@O6& zXKpf@w==TkfHRkL&fKbYZWBpyeF&GkO(n0}jChmVT-M>6NwW0ubm%ugqth5+&szU8i?OyFOjA8Qo^P7GEzp{%ZabBR}f!quax!eRkA+5 zZMMuiKxOYsBv-Iha>+9qWo{(AGgvNb1}oDwn+PLE?XY*Lou!W2;ary5S>dRiWVJh7 z@;c5G$}=P_IVE8oO2Yb-Eg9!159?4K)}cHc9pz!mSCc-%Za{jI?LoNAZYa5IPuYUq zi1>2bOY+){iLbJ~C9mZ?A}?)#bEhTYGS`Z5DeoDT{jNcLIqw>kJ+4W7m1~>sv0a*L zXuAIKEFI-eAROmTO7otW<~=#hbxNA+RMzj}P9vX9RrT3c?ZHP#eskG1oOH(9CQl{T$edlS96%h=vn zqAo1+sK`khX*%Z3%&FZA3tOz!K6D#ssX-8NvGen$RAw$2lxr z6`V_aY;Yd&rr>?4FD?4wd1 z`xxO$`#33M>=T4H*(V8qvy%yLv(s6+%1YgiwNn41?X#q;u(S@Y610vgZ)qJ>oh&Va z^NVX2?Q0z2GIty6;6WoC;cgNgL^>A;5bssz>y|DJC3xfr+o^WjNtgD zrn<~NEy__mlm5NjGUqyO!Y_Noo(IgygcPG5f?n(LzyBG1* zb|1o#K^sz*+usS71snxua7W@z0VSv1N;z)|)}bWDfKsuqKS&u9P&QgGC8ym|a@s96 zp~YeiS}Ycz#fk-b*gpx^!+jA{tshvzfk8mnH4s~k4#YA)1Zxof6eMhIMUYw`5L=B5 z)@98Ot`q6YU1!2&uA1~wt^@HVN2zEtdEzS_mZY`R5dP-K#ocBP(pR|+iH~(X*-kgN z5n*@Ni*N(CF<}o^%hJ)VNO+qov;GQKM|`!bC;Y*6VV#ZKdc;S%^$CA+T?v17-AJ!< z-H9)98xSs(H=L#C8Xi4#xxC9PJ=Z#>e>a)V=os1x@8v?5o4hFXzXnRX!}sWtk=XWN zlylY|lIn7Ms3Wt;N1u0JKx_3<#I>EbVu<>D<- z)%BS%RQX%ipITWTpF*0BN1>v+KHh}N-?~1Yg!FIx2o=@!@gY?H*7flpRQ}fW@g1ap z<2k6Pu8-HC^0%&!$AI^DW*)9AHl;ajYIAH_b8LEZEXym_(!64?ESBXJn`LQPUa^~| ziRH3bmRCGYSz4AC&rEY#mRGE(>xmt+Se938nWbfU#h#ib7R_Q=Ua@MHmgN=8W@%Yo zv96|xeY04WS8SZ6WqC6@%TuW4m6+z0nC6w3=9QS{m6+~Vo?ElLnVlsq%bVF*(z3jn zoz+(;rBYvE7R&NVJI&IvywX-REwi)u*s?O?0c&2G<;4TmoR;Oy>`a-O^JaFIv@CCC zXGzQQW_A`oUbbI6V3mDjc9x~telt7E^Ss(hVwzWCnpa}FUx{g6iRpgD1CZs->?~DXfENjl2*;&%Eyjgpev@CDdp2csO?KiWt zq-A+CJ4;%YH?uSQZ_b<9S<Ho7q{?vb>p{#s8|uE3s_9nVlsq+izxPNz3+28Pb{&-))wc<;`hX-ptOjUY0kr zvv_;6yqTRPEz6tPS<?~=Tm%UcXEHT}$#I(#3)4UQ>TS+X- zo7q`>&{^Kh&XShp&Fm~`S>DXf9Ak6d%+8XQ<<0CYX<6RP&f@3J_M6#R(z3jnoh2>H zOZn6Kz>dv%GdoLKmN&Drq-A+CJCo9!H?y;(WqC6@OPb~-XJx+<(=tm;?JP0PD>1dR z#In4Zo!M)1-ptODmgUXtENNNZ%+8dvId5iXNz3wPc9yg(Z)RtXtT}IHXGzQQW_Fge zEN^CKY|)%Iv$LdSc{4jpT9%h%PwNQlHRsLjENNNZ%+8WFgFe16+ALt~GIJ<44&UYP zajL<)<`KSpNVjXwks6q=!6d5(n7dc=S1p(U`|Q4tnJ#Zq&Q1T5w>Rdd+a|hI$-_nm zMe?Sr8lFR>CsulD4R2pgpdTHfvhey}&cewUuf_0HA1GpB7p^#RofS07bzMWDYunYX!yKpj+HTBp>Q%c%?e4XQ)m~J4W$iV!w=z@diQ1=X zpRb+8Or+Vh^J*8>eqFn)7!>2;8pXEEHp&;f75gx&XmIhU;w`0!F?L-_-AWgit}0zu zdcRyMA6tIEysU0Q-Ggz=NAvF_!%H|pN5d%tdR-Ku)S*tad~53fI}{`mUwUD|b7 zr^|j_hIF~Q%c?HFuHUZfX5Hd$?YedDR_=a&_lq`I-J`?3cip%8fgTN}p{k)*{#?zQx8+}r8E+o7yV%!){elaFD;eQ@uZ#au$Mw|lrfxg8BV(G*aOX1q<$B)O zJJHSII|{$J-@}W;@qek~ov7nIspI{q<0C3{Jgxe(>LtvZ{5^k1p-rI!bJ^D`Y|E_n zy()El7-KK5E<9eC%Bagv3SSkzOJ_Z|so5~C<5OzRs2Nc+zUGOVXP8g@Wm?CEI*!sh zUYq%B^~|Ww>Ub~4SzbmRkEnfs5tfq~W2tp4v&^)PBkFj~ztr)N;!Pz-9oIG2@q5(q z;PO=JcszCdB%>RjV|?SQjBw2AII7g~(0{7qi>c!uD|OuVKh|;3(6XU>!>$c`H5^JE zAK!3E!_^I=8g6d5r(tHpoQChIW8c`aam~hc8f()!?$)?jAt3qnm%iqSE*w;!~es-+*R%?-q>|n?n3tt zr~4_nqjOv34vfFmRsZ<%U$d;9`P1(!PF^u&#r{hc8ndJU7CE;??} zF$?qTsU0K>?Sh{dJhI@i1tS++D_dFE7dBe($$}3S@cysG8!YHL|JnI>HQv?mmp9us zo;2^H#`7C@ZtUOKvSDe%;sq}?+}==V=sa)Lyd@3E{DLua{Z}W<*?CUSIeX37@$*F= zpZC?apI(0Cyu;5KJg>`6H8<7Ft^K<(MXtc5R^_>Mb#Q+EV#E$({I`irC_>(5(% z&ib?0|7iX9>W?+1p5rOcF2{9ytbb~KslH1+*KzsR{;u{j*E(^n;p=o-r?dRs`Bj+F zc_85!1}@cC@wRxb*bTw$!4$V7{3809_n7a&oTw{v+sXRbzueYYjJn>8ap60nd+|26 zxw!`3*xb}&i7)hnO6LwwCWCh zTXB5o6@T5s06Z|f~vZ`Zotzvj!<|A)4wGr!@* zct$jiJEEAok&t_o7L4uQ)eOdye*_-yrwzu0wKiGcuLHm$> zn9;#sgx(Dc+SuQNFzCn#;I)~{vwLt{Ff=%x5x?>#k{5z0;lBLZb#k3uHD422C;HK? z>uz=9+-;1|T^8(2-$)hS&zAT;TjBZKjULC{>2KVF-o`!YYuqn5*mn%}Gehw5ABB(q zXgvJK;NL$M@BRq-??%#lH;TTy(e&I+q?hi2;C}NSJtXhbKQfEnkq?6D=ELAgUk={2 zRl$e0P4KxNU^@m&Y^PwU?Hnxg^}*M+HfXdxTuZy5Yh`=7)^<}~pT4up+g)72?&@mn zFxTH+;tsKwxQ-DM}c@%A0}rTx+^XVmn!p|jtGq5VFLm~XSa+0l0h`uVQ@P&0seIJ=oc_|i(J z;6T5HIoB6_HDldt&5dC(9Dfq;9VYW_t(>ieGqu^!c?9|#R?r!^(n_#E9iS}uCkA22X3a;Rt`YlZx{L5Ph zHD-7)hFL$eX+^6Tg@p6#qQ(Qvjg4w_A9p{SnRyJAb7(M_J^Au zX76BETeSDO<3j5<@<;H^%r|^5b53xqZ5h02FLL|X>)n2Kfm<4MVjj|F!47`^VE^C% zzop;S|1BIAp2dCl*}Pq6wBI?nJzVHF4<-c@f{DSi;cdKWX92St7W#qCI2)|yZa&AI z{0?qszn?$A?e7od3t9)c1Km;XXm_mN%J1#B=C1xccZ)y4pXfezU$~!{85Q{Ld_TX7 z-_!5m`{rVQWO!z9hd)JTT?K!*0e)A%dvFAEr3U$f+=anNzmp&0kMjM4dxQJp9{xPu zu)di;-=FKx;f?CsL|;a8s`^B4S8YbW6G?8zf!hx$&Z^zRBX`>tspQ z)>T_nZC=%@s(01KN$+IiWXGgOvQg4AZe*1E!gxtMFaA8)J=rZO@$UA`6>hkY?*A8Y|W_nZIW%1za`rx+b8{!9pdHm zla8X#XC;36k@N+PO>T<6Nya6&C3Q)?-P(WcKlC5@+0oawRs3bV*c7A1=6v(G`NA#= z+lROFOx8b4!YXr~{lz>MwltsH4rWWczTGBlW%+`aJwIH--e(tvZS1Gvnqgb>rCl8E zAD$6j#F`ar zD11A7hxq`{x-G-!!gu}K{!{;1xL&w^*fo61f9^kFR@cY=3;$)XPcYk_?B^t1%s#ej zIN87B-}UdAE6r8mK!0JlhrPutF-vXhaHp_;_&0xv-P~Wvw;_A-4auGS1>uI~im+$c z%Wh`-h8u@{Y&Y|~J=I_8FY}lCE5gmgzW%Cki*T!OyKwukU&vP?!=1xj!d-*T;i7PH z_;t7}xFlR2t_+*}1K~H}kKxbZuWrY1wc9Hg7#a6{WZl9jjN-^gNz^iG6;(xTqjpjI z;L_l-;BJ3!w2nK2S$*#WA4hGXHG}c~A^)KJA&UIf{$YPjw1&UdKjN?RkNWHVWBvyJ zxF7DH@HhG={Rlrf+|>08_lY|Dk$#FF<#zG+_&1X>^J&jb&P&cuE=bNw&bC{HtNf&> zwLRDE7H$wO@fZ91!`-5_!i~Zeezbqet{r|C_712!s z#!vM(`KSF@|BS!cKWjgZT)1VlZn$-n3%7|{gxdy>hkHdG{Vo1Ef2$wopAR<)zxB6; zKbZ&lD&)iApZ<3Lf?Y5Cg*l2F1=XfkkT=@~MRRp=7=tpG1M5 z=x6es1Nq9qMts?zPx?KB!OVi^iwS;-%ok2(Fkkq^c8r*m<^+*kH}_qmYz?eL}rv>^>YwT)sDkBC?W4yrW zj21Y9u>xl@QeYV41kPfVz}dmY<`YI+d>XuF4|F~3L2g5PupNC(BUxstSufn-uJ}iVa zVQp9pOJO;z3r`A9Hr-5jvw_*rY>`~*7blk_HzwDIH-%%vo5NeeTg_$Wa`UWt&b*pj zo?Mw+9o`>45I*P|!-v9$%|f%tEH+;!S0q;@*MzTzuZ6Gsh2az7li?fTOuO8!uq&Ah zd_g)Z>xOWCxWJxdPYJ8Tc42)oJh?2XNotvwgReAtIw>T@bZ)G?D^1^;_EFp-_RQIN zK4~8{MDvn%@%Qlu@rTju=;P><=(Fha=!>LHv?N-ZtR0PsZcElmIwWnAHIp@>=i+Ok z@zI3nmgv@KY&0samKi_Ey37#km~=|^NjfLhNuKvLZupn)oA6Z=zHK63IqCf$zpcU- zRd}C*d|~AP-qmq*e6l~CH*_4qJ2~VlEyu|BS(3e@o>8x;Z`3W?gzo@$i8hP6Mty># zqH?r;v~kosS})o#>K<(nZ4}inAem#DJSt%Waa|Jhy3XijKYfkqKYht*ezKx!uVkgn+N;_-eK)$iBb_&+r*96Iw}da|ZQ;BlJX&B9 zyDI3wd+x4De#teM*X=#LfBG7}1b1C)o#4yVQAIyErP1ktIkNh%Vv*Rm8VsnVVnQqoiH^@ z>RYNM4$){-yay18x4Wc7kDz5Gsz&RSShiiSL?h8IO7sr89<0xH?m+Py2(f%8shbjg zhsyIjL|>sBD7>G;aJQWj%|$mE`oq7|s*hv*x0Yb9EVZlgpuquVMxr5m2o6)yW`y9$!FeTALTeiiTn87YTw7>M6P zz?Wops&E6!8@N*LMkT-S8i;QNY=Z8pSou!WZi-zO-CeO#CwnMXY`LdmrEGgC_AGR7 z#a@UGQ0&F%K8ls{NV&n@hVHA_`%!!(f}M%(uh_Ry@&17Q5Is<__@c}~iWS=)tVH1Y)xxN+4xFN(qieD+E^& zKSl{gp~ou0o#=5&@B}(k3EoGKSAtK`6O^Cd;`mhqmsO$scR_J3&+DaGB4 zPF3R0=+jEH2z^G0zeb-`;_cDrlz3hAc_mtozM#Y}qc1A4=u1jG1D&SeJ2PfFNLmE1 zR0z>mD>(GE3N6srD{O_nQ9;_(On4gx!#nUE$lua-1zC5N!dH3?V|7y)g>4wIYZ#qt z7|&=JpPRx+M#C816f5V~r%Ln#Dz*d0GaB3#(U`w0ku3jNVT7YGzW~=K z#?l%i#|Dg|HRcb6vE9b}sRTQts}+2i(piwg=u~6*L%_djY@o<5xus2{usw^t1V*qL zOB)jKgBr^*2=ZHDa|*uE^h<_T+7Y(0)Qy0@H2sZ9e`jPJ**D-rHCFZq@_S-sAAn!g z*w#w=d$0y^U{(j8Dp5RjXV+Blzw+4{MXt?Ojt7DhP$?_Ob=t0_1Sg`@u^`uMi>(EG zw|ve?k?Xho{t3a!sO(SL%dseRCg9`cL#PTfMU1Uh@cZ(jam9>8X+r|OU}I|(W|J6O ztKc6twx}?_#MqJ&+=7-BxenSo1wXQ}^@?2EY!?OJva#zaa(>$N75vS{c2(qD#eb86 z58B9YdHQ=k3*A7$FKuiOMb2Zpp%P3-dn$5H+l>_7#$;?Sg>Q2kW>usxa=|dSLXkS( zL)j8M~R{2cVl*5Zm`vm|tS-78Rr(wp5sLV(eBGq)xV0n3ZDeHVX4{ zjNMjYZiX%6SV;$}Hz9cxl&ieuBFgJ+{K5=y3}335=Dp3Xg%5513(KtdvQ3 z9Hbn;oC9M|s_+DQvcfC`V^68@BzmgCyaZ!Ut1uZoU2)^lGb+4;o~bbJO6y7LO5$fJ z%(^l5>lEJ! zya&AD_1$|QSV&};fK1Zi0ZVCESg`d%> zid&67t@s-B8AV1QFnh=_cgT3L)$>ZUE&75I^+R7&ytJ{G6fbRWn&MAFr^5`kBQ|+O zp%>BE*A#gcWOi*za3uPM;_J|v6-ubI4+uU%-%`9B``Zz5Lbdf@Ttg(v~Bk`}5;8s-Hjj$#xRha#3?6L}SE-Y7=!DH--3VWa{6<0!=6fgE% zrTFd9ZjGhu(97M;xn+{E5YID4~n@7{ZXO6*w~*Gc~-Q4S9}lj=L#F4zbN!8 z8~dxm{4gW_1%bY1BhM%4Gm4z2e<*>J`OgYRp>oauebOc{iorgCt&pHB5SU43q|K#B zJXFN@5JVMDMPo($5cE7Kr=cwrd1j+0LYaZeK0uz~zvlzniufJmIWXlxv_|n8qSRB$L1f zcsVYy1xOnSpXuZOmKNE0GNfG<4r-)A|Sii#QXjet<0fTOelWlZYAx@m;xONEgTNiAjxZ}`ml~CII-xM!p-%eqagpvCj z!R&zcQ{=iH$lt&i3PV3-iukaCohlrQ_E+RtRGyhr-b8m%l==X_KPuZ26%J6m*z7={t$DG>!Egv| zX&8E_63TH6Qo^%QX@9~@7+hgAdbr}{SjBe2?QobT*V)Vo~Jlj=R(C{_dwbKI9canxP-Xa=2FFp zEiO~MwCl?iFLi#U;-!sWr8wE%)rymSUZc2M&}-p3$|*LJb_VWa^ajO!feu&P&*+Vc z`vV=JgaJBA@!O$N_u%`XV-zoK{3gXqn;oloY0Eb&zAq|ef?SN=s(5KHv^6j1*~AJ*p!ZZ5g5In6LFj#o zm-@P2aTlTwR2YdqsQ8`Ghu~qhFWY%U@%_<9;W3bHKd!_*&?gix_4T9@_e3Wv@n+~0 z#h;HprTBBvsfwq~F}@)s-U@w2iMK(Yh3AZkzC@o_s`{WWDAC*Ki%Qid=u1kKY-gHM zwIwvBN?o z*#i~ZK_cx+>;;Kjf4)|dT~R3$By!#@Rg(VbGFVQ!q^*FJ#HD_llt}ElN=Y_Ezk$EA zj@0kZN+RX_1y+;34c7~!#BA4DC1yV^PE%5#VBiC7hcM}-# zVF|qNz{q`oz>Iby*JXh>AQRGg&qkf6Ca440cR4gLx(Bi zFO+9v!BbaqEtdNlPdk-shY(4+Y!_@R^l~Mpow+NNcrkjVVv6WhN+ju5E7Cvau2Ib6 z=(UQW?Yip~dki{Uk!L1%qY}19#qJQwu}gh`sYRtO!SqMP?$lc-bt3fvMvh793FNs% z`lSTvC{KgNl*5cu28}(TA0A zfAkS0l=^>E2`@wC_#u?zkoth|8T1Jy+z)*co+AAebSgYe{1Q~wdzQG^={d!}k3O%2 zvdP^-8oa?MC7g`@ z0jt>;$IWHT$g_gE5)CR0M4jR}pT&QgvIiO|;tLF8$dPvm+Cs6dQ4b011XUIOhH}mb zp7tQ^UXZ>EY3qWQGOSTyGqjCjdZM)5lx( zp&bAcG$bZGISF~?z2NFtFRn41v$QzAmsr6 z04m2Rd;?Mrfi@LxS>b0?$|U>>TPyNg5pGj~HWY5FxV=!RV~}UF^cXk}nu`gySEMb6 z{glX}J1A};D%*uf+M3iWL^0YQut6kkY8Tj*xU{3)lt|jw?yx86(k`SNds7Cn{{Thq zk;8oye=jQKgGk!KzKZ57wj7MluU z`!khD+VC*Nk3`Q>{1o(T#g9VIQJmEI#frZNy+rYEqEg3@l+nxJD&mq)?29cE*|yjY zth8gXm#_-NM&Ku*Vi$O3*mQ=^F-Jk?o%QugB+W%Cp@4;9nc3AFUKwW06!IdSn*;5*$4Qi z(MJ_8_IOP3&!CShUTpJ(;-5vIRP4v-WF>OwlnPs-VlRl+MP=WDT(@L@5am$WhalH5 z*)Bva(B~>_i$1ReQkEAg?1jFlL>F_egcq=+X@v^;FDr|zjTH#yt zHN{KazFy%c^bN&`U1wJK1C@3UM(p}lg+I}^6))}L9mPx8-&JJ1L-<~WU(olJ;CFPE zVx&!epoo7r{7^By(2o@H^@g(*Bes(I0P*RDpD5;P^ixIrI^ky(_C`Nfyx8&!#ovK` zsd%yL9L3*>ex-P^@m$5;xGTk^YV@qQ0cA z7Ay8N^lQcKgf3B}zdBs1c&X22iairuu6U_iIiJCgM^`Fd>bXggd$jZ#w2EuXkHo)G z-%vTX!TlZmLGf~KOMdXub|eq@i%?k){C()pil2bWzQIfTlKlxi zK=vWX@kyHiEA{z@5(Vg=il2zCRy=Jp+E9`GwcbXFuz9sn{K;r5#h;3HQapC9-d>5j zpx9c7X{*)!VQ1o9(cP7J19VR%-U#KK6yl9h>RyO9LHASQKIr~%0O@_vgO!+iuRcPF z2ct(S@p0%7IEwX8KyO##^-=0lh`XcDEAh7IG{w_Ks;2|(A`zt>2z+JGR8#lWZxWX@ z&RHQj9Oay?{*XA!syV-^v3DZn`cz3iKtF@8Nk1BueLzB<>ZJ-_Jv7y{!)n?|zo;}(LmQ4B4Z z>(GKCe&u|PV#cDiiuio$=03EGBL3I>dWxBVuCIun zINwz<_oLku@zLhHD~9%$-#`hTMmhflGZWoV37$fGDpu^x`6h_3FyBkDV*8C1@g3%S zD^}`Z6Gi-p`96w_`^#^t1k2IQ6f5@ITnSd7oU4KrTW+BQE72_#D|X#V5uaavYsHGq zwo$}ym)};gV!yvB;=jvFy9X<_l(r7y&&x~u1}n$6gW{wO?xvcU8onm)}jX`=YxmPU>n8MaG@wxxNWb>TNH@?vL)Rh(9ksK#}oi`F#{8 z^*K4dzQw$33uOFJUh;!G1(iHtZ$gh!+^Oi%iXDp{qqx)1V-2GBzhKbpzs)%b%;*Y3O;1_~-KHEA~zF z0>yoTUZ~i&(2ErDH{~x@?7QeCiuj-Mmn!x>^fE8fhVr5-vXTU5~lb5yyM)FE~0vX?tmo@}uZFHg{V>#=qL>2ulp3O4gFda;)#x*dITd|Y3C=;EQ;eKj&nwc;oR@P6 z4Ch$>MMe6Y^Dimp40M_joR3ad%$exRN^k)>Lovh9R}|^5&cCXdv(VQR>9@|mu9&mY zH%)g`915r5-!Sz7jQ|v+L`-xq7-*h5e`ufT1D&Q@e>asFe)^+Kh5AmfblQYLU4qn{}X;V}7|J{S)~Wij_KAsYriCzDbdBj`>xJ^j+k?QLNPe zw~CvLey3PD*6$T3`F>EW9QTik`112VDOPOocSZdB`JWXl_V`5+e}Dd0#Y-Lirubvg z-xV))^oQb)L;qB~)X{3i4>fWcngZ7e@n06WE)>=vp@g=9wMgfjDs+Hq(l0=3pbP1j zqwB$jq+_2#PoO@-yHM({unp<7g~GP519i6*+8=hOjZx0RUa&vwKaU=$Sn91nI~ME` z^iai8Z-v7YOT85a!!hLLoG8e)P9{!S3#TZdEI(E8U!kWd;l=3bil;pm&QQd!S2$Dg z^Uz_6_^}FSDZT+cTakXy!a0hkUJ7C(5T8xqJjE|S&sW6HQMf>1F1;y8Ij&-T&XK~^ zaHBDXdMu29n@PU`y#=tPc>x^{ltp|bh5O+#;(7FOm_nTTElh={iJyc%1J9AS8~VIr zsHcK#3(OYii%N1S`jX-~hYHh_ zZ7xKmjv=`Mm3oB)`xc}wA-M)^0P0G7X$7ep@RC=cPQ-UukmLWFILA|10$dj?6jmr! z>X2(fp^0r?i>^`F_--%1x_*t=1FTW^O+Uc)~^a~Y!Q>1UI@Vg>? zK7~J&WH|b#l3?2!4!fob-@=b*8(5R_kXX}JiJn5)mJrcCYTCnE#AzcnYb!|sT}MfZ zXa`uAb*Q(Rj?jtt2WV%=6Q`bPBo9Q?Nsa8UmNK+JB|k*Zpd}@G9xW@0?7vQl8c>c+ zh_F>n7bTJM(nf{&d$cEPL|n?y3wpEuY;+UYl=x@pW=bM9*c|$jPQBG^p(JvwTPo2Q zbSovg4c%HvuuIK0N+LGcR!PK`e^V0dTeF>#tbuN?M4V$a{gjwCRq6z3u z(4Vs1g6^zDW6@odXcW4u64M@Pc7xqnpL4Zl4<(^)YW7qTskgmgZ|Ys@YJigLg9`hS zF7>v*5`Bsuro=y>rzo);->FJ0wm(CODQnG{Fbw-k8P9@qh*PGTbK!jA?4#xaxR5yI zsJTdqd!rXC@oDHKN-W#H6llLO+pW1=iP>%q=WWfEq@Rag1=uoXyEU9+HP;hoSq>+hJwB|2S62B2RmiL5(ENo0Fp!Cb~Yo`^0{64}N#O0pmw zeq(Aab@2&tr{n@OQsR%%Sczw&UdhS2?UZCsbZsTawrbZ=;x=ervDcvm#nSF-YoM0> zwnaI9Azl;3MnWj*)Ke|>oC{IvRmkPgUW%dZ)^4H1?NQDjA^r&6ONrk^XHjLBwA{4~9X+-$D;lVr*DD7%t+sY$gcbEnuy5Y)TirAB=7j}*zrTJTY-hK(rl-2Ps=B(W zy1NwPV64P*I||^8X?TMER1EN4+5IT!htUVm$3)Ry!}D2DjA}f=CsYjRlQOhJ#i+&e zc~K0=QyKV#3a-Fk(F0HDC@MxzJl_z-sKN71QH;~@d|MP=zY{;B@cMV~ zGm3FGp6`lcoP*~FqUfMy*)CCx-gu&~RE#t6JRpkpBA!2rVq7Unc!d|^d^|N29q`Zv zQH&G0#|6LS=+WtcnBN@*>MKK^B6~{y|@+GM~@S$R~ zlB5oxI~8LymLcdX72^UtAwwMrrXQYwqhefzXQ?O#`r2upC_3oTX}%~7-{~9{#RvYW z%o9bsN0PSOCyMtbNqQJCRFY;((xa84c%jGkNun6%;whu}P;n=o=+C~6`1v57olpkA z4_1OF=uSm`0nb6A$gksxF{2{CgXa)YAsYTl*jn`^MmB(03o?jfw&}-8W7Y zWi+1XClzHDo>!tQfF1yE?7JCd8Ghb^C&p@DBYvjut`SB12G6x9cc6Yep6f-?F2$4j zvkCPWpM9V^6`lI`5DMDU3-Ejx>phcs_yhBz`7*pAtpC9M7jk(XYmH zE6Ou~nT{u9cHcJqyckdDb1M2uJpU?+ek-2aQJzQrDm;mfC_4JH??sfC@H6!Tvb*n9 z{7n6L59LGryaCTIMbXipeP4;9Q$O~id<_`t$39W?$MD>b0@~=*k8e@_i=PSi1ET0e zw_i}e>pqO%eq9vrAw0qNRJ@1r^oruc817F-Nk#n;Jkvz+U5KY2B@^{W@ytcZ!_R1Y ze*mQzKjRzwOGWYij%No^yno=?5v3M9kG}8kiP8%{qhI?^Lpc*aV{G%+S>n?DBAmY?m+>4j3PYg9TeY1c%uK`pgoU()}Q4DH-hA75=@ti4&aS+d0D06{7 zc%x~aC7mH$G+?$q(;v0r1_49VXAH#Ds%3m-> z!|?>)Q}I&$-JDcs!{O7;o=!JUW%)B2p&r}vp>oZhup*IqqqYpQ!xb?;W%rL;?B z=T03vv~O2YUe>0hO-XT}sBP<3g#~%JIoX~}PiBTcJuNjQ+2>7C4b{MJ?e+YQEZ`3? zf51}TuQuP9KK+da<{JwZF#P$A1;L;>!L#p}6b8B30{Z^~ zKsKX(e&3+>#=hYF_;CXM3%wD%ACCpWefNig3zU5mpi(FoO?yDw18z%~ItAOOFjZoM zB;3l$RQYn~qLG6&oOR1au^})TJODHNe!uR^?^wkG3^$=DnSqM(@(QqEciF>+$yw&V z=Z8L-^CsKaH*ju;c4xQM_8hBZ*O<4<=e^c&?CyI)m!eVJ0K>m)ER%8XCA6G@Jv}p! z50>4(>cHY60d~@hyn% zpKL{>FP?909DF6H_e!2;WM!+Dy2ATn4%Pl?*zZ<|cO}DDuRz;7^cZQkfg3jSTloHJ z8wU5U_KSz1?`V5$9Anyd=!Dx@Tj-x>iPL_QG+VT<#L(LXbA){&VB*Hj`IdfI8rcHO z7Ux@GRvh0K;!Wc=2L`vb$HRo0h=1+=dQW4R8Hk={|42RftC4;3=lR56?1ewikK!)} zPuzO?VSM|9gXaqy2VX~4mbfo2m`>9(SgDk1gCL zMmM~TiyXm>#@KzR{fdR9+))C|Lf`uq%=-=u>`0th{BMH6w5@v=!7Aol5`Nl&flXp` z2TTRDVxvS*ixDH`x=KLdTLd%Af_aw1EJ+A+ngs)!2JI|O2y>wYvz5avO9Z3O#|jtt zNU&Yd&hlYzTKK$a@iy?$Z#T+0OcRG$G3;>*=5Y%~=-`v+6E1@%)Jx%y2u9Dh#$5N_ zw&j>b!()Pmk|K2v_XEr-DNV|QRntG%FUz0GR6}Efl9;aPOVAa0smCiD3S*Li5U8e& z9IV3P9wiM)Pe;B*L3&<#9$rtw{Nwj$_;uy$4uQ`Kv~|NdH`n6JoI-iLV-eA0&~e(cS7e&h6v45C#BP#eAf*yA9GhiKl=CD`|0AIn^1nc5!GsDf-1g*ff2ejaCMYf=czX9vwZw`AW zhZTGt3+v)@shs$n8EAbzh#4a{XxGK>yxlu^yMpgy+I90i+6CWJyYkykyAJ=G8E*ck zc4gT8=$nuOYS)ni(9AW5BpqM}&>nMaqhu)%Y~ul6!ZLzeWw0W{BI-gGk(4YY`~9jX zPnbhY@E>zbA@g@(1cfCsgA`p@K+RadShkn(5O^vLmj3*KTPtDCS4v3|W60!|vDI0I z)$NgV)q|)DzCHmjjU0@vgW7nnA#2(wZAf9T3%wvEu?462MqMyVlE{X2M9J^>`C1eH z*|1^l0<+Fv(jB+B><;ypSB7TFZ#MTaa~}MIt-DCuv){aOuX*WyHp^TgpDAOtC-gB+ z1t&dmCP-)Ce)KC6&82{$xl6ztR68Yx;W7jm=#BM=B^&~cGNeMORO%J1Nn*Hjfh<%- zrd5fi(Yk}^fDN|O>nQb1?_FVS#wB`5Yr>Pg; zf6etTO!@lSx=G95yzbIb(}4kKz;WgFN?)P@Yz|@5Lh2lwcD>o3`U4u+Fmt(GVo%q+ z9dn)=Mn59$h=YL!&^%lp^=*xB`TB)_F!w;V(2lu>Yh6XE!5lCUFhse|(#*dmGfiiM z25wCOqm_G@BI~kpEf#v3s%s4flVzKfxP@svI1WaCVX(pi#B%P0kesnPcdRHQ(&Lkb zfy$~RtP?V;d(>3L(jLrJoSn^V!aE~S^U_=Ljjk~WJ$&9W_OIA+P)|Gm@y*dgq5iy} zXY)ge#)I<`Xl;*={X3+lA$(X{svW?5bb7F-Br90yXbV6MMN@CW$ppyJVr&cvoK&wf zNg68+VNyYUZni%yB{|8ETC>)MFQ=ncTq;-h$SAGquIA(h%F9cNSF{x54g8+r66HfsBv?=~%NG=DVB zu=&5n#kU{41x&?p#9am(Fz;Lxydae^In65rPY8f!XsWS5GH9uN6G^`&D_1}sY_xS< zs`uDvmlPMZDagyo&PY%30rhfLo)m?8ZbqPcZZ>e&v;8ON!{_&UFl*L!EFE~(33}4N z3R8FJow}LRVmgE|XfW%D=HP#LNFXB{*pBdV@GZm4blkE___%OA!C~}+vc~lUU>rG$ zfq@-7pamFOKZtKNvSTg4kWLaXYZJ9YINSKZUgbDL#|gYL9NZn_8>7(xduJ)^onmAe z4GRuUfn_6QG11d9x{NIVytDA$qf`Dt;f)V@f1a?$AFI2Fw<0& zp{e4MjIykZiX_-RT5Y+-b-A@wMh@q^3YKHDT}g2TEGf>5SvhRVh>b533l8Xi#`X&q zJf3U*lG4A*e6f3t!-ZSNjtnNVV4Jqj9~$wRc`+OPE3stCUw`QR-}}#*Qrg@-g|lS# z>+DzM6%|~%{$IcmIFE-6-RQ`Wrpmaz4Reu#zTM46*KNMs}90mK2wk zR|ImO5V;TFC09yeaX%O^Ovm6EJZu8 z-F)omPv)aSh?w8RJdiAeh-H15aPgEhKeY8NacQ73iB=MZVUWppwL zV(wFA_~g7AWF>&v(ZaHq)nD3Mp09$DVY`aJfy`KsA{9enNoo?TBzSPI@B*{bgkBc+HGqAs0$K9)CFM_L!z_LYG$Ck%8001 ziDn)3%)q7fN}YB#J9-46Zjm# z-Oc1fi^qr7JEEO+(&sI}kWLmbjjSOa#vH0{;QRs@(EM(Se2B4f_ZR#a-xol-Vf4e{ zLoM`$d`|+0u!MOfwlC&572_*lfWroc)t!w4_oeW65r23(ar+S%>{(0zWA=@-&w2JG z&a{usxkV0j7~%9^YOx z{ooU;kEacXA-^oA0q~lW5N39S2ELBcODCg~uhS{ObZ!xb{AOZIDigs_-)(sUowyu0 zG~jc%@S8afLaaT){nUw=!!xB^7_^N-b9aLih{@B_e6p6zbVNEDQdyFbG|bD$YKHd$ z^GJG%j9Gj)yk6?oWokGRP#KJ8zv&7H()qX3lso7k!=9BALrupP-SqZ&bd&~9aOZl@KUwcj4 z^U5ohzIjb;&DNM#hZeH?%?aQkCe6h7_H%Tb0^}9gCALPxG>OG1aU1%E|GRY?!XMR` zCwWo(HTRTXg=$+7>O-sF{cO!%cK?1`hPWM$R`5G~RoWZ)UWGKCA)bdd`mx)|y8=EJ z-aHHDGx+id=6VjZP$6#~!Eo<~1@j&Eo#A#=4zq~+&IpEkJp_z#wt$f_1>jr4*TLMr z4k(?=1PtwO1dQ-;#KH`++Cdx?Fv6D?3v;Q}4p;#&!l&Va39mulXX*L8U)g{$ytjp? zgvozKSX=(HQ=}2s(Js2i&JQimA*Z7IPoUSW`EV%4FiC13gpVwCKGYx`qf}y-Bq@pb zSN9dTX2SK#OQ8$pt3vB&7VNt>^aSx?_-)Js)MkcM73>P0Lug8qu=G)A^{*lli50)F z+dxFJl@VJ3(%Qp zHk8{lEBI(Mva!*+4Sl@~Fl~8XD}x=;GeunjoP?CnIFGUfgh>~;I;Cjqvst}FW_sV2{h&5>=?CF5iJ9s+mXdSC`XXPEUC^hggz9{A4$sB803RkEnYHepP zOLaXvORP%~c!aU7!;{P5ai&S~=&?qapLhS0C83?RE195Q=1%Z0jR@J$D?Cw~lSO(^Fm@jBvZPm_1S7YrC^ttYoY!b+n37m0Y>U!tVSa_Cj_(|9I7{MwecJm$mlm=^4SX&C~MCadn=EIG|KJ(WQ z{JEjKD|0-x3z>cZe5rdke9Vw}z}Qv>axj_XJbeWwH20Qp^O^pa0vnoT!-nSnkbPtQ zq`{EZQ)YnL1I%ARnZ&zR3a{LI9Ud`OX^3Ct4YxzwFj{wHwzcAnIqVf>Nr$olJwpS{ zU#;=CO%_E7%@U08=N9t|v9^0d3*q~muE;Anhfb5@{P70vn6>x=_5IakAi(_>#-o5w zkva!ENHD9ICO6Ucw!RketdEx==3DN>3cna4oPm3$Y@KjYER3&fNHL2b{M$Gt=x zftvVE_^@X>zLPIqAts3;B8hI11ZxSys1wRdc4mjtL?E(kDLMDFz#ZC@isgYDT$S=! zzL*xIYFdI=|FSGQ(4Qsg4M)wdZFE`6in((ZV`RV0VoATP3M~WL%jMb4`KxZZWtBW3 zbpM|w0(G{0aJw2ji{FX&$e&jsJ#eD+ivB5IuRH+$Cdo{=UeOQm^}z!tTCaG{5-=xP zuXrX2m=mp6JOizEPOx6_Otjiz9Ot<83eR&`&2tYPkh^dgk$XUE8YlJ&C3`>5J$L}Y za_YN?xe|;ObES2UK9jF|9$+U~_neg0mTrZA*BT$heqFTZG3BYQF~AZ(vStLVYYaH- zO&nIN9SPQ1JDM5pu^?DFXAS*JkPiY_*O+ivO9x5po09k-QDP zDO?ykZ-svY1|siDz#IzKiSM{9>LwTgX`eAdWXeTn?hd%_&RR;NE#ka!YQL*2Wkf+Yx zinK%LzQ@5VG5fRU?7on1Pts$@QCb=PQ-)7L)@k>N(Cx&t&>i@;(Cu;AohQ=&>LLMiBK@y!7BDB$|LQGPJ15Zp>VsB0C(!@O z$6WvKJdyra_Hq5cvqk-X3cPtrJdSxp-p=QdohO?|PByOO`*HKa$;TNwZz#t3a`20f z{9a^g%Hv_>iPW_gBS6AON|sdiP-d8aDtYEHrteqN_wPS`bU)`q-Y(aDG+NMo;VH3l zBfiabpMW_Oo+@Bmy3fK7vc*T;*YDye-6st-M-cwj-wo)#FXLoJ;6i=_{vG`g46WFB zNi57kN#yFfbe6!E%do(Ajg;L&JEZ%>x0=HLYypO1Q3B?Ol+pqW`7Fh^)=4$-Fy>I@ ze!K4!XJV^dw5PR>c(+k{C;nX;cUNE5#`h)sT{H}0QC5yZME6-VA>Ajw6_#>O`mOcS z8}Tq^fA=^-_q`W4j?hV39@j|++18eIlGdKRogN{z>(t=N4=5x(KI`<5Hi;sKQ@~abnV15#EM(bz6FL8PS zI%!Dwu$qc?{ZhwZI|;!Xg&`+HQAC16Jta7Bw{dEU7tSaNn^q{n0eMVVHDyOuORC)U zEAu$>&6rq!Jxek}SwDU?V${spH_T959sh1Grcc5L-_jV#0rR2<o9U^^t0Tu0Yo!AyXbDlLH0$ z!5KN|4)&+O&{S$_YFU8cKf@0firVA)^Vu>sDD<{`j=9r3W0$taJjZ-<==u@twb0z= zZSp-|nSJr?_3*LcTj*07nxs5~zjB-~KWJC-zM>v|UCXREd9)4ahS3i)n*U?s77ga>`2df- zq)Ms&3|h<6N*=Qh<{{d~gZ~gPJZv_|n_pnBu->5qa+Ud(+4*Jlw=YBM5SHl_l4)5_ zbzYlH^g4GshEV;ew%rS?+_u-!oeIRUZ;& zF+NqSrY6@Y*9~WgGUb%ZkIx<5YiyOdOrB!CZdSg4RrwgX$F!nBuNM{8nAbIbAz%5v zIgaB(XCxH7c?$9I+*}B%p1KH$NTchnco`xycYEP}= z+ZX zJa4lC`~Vorp$!kj_jzoZ$NQc9GCmIT-0dP?W_@hC7^}W+7{t6EjP|3Uog&gzG@dMf z0IiL#FWPU#9`|$6q`qYVW}1MB&YdyG!Hbno?}8Q;^1JF%qKUUrg@zU5q3^GsZ?6vFR&wmtc{%8TZY(zKYBoZQ)Ppduu8cCX}b{OHLNhLqMhI0 zt|FD?v9;!JipKJLcF!=6d~5!Y(XF->B1_ty=5VLm9vE=`1GjZn7+j@Cdp`71-GtZf z?;c8*k9NK1l?lV2-`p#dZjGD1i;sD!7<2i-_%Vl^?V`01<1pSv`L1{vvp@CK1@o5# zE+=d}voOYefJN#Xp+84ak^6!?c(U|2(rNKakj=bFjnlMMo@#oo^kRd^^yd1Gm z>{0|Nkq8Y^R?14daos!~mS*lYyHxZa)ZIu1>2?JlpMKSzvz1g3?%UpTR@blG*E`h8 z!b`i6)}^cyr&SX(;^_dHyphvWz#L>|JPh2TFecdpa|IUq;F%icm7{qkD20P~^V>-sX zrAQ1>>_L{B1OWi@m8cVuW>K#W>EzGLEY^@L<^-`5j9^K&9nwxbl&%1G3xm2GzGLDi z_^uZNzY?i?uuEPF0@=V1|1{vI!f`!vFk#6Nw8QMBdH#G6X15&I)m%o2v53bUcB?|7 zWU=yaN4T*&+B{|+b>V9`Sk7^ATNE2UW&UB|Nn_9XzD=;uuVKd!8$`;zXfW9U0ci-3 zN>_~n%GK;4GzV!Bhp9T)W5>)V(w;X9#6M%?JyXX@_%~oTUoz)PVZ1_ zeE8?H_gppo@t{&2!;|Cuqz_bI-Brx8Gvb+qRjz-rD~C_uHR8c+km&-)=to(@*B(+ka%KVX$GE`BPXj z&7U~V94A^Av%WMQ$WEQ;>nRSSH!?B<|aBCZcwTmd>L|4=+5VT?SBno2&dyv{G)msS|g~3t>gx3BXPKpDo3+5LG znAEO3(5bjnUTzj8F&I)2D~b+fS9R;&My~2!jXmU9dP#9f4$q8EOhH+$K4;JkSL7bN zYMi1>n3{-~x<}7_@%2fUOf>htn24z013^==;RU@8v7v&dF1t1s<{);{ak{q*16?S5 zlF@VrPjOpEeCvpnrw|WAJkDXj<5!>TTlzm)Mhkr4^b7Mz0(_wRz~c@dOr$6n(S+)4 zJf#XBuP2+#!q>g0CzdvcrG+ivf_1*tr!W%X6Vi|NR$DMl(q;kU^5^hxMPPj8EUSfY z(flXq*T_OA{nil{PTUUpm#lVvYUx{^9X5=w)P{+}*=ff&j)^(jz1Ls#%YpH}ng|AS zwlh|I&JOeW7`)@;!^VsS@>l<8q3_POu&4XNll9%#=@ei(w+MsWR6#>uWg-~r7q^)( zUeM`WZk+xl-qTI}+`-@J&*!C<+1-aCTZji@e;luhHn2Rb{Uz+S4UkS!Ok|PQjo+ApFTn;0A?gZoH zhyvz2s~r&wOAzNn%=&BrBQN3YB#7?;<}wRr3x`P%*8|L83kIG=;G7_y2bfDOn9Up} zE{;o2d1KB$;ezw5A zq`jtnf@jd2j(u7UI!sI}(KN}xzFQ};J2R6>nT44JIa$t;Fou-DGAJi8VDAbHa5q2f z(Cjj7dc@Y#j4Gwg-_3WQewv;3vAWRS{?Xjy*$`dvxg-F%vZ|H=IPits>SwnWM`(O04%vYpbKw@*!!xN1pIzVip93q zlJ#=u#}CfF;qVjYH^=Y1_13@qsqILqIpU|5_T zcD!TxB;LKnpY&Zb;*lKFqkQnlx$|bN4}D_*GvHT)HGWs%mo2rCCW=h|00ahmLUA3V z2108Lj9}r$9jS0$6b6ee7;Qm|Ky^Xv)os%XUC5Te3*}WFq&~ZM#Zn*a&05yj&~~lq z_UM?u(snH|Mtr-LJxsJ+%iJJ_${8ze-(ws|*3hSG$al_Wu?M(riP3e$^Wpj2#?OS8 z=K5fAX%74+8ENn$%1BxC!ul;nsq_c^z?dxf8bUCS1ZtpAg;Mw?*VBAoqLQB)bI z#8=z4D=R_%D&>Qdx4kx7FDdf-ORy)sxSa3mtf{H$o|9Wu4XsP8O$wNDx3zVB29$QH z9d16I-1EyjR~&d`%-BZ`EdR@wHOc0+w`?6g>Y1f;pRLE?KYwoN-cf%mm9=A2rmwjE zW0t>V6U+Jgwac#Ddpv1b)7^J9Enjrx-apLmEuDgm#FPh?LtbPLWvh`a()mxW-StRA zw>-ExS?Q^OPVwgiXwMd4ZVYoOK=f<$){o3}Cq5s4>yI*cTRmjt_KHRQrd~ z!`OABfFT>5fi2|V$?dqi;_OtM1AunOA3%K}pD$o& zeSy3K^7*3Q!slxnMf7dN1YGR`c5igMn6dt1-l=(U(r_O1SgCYgus>s(Qd)>@x!`V9 z8RW&V48&1piZURDN#`R2l}StS9!W1|62OciA;-Q7m0eH_eU+W3>qz^<7GrCaOOy)i zFM`VIo?Ba1t5juTE`cAvx<`fbLCIpbe{F@KdickNtc?kHLO_Zvz({>jdr zcKH;2g3^FLBO@cP$fLLEm}#Fv zfF09HW=Vxnl39Unus{xjzJBcUorKdCpeCSAilIbX z;b01c-4yJFK*FPyBH*#|ehY&EOpZ(%1t5_Z91l|$%%JVQSs7^D57G1cllWFrp0t`s z0H4{oQLY3AF(P=^F}eFk@}5LeNPD?|P(OuU>_i#0uzi@Of;(yI!__{R1B8x)8WdLK z1Ue6)O{;?ZoGcFxI*>ZCPF$fEm5MFgMAZr$4u=CENS|4UBS4Yi$6Rp;hx~xqZ0<^8 zM$)r4Eq-|24UfLOd)06E-1p;h#SD4xyy2$RgJ+y^%hm7CU)r2|^sAZI&6+T(u5G8T zJMLY)^XjX2%o{&t+K4_EbWJNQyzH@si{70^dW83Z>yg_mJ#ssjPj?iqLAm_VWcdUr>ISU;2 z+PL{D*x8ZxJulkr`-&th7HiwML?3FO>o4jT=^eDszeBhrjy3V`aa)?+iRBYy4ueG& zK!bo^ZUWESd}6OQIG=QAUs0A%KCd)~PcYdLYt+{E#z_V=#~Fd%aC`|xW6+F8iMu#O zLzUM)+q`uC`&Zv`=JkVD-*m&BUNfXD|M9+iep|Ksv}<-5!0rOpSR=ct9LHGcSqMwZRu9!zvEyT1XryHCg$(r(m?wXv6q_;H_2u-9BI7-;%HfL)htkqAj|h( z$ji;OYxgf$^1m&ge!6JYszuvafAgki)XI-O`_$}{GGyC|mG4dc*No}YZ+Mt(dgAy? zgd6NO6$z5agbW1R02!zS+HPrEo%m54!$@K7OoZ&od>p1eXjYrQsy`uxC`}cvH3d^5w z;bA!A#=(uxd!HwO>Fb7poPHAY z{#X}G0gVtKhiWaM&56Q7=d`7>YDT~OmU0DA_^xH#2H$r)mCSFv!{|Oh^%p)~h<(GZ zpy>$T9z}l~Pva-C3uplN*_j%h7HSO|`c-d=w%6=-2EMYxOltG)@}%#<2}DQU?}!HQ>42Jpryv&oph+Mrk1^lUIXsf6-J z?48b-7Wgq#t*P5fTKaokFbyBV3XUfqWO%SUGnWyXeDiWZ0sktjw&Y`Wf!RYj_u`co z?>2YeWB&RM+ntfITWKvnw14;R{pRh>3z%kh(C+F0J!Z)W{6oaskmvA0Z3yUwbxbfo z)Z)@2)f2Kj*(EL2m!xa7>adbscsMkY?E)?H^LFznasr;;u;F>;yVE?Hv*MTgl)p8f zf9v+`w<^y!SKapu_JmsBG7%#vl)42gbHQw6F*9|E>$5aI{Ii)E>EgqMtk8;#xIb+B z`3*#=q7Zl~_u#mT;&6Z`f9wRk`M_O@?m*Yo(7R9Ez#K~eT%t3bGWH9hQc5DHL zd@%f5h`Y=eFs`{pe2e140-q-7#}?WlyH~&*L2#e!aQECR+9ChH_|`h>Op$mPoTo}K z&~1ORwOl{N_V=IC(Re)J+Xt`M@A@ufzbASZ@q!lU!2Rz6wtDfx<=p=W}V|{ZVrsl1UehzEA+7(@vY-L3O5YSefT*} zXCvpt4Fg{460NgszID;(C+X+JID6i5a6ZaP1&o`{SVKAE$mbcc9s-{@@qie9fPee5 z_`ZWaCa2+}T#j0j5jRXrvgU$0!M8|8#J3X42>J#6V#B~ji|LmnhyMs4jAgIUZ?vZZ{EuwPIy`(0& ze(Vn0iuQr{$bNzM)Jac?WMbjah+LkD6<|DDAcOMs8NYmlj zV@Srpwp+MS$?GFFWVXRg>3MlPHwl<#V&wvZH8b)94j>h0J}T^O^J><1M{c{!td98~ zu)_EAJ7#6J&wY~>nN!V={+U&rp4K)8&Y9-#F55qC+WyOw{O0c_?Y;Wyy_1xD91U4J zWb1^nPYr8+U-Z%Vo%7=^>Z5m!EMkRj{m1c-!03l$5yLtW%t0k7j`u}7q}Ro_Rx>OA z$)(o?4B31FrcsX1=>g4&o)H*DilaF)Dzw``^IQpbQf3OAXA#zL<#6UoxfyvGJcpCH zXpWz4T35@tW)`ddYtO!cK)+ruuu3ymPB-8Aruy`vqBCj_$j9U_%%dac_6^P($(v`YUDz~bAkK`!0=p1 zu|}*mFVuc?)t{$;ZuWOUBb~#G^F$WC7J(eD{J4muz$DGfpqxcGy1A(ETo&e+ zFAn{S^<>_*J@WFaT4N1X6WS;DRT|9>wGF+44b|+k=4qkVxjfc_?*G$%M;=G(U_n~4 z2SE%-*C6~2T7oZYTBXbQLS}#=BePUwWI`3xvU0Z4&q_xkeYkhOG40KzCIm8cCHvv_ zem(w{8|W9>6xt>a=6wT?Xp1;MenB)voZ#w75+#q7tF+7WQi0-@{%tM#Q(OtAd zHiY=r5tiJ-w}@v&JB{q^7GNkpK(up+#pm9WF2NYtFwiCOdG)dVTF+i@;ajBl#kZPb z&&Glsjui;bb`bufnqXBfloE|olC9gBB3*9jc55-3Df~fD>KPe+FOG3#+2R_40Im`U zKu-k}tt3}yEv?b~kJ)7YY92P<|N14?^J%u?aaQw!x%5Di;30Kmqgfq#UGB?vHL_}R z7nR0z!A+4d=KPC3fS+N58~uTA1^a^Sz^Et6Ul+7F@pw`@SMfN-7j%~`+DW+Qz;jT* zD2USmCgFYp&-WJ0WgI5q{#8#o?E_$6$eTD!{5}AIGufYlch)7y`8ow2G@nNNC7<>I zpdI)dpviADmnGf@aB@1rW_9=w_U_$mIhSqhEmL=546^AQI_`3W8i5-FpL5PMRB)!D zJ)t26)!*NrE7xjxZEF#9pyeWV$|Fe*u8i68HKiAJIIr=1GgTcF+E6jF^T723*$-Qk z#Z{B56nXz6&9~NEU4tJm{`}iq=HXP~GQTE{?*$CWA%}tdSo{55e*Kts;E#wuH!c=t zO(Gchwm=Klw-!gwL4-5>4lWq@(04_{z&5xZYjC1z5k)F-XeXvkEW{y-loE+^J7rlJ zk8lr^r+rW^bf9FXMizs<(W#MvM3kn)Ncnp@kf`~!#59j&M#fR!ypu8_Nd`Gx>^@@- zx>kB4s$M6$^F9qy_n=P&0LJUAGlItAS#4q$Pd4B45q$KKGS0#?AC z48@fSd|ixlP8*fHblGsZpMJ#yx2=12)^z!gkfxpo!|krQQ>XUsaCT9fbIm~)FI;%> zed>t4_Z?qTF!9=kvwTTkq@)8i=)FPkJEy8wNdc*gG-u$}TsRz(%QF!mW^K6hqcHL- zx#;QyNFJsxnSyfT2a{5i>Tv+BB*EEOh~$6gPZ+0B*59c+_%ot$CB;lC?o!gFbt@z; zrb+>ZP!^>=SPn@9Gc1Q>MGcPirNr}+YJ}%1;M=Q4K00?zvK><%n>hEatJW->G=Ads zSwD4S?2!u|SbEW)-m(Y#%)UKiOhfU-Gp6JYUVrsXxAgI)7oMhFG^chw6}oQ<7~f;k$Pj2UGHlr z-7o4P2dR870>L9kl;HXLs6FR(gp{215&x#EjrMjMG$yY4;ZgMioo{w<*E_iD-nH}a zX$N<^Pr7%FtG>6Z{f^QC7w$HEIl(8wJkqwSjZStOF}Qb*svqRwUg@rn;I1Ej#*KTX z1+RNof9$F^{7yYxE*0r3<>`oVYGj=weNwLy^{(F7F+S&Ar%l6qgjKrQwCSPihvvJ# zW!D>6YgV}6yF0jrahQSAzV?k>uOETp;PvK6^&A^F=#NQqj|jZ}u+x{V?8$`nchC*v z_Bb0)+3>z%yPn#2+Ntnzc=vZgO(gsFd*0I|;ky>HU^w_T1%WSg#mex{>L7JSl&)w4 z_dV$gtS1IRSKwF0{?*nME)6lBY+kN7#!?1HD`<#1mxhS?bBnrySqU|y3#>RrF0G|2 z|>$8Xu169mC?Gw40B!ahtH)eu2g3vRu=N1SY=_;8+6l&*X-XN znWytVT{=RK;bFvkL0|n3=-f)FmlTw?4cyupS{Fw}%Sw70CWi7dS=Tx-Ts{Db##bk) zq=o5~QUsKd46QS*!H4W41rAq589x}8dg#cHPPR32m&9NQ)Y?$wudsh6CEb=uea<}n zwA$)!T{^TY3ADxWVie z-Qa-(SB_=+%(WZD_~?I-{K;*>$CO9>fjw^eAEbM%`h)Uqk$M_mUN1{^*h4u3DqfuDkE~}34-^jET8hE2YG{%yCI*WRXv^m(>%m{m##`BdijEPY zBiTd)tz7_o=A;A{=k$9DRLe4s>#@$~gQ(E#8U<5_B#;1{b znmRSce2}v!M$@-J?2jf_eyuYgQKn=#v+b% zk{A!@9uANB)8neAxz4I@^113M&sDUKwZf!GpJA4$hcAEgZtq_DDUKU%^{Pq$fl@=C>zo-1xkPd_t!k%%4^}TiJgT*5ARf zQ`Ls2`BT9AitT#LkC1!29`~EIkHG7gA340PH_ZkO`TTfTr5sk$6ALXp;YA7%;$T86 zh+k-`w3GruceH24%I~lh1G5zamwET!F?+_!yj$ecQ|T}+m&lh_l<+gws(5gpa{Ra< z?TGvr6Xp-f!ioK=FLS_xOK;vi_lA#mEnK!_@y*LuX7wG@?iqNTKB*Xc)?zdK(hH`! z?6bdbyywH6n>M{Kct!=UqQ9U+KjIDFmEn0fmxQ1FE_dNOSjlD(G|59o)G9}J>R7x{ znj_bg^b0mn+cZJaqhe+0P%cqDR!HNmJwME_G-j|o5fG0Z(Qj1;&D5MD<1 zlAr_4^D&i3=ZK;Qt+jBIgGGAkUwc>;=CR+1sEjdLXaDxsXKA z1^H(&obyTj{6X32e{6ktSWO4qNTOy9m_KRZ?m4q}zqe$?@}&!Jxizcr=yqGx7uKw& z>qxqr-<6N)wQGHm(mAM6(q&4g0O6Ku&|9nE;gzL-@Li5QRF zoREQhW^+q27JAaSzC|Hp(BnU-!(n^0qIh>fezK2p8psX8<4fEM5P^1{=|f9u%=xWY zD-me7=X@1@Wiq=k&0Ch4Do@*VbkU-tn_gy0=`Y!H#w}lV#_Z7(=4Ss=YBuLKGUbV< zn6~=m%~hi=-?On{Oa0VKsvdp=G^_&+hjaf-d+D6uSt;|-F$Hl25Y^gv1g zpgnp}6TpxxQ;6#XZs?Du!w||!AP+@l?K3J2%J#^#(ag=PQs6K($}1Eb&645@1por~ z&+lEj9w?vHd*O=J7thZ5C9}(cR&6buUp=e$s!I�# z-Z{ByP}k5@gZCoEyjc}NxI`FWIBP3Jnmki-2x z&{Os39J)lEBmUq-FD-6en3cf~MQ+d9Tiy)1Acn-K9RH&pl@#aZ(zAt8xbhNZ<*k9* zEV)bhRV9^Py~PnJx_Yv%yklJZKw<0Xp`m$<#)i*V1JEzZIl_F&=Qr>Ww-IfZ0 zs)xPuh^wA#0ntt)yVzAv^SP*BYs1rbo%ZP-1bmnKP+Z>uUOK&J<759$JViE7%)IHc zuid6~?7V3Wh%ked_<7SFuy|Y9J#U`KREBWF0Tp8^moMHud(Q5gC(R#_MRWpUWlmz+fA6(7EZ$=m=kasawn*+%fbyu(;n~aSnfZZNZVtPq(t7f_7%mQOFBb+ z;goVH2YB3Q_M>DabPH+k7OO(=C=QLlG-MAxMI^vGYXkLF^BE61IU%awTJHg69cn{k zt)5eQ6YGWU+G_=i0?Tz6w+sU4P=1sVLx5EA~-n@QUFocS|KLTmH&vat)UIVDM)Of zlQbPI7&x295e!@mGLeq39W4zhD`ir3Rmb+FUCO$&ZCzN9otfg3aI`t?A7jPk6-GrZ zNqwAnkUB@|hFdt8<=Q~Tb-B9#<_Ft7v^cEC2}@1&hF7*VAGBmeUfRD~r(WHag1A9uGsp7V|>X4`Ez(C*sKyhvUZr?~f z){JYUhj<R2bVQek@6;s8jnu6y&%TQkoR})Sx=JAL&d6XJAd)p3v{?7WZ}eyt-n3^f)2qmP7(3`dC}k(1nIK93Ahp=&*%VCmXL zVWoGD1BCVMfDQIB9NrT35~0<;#g}N|M(=QSP0ml@^uZDHB3;PF21Iavw7wVjYOq`6 zEldNjM-TxU52J*i=FG8*eFy!o3+9z#UWP-jva}NPEiU$FmzVjAlM%W`l+2dkIF3hv zG8-Ex-Lt{($QJ6wr8#;+P{N_l;_@hZd{Wmdf} zs-A=T3>PS|1GUi$TP(aX^Danc$lg+tqy-q|kr*koTyH>ij31oByk6m2<)^TC>Lrh- z-ea@LS&18vd_Mbq*uVCVEjLAYpX+K$l~fy-#7$w`M{(5n0vVIOBsrJ``=6jCunD)x zjq&36@0QykmMQ3oFj((1YWwx<2h!Jc5G+$#oJv<9@wEim2na`>kbT646L3~}g?kKE-+cY7TXI)1`RON^wwAozcic1J z+-}PrlAoI0_!molfFs2kWcc22mhkEy@xWd}S`$o$+|X@$9T0IC6Rb;NI*dR=&(F(* zrv+0f?!!#-$p-cxDu#TySiVtk01fa?aTc3^8(TDOv^J!uNRm2tYTvG?yr{gi7!9{A zE6&cSNXDM1*p(bQX)omT$U@G@tS!l5MpgOakIi0;{+@Z-vQ2kSTWMBJE$blq{L+wf z)_*@CCvVm*N#_sUpt0A^S)GhU-JWxp!YPo3 z=08`kKVG}RUS~|^>k^^~`5*6f(TdhFqW&NonW!G~*4>eM?tc{UM-!5oY zY1b3Z4nE}L$5?T{xWL^V-?#Jz*1c%MTK7iYjpfG}*>&J47Q%55bb~$`fjI0$#9<@) z2&N0UDX;F z_+gde(>LBYVs7D&?T@j~Lcc&C&0eX_SY?_|KVcqsE2PjxTp=;(a~N~S^gL`l=^ymc z{q0FG#Asi85oS6+bPQK7<8ajlKZ>xB?^0pNNxj0VsS8qM0{d3VO2w&>Vke{RLh*k- z_TCBor{q`ryBD3`M}2?V9RqWcKG1yU^*cTg148>j6&2sllj?)sbhuMtBJh3n^nD7o zaium6r>g;w?%kkBG|=MrZWlsv!fmfzk>IalKMfi#E2V^P+D{|yF+m!)wcFChFvOCdf!PKmtc`d7eW;2fLM^VDXs+8ToC1TgX&6{alzq zp7|IXyCBcVA0(Y2oxz^9_TM~9rUt>_e1w6(ox|WxTo1!UZoi9qU0%A4e#d#tBwuK2 zDe%^P*P+6JGj`#9z_suVE*l(=WfmT5YNy2)aNia!<*kK$oBUkFG$>KQwUn)tndR3Ga7dd^l?ieHYMT>pL;f#^s&MEgk z>6tCVY7yr-`(#9jIJEl55Cc35-q9`s@081Hi0^O~^>yJvB3>9CWbr@eFFwBl2DZW) z>0vQ<65nxKLe#I5-gDKHuUgbM;s!{P1JTZ{cD-*VyWCYzww8cj8`Zv34P>#kQ<%Tw+GR3J*~B zObJqhF+lRj`+i!s>gXLeeY`Z){Ik>JH>_VXf7)DSAN%+GuhMQ|(lgI9wtW2K*Q|eb z%a-S+j(Kzax_?|_;rG7!AK3gC2S?C-cwVM3%!3Nz87H|14_K4+PrSyl#?6n&0m5n~ z*Sh+#1M48JezaZ3Jn<(tn~+D4;{=`9aD#qT!|>WprRP=_r0Xqq=iK2_(%#fBp3$*u zRIiBc(4p!WtY`RH*H9(!`|)s-s`3ePJPZnc?M+E0ZX=~rTp5qfakm|Q;*oE*3gI|u z@{uR^n8&Z5eEBl@_Ruwmbiex5m+yyq$@fiPKq{4VF4j)?7I+2g2CS(zyw2;xA%TOa z=W*{D+<%X~6jt1ug+s9Q3C}WVRB$*POHhcIT?Vy+6*Lfj1)Qgmq`_9xb$&BhQav)T zDrf~`5E<{nL|_G(mQrnD$wCMp=;EgTN)a+m>+N|@Y88+ zdXI+wYDGKUutH=>=t`R4BP$3Ah2%alkerqPtX1+(6h)^2t9u zx!Y{Eha(a={`ynbs9^j-SHh=E8WtRy3%d?JVXY0r1Y^-y8)O@Iz)P0(deE4!Vy%gW zgpu#wCYGkt!)%(8FeadBJn}I#jp{%QNuBUF^`iM1o;Z#^gby2MfHz8{&3uCVE94U= z{}j?wXSOe&tSZD&@h5~DX$C~UqRbZMyB%!5pkT${J5 zW7Khw>vNyuVlCXYIV8@&8{$0?D8tXix5PYm1Aosg4PqmR|2`YP2p+Lc35MX4iAa%p~#joNOy^TWu(I@r_|jt@Ljo;af(XJ5>b^_KLZ#6$2n~U!!aV5EbMS2F&j7A zte8LOkr0maT4{0HHih|_{$x^W6|8~_Afl2d?79`4)LNNOC89xaV3{~)fnA)K6vqpA zG?MiD$@Ms38cEmFJ{y_?$QKgs7rW0U4rXmUjC3t;2YYd>b{fO+=b}@di!UG$d=sMuxb(0r6^~7WSd3_V=+jHAfv~whkMIPXHqW&Uo3-fy1 zEeHP)>P9>urA z;d7~88je11bKrIF`lI~Y(hS@S_ps~Rd>p)u;XmWYL7GjlHvYu_7L+p%IM4qx_<@Pn zd=lyXElpt-nf@vQxC4e_1q6fLkBz@tr@afvQ*BR5C_ljEVbC-I&x3a3 zl$Ys@cus51!*o(SNeWg*jdBW}K%Vx~%dc~qxbH!$8%)Mn%lDv>n{36 zJ+WseybgRIWRJ!;B73p*wp=8n3&ya8dRjwRW4I6P$Bv#@&&-D{m@IV&R`|RI9C>u4 zjkP@-V~8E4)?F<)Q#K>hzE#A&Jjfuen#tC(ZsrASm-(Lg@C2N5@IHIXY#my{zHTt# zY9bz?b<=#<%{fxfU^N|fM}cvi2AYBo@RU7nwQ!ReKC#Fl3^=zUBfEs3%2X9)$Xk~e z;rq4$9F2uz!H2$$LWZxaS_2naSA7oLC~x3&&U4U%>U=)eq8{=On#azyq8||${U9J? z&#<9+)M=m3qy6INHq3u67|egmqhUa^G}xpXcs*Goz)h%RY6B{o8z+ zsl5l5bmAv&>6ch%vZ8$%=P*dhMzl}*3umq(7K+db7UZ-%*CfjE#G1=;O~QKR0fEvI ze+CY-O!xTObi{347(lEk__~m^QyDkXbD^24l#QR8$EV-%%_Fr&C;$_9ZqAc zXZNvk&(M2v&pYSLdcwo54wd)r9;_)X?t!ypZh?Ln0esSd4|Y8JlXQ5dF{l!psmM=( zdxNfoA@?A6b6|Bbk<>aen3$B4mF)Exbov-&`&wB`K#4EUkfY?vOJd;#n>Q?3%7z zCi!?Ll*wLZYvM7%6Cm&pmVH3)e$Vrm@Gj*su?GHKvKuzr@Z1*oEm}UoLrrFXxjmiZ zN_-|&z+M0h>^Im+&sCy$Udxcyf3wc}HJ zSF6fSgO-EPlUex2b)5D;mf+L{-*s6YAw?b#-ugS;@l`JWIEns#<*m{8i_-f?#NXi( z)O|A!xZZ~>;O`2Z3DX9yrkjIa9OH;XIB?n`R2*$DEcbel;E;s#s1*nX->703tRCIu zz6gCHhLOj2N#3ayJ-w9-bRcCQHzAUP20R(P!JL@4rH?a%+iTA|DU{()% z2n^@^u`Za7KL(^gNhbc4;4I$OnDOY)a>O+(&y?lo#nAz_Z*=AVJe{7L^x65Hcg(!= zL$mqXq2sSIrwki8M;-U+tm(hpFz4-;LaFixmrs~EF4Rx{Y(&G1>7ii)cf`R6_YTsW zU|Ml&Wd7KWMmnvWa{k(q<43Q@$v)&^qntvR0GOP)1D%JoO289jjmxruIG16JPXL7s zWG0oD2HLiQzt?d~TAubex1`fA%s){*PuDIPQQM(xKp&@vW^+{6EeGXA(Or#@p?Rse z?`vha3H=^tkC}>D(i$@{64tiuiG1v!>o8{aA3!&8>;uDJ`59=5#*Fz(DrkQ&|6fEi zVhgtr{A$1cn2q^cGw%G5sn-l0KNW*EVlFum>|v9C4%JX!%wKg9>|h1>wa1bzwu-@! zsUEDKPJra`2XT!i*AXNeeBEpU37k72uX5E>T#MIZwYNyr?QE!ViCo*b$4EB+$aL&rPulNd)TxQzRJT@jSulu5ru zx$MV%eZ=Le7kWe;O}-f%X-ayrX&N4UY=&w*fL~i_YA_WpNQNV{WE?l5kw_7uS)Q~eZpN|SXE-jgZh~H z6cd3G(K+TE+q#^Gg(ym5^-^qVaQXw^HTjF{gQ=P54|ofS1ayU;=no|xME56hWKChP zZNlzEAnJli<;DKYvhF;dQZ1s{wqoN7!0HB_YBN8l(m$|gR42q)Hj2`zo04yZdhAY+ ztn+;1_v?Dqou(qm2l=X25doGr|eZfjMG9~ zer$s!8Y~wmcLB7oXxlnBTZFhI#O`eu08hhD)Yk+yuKE#j@3$<%`FK3mWes7k+PhzY zy?ajA&OIacZhrJ|n)z47TfZ#)EXA5YmqOxG?DNr}`msEhaAS(ir%x}Na+2E zE>)-Xm*By}O0aisPvVT=F-k z`3HS`ssF)>qhs!N!y`8lo>)h=BkdfL zo_5tkZ;AHdXBlJbtw{T%w^*ES8@SGM!zA`eBRA2(6YZ>#w#M5p*f+9*{AL^nx*PYu z5LA3q{kPCR=+hd^ZP^mm)BeaEu2J3=9M%0#6)Q@}{MOuF zJq$mo<3hg8*54Kh0?vJoc9>mc>*34>+L%?2U_0N>X>a7*bae6Jqnk$0J_GwWFPVM% z>9d_(oU6^_Pd#CV8b6u1Wpcxoi4(UpOx`jPW5{tLU%Nt{ROAdddmHUN+!U5XPowW`g!o{ygIHQb zHgE&X+L+a$U7%}mR~SZgVU{5k#ca&#)}8)Uk!BQEH}V@Z_>ScSr26qeXk%r-(`R@7 z;;PFA4@*ciwUMQC_~?Z(ljK2rSF}t!;(wwM<#GzS5HyX{yZ2fy<#Na2!MBe@XsvzY zv~xtdKT=OVe$hU1Ke6fF85_HOUH|7)d_Jz8&Xu>?hYkbZ+3oly%kZ-hJk>kjtq}F- zNA&k2-#Pr1`#at3_Ha+jW0CLExe|gmyiH*je5Br2PBwspFX;(E5BDC^r4BruC2>gv zp7MIF_J4A>V+^tDeWg+LHoSqH=LZtBV<6|*s)x_ep%d3nmvFl(YQGc7uxkw0GprHp zzBsrUzK-_!6a??8@6r?B3#tPR-4)cuTX1-uO3@mxYw!tm)CMfA{|Jx-4CIhs1`;Q`KdeNZQ5}V3hDRFBz~^ zNEYLp`cJ6f_EcTiw;;cOEmTGf?lHJ`o36%uxz3s@POSCRiS0X71}0wHp~KKiuMs+= zKk0q&D|pStk8YXabB4pa<$TVtxYFTEk~^K`+Lk2;-tZn{b*}nOwrqG8vMmYg7qRsT z>laHiqy6}$U8Z$ zq;n&oJ{AR;JD;HsdPB4Pmr?iHm7f)}q!cJli?GiNs&2;T4e&wITX%ni_Rdjt9?kb0!1PZ zyibqZ2*AJ_*j#u`ByunP$XQL8b*1n;a4i6o#_F3UHi{=4@f1x@tmNgsOY5GZd{# zgG{EOsALdG6Jt!FF(zS*_`nG0LA2tdU4)sZVp?(%-WHpYYPDD%8J^i9%0?PPl%*pL zWVjsH!jdook$L&dlupeDK0C78U?9w3sG|nepIJD4&fIA=D-ZG=?uvi69G^EeU5r?3 zJwAW6L?*IL0F_vaVm?h*6vEx7)8VJq$JFYs2vzy))V^ov*&S-mcj=;K8Za&Fgd^c&18x_D#j(`BWd3xNf8l* zy(`;EpAzl3Ux~OG*)H}pwNw0lUoV#3B)PT&!f~6&xh*lO@C$5Z^ouvT&2!0>V6Q?= z7YV20o^KdqjI~fs7i4%uM@jG;nBSTuJXOl`226O~GYB_&LH z9$=7oM353^iskG6UORB6X4Hj~-d*%}RzBGi7u(ia6%x71W(-BuQM-o$9 zsY#U_l`6y<=pu+}e_TbZdo#@{8V!Td7tgAH1z09vGnC*wjuivV=clSnRL z2xTar1QwA%gwj`GLR`L80eS$H{|kY6MnUj9oXCi1Zxxptf`6E&QKMB(-E5F`9szG4 zc9U&XNOi23e4*hPA4s1*iUA^HNuYU4*in&JK{^?X1I0lJEBj?u32WgTwMg%KFn^fk zuI@i;gnKj;CG5!#kU*m#B~c?X5TT{y=#377HUJ+0LA$`;3$O2VEMo(B2nLHD_(as6 z(v^-(A)u!KKRCb%71}Hv-~#*9hX@a^;STpD$Lko^uY2h#zAmC7;Zub+M6^MUbRnG% zF;D3wgz1JDtP+Xo2Kca&d+HXP^QAn7qaF(mEF>Pc1dlxpK<|bX)Wc)qA6Ax!)52{K zX*8140H4T(hCp5sH&M!CxC;md8vX*00aV@cFep(lxn(jj`Qc{oa71ng=mej~gU$p6 zxZ6P>F%WKkwE}iZyyUY%jql=yy_}59D9{a1E8;P^CynA>h^{Y70)&CbcC6mw@0)$- zfwfSe;}9s$Y#+iNZuVG?K_3KFAALA%LeAVIB&y+Ng{h~L$=G>Ve&A7xjB0a8+dHCx z$@Up(SNrhdFZt!FXo%Tx)uhE@RXm7VT_jR$k61zu}Y(Uv@X)V-@RQ zIwn=sW`YhC`nwztQ#*n(WYN*CL70kAd}u649Fe=mS$5x8=(zW?&OMsgNy#0ZV{fB5T`RtMB+%AFB7X4v9&_XG`k=8$K zVkj9P&sWi(&R6kX_+zDgWg>4{`d+#NmHbiGAA@I#KEl>Q-*w48$bb6?5s zPsv^WqVMw%pU|M}^GLUWI2ev~{kL_4;h>{)9QmvY0!1FJ8!SLT?hk*)grvs*H-i0AN$YRfKd+jV{9{fH*RsVP<${zVzeA(($s zg>k(0BlQ^m+>j7d_lpd%qy8i+ql=_jic-RVsCt5xj9^X8QyP8lpWpq$68VFXV}APn zw=XA-7&!p}OB3<>4jEgXef_j*=LfsCYfF4&N_W^OtT+!-2^%lc4jco>Q3A&DY##;{ z&#K$` zflQ(kwl<=(n$kMAg+XUUNTDiVSXF^@RfcBa)j|-Z2V_o&qskesRAU6yST)0&W&PhH zfWWjzNIb7?{GGoW%7R%#)@I0%DYo_1ulZPr7*}60u521tT53c%>KJ48sbm9A zT-1T|rs5cR5#nx3&T%n8y--?-;Ak9C_K+aV3_wIAN`@-|rAWQ-(Hdnl{_lyZQ!}Sk z-GuC}2^}jHc9^s(cTbhDzZ-3oU$4H&Suu-T?N*IsSx+&;kHyE-A9^^7fDS?T?tqM4$d7cjR-HFsJeSrltLb z?Io?Oobb?WL0r51ZeSuSEPbY>snKo@Ov?ArjAv4etmqFp#qdn=Y`oJ~QhA;&?iEBA zQ@UVW!C2#{?vk65W^_`<49hq|_WwsX&cR;|{8ZCzFkeb6M`kyoeP z>gd%wdud`PfYw|a&qP5r~CBD{r>CjTPw9p z8rbETVU7CrYnWCeb!5k`L-d4)*Yt#I*Sowvxk<04jVo7a*0k#j-CjAA8h?ubuhb)B;||l%hv%QFp z-P^nrsH0A^0RFqAgSS(!fQ}@ker_GeMKhFY1$00?DpDX1nOT{R4>F22u01L0(w$fm5A% zpJV3LO~co`Y*6JPwB5$f1)o6QHqd7$i=7Q#{&3J}&{u{okH=n|M%GX=))CmWNmqam zX1MFi5Qjr23WoKPb?QmGqnw{@`|Ciru@II87!q%+7BfJHd^oaOz6#IMnyb=S9`cu3TsHCbhS*(%x)ZyI$drw*b&JVDID(qmOQH zQNMl11!D$m>c_(BK3y*s5HB_$iOL{g!HI&V#7}R$F6E+oC&T`z$dqDA z{bBcgFM-T&_a4d0Jg#_fzl>wU^w({cj+A4`_#dq8fCX7BVVY zKud}~h{uKO_k7oUgB~HjtM0ToWjpCLxZ4Lvy@mxCvFs6uyY+ro^qKycUKN2j+ufe$ zi3Zk_tLYNACvSTms8M#^)eTIim>;?DgWMQt~4Fz z2OVR`tTM8TOXmldY?>Gk;!oK#4CmM2uW@*K&aX#LFTJriy6D|F8}{Sf6)0y2@>i#r zHmp^s_C*jZFit7c>Ei*>R7(LN=AApZL2(mq%h+a6mN zZwPv5T}XP616$6zxNqdkcX-c=38C;@G6;v$Nhxh?{Q(CiAUxv8?_)%H3L~4+pUhl1 z*LvhynL@{!NK~*fn=F&=8;%Pbm&>gB122M7=88oFXZ6;31-xnL9VjLI~ov1O=E<$6{!F~z_B!H}51d!#F zpJ6X~K7zc}^UL&-Kv{80oRcEog?<|DNhdM#O0d6@}YFTSjq?wcBeZab`{BM~(mAW*YtMI{1G z327jR0}a5TKrRySJRpGe$9ze+G-r7|@ELXUoEnJoR21?O;0<;bvI1 zKTm6p;DkBE;Fdnw?K?lWEyYb4umJ)!;n6WZ?@ z?NiI}0hp6leV#AuqH???%1%iqZ%uMY(hs?~STReP=Tp0WF0dkf`T#5Pg-7KgpvT`^X1s(i+0Da$lUdklU_B7_ z9@shL{FZ6=Sy#U8k35HBDd{`(!(vCy&x5JImSNiV%LNnP*meBq8558ffh zxwmwjLLS@^@*qNqFSo`$WPoptdqC;ffn69OcDA#$#yyp|f5N^-RONM$C-(KHVqfPF zq1e|GF5J0uVM6J)9!wN_X{DG*K`Zv$X=6^xjG;6}xuk6SQcvu%h#{smi|2s%<;4(B zE%RO9eL&Bom>8k~F|+tvt_!q_wJF1C2svRC#oAOX~KezzJLe9Ifw@!d2ig_^hBI<+7J%o0#hsud5 zC;G*>>)S5J>wOpPSL$!%ta#TR$#21P^EaM-Eci+OB5JoF9(IR^X5ds^^R!be zduh9nRkHuDo_3rA-nm1r;83Gh3iyxpM(2s_UwWQUJJBiW5xF%UI(^pCJ;T0CGT8fk z=%#m+v1Mf;=Guk(#C*t`AjOfJV20aVB$>mRQ|d27B73xz@K_zp5iV<+!-vEE!TYhu z(=o1aTUyL1M)*m6-5Xo2Y}00CE43dGUmkll<;&7jd$c9{4s4iUp7+@deknvjp)9uM zVCpTliQoJ@#$~g)qEGSLY!kV9)qe8n?v0?A)`*~8@Z(E4Z?t@=9eV;}0-w+>)=1OG z#$6c`JrB=GAlr3pC}Jlta+sjVkL3e}0DvZIbhNlt`HViRlnq|0*$aFRvyHZAMMu|+ ze(sOaku_tYYDA3&V|MdD3!*C9?NuTR;MZ!^`{J}0FXpj*yj7ozQ(wB+m+gDFnSIjX zqrQC)wdb{oenFd%H%QgN`dX~~jDMMI_oZ2ZyfE>>T)}+!j8Kn!wVg9MN&xocL`A~q<111q)FW-$Q;FRtM1=945H8UvVd1Wr z^DLYvW$jy)(}zEI$}hT3zvg;>_r{h>TDDr!0+Plyb9tELmw30>H`mbsKHl`wWSVWd z0zXyt+$t6bA3r#%l2IFpAWwXQ0*%-Z5EU!kj$$xL8;fyT11O=@4(M4Qf;HIYG)Fl8(@aid zZR^jj=a&R?4Qg+18a9JPKF>N$V&Mh+#4l-b5;Sd@TLGsHde!Hbp?;vITgNh zKr(>lfX;11fMD&*x$(9`|5{PnF3wEZ{}*LpX}j1fq8)psnNK_IZ`r;=L9XoM&xej9 zVj^h$WzNZlT!^d#YBhzt~fBl(rVI>Ot64eLV*%3gA$nRi1Ia_IS_O zYs}(GgXr=-VucY|&k-xs%3kL;Pe%jsq+-l@{tLT;^-#Ny=@+>)A8t_l$r;AMdq-?G z&0FKjlUy;vdi@P8}&jQ2sZD?wkx!iX?Sz3Bc^wYcN> zEIbpY1o*TGYYaXqip@ga7-7-ieR=prn4UB^r9_YmTH%#SwkC@M1C9v?(6t!ASSPCu z-DkDY?r+sPud84Af3w$J+y5J}R*dIk?y+uRvuvd72l|?fwQDMXazFzw(aA0ouJk2b zcmSOm{$R3`Re*&EGy>cM{zJ?*D1z>i2U3JrIF3Hng-m!A!%zuxAl4z-?Y z)_u&FiEnpJ&2CuBOWBCo&$e;B-=J_^?b_jDeN2Xa{Ud0Mlrfj82IrK zk$3CU2m5za**-Xf7Ga%j0ai>1BoDM?%(@8nf=>W=9_kPffebFO5rCAG<_HtUe}^?n zM0nuffq#k_?l$Kl7JUEhJ5#3IdHX*94L>iOGiTv_(>eYxHsRB$(>@)~PpYBQ2M(G^ zYilLmOZ7%Q*dr>CURAX!9dy+Mz$Bc+R;%uZ$Og(0vFcsiZTSP!xhoGt@GVuyrWN=J zzFyMy>P-1U|#0qemA#yj) z8YdHa{QU?PD1{PwQnE62O6bvDnYQdO)tRhXBWxH_wia=mpW3^ZWgq{TW$)R;Pkp@a z=b!hzfAc2$+b)Rf1Rx40^~Gzd%3u`E`p9hq+*oKQV|Tgz;yxKH=dC zJ^$e??b9n)^!rz?xEEi(EawfLpmX3l?vmh$l#^9Oy^U((x@S==P)|&LF#;o+=FXJQ zAGll7?EO_$zxOZ{Unh!`=W)K+@k@fo2Zop-jkH_@Q3#cdB%YX1`Ic%LT_%4 zTfEvsb^e3R%jlVw+O-lJc>0Q}rS;6=xAXWJ_mb4w&CVtpqz{n3LoSj%1Tc zF$+Qdsu@=PVSXsD1eFb?`v^$Ml!sDEs;PZ^d}O4e#5?1ii3yPvA}b(2$gbEU5%XaU zhLPLoR`Cp*g?DOZQZu31IeH?xWeDJ}F9{`rm_EbEh!Pgv%T9sG+=N{)W}Ejx1L zyYHG6`R!&^KK__h+3i<^pZWQZKj!E0GaI0-3VLwr)B|mP@lf%Dd%f zC*5t5Bdzc=ijXZC`&3h`AuSJg8%>i_?Npp;)+m>i?lxGQ*&<=yv!g6_OuFP2#pWZn z(>jt(KKa3JR_C)*tj_KOC)gDCiG>^gefa2)8y8+`kjYX`oMN?h?c$%EI>|3*Hn_xw zr(EB2@xguTC5b)-+B-&{cS`&CwU>R=mqedJ*+<=9;@fA8(Px9`Q&euB?nWOH zz~+FN<@OnE^jRnR%qp*sWxb`o7}qJ$XLjeKL^J3)T1vBJhXoOX7(0*|@UA(X-!l5V zCHs`X18RN&SPsPJH_!)}mL>TJ%9dKvU(`#^2e+Ah_^7!2uWK3NnUbH#NiFg66McR7 zDf-qGeI;M1ua{@s=F3+lEdYFF7XRxy>=p*CzI}c8OV8E!i|0x{tG;uA=lbwj^xY`> zN`61u*N5Mt?>^C2^8Jy%zI>;?+K-~I#yvslR z^i%%XyXw0qSZvpzEBr_2($6N&{cig7@8(YYY^jsQT?u-I|9IjIKl0vtESKoSUNq%m z%_h*jKhh8SX?!T6D-q5>u{P3ZQd1NIswT`OI6YF+(!$Mtv6UQFmPV1NGT0_6Tn4Vn zB2N}(Rh#fLiA_RWrW8k$j6Mr$e)?JU8N*#IlGDtoAx#tc=c-BF-Bj1U3<=FI;9=~> zgz=$)7d5@9yMr5o!y`+siv3iPZ2~b*kR_&E!u{4Oq6gUlyOzBhLD#8{`YNL_7dDI% zw;&q{NaGeHlrxnQI$_YLoMsCX5x5QpRYwNk3q;FWIpN}Pk&0S%1gJm9#%ZBSDQ;dw|R8xr6Td`1R}2m#F@ zteem@tTy5U{tC1pg3E&_EC5cyB>W$2d3`(U#hSs^dyXIHubtt)f5BhnpRliaBi4fD z1EJGBRh{8}s`#Gzta}Ol(L&VY)CS&V^CNyEiFZ0|o4BhtGhY$weFS2hcR`kzO$`O@ zm@m@^^a~AS>uM(d zm{&Of(w3_u-Id*{I>$YcWB|QqDBcqxF_7s!h^T_$4EN+AxUfK7z$?h7(Zne+9 z{^iE)$&C}0=-}^~9H1kTu<4*@$?=*H@HzzdDMWS+rg)GfkYF}D%%saAT|5O^A?l-9 zs6Lt;cBB#&rZ`=ZwP22RI=}$abasL@;}L4%ZjD`+^Tx-}%_Fp4DPi!l3y%%-A!CJ_G_0En8Zz zD3RT{Vv8=7Lz-&m_yb_olhAIRpDA z7I!+t+Es{yO_*NqRpv>7XNCfgxqKH+4O8E$gmC-Lt*_~hYVGrhUsA7qlH586Wsot@&25>PAN)CK62BzftqOA<(w z=6*0@VsR1t9Eu(4rU7NTKvsHsNbp7}w`eQ)TjCMcC*(6NL}ZXTtey3#yr(*!1+Mky z4?oj?zjW#0P5u5u-F=hg>c7)EL(ZCsZsazSl*q+|=?(7ybHP&FFHrSSOtKJ_kA$R& zT1Ti2=t%*<4}{va_!j?>1+H1rdvjBytUXw(#{3LZ{ujLAqWM)_Y7y$X%oqlifLC+D zt8K(9{V6m+4(ai-UDAXz745LUHDUKkHW`}bCZSnMnGx%u8-aE}oQ9wP9v(IbMnHhk zN$`(~Q>7fbGj*a{2I~sCYiZ%PSsZ_`W@+!uP51+FO#9$x?&g{7FwyM>CboMj(Jl9; z`4zl7lJ4t3qfjVUSOr?O@oqBti@M)F6nMg;;TzD&P~}J5lT-j6&}<sn@HZgxA!+a~HRLS6g)h5f(eH1%KW9PARk(6xA=a$>hv&{NT7Gf7{=54sH_e|sj?OTQ+5DEE zuNl#&oG>AT+R$%qp`G*_R9(PIA`cuaK;jgE9PJ0$0Zk(~IM^N>k!(#%BH77&=z*$Z z5X3ftp5Kd#9&B@e0cHt$w09*jSPmvh3|>n*2hMr2XOSyNJ#TiHdSodrE+jHZLgPEU+~6t zZG#Rh(@#noFE!u0MeFXvwkBWxHB!B3kSlaRKiYQ`Lxc!oEENDmn=p~au}{!W25cJ2BBmSvCWcLl0UW?EO}`zhq%t1B;_pEsr5WSHIlFf7=?tg5yri z+j`0FKC4!a`{vbo$7A_#Q9D`CmXBG@-S6_#5%X>>oHy_53zz@#`Mh~sews|Syx(TOdw9E=~-~-L9fLv&vH1Uk3iu#%=BE?i7#X`uZd-@Q%9u8CLi3N&* zf%!&fEM4^NksDbSrv~Xza3NyNFjW33wNugs4L~)R3txlfrkjxmm~*e!RLQ^jz;=T_ z(AVv|abw^6H*R23=6u1NYdrSK4Xo06_asOK|FVWlG1eN;o;PFtP@XgH5HL)d0OAX) zB^|`H;&T$6-7$e|$3n39Z>)2x691i8qUcVGu1WvZs)fU8Fuf3oz=kaaitcl-it zTsRxspQ%;&gFjc#pZ|*LbYE6G)cp393(U`5mEA9zG+~-JYfDz@cR>g40HDhf*inJC zf@DL52uhN)|J%Et3UiSC6R}Q-IVeQU6q| zt$3h5A%h6mwW3O7l6P%+ti)7cQQSvy1RIOZ46lUsI6u9653Bj{78bZOn*SDieBQ>d zE2vf6XCg0coqIBth1j?9|9B0?lYiPWZ{FwsxP0O3dGi+CoCms9(0$8t4RlkjQd9^d zSd8F|NL9B~N`cT7@GxQG_Y`KAVbbzR_Keha@3XFV$-sV>Eb4#oTecA_>ecP;`LqAC=_7t_xT;1be(6YJ z{o4J$V$K`8mlWOyA0tX`n-_zR$x4PYyY;Rh@Ua>MHO%Z|QFg@)59xG79YF2JrEECD zD0Omz8S8)wKMHnLr*HVH8Wzs~?JKB+%an9i3XI7F90q??u)iOafMk|T35P zCBx(r<=M%;Ylu1EUQ0IXVSD-I5A5%}c{8YLR``3&b?7Lou=e4N=&KuN?@eLWs2woV zAJ^<^m#vfExEisZxz4a1dvfbFZeU}dvx=|2%Rf1_=hQcICoa7*RU0(n@N?gSC!??@ zmVqbHkhoMaRYQ=H#vpMOdGAqGUoMb}BX&b#d~A#@EEshz;D3l_(WK4@k4bs*HQXT* z$JJ}c`1RGgJ?82r(93^~+Q9<1l5E|iOH2CiU~)hO2{4(JhXnaLwi;opMG=W zx}T>%f4bn=6&1r$3VQR)3IFUnyjr)n+cS-ST(F?dq`X-(>rOOH>oJ=b+VOlA`mE{g8IQmRw_^>=0r<5oGzfKg zh~su}9JwEG1kj~0N4jWXGZ9|4IGG!Q1d!6t;UOsXa^u>8g+p_BJv+lDjxBaWb)#h5e*Pc7N zZQIc%&rYo)&KJz9sV4b`^{zDEz(Ry+0&7#Y1H;g0pTXWPx4nSDI$uuzLgiYy?L|hc z%A?Pp`Go$neEVCbc{mQE^YT2*8(VbFNz(K?eNdP z?!zz7`Y3&08GaH5h5Vl6C#?rDj>o@Oc6}k%Nqi5nPDZYZ{GO-X^FHHq$aun_n*teW zS1OTKO^E3cwq?iR>zs zo&Ip^18WZov@lW&RA&leb6LaXRSrRHo)liHM?05UzFzp{#G>)D-k$i+f-9~68b9}? z5tCXBo;YF9&?z%`U(>r+{yXfzJ|myYch4JC z09on6I4BM}L~-UO1;Y^Ni6yEbBB4Pn#(;Zfv`xevAeN{!2H46j0xick7P>tuK}^u+ z`ou#|5=Gg7=LWew2J$=}^>=_$KxZKUbi685Rj`H>B)ZT+bR`1bE!CNjo|ulZ20<3H z63^oOq+EiEn*#qf{&t9S1rjHLz;(9@nd#!1gDi#BnDy3Mg)glg zxP55ht@V=@ESxxT;lk)CH@4oq8<^C8_{&Sa%*x7Y>5MA8xbn3dQ!cJpw|@Kf_3Kt( z+@P{M&c+B}eWWW*avQ>|r2)7~*Ia3cfPg<9nxaV)7h#Wt^~BL&5KKwIRWvR}*!$C2 zx*=FWIyvZt3YQda5&A7CmZv2BAhkKQ(Spm1bLBN}k~|dj3;8n+ z;~}|P8UL!Hy&1+8j*;PRjSvppH?VdQETod5M~ue@%0}eiq`RDs__!!L{1<>OHIfO- zj7NdlU!&t*4#YbjSy^iRIhUrBeHVtEUs%ihcnta>VfAqL16GyCA zF=*u2fqjPBZZ~IBW_|fW|MAmDO#eRO%{7%fckI}(NspZ^>O9rCO`{qtwawBY9g311 zi#rWmg54$Of^b@mxd?{6l}xe1i$pubGZ&r>Qf4jyCghomBqcmdDNCVNDl{x&X^A1J z1Na|EmV&NrE;>6&5c=KSp@T+_$zM60O!%BUmP)p~1s< z^Pe_akCHARpHrk1l-qyi6Z+38)1S^d`J4sp8L>Zl@T=N2$ler+F^LMp zwm|wsnQ%!26yerO$CZp%N>Ng3TkB$A6+so{;7}r~DnK-Z)Dp3iTJ7c? zzb|f5ls~)r$QsSJJk2j@4fyN%FVjh9V2{h|nxqHcK?=x=L4Y=(eRFdg}Qg zLWaR;lND8qfJ*R_uuU^mb`&K=&hdv-Jw;vQsdV%36}_RTi;g)I^a!~*15YNoiAWu9 zJI$4BpTYK)+g`wo94H!>SR=B3p>nI-{zb~+a@%J{kn z13c|M<61y5#iHHjLuZ=*b(nrh8^!4U=5sO1zxiB@_HRBHqyC%E#pwU$bHRnu&%NXI z&@Z_0H=hfxlz#5zi|6}-JEfls{gU`>7W^sY8|^u2_k2&R7UO#~|D;EX@0sts;LA@> zyZj!sOMFWHxu5mbrkn6nM#Dcx+L9-tz&HzPmDQGF0i_yWAto_4k;)1I#*^v_dv0+C zD2&YxTalSba~kfq1f;G`f9+mD!M)eS-@K8U$rjC-vxr6G4~+ARqIa=Imj+*AjSwDo z2tV*cyR^J(H*XfNym{@~P1>_mFA%z8*}9O}rx5x5$xHxY;!_t=QshnB6(*}k>q2U+ zim&?Cg)BLUcl5UO2mhoU;2HjdHc=Y752iGE6XU)ZXX`RXb3vlhE_nts|C(6w?#_Oq%euw&tdldB- zbwWk|7HB_f(Y*cVazumSIUl24)Rvde@z$2#j`rs*Io|&BOLFl%+#5=MGPS@Obtv7X zsUk2w+-8A7!4QlQm+SeBZWF*~B3nisVP#hWQ zblJ#au;E!OMko?ucXDXS;3#r=Qu#CLFfeP*!8)u*>aaEmPsR1CHDiCx zsj=xct25@bKB!8+$`R&ML7{~!i^un`VKtu&v=+X?`nFo!s@0N~?u~dQ#?zZ$#kK7m z?7@?A1EOIl4}uSlu;|i3dJ0PCDVCXJ&NjoG4U?11LBO$T-14x}<8m{|lftyIWqV_6 z!gW`svvf39QL5B*q}Z$pS^j=VTN1h%a>(hVttxE1IVPO678$3Mg>YV>R?}f-*HWrB zANnKzYtq3%-PiZ;vZN<}U+b{q!qvI+?(zq#wk)6Dn$F!1o_3wxSGcBSP(ZCweY%W( zIyB_;p}^1~<9ZA~`}~+;qr~Y8oTidLb;9w8qKqr#2$-QBKzU{&oCn*P#;96UV?UFL z(u;={#i9&JL;D)&7NFM))&^63t9A2%$o!7J?~trr8b!rl)oI0}v}LDGxwk!?t?S27 z0@lE=7dmhv`OmDlOG5`HjTh6CBY^pZmY6MyNa0#)kASl;CL+%TkJ17Kh12KZtk+KNV&O@V7%R z(>r3!38a^Wg^Ie3hF)gq#KL6fqn9C4uV!jmrlFTPX^2w3>rp-zNwGd!FKNBy*Mfpy zw;W_z%5V0`eP_>_HM`xWQ~c_>f}%g(-pNdh4{pusHuT*3wTItW2csI@(QoK(tOF}f z9YhWSQx{}VjEt}$%H((4Yr}2i6|^OWCt?{`=&&g@8N%8tTs3qb*QEIr_gT7^d&+gF z3;D8fICZwnE~+=FCrWtDj9Sdpx8LRqPGz5d<(0ehwauTc8N4+=f9v2ipUJ&RI9S&} zm%xPz!xlq41@@+Q8~TtZP8>LsBw8OXMrQA+BO(Dxuh;+B^fq6keZkk&tOt0*is?N< zH!fEPpFi*3B~ZG8g79vdcgjf@Id6uZN57N&G;-0eZ}jQ+B&-BFr;METzgVBr=hAvI z+Gnus<+c~FHRZM!Dp$&FFH+tsw|(Xl`p@$1Pv?$7&ukW7`W&D3IjmM`yU(~5u$eyX zPr$99^GH4)c0FH=053lS=9b|n^dr$9n$fd9e5UirpmRP&O4Hhf#p?p@Jr$Hx@(Tp` z1CA&@Or>?=v1a7RgbWA}afMJ6rvu$lgBFF>%t-ZMRzv9Gl)=>|%7YzBasLQu5|;;n zyX|!sb=xwoWA`DeH|*TM`0GjhH1fuq4a;v)6UMLkL92?l7X7l_@p**<^R}L_sbafjWm#1ZV-WW?(|>`R z7NwwuJ%MP}5FuBFC68`vmOOaivn=hb;gn1vvnfnTMivFd_rYw3zhSwsI@BZl4!^{d zwQHHOZVh8_U8A^K1gpg2)eQGn$KKIjd)VupWArl$5nkY91r0q)eigNNs*okC68YL- z^}!`qQ>Xh-)E`>7afGG2k`iN3Zpa$y??=AYQqv+%UWdHcW?F^!P}*D(>mY56ql%Chvt;}A@yn;Yv{dXFLBG&tPh&i|YpOXu?WCK^_8Dqn zx$On&^X0Y|vIFI|7qLaEY8na!YdLq-bvecI=!VWsUp<65BhlkLb! zcv_sL^c>jMRm1n;8Q&8=_m1-kpL@sqgwMU>e!}P8@ju~nFCXZ0?|4h;_wwTjpL_Wt zo=>`b+3}a*59Kk+d6)blK0o1mW!DScDaHJl@359W{Pwha>6M>Dc6Q~>^iRb38n0B& zO%D#R;GQXCQDv5`kUs(pH#Qn^K%#IJp)fJ*1{kx$nS5sGyD!%1xv>DkoQt zjV5oplEjjvFCFrcA}Pp_rck1+Y%cD{IeZTV_>-b@qB|B&RoX~*QySB8N(XrsC6|X*Aa^~Gv zH@tgb%?b)-0CL3uZkz( zTgLZI6A?Aoy!9@B+?k>l$;(Sf=rX!Qu>04B24iW z%3Bag3;2uj7P4rY5m!8M`S{TZJNMY@qsIHu~_S7xoUEo>x#b_Op<#EAwhK>)fD8hplZJJ=Lyh zy?)C(cV5(^|CC^}b>Wb_64ioUpsx0l!=l6A}Dtis(dRKk3u(z9-~) zVA1^_@;o45`T};cHqU2U_(}fhbYKrvV`m9phj5gn{&iU|!h0g=#s>E-mQ+Zvs<*_D zsYJ*S6`EtR$n_F=Ip`Nz1#3zqHy8^^avWwBF&{wF#7mz+hR2-U|2(&Sz~GnPTk)QJ zFAu8r-wm67&)lE5aKQL=c)#R>{;60$zsmKaJ>?xg-Pt0jZcZS~LY}1#*B=6h5g~{` zUQ%mm#jBnLFH!YGs*Xt15o;ZKm|X9g%tHZzz1O*L4Xn&RU~TxhTaDLYW_h(wKJl>T z)F}`LTzp8aOwbTQyB=&sg84sb~*YsKPhC1os{Vgd24w zXvulF8mt6^r3P2YA>+xXKs@b2c2dpY-(sY7=``VO*xr8>4`W~Q%6PV1-yMh^%w@ye z23XxV`=J4NJk>)e@Dkj`tLUVXh27H0>g=tuNwwx9ScJ$8@Yb5Ab4C6arujXSQz@l& z10n!RzWR}u9 zBJN$DJ0b#xAG;$?+4B3GIlpgVy8M@TllO9?MlbXA;va8)RW_Kf@zh+$HL<;08MUCRa`;ZH{urc__~1HZ-ELp<0oev7=1 z_b$}0dX%>bxo8epRkcIgJA9#9RjtlnX4Bkf_@+V28^QjCJ%O`OKLQ#h9vQ9mn%+I| z6SW7np}9nRFK;{M9eG`{y*c@LF;?0`+2|ima_8~FY7-A_tbBIMYBzHZ3lGeoPXr$Dqek?oQu zRkVxzpPBrO)Rg!c!yXB`%{bwFa$b`EF6Tw6XAX#C*8L&t&h)>)jN(bOnzh*gLiEsM z{zlN_FL`GYvQY2{P|i(Mcu7e_R@6#_7fX+23dfx9e_6edO`GvGnFI^sz zFe^!I|9_zitNT&9z(=eUi;MWEKd|9PQ=ocT@R8Q;pJ=xM(E}CSDV{$b`wS@{o*W!Z zux}0ykjNpT{7jl3619=0U}Wk%(hC^siV_32DlytBI33`VsN-d`!|6}GO!V$70VwP~a zJrc77%^HWB2#&-3mMPJZvM3E=mQbDqpc*^Wh zK87u_&6+fDy8TuP(+_U`wXpEls3ULG=s9Z3OFJj68`ib@)`K3AE_sWZEL6`s0udzZ zTJMSiZyg|C$Ki{B9t)g9LXY!@PGuxxRYZh_j8IN3rz7R%$V411A4fNJ&Q16BBb5+O zRVl2)h2Y6Y`yyr;;-0EY+fyP_KvaY+4fyIJ(+jIVt8~=PWCd9}sm9rcpfob;M$UDA zo4}&J*+Q=GEtmMu6~0z~?oAfZ-ogNisjB-G_l%$E-|)I0O3SBV^;BVDM%W+L+TZ8u zc+dYwb9LY)!^tHg0J9vLH&@4mYJmJI3miG-=gaK&pQ0Whl_F%jL^VM7E!I?21H}2l z-_k4M{T1jeg{RC!1?YrML{WSQpoey=mCGfJcI}NAJA2(u$gBPp+=1FOVeTVITuHfHG`CF&fubf)&Rtc{Dyixn!yQ3=L%V~U1P$cF>LPq< z*i%7)uoYE^L#(FQQ)OZ`MNMy?J%vpk5spMRc(lBG$`b_d@vd3CX-H8(7kIYRzjiC) z<$)7t*$`SZCT!M}!87bPQ+TmgM>@E*de>p=ChdG_%c!0;-Z%m}g|7`){*j0t&QVsj z-c<#ADkudpa~Y|L09H`pLJy^16M;;Wk&5sSk$ptHlHi55XgacwpgZM5F1UoMjge6H z5yS&!A3fHEY%xX;BS*mKEwYcYYNWf8lVYN*A>=qyDzQo;`v^vQswiZa8;25)WYnrB zLfME^r9uqA38CAg@c60U@=y5tbAI32Yih$|pGVr8b{ci`rKv|p4(k>dpEamT`^M{A zZJxDeXS;!Y+P3c9Eeg>9f#i)mkNx%b3D)%e(Nm9(8g*#O*uyQ=_^6MPBCFS8QI(et z?>lyU|AC8Xo#BpS>VtI_D$q7i0;3Cs4Xb&`>Q>dVDhqgBHk+GDFp%~jbGe<_>c6kD z1I)BGfERDSrT6{P-G&ww<#KCtza+h(KD0iC?dS6)o)Gxyf;{^` z$TL@N3W^zu=u=p7aOOZ3lWs1r$GFHjP|ucd2%wr}h0Dwy3uAkMaTUq*ppTmVHnIOx zb`Ax!_^{gJ=W}(7cj7F|E6LO^m^b3=uAsA!c$+8-LNElBhZnW1BY*a3U>V;d%aI5y~`5Bjr2+2=$MK!znB@$R9Da2#P_cuDBqIsv`Iqe#lrY zFbV(suWEX`GNaeIqH7tJ>O92`u{-cdWP)8_l zk4+uKf&mi!`VIaC%j91m;P^1`It~}}H<1@h5FM#oUfRM>vzquv{Z7y{05okk{e<=S z!aj-{_NGBq1adKQ!N;0}&D2jtEGEu2(j9uk^bdn?zX0a%-_2j>5$MYNsL&wo)W7N5 zBNqxJ-j!xcv4*FnSZ$6#42P1%T^fSEU1{Ppq$z+{i;BYdP<+th$fT^oFvkG4!xFe| zxu0d?_e=Me#6Pf(?mc-dG@>_no}b#GuBznz#?M}Ti|M;RSaEss`MqiRBj%4gvHQmk z{bC!|&F0_G9MnbJNpo`qR><01TO6#w6_{?uS*~CvR2{KL6(H}ajJ*h4?~A(_7(`M| zpdTCJzZYVuBqT1J9HO3?iqbWuU-BFi)Q4TtJg@Gr4m`innCr+!s zL{kO~A2~jasB5YKh^+>pWiZEXSBt-72e&&Lri55?!y4AxvE%giDt(fZZIzSSbk^%0 zEAG4hh{^w)$<(!tw)t59{YQcWKG#j{+V{uHz=z?8-(N2F3UVysD3K3P4pg*Ih2sb{ zJ0Tpx!4<+k#M#J{=_HbX@&uV*S_cd}$Z3lqKw4%`wVUVeR;U{)Y1)1frYZ3Hv|b0BE5C_``vAm0#MX9&sw`Q_m-@F0XT#gQ0?v`%k1MKLZ) z?+hXbn%FmX2UU-g736RdSR&2lROHgrf$Go(@^64ibb$Z<9sZ}*c>6ANqN#UbcT8GX zR5+V|qh>yP>8GDAJ$p$#{^FMfv(Jpb#0o|Xg@czVwZYfFkfT&tc_z10Dhu#WV}1cZ z0#gw~qv>s+9rsL(-l=$#fjEOV1!jxDpO=WJR-JK`a75k;aMEe zsG}T~(vwT5+&Nhg#W~KLEC8Tn8f(O&H*N;DtL#uKzSZ^Kl>DXD2e&&l<|qDs_L({} zRP|t;SF%~lpRT_#u;%jo7x%ifQ>#;u-@AV0l9s6#nly#)XT38eEp;{Mjazszqt&uk zr9h}YqRP!FP6-nn7(^$+Hat-J>VTGtgikx)I5Pv`H4n^-q|LOuGMi)gk zv3ji5WUDPX)f!+1+M~q@iECkY2Xm2@OK{$4%*bU^^u0Ht{h`6^ND6v=>iIV2hA2( zT6)U88xMhI%EKkpM5h7_e*!KH-dAxz#O1~zp91Yz|00pa=qW$#ksIOX2k|K2OAS+_ zpV$XdB4ZTU`tQ63|1YnlZ+_TUpZa}qKW*dptjqV`3;kea$vw+O(38d{fPknfcfvKLGb|m!yc;CSPPQ!w$=o40vxAZUk6Vy`K(PN1B{Wp%_+8ru%95MmVL)t0 zy-X_$2*g>vXMG00 zdWKzNj3<0Ga9k{}!~PLBZr}y=^wNT*EN|PsrHRST#HD-Q;0v|B2`SEm0{%<=rtFO- z^`{G24*P=+UWF^bxq@#8bJYe2%E&^(Pr8C5RZgwvz(>p?9idkI9Uv-$IiOMzVvV3* zI37&z@@i@jKgz3qz#m+`%mSZPBUvB!Rc*oEFRHYg|WfujO|)@?SRbJ8Nzq zb**`J;$P3RK@%C9zy^(jYX0DO8oyh-Bkg0?$q&+psF7o8gcgse9-PUhupm{B*tl$? z%C(2r23Wi0$g zaMj~rMU7B305G?teHce_@3uhgQiA)1u;Acs!L-EbODssi#o+(^tsc3t*lpF6s+B7t zzYd%g+6c5ON2o_1A?}Gk<>(~k=q0Aj>&z<`>t$6F4Jtoobtmtt`RFHu=dYgEqf|i| zG;j6%=A|kMba(iyP2_)wf_*YsX`kCB5d&mx!a`I{2@VZJ;SEI_8iYcs{uWgPN8{73 zu-cf--ORv(hGv^wA(<8lo=|q3STQ>I*l0!Au>|Z+lxM(y;TUU9l*8o!BqbFdX~BYj zWSwuapl=$i9a6-TF?i~|wgr~c46`;fh=w)~?1bk8aCfBkBYTx=NZBy6K3_w1 zC)-lOf&muF=s*=2pbnvOLCwlRNHxO^oX~Zoxe+@HO197sOlEiOCSwN=dP!s9e(v9H z6+0>{&_}q>b?KVG_%Htd`sMq32{Ef5u22sorS)fjHtyD}ef!?04jp{6YWI{6)y_F> zl6Ico|7w*^&clZt%`+NM7#1`{vc})ToX0_qRKg0Vt@O{$tH%5TazSO|`TaNKQ$Bng7J_ll3oFml(-s+?IlGreMJ3c)nsp^uAF?A{!MvAirINYwg5eX{LL5d3pRSt{8LquSNJDpgg<6fgM_$ z&SD#f+x9TE_7e7Iry!mglamYp1@)^Y;VuL!?OyukQXb2$(;xh(Cb_TBAAWK~VnRyv z$V!gh1>vk>)e#Nrjjq9Krgo~*0sCP{Nv3Iud80TJD=LUeN{9%e3MDD=aimni&V+RX z59M?S7Y(He5P=HeK|WIrCM$aqDb8MkYr~w;RfhX zzx#+^U%!P_cyH43JF6r4-Na?1)dov>@tc!2e0Gw>F50H?6JLB7a)h<{;YZf)qu>ue z3ZC)R>|uqWJZ8^({I_*MAF`c#xSjv!#!vh|(P8_S5lt9RBhyUte4Ovqk;B<5w|hkd zd-$8P5i99mGZX4mY?K|2I;t8VwJGw`=raLsWxI+>_ByyJ7ABs}B5+0dub46IQ zY~c}sbi`?xEk~M*(P)qw0Il5O1mcFp5-#j)Fjhz9P&pxBtq0r$& zc|QNO(Ld*OZcsc_TRa2cKkA$N!jga1SzKS%`Wk`Vs9W_tp-I>Nx~we-;J^Oo#UonN z;>>Dc+EUuY-lbv6z@SY))AS%4!QvZb68CHpe^Dr&oF#;vDY$b` zO=qj&by(lIvCNXPr{t9*{OmhBS+%3DFt*3ZA10kFc>eui%O~9qh+fjOQfICCMN4Sw z2@Tgr&KMrI=Ib#i8F2Sk)@}dTZ`Z~a%^P=P_qjha)DdrV9)K7$fd{GsfFCClVrQZ} zS2TI?L;!~jS&_**;1&>gB}6hTAi4>+H2&ZU{s)l3%{*JL zxb~UV-Pd$=|H(G=Sl)A8_vJm={Hs^_6|fEQ-+?adJybeUngi{wpYl+iN)^Jxf;E4w zX^_8W^7n%!rAuwqFDTog!e52SN-Y0l7VPI>O0by{uIOy5jTNaP&Q1x!BZgt0YSLn& z1O^(J@WEjL8m#*6TDC|@VM^cL z-MhAL+oE&J&P^KCubYySl9O3IqhexwWQ5HM*FH2rt4zBWR)r{78z||EEP1uEk^n7A znTs;;nhArnCvd??@S#+F8v;9N0a>gOCLb6G=n&E-P0m`jV&1zumNltge_EsJomV#b zD<_+&tkdiBN_NiPom*|SDQMd5EyxZ6K7q&%dZ^Z$k-vU(?{5!RuVrR4W))JV(4R$d zb(3o~&CSWJ7qNN%tT*lIM}Y|u$D>k$KHs4q;=8}j`JTW3-r&Y9^7+_ua*DK&MnhPI z8+A6_Db$OnSwHk-7_El{oF}Vih z?-t{COt%%&?SKsoy8Rf`571}gHm@QSk0Rdl+9HuhUL)nxlBlCUyv$GRmz(0#1->|x z29(c(wp;o*Sc}MlmZ4<8fabJ?J0qNAL1PxNcS{qlEx6NYPP%i!JwP@>V|Pd8==(aR z53Jp9eINetxh8o7S;@lBSub^9yY`b1Z=wXIt{%~7c*R~Ocxe`hC7gB7@kCCvT%ya#puXr zV?_`l{*#Ff2v^vk9yxxHyBl}neK4>Mh|+tlO*3XXcwFy$co(0+rnYNcJW0LnzS*p! z`fqoIcMjo|SO@c*lV_^JAh>v*rwDY4p@e30$ zz|=?jYM&pt$9*YTZ+#^8xZUlrJY?txNA`8}3-H@__`{~G6!9QCD$5AnJvHj^(hro| zAAMw3^vC)ySslqCJ^pBAP6PRR-N)-l~l^G#O-> z4q1h>s>6WsFP=xv1}@r!g?%X*^-lZwr_JLF)|F4Z`nd1P*{hX-&*MK9SvCy`aWof> zAOCFM(j8uo^5BOj)g2piTq;zu#Yx4(mjYSOokHkaWt8ot(tZzs7c|eAypg&K>x}K} z5N*^Md_VllZ6v&l9k8P!An1g6dZInvd!UC&u;8(^(L?@YXV;tu0XGBRWIQuhI8_iA z@$#C*|4^JihPy{}2@MGf@FUiVBn(`#;9%E+9SG@F17V$tAsxjhcb7~dW^og%S3m&F zpl>m4{Ug&(o#Gh!?BCNKsbzs18rIEH-e(SDR?V2E+)$Bp{AJGz8_jsyd)4X1;Sa0$^OUnEaEWYPc|)R=k@3gIG$@X>v-s2N|oa?HfVP4mB8zwz3fq=(lkjpDMC ztZ~B5p*1rWO|K>7D8qWgC!J$dQ@N{;y!kwmFCd>X^CVMqg zZ2kYnMjfvdS}IZ}@hCc0Y}8d&uWZCI(@_R9s5`P={EM{?6PsQU{8H+TGi0Wj9VwwK%c3`4+r8}Q9wteqOurz zAPc03L$H&zqyRp2@@;QD_{Hkrwd+P=La4k#wtZUKmC{WXZ)DOMYoJdeI-R z0?Xl>&Xnh{@BAQ>0_KsW4-!al-y}7d2N^tGBiiN|P-Wa4N~knpJ;0xWp!#>ak6X`fwwX^E3^%Y9De zjsteFuT5(>KV$JPdkW@cWy~%pn46tB+bwG!^LVF;)tr3b#PmTm%C9#n$It$B<@#?H zf1KCQzi>frK|@|a1B4u)sR5wnEPg&A$5wMTI_^Dsl7C+BMMs1R50`DZ=P@ zPbykDaMi8db2jg+pZ?J1xz&po){JRbNLCQ!!d;d}Wx&2=+9*s1hj+JrEM12tC}z1oaB@b`SmyZS&#Wjp&0UANQvz53yjJ8u|Yl@b!^a(y4;WI`<#gX~}J1a8Yl zH!Hpc_PI4%5x0tgegtKa3DqUQmE=3beSB(*k#^HxGJGk|j_&i(q8iEp zfEG-#cEQ>pY9wrCG){D?-+j!gN9lG-X5kD7Rg3AEg`Jv}W7ZI3+D5V5DqbtD z*z)Td9dopKXhQw=t$R1JipFKqDP_RMPo}T_%Wd?D1w(6QPO08{oYm^DyrN`jC%!&? z$=h%W!B|aqkt5l$lZKo7@aVwsg9k8OLX_bT<5aCfOr}-=xP{0VnFZkXCzDKwbq&sA z#RMibzRzC#{q*VE>Mayz&z@Ea_*JCR{txna;M`5{rx+l5#Ji`nkV{a(>wHT-_G%CzF%HG1~Ot7Wm2btuw~~aFZyQV z?aqdhs4TNxq%3de<(kK zj!pq*>&<(~%%}486lqHhBXf@Cy@Y&GYF1&DU&V6>DP)#&mX(FF#LKcCJnLYjyTFcCu`|5>DejYhE|huojxxC{2~51wIh9g0H06r@@YEyydCA& za(H^C8BV!RwVDhLf1v4ml)sM8nGk+U6zAK7=l`G1GAmf`s*Fh8z_z7SuDu8D-(PU& zz2vh}WD+gFyZp>C8sD(ER-wn&CF^l;G(L$U#jZHyz$S%)WAG#;cary8xr zoQQv^2OG<|EbZlI863*WT$vrui7c1{FJ7j*ijaN_CJ4@>hsTX7x=p1GirU_^sabEeItl> zs1}tG9)n~6xhn}Oyr7nnjtS0a`_Kz0^fY6~q+`u}&=}rEn<45Lc=@l;s!Q`&sDj!& zwf~xOT|BPsiZMN8N1sRG^AP@dCtmwZh%mu}gp#Aa9l*$&gQ-~7#Cn);MUqC zpRJG~fAt4-!9fa9ge?n|;Gh*MsdPWc)%~130)lz&VYuN#F9tCQE+6o9bhAgh2SX4< z4=`e8NT(FBGSIjEzR9;e2-l=$&ay|Kpy(h<2Ykt*?9QVqeCzH>x zv9-VS9EqdLBY#xSpK8Z(8lrjqf_ViB!;VsL72McrP_fzGl1s;%nNJfi+zYgS?0AkY$}HrGgU(tuJ6hIBcia z-LMF?o}|@`!rQ!UyDCVU18Shb?5!<{_8FnOT!E83-J;xo1PVpVQLsV zzMCa|Aq@cC(swh}QOv~XG4@9VA9;z~09yUw4$YH3FXo?byrX{Z1Nd6NfBdTT=b!lJ z!@^B@y0j1QpG}{A<>~TVeEx-h-X#o1Ea`N7{`E_$e}H`^H;AY3`8WP~hcG~1C+Fbv ze^j^-Bsa*@@%eZD`B8!TpMuYS@b(r8+vNi=nbvAirDZcD3GiwccUjm^@trrIqFvGmITF!FCD10Z&%}`?cvywO%vqfH+NV zkjeo2tqp94@FVc|HDLc~13Ms`lpFXQemBD;bAOKt=P*Cy;?Vqov8+|cxmF$LLKXuY zKLprK)Z;i451DW_Pjm&oPXhKQV4GBYZc^(V6mG~1C-iq$eC)khI{Y%w7&CIaui4nFYT!-L*}Eo_dwZQ{UmU=m@3uhqfgM5}d$ zMW%DGqMIJxIgehUFovP3H=U?8vV$y^6eGX`;ya@mwPs3ZT&Q}X?$uD3t}T( zVyY6$CyAGO`4#t0C>Yc?4m>XMY*t96kolYAaPZf134bjQ5$U<1#^JzgnYrSzEU_;Z zHvS;#b|92gr_XQEAs`C-a8Le#eIY@Hgm^CC+mQnb5H2$k!Jmp^xtNdFpLSVzGZ;7tCq1FfB8trO1fEQhVcU@)bUs+H6%Lk}$ z8bfpc$m9JrcmTEk&8Gefn|_l1!1sQzV1d79M*(~~f5JgoAX4~}^5gA^HjfIPu~O2Rq*Ywl_&6dmLJ75@l3ZgT$tB9M+Dn8 zO&qiYqtfOA)RL&OAcTvdGPY5>yV1ef3Df?-6PNV&T#OKhEa)+=s$(uE9`S?jr5qi3 zbIs_euWLpJmQ&n(Z*;Ir&FG*}(K`NudHX}_1WyG&B-SPG2|OI20h@>I0N>3yU^zHZ zVL2h5tRh(-td=_ks8N6nE}{Q25j@|<_)K6rj= z!-$Lw&ylI+<*9wKq|fTb;a}V8qGt~pI%>q|rN=5p9GSlGrKIr8!D&uP@3OwBWo4;- z%gk#eVU1`G`6Z3e%Z}4p0k{0oSEK!glWd&-7^-c7^-hRoP5anZ2Hg4v6Ury*E8o>G_l8>~GdYXX(Mj??Vyd+#aNb$!p? z>VMXLI1*Vgam~ou%tUGvA|;;J%z3mE1|Cv!J(0{ z5E)Ak0TZXXJVe9BRxfMxxSsx-s)6XPk7ZTc*1f_Jthv*B_D?~bWAARnp23#Ewgj2} zm}sLFEvC|H^u`{|6=CoI69}YBf#M&dXw!hjq)YIhF(BE8c7>XspOhEp;m z`OR#r><_EhqAQ=WM_AVnSpGNDgG)9|>N9nK-o|HR-O?AT#-Ex~`CtdT6VW|JWNlPF zxTfq@ma*Av{Pd4{re-OBz1lEi-t;N+Co4lgWqVi`){#B--GXnF^H0`)bfB_RcCU<~ z^RBL6{n_mF$YG6DJyKu0_&f`KT$zdxMGq+rv7XNxdWmy)Zrd^E;pq#W!;t|V<~ZKD zPw_YKLv7x`d4Q#G*v>Yv(}1n!uw89n;{l7~u-$E7E1NQK*3g@KZyOluVgC~Bkv6dE zre3hZmw(zoM zD4D}+O7ff>RMRVgJ4>KeTjOW4gNF^gWWZe=&HqKi3Lf4PIs^ZQ5H|rL3|L-HI+OH% zrwcvKcX|(hu@wBc5b%EVg-+*<${>~!4gbpd%3L=84C{4P{Y#m9R(b7=GFQxDy@(H4 zfH&Ga`3CG+qDfmyd3+$p>DV3_Cq*g15B{FG;Br0Mi7eY6ObU-71`$I|EAxh+Kqhnz z3ycnmc6AnDy2s5M;2fw!_B>K5#f8Lqa>2W2oTnP3Q0J+`+p3Mqv9abv-ol0@QE|Ov z*EFold2Yn0W4Y@WZ;I_57rA2bqWqI%>Q7Cce5$_w)yb1zbxZ5huyjf8k&!ho<*i$~ zEEfjHXQ!W?J?HGSX=mrmK0BT6u})3?;@8^txNSX+Fq;Eo zun228760h5!!071fr(!${$H{y+V+3hXjOaJKNNrVt?rq>s|Q^M`}SAeGk-i_tG;#4 zDc`c^`Fl$zbTay(4|F%&%qB=hV!kZPa7lyR2j>%TNxGtubKm1Xw!JY=`(0x{@hMch zd))NJA~NW(9Jhu=<4EP>zM}o}FL-`Yv6Wb;Fvx-=%2!SE6<9IVq=z5lE^f{9hM|=d z)>tK8`sgFIF4zUE{QcIIg*zy0u3I2>l|LmXko)Ra{`B@_NjBF-zc%;ZuZ{4hxnGNEiPWmT#D8WHho@Kggw*Ju8)Acyl4#4Oui*Bgp%f+AqxGF_+IdIck*%eQTx(r z+xBItQWh=y9h_EGm6kqyIPag2Wboj1MO&)U(}oXEORrMb>3jCI)KPrtK5;E|YH}8S;DAXyED?(-aMqf4AzF5UqsZI^*kJz7MD!(RaS1tYoc#&D zu!j#w{ja_L#uqSW`I%x5W0gK*5t2cw!(g3Bz>Iwaa+nIkD=i)#Xy!99z45qI*LWPX zv=TDYFlhkpf@duyru@zl#91J2f*o!HD-aKW_U8h2qzw%9Y}9&3+rUnmeUK%VtAg)mlenQe2^5lxLrs^jaw2TCWA1^v8UT^7*(LIrZX| z%!=S_;6%@4W{?8d(IZb`0|Sr5N1;5NiD(}5R@G@P(74dfL}?e>#oPJ&HJKQ5Yo@eI zjBb1f)zBX5NssaNF7oy+igxDjHE@haKlFWwhJTO#F3Nb(tMzm*w}GP^!Ks|qAHOZf zb&vT)vt5U0-l8Fy+ck~n5^v{HoAJ>1AsYTY`nkmWW5P6P8f)P5zhBw{ksME9c1hAS zv9xg?%?WKtGx(f7;eCH%ig7*@Yxr-|8h&JD4N2zu4Rn)sg16DreDkQLajM}8T|KZW z1Bax_R$019tm51vI6?nt2Zq!U!1?EVj-QJw`8Yn;cyZj2ytS?w4xJ~#)q3n3xr@l_ zfg(}6jV^SbaF%_e(TdQ8qD|7X;R7vda)7z;p!AC(EP()CiNvIp0&OYD*o zs)V8x6LN($;vfGD{lF0p{p7L-(S;XVt4y%$25XM_$Zw#ZV9mGaSEu=wo#g9={^g_m z`|JGs>-0UwbrAZ#<#Gc=R@!HEB6t9p=r}WX=6q1P)|e)~z`i}l-hplLMF-`5a9F&~ zCDeJ|R0mNaz&D@@Rg<5;<0rn@*jKvBzEz@uq^=Gu9C0YE=n^T$0eE5x zeFTK-cz$lMri5UXGj(pyWq~maF*`JHpoj@LiP4M`H{9tcT@yFI%fc={qd)wy^6tlN z+J$5eVM2JjLUx-qv$3Iw2wp0y9}|TCAu3IPyS(R4M{#50Sm~PDf%4JE&)Pk6S^413 zM;}uc82h`>b8dj1Q^M%G8N=ZR3=T*HkJ3UGT$@oqF66}6BVRjRS)@WCw+rg#UFo$u zy`(yaD=BSJIDlgb2bP4Z|)H91!9IAovafzd#;H(Ot~(Y)l?I zP@Tz(tQ9twGluda+-(QWKNhW`<6<-pbW>m)p}^#|V~#&Saz^sn2_ipZiX9jiP5#9c z=}gDQ4*G>HvJY~ynK0HSt@;#T6X6;1F)AVdUsU_?Ejh&Q_7AW&5+NtP;smIa{Vh3*0cbvkV^RKvQV zyatxmgYqfaJK7@*PV*A$A>HOdw)q0%QH^bLlFh%$<|*^8Ds!>>H(X>6%5N8y|1kT; zgS0zE;bGVWoQ6$+7i1XMRX@iF3<1SpV!=sU;|By zjjp9R(1hH!HAJG(w{8qOvZFWTO5V}l(UIK{1R|I+;9`beft_3eJGCP;1ryic$&(U8 znL!4;@b`lCwx@JY$ZqyjLw0>`WO86a3cDaayC`j1zsQ83o@wF*6%u7ML(-@B>z)u8 z-&Yiuz42_X#L%Fk{-<7uOX(btTdeeW{h3}#p@u;NPQ4hP65^jTNZmI(V2klOY%#oq zEyTyGzCol=lvs(ydN8Sq0^Ku-&`wUNA%r(XTEMwL*soPMFZhrj&`oQ*l1qR+&tW&(z)r#@V~@rS^?n4bwOvUI?58%c zcVSnu0k34(l>pY-uH;?Vm2A*>1NMs<)@(cSg77`g;g13P6|nW{yK+6)CCuS8>`Hb? zWq|$Grrt5wl{_hb4cLF$z)oWhyZ9V_H^Z9kN>0MAWRFIRdVc`c+OFhb*p-}?9|G(q zV6E*+cEGOWb?GEvBy+Q{E5VMs%tGW`__}I@^qfO_5R4~85ZL&W0BglJ_|Po_t@Yx& z0csY>7BdNciAZA`CrGt8*)<<3L39@jP2HqZ=v@**_&fCPWoAT9xP@Y*Q+JZipQrk3 z*<$H3-U$vugb`-UTr1sjtu^0zMLcSrDFQyU(9q{eNgewtU=z0%O zdu{HSj@;(nn@6CIV)d#M%;f|NQ9eGQ{CHv&jf4qVQiQZt^Efyn6TT4gj1=(zEs~(X zf-~3ZBJ+GmP*9vF@<7LVBKJs$D|^rRW(l)ZZkF71KIHW0VC7F{Gx$#@ zaRm$6yKUjZ9eZgqdv`2cxNR>*-lIXk0Q;p4uwQZ}NtczrQKt110JY2m2y)fX05ljt z5Dg&6RWv#(7e}*9<=7b3#qqo&>s*82^BL932aY$`18*JK^XQSYY`n7m?2$+J9C=e& zPh*gUDpo4rfNg^-B=V6$f>6ULu>v99ZCEb(OUkgc7w2KLbQ{6x1D=*zTZ9_Ly<&sd zjC^C1;Fl;=>Twwf{Q?8s-4It0x~0I#z{oHjWyaUX4S6%{Y$;7VX_#njSSJcINv>?< zVcJf-TR0yVf-2@rL!OLlnh-Ke+&}I8hf7Nzet+6@_4o8?uT7cq+O&H5`Bm}og-oA1 zF*2w|IXu+2d!)}WRyqV_QD=zx_r@uwr%gLOMg4i;$Pux9$)LD=_xG4nczAdqcH;rW znm(Yp4xEG_Cc+4g5!k(IZL}Jjc>=-$+UQ{J!E>9C-c5Cn(h0Vr&bG!1LI@pcsm7!} zy<(yxyLS!q^K}bx4^fdp0r&_RnofagpkG8F;Yv4AD~CkEsHH~)Ok5}%9JnBpPb16} z=-TB@Q{2%*RnSQXb}8RotgpYwJa+A39`u*;-LBfVHWw9beyi5>TlsL(iMo-GPqcs2 zVPZz&=tTTKW0b?2_G9;rtUEEu^RCLg!Alm^c{5@NiVog9G^wypby8AwpMs>JTZ$*0 zAbM(zyL6$0skQG)AHLp$z6otfBCn5d7m8HXWX8 z*mR+xL}k6=W1>T&LZgU-Yei-Ei7hzqt0q)%_BQXg`$EzdmcMkz!z)*g%}z_p8h3wW z^rU!g&E&e}SJ=43m}n&I5g}7NEd1VJ2Xud&0xk+rzM2U;6mUOVspDwG&~ z@k&7oxj;jJA98~_IYhNXG&sQ?Q*(BpxiwGBAUTsv4^fA4x`5o8($w15ra2pO7DT?wbJosbO1GU zqiBW{bTTA(`RQyOiW7|Gg9Zls`Flp%**Fv%GszZ5qP5d3z}ng2)btYi8w>P^`vD6E z;Dv0Ka9BckVTXsMMlQxLXr~?R+u1tcqo%;kjb3JMUT!>$pS`QSx|A)iG>S^V$oj|~ zZd~|hUQ1$OqTR*utn$0#$G>X~ru7tGn*MK^z{p8eGe@dRiP_|h#270uMv6`704(kD4lF<1!QNi*K6#Hab~H3+3f8# z!{ErQDWoJA9erIpxHiWih5GG>2PmD&V_;N1UfPpT#;rYM71{=pjh- z@95>J_t1OLwxPJNXv8MKPD@VuL^?W3aALWAkXnKqBIp9XePQ%swz#@+jk=MhFJ>1@ zdn6lUN@=)rD@%sYx_d{BOpPgz=?gj$G3KN4Cz=mH%6`InBjPoPdYu;G9VpGY58qch z8@&yJ;pr)&!yMY_m>yros&g5$Y~={I$@)ocj}ma>j?C%J zs{M}-9X5*3f11=uiqd?>r8DuIv-q#{xy`&27qQSTH~UgIo7}JuhwU0Vbl0$9J1Z)7 z4(mH?SYP~;I^pk1`o0q1KR+zBZ)IiQ)L|GB)})uXTuRa0fIn!sFeB%XFP6dH;Oqp~ zW*=Zd;)4_4w)LIgy<$?k%)$;?B?HCf^JZ1lMB3PSc9!dVbumns95<(?@twM! zd0U6|tAcmq6)`IE%VBBsW4i8nw9# z2=0&5Q>=ls*JMFY>H+WO?=2n)sz4YKk*t~32GdPM+V<5@G>|I zpe0_mjHtpLwZO_Sxki0d0nBB=&ly|;$s&}_c(OB9Lo>MJZ_ej3uh(9*^_o1ecGYVv zD=DeJ{F-8r+Am1T+0f81DkqK9HjY1h!Oe< z@W%G*h>-IskWZ7U0tq+ZGJqEtanHCq8MtS7n6MT{y)qf;9lAvr0y=oRxgrw}+^)&d z1m-0nah&7DsSttyWMmVinnr*3w|#xG5+tcldXrB^ zoTy)^y#Mspu6d>DDXIBhb0hXuj#wy3Jr`H(Jo>L4;r#|>8`BDX=5*UrHgb_x6TPwD z_G98v2RCC(k8-~m?c9wqQ<8}WC81P!Lsx+uRl$h3w>|#e{YC@92*ArVz}6ZOIZQmc*B^42v@zEO6rEQcReJ z;aD-#g2c@lQ3e=OC7c@0NTCQKLvpl=ZgWngd317i@N-W+J#WSv_4RMen0G3*vyYR( zHTjkKGv2D7_U6FpgOVSJ^6l(oAMF`ln>uK^CcJ)7T5WiTaC<{kP>+mE<1e z>Js2)95dy$`f0CEsZI(GatU$iQ#0jtdeJHc1E=)t<{jnXl;9E8drJTQQxZG-#I=j= z77;&%a3l(Q;Lo}j?{{QP7LX;?76&isSjd{HGZ54qGZTK{;007!FrxHm$d6O1#3>^6 z^Xtfj;J}XIe&HSns)|&FzRcH#&=uv$H=ueBQw%&09s`g3JQ24cn7kmtbK+Ev5XFW= zQ~X|SNS$E}&R#Y81Y-?s_P4tq`eNqfk6xHRed_GF_4=MwvhCC(ulabL?iBKxviXmM z*Od1kTlUj7kM-B)eZ&qdaBDd9?jxf*WZ*~!iO*Ah)flkf>?uz%jzGxAWf;EW%#g4v z@a7?_Ac}7Zt03~-CQTlUf>4((b2n#=7O^fNE#vw&!~kF#!|if$Xya~q@}0j#p|P>& zhnvLD#EV-mH7-wTT)_K$ugO8v1ARii#B~ZxKv)=D;c5@G(?6 z#>PELqvpb2y)-}Ha?-wrIW&E!1dBJd@!*GN8QVEQ!-iuNCkC3qVM=mEFDxMDAwg+? z@~W{IbXG7HgQVIW1>9N+z>W+cp^{G0d)I>)+K~zFNcDo#z>6Ulfk&9D`80@ew#b;^ z?(C)=6P$~zRf(?4PCp+}*u~2&GvL7&m0+Fid0Dqp?s5dz}cB5f~LHYCu1h4%qB4pil~W29%L<5$9+ zh?_(#!7q_j(kS}*cIXn?A;>oeB8&I2cL$9w-%=7)_(=Bg(e>}{DoN|} zNbbJu7f08h-&vZTII(1NS!`8jB{FdZd$&*N<{@J+P^@4+@Kyo5X~43=G6VUIz*?CF zmtd8qB3=-ggaJd$fcJuw&o*CSTa}utlfL}s3tYtCHF`9*XD;kR_JKln5oj}AsuQnj zZe!nf5sv2^iUhGZ!d8cgonXxdwhea&(l=RrgEtLvZbWu|Koy?R2so|k0t=A91WpxI zGI=-_@~fQM^QU6Ch34I}oH4L%5%34OruN7i63u}oJ?V_;*u}4l%JIP(h0Ykgndie< z%ik7v^L(7;<7YFmd~u_fZK*FG(mN(9-Qk4K{`rG9l$_S}u1Xy2+0QRIuD4WIS}~&3 zM(g6M@eT0p=$l>>J0xDoD;=>owp&kId&wr)%g>MFt`_z+ncBnPZTy8=qaFchX;*@? zRT*1f%r~2dX2kg@5psyTMLb{?IhZubUDVI_EQUE-#s;BWA_Ap=Rp-n_o0KQcDhDqH zm5z3|JAYB@JZ4zd!h!u3?#Rr`%go5jlcuG09Vf*qZ$$J@T3J6~RqDe<+1bT|aMGvgxqK3trYJE%B2yT~-J$x=t) z)m3OunWV9)I9|z8T^13h-8@o`UlY+&f<$*WBs(DMR7kybmN-UuOkyKAegp8hWN#ii z{p$X0uPZvKG_%J41;2-tODx=J;Sy=`!R_mxKCr!8a#BL)+#zh)SX$>$X^t49{T}OF zY1G@{+(m>ogh?|~uPFv{KAtZq4QpA(a)4~DHdhNQ`m@tCm^Ta#OHhM(R zA!jO8n{VbDNqFJ>$gEkbMn)ESMz#xZ>0;QjMViB|Y}QYychPQ?b-wPMHY@%r?!={1 zIB-Wkumg;RUQ7pPSF$z%U23t`(5NCKCcIx|xgbx?-bgpRnrsrB3=)9k2lz8V^@>HT zdN>SloFb}}-n5zGR4&AtgNoMD8HK&D_=v|dUJLUEdAJTAoVTdoz(rXV<6Lddzq=(P zFE=wYKVMurFsn;K_o%wCg!o0Z(^e(rM^10tG;0Z4+dn&Ja7lJfKf-^lG)L+RI(HQ^ z>1~8PrlQ^hWQ~J^7*TAx0{;HVCCc__`3^;R$`=@D<(J^)gH(tbz3JtH_?p;&^zh*n z%hE5t<6S#s%DRi0iAnkL_i#RrRSqQ=EgGSWV`C!Yxj3|M*FGT7 zNvnrfBV3KZpYym@F<@s@dc>2Z_F}=Z5^vYoh%wrgA`Mt4rU}>jq-rnNJ7UNUb zED~#GFBBSWK|t8K{7p-e3>S<5>qgrIw2A1(pin1Jn`m1c^ujON zLL$LDifE<|5TkR_>7i(V0Hft?Obh}%|Cq(-q|O($?&FHptF>Z`v;MrY-E^O? zuX?u@M$S|W7T2muCt|#oblL?*JJ7Ev=y5U7MMgY^!9tsTCp=Jj^{hQ{F z5Xj>JVi+AfU>n5mDbsxl{t3&%371=c{r04PvUyTXYh-rqYUT2T!npCNG5Us z!$^WI1}k73GtRET$ex4+$I$=@94>e_k2vnmsWoVk3m!-B{EPGF2YK5E=t2!?hRTML z5^ck(&B|vU2v{PnM@Z_DQLNi$K1SlNyJ~(1i9?zS4iFclqz(xyS_N|g&PX$X*f%{z z6bA#RHSJ2ArK(VY7&!7dWizI%znGPnn1AtA4fCp#rY#zQh{T(4{Y9|xjmvN*@IL9V z?T_yf z5N#;$MpVYe4U1rrjmvgU*jHe_VHlIA5NtHKI^d{*qAgdQviTB2 zLGW@e?OphmAU%|MOr(u6jV0moyZ=u2FgUsxJhLx<@cE~u?gpoJ{vO5PE7Dk0g2%vc!*E+3OP$oXHUi8!$+}n%Ou^eSR zV#~s@90PO4qjk)G5^(et`nMzNXoRK&ebLcDFp|h}hJr^OFkOELXVA&H6GwzOHYKc& zCb3b<6JkH*7#l3jc>tkdcF#gy>peK%E2KJUzV-yyXTqYG*aS~Zi652fK5IS-h_7N0 zNI+9h8?5OOnpt6td zdSUIog$3waJ!2_4lrQ00fZPO#CJrB5n>iSHE)H3B`W@9mc-L4jManU11qE<`;1Hqs zhiXJ~Gy++P11fq8-XWb3)tq)t426eM85Be{rw0OfVI9(?yH93AQ<4TI84J#y-1g|n z;2HC3*e+?#W+q1^heXBo=stbrvIin6>vD2*xZ==j6=XIhq7`pc85*E84wo7RDu0h!o6CbQj9c-(!AC{Xn!KB+F zJPZNt`U=yG`j+^&s&Fh2ITR&Xi{&8{OoY%*26kY=fI~(UMuFnEe@;-VV$jT3EeBmE z1Ob-ua!Kx`Zo}3yhtCGgQ#7%Bb=fCl4vr8nYfFvk1Ih+gf2I_R`;=?Tk5)g08P;Y8 zg~dj8OKMo9d2HiJ&C;=jweYM5u?ZtVw=*y=irYTKsBekeZaTm23g6DjmvdE~L>-G- zf%&C|6Rb^acazld1CrSqB=?bQJ+q%W^=+O0rYvj|y&J#TzF@(27O8v;Lj$yI z9+#uAmG%?g%l6n$FoG2!JqAxI0?$zFOahw#c9eWGm^_Sv{4%)^`^puC1I>lSMSoM) zXlPZ8XU1sLA_>Vcu)8A#N0T1|XMQlTk*xGhAuJBv8=Dw>0vcaat(WD&03w2MGT>Mnxtw0XN>_aP{wxdQDTQ!!3KtpeNoGk=p5 zF*vSe@9^mGFsRj;w5MP;zZ|{0oLyi=y)(;(WrXIme=$lNqzvew^O%$~|B<()y5!o7 zF5Ua~j8FCRiDpkd_D)F8wNvJq@4ixg{sjyBjyNMYwE3h6CXtsU)?%NlR*%g$BEo{> z-D94cY9j?fsao1}MVV{0E(Q!d792U*10|eWh{C$Eu1bcAN8rW}d=50Pn zOgy)09ck7gTfFbU{jlr9j!yabxs4|rKGbLRs3_NYuPd6p^X+{IkCu^IDZw_qF8kSs z-nhQG#t_gjws+>52@7}c%7}@{Opl9A2gwj$Fxe#g@uPR2DLyn*51?ZRGemg|S*;0D z34TG^3L%>$^ds9mA1^mQcRwB_n#6&oGXP_b0~4w~esQjo#9KY5Fqz!gR(2ICGS3W{RO9Kyhq9p&G|N$vsrVb-JJfh*NfD{8(Ze!E%R+N0l+S zD3@vXKh{`h=1E3@PJD&V&|gnD>Y>9znn}gKO;r4BJcx<1O%hVd1P(og%rwYUgA0cO z=(j3RV)O~?LW+aPZe3!+VuB1EJNtD;G({Yt7E2x%!`0h#G1A#-zAY>fY5A6B*CsqQ zYDQ63Rr$^lRl6!iWb~Um>d*rjL(0?A%Z6n18qmLY@BaOyy2LTY%vuKE+$E(+E<~w3K8ZS^?rz%56P^? zER_v0@AWp}^Y123b^0uSn%@gzyv7%LwrL#+)R=7eVC6KGv;emeY=Cq z5N99gfjCrEX_Gko%o;m_87{B++cSss##Jt0lXn3^7F zSj>0AoPUX|;PBQreqcw_<9noKfZq6iAX(_kkcIjQeT)gPNd*Oftzqy0go>V=wqUfdg7RVDGgm ztf0q|xJT?a+$^5N;JT6lHzL1r z)a$Z)CU?lrIT@WFUR)&JnE2R=v}w$HN#EyQE17W%k18f?MY~tf?)}Dl z^fBTT1%nrdj|AGem-i&jm*%K(B-o?usiq5+&HmwsCw}-r`uKxAAAY#!1C*q8<-L*z z0=WHy&m@UHaWhLEjWaa`|N0lz6@@LbCv;t(pstRxBS6DSuLQ*QgtUfCesUxPyur5? zp0Ttb;IVL|xo_bT?0VVr@yD6>V~@c%DP1`&US&BrH$w#Bb|LwBi^pykHv4(kDsM`e zIHGh~_*Ywj4^&>29C`iDW;o)8x6~hq`ki_GE@pVE_NjhHULOixEA59W=foJX7y1u3 z!&|rCcu5N9^}Cwkt=g|u&PiQ){}E<*tNIg^b1X~DMf=^%aLf8lw;R7P!Mj_73)Frj zZ$HuuZ`D5FES1(tNQU z#-D74Thfov0#7l+CCmLW7VUT9^pR?Yx594~;7&*ntJA`c*vj}vVSc@M|7lj?RTy6} zhvQ1HQlH>Mc>ftz;Um%h3=YpU!&}X-1)gPww;KN(v|q&Q!+OO^|Ae1XKE50?yjA-Z zpl@~mLdK=mZw2p%@#%Q`5Wn4{{ZYJqh(c9(EBsd|r_jGE@LOPpw`#uv?ROO&0WY)) zU#0Y6w?z1hYM~;v(tkGK&vAHvtMILWU*T|=b6TlC67YX<_&}@hwN0HR4>lG354s2Z zH_1cT1vqs2R@&dvRE_gH4Dezzyk-6ZQzqi>jD`&lyuP^-q6mHyJfSIWBd(x>AAA4| zc$A5<@ai3bGTZTcDx>M9_@!jT#pou4Awq)biPIt|gxRP`N(dj87CD_|n3j+zXD71B zaAKQwKl#+dyPkSt_tK?leQhtDef#n!XU|@G2v(tX%N8iNFp_li_dV~=1yUsB%&{UT z1P>1TBQjXECLz45=N@JWA#6g}mWQ8t=HcDXJiX^Z*S7=G&iF_6O|!lH)|pQ~d+W_l zwlUkPBxQEUB-UVfaN!Wl6qLl?lj3kglT03}ND|`_+Q?Xsy2np03#1qVWQ+@0AbanG z?eRyYxI1r&TUS3d2PK$*6N9~kcC6|+-F*w;fax|8xG)xGPSR$6D%>rB<7RU$Pb#*e|BAuVDLJcakG_3Vii)CAV#C98 z#Us+dW&Ij9_D?M@Jz^VGk>cUoqf6J`D-ybfbPoG}{ye3@4DL;R&@~CM1HhXGX$p+h+nhu^_;(`hmJgVP5_llT2AtiS#E@*hv z;l~#kXPX>|G>N-KWgxybax$zvk~_mPphZsBkM;ebs_L-T?pWPMF{1IKZFP0qSe|mi z4o#Z-v&eHr!&n4SSaY(gd*`{Lo+NiOvu%ih3G|bHyt9AQsHb>O*X;iDA9O}TAK&zc zcn0(G6Y7n29?qhqbut+bQJ!@J=o%_QlJB&UNSPOa47L77aAhvW1y?>^NEOD7QL$98 z*fFIFi}_o*)w((RkBKRrRLi>?!BF5ig^Y*v z?uI}|!#$c+vkLMV(pnKh>9ihfOU#r}$z?k#X6`%;)-txDjjUj9t`{qwFpjlq!6p z9pmc41SDtlb@g?yLyj_Mh731qc1czGB$<>7mLd~2F>mR>$oQuZUyO*Du=K#JnB?S` zn3NQK;*7H7rA4fr^0LG1Y4f(MOONlBmKL7?o(Z%C&JxyMblw|`2suLvNqpNZUb;u7 z#VObVv&3xWkhoF5WoKhGoy}6K^^6u$jYjw{l5hzP-b-YJsdf&f)#=tXG`e%NDjR`& zQS<7M=F225x?gG0idD}IO^MIkKWD(A{Oq{I;e*y!^y-@x8<*9$cZ4yqdt~oEwu^>m zPIl0@tL{@Vx7Uco#8K_^4wExeYWh6bJ2EOMF*>q08x`NRYg}B{uJL^Beg~bV5S=nf zl@q}on#+mEG?#BJbpvt%Ym2xD!XNY2f<&Ce=l@)mvX!V&QU19sZ2~nC**}-%Sy297 zP{qeesZc29w8frr!)X8wkYuqcIJn7+pjlF-1_aQOtP1WZsxc~?Lz~5`IAegVZ(Zu> z<&Q6qoI0lOknLr?vXQ-|cYJQ9-RkPx`E?0t8z#>=&|%>2Me9yivi$>kL>Cug;}A{Z zjKGhLQZnB+$j70|sw~A+AXQ}01DArVdDeH0IcpvwB}02n1l3AJH4eKbs;6n!?4M1$ zCN?ESO2)QHSz4t0#*&-2O?tYzZ9vd;(m4wJL!JnQHlE--(=UeKypNQnkBpv|w5y?54uoC3D7_>JSKOO&fqMqD~D z^$)Zch4$*up2NN5aEN*0L9y3hQ(?#XRrx_21r-g1U_}8UjQ<&e9l;dv}|N5&s z#zjrPvczQ~6S5;KfpBxGe=DFBj3+YWG^aSb2_ z+LMxq#t?~t1vISc*sbe~AIFXQwWd#u=U2ZyFqPsxW{B&=FEyXw&GaD1X1gjg6Dh$I zS|XVm;NNrjax+{yW&tk{x3l*&7f^qN8IH7eE%j3Xe~H6aT7?&i+r>wC`>U+N2cZ9R z9KQOVaQK6x|20Tl%rH(G@!Vth+E92-o9jk{@K*D$6LZ;7Ey-jbGQ(TVFADHF z4&T`p4tifCjzxr|G1$x2<8iC6ZBsmM9OdfcjF~sII2OA(D~onC_A{Hr=1K$Ze?Ox< z-_O_wwG3ecr5em*H^w=O_6g=Ot9hTSV)NK6WFOUO_W)jNg4Z^~aeZmlK=u%#?h`x+ zmWgEbrnb|vUrY&)a|BN_iST`AM1PiQne&ua#z6DGy1J_AlPPy1%LX zpS=CGvWJ!O1xUh@6k6UTKAIej% z(h#kBz7T#O-Df)OdimdK`8N1JZ*}||tgi2P;C~S>ubw~DzB6xsgZ!+O@euxhx7z+D zdAzmqpa<*Y*=%(@kYVV?TgA_287D*=dcODgH(MQlBF3|jk6%3xi5?vJd^bzaSZTkY z>Gyk#e~Z=egZ^zP@5Wv9L!YTU*6l&k9<`na41?Zm`buZidlu4ksUpkB#7BKWC0Lecr5f1wu(;UHp@D(K2`BcBO^r+K9uXSTIVLb9FeEsrgSU&p z)quw@-jj~z_aqKcRS^%KK?_qu)m4~3w&)uP0#bNhntc7peV7c%O$HD6q}5fg$jn|b zvU+(&=8D^!Ek2y#QdMbRdQ5a?TFgsBKzfV}jL+l+=ay%UA0j zm9b*Iii@%`dnLri2Juy^C@UIXJiIVJb5Pcx6k|e0uZ-CE*!Z4t5#fOdMQpi(?)SNZ zZPzrY&6)6Hm{F~_^ zL&yoREn4Ain5fHWyhn8#8&C+1fm6ueGyy8fsh?UidPpg`yv3O) zWzMXr4fPEZ9~eEQW=hqt(&{1A1N-NeY69Av4gVb- z{g0?hTy8;PzxV$q64Q6N&qL-eTKk_+-krBvD3ZUOx-{L;h2pLWwlm_KqMI9UL)Yz%p`A!#nCl46cvWTehtbd1RCYR zS9okmgKGd>>7&IHCl4^G@x)6H{2||9QFvoVVeSv1{UF}{_Z-)!0lTdA6SewV^qIB8 zo8*$#RnY43E`;qBK5HJtXYw;M2yw<9Jl;D3HqdXp$!%mEasXir{k+V_k3M2yc@Oe$es5U*EjK0f>z9CkcZSg)@%{U=8K!SEVqtvG!or^Mg?Inv zb10Dil9Fgndb~w3$Kx7%DOZaq``RD*=chH%;t!f@_pVv5ie95HCe?s*P}dwsq(sJdX^z3r_coOY^F;$!5sYz0xlVDD^RI|j9@D$3soXwEyzNDCLp9^ zJ1AJ-#!5b7q_$8a$EtB@3@Wp!24)ji^eW5r?buP=B8?i{r#QV+Pn(T!$gz*?9ur*K z(7k(ET?4KATqTV?*;K`JMAv_1sl57MSvait`0iY7{7?~^CJMGfM?ObaICu$JblOZs z0b2xlH4Q>Tno$VgVqz3wK4UgDcJS5-f!1~n#hK9R zupey6CY0PsLhKoAL}jQk5l+{E*@`x{)o`{DhQc_25@qY5iW8wU@uA?(ZA#LRaOLZC zno787lr@(wF$RW)`gkLvpAZ@r8rG$ACx7n{pAa_}doKqs49Cvd)wvzyd(cdhb`sI4 z;8l#{C`OGL>F%Ko@v!8{5wzKT(--1I`){r^u4$(ky7y&va?c|#vX}Pe6cps<z4_+0yzQ^=XQKw?4IDmvVBVlnO7A^;fd6StKiE10 zFTq+*;8Q1LNz3_uoQ4m#5Esw<{W9q>{yp%h8LPPdutcZ&`oGvR z{(W`R51N-XUyH#k8DxfRF6^RMhSkNDCzkQm6@_hxm2^PPhrZt+7>#`bIwHC;{4-!N z2n953DBzHerO?0}UBji{u;K=gWUjE`?%?C^=VRz#Ft~*pbO^v1Wb26$%fDKB=a=}^1r;ZhFLT!P7CXnTdVO?s(%|i9 z>n5MwHh9HIX70?cc(ON zZd~TUgsYL_OX5o#uJv9Vt9SXx#V&4X!d10j+vA$d|E+#ETvhwkp7<-pqTd(Sx9#_= zTb(8sk%QoCNv0yE+1gl{tut2{&}CxGwYdwOr)57kr4_gL^dBgf z-I>B{OuhYiq5r@O3WQK-5o>oAIQ*aV3FCo#^r?O1&jBX%b z4o*ze)dlG^flH_mFfNP4Hvu7>UP2InCl2Hc7bN(1!!a}@j>$e7t|lDJ#A4kkmG;HX z?U}i+&$W%>OOg0`X`CHMMIXDk_q7d;sWeyW*Y;;Kz5IXaR~K#W_pcP~3ANv=8`|`{ zz7ckSyx+5KkD2L(BA>Bb*h^TSt+R_dTZVZeyNdI78`uDf_Di5ta}F&o**kJzaV zjYf03z@usH94L-0!l5J4s)|OW;(-YS(q^|tCj}9eY3)L&i?|TAAK7aI)7`0)%Ln$q zy<1wT{JBAVIc7bxxiGN*1!luLB>bHP{{C0`({Dpz2C!$u52Vg)BV>vOtLrc_sqSUY_iMa z^Zb9m|ND8-WV3V6ojG&n%$YN1&YUCNykhZ*?U>-0x>bBSA+L7!h3@LRs0+0F8aTA$ zIN+YRKU73-Tnz^f2x(1{O;`ddGu-ObPN;DEz+5*_LM*XF1V|x%H6oWnIpZqru2_6y zJE5H|XeYOJ|MR`!(s<)ZX77F>yLMiJW6D->MMB3|AIlZqHrA1L@^G#H=sOePU!?WF z3-ABps)Os=f5d%rP8Bc`#49XaW~E(e9BbA4eE-_HXl)Bx>lEv2k#3g8Y7`JxY;{c0 zD8TH519lr21Hu9QN8g#?Pn4(rccJG%0bQr*N-ph4%dYpIheLsMPlw0^ zaXD|KR=8ARw)_)q3sTKV{SN0qDt-6p%v7)Sz!TtykM8eh*L~%sAB!(h0 zgWK{F8{I_2ajNV3QZ6r8xe#$KI3pZG#Ah~~)C9kLN}I|jH;B(ThHN;giI$R<+G21r zP~0Kz*l?0BLR_$5A`W#7-S94#HGEZim-7tp_G|Qi5pR>p6W$LW{dahad@a!Cw}pIm zEP;qJE#msNuMa}Ivo7#yk+^uKyWA8nTi|?8j*`ej8WbE_E>|$$XuSj5DI{Txe72WN zAwj}dzlZWFKI0!{8S3=u_1A@7H1*X->$TMoNhu(3`t<453-w}s0xe1A{4e9=J#_;! zJ*rcIlku|paD#aAL7*3e(w|EoixbvNY!=%h7H_Z+YPSRjVyDOqG#ki~DT;ylEO3aU z*aakUoN~Z;4mwN~T|%lSo^Z4!y`y9Lyhf$%rMEDUo%chz(fR0Gv{O{M9a034^OCpY zB_d>jHnA!C5KXsqLt95%N4pI-n?Kcv7C^2miF-(|a<(JARodRA9ncv4p&X^bh>Ha8 zjvzRU`5<6CO*LwaVv2}^AaF?04+#kg4+#$oHOt%~w!B$n0n>3|P{u_EwY;Qxr5WP* zSZOJ>6IVGVrO&068V`qvJ2q<5tn?4czzf6DF$>SX>#Ua|Ly|x>Cc98q z?{t_nyvjt}z$fdwEl6Xe$=c%G4UWHPs%w*4KBZ3%eX45$proa9BI)%1#I(R52nhl_ zaY)RQVjBnj7AAy@1k%Z{6hP>Wg7WRWvjjC<>fXqj(8Q^eIh9-(oOS0_eg_bWj8g`2 zrPrx^N-JjW+&MEld(C%?7k{^=bgG6XSAd<&vvbzWT~`;}T)Fb*0$mjb7H^h)VtT@f zs|_ML9*ciMHRx8jC5=Ur)GFYQLmXJ~rGA7k<}IR;Hnb+Cb6j0yBN=`WcsfM$Yf7z9 zxRh5m-fFtPGnDhvscXMoy!cz3Y7oBCibnI&J62Y{Gz_oqnmKEyriN+i5cWssgj&#Z z_eln$3Aq_fIB7nT%eOz;Gw7qwT1`9Mysj zMY#BRdWQ9faPjx>tU7c$sx!dTGt^1X0zExLo%GCH^%>}riD!%PEY#C8$U%A*=HXd& zz0Pp$ndnN->UfXZi*S4PwXjcV2OFHxXaT<;(njKtW)uBdIE`nu@GKb5PHWFjYtM@D zET2CM@$hUPo>84amFoomeIm>_i8w%NXQ{*;pqcEd65kkOJ6GOCoXsiZqE<@ zQ92N>Lg)+?W+_MHcVQ4P9Fuv@K}>!A3KkeK=n$K(E_;d1U^5S?PqFDQsmo@)#HO-o zhty?k`XP0>x&mKGri?G!VC)V+B0|MOz+nXA885vey=JKMR}s}crmTbEP53-ezHmr`2Bdfx-u&yR zq1$n3kMtb%L%2}Z!5FE-K!P-=8D?e|3>n9b9ZGX(?X1905p4E2+(fOU){y;{bw`ji zWPE^bNmzSH9Bs!bv88AyI7uGo_z-;+UHVGzV3g^d zFteA04i_(xic0J7ZadD2jl^`wA3N~9uh9l+DUiDhViq|A86qga=7#VV2ntOSOS`KM zvlGcIq>T{Zq8Vfgf&(h=30#(Irh18~h#sd2T7D_lE`2V2Uh?ioKDVA|+N)Pnm|+c1 z|20LN%zi8#(z8j^-n~(TW-4+i(cN26XffF$r!hgxe?(OBl*h+o))|j^Wk8pTHj+u3 zMJuF5Q7|4*tx`lBx_RuH7{~CK=BuV&@`z5=+)5tNbIYCt?B0b=unu!Z62k0|0OY6y zO9$B(v7(rX3z2Ws{H{{OZxM+u@J6AAojeS{E~F)5Jhj~sF27=XgyF`R@k$iEl0?L( zMnxq|u2piGs=I`E>cmS<9DHD{ub>$$^j!7ChbSO&C;+?r<3uCW;v3~3Wt0UU=1nxS z#zSLBwL%3m*b?cymm*eL!50YL#rEI1BMU#UyQMMG8Ea6GwX})VY}Si}JD1GXiejJw zbSrQP!Mz0BA_qyx$s1{Cd02oEkVwE8DP##NY*TcsVj{yrgUr4m{vjG>6tvtOGb?bC ztfU|if>p39xokGewKN=EQ54%cP9P;f-E-7|$KmMI)hR+haKvGT3>;y=CLCp3xLj<*i3?lf`SVtC>k&ql zg`0d0$3aoUF&vOJsOcq{d`laaR+p}ccS`F?7bS>QAXWiKnUMnoKf5=AsvFSQ3dB3)GbtG(DEwqN^{KEh`fJ1E}ar3Yux7j~%Fp!R3`*`ZllDe;(V zJEm8uddMp;V>wQH9l4G^;y;|YmDUmWJNi3tTm$`-bMF<0@#?s1BEgGSOg6Rg3 zH*Dv~GDJA1dl}NbL?u1hNIwie7W^Rd4|?E4O78&MKZm1?uSG?dN}sxPsYoooaG|IO zKddP_dQi=pMO{*R75h?`)Lyf+(#w~Nis*-BUATO?_&dA;T)l;(WqpjFBefZwe8s}H zO!oe|LaLCCd|oT;OKTvTDzZ4#OvKIk_-YXJwiwY{u*Sl10Glt_A7PRy_zR>K#4%!F z7y`X;&r*alj2}a2U%{KMpn3cFc=r>$y?ye{2!-#{y>a7)4eQmbRg1EcG;Y?oS<@yB z(;KEYN~@PzFSSAaT6JsHty5b&T0?;302UC0xxwhr-RYsD2OH7CBZB8>Lz#@7CH>&< zbQ}%PZUc4>Bg^xLJLFB5PXw%Xrpwy!h-y z)_i=)arHF5o!e1bjUAU>VaH3W?O?m`&cIFC*_-J7=LfaLtL@tka@=N3C#t6>qK1j$ zvs8t8n*Zv<-d5W=uI<3T(&Oy7+5u$7*-HhTo!sE0^#c36YB5ofSVm(bAo@dtki0X@ zESiK63o<-`$_PXO<}QRwlw!i-Sty8z&VfzG2w467jJ`-OMnhoo@-p=kOeU{G;n z3wD3Oc5@7vN;}oUsYWCzUkc24xNp%2M+N+MD7>*4%xg*5Y-3-DUl9CZa=0USK(prk zbMF2yVCdk1ckT=v*t~hRBUH?)7iUZDbUNeDKRchxtRH8s7cTxZ;O8Iv4QSfD-=IPL zn>WeM{^^%&wWZj<-op8H+psRb{@O|IT(@w3T^d{Ff}i1-pQh`%2@&>41-pi}ny4d#s3p>Q3)Nc=|cZq%nxUSa$ zA*66;08MtGGa_z6G^`=sa98l?r|E;ru_7ZfS3ip8ivuT_R1TOkkkA0_q5)$?1IeVqq_XmMYCIC9zf?m- zbI&{S#oY`hP+2&jZiJpnxck9JGDPTU@8$z5B-%x5$Q*}eC0y1qki}igKZ>bpH1erx z%=ckNld-$MKN8N;T|=`!(g5OCo{kjs0~%Jdm7(9zhOoy-m4I3z1e-Wdt)bDuQI}(< z8XjGccG4Gzg9WlRL>hJCb8IauRt+UR*jH-&uAM|DgK(?tYxv6EgM{yZyPG*caf~q2 zJ`JQYvjABN7!?@iFUc0lUxpa*K}L~L>Thr6H6qkEMDoV6k?r-)J5LgkUNiuqMF)2@|UaUQEb9VOTfm^p~pE+9w+#IkuXW-@mNO-Yji}snbdBDwqn{!$X*xE8X zTRPsdfB%+SvP<9F%CcKgLHrgfX_c*xzIoG%*H8z$L6vM8Fkll^!aq^T4Tf4=s(v*a z^-vXfc}vS|Y4(63=KDr0YGgLeT`vw7hp$&_ zi{Ilf$F}wCQ^3PU$0h?_%g>Qyw_)3ZmD6=}U=yJPEmoKoLh@7P9Iksy?W;edanw8qU&n@~@d_59O3 zk4JSNh3IFB^WVNNlR|IORvUs3t7%iC3+R5VMM74?4_;c*{Y%anqRFl>H^ zPX<3s1<9rqJza_-P*Qmxv{u6jiX2PWgcV{eov+|Bwf+kB1=<^Qf3qgN0ZuD~?(rYI zLPLqGnffagwR=K{#`V9fp2qq=t)2${zpP#h;rO3nPn_{zR!`jWpJGp}^Iuj^?DU^i z|6kSYWH$P=hb1O3A)#Jky-GQ9G|duH97>tT961uV+HtRX81Q*=MDgQMOSeqR8_+DR zK}X+;OgU{FjmL^PV(vIcXp8Ld9+WdjJpP!RIgUEwxzUcjV(#cwuGw>-^FYs_Jb1Ko zMAmtj2#~25mMEAbuse4>tVA#{EW!XZ!ZXu|V_O8@;(i*5*i{@C2a1c>7mgPkbHqgP z4M!)r_*#i_6~C`R43ci;(hl?xNK#00%J{{P1Mne8`N$_t#|7Qtf-jhSOlVGT&4kuc z_10(ubDUil7m3+wqGJwwL44z?Tym|%KxZPNa0iR|ar7q|^0uA5bsUogn>7a7M?B^` zGL0dm4$kQcp)F#k038T6e#A>4zaUnCT?OkY2(i`hb~OBg&`YRxY2^vLZ9J(r67$mi zW?Dm&pobW-5=lkdncv5gCx5K|v3;9*@4}R8tA1a<{(>9aT73mTYV}PFC)u>#@je*qWABN$(9q9NMwtj;XoIy+ z!yj-Su@42>76s{by+m`UGx4}P-pSHK)yA%GVC>{LH>?+ayR+3x zqP+6%IxjaoaS#R?vJ4;OOd&!pCXX8mq6w27>CFWgV}#*A;LOOd5R5FMM<|#K*78K@ z>1M{vlo?$oZ)z~|h=a1~y^p7iJIUAvc3rhC`+6Zr3(8#u+V?maH!E7$^tkek0u?C$aSnIJx08hyH2qC*EDVCI68fSN2%n$5NXLpaY!SPg2vLGYv8HEJW z)J}Xt0f8FAP3+P-M>KBEjxYXEZdG#9@v|~=t@@36do_ztzhBK_SoB);J4*Y-&2^5u z>W>@f$p#k6LN}=2vxp7q4}>S?h?oCk@H9$)ho=|P*`tdxQsr@jBV({t<6zl|BoIEX zj2FLiM3#({TZtCO&m||>Y#qmF7PFc#S*_xNEM+IVB!-A#rFI?1?^q;oRDS^8z!N@v z#?io&{I@MaQ+s+jHNCyyQuA-A>CvL;C6*(($#D5ERjFJ2sq~t9TfM!8MXKMe0SSQ~ zkkBojrFJ*^5d~@fFA=U81}k^)mw_V5^PLmJoO1QOKqwkGUqIBrLL-rd6D}sGH8RUokdEzr86x3!M%?atP#VSbn-W0##Nz-Gr#* z8^lELww0Vr%vSLQntIYnb+kCTWXvn<8YbF0QMp=*%~wSmCOTc#+5mQFL!?tl%qqSI zrLMw-1UpdF&s}JE{n(>9YrkAk^_NsL)%_9hZvp&y-7vl~_*ZdPNjmY=BHmVVQvmY3 zZrb_bhbei8sg2C4 z8p`s<%cZT5>yzZp`jTv{gcdgKICTgQhYKk=Mh^o1%7oRCdQe`DIN)oIQrlsy%oop)T!Y+6sF!Mo!L$gc-|9|0R{N zvEl41smZ01`#|703p8$!-v!5clP?I^0^R^%F_MFH?kz5cHwcqJ2Rw1{z%m+*-bU{r zGX!=732bsk1f?YhXOPXMqe@R)W`UeRHe69RNQX*$(ZE-2kNkXC22A{VdpHk5dji_S zs_N<;sI?c23{_|k6hfaE5(k;(9;KtDP3)_6)Y|wfY%D}+4c;2JL&(_%e<74sQ<_aa zur$$hLWKDxUJNXR2`|E0E+G#XtmPE@9xJOP6VHVT2;mDV@_#|ThFJ3Uuu?h_`k@G6 z2q;QF2eesm7ymxHgMV^8+M8c}fAa_G8P?>3&F^!6hXZ9r@GQT9YLT^#5LgWR9|jKX zp<%3yBY+K^p>TiDd|-z|6kvc%DEdDiprF8)Pj44}*KrB4iu2X#Y#cTI8KJ?(*I{1~ z0<4L8h9iK$?~X}62Gbx|uB)7VAtf!+?$Oy7i%-A^r8NwKCq!xktlU8%um)g5u;z}M zqwZ15R;~nlwmvsDtnmO|;R-29f`!1cFbsd1C&YoqXSsh+Uk-7<$Y*sH_ zpQZKJ?%3n~k*N+WNf9pn^>nTk=uhWb{t~?yx!K(^>u`C`S>77vFHhy2MR?46fbSz>Ve?R)FToGNL-{gFCFY@g zrMTQ<`EGH&$MO&4DW1xix0K?sJV5-yV|j!GTdg}jEP;LPvAh-zvpvDLMw|st<lkPT9j{2w;8^PYT;Km~D@P`B^glEzED?bzwWzBOcL%jz~^9hc&J)Y~g+E zmuZb+g6WTBOkX2S-7SG4HP$W{znT^f5&+-?YfxeIR8Ifn#3Tn`9-n0xkwxidyqHAsK=B?@T<_|Haq1OGq*rh~Vjst|YI$q%JCEg^k$Q*vRTaLE zxZ7iSKAl~8fL|un@mTKEBdXTFSzm9fmhaZ}j;iG!$d&ady}!^eV2g3bhXshwc`T2R zQazR@kTK0eJ+*W_q6$8&wK&-${B(UitO`F@9PbgnP}J^YSA}0G{^SvUyLiiE`F>HG zFIDR~EAH?Jf1W+zvAjsvN2=CyO?=TK{BOFxSp^>Yg-1N0U+nT!kJ3u=@mSv4GaZyR z;yWJU+ls$=EN?G9^jO|OYU;7P<741EJ*K>~sOhIw>Ci>;IFFRBp68>IAzt=~Po@;@ zvAo-3%Gb*+Ji>35hIlN0$rIml{okUSwiqBKE1)xY%kjaL9An^l|;-@tZyuO~T^_P!1s# z;VZ5pc-#xJ8xCU+W)_>n5h963((8o7twT|GQQs%M?UKLjNgrS;m=8QRmpuuep(b{3 z92dc=35#Rru1BijxYmb^rv-o;hznizK!77)i(ZCEE!nR;CWflvwS=x+5k$3N`>xGe z^+Xr?Tl=&P?a;V!r+&TWYP!{G^&R#-OM%~!Q06FUr^S#cX~$JEq7yxL$Tfsy?Kx)1 zS3)T44v3J0oFD}EGDBE`Qtbs%SOa(!@D$G*XR5df3wtn5w>rc330o%k9Z+`*fP5~+ zCDvkjCnPGk>JO(qoDFM%D{b*~(O+^2EyMn~Z1u2iopSryQzE@{^4@Hho7=8!Zm#-H z+Q(amj>+!Ou3u!2;nk&gbKADf$!Xg*7r3vJmP=QZ`$Ccta}i@x#xy--oirQe-wH`k zn^A5Os2oHEJo^FgW+C1lOYT~H47%VEL*y(CZGrXFh|R+2x~daf!kitbm6ziknPSh% z?VLGmm2!Vv@`&ycS?xRYA3bdA$Gra8sQ+7{O{G}4Ize)TZjT$sOSN)&&3$t_bsM%? znmxAqi0+a7+I7h0HEX!L)a^obopExQUbj1u*@0!NhGlln&C&=f%?3e-jphXHJ_2VP zBIu&gi(>xS>~V4abT*S=GvoRRPCdby_%2WjH4+l(%D8(Qiu=%Rq~R=Y)p6(FAu+ZJ zN;J0MvmaQBgwaEe6L-GFbLk38A-<*O#NX^Ez*Xj3ozYQW1GO_^ajel}aU^?hU~SkG zymgyhL}Zm9ioL<65Vs>96c4dd{?7XHch<4EzkdfVF1wARw0BVdEnzB~La{wWt$vzw z4G6}xxE!Wfn4!T)RbX7|0iGI+jwi2&`b07gV~98+dS7@P5iLp#+QNCJ{3EZYwGK0d z*Mn~I{!%@g)XwscydEda3?6O9NeY6Ym?cYiJ)QM>{^IpOI8@Ywe&ur*$WV??S2vu| z7Vd=+&Q6$dye-hb0%zbe*hqBG$KWO-O4MsQ-G}qBa<)l><{T^P=V0D8-r;oj*6?$o zdsUd*Y`A+LsBMm)Ru5n}erU4-KeW|@w*?u``{Irtzg#&uu}fiVyKzg&x7_^QI@53Y~((WLAYKE5&%F8nbl0 zBN=l5Fo^T^a~bho5G`JO+{!1oHYW_{sSgY%MpUo3*{u)2&v2e-S^-nFZJJxkle`}2 zHXOfup6aR4e>51kdPaa2?-0K;%s=9HmZ|f5DPTRzCLTkGx2?_DTf%PMwyT`sFeGQF zUbI~-Jg339jAzw)ZnIJi#${e}{3_xVfyRVaWjRAIrwn`0R(qWm9$+Z$k?BA=J}L`# z!-wYRMc%LJdOg$K@FBVzIZUArGshhU_>}9HobDUla3&r!a^68b0`U%Dhqe z#yd`73Es&syDNWY+J`=9^ZK4}inq;NFX;Vr;V+_bH{MoxJz86$i#(;aTnU<;3%Y>uA*b_sjm~V38=b4d+!h^f zV~Vzn4|!W!J%Dj*D-H8zC2y-pAJcJeZB>Q2&Ca^Fg?bk9df)&F9=j!sbgPGS99Njz z>^=8-K<9-VXRV&w>;pHPr+}Y7;B8@F%K7;zw|b_4pFiOBIAP|y)l;z^V?WF5abJ&n zz{6=IwI%$Z^{Z^OTfaCAUn4b``(-)}UB{~l^*X(ZvSw*?qCoHNib ze*>)ftc0%%8w8xoa@>7TPA9ES*Zu{A_hjP> zfO$%T5!SJzBu~IIM~P5WzuG~b&f8t5(;$oLFMADhB!~D`e3rj^OWowgw+pJk+(zyg zF0Wj8lExv2(@Cr6HXF$M?$n_Ohs9`NJ;&iF@B8fsyzgbO0*QI$<&X*LR*oA^*2R3| zP~b-JM$>&2JWTaKN8C^jpJYNkM47TbD~}AXL&e3|4=P~2w;v;_;|=uvikipP@n>f= zeC})b97YUPZH%Zq*=I~ya@iqa9GZN<+de0KCRsPy&U61F?f>18=S@; zvytKettN4RK0XW4r?s4Z8qDpoKdRPK_KVtCOd*|v>JgIBW595IwFSn*^O}yf4F`E2 zRlEZ#i5N}L5aVSyC{ILPC?~wd1y$P<@UA?N-qq|~;K_l`cPs2*ywC1qP4i|6%?V^9 z1+LhKY3nNH9&g80{?MFQ!rLKO%!yKb5YJLM$rN6P!BkA98fSSqJaBi;XKIt%+fWb3 zOKZz@t`J_YE1;ni`FI%KZd!S}>IALbaNb5C1#tL%62kf99i!=4G4 zTk0w1O)$`Fy>Gy5Y6F>>lI{jlp{00bapx&d*d% zvO+Jv4|g(Nj(+6Gd0IK)hEyuF{{U`I{ISkde)mu3yH&~`RVpXG)Nm+vmRD)(HXH1Y zKlBy@=f6!l|9ODn?b`JEjV6ciJnu^~>VKN|<+A>68@Kwgx*Aq+`amxNkKPjQ@OP`0 z-xk|x<&Xm_c%8Z)CAM~}6Z)7g2X3NH&|F{JE0<%uSX~{@EO`~j;X4if2W>2pRo8NY zZ(rW8RU8Mv)3}T7I@m1W;K%FK0fl7#rRc{6Da3$LMy*7X=6kB%RtUY+IT~*XmwVS6P4fn)A=s7d*T~2(U^Mv~v%ll{~IYIT4oOq7U2}qW|vuFM%Ha+Cf{YhC*x}l8Q zU!e0Xr>)t=UXh0D4SpP^o(6*mB3w6gff<8&a)e-T-&d-Mn5I?NI`ma{u~DW1-z|nHyGe-c+ogY zNFpCcL__&N@z!AB{ZBM-#jEPR?v{uBVPDAo!CXEp)_C@3jW>a>f$Pokk9?eOAu9!~ zZ9U8GNoNUOCP2s^sLg!M!}#+xQvO9N$8Rbx*R#Cd)5>){D+_u>PpU@=(#p?j@SuU5 z#>)*_IaP;xh&IQS2SSoUf-PA*%401NfBb_#?~UhnPP^(l?Xs%U4zl1cP3M=fSE6-F z)A|2q-b&?j>8qU_m$Lq-=N&}POw#N5S_S_=w?BdM0%Ll4`OPxBhC83D74>|r)uXjb z_2_d|uU{`mJ^CEGsq1z}rB>_Ej^3rkr#Pc2%Q z(Iy5}UR=JO#){)1+r%Wo6MRhA;=Uj44JBFE&3L;U=ECD)z+m^$A6}1;Z2DMS37k=% z5`j-1PlHj8G`jnS+fFzkW&8vNkv~OILd-P@iT}DGW|SZsWn6aSL@-dCQ^_jf&W-t$ zg+&Le_gHoIx%8;iq$V+o`ZKCV-86UpRKCN#Pn(ctZ%~bbP-+gMxJXn;AO&b7Clhzf zWV9s9$X_297iWvJ#n^&s80gfI!b8x_VjkbYXyYm0aRUZX8O0F9{lSHwMRf<-+YX%8 zx7%DpnKZ9x?utv(CJ$?#VN-v{2%WJkT%T3F#<*@-BZdxN{$}prW3!%ov3X+qf^HVI ziH0cATCC5$kdP;ms4UjkctWhN^Mt64uWaMdKM;QbSL6}=3x2~`79?R9PLk>F8U;u- z;|h=^&fpVWlOcjd8qlLy6{*B8R`x}F;ZrPSOXFsV>Q$Da7Oh{->Zvzl+GI$FF+Td3 z%OlIj3fRzCabCCzo-GzJdLY_Wog2Oo%;4Q4SAizyiZ3*L0Y4AiupjjpOdo$t?}NGY z?-#W1^c?*GPv8g}?Ua4&##{Uy4uf|d2LoL8%f-Z1WglyJp{B>jF zGT7=EcEFf}?6BSu`Iy!biN%4?Pw|{BbelV`>yc>qO@xD?>7F7RVN#3;j3^=uoG4~V zaH6P27a=9wo^wLb6Dgm=AzFU6J&G+C4vBMQ?8OpgfJ+GCnc9A8NUHeUP^SD?l& zQmTYYTnc`qy1S;{|MSr!al#|sy2HWSM&2Kt9-_hY72zU0i9A47V>*xB8!dFQx2NXd z-p-JvM8vf=gDi~p_3}YHPD4Jzb{Vpa-6A3|ZG?#Ei0G(DEtqfR6egNKyNC283}i_q z(hNcxlWH-P#$;G_^ZxDQn;17qqZ}Xpe(HBak6N|s+eXf+U90by8S2q5@egQ%F2GxY zEe9AIg?1Xn0(h<$h#GP;$YP*X2st3QrGm+}~SK);_jXLT@kdwVZs_kV9)Y) z(zI3(@Y5;Is0lOp-g#jWPY_r$+m4kVcxiGS0RTeQAe#~@Y@6CsDD!r zmkVll!~L@H8a`@w4Ij0;_CCJz_tow?9@-zkga3i|%g2T9#(|HMe!RaLuPZb3aq|&+ zYcvg_>105pQ^a4yJqc~_BIr+|EiYnx$^nK`_}@-CovVnm_+UDR^T7k)due7}*^cdPN!7jJt7|EvF9`;LXud2pniN?O1r@MDO5(dc>f?L;ozC#QUd4MzL?8x$R7yjd}NZ>zD z>`n2#B=BN`Gpv^S-F43+H)Zcrl=~W z|3(Bmr?wbA|C_hefxn-+XXwiU)Zf*Yba{fYi7`x*PMNL&7tlk)#d#9Laft#hXMhXQ zCs1f*Z>~|uNIXgx=Ml`o%U~i3as4Js?&jx5^zjSyLl6a5DtSApB-x}iXl`5tvY!?& zDth?NpCXVm4&AlOr2Yjqb3Cgd2>hae-x-eIpC0l1U!fJH*U}LZL*DvkzMA(pw0iV! za4}bm8x~h>v8uAX{=0F*qABUPNGlzu8xdj58#g+BuR3OnF=oZ?c!0m=8CFU*(`Gz( zxIYJW^OOk5X0%n{iKUifNI?=Y>I}EE8AEXVzri!vNi$^qYJf#cIdkaHyzBUfnvcqV z;L3NJzMgipx5J{z*H1*yMr1i!Qe|N{rk7MeD>=O5{^!f7$E;wEBCKojAN9&pgDqgg z2uG4z8jg@#u$$rg2*+kuUtX^OR<#^wpMtTxd=ubZe0foRn%9H!3cni;KfqaD;mg9y z%gW2keJyzT9$uc0ddhtqcsXpXz;iju%gR0NCpA6}BwF;1$rayu9KJ zgV!_C314BeCwMGPR8N1jTW&Mw@b!3kuw!$D&6>(-cdX%AVWXmY3J4)4taof?^UJ1S z5743O5efihfeHX=FAan0Pr(M+KvFRxAf9n?5UH9da7H#>l@KTfU_G<#zWC-R_?j(N z1^LaK`#|s`_JQlG)vZ12mvO@!n@6^46!HDT3DXG|=BYrI9h`c$EUjcnU!^(L#ge7%Mn)k$p=4%*(z*(69+ z(PlJ=Cy_E%PEqL4w4dVcr{$6;N?NS#qoUjD{8Ua0+PxdSLWvd_6xe*^?|9!r z1&Sw)0IU=hnUog3P-h}$qy!nlx4Ve+5FF@FgN4Y@MxKn0E^AujWQs_rMU-;_kND{OK8;I*h0ID?x!;D&7u?1C?1Ute43X77r7E;2UtA_CZoa-o2j zSBlY42tlbBWd+fwcpNH*O}@c^P?A_%a)oY8K+NGpYizY>1WLAm(zRJ_FK4b^gc3t+ zN80#PUhXifGtOg0PKpMN(yjiY`1G!at6tbKbHmIpH>|z8TvE%Vts_RwTRUaZqLn+h z&3Iym!u+JC?*~tO|H-G{4)u*XIQNOSCXV^%ocytq^9RqkFn{=vIb(C4e0Pl2*RklU zAI8BT2VkKTxeawQ`WO!DMN4}#IJr|`kV1@u0?N}k$OT{-y5&2mW z!dbY9_bNe5OVj#cv^Hu)fix(LhHSC&&`{#NH`Ff=$T6nx4nOsJqWW9dOU&oF_gKSY zFQ}iqRr;s=*$Z1g4&KDV-Z}Pj+0vQoZp?i{J@DI)>VY@K%-ttm0Y<&mj!Hamk0)&~ z1d&TZ1HdLC4GKkpDun#PzHlzr27xnA>Y@}ND`SDut%f;1$;S7f>Bu+ej00w~rLi=y zP6!JL4du8}%&p$c-;lR?z}W4*N4`FN4SUIg7y`NEw_rIy$e17TgoToUhxGA!jnV0ofd1s5KQ(!O zu&4FMjy@PmF1n)!Nfu;-Bpc=;A(VoR2z86wU(hYgh`|`n0xqiJ1@z2p3ALGEk4ZEb zWORWdnSi~}w-D-^Es4jY3#D$SD>ade?6-rjt9PGSdT*!dCucbX_SUNDZ;b4{eN4{g zTqWn3-^;fLfep`(nSceN8S0A47U__tUZ;lvza?RC!4UQJxR6l&T z&h?tBzTDMgMD!YxKV?4|+H*OBa|y^FZ!w*Z2g*$ws9d|l!@OnS33!;K4;5NzRUM=T1I#0Zzmeo#@Hl@_~ z^DfZ_wscp2OP@)?hh@KN^eg+78@NQe6TrtL08$1KxB_6k!bVP@cq99^Df+s&{%g;@f9ydWD9E{_7*@W8+r z8mvyho>C3O8;ogO^izl%#ADvAu45tVmn~h>p{u!eh_yrF3+Feg!BcMUm%cBJSi5G; zT5;;Y_LB6u$@|>fjukI_GX-P=4~|ryRW=$LWB(T+AY%hASt`i9$go3RA}Hvzf{4fl zgT9uc6I_Ms$Drc?MKfLtz|wCvkqw$r;4KJ@2DJJcSqRe!ZI#EU<`P7i3u7WSrJEOu zK_x#iVZoxgOUnfHS?LAGTZYENZ+-UcX{0#tlNT2b8#5QUF<~#};+L2=3Bqul-jNvk zSSVZ~riHim1(BJZ^bS$5`hc!vT@(f*eWXt92)!H~>F0c?jYPKH2cpjwVzb1Xe5#T3 z)Ac7#=X7qG*8W7-Y{~qwG&1!cvyQyYd7Y! zA;=krlpSoau-7XrXdC-Xouxh?gT@)A6s~=Fz@l18ku9RyTJ`Iz4Zl_ws^4~19~!3= z&u;q-i`mlnpWioaNaM6f9VEYt{#X$4+nZ3Q7<10-$e}=$>-HpyFh9%1QzZI>B1{@x zL8y3`{kqK@WD8WFqao}fF*~wjfVDJLCq#Z%{eAU<)eF=I%%|P9KFjYutqxLNoj<)t z3B1r6CsZH%3A9Mic@XC7P2g2iXd<+>w@fr)&rvM^X%WQ?#7+Z~!)`u`ZgGL0kfeiw zUar`!PAySLYf!66ohAvkaEe%2Q>;nq3DXz-?eoJ5w{4g9 zNA>8Q(bIfIe(%H++iEvCHhtUWapNv+opG#b?X8neyeD5V_v+fCN8~s2=RP@ScHxtS z=qBi&1sPfk{fwa~bdhA+f=UAsNh%EyAB4`yB-tb9V+p|Fk%)9A$R3ScAwrB8!vkjV z&QWMn5-e8z{0QqS5uSaPl{+lSHngB%l%zglGm4fR_-@+kM=_&+>bIuvwodDZOzJo9 z)c6g5ZQk~_`gJ|^Tm4SqFzAX~F@Ft$)m{x72!5!A`H2OKtK&dki)Rn(k(Dtk{*#BP zTh;CAN1`7K7X#!uC5tHZBi4yG0UN5Vvo>0nBN%MW==(H`@p$EgP>s$ZgUqm5AsQa8 z<>4U|=(;>FE=#9q=>kRy`ennQg!C|jXr|%OMrYpG@rQ@25AW=`J7*7T`BU5%#fwIa znKfTh&L(a6X!eaVVH;C+H~*fE{3ia(6!oThXVQ*?^CmCcjV5q*NB1^>R}e7JGBXJX zK1k6OwVl&wEYGw)Q9c=M@nzkDvHVAdTdDxe}qeq)x7I6Qjv;n4x& zy%L7B-rc)rW^^YyL4Q#?fk#q=6}qNjjYGytgto_ug(O~xkqb?uQW>m+PRWXMUKw%r z#6s|oQ_x^7C@>)IHC<+nvcuw36@qqNnC=9JApumj-5)ed5mFM85>srn14}hG6d;zu zkb0Fb&+$pg>0H-OYgk7l<(l&&(h+T9-aqeRjSJOR&fHn@!qUDn-?1P3S zu4EDQ7xx`7y0&z!m<2yQN*x_?=h)L{$HYW^YKfUMw%3q`a2@TJ(74ajeM+m7&cXec z;E!bB{!1dxz~P52k41dJc;PvHrSZlf;wm!2?_#CVz94R}lO7RV^FjbbF`JL9P{5q4 zP1hp{uzJL}0HE{zbSQ`&V#_GI6=caKsl#VyK8e99Fce8TJd6p|qQm0D;{*MX2f-j9 zaICgdLgGvt?X*Ku`BbH?2hRY&6$7xg_^*O_nZbT)88XiVcbPk6!KZU(etLev(j|-L zFI^UF&q;Y%&U>?ZZkt7F+3`12^{FeLJoC)?5BBc;(8<%?L64e38rcAlJ3 zg0K1FT7W4g0BarpT&Y`9jT#8eKxcH8WG<$|wBJT;1dX9#e28gzr5M=h7~XgT<3chN z!t=|gQ&$ffxwCJd-J=Rtrmc!>RxPnrw-&O}u;BUS%l8dwB1uiVw@t3rjQuM;%o>Zi zAvN6DB4)CQQ7sf5}Ia#8P=wLBSAP{LpXmGsYbnzV6Xx zc5Cya4I|&0+k3|Ft=-gWnOh+#AulGYOXW$xF$OWX`o0>&z!Vu8JA$2XcA!W&u#`D| zoMX6IgRAj$>{Y=!Tn_4sDa|{h!B$NSlhPXTo`isZ z!bmtal723I$o>&JzVVI^rhl_{?{_oC{Bu@taD&;Clb&LA#^f#@Kdfy;jR6xIs!K10 zX4RR;{GJbf!Le%TAG?AVeYzw_sx^K>P025K(6f1`Hw906F4=p)2Hwv;m~VB^&oF4x zZS8g_$k3v(TtV+tuy83z4+0|-En8YQ3-oCdju2zvvEi^C1p52HazMd1_35CCjdW{T zAa*L)iid<63>MxUV~7~C?u*td8?Ej`UJ9$J64z2^(k63gABUN#a986A_}B2`)DLKOU=z)3-*r$zYS zet#5%g_MES7Z)3x8*tqDN7rc3_^KC+l)`k-EU%tX{pwwd-{#6T0+&dgi=c{&MQ6 zi$31xWqEH&$`{YDmNui3mRO@5uzq5NH^#NtazMl4~U7jS)-F-l_7L4RCKt5dB@!V9l9Z#DMFDE3tI{;YqqHd(Bn zykYd=ks}X}E@?NQhu0;O@yy#&x8PBS>tteq>(;es{c|OyI0Gh%9e4Q(|MnL(Ku+CLxg} z^2txLJ}psWDlX*YFm1JhLP4EMhPRDH(bg}q@3OnABqey$#J;nmeoZNU>k*qPaT=f?G0np8S*jm%Tl@uf{GkSboQ-2&3DQ~2mT!Xy~)~hZaIPlwK5#| zVGQ`8NX`R&8VK3;tZ?u{L=dcDSn60DEJn6?E7H#?WE%sELsXLQ5f~YZ7Gnw-#b9V4 zQze=7U`S#@{kk<%!a_qV<^ar0kc{ihnsQ9s9mY4^74|Yx$&6t}?5Qltn%LnAnOJYa z#U=0TU4FHzXxujUd6wr`DZQhPDtvQjy_M5eboq3!fAgK$_D<`Dw;!qY?XYU>ye*@e zGOKmiQ>WNmpX+a^9esVK9-lNOZ`|5(EjqIhpSl_K5*sy*2L)h{1?>)_&#}T(yAKi( zu|N}c>$Fix2Ky(%1_+f$DdZM!c`hj~bY6iTlhQ*nh|Ajes&FzM$raZ4Y!NcoLKy>T zhfJ~NX%kNj#58KS8rHOJf^Mi?y|Z}rsPpU9@zPnx3YNWg@3!sJpV)3<0mjw8t1~8^ zSvdCX*}lH)@TnW#>Y`I?MvR|1I&c0vIM+enhNTfV+-lNAnQXx%Q&QTMFaKI+Zs z3$usyYBaPBwozk0-TKMHbC;eN{^I8>RSlN&o>hxt_KX=kzh_iTX6zd$ZIIYGCGYvPm?j4)mG5JOL&X7UF1>)`R5|EZpS;-kgyT#vsK zJaj` z>?n#pN`Qh;4x?EmIo(dldG+$$cPku$7%!mxtAlME%&>~phU zygA|MG4&U*ZtmuOnY}g@LKuglOqc@w#jLc$T+7!-AF~VVjsYBDFcxCl zfMa${2ofDeqcWI;r9z`$2@C*$gzOmM0z?KWOHJwrjzrLrhDphFuxUkCFyIukyqcnK zl#(PxY>)^Sa@V_)N|3&sfjj>TM! zp^S1+9{5zHfMyUcPS;d!iO(b4W%!oi}Fg z>^|Yf!A0k$NF~b1L4$|cY(odnSBliLv0Fc%H)qqM^&^iz*=ySHtzGAI-!hajxIeh^ zO*IWC7=$4{h+ia#Jdq;;W^rN%+XvpNCRB^iak83;yj3;%kYK38$eVd?)~@cAm3ZHz zZf*9lkugB2+vZ2>hQBqh_w?agGrH9nHMFCbQxZFD_i z#wue5{|FSbQPA{wXHct(V~>2HTlTB*L5Xzmk)Bq5?vX?~B9=`22ufN@oX{j2eq!RE z&-X5X9qj(4^ItF8qCTNcKl$yj8gCyy)%nzdJ-s{aJNepk2bK=F@P~T7{n^HIwhb?6 zPEEV$wMnGc(s-9W;TWxt_h@~*andi(z?$MqSrNIlc0Mb^|2z}JsvOpvHG`YkOX_>-EB(|`IZv&{E;}wdir6P=ebi6mm|XTf z>=QpgtA_t7`3(dm#f64Yt`^vF8RELbs1;SU5cWLUkrTKtYRQ41Wo!_cBXF=mR#I+K zl znK&w=T8pSbjTXGoaBgHukl7aTk@^FBLAI@IkmBcWIPV*fHK^^%dZjA{*EbtZ`MJ1O!D)_9NK7#Y8hv7FS|CpNnI$wIf(FxmFtuux3)=+K0)1mF>poQQJ@o&bYRxcDxF%z=FGl@4Q@e!OL% z{jbtny+5w`sqOo|nh2pZ=0LMD$Kl#-BO}|_&mEFDPR=V96*wGkzXUBbE&8A-G`642y@wnIA~w=sb+8(4=T5 zNoyRe_rW?tcTf3aP{AKlb`Py{ko8vIyq3q}GwoeQAqCNhuB|g|x&M;K9#pTtmiOwq z{{Q+{|8=kCy~b<@uS`8PrN@$9i*}zlv2#hUB|WB`no7LOnRVi)rR?FS1=lu0?cgA)^nz zNnh_>`0;c$v0Hw@wmvC+c8)9@aq;Jk>a!_Zi`Nf73_g>DE$S5Rk6^*h)+VIe{j70F zJpx-5TqwwTQU|huZt?Jw2JU*q0}66q7FZ--i3ky4eYSv<=~!XOaA4pz? zavKW6nFdrPB7qeG5ChUbB0ap{#3%+6qA_K5uds&3GFfTaMBY{`%xRlxq~?VlnB&!9 zQ>Y=NvR0ZH4yACdNChUFhLlubdIgfZ>I0+pK$qS)M#7pcV9nMgR$itzGnp9W zav?3s$Hy=jehei16ovEIK$*Ht7abb^&Aa?9A0Ojjs9D&vR(hYz9*vyuqb)S*!%Vob zqDffTKOX|9fX&n#=<9<7IiNhZ29X^I6ND!& z;gT8S(t^xSw0We&IShlu=XnY9WAbOOR__$ABsJ-t``N3>o#N!=^j_IDrnQ{0xY3I* zie|O6q21P9X{Y`<Ww$ESd%lj{O1%3iZ7Jk(hj`mue}UnJ#RhlXonLcAr>2JJl13uDHT zEjIFyG1A>D=K)4iTB3e}K|N#N{Mz7v^t_`aI(~ZVw=d*=^xUM+mNTO?q5rV_VS_qm zu}}TjqHEXA23wi*-l5U^2Y1{s#oyjGw@a5C+%3c$ONPm9A#@}^oKB?L>-k|6Xx~6G zqQdK|fDaB+X&nxnx+&JSc$#4>;N$Q|}Z@n=8({F#a&E$%mF zOh2(-E<32MySRVvXVO<{GxbEjj$O%DM{~D6inz&(_gb@ygknN9D zGzb{j8ThFN_OFAyz#6pW)mHNw91M(84rIi{F8_j5?GlM!tK83c7Mqm`XN>D&SR zbb-W7iojBt7;g=+_-pB_p)(0_EY{m;7tr=i)(Z2gW)C0-1sk+eOe5WDK&Q8&anG@5 zpT*$&wd?x+&8S}jhUE5|(6!GAWPm~!MCB^NY(S~R@411<)hG2dMJ<9Hzh+`raS^||H|T-vlcI&J#!(} z>WO7P8BNfAZLm4E7FKJkmL(=qG)m2y)~+QRj6OJ`H_%CB)l!C1-47xbTmP&~6AUYw zdwG7Q7gh$L09$bVaLwihfjQH!9E?NZEV5OL#KdHq1^*{_(`?qarpY0?qX&$=x^@VO z%hi=2Y`*n{lAA0Qno2M%n6S$zGny{8E=^FF84~ zcv{M^?2HlBs*UJ8f0R6DWMP-#v9ZH5`VUJH8wNkGu5H<5$RvA*HD%8SzsQ7@Et^s% zw5BarmI*Hg4|*oIQ!DmfiwuRbTW;mTeazCu>^`n zrqeVYbkS%^rDEk$UE7W$aoScVm4AQ>+bAYHOK*#UD;1^eqO&r{bTg# zoE|yZ1H@OCeK6{)^Bd1as;{vxrj0I`HFYfPGPDP8jkpa4`8$laW-mR8Iphajw;_CO zVDJ#g%LQ zT)lcw{IYZw?eO+FV(}_u7~J!v^U6`d7d~Q7*!{iWs4ohkW`7()knx<9D5O$^wIv_X zyCu@K;kt&1K}OuBG#dLE!97v@34n0GH=@eZY^)Xv#Op92DeB zeq|O*D*ngKBK#jER{YJvI*eIAzTH3fZJ#!C$G(5Meo>C9ud=S{8?2M#HI}FD5xbOb zqHpSP*1_=x%U5@cov3e2u%d&vpu<{(EW0;$Xc9DVobzkFibQfny63~y0qsN*@>#d# zhSLcW_<%C_IDz;h+G?8<;APIY+Ey59(^55S18H_fSn=3p_1^O@1bliRscW1eF@1UT zwXfv3!#iJqUgk9(`x=b<Ra*VS#0Q}N6(n6yVl$+zEJ~5gZ#5i`OhkHVfbKTf%TvP!~Yl*cZkunj*vxV8obD zeDAOXwO8}EHjX(mYV^@D2?^@W&s+3^Z%zMfInU9nk@!tXy?r}I9wO%&qZC^F8T@MS zF9XM6{}1kqnJ^3EcLs7Rl_JrT?!*e&}#1Qd`J?+)3op1Ps_@mKH%_v?m_nZuL-6OFl~d>0D~| zmYkMwau=~)3-V;lHzTk_j0@~8$&(Q7lF*6ilrcM#JJRw+t~?{W0VXvv_ga&!MoTJ= za>;;dW7Bamvq1g2ySlvV@;?Kkk@_SxLe4AM^ZW1Yc!N>rrcA$_!{slnZ~f7xkB|%% z1FY%My6hwP(3yyCUDg*bEMaUFJI!RZRBg)5${FmHl06WvwNN4W2z4vh@MkruJJL*^ zcs#2CbwtL7iFQk962}4I=5RAD*D#A(;L(Hq9QNZj_+_M%HP}XGVPb{lY{iM#dS-L| zYHzSrsv<_WO*(P?-NZK0k^x3--+q@1@~`w`_kqLRK6fWizcNG(V|NQaojB&(UTPRx z0!|Q5(k)J7_(al>>y}+CoD@I=Fh;?Mp3>Df^pm!iW;RRRCS6c>NGmQ~DupGE#%hY1 zA?34W+=m9ft+>r1XujuseuIdk0EDw&xW{AOE7{mLkcdG$`wN|1Y4&Pbw#|cEVp1+NNg8 z(zF!Z!r^ga7)Z~aJgl57Zl#<=9nYb|1$ZaPYw8uy$7`za4L`%cN+}N4%2B}MSPDP$ zvy9|2Z$$lI?8whJ%AoM(WjqES=sy{*5UruhSYX@m3iN@WJ28c}+y~++K389$-)V+5 zyIzFtr(UG_Fk)#54u*chPdgaa7K;_BqLGZ)nohqgVz?MH4CcS+VJvvH`jhDRewg|* zlN{d;QSYo$j+Q)?f1|!&|Hm;r0l#f+^)?IuFxP%M&_F!l^0t*(f zb0rPQ4=NxXR@8#{g80Q26}Uqy9*!5eeQrMNbMS)XPf!G21VduZWkaq>g9)@(_UnlW z@j>y5Uli=GP#MyZmYGaMx}Q)Q$=&{S(+W~P?VS)C)hBskfi=5PZE@LWmM&ss=^NQT zZ!2DNmTsyK10EArp&QMN0hr7K?LiTsQzZ0akWC20FTyk&m`2dlfjUPHP8`d*TyL69 zCq`iqbnpkqRXiPrG%7rS|6HQYg8vMD2v?)Ipofrb;F6XL336`7|G0-Jm?#PHIurZ#WK@!Ny}>;v5st0eaU6LGjL zigC17S?MMS9wGb4 zHgNt77{Tb%K{&$aIBxE`lpA~|?ZacOPGt<$DW~dnzUW>jFe@P0Bl|nwkuTDBHl2T` zcxy`#yWb#m=HGjxEsFhapxEzd1NV*)M-6#VdmLUpUvH>*C{gF`wDBV`nnsw7U8x=CkahTPNR} z-|g(w^&c!^Ps_nqe_F6;(So+0``(&VhW|~1K^pTgV~l+uBFO=QDJU9gCj8{Ct zTw>cs{I-{uf!sCX$X&xi@FLdZ{G&0H;8-rZU`Oa-P>?C!8suXj6^tI~=}?H@j1}P* zK=72A6HKw7p%#1V%>JeeE(NaDZ?L!nGcWFsShM~$+BV=W+Up}&BOg#` zShs>OQSv|mQwh&*Vt!%<7!(OOfkV8XFBDt0Eu7d}iV`;6xSE;iw&PZ_R8AYi8 z6BsZd3^xKYI6D(Fz?&9JvJgWP9fgLGV5dx$V3QF552ycN3oTh@Ot2ZF119B52U#PC zWtuGO|Ak6h+C;^yjfZCcU)t}>o96vzPSbMsH}7WG6;|;Xkk1jB+|M9q|YellzFkeU!970)9Ng7ZkxCv+@LXq^T1m{sTsH=%TTn$WRYm^{u4P{j>#Uf=Im1^@@KEwy?Oi2)$`^rg9C)$vE%P)?;q0M zQ{H*@;l&T8CO)us-KlX?sYJ#Kq=+m_8ulWv*PYyX@PqsNIW_w4b(BcZU!>Ns3o z$MJJe3%-4n<8)wRO#TO9td4Iz8FcW>1Z}91VrJu65A3x;`bLfC&rXJ4_G#d9o`X{` z827Ou{Q3l~n&bF*!tuc2``EeWtGb^{GbNm&aa4i!5Z>oCKZy2-;D2zPa01m}P~G_> zJip`VH{nsnv{m}Mv{mkRg=kN!TWK6}1&zE`%Gd!2nHp4ls|)qWnj zut(9Np)Alff3IsG8(1-+Ti1yd+8JaoCWk&jDO0`!cI;i$17RHGCkMx3xEC)&c1U1L z8JGyPgw88SqoSyzVePW0@NPxAxej4q=KXxV4dgcLWq?Kol#pCKI0;1fhJJj(&=Yzx zLF4xLLG9<0_pta!4>ESbto>?!aLL^lK0LMPp)eS!u1Jm-*Bxb97ca7`V>900H+$*# z7e4*EX@=`4tE+3`aPz190bmPzDNUoi(ek$hbL!vSIa&dW(lp8|tX~J;c97oLtWkT< zbuN?5ZSLbfcf2sR{!Y1u@>cUauHdhP*LC;?A6CQr`ib}Ty`bwvF$Q@lzy7m621c;s-6C zwue5OH*w-TKCbW7WaxbC!kc>Lvkbx8Xn^u|8Hgx&E4IwnM>N3BA{qcQMx%yHDz=;@;TKYEaNW;A-$gK*mk5ZgTr`)VlG7ff25%@V`; zG+VGWh-hOAqvj5V@-S+8+^9Pu${^pZ?KEwfJbZD`732IjH}3s%ZNO>G#iR#<)?eDO z?(N0KD*AVLB0YPT7Vu0>Mf_c+ygSOHx;g~ac`H@=3ZZ}9v zmnPXBj7?pvU1g`3H@nw0Dz;llaK5d=8q3Ce7j*mTtAYY=Z7*r7M1S9`q%N6$msXK{ zOMDMBj#xpKhgov-e*a#1`8ylnm z&SOA{&^ktC@RDTfLwt-IE|Y176lL5zRY*V>6pMcMC4Tfh8mr z5iMv7w`L}8ZT$OBYp=^gwU-}x^Gegy`2QqLT+B8b@6=A7zW8zgb81r1EAO8^y>g5; ziS4RgcUm0Fdb)W?!vTyd8j=!p`_N*L=dR>M_Hkm=j7FVNv%;1HZ-0jVvB6dg9*D-s zLTEKZh~Fiz83#qQ>wKCVbnO^T7IB9oS=&XBC+^eU#8_Wq>#j6Sv0qM{xPwH583bVcuTRt0~R`-yupQfA0~h=9hjWVgyihxtjvrw1kTuFBVhXq3h?*! zQiLRyPuhOgJZQM*@_!D9n=)0zA$;bMiN!c_H#v-rUEO03aK z@?_xjA8`TvmhcR}PH}UCc@2R6`gLaG*TFB5J`{5QOuFtBLHCRxMTWM-7@5OaJZ#noR&?Q{wdCRFiUjww?tG6fmRik|2 zp?B(!q}fD!ex0``dWZJ-m$WxLpE>A90Ca)8es~+UpED13_{M<1L8%}h7-3*gAW^vR zFrL&Vtm7-{T!&UNEfr+%I1 zT&L@L&UNF~m-Op2*KB^B)*N%CDeG&XJc_(H*W_HsTHJ#MjP{V~7yJqDXZ>T|4}m~L z1RNj;#QWKGV}-%OCb3}cH5N6~;)saIvCd`T+AGWpVqJgjtM$0nAqz2=-?CzMc@?|# zWZu-QtZBJVYSF7S!{?64nVFLvpR>ytW3_fj9)SG{r>JRgr8?gSVO?IP5G{~}F&?(h z&Q<;4LYUQL4^j;gUE-iggcViaB~MH-Dc{A*S6}#S#XpX%duOrtm4I1w3wG{U^tkH_ zHYAp1es&L&cW^rS%w2cC$k&NZ&B06=i1Y{)tOp`(4@q%7qAD)h}g8yhXc-84$zoBWKMnVQX2L>p8Jld;OJHwM^6z)rz%e zDs~NFPr4R5&uRnKu`c4lPqiKxFV>XH8Ibon>2cej^*nAHUV0*Bv{J}5FN>sK{S;&q zmltLZ1_w=K14Vc`8N7(ci;cGf?hcLg0=T|@U{ofy1 z{d~CgYuJ6rE_RM(pLsxgEo8&rx2)O*=Uk?-plz#;eY@Zx?bJVi*6w&h<=$0{+ zPuWY?)xUDj1Lx#5!e3~!;<`3;HV|(is@{Y2GXWgN>hP4>I82eFsHmq-# zv~@>fH-sky2iwD6L;m;C(y+p}$Ij5EmhLPq+u2{NyLuFR!_PS2y(7VUa1b2(!Fv-^ zCXs#FL5wI8)&M^Eu7rjJ_#ra1BO)I39dSn;aDPPXh@BF?=?F^f`h@0;{WWA!-H7?! z)~y{q-~3xFlOH=u7%J@PJ2OX2tv@m0;5!qCWgdUbgO~v8go{99FrEaVPf<@W*A#C+ zt~%h&kbna|6EH&PdJ>F|Y^#JhF}f&7X|dK$2~i1QW~5p$&?vq5C_QIVZjC1-K>?l) zvZT{zPK-TB^f4yI{%T%OyKZf_rjd0E&A-NK&Zit@WsaNy16pwDW5+XxO?>CzgcJ2s zM`YglG<&WrC#Q`5Fo)JP<#PxQ!W@7>V5ZXN0G^ZP&~}Bdn?vhL>vM>``AWB&!yl~r z8P6PUvij^POc8T%z+QoToVC)&z|}XzLFpU^WnPPepapm1p!L!q*BNo3>kP7^3GZqL z-gO!II|uSuB!BW}Kr|4^chFAz1L8_RDv4?2S>@9S>QWg>3_y*icp(@GxW}zV1`o+3 z{{t7a1H*}@Za^vFu3CQtO%9yF`m(3Au3!LjkiYFs*Sk1Tl5iA$2uI<&*%91Mrf{~% z*a2ZWk-+4n6{n!1&QL;l!@-?Yp9X_ikB!M8xKiuE5dp$hci`Rtr%3$gRv3{wqm zJ2emcRr$EHDTq&Zw1cCjqTA-ohLBMCQDaHQ;tw}%`)C2MZ zc6)ACYCfALC4Oo)Hf}#Zv+2DJ%wPLu*4pLsCq>@&+4_hF-~Qkk?Ijsn_g>}wdX_~` zJ%rI<9yQQ6JP-H|LF5DQ41`gLRM;m45v$9LUcf8xiU(ZC>EO?3vj{Z<2+UBlm=n#3 zakiM~juCh~BqTOA$OjY{{_#jP0>VW42Afrs;vKeZMR(AJpAx(P^oc^6Ri9tji+%Ib z{F5muCl@^Voh%hEW-Agb<3^U(vvAfhux6YkL9RV_-&5LG+J`e68)vc*7XHRV=gy5k zTYc)uU0c5UZp*GGPmMS`j^@JiCn@WIGh>C9bxTjM$y*edEg}%ph=l1>f;+CRgD|(b z1D65`Cqa?nki)Nw`V+0!tKIIp;nWRZ0giIz280gEV7on<4H6$b_epV=N(V@802ol4 zq8OYhoM~!491uCYJU-LzuUF9s!)`l z^Y*GgT*tb&)&UNVYH{*Wteq9u0XCzKkOct;xUq)(2*7*6(Cp6oiDs*o2I<6 zW5UVaosKVCde3mJX84q}l*uF4+>$;;i!00uOK0oY;w0!4?qSM~_5V5&x#i1MCB1g; ziijv#BQ{m691uBT*N7)KMwYE4WwB7&{JTW4p5f%@>NbV*I2Z~WO6Oi<+_VGK%3yYa zlP1!Kfe%FPR${Q?fW0X|1p;eMCVdBoWk!IqSj;lCH}1MLefk%t=-a$TBfMGG7}Dxr zdw<)1_FMP=d+YmKZh5xX%wjG}{7uQ?`n{ppQG@XcdL-EZu~Kpfzdp--J*kC1()ENZ z+}9`Q*HIg(g14vIORDk8zwrT`!u3(D*IR2Tsoxyt?+5?!v)Y~a3m%WgPq{;}wgg9@L-EJ0{s0z7n#lyeB495R;n0afVDtgy~-WK9sv20#2th{e>w+*=EN z?1_hBqold20poS|1OD+F^eYK9;sR;B`Ud#+2*JkuOHX@)X2I3F)p*1Y)si++Re zL4nHGw_9{wyT}{1yZ(Ka8@9XteW_^IsbzeSZNb_ggu+8d7wLZJaO^u7^e5Mhdd%M*fNyvad^gRAbItsgwQj%h<67?YL@ z)RBFO%rtEB1C5g&nACWBQhk-Sv!;ek9$GhgsJLMA#XHyB`QG^P@8RR4Ne^t>&e)y} z?7Xyd{ra6cJU|v}XY;{t=>pkp$OZ&E-t(T^vH((U&*9hY`gOW5Pv!82=L~J0gLDD7 z!hS<0CYv=@3BtAh+dy{Nc=}Dx#eeQmgbNqQ+_ojS+@zf4H)$??n-fz(DS9m|qt*R>(|xys|8f&0p6ny)a}GaeQ4Bl?Zyzp+~EfZ9Po4N1IEHEwh37Up2xAJea+zj))e z-_g5xMkLaNjJ={CKB+&nQ{KHvJG;9bRf9{_pOfQSpHq)t^PE9C&)-k)wP0SPzgDI5 zSLipiOv?AvUOJC)(i{7^-v~Py?nBP=nx@~!b-I6sK8@StllpJ<6}`Rsw5Pps^`ExK z^VFW+he~#Q=3XCo=B>`UZv2;8#-E7sSMl**`VWmS1B;u^`@5vSPu`@zPhQF2hx=ar zuDeg;$9?Kwh2D!+UfsvrL+<6Z4OH=S{@X3bi7M4IM}L$rY&zgZ6^C4<-)PTkJF8UN z83=O;{CKR&*TNsgB_kOCcoWhVAQguld8OTP$y_PGU1xQ*09i07O)4@=gBy!q$^rtm zZCbs%=#D41-Ws6&60q*K`_3`*ZQHaTpS}0@jqKA6TjyWcy!jKx_O09c)#|&om(Oo{ zPkZ^Um0w_7_i1~SO7Ocj0UnxGaEWjq;jtPrghzE50$MQ<=!D!k-7rKqXOAdwOw1;1Lg z12$}b@<`#HH6u1&F7ip?iF9{Si4_q{$$JM3-b$dDMvbXNZqfX zsw(&ZBN7k;(}E^J-k~TDAB>6zQo{u}lK2_KQfPl#a=6I*&xMz7nlpc6|FCm$>pwnt=;ICSqt11Git7^U?wvaIUJe&c+ITS) zUIfU>au#N`j4ol0AiIMFv8FfPILyMd?_6&vr(e5W`|0vQ?H{0*`-BzBBqag%om8Q( z@KjMopWeNSx)-VefqA(ODC$)|-{hn&@R$exgUl4Zl57DZ9~ptvj1bX%q42{xWni6> z;6Uvs2l^q>1#U2~X+T#4`P9f@{e>-Oj6d`B4Hz8+*sAu$LL$>h0516j_)hRVh^CN@ zhF$kOlHTxFpdwOK-{PLo-FMB;$xcs8O-bw=7Ymp_u;L93BWst{R*zn{ zwze8yM%J!n_4UJQR<5iWQM-85@S2q?Mh+jf__{0XAN9jVty(pT8dcY>Sv{&6Y!;pC zTU;MX4>s>d055!n$=(m{8vm{as0ec*-}7`Hl8t3Dn`9ToC*Eg$A7Ul%J@2dis(r)G zX@x8zirzCw3znvdNV7w5AOQ{-God7&ok`QQbFR}*Kl*?;NmN{ywW-xqKWdEhi{5{s zd{AAe21Eaz^&s49C84DC7;w(1)|0(O0LMuD8}(LM{g-$vKMV1(HmeN17O!Lw8m5Ns z*Y-d5jCRMyIfJgU)Fbz@yx)rDgF}Z89a=khQJ+4G1_QU95N+&RsR5x?pMt5$f`tS5 z-NY>JrAN4r{HecXDe$Mpef-VW4j7P|TUM6q{?zL81`No9+DiJA zUnzwx2+ZUOZMm2rBOV#M+D{J|4}p>#Y9x}@u!p24=Xu^xWu@gZ_LVc}xXA>ZJwHYE z@seZ{JrdO{~ctN4oL0#Cq z5%NHMkhB1M_POMvd-TJM$Qai*3!zq^HFfB!dd1?fgxL3+HccxIl($jA0h+Eq-v$ zt1Uw0U2qVM1X)Qu$UX!b85+qrU}F)%L!wwqdS!}<17uKI%hnN4{Y7oZ{S?V=w7EM z58A!?*51WUQq;+e(cLNvvO3?NHMm@hh zf7);*rp+Sd#7ZMs60GOr8nvUp{i2mh@#r^#c;u*e$EKV@-7)^ zQH7eK5S>P$0*FqXNRk3|;`R5SouKYPkw`t^&Z35$MFLaMoa^q&RR7UiCoFmq&KnaD zd6)Cd_WR$scl#O5d3yVOuiwA@^c8mI?3Vj~`R9FG&c1$n>;1p~`}Ee+7%Jbh7}VxF z1A8A`Fes-Uh47o2ky35XTIN%r&Mh+;tFHu%J`)TXX+Sff2myfPr zmDpeV?w2h-Qm{ENG}JFxdX0VQQnrmuudA)COB``j{6*`OudTFan9Na~LQR?2*HxIr zlS(1R1o$xp^PG}KeOp;T3suDM;RJ(xHspsdDTX-7W{Ptt{0}8t4N}>8*15m-;a|^u ztzGQPl3vp;3}6Y5-}f!+GC)eu_T01V9_?wi86RxY$rX38Vr|l0OZc9gkeb*7#D6Ov zr4XFW)hgKg&G%wK+%Y^HX=ZW{93I2t71l*T@9h1F|9PtlE_7~sUfTRG=$QHdK2Zs> zGs*hyb4Q9Mo?Vn{`ncOfD#`i?-*fx9>gN;c9l>*#@)}#LLBTPqSH~_6q;Wv*Ut);y zZ%Z(frIck(pW&-5XN&wN&P8R&^t-;8KK;@u?e*7IO?h_g#`m}Ux+`Y)ubVNa3C**V z2QfzrX{N#bGYLu>!Vfn?c9e+{-Wtel&n$|nyOHU68qqs0WqL1@!;~Gwxd`*5iU$8P_?^#@XkV z6rMR`?sEhw?yyF#uj5zZ3wM$}8@n@}9w{GkSS0JDJPWX6kR~&d$J&UtQ{2Pw1VhB^D?Jh}lY5Dp2 z>;tod!cJrEnjqrWiKD{^F8{q_7x$O z8_j_*rJL^rb^+swW|%`zNXr}~_>>V7D(<+$&;RJF%<>TGrS@b`q6f^xJ%KT!nfg!-mco%>6j^iq9o>f88Y4)nNcDJ;UnlzjduQ`Q zY}3h;KmN$)GT-%)xUu<>|H*!!S|;s>#CpHFd8UtX#-^8CAF)rgZxRz(gl5C~R3oab z68xUm zX5Yg1+D^PNdz`H7z?_e`>t;U=PJmbf`4P?%fVK>jhq5T;Yf<%qA1Qw4i?dljc_uuS zL6cms>O7O{RX5MXg#B8zw7Ge4>w3bh1NbJeV4w|*>9B#Su^!k^TD-EB?%e&Q_TdTb z;>w*njgU?vjF=$K#Ws13lnq@;8+r!%h0TWx87FK=e@)%!oaasG8PPII>mX&jYQ*EN z8l^M5dB{VD3D>~@r79pR1xAd4d&caA_$|-2A>9JxDT6fs)nzYjnql;r$w9!zA`=s} zuj#=i*F|w_^OJ4PV;s7t^C)h0{Y?zlo=Hk#-CY+Sp8N2MMlbJi*FMwsEGp(ER*;mW zJu8O0F0LHs?bW#A;kj6sGS^RHdGlYvrAG>R99mM)Gfsy@`4+Hp)x?o<_X6m9$@2-8 z&&Z%i-Rp_iP7X1o1n-sxqd2~ zSX4Bzpn(1@Y${4gE-Fe+DZ*9(KF$ljh&5s?ILz+_hf{I$)QS!txc|ERqx2g51K|yq zM(taE8?V}E4JM#Y^C;AzHVZj?M!;j>xFFL?{oyMlK*j=g!%^S~<6$xb^{ccZLJ}2x z^aG%TaSkJ%bklY&RgvOHeEi7D`d(F~IdNG>SB`NE9h@2G*zP;+wl0ZTNrtKWx+G=c zt!t1QJr4RNMHonZm!9?o{s{w8z6JrIDWM-&Wv{_M{07p~Vkz`+KM%OTaBo9CliPok z=P=Zj`lG(EZ8LDcoiL^MB>>l5bK?emF&urUmuCLJZkOkLb*Bb}Ev@Ss1X9H{KXJ|6 zaEA%gLBmBZyNPvtN)_mjp22aw=Ee>BGa-gH)4b-)kBHXV`Zp+FZ`v1)eLAKmBIy-A zs4qd}ePKOUUw7k1eNndJpfx|7)sj#CO~bpGuvjaU`ZYh$N;7EB!a0d(-y6;gbrz;m zkG9?MJ2#>k3eW|j-Gf*f8}pzmyZrolZ4)E&8v4CWOP134dRFMLqSGo`u<0~0K^%q; zQK-W=f%?T-G9vKT+_}LlfvK>jQo3u*S?%@1Z0pa|-#Wyy9~4dkpNygY9)!k`OQAH~ zDDW|oh;2l}89cj;1cV4N4V_EWc}HS&u$w3xc>QgC<{;O|OiK~sm-E)A>8CD2=uG*L&tIq2ow4p!t!JeJAHsB;N_0L9AA(dz9ZDEOICW2IscUcD zXys8v9GbXH^8wJW!zV9YBAq@HW@7DjLhq^w$<$|&l`gKqn&N!&)h0PjWJDI*9Y4~y zTC&BR+Hcx-%9$$z<%<`td0!HLpM_q<*U5eQ>ZpT?8@vuDOx)@EgoV-TK9D~`lQ!cs z29D5?`6_^(#8J| z-YZUhU%UnHog*(5x2lK0o2X}z(+E7J-2vSy6sr)5f0(yt=bYVpX7AoLcelJ^?(W@9 zdw1b?6N#1rYyOHAh-0KQ=)2u}jI<`8#X%g?!_!FB$4K$T31bxRlmLev;m+~m&EktRe ziVwxbkVX&0W*IgL;yz>rz!#bL5g(3c5T_82)I}>xE_^Iv^5pkz8I_ zKA=x!!|OBFzp{Vap&EHZe&5N%hm6;nCrA8c?dd1V){Vrg02q|(Vk2@ocYxH=tEec# z8?h25)CT!QvC{u-vfLC3Y!m*fE0)usa^$8V zQo<@IrjGOvlvGsVEP)7_POKf^!;D5QaO>$6sdUAE@mx*&=ZaEVx?THPvr>et8Hs&^f+%k(*iKZ&jYlbBuJLu3Ar2#dCGzOw|0!#o=Qmwkh;#}U zH@*H_fTsC3)HcpztZAZ@PB5Ax|EOk7AgQnj-;zZ@1a5=s&JED+xQk&5d;sH7iH57J+$YB)?ivWT zNj(GpiG0Du&u%R|QMcsHg$v(YGWtaKb%Q4Lozh@VOka_JHN z71y2rzGdLRTj);^owv((YWvkM;JX+voFR<;U_AI%((QHuz$6eSElM+S?8rTqRJkh5 zk?>*!?ylxxDj>p;RpI(Yc_upR?SVG_^Z^1!dN^CqyaWtbw8jR+Qzo z#_}qhoN?!v4%?NPnVo|W7oFQha%OUkw{yfqUbwE`!pich#;;sl&MK>JTQO) zZS*bAbd<$)^Ob*yOdMHOIm%K|DEA*XuHlO=-8+SUlo6e01u%=w1M*SrfciP`R7atN zQ?)`QVi(~uLiK^%ZYJ&-Lq!EBB+DenP|y%Fa&3>HIDbS+X~g7r-^s{M%aV^CoNiivaL@ewyrS+^wqC5t zCpoV`5MAZ+8P^rV1023G`4|&$A^`AG@80tjQ^?3E2hyT<*G&y8qfW2;ou}YKvjl3@DTB zI<#opwna-eZCX;4&2oym!+hkx^cVUrI&}L&-}$#M7}49e&&ZK|eEUG5 zVHX|3p%`j=kg?L!X@JUbU28x*2;@Oxz8fG$iNc`Bq7Ia(Myy5y>>ooCB)Uns1X*W- zf~_WtN2FpzQL}-dRXqWXO;hq3hfdhVhLv>OvsnJQ-{kphpmt_*Hd}>y7>vWrR;*8? z&_v_WEl75pA{_adFpt56Qqv34QVSEaq|M?w`RE<90%sjtP;JQ_T@YAQ z+r>Hr94GdBhkRVyXLylgul@RrC?#2dH|+kVU_@2Jpu?+Bx4ilf#kU7?wU2RY3`)qIeS+bbG!AAjw;P{WXs17H~B2tpUa}1-{%%D==EZc znqnV76zDu)>WsDpa}E*;_=(COASj&&=@&(M}iq$<05Sw7R81^9{a zoG#M#kmo2>zeD&a=c*fZm$uQc(?YT<2f&)GrdSIZTzS9Lt)4xVG7$kkA{db8Btm*g zT*!2;%$txqBs^kh;jjsN*x*E3CtCZwHd|Fe+FM0yAhiuLf3-jK%_lR8vc+?8?vA-kU#~`6Vma4nXx5&1YsDW zHYzfj$z-z|Y$nN7GqUE?u~R3< z)Sou>I*(QZ=6B4o`1uq~; z8xd(M?YMifZ$_10#M15lIX|)!g}s@+P6qkTW?zN!-`3DRJ?IP5gU3P~sQ^4NmFZw^ zzy?XL8$_t6&pL zvkwyYvXv8R^RgNzEZdP1Z%bCD#3ofVjLFWPSrwZU3&MQ$pYqY>BJ~US&SePs!rwVe z1){2*k{&C1!4@V8UYO3f1Jy zu>FA?fTyxEyMHTU)U!nC%u<$zS>jtu9EcvRq%uO5NUw%ss}Ar~IH;;NtZKeBw6+us z)S^o8Pb(Xz74#mnaEZ3he_mqW@UqBTwA~e%Ii(4`eZBX+#nK#Unex$|j--CXQ^iyg zPnDkwmSuh?YgK#^lfYPY?qrz-&ZQ8*BVGLlds2Zti9tr2JmDDM6Cc`>TuC%|lR28! zwas?G`+&9s7>8E2(ddiB2w)ZI6M@sr2MbN)B(2So{#TD+F|An6oUHWJ&UQmqi|JG{Vm!J!4!eSC{Yfbr=);#OM9s2D-K`U&`W z7uK*7Ap3EB1?`;x(KuCJo)zp&e21(6ph0_iFcLZTNQfOmqJFPx%F0v^l;g!b?0lmB zfCQNQ(wLXl z*2>(vlCIY_AN%fIZ#8T{Zq@izi-@t`fyHcCzPB8p7+2t<%wZE;?{~21ti29~;~Jjm z>t^f0)656Yc*<}NdiGe4j{vG%GaG0tjD(Ck+qB4xZk`_SDpXQkYD%ukF%soACYu3i zTsS`;79X!yl-1cSF!`=dX((=6y0pAS-CM^Qg&L)9Dj0@wCh>80f@2|NbVP;_eXUS71R$w9ZJw~BJ5NUhVIBW zxC6eDBu*RYR#in(;pYz{A^c|B`WqpM4qT*=aSoUOE-vaa?B1U=MzM%U-~>8}6>QLMkRwG?54gf(%2s1fCi zd$cYgBOs=vpj)2wQBv~gp0jKPN9Xx0I@BlM_4lUPtfXVaXE`JK`t(8F66Zp|=3#>u zG#OmCT+}a|$qFL)D85s~Ttv*pBR(LaOjaq~XNwqtd2`(ur3q>g4Jb`e>m1y&r#lBr z7z8fD`D8djx{5CmMM zyLTI2bbe2LJHNy@7okdes}3Ef=>~QQG;Xg$C!<7=wn&?>TS;0V4(94Pye}K?`wH*# z6;e3nwRs^KE1$K_%;6A2H~@o6X76BbVsIO(QC|(!Ic*X#-zI~c=k3rQousN9aY;7Y=8F+6a`q+v-!Uc=a zm#=I$aIaL4n#&mIZVgxfN_BfMg)QxMdodhnSC@~OZOPmH3YKxAZva1390JHVfG zFE-bzx;;#ovZ6NMZty(-o$9%X@hNGs6O|QjiG%A0k4g_7klfj~o1ekAr+?@E3lc3c z@z|g980&QPW6%<}-2?k0_!}XMkcvpeNJ+IoawQQz0WLT3Hu6j67==3w@?0$#4fh2C z*X4@rn^fCc2ZW61$VC6@BlP@6eX0UkX-X zpN>(jK#Xzd726Nh9lUa3CUnC9oOyYYXQ_dz=L~}0E)I<`15aa!@=I>oy2!3Kl$YVP zf7BAB-P;=6*%FM}yKd==!WeY|8Hy#RbTpyvg1f}U6Z&y|$I^-i%~?2Z@|qo9LkFaE zA3t^7gn7$1v*LuoO205$Kv3zxzV+ivdpkNr`GpQB9WZiUuOtfw3w%(F^&fAz068a( zLrNUUiO8x*%a8Sj)z~8-V)>a^8EXq{S$<03O_DO#_L^Ov?4C2i92e#t5N%C^7q0m!7a8$m^V>d z1E`j1OWh`87j+EpMG6s24+T6=)zBs!;or+YyC8nn_b9MpG~yx{_kOl8p>K?TBs zp&+3$ICM#DdkNH$nnsfZiEt87N0?DCs%rX#YEnk3GcYo|T#KsfW&WUnM6a)_FUl6!TQUqzAT!SYgzD4VeOFp@0p7+udiMAfv>LPinQ67?z)Rc`xx%u_|y?a;b>#|Jx8np2!^s$|V z!F(4=kV{KJZgXC%9=d+)@EXuS(0T#NYOuOIr2`~V&c(5MY!o@t+T$QGb?Oin7~pFp z)ocrS0> zWyXzlq;&3OI6AI2rz$+<*2%L?A%7R&9XK(|bvV$RpV~9~mT~rM2Z=v|*X8rtIkro= zkLyx93l5==P$kq0w+MIhxgCyT9ix@#j>*3T8rZ_o36^%HI2;ki_4D)VW#s%h!${Q^4#OUm`#rWuyJ9jr6qq(@!WI2rEN=B zzuB`J#?GF}l5?|@#bI-1jTsC7@08r^q^pBwu{rf)=$0cp*>}#YvHJI%Bzf0tHhXOS z?CGgFIjL9vGLzvAcqkRkRP!8$SInA)_hqFxzov!_vu31bJ5scBRg))IB@}j-|5er4 zSe4MN;Oa+%rc4=R?_MNb(64m6da-iqL~4ARxclYr6G7Pi`H%rWR+JxFW%_8WU%j|hJI}KSdsPbedU(E ztjjp@_FX++9>-2BXz0DsRmYMVv`59V;*G`y&JnE6U%L+}wAmo-@TX(__Z44_>iNo8 ze`z@D*He4H4s8N)(GjRql-!ORK%s<;Kq>18Ygd3gQC8{5mNuN? zw{HS}bf{@`&yH)KN9jsfAp>P3P9h+c;DVHGv1fkgI)7G7W@nX{B|lH0Gsv7hmGI_L zVU;4$mYz!o|tAGF7av(!>Y~Z?AdAfrtUct za%ZgAP>`Cx>A`u?%Av&YkeJ4)@qsyMUBNA*PgjG|K^v`31b*tkA;2Gk4}ynqZ*DL% zxa~6b>`X(L=6lz(Qi0Op`Sk~;>CdjjvrGB25&YQz3=@FG9}a1G7!sX5Q(Jnfs+;tz z^6B$^rX4`PSAWG^b1~O2p^!hDsWX${t4hE?;yuHFM#!_!%}-(xSUE$vAfp!|`B4f& z@c z2&U9)Sob{nc(YyoLa+&6>M%jZf^3L5wEWA+)T|g(%75wJ2n-M=2ZI1{NA>bjtKmfF zRS%7t>P1Qm;$`x$eVFfHb=wDFGpOdTG3UW8XrHAs-d?l*pzYd?kwC?}%;q2h^~ zy#ag=+{Q2)n-wvCK#)+Ux^rQ2a51|pJn5*AYCP$37fdp=lEj=k-)aoF^_CGE*+wxv zAvaUK{ji#qla|CbvQ=YmS?@P-w|eozF-s|#rMLRoduT=VnoR^q`bK~F?DRCpM2@g<4e2t zEGP6MUlLF8bqNycb?79fDv}&auUj7q-jo1AG5i)54Hhi&JtZ9^?25F8C`FAX)kT4@ z5Fswqy_5zd`M7>5<7`raB3NDKIYFe8G)Ly|G z`Tj~q_ZTO&8{_qBNMqC&(c)P|1&as*j4?t})qWMjc)1lm#@3ajBwN?7B=@5C0N-7F zoH_tvA>HE?u-DrS3&HPNg`qUgqEcc70NLd4BN}0SkcCMwK^RmoN(ANY&GDi)Qiyu1 z-j!xEGO@ri7!%bA`t0B!xFQ(65YuW!qkI1)GL92YV0z(}m!;b!l2t?3ulDN5WU zjjQf9yx5Xw*d;Y;kGRjgx*;VcBW~)F)Rf`V7HdP@2!OBipO4=_<2MLi-YAVJc&n;+ zwSY-r{HnKF8H(|PO^=KSH^ckme=vTj{RzL}_-DC~{WZgP;{b{IqYV3Q18qI|?YQm0 zIwMBR0Z~heCzHf_gAA=4Vrj^Ar>)~oP@osG9P*8)Ljz$~=afTK@>BDCml6)o`AyrJ zS5c9dS6L|*xW6dxAktW<$aPdyIC3jIpUuslaiQSzH*`9LN%FT+mcaoSi4l@+0wuJ{ zuwSXFp&B0swcgjuM^X)HrPV@foDgqGvL9&arl9Pr^ZqjyF=F&WKD?OiBP)}L)Foa4!gzZBY9Of4WZ7`&*Hjx7@d)RjNY%k3d(_;(W^Hju&JenHq ztp15!gr%~R-G{gi)HUNL8@f&EoLKyNz!rL@x*pUc#e3@LqZMjcXkm4AVfX54*;&=C zYgJX(ZdG`sT)r$JzYq|Dg}?KPy*q1w12A6tvQ16&e8Hu;ty&^oG7=h3`@=HR$)W9dk(k_ zpl8h7mnU^5{|=>f_8yxrOuxWUCu(jRcBHmn-`XQXZ`zdjn zdM7`*f9|97e-#@tx^!Vl$->h93;W~$nSJ|a;!i%+dv;&lFR<_I-mCdFTnD&e?qdOu z&th+UgkqiI1cIZWNCO5JL1=5Z^y7A!K*}_F1WL~K*Q+12Sleu%BZsqJp`ivg?s%zx zr@ec}k7mdzd~4+9K8-ne^BJ~H{7w28QfCy02NP7L0#C>~7h{5EO7tu)RR25{FRCSi|IK%4J*BUjS1E7&`M4x(w84&=l8dYreQ%A5Hz{v) zd+3p(imp@FPs9Sft<{P>VH*n;+?)^v1jG>AFTi!Ng;#^C5%IEe13B-=@I0_k6EKX+ zZrTPB{CFZ5?mR)U7LPlR$&+E*=EyV~a!5(^_M(i$#EjwAsq(q$i?rIAovgNwpCu2I zj*hIv_)4`3F&LOR*n?rk&v(YIl|EJjFP~A#g&eYXi&moS6{l^o7P2q zcn(Ha$M@@^-YN_`u7z=?^gH7n(s^*?b%1 z_-kUOFopkxI40MdKe8j5;p>x{9(RL^fVXM?P_yBUI)Lw6PZQkbc-2a=ETV%sM3(yV z6Mmy$F@?L@Aqp-uD1fjlWw32S%eW1gl(jf*q!Ndv7-o^MP*wAaN)5@KkrQo+&pgJu zP3)OmV#}MJ9Gi2Pt&;!Y<9$oP6kkWGcS%#fnBbX(BXUxFr|kg@UHx5Nru|@eS_lR2 znj-Y)D=rUsZBx3qn*;#S{M7#mAT5>~$iX5qm%9Dv$QC7m%;wR8P#*H)& zU|Vx;mPADBe{|K@9)n7AFyevXg-jxqmB=JAsJQna^au&=?o>HNiTFA&ni$*3p9Le$|Hf8YOS);opC3FRxfL7$W99vN4^mD$Dk^i99Y3ypo?BX)3jpUZ;e5mOvvx=Gi{Me* zu}iE??2;>MJlq*ptr@p^<+wGjUneYIHF3?V2`g8R2i?GWKLvlo4-oTfFy=Zr%Y$pr z!MJIYj$Ja)y=qMFgjdk=pNQTUp~e9alY-p&__`zmyj02nkiei z;(97i=V$cmm(ibiH2D^`MgLIyzL8yzy5zu}OPi;PZ{0g zk;l7_PT8EhXFKL7IsLSb&0X+*J=>C7uB15kV6wzgE(GWmP-(OgmMxThh0i2qf0O8@ zC$Um%5QM(jx*A$HS@DgJ^Q094LPzQexAn@ZI{n#-y6o!csOs#7pWVWm*cO&qX$Rxo}ev(M` zHfPh8@RRH7nTh4HEM^!!aC+cY|Ff&+X36quuMMMN=c1@l(FF2w@ za3;;!rO5NK&XgB6fuDgt%Dv~=)t3Bw?rdh_i_h8CU)ZzfgY|LGraj8y-g%eB{#BlD z9oD1AFzb*5W5>cGfxeu7N449zphI55V(RNb@CTd>k$B`W5n(;r3Q2Xa=`%7B5vlT+ zh=4xY$V=`f9uv`xZhA~aEfb*pF!oGE?DOuIS9U6mm)>RRuJ;ek+W$Vs87JiLy*H_e z0?!>GJLyy0q<<0{gy95!$5K8v*@^w-xg_`()KS&1NbWD-YadWLh(8#{0&-gN z6mdfzcK&~s*Mani;t#IpUs>_hW6F#7-M5(qX#d300?%R0PU`|{`7cW)0WF0LT{P<#~sR#t*rR0YZr^jlupK!>A$ z|9yF-Wx4poVoO(7Vy=^KGFO~oGD9htF4)~am@C>)L-L46vXh(46&?>T&|KH%59exO z4&6ql(}y!N-0P!;9Tql|i0t`ba@QtVaAn5_0@fn(r6M^0(!-rTa%JV*ah z{oH=)Iud;ph8ehP z5G<(-JQG^V8&M8NJK8I1-b)rlfRDo@1K4p`QiCyIF+EQrzEW?qv3}_3E^; zLuA*)sF)xhZ*OnEhz{Z5KHgqIJ|n#gl4Fnz4+Ibj+OSR?VxYQHQ8p_;AO9Z2EmWxR zT?VfMO#yNSg(-24FzxpdT9x*%5vSGk-M{YIJ%(liS>{d6iM?%+^9b>T@u~j5<&R*J zB@CkKuP)YcAUil3~r*n+rZgfqgsH$sRsHDs=2TjA^yyp#PO#>_4 zd~U%4diSA2+M7sf!<=Tk|K$Jm`%M-Kv$5d)=1r`0be;1J?VrmRw&{SwM1=f?5DNJr zpv7+hN0#hD6u=__QNhcm0aw@{?k?jACp20333NxVWLrXA^SkV+J@Cl0J0uh0|pko_=x;QkHTZr+43VaC+AA}pwvV83AEV8`wQ1aFNSz` z+7nU^AytM)X=qZ+hB(EZ9hWWzzU*prHNGhMD?j}+tmM7-N;>?5-nUuy(}pN-L;sb< z-`6=1uW{?YZkXWk8U>i{jpgx+Bn72wSUUySB<1bNV~UrhnG%NQmHPYKW{T$XI0@Xe zuz52mt4EH&Y9Y7^Se3jR$gJoFW_)X(ib641z?@o4t^?^TaOjZ??Ux}lk7|EA&Tz<_ zJ2n62?ak-lztfA)Cl~$`f}aRUIXnyjLwc+^c7GXyONn-ITX0J`9?&*xoYjVepzdTn znFfv#i9gr*Hr*6wcO@Pfo!BcPzNo<3G23^sS9N`E-H4PfmFd$8e~AdT#Mlz;gO3r<(ssHM=1^`8dCJPEEsOm4)iCC3Gk|eJCZ2~QAhwr!N#DsahosT5EyUI&ha?c z(PYUL)a-E%g;S{JpT}a8dM_GX(Z8~TpDi>$A!^`+F(oB~LjrB`cRga#rOB+JrhMFh zA*nI>wiq^(jjbG5TUneF$M?NaUZOo?SRh!1o_v2C(b(-6oDZ=qFaVlw;IC^%d{A5N zCJ@yzJQM+?R%Z1G3^3TW*jxNXu7%bGZ8}Y~U#`X;bNZiXT6d=3oQ-`ld)!((tViMC zevWSThz@;}?J47{W^TD-$BcvH3xj8y`>dQbZgk)7{qjxKLD21E-wsI6Y7{4&ApDia z`Y`NF5||-)c9SwRNzcA86DlxJuq6olWXg1G1HcOKgtMqyiW=|*(ad^~aq@M~$O>C> z(}#*$Gd#3(@<$I~e~rO$*5JgTP=ik=U329wF=-FY&O!(Yc~j?*@=$kjA-_)oZHhX6 zM~=!IRU;Ra1Wy=ugYe_Y@`*6TmXh6LFiVIw^fK)m-#!+(bTZbA{KAiGI}Ca(@*W-9 zc`Pz59O`&cEHVxr++qXTTxl1JOsKhSEHX*h6l5&cLybxz_BFA{xJ|4U7iaZ$I41~T zDhdgLGe>wR#Ug_Q1jJFasoSX=9`3XXm_C#+c7p?o3C_?Uw%xgLPtMRO^X5*j&owT~ z&&bN}A8nD(NM`K|$NnWgO^1tfr;Of!3eP{Fc=8Xp>)c(Nf51Y=Pfu9OM+y%lzFV&K3zo2PYVZ6J=_Qd< z2d~<(&G)VJ?DP!z=-zo<9X$&w?tM~JBQVvFjMySI z4%~ID5n=y61|Vy2ky1D~90PP;h$$B2Wh82Y=UE1C3ehkO=}xFz69pI`=`BQW)bD~a z!yuNMkeeyp)WOseZOt{cHZx&y+Hwp&D2=PqNj(#m-TIvpcxB{hetip4R3*40>)S0= zRd%zG$P!kNff`YsFS|{V>cz0s;(jpCC->8uSxRh3aB2xFv4n*t^}noLw9s5dXCLW% znt@o~hNh{TkOtkM)55gr_EijG4uO}F{n;SOkO z0b3KMgRDM$?bT3cpQSywEMBr@>*ADzMek5bhU^~QbC8!I<(0CzdSZr!2YsJq>BEbC zd)M#~MU3xW=_&0m>K9!4+ui28`oj)~+yM&Q>fq-?=M`6^Hdoxa1EMKG0FE6GS%e@6 zN7zQX1nv-MjVwb};5=mXMVR6>%|P?0kt8BD@gL_6XgR4AixY;TXE>)oTXbe!=O;GJ zYiyS{AV>W|&l{j!lFZlU4R~C7l%Iu;p4fdTGlWoYK$RKC7VH54lna2sHQY^2tfwJX z#>K@UTc|s%usz%(x{Uk-9l8&?s|TA~6C7(+0;6J65UgM~DaJ7W*ktumhJFm}ajt0% z;|%gFQMOaSK67>jjI2Q1f?1fS?*Jvn2=Kwc04f0YGB^sCUvHI3`HbNj+c26fWH?dnDC4mMId z#2Q=|*x<+r?QZT&Df8Sody!Lx>O^J;g~C7dm7}mjV+M*k1F<1GInwh(!4Iq#8J{z7 z>-A@S$ zq$K3h`J<F$WBW^7_OdNr^OtX2Q63tqzF10oR8$0YIrQgTMM8WZ zJh%~83WNd2Cy0~vC=vnx63R+L6%pfOW1`w7qc?h3Rd_bJoqIsUdD$nO^#hGGwV8f9 zozXVRTC;fb=EX%hIYmV|j;U$(xb(Dmdz$v26njEaQbIyk^9$rqIE`k9*gs%$ckG`P)AT|-kfI{l2BrwLJD(>>&@EYRY^{yJx7;M( zO_49^HQ3;e5Tl29B=6Tf0GYrFMvK9jK#>e?$mYU5~)u0^Z#$HTzsVY z#Q&Q<`jO{s8$Z~&>-`P(=h8_Z{U(chOe=@7zx%M*p$Er~IY@np&M23&Ii&gVwl-d@ zFL(h|6vG;V(1_%6>7#m)FP-3{8W2(ghx7)VJTLX8HeUS*al)b-=ZLaOH@xb6;`ZfZ za)u7cj?F&C*3|bLR7ytPHrG})^sJ(5+Gk!>3vAYeIG-VNtk%xj6+`6$tF4R8IC!?z znuv8BFCSPu|i*0vBJHs;#FkS6?Qj2237|ZO!)cf>;q?M5iw;zu9z## z54?c02gMo;h5!RXPCTiAS#}(SnuK|>bYBf;r?g?>Uw+jtJ$9s1$CHn0pSmt?9y4as zBh&9^uWLUdPR68h8v|^l7n}18A7D=ti|lYbCM%m;-GI~SPC!gX7ScK(uTD6k-nuXc z1va!XxrMoEeb3i?_F2t4#)tn8d1nJxRk1euXJ+laK_x}S#6m?yB}GL=#g7yf6%`c~ z6^#td4^&h#EJ`y}G%_+vGE6cnGAk-FOEXS~%8KKm@{|>)I43JAPgz-6X~O3IXYIWa z&B}A```-8d?$zI)S!+I?d1lsHvuB=}HLKCv$^ZCg@;i+jAN-iTZP_*Vt^4W6b=%XI z-nZsQW6OTpb-O<1U%@=gpZH11Fm<8#sSHnD)DLeo^Zen?-ujsH6V?y1cQ*0=jGXw`Q!lFZqTQvA;#$8JmXr^|oyq<`>!+i@mGIh<>(BgO?7?CZJ9Ax9$S> z4{Tb}`+awzmFs?l4x(zz`q2vJAt>}C|J}yo6vv>xS{WY8O z2PMmRKBpHPY*tGKUmDEY=k?c28WRA+>GQ9bY~H8g z;otB0!HVbE3&Nr}D5gIP_~|>ct0!ywvDP_c9(`)hrB5~=2WB;Ya0{$!XRpyVofc!O z;`ij7Rs3dRFqgI1t=pKj`}2}6pEk06wEx|#-G6z_r{ot}lMfkN4qk3?IP4GqT>4v~$(CsxE^g6~uCHg6 zIiFAuY8ZqunXT{}G6c1k4%0*b&0AC*TbKRz&wu`D)vs>TIXiavyHBw>Q_Wi6P3m(^ zJFObKuCOZXcK>@Wu-)!k_1b-J_&RG@5y`-SE1eD~zqgRIy5vbw{m$GvMO9{2SN zPygiJTHB%a4!K15W>X7(u;{dS?oje~Iz3DIo!p^L#aGE#G{v$hKUeFnPS4(9p3MjP zn&sqXjBO8kPXDxMMDIZ{i`C_q_a3oi?bZEfv~6=m|Jkdri5fB_s&~wgs0Fuo?bxyF z?RMQQXT5z3S1*2HMtQ#X-i&hlKr(m2Z7+cU``R{z$l5?!N8s ze>bA&6PB@V?mc_m+(OTqx%TEtGWWpNnOJx*8JW$$yl)H4#_VHn=GnoHM1Ljgw_{-j zGQ++W%^SCB(#pJ>#Y`DrPxEKnX!8*H?g(~bt=G8MDr%F_VH5YmXip#a)M(%RAouZnb@cR6?dR(|p06A1=j*HL#9u#Oyt8mhy-NH> zGT5`&=3={n_&48IFc-Z;y>}HB7LIJvhIbWG_|D#`n=airazP*JVyAmr?HqZVXDK|U zqZzZCg+SPlxx(w1$HIVVdbqP}`(+e+cp$Z-*?Y-6xqUp=F?Vjo!&}=7ZyVIH+0Yqp zyFY*YIhX&74n1NjTDxC#Pm>k4e7?kP2GXpqGV)EY{LC#yKbI3;KxyPp&yJZ?2Uo$| z5sZcHOw8xCt$QDSUnLE1*0Fip;qGaBALGk6pHCXC9WOG0WM9|*HQ&2O)$Ye$6&BOZ z>__4q&XCzzn^lJOvdiJL$Ju?o-=6PN)4!-sKr8S~h}_uXOq9>veBSx?2wtXaR!6IL^y_3W)`pEK*&t52W0%iBJfb?kOp zd75o~j@5RhedV{ybHA{>z3zTF{j95N?R75JHo5#b_KwS4zHzxe{hafI+8KTu?Dn5p zwcn1TD|G?uml(@gW|vU-Pjx6*cV>CzUEzbVeLDF-(B7JRD}0Ai137CPi*MkT${!B)`O*g zOkd`3`Iv-L^R6FD$c%NAWd&*G#a9tV3x~H&qHo*?R^E}t)8TY-s#j(h~HqX>9@}#d_yhf|?gyWFMm5^aGF?^urlX3zXdKOH}0_?Y;iG2_g_4fk96qUbSW`}G^mtca#v zJIc2ON6`Na5_V+wbaBmYq*%5^Wzh-BW~S9*?$6<{r_3GJMALb#-);5tbz4;jtRVG% zGt@ZW+iz<5fXR~wFw%25A9=*z{grCrKYUD7pD|~ zH=}TKyP9cu+qCJM)MmR7KXty>+S=V!_4;qT+NSou_L|YtS)*6@|J`dtxIjIB(^%mB zMfTZQ>vwBCI-b+D?ReLxuRCjU=grGC+&rvjuVKS_^&F<|v31+d7%SCpygizUkWn$Q zjIr$3UoAg&2(n+IK4+lyhcCtc)_|*i&!JttJL3FEzx7mXjyI_C4MKBVT=vy|0s?!Mc8zFjl* zTEBmCM>H{3J=@k|%+eUDEYJAb^9-N!0JA@hRo}p@THN`MH{8qO1`ZxMa`2#0u9-@^ z-Rh#q;juk>4v$6NRgQP;wX;pwODDzCj$oGZ*!?kt+0VgT+HqyKC3f$SsY7OV&%{Ap z&l{(nhlbu^AWuzT^FX%HJ@fLZ*%yl5;hF9s&x~cXt^e}rGiyG5!SPPQt-O6|UO-Jy zYdm9V)7gJVf6n;c=sClqXG;u%=A#e4R@3x!9T=EVvo6Z7v~14H$PE9_XlV9)|CNU3 zb@Tg^^QJy9b5xvpJ=XQu3svW8Xs*{)j`#JCeq+%uOm=$~o^-3z!rV) z@^>sGiLctsZqoMLmD$Rt{dwcsQO;b3e@`;DwYH`mYu_%kO~@s|Y;7DE)->!)xdYBq zZtPp;H~AbZ$V16@P2J9W!dKouWplrQSB(CZHN^3L!YzqIr||ypEeY!Odhev$&)5XV zKdcwIhW-*DD_Nb+j{`F>o-a=^jm>Z_i#bxsW+K|bMwjM0r3^$Y#{}$(rfyo88B~_0 zTlg|zYNko;yRr>Nl;25B`7dHUYe0j5=Df6RCN$ZU!Slkly>Ud{OWSvuyYC;K7q^Sb zy=%X@Hb(CW|99zataf#J|6@PKy5G=yh^=>!Jb6}qcc6-?*=1BGwZ6(z>rTGrVivua zsb{CdOs0BY3b3Pk>z?Py-UrT8^`7g(y9FkSGFQ)BpR?n{g!zJhFSqGjr3UTVH?yx$ z$eAnDvHozUuEZ)VFQ##u+itruNr#;&`L&m>9+J|FTg`jThOi)oci-fpv&tTBZ2XK( zy!V=)!}6QX>>uTFF(UT!vt~01ZTZ>zI-0wV{r^m<>P0c(SQi)i?!OC`NEt6~*Z_+@ z&!E{tq(SS3ttoIrmOGufCC~fh)s;NwtPLT&8;I0Z!H3-kldPh5`w)EDu!$V^^{MLH`@HtIru>F>vg7~B z{e+IK{fK__mlAZU)H{|a^^Fx|wKYf`bTH3;A>T9g>#$ml-rCYJz-?d8)o9>J>*rhP z%vCnsU6!EIo2}okW#ncSOd4yO@6#;3`}JKVmZ5>gsVNYlz zoovh7d2M%mKA?r=d*PwG?#vsQZFEc3qG|u$4I3VHxc=3vflddk=+TGOs zTI)098kXFYB|HQa>CyVd$3GFB>_zd|PaQUlV#J zi|n~;vuMq!ymQm7|}>1v!m%JjYA zO*^))TLa9#hxRbiEWTrDjQNb3w|{O8c-7fIHo0%?)uZ3P{`&a)SKYbW`Ca6&)hXMP z*1EGlZvXn``xftBz@#<(!o%Fd$@V?WcSp~252raYRU2#smhW8+W8D4Sci7Ahy{gS_ zSC~6d71??GuC0KwdcT$Xzw#uhnHGTTf zZm+8WH`}^O7i)&qfOio6uqg3$?*MuZ#-ikqb!M{O7+uY)qHI&=&?#npY61pC=2pZH z)4R)jW6pfBw{r)-e!Y3g#^vhr{qdT=_WY{*6&r)Ynp_lW&Cr=OIXB$!-N4nuhOIXB z+pP9AN2#k3_3M2%re$ZqtT=*9uFouAIOuR*weOn+qYov`1XH^9zgK0Y0;_v*)1 zF@?>yJoVky5G&xq(&dou?(45N>DKbWqTY@Xq-%-M0FQOt#P;F<(`1^(0p?43Ym3!J zy|;!@zKOEJU8-Bid;GSyHE*nAj%GVxkCmaF{V{saF5iB^)DU|{SSx17tL%sQ$bHOv zHD8jx7l*kQmfq|+VXd32W;F06Cw&&jw@Az%l$8x1n_KOywdUuU1X=DZqkAv+L>(pv z=$rFxMmptK4rzQ?^=q$d)a}NZlFTx*375%uGmX%&fy=g7nmrnuw`awm-TI-HpUbs> z%-|+{dkr3$!pEW=d)*TozwSSJV%&irN)FidZw%>CSH5jWc$@!-A?n7yg21URabRpV9BcY+P59I zIdZAndiQ9_LhI0i?#Ygsd=Zd18+b;>IcD-Cw2NtD9^&?<)~pmd;#Bx};&|sJD4+QX zqxrvqMqob!w3*eJR?g`MP1{#XtAkNee;UJsP(SjO^#!Q~k!~`x-s29fM*iBJJn&+GDQGjx_0{I~e^Nj&nq^!$O0n zc~`U6Gn=L)rgn=X$jWCGh?#}7Z#K!IG-gdAV|Ryl4;>aFFl;gN*DZxT+1MP13+eQ2 zjAI)_oB6Cu9aQF`?1KB&t}9sc@rU_8+X`Fua^r2Pn9Izhr)5@WB#$H5-t1OQQ{&IG)S@>HTYalbN%J3@Zyc4JJPI88wA=CY z^bsSb8;l^?!cy;OyB%d6g|QEWjx+OEDFo6U*z=T>rk&?TXy=SRJ(Ew$&Gt3|WBW16(d%}t)JJDzPCs2h-2Qt9}Y zb(7z0uU)TiOz%4TWBp}8eP#S_+Va>x&djd)Y(1F9lk;_T=j=zx`Fh{E+53_6 zTkLZoJ$o#2j*S}mXU=c6&$~IkP{UoVl&j(Gyrs{oF`k)U>}US$cestci;Kpuj78_( zd)Km*ga-$+lY`DZxA&O^Lj4#Fo8=;hS+i2_t!*WRj#Ij;J*WPA^YLaaoEc6pIaqxg zlXRWjADH|5g43G0{KDI+5Bidl_Hy>BYR+oYW-=zGq2~*#W`4|L6>3H^z;-a^VVTV+ zRAvb_`lfiAxwA8Vbjf)ijyJ!|HdYRgg~p5$*wW|B7FHvcZk;$xHHx3k9#&0~}#;P<^_Onbh3N)NfIANzuHAhXPGD))ktCKs7aMa|A- zp2xjk$9mPT1~0v1>_9a#IDTyJ_~7tnLppdiF3XDh*Q8sPUK!4(WX#rOs&)YPU{ihB zzgg#=Ykp3hM=#klW&J(tr)(INzA8PgUX_nan|eiN(W;Fv-8^;psNVIj_f&O)2e+|w zis`^AM#|a9d|m0Bg0gW|W7XJO&`y0i`q{5FP^l{N%G9o^S^vmnw86{LqP#^>d(5HxNoT~q^H!qx>b$o>Cx)fczSx2 zv-*B_bNBVNeF%n$2FlH~VZ^H6e}^cN5oU*0vkHO&`VVnN3IQ+`YbANQHerWsl9kLxMw{{4+Wb~AXal>v62?`xOsr#6b=!^Vb`ZjC5HR=zp ztFhy8U3*!H`nHl1la94fy06)v+Sj*l%1Qys zYAu^RJSD#45dTN4>-5&ho}LwyS7fX)dKWU+{G2Nn+u8Zn^O&EfI-6NxV&9z5UXHhJ zS#*EI$euUF-{h;WNf%yUp>}?9+I&@$K|k`PKRiS}y)w@>Gvlr} zb-3n=pvU|_#T#p+ox)D%SL$vi(jw#3;h(N0+)j7qPoo>0F)Gf%Xox;^um5q}a)qmb zO!d23Ci`VW8my7YuBYK8nS4gS+BeOytEpUb#t;23Funh!(yKnsk+S71u9l{*ozl0? z?=#ky|1nqDabA}#ew|5+dp=luAJlN1Y%w@0E|{EuBkpg>z0SyBugS@-c({_f-47qY z%TPi6eqDQ)3IA1Id(d-F?E#1F%3SJs{)OObCi5=@=g-vD@8C*7H^N<=J@NdiWsCnW z-s36gz6e&zWY#N8#(%Q^$8ZulL0`fGYVYzRo{{lKaZMcEkMb@yZtY%pL03p1?z`}l z3BxUfcfbw!OH)|q_3w;Z&iNeMZ?xiD%ETu40s zF39V|eOjN$bI$9B{Z}8Gyw1g&hab-(bBB}tlDUt0R{eQa{drdXc~)Hv5RJ|z&RM#9 z)B1<-j9y0l`-qZzUANLMaqc=u8s4U7AF=t)XyRN517xf73*t_cAZL_Z^>1^4v~k=Q zzsKEjg>$5OdCmgVq_ zPU7q1aI?PVe~u00?SKuAQ()ZsJc@3Hzk6NZ`T5-Ql)*Ka4ST*kfB71$6W%-pT>oHi zoELEa=a|BL&iht~1nF1#{rUhm8<%6(ySPut2Es45UE=t4p-n)4n@q3kJ3q&Dtd${- z&uuo~LT!!BXB>myYsODDIHw?Ungn^n@5BXJ=1o)RaXoQ$uq=lSjvnY1T>A(-4zEC& zmtx${O&r`j_y%4Dw-@8r5=w}Z=#`hr`Frrx8B9L4kC4xD{T*W=!mSi(VBpxuFqky& z8C@J3>r8$Y`IQ<={qL=Z0V|J*B-XzS5ePVzm2&L^>KAH=e4`-IzK0@emryR zs^QvQO8k$wf6p+<@!?tL^~3(_k4;|Z@{vrcr_TlF>G!QncU{A?xdfS}J@`~Mp4BdR z+K9S#%j(AUv#EU=H{77Vu<`oa;REm=Wp%4Ph`SU_*!3Q2zjfR}K8CrH^dFMw?8NU` z5Bi-glg_T_&;93lhB>yM^?%D<^+#z;9_Qk_AMJd9eXp+ah5w%G?1|j-@Ox?M!gfn% zM?GA7CE|~8+%CP&V!vGMcosQ8|Jrta=l_Z8oJHTmi=93XnYYM|7m9PZ+~L^C{q#D0 z5BitRg>s`kUb|H?{94loZB3uDKkiWas)lL6IK%%{_#EDVDrg4n>3bfjz4Z^{AdkH~ zQ=NAqt1EpUT<84~>5O13fi66UL9V|cZ6&cC7Wr8)jguJY%cepXNVrd#|^ z*?#l=qmWt6@6>5o?7W2hzapQv8ON3K8+gP2865BPOqu)bFSJjov=@f^y>6-`nq%h) zTwmDv+&-lJ_n*&y>zQ_n%=i2*F`l-6pZJ~j{7$Xqcj+K(ujlUN_$|Um;l2v|e$~do zEAW_e2Ib9^WHv_Ybaq?J@9rbidk2|r{Y2m4*U$f1ziSs7?&^-rclaGx&F@=2?tdfL z1*SUQ<9gi9Z$h4rS~ugiaM!EcU$wLq7t6%D>t*^FpFkOW$NfB%a?`fke8)3F9UDv> zXEV6R8{eei-ZAyWEa-H{NaXT-^Bmd!jz8mm3%IV=;b)E?B>hxm#^N?79r$HQC%;LA zJt|XOAK~619Uat@U#9Ih-E}*4cRO*v2A&be5!y7yk9J>rjkIBtqpPjeGQjDQh17A9 zbBRPdR>^SZXh}479_JRB$T)R?e@hu^;@ab}9kR{UQaaf-D4$*KZQ3QqmW{HwKA%gD zUn|+}61lCx5M;RJF2^Ue-#ABdY#1f;t=Te@{jygX?6xBj-9DEEd`oY#vyIGm6yUZ+ zCdYRC1X*T3<0jr=!ok^%=f0b~1Y6)5NQ7Hp32gJa=GYf+7RM&eW`ph|V_#4j_2(O zY*%;5PG^|xG_LC_*~!~h3I4lzAO0)m_@}dn(PZ4o*y^igKa7I|UKZmnwjPq(VX+_f zMb7KTIV+65%_UsZHI~1$r|m^)?69D-aApGy~g?{x`Mt(7U^}Yhj@VJ?^)dE;T=}} z81~32YcKIOK$1+f4&Zvv^$6JrV_+-HwH~3qcEKZ(|NlZ6)I;uct1IJ`NExX+%LE-H z!}L$sqg!AfZVeIChoLFYa4UYZE8#U6Y>s{BR(r{?E@rILK~}1xk^#MRLu}>^X%8C8 zGT8WkBoFo(a{VY1{JxPn;;an6pqd*1P0y+_z(C#zw=VV74?f zJPrFze39yp*$2+-1t)4UE;yKa^ymF=(-xXGP_y1!<0|%;;JFmq7CWvj(Zo3@TNUU~C@!0{5F299s(=*}N8|vG%>TFkDo0V;2 z^4XVsb#RVL8P}WngfsSP#`up>{>LQS*cI!_cAhc3vCY}x+cVuT#(^>M1}gW?h&(CC{#o?dEu=Dv7x^Zs(Z*L`V66#nP+$c z9XL1nnDln|IL3-k$sB{@Bh}i=rML#q`DeI5f8%BYeS_VG3ussD`2%tVcb}Va@hZmI9+I6gvfA|leG%rUv43oB z_#C#m(Tt^eu3g))O$?Exq)GK#B@Z!XxSROd_@y}3$W;92x;~NTu?t@3tY-g;N08yU z=QcPCxb|jD@u^&kn`p)vj#RGwXN>>NJuz9P*kgNR!|M;1Fuu=1UJT`G$9Tj%t0ui+ z4fCkJW8?G+1x@%kWteS0-AVn})K;Lcr>!`X8|C!L|k4Wu$#E z*WAo;@cY-6La5v6-`Uje>*p4VFtg*Gy^a|A};F?9v&z%N^^a3vMs}5;L!f{-!MNV}oO! zkn6F^CGsTq^jhJc<70`_k4Pqd_c}T-rhAET|8p{!Hp#YQVE^dF%Mo|$2eAX;Z|nxF z;p@Xa{uA|Zv+;9|q5T;vKUpb~X7guhL|LbrXIhUyPMln4>dIy27pnOEeOcx?I`d3{ zIkp-}f#sAN&||teHhC+yvsDv$w=`U~S+6qwCY)z4)1bFuf3VooHy_&#@T|<&yZ8;N z2Wf7CJVz(VvE}<=FE|$`_PWuvRp@ZD^%>7FwnggU2J4t4yQT{Zu&eI}K80Ar65r}O zVW;Q3db8*F^eMvHQjOu9-vv){-UioC*hvfjUm9{84Z{eZ4P3+1KXBe35{w?|FOuLx|BZI)d&Z#c zpcltzXfWeZ1HV-Z)jZ}i%~+N(D8E|_@60$<%#voqRbb@KA&lQJgPXkNZ(zo<#5w&1 zTuuI+Aq8H6Pw+blKXJ^v@23yqQWo>Cn(=SV<+uajP53js3RJz|XODxQ;QS(Z4gN)Z zCo-mc@t#+IN!*?AwAbbMG%ur`rcSE=3HcnG{7t>~;sn#M=nFfDLl0 z=fMKtdfV55nyRjXH(&%9oy>I_2u}$kzG}p^xhj>&1s>`L(>7TG= zEjLJ`>Ue2TJ(>Kwb8PB36uy_HHLcAxH+dQR1?j%yU5+_o)lhHl7o}NEe+jBdmB!qE zK{fN~S3E7Q(|qOi^mEjIZ}Ti7XFW0-!WbA!_%nn*BTcK{)Z?(pdHXH81RVi=w|m*I zA18bSwviD$seAyNjGzisnbH6c5*rEJ-%SGnHXd5(Gzhe z)(+6vDvV3L?-Bir+vq2O)%&T_XQ^{@FO}k+kmfZZ^ly9VzAXOk4n0^eKNj0`HoBt+ zdGSxDdpSys0EmP{$OP_RESzFhz)4#85Qu>!SP47e0Fc&6S|@4gC5V$cbZ!FDI!Q~< zOI)FVTvsL_*HsEtyg3mJ;Sdk#;+F^epweTd@(;sBrav-go2M&t_|=J+J*?9rh`6eI!ZTI9ekk&FEy z0umqt(EDO^xtP3Kl2=R8wTuDewj@o<9dH1S@=2-yhy-*D&VoWHgJUAC0)hNmkzXrx zxg;B^;DpGf!7vC?0RKyOK{*^}&t}3x2n&gabjX8!BCP{}JX(_n&62b!hQlIl_do?y zi-d+kG$aFYLy6liA4){pqi+XfbclpRNP|s4`VOQI!#^wmGJrH;qzOABOc_Er>=Wq} z4aDh`3Wr2G=K*PF8VQMz0r@~!SM-W-Ksb;t0(lWRPy~m7wB3SX5TpR%-Le4L-N>`sF_G?p z5C!PkeI@LG18`KNM*u_uVLb@zkqgBlk^T??36KtXun#Il_(_tUVGsvtkPW+_9FB|h z3W8`z26X9#F1^a&m`LwHK$qU+*PHx$qf2je=}lM^VNszF3&n64P6|saAQ;G}PXUxd zl}KOw`$hmV`tB3y$8oj(2aq`wnM08|jP%1uKaBLlkT(n+h8>2JBEv%< z2Ic_ih8MvhI3W^?%vfZ`A~QA*_Cck{2!9BML68F3unWrJxX8#Lhz4{Ug>IubAI15o zI7ot(B5~v!w+Z$@1yco?B4dy@hWy5m-&pjC$BjQJGLE?8qJXsHNIPx^9Dt)D;|Uv& z{u2VAgf1N66FHwq`iVI}+=;}USSd0|APfdU3gkhd$mCREiVw&;aSo6!k#va%fIOxk zdrBmr>r`Y+%@COu4$(mRqzFg={FCwlJ(7+HKe0f(=`n!Z>F72cxzmw59l0}*I|I2h z5+M@`pcJY^uJ8xsUV+>zkb4DkuP6cJCL=c)xyi`6G8AGVRahDT_|J@objX8!P|45x z9LRwpAl+5Q@0dsmd8ZI3h4WbgVGsvtunG1+1yqa7E&$TcJ_IL3t`3GlkOJAT3(A48 zIfTuL1me#j{v7<~;y0K0bBRBf`11&#M_%)ifbjX`ks1UM5DV#m&Z#?KA0Q|7s0dwG zSwNfx#95FG8ITKwPy&bHq{zZR2!|LTkA=uHJHReP-a_OpMBc*VB8&VXR3weKY0;1X zsUnLjfbb=RF9{Y|itbAjAq~)fX)%<+5jZK59thz;e(A(XCr)|+?16Hqf@+a#f`ELk zA)jkfAq(;WdDkHC8suGryk*E+hP-9SyEYQYI|G(y0P&Yo*5$;#E>Gn8Fd$84DOA95 zhIjrD3ek`RPrCIfKwj&Sy?z&zLIoTbxy2tMAOX?={cj=vTgd;GN;n~s zgAO@iK%5+8cqkXyfKIoCLYYV|adNW(9dnVDi>%zEBDW*wcI23y>hB=V z9mKhVICty;WZY2&)tE4YAOi5avry!&KnRC;khiWbVj^lOhj90{T6W2H8+0@*rs+3W8`z26LVZ#XxwWKSTh!6yjHS2#$+9 z3_D4;lXN>1fV_8-Zf7Zw?h(>G5)4TqyNLH_0F;Y7hWy8f_gEp6i9Al)$4Og+oT8JM zcmm-tAmhnuk*7%eR0PBV`aMPYo+9m2q8bgaUGQ6Mr}HcN4ao{C1Py zZqn>70c7t!Ch|-Ggux(4gfz&80@wrPPzBW@dyu;axqHxc54!F_hdudl04m{x$g{}X z8wtqTn*qq$i>$rK+Ka5c$l8mneL)Zbv5+kCyg(p?Lktk_dE)IqEb;>BN(!L_I4>dW zPx!sKL*&l~L`u=+B?pl9r9&bwrvu@yaQ+JEULoBpqN0lo6+lIA!rL2UbEJ6ajgZ9ToWtI{zgC20;Z=>&W_RDwK+h`jB9aEJ$Vf17;X2?XN2Qv$?!=cLHt5QqWf9L|9vk#{+N zHwj4hUMy6Lyifk`R{_TrK@b6iRU|_OKolVF?<-*k>;uaC_Y)!? z1V9)Jf<#DzO+eU(gndZ-4~hRF@js-TmH1T>zmoWs#IMW*;#cm1QmBGzk$(h1J`}@Y zI41H>^!aB9L_s{vft8R4MQ{KrMLrTph7us{M<+#&5a$SSJ|^AAr2Ck3ALIA2@k6(d z(e0Bo$c6&I|I-90hboaOboq?)&r%@^%sIM!Rt85zK6gL}L_sVhLk8qRp~x4}fZrFS z{lc7=h#U=sbU=@P5&o}AkuOQ}C277S&X>gb@-Unf`6>j6_Z8>I!hyJ7#{+tNL)vdC z^S3!7$0Gnek0a+eVaJhi9R0p?0O`IX&3EMa9kRY7?7O2P-v>bqqycHZKLE!?ejv{u zqJX?kWI_Ryiu{O-AIn63BHd4sfSjKbAQg!BGx?q5_~Z#}oXLRPQ`u0BovsLwe;WVO z6+k}K$f@3hO)3;JAQ$@;e(ne;WLF?$*B%qz_h*-oP3)l%419}S#|gU(h;raM&3A_b zAOv>6K2d%-qOesc|6NcD6>wba4~jMj#f^ppNQEpQT?67ZI3lW{Kq$mO3S>b(6vH7n zDyoq`5T_Aw0yqvx7j;oM5Y||r1jIpl8zzz^^IgX-b@?hvAs0W}8Gc zM_zOEYMub8kOk!1yco*h2%HoZ6bO+(yr6X01jTR&j*Ds$2$4X(Es)a!IV}oAU5pMF z?}AdO0OGdvhfpBjmI*-omc(yKzAcNP42}T#1_weo#E5Fe@g)JUNz|p05CB_LWdAszV42f@D|;1+WK@(*ZeQ0f6j|=+Fth zuy?3Vr9fEc3{m0!5DLddT^0i=P$sGix^>~WOO>dul%Z=WQ~>d~l~qJAghLGM64ebo zyP;>deBiu$x~LvO5CO4(emzLvgY=R3N2Wp+aNd)+J#$3$3Wa@eNL24^QBkDrGYCpV z^-ToQ_ajX-=l#QhG7JcSG*JUnL=6(i6LmRh2j_|!5(VfVQzmNYN>RgzJ1k7p@B}z4 ziZQVoiJXxqM8$=O8XYZa41Qzr8+%mLI0qnWLV>6R;!i9THHmnWkUOcGg>C4Y7$j;6 z=Ti=dni>c@fa7WTqLMgIDibw5N7RftP%Mfup-RpabtP%9#GM%id7`e0hDuQ>lqH4q zDTkp7PKcW2fFL05tSE?uW1?m!!W_teY{-K>Z~)Msv7Wj*4w4{M)SO5_@43{&T*@(* zJm(@~ZaU<`E+FmP3OFHZo&$m)45AfF`||Qh|0)-O;7}+&8QN!T!4C59t|f%U3Wy(^`yH#9`XS_GfA5n2iZ^x z_}vf=l;eiuqHYWV^0|?;D~P*-uoaYfMG8>n706jZ+!dr-aZJ=of1u1OV}Nuk(R(F% z-$dG*@V{vgq(LqacGF=|s|Z^~*ec|%B5YLwAafOAHwQx`BmjBcybs9hW@KiOCMyxL zp%4xL{;QLLyEX(eL}kZAxu|vMyAB!agMjcH^u9F$;$RMB0s7oZ z*sX`*xTp;QfXofCfLz9WYD2!L+XP5|+b&VL=*-wp-HzYwxEl$-gYy&bziKg?UZ5rCO9JM{$f!(h`Zyc zs0Rj#dN5PeLkVz5R3Umi91T^XcJ34P2x%W7&s}LiUXPORqZOha!+oqo)Z;0liUe{+ zJrM0EmEi zNP}D`f^s+}>ZJgPfOtrQTquHaI40`l0EmEiNP}D`f^s+}>XiV9fOtrQTquHaI40^q z07O7Mq(Lqe0d@XrA{-I*S~z5hdOZTD_p$;}e+hsLQ3vBi{WTi6Uggv!V-EEub@`S* zP&aQ;hi@Ghbtne%pi=N}c_4G0I@o^du|KnUJ0CfGh z1jCV=}j?$@~AAm^K7qQ0fBj+6d4e#fbk?~walwW#l@ zhaZsj1Lr^Ff;m3`S5@ehP(H zm;=Rtyq}5pa|%?6IvEF~KNSw7`^6uMM4e86OhAX~5GWJnCS7fsXbFH6U~^0<6}F0p zJki=8N<=%7AP1^MJNejE1LkHMhCsIHMsaXlbU?o7i(=rY=*IXrJ|enFEbM@jq5~75 z2smz<3Wr5EO9A3FpCdYm@SsXK2Gycl1VIEKqeU`gKrR$Q36Q=8aW8g22t+|VAnW3l zkOxI@04m{x=#~Kx27@3G(jXfOU=Nf-6;z834uS}Xg=ENpTquMRI1I-`w{k!TL;>~G zY9&zSRtH31LRl{*EF=u5r;s$rh630F6;Lg@btuF_GLTPe@@ZWNB|tu{$)}A2LV$eQ z#KRm|33*Ti2cQy8h;ADIVK4|1Aq}#j0QNvRR6(`q&>)C_SV)Ep$b~{Efx~c2bUO!x zKorEo99Ri?un#Ilw-*S56QVl=1O6TG55qr<^RP&u9>UUK6YPNs;Qs0857a})Xh;C= zk&aoA55-UhN8qGr#t*tvIK;p{s1V(m^qtYAa}gX69gZI1qz@_eV?$g>Z5_Q{75I3l_)a{GqCAV`61D1cHReLrOP3kA~mLw>)NK>B{gP$@cEfb`LE zKv;Ah?1MvaLUe!9_9tzB()Le1LQGq z2av}=@)&qj^dQPGC=!q{C=Ifq07{_(j*GtBA3`A(k|7I_n3HAVa4|6~`!~kiB zk#<-P>;TdaI|Ro?4-W!#7><6!(SLXbpvQ3Z7+wO0;e_Z|WW}xo(#IZvD$yfi;Hc=4 z{($_E$RCO9k!64mBdbM^3WWs75*x6CHrOiBUlO ziF05j5O-n`9DqtVA$n2(pwpyHunS57xszjobd&c$x#&dXByygJoGFxJN-!LQYSB|k zH!Tq|MJGi8@sp~6u<4;d8DOz zik@8zrJ}DsBzg|#bE)Hbq?=a>8R6GPh|UNSy&Qd(6X!bOTptA|Mc;5p^o<#!S0uv`(Km&N zUKK9-X5wU3ie8QXYV=r5*qRd2YZGA(92T9OB)otMd7{@Rh`uEZ%0%Z3f_%}plJBj^ z-Vg#DGmg_6GNDNHZShbcn(>>yJqD1!F%-~uBYAEl9pgE@aTn|Z@Ae~bQuO`gcYipMCMM??W_>JD;$oCezZjNW5jv1%}u%~uFDI67DEI_`+#4C=2BuE9~7UuwQi_1hmO}wW=ArcZG3rgV#koRt6 z?2ZA#cBeo(WQl$T9iAx{&3v1Od|c!`mjpYYLiAqBzBdh4LV@UgMWUaNggn?IdOvdZ z7m9u%6ws+83P@8zotBWUq+Il$Qs4+27yV*5P+xzhE=&D^uu}3ZCEiP6!0}7RM88bD zmy!4KJ}85uqF)&V==x>Sh z?J?2EH;Mi(8cvG-9$kOH{|E9of!_&qK7qa`@;vSus>Jd;ES7&Bl#10L5_X8y zFc8v#utw3a3y9BLixp5N)U0R9~+#0m?CXh;IiJK}cCgnZa17UKo06M1%aKrkdh zDv(cS;&dhsV+Jcc8;*;0SsWxoCJ=rZ;g?m2)g=-VARRV|)insB0R6k7f7f!cBK(1{ zZov=@N5tyBQmh`x?2!aV#fn5mf&)+`)&S~#0CET9i8YYpfyHoGEc&?et;ulLwr{8?k~k<&mz)m`4>MjY?<9tUvzw)glV6{^1X z9yexRj%MEDKxt@=^d2{rK+C6R3;Zdyt>?w~FZ3K!$crtn&V0`z#MN^5-PnUlEuS)IZDK5E-vp?5;B)qp)pqQmvK%)Rzh!dmSurOQXEAbz5tb%%xWnd>$8wHm5jRS@laI-1AifKb(M|f3 zcQ1Tq6LT&pdJ{HDCd)V&SWk90&d-)zU&C|5rV`iawg5erP=X7~`HaNh&ut2Ng;Js= z=zDfeEg(-55=z;Y;m)yjHf3Lg-%^>!U!&Jz=w5d;iI~Q3xt)5bE!U&}wYL7|8f9?J zu9X4Oga2nFEJl70`x^dUxVfet%|_bt%oU$(Ym*_@llL;DgnDD7;a<)85^^)wBNVMn zIX!oRx#}kFWNIKDcLG|OxS?`Ja{O5mA_zP8YV@S+2G8B*(d_JeecH^D>(Fn3egDkn zugUv*&W#?PdLAi5WukqYLG6Ur)rF^~uB9yIK2Ilwsc~~hq~V%7cRn>Y0lnk@qcmsk zm2>aC-wrubTXWFE^8{Qgu^eAZDHrn$7~ka_XK-Zh+)4cP)PE@N4ld`+Jd@@g>jYPG zzL@{!?)g0_q4bZI5I2-~=1IKPzKZ7B-iS2wY+pvJuz;hh?K(CgR};tF8M8R@v;)_2 z)r}6G`{hF7gi`NDdn2KKsp`u)yIe!b-;>)C@-au|sab-1rtaq9vmDLN_?WAjS?_!a z=O#@&F|W5v*bN;_xs5z?-=4XLGVnL|#AN<1MqhIu&I8}Qe?E;&{h3-wN7A)21=lX0Cu~`7+SXNHF)Zc>?Eh4QAnE?(SK{3YAgk$S}3J%+_=X z_lbELx{<$;vyArKJP)RAH>L1gwNUaq*C&JL<=1s=^sb+C{Sr>5r(pkcKPyjoj?Vr| zpMp+=gmM2qNsPb9>vA=p&$9TgqEoq)pYm4?R72HB1*nTuW7R|js-~)$YOaD*3w5z- z$%nRDsY}$QDnzwbZB$!+>D#IHs)Gts9aSgQS%s_1R2S7%MW}A7yXv7LRZrE6Poqbv zKC(&mRsB@7bX5J-05wnzQkSd2YKU}FF|=AWYN#3}wQ9JERU_0$>8wVnI5k?0QDarS z8mGpq2`Yi7_RR)U`E>qX3>s6+7Q8%a?)e1SOR;ruSDs{8U zQmfS(wN_=Tb!xr3Mdhel=?QgJx2arpJKsFLLv2!bs=L%?m8b4jThu)&Uu{+Qs%@%3 z-KVyz`_&HhfO=3pqzcu;YNvWc?NX1b$JFDhNIfAD>PdN1J*A4()AE*-%NuI9dPeQx zy~SVDb84^Jr=I6)moKOi^(XbB`m-ukFR7Q+E9!uHRlTNOS7qui>Y)0oDpzl)H`QC} zkouc?TfL(Wt9R9V>U~wA{;obyAF4|A5A{#=kvgJ2R-dR(Rh9ZoeXhPxN7cX7m+C8Z zOuDJB)i>%}bzHiu@6`9|2X#XIsD4sEtCQ-K^iaR3)2dq4D7UKR2K$81+G>g9OQH_# zER*Fn04zF4y(w{E2`(U;rcS&MR(N^x|{BG67kPLL?x$Lymg z>B%}#PtjBLG@YcU>lykAovg2vzIvvI{k2%lQiJVR=_l^>zAsovCloH|iC7rM^k8(l_fYy;`r)Yjw6> zr`PLSbdJ7NZ_u}CzQL_G>N}*r-lXr80s1bzS?B4y^%i}P4Al90tG-un(*-g}-zQ(` z?ec=YU+>Tl=m+&fx==r?cj`yZ|#ogXYCsC~{Ym5OKV}nGqPSV*HmL;L$LazZ#LV6(~y*F|)ozOy0Pe`Me z5Nc=%EhLoxn|W{VR)+k)-}k}Knt3y`GjHC!_vX!;a^NmHB(Xhlwe?H_e*Y_R9sC^E z4T&2QH|aSi@w3FuiCYr4CT>gIp7=Suk9SAn&ct1byA$^$?zM&z_a%Oj_+{c()~ShK zCw`OoZQ^%{-&@0pKP2vl_hdFE{*?H0;xCE6T3=5*ka#fhP~zdlBZ)^7k0l;YJdt=Z z@wdcNiN7bFPCS!%Ht}5I`NRu}ezT zH^L7J&$MURv+X(7;qW5HT$t%b;dcK{_RjV$_OA9kdpCP`dk=e0y9s_rb}zfx-rHVa z?_=+4?`MC+-rrtmx7ds9R{H=uX{W5Ewr{8Hz;3hK?Tp=FciIQq2U$nh2iu3(hgxsL zFP|;8yX>r;v-5Cod6^yBOYFn#rS=i_GW$sTDEnx8xxK?KA8%?X&E&VeWj&KF2=SKF>ZMewO$``y%)i zuZ!(V>`U!!_GR|R?2p@*+n=yMX@AQ8wEY?Tv-aog&)Z+Hzi3}!e+k|J__BSa{T2JG z_SfvMgDtkj{)YWc`&;(6?eEy%wZCV7-~NI9L;FYekL{n>SJ^)Wo90aGEbANKi#Z); ztuyQ?d%JzLeT{vseVu*1eS>|YeUtq&`)2zV`&Rol`*!>1_8s<}_FeYf_C5B!_I>s* z>|ffyvVU#=#{RASJNx(cAME?>KiYq?|7`!o{;U0f{h<92+>L+Oegs|~eAIr-e%yY- zeiB}F`J4Tewc7r>{j~jz{jB|*{k;8x{SW&^`z8Bj`xX0D`=9o|?APqq?KiCB>^JSV z?0?&DTklv;+yAluYrkW^Yrki|4?l!kV_nJ;41TkXF~*sIANrKcWr}&MmesL(*1#Is z3^tR^Vzb#CHka+hc4oVoy+F4y;w8bn=N4buzlHn z>?3S{wve^3MXZ$_z>+M*e3oVbYh&#!!#Y?eJCGg34rYh2L)l?$G3#PkmScHVU?E$= z4rfc*5o{Sd5`F{uXttcKV8^hP>{zynt!Bru<5{=W!+O{W>_qDXb`m?8ox;|zURGp% ztlv734X_eh3-5cu%XMr$8?;_zr?L%fh;3xUY=n)n)7TgrXA^9aZDO0*7Pgh0&dy+G zS|_u!*xBqHb}l;)R>9A*3)qG1BI_mgQFbxAgk8$E>0fPTA7_`dPq0t2Pq9z4&#=$3 z&#}+5FR(ANE7+IVm)Vu>`rzUyPMs^?q&C}U$9@Y zU$I}a->~1Z-?86YFR(wb``I7apV*(-U)W#S1METe5PO(C!X9OhvB%jH>`C@F_7wX& zdzwANo@LLm=h+MFAM8c;5__4w!d_+nWdCBXvDeuf>`nF-`!{=={fGURy~EyR@3Hsc z_r+^?g4>*N&INb4x9~;0l^?*9JjH#U<^gZx?K}g&Z`{cbkOYnC{xAL-f1SU<-{f!cfAhED1#OrA*JAt~c$w;5@a(+D-?zRgEKy^5;J-dpB&@~o z^3^F;uhlG=;6eyTNZ|@)3F{VXCcK&QoOPJhXl)msb+xFqE*5p7UNneCF+;~`RTxVSmo<43}V_j?AZQUjI5POOyF<ZCfY?tbcjxIp!IF={+w^!0qcx9aS*&Nc$qj@9AbS;94ZbIi$#~n z!Ye^vf!DWlB5z$H3UHzE)7BTQE37YBS6bf@p>?BJA`TZz#SvneI8q!Xjuy+s3UQ2B zDUKDZ#A|cqE{3}pXe6@q9oRebz;336sL*}Vn}Qh!(v2? ziqpiH7#9;_Qfv~N#TKzuoG#7~XNt4L+2R~=t~gJeFD?)lii^ZY#l_+hajDoQE)yRU z9~YO4Pl!*7Pl->9&xp^8&xy~AFNiOSE5w(?m&KLhE8?r-YvSwT8{(VdTjJZ|JL0?I zd*b`n&Ef~*hvG-#$KogAD)CcM7E@xoxLRBzt`*mb>%|S?Msbt)nYdZpB5oD8iQC1` z#U0{KahJGT+#~K4_laMKUy5IeUyI*}--_Rf--|zp`^6u{pTwWVU&LR<1L8sPka*a7 zT|6Ql6^~hOSZ|8Q#S`L5@i+05_`7&oJR_bJ&xz;73*sM^wC)ivikHO8;uZ0#_$PRM zAGdPiU)JT~HR}QELF*ywVez{4i1n!Tq&SIy_$vQbF?-ZQSS>hb-EOm}>mN`c{M>$73%bgX@G0sZoSZ9^9 z+BwcS-syIFoD-ZAos*oCol~4OPOnpR`ka1ez$rOvopsK7XV5v-+29O08=YZi#2Ix? zbH`Xb^ovWQ|oNJxyoa>z%oEx2+oS!*2JGVHu zI=4BuJ3n{saPD;Oa_)BSaqe~QbAI9c()pG1Yv(u4Z=K&czjyxN-0%F+`IGZ!=P%A* zod=u;orj!;=Jno z)A^V4n)ABzhV!QLmh*4tZRbDEf1P)ncb)f~_qEerCZsKyC3bXWSeZ48QCE_<$>}bd9XZ09x4x$i)EM0%ACy0f(+#ndAM9EkC4mc zk@6^cv|KJ%$YbP6d8}L|SIgt%@v>X?$P?s=@+5h(JVmaNy|O6#WWOAcCAn6vlk4T6 zJXLOxLvo`WmLqaho+iiSxSWuaa+BOFx5%yXba{q6Q=TQymgmTG<$3aad4ar8UL-#% zFP4|cOXW6snf#dixV&6`LVi+yN`6{?Mt)X)PJUi~L4HwQA-^QQEU%PbkzbWxlV6wL zkl&QwlHZo!k>8cyli!y=kUx|^l0TL|kypu|%Cel2+vU~r8hNd}PF^o>kT=Sk^I z@)mikyiMLNe=hHkcgnlu-SQrJue?wGLjF?zO8#2@M*dd*PX1p0LEbO_DE}n?EdL_^ zDj$#!%7^5`@)7x{d`vzrpO8<=zsaZM-{sTt8TqVyPChSRkpGY`%9rHJ@)h~2{HOev zd`-SC-;i(0x8%R&+wwp1zw#aVu6$3v?^Pb=^o`C?Jjp$xW~9F-DBNV?rQfq_jtG4?Qu_VPjpXmPj*jn*SNiI(d~2l z-2u1cu65VB>)k>3RCj|rg2!yO+3^y4&2#+>f~*cQ1E8;eOKnl>2G-Gwx^I&$*v>zue{~;lA9NpbA9f#cA9WvdA9tT{pLGA`KIQ)1 zecFA-eb#->ecpY+{fGOa`;z;z`-=Oj`%m{@?rZMr?i=o#?pyA^-M8KUxc_zEao=^{ zbKh5%s!<7LE2g*-%286eN-0m(sybD#8dRg2p=PRCYPOoA=Bl04&T1F6tD2{FQ@g7@ z)SjwI%~yM=X0^9kp!QMws{PbQ)c$IrYEg?+t2#g>RZ96Ptpe4i+Eqq%s7`gDI!GO? z4pE1y!_;EcrLrog@~WUhwL~4RmZ~GvGIgXnN*%41s}<@PwNf3cR;ktMICZ@0Rz2zj zb)q^+ovcn#YgDf)sy@}P22@F{RqNDxHKRff6I$vF&E>st(kE)B+CF)YOOZhu#rqp(IwYo-KtFBYms~gmf>L&Fwb+fuf-KuU=x2vD4JJg-(E_JuMN8PLLQ@>EZ zRKHTcR=-idRlifeSAS6Vt3RqgsXwc~sK2TQ)Pw3F^{{$GJ*pm4kE)q4$Iqc_8w>CN(Hdvmk9hlg3%wR^k=N=S;3d73=X+@{@Y=j~FXMH1o!)`o zLEgdMA>N_hVcue|%gcH>FYgt+&|Bgi?k)9>@RoT;dPjLjd&|8Q-Z9=v?^th@x7s_- zJKpQ|db|_76TOqXlf6^CHD0e*^!mJhZ@?>gYrS>edT-D>)!X0=c^kc9Z^Rq*PV>gR zac{z#^fq~$y)E8W?{x1B?@aG3?`-cJ?_BRZ?|kn9)ipLaysp?kIZ^UVbY$JgaA||n zwXxVgHZm-_`o>C|N=_FgPYw?zQ@Olj!h8Y4LehkOG75c!{dOIu3YeZMbeVhzO+JJH z=66xKt`35`D9ll4+DR3%^nI4T&(inVcHT8Ky1uB)--(gok#X~3n8XUhWGBH`ahS{! zj17cI)1g$D#D>CTi1}IiK1<(c&G$(^P4#3=J;@-29S`zRhzN!q^nC|?-$CDXQ2QO! zeh0PRLG5=$?dQai#f^OfMU74}Rq&mzf*C3U2YKp$lIW3)U_;NOAEfcSjue(p`7B$S zpvpQjUao&|tbcOj+M&`Gl^YnDDE9Z4h9`7c7&C)9bQQap>cBeFq3KF8)zKyL{YBsq zDvmuXBx%Tqk_Dtps*v(|zOOijh@?Va=1(_YuW<^*Xa&P)s!+wFfIKG(m3ERob`e7A zqK_0Vq^RpDVx?4+PI#pVFB;JTjwG;Dluj&`BNodMNpn zfUxG1RA<^-5*yPcRazSU@qMwRO3PG8ee;v{lGc>a)wHHuQ?fJNnyQOc)tZt^%=omX zYOA$IrF~!Lo0_AfFu)k_Y_gRQ_B*`8tJoQg{S?vNCwlu4PBe~w7dt%aUXaTmWl(=4 zgNS0NN0Ou z7cZTri%oSP5C$Cx5sdSm#@^9uhf^P`jSDi9czIYkj6Wr z+I^Iy02v^iL52v3AyR2l8wDJiLYg#Onj|i5BrX}?t~3miP89~EE&@^)NQ6`&=;BAO9~s$T7lzlFdIQwTKs-b#K<%6iU{2K7(+2kkX^U2~f@o0THZ?2-Ze}mZSU}<)h(|DYvJ7y}fOMi4$zvf; z-=hVWDxd`iq3I&?Y>qj(&Q(++|k6AM|p$A>8j4@7I zyI5Ie9G@&TKShLUBf_*rO%Y+*3}O9LDom{0f@2uu#IdGg@7Nt>FS0h;X_(rn_I5(N zo!GP8v<6IwQ+%q6R6WiONk7#kRvBc?EDT^Yb+!|F?Sx)CjeEv42$aaxYA%MbwXZl{ za#kTF5b<=uUR9jrt2Gac)i|ZBCRSc;SedWZi-5Y-(-?Yne45FVDVZnC^Eef!P|+t- zq~LwD!=NYB;|x(ELzKuw=|uMobqvK17?AQKZ56Qq3KHZ~$3yJ6A1Qzg5hhdcj<1f6 zINnSf;&?M|?(xxdV_2quCT*%fR(gS~^8#As$pDub$so+Zx#mGb%TzY)^;GL8`cfY| z3Zlofht)^sRY+YT5%58#SCjEbp^>Ww0;b^@wvl|bkzBQrJhjn;OLPhgRF3Es7P3wc zna?Mf&Z`qDb04DDNxa%g*ms%{0#y{S6F?H#3A9r1bD2;S(elueR_MZ}3t3{`ESYy% z!y;f(6N^N;sms9d9im={n7#{9E_9)7;FF!3%Hss)`&55dq*JM#E@VYNnRbfE#ZIxx zs;NR}mnv4*v?dzQPNsO#Snx*eqry!Fq_~5K&kIm_sj5bTe4AYao1$ovbR;q^h$J+_ z15qlmR3!$+w6O$$G#G;!5iEhaVwIDk5?xe6ldF7!nUF*3<=^WQYp(RF%$Aw#G&l$rxjOkxEZ> z(4e&ulfd8^%AqENM}Dd4gXhKAUlmX8HmHWp~zQ6OJL0euf3ZX{M&63ZO*Ax9L> zk@!W6r!=-7ph=Mo+EBcLe1?~_T-2@^EsjmJu3e)i5_@fH3jPgp_!kXv3Rp|5Ee)@0 zO>tNOuN(KqO)xPwvY}LO;#CTmK~9BCmq%K*C)qk+3vXR)c-Kw)Aer*hVqKMFsgSzh zr`WpI@qVQx*Kbck6qyJ~2wg!<5}=g?MU3W!khr0 z$_BNp3=%618dkzN-49IxXRxZpV7{gKj|9PwI2xD4V0UJ*_FNV}HY7`Dyi*CaNHG1N z)3gF%wO|k#T5WK!?^HGjgl;$$48ig7iQ?dpDW|Hicj^ul13#LfT$;ouKqCv3p3(TQ zw4g9e<3f{HAx*5CCQ7H<_y#>*Vgp(=x)Z6+E_Z0--~du`C@%D99Kot1U_;PNF;vyx zsdP>ZRX7S3EHrks&MnaTwvf(?q1N&7r0)$GGuXs&7(nsqjQUFB)jYpFX8>0>YhoU@ zT`d9#P=>*xlA%$F1D$ao8wc_RFoX?qApE{3Mixxvsm_8Jj!`aX7sD0G!ODwf?SP~J^dD9orK1d{ayd2( zDDn}ravCAN9x;4fH!{u8G{cH37nqvp`+`wxpe~~@vI;QYM|TaFE0iAb4lOte0ZA>Y zw^SjTc+htZ0z&yX@xuy^P$ta+K3+be8(Mkb>lt^1hdn2)x(+I7cD2%V1 z(C!LpOhQ}(gEI~h2+5)iiNIlo)(n|68;PVgK)(yDkTQIv6mde3LAeUheGIDs8l$!- zM0pEv`JMD($$uIN&{$lMf;=BHdeZ#GoZ7LqgX8P9o`n4X!zg~HAjgQ^#8`}D+A?CS z$}zBp!s0lo!blLOkV#u0leW+nvN7Eiu-!K4a6FDuIuzrk32%G{ZR1B1Wjl>TJB?&J z^%}K*s?bifjTaU~D29p;UWXOvH&`*cOn8LSmzKV#5p}-)Ihvr# zXl8D&n2ha_d#R8iqYo@MFa*V<(VKkINTn9MB$?~J-lHHXoitL)C(WX8a=NTen}l%5 zkcvFh=w*P($t>z1G>bA=44RREkYp-DBb1>L%0%hJ85tr{f$|HKAI%e}BS7|uhy@~I zn6f8xZe9i7ex!t|MlPIEzk&Icej zYKnl|Mgh8wzzI#ZbSeW*=>Dx^hGYS5serrK5EOjGXbS}BWCFJu4KZ5k$pAN#AdD)usUMOfI3(*Nq>bc|mg8Z@XQu;-HvE(DFGh5qh~?wd9nuzNNbAIqwlYInFNSm) zA|$_7NG{Qk9C0D3i;x_0A*qcJxdsexB09JIyuD6Bk+?DZnPm3()ubScW+4h6CqjK zA?;Iyv_BE%Gq76I2OSby2JNwmPoLNg?EvuhpnRlrJ|8#ga-ultOd>PPrf^!{8g@vm zB{(*Uw6hY@Iw7PTmXOv9A?-bcWJ8CzGzOPMBs!!qX$K{w^+1UGO0X|sbPR+UdvyJv zgn#SwF02h$^AWApmH8XPh&B;IvS&luObE%Y4QW#$B>Og`&4rNc+>l)1A)U4f(SHiM zoP-&jSpXAtX_XMtDV&h}vmyG{QX#J5A*Ax;&knadf$G71b=bFz+NX3nsnHfGUGgXf=#GZ^NI8>F zFTn1@q(bfDem|6>$t2pN#B~|;gT6bX5gWa;TOm>1OnKv>mLD6 zA*`XsO2hqIsVbv6pp@ZG2+f=cq3ITcQGSG;AseKd;euLmjxFGD0gU8G(b23_Hm6Q6 zjg7RLwYda?PPL%tLqytfh$7OT?63SEe#Kq)@ros3@}DW z*7m^?z7%B{Aj+!O(1sGYG|hJn1V-62s+CfkGh;PV(u`{LQK48Hlr$^e5T(tY)*2$i@sH$<+d7-cxx?FxNUpk#{^r7_)Som4t)vN!}l1Eoi>j3VCf$V3!(Mu#SKC3557 zu!(pZCx<2mM~AjTqB}6SX>h<$Ru_wk)WcDUv5_rN6?H{$Q=qpOzVV9VfXm?c28bJU zqQQyKiQpMkT%+z!Lzoiluo;3HE2vXKt-(Jkix@^_D?Oovdg=~=Gpc=}lv(kPQQFK{ z?5&+apRiPCI^RxX2w|rlj^7QWWx>&*|;O4MU^5?>n<3kM|seoVR{%tEzufwiWsW3 zgX<>8N&|3Y0y~guQzN6L;l9bCq0$8PDP2D?Hdq{9H&mLIOqvW8y5H8-<;9rU11Bz2 zY8q>(Hez6}w6T)sVU<{}+OmPQ;~GeqHo&auIK&I&;s9(%K>y6AfRX{~PMZYj(C2{1 z!2E7B5R6!qz(>ahHnmT@8Vo zMF*#wz{NQm5*jM8_!JHqb!IMy2u_H4a@G~lRH~y5IIHTYDMOPzfb}@-S2OesuFIhn z0FgRl4nzeM&grIpoYi%dECq81P6+g< zLZC+#0zIk_=uw40k17OuR3Xr#3V|L~2=u5zphpz~J*s`<(Wv%SMzs%W(#OrvFoPmA zsyba8WjLyR)lr2{qfwmBp&6z}G}92#Oh<`kl`=>(4I<5A8JcDq zG&Iu@L$gW&qM3$?W;%*A(=nu3r8v^elt!AFDALRnuhL9|ahhp3qM7*$31f;?qj8$) zEDf6lB5ZNcM1y{MfN|ZH!i6KixbjM&#{=N#J2c5sxG;ruT$!cXk}jxZBS`COjgVq| z+|vsriogUp;->Yw1o zc>o>?$@X~m45S%A|(qCwa`-DvFOdRU)~ zX%h>8m{8YXZ}$0Tb5hwcq;E z;6yFL8%jf)2F-2{7#a9=Tdv@i#wXwu%0y|vEsl+iY}SiD(_$uU12byv#F231r%UJf zaQq7bFa%>|I^gUbBpO4RK5K6`n@uo3N)#%!Zps0CyrfeIpZSXlKGq zrTti97o1Il_9sWN_`t|!>|tjrjVY6(1Jq}9jKCq=u6py0S>77cQJa_0U1R&sn%-xV zHY4i5j-Pax>;{uvT`L${Iuo{=%-K5-!z9j(D*V7la4JXJuO?r2(|}ZA#sC#$cFacG z-IN7#RzHN3{c!+Wpkj!l8W>*Jx2Au6seePQiS`wThDIi~z;5_paUIalgp;FYfZO28 zl!3>PPukGI0 z{kQ;A`*>vnU}_)z!2nbHcyihg(ESb}(k(#uJHUhou}FaKcSy(K3DErxaK}tsvS_=u z6*+yN(JWTL`iK(9;;6tgDvrpgM5D1)W1q}Gb2OGxkIs|I7pF~Xe_B@&G2i;7@SLR>JSPssO1APNQn z6~Q2w1S2Ynt2*jEE$k3#TnnCaBau|LF_MvpK9T=5YROFWATk8UL?$W`iOjSTMr0@@ zE;3P4Ok^l&y2wzXwgTYvwQp7p^$`I44+}5MOSi`Xb3m1Hg0@&rTdbI$>WJmwao4Ce zb0{`F!?Z*vWMgH6SS_&psOEq@7zYpygD=c?T3#c3Ve&KpI1lxHiB7MtZiqz1z()#_ z4|y{p*Cx^vQf5XesDexdCaF@Q!GP6l{37y=nri1%Dj^rDNu6a<$Km4DkUnZZ9f3-U zCOaI8HQmS{0GGS~k4$}6w5Ty4j!zzx8RQwj$IeGzB`Y~_0m2M1(@=c^AYRfO zdyYzC%ZNq}ajGv&L!+U3fj?GD*02E8l0qCCVi(CHoZ&cpyr;;C^qG%n)>khL$G)N} zV;6j@nYnlu((#@nH&gv^vA6n75T{lU|0X~*kOs)1Q~})N)fLn)pGFWGiYgBJwr8xR zT%4wbX)VQzp+r$jZE;lFs#Swg7q6{7PD_1Xf;a_nPI^{!m3u}FFs9tf3)sn3aJKSPI92=@PdtxQ0;q1rJ^bt+%rq+@)IIUSk39iFby9L)< z3_y2d44|Fc#OQEJGmcamo2p#XAV$O~DFWgj1aW%8K3Y^SETZC^9K^?fxW9hn1Gt0W zR|&0eF2w4~#i?GH)>6C}PJ)DLTO8H4YSo|x;~!=^ssJaWs{kBrjsZxY`pPNg zSYAgQb2tcI{i-8Qp$@FCe(MK@4D>^s{NNMPRWwvj`o^k+H&b*b3ctPw8UyuZP6IYp z1-hDVL^=j)p{{~PtP#|PlD^wzu3*Kg*H`iotlU5{AeKk|ChcWvfR`%(RZKyA_2qzA zh5AlG9IT*U9qDSm8S5$tXUE}meC2D%jr5$c(DaB;%Z0=8mBM&pJ_hO&@i9;zYB!*n zRpDuzI8YsIxX&Bou^`T4LEJ)uS07>(6yo0$Vtfgw!ehl~l0XbXPZd?5a!!2eGPr4nUQ)0f>J?yhqJec{vGZtWBfSj&_=q9nVCX#9d(fP`_Lh@w)Md zSFncnNUBpg09Bg85yp5}Ng3)lYsDM)PnK*A)J z*d@ZevVjv7{g9j;zcIDP+pBz2&Drsr%J$F)+NtKyH@il-;dPvNLm!qEeTAi?Z_QWz zC?vanNEQ)h7qdAv?W6ylLoFGeqBXvmtjvNx#(eN%kQoLnn67eFG8MCWlCUpWEk9pi0uk*NmQuBA}{ApvqV+w8qC;XpJ8Mh=$R#l{G%e2Q3*tWIf$cS1s-} zfbaO=62Aks_`w40=g2*m$FsSO{G*v zAdiE?w&Sq-n&??6H})4tqiq5}#<~ ztP@r@4xDC!16&huzR`rbcDJwCx7C~rm;K`turblU-Zd9HbS49}u*o3nM-M`Dw5!ti z`k|4L(MlGbc!qr+EQ%K*;A$|^#m9>gKo6o9UE67+Ylm(5yj(~9rV4`kb+CUmQ5*t| zGz#>YF&%^pr#qwoF7Z!xC;+*Tf_10z-l_U_2`DzGxORiydL15uOQnPTE?#MXWIm){ zjW8diy5OR)KKGB8RIrk^Kwk_Pf_F29J#*(42uhc@;g&9rR0oy z5HNyfg95I<6Pw`Ob{I(-S-N%aNAIoB-L3*XP*9hYHmQ!bOgBL22MPrL_iD^(5qVkzTg1&v5?mTys-l?QYN5R zxdOV{M_WKi+WLXeY?(nw^+(S*;jKGJH?jdC3Ti;FG6i`1B^g9lxN$QZj^ra_2RH%% z(|5RK2Ui9N#w{_pnt%#|w!Q#1TUy%4HB~j%BBUdy26*cb=s@4$eP6iBfdU*5 zM+U^<0iOK_I#78!(@$H1(Eq5v^nLWYAZ}4=^BU;^kN9ZC8PNTq0PhcLBb(9*KYU*V z`cL&C#{+$^{WQ^+c3$Bg5`LE^dZxpWZ_rQWnOf7?Tw-_yj3wd4jNX| z7_L6!$(s~X24Ex95SkuCNc-J%&n1OI3F(GuAvD4Pp&5J#jZi^|`^G68JAe)4AT*SN zFj9-u4yt1?gp87a139LAS0`Qqg~t-GJZK$*cM{b!ELqG5Lztvn4KSbA#%*dUj?E_V zr4qf;q4cO)%E$X`aOj$20J_@D=rPsX;n%|Ea%rqMq$j)$4RHVre2p8(Njuz}7}rhdGu8F6I8}d*?hW^=#xtDNhSECLi~JyuNA=}zkisbaN;J4 z!g-r03Wsu{C>+)?XG!3`ENWIiU%=&MXIu4@cM6Wdn8Rb{)IXh>(Ff7SM>bYYqa^7q zq%>V8OVeDICf%K;IW0{(JWX?3nsj-Z=D0NJ^fb+NY0~X!n)A|hvpi4F<>pBd<>@8L zJiV)uryHMndXX|u@2lkLWy(Cgvy!J5D)aQ-N}gV-%+tFodAe_zr~8(9x^I~$MVF@s z1@rWVM4s+p=IJeod^8u}Jhju+j@D8#P1aR9dcK98 z;R?}8gIkkEF5wm~DPHPNNU!6C)US}#r-RwNw&Cb(fY)nz)p@#Cou_-%d3wDlAK^vMLgwk^lsrABnI|sG6PM+QyYi?mVW)}u zL3e@kbQd^JcY*U{mgH%5m?y5x6W8Zy?T`$UTK7S}0@892)w<7cpHJ_C`E>QxC;Qe% ztdo8rJ3I1m#2r4h#$QA3q*|CZ=>e3X{y9-d!ncyU8|9U7FQO%r=hQ+Kd2zT7TG6P^*CIN80VQ^qwEVm95D7&E_46?Ce z-{A1Tq^@g*J`#pMEl??;k6?fa0gdPqjqnG~8RL3SCxFj%N4KH&G**$VGlbE88(qBC zKvemRicVVtd2sV^qEV+n?r0HKtGaxY04|BK5uM=a=ML!m+99x0wOyn$8X|z`S%Il= z9kNUWfg(ja$+S{|=;K-X5hacD`r^=9`UK7Z53e)h6HD}TA{Br$D#dkhgOI>l!vyf? zoo)evs9@Df(|O=ziy3V?MQ#C#>qrA~NX66Y8D0kZ0)JQIll`?C4O12}VgT^xhdCQR zByqBTCgN*;Kt#6Z~K4L}yKHWVR-zqcjHG+vB3B&Mgz4xv`vgr~m&%Lx8;R&>14scVMKK|ELlf$0?%T1_HCuu~s{U|TN+ z!K=P82zDA{5d6|W41yiN7z8hS8Hgsyb`Tg;cG2L~8Fr5#Nw0c!MUmxEWOWoNMv+n! z8HplW6@3nGrPZ2S$)qCcVMIX5z{b})Eh{qOpgKGqNGhiR25*DDR}qKx=n~wh^9}te zp-v~jrXz0qG#a7P3`VVbQ8O^1;oJt>2he|WFK`^*shfa|`ZXx4`VCSr8)nCaRX<-- zg2Wk7MQft3W^WjQ*Xsx2;Xuu!8b>H*!GASY&HL}eFNXd<{#OG(9tgkA{zrblWwBE% z>%CL>Gw;91hTebfz2mBR@4w3LXQ#aXD(3PRARprJE0qtx?}J_mzZQSUd-uQlaw1)m zd+*+NpO4bTRs1FU{KQwqQ~Wi1bK;6>eU_!`i&_&lwikU@^WJ;+SL&4S-ADDl9Oa9v z?DH#i-(YWv>MvU@O=W9!ccG`LY1s`{{V~hR;@A_q%fY6RY%l0pd15ydp0};Lsk~wZBrWcl*HrG%v5uaerYS5980`m11T~eDIzOpP z-oB!{38=BH*i=?4x_cp|N#`jYYuB;%-g&(}Jw5Y)TIJeYf7x2uUAC6#!t(*1x2(K} zj_t9mctfMruS?v(t-hX~fnra&W?@ec^`NI|0Q%FM?O9ajElq`{GFwoDJ~_D+-DRga zTb9jP7y%V2Ex6oha`_G5WT+_CuZP3 z0tz|kdT&!uN2#07Epdd4A9Sz{CwLQ;9^OJW$LpDmS)37n+*N4Y?z9&maOLRBqJJN`M;8c+G%{ z8VymJfCl}5czH&yw`p5%Q+WoEZBcn<%d%D7Q*0pLvv;|!)VyU;c~;A^W4f0ei;45* zL;5U}KD%YgnweYOJvDP?u3S^hmS-%~A_uIMoodj38sSg5W-g3{y@ElY9P&vQ53$@4Ryj{2=ozE1S(~3e1MQn&Q-Kxv+fM!g+fE zd(VYF&RMvqyi?0mjShDPdh2kPmML3@yS7X*9nNc+;yT=|WlHF9_m(L~hkLY4NgeLl zGUe)UVGB?L>0cJTK9864r^CIWe>z+M{nOz-&_5mS3;omKe$YQ1egyib!~LOu zI&5ueI@k!(0WD3v<(+$*Kukn`|i`u&{gp$YTmbVF_^ThYDnKv7=cl z_W$1!z>bT`el)~W^`f9TuAJI`ir363bc0gVqnM77=YN$6TAJDn=50_L)>HVPngH$d zq1ftlYwk5>s?HzU+%Xl@%+Y;q2YNsUKJ=Sj5SC)cqH?CCb*FZqxiGaD#;An2~S<(;4y19iH<6q~BG zvSlx~u(YkUxvA;kZBXYy(~C8=Vtr-NoQ+C1m3y^LS$s_Q)vSp(&AXcI!*}h;YE7#^ zX+!&fL37w!7BJe=#T6v0W+Bc>EY~~GT;?#Tg0f?|;yj4=_JDra@tY!`2Kv7_EOyLm zh89BTCj_PysP97>0YtP)7NA66FgP$A%pf~p0yP%(Y^9N~;V)^@YFof82S>DM0u1;* zM2qHwflP-~vdRjSNmEnUyhJyuNAb`o&vXVUUA9(rw>BLN6S~Gefr(IQWhlyG0YFP3 zt75z0AbybZdYfsqK=Usu9~QM{s87Sys|}nTyBrPiV$dJ0nu=k0r(E}nc`&Co9o*A8 zm8_W!a@#d6cjdel({i)Za-(nK_3ijYuBCk7!gzt`qo~1rOZlLM+kpKvk8J}<|6jPl zfVP&CfMUUPS+nszNckcdXj$yKX6I&*v{sNj>`>S;rC_en+;2Gl|Bj`Xd>DiMzi_dp zx7K3^H+RgNALEz#J%r~HP{0Q+jHq%rKnE?Hug6T&g?dvV!BQZ>929%7PC&wEwU*mK z%8&RT>C2$Hn%T3;87OmPOSuz*qcjx@K<=gxCgF%$N4IE(E*}MCUf#0ZvOe#JV8{b34R(TCT3av=bnP zX(#G(H9GesUCzW#*5yp>6kX25*6211P^?$CsUt<*rjGRKHg%+5mpL3F1G%ZRc0qJZ6I~Z8X8{_AxfY_j%mhYtnMqSdXXrAU;NwFowQe?$`CzDAspAMsoUFMV<~m&RjZRrkcCmZT$eQK3%)XAbzkwSk;FsrD$-~9L zqDAiEIEs?b6hq=9aWu=aKrG-Uxjx(F?!I`J#d8+VT->nOTkPC!IhF_I=Rk(Fc-sFu z<3`K2to+p8HJ2O%ONdLl3Eoe`H%Kc==$SXQuTHv2o@>>x#h3K2qLQ!%>*-nCxJj%P j$B84@p{!Ljai@O&8*1LasLVbNGkpGPJ|L`o-unLlIZ;rO literal 0 HcmV?d00001 diff --git a/stemroller/assets/stemroller.svg b/stemroller/assets/stemroller.svg new file mode 100644 index 0000000..dda63c9 --- /dev/null +++ b/stemroller/assets/stemroller.svg @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/stemroller/audio_engine.py b/stemroller/audio_engine.py new file mode 100644 index 0000000..60de0cc --- /dev/null +++ b/stemroller/audio_engine.py @@ -0,0 +1,307 @@ +"""Stem playback: mixes loaded stems with gain/solo/mute and a master volume in a PortAudio callback. + +The callback thread owns mixing; the UI reads position and meter levels once +per frame via snapshot(), which interpolates from a small ring of per-block +DAC timestamps so the playhead stays smooth at 240Hz. +""" + +import threading + +import numpy as np +import sounddevice as sd +import soundfile as sf +from PySide6.QtCore import Property, QObject, Signal, Slot + +RING = 64 +BLOCK = 256 + + +class AudioEngine(QObject): + playingChanged = Signal() + loadedChanged = Signal() + volumeChanged = Signal() + durationChanged = Signal() + loadFailed = Signal(str) + _loadedInternal = Signal(object, object) + + def __init__(self, parent=None): + super().__init__(parent) + self._stems: list[np.ndarray] = [] + self._names: list[str] = [] + self._sr = 44100 + self._len = 0 + self._pos = 0 + self._playing = False + self._ended = False + self._stream: sd.OutputStream | None = None + self._key = None + self._load_token = 0 + self._gain_db: list[float] = [] + self._solo: list[bool] = [] + self._mute: list[bool] = [] + self._target = np.zeros(0, np.float32) + self._current = np.zeros(0, np.float32) + self._volume = 1.0 # master slider position, 0..1 + self._master = 1.0 # master gain the callback ramps toward + self._master_cur = 1.0 + self._mix = np.zeros((4096, 2), np.float32) + self._tmp = np.zeros((4096, 2), np.float32) + # ring of (dac_time, block_start_frame, peakL, peakR); written by the audio thread + self._ring = np.zeros((RING, 4), np.float64) + self._ring_i = 0 + self._loadedInternal.connect(self._on_loaded) + + # ---- loading ------------------------------------------------------- + def load(self, key, stems: list[tuple[str, str]]): + """Load stems [(name, path)] in a background thread; replaces the current set.""" + if key == self._key and self._stems: + return + self.unload() + self._key = key + self._load_token += 1 + token = self._load_token + + def work(): + try: + arrays, sr = [], None + for name, path in stems: + data, file_sr = sf.read(path, dtype="float32", always_2d=True) + if data.shape[1] == 1: + data = np.repeat(data, 2, axis=1) + arrays.append(np.ascontiguousarray(data[:, :2])) + sr = sr or file_sr + n = min(a.shape[0] for a in arrays) + self._loadedInternal.emit((token, [s[0] for s in stems], sr), [a[:n] for a in arrays]) + except Exception as e: # surfaced in the UI as a toast + self._loadedInternal.emit((token, None, str(e)), None) + + threading.Thread(target=work, daemon=True).start() + + def _on_loaded(self, info, arrays): + token, names, sr = info + if token != self._load_token: + return + if names is None: + self.loadFailed.emit(sr) + return + self._names = names + self._sr = sr + self._stems = arrays + self._len = arrays[0].shape[0] if arrays else 0 + self._pos = 0 + k = len(arrays) + self._gain_db = [0.0] * k + self._solo = [False] * k + self._mute = [False] * k + self._target = np.ones(k, np.float32) + self._current = self._target.copy() + self._ring[:] = 0 + self.loadedChanged.emit() + self.durationChanged.emit() + + @Slot() + def unload(self): + self.pause() + self._close_stream() + self._stems, self._names, self._len, self._pos, self._key = [], [], 0, 0, None + self._load_token += 1 + self.loadedChanged.emit() + self.durationChanged.emit() + + # ---- transport ----------------------------------------------------- + @Slot() + def toggle(self): + self.pause() if self._playing else self.play() + + @Slot() + def play(self): + if not self._stems or self._playing: + return + if self._pos >= self._len - BLOCK: + self._pos = 0 + self._ended = False + if self._stream is None or self._stream.samplerate != self._sr: + self._close_stream() + self._stream = sd.OutputStream(samplerate=self._sr, channels=2, dtype="float32", + blocksize=BLOCK, latency="low", callback=self._callback) + self._ring[:] = 0 + self._playing = True + self._stream.start() + self.playingChanged.emit() + + @Slot() + def pause(self): + if not self._playing: + return + self._playing = False + if self._stream is not None: + # Rewind to what was actually heard, not what was queued to the device. + heard = self._interpolated_pos() + self._stream.stop() + self._pos = int(heard) + self.playingChanged.emit() + + @Slot(float) + def seek(self, seconds): + self._pos = int(max(0.0, min(seconds * self._sr, self._len - 1))) + self._ring[:] = 0 + self._ended = False + + def _close_stream(self): + if self._stream is not None: + try: + self._stream.close() + except Exception: + pass + self._stream = None + + # ---- mixer controls ------------------------------------------------ + @Slot(int, float) + def setGain(self, i, db): + if 0 <= i < len(self._gain_db): + self._gain_db[i] = db + self._recompute() + + @Slot(int, bool) + def setSolo(self, i, on): + if 0 <= i < len(self._solo): + self._solo[i] = on + self._recompute() + + @Slot(int, bool) + def setMute(self, i, on): + if 0 <= i < len(self._mute): + self._mute[i] = on + self._recompute() + + @Slot(float) + def setVolume(self, v): + v = max(0.0, min(1.0, float(v))) + if v != self._volume: + self._volume = v + # cubic taper: roughly even loudness steps across the slider + self._master = v ** 3 + self.volumeChanged.emit() + + def _recompute(self): + any_solo = any(self._solo) + t = np.zeros(len(self._stems), np.float32) + for i, db in enumerate(self._gain_db): + audible = self._solo[i] if any_solo else not self._mute[i] + t[i] = 10 ** (db / 20) if audible else 0.0 + self._target = t + + def mix_gains(self) -> np.ndarray: + return self._target.copy() + + def stem_gain(self, name) -> float: + i = self._names.index(name) + return 10 ** (self._gain_db[i] / 20) + + def loaded_key(self): + return self._key + + def arrays(self): + return dict(zip(self._names, self._stems)), self._sr + + # ---- audio thread -------------------------------------------------- + def _callback(self, outdata, frames, time_info, status): + pos = self._pos + n = max(0, min(frames, self._len - pos)) + mix = self._mix[:frames] + mix.fill(0) + if self._playing and n: + target, current = self._target, self._current + if len(target) != len(self._stems): + target = current = np.zeros(len(self._stems), np.float32) + ramp = None + for i, stem in enumerate(self._stems): + g0, g1 = current[i], target[i] + if g0 == 0 and g1 == 0: + continue + tmp = self._tmp[:n] + if g0 == g1: + np.multiply(stem[pos:pos + n], g1, out=tmp) + else: # click-free gain change across one block + if ramp is None: + ramp = np.linspace(0.0, 1.0, n, dtype=np.float32)[:, None] + np.multiply(stem[pos:pos + n], g0 + (g1 - g0) * ramp, out=tmp) + mix[:n] += tmp + self._current = target.copy() + m0, m1 = self._master_cur, self._master + if m0 != m1: + if ramp is None: + ramp = np.linspace(0.0, 1.0, n, dtype=np.float32)[:, None] + mix[:n] *= m0 + (m1 - m0) * ramp + self._master_cur = m1 + elif m1 != 1.0: + mix[:n] *= m1 + self._pos = pos + n + outdata[:] = mix + peak = np.abs(mix).max(axis=0) if frames else (0.0, 0.0) + dac = time_info.outputBufferDacTime + if dac <= 0: # some host APIs leave it unset; fall back to the stream clock + dac = self._stream.time + self._stream.latency + r = self._ring[self._ring_i % RING] + r[0] = dac + r[1] = pos + r[2], r[3] = peak[0], peak[1] + self._ring_i += 1 + if self._playing and pos + n >= self._len: + self._ended = True + + def _played(self, now): + ring = self._ring + return ring[(ring[:, 0] > 0) & (ring[:, 0] <= now)] + + def _interpolated_pos(self): + if self._stream is None: + return self._pos + now = self._stream.time + played = self._played(now) + if not len(played): + return self._pos if not self._playing else max(0, self._pos - BLOCK * 2) + last = played[np.argmax(played[:, 0])] + return min(self._len, last[1] + (now - last[0]) * self._sr) + + # ---- per-frame UI read --------------------------------------------- + @Slot(result="QVariantList") + def snapshot(self): + """[position_seconds, peakL, peakR, playing] for the current frame.""" + if not self._stems: + return [0.0, 0.0, 0.0, False] + if not self._playing or self._stream is None: + return [float(self._pos) / self._sr, 0.0, 0.0, False] + now = self._stream.time + played = self._played(now) + if len(played): + last = played[np.argmax(played[:, 0])] + pos = min(self._len, last[1] + (now - last[0]) * self._sr) + l, r = float(last[2]), float(last[3]) + else: + pos, l, r = self._pos, 0.0, 0.0 + if self._ended and pos >= self._len - 1: + self._playing = False + self._stream.stop() + self._pos = 0 + self.playingChanged.emit() + return [0.0, 0.0, 0.0, False] + return [float(pos) / self._sr, l, r, True] + + # ---- properties ---------------------------------------------------- + def _get_playing(self): + return self._playing + + def _get_loaded(self): + return bool(self._stems) + + def _get_duration(self): + return self._len / self._sr if self._stems else 0.0 + + def _get_volume(self): + return self._volume + + playing = Property(bool, _get_playing, notify=playingChanged) + loaded = Property(bool, _get_loaded, notify=loadedChanged) + duration = Property(float, _get_duration, notify=durationChanged) + volume = Property(float, _get_volume, setVolume, notify=volumeChanged) diff --git a/stemroller/catalog.py b/stemroller/catalog.py new file mode 100644 index 0000000..72914d2 --- /dev/null +++ b/stemroller/catalog.py @@ -0,0 +1,51 @@ +"""Model catalog and stem metadata shared by the UI and the worker. + +Kept free of torch imports so the UI process stays light. +""" + +DEMUCS_4 = ["drums", "bass", "other", "vocals"] +DEMUCS_6 = ["drums", "bass", "other", "vocals", "guitar", "piano"] + +MODELS = [ + {"id": "htdemucs", "label": "HT Demucs", "family": "demucs", + "stems": DEMUCS_4, "note": "Fast 4-stem"}, + {"id": "htdemucs_ft", "label": "HT Demucs FT", "family": "demucs", + "stems": DEMUCS_4, "note": "Fine-tuned 4-stem, ~4x slower"}, + {"id": "htdemucs_6s", "label": "HT Demucs 6-stem", "family": "demucs", + "stems": DEMUCS_6, "note": "Adds guitar and piano"}, + {"id": "roformer_bs_vocals", "label": "BS-RoFormer Vocals", "family": "roformer", + "file": "model_bs_roformer_ep_317_sdr_12.9755.ckpt", + "stems": ["vocals", "instrumental"], "note": "Viperx 1297, vocals / instrumental"}, + {"id": "roformer_mel_kim_ft", "label": "Mel-RoFormer Vocals FT", "family": "roformer", + "file": "mel_band_roformer_kim_ft_unwa.ckpt", + "stems": ["vocals", "instrumental"], "note": "Kim FT by unwa, cleanest vocals"}, + {"id": "roformer_bs_sw", "label": "BS-RoFormer SW 6-stem", "family": "roformer", + "file": "BS-Roformer-SW.ckpt", + "stems": DEMUCS_6, "note": "jarredou, 6-stem RoFormer"}, +] + +MODELS_BY_ID = {m["id"]: m for m in MODELS} + +STEM_COLORS = { + "vocals": "#FF7AB6", + "drums": "#FFB547", + "bass": "#7C8CFF", + "other": "#4CD07D", + "guitar": "#FF8A5C", + "piano": "#B48CFF", + "instrumental": "#3DD6C6", +} + +# Lane order in the UI, regardless of the order a model emits stems in. +STEM_ORDER = ["vocals", "drums", "bass", "guitar", "piano", "other", "instrumental"] + + +def stems_for(model_id: str, two_stems: bool) -> list[str]: + stems = MODELS_BY_ID[model_id]["stems"] + if two_stems and "vocals" in stems: + return ["vocals", "instrumental"] + return stems + + +def sort_stems(names): + return sorted(names, key=lambda n: STEM_ORDER.index(n) if n in STEM_ORDER else 99) diff --git a/stemroller/controller.py b/stemroller/controller.py new file mode 100644 index 0000000..e1607e6 --- /dev/null +++ b/stemroller/controller.py @@ -0,0 +1,542 @@ +"""App controller: queue, dispatch to the worker, cache, export. Exposed to QML as `app`.""" + +import hashlib +import json +import os +import shutil +import threading +import time +import uuid + +import numpy as np +import soundfile as sf +from PySide6.QtCore import Property, QObject, QUrl, Signal, Slot +from PySide6.QtGui import QDesktopServices + +from .catalog import MODELS, MODELS_BY_ID, STEM_COLORS, sort_stems +from .jobs_model import Job, JobsModel +from .settings import Settings +from .worker_client import WorkerClient + +CACHE_ROOT = os.path.join(os.path.expanduser("~/.cache/stemroller"), "stems") +AUDIO_EXTS = {".mp3", ".wav", ".flac", ".ogg", ".oga", ".opus", ".m4a", ".aac", ".aif", ".aiff", + ".wma", ".mp4", ".mkv", ".webm", ".mka", ".alac", ".wv", ".ape"} + + +def _cpu_name(): + try: + with open("/proc/cpuinfo") as f: + for line in f: + if line.startswith("model name"): + return line.split(":", 1)[1].strip().replace(" 8-Core Processor", "") + except OSError: + pass + return "CPU" + + +def _fmt_mb(mb): + return f"{mb / 1024:.1f} GB" + + +def _dir_size(path): + total = 0 + for root, _, files in os.walk(path): + for f in files: + try: + total += os.path.getsize(os.path.join(root, f)) + except OSError: + pass + return total + + +class Controller(QObject): + selectedChanged = Signal() + devicesChanged = Signal() + vramChanged = Signal() + workerStateChanged = Signal() + cacheChanged = Signal() + toast = Signal(str, str, str) # message, kind (info|success|error), folder to open ("" = none) + _exportDone = Signal(str, str, str) + _cacheSized = Signal(int) + + def __init__(self, audio, peak_store, parent=None): + super().__init__(parent) + self.settings = Settings(self) + self.jobs = JobsModel(self) + self.audio = audio + self.peak_store = peak_store + self._selected_id = "" + self._set_running("") + self._devices = [{"id": "auto", "label": "Auto", "sub": "Starting engine…"}, + {"id": "cpu", "label": "CPU", "sub": _cpu_name()}] + self._gpus = [] + self._vram = {} # device -> (free_mb, total_mb) + self._cache_bytes = 0 + self._exporting = False + + self.worker = WorkerClient(self) + self.worker.stateChanged.connect(lambda _: (self.workerStateChanged.emit(), self._dispatch())) + self.worker.hello.connect(self._on_hello) + self.worker.vram.connect(self._on_vram) + self.worker.progress.connect(self._on_progress) + self.worker.done.connect(self._on_done) + self.worker.failed.connect(self._on_failed) + self.worker.cancelled.connect(self._on_cancelled) + self.worker.crashed.connect(self._on_crashed) + self._exportDone.connect(self._on_export_done) + self._cacheSized.connect(self._on_cache_sized) + self.settings.deviceIdChanged.connect(self.vramChanged) + self.settings.modelIdChanged.connect(self.selectedChanged) + self.settings.twoStemsChanged.connect(self.selectedChanged) + self.settings.outputModeChanged.connect(self.selectedChanged) + self.settings.stemsDirChanged.connect(self.selectedChanged) + self.audio.loadedChanged.connect(self.selectedChanged) + self.audio.loadFailed.connect(lambda m: self.toast.emit(f"Could not load stems: {m}", "error", "")) + self.audio.setVolume(self.settings.get("masterVolume")) + self.worker.start() + self.refreshCacheSize() + + # ---- worker events ------------------------------------------------- + def _on_hello(self, msg): + self._gpus = msg["devices"] + devs = [] + if self._gpus: + best = max(self._gpus, key=lambda d: d["total_mb"]) + devs.append({"id": "auto", "label": "Auto", "sub": best["name"]}) + for d in self._gpus: + devs.append({"id": d["id"], "label": d["name"].replace("AMD ", ""), + "sub": f"{d['arch']} · {_fmt_mb(d['total_mb'])}"}) + else: + devs.append({"id": "auto", "label": "Auto", "sub": "No GPU found, using CPU"}) + devs.append({"id": "cpu", "label": "CPU", "sub": _cpu_name()}) + self._devices = devs + self.devicesChanged.emit() + self.selectedChanged.emit() + + def _on_vram(self, device, free_mb, total_mb): + self._vram[device] = (free_mb, total_mb) + if device == self._effective_gpu(): + self.vramChanged.emit() + + def _on_progress(self, job_id, pct, stage): + job = self.jobs.get(job_id) + if job and job.status == "running": + self.jobs.update(job_id, progress=max(job.progress, pct), stage=stage) + if job_id == self._selected_id: + self.selectedChanged.emit() + + def _on_done(self, job_id, result): + job = self.jobs.get(job_id) + self._set_running("") + if job: + self.jobs.update(job_id, status="done", progress=1.0, stage="Done", result=result, + elapsed=time.monotonic() - job.started) + if job_id == self._selected_id: + self._load_selected() + self.selectedChanged.emit() + if self.settings.get("autoExport"): + self._export(job, [s["name"] for s in result["stems"]], mix=False, auto=True) + self._prune_cache() + self._dispatch() + + def _on_failed(self, job_id, msg): + if job_id == self._running_id: + self._set_running("") + job = self.jobs.get(job_id) + if job: + self.jobs.update(job_id, status="error", stage="Failed", message=msg) + if job_id == self._selected_id: + self.selectedChanged.emit() + self.toast.emit(f"{job.file_name}: {msg}", "error", "") + self._dispatch() + + def _on_cancelled(self, job_id): + if job_id == self._running_id: + self._set_running("") + if self.jobs.get(job_id): + self.jobs.update(job_id, status="cancelled", stage="Cancelled", progress=0.0) + if job_id == self._selected_id: + self.selectedChanged.emit() + self._dispatch() + + def _on_crashed(self): + if self._running_id: + self._on_failed(self._running_id, "The separation engine crashed; restarting it.") + + def _set_running(self, job_id): + self._running_id = job_id + self.workerStateChanged.emit() + + # ---- queue --------------------------------------------------------- + def _cache_dir(self, path, model_id, two_stems): + st = os.stat(path) + key = hashlib.sha1(f"{os.path.realpath(path)}|{st.st_size}|{st.st_mtime_ns}".encode()).hexdigest()[:16] + return os.path.join(CACHE_ROOT, f"{key}_{model_id}{'_2s' if two_stems else ''}") + + def _enqueue(self, path): + model_id = self.settings.get("modelId") + if model_id not in MODELS_BY_ID: + model_id = "htdemucs" + two = self.settings.get("twoStems") and "vocals" in MODELS_BY_ID[model_id]["stems"] \ + and len(MODELS_BY_ID[model_id]["stems"]) > 2 + cache_dir = self._cache_dir(path, model_id, two) + job = Job(id=uuid.uuid4().hex[:12], file=path, file_name=os.path.basename(path), + model_id=model_id, model_label=MODELS_BY_ID[model_id]["label"] + (" · 2-stem" if two else ""), + two_stems=two, device_id=self.settings.get("deviceId"), cache_dir=cache_dir) + meta_path = os.path.join(cache_dir, "meta.json") + if os.path.exists(meta_path): + try: + with open(meta_path) as f: + meta = json.load(f) + if all(os.path.exists(s["path"]) for s in meta["stems"]): + os.utime(cache_dir) # LRU touch + job.status, job.progress, job.stage = "done", 1.0, "Done (cached)" + job.result = {k: meta[k] for k in ("stems", "peaks_path", "samplerate", "duration")} + job.result["device"] = meta.get("device", "") + except (OSError, ValueError, KeyError): + pass + self.jobs.add(job) + return job + + @Slot("QVariantList") + def addUrls(self, urls): + paths = [] + for u in urls: + if isinstance(u, QUrl): + p = u.toLocalFile() + else: + p = QUrl(u).toLocalFile() if str(u).startswith("file:") else str(u) + if os.path.isdir(p): + for root, _, files in os.walk(p): + paths += [os.path.join(root, f) for f in sorted(files)] + else: + paths.append(p) + paths = [p for p in paths if os.path.splitext(p)[1].lower() in AUDIO_EXTS and os.path.isfile(p)] + if not paths: + self.toast.emit("No audio files in that drop.", "info", "") + return + first = None + for p in paths: + job = self._enqueue(p) + first = first or job + if not self._selected_id or not self.jobs.get(self._selected_id) or len(paths) == 1: + self.select(first.id) + self._dispatch() + + def _dispatch(self): + if self._running_id or self.worker.state != "ready": + return + job = next((j for j in self.jobs.jobs if j.status == "queued"), None) + if not job: + return + s = self.settings + ok = self.worker.send("start", id=job.id, file=job.file, model=job.model_id, device=job.device_id, + two_stems=job.two_stems, out_dir=job.cache_dir, segment=s.get("segment"), + shifts=s.get("shifts"), overlap=s.get("overlap"), fp16=s.get("fp16")) + if ok: + self._set_running(job.id) + self.jobs.update(job.id, status="running", stage="Starting", progress=0.0, message="", + started=time.monotonic()) + if job.id == self._selected_id: + self.selectedChanged.emit() + + @Slot(str) + def cancelJob(self, job_id): + job = self.jobs.get(job_id) + if not job: + return + if job.status == "running": + self.jobs.update(job_id, stage="Cancelling") + self.worker.send("cancel", id=job_id) + elif job.status == "queued": + self.jobs.update(job_id, status="cancelled", stage="Cancelled") + if job_id == self._selected_id: + self.selectedChanged.emit() + + @Slot(str) + def removeJob(self, job_id): + job = self.jobs.get(job_id) + if not job: + return + if job.status == "running": + self.cancelJob(job_id) + row = self.jobs.row_of(job_id) + self.jobs.remove(job_id) + self.peak_store.drop(job_id) + if job_id == self._selected_id: + nxt = self.jobs.jobs[min(row, len(self.jobs.jobs) - 1)].id if self.jobs.jobs else "" + self.select(nxt) + + @Slot(str) + def retryJob(self, job_id): + job = self.jobs.get(job_id) + if job and job.status in ("error", "cancelled"): + self.jobs.update(job_id, status="queued", stage="Waiting", progress=0.0, message="") + if job_id == self._selected_id: + self.selectedChanged.emit() + self._dispatch() + + @Slot() + def rerunSelected(self): + job = self.jobs.get(self._selected_id) + if job: + new = self._enqueue(job.file) + self.select(new.id) + self._dispatch() + + @Slot(str) + def select(self, job_id): + if job_id == self._selected_id: + return + self._selected_id = job_id + self._load_selected() + self.selectedChanged.emit() + + def _load_selected(self): + job = self.jobs.get(self._selected_id) + if job and job.status == "done": + stems = sort_stems([s["name"] for s in job.result["stems"]]) + by_name = {s["name"]: s["path"] for s in job.result["stems"]} + self.audio.load(job.id, [(n, by_name[n]) for n in stems]) + else: + self.audio.unload() + + # ---- export -------------------------------------------------------- + def _target_dir(self, job): + base = os.path.splitext(job.file_name)[0] + if self.settings.get("outputMode") == "folder": + return os.path.join(self.settings.get("stemsDir"), base) + return os.path.join(os.path.dirname(job.file), f"{base} - stems") + + def _export(self, job, names, mix, auto=False): + if self._exporting: + self.toast.emit("An export is already running.", "info", "") + return + self._exporting = True + fmt = self.settings.get("exportFormat") + target = self._target_dir(job) + base = os.path.splitext(job.file_name)[0] + loaded = self.audio.loaded_key() == job.id and self.audio.loaded + if loaded: + arrays, sr = self.audio.arrays() + gains = {n: self.audio.stem_gain(n) for n in arrays} + mix_gains = dict(zip(arrays.keys(), self.audio.mix_gains())) + else: + arrays, sr, gains, mix_gains = None, job.result["samplerate"], {}, {} + paths = {s["name"]: s["path"] for s in job.result["stems"]} + + def read(name): + if arrays is not None and name in arrays: + return arrays[name] + data, _ = sf.read(paths[name], dtype="float32", always_2d=True) + return data + + def write(path, data): + if fmt == "mp3": + sf.write(path, np.clip(data, -1, 1), sr, format="MP3", subtype="MPEG_LAYER_III", + bitrate_mode="CONSTANT", compression_level=0.0) + elif fmt == "flac": + sf.write(path, np.clip(data, -1, 1), sr, format="FLAC", subtype="PCM_24") + else: + subtype = "FLOAT" if np.abs(data).max() > 0.999 else "PCM_24" + sf.write(path, data, sr, format="WAV", subtype=subtype) + + def work(): + try: + os.makedirs(target, exist_ok=True) + if mix: + out = None + for n in paths: + g = mix_gains.get(n, 1.0) + if g: + d = read(n) * g + out = d if out is None else out + d + write(os.path.join(target, f"{base} - mix.{fmt}"), out if out is not None else read(next(iter(paths))) * 0) + msg = "Exported the current mix" + else: + for n in names: + g = gains.get(n, 1.0) + d = read(n) + write(os.path.join(target, f"{base} - {n}.{fmt}"), d * g if g != 1.0 else d) + msg = f"Exported {len(names)} stem{'s' if len(names) != 1 else ''}" if not auto else \ + f"Auto-exported {len(names)} stems" + self._exportDone.emit(job.id, f"{msg} to {self._pretty(target)}", target) + except Exception as e: + self._exportDone.emit(job.id, f"Export failed: {e}", "") + + threading.Thread(target=work, daemon=True).start() + + def _on_export_done(self, job_id, msg, target): + self._exporting = False + if target and self.jobs.get(job_id): + self.jobs.update(job_id, exported_to=target) + if job_id == self._selected_id: + self.selectedChanged.emit() + self.toast.emit(msg, "success" if target else "error", target) + + @staticmethod + def _pretty(path): + home = os.path.expanduser("~") + return "~" + path[len(home):] if path.startswith(home) else path + + @Slot() + def exportAll(self): + job = self.jobs.get(self._selected_id) + if job and job.status == "done": + self._export(job, sort_stems([s["name"] for s in job.result["stems"]]), mix=False) + + @Slot(str) + def exportStem(self, name): + job = self.jobs.get(self._selected_id) + if job and job.status == "done": + self._export(job, [name], mix=False) + + @Slot() + def exportMix(self): + job = self.jobs.get(self._selected_id) + if job and job.status == "done": + self._export(job, [], mix=True) + + @Slot(str) + def openFolder(self, path): + if path and os.path.isdir(path): + QDesktopServices.openUrl(QUrl.fromLocalFile(path)) + + @Slot() + def openTargetFolder(self): + job = self.jobs.get(self._selected_id) + if job: + t = self._target_dir(job) + self.openFolder(t if os.path.isdir(t) else os.path.dirname(t)) + + # ---- cache --------------------------------------------------------- + def _referenced(self): + return {os.path.realpath(j.cache_dir) for j in self.jobs.jobs} + + def _prune_cache(self): + limit = self.settings.get("cacheLimitGb") * 2**30 + refs = self._referenced() + + def work(): + if not os.path.isdir(CACHE_ROOT): + self._cacheSized.emit(0) + return + entries = [] + for d in os.listdir(CACHE_ROOT): + p = os.path.join(CACHE_ROOT, d) + entries.append((os.path.getmtime(p), _dir_size(p), p)) + total = sum(e[1] for e in entries) + for _, size, p in sorted(entries): + if total <= limit: + break + if os.path.realpath(p) not in refs: + shutil.rmtree(p, ignore_errors=True) + total -= size + self._cacheSized.emit(total) + + threading.Thread(target=work, daemon=True).start() + + @Slot() + def refreshCacheSize(self): + threading.Thread(target=lambda: self._cacheSized.emit(_dir_size(CACHE_ROOT) if os.path.isdir(CACHE_ROOT) else 0), + daemon=True).start() + + @Slot() + def clearCache(self): + refs = self._referenced() + if os.path.isdir(CACHE_ROOT): + for d in os.listdir(CACHE_ROOT): + p = os.path.join(CACHE_ROOT, d) + if os.path.realpath(p) not in refs: + shutil.rmtree(p, ignore_errors=True) + self.refreshCacheSize() + self.toast.emit("Cleared cached stems not in the queue.", "info", "") + + def _on_cache_sized(self, n): + self._cache_bytes = n + self.cacheChanged.emit() + + # ---- QML-facing properties ----------------------------------------- + def _effective_gpu(self): + dev = self.settings.get("deviceId") + if dev == "cpu" or not self._gpus: + return "" + if dev == "auto" or not any(g["id"] == dev for g in self._gpus): + return max(self._gpus, key=lambda d: d["total_mb"])["id"] + return dev + + def peaks_path_for(self, job_id): + job = self.jobs.get(job_id) + return job.result.get("peaks_path") if job and job.status == "done" else None + + def _get_selected(self): + job = self.jobs.get(self._selected_id) + if not job: + return {"valid": False} + stems = [] + if job.status == "done": + stems = [{"name": n, "color": STEM_COLORS.get(n, "#9B9DA3")} + for n in sort_stems([s["name"] for s in job.result["stems"]])] + dev = job.result.get("device", "") if job.result else "" + dev_label = "CPU" if dev == "cpu" else next((g["name"].replace("AMD ", "") for g in self._gpus if g["id"] == dev), dev) + return { + "valid": True, "id": job.id, "fileName": job.file_name, "filePath": job.file, + "folder": self._pretty(os.path.dirname(job.file)), + "modelId": job.model_id, "modelLabel": job.model_label, "status": job.status, + "progress": job.progress, "stage": job.stage, "message": job.message, + "elapsed": job.elapsed, "duration": job.result.get("duration", 0.0) if job.result else 0.0, + "deviceLabel": dev_label, "stems": stems, + "audioReady": self.audio.loaded and self.audio.loaded_key() == job.id, + "target": self._pretty(self._target_dir(job)), "exportedTo": job.exported_to, + "rerunLabel": self._rerun_label(job), + } + + def _rerun_label(self, job): + m = self.settings.get("modelId") + two = self.settings.get("twoStems") and len(MODELS_BY_ID.get(m, {"stems": []})["stems"]) > 2 + if m == job.model_id and two == job.two_stems: + return "" + return MODELS_BY_ID[m]["label"] + (" · 2-stem" if two else "") + + def _get_models(self): + return [{"id": m["id"], "label": m["label"], "note": m["note"], "family": m["family"], + "stems": len(m["stems"])} for m in MODELS] + + def _get_devices(self): + return self._devices + + def _get_vram(self): + gpu = self._effective_gpu() + if not gpu or gpu not in self._vram: + return {"valid": False} + free, total = self._vram[gpu] + return {"valid": True, "free": free, "total": total, + "text": f"{_fmt_mb(free)} free of {_fmt_mb(total)}"} + + def _get_worker_state(self): + if self.worker.state == "ready" and self._running_id: + return "busy" + return self.worker.state + + def _get_cache_text(self): + return f"{self._cache_bytes / 2**30:.2f} GB" + + def _get_settings(self): + return self.settings + + def _get_jobs(self): + return self.jobs + + selected = Property("QVariantMap", _get_selected, notify=selectedChanged) + models = Property("QVariantList", _get_models, constant=True) + devices = Property("QVariantList", _get_devices, notify=devicesChanged) + vram = Property("QVariantMap", _get_vram, notify=vramChanged) + workerState = Property(str, _get_worker_state, notify=workerStateChanged) + cacheText = Property(str, _get_cache_text, notify=cacheChanged) + settingsObj = Property(QObject, _get_settings, constant=True) + jobsModel = Property(QObject, _get_jobs, constant=True) + + def shutdown(self): + self.settings.masterVolume = self.audio.volume + self.audio.unload() + self.worker.shutdown() diff --git a/stemroller/gpu_monitor.py b/stemroller/gpu_monitor.py new file mode 100644 index 0000000..159ecf5 --- /dev/null +++ b/stemroller/gpu_monitor.py @@ -0,0 +1,77 @@ +"""How busy the GPU is with work that isn't ours. + +Two signals, both read from the kernel (no GPU calls): + - DRM fdinfo: per-client gfx/compute engine time. Games and other apps show + up here; our ROCm worker runs through KFD and our own UI is excluded by pid. + - amdgpu gpu_busy_percent: catches other ROCm/compute users that fdinfo + misses, but also counts our worker, so it only means something while our + worker is idle. +""" + +import os +import re + +_KV = re.compile(r"^(drm-[\w-]+):\s+(\S+)", re.M) +_ENGINES = ("drm-engine-gfx", "drm-engine-compute") + + +class GpuMonitor: + def __init__(self): + self.pdev = None # "0000:03:00.0"; None counts every GPU + self.exclude: set[int] = {os.getpid()} + self._last: dict[str, int] = {} # drm-client-id -> engine ns + self._last_t = None + + def set_device(self, pci): + if pci != self.pdev: + self.pdev = pci + self._last, self._last_t = {}, None + + def _busy_path(self): + if self.pdev: + p = f"/sys/bus/pci/devices/{self.pdev}/gpu_busy_percent" + return p if os.path.exists(p) else None + return None + + def _clients(self): + out = {} + for pid in os.listdir("/proc"): + if not pid.isdigit() or int(pid) in self.exclude: + continue + try: + fds = os.listdir(f"/proc/{pid}/fd") + except OSError: + continue + for fd in fds: + try: + if not os.readlink(f"/proc/{pid}/fd/{fd}").startswith("/dev/dri/"): + continue + with open(f"/proc/{pid}/fdinfo/{fd}") as f: + kv = dict(_KV.findall(f.read())) + except OSError: + continue + cid = kv.get("drm-client-id") + if not cid or (self.pdev and kv.get("drm-pdev") != self.pdev): + continue + # one client can sit behind several dup'd fds; count it once + out[cid] = sum(int(kv[k]) for k in _ENGINES if kv.get(k, "").isdigit()) + return out + + def sample(self, now): + """(other_fraction, busy_percent). other_fraction is engine time used by + other processes over the last interval, as a fraction of wall time.""" + clients = self._clients() + other = 0.0 + if self._last_t is not None and now > self._last_t: + delta = sum(ns - self._last[c] for c, ns in clients.items() if c in self._last and ns >= self._last[c]) + other = delta / ((now - self._last_t) * 1e9) + self._last, self._last_t = clients, now + pct = -1 + path = self._busy_path() + if path: + try: + with open(path) as f: + pct = int(f.read().strip()) + except (OSError, ValueError): + pass + return other, pct diff --git a/stemroller/jobs_model.py b/stemroller/jobs_model.py new file mode 100644 index 0000000..47bbdad --- /dev/null +++ b/stemroller/jobs_model.py @@ -0,0 +1,82 @@ +"""Queue of separation jobs as a QML list model.""" + +from dataclasses import dataclass, field + +from PySide6.QtCore import QAbstractListModel, QByteArray, QModelIndex, Qt, Signal + + +@dataclass +class Job: + id: str + file: str + file_name: str + model_id: str + model_label: str + two_stems: bool + device_id: str + cache_dir: str + status: str = "queued" # queued | running | done | error | cancelled + progress: float = 0.0 + stage: str = "Waiting" + message: str = "" + started: float = 0.0 + elapsed: float = 0.0 + result: dict = field(default_factory=dict) + exported_to: str = "" + + +ROLES = ["jobId", "fileName", "filePath", "modelLabel", "status", "progress", "stage", "message", "elapsed"] +_ATTR = {"jobId": "id", "fileName": "file_name", "filePath": "file", "modelLabel": "model_label"} + + +class JobsModel(QAbstractListModel): + countChanged = Signal() + + def __init__(self, parent=None): + super().__init__(parent) + self.jobs: list[Job] = [] + self._roles = {Qt.ItemDataRole.UserRole + i: name for i, name in enumerate(ROLES)} + + def roleNames(self): + return {k: QByteArray(v.encode()) for k, v in self._roles.items()} + + def rowCount(self, parent=QModelIndex()): + return 0 if parent.isValid() else len(self.jobs) + + def data(self, index, role=Qt.ItemDataRole.DisplayRole): + if not index.isValid() or role not in self._roles: + return None + name = self._roles[role] + return getattr(self.jobs[index.row()], _ATTR.get(name, name)) + + def get(self, job_id) -> Job | None: + return next((j for j in self.jobs if j.id == job_id), None) + + def row_of(self, job_id) -> int: + return next((i for i, j in enumerate(self.jobs) if j.id == job_id), -1) + + def add(self, job: Job): + n = len(self.jobs) + self.beginInsertRows(QModelIndex(), n, n) + self.jobs.append(job) + self.endInsertRows() + self.countChanged.emit() + + def remove(self, job_id): + row = self.row_of(job_id) + if row >= 0: + self.beginRemoveRows(QModelIndex(), row, row) + del self.jobs[row] + self.endRemoveRows() + self.countChanged.emit() + + def update(self, job_id, **changes): + row = self.row_of(job_id) + if row < 0: + return + job = self.jobs[row] + for k, v in changes.items(): + setattr(job, k, v) + idx = self.index(row) + roles = [r for r, name in self._roles.items() if _ATTR.get(name, name) in changes or name in changes] + self.dataChanged.emit(idx, idx, roles) diff --git a/stemroller/library_core.py b/stemroller/library_core.py new file mode 100644 index 0000000..957799e --- /dev/null +++ b/stemroller/library_core.py @@ -0,0 +1,107 @@ +"""Library rules for the server daemon (server/stemd.py): which file is a track's source, +where its stems go, and what marks it done. stemserve reads the same layout and marker. + +No Qt here, so the server container doesn't need PySide6. + + /Artist/Album/01 Song.flac -> /Artist/Album/01 Song/01 Song - vocals.flac, ... +""" + +import errno +import json +import os +import shutil +import subprocess +import time + +import numpy as np +import soundfile as sf + +from .catalog import sort_stems + +MARKER = ".stemroller.json" +BEST_MODEL = "roformer_bs_sw" +MAX_SECONDS = 40 * 60 # longer files are mixes and radio rips +# Lower wins when one folder holds the same track in several formats. +SOURCE_RANK = {".flac": 0, ".wav": 0, ".aif": 0, ".aiff": 0, ".wv": 0, ".ape": 0, ".alac": 0, + ".m4a": 1, ".opus": 2, ".ogg": 2, ".oga": 2, ".mp3": 3, ".aac": 3, ".wma": 4} +# Errors that mean the destination as a whole is unusable, not just this track. +SHARE_ERRNOS = {errno.ENOSPC, errno.EROFS, errno.EDQUOT, errno.ENOTCONN, errno.EHOSTDOWN, + errno.EHOSTUNREACH, errno.ETIMEDOUT, errno.EIO, errno.EACCES} + + +def duration(path): + if os.path.splitext(path)[1].lower() in (".flac", ".wav", ".aif", ".aiff"): + try: + return sf.info(path).duration + except Exception: + pass + try: + out = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path], + capture_output=True, text=True, timeout=30).stdout + return float(out.strip()) + except (OSError, ValueError, subprocess.SubprocessError): + return None + + +def is_share_error(e): + return isinstance(e, OSError) and e.errno in SHARE_ERRNOS + + +def iter_tracks(src, dst): + """Yield (source path, stems folder) for every track under src, best format per name.""" + dst_real = os.path.realpath(dst) + for root, dirs, files in os.walk(src): + dirs[:] = sorted((d for d in dirs if not d.startswith(".") + and os.path.realpath(os.path.join(root, d)) != dst_real), key=str.casefold) + best = {} + for f in files: + stem, ext = os.path.splitext(f) + rank = SOURCE_RANK.get(ext.lower()) + if rank is None or f.startswith("."): + continue + key = stem.casefold() + if key not in best or rank < best[key][0]: + best[key] = (rank, f) + for _, f in sorted(best.values(), key=lambda v: v[1].casefold()): + path = os.path.join(root, f) + yield path, os.path.join(dst, os.path.splitext(os.path.relpath(path, src))[0]) + + +def is_done(dest): + return os.path.exists(os.path.join(dest, MARKER)) + + +def signature(path): + """[size, mtime_ns]: a failed track is retried once its source changes.""" + st = os.stat(path) + return [st.st_size, st.st_mtime_ns] + + +def write_track(dest, stems, meta): + """Write stems into dest as 24-bit FLAC, then the marker, so a half-written track is redone. + + stems maps name -> a path to read, or float32 (samples, channels) audio; meta needs + "samplerate" and is stored in the marker along with the stem list. + """ + base = os.path.basename(dest) + parent = os.path.dirname(dest) + part = os.path.join(parent, f".{base}.partial") + shutil.rmtree(part, ignore_errors=True) + os.makedirs(part) + written = [] + for name in sort_stems(list(stems)): + data, sr = stems[name], meta["samplerate"] + if isinstance(data, str): + data, sr = sf.read(data, dtype="float32", always_2d=True) + fname = f"{base} - {name}.flac" + sf.write(os.path.join(part, fname), np.clip(data, -1, 1), sr, format="FLAC", subtype="PCM_24") + written.append({"name": name, "file": fname}) + meta = dict(meta, stems=written, finished=time.time()) + with open(os.path.join(part, MARKER), "w") as f: + json.dump(meta, f, indent=2) + if not os.path.exists(dest): + os.rename(part, dest) + else: # keep whatever else is in there; the marker lands last + for name in [s["file"] for s in written] + [MARKER]: + os.replace(os.path.join(part, name), os.path.join(dest, name)) + os.rmdir(part) diff --git a/stemroller/player/README.md b/stemroller/player/README.md new file mode 100644 index 0000000..d6be019 --- /dev/null +++ b/stemroller/player/README.md @@ -0,0 +1,59 @@ +# StemRoller Player + +The desktop counterpart to the phone app: your Plex library and its stems, with per-stem +faders, mute/solo, mix presets and a master volume. It is dressed as Microsoft Excel 2016. + +```sh +stemroller-player # or "StemRoller Player" in the app grid (scripts/install-desktop.sh) +``` + +## First run + +**Data → Connect to Plex** (or click **Sign in** on the title bar), then enter the 4-character +code at plex.tv/link. It picks the music library at `…/Flacs`. Until then the workbook is built +from the stem server's index alone (artist / album / song from the stems folders), so every +separated song is already playable. + +## Where things are + +| Excel | Here | +|---|---| +| Sheets: Songs, Artists, Albums, Playlists, Stems, Queue | The library. Double-click (or Enter) plays a song from that point, or opens an artist, album or playlist as a new sheet. Backspace / middle-click closes it | +| Row 1 filter buttons, Sort & Filter | Sort by any column | +| "Tell me what you want to do" | Search (Ctrl+F). Results open as a sheet | +| Status bar Average / Count / Sum | Select a range of times and it adds them up | +| Zoom slider | Master volume (scroll on it, too). Ctrl+scroll on the grid is the real zoom | +| Home → Cell Styles | Mix presets: Full Mix, Karaoke ("Bad"), A Cappella ("Good"), No Drums, Rhythm, No Guitar, No Bass | +| Home → Cells | Play Next, Add to Queue, Delete Rows (queue or playlist) | +| Insert → Playlists | New Plex playlist from the selection, or add the selection to one | +| AutoSum | AutoShuffle: shuffle the whole sheet | +| Quick Access Toolbar | Play/Pause, Undo = previous song, Redo = next song | +| Format Mix task pane | Now playing, a sparkline of the song to seek on, and the stems as a column chart: drag a column to set its level, double-click for 0 dB, M / S below | +| Green triangle in a cell | The song that's playing | +| `#GETTING_DATA` | A playlist loading from Plex | +| File → Info / Account / Options | Library and server status, Plex sign-in, server addresses and folders | + +Keys: Space play/pause, Ctrl+←/→ previous/next, V vocals on/off, arrows/Shift+arrows select, +Ctrl+C copies cells as text, Ctrl+Q quits. The media keys, the desktop's media controls and +KDE Connect on the phone work through MPRIS. + +## How it plays + +- **Stems** come straight off the `Stems` share (`/var/mnt/unraid/Music/Stems`) when it's + mounted, else they're downloaded from stemserve once into `~/.cache/stemroller/player/files` + (4 GB, oldest first out). Songs without stems play the original from the music share, or from + Plex if the share isn't there. +- A decoder thread reads every stem about 1.5 s ahead of the playhead, so songs start at once + and nothing is decoded whole; the audio callback mixes with click-free gain ramps. The fader + taper matches the phone (0.8 = 0 dB, top = +3.9 dB). +- Plays are reported to Plex (now playing, and the play count at 90%). +- Album art: Plex's, or the album folder's `cover.*`, or the picture embedded in the file. +- The queue, position, mix and volume come back on the next launch (`~/.config/stemroller/`). + +## Checking it without a window + +```sh +QT_QPA_PLATFORM=offscreen stemroller-player --no-mpris --screenshot /tmp/p.png@5 --quit-after 6 +``` + +`--eval 'JS@seconds'` runs JavaScript against the window (e.g. `library.activate(0, 0)@2`). diff --git a/stemroller/player/__init__.py b/stemroller/player/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/stemroller/player/__main__.py b/stemroller/player/__main__.py new file mode 100644 index 0000000..ac99fd1 --- /dev/null +++ b/stemroller/player/__main__.py @@ -0,0 +1,5 @@ +import sys + +from .app import main + +sys.exit(main()) diff --git a/stemroller/player/app.py b/stemroller/player/app.py new file mode 100644 index 0000000..88918a3 --- /dev/null +++ b/stemroller/player/app.py @@ -0,0 +1,136 @@ +"""StemRoller Player: the Plex library and its stems, in a workbook.""" + +import argparse +import os +import signal +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) + + +def main(): + os.environ.setdefault("QT_QUICK_CONTROLS_STYLE", "Basic") + os.environ.setdefault("QT_QPA_PLATFORM", "wayland;xcb") + os.environ.setdefault("QSG_RENDER_LOOP", "threaded") + ap = argparse.ArgumentParser(prog="stemroller-player") + ap.add_argument("--screenshot", action="append", default=[], metavar="PNG@SECONDS", + help="grab the window to PNG after N seconds (repeatable; for headless checks)") + ap.add_argument("--quit-after", type=float, default=0, metavar="SECONDS") + ap.add_argument("--size", default="", metavar="WxH") + ap.add_argument("--no-mpris", action="store_true") + ap.add_argument("--eval", action="append", default=[], metavar="JS@SECONDS", + help="run a JavaScript snippet against the window after N seconds (dev)") + args = ap.parse_args() + + from PySide6.QtCore import QTimer, QUrl + from PySide6.QtGui import QFontDatabase, QGuiApplication, QIcon, QSurfaceFormat + from PySide6.QtQml import QQmlApplicationEngine + + fmt = QSurfaceFormat.defaultFormat() + fmt.setSwapInterval(1) + QSurfaceFormat.setDefaultFormat(fmt) + + app = QGuiApplication(sys.argv) + app.setApplicationName("StemRoller Player") + app.setOrganizationName("stemroller") + app.setDesktopFileName("stemroller-player") + app.setWindowIcon(QIcon(os.path.join(HERE, "assets", "stemroller-player.svg"))) + for d in (os.path.join(HERE, "assets", "fonts"), os.path.join(HERE, "..", "assets", "fonts")): + if os.path.isdir(d): + for f in sorted(os.listdir(d)): + if f.endswith((".ttf", ".otf")): + QFontDatabase.addApplicationFont(os.path.join(d, f)) + families = set(QFontDatabase.families()) + # Excel: Segoe UI for the chrome, Calibri (or its metric twin Carlito) in the cells. + ui_font = next((f for f in ("Segoe UI", "Selawik", "Inter") if f in families), "sans-serif") + cell_font = next((f for f in ("Aptos", "Calibri", "Carlito") if f in families), ui_font) + + from . import config + from .engine import PlayerEngine + from .icons import IconProvider + from .library import Library + from .player import Player + from .plex import Plex + from .stems import StemServer + + cfg = config.load() + plex = Plex(cfg) + stems = StemServer(cfg, config.CACHE_DIR) + engine = PlayerEngine() + library = Library(cfg, plex, stems) + player = Player(cfg, plex, stems, engine) + library.player = player + player.library = library + library.update_queue() + + qml = QQmlApplicationEngine() + qml.addImageProvider("icon", IconProvider()) + qml.addImportPath(os.path.join(HERE, "qml")) + ctx = qml.rootContext() + ctx.setContextProperty("library", library) + ctx.setContextProperty("sheetModel", library.model) + ctx.setContextProperty("player", player) + ctx.setContextProperty("engine", engine) + settings = _Settings(cfg) + ctx.setContextProperty("settings", settings) + ctx.setContextProperty("uiFont", ui_font) + ctx.setContextProperty("cellFont", cell_font) + qml.load(QUrl.fromLocalFile(os.path.join(HERE, "qml", "StemPlayer", "Main.qml"))) + if not qml.rootObjects(): + print("failed to load QML", file=sys.stderr) + return 1 + window = qml.rootObjects()[0] + if args.size: + w, h = (int(v) for v in args.size.split("x")) + window.resize(w, h) + + if not args.no_mpris: + from .mpris import Mpris + mpris = Mpris(player, engine, lambda: (window.show(), window.raise_(), window.requestActivate()), app.quit) + window.setProperty("mprisOk", mpris.ok) + + for e in args.eval: + code, _, after = e.rpartition("@") + QTimer.singleShot(int(float(after) * 1000), lambda code=code: window.setProperty("devEval", code)) + for shot in args.screenshot: + path, _, after = shot.rpartition("@") + QTimer.singleShot(int(float(after) * 1000), + lambda path=path: (window.grabWindow().save(path), print("screenshot saved", path, flush=True))) + if args.quit_after: + QTimer.singleShot(int(args.quit_after * 1000), app.quit) + + signal.signal(signal.SIGINT, lambda *_: app.quit()) + keepalive = QTimer() + keepalive.start(500) + keepalive.timeout.connect(lambda: None) + + def shutdown(): + player.shutdown() + engine.shutdown() + config.save(cfg) + app.aboutToQuit.connect(shutdown) + rc = app.exec() + del qml + return rc + + +def _Settings(cfg): + """Editable settings for File → Options.""" + from PySide6.QtCore import QObject, Slot + + from . import config + + class Settings(QObject): + @Slot(str, result="QVariant") + def get(self, key): + return cfg.get(key) + + @Slot(str, "QVariant") + def set(self, key, value): + cfg[key] = value + config.save(cfg) + return Settings() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/stemroller/player/assets/fonts/Carlito-Bold.ttf b/stemroller/player/assets/fonts/Carlito-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..67543b5a1efe4b910317116b02e8e9e01659692e GIT binary patch literal 682468 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 @S?PS@eC(`o@;MPs0jH3Y--&bz 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%0D)UN7`} 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%0D+iju*j6A>x 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