From 02e0a34fd0564ce25bf8a0a7cdfa6131513e6eb7 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 21 Nov 2026 13:40:48 +0000 Subject: [PATCH 1/2] Scripts read the game screen's window size from their first line A profile's scripts now read the main window's size the game screen gives from their first line, not 90 by 25 until the profile has loaded. A Geyser window that wraps to its width and prints as the profile loads, as the starter UI's chat window does, wraps at the width the player sees rather than at about 13 columns. - The engine gives a profile the sizes it was given before it opened as part of its start (Mudlet patch 0043, THeadlessSession's Options::mainWindowSize and screenSize), so they are in place before its first script runs and raise no sysWindowResizeEvent for it. - Protocol 48: the control socket takes setScreenSize and setMainWindowSize, which the engine keeps for each profile opened after them and gives to none open now, as a profile's own socket exists only once it has opened. - The app sends them before openProfile and on each attach. It keeps the last sizes the game screen gave a profile with no windows yet (StartSizes, "startSizes" in the engine preferences) with the window, text size and layout they were measured in, so the first profile opened after the app starts gets them too. Tests: StartSizesTest (JVM); start_sizes in test_mudlet_engine.py; GameSwitcherTest on the emulators. Part of Mudlet/Mudlet#9011 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016ujaeFyaqXXDx8xjoThE6J --- .../org/mudlet/android/ui/FakeEngine.kt | 3 + .../org/mudlet/android/ui/GameSwitcherTest.kt | 24 +++ .../org/mudlet/android/ui/EngineClient.kt | 63 ++++-- .../org/mudlet/android/ui/MainActivity.kt | 6 + .../org/mudlet/android/ui/game/GameScreen.kt | 2 +- .../android/ui/game/ScriptWindowsArea.kt | 5 + docs/ai-instructions.md | 4 +- docs/architecture.md | 12 +- docs/multi-profile.md | 1 + docs/phase-f.md | 5 + docs/protocol.md | 14 +- native/api/IEngineControl.h | 4 + native/enginehost/ControlBridge.cpp | 10 + native/enginehost/MudletEngine.h | 2 + native/enginehost/MudletProfile.cpp | 7 + native/enginehost/SocketBridge.cpp | 30 ++- native/enginehost/SocketBridge.h | 8 +- native/tests/protocol_client.py | 2 +- native/tests/test_mudlet_engine.py | 100 +++++++++- .../org/mudlet/android/protocol/Protocol.kt | 2 +- .../org/mudlet/android/protocol/StartSizes.kt | 52 +++++ .../mudlet/android/protocol/StartSizesTest.kt | 54 ++++++ ...3-headless-main-window-size-at-start.patch | 182 ++++++++++++++++++ 23 files changed, 558 insertions(+), 34 deletions(-) create mode 100644 protocol/src/main/kotlin/org/mudlet/android/protocol/StartSizes.kt create mode 100644 protocol/src/test/kotlin/org/mudlet/android/protocol/StartSizesTest.kt create mode 100644 scripts/mudlet-patches/0043-headless-main-window-size-at-start.patch diff --git a/app/src/androidTest/kotlin/org/mudlet/android/ui/FakeEngine.kt b/app/src/androidTest/kotlin/org/mudlet/android/ui/FakeEngine.kt index d4c4ca880..1786ca51b 100644 --- a/app/src/androidTest/kotlin/org/mudlet/android/ui/FakeEngine.kt +++ b/app/src/androidTest/kotlin/org/mudlet/android/ui/FakeEngine.kt @@ -241,6 +241,9 @@ class FakeEngine(open: List = emptyList()) : AutoCloseable { /** Every request [receive] has read from the profile's socket, the skipped ones included. */ val received: List get() = game().received + /** Every request [receive] has read from the control socket, the skipped ones included. */ + val controlReceived: List get() = control.received + /** The UI's hello on the profile's socket: "instance" and "lastSeq" when it was attached to an engine before. */ val hello: JSONObject get() = game().hello diff --git a/app/src/androidTest/kotlin/org/mudlet/android/ui/GameSwitcherTest.kt b/app/src/androidTest/kotlin/org/mudlet/android/ui/GameSwitcherTest.kt index f173f02b2..fbe3a3041 100644 --- a/app/src/androidTest/kotlin/org/mudlet/android/ui/GameSwitcherTest.kt +++ b/app/src/androidTest/kotlin/org/mudlet/android/ui/GameSwitcherTest.kt @@ -275,6 +275,30 @@ class GameSwitcherTest { compose.onNode(hasText(string(R.string.games_title))).assertDoesNotExist() } + @Test + fun aGameOpenedBesideStartsWithTheSizeTheGameScreenGaveTheLast() { + showFromTheList(ALPHA.name) + beta.receive("setFront") + waitFor(titleReading(ALPHA.name, R.string.connection_connected, 1, 2)) + // Mudlet's font, which the first mainArea tells the game screen, which then gives the main window its size + alpha.mainArea(800, 600, 100, 40, 0, 0, 800, 600) + // The test's clock recomposes only while the test waits on it, not while it reads a socket + compose.waitUntil(WAIT_MS) { EngineClient.session(ALPHA.name)?.windows?.state?.charWidth != null } + compose.waitForIdle() + val given = alpha.receiveLast("setMainWindowSize", readPast = true) + + openTheSheet() + compose.onNode(hasText(string(R.string.game_open_another)) and hasClickAction()).performScrollTo() + activate(hasText(string(R.string.game_open_another))) + activate(hasContentDescription(string(R.string.profile_connect_to, GAMMA.name))) + beta.receive("openProfile") + // On the control socket, before it: the new profile's own socket exists only once it has opened + val frames = beta.controlReceived + val before = frames.subList((frames.size - 3).coerceAtLeast(0), frames.size - 1) + assertEquals(listOf("setScreenSize", "setMainWindowSize"), before.map { it.optString("t") }) + assertEquals(given.getInt("w") to given.getInt("h"), before[1].getInt("w") to before[1].getInt("h")) + } + @Test fun openAnotherGameOpensOneBesideThoseOpen_untilAsManyAsCanBeAre() { showFromTheList(ALPHA.name) diff --git a/app/src/main/kotlin/org/mudlet/android/ui/EngineClient.kt b/app/src/main/kotlin/org/mudlet/android/ui/EngineClient.kt index 9ebea74e5..07dead762 100644 --- a/app/src/main/kotlin/org/mudlet/android/ui/EngineClient.kt +++ b/app/src/main/kotlin/org/mudlet/android/ui/EngineClient.kt @@ -31,10 +31,12 @@ import org.mudlet.android.engine.EngineSocket import org.mudlet.android.protocol.EngineLink import org.mudlet.android.protocol.EngineMessage import org.mudlet.android.protocol.EngineRestore +import org.mudlet.android.protocol.MudletSize import org.mudlet.android.protocol.OpenProfile import org.mudlet.android.protocol.OpenProfileState import org.mudlet.android.protocol.Profile import org.mudlet.android.protocol.Requests +import org.mudlet.android.protocol.StartSizes import org.mudlet.android.protocol.Transport import org.mudlet.android.ui.game.ScriptWebPages import java.io.IOException @@ -65,6 +67,7 @@ object EngineClient { private const val RESTART_AFTER_FAILED_ATTEMPTS = 6 private const val PREF_LAST_PROFILE = "lastProfile" + private const val PREF_START_SIZES = "startSizes" private const val TAG = "EngineClient" @@ -187,7 +190,12 @@ object EngineClient { var screenSize: Pair? = null private set + /** The size of the window the app is drawn in, as `WxH` in dp; MainActivity keeps it. */ + @Volatile + var window = "" + // Main thread only + private var startSizes: StartSizes? = null private var startRequestedAt = 0L private var detachStartedAt = 0L private var lostAt = 0L @@ -203,6 +211,7 @@ object EngineClient { if (::app.isInitialized) return app = context.applicationContext lastProfile = prefs().getString(PREF_LAST_PROFILE, null) + startSizes = StartSizes.decode(prefs().getString(PREF_START_SIZES, null)) } fun startEngine() { @@ -336,6 +345,12 @@ object EngineClient { sessions.forEach { it.changeSetting(setting, value) } } + /** The game screen's console size: [setScreenSize], and the one the next profile opened starts with. */ + fun setGameConsoleSize(columns: Int, rows: Int) { + keepStartSizes(StartSizes.withScreen(startSizes, startWindow(), columns, rows)) + setScreenSize(columns, rows) + } + /** The console's size, which every open profile is given: all of them would show on this screen. */ fun setScreenSize(columns: Int, rows: Int) { val size = columns to rows @@ -365,23 +380,46 @@ object EngineClient { /** Asks the engine to list its profiles again, as it does not see one added beside it, as an import adds one. */ fun refreshProfiles(onAnswer: (error: String?) -> Unit) = profileRequest(onAnswer) { Requests.listProfiles(it) } + /** The main window's [size] the game screen gives a profile that has no windows yet, which the next profile opened starts with. */ + fun setStartMainWindowSize(size: MudletSize) = keepStartSizes(StartSizes.withMainWindow(startSizes, startWindow(), size)) + + // What decides the sizes besides the window: the app's text size and layout + private fun startWindow() = "$window ${Settings.textSize.value} ${ScriptWindowsClient.layoutMode}" + + private fun keepStartSizes(sizes: StartSizes) { + if (sizes == startSizes) return + startSizes = sizes + prefs().edit { putString(PREF_START_SIZES, sizes.encode()) } + } + + // Before the profile's own socket exists to give them, so its scripts read them from their first line + private fun sendStartSizes() { + startSizes?.requestsFor(startWindow())?.forEach(::send) + } + /** Opens and connects the profile [name], closing those open; Reconnect then goes to its address, or opens it again once none is. */ - fun openProfile(name: String, password: String?, onAnswer: (error: String?) -> Unit) = profileRequest({ error -> - if (error == null) opened(name) - onAnswer(error) - }) { Requests.openProfile(name, password, proxyPassword = proxyPasswordOf(name), connect = true, alongside = false, id = it) } + fun openProfile(name: String, password: String?, onAnswer: (error: String?) -> Unit) { + sendStartSizes() + profileRequest({ error -> + if (error == null) opened(name) + onAnswer(error) + }) { Requests.openProfile(name, password, proxyPassword = proxyPasswordOf(name), connect = true, alongside = false, id = it) } + } /** * Opens and connects the profile [name], with [password] for this run, beside those open, and makes it the front; * one already open stays as it is, and comes to the front. */ - fun openProfileAlongside(name: String, password: String?, onAnswer: (error: String?) -> Unit) = profileRequest({ error -> - if (error == null) { - opened(name) - setFront(name) - } - onAnswer(error) - }) { Requests.openProfile(name, password, proxyPassword = proxyPasswordOf(name), connect = true, alongside = true, id = it) } + fun openProfileAlongside(name: String, password: String?, onAnswer: (error: String?) -> Unit) { + sendStartSizes() + profileRequest({ error -> + if (error == null) { + opened(name) + setFront(name) + } + onAnswer(error) + }) { Requests.openProfile(name, password, proxyPassword = proxyPasswordOf(name), connect = true, alongside = true, id = it) } + } /** * Opens the profile [name] without connecting it, as desktop's Offline, with [password] for a later connection; beside @@ -389,6 +427,7 @@ object EngineClient { */ fun openProfileOffline(name: String, password: String?, onAnswer: (error: String?) -> Unit) { val alongside = sessions.isNotEmpty() + sendStartSizes() profileRequest({ error -> if (error == null) { opened(name) @@ -559,6 +598,8 @@ object EngineClient { } // What it says is in front now stands: it had any setFront sent before requestedFront = null + // For the profiles a restore opens after this, as for those the player opens + sendStartSizes() // A profile's socket that went with the engine may be back: no need to wait out the link's retry sessions.forEach(ProfileSession::wake) val now = SystemClock.elapsedRealtime() diff --git a/app/src/main/kotlin/org/mudlet/android/ui/MainActivity.kt b/app/src/main/kotlin/org/mudlet/android/ui/MainActivity.kt index e94faba38..cf391f593 100644 --- a/app/src/main/kotlin/org/mudlet/android/ui/MainActivity.kt +++ b/app/src/main/kotlin/org/mudlet/android/ui/MainActivity.kt @@ -16,11 +16,14 @@ import androidx.compose.material3.AlertDialog import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable +import androidx.compose.runtime.SideEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.platform.LocalWindowInfo import androidx.compose.ui.res.stringResource import androidx.core.content.IntentCompat import androidx.core.content.edit @@ -97,6 +100,9 @@ class MainActivity : ComponentActivity() { gameLink = savedInstanceState.getString(STATE_GAME_LINK)?.let(TelnetLink::parse) } setContent { + // The window a profile opened from here will be drawn in, which the sizes it starts with are kept for + val window = with(LocalDensity.current) { LocalWindowInfo.current.containerSize.let { "${it.width.toDp().value.toInt()}x${it.height.toDp().value.toInt()}" } } + SideEffect { if (window != "0x0") EngineClient.window = window } MudletTheme { val explainEngineStopped = EngineClient.engineStoppedInBackground && !engineStoppedAnswered AppNavigation( diff --git a/app/src/main/kotlin/org/mudlet/android/ui/game/GameScreen.kt b/app/src/main/kotlin/org/mudlet/android/ui/game/GameScreen.kt index cfc4e54c8..7d6b94f36 100644 --- a/app/src/main/kotlin/org/mudlet/android/ui/game/GameScreen.kt +++ b/app/src/main/kotlin/org/mudlet/android/ui/game/GameScreen.kt @@ -467,7 +467,7 @@ private fun ProfileGameScreen( textSizeSp = textSizeSp, colors = colors, onTextSize = Settings.textSize::set, - onScreenSize = EngineClient::setScreenSize, + onScreenSize = EngineClient::setGameConsoleSize, consoleModifier.tourTarget(TourTarget.CONSOLE), links = c.links, onMakeTrigger = onMakeTrigger, diff --git a/app/src/main/kotlin/org/mudlet/android/ui/game/ScriptWindowsArea.kt b/app/src/main/kotlin/org/mudlet/android/ui/game/ScriptWindowsArea.kt index d5295c869..b288e30e1 100644 --- a/app/src/main/kotlin/org/mudlet/android/ui/game/ScriptWindowsArea.kt +++ b/app/src/main/kotlin/org/mudlet/android/ui/game/ScriptWindowsArea.kt @@ -256,6 +256,11 @@ private fun WindowsArea( // A new engine instance has none of what the last was told val attaches = EngineClient.front.attaches LaunchedEffect(layout.mainWindowSize, attaches) { layout.mainWindowSize?.let(client::setMainWindowSize) } + // What a profile with no windows yet is given here, for the next one opened before this screen has measured it + val startSize = remember(windows.charWidth, w, h, fitted, metrics, headerHeight) { + WindowLayout.of(ScriptWindows(charWidth = windows.charWidth), WindowLayout.Area(w, h, fitted, metrics.charWidth, headerHeight, null)).mainWindowSize + } + LaunchedEffect(startSize) { startSize?.let(EngineClient::setStartMainWindowSize) } LaunchedEffect(layout.placements, attaches) { for ((name, placement) in layout.placements) client.placeUserWindow(name, placement) } diff --git a/docs/ai-instructions.md b/docs/ai-instructions.md index 97d7f7f5c..05248f1a5 100644 --- a/docs/ai-instructions.md +++ b/docs/ai-instructions.md @@ -61,8 +61,8 @@ Procedures too long for this file are in `.agents/skills//SKILL.md` (Claud - Stored names are the player's data: renaming one alone orphans what players already have. Rename one only with a migration that runs before the first read, and a test that reads the old name. They are: - the application id `org.mudlet.mudlet` (`.ptb` for the PTB); - - the SharedPreferences `settings` (the keys in `data/Settings.kt`), `engine` (`qpaPlatform`, `lastProfile`, and - `lastHost:`, `lastPort:` and `lastTls:` before a profile's name) and `ui`; + - the SharedPreferences `settings` (the keys in `data/Settings.kt`), `engine` (`qpaPlatform`, `lastProfile`, + `startSizes`, and `lastHost:`, `lastPort:` and `lastTls:` before a profile's name) and `ui`; - `PasswordStore`'s file `passwords/profiles.json`, its keys (the lowercased profile name, and `proxy:` before it for the proxy's password) and KeyStore alias `profile-passwords`; - the engine's files: `files/mudlet/` (`profiles//`, `profile-order.json`, and what Mudlet keeps under the diff --git a/docs/architecture.md b/docs/architecture.md index ddbb9c024..f7c459797 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1190,6 +1190,8 @@ And the style sheet `setCmdLineStyleSheet()` gives a command line (`ScriptWindow And a profile's SOCKS5 proxy as the desktop's Connection preferences hold it, with its password given for the run as the game's is (`proxy()`, `setProxy()`, `setProxyPassword()`, `0042-headless-proxy.patch`; see `getProxy` in [`protocol.md`](protocol.md)). +And the main window's size, or the console's columns and rows, given with the start, so a profile's scripts read it from +their first line (`THeadlessSession::Options::mainWindowSize` and `screenSize`, `0043-headless-main-window-size-at-start.patch`). [`c-device.md`](decisions/hosting-results/c-device.md) has the emulator run of the earlier build, which read Mudlet's console model and needed a patch. @@ -1226,8 +1228,8 @@ keeps the profiles' passwords in the KeyStore. | `commandLineTextRequested` (`printCmdLine()` and the like) | `commandLine` | | `scriptWindows()`, read at `profileLoaded`, then at each `scriptWindowsChanged` | `windows`, only the windows that changed and those `removed`; all of them, with `full`, to a UI that attaches. A close sends an empty list | | `windowLines()`, the last 300 rows, at `profileLoaded` and at each `windowTextChanged` | `windowText`; any rows on request with `getWindowText` | -| `setMainWindowSize()`, then `mainConsoleGrid()`, `mainConsoleTextRect()` and `mainBorderColor()` at `profileLoaded` and at each `mainConsoleAreaChanged` and `mainBorderColorChanged` | `setMainWindowSize`, kept and given again to each profile as it loads; `mainArea` | -| `setScreenSize()` until the profile has the main window's size, then `setGameScreenSize()` (carried), at `profileLoaded`, at the start's end and at each change | `setScreenSize`, kept and given again to each profile as it loads | +| `Options::mainWindowSize` at the start (carried) and `setMainWindowSize()`, then `mainConsoleGrid()`, `mainConsoleTextRect()` and `mainBorderColor()` at `profileLoaded` and at each `mainConsoleAreaChanged` and `mainBorderColorChanged` | `setMainWindowSize`, kept and given to each profile as it starts, before its first script, and again as it loads; on the control socket, only kept, for the profiles opened after it; `mainArea` | +| `Options::screenSize` at the start while it has no main window's size, `setScreenSize()` until the profile has the main window's size, then `setGameScreenSize()` (carried), at `profileLoaded`, at the start's end and at each change | `setScreenSize`, kept and given to each profile as it starts and again as it loads; on the control socket, only kept, for the profiles opened after it | | `setUserWindowGeometry()`, `closeUserWindow()` | `placeUserWindow`, `closeUserWindow` | | `submitWindowCommandLine()`; `windowCommandLineTextChanged` | `sendWindowCommandLine`; `windowCommandLine` | | `labelContent()` of each label, read with `scriptWindows()` | `label` after the `windows`, for each label whose content changed; every label to a UI that attaches | @@ -1324,6 +1326,9 @@ Android options (`scripts/build-libmudlet-desktop.sh`) to run it. It checks: size and the game is told the console's columns and rows (below 40 as 40), not that size's grid, also after a new main window's size; given both before the profile loads, the same for `getMainWindowSize()` and the game; and with a main window's size the loading profile refuses, `setScreenSize` sizing the main window and reaching the game; +- the sizes given before a profile opens, on its own socket or on the control socket: its scripts read them from their + first line, so a Geyser `MiniConsole` with `autoWrap` that echoes as the profile loads wraps at the console's + columns; the control socket refusing a size as a profile's socket does, and leaving an open profile its own; - script windows: a Geyser `MiniConsole` as `windows` with its geometry, and its `cecho()` as `windowText` with its colours; a Geyser `UserWindow` placed by `placeUserWindow`, which raises `sysUserWindowResizeEvent`; the size from `setMainWindowSize` before the profile loads, `setBorderLeft()` and `setBorderColor()`, as `mainArea`; @@ -2316,6 +2321,8 @@ alias of run-lua-code, one of desktop Mudlet's default packages, which a profile grid). Narrower, the borders become bands above and below the console, and the side windows and docks become tabs below it; a tab opens its window over the console, its back button or the system's Back closes it. - A window's text is readable, its newest line in view; scrolled back, it stays put. + - A window that wraps to its width, such as the starter UI's chat window in a game with no GUI of its own, has its + first lines wrapped at its full width, also in the profile opened first after the app starts. - A console a script gave a scroll bar (`lua enableScrollBar("")`) with more rows than fit has a thumb at its right edge, which moves as the rows scroll and scrolls them when dragged; `disableScrollBar` takes it away. - With TalkBack on: swiping goes from the console to the input line, then the pinned commands, then @@ -2446,6 +2453,7 @@ alias of run-lua-code, one of desktop Mudlet's default packages, which a profile - Pinch the window with two fingers: its text grows or shrinks as the fingers move, the main console's does not, and once they lift `win ` shows on the main console and `lua echo(getFontSize("win"))` gives that size. New text in the window wraps to its new width. One finger still scrolls it, and a tap on a link in it still follows. + Text already in the window keeps the rows it had, as on the desktop. - `lua win:setFontSize(8)` changes nothing that stays: the window goes back to the pinched size. Close and reopen the profile, or kill the app and start it again: the window comes back at the pinched size. - Tap the window twice with two fingers: it goes back to 8 (the size its script last gave it), and a later diff --git a/docs/multi-profile.md b/docs/multi-profile.md index 171c3d29c..200be9ce6 100644 --- a/docs/multi-profile.md +++ b/docs/multi-profile.md @@ -83,6 +83,7 @@ New on the control socket: | `closeProfile` | UI→E | `name`, `id`? | Saves and closes that profile, with its `sysExitEvent`; its socket closes. Answered by `openProfiles` or `error`. | | `setFront` | UI→E | `name` | The profile the player is looking at: raises `sysProfileFocusChangeEvent`, as a desktop tab change does. | | `markSeen` | UI→E | `name`, `seq` | The player has seen that profile's lines up to `seq`: clears `attention`, and `unread` counts from there. | +| `setScreenSize`, `setMainWindowSize` | UI→E | as on a profile's socket | Kept, and given to each profile opened after them as it starts, so its first script reads them; no profile open now takes them (version 48). | | `openProfiles` | E→UI | `profiles`: `name`, `slot`, `socket`, `state`, `connection`, `lastSeq`, `unread`, `attention`, `front`; `re`? | Every open profile, in the order opened. `state` is `starting`, `loaded`, `closing` or `restoring`. `attention` is set by `alert()`, the bell or new data while minimized, until seen. Sent on attach and on every change (line counts coalesced to every 500 ms), and as the answer to `openProfile` and `closeProfile`. | The profile opened last becomes the front; when the front closes, the next one to the right takes over, else the one to diff --git a/docs/phase-f.md b/docs/phase-f.md index e26076120..012568826 100644 --- a/docs/phase-f.md +++ b/docs/phase-f.md @@ -158,6 +158,11 @@ everything at one scale `s` (screen pixels per Mudlet pixel): `setMainWindowSize(areaPx / s)`, where `areaPx` is the game screen's area above the input line. Mudlet's grid is then the columns and rows the app's console shows, and a border a script sets takes the same share of the screen as of Mudlet's window. A font size change or rotation sends the size again. + The app also sends the last size, and the console's columns and rows, on the control socket before `openProfile` + and as it attaches, for the profiles a restore opens (protocol 48), so the profile opened next reads them from its + first script line rather than after it has loaded. + They are kept between runs (`StartSizes`, `startSizes` in the `engine` preferences) with the window's size, the text + size and the layout they were measured in, as the profile list comes before any game screen has measured itself. - **Fitted**, when the game area is at least 600 dp wide (landscape, tablets, an unfolded phone): the main window's area is drawn as on the desktop, scaled by `s`: the console in `mainArea`'s text rectangle, the windows of the main area over it by `stack`. Docked user windows take a column on their `dockArea`'s side, a quarter of the width diff --git a/docs/protocol.md b/docs/protocol.md index c5e7225e6..7bbc6c93d 100644 --- a/docs/protocol.md +++ b/docs/protocol.md @@ -11,7 +11,7 @@ How the UI process talks to the engine process, as implemented by: the same messages and fields, and that all of them, and the Python client, use the same protocol version. Change this file in the same commit as the code. -The current version is **47**. +The current version is **48**. ## Transport @@ -63,7 +63,7 @@ message, in backquotes, with `?` after an optional one, and the fields of the ob | `complete` | `text`, `fromHistory`?, `id`? | Completes the input line `text`, answered by status `completion`: the whole completed line, or empty for none. `fromHistory` true completes it from the history, as the up arrow does in Mudlet with "Highlight history" on: the newest line that starts with `text`. Otherwise, as Tab, it completes the last word from the words the game sent lately and those scripts suggested. A `complete` whose `text` is the line the last one answered goes on to the next word or older line. libmudlet runs `setCommandLineText()`, then `completeCommandLine()` or `completeCommandLineFromHistory()`; nothing completes while input is hidden. A `fromHistory` that is not a boolean gets `error`. | | `disconnect` | | Closes the game connection. | | `runLua` | `code`, `id` | Runs Lua in the engine. The result comes back as status `luaResult` with `re` set to `id`. | -| `setScreenSize` | `columns`, `rows` | The UI's console in characters of the font it draws in, each a whole number from 1 to 65535 (else `error`): the UI does the measuring. A game that asks (telnet NAWS) is told it. libmudlet gives it to each profile as it loads and to the running one at once: to `setScreenSize()`, so the profile's scripts read it as the main window's size, until `setMainWindowSize` has given that size, and from then on to `setGameScreenSize()` (carried in `scripts/mudlet-patches/`), which tells the game the console's size and leaves the main window's alone; as in Mudlet, a width below 40 counts as 40, the game is told no more than the profile's wrap width, and of a change once the size has held for 0.3 s. Until the UI sends one, a game is told the main console's grid: that of the size `setMainWindowSize` gave, or 90 by 25. | +| `setScreenSize` | `columns`, `rows` | The UI's console in characters of the font it draws in, each a whole number from 1 to 65535 (else `error`): the UI does the measuring. A game that asks (telnet NAWS) is told it. libmudlet gives it to each profile as it starts, before its first script runs (`THeadlessSession::Options::screenSize`, carried in `scripts/mudlet-patches/`), and to the running one at once: to `setScreenSize()`, so the profile's scripts read it as the main window's size, until `setMainWindowSize` has given that size, and from then on to `setGameScreenSize()` (carried in `scripts/mudlet-patches/`), which tells the game the console's size and leaves the main window's alone; as in Mudlet, a width below 40 counts as 40, the game is told no more than the profile's wrap width, and of a change once the size has held for 0.3 s. Until the UI sends one, a game is told the main console's grid: that of the size `setMainWindowSize` gave, or 90 by 25. On the control socket it is only kept ("Several profiles" below). | | `getLink` | `link`, `window`?, `id`? | Asks what the link with that id of the console `window` offers now, answered by `link`, or by `error` `getLink: unknown` for an id the console no longer holds, one from a main console line of a profile opened before the one running, a `window` that is no console's, or with no profile open. `window` is a mini console, user window or MXP frame as `windowText` names it, and the main console when absent, empty or `main`; one that is not a string gets `error`. `link` is the id a run carries, a whole number from 1 (else `error`). | | `followLink` | `link`, `item`?, `window`?, `id`? | Follows the link of `window`, as for `getLink`, as a tap does, or picks `item`, counted from 0, from `link`'s `items`, as its menu does (`followLink()`): a spoiler not yet revealed is only revealed, else its command or function runs. Nothing answers a link that ran or was revealed; `linksChanged` follows what that changed of it, or for a script window's link that window's next `windowText`. Otherwise `error` answers with `followLink:` and the name of the `LinkResult`: `disabled` (a disabled link, or a menu's greyed-out item), `concealed`, `noSuchItem`, `unknown` (as for `getLink`), or `failed` or `refused` followed by a colon and why. A `link` that is not a whole number from 1, an `item` that is not one from 0, or a `window` that is not a string, gets `error`. | | `setAppState` | `active`, `minimized` | The app is in front (`active`) or not, and its window is minimized or sent to the background (`minimized`), each a boolean (else `error`). libmudlet gives `active` to `setApplicationActive()`, so a change raises `sysApplicationFocusChangeEvent` once in each open profile, as the GUI's window gaining or losing focus does, and `minimized` to each profile's `setWindowMinimized()`, so that, with the profile's "notify on new data while minimized" on, game text then asks for `attention`. When `active` turns false, the open profiles are saved as Mudlet saves them at a close, but with no `sysExitEvent`, as the system may stop the engine without warning once the app has left the front: status `save` tells how that went. Until the first, `active` is true and `minimized` false; each holds for the profiles opened later. | @@ -74,7 +74,7 @@ message, in backquotes, with `?` after an optional one, and the fields of the ob | `saveProfile` | `name`, `host`, `port`, `tls`, `login`, `autoReconnect`, `id`? | Creates the profile `name`, or updates the one of that name, ignoring case; an update keeps the name it was created with. All the fields are needed: `host` not empty, `port` from 1 to 65535, `tls` and `autoReconnect` booleans, `login` a string, which may be empty. A new `name` must be one Mudlet can make a folder of: only the letters A to Z, the digits, spaces and `. _ ( ) - # &`, no space at either end, and neither `.` nor `..` in it. A running profile is given all of them at once, with no close: the `login` for its next connection, and `host`, `port` and `tls` for the next connection that is made, the reconnect Mudlet makes on its own included, while the one that is open stays as it is. `autoReconnect` counts from the next time the connection is lost or fails; a retry Mudlet is already waiting to make is still made, and `disconnect` calls it off. An address Mudlet refuses, as TLS to an IP address, leaves the running profile with the one it had, and its `connect` then says why. | | `deleteProfile` | `name`, `id`? | Deletes the profile, with everything Mudlet keeps for it. Refused while it is running, being opened or closed, or waited for by a restore. | | `openProfile` | `name`, `password`?, `proxyPassword`?, `connect`?, `alongside`?, `id`? | Starts the profile `name`. Without `alongside`, those open are first closed and saved, as Mudlet closes a profile; with it, the profile starts beside them, and `error` `openProfile: at most 4 open` refuses a fifth. `password` is for this run only: Mudlet's auto-login sends the profile's `login` and then this password once it connects, and nothing stores it. `connect`, true if absent, connects the profile to its own address. Opening the profile that is running leaves it running, gives it `password` in place of the one it had, none if absent, for its next connection, and connects it if `connect` and it is not connected; the UI sends it so, with `alongside` and `connect` false, when the player stores or forgets the password of a game that is open, and when `openProfiles` says an open game has none (`passwordGiven`). Sent so, it only hands the password over: the profile keeps its place in `profiles`, and a restore of it goes on. While a profile is being opened, `connect`, `disconnect` and `runLua` are for it. `proxyPassword` is the password of the profile's proxy (`setProxy`), for this run only as `password` is and given, replaced and withdrawn with it: nothing stores it, no message carries it back, and it goes to the proxy alone. | -| `setMainWindowSize` | `w`, `h` | The main window's size in Mudlet's pixels, whole numbers above 0. The borders scripts set take their room from it, and the main console's font decides the grid in what is left (`mainArea`). libmudlet gives it to the running profile at once (`THeadlessSession::setMainWindowSize()`, which raises `sysWindowResizeEvent`) and keeps it for each profile that loads later, which may still refuse it: `mainArea` then gives 0 for it. A `setScreenSize` before or after it leaves it the main window's size; the game is still told the console's columns and rows, not the grid Mudlet's font fits in this size. | +| `setMainWindowSize` | `w`, `h` | The main window's size in Mudlet's pixels, whole numbers above 0. The borders scripts set take their room from it, and the main console's font decides the grid in what is left (`mainArea`). libmudlet gives it to the running profile at once (`THeadlessSession::setMainWindowSize()`, which raises `sysWindowResizeEvent`) and keeps it for each profile that starts later, which takes it before its first script runs, so that script reads it and is sent no `sysWindowResizeEvent` for it (`THeadlessSession::Options::mainWindowSize`, carried in `scripts/mudlet-patches/`), and may still refuse it: `mainArea` then gives 0 for it. On the control socket it is only kept ("Several profiles" below). A `setScreenSize` before or after it leaves it the main window's size; the game is still told the console's columns and rows, not the grid Mudlet's font fits in this size. | | `getWindowText` | `window`, `first`, `count`, `id`? | Up to `count` rows, at most 1000, of the console `window` (a mini console, user window or MXP frame; `main` is the main console, as in Mudlet) from row `first`, counted from 0. A negative `first` counts back from the end, so `-count` is the last `count` rows. Answered by `windowText`, or `error` for a name that is no console's. | | `placeUserWindow` | `name`, `x`, `y`, `w`, `h`, `floating` | Where the UI put the user window `name`, in the main window's pixels, docked or `floating` (`setUserWindowGeometry()`). A new size raises `sysUserWindowResizeEvent`. `w` and `h` above 0. | | `closeUserWindow` | `name` | The dock's close button: hides the user window, as `hideWindow()` does. | @@ -848,6 +848,10 @@ What the control socket carries depends on the UI's `hello`: - With `profileSockets`, the control requests above, `ping`, `openProfiles`, and the engine's own statuses (`enginePid`, `socketPath`, `appState`, the font, the heartbeat, `save`, `restore`, `engineKind`, `configDir`); any other request gets `error` (`: send it on the profile's socket`). + Also `setScreenSize` and `setMainWindowSize`, refused as on a profile's socket: the engine keeps them for each + profile opened after them, which starts with them until its own socket gives its own, and gives them to no profile + open now. The app sends them before `openProfile` and as it attaches, so the profile's scripts read the size the + game screen gives them from their first line rather than 90 by 25 until its socket's sizes come. The clipboard's messages go on the control socket too, as the clipboard is the whole app's, and a profile's socket refuses `answerClipboardRead` as it refuses the control requests. So do `pickFile` and `answerPickFile`, as the system's picker is the whole app's, and `openUrl` and @@ -915,7 +919,9 @@ and `EngineLink` then tracks `lastSeq` from those lines. ## Versioning and compatibility -As implemented in version 47, which added the profile's proxy (`getProxy`, `setProxy`, `proxy`, and `proxyPassword` +As implemented in version 48, which took `setScreenSize` and `setMainWindowSize` on the control socket, as the sizes +the profiles opened after them start with; +version 47 added the profile's proxy (`getProxy`, `setProxy`, `proxy`, and `proxyPassword` in `openProfile`); version 46 added a command line's style sheet (`styleSheet` on a `commandLine` window); version 45 added the colour of the border around the main console (`borderColor` on `mainArea`); diff --git a/native/api/IEngineControl.h b/native/api/IEngineControl.h index d567270f0..98bccaf07 100644 --- a/native/api/IEngineControl.h +++ b/native/api/IEngineControl.h @@ -34,4 +34,8 @@ class IEngineControl virtual bool restorePending() const = 0; // The open profile the player now looks at, as a desktop tab brought forward virtual void setFront(const QString& name) = 0; + // The UI's console in characters and Mudlet's main window in pixels, as each profile opened later starts with them + // until its own socket gives its own: kept, not given to the profiles open now + virtual void setStartScreenSize(int columns, int rows) = 0; + virtual void setStartMainWindowSize(int width, int height) = 0; }; diff --git a/native/enginehost/ControlBridge.cpp b/native/enginehost/ControlBridge.cpp index a549f93b4..e9368d4cc 100644 --- a/native/enginehost/ControlBridge.cpp +++ b/native/enginehost/ControlBridge.cpp @@ -161,6 +161,16 @@ bool ControlBridge::handleControl(const QString& type, const QJsonObject& messag mPickLoop->quit(); } } + } else if (!mProfileOutput && type == QLatin1String("setScreenSize")) { + if (const std::optional size = screenSizeOf(message)) { + mEngineControl->setStartScreenSize(size->width(), size->height()); + } + } else if (!mProfileOutput && type == QLatin1String("setMainWindowSize")) { + if (const std::optional size = mainWindowSizeOf(message)) { + mEngineControl->setStartMainWindowSize(size->width(), size->height()); + } else { + refuse(type, mainWindowSizeProblem()); + } } else if (!mProfileOutput) { sendError(QStringLiteral("%1: send it on the profile's socket").arg(type)); } else { diff --git a/native/enginehost/MudletEngine.h b/native/enginehost/MudletEngine.h index 88d66ee25..f6f43574c 100644 --- a/native/enginehost/MudletEngine.h +++ b/native/enginehost/MudletEngine.h @@ -40,6 +40,8 @@ class MudletEngine : public QObject, public IEngineControl IEngine* defaultSession() override; bool restorePending() const override; void setFront(const QString& name) override; + void setStartScreenSize(int columns, int rows) override { mUi.screen = QSize(columns, rows); } + void setStartMainWindowSize(int width, int height) override { mUi.mainWindow = QSize(width, height); } private: friend class MudletProfile; diff --git a/native/enginehost/MudletProfile.cpp b/native/enginehost/MudletProfile.cpp index 800218ca7..f115c20d8 100644 --- a/native/enginehost/MudletProfile.cpp +++ b/native/enginehost/MudletProfile.cpp @@ -1070,6 +1070,13 @@ void MudletProfile::beginLoad() options.password = passwords.game; options.proxyPassword = passwords.proxy; options.configDir = mEngine.mConfigDir; + // So the profile's scripts read the UI's size from their first line, not 90 by 25 until profileLoaded; the screen + // size stands in for the main window only while the UI has given it none, as in applyScreenSize() + if (!mMainWindowSize.isEmpty()) { + options.mainWindowSize = mMainWindowSize; + } else { + options.screenSize = mScreenSize; + } // Kept until the start, and a session that joins the pool takes the pool's instead mSession->setApplicationActive(mEngine.mAppActive); mSession->setWindowMinimized(mEngine.mMinimized); diff --git a/native/enginehost/SocketBridge.cpp b/native/enginehost/SocketBridge.cpp index 9914fe1c1..45d86a2c4 100644 --- a/native/enginehost/SocketBridge.cpp +++ b/native/enginehost/SocketBridge.cpp @@ -960,6 +960,13 @@ void SocketBridge::complete(const QJsonObject& message) } void SocketBridge::setScreenSize(const QJsonObject& message) +{ + if (const std::optional size = screenSizeOf(message)) { + mEngine->setScreenSize(size->width(), size->height()); + } +} + +std::optional SocketBridge::screenSizeOf(const QJsonObject& message) { const double columns = message.value(QLatin1String("columns")).toDouble(-1); const double rows = message.value(QLatin1String("rows")).toDouble(-1); @@ -969,9 +976,9 @@ void SocketBridge::setScreenSize(const QJsonObject& message) }; if (!fits(columns) || !fits(rows)) { sendError(QStringLiteral("setScreenSize: columns and rows must be whole numbers from 1 to 65535")); - return; + return std::nullopt; } - mEngine->setScreenSize(int(columns), int(rows)); + return QSize(int(columns), int(rows)); } void SocketBridge::getLink(const QJsonObject& message) @@ -1047,12 +1054,21 @@ void SocketBridge::followLink(const QJsonObject& message) QString SocketBridge::setMainWindowSize(const QJsonObject& message) { - const std::optional width = wholeNumber(message.value(QLatin1String("w"))); - const std::optional height = wholeNumber(message.value(QLatin1String("h"))); - if (!width || !height || *width < 1 || *height < 1) { - return QStringLiteral("w and h must be whole numbers above 0"); + const std::optional size = mainWindowSizeOf(message); + if (!size) { + return mainWindowSizeProblem(); + } + return mEngine->setMainWindowSize(size->width(), size->height()); +} + +std::optional SocketBridge::mainWindowSizeOf(const QJsonObject& message) +{ + const std::optional width = wholeNumber(message.value(QLatin1String("w")), 1); + const std::optional height = wholeNumber(message.value(QLatin1String("h")), 1); + if (!width || !height) { + return std::nullopt; } - return mEngine->setMainWindowSize(*width, *height); + return QSize(*width, *height); } void SocketBridge::getWindowText(const QJsonObject& message) diff --git a/native/enginehost/SocketBridge.h b/native/enginehost/SocketBridge.h index e4edc5142..5a773ada6 100644 --- a/native/enginehost/SocketBridge.h +++ b/native/enginehost/SocketBridge.h @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -33,7 +34,7 @@ class SocketBridge : public QObject, public IFrontend Q_OBJECT public: - static constexpr int protocolVersion = 47; + static constexpr int protocolVersion = 48; static constexpr quint32 maxFrameBytes = 16 * 1024 * 1024; static constexpr qsizetype scrollbackLines = 2000; static constexpr qint64 highWaterBytes = 4 * 1024 * 1024; @@ -144,6 +145,11 @@ class SocketBridge : public QObject, public IFrontend void refuse(const QString& request, const QString& problem); void complete(const QJsonObject& message); void setScreenSize(const QJsonObject& message); + // A setScreenSize's columns and rows, or none after sending why not + std::optional screenSizeOf(const QJsonObject& message); + // A setMainWindowSize's w and h, or none when they are not whole numbers above 0 + static std::optional mainWindowSizeOf(const QJsonObject& message); + static QString mainWindowSizeProblem() { return QStringLiteral("w and h must be whole numbers above 0"); } void getLink(const QJsonObject& message); void followLink(const QJsonObject& message); QString setMainWindowSize(const QJsonObject& message); diff --git a/native/tests/protocol_client.py b/native/tests/protocol_client.py index 5a5d7af64..0f182ad00 100644 --- a/native/tests/protocol_client.py +++ b/native/tests/protocol_client.py @@ -5,7 +5,7 @@ import struct import time -PROTOCOL_VERSION = 47 +PROTOCOL_VERSION = 48 class Closed(Exception): diff --git a/native/tests/test_mudlet_engine.py b/native/tests/test_mudlet_engine.py index a7a4e0a3e..37d3e63c2 100644 --- a/native/tests/test_mudlet_engine.py +++ b/native/tests/test_mudlet_engine.py @@ -24,6 +24,7 @@ import time import zipfile import zlib +from xml.sax.saxutils import escape as xml_escape sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import fake_socks5 # noqa: E402 @@ -119,7 +120,7 @@ def main(): try: for checks in (engine_basics, tls_checks, profile_requests): checks(port) - for checks in (bridge_refusals, input_line, console, screen_and_main_window, links, app_state, script_windows, window_links, + for checks in (bridge_refusals, input_line, console, screen_and_main_window, start_sizes, links, app_state, script_windows, window_links, script_labels, label_links, script_text_boxes, frame_tabs, button_bars, map_view, app_map, map_info, map_moves, map_rooms, map_edits, map_download, map_files, profile_settings, script_items, variables, sounds, clipboard, file_dialog, web_pages, packages, error_console, default_packages, key_bindings, scripts_stopped, @@ -1532,6 +1533,96 @@ def screen_and_main_window(): check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") +def start_sizes(): + """The sizes a UI gives before a profile opens are what its scripts read from their first line: on the profile's + own socket, as version 14's UI and a UI that attaches again send them, and on the control socket, which keeps them + for each profile opened after them and gives them to none open now. A MiniConsole that wraps to its width and + echoes as the profile loads wraps at that width, not at that of the main window the profile had before the UI's.""" + profile = "Start Size Test" + folder = os.path.join(TMP, "start-size") + os.makedirs(folder, exist_ok=True) + path = package_file("Early Wrap", folder, {"title": "Wraps as it loads"}, script="\n".join([ + 'local w, h = getMainWindowSize()', + 'earlyWindow = string.format("%dx%d", w, h)', + 'earlyWrap = Geyser.MiniConsole:new({name = "earlyWrap", x = 0, y = 0, width = "100%", height = "50%", autoWrap = true})', + 'earlyWrap:echo(string.rep("x", 300) .. "\\n")', + ])) + proc, c = start_engine(profile) + seen = [] + c.wait_for(lambda m: m["t"] == "synced", collect=seen) + c.ask({"t": "saveProfile", "name": profile, "host": "127.0.0.1", "port": 23, "tls": False, "login": "", + "autoReconnect": False}, collect=seen) + c.send({"t": "openProfile", "name": profile, "connect": False}) + wait_status(c, "profile", lambda v: v == f"{profile} loaded", seen) + since = len(seen) + c.send({"t": "installPackage", "path": path}) + m = seen_or_next(c, lambda m: m["t"] == "packageInstalled", seen, since, timeout=15) + check(m.get("result") == "installed", f"a package whose script wraps a console as it loads installs: {m}") + c.send({"t": "setAppState", "active": False, "minimized": True}) + m = wait_status(c, "save", lambda v: True, seen) + check(m["value"] == "saved", f"and the profile saved: {m}") + code = stop_engine(proc) + check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") + + def loaded_at(client, frames, size, how): + client.send({"t": "runLua", "code": 'echo("early window " .. tostring(earlyWindow) .. "\\n")'}) + m = client.wait_for(lambda m: m["t"] in ("line", "tail") and m["text"].startswith("early window "), collect=frames) + check(m["text"] == f"early window {size}", f"the profile's script read the main window's size {how} as it loaded: {m['text']}") + seen_or_next(client, windows_with("earlyWrap", "miniConsole", lambda w: w.get("columns", 0) > 0), frames, 0) + client.send({"t": "runLua", "code": 'echo("early wrap " .. getWindowWrap("earlyWrap") .. "\\n")'}) + wrap = int(client.wait_for(lambda m: m["t"] in ("line", "tail") and m["text"].startswith("early wrap "), + collect=frames)["text"].split()[-1]) + m = client.ask({"t": "getWindowText", "window": "earlyWrap", "first": 0, "count": 50}, answers=("windowText", "error"), + collect=frames) + rows = [line["text"] for line in m.get("lines", []) if line["text"]] + check(rows and "".join(rows) == "x" * 300 and abs(len(rows[0]) - wrap) <= 1, + f"so the line it echoed then wraps where the console wraps now, at {wrap}: {[len(row) for row in rows]}") + + # As version 14's UI, or one that attaches again, sends them + proc, c = start_engine(profile) + seen = [] + c.wait_for(lambda m: m["t"] == "synced", collect=seen) + c.send({"t": "setScreenSize", "columns": 60, "rows": 40}) + c.send({"t": "setMainWindowSize", "w": 1600, "h": 800}) + c.send({"t": "openProfile", "name": profile, "connect": False}) + wait_status(c, "profile", lambda v: v == f"{profile} loaded", seen) + loaded_at(c, seen, "1600x800", "given on its socket before it opened") + code = stop_engine(proc) + check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") + + proc, c = start_engine(profile) + c.close() + ctl = Client(SOCK, profile_sockets=True) + control = [] + ctl.wait_for(lambda m: m["t"] == "synced", collect=control) + ctl.send({"t": "setMainWindowSize", "w": 0, "h": 800}) + m = ctl.wait_for(lambda m: m["t"] == "error", collect=control) + check(m["message"] == "setMainWindowSize: w and h must be whole numbers above 0", + f"the control socket refuses a main window's size as a profile's socket does: {m}") + ctl.send({"t": "setScreenSize", "columns": 0, "rows": 40}) + m = ctl.wait_for(lambda m: m["t"] == "error", collect=control) + check(m["message"] == "setScreenSize: columns and rows must be whole numbers from 1 to 65535", + f"and a screen size: {m}") + ctl.send({"t": "setScreenSize", "columns": 60, "rows": 40}) + ctl.send({"t": "setMainWindowSize", "w": 1400, "h": 700}) + since = len(control) + m = ctl.ask({"t": "openProfile", "name": profile, "connect": False}, timeout=30, collect=control, + answers=("openProfiles", "error")) + check(m["t"] == "openProfiles", f"openProfile after them answers: {m}") + opened = seen_or_next(ctl, lambda m: m["t"] == "openProfiles" and [(p["name"], p["state"]) for p in m["profiles"]] + == [(profile, "loaded")], control, since, timeout=30)["profiles"] + p = Client(opened[0]["socket"]) + frames = [] + p.wait_for(lambda m: m["t"] == "synced", collect=frames) + loaded_at(p, frames, "1400x700", "given on the control socket before it opened") + ctl.send({"t": "setMainWindowSize", "w": 1200, "h": 800}) + ctl.ask({"t": "listProfiles"}, collect=control) + size = main_window_size(p, frames, "kept") + check(size == "1400x700", f"a size the control socket is given leaves the open profile's as it was: {size}") + code = stop_engine(proc) + check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") + + def link_ids(m): """The link ids of a line's or tail's runs, in order.""" return [r[5] for r in m["runs"] if len(r) == 6 and r[5] > 0] @@ -5180,14 +5271,15 @@ def web_pages(): check(secret not in f.read(), "the URL is not in the engine's log") -def package_file(name, folder, details, icon=None): +def package_file(name, folder, details, icon=None, script=None): """A Mudlet package as the desktop's exporter makes one: a zip of its config.lua, its XML with a script, and its icon - in .mudlet/Icon.""" + in .mudlet/Icon. Its script is the Lua given, or one that sets _G[" loaded"].""" path = os.path.join(folder, f"{name}.mpackage") config = "".join(f'{key} = [[{value}]]\n' for key, value in dict(mpackage=name, **details).items()) + code = xml_escape(script) if script else f'_G["{name} loaded"] = true' xml = ('\n\n' f'\n') + f'\n') with zipfile.ZipFile(path, "w") as z: z.writestr("config.lua", config) z.writestr(f"{name}.xml", xml) diff --git a/protocol/src/main/kotlin/org/mudlet/android/protocol/Protocol.kt b/protocol/src/main/kotlin/org/mudlet/android/protocol/Protocol.kt index a521d3206..ec7a704e2 100644 --- a/protocol/src/main/kotlin/org/mudlet/android/protocol/Protocol.kt +++ b/protocol/src/main/kotlin/org/mudlet/android/protocol/Protocol.kt @@ -12,7 +12,7 @@ import kotlin.math.roundToInt // Wire format shared with native/enginehost/SocketBridge.cpp, specified in docs/protocol.md: a 4-byte // big-endian length, then one UTF-8 JSON object whose "t" field is the message type. -const val PROTOCOL_VERSION = 47 +const val PROTOCOL_VERSION = 48 private const val MAX_FRAME_BYTES = 16 * 1024 * 1024 private const val QUOTE = '"'.code.toByte() diff --git a/protocol/src/main/kotlin/org/mudlet/android/protocol/StartSizes.kt b/protocol/src/main/kotlin/org/mudlet/android/protocol/StartSizes.kt new file mode 100644 index 000000000..0cc54e085 --- /dev/null +++ b/protocol/src/main/kotlin/org/mudlet/android/protocol/StartSizes.kt @@ -0,0 +1,52 @@ +package org.mudlet.android.protocol + +import org.json.JSONException +import org.json.JSONObject + +/** + * The sizes the game screen last gave Mudlet for a profile that has no windows yet, and the window and settings it gave + * them in ([window]), which decide them. The app sends them on the control socket before it opens a profile, so the + * profile's scripts read them from their first line ("Several profiles" in docs/protocol.md). They are kept between + * runs: the profile the app opens first after it starts has no game screen to measure yet. + */ +data class StartSizes(val window: String, val mainWindow: MudletSize? = null, val screen: Pair? = null) { + /** What to send before opening a profile from [window]: nothing of sizes another window or other settings gave. */ + fun requestsFor(window: String): List = if (window != this.window) { + emptyList() + } else { + listOfNotNull(screen?.let { Requests.setScreenSize(it.first, it.second) }, mainWindow?.let { Requests.setMainWindowSize(it.w, it.h) }) + } + + fun encode(): String = JSONObject().put("window", window).apply { + mainWindow?.let { put("mainW", it.w).put("mainH", it.h) } + screen?.let { put("columns", it.first).put("rows", it.second) } + }.toString() + + companion object { + /** [known] with the main window's [size] given in [window]; sizes another window gave are dropped. */ + fun withMainWindow(known: StartSizes?, window: String, size: MudletSize): StartSizes = (known?.takeIf { it.window == window } ?: StartSizes(window)).copy(mainWindow = size) + + /** [known] with the console's [columns] and [rows] measured in [window]; sizes another window gave are dropped. */ + fun withScreen(known: StartSizes?, window: String, columns: Int, rows: Int): StartSizes = (known?.takeIf { it.window == window } ?: StartSizes(window)).copy(screen = columns to rows) + + /** What [encode] wrote, or null for nothing or what no version of it wrote. */ + fun decode(text: String?): StartSizes? { + if (text == null) return null + return try { + val json = JSONObject(text) + fun size(a: String, b: String): Pair? { + val first = json.optInt(a, 0) + val second = json.optInt(b, 0) + return if (first > 0 && second > 0) first to second else null + } + StartSizes( + json.getString("window"), + size("mainW", "mainH")?.let { MudletSize(it.first, it.second) }, + size("columns", "rows")?.takeIf { it.first <= 65535 && it.second <= 65535 }, + ) + } catch (_: JSONException) { + null + } + } + } +} diff --git a/protocol/src/test/kotlin/org/mudlet/android/protocol/StartSizesTest.kt b/protocol/src/test/kotlin/org/mudlet/android/protocol/StartSizesTest.kt new file mode 100644 index 000000000..9e3df0e08 --- /dev/null +++ b/protocol/src/test/kotlin/org/mudlet/android/protocol/StartSizesTest.kt @@ -0,0 +1,54 @@ +package org.mudlet.android.protocol + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** The sizes the app gives the engine before it opens a profile, and what it keeps of them between runs. */ +class StartSizesTest { + private val portrait = "411x891 14 AUTO" + private val landscape = "891x411 14 AUTO" + + private fun requests(sizes: StartSizes?, window: String) = sizes?.requestsFor(window).orEmpty().map { it.toString() } + + @Test + fun theSizesGivenInAWindowGoOutBeforeAProfileOpensFromIt() { + val sizes = StartSizes.withMainWindow(StartSizes.withScreen(null, portrait, 31, 52), portrait, MudletSize(1693, 795)) + assertEquals( + listOf(Requests.setScreenSize(31, 52).toString(), Requests.setMainWindowSize(1693, 795).toString()), + requests(sizes, portrait), + ) + } + + @Test + fun noneGoOutForAnotherWindowOrOtherSettings() { + val sizes = StartSizes.withMainWindow(StartSizes.withScreen(null, portrait, 31, 52), portrait, MudletSize(1693, 795)) + assertTrue(requests(sizes, landscape).isEmpty()) + assertTrue(requests(sizes, "411x891 18 AUTO").isEmpty()) + assertTrue(requests(null, portrait).isEmpty()) + } + + @Test + fun aSizeGivenInAnotherWindowReplacesThoseOfTheLast() { + val portraitSizes = StartSizes.withMainWindow(StartSizes.withScreen(null, portrait, 31, 52), portrait, MudletSize(1693, 795)) + val turned = StartSizes.withScreen(portraitSizes, landscape, 88, 20) + assertEquals(StartSizes(landscape, screen = 88 to 20), turned) + assertEquals(listOf(Requests.setScreenSize(88, 20).toString()), requests(turned, landscape)) + } + + @Test + fun whatIsKeptReadsBackAsItWasWritten() { + val sizes = StartSizes.withMainWindow(StartSizes.withScreen(null, portrait, 31, 52), portrait, MudletSize(1693, 795)) + assertEquals(sizes, StartSizes.decode(sizes.encode())) + assertEquals(StartSizes(portrait), StartSizes.decode(StartSizes(portrait).encode())) + } + + @Test + fun nothingKeptOrWhatNoVersionWroteIsNone() { + assertNull(StartSizes.decode(null)) + assertNull(StartSizes.decode("not json")) + assertNull(StartSizes.decode("{}")) + assertEquals(StartSizes(portrait), StartSizes.decode("""{"window":"$portrait","mainW":0,"mainH":5,"columns":70000,"rows":20}""")) + } +} diff --git a/scripts/mudlet-patches/0043-headless-main-window-size-at-start.patch b/scripts/mudlet-patches/0043-headless-main-window-size-at-start.patch new file mode 100644 index 000000000..d9f0695b7 --- /dev/null +++ b/scripts/mudlet-patches/0043-headless-main-window-size-at-start.patch @@ -0,0 +1,182 @@ +Headless apps give the main window's size before scripts load + +THeadlessSession takes the main window's size, setMainWindowSize() in pixels or setScreenSize() in characters, +only once a profile has loaded. Every script that runs as the profile loads reads the default of 90 by 25 +characters instead, and a package that fits its windows to the main window then, as the starter UI fits its dock, +lays them out for a size the app never shows. A console with autoWrap keeps the wrap each line had as it arrived, +so a line echoed then stays wrapped at that width after the window grows. + +- THeadlessSession::Options takes mainWindowSize (pixels) or else screenSize (characters). The area is laid out + with the font and borders the save left before the first script runs, which reads that size and is sent no + sysWindowResizeEvent for it. The same size given again after the load changes nothing. +- A screen size of more than 65535 either way is refused, as setScreenSize() refuses it. A main window that + holds no character of the profile's font is not taken, and setMainWindowSize() refuses it once loaded. +- The GUI and the headless runner are unchanged. + +Tested by HeadlessSessionTest (test_aMainWindowGivenAtStartIsWhatTheFirstScriptReads, +test_aScreenSizeGivenAtStartIsWhatTheFirstScriptReads) and by Mudlet/android's native/tests/test_mudlet_engine.py. + +Carried by Mudlet/android's scripts/apply-mudlet-patches.sh until Mudlet/Mudlet has it. +Upstream: not opened yet + +diff --git a/docs/headless.md b/docs/headless.md +index a1ff07e13..d6de93416 100644 +--- a/docs/headless.md ++++ b/docs/headless.md +@@ -934,6 +934,14 @@ There are two ways to give the area, and the later of the two holds: + - `setMainWindowSize(QSize(width, height))` gives it in pixels, for an app that draws the main console + itself. A font change keeps the area and fits the new font's characters into it, so the grid changes. + ++An app that knows the size before it opens the profile gives it to `start()` as well, in ++`options.mainWindowSize` (pixels) or else `options.screenSize` (characters): the area is laid out with ++the font and borders the save left before the first script runs, so a script that fits its windows to ++the main window as it loads reads the size the app shows, and is sent no `sysWindowResizeEvent` for it. ++Given again once the profile has loaded, the same size changes nothing. A screen size of more than 65535 ++either way is refused; a main window that holds no character of the profile's font, or more than 65535, ++is not taken, and `setMainWindowSize()` refuses it once the profile has loaded. ++ + Either raises `sysWindowResizeEvent` with the text's width and height in pixels, as a resize of the main + window does in the GUI, and nothing when the size is the one already given; a border change raises it + too. Both are refused where `submit()` is, and for a size of no character, or more than 65535, either +diff --git a/src/Host.cpp b/src/Host.cpp +index cd012ea85..e5b1bb7f2 100644 +--- a/src/Host.cpp ++++ b/src/Host.cpp +@@ -903,7 +903,7 @@ void Host::startProfileScripts() + { + // enable script compilation (which is off by default) + mBlockScriptCompile = false; +- if (!hasConsoleView() && !mBorders.isNull()) { ++ if (!hasConsoleView() && (!mBorders.isNull() || mMainAreaCells || mMainAreaPixels)) { + layOutMainAreaWithNoView(MainAreaChange::load); + } + // This uses the external LuaGlobal.lua file to load all the other external +diff --git a/src/headless/THeadlessSession.cpp b/src/headless/THeadlessSession.cpp +index 1a8c80a8e..33265468d 100644 +--- a/src/headless/THeadlessSession.cpp ++++ b/src/headless/THeadlessSession.cpp +@@ -43,6 +43,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -536,6 +537,11 @@ std::optional THeadlessSession::prepareStart(Opti + mErrorString = tr("The profiles closed earlier are still closing; try again once they have."); + return StartResult::poolClosing; + } ++ if (options.screenSize.width() > 65535 || options.screenSize.height() > 65535) { ++ //: Error from a frontend with no window given a screen size that cannot be sent to the game; %1 is the number of columns asked for, %2 the number of rows ++ mErrorString = tr("A screen of %1 columns by %2 rows cannot be sent to the game: each must be from 1 to 65535.").arg(options.screenSize.width()).arg(options.screenSize.height()); ++ return StartResult::notOpened; ++ } + // Before the pool is made, as a handler of that end may call shutdown() or start() + if (!mpPool && !finishOpenProgress()) { + return StartResult::notOpened; +@@ -1064,6 +1070,18 @@ THeadlessSession::StartResult THeadlessSession::finishStart(const Options& optio + if (options.port > 0) { + pNewHost->setPort(options.port); + } ++ // Laid out by startProfileScripts(), with the font and borders the save left ++ if (const QSize pixels = options.mainWindowSize; !pixels.isEmpty()) { ++ const QFontMetrics metrics(pNewHost->displayFontWithNoView()); ++ const qint64 columns = pixels.width() / std::max(1, metrics.averageCharWidth()); ++ const qint64 rows = pixels.height() / std::max(1, metrics.height()); ++ if (columns >= 1 && columns <= 65535 && rows >= 1 && rows <= 65535) { ++ pNewHost->setMainAreaPixels(pixels); ++ } ++ } else if (const QSize cells = options.screenSize; !cells.isEmpty()) { ++ // The GUI's main console never reports itself narrower ++ pNewHost->setMainAreaCells(QSize(std::max(40, cells.width()), cells.height())); ++ } + }); + // The GUI connects a profile whose save failed too, but there the player sees why it has no scripts. Unless + // a script that did load ran the event loop for long enough, the address is still being looked up. +diff --git a/src/headless/THeadlessSession.h b/src/headless/THeadlessSession.h +index 23f4bc9a6..0b0361ca1 100644 +--- a/src/headless/THeadlessSession.h ++++ b/src/headless/THeadlessSession.h +@@ -93,6 +93,13 @@ public: + // asks for it with transportDialRequested, and never uses its own. Only for the session's profile, not + // ones its scripts open. See "The game connection" in docs/headless.md + bool supplyTransport = false; ++ // The main window's area as setMainWindowSize() gives it in pixels, or else as setScreenSize() gives it in ++ // characters, taken once the save has loaded and laid out with its font and borders before the first script ++ // runs, which then reads that size and is sent no sysWindowResizeEvent for it. Empty for none. A screen ++ // size of more than 65535 either way is refused; a main window that holds no character of the profile's ++ // font, or more than 65535, is not taken, and setMainWindowSize() refuses it once the profile has loaded. ++ QSize mainWindowSize; ++ QSize screenSize; + }; + + // How the game asked for a run of a line to be shown. Reverse is not applied to the colours: the GUI +diff --git a/test/functional_tests/HeadlessSessionTest.cpp b/test/functional_tests/HeadlessSessionTest.cpp +index d22596eaa..c47d17d54 100644 +--- a/test/functional_tests/HeadlessSessionTest.cpp ++++ b/test/functional_tests/HeadlessSessionTest.cpp +@@ -160,6 +160,17 @@ private: + .toUtf8()); + } + ++ // Reads the main window as it loads, and counts what it is told of a resize ++ static QString scriptReadingTheMainWindow() ++ { ++ return qsl(R"lua(local w, h = getMainWindowSize() ++headlessAtStart = w .. "x" .. h .. " " .. getColumnCount() .. "x" .. getRowCount() ++headlessResizes = 0 ++registerAnonymousEventHandler("sysWindowResizeEvent", function() ++ headlessResizes = headlessResizes + 1 ++end))lua"); ++ } ++ + // Opened binary so Windows writes no \r + static QString recordingScript(const QString& recordPath) + { +@@ -5056,6 +5067,45 @@ headlessGrid = getColumnCount() .. "x" .. getRowCount())lua"))); + QVERIFY(session.shutdown(false)); + } + ++ // A frontend that knows its main window before the profile opens gives it to start(), so a script that fits a ++ // window to it as it loads reads that size from its first line, laid out with the save's font and borders ++ void test_aMainWindowGivenAtStartIsWhatTheFirstScriptReads() ++ { ++ const QString name = qsl("Headless Main Window At Start"); ++ QVERIFY(writeProfile(name, scriptReadingTheMainWindow(), qsl("100"))); ++ THeadlessSession session; ++ QCOMPARE(session.start({.profile = name, .connect = false, .mainWindowSize = QSize(800, 600)}), THeadlessSession::StartResult::started); ++ QVERIFY(session.runLua(qsl("cellWidth, cellHeight = calcFontSize()"))); ++ const int cellWidth = luaGlobalString(session.host(), "cellWidth").toInt(); ++ const int cellHeight = luaGlobalString(session.host(), "cellHeight").toInt(); ++ QVERIFY(cellWidth > 0 && cellHeight > 0); ++ QCOMPARE(luaGlobalString(session.host(), "headlessAtStart"), qsl("800x600 %1x%2").arg(std::max(40, 700 / cellWidth)).arg(600 / cellHeight)); ++ // As a frontend gives it again once the profile has loaded, which tells scripts nothing for the size they have ++ QVERIFY(session.setMainWindowSize(QSize(800, 600))); ++ QCOMPARE(luaGlobalString(session.host(), "headlessResizes"), qsl("0")); ++ QVERIFY(session.shutdown(false)); ++ } ++ ++ void test_aScreenSizeGivenAtStartIsWhatTheFirstScriptReads() ++ { ++ const QString name = qsl("Headless Screen Size At Start"); ++ QVERIFY(writeProfile(name, scriptReadingTheMainWindow(), qsl("100"))); ++ THeadlessSession session; ++ QCOMPARE(session.start({.profile = name, .connect = false, .screenSize = QSize(65536, 20)}), THeadlessSession::StartResult::notOpened); ++ QVERIFY2(session.errorString().contains(qsl("from 1 to 65535")), qPrintable(session.errorString())); ++ QVERIFY(!session.host()); ++ ++ QCOMPARE(session.start({.profile = name, .connect = false, .screenSize = QSize(70, 20)}), THeadlessSession::StartResult::started); ++ QVERIFY(session.runLua(qsl("cellWidth, cellHeight = calcFontSize()"))); ++ const int cellWidth = luaGlobalString(session.host(), "cellWidth").toInt(); ++ const int cellHeight = luaGlobalString(session.host(), "cellHeight").toInt(); ++ QVERIFY(cellWidth > 0 && cellHeight > 0); ++ QCOMPARE(luaGlobalString(session.host(), "headlessAtStart"), qsl("%1x%2 %3x20").arg(70 * cellWidth).arg(20 * cellHeight).arg(std::max(40, (70 * cellWidth - 100) / cellWidth))); ++ QVERIFY(session.setScreenSize(70, 20)); ++ QCOMPARE(luaGlobalString(session.host(), "headlessResizes"), qsl("0")); ++ QVERIFY(session.shutdown(false)); ++ } ++ + void test_aResizeHandlerThatClosesTheProfile_data() + { + QTest::addColumn("deleteSession"); From d391cdcaae62959b014d709524751b2c692dae2f Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 21 Nov 2026 13:41:13 +0000 Subject: [PATCH 2/2] The starter UI's chat welcome fills its window after it widens The starter UI's chat window opens on its welcome, "Tells, says and channel chat from the game will be collected here." A console keeps the wrap a line had when it was printed, so after the game area widened (a tablet turned, a phone unfolded) the welcome stayed wrapped at the old, narrower width. Now, when the starter UI fits its dock to a new window size and the chat window still holds only the welcome, it prints the welcome again at the new width. Chat the game sent is never touched, and a dock the player dragged to a width of their own is left as it is. The desktop gets the same fix upstream. Carried as Mudlet patch 0044 until Mudlet/Mudlet has it; no protocol change. Tests: starter_ui_welcome in test_mudlet_engine.py; upstream, StarterUiChatWelcome_spec.lua. Part of Mudlet/Mudlet#9011 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016ujaeFyaqXXDx8xjoThE6J --- docs/architecture.md | 6 + native/tests/test_mudlet_engine.py | 55 +- .../0044-starter-ui-chat-welcome-refit.patch | 1473 +++++++++++++++++ 3 files changed, 1533 insertions(+), 1 deletion(-) create mode 100644 scripts/mudlet-patches/0044-starter-ui-chat-welcome-refit.patch diff --git a/docs/architecture.md b/docs/architecture.md index f7c459797..667f5a669 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1192,6 +1192,8 @@ as the game's is (`proxy()`, `setProxy()`, `setProxyPassword()`, `0042-headless- [`protocol.md`](protocol.md)). And the main window's size, or the console's columns and rows, given with the start, so a profile's scripts read it from their first line (`THeadlessSession::Options::mainWindowSize` and `screenSize`, `0043-headless-main-window-size-at-start.patch`). +And the starter UI's chat welcome printed again at its window's width when the window grows, while it is all the chat +window holds (`BaseUI.fitDock()`, `0044-starter-ui-chat-welcome-refit.patch`). [`c-device.md`](decisions/hosting-results/c-device.md) has the emulator run of the earlier build, which read Mudlet's console model and needed a patch. @@ -1329,6 +1331,8 @@ Android options (`scripts/build-libmudlet-desktop.sh`) to run it. It checks: - the sizes given before a profile opens, on its own socket or on the control socket: its scripts read them from their first line, so a Geyser `MiniConsole` with `autoWrap` that echoes as the profile loads wraps at the console's columns; the control socket refusing a size as a profile's socket does, and leaving an open profile its own; +- the starter UI's chat window built in a narrow main window that then widens: its welcome printed again at the new + width, and chat in it keeping its lines through a resize; - script windows: a Geyser `MiniConsole` as `windows` with its geometry, and its `cecho()` as `windowText` with its colours; a Geyser `UserWindow` placed by `placeUserWindow`, which raises `sysUserWindowResizeEvent`; the size from `setMainWindowSize` before the profile loads, `setBorderLeft()` and `setBorderColor()`, as `mainArea`; @@ -2323,6 +2327,8 @@ alias of run-lua-code, one of desktop Mudlet's default packages, which a profile - A window's text is readable, its newest line in view; scrolled back, it stays put. - A window that wraps to its width, such as the starter UI's chat window in a game with no GUI of its own, has its first lines wrapped at its full width, also in the profile opened first after the app starts. + - With the starter UI, turn a tablet or unfold a phone so the game area widens: the chat window's welcome line + fills its new width, while chat the game sent there keeps the lines it arrived on. - A console a script gave a scroll bar (`lua enableScrollBar("")`) with more rows than fit has a thumb at its right edge, which moves as the rows scroll and scrolls them when dragged; `disableScrollBar` takes it away. - With TalkBack on: swiping goes from the console to the input line, then the pinned commands, then diff --git a/native/tests/test_mudlet_engine.py b/native/tests/test_mudlet_engine.py index 37d3e63c2..b18ee8822 100644 --- a/native/tests/test_mudlet_engine.py +++ b/native/tests/test_mudlet_engine.py @@ -120,7 +120,8 @@ def main(): try: for checks in (engine_basics, tls_checks, profile_requests): checks(port) - for checks in (bridge_refusals, input_line, console, screen_and_main_window, start_sizes, links, app_state, script_windows, window_links, + for checks in (bridge_refusals, input_line, console, screen_and_main_window, start_sizes, starter_ui_welcome, + links, app_state, script_windows, window_links, script_labels, label_links, script_text_boxes, frame_tabs, button_bars, map_view, app_map, map_info, map_moves, map_rooms, map_edits, map_download, map_files, profile_settings, script_items, variables, sounds, clipboard, file_dialog, web_pages, packages, error_console, default_packages, key_bindings, scripts_stopped, @@ -1623,6 +1624,58 @@ def loaded_at(client, frames, size, how): check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") +def starter_ui_welcome(): + """The starter UI's chat window, built in a narrow main window that then widens, as the game screen gives its size + once it has measured itself: the welcome line is printed again at the window's new width, and chat the game sent + there keeps the lines it arrived on through a resize.""" + profile = "Starter UI Test" + pane = "BaseUI_chat_all" + welcome = "Tells, says and channel chat from the game will be collected here." + proc, c = start_engine(profile) + seen = [] + c.wait_for(lambda m: m["t"] == "synced", collect=seen) + c.ask({"t": "saveProfile", "name": profile, "host": "127.0.0.1", "port": 23, "tls": False, "login": "", + "autoReconnect": False}, collect=seen) + c.send({"t": "setMainWindowSize", "w": 800, "h": 600}) + c.send({"t": "openProfile", "name": profile, "connect": False}) + wait_status(c, "profile", lambda v: v == f"{profile} loaded", seen) + + def rows(): + m = c.ask({"t": "getWindowText", "window": pane, "first": 0, "count": 50}, answers=("windowText", "error"), collect=seen) + return [line["text"] for line in m.get("lines", []) if line["text"]] + + def resized(width, wider_than=None, narrower_than=None): + since = len(seen) + c.send({"t": "setMainWindowSize", "w": width, "h": 600}) + seen_or_next(c, windows_with(pane, "miniConsole", lambda w: (wider_than is None or w["columns"] > wider_than) + and (narrower_than is None or w["columns"] < narrower_than)), seen, since, what=f"{pane} resized") + + since = len(seen) + c.send({"t": "runLua", "code": "BaseUI.build()"}) + seen_or_next(c, windows_with(pane, "miniConsole", lambda w: w.get("columns", 0) > 0), seen, since, timeout=15, + what=f"{pane} built") + narrow_columns = window_of(seen, pane, "miniConsole")["columns"] + narrow = rows() + check("".join(narrow).replace(" ", "") == welcome.replace(" ", "") and len(narrow) > 1, + f"the starter UI's chat window opens on its welcome, wrapped at its {narrow_columns} columns: {narrow}") + + resized(1600, wider_than=narrow_columns) + wide_columns = window_of(seen, pane, "miniConsole")["columns"] + wide = rows() + check("".join(wide).replace(" ", "") == welcome.replace(" ", "") and len(wide) < len(narrow) and len(wide[0]) > narrow_columns, + f"widened to {wide_columns} columns, the welcome is printed again at that width: {wide}") + + c.send({"t": "runLua", "code": "BaseUI.chats.all:echo(\"Ana tells you, 'meet me at the fountain when the bells ring for " + "the third time today'\\n\")"}) + wait_status(c, "luaResult", lambda v: True, seen) + before = rows() + resized(800, narrower_than=wide_columns) + after = rows() + check(after == before and len(before) > len(wide), f"chat the game sent keeps its lines through a resize: {before} then {after}") + code = stop_engine(proc) + check(code == 0, f"the engine exits cleanly on SIGTERM: {code}") + + def link_ids(m): """The link ids of a line's or tail's runs, in order.""" return [r[5] for r in m["runs"] if len(r) == 6 and r[5] > 0] diff --git a/scripts/mudlet-patches/0044-starter-ui-chat-welcome-refit.patch b/scripts/mudlet-patches/0044-starter-ui-chat-welcome-refit.patch new file mode 100644 index 000000000..c3cc377ff --- /dev/null +++ b/scripts/mudlet-patches/0044-starter-ui-chat-welcome-refit.patch @@ -0,0 +1,1473 @@ +The starter UI's chat welcome fills its window after a resize + +The starter UI's chat window opens on one line, "Tells, says and channel chat from the game will be collected +here." A console keeps the wrap each line had when it was printed, so when the window grows after the dock was +built (a window restored to its size after the profile loaded, a player maximising it, a frontend that gives its +size late) the welcome stays wrapped at the old, narrower width in a chat window that is now wide. + +- When BaseUI.fitDock() changes the dock's width and "All" still holds nothing but the welcome, the welcome is + cleared and printed again at the chat window's new wrap. +- Chat the game has sent is never touched: once "All" holds anything else, the welcome is left as it is for the + rest of the session. +- A dock the player has dragged to a width of their own is left alone, as fitDock() already leaves it. + +Tested by StarterUiChatWelcome_spec.lua, which builds the dock in a narrow window, widens it, and reads the +welcome back at the new wrap, then checks that chat in the window keeps its lines through a resize, and by Mudlet/android's +native/tests/test_mudlet_engine.py. + +Carried by Mudlet/android's scripts/apply-mudlet-patches.sh until Mudlet/Mudlet has it. +Upstream: not opened yet + +diff --git a/src/mudlet-lua/tests/StarterUiChatWelcome_spec.lua b/src/mudlet-lua/tests/StarterUiChatWelcome_spec.lua +new file mode 100644 +index 000000000..d055b3a96 +--- /dev/null ++++ b/src/mudlet-lua/tests/StarterUiChatWelcome_spec.lua +@@ -0,0 +1,127 @@ ++-- The starter UI's chat window opens on a line saying what will collect there. ++-- A console keeps the wrap a line had when it was printed, so a welcome printed ++-- while the window was still small stays narrow after the window grows, unless ++-- the starter UI prints it again. Only the welcome is ever printed again: chat ++-- the game sent keeps the lines it arrived on. ++-- ++-- The self-test profile has no starter UI, so it is installed here for these ++-- specs and taken away again after them. ++ ++describe("Tests the starter UI's chat welcome as the window is resized", function() ++ local packageName = "mudlet-base-ui" ++ local pane = "BaseUI_chat_all" ++ local welcome = "Tells, says and channel chat from the game will be collected here." ++ local windowWidth, windowHeight ++ local installedHere = false ++ ++ local function waitUntil(condition, timeoutMilliseconds) ++ local waited = 0 ++ while waited < timeoutMilliseconds do ++ if condition() then ++ return true ++ end ++ pumpEvents(50) ++ waited = waited + 50 ++ end ++ return condition() and true or false ++ end ++ ++ local function packageIsInstalled() ++ return table.contains(getPackages(), packageName) ++ end ++ ++ -- see UI_spec's "Toolbar buttons" ++ local function waitForProfileSaveToPass() ++ local _, err = installPackage("") ++ return not tostring(err):find("still in progress", 1, true) ++ end ++ ++ -- see Actions_spec: setMainWindowSize() sizes the whole window and ++ -- getMainWindowSize() reads the console, so the difference is the chrome ++ local function sizeMainWindow(width, height) ++ setMainWindowSize(width, height) ++ pumpEvents(50) ++ local innerWidth, innerHeight = getMainWindowSize() ++ setMainWindowSize(width + (width - innerWidth), height + (height - innerHeight)) ++ pumpEvents(200) ++ end ++ ++ -- getLineCount() is the index of the empty line the buffer sits on ++ local function paneLines() ++ return getLines(pane, 0, getLineCount(pane)) or {} ++ end ++ ++ -- a wrap drops the space it breaks at ++ local function stripped(text) ++ return (text:gsub("%s", "")) ++ end ++ ++ local function welcomeRows() ++ local rows = {} ++ for _, line in ipairs(paneLines()) do ++ if line ~= "" then ++ rows[#rows + 1] = line ++ end ++ end ++ return rows ++ end ++ ++ setup(function() ++ windowWidth, windowHeight = getMainWindowSize() ++ if not packageIsInstalled() then ++ assert.is_true(waitForProfileSaveToPass(), "a profile save never finished") ++ local installed, reason = installPackage(":/packages/mudlet-base-ui/mudlet-base-ui.mpackage") ++ assert.is_true(installed, "could not install the starter UI: " .. tostring(reason)) ++ assert.is_true(waitUntil(packageIsInstalled, 5000), packageName .. " did not turn up in getPackages()") ++ installedHere = true ++ end ++ end) ++ ++ teardown(function() ++ if installedHere and packageIsInstalled() then ++ assert.is_true(waitUntil(function() return uninstallPackage(packageName) == true end, 5000), ++ packageName .. " could not be uninstalled") ++ assert.is_true(waitUntil(function() return not packageIsInstalled() end, 5000), ++ packageName .. " was still installed after being uninstalled") ++ end ++ -- the save the uninstall queues must finish before Mudlet shuts down ++ pumpEvents(300) ++ assert.is_true(waitForProfileSaveToPass(), "the profile save the uninstall queued never finished") ++ sizeMainWindow(windowWidth, windowHeight) ++ end) ++ ++ it("prints the welcome again at the wrap of a window that grew after it was built", function() ++ if not installedHere or BaseUI.container then ++ pending("the starter UI was already in this profile") ++ return ++ end ++ sizeMainWindow(800, 600) ++ BaseUI.build() ++ pumpEvents(100) ++ local narrowWrap = getWindowWrap(pane) ++ local narrowRows = welcomeRows() ++ assert.equals(stripped(welcome), stripped(table.concat(narrowRows))) ++ ++ sizeMainWindow(1600, 600) ++ local wideWrap = getWindowWrap(pane) ++ assert.is_true(wideWrap > narrowWrap, "the chat window did not get wider: " .. narrowWrap .. " then " .. wideWrap) ++ local wideRows = welcomeRows() ++ assert.equals(stripped(welcome), stripped(table.concat(wideRows))) ++ assert.is_true(#wideRows < #narrowRows, table.concat(wideRows, "|")) ++ assert.is_true(#wideRows[1] > narrowWrap, table.concat(wideRows, "|")) ++ end) ++ ++ it("leaves the chat window as it is once the game has sent chat to it", function() ++ if not installedHere or not BaseUI.chats then ++ pending("the starter UI was already in this profile") ++ return ++ end ++ BaseUI.chats.all:echo("Ana tells you, 'meet me at the fountain when the bells ring for the third time today'\n") ++ local before = paneLines() ++ local wideWrap = getWindowWrap(pane) ++ ++ sizeMainWindow(800, 600) ++ assert.is_true(getWindowWrap(pane) < wideWrap, "the chat window did not get narrower") ++ assert.are.same(before, paneLines()) ++ end) ++end) +diff --git a/src/packages/mudlet-base-ui/config.lua b/src/packages/mudlet-base-ui/config.lua +index 348e1c094..aef74612c 100644 +--- a/src/packages/mudlet-base-ui/config.lua ++++ b/src/packages/mudlet-base-ui/config.lua +@@ -47,5 +47,5 @@ stay solid. + When a game installs an interface of its own, this one quietly stands + aside - `baseui show` brings it back if you prefer it. + ]] +-version = [[1.9.5]] ++version = [[1.9.6]] + created = "2026-07-25T12:00:00+00:00" +diff --git a/src/packages/mudlet-base-ui/mudlet-base-ui.mpackage b/src/packages/mudlet-base-ui/mudlet-base-ui.mpackage +index 038072b66b9d5be8deb249b94718398a4e1f91cf..f5867c086570aa08ff7b85a4c77c37105f1d4c8c 100644 +GIT binary patch +delta 32539 +zcmV)IK)k<`n+fTh2{lkl0|XQR000O87oBxo8aml5a|8eY=?DM-3IH4cV{dL|X=g5M +zbzxOh2>=7W^8stV^8ss-H6Z~_u~$q4EY0%l`{ns}cdySc&d%_CRh~!ce^5&U1QY-O +z00;mSopoJZ;hn!;oB#knN|Vn79SFDc0c*GO0c*4L1Vk5qt~9~l#is~E<_M6GVDe_m +z$;#HEC|cr_D6vS&u31T1jszkzqX-~i1dta?tRFK^Fl+V96ZD((oAi^+`M$mPxkLnz +zNQ$mi!tLX{F2^;c2VM)$B0vE0 +zGI&I<>DNMkxj8PLTL4fJXF0q}u{&o?4x93xKR8qm$H`cq6-A_jEpk#F)^zB;6h&?Q +zm9orVd9wJ}F|a0$s+zlbkv)D)9GQ{0S@7`7=m=_eAqNtJe&Xs~O9nWGB%bBvE$| +zIvN?OCK_f;V}TqsjIuwf)D_e?oF^KxM8BGHezsWpfFVSGbOn8c4ek`b9~}K-`yXa^ +z_l?&I+sER&H}?1LJ$xu~l(bel<~GTf@1hcfe8cPLAR6({;Uoo>>j&M9$85(bbH7t5 +zT`fR=y-$|Q)6?VQo{Eoi$Xw{yFjJnOF3952aY=0Z+FOWBp_N@vMRsm7zPbB-?MYoF +z=vPWKK8%loa99KC10cngcz@=O?Y_!P+Rexttyfz6l`r^hCT%XkXigEzHH7&Z<}Eo{ +z7{}W0{pFMX?aSMjgZRI{?QIk^#TV +z*ZlY*FSnlw*})Sh8T6xhaGP!v$K)OEDh@lX$BPel7ng1Yr{yHNx(7LVT_0q><1y+z +zQe#A|HO&x{Vsc<7jqi#&t0S5fRa||Y*5Dbv>3G%~huD%3&(Mlz7Kllaf{I!bQ_Z}8 +zG+Shz5?DDi5*2z%(@uBe9yCQR_z!Fvb;o-S@Q<0wUoWPqS3yQ`nvQ3n=2Vrr+-g;{ +zrdKB?i4s0SLDYDG+%;1QC_ah32^(8l6d`v!EywTn%v3H1>${?keco!eRhy*7?U-3o +zXIlF4a!toWQ%m1IzxzUs$`_hT8McsrEvotmHmv2peg{$QXIrQEd!4;_pUE2s2XqSk +zyy>yVBC+*GpHD+yZ3)??b$lX`Uk#pf1LEsl|G_{r_+sqB`dE~2viQBOn@&^aF7W%~ +z0X9Q)lZNo*u1#z_GT-k_1GK-y8yO8Za?AbyY{1s@O+%K=u!+;fPRGcwB9Hrjn|K;Z +z!n@*1%@xq4-ATTz<45a(VHZ +z;6Q_VHX3R)3f9}UtWPFx;|#`2|DGTJ>YK$ +zx)g#D0|tFHsd5cl*1Vb&;+O1yn@m)q8u5h_BHc>^20cqjZgypUrR|C6iAdkd>;=|w +zDe7$b1nx*(FD9<@8rvwJ6ivxQS@=X5izuCv=Ot7Li4LOgM5Yh~{nRV}LFkHTb*O0u +z8d5GUD4pk7u{=fTXm<)Tq@SKD6aTJkrEH?7SA&eDpzHMl(dRUG%xUU>u_csHN;m3i +zDW{W4II@c0R}&xF^fRr`%fx~{Os~&$UE6nXc`ety^HN%2q@(I6Ancz|104#lTS6i0 +zs4Gg<@ta3ICXw_ISLhYWv11o##eI3y8z63RwOkjTxFMwWKI@t6BbH$aniVN#kzdic +z?KBJ5r$=HPld9y5yM;)9N>_#G; +zf8u6oBzG}cyoQ<6*kXnrL{HlG@z2`TSIJej;FqM)#w%Hn+cRPdZ3z?+8@9+R$l7*6Oo6@Ph_#xD!{ujT0xbzt*QN34oOGA*d +z+SS?7-M0s)s-QUfGFGcT`D%VDo~QR3$ii+|`%zc?Cw&W171nHN$0y`kvkVCv=~`+vhKw^`lNe}8)J+{6rW?@ZA=lN +z0h?x0<*Ud$x}#Qq1~PIbFC0OByw!1CEYEpr7?EB$eGh>#_9~vIXGVfW_xJAZ@2kxf +zjN2Qh-RBOn`84Z4d-+tdrY=`|2sM~Sc~21D=hKDb%b5Ag1w@I38^e6{)7j!DT&Fh( +zHW_`0t}WVV#0NMMlPvu}40$-ygSpfRh}_@oB#o%~MSkUf<7%b3Nr|&;$)pzQmjx1d +z;$25}<4*_713Zy%SB40+7aBKZ`BB_ld`5kiKI#c+VCt^Dln308pZu?H?T5Z*_v635 +zwHEFC(LT+RK0WX3(@fi+=RB|Y7YvZ6SDiha`5yXT&+Ugb!n@)3bN*CPm;dp^^ey>c +zuk43*K<_7ie?7InHO6|GjP>7atVXTu|9px@gwR6NSv(t;GX6{VS_vy~=Nw%6p8H?_ +z=6fDqwca59Fy{2*fStN5|+IJ4P3h8^(VK!EQ(lbh6rFyx12QsZJMZsz%b&kkLox^)k{K! +zgf!WY8Eq$B$36I(|>#M^yRas-#>X8-VN6}zkA;J +z?hk)@`uyqlucL44m9Dpq2}KS3@Z!Y}-{bM-*c&(4T$@{k{SqiyPT>=}P$VG->;^%9 +zJ`(h&Y>E0NjP}c-R>6C9Q3W-&ZZGjTUw|x_^ABFsPqYUr#q{*EAFbF9M|u#szGC7_ +zKObhtA!#jt5;cA3dUxplb5O63`*(-g-GND&kUQn_y+I_fN*l*%8^>tlxVw$xb{kIE +zOgix&hiQXN-$VRx)6Gi=vOm23XA=XRa4Z`2Hgn=Jwuy-(Z3a +zM(^!e(vWXI`G$K?z9BY3aVX=e(Fks0tjWjmKYse?6X}5}5%?o|$P}aIZ&7Wq*zADY +zpXn|cB!j_>>3DR;_)=p;e!5+k{LEXo+yorqrMDg3v0wJDExB){sl;tvzFiiNGksAZ-YH9={K!gU*t2#Ln&o%DS +zZ)DLc2CpHdwz7k6vibYmy;k2pmwcBc +zgwfpzyFwO8@IIOkx~uje5<+kCk->%?v1Mws56QH2_ioe7CnrcZz1T*ucpwJv8ZZqy +zr=TL`3bh10Y!7k=6$4IDY61q0giJUBA7zT1K-+`C-|T7lfmpifY=ncbT9k$_<0H@| +zh?t?v5?@qX`m>rX&KaP84B3AY!oy~{0tB7a-kwkXBC0ONB~t +zd_!UiqyrK`S*!Sgj<|DAOeu)n+N0snqr!0&_cF)aBqSfnl`z_@Dork-rY4hQfC=t1 +zilXDgs&Dzs0&0%{{_($o1(f_z`@c@(d$+)~FOJK?-eb`UjU33+nY(Ni6Ir{OK~#|(ihVf^`8m||$j$*hy`uH&}v +z!ozj+dtP5eU;NwJvFx-VyA%dCTi4Ne{W^Qd+3!t?IZ& +zX3)za&`UTQsU$3GVsdaJuL!1SI?AlD=u!^dM#pgffFdq`{xRmO0eQ(r%00;#Qy+om +zo_mqQ_&g69B|+ibUq^>Wt%~GV)%wk`fy&=+6-9n~_}28axD}w$bCXJApMQ7*7n(2S#f}x@cInKu)vmU837Ynr^63 +zwI@-Wxr9cR%Pa@R?3{G0(TbD~B;<8jitdgKLaF6b +zPMyVD2n}Q5p9US~)MBC=x>?st6ELs&s^1FZ_Odi{GbFx5&s-Q{Da;1b2xZzmIqu4p +z!RL&Bi(vV14}8B?{EX9ref(ZEOX*|$ga_AxH^7Fpv4>sH9!BlCN9qDm6;DJTkOFTM +z@fKJ7F)8GM$PPyF_bV0W;6M#?G%Zx&)*xzcz?_cEg;k7t?YKOh~rWJ#+2l +zk$F~6awNvr*R2U38o6C@AjZ3|)_@FUoBD)nkwnX|G$#@Fxrb~rNyOBA;s%f8`rGjJ +zuDk6|ZvJT4EsgFM<9E;V1t90xg0Kh#J1tj+=anMn4c#VIOby|%1SjL9K3!DfGq=-! +z-s|W->1-fl9_8KrFgW?BD1DngdN+v_>tqcLY;I_V91)^-X;&che$#m8E?Urc|MsiT +z2evd4Q*gSG0JL5Ac48fF5KycKN&${d?dh%*f;i0jY+w1Q#4Se`>f{Qw#NI%|o&D{= +zWW$1Y^H8%GxQ*$qNG@pYv*lv#LZ$S7_(4hhh|di?ceq_;i5~w3;b`JfOiBmYL6Tl| +zf^IQBYh8}(3`Lp92!u1B5Fe?W)fXi#6?=$;K9K-*O~cQZvtkl*4>h@wK%`SQ+k)3C +zu@E3y)ukNGD=r|xRz+q2ED}wY7Gjj`iQUosFgfzFS8k!W3)@MqtKuj`lPJmOW?@tJ^Ps3a$B&yn6WrJ3_6>aPQgCl(c;-K +zDI>u+#8ilb)Z7_tN0Ue_)KC_J&QchFBnVC}M!9OAnwnWvqwELtlwK^qZiS|6;tLbS +zca+1%pgzcROfMjdvit2b}L^@2|uEk%n~^Xy;jnkL*JcbSvl@^MrUoK +z%Bt+DJ+5$_dHICP;3bpFLd?9#dZ7@_x?Luc*2BgKcA&}A7x~o)(9KG4!2POy7y#lz +zYcBSZTUBP4pv$%U&t%l%qPBToam4+I=7_v4LhEbV7(CSt-~zkb&6VAMhoA5b31;o5 +z!df)`WlMnD#3jS)&Ca&YO4*EZ`-wiRr(~nibT3=O7V`YlPzWcL-O06@F=&lF8=I|@ +zPJLbE>=GLB+q>nCaf)sQsDG-t%WD+h7? +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 +z9^SiyfB%5+so^ZqoXX|M)LXDgpW( +z7RoWbZ`ZDMGzQ-2{=U2K7!&>@7PWy|P^5?ge~H0;XR&T&ukqfW)uz+EB)YC2O2CQ0 +zOO}<&TM;*pf6dp{2Vr#Ow@?j6dw(af}fHg(#eM)8`fo`yBP?x6rAa6j&3f +zEo%He-b(&+POfq%r2i8U|AoxjoCp{D(k%ZhIl#Pytqep|cPAQtaIsOF>F!#^0K*W?ITKD_6 +z9ZhZ&9NQA(jl{+4Wy7{Gm7@HnnYLjtARZDj9s(Bk??YF95^m-2_g9 +zSCY_EWCWt71xpNo?*xVjL2p0-rq9r7%eZoj75eoYHUe;p^f6FoU +zvOvSaHhlM<6O7z?yX|)>vPuNirvU>eS`?bXqFT*xkPosu?r-}YTeaRCd&dVYi* +z;($Y(k@pliIZ}%rqI8Y(j!T8*D6_Ds2q~)03+iX>)_tf7aSFnpHw` +zx$JFCfg=jA#A;~}lZSAVY_8nyuL5@PZe+WRoJJc&|9arwzl^;&<=L7$Mdq?@tW!maBXTw|+MFVQK}eXV)U^Oxk4^=mpQAYw2W1TM66Gy`M3p349uOhQ +zK1^w9BD3FtjvLIy2sufsu`bX43wC+tEitnVoj(6B*y;1F^L+VVe{h~JyGY}Mw+8J9 +zQY3?|05;w=u-fysWywlpAgAbZR=eKp-TK_#w5XZ)GLx2Mmhi}=JQaDw`z0apn-7+x +z?sNxbzSIFMv{p`+r91B_5V6N7sI6|&B&|pMtL7y62W@aYgKoRIzjo)sB^fQJU)l~j +z`}i!V>H1W``TAb(f7s)X$bqh()7gj2>Br}hH=NVijpy{^F~}X}^!!8S^rN%zo6hO^ +z4d?VDa`5Zt^zuXK^y8l~H=NVU-RQJCYE6CIf+fjNFkeV|1AEhVn`2a2@Z+4Mx0B{SWWg&ScU(aa;O1`!BQ5*Gr@Sf2m8|eS-a`P2r7}x_xfl +zj+sC^lmT%_@V#{gPZCQ}jBcKNEUOEvh6-s^eS0ka8RW@fwg70r@$|~7xy8Ph`al}! +zdEcbUlj^bbe#DG%5qJ3C?3dn$iCtY&`)-v|?+4j8?yq|f +z_OrhG&%iy-aGpC~m-YCfT26`l_aQ2dt&(^C%DaBHe+NT@a5`+dfInCTXn%9|q2JtD +zMDFUwVc=IleidHs5B{^t3IeRGGog|&9W +z#7YR-N1fH~ugyN_YuC@`hOeFP{53#MP)b1Z4FlWzNpPnkSE&W8LTVQHY0vSzSvlEL +z2gR@Ee_af{xQ==G0E~~ryX2eKFt3f@{4n07-`vi;HhuF0d6#_i8s@d>n;*!#qV?Ro +zsei?KZvN&q%=0#62>%@0)9R)bWznSpCYVKz#qm|eB!LfZH=kLhhR4O%!hN8 +zT|YRx=7T#km7PC$zV(B<3tzi_@N)YIcV}WZTEnp8Kb(i%Xbrb~aAy{Fqcz<8!5syz +z8_lOmDjz6q-DoB^eQGyR>qc{!d}?p6e=B8E4cd=1(5rfvv#M(-?mlCMWDBOq4J0x+ +z#3YW(0vi!ZirkGTyS5f6;>~MFu!h}z4o7b$cSgelBr~h;&RBF3M;O`se*jB?W#&UI4PF}pyWK!wKjMKO*TKJ+tDp1_ce#*SKB1I_;`F4g?d^G1sTEZ)#;`P!(YDM>f1qYmOjC>l +z$UT<~&7J4-vOZ%;Bf@kMoy!oKop?WXO)0P+yJG-ZYQ@998pew!2#Mn4bo~^w=vI{sy>C;=icwIV-GlfU5r{99lN3O4lS)tl +zqYHv2x_4x+=NFEC6WSbRe^J#DO{L(KTl|9C!-HEEFVC=efcw{Lr+^%w<{Rt-S9Ux_ +zSp9$rWO6~>!g$i^Zg}Mhd{QwY;3w@6UY~@~)r002>vtugR&-66PO6F=U@ZLc8e?_W +zBy>re^fA+yl8|Y8itT;M&_ZRHl9tyRoV;ArFw4A#_m1PNV;HM8e`b=! +zm`@r5bX%3NPtpeoq1br$*C1hSntmUlezHc?Ix1|OFjSKWC4xO^PI_{mVpeUViTb%> +zHT8kC6_BM}o8>r^*&7dQ +zN)i?+oE3S1gX|hLnBxP`Oh0*Uhj&gz5k)z|uJtvbbCr*M4CqGW +z9>IhJmafi;0o{9+t~-Z?qxq +zZ7;Ys8s!I?nDxf_-|pJK4tkYU@Fg0PBz3_Cx)%TF5tR+K&>XYyrCkMo8vj8X +z`eQy`RZ=0-7adO1BaywR0xp6xy$&9@}C1Au_u!vdpy64q+0%zA9Ho$*rjVXP;P><;n(@-Ol>>^Rw)p +zR5m!o-GP@(`>naLmd$M3IA&#}N1y13TUtT8oM+ceVo?O~r@`m+DmQLp=|Qk;qMyzz +zL1f4raVk&8y6 +zk`y{s#{!5EwH_b@9mKHkYC=BF4P9bcEDF|HM%IlM%PE&$ghipG(;zHs`>!;|C;9Ww +zV!QIEE2M*AkZIy)zq*ndPWy%(QN=P4#q=C8x;J3v#w5852;gCP->?Wv;Sr*7>`{yt +z^JO_V3mhg&z~T3JWunuge8*zvM@SIh-OXq1Y7 +z(;`1F0*beHj$4+NfWos3%hDr_h-RYH0K__>iJ(?UAt6~F?77HYf0K(?}nH|kXX5vjkStWev!&{X?8 +ze^4>{UExk9SS?ucz;6usUcBvt2(7Q+bPl?lV}6b`?kjJU(&C*0{g!=KEz|pK${53; +zG+3W_jw_`uwihCLJ +zm5;FLqlkmnf5s2IZq_lgdhO^FyV;@B{|dGd?=;sr&*pvq0fx_}@o7QfvvjKHI+bdG?9TML65SF_bQr$%C=t*f{$0$>gQTBYl%gb`=qC +zWnPql-%N!XC4-;kbe2dfqddW->@cYeBPF|GIEg=rf44M2pUns6qdm6hEo+;9C$Wr8 +zI~5vw?^Wu>TBOF*i$`fuicpoPkSdiV+Jdl^lYrz#3-5^ro5`3r%wsgq&F;QWtk8W< +zoZ2X)AZ+gEO|f?kE96mJ@(CxQ2Tm^Jjd9`2g{ibwMIxXY`tin9y95_2JftO*Hbj}D +z98^&>f8oo$QJELVe4F-`|Zexu7fG&VqGRg{kGdf$8NS*oQ=rvQT=lr +zSDRJ(ds-syP=6R2uN}v7b<|>^cp$wO9`?*NddU419%!-L=s~^WAGQuz2ZPr;t^n`L +ze|(t$9C^a&1D{xx;3(LKw;vh6w3Vz^aP!4tstBbl<)pRbP}0e}xhB>4oqO$KnQKwB +zW7chFd^sC53r!MSu9`d4@e2e&QvKK1(B(Tt3q`fkWici7G9n_ym^i?5h*!=!egooAC`vPOgt2qqpyYZclwk(m7>s-Ki@hL@Ate{wAR +z0iZ=BeYH(^errv=7{7}v8O1V;1&UJ)ib9L(P$3N#!1lRl6&EMcuOBYv-w=trYt%mIo?u82}ZWQo}aCk +ztWYtzB6AQ#=~b~{yxh6KWGxMhnKs;f84RKBk56lfH&M%s;>1IFvyP8ge^xNJTNf-5 +zcS-|t$Z}90+ADN00!@D9x=_D+{^QpNS?^!+xm&||_CNo}65&0?T+>N=xKO%5EEa%p +z9l)-rF|3J~5-(=a#(X-JD +z`?%j9nH0oUMUe-Me{RFzpH>ifo|LzD@@jqj@5Oi}U6`!ZLMR`xaoHzgpLfJ= +z82EKjX`=;L*=rs7VRrZ7t>%~mSiASV`FoF};;iz3@?zm&kxez_9Lk1STfq^F(}>QN +zc^$vN20XWJcIHT)hos&AM835r{Ltw-C?25~Kg$HFBJ1w*f6*u1Be9@oek2k*%%k4y +zY)Z4*>n(lWzxAs+v|Cq5s?EN9_{U76-T1+{jjf;c3TIy$Q(x85?a}Su-2U?RXSYAU +z-M>A!eRTWn?Z4dq?JsZMyv5FX^XB$`PlFOIs82Qni@&kt6S&$5igv5+w1E7eC8b5l +zq7zo^lgoGOe}!YFaOs+C6@cBZ~KFTA+%yhZ2wz6TReJu +z^p{O{e%>G6|HJz)2U#B#AtY-nF89$nIZ~)1LdX0q%Sp5~sweigSE}?DL|=bXoon^c +zy|-r1t&i@%4WXSs%%eg^nuU-v91$qHI6Eq+D&j!af9a;N9k;v +zn;Xb=Lq^Za_4qa7SDeCb>lxXZbU=>pxD|YD)6`FWHJwvDcSrYOWMT}~29!EE?C9jJ +zO+6<#h)!Ssn$AZdq5P2ib&-kbN5l2vv-Vo8f65aFk9zrB7Ra>a2vDrKFrCZ?WiDvK +zW^a#vE8$Yv`-I5-_t3#81d@spF7-PfY-vu7b`GftN(1ruham%c5E}tnuNwhvAqmYJ +z_8Z%sFH5zC47wG`u2w$ER9rU>Z!c}Fa?_?0uYY3>8Y4{2BI~)94E3hNP}@hWF|0UO +zf5B>p3X|VFfAWIl`ux?`FHBusI$kSf!^Zh?DOp+Q%cr%9?i=h9o}rp*eZ6I3+<4{L +z| +z-Dfn@8YU&(+(MQC460^PHmVKvJ590Tf7u=7#yIZfbKRZBSu>9c?w8}~mBnJ9dM2!4 +z^Gd@4)y|efb3S44ijtwQL=WQcC{dipSA|rENh@1Q-u0p!qjM0{xI?mhdf}*d&no?; +zAmNX&DkU;Qa^e=OYfTRxn +zh@TK4F`r98Odg$2!(eAhypH=kL% +z@l`&D{G5U)0D3KZBk#QF2}L?7e*~6mK&~yV*x?=n@p#l;6#!gCQ^&45>oRVfwOA+r +zzOGjzTwWG+vBLE?^Ii~(LDEt$(dx#wi^iTp?u?7Zy4|u~YLb*zWHie%?8&ZoViU|F +z$%}>`ip#V#3Gru-Up|fek3!?aDETPDJ!?c@S_ruz<)2t#NPq-ko57esy=LwqFrsQC>1=(w`Nwiv1VK?yQA8y~ +zvxxf%&kdU`4-(Pc4Pv=oe_)0EmrqKyf-vR|#On)jO^TCzJw;+2lIQ9isSC-RGe#)9JFfYVXY_9?ZmG=w0jQaj%>}QhT41cB5nCMZtsurU8Sx%>0ErN>HE{toxhd +zs;0$k1)e=C;20VTfCPshLJfy9M1llfAtXcWVC-QsV|FfLW1P+%e{D?Kt2!c!d6Ca4 +zV9zZ!q2>N@Lr;jq^80uvvdb-UhT&V7qhz4E6Hc}Prpsa_^2{mOb$+Trjd5f&p3lpg +zN1NjdBqzbU5rd)v&5(^D_=IfW3R8=6Nq3UhVcUbtl_Lp0@BGmXH- +z22;@^Oq;sMm-Axs%6;pPIq`3re4_P06pVS}-NC8jVP!*5*CW7VV5nf;Vc}`Im~7l5 +z;fO*RBuMeAYRy15TQetniF789h&9LJqE>J|MG?79`eOjCe_D2Ri#iFQuBOH7QtZCj +z{!st#-ouBPWK=w!F3xhwXd2_oNCqcw=F7773HNg`^dS7tso1Pe)D>|9;?#@0}`+vCbqouSTuVY +z;De;GQ!$a3f2domqHdw}rf7|N1{R^mICp_U7l8Zq_lNv{11lUT)mn8*v*RhSDlQ~} +zmsUyv6wXzwUP=Xcg +z(}YLgeB_3P&4(g9cdG_gAHni_DA(}YF5inT-;;o0f4g-*x^+Li@gTbV;B8VMJDO)* +z-#qq*Pa*&i9x9#La^7M^$sAa0dWS8tO0F_*$NXMP?P(=z*$g=e +zc;9G=-XW(2NQi)$nB^gN+5nM`Js)L{=T{;kA#0Myllv4Z5RKh5tDd4mAy*B)R>>W5 +z`{5)Xf2&Omp2$hvT041P`}@R=DGvJ&0Zuw +zfv4FwBOo8W_A_rf${5Ozd-mhL`>~ItKhH+>9TI{(^Wd%L#Y%$~jb+sFSa{WnRh3pL +zsWiOSbY|D&9rFmrNSwGQ%0R?Bxw?oLP#D*BsrPYy?}exdP%Jb3|v&b@Xa_I0sK=VK;yV(&^!B0d4uuvkpXBDS=K +z6Jh8BySf-(9nF>CQpnE2c7#^ajO02l2sc%O64s?t9>C}{lwnd#OZQ2H+PQNMM&9Eq +zf7=k$TGSXY5)Z<-5F5L2b~#`WI5bA3_0p@{n*SxjU{YrY9dy$S3z8<-3Fnlh(FgGF +zMIo+mHxf5YnSaGPd{<1bi1#RBUS&N|7l!2Z)_6{n7De=O9~u`2*^B7R5s!TDCC*-* +z#<~Z=S;Fq&7LjuH8fW1t)Ub%yZ9RdFe{Vyp!+MCPmrGNl>MZ=V8 +z*A3oNpE8tBli-!A_~@tcez3IHY)>3n__9PUUg_~?OM(+dnj~z^M0%RTzchA?fBJMP +z0U=C%Tmp92ZJbFl%3cUgyUx1SLK850ic! +zxpzm3OQQA!c`Win)$K0mQ*;0gJ9@952ut$njB++8mjiPhcT)5wFoQn}WdF9^%cHq@ +zbQ_*r$h>u*qk85@0S)VsvRrFWre-$K<{Rm)8STI@`PQ&qDCaIT5KUepf8T#uNdAW- +zX4UtSj>`brJ}QBnBL8p1KNLsTx-tqZBX +zP{=&hcyf2V3}ZYxfoKR5RMw_1U*uP0I_BkcTTguz*~v6#Fp*n|R?ZM2P$MSSw=M@x +z%{e&Sg{Pytl9{uSrOSjye^#K!*rgN4On!VugJUHjwsQ%TqJU##k3^?P0+q2^bH^~% +zz^Ev5YGxaK6%rSqkp=&k2L8EP6(&_7t4f0xEcyqrkD0N?Ah~rpRc=(N)F75q#;Fy0 +zTC0dqksBM!$D&)4rpmHemE%mWgw%n)d+{wbYHF+M?HHOF%z~r)e*=}kYS|;~B{V%5 +z>?q6ukXbcfIaZ~bRm2j53rtnmSz%-mPgxQgMn#tJ{NpPOlh!aQN$#%$ +z)9|4rV+zjJ5?k)4E83tsCmQG>UVLFAeA?6C&oVxC(fxob=w_^atV0t}R_XtjzIkuc +zoA<7J^Zuqcp=(G_f1zBwPsk#fJM!D1XE&-xx*Piz_??KeB%aeb&tA=Q-o}OxLw|p^ +z{@e{+yBB^oI?RA;@#szKj#XC)G-9SAa+DMw5m;F*_-&g0Xwjuo0ns7%^c>zc{aIJq +z+fO`-wul2znGr#!!qN`oZ(!BsT_2UqsxtxDJ}1G+jg#-^(Mb!>1b;DjV7nCOou@~i +z=cFgymhIL!Z96QuZ6m;8+%&~9p?<$Q@_kdu4tH7QMvMC_Je-g!H70YKy5Wj?;GIgM +zyNMmWb?T?EKwWJ&3Oex@mS(jrp-OCi6{#mQ)Jk*uQYu7;e)Rjn+n}^;lU~g< +z=FZtfUom3ti90cxl^&+9_T{6`=y{(OaUzZ868`v1tyOb7LFMS4GX^$3vylNn4}mB& +zqNpB={cBEbdPyY-_9k_3OB7aEh-D#gE~*kqpq?yW63>5DRexBsFvpI}1;VIH)CrGu +zNIL9s#}3_i_BD5C%#B~uhKr7c7GGCLziws?|z#cB3S%3!ZchH)zfX1pT&dRWb#jDLUlxo=k(_Lbu=2ym-qYF-}f4S-*5bF +zAMGHpt?Q}l716UJpa8{@#`83TE@H;{6w;8W{+-&12(b0ga;}Km2c9q~7R(hx;hl() +z(VCaeme;``SL#L2@4Zu`AL +z*I%6#DECx5DV#S3n_f_HjhDWeUMy<50>& +zG`{1g{oWH%Cp~fRF@@r`qx;)+&ps4t*t$QCr|aeMV3_R>woIRF-ObY%-@kVH;(v#C +zn!e-(nLfFs)3-$p3KqhAY{(-uo9)dX@n^D|{R%PT`CMFL9o%v+Tf$+vH=dT_ +z>0B0cZO#g;24bMrwPNR^ +z^MB>E{B;yDeEK}pD=ovE;*+2XQXZTdiKZ-m#JELG0RzZW0y>Z)8hZhg6;v;w27-yj`NbAM0Z1)~JUhBVf9v($+#89B#a=f}cQLU(p^xQA>@Nk;5y +zGj+TR&=Vg|hCa19?A!xwz);Hx$4G0;jg){wJZe-K^IEf@cRRze-0 +z6_3oprq*s8c{QLeB-%?1u9y}T50lNII7v@*p86@(yGa;I`bvQ7)fXkHr9t_V;skLK +zxb<~$lF~cwMH8sgff*BxT62?SU!6Z~oI!>5%?z%eX7&xuBeL@k!H!n25IrdcW1 +z*G9NVxeuO|qN9X`RDbRg8U>q)W5$6oralVo(qdVhm({xFGPoYIi(A+ +z$ty$CWPFIdpHpg@ka}Rdqqt(^HOgL%m*ql)AE!fTgmMHNX%Q+gl-Ii}~%wmLniIVx-x-62) +zSGZRn;bxRFPZy%~KVPqqa5UD^xDv8*<)~5sBx~=|r@azRP#R97lmvBt!%a5N6{1mdi&aZp$c0GDC@0ruv +zo4C=p!7zn};Qa9Da}vJ$KNRB%l3=5z9Ak6fRYjbfa@SN@af5XeU}4>wY}1b7MbA6TUmR!{ +zvSJhgacA>zj1zb!m*loMhsk3Sf)3zt)xd4>SWm1Mb**OV5 +zQB=5(s;uHRc1*OmDjH!?SBqlOjzGQ|JNhRZ?|%wCZf(&Jt@GNh-AZb?39N`09s`$) +zOA{EdhJ7enjOO7I8W2pO>~{7^xJDc!JMK3C*EU;h_CFXY)P*nDtr3yobX14Fx6GpI +zDct*+6q57TaYRcBh&z#aROC@KUYwQH@1-FDjwYI`z^FxvWK +z27k}}N0igZLzqE%66(IzcsT1>=@)fKeC{^zxZseAxny7aBQj;6rc}F^2213#Wq&5z(WTN;N2u7=2W@SRX)?$BgTn3Pv?E6yMByt-JsnfKS4= +zBlk9;p;DZnky~n5LEN2#v6K6j8YJxgoX}$sjUtXv4p;xYq)32QM)1);4v2RzmYU{I +z_$!adfTzTN2x>vOIl#|2Q44(~G7PEY>z?%`Sb&aQ*8X8p%sk@Lg=_>tk7y-(f`RuQ +zPp3V_LTt<)g4k9&PhWzH63wU8CCR0RX9G1Vo;fOae(IuJ@aBV?j>;t8G6}TO3X^r8 +z9}rR39V2>KxP!kn7)YhrfmPC|rI5z0Bu$MpaZiJPyJFI4yw!F@wg|@5w#IPU)En>< +zg};U97q>OkDlD3aAn~3`e5DhMCZ|O}l%bkqfI(`aXqV0?gC?O-slwNr;*h@|bBII9 +zUM=T>z%2|qPy?Gn$VBvt)J`FkMj!V_-a>?c6I_shfX8}SAjT=``LvXN=)Btv(k|$d +zugjc&1)D+i&~@Fd$|FS5NxxFuSum^m +zy&=~neFoB{yWxY{lAB$*HQMNg%p63KqrS1Jj~iCpQnySU9RmZTC|`%aVIi==Elc3pGnAB)BhBCjiiWeu1LrSUe4Gi$0W=y +z4s&^hqeyi-b+VB1s17K=8^mvBgdU+JT^YxJ{yO$r +z0zOntjKNS^^(~CJ56d?&%V)GNtL56Dm<;8&DA<>;p~dn +zz)wOj0K?HH+Ww!=GfHK5ABK;Ar1{X^6el#l(GsU`MZ9*eANA!k5X?Y0?}K2O3r|FR +zH@e8iPE=3p5R!Bprpcuiy~L?ygG;iNcOIO)wRv#vDE%)mxK8p=#H0<$nq6z&W^Ap9 +z<}G=iT@$^rMSV&Q(eY4d*Rhm4k7|+_k2;Ken{3M-DX`o0w2=H#w2yHdm2ZXo_aoZBe=i~ZsQ0_k{~w0C(Kp7Z4&`p)%)bEZ +zmM+K8hLXBmJF{)sd3Pn6z+hlBca;+nG$(4?MB)P*XEJaRzv|b2u@X@S!{gc-gl9E{ +z;1ICOggngt$_$&oS}h_c@hzRiUvwmPQ5F=BrXjzZ$vm_eOwkcUzXdW}al_D66|H$- +zaM!PCyqDt@iJ^bRgNZw|U|^fYUJHFR4pZ+)Wuc7TX~5hQIF*$Iq4;_YqWf!Mpq$d6 +z`+(J=nM;j3QS4iP0I@B=oUV)nL4Ee;_%(R|T?x}&=GqX$Ba*9A6+}Lk5FW3t7z(sy +zds04!%YI6B)6Ie=GjUd0YCQ+Xztbr{~pi@mSMwV&B+0UruNMmvShqCKV2Us$T!PVsP+MZih^DDoS&rPSOQ! +z>DMa*#c&K@373TFNxk!BV31@B_mD*BXNk5NY5b +z3f-3IPAL|Dhn;CaV`?fd5qdSBm@b!V4LNS^xt5=puf)%0sLv9#B4g$E0!*;<8Us0| +zhKoKw7~S7r8=MVVdN_LUa4jI~+@mdM^$D>4>s74|3wM1f#zw{bN71V;ES&a^?-FI& +z*JzEub+cL!+kh#Wu8Iwa6Ksrtj0d;Urjh=doNt +zY=&HTHkXH@v#^}XL4{~l_KQmfLSPyP11!vws(=`9s~3Mm2nF5!RcP&mL4Q`tCJL}u +zoC|Zia~j|$!51URn>`SB2~IITxWxTF?Z8K|C)*e%I!$7u#0&;8#%_AiHW76@fJXE| +zra13^`}|*>_oR>dy+&5`?Kn9djgBHwtfTCSaQK*u8S0^CG3OY6XiW0M +zLPEtc@-!l+(gKH>d6taLjKZ=A)mXPdH#!@Ca>Mk;|2UNS^NWPicS?hjsg+V+i)94S +ztAie?2@2omR|fw6mUa#|cA!B34a|^sBy1$s8$?f6HJ!GvRB&Lf^FB1yIAKHSe$f%_ +z-;k&7SYOA4+e3c5OSFx|4{z|;Rq$;eBc1ciYQ^puGS+f+6-~AFt#iJvncQ^#`W;t) +z-E{7=yzsR>25c!}O)R!G&PfowI(YKuTEvf^;zzJtJ;XGdA;%l0^^WhiIqn{38RUf3SWv;z6yzR +z0^+c$wD{h#4pm9ji7_ot3Yr{8TvfuM=L(~3`U)bv*{@Jpj4n!19mmb| +zcoAjI&Aptettu1OpbaTpjAj(X=#}d>w)klO;lm;RdGIjG`KLrTW6|-Il)nXuNvR0;R2ANQL_T$ujrpC{|Ifap;a7oZN=h +zz#h#$b6WQX%+FA&`CHl;`f&Z!154;GDme23H|&YJV6ln;R+z;AXlXUEK?- +zIoQDIn#kJ9=yt@=vz5^2Bqm!+k7+iM)nmh$h +zF!QEre^ju9&Lba{?NPdd#Yzg6o||>YA7#;LHM1_Dua#|!^FlnoAqhKQ`qLYl{;O(3 +z@}rsuBxD~cW~(S?I3BaLrbfc`Dydg32fIWQv6)7p)4fnTP~+5pkb?(_M|$Y{#+78s +zTSatGNj5R|BV~C@U#VHIs{!}4KqWb+uojnNpfj275ibyA6$V@cxd`c%ipeBXf()a^R<@bSqH*G72h>X#ZVcUn=5VJ$5 +zHK~OOkx(p?;oL%pf|}AQ!C~fal96_nQQxAG^KT6Nb+s5!5?MrNA_-pnKP2f*^eiON +z&?FmfwuA!6YtZx0y6)cb1avEy26j8X_=5D?G`OGH|EtJPr9Y$q2X8t;)r+4e9g=;J +z0JllwAxyV_8Te&UOiX>K47~x+tn;;pcUT#_L|8AedZ?usv-FUbmU>tn3uvmxo!XO_ +zsR_*+Q@3cWqKXV5Zq9P9mAA*mDErP`BU2}B=F?TNoQp^+utmb~4@40ot)Ue$^*Qe7 +zW*F*_pk1)_Abo^_W_I|<-jF;l#YK~Fb)sD7OkpyA#nS3?dK!-t=_O6zn3Y@wYeP>! +zIi|Fxd^FkkTUFrDL7$#3InusXk`r;qD^y0#CtmrH=rD`+vZCa(@PG8RGr0foS7I15R*Be|<^xYM0xdL&8y#|GZ&u*td +z*-@;2OYEOCNP_hocYJ(nl>8LE?4#1!@2e{-uB*|4=JrORZVYaJ+Yn1uA~q=#`Wd;8 +z<9B=(VGHhM{~KiG{{RU_e<-Qfaw&V?L}Lgz`{=-Pw~G9$kI%P9qp~uw3Y-X#h`xjN +zb8cFg^rNoy$b;T^v(0Z5ztB9FCMEf@8y6$UeJW8W*cB*SC^g3f{Z(~h +z-R|Ox)5_+SY@&5+o+6}Pv4fzG;( +zaUBI1J}&XA@@dr-o6R-NfX#!-(lmSn=7es%Z%J2$ZRIC*-O*gbx!d`*s2ia!i(ZgF +z&{qq?loCideZR249A&n(RhuL@yf@d-V<~Atin11b9YN(6Q>3&<*nS~oUp2Q<1yG7L +zi>io5IYpFG<%|k|*T))$PXdg8@kA6{7|6yoeVAR7_JlY4y&o3E8~|v&uEmN=JK2Jf +zCIlKUF`mN(gkkvnsM~eBkQ4ZU*>9rV(HnN`gIlUyb$*A!uuN{#uB)HXE};B0_G;%R +zlJZb5n9V--y1ef3*t+6_rB0cR@n>}%d0N&tsV|k9k_vCkad~PfuWA^7@R;Gp>l&#n +zb!6WE)XG6A;G%emij`GVIM&grR_N^vkQzF`FeB4ZpM^kpsQXyED%HDdth +zVWZhxGhl7pjY>Kuu@XpAo=QwPQjAh;7yfNMuwsMVr-=^}ryol$`m!Q0;+o|ysgNEb +zC@A}QE37&wVIx*KR;)08DO8Yt6Z!s2YivS+_jRZM;e(*iE$Nb#cvnM``wDe?TQBg3 +zQ8e>#r}E|QxfjL!YDZhU*zr;$db}dkH6&8ke^=^Anq^+UCpP&G^@0LS>*-WNX=o~4 +z!)i96wyH$y@%-E`D2*lPNEFfx9-4uuV&0#YEDgMd+@ZRSY>9RXxG7zGIh<4;d2nLUb{TS_}xd*cTy+zb`hqt +zK2l_BY{#yD2Spoq+Lp$fDA~ITTAjV@W&)mv=jTQ2Ku@AA6l;qTEfJhNZ}jWqC0^dY +zFtxc6t%b&f;ajZ>Dgna##3-T$YOyRy^|f>EvNpCS-hHfi(W&pVUag53^6TB5+dP^Z +z2r+eSs$=pn3m!^yVuk?3%=cLSjUH+Rclsqt2AkA>iHnYhB*G1>>ZF{PH7L|-4uk^` +zZoHXiVJnS!i)D-He&@%Oxu$3B+G?Oecvm;C;efAK?ZXkcq7U +znKUJTTAUo}l6hmCj`iJ-^9e!i1klU^5W8Xz-AKFY-0{z^#hwiGS_}RC#}+lEe_u-^ +z7;~FT(Vk{fPJ^Q)lA&>xM4adP8i6RwDkC-NghX-#+_>1?Y$!&|RqvEzK7YQYZ +z%~AaVmTgh-l=Y95&Ygu80ip6CA03c(|4hk`q~wIcQ@cf~JB#3;oG@!0>Jj +zs-;o{>L49L^6`X4PK-q}|Np!Q5e)*@Y0atNp*0E{8JX5$>P0_pxHEk +zR_=&RBSji~$w@74>fT_22WcP|ETtgw8^_5#Z;~EehYVv=w;dcIjqvd^7fA_@oS!%% +zuV&9y#SCCBn%Nnwc@2Eb&9a(;U#jT4L}B6vR7k`IlAT+{Cr|`qqVS?}T2bYWkX^za +zYxyb#Ri%u^xfwfz{k#qnBjK0aE_f|}g2vdFJ&+RbUUqlOhPW$l)1GR&OR}z!3#elh +zni{*@rM@#|w8cuCoN--ZK}nKq!N^v9s!F$X$}E|;GFX;MlO%p~cuTE!6g7RxfO1LbVP+|R!Ar(? +zU?;ysG1pr7PzrPkkdbL~XA8urm$O_#CZzbB(7 +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 +zkakyu+e58LzPzE(H)kf1JKG +zzOr%YX^u(OAHI2uBc*4)3D&p?Y|$b|HZFeC=41~zjzB5tu_k7U;cEA_H6sHQZjtlV +z!oXlOXpM5mugOhh(01NUFox}Jp$+LaO^56@2iO)%(RQOx<9;XAZVBe>40cQ+C6X$$ +z&1nc$iRRSpvOoUws-eok?2l`!e}f~5XaZgg9(CaHBuleiN_39#eTiqX2Fv+)x}FHk +zmB)qG0HC=Z9cU#UeG4vPllyw7UH=O4fgRg6f>+t0m1irlm;w$VU(yL$v4m8&?JaUB +zNbp(b_sv<+klY2QJwlX{&;qBcxGg$sF}q!`X~k?>Dk^gu?dm|pL^jL7e+L|GSzqdF +zS7IpWTL*Y^5S`||uF=K$M85L@TW!277aC9;APc~_CI^JYf>>@yc7>xCQ9duusKTk{ +zCAm+0ZdEOkvMvH<9E{m{UCoCHqK)BvSy+&P#_-4ou^LEA!0u+KX%_;^sspW`k(a0P*4~7yQf0qW+)he-wk_`+J=AMYtF9UMk5+O`Z5U)I^4&F@8?1A~*WVB@7)1U;cF$KtEQwFbl;(v$_%)PWyvBXYV +z98`%H_Qh>2z7F`PohW~mexQ>>cjr0!q4muOrzS>yohFnq)|!ORJvH?j2-Z~+*8`g4yuj~QGL+nAi2C4y#q%IJBEy +za~=I{OL-z{5sW4+~GD6;~Uw7fA^cX;V>++ufey|tBe*6=?<+JBfq{K +z=S}+6teg3Rxik)`GXcpQnt3RF?{d4lf`HroVA%JN^Q!pQgJ0d{mX&)iHFE#z4`BZ_ +zKHzy)NZ4zzgCRBpykeHa$CR%1>R0z>`|-TD+v!YelNPJl;FgjGc63YmQSB_ue}v&T +zf2E^6m5&mGSiD<&_|$fZP4-fQRqoK^@6;D}?bP1P;|EkY)LjOu4+zYODF?oD8qH61 +zt`N;nhMs~Vch?2G`TXCm8*_fUzFkLUz62?3XlDxkcsn|tu9wF{53sCL&quz`6&$GN +zmuk>cId9|qM{dhlsx*r`!8E;%N5f`_f9$DcMWz0sn}e~pn7Zxh&s_r+Apa%j(=9|m +zPsTGtnNp9juZ-x6!6DYNn6Rd`8;I&;V((lQ(;}}mv>0_ywWMqHPAu9GBCSZlD0_^s +z8)hKN+*#$?{5;j_i`imzWxc%R<;R9<4a#Y(cXok(hSV_^#6;Gs`LL$OZ~e_`fJ +zjQ!Hn +zN3v^AEFeR`gWbV*#gHS(k5IVod}YNH%G%l(-Adg}UZiO<0g`0aF;WW#R1Vf`XT#$p +z%Q%?+)DeN`6v#sh@;@bjtiPU5e+va{Op4|V)Pv3_E5BACGxgvoXtFE>zr@%rTIQ>{ +zh6!4vJp%izEN2Nbc0mhRIkV}9Kq+xyh>fOiBkTdggw(VEDd%BX`l2Bz{p3+kTtkuz +zob@HuZ23+W8jlR3hyk>wpODR@dC%M;NLgChHgCI5w>wU+bDM%Hi_>aVe?pvMw%~e^ +z5&w^$gxEH1%WiCecswgIgWRld% +zs*(RB^>zYsfa7lm@#08~UTz|Zh5=^P0_VuhdIW; +zqsH}$bKwqK@XQy>g1JWHf1>W#RI-VfOC|$qZI{*)*Ty8FgkLp3DNp-7b?YM+E6q5S +zL(qy6+9}vf-L~Ae-SV-~@`i>rd)jjScWJzlY_IM6h|%sOi#TjF$?9;g$HAsAG;H@N +z=O>Of?TY)o;maXzq48o!t19(!^lmfrs`;){WL~)$(5$EEMaD^se~si7nvC8HNanua +zz{|qwNlB<})KFSUqVau+5PeA$<7U@SN_y)XZ@l7e|7Kl26Znv1rl^EcM{T_I<6O~3 +zUbwxEg$wU2g#0%xt7Yv3~ +zgR-T*0iqns+R7o=foZI~mJ`A;^khumT|Wi*T4X+wvW=Q?mXB9Fh!|?8X_btgGJ#EF +z!Q=37Gj6bA&8e5IAlmtW*G2WNn2$0gM<0tIREyf;d#dIWf4Q`x_*><^%D7I=P|mOT +zK&!NJmt_s|(`ESbdU3#VI4$Ex`f+bgTE5F8a7>bDsscRObb32Q3 +zsqAjXEk?_0e_t%yYER~j=^R@KtM-f(7_=Z +zNaFT^2g*|RIpQ=RTHYc|5>x}G^F}KvBFgbHpO4SHjL8b{d+UW137A)V)xt2OQn5>M +zb0j!PFCIufV}unI)FINpqp_(8S7~CgHV3X|N{E+aeO8AHM%xbcdLrH0~Lf+iFOIk7B5#2tO^|9t->Ug(McC^)(k +zBZ(?$kA#5xn}wEc%cWu^UP+lsqWoGhp+0Off_OIMxr6KfeCL%tV?R~i!j*q1 +zuJkWH{m=6hvGQtkvGQt>H6a0Mu~$q4EW72|_sjD)cdySc&d%_CRh~!ce^5&U1QY-O +z00;mlY-(Mgk_1?Yn*abeN0ZM49S9m7^J*F$^J=s71Vk5qj&#A_&8J91<_M5bVDTo) +zCD+lSC|csQD6vV(?pZ}z&H}QkvI!tzBv2Pi>>o2vFl(KeCpd4?Z_-aP`}-ndUosOY +z6h-&y@#!O?^0ISZV#ki_7rpN*PRLcUf^2ZSgkV6YI{(C9xP6@0<+!Hwz-!@I1PDN0 +z29M}9{aPr0H^;?u3jj*uEQfa~cIT|gVN>4o2Z!q6I2r4+qKI^`MNX>2nhxEUqNuIE +zQkMBEPZl3L2G*oeRdY8lvd1qKL37U1R&>LushR5VtKfjB&^Vh{mWWoCR +zotm!j?FE_B +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 +z%1AH{F%{wvDEk3Dr5DSuTcPQi_`*c- +z9p$hws1LP7ksLI)wOn~9)p^{1-ds_$-O3kJ!jC8>vqVlpuaz|C(03UR+ZT$=yL7;Ga0qGsBPYt9C1IQIU;Y1(E5rt22XVZxWMjqb7l8`;m3SKf?4~i +zuojJf*%IJ3amny{v$L(UQZ}R9eyk7cDcNW=-OJXng*^W>6v9bmcXF*}3|eE)#%AlJ +zQ(qT3yM#vk_HOwyT8G@G0fkAq$d~hCl0I^s2-EqFMoB_)JYJuU`@JKBV00|^jTk){ +zn8IKaUpmClCtmlcp7_&$0Gi3`o=;RuEYhWd7aLc`c8F7omSz1m+HF^06}@m~Ne2mU +zP$-RKDJB)LV3?{_cnn(MO^%-w%O&`(r0xb-kXw?1G;u7Ul`zYAH6+b3%^C6U%0XQJ +zC(Fu-ViRWcE(>JdpO|4v*&(9Y#I{{Ina$uPrRlwse2hlTZcccAa0Cu20`1Upk9nxc +zW?ru68f+1`2T*Ct5hwg-HIor2H+*Nq|bsHG^&tTEgW;*pVp6Okh=1 +zDdS|lE`p6awi~%7Z+K#5hIPO9dJg--q@4Y9x-7169;SnP9$5*Rq!_61}V+hWAaCq^MWJ!kvAzvZmC|L+l +zLs~+>oMF%}ndXp7IM#t>_s0bVFyNuUWcYg_rI7W&gC~GNSUj!4^S}{K=Vh%TCw6AsytREGSsa=;;`2W$ +z!Sm2BVRO(m=F1!`XBKX_M;$OEZrUN{!2%ntgCo7^B +zm_!J%3}=TIPv6lZ4mKey%kTxaCYqT^{E^|m4ZcW|ConjFe4)k>n-U6Vjy9z+!)x{P +z9d}+!q~zI2aiIyZwN7E~3r=Xo9jHKxvU36I(bEvSVq}p**!{EP@^meb={V>FU_~dI +zaPAk_B|^S?@-5jMOn?`g&L1(S->iWa6f%x11cRyj^195u#Y%G59v2$9M6-Q}AN>Bw +zzrIo{VZZkd?el}|;l2BJKHJ~Vp1G6kFfjw`&->x$gYffV`1x7*`MdD*^LOwic__+s2^$@`?fdb1 +zf?n{y=!5*YZ$BQ`kB9c-GyCy7`=Q?@Lepg8F>x%3h4MfwxR!H~=;nfTxF}=~9l$Iv +ziAl^KR&PWU+q;U;<9*J%rH05UMz%zyf6RZz7s;Wu!XhUa34s;#!nbrqj+43&!Y(Cb +z9JJ{{D#&KpL-PWFT;ASs%({NN%#pDE(s8b`K9lqHW6cC{wEx{dA7t6@9^AQm_d&*8 +znq~JN-1+_I6#f`PRg{X|Ak@ZU;bi|@~ +z@&;W_;oz3wl&-Uri8dAki=-WHlt2~-DhyN=z(c7mF%r94I`)w-*$z!@L<>@`V%9Oo +z#FGVRP2I+M3WHFDKt}D|MvXnh~PMJTzT*4ziwOrDtZbb7$ak +z)!ivKw~Jq}lzwu3zj!N;roFXh+Tn2e`a(;-YM7f3r>wx5=*t51zb@ad?>uwsbmzqn +z&xYCKaygzBcUH&wvmd|asr2&MqaVK+X5T$`3cxUX`r^qjd*t}UMKwKfe@BN_+#X +zdH>zuQ^(&vjaX`p(w)zpe;|t}z36qP^||+7*Pq;R{~sP@cOklu-X!zSJ;RB&arSfv +z^$~T~BT_g{LpSHWC_B!BT>-OWTR&d+J3A6Rz)`8Wm6TuxcC`!id~n|hT8 +z0G4!+{eB;chr8we_j@<*Rw(3TOQ$}qPTYSwW+z&X&h6vYBd|l)e|PD`m&zQ^7K6r~ +za?f+G3qvHeMsEp&{N>p3oe9}yc>g@S4}XjM2RVRW)?c#BqP0M7NmdCaDjf6|>R9FK +z>X+I1pus=g%Z`8Izmi)uXf=1KU3eFq(=YvO_(tNHlX*hWt<3H(9XDry3Ep!1e9O&C +zYuL!dI74;}P)zJ{e>ec7wwjOzNZ}wm%CftkeSXLN|15i>`w>xzJ?IR~+*uS7sSkb7 +zlXJQJ&XN1mxeOMe83%{2-@N%0lzQ}~(6WLv5wFDuE~@6RCn*8QD>WR*ihziU{OR>d +zt`qYrdy<=YkllBj;|~7g4rE6*?!p6HaQ}fX<(EvJ%i;%rf9YAR#ayDb@NtFUmx^>+ +zT@cYrr9ilbJ}6`AyS5n?evsYUze^x5*X`%J!ydYCJ+x23OePpqS8~i`JpowJwtDg< +zCd0}!b4#Ik6#^R`}+^wl5N@4p(G;Mm7K;}f{v@GaLQ#J +zp$GF!ofZmoe<;A3&?qeZOG8ekvddxsfY+kc0cq->;-e>zR7bz=6=$@lr*-{07C?xhFs +z+^vK3q3DnaVevX921pONOJbOgd1Uep;Hd>iCn`RGhZJ9pbs9*f|o4clA;y~08BiaayMRu>)Hkw8W +z!ORr9gf9`=G)qV^$2gcl-gwD$^}WPk&p?xk39y0yUU$@aTKT@aN$WrQ<3Bs81n75I +zD97}^UAxxN7KbJU~XLZ@<4U`?d9 +zsPX%FEBVhkxyqf8{!c{wBO1vO&BHsN@vEeYJF9KpnUOe#N^sBs_+9y>E*D9sx +ze@ZEb(Fmmhdw%@79DiKtl1`M2NQD_Q_YBj?_KFIF4zwLKy)p~vG9Urui=ct>D +z&(6IT*zcV!$UyE2?+*mu(52av^5k=Pp)R9%?(;xe{0WZRte4J +zvbQw_jwrwqtEE9q9>Pts*$#vb*Gu&*)@}=r&p?MF5|-9{9qDeilV=NII)X9>$7)|Bc +zg=%5F+r7A@uS!7$ISTC}e*pdNP_M9cT)AggemKFO5Bvl2C0zSFYhbV;M5>XZ)8T(j +zsP4dfT0MHOP8B7N$l1hbbBX{4Az_|U*8*%kIu(e1j^<1plrhLll(zs9Rg!FZK!hm! +zFr}%9%zg(tZZH=kvMb4qGsO9Oj?pz!XuONROAuwmxRD?K3I~v +z(;bxgQU|cmS~*>o?!2c!#2%xdwz^4^v>x%Vnv>)ow88ZZy6xuv+MNrRWVD=qX*=lb +z!?U2K>r(~i>wCRpe~&*P2fBVvXYVtoAD&0va8748p3@J`mWoj!|X74|9^mKfGT%lS%i)ZRzLizs*8lFOB|}e=c?R3HDz$g*RI2_PKRC +zW&-U{2E-x3_tqIaNi0P%x_S1otS+n?Dx^{M?Xmc0kSB-P0-yoM(<`gy7W-c618Jb= +zeUmCrs>jm%5i`a`+~I$-UwZE+c6CkdU%H)Yoz7|RQ~M+`UHV9h_Z3{;vsbhC>(#DD +z|NHjp{C#@0fAit_p1r!f!Cd*h;XUznhr`#jC#$DIi%@?R94F;GYU@RHp~Z^Tu^jvT +z-4_N2*+wtEG!tC;M0p-?djzLDbgvCw_pEOr4}+m?w#7kq_rd+FfA_QB4YF_CU-usD +zXMOjdfqR_cJa@h>>+wakoD%u(eN-GcUYwd=K +zl@PQKI;-7Zo4wc9uAk2hUpwFVYk-`flz`+L2DbN;;7&!ZQVUpx)GYARp5uA5a$!PT +z|BCh8{LO2a*RNR5E#KVEyne;pw)S^4u^Tq{ub9;hU)#pKe#Lxl`q~!em40paFrJRk +z9ShC5r3Djj6uiTD`RH>J2d$Eyd!_IGezj<7gS?;(Tmw6Xrf{lVzQHVm1vt^uThhRqC#Byw!$ +zf0PP8R?%na6%2-Bj!rizIOfK<@OQo&ctrChGECQKM%Xn8gBXE&MfRkYq^kLN5iP=ATI%d00$9whUMn0hHC*%A>PDYePmxPf9w`hAp-YNdyf8|Ib +zBTvh7mj5x}+Ly0hJpKL~VuhDemT1p%0qv|peaz|9vegX%gV=i>CQg8q5N1?Jlo9ZY +zYG5_}y-=_N?w(QhJ!7Q_@U7Ukt19i_q+Aw&lJjui(zA)i6M{Vyt6AYD7?%3}&+mqe +zFZ}5z0XRSO5$pXi-~pAZ2r!POe|f$g`c~cZ3yiOi4$O;-J0GnqnM4 +z?zv=W?mVBD^%+YV5vGgiT!zr>#QU*pN`d{@9RtWxD<1yW4P&M0UiF;_H#%U1>A;6T +z8DjJqYJ9V{Td~~JFkU=CNE9ch>!+ASx2k05eVa;FjDqUy9>mXxKzym3qyUPWRDuc^ +zT@W^uV-(VlOvg0Yj +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 +zD^yIb$Q%SwdQ~hKFLy35SxW8kyR+@Al( +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 +zrIk`Z#a6B>Plr<_7X?@X;n=|t!xG-lwbw> +zG~v-VAGx7n^PvdO-Kv4rN3i@J$~FA9%lD$o_atE0e{S86Zru-WJcuqoc#{;!j^+yF~3(*ds@j_HbYJV +z-ZxsJcgSf05+YzGW_ie+HbA6f&qvv#`IU%B$eQHwi +zemKd;e`-^MCvsA^)=u8n{yuhNio^axfYZ;AUB2@3DG&A#%AxihRUnG#BnnX3I5DbE +z;A!^F2*^jT{mh$=GKTWwp8dG*e(WRZ&$Cf|hlC){Jb2@IvC^PLV;OZk5?-}pRi#x* +zDh;nSo!K>c$2@{D5-0A7G7#}jt}Y6K3A%eTe~2c8aX2oB3Y_b9eO>I*`It$a*t-&wh);kuEEdzUh%K$* +zL>T(Ot}ez`M{^~(6tc6h9if#pBe{+X!cEnngmvkZ2QWGfWtbGx(tQ%4cJ7>mk@xt@ +ze>McQ7BvQp#Dg#{#Ktb1T@Dxo4vkT1z4R)#=6{JWnA90U2i-Kof}{y{!Z~GW^a1>P +zQHU$tjl>O8=3lW6-xkv=;ysF(S6NTgg&}#pHJ;O?MG?K+hsMQ0_B=Xs#3SE(fwNbq +zvF<@|mau!cMWmd)##wj@H7p`_TTfu)f7{UNupZ*+<+vBx`@kk;A6kv=A1 +zk!$8vrOO=KiK4{E>x^6EY^Stvf4H3kfMq#z54Rj`A?C}e3=I^eSNU-ZK}nDO!=ztF +z?%k2%lBhjF9*g`?b-N4t6dgdrj^67h!jil^qnr)O<-lCWofN$Z%;3)g*}rY~@@Q@z +z-G(O@GH>1IsGd1eK*M^ZEY}*8shJJ5`9^wcMmsP}zBOzY%DD>-M3a}ufA?P$lK|f!-ebPToJrA2&O&|@ihq!}zLEn#R206mhH%X65S5E{>q4q8 +z6f#dWp4=TT!x)cFAR591m9^>17x@*Lj(IuV)>B_ab~4QwOyriLl{170)QHLTt;>N^ +za}Ex7;pynEWaeyS=`x{_e--EvcIm`1lOLbb;8;nB?OXz-DB#%GBhe|6KxM4f+%Zfw +zFe=KNn%PEQg~SDDWWoQXfq$-6g-KP&s?y*Ei~d3EV`i)|NN!zDl^azmHHhVuacYI0 +z)+!=YpPEIuL3EWLC{rj#a5<6|uzN0#g-sRv1~tQ(B(0Rr>#>Z{FMV +z=Dq9Qyuay9=o->fe<&C460%6ZHf=>K}rCDuDs1loBMd}F+wbGovlnT*d`H)9R +z=aWf`X63ai%vC-a1%F}C>j&Gd6+@fq$cWG(f64RyVJ?RKz8C$zAN_vtCMYf2q*pVI +zxpOwrSB#i@;!ccarH84jefj7!dful+oJga&gg-u2Yt`INP&vBijDd~MY-9k?Lm&!` +zD5}R||C&>qUQ$Vdy-6M15``5OVp#~Bi>gEts3*&p#Pgq36@S(&%&{YLfiUV4b;4sE +zk`8;^u|qeWea#&j^E=yul2~{arFDg;UU3$#@k2KsXJX-5)Utoy01W9navR`yTFl5J +zA_{y8gR7@Nyg$qy#@N#vg#SZbyTizb(0cT_|E7N3Sb4=fWRS-gQ5_@!i+5D(We&Wa +zV={*0tF+Ii-G4;u(50KuyWb{X~qpjp01`LS8L>)0Ns +z5~Eme&kJw*5cSZ*+ZuGOno2}^mZB@-bC4qnyi4whgnwa5)M9O6wQ`u{l*J20qEcAB +zNaQl+16lRNoetvqfwDpauBmOYqS10@T+PSN^2G)gr1F!wi>!MRCS~HC1ir25^bcyu +ziWdA6srZ4xhl6VeNu$Z))M;IhFb&s4^>iEMXYn96nf#NPP#w|YIlcKlIeWcr4!7~O +z=#VXjT9^=<$ +z5ia5r!h^sm(~K7>UGT>}`*B|)>CZ;9a^B~a2fVVNLv*0}h=mQeeJM8oba4+7tR-EC +zpTnrp{!n{_{~G8_-AMxODm#pS@9Dqy_1_0?I)8W>KNt&J9gRlw<^4YP_r1p7_ZxrP +zM>_~?>w4;XMfB_lC_r(f@jT6-i-4f4FabT=1Vs16cdiZ0+4bUGwaCZiDoS4H+WJr=r$6YE +z4L!<4(nI?$4OaT>zx!r&2DFh|3g>CktmmgR*F3K4zP6AYs%abUiIF#}b +zjqf;WzxPB%yvk!$Dw(gJP>3VrQ7-su}Ez>7kck}ec_phD4_3jEW_$BT{F&@#ze3D-J{Ol*2e;hImT*|^ji;q} +zI+q3A+vQ3slmPkn`Fa(FY;4erdtt@sN#HtZWDd-@YRzDjH~sR4x{xuIff%TDt=ReK +z{9idOe;q{(pFR)uN=tIWMA0Brt$%^Rf69bM_yHB=qB;@M^BmWS&2veQlI%9Koze!& +z@~$%)H_F8cOsJj`GRBNs&b~iI`bOhdfobJljFKcxBM_ +zj?i@6x?Jgcwzw=;n?BIm8{su4OO> +zyKd$hJ{e%~9B~7P6p9zB^LEE*7UAw-`-^{c9q-GCPAY?JhrLg;CmGC&hlUzK2y#0R +zpJJ(x +zMK~-duYs@#gZy4>Wh-p(xCiFae}xA +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 +z1?p_vjS3_b&G~W)Fyfl!E~yM1A}A>P +zcq^2siwKp)@p=u38_I(Y3u>)3QVI}pgPlNNfbRvjQVC>A^kYD-~5Vx{aNkznEX`3 +zLp{kRn=yoABGtKTYBu|NlFHyR)d5w(0w?^@YC#npm~Rot7|}#@2=mJV5iJRSbMC=WJS&}4aunvP=;ZH8>qX9?cnz=h)W>f62Fx`}In$m* +zokdkIsI>yPA;otOV)fXqR~@DYWkeLZH;5Gi_@w~{!02Goh~q<%`+o_iQ{Bk$J5&FU +zAO>})M`;l3dzM4vW=QCzn~oX=Tg`-z+!eb!A+{fAL24*s8@4ZhkK9?0)Ph!9^_L^z +zwoH6s1RKetb~SmG%}kNMnrNbOL`mOJ)(!dzBfs9=xy_@wfe=&I +zraC4Mv*4jLCuRsh%zTgK-{_%MaHn6QWUxtntmt@1BHX~LPRe;%gF+2!Jsf~=3n&m0<+hEIOu>#2N5D;jUlc1{#owbu&`9 +z(E}w*4t2@AF;2(2*2npTU|s^`WC4g>v4?J?UG=^A=htFS25P5;{{CZ&Inuwc(D26G +z=2EPrnUvGuD2ZffTqO}Fy2`peibSGF1=Ay@i4o#|!66d<;(cjy+hXgexGl>?LJ4AX +zRKI{_TU0z{JHY9Zd%{727BE$OxN-7?%rGw-|7UU1wScn{`V7EelvK}zJTZ3w; +z6oEQOhmd?cVUZJK(airpFG56vz!X|@DtKsZwnoOMb(nh7PuhIXBe?`3(D0mc6{1`C +z(9QCH%YAma#rDP-payzz*iabnWcS*bHf?)f^hgugMs0xMi9h8h9kEJia&gEg;#3%FTUQ_w#ZeU~W6+JGW|iP%80bF26SieOR{R#8qXs@xHBOxR;B +zU!|b7l+idhW0SC-*I{lX{F2)RuSL)s`?3d8;@!*cZrKobi +z+mn~Z3;Tn^hbLL-ajEBuGcgJpm#|D7mlgB_UUtr35b-9O+}xH)wgC{=#AobWbj6D$#V$V^EzN6R6vNl2;qc +zzM+V+hE!JS%+SzwZCB(KjbUF|cw(>``UCPpYi5XfP+Hkr7E_5KBVd&UF}W^EWr%#d +ztZHv7w{0iIZh~C^-R`srSa^PG@Qp$u-b7iTpb6t6O(v>k?;o?)F~S`It;x+Hokeyt +zJ9W9>d)Nf0RTbt`nry7jh*xiaZHeE9vHq};GXp+jP!nuGjKcB-|I2C{`Z4pW#to#W +zeB7BVVBv4DGHRrEbTCyZHscVF3482eV}JO?{CJ}O2uQo+Z2w4#irshsNp@N +z;|P5TPSSBI9=G9W{ACYGbE^}sMCf~P>sM9n_OJd?l4|=sr=zU|PSD?fdo(Ri=dg44 +zd(-sJS55`%H!6iiOvpG&lh;KDSi+J*t +zK;{IYteesIP|@aEN&&}A^l9yxOeYY&!Z}1|jQvHAOtkkb?!$^9kq?#A?mRRTOI}Ec +z={{tY7&I56%e96}JT+2Rfu{AeN{y-22`^a5*eGd>*WHfnye2XKN%j^j$r{496q9#YCHv&YXVw>^9L_45IpMroP06|z;{0`P{Z9|CHV +zU5F%qVgOuSvTYod%@%A-0-@@{DhHP_zOF=K7fTUU^-MGKl#>g`Op)Zt^f4U-Dofg; +z3q89peN0btVO4x<%9k>C!0d&g4{l{|^{|L(v7|t9a2+_EbI@)ZF>Ir40b!7#(K=fn +zT4{5{Ea>V4A%bwhhuV=B?hhx4@%Nis8(oxtdGt_fGc7iS9>{B_ov%sBy>y#c +zw?}7jkt=eDV;~4FZTj5&LjP793C?&=zB7Pd?a1^8)3F=c?kjs7$`ks@%PK(tm^w+(TQaK><6peHRLkUv_$3?z;RXC< +z54+#-gLW8&hwX~JpnvZ)MR=h_bsioeDTcJ6W^SWkQWx{uuKm(rl4}l{p1-@(kNaMe +zgS7;YWc$UR(*vCLNH?2rTQi}uLU^Z<*SB+2K)^-!2px@zAA252+7N#lyu!QO7s{94QxhDY>zE_AI|46sgNlcz89IbOzCiDPwBQWyFp)imw}1JvMpR(nsZM +zT9Y1&BY)c?>Auty@#dk>r>P`w{hJhhfF +z#!-f71o8cAgtmH-h9RTbDPk>59y*qhx#>^1`eXOu<%*y`?#El8dO(>5X?d?h +zB!6O>*dh^C;Cvdfd0e;^!nh5gV2f!hfQmH(?MRYQ)tU~Qm?F+?Fk5cErQ4(p+}SQ@ +z7{cG20!}NK#I}#!3wtO{Fh@M&xoH`=&kzvFkYH`$(c^C)y%=czgCtR4tq`~tx$Jp- +zG0G28g4KHsy1XxAAm({XqhUSIzl|l=<^jq(|$;#8)^?kX$pH5f&=m2yhp_A3L(tVsw~5c`kB5 +z7&j!W?<>czyo8lcCZGmh?Bn^NwUwk9&x2L!=3}qm8wSn1ZgLoQ?!S*{k +zK20d@mWSVqvNAKEG^FwdCI33|?VwfVPptfFEndr69FGdrnKg0S6S~JLZlZfESS=~w +zg#I%Wd0>#ML~@=lQHqO3J%3rPFEXiA?o)cjHf>%5B1O>*KdJn2)M2#w+q$S%jV&f* +z7(RK!EhC|QkZ_i(zHdeK5?zeJ^-n@i@e{u3$=(mopa1avlkZ>s^!=k}Pk0z^eDu2~ +ze|qwrCUMRu*wy{sizm;2c=5_D%zBP+m+<^1D8FKk+tGyKh*YDjvVSLUqXl!qXEyUD +zZ4`6(f?7v>&g}#k-@Ssd_?Z*HT+G{jt@NffMJFZDPq0f!cZh2~%K_|&m{`%l#6s^* +zc*$@eOzHtziBUfmJ07g^W|x-!ZP +zTU_ImEPkn63hpIQ9)D`7o9w$L)({CHa$Qo$G4#TR7#vXaJu#Rlcq7_woTg(S79ZM< +zhF}Afit;bfczoJyF_U+>DE1>3bCxfPP3>_)U&wqGKB%#AUn+(E$nw%ABy5neny)w5 +zTjO?2wRS6p#af9sL*09h^2=r6BXwzdqh>Ugx|xXCSuaAhzJFU*Yb5r&92Y{k9wC() +zs+bMLbt5q=>PK)EroC4vpN@)}(8Desq$8SqJkT5xB(A0E$#(Nm-Odk-x3k58d2u +zu-v*5vK{uMREI=oK-!2x4)aMo9W{aBkc7bI&%$`Gw({v^nGds=v<^<8$M;^}``zuM +zqy4?#e}8fC=93waoO-cDj@SsI%RgCEnwqBNx7_8AI=?=I{b28|$wXcmklVpNoW6Bb +zMgSM?h=2 +zC#8wfjgFwO*Yl{ZbF-4sN@J(=b_+wEwV(p)vVWpRhbdRl%L9fL8Do(^ljH%j%788P +zLM6A8d{$0z?Ac>tJVJ%I-q0J4*dQ;~V6 +z-=s3$G?T0&(iMM>*5xbL%5(QIwX;hv%+A-Vuj(K9$R9QNuotX;*85&;m)uZbqFt%! +zm4ydeg$OB8qOcoo`2fQ8aV=$tFQoE1X@6xERS!U_H{o<7=})49EvZVgAZSux2$!2T +zX5SFZd0ylikL^*KGrIOPnoK+~);WUOMak$Z)bH~NY_lS-?JStfsSR@md)T>q4wBAwEc#bDSrtJ +z;TxH_f8c${1c5b1Va44{#g2p18IbJyz1uH8?KP_;74uW}bG_wlM8Trd(I +z{RPLun@{jxIl2bkO2m&x790NkX?7PtsnRfS%3Q?0Obp@ZBavwoD_Bkhw?yN7)z`uG +zvYwp*?cwex=19GvJ?J-kcGuVCkbjQd@@*b{#DAPuH|wW`YsOFLYV}ynu3IpU +z`3ezd$j@TYAIxFTXAFwAiI1oyz8(J51OmL`>(*JQ2 +zU8`ILT&;W+jz;5J87TFCjE>DA(lO~)-*7I+wnc$Nj50BPn` +z^%fHexv0^)APyw0g@RG_Dt`s)i-*;@dwc*-lf0C^J#B@!Ct8y7b03B*6*rNr$dmx9 +zx<%@scQXMpq}>(a_E0O5FK;NMxk2^X9-bN9eQb6geV`$KbcBXA@5E6~t$Phvp6xId +zej{!sr*Dm~Y+QPpW0LiUZ{Ffa>6veWHEsf1w8)W-i{G?4*#nLvP=88#q=}hgxY~Vf +z&By?STjYGTFfbSmTBF?YYjP7Aw4HYojA6T5XhXV9(;>Uf0k*|bwB6{_xZg>&TY@<| +zgB_DdiKL2ca~gtGqB(WD?2rGtYN&EB`{UZ`;7B5xfER;D9e6y+(yW&fonw4o;+d?$ +zaz37}CjxWjap5%pXn(Fp2U>|o--3(S^W+rhr4pmvn+w +zEFslxdy5rGNA2N?lKO39A^xSUFG1B%EjkGhMhLB^L%^%_THzwY*ALqyLs;#gw+& +zWuSaA%we0~`qw*-(TK(mxe%b%v#LT?*;nyB6~fvFZ0FND1{sQccMazT>)i15Hv|j@kw2H+^M4f)OX8C7FAMPz!Z|g~(iv+-x_ppP81F +zi@MU&`Feq=b`S>r07PxR-jRk|oYN@}SBfw1SpuIOhGG#OT3J +z=WnA6oqsJyOIV$pByY$%!nd{YwCx73Tlo?MF&>O+nK%jv!9<*DAZ@ZBx=j5LK?V_w +zb?8DHYgyiSJSA4AL^kT$NOYwp0?tY=-eb2g>OMEaZUI0 +z<>`8+GikqFul;rLUkna_lW$fml`a-JV+VXL_Y`*Gd49?|j|gcKH}>Dw)k?JM(7gRT +z5bNc~f9dr{pA34x{h0oe#@*guKE~aTf7?s$${hJ;&EJAWcZ7Z2Oz9e`SIc*8mr0JN +zOn=|sg_u4ZYf|R4`J;pXLZ)y772wrIt3mYrJ_u>hG$BZ)LXbE+<=O2zLd!NgE%Ulx +z&Rx^PEM8My!XA(x$p$bo6XMe+4*|7l1Bj?+`)=!UA&F@XkpLup7(&(Hm=X=uMO}-Yl7b+6or=Mr}eueQ1c_!7d_^PlVYZ +z`dC`nrlO2HY?&vale-i?3EzF+PsFoePKG@}56!y`*rD=-H&}1zR$M3m5mSg-0Dob; +z>0-FA@PKT=gwJTk0RsIt9p&wWG%3a=9k +z!)g^b4(+DbTt|P~Ql5xf1fvOzBfUf#*1a>oqr@N*ev#11#&* +z^O5g!1qbT+r5f~9&f7Tuk=rtsD$U|fFimgc(XbgJdumxxsekC^VC*fXZhQK3*MJ4c +zf64iD3lY$h@yt-B)MM-`BY*m0aEP@mCah`g2BJEd*gKcSw8(1>Ek@l_E$Ldl6^k~6 +zNGnn>${r!?h8c)5cUHMJKToy#VzyXaSubz-IB9_{m6up{7(rW>#yh2LIE3-qB#Tgpfk$KuNBBlJva)QEDOOe +zF?NfV`D(6Vf);6yz<)j~%UQyVUC;tn&TRT2P)b}FVx#HX2z$UVAvG;P%6V9pzGz5F +zKY7#>*O24_XMIUETfUWr#v_9$VgRk_CuB2e-ZQrdQkGV>&D*Zi?T*vy+@_$);^5Y$E28$$(nhrS-(MF-a)lSItk#(|%9g +z`pCsfGfw3Yw11+6b_zCAw=K7Aw|s20yrE&up0-^7T^esB+iUwiVzfKSA`Tl(vO3)B +zaj@xg4cmRf`H7=VyW)Ot_;QF_XuKHGs!F{az1z&ZYQF0fnU`(`H0vpPk#W*uBYBA? +zqxS-mxi2{IqOf{W5^5VYlva{xd|x6&Ul7H(+4Yl>-hcYW8!x%rzgd@01wJI1DJr4V +zQ5$dlI9Ifh=WefK;leu$x$;6BLXG#HZhA{97=%6yZta%O=^Mw5k=Gjos7$&Gl11PA +zHgm|gyqVCr>pE(1Hm5s|gJ{eGuDUG@es{CC9yuQWSRhz-c!!(sMODp4Pv$?gMVSwplqpcfGEeZwsHt|U>Ym0<%DnyJsHz?*G~by7MYKvY@=qJ<>M6(B8J*& +zS|y{WOkmSk@Hjl&j2o<2bLwR)h;}~Uby2-7=A%r>(Z?bP)uOieo~rpoF0Cm3R=KY- +zu2VCV^D92kDy`gQS%ds^8NR$;9IzZti+!Z +z>Y4@V+|J@$D!ZF;i_!Ah7t6NVlR0C0NLVecCu14HRCj29iEFT_5J{?8DVmy8JPS7v +z(0@@Fba03UlDK`~fwGi+jyMg7mbVC#1l54)ywOUEh;qEl=i@UkW3mGL-g+TL0_N3T +zwJ;2+RP0jR90^X+iwBa=7-2;Pb%^xuXl!c2Rhn3=&4H_#65=IUNwAS)nkgy1DyrN>Mq4<`d357vUEXxpaN1yvY-+w=e +z7kcbJ3Xbl?NTN#GBO&1aW}&6qa;aE}S5l^uD8E)rs1KWr;7<-a;7>NlVEQ4-z#Sjj +z0wC}zFkCC{u5~qh0T3&zN$N+n9aZC`&KWi;ISUdWXk#EXS;Uz^#LXM^YeJM-D0wOy +z)TdiXO6jdG+aa6W7?zZ(7Z#i9Moj#NJ93cxk6ZurPyh4>%HrS39%OBnJGlObJ1^}S +z`>FC4uKaUxrGN41KYUwE7vc6l{o&00{o{-8{>LBg*e^7bJoSe=Vo&oI{y&3Zp|@e7 +z0idf0ye?{8X|duImkCV*DJ^ud@@jQ>3jhHG000001ONa408mQ-0v-bt0000804Ho} +zU7(T#Scsbd05?aMUrhol1R5RlYL|{p0yzSUpqI%_0yF}#pqKwm0yzTQpp(v_85U4W +X1qJ{B000F51pr