From 04d786fe268c3cd544d7beb19442d3d43699040e Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 27 Jul 2026 23:59:40 -0400 Subject: [PATCH 01/24] fix popup position --- .../controller/CrossFlickInputController.kt | 373 +++++++++++++++--- .../controller/PopupWindowAnchorLocation.kt | 25 ++ 2 files changed, 343 insertions(+), 55 deletions(-) diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt index 2201bc234..bf93da281 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt @@ -4,10 +4,12 @@ import android.annotation.SuppressLint import android.content.Context import android.graphics.Color import android.graphics.PointF +import android.os.Build import android.view.Gravity import android.view.MotionEvent import android.view.View import android.view.ViewConfiguration +import android.view.ViewTreeObserver import android.view.WindowManager import android.widget.Button import android.widget.PopupWindow @@ -121,6 +123,19 @@ class CrossFlickInputController( private var directionalPopupAnchorWidth = -1 private var directionalPopupAnchorHeight = -1 private var originalKeyText: CharSequence? = null + private val popupAnchorLocation = IntArray(2) + private val popupKeyLocationScratch = IntArray(2) + private val popupWindowLocationScratch = IntArray(2) + private val popupPositionScratch = IntArray(2) + private var trackedPopupAnchor: View? = null + private var trackedPopupViewTreeObserver: ViewTreeObserver? = null + private var lastPopupAnchorX = Int.MIN_VALUE + private var lastPopupAnchorY = Int.MIN_VALUE + private var lastPopupAnchorWidth = -1 + private var lastPopupAnchorHeight = -1 + private val popupGlobalLayoutListener = ViewTreeObserver.OnGlobalLayoutListener { + repositionVisiblePopupsIfAnchorMoved() + } private val gridPopup = PopupWindow( CrossFlickPopupView(context), @@ -134,6 +149,7 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null + configurePopupWindowPositioning(this) } private val controllerScope = CoroutineScope(Dispatchers.Main + SupervisorJob()) @@ -535,31 +551,31 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null + configurePopupWindowPositioning(this) } - val location = getLocationRelativeToWindowAnchor(anchor, windowAnchor) - val x = location[0] - val y = location[1] - - val popupX = when (direction) { - FlickDirection.UP_LEFT_FAR, FlickDirection.UP_LEFT -> x - anchor.width - FlickDirection.UP_RIGHT_FAR, FlickDirection.UP_RIGHT -> x + anchor.width - else -> x - } - val popupY = when (direction) { - FlickDirection.UP -> y - anchor.height - FlickDirection.DOWN -> y + anchor.height - else -> y - } + readPopupAnchorLocation(anchor, windowAnchor) + resolveActionPopupPosition( + direction = direction, + anchor = anchor, + anchorX = popupAnchorLocation[0], + anchorY = popupAnchorLocation[1] + ) val shown = runCatching { - popupWindow.showAtLocation(windowAnchor, Gravity.NO_GRAVITY, popupX, popupY) + popupWindow.showAtLocation( + windowAnchor, + Gravity.NO_GRAVITY, + popupPositionScratch[0], + popupPositionScratch[1] + ) true }.getOrDefault(false) if (shown) { actionPopupWindows[direction] = popupWindow actionPopupViews[direction] = popupView + startPopupPositionTracking() } } @@ -599,6 +615,7 @@ class CrossFlickInputController( actionPopupWindows.values.forEach { if (it.isShowing) it.dismiss() } actionPopupWindows.clear() actionPopupViews.clear() + stopPopupPositionTrackingIfNoPopupsVisible() } // TEXT モードの方向ポップアップを必要なときだけ生成し、同じキーでは再利用する。 @@ -666,6 +683,7 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null + configurePopupWindowPositioning(this) } } @@ -692,55 +710,39 @@ class CrossFlickInputController( return } - val location = getLocationRelativeToWindowAnchor(currentAnchor, windowAnchor) - val anchorX = location[0] - val anchorY = location[1] + readPopupAnchorLocation(currentAnchor, windowAnchor) + val anchorX = popupAnchorLocation[0] + val anchorY = popupAnchorLocation[1] val keyWidth = currentAnchor.width val keyHeight = currentAnchor.height - val anchorCenterX = anchorX + keyWidth / 2 - val anchorCenterY = anchorY + keyHeight / 2 val popupWidth = popupToShow.width val popupHeight = popupToShow.height - val x: Int - val y: Int - - when (direction) { - FlickDirection.TAP -> { - x = anchorCenterX - popupWidth / 2 - y = anchorCenterY - popupHeight / 2 - } - - FlickDirection.UP -> { - x = anchorCenterX - popupWidth / 2 - y = anchorCenterY - popupHeight - } - - FlickDirection.DOWN -> { - x = anchorCenterX - popupWidth / 2 - y = anchorCenterY - } - - FlickDirection.UP_LEFT_FAR, FlickDirection.UP_LEFT -> { - x = anchorCenterX - popupWidth - y = anchorCenterY - popupHeight / 2 - } - - FlickDirection.UP_RIGHT_FAR, FlickDirection.UP_RIGHT -> { - x = anchorCenterX - y = anchorCenterY - popupHeight / 2 - } - } + resolveDirectionalPopupPosition( + direction = direction, + anchorX = anchorX, + anchorY = anchorY, + keyWidth = keyWidth, + keyHeight = keyHeight, + popupWidth = popupWidth, + popupHeight = popupHeight + ) val shown = runCatching { - popupToShow.showAtLocation(windowAnchor, Gravity.NO_GRAVITY, x, y) + popupToShow.showAtLocation( + windowAnchor, + Gravity.NO_GRAVITY, + popupPositionScratch[0], + popupPositionScratch[1] + ) true }.getOrDefault(false) if (shown) { currentVisibleDirectionalPopup = popupToShow currentVisibleDirectional = direction + startPopupPositionTracking() } } @@ -770,24 +772,43 @@ class CrossFlickInputController( ) popupView.highlightDirection(currentDirection) - val location = getLocationRelativeToWindowAnchor(currentAnchor, windowAnchor) + readPopupAnchorLocation(currentAnchor, windowAnchor) popupView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED) - val x = location[0] + currentAnchor.width / 2 - popupView.measuredWidth / 2 - val y = location[1] + currentAnchor.height / 2 - popupView.measuredHeight / 2 + resolveCenteredPopupPosition( + anchorX = popupAnchorLocation[0], + anchorY = popupAnchorLocation[1], + keyWidth = currentAnchor.width, + keyHeight = currentAnchor.height, + popupWidth = popupView.measuredWidth, + popupHeight = popupView.measuredHeight + ) gridPopup.width = WindowManager.LayoutParams.WRAP_CONTENT gridPopup.height = WindowManager.LayoutParams.WRAP_CONTENT if (!gridPopup.isShowing) { runCatching { - gridPopup.showAtLocation(windowAnchor, Gravity.NO_GRAVITY, x, y) + gridPopup.showAtLocation( + windowAnchor, + Gravity.NO_GRAVITY, + popupPositionScratch[0], + popupPositionScratch[1] + ) } } else { runCatching { - gridPopup.update(x, y, -1, -1) + gridPopup.update( + popupPositionScratch[0], + popupPositionScratch[1], + -1, + -1 + ) } } + if (gridPopup.isShowing) { + startPopupPositionTracking() + } } // グリッドポップアップ内の対応セルをハイライトする。長押し中の指移動で呼ばれる。 @@ -835,12 +856,14 @@ class CrossFlickInputController( if (gridPopup.isShowing) { gridPopup.dismiss() } + stopPopupPositionTrackingIfNoPopupsVisible() } // ACTION・TEXT 両モードのポップアップをすべて閉じる。 fun dismissAllPopups(clearDirectionalCache: Boolean = false) { dismissAllActionPopups() dismissDirectionalPopups(clearCache = clearDirectionalCache) + stopPopupPositionTracking() } private fun invalidateDirectionalPopupCache() { @@ -857,6 +880,246 @@ class CrossFlickInputController( if (!windowAnchor.isAttachedToWindow) return false return windowAnchor.windowToken != null } + + private fun readPopupAnchorLocation(keyAnchor: View, windowAnchor: View?) { + if (usesScreenPositionedPopupWindows()) { + keyAnchor.getLocationOnScreen(popupAnchorLocation) + return + } + + getLocationRelativeToWindowAnchor( + keyAnchor = keyAnchor, + windowAnchor = windowAnchor, + outLocation = popupAnchorLocation, + keyLocationScratch = popupKeyLocationScratch, + windowLocationScratch = popupWindowLocationScratch + ) + } + + private fun configurePopupWindowPositioning(popupWindow: PopupWindow) { + if (usesScreenPositionedPopupWindows()) { + popupWindow.setAttachedInDecor(false) + popupWindow.setIsLaidOutInScreen(true) + } + } + + private fun usesScreenPositionedPopupWindows(): Boolean { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q + } + + private fun resolveActionPopupPosition( + direction: FlickDirection, + anchor: View, + anchorX: Int, + anchorY: Int + ) { + popupPositionScratch[0] = when (direction) { + FlickDirection.UP_LEFT_FAR, FlickDirection.UP_LEFT -> anchorX - anchor.width + FlickDirection.UP_RIGHT_FAR, FlickDirection.UP_RIGHT -> anchorX + anchor.width + else -> anchorX + } + popupPositionScratch[1] = when (direction) { + FlickDirection.UP -> anchorY - anchor.height + FlickDirection.DOWN -> anchorY + anchor.height + else -> anchorY + } + } + + private fun resolveDirectionalPopupPosition( + direction: FlickDirection, + anchorX: Int, + anchorY: Int, + keyWidth: Int, + keyHeight: Int, + popupWidth: Int, + popupHeight: Int + ) { + val anchorCenterX = anchorX + keyWidth / 2 + val anchorCenterY = anchorY + keyHeight / 2 + when (direction) { + FlickDirection.TAP -> { + popupPositionScratch[0] = anchorCenterX - popupWidth / 2 + popupPositionScratch[1] = anchorCenterY - popupHeight / 2 + } + + FlickDirection.UP -> { + popupPositionScratch[0] = anchorCenterX - popupWidth / 2 + popupPositionScratch[1] = anchorCenterY - popupHeight + } + + FlickDirection.DOWN -> { + popupPositionScratch[0] = anchorCenterX - popupWidth / 2 + popupPositionScratch[1] = anchorCenterY + } + + FlickDirection.UP_LEFT_FAR, FlickDirection.UP_LEFT -> { + popupPositionScratch[0] = anchorCenterX - popupWidth + popupPositionScratch[1] = anchorCenterY - popupHeight / 2 + } + + FlickDirection.UP_RIGHT_FAR, FlickDirection.UP_RIGHT -> { + popupPositionScratch[0] = anchorCenterX + popupPositionScratch[1] = anchorCenterY - popupHeight / 2 + } + } + } + + private fun resolveCenteredPopupPosition( + anchorX: Int, + anchorY: Int, + keyWidth: Int, + keyHeight: Int, + popupWidth: Int, + popupHeight: Int + ) { + popupPositionScratch[0] = anchorX + keyWidth / 2 - popupWidth / 2 + popupPositionScratch[1] = anchorY + keyHeight / 2 - popupHeight / 2 + } + + private fun startPopupPositionTracking() { + val anchor = anchorView ?: return + val observer = anchor.viewTreeObserver + if ( + trackedPopupAnchor === anchor && + trackedPopupViewTreeObserver === observer && + observer.isAlive + ) { + return + } + + stopPopupPositionTracking() + if (!observer.isAlive) return + + trackedPopupAnchor = anchor + trackedPopupViewTreeObserver = observer + observer.addOnGlobalLayoutListener(popupGlobalLayoutListener) + + val windowAnchor = resolveWindowAnchor(anchor) + if (isAnchorReady(anchor, windowAnchor)) { + readPopupAnchorLocation(anchor, windowAnchor) + rememberPopupAnchorGeometry(anchor) + } + } + + private fun stopPopupPositionTracking() { + trackedPopupViewTreeObserver?.let { observer -> + if (observer.isAlive) { + observer.removeOnGlobalLayoutListener(popupGlobalLayoutListener) + } + } + trackedPopupAnchor = null + trackedPopupViewTreeObserver = null + lastPopupAnchorX = Int.MIN_VALUE + lastPopupAnchorY = Int.MIN_VALUE + lastPopupAnchorWidth = -1 + lastPopupAnchorHeight = -1 + } + + private fun stopPopupPositionTrackingIfNoPopupsVisible() { + val hasVisibleActionPopup = actionPopupWindows.values.any { it.isShowing } + val hasVisibleDirectionalPopup = currentVisibleDirectionalPopup?.isShowing == true + if (!hasVisibleActionPopup && !hasVisibleDirectionalPopup && !gridPopup.isShowing) { + stopPopupPositionTracking() + } + } + + private fun rememberPopupAnchorGeometry(anchor: View) { + lastPopupAnchorX = popupAnchorLocation[0] + lastPopupAnchorY = popupAnchorLocation[1] + lastPopupAnchorWidth = anchor.width + lastPopupAnchorHeight = anchor.height + } + + private fun repositionVisiblePopupsIfAnchorMoved() { + val anchor = anchorView ?: run { + stopPopupPositionTracking() + return + } + val windowAnchor = resolveWindowAnchor(anchor) + if (!isAnchorReady(anchor, windowAnchor)) { + stopPopupPositionTracking() + return + } + + readPopupAnchorLocation(anchor, windowAnchor) + val geometryUnchanged = + popupAnchorLocation[0] == lastPopupAnchorX && + popupAnchorLocation[1] == lastPopupAnchorY && + anchor.width == lastPopupAnchorWidth && + anchor.height == lastPopupAnchorHeight + if (geometryUnchanged) return + + rememberPopupAnchorGeometry(anchor) + repositionVisibleActionPopups(anchor) + repositionVisibleDirectionalPopup(anchor) + repositionGridPopup(anchor) + } + + private fun repositionVisibleActionPopups(anchor: View) { + actionPopupWindows.forEach { (direction, popupWindow) -> + if (!popupWindow.isShowing) return@forEach + resolveActionPopupPosition( + direction = direction, + anchor = anchor, + anchorX = popupAnchorLocation[0], + anchorY = popupAnchorLocation[1] + ) + runCatching { + popupWindow.update( + popupPositionScratch[0], + popupPositionScratch[1], + -1, + -1 + ) + } + } + } + + private fun repositionVisibleDirectionalPopup(anchor: View) { + val popupWindow = currentVisibleDirectionalPopup ?: return + val direction = currentVisibleDirectional ?: return + if (!popupWindow.isShowing) return + + resolveDirectionalPopupPosition( + direction = direction, + anchorX = popupAnchorLocation[0], + anchorY = popupAnchorLocation[1], + keyWidth = anchor.width, + keyHeight = anchor.height, + popupWidth = popupWindow.width, + popupHeight = popupWindow.height + ) + runCatching { + popupWindow.update( + popupPositionScratch[0], + popupPositionScratch[1], + -1, + -1 + ) + } + } + + private fun repositionGridPopup(anchor: View) { + if (!gridPopup.isShowing) return + val popupView = gridPopup.contentView ?: return + popupView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED) + resolveCenteredPopupPosition( + anchorX = popupAnchorLocation[0], + anchorY = popupAnchorLocation[1], + keyWidth = anchor.width, + keyHeight = anchor.height, + popupWidth = popupView.measuredWidth, + popupHeight = popupView.measuredHeight + ) + runCatching { + gridPopup.update( + popupPositionScratch[0], + popupPositionScratch[1], + -1, + -1 + ) + } + } } internal fun commitCrossFlickAction( diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/PopupWindowAnchorLocation.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/PopupWindowAnchorLocation.kt index cea60a0c0..527bdb728 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/PopupWindowAnchorLocation.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/PopupWindowAnchorLocation.kt @@ -23,3 +23,28 @@ internal fun getLocationRelativeToWindowAnchor( keyLocation[1] - windowLocation[1] ) } + +internal fun getLocationRelativeToWindowAnchor( + keyAnchor: View, + windowAnchor: View?, + outLocation: IntArray, + keyLocationScratch: IntArray, + windowLocationScratch: IntArray +) { + require(outLocation.size >= 2) + require(keyLocationScratch.size >= 2) + require(windowLocationScratch.size >= 2) + + val resolvedWindowAnchor = windowAnchor ?: keyAnchor + + if (keyAnchor === resolvedWindowAnchor) { + keyAnchor.getLocationInWindow(outLocation) + return + } + + keyAnchor.getLocationOnScreen(keyLocationScratch) + resolvedWindowAnchor.getLocationOnScreen(windowLocationScratch) + + outLocation[0] = keyLocationScratch[0] - windowLocationScratch[0] + outLocation[1] = keyLocationScratch[1] - windowLocationScratch[1] +} From 07f8a55dcad701f93d5d723fbf3857bc1dc003e6 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Tue, 28 Jul 2026 05:38:33 -0400 Subject: [PATCH 02/24] add exactinput candidate --- ...datePromoterPerformanceInstrumentedTest.kt | 276 ++++++++++++++++++ .../ExactInputCandidatePromotionPolicy.kt | 107 +++++++ .../path_algorithm/ExactInputPenaltyPolicy.kt | 1 - .../ime_service/IMEService.kt | 73 ++--- ...ctInputCandidatePromoterPerformanceTest.kt | 234 +++++++++++++++ .../ExactInputCandidatePromotionPolicyTest.kt | 137 +++++++++ .../view/DirectionalKeyPopupView.kt | 143 ++++++--- .../view/DirectionalKeyPopupViewTest.kt | 88 ++++++ 8 files changed, 991 insertions(+), 68 deletions(-) create mode 100644 app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceInstrumentedTest.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicyTest.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupViewTest.kt diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceInstrumentedTest.kt new file mode 100644 index 000000000..055bae3b5 --- /dev/null +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceInstrumentedTest.kt @@ -0,0 +1,276 @@ +package com.kazumaproject.markdownhelperkeyboard.converter.candidate + +import android.content.Context +import android.os.Debug +import android.os.SystemClock +import androidx.test.core.app.ApplicationProvider +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Assume.assumeTrue +import org.junit.Test +import org.junit.runner.RunWith +import java.io.File +import java.util.Locale + +@RunWith(AndroidJUnit4::class) +class ExactInputCandidatePromoterPerformanceInstrumentedTest { + @Volatile + private var listSink: List? = null + + @Volatile + private var setSink: Set? = null + + @Volatile + private var wordListSink: List? = null + + @Test + fun measuresRuleAndCandidateScaleOnAndroidRuntime() { + val arguments = InstrumentationRegistry.getArguments() + assumeTrue(arguments.getString(PERFORMANCE_PROBE_ARGUMENT) == "true") + + warmUp() + val ruleResults = listOf(22, 10_000, 100_000).map(::measureRuleScale) + val candidateResults = listOf(10_000, 100_000).map(::measureCandidateScale) + + val report = buildString { + appendLine("EXACT_INPUT_PROMOTION_ANDROID_REPORT") + appendLine( + "device=${android.os.Build.MANUFACTURER} ${android.os.Build.MODEL} " + + "api=${android.os.Build.VERSION.SDK_INT}", + ) + appendLine( + "rules\tsetBuildMs\tsetBuildAllocatedBytes\tsetRetainedHeapDeltaBytes\t" + + "hitP50Us\thitP95Us\thitAllocatedBytesPerCall\t" + + "missP50Us\tmissP95Us\tmissAllocatedBytesPerCall", + ) + ruleResults.forEach { appendLine(it.asTsv()) } + appendLine( + "candidates\tpromotionP50Ms\tpromotionP95Ms\t" + + "promotionAllocatedBytesPerCall\tbytesPerCandidate", + ) + candidateResults.forEach { appendLine(it.asTsv()) } + } + + val context = ApplicationProvider.getApplicationContext() + File(context.filesDir, REPORT_DIRECTORY).apply { mkdirs() } + .resolve(REPORT_FILE) + .writeText(report) + println(report) + } + + private fun warmUp() { + val candidates = List(64) { index -> + candidate(if (index == 63) WARMUP_INPUT else "候補-$index") + } + val promoter = ExactInputCandidatePromoter(hashSetOf(WARMUP_INPUT)) + repeat(1_000) { + listSink = promoter.promote(WARMUP_INPUT, candidates) + } + } + + private fun measureRuleScale(ruleCount: Int): RuleScaleResult { + val words = List(ruleCount) { index -> "長期運用語-$index" } + wordListSink = words + setSink = null + forceGc() + val heapBefore = usedHeapBytes() + val allocatedBefore = allocatedBytes() + val startedNs = SystemClock.elapsedRealtimeNanos() + val rules = HashSet(words) + val buildElapsedNs = SystemClock.elapsedRealtimeNanos() - startedNs + val buildAllocatedBytes = allocatedBytes() - allocatedBefore + setSink = rules + forceGc() + val retainedHeapDeltaBytes = usedHeapBytes() - heapBefore + + val target = words.last() + val candidates = List(64) { index -> + candidate(if (index == 63) target else "候補-$index") + } + val promoter = ExactInputCandidatePromoter(rules) + repeat(50) { + listSink = promoter.promote(target, candidates) + } + val hitTiming = measureRepeated(300) { + listSink = promoter.promote(target, candidates) + } + val hitAllocatedBytesPerCall = measureAllocatedBytesPerCall(200) { + listSink = promoter.promote(target, candidates) + } + val missTiming = measureRepeated(300) { + listSink = promoter.promote(UNREGISTERED_INPUT, candidates) + } + val missAllocatedBytesPerCall = measureAllocatedBytesPerCall(500) { + listSink = promoter.promote(UNREGISTERED_INPUT, candidates) + } + + assertEquals(target, promoter.promote(target, candidates).first().string) + assertSame(candidates, promoter.promote(UNREGISTERED_INPUT, candidates)) + return RuleScaleResult( + rules = ruleCount, + setBuildNs = buildElapsedNs, + setBuildAllocatedBytes = buildAllocatedBytes, + setRetainedHeapDeltaBytes = retainedHeapDeltaBytes, + hitTiming = hitTiming, + hitAllocatedBytesPerCall = hitAllocatedBytesPerCall, + missTiming = missTiming, + missAllocatedBytesPerCall = missAllocatedBytesPerCall, + ) + } + + private fun measureCandidateScale(candidateCount: Int): CandidateScaleResult { + val promoter = ExactInputCandidatePromoter(hashSetOf(TARGET_INPUT)) + val candidates = List(candidateCount) { index -> + candidate( + string = if (index == candidateCount - 1) TARGET_INPUT else "候補-$index", + type = if (index % 1_000 == 0) { + CANDIDATE_TYPE_LEARNED_DICTIONARY + } else { + 1 + }, + ) + } + repeat(if (candidateCount == 10_000) 30 else 10) { + listSink = promoter.promote(TARGET_INPUT, candidates) + } + val allocatedBytesPerCall = measureAllocatedBytesPerCall( + iterations = if (candidateCount == 10_000) 20 else 10, + ) { + listSink = promoter.promote(TARGET_INPUT, candidates) + } + val timing = measureRepeated(if (candidateCount == 10_000) 50 else 20) { + listSink = promoter.promote(TARGET_INPUT, candidates) + } + val result = promoter.promote(TARGET_INPUT, candidates) + val learnedCount = candidates.count { + it.type == CANDIDATE_TYPE_LEARNED_DICTIONARY + } + + assertEquals(candidateCount, result.size) + assertEquals(TARGET_INPUT, result[learnedCount].string) + assertTrue(allocatedBytesPerCall > 0L) + return CandidateScaleResult( + candidates = candidateCount, + timing = timing, + allocatedBytesPerCall = allocatedBytesPerCall, + ) + } + + private fun measureAllocatedBytesPerCall( + iterations: Int, + block: () -> Unit, + ): Long { + val before = allocatedBytes() + repeat(iterations) { + block() + } + return (allocatedBytes() - before) / iterations + } + + private fun measureRepeated( + iterations: Int, + block: () -> Unit, + ): TimingMeasurement { + val samples = LongArray(iterations) + repeat(iterations) { index -> + val startedNs = SystemClock.elapsedRealtimeNanos() + block() + samples[index] = SystemClock.elapsedRealtimeNanos() - startedNs + } + samples.sort() + return TimingMeasurement( + p50Ns = samples[((samples.size - 1) * 50) / 100], + p95Ns = samples[((samples.size - 1) * 95) / 100], + ) + } + + private fun forceGc() { + repeat(3) { + Runtime.getRuntime().gc() + SystemClock.sleep(50) + } + } + + private fun usedHeapBytes(): Long { + val runtime = Runtime.getRuntime() + return runtime.totalMemory() - runtime.freeMemory() + } + + private fun allocatedBytes(): Long = + checkNotNull(Debug.getRuntimeStat("art.gc.bytes-allocated")).toLong() + + private fun candidate( + string: String, + type: Byte = 1, + ): Candidate = Candidate( + string = string, + type = type, + length = string.length.toUByte(), + score = 0, + ) + + private data class RuleScaleResult( + val rules: Int, + val setBuildNs: Long, + val setBuildAllocatedBytes: Long, + val setRetainedHeapDeltaBytes: Long, + val hitTiming: TimingMeasurement, + val hitAllocatedBytesPerCall: Long, + val missTiming: TimingMeasurement, + val missAllocatedBytesPerCall: Long, + ) { + fun asTsv(): String = listOf( + rules, + setBuildNs.asMilliseconds(), + setBuildAllocatedBytes, + setRetainedHeapDeltaBytes, + hitTiming.p50Ns.asMicroseconds(), + hitTiming.p95Ns.asMicroseconds(), + hitAllocatedBytesPerCall, + missTiming.p50Ns.asMicroseconds(), + missTiming.p95Ns.asMicroseconds(), + missAllocatedBytesPerCall, + ).joinToString("\t") + } + + private data class CandidateScaleResult( + val candidates: Int, + val timing: TimingMeasurement, + val allocatedBytesPerCall: Long, + ) { + fun asTsv(): String = listOf( + candidates, + timing.p50Ns.asMilliseconds(), + timing.p95Ns.asMilliseconds(), + allocatedBytesPerCall, + String.format( + Locale.ROOT, + "%.2f", + allocatedBytesPerCall.toDouble() / candidates, + ), + ).joinToString("\t") + } + + private data class TimingMeasurement( + val p50Ns: Long, + val p95Ns: Long, + ) + + private companion object { + const val PERFORMANCE_PROBE_ARGUMENT = "exactInputPromotionPerfProbe" + const val REPORT_DIRECTORY = "conversion-perf" + const val REPORT_FILE = "exact-input-promotion-android.txt" + const val WARMUP_INPUT = "ウォームアップ" + const val TARGET_INPUT = "ふ" + const val UNREGISTERED_INPUT = "登録外" + + fun Long.asMicroseconds(): String = + String.format(Locale.ROOT, "%.3f", this / 1_000.0) + + fun Long.asMilliseconds(): String = + String.format(Locale.ROOT, "%.3f", this / 1_000_000.0) + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt new file mode 100644 index 000000000..c31bcc321 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt @@ -0,0 +1,107 @@ +package com.kazumaproject.markdownhelperkeyboard.converter.candidate + +/** + * Promotes selected literal-input candidates without overriding learned choices. + * + * The stable priority order is: + * 1. learned candidates, + * 2. the first candidate whose output is exactly the current input, + * 3. every other candidate. + * + * Callers may apply an explicit, user-saved order after this policy. Inputs or candidate lists that + * require no reordering are returned unchanged so the normal conversion path does not allocate. + */ +internal class ExactInputCandidatePromoter( + private val promotedInputs: Set, +) { + fun promote( + input: String, + candidates: List, + ): List { + if (candidates.size <= 1 || input !in promotedInputs) return candidates + + var exactIndex = -1 + var previousCategory = LEARNED_CATEGORY + var needsReordering = false + + for (index in candidates.indices) { + val candidate = candidates[index] + if (exactIndex == -1 && candidate.string == input) { + exactIndex = index + } + val category = when { + candidate.type == CANDIDATE_TYPE_LEARNED_DICTIONARY -> LEARNED_CATEGORY + index == exactIndex -> EXACT_INPUT_CATEGORY + else -> OTHER_CATEGORY + } + if (category < previousCategory) { + needsReordering = true + } + previousCategory = category + } + + if (exactIndex == -1 || !needsReordering) return candidates + + val exactCandidate = candidates[exactIndex] + val result = ArrayList(candidates.size) + for (index in candidates.indices) { + val candidate = candidates[index] + if (candidate.type == CANDIDATE_TYPE_LEARNED_DICTIONARY) { + result.add(candidate) + } + } + if (exactCandidate.type != CANDIDATE_TYPE_LEARNED_DICTIONARY) { + result.add(exactCandidate) + } + for (index in candidates.indices) { + val candidate = candidates[index] + if ( + candidate.type != CANDIDATE_TYPE_LEARNED_DICTIONARY && + index != exactIndex + ) { + result.add(candidate) + } + } + return result + } + + private companion object { + const val LEARNED_CATEGORY = 0 + const val EXACT_INPUT_CATEGORY = 1 + const val OTHER_CATEGORY = 2 + } +} + +internal object ExactInputCandidatePromotionPolicy { + private val promoter = ExactInputCandidatePromoter( + hashSetOf( + "ての", + "か？", + "え", + "き", + "く", + "け", + "こ", + "さ", + "し", + "せ", + "そ", + "た", + "ち", + "て", + "ひ", + "ふ", + "ほ", + "み", + "む", + "め", + "ゆ", + "り", + ), + ) + + fun promote( + input: String, + candidates: List, + ): List = promoter.promote(input, candidates) +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/ExactInputPenaltyPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/ExactInputPenaltyPolicy.kt index ddbfeb799..0c5432a9b 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/ExactInputPenaltyPolicy.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/ExactInputPenaltyPolicy.kt @@ -6,7 +6,6 @@ internal object ExactInputPenaltyPolicy { private val zeroPrefixPenaltyWords: Set = setOf( "にて", "しか", - "ての", ) fun shouldZeroPrefixPenalty( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 69c542cb9..205bf4b86 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -177,6 +177,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_USER_DICTIONARY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_USER_TEMPLATE import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.ExactInputCandidatePromotionPolicy import com.kazumaproject.markdownhelperkeyboard.converter.candidate.QWERTY_GLIDE_CANDIDATE_TYPE import com.kazumaproject.markdownhelperkeyboard.converter.candidate.ZenzCandidate import com.kazumaproject.markdownhelperkeyboard.converter.candidate.buildRomajiCandidates @@ -15193,7 +15194,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, rawScores.toList() ) - reranked + applyMergedCandidateOrder( + input = insertString, + candidates = reranked, + ) } private suspend fun getZenzContext( @@ -22141,17 +22145,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } }.withoutHentaiganaCandidatesIfNeeded().distinctBy { it.string } - val orderedCandidates = - if (appPreference.candidate_order_override_enable_preference == true) { - measureDebugStage("IMEService.candidateOrderOverride") { - candidateOrderOverrideRepository.applyOrderFromSnapshot( - input = insertString, - candidates = filteredCandidates - ) - } - } else { - filteredCandidates - } + val orderedCandidates = applyMergedCandidateOrder( + input = insertString, + candidates = filteredCandidates, + ) if (candidateRequestTracker.isCurrent(token)) { updateBunsetsuStateAfterCandidateMerge( @@ -22273,17 +22270,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, }.withoutHentaiganaCandidatesIfNeeded().distinctBy { it.string } } - val orderedCandidates = - if (appPreference.candidate_order_override_enable_preference == true) { - measureDebugStage("IMEService.candidateOrderOverride") { - candidateOrderOverrideRepository.applyOrderFromSnapshot( - input = insertString, - candidates = filteredCandidates - ) - } - } else { - filteredCandidates - } + val orderedCandidates = applyMergedCandidateOrder( + input = insertString, + candidates = filteredCandidates, + ) if (token == null || candidateRequestTracker.isCurrent(token)) { updateBunsetsuStateAfterCandidateMerge( @@ -22402,17 +22392,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } }.withoutHentaiganaCandidatesIfNeeded().distinctBy { it.string } - val orderedCandidates = - if (appPreference.candidate_order_override_enable_preference == true) { - measureDebugStage("IMEService.candidateOrderOverride") { - candidateOrderOverrideRepository.applyOrderFromSnapshot( - input = insertString, - candidates = filteredCandidates - ) - } - } else { - filteredCandidates - } + val orderedCandidates = applyMergedCandidateOrder( + input = insertString, + candidates = filteredCandidates, + ) if (candidateRequestTracker.isCurrent(token)) { updateBunsetsuStateAfterCandidateMerge( @@ -22425,6 +22408,28 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, return orderedCandidates } + private suspend fun applyMergedCandidateOrder( + input: String, + candidates: List, + ): List { + val promotedCandidates = measureDebugStage("IMEService.exactInputPromotion") { + ExactInputCandidatePromotionPolicy.promote( + input = input, + candidates = candidates, + ) + } + return if (appPreference.candidate_order_override_enable_preference == true) { + measureDebugStage("IMEService.candidateOrderOverride") { + candidateOrderOverrideRepository.applyOrderFromSnapshot( + input = input, + candidates = promotedCandidates, + ) + } + } else { + promotedCandidates + } + } + private suspend fun getSuggestionListEnglishKana( insertString: String, ): List { diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceTest.kt new file mode 100644 index 000000000..2ff4ab98a --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromoterPerformanceTest.kt @@ -0,0 +1,234 @@ +package com.kazumaproject.markdownhelperkeyboard.converter.candidate + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import java.util.Locale + +class ExactInputCandidatePromoterPerformanceTest { + @Volatile + private var listSink: List? = null + + @Volatile + private var setSink: Set? = null + + private val allocationMeter = ThreadAllocationMeter() + + @Test + fun measuresTenThousandAndHundredThousandPromotionRules() { + val warmupCandidates = List(64) { index -> + candidate(if (index == 63) "ウォームアップ" else "候補-$index") + } + val warmupPromoter = ExactInputCandidatePromoter(setOf("ウォームアップ")) + repeat(500) { + listSink = warmupPromoter.promote("ウォームアップ", warmupCandidates) + } + + listOf(22, 10_000, 100_000).forEach { ruleCount -> + val words = List(ruleCount) { index -> "長期運用語-$index" } + val setBuild = measureOnce { + HashSet(words) + } + val rules = setBuild.value + setSink = rules + val target = words.last() + val candidates = List(64) { index -> + candidate(if (index == 63) target else "候補-$index") + } + val promoter = ExactInputCandidatePromoter(rules) + repeat(20) { + listSink = promoter.promote(target, candidates) + } + val hitTiming = measureRepeated(200) { + listSink = promoter.promote(target, candidates) + } + val missAllocation = measureOnce { + promoter.promote("登録外", candidates) + } + val missTiming = measureRepeated(200) { + listSink = promoter.promote("登録外", candidates) + } + + println( + "EXACT_PROMOTION_RULE_SCALE " + + "rules=$ruleCount " + + "setBuildMs=${setBuild.elapsedNs.toMilliseconds()} " + + "setIndexAllocatedBytes=${setBuild.allocatedBytes} " + + "hitMedianUs=${hitTiming.medianNs.toMicroseconds()} " + + "hitP95Us=${hitTiming.p95Ns.toMicroseconds()} " + + "missMedianUs=${missTiming.medianNs.toMicroseconds()} " + + "missP95Us=${missTiming.p95Ns.toMicroseconds()} " + + "missAllocatedBytes=${missAllocation.allocatedBytes}", + ) + + assertEquals(target, promoter.promote(target, candidates).first().string) + assertSame(candidates, missAllocation.value) + assertTrue(setBuild.allocatedBytes > 0) + assertTrue(hitTiming.medianNs < 100_000_000L) + assertTrue(missAllocation.allocatedBytes < 1_024L) + } + } + + @Test + fun measuresTenThousandAndHundredThousandCandidates() { + val promoter = ExactInputCandidatePromoter(setOf("ふ")) + val scenarios = listOf(10_000, 100_000).associateWith { candidateCount -> + List(candidateCount) { index -> + candidate( + string = if (index == candidateCount - 1) "ふ" else "候補-$index", + type = if (index % 1_000 == 0) { + CANDIDATE_TYPE_LEARNED_DICTIONARY + } else { + 1 + }, + ) + } + } + repeat(30) { + listSink = promoter.promote("ふ", checkNotNull(scenarios[100_000])) + } + + scenarios.forEach { (candidateCount, candidates) -> + repeat(if (candidateCount == 10_000) 20 else 5) { + listSink = promoter.promote("ふ", candidates) + } + val allocation = measureOnce { + promoter.promote("ふ", candidates) + } + listSink = allocation.value + val timing = measureRepeated(if (candidateCount == 10_000) 50 else 15) { + listSink = promoter.promote("ふ", candidates) + } + val learnedCount = candidates.count { + it.type == CANDIDATE_TYPE_LEARNED_DICTIONARY + } + + println( + "EXACT_PROMOTION_CANDIDATE_SCALE " + + "candidates=$candidateCount " + + "medianMs=${timing.medianNs.toMilliseconds()} " + + "p95Ms=${timing.p95Ns.toMilliseconds()} " + + "allocatedBytes=${allocation.allocatedBytes} " + + "bytesPerCandidate=" + + String.format( + Locale.ROOT, + "%.2f", + allocation.allocatedBytes.toDouble() / candidateCount, + ), + ) + + assertEquals(candidateCount, listSink?.size) + assertEquals("ふ", listSink?.get(learnedCount)?.string) + assertTrue(timing.medianNs < 100_000_000L) + assertTrue(allocation.allocatedBytes in 1..candidateCount * 16L) + } + } + + private fun candidate( + string: String, + type: Byte = 1, + ): Candidate = Candidate( + string = string, + type = type, + length = string.length.toUByte(), + score = 0, + ) + + private fun measureOnce(block: () -> T): AllocationMeasurement { + val allocatedBefore = allocationMeter.currentThreadAllocatedBytes() + val startedNs = System.nanoTime() + val value = block() + val elapsedNs = System.nanoTime() - startedNs + val allocatedBytes = + allocationMeter.currentThreadAllocatedBytes() - allocatedBefore + return AllocationMeasurement( + value = value, + elapsedNs = elapsedNs, + allocatedBytes = allocatedBytes, + ) + } + + private fun measureRepeated( + iterations: Int, + block: () -> Unit, + ): TimingMeasurement { + val samples = LongArray(iterations) + repeat(iterations) { index -> + val startedNs = System.nanoTime() + block() + samples[index] = System.nanoTime() - startedNs + } + samples.sort() + return TimingMeasurement( + medianNs = samples[samples.size / 2], + p95Ns = samples[((samples.size - 1) * 95) / 100], + ) + } + + private fun Long.toMicroseconds(): String = + String.format(Locale.ROOT, "%.3f", this / 1_000.0) + + private fun Long.toMilliseconds(): String = + String.format(Locale.ROOT, "%.3f", this / 1_000_000.0) + + private data class AllocationMeasurement( + val value: T, + val elapsedNs: Long, + val allocatedBytes: Long, + ) + + private data class TimingMeasurement( + val medianNs: Long, + val p95Ns: Long, + ) + + /** + * Android's unit-test compile classpath does not expose java.lang.management, even though + * these tests run on a HotSpot JVM. Reflection keeps the benchmark out of production code + * while still using the JVM's precise per-thread allocation counter at test runtime. + */ + private class ThreadAllocationMeter { + private val bean: Any + private val allocatedBytesMethod: java.lang.reflect.Method + + init { + val managementFactoryClass = + Class.forName("java.lang.management.ManagementFactory") + bean = requireNotNull( + managementFactoryClass + .getMethod("getThreadMXBean") + .invoke(null) + ) + + val threadMxBeanClass = Class.forName("com.sun.management.ThreadMXBean") + check( + threadMxBeanClass + .getMethod("isThreadAllocatedMemorySupported") + .invoke(bean) as Boolean + ) { + "The test JVM must support per-thread allocation measurement" + } + if ( + !(threadMxBeanClass + .getMethod("isThreadAllocatedMemoryEnabled") + .invoke(bean) as Boolean) + ) { + threadMxBeanClass + .getMethod( + "setThreadAllocatedMemoryEnabled", + Boolean::class.javaPrimitiveType, + ) + .invoke(bean, true) + } + allocatedBytesMethod = threadMxBeanClass.getMethod( + "getThreadAllocatedBytes", + Long::class.javaPrimitiveType, + ) + } + + @Suppress("DEPRECATION") + fun currentThreadAllocatedBytes(): Long = + allocatedBytesMethod.invoke(bean, Thread.currentThread().id) as Long + } +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicyTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicyTest.kt new file mode 100644 index 000000000..49fff19b8 --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicyTest.kt @@ -0,0 +1,137 @@ +package com.kazumaproject.markdownhelperkeyboard.converter.candidate + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Test + +class ExactInputCandidatePromotionPolicyTest { + + @Test + fun promotesEveryConfiguredLiteralInput() { + configuredInputs.forEach { input -> + val candidates = listOf( + candidate("変換候補"), + candidate(input), + candidate("別候補"), + ) + + val result = ExactInputCandidatePromotionPolicy.promote(input, candidates) + + assertEquals(input, result.first().string) + assertEquals(candidates.toSet(), result.toSet()) + } + } + + @Test + fun keepsAllLearnedCandidatesAheadOfExactInput() { + val candidates = listOf( + candidate("通常候補"), + candidate("学習2", CANDIDATE_TYPE_LEARNED_DICTIONARY), + candidate("ふ"), + candidate("学習1", CANDIDATE_TYPE_LEARNED_DICTIONARY), + candidate("その他"), + ) + + val result = ExactInputCandidatePromotionPolicy.promote("ふ", candidates) + + assertEquals( + listOf("学習2", "学習1", "ふ", "通常候補", "その他"), + result.map { it.string }, + ) + } + + @Test + fun learnedExactInputStaysInLearnedGroupWithoutDuplication() { + val candidates = listOf( + candidate("通常候補"), + candidate("む", CANDIDATE_TYPE_LEARNED_DICTIONARY), + candidate("別の学習", CANDIDATE_TYPE_LEARNED_DICTIONARY), + ) + + val result = ExactInputCandidatePromotionPolicy.promote("む", candidates) + + assertEquals(listOf("む", "別の学習", "通常候補"), result.map { it.string }) + assertEquals(1, result.count { it.string == "む" }) + } + + @Test + fun segmentedAndFallbackOutputsNeedOnlyFinalStringEquality() { + val candidates = listOf( + candidate("過？"), + candidate("か？"), + candidate("可？"), + ) + + val result = ExactInputCandidatePromotionPolicy.promote("か？", candidates) + + assertEquals("か？", result.first().string) + } + + @Test + fun returnsOriginalListWhenInputIsNotConfigured() { + val candidates = listOf(candidate("候補"), candidate("そのまま")) + + val result = ExactInputCandidatePromotionPolicy.promote("そのまま", candidates) + + assertSame(candidates, result) + } + + @Test + fun returnsOriginalListWhenExactCandidateIsMissing() { + val candidates = listOf(candidate("無"), candidate("夢")) + + val result = ExactInputCandidatePromotionPolicy.promote("む", candidates) + + assertSame(candidates, result) + } + + @Test + fun returnsOriginalListWhenPriorityOrderIsAlreadySatisfied() { + val candidates = listOf( + candidate("学習", CANDIDATE_TYPE_LEARNED_DICTIONARY), + candidate("ほ"), + candidate("補"), + ) + + val result = ExactInputCandidatePromotionPolicy.promote("ほ", candidates) + + assertSame(candidates, result) + } + + private fun candidate( + string: String, + type: Byte = 1, + ): Candidate = Candidate( + string = string, + type = type, + length = string.length.toUByte(), + score = 0, + ) + + private companion object { + val configuredInputs = listOf( + "ての", + "か？", + "え", + "き", + "く", + "け", + "こ", + "さ", + "し", + "せ", + "そ", + "た", + "ち", + "て", + "ひ", + "ふ", + "ほ", + "み", + "む", + "め", + "ゆ", + "り", + ) + } +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupView.kt index c17e48c23..0c57eaf91 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupView.kt @@ -10,10 +10,10 @@ import android.graphics.RectF import android.util.TypedValue import androidx.appcompat.widget.AppCompatTextView import androidx.core.graphics.toColorInt -import androidx.core.graphics.withRotation import com.kazumaproject.core.data.popup.PopupViewStyle import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.FlickPopupColorTheme +import kotlin.math.min /** * 通常フリック時に表示される、方向を示す矢印型のポップアップ @@ -33,7 +33,6 @@ class DirectionalKeyPopupView(context: Context) : AppCompatTextView(context) { private val backgroundPath = Path() private val textBounds = Rect() - private var viewRotation = 0f private var currentDirection: FlickDirection = FlickDirection.TAP // カラーテーマから受け取る色のプレースホルダー @@ -66,13 +65,6 @@ class DirectionalKeyPopupView(context: Context) : AppCompatTextView(context) { fun setFlickDirection(direction: FlickDirection) { this.currentDirection = direction - this.viewRotation = when (direction) { - FlickDirection.UP -> 90f - FlickDirection.DOWN -> -90f - FlickDirection.UP_LEFT_FAR -> 0f - FlickDirection.UP_RIGHT_FAR -> 180f - else -> 0f - } invalidate() } @@ -102,13 +94,8 @@ class DirectionalKeyPopupView(context: Context) : AppCompatTextView(context) { updatePath(w, h) - // 背景と枠線の両方が回転されるように、withRotationブロック内で描画 - canvas.withRotation(viewRotation, w / 2f, h / 2f) { - // 1. 背景（塗りつぶし）を描画 - drawPath(backgroundPath, backgroundPaint) - // 2. 枠線を描画 - drawPath(backgroundPath, strokePaint) - } + canvas.drawPath(backgroundPath, backgroundPaint) + canvas.drawPath(backgroundPath, strokePaint) val textToDraw = this.text.toString() val textPaint = this.paint @@ -129,34 +116,124 @@ class DirectionalKeyPopupView(context: Context) : AppCompatTextView(context) { private fun updatePath(w: Float, h: Float) { backgroundPath.reset() - val cornerRadius = 24f - val pointerHeight = 35f - val showPointer = currentDirection != FlickDirection.TAP - - if (showPointer) { - val rectWidth = w - pointerHeight + val cornerRadius = min(24f, min(w, h) / 2f) + val pointerLength = min(35f, min(w, h)) - backgroundPath.moveTo(cornerRadius, 0f) - backgroundPath.lineTo(rectWidth, 0f) - backgroundPath.lineTo(w, h / 2f) - backgroundPath.lineTo(rectWidth, h) - backgroundPath.lineTo(cornerRadius, h) - backgroundPath.quadTo(0f, h, 0f, h - cornerRadius) - backgroundPath.lineTo(0f, cornerRadius) - backgroundPath.quadTo(0f, 0f, cornerRadius, 0f) - - } else { - backgroundPath.addRoundRect( + when (currentDirection) { + FlickDirection.TAP -> backgroundPath.addRoundRect( RectF(0f, 0f, w, h), cornerRadius, cornerRadius, Path.Direction.CW ) + + FlickDirection.UP -> updateDownPointingPath( + w = w, + h = h, + cornerRadius = cornerRadius, + pointerLength = pointerLength + ) + + FlickDirection.DOWN -> updateUpPointingPath( + w = w, + h = h, + cornerRadius = cornerRadius, + pointerLength = pointerLength + ) + + FlickDirection.UP_LEFT_FAR, + FlickDirection.UP_LEFT -> updateRightPointingPath( + w = w, + h = h, + cornerRadius = cornerRadius, + pointerLength = pointerLength + ) + + FlickDirection.UP_RIGHT_FAR, + FlickDirection.UP_RIGHT -> updateLeftPointingPath( + w = w, + h = h, + cornerRadius = cornerRadius, + pointerLength = pointerLength + ) } backgroundPath.close() } + private fun updateRightPointingPath( + w: Float, + h: Float, + cornerRadius: Float, + pointerLength: Float + ) { + val bodyRight = w - pointerLength + val radius = min(cornerRadius, min(bodyRight, h) / 2f) + backgroundPath.moveTo(radius, 0f) + backgroundPath.lineTo(bodyRight, 0f) + backgroundPath.lineTo(w, h / 2f) + backgroundPath.lineTo(bodyRight, h) + backgroundPath.lineTo(radius, h) + backgroundPath.quadTo(0f, h, 0f, h - radius) + backgroundPath.lineTo(0f, radius) + backgroundPath.quadTo(0f, 0f, radius, 0f) + } + + private fun updateLeftPointingPath( + w: Float, + h: Float, + cornerRadius: Float, + pointerLength: Float + ) { + val bodyLeft = pointerLength + val bodyWidth = w - bodyLeft + val radius = min(cornerRadius, min(bodyWidth, h) / 2f) + backgroundPath.moveTo(w - radius, 0f) + backgroundPath.lineTo(bodyLeft, 0f) + backgroundPath.lineTo(0f, h / 2f) + backgroundPath.lineTo(bodyLeft, h) + backgroundPath.lineTo(w - radius, h) + backgroundPath.quadTo(w, h, w, h - radius) + backgroundPath.lineTo(w, radius) + backgroundPath.quadTo(w, 0f, w - radius, 0f) + } + + private fun updateDownPointingPath( + w: Float, + h: Float, + cornerRadius: Float, + pointerLength: Float + ) { + val bodyBottom = h - pointerLength + val radius = min(cornerRadius, min(w, bodyBottom) / 2f) + backgroundPath.moveTo(radius, 0f) + backgroundPath.lineTo(w - radius, 0f) + backgroundPath.quadTo(w, 0f, w, radius) + backgroundPath.lineTo(w, bodyBottom) + backgroundPath.lineTo(w / 2f, h) + backgroundPath.lineTo(0f, bodyBottom) + backgroundPath.lineTo(0f, radius) + backgroundPath.quadTo(0f, 0f, radius, 0f) + } + + private fun updateUpPointingPath( + w: Float, + h: Float, + cornerRadius: Float, + pointerLength: Float + ) { + val bodyTop = pointerLength + val bodyHeight = h - bodyTop + val radius = min(cornerRadius, min(w, bodyHeight) / 2f) + backgroundPath.moveTo(w / 2f, 0f) + backgroundPath.lineTo(w, bodyTop) + backgroundPath.lineTo(w, h - radius) + backgroundPath.quadTo(w, h, w - radius, h) + backgroundPath.lineTo(radius, h) + backgroundPath.quadTo(0f, h, 0f, h - radius) + backgroundPath.lineTo(0f, bodyTop) + } + // ▼▼▼ 追加: dpをピクセルに変換するヘルパー関数 ▼▼▼ private fun dpToPx(dp: Float): Float { return TypedValue.applyDimension( diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupViewTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupViewTest.kt new file mode 100644 index 000000000..6d32f74af --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/DirectionalKeyPopupViewTest.kt @@ -0,0 +1,88 @@ +package com.kazumaproject.custom_keyboard.view + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.Canvas +import android.graphics.Color +import android.view.ContextThemeWrapper +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.core.data.popup.PopupViewStyle +import com.kazumaproject.custom_keyboard.data.FlickDirection +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class DirectionalKeyPopupViewTest { + + @Test + fun verticalDirectionsFillLandscapePopupWidthWithoutRotationClipping() { + val upBitmap = render(FlickDirection.UP) + val downBitmap = render(FlickDirection.DOWN) + + listOf(40, POPUP_WIDTH - 40).forEach { x -> + assertEquals(Color.RED, upBitmap.getPixel(x, 40)) + assertEquals(Color.RED, downBitmap.getPixel(x, POPUP_HEIGHT - 40)) + } + } + + @Test + fun horizontalDirectionsStillFillLandscapePopupHeight() { + val leftBitmap = render(FlickDirection.UP_LEFT_FAR) + val rightBitmap = render(FlickDirection.UP_RIGHT_FAR) + + listOf(30, POPUP_HEIGHT - 30).forEach { y -> + assertEquals(Color.RED, leftBitmap.getPixel(40, y)) + assertEquals(Color.RED, rightBitmap.getPixel(POPUP_WIDTH - 40, y)) + } + } + + private fun render(direction: FlickDirection): Bitmap { + val context = ContextThemeWrapper( + ApplicationProvider.getApplicationContext(), + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + val view = DirectionalKeyPopupView(context).apply { + text = "" + applyPopupViewStyle( + PopupViewStyle( + sizeScalePercent = 100, + textSizeSp = 28f, + backgroundColor = Color.RED, + textColor = Color.WHITE + ) + ) + setFlickDirection(direction) + measure( + ViewMeasureSpec.exactly(POPUP_WIDTH), + ViewMeasureSpec.exactly(POPUP_HEIGHT) + ) + layout(0, 0, POPUP_WIDTH, POPUP_HEIGHT) + } + return Bitmap.createBitmap( + POPUP_WIDTH, + POPUP_HEIGHT, + Bitmap.Config.ARGB_8888 + ).also { bitmap -> + view.draw(Canvas(bitmap)) + } + } + + private object ViewMeasureSpec { + fun exactly(size: Int): Int = + android.view.View.MeasureSpec.makeMeasureSpec( + size, + android.view.View.MeasureSpec.EXACTLY + ) + } + + private companion object { + const val POPUP_WIDTH = 401 + const val POPUP_HEIGHT = 120 + } +} From eead23124083a4e22886833bab65f9362287acd3 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Tue, 28 Jul 2026 06:27:18 -0400 Subject: [PATCH 03/24] improve popup position --- .../controller/CrossFlickInputController.kt | 22 +---- ...ssFlickInputControllerPopupPositionTest.kt | 89 +++++++++++++++++++ 2 files changed, 91 insertions(+), 20 deletions(-) create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt index bf93da281..c827f9dbc 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt @@ -4,7 +4,6 @@ import android.annotation.SuppressLint import android.content.Context import android.graphics.Color import android.graphics.PointF -import android.os.Build import android.view.Gravity import android.view.MotionEvent import android.view.View @@ -149,7 +148,6 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null - configurePopupWindowPositioning(this) } private val controllerScope = CoroutineScope(Dispatchers.Main + SupervisorJob()) @@ -551,7 +549,6 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null - configurePopupWindowPositioning(this) } readPopupAnchorLocation(anchor, windowAnchor) @@ -683,7 +680,6 @@ class CrossFlickInputController( animationStyle = 0 enterTransition = null exitTransition = null - configurePopupWindowPositioning(this) } } @@ -882,11 +878,8 @@ class CrossFlickInputController( } private fun readPopupAnchorLocation(keyAnchor: View, windowAnchor: View?) { - if (usesScreenPositionedPopupWindows()) { - keyAnchor.getLocationOnScreen(popupAnchorLocation) - return - } - + // showAtLocation(NO_GRAVITY) receives coordinates relative to the containing window. + // Screen coordinates add the left navigation inset again when the device is rotated 270°. getLocationRelativeToWindowAnchor( keyAnchor = keyAnchor, windowAnchor = windowAnchor, @@ -896,17 +889,6 @@ class CrossFlickInputController( ) } - private fun configurePopupWindowPositioning(popupWindow: PopupWindow) { - if (usesScreenPositionedPopupWindows()) { - popupWindow.setAttachedInDecor(false) - popupWindow.setIsLaidOutInScreen(true) - } - } - - private fun usesScreenPositionedPopupWindows(): Boolean { - return Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q - } - private fun resolveActionPopupPosition( direction: FlickDirection, anchor: View, diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt new file mode 100644 index 000000000..a5cf6861c --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt @@ -0,0 +1,89 @@ +package com.kazumaproject.custom_keyboard.controller + +import android.content.Context +import android.view.View +import androidx.test.core.app.ApplicationProvider +import org.junit.Assert.assertArrayEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class CrossFlickInputControllerPopupPositionTest { + + @Test + fun normalKeyboardUsesWindowCoordinatesWhenSystemInsetMovesWindowOrigin() { + val key = LocatedView( + context = ApplicationProvider.getApplicationContext(), + screenLocation = intArrayOf(560, 599), + windowLocation = intArrayOf(434, 599) + ) + + assertArrayEquals( + intArrayOf(434, 599), + readPopupAnchorLocation(keyAnchor = key, windowAnchor = key) + ) + } + + @Test + fun floatingKeyboardUsesCoordinatesRelativeToProvidedWindowAnchor() { + val context = ApplicationProvider.getApplicationContext() + val key = LocatedView( + context = context, + screenLocation = intArrayOf(760, 640), + windowLocation = intArrayOf(760, 640) + ) + val windowAnchor = LocatedView( + context = context, + screenLocation = intArrayOf(120, 80), + windowLocation = intArrayOf(120, 80) + ) + + assertArrayEquals( + intArrayOf(640, 560), + readPopupAnchorLocation(keyAnchor = key, windowAnchor = windowAnchor) + ) + } + + private fun readPopupAnchorLocation( + keyAnchor: View, + windowAnchor: View + ): IntArray { + val controller = CrossFlickInputController( + context = ApplicationProvider.getApplicationContext(), + flickSensitivity = 80 + ) + val method = CrossFlickInputController::class.java.getDeclaredMethod( + "readPopupAnchorLocation", + View::class.java, + View::class.java + ).apply { + isAccessible = true + } + method.invoke(controller, keyAnchor, windowAnchor) + + return CrossFlickInputController::class.java + .getDeclaredField("popupAnchorLocation") + .apply { isAccessible = true } + .get(controller) as IntArray + } + + private class LocatedView( + context: Context, + private val screenLocation: IntArray, + private val windowLocation: IntArray + ) : View(context) { + + override fun getLocationOnScreen(outLocation: IntArray) { + outLocation[0] = screenLocation[0] + outLocation[1] = screenLocation[1] + } + + override fun getLocationInWindow(outLocation: IntArray) { + outLocation[0] = windowLocation[0] + outLocation[1] = windowLocation[1] + } + } +} From d5c28e19743cab72522f20cffedf1475d568b1ff Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Tue, 28 Jul 2026 18:58:00 -0400 Subject: [PATCH 04/24] add double tap --- ...versionPerformanceInstrumentedProbeTest.kt | 84 ++++++ .../GemmaDatabaseMigrationInstrumentedTest.kt | 10 +- .../ExactInputCandidatePromotionPolicy.kt | 1 + .../custom_keyboard/data/KeyDefinition.kt | 4 +- .../import_export/KeyboardBackupPipeline.kt | 50 +++- .../import_export/KeyboardLayoutExportDtos.kt | 6 + .../KeyboardLayoutJsonExporter.kt | 14 + .../KeyboardLayoutJsonImporter.kt | 2 +- .../custom_keyboard/ui/KeyEditorFragment.kt | 151 ++++++++++- .../database/AppDatabase.kt | 55 +++- .../ime_service/CustomKeyboardShiftState.kt | 36 +++ .../ime_service/IMEService.kt | 135 ++++------ .../ime_service/di/AppModule.kt | 4 + .../repository/KeyboardRepository.kt | 43 ++- .../main/res/layout/fragment_key_editor.xml | 36 +++ app/src/main/res/values-ja/strings.xml | 2 + app/src/main/res/values/strings.xml | 2 + .../database/DoubleTapMigrationTest.kt | 133 ++++++++++ .../KeyboardLayoutJsonImporterTest.kt | 219 +++++++++++++++- .../CustomKeyboardShiftStateTest.kt | 41 +++ .../KeyboardRepositoryDeleteImpactTest.kt | 41 +++ .../KeyboardRepositoryGridPlacementTest.kt | 95 +++++++ .../DoubleTapFlickKeyboardInstrumentedTest.kt | 248 ++++++++++++++++++ .../controller/CrossFlickInputController.kt | 12 +- .../controller/CustomAngleFlickController.kt | 4 + .../controller/DoubleTapActionDispatcher.kt | 126 +++++++++ .../FlickLongPressInputController.kt | 7 + .../StandardFlickInputController.kt | 4 + .../TfbiHierarchicalFlickController.kt | 7 + .../controller/TfbiInputController.kt | 7 + .../controller/TfbiStickyFlickController.kt | 7 + .../custom_keyboard/data/KeyCharacterCase.kt | 25 ++ .../custom_keyboard/data/KeyGestureBinding.kt | 60 +++++ .../custom_keyboard/data/KeyModels.kt | 3 +- .../layout/KeyboardDefaultLayouts.kt | 10 +- .../view/CrossFlickPopupView.kt | 27 +- .../view/CustomAngleFlickPopupView.kt | 25 +- .../custom_keyboard/view/FlickKeyboardView.kt | 186 +++++++++++-- .../view/StandardFlickPopupView.kt | 17 +- .../view/TfbiFlickPopupView.kt | 10 +- .../DoubleTapActionDispatcherTest.kt | 117 +++++++++ .../data/KeyCharacterCaseTest.kt | 29 ++ .../data/KeyGestureBindingTest.kt | 62 +++++ .../layout/AlphabetTemplateLayoutsTest.kt | 11 + .../FlickKeyboardViewCharacterCaseTest.kt | 147 +++++++++++ .../FlickKeyboardViewTouchDispatchTest.kt | 123 ++++++++- 46 files changed, 2289 insertions(+), 149 deletions(-) create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftState.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/database/DoubleTapMigrationTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftStateTest.kt create mode 100644 custom_keyboard/src/androidTest/java/com/kazumaproject/custom_keyboard/DoubleTapFlickKeyboardInstrumentedTest.kt create mode 100644 custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcher.kt create mode 100644 custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCase.kt create mode 100644 custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyGestureBinding.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcherTest.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCaseTest.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyGestureBindingTest.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewCharacterCaseTest.kt diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt index ab8ffc1ad..9873eb540 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt @@ -1,9 +1,13 @@ package com.kazumaproject.markdownhelperkeyboard.converter import android.content.Context +import android.view.ContextThemeWrapper import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase +import com.kazumaproject.custom_keyboard.layout.KeyboardDefaultLayouts +import com.kazumaproject.custom_keyboard.view.FlickKeyboardView import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine import com.kazumaproject.markdownhelperkeyboard.ime_service.di.KanaKanjiEngineEntryPoint @@ -11,6 +15,7 @@ import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryReposit import dagger.hilt.android.EntryPointAccessors import kotlinx.coroutines.runBlocking import org.junit.Assume.assumeTrue +import org.junit.Assert.assertEquals import org.junit.Test import org.junit.runner.RunWith import java.io.File @@ -19,6 +24,85 @@ import kotlin.system.measureNanoTime @RunWith(AndroidJUnit4::class) class ConversionPerformanceInstrumentedProbeTest { + @Test + fun compareConversionWithDefinedAndUppercaseKeyPresentation() = runBlocking { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val arguments = InstrumentationRegistry.getArguments() + assumeTrue(arguments.getString("keyCaseConversionProbe") == "true") + val iterations = arguments.getString("keyCaseConversionIterations")?.toIntOrNull() ?: 30 + val input = "わたしはきのうともだちとえきまえであいました" + val context = ApplicationProvider.getApplicationContext() + val entryPoint = EntryPointAccessors.fromApplication( + context.applicationContext, + KanaKanjiEngineEntryPoint::class.java, + ) + val engine = entryPoint.kanaKanjiEngine() + val repository = entryPoint.userDictionaryRepository() + lateinit var keyboard: FlickKeyboardView + + instrumentation.runOnMainSync { + keyboard = FlickKeyboardView( + ContextThemeWrapper( + context, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar, + ), + ).apply { + setKeyboard(KeyboardDefaultLayouts.createQwertyTemplateLayout()) + } + } + + repeat(30) { + engine.convertForProbe(input, repository) + } + + val asDefinedNanos = LongArray(iterations) + val uppercaseNanos = LongArray(iterations) + var asDefinedCandidates: List = emptyList() + var uppercaseCandidates: List = emptyList() + + suspend fun measure( + characterCase: KeyCharacterCase, + samples: LongArray, + index: Int, + capture: (List) -> Unit, + ) { + instrumentation.runOnMainSync { + keyboard.setKeyCharacterCase(characterCase) + } + samples[index] = measureNanoTime { + capture(engine.convertForProbe(input, repository)) + } + } + + repeat(iterations) { index -> + if (index % 2 == 0) { + measure(KeyCharacterCase.AS_DEFINED, asDefinedNanos, index) { + asDefinedCandidates = it + } + measure(KeyCharacterCase.UPPERCASE, uppercaseNanos, index) { + uppercaseCandidates = it + } + } else { + measure(KeyCharacterCase.UPPERCASE, uppercaseNanos, index) { + uppercaseCandidates = it + } + measure(KeyCharacterCase.AS_DEFINED, asDefinedNanos, index) { + asDefinedCandidates = it + } + } + } + + assertEquals(asDefinedCandidates, uppercaseCandidates) + val asDefinedAverageUs = asDefinedNanos.average() / 1_000.0 + val uppercaseAverageUs = uppercaseNanos.average() / 1_000.0 + println( + "KEY_CASE_CONVERSION_ISOLATION iterations=$iterations " + + "asDefinedAverageUs=$asDefinedAverageUs " + + "uppercaseAverageUs=$uppercaseAverageUs " + + "ratio=${uppercaseAverageUs / asDefinedAverageUs} " + + "candidateCount=${uppercaseCandidates.size}", + ) + } @Test fun measureProductionDiConversionPerformance() = runBlocking { diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/gemma/GemmaDatabaseMigrationInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/gemma/GemmaDatabaseMigrationInstrumentedTest.kt index c0c9080e3..ef2f40e99 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/gemma/GemmaDatabaseMigrationInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/gemma/GemmaDatabaseMigrationInstrumentedTest.kt @@ -11,17 +11,21 @@ import org.junit.Assert.assertTrue import org.junit.Test import org.junit.runner.RunWith -/** Verifies the production 40 -> 41 migration against the database installed on the device. */ +/** Verifies the production 40 -> latest migration against the database installed on the device. */ @RunWith(AndroidJUnit4::class) class GemmaDatabaseMigrationInstrumentedTest { @Test fun migrateExistingDatabaseAndSeedMediaActions() = runBlocking { val context = InstrumentationRegistry.getInstrumentation().targetContext val database = Room.databaseBuilder(context, AppDatabase::class.java, "learn_database") - .addMigrations(AppDatabase.MIGRATION_40_41) + .addMigrations( + AppDatabase.MIGRATION_40_41, + AppDatabase.MIGRATION_41_42, + AppDatabase.MIGRATION_42_43 + ) .build() try { - assertEquals(41, database.openHelper.writableDatabase.version) + assertEquals(43, database.openHelper.writableDatabase.version) val repository = GemmaPromptTemplateRepository(database.gemmaPromptTemplateDao()) repository.ensureBuiltIns() val keys = database.gemmaPromptTemplateDao().getBuiltInKeys() diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt index c31bcc321..4ecb7e414 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt @@ -77,6 +77,7 @@ internal object ExactInputCandidatePromotionPolicy { hashSetOf( "ての", "か？", + "なにこれ？", "え", "き", "く", diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/data/KeyDefinition.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/data/KeyDefinition.kt index 7437648e9..7f8787d6a 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/data/KeyDefinition.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/data/KeyDefinition.kt @@ -41,5 +41,7 @@ data class KeyDefinition( val columnUnits: Int? = null, val rowSpanUnits: Int? = null, val columnSpanUnits: Int? = null, - val specialKeyColorStyle: String = SpecialKeyColorStyle.SPECIAL.dbValue + val specialKeyColorStyle: String = SpecialKeyColorStyle.SPECIAL.dbValue, + val doubleTapAction: String? = null, + val doubleTapPolicy: String? = null ) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardBackupPipeline.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardBackupPipeline.kt index b938725d8..45f4842f3 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardBackupPipeline.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardBackupPipeline.kt @@ -3,14 +3,17 @@ package com.kazumaproject.markdownhelperkeyboard.custom_keyboard.import_export import com.google.gson.Gson import com.google.gson.JsonElement import com.google.gson.JsonObject +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy import com.google.gson.reflect.TypeToken import com.kazumaproject.custom_keyboard.data.CircularFlickDirection import com.kazumaproject.custom_keyboard.data.FlickDirection +import com.kazumaproject.custom_keyboard.data.KeyActionMapper import com.kazumaproject.custom_keyboard.data.KeyType import com.kazumaproject.custom_keyboard.data.KeyIconBuiltInDrawable import com.kazumaproject.custom_keyboard.data.KeyIconType import com.kazumaproject.custom_keyboard.data.KeyboardLayoutUsageMode import com.kazumaproject.custom_keyboard.data.SpecialKeyColorStyle +import com.kazumaproject.custom_keyboard.data.automaticDoubleTapPolicy import com.kazumaproject.custom_keyboard.view.TfbiFlickDirection import com.kazumaproject.markdownhelperkeyboard.custom_keyboard.data.CircularFlickMapping import com.kazumaproject.markdownhelperkeyboard.custom_keyboard.data.CustomKeyboardLayout @@ -301,6 +304,39 @@ object KeyboardBackupNormalizer { ) } + val normalizedTapAction = remapKeyAction( + action = keyDto.action, + stableIdsByOldLayoutId = stableIdsByOldLayoutId, + layoutIndex = layoutIndex, + keyIndex = keyIndex, + warnings = warnings + ) + val isSpecialKey = keyDto.isSpecialKey ?: false + val normalizedDoubleTapAction = when { + !isSpecialKey -> null + keyDto.doubleTapEnabled == false -> null + keyDto.doubleTapAction != null -> remapKeyAction( + action = keyDto.doubleTapAction, + stableIdsByOldLayoutId = stableIdsByOldLayoutId, + layoutIndex = layoutIndex, + keyIndex = keyIndex, + warnings = warnings + ) + // Backups from before schema v3 had no gesture field. Preserve the new Shift + // default during import while still allowing v3+ exports to explicitly disable it. + keyDto.doubleTapEnabled == null && normalizedTapAction == "ShiftKeyPressed" -> + "CapLockKey" + else -> null + } + val normalizedDoubleTapPolicy = normalizedDoubleTapAction?.let { + val doubleTapAction = KeyActionMapper.toKeyAction(normalizedDoubleTapAction) + ?: return@let DoubleTapPolicy.EXCLUSIVE.serializedName + automaticDoubleTapPolicy( + normalAction = KeyActionMapper.toKeyAction(normalizedTapAction), + doubleTapAction = doubleTapAction + ).serializedName + } + val normalizedKey = KeyDefinition( keyId = 0, ownerLayoutId = 0, @@ -310,7 +346,7 @@ object KeyboardBackupNormalizer { rowSpan = keyDto.rowSpan ?: 1, colSpan = keyDto.colSpan ?: 1, keyType = enumValueOrNull(keyDto.keyType) ?: KeyType.NORMAL, - isSpecialKey = keyDto.isSpecialKey ?: false, + isSpecialKey = isSpecialKey, drawableResId = keyDto.drawableResId, iconType = normalizedIconType( iconType = keyDto.iconType, @@ -325,20 +361,16 @@ object KeyboardBackupNormalizer { iconValue = keyDto.iconValue ), keyIdentifier = identifier, - action = remapKeyAction( - action = keyDto.action, - stableIdsByOldLayoutId = stableIdsByOldLayoutId, - layoutIndex = layoutIndex, - keyIndex = keyIndex, - warnings = warnings - ), + action = normalizedTapAction, rowUnits = keyDto.rowUnits?.coerceAtLeast(0), columnUnits = keyDto.columnUnits?.coerceAtLeast(0), rowSpanUnits = keyDto.rowSpanUnits?.coerceAtLeast(1), columnSpanUnits = keyDto.columnSpanUnits?.coerceAtLeast(1), specialKeyColorStyle = SpecialKeyColorStyle .fromDbValue(keyDto.specialKeyColorStyle) - .dbValue + .dbValue, + doubleTapAction = normalizedDoubleTapAction, + doubleTapPolicy = normalizedDoubleTapPolicy ) ImportableKeyWithFlicks( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutExportDtos.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutExportDtos.kt index 11d959a2d..74f23dbb6 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutExportDtos.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutExportDtos.kt @@ -94,6 +94,12 @@ data class KeyDefinitionDto( val iconValue: String? = null, @SerializedName("action") val action: String? = null, + @SerializedName("doubleTapEnabled") + val doubleTapEnabled: Boolean? = null, + @SerializedName("doubleTapAction") + val doubleTapAction: String? = null, + @SerializedName("doubleTapPolicy") + val doubleTapPolicy: String? = null, @SerializedName("rowUnits") val rowUnits: Int? = null, @SerializedName("columnUnits") diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonExporter.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonExporter.kt index 22c9846fa..9966785d7 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonExporter.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonExporter.kt @@ -2,6 +2,8 @@ package com.kazumaproject.markdownhelperkeyboard.custom_keyboard.import_export import com.google.gson.Gson import com.google.gson.GsonBuilder +import com.kazumaproject.custom_keyboard.data.KeyActionMapper +import com.kazumaproject.custom_keyboard.data.automaticDoubleTapPolicy import com.kazumaproject.markdownhelperkeyboard.custom_keyboard.data.FullKeyboardLayout import com.kazumaproject.markdownhelperkeyboard.custom_keyboard.data.KeyWithFlicks @@ -84,6 +86,15 @@ private fun exportLayoutName(rawName: String?, layoutId: Long): String { } internal fun KeyWithFlicks.toExportDto(): KeyWithFlicksExportDto { + val doubleTapAction = this.key.doubleTapAction.takeIf { this.key.isSpecialKey } + val doubleTapPolicy = doubleTapAction + ?.let(KeyActionMapper::toKeyAction) + ?.let { action -> + automaticDoubleTapPolicy( + normalAction = KeyActionMapper.toKeyAction(this.key.action), + doubleTapAction = action + ).serializedName + } return KeyWithFlicksExportDto( key = KeyDefinitionDto( keyId = this.key.keyId, @@ -100,6 +111,9 @@ internal fun KeyWithFlicks.toExportDto(): KeyWithFlicksExportDto { iconType = this.key.iconType, iconValue = this.key.iconValue, action = this.key.action, + doubleTapEnabled = doubleTapAction != null, + doubleTapAction = doubleTapAction, + doubleTapPolicy = doubleTapPolicy, rowUnits = this.key.rowUnits, columnUnits = this.key.columnUnits, rowSpanUnits = this.key.rowSpanUnits, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporter.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporter.kt index d2a6cd5f3..1243fe216 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporter.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporter.kt @@ -24,7 +24,7 @@ object KeyboardLayoutJsonImporter { /** * 想定する最新の schemaVersion。 */ - const val LATEST_SCHEMA_VERSION: Int = 2 + const val LATEST_SCHEMA_VERSION: Int = 3 internal val gson: Gson by lazy { GsonBuilder() diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/ui/KeyEditorFragment.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/ui/KeyEditorFragment.kt index 87e28300f..e1964e235 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/ui/KeyEditorFragment.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/ui/KeyEditorFragment.kt @@ -32,6 +32,7 @@ import androidx.lifecycle.lifecycleScope import androidx.navigation.fragment.findNavController import androidx.recyclerview.widget.LinearLayoutManager import com.kazumaproject.custom_keyboard.data.CircularFlickDirection +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding import com.kazumaproject.custom_keyboard.data.FlickAction import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.KeyAction @@ -44,6 +45,7 @@ import com.kazumaproject.custom_keyboard.data.KeyIconType import com.kazumaproject.custom_keyboard.data.KeyItem import com.kazumaproject.custom_keyboard.data.KeyType import com.kazumaproject.custom_keyboard.data.SpecialKeyColorStyle +import com.kazumaproject.custom_keyboard.data.automaticDoubleTapPolicy import com.kazumaproject.custom_keyboard.data.compatibleColumnSpan import com.kazumaproject.custom_keyboard.data.compatibleRowSpan import com.kazumaproject.custom_keyboard.data.toCircularFlickMap @@ -118,6 +120,8 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { private lateinit var keyActionAdapter: ArrayAdapter private lateinit var customKeyboardTargetAdapter: ArrayAdapter + private lateinit var doubleTapActionAdapter: ArrayAdapter + private lateinit var doubleTapTargetAdapter: ArrayAdapter private lateinit var circularFlickAdapter: CircularFlickMappingAdapter private lateinit var circularMapAdapter: ArrayAdapter @@ -127,6 +131,7 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { private var customKeyboardTargets: List = emptyList() private var customKeyboardTargetOptions: List = emptyList() private var selectedTargetCustomKeyboardStableId: String? = null + private var selectedDoubleTapTargetStableId: String? = null private var selectedIconRef: KeyIconRef? = null private var originalIconRef: KeyIconRef? = null private val pendingUserIconPaths = mutableSetOf() @@ -188,6 +193,17 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { ) binding.keyActionSpinner.setAdapter(keyActionAdapter) + doubleTapActionAdapter = ArrayAdapter( + requireContext(), + android.R.layout.simple_spinner_dropdown_item, + listOf(getString(R.string.double_tap_disabled)) + actionDisplayNames + ) + binding.doubleTapActionSpinner.setAdapter(doubleTapActionAdapter) + binding.doubleTapActionSpinner.setText( + getString(R.string.double_tap_disabled), + false + ) + // 特殊フリック用アクションスピナー（セル選択後に表示） val specialActionNames = mutableListOf("").apply { addAll(specialFlickDisplayActions.map { it.displayName }) @@ -205,6 +221,12 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { mutableListOf() ) binding.customKeyboardTargetSpinner.setAdapter(customKeyboardTargetAdapter) + doubleTapTargetAdapter = ArrayAdapter( + requireContext(), + android.R.layout.simple_spinner_dropdown_item, + mutableListOf() + ) + binding.doubleTapTargetSpinner.setAdapter(doubleTapTargetAdapter) circularFlickAdapter = CircularFlickMappingAdapter { updated -> val currentMap = currentCircularFlickMaps.getOrNull(currentCircularMapIndex) @@ -343,6 +365,7 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { handleInputStyleUi() } + updateDoubleTapControlsVisibility() updateDoneButtonState() } @@ -425,6 +448,22 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { refreshIconPreview() updateDoneButtonState() } + binding.keyActionSpinner.setOnItemClickListener { _, _, position, _ -> + if ( + displayActions.getOrNull(position)?.action == KeyAction.ShiftKey && + selectedDoubleTapDisplayAction() == null + ) { + displayActionForAction(KeyAction.CapLockKey)?.let { capLock -> + binding.doubleTapActionSpinner.setText(capLock.displayName, false) + updateDoubleTapControlsVisibility() + } + } + } + + binding.doubleTapActionSpinner.doAfterTextChanged { + updateDoubleTapControlsVisibility() + updateDoneButtonState() + } binding.customKeyboardTargetSpinner.setOnItemClickListener { _, _, position, _ -> val option = customKeyboardTargetOptions.getOrNull(position) @@ -451,6 +490,14 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { updateDoneButtonState() } + binding.doubleTapTargetSpinner.setOnItemClickListener { _, _, position, _ -> + selectedDoubleTapTargetStableId = customKeyboardTargetOptions + .getOrNull(position) + ?.takeIf { it.isValid } + ?.stableId + updateDoneButtonState() + } + binding.buttonChooseBuiltinIcon.setOnClickListener { showBuiltInIconPicker() } @@ -860,6 +907,11 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { return displayActions.firstOrNull { it.displayName == selectedText } } + private fun selectedDoubleTapDisplayAction(): DisplayActionUi? { + val selectedText = binding.doubleTapActionSpinner.text.toString() + return displayActions.firstOrNull { it.displayName == selectedText } + } + private fun isMoveToCustomKeyboardSelected(): Boolean { return selectedSingleDisplayAction()?.action is KeyAction.MoveToCustomKeyboard } @@ -911,6 +963,9 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { customKeyboardTargetAdapter.clear() customKeyboardTargetAdapter.addAll(customKeyboardTargetOptions.map { it.label }) customKeyboardTargetAdapter.notifyDataSetChanged() + doubleTapTargetAdapter.clear() + doubleTapTargetAdapter.addAll(customKeyboardTargetOptions.map { it.label }) + doubleTapTargetAdapter.notifyDataSetChanged() } private fun selectTargetCustomKeyboard(stableId: String?) { @@ -933,6 +988,41 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { binding.customKeyboardTargetSpinner.setText(option?.label.orEmpty(), false) } + private fun selectDoubleTapTargetCustomKeyboard(stableId: String?) { + val id = stableId.orEmpty() + if (id.isBlank()) { + selectedDoubleTapTargetStableId = null + binding.doubleTapTargetSpinner.setText("", false) + return + } + + var option = customKeyboardTargetOptions.firstOrNull { it.stableId == id } + if (option == null) { + refreshCustomKeyboardTargetOptions(deletedStableId = id) + option = customKeyboardTargetOptions.firstOrNull { it.stableId == id } + } + + selectedDoubleTapTargetStableId = option + ?.takeIf { it.isValid } + ?.stableId + binding.doubleTapTargetSpinner.setText(option?.label.orEmpty(), false) + } + + private fun updateDoubleTapControlsVisibility() { + val supportsDoubleTap = + binding.keyTypeChipGroup.checkedChipId == R.id.chip_special + binding.doubleTapActionLayout.isVisible = supportsDoubleTap + val selected = selectedDoubleTapDisplayAction() + val isMoveToCustomKeyboard = selected?.action is KeyAction.MoveToCustomKeyboard + binding.doubleTapTargetLayout.isVisible = supportsDoubleTap && isMoveToCustomKeyboard + if (isMoveToCustomKeyboard && selectedDoubleTapTargetStableId.isNullOrBlank()) { + customKeyboardTargetOptions.firstOrNull { it.isValid }?.let { + selectedDoubleTapTargetStableId = it.stableId + binding.doubleTapTargetSpinner.setText(it.label, false) + } + } + } + private fun updateCustomKeyboardTargetVisibility() { val isSpecialSingleMoveTo = binding.keyTypeChipGroup.checkedChipId == R.id.chip_special && @@ -1041,7 +1131,17 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { else -> false } - binding.buttonDone.isEnabled = isEnabled + val doubleTapAction = selectedDoubleTapDisplayAction() + ?.action + ?.takeIf { binding.keyTypeChipGroup.checkedChipId == R.id.chip_special } + val isDoubleTapValid = if (doubleTapAction is KeyAction.MoveToCustomKeyboard) { + selectedDoubleTapTargetStableId + ?.let { target -> customKeyboardTargets.any { it.stableId == target } } + ?: false + } else { + true + } + binding.buttonDone.isEnabled = isEnabled && isDoubleTapValid } private fun setupInitialState() { @@ -1074,6 +1174,18 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { val key = currentKeyData!! selectedIconRef = key.icon?.takeIf { it.isOverride() } originalIconRef = selectedIconRef + key.doubleTapBinding + ?.takeIf { key.isSpecialKey } + ?.let { doubleTap -> + val doubleTapAction = doubleTap.action + displayActionForAction(doubleTapAction)?.let { display -> + binding.doubleTapActionSpinner.setText(display.displayName, false) + } + if (doubleTapAction is KeyAction.MoveToCustomKeyboard) { + selectDoubleTapTargetCustomKeyboard(doubleTapAction.stableId) + } + } + updateDoubleTapControlsVisibility() isFlexibleSizeEditing = state.layout.usesFlexiblePlacement() && selectedKeyItem != null if (isFlexibleSizeEditing) { @@ -1839,6 +1951,40 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { } } + val selectedDoubleTapAction = selectedDoubleTapDisplayAction() + ?.action + ?.takeIf { isSpecial } + val resolvedDoubleTapAction = if ( + selectedDoubleTapAction is KeyAction.MoveToCustomKeyboard + ) { + val stableId = selectedDoubleTapTargetStableId + ?.takeIf { id -> customKeyboardTargets.any { it.stableId == id } } + ?: return + KeyAction.MoveToCustomKeyboard(stableId) + } else { + selectedDoubleTapAction + } + val newDoubleTapBinding = resolvedDoubleTapAction + ?.takeIf { isSpecial } + ?.let { + DoubleTapBinding( + action = it, + policy = automaticDoubleTapPolicy( + normalAction = newAction, + doubleTapAction = it + ) + ) + } + if (newDoubleTapBinding?.action == KeyAction.VoiceInput) { + val hasPermission = ContextCompat.checkSelfPermission( + requireContext(), + Manifest.permission.RECORD_AUDIO + ) == PackageManager.PERMISSION_GRANTED + if (!hasPermission) { + requestRecordAudioPermission.launch(Manifest.permission.RECORD_AUDIO) + } + } + val savedIconRef = selectedIconRef?.takeIf { isSpecial } val updatedKey = originalKey.copy( label = newLabel, @@ -1863,7 +2009,8 @@ class KeyEditorFragment : Fragment(R.layout.fragment_key_editor) { selectedSpecialKeyColorStyle() } else { SpecialKeyColorStyle.SPECIAL - } + }, + doubleTapBinding = newDoubleTapBinding ) val updated = viewModel.updateKeyAndMappings( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/database/AppDatabase.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/database/AppDatabase.kt index b3712d5cf..676b67e64 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/database/AppDatabase.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/database/AppDatabase.kt @@ -80,7 +80,7 @@ import com.kazumaproject.markdownhelperkeyboard.zeroquery.custom.CustomZeroQuery SumireSpecialKeyPlacementOverrideEntity::class, CustomZeroQueryEntry::class, ], - version = 41, + version = 43, exportSchema = false ) @TypeConverters( @@ -1095,5 +1095,58 @@ abstract class AppDatabase : RoomDatabase() { ) } } + + val MIGRATION_41_42 = object : Migration(41, 42) { + override fun migrate(db: SupportSQLiteDatabase) { + db.execSQL( + "ALTER TABLE `key_definitions` ADD COLUMN `doubleTapAction` TEXT" + ) + db.execSQL( + "ALTER TABLE `key_definitions` ADD COLUMN `doubleTapPolicy` TEXT" + ) + db.execSQL( + """ + UPDATE `key_definitions` + SET `doubleTapAction` = 'CapLockKey', + `doubleTapPolicy` = 'PROMOTE' + WHERE `action` = 'ShiftKeyPressed' + """.trimIndent() + ) + } + } + + val MIGRATION_42_43 = object : Migration(42, 43) { + override fun migrate(db: SupportSQLiteDatabase) { + // Character keys must keep repeated taps as repeated text input. + db.execSQL( + """ + UPDATE `key_definitions` + SET `doubleTapAction` = NULL, + `doubleTapPolicy` = NULL + WHERE `isSpecialKey` = 0 + """.trimIndent() + ) + // Resolution policy is an implementation detail: only Shift promotes its first tap. + db.execSQL( + """ + UPDATE `key_definitions` + SET `doubleTapPolicy` = CASE + WHEN `action` = 'ShiftKeyPressed' + AND `doubleTapAction` = 'CapLockKey' THEN 'PROMOTE' + ELSE 'EXCLUSIVE' + END + WHERE `isSpecialKey` = 1 + AND `doubleTapAction` IS NOT NULL + """.trimIndent() + ) + db.execSQL( + """ + UPDATE `key_definitions` + SET `doubleTapPolicy` = NULL + WHERE `doubleTapAction` IS NULL + """.trimIndent() + ) + } + } } } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftState.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftState.kt new file mode 100644 index 000000000..7eb65743d --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftState.kt @@ -0,0 +1,36 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service + +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase + +internal enum class CustomKeyboardShiftState { + OFF, + ONE_SHOT, + LOCKED; + + val appliesUppercase: Boolean + get() = this != OFF + + val keyCharacterCase: KeyCharacterCase + get() = if (appliesUppercase) { + KeyCharacterCase.UPPERCASE + } else { + KeyCharacterCase.AS_DEFINED + } + + fun onShiftTap(): CustomKeyboardShiftState = when (this) { + OFF -> ONE_SHOT + ONE_SHOT, LOCKED -> OFF + } + + fun onCapsLockTap(): CustomKeyboardShiftState = when (this) { + LOCKED -> OFF + OFF, ONE_SHOT -> LOCKED + } + + fun consumeOneShot(): CustomKeyboardShiftState = + if (this == ONE_SHOT) OFF else this + + fun transformAsciiLetters(text: String): String { + return keyCharacterCase.transformAsciiLetters(text) + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 205bf4b86..8dc4ff992 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -148,6 +148,7 @@ import com.kazumaproject.core.domain.window.getScreenHeight import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.KeyAction import com.kazumaproject.custom_keyboard.data.KeyActionMapper +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase import com.kazumaproject.custom_keyboard.data.KeyboardInputMode import com.kazumaproject.custom_keyboard.data.KeyboardLayout import com.kazumaproject.custom_keyboard.data.KeyboardLayoutUsageMode @@ -7486,7 +7487,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, flickView.setKeyboard(applyDeleteKeyFlickPreferences(layout)) } - private fun syncCustomKeyboardToggleKeyIcons(flickView: FlickKeyboardView) { + private fun syncCustomKeyboardTogglePresentation(flickView: FlickKeyboardView) { + flickView.setKeyCharacterCase(customKeyboardShiftState.keyCharacterCase) flickView.updateKeyIconByAction( KeyAction.SwitchDirectMode, if (isCustomLayoutDirectMode) { @@ -7505,10 +7507,13 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) flickView.updateKeyIconByAction( KeyAction.ShiftKey, - if (isCustomLayoutShiftPressed) { - com.kazumaproject.core.R.drawable.shift_fill_24px - } else { - com.kazumaproject.core.R.drawable.shift_24px + when (customKeyboardShiftState) { + CustomKeyboardShiftState.OFF -> + com.kazumaproject.core.R.drawable.shift_24px + CustomKeyboardShiftState.ONE_SHOT -> + com.kazumaproject.core.R.drawable.shift_fill_24px + CustomKeyboardShiftState.LOCKED -> + com.kazumaproject.core.R.drawable.caps_lock } ) flickView.updateKeyIconByAction( @@ -7521,13 +7526,13 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) } - private fun syncCustomKeyboardToggleKeyIconsOnAvailableSurfaces() { + private fun syncCustomKeyboardTogglePresentationOnAvailableSurfaces() { getNormalKeyboardSurface() ?.customLayout - ?.let(::syncCustomKeyboardToggleKeyIcons) + ?.let(::syncCustomKeyboardTogglePresentation) getFloatingKeyboardSurface() ?.customLayout - ?.let(::syncCustomKeyboardToggleKeyIcons) + ?.let(::syncCustomKeyboardTogglePresentation) } private fun applyCurrentFlickGuidePreference(flickView: FlickKeyboardView) { @@ -7550,6 +7555,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private fun setSumireLayoutTo(flickView: FlickKeyboardView) { val layoutType = sumireInputKeyLayoutType ?: "toggle" + flickView.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) applyCurrentFlickGuidePreference(flickView) flickView.setSumireSpecialKeyActionResolver( resolver = SumireSpecialKeyActionResolver(sumireSpecialKeyActionOverrides)::resolve, @@ -7560,6 +7566,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } private fun setNumberLayoutTo(flickView: FlickKeyboardView) { + flickView.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) applyCurrentFlickGuidePreference(flickView) val numberCustomLayout = numberUsageCustomKeyboardLayoutOrNull() if (numberCustomLayout != null) { @@ -7656,14 +7663,13 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, stableId = expectedStableId, defaultValue = finalLayout.isDirectMode ) - isCustomLayoutShiftPressed = false - isCustomLayoutCapLock = false + customKeyboardShiftState = CustomKeyboardShiftState.OFF withContext(Dispatchers.Main) { if (!isCurrentCustomKeyboardSelection(layoutId = id, stableId = expectedStableId)) { return@withContext } setKeyboardWithDeleteKeyFlickPreferences(flickView, finalLayout) - syncCustomKeyboardToggleKeyIcons(flickView) + syncCustomKeyboardTogglePresentation(flickView) refreshBaselineInputBehaviorForCurrentKeyboard("custom layout input mode loaded") } } @@ -10574,8 +10580,11 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private var isCustomLayoutRomajiMode = false private var isCustomLayoutDirectMode = false - private var isCustomLayoutShiftPressed = false - private var isCustomLayoutCapLock = false + private var customKeyboardShiftState = CustomKeyboardShiftState.OFF + private val isCustomLayoutShiftPressed: Boolean + get() = customKeyboardShiftState == CustomKeyboardShiftState.ONE_SHOT + private val isCustomLayoutCapLock: Boolean + get() = customKeyboardShiftState == CustomKeyboardShiftState.LOCKED private fun customKeyboardInputModePersistenceKey(layoutId: Long, stableId: String): String { return stableId.takeIf { it.isNotBlank() } ?: layoutId.toString() @@ -10795,15 +10804,14 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, stableId = expectedStableId, defaultValue = finalLayout.isDirectMode ) - isCustomLayoutShiftPressed = false - isCustomLayoutCapLock = false + customKeyboardShiftState = CustomKeyboardShiftState.OFF withContext(Dispatchers.Main) { if (!isCurrentCustomKeyboardSelection(layoutId = id, stableId = expectedStableId)) { Timber.d("renderCustomKeyboardLayout: skip stale render id=$id stableId=$expectedStableId") return@withContext } setCustomLayoutOnAvailableSurfaces(finalLayout) - syncCustomKeyboardToggleKeyIconsOnAvailableSurfaces() + syncCustomKeyboardTogglePresentationOnAvailableSurfaces() refreshBaselineInputBehaviorForCurrentKeyboard("custom layout input mode loaded") } } @@ -11715,15 +11723,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } KeyAction.ShiftKey -> { - isCustomLayoutShiftPressed = !isCustomLayoutShiftPressed - - Handler(mainLooper).post { - getActiveKeyboardSurface()?.customLayout?.updateKeyIconByAction( - KeyAction.ShiftKey, - if (isCustomLayoutShiftPressed) com.kazumaproject.core.R.drawable.shift_fill_24px - else com.kazumaproject.core.R.drawable.shift_24px - ) - } + handleCustomKeyboardShiftTap() } KeyAction.MoveCustomKeyboardTab -> { @@ -11858,15 +11858,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } KeyAction.CapLockKey -> { - isCustomLayoutCapLock = !isCustomLayoutCapLock - - Handler(mainLooper).post { - getActiveKeyboardSurface()?.customLayout?.updateKeyIconByAction( - KeyAction.CapLockKey, - if (isCustomLayoutCapLock) com.kazumaproject.core.R.drawable.caps_lock - else com.kazumaproject.core.R.drawable.caps_lock_outline - ) - } + handleCustomKeyboardCapsLockTap() } KeyAction.ForceHalfWidthSpace -> { @@ -11901,18 +11893,14 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, if (text.isEmpty()) return val shiftedText = applyCustomLayoutShiftAndCapLock(text) if (dispatchDirectTextIfNeeded(shiftedText)) { - if (isCustomLayoutShiftPressed) { - isCustomLayoutShiftPressed = false - } + consumeCustomKeyboardOneShotShift() return } if (isCustomLayoutDirectMode) { finishComposingText() setComposingText("", 0) commitText(shiftedText, 1) - if (isCustomLayoutShiftPressed) { - isCustomLayoutShiftPressed = false - } + consumeCustomKeyboardOneShotShift() return } if (text.length == 1) { @@ -11964,20 +11952,16 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) } - if (isCustomLayoutShiftPressed) { - isCustomLayoutShiftPressed = false - } - } else { if (isCustomKeyboardTwoWordsOutputEnable == true) { finishComposingText() setComposingText("", 0) - commitText(text, 1) + commitText(shiftedText, 1) } else { if (isCustomLayoutRomajiMode) { val insertString = inputString.value val sb = StringBuilder() - sb.append(insertString).append(text) + sb.append(insertString).append(shiftedText) romajiConverter?.let { converter -> if (isDefaultRomajiHenkanMap) { _inputString.update { @@ -11998,11 +11982,12 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } else { val insertString = inputString.value val sb = StringBuilder() - sb.append(insertString).append(text) + sb.append(insertString).append(shiftedText) _inputString.update { sb.toString() } } } } + consumeCustomKeyboardOneShotShift() } TenKeyQWERTYMode.Sumire -> { @@ -12285,15 +12270,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } KeyAction.ShiftKey -> { - isCustomLayoutShiftPressed = !isCustomLayoutShiftPressed - - Handler(mainLooper).post { - getActiveKeyboardSurface()?.customLayout?.updateKeyIconByAction( - KeyAction.ShiftKey, - if (isCustomLayoutShiftPressed) com.kazumaproject.core.R.drawable.shift_fill_24px - else com.kazumaproject.core.R.drawable.shift_24px - ) - } + handleCustomKeyboardShiftTap() } KeyAction.SwitchDirectMode -> { @@ -12313,15 +12290,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } KeyAction.CapLockKey -> { - isCustomLayoutCapLock = !isCustomLayoutCapLock - - Handler(mainLooper).post { - getActiveKeyboardSurface()?.customLayout?.updateKeyIconByAction( - KeyAction.CapLockKey, - if (isCustomLayoutCapLock) com.kazumaproject.core.R.drawable.caps_lock - else com.kazumaproject.core.R.drawable.caps_lock_outline - ) - } + handleCustomKeyboardCapsLockTap() } KeyAction.SwitchRomajiEnglish -> { @@ -12435,25 +12404,25 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, }) } + private fun handleCustomKeyboardShiftTap() { + customKeyboardShiftState = customKeyboardShiftState.onShiftTap() + Handler(mainLooper).post(::syncCustomKeyboardTogglePresentationOnAvailableSurfaces) + } + + private fun handleCustomKeyboardCapsLockTap() { + customKeyboardShiftState = customKeyboardShiftState.onCapsLockTap() + Handler(mainLooper).post(::syncCustomKeyboardTogglePresentationOnAvailableSurfaces) + } + + private fun consumeCustomKeyboardOneShotShift() { + val consumedState = customKeyboardShiftState.consumeOneShot() + if (consumedState == customKeyboardShiftState) return + customKeyboardShiftState = consumedState + Handler(mainLooper).post(::syncCustomKeyboardTogglePresentationOnAvailableSurfaces) + } + private fun applyCustomLayoutShiftAndCapLock(text: String): String { - if (!isCustomLayoutShiftPressed && !isCustomLayoutCapLock) { - return text - } - if (isCustomLayoutShiftPressed) { - Handler(mainLooper).post { - getActiveKeyboardSurface()?.customLayout?.updateKeyIconByAction( - KeyAction.ShiftKey, - com.kazumaproject.core.R.drawable.shift_24px - ) - } - } - return text.map { char -> - if (char in 'a'..'z' || char in 'A'..'Z') { - char.uppercaseChar() - } else { - char - } - }.joinToString("") + return customKeyboardShiftState.transformAsciiLetters(text) } private fun handleOnKeyForSumire( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/AppModule.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/AppModule.kt index 87d948cbd..ac178958b 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/AppModule.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/AppModule.kt @@ -55,6 +55,8 @@ import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.M import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_38_39 import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_39_40 import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_40_41 +import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_41_42 +import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_42_43 import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_2_3 import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_3_4 import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase.Companion.MIGRATION_4_5 @@ -151,6 +153,8 @@ object AppModule { MIGRATION_38_39, MIGRATION_39_40, MIGRATION_40_41, + MIGRATION_41_42, + MIGRATION_42_43, ) .build() diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepository.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepository.kt index 7b74c0f14..cf6031c94 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepository.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepository.kt @@ -1,6 +1,7 @@ package com.kazumaproject.markdownhelperkeyboard.repository import com.kazumaproject.custom_keyboard.data.CircularFlickDirection +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding import com.kazumaproject.custom_keyboard.data.FlickAction import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.GridPlacement @@ -18,8 +19,10 @@ import com.kazumaproject.custom_keyboard.data.KeyboardLayoutItem import com.kazumaproject.custom_keyboard.data.KeyboardLayoutUsageMode import com.kazumaproject.custom_keyboard.data.SpecialKeyColorStyle import com.kazumaproject.custom_keyboard.data.SpacerItem +import com.kazumaproject.custom_keyboard.data.automaticDoubleTapPolicy import com.kazumaproject.custom_keyboard.data.copyWithItems import com.kazumaproject.custom_keyboard.data.copyWithKeys +import com.kazumaproject.custom_keyboard.data.effectiveDoubleTapBinding import com.kazumaproject.custom_keyboard.data.toCircularFlickDirection import com.kazumaproject.custom_keyboard.data.toKeyItem import com.kazumaproject.custom_keyboard.data.usesFlexiblePlacement @@ -599,7 +602,21 @@ class KeyboardRepository @Inject constructor( ) } - // 2) flick mapping + // 2) double-tap action + val doubleTapAction = KeyActionMapper.toKeyAction(key.doubleTapAction) + if (doubleTapAction is KeyAction.MoveToCustomKeyboard && + doubleTapAction.stableId == targetStableId + ) { + references += MoveToCustomKeyboardReference( + sourceLayoutId = sourceLayoutId, + sourceLayoutName = sourceLayoutName, + sourceKeyIdentifier = keyIdentifier, + sourceKeyLabel = keyLabel, + targetStableId = targetStableId + ) + } + + // 3) flick mapping for (flick in keyWithFlicks.flicks) { val act = flick.toFlickAction() if (act is FlickAction.Action) { @@ -901,6 +918,17 @@ class KeyboardRepository @Inject constructor( val iconRef = keyIconRefFromDb(dbKey.iconType, dbKey.iconValue) val specialKeyColorStyle = SpecialKeyColorStyle.fromDbValue(dbKey.specialKeyColorStyle) + val doubleTapBinding = KeyActionMapper.toKeyAction(dbKey.doubleTapAction) + ?.takeIf { dbKey.isSpecialKey } + ?.let { + DoubleTapBinding( + action = it, + policy = automaticDoubleTapPolicy( + normalAction = restoredAction, + doubleTapAction = it + ) + ) + } val keyData = if (restoredAction == null) { KeyData( label = dbKey.label, @@ -915,7 +943,8 @@ class KeyboardRepository @Inject constructor( icon = iconRef, keyId = dbKey.keyIdentifier, action = null, - specialKeyColorStyle = specialKeyColorStyle + specialKeyColorStyle = specialKeyColorStyle, + doubleTapBinding = doubleTapBinding ) } else { KeyData( @@ -931,7 +960,8 @@ class KeyboardRepository @Inject constructor( icon = iconRef, keyId = dbKey.keyIdentifier, action = restoredAction, - specialKeyColorStyle = specialKeyColorStyle + specialKeyColorStyle = specialKeyColorStyle, + doubleTapBinding = doubleTapBinding ) } val placement = GridPlacement( @@ -1121,6 +1151,7 @@ class KeyboardRepository @Inject constructor( val keyIdentifier = keyData.keyId ?: UUID.randomUUID().toString() val actionString: String? = KeyActionMapper.fromKeyAction(keyData.action) + val doubleTapBinding = keyData.effectiveDoubleTapBinding(keyData.action) val placement = itemByKeyId[keyIdentifier]?.placement ?: keyData.toKeyItem().placement keys.add( @@ -1145,7 +1176,11 @@ class KeyboardRepository @Inject constructor( columnUnits = placement.columnUnits, rowSpanUnits = placement.rowSpanUnits, columnSpanUnits = placement.columnSpanUnits, - specialKeyColorStyle = keyData.specialKeyColorStyle.dbValue + specialKeyColorStyle = keyData.specialKeyColorStyle.dbValue, + doubleTapAction = KeyActionMapper.fromKeyAction( + doubleTapBinding?.action + ), + doubleTapPolicy = doubleTapBinding?.policy?.serializedName ) ) diff --git a/app/src/main/res/layout/fragment_key_editor.xml b/app/src/main/res/layout/fragment_key_editor.xml index 4ef3cc55c..ce4dc186e 100644 --- a/app/src/main/res/layout/fragment_key_editor.xml +++ b/app/src/main/res/layout/fragment_key_editor.xml @@ -327,6 +327,42 @@ tools:text="My Keyboard" /> + + + + + + + + + + 特別なキー キーの表示ラベル キーのアクション + ダブルタップのアクション + なし フリック設定 タップ 左フリック diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index dc90f03c6..1f0d3150a 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -710,6 +710,8 @@ Special Key Label for Key Display Action for Key + Double-tap action + None Flick Tap Flick Left diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/database/DoubleTapMigrationTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/database/DoubleTapMigrationTest.kt new file mode 100644 index 000000000..ad29c9f73 --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/database/DoubleTapMigrationTest.kt @@ -0,0 +1,133 @@ +package com.kazumaproject.markdownhelperkeyboard.custom_keyboard.database + +import android.content.Context +import androidx.sqlite.db.SupportSQLiteDatabase +import androidx.sqlite.db.SupportSQLiteOpenHelper +import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class DoubleTapMigrationTest { + @Test + fun migration41To42_addsColumnsAndConfiguresExistingShiftKeys() { + val context = ApplicationProvider.getApplicationContext() + val name = "double-tap-migration-${System.nanoTime()}.db" + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(name) + .callback(object : SupportSQLiteOpenHelper.Callback(1) { + override fun onCreate(db: SupportSQLiteDatabase) { + db.execSQL( + "CREATE TABLE key_definitions (keyId INTEGER PRIMARY KEY NOT NULL, action TEXT)" + ) + } + + override fun onUpgrade( + db: SupportSQLiteDatabase, + oldVersion: Int, + newVersion: Int + ) = Unit + }) + .build() + ) + try { + val db = helper.writableDatabase + db.execSQL("INSERT INTO key_definitions VALUES (1, 'ShiftKeyPressed')") + db.execSQL("INSERT INTO key_definitions VALUES (2, 'Delete')") + + AppDatabase.MIGRATION_41_42.migrate(db) + + db.query( + "SELECT doubleTapAction, doubleTapPolicy FROM key_definitions WHERE keyId = 1" + ).use { cursor -> + cursor.moveToFirst() + assertEquals("CapLockKey", cursor.getString(0)) + assertEquals("PROMOTE", cursor.getString(1)) + } + db.query( + "SELECT doubleTapAction, doubleTapPolicy FROM key_definitions WHERE keyId = 2" + ).use { cursor -> + cursor.moveToFirst() + assertNull(cursor.getString(0)) + assertNull(cursor.getString(1)) + } + } finally { + helper.close() + context.deleteDatabase(name) + } + } + + @Test + fun migration42To43_removesNormalKeyBindingsAndNormalizesSpecialKeyPolicies() { + val context = ApplicationProvider.getApplicationContext() + val name = "double-tap-capability-migration-${System.nanoTime()}.db" + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(name) + .callback(object : SupportSQLiteOpenHelper.Callback(1) { + override fun onCreate(db: SupportSQLiteDatabase) { + db.execSQL( + """ + CREATE TABLE key_definitions ( + keyId INTEGER PRIMARY KEY NOT NULL, + isSpecialKey INTEGER NOT NULL, + action TEXT, + doubleTapAction TEXT, + doubleTapPolicy TEXT + ) + """.trimIndent() + ) + } + + override fun onUpgrade( + db: SupportSQLiteDatabase, + oldVersion: Int, + newVersion: Int + ) = Unit + }) + .build() + ) + try { + val db = helper.writableDatabase + db.execSQL("INSERT INTO key_definitions VALUES (1, 0, 'Text:a', 'Copy', 'PROMOTE')") + db.execSQL( + "INSERT INTO key_definitions VALUES (2, 1, 'ShiftKeyPressed', 'CapLockKey', 'EXCLUSIVE')" + ) + db.execSQL("INSERT INTO key_definitions VALUES (3, 1, 'SelectAll', 'Copy', 'PROMOTE')") + db.execSQL("INSERT INTO key_definitions VALUES (4, 1, 'Delete', NULL, 'PROMOTE')") + + AppDatabase.MIGRATION_42_43.migrate(db) + + db.query( + "SELECT doubleTapAction, doubleTapPolicy FROM key_definitions ORDER BY keyId" + ).use { cursor -> + cursor.moveToNext() + assertNull(cursor.getString(0)) + assertNull(cursor.getString(1)) + + cursor.moveToNext() + assertEquals("CapLockKey", cursor.getString(0)) + assertEquals("PROMOTE", cursor.getString(1)) + + cursor.moveToNext() + assertEquals("Copy", cursor.getString(0)) + assertEquals("EXCLUSIVE", cursor.getString(1)) + + cursor.moveToNext() + assertNull(cursor.getString(0)) + assertNull(cursor.getString(1)) + } + } finally { + helper.close() + context.deleteDatabase(name) + } + } +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporterTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporterTest.kt index 86915ed55..a9b4dc2c7 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporterTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/custom_keyboard/import_export/KeyboardLayoutJsonImporterTest.kt @@ -14,6 +14,7 @@ import com.kazumaproject.markdownhelperkeyboard.custom_keyboard.data.SpacerDefin import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -254,12 +255,228 @@ class KeyboardLayoutJsonImporterTest { assertTrue("root must be object", root.isJsonObject) val obj = root.asJsonObject - assertEquals(2, obj["schemaVersion"].asInt) + assertEquals(3, obj["schemaVersion"].asInt) assertNotNull(obj["layouts"]) assertTrue("layouts must be array", obj["layouts"].isJsonArray) assertEquals(0, obj["layouts"].asJsonArray.size()) } + @Test + fun parse_legacyShift_addsPromoteCapsLockDoubleTapDefault() { + val json = """ + [ + { + "layout": { + "layoutId": 1, + "name": "Legacy Shift", + "columnCount": 1, + "rowCount": 1, + "stableId": "legacy-shift" + }, + "keysWithFlicks": [ + { + "key": { + "keyIdentifier": "shift", + "label": "", + "row": 0, + "column": 0, + "keyType": "NORMAL", + "isSpecialKey": true, + "action": "ShiftKeyPressed" + } + } + ] + } + ] + """.trimIndent() + + val key = KeyboardLayoutJsonImporter.parse(json) + .layoutsOrThrow() + .single() + .keysWithFlicks + .single() + .key + + assertEquals("CapLockKey", key.doubleTapAction) + assertEquals("PROMOTE", key.doubleTapPolicy) + } + + @Test + fun parse_schema3ShiftWithExplicitDisable_doesNotRestoreDefault() { + val json = """ + { + "schemaVersion": 3, + "layouts": [ + { + "layout": { + "layoutId": 1, + "name": "Disabled Shift", + "columnCount": 1, + "rowCount": 1, + "stableId": "disabled-shift" + }, + "keysWithFlicks": [ + { + "key": { + "keyIdentifier": "shift", + "label": "", + "row": 0, + "column": 0, + "keyType": "NORMAL", + "isSpecialKey": true, + "action": "ShiftKeyPressed", + "doubleTapEnabled": false + } + } + ] + } + ] + } + """.trimIndent() + + val key = KeyboardLayoutJsonImporter.parse(json) + .layoutsOrThrow() + .single() + .keysWithFlicks + .single() + .key + + assertEquals(null, key.doubleTapAction) + assertEquals(null, key.doubleTapPolicy) + } + + @Test + fun exportImport_roundTrip_preservesConfiguredDoubleTapShortcut() { + val fullLayout = FullKeyboardLayout( + layout = CustomKeyboardLayout( + layoutId = 1, + name = "Double Tap", + columnCount = 1, + rowCount = 1, + stableId = "double-tap" + ), + keysWithFlicks = listOf( + KeyWithFlicks( + key = KeyDefinition( + keyId = 1, + ownerLayoutId = 1, + label = "Select", + row = 0, + column = 0, + keyType = KeyType.NORMAL, + isSpecialKey = true, + keyIdentifier = "select", + action = "SelectAll", + doubleTapAction = "Copy", + doubleTapPolicy = "EXCLUSIVE" + ), + flicks = emptyList(), + circularFlicks = emptyList(), + twoStepFlicks = emptyList(), + longPressFlicks = emptyList(), + twoStepLongPressFlicks = emptyList() + ) + ) + ) + + val importedKey = KeyboardLayoutJsonImporter.parse( + KeyboardLayoutJsonExporter.toJson(listOf(fullLayout)) + ).layoutsOrThrow().single().keysWithFlicks.single().key + + assertEquals("Copy", importedKey.doubleTapAction) + assertEquals("EXCLUSIVE", importedKey.doubleTapPolicy) + } + + @Test + fun exportImport_dropsDoubleTapConfigurationFromNormalCharacterKey() { + val fullLayout = FullKeyboardLayout( + layout = CustomKeyboardLayout( + layoutId = 1, + name = "Normal Key", + columnCount = 1, + rowCount = 1, + stableId = "normal-key" + ), + keysWithFlicks = listOf( + KeyWithFlicks( + key = KeyDefinition( + keyId = 1, + ownerLayoutId = 1, + label = "a", + row = 0, + column = 0, + keyType = KeyType.NORMAL, + isSpecialKey = false, + keyIdentifier = "a", + action = "Text:a", + doubleTapAction = "Copy", + doubleTapPolicy = "PROMOTE" + ), + flicks = emptyList(), + circularFlicks = emptyList(), + twoStepFlicks = emptyList(), + longPressFlicks = emptyList(), + twoStepLongPressFlicks = emptyList() + ) + ) + ) + + val exportedJson = KeyboardLayoutJsonExporter.toJson(listOf(fullLayout)) + val exportedKey = JsonParser.parseString(exportedJson) + .asJsonObject["layouts"].asJsonArray[0] + .asJsonObject["keysWithFlicks"].asJsonArray[0] + .asJsonObject["key"].asJsonObject + val importedKey = KeyboardLayoutJsonImporter.parse(exportedJson) + .layoutsOrThrow().single().keysWithFlicks.single().key + + assertFalse(exportedKey["doubleTapEnabled"].asBoolean) + assertTrue(exportedKey["doubleTapAction"].isJsonNull) + assertTrue(exportedKey["doubleTapPolicy"].isJsonNull) + assertNull(importedKey.doubleTapAction) + assertNull(importedKey.doubleTapPolicy) + } + + @Test + fun import_nonShiftSpecialKeyForcesExclusivePolicy() { + val json = """ + { + "schemaVersion": 3, + "layouts": [ + { + "layout": { + "name": "Special Key", + "columnCount": 1, + "rowCount": 1, + "stableId": "special-key" + }, + "keysWithFlicks": [ + { + "key": { + "keyIdentifier": "select", + "label": "Select", + "row": 0, + "column": 0, + "keyType": "NORMAL", + "isSpecialKey": true, + "action": "SelectAll", + "doubleTapEnabled": true, + "doubleTapAction": "Copy", + "doubleTapPolicy": "PROMOTE" + } + } + ] + } + ] + } + """.trimIndent() + + val key = KeyboardLayoutJsonImporter.parse(json) + .layoutsOrThrow().single().keysWithFlicks.single().key + + assertEquals("Copy", key.doubleTapAction) + assertEquals("EXCLUSIVE", key.doubleTapPolicy) + } + @Test fun exporter_withBlankLayoutName_writesFallbackName() { val exported = KeyboardLayoutJsonExporter.toJson( diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftStateTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftStateTest.kt new file mode 100644 index 000000000..bfac7651a --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/CustomKeyboardShiftStateTest.kt @@ -0,0 +1,41 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service + +import org.junit.Assert.assertEquals +import org.junit.Test + +class CustomKeyboardShiftStateTest { + @Test + fun doubleTapSequence_promotesOneShotToLocked_thenNextShiftTurnsOff() { + val afterFirstTap = CustomKeyboardShiftState.OFF.onShiftTap() + val afterDoubleTapAction = afterFirstTap.onCapsLockTap() + val afterNextShiftTap = afterDoubleTapAction.onShiftTap() + + assertEquals(CustomKeyboardShiftState.ONE_SHOT, afterFirstTap) + assertEquals(CustomKeyboardShiftState.LOCKED, afterDoubleTapAction) + assertEquals(CustomKeyboardShiftState.OFF, afterNextShiftTap) + } + + @Test + fun oneShot_isConsumed_butLockedIsRetained() { + assertEquals( + CustomKeyboardShiftState.OFF, + CustomKeyboardShiftState.ONE_SHOT.consumeOneShot() + ) + assertEquals( + CustomKeyboardShiftState.LOCKED, + CustomKeyboardShiftState.LOCKED.consumeOneShot() + ) + } + + @Test + fun uppercaseTransformation_onlyChangesAsciiLetters() { + assertEquals( + "ABC-あ1", + CustomKeyboardShiftState.LOCKED.transformAsciiLetters("aBc-あ1") + ) + assertEquals( + "aBc-あ1", + CustomKeyboardShiftState.OFF.transformAsciiLetters("aBc-あ1") + ) + } +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryDeleteImpactTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryDeleteImpactTest.kt index 04ba7322a..e2b9377a1 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryDeleteImpactTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryDeleteImpactTest.kt @@ -161,6 +161,47 @@ class KeyboardRepositoryDeleteImpactTest { assertEquals("key-source-circ", impact.references.single().sourceKeyIdentifier) } + @Test + fun getDeleteImpactForLayout_referencedByDoubleTapAction_isDetected() = runBlocking { + val targetStableId = "target-via-double-tap" + val target = layout(layoutId = 15, stableId = targetStableId, name = "Target") + val source = layout(layoutId = 25, stableId = "source-stable", name = "Source") + val sourceFull = FullKeyboardLayout( + layout = source, + keysWithFlicks = listOf( + KeyWithFlicks( + key = KeyDefinition( + keyId = 250, + ownerLayoutId = 25, + label = "→", + row = 0, + column = 0, + keyType = KeyType.NORMAL, + isSpecialKey = true, + keyIdentifier = "key-source-double", + action = "MoveCustomKeyboardTab", + doubleTapAction = "MoveToCustomKeyboard:$targetStableId", + doubleTapPolicy = "EXCLUSIVE" + ), + flicks = emptyList(), + circularFlicks = emptyList(), + twoStepFlicks = emptyList(), + longPressFlicks = emptyList(), + twoStepLongPressFlicks = emptyList() + ) + ), + spacers = emptyList() + ) + val targetFull = FullKeyboardLayout(target, emptyList(), emptyList()) + whenever(dao.getFullLayoutOneShot(15L)).thenReturn(targetFull) + whenever(dao.getAllFullLayoutsOneShot()).thenReturn(listOf(targetFull, sourceFull)) + + val impact = repository.getDeleteImpactForLayout(15L) + + assertTrue(impact.hasReferences) + assertEquals("key-source-double", impact.references.single().sourceKeyIdentifier) + } + @Test fun getDeleteImpactForLayout_noReferences_returnsEmpty() = runBlocking { val target = layout(layoutId = 13, stableId = "target-no-ref", name = "Target") diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryGridPlacementTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryGridPlacementTest.kt index a3d8bcde0..dedc988e2 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryGridPlacementTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/repository/KeyboardRepositoryGridPlacementTest.kt @@ -1,6 +1,8 @@ package com.kazumaproject.markdownhelperkeyboard.repository import com.kazumaproject.custom_keyboard.data.GridPlacement +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy import com.kazumaproject.custom_keyboard.data.KeyAction import com.kazumaproject.custom_keyboard.data.KeyData import com.kazumaproject.custom_keyboard.data.KeyItem @@ -115,6 +117,99 @@ class KeyboardRepositoryGridPlacementTest { assertEquals(2, restored.keys.single().colSpan) } + @Test + fun convertRoundTrip_preservesDoubleTapActionAndPolicy() { + val shift = KeyData( + label = "", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.ShiftKey, + keyType = KeyType.NORMAL, + isSpecialKey = true, + keyId = "shift", + doubleTapBinding = DoubleTapBinding( + action = KeyAction.CapLockKey, + policy = DoubleTapPolicy.PROMOTE + ) + ) + val layout = KeyboardLayout( + keys = listOf(shift), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + + val dbKey = convertToDbKeys(layout).single() + val restored = convertToUiLayout(listOf(dbKey)).keys.single() + + assertEquals("CapLockKey", dbKey.doubleTapAction) + assertEquals("PROMOTE", dbKey.doubleTapPolicy) + assertEquals(KeyAction.CapLockKey, restored.doubleTapBinding?.action) + assertEquals(DoubleTapPolicy.PROMOTE, restored.doubleTapBinding?.policy) + } + + @Test + fun convertRoundTrip_dropsDoubleTapBindingFromNormalCharacterKey() { + val characterKey = KeyData( + label = "a", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Text("a"), + keyType = KeyType.NORMAL, + isSpecialKey = false, + keyId = "a", + doubleTapBinding = DoubleTapBinding( + action = KeyAction.Copy, + policy = DoubleTapPolicy.PROMOTE + ) + ) + val layout = KeyboardLayout( + keys = listOf(characterKey), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + + val dbKey = convertToDbKeys(layout).single() + val restored = convertToUiLayout(listOf(dbKey)).keys.single() + + assertNull(dbKey.doubleTapAction) + assertNull(dbKey.doubleTapPolicy) + assertNull(restored.doubleTapBinding) + } + + @Test + fun convertRoundTrip_normalizesNonShiftShortcutToExclusivePolicy() { + val selectKey = KeyData( + label = "Select", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.SelectAll, + keyType = KeyType.NORMAL, + isSpecialKey = true, + keyId = "select", + doubleTapBinding = DoubleTapBinding( + action = KeyAction.Copy, + policy = DoubleTapPolicy.PROMOTE + ) + ) + val layout = KeyboardLayout( + keys = listOf(selectKey), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + + val dbKey = convertToDbKeys(layout).single() + val restored = convertToUiLayout(listOf(dbKey)).keys.single() + + assertEquals("EXCLUSIVE", dbKey.doubleTapPolicy) + assertEquals(DoubleTapPolicy.EXCLUSIVE, restored.doubleTapBinding?.policy) + } + @Test fun dbRoundTrip_preservesFlexibleOnePointFiveSpanAfterCrush() { val key = KeyData( diff --git a/custom_keyboard/src/androidTest/java/com/kazumaproject/custom_keyboard/DoubleTapFlickKeyboardInstrumentedTest.kt b/custom_keyboard/src/androidTest/java/com/kazumaproject/custom_keyboard/DoubleTapFlickKeyboardInstrumentedTest.kt new file mode 100644 index 000000000..3021023c9 --- /dev/null +++ b/custom_keyboard/src/androidTest/java/com/kazumaproject/custom_keyboard/DoubleTapFlickKeyboardInstrumentedTest.kt @@ -0,0 +1,248 @@ +package com.kazumaproject.custom_keyboard + +import android.os.SystemClock +import android.os.Debug +import android.view.ContextThemeWrapper +import android.view.MotionEvent +import android.view.View +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy +import com.kazumaproject.custom_keyboard.data.FlickDirection +import com.kazumaproject.custom_keyboard.data.KeyAction +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase +import com.kazumaproject.custom_keyboard.data.KeyData +import com.kazumaproject.custom_keyboard.data.KeyType +import com.kazumaproject.custom_keyboard.data.KeyboardLayout +import com.kazumaproject.custom_keyboard.view.FlickKeyboardView +import com.kazumaproject.custom_keyboard.view.AutoSizeButton +import com.kazumaproject.custom_keyboard.layout.KeyboardDefaultLayouts +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import java.util.concurrent.CopyOnWriteArrayList + +@RunWith(AndroidJUnit4::class) +class DoubleTapFlickKeyboardInstrumentedTest { + @Test + fun qwertyCharacterCaseRefresh_measuresRuntimeAndAllocationOnAndroidRuntime() { + val instrumentation = InstrumentationRegistry.getInstrumentation() + var elapsedNanos = 0L + var allocatedBytes = 0L + val iterations = 200 + + instrumentation.runOnMainSync { + val context = ContextThemeWrapper( + instrumentation.targetContext, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + val keyboard = FlickKeyboardView(context).apply { + setKeyboard(KeyboardDefaultLayouts.createQwertyTemplateLayout()) + val widthSpec = View.MeasureSpec.makeMeasureSpec(1080, View.MeasureSpec.EXACTLY) + val heightSpec = View.MeasureSpec.makeMeasureSpec(480, View.MeasureSpec.EXACTLY) + measure(widthSpec, heightSpec) + layout(0, 0, 1080, 480) + } + + repeat(10) { + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + keyboard.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) + } + val allocatedBefore = + Debug.getRuntimeStat("art.gc.bytes-allocated")?.toLongOrNull() ?: 0L + val startNanos = SystemClock.elapsedRealtimeNanos() + repeat(iterations) { index -> + keyboard.setKeyCharacterCase( + if (index % 2 == 0) { + KeyCharacterCase.UPPERCASE + } else { + KeyCharacterCase.AS_DEFINED + } + ) + } + elapsedNanos = SystemClock.elapsedRealtimeNanos() - startNanos + val allocatedAfter = + Debug.getRuntimeStat("art.gc.bytes-allocated")?.toLongOrNull() ?: allocatedBefore + allocatedBytes = allocatedAfter - allocatedBefore + assertEquals("q", (keyboard.getChildAt(0) as AutoSizeButton).text.toString()) + } + + val averageMicros = elapsedNanos / iterations / 1_000.0 + val averageAllocatedBytes = allocatedBytes / iterations + println( + "KEY_CHARACTER_CASE_PERF iterations=$iterations " + + "averageUs=$averageMicros allocatedBytesPerToggle=$averageAllocatedBytes" + ) + } + + @Test + fun qwertyKeyLabel_updatesWithoutRebuildingOnAndroidRuntime() { + val instrumentation = InstrumentationRegistry.getInstrumentation() + + instrumentation.runOnMainSync { + val context = ContextThemeWrapper( + instrumentation.targetContext, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + val keyboard = FlickKeyboardView(context).apply { + setKeyboard( + KeyboardLayout( + keys = listOf( + KeyData( + label = "q", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Text("q"), + keyId = "q", + keyType = KeyType.NORMAL + ) + ), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + ) + } + val key = keyboard.getChildAt(0) as AutoSizeButton + assertEquals("q", key.text.toString()) + + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + assertEquals("Q", key.text.toString()) + + keyboard.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) + assertEquals("q", key.text.toString()) + } + } + + @Test + fun shiftDoubleTap_dispatchesPromotedCapsLockActionOnAndroidRuntime() { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val actions = CopyOnWriteArrayList() + lateinit var keyboard: FlickKeyboardView + + instrumentation.runOnMainSync { + val context = ContextThemeWrapper( + instrumentation.targetContext, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + keyboard = FlickKeyboardView(context).apply { + setOnKeyboardActionListener(RecordingListener(actions)) + setKeyboard( + KeyboardLayout( + keys = listOf( + KeyData( + label = "", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.ShiftKey, + isSpecialKey = true, + keyId = "shift", + keyType = KeyType.NORMAL, + doubleTapBinding = DoubleTapBinding( + action = KeyAction.CapLockKey, + policy = DoubleTapPolicy.PROMOTE + ) + ) + ), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + ) + val widthSpec = View.MeasureSpec.makeMeasureSpec(240, View.MeasureSpec.EXACTLY) + val heightSpec = View.MeasureSpec.makeMeasureSpec(120, View.MeasureSpec.EXACTLY) + measure(widthSpec, heightSpec) + layout(0, 0, 240, 120) + } + tapCenter(keyboard) + } + + SystemClock.sleep(100) + instrumentation.runOnMainSync { + tapCenter(keyboard) + } + + assertEquals(listOf(KeyAction.ShiftKey, KeyAction.CapLockKey), actions) + } + + @Test + fun normalCharacterKey_dispatchesRepeatedTextEvenWithInvalidPersistedBinding() { + val instrumentation = InstrumentationRegistry.getInstrumentation() + val actions = CopyOnWriteArrayList() + + instrumentation.runOnMainSync { + val context = ContextThemeWrapper( + instrumentation.targetContext, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + val keyboard = FlickKeyboardView(context).apply { + setOnKeyboardActionListener(RecordingListener(actions)) + setKeyboard( + KeyboardLayout( + keys = listOf( + KeyData( + label = "a", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Text("a"), + isSpecialKey = false, + keyId = "a", + keyType = KeyType.NORMAL, + doubleTapBinding = DoubleTapBinding( + action = KeyAction.Copy, + policy = DoubleTapPolicy.PROMOTE + ) + ) + ), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + ) + val widthSpec = View.MeasureSpec.makeMeasureSpec(240, View.MeasureSpec.EXACTLY) + val heightSpec = View.MeasureSpec.makeMeasureSpec(120, View.MeasureSpec.EXACTLY) + measure(widthSpec, heightSpec) + layout(0, 0, 240, 120) + } + + tapCenter(keyboard) + assertEquals(listOf(KeyAction.Text("a")), actions) + tapCenter(keyboard) + } + + assertEquals(listOf(KeyAction.Text("a"), KeyAction.Text("a")), actions) + } + + private fun tapCenter(keyboard: FlickKeyboardView) { + val key = keyboard.getChildAt(0) + val x = key.left + key.width / 2f + val y = key.top + key.height / 2f + val downTime = SystemClock.uptimeMillis() + MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, x, y, 0).also { + keyboard.onTouchEvent(it) + it.recycle() + } + MotionEvent.obtain(downTime, downTime + 20, MotionEvent.ACTION_UP, x, y, 0).also { + keyboard.onTouchEvent(it) + it.recycle() + } + } + + private class RecordingListener( + private val actions: MutableList + ) : FlickKeyboardView.OnKeyboardActionListener { + override fun onPress(action: KeyAction) = Unit + override fun onAction(action: KeyAction, isFlick: Boolean) { + actions += action + } + override fun onActionLongPress(action: KeyAction) = Unit + override fun onActionUpAfterLongPress(action: KeyAction) = Unit + override fun onFlickDirectionChanged(direction: FlickDirection) = Unit + override fun onFlickActionLongPress(action: KeyAction) = Unit + override fun onFlickActionUpAfterLongPress(action: KeyAction, isFlick: Boolean) = Unit + } +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt index c827f9dbc..a1c4db603 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt @@ -156,6 +156,7 @@ class CrossFlickInputController( private var isLongPressTriggered = false private var popupColorTheme: FlickPopupColorTheme? = null + private var inputTextTransform: (String) -> String = { it } private var directionalPopupStyle = PopupViewStyle(100, 28f) private var crossPopupStyle = PopupViewStyle(100, 18f) private val displayActionsByClass by lazy { @@ -193,6 +194,13 @@ class CrossFlickInputController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + (gridPopup.contentView as? CrossFlickPopupView)?.setInputTextTransform(transform) + actionPopupViews.values.forEach { it.setInputTextTransform(transform) } + invalidateDirectionalPopupCache() + } + // コントローラを破棄する。ビューのデタッチやキーボードビューの再構築時に FlickKeyboardView から呼ばれる。 fun cancel() { activeGestureConfig = null @@ -527,6 +535,7 @@ class CrossFlickInputController( if (!isAnchorReady(anchor, windowAnchor)) return val popupView = CrossFlickPopupView(context).apply { + setInputTextTransform(inputTextTransform) applyPopupViewStyle(crossPopupStyle) val scale = crossPopupStyle.sizeScalePercent.coerceIn(50, 200) / 100f setCells( @@ -643,7 +652,7 @@ class CrossFlickInputController( if (text.isNullOrEmpty()) return@forEach val popupView = DirectionalKeyPopupView(context).apply { - this.text = text + this.text = inputTextTransform(text) applyPopupViewStyle(directionalPopupStyle) popupColorTheme?.let { setColors(it) } setFlickDirection(direction) @@ -754,6 +763,7 @@ class CrossFlickInputController( } val popupView = gridPopup.contentView as CrossFlickPopupView + popupView.setInputTextTransform(inputTextTransform) popupView.applyPopupViewStyle(crossPopupStyle) popupColorTheme?.let { popupView.setColors(it) } val scale = crossPopupStyle.sizeScalePercent.coerceIn(50, 200) / 100f diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt index d4404d74c..c4d104abb 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt @@ -130,6 +130,10 @@ class CustomAngleFlickController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + popupView.setInputTextTransform(transform) + } + private fun updateEffectiveRangesForMap( map: Map ) { diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcher.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcher.kt new file mode 100644 index 000000000..45456eab1 --- /dev/null +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcher.kt @@ -0,0 +1,126 @@ +package com.kazumaproject.custom_keyboard.controller + +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy +import com.kazumaproject.custom_keyboard.data.KeyAction + +fun interface CancellableTask { + fun cancel() +} + +fun interface TapTaskScheduler { + fun schedule(delayMillis: Long, task: () -> Unit): CancellableTask +} + +/** + * Resolves committed taps into normal or double-tap actions. + * + * This class is intentionally independent from MotionEvent. FlickKeyboardView already owns + * gesture recognition for normal, flick and long-press keys; feeding only committed taps here + * prevents a long press or a cancelled gesture from being mistaken for a double tap. + */ +class DoubleTapActionDispatcher( + private val timeoutMillis: Long, + private val minimumIntervalMillis: Long, + private val clockMillis: () -> Long, + private val scheduler: TapTaskScheduler, + private val dispatch: (KeyAction) -> Unit +) { + private data class PendingTap( + val keyIdentity: String, + val normalAction: KeyAction, + val binding: DoubleTapBinding, + val startedAtMillis: Long, + val generation: Long, + val scheduledTask: CancellableTask + ) + + private var pending: PendingTap? = null + private var generation: Long = 0 + + fun onCommittedTap( + keyIdentity: String, + normalAction: KeyAction, + binding: DoubleTapBinding? + ) { + val now = clockMillis() + val previous = pending + val interval = previous?.let { now - it.startedAtMillis } + if ( + previous != null && + previous.keyIdentity == keyIdentity && + interval != null && + interval in 0 until minimumIntervalMillis + ) { + return + } + val isDoubleTap = previous != null && + previous.keyIdentity == keyIdentity && + previous.binding == binding && + interval != null && + interval in minimumIntervalMillis..timeoutMillis + + if (isDoubleTap) { + clearPending() + dispatch(requireNotNull(binding).action) + return + } + + flushPending() + if (binding == null) { + dispatch(normalAction) + return + } + + if (binding.policy == DoubleTapPolicy.PROMOTE) { + dispatch(normalAction) + } + + val thisGeneration = ++generation + val task = scheduler.schedule(timeoutMillis) { + val active = pending + if (active?.generation != thisGeneration) return@schedule + pending = null + if (active.binding.policy == DoubleTapPolicy.EXCLUSIVE) { + dispatch(active.normalAction) + } + } + pending = PendingTap( + keyIdentity = keyIdentity, + normalAction = normalAction, + binding = binding, + startedAtMillis = now, + generation = thisGeneration, + scheduledTask = task + ) + } + + /** + * Ends double-tap recognition because a different committed gesture is about to run. + * An exclusive normal tap is delivered before the interrupting action. + */ + fun interrupt() { + flushPending() + } + + /** + * Drops all pending work. Use when a keyboard is detached or replaced. + */ + fun cancel() { + clearPending() + } + + private fun flushPending() { + val active = pending ?: return + clearPending() + if (active.binding.policy == DoubleTapPolicy.EXCLUSIVE) { + dispatch(active.normalAction) + } + } + + private fun clearPending() { + pending?.scheduledTask?.cancel() + pending = null + generation++ + } +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/FlickLongPressInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/FlickLongPressInputController.kt index 1a6459b0c..255430603 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/FlickLongPressInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/FlickLongPressInputController.kt @@ -65,6 +65,7 @@ class FlickLongPressInputController( private var popupView: TfbiFlickPopupView? = null private var popupWindow: PopupWindow? = null private var popupWindowAnchorProvider: (() -> View?)? = null + private var inputTextTransform: (String) -> String = { it } private var popupBackgroundColor: Int? = null private var popupHighlightedColor: Int? = null @@ -101,6 +102,11 @@ class FlickLongPressInputController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + popupView?.setInputTextTransform(transform) + } + fun attach( view: View, normalMap: Map, @@ -261,6 +267,7 @@ class FlickLongPressInputController( private fun showPopup(anchorView: View) { popupWindow?.dismiss() popupView = TfbiFlickPopupView(context).apply { + setInputTextTransform(inputTextTransform) if (popupBackgroundColor != null && popupHighlightedColor != null && popupTextColor != null) { setColors(popupBackgroundColor!!, popupHighlightedColor!!, popupTextColor!!) } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt index f748557c6..62f34da86 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt @@ -97,6 +97,10 @@ class StandardFlickInputController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + popupView.setInputTextTransform(transform) + } + @SuppressLint("ClickableViewAccessibility") fun attach( button: View, diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt index 884949b11..70db944c7 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt @@ -103,6 +103,7 @@ class TfbiHierarchicalFlickController( // ポップアップView関連 private var popupView: TfbiFlickPopupView? = null private var popupWindow: PopupWindow? = null + private var inputTextTransform: (String) -> String = { it } private var popupStyle = PopupViewStyle(100, 20f) private var popupWindowAnchorProvider: (() -> View?)? = null @@ -146,6 +147,11 @@ class TfbiHierarchicalFlickController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + popupView?.setInputTextTransform(transform) + } + /** * View と階層フリックのルートマップをアタッチします。 */ @@ -573,6 +579,7 @@ class TfbiHierarchicalFlickController( } popupView = TfbiFlickPopupView(context).apply { + setInputTextTransform(inputTextTransform) // ▼▼▼ 修正: 色設定があれば適用 ▼▼▼ if (popupBackgroundColor != null && popupHighlightedColor != null && popupTextColor != null) { setColors(popupBackgroundColor!!, popupHighlightedColor!!, popupTextColor!!) diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt index 4a9ed693e..452f03b8e 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt @@ -76,6 +76,7 @@ class TfbiInputController( private var popupView: TfbiFlickPopupView? = null private var popupWindow: PopupWindow? = null + private var inputTextTransform: (String) -> String = { it } private var popupWindowAnchorProvider: (() -> View?)? = null @@ -118,6 +119,11 @@ class TfbiInputController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + popupView?.setInputTextTransform(transform) + } + fun attach( view: View, provider: (TfbiFlickDirection, TfbiFlickDirection) -> String, @@ -311,6 +317,7 @@ class TfbiInputController( } popupView = TfbiFlickPopupView(context).apply { + setInputTextTransform(inputTextTransform) // ▼▼▼ 修正: 色設定があれば適用 ▼▼▼ if (popupBackgroundColor != null && popupHighlightedColor != null && popupTextColor != null) { setColors(popupBackgroundColor!!, popupHighlightedColor!!, popupTextColor!!) diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiStickyFlickController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiStickyFlickController.kt index c983aed5b..3eda5618b 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiStickyFlickController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiStickyFlickController.kt @@ -71,6 +71,7 @@ class TfbiStickyFlickController( private var popupView: TfbiFlickPopupView? = null private var popupWindow: PopupWindow? = null private var popupStyle = PopupViewStyle(100, 20f) + private var inputTextTransform: (String) -> String = { it } private var popupWindowAnchorProvider: (() -> View?)? = null @@ -96,6 +97,11 @@ class TfbiStickyFlickController( popupWindowAnchorProvider = provider } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + popupView?.setInputTextTransform(transform) + } + fun applyPopupViewStyle(style: PopupViewStyle) { popupStyle = PopupViewStyle( sizeScalePercent = style.sizeScalePercent.coerceIn(50, 200), @@ -275,6 +281,7 @@ class TfbiStickyFlickController( } popupView = TfbiFlickPopupView(context).apply { + setInputTextTransform(inputTextTransform) applyPopupViewStyle(popupStyle) setCharacters(tapCharacter, petalChars) highlightDirection(TfbiFlickDirection.TAP) diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCase.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCase.kt new file mode 100644 index 000000000..45edec52a --- /dev/null +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCase.kt @@ -0,0 +1,25 @@ +package com.kazumaproject.custom_keyboard.data + +/** + * Presentation case for text-producing custom keyboard keys. + * + * [AS_DEFINED] preserves the canonical label and input maps exactly as stored. [UPPERCASE] + * changes only ASCII letters so the visual representation stays consistent with the IME's + * Shift/CapsLock input semantics without introducing locale-dependent transformations. + */ +enum class KeyCharacterCase { + AS_DEFINED, + UPPERCASE; + + fun transformAsciiLetters(text: String): String { + if (this == AS_DEFINED || text.none { it in 'a'..'z' }) return text + val characters = text.toCharArray() + characters.indices.forEach { index -> + val char = characters[index] + if (char in 'a'..'z') { + characters[index] = char.uppercaseChar() + } + } + return characters.concatToString() + } +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyGestureBinding.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyGestureBinding.kt new file mode 100644 index 000000000..6dfd7ac82 --- /dev/null +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyGestureBinding.kt @@ -0,0 +1,60 @@ +package com.kazumaproject.custom_keyboard.data + +/** + * Internal strategy for resolving a special key's first tap. + * + * This remains serialized for backup compatibility, but it is deliberately not user-configurable: + * Shift uses [PROMOTE], while every other supported shortcut uses [EXCLUSIVE]. + */ +enum class DoubleTapPolicy(val serializedName: String) { + PROMOTE("PROMOTE"), + EXCLUSIVE("EXCLUSIVE"); + + companion object { + fun fromSerializedName(value: String?): DoubleTapPolicy? = + entries.firstOrNull { it.serializedName == value } + } +} + +data class DoubleTapBinding( + val action: KeyAction, + val policy: DoubleTapPolicy = DoubleTapPolicy.EXCLUSIVE +) + +/** + * Normal character keys must dispatch repeated taps as repeated input, never as a hidden gesture. + * Special keys are the only keys that may own a double-tap shortcut. + */ +val KeyData.supportsDoubleTap: Boolean + get() = isSpecialKey + +fun automaticDoubleTapPolicy( + normalAction: KeyAction?, + doubleTapAction: KeyAction +): DoubleTapPolicy = + if ( + normalAction == KeyAction.ShiftKey && + doubleTapAction == KeyAction.CapLockKey + ) { + DoubleTapPolicy.PROMOTE + } else { + DoubleTapPolicy.EXCLUSIVE + } + +/** + * Resolves persisted bindings through the current capability and policy rules. + * + * Runtime callers use the action that was actually committed so old or imported policy values + * cannot re-enable immediate execution for non-Shift shortcuts. + */ +fun KeyData.effectiveDoubleTapBinding(normalAction: KeyAction?): DoubleTapBinding? = + doubleTapBinding + ?.takeIf { supportsDoubleTap } + ?.let { binding -> + binding.copy( + policy = automaticDoubleTapPolicy( + normalAction = normalAction, + doubleTapAction = binding.action + ) + ) + } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyModels.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyModels.kt index 698408b9a..3f0b8666f 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyModels.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/data/KeyModels.kt @@ -135,7 +135,8 @@ data class KeyData( val isHiLighted: Boolean = false, val keyId: String? = null, val keyType: KeyType = if (isFlickable) KeyType.CIRCULAR_FLICK else KeyType.NORMAL, - val specialKeyColorStyle: SpecialKeyColorStyle = SpecialKeyColorStyle.SPECIAL + val specialKeyColorStyle: SpecialKeyColorStyle = SpecialKeyColorStyle.SPECIAL, + val doubleTapBinding: DoubleTapBinding? = null ) data class GridPlacement( diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/layout/KeyboardDefaultLayouts.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/layout/KeyboardDefaultLayouts.kt index 4f7924e85..73fe992c5 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/layout/KeyboardDefaultLayouts.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/layout/KeyboardDefaultLayouts.kt @@ -2,6 +2,8 @@ package com.kazumaproject.custom_keyboard.layout import com.kazumaproject.custom_keyboard.data.FlickAction import com.kazumaproject.custom_keyboard.data.FlickDirection +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy import com.kazumaproject.custom_keyboard.data.GridPlacement import com.kazumaproject.custom_keyboard.data.KeyAction import com.kazumaproject.custom_keyboard.data.KeyData @@ -4712,6 +4714,7 @@ object KeyboardDefaultLayouts { val label: String = "", val action: KeyAction, val drawableResId: Int? = null, + val doubleTapBinding: DoubleTapBinding? = null, override val columnSpanUnits: Int = 2 ) : TemplateItemSpec @@ -4785,7 +4788,8 @@ object KeyboardDefaultLayouts { keyType = KeyType.NORMAL, isSpecialKey = true, drawableResId = itemSpec.drawableResId, - keyId = keyId + keyId = keyId, + doubleTapBinding = itemSpec.doubleTapBinding ) items += KeyItem(id = keyId, keyData = keyData, placement = placement) keys += keyData @@ -4823,6 +4827,10 @@ object KeyboardDefaultLayouts { idSuffix = "shift", action = KeyAction.ShiftKey, drawableResId = com.kazumaproject.core.R.drawable.shift_24px, + doubleTapBinding = DoubleTapBinding( + action = KeyAction.CapLockKey, + policy = DoubleTapPolicy.PROMOTE + ), columnSpanUnits = 2 ) diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CrossFlickPopupView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CrossFlickPopupView.kt index 26a90e572..854d6cafb 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CrossFlickPopupView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CrossFlickPopupView.kt @@ -23,14 +23,16 @@ import com.google.android.material.R as materialR private data class PopupCellContent( val text: String?, val label: String?, - val drawableResId: Int? + val drawableResId: Int?, + val isInputText: Boolean ) private fun FlickAction.toPopupCellContent(): PopupCellContent = when (this) { is FlickAction.Input -> PopupCellContent( text = char.takeUnless { it.isEmpty() }, label = label?.takeUnless { it.isEmpty() }, - drawableResId = drawableResId + drawableResId = drawableResId, + isInputText = true ) is FlickAction.Action -> { @@ -43,7 +45,8 @@ private fun FlickAction.toPopupCellContent(): PopupCellContent = when (this) { PopupCellContent( text = text, label = label?.takeUnless { it.isEmpty() }, - drawableResId = drawableResId + drawableResId = drawableResId, + isInputText = action is KeyAction.Text ) } } @@ -71,7 +74,7 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { background = backgroundShape } - fun setContent(action: FlickAction) { + fun setContent(action: FlickAction, inputTextTransform: (String) -> String) { val content = action.toPopupCellContent() if (content.drawableResId != null) { imageView.setImageResource(content.drawableResId) @@ -80,7 +83,12 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { return } - val text = content.label ?: content.text + val resolvedText = content.label ?: content.text + val text = if (content.isInputText && resolvedText != null) { + inputTextTransform(resolvedText) + } else { + resolvedText + } if (text.isNullOrEmpty()) { textView.visibility = View.GONE imageView.visibility = View.GONE @@ -151,6 +159,7 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { private var popupTextSizeSp: Float = 18f private var popupBackgroundColor: Int? = null private var popupTextColor: Int? = null + private var inputTextTransform: (String) -> String = { it } init { addView(gridLayout, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)) @@ -170,6 +179,10 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { invalidate() } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + } + fun setCells(map: Map, keyWidth: Int, keyHeight: Int) { gridLayout.removeAllViews() cells.clear() @@ -188,7 +201,7 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { } val cell = CellView(context).apply { - setContent(action) + setContent(action, inputTextTransform) applyTextSize(popupTextSizeSp) val theme = colorTheme if (theme != null) { @@ -239,7 +252,7 @@ class CrossFlickPopupView(context: Context) : FrameLayout(context) { if (action != null) { val cell = CellView(context).apply { - setContent(action) + setContent(action, inputTextTransform) applyTextSize(popupTextSizeSp) val theme = colorTheme if (theme != null) { diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CustomAngleFlickPopupView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CustomAngleFlickPopupView.kt index cb8868446..4eebc9fbb 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CustomAngleFlickPopupView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/CustomAngleFlickPopupView.kt @@ -70,6 +70,7 @@ class CustomAngleFlickPopupView @JvmOverloads constructor( private var mapSwitchDirection: CircularFlickDirection? = null private var showMapSwitchLabel = false private var mapSwitchLabel: String? = null + private var inputTextTransform: (String) -> String = { it } // --- Size Properties --- // デフォルト値を設定（後で setUiSize で上書き可能） @@ -154,6 +155,11 @@ class CustomAngleFlickPopupView @JvmOverloads constructor( invalidate() } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + invalidate() + } + // --- Drawing Logic --- // (onMeasure, onSizeChanged, onDraw, updateShaders などは既存のままでOK) // ※ createPathForDirection 内で centerCircleRadius が使われますが、 @@ -213,14 +219,17 @@ class CustomAngleFlickPopupView @JvmOverloads constructor( private fun FlickAction?.toDisplayLabel(): String { return when (this) { - is FlickAction.Input -> label ?: char - is FlickAction.Action -> label ?: when (action) { - KeyAction.ShowEmojiKeyboard -> "絵" - KeyAction.SwitchToNextIme -> "IME" - KeyAction.SwitchToKanaLayout -> "かな" - KeyAction.SwitchToEnglishLayout -> "英" - KeyAction.SwitchToNumberLayout -> "数" - else -> "" + is FlickAction.Input -> inputTextTransform(label ?: char) + is FlickAction.Action -> when (val keyAction = action) { + is KeyAction.Text -> inputTextTransform(label ?: keyAction.text) + else -> label ?: when (keyAction) { + KeyAction.ShowEmojiKeyboard -> "絵" + KeyAction.SwitchToNextIme -> "IME" + KeyAction.SwitchToKanaLayout -> "かな" + KeyAction.SwitchToEnglishLayout -> "英" + KeyAction.SwitchToNumberLayout -> "数" + else -> "" + } } null -> "" diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt index 822518b96..146490d8e 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt @@ -46,8 +46,11 @@ import com.kazumaproject.core.domain.flick.RuntimeGestureSettings import com.kazumaproject.core.domain.flick.RuntimeGestureSettingsSource import com.kazumaproject.custom_keyboard.controller.CrossFlickInputController import com.kazumaproject.custom_keyboard.controller.CustomAngleFlickController +import com.kazumaproject.custom_keyboard.controller.CancellableTask +import com.kazumaproject.custom_keyboard.controller.DoubleTapActionDispatcher import com.kazumaproject.custom_keyboard.controller.FlickLongPressInputController import com.kazumaproject.custom_keyboard.controller.StandardFlickInputController +import com.kazumaproject.custom_keyboard.controller.TapTaskScheduler import com.kazumaproject.custom_keyboard.controller.TapLongPressInputController import com.kazumaproject.custom_keyboard.controller.TfbiHierarchicalFlickController import com.kazumaproject.custom_keyboard.controller.TfbiStickyFlickController @@ -57,6 +60,7 @@ import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.FlickPopupColorTheme import com.kazumaproject.custom_keyboard.data.GridPlacement import com.kazumaproject.custom_keyboard.data.KeyAction +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase import com.kazumaproject.custom_keyboard.data.KeyIconResolver import com.kazumaproject.custom_keyboard.data.KeyActionMapper import com.kazumaproject.custom_keyboard.data.KeyData @@ -73,11 +77,13 @@ import com.kazumaproject.custom_keyboard.data.buildSumireSpecialKeyDisplayAction import com.kazumaproject.custom_keyboard.data.buildEvenCircularRanges import com.kazumaproject.custom_keyboard.data.dispatchResolvedSumireSpecialKeyAction import com.kazumaproject.custom_keyboard.data.dispatchSumireSpecialKeyRuntimeAction +import com.kazumaproject.custom_keyboard.data.effectiveDoubleTapBinding import com.kazumaproject.custom_keyboard.data.refreshSumireSpecialKeyTap import com.kazumaproject.custom_keyboard.data.toCircularFlickKeyMaps import com.kazumaproject.custom_keyboard.data.toLegacyFlickDirection import com.kazumaproject.custom_keyboard.data.toSumireSpecialKeyDirectionOrNull import com.kazumaproject.custom_keyboard.layout.SegmentedBackgroundDrawable +import java.util.IdentityHashMap import kotlin.math.abs import kotlin.math.roundToInt @@ -100,6 +106,7 @@ class FlickKeyboardView @JvmOverloads constructor( private const val SPECIAL_KEY_BASE_TEXT_SIZE_SP = 16f private const val SPECIAL_ICON_TO_TEXT_RATIO = 1.6f private const val INPUT_MODE_SWITCH_ICON_SIZE_MULTIPLIER = 1.65f + private const val DOUBLE_TAP_MIN_INTERVAL_MILLIS = 40L } private var listener: OnKeyboardActionListener? = null @@ -111,6 +118,17 @@ class FlickKeyboardView @JvmOverloads constructor( private val stickyTfbiControllers = mutableListOf() private val hierarchicalTfbiControllers = mutableListOf() private val tapLongPressControllers = mutableListOf() + private val doubleTapActionDispatcher = DoubleTapActionDispatcher( + timeoutMillis = ViewConfiguration.getDoubleTapTimeout().toLong(), + minimumIntervalMillis = DOUBLE_TAP_MIN_INTERVAL_MILLIS, + clockMillis = SystemClock::uptimeMillis, + scheduler = TapTaskScheduler { delayMillis, task -> + val runnable = Runnable(task) + postDelayed(runnable, delayMillis) + CancellableTask { removeCallbacks(runnable) } + }, + dispatch = { action -> listener?.onAction(action, false) } + ) private var popupWindowAnchorProvider: (() -> View?)? = null @@ -153,8 +171,12 @@ class FlickKeyboardView @JvmOverloads constructor( private var liquidGlassEnable: Boolean = false + private val keyInfos = mutableListOf() private val dynamicKeyMap = mutableMapOf() + private val canonicalGuideLabels = + IdentityHashMap() private var currentLayout: KeyboardLayout? = null + private var keyCharacterCase: KeyCharacterCase = KeyCharacterCase.AS_DEFINED private var sumireSpecialKeyActionResolver: ((String, String, KeyData, SumireSpecialKeyDirection) -> ResolvedSumireSpecialKeyAction)? = null @@ -214,6 +236,17 @@ class FlickKeyboardView @JvmOverloads constructor( this.listener = listener } + /** + * Updates text-producing key labels without rebuilding the keyboard or changing canonical + * [KeyData]. This preserves active gesture recognizers, including the second Shift tap. + */ + fun setKeyCharacterCase(characterCase: KeyCharacterCase) { + if (keyCharacterCase == characterCase) return + keyCharacterCase = characterCase + keyInfos.forEach(::refreshKeyTextPresentation) + refreshPopupTextTransformers() + } + fun setSumireSpecialKeyActionResolver( resolver: ((String, String, KeyData, SumireSpecialKeyDirection) -> ResolvedSumireSpecialKeyAction)?, layoutType: String?, @@ -474,6 +507,7 @@ class FlickKeyboardView @JvmOverloads constructor( fun setKeyboard(layout: KeyboardLayout) { Log.d("FlickKeyboardView", "setKeyboard (Full Rebuild)") + doubleTapActionDispatcher.cancel() cancelTrackedTouchState() listener?.onLongPressActionCanceled(KeyAction.Cancel) @@ -503,7 +537,9 @@ class FlickKeyboardView @JvmOverloads constructor( tapLongPressControllers.forEach { it.cancel() } tapLongPressControllers.clear() + keyInfos.clear() dynamicKeyMap.clear() + canonicalGuideLabels.clear() currentLayout = layout columnCount = if (layout.items.isNotEmpty()) layout.columnUnitCount else layout.columnCount @@ -544,8 +580,10 @@ class FlickKeyboardView @JvmOverloads constructor( val controller = attachKeyBehavior(keyView, keyData) applyVisibleKeyFilter(keyView, keyData) + val info = KeyInfo(keyView, keyData, controller, index) + keyInfos += info keyData.keyId?.let { id -> - dynamicKeyMap[id] = KeyInfo(keyView, keyData, controller, index) + dynamicKeyMap[id] = info } addView(keyView) @@ -598,6 +636,7 @@ class FlickKeyboardView @JvmOverloads constructor( val needsNewView = (oldViewIsIcon && newViewIsText) || (oldViewIsText && newViewIsIcon) detachKeyBehavior(info.controller) + (oldView as? AutoSizeButton)?.let(canonicalGuideLabels::remove) val newView: View if (needsNewView) { @@ -632,6 +671,57 @@ class FlickKeyboardView @JvmOverloads constructor( } } + private fun refreshKeyTextPresentation(info: KeyInfo) { + val button = info.view as? AutoSizeButton ?: return + val guideLabels = canonicalGuideLabels[button] + updateKeyVisuals(button, info.keyData) + if (guideLabels != null) { + applyDisplayedGuideLabels(button, info.keyData, guideLabels) + } + } + + private fun refreshPopupTextTransformers() { + val transform = ::transformInputTextForDisplay + flickControllers.forEach { it.setInputTextTransform(transform) } + crossFlickControllers.forEach { it.setInputTextTransform(transform) } + standardFlickControllers.forEach { it.setInputTextTransform(transform) } + tfbiControllers.forEach { it.setInputTextTransform(transform) } + flickLongPressControllers.forEach { it.setInputTextTransform(transform) } + stickyTfbiControllers.forEach { it.setInputTextTransform(transform) } + hierarchicalTfbiControllers.forEach { it.setInputTextTransform(transform) } + } + + private fun transformInputTextForDisplay(text: String): String = + keyCharacterCase.transformAsciiLetters(text) + + private fun shouldTransformMainLabel(keyData: KeyData): Boolean { + if (keyData.action is KeyAction.Text) return true + return !keyData.isSpecialKey && keyData.keyType != KeyType.NORMAL + } + + private fun keyLabelForDisplay(keyData: KeyData): String { + val canonicalLabel = KeyIconResolver.resolvedLabelForRendering(keyData) + return if (shouldTransformMainLabel(keyData)) { + transformInputTextForDisplay(canonicalLabel) + } else { + canonicalLabel + } + } + + private fun transformGuideLabels( + labels: AutoSizeButton.FlickGuideLabels + ): AutoSizeButton.FlickGuideLabels = labels.copy( + tap = transformInputTextForDisplay(labels.tap), + up = transformInputTextForDisplay(labels.up), + upRight = transformInputTextForDisplay(labels.upRight), + right = transformInputTextForDisplay(labels.right), + downRight = transformInputTextForDisplay(labels.downRight), + down = transformInputTextForDisplay(labels.down), + downLeft = transformInputTextForDisplay(labels.downLeft), + left = transformInputTextForDisplay(labels.left), + upLeft = transformInputTextForDisplay(labels.upLeft) + ) + /** * 100 = デフォルト margin * 200 = margin 0 @@ -824,11 +914,12 @@ class FlickKeyboardView @JvmOverloads constructor( private fun applyButtonText(button: AutoSizeButton, keyData: KeyData) { val targetTextSizeSp = getKeyTextSizeSp(keyData) - val label = KeyIconResolver.resolvedLabelForRendering(keyData) + val label = keyLabelForDisplay(keyData) button.setDefaultTextSize(targetTextSizeSp) button.setFlickGuideTextSizeSp(flickGuideTextSizeSp) button.setFlickGuideLabels(null) + button.contentDescription = label if (label.contains("\n")) { button.maxLines = 2 @@ -1015,10 +1106,24 @@ class FlickKeyboardView @JvmOverloads constructor( (!singleCharacterLabel && !eligibleMultiCharacterLabel) || !labels.hasVisibleGuides() ) { + canonicalGuideLabels.remove(button) button.setFlickGuideLabels(null) return } + canonicalGuideLabels[button] = labels + applyDisplayedGuideLabels(button, keyData, labels) + } + + private fun applyDisplayedGuideLabels( + button: AutoSizeButton, + keyData: KeyData, + canonicalLabels: AutoSizeButton.FlickGuideLabels + ) { + val labels = transformGuideLabels(canonicalLabels) + val singleCharacterLabel = isSingleGuideCharacter(keyData.label) + val eligibleMultiCharacterLabel = + flickGuideAllowsMultiCharacterLabels && !keyData.isSpecialKey if (!singleCharacterLabel && eligibleMultiCharacterLabel && labels.tap.isNotEmpty()) { button.maxLines = 1 button.setLineSpacing(0f, 1f) @@ -1256,6 +1361,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) val secondaryColor = context.getColorFromAttr(R.attr.colorSecondaryContainer) val surfaceContainerLow = @@ -1336,7 +1442,8 @@ class FlickKeyboardView @JvmOverloads constructor( when (action) { is FlickAction.Input -> { if (action.char.isNotEmpty()) { - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(action.char), isFlick = direction != CircularFlickDirection.TAP ) @@ -1344,7 +1451,8 @@ class FlickKeyboardView @JvmOverloads constructor( } is FlickAction.Action -> { - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, action.action, isFlick = direction != CircularFlickDirection.TAP ) @@ -1430,6 +1538,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyleSet( popupViewStyleSet.directional, popupViewStyleSet.cross @@ -1489,7 +1598,8 @@ class FlickKeyboardView @JvmOverloads constructor( isFlick = isFlick, resolve = ::resolveSumireSpecialKeyOverride ) { dispatchedAction, actionIsFlick -> - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, dispatchedAction, actionIsFlick ) @@ -1498,6 +1608,7 @@ class FlickKeyboardView @JvmOverloads constructor( override fun onFlickLongPress(action: KeyAction) { if (action !is KeyAction.Text) { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onFlickActionLongPress(action) } } @@ -1507,6 +1618,7 @@ class FlickKeyboardView @JvmOverloads constructor( isFlick: Boolean ) { if (action !is KeyAction.Text) { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onFlickActionUpAfterLongPress( action, isFlick = isFlick ) @@ -1662,6 +1774,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyle(popupViewStyleSet.standard) this.listener = object : StandardFlickInputController.StandardFlickListener { @@ -1670,7 +1783,7 @@ class FlickKeyboardView @JvmOverloads constructor( } override fun onFlick(character: String) { - this@FlickKeyboardView.listener?.onAction( + dispatchNonTapAction( KeyAction.Text(character), isFlick = true ) @@ -1765,6 +1878,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyleSet( popupViewStyleSet.directional, popupViewStyleSet.cross @@ -1843,11 +1957,12 @@ class FlickKeyboardView @JvmOverloads constructor( } override fun onFlick(action: KeyAction, isFlick: Boolean) { - this@FlickKeyboardView.listener?.onAction(action, isFlick) + dispatchCommittedKeyAction(keyData, action, isFlick) } override fun onFlickLongPress(action: KeyAction) { if (action !is KeyAction.Text) { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onFlickActionLongPress(action) } } @@ -1857,6 +1972,7 @@ class FlickKeyboardView @JvmOverloads constructor( isFlick: Boolean ) { if (action !is KeyAction.Text) { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onFlickActionUpAfterLongPress( action, isFlick @@ -1936,6 +2052,7 @@ class FlickKeyboardView @JvmOverloads constructor( override fun onTap() { if ( dispatchResolvedSumireSpecialKeyAction( + keyData, resolveSumireSpecialKeyOverride( keyData, SumireSpecialKeyDirection.TAP @@ -1950,19 +2067,22 @@ class FlickKeyboardView @JvmOverloads constructor( "FlickKeyboardView KeyType.NORMAL", "currentAction: $currentAction" ) - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, currentAction, isFlick = false ) } override fun onLongPress() { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onActionLongPress( currentAction() ) } override fun onUpAfterLongPress() { + doubleTapActionDispatcher.interrupt() this@FlickKeyboardView.listener?.onActionUpAfterLongPress( currentAction() ) @@ -1998,6 +2118,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : TfbiInputController.TfbiListener { override fun onPress( @@ -2017,7 +2138,8 @@ class FlickKeyboardView @JvmOverloads constructor( "$character $first $second" ) if (character.isNotEmpty()) { - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(character), isFlick = !(first == TfbiFlickDirection.TAP && second == TfbiFlickDirection.TAP) ) @@ -2031,10 +2153,10 @@ class FlickKeyboardView @JvmOverloads constructor( val output = twoStepLongPressMap?.get(first)?.get(second).orEmpty() if (output.isEmpty()) return false - this@FlickKeyboardView.listener?.onAction( + dispatchNonTapAction( KeyAction.Text(output), isFlick = !(first == TfbiFlickDirection.TAP && - second == TfbiFlickDirection.TAP) + second == TfbiFlickDirection.TAP) ) return true } @@ -2092,6 +2214,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : FlickLongPressInputController.Listener { override fun onPress(character: String) { @@ -2099,7 +2222,8 @@ class FlickKeyboardView @JvmOverloads constructor( } override fun onCommit(character: String, isFlick: Boolean) { - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(character), isFlick = isFlick ) @@ -2141,6 +2265,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : TfbiStickyFlickController.TfbiListener { override fun onPress( @@ -2160,7 +2285,8 @@ class FlickKeyboardView @JvmOverloads constructor( "$character $first $second" ) if (character.isNotEmpty()) { - this@FlickKeyboardView.listener?.onAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(character), isFlick = !(first == TfbiFlickDirection.TAP && second == TfbiFlickDirection.TAP) ) @@ -2199,6 +2325,7 @@ class FlickKeyboardView @JvmOverloads constructor( gestureConfigSource = gestureSessionConfigSource ).apply { setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setInputTextTransform(::transformInputTextForDisplay) setModeSwitchAngleMargin(hierarchicalFlickModeSwitchAngleMargin) applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : TfbiHierarchicalFlickController.TfbiListener { @@ -2212,7 +2339,7 @@ class FlickKeyboardView @JvmOverloads constructor( "Char: $character" ) if (character.isNotEmpty()) { - this@FlickKeyboardView.listener?.onAction( + dispatchNonTapAction( KeyAction.Text(character), isFlick = true ) @@ -2290,12 +2417,35 @@ class FlickKeyboardView @JvmOverloads constructor( return resolver(layoutType, inputMode, keyData, direction) } + private fun dispatchCommittedKeyAction( + keyData: KeyData, + action: KeyAction, + isFlick: Boolean + ) { + if (isFlick) { + dispatchNonTapAction(action, isFlick = true) + return + } + doubleTapActionDispatcher.onCommittedTap( + keyIdentity = keyData.keyId + ?: "legacy:${keyData.row}:${keyData.column}:${keyData.keyType}", + normalAction = action, + binding = keyData.effectiveDoubleTapBinding(action) + ) + } + + private fun dispatchNonTapAction(action: KeyAction, isFlick: Boolean) { + doubleTapActionDispatcher.interrupt() + listener?.onAction(action, isFlick) + } + private fun dispatchResolvedSumireSpecialKeyAction( + keyData: KeyData, resolved: ResolvedSumireSpecialKeyAction, isFlick: Boolean ): Boolean { return dispatchResolvedSumireSpecialKeyAction(resolved, isFlick) { action, actionIsFlick -> - listener?.onAction(action, actionIsFlick) + dispatchCommittedKeyAction(keyData, action, actionIsFlick) } } @@ -2527,13 +2677,13 @@ class FlickKeyboardView @JvmOverloads constructor( if (abs(dx) > abs(dy) && abs(dx) > threshold) { val action2 = if (dx < 0f) KeyAction.MoveCursorLeft else KeyAction.MoveCursorRight - listener?.onAction(action2, false) + dispatchNonTapAction(action2, false) cursorInitialX = currentX cursorInitialY = currentY } else if (abs(dy) > abs(dx) && abs(dy) > threshold) { val action2 = if (dy < 0f) KeyAction.MoveCursorUp else KeyAction.MoveCursorDown - listener?.onAction(action2, false) + dispatchNonTapAction(action2, false) cursorInitialX = currentX cursorInitialY = currentY } @@ -2746,6 +2896,7 @@ class FlickKeyboardView @JvmOverloads constructor( } override fun onDetachedFromWindow() { + doubleTapActionDispatcher.cancel() cancelTrackedTouchState() super.onDetachedFromWindow() listener?.onLongPressActionCanceled(KeyAction.Cancel) @@ -2762,6 +2913,7 @@ class FlickKeyboardView @JvmOverloads constructor( override fun onVisibilityChanged(changedView: View, visibility: Int) { super.onVisibilityChanged(changedView, visibility) if (changedView == this && visibility != View.VISIBLE) { + doubleTapActionDispatcher.cancel() cancelTrackedTouchState() listener?.onLongPressActionCanceled(KeyAction.Cancel) } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/StandardFlickPopupView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/StandardFlickPopupView.kt index a39bb5317..c1c4eae7e 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/StandardFlickPopupView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/StandardFlickPopupView.kt @@ -46,6 +46,7 @@ class StandardFlickPopupView(context: Context) : AppCompatTextView(context) { private var popupTextSizeSp: Float = 19f private var popupBackgroundColor: Int? = null private var popupTextColor: Int? = null + private var inputTextTransform: (String) -> String = { it } private class YOffsetSpan(private val yOffset: Int) : ReplacementSpan() { override fun getSize( @@ -118,20 +119,24 @@ class StandardFlickPopupView(context: Context) : AppCompatTextView(context) { colorTheme?.let { applyTheme(it, direction) } } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + } + fun updateText(text: String?) { if (text.isNullOrEmpty()) { this.text = "" return } - this.text = createSpannableText(text) + this.text = createSpannableText(inputTextTransform(text)) } fun updateMultiCharText(characters: Map) { - val up = characters[FlickDirection.UP] ?: "" - val left = characters[FlickDirection.UP_LEFT_FAR] ?: "" - val tap = characters[FlickDirection.TAP] ?: "" - val right = characters[FlickDirection.UP_RIGHT_FAR] ?: "" - val down = characters[FlickDirection.DOWN] ?: "" + val up = inputTextTransform(characters[FlickDirection.UP] ?: "") + val left = inputTextTransform(characters[FlickDirection.UP_LEFT_FAR] ?: "") + val tap = inputTextTransform(characters[FlickDirection.TAP] ?: "") + val right = inputTextTransform(characters[FlickDirection.UP_RIGHT_FAR] ?: "") + val down = inputTextTransform(characters[FlickDirection.DOWN] ?: "") val tapSize = popupTextSizeSp.coerceIn(8f, 48f) val sideSize = tapSize * 0.58f diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/TfbiFlickPopupView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/TfbiFlickPopupView.kt index ac66b4720..c53c86eea 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/TfbiFlickPopupView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/TfbiFlickPopupView.kt @@ -43,6 +43,7 @@ class TfbiFlickPopupView(context: Context) : View(context) { } private var popupBackgroundColor: Int? = null private var popupTextColor: Int? = null + private var inputTextTransform: (String) -> String = { it } private val rects = mutableMapOf() private var cornerRadius = 20f @@ -80,6 +81,11 @@ class TfbiFlickPopupView(context: Context) : View(context) { invalidate() } + fun setInputTextTransform(transform: (String) -> String) { + inputTextTransform = transform + invalidate() + } + fun highlightDirection(direction: TfbiFlickDirection) { if (this.highlightedDirection != direction) { this.highlightedDirection = direction @@ -118,7 +124,7 @@ class TfbiFlickPopupView(context: Context) : View(context) { if (highlightedDirection == TfbiFlickDirection.TAP) highlightBgPaint else bgPaint canvas.drawRoundRect(rect, cornerRadius, cornerRadius, paint) canvas.drawRoundRect(rect, cornerRadius, cornerRadius, strokePaint) - drawTextCentered(canvas, tapCharacter, rect) + drawTextCentered(canvas, inputTextTransform(tapCharacter), rect) } for ((direction, char) in petalCharacters) { @@ -126,7 +132,7 @@ class TfbiFlickPopupView(context: Context) : View(context) { val paint = if (highlightedDirection == direction) highlightBgPaint else bgPaint canvas.drawRoundRect(rect, cornerRadius, cornerRadius, paint) canvas.drawRoundRect(rect, cornerRadius, cornerRadius, strokePaint) - drawTextCentered(canvas, char, rect) + drawTextCentered(canvas, inputTextTransform(char), rect) } } } diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcherTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcherTest.kt new file mode 100644 index 000000000..fab6cc128 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/DoubleTapActionDispatcherTest.kt @@ -0,0 +1,117 @@ +package com.kazumaproject.custom_keyboard.controller + +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy +import com.kazumaproject.custom_keyboard.data.KeyAction +import org.junit.Assert.assertEquals +import org.junit.Test + +class DoubleTapActionDispatcherTest { + private var now = 0L + private val scheduler = FakeScheduler { now } + private val dispatched = mutableListOf() + private val dispatcher = DoubleTapActionDispatcher( + timeoutMillis = 300, + minimumIntervalMillis = 40, + clockMillis = { now }, + scheduler = scheduler, + dispatch = dispatched::add + ) + + @Test + fun promote_dispatchesFirstTapImmediately_thenOnlyDoubleTapAction() { + val binding = DoubleTapBinding(KeyAction.CapLockKey, DoubleTapPolicy.PROMOTE) + + dispatcher.onCommittedTap("shift", KeyAction.ShiftKey, binding) + now = 120 + dispatcher.onCommittedTap("shift", KeyAction.ShiftKey, binding) + + assertEquals(listOf(KeyAction.ShiftKey, KeyAction.CapLockKey), dispatched) + scheduler.runDueAt(500) + assertEquals(listOf(KeyAction.ShiftKey, KeyAction.CapLockKey), dispatched) + } + + @Test + fun exclusive_doubleTap_suppressesNormalAction() { + val binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.EXCLUSIVE) + + dispatcher.onCommittedTap("select", KeyAction.SelectAll, binding) + now = 160 + dispatcher.onCommittedTap("select", KeyAction.SelectAll, binding) + + assertEquals(listOf(KeyAction.Copy), dispatched) + } + + @Test + fun exclusive_singleTap_dispatchesAfterTimeout() { + val binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.EXCLUSIVE) + + dispatcher.onCommittedTap("select", KeyAction.SelectAll, binding) + scheduler.runDueAt(299) + assertEquals(emptyList(), dispatched) + scheduler.runDueAt(300) + + assertEquals(listOf(KeyAction.SelectAll), dispatched) + } + + @Test + fun differentKey_flushesExclusiveTapBeforeNewAction() { + val binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.EXCLUSIVE) + + dispatcher.onCommittedTap("select", KeyAction.SelectAll, binding) + now = 100 + dispatcher.onCommittedTap("space", KeyAction.Space, null) + + assertEquals(listOf(KeyAction.SelectAll, KeyAction.Space), dispatched) + } + + @Test + fun tooFastSecondTap_isIgnoredAsTouchBounce() { + val binding = DoubleTapBinding(KeyAction.CapLockKey, DoubleTapPolicy.PROMOTE) + + dispatcher.onCommittedTap("shift", KeyAction.ShiftKey, binding) + now = 20 + dispatcher.onCommittedTap("shift", KeyAction.ShiftKey, binding) + + assertEquals(listOf(KeyAction.ShiftKey), dispatched) + } + + @Test + fun cancel_dropsPendingExclusiveAction() { + val binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.EXCLUSIVE) + + dispatcher.onCommittedTap("select", KeyAction.SelectAll, binding) + dispatcher.cancel() + scheduler.runDueAt(500) + + assertEquals(emptyList(), dispatched) + } + + private class FakeScheduler( + private val clock: () -> Long + ) : TapTaskScheduler { + private data class Entry( + val dueAt: Long, + var canceled: Boolean, + val task: () -> Unit + ) + + private val entries = mutableListOf() + + override fun schedule(delayMillis: Long, task: () -> Unit): CancellableTask { + val entry = Entry(clock() + delayMillis, false, task) + entries += entry + return CancellableTask { entry.canceled = true } + } + + fun runDueAt(now: Long) { + entries + .filter { !it.canceled && it.dueAt <= now } + .sortedBy { it.dueAt } + .forEach { + it.canceled = true + it.task() + } + } + } +} diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCaseTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCaseTest.kt new file mode 100644 index 000000000..0b0ae9da7 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyCharacterCaseTest.kt @@ -0,0 +1,29 @@ +package com.kazumaproject.custom_keyboard.data + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Test + +class KeyCharacterCaseTest { + @Test + fun uppercase_transformsOnlyLowercaseAsciiLetters() { + assertEquals( + "ABC XYZ-123 あİß", + KeyCharacterCase.UPPERCASE.transformAsciiLetters("aBc xyz-123 あİß") + ) + } + + @Test + fun asDefined_returnsCanonicalInstance() { + val canonical = "qWERTY あいう" + + assertSame(canonical, KeyCharacterCase.AS_DEFINED.transformAsciiLetters(canonical)) + } + + @Test + fun uppercase_withoutLowercaseAscii_returnsCanonicalInstance() { + val canonical = "ABC 123 あいう" + + assertSame(canonical, KeyCharacterCase.UPPERCASE.transformAsciiLetters(canonical)) + } +} diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyGestureBindingTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyGestureBindingTest.kt new file mode 100644 index 000000000..38d29c287 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/data/KeyGestureBindingTest.kt @@ -0,0 +1,62 @@ +package com.kazumaproject.custom_keyboard.data + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class KeyGestureBindingTest { + @Test + fun normalCharacterKey_neverExposesPersistedDoubleTapBinding() { + val key = key( + normalAction = KeyAction.Text("a"), + isSpecialKey = false, + binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.PROMOTE) + ) + + assertNull(key.effectiveDoubleTapBinding(KeyAction.Text("a"))) + } + + @Test + fun shiftCapsLock_usesPromoteRegardlessOfPersistedPolicy() { + val key = key( + normalAction = KeyAction.ShiftKey, + isSpecialKey = true, + binding = DoubleTapBinding(KeyAction.CapLockKey, DoubleTapPolicy.EXCLUSIVE) + ) + + assertEquals( + DoubleTapPolicy.PROMOTE, + key.effectiveDoubleTapBinding(KeyAction.ShiftKey)?.policy + ) + } + + @Test + fun otherSpecialShortcut_usesExclusiveRegardlessOfPersistedPolicy() { + val key = key( + normalAction = KeyAction.SelectAll, + isSpecialKey = true, + binding = DoubleTapBinding(KeyAction.Copy, DoubleTapPolicy.PROMOTE) + ) + + assertEquals( + DoubleTapPolicy.EXCLUSIVE, + key.effectiveDoubleTapBinding(KeyAction.SelectAll)?.policy + ) + } + + private fun key( + normalAction: KeyAction, + isSpecialKey: Boolean, + binding: DoubleTapBinding + ) = KeyData( + label = "test", + row = 0, + column = 0, + isFlickable = false, + action = normalAction, + isSpecialKey = isSpecialKey, + keyId = "test", + keyType = KeyType.NORMAL, + doubleTapBinding = binding + ) +} diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/layout/AlphabetTemplateLayoutsTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/layout/AlphabetTemplateLayoutsTest.kt index 402063a92..1e8fd566b 100644 --- a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/layout/AlphabetTemplateLayoutsTest.kt +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/layout/AlphabetTemplateLayoutsTest.kt @@ -1,6 +1,7 @@ package com.kazumaproject.custom_keyboard.layout import com.kazumaproject.custom_keyboard.data.GridPlacement +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy import com.kazumaproject.custom_keyboard.data.KeyAction import com.kazumaproject.custom_keyboard.data.KeyData import com.kazumaproject.custom_keyboard.data.KeyItem @@ -80,6 +81,16 @@ class AlphabetTemplateLayoutsTest { assertEquals("$prefix SwitchToNextIme rowUnits", 6, switchIme!!.placement.rowUnits) assertEquals("$prefix Space rowUnits", 6, space!!.placement.rowUnits) assertEquals("$prefix Enter rowUnits", 6, enter!!.placement.rowUnits) + assertEquals( + "$prefix Shift double tap action", + KeyAction.CapLockKey, + shift.keyData.doubleTapBinding?.action + ) + assertEquals( + "$prefix Shift double tap policy", + DoubleTapPolicy.PROMOTE, + shift.keyData.doubleTapBinding?.policy + ) } private fun assertAllCharacterKeysAreNormalText(layout: KeyboardLayout) { diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewCharacterCaseTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewCharacterCaseTest.kt new file mode 100644 index 000000000..5e9776616 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewCharacterCaseTest.kt @@ -0,0 +1,147 @@ +package com.kazumaproject.custom_keyboard.view + +import android.content.Context +import android.view.ContextThemeWrapper +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.custom_keyboard.data.KeyAction +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase +import com.kazumaproject.custom_keyboard.data.KeyData +import com.kazumaproject.custom_keyboard.data.KeyType +import com.kazumaproject.custom_keyboard.data.KeyboardInputMode +import com.kazumaproject.custom_keyboard.data.KeyboardLayout +import com.kazumaproject.custom_keyboard.layout.KeyboardDefaultLayouts +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class FlickKeyboardViewCharacterCaseTest { + @Test + fun qwertyLabels_followCharacterCase_withoutMutatingCanonicalLayout() { + val keyboard = createView() + val layout = KeyboardDefaultLayouts.createQwertyTemplateLayout() + keyboard.setKeyboard(layout) + + assertNotNull(keyboard.findButtonWithText("q")) + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + assertNotNull(keyboard.findButtonWithText("Q")) + assertNull(keyboard.findButtonWithText("q")) + assertEquals("q", layout.keys.first { it.keyId == "qwerty_key_q" }.label) + + keyboard.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) + assertNotNull(keyboard.findButtonWithText("q")) + assertNull(keyboard.findButtonWithText("Q")) + } + + @Test + fun characterCaseSetBeforeLayout_isAppliedWhenKeysAreCreated() { + val keyboard = createView() + + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + keyboard.setKeyboard(KeyboardDefaultLayouts.createQwertyTemplateLayout()) + + assertNotNull(keyboard.findButtonWithText("Q")) + } + + @Test + fun nonInputShortcutLabel_isNotChanged() { + val keyboard = createView() + keyboard.setKeyboard( + KeyboardLayout( + keys = listOf( + KeyData( + label = "paste", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Paste, + isSpecialKey = false, + keyId = "paste", + keyType = KeyType.NORMAL + ) + ), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + ) + + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + + assertNotNull(keyboard.findButtonWithText("paste")) + assertNull(keyboard.findButtonWithText("PASTE")) + } + + @Test + fun textActionLabel_isChangedEvenWhenItUsesSpecialKeyStyling() { + val keyboard = createView() + keyboard.setKeyboard( + KeyboardLayout( + keys = listOf( + KeyData( + label = "a", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Text("a"), + isSpecialKey = true, + keyId = "styled_text", + keyType = KeyType.NORMAL + ) + ), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + ) + + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + + assertNotNull(keyboard.findButtonWithText("A")) + } + + @Test + fun englishFlickGuideTapLabel_followsCharacterCase() { + val keyboard = createView() + keyboard.setFlickGuideEnabled(enabled = true, allowMultiCharacterLabels = true) + keyboard.setKeyboard( + KeyboardDefaultLayouts.createFinalLayout( + mode = KeyboardInputMode.ENGLISH, + dynamicKeyStates = emptyMap(), + inputLayoutType = "flick", + inputStyle = "default" + ) + ) + assertNotNull(keyboard.findButtonWithText("a")) + + keyboard.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + assertNotNull(keyboard.findButtonWithText("A")) + assertNull(keyboard.findButtonWithText("a")) + + keyboard.setKeyCharacterCase(KeyCharacterCase.AS_DEFINED) + assertNotNull(keyboard.findButtonWithText("a")) + } + + private fun createView(): FlickKeyboardView { + val context = ApplicationProvider.getApplicationContext() + return FlickKeyboardView( + ContextThemeWrapper( + context, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar + ) + ) + } + + private fun FlickKeyboardView.findButtonWithText(text: String): AutoSizeButton? { + for (index in 0 until childCount) { + val button = getChildAt(index) as? AutoSizeButton ?: continue + if (button.text.toString() == text) return button + } + return null + } +} diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewTouchDispatchTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewTouchDispatchTest.kt index cc0eaa778..3d8c5db7e 100644 --- a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewTouchDispatchTest.kt +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewTouchDispatchTest.kt @@ -2,13 +2,17 @@ package com.kazumaproject.custom_keyboard.view import android.content.Context import android.graphics.Rect +import android.os.Looper import android.view.ContextThemeWrapper import android.view.MotionEvent import android.view.View import androidx.test.core.app.ApplicationProvider import com.kazumaproject.custom_keyboard.data.FlickAction import com.kazumaproject.custom_keyboard.data.FlickDirection +import com.kazumaproject.custom_keyboard.data.DoubleTapBinding +import com.kazumaproject.custom_keyboard.data.DoubleTapPolicy import com.kazumaproject.custom_keyboard.data.KeyAction +import com.kazumaproject.custom_keyboard.data.KeyCharacterCase import com.kazumaproject.custom_keyboard.data.KeyData import com.kazumaproject.custom_keyboard.data.KeyType import com.kazumaproject.custom_keyboard.data.KeyboardLayout @@ -17,7 +21,9 @@ import org.junit.Assert.assertTrue import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf import org.robolectric.annotation.Config +import java.util.concurrent.TimeUnit @RunWith(RobolectricTestRunner::class) @Config(sdk = [35]) @@ -62,6 +68,72 @@ class FlickKeyboardViewTouchDispatchTest { assertFalse(listener.actions.contains(KeyAction.Paste)) } + @Test + fun normalShiftKey_doubleTap_dispatchesShiftThenCapsLock() { + val listener = RecordingKeyboardActionListener() + val keyboardView = keyboardView(listener) + keyboardView.setKeyboard(shiftKeyLayout()) + layoutKeyboard(keyboardView) + val shiftKey = keyboardView.getChildAt(0) + val x = shiftKey.centerX() + val y = shiftKey.centerY() + + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 100L, 100L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 100L, 120L) + shadowOf(Looper.getMainLooper()).idleFor(100, TimeUnit.MILLISECONDS) + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 220L, 220L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 220L, 240L) + + assertTrue(listener.actions == listOf(KeyAction.ShiftKey, KeyAction.CapLockKey)) + } + + @Test + fun characterCaseRefreshAfterFirstShiftTap_preservesSecondTapRecognition() { + lateinit var keyboardView: FlickKeyboardView + val listener = RecordingKeyboardActionListener { action -> + if (action == KeyAction.ShiftKey) { + keyboardView.setKeyCharacterCase(KeyCharacterCase.UPPERCASE) + } + } + keyboardView = keyboardView(listener) + keyboardView.setKeyboard(shiftKeyLayout()) + layoutKeyboard(keyboardView) + val shiftKey = keyboardView.getChildAt(0) + val x = shiftKey.centerX() + val y = shiftKey.centerY() + + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 300L, 300L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 300L, 320L) + shadowOf(Looper.getMainLooper()).idleFor(100, TimeUnit.MILLISECONDS) + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 420L, 420L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 420L, 440L) + + assertTrue(listener.actions == listOf(KeyAction.ShiftKey, KeyAction.CapLockKey)) + } + + @Test + fun normalCharacterKey_ignoresDoubleTapBindingAndDispatchesBothTaps() { + val listener = RecordingKeyboardActionListener() + val keyboardView = keyboardView(listener) + keyboardView.setKeyboard(normalCharacterKeyWithInvalidBindingLayout()) + layoutKeyboard(keyboardView) + val characterKey = keyboardView.getChildAt(0) + val x = characterKey.centerX() + val y = characterKey.centerY() + + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 500L, 500L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 500L, 520L) + keyboardView.dispatchTouch(MotionEvent.ACTION_DOWN, x, y, 620L, 620L) + keyboardView.dispatchTouch(MotionEvent.ACTION_UP, x, y, 620L, 640L) + + assertTrue( + listener.actions == listOf( + KeyAction.Text("a"), + KeyAction.Text("a") + ) + ) + } + private fun keyboardView( listener: FlickKeyboardView.OnKeyboardActionListener ): FlickKeyboardView { @@ -97,6 +169,52 @@ class FlickKeyboardViewTouchDispatchTest { ) } + private fun shiftKeyLayout(): KeyboardLayout { + val shiftKey = KeyData( + label = "", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.ShiftKey, + isSpecialKey = true, + keyId = "shift", + keyType = KeyType.NORMAL, + doubleTapBinding = DoubleTapBinding( + KeyAction.CapLockKey, + DoubleTapPolicy.PROMOTE + ) + ) + return KeyboardLayout( + keys = listOf(shiftKey), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + } + + private fun normalCharacterKeyWithInvalidBindingLayout(): KeyboardLayout { + val characterKey = KeyData( + label = "a", + row = 0, + column = 0, + isFlickable = false, + action = KeyAction.Text("a"), + isSpecialKey = false, + keyId = "a", + keyType = KeyType.NORMAL, + doubleTapBinding = DoubleTapBinding( + KeyAction.Copy, + DoubleTapPolicy.PROMOTE + ) + ) + return KeyboardLayout( + keys = listOf(characterKey), + flickKeyMaps = emptyMap(), + columnCount = 1, + rowCount = 1 + ) + } + private fun layoutKeyboard(keyboardView: FlickKeyboardView) { val widthSpec = View.MeasureSpec.makeMeasureSpec(240, View.MeasureSpec.EXACTLY) val heightSpec = View.MeasureSpec.makeMeasureSpec(120, View.MeasureSpec.EXACTLY) @@ -120,13 +238,16 @@ class FlickKeyboardViewTouchDispatchTest { private fun View.centerY(): Float = top + height / 2f - private class RecordingKeyboardActionListener : FlickKeyboardView.OnKeyboardActionListener { + private class RecordingKeyboardActionListener( + private val afterAction: (KeyAction) -> Unit = {} + ) : FlickKeyboardView.OnKeyboardActionListener { val actions = mutableListOf() override fun onPress(action: KeyAction) = Unit override fun onAction(action: KeyAction, isFlick: Boolean) { actions += action + afterAction(action) } override fun onActionLongPress(action: KeyAction) = Unit From aa544e8511a7c72b500b8975f0627031ed34a4be Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Tue, 28 Jul 2026 21:16:44 -0400 Subject: [PATCH 05/24] fix popupview --- .../controller/CrossFlickInputController.kt | 404 +++++------------- .../controller/KeyboardPopupOverlay.kt | 165 +++++++ .../custom_keyboard/view/FlickKeyboardView.kt | 6 +- ...CrossFlickInputControllerPopupCacheTest.kt | 6 +- ...ssFlickInputControllerPopupPositionTest.kt | 53 ++- .../controller/KeyboardPopupOverlayTest.kt | 74 ++++ 6 files changed, 396 insertions(+), 312 deletions(-) create mode 100644 custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlay.kt create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlayTest.kt diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt index a1c4db603..7ce81a17e 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt @@ -2,17 +2,11 @@ package com.kazumaproject.custom_keyboard.controller import android.annotation.SuppressLint import android.content.Context -import android.graphics.Color import android.graphics.PointF -import android.view.Gravity import android.view.MotionEvent import android.view.View import android.view.ViewConfiguration -import android.view.ViewTreeObserver -import android.view.WindowManager import android.widget.Button -import android.widget.PopupWindow -import androidx.core.graphics.drawable.toDrawable import com.kazumaproject.core.data.popup.PopupViewStyle import com.kazumaproject.core.domain.flick.FixedGestureSessionConfigSource import com.kazumaproject.core.domain.flick.FlickDirection as CoreFlickDirection @@ -100,7 +94,7 @@ class CrossFlickInputController( var listener: CrossFlickListener? = null - private var popupWindowAnchorProvider: (() -> View?)? = null + private var popupOverlayHostProvider: (() -> View?)? = null private var inputMode: InputMode = InputMode.ACTION private var anchorView: View? = null @@ -112,11 +106,10 @@ class CrossFlickInputController( private var textMap: Map = emptyMap() private var longPressTextMap: Map = emptyMap() - private val actionPopupWindows = mutableMapOf() private val actionPopupViews = mutableMapOf() - private val directionalPopupMap = mutableMapOf() - private var currentVisibleDirectionalPopup: PopupWindow? = null + private val directionalPopupMap = mutableMapOf() + private var currentVisibleDirectionalPopup: DirectionalKeyPopupView? = null private var currentVisibleDirectional: FlickDirection? = null private var directionalPopupCacheDirty = true private var directionalPopupAnchorWidth = -1 @@ -124,30 +117,11 @@ class CrossFlickInputController( private var originalKeyText: CharSequence? = null private val popupAnchorLocation = IntArray(2) private val popupKeyLocationScratch = IntArray(2) - private val popupWindowLocationScratch = IntArray(2) + private val popupHostLocationScratch = IntArray(2) private val popupPositionScratch = IntArray(2) - private var trackedPopupAnchor: View? = null - private var trackedPopupViewTreeObserver: ViewTreeObserver? = null - private var lastPopupAnchorX = Int.MIN_VALUE - private var lastPopupAnchorY = Int.MIN_VALUE - private var lastPopupAnchorWidth = -1 - private var lastPopupAnchorHeight = -1 - private val popupGlobalLayoutListener = ViewTreeObserver.OnGlobalLayoutListener { - repositionVisiblePopupsIfAnchorMoved() - } - - private val gridPopup = PopupWindow( - CrossFlickPopupView(context), - WindowManager.LayoutParams.WRAP_CONTENT, - WindowManager.LayoutParams.WRAP_CONTENT, - false - ).apply { - setBackgroundDrawable(Color.TRANSPARENT.toDrawable()) - isClippingEnabled = false + private val popupOverlay = KeyboardPopupOverlay(::positionVisiblePopupsBeforeDraw) + private val gridPopupView = CrossFlickPopupView(context).apply { elevation = 8f - animationStyle = 0 - enterTransition = null - exitTransition = null } private val controllerScope = CoroutineScope(Dispatchers.Main + SupervisorJob()) @@ -186,17 +160,17 @@ class CrossFlickInputController( textColor = cross.textColor ) actionPopupViews.values.forEach { it.applyPopupViewStyle(crossPopupStyle) } - (gridPopup.contentView as? CrossFlickPopupView)?.applyPopupViewStyle(crossPopupStyle) + gridPopupView.applyPopupViewStyle(crossPopupStyle) invalidateDirectionalPopupCache() } - fun setPopupWindowAnchorProvider(provider: (() -> View?)?) { - popupWindowAnchorProvider = provider + fun setPopupOverlayHostProvider(provider: (() -> View?)?) { + popupOverlayHostProvider = provider } fun setInputTextTransform(transform: (String) -> String) { inputTextTransform = transform - (gridPopup.contentView as? CrossFlickPopupView)?.setInputTextTransform(transform) + gridPopupView.setInputTextTransform(transform) actionPopupViews.values.forEach { it.setInputTextTransform(transform) } invalidateDirectionalPopupCache() } @@ -421,7 +395,7 @@ class CrossFlickInputController( } InputMode.TEXT -> { - if (gridPopup.isShowing) { + if (popupOverlay.isShowing(gridPopupView)) { highlightGrid(direction) } else { showDirectionalPopup(direction) @@ -531,8 +505,7 @@ class CrossFlickInputController( val flickAction = resolveAction(direction) ?: return if (!isVisiblePopupAction(flickAction)) return val anchor = anchorView ?: return - val windowAnchor = resolveWindowAnchor(anchor) - if (!isAnchorReady(anchor, windowAnchor)) return + if (!anchor.isAttachedToWindow) return val popupView = CrossFlickPopupView(context).apply { setInputTextTransform(inputTextTransform) @@ -545,43 +518,24 @@ class CrossFlickInputController( ) popupColorTheme?.let { setColors(it) } if (highlighted) highlightDirection(direction) - } - - val popupWindow = PopupWindow( - popupView, - (anchor.width * (crossPopupStyle.sizeScalePercent.coerceIn(50, 200) / 100f)).toInt().coerceAtLeast(1), - (anchor.height * (crossPopupStyle.sizeScalePercent.coerceIn(50, 200) / 100f)).toInt().coerceAtLeast(1), - false - ).apply { - isClippingEnabled = false elevation = 8f - animationStyle = 0 - enterTransition = null - exitTransition = null } + val scale = crossPopupStyle.sizeScalePercent.coerceIn(50, 200) / 100f + val popupWidth = (anchor.width * scale).toInt().coerceAtLeast(1) + val popupHeight = (anchor.height * scale).toInt().coerceAtLeast(1) - readPopupAnchorLocation(anchor, windowAnchor) - resolveActionPopupPosition( - direction = direction, + // Register first so the overlay's initial pre-draw placement can include this view. + actionPopupViews[direction] = popupView + val shown = popupOverlay.show( anchor = anchor, - anchorX = popupAnchorLocation[0], - anchorY = popupAnchorLocation[1] + preferredHost = resolvePreferredOverlayHost(), + popupView = popupView, + width = popupWidth, + height = popupHeight ) - val shown = runCatching { - popupWindow.showAtLocation( - windowAnchor, - Gravity.NO_GRAVITY, - popupPositionScratch[0], - popupPositionScratch[1] - ) - true - }.getOrDefault(false) - - if (shown) { - actionPopupWindows[direction] = popupWindow - actionPopupViews[direction] = popupView - startPopupPositionTracking() + if (!shown) { + actionPopupViews.remove(direction) } } @@ -596,13 +550,14 @@ class CrossFlickInputController( FlickDirection.UP_LEFT_FAR, FlickDirection.UP_RIGHT_FAR ).forEach { direction -> - val existingPopup = actionPopupWindows[direction] val existingPopupView = actionPopupViews[direction] - if (existingPopup?.isShowing == true && existingPopupView != null) { + if ( + existingPopupView != null && + popupOverlay.isShowing(existingPopupView) + ) { existingPopupView.highlightDirection(null) } else { - existingPopup?.dismiss() - actionPopupWindows.remove(direction) + existingPopupView?.let(popupOverlay::dismiss) actionPopupViews.remove(direction) showActionPopup(direction, highlighted = false) } @@ -618,10 +573,8 @@ class CrossFlickInputController( // 表示中のアクションポップアップを全て閉じてマップをクリアする。 private fun dismissAllActionPopups() { - actionPopupWindows.values.forEach { if (it.isShowing) it.dismiss() } - actionPopupWindows.clear() + actionPopupViews.values.forEach(popupOverlay::dismiss) actionPopupViews.clear() - stopPopupPositionTrackingIfNoPopupsVisible() } // TEXT モードの方向ポップアップを必要なときだけ生成し、同じキーでは再利用する。 @@ -634,7 +587,7 @@ class CrossFlickInputController( return } - directionalPopupMap.values.forEach { if (it.isShowing) it.dismiss() } + directionalPopupMap.values.forEach(popupOverlay::dismiss) directionalPopupMap.clear() currentVisibleDirectionalPopup = null currentVisibleDirectional = null @@ -678,18 +631,12 @@ class CrossFlickInputController( } }.let { (it * scale).toInt().coerceAtLeast(1) } - directionalPopupMap[direction] = PopupWindow( - popupView, - popupWidth, - popupHeight, - false - ).apply { - isClippingEnabled = false - elevation = 8f - animationStyle = 0 - enterTransition = null - exitTransition = null - } + popupView.elevation = 8f + popupView.measure( + View.MeasureSpec.makeMeasureSpec(popupWidth, View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(popupHeight, View.MeasureSpec.EXACTLY) + ) + directionalPopupMap[direction] = popupView } directionalPopupAnchorWidth = currentAnchor.width @@ -704,65 +651,40 @@ class CrossFlickInputController( return } - currentVisibleDirectionalPopup?.dismiss() + currentVisibleDirectionalPopup?.let(popupOverlay::dismiss) val popupToShow = directionalPopupMap[direction] ?: return val currentAnchor = anchorView ?: return - val windowAnchor = resolveWindowAnchor(currentAnchor) - if (!isAnchorReady(currentAnchor, windowAnchor)) { + if (!currentAnchor.isAttachedToWindow) { currentVisibleDirectionalPopup = null currentVisibleDirectional = null return } - - readPopupAnchorLocation(currentAnchor, windowAnchor) - val anchorX = popupAnchorLocation[0] - val anchorY = popupAnchorLocation[1] - val keyWidth = currentAnchor.width - val keyHeight = currentAnchor.height - - val popupWidth = popupToShow.width - val popupHeight = popupToShow.height - - resolveDirectionalPopupPosition( - direction = direction, - anchorX = anchorX, - anchorY = anchorY, - keyWidth = keyWidth, - keyHeight = keyHeight, - popupWidth = popupWidth, - popupHeight = popupHeight + currentVisibleDirectionalPopup = popupToShow + currentVisibleDirectional = direction + val shown = popupOverlay.show( + anchor = currentAnchor, + preferredHost = resolvePreferredOverlayHost(), + popupView = popupToShow, + width = popupToShow.measuredWidth, + height = popupToShow.measuredHeight ) - val shown = runCatching { - popupToShow.showAtLocation( - windowAnchor, - Gravity.NO_GRAVITY, - popupPositionScratch[0], - popupPositionScratch[1] - ) - true - }.getOrDefault(false) - - if (shown) { - currentVisibleDirectionalPopup = popupToShow - currentVisibleDirectional = direction - startPopupPositionTracking() + if (!shown) { + currentVisibleDirectionalPopup = null + currentVisibleDirectional = null } } // TEXT モードの長押し発動時にグリッドポップアップを表示する。既に表示中なら位置を更新する。 private fun showGridPopup() { val currentAnchor = anchorView ?: return - val windowAnchor = resolveWindowAnchor(currentAnchor) - if (!isAnchorReady(currentAnchor, windowAnchor)) { - if (gridPopup.isShowing) { - gridPopup.dismiss() - } + if (!currentAnchor.isAttachedToWindow) { + popupOverlay.dismiss(gridPopupView) return } - val popupView = gridPopup.contentView as CrossFlickPopupView + val popupView = gridPopupView popupView.setInputTextTransform(inputTextTransform) popupView.applyPopupViewStyle(crossPopupStyle) popupColorTheme?.let { popupView.setColors(it) } @@ -778,48 +700,19 @@ class CrossFlickInputController( ) popupView.highlightDirection(currentDirection) - readPopupAnchorLocation(currentAnchor, windowAnchor) popupView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED) - - resolveCenteredPopupPosition( - anchorX = popupAnchorLocation[0], - anchorY = popupAnchorLocation[1], - keyWidth = currentAnchor.width, - keyHeight = currentAnchor.height, - popupWidth = popupView.measuredWidth, - popupHeight = popupView.measuredHeight + popupOverlay.show( + anchor = currentAnchor, + preferredHost = resolvePreferredOverlayHost(), + popupView = popupView, + width = popupView.measuredWidth, + height = popupView.measuredHeight ) - - gridPopup.width = WindowManager.LayoutParams.WRAP_CONTENT - gridPopup.height = WindowManager.LayoutParams.WRAP_CONTENT - - if (!gridPopup.isShowing) { - runCatching { - gridPopup.showAtLocation( - windowAnchor, - Gravity.NO_GRAVITY, - popupPositionScratch[0], - popupPositionScratch[1] - ) - } - } else { - runCatching { - gridPopup.update( - popupPositionScratch[0], - popupPositionScratch[1], - -1, - -1 - ) - } - } - if (gridPopup.isShowing) { - startPopupPositionTracking() - } } // グリッドポップアップ内の対応セルをハイライトする。長押し中の指移動で呼ばれる。 private fun highlightGrid(direction: FlickDirection) { - (gridPopup.contentView as? CrossFlickPopupView)?.highlightDirection(direction) + gridPopupView.highlightDirection(direction) } // グリッドポップアップに渡す表示文字マップを生成する。各方向で longPressTextMap を優先し、なければ textMap を使う。 @@ -849,53 +742,41 @@ class CrossFlickInputController( // TEXT モードのポップアップ（方向ポップアップとグリッドポップアップ）をすべて閉じる。 private fun dismissDirectionalPopups(clearCache: Boolean = false) { - currentVisibleDirectionalPopup?.dismiss() + currentVisibleDirectionalPopup?.let(popupOverlay::dismiss) currentVisibleDirectionalPopup = null currentVisibleDirectional = null - directionalPopupMap.values.forEach { if (it.isShowing) it.dismiss() } if (clearCache) { + directionalPopupMap.values.forEach(popupOverlay::dismiss) directionalPopupMap.clear() directionalPopupAnchorWidth = -1 directionalPopupAnchorHeight = -1 directionalPopupCacheDirty = true } - if (gridPopup.isShowing) { - gridPopup.dismiss() - } - stopPopupPositionTrackingIfNoPopupsVisible() + popupOverlay.dismiss(gridPopupView) } // ACTION・TEXT 両モードのポップアップをすべて閉じる。 fun dismissAllPopups(clearDirectionalCache: Boolean = false) { dismissAllActionPopups() dismissDirectionalPopups(clearCache = clearDirectionalCache) - stopPopupPositionTracking() + popupOverlay.dismissAll() } private fun invalidateDirectionalPopupCache() { dismissDirectionalPopups(clearCache = true) } - private fun resolveWindowAnchor(keyAnchor: View): View? { - return popupWindowAnchorProvider?.invoke() ?: keyAnchor - } - - private fun isAnchorReady(keyAnchor: View, windowAnchor: View?): Boolean { - if (!keyAnchor.isAttachedToWindow) return false - if (windowAnchor == null) return false - if (!windowAnchor.isAttachedToWindow) return false - return windowAnchor.windowToken != null + private fun resolvePreferredOverlayHost(): View? { + return popupOverlayHostProvider?.invoke() } - private fun readPopupAnchorLocation(keyAnchor: View, windowAnchor: View?) { - // showAtLocation(NO_GRAVITY) receives coordinates relative to the containing window. - // Screen coordinates add the left navigation inset again when the device is rotated 270°. - getLocationRelativeToWindowAnchor( + private fun readPopupAnchorLocation(keyAnchor: View, overlayHost: View) { + getLocationRelativeToOverlayHost( keyAnchor = keyAnchor, - windowAnchor = windowAnchor, + overlayHost = overlayHost, outLocation = popupAnchorLocation, keyLocationScratch = popupKeyLocationScratch, - windowLocationScratch = popupWindowLocationScratch + hostLocationScratch = popupHostLocationScratch ) } @@ -968,109 +849,44 @@ class CrossFlickInputController( popupPositionScratch[1] = anchorY + keyHeight / 2 - popupHeight / 2 } - private fun startPopupPositionTracking() { - val anchor = anchorView ?: return - val observer = anchor.viewTreeObserver - if ( - trackedPopupAnchor === anchor && - trackedPopupViewTreeObserver === observer && - observer.isAlive - ) { - return - } - - stopPopupPositionTracking() - if (!observer.isAlive) return - - trackedPopupAnchor = anchor - trackedPopupViewTreeObserver = observer - observer.addOnGlobalLayoutListener(popupGlobalLayoutListener) - - val windowAnchor = resolveWindowAnchor(anchor) - if (isAnchorReady(anchor, windowAnchor)) { - readPopupAnchorLocation(anchor, windowAnchor) - rememberPopupAnchorGeometry(anchor) - } - } - - private fun stopPopupPositionTracking() { - trackedPopupViewTreeObserver?.let { observer -> - if (observer.isAlive) { - observer.removeOnGlobalLayoutListener(popupGlobalLayoutListener) - } - } - trackedPopupAnchor = null - trackedPopupViewTreeObserver = null - lastPopupAnchorX = Int.MIN_VALUE - lastPopupAnchorY = Int.MIN_VALUE - lastPopupAnchorWidth = -1 - lastPopupAnchorHeight = -1 - } - - private fun stopPopupPositionTrackingIfNoPopupsVisible() { - val hasVisibleActionPopup = actionPopupWindows.values.any { it.isShowing } - val hasVisibleDirectionalPopup = currentVisibleDirectionalPopup?.isShowing == true - if (!hasVisibleActionPopup && !hasVisibleDirectionalPopup && !gridPopup.isShowing) { - stopPopupPositionTracking() - } - } - - private fun rememberPopupAnchorGeometry(anchor: View) { - lastPopupAnchorX = popupAnchorLocation[0] - lastPopupAnchorY = popupAnchorLocation[1] - lastPopupAnchorWidth = anchor.width - lastPopupAnchorHeight = anchor.height - } - - private fun repositionVisiblePopupsIfAnchorMoved() { + private fun positionVisiblePopupsBeforeDraw() { val anchor = anchorView ?: run { - stopPopupPositionTracking() + popupOverlay.dismissAll() return } - val windowAnchor = resolveWindowAnchor(anchor) - if (!isAnchorReady(anchor, windowAnchor)) { - stopPopupPositionTracking() + val overlayHost = popupOverlay.currentHost ?: return + if (!anchor.isAttachedToWindow || !overlayHost.isAttachedToWindow) { + popupOverlay.dismissAll() return } - readPopupAnchorLocation(anchor, windowAnchor) - val geometryUnchanged = - popupAnchorLocation[0] == lastPopupAnchorX && - popupAnchorLocation[1] == lastPopupAnchorY && - anchor.width == lastPopupAnchorWidth && - anchor.height == lastPopupAnchorHeight - if (geometryUnchanged) return - - rememberPopupAnchorGeometry(anchor) - repositionVisibleActionPopups(anchor) - repositionVisibleDirectionalPopup(anchor) - repositionGridPopup(anchor) + readPopupAnchorLocation(anchor, overlayHost) + positionVisibleActionPopups(anchor) + positionVisibleDirectionalPopup(anchor) + positionGridPopup(anchor) } - private fun repositionVisibleActionPopups(anchor: View) { - actionPopupWindows.forEach { (direction, popupWindow) -> - if (!popupWindow.isShowing) return@forEach + private fun positionVisibleActionPopups(anchor: View) { + actionPopupViews.forEach { (direction, popupView) -> + if (!popupOverlay.isShowing(popupView)) return@forEach resolveActionPopupPosition( direction = direction, anchor = anchor, anchorX = popupAnchorLocation[0], anchorY = popupAnchorLocation[1] ) - runCatching { - popupWindow.update( - popupPositionScratch[0], - popupPositionScratch[1], - -1, - -1 - ) - } + popupOverlay.place( + popupView = popupView, + left = popupPositionScratch[0], + top = popupPositionScratch[1] + ) } } - private fun repositionVisibleDirectionalPopup(anchor: View) { - val popupWindow = currentVisibleDirectionalPopup ?: return + private fun positionVisibleDirectionalPopup(anchor: View) { + val popupView = currentVisibleDirectionalPopup ?: return val direction = currentVisibleDirectional ?: return - if (!popupWindow.isShowing) return + if (!popupOverlay.isShowing(popupView)) return resolveDirectionalPopupPosition( direction = direction, @@ -1078,39 +894,31 @@ class CrossFlickInputController( anchorY = popupAnchorLocation[1], keyWidth = anchor.width, keyHeight = anchor.height, - popupWidth = popupWindow.width, - popupHeight = popupWindow.height + popupWidth = popupView.measuredWidth, + popupHeight = popupView.measuredHeight + ) + popupOverlay.place( + popupView = popupView, + left = popupPositionScratch[0], + top = popupPositionScratch[1] ) - runCatching { - popupWindow.update( - popupPositionScratch[0], - popupPositionScratch[1], - -1, - -1 - ) - } } - private fun repositionGridPopup(anchor: View) { - if (!gridPopup.isShowing) return - val popupView = gridPopup.contentView ?: return - popupView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED) + private fun positionGridPopup(anchor: View) { + if (!popupOverlay.isShowing(gridPopupView)) return resolveCenteredPopupPosition( anchorX = popupAnchorLocation[0], anchorY = popupAnchorLocation[1], keyWidth = anchor.width, keyHeight = anchor.height, - popupWidth = popupView.measuredWidth, - popupHeight = popupView.measuredHeight + popupWidth = gridPopupView.measuredWidth, + popupHeight = gridPopupView.measuredHeight + ) + popupOverlay.place( + popupView = gridPopupView, + left = popupPositionScratch[0], + top = popupPositionScratch[1] ) - runCatching { - gridPopup.update( - popupPositionScratch[0], - popupPositionScratch[1], - -1, - -1 - ) - } } } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlay.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlay.kt new file mode 100644 index 000000000..c624c2798 --- /dev/null +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlay.kt @@ -0,0 +1,165 @@ +package com.kazumaproject.custom_keyboard.controller + +import android.view.View +import android.view.ViewGroup +import android.view.ViewTreeObserver + +/** + * Draws keyboard popups in the same window and draw traversal as their key anchor. + * + * PopupWindow creates a child window whose relayout is committed independently from the IME + * window. That can expose an intermediate frame when the IME height changes. ViewGroupOverlay + * keeps popup drawing in the anchor's existing window, and this pre-draw callback places every + * visible popup after the current traversal has laid out the keyboard. + */ +internal class KeyboardPopupOverlay( + private val positionVisiblePopups: () -> Unit +) { + private val visibleViews = LinkedHashSet() + private var host: ViewGroup? = null + private var observedViewTree: ViewTreeObserver? = null + + private val preDrawListener = ViewTreeObserver.OnPreDrawListener { + if (visibleViews.isEmpty()) { + stopObserving() + } else { + positionVisiblePopups() + } + true + } + + val currentHost: ViewGroup? + get() = host + + fun show( + anchor: View, + preferredHost: View?, + popupView: View, + width: Int, + height: Int + ): Boolean { + if (!anchor.isAttachedToWindow) return false + val resolvedHost = resolveHost(anchor, preferredHost) ?: return false + if (!resolvedHost.isAttachedToWindow) return false + + if (host !== resolvedHost) { + removeAllViews() + host = resolvedHost + } + + measureExactly(popupView, width, height) + if (visibleViews.add(popupView)) { + resolvedHost.overlay.add(popupView) + } + startObserving(resolvedHost) + + // Place before the first invalidation as well as immediately before each later draw. + positionVisiblePopups() + resolvedHost.invalidate() + return true + } + + fun isShowing(popupView: View): Boolean = popupView in visibleViews + + fun place( + popupView: View, + left: Int, + top: Int, + width: Int = popupView.measuredWidth, + height: Int = popupView.measuredHeight + ) { + if (popupView !in visibleViews) return + val resolvedWidth = width.coerceAtLeast(1) + val resolvedHeight = height.coerceAtLeast(1) + if ( + popupView.measuredWidth != resolvedWidth || + popupView.measuredHeight != resolvedHeight + ) { + measureExactly(popupView, resolvedWidth, resolvedHeight) + } + popupView.layout( + left, + top, + left + resolvedWidth, + top + resolvedHeight + ) + } + + fun dismiss(popupView: View) { + if (!visibleViews.remove(popupView)) return + host?.overlay?.remove(popupView) + if (visibleViews.isEmpty()) { + stopObserving() + host = null + } + } + + fun dismissAll() { + removeAllViews() + host = null + } + + private fun resolveHost(anchor: View, preferredHost: View?): ViewGroup? { + val anchorRoot = anchor.rootView + val preferredGroup = preferredHost as? ViewGroup + if (preferredGroup != null && preferredGroup.rootView === anchorRoot) { + return preferredGroup + } + return anchorRoot as? ViewGroup + ?: generateSequence(anchor.parent) { parent -> + (parent as? View)?.parent + }.filterIsInstance().lastOrNull() + } + + private fun startObserving(resolvedHost: ViewGroup) { + val observer = resolvedHost.viewTreeObserver + if (observedViewTree === observer && observer.isAlive) return + + stopObserving() + if (!observer.isAlive) return + observedViewTree = observer + observer.addOnPreDrawListener(preDrawListener) + } + + private fun stopObserving() { + observedViewTree?.let { observer -> + if (observer.isAlive) { + observer.removeOnPreDrawListener(preDrawListener) + } + } + observedViewTree = null + } + + private fun removeAllViews() { + val currentHost = host + if (currentHost != null) { + visibleViews.forEach(currentHost.overlay::remove) + } + visibleViews.clear() + stopObserving() + } + + private fun measureExactly(view: View, width: Int, height: Int) { + view.measure( + View.MeasureSpec.makeMeasureSpec(width.coerceAtLeast(1), View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(height.coerceAtLeast(1), View.MeasureSpec.EXACTLY) + ) + } +} + +internal fun getLocationRelativeToOverlayHost( + keyAnchor: View, + overlayHost: View, + outLocation: IntArray, + keyLocationScratch: IntArray, + hostLocationScratch: IntArray +) { + require(outLocation.size >= 2) + require(keyLocationScratch.size >= 2) + require(hostLocationScratch.size >= 2) + + keyAnchor.getLocationOnScreen(keyLocationScratch) + overlayHost.getLocationOnScreen(hostLocationScratch) + outLocation[0] = keyLocationScratch[0] - hostLocationScratch[0] + outLocation[1] = keyLocationScratch[1] - hostLocationScratch[1] +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt index 146490d8e..9be6384e1 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt @@ -266,7 +266,7 @@ class FlickKeyboardView @JvmOverloads constructor( fun setPopupWindowAnchorProvider(provider: (() -> View?)?) { popupWindowAnchorProvider = provider flickControllers.forEach { it.setPopupWindowAnchorProvider(provider) } - crossFlickControllers.forEach { it.setPopupWindowAnchorProvider(provider) } + crossFlickControllers.forEach { it.setPopupOverlayHostProvider(provider) } standardFlickControllers.forEach { it.setPopupWindowAnchorProvider(provider) } tfbiControllers.forEach { it.setPopupWindowAnchorProvider(provider) } flickLongPressControllers.forEach { it.setPopupWindowAnchorProvider(provider) } @@ -1537,7 +1537,7 @@ class FlickKeyboardView @JvmOverloads constructor( context = context, gestureConfigSource = gestureSessionConfigSource ).apply { - setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setPopupOverlayHostProvider(popupWindowAnchorProvider) setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyleSet( popupViewStyleSet.directional, @@ -1877,7 +1877,7 @@ class FlickKeyboardView @JvmOverloads constructor( context = context, gestureConfigSource = gestureSessionConfigSource ).apply { - setPopupWindowAnchorProvider(popupWindowAnchorProvider) + setPopupOverlayHostProvider(popupWindowAnchorProvider) setInputTextTransform(::transformInputTextForDisplay) applyPopupViewStyleSet( popupViewStyleSet.directional, diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupCacheTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupCacheTest.kt index 539a6ab05..c6305ceec 100644 --- a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupCacheTest.kt +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupCacheTest.kt @@ -3,8 +3,8 @@ package com.kazumaproject.custom_keyboard.controller import android.content.Context import android.view.ContextThemeWrapper import android.view.MotionEvent +import android.view.View import android.widget.Button -import android.widget.PopupWindow import androidx.test.core.app.ApplicationProvider import com.kazumaproject.custom_keyboard.data.FlickDirection import com.kazumaproject.custom_keyboard.data.KeyAction @@ -81,11 +81,11 @@ class CrossFlickInputControllerPopupCacheTest { @Suppress("UNCHECKED_CAST") private fun CrossFlickInputController.directionalPopups(): - Map { + Map { val field = CrossFlickInputController::class.java .getDeclaredField("directionalPopupMap") .apply { isAccessible = true } - return field.get(this) as Map + return field.get(this) as Map } } diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt index a5cf6861c..1de844e1a 100644 --- a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputControllerPopupPositionTest.kt @@ -14,21 +14,58 @@ import org.robolectric.annotation.Config class CrossFlickInputControllerPopupPositionTest { @Test - fun normalKeyboardUsesWindowCoordinatesWhenSystemInsetMovesWindowOrigin() { + fun popupCoordinatesAreRelativeToOverlayHost() { + val context = ApplicationProvider.getApplicationContext() val key = LocatedView( - context = ApplicationProvider.getApplicationContext(), + context = context, screenLocation = intArrayOf(560, 599), windowLocation = intArrayOf(434, 599) ) + val overlayHost = LocatedView( + context = context, + screenLocation = intArrayOf(126, 95), + windowLocation = intArrayOf(0, 0) + ) + + assertArrayEquals( + intArrayOf(434, 504), + readPopupAnchorLocation(keyAnchor = key, overlayHost = overlayHost) + ) + } + + @Test + fun popupCoordinatesRemainStableWhenAnchorAndHostWindowMoveTogether() { + val context = ApplicationProvider.getApplicationContext() + val beforeMoveKey = LocatedView( + context = context, + screenLocation = intArrayOf(760, 640), + windowLocation = intArrayOf(760, 640) + ) + val beforeMoveHost = LocatedView( + context = context, + screenLocation = intArrayOf(120, 80), + windowLocation = intArrayOf(120, 80) + ) + val afterMoveKey = LocatedView( + context = context, + screenLocation = intArrayOf(760, 735), + windowLocation = intArrayOf(760, 735) + ) + val afterMoveHost = LocatedView( + context = context, + screenLocation = intArrayOf(120, 175), + windowLocation = intArrayOf(120, 175) + ) assertArrayEquals( - intArrayOf(434, 599), - readPopupAnchorLocation(keyAnchor = key, windowAnchor = key) + readPopupAnchorLocation(beforeMoveKey, beforeMoveHost), + readPopupAnchorLocation(afterMoveKey, afterMoveHost) ) } @Test - fun floatingKeyboardUsesCoordinatesRelativeToProvidedWindowAnchor() { + @Config(qualifiers = "land") + fun overlayCoordinateRuleDoesNotChangeWithOrientation() { val context = ApplicationProvider.getApplicationContext() val key = LocatedView( context = context, @@ -43,13 +80,13 @@ class CrossFlickInputControllerPopupPositionTest { assertArrayEquals( intArrayOf(640, 560), - readPopupAnchorLocation(keyAnchor = key, windowAnchor = windowAnchor) + readPopupAnchorLocation(keyAnchor = key, overlayHost = windowAnchor) ) } private fun readPopupAnchorLocation( keyAnchor: View, - windowAnchor: View + overlayHost: View ): IntArray { val controller = CrossFlickInputController( context = ApplicationProvider.getApplicationContext(), @@ -62,7 +99,7 @@ class CrossFlickInputControllerPopupPositionTest { ).apply { isAccessible = true } - method.invoke(controller, keyAnchor, windowAnchor) + method.invoke(controller, keyAnchor, overlayHost) return CrossFlickInputController::class.java .getDeclaredField("popupAnchorLocation") diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlayTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlayTest.kt new file mode 100644 index 000000000..b6b59fcf9 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/controller/KeyboardPopupOverlayTest.kt @@ -0,0 +1,74 @@ +package com.kazumaproject.custom_keyboard.controller + +import android.app.Activity +import android.view.View +import android.widget.FrameLayout +import android.widget.PopupWindow +import androidx.test.core.app.ApplicationProvider +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class KeyboardPopupOverlayTest { + + @Test + fun crossFlickControllerDoesNotRetainPopupWindowState() { + val hasPopupWindowField = CrossFlickInputController::class.java.declaredFields.any { + PopupWindow::class.java.isAssignableFrom(it.type) + } + + assertFalse(hasPopupWindowField) + } + + @Test + fun visiblePopupIsPlacedAgainInTheSamePreDrawAsAnchorMovement() { + val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + val host = FrameLayout(activity) + val anchor = View(activity) + val popup = View(activity) + activity.setContentView(host) + host.addView(anchor, FrameLayout.LayoutParams(100, 60)) + host.measure(exactly(500), exactly(500)) + host.layout(0, 0, 500, 500) + anchor.layout(40, 300, 140, 360) + + lateinit var overlay: KeyboardPopupOverlay + overlay = KeyboardPopupOverlay { + overlay.place( + popupView = popup, + left = anchor.left, + top = anchor.top - 60, + width = 100, + height = 60 + ) + } + + assertTrue( + overlay.show( + anchor = anchor, + preferredHost = host, + popupView = popup, + width = 100, + height = 60 + ) + ) + assertEquals(240, popup.top) + + anchor.layout(40, 205, 140, 265) + host.viewTreeObserver.dispatchOnPreDraw() + + assertEquals(145, popup.top) + overlay.dismiss(popup) + assertFalse(overlay.isShowing(popup)) + } + + private fun exactly(size: Int): Int = + View.MeasureSpec.makeMeasureSpec(size, View.MeasureSpec.EXACTLY) +} From cec765f29e21c3a0c10fe26d95db521e80d359ee Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Wed, 29 Jul 2026 19:55:39 -0400 Subject: [PATCH 06/24] Add delete long-press conversion setting --- .../DeleteLongPressConversionBehavior.kt | 28 ++++++ .../DeleteLongPressConversionGate.kt | 62 +++++++++++++ .../ime_service/IMEService.kt | 89 +++++++++++++++++-- .../setting_activity/AppPreference.kt | 13 +++ app/src/main/res/values-ja/strings.xml | 3 + app/src/main/res/values/arrays.xml | 10 +++ app/src/main/res/values/strings.xml | 3 + app/src/main/res/xml/pref_common_legacy.xml | 9 ++ .../main/res/xml/pref_operation_feedback.xml | 9 ++ .../DeleteLongPressConversionBehaviorTest.kt | 34 +++++++ .../DeleteLongPressConversionGateTest.kt | 55 ++++++++++++ 11 files changed, 308 insertions(+), 7 deletions(-) create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionBehavior.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionGate.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionBehaviorTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionGateTest.kt diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionBehavior.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionBehavior.kt new file mode 100644 index 000000000..0420dd9a8 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionBehavior.kt @@ -0,0 +1,28 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service + +/** + * Controls only candidate conversion and composing presentation during delete repeat. + * + * The repeat interval and the actual deletion algorithm are shared by both behaviors. + */ +internal enum class DeleteLongPressConversionBehavior( + val preferenceValue: String, + val suspendsCandidateResultsDuringRepeat: Boolean, +) { + Deferred( + preferenceValue = "deferred", + suspendsCandidateResultsDuringRepeat = true, + ), + Continuous( + preferenceValue = "continuous", + suspendsCandidateResultsDuringRepeat = false, + ); + + companion object { + val Default = Deferred + + fun fromPreferenceValue(value: String?): DeleteLongPressConversionBehavior { + return entries.firstOrNull { it.preferenceValue == value } ?: Default + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionGate.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionGate.kt new file mode 100644 index 000000000..2ecf1c186 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/DeleteLongPressConversionGate.kt @@ -0,0 +1,62 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service + +import com.kazumaproject.markdownhelperkeyboard.ime_service.models.CandidateShowFlag + +/** + * Coordinates composing-text presentation and candidate conversion while delete is repeating. + * + * Candidate results stay suspended after the finger is released until the replacement refresh + * actually starts. This closes the small window in which an older asynchronous result could + * otherwise be applied between ACTION_UP and collection of the final refresh request. + */ +internal class DeleteLongPressConversionGate { + @Volatile + private var repeating = false + + @Volatile + private var candidateResultsSuspended = false + + @Synchronized + fun beginRepeat(): Boolean { + if (repeating) return false + repeating = true + candidateResultsSuspended = true + return true + } + + fun shouldRenderRawComposing(input: String): Boolean { + return repeating && input.isNotEmpty() + } + + fun mayApplyCandidateResult(): Boolean = !candidateResultsSuspended + + /** + * Ends a real repeat session and returns the single refresh to issue after ACTION_UP. + * + * The result suspension is intentionally retained here. It is released only when the returned + * refresh starts being collected. + */ + @Synchronized + fun finishRepeat(input: String): CandidateShowFlag? { + if (!repeating) return null + repeating = false + return if (input.isEmpty()) { + CandidateShowFlag.Idle + } else { + CandidateShowFlag.Updating + } + } + + /** + * Called at the beginning of candidate refresh collection. + * + * Requests observed during the repeat must not reopen the gate. The one issued after release + * does, after collectLatest has cancelled and joined the previous request. + */ + @Synchronized + fun onCandidateRefreshStarted() { + if (!repeating) { + candidateResultsSuspended = false + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 8dc4ff992..f9e79cce0 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -744,6 +744,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, AppPreference.SUMIRE_KEYMAP_GUIDE_NUMBER_KEY, AppPreference.CUSTOM_KEYMAP_GUIDE_KEY, AppPreference.LONG_PRESS_TIMEOUT_KEY, + AppPreference.DELETE_LONG_PRESS_CONVERSION_BEHAVIOR_KEY, AppPreference.VIBRATION_KEY, AppPreference.VIBRATION_TIMING_KEY, AppPreference.KEY_SOUND_KEY, @@ -1212,6 +1213,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, emptyList() private var deleteLongPressJob: Job? = null + private val deleteLongPressConversionGate = DeleteLongPressConversionGate() private var rightLongPressJob: Job? = null private var leftLongPressJob: Job? = null private var candidateTranslationJob: Job? = null @@ -1333,6 +1335,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private var flickThresholdShapePreferenceValue: FlickThresholdShape = FlickThresholdShape.Radial private var longPressTimeoutPreferenceValue: Int? = 300 + private var deleteLongPressConversionBehavior = + DeleteLongPressConversionBehavior.Default + private var activeDeleteLongPressConversionBehavior: + DeleteLongPressConversionBehavior? = null private var tenkeyShowIMEButtonPreference: Boolean? = true private var qwertyShowIMEButtonPreference: Boolean? = true private var qwertyShowEmojiButtonPreference: Boolean? = false @@ -2270,6 +2276,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, flickSensitivityPreferenceValue = sensitivity flickThresholdShapePreferenceValue = thresholdShape longPressTimeoutPreferenceValue = longPressTimeout + deleteLongPressConversionBehavior = + DeleteLongPressConversionBehavior.fromPreferenceValue( + appPreference.delete_long_press_conversion_behavior + ) isVibration = appPreference.vibration_preference ?: true vibrationTimingStr = appPreference.vibration_timing_preference ?: "both" isKeySoundEnabled = appPreference.key_sound_preference ?: false @@ -14277,6 +14287,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, launch { var prevFlag: CandidateShowFlag? = null candidateRefreshRequests.collectLatest { request -> + deleteLongPressConversionGate.onCandidateRefreshStarted() val currentFlag = request.flag val insertString = request.input Timber.d( @@ -15286,7 +15297,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, requestInput: String, token: CandidateRequestToken? = null, ): Boolean { - return !suppressSuggestions && + return deleteLongPressConversionGate.mayApplyCandidateResult() && + !suppressSuggestions && requestInput.isNotEmpty() && inputString.value == requestInput && (token == null || candidateRequestTracker.isCurrent(token)) @@ -16178,6 +16190,12 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } else { clearBunsetsuReconversionDraft() } + if (deleteLongPressConversionGate.shouldRenderRawComposing(string)) { + Timber.d("deleteLongPress: render raw composing input=[%s]", string) + applyRawComposingFallback(string) + refreshReconversionUi() + return + } if (suppressSuggestions) { setComposingText(string, 1) refreshReconversionUi() @@ -17198,7 +17216,11 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val henkanActive = isHenkan.get() val tailIsEmpty = stringInTail.get().isEmpty() val shouldCommitIdle = !bunsetusMultipleDetect || tailIsEmpty - if (!henkanActive && shouldCommitIdle) { + if ( + !henkanActive && + shouldCommitIdle && + deleteLongPressConversionGate.mayApplyCandidateResult() + ) { requestCandidateRefresh(CandidateShowFlag.Idle) } } @@ -22569,6 +22591,15 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, invalidateZeroQueryForEditorMutation() if (isKeyboardLayoutEditModeActive()) return if (deleteLongPressJob?.isActive == true) return + val behavior = deleteLongPressConversionBehavior + activeDeleteLongPressConversionBehavior = behavior + if (behavior.suspendsCandidateResultsDuringRepeat) { + if (!deleteLongPressConversionGate.beginRepeat()) { + activeDeleteLongPressConversionBehavior = null + return + } + candidateRequestTracker.invalidate() + } activeDeleteHistoryBatch = DeleteHistoryBatch( initialInput = inputString.value, initialTail = stringInTail.get(), @@ -22596,7 +22627,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val newString = current.dropLast(1) _inputString.update { newString } if (newString.isEmpty() && tailIsEmpty) { - setComposingText("", 0) + clearStyledComposingTextAfterFinalDelete(current) } } @@ -22604,10 +22635,17 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } // （連続タップ入力解除など） enableContinuousTapInput() - - val flag = if (inputString.value.isEmpty()) CandidateShowFlag.Idle - else CandidateShowFlag.Updating - requestCandidateRefresh(flag) + if ( + activeDeleteLongPressConversionBehavior == + DeleteLongPressConversionBehavior.Continuous + ) { + val refreshFlag = if (inputString.value.isEmpty()) { + CandidateShowFlag.Idle + } else { + CandidateShowFlag.Updating + } + requestCandidateRefresh(refreshFlag, inputString.value) + } } deleteLongPressJob?.invokeOnCompletion { if (selectMode.value || !isEditHistoryEnabled()) { @@ -22627,11 +22665,48 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } } + /** + * Removes the final composing character without collapsing composing spans to length zero. + * + * Some editor implementations warn when a styled composing range is replaced directly with an + * empty string. Finishing and deleting inside one batch removes those spans first and does not + * expose the temporary committed state to the display. + */ + private fun clearStyledComposingTextAfterFinalDelete(previousInput: String) { + beginBatchEdit() + try { + finishComposingText() + val codePointCount = previousInput.codePointCount(0, previousInput.length) + if (codePointCount > 0) { + deleteSurroundingTextInCodePoints(codePointCount, 0) + } + } finally { + endBatchEdit() + } + } + private fun stopDeleteLongPress() { deleteKeyLongKeyPressed.set(false) onDeleteLongPressUp.set(true) deleteLongPressJob?.cancel() deleteLongPressJob = null + if ( + activeDeleteLongPressConversionBehavior == + DeleteLongPressConversionBehavior.Deferred + ) { + val refreshFlag = deleteLongPressConversionGate.finishRepeat(inputString.value) + if (refreshFlag != null) { + enableContinuousTapInput() + candidateRequestTracker.invalidate() + Timber.d( + "deleteLongPress: resume candidate refresh once input=[%s] flag=%s", + inputString.value, + refreshFlag, + ) + requestCandidateRefresh(refreshFlag, inputString.value) + } + } + activeDeleteLongPressConversionBehavior = null } private fun enableContinuousTapInput() { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt index 601a81163..a45858b14 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt @@ -75,6 +75,8 @@ object AppPreference { const val SUMIRE_KEYMAP_GUIDE_NUMBER_KEY = "sumire_keymap_guide_number" const val CUSTOM_KEYMAP_GUIDE_KEY = "flick_keymap_guide" const val LONG_PRESS_TIMEOUT_KEY = "long_press_timeout_preference" + const val DELETE_LONG_PRESS_CONVERSION_BEHAVIOR_KEY = + "delete_long_press_conversion_behavior" const val VIBRATION_KEY = "vibration_preference" const val VIBRATION_TIMING_KEY = "vibration_timing" const val KEY_SOUND_KEY = "key_sound_preference" @@ -98,6 +100,8 @@ object AppPreference { FlickThresholdShape.Radial.preferenceValue ) private val LONG_PRESS_TIMEOUT = Pair(LONG_PRESS_TIMEOUT_KEY, 300) + private val DELETE_LONG_PRESS_CONVERSION_BEHAVIOR = + Pair(DELETE_LONG_PRESS_CONVERSION_BEHAVIOR_KEY, "deferred") private val VIBRATION_PREFERENCE = Pair(VIBRATION_KEY, true) private val VIBRATION_TIMING_PREFERENCE = Pair(VIBRATION_TIMING_KEY, "both") private val KEY_SOUND_PREFERENCE = Pair(KEY_SOUND_KEY, false) @@ -1613,6 +1617,15 @@ object AppPreference { it.putInt(LONG_PRESS_TIMEOUT.first, value ?: 300) } + var delete_long_press_conversion_behavior: String + get() = preferences.getString( + DELETE_LONG_PRESS_CONVERSION_BEHAVIOR.first, + DELETE_LONG_PRESS_CONVERSION_BEHAVIOR.second, + ) ?: DELETE_LONG_PRESS_CONVERSION_BEHAVIOR.second + set(value) = preferences.edit { + it.putString(DELETE_LONG_PRESS_CONVERSION_BEHAVIOR.first, value) + } + var n_best_preference: Int? get() = preferences.getInt( N_BEST_PREFERENCE.first, N_BEST_PREFERENCE.second diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index f4d3aa609..4b7f4b054 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -203,6 +203,9 @@ 長押し時間 長押しと判定するまでの時間を変更します。 %1$d ms + 削除キー長押し時の変換方式 + スムーズ（推奨）：指を離した後に1回変換 + 従来方式：1文字削除するたびにライブ変換 ローマ字変換のカスタマイズ ローマ字の変換表を作成、選択します diff --git a/app/src/main/res/values/arrays.xml b/app/src/main/res/values/arrays.xml index 55f475e7c..1f688d490 100644 --- a/app/src/main/res/values/arrays.xml +++ b/app/src/main/res/values/arrays.xml @@ -1,5 +1,15 @@ + + @string/delete_long_press_conversion_behavior_deferred + @string/delete_long_press_conversion_behavior_continuous + + + + deferred + continuous + + @string/physical_keyboard_input_mode_romaji @string/physical_keyboard_input_mode_kana diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 1f0d3150a..87529cca1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -204,6 +204,9 @@ Long-press Time Adjust how long a key must be held before long-press is triggered. %1$d ms + Conversion while holding Delete + Smooth (recommended): convert once after release + Legacy: live-convert after every deletion Customize Romaji Conversion Create and select a Romaji conversion table diff --git a/app/src/main/res/xml/pref_common_legacy.xml b/app/src/main/res/xml/pref_common_legacy.xml index 5283ae064..6eacfcfa5 100644 --- a/app/src/main/res/xml/pref_common_legacy.xml +++ b/app/src/main/res/xml/pref_common_legacy.xml @@ -714,6 +714,15 @@ android:summary="@string/long_press_timeout_preference_summary" android:title="@string/long_press_timeout_preference_title" /> + + diff --git a/app/src/main/res/xml/pref_operation_feedback.xml b/app/src/main/res/xml/pref_operation_feedback.xml index 45ad3c061..944baaf86 100644 --- a/app/src/main/res/xml/pref_operation_feedback.xml +++ b/app/src/main/res/xml/pref_operation_feedback.xml @@ -54,6 +54,15 @@ + + Date: Wed, 29 Jul 2026 19:10:08 -0400 Subject: [PATCH 07/24] add setting for full screen --- README.md | 1 + ...referenceClassificationInstrumentedTest.kt | 23 ++++++++ .../ime_service/FullscreenModePolicy.kt | 15 ++++++ .../ime_service/IMEService.kt | 24 ++++----- .../setting_activity/AppPreference.kt | 4 ++ .../ui/setting/SettingSearchIndex.kt | 17 +++++- app/src/main/res/values-ja/strings.xml | 2 + app/src/main/res/values/strings.xml | 2 + app/src/main/res/xml/pref_common_legacy.xml | 6 +++ .../main/res/xml/pref_keyboard_display.xml | 6 +++ .../ime_service/FullscreenModePolicyTest.kt | 53 +++++++++++++++++++ 11 files changed, 140 insertions(+), 13 deletions(-) create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/FullscreenModePolicy.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/FullscreenModePolicyTest.kt diff --git a/README.md b/README.md index 2bb180346..4586d6873 100644 --- a/README.md +++ b/README.md @@ -114,6 +114,7 @@ Sumireは、**プライバシーを絶対に妥協しない** | キーボード | キーボードの選択 | 画面/操作 | | キーボード | 位置とサイズの設定(縦画面) | 画面/操作 | | キーボード | 位置とサイズの設定(横画面) | 画面/操作 | +| キーボード | 横画面で全画面入力を許可 | 通常端末: OFF / small端末: ON | | キーボード | キー・変換候補の文字サイズ | 画面/操作 | | キーボード | キーボード背景画像 | 画面/操作 | | キーボード | 背景画像の表示方法 | フィット | diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingInlinePreferenceClassificationInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingInlinePreferenceClassificationInstrumentedTest.kt index d319279a5..17b7be32f 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingInlinePreferenceClassificationInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingInlinePreferenceClassificationInstrumentedTest.kt @@ -42,6 +42,29 @@ class SettingInlinePreferenceClassificationInstrumentedTest { assertEquals(R.id.keyboardDisplayPreferenceFragment, target.destinationId) } + @Test + fun fullscreenPreferenceUsesDeviceResourceDefaultInSearchAndAppPreference() { + val key = AppPreference.ALLOW_FULLSCREEN_MODE_KEY + val deviceDefault = context.resources.getBoolean(R.bool.config_allow_fullscreen_mode) + val target = destinationForKey(key).destination as SettingDestinationType.SwitchPreference + val preferences = PreferenceManager.getDefaultSharedPreferences(context) + + assertEquals(deviceDefault, target.defaultValue) + assertEquals(deviceDefault, AppPreference.isFullscreenModeAllowed(deviceDefault)) + + preferences.edit().putBoolean(key, !deviceDefault).commit() + + assertEquals(!deviceDefault, AppPreference.isFullscreenModeAllowed(deviceDefault)) + } + + @Test + fun fullscreenPreferenceIsAvailableInNewAndLegacySettings() { + val key = AppPreference.ALLOW_FULLSCREEN_MODE_KEY + + assertTrue(key in realPreferenceKeys(listOf(R.xml.pref_keyboard_display))) + assertTrue(key in realPreferenceKeys(listOf(R.xml.pref_common_legacy))) + } + @Test fun listPreferenceXmlItemIsClassifiedWithEntriesAndEntryValues() { val destination = destinationForKey("candidate_column_preference") diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/FullscreenModePolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/FullscreenModePolicy.kt new file mode 100644 index 000000000..0d30fa008 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/FullscreenModePolicy.kt @@ -0,0 +1,15 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service + +import android.view.inputmethod.EditorInfo + +internal object FullscreenModePolicy { + + fun shouldUseFullscreenMode( + frameworkRequestsFullscreen: Boolean, + fullscreenModeAllowed: Boolean, + imeOptions: Int, + ): Boolean = + frameworkRequestsFullscreen && + fullscreenModeAllowed && + imeOptions and EditorInfo.IME_FLAG_NO_EXTRACT_UI == 0 +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index f9e79cce0..f6d913f46 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -4916,18 +4916,18 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, override fun onEvaluateFullscreenMode(): Boolean { - val isFullscreenModeAllowed: Boolean = - resources.getBoolean(R.bool.config_allow_fullscreen_mode) - - if (super.onEvaluateFullscreenMode() && isFullscreenModeAllowed) { - // TODO: Remove this hack. Actually we should not really assume NO_EXTRACT_UI - // implies NO_FULLSCREEN. However, the framework mistakenly does. i.e. NO_EXTRACT_UI - // without NO_FULLSCREEN doesn't work as expected. Because of this we need this - // hack for now. Let's get rid of this once the framework gets fixed. - val ei = getCurrentInputEditorInfo() - return !(ei != null && ((ei.imeOptions and EditorInfo.IME_FLAG_NO_EXTRACT_UI) != 0)) - } - return false + val deviceDefault = resources.getBoolean(R.bool.config_allow_fullscreen_mode) + val isFullscreenModeAllowed = + appPreference.isFullscreenModeAllowed(defaultValue = deviceDefault) + val imeOptions = currentInputEditorInfo?.imeOptions ?: 0 + + // Keep treating NO_EXTRACT_UI as NO_FULLSCREEN. Android's framework does not + // reliably support the former without the latter. + return FullscreenModePolicy.shouldUseFullscreenMode( + frameworkRequestsFullscreen = super.onEvaluateFullscreenMode(), + fullscreenModeAllowed = isFullscreenModeAllowed, + imeOptions = imeOptions, + ) } /** diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt index a45858b14..fd942a447 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt @@ -81,6 +81,7 @@ object AppPreference { const val VIBRATION_TIMING_KEY = "vibration_timing" const val KEY_SOUND_KEY = "key_sound_preference" const val KEY_SOUND_VOLUME_PERCENT_KEY = "key_sound_volume_percent_preference" + const val ALLOW_FULLSCREEN_MODE_KEY = "allow_fullscreen_mode_preference" private const val MIN_CANDIDATE_VISIBLE_HEIGHT_DP = 30 private const val MAX_CANDIDATE_VISIBLE_HEIGHT_DP = 300 @@ -1325,6 +1326,9 @@ object AppPreference { it.putBoolean(LANDSCAPE_FORCE_QWERTY_PREFERENCE.first, value) } + fun isFullscreenModeAllowed(defaultValue: Boolean): Boolean = + preferences.getBoolean(ALLOW_FULLSCREEN_MODE_KEY, defaultValue) + var landscape_force_qwerty_romaji_preference: Boolean get() = preferences.getBoolean( LANDSCAPE_FORCE_QWERTY_ROMAJI_PREFERENCE.first, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingSearchIndex.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingSearchIndex.kt index 9ec0959f6..c3b8f1104 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingSearchIndex.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingSearchIndex.kt @@ -478,7 +478,12 @@ object SettingSearchIndex { "SwitchPreferenceCompat", "SwitchPreference" -> SettingDestinationType.SwitchPreference( preferenceKey = key, - defaultValue = readBooleanAttribute(parser, "defaultValue", defaultValue = false), + defaultValue = readBooleanAttribute( + context = context, + parser = parser, + name = "defaultValue", + defaultValue = false, + ), destinationId = destinationId, highlightPreferenceKey = highlightPreferenceKey ?: key, ) @@ -610,10 +615,20 @@ object SettingSearchIndex { } private fun readBooleanAttribute( + context: Context, parser: XmlResourceParser, name: String, defaultValue: Boolean, ): Boolean { + listOf(ANDROID_NS, APP_NS).forEach { namespace -> + val resourceId = parser.getAttributeResourceValue(namespace, name, 0) + if (resourceId != 0) { + return runCatching { + context.resources.getBoolean(resourceId) + }.getOrDefault(defaultValue) + } + } + val raw = parser.getAttributeValue(ANDROID_NS, name) ?: parser.getAttributeValue(APP_NS, name) ?: return defaultValue diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 4b7f4b054..8e1ba5c8a 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -120,6 +120,8 @@ 右上を角丸にする 左下を角丸にする 右下を角丸にする + 横画面で全画面入力を許可 + 横画面で、Androidが必要と判断した場合に入力画面を全画面表示します。 横画面では常に QWERTY に切り替える 端末が横画面のとき、一時的に QWERTY キーボードへ切り替えます。 横画面 QWERTY の入力モード diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 87529cca1..c5ef85df1 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -119,6 +119,8 @@ Round top-right corner Round bottom-left corner Round bottom-right corner + Allow fullscreen input in landscape + Allow Android to use a fullscreen input view in landscape when needed. Always use QWERTY in landscape When the device is in landscape, temporarily switch to a QWERTY keyboard. Landscape QWERTY input mode diff --git a/app/src/main/res/xml/pref_common_legacy.xml b/app/src/main/res/xml/pref_common_legacy.xml index 6eacfcfa5..7bc0a1016 100644 --- a/app/src/main/res/xml/pref_common_legacy.xml +++ b/app/src/main/res/xml/pref_common_legacy.xml @@ -44,6 +44,12 @@ android:summary="@string/keyboard_screen_preference_summary" android:title="@string/keyboard_screen_landscape_size_preference_title" /> + + + + Date: Wed, 29 Jul 2026 19:58:51 -0400 Subject: [PATCH 08/24] Align dictionary label test expectations --- .../adapters/SuggestionAdapterUserTemplateTypeTest.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapterUserTemplateTypeTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapterUserTemplateTypeTest.kt index 039822570..f76b436cd 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapterUserTemplateTypeTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/adapters/SuggestionAdapterUserTemplateTypeTest.kt @@ -116,7 +116,7 @@ class SuggestionAdapterUserTemplateTypeTest { awaitItemCount(adapter, 3) val holder = createHolder(adapter) - val expected = listOf("学習", "ユーザー", "定型") + val expected = listOf("[学習]", "[ユーザー]", "[定型]") expected.forEachIndexed { position, label -> adapter.onBindViewHolder(holder, position) assertEquals(label, holder.typeText.text.toString()) @@ -136,7 +136,7 @@ class SuggestionAdapterUserTemplateTypeTest { val holder = createHolder(adapter) adapter.onBindViewHolder(holder, 0) - assertEquals("定型", holder.typeText.text.toString()) + assertEquals("[定型]", holder.typeText.text.toString()) adapter.setShowDictionaryCandidateLabels(false) adapter.onBindViewHolder(holder, 0) From cd584a1e0ad21d334bca51b3918c52bd169c8714 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Fri, 31 Jul 2026 20:48:01 -0400 Subject: [PATCH 09/24] fix initial keyboard to select --- .../setting_activity/AppPreference.kt | 5 +- .../AppPreferenceKeyboardOrderTest.kt | 46 +++++++++++++++++++ 2 files changed, 47 insertions(+), 4 deletions(-) create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreferenceKeyboardOrderTest.kt diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt index fd942a447..50ba89748 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt @@ -381,10 +381,7 @@ object AppPreference { private val defaultKeyboardOrderJson = gson.toJson( listOf( KeyboardType.TENKEY, - KeyboardType.SUMIRE, - KeyboardType.QWERTY, - KeyboardType.ROMAJI, - KeyboardType.CUSTOM + KeyboardType.QWERTY ) ) private val KEYBOARD_ORDER = Pair("keyboard_order_preference", defaultKeyboardOrderJson) diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreferenceKeyboardOrderTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreferenceKeyboardOrderTest.kt new file mode 100644 index 000000000..7c7c65941 --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreferenceKeyboardOrderTest.kt @@ -0,0 +1,46 @@ +package com.kazumaproject.markdownhelperkeyboard.setting_activity + +import android.content.Context +import android.content.SharedPreferences +import androidx.preference.PreferenceManager +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.markdownhelperkeyboard.ime_service.state.KeyboardType +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class AppPreferenceKeyboardOrderTest { + private lateinit var context: Context + private lateinit var preferences: SharedPreferences + + @Before + fun setUp() { + context = ApplicationProvider.getApplicationContext() + preferences = PreferenceManager.getDefaultSharedPreferences(context) + preferences.edit().clear().commit() + AppPreference.init(context) + } + + @Test + fun freshInstallDefaultsToTenKeyAndQwertyOnly() { + assertEquals( + listOf(KeyboardType.TENKEY, KeyboardType.QWERTY), + AppPreference.keyboard_order + ) + } + + @Test + fun savedKeyboardOrderIsPreserved() { + AppPreference.keyboard_order = listOf(KeyboardType.SUMIRE, KeyboardType.ROMAJI) + + assertEquals( + listOf(KeyboardType.SUMIRE, KeyboardType.ROMAJI), + AppPreference.keyboard_order + ) + } +} From 473be84fed2709a48120166b3f60c3d98d1cd403 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sat, 1 Aug 2026 00:06:56 -0400 Subject: [PATCH 10/24] fix hot start in sumire and qwerty --- .../converter/engine/EnglishEngine.kt | 92 +++++++++++++++++++ .../ime_service/IMEService.kt | 35 +++++-- ...glishEngineQwertyGlideConfigurationTest.kt | 59 ++++++++++++ .../core/domain/extensions/Drawable.kt | 6 +- .../custom_keyboard/view/FlickKeyboardView.kt | 77 ++++++++++++++-- .../view/FlickKeyboardViewReuseTest.kt | 55 +++++++++++ 6 files changed, 305 insertions(+), 19 deletions(-) create mode 100644 custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewReuseTest.kt diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt index b828e8453..dd6d76c6c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngine.kt @@ -20,6 +20,7 @@ import com.kazumaproject.markdownhelperkeyboard.dictionary_override.DictionaryFi import com.kazumaproject.qwerty_keyboard.glide.QwertyInputPointers import com.kazumaproject.qwerty_keyboard.glide.QwertyKeyboardProximityInfo import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.CoroutineStart import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job import kotlinx.coroutines.SupervisorJob @@ -261,6 +262,97 @@ class EnglishEngine : QwertyGlideCandidateProvider { } } + /** + * Loads the bundled glide index away from the IME main thread. + * + * Until the index is ready, glide input continues to use the small fallback decoder. Repeated + * input sessions share the in-flight job instead of restarting the same asset read. + */ + fun configureQwertyGlideDecoderAsync( + enabled: Boolean, + canUseBundledPrebuiltIndex: Boolean, + prebuiltDictionaryLoader: QwertyGlidePrebuiltDictionaryLoader?, + ) { + if (!enabled) { + configureQwertyGlideDecoder( + enabled = false, + canUseBundledPrebuiltIndex = canUseBundledPrebuiltIndex, + prebuiltDictionaryLoader = prebuiltDictionaryLoader, + ) + return + } + + synchronized(this) { + if ( + canUseBundledPrebuiltIndex && + qwertyGlideInputEnabled && + (qwertyGlideDictionaryReady && qwertyGlideDecoder != null || + qwertyGlideWarmupJob?.isActive == true) + ) { + return + } + qwertyGlideInputEnabled = true + cancelQwertyGlideWarmup() + qwertyGlideDecoder = null + qwertyGlideDictionaryReady = false + } + + if (!canUseBundledPrebuiltIndex || prebuiltDictionaryLoader == null) { + logQwertyGlidePrebuilt( + "External English dictionary override active, skip bundled prebuilt glide index" + ) + logQwertyGlidePrebuilt("Fallback to runtime glide dictionary build") + return + } + + val job = qwertyGlideWarmupScope.launch(start = CoroutineStart.LAZY) { + val startedAt = System.nanoTime() + val result = prebuiltDictionaryLoader.load() + if (!isActive) return@launch + when (result) { + is QwertyGlidePrebuiltLoadResult.Loaded -> { + val decoder = createQwertyGlideDecoder( + provider = result.provider, + dictionaryReady = true, + ) + if (!isActive) return@launch + synchronized(this@EnglishEngine) { + if (!isActive || !qwertyGlideInputEnabled) return@synchronized + qwertyGlideDecoder = decoder + qwertyGlideDictionaryReady = true + } + logQwertyGlidePrebuilt( + "Bundled prebuilt glide index loaded asynchronously: " + + "entries=${result.provider.entryCount} " + + "elapsed_ms=${(System.nanoTime() - startedAt) / 1_000_000L}" + ) + } + + is QwertyGlidePrebuiltLoadResult.NotAvailable -> { + logQwertyGlidePrebuilt( + "Bundled prebuilt glide index unavailable: ${result.reason}" + ) + logQwertyGlidePrebuilt("Fallback to runtime glide dictionary build") + } + + is QwertyGlidePrebuiltLoadResult.Invalid -> { + logQwertyGlidePrebuilt( + "Bundled prebuilt glide index invalid: ${result.reason}" + ) + logQwertyGlidePrebuilt("Fallback to runtime glide dictionary build") + } + } + } + synchronized(this) { + qwertyGlideWarmupJob = job + } + job.start() + } + + internal suspend fun awaitQwertyGlideWarmup() { + qwertyGlideWarmupJob?.join() + } + fun cancelQwertyGlideWarmup() { qwertyGlideWarmupJob?.cancel() qwertyGlideWarmupJob = null diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index f6d913f46..4e679da35 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -2189,7 +2189,6 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } } } else { - setupKeyboardView() scope.coroutineContext.cancelChildren() mainLayoutBinding?.let { mainView -> startScope(mainView) @@ -2407,13 +2406,20 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, englishEngine.invalidateQwertyGlideCache() currentQwertyGlideCompositionText = null } - englishEngine.configureQwertyGlideDecoder( - enabled = preferences.qwertyGlideInputPreference, - canUseBundledPrebuiltIndex = !dictionarySourceResolver.shouldUseOverrideCategory( - DictionaryCategory.ENGLISH - ), - prebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader(dictionarySourceResolver), - ) + val dictionaryReloadWillConfigureGlide = + dictionaryOverrideApplyJob?.isActive == true || + dictionaryOverrideStore.currentRevision != lastAppliedDictionaryOverrideRevision + if (!dictionaryReloadWillConfigureGlide) { + englishEngine.configureQwertyGlideDecoderAsync( + enabled = preferences.qwertyGlideInputPreference, + canUseBundledPrebuiltIndex = !dictionarySourceResolver.shouldUseOverrideCategory( + DictionaryCategory.ENGLISH + ), + prebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( + dictionarySourceResolver + ), + ) + } qwertyShowPopupWindowPreference = preferences.qwertyShowPopupWindowPreference qwertyEnableFlickUpPreference = preferences.qwertyEnableFlickUpPreference qwertyEnableFlickDownPreference = preferences.qwertyEnableFlickDownPreference @@ -2746,6 +2752,19 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, if (success) { lastAppliedDictionaryOverrideRevision = revisionToApply + } else { + // The regular reload also configures glide. If it failed before reaching that + // point, retain the lightweight asynchronous configuration as a fallback. + englishEngine.configureQwertyGlideDecoderAsync( + enabled = qwertyGlideInputPreference, + canUseBundledPrebuiltIndex = + !dictionarySourceResolver.shouldUseOverrideCategory( + DictionaryCategory.ENGLISH + ), + prebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( + dictionarySourceResolver + ), + ) } } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngineQwertyGlideConfigurationTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngineQwertyGlideConfigurationTest.kt index 91458bae1..6482a6c53 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngineQwertyGlideConfigurationTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/EnglishEngineQwertyGlideConfigurationTest.kt @@ -4,6 +4,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.glide.QwertyGlideIndex import com.kazumaproject.markdownhelperkeyboard.converter.glide.QwertyGlidePrebuiltDictionaryLoader import com.kazumaproject.markdownhelperkeyboard.converter.glide.characterMask import com.kazumaproject.markdownhelperkeyboard.converter.glide.transitionMask +import kotlinx.coroutines.runBlocking import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test @@ -12,6 +13,8 @@ import java.io.ByteArrayOutputStream import java.io.DataOutputStream import java.io.FileNotFoundException import java.io.InputStream +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit class EnglishEngineQwertyGlideConfigurationTest { @Test @@ -115,6 +118,62 @@ class EnglishEngineQwertyGlideConfigurationTest { assertTrue(engine.isQwertyGlideDictionaryReady()) } + @Test + fun asyncConfigurationLoadsPrebuiltWithoutBlockingCaller() = runBlocking { + val engine = EnglishEngine() + val loadStarted = CountDownLatch(1) + val allowLoadToFinish = CountDownLatch(1) + + engine.configureQwertyGlideDecoderAsync( + enabled = true, + canUseBundledPrebuiltIndex = true, + prebuiltDictionaryLoader = loader { + loadStarted.countDown() + check(allowLoadToFinish.await(2, TimeUnit.SECONDS)) + validIndex("an").inputStream() + }, + ) + + assertTrue(engine.isQwertyGlideInputEnabled()) + assertTrue(loadStarted.await(2, TimeUnit.SECONDS)) + assertFalse(engine.isQwertyGlideDictionaryReady()) + allowLoadToFinish.countDown() + engine.awaitQwertyGlideWarmup() + assertTrue(engine.isQwertyGlideDictionaryReady()) + assertTrue(engine.hasQwertyGlideDecoder()) + } + + @Test + fun repeatedAsyncConfigurationSharesInFlightLoad() = runBlocking { + var opens = 0 + val engine = EnglishEngine() + val loadStarted = CountDownLatch(1) + val allowLoadToFinish = CountDownLatch(1) + val prebuiltLoader = loader { + opens += 1 + loadStarted.countDown() + check(allowLoadToFinish.await(2, TimeUnit.SECONDS)) + validIndex("an").inputStream() + } + + engine.configureQwertyGlideDecoderAsync( + enabled = true, + canUseBundledPrebuiltIndex = true, + prebuiltDictionaryLoader = prebuiltLoader, + ) + assertTrue(loadStarted.await(2, TimeUnit.SECONDS)) + engine.configureQwertyGlideDecoderAsync( + enabled = true, + canUseBundledPrebuiltIndex = true, + prebuiltDictionaryLoader = prebuiltLoader, + ) + + allowLoadToFinish.countDown() + engine.awaitQwertyGlideWarmup() + assertTrue(engine.isQwertyGlideDictionaryReady()) + assertTrue(opens == 1) + } + private fun loader(openBundledIndex: () -> InputStream) = QwertyGlidePrebuiltDictionaryLoader( openBundledIndex = openBundledIndex, isBundledEnglishDictionaryActive = { true }, diff --git a/core/src/main/java/com/kazumaproject/core/domain/extensions/Drawable.kt b/core/src/main/java/com/kazumaproject/core/domain/extensions/Drawable.kt index 16f739b6c..5605f7478 100644 --- a/core/src/main/java/com/kazumaproject/core/domain/extensions/Drawable.kt +++ b/core/src/main/java/com/kazumaproject/core/domain/extensions/Drawable.kt @@ -176,8 +176,10 @@ fun View.setDrawableSolidColor(@ColorInt color: Int, index: Int = 0) { */ fun View.setDrawableAlpha(alpha: Int) { val background = this.background ?: return - // mutate() してこのView専用のインスタンスにする（他のViewへの影響を防ぐ） - background.mutate().alpha = alpha + // Key backgrounds are assigned per View. Mutating a nested LayerDrawable whose child has no + // ConstantState makes Android clone the layer hierarchy and emit an exception stack for every + // key. Alpha itself is a property of the top-level Drawable, so it can be updated directly. + background.alpha = alpha.coerceIn(0, 255) } /** diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt index 9be6384e1..b2daab04e 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt @@ -176,6 +176,8 @@ class FlickKeyboardView @JvmOverloads constructor( private val canonicalGuideLabels = IdentityHashMap() private var currentLayout: KeyboardLayout? = null + private var keyboardRenderRevision: Int = 0 + private var renderedKeyboardRenderRevision: Int = -1 private var keyCharacterCase: KeyCharacterCase = KeyCharacterCase.AS_DEFINED private var sumireSpecialKeyActionResolver: ((String, String, KeyData, SumireSpecialKeyDirection) -> ResolvedSumireSpecialKeyAction)? = @@ -356,21 +358,21 @@ class FlickKeyboardView @JvmOverloads constructor( } flickGuideEnabled = enabled flickGuideAllowsMultiCharacterLabels = allowMultiCharacterLabels - currentLayout?.let { setKeyboard(it) } + rebuildCurrentKeyboard() } fun setFlickGuideTextSizeSp(sizeSp: Float) { val coerced = sizeSp.coerceIn(6f, 16f) if (flickGuideTextSizeSp == coerced) return flickGuideTextSizeSp = coerced - currentLayout?.let { setKeyboard(it) } + rebuildCurrentKeyboard() } fun setFlickGuideMaxCodePoints(maxCodePoints: Int) { val coerced = maxCodePoints.coerceIn(1, 4) if (flickGuideMaxCodePoints == coerced) return flickGuideMaxCodePoints = coerced - currentLayout?.let { setKeyboard(it) } + rebuildCurrentKeyboard() } fun applyKeySizing( @@ -380,13 +382,27 @@ class FlickKeyboardView @JvmOverloads constructor( textSizeSp: Float, specialKeyTextSizeSp: Float ) { - this.keyWidthScalePercent = keyWidthScalePercent.coerceIn(0, 200) - this.keyHeightScalePercent = keyHeightScalePercent.coerceIn(0, 200) - this.iconScalePercent = iconScalePercent.coerceIn(40, 200) - this.defaultTextSize = textSizeSp.coerceIn(8f, 32f) - this.specialKeyTextSizeSp = specialKeyTextSizeSp.coerceIn(8f, 32f) + val normalizedWidthScale = keyWidthScalePercent.coerceIn(0, 200) + val normalizedHeightScale = keyHeightScalePercent.coerceIn(0, 200) + val normalizedIconScale = iconScalePercent.coerceIn(40, 200) + val normalizedTextSize = textSizeSp.coerceIn(8f, 32f) + val normalizedSpecialTextSize = specialKeyTextSizeSp.coerceIn(8f, 32f) + if ( + this.keyWidthScalePercent == normalizedWidthScale && + this.keyHeightScalePercent == normalizedHeightScale && + this.iconScalePercent == normalizedIconScale && + this.defaultTextSize == normalizedTextSize && + this.specialKeyTextSizeSp == normalizedSpecialTextSize + ) { + return + } + this.keyWidthScalePercent = normalizedWidthScale + this.keyHeightScalePercent = normalizedHeightScale + this.iconScalePercent = normalizedIconScale + this.defaultTextSize = normalizedTextSize + this.specialKeyTextSizeSp = normalizedSpecialTextSize - currentLayout?.let { setKeyboard(it) } + rebuildCurrentKeyboard() } fun setCursorMode(enabled: Boolean) { @@ -434,6 +450,21 @@ class FlickKeyboardView @JvmOverloads constructor( liquidGlassKeyAlphaEnable: Int, borderWidth: Int ) { + val renderConfigurationChanged = + this.themeMode != themeMode || + this.isNightMode != + (currentNightMode == Configuration.UI_MODE_NIGHT_YES) || + this.isDynamicColorEnabled != isDynamicColorEnabled || + this.customBgColor != customBgColor || + this.customKeyColor != customKeyColor || + this.customSpecialKeyColor != customSpecialKeyColor || + this.customKeyTextColor != customKeyTextColor || + this.customSpecialKeyTextColor != customSpecialKeyTextColor || + this.liquidGlassEnable != liquidGlassEnable || + this.customBorderEnable != customBorderEnable || + this.customBorderColor != customBorderColor || + this.liquidGlassKeyAlphaEnable != liquidGlassKeyAlphaEnable || + this.borderWidth != borderWidth this.themeMode = themeMode this.isNightMode = (currentNightMode == Configuration.UI_MODE_NIGHT_YES) this.isDynamicColorEnabled = isDynamicColorEnabled @@ -447,6 +478,9 @@ class FlickKeyboardView @JvmOverloads constructor( this.customBorderColor = customBorderColor this.liquidGlassKeyAlphaEnable = liquidGlassKeyAlphaEnable this.borderWidth = borderWidth + if (renderConfigurationChanged) { + keyboardRenderRevision += 1 + } if (liquidGlassEnable) { this.setBackgroundColor(ColorUtils.setAlphaComponent(customBgColor, 0)) @@ -505,6 +539,29 @@ class FlickKeyboardView @JvmOverloads constructor( @SuppressLint("ClickableViewAccessibility") fun setKeyboard(layout: KeyboardLayout) { + setKeyboard(layout, forceRebuild = false) + } + + private fun rebuildCurrentKeyboard() { + currentLayout?.let { setKeyboard(it, forceRebuild = true) } + } + + @SuppressLint("ClickableViewAccessibility") + private fun setKeyboard(layout: KeyboardLayout, forceRebuild: Boolean) { + val expectedChildCount = if (layout.items.isNotEmpty()) { + layout.items.size + } else { + layout.keys.size + } + if ( + !forceRebuild && + currentLayout == layout && + renderedKeyboardRenderRevision == keyboardRenderRevision && + childCount == expectedChildCount + ) { + Log.d("FlickKeyboardView", "setKeyboard (Reuse Existing Views)") + return + } Log.d("FlickKeyboardView", "setKeyboard (Full Rebuild)") doubleTapActionDispatcher.cancel() @@ -570,6 +627,7 @@ class FlickKeyboardView @JvmOverloads constructor( ) } } + renderedKeyboardRenderRevision = keyboardRenderRevision } private fun addKeyItem(item: KeyItem) { @@ -625,6 +683,7 @@ class FlickKeyboardView @JvmOverloads constructor( displayActions = KeyActionMapper.getDisplayActions(context), resolve = ::resolveSumireSpecialKeyOverride ) + if (info.keyData == newKeyData) return val oldView = info.view val newViewIsIcon = KeyIconResolver.hasIcon(newKeyData) diff --git a/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewReuseTest.kt b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewReuseTest.kt new file mode 100644 index 000000000..4e7a860b6 --- /dev/null +++ b/custom_keyboard/src/test/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardViewReuseTest.kt @@ -0,0 +1,55 @@ +package com.kazumaproject.custom_keyboard.view + +import android.view.ContextThemeWrapper +import androidx.test.core.app.ApplicationProvider +import com.kazumaproject.custom_keyboard.data.KeyboardInputMode +import com.kazumaproject.custom_keyboard.layout.KeyboardDefaultLayouts +import org.junit.Assert.assertNotSame +import org.junit.Assert.assertSame +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [35]) +class FlickKeyboardViewReuseTest { + @Test + fun equivalentLayoutReusesExistingKeyViews() { + val view = createView() + view.setKeyboard(createLayout()) + val firstKey = view.getChildAt(0) + + view.setKeyboard(createLayout()) + + assertSame(firstKey, view.getChildAt(0)) + } + + @Test + fun renderingPreferenceChangeStillRebuildsKeyViews() { + val view = createView() + view.setKeyboard(createLayout()) + val firstKey = view.getChildAt(0) + + view.setFlickGuideEnabled(enabled = true, allowMultiCharacterLabels = true) + + assertNotSame(firstKey, view.getChildAt(0)) + } + + private fun createView(): FlickKeyboardView { + val context = ApplicationProvider.getApplicationContext() + return FlickKeyboardView( + ContextThemeWrapper( + context, + com.google.android.material.R.style.Theme_Material3_DayNight_NoActionBar, + ), + ) + } + + private fun createLayout() = KeyboardDefaultLayouts.createFinalLayout( + mode = KeyboardInputMode.HIRAGANA, + dynamicKeyStates = emptyMap(), + inputLayoutType = "toggle", + inputStyle = "default", + ) +} From ebf4eb0d239589e837c8b97e66530853ce2ddb95 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sat, 1 Aug 2026 05:27:32 -0400 Subject: [PATCH 11/24] improve speed of warm start --- ...rsionSessionPerformanceInstrumentedTest.kt | 64 +++- .../converter/engine/KanaKanjiEngine.kt | 27 ++ .../converter/graph/GraphBuilder.kt | 362 ++++++++++++------ .../graph/IncrementalGraphMetadata.kt | 2 + .../louds/with_term_id/LOUDSWithTermId.kt | 85 ++-- .../converter/path_algorithm/FindPath.kt | 58 ++- .../session/KanaKanjiConversionSession.kt | 17 +- .../ime_service/IMEService.kt | 101 +++-- .../ime_service/ImePreferencesSnapshot.kt | 5 +- .../candidate/CandidateRefreshCoordinator.kt | 1 + .../repository/LearnRepository.kt | 8 + .../repository/UserDictionaryRepository.kt | 13 + .../KanaKanjiConversionSessionParityTest.kt | 15 +- ...rementalConversionSessionPreferenceTest.kt | 11 + 14 files changed, 543 insertions(+), 226 deletions(-) diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt index 38bd07fbd..335eecfc8 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt @@ -38,6 +38,11 @@ import kotlin.system.measureNanoTime @RunWith(AndroidJUnit4::class) class IncrementalConversionSessionPerformanceInstrumentedTest { + private var probeOmissionSearchEnabled = false + private var probeFlickTypoCorrectionEnabled = false + private var probeOptionalDictionariesEnabled = false + private var probeNBest = 4 + @Test fun compactCoreDictionariesMatchSerializedAssetsOnDevice() { val arguments = InstrumentationRegistry.getArguments() @@ -589,7 +594,21 @@ class IncrementalConversionSessionPerformanceInstrumentedTest { val bunsetsuSeparation = arguments.getString("conversionPerfBunsetsu") ?.toBooleanStrictOrNull() ?: true - val prefixes = phrase.indices.map { phrase.substring(0, it + 1) } + probeOmissionSearchEnabled = arguments.getString("conversionPerfOmission") == "true" + probeFlickTypoCorrectionEnabled = + arguments.getString("conversionPerfFlickTypoCorrection") == "true" + probeOptionalDictionariesEnabled = + arguments.getString("conversionPerfMozcOptional") == "true" + probeNBest = arguments.getString("conversionPerfNBest")?.toIntOrNull() ?: 4 + val strictCandidateParity = arguments.getString("conversionPerfStrictParity") != "false" + val requestedPrefixLengths = arguments.getString("conversionPerfPrefixLengths") + ?.split(',') + ?.mapNotNull(String::toIntOrNull) + ?.filter { it in 1..phrase.length } + ?.distinct() + ?.takeIf { it.isNotEmpty() } + val prefixLengths = requestedPrefixLengths ?: (1..phrase.length).toList() + val prefixes = prefixLengths.map { phrase.substring(0, it) } val context = ApplicationProvider.getApplicationContext() val entryPoint = EntryPointAccessors.fromApplication( context.applicationContext, @@ -622,7 +641,21 @@ class IncrementalConversionSessionPerformanceInstrumentedTest { bunsetsuSeparation, collectFingerprints = true, ) - assertEquals(legacyParity.fingerprints, incrementalParity.fingerprints) + val candidateParityExact = legacyParity.fingerprints == incrementalParity.fingerprints + if (strictCandidateParity) { + prefixes.indices.forEach { index -> + assertEquals( + "prefix=${prefixes[index]}", + legacyParity.fingerprints[index], + incrementalParity.fingerprints[index], + ) + } + } else { + assertEquals( + legacyParity.fingerprints.map { it.take(2) }, + incrementalParity.fingerprints.map { it.take(2) }, + ) + } repeat(warmups) { runSequence( @@ -711,14 +744,17 @@ class IncrementalConversionSessionPerformanceInstrumentedTest { appendLine("device=${android.os.Build.MANUFACTURER} ${android.os.Build.MODEL} API ${android.os.Build.VERSION.SDK_INT}") appendLine("phrase=$phrase") appendLine("prefixCount=${prefixes.size}") + appendLine("prefixLengths=${prefixLengths.joinToString(",")}") appendLine("warmups=$warmups") appendLine("iterations=$iterations") appendLine("bunsetsuSeparation=$bunsetsuSeparation") appendLine("mode=$mode") - appendLine("optionalDictionaries=false") - appendLine("typoCorrection=false") - appendLine("omissionSearch=false") - appendLine("candidateParityEveryPrefix=true") + appendLine("optionalDictionaries=$probeOptionalDictionariesEnabled") + appendLine("typoCorrection=$probeFlickTypoCorrectionEnabled") + appendLine("omissionSearch=$probeOmissionSearchEnabled") + appendLine("nBest=$probeNBest") + appendLine("candidateParityEveryPrefix=$candidateParityExact") + appendLine("top2CandidateParityEveryPrefix=true") appendLine("legacySessionMs=${legacySession.asMilliseconds()}") appendLine("incrementalSessionMs=${incrementalSession.asMilliseconds()}") appendLine("legacyCommandMs=${legacyCommand.asMilliseconds()}") @@ -1068,16 +1104,16 @@ class IncrementalConversionSessionPerformanceInstrumentedTest { input = input, mode = mode, bunsetsuSeparation = bunsetsuSeparation, - n = 4, - mozcUtPersonName = false, - mozcUtPlaces = false, - mozcUtWiki = false, - mozcUtNeologd = false, - mozcUtWeb = false, + n = probeNBest, + mozcUtPersonName = probeOptionalDictionariesEnabled, + mozcUtPlaces = probeOptionalDictionariesEnabled, + mozcUtWiki = probeOptionalDictionariesEnabled, + mozcUtNeologd = probeOptionalDictionariesEnabled, + mozcUtWeb = probeOptionalDictionariesEnabled, userDictionaryRepository = repository, learnRepository = null, - omissionSearchEnabled = false, - typoCorrectionJapaneseFlickEnabled = false, + omissionSearchEnabled = probeOmissionSearchEnabled, + typoCorrectionJapaneseFlickEnabled = probeFlickTypoCorrectionEnabled, typoCorrectionQwertyEnglishEnabled = false, typoCorrectionOffsetScore = 3000, omissionSearchOffsetScore = 1900, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt index 3d1f5befc..bf62a1fc1 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt @@ -89,12 +89,29 @@ class KanaKanjiEngine { val stateRejectionCount: Int, val expansionCacheHitCount: Int, val expansionCacheMissCount: Int, + val graphAppendReused: Boolean, + val forwardDpReused: Boolean, ) class IncrementalSessionState internal constructor( internal val graphState: GraphBuilder.SessionState, internal val pathState: FindPath.SessionState, ) { + internal fun beginQueryTransaction() { + graphState.beginQueryTransaction() + pathState.beginQueryTransaction() + } + + internal fun commitQueryTransaction() { + graphState.commitQueryTransaction() + pathState.commitQueryTransaction() + } + + internal fun rollbackQueryTransaction() { + graphState.rollbackQueryTransaction() + pathState.rollbackQueryTransaction() + } + internal fun reset() { graphState.reset() pathState.reset() @@ -115,7 +132,11 @@ class KanaKanjiEngine { stateRejectionCount = pathState.lastStateRejectionCount, expansionCacheHitCount = pathState.lastExpansionCacheHitCount, expansionCacheMissCount = pathState.lastExpansionCacheMissCount, + graphAppendReused = graphState.lastAppendReused, + forwardDpReused = pathState.lastForwardDpReused, ) + + internal fun committedInput(): String? = graphState.committedInput() } private lateinit var graphBuilder: GraphBuilder @@ -1074,6 +1095,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) @@ -1577,6 +1599,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) @@ -2111,6 +2134,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) @@ -2586,6 +2610,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) @@ -3041,6 +3066,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) @@ -3532,6 +3558,7 @@ class KanaKanjiEngine { omissionSearchOffSetScore = omissionSearchOffsetScore, graphNodeDedupMode = graphNodeDedupModeForCurrentDictionary(), mozcNodeAttributeTable = mozcNodeAttributeTableForCurrentDictionary(), + beamWidth = beamWidth, sessionState = incrementalSessionState?.graphState, ) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt index e51cebef4..a0d0189a4 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt @@ -36,7 +36,7 @@ class GraphBuilder { val webPrefixStates: Map, val personPrefixStates: Map, val neologdPrefixStates: Map, - val unprunedFrontier: MutableList?, + val unprunedPositions: Map>?, ) /** @@ -49,16 +49,89 @@ class GraphBuilder { internal var cachedGraph: CachedGraph? = null internal var performanceProbeEnabled: Boolean = false internal var lastConstructGraphNs: Long = 0 + internal var lastAppendReused: Boolean = false + + private var queryTransaction: QueryTransaction? = null + + private data class InPlaceAppendRollback( + val graph: IncrementalGraph, + val previousReusedThroughEndIndex: Int, + val previousForwardDpReusableThroughEndIndex: Int, + val previousInputLength: Int, + val previousPositions: Map?>, + val previousEosIndex: Int, + val previousEos: MutableList?, + ) { + fun restore() { + graph.keys.removeAll { it > previousInputLength } + previousPositions.forEach { (position, nodes) -> + nodes?.let { graph[position] = it } ?: graph.remove(position) + } + previousEos?.let { graph[previousEosIndex] = it } + ?: graph.remove(previousEosIndex) + graph.reusedThroughEndIndex = previousReusedThroughEndIndex + graph.forwardDpReusableThroughEndIndex = + previousForwardDpReusableThroughEndIndex + check(graph.keys.none { it > previousEosIndex }) + } + } + + private data class QueryTransaction( + val committedCache: CachedGraph?, + var inPlaceAppendRollback: InPlaceAppendRollback? = null, + ) + + internal fun beginQueryTransaction() { + check(queryTransaction == null) { "Graph query transaction is already active" } + queryTransaction = QueryTransaction(committedCache = cachedGraph) + } + + internal fun registerInPlaceAppend( + graph: IncrementalGraph, + previousReusedThroughEndIndex: Int, + previousForwardDpReusableThroughEndIndex: Int, + previousInputLength: Int, + positionsToRestore: Set, + previousEosIndex: Int, + previousEos: MutableList?, + ) { + queryTransaction?.inPlaceAppendRollback = InPlaceAppendRollback( + graph = graph, + previousReusedThroughEndIndex = previousReusedThroughEndIndex, + previousForwardDpReusableThroughEndIndex = + previousForwardDpReusableThroughEndIndex, + previousInputLength = previousInputLength, + previousPositions = positionsToRestore.associateWith { graph[it] }, + previousEosIndex = previousEosIndex, + previousEos = previousEos, + ) + } + + internal fun commitQueryTransaction() { + queryTransaction = null + } + + internal fun committedInput(): String? = cachedGraph?.input + + internal fun rollbackQueryTransaction() { + val transaction = queryTransaction ?: return + transaction.inPlaceAppendRollback?.restore() + cachedGraph = transaction.committedCache + queryTransaction = null + } internal fun reset() { + queryTransaction = null cachedGraph = null lastConstructGraphNs = 0 + lastAppendReused = false } } - private class IncrementalGraph( + internal class IncrementalGraph( override var reusedThroughEndIndex: Int, override val conversionSignature: Int, + override var forwardDpReusableThroughEndIndex: Int = reusedThroughEndIndex, ) : LinkedHashMap>(), IncrementalGraphMetadata @Volatile @@ -208,6 +281,7 @@ class GraphBuilder { enableTypoCorrectionJapaneseFlick: Boolean = false, typoCorrectionOffsetScore: Int, omissionSearchOffSetScore: Int, + beamWidth: Int = 20, graphNodeDedupMode: GraphNodeDedupMode = GraphNodeDedupMode.EXISTING_BY_TANGO_L_R, mozcNodeAttributeTable: MozcNodeAttributeTable? = null, graphNodeTrace: MutableList? = null, @@ -239,6 +313,7 @@ class GraphBuilder { enableTypoCorrectionJapaneseFlick = enableTypoCorrectionJapaneseFlick, typoCorrectionOffsetScore = typoCorrectionOffsetScore, omissionSearchOffSetScore = omissionSearchOffSetScore, + beamWidth = beamWidth, graphNodeDedupMode = graphNodeDedupMode, mozcNodeAttributeTable = mozcNodeAttributeTable, ) @@ -246,15 +321,20 @@ class GraphBuilder { val reusable = activeCache?.takeIf { graphNodeTrace == null && it.signature == signature && - str.length == it.input.length + 1 && + ( + sessionState != null && str.length > it.input.length || + sessionState == null && str.length == it.input.length + 1 + ) && str.startsWith(it.input) && // Appending within an alphabet token changes every maximal-run node that starts // in that token. The current append cache can only preserve a fully stable // prefix, so rebuild this transition instead of publishing a stale short token. - !( - it.input.lastOrNull()?.isAsciiAlphabet() == true && - str.lastOrNull()?.isAsciiAlphabet() == true - ) + str.substring((it.input.length - 1).coerceAtLeast(0)) + .windowed(2) + .none { pair -> pair[0].isAsciiAlphabet() && pair[1].isAsciiAlphabet() } + } + if (sessionState?.performanceProbeEnabled == true) { + sessionState.lastAppendReused = reusable != null } val reusablePrefixLength = reusable?.input?.length ?: -1 val systemOmissionStates = LinkedHashMap>() @@ -281,13 +361,23 @@ class GraphBuilder { reusable != null && previousNodeIndex != null ) { - trie.advanceCommonPrefixSearch( - previousNodeIndex = previousNodeIndex, - char = str.last(), - input = str, - start = start, - succinctBitVector = bitVector, + var current = LOUDSWithTermId.CommonPrefixSearchProgress( + results = emptyList(), + nodeIndex = previousNodeIndex, ) + val newResults = ArrayList() + for (endIndex in reusable.input.length until str.length) { + current = trie.advanceCommonPrefixSearch( + previousNodeIndex = current.nodeIndex, + char = str[endIndex], + input = str.subSequence(0, endIndex + 1), + start = start, + succinctBitVector = bitVector, + ) + newResults.addAll(current.results) + if (current.nodeIndex < 0) break + } + current.copy(results = newResults) } else { trie.commonPrefixSearchWithProgress( str = str, @@ -298,20 +388,109 @@ class GraphBuilder { currentStates[start] = progress.nodeIndex return progress.results } + + fun typoSearch( + trie: LOUDSWithTermId, + bitVector: SuccinctBitVector, + start: Int, + previous: LOUDSWithTermId.TypoSearchProgress?, + ): LOUDSWithTermId.TypoSearchProgress { + if (sessionState == null || reusable == null || previous == null) { + return trie.commonPrefixSearchWithTypoCorrectionProgress( + str = str, + startIndex = start, + succinctBitVector = bitVector, + maxResults = 98, + maxLen = 12, + ) + } + var current: LOUDSWithTermId.TypoSearchProgress = checkNotNull(previous) + val newResults = ArrayList() + for (index in reusable.input.length until str.length) { + current = trie.advanceTypoCorrectionSearch( + previous = current, + char = str[index], + succinctBitVector = bitVector, + maxResults = 98, + maxLen = 12, + ) + newResults.addAll(current.results) + if (current.terminalStates.isEmpty()) break + } + return current.copy(results = newResults) + } + + fun omissionSearch( + trie: LOUDSWithTermId, + bitVector: SuccinctBitVector, + start: Int, + previous: List?, + ): LOUDSWithTermId.OmissionSearchProgress { + if (sessionState == null || reusable == null) { + return trie.commonPrefixSearchWithOmissionProgress( + str = str, + startIndex = start, + succinctBitVector = bitVector, + ) + } + if (previous == null) { + // Preserve the former one-character append semantics exactly. A larger jump is + // the cancellation catch-up path; build the missing frontier from its true start + // so no matches in the skipped characters are lost. + return if (str.length == reusable.input.length + 1) { + trie.advanceOmissionSearch( + states = listOf(LOUDSWithTermId.OmissionSearchState(0, false)), + char = str.last(), + succinctBitVector = bitVector, + ) + } else { + trie.commonPrefixSearchWithOmissionProgress( + str = str, + startIndex = start, + succinctBitVector = bitVector, + ) + } + } + var states: List = previous + val newResults = ArrayList() + for (index in reusable.input.length until str.length) { + val current = trie.advanceOmissionSearch( + states = states, + char = str[index], + succinctBitVector = bitVector, + ) + states = current.terminalStates + newResults.addAll(current.results) + if (states.isEmpty()) break + } + return LOUDSWithTermId.OmissionSearchProgress(newResults, states) + } val graph: MutableMap> = if (reusable != null) { val sessionGraph = reusable.graph as? IncrementalGraph if (sessionState != null && sessionGraph != null) { // A session owns this graph exclusively. Keep the already-pruned lattice and // extend it in place instead of cloning every node twice for every typed letter. // Clear the published cache first so cancellation cannot expose a partial append. + sessionState.registerInPlaceAppend( + graph = sessionGraph, + previousReusedThroughEndIndex = sessionGraph.reusedThroughEndIndex, + previousForwardDpReusableThroughEndIndex = + sessionGraph.forwardDpReusableThroughEndIndex, + previousInputLength = reusablePrefixLength, + positionsToRestore = reusable.unprunedPositions?.keys.orEmpty(), + previousEosIndex = reusablePrefixLength + 1, + previousEos = sessionGraph[reusablePrefixLength + 1], + ) sessionState.cachedGraph = null sessionGraph.reusedThroughEndIndex = reusablePrefixLength + sessionGraph.forwardDpReusableThroughEndIndex = + if (reusable.unprunedPositions.isNullOrEmpty()) reusablePrefixLength else -1 sessionGraph.remove(reusablePrefixLength + 1) // previous EOS - // The previous final position was pruned while it still had a suffix penalty. - // It must be reconsidered after that penalty disappears on append. Retain only - // this one unpruned frontier, not a deep copy of the whole lattice. - reusable.unprunedFrontier?.let { frontier -> - sessionGraph[reusablePrefixLength] = frontier + // Beam pruning is query-local. With correction and optional dictionaries, nodes + // discarded on an earlier prefix can still participate in a later K-best path. + // Restore the node lists while retaining the node objects and search frontiers. + reusable.unprunedPositions?.forEach { (position, nodes) -> + sessionGraph[position] = nodes } sessionGraph } else { @@ -351,7 +530,13 @@ class GraphBuilder { var foundInAnyDictionary = false // 1. ユーザー辞書 - val userWords = userDictionaryRepository?.commonPrefixSearchInUserDict(subStr()) ?: emptyList() + val userWords = userDictionaryRepository?.let { repository -> + if (reusable != null && str.length == reusable.input.length + 1) { + repository.exactMatchesForConversion(subStr()) + } else { + repository.commonPrefixSearchInUserDict(subStr()) + } + } ?: emptyList() if (userWords.isNotEmpty()) foundInAnyDictionary = true userWords.forEach { userWord -> val endIndex = i + userWord.reading.length @@ -373,7 +558,13 @@ class GraphBuilder { } // 2. 学習辞書 - val learnedWords = learnRepository?.findCommonPrefixes(subStr()) ?: emptyList() + val learnedWords = learnRepository?.let { repository -> + if (reusable != null && str.length == reusable.input.length + 1) { + repository.findExactMatchesForConversion(subStr()) + } else { + repository.findCommonPrefixes(subStr()) + } + } ?: emptyList() if (learnedWords.isNotEmpty()) foundInAnyDictionary = true learnedWords.forEach { learnedWord -> val endIndex = i + learnedWord.input.length @@ -465,34 +656,12 @@ class GraphBuilder { // 1.x システムユーザー辞書 (Typo Correction Prefix) if (enableTypoCorrectionJapaneseFlick && subStr().length > 2) { - val typoProgress = if (reusablePrefixLength >= 0) { - val previous = reusable?.systemUserTypoProgress?.get(i) - if (previous == null) { - localSystemUserYomiTrie.commonPrefixSearchWithTypoCorrectionProgress( - str = str, - startIndex = i, - succinctBitVector = localSystemUserLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } else { - localSystemUserYomiTrie.advanceTypoCorrectionSearch( - previous = previous, - char = str.last(), - succinctBitVector = localSystemUserLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } - } else { - localSystemUserYomiTrie.commonPrefixSearchWithTypoCorrectionProgress( - str = str, - startIndex = i, - succinctBitVector = localSystemUserLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } + val typoProgress = typoSearch( + trie = localSystemUserYomiTrie, + bitVector = localSystemUserLBSYomi, + start = i, + previous = reusable?.systemUserTypoProgress?.get(i), + ) systemUserTypoProgress[i] = typoProgress val typoPrefixResults = typoProgress.results if (typoPrefixResults.isNotEmpty()) foundInAnyDictionary = true @@ -560,26 +729,12 @@ class GraphBuilder { // 1.y システムユーザー辞書 (Omission Search) if (isOmissionSearchEnable && !subStr().hasNConsecutiveChars(4)) { - val omissionProgress = if (reusablePrefixLength >= 0) { - val previousStates = reusable?.systemUserOmissionStates?.get(i) - ?: listOf( - LOUDSWithTermId.OmissionSearchState( - nodeIndex = 0, - omissionOccurred = false, - ) - ) - localSystemUserYomiTrie.advanceOmissionSearch( - states = previousStates, - char = str.last(), - succinctBitVector = localSystemUserLBSYomi, - ) - } else { - localSystemUserYomiTrie.commonPrefixSearchWithOmissionProgress( - str = str, - startIndex = i, - succinctBitVector = localSystemUserLBSYomi, - ) - } + val omissionProgress = omissionSearch( + trie = localSystemUserYomiTrie, + bitVector = localSystemUserLBSYomi, + start = i, + previous = reusable?.systemUserOmissionStates?.get(i), + ) systemUserOmissionStates[i] = omissionProgress.terminalStates val omissionSearchResults = omissionProgress.results if (omissionSearchResults.isNotEmpty()) foundInAnyDictionary = true @@ -687,34 +842,12 @@ class GraphBuilder { // 3.x システム辞書 (Typo Correction Prefix) if (enableTypoCorrectionJapaneseFlick && subStr().length > 2) { - val typoProgress = if (reusablePrefixLength >= 0) { - val previous = reusable?.systemTypoProgress?.get(i) - if (previous == null) { - yomiTrie.commonPrefixSearchWithTypoCorrectionProgress( - str = str, - startIndex = i, - succinctBitVector = succinctBitVectorLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } else { - yomiTrie.advanceTypoCorrectionSearch( - previous = previous, - char = str.last(), - succinctBitVector = succinctBitVectorLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } - } else { - yomiTrie.commonPrefixSearchWithTypoCorrectionProgress( - str = str, - startIndex = i, - succinctBitVector = succinctBitVectorLBSYomi, - maxResults = 98, - maxLen = 12, - ) - } + val typoProgress = typoSearch( + trie = yomiTrie, + bitVector = succinctBitVectorLBSYomi, + start = i, + previous = reusable?.systemTypoProgress?.get(i), + ) systemTypoProgress[i] = typoProgress val typoPrefixResults = typoProgress.results @@ -777,26 +910,12 @@ class GraphBuilder { // 4. システム辞書 (Omission Search) if (isOmissionSearchEnable && !subStr().hasNConsecutiveChars(4)) { - val omissionProgress = if (reusablePrefixLength >= 0) { - val previousStates = reusable?.systemOmissionStates?.get(i) - ?: listOf( - LOUDSWithTermId.OmissionSearchState( - nodeIndex = 0, - omissionOccurred = false, - ) - ) - yomiTrie.advanceOmissionSearch( - states = previousStates, - char = str.last(), - succinctBitVector = succinctBitVectorLBSYomi, - ) - } else { - yomiTrie.commonPrefixSearchWithOmissionProgress( - str = str, - startIndex = i, - succinctBitVector = succinctBitVectorLBSYomi, - ) - } + val omissionProgress = omissionSearch( + trie = yomiTrie, + bitVector = succinctBitVectorLBSYomi, + start = i, + previous = reusable?.systemOmissionStates?.get(i), + ) systemOmissionStates[i] = omissionProgress.terminalStates val omissionSearchResults: List = omissionProgress.results if (omissionSearchResults.isNotEmpty()) foundInAnyDictionary = true @@ -1118,8 +1237,13 @@ class GraphBuilder { webPrefixStates = webPrefixStates, personPrefixStates = personPrefixStates, neologdPrefixStates = neologdPrefixStates, - unprunedFrontier = if (sessionState != null) { - graph[str.length]?.toMutableList() + unprunedPositions = if (sessionState != null) { + graph.entries + .asSequence() + .filter { (endIndex, _) -> endIndex <= str.length } + .associateTo(LinkedHashMap()) { (endIndex, nodes) -> + endIndex to nodes.toMutableList() + } } else { null }, @@ -1164,6 +1288,7 @@ class GraphBuilder { enableTypoCorrectionJapaneseFlick: Boolean, typoCorrectionOffsetScore: Int, omissionSearchOffSetScore: Int, + beamWidth: Int, graphNodeDedupMode: GraphNodeDedupMode, mozcNodeAttributeTable: MozcNodeAttributeTable?, ): Int { @@ -1181,6 +1306,7 @@ class GraphBuilder { result = 31 * result + enableTypoCorrectionJapaneseFlick.hashCode() result = 31 * result + typoCorrectionOffsetScore result = 31 * result + omissionSearchOffSetScore + result = 31 * result + beamWidth result = 31 * result + graphNodeDedupMode.hashCode() result = 31 * result + System.identityHashCode(mozcNodeAttributeTable) return result diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/IncrementalGraphMetadata.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/IncrementalGraphMetadata.kt index fadce0c4d..a7df6b308 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/IncrementalGraphMetadata.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/IncrementalGraphMetadata.kt @@ -3,5 +3,7 @@ package com.kazumaproject.markdownhelperkeyboard.converter.graph /** Metadata carried only by graphs built from a one-character append. */ interface IncrementalGraphMetadata { val reusedThroughEndIndex: Int + val forwardDpReusableThroughEndIndex: Int + get() = reusedThroughEndIndex val conversionSignature: Int } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt index bc5c866ae..e5e862165 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt @@ -882,74 +882,43 @@ class LOUDSWithTermId { return TypoSearchProgress(emptyList(), emptyList(), emptyMap()) } - // 同一yomiの重複を最小penaltyで集約 - val bestPenaltyByYomi = HashMap(128) - val sb = StringBuilder(maxLen) - val terminalStates = ArrayList() - - fun acceptIfLeaf(nodeIndex: Int, penaltyUsed: Int) { - if (sb.isEmpty()) return - if (!isLeaf[nodeIndex]) return - - val yomi = sb.toString() - val prev = bestPenaltyByYomi[yomi] - if (prev == null || penaltyUsed < prev) { - bestPenaltyByYomi[yomi] = penaltyUsed - } - } - - fun dfs(strIndex: Int, nodeIndex: Int, penaltyUsed: Int) { - if (penaltyUsed > maxPenalty) return - if (sb.length > maxLen) return - if (bestPenaltyByYomi.size >= maxResults) return - - // ★ prefix検索: 途中でも leaf なら採用 - acceptIfLeaf(nodeIndex, penaltyUsed) - - // 入力を使い切ったら終了（prefixなのでここで止める） - if (strIndex >= str.length) { - terminalStates.add( - TypoSearchState(nodeIndex, penaltyUsed, sb.length, sb.toString()) - ) - return - } - if (sb.length >= maxLen) return - - val ch = str[strIndex] - - // ★ 候補をペナルティ昇順で展開（枝刈り） - val candidates: List = getTypoCandidates(ch) - - for (cand in candidates) { - val nextPenalty = penaltyUsed + cand.penalty - if (nextPenalty > maxPenalty) continue - - var childPos = firstChild(nodeIndex, succinctBitVector) - while (childPos >= 0 && LBS[childPos]) { - val labelNodeId = succinctBitVector.rank1(childPos) - if (labelNodeId < labelCount && labelAt(labelNodeId) == cand.ch) { - sb.append(cand.ch) - dfs(strIndex + 1, childPos, nextPenalty) - sb.setLength(sb.length - 1) - break - } - childPos++ + // Use the exact same character-at-a-time transition as an incremental append. The old + // cold path used depth-first traversal while append used frontier traversal; once the + // bounded result set reached maxResults, they retained different typo paths and could + // produce different first candidates for the same input. + var progress = TypoSearchProgress( + results = emptyList(), + terminalStates = listOf(TypoSearchState(0, 0, 0, "")), + acceptedPenalties = emptyMap(), + ) + val acceptedResults = LinkedHashMap() + val endExclusive = minOf(str.length, startIndex + maxLen) + for (index in startIndex until endExclusive) { + progress = advanceTypoCorrectionSearch( + previous = progress, + char = str[index], + succinctBitVector = succinctBitVector, + maxPenalty = maxPenalty, + maxLen = maxLen, + maxResults = maxResults, + ) + progress.results.forEach { result -> + val previousPenalty = acceptedResults[result.yomi] + if (previousPenalty == null || result.penaltyUsed < previousPenalty) { + acceptedResults[result.yomi] = result.penaltyUsed } } + if (progress.terminalStates.isEmpty()) break } - // ルート開始 - dfs(strIndex = startIndex, nodeIndex = 0, penaltyUsed = 0) - - // 出力整形: penalty昇順 → 長さ降順（好み）→ 文字列昇順 - val results = bestPenaltyByYomi.entries + val results = acceptedResults.entries .sortedWith( compareBy> { it.value } .thenByDescending { it.key.length } .thenBy { it.key } ) .map { TypoCorrectionResult(it.key, it.value) } - return TypoSearchProgress(results, terminalStates, bestPenaltyByYomi) + return progress.copy(results = results) } fun advanceTypoCorrectionSearch( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt index 3783e86de..670a5e90c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt @@ -59,8 +59,39 @@ class FindPath( internal var lastStateRejectionCount: Int = 0 internal var lastExpansionCacheHitCount: Int = 0 internal var lastExpansionCacheMissCount: Int = 0 + internal var lastForwardDpReused: Boolean = false + + private var queryCheckpoint: QueryCheckpoint? = null + + private data class QueryCheckpoint( + val forwardDpCache: ForwardDpCache?, + val penaltyCache: PenaltyCache?, + ) + + internal fun beginQueryTransaction() { + check(queryCheckpoint == null) { "Path query transaction is already active" } + queryCheckpoint = QueryCheckpoint( + forwardDpCache = forwardDpCache, + penaltyCache = penaltyCache, + ) + } + + internal fun commitQueryTransaction() { + queryCheckpoint = null + } + + internal fun rollbackQueryTransaction() { + val checkpoint = queryCheckpoint ?: return + forwardDpCache = checkpoint.forwardDpCache + penaltyCache = checkpoint.penaltyCache + queryCheckpoint = null + // Queue/path arenas are query-local. They are cleared at the next begin(), while + // node ids and expansion entries for the committed prefix remain reusable. + backwardSearchScratch.discardInFlightWork() + } internal fun reset() { + queryCheckpoint = null forwardDpCache = null penaltyCache = null backwardSearchScratch.reset() @@ -71,6 +102,7 @@ class FindPath( lastStateRejectionCount = 0 lastExpansionCacheHitCount = 0 lastExpansionCacheMissCount = 0 + lastForwardDpReused = false } } @@ -314,6 +346,11 @@ class FindPath( nodeIds.clear() expansionCache.reset() queueElementPool.clear() + } else { + // Restoring an unpruned incremental lattice can add predecessor nodes to an + // existing position. Cached expansion lists are therefore query-local even + // though node identities and the reusable work arena remain session-local. + expansionCache.clear() } expansionCache.configure( connectionMatrix = connectionMatrix, @@ -344,6 +381,17 @@ class FindPath( expansionCacheMissCount = 0 } + fun discardInFlightWork() { + queue.clear() + bestBackwardCostByState.clear() + bestSplitCostsByState.clear() + charPathArena.reset() + queueElementCount = 0 + stateRejectionCount = 0 + expansionCacheHitCount = 0 + expansionCacheMissCount = 0 + } + fun queueElementCount(): Int = queueElementCount fun recordStateRejection() { @@ -953,12 +1001,15 @@ class FindPath( val activeCache = if (sessionState != null) sessionState.forwardDpCache else forwardDpCache val reusableForwardDp = activeCache?.takeIf { cached -> incrementalMetadata != null && - incrementalMetadata.reusedThroughEndIndex == cached.inputLength && + incrementalMetadata.forwardDpReusableThroughEndIndex == cached.inputLength && incrementalMetadata.conversionSignature == cached.conversionSignature && length == cached.inputLength + 1 && cached.connectionMatrixIdentity == System.identityHashCode(connectionMatrix) && cached.beamWidth == effectiveBeamWidth } + if (sessionState?.performanceProbeEnabled == true) { + sessionState.lastForwardDpReused = reusableForwardDp != null + } val forwardDpStartPosition = if (reusableForwardDp != null) { reusableForwardDp.nodesBeforePreviousEnd.forEach { (position, nodes) -> graph[position] = nodes @@ -1530,12 +1581,15 @@ class FindPath( val reusableForwardDp = activeCache?.takeIf { cached -> forwardDpTrace == null && incrementalMetadata != null && - incrementalMetadata.reusedThroughEndIndex == cached.inputLength && + incrementalMetadata.forwardDpReusableThroughEndIndex == cached.inputLength && incrementalMetadata.conversionSignature == cached.conversionSignature && length == cached.inputLength + 1 && cached.connectionMatrixIdentity == System.identityHashCode(connectionMatrix) && cached.beamWidth == effectiveBeamWidth } + if (sessionState?.performanceProbeEnabled == true) { + sessionState.lastForwardDpReused = reusableForwardDp != null + } val forwardDpStartPosition = if (reusableForwardDp != null) { reusableForwardDp.nodesBeforePreviousEnd.forEach { (position, nodes) -> graph[position] = nodes diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt index 1f7539d72..3e59bb152 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt @@ -6,6 +6,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine import com.kazumaproject.markdownhelperkeyboard.converter.engine.PredictionConfig import com.kazumaproject.markdownhelperkeyboard.repository.LearnRepository import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryRepository +import kotlinx.coroutines.CancellationException import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock @@ -72,9 +73,12 @@ class KanaKanjiConversionSession( internal fun performanceSnapshot(): KanaKanjiEngine.IncrementalPerformanceSnapshot? = incrementalState?.performanceSnapshot() + internal fun committedInput(): String? = incrementalState?.committedInput() + suspend fun query(request: KanaKanjiQueryRequest): KanaKanjiQueryResult = mutex.withLock { + incrementalState?.beginQueryTransaction() try { - when (request.mode) { + val result = when (request.mode) { CandidateQueryMode.EISUKANA -> KanaKanjiQueryResult( candidates = engine.getCandidatesEnglishKana( input = request.input, @@ -86,9 +90,16 @@ class KanaKanjiConversionSession( CandidateQueryMode.PREDICTION -> queryPrediction(request) CandidateQueryMode.CONVERSION -> queryConversion(request) } + incrementalState?.commitQueryTransaction() + result + } catch (cancellation: CancellationException) { + // Keep the last fully committed prefix. Graph append and path caches have an explicit + // rollback boundary, so rapid collectLatest input no longer forces a cold rebuild. + incrementalState?.rollbackQueryTransaction() + throw cancellation } catch (throwable: Throwable) { - // Graph construction and forward DP update state in place. A collectLatest - // cancellation (or any failure) must make the next request rebuild atomically. + // Unexpected engine/repository failures may violate invariants outside the tracked + // append delta. Prefer a clean rebuild for those rare failures. incrementalState?.reset() throw throwable } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 4e679da35..c67526130 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -1182,6 +1182,18 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, applyRawComposingFallback(insertString) } } + if (BuildConfig.DEBUG && shouldStartLiveConversion(insertString)) { + val request = candidateRefreshCoordinator.requests.value + if (request.input == insertString) { + Timber.d( + "liveConversionLatency inputLength=%d revision=%d requestToApplied=%.2fms", + insertString.length, + request.revision, + (System.nanoTime() - + request.publishedAtNanos) / 1_000_000.0, + ) + } + } true } @@ -2232,7 +2244,11 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, kanaKanjiConversionSession = KanaKanjiConversionSession( engine = kanaKanjiEngine, backend = backend, - ) + ).also { session -> + if (BuildConfig.DEBUG && backend == ConversionBackend.INCREMENTAL_SESSION) { + session.enablePerformanceProbe() + } + } candidateRequestTracker.restart(backend) candidateRefreshCoordinator.restart() } @@ -22175,44 +22191,53 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, insertString: String, mainView: MainLayoutBinding, token: CandidateRequestToken? = null, - ): List = measureDebugStage("IMEService.getSuggestionList") { - val resultFromUserDictionary = if (isUserDictionaryEnable == true) { - measureDebugStage("IMEService.getSuggestionList.userDictionary") { - withContext(Dispatchers.IO) { + ): List = measureDebugStage("IMEService.getSuggestionList") { coroutineScope { + // These lookups do not depend on one another. Starting them together moves Room and + // template latency under the converter's CPU time instead of paying it serially first. + val userDictionaryDeferred = async(Dispatchers.IO) { + if (isUserDictionaryEnable == true) { + measureDebugStage("IMEService.getSuggestionList.userDictionary") { val prefixMatchNumber = (userDictionaryPrefixMatchNumber ?: 2) - 1 - if (insertString.length <= prefixMatchNumber) return@withContext emptyList() - userDictionaryRepository.searchByReadingPrefixSuspend( - prefix = insertString, limit = userDictionaryPredictionCandidateLimit - ).map { - Candidate( - string = it.word, - type = CANDIDATE_TYPE_USER_DICTIONARY, - length = (it.reading.length).toUByte(), - score = it.posScore - ) - }.sortedBy { it.score } + if (insertString.length <= prefixMatchNumber) { + emptyList() + } else { + userDictionaryRepository.searchByReadingPrefixSuspend( + prefix = insertString, + limit = userDictionaryPredictionCandidateLimit, + ).map { + Candidate( + string = it.word, + type = CANDIDATE_TYPE_USER_DICTIONARY, + length = it.reading.length.toUByte(), + score = it.posScore, + ) + }.sortedBy { it.score } + } } + } else { + emptyList() } - } else { - emptyList() } - val resultFromUserTemplate = + val userTemplateDeferred = async { measureDebugStage("IMEService.getSuggestionList.userTemplate") { getUserTemplateCandidates(insertString) } + } val suggestionLearnRepository = learnedRepositoryForSuggestion() - val resultFromLearnDictionary = + val learnDictionaryDeferred = async(Dispatchers.IO) { if (enablePredictionSearchLearnDictionaryPreference == true && suggestionLearnRepository != null ) { measureDebugStage("IMEService.getSuggestionList.learnDictionary") { - withContext(Dispatchers.IO) { - val prefixMatchNumber = (learnPredictionPreference ?: 4) - 1 - if (insertString.length <= prefixMatchNumber) return@withContext emptyList() + val prefixMatchNumber = (learnPredictionPreference ?: 4) - 1 + if (insertString.length <= prefixMatchNumber) { + emptyList() + } else { suggestionLearnRepository.predictiveSearchByInput( - prefix = insertString, limit = learnDictionaryPredictionCandidateLimit + prefix = insertString, + limit = learnDictionaryPredictionCandidateLimit, ).map { Candidate( string = it.out, @@ -22227,6 +22252,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } else { emptyList() } + } val ngWords = measureDebugStage("IMEService.getSuggestionList.ngWordSnapshot") { if (isNgWordEnable == true) ngWordsList.value.map { it.tango } else emptyList() @@ -22240,8 +22266,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, (enableTypoCorrectionQwertyEnglishKeyboardPreference == true) && (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTY || (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTYRomaji && !currentQwertyRomajiModeForSession)) - val coreResult = measureDebugStage("IMEService.getSuggestionList.kanaKanjiEngine") { - withContext(Dispatchers.Default) { + val coreResultDeferred = async(Dispatchers.Default) { + measureDebugStage("IMEService.getSuggestionList.kanaKanjiEngine") { queryKanaKanjiCore( input = insertString, mode = CandidateQueryMode.PREDICTION, @@ -22252,6 +22278,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) } } + val coreResult = coreResultDeferred.await() + val resultFromUserDictionary = userDictionaryDeferred.await() + val resultFromUserTemplate = userTemplateDeferred.await() + val resultFromLearnDictionary = learnDictionaryDeferred.await() val engineResult = coreResult.bunsetsuResult val engineCandidates = coreResult.candidates engineResult?.let { @@ -22294,7 +22324,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } orderedCandidates - } + } } private fun getLeftContext(inputLength: Int): String { val ic = currentInputConnection ?: return "" @@ -22467,7 +22497,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ).also { kanaKanjiConversionSession = it } - return session.query( + val result = session.query( KanaKanjiQueryRequest( input = input, mode = mode, @@ -22490,6 +22520,21 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, predictionConfig = predictionConfig, ) ) + if (BuildConfig.DEBUG) { + session.performanceSnapshot()?.let { snapshot -> + Timber.d( + "conversionStages inputLength=%d graph=%.2fms penalty=%.2fms forward=%.2fms backward=%.2fms graphReused=%s forwardReused=%s", + input.length, + snapshot.graphNs / 1_000_000.0, + snapshot.penaltyNs / 1_000_000.0, + snapshot.forwardDpNs / 1_000_000.0, + snapshot.backwardSearchNs / 1_000_000.0, + snapshot.graphAppendReused, + snapshot.forwardDpReused, + ) + } + } + return result } private fun List.withoutHentaiganaCandidatesIfNeeded(): List { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt index 86a5b0fdd..266768a39 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt @@ -317,7 +317,10 @@ data class ImePreferencesSnapshot( appPreference.live_conversion_candidate_yomi_preference ?: false, nBest = appPreference.n_best_preference ?: 4, conversionBeamWidth = appPreference.conversion_beam_width_preference, - conversionBackend = if (appPreference.incremental_conversion_session_preference) { + conversionBackend = if ( + appPreference.incremental_conversion_session_preference || + appPreference.live_conversion_preference == true + ) { ConversionBackend.INCREMENTAL_SESSION } else { ConversionBackend.LEGACY diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/candidate/CandidateRefreshCoordinator.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/candidate/CandidateRefreshCoordinator.kt index 8335e6c8b..4d4687653 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/candidate/CandidateRefreshCoordinator.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/candidate/CandidateRefreshCoordinator.kt @@ -68,4 +68,5 @@ internal data class CandidateRefreshRequest( val revision: Long, val input: String, val flag: CandidateShowFlag, + val publishedAtNanos: Long = System.nanoTime(), ) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/LearnRepository.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/LearnRepository.kt index df3e58efe..994c30187 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/LearnRepository.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/LearnRepository.kt @@ -90,6 +90,14 @@ class LearnRepository @Inject constructor( .toList() } + suspend fun findExactMatchesForConversion(input: String): List { + val firstCharacter = input.firstOrNull() ?: return emptyList() + return getConversionBucket(firstCharacter) + .asSequence() + .filter { it.input == input } + .toList() + } + fun all(): Flow> = learnDao.all() suspend fun allSuspend(): List = learnDao.getAllSuspend() diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/UserDictionaryRepository.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/UserDictionaryRepository.kt index a438cf9a8..b6ec6b284 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/UserDictionaryRepository.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/UserDictionaryRepository.kt @@ -52,6 +52,19 @@ class UserDictionaryRepository @Inject constructor( .orEmpty() } + /** + * Incremental lattice append only needs entries whose reading ends at the new input tail. + * Earlier, shorter common-prefix matches are already present in the committed graph. + */ + suspend fun exactMatchesForConversion(reading: String): List { + val firstCharacter = reading.firstOrNull() ?: return emptyList() + return getConversionSnapshot()[firstCharacter] + ?.asSequence() + ?.filter { it.reading == reading } + ?.toList() + .orEmpty() + } + suspend fun allWordsSuspend(): List { return userWordDao.getAllSuspend() } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt index f4d89f422..985ee0c6a 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt @@ -75,6 +75,13 @@ class KanaKanjiConversionSessionParityTest { } emptyList() } + whenever(repository.exactMatchesForConversion(any())).thenAnswer { + lookupCount++ + if (failDuringAppend && lookupCount == 3) { + throw kotlinx.coroutines.CancellationException("controlled partial append") + } + emptyList() + } val incremental = KanaKanjiConversionSession( localEngine, ConversionBackend.INCREMENTAL_SESSION, @@ -98,21 +105,23 @@ class KanaKanjiConversionSessionParityTest { cancellationObserved = true } assertTrue(cancellationObserved) + assertEquals("きょ", incremental.committedInput()) failDuringAppend = false lookupCount = 0 val recovered = incremental.query( - request("きょう", CandidateQueryMode.PREDICTION, true).copy( + request("きょうは", CandidateQueryMode.PREDICTION, true).copy( userDictionaryRepository = repository, ), ) val rebuilt = KanaKanjiConversionSession(localEngine, ConversionBackend.LEGACY).query( - request("きょう", CandidateQueryMode.PREDICTION, true).copy( + request("きょうは", CandidateQueryMode.PREDICTION, true).copy( userDictionaryRepository = repository, ), ) assertEquals(rebuilt.candidates.fingerprint(), recovered.candidates.fingerprint()) assertEquals(rebuilt.bunsetsuResult?.splitPatterns, recovered.bunsetsuResult?.splitPatterns) + assertEquals("きょうは", incremental.committedInput()) } private fun request( @@ -163,6 +172,8 @@ class KanaKanjiConversionSessionParityTest { runBlocking { whenever(userDictionaryRepository.commonPrefixSearchInUserDict(any())) .thenReturn(emptyList()) + whenever(userDictionaryRepository.exactMatchesForConversion(any())) + .thenReturn(emptyList()) } } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/IncrementalConversionSessionPreferenceTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/IncrementalConversionSessionPreferenceTest.kt index 1ea8e6a39..cd528e83c 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/IncrementalConversionSessionPreferenceTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/IncrementalConversionSessionPreferenceTest.kt @@ -47,6 +47,17 @@ class IncrementalConversionSessionPreferenceTest { ) } + @Test + fun liveConversionAlwaysUsesIncrementalSession() { + AppPreference.incremental_conversion_session_preference = false + AppPreference.live_conversion_preference = true + + assertEquals( + ConversionBackend.INCREMENTAL_SESSION, + ImePreferencesSnapshot.from(AppPreference).conversionBackend, + ) + } + @Test fun switchIsSharedByNewAndLegacyConversionEngineSettings() { assertTrue(conversionEngineXmlContainsDefaultOffSwitch()) From 6460b70e49cdb300445fe8658705c4e929d613f8 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sat, 1 Aug 2026 07:53:29 -0400 Subject: [PATCH 12/24] improve conversion speed --- ...rsionSessionPerformanceInstrumentedTest.kt | 6 + .../converter/engine/KanaKanjiEngine.kt | 39 +++++- .../converter/graph/GraphBuilder.kt | 115 +++++++++++++++--- .../converter/path_algorithm/FindPath.kt | 4 + .../session/KanaKanjiConversionSession.kt | 8 +- .../ime_service/IMEService.kt | 90 +++++++++----- .../KanaKanjiConversionSessionParityTest.kt | 61 ++++++++++ 7 files changed, 271 insertions(+), 52 deletions(-) diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt index 335eecfc8..dd3cad72c 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/IncrementalConversionSessionPerformanceInstrumentedTest.kt @@ -615,6 +615,12 @@ class IncrementalConversionSessionPerformanceInstrumentedTest { KanaKanjiEngineEntryPoint::class.java, ) val engine = entryPoint.kanaKanjiEngine() + if ( + probeOptionalDictionariesEnabled && + !engine.isInitialOptionalDictionaryStateLoaded() + ) { + engine.initializeOptionalDictionaryStateFromCurrentSources() + } val repository = entryPoint.userDictionaryRepository() val disableSystemNgramForProbe = arguments.getString("conversionPerfSystemNgram") == "false" diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt index bf62a1fc1..05f24a395 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt @@ -143,6 +143,9 @@ class KanaKanjiEngine { private lateinit var findPath: FindPath private var dictionaryBinaryReader: DictionaryBinaryReader? = null + @Volatile + private var initialOptionalDictionaryStateLoaded: Boolean = false + private lateinit var connectionMatrix: ConnectionMatrix.CostTable fun createIncrementalSessionState(): IncrementalSessionState = IncrementalSessionState( @@ -487,9 +490,37 @@ class KanaKanjiEngine { assignNeologdDictionary(newNeologd) assignWebDictionary(newWeb) mozcDictionaryActive = newMozcDictionaryActive + initialOptionalDictionaryStateLoaded = true + } + } + + /** + * Completes the dictionary state that is not supplied by the Hilt graph without rebuilding + * the already-loaded core dictionaries. The IME starts this once in the background instead + * of racing the first input against a redundant full dictionary reload. + */ + fun initializeOptionalDictionaryStateFromCurrentSources() { + val reader = checkNotNull(dictionaryBinaryReader) { + "DictionaryBinaryReader must be configured before optional dictionaries" + } + val newPerson = loadOptionalTripleDictionary(reader, DictionaryCategory.PERSON_NAME) + val newPlaces = loadOptionalTripleDictionary(reader, DictionaryCategory.PLACES) + val newWiki = loadOptionalTripleDictionary(reader, DictionaryCategory.WIKI) + val newNeologd = loadOptionalTripleDictionary(reader, DictionaryCategory.NEOLOGD) + val newWeb = loadOptionalTripleDictionary(reader, DictionaryCategory.WEB) + synchronized(this) { + assignPersonDictionary(newPerson) + assignPlacesDictionary(newPlaces) + assignWikiDictionary(newWiki) + assignNeologdDictionary(newNeologd) + assignWebDictionary(newWeb) + initialOptionalDictionaryStateLoaded = true } } + fun isInitialOptionalDictionaryStateLoaded(): Boolean = + initialOptionalDictionaryStateLoaded + private fun loadOptionalTripleDictionary( reader: DictionaryBinaryReader, category: DictionaryCategory, @@ -515,10 +546,10 @@ class KanaKanjiEngine { tangoTrie = tangoTrie, yomiTrie = yomiTrie, tokenArray = tokenArray, - succinctBitVectorLBSYomi = SuccinctBitVector(yomiTrie.LBS), - succinctBitVectorIsLeafYomi = SuccinctBitVector(yomiTrie.isLeaf), - succinctBitVectorTokenArray = SuccinctBitVector(tokenArray.bitvector), - succinctBitVectorTangoLBS = SuccinctBitVector(tangoTrie.LBS), + succinctBitVectorLBSYomi = reader.loadYomiLbsIndex(yomiKey, yomiTrie), + succinctBitVectorIsLeafYomi = reader.loadYomiLeafIndex(yomiKey, yomiTrie), + succinctBitVectorTokenArray = reader.loadTokenIndex(tokenKey, tokenArray), + succinctBitVectorTangoLBS = reader.loadTangoLbsIndex(tangoKey, tangoTrie), ) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt index a0d0189a4..0899c882b 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt @@ -77,10 +77,22 @@ class GraphBuilder { } private data class QueryTransaction( - val committedCache: CachedGraph?, + var committedCache: CachedGraph?, var inPlaceAppendRollback: InPlaceAppendRollback? = null, + var completedGraphRollback: CompletedGraphRollback? = null, ) + private data class CompletedGraphRollback( + val graph: IncrementalGraph, + val unprunedPositions: Map>, + ) { + fun restore() { + unprunedPositions.forEach { (position, nodes) -> + graph[position] = nodes + } + } + } + internal fun beginQueryTransaction() { check(queryTransaction == null) { "Graph query transaction is already active" } queryTransaction = QueryTransaction(committedCache = cachedGraph) @@ -111,11 +123,28 @@ class GraphBuilder { queryTransaction = null } + /** + * Publishes a completely constructed lattice before the cancellable DP/K-best phase. + * If that later phase is cancelled, retain the new input frontier and only restore the + * node lists that beam search may have pruned in place. + */ + internal fun commitCompletedGraph(cache: CachedGraph) { + val transaction = queryTransaction ?: return + val graph = cache.graph as? IncrementalGraph ?: return + transaction.committedCache = cache + transaction.inPlaceAppendRollback = null + transaction.completedGraphRollback = CompletedGraphRollback( + graph = graph, + unprunedPositions = cache.unprunedPositions.orEmpty(), + ) + } + internal fun committedInput(): String? = cachedGraph?.input internal fun rollbackQueryTransaction() { val transaction = queryTransaction ?: return - transaction.inPlaceAppendRollback?.restore() + transaction.completedGraphRollback?.restore() + ?: transaction.inPlaceAppendRollback?.restore() cachedGraph = transaction.committedCache queryTransaction = null } @@ -468,9 +497,12 @@ class GraphBuilder { val graph: MutableMap> = if (reusable != null) { val sessionGraph = reusable.graph as? IncrementalGraph if (sessionState != null && sessionGraph != null) { - // A session owns this graph exclusively. Keep the already-pruned lattice and - // extend it in place instead of cloning every node twice for every typed letter. - // Clear the published cache first so cancellation cannot expose a partial append. + // Keep two views of the completed prefix: the graph contains the beam-pruned DP + // view, while CachedGraph.unprunedPositions retains the complete lattice. Only + // the old input frontier can change its suffix/exact-input penalty after a + // one-character append, so restore that position and keep older DP results. + // A catch-up append cannot use the one-step path cache and therefore restores the + // complete lattice before FindPath performs a full DP pass. sessionState.registerInPlaceAppend( graph = sessionGraph, previousReusedThroughEndIndex = sessionGraph.reusedThroughEndIndex, @@ -483,14 +515,21 @@ class GraphBuilder { ) sessionState.cachedGraph = null sessionGraph.reusedThroughEndIndex = reusablePrefixLength - sessionGraph.forwardDpReusableThroughEndIndex = - if (reusable.unprunedPositions.isNullOrEmpty()) reusablePrefixLength else -1 sessionGraph.remove(reusablePrefixLength + 1) // previous EOS - // Beam pruning is query-local. With correction and optional dictionaries, nodes - // discarded on an earlier prefix can still participate in a later K-best path. - // Restore the node lists while retaining the node objects and search frontiers. - reusable.unprunedPositions?.forEach { (position, nodes) -> - sessionGraph[position] = nodes + + if ( + str.length == reusablePrefixLength + 1 && + !reusable.unprunedPositions.isNullOrEmpty() + ) { + sessionGraph.forwardDpReusableThroughEndIndex = reusablePrefixLength + reusable.unprunedPositions[reusablePrefixLength]?.let { frontierNodes -> + sessionGraph[reusablePrefixLength] = frontierNodes + } + } else { + sessionGraph.forwardDpReusableThroughEndIndex = -1 + reusable.unprunedPositions?.forEach { (position, nodes) -> + sessionGraph[position] = nodes + } } sessionGraph } else { @@ -505,6 +544,16 @@ class GraphBuilder { } else { IncrementalGraph(-1, signature).apply { put(0, mutableListOf(BOS)) } } + + fun invalidateForwardDpReuseAndRestoreCompletePrefix() { + val incrementalGraph = graph as? IncrementalGraph ?: return + if (incrementalGraph.forwardDpReusableThroughEndIndex < 0) return + reusable?.unprunedPositions?.forEach { (position, nodes) -> + incrementalGraph[position] = nodes + } + incrementalGraph.forwardDpReusableThroughEndIndex = -1 + } + graph[str.length + 1] = mutableListOf( Node( l = 0, @@ -1172,6 +1221,17 @@ class GraphBuilder { // prefix. Remove the now-invalid unknown fallback retained by the incremental graph. if (foundInAnyDictionary && reusablePrefixLength >= 0) { val fallbackEndIndex = i + 1 + val removesStablePrefixNode = + fallbackEndIndex < reusablePrefixLength && + graph[fallbackEndIndex].orEmpty().any { + it.candidateSource == CandidateSource.UNKNOWN && it.sPos == i + } + if (removesStablePrefixNode) { + // A dictionary match completed by the appended character can invalidate an + // older unknown fallback. Restore the complete prefix and deliberately fall + // back to full DP for this uncommon transition. + invalidateForwardDpReuseAndRestoreCompletePrefix() + } graph[fallbackEndIndex]?.removeAll { it.candidateSource == CandidateSource.UNKNOWN && it.sPos == i } @@ -1238,18 +1298,39 @@ class GraphBuilder { personPrefixStates = personPrefixStates, neologdPrefixStates = neologdPrefixStates, unprunedPositions = if (sessionState != null) { - graph.entries - .asSequence() - .filter { (endIndex, _) -> endIndex <= str.length } - .associateTo(LinkedHashMap()) { (endIndex, nodes) -> - endIndex to nodes.toMutableList() + val incrementalGraph = graph as? IncrementalGraph + if ( + reusable != null && + incrementalGraph?.forwardDpReusableThroughEndIndex == reusablePrefixLength + ) { + // Older positions intentionally remain pruned in the active DP view. Carry + // their complete lattice lists forward without publishing them back into the + // graph; the previous frontier and new suffix are currently unpruned. + LinkedHashMap>().apply { + reusable.unprunedPositions?.forEach { (endIndex, nodes) -> + if (endIndex < reusablePrefixLength) put(endIndex, nodes) + } + graph.entries.forEach { (endIndex, nodes) -> + if (endIndex in reusablePrefixLength..str.length) { + put(endIndex, nodes.toMutableList()) + } + } } + } else { + graph.entries + .asSequence() + .filter { (endIndex, _) -> endIndex <= str.length } + .associateTo(LinkedHashMap()) { (endIndex, nodes) -> + endIndex to nodes.toMutableList() + } + } } else { null }, ) if (sessionState != null) { sessionState.cachedGraph = updatedCache + sessionState.commitCompletedGraph(updatedCache) if (performanceStartNs != 0L) { sessionState.lastConstructGraphNs = System.nanoTime() - performanceStartNs } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt index 670a5e90c..91a4b9e2e 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt @@ -60,6 +60,7 @@ class FindPath( internal var lastExpansionCacheHitCount: Int = 0 internal var lastExpansionCacheMissCount: Int = 0 internal var lastForwardDpReused: Boolean = false + internal var afterForwardDpForTest: (() -> Unit)? = null private var queryCheckpoint: QueryCheckpoint? = null @@ -103,6 +104,7 @@ class FindPath( lastExpansionCacheHitCount = 0 lastExpansionCacheMissCount = 0 lastForwardDpReused = false + afterForwardDpForTest = null } } @@ -1026,6 +1028,7 @@ class FindPath( startPosition = forwardDpStartPosition, cancellationCheck = cancellationCheck, ) + sessionState?.afterForwardDpForTest?.invoke() val updatedCache = incrementalMetadata?.let { ForwardDpCache( inputLength = length, @@ -1616,6 +1619,7 @@ class FindPath( if (performanceState != null) { performanceState.lastForwardDpNs = System.nanoTime() - forwardDpStartNs } + sessionState?.afterForwardDpForTest?.invoke() val updatedCache = if (incrementalMetadata != null) { ForwardDpCache( diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt index 3e59bb152..c3bfe9151 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt @@ -75,6 +75,10 @@ class KanaKanjiConversionSession( internal fun committedInput(): String? = incrementalState?.committedInput() + internal fun setAfterForwardDpForTest(callback: (() -> Unit)?) { + incrementalState?.pathState?.afterForwardDpForTest = callback + } + suspend fun query(request: KanaKanjiQueryRequest): KanaKanjiQueryResult = mutex.withLock { incrementalState?.beginQueryTransaction() try { @@ -93,8 +97,8 @@ class KanaKanjiConversionSession( incrementalState?.commitQueryTransaction() result } catch (cancellation: CancellationException) { - // Keep the last fully committed prefix. Graph append and path caches have an explicit - // rollback boundary, so rapid collectLatest input no longer forces a cold rebuild. + // A completed graph has its own staged commit. Keep that newest frontier when only the + // later path search was cancelled; an incomplete append still rolls back entirely. incrementalState?.rollbackQueryTransaction() throw cancellation } catch (throwable: Throwable) { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index c67526130..39379a2aa 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -22,6 +22,7 @@ import android.os.Bundle import android.os.CombinedVibration import android.os.Handler import android.os.Looper +import android.os.Process import android.os.ResultReceiver import android.os.SystemClock import android.os.VibrationEffect @@ -334,6 +335,7 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.FlowPreview import kotlinx.coroutines.Job import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.asCoroutineDispatcher import kotlinx.coroutines.async import kotlinx.coroutines.cancel import kotlinx.coroutines.cancelChildren @@ -371,6 +373,7 @@ import java.util.Locale import java.util.concurrent.atomic.AtomicBoolean import java.util.concurrent.atomic.AtomicLong import java.util.concurrent.atomic.AtomicReference +import java.util.concurrent.Executors import java.util.regex.Pattern import javax.inject.Inject import androidx.appcompat.R as AppCompatR @@ -727,6 +730,15 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob()) private val ioScope = CoroutineScope(Dispatchers.IO + SupervisorJob()) + private val kanaKanjiConversionDispatcher = Executors.newSingleThreadExecutor { runnable -> + Thread( + { + Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY) + runnable.run() + }, + "KanaKanjiConversion", + ).apply { isDaemon = true } + }.asCoroutineDispatcher() private val mainHandler = Handler(Looper.getMainLooper()) private val runtimeGestureSettingsSource = MutableRuntimeGestureSettingsSource( RuntimeGestureSettings() @@ -2423,8 +2435,10 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, currentQwertyGlideCompositionText = null } val dictionaryReloadWillConfigureGlide = - dictionaryOverrideApplyJob?.isActive == true || - dictionaryOverrideStore.currentRevision != lastAppliedDictionaryOverrideRevision + lastAppliedDictionaryOverrideRevision != Long.MIN_VALUE && + (dictionaryOverrideApplyJob?.isActive == true || + dictionaryOverrideStore.currentRevision != + lastAppliedDictionaryOverrideRevision) if (!dictionaryReloadWillConfigureGlide) { englishEngine.configureQwertyGlideDecoderAsync( enabled = preferences.qwertyGlideInputPreference, @@ -2750,37 +2764,54 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, dictionaryOverrideApplyJob = ioScope.launch { val revisionToApply = dictionaryOverrideStore.currentRevision + val initialOptionalStateOnly = + lastAppliedDictionaryOverrideRevision == Long.MIN_VALUE && + !kanaKanjiEngine.isInitialOptionalDictionaryStateLoaded() + val startedAt = System.nanoTime() val success = runCatching { - kanaKanjiEngine.applyDictionaryOverrideState(applicationContext) - englishEngine.reloadDictionariesFromCurrentSources( - reader = dictionaryBinaryReader, - qwertyGlideInputEnabled = qwertyGlideInputPreference, - qwertyGlidePrebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( - dictionarySourceResolver - ), - canUseBundledPrebuiltIndex = !dictionarySourceResolver.shouldUseOverrideCategory( - DictionaryCategory.ENGLISH - ), - ) + if (initialOptionalStateOnly) { + kanaKanjiEngine.initializeOptionalDictionaryStateFromCurrentSources() + } else { + kanaKanjiEngine.applyDictionaryOverrideState(applicationContext) + englishEngine.reloadDictionariesFromCurrentSources( + reader = dictionaryBinaryReader, + qwertyGlideInputEnabled = qwertyGlideInputPreference, + qwertyGlidePrebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( + dictionarySourceResolver + ), + canUseBundledPrebuiltIndex = + !dictionarySourceResolver.shouldUseOverrideCategory( + DictionaryCategory.ENGLISH + ), + ) + } }.onFailure { Timber.w(it, "Failed to apply dictionary override revision $revisionToApply") }.isSuccess - if (success) { + if (success && dictionaryOverrideStore.currentRevision == revisionToApply) { lastAppliedDictionaryOverrideRevision = revisionToApply + if (initialOptionalStateOnly) { + Timber.d( + "Initial optional dictionary state loaded without core reload: " + + "elapsed_ms=${(System.nanoTime() - startedAt) / 1_000_000.0}" + ) + } } else { - // The regular reload also configures glide. If it failed before reaching that - // point, retain the lightweight asynchronous configuration as a fallback. - englishEngine.configureQwertyGlideDecoderAsync( - enabled = qwertyGlideInputPreference, - canUseBundledPrebuiltIndex = - !dictionarySourceResolver.shouldUseOverrideCategory( - DictionaryCategory.ENGLISH + if (!initialOptionalStateOnly) { + // The regular reload also configures glide. If it failed before reaching that + // point, retain the lightweight asynchronous configuration as a fallback. + englishEngine.configureQwertyGlideDecoderAsync( + enabled = qwertyGlideInputPreference, + canUseBundledPrebuiltIndex = + !dictionarySourceResolver.shouldUseOverrideCategory( + DictionaryCategory.ENGLISH + ), + prebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( + dictionarySourceResolver ), - prebuiltDictionaryLoader = QwertyGlidePrebuiltDictionaryLoader( - dictionarySourceResolver - ), - ) + ) + } } } } @@ -21301,6 +21332,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, closeConnection() scope.cancel() ioScope.cancel() + kanaKanjiConversionDispatcher.close() } private fun resetFlagsSuggestionClick() { @@ -22139,7 +22171,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, (enableTypoCorrectionQwertyEnglishKeyboardPreference == true) && (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTY || (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTYRomaji && !currentQwertyRomajiModeForSession)) - val coreResult = withContext(Dispatchers.Default) { + val coreResult = withContext(kanaKanjiConversionDispatcher) { queryKanaKanjiCore( input = insertString, mode = CandidateQueryMode.NO_TAB_DEFAULT, @@ -22266,7 +22298,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, (enableTypoCorrectionQwertyEnglishKeyboardPreference == true) && (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTY || (qwertyMode.value == TenKeyQWERTYMode.TenKeyQWERTYRomaji && !currentQwertyRomajiModeForSession)) - val coreResultDeferred = async(Dispatchers.Default) { + val coreResultDeferred = async(kanaKanjiConversionDispatcher) { measureDebugStage("IMEService.getSuggestionList.kanaKanjiEngine") { queryKanaKanjiCore( input = insertString, @@ -22403,7 +22435,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val ngWords = if (isNgWordEnable == true) ngWordsList.value.map { it.tango } else emptyList() - val coreResult = withContext(Dispatchers.Default) { + val coreResult = withContext(kanaKanjiConversionDispatcher) { queryKanaKanjiCore( input = insertString, mode = CandidateQueryMode.CONVERSION, @@ -22473,7 +22505,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private suspend fun getSuggestionListEnglishKana( insertString: String, ): List { - val engineCandidates = withContext(Dispatchers.Default) { + val engineCandidates = withContext(kanaKanjiConversionDispatcher) { queryKanaKanjiCore( input = insertString, mode = CandidateQueryMode.EISUKANA, diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt index 985ee0c6a..4cf535b17 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt @@ -124,6 +124,67 @@ class KanaKanjiConversionSessionParityTest { assertEquals("きょうは", incremental.committedInput()) } + @Test + fun completedGraphSurvivesCancellationAfterForwardDp() = runBlocking { + val localEngine = TestEngineFactory.create() + val incremental = KanaKanjiConversionSession( + localEngine, + ConversionBackend.INCREMENTAL_SESSION, + ) + incremental.query(request("きょ", CandidateQueryMode.PREDICTION, true)) + + var cancelAfterForwardDp = true + incremental.setAfterForwardDpForTest { + if (cancelAfterForwardDp) { + cancelAfterForwardDp = false + throw kotlinx.coroutines.CancellationException("controlled post-forward cancellation") + } + } + var cancellationObserved = false + try { + incremental.query(request("きょう", CandidateQueryMode.PREDICTION, true)) + } catch (_: kotlinx.coroutines.CancellationException) { + cancellationObserved = true + } + + assertTrue(cancellationObserved) + assertEquals("きょう", incremental.committedInput()) + + incremental.setAfterForwardDpForTest(null) + val recovered = incremental.query(request("きょうは", CandidateQueryMode.PREDICTION, true)) + val rebuilt = KanaKanjiConversionSession(localEngine, ConversionBackend.LEGACY).query( + request("きょうは", CandidateQueryMode.PREDICTION, true), + ) + assertEquals(rebuilt.candidates.fingerprint(), recovered.candidates.fingerprint()) + assertEquals(rebuilt.bunsetsuResult?.splitPatterns, recovered.bunsetsuResult?.splitPatterns) + assertEquals("きょうは", incremental.committedInput()) + } + + @Test + fun oneCharacterAppendReusesCommittedForwardDpAndMatchesLegacy() = runBlocking { + val localEngine = TestEngineFactory.create() + val incremental = KanaKanjiConversionSession( + localEngine, + ConversionBackend.INCREMENTAL_SESSION, + ).also { it.enablePerformanceProbe() } + val legacy = KanaKanjiConversionSession(localEngine, ConversionBackend.LEGACY) + + incremental.query(request("きょう", CandidateQueryMode.PREDICTION, true)) + val incrementalResult = incremental.query( + request("きょうは", CandidateQueryMode.PREDICTION, true), + ) + val legacyResult = legacy.query( + request("きょうは", CandidateQueryMode.PREDICTION, true), + ) + + assertTrue(incremental.performanceSnapshot()?.forwardDpReused == true) + assertEquals(legacyResult.candidates.fingerprint(), incrementalResult.candidates.fingerprint()) + assertEquals( + legacyResult.bunsetsuResult?.splitPatterns, + incrementalResult.bunsetsuResult?.splitPatterns, + ) + } + private fun request( input: String, mode: CandidateQueryMode, From ddcce2a12f4b5c324ad89d081775921a5125ad8e Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sat, 1 Aug 2026 10:14:06 -0400 Subject: [PATCH 13/24] improve n gram sysyem dictionary --- .../converter/dictionary/TokenArray.kt | 45 ++++++ .../converter/graph/GraphBuilder.kt | 149 +++++++++--------- .../converter/graph/TypoCorrectionResult.kt | 7 +- .../louds/with_term_id/LOUDSWithTermId.kt | 20 ++- .../converter/path_algorithm/FindPath.kt | 115 ++++++++++++-- .../ime_service/IMEService.kt | 32 +++- .../FindPathSessionScratchTest.kt | 26 +++ 7 files changed, 296 insertions(+), 98 deletions(-) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/dictionary/TokenArray.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/dictionary/TokenArray.kt index db2ecf1eb..6dfe0cf48 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/dictionary/TokenArray.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/dictionary/TokenArray.kt @@ -116,6 +116,51 @@ class TokenArray { } } + /** + * Visits at most [scratchIndices].size tokens in stable ascending word-cost order without + * materialising and sorting every token for the reading. [scratchIndices] belongs to the + * caller so repeated typo-frontier hits do not allocate a temporary list per result. + */ + fun forEachLowestCostDictionaryByYomiTermId( + nodeId: Int, + succinctBitVector: SuccinctBitVector, + scratchIndices: IntArray, + block: (posTableIndex: Short, wordCost: Short, nodeId: Int) -> Unit, + ) { + if (scratchIndices.isEmpty()) return + val startSelect0 = succinctBitVector.select0(nodeId) + val endSelect0 = succinctBitVector.select0(nodeId + 1) + val startRank1 = succinctBitVector.rank1(startSelect0) + val endRank1 = succinctBitVector.rank1(endSelect0) + var selectedCount = 0 + for (tokenIndex in startRank1 until endRank1) { + var insertionIndex = selectedCount + while ( + insertionIndex > 0 && + wordCostList[tokenIndex] < wordCostList[scratchIndices[insertionIndex - 1]] + ) { + insertionIndex-- + } + if (insertionIndex >= scratchIndices.size) continue + val newCount = (selectedCount + 1).coerceAtMost(scratchIndices.size) + var shiftIndex = newCount - 1 + while (shiftIndex > insertionIndex) { + scratchIndices[shiftIndex] = scratchIndices[shiftIndex - 1] + shiftIndex-- + } + scratchIndices[insertionIndex] = tokenIndex + selectedCount = newCount + } + for (index in 0 until selectedCount) { + val tokenIndex = scratchIndices[index] + block( + posTableIndexList[tokenIndex], + wordCostList[tokenIndex], + nodeIdAt(tokenIndex), + ) + } + } + fun getListDictionaryByYomiTermIdShortArray( nodeId: Short, rank0ArrayTokenArrayBitvector: ShortArray, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt index 0899c882b..b8b7fd271 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/GraphBuilder.kt @@ -376,6 +376,7 @@ class GraphBuilder { val webPrefixStates = LinkedHashMap() val personPrefixStates = LinkedHashMap() val neologdPrefixStates = LinkedHashMap() + val typoTopTokenScratch = IntArray(5) fun prefixSearch( trie: LOUDSWithTermId, @@ -719,60 +720,54 @@ class GraphBuilder { if (typo.penaltyUsed == 0) continue val yomiStr = typo.yomi - val nodeIndex = localSystemUserYomiTrie.getNodeIndex( - yomiStr, - localSystemUserLBSYomi, - ) + val nodeIndex = typo.nodeIndex if (nodeIndex <= 0) continue val termId = localSystemUserYomiTrie.getTermId( nodeIndex, localSystemUserIsLeaf, ) - val listToken = localSystemUserTokenArray.getListDictionaryByYomiTermId( - termId, - localSystemUserTokenBitVector, - ) val endIndex = i + yomiStr.length if (endIndex <= reusablePrefixLength) continue val penalty = typoCorrectionOffsetScore * typo.penaltyUsed - listToken - .sortedBy { it.wordCost } - .take(5) - .forEach { token -> - val tango = when (token.nodeId) { - -2 -> yomiStr - -1 -> yomiStr.hiraToKata() - else -> localSystemUserTangoTrie.getLetter( - token.nodeId, - succinctBitVector = localSystemUserTangoLBS, - ) - } - val cost = token.wordCost.toInt() + penalty - addOrUpdateNode( - graph, - endIndex, - Node( - l = localSystemUserTokenArray.leftIds[token.posTableIndex.toInt()], - r = localSystemUserTokenArray.rightIds[token.posTableIndex.toInt()], - score = cost, - f = cost, - g = cost, - tango = tango, - yomiUsed = yomiStr, - len = yomiStr.length.toShort(), - sPos = i, - mozcAttributes = mozcAttributesFor( - localSystemUserTokenArray.leftIds[token.posTableIndex.toInt()], - ), - ), - graphNodeDedupMode, - graphNodeTrace, - str, - "SYSTEM_USER_TYPO", + localSystemUserTokenArray.forEachLowestCostDictionaryByYomiTermId( + nodeId = termId, + succinctBitVector = localSystemUserTokenBitVector, + scratchIndices = typoTopTokenScratch, + ) { posTableIndex, wordCost, tokenNodeId -> + val tango = when (tokenNodeId) { + -2 -> yomiStr + -1 -> yomiStr.hiraToKata() + else -> localSystemUserTangoTrie.getLetter( + tokenNodeId, + succinctBitVector = localSystemUserTangoLBS, ) } + val cost = wordCost.toInt() + penalty + addOrUpdateNode( + graph, + endIndex, + Node( + l = localSystemUserTokenArray.leftIds[posTableIndex.toInt()], + r = localSystemUserTokenArray.rightIds[posTableIndex.toInt()], + score = cost, + f = cost, + g = cost, + tango = tango, + yomiUsed = yomiStr, + len = yomiStr.length.toShort(), + sPos = i, + mozcAttributes = mozcAttributesFor( + localSystemUserTokenArray.leftIds[posTableIndex.toInt()], + ), + ), + graphNodeDedupMode, + graphNodeTrace, + str, + "SYSTEM_USER_TYPO", + ) + } } } @@ -908,52 +903,50 @@ class GraphBuilder { if (typo.penaltyUsed == 0) continue val yomiStr = typo.yomi - val nodeIndex = yomiTrie.getNodeIndex(yomiStr, succinctBitVectorLBSYomi) + val nodeIndex = typo.nodeIndex if (nodeIndex <= 0) continue val termId = yomiTrie.getTermId(nodeIndex, succinctBitVectorIsLeafYomi) - val listToken = tokenArray.getListDictionaryByYomiTermId( - termId, - succinctBitVectorTokenArray - ) - val endIndex = i + yomiStr.length if (endIndex <= reusablePrefixLength) continue val penalty = typoCorrectionOffsetScore * typo.penaltyUsed - listToken - .sortedBy { it.wordCost } - .take(5) - .forEach { token -> - val tango = when (token.nodeId) { - -2 -> yomiStr - -1 -> yomiStr.hiraToKata() - else -> tangoTrie.getLetter(token.nodeId, succinctBitVectorTangoLBS) - } + tokenArray.forEachLowestCostDictionaryByYomiTermId( + nodeId = termId, + succinctBitVector = succinctBitVectorTokenArray, + scratchIndices = typoTopTokenScratch, + ) { posTableIndex, wordCost, tokenNodeId -> + val tango = when (tokenNodeId) { + -2 -> yomiStr + -1 -> yomiStr.hiraToKata() + else -> tangoTrie.getLetter(tokenNodeId, succinctBitVectorTangoLBS) + } - val cost = token.wordCost.toInt() + penalty + val cost = wordCost.toInt() + penalty - addOrUpdateNode( - graph, - endIndex, - Node( - l = tokenArray.leftIds[token.posTableIndex.toInt()], - r = tokenArray.rightIds[token.posTableIndex.toInt()], - score = cost, - f = cost, - g = cost, - tango = tango, - yomiUsed = yomiStr, - len = yomiStr.length.toShort(), - sPos = i, - mozcAttributes = mozcAttributesFor(tokenArray.leftIds[token.posTableIndex.toInt()]), + addOrUpdateNode( + graph, + endIndex, + Node( + l = tokenArray.leftIds[posTableIndex.toInt()], + r = tokenArray.rightIds[posTableIndex.toInt()], + score = cost, + f = cost, + g = cost, + tango = tango, + yomiUsed = yomiStr, + len = yomiStr.length.toShort(), + sPos = i, + mozcAttributes = mozcAttributesFor( + tokenArray.leftIds[posTableIndex.toInt()], ), - graphNodeDedupMode, - graphNodeTrace, - str, - "SYSTEM_TYPO", - ) - } + ), + graphNodeDedupMode, + graphNodeTrace, + str, + "SYSTEM_TYPO", + ) + } } } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt index d529baab0..5f01debbe 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/graph/TypoCorrectionResult.kt @@ -1,3 +1,8 @@ package com.kazumaproject.markdownhelperkeyboard.converter.graph -data class TypoCorrectionResult(val yomi: String, val penaltyUsed: Int) +data class TypoCorrectionResult( + val yomi: String, + val penaltyUsed: Int, + /** LOUDS bit position reached by this result. Avoids traversing [yomi] a second time. */ + val nodeIndex: Int = -1, +) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt index e5e862165..0c51eddd1 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/louds/with_term_id/LOUDSWithTermId.kt @@ -892,6 +892,7 @@ class LOUDSWithTermId { acceptedPenalties = emptyMap(), ) val acceptedResults = LinkedHashMap() + val acceptedNodeIndices = HashMap() val endExclusive = minOf(str.length, startIndex + maxLen) for (index in startIndex until endExclusive) { progress = advanceTypoCorrectionSearch( @@ -906,6 +907,7 @@ class LOUDSWithTermId { val previousPenalty = acceptedResults[result.yomi] if (previousPenalty == null || result.penaltyUsed < previousPenalty) { acceptedResults[result.yomi] = result.penaltyUsed + acceptedNodeIndices[result.yomi] = result.nodeIndex } } if (progress.terminalStates.isEmpty()) break @@ -917,7 +919,13 @@ class LOUDSWithTermId { .thenByDescending { it.key.length } .thenBy { it.key } ) - .map { TypoCorrectionResult(it.key, it.value) } + .map { + TypoCorrectionResult( + yomi = it.key, + penaltyUsed = it.value, + nodeIndex = checkNotNull(acceptedNodeIndices[it.key]), + ) + } return progress.copy(results = results) } @@ -935,6 +943,7 @@ class LOUDSWithTermId { val bestPenaltyByYomi = HashMap(previous.acceptedPenalties) val terminalStates = ArrayList() val newResults = LinkedHashMap() + val newResultNodeIndices = HashMap() val typoCandidates = getTypoCandidates(char) for (state in previous.terminalStates) { if (bestPenaltyByYomi.size >= maxResults) break @@ -951,6 +960,7 @@ class LOUDSWithTermId { if (oldPenalty == null || nextPenalty < oldPenalty) { bestPenaltyByYomi[yomi] = nextPenalty newResults[yomi] = nextPenalty + newResultNodeIndices[yomi] = child } } } @@ -960,7 +970,13 @@ class LOUDSWithTermId { .thenByDescending { it.key.length } .thenBy { it.key } ) - .map { TypoCorrectionResult(it.key, it.value) } + .map { + TypoCorrectionResult( + yomi = it.key, + penaltyUsed = it.value, + nodeIndex = checkNotNull(newResultNodeIndices[it.key]), + ) + } return TypoSearchProgress(results, terminalStates, bestPenaltyByYomi) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt index 91a4b9e2e..b3bd1251a 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt @@ -349,10 +349,10 @@ class FindPath( expansionCache.reset() queueElementPool.clear() } else { - // Restoring an unpruned incremental lattice can add predecessor nodes to an - // existing position. Cached expansion lists are therefore query-local even - // though node identities and the reusable work arena remain session-local. - expansionCache.clear() + // Expansion keys include the predecessor-list identity. A one-character append + // replaces the restored frontier list, while older pruned lists retain their + // identity, so only the changed frontier and new suffix miss the cache. + expansionCache.prepareForIncrementalQuery() } expansionCache.configure( connectionMatrix = connectionMatrix, @@ -486,6 +486,7 @@ class FindPath( private var nextNode2 = IntArray(currentNode.size) private var nextNode3 = IntArray(currentNode.size) private var adjustedScore = IntArray(currentNode.size) + private var predecessorLists = arrayOfNulls>(currentNode.size) private var values = arrayOfNulls(currentNode.size) private var stamps = IntArray(currentNode.size) private var generation = 1 @@ -529,6 +530,7 @@ class FindPath( fun reset() { clear() + predecessorLists.fill(null) values.fill(null) configured = false configuredConnectionMatrix = null @@ -537,22 +539,37 @@ class FindPath( configuredBoundaryMode = null } + fun prepareForIncrementalQuery() { + if (entryCount < MAX_RETAINED_ENTRY_COUNT) return + clear() + predecessorLists.fill(null) + values.fill(null) + } + fun get( currentNode: Int, nextNode1: Int, nextNode2: Int, nextNode3: Int, adjustedScore: Int, + predecessorList: List, ): ExpansionList? { - var slot = hash(currentNode, nextNode1, nextNode2, nextNode3, adjustedScore) and - (stamps.size - 1) + var slot = hash( + currentNode, + nextNode1, + nextNode2, + nextNode3, + adjustedScore, + predecessorList, + ) and (stamps.size - 1) while (stamps[slot] == generation) { if ( this.currentNode[slot] == currentNode && this.nextNode1[slot] == nextNode1 && this.nextNode2[slot] == nextNode2 && this.nextNode3[slot] == nextNode3 && - this.adjustedScore[slot] == adjustedScore + this.adjustedScore[slot] == adjustedScore && + this.predecessorLists[slot] === predecessorList ) return values[slot] slot = (slot + 1) and (stamps.size - 1) } @@ -565,18 +582,26 @@ class FindPath( nextNode2: Int, nextNode3: Int, adjustedScore: Int, + predecessorList: List, value: ExpansionList, ) { if ((entryCount + 1) * 10 >= stamps.size * 6) grow() - var slot = hash(currentNode, nextNode1, nextNode2, nextNode3, adjustedScore) and - (stamps.size - 1) + var slot = hash( + currentNode, + nextNode1, + nextNode2, + nextNode3, + adjustedScore, + predecessorList, + ) and (stamps.size - 1) while (stamps[slot] == generation) { if ( this.currentNode[slot] == currentNode && this.nextNode1[slot] == nextNode1 && this.nextNode2[slot] == nextNode2 && this.nextNode3[slot] == nextNode3 && - this.adjustedScore[slot] == adjustedScore + this.adjustedScore[slot] == adjustedScore && + this.predecessorLists[slot] === predecessorList ) { values[slot] = value return @@ -589,6 +614,7 @@ class FindPath( this.nextNode2[slot] = nextNode2 this.nextNode3[slot] = nextNode3 this.adjustedScore[slot] = adjustedScore + this.predecessorLists[slot] = predecessorList values[slot] = value entryCount++ } @@ -599,6 +625,7 @@ class FindPath( val oldNextNode2 = nextNode2 val oldNextNode3 = nextNode3 val oldAdjustedScore = adjustedScore + val oldPredecessorLists = predecessorLists val oldValues = values val oldStamps = stamps val oldGeneration = generation @@ -608,6 +635,7 @@ class FindPath( nextNode2 = IntArray(currentNode.size) nextNode3 = IntArray(currentNode.size) adjustedScore = IntArray(currentNode.size) + predecessorLists = arrayOfNulls(currentNode.size) values = arrayOfNulls(currentNode.size) stamps = IntArray(currentNode.size) generation = 1 @@ -620,6 +648,7 @@ class FindPath( nextNode2 = oldNextNode2[slot], nextNode3 = oldNextNode3[slot], adjustedScore = oldAdjustedScore[slot], + predecessorList = checkNotNull(oldPredecessorLists[slot]), value = checkNotNull(oldValues[slot]), ) } @@ -639,14 +668,18 @@ class FindPath( nextNode2: Int, nextNode3: Int, adjustedScore: Int, + predecessorList: List, ): Int { var result = currentNode result = 31 * result + nextNode1 result = 31 * result + nextNode2 result = 31 * result + nextNode3 result = 31 * result + adjustedScore + result = 31 * result + System.identityHashCode(predecessorList) return result xor (result ushr 16) } + + const val MAX_RETAINED_ENTRY_COUNT = 32_768 } } @@ -717,6 +750,37 @@ class FindPath( return true } + fun containsExactCost( + nodeIdentity: Int, + nextIdentity1: Int, + nextIdentity2: Int, + nextIdentity3: Int, + outputPathId: Int, + sourceMask: Int, + cost: Int, + ): Boolean { + var slot = hash( + nodeIdentity, + nextIdentity1, + nextIdentity2, + nextIdentity3, + outputPathId, + sourceMask, + ) and (stamps.size - 1) + while (stamps[slot] == generation) { + if ( + this.nodeIdentity[slot] == nodeIdentity && + this.nextIdentity1[slot] == nextIdentity1 && + this.nextIdentity2[slot] == nextIdentity2 && + this.nextIdentity3[slot] == nextIdentity3 && + this.sourceMask[slot] == sourceMask && + this.outputPathId[slot] == outputPathId + ) return costs[slot] == cost + slot = (slot + 1) and (stamps.size - 1) + } + return false + } + private fun grow() { val oldNodeIdentity = nodeIdentity val oldNextIdentity1 = nextIdentity1 @@ -1086,6 +1150,7 @@ class FindPath( if (cancellationPollCounter++ and 0x3f == 0) cancellationCheck() val element = pQueue.poll() ?: break val currentNode = element.node + if (!isCurrentBestBackwardState(element, searchScratch)) continue if (currentNode.tango == "BOS") { val stringFromNode = searchScratch.outputString(element.outputPathId) @@ -1315,23 +1380,24 @@ class FindPath( } else { -1 } + val previousNodes = getPrevNodes2( + graph = graph, + node = currentNode, + startPosition = currentNode.sPos, + ) scratch.expansionCache.get( currentNode = currentNodeId, nextNode1 = nextNode1Id, nextNode2 = nextNode2Id, nextNode3 = nextNode3Id, adjustedScore = currentNode.adjustedScore, + predecessorList = previousNodes, )?.let { scratch.expansionCacheHitCount++ return it } scratch.expansionCacheMissCount++ - val previousNodes = getPrevNodes2( - graph = graph, - node = currentNode, - startPosition = currentNode.sPos, - ) val cachedNodes = arrayOfNulls(previousNodes.size) val localCosts = IntArray(previousNodes.size) var count = 0 @@ -1365,6 +1431,7 @@ class FindPath( nextNode2 = nextNode2Id, nextNode3 = nextNode3Id, adjustedScore = currentNode.adjustedScore, + predecessorList = previousNodes, value = result, ) } @@ -1411,6 +1478,23 @@ class FindPath( ) } + private fun isCurrentBestBackwardState( + element: PathQueueElement, + scratch: BackwardSearchScratch, + ): Boolean { + val next = element.next ?: return true // The initial EOS element is not in the state table. + val nodeIds = scratch.nodeIds + return scratch.bestBackwardCostByState.containsExactCost( + nodeIdentity = nodeIds.getValue(element.node), + nextIdentity1 = nodeIds.getValue(next.node), + nextIdentity2 = next.next?.node?.let(nodeIds::getValue) ?: -1, + nextIdentity3 = next.next?.next?.node?.let(nodeIds::getValue) ?: -1, + outputPathId = element.outputPathId, + sourceMask = element.sourceMask, + cost = element.backwardCost, + ) + } + private fun getEdgeCost( rid: Int, lid: Int, @@ -1734,6 +1818,7 @@ class FindPath( if (cancellationPollCounter++ and 0x3f == 0) cancellationCheck() val element = pQueue.poll() ?: break val currentNode = element.node + if (!isCurrentBestBackwardState(element, searchScratch)) continue if (currentNode.tango == "BOS") { val stringFromNode = searchScratch.outputString(element.outputPathId) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 39379a2aa..091ebb3ae 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -21892,9 +21892,24 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, if (!shouldApplyCandidateResult(insertString, token)) { return } + val shouldApplyLiveConversion = + shouldStartLiveConversion(insertString) && !hasConvertedKatakana + val applyLiveConversionBeforeCandidateStrip = + shouldApplyLiveConversion && liveConversionApplyDelayMillis() == 0L + if (applyLiveConversionBeforeCandidateStrip) { + // This is the completed conversion candidate, not a raw composing fallback. Keep the + // candidate-strip DiffUtil work out of the visible live-conversion critical path. + delayBeforeApplyingLiveConversion() + if (!shouldApplyCandidateResult(insertString, token)) return + if (!applyFirstSuggestionOnMainIfCurrent( + insertString = insertString, + candidate = displayedCandidates.firstOrNull(), + ) + ) return + } updateDisplayedCandidates(insertString, displayedCandidates) - if (shouldStartLiveConversion(insertString) && !hasConvertedKatakana) { + if (shouldApplyLiveConversion && !applyLiveConversionBeforeCandidateStrip) { delayBeforeApplyingLiveConversion() if (!shouldApplyCandidateResult(insertString, token)) { return @@ -21958,9 +21973,22 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, if (!shouldApplyCandidateResult(insertString, token)) { return } + val shouldApplyLiveConversion = + shouldStartLiveConversion(insertString) && !hasConvertedKatakana + val applyLiveConversionBeforeCandidateStrip = + shouldApplyLiveConversion && liveConversionApplyDelayMillis() == 0L + if (applyLiveConversionBeforeCandidateStrip) { + delayBeforeApplyingLiveConversion() + if (!shouldApplyCandidateResult(insertString, token)) return + if (!applyFirstSuggestionOnMainIfCurrent( + insertString = insertString, + candidate = displayedCandidates.firstOrNull(), + ) + ) return + } updateDisplayedCandidates(insertString, displayedCandidates) - if (shouldStartLiveConversion(insertString) && !hasConvertedKatakana) { + if (shouldApplyLiveConversion && !applyLiveConversionBeforeCandidateStrip) { delayBeforeApplyingLiveConversion() if (!shouldApplyCandidateResult(insertString, token)) { return diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPathSessionScratchTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPathSessionScratchTest.kt index 4bb899385..876697a7b 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPathSessionScratchTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPathSessionScratchTest.kt @@ -28,14 +28,40 @@ class FindPathSessionScratchTest { fun stateTableKeepsOnlyTheLowestCostForAnExactState() { val table = FindPath.StateCostTable(initialCapacity = 16) assertTrue(table.putIfLower(1, 2, 3, 4, 5, 0, 100)) + assertTrue(table.containsExactCost(1, 2, 3, 4, 5, 0, 100)) assertFalse(table.putIfLower(1, 2, 3, 4, 5, 0, 101)) assertTrue(table.putIfLower(1, 2, 3, 4, 5, 0, 99)) + assertFalse(table.containsExactCost(1, 2, 3, 4, 5, 0, 100)) + assertTrue(table.containsExactCost(1, 2, 3, 4, 5, 0, 99)) assertTrue("a different canonical output remains a candidate", table.putIfLower(1, 2, 3, 4, 6, 0, 101)) table.clear() assertTrue(table.putIfLower(1, 2, 3, 4, 5, 0, 200)) } + @Test + fun expansionCacheReusesOnlyTheSamePredecessorList() { + val cache = FindPath.ExpansionCache(initialCapacity = 16) + val predecessor = Node( + l = 0, + r = 0, + score = 0, + f = 0, + tango = "前", + len = 1, + yomiUsed = "まえ", + sPos = 0, + ) + val firstList = mutableListOf(predecessor) + val restoredFrontier = mutableListOf(predecessor) + val expansion = FindPath.ExpansionList(arrayOf(predecessor), intArrayOf(123), 1) + + cache.put(1, 2, 3, 4, 5, firstList, expansion) + + assertSame(expansion, cache.get(1, 2, 3, 4, 5, firstList)) + assertNull(cache.get(1, 2, 3, 4, 5, restoredFrontier)) + } + @Test fun kBestStateTableRetainsOnlyTheExactLowestDistinctSuffixes() { val table = FindPath.KBestStateCostTable(k = 2, initialCapacity = 16) From 7c39efa3a238edb40cb4fd29494f0dfc203533ad Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sun, 2 Aug 2026 06:59:11 -0400 Subject: [PATCH 14/24] fix number extension --- ...apaneseNumberConversionInstrumentedTest.kt | 270 ++++++++++++++++++ .../converter/engine/KanaKanjiEngine.kt | 139 ++++++--- .../extensions/NumberExtenstion.kt | 227 ++++++++------- .../extensions/StringExtenstion.kt | 21 -- .../KanaKanjiEngineEnglishKanaNumberTest.kt | 61 ++++ .../extensions/NumberExtensionTest.kt | 62 +++- 6 files changed, 611 insertions(+), 169 deletions(-) create mode 100644 app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/JapaneseNumberConversionInstrumentedTest.kt diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/JapaneseNumberConversionInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/JapaneseNumberConversionInstrumentedTest.kt new file mode 100644 index 000000000..203aa42a9 --- /dev/null +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/JapaneseNumberConversionInstrumentedTest.kt @@ -0,0 +1,270 @@ +package com.kazumaproject.markdownhelperkeyboard.converter + +import android.content.Context +import android.os.Build +import android.os.Debug +import androidx.test.core.app.ApplicationProvider +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine +import com.kazumaproject.markdownhelperkeyboard.ime_service.di.KanaKanjiEngineEntryPoint +import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryRepository +import dagger.hilt.android.EntryPointAccessors +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import java.io.File +import java.util.Locale + +@RunWith(AndroidJUnit4::class) +class JapaneseNumberConversionInstrumentedTest { + + @Test + fun verifyCorrectnessAndMeasureProductionPaths() = runBlocking { + val context = ApplicationProvider.getApplicationContext() + val entryPoint = EntryPointAccessors.fromApplication( + context.applicationContext, + KanaKanjiEngineEntryPoint::class.java, + ) + val engine = entryPoint.kanaKanjiEngine() + val repository = entryPoint.userDictionaryRepository() + + val forbiddenByInput = linkedMapOf( + "よしよし" to setOf("4444", "４４４４", "8383", "８３８３", "四千四百四十四"), + "しせん" to setOf("4000", "４０００", "4,000", "四千"), + "くちょう" to setOf("9000000000000", "９００００００００００００", "九兆", "9兆"), + "ちょうせん" to setOf("1000000001000", "一兆一千"), + "ごご" to setOf("55", "５５", "五十五"), + "さんご" to setOf("35", "３５", "三十五"), + "しえん" to setOf("4円", "４円"), + "しじ" to setOf("4時", "４時"), + "いちいち" to setOf("11", "１１", "十一"), + "さんさん" to setOf("33", "３３", "三十三"), + "ろくろく" to setOf("66", "６６", "六十六"), + "よせん" to setOf("4000", "４０００", "4,000", "四千"), + "くせん" to setOf("9000", "９０００", "9,000", "九千"), + ) + + val englishKanaResults = linkedMapOf>() + forbiddenByInput.forEach { (input, forbidden) -> + val candidates = engine.getCandidatesEnglishKana(input) + englishKanaResults[input] = candidates + assertEquals(input, candidates.first().string) + assertTrue( + "$input unexpectedly generated ${candidates.map { it.string }}", + candidates.none { it.string in forbidden }, + ) + } + + val validInputs = linkedMapOf( + "よんせん" to setOf("4000", "四千"), + "きゅうちょう" to setOf("9000000000000", "九兆"), + "さんにん" to setOf("3人"), + "にじゅっぷん" to setOf("20分"), + "ろくじ" to setOf("6時"), + "にじゅうよじ" to setOf("24時"), + "くじ" to setOf("9時"), + "いっちょう" to setOf("1000000000000", "一兆"), + "しじゅう" to setOf("40", "四十"), + "じゅうよ" to setOf("14", "十四"), + "よにん" to setOf("4人"), + "よえん" to setOf("4円"), + "くえん" to setOf("9円"), + "くにん" to setOf("9人"), + "いっぷん" to setOf("1分"), + "ろっぷん" to setOf("6分"), + "はっぷん" to setOf("8分"), + ) + validInputs.forEach { (input, required) -> + val candidates = engine.getCandidatesEnglishKana(input) + englishKanaResults[input] = candidates + val values = candidates.mapTo(hashSetOf()) { it.string } + assertTrue("$input missing $required from $values", values.containsAll(required)) + } + + val standardResults = linkedMapOf>() + forbiddenByInput.forEach { (input, forbidden) -> + val candidates = engine.convertOriginal(input, repository) + standardResults[input] = candidates + assertTrue( + "$input unexpectedly generated ${candidates.map { it.string }}", + candidates.none { it.string in forbidden }, + ) + } + + val benchmarkCorpus = (forbiddenByInput.keys + validInputs.keys).toList() + val englishKanaBenchmark = measureConversions( + label = "englishKana", + corpus = benchmarkCorpus, + warmupIterations = 1_000, + measuredIterations = 20_000, + ) { input -> + engine.getCandidatesEnglishKana(input) + } + val standardBenchmark = measureConversions( + label = "standardDictionary", + corpus = benchmarkCorpus, + warmupIterations = 30, + measuredIterations = 500, + ) { input -> + engine.convertOriginal(input, repository) + } + + val report = buildString { + appendLine("device=${Build.MANUFACTURER} ${Build.MODEL}") + appendLine("api=${Build.VERSION.SDK_INT}") + appendLine("abi=${Build.SUPPORTED_ABIS.joinToString()}") + appendLine("correctness=PASS") + appendLine("forbiddenCaseCount=${forbiddenByInput.size}") + appendLine("validCaseCount=${validInputs.size}") + appendLine(englishKanaBenchmark.asReportLine()) + appendLine(standardBenchmark.asReportLine()) + appendLine("englishKanaCandidates") + englishKanaResults.forEach { (input, candidates) -> + appendLine("$input\t${candidates.take(16).joinToString(" / ") { it.string }}") + } + appendLine("standardCandidates") + standardResults.forEach { (input, candidates) -> + appendLine("$input\t${candidates.take(16).joinToString(" / ") { it.string }}") + } + } + + val outputDir = File(context.filesDir, "conversion-perf").apply { mkdirs() } + File(outputDir, "japanese-number-conversion.txt").writeText(report) + println("JAPANESE_NUMBER_CONVERSION_REPORT\n$report") + } + + private suspend fun KanaKanjiEngine.convertOriginal( + input: String, + repository: UserDictionaryRepository, + ): List = getCandidatesOriginal( + input = input, + n = 8, + mozcUtPersonName = false, + mozcUTPlaces = false, + mozcUTWiki = false, + mozcUTNeologd = false, + mozcUTWeb = false, + userDictionaryRepository = repository, + learnRepository = null, + isOmissionSearchEnable = false, + enableTypoCorrectionJapaneseFlick = false, + enableTypoCorrectionQwertyEnglish = false, + typoCorrectionOffsetScore = 3_000, + omissionSearchOffsetScore = 3_000, + beamWidth = 20, + ) + + private suspend fun measureConversions( + label: String, + corpus: List, + warmupIterations: Int, + measuredIterations: Int, + convert: suspend (String) -> List, + ): BenchmarkResult { + var blackHole = 0L + repeat(warmupIterations) { index -> + val candidates = convert(corpus[index % corpus.size]) + blackHole += candidates.size + (candidates.firstOrNull()?.string?.length ?: 0) + } + + forceGc() + val baseline = memorySnapshot() + val allocatedBefore = allocatedBytes() + val samplesNs = LongArray(measuredIterations) + + repeat(measuredIterations) { index -> + val startedNs = System.nanoTime() + val candidates = convert(corpus[index % corpus.size]) + samplesNs[index] = System.nanoTime() - startedNs + blackHole += candidates.size + (candidates.firstOrNull()?.string?.length ?: 0) + } + + val allocatedAfter = allocatedBytes() + val immediate = memorySnapshot() + forceGc() + val settled = memorySnapshot() + val sortedNs = samplesNs.sortedArray() + + return BenchmarkResult( + label = label, + iterations = measuredIterations, + averageUs = samplesNs.average() / 1_000.0, + p50Us = sortedNs.percentile(0.50) / 1_000.0, + p95Us = sortedNs.percentile(0.95) / 1_000.0, + allocatedBytesPerCall = allocatedBefore?.let { before -> + allocatedAfter?.let { after -> (after - before).coerceAtLeast(0L).toDouble() / measuredIterations } + }, + baseline = baseline, + immediate = immediate, + settled = settled, + blackHole = blackHole, + ) + } + + private fun LongArray.percentile(fraction: Double): Long { + if (isEmpty()) return 0L + val index = ((size - 1) * fraction).toInt().coerceIn(indices) + return this[index] + } + + private fun allocatedBytes(): Long? = + Debug.getRuntimeStat("art.gc.bytes-allocated")?.toLongOrNull() + + private fun memorySnapshot(): MemorySnapshot { + val runtime = Runtime.getRuntime() + return MemorySnapshot( + javaHeapKb = (runtime.totalMemory() - runtime.freeMemory()) / 1024L, + totalPssKb = Debug.getPss().toLong(), + ) + } + + private fun forceGc() { + repeat(2) { + Runtime.getRuntime().gc() + System.runFinalization() + Thread.sleep(100) + } + } + + private data class MemorySnapshot( + val javaHeapKb: Long, + val totalPssKb: Long, + ) + + private data class BenchmarkResult( + val label: String, + val iterations: Int, + val averageUs: Double, + val p50Us: Double, + val p95Us: Double, + val allocatedBytesPerCall: Double?, + val baseline: MemorySnapshot, + val immediate: MemorySnapshot, + val settled: MemorySnapshot, + val blackHole: Long, + ) { + fun asReportLine(): String = String.format( + Locale.US, + "%s iterations=%d avgUs=%.3f p50Us=%.3f p95Us=%.3f " + + "allocatedBytesPerCall=%s " + + "heapBaselineKb=%d heapImmediateKb=%d heapSettledKb=%d " + + "pssBaselineKb=%d pssImmediateKb=%d pssSettledKb=%d blackHole=%d", + label, + iterations, + averageUs, + p50Us, + p95Us, + allocatedBytesPerCall?.let { String.format(Locale.US, "%.1f", it) } ?: "unavailable", + baseline.javaHeapKb, + immediate.javaHeapKb, + settled.javaHeapKb, + baseline.totalPssKb, + immediate.totalPssKb, + settled.totalPssKb, + blackHole, + ) + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt index 05f24a395..4c549a38a 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt @@ -52,7 +52,6 @@ import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.convertFu import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.convertFullWidthNumbersToHalfWidth import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.convertToKanjiNotation import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.createValueBasedSymbolCandidates -import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.groupAndReplaceJapaneseForNumber import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.isAllEnglishLetters import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.isAllFullWidthAscii import com.kazumaproject.markdownhelperkeyboard.ime_service.extensions.isAllHalfWidthAscii @@ -78,6 +77,12 @@ import java.text.SimpleDateFormat import java.util.Calendar import java.util.Locale +private const val POS_ID_COUNTER_GENERIC: Short = 2011 +private const val POS_ID_COUNTER_TIME: Short = 2015 +private const val POS_ID_NUMBER_ARABIC: Short = 2044 +private const val POS_ID_NUMBER_SEPARATED: Short = 2045 +private const val POS_ID_NUMBER_KANJI: Short = 2046 + class KanaKanjiEngine { data class IncrementalPerformanceSnapshot( @@ -4073,49 +4078,60 @@ class KanaKanjiEngine { predictionConfig: PredictionConfig = PredictionConfig(), ): List { val inputToEnglish = input.replaceJapaneseCharactersForEnglish() - val inputToNumbers = input.groupAndReplaceJapaneseForNumber() + val explicitDigitInput = input.takeIf { value -> + value.isNotEmpty() && value.all { it in '0'..'9' || it in '０'..'９' } + } val directJapaneseNumber = input.toNumber() val numberUnitCandidates = createCandidatesForJapaneseNumberWithUnit(input) val preferredNumberCandidate = when { numberUnitCandidates.isNotEmpty() -> numberUnitCandidates.first().string directJapaneseNumber != null -> directJapaneseNumber.second - else -> inputToNumbers + explicitDigitInput != null -> explicitDigitInput.convertFullWidthNumbersToHalfWidth() + else -> null } - val listJapaneseCandidates = listOf( - Candidate( + val listJapaneseCandidates = buildList { + add(Candidate( string = input, type = (1).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( + )) + add(Candidate( string = input.hiraToKata(), type = (1).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( + )) + add(Candidate( string = input.toHankakuKatakana(), type = (31).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( + )) + add(Candidate( string = inputToEnglish, type = (1).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( + )) + add(Candidate( string = inputToEnglish.replaceFirstChar { it.uppercaseChar() }, type = (1).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( + )) + add(Candidate( string = inputToEnglish.uppercase(), type = (1).toByte(), length = input.length.toUByte(), score = 3000 - ), Candidate( - string = preferredNumberCandidate, - type = (1).toByte(), - length = input.length.toUByte(), - score = 3000 - ) - ) + )) + if (preferredNumberCandidate != null && preferredNumberCandidate != input) { + add(Candidate( + string = preferredNumberCandidate, + type = (1).toByte(), + length = input.length.toUByte(), + score = 3000 + )) + } + } val digitCandidates = when { directJapaneseNumber != null -> createDigitCandidates( @@ -4123,7 +4139,11 @@ class KanaKanjiEngine { ) numberUnitCandidates.isNotEmpty() -> emptyList() - else -> createDigitCandidates(inputToNumbers, input.length.toUByte()) + explicitDigitInput != null -> createDigitCandidates( + explicitDigitInput, + input.length.toUByte(), + ) + else -> emptyList() } val englishDeferred = if (input.isAllEnglishLetters()) { @@ -4251,16 +4271,16 @@ class KanaKanjiEngine { type = 22, length = inputLength, score = 8000, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_ARABIC, + rightId = POS_ID_NUMBER_ARABIC ) val halfWidth = Candidate( string = halfWidthDigits.convertFullWidthToHalfWidth(), type = 31, length = inputLength, score = 8000, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_ARABIC, + rightId = POS_ID_NUMBER_ARABIC ) val timeConversion = createCandidatesForTime(halfWidthDigits) val dateConversion = createCandidatesForDateInDigit(halfWidthDigits) @@ -4274,8 +4294,8 @@ class KanaKanjiEngine { type = 17, score = 2000, length = inputLength, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_KANJI, + rightId = POS_ID_NUMBER_KANJI ) ) add( @@ -4284,8 +4304,8 @@ class KanaKanjiEngine { type = 19, score = 8001, length = inputLength, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_SEPARATED, + rightId = POS_ID_NUMBER_SEPARATED ) ) add( @@ -4294,8 +4314,8 @@ class KanaKanjiEngine { type = 18, score = 8002, length = inputLength, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_ARABIC, + rightId = POS_ID_NUMBER_ARABIC ) ) add( @@ -4304,8 +4324,8 @@ class KanaKanjiEngine { type = 23, score = 7900, length = inputLength, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_KANJI, + rightId = POS_ID_NUMBER_KANJI ) ) } @@ -4324,9 +4344,13 @@ class KanaKanjiEngine { for ((readingSuffix, unit) in unitMappings) { if (!input.endsWith(readingSuffix) || input.length <= readingSuffix.length) continue - val number = input.removeSuffix(readingSuffix).toNumber() ?: continue + val numberReading = normalizeJapaneseNumberReadingForCounter( + input.removeSuffix(readingSuffix), + readingSuffix, + ) ?: continue + val number = numberReading.toNumber() ?: continue val isTimeLike = unit == "時" || unit == "分" - val connectionId = if (isTimeLike) 1851.toShort() else 2040.toShort() + val rightId = if (unit == "時") POS_ID_COUNTER_TIME else POS_ID_COUNTER_GENERIC return listOf( Candidate( @@ -4334,15 +4358,15 @@ class KanaKanjiEngine { type = if (isTimeLike) CANDIDATE_TYPE_TIME else 18, length = input.length.toUByte(), score = 8000, - leftId = connectionId, - rightId = connectionId + leftId = POS_ID_NUMBER_ARABIC, + rightId = rightId ), Candidate( string = "${number.first}$unit", type = if (isTimeLike) 30 else 22, length = input.length.toUByte(), score = 8001, - leftId = connectionId, - rightId = connectionId + leftId = POS_ID_NUMBER_ARABIC, + rightId = rightId ) ) } @@ -4350,6 +4374,31 @@ class KanaKanjiEngine { return emptyList() } + private fun normalizeJapaneseNumberReadingForCounter( + numberReading: String, + counterReading: String, + ): String? { + fun isStandaloneOrAfterPlace(alias: String): Boolean { + if (numberReading == alias) return true + val prefix = numberReading.dropLast(alias.length) + return listOf("じゅう", "ひゃく", "せん", "まん", "おく", "ちょう") + .any(prefix::endsWith) + } + + // 「し」は単独の四としては有効だが、現在扱っている助数詞の + // 直前では通常語との衝突が大きい（しじ、しえん、しにん等）。 + if (numberReading.endsWith("し") && isStandaloneOrAfterPlace("し")) return null + if (counterReading != "じ") return numberReading + + return when { + numberReading.endsWith("よ") && isStandaloneOrAfterPlace("よ") -> + numberReading.dropLast(1) + "よん" + numberReading.endsWith("く") && isStandaloneOrAfterPlace("く") -> + numberReading.dropLast(1) + "きゅう" + else -> numberReading + } + } + fun getSymbolEmojiCandidates(): List = emojiTokenArray.getNodeIds().map { nodeId -> emojiTangoTrie.getLetterShortArray(nodeId, emojiSuccinctBitVectorTangoLBS) @@ -5151,7 +5200,7 @@ class KanaKanjiEngine { Candidate( string = numberAsLong.toKanji(), type = 32, // 新しいタイプ length = input.length.toUByte(), score = 8000, // 優先度を調整 - leftId = 2040, rightId = 2040 + leftId = POS_ID_NUMBER_KANJI, rightId = POS_ID_NUMBER_KANJI ) ) } @@ -5164,8 +5213,8 @@ class KanaKanjiEngine { type = 17, length = input.length.toUByte(), score = 8000, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_KANJI, + rightId = POS_ID_NUMBER_KANJI ) ) } @@ -5178,8 +5227,8 @@ class KanaKanjiEngine { type = if (it == firstNum) (30).toByte() else (31).toByte(), length = input.length.toUByte(), score = 8002, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_ARABIC, + rightId = POS_ID_NUMBER_ARABIC ) ) } @@ -5191,8 +5240,8 @@ class KanaKanjiEngine { type = 19, length = input.length.toUByte(), score = 8001, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_SEPARATED, + rightId = POS_ID_NUMBER_SEPARATED ) ) @@ -5204,8 +5253,8 @@ class KanaKanjiEngine { type = 20, length = input.length.toUByte(), score = 8003, - leftId = 2040, - rightId = 2040 + leftId = POS_ID_NUMBER_ARABIC, + rightId = POS_ID_NUMBER_ARABIC ) ) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtenstion.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtenstion.kt index cf9532c6c..cc0c6a87c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtenstion.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtenstion.kt @@ -7,125 +7,148 @@ fun detectMultipleSen(input: String): Boolean { return regex.matches(input) } -private val japaneseNumberDigits = mapOf( - "ぜろ" to 0L, "れい" to 0L, - "いち" to 1L, "いっ" to 1L, - "に" to 2L, - "さん" to 3L, - "よん" to 4L, "よ" to 4L, "し" to 4L, - "ご" to 5L, - "ろく" to 6L, "ろっ" to 6L, - "なな" to 7L, "しち" to 7L, - "はち" to 8L, "はっ" to 8L, - "きゅう" to 9L, "く" to 9L -) - -private val japaneseNumberUnits = mapOf( - "じゅう" to 10L, - "ひゃく" to 100L, "びゃく" to 100L, "ぴゃく" to 100L, - "せん" to 1000L, "ぜん" to 1000L -) - -private val japaneseNumberBigUnits = listOf( - "ちょう" to 1_000_000_000_000L, - "おく" to 100_000_000L, - "まん" to 10_000L -) - -private val japaneseNumberDigitPatterns = - japaneseNumberDigits.keys.sortedByDescending { it.length } - -private fun normalizeJapaneseNumberReading(input: String): String { - return input - .replace("じゅっ", "じゅう") - .replace("じっ", "じゅう") -} - -private fun parseJapaneseDigitSequence(text: String): Long? { - if (text.isEmpty()) return null - - var number = 0L - var remaining = text - - while (remaining.isNotEmpty()) { - val matched = japaneseNumberDigitPatterns.firstOrNull { remaining.startsWith(it) } ?: return null - number = number * 10 + japaneseNumberDigits.getValue(matched) - remaining = remaining.substring(matched.length) - } - - return number +private enum class JapaneseNumberReadingType { + UNIT, + SMALL_PLACE, + BIG_PLACE, } -private fun parseJapaneseNumberSection(sectionText: String): Long? { - if (sectionText.isEmpty()) return 0L - - var sectionTotal = 0L - var remaining = sectionText +private data class JapaneseNumberReading( + val reading: String, + val type: JapaneseNumberReadingType, + val value: Long, + val placeOrder: Int = 1, +) - val orderedUnits = listOf("せん", "ぜん", "ひゃく", "びゃく", "ぴゃく", "じゅう") +/** + * Number readings accepted by Mozc's NumberDecoder, limited to the range that + * can be represented by this app's Long-based number candidate API. + * + * Sound changes such as 「いっ」「ろっ」「はっ」 are units here, not global + * string replacements. Decoder state determines where they are usable. + */ +private val japaneseNumberReadings = listOf( + JapaneseNumberReading("ぜろ", JapaneseNumberReadingType.UNIT, 0L), + JapaneseNumberReading("れい", JapaneseNumberReadingType.UNIT, 0L), + JapaneseNumberReading("いち", JapaneseNumberReadingType.UNIT, 1L), + JapaneseNumberReading("いっ", JapaneseNumberReadingType.UNIT, 1L), + JapaneseNumberReading("に", JapaneseNumberReadingType.UNIT, 2L), + JapaneseNumberReading("さん", JapaneseNumberReadingType.UNIT, 3L), + JapaneseNumberReading("し", JapaneseNumberReadingType.UNIT, 4L), + JapaneseNumberReading("よん", JapaneseNumberReadingType.UNIT, 4L), + JapaneseNumberReading("よ", JapaneseNumberReadingType.UNIT, 4L), + JapaneseNumberReading("ご", JapaneseNumberReadingType.UNIT, 5L), + JapaneseNumberReading("ろく", JapaneseNumberReadingType.UNIT, 6L), + JapaneseNumberReading("ろっ", JapaneseNumberReadingType.UNIT, 6L), + JapaneseNumberReading("なな", JapaneseNumberReadingType.UNIT, 7L), + JapaneseNumberReading("しち", JapaneseNumberReadingType.UNIT, 7L), + JapaneseNumberReading("はち", JapaneseNumberReadingType.UNIT, 8L), + JapaneseNumberReading("はっ", JapaneseNumberReadingType.UNIT, 8L), + JapaneseNumberReading("きゅう", JapaneseNumberReadingType.UNIT, 9L), + JapaneseNumberReading("きゅー", JapaneseNumberReadingType.UNIT, 9L), + JapaneseNumberReading("く", JapaneseNumberReadingType.UNIT, 9L), + JapaneseNumberReading("じゅう", JapaneseNumberReadingType.SMALL_PLACE, 10L, 2), + JapaneseNumberReading("じゅー", JapaneseNumberReadingType.SMALL_PLACE, 10L, 2), + JapaneseNumberReading("じゅっ", JapaneseNumberReadingType.SMALL_PLACE, 10L, 2), + JapaneseNumberReading("じっ", JapaneseNumberReadingType.SMALL_PLACE, 10L, 2), + JapaneseNumberReading("ひゃく", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("ひゃっ", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("びゃく", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("びゃっ", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("ぴゃく", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("ぴゃっ", JapaneseNumberReadingType.SMALL_PLACE, 100L, 3), + JapaneseNumberReading("せん", JapaneseNumberReadingType.SMALL_PLACE, 1_000L, 4), + JapaneseNumberReading("ぜん", JapaneseNumberReadingType.SMALL_PLACE, 1_000L, 4), + JapaneseNumberReading("まん", JapaneseNumberReadingType.BIG_PLACE, 10_000L, 5), + JapaneseNumberReading("おく", JapaneseNumberReadingType.BIG_PLACE, 100_000_000L, 9), + JapaneseNumberReading("おっ", JapaneseNumberReadingType.BIG_PLACE, 100_000_000L, 9), + JapaneseNumberReading("ちょう", JapaneseNumberReadingType.BIG_PLACE, 1_000_000_000_000L, 13), +).sortedByDescending { it.reading.length } - for (unit in orderedUnits) { - while (remaining.contains(unit)) { - val index = remaining.indexOf(unit) - val digitText = remaining.substring(0, index) - val digitValue = if (digitText.isEmpty()) { - 1L - } else { - parseJapaneseDigitSequence(digitText) ?: return null - } +private fun parseJapaneseNumberValue(input: String): Long? { + if (input.isEmpty()) return null - sectionTotal += digitValue * japaneseNumberUnits.getValue(unit) - remaining = remaining.substring(index + unit.length) + var index = 0 + var total = 0L + var section = -1L + var smallPlaceOrder = -1 + var bigPlaceOrder = Int.MAX_VALUE + var hasNumber = false + var restrictedUnit: String? = null + + while (index < input.length) { + val entry = japaneseNumberReadings.firstOrNull { + input.startsWith(it.reading, index) + } ?: return null + + // Mozc accepts these historical readings only in constrained places: + // 「よ」「く」 must finish the number, while 「し」 may additionally + // precede canonical 「じゅう」 (e.g. 四十 = しじゅう). + when (restrictedUnit) { + "よ", "く" -> return null + "し" -> if (entry.reading != "じゅう") return null + } + restrictedUnit = if ( + entry.type == JapaneseNumberReadingType.UNIT && + (entry.reading == "し" || entry.reading == "よ" || entry.reading == "く") + ) { + entry.reading + } else { + null } - } - - if (remaining.isNotEmpty()) { - sectionTotal += parseJapaneseDigitSequence(remaining) ?: return null - } - - return sectionTotal -} -private fun parseJapaneseNumberValue(input: String): Long? { - if (input == "ちょうせん" || detectMultipleSen(input) || input == "おくせん") return null + when (entry.type) { + JapaneseNumberReadingType.UNIT -> { + if (hasNumber && entry.value == 0L) return null + if (section == 0L || (section >= 0L && section % 10L != 0L)) return null - val normalized = normalizeJapaneseNumberReading(input) - if (normalized.isEmpty()) return null + section = if (section < 0L) { + entry.value + } else { + Math.addExact(section, entry.value) + } + hasNumber = true + } - var remaining = normalized - var total = 0L + JapaneseNumberReadingType.SMALL_PLACE -> { + if (smallPlaceOrder > 1 && entry.placeOrder >= smallPlaceOrder) return null + if (section == 0L) return null - while (remaining.isNotEmpty()) { - var matchedBigUnit = false + section = if (section < 0L) { + entry.value + } else { + val unit = maxOf(1L, section % 10L) + val base = section / 10L * 10L + Math.addExact(base, Math.multiplyExact(unit, entry.value)) + } + smallPlaceOrder = entry.placeOrder + hasNumber = true + } - for ((bigUnit, bigUnitValue) in japaneseNumberBigUnits) { - if (!remaining.contains(bigUnit)) continue + JapaneseNumberReadingType.BIG_PLACE -> { + if (entry.placeOrder >= bigPlaceOrder || section <= 0L) return null - val index = remaining.indexOf(bigUnit) - val leftText = remaining.substring(0, index) - val sectionValue = if (leftText.isEmpty()) { - 1L - } else { - parseJapaneseNumberSection(leftText) ?: return null + total = Math.addExact(total, Math.multiplyExact(section, entry.value)) + section = -1L + smallPlaceOrder = -1 + bigPlaceOrder = entry.placeOrder + hasNumber = true } - - total += sectionValue * bigUnitValue - remaining = remaining.substring(index + bigUnit.length) - matchedBigUnit = true - break } - if (!matchedBigUnit) { - total += parseJapaneseNumberSection(remaining) ?: return null - break - } + index += entry.reading.length } - return total + if (!hasNumber) return null + return if (section >= 0L) Math.addExact(total, section) else total } fun String.toNumber(): Pair? { - val total = parseJapaneseNumberValue(this) ?: return null + val total = try { + parseJapaneseNumberValue(this) + } catch (_: ArithmeticException) { + null + } ?: return null val fullWidth = total.toString().map { it.toFullWidthChar() }.joinToString("") val halfWidth = total.toString() @@ -134,7 +157,11 @@ fun String.toNumber(): Pair? { } fun String.toNumberExponent(): Pair? { - val total = parseJapaneseNumberValue(this) ?: return null + val total = try { + parseJapaneseNumberValue(this) + } catch (_: ArithmeticException) { + null + } ?: return null val result = if (total < 100_000_000L) { null diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/StringExtenstion.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/StringExtenstion.kt index 9f1a4eea2..21c9115da 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/StringExtenstion.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/StringExtenstion.kt @@ -287,27 +287,6 @@ fun String.replaceJapaneseCharactersForEnglish(): String { .replace('！', '!') } -fun String.groupAndReplaceJapaneseForNumber(): String { - val result = StringBuilder() - for (char in this) { - when (char) { - in 'あ'..'お' -> result.append('1') - in 'か'..'こ' -> result.append('2') - in 'さ'..'そ' -> result.append('3') - in 'た'..'と' -> result.append('4') - in 'な'..'の' -> result.append('5') - in 'は'..'ほ' -> result.append('6') - in 'ま'..'も' -> result.append('7') - 'や', 'ゆ', 'よ' -> result.append('8') - in 'ら'..'ろ' -> result.append('9') - 'わ', 'を', 'ん' -> result.append('0') - // 上記以外の文字はそのまま追加する - else -> result.append(char) - } - } - return result.toString() -} - /** * 数字文字列を上付き文字（¹²³）に変換します。 */ diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngineEnglishKanaNumberTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngineEnglishKanaNumberTest.kt index 73b5baafd..e18ce6c02 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngineEnglishKanaNumberTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngineEnglishKanaNumberTest.kt @@ -59,6 +59,67 @@ class KanaKanjiEngineEnglishKanaNumberTest { assertTrue(engine.getCandidatesEnglishKana("にじゅっふん").any { it.string == "20分" }) assertTrue(engine.getCandidatesEnglishKana("ろくじ").any { it.string == "6時" }) assertTrue(engine.getCandidatesEnglishKana("にじゅうよじ").any { it.string == "24時" }) + assertTrue(engine.getCandidatesEnglishKana("くじ").any { it.string == "9時" }) + assertTrue(engine.getCandidatesEnglishKana("じゅうくじ").any { it.string == "19時" }) + assertTrue(engine.getCandidatesEnglishKana("よにん").any { it.string == "4人" }) + assertTrue(engine.getCandidatesEnglishKana("よえん").any { it.string == "4円" }) + assertTrue(engine.getCandidatesEnglishKana("くえん").any { it.string == "9円" }) + assertTrue(engine.getCandidatesEnglishKana("くにん").any { it.string == "9人" }) + assertTrue(engine.getCandidatesEnglishKana("いっぷん").any { it.string == "1分" }) + assertTrue(engine.getCandidatesEnglishKana("ろっぷん").any { it.string == "6分" }) + assertTrue(engine.getCandidatesEnglishKana("はっぷん").any { it.string == "8分" }) + } + + @Test + fun getCandidatesEnglishKana_does_not_generate_numeric_candidates_for_ordinary_words() { + val cases = mapOf( + "よしよし" to setOf("4444", "４４４４", "8383", "８３８３", "四千四百四十四"), + "しせん" to setOf("4000", "４０００", "4,000", "四千"), + "くちょう" to setOf("9000000000000", "９００００００００００００", "九兆", "9兆"), + "ちょうせん" to setOf("1000000001000", "一兆一千"), + "ごご" to setOf("55", "５５", "五十五"), + "さんご" to setOf("35", "３５", "三十五"), + "しえん" to setOf("4円", "４円"), + "しじ" to setOf("4時", "４時"), + "いちいち" to setOf("11", "１１", "十一"), + "さんさん" to setOf("33", "３３", "三十三"), + "ろくろく" to setOf("66", "６６", "六十六"), + "よせん" to setOf("4000", "４０００", "4,000", "四千"), + "くせん" to setOf("9000", "９０００", "9,000", "九千"), + ) + + cases.forEach { (input, forbidden) -> + val candidates = engine.getCandidatesEnglishKana(input).map { it.string } + assertEquals(input, candidates.first()) + assertTrue("$input: $candidates", candidates.none { it in forbidden }) + } + } + + @Test + fun getCandidatesEnglishKana_keeps_valid_cardinal_and_counter_candidates() { + val fourThousand = engine.getCandidatesEnglishKana("よんせん") + assertTrue(fourThousand.any { it.string == "4000" }) + assertTrue(fourThousand.any { it.string == "四千" }) + assertTrue(fourThousand.any { + it.string == "四千" && it.leftId == 2046.toShort() && it.rightId == 2046.toShort() + }) + + val nineTrillion = engine.getCandidatesEnglishKana("きゅうちょう") + assertTrue(nineTrillion.any { it.string == "9000000000000" }) + assertTrue(nineTrillion.any { it.string == "九兆" }) + + val oneTrillion = engine.getCandidatesEnglishKana("いっちょう") + assertTrue(oneTrillion.any { it.string == "1000000000000" }) + assertTrue(oneTrillion.any { it.string == "一兆" }) + + val historicalForty = engine.getCandidatesEnglishKana("しじゅう") + assertTrue(historicalForty.any { it.string == "40" }) + assertTrue(historicalForty.any { it.string == "四十" }) + + val threePeople = engine.getCandidatesEnglishKana("さんにん") + assertTrue(threePeople.any { + it.string == "3人" && it.leftId == 2044.toShort() && it.rightId == 2011.toShort() + }) } @Test diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtensionTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtensionTest.kt index 44f609f17..364220cfa 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtensionTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/extensions/NumberExtensionTest.kt @@ -2,6 +2,7 @@ package com.kazumaproject.markdownhelperkeyboard.ime_service.extensions import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull import org.junit.Test class NumberExtensionTest { @@ -10,7 +11,11 @@ class NumberExtensionTest { fun toNumber_converts_basic_hiragana_numbers_to_half_width_digits() { val cases = mapOf( "いち" to "1", + "し" to "4", + "よ" to "4", + "く" to "9", "じゅう" to "10", + "いちじゅう" to "10", "にじゅう" to "20", "ひゃく" to "100", "せん" to "1000", @@ -25,10 +30,12 @@ class NumberExtensionTest { } @Test - fun toNumber_handles_zero_and_digit_by_digit_readings() { + fun toNumber_handles_zero_but_rejects_unstructured_digit_sequences() { assertEquals("0", "ぜろ".toNumber()?.second) assertEquals("0", "れい".toNumber()?.second) - assertEquals("301", "さんぜろいち".toNumber()?.second) + assertNull("さんぜろいち".toNumber()) + assertNull("いちいち".toNumber()) + assertNull("さんさん".toNumber()) } @Test @@ -39,7 +46,14 @@ class NumberExtensionTest { "はっぴゃく" to "800", "さんぜん" to "3000", "はっせん" to "8000", - "じゅうまん" to "100000" + "じゅうまん" to "100000", + "いっちょう" to "1000000000000", + "しじゅう" to "40", + "じゅうし" to "14", + "じゅうよ" to "14", + "じゅうく" to "19", + "さんひゃく" to "300", + "はちせん" to "8000", ) cases.forEach { (input, expected) -> @@ -48,4 +62,46 @@ class NumberExtensionTest { assertEquals(expected, number?.second) } } + + @Test + fun toNumber_rejects_ordinary_words_that_only_look_numeric_by_character() { + val ordinaryReadings = listOf( + "よしよし", + "しせん", + "くちょう", + "ちょうせん", + "ごご", + "さんご", + "しえん", + "しじ", + ) + + ordinaryReadings.forEach { input -> + assertNull(input, input.toNumber()) + } + } + + @Test + fun toNumber_rejects_invalid_unit_order_repetition_and_contextual_readings() { + val invalidReadings = listOf( + "よせん", + "しせん", + "くせん", + "しけい", + "しがいせん", + "じゅうひゃく", + "せんせん", + "いちまんにおく", + "いちまんにまん", + ) + + invalidReadings.forEach { input -> + assertNull(input, input.toNumber()) + } + } + + @Test + fun toNumber_returns_null_instead_of_treating_long_invalid_input_as_digits() { + assertNull("きゅう".repeat(20).toNumber()) + } } From eb02ad82fc8cf2a2b43efb70014b43260f21448d Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Sun, 2 Aug 2026 19:14:57 -0400 Subject: [PATCH 15/24] improve emoji category --- .../FastInputMatrixInstrumentedTest.kt | 77 + .../EmojiCategoryInstrumentedTest.kt | 73 + .../ime_service/IMEService.kt | 114 +- .../converter/BundledEmojiCategoryTest.kt | 71 + docs/flick-editor-preview-design.md | 696 +++ .../kazumaproject/data/emoji/EmojiCategory.kt | 27 +- .../java/com/kazumaproject/domain/Emoji.kt | 219 +- .../domain/EmojiCategoryMetadata.kt | 5313 +++++++++++++++++ .../CustomSymbolKeyboardView.kt | 48 +- .../src/main/res/values-ja/strings.xml | 10 + .../src/main/res/values/strings.xml | 10 + .../domain/EmojiCategoryMetadataTest.kt | 76 + .../generate_category_metadata.py | 174 + 13 files changed, 6595 insertions(+), 313 deletions(-) create mode 100644 app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/EmojiCategoryInstrumentedTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/BundledEmojiCategoryTest.kt create mode 100644 docs/flick-editor-preview-design.md create mode 100644 symbol_keyboard/src/main/java/com/kazumaproject/domain/EmojiCategoryMetadata.kt create mode 100644 symbol_keyboard/src/test/java/com/kazumaproject/domain/EmojiCategoryMetadataTest.kt create mode 100644 tools/emoji_metadata/generate_category_metadata.py diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt index 15bf3a223..4303a397e 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt @@ -240,6 +240,83 @@ class FastInputMatrixInstrumentedTest { } } + @Test + fun tenKeyDeleteLongPressClearsComposingCandidatesOnPhysicalDevice() { + runPhysicalDeviceSession("delete-long-press-candidate-clear") { session -> + val testCase = TestCase( + keyboard = TestKeyboard.TENKEY, + columns = 1, + candidateTabVisible = false, + toolbarVisible = false, + toolbarIntegrated = false, + orientation = TestOrientation.PORTRAIT + ) + var scenario: ActivityScenario? = null + try { + scenario = launchHost(session.context) + rotateAndVerify(TestOrientation.PORTRAIT) + applyCasePreferences(session.preferences, testCase) + check( + session.preferences.edit() + .putInt("long_press_timeout_preference", 100) + .putString("delete_long_press_conversion_behavior", "deferred") + .putBoolean("live_conversion_preference", false) + .commit() + ) + + ensureTargetImeSelected(session) + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + assertDeviceReady(session.context, session.targetIme, scenario) + prepareEmptyEditor(scenario) + + val before = awaitStableGeometry( + keyboard = TestKeyboard.TENKEY, + requireCandidateContent = false + ) + val inputInjected = injectSequence( + first = before.first.center, + second = before.second.center, + repetitions = 1 + ) + val inputText = awaitTextSettled(scenario) + awaitStableGeometry( + keyboard = TestKeyboard.TENKEY, + requireCandidateContent = true + ) + assertTrue("Ten-key input injection failed", inputInjected) + assertTrue("Composing input did not reach the editor", inputText.isNotEmpty()) + assertTrue( + "Candidate list was not populated before delete long press", + findCandidateState().texts.isNotEmpty() + ) + + val deleteBounds = findVisibleNodeById("key_delete")?.screenRect() + ?: throw SetupException("Delete key is not visible") + val deleteInjected = injectTapWithoutTrailingGap( + point = deleteBounds.center, + holdMs = 850L + ) + awaitStableGeometry( + keyboard = TestKeyboard.TENKEY, + requireCandidateContent = false + ) + val afterText = awaitTextSettled(scenario) + val afterCandidates = findCandidateState().texts + + assertTrue("Delete long-press injection failed", deleteInjected) + assertTrue("ComposingText was not fully deleted", afterText.isEmpty()) + assertTrue( + "SuggestionAdapter still exposes candidates after ComposingText deletion: " + + afterCandidates, + afterCandidates.isEmpty() + ) + } finally { + scenario?.close() + } + } + } + @Test fun qwertyVariationPopupTwoFingerInputOnPhysicalDevice() { runPhysicalDeviceSession("qwerty-variation-popup-multitouch") { session -> diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/EmojiCategoryInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/EmojiCategoryInstrumentedTest.kt new file mode 100644 index 000000000..6e3e63874 --- /dev/null +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/EmojiCategoryInstrumentedTest.kt @@ -0,0 +1,73 @@ +package com.kazumaproject.markdownhelperkeyboard.converter + +import android.content.Context +import androidx.test.core.app.ApplicationProvider +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.kazumaproject.data.emoji.EmojiCategory +import com.kazumaproject.data.emoticon.EmoticonCategory +import com.kazumaproject.domain.categorizeEmoji +import com.kazumaproject.domain.toEmoticonCategory +import com.kazumaproject.markdownhelperkeyboard.ime_service.di.KanaKanjiEngineEntryPoint +import dagger.hilt.android.EntryPointAccessors +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import java.io.File + +@RunWith(AndroidJUnit4::class) +class EmojiCategoryInstrumentedTest { + + @Test + fun bundledEmojiDictionaryUsesPublishedMetadataOnDevice() { + val context = ApplicationProvider.getApplicationContext() + val engine = EntryPointAccessors.fromApplication( + context.applicationContext, + KanaKanjiEngineEntryPoint::class.java, + ).kanaKanjiEngine() + + val emojis = engine.getSymbolEmojiCandidates() + val emoticons = engine.getSymbolEmoticonCandidates() + val emojiCounts = EmojiCategory.entries.associateWith { category -> + emojis.count { it.category == category } + } + val emoticonCounts = EmoticonCategory.entries.associateWith { category -> + emoticons.count { it.category == category } + } + + val report = buildString { + appendLine("device=${android.os.Build.MANUFACTURER} ${android.os.Build.MODEL} API ${android.os.Build.VERSION.SDK_INT}") + appendLine("emojiTotal=${emojis.size}") + EmojiCategory.entries.forEach { appendLine("emoji.${it.name}=${emojiCounts.getValue(it)}") } + emojis.asSequence() + .filter { it.category == EmojiCategory.UNKNOWN } + .take(30) + .forEach { emoji -> + appendLine( + "emoji.unknown=${emoji.symbol} [" + + emoji.symbol.codePoints().toArray() + .joinToString(" ") { "U+%04X".format(it) } + + "]" + ) + } + appendLine("emoticonTotal=${emoticons.size}") + EmoticonCategory.entries.forEach { + appendLine("emoticon.${it.name}=${emoticonCounts.getValue(it)}") + } + } + val reportFile = File(context.filesDir, "emoji-category-device-report.txt") + reportFile.writeText(report) + println(report) + + assertEquals(1_902, emojis.size) + assertEquals(436, emoticons.size) + assertEquals(EmojiCategory.FLAGS, categorizeEmoji("🇯🇵")) + assertEquals(EmojiCategory.SYMBOLS, categorizeEmoji("#️⃣")) + assertEquals(EmojiCategory.SMILEYS_EMOTION, categorizeEmoji("❤️‍🔥")) + assertEquals(EmoticonCategory.SMILE, ":-)".toEmoticonCategory()) + assertEquals(EmoticonCategory.SADNESS, "(TT)".toEmoticonCategory()) + assertEquals(4, emojiCounts.getValue(EmojiCategory.UNKNOWN)) + assertTrue(emojiCounts.getValue(EmojiCategory.UNKNOWN) < emojis.size) + assertTrue(emoticonCounts.getValue(EmoticonCategory.UNKNOWN) < emoticons.size) + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 091ebb3ae..7b6ee394f 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -1363,6 +1363,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, DeleteLongPressConversionBehavior.Default private var activeDeleteLongPressConversionBehavior: DeleteLongPressConversionBehavior? = null + private var deleteLongPressFinalRefreshRequested = false private var tenkeyShowIMEButtonPreference: Boolean? = true private var qwertyShowIMEButtonPreference: Boolean? = true private var qwertyShowEmojiButtonPreference: Boolean? = false @@ -14431,7 +14432,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, CandidateShowFlag.Idle -> { var resetCandidateTabSelection = false clearZenzLiveSlot("suggestion idle") - setSuggestionAdapterSuggestionsOnMain(emptyList()) + setSuggestionAdaptersOnMain(emptyList()) if (stringInTail.get().isEmpty()) { shortcutToolbarHiddenForCandidates = false resetCandidateTabSelection = true @@ -17282,11 +17283,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val henkanActive = isHenkan.get() val tailIsEmpty = stringInTail.get().isEmpty() val shouldCommitIdle = !bunsetusMultipleDetect || tailIsEmpty - if ( - !henkanActive && - shouldCommitIdle && - deleteLongPressConversionGate.mayApplyCandidateResult() - ) { + if (!henkanActive && shouldCommitIdle) { requestCandidateRefresh(CandidateShowFlag.Idle) } } @@ -22717,6 +22714,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, if (deleteLongPressJob?.isActive == true) return val behavior = deleteLongPressConversionBehavior activeDeleteLongPressConversionBehavior = behavior + deleteLongPressFinalRefreshRequested = false if (behavior.suspendsCandidateResultsDuringRepeat) { if (!deleteLongPressConversionGate.beginRepeat()) { activeDeleteLongPressConversionBehavior = null @@ -22730,45 +22728,39 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, deletesCommittedText = inputString.value.isEmpty() ) deleteLongPressJob = scope.launch { - while (isActive && deleteKeyLongKeyPressed.get()) { - val current = inputString.value - val tailIsEmpty = stringInTail.get().isEmpty() - - if (current.isEmpty()) { - if (tailIsEmpty) { - if (isEditHistoryEnabled()) { - val beforeChar = - captureDeletedTextFromConnection(currentInputConnection) - if (beforeChar.isNotEmpty()) { - activeDeleteHistoryBatch?.deletedText?.insert(0, beforeChar) + try { + while (isActive && deleteKeyLongKeyPressed.get()) { + val current = inputString.value + val tailIsEmpty = stringInTail.get().isEmpty() + + if (current.isEmpty()) { + if (tailIsEmpty) { + if (isEditHistoryEnabled()) { + val beforeChar = + captureDeletedTextFromConnection(currentInputConnection) + if (beforeChar.isNotEmpty()) { + activeDeleteHistoryBatch?.deletedText?.insert(0, beforeChar) + } } + deleteLastGraphemeOrSelection() + } else { + break } - deleteLastGraphemeOrSelection() } else { - break - } - } else { - val newString = current.dropLast(1) - _inputString.update { newString } - if (newString.isEmpty() && tailIsEmpty) { - clearStyledComposingTextAfterFinalDelete(current) + val newString = current.dropLast(1) + _inputString.update { newString } + if (newString.isEmpty() && tailIsEmpty) { + clearStyledComposingTextAfterFinalDelete(current) + } } - } - delay(LONG_DELAY_TIME) - } - // （連続タップ入力解除など） - enableContinuousTapInput() - if ( - activeDeleteLongPressConversionBehavior == - DeleteLongPressConversionBehavior.Continuous - ) { - val refreshFlag = if (inputString.value.isEmpty()) { - CandidateShowFlag.Idle - } else { - CandidateShowFlag.Updating + delay(LONG_DELAY_TIME) } - requestCandidateRefresh(refreshFlag, inputString.value) + } finally { + // The key-up path cancels this job. Final candidate cleanup must therefore also + // live in finally so cancellation cannot skip it. + enableContinuousTapInput() + requestFinalDeleteLongPressRefresh() } } deleteLongPressJob?.invokeOnCompletion { @@ -22789,6 +22781,33 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } } + private fun requestFinalDeleteLongPressRefresh() { + if (deleteLongPressFinalRefreshRequested) return + + val behavior = activeDeleteLongPressConversionBehavior ?: return + val finalInput = inputString.value + val refreshFlag = when (behavior) { + DeleteLongPressConversionBehavior.Deferred -> + deleteLongPressConversionGate.finishRepeat(finalInput) + + DeleteLongPressConversionBehavior.Continuous -> + if (finalInput.isEmpty()) { + CandidateShowFlag.Idle + } else { + CandidateShowFlag.Updating + } + } ?: return + + deleteLongPressFinalRefreshRequested = true + candidateRequestTracker.invalidate() + Timber.d( + "deleteLongPress: final candidate refresh input=[%s] flag=%s", + finalInput, + refreshFlag, + ) + requestCandidateRefresh(refreshFlag, finalInput) + } + /** * Removes the final composing character without collapsing composing spans to length zero. * @@ -22814,22 +22833,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, onDeleteLongPressUp.set(true) deleteLongPressJob?.cancel() deleteLongPressJob = null - if ( - activeDeleteLongPressConversionBehavior == - DeleteLongPressConversionBehavior.Deferred - ) { - val refreshFlag = deleteLongPressConversionGate.finishRepeat(inputString.value) - if (refreshFlag != null) { - enableContinuousTapInput() - candidateRequestTracker.invalidate() - Timber.d( - "deleteLongPress: resume candidate refresh once input=[%s] flag=%s", - inputString.value, - refreshFlag, - ) - requestCandidateRefresh(refreshFlag, inputString.value) - } - } + requestFinalDeleteLongPressRefresh() activeDeleteLongPressConversionBehavior = null } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/BundledEmojiCategoryTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/BundledEmojiCategoryTest.kt new file mode 100644 index 000000000..7a655bb6f --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/BundledEmojiCategoryTest.kt @@ -0,0 +1,71 @@ +package com.kazumaproject.markdownhelperkeyboard.converter + +import com.kazumaproject.Louds.LOUDS +import com.kazumaproject.data.emoji.EmojiCategory +import com.kazumaproject.dictionary.TokenArray +import com.kazumaproject.domain.categorizeEmoji +import com.kazumaproject.markdownhelperkeyboard.converter.bitset.SuccinctBitVector +import org.junit.Assert.assertEquals +import org.junit.Test +import java.io.BufferedInputStream +import java.io.File +import java.io.ObjectInputStream + +class BundledEmojiCategoryTest { + + @Test + fun allBundledEmojiCandidatesAreCountedAgainstUnicodeMetadata() { + val assetsDir = findAssetsDir() + val tangoTrie = ObjectInputStream( + BufferedInputStream(File(assetsDir, "emoji/tango_emoji.dat").inputStream()) + ).use { LOUDS().readExternalNotCompress(it) } + val tokenArray = TokenArray().also { tokenArray -> + ObjectInputStream( + BufferedInputStream(File(assetsDir, "emoji/token_emoji.dat").inputStream()) + ).use(tokenArray::readExternal) + } + val tangoLbs = SuccinctBitVector(tangoTrie.LBS) + val symbols = tokenArray.getNodeIds() + .map { tangoTrie.getLetterShortArray(it, tangoLbs) } + .distinct() + val counts = EmojiCategory.entries.associateWith { category -> + symbols.count { categorizeEmoji(it) == category } + } + val classifiedCount = symbols.size - counts.getValue(EmojiCategory.UNKNOWN) + val expectedCounts = mapOf( + EmojiCategory.SMILEYS_EMOTION to 168, + EmojiCategory.PEOPLE_BODY to 385, + EmojiCategory.ANIMALS_NATURE to 158, + EmojiCategory.FOOD_DRINK to 130, + EmojiCategory.TRAVEL_PLACES to 218, + EmojiCategory.ACTIVITIES to 85, + EmojiCategory.OBJECTS to 262, + EmojiCategory.SYMBOLS to 223, + EmojiCategory.FLAGS to 269, + EmojiCategory.UNKNOWN to 4, + ) + + println("emojiTotal=${symbols.size}") + EmojiCategory.entries.forEach { println("emoji.${it.name}=${counts.getValue(it)}") } + println("emojiClassified=$classifiedCount") + + assertEquals(1_902, symbols.size) + assertEquals(expectedCounts, counts) + assertEquals(1_898, classifiedCount) + assertEquals( + setOf("🦰", "🦱", "🦲", "🦳"), + symbols.filter { categorizeEmoji(it) == EmojiCategory.UNKNOWN }.toSet(), + ) + } + + private fun findAssetsDir(): File { + var current = File(System.getProperty("user.dir") ?: ".").absoluteFile + repeat(6) { + val candidate = File(current, "app/src/main/assets") + if (candidate.isDirectory) return candidate + current = current.parentFile + ?: error("Cannot find app/src/main/assets from ${System.getProperty("user.dir")}") + } + error("Cannot find app/src/main/assets from ${System.getProperty("user.dir")}") + } +} diff --git a/docs/flick-editor-preview-design.md b/docs/flick-editor-preview-design.md new file mode 100644 index 000000000..c9c7bac59 --- /dev/null +++ b/docs/flick-editor-preview-design.md @@ -0,0 +1,696 @@ +# フリック選択文字の入力欄プレビュー設計 + +## 1. 結論 + +TenKey と Sumire の文字フリックに、指を離す前から選択中の文字を入力欄へ仮表示する機能を追加する。 + +- 設定は TenKey 用、Sumire 用に分けず、フリック系入力共通の 1 個の Switch とする。 +- 新設定画面と従来設定画面には、同じ SharedPreferences キーを持つ項目をそれぞれ配置する。 +- デフォルトは OFF とし、OFF の場合は既存の入力イベントと IME 処理を一切変更しない。 +- QWERTY は対象外とする。Sumire の英語モードが QWERTY 表示へ切り替わっている場合も対象外である。 +- 押下中の文字は `commitText()` せず、一時的な `setComposingText()` として表示する。 +- `_inputString`、候補検索、学習、IME 内部の編集履歴は指を離すまで更新しない。 + +入力欄へ一度 `commitText()` してから削除・置換する方式は採用しない。この方式は入力先アプリの Undo、TextWatcher、選択範囲、カーソル位置を壊す可能性があるためである。 + +`setComposingText()` による仮表示自体は入力先アプリから観測できる。検索欄の即時検索や独自 TextWatcher が MOVE 中の文字を受け取ることは、この機能の性質上避けられない。また、エディタによっては composing 更新も独自の Undo 単位として扱う可能性がある。このため本機能は opt-in、デフォルト OFF とし、代表的な EditText、Compose TextField、WebView で互換性を確認する。 + +## 2. 対象範囲 + +### 2.1 対象 + +初回実装では次を対象とする。 + +- TenKey + - 通常表示 + - フローティング表示 + - 日本語・英語・数字モードのうち、最終的に composing 入力を行う通常文字キー +- Sumire + - 通常表示 + - フローティング表示 + - 日本語・英語・数字モードのうち、最終的に composing 入力を行う通常文字キー + - Sumire の標準入力スタイルすべて + +| Sumire の設定値 | `KeyType` | コントローラー | +|---|---|---| +| `default` | `PETAL_FLICK` | `CrossFlickInputController` の TEXT モード | +| `circle` | `STANDARD_FLICK` | `StandardFlickInputController` | +| `second-flick` | `TWO_STEP_FLICK` | `TfbiInputController` | +| `third-flick` | `HIERARCHICAL_FLICK` | `TfbiHierarchicalFlickController` | +| `sumire` | `CIRCULAR_FLICK` | `CustomAngleFlickController` | + +通常文字キーとは、最終出力が `KeyAction.Text` または `FlickAction.Input` として表現されるキーを指す。出力は 1 文字に限定せず、Sumire の複数文字出力も対象にする。 + +### 2.2 初回実装の対象外 + +- QWERTY、QWERTY ローマ字、QWERTY 数字 +- Tablet 五十音キーボード +- ユーザー作成カスタムキーボードの実行モード + - `FlickKeyboardView` の共通イベント基盤は再利用できるように作るが、IME 側の適用判定では `TenKeyQWERTYMode.Custom` を除外する。 +- Sumire の特殊キー + - 削除、空白、変換、Enter、カーソル、濁点切替など + - 特殊キーの方向に文字列オーバーライドが設定されていても初回実装では対象外とする。 +- 変換中、文節選択中、選択モード、カーソル移動モード +- composing 内のカーソル編集で `stringInTail` が空でない状態 +- パスワード、電話番号、日時など、composing 表示を安全に保証できない入力欄 +- Direct Commit が選択されている入力動作 +- ダブルタップバインディングがあるキー + +対象外条件では設定を自動的に OFF へ書き戻さず、その 1 ジェスチャーだけ従来方式へフォールバックする。 + +## 3. ユーザー向け設定 + +### 3.1 Preference + +共通キーは次とする。 + +```text +flick_editor_preview_preference +``` + +値は Boolean、デフォルトは `false` とする。既存ユーザーの移行処理は不要である。 + +推奨表示文言は次のとおり。 + +```text +タイトル: +入力欄でフリック文字をプレビュー + +OFF の概要: +従来方式：指を離したときに文字を入力します + +ON の概要: +TenKey・Sumireで、選択中のタップ／フリック文字を入力欄に仮表示します +``` + +英語リソースも同時に追加する。 + +```text +Title: +Preview flick characters in the text field + +Off summary: +Enter the character when you release the key + +On summary: +Preview the selected tap or flick text while holding a TenKey or Sumire key +``` + +### 3.2 配置 + +新設定画面では `pref_operation_feedback.xml` に `category_flick_input_title`（表示名「フリック入力」）を設け、次を同じカテゴリにまとめる。 + +- `flick_input_only_preference` +- `flick_editor_preview_preference` +- `flick_sensitivity_preference` +- `flick_threshold_shape_preference` + +新しい Switch は `flick_input_only_preference` の直後へ配置する。現在の先頭 `category_function_title` にあるフリック以外の設定は、既存の `category_function_title` に残す。 + +従来設定画面でも `pref_common_legacy.xml` に同じ `category_flick_input_title` を設け、上記 4 項目を現在の `category_function_title` から移す。Preference キー、デフォルト値、保存先は変更せず、表示上の分類だけを揃える。 + +両方が同じキーを使うため、画面間の同期コードは追加しない。既存の `PreferenceManager.getDefaultSharedPreferences()` が唯一の保存先になる。 + +設定検索には XML から自動登録される。よく使う設定の候補にも表示できるよう、`frequentCandidatePreferenceKeys` に同じキーを追加する。 + +### 3.3 設定読み込み + +次を追加する。 + +- `AppPreference.FLICK_EDITOR_PREVIEW_KEY` +- `AppPreference.flick_editor_preview_preference: Boolean` +- `ImePreferencesSnapshot.flickEditorPreviewPreference: Boolean` +- `IMEService.flickEditorPreviewPreference: Boolean` +- `runtimeInputPreferenceKeys` へのキー登録 +- `syncRuntimeInputPreferences()` での再読み込み + +設定値はジェスチャー開始時にスナップショットする。押下中に設定が変更されても、そのジェスチャーは DOWN 時の設定で完了し、次の DOWN から新しい値を使う。 + +## 4. 現行処理と変更方針 + +### 4.1 TenKey + +現行の `TenKey.onTouch()` は次の流れになっている。 + +```text +ACTION_DOWN + -> FlickListener.onFlick(Down, key, null) + +ACTION_MOVE + -> setTapInActionMove() / setFlickInActionMove() + -> キーとポップアップの表示だけ変更 + +ACTION_UP + -> FlickListener.onFlick(Tap/Flick..., key, char) + -> IMEService.handleTapAndFlick() + -> _inputString 更新 +``` + +既存の `FlickListener.onFlick()` は確定通知の意味を維持し、MOVE からは呼ばない。別のプレビューイベントを追加する。 + +### 4.2 Sumire + +`FlickKeyboardView` は複数のコントローラーを `OnKeyboardActionListener` へ集約しているが、MOVE 中に共通して得られるのは一部の方向変更だけである。方向だけでは、2 段・階層・長押し出力・円形マップ切替後の最終文字を判断できない。 + +各コントローラーが、方向ではなく次を通知するようにする。 + +> 今この状態で指を離した場合に、通常の確定処理へ渡される文字列と `isFlick` + +特殊アクション、無効方向、まだ文字が決まっていない階層は `text = null` とする。 + +## 5. 共通プレビューイベント + +TenKey と Sumire が共有できる型を `core` モジュールへ追加する。 + +```kotlin +data class FlickTextSelection( + val text: String?, + val isFlick: Boolean, +) + +sealed interface FlickTextPreviewEvent { + val gestureId: Long + + data class Started( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class Changed( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class CommitPending( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class Finished( + override val gestureId: Long, + ) : FlickTextPreviewEvent + + data class Canceled( + override val gestureId: Long, + ) : FlickTextPreviewEvent +} + +fun interface FlickTextPreviewListener { + fun onFlickTextPreview(event: FlickTextPreviewEvent) +} +``` + +`text = null` は「現時点では仮表示できる文字出力がない」ことを表す。空文字はイベント送出前に `null` へ正規化する。 + +### 5.1 イベント順序 + +通常確定は必ず次の順序にする。 + +```text +Started +Changed (0回以上) +CommitPending +既存の確定コールバック +Finished +``` + +キャンセルは次の順序にする。 + +```text +Started +Changed (0回以上) +Canceled +``` + +`CommitPending` と `Finished` の間で既存の確定コールバックがプレビュー済み入力計画を消費しなかった場合、`Finished` で元の composing 表示を復元する。これにより、特殊アクションへの変化、ダブルタップによる遅延、イベント不一致があっても仮文字が残らない。 + +### 5.2 Emitter + +イベント順序、gesture ID、同一選択の重複抑止を共通化するため、Android View に依存しない `FlickTextPreviewEmitter` を `core` に追加する。 + +```kotlin +class FlickTextPreviewEmitter { + var listener: FlickTextPreviewListener? = null + + fun begin(selection: FlickTextSelection) + fun update(selection: FlickTextSelection) + fun commit(selection: FlickTextSelection, dispatch: () -> Unit) + fun cancel() +} +``` + +`commit()` は `try/finally` で `CommitPending -> dispatch -> Finished` を保証する。`update()` は `text` と `isFlick` が直前と同じなら通知しない。 + +## 6. キーボード側の実装 + +### 6.1 TenKey + +`TenKey` に次を追加する。 + +```kotlin +fun setOnFlickTextPreviewListener(listener: FlickTextPreviewListener?) +``` + +通常文字キーについて、現在の `InputMode` と `KeyTapFlickInfo` から選択文字を解決する共通関数を作る。 + +```kotlin +private fun resolveTextSelection( + key: Key, + gestureType: GestureType, +): FlickTextSelection +``` + +呼び出し位置は次のとおり。 + +- `ACTION_DOWN`: TAP 出力で `emitter.begin()` +- `ACTION_MOVE`: `getGestureType()` 後、選択が変わったとき `emitter.update()` +- `ACTION_UP`: 最終選択を渡して `emitter.commit { 既存 FlickListener.onFlick() }` +- `ACTION_CANCEL`: `emitter.cancel()` +- `cancelActiveTouch()`、View 非表示、detach: `emitter.cancel()` +- 2 本目の指、カーソルモード、長押し特殊動作へ移行する場合: 確定処理の前に `emitter.cancel()` + +通常表示とフローティング表示は同じ `TenKey` クラスを使うため、IME 側でそれぞれ同じプレビューリスナーを登録する。 + +### 6.2 Sumire 共通 + +`FlickKeyboardView` に次を追加する。 + +```kotlin +fun setOnFlickTextPreviewListener(listener: FlickTextPreviewListener?) +``` + +各コントローラーの emitter は `FlickKeyboardView` の現在の listener へイベントを転送する。`FlickKeyboardView` は通常文字キーかつダブルタップバインディングなしの場合だけ emitter を接続する。 + +View の `onVisibilityChanged()`、`onDetachedFromWindow()`、`cancelTrackedTouchState()` はすべて controller の `cancel()` を経由し、必ず `Canceled` を送る。 + +### 6.3 Sumire 各入力スタイル + +#### PETAL_FLICK + +`CrossFlickInputController` の TEXT モードで、`resolveText(currentDirection, preferLongPress)` の結果を通知する。 + +- DOWN: TAP の通常文字 +- MOVE: 方向変更後の通常文字 +- 長押し成立: 長押し文字が存在すればその文字へ Changed +- UP: 実際に commit する通常／長押し文字 +- CANCEL: Canceled + +ACTION モードの特殊キーはプレビュー対象にしない。 + +#### STANDARD_FLICK + +`StandardFlickInputController.characterMap` から現在方向の文字列を通知する。 + +- DOWN は TAP +- MOVE は `calculateDirection()` の結果 +- UP は finalDirection + +現在の確定処理が TAP も `isFlick = true` として渡している場合、プレビューイベントも既存確定処理と同じ値を使う。ここで入力方式の意味を変更しない。 + +#### CIRCULAR_FLICK + +`CustomAngleFlickController` の現在マップと方向から `FlickAction` を解決する。 + +- `FlickAction.Input` は `char` を通知 +- `FlickAction.Action(KeyAction.Text)` は `text` を通知 +- それ以外の Action、マップ切替方向、無効方向は `text = null` +- マップが切り替わった場合は、新しいマップで同じ方向を再解決して Changed を送る + +#### TWO_STEP_FLICK + +`TfbiInputController` の `firstFlickDirection` と `currentSecondFlickDirection` を provider に渡し、現時点の最終文字を通知する。 + +- DOWN は `TAP/TAP` +- 1 段目確定時にも Changed +- 2 段目のハイライト変更時にも Changed +- 中央へ戻って状態がリセットされた場合は `TAP/TAP` へ Changed +- 長押し出力が成立した場合は longPressProvider の文字へ Changed +- UP は、既存処理が最終的に選んだ first/second の組を使用 + +#### HIERARCHICAL_FLICK + +`TfbiHierarchicalFlickController` は現在の `currentMap` と `currentHighlight` から「UP した場合の selectedNode」を解決する純粋関数を持つ。 + +```kotlin +private fun resolveCurrentOutput(): String? +``` + +- 終端 `Input`: その文字 +- `SubMenu`: 現行 UP 処理と同様に `nextMap[TAP]` が Input ならその文字 +- 無効方向、出力を持たない submenu: `null` +- 階層 push/pop、ハイライト変更、内部モード変更のたびに再解決して Changed +- UP でも同じ resolver を使用し、プレビューと確定の分岐を重複させない + +## 7. IME 側の状態設計 + +### 7.1 FlickInputPreviewCoordinator + +`IMEService` へロジックを直接追加し続けず、`ime_service/flick_preview/FlickInputPreviewCoordinator.kt` を追加する。 + +```kotlin +data class ActiveFlickPreview( + val gestureId: Long, + val editorSessionId: Long, + val baseInput: String, + val baseCanonicalRevision: Long, + val settingEnabledAtDown: Boolean, + val lastSelection: FlickTextSelection?, + val lastMutation: FlickTextMutation?, +) +``` + +リスナー登録時に `FlickPreviewSource.TENKEY` または `FlickPreviewSource.SUMIRE` を含む `FlickPreviewContext` を組み立てる。イベント型自体はキーボード固有 enum を持たず、適用対象の判定は IME 境界で行う。 + +主な API は次とする。 + +```kotlin +fun onEvent(event: FlickTextPreviewEvent, context: FlickPreviewContext) +fun consumePendingCommit(text: String, isFlick: Boolean): FlickTextMutation? +fun cancel(reason: FlickPreviewCancelReason, restore: Boolean) +``` + +`editorSessionId` は `onStartInput()` ごとに増加させる。別の InputConnection から届いた古いイベントは無視する。 + +### 7.2 ComposingTextArbiter + +プレビュー中には、旧候補計算や live conversion の非同期結果が `setComposingText()` を呼ぶ可能性がある。その書き込みでプレビューが上書きされないよう、canonical 表示と preview 表示を調停する。 + +```kotlin +sealed interface CanonicalComposingState { + data class Text(val value: CharSequence, val cursorPosition: Int) : CanonicalComposingState + data object Finished : CanonicalComposingState +} + +class ComposingTextArbiter { + fun setCanonical(text: CharSequence?, cursorPosition: Int): Boolean + fun showPreview(text: CharSequence, cursorPosition: Int): Boolean + fun suspendPreviewAndRestore(): Boolean + fun releasePreview(leaveDisplayedText: Boolean) + fun cancelPreviewAndRestore(): Boolean + fun finishCanonical(): Boolean +} +``` + +規則は次のとおり。 + +- プレビューなし: canonical 書き込みをそのまま InputConnection へ転送する。 +- プレビュー中: canonical 書き込みは最新値を保存するが、エディタには転送しない。 +- preview 書き込み: InputConnection へ直接転送するが canonical 状態は変更しない。 +- `text = null` への移動: preview 表示だけを停止して canonical を復元するが、ジェスチャーセッションは保持する。文字方向へ戻ったら同じ `baseInput` から preview を再開する。 +- CANCEL: 最新 canonical 状態を復元する。DOWN 時点の古い状態へ固定的に戻さない。 +- 正常 UP: preview を表示したまま所有権だけ解放し、直後の `_inputString` 更新による canonical 描画へ接続する。 +- `commitText()`、`finishComposingText()`、削除、selection 変更など文字プレビュー以外の編集操作が入る場合: 先に preview をキャンセルしてから操作する。 + +`IMEService.setComposingText()` は canonical 経路として arbiter を通す。現在 `updateComposingText()` にある `currentInputConnection?.setComposingText()` の直接呼び出しも canonical 経路へ統一する。preview だけが arbiter の専用 bypass API から実 InputConnection を呼ぶ。 + +`CharSequence` は後から Span が変化しないよう `SpannableString` へコピーして保存する。 + +`showPreview()` が `false` を返した場合、そのジェスチャーでは preview を中止して従来方式へフォールバックする。InputConnection の戻り値が `true` でも独自実装が表示を無視する場合までは自動判定できないため、設定は best effort とする。 + +### 7.3 候補と非同期処理 + +MOVE 中は次を行わない。 + +- `_inputString` 更新 +- `requestCandidateRefresh()` +- Zenz リクエスト +- 学習状態更新 +- `finishComposingText()` +- `commitText()` +- `deleteSurroundingText()` + +DOWN 前から動作していた候補処理は継続してよい。結果の canonical composing 書き込みだけ arbiter が保留する。CANCEL なら最新結果を復元でき、UP なら正式入力後の新しい candidate token によって古い結果が無効化される。 + +## 8. 入力結果の予測と正式反映 + +### 8.1 純粋な mutation resolver + +プレビュー文字を単純に `baseInput + selection.text` としてはならない。TenKey と Sumire の 1 文字タップにはトグル入力があるため、例えば既に「あ」がある状態で「あ」キーをタップすると、結果は「ああ」ではなく「い」になる場合がある。 + +`sendCharTap()`、`sendCharFlick()`、`handleOnKeyForSumire()` に散らばる通常 composing 入力の判断を、純粋な resolver と適用処理へ分ける。 + +```kotlin +sealed interface FlickTextMutation { + data class ReplaceComposingInput( + val resultInput: String, + val effects: FlickInputEffects, + ) : FlickTextMutation + + data class Unsupported(val reason: FlickPreviewUnsupportedReason) : FlickTextMutation +} +``` + +resolver の入力には次を含める。 + +- DOWN 時点の `baseInput` +- 選択文字列 +- `isFlick` +- `isFlickOnlyMode` +- `isContinuousTapInputEnabled` +- `lastFlickConvertedNextHiragana` +- 現在の InputType と `ResolvedInputBehavior` +- TenKey / Sumire のモード +- 変換、選択、cursor、tail の各状態 + +1 文字出力は既存の `getNextInputChar()` と同じ規則を使い、複数文字出力は既存 Sumire 処理と同様に末尾へ追加する。 + +### 8.2 プレビューと確定で同じ計画を使う + +`Started` / `Changed` では resolver の結果だけを preview composing として表示する。 + +`CommitPending` では最後の mutation を pending として保持する。直後の既存文字確定コールバックが `text` と `isFlick` の一致する pending mutation を取得し、`_inputString` と既存フラグを一度だけ更新する。 + +これにより次を保証する。 + +- プレビューが「い」なのに UP 後「ああ」にならない。 +- MOVE 回数だけ文字が増えない。 +- プレビュー中にトグル入力フラグが変わらない。 +- 候補検索は最終文字に対して 1 回だけ開始される。 + +pending mutation が一致しない場合は preview を復元して、既存の確定処理へフォールバックする。 + +## 9. 詳細な状態遷移 + +### 9.1 通常例 + +入力前が「か」、押したキーが「あ」の場合: + +```text +Idle + -> DOWN/TAP + editor preview = "かあ" + _inputString = "か" + -> MOVE/UP direction + editor preview = "かう" + _inputString = "か" + -> MOVE/back to TAP + editor preview = "かあ" + _inputString = "か" + -> UP + pending mutation = "かあ" + existing final callback consumes mutation + _inputString = "かあ" + canonical composing/candidate refresh runs + -> Idle +``` + +### 9.2 無効方向・特殊方向 + +```text +text selection + -> MOVE to text = null + canonical composing を復元して preview を一時停止 + -> MOVE back to text selection + 同じ baseInput から preview を再表示 +``` + +`text = null` へ移動した時点で gesture 自体は終了させない。後から文字方向へ戻れるためである。 + +### 9.3 CANCEL + +次では canonical composing を復元し、IME 内部入力を変更しない。 + +- `ACTION_CANCEL` +- キーボード View 非表示 +- View detach / rebuild +- フローティングキーボード dismiss +- 入力モード・キーボード種類変更 +- `onFinishInputView()` +- 新しい `onStartInput()` +- editor session ID 不一致 +- 2 本目の指による既存特殊操作 +- プレビュー中の commit/delete/selection 操作 + +InputConnection が終了済みの場合は `restore = false` で状態だけ破棄する。 + +## 10. 適用判定 + +`FlickPreviewEligibilityPolicy` を pure class として追加し、次をすべて満たす場合だけ有効にする。 + +```text +setting enabled at DOWN +AND source is TenKey or Sumire +AND QWERTY surface is not active +AND ordinary text-producing key +AND no double-tap binding +AND input behavior is composing +AND not password/numeric/phone/date/time direct field +AND !isHenkan +AND !selectMode +AND !cursorMoveMode +AND stringInTail is empty +AND currentInputConnection exists +AND editor session matches +``` + +Sumire については `TenKeyQWERTYMode.Sumire` と、Sumire の数字レイアウトとして表示している `TenKeyQWERTYMode.Number` の composing 文字キーを許可する。`TenKeyQWERTYMode.Custom` は初回実装では拒否する。 + +## 11. 性能要件 + +- MotionEvent ごとに `setComposingText()` しない。 +- 選択文字列または `isFlick` が変化した場合だけ更新する。 +- MOVE 処理で coroutine を起動しない。 +- MOVE 処理で候補検索・辞書検索・DB 書き込みを行わない。 +- `SpannableString` は選択変化時に 1 個だけ生成する。 +- 1 ジェスチャー中に保持する preview state は 1 件だけとする。 + +通常の 4 方向 TenKey では、指が同じ方向にいる限り MOVE が何回来ても editor 呼び出しは増えない。 + +## 12. 変更予定ファイル + +### core + +- `core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEvent.kt` +- `core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitter.kt` +- emitter の unit test + +### tenkey + +- `tenkey/src/main/java/com/kazumaproject/tenkey/TenKey.kt` +- TenKey selection resolver の unit test +- DOWN/MOVE/UP/CANCEL の instrumented test + +### custom_keyboard + +- `FlickKeyboardView.kt` +- `CrossFlickInputController.kt` +- `StandardFlickInputController.kt` +- `CustomAngleFlickController.kt` +- `TfbiInputController.kt` +- `TfbiHierarchicalFlickController.kt` +- 各 controller の selection/commit/cancel test + +### app + +- `AppPreference.kt` +- `ImePreferencesSnapshot.kt` +- `IMEService.kt` +- `ime_service/flick_preview/FlickInputPreviewCoordinator.kt` +- `ime_service/flick_preview/ComposingTextArbiter.kt` +- `ime_service/flick_preview/FlickTextMutationResolver.kt` +- `ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt` +- `pref_operation_feedback.xml` +- `pref_common_legacy.xml` +- `values/strings.xml` +- `values-ja/strings.xml` +- coordinator、arbiter、resolver、eligibility の unit test +- TenKey/Sumire の instrumented test + +## 13. テスト計画 + +### 13.1 Unit test + +#### Emitter + +- Started は 1 回だけ +- 同じ selection の Changed は抑止 +- CommitPending -> callback -> Finished の順序 +- callback が例外でも Finished +- CANCEL 後の Changed/Finished は無視 + +#### Coordinator + +- stale gesture ID を無視 +- TenKey と Sumire の source context を識別 +- setting OFF、QWERTY、Custom のイベントを editor へ転送しない +- pending mutation が既存確定コールバックで消費されなかった場合に復元 + +#### Mutation resolver + +- 空入力 + 「あ」TAP +- 「あ」+ 同じキー TAP が「い」へ置換 +- Flick は末尾追加 +- フリックのみ設定 ON の TAP は末尾追加 +- Sumire 複数文字出力 +- unsupported InputType +- henkan/select/cursor/tail 状態 +- resolver 結果と既存確定結果の一致 + +#### Arbiter + +- preview 中の canonical write は editor へ出さず最新値だけ保存 +- CANCEL は最新 canonical を復元 +- 正常 release は preview 表示を消さない +- finish/commit/delete 前に preview を復元 +- editor session 変更後の古い CANCEL を無視 + +### 13.2 Controller test + +各 Sumire スタイルについて次を確認する。 + +- DOWN の TAP selection +- 方向変更の Changed +- 同方向 MOVE の重複抑止 +- 中央へ戻る +- 無効方向の `text = null` +- UP の final selection と既存確定出力が同じ +- ACTION_CANCEL / cancel() の Canceled +- 2 段、階層、map switch、長押し出力 + +### 13.3 Instrumented test + +Fake editor またはテスト Activity の EditText で InputConnection 呼び出しを記録する。 + +- OFF: DOWN/MOVE では editor 書き込みなし、UP は従来どおり +- ON: DOWN/MOVE は `setComposingText()` のみ +- ON: MOVE 中に `commitText()`、delete、candidate request がない +- UP: `_inputString` 更新と候補 request は 1 回だけ +- CANCEL: 入力前の composing と `_inputString` に戻る +- rapid input: 前の canonical 更新が次の preview を上書きしない +- normal/floating の両方 +- TenKey と Sumire 5 スタイル +- live conversion ON/OFF +- flick-only ON/OFF +- 候補欄 1/2/3 列、候補タブ表示 ON/OFF +- 縦/横 +- password、number、direct mode の fallback +- View hide、keyboard switch、IME restart + +Undo 対応エディタでは、1 ジェスチャーが中間文字ごとの複数 Undo 履歴にならないことも手動確認する。 + +## 14. 受け入れ条件 + +1. 設定 OFF では既存の文字列、候補、振動、音、ポップアップ、長押し、フリック判定が変わらない。 +2. 設定 ON では、対象キーの DOWN 直後に TAP 文字が入力欄へ表示される。 +3. 方向を変えると、前の仮文字が増殖せず現在選択文字へ置き換わる。 +4. 中央へ戻す、2 段目を変える、階層を戻る操作でも最終出力と表示が一致する。 +5. UP 後の `_inputString` と preview 最終表示が一致する。 +6. MOVE 中には候補生成、学習、commit、delete が走らない。 +7. CANCEL 後に仮文字が残らない。 +8. TenKey の通常・フローティングと、Sumire の通常・フローティングおよび 5 スタイルで同じ原則が成立する。 +9. QWERTY と対象外入力欄は従来動作を維持する。 +10. 新設定画面と従来設定画面の Switch が同じ値を表示する。 + +## 15. 実装順序 + +1. Preference、snapshot、runtime 同期を追加する。ただしまだ挙動には接続しない。 +2. core の event/emitter と unit test を追加する。 +3. TenKey へ event を追加し、OFF 時回帰 test を通す。 +4. Sumire 5 controller へ selection event を追加し、controller test を通す。 +5. mutation resolver と eligibility policy を追加し、既存確定処理を共通 mutation へ寄せる。 +6. composing arbiter を導入し、すべての canonical `setComposingText()` を経由させる。 +7. preview coordinator を TenKey/Sumire の通常・フローティングへ接続する。 +8. CANCEL/lifecycle/direct-operation の統合 test を追加する。 +9. rapid input、live conversion、候補欄レイアウトを含む instrumented matrix を実行する。 + +この順序により、キーボードイベント、入力結果計算、Editor 境界を分けて検証でき、設定 OFF の既存動作を各段階で確認できる。 diff --git a/symbol_keyboard/src/main/java/com/kazumaproject/data/emoji/EmojiCategory.kt b/symbol_keyboard/src/main/java/com/kazumaproject/data/emoji/EmojiCategory.kt index c3cb62d30..e115052bb 100644 --- a/symbol_keyboard/src/main/java/com/kazumaproject/data/emoji/EmojiCategory.kt +++ b/symbol_keyboard/src/main/java/com/kazumaproject/data/emoji/EmojiCategory.kt @@ -1,20 +1,15 @@ package com.kazumaproject.data.emoji -/** - * Unicode の絵文字群を大まかに以下のように分類します。 - * 実際の Unicode 仕様ではさらに細かく分かれていますが、 - * アプリでよく使われる大分類として参考にしてください。 - */ +/** Unicode Emoji の CLDR 順序に含まれるトップレベルグループ。 */ enum class EmojiCategory { - EMOTICONS, // 😀〜🙏 のような「顔文字」系 (U+1F600–1F64F) - GESTURES, // 👍👎✊✌️など「手や指・ジェスチャー」系 (U+1F590–1F5FF、U+1F90C–1F91F、U+2700–27BF など) - PEOPLE_BODY, // 👦👧👮🧕 など「人・体のパーツ」系 (U+1F466–1F487、U+1F9D0–1F9FF など) - ANIMALS_NATURE, // 🐶🐱🌲🌻 など「動物・自然」系 (U+1F300–1F5FF の一部、U+1F900–1F9FF の動植物範囲) - FOOD_DRINK, // 🍎🍔☕️ など「食べ物・飲み物」系 (U+1F34F–1F37F、U+1F950–1F96F など) - TRAVEL_PLACES, // 🚗✈️🏝 など「乗り物・場所」系 (U+1F680–1F6FF、U+1F3E0–1F3FF など) - ACTIVITIES, // ⚽️🎮🎉 など「アクティビティ・イベント」系 (U+26F0–26FF、U+1F3A0–1F3FF など) - OBJECTS, // 💡📱🔑 など「モノ一般」系 (U+1F4A0–1F4FF、U+1F500–1F5FF の一部) - SYMBOLS, // ♻️✅🔣 など「記号・シンボル」系 (U+2600–26FF、U+1F300–1F5FF の一部、U+1F7E0–1F7EB など) - FLAGS, // 🇯🇵🇺🇸 など「旗」系 (U+1F1E6–1F1FF) - UNKNOWN // どの範囲にも当てはまらない場合 + SMILEYS_EMOTION, + PEOPLE_BODY, + ANIMALS_NATURE, + FOOD_DRINK, + TRAVEL_PLACES, + ACTIVITIES, + OBJECTS, + SYMBOLS, + FLAGS, + UNKNOWN, } diff --git a/symbol_keyboard/src/main/java/com/kazumaproject/domain/Emoji.kt b/symbol_keyboard/src/main/java/com/kazumaproject/domain/Emoji.kt index ea416b8b7..a036adb9f 100644 --- a/symbol_keyboard/src/main/java/com/kazumaproject/domain/Emoji.kt +++ b/symbol_keyboard/src/main/java/com/kazumaproject/domain/Emoji.kt @@ -5,219 +5,18 @@ import com.kazumaproject.data.emoji.EmojiCategory import com.kazumaproject.data.emoticon.EmoticonCategory import com.kazumaproject.data.symbol.SymbolCategory -private val hardMap: Map = buildMap { - putAll( - codePoints( - 0x263A, 0x2639, - 0x1F600..0x1F64F, 0x1F910..0x1F93A, 0x1F97A..0x1F97A, 0x1F9D0..0x1F9D0, - 0x1F971, 0x1F974, 0x1F972, 0x1F973, 0x1F975, 0x1F976, 0x1F978, 0x1F979, - 0x1FAE0..0x1FAE5, 0x1FAE8 - ), - EmojiCategory.EMOTICONS - ) - - putAll( - codePoints( - 0x270A..0x270D, - 0x1F44A..0x1F4AA, - 0x1F590..0x1F590, - 0x1F91A..0x1F91F, - 0x1FAF0..0x1FAF8, - 0x1F64C, - 0x1F64F, - 0x1F919, - 0x1F918, - 0x1F933, - 0x1F596, - 0x1F595, - 0x1F440, - 0x1F441, - 0x1F442, - 0x1F443, - 0x1F444, - 0x1F445, - 0x1F446, - 0x1F447, - 0x1F448, - 0x1F449, - 0x261D, - 0x1F90C, - 0x1F90F - ), - EmojiCategory.GESTURES - ) - - putAll( - codePoints( - 0x1F319..0x1F31F, - 0x1F466..0x1F487, - 0x1F9B0..0x1F9B3, - 0x1FAC0..0x1FAC5, - 0x1F385, - 0x1F977, - 0x1F9B5, - 0x1F9B6, - 0x1F9B8, - 0x1F9B9, - 0x1F9BF, - 0x1F9BE, - 0x1F9CD, - 0x1F9CE, - 0x1F9CF, - 0x1FAE6, - 0x1F9E0 - ), - EmojiCategory.PEOPLE_BODY - ) - - putAll( - codePoints( - 0x1F43F, - 0x1F9E3, - 0x1F9E5, - 0x1F9A6, - 0x1F9A4, - 0x1F9A7, - 0x1F9A8, - 0x1F9A9, - 0x1F9AB, - 0x1F9AA, - 0x1FAB0, - 0x1FAB1, - 0x1FAB2, - 0x1FAB3, - 0x1FAB4, - 0x1FAB5, - 0x1FAB6, - 0x1FAB7, - 0x1FAB8, - 0x1FABB, - 0x1FABC, - 0x1FABD, - 0x1FABF, - 0x1FACE, - 0x1FACF, - 0x1FAD0, - 0x1FAD1, - 0x1FAD2, - 0x1FAD3, - 0x1FADA, - 0x1FADB, - 0x1FAD8 - ), - EmojiCategory.ANIMALS_NATURE - ) - - putAll( - codePoints(0x1F34F..0x1F37F, 0x1F950..0x1F96F), - EmojiCategory.FOOD_DRINK - ) +fun categorizeEmoji(emoji: String): EmojiCategory = + EmojiCategoryMetadata.emojiCategoryOf(emoji) - putAll( - codePoints(0x1F680..0x1F6FF, 0x1F3E0..0x1F3FF), - EmojiCategory.TRAVEL_PLACES - ) - - putAll( - codePoints(0x26F0..0x26FF, 0x1F3A0..0x1F3CA, 0x1F3C5..0x1F3FA), - EmojiCategory.ACTIVITIES - ) - - putAll( - codePoints(0x1F4A0..0x1F4FF, 0x1F5A4..0x1F5FF), - EmojiCategory.OBJECTS - ) - - putAll( - codePoints(0x2600..0x26FF, 0x1F300..0x1F318, 0x1F320..0x1F335, 0x1F7E0..0x1F7EB), - EmojiCategory.SYMBOLS - ) -} - -private fun MutableMap.putAll(points: Iterable, cat: EmojiCategory) = - points.forEach { this[it] = cat } - -fun categorizeEmoji(emoji: String): EmojiCategory { - if (emoji.isEmpty()) return EmojiCategory.UNKNOWN - val cp = emoji.codePointAt(0) - hardMap[cp]?.let { return it } - return when { - (cp in 0x1F600..0x1F64F) - || (cp in 0x1F300..0x1F323) - || (cp in 0x1F900..0x1F9FF && cp in listOf( - 0x1F916, 0x1F917, 0x1F918, 0x1F919, 0x1F91A, 0x1F91B, - 0x1F91C, 0x1F91E, 0x1F91F, 0x1F920..0x1F927, - 0x1F970..0x1F97F, 0x1F9D0..0x1F9E3 - )) - -> EmojiCategory.EMOTICONS - - (cp in 0x1F44A..0x1F44F) - || (cp in 0x270A..0x270D) - || (cp in 0x1F91A..0x1F91F) - || (cp in 0x1FAF0..0x1FAF8) - -> EmojiCategory.GESTURES - - (cp in 0x1F466..0x1F487) - || (cp in 0x1F9B0..0x1F9B3) - || (cp in 0x1F9D1..0x1F9DF) - -> EmojiCategory.PEOPLE_BODY - - (cp in 0x1F400..0x1F43E) - || (cp in 0x1F980..0x1F997) - || (cp in 0x1F995..0x1F9A2) - || (cp in 0x1F9AC..0x1F9AE) - || (cp in 0x1F331..0x1F37C) - -> EmojiCategory.ANIMALS_NATURE - - (cp in 0x1F347..0x1F37F) - || (cp in 0x1F950..0x1F96F) - || (cp in 0x1F9C0..0x1F9C2) - -> EmojiCategory.FOOD_DRINK - - (cp in 0x1F680..0x1F6FF) - || (cp in 0x1F3E0..0x1F3FF) - || (cp in 0x1F5FA..0x1F5FF) - || (cp in 0x2600..0x26FF) - -> EmojiCategory.TRAVEL_PLACES - - (cp in 0x26F0..0x26FF) - || (cp in 0x1F3A0..0x1F3CA) - || (cp in 0x1F3C5..0x1F3FA) - || (cp in 0x1FA80..0x1FA9F) - -> EmojiCategory.ACTIVITIES - - (cp in 0x1F4A0..0x1F4FF) - || (cp in 0x1F500..0x1F5FF) - || (cp in 0x1FA9A..0x1FA9F) - || (cp in 0x1F52E..0x1F54A) - -> EmojiCategory.OBJECTS - - (cp in 0x2600..0x26FF) - || (cp in 0x1F300..0x1F5FF) - || (cp in 0x1F7E0..0x1F7EB) - || (cp in 0x2B50..0x2B55) - || (cp in 0x1F191..0x1F19A) - || (cp in 0x2753..0x2757) - -> EmojiCategory.SYMBOLS - - (cp in 0x1F1E6..0x1F1FF) - -> EmojiCategory.FLAGS - - else -> EmojiCategory.UNKNOWN - } -} - -private fun codePoints(vararg items: Any): List = buildList { - items.forEach { elem -> - when (elem) { - is Int -> add(elem) - is IntRange -> addAll(elem) - } - } -} +internal fun emojiSortOrder(emoji: String): Int = + EmojiCategoryMetadata.emojiOrderOf(emoji) fun List.sortByEmojiCategory(): List = - sortedWith(compareBy { it.category.ordinal }.thenBy { it.symbol }) + sortedWith( + compareBy { it.category.ordinal } + .thenBy { emojiSortOrder(it.symbol) } + .thenBy { it.symbol } + ) private val emoticonCategoryMap = mapOf( "(๑•̀ㅁ•́๑)✧" to EmoticonCategory.SMILE, diff --git a/symbol_keyboard/src/main/java/com/kazumaproject/domain/EmojiCategoryMetadata.kt b/symbol_keyboard/src/main/java/com/kazumaproject/domain/EmojiCategoryMetadata.kt new file mode 100644 index 000000000..d6134e80b --- /dev/null +++ b/symbol_keyboard/src/main/java/com/kazumaproject/domain/EmojiCategoryMetadata.kt @@ -0,0 +1,5313 @@ +// Generated by tools/emoji_metadata/generate_category_metadata.py. Do not edit manually. +// Unicode Emoji 17.0: https://www.unicode.org/Public/17.0.0/emoji/emoji-test.txt +package com.kazumaproject.domain + +import com.kazumaproject.data.emoji.EmojiCategory + +internal object EmojiCategoryMetadata { + const val UNICODE_VERSION: String = "17.0" + + private data class EmojiMetadata(val category: EmojiCategory, val order: Int) + + private val emojiIndex: Map by lazy(LazyThreadSafetyMode.PUBLICATION) { + val result = HashMap(10432) + var order = 0 + emojiDataChunks.forEach { chunk -> + chunk.lineSequence().filter(String::isNotBlank).forEach { line -> + val separator = line.indexOf(':') + val category = emojiCategory(line.substring(0, separator)) + val symbol = decodeCodePoints(line, separator + 1) + result.putIfAbsent(symbol, EmojiMetadata(category, order)) + order++ + } + } + result + } + + // U+FE0E/U+FE0F select text/emoji presentation; they do not change the + // Unicode/CLDR group. Some bundled entries add U+FE0F to characters whose + // fully-qualified emoji-test sequence does not contain a selector. + private val presentationIndependentEmojiIndex: Map by + lazy(LazyThreadSafetyMode.PUBLICATION) { + val result = HashMap(emojiIndex.size * 2) + emojiIndex.forEach { (symbol, metadata) -> + val key = symbol.withoutPresentationSelectors() + val existing = result[key] + check(existing == null || existing.category == metadata.category) { + "Presentation-independent emoji category collision for $key" + } + if (existing == null || metadata.order < existing.order) { + result[key] = metadata + } + } + result + } + + fun emojiCategoryOf(symbol: String): EmojiCategory = + emojiMetadataOf(symbol)?.category ?: EmojiCategory.UNKNOWN + + fun emojiOrderOf(symbol: String): Int = emojiMetadataOf(symbol)?.order ?: Int.MAX_VALUE + + internal fun emojiEntryCount(): Int = emojiIndex.size + + private fun emojiMetadataOf(symbol: String): EmojiMetadata? = + emojiIndex[symbol] + ?: presentationIndependentEmojiIndex[symbol.withoutPresentationSelectors()] + + private fun String.withoutPresentationSelectors(): String = + replace("\uFE0E", "").replace("\uFE0F", "") + + private fun emojiCategory(code: String): EmojiCategory = when (code) { + "S" -> EmojiCategory.SMILEYS_EMOTION + "P" -> EmojiCategory.PEOPLE_BODY + "N" -> EmojiCategory.ANIMALS_NATURE + "F" -> EmojiCategory.FOOD_DRINK + "T" -> EmojiCategory.TRAVEL_PLACES + "A" -> EmojiCategory.ACTIVITIES + "O" -> EmojiCategory.OBJECTS + "Y" -> EmojiCategory.SYMBOLS + "L" -> EmojiCategory.FLAGS + else -> error("Unknown emoji category code: $code") + } + + private fun decodeCodePoints(line: String, startIndex: Int): String { + val result = StringBuilder() + var tokenStart = startIndex + var index = startIndex + while (index <= line.length) { + if (index == line.length || line[index] == ' ') { + if (index > tokenStart) { + result.appendCodePoint(line.substring(tokenStart, index).toInt(16)) + } + tokenStart = index + 1 + } + index++ + } + return result.toString() + } + + private val emojiDataChunks = arrayOf( + """ +S:1F600 +S:1F603 +S:1F604 +S:1F601 +S:1F606 +S:1F605 +S:1F923 +S:1F602 +S:1F642 +S:1F643 +S:1FAE0 +S:1F609 +S:1F60A +S:1F607 +S:1F970 +S:1F60D +S:1F929 +S:1F618 +S:1F617 +S:263A FE0F +S:263A +S:1F61A +S:1F619 +S:1F972 +S:1F60B +S:1F61B +S:1F61C +S:1F92A +S:1F61D +S:1F911 +S:1F917 +S:1F92D +S:1FAE2 +S:1FAE3 +S:1F92B +S:1F914 +S:1FAE1 +S:1F910 +S:1F928 +S:1F610 +S:1F611 +S:1F636 +S:1FAE5 +S:1F636 200D 1F32B FE0F +S:1F636 200D 1F32B +S:1F60F +S:1F612 +S:1F644 +S:1F62C +S:1F62E 200D 1F4A8 +S:1F925 +S:1FAE8 +S:1F642 200D 2194 FE0F +S:1F642 200D 2194 +S:1F642 200D 2195 FE0F +S:1F642 200D 2195 +S:1F60C +S:1F614 +S:1F62A +S:1F924 +S:1F634 +S:1FAE9 +S:1F637 +S:1F912 +S:1F915 +S:1F922 +S:1F92E +S:1F927 +S:1F975 +S:1F976 +S:1F974 +S:1F635 +S:1F635 200D 1F4AB +S:1F92F +S:1F920 +S:1F973 +S:1F978 +S:1F60E +S:1F913 +S:1F9D0 +S:1F615 +S:1FAE4 +S:1F61F +S:1F641 +S:2639 FE0F +S:2639 +S:1F62E +S:1F62F +S:1F632 +S:1F633 +S:1FAEA +S:1F97A +S:1F979 +S:1F626 +S:1F627 +S:1F628 +S:1F630 +S:1F625 +S:1F622 +S:1F62D +S:1F631 +S:1F616 +S:1F623 +S:1F61E +S:1F613 +S:1F629 +S:1F62B +S:1F971 +S:1F624 +S:1F621 +S:1F620 +S:1F92C +S:1F608 +S:1F47F +S:1F480 +S:2620 FE0F +S:2620 +S:1F4A9 +S:1F921 +S:1F479 +S:1F47A +S:1F47B +S:1F47D +S:1F47E +S:1F916 +S:1F63A +S:1F638 +S:1F639 +S:1F63B +S:1F63C +S:1F63D +S:1F640 +S:1F63F +S:1F63E +S:1F648 +S:1F649 +S:1F64A +S:1F48C +S:1F498 +S:1F49D +S:1F496 +S:1F497 +S:1F493 +S:1F49E +S:1F495 +S:1F49F +S:2763 FE0F +S:2763 +S:1F494 +S:2764 FE0F 200D 1F525 +S:2764 200D 1F525 +S:2764 FE0F 200D 1FA79 +S:2764 200D 1FA79 +S:2764 FE0F +S:2764 +S:1FA77 +S:1F9E1 +S:1F49B +S:1F49A +S:1F499 +S:1FA75 +S:1F49C +S:1F90E +S:1F5A4 +S:1FA76 +S:1F90D +S:1F48B +S:1F4AF +S:1F4A2 +S:1FAEF +S:1F4A5 +S:1F4AB +S:1F4A6 +S:1F4A8 +S:1F573 FE0F +S:1F573 +S:1F4AC +S:1F441 FE0F 200D 1F5E8 FE0F +S:1F441 200D 1F5E8 FE0F +S:1F441 FE0F 200D 1F5E8 +S:1F441 200D 1F5E8 +S:1F5E8 FE0F +S:1F5E8 +S:1F5EF FE0F +S:1F5EF +S:1F4AD +S:1F4A4 +P:1F44B +P:1F44B 1F3FB +P:1F44B 1F3FC +P:1F44B 1F3FD +P:1F44B 1F3FE +P:1F44B 1F3FF +P:1F91A +P:1F91A 1F3FB +P:1F91A 1F3FC +P:1F91A 1F3FD +P:1F91A 1F3FE +P:1F91A 1F3FF +P:1F590 FE0F +P:1F590 +P:1F590 1F3FB +P:1F590 1F3FC +P:1F590 1F3FD +P:1F590 1F3FE +P:1F590 1F3FF +P:270B +P:270B 1F3FB +P:270B 1F3FC +P:270B 1F3FD +P:270B 1F3FE +P:270B 1F3FF +P:1F596 +P:1F596 1F3FB +P:1F596 1F3FC +P:1F596 1F3FD +P:1F596 1F3FE +P:1F596 1F3FF +P:1FAF1 +P:1FAF1 1F3FB +P:1FAF1 1F3FC +P:1FAF1 1F3FD +P:1FAF1 1F3FE +P:1FAF1 1F3FF +P:1FAF2 +P:1FAF2 1F3FB +P:1FAF2 1F3FC +P:1FAF2 1F3FD +P:1FAF2 1F3FE +P:1FAF2 1F3FF +P:1FAF3 +P:1FAF3 1F3FB +P:1FAF3 1F3FC +P:1FAF3 1F3FD +P:1FAF3 1F3FE +P:1FAF3 1F3FF +P:1FAF4 +P:1FAF4 1F3FB +P:1FAF4 1F3FC +P:1FAF4 1F3FD +P:1FAF4 1F3FE +P:1FAF4 1F3FF +P:1FAF7 +P:1FAF7 1F3FB +P:1FAF7 1F3FC +P:1FAF7 1F3FD +P:1FAF7 1F3FE +P:1FAF7 1F3FF +P:1FAF8 +P:1FAF8 1F3FB +P:1FAF8 1F3FC +P:1FAF8 1F3FD +P:1FAF8 1F3FE +P:1FAF8 1F3FF +P:1F44C +P:1F44C 1F3FB +P:1F44C 1F3FC +P:1F44C 1F3FD +P:1F44C 1F3FE +P:1F44C 1F3FF +P:1F90C +P:1F90C 1F3FB +P:1F90C 1F3FC +P:1F90C 1F3FD +P:1F90C 1F3FE +P:1F90C 1F3FF +P:1F90F +P:1F90F 1F3FB +P:1F90F 1F3FC +P:1F90F 1F3FD +P:1F90F 1F3FE +P:1F90F 1F3FF +P:270C FE0F +P:270C +P:270C 1F3FB +P:270C 1F3FC +P:270C 1F3FD +P:270C 1F3FE +P:270C 1F3FF +P:1F91E +P:1F91E 1F3FB +P:1F91E 1F3FC +P:1F91E 1F3FD +P:1F91E 1F3FE +P:1F91E 1F3FF +P:1FAF0 +P:1FAF0 1F3FB +P:1FAF0 1F3FC +P:1FAF0 1F3FD +P:1FAF0 1F3FE +P:1FAF0 1F3FF +P:1F91F +P:1F91F 1F3FB +P:1F91F 1F3FC +P:1F91F 1F3FD +P:1F91F 1F3FE +P:1F91F 1F3FF +P:1F918 +P:1F918 1F3FB +P:1F918 1F3FC +P:1F918 1F3FD +P:1F918 1F3FE +P:1F918 1F3FF +P:1F919 +P:1F919 1F3FB +P:1F919 1F3FC +P:1F919 1F3FD +P:1F919 1F3FE +P:1F919 1F3FF +P:1F448 +P:1F448 1F3FB +P:1F448 1F3FC +P:1F448 1F3FD +P:1F448 1F3FE +P:1F448 1F3FF +P:1F449 +P:1F449 1F3FB +P:1F449 1F3FC +P:1F449 1F3FD +P:1F449 1F3FE +P:1F449 1F3FF +P:1F446 +P:1F446 1F3FB +P:1F446 1F3FC +P:1F446 1F3FD +P:1F446 1F3FE +P:1F446 1F3FF +P:1F595 +P:1F595 1F3FB +P:1F595 1F3FC +P:1F595 1F3FD +P:1F595 1F3FE +P:1F595 1F3FF +P:1F447 +P:1F447 1F3FB +P:1F447 1F3FC +P:1F447 1F3FD +P:1F447 1F3FE +P:1F447 1F3FF +P:261D FE0F +P:261D +P:261D 1F3FB +P:261D 1F3FC +P:261D 1F3FD +P:261D 1F3FE +P:261D 1F3FF +P:1FAF5 +P:1FAF5 1F3FB +P:1FAF5 1F3FC +P:1FAF5 1F3FD +P:1FAF5 1F3FE +P:1FAF5 1F3FF +P:1F44D +P:1F44D 1F3FB +P:1F44D 1F3FC +P:1F44D 1F3FD +P:1F44D 1F3FE +P:1F44D 1F3FF +P:1F44E +P:1F44E 1F3FB +P:1F44E 1F3FC +P:1F44E 1F3FD +P:1F44E 1F3FE +P:1F44E 1F3FF +P:270A +P:270A 1F3FB +P:270A 1F3FC +P:270A 1F3FD +P:270A 1F3FE +P:270A 1F3FF +P:1F44A +P:1F44A 1F3FB +P:1F44A 1F3FC +P:1F44A 1F3FD +P:1F44A 1F3FE +P:1F44A 1F3FF +P:1F91B +P:1F91B 1F3FB +P:1F91B 1F3FC +P:1F91B 1F3FD +P:1F91B 1F3FE +P:1F91B 1F3FF +P:1F91C +P:1F91C 1F3FB +P:1F91C 1F3FC +P:1F91C 1F3FD +P:1F91C 1F3FE +P:1F91C 1F3FF +P:1F44F +P:1F44F 1F3FB +P:1F44F 1F3FC +P:1F44F 1F3FD +P:1F44F 1F3FE +P:1F44F 1F3FF +P:1F64C +P:1F64C 1F3FB +P:1F64C 1F3FC +P:1F64C 1F3FD +P:1F64C 1F3FE +P:1F64C 1F3FF +P:1FAF6 +P:1FAF6 1F3FB +P:1FAF6 1F3FC +P:1FAF6 1F3FD +P:1FAF6 1F3FE +P:1FAF6 1F3FF +P:1F450 +P:1F450 1F3FB +P:1F450 1F3FC +P:1F450 1F3FD +P:1F450 1F3FE +P:1F450 1F3FF +P:1F932 +P:1F932 1F3FB +P:1F932 1F3FC +P:1F932 1F3FD +P:1F932 1F3FE +P:1F932 1F3FF +P:1F91D +P:1F91D 1F3FB +P:1F91D 1F3FC +P:1F91D 1F3FD +P:1F91D 1F3FE +P:1F91D 1F3FF +P:1FAF1 1F3FB 200D 1FAF2 1F3FC +P:1FAF1 1F3FB 200D 1FAF2 1F3FD +P:1FAF1 1F3FB 200D 1FAF2 1F3FE +P:1FAF1 1F3FB 200D 1FAF2 1F3FF +P:1FAF1 1F3FC 200D 1FAF2 1F3FB +P:1FAF1 1F3FC 200D 1FAF2 1F3FD +P:1FAF1 1F3FC 200D 1FAF2 1F3FE +P:1FAF1 1F3FC 200D 1FAF2 1F3FF +P:1FAF1 1F3FD 200D 1FAF2 1F3FB +P:1FAF1 1F3FD 200D 1FAF2 1F3FC +P:1FAF1 1F3FD 200D 1FAF2 1F3FE +P:1FAF1 1F3FD 200D 1FAF2 1F3FF +P:1FAF1 1F3FE 200D 1FAF2 1F3FB +P:1FAF1 1F3FE 200D 1FAF2 1F3FC +P:1FAF1 1F3FE 200D 1FAF2 1F3FD +P:1FAF1 1F3FE 200D 1FAF2 1F3FF +P:1FAF1 1F3FF 200D 1FAF2 1F3FB +P:1FAF1 1F3FF 200D 1FAF2 1F3FC +P:1FAF1 1F3FF 200D 1FAF2 1F3FD +P:1FAF1 1F3FF 200D 1FAF2 1F3FE +P:1F64F +P:1F64F 1F3FB +P:1F64F 1F3FC +P:1F64F 1F3FD +P:1F64F 1F3FE +P:1F64F 1F3FF +P:270D FE0F +P:270D +P:270D 1F3FB +P:270D 1F3FC +P:270D 1F3FD +P:270D 1F3FE +P:270D 1F3FF +P:1F485 +P:1F485 1F3FB +P:1F485 1F3FC +P:1F485 1F3FD +P:1F485 1F3FE +P:1F485 1F3FF +P:1F933 +P:1F933 1F3FB +P:1F933 1F3FC +P:1F933 1F3FD +P:1F933 1F3FE +P:1F933 1F3FF +P:1F4AA +P:1F4AA 1F3FB +P:1F4AA 1F3FC +P:1F4AA 1F3FD +P:1F4AA 1F3FE +P:1F4AA 1F3FF +P:1F9BE +P:1F9BF +P:1F9B5 +P:1F9B5 1F3FB +P:1F9B5 1F3FC +P:1F9B5 1F3FD +P:1F9B5 1F3FE +P:1F9B5 1F3FF +P:1F9B6 +P:1F9B6 1F3FB +P:1F9B6 1F3FC +P:1F9B6 1F3FD +P:1F9B6 1F3FE +P:1F9B6 1F3FF +P:1F442 +P:1F442 1F3FB +P:1F442 1F3FC +P:1F442 1F3FD +P:1F442 1F3FE +P:1F442 1F3FF +P:1F9BB +P:1F9BB 1F3FB +P:1F9BB 1F3FC +P:1F9BB 1F3FD +P:1F9BB 1F3FE +P:1F9BB 1F3FF +P:1F443 +P:1F443 1F3FB +P:1F443 1F3FC +P:1F443 1F3FD +P:1F443 1F3FE +P:1F443 1F3FF +P:1F9E0 +P:1FAC0 +P:1FAC1 +P:1F9B7 +P:1F9B4 +P:1F440 +P:1F441 FE0F +P:1F441 +P:1F445 +P:1F444 +P:1FAE6 +P:1F476 +P:1F476 1F3FB +P:1F476 1F3FC +P:1F476 1F3FD +P:1F476 1F3FE +P:1F476 1F3FF +P:1F9D2 +P:1F9D2 1F3FB +P:1F9D2 1F3FC +P:1F9D2 1F3FD +P:1F9D2 1F3FE +P:1F9D2 1F3FF +P:1F466 +P:1F466 1F3FB +P:1F466 1F3FC +P:1F466 1F3FD +P:1F466 1F3FE +P:1F466 1F3FF +P:1F467 +P:1F467 1F3FB +P:1F467 1F3FC +P:1F467 1F3FD +P:1F467 1F3FE +P:1F467 1F3FF +P:1F9D1 +P:1F9D1 1F3FB +P:1F9D1 1F3FC +P:1F9D1 1F3FD +P:1F9D1 1F3FE +P:1F9D1 1F3FF +P:1F471 +P:1F471 1F3FB +P:1F471 1F3FC +P:1F471 1F3FD +P:1F471 1F3FE +P:1F471 1F3FF +P:1F468 +P:1F468 1F3FB +P:1F468 1F3FC +P:1F468 1F3FD +P:1F468 1F3FE +P:1F468 1F3FF +P:1F9D4 +P:1F9D4 1F3FB +P:1F9D4 1F3FC +P:1F9D4 1F3FD +P:1F9D4 1F3FE +P:1F9D4 1F3FF +P:1F9D4 200D 2642 FE0F +P:1F9D4 200D 2642 +P:1F9D4 1F3FB 200D 2642 FE0F +P:1F9D4 1F3FB 200D 2642 +P:1F9D4 1F3FC 200D 2642 FE0F +P:1F9D4 1F3FC 200D 2642 +P:1F9D4 1F3FD 200D 2642 FE0F +P:1F9D4 1F3FD 200D 2642 +P:1F9D4 1F3FE 200D 2642 FE0F +P:1F9D4 1F3FE 200D 2642 +P:1F9D4 1F3FF 200D 2642 FE0F +P:1F9D4 1F3FF 200D 2642 +P:1F9D4 200D 2640 FE0F +P:1F9D4 200D 2640 +P:1F9D4 1F3FB 200D 2640 FE0F +P:1F9D4 1F3FB 200D 2640 +P:1F9D4 1F3FC 200D 2640 FE0F +P:1F9D4 1F3FC 200D 2640 +P:1F9D4 1F3FD 200D 2640 FE0F +P:1F9D4 1F3FD 200D 2640 +P:1F9D4 1F3FE 200D 2640 FE0F +P:1F9D4 1F3FE 200D 2640 +P:1F9D4 1F3FF 200D 2640 FE0F +P:1F9D4 1F3FF 200D 2640 +P:1F468 200D 1F9B0 +P:1F468 1F3FB 200D 1F9B0 +P:1F468 1F3FC 200D 1F9B0 +P:1F468 1F3FD 200D 1F9B0 +P:1F468 1F3FE 200D 1F9B0 +P:1F468 1F3FF 200D 1F9B0 +P:1F468 200D 1F9B1 +P:1F468 1F3FB 200D 1F9B1 +P:1F468 1F3FC 200D 1F9B1 +P:1F468 1F3FD 200D 1F9B1 +P:1F468 1F3FE 200D 1F9B1 +P:1F468 1F3FF 200D 1F9B1 +P:1F468 200D 1F9B3 +P:1F468 1F3FB 200D 1F9B3 +P:1F468 1F3FC 200D 1F9B3 +P:1F468 1F3FD 200D 1F9B3 +P:1F468 1F3FE 200D 1F9B3 +P:1F468 1F3FF 200D 1F9B3 +P:1F468 200D 1F9B2 +P:1F468 1F3FB 200D 1F9B2 +P:1F468 1F3FC 200D 1F9B2 +P:1F468 1F3FD 200D 1F9B2 +P:1F468 1F3FE 200D 1F9B2 +P:1F468 1F3FF 200D 1F9B2 +P:1F469 +P:1F469 1F3FB +P:1F469 1F3FC +P:1F469 1F3FD +P:1F469 1F3FE +P:1F469 1F3FF +P:1F469 200D 1F9B0 +P:1F469 1F3FB 200D 1F9B0 +P:1F469 1F3FC 200D 1F9B0 +P:1F469 1F3FD 200D 1F9B0 +P:1F469 1F3FE 200D 1F9B0 +P:1F469 1F3FF 200D 1F9B0 +P:1F9D1 200D 1F9B0 +P:1F9D1 1F3FB 200D 1F9B0 +P:1F9D1 1F3FC 200D 1F9B0 +P:1F9D1 1F3FD 200D 1F9B0 +P:1F9D1 1F3FE 200D 1F9B0 +P:1F9D1 1F3FF 200D 1F9B0 +P:1F469 200D 1F9B1 +P:1F469 1F3FB 200D 1F9B1 +P:1F469 1F3FC 200D 1F9B1 +P:1F469 1F3FD 200D 1F9B1 +P:1F469 1F3FE 200D 1F9B1 +P:1F469 1F3FF 200D 1F9B1 +P:1F9D1 200D 1F9B1 +P:1F9D1 1F3FB 200D 1F9B1 +P:1F9D1 1F3FC 200D 1F9B1 +P:1F9D1 1F3FD 200D 1F9B1 +P:1F9D1 1F3FE 200D 1F9B1 +P:1F9D1 1F3FF 200D 1F9B1 +P:1F469 200D 1F9B3 +P:1F469 1F3FB 200D 1F9B3 +P:1F469 1F3FC 200D 1F9B3 +P:1F469 1F3FD 200D 1F9B3 +P:1F469 1F3FE 200D 1F9B3 +P:1F469 1F3FF 200D 1F9B3 +P:1F9D1 200D 1F9B3 +P:1F9D1 1F3FB 200D 1F9B3 +P:1F9D1 1F3FC 200D 1F9B3 +P:1F9D1 1F3FD 200D 1F9B3 +P:1F9D1 1F3FE 200D 1F9B3 +P:1F9D1 1F3FF 200D 1F9B3 +P:1F469 200D 1F9B2 +P:1F469 1F3FB 200D 1F9B2 +P:1F469 1F3FC 200D 1F9B2 +P:1F469 1F3FD 200D 1F9B2 +P:1F469 1F3FE 200D 1F9B2 +P:1F469 1F3FF 200D 1F9B2 +P:1F9D1 200D 1F9B2 +P:1F9D1 1F3FB 200D 1F9B2 +P:1F9D1 1F3FC 200D 1F9B2 +P:1F9D1 1F3FD 200D 1F9B2 +P:1F9D1 1F3FE 200D 1F9B2 +P:1F9D1 1F3FF 200D 1F9B2 +P:1F471 200D 2640 FE0F +P:1F471 200D 2640 +P:1F471 1F3FB 200D 2640 FE0F +P:1F471 1F3FB 200D 2640 +P:1F471 1F3FC 200D 2640 FE0F +P:1F471 1F3FC 200D 2640 +P:1F471 1F3FD 200D 2640 FE0F +P:1F471 1F3FD 200D 2640 +P:1F471 1F3FE 200D 2640 FE0F +P:1F471 1F3FE 200D 2640 +P:1F471 1F3FF 200D 2640 FE0F +P:1F471 1F3FF 200D 2640 +P:1F471 200D 2642 FE0F +P:1F471 200D 2642 +P:1F471 1F3FB 200D 2642 FE0F +P:1F471 1F3FB 200D 2642 +P:1F471 1F3FC 200D 2642 FE0F +P:1F471 1F3FC 200D 2642 +P:1F471 1F3FD 200D 2642 FE0F +P:1F471 1F3FD 200D 2642 +P:1F471 1F3FE 200D 2642 FE0F +P:1F471 1F3FE 200D 2642 +P:1F471 1F3FF 200D 2642 FE0F +P:1F471 1F3FF 200D 2642 +P:1F9D3 +P:1F9D3 1F3FB +P:1F9D3 1F3FC +P:1F9D3 1F3FD +P:1F9D3 1F3FE +P:1F9D3 1F3FF +P:1F474 +P:1F474 1F3FB +P:1F474 1F3FC +P:1F474 1F3FD +P:1F474 1F3FE +P:1F474 1F3FF +P:1F475 +P:1F475 1F3FB +P:1F475 1F3FC +P:1F475 1F3FD +P:1F475 1F3FE +P:1F475 1F3FF +P:1F64D +P:1F64D 1F3FB +P:1F64D 1F3FC +P:1F64D 1F3FD +P:1F64D 1F3FE +P:1F64D 1F3FF +P:1F64D 200D 2642 FE0F +P:1F64D 200D 2642 +P:1F64D 1F3FB 200D 2642 FE0F +P:1F64D 1F3FB 200D 2642 +P:1F64D 1F3FC 200D 2642 FE0F +P:1F64D 1F3FC 200D 2642 +P:1F64D 1F3FD 200D 2642 FE0F +P:1F64D 1F3FD 200D 2642 +P:1F64D 1F3FE 200D 2642 FE0F +P:1F64D 1F3FE 200D 2642 +P:1F64D 1F3FF 200D 2642 FE0F +P:1F64D 1F3FF 200D 2642 +P:1F64D 200D 2640 FE0F +P:1F64D 200D 2640 +P:1F64D 1F3FB 200D 2640 FE0F +P:1F64D 1F3FB 200D 2640 +P:1F64D 1F3FC 200D 2640 FE0F +P:1F64D 1F3FC 200D 2640 +P:1F64D 1F3FD 200D 2640 FE0F +P:1F64D 1F3FD 200D 2640 +P:1F64D 1F3FE 200D 2640 FE0F +P:1F64D 1F3FE 200D 2640 +P:1F64D 1F3FF 200D 2640 FE0F +P:1F64D 1F3FF 200D 2640 +P:1F64E +P:1F64E 1F3FB +P:1F64E 1F3FC +P:1F64E 1F3FD +P:1F64E 1F3FE +P:1F64E 1F3FF +P:1F64E 200D 2642 FE0F +P:1F64E 200D 2642 +P:1F64E 1F3FB 200D 2642 FE0F +P:1F64E 1F3FB 200D 2642 +P:1F64E 1F3FC 200D 2642 FE0F +P:1F64E 1F3FC 200D 2642 +P:1F64E 1F3FD 200D 2642 FE0F +P:1F64E 1F3FD 200D 2642 +P:1F64E 1F3FE 200D 2642 FE0F +P:1F64E 1F3FE 200D 2642 +P:1F64E 1F3FF 200D 2642 FE0F +P:1F64E 1F3FF 200D 2642 +P:1F64E 200D 2640 FE0F +P:1F64E 200D 2640 +P:1F64E 1F3FB 200D 2640 FE0F +P:1F64E 1F3FB 200D 2640 +P:1F64E 1F3FC 200D 2640 FE0F +P:1F64E 1F3FC 200D 2640 +P:1F64E 1F3FD 200D 2640 FE0F +P:1F64E 1F3FD 200D 2640 +P:1F64E 1F3FE 200D 2640 FE0F +P:1F64E 1F3FE 200D 2640 +P:1F64E 1F3FF 200D 2640 FE0F +P:1F64E 1F3FF 200D 2640 +P:1F645 +P:1F645 1F3FB +P:1F645 1F3FC +P:1F645 1F3FD +P:1F645 1F3FE +P:1F645 1F3FF +P:1F645 200D 2642 FE0F +P:1F645 200D 2642 +P:1F645 1F3FB 200D 2642 FE0F +P:1F645 1F3FB 200D 2642 +P:1F645 1F3FC 200D 2642 FE0F +P:1F645 1F3FC 200D 2642 +P:1F645 1F3FD 200D 2642 FE0F +P:1F645 1F3FD 200D 2642 +P:1F645 1F3FE 200D 2642 FE0F +P:1F645 1F3FE 200D 2642 +P:1F645 1F3FF 200D 2642 FE0F +P:1F645 1F3FF 200D 2642 +P:1F645 200D 2640 FE0F +P:1F645 200D 2640 +P:1F645 1F3FB 200D 2640 FE0F +P:1F645 1F3FB 200D 2640 +P:1F645 1F3FC 200D 2640 FE0F +P:1F645 1F3FC 200D 2640 +P:1F645 1F3FD 200D 2640 FE0F +P:1F645 1F3FD 200D 2640 +P:1F645 1F3FE 200D 2640 FE0F +P:1F645 1F3FE 200D 2640 +P:1F645 1F3FF 200D 2640 FE0F +P:1F645 1F3FF 200D 2640 +P:1F646 +P:1F646 1F3FB +P:1F646 1F3FC +P:1F646 1F3FD +P:1F646 1F3FE +P:1F646 1F3FF +P:1F646 200D 2642 FE0F +P:1F646 200D 2642 +P:1F646 1F3FB 200D 2642 FE0F +P:1F646 1F3FB 200D 2642 +P:1F646 1F3FC 200D 2642 FE0F +P:1F646 1F3FC 200D 2642 +P:1F646 1F3FD 200D 2642 FE0F +P:1F646 1F3FD 200D 2642 +P:1F646 1F3FE 200D 2642 FE0F +P:1F646 1F3FE 200D 2642 +P:1F646 1F3FF 200D 2642 FE0F +P:1F646 1F3FF 200D 2642 +P:1F646 200D 2640 FE0F +P:1F646 200D 2640 +P:1F646 1F3FB 200D 2640 FE0F +P:1F646 1F3FB 200D 2640 +P:1F646 1F3FC 200D 2640 FE0F +P:1F646 1F3FC 200D 2640 +P:1F646 1F3FD 200D 2640 FE0F +P:1F646 1F3FD 200D 2640 +P:1F646 1F3FE 200D 2640 FE0F +P:1F646 1F3FE 200D 2640 +P:1F646 1F3FF 200D 2640 FE0F +P:1F646 1F3FF 200D 2640 +P:1F481 +P:1F481 1F3FB +P:1F481 1F3FC +P:1F481 1F3FD +P:1F481 1F3FE +P:1F481 1F3FF +P:1F481 200D 2642 FE0F +P:1F481 200D 2642 +P:1F481 1F3FB 200D 2642 FE0F +P:1F481 1F3FB 200D 2642 +P:1F481 1F3FC 200D 2642 FE0F +P:1F481 1F3FC 200D 2642 +P:1F481 1F3FD 200D 2642 FE0F +P:1F481 1F3FD 200D 2642 +P:1F481 1F3FE 200D 2642 FE0F +P:1F481 1F3FE 200D 2642 +P:1F481 1F3FF 200D 2642 FE0F +P:1F481 1F3FF 200D 2642 +P:1F481 200D 2640 FE0F +P:1F481 200D 2640 +P:1F481 1F3FB 200D 2640 FE0F +P:1F481 1F3FB 200D 2640 +P:1F481 1F3FC 200D 2640 FE0F +P:1F481 1F3FC 200D 2640 +P:1F481 1F3FD 200D 2640 FE0F +P:1F481 1F3FD 200D 2640 +P:1F481 1F3FE 200D 2640 FE0F +P:1F481 1F3FE 200D 2640 +P:1F481 1F3FF 200D 2640 FE0F +P:1F481 1F3FF 200D 2640 +P:1F64B +P:1F64B 1F3FB +P:1F64B 1F3FC +P:1F64B 1F3FD +P:1F64B 1F3FE +P:1F64B 1F3FF +P:1F64B 200D 2642 FE0F +P:1F64B 200D 2642 +P:1F64B 1F3FB 200D 2642 FE0F +P:1F64B 1F3FB 200D 2642 +P:1F64B 1F3FC 200D 2642 FE0F +P:1F64B 1F3FC 200D 2642 +P:1F64B 1F3FD 200D 2642 FE0F +P:1F64B 1F3FD 200D 2642 +P:1F64B 1F3FE 200D 2642 FE0F +P:1F64B 1F3FE 200D 2642 +P:1F64B 1F3FF 200D 2642 FE0F +P:1F64B 1F3FF 200D 2642 +P:1F64B 200D 2640 FE0F +P:1F64B 200D 2640 +P:1F64B 1F3FB 200D 2640 FE0F +P:1F64B 1F3FB 200D 2640 +P:1F64B 1F3FC 200D 2640 FE0F +P:1F64B 1F3FC 200D 2640 +P:1F64B 1F3FD 200D 2640 FE0F +P:1F64B 1F3FD 200D 2640 +P:1F64B 1F3FE 200D 2640 FE0F +P:1F64B 1F3FE 200D 2640 +P:1F64B 1F3FF 200D 2640 FE0F +P:1F64B 1F3FF 200D 2640 +P:1F9CF +P:1F9CF 1F3FB +P:1F9CF 1F3FC +P:1F9CF 1F3FD +P:1F9CF 1F3FE +P:1F9CF 1F3FF +P:1F9CF 200D 2642 FE0F +P:1F9CF 200D 2642 +P:1F9CF 1F3FB 200D 2642 FE0F +P:1F9CF 1F3FB 200D 2642 +P:1F9CF 1F3FC 200D 2642 FE0F +P:1F9CF 1F3FC 200D 2642 +P:1F9CF 1F3FD 200D 2642 FE0F +P:1F9CF 1F3FD 200D 2642 +P:1F9CF 1F3FE 200D 2642 FE0F +P:1F9CF 1F3FE 200D 2642 +P:1F9CF 1F3FF 200D 2642 FE0F +P:1F9CF 1F3FF 200D 2642 +P:1F9CF 200D 2640 FE0F +P:1F9CF 200D 2640 +P:1F9CF 1F3FB 200D 2640 FE0F +P:1F9CF 1F3FB 200D 2640 +P:1F9CF 1F3FC 200D 2640 FE0F +P:1F9CF 1F3FC 200D 2640 +P:1F9CF 1F3FD 200D 2640 FE0F +P:1F9CF 1F3FD 200D 2640 +P:1F9CF 1F3FE 200D 2640 FE0F +P:1F9CF 1F3FE 200D 2640 +P:1F9CF 1F3FF 200D 2640 FE0F +P:1F9CF 1F3FF 200D 2640 +P:1F647 +P:1F647 1F3FB +P:1F647 1F3FC +P:1F647 1F3FD +P:1F647 1F3FE +P:1F647 1F3FF +P:1F647 200D 2642 FE0F +P:1F647 200D 2642 +P:1F647 1F3FB 200D 2642 FE0F +P:1F647 1F3FB 200D 2642 +P:1F647 1F3FC 200D 2642 FE0F +P:1F647 1F3FC 200D 2642 +P:1F647 1F3FD 200D 2642 FE0F +P:1F647 1F3FD 200D 2642 +P:1F647 1F3FE 200D 2642 FE0F +P:1F647 1F3FE 200D 2642 +P:1F647 1F3FF 200D 2642 FE0F +P:1F647 1F3FF 200D 2642 +P:1F647 200D 2640 FE0F +P:1F647 200D 2640 +P:1F647 1F3FB 200D 2640 FE0F +P:1F647 1F3FB 200D 2640 +P:1F647 1F3FC 200D 2640 FE0F +P:1F647 1F3FC 200D 2640 +P:1F647 1F3FD 200D 2640 FE0F +P:1F647 1F3FD 200D 2640 +P:1F647 1F3FE 200D 2640 FE0F +P:1F647 1F3FE 200D 2640 +P:1F647 1F3FF 200D 2640 FE0F +P:1F647 1F3FF 200D 2640 +P:1F926 +P:1F926 1F3FB +P:1F926 1F3FC +P:1F926 1F3FD +P:1F926 1F3FE +P:1F926 1F3FF +P:1F926 200D 2642 FE0F +P:1F926 200D 2642 +P:1F926 1F3FB 200D 2642 FE0F +P:1F926 1F3FB 200D 2642 +P:1F926 1F3FC 200D 2642 FE0F +P:1F926 1F3FC 200D 2642 +P:1F926 1F3FD 200D 2642 FE0F +P:1F926 1F3FD 200D 2642 +P:1F926 1F3FE 200D 2642 FE0F +P:1F926 1F3FE 200D 2642 +P:1F926 1F3FF 200D 2642 FE0F +P:1F926 1F3FF 200D 2642 +P:1F926 200D 2640 FE0F +P:1F926 200D 2640 +P:1F926 1F3FB 200D 2640 FE0F +P:1F926 1F3FB 200D 2640 +P:1F926 1F3FC 200D 2640 FE0F +P:1F926 1F3FC 200D 2640 +P:1F926 1F3FD 200D 2640 FE0F +P:1F926 1F3FD 200D 2640 +P:1F926 1F3FE 200D 2640 FE0F +P:1F926 1F3FE 200D 2640 +P:1F926 1F3FF 200D 2640 FE0F +P:1F926 1F3FF 200D 2640 +P:1F937 +P:1F937 1F3FB +P:1F937 1F3FC +P:1F937 1F3FD +P:1F937 1F3FE +P:1F937 1F3FF +P:1F937 200D 2642 FE0F +P:1F937 200D 2642 +P:1F937 1F3FB 200D 2642 FE0F +P:1F937 1F3FB 200D 2642 +P:1F937 1F3FC 200D 2642 FE0F +P:1F937 1F3FC 200D 2642 +P:1F937 1F3FD 200D 2642 FE0F +P:1F937 1F3FD 200D 2642 +P:1F937 1F3FE 200D 2642 FE0F +P:1F937 1F3FE 200D 2642 +P:1F937 1F3FF 200D 2642 FE0F +P:1F937 1F3FF 200D 2642 +P:1F937 200D 2640 FE0F +P:1F937 200D 2640 +P:1F937 1F3FB 200D 2640 FE0F +P:1F937 1F3FB 200D 2640 +P:1F937 1F3FC 200D 2640 FE0F +P:1F937 1F3FC 200D 2640 +P:1F937 1F3FD 200D 2640 FE0F +P:1F937 1F3FD 200D 2640 +P:1F937 1F3FE 200D 2640 FE0F +P:1F937 1F3FE 200D 2640 +P:1F937 1F3FF 200D 2640 FE0F +P:1F937 1F3FF 200D 2640 +P:1F9D1 200D 2695 FE0F +P:1F9D1 200D 2695 +P:1F9D1 1F3FB 200D 2695 FE0F +P:1F9D1 1F3FB 200D 2695 +P:1F9D1 1F3FC 200D 2695 FE0F +P:1F9D1 1F3FC 200D 2695 +P:1F9D1 1F3FD 200D 2695 FE0F +P:1F9D1 1F3FD 200D 2695 +P:1F9D1 1F3FE 200D 2695 FE0F +P:1F9D1 1F3FE 200D 2695 +P:1F9D1 1F3FF 200D 2695 FE0F +P:1F9D1 1F3FF 200D 2695 +P:1F468 200D 2695 FE0F +P:1F468 200D 2695 +P:1F468 1F3FB 200D 2695 FE0F +P:1F468 1F3FB 200D 2695 +P:1F468 1F3FC 200D 2695 FE0F +P:1F468 1F3FC 200D 2695 +P:1F468 1F3FD 200D 2695 FE0F +P:1F468 1F3FD 200D 2695 +P:1F468 1F3FE 200D 2695 FE0F +P:1F468 1F3FE 200D 2695 +P:1F468 1F3FF 200D 2695 FE0F +P:1F468 1F3FF 200D 2695 +P:1F469 200D 2695 FE0F +P:1F469 200D 2695 +P:1F469 1F3FB 200D 2695 FE0F +P:1F469 1F3FB 200D 2695 +P:1F469 1F3FC 200D 2695 FE0F +P:1F469 1F3FC 200D 2695 +P:1F469 1F3FD 200D 2695 FE0F +P:1F469 1F3FD 200D 2695 +P:1F469 1F3FE 200D 2695 FE0F +P:1F469 1F3FE 200D 2695 +P:1F469 1F3FF 200D 2695 FE0F +P:1F469 1F3FF 200D 2695 +P:1F9D1 200D 1F393 +P:1F9D1 1F3FB 200D 1F393 +P:1F9D1 1F3FC 200D 1F393 +P:1F9D1 1F3FD 200D 1F393 +P:1F9D1 1F3FE 200D 1F393 +P:1F9D1 1F3FF 200D 1F393 +P:1F468 200D 1F393 +P:1F468 1F3FB 200D 1F393 +P:1F468 1F3FC 200D 1F393 +P:1F468 1F3FD 200D 1F393 +P:1F468 1F3FE 200D 1F393 +P:1F468 1F3FF 200D 1F393 +P:1F469 200D 1F393 +P:1F469 1F3FB 200D 1F393 +P:1F469 1F3FC 200D 1F393 +P:1F469 1F3FD 200D 1F393 +P:1F469 1F3FE 200D 1F393 +P:1F469 1F3FF 200D 1F393 +P:1F9D1 200D 1F3EB +P:1F9D1 1F3FB 200D 1F3EB +P:1F9D1 1F3FC 200D 1F3EB +P:1F9D1 1F3FD 200D 1F3EB +P:1F9D1 1F3FE 200D 1F3EB +P:1F9D1 1F3FF 200D 1F3EB +P:1F468 200D 1F3EB +P:1F468 1F3FB 200D 1F3EB +P:1F468 1F3FC 200D 1F3EB +P:1F468 1F3FD 200D 1F3EB +P:1F468 1F3FE 200D 1F3EB +P:1F468 1F3FF 200D 1F3EB +P:1F469 200D 1F3EB +P:1F469 1F3FB 200D 1F3EB +P:1F469 1F3FC 200D 1F3EB +P:1F469 1F3FD 200D 1F3EB +P:1F469 1F3FE 200D 1F3EB +P:1F469 1F3FF 200D 1F3EB +P:1F9D1 200D 2696 FE0F +P:1F9D1 200D 2696 +P:1F9D1 1F3FB 200D 2696 FE0F +P:1F9D1 1F3FB 200D 2696 +P:1F9D1 1F3FC 200D 2696 FE0F +P:1F9D1 1F3FC 200D 2696 +P:1F9D1 1F3FD 200D 2696 FE0F +P:1F9D1 1F3FD 200D 2696 +P:1F9D1 1F3FE 200D 2696 FE0F +P:1F9D1 1F3FE 200D 2696 +P:1F9D1 1F3FF 200D 2696 FE0F +P:1F9D1 1F3FF 200D 2696 +P:1F468 200D 2696 FE0F +P:1F468 200D 2696 +P:1F468 1F3FB 200D 2696 FE0F +P:1F468 1F3FB 200D 2696 +P:1F468 1F3FC 200D 2696 FE0F +P:1F468 1F3FC 200D 2696 +P:1F468 1F3FD 200D 2696 FE0F +P:1F468 1F3FD 200D 2696 +P:1F468 1F3FE 200D 2696 FE0F +P:1F468 1F3FE 200D 2696 +P:1F468 1F3FF 200D 2696 FE0F +P:1F468 1F3FF 200D 2696 +P:1F469 200D 2696 FE0F +P:1F469 200D 2696 +P:1F469 1F3FB 200D 2696 FE0F +P:1F469 1F3FB 200D 2696 +P:1F469 1F3FC 200D 2696 FE0F +P:1F469 1F3FC 200D 2696 +P:1F469 1F3FD 200D 2696 FE0F +P:1F469 1F3FD 200D 2696 +P:1F469 1F3FE 200D 2696 FE0F +P:1F469 1F3FE 200D 2696 +P:1F469 1F3FF 200D 2696 FE0F +P:1F469 1F3FF 200D 2696 +P:1F9D1 200D 1F33E +P:1F9D1 1F3FB 200D 1F33E +P:1F9D1 1F3FC 200D 1F33E +P:1F9D1 1F3FD 200D 1F33E +P:1F9D1 1F3FE 200D 1F33E +P:1F9D1 1F3FF 200D 1F33E +P:1F468 200D 1F33E +P:1F468 1F3FB 200D 1F33E +P:1F468 1F3FC 200D 1F33E +P:1F468 1F3FD 200D 1F33E +P:1F468 1F3FE 200D 1F33E +P:1F468 1F3FF 200D 1F33E +P:1F469 200D 1F33E +P:1F469 1F3FB 200D 1F33E +P:1F469 1F3FC 200D 1F33E +P:1F469 1F3FD 200D 1F33E +P:1F469 1F3FE 200D 1F33E +P:1F469 1F3FF 200D 1F33E +P:1F9D1 200D 1F373 +P:1F9D1 1F3FB 200D 1F373 +P:1F9D1 1F3FC 200D 1F373 +P:1F9D1 1F3FD 200D 1F373 +P:1F9D1 1F3FE 200D 1F373 +P:1F9D1 1F3FF 200D 1F373 +P:1F468 200D 1F373 +P:1F468 1F3FB 200D 1F373 +P:1F468 1F3FC 200D 1F373 +P:1F468 1F3FD 200D 1F373 +P:1F468 1F3FE 200D 1F373 +P:1F468 1F3FF 200D 1F373 +P:1F469 200D 1F373 +P:1F469 1F3FB 200D 1F373 +P:1F469 1F3FC 200D 1F373 +P:1F469 1F3FD 200D 1F373 +P:1F469 1F3FE 200D 1F373 +P:1F469 1F3FF 200D 1F373 +P:1F9D1 200D 1F527 +P:1F9D1 1F3FB 200D 1F527 +P:1F9D1 1F3FC 200D 1F527 +P:1F9D1 1F3FD 200D 1F527 +P:1F9D1 1F3FE 200D 1F527 +P:1F9D1 1F3FF 200D 1F527 +P:1F468 200D 1F527 +P:1F468 1F3FB 200D 1F527 +P:1F468 1F3FC 200D 1F527 +P:1F468 1F3FD 200D 1F527 +P:1F468 1F3FE 200D 1F527 +P:1F468 1F3FF 200D 1F527 +P:1F469 200D 1F527 +P:1F469 1F3FB 200D 1F527 +P:1F469 1F3FC 200D 1F527 +P:1F469 1F3FD 200D 1F527 +P:1F469 1F3FE 200D 1F527 +P:1F469 1F3FF 200D 1F527 +P:1F9D1 200D 1F3ED +P:1F9D1 1F3FB 200D 1F3ED +P:1F9D1 1F3FC 200D 1F3ED +P:1F9D1 1F3FD 200D 1F3ED +P:1F9D1 1F3FE 200D 1F3ED +P:1F9D1 1F3FF 200D 1F3ED +P:1F468 200D 1F3ED +P:1F468 1F3FB 200D 1F3ED +P:1F468 1F3FC 200D 1F3ED +P:1F468 1F3FD 200D 1F3ED +P:1F468 1F3FE 200D 1F3ED +P:1F468 1F3FF 200D 1F3ED +P:1F469 200D 1F3ED +P:1F469 1F3FB 200D 1F3ED +P:1F469 1F3FC 200D 1F3ED +P:1F469 1F3FD 200D 1F3ED +P:1F469 1F3FE 200D 1F3ED +P:1F469 1F3FF 200D 1F3ED +P:1F9D1 200D 1F4BC +P:1F9D1 1F3FB 200D 1F4BC +P:1F9D1 1F3FC 200D 1F4BC +P:1F9D1 1F3FD 200D 1F4BC +P:1F9D1 1F3FE 200D 1F4BC +P:1F9D1 1F3FF 200D 1F4BC +P:1F468 200D 1F4BC +P:1F468 1F3FB 200D 1F4BC +P:1F468 1F3FC 200D 1F4BC +P:1F468 1F3FD 200D 1F4BC +P:1F468 1F3FE 200D 1F4BC +P:1F468 1F3FF 200D 1F4BC +P:1F469 200D 1F4BC +P:1F469 1F3FB 200D 1F4BC +P:1F469 1F3FC 200D 1F4BC +P:1F469 1F3FD 200D 1F4BC +P:1F469 1F3FE 200D 1F4BC +P:1F469 1F3FF 200D 1F4BC +P:1F9D1 200D 1F52C +P:1F9D1 1F3FB 200D 1F52C +P:1F9D1 1F3FC 200D 1F52C +P:1F9D1 1F3FD 200D 1F52C +P:1F9D1 1F3FE 200D 1F52C +P:1F9D1 1F3FF 200D 1F52C +P:1F468 200D 1F52C +P:1F468 1F3FB 200D 1F52C +P:1F468 1F3FC 200D 1F52C +P:1F468 1F3FD 200D 1F52C +P:1F468 1F3FE 200D 1F52C +P:1F468 1F3FF 200D 1F52C +P:1F469 200D 1F52C +P:1F469 1F3FB 200D 1F52C +P:1F469 1F3FC 200D 1F52C +P:1F469 1F3FD 200D 1F52C +P:1F469 1F3FE 200D 1F52C +P:1F469 1F3FF 200D 1F52C +P:1F9D1 200D 1F4BB +P:1F9D1 1F3FB 200D 1F4BB +P:1F9D1 1F3FC 200D 1F4BB +P:1F9D1 1F3FD 200D 1F4BB +P:1F9D1 1F3FE 200D 1F4BB +P:1F9D1 1F3FF 200D 1F4BB +P:1F468 200D 1F4BB +P:1F468 1F3FB 200D 1F4BB +P:1F468 1F3FC 200D 1F4BB +P:1F468 1F3FD 200D 1F4BB +P:1F468 1F3FE 200D 1F4BB +P:1F468 1F3FF 200D 1F4BB +P:1F469 200D 1F4BB +P:1F469 1F3FB 200D 1F4BB +P:1F469 1F3FC 200D 1F4BB +P:1F469 1F3FD 200D 1F4BB +P:1F469 1F3FE 200D 1F4BB +P:1F469 1F3FF 200D 1F4BB +P:1F9D1 200D 1F3A4 +P:1F9D1 1F3FB 200D 1F3A4 +P:1F9D1 1F3FC 200D 1F3A4 +P:1F9D1 1F3FD 200D 1F3A4 +P:1F9D1 1F3FE 200D 1F3A4 +P:1F9D1 1F3FF 200D 1F3A4 +P:1F468 200D 1F3A4 +P:1F468 1F3FB 200D 1F3A4 +P:1F468 1F3FC 200D 1F3A4 +P:1F468 1F3FD 200D 1F3A4 +P:1F468 1F3FE 200D 1F3A4 +P:1F468 1F3FF 200D 1F3A4 +P:1F469 200D 1F3A4 +P:1F469 1F3FB 200D 1F3A4 +P:1F469 1F3FC 200D 1F3A4 +P:1F469 1F3FD 200D 1F3A4 +P:1F469 1F3FE 200D 1F3A4 +P:1F469 1F3FF 200D 1F3A4 +P:1F9D1 200D 1F3A8 +P:1F9D1 1F3FB 200D 1F3A8 +P:1F9D1 1F3FC 200D 1F3A8 +P:1F9D1 1F3FD 200D 1F3A8 +P:1F9D1 1F3FE 200D 1F3A8 +P:1F9D1 1F3FF 200D 1F3A8 +P:1F468 200D 1F3A8 +P:1F468 1F3FB 200D 1F3A8 +P:1F468 1F3FC 200D 1F3A8 +P:1F468 1F3FD 200D 1F3A8 +P:1F468 1F3FE 200D 1F3A8 +P:1F468 1F3FF 200D 1F3A8 +P:1F469 200D 1F3A8 +P:1F469 1F3FB 200D 1F3A8 +P:1F469 1F3FC 200D 1F3A8 +P:1F469 1F3FD 200D 1F3A8 +P:1F469 1F3FE 200D 1F3A8 +P:1F469 1F3FF 200D 1F3A8 +P:1F9D1 200D 2708 FE0F +P:1F9D1 200D 2708 +P:1F9D1 1F3FB 200D 2708 FE0F +P:1F9D1 1F3FB 200D 2708 +P:1F9D1 1F3FC 200D 2708 FE0F +P:1F9D1 1F3FC 200D 2708 +P:1F9D1 1F3FD 200D 2708 FE0F +P:1F9D1 1F3FD 200D 2708 +P:1F9D1 1F3FE 200D 2708 FE0F +P:1F9D1 1F3FE 200D 2708 +P:1F9D1 1F3FF 200D 2708 FE0F +P:1F9D1 1F3FF 200D 2708 +P:1F468 200D 2708 FE0F +P:1F468 200D 2708 +P:1F468 1F3FB 200D 2708 FE0F +P:1F468 1F3FB 200D 2708 +P:1F468 1F3FC 200D 2708 FE0F +P:1F468 1F3FC 200D 2708 +P:1F468 1F3FD 200D 2708 FE0F +P:1F468 1F3FD 200D 2708 +P:1F468 1F3FE 200D 2708 FE0F +P:1F468 1F3FE 200D 2708 +P:1F468 1F3FF 200D 2708 FE0F +P:1F468 1F3FF 200D 2708 +P:1F469 200D 2708 FE0F +P:1F469 200D 2708 +P:1F469 1F3FB 200D 2708 FE0F +P:1F469 1F3FB 200D 2708 +P:1F469 1F3FC 200D 2708 FE0F +P:1F469 1F3FC 200D 2708 +P:1F469 1F3FD 200D 2708 FE0F +P:1F469 1F3FD 200D 2708 +P:1F469 1F3FE 200D 2708 FE0F +P:1F469 1F3FE 200D 2708 +P:1F469 1F3FF 200D 2708 FE0F +P:1F469 1F3FF 200D 2708 +P:1F9D1 200D 1F680 +P:1F9D1 1F3FB 200D 1F680 +P:1F9D1 1F3FC 200D 1F680 +P:1F9D1 1F3FD 200D 1F680 +P:1F9D1 1F3FE 200D 1F680 +P:1F9D1 1F3FF 200D 1F680 +P:1F468 200D 1F680 +P:1F468 1F3FB 200D 1F680 +P:1F468 1F3FC 200D 1F680 +P:1F468 1F3FD 200D 1F680 +P:1F468 1F3FE 200D 1F680 +P:1F468 1F3FF 200D 1F680 +P:1F469 200D 1F680 +P:1F469 1F3FB 200D 1F680 +P:1F469 1F3FC 200D 1F680 +P:1F469 1F3FD 200D 1F680 +P:1F469 1F3FE 200D 1F680 +P:1F469 1F3FF 200D 1F680 +P:1F9D1 200D 1F692 +P:1F9D1 1F3FB 200D 1F692 +P:1F9D1 1F3FC 200D 1F692 +P:1F9D1 1F3FD 200D 1F692 +P:1F9D1 1F3FE 200D 1F692 +P:1F9D1 1F3FF 200D 1F692 +P:1F468 200D 1F692 +P:1F468 1F3FB 200D 1F692 +P:1F468 1F3FC 200D 1F692 +P:1F468 1F3FD 200D 1F692 +P:1F468 1F3FE 200D 1F692 +P:1F468 1F3FF 200D 1F692 +P:1F469 200D 1F692 +P:1F469 1F3FB 200D 1F692 +P:1F469 1F3FC 200D 1F692 +P:1F469 1F3FD 200D 1F692 +P:1F469 1F3FE 200D 1F692 +P:1F469 1F3FF 200D 1F692 +P:1F46E +P:1F46E 1F3FB +P:1F46E 1F3FC +P:1F46E 1F3FD +P:1F46E 1F3FE +P:1F46E 1F3FF +P:1F46E 200D 2642 FE0F +P:1F46E 200D 2642 +P:1F46E 1F3FB 200D 2642 FE0F +P:1F46E 1F3FB 200D 2642 +P:1F46E 1F3FC 200D 2642 FE0F +P:1F46E 1F3FC 200D 2642 +P:1F46E 1F3FD 200D 2642 FE0F +P:1F46E 1F3FD 200D 2642 +P:1F46E 1F3FE 200D 2642 FE0F +P:1F46E 1F3FE 200D 2642 +P:1F46E 1F3FF 200D 2642 FE0F +P:1F46E 1F3FF 200D 2642 +P:1F46E 200D 2640 FE0F +P:1F46E 200D 2640 +P:1F46E 1F3FB 200D 2640 FE0F +P:1F46E 1F3FB 200D 2640 +P:1F46E 1F3FC 200D 2640 FE0F +P:1F46E 1F3FC 200D 2640 +P:1F46E 1F3FD 200D 2640 FE0F +P:1F46E 1F3FD 200D 2640 +P:1F46E 1F3FE 200D 2640 FE0F +P:1F46E 1F3FE 200D 2640 +P:1F46E 1F3FF 200D 2640 FE0F +P:1F46E 1F3FF 200D 2640 +P:1F575 FE0F +P:1F575 +P:1F575 1F3FB +P:1F575 1F3FC +P:1F575 1F3FD +P:1F575 1F3FE +P:1F575 1F3FF +P:1F575 FE0F 200D 2642 FE0F +P:1F575 200D 2642 FE0F +P:1F575 FE0F 200D 2642 +P:1F575 200D 2642 +P:1F575 1F3FB 200D 2642 FE0F +P:1F575 1F3FB 200D 2642 +P:1F575 1F3FC 200D 2642 FE0F +P:1F575 1F3FC 200D 2642 +P:1F575 1F3FD 200D 2642 FE0F +P:1F575 1F3FD 200D 2642 +P:1F575 1F3FE 200D 2642 FE0F +P:1F575 1F3FE 200D 2642 +P:1F575 1F3FF 200D 2642 FE0F +P:1F575 1F3FF 200D 2642 +P:1F575 FE0F 200D 2640 FE0F +P:1F575 200D 2640 FE0F +P:1F575 FE0F 200D 2640 +P:1F575 200D 2640 +P:1F575 1F3FB 200D 2640 FE0F +P:1F575 1F3FB 200D 2640 +P:1F575 1F3FC 200D 2640 FE0F +P:1F575 1F3FC 200D 2640 +P:1F575 1F3FD 200D 2640 FE0F +P:1F575 1F3FD 200D 2640 +P:1F575 1F3FE 200D 2640 FE0F +P:1F575 1F3FE 200D 2640 +P:1F575 1F3FF 200D 2640 FE0F +P:1F575 1F3FF 200D 2640 +P:1F482 +P:1F482 1F3FB +P:1F482 1F3FC +P:1F482 1F3FD +P:1F482 1F3FE +P:1F482 1F3FF +P:1F482 200D 2642 FE0F +P:1F482 200D 2642 +P:1F482 1F3FB 200D 2642 FE0F +P:1F482 1F3FB 200D 2642 +P:1F482 1F3FC 200D 2642 FE0F +P:1F482 1F3FC 200D 2642 +P:1F482 1F3FD 200D 2642 FE0F +P:1F482 1F3FD 200D 2642 +P:1F482 1F3FE 200D 2642 FE0F +P:1F482 1F3FE 200D 2642 +P:1F482 1F3FF 200D 2642 FE0F +P:1F482 1F3FF 200D 2642 +P:1F482 200D 2640 FE0F +P:1F482 200D 2640 +P:1F482 1F3FB 200D 2640 FE0F +P:1F482 1F3FB 200D 2640 +P:1F482 1F3FC 200D 2640 FE0F +P:1F482 1F3FC 200D 2640 +P:1F482 1F3FD 200D 2640 FE0F +P:1F482 1F3FD 200D 2640 +P:1F482 1F3FE 200D 2640 FE0F +P:1F482 1F3FE 200D 2640 +P:1F482 1F3FF 200D 2640 FE0F +P:1F482 1F3FF 200D 2640 +P:1F977 +P:1F977 1F3FB +P:1F977 1F3FC +P:1F977 1F3FD +P:1F977 1F3FE +P:1F977 1F3FF +P:1F477 +P:1F477 1F3FB +P:1F477 1F3FC +P:1F477 1F3FD +P:1F477 1F3FE +P:1F477 1F3FF +P:1F477 200D 2642 FE0F +P:1F477 200D 2642 +P:1F477 1F3FB 200D 2642 FE0F +P:1F477 1F3FB 200D 2642 +P:1F477 1F3FC 200D 2642 FE0F +P:1F477 1F3FC 200D 2642 +P:1F477 1F3FD 200D 2642 FE0F +P:1F477 1F3FD 200D 2642 +P:1F477 1F3FE 200D 2642 FE0F +P:1F477 1F3FE 200D 2642 +P:1F477 1F3FF 200D 2642 FE0F +P:1F477 1F3FF 200D 2642 +P:1F477 200D 2640 FE0F +P:1F477 200D 2640 +P:1F477 1F3FB 200D 2640 FE0F +P:1F477 1F3FB 200D 2640 +P:1F477 1F3FC 200D 2640 FE0F +P:1F477 1F3FC 200D 2640 +P:1F477 1F3FD 200D 2640 FE0F +P:1F477 1F3FD 200D 2640 +P:1F477 1F3FE 200D 2640 FE0F +P:1F477 1F3FE 200D 2640 +P:1F477 1F3FF 200D 2640 FE0F +P:1F477 1F3FF 200D 2640 +P:1FAC5 +P:1FAC5 1F3FB +P:1FAC5 1F3FC +P:1FAC5 1F3FD +P:1FAC5 1F3FE +P:1FAC5 1F3FF +P:1F934 +P:1F934 1F3FB +P:1F934 1F3FC +P:1F934 1F3FD +P:1F934 1F3FE +P:1F934 1F3FF +P:1F478 +P:1F478 1F3FB +P:1F478 1F3FC +P:1F478 1F3FD +P:1F478 1F3FE +P:1F478 1F3FF +P:1F473 +P:1F473 1F3FB +P:1F473 1F3FC +P:1F473 1F3FD +P:1F473 1F3FE +P:1F473 1F3FF +P:1F473 200D 2642 FE0F +P:1F473 200D 2642 +P:1F473 1F3FB 200D 2642 FE0F +P:1F473 1F3FB 200D 2642 +P:1F473 1F3FC 200D 2642 FE0F +P:1F473 1F3FC 200D 2642 +P:1F473 1F3FD 200D 2642 FE0F +P:1F473 1F3FD 200D 2642 +P:1F473 1F3FE 200D 2642 FE0F +P:1F473 1F3FE 200D 2642 +P:1F473 1F3FF 200D 2642 FE0F +P:1F473 1F3FF 200D 2642 +P:1F473 200D 2640 FE0F +P:1F473 200D 2640 +P:1F473 1F3FB 200D 2640 FE0F +P:1F473 1F3FB 200D 2640 +P:1F473 1F3FC 200D 2640 FE0F +P:1F473 1F3FC 200D 2640 +P:1F473 1F3FD 200D 2640 FE0F +P:1F473 1F3FD 200D 2640 +P:1F473 1F3FE 200D 2640 FE0F +P:1F473 1F3FE 200D 2640 +P:1F473 1F3FF 200D 2640 FE0F +P:1F473 1F3FF 200D 2640 +P:1F472 +P:1F472 1F3FB +P:1F472 1F3FC +P:1F472 1F3FD +P:1F472 1F3FE +P:1F472 1F3FF +P:1F9D5 +P:1F9D5 1F3FB +P:1F9D5 1F3FC +P:1F9D5 1F3FD +P:1F9D5 1F3FE +P:1F9D5 1F3FF +P:1F935 +P:1F935 1F3FB +P:1F935 1F3FC +P:1F935 1F3FD +P:1F935 1F3FE +P:1F935 1F3FF +P:1F935 200D 2642 FE0F +P:1F935 200D 2642 +P:1F935 1F3FB 200D 2642 FE0F +P:1F935 1F3FB 200D 2642 +P:1F935 1F3FC 200D 2642 FE0F +P:1F935 1F3FC 200D 2642 +P:1F935 1F3FD 200D 2642 FE0F +P:1F935 1F3FD 200D 2642 +P:1F935 1F3FE 200D 2642 FE0F +P:1F935 1F3FE 200D 2642 +P:1F935 1F3FF 200D 2642 FE0F +P:1F935 1F3FF 200D 2642 +P:1F935 200D 2640 FE0F +P:1F935 200D 2640 +P:1F935 1F3FB 200D 2640 FE0F +P:1F935 1F3FB 200D 2640 +P:1F935 1F3FC 200D 2640 FE0F +P:1F935 1F3FC 200D 2640 +P:1F935 1F3FD 200D 2640 FE0F +P:1F935 1F3FD 200D 2640 +P:1F935 1F3FE 200D 2640 FE0F +P:1F935 1F3FE 200D 2640 +P:1F935 1F3FF 200D 2640 FE0F +P:1F935 1F3FF 200D 2640 +P:1F470 +P:1F470 1F3FB +P:1F470 1F3FC +P:1F470 1F3FD +P:1F470 1F3FE +P:1F470 1F3FF +P:1F470 200D 2642 FE0F +P:1F470 200D 2642 +P:1F470 1F3FB 200D 2642 FE0F +P:1F470 1F3FB 200D 2642 +P:1F470 1F3FC 200D 2642 FE0F +P:1F470 1F3FC 200D 2642 +P:1F470 1F3FD 200D 2642 FE0F +P:1F470 1F3FD 200D 2642 +P:1F470 1F3FE 200D 2642 FE0F +P:1F470 1F3FE 200D 2642 +P:1F470 1F3FF 200D 2642 FE0F +P:1F470 1F3FF 200D 2642 +P:1F470 200D 2640 FE0F +P:1F470 200D 2640 +P:1F470 1F3FB 200D 2640 FE0F +P:1F470 1F3FB 200D 2640 +P:1F470 1F3FC 200D 2640 FE0F +P:1F470 1F3FC 200D 2640 +P:1F470 1F3FD 200D 2640 FE0F +P:1F470 1F3FD 200D 2640 +P:1F470 1F3FE 200D 2640 FE0F +P:1F470 1F3FE 200D 2640 +P:1F470 1F3FF 200D 2640 FE0F +P:1F470 1F3FF 200D 2640 +P:1F930 +P:1F930 1F3FB +P:1F930 1F3FC +P:1F930 1F3FD +P:1F930 1F3FE +P:1F930 1F3FF +P:1FAC3 +P:1FAC3 1F3FB +P:1FAC3 1F3FC +P:1FAC3 1F3FD +P:1FAC3 1F3FE +P:1FAC3 1F3FF +P:1FAC4 +P:1FAC4 1F3FB +P:1FAC4 1F3FC +P:1FAC4 1F3FD +P:1FAC4 1F3FE +P:1FAC4 1F3FF +P:1F931 +P:1F931 1F3FB +P:1F931 1F3FC +P:1F931 1F3FD +P:1F931 1F3FE +P:1F931 1F3FF +P:1F469 200D 1F37C +P:1F469 1F3FB 200D 1F37C +P:1F469 1F3FC 200D 1F37C +P:1F469 1F3FD 200D 1F37C +P:1F469 1F3FE 200D 1F37C +P:1F469 1F3FF 200D 1F37C +P:1F468 200D 1F37C +P:1F468 1F3FB 200D 1F37C +P:1F468 1F3FC 200D 1F37C +P:1F468 1F3FD 200D 1F37C +P:1F468 1F3FE 200D 1F37C +P:1F468 1F3FF 200D 1F37C +P:1F9D1 200D 1F37C +P:1F9D1 1F3FB 200D 1F37C +P:1F9D1 1F3FC 200D 1F37C +P:1F9D1 1F3FD 200D 1F37C +P:1F9D1 1F3FE 200D 1F37C +P:1F9D1 1F3FF 200D 1F37C +P:1F47C +P:1F47C 1F3FB +P:1F47C 1F3FC +P:1F47C 1F3FD +P:1F47C 1F3FE +P:1F47C 1F3FF +P:1F385 +P:1F385 1F3FB +P:1F385 1F3FC +P:1F385 1F3FD +P:1F385 1F3FE +P:1F385 1F3FF +P:1F936 +P:1F936 1F3FB +P:1F936 1F3FC +P:1F936 1F3FD +P:1F936 1F3FE +P:1F936 1F3FF +P:1F9D1 200D 1F384 +P:1F9D1 1F3FB 200D 1F384 +P:1F9D1 1F3FC 200D 1F384 +P:1F9D1 1F3FD 200D 1F384 +P:1F9D1 1F3FE 200D 1F384 +P:1F9D1 1F3FF 200D 1F384 +P:1F9B8 +P:1F9B8 1F3FB +P:1F9B8 1F3FC +P:1F9B8 1F3FD +P:1F9B8 1F3FE +P:1F9B8 1F3FF +P:1F9B8 200D 2642 FE0F +P:1F9B8 200D 2642 +P:1F9B8 1F3FB 200D 2642 FE0F +P:1F9B8 1F3FB 200D 2642 +P:1F9B8 1F3FC 200D 2642 FE0F +P:1F9B8 1F3FC 200D 2642 +P:1F9B8 1F3FD 200D 2642 FE0F +P:1F9B8 1F3FD 200D 2642 +P:1F9B8 1F3FE 200D 2642 FE0F +P:1F9B8 1F3FE 200D 2642 +P:1F9B8 1F3FF 200D 2642 FE0F +P:1F9B8 1F3FF 200D 2642 +P:1F9B8 200D 2640 FE0F +P:1F9B8 200D 2640 +P:1F9B8 1F3FB 200D 2640 FE0F +P:1F9B8 1F3FB 200D 2640 +P:1F9B8 1F3FC 200D 2640 FE0F +P:1F9B8 1F3FC 200D 2640 +P:1F9B8 1F3FD 200D 2640 FE0F +P:1F9B8 1F3FD 200D 2640 +P:1F9B8 1F3FE 200D 2640 FE0F +P:1F9B8 1F3FE 200D 2640 +P:1F9B8 1F3FF 200D 2640 FE0F +P:1F9B8 1F3FF 200D 2640 +P:1F9B9 +P:1F9B9 1F3FB +P:1F9B9 1F3FC +P:1F9B9 1F3FD +P:1F9B9 1F3FE +P:1F9B9 1F3FF +P:1F9B9 200D 2642 FE0F +P:1F9B9 200D 2642 +P:1F9B9 1F3FB 200D 2642 FE0F +P:1F9B9 1F3FB 200D 2642 +P:1F9B9 1F3FC 200D 2642 FE0F +P:1F9B9 1F3FC 200D 2642 +P:1F9B9 1F3FD 200D 2642 FE0F +P:1F9B9 1F3FD 200D 2642 +P:1F9B9 1F3FE 200D 2642 FE0F +P:1F9B9 1F3FE 200D 2642 +P:1F9B9 1F3FF 200D 2642 FE0F +P:1F9B9 1F3FF 200D 2642 +P:1F9B9 200D 2640 FE0F +P:1F9B9 200D 2640 +P:1F9B9 1F3FB 200D 2640 FE0F +P:1F9B9 1F3FB 200D 2640 +P:1F9B9 1F3FC 200D 2640 FE0F +P:1F9B9 1F3FC 200D 2640 +P:1F9B9 1F3FD 200D 2640 FE0F +P:1F9B9 1F3FD 200D 2640 +P:1F9B9 1F3FE 200D 2640 FE0F +P:1F9B9 1F3FE 200D 2640 +P:1F9B9 1F3FF 200D 2640 FE0F +P:1F9B9 1F3FF 200D 2640 +P:1F9D9 +P:1F9D9 1F3FB +P:1F9D9 1F3FC +P:1F9D9 1F3FD +P:1F9D9 1F3FE +P:1F9D9 1F3FF +P:1F9D9 200D 2642 FE0F +P:1F9D9 200D 2642 +P:1F9D9 1F3FB 200D 2642 FE0F +P:1F9D9 1F3FB 200D 2642 +P:1F9D9 1F3FC 200D 2642 FE0F +P:1F9D9 1F3FC 200D 2642 +P:1F9D9 1F3FD 200D 2642 FE0F +P:1F9D9 1F3FD 200D 2642 +P:1F9D9 1F3FE 200D 2642 FE0F +P:1F9D9 1F3FE 200D 2642 +P:1F9D9 1F3FF 200D 2642 FE0F +P:1F9D9 1F3FF 200D 2642 +P:1F9D9 200D 2640 FE0F +P:1F9D9 200D 2640 +P:1F9D9 1F3FB 200D 2640 FE0F +P:1F9D9 1F3FB 200D 2640 +P:1F9D9 1F3FC 200D 2640 FE0F +P:1F9D9 1F3FC 200D 2640 +P:1F9D9 1F3FD 200D 2640 FE0F +P:1F9D9 1F3FD 200D 2640 +P:1F9D9 1F3FE 200D 2640 FE0F +P:1F9D9 1F3FE 200D 2640 +P:1F9D9 1F3FF 200D 2640 FE0F +P:1F9D9 1F3FF 200D 2640 +P:1F9DA +P:1F9DA 1F3FB +P:1F9DA 1F3FC +P:1F9DA 1F3FD +P:1F9DA 1F3FE +P:1F9DA 1F3FF +P:1F9DA 200D 2642 FE0F +P:1F9DA 200D 2642 +P:1F9DA 1F3FB 200D 2642 FE0F +P:1F9DA 1F3FB 200D 2642 +P:1F9DA 1F3FC 200D 2642 FE0F +P:1F9DA 1F3FC 200D 2642 +P:1F9DA 1F3FD 200D 2642 FE0F +P:1F9DA 1F3FD 200D 2642 +P:1F9DA 1F3FE 200D 2642 FE0F +P:1F9DA 1F3FE 200D 2642 +P:1F9DA 1F3FF 200D 2642 FE0F +P:1F9DA 1F3FF 200D 2642 +P:1F9DA 200D 2640 FE0F +P:1F9DA 200D 2640 +P:1F9DA 1F3FB 200D 2640 FE0F +P:1F9DA 1F3FB 200D 2640 +P:1F9DA 1F3FC 200D 2640 FE0F +P:1F9DA 1F3FC 200D 2640 +P:1F9DA 1F3FD 200D 2640 FE0F +P:1F9DA 1F3FD 200D 2640 +P:1F9DA 1F3FE 200D 2640 FE0F +P:1F9DA 1F3FE 200D 2640 +P:1F9DA 1F3FF 200D 2640 FE0F +P:1F9DA 1F3FF 200D 2640 +P:1F9DB +P:1F9DB 1F3FB +P:1F9DB 1F3FC +P:1F9DB 1F3FD +P:1F9DB 1F3FE +P:1F9DB 1F3FF +P:1F9DB 200D 2642 FE0F +P:1F9DB 200D 2642 +P:1F9DB 1F3FB 200D 2642 FE0F +P:1F9DB 1F3FB 200D 2642 +P:1F9DB 1F3FC 200D 2642 FE0F +P:1F9DB 1F3FC 200D 2642 +P:1F9DB 1F3FD 200D 2642 FE0F +P:1F9DB 1F3FD 200D 2642 +P:1F9DB 1F3FE 200D 2642 FE0F +P:1F9DB 1F3FE 200D 2642 +P:1F9DB 1F3FF 200D 2642 FE0F +P:1F9DB 1F3FF 200D 2642 +P:1F9DB 200D 2640 FE0F +P:1F9DB 200D 2640 +P:1F9DB 1F3FB 200D 2640 FE0F +P:1F9DB 1F3FB 200D 2640 +P:1F9DB 1F3FC 200D 2640 FE0F +P:1F9DB 1F3FC 200D 2640 +P:1F9DB 1F3FD 200D 2640 FE0F +P:1F9DB 1F3FD 200D 2640 +P:1F9DB 1F3FE 200D 2640 FE0F +P:1F9DB 1F3FE 200D 2640 +P:1F9DB 1F3FF 200D 2640 FE0F +P:1F9DB 1F3FF 200D 2640 +P:1F9DC +P:1F9DC 1F3FB +P:1F9DC 1F3FC +P:1F9DC 1F3FD +P:1F9DC 1F3FE +P:1F9DC 1F3FF +P:1F9DC 200D 2642 FE0F +P:1F9DC 200D 2642 +P:1F9DC 1F3FB 200D 2642 FE0F +P:1F9DC 1F3FB 200D 2642 +P:1F9DC 1F3FC 200D 2642 FE0F +P:1F9DC 1F3FC 200D 2642 +P:1F9DC 1F3FD 200D 2642 FE0F +P:1F9DC 1F3FD 200D 2642 +P:1F9DC 1F3FE 200D 2642 FE0F +P:1F9DC 1F3FE 200D 2642 +P:1F9DC 1F3FF 200D 2642 FE0F +P:1F9DC 1F3FF 200D 2642 +P:1F9DC 200D 2640 FE0F +P:1F9DC 200D 2640 +P:1F9DC 1F3FB 200D 2640 FE0F +P:1F9DC 1F3FB 200D 2640 +P:1F9DC 1F3FC 200D 2640 FE0F +P:1F9DC 1F3FC 200D 2640 +P:1F9DC 1F3FD 200D 2640 FE0F +P:1F9DC 1F3FD 200D 2640 +P:1F9DC 1F3FE 200D 2640 FE0F +P:1F9DC 1F3FE 200D 2640 +P:1F9DC 1F3FF 200D 2640 FE0F +P:1F9DC 1F3FF 200D 2640 +P:1F9DD +P:1F9DD 1F3FB +P:1F9DD 1F3FC +P:1F9DD 1F3FD +P:1F9DD 1F3FE +P:1F9DD 1F3FF +P:1F9DD 200D 2642 FE0F +P:1F9DD 200D 2642 +P:1F9DD 1F3FB 200D 2642 FE0F +P:1F9DD 1F3FB 200D 2642 +P:1F9DD 1F3FC 200D 2642 FE0F +P:1F9DD 1F3FC 200D 2642 +P:1F9DD 1F3FD 200D 2642 FE0F +P:1F9DD 1F3FD 200D 2642 +P:1F9DD 1F3FE 200D 2642 FE0F +P:1F9DD 1F3FE 200D 2642 +P:1F9DD 1F3FF 200D 2642 FE0F +P:1F9DD 1F3FF 200D 2642 +P:1F9DD 200D 2640 FE0F +P:1F9DD 200D 2640 +P:1F9DD 1F3FB 200D 2640 FE0F +P:1F9DD 1F3FB 200D 2640 +P:1F9DD 1F3FC 200D 2640 FE0F +P:1F9DD 1F3FC 200D 2640 +P:1F9DD 1F3FD 200D 2640 FE0F +P:1F9DD 1F3FD 200D 2640 +P:1F9DD 1F3FE 200D 2640 FE0F +P:1F9DD 1F3FE 200D 2640 +P:1F9DD 1F3FF 200D 2640 FE0F +P:1F9DD 1F3FF 200D 2640 +P:1F9DE +P:1F9DE 200D 2642 FE0F +P:1F9DE 200D 2642 +P:1F9DE 200D 2640 FE0F +P:1F9DE 200D 2640 +P:1F9DF +P:1F9DF 200D 2642 FE0F +P:1F9DF 200D 2642 +P:1F9DF 200D 2640 FE0F +P:1F9DF 200D 2640 +P:1F9CC +P:1FAC8 +P:1F486 +P:1F486 1F3FB +P:1F486 1F3FC +P:1F486 1F3FD +P:1F486 1F3FE +P:1F486 1F3FF +P:1F486 200D 2642 FE0F +P:1F486 200D 2642 +P:1F486 1F3FB 200D 2642 FE0F +P:1F486 1F3FB 200D 2642 +P:1F486 1F3FC 200D 2642 FE0F +P:1F486 1F3FC 200D 2642 +P:1F486 1F3FD 200D 2642 FE0F +P:1F486 1F3FD 200D 2642 +P:1F486 1F3FE 200D 2642 FE0F +P:1F486 1F3FE 200D 2642 +P:1F486 1F3FF 200D 2642 FE0F +P:1F486 1F3FF 200D 2642 +P:1F486 200D 2640 FE0F +P:1F486 200D 2640 +P:1F486 1F3FB 200D 2640 FE0F +P:1F486 1F3FB 200D 2640 +P:1F486 1F3FC 200D 2640 FE0F +P:1F486 1F3FC 200D 2640 +P:1F486 1F3FD 200D 2640 FE0F +P:1F486 1F3FD 200D 2640 +P:1F486 1F3FE 200D 2640 FE0F +P:1F486 1F3FE 200D 2640 +P:1F486 1F3FF 200D 2640 FE0F +P:1F486 1F3FF 200D 2640 +P:1F487 +P:1F487 1F3FB +P:1F487 1F3FC +P:1F487 1F3FD +P:1F487 1F3FE +P:1F487 1F3FF +P:1F487 200D 2642 FE0F +P:1F487 200D 2642 +P:1F487 1F3FB 200D 2642 FE0F +P:1F487 1F3FB 200D 2642 +P:1F487 1F3FC 200D 2642 FE0F +P:1F487 1F3FC 200D 2642 +P:1F487 1F3FD 200D 2642 FE0F +P:1F487 1F3FD 200D 2642 +P:1F487 1F3FE 200D 2642 FE0F +P:1F487 1F3FE 200D 2642 +P:1F487 1F3FF 200D 2642 FE0F +P:1F487 1F3FF 200D 2642 +P:1F487 200D 2640 FE0F +P:1F487 200D 2640 +P:1F487 1F3FB 200D 2640 FE0F +P:1F487 1F3FB 200D 2640 +P:1F487 1F3FC 200D 2640 FE0F +P:1F487 1F3FC 200D 2640 +P:1F487 1F3FD 200D 2640 FE0F +P:1F487 1F3FD 200D 2640 +P:1F487 1F3FE 200D 2640 FE0F +P:1F487 1F3FE 200D 2640 +P:1F487 1F3FF 200D 2640 FE0F +P:1F487 1F3FF 200D 2640 +P:1F6B6 +P:1F6B6 1F3FB +P:1F6B6 1F3FC +P:1F6B6 1F3FD +P:1F6B6 1F3FE +P:1F6B6 1F3FF +P:1F6B6 200D 2642 FE0F +P:1F6B6 200D 2642 +P:1F6B6 1F3FB 200D 2642 FE0F +P:1F6B6 1F3FB 200D 2642 +P:1F6B6 1F3FC 200D 2642 FE0F +P:1F6B6 1F3FC 200D 2642 +P:1F6B6 1F3FD 200D 2642 FE0F +P:1F6B6 1F3FD 200D 2642 +P:1F6B6 1F3FE 200D 2642 FE0F +P:1F6B6 1F3FE 200D 2642 +P:1F6B6 1F3FF 200D 2642 FE0F +P:1F6B6 1F3FF 200D 2642 +P:1F6B6 200D 2640 FE0F +P:1F6B6 200D 2640 +P:1F6B6 1F3FB 200D 2640 FE0F +P:1F6B6 1F3FB 200D 2640 +P:1F6B6 1F3FC 200D 2640 FE0F +P:1F6B6 1F3FC 200D 2640 +P:1F6B6 1F3FD 200D 2640 FE0F +P:1F6B6 1F3FD 200D 2640 +P:1F6B6 1F3FE 200D 2640 FE0F +P:1F6B6 1F3FE 200D 2640 +P:1F6B6 1F3FF 200D 2640 FE0F +P:1F6B6 1F3FF 200D 2640 +P:1F6B6 200D 27A1 FE0F +P:1F6B6 200D 27A1 +P:1F6B6 1F3FB 200D 27A1 FE0F +P:1F6B6 1F3FB 200D 27A1 +P:1F6B6 1F3FC 200D 27A1 FE0F +P:1F6B6 1F3FC 200D 27A1 +P:1F6B6 1F3FD 200D 27A1 FE0F +P:1F6B6 1F3FD 200D 27A1 +P:1F6B6 1F3FE 200D 27A1 FE0F +P:1F6B6 1F3FE 200D 27A1 +P:1F6B6 1F3FF 200D 27A1 FE0F +P:1F6B6 1F3FF 200D 27A1 +P:1F6B6 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 200D 2640 200D 27A1 FE0F +P:1F6B6 200D 2640 FE0F 200D 27A1 +P:1F6B6 200D 2640 200D 27A1 +P:1F6B6 1F3FB 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FB 200D 2640 200D 27A1 FE0F +P:1F6B6 1F3FB 200D 2640 FE0F 200D 27A1 +P:1F6B6 1F3FB 200D 2640 200D 27A1 +P:1F6B6 1F3FC 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FC 200D 2640 200D 27A1 FE0F +P:1F6B6 1F3FC 200D 2640 FE0F 200D 27A1 +P:1F6B6 1F3FC 200D 2640 200D 27A1 +P:1F6B6 1F3FD 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FD 200D 2640 200D 27A1 FE0F +P:1F6B6 1F3FD 200D 2640 FE0F 200D 27A1 +P:1F6B6 1F3FD 200D 2640 200D 27A1 +P:1F6B6 1F3FE 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FE 200D 2640 200D 27A1 FE0F +P:1F6B6 1F3FE 200D 2640 FE0F 200D 27A1 +P:1F6B6 1F3FE 200D 2640 200D 27A1 +P:1F6B6 1F3FF 200D 2640 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FF 200D 2640 200D 27A1 FE0F +P:1F6B6 1F3FF 200D 2640 FE0F 200D 27A1 +P:1F6B6 1F3FF 200D 2640 200D 27A1 +P:1F6B6 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 200D 2642 200D 27A1 FE0F +P:1F6B6 200D 2642 FE0F 200D 27A1 +P:1F6B6 200D 2642 200D 27A1 +P:1F6B6 1F3FB 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FB 200D 2642 200D 27A1 FE0F +P:1F6B6 1F3FB 200D 2642 FE0F 200D 27A1 +P:1F6B6 1F3FB 200D 2642 200D 27A1 +P:1F6B6 1F3FC 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FC 200D 2642 200D 27A1 FE0F +P:1F6B6 1F3FC 200D 2642 FE0F 200D 27A1 +P:1F6B6 1F3FC 200D 2642 200D 27A1 +P:1F6B6 1F3FD 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FD 200D 2642 200D 27A1 FE0F +P:1F6B6 1F3FD 200D 2642 FE0F 200D 27A1 +P:1F6B6 1F3FD 200D 2642 200D 27A1 +P:1F6B6 1F3FE 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FE 200D 2642 200D 27A1 FE0F +P:1F6B6 1F3FE 200D 2642 FE0F 200D 27A1 +P:1F6B6 1F3FE 200D 2642 200D 27A1 +P:1F6B6 1F3FF 200D 2642 FE0F 200D 27A1 FE0F +P:1F6B6 1F3FF 200D 2642 200D 27A1 FE0F +P:1F6B6 1F3FF 200D 2642 FE0F 200D 27A1 +P:1F6B6 1F3FF 200D 2642 200D 27A1 +P:1F9CD +P:1F9CD 1F3FB +P:1F9CD 1F3FC +P:1F9CD 1F3FD +P:1F9CD 1F3FE +P:1F9CD 1F3FF +P:1F9CD 200D 2642 FE0F +P:1F9CD 200D 2642 +P:1F9CD 1F3FB 200D 2642 FE0F +P:1F9CD 1F3FB 200D 2642 +P:1F9CD 1F3FC 200D 2642 FE0F +P:1F9CD 1F3FC 200D 2642 +P:1F9CD 1F3FD 200D 2642 FE0F +P:1F9CD 1F3FD 200D 2642 +P:1F9CD 1F3FE 200D 2642 FE0F +P:1F9CD 1F3FE 200D 2642 +P:1F9CD 1F3FF 200D 2642 FE0F +P:1F9CD 1F3FF 200D 2642 +P:1F9CD 200D 2640 FE0F +P:1F9CD 200D 2640 +P:1F9CD 1F3FB 200D 2640 FE0F +P:1F9CD 1F3FB 200D 2640 +P:1F9CD 1F3FC 200D 2640 FE0F +P:1F9CD 1F3FC 200D 2640 +P:1F9CD 1F3FD 200D 2640 FE0F +P:1F9CD 1F3FD 200D 2640 +P:1F9CD 1F3FE 200D 2640 FE0F +P:1F9CD 1F3FE 200D 2640 +P:1F9CD 1F3FF 200D 2640 FE0F +P:1F9CD 1F3FF 200D 2640 +P:1F9CE +P:1F9CE 1F3FB +P:1F9CE 1F3FC +P:1F9CE 1F3FD +P:1F9CE 1F3FE +P:1F9CE 1F3FF +P:1F9CE 200D 2642 FE0F +P:1F9CE 200D 2642 +P:1F9CE 1F3FB 200D 2642 FE0F +P:1F9CE 1F3FB 200D 2642 +P:1F9CE 1F3FC 200D 2642 FE0F +P:1F9CE 1F3FC 200D 2642 +P:1F9CE 1F3FD 200D 2642 FE0F +P:1F9CE 1F3FD 200D 2642 +P:1F9CE 1F3FE 200D 2642 FE0F +P:1F9CE 1F3FE 200D 2642 +P:1F9CE 1F3FF 200D 2642 FE0F +P:1F9CE 1F3FF 200D 2642 +P:1F9CE 200D 2640 FE0F +P:1F9CE 200D 2640 +P:1F9CE 1F3FB 200D 2640 FE0F +P:1F9CE 1F3FB 200D 2640 +P:1F9CE 1F3FC 200D 2640 FE0F +P:1F9CE 1F3FC 200D 2640 +P:1F9CE 1F3FD 200D 2640 FE0F +P:1F9CE 1F3FD 200D 2640 +P:1F9CE 1F3FE 200D 2640 FE0F +P:1F9CE 1F3FE 200D 2640 +P:1F9CE 1F3FF 200D 2640 FE0F +P:1F9CE 1F3FF 200D 2640 +P:1F9CE 200D 27A1 FE0F +P:1F9CE 200D 27A1 +P:1F9CE 1F3FB 200D 27A1 FE0F +P:1F9CE 1F3FB 200D 27A1 +P:1F9CE 1F3FC 200D 27A1 FE0F +P:1F9CE 1F3FC 200D 27A1 +P:1F9CE 1F3FD 200D 27A1 FE0F +P:1F9CE 1F3FD 200D 27A1 +P:1F9CE 1F3FE 200D 27A1 FE0F +P:1F9CE 1F3FE 200D 27A1 +P:1F9CE 1F3FF 200D 27A1 FE0F +P:1F9CE 1F3FF 200D 27A1 +P:1F9CE 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 200D 2640 200D 27A1 FE0F +P:1F9CE 200D 2640 FE0F 200D 27A1 +P:1F9CE 200D 2640 200D 27A1 +P:1F9CE 1F3FB 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FB 200D 2640 200D 27A1 FE0F +P:1F9CE 1F3FB 200D 2640 FE0F 200D 27A1 +P:1F9CE 1F3FB 200D 2640 200D 27A1 +P:1F9CE 1F3FC 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FC 200D 2640 200D 27A1 FE0F +P:1F9CE 1F3FC 200D 2640 FE0F 200D 27A1 +P:1F9CE 1F3FC 200D 2640 200D 27A1 +P:1F9CE 1F3FD 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FD 200D 2640 200D 27A1 FE0F +P:1F9CE 1F3FD 200D 2640 FE0F 200D 27A1 +P:1F9CE 1F3FD 200D 2640 200D 27A1 +P:1F9CE 1F3FE 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FE 200D 2640 200D 27A1 FE0F +P:1F9CE 1F3FE 200D 2640 FE0F 200D 27A1 +P:1F9CE 1F3FE 200D 2640 200D 27A1 +P:1F9CE 1F3FF 200D 2640 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FF 200D 2640 200D 27A1 FE0F +P:1F9CE 1F3FF 200D 2640 FE0F 200D 27A1 +P:1F9CE 1F3FF 200D 2640 200D 27A1 +P:1F9CE 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 200D 2642 200D 27A1 FE0F +P:1F9CE 200D 2642 FE0F 200D 27A1 +P:1F9CE 200D 2642 200D 27A1 +P:1F9CE 1F3FB 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FB 200D 2642 200D 27A1 FE0F +P:1F9CE 1F3FB 200D 2642 FE0F 200D 27A1 +P:1F9CE 1F3FB 200D 2642 200D 27A1 +P:1F9CE 1F3FC 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FC 200D 2642 200D 27A1 FE0F +P:1F9CE 1F3FC 200D 2642 FE0F 200D 27A1 +P:1F9CE 1F3FC 200D 2642 200D 27A1 +P:1F9CE 1F3FD 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FD 200D 2642 200D 27A1 FE0F +P:1F9CE 1F3FD 200D 2642 FE0F 200D 27A1 +P:1F9CE 1F3FD 200D 2642 200D 27A1 +P:1F9CE 1F3FE 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FE 200D 2642 200D 27A1 FE0F +P:1F9CE 1F3FE 200D 2642 FE0F 200D 27A1 +P:1F9CE 1F3FE 200D 2642 200D 27A1 +P:1F9CE 1F3FF 200D 2642 FE0F 200D 27A1 FE0F +P:1F9CE 1F3FF 200D 2642 200D 27A1 FE0F +P:1F9CE 1F3FF 200D 2642 FE0F 200D 27A1 +P:1F9CE 1F3FF 200D 2642 200D 27A1 +P:1F9D1 200D 1F9AF +P:1F9D1 1F3FB 200D 1F9AF +P:1F9D1 1F3FC 200D 1F9AF +P:1F9D1 1F3FD 200D 1F9AF +P:1F9D1 1F3FE 200D 1F9AF +P:1F9D1 1F3FF 200D 1F9AF +P:1F9D1 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 200D 1F9AF 200D 27A1 +P:1F9D1 1F3FB 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 1F3FB 200D 1F9AF 200D 27A1 +P:1F9D1 1F3FC 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 1F3FC 200D 1F9AF 200D 27A1 +P:1F9D1 1F3FD 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 1F3FD 200D 1F9AF 200D 27A1 +P:1F9D1 1F3FE 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 1F3FE 200D 1F9AF 200D 27A1 +P:1F9D1 1F3FF 200D 1F9AF 200D 27A1 FE0F +P:1F9D1 1F3FF 200D 1F9AF 200D 27A1 +P:1F468 200D 1F9AF +P:1F468 1F3FB 200D 1F9AF +P:1F468 1F3FC 200D 1F9AF +P:1F468 1F3FD 200D 1F9AF +P:1F468 1F3FE 200D 1F9AF +P:1F468 1F3FF 200D 1F9AF +P:1F468 200D 1F9AF 200D 27A1 FE0F +P:1F468 200D 1F9AF 200D 27A1 +P:1F468 1F3FB 200D 1F9AF 200D 27A1 FE0F +P:1F468 1F3FB 200D 1F9AF 200D 27A1 +P:1F468 1F3FC 200D 1F9AF 200D 27A1 FE0F +P:1F468 1F3FC 200D 1F9AF 200D 27A1 +P:1F468 1F3FD 200D 1F9AF 200D 27A1 FE0F +P:1F468 1F3FD 200D 1F9AF 200D 27A1 +P:1F468 1F3FE 200D 1F9AF 200D 27A1 FE0F +P:1F468 1F3FE 200D 1F9AF 200D 27A1 +P:1F468 1F3FF 200D 1F9AF 200D 27A1 FE0F +P:1F468 1F3FF 200D 1F9AF 200D 27A1 +P:1F469 200D 1F9AF +P:1F469 1F3FB 200D 1F9AF +P:1F469 1F3FC 200D 1F9AF +P:1F469 1F3FD 200D 1F9AF +P:1F469 1F3FE 200D 1F9AF +P:1F469 1F3FF 200D 1F9AF +P:1F469 200D 1F9AF 200D 27A1 FE0F +P:1F469 200D 1F9AF 200D 27A1 +P:1F469 1F3FB 200D 1F9AF 200D 27A1 FE0F +P:1F469 1F3FB 200D 1F9AF 200D 27A1 +P:1F469 1F3FC 200D 1F9AF 200D 27A1 FE0F +P:1F469 1F3FC 200D 1F9AF 200D 27A1 +P:1F469 1F3FD 200D 1F9AF 200D 27A1 FE0F +P:1F469 1F3FD 200D 1F9AF 200D 27A1 +P:1F469 1F3FE 200D 1F9AF 200D 27A1 FE0F +P:1F469 1F3FE 200D 1F9AF 200D 27A1 +P:1F469 1F3FF 200D 1F9AF 200D 27A1 FE0F +P:1F469 1F3FF 200D 1F9AF 200D 27A1 +P:1F9D1 200D 1F9BC +P:1F9D1 1F3FB 200D 1F9BC +P:1F9D1 1F3FC 200D 1F9BC +P:1F9D1 1F3FD 200D 1F9BC +P:1F9D1 1F3FE 200D 1F9BC +P:1F9D1 1F3FF 200D 1F9BC +P:1F9D1 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 200D 1F9BC 200D 27A1 +P:1F9D1 1F3FB 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 1F3FB 200D 1F9BC 200D 27A1 +P:1F9D1 1F3FC 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 1F3FC 200D 1F9BC 200D 27A1 +P:1F9D1 1F3FD 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 1F3FD 200D 1F9BC 200D 27A1 +P:1F9D1 1F3FE 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 1F3FE 200D 1F9BC 200D 27A1 +P:1F9D1 1F3FF 200D 1F9BC 200D 27A1 FE0F +P:1F9D1 1F3FF 200D 1F9BC 200D 27A1 +P:1F468 200D 1F9BC +P:1F468 1F3FB 200D 1F9BC +P:1F468 1F3FC 200D 1F9BC +P:1F468 1F3FD 200D 1F9BC +P:1F468 1F3FE 200D 1F9BC +P:1F468 1F3FF 200D 1F9BC +P:1F468 200D 1F9BC 200D 27A1 FE0F +P:1F468 200D 1F9BC 200D 27A1 +P:1F468 1F3FB 200D 1F9BC 200D 27A1 FE0F +P:1F468 1F3FB 200D 1F9BC 200D 27A1 +P:1F468 1F3FC 200D 1F9BC 200D 27A1 FE0F +P:1F468 1F3FC 200D 1F9BC 200D 27A1 +P:1F468 1F3FD 200D 1F9BC 200D 27A1 FE0F +P:1F468 1F3FD 200D 1F9BC 200D 27A1 +P:1F468 1F3FE 200D 1F9BC 200D 27A1 FE0F +P:1F468 1F3FE 200D 1F9BC 200D 27A1 +P:1F468 1F3FF 200D 1F9BC 200D 27A1 FE0F +P:1F468 1F3FF 200D 1F9BC 200D 27A1 +P:1F469 200D 1F9BC +P:1F469 1F3FB 200D 1F9BC +P:1F469 1F3FC 200D 1F9BC +P:1F469 1F3FD 200D 1F9BC +P:1F469 1F3FE 200D 1F9BC +P:1F469 1F3FF 200D 1F9BC +P:1F469 200D 1F9BC 200D 27A1 FE0F +P:1F469 200D 1F9BC 200D 27A1 +P:1F469 1F3FB 200D 1F9BC 200D 27A1 FE0F +P:1F469 1F3FB 200D 1F9BC 200D 27A1 +P:1F469 1F3FC 200D 1F9BC 200D 27A1 FE0F + """.trimIndent(), + """ +P:1F469 1F3FC 200D 1F9BC 200D 27A1 +P:1F469 1F3FD 200D 1F9BC 200D 27A1 FE0F +P:1F469 1F3FD 200D 1F9BC 200D 27A1 +P:1F469 1F3FE 200D 1F9BC 200D 27A1 FE0F +P:1F469 1F3FE 200D 1F9BC 200D 27A1 +P:1F469 1F3FF 200D 1F9BC 200D 27A1 FE0F +P:1F469 1F3FF 200D 1F9BC 200D 27A1 +P:1F9D1 200D 1F9BD +P:1F9D1 1F3FB 200D 1F9BD +P:1F9D1 1F3FC 200D 1F9BD +P:1F9D1 1F3FD 200D 1F9BD +P:1F9D1 1F3FE 200D 1F9BD +P:1F9D1 1F3FF 200D 1F9BD +P:1F9D1 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 200D 1F9BD 200D 27A1 +P:1F9D1 1F3FB 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 1F3FB 200D 1F9BD 200D 27A1 +P:1F9D1 1F3FC 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 1F3FC 200D 1F9BD 200D 27A1 +P:1F9D1 1F3FD 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 1F3FD 200D 1F9BD 200D 27A1 +P:1F9D1 1F3FE 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 1F3FE 200D 1F9BD 200D 27A1 +P:1F9D1 1F3FF 200D 1F9BD 200D 27A1 FE0F +P:1F9D1 1F3FF 200D 1F9BD 200D 27A1 +P:1F468 200D 1F9BD +P:1F468 1F3FB 200D 1F9BD +P:1F468 1F3FC 200D 1F9BD +P:1F468 1F3FD 200D 1F9BD +P:1F468 1F3FE 200D 1F9BD +P:1F468 1F3FF 200D 1F9BD +P:1F468 200D 1F9BD 200D 27A1 FE0F +P:1F468 200D 1F9BD 200D 27A1 +P:1F468 1F3FB 200D 1F9BD 200D 27A1 FE0F +P:1F468 1F3FB 200D 1F9BD 200D 27A1 +P:1F468 1F3FC 200D 1F9BD 200D 27A1 FE0F +P:1F468 1F3FC 200D 1F9BD 200D 27A1 +P:1F468 1F3FD 200D 1F9BD 200D 27A1 FE0F +P:1F468 1F3FD 200D 1F9BD 200D 27A1 +P:1F468 1F3FE 200D 1F9BD 200D 27A1 FE0F +P:1F468 1F3FE 200D 1F9BD 200D 27A1 +P:1F468 1F3FF 200D 1F9BD 200D 27A1 FE0F +P:1F468 1F3FF 200D 1F9BD 200D 27A1 +P:1F469 200D 1F9BD +P:1F469 1F3FB 200D 1F9BD +P:1F469 1F3FC 200D 1F9BD +P:1F469 1F3FD 200D 1F9BD +P:1F469 1F3FE 200D 1F9BD +P:1F469 1F3FF 200D 1F9BD +P:1F469 200D 1F9BD 200D 27A1 FE0F +P:1F469 200D 1F9BD 200D 27A1 +P:1F469 1F3FB 200D 1F9BD 200D 27A1 FE0F +P:1F469 1F3FB 200D 1F9BD 200D 27A1 +P:1F469 1F3FC 200D 1F9BD 200D 27A1 FE0F +P:1F469 1F3FC 200D 1F9BD 200D 27A1 +P:1F469 1F3FD 200D 1F9BD 200D 27A1 FE0F +P:1F469 1F3FD 200D 1F9BD 200D 27A1 +P:1F469 1F3FE 200D 1F9BD 200D 27A1 FE0F +P:1F469 1F3FE 200D 1F9BD 200D 27A1 +P:1F469 1F3FF 200D 1F9BD 200D 27A1 FE0F +P:1F469 1F3FF 200D 1F9BD 200D 27A1 +P:1F3C3 +P:1F3C3 1F3FB +P:1F3C3 1F3FC +P:1F3C3 1F3FD +P:1F3C3 1F3FE +P:1F3C3 1F3FF +P:1F3C3 200D 2642 FE0F +P:1F3C3 200D 2642 +P:1F3C3 1F3FB 200D 2642 FE0F +P:1F3C3 1F3FB 200D 2642 +P:1F3C3 1F3FC 200D 2642 FE0F +P:1F3C3 1F3FC 200D 2642 +P:1F3C3 1F3FD 200D 2642 FE0F +P:1F3C3 1F3FD 200D 2642 +P:1F3C3 1F3FE 200D 2642 FE0F +P:1F3C3 1F3FE 200D 2642 +P:1F3C3 1F3FF 200D 2642 FE0F +P:1F3C3 1F3FF 200D 2642 +P:1F3C3 200D 2640 FE0F +P:1F3C3 200D 2640 +P:1F3C3 1F3FB 200D 2640 FE0F +P:1F3C3 1F3FB 200D 2640 +P:1F3C3 1F3FC 200D 2640 FE0F +P:1F3C3 1F3FC 200D 2640 +P:1F3C3 1F3FD 200D 2640 FE0F +P:1F3C3 1F3FD 200D 2640 +P:1F3C3 1F3FE 200D 2640 FE0F +P:1F3C3 1F3FE 200D 2640 +P:1F3C3 1F3FF 200D 2640 FE0F +P:1F3C3 1F3FF 200D 2640 +P:1F3C3 200D 27A1 FE0F +P:1F3C3 200D 27A1 +P:1F3C3 1F3FB 200D 27A1 FE0F +P:1F3C3 1F3FB 200D 27A1 +P:1F3C3 1F3FC 200D 27A1 FE0F +P:1F3C3 1F3FC 200D 27A1 +P:1F3C3 1F3FD 200D 27A1 FE0F +P:1F3C3 1F3FD 200D 27A1 +P:1F3C3 1F3FE 200D 27A1 FE0F +P:1F3C3 1F3FE 200D 27A1 +P:1F3C3 1F3FF 200D 27A1 FE0F +P:1F3C3 1F3FF 200D 27A1 +P:1F3C3 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 200D 2640 200D 27A1 FE0F +P:1F3C3 200D 2640 FE0F 200D 27A1 +P:1F3C3 200D 2640 200D 27A1 +P:1F3C3 1F3FB 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FB 200D 2640 200D 27A1 FE0F +P:1F3C3 1F3FB 200D 2640 FE0F 200D 27A1 +P:1F3C3 1F3FB 200D 2640 200D 27A1 +P:1F3C3 1F3FC 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FC 200D 2640 200D 27A1 FE0F +P:1F3C3 1F3FC 200D 2640 FE0F 200D 27A1 +P:1F3C3 1F3FC 200D 2640 200D 27A1 +P:1F3C3 1F3FD 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FD 200D 2640 200D 27A1 FE0F +P:1F3C3 1F3FD 200D 2640 FE0F 200D 27A1 +P:1F3C3 1F3FD 200D 2640 200D 27A1 +P:1F3C3 1F3FE 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FE 200D 2640 200D 27A1 FE0F +P:1F3C3 1F3FE 200D 2640 FE0F 200D 27A1 +P:1F3C3 1F3FE 200D 2640 200D 27A1 +P:1F3C3 1F3FF 200D 2640 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FF 200D 2640 200D 27A1 FE0F +P:1F3C3 1F3FF 200D 2640 FE0F 200D 27A1 +P:1F3C3 1F3FF 200D 2640 200D 27A1 +P:1F3C3 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 200D 2642 200D 27A1 FE0F +P:1F3C3 200D 2642 FE0F 200D 27A1 +P:1F3C3 200D 2642 200D 27A1 +P:1F3C3 1F3FB 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FB 200D 2642 200D 27A1 FE0F +P:1F3C3 1F3FB 200D 2642 FE0F 200D 27A1 +P:1F3C3 1F3FB 200D 2642 200D 27A1 +P:1F3C3 1F3FC 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FC 200D 2642 200D 27A1 FE0F +P:1F3C3 1F3FC 200D 2642 FE0F 200D 27A1 +P:1F3C3 1F3FC 200D 2642 200D 27A1 +P:1F3C3 1F3FD 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FD 200D 2642 200D 27A1 FE0F +P:1F3C3 1F3FD 200D 2642 FE0F 200D 27A1 +P:1F3C3 1F3FD 200D 2642 200D 27A1 +P:1F3C3 1F3FE 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FE 200D 2642 200D 27A1 FE0F +P:1F3C3 1F3FE 200D 2642 FE0F 200D 27A1 +P:1F3C3 1F3FE 200D 2642 200D 27A1 +P:1F3C3 1F3FF 200D 2642 FE0F 200D 27A1 FE0F +P:1F3C3 1F3FF 200D 2642 200D 27A1 FE0F +P:1F3C3 1F3FF 200D 2642 FE0F 200D 27A1 +P:1F3C3 1F3FF 200D 2642 200D 27A1 +P:1F9D1 200D 1FA70 +P:1F9D1 1F3FB 200D 1FA70 +P:1F9D1 1F3FC 200D 1FA70 +P:1F9D1 1F3FD 200D 1FA70 +P:1F9D1 1F3FE 200D 1FA70 +P:1F9D1 1F3FF 200D 1FA70 +P:1F483 +P:1F483 1F3FB +P:1F483 1F3FC +P:1F483 1F3FD +P:1F483 1F3FE +P:1F483 1F3FF +P:1F57A +P:1F57A 1F3FB +P:1F57A 1F3FC +P:1F57A 1F3FD +P:1F57A 1F3FE +P:1F57A 1F3FF +P:1F574 FE0F +P:1F574 +P:1F574 1F3FB +P:1F574 1F3FC +P:1F574 1F3FD +P:1F574 1F3FE +P:1F574 1F3FF +P:1F46F +P:1F46F 1F3FB +P:1F46F 1F3FC +P:1F46F 1F3FD +P:1F46F 1F3FE +P:1F46F 1F3FF +P:1F46F 200D 2642 FE0F +P:1F46F 200D 2642 +P:1F46F 1F3FB 200D 2642 FE0F +P:1F46F 1F3FB 200D 2642 +P:1F46F 1F3FC 200D 2642 FE0F +P:1F46F 1F3FC 200D 2642 +P:1F46F 1F3FD 200D 2642 FE0F +P:1F46F 1F3FD 200D 2642 +P:1F46F 1F3FE 200D 2642 FE0F +P:1F46F 1F3FE 200D 2642 +P:1F46F 1F3FF 200D 2642 FE0F +P:1F46F 1F3FF 200D 2642 +P:1F46F 200D 2640 FE0F +P:1F46F 200D 2640 +P:1F46F 1F3FB 200D 2640 FE0F +P:1F46F 1F3FB 200D 2640 +P:1F46F 1F3FC 200D 2640 FE0F +P:1F46F 1F3FC 200D 2640 +P:1F46F 1F3FD 200D 2640 FE0F +P:1F46F 1F3FD 200D 2640 +P:1F46F 1F3FE 200D 2640 FE0F +P:1F46F 1F3FE 200D 2640 +P:1F46F 1F3FF 200D 2640 FE0F +P:1F46F 1F3FF 200D 2640 +P:1F9D1 1F3FB 200D 1F430 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 1F430 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 1F430 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 1F430 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 1F430 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 1F430 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 1F430 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 1F430 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 1F430 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 1F430 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 1F430 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 1F430 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 1F430 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 1F430 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 1F430 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 1F430 200D 1F9D1 1F3FF +P:1F9D1 1F3FF 200D 1F430 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 1F430 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 1F430 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 1F430 200D 1F9D1 1F3FE +P:1F468 1F3FB 200D 1F430 200D 1F468 1F3FC +P:1F468 1F3FB 200D 1F430 200D 1F468 1F3FD +P:1F468 1F3FB 200D 1F430 200D 1F468 1F3FE +P:1F468 1F3FB 200D 1F430 200D 1F468 1F3FF +P:1F468 1F3FC 200D 1F430 200D 1F468 1F3FB +P:1F468 1F3FC 200D 1F430 200D 1F468 1F3FD +P:1F468 1F3FC 200D 1F430 200D 1F468 1F3FE +P:1F468 1F3FC 200D 1F430 200D 1F468 1F3FF +P:1F468 1F3FD 200D 1F430 200D 1F468 1F3FB +P:1F468 1F3FD 200D 1F430 200D 1F468 1F3FC +P:1F468 1F3FD 200D 1F430 200D 1F468 1F3FE +P:1F468 1F3FD 200D 1F430 200D 1F468 1F3FF +P:1F468 1F3FE 200D 1F430 200D 1F468 1F3FB +P:1F468 1F3FE 200D 1F430 200D 1F468 1F3FC +P:1F468 1F3FE 200D 1F430 200D 1F468 1F3FD +P:1F468 1F3FE 200D 1F430 200D 1F468 1F3FF +P:1F468 1F3FF 200D 1F430 200D 1F468 1F3FB +P:1F468 1F3FF 200D 1F430 200D 1F468 1F3FC +P:1F468 1F3FF 200D 1F430 200D 1F468 1F3FD +P:1F468 1F3FF 200D 1F430 200D 1F468 1F3FE +P:1F469 1F3FB 200D 1F430 200D 1F469 1F3FC +P:1F469 1F3FB 200D 1F430 200D 1F469 1F3FD +P:1F469 1F3FB 200D 1F430 200D 1F469 1F3FE +P:1F469 1F3FB 200D 1F430 200D 1F469 1F3FF +P:1F469 1F3FC 200D 1F430 200D 1F469 1F3FB +P:1F469 1F3FC 200D 1F430 200D 1F469 1F3FD +P:1F469 1F3FC 200D 1F430 200D 1F469 1F3FE +P:1F469 1F3FC 200D 1F430 200D 1F469 1F3FF +P:1F469 1F3FD 200D 1F430 200D 1F469 1F3FB +P:1F469 1F3FD 200D 1F430 200D 1F469 1F3FC +P:1F469 1F3FD 200D 1F430 200D 1F469 1F3FE +P:1F469 1F3FD 200D 1F430 200D 1F469 1F3FF +P:1F469 1F3FE 200D 1F430 200D 1F469 1F3FB +P:1F469 1F3FE 200D 1F430 200D 1F469 1F3FC +P:1F469 1F3FE 200D 1F430 200D 1F469 1F3FD +P:1F469 1F3FE 200D 1F430 200D 1F469 1F3FF +P:1F469 1F3FF 200D 1F430 200D 1F469 1F3FB +P:1F469 1F3FF 200D 1F430 200D 1F469 1F3FC +P:1F469 1F3FF 200D 1F430 200D 1F469 1F3FD +P:1F469 1F3FF 200D 1F430 200D 1F469 1F3FE +P:1F9D6 +P:1F9D6 1F3FB +P:1F9D6 1F3FC +P:1F9D6 1F3FD +P:1F9D6 1F3FE +P:1F9D6 1F3FF +P:1F9D6 200D 2642 FE0F +P:1F9D6 200D 2642 +P:1F9D6 1F3FB 200D 2642 FE0F +P:1F9D6 1F3FB 200D 2642 +P:1F9D6 1F3FC 200D 2642 FE0F +P:1F9D6 1F3FC 200D 2642 +P:1F9D6 1F3FD 200D 2642 FE0F +P:1F9D6 1F3FD 200D 2642 +P:1F9D6 1F3FE 200D 2642 FE0F +P:1F9D6 1F3FE 200D 2642 +P:1F9D6 1F3FF 200D 2642 FE0F +P:1F9D6 1F3FF 200D 2642 +P:1F9D6 200D 2640 FE0F +P:1F9D6 200D 2640 +P:1F9D6 1F3FB 200D 2640 FE0F +P:1F9D6 1F3FB 200D 2640 +P:1F9D6 1F3FC 200D 2640 FE0F +P:1F9D6 1F3FC 200D 2640 +P:1F9D6 1F3FD 200D 2640 FE0F +P:1F9D6 1F3FD 200D 2640 +P:1F9D6 1F3FE 200D 2640 FE0F +P:1F9D6 1F3FE 200D 2640 +P:1F9D6 1F3FF 200D 2640 FE0F +P:1F9D6 1F3FF 200D 2640 +P:1F9D7 +P:1F9D7 1F3FB +P:1F9D7 1F3FC +P:1F9D7 1F3FD +P:1F9D7 1F3FE +P:1F9D7 1F3FF +P:1F9D7 200D 2642 FE0F +P:1F9D7 200D 2642 +P:1F9D7 1F3FB 200D 2642 FE0F +P:1F9D7 1F3FB 200D 2642 +P:1F9D7 1F3FC 200D 2642 FE0F +P:1F9D7 1F3FC 200D 2642 +P:1F9D7 1F3FD 200D 2642 FE0F +P:1F9D7 1F3FD 200D 2642 +P:1F9D7 1F3FE 200D 2642 FE0F +P:1F9D7 1F3FE 200D 2642 +P:1F9D7 1F3FF 200D 2642 FE0F +P:1F9D7 1F3FF 200D 2642 +P:1F9D7 200D 2640 FE0F +P:1F9D7 200D 2640 +P:1F9D7 1F3FB 200D 2640 FE0F +P:1F9D7 1F3FB 200D 2640 +P:1F9D7 1F3FC 200D 2640 FE0F +P:1F9D7 1F3FC 200D 2640 +P:1F9D7 1F3FD 200D 2640 FE0F +P:1F9D7 1F3FD 200D 2640 +P:1F9D7 1F3FE 200D 2640 FE0F +P:1F9D7 1F3FE 200D 2640 +P:1F9D7 1F3FF 200D 2640 FE0F +P:1F9D7 1F3FF 200D 2640 +P:1F93A +P:1F3C7 +P:1F3C7 1F3FB +P:1F3C7 1F3FC +P:1F3C7 1F3FD +P:1F3C7 1F3FE +P:1F3C7 1F3FF +P:26F7 FE0F +P:26F7 +P:1F3C2 +P:1F3C2 1F3FB +P:1F3C2 1F3FC +P:1F3C2 1F3FD +P:1F3C2 1F3FE +P:1F3C2 1F3FF +P:1F3CC FE0F +P:1F3CC +P:1F3CC 1F3FB +P:1F3CC 1F3FC +P:1F3CC 1F3FD +P:1F3CC 1F3FE +P:1F3CC 1F3FF +P:1F3CC FE0F 200D 2642 FE0F +P:1F3CC 200D 2642 FE0F +P:1F3CC FE0F 200D 2642 +P:1F3CC 200D 2642 +P:1F3CC 1F3FB 200D 2642 FE0F +P:1F3CC 1F3FB 200D 2642 +P:1F3CC 1F3FC 200D 2642 FE0F +P:1F3CC 1F3FC 200D 2642 +P:1F3CC 1F3FD 200D 2642 FE0F +P:1F3CC 1F3FD 200D 2642 +P:1F3CC 1F3FE 200D 2642 FE0F +P:1F3CC 1F3FE 200D 2642 +P:1F3CC 1F3FF 200D 2642 FE0F +P:1F3CC 1F3FF 200D 2642 +P:1F3CC FE0F 200D 2640 FE0F +P:1F3CC 200D 2640 FE0F +P:1F3CC FE0F 200D 2640 +P:1F3CC 200D 2640 +P:1F3CC 1F3FB 200D 2640 FE0F +P:1F3CC 1F3FB 200D 2640 +P:1F3CC 1F3FC 200D 2640 FE0F +P:1F3CC 1F3FC 200D 2640 +P:1F3CC 1F3FD 200D 2640 FE0F +P:1F3CC 1F3FD 200D 2640 +P:1F3CC 1F3FE 200D 2640 FE0F +P:1F3CC 1F3FE 200D 2640 +P:1F3CC 1F3FF 200D 2640 FE0F +P:1F3CC 1F3FF 200D 2640 +P:1F3C4 +P:1F3C4 1F3FB +P:1F3C4 1F3FC +P:1F3C4 1F3FD +P:1F3C4 1F3FE +P:1F3C4 1F3FF +P:1F3C4 200D 2642 FE0F +P:1F3C4 200D 2642 +P:1F3C4 1F3FB 200D 2642 FE0F +P:1F3C4 1F3FB 200D 2642 +P:1F3C4 1F3FC 200D 2642 FE0F +P:1F3C4 1F3FC 200D 2642 +P:1F3C4 1F3FD 200D 2642 FE0F +P:1F3C4 1F3FD 200D 2642 +P:1F3C4 1F3FE 200D 2642 FE0F +P:1F3C4 1F3FE 200D 2642 +P:1F3C4 1F3FF 200D 2642 FE0F +P:1F3C4 1F3FF 200D 2642 +P:1F3C4 200D 2640 FE0F +P:1F3C4 200D 2640 +P:1F3C4 1F3FB 200D 2640 FE0F +P:1F3C4 1F3FB 200D 2640 +P:1F3C4 1F3FC 200D 2640 FE0F +P:1F3C4 1F3FC 200D 2640 +P:1F3C4 1F3FD 200D 2640 FE0F +P:1F3C4 1F3FD 200D 2640 +P:1F3C4 1F3FE 200D 2640 FE0F +P:1F3C4 1F3FE 200D 2640 +P:1F3C4 1F3FF 200D 2640 FE0F +P:1F3C4 1F3FF 200D 2640 +P:1F6A3 +P:1F6A3 1F3FB +P:1F6A3 1F3FC +P:1F6A3 1F3FD +P:1F6A3 1F3FE +P:1F6A3 1F3FF +P:1F6A3 200D 2642 FE0F +P:1F6A3 200D 2642 +P:1F6A3 1F3FB 200D 2642 FE0F +P:1F6A3 1F3FB 200D 2642 +P:1F6A3 1F3FC 200D 2642 FE0F +P:1F6A3 1F3FC 200D 2642 +P:1F6A3 1F3FD 200D 2642 FE0F +P:1F6A3 1F3FD 200D 2642 +P:1F6A3 1F3FE 200D 2642 FE0F +P:1F6A3 1F3FE 200D 2642 +P:1F6A3 1F3FF 200D 2642 FE0F +P:1F6A3 1F3FF 200D 2642 +P:1F6A3 200D 2640 FE0F +P:1F6A3 200D 2640 +P:1F6A3 1F3FB 200D 2640 FE0F +P:1F6A3 1F3FB 200D 2640 +P:1F6A3 1F3FC 200D 2640 FE0F +P:1F6A3 1F3FC 200D 2640 +P:1F6A3 1F3FD 200D 2640 FE0F +P:1F6A3 1F3FD 200D 2640 +P:1F6A3 1F3FE 200D 2640 FE0F +P:1F6A3 1F3FE 200D 2640 +P:1F6A3 1F3FF 200D 2640 FE0F +P:1F6A3 1F3FF 200D 2640 +P:1F3CA +P:1F3CA 1F3FB +P:1F3CA 1F3FC +P:1F3CA 1F3FD +P:1F3CA 1F3FE +P:1F3CA 1F3FF +P:1F3CA 200D 2642 FE0F +P:1F3CA 200D 2642 +P:1F3CA 1F3FB 200D 2642 FE0F +P:1F3CA 1F3FB 200D 2642 +P:1F3CA 1F3FC 200D 2642 FE0F +P:1F3CA 1F3FC 200D 2642 +P:1F3CA 1F3FD 200D 2642 FE0F +P:1F3CA 1F3FD 200D 2642 +P:1F3CA 1F3FE 200D 2642 FE0F +P:1F3CA 1F3FE 200D 2642 +P:1F3CA 1F3FF 200D 2642 FE0F +P:1F3CA 1F3FF 200D 2642 +P:1F3CA 200D 2640 FE0F +P:1F3CA 200D 2640 +P:1F3CA 1F3FB 200D 2640 FE0F +P:1F3CA 1F3FB 200D 2640 +P:1F3CA 1F3FC 200D 2640 FE0F +P:1F3CA 1F3FC 200D 2640 +P:1F3CA 1F3FD 200D 2640 FE0F +P:1F3CA 1F3FD 200D 2640 +P:1F3CA 1F3FE 200D 2640 FE0F +P:1F3CA 1F3FE 200D 2640 +P:1F3CA 1F3FF 200D 2640 FE0F +P:1F3CA 1F3FF 200D 2640 +P:26F9 FE0F +P:26F9 +P:26F9 1F3FB +P:26F9 1F3FC +P:26F9 1F3FD +P:26F9 1F3FE +P:26F9 1F3FF +P:26F9 FE0F 200D 2642 FE0F +P:26F9 200D 2642 FE0F +P:26F9 FE0F 200D 2642 +P:26F9 200D 2642 +P:26F9 1F3FB 200D 2642 FE0F +P:26F9 1F3FB 200D 2642 +P:26F9 1F3FC 200D 2642 FE0F +P:26F9 1F3FC 200D 2642 +P:26F9 1F3FD 200D 2642 FE0F +P:26F9 1F3FD 200D 2642 +P:26F9 1F3FE 200D 2642 FE0F +P:26F9 1F3FE 200D 2642 +P:26F9 1F3FF 200D 2642 FE0F +P:26F9 1F3FF 200D 2642 +P:26F9 FE0F 200D 2640 FE0F +P:26F9 200D 2640 FE0F +P:26F9 FE0F 200D 2640 +P:26F9 200D 2640 +P:26F9 1F3FB 200D 2640 FE0F +P:26F9 1F3FB 200D 2640 +P:26F9 1F3FC 200D 2640 FE0F +P:26F9 1F3FC 200D 2640 +P:26F9 1F3FD 200D 2640 FE0F +P:26F9 1F3FD 200D 2640 +P:26F9 1F3FE 200D 2640 FE0F +P:26F9 1F3FE 200D 2640 +P:26F9 1F3FF 200D 2640 FE0F +P:26F9 1F3FF 200D 2640 +P:1F3CB FE0F +P:1F3CB +P:1F3CB 1F3FB +P:1F3CB 1F3FC +P:1F3CB 1F3FD +P:1F3CB 1F3FE +P:1F3CB 1F3FF +P:1F3CB FE0F 200D 2642 FE0F +P:1F3CB 200D 2642 FE0F +P:1F3CB FE0F 200D 2642 +P:1F3CB 200D 2642 +P:1F3CB 1F3FB 200D 2642 FE0F +P:1F3CB 1F3FB 200D 2642 +P:1F3CB 1F3FC 200D 2642 FE0F +P:1F3CB 1F3FC 200D 2642 +P:1F3CB 1F3FD 200D 2642 FE0F +P:1F3CB 1F3FD 200D 2642 +P:1F3CB 1F3FE 200D 2642 FE0F +P:1F3CB 1F3FE 200D 2642 +P:1F3CB 1F3FF 200D 2642 FE0F +P:1F3CB 1F3FF 200D 2642 +P:1F3CB FE0F 200D 2640 FE0F +P:1F3CB 200D 2640 FE0F +P:1F3CB FE0F 200D 2640 +P:1F3CB 200D 2640 +P:1F3CB 1F3FB 200D 2640 FE0F +P:1F3CB 1F3FB 200D 2640 +P:1F3CB 1F3FC 200D 2640 FE0F +P:1F3CB 1F3FC 200D 2640 +P:1F3CB 1F3FD 200D 2640 FE0F +P:1F3CB 1F3FD 200D 2640 +P:1F3CB 1F3FE 200D 2640 FE0F +P:1F3CB 1F3FE 200D 2640 +P:1F3CB 1F3FF 200D 2640 FE0F +P:1F3CB 1F3FF 200D 2640 +P:1F6B4 +P:1F6B4 1F3FB +P:1F6B4 1F3FC +P:1F6B4 1F3FD +P:1F6B4 1F3FE +P:1F6B4 1F3FF +P:1F6B4 200D 2642 FE0F +P:1F6B4 200D 2642 +P:1F6B4 1F3FB 200D 2642 FE0F +P:1F6B4 1F3FB 200D 2642 +P:1F6B4 1F3FC 200D 2642 FE0F +P:1F6B4 1F3FC 200D 2642 +P:1F6B4 1F3FD 200D 2642 FE0F +P:1F6B4 1F3FD 200D 2642 +P:1F6B4 1F3FE 200D 2642 FE0F +P:1F6B4 1F3FE 200D 2642 +P:1F6B4 1F3FF 200D 2642 FE0F +P:1F6B4 1F3FF 200D 2642 +P:1F6B4 200D 2640 FE0F +P:1F6B4 200D 2640 +P:1F6B4 1F3FB 200D 2640 FE0F +P:1F6B4 1F3FB 200D 2640 +P:1F6B4 1F3FC 200D 2640 FE0F +P:1F6B4 1F3FC 200D 2640 +P:1F6B4 1F3FD 200D 2640 FE0F +P:1F6B4 1F3FD 200D 2640 +P:1F6B4 1F3FE 200D 2640 FE0F +P:1F6B4 1F3FE 200D 2640 +P:1F6B4 1F3FF 200D 2640 FE0F +P:1F6B4 1F3FF 200D 2640 +P:1F6B5 +P:1F6B5 1F3FB +P:1F6B5 1F3FC +P:1F6B5 1F3FD +P:1F6B5 1F3FE +P:1F6B5 1F3FF +P:1F6B5 200D 2642 FE0F +P:1F6B5 200D 2642 +P:1F6B5 1F3FB 200D 2642 FE0F +P:1F6B5 1F3FB 200D 2642 +P:1F6B5 1F3FC 200D 2642 FE0F +P:1F6B5 1F3FC 200D 2642 +P:1F6B5 1F3FD 200D 2642 FE0F +P:1F6B5 1F3FD 200D 2642 +P:1F6B5 1F3FE 200D 2642 FE0F +P:1F6B5 1F3FE 200D 2642 +P:1F6B5 1F3FF 200D 2642 FE0F +P:1F6B5 1F3FF 200D 2642 +P:1F6B5 200D 2640 FE0F +P:1F6B5 200D 2640 +P:1F6B5 1F3FB 200D 2640 FE0F +P:1F6B5 1F3FB 200D 2640 +P:1F6B5 1F3FC 200D 2640 FE0F +P:1F6B5 1F3FC 200D 2640 +P:1F6B5 1F3FD 200D 2640 FE0F +P:1F6B5 1F3FD 200D 2640 +P:1F6B5 1F3FE 200D 2640 FE0F +P:1F6B5 1F3FE 200D 2640 +P:1F6B5 1F3FF 200D 2640 FE0F +P:1F6B5 1F3FF 200D 2640 +P:1F938 +P:1F938 1F3FB +P:1F938 1F3FC +P:1F938 1F3FD +P:1F938 1F3FE +P:1F938 1F3FF +P:1F938 200D 2642 FE0F +P:1F938 200D 2642 +P:1F938 1F3FB 200D 2642 FE0F +P:1F938 1F3FB 200D 2642 +P:1F938 1F3FC 200D 2642 FE0F +P:1F938 1F3FC 200D 2642 +P:1F938 1F3FD 200D 2642 FE0F +P:1F938 1F3FD 200D 2642 +P:1F938 1F3FE 200D 2642 FE0F +P:1F938 1F3FE 200D 2642 +P:1F938 1F3FF 200D 2642 FE0F +P:1F938 1F3FF 200D 2642 +P:1F938 200D 2640 FE0F +P:1F938 200D 2640 +P:1F938 1F3FB 200D 2640 FE0F +P:1F938 1F3FB 200D 2640 +P:1F938 1F3FC 200D 2640 FE0F +P:1F938 1F3FC 200D 2640 +P:1F938 1F3FD 200D 2640 FE0F +P:1F938 1F3FD 200D 2640 +P:1F938 1F3FE 200D 2640 FE0F +P:1F938 1F3FE 200D 2640 +P:1F938 1F3FF 200D 2640 FE0F +P:1F938 1F3FF 200D 2640 +P:1F93C +P:1F93C 1F3FB +P:1F93C 1F3FC +P:1F93C 1F3FD +P:1F93C 1F3FE +P:1F93C 1F3FF +P:1F93C 200D 2642 FE0F +P:1F93C 200D 2642 +P:1F93C 1F3FB 200D 2642 FE0F +P:1F93C 1F3FB 200D 2642 +P:1F93C 1F3FC 200D 2642 FE0F +P:1F93C 1F3FC 200D 2642 +P:1F93C 1F3FD 200D 2642 FE0F +P:1F93C 1F3FD 200D 2642 +P:1F93C 1F3FE 200D 2642 FE0F +P:1F93C 1F3FE 200D 2642 +P:1F93C 1F3FF 200D 2642 FE0F +P:1F93C 1F3FF 200D 2642 +P:1F93C 200D 2640 FE0F +P:1F93C 200D 2640 +P:1F93C 1F3FB 200D 2640 FE0F +P:1F93C 1F3FB 200D 2640 +P:1F93C 1F3FC 200D 2640 FE0F +P:1F93C 1F3FC 200D 2640 +P:1F93C 1F3FD 200D 2640 FE0F +P:1F93C 1F3FD 200D 2640 +P:1F93C 1F3FE 200D 2640 FE0F +P:1F93C 1F3FE 200D 2640 +P:1F93C 1F3FF 200D 2640 FE0F +P:1F93C 1F3FF 200D 2640 +P:1F9D1 1F3FB 200D 1FAEF 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 1FAEF 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 1FAEF 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 1FAEF 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 1FAEF 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 1FAEF 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 1FAEF 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 1FAEF 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 1FAEF 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 1FAEF 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 1FAEF 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 1FAEF 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 1FAEF 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 1FAEF 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 1FAEF 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 1FAEF 200D 1F9D1 1F3FF +P:1F9D1 1F3FF 200D 1FAEF 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 1FAEF 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 1FAEF 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 1FAEF 200D 1F9D1 1F3FE +P:1F468 1F3FB 200D 1FAEF 200D 1F468 1F3FC +P:1F468 1F3FB 200D 1FAEF 200D 1F468 1F3FD +P:1F468 1F3FB 200D 1FAEF 200D 1F468 1F3FE +P:1F468 1F3FB 200D 1FAEF 200D 1F468 1F3FF +P:1F468 1F3FC 200D 1FAEF 200D 1F468 1F3FB +P:1F468 1F3FC 200D 1FAEF 200D 1F468 1F3FD +P:1F468 1F3FC 200D 1FAEF 200D 1F468 1F3FE +P:1F468 1F3FC 200D 1FAEF 200D 1F468 1F3FF +P:1F468 1F3FD 200D 1FAEF 200D 1F468 1F3FB +P:1F468 1F3FD 200D 1FAEF 200D 1F468 1F3FC +P:1F468 1F3FD 200D 1FAEF 200D 1F468 1F3FE +P:1F468 1F3FD 200D 1FAEF 200D 1F468 1F3FF +P:1F468 1F3FE 200D 1FAEF 200D 1F468 1F3FB +P:1F468 1F3FE 200D 1FAEF 200D 1F468 1F3FC +P:1F468 1F3FE 200D 1FAEF 200D 1F468 1F3FD +P:1F468 1F3FE 200D 1FAEF 200D 1F468 1F3FF +P:1F468 1F3FF 200D 1FAEF 200D 1F468 1F3FB +P:1F468 1F3FF 200D 1FAEF 200D 1F468 1F3FC +P:1F468 1F3FF 200D 1FAEF 200D 1F468 1F3FD +P:1F468 1F3FF 200D 1FAEF 200D 1F468 1F3FE +P:1F469 1F3FB 200D 1FAEF 200D 1F469 1F3FC +P:1F469 1F3FB 200D 1FAEF 200D 1F469 1F3FD +P:1F469 1F3FB 200D 1FAEF 200D 1F469 1F3FE +P:1F469 1F3FB 200D 1FAEF 200D 1F469 1F3FF +P:1F469 1F3FC 200D 1FAEF 200D 1F469 1F3FB +P:1F469 1F3FC 200D 1FAEF 200D 1F469 1F3FD +P:1F469 1F3FC 200D 1FAEF 200D 1F469 1F3FE +P:1F469 1F3FC 200D 1FAEF 200D 1F469 1F3FF +P:1F469 1F3FD 200D 1FAEF 200D 1F469 1F3FB +P:1F469 1F3FD 200D 1FAEF 200D 1F469 1F3FC +P:1F469 1F3FD 200D 1FAEF 200D 1F469 1F3FE +P:1F469 1F3FD 200D 1FAEF 200D 1F469 1F3FF +P:1F469 1F3FE 200D 1FAEF 200D 1F469 1F3FB +P:1F469 1F3FE 200D 1FAEF 200D 1F469 1F3FC +P:1F469 1F3FE 200D 1FAEF 200D 1F469 1F3FD +P:1F469 1F3FE 200D 1FAEF 200D 1F469 1F3FF +P:1F469 1F3FF 200D 1FAEF 200D 1F469 1F3FB +P:1F469 1F3FF 200D 1FAEF 200D 1F469 1F3FC +P:1F469 1F3FF 200D 1FAEF 200D 1F469 1F3FD +P:1F469 1F3FF 200D 1FAEF 200D 1F469 1F3FE +P:1F93D +P:1F93D 1F3FB +P:1F93D 1F3FC +P:1F93D 1F3FD +P:1F93D 1F3FE +P:1F93D 1F3FF +P:1F93D 200D 2642 FE0F +P:1F93D 200D 2642 +P:1F93D 1F3FB 200D 2642 FE0F +P:1F93D 1F3FB 200D 2642 +P:1F93D 1F3FC 200D 2642 FE0F +P:1F93D 1F3FC 200D 2642 +P:1F93D 1F3FD 200D 2642 FE0F +P:1F93D 1F3FD 200D 2642 +P:1F93D 1F3FE 200D 2642 FE0F +P:1F93D 1F3FE 200D 2642 +P:1F93D 1F3FF 200D 2642 FE0F +P:1F93D 1F3FF 200D 2642 +P:1F93D 200D 2640 FE0F +P:1F93D 200D 2640 +P:1F93D 1F3FB 200D 2640 FE0F +P:1F93D 1F3FB 200D 2640 +P:1F93D 1F3FC 200D 2640 FE0F +P:1F93D 1F3FC 200D 2640 +P:1F93D 1F3FD 200D 2640 FE0F +P:1F93D 1F3FD 200D 2640 +P:1F93D 1F3FE 200D 2640 FE0F +P:1F93D 1F3FE 200D 2640 +P:1F93D 1F3FF 200D 2640 FE0F +P:1F93D 1F3FF 200D 2640 +P:1F93E +P:1F93E 1F3FB +P:1F93E 1F3FC +P:1F93E 1F3FD +P:1F93E 1F3FE +P:1F93E 1F3FF +P:1F93E 200D 2642 FE0F +P:1F93E 200D 2642 +P:1F93E 1F3FB 200D 2642 FE0F +P:1F93E 1F3FB 200D 2642 +P:1F93E 1F3FC 200D 2642 FE0F +P:1F93E 1F3FC 200D 2642 +P:1F93E 1F3FD 200D 2642 FE0F +P:1F93E 1F3FD 200D 2642 +P:1F93E 1F3FE 200D 2642 FE0F +P:1F93E 1F3FE 200D 2642 +P:1F93E 1F3FF 200D 2642 FE0F +P:1F93E 1F3FF 200D 2642 +P:1F93E 200D 2640 FE0F +P:1F93E 200D 2640 +P:1F93E 1F3FB 200D 2640 FE0F +P:1F93E 1F3FB 200D 2640 +P:1F93E 1F3FC 200D 2640 FE0F +P:1F93E 1F3FC 200D 2640 +P:1F93E 1F3FD 200D 2640 FE0F +P:1F93E 1F3FD 200D 2640 +P:1F93E 1F3FE 200D 2640 FE0F +P:1F93E 1F3FE 200D 2640 +P:1F93E 1F3FF 200D 2640 FE0F +P:1F93E 1F3FF 200D 2640 +P:1F939 +P:1F939 1F3FB +P:1F939 1F3FC +P:1F939 1F3FD +P:1F939 1F3FE +P:1F939 1F3FF +P:1F939 200D 2642 FE0F +P:1F939 200D 2642 +P:1F939 1F3FB 200D 2642 FE0F +P:1F939 1F3FB 200D 2642 +P:1F939 1F3FC 200D 2642 FE0F +P:1F939 1F3FC 200D 2642 +P:1F939 1F3FD 200D 2642 FE0F +P:1F939 1F3FD 200D 2642 +P:1F939 1F3FE 200D 2642 FE0F +P:1F939 1F3FE 200D 2642 +P:1F939 1F3FF 200D 2642 FE0F +P:1F939 1F3FF 200D 2642 +P:1F939 200D 2640 FE0F +P:1F939 200D 2640 +P:1F939 1F3FB 200D 2640 FE0F +P:1F939 1F3FB 200D 2640 +P:1F939 1F3FC 200D 2640 FE0F +P:1F939 1F3FC 200D 2640 +P:1F939 1F3FD 200D 2640 FE0F +P:1F939 1F3FD 200D 2640 +P:1F939 1F3FE 200D 2640 FE0F +P:1F939 1F3FE 200D 2640 +P:1F939 1F3FF 200D 2640 FE0F +P:1F939 1F3FF 200D 2640 +P:1F9D8 +P:1F9D8 1F3FB +P:1F9D8 1F3FC +P:1F9D8 1F3FD +P:1F9D8 1F3FE +P:1F9D8 1F3FF +P:1F9D8 200D 2642 FE0F +P:1F9D8 200D 2642 +P:1F9D8 1F3FB 200D 2642 FE0F +P:1F9D8 1F3FB 200D 2642 +P:1F9D8 1F3FC 200D 2642 FE0F +P:1F9D8 1F3FC 200D 2642 +P:1F9D8 1F3FD 200D 2642 FE0F +P:1F9D8 1F3FD 200D 2642 +P:1F9D8 1F3FE 200D 2642 FE0F +P:1F9D8 1F3FE 200D 2642 +P:1F9D8 1F3FF 200D 2642 FE0F +P:1F9D8 1F3FF 200D 2642 +P:1F9D8 200D 2640 FE0F +P:1F9D8 200D 2640 +P:1F9D8 1F3FB 200D 2640 FE0F +P:1F9D8 1F3FB 200D 2640 +P:1F9D8 1F3FC 200D 2640 FE0F +P:1F9D8 1F3FC 200D 2640 +P:1F9D8 1F3FD 200D 2640 FE0F +P:1F9D8 1F3FD 200D 2640 +P:1F9D8 1F3FE 200D 2640 FE0F +P:1F9D8 1F3FE 200D 2640 +P:1F9D8 1F3FF 200D 2640 FE0F +P:1F9D8 1F3FF 200D 2640 +P:1F6C0 +P:1F6C0 1F3FB +P:1F6C0 1F3FC +P:1F6C0 1F3FD +P:1F6C0 1F3FE +P:1F6C0 1F3FF +P:1F6CC +P:1F6CC 1F3FB +P:1F6CC 1F3FC +P:1F6CC 1F3FD +P:1F6CC 1F3FE +P:1F6CC 1F3FF +P:1F9D1 200D 1F91D 200D 1F9D1 +P:1F9D1 1F3FB 200D 1F91D 200D 1F9D1 1F3FB +P:1F9D1 1F3FB 200D 1F91D 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 1F91D 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 1F91D 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 1F91D 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 1F91D 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 1F91D 200D 1F9D1 1F3FC +P:1F9D1 1F3FC 200D 1F91D 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 1F91D 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 1F91D 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 1F91D 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 1F91D 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 1F91D 200D 1F9D1 1F3FD +P:1F9D1 1F3FD 200D 1F91D 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 1F91D 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 1F91D 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 1F91D 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 1F91D 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 1F91D 200D 1F9D1 1F3FE +P:1F9D1 1F3FE 200D 1F91D 200D 1F9D1 1F3FF +P:1F9D1 1F3FF 200D 1F91D 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 1F91D 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 1F91D 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 1F91D 200D 1F9D1 1F3FE +P:1F9D1 1F3FF 200D 1F91D 200D 1F9D1 1F3FF +P:1F46D +P:1F46D 1F3FB +P:1F469 1F3FB 200D 1F91D 200D 1F469 1F3FC +P:1F469 1F3FB 200D 1F91D 200D 1F469 1F3FD +P:1F469 1F3FB 200D 1F91D 200D 1F469 1F3FE +P:1F469 1F3FB 200D 1F91D 200D 1F469 1F3FF +P:1F469 1F3FC 200D 1F91D 200D 1F469 1F3FB +P:1F46D 1F3FC +P:1F469 1F3FC 200D 1F91D 200D 1F469 1F3FD +P:1F469 1F3FC 200D 1F91D 200D 1F469 1F3FE +P:1F469 1F3FC 200D 1F91D 200D 1F469 1F3FF +P:1F469 1F3FD 200D 1F91D 200D 1F469 1F3FB +P:1F469 1F3FD 200D 1F91D 200D 1F469 1F3FC +P:1F46D 1F3FD +P:1F469 1F3FD 200D 1F91D 200D 1F469 1F3FE +P:1F469 1F3FD 200D 1F91D 200D 1F469 1F3FF +P:1F469 1F3FE 200D 1F91D 200D 1F469 1F3FB +P:1F469 1F3FE 200D 1F91D 200D 1F469 1F3FC +P:1F469 1F3FE 200D 1F91D 200D 1F469 1F3FD +P:1F46D 1F3FE +P:1F469 1F3FE 200D 1F91D 200D 1F469 1F3FF +P:1F469 1F3FF 200D 1F91D 200D 1F469 1F3FB +P:1F469 1F3FF 200D 1F91D 200D 1F469 1F3FC +P:1F469 1F3FF 200D 1F91D 200D 1F469 1F3FD +P:1F469 1F3FF 200D 1F91D 200D 1F469 1F3FE +P:1F46D 1F3FF +P:1F46B +P:1F46B 1F3FB +P:1F469 1F3FB 200D 1F91D 200D 1F468 1F3FC +P:1F469 1F3FB 200D 1F91D 200D 1F468 1F3FD +P:1F469 1F3FB 200D 1F91D 200D 1F468 1F3FE +P:1F469 1F3FB 200D 1F91D 200D 1F468 1F3FF +P:1F469 1F3FC 200D 1F91D 200D 1F468 1F3FB +P:1F46B 1F3FC +P:1F469 1F3FC 200D 1F91D 200D 1F468 1F3FD +P:1F469 1F3FC 200D 1F91D 200D 1F468 1F3FE +P:1F469 1F3FC 200D 1F91D 200D 1F468 1F3FF +P:1F469 1F3FD 200D 1F91D 200D 1F468 1F3FB +P:1F469 1F3FD 200D 1F91D 200D 1F468 1F3FC +P:1F46B 1F3FD +P:1F469 1F3FD 200D 1F91D 200D 1F468 1F3FE +P:1F469 1F3FD 200D 1F91D 200D 1F468 1F3FF +P:1F469 1F3FE 200D 1F91D 200D 1F468 1F3FB +P:1F469 1F3FE 200D 1F91D 200D 1F468 1F3FC +P:1F469 1F3FE 200D 1F91D 200D 1F468 1F3FD +P:1F46B 1F3FE +P:1F469 1F3FE 200D 1F91D 200D 1F468 1F3FF +P:1F469 1F3FF 200D 1F91D 200D 1F468 1F3FB +P:1F469 1F3FF 200D 1F91D 200D 1F468 1F3FC +P:1F469 1F3FF 200D 1F91D 200D 1F468 1F3FD +P:1F469 1F3FF 200D 1F91D 200D 1F468 1F3FE +P:1F46B 1F3FF +P:1F46C +P:1F46C 1F3FB +P:1F468 1F3FB 200D 1F91D 200D 1F468 1F3FC +P:1F468 1F3FB 200D 1F91D 200D 1F468 1F3FD +P:1F468 1F3FB 200D 1F91D 200D 1F468 1F3FE +P:1F468 1F3FB 200D 1F91D 200D 1F468 1F3FF +P:1F468 1F3FC 200D 1F91D 200D 1F468 1F3FB +P:1F46C 1F3FC +P:1F468 1F3FC 200D 1F91D 200D 1F468 1F3FD +P:1F468 1F3FC 200D 1F91D 200D 1F468 1F3FE +P:1F468 1F3FC 200D 1F91D 200D 1F468 1F3FF +P:1F468 1F3FD 200D 1F91D 200D 1F468 1F3FB +P:1F468 1F3FD 200D 1F91D 200D 1F468 1F3FC +P:1F46C 1F3FD +P:1F468 1F3FD 200D 1F91D 200D 1F468 1F3FE +P:1F468 1F3FD 200D 1F91D 200D 1F468 1F3FF +P:1F468 1F3FE 200D 1F91D 200D 1F468 1F3FB +P:1F468 1F3FE 200D 1F91D 200D 1F468 1F3FC +P:1F468 1F3FE 200D 1F91D 200D 1F468 1F3FD +P:1F46C 1F3FE +P:1F468 1F3FE 200D 1F91D 200D 1F468 1F3FF +P:1F468 1F3FF 200D 1F91D 200D 1F468 1F3FB +P:1F468 1F3FF 200D 1F91D 200D 1F468 1F3FC +P:1F468 1F3FF 200D 1F91D 200D 1F468 1F3FD +P:1F468 1F3FF 200D 1F91D 200D 1F468 1F3FE +P:1F46C 1F3FF +P:1F48F +P:1F48F 1F3FB +P:1F48F 1F3FC +P:1F48F 1F3FD +P:1F48F 1F3FE +P:1F48F 1F3FF +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 2764 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 2764 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 2764 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FB 200D 2764 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 2764 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 2764 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 2764 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 2764 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 2764 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 2764 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 2764 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 2764 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 2764 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 2764 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 2764 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 2764 200D 1F48B 200D 1F9D1 1F3FF +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 2764 200D 1F48B 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 2764 200D 1F48B 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 2764 200D 1F48B 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F9D1 1F3FE +P:1F9D1 1F3FF 200D 2764 200D 1F48B 200D 1F9D1 1F3FE +P:1F469 200D 2764 FE0F 200D 1F48B 200D 1F468 +P:1F469 200D 2764 200D 1F48B 200D 1F468 +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F468 200D 2764 FE0F 200D 1F48B 200D 1F468 +P:1F468 200D 2764 200D 1F48B 200D 1F468 +P:1F468 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FB 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FC 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FD 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FE 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FB +P:1F468 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FC +P:1F468 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FD +P:1F468 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FE +P:1F468 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F468 1F3FF +P:1F468 1F3FF 200D 2764 200D 1F48B 200D 1F468 1F3FF +P:1F469 200D 2764 FE0F 200D 1F48B 200D 1F469 +P:1F469 200D 2764 200D 1F48B 200D 1F469 +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FB 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FB 200D 2764 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FC 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FC 200D 2764 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FD 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FD 200D 2764 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FE 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FE 200D 2764 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F469 1F3FB +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F469 1F3FC +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F469 1F3FD +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F469 1F3FE +P:1F469 1F3FF 200D 2764 FE0F 200D 1F48B 200D 1F469 1F3FF +P:1F469 1F3FF 200D 2764 200D 1F48B 200D 1F469 1F3FF +P:1F491 +P:1F491 1F3FB +P:1F491 1F3FC +P:1F491 1F3FD +P:1F491 1F3FE +P:1F491 1F3FF +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 2764 200D 1F9D1 1F3FC +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 2764 200D 1F9D1 1F3FD +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 2764 200D 1F9D1 1F3FE +P:1F9D1 1F3FB 200D 2764 FE0F 200D 1F9D1 1F3FF +P:1F9D1 1F3FB 200D 2764 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 2764 200D 1F9D1 1F3FB +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 2764 200D 1F9D1 1F3FD +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 2764 200D 1F9D1 1F3FE +P:1F9D1 1F3FC 200D 2764 FE0F 200D 1F9D1 1F3FF +P:1F9D1 1F3FC 200D 2764 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 2764 200D 1F9D1 1F3FB +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 2764 200D 1F9D1 1F3FC +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 2764 200D 1F9D1 1F3FE +P:1F9D1 1F3FD 200D 2764 FE0F 200D 1F9D1 1F3FF +P:1F9D1 1F3FD 200D 2764 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 2764 200D 1F9D1 1F3FB +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 2764 200D 1F9D1 1F3FC +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 2764 200D 1F9D1 1F3FD +P:1F9D1 1F3FE 200D 2764 FE0F 200D 1F9D1 1F3FF +P:1F9D1 1F3FE 200D 2764 200D 1F9D1 1F3FF +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 2764 200D 1F9D1 1F3FB +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 2764 200D 1F9D1 1F3FC +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 2764 200D 1F9D1 1F3FD +P:1F9D1 1F3FF 200D 2764 FE0F 200D 1F9D1 1F3FE +P:1F9D1 1F3FF 200D 2764 200D 1F9D1 1F3FE +P:1F469 200D 2764 FE0F 200D 1F468 +P:1F469 200D 2764 200D 1F468 +P:1F469 1F3FB 200D 2764 FE0F 200D 1F468 1F3FB +P:1F469 1F3FB 200D 2764 200D 1F468 1F3FB +P:1F469 1F3FB 200D 2764 FE0F 200D 1F468 1F3FC +P:1F469 1F3FB 200D 2764 200D 1F468 1F3FC +P:1F469 1F3FB 200D 2764 FE0F 200D 1F468 1F3FD +P:1F469 1F3FB 200D 2764 200D 1F468 1F3FD +P:1F469 1F3FB 200D 2764 FE0F 200D 1F468 1F3FE +P:1F469 1F3FB 200D 2764 200D 1F468 1F3FE +P:1F469 1F3FB 200D 2764 FE0F 200D 1F468 1F3FF +P:1F469 1F3FB 200D 2764 200D 1F468 1F3FF +P:1F469 1F3FC 200D 2764 FE0F 200D 1F468 1F3FB +P:1F469 1F3FC 200D 2764 200D 1F468 1F3FB +P:1F469 1F3FC 200D 2764 FE0F 200D 1F468 1F3FC +P:1F469 1F3FC 200D 2764 200D 1F468 1F3FC +P:1F469 1F3FC 200D 2764 FE0F 200D 1F468 1F3FD +P:1F469 1F3FC 200D 2764 200D 1F468 1F3FD +P:1F469 1F3FC 200D 2764 FE0F 200D 1F468 1F3FE +P:1F469 1F3FC 200D 2764 200D 1F468 1F3FE +P:1F469 1F3FC 200D 2764 FE0F 200D 1F468 1F3FF +P:1F469 1F3FC 200D 2764 200D 1F468 1F3FF +P:1F469 1F3FD 200D 2764 FE0F 200D 1F468 1F3FB +P:1F469 1F3FD 200D 2764 200D 1F468 1F3FB +P:1F469 1F3FD 200D 2764 FE0F 200D 1F468 1F3FC +P:1F469 1F3FD 200D 2764 200D 1F468 1F3FC +P:1F469 1F3FD 200D 2764 FE0F 200D 1F468 1F3FD +P:1F469 1F3FD 200D 2764 200D 1F468 1F3FD +P:1F469 1F3FD 200D 2764 FE0F 200D 1F468 1F3FE +P:1F469 1F3FD 200D 2764 200D 1F468 1F3FE +P:1F469 1F3FD 200D 2764 FE0F 200D 1F468 1F3FF +P:1F469 1F3FD 200D 2764 200D 1F468 1F3FF +P:1F469 1F3FE 200D 2764 FE0F 200D 1F468 1F3FB +P:1F469 1F3FE 200D 2764 200D 1F468 1F3FB +P:1F469 1F3FE 200D 2764 FE0F 200D 1F468 1F3FC +P:1F469 1F3FE 200D 2764 200D 1F468 1F3FC +P:1F469 1F3FE 200D 2764 FE0F 200D 1F468 1F3FD +P:1F469 1F3FE 200D 2764 200D 1F468 1F3FD +P:1F469 1F3FE 200D 2764 FE0F 200D 1F468 1F3FE +P:1F469 1F3FE 200D 2764 200D 1F468 1F3FE +P:1F469 1F3FE 200D 2764 FE0F 200D 1F468 1F3FF +P:1F469 1F3FE 200D 2764 200D 1F468 1F3FF +P:1F469 1F3FF 200D 2764 FE0F 200D 1F468 1F3FB +P:1F469 1F3FF 200D 2764 200D 1F468 1F3FB +P:1F469 1F3FF 200D 2764 FE0F 200D 1F468 1F3FC +P:1F469 1F3FF 200D 2764 200D 1F468 1F3FC +P:1F469 1F3FF 200D 2764 FE0F 200D 1F468 1F3FD +P:1F469 1F3FF 200D 2764 200D 1F468 1F3FD +P:1F469 1F3FF 200D 2764 FE0F 200D 1F468 1F3FE +P:1F469 1F3FF 200D 2764 200D 1F468 1F3FE +P:1F469 1F3FF 200D 2764 FE0F 200D 1F468 1F3FF +P:1F469 1F3FF 200D 2764 200D 1F468 1F3FF +P:1F468 200D 2764 FE0F 200D 1F468 +P:1F468 200D 2764 200D 1F468 +P:1F468 1F3FB 200D 2764 FE0F 200D 1F468 1F3FB +P:1F468 1F3FB 200D 2764 200D 1F468 1F3FB +P:1F468 1F3FB 200D 2764 FE0F 200D 1F468 1F3FC +P:1F468 1F3FB 200D 2764 200D 1F468 1F3FC +P:1F468 1F3FB 200D 2764 FE0F 200D 1F468 1F3FD +P:1F468 1F3FB 200D 2764 200D 1F468 1F3FD +P:1F468 1F3FB 200D 2764 FE0F 200D 1F468 1F3FE +P:1F468 1F3FB 200D 2764 200D 1F468 1F3FE +P:1F468 1F3FB 200D 2764 FE0F 200D 1F468 1F3FF +P:1F468 1F3FB 200D 2764 200D 1F468 1F3FF +P:1F468 1F3FC 200D 2764 FE0F 200D 1F468 1F3FB +P:1F468 1F3FC 200D 2764 200D 1F468 1F3FB +P:1F468 1F3FC 200D 2764 FE0F 200D 1F468 1F3FC +P:1F468 1F3FC 200D 2764 200D 1F468 1F3FC +P:1F468 1F3FC 200D 2764 FE0F 200D 1F468 1F3FD +P:1F468 1F3FC 200D 2764 200D 1F468 1F3FD +P:1F468 1F3FC 200D 2764 FE0F 200D 1F468 1F3FE +P:1F468 1F3FC 200D 2764 200D 1F468 1F3FE +P:1F468 1F3FC 200D 2764 FE0F 200D 1F468 1F3FF +P:1F468 1F3FC 200D 2764 200D 1F468 1F3FF +P:1F468 1F3FD 200D 2764 FE0F 200D 1F468 1F3FB +P:1F468 1F3FD 200D 2764 200D 1F468 1F3FB +P:1F468 1F3FD 200D 2764 FE0F 200D 1F468 1F3FC +P:1F468 1F3FD 200D 2764 200D 1F468 1F3FC +P:1F468 1F3FD 200D 2764 FE0F 200D 1F468 1F3FD +P:1F468 1F3FD 200D 2764 200D 1F468 1F3FD +P:1F468 1F3FD 200D 2764 FE0F 200D 1F468 1F3FE +P:1F468 1F3FD 200D 2764 200D 1F468 1F3FE +P:1F468 1F3FD 200D 2764 FE0F 200D 1F468 1F3FF +P:1F468 1F3FD 200D 2764 200D 1F468 1F3FF +P:1F468 1F3FE 200D 2764 FE0F 200D 1F468 1F3FB +P:1F468 1F3FE 200D 2764 200D 1F468 1F3FB +P:1F468 1F3FE 200D 2764 FE0F 200D 1F468 1F3FC +P:1F468 1F3FE 200D 2764 200D 1F468 1F3FC +P:1F468 1F3FE 200D 2764 FE0F 200D 1F468 1F3FD +P:1F468 1F3FE 200D 2764 200D 1F468 1F3FD +P:1F468 1F3FE 200D 2764 FE0F 200D 1F468 1F3FE +P:1F468 1F3FE 200D 2764 200D 1F468 1F3FE +P:1F468 1F3FE 200D 2764 FE0F 200D 1F468 1F3FF +P:1F468 1F3FE 200D 2764 200D 1F468 1F3FF +P:1F468 1F3FF 200D 2764 FE0F 200D 1F468 1F3FB +P:1F468 1F3FF 200D 2764 200D 1F468 1F3FB +P:1F468 1F3FF 200D 2764 FE0F 200D 1F468 1F3FC +P:1F468 1F3FF 200D 2764 200D 1F468 1F3FC +P:1F468 1F3FF 200D 2764 FE0F 200D 1F468 1F3FD +P:1F468 1F3FF 200D 2764 200D 1F468 1F3FD +P:1F468 1F3FF 200D 2764 FE0F 200D 1F468 1F3FE +P:1F468 1F3FF 200D 2764 200D 1F468 1F3FE +P:1F468 1F3FF 200D 2764 FE0F 200D 1F468 1F3FF +P:1F468 1F3FF 200D 2764 200D 1F468 1F3FF +P:1F469 200D 2764 FE0F 200D 1F469 +P:1F469 200D 2764 200D 1F469 +P:1F469 1F3FB 200D 2764 FE0F 200D 1F469 1F3FB +P:1F469 1F3FB 200D 2764 200D 1F469 1F3FB +P:1F469 1F3FB 200D 2764 FE0F 200D 1F469 1F3FC +P:1F469 1F3FB 200D 2764 200D 1F469 1F3FC +P:1F469 1F3FB 200D 2764 FE0F 200D 1F469 1F3FD +P:1F469 1F3FB 200D 2764 200D 1F469 1F3FD +P:1F469 1F3FB 200D 2764 FE0F 200D 1F469 1F3FE +P:1F469 1F3FB 200D 2764 200D 1F469 1F3FE +P:1F469 1F3FB 200D 2764 FE0F 200D 1F469 1F3FF +P:1F469 1F3FB 200D 2764 200D 1F469 1F3FF +P:1F469 1F3FC 200D 2764 FE0F 200D 1F469 1F3FB +P:1F469 1F3FC 200D 2764 200D 1F469 1F3FB +P:1F469 1F3FC 200D 2764 FE0F 200D 1F469 1F3FC +P:1F469 1F3FC 200D 2764 200D 1F469 1F3FC +P:1F469 1F3FC 200D 2764 FE0F 200D 1F469 1F3FD +P:1F469 1F3FC 200D 2764 200D 1F469 1F3FD +P:1F469 1F3FC 200D 2764 FE0F 200D 1F469 1F3FE +P:1F469 1F3FC 200D 2764 200D 1F469 1F3FE +P:1F469 1F3FC 200D 2764 FE0F 200D 1F469 1F3FF +P:1F469 1F3FC 200D 2764 200D 1F469 1F3FF +P:1F469 1F3FD 200D 2764 FE0F 200D 1F469 1F3FB +P:1F469 1F3FD 200D 2764 200D 1F469 1F3FB +P:1F469 1F3FD 200D 2764 FE0F 200D 1F469 1F3FC +P:1F469 1F3FD 200D 2764 200D 1F469 1F3FC +P:1F469 1F3FD 200D 2764 FE0F 200D 1F469 1F3FD +P:1F469 1F3FD 200D 2764 200D 1F469 1F3FD +P:1F469 1F3FD 200D 2764 FE0F 200D 1F469 1F3FE +P:1F469 1F3FD 200D 2764 200D 1F469 1F3FE +P:1F469 1F3FD 200D 2764 FE0F 200D 1F469 1F3FF +P:1F469 1F3FD 200D 2764 200D 1F469 1F3FF +P:1F469 1F3FE 200D 2764 FE0F 200D 1F469 1F3FB +P:1F469 1F3FE 200D 2764 200D 1F469 1F3FB +P:1F469 1F3FE 200D 2764 FE0F 200D 1F469 1F3FC +P:1F469 1F3FE 200D 2764 200D 1F469 1F3FC +P:1F469 1F3FE 200D 2764 FE0F 200D 1F469 1F3FD +P:1F469 1F3FE 200D 2764 200D 1F469 1F3FD +P:1F469 1F3FE 200D 2764 FE0F 200D 1F469 1F3FE +P:1F469 1F3FE 200D 2764 200D 1F469 1F3FE +P:1F469 1F3FE 200D 2764 FE0F 200D 1F469 1F3FF +P:1F469 1F3FE 200D 2764 200D 1F469 1F3FF +P:1F469 1F3FF 200D 2764 FE0F 200D 1F469 1F3FB +P:1F469 1F3FF 200D 2764 200D 1F469 1F3FB +P:1F469 1F3FF 200D 2764 FE0F 200D 1F469 1F3FC +P:1F469 1F3FF 200D 2764 200D 1F469 1F3FC +P:1F469 1F3FF 200D 2764 FE0F 200D 1F469 1F3FD +P:1F469 1F3FF 200D 2764 200D 1F469 1F3FD +P:1F469 1F3FF 200D 2764 FE0F 200D 1F469 1F3FE +P:1F469 1F3FF 200D 2764 200D 1F469 1F3FE +P:1F469 1F3FF 200D 2764 FE0F 200D 1F469 1F3FF +P:1F469 1F3FF 200D 2764 200D 1F469 1F3FF +P:1F468 200D 1F469 200D 1F466 +P:1F468 200D 1F469 200D 1F467 +P:1F468 200D 1F469 200D 1F467 200D 1F466 +P:1F468 200D 1F469 200D 1F466 200D 1F466 +P:1F468 200D 1F469 200D 1F467 200D 1F467 +P:1F468 200D 1F468 200D 1F466 +P:1F468 200D 1F468 200D 1F467 +P:1F468 200D 1F468 200D 1F467 200D 1F466 +P:1F468 200D 1F468 200D 1F466 200D 1F466 +P:1F468 200D 1F468 200D 1F467 200D 1F467 +P:1F469 200D 1F469 200D 1F466 +P:1F469 200D 1F469 200D 1F467 +P:1F469 200D 1F469 200D 1F467 200D 1F466 +P:1F469 200D 1F469 200D 1F466 200D 1F466 +P:1F469 200D 1F469 200D 1F467 200D 1F467 +P:1F468 200D 1F466 +P:1F468 200D 1F466 200D 1F466 +P:1F468 200D 1F467 +P:1F468 200D 1F467 200D 1F466 +P:1F468 200D 1F467 200D 1F467 +P:1F469 200D 1F466 +P:1F469 200D 1F466 200D 1F466 +P:1F469 200D 1F467 +P:1F469 200D 1F467 200D 1F466 +P:1F469 200D 1F467 200D 1F467 +P:1F5E3 FE0F +P:1F5E3 +P:1F464 +P:1F465 +P:1FAC2 +P:1F46A +P:1F9D1 200D 1F9D1 200D 1F9D2 +P:1F9D1 200D 1F9D1 200D 1F9D2 200D 1F9D2 +P:1F9D1 200D 1F9D2 +P:1F9D1 200D 1F9D2 200D 1F9D2 +P:1F463 +P:1FAC6 +N:1F435 +N:1F412 +N:1F98D +N:1F9A7 +N:1F436 +N:1F415 +N:1F9AE +N:1F415 200D 1F9BA +N:1F429 +N:1F43A +N:1F98A +N:1F99D +N:1F431 +N:1F408 +N:1F408 200D 2B1B +N:1F981 +N:1F42F +N:1F405 +N:1F406 +N:1F434 +N:1FACE +N:1FACF +N:1F40E +N:1F984 +N:1F993 +N:1F98C +N:1F9AC +N:1F42E +N:1F402 +N:1F403 +N:1F404 +N:1F437 +N:1F416 +N:1F417 +N:1F43D +N:1F40F +N:1F411 +N:1F410 +N:1F42A +N:1F42B +N:1F999 +N:1F992 +N:1F418 +N:1F9A3 +N:1F98F +N:1F99B +N:1F42D +N:1F401 +N:1F400 +N:1F439 +N:1F430 +N:1F407 +N:1F43F FE0F +N:1F43F +N:1F9AB +N:1F994 +N:1F987 +N:1F43B +N:1F43B 200D 2744 FE0F +N:1F43B 200D 2744 +N:1F428 +N:1F43C +N:1F9A5 +N:1F9A6 +N:1F9A8 +N:1F998 +N:1F9A1 +N:1F43E +N:1F983 +N:1F414 +N:1F413 +N:1F423 +N:1F424 +N:1F425 +N:1F426 +N:1F427 +N:1F54A FE0F +N:1F54A +N:1F985 +N:1F986 +N:1F9A2 +N:1F989 +N:1F9A4 +N:1FAB6 +N:1F9A9 +N:1F99A +N:1F99C +N:1FABD +N:1F426 200D 2B1B +N:1FABF +N:1F426 200D 1F525 +N:1F438 +N:1F40A +N:1F422 +N:1F98E +N:1F40D +N:1F432 +N:1F409 +N:1F995 +N:1F996 +N:1F433 +N:1F40B +N:1F42C +N:1FACD +N:1F9AD +N:1F41F +N:1F420 +N:1F421 +N:1F988 +N:1F419 +N:1F41A +N:1FAB8 +N:1FABC +N:1F980 +N:1F99E +N:1F990 +N:1F991 +N:1F9AA +N:1F40C +N:1F98B +N:1F41B +N:1F41C +N:1F41D +N:1FAB2 +N:1F41E +N:1F997 +N:1FAB3 +N:1F577 FE0F +N:1F577 +N:1F578 FE0F +N:1F578 +N:1F982 +N:1F99F +N:1FAB0 +N:1FAB1 +N:1F9A0 +N:1F490 +N:1F338 +N:1F4AE +N:1FAB7 +N:1F3F5 FE0F +N:1F3F5 +N:1F339 +N:1F940 +N:1F33A +N:1F33B +N:1F33C +N:1F337 +N:1FABB +N:1F331 +N:1FAB4 +N:1F332 +N:1F333 + """.trimIndent(), + """ +N:1F334 +N:1F335 +N:1F33E +N:1F33F +N:2618 FE0F +N:2618 +N:1F340 +N:1F341 +N:1F342 +N:1F343 +N:1FAB9 +N:1FABA +N:1F344 +N:1FABE +F:1F347 +F:1F348 +F:1F349 +F:1F34A +F:1F34B +F:1F34B 200D 1F7E9 +F:1F34C +F:1F34D +F:1F96D +F:1F34E +F:1F34F +F:1F350 +F:1F351 +F:1F352 +F:1F353 +F:1FAD0 +F:1F95D +F:1F345 +F:1FAD2 +F:1F965 +F:1F951 +F:1F346 +F:1F954 +F:1F955 +F:1F33D +F:1F336 FE0F +F:1F336 +F:1FAD1 +F:1F952 +F:1F96C +F:1F966 +F:1F9C4 +F:1F9C5 +F:1F95C +F:1FAD8 +F:1F330 +F:1FADA +F:1FADB +F:1F344 200D 1F7EB +F:1FADC +F:1F35E +F:1F950 +F:1F956 +F:1FAD3 +F:1F968 +F:1F96F +F:1F95E +F:1F9C7 +F:1F9C0 +F:1F356 +F:1F357 +F:1F969 +F:1F953 +F:1F354 +F:1F35F +F:1F355 +F:1F32D +F:1F96A +F:1F32E +F:1F32F +F:1FAD4 +F:1F959 +F:1F9C6 +F:1F95A +F:1F373 +F:1F958 +F:1F372 +F:1FAD5 +F:1F963 +F:1F957 +F:1F37F +F:1F9C8 +F:1F9C2 +F:1F96B +F:1F371 +F:1F358 +F:1F359 +F:1F35A +F:1F35B +F:1F35C +F:1F35D +F:1F360 +F:1F362 +F:1F363 +F:1F364 +F:1F365 +F:1F96E +F:1F361 +F:1F95F +F:1F960 +F:1F961 +F:1F366 +F:1F367 +F:1F368 +F:1F369 +F:1F36A +F:1F382 +F:1F370 +F:1F9C1 +F:1F967 +F:1F36B +F:1F36C +F:1F36D +F:1F36E +F:1F36F +F:1F37C +F:1F95B +F:2615 +F:1FAD6 +F:1F375 +F:1F376 +F:1F37E +F:1F377 +F:1F378 +F:1F379 +F:1F37A +F:1F37B +F:1F942 +F:1F943 +F:1FAD7 +F:1F964 +F:1F9CB +F:1F9C3 +F:1F9C9 +F:1F9CA +F:1F962 +F:1F37D FE0F +F:1F37D +F:1F374 +F:1F944 +F:1F52A +F:1FAD9 +F:1F3FA +T:1F30D +T:1F30E +T:1F30F +T:1F310 +T:1F5FA FE0F +T:1F5FA +T:1F5FE +T:1F9ED +T:1F3D4 FE0F +T:1F3D4 +T:26F0 FE0F +T:26F0 +T:1F6D8 +T:1F30B +T:1F5FB +T:1F3D5 FE0F +T:1F3D5 +T:1F3D6 FE0F +T:1F3D6 +T:1F3DC FE0F +T:1F3DC +T:1F3DD FE0F +T:1F3DD +T:1F3DE FE0F +T:1F3DE +T:1F3DF FE0F +T:1F3DF +T:1F3DB FE0F +T:1F3DB +T:1F3D7 FE0F +T:1F3D7 +T:1F9F1 +T:1FAA8 +T:1FAB5 +T:1F6D6 +T:1F3D8 FE0F +T:1F3D8 +T:1F3DA FE0F +T:1F3DA +T:1F3E0 +T:1F3E1 +T:1F3E2 +T:1F3E3 +T:1F3E4 +T:1F3E5 +T:1F3E6 +T:1F3E8 +T:1F3E9 +T:1F3EA +T:1F3EB +T:1F3EC +T:1F3ED +T:1F3EF +T:1F3F0 +T:1F492 +T:1F5FC +T:1F5FD +T:26EA +T:1F54C +T:1F6D5 +T:1F54D +T:26E9 FE0F +T:26E9 +T:1F54B +T:26F2 +T:26FA +T:1F301 +T:1F303 +T:1F3D9 FE0F +T:1F3D9 +T:1F304 +T:1F305 +T:1F306 +T:1F307 +T:1F309 +T:2668 FE0F +T:2668 +T:1F3A0 +T:1F6DD +T:1F3A1 +T:1F3A2 +T:1F488 +T:1F3AA +T:1F682 +T:1F683 +T:1F684 +T:1F685 +T:1F686 +T:1F687 +T:1F688 +T:1F689 +T:1F68A +T:1F69D +T:1F69E +T:1F68B +T:1F68C +T:1F68D +T:1F68E +T:1F690 +T:1F691 +T:1F692 +T:1F693 +T:1F694 +T:1F695 +T:1F696 +T:1F697 +T:1F698 +T:1F699 +T:1F6FB +T:1F69A +T:1F69B +T:1F69C +T:1F3CE FE0F +T:1F3CE +T:1F3CD FE0F +T:1F3CD +T:1F6F5 +T:1F9BD +T:1F9BC +T:1F6FA +T:1F6B2 +T:1F6F4 +T:1F6F9 +T:1F6FC +T:1F68F +T:1F6E3 FE0F +T:1F6E3 +T:1F6E4 FE0F +T:1F6E4 +T:1F6E2 FE0F +T:1F6E2 +T:26FD +T:1F6DE +T:1F6A8 +T:1F6A5 +T:1F6A6 +T:1F6D1 +T:1F6A7 +T:2693 +T:1F6DF +T:26F5 +T:1F6F6 +T:1F6A4 +T:1F6F3 FE0F +T:1F6F3 +T:26F4 FE0F +T:26F4 +T:1F6E5 FE0F +T:1F6E5 +T:1F6A2 +T:2708 FE0F +T:2708 +T:1F6E9 FE0F +T:1F6E9 +T:1F6EB +T:1F6EC +T:1FA82 +T:1F4BA +T:1F681 +T:1F69F +T:1F6A0 +T:1F6A1 +T:1F6F0 FE0F +T:1F6F0 +T:1F680 +T:1F6F8 +T:1F6CE FE0F +T:1F6CE +T:1F9F3 +T:231B +T:23F3 +T:231A +T:23F0 +T:23F1 FE0F +T:23F1 +T:23F2 FE0F +T:23F2 +T:1F570 FE0F +T:1F570 +T:1F55B +T:1F567 +T:1F550 +T:1F55C +T:1F551 +T:1F55D +T:1F552 +T:1F55E +T:1F553 +T:1F55F +T:1F554 +T:1F560 +T:1F555 +T:1F561 +T:1F556 +T:1F562 +T:1F557 +T:1F563 +T:1F558 +T:1F564 +T:1F559 +T:1F565 +T:1F55A +T:1F566 +T:1F311 +T:1F312 +T:1F313 +T:1F314 +T:1F315 +T:1F316 +T:1F317 +T:1F318 +T:1F319 +T:1F31A +T:1F31B +T:1F31C +T:1F321 FE0F +T:1F321 +T:2600 FE0F +T:2600 +T:1F31D +T:1F31E +T:1FA90 +T:2B50 +T:1F31F +T:1F320 +T:1F30C +T:2601 FE0F +T:2601 +T:26C5 +T:26C8 FE0F +T:26C8 +T:1F324 FE0F +T:1F324 +T:1F325 FE0F +T:1F325 +T:1F326 FE0F +T:1F326 +T:1F327 FE0F +T:1F327 +T:1F328 FE0F +T:1F328 +T:1F329 FE0F +T:1F329 +T:1F32A FE0F +T:1F32A +T:1F32B FE0F +T:1F32B +T:1F32C FE0F +T:1F32C +T:1F300 +T:1F308 +T:1F302 +T:2602 FE0F +T:2602 +T:2614 +T:26F1 FE0F +T:26F1 +T:26A1 +T:2744 FE0F +T:2744 +T:2603 FE0F +T:2603 +T:26C4 +T:2604 FE0F +T:2604 +T:1F525 +T:1F4A7 +T:1F30A +A:1F383 +A:1F384 +A:1F386 +A:1F387 +A:1F9E8 +A:2728 +A:1F388 +A:1F389 +A:1F38A +A:1F38B +A:1F38D +A:1F38E +A:1F38F +A:1F390 +A:1F391 +A:1F9E7 +A:1F380 +A:1F381 +A:1F397 FE0F +A:1F397 +A:1F39F FE0F +A:1F39F +A:1F3AB +A:1F396 FE0F +A:1F396 +A:1F3C6 +A:1F3C5 +A:1F947 +A:1F948 +A:1F949 +A:26BD +A:26BE +A:1F94E +A:1F3C0 +A:1F3D0 +A:1F3C8 +A:1F3C9 +A:1F3BE +A:1F94F +A:1F3B3 +A:1F3CF +A:1F3D1 +A:1F3D2 +A:1F94D +A:1F3D3 +A:1F3F8 +A:1F94A +A:1F94B +A:1F945 +A:26F3 +A:26F8 FE0F +A:26F8 +A:1F3A3 +A:1F93F +A:1F3BD +A:1F3BF +A:1F6F7 +A:1F94C +A:1F3AF +A:1FA80 +A:1FA81 +A:1F52B +A:1F3B1 +A:1F52E +A:1FA84 +A:1F3AE +A:1F579 FE0F +A:1F579 +A:1F3B0 +A:1F3B2 +A:1F9E9 +A:1F9F8 +A:1FA85 +A:1FAA9 +A:1FA86 +A:2660 FE0F +A:2660 +A:2665 FE0F +A:2665 +A:2666 FE0F +A:2666 +A:2663 FE0F +A:2663 +A:265F FE0F +A:265F +A:1F0CF +A:1F004 +A:1F3B4 +A:1F3AD +A:1F5BC FE0F +A:1F5BC +A:1F3A8 +A:1F9F5 +A:1FAA1 +A:1F9F6 +A:1FAA2 +O:1F453 +O:1F576 FE0F +O:1F576 +O:1F97D +O:1F97C +O:1F9BA +O:1F454 +O:1F455 +O:1F456 +O:1F9E3 +O:1F9E4 +O:1F9E5 +O:1F9E6 +O:1F457 +O:1F458 +O:1F97B +O:1FA71 +O:1FA72 +O:1FA73 +O:1F459 +O:1F45A +O:1FAAD +O:1F45B +O:1F45C +O:1F45D +O:1F6CD FE0F +O:1F6CD +O:1F392 +O:1FA74 +O:1F45E +O:1F45F +O:1F97E +O:1F97F +O:1F460 +O:1F461 +O:1FA70 +O:1F462 +O:1FAAE +O:1F451 +O:1F452 +O:1F3A9 +O:1F393 +O:1F9E2 +O:1FA96 +O:26D1 FE0F +O:26D1 +O:1F4FF +O:1F484 +O:1F48D +O:1F48E +O:1F507 +O:1F508 +O:1F509 +O:1F50A +O:1F4E2 +O:1F4E3 +O:1F4EF +O:1F514 +O:1F515 +O:1F3BC +O:1F3B5 +O:1F3B6 +O:1F399 FE0F +O:1F399 +O:1F39A FE0F +O:1F39A +O:1F39B FE0F +O:1F39B +O:1F3A4 +O:1F3A7 +O:1F4FB +O:1F3B7 +O:1F3BA +O:1FA8A +O:1FA97 +O:1F3B8 +O:1F3B9 +O:1F3BB +O:1FA95 +O:1F941 +O:1FA98 +O:1FA87 +O:1FA88 +O:1FA89 +O:1F4F1 +O:1F4F2 +O:260E FE0F +O:260E +O:1F4DE +O:1F4DF +O:1F4E0 +O:1F50B +O:1FAAB +O:1F50C +O:1F4BB +O:1F5A5 FE0F +O:1F5A5 +O:1F5A8 FE0F +O:1F5A8 +O:2328 FE0F +O:2328 +O:1F5B1 FE0F +O:1F5B1 +O:1F5B2 FE0F +O:1F5B2 +O:1F4BD +O:1F4BE +O:1F4BF +O:1F4C0 +O:1F9EE +O:1F3A5 +O:1F39E FE0F +O:1F39E +O:1F4FD FE0F +O:1F4FD +O:1F3AC +O:1F4FA +O:1F4F7 +O:1F4F8 +O:1F4F9 +O:1F4FC +O:1F50D +O:1F50E +O:1F56F FE0F +O:1F56F +O:1F4A1 +O:1F526 +O:1F3EE +O:1FA94 +O:1F4D4 +O:1F4D5 +O:1F4D6 +O:1F4D7 +O:1F4D8 +O:1F4D9 +O:1F4DA +O:1F4D3 +O:1F4D2 +O:1F4C3 +O:1F4DC +O:1F4C4 +O:1F4F0 +O:1F5DE FE0F +O:1F5DE +O:1F4D1 +O:1F516 +O:1F3F7 FE0F +O:1F3F7 +O:1FA99 +O:1F4B0 +O:1FA8E +O:1F4B4 +O:1F4B5 +O:1F4B6 +O:1F4B7 +O:1F4B8 +O:1F4B3 +O:1F9FE +O:1F4B9 +O:2709 FE0F +O:2709 +O:1F4E7 +O:1F4E8 +O:1F4E9 +O:1F4E4 +O:1F4E5 +O:1F4E6 +O:1F4EB +O:1F4EA +O:1F4EC +O:1F4ED +O:1F4EE +O:1F5F3 FE0F +O:1F5F3 +O:270F FE0F +O:270F +O:2712 FE0F +O:2712 +O:1F58B FE0F +O:1F58B +O:1F58A FE0F +O:1F58A +O:1F58C FE0F +O:1F58C +O:1F58D FE0F +O:1F58D +O:1F4DD +O:1F4BC +O:1F4C1 +O:1F4C2 +O:1F5C2 FE0F +O:1F5C2 +O:1F4C5 +O:1F4C6 +O:1F5D2 FE0F +O:1F5D2 +O:1F5D3 FE0F +O:1F5D3 +O:1F4C7 +O:1F4C8 +O:1F4C9 +O:1F4CA +O:1F4CB +O:1F4CC +O:1F4CD +O:1F4CE +O:1F587 FE0F +O:1F587 +O:1F4CF +O:1F4D0 +O:2702 FE0F +O:2702 +O:1F5C3 FE0F +O:1F5C3 +O:1F5C4 FE0F +O:1F5C4 +O:1F5D1 FE0F +O:1F5D1 +O:1F512 +O:1F513 +O:1F50F +O:1F510 +O:1F511 +O:1F5DD FE0F +O:1F5DD +O:1F528 +O:1FA93 +O:26CF FE0F +O:26CF +O:2692 FE0F +O:2692 +O:1F6E0 FE0F +O:1F6E0 +O:1F5E1 FE0F +O:1F5E1 +O:2694 FE0F +O:2694 +O:1F4A3 +O:1FA83 +O:1F3F9 +O:1F6E1 FE0F +O:1F6E1 +O:1FA9A +O:1F527 +O:1FA9B +O:1F529 +O:2699 FE0F +O:2699 +O:1F5DC FE0F +O:1F5DC +O:2696 FE0F +O:2696 +O:1F9AF +O:1F517 +O:26D3 FE0F 200D 1F4A5 +O:26D3 200D 1F4A5 +O:26D3 FE0F +O:26D3 +O:1FA9D +O:1F9F0 +O:1F9F2 +O:1FA9C +O:1FA8F +O:2697 FE0F +O:2697 +O:1F9EA +O:1F9EB +O:1F9EC +O:1F52C +O:1F52D +O:1F4E1 +O:1F489 +O:1FA78 +O:1F48A +O:1FA79 +O:1FA7C +O:1FA7A +O:1FA7B +O:1F6AA +O:1F6D7 +O:1FA9E +O:1FA9F +O:1F6CF FE0F +O:1F6CF +O:1F6CB FE0F +O:1F6CB +O:1FA91 +O:1F6BD +O:1FAA0 +O:1F6BF +O:1F6C1 +O:1FAA4 +O:1FA92 +O:1F9F4 +O:1F9F7 +O:1F9F9 +O:1F9FA +O:1F9FB +O:1FAA3 +O:1F9FC +O:1FAE7 +O:1FAA5 +O:1F9FD +O:1F9EF +O:1F6D2 +O:1F6AC +O:26B0 FE0F +O:26B0 +O:1FAA6 +O:26B1 FE0F +O:26B1 +O:1F9FF +O:1FAAC +O:1F5FF +O:1FAA7 +O:1FAAA +Y:1F3E7 +Y:1F6AE +Y:1F6B0 +Y:267F +Y:1F6B9 +Y:1F6BA +Y:1F6BB +Y:1F6BC +Y:1F6BE +Y:1F6C2 +Y:1F6C3 +Y:1F6C4 +Y:1F6C5 +Y:26A0 FE0F +Y:26A0 +Y:1F6B8 +Y:26D4 +Y:1F6AB +Y:1F6B3 +Y:1F6AD +Y:1F6AF +Y:1F6B1 +Y:1F6B7 +Y:1F4F5 +Y:1F51E +Y:2622 FE0F +Y:2622 +Y:2623 FE0F +Y:2623 +Y:2B06 FE0F +Y:2B06 +Y:2197 FE0F +Y:2197 +Y:27A1 FE0F +Y:27A1 +Y:2198 FE0F +Y:2198 +Y:2B07 FE0F +Y:2B07 +Y:2199 FE0F +Y:2199 +Y:2B05 FE0F +Y:2B05 +Y:2196 FE0F +Y:2196 +Y:2195 FE0F +Y:2195 +Y:2194 FE0F +Y:2194 +Y:21A9 FE0F +Y:21A9 +Y:21AA FE0F +Y:21AA +Y:2934 FE0F +Y:2934 +Y:2935 FE0F +Y:2935 +Y:1F503 +Y:1F504 +Y:1F519 +Y:1F51A +Y:1F51B +Y:1F51C +Y:1F51D +Y:1F6D0 +Y:269B FE0F +Y:269B +Y:1F549 FE0F +Y:1F549 +Y:2721 FE0F +Y:2721 +Y:2638 FE0F +Y:2638 +Y:262F FE0F +Y:262F +Y:271D FE0F +Y:271D +Y:2626 FE0F +Y:2626 +Y:262A FE0F +Y:262A +Y:262E FE0F +Y:262E +Y:1F54E +Y:1F52F +Y:1FAAF +Y:2648 +Y:2649 +Y:264A +Y:264B +Y:264C +Y:264D +Y:264E +Y:264F +Y:2650 +Y:2651 +Y:2652 +Y:2653 +Y:26CE +Y:1F500 +Y:1F501 +Y:1F502 +Y:25B6 FE0F +Y:25B6 +Y:23E9 +Y:23ED FE0F +Y:23ED +Y:23EF FE0F +Y:23EF +Y:25C0 FE0F +Y:25C0 +Y:23EA +Y:23EE FE0F +Y:23EE +Y:1F53C +Y:23EB +Y:1F53D +Y:23EC +Y:23F8 FE0F +Y:23F8 +Y:23F9 FE0F +Y:23F9 +Y:23FA FE0F +Y:23FA +Y:23CF FE0F +Y:23CF +Y:1F3A6 +Y:1F505 +Y:1F506 +Y:1F4F6 +Y:1F6DC +Y:1F4F3 +Y:1F4F4 +Y:2640 FE0F +Y:2640 +Y:2642 FE0F +Y:2642 +Y:26A7 FE0F +Y:26A7 +Y:2716 FE0F +Y:2716 +Y:2795 +Y:2796 +Y:2797 +Y:1F7F0 +Y:267E FE0F +Y:267E +Y:203C FE0F +Y:203C +Y:2049 FE0F +Y:2049 +Y:2753 +Y:2754 +Y:2755 +Y:2757 +Y:3030 FE0F +Y:3030 +Y:1F4B1 +Y:1F4B2 +Y:2695 FE0F +Y:2695 +Y:267B FE0F +Y:267B +Y:269C FE0F +Y:269C +Y:1F531 +Y:1F4DB +Y:1F530 +Y:2B55 +Y:2705 +Y:2611 FE0F +Y:2611 +Y:2714 FE0F +Y:2714 +Y:274C +Y:274E +Y:27B0 +Y:27BF +Y:303D FE0F +Y:303D +Y:2733 FE0F +Y:2733 +Y:2734 FE0F +Y:2734 +Y:2747 FE0F +Y:2747 +Y:00A9 FE0F +Y:00A9 +Y:00AE FE0F +Y:00AE +Y:2122 FE0F +Y:2122 +Y:1FADF +Y:0023 FE0F 20E3 +Y:0023 20E3 +Y:002A FE0F 20E3 +Y:002A 20E3 +Y:0030 FE0F 20E3 +Y:0030 20E3 +Y:0031 FE0F 20E3 +Y:0031 20E3 +Y:0032 FE0F 20E3 +Y:0032 20E3 +Y:0033 FE0F 20E3 +Y:0033 20E3 +Y:0034 FE0F 20E3 +Y:0034 20E3 +Y:0035 FE0F 20E3 +Y:0035 20E3 +Y:0036 FE0F 20E3 +Y:0036 20E3 +Y:0037 FE0F 20E3 +Y:0037 20E3 +Y:0038 FE0F 20E3 +Y:0038 20E3 +Y:0039 FE0F 20E3 +Y:0039 20E3 +Y:1F51F +Y:1F520 +Y:1F521 +Y:1F522 +Y:1F523 +Y:1F524 +Y:1F170 FE0F +Y:1F170 +Y:1F18E +Y:1F171 FE0F +Y:1F171 +Y:1F191 +Y:1F192 +Y:1F193 +Y:2139 FE0F +Y:2139 +Y:1F194 +Y:24C2 FE0F +Y:24C2 +Y:1F195 +Y:1F196 +Y:1F17E FE0F +Y:1F17E +Y:1F197 +Y:1F17F FE0F +Y:1F17F +Y:1F198 +Y:1F199 +Y:1F19A +Y:1F201 +Y:1F202 FE0F +Y:1F202 +Y:1F237 FE0F +Y:1F237 +Y:1F236 +Y:1F22F +Y:1F250 +Y:1F239 +Y:1F21A +Y:1F232 +Y:1F251 +Y:1F238 +Y:1F234 +Y:1F233 +Y:3297 FE0F +Y:3297 +Y:3299 FE0F +Y:3299 +Y:1F23A +Y:1F235 +Y:1F534 +Y:1F7E0 +Y:1F7E1 +Y:1F7E2 +Y:1F535 +Y:1F7E3 +Y:1F7E4 +Y:26AB +Y:26AA +Y:1F7E5 +Y:1F7E7 +Y:1F7E8 +Y:1F7E9 +Y:1F7E6 +Y:1F7EA +Y:1F7EB +Y:2B1B +Y:2B1C +Y:25FC FE0F +Y:25FC +Y:25FB FE0F +Y:25FB +Y:25FE +Y:25FD +Y:25AA FE0F +Y:25AA +Y:25AB FE0F +Y:25AB +Y:1F536 +Y:1F537 +Y:1F538 +Y:1F539 +Y:1F53A +Y:1F53B +Y:1F4A0 +Y:1F518 +Y:1F533 +Y:1F532 +L:1F3C1 +L:1F6A9 +L:1F38C +L:1F3F4 +L:1F3F3 FE0F +L:1F3F3 +L:1F3F3 FE0F 200D 1F308 +L:1F3F3 200D 1F308 +L:1F3F3 FE0F 200D 26A7 FE0F +L:1F3F3 200D 26A7 FE0F +L:1F3F3 FE0F 200D 26A7 +L:1F3F3 200D 26A7 +L:1F3F4 200D 2620 FE0F +L:1F3F4 200D 2620 +L:1F1E6 1F1E8 +L:1F1E6 1F1E9 +L:1F1E6 1F1EA +L:1F1E6 1F1EB +L:1F1E6 1F1EC +L:1F1E6 1F1EE +L:1F1E6 1F1F1 +L:1F1E6 1F1F2 +L:1F1E6 1F1F4 +L:1F1E6 1F1F6 +L:1F1E6 1F1F7 +L:1F1E6 1F1F8 +L:1F1E6 1F1F9 +L:1F1E6 1F1FA +L:1F1E6 1F1FC +L:1F1E6 1F1FD +L:1F1E6 1F1FF +L:1F1E7 1F1E6 +L:1F1E7 1F1E7 +L:1F1E7 1F1E9 +L:1F1E7 1F1EA +L:1F1E7 1F1EB +L:1F1E7 1F1EC +L:1F1E7 1F1ED +L:1F1E7 1F1EE +L:1F1E7 1F1EF +L:1F1E7 1F1F1 +L:1F1E7 1F1F2 +L:1F1E7 1F1F3 +L:1F1E7 1F1F4 +L:1F1E7 1F1F6 +L:1F1E7 1F1F7 +L:1F1E7 1F1F8 +L:1F1E7 1F1F9 +L:1F1E7 1F1FB +L:1F1E7 1F1FC +L:1F1E7 1F1FE +L:1F1E7 1F1FF +L:1F1E8 1F1E6 +L:1F1E8 1F1E8 +L:1F1E8 1F1E9 +L:1F1E8 1F1EB +L:1F1E8 1F1EC +L:1F1E8 1F1ED +L:1F1E8 1F1EE +L:1F1E8 1F1F0 +L:1F1E8 1F1F1 +L:1F1E8 1F1F2 +L:1F1E8 1F1F3 +L:1F1E8 1F1F4 +L:1F1E8 1F1F5 +L:1F1E8 1F1F6 +L:1F1E8 1F1F7 +L:1F1E8 1F1FA +L:1F1E8 1F1FB +L:1F1E8 1F1FC +L:1F1E8 1F1FD +L:1F1E8 1F1FE +L:1F1E8 1F1FF +L:1F1E9 1F1EA +L:1F1E9 1F1EC +L:1F1E9 1F1EF +L:1F1E9 1F1F0 +L:1F1E9 1F1F2 +L:1F1E9 1F1F4 +L:1F1E9 1F1FF +L:1F1EA 1F1E6 +L:1F1EA 1F1E8 +L:1F1EA 1F1EA +L:1F1EA 1F1EC +L:1F1EA 1F1ED +L:1F1EA 1F1F7 +L:1F1EA 1F1F8 +L:1F1EA 1F1F9 +L:1F1EA 1F1FA +L:1F1EB 1F1EE +L:1F1EB 1F1EF +L:1F1EB 1F1F0 +L:1F1EB 1F1F2 +L:1F1EB 1F1F4 +L:1F1EB 1F1F7 +L:1F1EC 1F1E6 +L:1F1EC 1F1E7 +L:1F1EC 1F1E9 +L:1F1EC 1F1EA +L:1F1EC 1F1EB +L:1F1EC 1F1EC +L:1F1EC 1F1ED +L:1F1EC 1F1EE +L:1F1EC 1F1F1 +L:1F1EC 1F1F2 +L:1F1EC 1F1F3 +L:1F1EC 1F1F5 +L:1F1EC 1F1F6 +L:1F1EC 1F1F7 +L:1F1EC 1F1F8 +L:1F1EC 1F1F9 +L:1F1EC 1F1FA +L:1F1EC 1F1FC +L:1F1EC 1F1FE +L:1F1ED 1F1F0 +L:1F1ED 1F1F2 +L:1F1ED 1F1F3 +L:1F1ED 1F1F7 +L:1F1ED 1F1F9 +L:1F1ED 1F1FA +L:1F1EE 1F1E8 +L:1F1EE 1F1E9 +L:1F1EE 1F1EA +L:1F1EE 1F1F1 +L:1F1EE 1F1F2 +L:1F1EE 1F1F3 +L:1F1EE 1F1F4 +L:1F1EE 1F1F6 +L:1F1EE 1F1F7 +L:1F1EE 1F1F8 +L:1F1EE 1F1F9 +L:1F1EF 1F1EA +L:1F1EF 1F1F2 +L:1F1EF 1F1F4 +L:1F1EF 1F1F5 +L:1F1F0 1F1EA +L:1F1F0 1F1EC +L:1F1F0 1F1ED +L:1F1F0 1F1EE +L:1F1F0 1F1F2 +L:1F1F0 1F1F3 +L:1F1F0 1F1F5 +L:1F1F0 1F1F7 +L:1F1F0 1F1FC +L:1F1F0 1F1FE +L:1F1F0 1F1FF +L:1F1F1 1F1E6 +L:1F1F1 1F1E7 +L:1F1F1 1F1E8 +L:1F1F1 1F1EE +L:1F1F1 1F1F0 +L:1F1F1 1F1F7 +L:1F1F1 1F1F8 +L:1F1F1 1F1F9 +L:1F1F1 1F1FA +L:1F1F1 1F1FB +L:1F1F1 1F1FE +L:1F1F2 1F1E6 +L:1F1F2 1F1E8 +L:1F1F2 1F1E9 +L:1F1F2 1F1EA +L:1F1F2 1F1EB +L:1F1F2 1F1EC +L:1F1F2 1F1ED +L:1F1F2 1F1F0 +L:1F1F2 1F1F1 +L:1F1F2 1F1F2 +L:1F1F2 1F1F3 +L:1F1F2 1F1F4 +L:1F1F2 1F1F5 +L:1F1F2 1F1F6 +L:1F1F2 1F1F7 +L:1F1F2 1F1F8 +L:1F1F2 1F1F9 +L:1F1F2 1F1FA +L:1F1F2 1F1FB +L:1F1F2 1F1FC +L:1F1F2 1F1FD +L:1F1F2 1F1FE +L:1F1F2 1F1FF +L:1F1F3 1F1E6 +L:1F1F3 1F1E8 +L:1F1F3 1F1EA +L:1F1F3 1F1EB +L:1F1F3 1F1EC +L:1F1F3 1F1EE +L:1F1F3 1F1F1 +L:1F1F3 1F1F4 +L:1F1F3 1F1F5 +L:1F1F3 1F1F7 +L:1F1F3 1F1FA +L:1F1F3 1F1FF +L:1F1F4 1F1F2 +L:1F1F5 1F1E6 +L:1F1F5 1F1EA +L:1F1F5 1F1EB +L:1F1F5 1F1EC +L:1F1F5 1F1ED +L:1F1F5 1F1F0 +L:1F1F5 1F1F1 +L:1F1F5 1F1F2 +L:1F1F5 1F1F3 +L:1F1F5 1F1F7 +L:1F1F5 1F1F8 +L:1F1F5 1F1F9 +L:1F1F5 1F1FC +L:1F1F5 1F1FE +L:1F1F6 1F1E6 +L:1F1F7 1F1EA +L:1F1F7 1F1F4 +L:1F1F7 1F1F8 +L:1F1F7 1F1FA +L:1F1F7 1F1FC +L:1F1F8 1F1E6 +L:1F1F8 1F1E7 +L:1F1F8 1F1E8 +L:1F1F8 1F1E9 +L:1F1F8 1F1EA +L:1F1F8 1F1EC +L:1F1F8 1F1ED +L:1F1F8 1F1EE +L:1F1F8 1F1EF +L:1F1F8 1F1F0 +L:1F1F8 1F1F1 +L:1F1F8 1F1F2 +L:1F1F8 1F1F3 +L:1F1F8 1F1F4 +L:1F1F8 1F1F7 +L:1F1F8 1F1F8 +L:1F1F8 1F1F9 +L:1F1F8 1F1FB +L:1F1F8 1F1FD +L:1F1F8 1F1FE +L:1F1F8 1F1FF +L:1F1F9 1F1E6 +L:1F1F9 1F1E8 +L:1F1F9 1F1E9 +L:1F1F9 1F1EB +L:1F1F9 1F1EC +L:1F1F9 1F1ED +L:1F1F9 1F1EF +L:1F1F9 1F1F0 +L:1F1F9 1F1F1 +L:1F1F9 1F1F2 +L:1F1F9 1F1F3 +L:1F1F9 1F1F4 +L:1F1F9 1F1F7 +L:1F1F9 1F1F9 +L:1F1F9 1F1FB +L:1F1F9 1F1FC +L:1F1F9 1F1FF +L:1F1FA 1F1E6 +L:1F1FA 1F1EC +L:1F1FA 1F1F2 +L:1F1FA 1F1F3 +L:1F1FA 1F1F8 +L:1F1FA 1F1FE +L:1F1FA 1F1FF +L:1F1FB 1F1E6 +L:1F1FB 1F1E8 +L:1F1FB 1F1EA +L:1F1FB 1F1EC +L:1F1FB 1F1EE +L:1F1FB 1F1F3 +L:1F1FB 1F1FA +L:1F1FC 1F1EB +L:1F1FC 1F1F8 +L:1F1FD 1F1F0 +L:1F1FE 1F1EA +L:1F1FE 1F1F9 +L:1F1FF 1F1E6 +L:1F1FF 1F1F2 +L:1F1FF 1F1FC +L:1F3F4 E0067 E0062 E0065 E006E E0067 E007F +L:1F3F4 E0067 E0062 E0073 E0063 E0074 E007F +L:1F3F4 E0067 E0062 E0077 E006C E0073 E007F + """.trimIndent() + ) +} diff --git a/symbol_keyboard/src/main/java/com/kazumaproject/symbol_keyboard/CustomSymbolKeyboardView.kt b/symbol_keyboard/src/main/java/com/kazumaproject/symbol_keyboard/CustomSymbolKeyboardView.kt index 23c8d0ffd..031ab43fc 100644 --- a/symbol_keyboard/src/main/java/com/kazumaproject/symbol_keyboard/CustomSymbolKeyboardView.kt +++ b/symbol_keyboard/src/main/java/com/kazumaproject/symbol_keyboard/CustomSymbolKeyboardView.kt @@ -682,7 +682,7 @@ class CustomSymbolKeyboardView @JvmOverloads constructor( categoryTab.addTab( categoryTab.newTab().setIcon( categoryIconRes[cat] ?: com.kazumaproject.core.R.drawable.logo_key - ) + ).setContentDescription(emojiCategoryLabelRes.getValue(cat)) ) } } @@ -1035,9 +1035,21 @@ class CustomSymbolKeyboardView @JvmOverloads constructor( ).toInt() } + private val emojiCategoryLabelRes = mapOf( + EmojiCategory.SMILEYS_EMOTION to R.string.emoji_category_smileys_emotion, + EmojiCategory.PEOPLE_BODY to R.string.emoji_category_people_body, + EmojiCategory.ANIMALS_NATURE to R.string.emoji_category_animals_nature, + EmojiCategory.FOOD_DRINK to R.string.emoji_category_food_drink, + EmojiCategory.TRAVEL_PLACES to R.string.emoji_category_travel_places, + EmojiCategory.ACTIVITIES to R.string.emoji_category_activities, + EmojiCategory.OBJECTS to R.string.emoji_category_objects, + EmojiCategory.SYMBOLS to R.string.emoji_category_symbols, + EmojiCategory.FLAGS to R.string.emoji_category_flags, + EmojiCategory.UNKNOWN to R.string.emoji_category_unknown, + ) + private val categoryIconRes = mapOf( - EmojiCategory.EMOTICONS to com.kazumaproject.core.R.drawable.mood_24px, - EmojiCategory.GESTURES to com.kazumaproject.core.R.drawable.thumb_up_24dp, + EmojiCategory.SMILEYS_EMOTION to com.kazumaproject.core.R.drawable.mood_24px, EmojiCategory.PEOPLE_BODY to com.kazumaproject.core.R.drawable.person_24dp, EmojiCategory.ANIMALS_NATURE to com.kazumaproject.core.R.drawable.pets_24dp, EmojiCategory.FOOD_DRINK to com.kazumaproject.core.R.drawable.fastfood_24dp, @@ -1049,35 +1061,7 @@ class CustomSymbolKeyboardView @JvmOverloads constructor( EmojiCategory.UNKNOWN to com.kazumaproject.core.R.drawable.question_mark_24dp ) - private val categoryOrder = Comparator { a, b -> - listOf( - EmojiCategory.EMOTICONS, - EmojiCategory.GESTURES, - EmojiCategory.PEOPLE_BODY, - EmojiCategory.ANIMALS_NATURE, - EmojiCategory.FOOD_DRINK, - EmojiCategory.TRAVEL_PLACES, - EmojiCategory.ACTIVITIES, - EmojiCategory.OBJECTS, - EmojiCategory.SYMBOLS, - EmojiCategory.FLAGS, - EmojiCategory.UNKNOWN - ).indexOf(a).compareTo( - listOf( - EmojiCategory.EMOTICONS, - EmojiCategory.GESTURES, - EmojiCategory.PEOPLE_BODY, - EmojiCategory.ANIMALS_NATURE, - EmojiCategory.FOOD_DRINK, - EmojiCategory.TRAVEL_PLACES, - EmojiCategory.ACTIVITIES, - EmojiCategory.OBJECTS, - EmojiCategory.SYMBOLS, - EmojiCategory.FLAGS, - EmojiCategory.UNKNOWN - ).indexOf(b) - ) - } + private val categoryOrder = compareBy { it.ordinal } fun switchToClipboardMode(selectCategoryIndex: Int = 0) { // Modeを切り替え diff --git a/symbol_keyboard/src/main/res/values-ja/strings.xml b/symbol_keyboard/src/main/res/values-ja/strings.xml index 7a0702816..1148d6f67 100644 --- a/symbol_keyboard/src/main/res/values-ja/strings.xml +++ b/symbol_keyboard/src/main/res/values-ja/strings.xml @@ -6,4 +6,14 @@ ピン留め ピン留めを解除 削除 + 顔文字、気分 + 人々 + 動物、自然 + 食品、飲料 + 移動、場所 + 活動、イベント + 物 + 記号 + 旗 + その他 diff --git a/symbol_keyboard/src/main/res/values/strings.xml b/symbol_keyboard/src/main/res/values/strings.xml index 3aef28f3a..b4ed376ff 100644 --- a/symbol_keyboard/src/main/res/values/strings.xml +++ b/symbol_keyboard/src/main/res/values/strings.xml @@ -6,4 +6,14 @@ Pin Unpin Delete + Smileys & Emotions + People + Animals & Nature + Food & Drink + Travel & Places + Activities & Events + Objects + Symbols + Flags + Other diff --git a/symbol_keyboard/src/test/java/com/kazumaproject/domain/EmojiCategoryMetadataTest.kt b/symbol_keyboard/src/test/java/com/kazumaproject/domain/EmojiCategoryMetadataTest.kt new file mode 100644 index 000000000..e105ef0e8 --- /dev/null +++ b/symbol_keyboard/src/test/java/com/kazumaproject/domain/EmojiCategoryMetadataTest.kt @@ -0,0 +1,76 @@ +package com.kazumaproject.domain + +import com.kazumaproject.data.emoji.Emoji +import com.kazumaproject.data.emoji.EmojiCategory +import com.kazumaproject.data.emoticon.EmoticonCategory +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class EmojiCategoryMetadataTest { + + @Test + fun unicodeSequencesUseTheirPublishedTopLevelGroups() { + val expected = mapOf( + "😀" to EmojiCategory.SMILEYS_EMOTION, + "☺" to EmojiCategory.SMILEYS_EMOTION, + "❤️‍🔥" to EmojiCategory.SMILEYS_EMOTION, + "👍" to EmojiCategory.PEOPLE_BODY, + "👍🏽" to EmojiCategory.PEOPLE_BODY, + "👩‍💻" to EmojiCategory.PEOPLE_BODY, + "🐶" to EmojiCategory.ANIMALS_NATURE, + "🍎" to EmojiCategory.FOOD_DRINK, + "✈️" to EmojiCategory.TRAVEL_PLACES, + "⚽" to EmojiCategory.ACTIVITIES, + "💡" to EmojiCategory.OBJECTS, + "#️⃣" to EmojiCategory.SYMBOLS, + "🇯🇵" to EmojiCategory.FLAGS, + "⌚️" to EmojiCategory.TRAVEL_PLACES, + "♈️" to EmojiCategory.SYMBOLS, + "🫩" to EmojiCategory.SMILEYS_EMOTION, + "🫪" to EmojiCategory.SMILEYS_EMOTION, + ) + + expected.forEach { (symbol, category) -> + assertEquals(symbol, category, categorizeEmoji(symbol)) + } + assertEquals(EmojiCategory.UNKNOWN, categorizeEmoji("not-an-emoji")) + } + + @Test + fun emojiSortUsesPublishedCldrOrderAndLeavesUnknownLast() { + val input = listOf( + Emoji("not-an-emoji", EmojiCategory.UNKNOWN), + Emoji("😃", categorizeEmoji("😃")), + Emoji("😀", categorizeEmoji("😀")), + Emoji("🇯🇵", categorizeEmoji("🇯🇵")), + ) + + assertEquals( + listOf("😀", "😃", "🇯🇵", "not-an-emoji"), + input.sortByEmojiCategory().map { it.symbol }, + ) + } + + @Test + fun originalEmoticonCategoriesRemainUnchanged() { + val expected = mapOf( + ":-)" to EmoticonCategory.SMILE, + "( •̀ㅁ•́;)" to EmoticonCategory.SWEAT, + "Σ(ﾟДﾟ)" to EmoticonCategory.SURPRISE, + "(TT)" to EmoticonCategory.SADNESS, + "(-_-)" to EmoticonCategory.DISPLEASURE, + ) + + expected.forEach { (symbol, category) -> + assertEquals(symbol, category, symbol.toEmoticonCategory()) + } + assertEquals(EmoticonCategory.UNKNOWN, "not-an-emoticon".toEmoticonCategory()) + } + + @Test + fun generatedMetadataContainsThePinnedSourceData() { + assertEquals("17.0", EmojiCategoryMetadata.UNICODE_VERSION) + assertTrue(EmojiCategoryMetadata.emojiEntryCount() > 5_000) + } +} diff --git a/tools/emoji_metadata/generate_category_metadata.py b/tools/emoji_metadata/generate_category_metadata.py new file mode 100644 index 000000000..617032384 --- /dev/null +++ b/tools/emoji_metadata/generate_category_metadata.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Generate Kotlin category metadata from the pinned Unicode source. + +The generated Kotlin is written to stdout so callers can review/apply it explicitly. +""" + +from __future__ import annotations + +import argparse +from pathlib import Path + + +EMOJI_GROUPS = { + "Smileys & Emotion": "S", + "People & Body": "P", + "Animals & Nature": "N", + "Food & Drink": "F", + "Travel & Places": "T", + "Activities": "A", + "Objects": "O", + "Symbols": "Y", + "Flags": "L", +} + +def parse_emoji_test(path: Path) -> tuple[str, list[str]]: + version = "unknown" + current_group: str | None = None + rows: list[str] = [] + for raw_line in path.read_text(encoding="utf-8").splitlines(): + line = raw_line.strip() + if line.startswith("# Version:"): + version = line.split(":", 1)[1].strip() + elif line.startswith("# group:"): + current_group = line.split(":", 1)[1].strip() + elif line and not line.startswith("#") and ";" in line: + category_code = EMOJI_GROUPS.get(current_group or "") + if category_code is None: + continue + code_points = line.split(";", 1)[0].strip() + rows.append(f"{category_code}:{code_points}") + return version, rows + + +def chunks(rows: list[str], max_chars: int = 48_000) -> list[str]: + result: list[str] = [] + current: list[str] = [] + current_size = 0 + for row in rows: + row_size = len(row) + 1 + if current and current_size + row_size > max_chars: + result.append("\n".join(current)) + current = [] + current_size = 0 + current.append(row) + current_size += row_size + if current: + result.append("\n".join(current)) + return result + + +def render_chunks(name: str, rows: list[str]) -> str: + rendered = [] + for chunk in chunks(rows): + rendered.append(' """\n' + chunk + '\n """.trimIndent()') + return f" private val {name} = arrayOf(\n" + ",\n".join(rendered) + "\n )" + + +def render_kotlin(emoji_version: str, emoji_rows: list[str]) -> str: + emoji_chunks = render_chunks("emojiDataChunks", emoji_rows) + return f'''// Generated by tools/emoji_metadata/generate_category_metadata.py. Do not edit manually. +// Unicode Emoji {emoji_version}: https://www.unicode.org/Public/{emoji_version}.0/emoji/emoji-test.txt +package com.kazumaproject.domain + +import com.kazumaproject.data.emoji.EmojiCategory + +internal object EmojiCategoryMetadata {{ + const val UNICODE_VERSION: String = "{emoji_version}" + + private data class EmojiMetadata(val category: EmojiCategory, val order: Int) + + private val emojiIndex: Map by lazy(LazyThreadSafetyMode.PUBLICATION) {{ + val result = HashMap({len(emoji_rows) * 2}) + var order = 0 + emojiDataChunks.forEach {{ chunk -> + chunk.lineSequence().filter(String::isNotBlank).forEach {{ line -> + val separator = line.indexOf(':') + val category = emojiCategory(line.substring(0, separator)) + val symbol = decodeCodePoints(line, separator + 1) + result.putIfAbsent(symbol, EmojiMetadata(category, order)) + order++ + }} + }} + result + }} + + // U+FE0E/U+FE0F select text/emoji presentation; they do not change the + // Unicode/CLDR group. Some bundled entries add U+FE0F to characters whose + // fully-qualified emoji-test sequence does not contain a selector. + private val presentationIndependentEmojiIndex: Map by + lazy(LazyThreadSafetyMode.PUBLICATION) {{ + val result = HashMap(emojiIndex.size * 2) + emojiIndex.forEach {{ (symbol, metadata) -> + val key = symbol.withoutPresentationSelectors() + val existing = result[key] + check(existing == null || existing.category == metadata.category) {{ + "Presentation-independent emoji category collision for $key" + }} + if (existing == null || metadata.order < existing.order) {{ + result[key] = metadata + }} + }} + result + }} + + fun emojiCategoryOf(symbol: String): EmojiCategory = + emojiMetadataOf(symbol)?.category ?: EmojiCategory.UNKNOWN + + fun emojiOrderOf(symbol: String): Int = emojiMetadataOf(symbol)?.order ?: Int.MAX_VALUE + + internal fun emojiEntryCount(): Int = emojiIndex.size + + private fun emojiMetadataOf(symbol: String): EmojiMetadata? = + emojiIndex[symbol] + ?: presentationIndependentEmojiIndex[symbol.withoutPresentationSelectors()] + + private fun String.withoutPresentationSelectors(): String = + replace("\uFE0E", "").replace("\uFE0F", "") + + private fun emojiCategory(code: String): EmojiCategory = when (code) {{ + "S" -> EmojiCategory.SMILEYS_EMOTION + "P" -> EmojiCategory.PEOPLE_BODY + "N" -> EmojiCategory.ANIMALS_NATURE + "F" -> EmojiCategory.FOOD_DRINK + "T" -> EmojiCategory.TRAVEL_PLACES + "A" -> EmojiCategory.ACTIVITIES + "O" -> EmojiCategory.OBJECTS + "Y" -> EmojiCategory.SYMBOLS + "L" -> EmojiCategory.FLAGS + else -> error("Unknown emoji category code: $code") + }} + + private fun decodeCodePoints(line: String, startIndex: Int): String {{ + val result = StringBuilder() + var tokenStart = startIndex + var index = startIndex + while (index <= line.length) {{ + if (index == line.length || line[index] == ' ') {{ + if (index > tokenStart) {{ + result.appendCodePoint(line.substring(tokenStart, index).toInt(16)) + }} + tokenStart = index + 1 + }} + index++ + }} + return result.toString() + }} + +{emoji_chunks} +}} +''' + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--emoji-test", type=Path, required=True) + args = parser.parse_args() + + emoji_version, emoji_rows = parse_emoji_test(args.emoji_test) + print(render_kotlin(emoji_version, emoji_rows), end="") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From 81c6741119938286c50ab5655e14bc58db868679 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 3 Aug 2026 07:22:02 -0400 Subject: [PATCH 16/24] implement composing text --- .../FastInputMatrixInstrumentedTest.kt | 333 ++++++++++++++++++ .../ime_service/IMEService.kt | 109 +++++- .../ime_service/ImePreferencesSnapshot.kt | 2 + .../flick_preview/ComposingTextArbiter.kt | 80 +++++ .../FlickInputPreviewCoordinator.kt | 177 ++++++++++ .../FlickPreviewEligibilityPolicy.kt | 38 ++ .../FlickTextMutationResolver.kt | 91 +++++ .../setting_activity/AppPreference.kt | 22 +- .../ui/setting/SettingDestination.kt | 1 + app/src/main/res/values-ja/strings.xml | 4 + app/src/main/res/values/strings.xml | 4 + app/src/main/res/xml/pref_common_legacy.xml | 60 ++-- .../main/res/xml/pref_operation_feedback.xml | 13 +- .../flick_preview/ComposingTextArbiterTest.kt | 71 ++++ .../FlickInputPreviewCoordinatorTest.kt | 113 ++++++ .../FlickPreviewEligibilityPolicyTest.kt | 59 ++++ .../FlickTextMutationResolverTest.kt | 83 +++++ .../domain/flick/FlickTextPreviewEmitter.kt | 60 ++++ .../domain/flick/FlickTextPreviewEvent.kt | 39 ++ .../flick/FlickTextPreviewEmitterTest.kt | 45 +++ .../controller/CrossFlickInputController.kt | 14 + .../controller/CustomAngleFlickController.kt | 8 + .../StandardFlickInputController.kt | 8 + .../TfbiHierarchicalFlickController.kt | 28 +- .../controller/TfbiInputController.kt | 23 ++ .../custom_keyboard/view/FlickKeyboardView.kt | 156 ++++++-- ...review-implementation-report-2026-08-02.md | 88 +++++ .../java/com/kazumaproject/tenkey/TenKey.kt | 225 +++++------- 28 files changed, 1770 insertions(+), 184 deletions(-) create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/ComposingTextArbiter.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolver.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/ComposingTextArbiterTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt create mode 100644 app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolverTest.kt create mode 100644 core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitter.kt create mode 100644 core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEvent.kt create mode 100644 core/src/test/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitterTest.kt create mode 100644 docs/flick-editor-preview-implementation-report-2026-08-02.md diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt index 4303a397e..185cde18b 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt @@ -12,6 +12,7 @@ import android.graphics.Bitmap import android.graphics.PointF import android.graphics.Rect import android.os.Bundle +import android.os.Debug import android.os.ParcelFileDescriptor import android.os.PowerManager import android.os.SystemClock @@ -50,6 +51,284 @@ class FastInputMatrixInstrumentedTest { private val uiAutomation: UiAutomation get() = instrumentation.uiAutomation + @Test + fun flickEditorPreviewFunctionalAndPerformanceOnPhysicalDevice() { + runPhysicalDeviceSession("flick-editor-preview") { session -> + var scenario: ActivityScenario? = null + try { + scenario = launchHost(session.context) + rotateAndVerify(TestOrientation.PORTRAIT) + + val sumireStyles = listOf( + "default", + "circle", + "second-flick", + "third-flick", + "sumire", + ) + val functionalCases = buildList { + add(TestKeyboard.TENKEY to null) + sumireStyles.forEach { style -> add(TestKeyboard.SUMIRE to style) } + } + + functionalCases.forEach { (keyboard, style) -> + val testCase = previewTestCase(keyboard) + applyCasePreferences(session.preferences, testCase) + check( + session.preferences.edit() + .putBoolean("flick_editor_preview_preference", true) + .putString("sumire_keyboard_style_preference", style ?: "default") + .putString("sumire_input_method_preference", "switch-mode-effective") + .putString("keyboard_touch_effect_type_preference", "none") + .commit() + ) + ensureTargetImeSelected(session) + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + val geometry = awaitStableGeometry( + keyboard = keyboard, + requireCandidateContent = false, + ) + + val downTime = SystemClock.uptimeMillis() + assertTrue( + "DOWN injection failed for $keyboard/$style", + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_DOWN, + geometry.prime.center, + ), + ) + assertEquals( + "DOWN preview mismatch for $keyboard/$style", + keyboard.primeText, + awaitEditorText(scenario) { it.isNotEmpty() }, + ) + assertTrue( + "Candidate generation started before UP for $keyboard/$style", + findCandidateState().texts.isEmpty(), + ) + assertTrue( + "CANCEL injection failed for $keyboard/$style", + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_CANCEL, + geometry.prime.center, + ), + ) + assertEquals( + "Preview remained after CANCEL for $keyboard/$style", + "", + awaitEditorText(scenario) { it.isEmpty() }, + ) + } + + listOf(TestKeyboard.TENKEY, TestKeyboard.SUMIRE).forEach { keyboard -> + val testCase = previewTestCase(keyboard) + applyCasePreferences(session.preferences, testCase) + check( + session.preferences.edit() + .putBoolean("flick_editor_preview_preference", true) + .putString("sumire_keyboard_style_preference", "default") + .commit() + ) + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + val geometry = awaitStableGeometry(keyboard, false) + val end = PointF( + geometry.prime.center.x + geometry.prime.width * 0.70f, + geometry.prime.center.y, + ) + val downTime = SystemClock.uptimeMillis() + assertTrue( + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_DOWN, + geometry.prime.center, + ) + ) + assertEquals( + keyboard.primeText, + awaitEditorText(scenario) { it.isNotEmpty() }, + ) + assertTrue( + injectSinglePointerEvent(downTime, MotionEvent.ACTION_MOVE, end) + ) + val movedPreview = awaitEditorText(scenario) { + it.isNotEmpty() && it != keyboard.primeText + } + assertTrue("MOVE did not replace preview for $keyboard", movedPreview.isNotEmpty()) + assertTrue( + injectSinglePointerEvent(downTime, MotionEvent.ACTION_UP, end) + ) + assertEquals( + "UP result differed from MOVE preview for $keyboard", + movedPreview, + awaitTextSettled(scenario), + ) + } + + listOf(TestKeyboard.TENKEY, TestKeyboard.SUMIRE).forEach { keyboard -> + val testCase = previewTestCase(keyboard) + applyCasePreferences(session.preferences, testCase) + check( + session.preferences.edit() + .putBoolean("flick_editor_preview_preference", false) + .putString("sumire_keyboard_style_preference", "default") + .commit() + ) + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + val geometry = awaitStableGeometry(keyboard, false) + val downTime = SystemClock.uptimeMillis() + assertTrue( + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_DOWN, + geometry.prime.center, + ) + ) + SystemClock.sleep(PREVIEW_HOLD_ASSERT_MS) + assertEquals("OFF changed editor on DOWN for $keyboard", "", readText(scenario)) + assertTrue( + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_UP, + geometry.prime.center, + ) + ) + assertEquals(keyboard.primeText, awaitTextSettled(scenario)) + } + + val performanceLines = mutableListOf() + applyCasePreferences(session.preferences, previewTestCase(TestKeyboard.TENKEY)) + for (enabled in listOf(false, true)) { + check( + session.preferences.edit() + .putBoolean("flick_editor_preview_preference", enabled) + .putString("keyboard_touch_effect_type_preference", "none") + .commit() + ) + val candidateSamplesNs = LongArray(PREVIEW_CANDIDATE_SAMPLES) + repeat(PREVIEW_CANDIDATE_WARMUP + PREVIEW_CANDIDATE_SAMPLES) { index -> + restartInput(scenario) + val trialGeometry = awaitStableGeometry(TestKeyboard.TENKEY, false) + val downTime = SystemClock.uptimeMillis() + assertTrue( + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_DOWN, + trialGeometry.prime.center, + ) + ) + if (enabled) { + assertEquals( + TestKeyboard.TENKEY.primeText, + awaitEditorText(scenario) { it.isNotEmpty() }, + ) + } + assertTrue( + "Candidates changed before UP (enabled=$enabled)", + findCandidateState().texts.isEmpty(), + ) + val upStartedNs = SystemClock.elapsedRealtimeNanos() + assertTrue( + injectSinglePointerEvent( + downTime, + MotionEvent.ACTION_UP, + trialGeometry.prime.center, + ) + ) + val candidateLatencyNs = awaitCandidateVisibleLatencyNs(upStartedNs) + if (index >= PREVIEW_CANDIDATE_WARMUP) { + candidateSamplesNs[index - PREVIEW_CANDIDATE_WARMUP] = + candidateLatencyNs + } + } + val sortedCandidateSamples = candidateSamplesNs.sorted() + val candidateLine = buildString { + append("enabled=$enabled ") + append("samples=$PREVIEW_CANDIDATE_SAMPLES ") + append("candidateLatencyMeanMs=") + append(candidateSamplesNs.average() / 1_000_000.0) + append(" candidateLatencyP50Ms=") + append( + sortedCandidateSamples[sortedCandidateSamples.size / 2] / + 1_000_000.0 + ) + append(" candidateLatencyP95Ms=") + append( + sortedCandidateSamples[ + ((sortedCandidateSamples.size - 1) * 0.95).toInt() + ] / 1_000_000.0 + ) + } + performanceLines += candidateLine + Log.i(TAG, "FLICK_EDITOR_PREVIEW_CONVERSION $candidateLine") + sendProgress("FLICK_EDITOR_PREVIEW_CONVERSION $candidateLine\n") + + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + val geometry = awaitStableGeometry(TestKeyboard.TENKEY, false) + val performanceMovePoint = PointF( + geometry.prime.center.x + geometry.prime.width * 0.70f, + geometry.prime.center.y, + ) + repeat(PREVIEW_PERFORMANCE_WARMUP_GESTURES) { + injectPreviewCancelGesture(geometry.prime.center, performanceMovePoint) + } + Runtime.getRuntime().gc() + SystemClock.sleep(PREVIEW_GC_SETTLE_MS) + val allocatedBefore = runtimeStat("art.gc.bytes-allocated") + val pssBeforeKb = Debug.getPss().toLong() + val startedNs = SystemClock.elapsedRealtimeNanos() + repeat(PREVIEW_PERFORMANCE_GESTURES) { + assertTrue( + injectPreviewCancelGesture( + geometry.prime.center, + performanceMovePoint, + ) + ) + } + val elapsedNs = SystemClock.elapsedRealtimeNanos() - startedNs + val allocatedAfter = runtimeStat("art.gc.bytes-allocated") + val pssImmediateKb = Debug.getPss().toLong() + Runtime.getRuntime().gc() + SystemClock.sleep(PREVIEW_GC_SETTLE_MS) + val pssSettledKb = Debug.getPss().toLong() + val line = buildString { + append("enabled=$enabled ") + append("gestures=$PREVIEW_PERFORMANCE_GESTURES ") + append("meanGestureUs=") + append(elapsedNs / PREVIEW_PERFORMANCE_GESTURES / 1_000.0) + append(" allocatedBytes=") + append(allocatedAfter - allocatedBefore) + append(" allocatedBytesPerGesture=") + append((allocatedAfter - allocatedBefore) / PREVIEW_PERFORMANCE_GESTURES) + append(" pssBeforeKb=$pssBeforeKb") + append(" pssImmediateKb=$pssImmediateKb") + append(" pssSettledKb=$pssSettledKb") + } + performanceLines += line + Log.i(TAG, "FLICK_EDITOR_PREVIEW_PERF $line") + sendProgress("FLICK_EDITOR_PREVIEW_PERF $line\n") + } + + val report = File(session.outputDirectory, "flick-editor-preview-performance.txt") + report.writeText( + buildString { + appendLine("device=${android.os.Build.MODEL}") + appendLine("sdk=${android.os.Build.VERSION.SDK_INT}") + performanceLines.forEach(::appendLine) + } + ) + sendProgress("FLICK_EDITOR_PREVIEW_REPORT $report\n") + } finally { + scenario?.close() + } + } + } + @Test fun tenKeyNumberBracketGuideSurvivesActualFlicksOnPhysicalDevice() { runPhysicalDeviceSession("tenkey-number-bracket-guide") { session -> @@ -942,6 +1221,7 @@ class FastInputMatrixInstrumentedTest { .putBoolean("enable_typo_correction_japanese_flick_keyboard_preference", false) .putBoolean("enable_typo_correction_qwerty_english_keyboard_preference", false) .putBoolean("learn_dictionary_preference", false) + .putBoolean("zero_query_suggestion_preference", false) check(editor.commit()) { "Failed to persist preferences for $case" } check( @@ -1102,6 +1382,31 @@ class FastInputMatrixInstrumentedTest { return text } + private fun awaitEditorText( + scenario: ActivityScenario, + predicate: (String) -> Boolean, + ): String { + val deadline = SystemClock.uptimeMillis() + RESULT_TIMEOUT_MS + var latest = readText(scenario) + while (SystemClock.uptimeMillis() < deadline) { + latest = readText(scenario) + if (predicate(latest)) return latest + SystemClock.sleep(PREVIEW_TEXT_POLL_MS) + } + return latest + } + + private fun awaitCandidateVisibleLatencyNs(startedNs: Long): Long { + val deadline = SystemClock.uptimeMillis() + RESULT_TIMEOUT_MS + while (SystemClock.uptimeMillis() < deadline) { + if (findCandidateState().texts.isNotEmpty()) { + return SystemClock.elapsedRealtimeNanos() - startedNs + } + SystemClock.sleep(PREVIEW_CANDIDATE_POLL_MS) + } + throw SetupException("Candidate list did not become visible during latency measurement") + } + private fun awaitTextSettled( scenario: ActivityScenario ): String { @@ -1395,6 +1700,17 @@ class FastInputMatrixInstrumentedTest { } } + private fun injectPreviewCancelGesture(start: PointF, move: PointF): Boolean { + val downTime = SystemClock.uptimeMillis() + var injected = injectSinglePointerEvent(downTime, MotionEvent.ACTION_DOWN, start) + injected = injectSinglePointerEvent(downTime, MotionEvent.ACTION_MOVE, move) && injected + injected = injectSinglePointerEvent(downTime, MotionEvent.ACTION_CANCEL, move) && injected + return injected + } + + private fun runtimeStat(name: String): Long = + Debug.getRuntimeStat(name)?.toLongOrNull() ?: 0L + private fun injectTapPairAtDownInterval( point: PointF, downToDownIntervalMs: Long @@ -2116,6 +2432,15 @@ class FastInputMatrixInstrumentedTest { orientation.name.lowercase() } + private fun previewTestCase(keyboard: TestKeyboard) = TestCase( + keyboard = keyboard, + columns = 1, + candidateTabVisible = false, + toolbarVisible = false, + toolbarIntegrated = false, + orientation = TestOrientation.PORTRAIT, + ) + private data class PhysicalDeviceSession( val context: Context, val preferences: SharedPreferences, @@ -2306,6 +2631,14 @@ class FastInputMatrixInstrumentedTest { private const val TAP_GAP_MS = 12L private const val FLICK_MOVE_STEPS = 4 private const val FLICK_STEP_MS = 18L + private const val PREVIEW_HOLD_ASSERT_MS = 120L + private const val PREVIEW_TEXT_POLL_MS = 4L + private const val PREVIEW_PERFORMANCE_WARMUP_GESTURES = 30 + private const val PREVIEW_PERFORMANCE_GESTURES = 500 + private const val PREVIEW_GC_SETTLE_MS = 250L + private const val PREVIEW_CANDIDATE_WARMUP = 3 + private const val PREVIEW_CANDIDATE_SAMPLES = 15 + private const val PREVIEW_CANDIDATE_POLL_MS = 1L private const val GUIDE_SETTLE_MS = 350L private const val GUIDE_CHANNEL_TOLERANCE = 12 private const val MAX_GUIDE_CHANGED_PIXELS = 80 diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 7b6ee394f..3c0b7ff1e 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -124,6 +124,7 @@ import com.kazumaproject.core.domain.extensions.toZenkaku import com.kazumaproject.core.domain.extensions.toZenkakuAlphabet import com.kazumaproject.core.domain.extensions.toZenkakuKatakana import com.kazumaproject.core.domain.flick.FlickThresholdShape +import com.kazumaproject.core.domain.flick.FlickTextPreviewListener import com.kazumaproject.core.domain.flick.MutableRuntimeGestureSettingsSource import com.kazumaproject.core.domain.flick.RuntimeGestureSettings import com.kazumaproject.core.domain.key.Key @@ -238,6 +239,10 @@ import com.kazumaproject.markdownhelperkeyboard.ime_service.feedback.VibrationTi import com.kazumaproject.markdownhelperkeyboard.ime_service.floating_view.BubbleTextView import com.kazumaproject.markdownhelperkeyboard.ime_service.floating_view.FloatingDockListener import com.kazumaproject.markdownhelperkeyboard.ime_service.floating_view.FloatingDockView +import com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview.ComposingTextArbiter +import com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview.FlickInputPreviewCoordinator +import com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview.FlickPreviewContext +import com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview.FlickPreviewSource import com.kazumaproject.markdownhelperkeyboard.ime_service.image_effect.CinematicWaveEffectView import com.kazumaproject.markdownhelperkeyboard.ime_service.image_effect.CinematicWaveSettings import com.kazumaproject.markdownhelperkeyboard.ime_service.image_effect.FluidInkTransportMode @@ -748,6 +753,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private val runtimeInputPreferenceKeys = setOf( AppPreference.FLICK_SENSITIVITY_KEY, AppPreference.FLICK_THRESHOLD_SHAPE_KEY, + AppPreference.FLICK_EDITOR_PREVIEW_KEY, AppPreference.TENKEY_KEYMAP_GUIDE_JAPANESE_KEY, AppPreference.TENKEY_KEYMAP_GUIDE_ENGLISH_KEY, AppPreference.TENKEY_KEYMAP_GUIDE_NUMBER_KEY, @@ -1341,6 +1347,32 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private val rightCursorKeyLongKeyPressed = AtomicBoolean(false) private val leftCursorKeyLongKeyPressed = AtomicBoolean(false) private var isFlickOnlyMode: Boolean? = false + private var flickEditorPreviewPreference: Boolean = false + private var flickPreviewEditorSessionId: Long = 0L + private val composingTextArbiter = ComposingTextArbiter( + writeComposingText = { text, cursorPosition -> + currentInputConnection?.setComposingText(text, cursorPosition) ?: false + }, + finishComposingText = { + currentInputConnection?.finishComposingText() ?: false + }, + copyText = { text -> SpannableString(text) }, + ) + private val flickInputPreviewCoordinator = FlickInputPreviewCoordinator( + composingTextArbiter = composingTextArbiter, + ) + private val tenKeyFlickTextPreviewListener = FlickTextPreviewListener { event -> + flickInputPreviewCoordinator.onEvent( + event = event, + context = currentFlickPreviewContext(FlickPreviewSource.TENKEY), + ) + } + private val sumireFlickTextPreviewListener = FlickTextPreviewListener { event -> + flickInputPreviewCoordinator.onEvent( + event = event, + context = currentFlickPreviewContext(FlickPreviewSource.SUMIRE), + ) + } private var isOmissionSearchEnable: Boolean? = false private var delayTime: Int? = 1000 private var isLearnDictionaryMode: Boolean? = false @@ -2224,6 +2256,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, override fun onStartInput(attribute: EditorInfo?, restarting: Boolean) { super.onStartInput(attribute, restarting) + flickPreviewEditorSessionId += 1L + flickInputPreviewCoordinator.resetForEditorSession() gemmaInputSessionId += 1L gemmaMediaPanelController?.onInputSessionChanged() gemmaHandwritingController?.onInputSessionChanged() @@ -2304,6 +2338,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, flickSensitivityPreferenceValue = sensitivity flickThresholdShapePreferenceValue = thresholdShape longPressTimeoutPreferenceValue = longPressTimeout + flickEditorPreviewPreference = appPreference.flick_editor_preview_preference deleteLongPressConversionBehavior = DeleteLongPressConversionBehavior.fromPreferenceValue( appPreference.delete_long_press_conversion_behavior @@ -2381,6 +2416,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, mozcUTNeologd = preferences.mozcUTNeologd mozcUTWeb = preferences.mozcUTWeb isFlickOnlyMode = preferences.isFlickOnlyMode + flickEditorPreviewPreference = preferences.flickEditorPreviewPreference isOmissionSearchEnable = preferences.isOmissionSearchEnable delayTime = preferences.delayTime isLearnDictionaryMode = preferences.isLearnDictionaryMode @@ -4135,6 +4171,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, override fun onStartInputView(editorInfo: EditorInfo?, restarting: Boolean) { super.onStartInputView(editorInfo, restarting) + flickInputPreviewCoordinator.cancel(restore = true) clearZeroQueryAllState(refresh = false) // The input view can restart without onStartInput() after returning from settings. // Re-read preferences that may change while the existing input session is retained. @@ -4495,6 +4532,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } override fun onFinishInputView(finishingInput: Boolean) { + flickInputPreviewCoordinator.cancel(restore = false) gemmaMediaPanelController?.onInputViewHidden() gemmaHandwritingController?.onInputViewHidden() candidateRequestTracker.invalidate() @@ -4526,6 +4564,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } override fun onWindowHidden() { + flickInputPreviewCoordinator.cancel(restore = true) gemmaMediaPanelController?.onInputViewHidden() gemmaHandwritingController?.onInputViewHidden() clearAndPauseSuminagashiInkEffects() @@ -4533,6 +4572,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } override fun onDestroy() { + flickInputPreviewCoordinator.cancel(restore = false) Timber.d("onUpdate onDestroy") if (runtimeInputPreferenceListenerRegistered) { runtimeInputSharedPreferences.unregisterOnSharedPreferenceChangeListener( @@ -5191,7 +5231,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private fun updateComposingText(text: String) { // 途中経過の表示用（変換中のようなイメージ） - currentInputConnection?.setComposingText(text, 1) + setComposingText(text, 1) } private fun commitRecognizedText(text: String) { @@ -7906,6 +7946,9 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private fun configureFloatingTenKeyView( floatingKeyboardLayoutBinding: FloatingKeyboardLayoutBinding ) { + floatingKeyboardLayoutBinding.keyboardViewFloating.setOnFlickTextPreviewListener( + tenKeyFlickTextPreviewListener + ) floatingKeyboardLayoutBinding.keyboardViewFloating.applyKeyboardTheme( themeMode = keyboardThemeMode ?: "default", currentNightMode = currentNightMode, @@ -8049,6 +8092,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, mainView: MainLayoutBinding ) { mainView.keyboardView.apply { + setOnFlickTextPreviewListener(tenKeyFlickTextPreviewListener) applyKeyboardTheme( themeMode = keyboardThemeMode ?: "default", currentNightMode = currentNightMode, @@ -11126,6 +11170,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, mainView: MainLayoutBinding, isFloatingView: Boolean ) { + flickView.setOnFlickTextPreviewListener(sumireFlickTextPreviewListener) flickView.bindRuntimeGestureSettings(runtimeGestureSettingsSource) if (isFloatingView) { Timber.d("Configuring floating FlickKeyboardView mirror surface") @@ -12506,6 +12551,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, text: String, mainView: MainLayoutBinding, isFlick: Boolean ) { if (dispatchDirectTextIfNeeded(text)) return + if (applyPendingFlickTextMutation(text, isFlick)) return val insertString = inputString.value val sb = StringBuilder() if (text.isNotEmpty()) { @@ -24068,10 +24114,54 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } } + private fun currentFlickPreviewContext(source: FlickPreviewSource): FlickPreviewContext { + val surfaceEligible = when (source) { + FlickPreviewSource.TENKEY -> qwertyMode.value == TenKeyQWERTYMode.Default + FlickPreviewSource.SUMIRE -> qwertyMode.value == TenKeyQWERTYMode.Sumire || + qwertyMode.value == TenKeyQWERTYMode.Number + } + return FlickPreviewContext( + source = source, + editorSessionId = flickPreviewEditorSessionId, + settingEnabled = flickEditorPreviewPreference, + surfaceEligible = surfaceEligible && !isKeyboardLayoutEditModeActive(), + inputBehaviorUsesComposingText = + currentInputBehavior == ResolvedInputBehavior.COMPOSING_TEXT, + safeInputType = currentInputType !in passwordTypes && + currentInputType !in numberTypes && + currentInputType != InputTypeForIME.None, + isHenkan = isHenkan.get(), + selectMode = selectMode.value, + cursorMoveMode = cursorMoveMode.value, + hasComposingTail = stringInTail.get().isNotEmpty(), + hasInputConnection = currentInputConnection != null, + baseInput = inputString.value, + isFlickOnlyMode = isFlickOnlyMode == true, + isContinuousTapInputEnabled = isContinuousTapInputEnabled.get(), + lastFlickConvertedNextHiragana = lastFlickConvertedNextHiragana.get(), + ) + } + + private fun applyPendingFlickTextMutation(text: String, isFlick: Boolean): Boolean { + val mutation = flickInputPreviewCoordinator.consumePendingCommit(text, isFlick) + ?: return false + suggestionClickNum = 0 + _dakutenPressed.value = false + englishSpaceKeyPressed.set(false) + onDeleteLongPressUp.set(false) + mutation.effects.continuousTapInputEnabled?.let(isContinuousTapInputEnabled::set) + mutation.effects.lastFlickConvertedNextHiragana?.let( + lastFlickConvertedNextHiragana::set + ) + _inputString.update { mutation.resultInput } + return true + } + private fun sendCharTap( charToSend: Char, insertString: String, sb: StringBuilder ) { if (dispatchDirectTextIfNeeded(charToSend.toString())) return + if (applyPendingFlickTextMutation(charToSend.toString(), isFlick = false)) return when (currentInputType) { InputTypeForIME.None, InputTypeForIME.Number, @@ -24120,6 +24210,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, charToSend: Char, insertString: String, sb: StringBuilder ) { if (dispatchDirectTextIfNeeded(charToSend.toString())) return + if (applyPendingFlickTextMutation(charToSend.toString(), isFlick = true)) return when (currentInputType) { InputTypeForIME.None, InputTypeForIME.Number, @@ -25111,12 +25202,14 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, override fun deleteSurroundingText(p0: Int, p1: Int): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) cancelCandidateTranslationIfPreEditMutates() return currentInputConnection.deleteSurroundingText(p0, p1) } override fun deleteSurroundingTextInCodePoints(p0: Int, p1: Int): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) cancelCandidateTranslationIfPreEditMutates() return currentInputConnection.deleteSurroundingTextInCodePoints(p0, p1) } @@ -25124,40 +25217,48 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, override fun setComposingText(p0: CharSequence?, p1: Int): Boolean { if (currentInputConnection == null) return false cancelCandidateTranslationIfComposingChanges(p0) - return currentInputConnection.setComposingText(p0, p1) + return composingTextArbiter.setCanonical(p0, p1) } override fun setComposingRegion(p0: Int, p1: Int): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) return currentInputConnection.setComposingRegion(p0, p1) } override fun finishComposingText(): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) clearFunctionKeyConversionSource() cancelCandidateTranslationIfPreEditMutates() - return currentInputConnection.finishComposingText() + return composingTextArbiter.finishCanonical() } override fun commitText(p0: CharSequence?, p1: Int): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) clearFunctionKeyConversionSource() cancelCandidateTranslationIfPreEditMutates() - return currentInputConnection.commitText(p0, p1) + val committed = currentInputConnection.commitText(p0, p1) + if (committed) composingTextArbiter.markCanonicalFinished() + return committed } override fun commitCompletion(p0: CompletionInfo?): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) return currentInputConnection.commitCompletion(p0) } override fun commitCorrection(p0: CorrectionInfo?): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) return currentInputConnection.commitCorrection(p0) } override fun setSelection(p0: Int, p1: Int): Boolean { if (currentInputConnection == null) return false + flickInputPreviewCoordinator.cancel(restore = true) return currentInputConnection.setSelection(p0, p1) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt index 266768a39..e4f0dfd03 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/ImePreferencesSnapshot.kt @@ -21,6 +21,7 @@ data class ImePreferencesSnapshot( val mozcUTNeologd: Boolean, val mozcUTWeb: Boolean, val isFlickOnlyMode: Boolean, + val flickEditorPreviewPreference: Boolean, val isOmissionSearchEnable: Boolean, val delayTime: Int, val isLearnDictionaryMode: Boolean, @@ -289,6 +290,7 @@ data class ImePreferencesSnapshot( appPreference.mozc_ut_web_preference, ), isFlickOnlyMode = appPreference.flick_input_only_preference ?: false, + flickEditorPreviewPreference = appPreference.flick_editor_preview_preference, isOmissionSearchEnable = appPreference.omission_search_preference ?: false, delayTime = appPreference.time_same_pronounce_typing_preference ?: 1000, isLearnDictionaryMode = appPreference.learn_dictionary_preference ?: true, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/ComposingTextArbiter.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/ComposingTextArbiter.kt new file mode 100644 index 000000000..b02f70b11 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/ComposingTextArbiter.kt @@ -0,0 +1,80 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +internal sealed interface CanonicalComposingState { + data class Text( + val value: CharSequence, + val cursorPosition: Int, + ) : CanonicalComposingState + + data object Finished : CanonicalComposingState +} + +/** Keeps transient flick previews separate from the IME's canonical composing state. */ +internal class ComposingTextArbiter( + private val writeComposingText: (CharSequence?, Int) -> Boolean, + private val finishComposingText: () -> Boolean, + private val copyText: (CharSequence) -> CharSequence = { it.toString() }, +) { + private var canonicalState: CanonicalComposingState = CanonicalComposingState.Finished + private var previewVisible = false + + fun setCanonical(text: CharSequence?, cursorPosition: Int): Boolean { + val copied = copyText(text ?: "") + canonicalState = CanonicalComposingState.Text(copied, cursorPosition) + return if (previewVisible) true else writeComposingText(copied, cursorPosition) + } + + fun showPreview(text: CharSequence, cursorPosition: Int): Boolean { + val written = writeComposingText(copyText(text), cursorPosition) + previewVisible = written + return written + } + + fun suspendPreviewAndRestore(): Boolean { + if (!previewVisible) return true + previewVisible = false + return restoreCanonical() + } + + fun releasePreview(leaveDisplayedText: Boolean) { + if (!previewVisible) return + previewVisible = false + if (!leaveDisplayedText) restoreCanonical() + } + + fun cancelPreviewAndRestore(): Boolean { + if (!previewVisible) return true + previewVisible = false + return restoreCanonical() + } + + fun restoreCanonical(): Boolean { + return when (val state = canonicalState) { + is CanonicalComposingState.Text -> writeComposingText( + state.value, + state.cursorPosition, + ) + + // finishComposingText() would commit the currently displayed preview. Replacing the + // composing region with an empty value removes it and restores the no-composition + // state without inserting preview text into the editor. + CanonicalComposingState.Finished -> writeComposingText("", 0) + } + } + + fun finishCanonical(): Boolean { + canonicalState = CanonicalComposingState.Finished + return if (previewVisible) true else finishComposingText() + } + + fun markCanonicalFinished() { + canonicalState = CanonicalComposingState.Finished + } + + fun resetForEditorSession() { + previewVisible = false + canonicalState = CanonicalComposingState.Finished + } + + fun isPreviewVisible(): Boolean = previewVisible +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt new file mode 100644 index 000000000..845de5e4d --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt @@ -0,0 +1,177 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +import com.kazumaproject.core.domain.flick.FlickTextPreviewEvent +import com.kazumaproject.core.domain.flick.FlickTextSelection + +internal class FlickInputPreviewCoordinator( + private val composingTextArbiter: ComposingTextArbiter, + private val mutationResolver: ( + FlickMutationSnapshot, + FlickTextSelection, + ) -> FlickTextMutation = FlickTextMutationResolver::resolve, +) { + private data class ActivePreview( + val gestureId: Long, + val editorSessionId: Long, + val source: FlickPreviewSource, + val snapshot: FlickMutationSnapshot, + var lastSelection: FlickTextSelection, + var lastMutation: FlickTextMutation, + var pendingCommitConsumed: Boolean = false, + var previewWasReleased: Boolean = false, + ) + + private var active: ActivePreview? = null + + fun onEvent(event: FlickTextPreviewEvent, context: FlickPreviewContext) { + when (event) { + is FlickTextPreviewEvent.Started -> start(event, context) + is FlickTextPreviewEvent.Changed -> update(event, context) + is FlickTextPreviewEvent.CommitPending -> prepareCommit(event, context) + is FlickTextPreviewEvent.Finished -> finish(event, context) + is FlickTextPreviewEvent.Canceled -> cancelGesture(event, context) + } + } + + fun consumePendingCommit(text: String, isFlick: Boolean): FlickTextMutation.ReplaceComposingInput? { + val current = active ?: return null + if (!current.previewWasReleased || current.pendingCommitConsumed) return null + val mutation = current.lastMutation as? FlickTextMutation.ReplaceComposingInput ?: return null + if (mutation.selectedText != text || mutation.isFlick != isFlick) return null + current.pendingCommitConsumed = true + return mutation + } + + fun cancel(restore: Boolean) { + active?.let { current -> + if (restore) { + if (current.previewWasReleased) { + composingTextArbiter.restoreCanonical() + } else { + composingTextArbiter.cancelPreviewAndRestore() + } + } else { + composingTextArbiter.releasePreview(leaveDisplayedText = true) + } + } + active = null + } + + fun resetForEditorSession() { + active = null + composingTextArbiter.resetForEditorSession() + } + + private fun start( + event: FlickTextPreviewEvent.Started, + context: FlickPreviewContext, + ) { + cancel(restore = true) + if (!FlickPreviewEligibilityPolicy.isEligible(context)) return + + val snapshot = FlickMutationSnapshot( + baseInput = context.baseInput, + isFlickOnlyMode = context.isFlickOnlyMode, + isContinuousTapInputEnabled = context.isContinuousTapInputEnabled, + lastFlickConvertedNextHiragana = context.lastFlickConvertedNextHiragana, + ) + val mutation = mutationResolver(snapshot, event.selection) + active = ActivePreview( + gestureId = event.gestureId, + editorSessionId = context.editorSessionId, + source = context.source, + snapshot = snapshot, + lastSelection = event.selection, + lastMutation = mutation, + ) + renderMutation(mutation) + } + + private fun update( + event: FlickTextPreviewEvent.Changed, + context: FlickPreviewContext, + ) { + val current = matchingActive(event.gestureId, context) ?: return + val mutation = mutationResolver(current.snapshot, event.selection) + current.lastSelection = event.selection + current.lastMutation = mutation + renderMutation(mutation) + } + + private fun prepareCommit( + event: FlickTextPreviewEvent.CommitPending, + context: FlickPreviewContext, + ) { + val current = matchingActive(event.gestureId, context) ?: return + val previousMutation = current.lastMutation + val mutation = mutationResolver(current.snapshot, event.selection) + current.lastSelection = event.selection + current.lastMutation = mutation + current.pendingCommitConsumed = false + + when (mutation) { + is FlickTextMutation.ReplaceComposingInput -> { + val previousResult = + (previousMutation as? FlickTextMutation.ReplaceComposingInput)?.resultInput + val needsEditorUpdate = !composingTextArbiter.isPreviewVisible() || + previousResult != mutation.resultInput + if (needsEditorUpdate && + !composingTextArbiter.showPreview(mutation.resultInput, 1) + ) { + active = null + return + } + composingTextArbiter.releasePreview(leaveDisplayedText = true) + current.previewWasReleased = true + } + + FlickTextMutation.NoTextOutput -> { + composingTextArbiter.cancelPreviewAndRestore() + current.previewWasReleased = false + } + } + } + + private fun finish( + event: FlickTextPreviewEvent.Finished, + context: FlickPreviewContext, + ) { + val current = matchingActive(event.gestureId, context) ?: return + if (current.previewWasReleased && !current.pendingCommitConsumed) { + composingTextArbiter.restoreCanonical() + } + active = null + } + + private fun cancelGesture( + event: FlickTextPreviewEvent.Canceled, + context: FlickPreviewContext, + ) { + matchingActive(event.gestureId, context) ?: return + composingTextArbiter.cancelPreviewAndRestore() + active = null + } + + private fun matchingActive( + gestureId: Long, + context: FlickPreviewContext, + ): ActivePreview? { + return active?.takeIf { + it.gestureId == gestureId && + it.editorSessionId == context.editorSessionId && + it.source == context.source + } + } + + private fun renderMutation(mutation: FlickTextMutation) { + when (mutation) { + is FlickTextMutation.ReplaceComposingInput -> { + if (!composingTextArbiter.showPreview(mutation.resultInput, 1)) { + active = null + } + } + + FlickTextMutation.NoTextOutput -> composingTextArbiter.suspendPreviewAndRestore() + } + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt new file mode 100644 index 000000000..0d26b6226 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt @@ -0,0 +1,38 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +internal enum class FlickPreviewSource { + TENKEY, + SUMIRE, +} + +internal data class FlickPreviewContext( + val source: FlickPreviewSource, + val editorSessionId: Long, + val settingEnabled: Boolean, + val surfaceEligible: Boolean, + val inputBehaviorUsesComposingText: Boolean, + val safeInputType: Boolean, + val isHenkan: Boolean, + val selectMode: Boolean, + val cursorMoveMode: Boolean, + val hasComposingTail: Boolean, + val hasInputConnection: Boolean, + val baseInput: String, + val isFlickOnlyMode: Boolean, + val isContinuousTapInputEnabled: Boolean, + val lastFlickConvertedNextHiragana: Boolean, +) + +internal object FlickPreviewEligibilityPolicy { + fun isEligible(context: FlickPreviewContext): Boolean { + return context.settingEnabled && + context.surfaceEligible && + context.inputBehaviorUsesComposingText && + context.safeInputType && + !context.isHenkan && + !context.selectMode && + !context.cursorMoveMode && + !context.hasComposingTail && + context.hasInputConnection + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolver.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolver.kt new file mode 100644 index 000000000..c9c88212e --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolver.kt @@ -0,0 +1,91 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +import com.kazumaproject.core.domain.flick.FlickTextSelection +import com.kazumaproject.tenkey.extensions.getNextInputChar + +internal data class FlickMutationSnapshot( + val baseInput: String, + val isFlickOnlyMode: Boolean, + val isContinuousTapInputEnabled: Boolean, + val lastFlickConvertedNextHiragana: Boolean, +) + +internal data class FlickInputEffects( + val continuousTapInputEnabled: Boolean?, + val lastFlickConvertedNextHiragana: Boolean?, +) + +internal sealed interface FlickTextMutation { + data class ReplaceComposingInput( + val selectedText: String, + val isFlick: Boolean, + val resultInput: String, + val effects: FlickInputEffects, + ) : FlickTextMutation + + data object NoTextOutput : FlickTextMutation +} + +internal object FlickTextMutationResolver { + fun resolve( + snapshot: FlickMutationSnapshot, + selection: FlickTextSelection, + ): FlickTextMutation { + val selectedText = selection.text?.takeIf(String::isNotEmpty) + ?: return FlickTextMutation.NoTextOutput + + if (selectedText.length != 1) { + return FlickTextMutation.ReplaceComposingInput( + selectedText = selectedText, + isFlick = selection.isFlick, + resultInput = snapshot.baseInput + selectedText, + effects = FlickInputEffects( + continuousTapInputEnabled = null, + lastFlickConvertedNextHiragana = null, + ), + ) + } + + val selectedChar = selectedText.first() + val shouldAppend = selection.isFlick || + snapshot.isFlickOnlyMode || + (snapshot.isContinuousTapInputEnabled && + snapshot.lastFlickConvertedNextHiragana) + + val result = if (shouldAppend || snapshot.baseInput.isEmpty()) { + snapshot.baseInput + selectedChar + } else { + val nextChar = snapshot.baseInput.last().getNextInputChar(selectedChar) + if (nextChar == null) { + snapshot.baseInput + selectedChar + } else { + snapshot.baseInput.dropLast(1) + nextChar + } + } + + val effects = when { + selection.isFlick || snapshot.isFlickOnlyMode -> FlickInputEffects( + continuousTapInputEnabled = true, + lastFlickConvertedNextHiragana = true, + ) + + snapshot.isContinuousTapInputEnabled && + snapshot.lastFlickConvertedNextHiragana -> FlickInputEffects( + continuousTapInputEnabled = true, + lastFlickConvertedNextHiragana = false, + ) + + else -> FlickInputEffects( + continuousTapInputEnabled = false, + lastFlickConvertedNextHiragana = false, + ) + } + + return FlickTextMutation.ReplaceComposingInput( + selectedText = selectedText, + isFlick = selection.isFlick, + resultInput = result, + effects = effects, + ) + } +} diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt index 50ba89748..4bbad17db 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/AppPreference.kt @@ -67,6 +67,7 @@ object AppPreference { "gemma_handwriting_pen_color_preference" const val FLICK_SENSITIVITY_KEY = "flick_sensitivity_preference" const val FLICK_THRESHOLD_SHAPE_KEY = "flick_threshold_shape_preference" + const val FLICK_EDITOR_PREVIEW_KEY = "flick_editor_preview_preference" const val TENKEY_KEYMAP_GUIDE_JAPANESE_KEY = "tenkey_keymap_guide" const val TENKEY_KEYMAP_GUIDE_ENGLISH_KEY = "tenkey_keymap_guide_english" const val TENKEY_KEYMAP_GUIDE_NUMBER_KEY = "tenkey_keymap_guide_number" @@ -334,6 +335,7 @@ object AppPreference { Pair("candidate_view_empty_height_dp_landscape_preference", 110) private val FLICK_INPUT_ONLY = Pair("flick_input_only_preference", false) + private val FLICK_EDITOR_PREVIEW = Pair(FLICK_EDITOR_PREVIEW_KEY, false) private val OMISSION_SEARCH = Pair("omission_search_preference", false) private val UNDO_ENABLE = Pair("undo_enable_preference", false) private val SPACE_HANKAKU_ENABLE = Pair("space_key_preference", false) @@ -1446,8 +1448,15 @@ object AppPreference { var keyboard_order: List get() { val json = preferences.getString(KEYBOARD_ORDER.first, KEYBOARD_ORDER.second) - val type = object : TypeToken>() {}.type - return gson.fromJson(json, type) + val type = object : TypeToken>() {}.type + return runCatching { + gson.fromJson>(json, type) + .orEmpty() + .filterNotNull() + .ifEmpty { listOf(KeyboardType.TENKEY, KeyboardType.QWERTY) } + }.getOrElse { + listOf(KeyboardType.TENKEY, KeyboardType.QWERTY) + } } set(value) = preferences.edit { val json = gson.toJson(value) @@ -2111,6 +2120,15 @@ object AppPreference { it.putBoolean(FLICK_INPUT_ONLY.first, value ?: false) } + var flick_editor_preview_preference: Boolean + get() = preferences.getBoolean( + FLICK_EDITOR_PREVIEW.first, + FLICK_EDITOR_PREVIEW.second + ) + set(value) = preferences.edit { + it.putBoolean(FLICK_EDITOR_PREVIEW.first, value) + } + var undo_enable_preference: Boolean? get() = preferences.getBoolean(UNDO_ENABLE.first, UNDO_ENABLE.second) set(value) = preferences.edit { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingDestination.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingDestination.kt index 151a24d75..d45b5855d 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingDestination.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/setting_activity/ui/setting/SettingDestination.kt @@ -496,6 +496,7 @@ object SettingDestinations { "setting_route_custom_keyboard_preferences", "setting_route_tablet_preferences", "flick_input_only_preference", + "flick_editor_preview_preference", "flick_sensitivity_preference", "flick_threshold_shape_preference", "long_press_timeout_preference", diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 8e1ba5c8a..bbdb55844 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -155,6 +155,7 @@ 削除キータップ：ハイライト解除 機能 + フリック入力 ローマ字変換 QWERTY キーボード 記号キーボード @@ -181,6 +182,9 @@ フリック・トグル入力 フリック入力のみを使用し、トグル入力を無効にする トグル入力を有効にします + 入力欄でフリック文字をプレビュー + 従来方式：指を離したときに文字を入力します + TenKey・Sumireで、選択中のタップ／フリック文字を入力欄に仮表示します 元に戻す機能 元に戻す機能を無効にする 読みを戻す diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c5ef85df1..cefb3a57e 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -153,6 +153,7 @@ Long press Delete: Unhighlight\nTap Delete: Move selection back one place Tap Delete: Unhighlight Features + Flick input Romaji Conversion QWERTY Keyboard Symbol Keyboard @@ -179,6 +180,9 @@ Flick/Toggle Input Use only flick input and disable toggle input Enable toggle input + Preview flick characters in the text field + Enter the character when you release the key + Preview the selected tap or flick text while holding a TenKey or Sumire key Undo Function Disable the undo function Restore Reading diff --git a/app/src/main/res/xml/pref_common_legacy.xml b/app/src/main/res/xml/pref_common_legacy.xml index 7bc0a1016..558c8d9e8 100644 --- a/app/src/main/res/xml/pref_common_legacy.xml +++ b/app/src/main/res/xml/pref_common_legacy.xml @@ -455,6 +455,42 @@ + + + + + + + + + + + + - - - - - diff --git a/app/src/main/res/xml/pref_operation_feedback.xml b/app/src/main/res/xml/pref_operation_feedback.xml index 944baaf86..ae9277612 100644 --- a/app/src/main/res/xml/pref_operation_feedback.xml +++ b/app/src/main/res/xml/pref_operation_feedback.xml @@ -2,7 +2,7 @@ - + + + + + + + () + val arbiter = arbiter(writes) + arbiter.setCanonical("か", 1) + arbiter.showPreview("かあ", 1) + + assertTrue(arbiter.setCanonical("最新", 1)) + assertEquals(listOf("text:か:1", "text:かあ:1"), writes) + + arbiter.cancelPreviewAndRestore() + assertEquals("text:最新:1", writes.last()) + } + + @Test + fun suspendedPreviewRestoresCanonicalAndCanResume() { + val writes = mutableListOf() + val arbiter = arbiter(writes) + arbiter.setCanonical("か", 1) + arbiter.showPreview("かあ", 1) + arbiter.suspendPreviewAndRestore() + arbiter.showPreview("かう", 1) + + assertEquals( + listOf("text:か:1", "text:かあ:1", "text:か:1", "text:かう:1"), + writes, + ) + } + + @Test + fun releaseKeepsPreviewDisplayed() { + val writes = mutableListOf() + val arbiter = arbiter(writes) + arbiter.setCanonical("か", 1) + arbiter.showPreview("かあ", 1) + + arbiter.releasePreview(leaveDisplayedText = true) + + assertEquals("text:かあ:1", writes.last()) + assertEquals(2, writes.size) + } + + @Test + fun cancelFromNoCanonicalCompositionRemovesPreviewInsteadOfFinishingIt() { + val writes = mutableListOf() + val arbiter = arbiter(writes) + arbiter.showPreview("あ", 1) + + arbiter.cancelPreviewAndRestore() + + assertEquals(listOf("text:あ:1", "text::0"), writes) + } + + private fun arbiter(writes: MutableList) = ComposingTextArbiter( + writeComposingText = { text, cursor -> + writes += "text:$text:$cursor" + true + }, + finishComposingText = { + writes += "finish" + true + }, + ) +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt new file mode 100644 index 000000000..9abc70111 --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt @@ -0,0 +1,113 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +import com.kazumaproject.core.domain.flick.FlickTextPreviewEvent +import com.kazumaproject.core.domain.flick.FlickTextSelection +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Test + +class FlickInputPreviewCoordinatorTest { + @Test + fun downMoveCancelOnlyChangesEditorPreview() { + val fixture = Fixture() + fixture.arbiter.setCanonical("か", 1) + + fixture.coordinator.onEvent(started("あ"), fixture.context(baseInput = "か")) + fixture.coordinator.onEvent(changed("う"), fixture.context(baseInput = "か")) + fixture.coordinator.onEvent(canceled(), fixture.context(baseInput = "か")) + + assertEquals( + listOf("text:か:1", "text:かあ:1", "text:かう:1", "text:か:1"), + fixture.writes, + ) + } + + @Test + fun matchingCommitCanConsumeExactPreviewMutation() { + val fixture = Fixture() + fixture.arbiter.setCanonical("あ", 1) + fixture.coordinator.onEvent(started("あ"), fixture.context(baseInput = "あ")) + fixture.coordinator.onEvent(commit("あ"), fixture.context(baseInput = "あ")) + + val mutation = fixture.coordinator.consumePendingCommit("あ", false) + fixture.coordinator.onEvent(finished(), fixture.context(baseInput = "あ")) + + assertNotNull(mutation) + assertEquals("い", mutation?.resultInput) + assertEquals("text:い:1", fixture.writes.last()) + } + + @Test + fun unconsumedCommitRestoresCanonicalOnFinished() { + val fixture = Fixture() + fixture.arbiter.setCanonical("か", 1) + fixture.coordinator.onEvent(started("あ"), fixture.context(baseInput = "か")) + fixture.coordinator.onEvent(commit("あ"), fixture.context(baseInput = "か")) + fixture.coordinator.onEvent(finished(), fixture.context(baseInput = "か")) + + assertEquals("text:か:1", fixture.writes.last()) + } + + @Test + fun staleSessionAndMismatchedCommitAreIgnored() { + val fixture = Fixture() + fixture.arbiter.setCanonical("か", 1) + fixture.coordinator.onEvent(started("あ"), fixture.context(baseInput = "か")) + fixture.coordinator.onEvent(changed("う"), fixture.context(sessionId = 2L)) + + assertNull(fixture.coordinator.consumePendingCommit("別", false)) + assertEquals("text:かあ:1", fixture.writes.last()) + } + + private class Fixture { + val writes = mutableListOf() + val arbiter = ComposingTextArbiter( + writeComposingText = { text, cursor -> + writes += "text:$text:$cursor" + true + }, + finishComposingText = { + writes += "finish" + true + }, + ) + val coordinator = FlickInputPreviewCoordinator(arbiter) + + fun context(baseInput: String = "", sessionId: Long = 1L) = FlickPreviewContext( + source = FlickPreviewSource.TENKEY, + editorSessionId = sessionId, + settingEnabled = true, + surfaceEligible = true, + inputBehaviorUsesComposingText = true, + safeInputType = true, + isHenkan = false, + selectMode = false, + cursorMoveMode = false, + hasComposingTail = false, + hasInputConnection = true, + baseInput = baseInput, + isFlickOnlyMode = false, + isContinuousTapInputEnabled = false, + lastFlickConvertedNextHiragana = false, + ) + } + + private fun started(text: String) = FlickTextPreviewEvent.Started( + gestureId = 1L, + selection = FlickTextSelection(text, false), + ) + + private fun changed(text: String) = FlickTextPreviewEvent.Changed( + gestureId = 1L, + selection = FlickTextSelection(text, true), + ) + + private fun commit(text: String) = FlickTextPreviewEvent.CommitPending( + gestureId = 1L, + selection = FlickTextSelection(text, false), + ) + + private fun finished() = FlickTextPreviewEvent.Finished(gestureId = 1L) + private fun canceled() = FlickTextPreviewEvent.Canceled(gestureId = 1L) +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt new file mode 100644 index 000000000..f4a5665f5 --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt @@ -0,0 +1,59 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class FlickPreviewEligibilityPolicyTest { + @Test + fun eligibleContextIsAccepted() { + assertTrue(FlickPreviewEligibilityPolicy.isEligible(context())) + } + + @Test + fun settingSurfaceDirectAndUnsafeEditorAreRejected() { + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(settingEnabled = false))) + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(surfaceEligible = false))) + assertFalse( + FlickPreviewEligibilityPolicy.isEligible( + context(inputBehaviorUsesComposingText = false) + ) + ) + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(safeInputType = false))) + } + + @Test + fun conversionSelectionCursorAndTailStatesAreRejected() { + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(isHenkan = true))) + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(selectMode = true))) + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(cursorMoveMode = true))) + assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(hasComposingTail = true))) + } + + private fun context( + settingEnabled: Boolean = true, + surfaceEligible: Boolean = true, + inputBehaviorUsesComposingText: Boolean = true, + safeInputType: Boolean = true, + isHenkan: Boolean = false, + selectMode: Boolean = false, + cursorMoveMode: Boolean = false, + hasComposingTail: Boolean = false, + ) = FlickPreviewContext( + source = FlickPreviewSource.TENKEY, + editorSessionId = 1L, + settingEnabled = settingEnabled, + surfaceEligible = surfaceEligible, + inputBehaviorUsesComposingText = inputBehaviorUsesComposingText, + safeInputType = safeInputType, + isHenkan = isHenkan, + selectMode = selectMode, + cursorMoveMode = cursorMoveMode, + hasComposingTail = hasComposingTail, + hasInputConnection = true, + baseInput = "", + isFlickOnlyMode = false, + isContinuousTapInputEnabled = false, + lastFlickConvertedNextHiragana = false, + ) +} diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolverTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolverTest.kt new file mode 100644 index 000000000..e8282a41a --- /dev/null +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickTextMutationResolverTest.kt @@ -0,0 +1,83 @@ +package com.kazumaproject.markdownhelperkeyboard.ime_service.flick_preview + +import com.kazumaproject.core.domain.flick.FlickTextSelection +import org.junit.Assert.assertEquals +import org.junit.Test + +class FlickTextMutationResolverTest { + @Test + fun emptyInputTapAppendsCharacter() { + val mutation = resolve(baseInput = "", text = "あ", isFlick = false) + + assertEquals("あ", mutation.resultInput) + assertEquals(false, mutation.effects.continuousTapInputEnabled) + assertEquals(false, mutation.effects.lastFlickConvertedNextHiragana) + } + + @Test + fun repeatedTapUsesExistingToggleRule() { + val mutation = resolve(baseInput = "あ", text = "あ", isFlick = false) + + assertEquals("い", mutation.resultInput) + } + + @Test + fun flickAndFlickOnlyTapAppend() { + assertEquals( + "かあ", + resolve(baseInput = "か", text = "あ", isFlick = true).resultInput, + ) + assertEquals( + "かあ", + resolve( + baseInput = "か", + text = "あ", + isFlick = false, + isFlickOnlyMode = true, + ).resultInput, + ) + } + + @Test + fun firstTapAfterFlickAppendsThenClearsLastFlickFlag() { + val mutation = resolve( + baseInput = "か", + text = "あ", + isFlick = false, + continuous = true, + lastFlick = true, + ) + + assertEquals("かあ", mutation.resultInput) + assertEquals(true, mutation.effects.continuousTapInputEnabled) + assertEquals(false, mutation.effects.lastFlickConvertedNextHiragana) + } + + @Test + fun multiCharacterSumireOutputAppendsWithoutChangingTapFlags() { + val mutation = resolve(baseInput = "か", text = "abc", isFlick = true) + + assertEquals("かabc", mutation.resultInput) + assertEquals(null, mutation.effects.continuousTapInputEnabled) + assertEquals(null, mutation.effects.lastFlickConvertedNextHiragana) + } + + private fun resolve( + baseInput: String, + text: String, + isFlick: Boolean, + isFlickOnlyMode: Boolean = false, + continuous: Boolean = false, + lastFlick: Boolean = false, + ): FlickTextMutation.ReplaceComposingInput { + return FlickTextMutationResolver.resolve( + snapshot = FlickMutationSnapshot( + baseInput = baseInput, + isFlickOnlyMode = isFlickOnlyMode, + isContinuousTapInputEnabled = continuous, + lastFlickConvertedNextHiragana = lastFlick, + ), + selection = FlickTextSelection(text, isFlick), + ) as FlickTextMutation.ReplaceComposingInput + } +} diff --git a/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitter.kt b/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitter.kt new file mode 100644 index 000000000..b4d396fa7 --- /dev/null +++ b/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitter.kt @@ -0,0 +1,60 @@ +package com.kazumaproject.core.domain.flick + +class FlickTextPreviewEmitter { + var listener: FlickTextPreviewListener? = null + + private var nextGestureId = 1L + private var activeGestureId: Long? = null + private var lastSelection: FlickTextSelection? = null + + fun begin(selection: FlickTextSelection) { + cancel() + val normalized = selection.normalized() + val gestureId = nextGestureId++ + activeGestureId = gestureId + lastSelection = normalized + listener?.onFlickTextPreview( + FlickTextPreviewEvent.Started(gestureId, normalized) + ) + } + + fun update(selection: FlickTextSelection) { + val gestureId = activeGestureId ?: return + val normalized = selection.normalized() + if (normalized == lastSelection) return + lastSelection = normalized + listener?.onFlickTextPreview( + FlickTextPreviewEvent.Changed(gestureId, normalized) + ) + } + + fun commit(selection: FlickTextSelection, dispatch: () -> Unit) { + val gestureId = activeGestureId + if (gestureId == null) { + dispatch() + return + } + val normalized = selection.normalized() + lastSelection = normalized + listener?.onFlickTextPreview( + FlickTextPreviewEvent.CommitPending(gestureId, normalized) + ) + try { + dispatch() + } finally { + listener?.onFlickTextPreview(FlickTextPreviewEvent.Finished(gestureId)) + clear() + } + } + + fun cancel() { + val gestureId = activeGestureId ?: return + listener?.onFlickTextPreview(FlickTextPreviewEvent.Canceled(gestureId)) + clear() + } + + private fun clear() { + activeGestureId = null + lastSelection = null + } +} diff --git a/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEvent.kt b/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEvent.kt new file mode 100644 index 000000000..a08c78c22 --- /dev/null +++ b/core/src/main/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEvent.kt @@ -0,0 +1,39 @@ +package com.kazumaproject.core.domain.flick + +data class FlickTextSelection( + val text: String?, + val isFlick: Boolean, +) { + fun normalized(): FlickTextSelection = copy(text = text?.takeIf(String::isNotEmpty)) +} + +sealed interface FlickTextPreviewEvent { + val gestureId: Long + + data class Started( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class Changed( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class CommitPending( + override val gestureId: Long, + val selection: FlickTextSelection, + ) : FlickTextPreviewEvent + + data class Finished( + override val gestureId: Long, + ) : FlickTextPreviewEvent + + data class Canceled( + override val gestureId: Long, + ) : FlickTextPreviewEvent +} + +fun interface FlickTextPreviewListener { + fun onFlickTextPreview(event: FlickTextPreviewEvent) +} diff --git a/core/src/test/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitterTest.kt b/core/src/test/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitterTest.kt new file mode 100644 index 000000000..f49af25ba --- /dev/null +++ b/core/src/test/java/com/kazumaproject/core/domain/flick/FlickTextPreviewEmitterTest.kt @@ -0,0 +1,45 @@ +package com.kazumaproject.core.domain.flick + +import org.junit.Assert.assertEquals +import org.junit.Test + +class FlickTextPreviewEmitterTest { + @Test + fun emitsLifecycleAndSuppressesDuplicateSelection() { + val events = mutableListOf() + val emitter = FlickTextPreviewEmitter().apply { + listener = FlickTextPreviewListener(events::add) + } + + emitter.begin(FlickTextSelection("あ", false)) + emitter.update(FlickTextSelection("あ", false)) + emitter.update(FlickTextSelection("い", true)) + emitter.commit(FlickTextSelection("い", true)) { + events += FlickTextPreviewEvent.Finished(-1L) + } + + assertEquals(5, events.size) + assert(events[0] is FlickTextPreviewEvent.Started) + assert(events[1] is FlickTextPreviewEvent.Changed) + assert(events[2] is FlickTextPreviewEvent.CommitPending) + assertEquals(-1L, events[3].gestureId) + assert(events[4] is FlickTextPreviewEvent.Finished) + } + + @Test + fun cancelEndsGestureAndEmptyTextIsNormalized() { + val events = mutableListOf() + val emitter = FlickTextPreviewEmitter().apply { + listener = FlickTextPreviewListener(events::add) + } + + emitter.begin(FlickTextSelection("", false)) + emitter.cancel() + emitter.update(FlickTextSelection("い", true)) + + val started = events[0] as FlickTextPreviewEvent.Started + assertEquals(null, started.selection.text) + assert(events[1] is FlickTextPreviewEvent.Canceled) + assertEquals(2, events.size) + } +} diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt index 7ce81a17e..427884ffc 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CrossFlickInputController.kt @@ -85,6 +85,8 @@ class CrossFlickInputController( action: KeyAction, direction: FlickDirection ) {} + fun onTextSelectionChanged(text: String?, isFlick: Boolean) {} + fun onCanceled() {} } private enum class InputMode { @@ -177,6 +179,7 @@ class CrossFlickInputController( // コントローラを破棄する。ビューのデタッチやキーボードビューの再構築時に FlickKeyboardView から呼ばれる。 fun cancel() { + listener?.onCanceled() activeGestureConfig = null longPressJob?.cancel() controllerScope.cancel() @@ -275,6 +278,12 @@ class CrossFlickInputController( } else { updateNormalPopup(newDirection) } + if (inputMode == InputMode.TEXT) { + listener?.onTextSelectionChanged( + resolveText(currentDirection, preferLongPress = isLongPressMode), + currentDirection != FlickDirection.TAP + ) + } } return true } @@ -288,6 +297,7 @@ class CrossFlickInputController( commitAction() } else { notifyLongPressCanceledIfNeeded() + listener?.onCanceled() } restoreOriginalButtonText() @@ -316,6 +326,10 @@ class CrossFlickInputController( showGridPopup() highlightGrid(currentDirection) } + listener?.onTextSelectionChanged( + resolveText(currentDirection, preferLongPress = true), + currentDirection != FlickDirection.TAP + ) } } } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt index c4d104abb..96a8a22d3 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/CustomAngleFlickController.kt @@ -53,6 +53,8 @@ class CustomAngleFlickController( fun onFlick(direction: CircularFlickDirection, action: FlickAction) fun onStateChanged(view: View, newMap: Map) fun onFlickDirectionChanged(newDirection: CircularFlickDirection) + fun onSelectionChanged(action: FlickAction?, isFlick: Boolean) {} + fun onCanceled() {} } var listener: FlickListener? = null @@ -148,6 +150,7 @@ class CustomAngleFlickController( } fun cancel() { + listener?.onCanceled() activeGestureConfig = null hidePopup() controllerScope.cancel() @@ -273,6 +276,10 @@ class CustomAngleFlickController( popupView.updateFlickDirection(currentDirection) previousDirection = currentDirection } + listener?.onSelectionChanged( + keyMaps.getOrNull(currentMapIndex)?.get(currentDirection), + currentDirection != CircularFlickDirection.TAP + ) return true } @@ -315,6 +322,7 @@ class CustomAngleFlickController( previousDirection = CircularFlickDirection.TAP hidePopup() activeGestureConfig = null + listener?.onCanceled() return true } } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt index 62f34da86..14ab0fd2c 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/StandardFlickInputController.kt @@ -41,6 +41,8 @@ class StandardFlickInputController( interface StandardFlickListener { fun onPress(character: String) fun onFlick(character: String) + fun onSelectionChanged(character: String?, isFlick: Boolean) {} + fun onCanceled() {} } var listener: StandardFlickListener? = null @@ -143,6 +145,10 @@ class StandardFlickInputController( val direction = calculateDirection(dx, dy) segmentedDrawable?.highlightDirection = direction showPopup(direction) + listener?.onSelectionChanged( + characterMap[direction]?.takeIf(String::isNotEmpty), + direction != FlickDirection.TAP + ) return true } @@ -166,6 +172,7 @@ class StandardFlickInputController( dismissPopup() anchorView = null activeGestureConfig = null + listener?.onCanceled() return true } } @@ -244,6 +251,7 @@ class StandardFlickInputController( } fun cancel() { + listener?.onCanceled() activeGestureConfig = null dismissPopup() } diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt index 70db944c7..786e218c2 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiHierarchicalFlickController.kt @@ -55,6 +55,8 @@ class TfbiHierarchicalFlickController( interface TfbiListener { fun onPress(character: String) fun onFlick(character: String) + fun onSelectionChanged(character: String?, isFlick: Boolean) {} + fun onCanceled() {} /** * コントローラーの内部状態が変更されたことを通知します。 @@ -184,6 +186,7 @@ class TfbiHierarchicalFlickController( * コントローラーを View からデタッチし、リソースを解放します。 */ fun cancel() { + listener?.onCanceled() resetState() attachedView?.setOnTouchListener(null) attachedView = null @@ -197,7 +200,10 @@ class TfbiHierarchicalFlickController( MotionEvent.ACTION_DOWN -> handleTouchDown(event, view) MotionEvent.ACTION_MOVE -> handleTouchMove(event, view) MotionEvent.ACTION_UP -> handleTouchUp(event) - MotionEvent.ACTION_CANCEL -> resetState() + MotionEvent.ACTION_CANCEL -> { + listener?.onCanceled() + resetState() + } } return true } @@ -278,12 +284,14 @@ class TfbiHierarchicalFlickController( setupStageUI(currentMap!!) popupView?.highlightDirection(currentHighlight) + notifySelectionChanged() return // イベント処理終了 } } // --- 通常の "Sticky" 動作 --- popupView?.highlightDirection(currentHighlight) + notifySelectionChanged() return } @@ -351,6 +359,7 @@ class TfbiHierarchicalFlickController( Log.e(TAG, "Illegal state: StatefulKey found inside a flick map during Move.") } } + notifySelectionChanged() } private fun handleTouchUp(event: MotionEvent) { @@ -394,6 +403,23 @@ class TfbiHierarchicalFlickController( resetState() } + private fun notifySelectionChanged() { + listener?.onSelectionChanged( + resolveCurrentOutput(), + mapStack.size > 1 || currentHighlight != TfbiFlickDirection.TAP + ) + } + + private fun resolveCurrentOutput(): String? { + val map = currentMap ?: return null + return when (val node = map[currentHighlight]) { + is TfbiFlickNode.Input -> node.char + is TfbiFlickNode.SubMenu -> + (node.nextMap[TfbiFlickDirection.TAP] as? TfbiFlickNode.Input)?.char + else -> null + }?.takeIf(String::isNotEmpty) + } + private fun updateInternalState(newMode: KeyMode?, event: MotionEvent) { // 状態遷移のトリガーがなければ何もしない if (newMode == null) return diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt index 452f03b8e..bdb8e0360 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/controller/TfbiInputController.kt @@ -50,6 +50,12 @@ class TfbiInputController( fun onPress(first: TfbiFlickDirection, second: TfbiFlickDirection) fun onFlick(first: TfbiFlickDirection, second: TfbiFlickDirection) fun onLongPressFlick(first: TfbiFlickDirection, second: TfbiFlickDirection): Boolean = false + fun onSelectionChanged( + first: TfbiFlickDirection, + second: TfbiFlickDirection, + isLongPress: Boolean, + ) {} + fun onCanceled() {} } private enum class FlickState { NEUTRAL, FIRST_FLICK_DETERMINED } @@ -90,6 +96,11 @@ class TfbiInputController( isLongPressModeActive = true popupWindow?.dismiss() showPopup(view, TfbiFlickDirection.TAP, true) + listener?.onSelectionChanged( + TfbiFlickDirection.TAP, + TfbiFlickDirection.TAP, + true + ) } // ▼▼▼ 追加: 色設定保持用の変数 ▼▼▼ @@ -137,6 +148,7 @@ class TfbiInputController( } fun cancel() { + listener?.onCanceled() activeGestureConfig = null clearLongPressCallback(attachedView) isTouchActive = false @@ -167,6 +179,7 @@ class TfbiInputController( clearLongPressCallback(attachedView) resetState() activeGestureConfig = null + listener?.onCanceled() } } return true @@ -220,6 +233,11 @@ class TfbiInputController( } resetState() showPopup(view, TfbiFlickDirection.TAP, false) + listener?.onSelectionChanged( + TfbiFlickDirection.TAP, + TfbiFlickDirection.TAP, + false + ) return } val dx = event.x - intermediateTouchX @@ -238,6 +256,11 @@ class TfbiInputController( currentSecondFlickDirection = highlightTargetDirection } } + listener?.onSelectionChanged( + firstFlickDirection, + currentSecondFlickDirection, + isLongPressModeActive + ) } private fun handleTouchUp(event: MotionEvent) { diff --git a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt index b2daab04e..094ceb49a 100644 --- a/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt +++ b/custom_keyboard/src/main/java/com/kazumaproject/custom_keyboard/view/FlickKeyboardView.kt @@ -83,6 +83,9 @@ import com.kazumaproject.custom_keyboard.data.toCircularFlickKeyMaps import com.kazumaproject.custom_keyboard.data.toLegacyFlickDirection import com.kazumaproject.custom_keyboard.data.toSumireSpecialKeyDirectionOrNull import com.kazumaproject.custom_keyboard.layout.SegmentedBackgroundDrawable +import com.kazumaproject.core.domain.flick.FlickTextPreviewEmitter +import com.kazumaproject.core.domain.flick.FlickTextPreviewListener +import com.kazumaproject.core.domain.flick.FlickTextSelection import java.util.IdentityHashMap import kotlin.math.abs import kotlin.math.roundToInt @@ -110,6 +113,8 @@ class FlickKeyboardView @JvmOverloads constructor( } private var listener: OnKeyboardActionListener? = null + private val flickTextPreviewEmitter = FlickTextPreviewEmitter() + private var previewKeyData: KeyData? = null private val flickControllers = mutableListOf() private val crossFlickControllers = mutableListOf() private val standardFlickControllers = mutableListOf() @@ -238,6 +243,10 @@ class FlickKeyboardView @JvmOverloads constructor( this.listener = listener } + fun setOnFlickTextPreviewListener(listener: FlickTextPreviewListener?) { + flickTextPreviewEmitter.listener = listener + } + /** * Updates text-producing key labels without rebuilding the keyboard or changing canonical * [KeyData]. This preserves active gesture recognizers, including the second Shift tap. @@ -1485,7 +1494,7 @@ class FlickKeyboardView @JvmOverloads constructor( this.listener = object : CustomAngleFlickController.FlickListener { override fun onPress(action: FlickAction?) { when (action) { - is FlickAction.Input -> notifyTextPress(action.char) + is FlickAction.Input -> notifyTextPress(keyData, action.char) is FlickAction.Action -> this@FlickKeyboardView.listener?.onPress( action.action ) @@ -1539,6 +1548,15 @@ class FlickKeyboardView @JvmOverloads constructor( newDirection.toLegacyFlickDirection() ) } + + override fun onSelectionChanged( + action: FlickAction?, + isFlick: Boolean + ) { + updateTextPreview(textOutputFromFlickAction(action), isFlick) + } + + override fun onCanceled() = cancelTextPreview() } val mapSwitchLabels = List(circularKeyMapsList.size) { null } @@ -1838,15 +1856,23 @@ class FlickKeyboardView @JvmOverloads constructor( this.listener = object : StandardFlickInputController.StandardFlickListener { override fun onPress(character: String) { - notifyTextPress(character) + notifyTextPress(keyData, character) } override fun onFlick(character: String) { - dispatchNonTapAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(character), isFlick = true ) } + + override fun onSelectionChanged( + character: String?, + isFlick: Boolean + ) = updateTextPreview(character, isFlick) + + override fun onCanceled() = cancelTextPreview() } val stringMap = extractInputMap(flickActionMap) @@ -2010,7 +2036,7 @@ class FlickKeyboardView @JvmOverloads constructor( this.listener = object : CrossFlickInputController.CrossFlickListener { override fun onPress(action: KeyAction) { when (action) { - is KeyAction.Text -> notifyTextPress(action.text) + is KeyAction.Text -> notifyTextPress(keyData, action.text) else -> this@FlickKeyboardView.listener?.onPress(action) } } @@ -2019,6 +2045,13 @@ class FlickKeyboardView @JvmOverloads constructor( dispatchCommittedKeyAction(keyData, action, isFlick) } + override fun onTextSelectionChanged( + text: String?, + isFlick: Boolean + ) = updateTextPreview(text, isFlick) + + override fun onCanceled() = cancelTextPreview() + override fun onFlickLongPress(action: KeyAction) { if (action !is KeyAction.Text) { doubleTapActionDispatcher.interrupt() @@ -2184,7 +2217,7 @@ class FlickKeyboardView @JvmOverloads constructor( first: TfbiFlickDirection, second: TfbiFlickDirection ) { - notifyTextPress(twoStepMap[first]?.get(second) ?: "") + notifyTextPress(keyData, twoStepMap[first]?.get(second) ?: "") } override fun onFlick( @@ -2212,13 +2245,34 @@ class FlickKeyboardView @JvmOverloads constructor( val output = twoStepLongPressMap?.get(first)?.get(second).orEmpty() if (output.isEmpty()) return false - dispatchNonTapAction( - KeyAction.Text(output), + dispatchCommittedKeyAction( + keyData = keyData, + action = KeyAction.Text(output), isFlick = !(first == TfbiFlickDirection.TAP && second == TfbiFlickDirection.TAP) ) return true } + + override fun onSelectionChanged( + first: TfbiFlickDirection, + second: TfbiFlickDirection, + isLongPress: Boolean + ) { + val longPressText = if (isLongPress) { + twoStepLongPressMap?.get(first)?.get(second) + } else { + null + } + updateTextPreview( + longPressText?.takeIf(String::isNotEmpty) + ?: twoStepMap[first]?.get(second), + first != TfbiFlickDirection.TAP || + second != TfbiFlickDirection.TAP + ) + } + + override fun onCanceled() = cancelTextPreview() } attach( @@ -2277,7 +2331,7 @@ class FlickKeyboardView @JvmOverloads constructor( applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : FlickLongPressInputController.Listener { override fun onPress(character: String) { - notifyTextPress(character) + notifyTextPress(keyData, character) } override fun onCommit(character: String, isFlick: Boolean) { @@ -2331,7 +2385,7 @@ class FlickKeyboardView @JvmOverloads constructor( first: TfbiFlickDirection, second: TfbiFlickDirection ) { - notifyTextPress(twoStepMap[first]?.get(second) ?: "") + notifyTextPress(keyData, twoStepMap[first]?.get(second) ?: "") } override fun onFlick( @@ -2389,7 +2443,7 @@ class FlickKeyboardView @JvmOverloads constructor( applyPopupViewStyle(popupViewStyleSet.tfbi) this.listener = object : TfbiHierarchicalFlickController.TfbiListener { override fun onPress(character: String) { - notifyTextPress(character) + notifyTextPress(keyData, character) } override fun onFlick(character: String) { @@ -2398,13 +2452,21 @@ class FlickKeyboardView @JvmOverloads constructor( "Char: $character" ) if (character.isNotEmpty()) { - dispatchNonTapAction( + dispatchCommittedKeyAction( + keyData, KeyAction.Text(character), isFlick = true ) } } + override fun onSelectionChanged( + character: String?, + isFlick: Boolean + ) = updateTextPreview(character, isFlick) + + override fun onCanceled() = cancelTextPreview() + override fun onModeChanged( newLabel: String, activeRootMap: Map @@ -2481,19 +2543,37 @@ class FlickKeyboardView @JvmOverloads constructor( action: KeyAction, isFlick: Boolean ) { - if (isFlick) { - dispatchNonTapAction(action, isFlick = true) - return + val dispatch = { + if (isFlick) { + dispatchNonTapActionWithoutPreviewCancel(action, isFlick = true) + } else { + doubleTapActionDispatcher.onCommittedTap( + keyIdentity = keyData.keyId + ?: "legacy:${keyData.row}:${keyData.column}:${keyData.keyType}", + normalAction = action, + binding = keyData.effectiveDoubleTapBinding(action) + ) + } + } + val textAction = action as? KeyAction.Text + if (textAction != null && canPreviewText(keyData, textAction)) { + flickTextPreviewEmitter.commit( + FlickTextSelection(textAction.text, isFlick), + dispatch + ) + previewKeyData = null + } else { + cancelTextPreview() + dispatch() } - doubleTapActionDispatcher.onCommittedTap( - keyIdentity = keyData.keyId - ?: "legacy:${keyData.row}:${keyData.column}:${keyData.keyType}", - normalAction = action, - binding = keyData.effectiveDoubleTapBinding(action) - ) } private fun dispatchNonTapAction(action: KeyAction, isFlick: Boolean) { + cancelTextPreview() + dispatchNonTapActionWithoutPreviewCancel(action, isFlick) + } + + private fun dispatchNonTapActionWithoutPreviewCancel(action: KeyAction, isFlick: Boolean) { doubleTapActionDispatcher.interrupt() listener?.onAction(action, isFlick) } @@ -2508,12 +2588,39 @@ class FlickKeyboardView @JvmOverloads constructor( } } - private fun notifyTextPress(character: String) { - if (character.isNotEmpty()) { - listener?.onPress(KeyAction.Text(character)) + private fun notifyTextPress(keyData: KeyData, character: String) { + val action = KeyAction.Text(character) + if (character.isNotEmpty()) listener?.onPress(action) + if (character.isNotEmpty() && canPreviewText(keyData, action)) { + previewKeyData = keyData + flickTextPreviewEmitter.begin(FlickTextSelection(character, false)) + } else { + cancelTextPreview() } } + private fun updateTextPreview(character: String?, isFlick: Boolean) { + if (previewKeyData == null) return + flickTextPreviewEmitter.update(FlickTextSelection(character, isFlick)) + } + + private fun cancelTextPreview() { + flickTextPreviewEmitter.cancel() + previewKeyData = null + } + + private fun canPreviewText(keyData: KeyData, action: KeyAction.Text): Boolean { + return !keyData.isSpecialKey && keyData.effectiveDoubleTapBinding(action) == null + } + + private fun textOutputFromFlickAction(action: FlickAction?): String? { + return when (action) { + is FlickAction.Input -> action.char + is FlickAction.Action -> (action.action as? KeyAction.Text)?.text + null -> null + }?.takeIf(String::isNotEmpty) + } + private fun detachKeyBehavior(controller: Any?) { when (controller) { is CustomAngleFlickController -> { @@ -2593,6 +2700,7 @@ class FlickKeyboardView @JvmOverloads constructor( private val TAG = "FlickKeyboardViewTouch" private fun cancelTrackedTouchState() { + cancelTextPreview() if (motionTargets.isEmpty() && pointerDownTime.isEmpty()) return val eventTime = SystemClock.uptimeMillis() @@ -2956,6 +3064,7 @@ class FlickKeyboardView @JvmOverloads constructor( override fun onDetachedFromWindow() { doubleTapActionDispatcher.cancel() + cancelTextPreview() cancelTrackedTouchState() super.onDetachedFromWindow() listener?.onLongPressActionCanceled(KeyAction.Cancel) @@ -2973,6 +3082,7 @@ class FlickKeyboardView @JvmOverloads constructor( super.onVisibilityChanged(changedView, visibility) if (changedView == this && visibility != View.VISIBLE) { doubleTapActionDispatcher.cancel() + cancelTextPreview() cancelTrackedTouchState() listener?.onLongPressActionCanceled(KeyAction.Cancel) } diff --git a/docs/flick-editor-preview-implementation-report-2026-08-02.md b/docs/flick-editor-preview-implementation-report-2026-08-02.md new file mode 100644 index 000000000..e3dab98af --- /dev/null +++ b/docs/flick-editor-preview-implementation-report-2026-08-02.md @@ -0,0 +1,88 @@ +# フリック文字プレビュー 実装・実機試験報告 + +試験日: 2026-08-02 + +## 結論 + +`onDown` と `onMove` で、選択中の TenKey／Sumire の文字を入力先アプリの composing text に仮表示する設定を実装した。設定は新規設定画面と従来設定画面の両方に追加し、デフォルトは OFF とした。OFF の場合は従来どおり `onUp` または二本目の指を検知した時点で入力へ反映する。 + +Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま、Down 表示、Move 置換、Up 確定、Cancel 復元が正常に動作した。候補表示時間に有意と判断できる悪化は観測されなかった。プレビューONでは Down／Move／Cancel ごとに入力先アプリとの composing-text 通信が発生するため、合成ジェスチャ試験の同期処理時間と一時割り当て量は増えたが、GC後PSSの増加は観測されなかった。 + +## 実装内容 + +- 共通設定キー: `flick_editor_preview_preference` +- デフォルト: `false` +- 設定画面: 新規設定の「フリック入力」カテゴリ、従来設定の「フリック入力」カテゴリ +- 対象: TenKey と Sumire のテキスト入力キー +- Sumire確認スタイル: `default`、`circle`、`second-flick`、`third-flick`、`sumire` +- 通常表示とフローティング表示の両方へ同じリスナーを接続 +- `onDown`: タップ位置の文字を仮表示 +- `onMove`: 現在選択中の文字で仮表示を置換 +- `onUp`: プレビューと同一の入力変換を一度だけ確定し、その後に従来どおり候補生成 +- `ACTION_CANCEL`、ビュー非表示、入力セッション切替: 仮表示を破棄して正規の composing text を復元 +- パスワード、数値、直接入力、変換中、範囲選択中、カーソル移動中など、安全にプレビューできない状態では無効 +- プレビュー処理中は `_inputString` とトグル入力状態を変更せず、確定時だけ反映 + +実機試験で、composing text が存在しない状態へ `finishComposingText()` で復元すると、Pixel 6では表示中のプレビューが確定されることを検出した。復元処理は空の composing region を設定する方式に変更し、Cancel時に文字が残らないことを確認した。 + +また、端末に復元されていた既存のキーボード順序JSONに未知の列挙値が含まれると起動時に `null` が混入する問題を検出したため、未知値を除外し、空になった場合は TenKey／QWERTYへフォールバックするようにした。 + +## 実機機能試験 + +端末は USB 接続した Pixel 6 (`oriole`)、Android 16、API 36。`liteStandardDebug` を使用した。 + +以下を自動操作で確認し、最終差分に対する試験は成功した。 + +- 設定ON: TenKeyおよびSumire 5スタイルで Down直後に文字が表示される +- 設定ON: Up前は候補欄が空であり、変換処理が開始されない +- 設定ON: Cancel後に仮表示が消え、元の composing stateへ戻る +- 設定ON: TenKeyおよびSumire `default` で Moveにより文字が変化する +- 設定ON: Up後の確定結果がMove時のプレビューと一致する +- 設定OFF: TenKeyおよびSumireでDown時は未反映、Up時に従来どおり入力される + +## 変換時間 + +測定区間は `ACTION_UP` 注入開始から最初の候補が表示されるまで。各条件で3回ウォームアップ後、15回測定した。 + +| 条件 | 平均 | P50 | P95 | +|---|---:|---:|---:| +| OFF | 127.349 ms | 111.965 ms | 168.189 ms | +| ON | 126.288 ms | 124.467 ms | 151.561 ms | +| ON − OFF | -1.061 ms (-0.83%) | +12.502 ms (+11.17%) | -16.629 ms (-9.89%) | + +平均とP95はONで短く、P50はONで長い。サンプル数15かつ端末上のスケジューリングを含むため、このばらつきから高速化を主張することはできない。一方、平均値での遅延増加はなく、Up前に候補生成が開始されないことも各試行で検証しているため、今回の実装による変換開始後の明確な性能悪化は検出されなかった。 + +同じ端末での直前の反復でも、平均はOFF 127.700 ms、ON 120.777 msだった。2回の測定範囲はOFF 127.349–127.700 ms、ON 120.777–126.288 msであり、少なくとも今回の条件では悪化傾向は再現しなかった。 + +## プレビュー処理時間とメモリ + +Down→Move→Cancelを1ジェスチャとして30回ウォームアップ後、500回連続実行した。時間は3個の同期タッチイベント注入、IME処理、入力先アプリへの更新を含む。割り当て量は ART の `art.gc.bytes-allocated`、PSSは `Debug.getPss()` で取得した。 + +| 条件 | 1ジェスチャ平均 | 一時割り当て/ジェスチャ | PSS開始 | PSS直後 | GC後PSS | +|---|---:|---:|---:|---:|---:| +| OFF | 53.069 ms | 71,157 bytes | 235,727 KB | 268,227 KB | 248,709 KB | +| ON | 78.525 ms | 101,116 bytes | 237,317 KB | 260,177 KB | 243,041 KB | +| ON − OFF | +25.456 ms (+47.97%) | +29,959 bytes (+42.10%) | +1,590 KB | -8,050 KB | -5,668 KB | + +時間と割り当て量の増加は、ON時だけ Down、Move、Cancelで `InputConnection.setComposingText()` を実行し、入力先アプリとの同期処理および一時オブジェクト生成が追加されるためである。この53–79 msは1回のコールバックそのものではなく、UiAutomationによる3イベントの同期注入を含む試験全体の壁時計時間であり、そのままユーザーが感じる遅延とは解釈できない。 + +割り当て増加は反復して観測され、直前の反復でもOFF 71,092 bytes、ON 101,378 bytesだった。一方、最終試験のGC後PSSはONの方が5,668 KB低く、直前の反復でもONの方が3,730 KB低かった。測定順序はOFF→ONで固定され、JIT、ヒープ拡張、GCタイミングの影響を受けるため、ONでメモリが減るとは判断しない。結論は「プレビュー操作ごとの一時割り当ては約30 KB増えるが、保持メモリの増加は今回の試験では検出されなかった」である。 + +## 検証コマンド + +```text +./gradlew :core:testDebugUnitTest :app:testLiteStandardDebugUnitTest \ + :app:assembleLiteStandardDebug :app:assembleLiteStandardDebugAndroidTest + +./gradlew :app:connectedLiteStandardDebugAndroidTest \ + -Pandroid.testInstrumentationRunnerArguments.class=com.kazumaproject.markdownhelperkeyboard.FastInputMatrixInstrumentedTest#flickEditorPreviewFunctionalAndPerformanceOnPhysicalDevice +``` + +単体テスト、APK／instrumentation APKの組み立て、Pixel 6のinstrumentation testはいずれも成功した。 + +## 制約 + +- 物理端末はPixel 6の1機種、デバッグビルドのみ。 +- 候補表示時間は各条件15サンプルの探索的測定であり、正式なMacrobenchmarkではない。 +- 自動機能試験は通常表示で実施した。フローティング表示は同じプレビューリスナーへ接続し、コンパイル対象として検証したが、今回の実機自動操作マトリクスには含めていない。 +- PSS比較は単一プロセス内かつOFF→ONの固定順であり、小さい保持メモリ差を判定する用途には不十分。 diff --git a/tenkey/src/main/java/com/kazumaproject/tenkey/TenKey.kt b/tenkey/src/main/java/com/kazumaproject/tenkey/TenKey.kt index fec4339f2..72aaea24f 100644 --- a/tenkey/src/main/java/com/kazumaproject/tenkey/TenKey.kt +++ b/tenkey/src/main/java/com/kazumaproject/tenkey/TenKey.kt @@ -49,6 +49,9 @@ import com.kazumaproject.core.domain.state.toTwoStateNumberReturnTargetOrNull import com.kazumaproject.core.data.popup.PopupViewStyle import com.kazumaproject.core.domain.flick.FlickDirection as CoreFlickDirection import com.kazumaproject.core.domain.flick.FlickGestureMath +import com.kazumaproject.core.domain.flick.FlickTextPreviewEmitter +import com.kazumaproject.core.domain.flick.FlickTextPreviewListener +import com.kazumaproject.core.domain.flick.FlickTextSelection import com.kazumaproject.core.domain.flick.FlickThresholdShape import com.kazumaproject.core.ui.effect.Blur import com.kazumaproject.core.ui.input_mode_witch.InputModeSwitch @@ -135,6 +138,7 @@ class TenKey(context: Context, attributeSet: AttributeSet) : private var keyTouchCancelListener: KeyTouchCancelListener? = null private var inputModeChangedListener: ((InputMode) -> Unit)? = null private var qwertyNumberModeRequestedListener: (() -> Unit)? = null + private val flickTextPreviewEmitter = FlickTextPreviewEmitter() private var flickSensitivity: Int = 100 private var flickThresholdPx: Float = resolveFlickThresholdPx(flickSensitivity) @@ -1319,6 +1323,10 @@ class TenKey(context: Context, attributeSet: AttributeSet) : this.flickListener = flickListener } + fun setOnFlickTextPreviewListener(listener: FlickTextPreviewListener?) { + flickTextPreviewEmitter.listener = listener + } + /** Allow setting an external LongPressListener **/ fun setOnLongPressListener(longPressListener: LongPressListener) { this.longPressListener = longPressListener @@ -1382,6 +1390,8 @@ class TenKey(context: Context, attributeSet: AttributeSet) : keyTouchCancelListener = null inputModeChangedListener = null qwertyNumberModeRequestedListener = null + flickTextPreviewEmitter.cancel() + flickTextPreviewEmitter.listener = null longPressJob?.cancel() longPressJob = null isCursorMode = false @@ -1439,9 +1449,14 @@ class TenKey(context: Context, attributeSet: AttributeSet) : } if (isCursorMode) { + flickTextPreviewEmitter.cancel() return true } + flickTextPreviewEmitter.begin( + resolveTextSelection(key, GestureType.Tap) + ) + setKeyPressed() longPressJob = scope.launch { delay(longPressTimeout) @@ -1476,56 +1491,9 @@ class TenKey(context: Context, attributeSet: AttributeSet) : if (pressedKey.pointer == event.getPointerId(event.actionIndex)) { val gestureType = getGestureType(event) - // ← READING the state flow's current value: - val keyInfo = currentInputMode.value - .next(keyMap = keyMap, key = pressedKey.key, isTablet = false) - - Log.d("TenKey: ACTION_UP in pointer", "called $keyInfo $pressedKey") - - if (keyInfo == KeyInfo.Null) { - flickListener?.onFlick( - gestureType = gestureType, key = pressedKey.key, char = null - ) - if (pressedKey.key == Key.SideKeyInputMode) { - handleClickInputModeSwitch() - } else if (pressedKey.key == Key.SideKeyNumberMode) { - switchToNumberMode() - } - } else if (keyInfo is KeyInfo.KeyTapFlickInfo) { - when (gestureType) { - GestureType.Null -> {} - GestureType.Down -> {} - GestureType.Tap -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.tap - ) - - GestureType.FlickLeft -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickLeft - ) - - GestureType.FlickTop -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickTop - ) - - GestureType.FlickRight -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickRight - ) + Log.d("TenKey: ACTION_UP in pointer", "called $pressedKey") - GestureType.FlickBottom -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickBottom - ) - } - } + dispatchResolvedGesture(pressedKey.key, gestureType) } Log.d("TenKey: ACTION_UP out", "called $pressedKey") resetAllKeys() @@ -1599,6 +1567,9 @@ class TenKey(context: Context, attributeSet: AttributeSet) : } else { getGestureType(event, pressedKey.pointer) } + flickTextPreviewEmitter.update( + resolveTextSelection(pressedKey.key, gestureType) + ) when (gestureType) { GestureType.Null -> {} GestureType.Down -> {} @@ -1641,37 +1612,9 @@ class TenKey(context: Context, attributeSet: AttributeSet) : if (pressedKey.key == Key.KeyDakutenSmall && currentInputMode.value == InputMode.ModeNumber) { setNumberSmallKeyPresentation() } - val keyInfo = currentInputMode.value - .next(keyMap = keyMap, key = pressedKey.key, isTablet = false) - if (keyInfo == KeyInfo.Null) { - flickListener?.onFlick( - gestureType = gestureType2, key = pressedKey.key, char = null - ) - } else if (keyInfo is KeyInfo.KeyTapFlickInfo) { - when (gestureType2) { - GestureType.Null -> {} - GestureType.Down -> {} - GestureType.Tap -> { - flickListener?.onFlick( - gestureType = gestureType2, - key = pressedKey.key, - char = keyInfo.tap - ) - val button = getButtonFromKey(pressedKey.key) - button?.let { - if (it is AppCompatButton) { - setTextForMode(it, currentInputMode.value) - } - if (it is AppCompatImageButton && currentInputMode.value == InputMode.ModeNumber && it == binding.keySmallLetter) { - setNumberSmallKeyPresentation() - } - } - } - - GestureType.FlickLeft, GestureType.FlickTop, GestureType.FlickRight, GestureType.FlickBottom -> { - setFlickActionPointerDown(keyInfo, gestureType2) - } - } + dispatchResolvedGesture(pressedKey.key, gestureType2) + (getButtonFromKey(pressedKey.key) as? AppCompatButton)?.let { button -> + setTextForMode(button, currentInputMode.value) } pressedKey = pressedKey.copy( key = key, pointer = pointer, initialX = if (pointer == 0) { @@ -1701,6 +1644,9 @@ class TenKey(context: Context, attributeSet: AttributeSet) : } ) setKeyPressed() + flickTextPreviewEmitter.begin( + resolveTextSelection(key, GestureType.Tap) + ) longPressJob = scope.launch { delay(longPressTimeout) if (pressedKey.key != Key.NotSelected) { @@ -1721,56 +1667,8 @@ class TenKey(context: Context, attributeSet: AttributeSet) : val gestureType = getGestureType( event, event.getPointerId(event.actionIndex) ) - val keyInfo = currentInputMode.value - .next(keyMap = keyMap, key = pressedKey.key, isTablet = false) - Log.d("TenKey: ACTION_POINTER_UP", "called [${pressedKey.key}]") - if (keyInfo == KeyInfo.Null) { - flickListener?.onFlick( - gestureType = gestureType, key = pressedKey.key, char = null - ) - if (pressedKey.key == Key.SideKeyInputMode) { - handleClickInputModeSwitch() - } else if (pressedKey.key == Key.SideKeyNumberMode) { - switchToNumberMode() - } - } else if (keyInfo is KeyInfo.KeyTapFlickInfo) { - when (gestureType) { - GestureType.Null -> {} - GestureType.Down -> {} - GestureType.Tap -> { - flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.tap - ) - } - - GestureType.FlickLeft -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickLeft - ) - - GestureType.FlickTop -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickTop - ) - - GestureType.FlickRight -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickRight - ) - - GestureType.FlickBottom -> flickListener?.onFlick( - gestureType = gestureType, - key = pressedKey.key, - char = keyInfo.flickBottom - ) - } - } + dispatchResolvedGesture(pressedKey.key, gestureType) val button = getButtonFromKey(pressedKey.key) button?.let { if (it is AppCompatButton) { @@ -1798,6 +1696,7 @@ class TenKey(context: Context, attributeSet: AttributeSet) : } private fun cancelActiveTouch(reason: KeyTouchCancelReason) { + flickTextPreviewEmitter.cancel() resetLongPressAction() resetAllKeys() @@ -2167,6 +2066,74 @@ class TenKey(context: Context, attributeSet: AttributeSet) : } } + private fun resolveTextSelection( + key: Key, + gestureType: GestureType, + ): FlickTextSelection { + val keyInfo = currentInputMode.value.next( + keyMap = keyMap, + key = key, + isTablet = false + ) + return resolveTextSelection(keyInfo, gestureType) + } + + private fun resolveTextSelection( + keyInfo: KeyInfo, + gestureType: GestureType, + ): FlickTextSelection { + val character = (keyInfo as? KeyInfo.KeyTapFlickInfo)?.let { info -> + when (gestureType) { + GestureType.Tap -> info.tap + GestureType.FlickLeft -> info.flickLeft + GestureType.FlickTop -> info.flickTop + GestureType.FlickRight -> info.flickRight + GestureType.FlickBottom -> info.flickBottom + GestureType.Null, + GestureType.Down -> null + } + } + return FlickTextSelection( + text = character?.toString(), + isFlick = gestureType != GestureType.Tap + ) + } + + private fun dispatchResolvedGesture(key: Key, gestureType: GestureType) { + val keyInfo = currentInputMode.value.next( + keyMap = keyMap, + key = key, + isTablet = false + ) + val selection = resolveTextSelection(keyInfo, gestureType) + flickTextPreviewEmitter.commit(selection) { + when (keyInfo) { + KeyInfo.Null -> { + flickListener?.onFlick( + gestureType = gestureType, + key = key, + char = null + ) + if (key == Key.SideKeyInputMode) { + handleClickInputModeSwitch() + } else if (key == Key.SideKeyNumberMode) { + switchToNumberMode() + } + } + + is KeyInfo.KeyTapFlickInfo -> { + if (gestureType != GestureType.Null && gestureType != GestureType.Down) { + flickListener?.onFlick( + gestureType = gestureType, + key = key, + char = selection.text?.firstOrNull() + ) + } + } + } + } + } + private fun resolveFlickThresholdPx(sensitivity: Int): Float { return FlickGestureMath.thresholdPxForSensitivity( sensitivity = sensitivity, From be9eb8e6fde7842cb529155a813d5b1f0ce564be Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 3 Aug 2026 10:30:46 -0400 Subject: [PATCH 17/24] improve candidate order --- ...ndidateOrderOverrideImeInstrumentedTest.kt | 226 +++++++++++++++ ...versionPerformanceInstrumentedProbeTest.kt | 261 +++++++++++++++++- .../database/CandidateOrderOverrideDao.kt | 9 + .../candidate/CandidateConversionSegment.kt | 15 + .../ExactInputCandidatePromotionPolicy.kt | 14 + .../converter/engine/KanaKanjiEngine.kt | 13 + .../converter/path_algorithm/FindPath.kt | 39 +++ .../session/KanaKanjiConversionSession.kt | 49 +++- .../ime_service/IMEService.kt | 28 +- .../di/KanaKanjiEngineEntryPoint.kt | 8 +- .../CandidateOrderOverrideRepository.kt | 167 +++++++++-- ...andidateOrderOverrideSavedOrderEditTest.kt | 54 ++++ .../CandidateOrderOverrideSorterTest.kt | 90 +++++- .../MozcCompoundConversionParityTest.kt | 21 ++ .../KanaKanjiConversionSessionParityTest.kt | 21 ++ 15 files changed, 963 insertions(+), 52 deletions(-) create mode 100644 app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideImeInstrumentedTest.kt create mode 100644 app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/CandidateConversionSegment.kt diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideImeInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideImeInstrumentedTest.kt new file mode 100644 index 000000000..742b921c8 --- /dev/null +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideImeInstrumentedTest.kt @@ -0,0 +1,226 @@ +package com.kazumaproject.markdownhelperkeyboard.candidate_order + +import android.accessibilityservice.AccessibilityServiceInfo +import android.app.Instrumentation +import android.content.Context +import android.content.Intent +import android.graphics.PointF +import android.graphics.Rect +import android.os.SystemClock +import android.view.InputDevice +import android.view.MotionEvent +import android.view.accessibility.AccessibilityNodeInfo +import androidx.preference.PreferenceManager +import androidx.test.core.app.ActivityScenario +import androidx.test.core.app.ApplicationProvider +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import com.kazumaproject.markdownhelperkeyboard.FastInputHostActivity +import com.kazumaproject.markdownhelperkeyboard.ime_service.di.KanaKanjiEngineEntryPoint +import dagger.hilt.android.EntryPointAccessors +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class CandidateOrderOverrideImeInstrumentedTest { + + private val instrumentation: Instrumentation + get() = InstrumentationRegistry.getInstrumentation() + + @Test + fun savedHiOrderPromotesHiNodeInsideHiwoUsingSoftKeyboardTouches() = runBlocking { + configureAccessibilityInspection() + val context = ApplicationProvider.getApplicationContext() + val entryPoint = EntryPointAccessors.fromApplication( + context.applicationContext, + KanaKanjiEngineEntryPoint::class.java, + ) + val candidateOrderRepository = entryPoint.candidateOrderOverrideRepository() + val originalHiOrder = candidateOrderRepository.observeAll() + .first() + .filter { it.input.trim() == "ひ" } + .sortedBy { it.rank } + .map { it.candidate } + val preferences = PreferenceManager.getDefaultSharedPreferences(context) + val originalPreferences = preferences.all + preferences + .edit() + .putBoolean("candidate_order_override_enable_preference", true) + .putString( + "keyboard_order_preference", + """["TENKEY","SUMIRE","QWERTY","ROMAJI","CUSTOM"]""", + ) + .putBoolean("save_last_used_keyboard", false) + .putBoolean("flick_input_only_preference", true) + .putBoolean("live_conversion_preference", false) + .commit() + candidateOrderRepository.saveOrder( + input = "ひ", + candidates = listOf("火", "日", "陽"), + ) + + val scenario = ActivityScenario.launch( + Intent(context, FastInputHostActivity::class.java), + ) + try { + scenario.onActivity { it.restartEditorInput(clearText = true) } + instrumentation.waitForIdleSync() + SystemClock.sleep(1_500) + + assertTrue(flickLeft("key_6")) // は -> ひ + assertTrue(flickLeft("key_11")) // わ -> を + + val candidates = awaitVisibleCandidates() + assertEquals("火を", candidates.first().first) + assertTrue(tap(candidates.first().second.center())) + + val deadline = SystemClock.uptimeMillis() + 8_000L + var actual = "" + while (SystemClock.uptimeMillis() < deadline) { + scenario.onActivity { actual = it.editText.text.toString() } + if (actual == "火を") break + SystemClock.sleep(50) + } + assertEquals("火を", actual) + } finally { + scenario.close() + if (originalHiOrder.isEmpty()) { + candidateOrderRepository.deleteByInput("ひ") + } else { + candidateOrderRepository.saveOrder("ひ", originalHiOrder) + } + preferences.edit().clear().also { editor -> + originalPreferences.forEach { (key, value) -> + when (value) { + is Boolean -> editor.putBoolean(key, value) + is Float -> editor.putFloat(key, value) + is Int -> editor.putInt(key, value) + is Long -> editor.putLong(key, value) + is String -> editor.putString(key, value) + is Set<*> -> editor.putStringSet( + key, + value.filterIsInstance().toSet(), + ) + } + } + }.commit() + } + } + + private fun configureAccessibilityInspection() { + val automation = instrumentation.uiAutomation + val info = automation.serviceInfo + info.flags = info.flags or + AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS or + AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS + automation.serviceInfo = info + } + + private fun flickLeft(keyId: String): Boolean { + val bounds = awaitVisibleBounds(keyId) + val start = bounds.center() + val end = PointF(start.x - bounds.width() * 0.70f, start.y) + val downTime = SystemClock.uptimeMillis() + var injected = inject(downTime, MotionEvent.ACTION_DOWN, start) + SystemClock.sleep(16) + injected = inject(downTime, MotionEvent.ACTION_MOVE, end) && injected + SystemClock.sleep(16) + injected = inject(downTime, MotionEvent.ACTION_UP, end) && injected + SystemClock.sleep(100) + return injected + } + + private fun tap(point: PointF): Boolean { + val downTime = SystemClock.uptimeMillis() + var injected = inject(downTime, MotionEvent.ACTION_DOWN, point) + SystemClock.sleep(32) + injected = inject(downTime, MotionEvent.ACTION_UP, point) && injected + return injected + } + + private fun inject(downTime: Long, action: Int, point: PointF): Boolean { + val event = MotionEvent.obtain( + downTime, + SystemClock.uptimeMillis(), + action, + point.x, + point.y, + 0, + ).apply { + source = InputDevice.SOURCE_TOUCHSCREEN + } + return instrumentation.uiAutomation.injectInputEvent(event, true).also { + event.recycle() + } + } + + private fun awaitVisibleBounds(idName: String): Rect { + val deadline = SystemClock.uptimeMillis() + 8_000L + while (SystemClock.uptimeMillis() < deadline) { + findVisibleNodeById(idName)?.let { node -> + return Rect().also(node::getBoundsInScreen) + } + SystemClock.sleep(50) + } + error("Timed out waiting for visible id=$idName") + } + + private fun awaitVisibleCandidates(): List> { + val deadline = SystemClock.uptimeMillis() + 8_000L + while (SystemClock.uptimeMillis() < deadline) { + val recycler = findVisibleNodeById("suggestion_recycler_view") + val candidates = buildList { + if (recycler != null) { + for (index in 0 until recycler.childCount) { + val child = recycler.getChild(index) ?: continue + val textNode = findDescendant(child) { node -> + node.viewIdResourceName + ?.endsWith(":id/suggestion_item_text_view") == true + } ?: continue + val text = textNode.text?.toString().orEmpty().trim() + if (text.isNotEmpty()) { + add(text to Rect().also(textNode::getBoundsInScreen)) + } + } + } + } + if (candidates.isNotEmpty()) return candidates + SystemClock.sleep(50) + } + error("Timed out waiting for candidates") + } + + private fun findVisibleNodeById(idName: String): AccessibilityNodeInfo? { + for (window in instrumentation.uiAutomation.windows) { + val root = window.root ?: continue + val found = findDescendant(root) { node -> + node.isVisibleToUser && + node.viewIdResourceName?.endsWith(":id/$idName") == true + } + if (found != null) return found + } + return null + } + + private fun findDescendant( + root: AccessibilityNodeInfo, + predicate: (AccessibilityNodeInfo) -> Boolean, + ): AccessibilityNodeInfo? { + val queue = ArrayDeque() + queue.add(root) + while (queue.isNotEmpty()) { + val node = queue.removeFirst() + if (predicate(node)) return node + for (index in 0 until node.childCount) { + node.getChild(index)?.let(queue::addLast) + } + } + return null + } + + private fun Rect.center(): PointF = PointF(exactCenterX(), exactCenterY()) +} diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt index 9873eb540..34bfed9d1 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/converter/ConversionPerformanceInstrumentedProbeTest.kt @@ -1,7 +1,10 @@ package com.kazumaproject.markdownhelperkeyboard.converter import android.content.Context +import android.os.Debug +import android.os.SystemClock import android.view.ContextThemeWrapper +import androidx.room.Room import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 import androidx.test.platform.app.InstrumentationRegistry @@ -9,8 +12,12 @@ import com.kazumaproject.custom_keyboard.data.KeyCharacterCase import com.kazumaproject.custom_keyboard.layout.KeyboardDefaultLayouts import com.kazumaproject.custom_keyboard.view.FlickKeyboardView import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine +import com.kazumaproject.markdownhelperkeyboard.database.AppDatabase import com.kazumaproject.markdownhelperkeyboard.ime_service.di.KanaKanjiEngineEntryPoint +import com.kazumaproject.markdownhelperkeyboard.candidate_order.database.CandidateOrderOverrideEntity +import com.kazumaproject.markdownhelperkeyboard.repository.CandidateOrderOverrideRepository import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryRepository import dagger.hilt.android.EntryPointAccessors import kotlinx.coroutines.runBlocking @@ -112,6 +119,8 @@ class ConversionPerformanceInstrumentedProbeTest { val label = arguments.getString("conversionPerfLabel") ?: "instrumented" val warmup = arguments.getString("conversionPerfWarmup")?.toIntOrNull() ?: 2 val iterations = arguments.getString("conversionPerfIterations")?.toIntOrNull() ?: 10 + val collectCandidateSegments = + arguments.getString("conversionPerfCollectCandidateSegments") == "true" val inputs = listOf( "きょう", "きょうはいいてんきですね", @@ -136,24 +145,40 @@ class ConversionPerformanceInstrumentedProbeTest { userDictionaryRepository = entryPoint.userDictionaryRepository() } + var lastCandidateSegments: Map> = emptyMap() + suspend fun convert(input: String): List { + val segmentCollector: MutableMap>? = + if (collectCandidateSegments) LinkedHashMap() else null + return engine.convertForProbe( + input = input, + userDictionaryRepository = userDictionaryRepository, + candidateSegmentCollector = segmentCollector, + ).also { + if (segmentCollector != null) lastCandidateSegments = segmentCollector + } + } + val firstResults = LinkedHashMap>() val firstConversionNs = inputs.associateWith { input -> measureNanoTime { - firstResults[input] = engine.convertForProbe(input, userDictionaryRepository) + firstResults[input] = convert(input) } } repeat(warmup) { inputs.forEach { input -> - engine.convertForProbe(input, userDictionaryRepository) + convert(input) } } + Runtime.getRuntime().gc() + SystemClock.sleep(500) + val pssBeforeKb = Debug.getPss() val warmResults = LinkedHashMap>() val warmConversionNs = inputs.associateWith { input -> measureNanoTime { repeat(iterations) { - warmResults[input] = engine.convertForProbe(input, userDictionaryRepository) + warmResults[input] = convert(input) } } } @@ -162,14 +187,23 @@ class ConversionPerformanceInstrumentedProbeTest { var continuousResult: List = emptyList() val continuousElapsedNs = measureNanoTime { repeat(iterations) { - continuousResult = engine.convertForProbe(continuousInput, userDictionaryRepository) + continuousResult = convert(continuousInput) } } + Runtime.getRuntime().gc() + SystemClock.sleep(500) + val pssAfterKb = Debug.getPss() val report = buildString { appendLine("label=$label") appendLine("warmup=$warmup") appendLine("iterations=$iterations") + appendLine("collectCandidateSegments=$collectCandidateSegments") + appendLine("segmentCandidateCount=${lastCandidateSegments.size}") + appendLine("segmentNodeCount=${lastCandidateSegments.values.sumOf { it.size }}") + appendLine("pssBeforeKb=$pssBeforeKb") + appendLine("pssAfterKb=$pssAfterKb") + appendLine("pssDeltaKb=${pssAfterKb - pssBeforeKb}") appendLine("entryPointResolveNs=$entryPointResolveNs") appendLine("productionSingletonResolveNs=$productionSingletonResolveNs") appendLine("fingerprint=${warmResults.fingerprint()}") @@ -200,9 +234,227 @@ class ConversionPerformanceInstrumentedProbeTest { println(report) } + @Test + fun measureCandidateOrderScalePerformance() = runBlocking { + val arguments = InstrumentationRegistry.getArguments() + assumeTrue(arguments.getString("candidateOrderScaleProbe") == "true") + + val scale = arguments.getString("candidateOrderScale")?.toIntOrNull() ?: 100 + val conversionWarmup = + arguments.getString("candidateOrderConversionWarmup")?.toIntOrNull() ?: 10 + val conversionIterations = + arguments.getString("candidateOrderConversionIterations")?.toIntOrNull() ?: 100 + val sortIterations = + arguments.getString("candidateOrderSortIterations")?.toIntOrNull() ?: 10_000 + val candidatesPerGroup = + arguments.getString("candidateOrderCandidatesPerGroup")?.toIntOrNull() ?: 3 + require(scale in 1..10_000) + require(candidatesPerGroup in 3..200) + + val context = ApplicationProvider.getApplicationContext() + val input = "ひを" + lateinit var engine: KanaKanjiEngine + lateinit var userDictionaryRepository: UserDictionaryRepository + + suspend fun convertWithSegments(): Pair< + List, + Map>, + > { + val segments = LinkedHashMap>() + val candidates = engine.convertForProbe( + input = input, + userDictionaryRepository = userDictionaryRepository, + candidateSegmentCollector = segments, + ) + return candidates to segments + } + + val memoryProbeCandidates = listOf( + Candidate("日を", 1, 2u, 0), + Candidate("火を", 1, 2u, 1), + Candidate("陽を", 1, 2u, 2), + ) + val memoryProbeSegments = mapOf( + "日を" to listOf( + CandidateConversionSegment(0, 1, "日"), + CandidateConversionSegment(1, 2, "を"), + ), + "火を" to listOf( + CandidateConversionSegment(0, 1, "火"), + CandidateConversionSegment(1, 2, "を"), + ), + "陽を" to listOf( + CandidateConversionSegment(0, 1, "陽"), + CandidateConversionSegment(1, 2, "を"), + ), + ) + + val databaseName = "candidate-order-scale-${scale}-${System.nanoTime()}.db" + val database = Room.databaseBuilder( + context, + AppDatabase::class.java, + databaseName, + ).build() + try { + val dao = database.candidateOrderOverrideDao() + val repository = CandidateOrderOverrideRepository(dao) + + val now = System.currentTimeMillis() + val entityCount = scale * candidatesPerGroup + val insertNs = measureNanoTime { + val batch = ArrayList(10_000) + suspend fun flushBatch() { + if (batch.isEmpty()) return + dao.insertAll(batch) + batch.clear() + } + for (groupIndex in 0 until scale) { + val suffix = groupIndex.toString().padStart(5, '0') + val groupInput = if (groupIndex == 0) "ひ" else "べんちまっぷ$suffix" + for (candidateIndex in 0 until candidatesPerGroup) { + val output = when { + groupIndex == 0 && candidateIndex == 0 -> "火" + groupIndex == 0 && candidateIndex == 1 -> "日" + groupIndex == 0 && candidateIndex == 2 -> "陽" + else -> "候補${candidateIndex.toString().padStart(3, '0')}-$suffix" + } + batch += CandidateOrderOverrideEntity( + input = groupInput, + candidate = output, + rank = candidateIndex + 1, + createdAt = now, + updatedAt = now, + ) + if (batch.size >= 10_000) flushBatch() + } + } + flushBatch() + } + + // Measure only the conversion-time lookup/cache allocation. The test database is + // file-backed like production, and insertion pages are already present at baseline. + dao.findByInputs(listOf("__measurement_warmup__")) + forceGcForMeasurement() + val baselinePssKb = Debug.getPss() + val baselineHeapKb = usedJavaHeapKb() + + lateinit var firstOrdered: List + val firstSnapshotAndSortNs = measureNanoTime { + firstOrdered = repository.applyOrderFromSnapshot( + input = input, + candidates = memoryProbeCandidates, + candidateSegmentsByString = memoryProbeSegments, + ) + } + assertEquals("火を", firstOrdered.first().string) + + forceGcForMeasurement() + val snapshotPssKb = Debug.getPss() + val snapshotHeapKb = usedJavaHeapKb() + + val entryPoint = EntryPointAccessors.fromApplication( + context.applicationContext, + KanaKanjiEngineEntryPoint::class.java, + ) + engine = entryPoint.kanaKanjiEngine() + userDictionaryRepository = entryPoint.userDictionaryRepository() + repeat(conversionWarmup) { convertWithSegments() } + val (referenceCandidates, referenceSegments) = convertWithSegments() + + var lastSorted: List = emptyList() + val sortElapsedNs = measureNanoTime { + repeat(sortIterations) { + lastSorted = repository.applyOrderFromSnapshot( + input = input, + candidates = referenceCandidates, + candidateSegmentsByString = referenceSegments, + ) + } + } + assertEquals("火を", lastSorted.first().string) + + suspend fun convertAndOrder(): List { + val (candidates, segments) = convertWithSegments() + return repository.applyOrderFromSnapshot( + input = input, + candidates = candidates, + candidateSegmentsByString = segments, + ) + } + + repeat(conversionWarmup) { + convertWithSegments() + convertAndOrder() + } + val conversionOnlyNs = LongArray(conversionIterations) + val conversionAndOrderNs = LongArray(conversionIterations) + repeat(conversionIterations) { index -> + if (index % 2 == 0) { + conversionOnlyNs[index] = measureNanoTime { convertWithSegments() } + conversionAndOrderNs[index] = measureNanoTime { convertAndOrder() } + } else { + conversionAndOrderNs[index] = measureNanoTime { convertAndOrder() } + conversionOnlyNs[index] = measureNanoTime { convertWithSegments() } + } + } + + val conversionOnlyAvgUs = conversionOnlyNs.average() / 1_000.0 + val conversionAndOrderAvgUs = conversionAndOrderNs.average() / 1_000.0 + val report = buildString { + appendLine("scale=$scale") + appendLine("overrideGroupCount=$scale") + appendLine("overrideEntityCount=$entityCount") + appendLine("candidatesPerGroup=$candidatesPerGroup") + appendLine("databaseMode=file") + appendLine("conversionWarmup=$conversionWarmup") + appendLine("conversionIterations=$conversionIterations") + appendLine("sortIterations=$sortIterations") + appendLine("insertMs=${insertNs / 1_000_000.0}") + appendLine("firstSnapshotAndSortMs=${firstSnapshotAndSortNs / 1_000_000.0}") + appendLine("sortOnlyAvgUs=${sortElapsedNs / sortIterations / 1_000.0}") + appendLine("conversionOnlyAvgUs=$conversionOnlyAvgUs") + appendLine("conversionAndOrderAvgUs=$conversionAndOrderAvgUs") + appendLine( + "conversionOrderDeltaUs=${conversionAndOrderAvgUs - conversionOnlyAvgUs}", + ) + appendLine("baselinePssKb=$baselinePssKb") + appendLine("snapshotPssKb=$snapshotPssKb") + appendLine("snapshotPssDeltaKb=${snapshotPssKb - baselinePssKb}") + appendLine("baselineHeapKb=$baselineHeapKb") + appendLine("snapshotHeapKb=$snapshotHeapKb") + appendLine("snapshotHeapDeltaKb=${snapshotHeapKb - baselineHeapKb}") + appendLine("candidateCount=${referenceCandidates.size}") + appendLine( + "segmentCandidateCount=${referenceSegments.size}", + ) + } + + val outputDir = File(context.filesDir, "conversion-perf").apply { mkdirs() } + File(outputDir, "candidate-order-scale-$scale.txt").writeText(report) + println(report) + } finally { + database.close() + context.deleteDatabase(databaseName) + } + } + + private fun forceGcForMeasurement() { + repeat(3) { + Runtime.getRuntime().gc() + System.runFinalization() + SystemClock.sleep(300) + } + } + + private fun usedJavaHeapKb(): Long { + val runtime = Runtime.getRuntime() + return (runtime.totalMemory() - runtime.freeMemory()) / 1024L + } + private suspend fun KanaKanjiEngine.convertForProbe( input: String, userDictionaryRepository: UserDictionaryRepository, + candidateSegmentCollector: MutableMap>? = null, ): List = getCandidatesWithBunsetsuSeparation( input = input, @@ -220,6 +472,7 @@ class ConversionPerformanceInstrumentedProbeTest { typoCorrectionOffsetScore = 3000, omissionSearchOffsetScore = 1900, beamWidth = 20, + candidateSegmentCollector = candidateSegmentCollector, ).candidates private fun Map>.fingerprint(): String { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/database/CandidateOrderOverrideDao.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/database/CandidateOrderOverrideDao.kt index 6472fd6ea..c63692418 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/database/CandidateOrderOverrideDao.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/database/CandidateOrderOverrideDao.kt @@ -19,6 +19,15 @@ interface CandidateOrderOverrideDao { ) suspend fun findByInput(input: String): List + @Query( + """ + SELECT * FROM candidate_order_override + WHERE input IN (:inputs) + ORDER BY input ASC, rank ASC + """ + ) + suspend fun findByInputs(inputs: List): List + @Query( """ SELECT * FROM candidate_order_override diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/CandidateConversionSegment.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/CandidateConversionSegment.kt new file mode 100644 index 000000000..8120b8b69 --- /dev/null +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/CandidateConversionSegment.kt @@ -0,0 +1,15 @@ +package com.kazumaproject.markdownhelperkeyboard.converter.candidate + +/** + * Exact input/output correspondence for one node on a conversion path. + * + * Input offsets are UTF-16 indices into the original reading. Keeping offsets instead of slicing + * the completed candidate is required because readings and converted strings can have different + * lengths (for example, "きょう" and "今日"). + */ +data class CandidateConversionSegment( + val inputStart: Int, + val inputEnd: Int, + val output: String, +) + diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt index 4ecb7e414..fb0be5212 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/candidate/ExactInputCandidatePromotionPolicy.kt @@ -98,6 +98,20 @@ internal object ExactInputCandidatePromotionPolicy { "め", "ゆ", "り", + "ぎ", + "ぐ", + "げ", + "ご", + "ざ", + "じ", + "ず", + "ど", + "ば", + "び", + "ぶ", + "ぼ", + "ぴ", + "ぷ", ), ) diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt index 4c549a38a..9af6c650c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/engine/KanaKanjiEngine.kt @@ -23,6 +23,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.candidate.BunsetsuCand import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_ERA import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_TIME import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.converter.graph.GraphBuilder import com.kazumaproject.markdownhelperkeyboard.converter.graph.GraphNodeDedupMode import com.kazumaproject.markdownhelperkeyboard.converter.mozc.MozcBoundaryMode @@ -1083,6 +1084,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): List { val conversionContext = currentCoroutineContext() @@ -1154,6 +1156,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() @@ -1587,6 +1590,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): BunsetsuCandidateResult { val conversionContext = currentCoroutineContext() @@ -1660,6 +1664,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() @@ -2122,6 +2127,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): BunsetsuCandidateResult { val conversionContext = currentCoroutineContext() @@ -2195,6 +2201,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() @@ -2598,6 +2605,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): List { val conversionContext = currentCoroutineContext() @@ -2669,6 +2677,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() @@ -3055,6 +3064,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): List { val conversionContext = currentCoroutineContext() @@ -3125,6 +3135,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() @@ -3547,6 +3558,7 @@ class KanaKanjiEngine { beamWidth: Int = 20, incrementalSessionState: IncrementalSessionState? = null, predictionConfig: PredictionConfig = PredictionConfig(), + candidateSegmentCollector: MutableMap>? = null, ): BunsetsuCandidateResult { val conversionContext = currentCoroutineContext() @@ -3619,6 +3631,7 @@ class KanaKanjiEngine { beamWidth = beamWidth, cancellationCheck = { conversionContext.ensureActive() }, sessionState = incrementalSessionState?.pathState, + candidateSegmentCollector = candidateSegmentCollector, ) } conversionContext.ensureActive() diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt index b3bd1251a..d947b8719 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/path_algorithm/FindPath.kt @@ -11,6 +11,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.candidate.BunsetsuCand import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_LEARNED_DICTIONARY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_USER_DICTIONARY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.converter.graph.IncrementalGraphMetadata import com.kazumaproject.markdownhelperkeyboard.converter.mozc.MozcBoundaryCheckResult import com.kazumaproject.markdownhelperkeyboard.converter.mozc.MozcBoundaryChecker @@ -1042,6 +1043,7 @@ class FindPath( beamWidth: Int = 20, cancellationCheck: () -> Unit = {}, sessionState: SessionState? = null, + candidateSegmentCollector: MutableMap>? = null, ): MutableList = backwardAStar( graph = graph, length = length, @@ -1050,6 +1052,7 @@ class FindPath( beamWidth = beamWidth, cancellationCheck = cancellationCheck, sessionState = sessionState, + candidateSegmentCollector = candidateSegmentCollector, ) fun backwardAStar( @@ -1060,6 +1063,7 @@ class FindPath( beamWidth: Int = 20, cancellationCheck: () -> Unit = {}, sessionState: SessionState? = null, + candidateSegmentCollector: MutableMap>? = null, ): MutableList { cancellationCheck() val effectiveBeamWidth = beamWidth.coerceAtLeast(1) @@ -1157,6 +1161,10 @@ class FindPath( val yomiUsedFromNode = getYomiUsedFromPath(element) if (foundStrings.add(stringFromNode)) { + candidateSegmentCollector?.set( + stringFromNode, + getConversionSegmentsFromPath(element), + ) val candidate = Candidate( string = stringFromNode, type = resolveCandidateType( @@ -1591,6 +1599,7 @@ class FindPath( candidateTrace: MutableList? = null, cancellationCheck: () -> Unit = {}, sessionState: SessionState? = null, + candidateSegmentCollector: MutableMap>? = null, ): BunsetsuCandidateResult = backwardAStarWithBunsetsu( graph = graph, length = length, @@ -1603,6 +1612,7 @@ class FindPath( candidateTrace = candidateTrace, cancellationCheck = cancellationCheck, sessionState = sessionState, + candidateSegmentCollector = candidateSegmentCollector, ) fun backwardAStarWithBunsetsu( @@ -1617,6 +1627,7 @@ class FindPath( candidateTrace: MutableList? = null, cancellationCheck: () -> Unit = {}, sessionState: SessionState? = null, + candidateSegmentCollector: MutableMap>? = null, ): BunsetsuCandidateResult { cancellationCheck() val performanceState = sessionState?.takeIf { it.performanceProbeEnabled } @@ -1834,6 +1845,10 @@ class FindPath( ) if (foundStrings.add(stringFromNode)) { + candidateSegmentCollector?.set( + stringFromNode, + getConversionSegmentsFromPath(element), + ) if (pathMatchesSystemNgram(element, systemNgramDictionary)) { systemNgramMatchedCandidates.add(stringFromNode) } @@ -2559,6 +2574,30 @@ class FindPath( return result } + private fun getConversionSegmentsFromPath( + path: PathQueueElement, + ): List { + val result = mutableListOf() + var currentPosition = 0 + var current: PathQueueElement? = path + while (current != null) { + val node = current.node + if (node.tango != "BOS" && node.tango != "EOS") { + val nextPosition = currentPosition + node.len.toInt() + result.add( + CandidateConversionSegment( + inputStart = currentPosition, + inputEnd = nextPosition, + output = node.tango, + ), + ) + currentPosition = nextPosition + } + current = current.next + } + return result + } + private fun getBunsetsuPositionsFromPath( path: PathQueueElement, ): List { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt index c3bfe9151..ef5c2d89c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSession.kt @@ -2,6 +2,7 @@ package com.kazumaproject.markdownhelperkeyboard.converter.session import com.kazumaproject.markdownhelperkeyboard.converter.candidate.BunsetsuCandidateResult import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine import com.kazumaproject.markdownhelperkeyboard.converter.engine.PredictionConfig import com.kazumaproject.markdownhelperkeyboard.repository.LearnRepository @@ -41,11 +42,13 @@ data class KanaKanjiQueryRequest( val omissionSearchOffsetScore: Int, val beamWidth: Int, val predictionConfig: PredictionConfig = PredictionConfig(), + val collectCandidateSegments: Boolean = false, ) data class KanaKanjiQueryResult( val candidates: List, val bunsetsuResult: BunsetsuCandidateResult? = null, + val candidateSegmentsByString: Map> = emptyMap(), ) /** @@ -109,8 +112,9 @@ class KanaKanjiConversionSession( } } - private suspend fun queryOriginal(request: KanaKanjiQueryRequest): KanaKanjiQueryResult = - if (request.bunsetsuSeparation) { + private suspend fun queryOriginal(request: KanaKanjiQueryRequest): KanaKanjiQueryResult { + val segmentCollector = request.newCandidateSegmentCollector() + return if (request.bunsetsuSeparation) { engine.getCandidatesOriginalWithBunsetsu( input = request.input, n = request.n, @@ -129,7 +133,8 @@ class KanaKanjiConversionSession( beamWidth = request.beamWidth, incrementalSessionState = incrementalState, predictionConfig = request.predictionConfig, - ).asQueryResult() + candidateSegmentCollector = segmentCollector, + ).asQueryResult(segmentCollector) } else { KanaKanjiQueryResult( candidates = engine.getCandidatesOriginal( @@ -150,12 +155,16 @@ class KanaKanjiConversionSession( beamWidth = request.beamWidth, incrementalSessionState = incrementalState, predictionConfig = request.predictionConfig, + candidateSegmentCollector = segmentCollector, ), + candidateSegmentsByString = segmentCollector.orEmpty(), ) } + } - private suspend fun queryPrediction(request: KanaKanjiQueryRequest): KanaKanjiQueryResult = - if (request.bunsetsuSeparation) { + private suspend fun queryPrediction(request: KanaKanjiQueryRequest): KanaKanjiQueryResult { + val segmentCollector = request.newCandidateSegmentCollector() + return if (request.bunsetsuSeparation) { engine.getCandidatesWithBunsetsuSeparation( input = request.input, n = request.n, @@ -174,7 +183,8 @@ class KanaKanjiConversionSession( beamWidth = request.beamWidth, incrementalSessionState = incrementalState, predictionConfig = request.predictionConfig, - ).asQueryResult() + candidateSegmentCollector = segmentCollector, + ).asQueryResult(segmentCollector) } else { KanaKanjiQueryResult( candidates = engine.getCandidates( @@ -195,12 +205,16 @@ class KanaKanjiConversionSession( beamWidth = request.beamWidth, incrementalSessionState = incrementalState, predictionConfig = request.predictionConfig, + candidateSegmentCollector = segmentCollector, ), + candidateSegmentsByString = segmentCollector.orEmpty(), ) } + } - private suspend fun queryConversion(request: KanaKanjiQueryRequest): KanaKanjiQueryResult = - if (request.bunsetsuSeparation) { + private suspend fun queryConversion(request: KanaKanjiQueryRequest): KanaKanjiQueryResult { + val segmentCollector = request.newCandidateSegmentCollector() + return if (request.bunsetsuSeparation) { engine.getCandidatesWithoutPredictionWithBunsetsu( input = request.input, n = request.n, @@ -219,7 +233,8 @@ class KanaKanjiConversionSession( japanesePredictionEnabled = false, englishPredictionEnabled = false, ), - ).asQueryResult() + candidateSegmentCollector = segmentCollector, + ).asQueryResult(segmentCollector) } else { KanaKanjiQueryResult( candidates = engine.getCandidatesWithoutPrediction( @@ -240,10 +255,22 @@ class KanaKanjiConversionSession( japanesePredictionEnabled = false, englishPredictionEnabled = false, ), + candidateSegmentCollector = segmentCollector, ), + candidateSegmentsByString = segmentCollector.orEmpty(), ) } + } + + private fun KanaKanjiQueryRequest.newCandidateSegmentCollector(): + MutableMap>? = + if (collectCandidateSegments) LinkedHashMap() else null - private fun BunsetsuCandidateResult.asQueryResult(): KanaKanjiQueryResult = - KanaKanjiQueryResult(candidates = candidates, bunsetsuResult = this) + private fun BunsetsuCandidateResult.asQueryResult( + segmentCollector: Map>?, + ): KanaKanjiQueryResult = KanaKanjiQueryResult( + candidates = candidates, + bunsetsuResult = this, + candidateSegmentsByString = segmentCollector.orEmpty(), + ) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 3c0b7ff1e..143543f68 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -180,6 +180,7 @@ import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_USER_DICTIONARY import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CANDIDATE_TYPE_USER_TEMPLATE import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.converter.candidate.ExactInputCandidatePromotionPolicy import com.kazumaproject.markdownhelperkeyboard.converter.candidate.QWERTY_GLIDE_CANDIDATE_TYPE import com.kazumaproject.markdownhelperkeyboard.converter.candidate.ZenzCandidate @@ -463,7 +464,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val leftContext: String, val rightContext: String, val cacheKey: String, - val rerankTargets: List> + val rerankTargets: List>, + val candidateSegmentsByString: Map>, ) private data class ZenzContext( @@ -1886,6 +1888,11 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private var zenzLiveLatestResultMeta: ZenzLiveResultMeta? = null private var zenzRerankJob: Job? = null private var zenzRerankRequestToken: Long = 0L + @Volatile + private var latestCandidateSegmentInput: String = "" + @Volatile + private var latestCandidateSegmentsByString: + Map> = emptyMap() private val zenzRerankCache = object : LinkedHashMap>(16, 0.75f, true) { override fun removeEldestEntry(eldest: MutableMap.MutableEntry>?): Boolean { return size > 24 @@ -15214,7 +15221,12 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, leftContext = zenzContext.leftContext, rightContext = zenzContext.rightContext, cacheKey = cacheKey, - rerankTargets = rerankTargets + rerankTargets = rerankTargets, + candidateSegmentsByString = if (latestCandidateSegmentInput == insertString) { + latestCandidateSegmentsByString + } else { + emptyMap() + }, ) } @@ -15290,6 +15302,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, applyMergedCandidateOrder( input = insertString, candidates = reranked, + candidateSegmentsByString = plan.candidateSegmentsByString, ) } @@ -22277,6 +22290,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val orderedCandidates = applyMergedCandidateOrder( input = insertString, candidates = filteredCandidates, + candidateSegmentsByString = coreResult.candidateSegmentsByString, ) if (candidateRequestTracker.isCurrent(token)) { @@ -22416,6 +22430,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val orderedCandidates = applyMergedCandidateOrder( input = insertString, candidates = filteredCandidates, + candidateSegmentsByString = coreResult.candidateSegmentsByString, ) if (token == null || candidateRequestTracker.isCurrent(token)) { @@ -22538,6 +22553,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, val orderedCandidates = applyMergedCandidateOrder( input = insertString, candidates = filteredCandidates, + candidateSegmentsByString = coreResult.candidateSegmentsByString, ) if (candidateRequestTracker.isCurrent(token)) { @@ -22554,6 +22570,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, private suspend fun applyMergedCandidateOrder( input: String, candidates: List, + candidateSegmentsByString: Map> = emptyMap(), ): List { val promotedCandidates = measureDebugStage("IMEService.exactInputPromotion") { ExactInputCandidatePromotionPolicy.promote( @@ -22562,10 +22579,15 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) } return if (appPreference.candidate_order_override_enable_preference == true) { + if (candidateSegmentsByString.isNotEmpty()) { + latestCandidateSegmentInput = input + latestCandidateSegmentsByString = candidateSegmentsByString + } measureDebugStage("IMEService.candidateOrderOverride") { candidateOrderOverrideRepository.applyOrderFromSnapshot( input = input, candidates = promotedCandidates, + candidateSegmentsByString = candidateSegmentsByString, ) } } else { @@ -22621,6 +22643,8 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, omissionSearchOffsetScore = omissionSearchOffsetScorePreference ?: 1900, beamWidth = conversionBeamWidth, predictionConfig = predictionConfig, + collectCandidateSegments = + appPreference.candidate_order_override_enable_preference == true, ) ) if (BuildConfig.DEBUG) { diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/KanaKanjiEngineEntryPoint.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/KanaKanjiEngineEntryPoint.kt index 22f8dc853..f710e89a5 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/KanaKanjiEngineEntryPoint.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/di/KanaKanjiEngineEntryPoint.kt @@ -1,10 +1,11 @@ package com.kazumaproject.markdownhelperkeyboard.ime_service.di import com.kazumaproject.markdownhelperkeyboard.converter.engine.KanaKanjiEngine -import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryRepository -import com.kazumaproject.markdownhelperkeyboard.repository.NgramRuleRepository -import com.kazumaproject.markdownhelperkeyboard.ngram_rule.NgramRuleScorerManager import com.kazumaproject.markdownhelperkeyboard.dictionary_override.DictionaryBinaryReader +import com.kazumaproject.markdownhelperkeyboard.ngram_rule.NgramRuleScorerManager +import com.kazumaproject.markdownhelperkeyboard.repository.CandidateOrderOverrideRepository +import com.kazumaproject.markdownhelperkeyboard.repository.NgramRuleRepository +import com.kazumaproject.markdownhelperkeyboard.repository.UserDictionaryRepository import dagger.hilt.EntryPoint import dagger.hilt.InstallIn import dagger.hilt.components.SingletonComponent @@ -17,4 +18,5 @@ interface KanaKanjiEngineEntryPoint { fun ngramRuleRepository(): NgramRuleRepository fun ngramRuleScorerManager(): NgramRuleScorerManager fun dictionaryBinaryReader(): DictionaryBinaryReader + fun candidateOrderOverrideRepository(): CandidateOrderOverrideRepository } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/CandidateOrderOverrideRepository.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/CandidateOrderOverrideRepository.kt index 9dfe9851f..ed9f45248 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/CandidateOrderOverrideRepository.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/repository/CandidateOrderOverrideRepository.kt @@ -3,10 +3,11 @@ package com.kazumaproject.markdownhelperkeyboard.repository import com.kazumaproject.markdownhelperkeyboard.candidate_order.database.CandidateOrderOverrideDao import com.kazumaproject.markdownhelperkeyboard.candidate_order.database.CandidateOrderOverrideEntity import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import kotlinx.coroutines.flow.Flow -import kotlinx.coroutines.flow.onEach import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock +import java.util.LinkedHashMap import javax.inject.Inject import javax.inject.Singleton @@ -30,21 +31,90 @@ object CandidateOrderOverrideSorter { ) .map { it.value } } + + fun applyByConversionSegment( + input: String, + candidates: List, + overridesByInput: Map>, + candidateSegmentsByString: Map>, + ): List { + if (candidates.size <= 1 || overridesByInput.isEmpty()) return candidates + + val exactOverrides = overridesByInput[input].orEmpty() + if (exactOverrides.isNotEmpty()) { + return apply(candidates, exactOverrides) + } + if (candidateSegmentsByString.isEmpty()) return candidates + + val savedInputPrefixes = overridesByInput.keys + .asSequence() + .filter { savedInput -> + savedInput.isNotEmpty() && + savedInput.length < input.length && + input.startsWith(savedInput) + } + .sortedByDescending { it.length } + + for (savedInput in savedInputPrefixes) { + val rankBySegmentOutput = overridesByInput.getValue(savedInput) + .associate { it.candidate to it.rank } + val ranks = candidates.map { candidate -> + val leadingOutput = candidateSegmentsByString[candidate.string] + ?.leadingOutputAtInputEnd(savedInput.length) + leadingOutput?.let(rankBySegmentOutput::get) ?: Int.MAX_VALUE + } + if (ranks.all { it == Int.MAX_VALUE }) continue + + return candidates + .withIndex() + .sortedWith( + compareBy> { ranks[it.index] } + .thenBy { it.index }, + ) + .map { it.value } + } + + return candidates + } + + private fun List.leadingOutputAtInputEnd( + targetInputEnd: Int, + ): String? { + if (targetInputEnd <= 0) return null + + var expectedInputStart = 0 + val output = StringBuilder() + for (segment in this) { + if ( + segment.inputStart != expectedInputStart || + segment.inputEnd <= segment.inputStart || + segment.inputEnd > targetInputEnd + ) { + return null + } + output.append(segment.output) + expectedInputStart = segment.inputEnd + if (expectedInputStart == targetInputEnd) { + return output.toString() + } + } + return null + } } @Singleton class CandidateOrderOverrideRepository @Inject constructor( private val dao: CandidateOrderOverrideDao ) { - @Volatile - private var candidateOrderOverrideMap: Map>? = null - - private val snapshotMutex = Mutex() + private val cacheMutex = Mutex() + private val overridesByInputCache = + LinkedHashMap>( + MAX_CACHED_INPUTS, + 0.75f, + true, + ) - fun observeAll(): Flow> = - dao.observeAll().onEach { entities -> - updateSnapshot(entities) - } + fun observeAll(): Flow> = dao.observeAll() suspend fun saveOrder(input: String, candidates: List) { val normalizedInput = input.trim() @@ -61,7 +131,7 @@ class CandidateOrderOverrideRepository @Inject constructor( ) } dao.replaceForInput(normalizedInput, entities) - updateSnapshot(dao.getAll()) + invalidateInput(normalizedInput) } suspend fun applyOrder( @@ -71,7 +141,7 @@ class CandidateOrderOverrideRepository @Inject constructor( val normalizedInput = input.trim() if (normalizedInput.isEmpty() || candidates.size <= 1) return candidates - val overrides = dao.findByInput(normalizedInput) + val overrides = loadOverridesForInputs(listOf(normalizedInput))[normalizedInput].orEmpty() if (overrides.isEmpty()) return candidates return CandidateOrderOverrideSorter.apply(candidates, overrides) @@ -79,50 +149,87 @@ class CandidateOrderOverrideRepository @Inject constructor( suspend fun applyOrderFromSnapshot( input: String, - candidates: List + candidates: List, + candidateSegmentsByString: Map> = emptyMap(), ): List { val normalizedInput = input.trim() if (normalizedInput.isEmpty() || candidates.size <= 1) return candidates - val overrides = currentSnapshot()[normalizedInput].orEmpty() - if (overrides.isEmpty()) return candidates + val relevantOverrides = loadOverridesForInputs(normalizedInput.leadingPrefixes()) + if (relevantOverrides.isEmpty()) return candidates - return CandidateOrderOverrideSorter.apply(candidates, overrides) + return CandidateOrderOverrideSorter.applyByConversionSegment( + input = normalizedInput, + candidates = candidates, + overridesByInput = relevantOverrides, + candidateSegmentsByString = candidateSegmentsByString, + ) } suspend fun deleteByInput(input: String) { val normalizedInput = input.trim() if (normalizedInput.isNotEmpty()) { dao.deleteByInput(normalizedInput) - updateSnapshot(dao.getAll()) + invalidateInput(normalizedInput) } } suspend fun deleteAll() { dao.deleteAll() - updateSnapshot(emptyList()) + cacheMutex.withLock { overridesByInputCache.clear() } } suspend fun deleteById(id: Int) { dao.deleteById(id) - updateSnapshot(dao.getAll()) + cacheMutex.withLock { overridesByInputCache.clear() } + } + + private suspend fun loadOverridesForInputs( + inputs: List, + ): Map> = cacheMutex.withLock { + val distinctInputs = inputs.distinct() + val missingInputs = distinctInputs.filterNot(overridesByInputCache::containsKey) + if (missingInputs.isNotEmpty()) { + val loadedByInput = dao.findByInputs(missingInputs) + .groupBy { it.input.trim() } + .mapValues { (_, entities) -> entities.sortedBy { it.rank } } + for (input in missingInputs) { + // Empty entries are cached too, avoiding a query on every conversion. + overridesByInputCache[input] = loadedByInput[input].orEmpty() + } + trimCache() + } + + buildMap { + for (input in distinctInputs) { + overridesByInputCache[input] + ?.takeIf { it.isNotEmpty() } + ?.let { put(input, it) } + } + } } - private suspend fun currentSnapshot(): Map> { - candidateOrderOverrideMap?.let { return it } + private suspend fun invalidateInput(input: String) { + cacheMutex.withLock { overridesByInputCache.remove(input) } + } + + private fun trimCache() { + val iterator = overridesByInputCache.entries.iterator() + while (overridesByInputCache.size > MAX_CACHED_INPUTS && iterator.hasNext()) { + iterator.next() + iterator.remove() + } + } - return snapshotMutex.withLock { - candidateOrderOverrideMap ?: updateSnapshot(dao.getAll()) + private fun String.leadingPrefixes(): List = buildList { + var end = 0 + while (end < this@leadingPrefixes.length) { + end = this@leadingPrefixes.offsetByCodePoints(end, 1) + add(this@leadingPrefixes.substring(0, end)) } } - private fun updateSnapshot( - entities: List - ): Map> { - val snapshot = entities - .groupBy { it.input.trim() } - .mapValues { (_, values) -> values.sortedBy { it.rank } } - candidateOrderOverrideMap = snapshot - return snapshot + private companion object { + const val MAX_CACHED_INPUTS = 256 } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSavedOrderEditTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSavedOrderEditTest.kt index fcf1c9c40..5fc879017 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSavedOrderEditTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSavedOrderEditTest.kt @@ -9,6 +9,7 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.test.runTest import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Test @@ -118,6 +119,40 @@ class CandidateOrderOverrideSavedOrderEditTest { ) } + @Test + fun segmentOrderQueriesOnlyInputPrefixesAndReusesBoundedLookup() = runTest { + val dao = FakeCandidateOrderOverrideDao( + initialRows = mutableListOf( + entity(input = "ひ", candidate = "火", rank = 1), + entity(input = "べんちまっぷ00001", candidate = "候補", rank = 1), + ), + ) + val repository = CandidateOrderOverrideRepository(dao) + val candidates = listOf(candidate("日を"), candidate("火を")) + val segments = mapOf( + "日を" to listOf( + candidateSegment(0, 1, "日"), + candidateSegment(1, 2, "を"), + ), + "火を" to listOf( + candidateSegment(0, 1, "火"), + candidateSegment(1, 2, "を"), + ), + ) + + repeat(2) { + assertEquals( + listOf("火を", "日を"), + repository.applyOrderFromSnapshot("ひを", candidates, segments).map { it.string }, + ) + } + + assertEquals(1, dao.findByInputsCalls.size) + assertEquals(setOf("ひ", "ひを"), dao.findByInputsCalls.single().toSet()) + assertFalse(dao.findByInputsCalls.single().contains("べんちまっぷ00001")) + assertEquals(0, dao.getAllCallCount) + } + private fun entity( input: String, candidate: String, @@ -140,12 +175,21 @@ class CandidateOrderOverrideSavedOrderEditTest { score = 0 ) + private fun candidateSegment(inputStart: Int, inputEnd: Int, output: String) = + com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment( + inputStart = inputStart, + inputEnd = inputEnd, + output = output, + ) + private class FakeCandidateOrderOverrideDao( initialRows: MutableList ) : CandidateOrderOverrideDao { private val rows = initialRows private val rowsFlow = MutableStateFlow(rows.toList()) val deletedInputs = mutableListOf() + val findByInputsCalls = mutableListOf>() + var getAllCallCount = 0 fun rowsForInput(input: String): List { return rows.filter { it.input == input }.sortedBy { it.rank } @@ -155,11 +199,21 @@ class CandidateOrderOverrideSavedOrderEditTest { return rowsForInput(input) } + override suspend fun findByInputs( + inputs: List, + ): List { + findByInputsCalls += inputs.toList() + return rows + .filter { it.input in inputs } + .sortedWith(compareBy { it.input }.thenBy { it.rank }) + } + override fun observeAll(): Flow> { return rowsFlow } override suspend fun getAll(): List { + getAllCallCount++ return rows.sortedWith(compareBy { it.input }.thenBy { it.rank }) } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSorterTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSorterTest.kt index f6ff4877f..aec3ec8a5 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSorterTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/candidate_order/CandidateOrderOverrideSorterTest.kt @@ -2,6 +2,7 @@ package com.kazumaproject.markdownhelperkeyboard.candidate_order import com.kazumaproject.markdownhelperkeyboard.candidate_order.database.CandidateOrderOverrideEntity import com.kazumaproject.markdownhelperkeyboard.converter.candidate.Candidate +import com.kazumaproject.markdownhelperkeyboard.converter.candidate.CandidateConversionSegment import com.kazumaproject.markdownhelperkeyboard.repository.CandidateOrderOverrideSorter import org.junit.Assert.assertEquals import org.junit.Assert.assertSame @@ -80,6 +81,76 @@ class CandidateOrderOverrideSorterTest { assertEquals(listOf("修道", "主導", "手動", "酒道"), result.words()) } + @Test + fun exactConversionNodePrefixAppliesSavedOrderToLongerInput() { + val candidates = candidates("日を", "火を", "陽を") + val result = CandidateOrderOverrideSorter.applyByConversionSegment( + input = "ひを", + candidates = candidates, + overridesByInput = mapOf( + "ひ" to overridesFor("ひ", "火" to 1, "日" to 2, "陽" to 3), + ), + candidateSegmentsByString = mapOf( + "日を" to segments(0, 1, "日", 1, 2, "を"), + "火を" to segments(0, 1, "火", 1, 2, "を"), + "陽を" to segments(0, 1, "陽", 1, 2, "を"), + ), + ) + + assertEquals(listOf("火を", "日を", "陽を"), result.words()) + } + + @Test + fun textPrefixWithoutConversionBoundaryDoesNotMatch() { + val candidates = candidates("日を", "火を") + val result = CandidateOrderOverrideSorter.applyByConversionSegment( + input = "ひを", + candidates = candidates, + overridesByInput = mapOf("ひ" to overridesFor("ひ", "火" to 1, "日" to 2)), + candidateSegmentsByString = mapOf( + "日を" to segments(0, 2, "日を"), + "火を" to segments(0, 2, "火を"), + ), + ) + + assertEquals(listOf("日を", "火を"), result.words()) + } + + @Test + fun exactFullInputOrderTakesPriorityOverShorterSegmentOrder() { + val candidates = candidates("日を", "火を") + val result = CandidateOrderOverrideSorter.applyByConversionSegment( + input = "ひを", + candidates = candidates, + overridesByInput = mapOf( + "ひ" to overridesFor("ひ", "火" to 1, "日" to 2), + "ひを" to overridesFor("ひを", "日を" to 1, "火を" to 2), + ), + candidateSegmentsByString = mapOf( + "日を" to segments(0, 1, "日", 1, 2, "を"), + "火を" to segments(0, 1, "火", 1, 2, "を"), + ), + ) + + assertEquals(listOf("日を", "火を"), result.words()) + } + + @Test + fun savedOrderDoesNotMatchAConversionNodeLaterInInput() { + val candidates = candidates("亜日", "亜火") + val result = CandidateOrderOverrideSorter.applyByConversionSegment( + input = "あひ", + candidates = candidates, + overridesByInput = mapOf("ひ" to overridesFor("ひ", "火" to 1, "日" to 2)), + candidateSegmentsByString = mapOf( + "亜日" to segments(0, 1, "亜", 1, 2, "日"), + "亜火" to segments(0, 1, "亜", 1, 2, "火"), + ), + ) + + assertEquals(listOf("亜日", "亜火"), result.words()) + } + private fun candidates(vararg words: String): List = words.map { Candidate( @@ -91,9 +162,14 @@ class CandidateOrderOverrideSorterTest { } private fun overrides(vararg ranks: Pair): List = - ranks.map { + overridesFor("しゅどう", *ranks) + + private fun overridesFor( + input: String, + vararg ranks: Pair, + ): List = ranks.map { CandidateOrderOverrideEntity( - input = "しゅどう", + input = input, candidate = it.first, rank = it.second, createdAt = 1L, @@ -101,5 +177,15 @@ class CandidateOrderOverrideSorterTest { ) } + private fun segments( + vararg values: Any, + ): List = values.toList().chunked(3).map { chunk -> + CandidateConversionSegment( + inputStart = chunk[0] as Int, + inputEnd = chunk[1] as Int, + output = chunk[2] as String, + ) + } + private fun List.words(): List = map { it.string } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/MozcCompoundConversionParityTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/MozcCompoundConversionParityTest.kt index 37e497c71..a896ebca0 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/MozcCompoundConversionParityTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/MozcCompoundConversionParityTest.kt @@ -108,6 +108,27 @@ class MozcCompoundConversionParityTest { ) } + @Test + fun hiwoCandidatePathsKeepKanjiAndParticleAsExactNodes() { + val trace = engine.convertWithTrace("ひを") + val relevantCandidates = trace.finalCandidates.filter { + it.candidate == "火を" || it.candidate == "日を" + } + + assertTrue( + trace.finalCandidates.take(40).joinToString("\n"), + relevantCandidates.any { + it.candidate == "火を" && it.path == listOf("火", "を") + }, + ) + assertTrue( + trace.finalCandidates.take(40).joinToString("\n"), + relevantCandidates.any { + it.candidate == "日を" && it.path == listOf("日", "を") + }, + ) + } + companion object { private lateinit var engine: KanaKanjiEngine diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt index 4cf535b17..c6f107af6 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/converter/session/KanaKanjiConversionSessionParityTest.kt @@ -58,10 +58,30 @@ class KanaKanjiConversionSessionParityTest { legacyResult.bunsetsuResult?.splitPatternByCandidateString, incrementalResult.bunsetsuResult?.splitPatternByCandidateString, ) + assertEquals( + "$input/$mode/bunsetsu=$bunsetsu conversion segments", + legacyResult.candidateSegmentsByString, + incrementalResult.candidateSegmentsByString, + ) } } } + @Test + fun segmentCollectionUsesExactPathNodesWhenBunsetsuDisplayIsDisabled() = runBlocking { + val result = KanaKanjiConversionSession(engine, ConversionBackend.LEGACY).query( + request("ひを", CandidateQueryMode.CONVERSION, bunsetsu = false), + ) + + assertEquals( + listOf(Triple(0, 1, "火"), Triple(1, 2, "を")), + result.candidateSegmentsByString.getValue("火を").map { + Triple(it.inputStart, it.inputEnd, it.output) + }, + ) + assertEquals(null, result.bunsetsuResult) + } + @Test fun cancelledInPlaceAppendIsDiscardedBeforeNextRequest() = runBlocking { val localEngine = TestEngineFactory.create() @@ -207,6 +227,7 @@ class KanaKanjiConversionSessionParityTest { typoCorrectionOffsetScore = 3000, omissionSearchOffsetScore = 1900, beamWidth = 20, + collectCandidateSegments = true, ) private fun List.fingerprint(): List> = map { candidate -> From 1664b116a7dfc860b90fe799c86d5db7f07392e2 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 3 Aug 2026 10:52:43 -0400 Subject: [PATCH 18/24] improve commit real time refrection --- .../FastInputMatrixInstrumentedTest.kt | 123 ++++++++++++++++++ .../ime_service/IMEService.kt | 58 +++++++-- .../FlickInputPreviewCoordinator.kt | 14 +- .../FlickInputPreviewCoordinatorTest.kt | 22 +++- ...review-implementation-report-2026-08-02.md | 27 ++-- 5 files changed, 212 insertions(+), 32 deletions(-) diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt index 185cde18b..5ad228299 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt @@ -17,6 +17,9 @@ import android.os.ParcelFileDescriptor import android.os.PowerManager import android.os.SystemClock import android.provider.Settings +import android.text.Spanned +import android.text.style.BackgroundColorSpan +import android.text.style.UnderlineSpan import android.util.Log import android.view.InputDevice import android.view.MotionEvent @@ -58,6 +61,9 @@ class FastInputMatrixInstrumentedTest { try { scenario = launchHost(session.context) rotateAndVerify(TestOrientation.PORTRAIT) + val defaultPreviewBackgroundColor = session.context.getColor( + com.kazumaproject.core.R.color.char_in_edit_color + ) val sumireStyles = listOf( "default", @@ -77,6 +83,7 @@ class FastInputMatrixInstrumentedTest { check( session.preferences.edit() .putBoolean("flick_editor_preview_preference", true) + .putBoolean("theme_custom_input_color_enable", false) .putString("sumire_keyboard_style_preference", style ?: "default") .putString("sumire_input_method_preference", "switch-mode-effective") .putString("keyboard_touch_effect_type_preference", "none") @@ -104,6 +111,12 @@ class FastInputMatrixInstrumentedTest { keyboard.primeText, awaitEditorText(scenario) { it.isNotEmpty() }, ) + assertEditorPreviewDecoration( + scenario = scenario, + expectedText = keyboard.primeText, + expectedBackgroundColor = defaultPreviewBackgroundColor, + caseName = "$keyboard/$style DOWN", + ) assertTrue( "Candidate generation started before UP for $keyboard/$style", findCandidateState().texts.isEmpty(), @@ -129,6 +142,11 @@ class FastInputMatrixInstrumentedTest { check( session.preferences.edit() .putBoolean("flick_editor_preview_preference", true) + .putBoolean("theme_custom_input_color_enable", true) + .putInt( + "theme_custom_pre_edit_bg_color", + PREVIEW_TEST_BACKGROUND_COLOR, + ) .putString("sumire_keyboard_style_preference", "default") .commit() ) @@ -158,6 +176,12 @@ class FastInputMatrixInstrumentedTest { it.isNotEmpty() && it != keyboard.primeText } assertTrue("MOVE did not replace preview for $keyboard", movedPreview.isNotEmpty()) + assertEditorPreviewDecoration( + scenario = scenario, + expectedText = movedPreview, + expectedBackgroundColor = PREVIEW_TEST_BACKGROUND_COLOR, + caseName = "$keyboard MOVE", + ) assertTrue( injectSinglePointerEvent(downTime, MotionEvent.ACTION_UP, end) ) @@ -1382,6 +1406,61 @@ class FastInputMatrixInstrumentedTest { return text } + private fun assertEditorPreviewDecoration( + scenario: ActivityScenario, + expectedText: String, + expectedBackgroundColor: Int, + caseName: String, + ) { + val deadline = SystemClock.uptimeMillis() + RESULT_TIMEOUT_MS + var latest = readEditorDecoration(scenario) + while (SystemClock.uptimeMillis() < deadline) { + latest = readEditorDecoration(scenario) + if (latest.matches(expectedText, expectedBackgroundColor)) return + SystemClock.sleep(PREVIEW_TEXT_POLL_MS) + } + assertTrue( + "$caseName did not retain the pre-edit background/underline spans: $latest", + latest.matches(expectedText, expectedBackgroundColor), + ) + } + + private fun readEditorDecoration( + scenario: ActivityScenario + ): EditorDecorationSnapshot { + var snapshot = EditorDecorationSnapshot.Empty + scenario.onActivity { activity -> + val text = activity.editText.text + snapshot = EditorDecorationSnapshot( + text = text?.toString().orEmpty(), + backgrounds = text.getSpans( + 0, + text.length, + BackgroundColorSpan::class.java, + ).map { span -> + BackgroundSpanSnapshot( + color = span.backgroundColor, + start = text.getSpanStart(span), + end = text.getSpanEnd(span), + flags = text.getSpanFlags(span), + ) + }, + underlines = text.getSpans( + 0, + text.length, + UnderlineSpan::class.java, + ).map { span -> + SpanRangeSnapshot( + start = text.getSpanStart(span), + end = text.getSpanEnd(span), + flags = text.getSpanFlags(span), + ) + }, + ) + } + return snapshot + } + private fun awaitEditorText( scenario: ActivityScenario, predicate: (String) -> Boolean, @@ -2455,6 +2534,49 @@ class FastInputMatrixInstrumentedTest { val texts: List ) + private data class EditorDecorationSnapshot( + val text: String, + val backgrounds: List, + val underlines: List, + ) { + fun matches(expectedText: String, expectedBackgroundColor: Int): Boolean { + val expectedEnd = expectedText.length + val hasBackground = backgrounds.any { span -> + span.color == expectedBackgroundColor && + span.start == 0 && + span.end == expectedEnd && + span.flags and Spanned.SPAN_COMPOSING != 0 + } + val hasUnderline = underlines.any { span -> + span.start == 0 && + span.end == expectedEnd && + span.flags and Spanned.SPAN_COMPOSING != 0 + } + return text == expectedText && hasBackground && hasUnderline + } + + companion object { + val Empty = EditorDecorationSnapshot( + text = "", + backgrounds = emptyList(), + underlines = emptyList(), + ) + } + } + + private data class BackgroundSpanSnapshot( + val color: Int, + val start: Int, + val end: Int, + val flags: Int, + ) + + private data class SpanRangeSnapshot( + val start: Int, + val end: Int, + val flags: Int, + ) + private data class FlickVerification( val name: String, val normalizedDelta: PointF, @@ -2633,6 +2755,7 @@ class FastInputMatrixInstrumentedTest { private const val FLICK_STEP_MS = 18L private const val PREVIEW_HOLD_ASSERT_MS = 120L private const val PREVIEW_TEXT_POLL_MS = 4L + private const val PREVIEW_TEST_BACKGROUND_COLOR = 0x66336699 private const val PREVIEW_PERFORMANCE_WARMUP_GESTURES = 30 private const val PREVIEW_PERFORMANCE_GESTURES = 500 private const val PREVIEW_GC_SETTLE_MS = 250L diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 143543f68..75cb18c3c 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -1362,6 +1362,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) private val flickInputPreviewCoordinator = FlickInputPreviewCoordinator( composingTextArbiter = composingTextArbiter, + createPreviewText = ::createFlickPreviewComposingText, ) private val tenKeyFlickTextPreviewListener = FlickTextPreviewListener { event -> flickInputPreviewCoordinator.onEvent( @@ -21478,6 +21479,26 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, clearBunsetsuConversionSession() } + /** Down/Moveプレビューにも通常入力と同じPreEdit装飾を適用する。 */ + private fun createFlickPreviewComposingText(text: String): CharSequence { + return applyPreEditComposingSpans( + spannableString = SpannableString(text), + inputLength = text.length, + underlineEnd = text.length, + backgroundColor = if (customComposingTextPreference == true) { + inputCompositionBackgroundColor + ?: getColor(com.kazumaproject.core.R.color.char_in_edit_color) + } else { + getColor(com.kazumaproject.core.R.color.char_in_edit_color) + }, + textColor = if (customComposingTextPreference == true) { + inputCompositionTextColor + } else { + null + }, + ) + } + /** * 編集前（PreEdit）のテキスト装飾を設定する * * @param backgroundColor 背景色 (Color Int) @@ -21491,37 +21512,48 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, ) { val inputLength = inputString.length val tailLength = stringInTail.get().length + applyPreEditComposingSpans( + spannableString = spannableString, + inputLength = inputLength, + underlineEnd = inputLength + tailLength, + backgroundColor = backgroundColor, + textColor = textColor, + ) - spannableString.apply { - // 背景色の設定 + Timber.d("launchInputString: setComposingTextPreEdit $spannableString") + setComposingText(spannableString, 1) + } + + private fun applyPreEditComposingSpans( + spannableString: SpannableString, + inputLength: Int, + underlineEnd: Int, + @ColorInt backgroundColor: Int, + @ColorInt textColor: Int? = null, + ): SpannableString { + val spanFlag = Spannable.SPAN_EXCLUSIVE_EXCLUSIVE or Spannable.SPAN_COMPOSING + return spannableString.apply { setSpan( BackgroundColorSpan(backgroundColor), 0, inputLength, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE or Spannable.SPAN_COMPOSING + spanFlag, ) - - // テキスト色の設定（指定がある場合のみ） textColor?.let { color -> setSpan( ForegroundColorSpan(color), 0, inputLength, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE or Spannable.SPAN_COMPOSING + spanFlag, ) } - - // 下線の設定 setSpan( UnderlineSpan(), 0, - inputLength + tailLength, - Spannable.SPAN_EXCLUSIVE_EXCLUSIVE or Spannable.SPAN_COMPOSING + underlineEnd, + spanFlag, ) } - - Timber.d("launchInputString: setComposingTextPreEdit $spannableString") - setComposingText(spannableString, 1) } /** diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt index 845de5e4d..37deb625a 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt @@ -5,6 +5,7 @@ import com.kazumaproject.core.domain.flick.FlickTextSelection internal class FlickInputPreviewCoordinator( private val composingTextArbiter: ComposingTextArbiter, + private val createPreviewText: (String) -> CharSequence = { it }, private val mutationResolver: ( FlickMutationSnapshot, FlickTextSelection, @@ -115,9 +116,7 @@ internal class FlickInputPreviewCoordinator( (previousMutation as? FlickTextMutation.ReplaceComposingInput)?.resultInput val needsEditorUpdate = !composingTextArbiter.isPreviewVisible() || previousResult != mutation.resultInput - if (needsEditorUpdate && - !composingTextArbiter.showPreview(mutation.resultInput, 1) - ) { + if (needsEditorUpdate && !showPreview(mutation)) { active = null return } @@ -166,7 +165,7 @@ internal class FlickInputPreviewCoordinator( private fun renderMutation(mutation: FlickTextMutation) { when (mutation) { is FlickTextMutation.ReplaceComposingInput -> { - if (!composingTextArbiter.showPreview(mutation.resultInput, 1)) { + if (!showPreview(mutation)) { active = null } } @@ -174,4 +173,11 @@ internal class FlickInputPreviewCoordinator( FlickTextMutation.NoTextOutput -> composingTextArbiter.suspendPreviewAndRestore() } } + + private fun showPreview(mutation: FlickTextMutation.ReplaceComposingInput): Boolean { + return composingTextArbiter.showPreview( + createPreviewText(mutation.resultInput), + 1, + ) + } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt index 9abc70111..e6bccd528 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt @@ -60,7 +60,22 @@ class FlickInputPreviewCoordinatorTest { assertEquals("text:かあ:1", fixture.writes.last()) } - private class Fixture { + @Test + fun downAndMoveUsePreviewTextFactory() { + val fixture = Fixture(createPreviewText = { text -> "decorated[$text]" }) + + fixture.coordinator.onEvent(started("あ"), fixture.context()) + fixture.coordinator.onEvent(changed("う"), fixture.context()) + + assertEquals( + listOf("text:decorated[あ]:1", "text:decorated[う]:1"), + fixture.writes, + ) + } + + private class Fixture( + createPreviewText: (String) -> CharSequence = { it }, + ) { val writes = mutableListOf() val arbiter = ComposingTextArbiter( writeComposingText = { text, cursor -> @@ -72,7 +87,10 @@ class FlickInputPreviewCoordinatorTest { true }, ) - val coordinator = FlickInputPreviewCoordinator(arbiter) + val coordinator = FlickInputPreviewCoordinator( + composingTextArbiter = arbiter, + createPreviewText = createPreviewText, + ) fun context(baseInput: String = "", sessionId: Long = 1L) = FlickPreviewContext( source = FlickPreviewSource.TENKEY, diff --git a/docs/flick-editor-preview-implementation-report-2026-08-02.md b/docs/flick-editor-preview-implementation-report-2026-08-02.md index e3dab98af..c283a8e9e 100644 --- a/docs/flick-editor-preview-implementation-report-2026-08-02.md +++ b/docs/flick-editor-preview-implementation-report-2026-08-02.md @@ -1,12 +1,12 @@ # フリック文字プレビュー 実装・実機試験報告 -試験日: 2026-08-02 +試験日: 2026-08-02（背景Span修正の追試: 2026-08-03） ## 結論 `onDown` と `onMove` で、選択中の TenKey／Sumire の文字を入力先アプリの composing text に仮表示する設定を実装した。設定は新規設定画面と従来設定画面の両方に追加し、デフォルトは OFF とした。OFF の場合は従来どおり `onUp` または二本目の指を検知した時点で入力へ反映する。 -Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま、Down 表示、Move 置換、Up 確定、Cancel 復元が正常に動作した。候補表示時間に有意と判断できる悪化は観測されなかった。プレビューONでは Down／Move／Cancel ごとに入力先アプリとの composing-text 通信が発生するため、合成ジェスチャ試験の同期処理時間と一時割り当て量は増えたが、GC後PSSの増加は観測されなかった。 +Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま、Down 表示、Move 置換、既存PreEditと同じ背景・文字色・下線Span、Up 確定、Cancel 復元が正常に動作した。候補表示時間に有意と判断できる悪化は観測されなかった。プレビューONでは Down／Move／Cancel ごとに入力先アプリとの composing-text 通信が発生するため、合成ジェスチャ試験の同期処理時間と一時割り当て量は増えたが、GC後PSSの増加は観測されなかった。 ## 実装内容 @@ -18,6 +18,7 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま - 通常表示とフローティング表示の両方へ同じリスナーを接続 - `onDown`: タップ位置の文字を仮表示 - `onMove`: 現在選択中の文字で仮表示を置換 +- Down／Moveとも通常入力のPreEditと同じ `BackgroundColorSpan`、任意の `ForegroundColorSpan`、`UnderlineSpan` を適用し、カスタム入力色設定にも追従 - `onUp`: プレビューと同一の入力変換を一度だけ確定し、その後に従来どおり候補生成 - `ACTION_CANCEL`、ビュー非表示、入力セッション切替: 仮表示を破棄して正規の composing text を復元 - パスワード、数値、直接入力、変換中、範囲選択中、カーソル移動中など、安全にプレビューできない状態では無効 @@ -34,9 +35,11 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま 以下を自動操作で確認し、最終差分に対する試験は成功した。 - 設定ON: TenKeyおよびSumire 5スタイルで Down直後に文字が表示される +- 設定ON: TenKeyおよびSumire 5スタイルのDownで、デフォルト背景色の `BackgroundColorSpan` が全文範囲に `SPAN_COMPOSING` として存在する - 設定ON: Up前は候補欄が空であり、変換処理が開始されない - 設定ON: Cancel後に仮表示が消え、元の composing stateへ戻る - 設定ON: TenKeyおよびSumire `default` で Moveにより文字が変化する +- 設定ON: TenKeyおよびSumire `default` のMove後も、カスタム設定した背景色Spanと下線Spanが変更後の全文範囲に存在する - 設定ON: Up後の確定結果がMove時のプレビューと一致する - 設定OFF: TenKeyおよびSumireでDown時は未反映、Up時に従来どおり入力される @@ -46,13 +49,11 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま | 条件 | 平均 | P50 | P95 | |---|---:|---:|---:| -| OFF | 127.349 ms | 111.965 ms | 168.189 ms | -| ON | 126.288 ms | 124.467 ms | 151.561 ms | -| ON − OFF | -1.061 ms (-0.83%) | +12.502 ms (+11.17%) | -16.629 ms (-9.89%) | +| OFF | 125.475 ms | 123.272 ms | 156.910 ms | +| ON | 122.038 ms | 120.908 ms | 141.366 ms | +| ON − OFF | -3.437 ms (-2.74%) | -2.363 ms (-1.92%) | -15.543 ms (-9.91%) | -平均とP95はONで短く、P50はONで長い。サンプル数15かつ端末上のスケジューリングを含むため、このばらつきから高速化を主張することはできない。一方、平均値での遅延増加はなく、Up前に候補生成が開始されないことも各試行で検証しているため、今回の実装による変換開始後の明確な性能悪化は検出されなかった。 - -同じ端末での直前の反復でも、平均はOFF 127.700 ms、ON 120.777 msだった。2回の測定範囲はOFF 127.349–127.700 ms、ON 120.777–126.288 msであり、少なくとも今回の条件では悪化傾向は再現しなかった。 +平均、P50、P95はいずれもONで短かった。サンプル数15かつ端末上のスケジューリングを含むため、この差から高速化を主張することはできない。一方、平均値での遅延増加はなく、Up前に候補生成が開始されないことも各試行で検証しているため、背景Span修正後も変換開始後の明確な性能悪化は検出されなかった。 ## プレビュー処理時間とメモリ @@ -60,13 +61,13 @@ Down→Move→Cancelを1ジェスチャとして30回ウォームアップ後、 | 条件 | 1ジェスチャ平均 | 一時割り当て/ジェスチャ | PSS開始 | PSS直後 | GC後PSS | |---|---:|---:|---:|---:|---:| -| OFF | 53.069 ms | 71,157 bytes | 235,727 KB | 268,227 KB | 248,709 KB | -| ON | 78.525 ms | 101,116 bytes | 237,317 KB | 260,177 KB | 243,041 KB | -| ON − OFF | +25.456 ms (+47.97%) | +29,959 bytes (+42.10%) | +1,590 KB | -8,050 KB | -5,668 KB | +| OFF | 50.879 ms | 71,157 bytes | 231,947 KB | 264,615 KB | 243,903 KB | +| ON | 73.977 ms | 103,082 bytes | 234,181 KB | 255,181 KB | 239,333 KB | +| ON − OFF | +23.098 ms (+45.40%) | +31,925 bytes (+44.87%) | +2,234 KB | -9,434 KB | -4,570 KB | -時間と割り当て量の増加は、ON時だけ Down、Move、Cancelで `InputConnection.setComposingText()` を実行し、入力先アプリとの同期処理および一時オブジェクト生成が追加されるためである。この53–79 msは1回のコールバックそのものではなく、UiAutomationによる3イベントの同期注入を含む試験全体の壁時計時間であり、そのままユーザーが感じる遅延とは解釈できない。 +時間と割り当て量の増加は、ON時だけ Down、Move、Cancelで装飾済みSpannableを生成して `InputConnection.setComposingText()` を実行し、入力先アプリとの同期処理および一時オブジェクト生成が追加されるためである。この51–75 msは1回のコールバックそのものではなく、UiAutomationによる3イベントの同期注入を含む試験全体の壁時計時間であり、そのままユーザーが感じる遅延とは解釈できない。 -割り当て増加は反復して観測され、直前の反復でもOFF 71,092 bytes、ON 101,378 bytesだった。一方、最終試験のGC後PSSはONの方が5,668 KB低く、直前の反復でもONの方が3,730 KB低かった。測定順序はOFF→ONで固定され、JIT、ヒープ拡張、GCタイミングの影響を受けるため、ONでメモリが減るとは判断しない。結論は「プレビュー操作ごとの一時割り当ては約30 KB増えるが、保持メモリの増加は今回の試験では検出されなかった」である。 +背景Span修正後の一時割り当て増加は1ジェスチャあたり31,925 bytesだった。一方、最終試験のGC後PSSはONの方が4,570 KB低かった。測定順序はOFF→ONで固定され、JIT、ヒープ拡張、GCタイミングの影響を受けるため、ONでメモリが減るとは判断しない。結論は「装飾を含むプレビュー操作ごとの一時割り当ては約32 KB増えるが、保持メモリの増加は今回の試験では検出されなかった」である。 ## 検証コマンド From 9c51bea64a1fa49f3015355f0e95b4237762c2b7 Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 3 Aug 2026 15:32:27 -0400 Subject: [PATCH 19/24] improve commit real time reflection --- .../FastInputMatrixInstrumentedTest.kt | 170 +++++++++++++++++- .../ime_service/IMEService.kt | 11 +- .../FlickInputPreviewCoordinator.kt | 17 +- .../FlickPreviewEligibilityPolicy.kt | 3 +- .../FlickInputPreviewCoordinatorTest.kt | 44 ++++- .../FlickPreviewEligibilityPolicyTest.kt | 8 +- docs/flick-editor-preview-design.md | 11 +- ...review-implementation-report-2026-08-02.md | 22 ++- 8 files changed, 245 insertions(+), 41 deletions(-) diff --git a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt index 5ad228299..ae984026f 100644 --- a/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt +++ b/app/src/androidTest/java/com/kazumaproject/markdownhelperkeyboard/FastInputMatrixInstrumentedTest.kt @@ -224,6 +224,130 @@ class FastInputMatrixInstrumentedTest { assertEquals(keyboard.primeText, awaitTextSettled(scenario)) } + listOf(TestKeyboard.TENKEY, TestKeyboard.SUMIRE).forEach { keyboard -> + applyCasePreferences(session.preferences, previewTestCase(keyboard)) + check( + session.preferences.edit() + .putBoolean("flick_editor_preview_preference", true) + .putBoolean("theme_custom_input_color_enable", true) + .putInt( + "theme_custom_pre_edit_bg_color", + PREVIEW_TEST_BACKGROUND_COLOR, + ) + .putString("sumire_keyboard_style_preference", "default") + .putString("sumire_input_method_preference", "switch-mode-effective") + .commit() + ) + restartInput(scenario) + SystemClock.sleep(IME_LAYOUT_SETTLE_MS) + val geometry = awaitStableGeometry(keyboard, false) + assertTrue("First tail setup tap failed for $keyboard", injectTap(geometry.prime.center)) + assertTrue( + "Second tail setup tap failed for $keyboard", + injectTap(requireNotNull(geometry.neighbor).center), + ) + assertEquals( + "Tail setup text mismatch for $keyboard", + "あな", + awaitEditorText(scenario) { it == "あな" }, + ) + assertTrue( + "Cursor-left tap failed for $keyboard", + injectTap(findCursorLeftBounds(keyboard).center), + ) + + val movePoint = PointF( + geometry.prime.center.x + geometry.prime.width * 0.70f, + geometry.prime.center.y, + ) + val cancelDownTime = SystemClock.uptimeMillis() + assertTrue( + injectSinglePointerEvent( + cancelDownTime, + MotionEvent.ACTION_DOWN, + geometry.prime.center, + ) + ) + assertEquals( + "Tail was not retained on DOWN for $keyboard", + "ああな", + awaitEditorText(scenario) { it == "ああな" }, + ) + assertEditorPreviewDecoration( + scenario = scenario, + expectedText = "ああな", + expectedBackgroundColor = PREVIEW_TEST_BACKGROUND_COLOR, + expectedBackgroundEnd = 2, + caseName = "$keyboard tail DOWN", + ) + assertTrue( + injectSinglePointerEvent( + cancelDownTime, + MotionEvent.ACTION_MOVE, + movePoint, + ) + ) + val movedWithTail = awaitEditorText(scenario) { text -> + text.length == 3 && + text.startsWith("あ") && + text.endsWith("な") && + text != "ああな" + } + assertEditorPreviewDecoration( + scenario = scenario, + expectedText = movedWithTail, + expectedBackgroundColor = PREVIEW_TEST_BACKGROUND_COLOR, + expectedBackgroundEnd = 2, + caseName = "$keyboard tail MOVE", + ) + assertTrue( + injectSinglePointerEvent( + cancelDownTime, + MotionEvent.ACTION_CANCEL, + movePoint, + ) + ) + assertEquals( + "Tail preview did not restore after CANCEL for $keyboard", + "あな", + awaitEditorText(scenario) { it == "あな" }, + ) + + val commitDownTime = SystemClock.uptimeMillis() + assertTrue( + injectSinglePointerEvent( + commitDownTime, + MotionEvent.ACTION_DOWN, + geometry.prime.center, + ) + ) + assertTrue( + injectSinglePointerEvent( + commitDownTime, + MotionEvent.ACTION_MOVE, + movePoint, + ) + ) + val commitPreview = awaitEditorText(scenario) { text -> + text.length == 3 && + text.startsWith("あ") && + text.endsWith("な") && + text != "ああな" + } + assertTrue( + injectSinglePointerEvent( + commitDownTime, + MotionEvent.ACTION_UP, + movePoint, + ) + ) + assertEquals( + "UP did not insert before stringInTail for $keyboard", + commitPreview, + awaitTextSettled(scenario), + ) + } + val performanceLines = mutableListOf() applyCasePreferences(session.preferences, previewTestCase(TestKeyboard.TENKEY)) for (enabled in listOf(false, true)) { @@ -1411,17 +1535,27 @@ class FastInputMatrixInstrumentedTest { expectedText: String, expectedBackgroundColor: Int, caseName: String, + expectedBackgroundEnd: Int = expectedText.length, ) { val deadline = SystemClock.uptimeMillis() + RESULT_TIMEOUT_MS var latest = readEditorDecoration(scenario) while (SystemClock.uptimeMillis() < deadline) { latest = readEditorDecoration(scenario) - if (latest.matches(expectedText, expectedBackgroundColor)) return + if (latest.matches( + expectedText, + expectedBackgroundColor, + expectedBackgroundEnd, + ) + ) return SystemClock.sleep(PREVIEW_TEXT_POLL_MS) } assertTrue( "$caseName did not retain the pre-edit background/underline spans: $latest", - latest.matches(expectedText, expectedBackgroundColor), + latest.matches( + expectedText, + expectedBackgroundColor, + expectedBackgroundEnd, + ), ) } @@ -1591,6 +1725,26 @@ class FastInputMatrixInstrumentedTest { } ?: throw SetupException("Key ${locator.render()} is not visible") } + private fun findCursorLeftBounds(keyboard: TestKeyboard): ScreenRect { + return when (keyboard) { + TestKeyboard.TENKEY -> awaitVisibleNodeBounds("key_soft_left") + TestKeyboard.SUMIRE -> { + val root = findVisibleNodeById(keyboard.rootViewId) + ?: throw SetupException("${keyboard.rootViewId} is not visible") + val labels = setOf("CursorMoveLeft", "Move Cursor Left", "カーソル左") + val node = findDescendant(root) { candidate -> + candidate.text?.toString() in labels || + candidate.contentDescription?.toString() in labels + } ?: throw SetupException("Sumire cursor-left key is not visible") + node.screenRect() + } + + TestKeyboard.QWERTY -> throw SetupException( + "Tail preview test does not target QWERTY" + ) + } + } + private fun findCandidateState(): CandidateState { val recycler = findVisibleNodeById("suggestion_recycler_view") ?: return CandidateState(bounds = null, texts = emptyList()) @@ -2539,17 +2693,21 @@ class FastInputMatrixInstrumentedTest { val backgrounds: List, val underlines: List, ) { - fun matches(expectedText: String, expectedBackgroundColor: Int): Boolean { - val expectedEnd = expectedText.length + fun matches( + expectedText: String, + expectedBackgroundColor: Int, + expectedBackgroundEnd: Int, + ): Boolean { + val expectedUnderlineEnd = expectedText.length val hasBackground = backgrounds.any { span -> span.color == expectedBackgroundColor && span.start == 0 && - span.end == expectedEnd && + span.end == expectedBackgroundEnd && span.flags and Spanned.SPAN_COMPOSING != 0 } val hasUnderline = underlines.any { span -> span.start == 0 && - span.end == expectedEnd && + span.end == expectedUnderlineEnd && span.flags and Spanned.SPAN_COMPOSING != 0 } return text == expectedText && hasBackground && hasUnderline diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt index 75cb18c3c..cb98a608e 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/IMEService.kt @@ -21480,11 +21480,14 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, } /** Down/Moveプレビューにも通常入力と同じPreEdit装飾を適用する。 */ - private fun createFlickPreviewComposingText(text: String): CharSequence { + private fun createFlickPreviewComposingText( + text: String, + composingTail: String, + ): CharSequence { return applyPreEditComposingSpans( - spannableString = SpannableString(text), + spannableString = SpannableString(text + composingTail), inputLength = text.length, - underlineEnd = text.length, + underlineEnd = text.length + composingTail.length, backgroundColor = if (customComposingTextPreference == true) { inputCompositionBackgroundColor ?: getColor(com.kazumaproject.core.R.color.char_in_edit_color) @@ -24189,7 +24192,7 @@ class IMEService : InputMethodService(), LifecycleOwner, InputConnection, isHenkan = isHenkan.get(), selectMode = selectMode.value, cursorMoveMode = cursorMoveMode.value, - hasComposingTail = stringInTail.get().isNotEmpty(), + composingTail = stringInTail.get(), hasInputConnection = currentInputConnection != null, baseInput = inputString.value, isFlickOnlyMode = isFlickOnlyMode == true, diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt index 37deb625a..287bd8ce7 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinator.kt @@ -5,7 +5,8 @@ import com.kazumaproject.core.domain.flick.FlickTextSelection internal class FlickInputPreviewCoordinator( private val composingTextArbiter: ComposingTextArbiter, - private val createPreviewText: (String) -> CharSequence = { it }, + private val createPreviewText: (input: String, tail: String) -> CharSequence = + { input, _ -> input }, private val mutationResolver: ( FlickMutationSnapshot, FlickTextSelection, @@ -16,6 +17,7 @@ internal class FlickInputPreviewCoordinator( val editorSessionId: Long, val source: FlickPreviewSource, val snapshot: FlickMutationSnapshot, + val composingTail: String, var lastSelection: FlickTextSelection, var lastMutation: FlickTextMutation, var pendingCommitConsumed: Boolean = false, @@ -82,6 +84,7 @@ internal class FlickInputPreviewCoordinator( editorSessionId = context.editorSessionId, source = context.source, snapshot = snapshot, + composingTail = context.composingTail, lastSelection = event.selection, lastMutation = mutation, ) @@ -116,7 +119,7 @@ internal class FlickInputPreviewCoordinator( (previousMutation as? FlickTextMutation.ReplaceComposingInput)?.resultInput val needsEditorUpdate = !composingTextArbiter.isPreviewVisible() || previousResult != mutation.resultInput - if (needsEditorUpdate && !showPreview(mutation)) { + if (needsEditorUpdate && !showPreview(mutation, current.composingTail)) { active = null return } @@ -165,7 +168,8 @@ internal class FlickInputPreviewCoordinator( private fun renderMutation(mutation: FlickTextMutation) { when (mutation) { is FlickTextMutation.ReplaceComposingInput -> { - if (!showPreview(mutation)) { + val current = active ?: return + if (!showPreview(mutation, current.composingTail)) { active = null } } @@ -174,9 +178,12 @@ internal class FlickInputPreviewCoordinator( } } - private fun showPreview(mutation: FlickTextMutation.ReplaceComposingInput): Boolean { + private fun showPreview( + mutation: FlickTextMutation.ReplaceComposingInput, + composingTail: String, + ): Boolean { return composingTextArbiter.showPreview( - createPreviewText(mutation.resultInput), + createPreviewText(mutation.resultInput, composingTail), 1, ) } diff --git a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt index 0d26b6226..576b83a0f 100644 --- a/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt +++ b/app/src/main/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicy.kt @@ -15,7 +15,7 @@ internal data class FlickPreviewContext( val isHenkan: Boolean, val selectMode: Boolean, val cursorMoveMode: Boolean, - val hasComposingTail: Boolean, + val composingTail: String, val hasInputConnection: Boolean, val baseInput: String, val isFlickOnlyMode: Boolean, @@ -32,7 +32,6 @@ internal object FlickPreviewEligibilityPolicy { !context.isHenkan && !context.selectMode && !context.cursorMoveMode && - !context.hasComposingTail && context.hasInputConnection } } diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt index e6bccd528..7070cf1ed 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickInputPreviewCoordinatorTest.kt @@ -62,19 +62,42 @@ class FlickInputPreviewCoordinatorTest { @Test fun downAndMoveUsePreviewTextFactory() { - val fixture = Fixture(createPreviewText = { text -> "decorated[$text]" }) + val fixture = Fixture( + createPreviewText = { text, tail -> "decorated[$text|$tail]" } + ) fixture.coordinator.onEvent(started("あ"), fixture.context()) fixture.coordinator.onEvent(changed("う"), fixture.context()) assertEquals( - listOf("text:decorated[あ]:1", "text:decorated[う]:1"), + listOf("text:decorated[あ|]:1", "text:decorated[う|]:1"), fixture.writes, ) } + @Test + fun tailIsRenderedOnDownAndMoveButExcludedFromCommittedInputMutation() { + val fixture = Fixture( + createPreviewText = { text, tail -> "$text$tail" } + ) + val context = fixture.context(baseInput = "か", composingTail = "な") + fixture.arbiter.setCanonical("かな", 1) + + fixture.coordinator.onEvent(started("あ"), context) + fixture.coordinator.onEvent(changed("う"), context) + fixture.coordinator.onEvent(commit("う", isFlick = true), context) + val mutation = fixture.coordinator.consumePendingCommit("う", isFlick = true) + fixture.coordinator.onEvent(finished(), context) + + assertEquals( + listOf("text:かな:1", "text:かあな:1", "text:かうな:1"), + fixture.writes, + ) + assertEquals("かう", mutation?.resultInput) + } + private class Fixture( - createPreviewText: (String) -> CharSequence = { it }, + createPreviewText: (String, String) -> CharSequence = { text, _ -> text }, ) { val writes = mutableListOf() val arbiter = ComposingTextArbiter( @@ -92,7 +115,11 @@ class FlickInputPreviewCoordinatorTest { createPreviewText = createPreviewText, ) - fun context(baseInput: String = "", sessionId: Long = 1L) = FlickPreviewContext( + fun context( + baseInput: String = "", + sessionId: Long = 1L, + composingTail: String = "", + ) = FlickPreviewContext( source = FlickPreviewSource.TENKEY, editorSessionId = sessionId, settingEnabled = true, @@ -102,7 +129,7 @@ class FlickInputPreviewCoordinatorTest { isHenkan = false, selectMode = false, cursorMoveMode = false, - hasComposingTail = false, + composingTail = composingTail, hasInputConnection = true, baseInput = baseInput, isFlickOnlyMode = false, @@ -121,9 +148,12 @@ class FlickInputPreviewCoordinatorTest { selection = FlickTextSelection(text, true), ) - private fun commit(text: String) = FlickTextPreviewEvent.CommitPending( + private fun commit( + text: String, + isFlick: Boolean = false, + ) = FlickTextPreviewEvent.CommitPending( gestureId = 1L, - selection = FlickTextSelection(text, false), + selection = FlickTextSelection(text, isFlick), ) private fun finished() = FlickTextPreviewEvent.Finished(gestureId = 1L) diff --git a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt index f4a5665f5..7d01557d9 100644 --- a/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt +++ b/app/src/test/java/com/kazumaproject/markdownhelperkeyboard/ime_service/flick_preview/FlickPreviewEligibilityPolicyTest.kt @@ -23,11 +23,11 @@ class FlickPreviewEligibilityPolicyTest { } @Test - fun conversionSelectionCursorAndTailStatesAreRejected() { + fun conversionSelectionAndCursorStatesAreRejectedButTailIsAccepted() { assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(isHenkan = true))) assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(selectMode = true))) assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(cursorMoveMode = true))) - assertFalse(FlickPreviewEligibilityPolicy.isEligible(context(hasComposingTail = true))) + assertTrue(FlickPreviewEligibilityPolicy.isEligible(context(composingTail = "な"))) } private fun context( @@ -38,7 +38,7 @@ class FlickPreviewEligibilityPolicyTest { isHenkan: Boolean = false, selectMode: Boolean = false, cursorMoveMode: Boolean = false, - hasComposingTail: Boolean = false, + composingTail: String = "", ) = FlickPreviewContext( source = FlickPreviewSource.TENKEY, editorSessionId = 1L, @@ -49,7 +49,7 @@ class FlickPreviewEligibilityPolicyTest { isHenkan = isHenkan, selectMode = selectMode, cursorMoveMode = cursorMoveMode, - hasComposingTail = hasComposingTail, + composingTail = composingTail, hasInputConnection = true, baseInput = "", isFlickOnlyMode = false, diff --git a/docs/flick-editor-preview-design.md b/docs/flick-editor-preview-design.md index c9c7bac59..919e0efef 100644 --- a/docs/flick-editor-preview-design.md +++ b/docs/flick-editor-preview-design.md @@ -50,8 +50,8 @@ TenKey と Sumire の文字フリックに、指を離す前から選択中の - Sumire の特殊キー - 削除、空白、変換、Enter、カーソル、濁点切替など - 特殊キーの方向に文字列オーバーライドが設定されていても初回実装では対象外とする。 -- 変換中、文節選択中、選択モード、カーソル移動モード -- composing 内のカーソル編集で `stringInTail` が空でない状態 +- 変換中、文節選択中、選択モード、操作中のカーソル移動モード +- composing 内のカーソル編集で `stringInTail` が空でない場合も対象とする。DOWN 時点の tail を固定し、プレビュー表示へ連結する一方、入力 mutation からは除外する。 - パスワード、電話番号、日時など、composing 表示を安全に保証できない入力欄 - Direct Commit が選択されている入力動作 - ダブルタップバインディングがあるキー @@ -538,11 +538,13 @@ AND not password/numeric/phone/date/time direct field AND !isHenkan AND !selectMode AND !cursorMoveMode -AND stringInTail is empty +AND stringInTail is captured as an immutable preview tail AND currentInputConnection exists AND editor session matches ``` +`stringInTail` がある場合、背景 Span はカーソル前の入力プレビューまで、下線 Span は tail を含む composing 全体まで適用する。CANCEL では元の composing 全体を復元し、UP の mutation は tail を含めず、選択文字だけをカーソル前へ確定する。 + Sumire については `TenKeyQWERTYMode.Sumire` と、Sumire の数字レイアウトとして表示している `TenKeyQWERTYMode.Number` の composing 文字キーを許可する。`TenKeyQWERTYMode.Custom` は初回実装では拒否する。 ## 11. 性能要件 @@ -623,7 +625,8 @@ Sumire については `TenKeyQWERTYMode.Sumire` と、Sumire の数字レイア - フリックのみ設定 ON の TAP は末尾追加 - Sumire 複数文字出力 - unsupported InputType -- henkan/select/cursor/tail 状態 +- henkan/select/操作中の cursor 状態を拒否し、安定した tail 状態を許可 +- tail 付き DOWN/MOVE/CANCEL/UP の表示、Span 範囲、mutation 分離 - resolver 結果と既存確定結果の一致 #### Arbiter diff --git a/docs/flick-editor-preview-implementation-report-2026-08-02.md b/docs/flick-editor-preview-implementation-report-2026-08-02.md index c283a8e9e..1ad647766 100644 --- a/docs/flick-editor-preview-implementation-report-2026-08-02.md +++ b/docs/flick-editor-preview-implementation-report-2026-08-02.md @@ -1,6 +1,6 @@ # フリック文字プレビュー 実装・実機試験報告 -試験日: 2026-08-02（背景Span修正の追試: 2026-08-03） +試験日: 2026-08-02（背景Span・stringInTail対応の追試: 2026-08-03） ## 結論 @@ -19,6 +19,7 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま - `onDown`: タップ位置の文字を仮表示 - `onMove`: 現在選択中の文字で仮表示を置換 - Down／Moveとも通常入力のPreEditと同じ `BackgroundColorSpan`、任意の `ForegroundColorSpan`、`UnderlineSpan` を適用し、カスタム入力色設定にも追従 +- カーソル移動後に `stringInTail` がある場合は、カーソル前のプレビュー結果へtailを連結して表示する。背景Spanはカーソル前まで、下線Spanはtailを含む全文まで適用し、確定mutationにはtailを含めない - `onUp`: プレビューと同一の入力変換を一度だけ確定し、その後に従来どおり候補生成 - `ACTION_CANCEL`、ビュー非表示、入力セッション切替: 仮表示を破棄して正規の composing text を復元 - パスワード、数値、直接入力、変換中、範囲選択中、カーソル移動中など、安全にプレビューできない状態では無効 @@ -41,6 +42,9 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま - 設定ON: TenKeyおよびSumire `default` で Moveにより文字が変化する - 設定ON: TenKeyおよびSumire `default` のMove後も、カスタム設定した背景色Spanと下線Spanが変更後の全文範囲に存在する - 設定ON: Up後の確定結果がMove時のプレビューと一致する +- TenKeyおよびSumireで「あな」入力後に左カーソル移動し、Downで「ああな」、Moveで「カーソル前の変更文字＋な」が表示される +- 上記tail状態でCancelすると「あな」へ復元され、Upすると選択文字が「な」の直前へ一度だけ挿入される +- tailを伴うDown／Moveでは、背景Spanがカーソル前まで、下線Spanがtailを含む全文まで設定される - 設定OFF: TenKeyおよびSumireでDown時は未反映、Up時に従来どおり入力される ## 変換時間 @@ -49,11 +53,11 @@ Pixel 6 実機では、候補変換の開始を `onUp` まで遅延したまま | 条件 | 平均 | P50 | P95 | |---|---:|---:|---:| -| OFF | 125.475 ms | 123.272 ms | 156.910 ms | -| ON | 122.038 ms | 120.908 ms | 141.366 ms | -| ON − OFF | -3.437 ms (-2.74%) | -2.363 ms (-1.92%) | -15.543 ms (-9.91%) | +| OFF | 126.130 ms | 102.658 ms | 162.988 ms | +| ON | 127.674 ms | 128.309 ms | 148.719 ms | +| ON − OFF | +1.545 ms (+1.22%) | +25.651 ms (+24.99%) | -14.269 ms (-8.75%) | -平均、P50、P95はいずれもONで短かった。サンプル数15かつ端末上のスケジューリングを含むため、この差から高速化を主張することはできない。一方、平均値での遅延増加はなく、Up前に候補生成が開始されないことも各試行で検証しているため、背景Span修正後も変換開始後の明確な性能悪化は検出されなかった。 +平均はONで1.545 ms長く、P50は長い一方でP95は短かった。サンプル数15かつ端末上のスケジューリングを含み、分位点の方向も一致しないため、明確な悪化とは判定しない。Up前に候補生成が開始されないことは各試行で継続して検証している。 ## プレビュー処理時間とメモリ @@ -61,13 +65,13 @@ Down→Move→Cancelを1ジェスチャとして30回ウォームアップ後、 | 条件 | 1ジェスチャ平均 | 一時割り当て/ジェスチャ | PSS開始 | PSS直後 | GC後PSS | |---|---:|---:|---:|---:|---:| -| OFF | 50.879 ms | 71,157 bytes | 231,947 KB | 264,615 KB | 243,903 KB | -| ON | 73.977 ms | 103,082 bytes | 234,181 KB | 255,181 KB | 239,333 KB | -| ON − OFF | +23.098 ms (+45.40%) | +31,925 bytes (+44.87%) | +2,234 KB | -9,434 KB | -4,570 KB | +| OFF | 54.350 ms | 71,223 bytes | 239,456 KB | 274,512 KB | 252,187 KB | +| ON | 79.657 ms | 103,803 bytes | 239,436 KB | 234,479 KB | 242,947 KB | +| ON − OFF | +25.306 ms (+46.56%) | +32,580 bytes (+45.74%) | -20 KB | -40,033 KB | -9,240 KB | 時間と割り当て量の増加は、ON時だけ Down、Move、Cancelで装飾済みSpannableを生成して `InputConnection.setComposingText()` を実行し、入力先アプリとの同期処理および一時オブジェクト生成が追加されるためである。この51–75 msは1回のコールバックそのものではなく、UiAutomationによる3イベントの同期注入を含む試験全体の壁時計時間であり、そのままユーザーが感じる遅延とは解釈できない。 -背景Span修正後の一時割り当て増加は1ジェスチャあたり31,925 bytesだった。一方、最終試験のGC後PSSはONの方が4,570 KB低かった。測定順序はOFF→ONで固定され、JIT、ヒープ拡張、GCタイミングの影響を受けるため、ONでメモリが減るとは判断しない。結論は「装飾を含むプレビュー操作ごとの一時割り当ては約32 KB増えるが、保持メモリの増加は今回の試験では検出されなかった」である。 +stringInTail対応後の一時割り当て増加は1ジェスチャあたり32,580 bytesだった。一方、最終試験のGC後PSSはONの方が9,240 KB低かった。測定順序はOFF→ONで固定され、JIT、ヒープ拡張、GCタイミングの影響を受けるため、ONでメモリが減るとは判断しない。結論は「装飾を含むプレビュー操作ごとの一時割り当ては約33 KB増えるが、保持メモリの増加は今回の試験では検出されなかった」である。 ## 検証コマンド From edb8510847ad0d2c0d1b03d86d073ab9f7c784dd Mon Sep 17 00:00:00 2001 From: Codex Mozc Autonomy Date: Mon, 3 Aug 2026 16:27:01 -0400 Subject: [PATCH 20/24] update dictionary --- app/src/main/assets/ngram/system_ngram.dat | Bin 55752 -> 55955 bytes app/src/main/assets/system/tango.dat.zip | Bin 2152926 -> 2152932 bytes app/src/main/assets/system/token.dat.zip | Bin 5444799 -> 5444832 bytes 3 files changed, 0 insertions(+), 0 deletions(-) diff --git a/app/src/main/assets/ngram/system_ngram.dat b/app/src/main/assets/ngram/system_ngram.dat index 37f22ba9785860c9c160395ed5d4c9b0c27c4025..a145dc2b357a79abe08a9069d520bfdfca4657a3 100644 GIT binary patch delta 26895 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

UH;9g-+~s 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%0A^Dy4YOpY)aB_*y)u18Om{In z7e{eG`Qsty9TQIIsqI0PI(AJdK9=ElJL;kp@pVdraJY8EX&ZVuMnw}qc0sEPe=~Mb ziM427F8iWt_(#hSnbV0zHjNG$mh7;ObZ@=uXrhDe#|EGIbLq|+P!g=(Eg?Wtfu}pU z3tWdo?Fo71`0oGuofsKhF=4CAV1M+vfn|1|y7dwR-ZRtHv}F`fJrH6pt>S-OhtKPV zL8HHzB5~8%b_JzTF4vUP7tq_ce~1@8S6~hbe}(<*Zl&XFmHkq(icG|k___VmZ2t84FuE|~`1PztiSzmz2x%xpfY z%ngr)F?rmZI%H@njTO3<&rewY^?_9vg@ww7{+DN#kN@8Ktm9GK5x#7?ML<%M+ZJAKv+W|pVp z0>81Xt$}D(qe~z;d%SfmU5ebexNgs3tPw-1w10Rcx3ff9jo%ohX|qkcfS7x%~XcvnN@Fy#*0R$s)}D2Z_s{Eo|^)Y)la zV07$-j%z}CZcqXsVW3Q#5(%Vc9`sndqLHYu5b{|fx3l6^$NqHce@qHmNKt^8gte=j zQ!`H`_S*dID5Id5HL+-5uvpE%eWXMTZiKkDL0YXY1!A&fvpOVD>lWhO^m?!wDv6kH z--kt6Uyy1I-YcbH{$sF26(FCaPaI^j=|vr z&bCop+GOLXPKbT%GKUGz*LasOfO&?@VLH-h$yf|(x(8j+fA}^1=)R+83r_@nw_aPJ zxq|-kOZmKl`nkvD4HKAJX}|;xgDm60iYbE~gWwhAeypjXM`ro4k#H=qY>r}#K)C&O zW|;wW@$|+W7CcW329>dx1m0lo6BF3KcCkQUf!d}|3YNGVdk}+%VIG76#|rTvxP2=l z-3>jGc<$AYf6@RHn~P28#?2*%s{|yUXWEXi!8a$|#il&`>9r8S_9rogI75

ebYq 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ⅈ8_j*VV^r0Hn?=vY% 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∾lVt`gYhVd8S*^-pC&YQ%VxlT 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 &CW`822e`4%oBg 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

_kwBS2|8b=xDF`Y!V-#VgEBK6~X! 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

{Sb=?q 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

ZSlv$C>12=L zXRr!dLtk^pLhKShH2`C7p_&m<=}9M(4jC9^nJOD7ABHS*_3t-~i&cb7ibn0z^%Km) zL$4TkZdLewr6G@U36?>gozghbpSMf*LjHiNfiBTsOEqdb(Ppx@BR;eO`Z@ZdEVi-; z;+uJ58^6I$vRItMFn@#J*7PF37Wm@_LYIYCOs92?#G?5pF=U@do<3@{*oNG7Oby0~ zSeF6wd@c5V$2+4di?DtL?m1aSYMO8csybk0FD=r>^+4G%{09Cddu;xgwA64)7Vkh+ z42dhUfGwEd_x?Y=z6HFgDr>u-TnYl}C}16}j3085j!TA71b+wRA_In=qKY7@02(rtX?B zD`FATpQ~!u1b>%aGt}j8ue?G^Tft|uAEm66qCxJ;R9a=VnFYBbA488b zI;vf9pgr)7#8%k#V@;`G3xBZYhqZV=rja-aYkM3}H&p8r7h&YzzAE7P66YBY0qc0n zc`e!jss#6I9YBnJwx@Ipj7lgZt{4*=UJAi7uQV6tn13@&%KZHLdWbh#f@e}0ZF_hH zv3fBFSxaDpW(2J8pA4Kpi#Ji+V;kiBo?EQ`$d_eoGN)Ck4fkdt9#M}s#i|E8pkfF0 zF-GG@v=VcJG&@aG;7v|ToXRvCiRm3@pn@&MdHafG6U9QB=V+%$UXkk&6cOJiY=n3% zm?o;CxqtP5*tcf2W`wL*^bqxQaHDP#tL0E;(0?qGXsu6fNG{3GXi5Nl94SedNj*) z(-h)J(@nNC7bOy+5B*qmgd#;8G4_bMhGT|p9Dic}kEkC^G@90%3h{{!7!($Li~7~lO!`f#Jk!LQ)i^)!UFg3cHYh@fwk*v-V%L%t<9C5v^ZcJt z;V*MjWv^pbkB4^Xqg;pZjr6-iKhl^cyH`^r-IG1VG!!lT@TzuOky|WYs6LN<`l{Zb ziY{KLRB_jnrZGc&S>X?5m0VUmxT0S@n15Z!DAa>}ImT{iH?HJ&GBt#614k{N;GBFj z)E~O22~tf*@eXFVt6PiFOVNP9x`;+EG_L#~ss&^AmU)f!@J5cC(^ed28uJFT_Ta|6 zrmA*~HFsO^t<rD9up8>=H}!_9c3n(}HMVfGjoqX{Zb}vNYGf@J?qeEjfyp(i^(|z9X`Xt% zly~{;nxJ4`)lB2N>;xh_J6R+F^7B2l%oGkLAZFEv~y}(K~c? zLz$N>`UqO0mEEd#^~>bRiG|2IUK35(ELDe1L#c8Zz1Rn&n8}UK)Vp3JCV!K99I>8x zRI8rYUo|ZIk?3IE}c~3Af?4_$a@S1apxzISN!Axhpz>n4_cuow1Q z^hy=6U{HjRpC`;h4Cdf>6V^?f^s7uX`Cj!<>v){q(`#0TF2b91J;AQM-(7Ig1NDeW>l?|cmHerAq4R=fjt1kd zWx2K@2PmJXxh5_$72IHciVJ8KTBgZy zjGoq{ESp^2p%`tubv(aW6AV*z$%AMw2Vo=wwnBb4Q-{Zp^~Dk6`4SXM8gvsHP8pk+ zXtuOGJF-dl1_7rED+Ti`f1|{&pB-dyp+9)o@o2)oX_yPn(6KVxm|qYuDW*?RoWh zy07@Y)8l~RH~F0u6)Zl?&7`XGiZ(~A=VFmdH-7=nW6$>c7YT|LjIoJ7?5@noV4|42 zgjtbHaq%TmU?R2}s_Y?dD9aetUsFfHnb1XEmC%&7Cb@%VD_g2J&>Z%cn+oAQQ;%sP zDTz~S&|{9bnV2}sNwi?2Obe41Lsy;1S{a-jj@bG}^?2G%W|x*V2piLEb#dms?g1vF za(|Tc57=YUuet``Vtb-=lZ|WZ2Dzu z!n(cnr1lhGhFMzF8>BhG`FJO${w`@eq<@f3F|!u5E1ed7WY-5{ppL4eKFRlI&n|Hw z91I`O-d~*L|5e>55NldHu^72$h1#>W+X|Ea?wFxu!OH|4Gpf|C*ziTl#HM{)OMUQ6 zs9oNbyGi?lu!!;)DNiW)Y))gO2Ay(+lDnz?Xvq=X1R;U;SxPVI2cT_I1h?7-L4Uk3 zim-R>RQS+aA?8Z=@L$s!{fangB-wh(CZY=Uz){z?m5;#3$~HdPILrRLyTT#Yeb*mj zOP60(Dmkr7f~{89n%PX8vD>pqH=1i;RjdWdN%@rO!y{bx?84$`7=(y1NB4WyqMJ-w zCGJ@`_YZLES6$<-R~?3V!Sj^aW`CWnM%>`nvX;zAZc%?uc-rtHep~HXlzuL`L&^_( zvIgW&4L!bQF)T2>;y!@ydl919H_*%9^lNiW;a2`MwpIcLR%wFjcxw;DQ$0K1>#Zn6E_aU6^kMgR9Q)OPbtec>`FRX&i&@9{(w}jfI z@oXbx@;f126GW>RfZJ>%Gq>OgusL+%+c>^;(h!-K-X`31i=p;Rg?}lQn_)}jZcz2U z_I^f3DwK5^b}l!@F%{l2Hevj}mpFu(*PSIv1JP3K6Z0|^IScBxQuYh^U3g>pw~1Z& zZVzIlTh3|WJY42x+9uWZSY2YT;fd_m;lt{Ax=Gq zI$EWXvbM+`e?Ov@?SIM`CfZ!C>`ZB;9Xw*#<2Re^b*HP2D~A#D3}q9B+MO%83+`F< z6GJidnd5O{_KJM#8<|^PQ=ULM&ELS4oIl-B6-Ny6cm5to><=4K9J*piKzrDgm@Xvz ztoIdahp#c>Zbyq!0*X|pck`W0hj;wH*c6)@3$~(8X1Y;l9e>VDPl~d-Nb`@BjY91| z|8XDZZv3RkvxEN!*sLxoHdB$ik~01oMbsB%D~XTJ<8aJW{a5Is$?HE#Ho~NG^)#Gf zOB2V`8fYgv=WoQQsT>7wr0Z#wQTERBytj2qcn8PaAR)%s?L-@&qZ7_~KeJ2=KASxS zEqpW1hK<5?;eQ-=T@{@?5xel+HIH@RCB7E7F#f?F~w*%VXD9qEALxHjbJ!%)b zuqe^kgqR=^M^P%ZVaXh3FScU3{tM4h`?$)_pfT^R+!D8_cGQ$t9XF?ie`JOc+kD+t zw`hCH#CkK0N(oVnIFQlRUE^*EqrC4q9<(!BDDz4gR)4{>NY>QM!Vxqt)G6F#OEVR4 z!r8`7R<S<=Xp_eKPjZXZ zI8PacZGTYkyfs7FS$B`WKfEG)FKZU}gfHuVV;%0@#;>oQmUsq{VKd)rol2`oQmi_j z=1+t_93%db5$+z0)4a5MM(Y@)R~M;lU3D$_493mznqB%MzDL348(Tk7iuL!KYRg@2 z6}I{V(knIGN5@jO2KBXV5~5N&6IJ|-aE`A{ntw*0(>fI472)Qc{s}$uUg8fB?_&O< z-)JAF9t_pR&v@)f1HqPl73cC~;bvk##Tndsif5MHqLzEUq*0K5w_s1~7jtcsu&0SL zVNCYx#2#oLC&ecAgfBWy6LUf3WSp-`(xrlu6pVo^DTJ9Fi|E-2XQ+;XUT6++Ndt+w z$ba`JGriW3e%1bb=yBCEa;}&;@%^fHzE>69a4NYg{Yz}erQow=C-~lFWkrLOGnlLS z`P^tIb1bT#Xgn%25iJ2*jmvvGe>tQ(T6MW-i6>ERJ6uW15Oc~Ol9h{Xf;|bUU#Hp! z;#4IcOZom7+wLR zvTlM=C(VhPXPUzOH`-ah_@vP3yahq$)o?&&G@`5$1+59uDsy6g&8x!o{Cxa<5#fHz zCd8<=438=rZOn#W*bDiMakGIHnuQo8DT6$YSHl>ButCy5)=0V3!bW8bjj2e^y?=Wa zc@*p?uVo*tDE-U{C0r*~81i$lRc=kEFp9<+?eGxWK78u7qVMm~O(=TM_Z<^g-^k6N zdK}WO$e!{mo6rGG>3ZD+abR^(s1x=GH?xzNpkK@UC2$L|<8gRB5k~-8c+&7Rb94D# zZU*Jvu@=V+Ab!9L|Ce8Ni&8A@2!B@JruRgvNMVB%%l8&vGw-c9fp2Y~QRnJ5HYwX^ zU4Zt9bIXbSDe1a;Th24Z*Fv1IEwtSgt6oFdkot|@_c9eJ8LO7?s{BLR`|&>UI4gR8 zU1^T*a3Wf_n-n9jFc%MmIiTJWDHdbPwtuA0NgC+6 zNIhBNSpQf~sx_1O3+37os{nc~9oYCKk@kmTR(Fbz)VCHaG>_9oGb7-0+EK14$2aF< zUh*7eRcJYNDHA~NEGY_tQ#YDd1yq)I;i&t#a3A8_&)|!kjDm$)fUKO1npe5&R6m0= zkJu37iD$;T%QxA0G#pRbXMbhQY`y7W>b3e-@wLd9<7=_U<6#9pu>z8`Kv_Lh{fVP` zy0)Fux=T$HLq9Z}!m);U9}>)2d~Z?)G_F~^tPkGuy+YZ0Os?Y;*bpB(O|`HcUaxWl zKl0@eLo6IX>wnz26TWafP5PQ}7JPxR_4TGt9b>a!S9atLhD#YE_XuB0_o4;R!#DDEA z{pw9`sT9jy*Fyb7!Je>I&afv$u7m0n10wk8p^NnsY353E;AHMU4EJ)2(I#~fTO}cz zfaJX8t$;>Py0DQMUVk@~;uk2RwT-aBxe`75aEiF7wNk7UyQ~cRJ1ViK=GFBx8Cjv1 zJ~hQs&nt%|eG^I}dxCN6Jn@nBGd=U@d-{%>LEMAx<%;obr&4KQFhWg zbNwpV2qs3sF0}n7u^&D65bJF0of}fDu{+#{*Z7O!3H+C;%auQ?qW&+nU3yz3Y(2Cf zCL(r>Vzw7QEq}qe_iK*k)j!qPbCvrbnHl|4l=llB4sJAe14o3nth}r_^*mowLBiIwr#Q;2C1ur!@xRw+vfw77GOdNcI*gLlP8Z(_4t$tQ}zqTDw ztK>dF>kWmol~oW#OjSr;g}YvVZ0Q4rB1oc@Z?yJy%1@1~sQa}bYq>!JWfzl@g8Bk_ z%a2Wu=zkt`%rG`-U#6^6W~lfYW&E(cx&@q8b06(n@VoEG+x&@%%h)9K6LuGxlLlJ$ znX)n!4z|8gcf~YiS+4KV9Fy!luF;+kd1uOcM6bI@_93HiK7UAFL>gjT$@khORU8p} ztJFBB-ZRcp$8#Sew%)2TCU*zlFuuTLi^Xur*njHm!hXS6L@8iQ*OqODck5egieQP` zimjebS#Ur3%X2s~Q_=6Z4b`jhfGtv6`6!f=D~uB!wH-=PGwZ0C1j%HRnaWJw)UUF zb$`+=v=_B}GI!mm^F(QU6J>xp3w-oT_S9wxLJNs=Jn{2q|=vvB&M=Jq3|!4iHWf*J)IF6-So!CHCt_F?*NA8;@#6c%uF?mVcP+ zi4QA;@dX@W&D_hzm6rRgF7Gzo1od02-D4-V3gaw_`{)X6Y1p9O$V)QA`E|4!WpFus z0C7Ez0^g(j&VmD}PMHtg4Re$+>gjc7nNyH%A7@zWxrpdyBGU!$!hU(q6Pv~t(23FO zr}Q*v&3dGrZgKr8-fZ5FQ9o75$bZpRNHd}25&eMNq-d?&q^2b zn7x$wru&_;JaLZWSzT_1wW7_V3PkDt>FTCDx6s8k8eJZ2_Ae^Bi|gXn2NFoVH)pq8 zf$NfMd2Jv+lV8A*Gc&d`IQ) z|A7Qk9Qe(ASPqvLkCo>_@YlP9spNS#qcxqQdI&O=8yimLmUE*Mnm~^zVo}<=OCEq+ z(Ef*7M5g3Vh~X21mxY_kM~saIj;{-RUNk6}TKi99eO?oDGw-f~g?~xKhPBo)vbwNY zbD*>lf~9?Oo*qlHAMNft%8ue|#wIZr0@X!=Le~A$W_S>(U#GvMXAr#X%W?HUi+TvW zjz9OidVD$D$ChbuIrMnLDHHyIZ;5k@Tb$U>F5q4kmnL_kJ^WQ|G~W9^ttR~I|C*t+ zw(u|R*?(1o6J{aCVSn1EkVpE8U-8_g${L6P(hTVt@FC@hRfP*5TZDJe%?ek0Ty2#3wZ7^j|4Eldk7A zeij!)a^Pa#g3@_$?D>>re?)E$f&; zOnu5u%8^1pqW)K}7G_WJe-*K^njq;*!{_o50VWRTdAxmGxDSs#CfJv~CN#PRFhK{r zGLiOfjZLaNVSfoCmA$UV;45P1pz4Q;Bbr@oscEu_g-h0ZLY3i z<(R=&(&{YpQo|{?$n2Ej9IYXR|7h|^@^zt@ssUPcB;mAv+8h?t=R7mzbpzQQ+3oT2Tz|>GC z4dv`pP7!6~dgf8hi#&(smG1C0yTt^~Z4_eoWW%SL8^vGwPu6Yaw5$bMD37nk6>hCf z6qjnE9gkNXVG-{*W|*_8+8s|bQN^2Z6wSMHPEi!=p5^M1E1SxSg8KS~t#xrYs)}(=n_+$^CWWe)%0Q1kcsbY_ zPUU2nHdGxoX0xR=E@Jw#oa8>|G#JBluAga@D9?{u&-eP?fdv2jh!!lIVTKWVX_=Sb zX@4qoi`-mwhi4u}9xCWVziC2WeHhWr4z#x)!YAkn&%tGAW*13JWA4|Gq;tvCidp&8Hk2Cv)>-FTg&_<#8cxQN#}iT3k6`hjEcYgUU*RbA#hyw+!k zKkodd2M%HjH<5N0w(xz;2zVc#>I%NA*Z%#!h-Vwm+bq8^9UlElE7^um*#jq&ra@o$ z^3&Jx2}xsUH@5L_a;4;LS$FCa?1RmuTJ8iaC;5J&<7Ci0%KHpY+iuduX9T_9=?7w0wwqr}*!?&CsMg4dN z{*Ldm8{Y!;S`YTsN7!dg@_QjQvVT4J{5^Qq=XkwN{Ou^7u?5fg0Q=x0IO|>xI_`7B zTD;RDeE+2QcNq~@7e4d1a%9e#ZUSnll&+_hH|hmB+#n{QMKV#udEQ zF+8&c|6Zp4T|X1AdPT5Dlz-o`2fw9fLv+`U$8VBH*sFMjZoKP}SPFPjZrpwJO zGqD(rq~j51-~t}C8QRf$jI_+gC+PuFSiXY2wFTahYth^AuGB~0;E}Im`*+|IoyRe= z8J}K}8jHujCF`P{_3W2b*|B#i=EQk;60c9Q@?*RPq2t|n#fTmqsROL-!mXIMDF({ywdic#>{5Q>B9d-db$UXqB(R0`ifqWS7blcyYXmh`_$(eWydu1k2WK71M+@oO>O!6SO)@pv2W z`&Vr12Y8Jhe6~;U44fyjru+`P<3ViI7QAX3Wjx}~+t9vk36&!QqP#P{!*G z>NS)Z;jQ3zJ4-NjuU2weW$=sxY`>vQ*HCBDVvO?VSbH2Zw13vlVa=9JQY5!hNG$1*Jpq5jb+uLjz1k*WRO0CnXKbR?ci2G@6mgb-PB)oW)pf@L5X=^AhC|BNDpET8N(`u)&tdb=eXvn{rIHEL$SsM2hwk`!S+D zMkv|D(phXN>_PvSWq5%qE{sixUOxGy<+pheD;Dej7}~bPwj)grsFZ}Mm zn4|SsXXosel>-rvz+!*MSdw9#&AueF$p1V4p_3TS>`zceMe#GTa&+KM_36rec-O$M zl+$Q+4$;dmJ`4Vb3e$9$pBlTW!}Hj`ugL8E^*x9OhSq8I95bEjbOgJy^Nt>|FL(bs zlY+7(4bz!nk$oDjOB)xS9H}_NaqtObiN)4GsaBaDN#K;L+#-K*w}^Y-cyPWFM_<|y z%HcKDa#}%QPO}GOM)Y_GFvH|5n?qHHU9r&aFJ~RvSau<)7N$SvPYeC%tzhG^Z8~YB zKHHoooLjmLynM1*;tshFr0(Lr@MW1L;ia;2rb~S?cpyKXs*)@BB3|1~`z8hj)i;Ef z$Vy6Ic1xaZ+ckSX|nrI5-SUT8oZw4p2yrO?=~h%H$i8l ziVUVv8<*`3G zVYH6N-dtfFPkF4GphZtvA#jP)(yDhThO!AM_7iRrgCW&@QYI`$d6ZeLqg*qpXr=tU zs&=c3Vgi4AfZn;Vk>6d>ANEsDlyH;YJk_#_sTlQe=~vNmbOz6pvK!4-IA&al5%@Lt zf#4g)Zf1J9lz)>MqU@ALR^JYFI$F64hUuYqsD>XSlWV4l+yzrC)8#B-x`}BNPV(#F zt?GGj%rMifTYROyHvKu~C90$JjB&uay)}QEsSby!3AgGqXr)g*r06c&Q&dmO z_Lg}`y#OPv6{cwKd(2DJTGJFJPQAW#2Q(AYA!Jb{EoHUmpMyC?59Wz{t^Z`gS|$p% zYJwOI8S4fc^Q3#2oyMlBBZ8f{%%MEHh3Qf%%gP127-%4l7vJ*Bpyj$O(~>)~r<6Wn z9!Gzbn4|@b{c)4n4M-1HJzl9IO*iq$oJ(Yh9kFs$F*{u0XeAarT4|;|&)kP=T+Bfx z%Gf0CAvQ|u)a)tFtHEb&S!id6QNBIbwJM+)N^gsH8EqZ3TI^uy>9j8^yJ&wgc`vOH z3$uh#VoC8c%m7*!hCU%gD;^2=Qf|9gn>~L;*-^8aSgg4&Rdnb_r4Xr#V1`q@npM!g z%zaGzJ?vclMt;9oVoD{?p&23OCcjr@C|XI%<=hN$AnEN?GbK^SGkK zz=q@@4X4a$A&uoeQucGDN%`VE5iRp@tM?qIrP>K`DZ58EfmH-|@TY6a#a`{4Dm5ui z>CZ`V@UeBc|D>squeI*0I?6P{+o^vHY%P~UKc+p!AFi%L-}U)V73=SSxo)eB_}`-} zSwRtq5^j=qwK_g@QDqFJ>7NFZ<~~g{sa%Bn;H0r>*mSyWpr;2s@Iy>&_b9)=huXjdHYR zPR0oMGsDjI86Ys;&SQ%+;WEn$h0bCzVcm_`UUecxsLw&*Ts4oJQn_UpiY z88aR?wur@{rB(45(LD_vh>U*}8CGXLyj-x+_*CHe;2ZjqrF*%#O9xV|1bQ@EbuZ%S zWY}C*jz_nU`ZAPQXIHg{xLS3JBh^Xu<7nAj)t6}(GE!rzUL%C4=CtZCX-+W*X+8_* zk`EIDfix25$x2tOISqSxD!)<-CN^oHKIrPvJ*nxWN>P{a~zz{oEk?Sgvu* zFcjsM!NI^-+O^!IpN8|P1WDI^;I2IQA^ddOq`q{UY@B( zBs%~-Zn?ide6y^Qcmzx{zGu&I+sGA@wlTlu_ky?tg zFo1X-oV1=kiMNyDt~LPSzSL-H`=cy zmTKC2(T-y0Iv&@La?h%0%m00qn%SE&f%LXKU;3U?pEu3`XF!<0EPlpW67DNl7~@SKJkto)LAiNJPm@A0Y4}N7%y~?=^q4MJb9efo)t%f0!ESsi_>nY6+s^;a z_`UFr_yfa)U8B0~?izWR1zfALr1KzuJtbrW3Q zCTZcASu)OoPSZs9@#Jo{R~ldSPMMb&&7FYz=SPrSj};qB!V+aJw*NbF@7GSNj@ z?mqQfX2dR*`w*Q>R$>&AKAq!8(NLdl8x&qqHa-HRlyPV40WbD(W(`a{x&-~eXH^nVxz(lGgZx7>M4Iy2HphdF~;%a>Jus|l7Zw|EjbYX&3~r5Z2Q>L3}B zahkG&n_KyazQtJpSw)Frv3{)X_k1Oy`{l60yUqQ){+#=OZUWB2msCd9;{7b)>69+r z=umkTwcQ09p%35O30Sf832%i_ zDoWM2NaOiRM4M-m_ohA!Uxz(zQQd)kvzfaiU<*Dsu z#|)*;l!|^NhU%%{9q5Q~kn1K$;~P%Vz9mD|q+{4#;uwE3Dy5NTNy=xUoU4s5(AzXk z;rBzpWUN`8JW`G4QHDPD{*3hJgpJE?g)WjGt2#pUoZ=qMbJ+hq<}~6sGqH$t+9Nf^ z*;8tJv}fh)|0QCcG>3^w9~X*+Pu3ggz0z)nc-A&4^rL1djy~0@X8kDjq)?1?R${-b z1Y!YO(hYw&pFYljBVJenZzu=2XA#3DGmh%LfB}XWp3o6S{dvIDR=zYp9pJdx5GN>N4ghlQJvq#I3K zL&+V!EVQ&*s{K+<4~(U_$`Px4p3pk6hL+ayy@-FnhRgLkJ(+rWBsKd_!e!%g2_>P& zx!G1%fdT^T0(Cq^($bvemn)AW7M&$rH^mkWvbvV#Dm$r4%$xyP80*GUo+NRANh7)L z>?t*?nc?;0n6aLRD2JzbB;iRylJyhwe=p;?y~Y+|<^W$#263|?;{4c_#h_o&LUj>U z(8zy224hHHRvp3meXz&v9D?|`tp9J&knv-+oOyjel%t{yR2+G z6J6Gvvxur+VJmSTgbmDIEl>@sFbjJNBa?rB*Bjd=QT1kV0qCL30d=CdR@q^AQQVT; zt(l{_Z`rxvc{tc#6d9N&;g&QB>Cv z;*_0ouIU)oQsyoFBSl}dALZRf-dkqV+k>-wIOX$JPPTl)_G-bMLT}YH1@WexZ_s~D zFxhGM13mZi5mX*g&12Sj{u(+M!Qv4d?wOam%VTg%4Q3+dpANj|OG7I+*VUbSg!VFi zj_BZXiig*|OPo>O3e#j#@Pn@%PjiRVlkx`VrIa2?eYnI?{9AoCVz8}~c}3{gJpd__8wBm*s2D|BBg}ycdG*=WWr| z-}<%YMMlfg2g)B}mlZw8)Fq>hB2_GVkBxy6=~e640g_=C{Ph*UjpV?s&Y z^DE+5>zdi#D?)RW!uJX{`;~wHS-&duLtw1qarZ1;u0y988veimp!MCu_re0}vf??SwcK5~ z<=S3Ex3x7z^tOE8r8qneV{KN93t3Gw-|oS-(Q>r=w(uZ z21V+_{*&s#(mm!hagX?pCOQ<8E--)bNvk`p-&s!TM;TXE?4X)N^w=lhvicF$h<+eI zYzByM-dNR9xr~u!3#w>wIn^bA&14sgnNytB zKF-%2e!=85K37v-*33)91_N+M2I?GvNC}PSjn-cr|{lWd!_JsMy*6cFUC2_=x zdFkVP-%-o)nZJK9X0t|4ovF`htZ0L`;TU|(#>4r{am5SG<1ntQ(0zt+{sq^7{B2s9 zwWREXUu%1Xbgd{?F%tFZgW^DDZ)hp{gi)$hDHGfxH=0)o+dN-7OO_9`juGsojRr-y zLVK3))d!0P)nH6n)t>pBRbpPs-=5AUWh5TS?MbHiUwHoU5x?KMny#KQYjk!>o($ZMa;5m-kIM;5*3 zA@X5$|ImN73$tjA6C>|8rG92FH=|}X#ulS=6X3(@A|{%fsmtZGu5XD4JpU&8>OfVy zww+YpZH1J_=Pfn7SW{%IuN~$VO(S5l12Q~(1J$dRomh2^yG5L=iCq|TePMGhXMSB=T^!tYb&G2u6K;c-yJbECA0+l?o8floBL6|dR{aFN*E%br zeCxT07Nr@!sW=io&-Xe@pcx|^>`BT?q3Tr{6;wS~abCYIcO~^7vCKGNSuRt97-2o) zjmv-Bb?$R+Jp`5%N0@*hjVb3ptXLvwcPe_-$^1GW@c^!0lZ`?*8n z4zc)G3XodEixoTmy~bVN2;7pdEBBE`pS%iBdxqxFUE*DkmAr`X3aMDYH>4f~sg-MV zqov=#V&Z&E+xk;R!x)M)s^_gPjO5SaI7$}t3f`)ntLUTaJPvu-q$sQ-T} z=f7b-<+m%Z7WIRcJzRG$)yQX9)qjI|!b|*a#JF;HZAF{rAl_RC2i1R5Uw{uW>L>o| zlf-%ro0Ku6!o8%G0)M(W+28be|QhG{u%x2A<|-Wc)UB zl7CThw`#cRZR2}sLyBCiDi9ZnNt#A_P3pn+amtvbdsAN3jaCk*I-X(0Sae=ssE)Pd z*A1#ODTUxh_G{^u;}8D+(9$I%61zef&H~|O?(@JZ&%?%*x@d}lY4uOz(Yt@Oy~_J6 zb1K@beuFn*eoAZLP$S~VPO=?lQd z_yhaV!(QWelftp*A@y{zHoJd?EmiJU5B6L%ZJ>QC?!Os7+So7HUT1!OzLEn+-B#&V z!&X>L>o!%#)zc}91d(sH<{;JldQ`IF*HQbprF%`Wj?B>G&U{ixtUA(gia#NbJHJ$A zfAeSEM$&AoTqCPB>evrR;So#`jYjKt=BcE{2nz06t-@{$ZO&#m z=$M&d_1s-F2yTn7c~3Cq8CJ9s4Vs}1zX`ozz!-I-;a;5Y`w(yb6)smsYleDKYkQbORYx_Qd4sLvnZ0m1->JNc_d5&Uq%Xh` zx}ZGU)TjP0_l&aF_?B`P^aP@~T)2&BzN8rv2P7>}=AGe*x*O(p%DkgI!n7eUhlw*J{44VFV)ygF#zX9?^eZ@O)`2BsOHf7LGY)=!3Ar>XPrf#lXSK|IYhMx*o~=`?(dcmD-Wg zLoF%K&d(>M^?+0s#`y7Lv>`{6rol1vpkL^}s*x)=m7Rts*31zS>TYmH3~xqSo6>5z zSab_I(as*1RWe@E&WZ4uxW#fw9UuC^*aXEX3b~H$=RAK$59H_Fg-`QypUoGal=Jws zP@I3Lej<+jpPzd*9iiS}o21{aogi+>`rT5?%7N@+%O}8A7wdkjJ-cSHsWyC33y#)| z5lTik%IXg^GI2>yGjW-EbAgfpE%rk-UPZfprn7`pYQ!y$k9a9>FuMoGeqr8VXNe_+ z|A#Z58J2&t1YQb|HrDM86*8# z^xd-?P8pw~yh7?p%A-_LPv9HmcmI@q{ELjxP&<8^@YMfO(fQTycou#VsUxp%wT!Vn zRdSWyFx3!XZ@vr1Du0Cba><#GGvFPZgCC<8|HXg#HARTV%IjP6^Qro&c!$*Qc-&i2 zw!Lio&u_p`XWpBY{qO$&#ZK-L2xRIlCs$poXv@Dw`pl`Z>NO2pYYj^eX6j9y@nZ{eARLu6oH`?w^l3omL((ZP=2Bu z){=k!pbHg%CERFJY(yy=oS;mN&0R@%R4*~9ax!vPRvo1k5^4c)J*bC}&K`H&F)??g ztnn8Yip{@9c9$6eXR40sPbHp#7Gnz^%-J38Q$GXq*tyaiZ$*Yju!sA8-74u;t${M7 zxa?n6v-s073eeus#$TyLJ7$Qz%uA(|fv~V?@jch)vzFV z0QA{Yga%Rg1mP{n&d{#X8=*G7M8 z0+jU$n-ODl2=>GqP`1JyJg=K19~b{K13t0q6PpaihTE8^0-!FV=?oH3#KfrneCfokrhogHF?@G?%O{b6Vn5oH?s0 zuNYF3qKJhXpCFZTxmH~Zy~^(fPWL3Aq_;1Ypx7P|Zld3@Q>Cu1MIUQ;!7YC#MG*@) zWzmxAHL<>VE=JUFXuq2{=WT`fMC}+=#gnoZMVcHjy~tW!^{tSAG3KG_26i%9QjB6u zQ|P>(GiS)M6OW>43idP2)KqRgqBkw1WTo-8LE3hcT{F}zQhjr%ovMGinINuT3hXI4@wY?J?^3fB4e_pXW7sPt>^JNKwD$ zIWUpJZRG=0LjujlCbH4I#P)_Ax#f{ceiJbut3vI%36<-pRk{V-=-hG|mCh37BVhC8 zs3$d?3U%5FBRf5$KI4CrBKtd$y&cutKkw`irlWlwXNi!&mPYn)oEPf0T25N-Lp=5e z;|ok2;>T8scexa+i|+2oTCaGb@-nC zJ&JT8Mz-a}l!-6cWgfy~u-Tl480Iw`r72lcWF@v_yDf2%v7Y@JqZ6C&Gg1?TtQ8C- z5Vrvw=MVF}c3XdXspS(XD=-$VaMr*48Rby@B5z5P`*Y^fvOct92QY@ZOrurX4sT+# zNi_lA;HcFyHIRhSmjI-EkPvO%!CrAEzF78o)#j>3 z=haMwT(f`2QVzfKDpg((KS1Il;T)d72XYgd#Je=Ph>{ekv6X9<^(9}$XFiZM#r}MD z^|}^}3*V!+DQEJQz@^;s$~AC6pMmd_Jk31+BDh4}qV{!ZBrH;QFnbFYVw7dWW2rrn zcdE9G!M^)t{29pvPli$)H|da^`w!iO#M9-{FWY~=?u6${eEWL%D-#r-WE42w3!y2o z3to>(f;X7yRG00@q}_1)19o6;(%h9E!#VsO9P=C%?78LAtzc@>)50iT#TqG#!7~pu z`ce76H)f-yG*E2FjdotZD13}*!zveI0Q4We97GElp_tIcs-v{Z9$1yqnlL|Upl*_G zf@6QCX(H&8wo zfW6m3Hi8s?WuzLzMDY?cPB#fHN^@vw=H!}km=lOXJeUb>7;#pk_4ymviZ6u?Vlh=F z;aE8>G*j+HrXtktIhr|17zOj{Td7Jev7bh8(!jvycomy_7B@Puu5MAJ0@u%xAE$q@ zn{h}fIAYm!e|nN8X&}UNqw6Qq5tJE1RsJ)ytUQB{XC4skQEt+~*YTOMjhkGPVphfHkiFd7q~ z$NaoBGU;hun0Rj7#?_tDE!_gN|EyAQb(_=Zolu>TVS4d3VH+vf5NC>GMt*<3Wm?^7 ze1EI;LBtSfD~S1ni9;Nx<+>n{Hw{tOb@h1RPjEsh7@yPS>T-jb{vPybWNDA3Uq$pa zFtTfEie^v4oN_7j1GLC`qa*plwnAyV?@?DQ+JMHNQ0`B5M4#cUASM|)8)KiHlo3jG z%`&^;3^;$tI(^;TvCSp`G|ib5x!Sei`_|e`9fo2e~454J@|htuQDB#+t$pK z+a}eNvzBT*976=V8CLNBtQ#uatQ(r#$Njeh{3mq_BDJQ39^g~bQ^fvSU4=26^*b;J zUnb3F?sL9ZxT)SIub<+Po}&>ZZ(>Ph6#3hgF^_k-dP12RHfv=MzU5+iyKI-`f`z*N9=@|}N6Xw(B^%HA~=%;_~$xu7akrlG8ZF{DI z{EcpcRao~fsq-@ z^KBi(B?{pI?`tk0K$sM`{ferPoGWT(B@GWk}>Q3Vqq_WN0t>eX9 zv>GiL9wyp+H&k<9Xj#pDnF>`jMrR46S)cz;Vm)z|fEA9EHiC`vf|I)g`;9B9FO@NY zu`;)b1Q~xYUl^sEz|Q4+GZooWXv~uiWZ0mLaa$o?H>oh2?{!`!wQg9HJp~c@qv$CY zCoSfCt>X!k<4m)m-?4%%FqH4L>?3B5upwg^deBGsUSe%Wiwb@|_*R5lnbeNtaYb3l z>oJP5>kXcHm5;!uv@1;<2zi6~{nE(%b19CpN|k?6$}b+MNp~BqJ^FJ@l$6IVpv;xvXjAEo5*#MDy^|8>3VntEa5Ay!`-ul!JY?lOr?$1eMJu{J0to{^{pbtYh(q} zpXc{;b9EDHHW9-rwMphP?^liz6xDWFyLpxaD)$mAXT#$kEEbs^rx}>f%D2%u6vtxG640JH*MELo6H<&S89B=oZVox5Yl?&T9gLTh0#&VWWAe9KHcAr#OZV8KS9ew&Z#d=au2p}- z=9De)zW$H!hU}f5c7UY?js?aN`ytpYCrw6np))^pQ5EeuM4CU#avcC~hJFmSTbdL5 zle@FtkLbLve!`rlFDjRGxt4uS55DKSj4tAMWapY5G5pyQ_NS+hu?=rHwYJ;*nX%jV zoI2iA7<}3Homirqpzh$t@c&fjgnoY{4k}_FcYrfQ{eZX!`^S$hGcT$;Yjr_W;Cae^ z){WN1s8^bd8J?Od2c(WFD^KZBz0IFUx*?5R)$C8Fd=~w=yun;H^&O!r#0(;iITfjA zM;J!XW_P=1d3H&+ycGqto)N3A!64RX*+;7kDHA-7^yfYEm~wUj*?UK<`Wb)XSyum< zZ^$3+ED>vI=RtFy=WhQZ(+24V?GIoawcS|&U#A_FZY9ij{DCzFw~4*#v)DgR=l{Oq z7GltT;*m8?Ty+ht&^A>xEUG$QnJVU*3ImNa2b23MPK4T-uCxShHuWjH)x>5`3BJrk z7d%Hiag^s4+#0%wmMNs%s)VI3sF|mPl(j1?pH_$qc7Dtr+eFxy3U$Qi# zeKA+H*NKVg{#Icy6Q#x@JCg=gsflqvx14ypxGrLeOW&&h!o*qyTANSq&`apC zmSfz5Q4b`b-Tyh#@nNjm6d)}#OQy`bcs76Ifd(I62Ca9bWjch?Hjx9!B}KuC`K%1Eu`jXR5C%g z=$OcCW}=vA<}TLCY10MEG~peplebJm>#~q?HH|K`5}RGk|BtVCfp4lz`o{|{m5ac- z>w?zTt*nbcrR(6L++0>m;RQlZa?VMch9u{-DJMyrORq_qlr(?6LYk&+3N~#4MY{Z1 zP(ZK<7Tg6E>IJljf*@D{Yh6GoNL}PtWc|&Y=qq)9@Bh;erAbcC<$30r`OY&l-%%c+ z?8qj3r5i|H5V+m4nHfQRj8QG-I?L>Jf@Z)bHns6@0RgPlqwkXHCur6mxNt*GO zwtaQM#x7=Lv=LpUQx!No?ki?k!42`_GapGlN!YHok<>tUxbl=yZkj?-@3n$xtW zN4aM$_Y*^^V+s?Kx`4VS`(pBgu#vyce@hv5{O4xct;Z|t-euDy%bO$Tqh-9P zos>RQC>B>$KGi(Zwoe@*Jcwwz%RH5zojyIFDLGG-R+a9ciE?DgpBGZY7XwQ?bJKcs zefEj2J|}-3XMD8b4Xzt4^GAiX6=Q6oeWIb4i)H37zZFRc%}8HLoq-BO>i1AsEA?jk zjL$H~)FDSVWms@iY;D>&s{G@xHw(c(qV`BM^irlnXh!i0LpQsdzsaSrDkfl@nWM;h z0P#*H^Bi$Go8!?FzLX=@ACWmdUn$!Q8|yz4$3lNF@?W-gZe{Sr$lB11@WoPf`gF2g zX4Vl0jz}>mYW#2l*Y~$%Yna5)e&q$S>8+iJxZ{*VgrV>eT!4MPCAwy%GBe)L8}Shu zf|s4~a8~LJ^FH*?Ak}k#87Vch1Kdf|!x^2F1Dc}{max^~+u3%hLz6@qY2|l^7nhv3 zyNQ2MbVVY?r}^2cBIoRgQR-;zv`h#rp`N!wv&-951|4Ouk{uH_)cCoT>;T+iMwk-e zb=W7@q@IGS=(SawlJpAY2GoU)(3a45@RoE;c%0Z3ZEfZet&=h1ogqj z6k$_DMP42b%E5YYDFBi#xg+}rykD5`jXWl?S}U+&Eg2T#FT>&dW zUd5PT_L^UFPc3`TtSWg&+M(YhdCEsw#_Yn&<9ah`=X;<~2l1?@Ot zz;=;~6@OE;$aA#uT|#fxLcOA3p$2~tX;8NlzfT3J{89C2W-GJK&gO{< zs1qUS5X&sN1LrBp)H0mxbZ|KJOryM1k|^Sw1cx~@=8xQq;fqd)_z0tfzx97K6vdjS zsz=n{UX=_dpL^2u2_ZV}V{vTRFnr4W!X`*EjcKY?#_``G?sYIRp#zp*a9bMgV~(P~ zbeQQee=YSEY;~0yZlNzfV4m9AS@ugrdh1dbXeZ^~2d@z_B>x058oNwMwte0|P~``+ z5%#O^34MoBV_}-;shJ+%1Jr+EOlJz-@0rW=c>hqc2qdU7wg{DtDe2R=U7;mx75@k%TKR!OT{SCtsq;4KF!Cu9^Q1`iY-X zpI??HJl0f8Gh`EqAr&?I4ONk}0~F2urtA1*y8=ACA`GRzxvC=fJ=A}DBe2Bz2(vfJ zxk)V8zKh}z#9p(*3hEV=8{2YDInwU-dSNHC(a`I@0&m0n(p;${|LO2z%FcCmu4;L1 z!gEjJNWWR*r#x@v1w^cVxPYF>HFaTVGp{Lq1YTzn!@uTsA=Yd2t%FO=T*Iru7;&tj zyJdKw7Lk_)Z8!M;7R`U{cTDlU%J-P#J&4SOBI7f>y3DN};lZmeFBI;f414or#{}Z| zxAX}`Rf{auR3(DzZl`lLF=U~B*a%yor!Vn%ms~N%{%kmom4wH^p`WXt8~i9@L@C??hXS?g z;o5%>gX1;lU<)@zeSy0>eW`I~bAKB85~;hHAErb+R%JHoN09CL-?rme=^VG$flRXLPcAsB6fesJ;PbGPf*b zUI)Q~e`HW4Zx&c{CPcduNa!(vfqD)_SrLCo-yb3DrZVNtP}WWttM+0by2p=@*J>dhYw~rg<^Fmbpe07 zFoOdNH_;uhLjN`Lrp((UP`7G)mXQAhUV*z~_f;{tZl5YdqWcUK&!1u_9K3MFdGrk0?NPC-*EML1lCHKI@(FpJ)0uts5Jt{4+BfUVHi_3j4Ce)?P&Lz zkHPy~3eTgjkgsot%AfN9z>*q2-7$ZyLHzuONRHffZMH2!I9w%#za`v6752mq>91!K zGMrSM0jc^#?qkX?XAbg9?V}*1o#dFZD&Kpbd8#<0{)jMBnrmyXHI)ttFAo39QA!Mj zI9}C=U-Cgg{ke!+S>H~zC2*x=l}F%vBE`*VXt&zsF{ItiF4l%tl(>?KeX4&QR_OEX zb8XY*$YmBRLpibB`L{<%ku^aY`lX;7FeMQqEmiIq#^5~GfJQrmazh}8skQCXE2wkl+9bLUwEsQS z$rQElKJ?SH9>F8%WQIhUNv?nL&PW-}2l-IM>b`0l&2gZ%FgaZv(6COp!rb*jmr&3; zl6C`Om-y14=cSA@$`#4PcYl13JXj5C-a5z(?ZQ>&P(6SeHplMf);1nPy>O_a;Dy8J zBkW)o!3p#R@5o|uK0+J-&e?E-=hJS-@BvM&$$gLV0&3ljF^i;LM;d=2GebAY860oz zl)2>O=g54Oo`jzlj?;bM5wib`-s|j&0?PbiW>yr)Gow*nSbht&8IGW5u0>yT*Z+&l z15r&}MJ^=&m_hkt_GIIG|B*jw4rfGqAyH&pz zpVS?OB=vBS&m0SjeMwnoP2Xp&l{(nvct*NwmG=*oi|hg73l1}&&9Zlw19uln+sVS@mf2OlrekX>Kqdv4&IqSj`vw=h8nzFETUJKFu9#KajiAF@d^? z@kf@8E=`5E{2xTFHLaFb;+U2~E{^cvSbtWu^ZO5D{*!-}&BM>r@ROzgzn$?0zY6i= znpW#fpmtSp6V;=ejh^Ev_($1F-31pI;FiSt@N=YAaBwrhLYdZZ44?f& z#3e&ur3NC#$Xe2THRajP#&<~rYgB{gG&tzqE9HL~U&3{u4$edmq~mADF5s38&ZY>> zknJ>Dv@lPRaO#+5JxhJH5R3HW2jvczZxauNO46BVm(G19`~*9X>X5kgzWc&)<`WU0 z>unGyY07!aRKa9MuSIf_{GCgA{es=ht0DYi5E>;>9T&X6R1q z2elZ&u?*<;`&8Bm<(EFU_wp_c=bILo1z?W+xQ&H2ymbu=zu-aj>s+L zL(%#JNTG~(b^yH$xefufM-qR^bhG|QaCU#oIZy;may^10n2$)!!hb|jQXGkRs>kQ1 zWH=$6duYvRxl#eo&rRW;;>HWFu_=YMVztinGfDejGcWV*Sgj3j0FN_98YNTCNY$(VULmCL}D_LYaiL%xaoYsGM zydb;rn6%Qj#Cq0tl8FIp_G!rRj)IbcY+PwNIwSGbJO3D(Vfg@U?hV+fZ!f>xkbr*N z^G%J$d!1T1SJfwNg>G<|oh!$uTbBHDz4uWcW~Kk8jou#-G;I0&oNj+9{6QJH9{Y z?5+3wG$!^rvfc)#=luj#Xv8SuOYbk_vW5xe=c6m z0Twoi#*#GOMcYYbEq^t@Gqp@&$>D&7TMNl8L!}O4w7{7ZW${nwvaCcH`afg<|n|Cvft?2BfiKDJonHjkD8{7dV;|Fu0HDHOEv7K zo2;DOK>b_HlPktlK1KWT`rIf|q^!bE^8}<<@)weHuwcr$CXeOpq5xDJ`LfsQG&KbTKBn2VJF-w2x(@~?LKzWMVN?Lmpa;u`<0feE< zXnh>KZ^so@Hmqb3%_)CH@8yn9o8WzCrxWCgZA9SdZ>f}s*DX-#+8@|;r#*}I1Z zi%B$HXXLC3L>1$xw<&e-v(Kem)v{r(Dh4fmQ?2JXe>HVYO#^>E*{h(*x|^BPa<2Sx zODy8d{WKOOhvAfVL^P`}?bDie%|LKCbZ}1l5dGGiM$2a zV=ZxZMt3`*O`p$QH*|x^jD7))D`ouHZ$XH)@w0_>l&L}dBRNxOjrsE^ha^X&x-3Me zBc&pt92{YVG>d=z!l;l|W^|TpKu=>dQ;TOL?zlTgb1<77RW@A0Rl5qUF>h<5u2YU~ zob#jMs`RCy#cTrY2I~gIvBc&}c}2!&DDOr$!0d&E+<3N{8&5sEr9YDw#(%3(u?y|b znr_MxU5WESdMAp%qM3vL$@Xi|UvvE0@e<1Mf1p{!o0NY|IGDTqJJ8Us8|_1x^D`Bs znW#UA?_u98d@|7-&yRxzq>CJnGc!Gc-7W9?y}#zPHm=rWyBO|T!Jx;t2ajC=3;CnO ze@3~^kj2bQU69t3cH8Uq2)609rmV-|5_)e*6c;DHE4zv8Fm?5zy+2#KvXR(m@v8s3 zf#8bX1h$2pnm0B{5pS!*FzoGbIK52`%CyBqv!@HH07jFSwcSZ4V?XgoIP z*pP4okJHGro&x2;JT=>LUHwb6r##z@_Ou{ZFU}Qzqo(^#{~^2dr!#MU;RC1Y!SC?b zU}d>lVrd74G7k$QP)XgzHH)eKQ{T>wx3y7Myw*`+e3Tu}4sOy{R&x0>I$|`bw_f@_i45TiwO%Lr7Zs;0J_f&7CynEVh zFwV4_lw+OXm_nI0MblfqH~drVU>B{dV^%~~C@(;P4L>z1j58srwbRNA_f#(OC97X8 z;X*TVAI?#@e;dsj(&sn6tNDxfJTZS)m|WCb4ixH;V_5A2DoNPGE;4z`GAoCQr!-w< zX*xq_m(_&+=XGW?ylv0cH3Uw&<0GBK09JJmn-E&8^{uaCVlvH{chx>fu}tF7ag~@y zReUYpZ_R>FD{}o?nC(JU%Q;8nxhD$~EVKA)%uL&7p&5h&`1O`Pil`fBhQEJJpN_vT zAR4Gus?ftZz%R|PQzt-O13f)u90v1RVu`7r829+~%8{*|%EIu4Omp#l?t6qil-oqL zD4uHVBtjWNbB-d)C)8BNp2cx@ndUL;_%*)2SA1=EJC{_y+`74Ni(?o*b+LYIv(|q? zd4YY?cb}%qqzFHey;Nr~{L_DG63>U#-cPg%v|AS*t32ZRMmv_dE8|7+e%)F7r~-5F z#Yku9Gr?078*1|%x6F$iW)rFwG282wnG#JOyZZwgt~+f+(OuR@h&N%)X?9WQ1$fPL z)8$jnq#9suipd+=f;zr{Uuw?|oP?9oN^2J3Bi3%txAzwhg;Tg1Z}ETQgWGD|jU2oQ z8yk;9yP+4Ks+xMwIA@11Ml%=q@!<;;p{0x-Ho=_lc$~WJkgups5bmK$f8B1X*$-qP za=XfmOdDb7rut-+l=-SAiS|7yXLeO`lsn^veeQTjl3513m4&|X{KJ|q>Cc>wdVfX^ zYZKCcZ}P5S;Hc?tQ;~l;pXN)vUs`E9>Hcl-MQc`(z%Jr7{(4ubWgdJUIGO*w{aMz| z#IV)WX_h!aE&9gy^s!;J{er7RQo6oriS-!FQzM@ZhPH|bL zw1elxDh+ByVZc6@32CRmCCjYbjk*EjuPF0Nx1aJuse_<#rY1gem@@O2ZD_gWUI5|S z_KD&UviE7Xmygd$NFPc)Y}cIjpWvo=8qB56LX+3fEx8E^nqUrxO;yqe!F%l-?M&BVeRr;EdoDI8E0#w4x*@YPd3N6KQkqH1SR1TZPuT{ zw^1fCTRY)^xl|t;?M`89<*!p8BCycw(DRPRN#bd)NWY-OBtUY}j*_Y7e6QDcpHOM} z1&ino@zP~oNS)-F8}0Ex-K?9RcwrxE!)m4}aI7xKU*msL==-@ZdFEz5NLh6DueIaY zYRZn)x35+(GaaS+eA^q;XHh#zdOUBNdAO~;;F3`x@>!4Litd3@-x>XR!X4(R+DQ;Z zZMcQ_JgMiOKHvC^leO&Tp5qYbP+cCOVPaY$Mp5ErV%9}F!BgkD+6QE=v%8tmf}EQp zo<~bTJiUK)ut2{7EW~n@%3HID-;+OTM$aRyhZ&9@%iq&0;eFwCwpf@+b!etUetc1^ zb9VZ$VgsZ`ZlNvo^BS?k@CE8G)Vl0E{}ve;q;M}$^&nlF_-hc+l#m}1G5TVx`x=W8 z*=^0UuA+JvLdZe>XlR#ZmSvVo(&twcq%P1=b+mtpJfOy&fX3z14cOZJTUPGHbDa&% zfS_d-#i6K%QO@Jar~DhZfjVR+Gm~b+NQh125rR+a$FAyMa~fyoOS%3=LsDF^(=()L zwQhIj*op!~vwxNH(hma9jM8nlJ}ep|t;{%X?Yds|=*E=d>7I;8efnbWA9T+Lo)N7D zo`8Ra@+&B6L-$I2Umn#9`-I|*hm_sSkjhWQ`@Kn#PF;XaU=@;0+7a3%c0_JbZ*}h{ zu-VxeNzjjlRlbn|%s34WaS75$dbW%7sZzeNwWu-Hl&%pRep zR(Zib3U$lYbVV#Wk2IRd@kp^IDTy?6a>VxrOy zty>n3GbQQ1SE{nd=+EoU64ze%37K``Oj)KnL>?-R?$e&_Y_*w%Oyc*l&tJP#n_z48 z9PrmuWr}bEQMw_l#;Z=&Z$WLE0v|$+oSDF8KFEJ=yO!4DoZavcq2Me+*cGd-*b9_#BzwjEOgqLm8!K~E7 z9!;(47<>Y6Q3NJ$YTebUMZ{T($TR3#iL!wRG~7ijZICQ%!r9JYMpo>!^g%N1mkEzS zziqmHF5dmRRb_mS{aMGaov!A7{Z)VJoukiRo`F922JR$WfjabzSsDcZSwN=0it^|# z%CVvR*2%szIkO5bF)>0RYo+rb))@wsKBsN`()(#oT@&BjFZHSmb-Nw8=7-ATY#Pf# zWeQ1|bxG@1Slps+*^D0c%fb7bi>Rw5^>~8UwI2$JQm3nm9k3P(MYhk%YT!NbNoKEq zd9>9OzG$8r&`>AvW+QwidbCBl{o3DEv%LH8(Y%^W=daJjZw!M3GQAin&fSon%| z$RiOkWFl`4d22A>TgAVm73vc zh+Q*@S-{yTt>oVEeFF;gj*mCKr&BRKTr7GT3w0{gF^hF7`&^LFdw&66Ifw}neVPzd zP>y{074&SD;Bm>uH$W|2f;>10U%*O~=~Fck&s<0kGdW_5x%`{d=Z#;5UbcAy&(zeG z-6ie7RhlW)7$425tjp7_5j*OCKlA0QExP^e03vQ4Jxh^lmWdMu7US6}z%Tq2PC9aN zMK)4yJ|3fyJDVsV1A;nLWsP$-Lv>Ud$aJ2F?wQhlX>fKh#y-axA6UY~)VZO(EPtBfnVi*K*^0;(kHVYWGc%h3Us^o>{bWQ%wlAV+-AbP5|Y6ezcFvpa+ zi4jrLg{w--T9`!dD9AD;MK0=giy_*R5Qb{UaWk!5RW`imSobr^6sq5W#i+~GO{;Cw znbW={kkqgjy~p%_aH@Ay?huq62R|=IA!RWdWePuAw_8=j#iIA0te@}dV-mC0a@~9n zpCNTZ7S5g-94*%w9QW|WmaFIyr-T=aJS17OP1~Eb70;WJv{S6Lc+LVig%Y(Kd>Oe* z??>P5lIL2@OYkxi^31Im?gWZalmFm+d%SC9X^nH z(=~M$m=Oj<)Y?ge^-2y~v;14q&N3tX_4@OLSu!3_kOxoEIojvbU$E^{_AxVIr(q0Q z#29T{v$3X@_H44&YRAc4LLFSJZw+eA)2R!9&AbV3*P3t@okZDiXcJf`Gt(KbeicU| z-Y^EAC&|cv2giuKd4!qe=OKQXrw+NQxVwWH+%BbFKs%^ih{w*>bg|Cj75W>ln@ouI zQTWBgxuqV>#PIX@YpyDDeA8-@gvR3$RmP;e4t_C8sfK-5rAO`ccK9xE7*hil_z1pg z`6Yh}CI29<&Xb4|j;7t#OqL#p<6%Es${gEN6IjB3O|d@g_*7UKR@moMyl&`=ycyb} zyjOiNxS#en#If~9jE}mi%G|-DjmOz}{I?mC!d={p`e(BL3))$m`Bu=xexbVre+$Q{ z^pRWeR@l!3xG8X%mH0V$?agVQHnkaUWgj&*tCy>XJ0D?2@z+CdMV3i_My+x?n8+>+ z7nd%7=A5pZx_?s#)!=^HzJjk@UhemyEx}an2!2@P3GQ68arvsSA~W8o2+q#vH2%%l zlz)i$10)u$S_fauj7Chj!WV-hl!yLJ4CO1k`j(CMKc)PaGA?hbI98M6nBd4|?h4Il zPE)3cAw!?Fi@!!A+jv}@Ax>*r&BU~J`U@a`S(%d7PrG5}5tJK<_C{fSc-iO(=>msx zKQo$(Z7Ksb0a4I-z(^1C|Yf&oYU?P6z^fz*+3I*DIISNe|b(}=IvnqJMt1q;Rq=&kH zeOkNFy3oF%S{tW~3&!wrG@|}J?lZ8~)Q00UlUmNTTn}zjJE5I)I%1BY6#r}OBotw0 z$&02Qrxv}YD`pAp(R*(YLyNYs#t$3q^TiG3$%r#HiAItv+RIAoVeR2Aajc_E85bQj z+QXtdfILJCF;cx~wLi;D2rMv5=|jzbrTjQ3SH|IeE;IBImks5vyZX$NZR7o0YChn) zLCt@p8eyn4FKX=Z9(4j#Wxuz&**l7hvFITq^s>1>xIcS1H{LS7>|JG?`X1`1;qDd3 zrVk~Ce%gtlYz=q6Tsu%op0&BZYLT|p8%Y1MrndfN-EOpMrL@15^?hKsdvlD1|IyaL)ar*UT9Y@s??#2rw;#Mr;) zKSwR}iEe~;lK$RoAEM}PS07roHe#!SQ?`r5j#yI*pJbfzJM{TdR`?Ora6$Jr&3~IG z*VM8LgC<&&wv);f-EN}-%1ai1)m@EhSlb)6leX!yP6;xj#CMI41}u%oxVu5^jL(?l zJHy4I4^kCI-H788tDS_$y-czMuc@ojyutj&W11v<-g4TtMQf8{N~*hB@!zQR+ligm zXQDYb^qG=cx3=7cvezRN@rzj%Gm=%c++|e!C`ov}at6;27UJqybJ}))vg%Jt#{M;} z6U2$-;xx(`;htiv$sQDBi|-1XTzyKdID;AKjAs(-s$p@{>bfAPJ$7(qJ&uyPq^{jN z%AA09Y)Ou&zJO>L?WxNj z$p&(3N#ZMV36E41pe^2i#GgvP4hyM9)A&Z#X1kl}fI@qSqrlM3b(9HZMJ0;Hb?ROOur_cP*cP)McN^LOgTa==TL%C_rk~NG0+WVkskAj!hg5! zT039f%WdHEV6*!fqXLmaIWv-U56-^F=OngCl({XSNYkaYy0(K_{Ed;XyPBgwi?yo! zGWQgG!NnHVtST$E`5thSpOlk7p(2;^nQ$#B_^Z@ESe7||wJ;Dsxl13)#kQP7spOGofd$e^XC7Rk+I%KPiK|(+21NcEF>NqCOkz~K z;i|AwhGE8kBx9L4SM21+QB8iy231kfbgB&1&krIZNWW&kg;r-V&TczC`vquo{*jr3 zh|gM9#KhqBk3gmz4eN{MUa5ZHk|O2lmw}^jr8&N?+mu9+HSegB!;Qy^_cpE83^X2> zI=BLJCi>-*iK8cdsm7H4mOej<80GuYh&&S$y+`_g-P+kA&}S&)F`)xErmkS3`)Oe) zn<97gejoNAI@ze~L*<_&EN^#ohh{V` z%29ZRXcp7a>v|m%%%#d6I-_p4eXhsujMq+T>=MuGOsVU1+r@U+N8UO`&Lg*Q{eb=9)6G-f2MR{ctN3>NV7bOTHi zb!Ul^V9MIP~g$yRyK^W)O`NoJgL5Obb^%c2qG=Tzapv;JIv z1SN=96&V%F$%8>eEY+_nG5n|!*SxRY*^dm&OJbyJF2yXN*|C$t|%ac&}__j6%-X;1PdeH3 zzGArTBAyHL7>GX;p#o+E~P=7>3l{5d&8DmCpaX|cNY`Xi?J<%PKJJ{1zv zZr8lTIx7-zeIXXIO-E!tE(cczF++hhd@+4Be@bT}Z?a_=&UP-Le$!2Vrk40#obf^; z^#G`{5e`uwWSzE?>U-6rtG7BQQ)Cd)u&N z%~}x+h19bM_fgKKCJD+o11F&^T}%uvknZX${ROU$6zW8!-{KKySI>>8KkH2SGzj{u zahy_!nF+NPYaX6<+xQG?g_`JJcm9TQTE#LJ{tiABLrtr>Sn*wdb3FRcMPkU+hh9Y@ zb*^mPYDy|xNh?VV5tibw6|NMgH6CkPjo);@cceqe;^{U<*BdJd#Z=v1<`xFhHT0hG zQ6&$ToKSbQ_N@8)N$DWR}ql{}jj>iz6-2X(6ThviT zG3y}S61*pWxspKjE3l@03RPej6mQOf1;(oX=%fC#Is}38jb3JY_>U+DpQ0#AmbFEE z_EA5JtOsF1crlH#u!;OM{;I35{4(VOQv6=(ZS9QI^F4VT%Kco5bwW!l6QKA*!&@&7`#9&SWQtd~`-uaAs@!qDyFxSAYTpC4HnNI;XcOD1u9_l|bwQ7c;z*REZyW1N zwq~(5X@_#U@`6VdIjly#$B&QJlCH1QD-6Bdi|HC=UucG{4MMiDc~hwd!LnKm!9nvV zT?4zQ@jZCon#FaS^TDD&PaS5cZU@m#O6&W?AxNjihWIVs0(U;K$4F z50iF(7<$c9VTW!%HwE6KeY}8%svST_d-`%#QE8YD%}}1kd$^=iL9j$oasWS*(E9!p z_AgyPn!(V`%tG(mPd&k%vn6+n0GH5XZWcF4JJ84LP!%n|MOkR*yYF?L&3K4*qEV(P z!>0l?KjgNPmZ46T23Te_qD_>3)|FEJMDB=xnfXJO(2sdOcV-Fw)De6E{@Vmfmlv(4 z2d|=WsgRIc5airOX^SFetBR zki1#?0=2q<^>YF`icke~;Vy2A%Lzh=(2yWy;TzU|&4!fS6M|~uSPes4MBT#h?RSZ$Dg!HAl@7HeD z{EENEua8zpvGZt;Kq#c1TDtA}t=dU{(vBR3Zui=!8}^24D4whine(aVpB!=j)-a|r zoxc{1x>HA(h%dBD*~i?E-uE}ueZ!uuk7XC>)_d=>zNh_-e~YK8{z&6{mRY_SYgR=r zGtxejN#r&9c6`3Q)bByRl{gKeRlOu*t(~-Xpo6%TP@k=qdlcWWn)s#YHQGFXLhCS+ z{T$IF8GjjBQP*zI2EV`FF(s@9mbht5^OVFvus(aczTMp~>*=6#wrwm$;?NT=bk3$c zFWbq`uGUV`82Q#YyYdr{%JDef$4oQpd<55eoMfX2lQ=PVneKaky*gC0CT)bwutKtt zlB0l3Z&Jmnik;4Q>8SCSph=&9F6{_E!cDYIcg}WpD&x3`^nH)ec-;NjU`ZF}{wU|T z7MGZc3ZLS-f3EXfgIINK<6+^TuCG7zeC4L34=o#}87z%Ic9tC^p`mCFWaSU*EE`|r z^$T|2DY=NWgS0zRc7{nT*d2MIT$OjMwev?FChbD{k^icMQek=YUGrprClE^;>Y1JL zYbA9es`2~(<`F7>i@r7Ge5ow6sDprcvTJ+APS0b?k-F_%_Y3=oAD7-OQE0y;N%se9 z{6(nGndc}5Z)>B@le!vxe&{orL6Ugi8CWIl@Yid)GF_5Q80tF{=6Ox-5ZdFGE1fcN zoY;!5>2GT;qLX0#5t1c;VJN>i(uruloFdn9{ZmThGIeQ|wIEA99v}rR{c1=l%Y=}f z;w33HwUu(GJRErjN1bOE!eLk6iq(KV^!hof$IK6^eXs*D$Lgwm4Qp*}IW;If_CR4;jZO{=!sVfk7qs@dds?`uqc zyssJH=eT?8Z$m0SPq+)mum%*qGwIVQcTC(+m#2~hai#NvvQi)vuw(T}=7B+(dBXO|_f!TlMXZ-?T=U;q;gMe?Ih3e7o){Xqdf_T=*E? z*|GF5(Gv@Q>QwwYg^wA=6l7b^uAdWDub%^7)h*NKXEH0S>JXxa8Tx!D;Jc{V(7vDN zCYq<}&r3V>?fFa6ZbMh)qUH~EI0oS^v|*LsJlFN(OO$IoLaEfY4urpk(_W{?a>hSN~sGz=Ju}@6dyHvK0T^P7i*?Elab&L8Tto z(gzKwK?p(hQ*V;u~jhkVI9RGO-w!w!!r*npFJY@{nKGXh=vIW$I zcjgLzH1|hy1p*q;NLd2b!ulh)0{2oKoY0JSXc3CSd|3??m`9tZQk9^#NLfpn0F(tl zIRKOakR$4{OxL3k|6t6Iaeh;hl;?X`JLSjNK3IQ>?uRcH#inOR$_9FUn54&gD|WIoyRc!pQ- zT7%DV0nhziYb#u;zsY|D$7Sx5pZc!*@f>n4I3CpwdvRvY!RL6Me)N34#CdrmYcn2y zu?tt;KjoRdf}dW7Pb<*=;0$m0fmirby!LmVIfAOCs{ZYlTE zNaHeN$l(=VlkfEqUh@*3rwy<27kuv$e%gOc*03-5gwj`Z7j7P5WB3Go_U`x{(|M{(@?(OWr*N8Xa}?qfXjA$-Owc&RX=GiWo8P6cy^M}Qc&u46IRb~axW6E zCSue%p&88eC{q_j*aIh>(}>GmGI8sO?N=$#{|a#o-#Zr}Dby)UA;f$|DuI&1tZr@woF5&(X%N$YEx?UC(`nUe-ax87y%; zIA^CW(C4QwC8kE@TC_o_h=R=Q0LpnX#edRn6LUFO*!=Y7id-D)t?=ra(?OHmgZU%t z6Sxj(i#GYq%DFKg3aa2}ifR{Bp}#Un_Jp+%AZPQ>;z5o_cG9zSECE&0Yhm zi|!(ONsKVgM>JglP55E$B&z*^jry_Xe9BeTE1X*D9#0+v#W)+gh(+Hyn;B`*8*Zyd zGa+|8W$T(gHb2D7_smr)*@3*=8h=H+Z945zSx=ZtDO1E>@BIXSeF3r!b+n_v&I1iu ze$8acwDbt5tL3OzGzJz}LY0dx*AbO#K@1Yx)Fqs^8pI1ZlG1zLoWHi-_W}2gtAzSB z>KcSS{uAPP+qLy|#%FNlFKjsB`bPSjx=_wu$t%BXx=-q5#z}5wB;M&5=VbDQ!rvld zokT2v_KAo^M(K8cqb`%LH~G33V{Q#hV~F)eE4Ozt7dx)C-}H#KLx z^AWj%D_48e{;YN^qWOck=K9gMmYCDrLvnTd+b9l%u*`yF$|DFr0UkV~2k)&0*qXoc>-FdDqs(lSH<0!dBP-AgPE?1&an>yA!-bf_ zgOV~%w_BOgqLw<+uMvVZC299Dd(kH-3G?_|pA}?lf9JXx+QrY&KBnB@IW8K5uUZn6 zeErLR;&NS7Qn#ev) ztfOl#XT}qj&DCJ~3wBGrPDC2^XFUgheWo?1`7Y;M=mFCHj2+U+eC(6JH(lRo{+nMa ztz;AIqx|($S0e4uCeXgE?OMcVe?!KKA?m=4Gha?@EvWsI#pWL)=d?P1s&l6NhiLA9 zgXyL!KK&YMj&u4{>L|v=auadQP7ZyF_Cp&?2%6-TRti^JhEf%D)&{8ZJ?to}TgHD& z`}ol;Hg*w{$Q+azuY=Tf=2^>OSCLb|*IX;i3WeJYiA-M-YHXeV4cGH~DRF-u& z@l25pp>g#60zccR4&gh==6L?w=o6Fvz;*s8Ub&E())bbXOGCm_B==}5nh z7VdgYd3cDJji3CL`q&7~E}xQTC1x*k)KrB2-pXbpJ0Q-WZ?cEMj~<^0Jxs0nLF#N~ zpQCDpua-U>SQ5}hZV|Hz>2Pa*kx(fdQqF|S8S70&A|e#h5X2WP_tklii>2BEwBsuR zCsWrk+f8FK-tzsOd5(K4XO^;09Wr$LVl;`sTYh1k5Lsb0h1J>wILN)ky<_cEUsql* z-Hoy^pI@qL$mXS$?szEWy7gNv^K=382*l^Uv=Ph-CPo0=djAQ>u=RC++DY6L^Fv|Y zK1#el(rL{SCn74a`?vUxo9^MC)pcrHndhWG7yS-O3$n>hkd@&7Ar;FsZNxx1NWR5a$_>!2@|1b8G5|mI~=x6)nR(U@v3rBo`WxRHrDJf@)IM#GC_%v1b zq3$^ij%I;+40wBSX4d_G4^}5sTupOJH8e$cWjF&T^>NPGlxyf1CKR@I=2?Yul|-4$ zIuotP+#zVw&xogBxp^|AIKq@;YyJ>K(PYhHw$WaK&Qy?1Jk!i9+y2&0Yj)#tI2`%2 zaHBlW(OuIn_3CQa7faJBIgcP7a^$*ytG~f0iejCQ5O#x?yh)9J@0z@k!)fP`>8`u zCOfVL6%irT@xl$;TO4tGjA%@ApAL{R-L7hzbq=Q)twx+HNcMX;>@jNk3m~O&OVwMf) z?%Wfg`J`QciZE{zg`w1Mo+`r(-Gn^N&H8-ej7lGxmtNy9SrFapHcu5d@SkhCD!z6^ zz)^Q0pkYRM1mAtyNevG*xr;CA=Z62{TDj(QINs1}eqJ9}In+2al^2So9aKl;KM}ql zJuY{3=+^D#*O#TS3j-(Nl>UZZL0N>pWZ!syfzaH4+Nl|!aWsu7dzFb{ZT4)T7*bu| zi1*V9(YGrvn5R-j4xwg5XlaSV)G+i_^(RZlx?oaO-x{2FFe~nuoK`ll-!gMD8mL_*=XA62xTsQ5q z^7Dd!FE+lXI~%x-h>6%#WUdj)j7R&KT=u4|ja%#LV+S0$hHheKr(RUFdZ^kkeW>F% z`fEaAOJc(bLwDeIlyRFMA7zR(^bTfLbbMoxGP$0{FxHtI|{BAn$laFW}VcDrOMli1p6>i{-< zTYt@gGeSG?bno029|%>Dw{j@$zT>l;5;u^C$68k^Ui{hq6F-h*j=Ca) zf$3qZTLjdz!>INj9Nw$4Wai{gKu_I;Kj?i?1wQQ$GNa)o?y12$Y$$Cbe)N*iTf@tI zhF(ZnRT_>PboW2~E&foYeCHk9<8zuPdy^{u29?C*)bPd+aW~ZTO{@R6_?78+Wzd?a-?h85NM@>dScP$9xm}*RprBHGe|w7$~5p$=~U`e|d8y=R8ZfC$QLGuZ_$2 zBs{H=A)#WL|( z2(tyDfgfl3M*f>+wiX~hv9*F9aa3|y2tJW@ShC#p>Zf}A!Q2bwas`SHyfWsf0@i#O z3Pq#uVRli@1PF#MLm_(PU&%3l2n`}e>c@ot41LRQW{zb>N_o+pZqVg*RO~d5mR3Ru z#o+nb^+&i4F+1yS^eFz#tz`$OS}vGha+qBdzNj4$_$2&D@!qC3wl2N0Hr@M&D8>)& z*QW;Sau2y~QUy;&XMxA%4Oo~Fcuh|Jc@=#?Hs=A<6E(6={nL{y$tI?M9*6m`8t3cY5Lg=#h5BM3O;1J|E^R#jP`pkH$=?^UqSfH?Ihv{)*T0reKoqAQuKQ+E&M5y2C zZy+wc1m8({x;4V4thMr4f*^l}Kf6)da$uu13%0Jl0B_k%%xUek^l4I2$)dm~a)oS75MTUN=58v+*3e@nLX*`5YzC70rO zTswu8EY)^XhFvIsHr@0HRa0C(c;8&AwyZhr$d!8K4jGRVKRdCX>+|jXjw#H#%B!qR zQf4x1P8;s#d9fqnGv|x<2VeBw=bUC9LHl090H^c*A7+l_7yJZsDX-CQ;a=p&x17_p zHtb`qtiAFniadlB;S272XwQf2GdH|+vHpC^Relb|xv5%znDe!*ea5URPsElUP6PKo#oqaU2f=vj==?2n9Xh1hW zOrYqY_Mr8D`IaiQNnVIG-r9*aL*o(91Mac4QT1f{P=Eak`@{~!(p@jCmRTy^cRo^( zt?VI-70n+(>1Y=UYfbgH*+qPhbgXzNRkRlen(U0|=L7Cf~`5@h^c#5L`)t7P< za9QqUxj-G_Uep=%V=IT+kDC;lF5`z((;T@amPdRQ?QBBc5@u_7Q)pM-Bt$$pRLv|- zH1sNekKkxFcvK!l8#G%?h`2{hUeg%I6vr@>&^~<}dgKaIyl#N%dYarNXkB#A%Y8Cf zUc-;4zsS-$hNazB9ua?-#lUUzRL7KnhVpHxLYp!OS%tfw7;S8=u5Ti@T07I1s_(^F zJ=NG1=EGe@vC(Kf{iaMaT!-@lCz(;^smykN;95Hi76$()tu)<4EAhJe9+`0fB@Sm; z!(Zc%(ipd#h4-6QJ8~gNkw&UiPDf1_y&sZRM2Q`g$3r8-rMTl;TP4LBaB`fzDS>7z_yPJ;e*W`xWNG#0O$GIqidVp?x_i1OYL$13gp{5|4N_Dzmk*Gu(xa zjssW^Q#l-@U^#p;jFig&avLCYCwuRIv}xEoJ8jC&PMb@cwmTsy>AjF!+XNPY0V*89>?VGgwMXIkeJo6m8n}L8x+WQ)Dft5b9sJ018J`?)H(!AfcmPI!rDENm z$u4q4(}AvYKSuq|Wb|NgK8Tes&F#)U?NlKxb0AA=UFy}CE^}UDvkkLPU^smCh9}q- zm{BRH$j@pT4u!fyNg)=`RQXxl>B@ePe5Rf+jknC?`jIbaCrdo!qfgPdy<)Jr#Jh^L z7Pe(Qg|3rAf2_mpwW2)ls^AxYwfpj{&F9HZaW*?Pd?B{F4vfZh8FjXPx)X~#wB`B0 zb8GIumy8;S{HetOd`oOgxC40HF!GA$QQ%qes*h^-XsV~^C33#eK;8kqedX`9Z+|~} zD2X~sy~xjlJWFG|v>X@bi@mY>hQ(wPEs}$dQvW>E;VP2iuFAnS2P+kgu$^KVmmtn&d8si;dt)X#F% zSikhYUt6>0EV{CO??SBcsJMQ^6J%3agZ=}|I=~t3+hvYaRQyUB?+aLVX7B&t3YIr=Q8f$Mm;3I`WC#e zeDy<>!^FZ!MUJC#Sj6YgBW-MNed7Jvdw@nIc=FY}0vPeCrjOZw9#qMpdKgsXTSG)t zG$o}}nNSp~bOdy29Bs~152K!o_E00u?-8~B!_W-X!z8z$kot<0Wq!n-5$6NaJ_ESy zr+etAMCzhtlI_*tyTb0#kb>aa|0Y00N63=6pJ?!ySF`RO)q~DHMR~5uJgfL8avm_B zO>8Ew-KQz^k9#?P5kBYTEHl-w$tk28j;Q$2@BYbuHK9*k2iACTI%PM#j!zO7_%}7} z%1Xdo-`tKBhK{$;lb-IEV*XClaET}DW9r~FTjo9yk(o}#HPtF6FtoNM5J?WU>J2-}5-v-(r}yt*|o zKU20{q*s*AcAQ`rSIy2Eq~Bp$ObsgH=9b%jQ0}Zhp3wPu`Ad}D^E1q@<5^Xiwei@uaPG+slu1$wekXK; zJB+R|_<8;g);%?+phpVi+B9xIu3?}Ss5f96T>e~ts9P$l-Cz5e^(1u~bsbR4M*R>q zf_yxC~@AAKtoky7aX_;qmm0V(xF*PG8$5q>@yOf9A&*a3nl7;^o5O^5yiGT1a* z*~RV0&j)9z7XdE5$KS?t(zS>-f_q5^UJJb#-3a)r${vx%Dp6(%r?O7MJI3m~r~&YO zqAjFE^a$mYw1OApzqcsvt>a=*xr%CVatGhS;a@ zD7zACa&@DFv*2kKlk@xz{68T=FUITH+Kbif*f)v(9}P!QVFMAo=Q945EVAb1Jf`fH zW?~(!eiB&^$YmVU55ACiID+gdIY2LwCtAH3%k-ax^%K<8X5;dq7q1OZO5rt{CG>n;|`_eQ!vPoaa3_^Di zcyFU+Qr(VkhrfgGo*m=mlq$(yd)e&5m9x z%FA2FspMIt_Q!F%bVY2XwcIp+)n&?_%qPmpIe>hM@?iY$b-U%{=vT3t)H&!;0IYQt zS(QDRn&v)(dM?0;G{ITHS(5!et>(YqKYBOC*0}!8)s-xH!~Ng+3hbV?WEZW{8~$+* z?vn3UiE`rZ*|FNLTw;_D-oHj0+{PI-)8er$&J8_Fg87<<*_Mq4#IWpt;?foV?G?X5 zw;hamfWy$q&E9YTu5`RQh`LkkYGt?MG^?q3P#R7R3Owrgn$uUc=1>yt_&RG4pt+JeWhPFSBPOqb{SgO)bU!}2P0aVBc4pmf|7 z&%u+5sdNJayP+P{^l@fi*-H5-*9F={PLM0Q-lD_g1HAz?P{~WU*2?c=w%=b%OUyaR zO1>e@>V(hUx87Fy#g;|Dt6GbFAr|5k*|aNsuKB^uyR37| zpQfAL|1Kxfwd`4cv3aXTZxD)#4mXcLKN{4`jjc@2!APSFmpx;2^LE|n!c>U(ucF2! zV4IT|S&%`+oXa%0FOD3Eo~k~CN_5OSScN9f0lt)rT{eZO1o{0P(qTDH{P1ZXs#&0; z9=Aazj<>=LYAI3UNFQm%)k)MDLv#cq`)`yNB5j{|j=xiX^?QdqYbMcPox81zdg3oU4t?)rK>d4n;Pi8tTZMFMiO2Rp@I@Q>^6ykOGTLIUfZgrAxZNH3lvA|d( z!Mavp3>{Jm*;F!wyl9zax=g*+^f7JroD*Jfos6T~ZN~@&pWn!-JUO06u}eGma#c~2 z+Ob~~2wz}-hO#}Dnbl9*=NU(nC6?8IsxJ_qMUN^uSj|E7Td?Y4pV%AIUb#n>!>X#$$^Mf498hT3V@+>uQwCl z=1aPJaQrf|m%B*T(B@oIXd;Zk^X1QZHlq?m<51E-B<&bd%P;pXbf@QFU0)7y!n2^L zdEv8F2jPjn6;m3{fS<1<4aQ`mF>Lj1CaixDyoX%$iX-{T6Y#yd*h=a$a-sgTiKl`j zlVrnxmD^%#gO%{N)%ex@cME9V#J*p@_s4pk*hNo^TwB&xsHKcgzOvA9g6`K&^)zG5 zGaF8cXyXz4-rmf@m5 zLu{jZ!s*l~eNgPpG_gJRX%q+P<>W01H~=$$=srz;n!Oe0ZDQ}b1?+8zWTTiNOuDo^ z5>UP_B{vP>{uT32)=cby&$G(;Vw-ytFqOSr5cRS>SK&GQC=29IsThp^$jL4fd+P^< zZn4)i0rk1%WF}osDc(@^rRzfQRPInbvda`aMy^p_vDvhoEa8kz580xICs1`n&&v6K z%B1Xe$Jfj|nWoT+ zVNW%FR>`BwoAG&bi8iTZNc`K%Bz&8AHDX~_{WdD9QND>cNZPj zbwLhuE4wW>EQ#b!bCkcD^O#mtmEe;Fd^a~VkvbacP?a=YVaKRScsqb!b?FB8r=<6T`h*%M~C=lI+FZQ#qA+D~z=;f!n=jK_*O>kKPhK`$;yWN(Ep zSiNa=i9a?u4cznyX316>Y3Li}?fsO06C)ei5s!`ZSc} z?F6p0B&&McCVqZ!Rw#)*Q?LfB*re3JY~Y=CTLoaz%`TzgfU>))Hy@aiVQceX;L%q} z2U)_LB1?Rqgpz9a(Y1xCO-W5@%~4cQ;9JpsHmgy06jd94;Hqz1vhyy*R!L9BI$G?^ zBs>B&R6PonBBef(MGE0fB7ncSJ?e?^Bs*$g0rN-)j5ED3 z74RP*tLg;w_?CX+X+<`Y&&ivAzou5UC4MDD!=#5gNWNn~9GR_p5O`9t?_z~-^RA|E z`Kv++p0(hAzksFh3$8Brlk?sI@@mW@F^gAdr}7EJB{Xh33dipw8eC1+;0nwgz*^~8 z4UySHKG%(gxmrvV>;8jWuv5TRc9I%rU&~zVfx-28W|BUU8A`s@kmh~D&+?~~sY4x} z6S%q^+_rHEKLp*!41eLTMs||(rK$A;B!DVssJn`P+#|X`)4}P)Uinw*;d(pv(Zt;y za5u+351vaI;^MV8n%k*u=zkaPXql_*l4#3LRA;st@lVSyCE04!b=jtPE~9^?-q6TM zAE%y_dLoD{(rcm{0JFXW^orwANtX6(Xqj= ze@dHVXKlbk9T@tHevGx9) z{eN`X{_me^V#oPspHDYmf$^}cstCSU_s>4Dt-NMMe^rro3OrF8))iH+ARB?d1hD6@ zw#HTl*yW#Hp(3`6{KIkn@w51jac)&n-X%cI*ZkwQ%#*~5!RvfviMn{*3sO0G3EyB< z5p|vI@$ZY?`@ikOdoC9puFQZLdE5Go=EshMxW*grqx^9+TZSvpKSCAxv5E@a_Z|~~ zD$J!~f3H}G_yRpjEMp-?7h;6wjF?6Ir?3-U8K43l^zd2*tg9v`8FNdXjChCG%ty&a z#5>e9gF@NmF2cIF&9}xF>v9QE1MXn*v^s3R9iE=&|ULxx-nX3kh|%>^Adz z_*vYu#2V8)4`l0rc@;X_YXYbjRFKtVZ>NrKtPuJ=2aR{V ze*>O#o(beLX}niMjVSpUpNOkd;sW44`D@T4;C!@Q)XEe6^8zcvXVG;SSCp}tbDS zxF3Nr%F4$OREK&LuCxF%wO6l*RH%kmf7!Uh{$W+G5?VT;DbrtHIRs)n6I^$MLnY z3zeYxB(u?(Y|bTR@LXg*G4#Ak;NGRp5Pc?Xvd9ygzssStlOdbc`khRLT9mB5Ke0^{m-l;Xu z_#mpG>v{u5KpwBU?=%dMJ%wf|RoO#iTo=Zb6}T@J??y@$itr7`b_SZYN-kF#Pp`@4r}+AVYufGWAV5|JFnpm9=jRF{t3)w5vQZnoU7lF`#_yP z`(v!161A?A-cE5r{WZD0@-GfgQ6Bc3Vh1ty<21LMe$FR04G|ZZbDhc7f4uVdTqkW6 z7C<2mkF8AirC|iRM&nb=amX`p1q0B)1D4~yPpC&Fy5f*H9mep#)B8xdS3|FJ_F0`+ z3mEepp)H$m-es*ur4XSw)E)YUZE?8uzs*;azb62%gzWfSPNJ==>PvKo#6EssfHV{> z&m4}c>F!%XG23FDWJsewf0StQPI-NGLg*WrCg)=F`VPHT>nTh%qyCX60f5e5wkcLO`EaC0z zr;!8f8JwR?7rg><_&(!Z_nE4K=)VMKH4VejlQpwu1+SnNE0b`oH(r5>Pg|aWdjHv{ zDl#i_%tp&Y$~0>p`!3zhwa`=f-9o=PS3IDdEKkh*ioes`Og@5{CYocq0NSdx=QCJw zgSWGMx7yV7F|K|ye^Z`C#em{1tCcET8AUX}&IwHJ zUXhalsjk44G~7ecJdE?nSI+IH7l&?G-ZA{%^z)4A=uyCGh)ozG&oRHpzHc_L&ooVw zX-g-*7i#F5e>^hS@(}W*xIUNXa#jM)a3TTvl8gEHA>n7F6z(=g^C}{W*`3gVa8D4r2UJVkpV6!5e5eTAkoh zsTYy+w1xW)>v>_MhXTgXe~}Nc#)=eUceZY{>82q~UyG`|biX7LTl6jeR9xw{%nZMa zb4?|pe+#WV2Xd-iJV4jl24}G3AjT!japTa?H=0G8FPUcJ?pkao1(halaEH~w=Ju+C zx-QKhnW5V*vOS@1s2=1TY>QAWtTm2~E@(6aud%Ft9M|G}&e$1Tvi!IU9!>3Y9}inK%b6`Wu*#Wt=-`Z(R<-@LVwj%>Zo@>Y!|Bi z^QckHOS!|5OW2u5jR_vB{!n?^yRi6wP6TIe}r21bS-8cvP;?;_Z0zDouL~|jjVc>zoSe; zJsqri#(5^w$lx%y!_1uuk?BcW8M@pU9i`W)GNPzzRR{6T^=D!H%^)XqLk)jHKNX{! z8bq&p5rZNvVXf&Cb&ujR>QSq%Z{?>n^GgwMO9=DSRZx?g$3xpe_}a? z`Hfy|xy|_+GnF?zk1*HB5ocfUr2cb$zG-%JJ^Bcf)5NBoY)O=8L?Y@SpxN?hyRo2V z1@UW>%!Y7BOkLN`Y&WEp*Gefk1MKt4>mlNycaH{lxOH9Xhp=J>BEs(G_Bwx7f@Y4N9~Ap= zFD(C2q1c^H*V5@RHL>?03hF(Cw;NckSa{AQ=yx<6bN2DOalTxAtN+p!y-e zWY-O8rrGo^MA5NIPe2crf8&T8>2x8X{9B`f>xWr65PL@O$#4hu`d7`4f8Mf_eZOTc z*=f?yBDMy#8{eWHGd?5z57%RJn{WUnh#eJv{*P&e8{WWXvcX7Pi?@J$#6!u*qd|6byDbYCaZ^2*LA(xV)uUwAD8>BPUB9P z{TF}%B_bB#8ZF1M#u2jLftI-tAD71J2d-j$BG;ce;Os+>MPdVtKL^H5Y$XQWSa3J1 z_S1ZQ#xhNZv)5$>e=ae>eMegi@w$x$mVyBai1()f(6IGX6iF%2&}R{SClFx^C4f^JaJd$z97jnDwP zdn3cp4Q1b^9*}8WZ}hE}I?toJ(V=f_W&A#KE=H2VR36?Ue|I?M(S65sGp3el&%1;* zo!Tid&X4dz95m{$oRhkhK)!o9?H{bf zZ7`)H8R2(LJodh^i`lz*3&#o*H^MDA)>8Nc9rk89#>svhHx8z)Am{(3O(M)f4FC0*23tE?e1rJak72~} z4)FHqaVkiSlv1oS)Wwhi0ut@G8Fzj6TxM@;fQwm2`U0ro63S-Zmr^|!m~`~eidF3P zV70K4*8VE|uGDCpM)nYeHj!&UW*{nEC#@spiOQR}YX?`bk7QsT!+98*0r;K;mUqS5 ziS?=Mf7@hN%ykQ%deq>+8vc?vAB(vw9cIV!cZ|t~zp%GS4(55hK8TQ0Bs*pbb_~5j z|ADp7I{?USc4m*h&FCgY)Kcm-bd*9}Hdf>946dvy5Dyp~Sf|SwMT<&|u9rr#tBDtD zm&@NPFUqe_KSVFCu`;uyKJqHP9PZ{GJDBW*e_4S$7W^KkmvE zEtf`-OX`Q@6tPfmAbVp@>Ms!%JN?L!sv>PM@c#$NnV8z|wW2(DjxUln>{*X#Hgt;3 ze-Im9C4gy!1l%ts`?&o@`(Xa-u+o7YL+#5d^A0pDus$PxL2bn~0^9VBc50;mu1kDo(als&d4t<1TGPNm%mfl!?s}7;#6FFd@Uq9k59yIabQP{4M%b8%1@EcvgO*n z>iIZo&AFL9b_pwx+0~qJ+cEU+a_4&Qf95!Ze&gcus~eZNPDbB^cQn%PbIq6As|uP> zJLpx?sznc(OyvAn14Kn|OnH{rrn9%HX;yySf;a=O^8>dW?fZoJy^w&lX8io>75W|A zi5v>hKpH9VZzpBw6ed4qb#g}90hu*1d{#UVeL*-Pw{KiRnv`lKV7??Nk^wE+v5^2O5MB6c0N(lL9ey)_*B?4E|q=L{;Esk`h9dk z$pLb~*BafPIY1Q?EB5i@j)QjGM5iyM#IsOH8WOI zX+zI;D!|)SM+!a6mS-(3e|5$@7-c&*&B&ji9>psxo%%MIm5YFd`UBc1BUxc*XwW~GKi7eb_J4({L@(e(+qw;dgc3(XLN z<}yR1RIdq;;!f--;O&u3w(0OBMCY$vDqoQ@eT&-CCMP3PTj#6ue`Dnx);3D1aJ3(! zcN@73_qLOK(Dd=fC83Utt>RKtA0zn`%wP1uw(QKaqJuqZSC!X8{9{Rg>IuJFn92;L z#?)WTno0Def%vK6rdLyd@RYEJoq>Cwyo(MK3!vAQMC z(2=XwXE@%#>Dcjad>Cj4C4L~=wu zjFeNub-fvTD_z08b**d**I)BHWLl`g8TWypMq-yEj$-~QswA#mk4~?a;|#~78x`6l zc@FcAc6qeDc?3D)9msxO`cAWmJ3&n|8?mYzI}c1ZGqzese*z2GC2WPvQ?2V;b6lQC zY^sv_v!=_Anxf^@G;wS8WCJV5eC!CzjAc4Si$BAht1bp+a;N-H{8C_%idc_F7YT+Q z$EtN;#EG#ib{j_1zIddGc}Cq4r;`q5d`8ScgI=B;boQ3-Hck_&X)`q_de1ruqD+6J zB3^rg`P>RKf5P^TWG5Y=G|q_ifrFlcQT{4<4&S_KHs&#S8yxjw9F0*CY7j)~gK{#r zzkIjh_rZ_2e%#NkPEd(i1A@!jsqFSFQ9}e`ABT+JARIvr4cl~OH!@|HYW+0pNSOPT zOqXqN@a5=wmPMyYe3p>;Isna91J0~OoGCx0>G0-Ke}hz_?i=i!%~+-zN-gCY#03>Q zq8^u6IGGLteIHKZI$5 zYrbJ&e7#`JS@yQjs7dyfQ%CVhB3o;z%MON;A^}oD4XR#&t4&m}W=h@(a-M5&ox!s* z8^Ui>f76OBpAS<%zxv-rp8#+W6~z)_~@ z=dae?Y8r-n5XHHXOG=1%jo)Pq1mT7+mS>qeaBP>L6-L zR}Cv(K#e3PBTmaT%W=TrJ*s^ovXAWv&a(d6u(0+Ve}7ds zI%_rl9RCXy%A5BU?c)xcrdAm_2THk^vP*z3Ab7o1OQI7ANOx(t=(9ngFWBT6T}h`*0H0N%+uUGqCz z89HcVG{AM`a0g}&+G3j`BowAbe}LIjU&(XyHS{{iTcISOT0D?ZLpC~-YtEn=6xR<- zI<{LS&q8fhV#7|HEsLnR9y#J{8i#obo}j~@7YW3D&^><+Jobm*23L|@$PYc28;+vMbSxG=C~01lnBo#QH12S?pb8T|eyRp!4<1gtbGMe8*#!rgEQrRjjOaFzzQ&GSeL+##Y#vaAv7Rtjcg({@DzX} zdRJj265Fskh3qT&1hKUye=(lv;(g-LT&2?4hcSw|rk(7l!Ms5lH7C6H;yKN!YVSQ@%|H1nJR;H zYJX)+W;HlZEjzuMe}7KZXm*cwC>OH#EfP5UES#1q2wfvFQFJ6e~!7B8*22pQ0?vHm!gU@ zcC*qJ%S`sVJf|=bvYWVhT z$A&nc#Uqh}5Z{BqV`7yISotaxqh}^C&r{@i{%ZDi<6Y+$#u9Q~*7R;Rpz2GURm>L5Vd%JRxfbsogpm#rIADy* z@RR=XKS|q}VQ|GMnLXO42+PGfErYYPQ}pxk?QHGUjpq7ogSq}NgHe@ALp^Fz<`Ss1 zP?9pqaWmZE5-^GqBi66snpf;B7poIW-$7S(+~cD~e{qB5nw+fb!q|c{Dqv(c1FL+V zbXz)OyR=TgvI@_VrfCr;YMd+Quy@gEmK}=-kG8<^9au|=EBE9o>5O+l%5&n?F%ni8 z_zep~9n7TInh$V$h7*-k4|Wo7Qt*nbM$CbnDs&^5AMY%Mt4?$YVmtSoJ~@10+r^?U zxWk-Jf3pZi1+bo+$2?2qIqn&rM?y1ny^amS5vD7+&9|p~cf~+Uov&4Rfw$Y|0Yi>y zYRW{OqvV}^mfJ$VJWUyh&Wh|4ilmBC7 z5@eE(NO!)z&Y%<(mm4> zal-rZv178zgnqb}4^TM}vl(z(7+ZyAZ80j^MJlpp*7e2usMia{FlrgBlaL89uDK>^ zf29=iSz#*Mf-A#-k5skEYvZM8n`B3rSPOWC>+5NfO`O#F_?7hb}mfi z?e42Gyl-T7#sXepx@mm|5c)pbV_2oh`Si1xl}wR)M!3VA8`J08MUIlU;n{x+D9XlP zb@t^>XS-#B9k-s#y3v4r+W^-P^v{9oe|ebF5jum#er>DKHU&{5*B_jP;|IqHscIff zuMmEt1Z2bSlTxgcY!jN>>o3;%(JwB(GbRJ#B4*nZLmK9`SS5@fvnRR+AwrBAq;n>f ziT7Oa4A$r2Je6n|vv%xOhVk(k@sVXhKQd_SZU)|-(r6&%Znt_A?zrOdsV98pe{dCR zr6;9x>z7SDVa&sO+UlA6I=HMBS*<@7@83ceQc~xkkPS7_D9yBi-TwW;-)Wo@kkgs}Anb=4kkwuNChO=Mer~@Em$@ zucc#-&2v=4nRGrWR%3FDx7S`bf8B)RwW9h9c~2^Xcbx)gMu)2Fqz$nI7t_VT+6x@z z+un@(VAB@k=y=pA^lhv#+HemV<1Apo>E-WnpTJe8x&)b^^RY~#uSGV=$u+<8F5@(H zw@kCqjXEc}>0_b~_fT`;EQfSc#0APevQz&qj%s0&XGz9k$m_pWdw2z2e?!p_^0wtQ zU2kxioNPJHYT*5+=-=QrXMNS&p65{yC$D%1OgC+rs&grnFGi_*}Ja!Q~<9u zGy~%ASnU+JUxFB-{uyUMsWf_uoU2C)O*YCh3C z7*~nO2ay0Xln+)OgX-TLHE^vjM&HD`B)UIP zs45|9@j&ScCS5&BPI1lmkMpS5*Ry6)5M{|_DK#`Pq=0K2uV;OgfAKnS+-cH~s;QQT zl&mlwaw?!XTbcL)DGR<}=$7Y_R^`o#!B%J1%}7A=Fl2r`dl%R-dNiaflh`rlJa&w( zYfZJ3T9jw$EcBR-Tt9UbuinfCoW543OCPKrHD?~m(m$_Soj z#~N5|QYgvy0<%FTf6AmaqkzqfAsGgR7x+6qOPxU+=cdL^R zq25d=FXGJJ%^VazCFjuRNT_D7TfbDE@Ne)Ch(=G5&)jF2e=X>HM3!;G%j>n1e{iD9 zNfsUqz8rI-8y451p;uVHX*kZk&c1FAXrDqyB+|z0<`bz0h&gzn;H0erJ(03yQYj55 zpJZ$$pF+e~l#__QNDw1hVUEuur*h7tZVdy7ulTIviu4}4dCODy{FAH7 zXX#qRGt_lpf6L#56t%x~r$ZL9DW4VAI_}o)lUG&!+VDi=lK;e}sF0u@=Gp9UBbRfZ zv6WS4v12i^A-2@@dRC!6Nc3KIJJabkkxwA^UqA)3@WyaQ_!KqB_Dgk8cZ2Q0G3Esv zT@}Ds8rh^OVaJv~hfau=o#@2NGNmi%T3Xx!f3BM*gw_TgBd?(!1wo$u8Tp$s zsp{3dGwNaFmCy`yY^6;^BByAP)Py@A8@(uMH7ONN7%!&GKDpgKA+nQPS^Ee%#wR%3 z(It%n#5S9M9@np(n%QSQVd!JWU_=bvV8^f@)Sr%Z{6AE?FU-IQ+feXG)5mlzc@Z+? zOMpVUe~gPvXX?*Ja}7`68nfnMU2pz`HHU&HvC7Xqk~>T?l=B=ni4L_SsS!BJw3DS_ zjvAo^a^RuL&l)bE!ybFRs+Tk{L$ddvq6@oHJV1FvH%fPuDmL%Zj-hKauQ;rruX|1K`+lR_Itk`^VbdyGS)^j~rO>O8kA~3-tR~|$ z*rm_6ieaJzlpJiFQCDb)Y$i-+&F}E-%X7Asuf0VmM;Y}W!V8%nVTGn1J&wL5docor ze><}Gm~%5~yzQaKOW*M)H0D(m02fvWzboD0f8X##=|c@uGpG1^N*lADVq4(Z+X=;V zl3as-O&%4<-J(qLs9>zEV(-TD0!B+}ntGUe6me*ujMW~MlXCn`JYSGy#2N+O5ZPqO z7Va=}QF)c_udn0pCCAsbht|&V*U+X zewy2@#`vBV)k*yN-SyX+B(_60TI?mZx>nZ(I15c^vw`c++09?g>@nxM1pgpgYIYw) zTZJJFwOk9^uqRpU&6-)A70SRaJbp;SCnZD5GW5HfQ`ABB13;%|a9%_W!54x@e+t{o zN3CAcCMW9~9q#q2;J0+Y<%WOU+L;Y$cV=m%CV~YT^Rd&Nf$)j&Yazx zD)&nLUe&`jzcU|I?ufoc-hfDb4!(N^=H}nHR?6L!YKjS||!*v%2 zTmnBj#LBC@Y~&Jr<2X53bUu2+-HUexc;^fvGe8u_iAGWiz-v&^1@dA+e{98JA@ReL z>C;ylBEEosU-`w{ul@VP`Anwyl@KfD>VK>3=2UVDymLFf*qO_87Mu)>*D4K9DCLZ& zvedX1j|hg_EWT)X!r}#F(N_HLYpR)R4o~y~Fh_g#1@G(P0mHw`tD?EV9fn_c4tZCV zW`>gegR&Jl3Q>a$Gc?h0f0H{U&gE3>nA+!+W^YAF)}35z}pKRDSAEQsk}GnsRq}>SyV9SUPoG*%uHGe{H*nE7SVldRI}t zhTAx*w3E5#VE$azP8Obou^cAdKn!u$DD$(Npt zzExOYby{X-C6w=`u3LJzR;(1xP{R1yKu_g|@U6z=h6||e!F1vZgsmbv)loyQhX~ih z)kg18NAndMs$drPf9kp*_P+rcec4`-kCQ0R|_CkhMrJCG}; zVZ{b-FVahI0#hC<6cYvWZ-K&kZRwtMzeWaLWAqPd?kcHnfBqR+R;n-`4ZoT-GkOnr z;z#6s$pM$uoZH;qG)_Itm|WFsttFcv8|T&TX1c=Xq6XIk#HJqQWqo_}!2dFo+n%?~ z0# z*PqTbIsO_`f8fpdzVGaRSFbO*uNocIR1|Sv6o{*K?7qlcT{BAcFe(XZ&yZYke?BqY=LDgPY01K|W4&~Rq_S!l zd&|;U9Dx7c;1Vj{jh)McXQD-Oso6lxs)wbmYiHWpf1;&xe{V#kb$+Zi5r6CRGgnM;JgMgA^ZQUi$|dL@0QS=XtV3jba1Gg#NY_$JgZaAAxYBPONo}qA zk{VPpe{=JtY}xa;reE0=TxsH!X~K~lNA@JoBiJ=#orJv4oCg`FJhGF&ith7Lij=~& za96@-^#&=0zl!`E5ehSuHk0a#oRB*D7CiHQ@41@au|3g~yrQv>sH4CUiA_#v5&%tf z7Chp)LAn8{{G-q9dp!Wa5UAwx_kK5c1~B5(f513(|HJukOq$oq;x9L=q`IkdAeYY{%S~_Kbx7NOjCA~ z4y?-4PR43Hri=4Bf9-z6+o}DPb>x-;)6a>bYO2T3G$h*Im?<2|*xK~5qb#~U`X)8p z0yD+C5c|il-oog{3f$PL^UDTBG&k^QWG6j{8pQeFo$IL)mR6x3_pHQErBv%ke?uBM z$#li5e6WKSV(b)05B&)>Ds%(!uG74V-hyyAg4iW(v4<>G6=oM{7YEgTUS z0Kc7vV;UU|S3e*}H}`$6e(S zq~dNQjA}DfgnQPR%`B!qjYIYUE5L)b9Y zby6xr%@ei-_k~b}khsVaOVs!{%u`}Ds)lp>9XGKHOf@_>t8yre&ZDZ~;j`)>em<@W zz#Yz(xhv6PeWCF|sF5>DqQe?csdhPA-_S%;;{+jJ~PsZK)%E<6W=GbD89$w=J;&kFp6{n?Z6JF#Vt zC-0DpWS{YFVH@`xf1tz-#MWqtDVUF;*Q3{*oF6Q<2GMbEo)s(YA-0Ix zG30`;hn#|O_!)UAvT5DDe0^mCyrnD8G;_;+*dTE;asQm+A*kiMwa+4;!b_l@6ppWbR#RFVQRxv_FeXRa27R^ zXflCeaGRCse|Sd6+{Qku5srF~YbL(PPIa2`D^#>I&CYRfex3NMB@=Yc$hY@lp2V&ATi+iw-lLjau!P zs)J1ln3+8?X6AlBBYajJ@i!Wc_P8+z9G-W8H9TY)Qie4z{`D9nsXjp+x^b7)qsbJvE%v& z1%=QJdbw>Fy|{P-X@v~_Ci%?JsN~TVMUPcPOX%hGr-cN+U2G;cdO7MNpwFG)?t3H{dza14ma(K7#{Md$64jGRUyb#e{`5QkANPUB{dL9O&{)b$F z4o>+w3V5sktmjlyRRE&}@h++^D*-#9wA5%8-mo+)S@?$6v#RBB&kURP}o;Zld-NVzb3|xYk@E zk*bQps2XV8ubo2H5fAZZ)R>m5=@^=o+#kZTdfHKwIUp`jvK52fqk}KQII(dzf3?MO zvOLQ_FMkT2(+sRGobIYDI!rwW5pEg&jM-8#*!UIsnwsXQ!M9?auL;zjU3V{YK%eOT zcl{gq8G1E;n@Q&v=G-m%8~H4xsB`+qi3d2~SlZ!wS0sQw(4;1Jhj-QHOI5RhC6BTd z;Lcmt%&eJ!H>UwAxJcK`u#Ign>Zu7HZy5NjVrH~PW32M17&-NZ9`qtFZ8o=f2X^Vh3sAXNbUnz z#kX+@dPft#^P2d=CYi}4Ec>YA1j*PqQyP|cR{u-#g@0V`&`mGs=lknO+vd^mZr_cm zC*`14_yz~r1d-K7_JleB>GYtRgS-kA`-wFj#6flc)+<3JK_PIJPu={7I!UJz*_3ZAS0g)z7+Xm!+T^Ab&7EOEmX9v zKmAYnw&wo)hFxRutTjXf`L&#sL+lSSYdBx_WM(YfwF#@Ef2Cw}=d_hq?14G&N3XhS zV8X5oh4tDo@~P}S)F@z*_DVB$tZP>4lXYF_K3}?nR*}D{U(*}hmEq^Y`>>|pHif@h zXkL3Ot}?Fs6WfBbFgR=NtyoT!*p|F{YNTY(InVWr2e41Axjp!-v(Jzg)0qf< z@5^1CYm$cHe~t)p{g~#PjTu5#*8DD}{8si)^2DZ}Iu)Zvi0IUfX6K?`SZv+ZrkzSI zAzC9RE1x14Ht%AdCTjI4z{E#02T(JUYYI(-@p*>+MEQ_BF`ijVcRbr577BjgcsTBD z@H5~_6^BR-JC_|JugcfEtPtZSsUJf9+K^k*kKG2$e-LFCGe!SlW1e-ct~c+DYkux@ z5i4_T!W+#gbX{noXH~_3p+ZA42g2vb1}Pclfsy-k?IW5+!1ulg%i77&?xG~GY)78jr-oQ^BT7RlF;3dl{zwrMu2Qq(i zv#?hm6rRsX4l@-#DVe9ty$zuZiLtuoK;m2 z>R`v#`OU8&heQ=?m!J=te!lrqB*3JbbFn_p*{4~=&(+7e=E^0b+j3hwIqyu?ze$ax z6F9ovILX>)%Zx6FX;qi#x=a%=GD@`P&%u|oWow_&oxRN&2I$;iCU_F=|2$o5oF+Z1d6*io01Hjg!2&$mX#N!T4a@8=Ak0{})OMp+a>I)q`t5 zT#KzB^iBBPs)O8q)6b=phGY2($u6aYf4;$pCegGa_%iT1KqCJ4)n5U()VStVHN|nM?>=duN zwb4L&NH0A1+az818TrD*Lq19{Pk?OI+O$hbC4a;HbwB|-o7<^zxNn2HzLuE*e{@1T zk5PcG#Z}OfA>x7j*~Ws3OxH=&L~-_U7yWm`9TH@D(;{7$m4}?Pm|nrIZp@^YJCoV7 zxFe(K0N@n!C)j)mYiP0ZA$*oQK?Ta|;mr63CX4g2o0e-45`J*q!?ls+x!*e8v#LfHizYaG1G0z?;{%bE@* zT{(iBhbZOM^=2%yO}84YfG0A0LTcd0JL9!a>@(Q&US1Se#E^e_IqE^f4CjJfuC|@#(b1b8Y9`5lN{L;>L{-TW~S#_xE6>`)y?g|MUu!%)Chhz z=5Ab*5vMaR!_Oc>QzIIVf3wG6p8Qmwd#71WI?X zbFgZc*eEalPD=HU%Wj8nwUJF_Pa;M|HUxa@sL-f9k!Pi*DU&h|e`mLst|&d|HK7VG z+oBIT!iYb3s_ex>nayvIj}6Zx~!JU0;QA8OxiTeB-5r$k~Wt%ZIjTJ zkY1rp({>8mv<2k$HuAEdh(HxB=mIMh7o=QPE{X-p#TR7-mb%DWK>z1VKtX+fpZ}+y zLYrnL&pelNzUO()`F?Y^CqWO&On)14&i}{Q+rULtXaD19X{ak~ZL3CG#5EVS{^#7$Qn&rR{x4n%4EN#lc+UHr&pGcyG~7>QRz{qHWw&sS5BW=f zYLM9T|Izg|a7|oU-_%y?N7ZfDs-?Bmw`)Nv+gl%>irPmjTB`;onM_ECGf5yYnLs9i z03iej2>~>OAVHTv&`PyFU2UyZ>6hBB`n2@J57f3=SBn)X`&wH+Dy{VaY2R}u?N zs0&>XJifw=+?M{Vxblt7YgrSKBgV;$_Ya{mgke6k;V*@`h0nDZIhi8?uCiHw`9hwd z>XQ2rtg;7uf;kh%9lOXExFbL>%ie@)aDXX#$SZjHNB)a<*djYaht%dp)SvA-_GzgvTBVN z`O6zRd^^cEWIwLjp{{&?#R7S(O-&fM>ISe|cJn8Iz>kXt>VTm`Jgj+6>~9?rzGm&G zM%gL_4{yTyHD`bI7m7&MgDpP?&$FhM+}yEQC1^2RjqcOVd& zR69S19Qn}epNh}qjZfAS`7h1z4AFThdqE)1jZ8cpZHto`Ik!Q7G z8qDG@bBc8gVwuXj@?@c|ro-*?(5~5r7u5hF?FvW;D?I4eI38!(EB+>S=wGtr8eq;g z9XCE_c|(21*9Z822EJocmwXjvWsPF#vJ|Qp@M{`LV+YXFAXcZQ0>(@hBYdCs&wO9_ zg0C-ZRQICwH(xeiCTqo6>&`HmiX!7Pn)}>;6K83Q!uw4>DPPbK_Z6FhWfL%=`H=1RAqL?ux77rT-8PE!cZ)iO5YC~S9sf) zoD6Bzys_yp%tE>TubKA|O(bkeu?;U@qD-SuEj|e6Q2#SKMRtp4rja+T@g3w`LzXr6 zealqqLet$11<0`${tICwhP4&9XL5$9f0xT?_)ltdm%QH(H9#nQN{-u~M#Vv}7i*+e zuOO8q$I!x@RE?xYD+{F@(OTu*Y>p+juETh)tjzyRIIZy=IwH<$C}muuh;8cCS}#3~|Tct02HbOn(qcV~^K)1VEDa77oQ!voT{ zZdL63=XyV@;CI8bP6eNWPbQQLhG@n@23`&77Z%;PYSztaQZ4=|Uy;SVM%Bm)CDtDoO3@mQu3Tj86M z;{9TYfh|X$3^SGmB(Dj+4fkJDn9Ke|-sP7H;twzaAK;ff;twAX*|y*Y#P6ZE)n~|V zuure+muun=B!4vj5Io~_ZM?zgAinR~jktz|E0M)_mR-jPfU`qczj-z^QgM;(F2VcV74f)EK}{qxA!1u{@S9C|~9pEV*H9rbTMAepr1Wa}v;y zBl`|ggS$EsPicSz(?1%|1paHsiHv-+y<|8iW2N!kFhMw>EUxyxdkf zW4NF7E8Y;_AsXsc@(-}cxCeapV7~(1KV&>Z*w&xi z$C)na&fX)vx^dF}+Yx=BY_0HJ=n=0z5SMY#dzSR)9->YKM(VoJ4q{%agCN@$I{-1{ zc+6pBG=KaKZM=RMbCpyZjBP(QewNNyr{R7E?lEKC4cktqkxk%{DyuFEqj0sN_G^O| z^CBDfx)fA0R-G%81cRhHvSB@CQfg}Ra?i&>OkP&(`XtG*F_UqJ;i0$jn^imkil z+`m8Tt>;wzF0<=jo|6P&PDxof#s84%HUgM`BZtV6YR3BE@L<(VoNLZF2Z`qGmXxjC zu79tt^AKh9H8sY4I>gv2{Tf72??I`l0ehI*PDHCW7- zO)1($W)YR7Pv=)z-|=h6D>#bVPUTJ476Gb&)7u+_k^FAQT)9U*)H>O-)s!Na6#u-#!`b0LNe%5leL(d9u_3>PBhPQfoOOYA z##Mh2Qppb@!z;|VM(Y@URg=;^!GB^B64=ey=f27M7Py~C`V#U6W(P{@Uay7EYnO7P zo4pkH2QiGlaa}ReiED_sLWPyx^(NW^qvLqp%lJwD4EO0sL>o^eZqc?=%61oTov$sn znlgs@zN>pV|8enzJXS*BV_frX-TD?vR^rZ+Vb(KeUwzOqGxSK~UQ(cbPk*qxtlD_> z8GeU2tNh-Izrm9q;I3;&Nm&_zm6nnkeh$`jTh90jOVk*h1~2+v^OaCB2BRj9t~JjI zzMvf?@5Wkbs?so9oE6wt_@?m>RFdCJ%_BvC6Ba}4+W;0Xs3EOMQthvY1Pc?rL1C<% zk>1mqJE$>o26|?3i%}eJOn+|b!Z_3TY3OavUOa+YZ|x7wWOdXQewFiK{XO(DUk5eH z`8D;dYd^mry++eTi^wJDx`P(m=SeH;HfDIJD>xgUl{Owd9C|m-Zb|~L==Bd7&QVFW zCm4-@EIrG~vFAnpYwbi`pZlm|E_FBYpzp%bF3^Eb)Mu<5&Q2<+eScoYTIk!YxR+d( zhH;YdTjU06J0*BUp+1&6go&ihn_V)?eQ>UyknlBExW|mH7(JHW!`@Dm{3>lQeVljWWkfWtzdr zDwsnih(BP49Ya>vCS|CL+e-3q9~_R@s=1GP*nFA0Ue$=}QPdt7D<6{+s!>=WM^N{y zN*l&_PS?lu>YHm0AseG1j#W5jBGXCh_dPOCcQ?0e_ly974uBpWM zhsHz)0hG|5`GRi_Rws*_l+&P%X&A-eo!}311KJAr*Q6xJxNVvgL^F=LRufj@RS(1U z%d!d7D3{9U4zD3SKH~Tga2(cT_SSp7{}bkDf}v5VoUD7%+dMfdeW|Z2l=*Q z@RuvEAxjLiNe-@&sEQnaTepJT#I?QOW1)2`+^0=t_?+`MBexURL9%?`F;}B}ZqeN^ ze43d5fH}*^m#gUyGXnbSm*D9S8h?K((|j*c%{Y%5av)mmcBf*#O2#loqmB2}wr+uY z&cQWaIQx9=ocS(hkv`ddyhUl6X4qK$6ksgdhP}RCU3bRXwjbf_vWysRE7QweC)>F3 z1V%y@j73!WMZao%j%g=#zwGezGVRnvQ%c(@(&a0}`+0tVv$xN~wH8CJVt=gRbI$Jm z)|4+KI2v{1YL+R+MiQEx*~jFu?%|HP+IR<1Ukg2A<+yFpXUJ&W4@i}x9%>ACF5E~y z!mK;AB?cqWWxq$(L=tqpx?c2^+|?>q=>@zdvTaGbzt=f?&SP9h^Cq~mv2h4&86LXJS0v#+GgaQ{F19<_k*XAO=5 zY%@lY=tW5e#JybTLav*nXT_~Pm>I9FDOYE|9M#(^OKYdgis09|#E9_tuIB!A84PzbKS#rMQ4EYAD5CchYwG-qF zL|$)`*PyRDLKnnI`T#RgafG}MPhzw3gmP8!ot!?WI@e0hv28g=LU(xbxO1&v=31$# z$`j3-TEEPxCYKxuj(-Hwzhd&g%KEzP^{x2epIK>G(e&FVzCz*on*XX^Ch4+e3G2bn zt@Nj&+9@}mXlrYtYK1AOyRlFx3Y_P8b9bxwx%le`k@sTeHWMu9gaUvhTUHRu&X(StBc&y{>{9pj8E zn?Nt36Ok*&rDt1mjs#y1&d$*A3owJM;fl1ca~1qqreahmmYD~UOR48G?-2Ngq{clk zGcT0y7f;wKvwxOGI-UK(6vtd)6nbME_n1?`jc50H)xp=vS$;?Oed9AtUC3)fjX}O} z%w%@yAs*JH*F1mCLBPk{<5?|G!P)X|+jQ_DV{G}h>E!cBC!jo<(Ui-@t1d-ko2i65 zXDXxa)O~Nw_2oyA19-_^_vw;KiBsyjOHrI@*r>k;D}UYH|KXVH?8}?#>u~AOC)ass zOZ9ikH2na#)m+PMv^=8glV8@vF`Cv9+C&>*5t8j7c+XWAQN`9lLO)W;0&Pr=UI%TW zYAn-^d&kU*5Th@$O{cublixT5_I453(sn9xtfUOQc~9tv{GFz8ntJyHh%dW{0~vgR z8zRGP(|;Ab?_upyW+Fs}@C?!WVeTFNg?8i2F#2pGCD~<2nlJ9-_O18ZL z`HpP)xL+oQB^K~F+%sbLMSd2qQqN|@MA4A&B>s%yY}M_TULqXjCG7^e$6tpdf0}H;rx!KE<7VON}$7~)K{0W?hhj)@s%oO zQr>ju9i|)Hyt4ld>|+NEE!Ks$6k`4^GQ;D2;Lf=GGUl*zNUY9~X=H=a~P_Xfj`D9id#uOtKBn`8IqJ*_mplE2q(mJX<5%*zI+mjF@n#@j1*) zllPFft^Lfzf2QN^qig!56(2h?_<%QVi(VV`4v-(!_Z@p!oJ~GQ&5F8?Xw*T=6vfOW z%wr0dUz7eG9a79JOA4Ik-i12hTShX7^D+-*K`}8?PbZK|_aOGN72waHq@a zjAPr$%HVQ)7c(!E?AM4LR4c#3Kcu>5DkI0Tc3HBUe~z>_fW?j_CmN3<(_SFSJwewU zo=LxjUMdu;8mo=JC5LnUh8E?AOo6gnKM;}f>ugT|_82W-uAj%(2iQH{u#w;4KB~Hw zUW3^nB*Q_-mw+|{)`jFX?7O0KS~FbT2J?S9uB*ZL(fxV_xYjTEk<3C|`}l<=Y8uvhS zIhwAua;!!*wxu5xa0nCnQQxeI6K9$7*R9AsMU7!5WwfwAiSwzc)`iI5gggAqAqC$$ zBBTn%wm0Ypba$hYEEQw?LnxNWm_=d-&RDGXf5M$kj1q7}S+Z@@Gr%5H6oLIC&N#Bk zn}w?qWQk+$8ZY?g^_cZQcD9}JtadBNO4A~eV!o@5m-l2*RM54b7^snkbG)2iMcs{7 zoZ4>6cTaF$3cF1=wGq|?mZY9|g-Sq2lN@uEABubZC)A^8Sz#{D1@}>#TFgX#Fz`D? ze+4tZ`X-RYkw32QvpPvoe<#KjbS=}16|vA$8mu@0pZ+7MgVyH3-)}qntA@E3(*xp# zsVMLrd~Hz$Bj~@IBvAI}wk;6- z{uH{<`XyY&=txi<0N?yO6}nr!s&zi(_H!*v1%kB+QrHf z%tF#_nTnNC@>qRwVQ%XPDk(78@nq)jHG6J*70r;+zm+kItY|ysI!-JVgUIv$?`l4#ne=2%7=m)H{6qHzdZqosTjqWfT{J%s*B2}$j8bls>i@)oZ#oXch&W(&$_B;k#5i=D7*O`f9y}hQuvx- zYj~#R2sI}AsObhj58~!7`+MYbI?+0Y^1D+YMvaqSMs1v;Re`62XG<=V9@T-U(l-3w zNZz250Pot;mylO2Q;|hk*-g?y6wzkJs}4}}8fxKQ>&Qodg3qcBMDLgHGZ>3j;ho_( z;HZh=1)2e=J}fnFs;96ee@6MbzRI#s@h57mpJh$W&OAeAXZ8bBOz2V7f%3=r3x16} z);gcm!5tbf%UC=i-m4fzY-NWq_YNaz(SX(=y2c>TjeFZ43B{%_p<)n6Nip>lQwqIJ z`;a(^&DJ3MST^ojuUjE*LgpMo=WoVb0PY;~75O%N9UM7o~uO#+D4Me+v$hNwA(qW#1E97AH zZF(1Vl(UPIyoWU;Isy&vMLElnTRH^e*RWBD!`#`rmxVZzj`fEUKX5g~8Gw?@${@3f&Qt)ZC)L#G?9&ZSBFkRq-P(3B_&lzNHNNA!hy58MA)R#) z>+X>ipfHg+X)(fe3PVg`Zq0u+enx7zxo(AV-v4*iJhDWX0k+H>hyk>}qtGSk6xhUt z$VN$v=F7L&yp((oh#c&c`+=Mz=+`0EH;{n-rS^I4^OWt?f6Mabgs+8>&1$nv?MOhT zOoOZ0i3-A)Lq_W4vEghfGxasa170Uj%AM-?5YWNQ z&~nPJTxaYtf6sv#g}Yq0Sk17J=82g(dCPmKxMuO?OZ?oZ{@$)Y4fhM6xC(l0W$#p3a|fNG`gGYr^WOZPRf_LmkT#{$-J(vC8#>ae#gvm1) zA0xZDyTrnxU70VHe9s&**FulRa3eCle={q}=UB3}(~;E{;|qRObsbigBJ&0F5u#ON zvi!0zrsR9Jky+tVteHj50s=1NMmU}n!*y+@GKiFycvk1nz#3nOu-`%a%3SqLCYfX> zM7jOsI9PcZC$Y;!Yd}aozrd7)>fy~!U7uH7{ZREV^Ie!r$FCB{D|j(tDl?4>f5j@V ziOI?r>K|ZrF5W$vev^P$v>TNqE zBr;dUP0UBs=#uY6L&mJ~_cK-~f43S;{3-`Am=w$OrB+jLHpb=1kl*q%qk%KDRG-2f z1F&!x8m<6l7;l(gw8{u0RJl&M4iGFLE2&QLw!I_eG_nP8lqt@ocigt(!u)6mBI_Jt zDRwhv*zg7FUey8dgr!*iJfQB~RFX8ZZMKodXG}K&a|4s3{$3udO!f}9e~rwHcO;N4 z%oV^4i%B=Jp?>-8RyKSMu4MWr;>%Jkr^Yh>W9ZCy^4B@Zoip8y*pE)+&f&Uda0Axx z>tCXm!c2UYUTJVakKOA&T6PGdM6BX*#+k-3*P_vP@O9Lv@@{N8o}Yu+&(t>KAKFey zY#EbGGG3nP(8f0%Hzip)f8~gb7>I)^4I8O3{0?WFKvU~|--%)O1k*H9NGkE%+NGp2 z>p_TSuh@nwc-@dTkBF%{*Q&;b z2UQi`O~_PHu-b73Y}@b_qtUyz2Vxu>IZm%!{Uy1`TtThjqE*a6N1QSZX6CmLfsG`e zW_H?bcxRjp?`riCyf5cH(K}O~*AToTh&JG!%J<`4iT8#cIK}&7CaUh@p5g3xU;ZU% zh2hRL`XX+Ab3JQnJif;3($i*byz|nU#dwb@GxW^NIuD>0n^38IU6(xk4;%?mlN#m& z^p^Hhmtp)58X;Ku9Y$}iwRL##L;sMvcTH=ktaJiqt2#Q#@<_z@UD?Z*ocs?Pe_<3@ zvWK~j(peBclkiG`4&2~2`oO+%^Nq=XBMlhaW7f7nd;eQ~#&9m&sT^Uthna-CN6tP& z2eZO4m+vc^sqDs8CUKTwGGI#uwFu_*0%|fcjJD6is@GqC(~0n@fmLKWIGOfw$82g3 zHJaTnZVJDT`Dy%W#57dUF`HGWe?Ddv#>YaBGAi+7+DaWFo0Z-AFLh_NiP}UeCVdH@ ztS`yip-0Kh^d*4k_K|)nnVbk7XBB}B%r#57`+-1^>uB9#PRxq)nVQ!|5?WP?V(fFr zqZlDkdoYK&A}zX-qdXtYr3Pf~jE?J)uV{z+0!9VMo1q_Odc=H)bbuvVf1nseC4tTR z*t!tL9*6$LPL2EXeW}*yf!@OON1zYN7jSnBzVf* zfKE=5O|$})MywCG6ozxw<3t|mYzT1URR^5UsQY1FysNs4HWQm}94$(#q2s7AAqJ~_ z$T4=H-sDRJo7huzG4unne+6O8V#$uO?2yg!9;Qt<&U_hv%$HG1s3D*}3+Pv_{P=c` zk>9WJ2fhk?MFO^N&uaY?&3(9E3sES8nhn-m%qBtvS-3Q?3ptO;-%U5jtLB~JEZcBq zxI+u~1reJ60I_9dTm7LQz$Xm@9K4&PXT~f4gqRr6!^;@g5uGrWUR)sC$g6=QvNz`l z^xk>OFX@Lb_pGk#Wv=8tBZ^JS_p=Bbhz#h;g8{|^)iqPoANCQlZajF)}?4<>(+Uqx*B6Ue7)XQCcG zd6ncsk9`S<$Smb|dZawUZ=helmNQZ=cmU^BT_e_UY9~@jFdKKH8UwP&1SXf2new$i zi+i=xRb#Qzm|vwGB_wJe$~|Q%4%iEyOaCjM9j+}YYuy5I{nd5PHgz!ta(QMaShF-d zGh9Ox*g$Y+1gw84>b3_aV?3j80S~i@Y$;!bERATp$XirB*$uJrhiJV3L!JhY-9s+6 zB1S(Tafki`qW&G^sQeCn@#=%Ok4@wyuDHS3QO~8$W1f>I3ojr_QUK9zTBH+ZAhgEH zSvgG?SsNLye9@oEeARFzlHi(e*%z41oD7^~euR-~gC~D~Dbfir&IWT&<%naHbggn4 z@{=_?1G`ugzKgE|CWr`C!sAqua*B4M@+q(eYo)lW8W7nylIrXu7Od;P9qVA7rZ&FW ziL1jdE1dmmXo#-GweaZb3pp=L!OziRpw(>1K^_@yy!*KEu|k)3xT;4UtBqIp)6(jN zcep#17%YFOfnBB)^v}&}{TfBFGMO*naxgwcR-M)@!dU%(sqQtn$SW;1{1dpQQgu;v zPbjwJGJ82Bqvi!}IO5d3z7oFBTtAE#>%^M4uCZ}5(r{uv87A-lyVx}>pa>V z{(xUVb{n6OIO;}_F0g7fkxqFm=@;UdE!5b6!Zm*%dMXfjIuKO#lrIaOwaz2oQuW{~ z&ydeUL(C-dnszBOkD1F{qX+z{{-c`vn%8P4DvF5;BTA`8WtuWg1(vjNgCoK8QmE9O zq9;W^S@M}1{JYqCDv8MeE0Edj1p9@#wcnB}=A|K7W}-W_t{&H$4DV6(*;~kNM;vX= z-b8-{82g`#CjyBu4>uL>;I+I{Wp>ZOJ-g;jZc|_zqYR`s*O4=t0r|awB=cSJ?iM38 z*7yfvLp&KaYVMQAMiMFpG5SJgpkE`dqE(jStnqkTqJNSRyC6}=+rfZ&0!s`LSKIR=FpBKJaIw25r zq~cXtjPlq#L-;r#u#=?|!XG#iAXeKPJgd8mv2=?u_o0AEb+2naJbe{kK-X$NBYbmx zbDedbJJkqdUN=4KL)Uz!NOeGdnVRhE&zxeq5hIrrr)!kYVQrXabEro{1UhtqnN)vN zk0Xw%Z`|Q(lsI5aQJpGW%~uwNV!=Xn|6A@HNv$BP;Gb|GB_>p{#wtIyRz8J0XX_@f zi3Y4CT(g)xoLk|V@7c@_M8b`GrA&zNLISRUarSjjW8MIrMpinA_%R@fF-={VYaxCt zWsLkf+i&GAiF&0h_zYDOoYo(3T^xVT1`!Qd5SwSUIGeLu_QCmPk&m_0#WI(*=`eaQ zcEFPD>`(;}_W&A=F?}H98iHNm;!Nvo^pR>{R#W zeJXCk2)L;W?SH{husHSNCg0AmQP-`xk4m-{SAR`iUUh9%iKMUE6?SJj*a3g@W#$Uj zlZ6=1CoVmE*tZj&s3#C4TRf}DC+OoLK0X9q@pH0-ba3~Qee3}JLf#xxisKBG)O6HQ zpn^zV`IH*#h?1z4#1`DEd@8Vuk6=qN|DU87)1~!yne!RG&ov+LUB32^#MXO>EPn5(9taIJCWbHQ-*EQJ(~u(_ELyJBWU#kx;ddj~H&suKSu=l2yjTBf(c{%u zd~u{4E9yAA_927OoU;0GLwD)0@Oq*Nf8&0Hnn?C5*P*ZCwrPv}spMI`vK_+q$J^Bh=I1F_?tB=6Kb=OFYV@niik zNskO-D(`S)b7y}BERk7Mw=P9eraz1O-@Zbo0LMD<1$RJCpD%wL;ZJouX}Tx6q8pfO zZ)c7ajtF)6@~I^6Dt&74ogSMuF{?zFp`3<$`*dw^Kb&nX#P7Sc6MYfpkp5LN+;6UX zS^1&X7kZI=3bX%5?~u)#1AYNlE}NafgY1Cv@9Y3`4LLLfwYZn6FRI7NM(CC4VWSY| z59i6a@urk~PG5fv82k=-w_Kq-k1>sYJ?auG@2!6jceeyu+)KYH?j>Dd#d{nOIXehu z+ljMD6?neu4x$<>r!`oyRizrmDq8i_AXu33j=A3dhDce4dxf06>}43KKdFLl2ks3j z{v=P!8t*G?RasK`0*IEF@|_U(t|C79MuQO}r9h1KXH$O)c#?_kM=~_Z69Ie1EPuV} z5%8g#9<0e)V2Km!M{2$(TS!ozr*nN7Gw2)Q{i6WGjUSum)>3V&OBLE zi;X)+jkY?o*KybBW$ALPY4GiIoeCSv_v>FOxvWWP9jWQk->EvV29@(RQ}wRnaKM^|uf zQN8#vs{5*XT=Sbxsm5~Sm48?M9Xyu|TKXRRhLMYZSMswCntW@23h&kQGudp}BmW<} zwxPh!_*2v0RQI~?vQJgs8=k3e5k`6PGOmTo8VZ!_$dQ`M5S89RjV>NhRzmtAa(_h| zaU>{CQ+J0yfapDg-Q-UN|0o*&;L=;?W4^jD3OTjNK4t~qSMO8>6?}MQ#xQ;rH^TE7 z71N@B)|W?Dnc7okewmo!X976PhmV<0^Cb{Ya;Kai+tw+PqeN zS*{RgdDRwE;|_?}zjp0s+pYc2|F72Vc$5UdZZE1-0cwq*f)JmNhPVgg{?Ver@JDzZ zbSbEqP;6B{C1V@8@s_F7D701Hv*eh#m$_1ZRzeRr`;mv08bd7L5q^h|0d;7I9P60D z$I|c=Oq%6vJ0P)JjsoBO8eTxy*g_$kH)^tR5ue5*mTkhFfl1KAKnG|WHv<^WF z7kg|()-FJNo!a=0voG6B_{MeIF!U6E&{C|^FlS}MJ(Opj_WnmE`py<#rblPvv3OXpwi^TQDkDKpD@)84H|4%L6Ys+4vEe|!DgUv8DhYE;>YKU`*rP-Nx+d6qU7CxaBTj6FR0PTBg98=f1J6ZHUsvzHNO}` zbhzp>%kRR~YS)_2pu?k;)?JHP$iK}S%&$BxE6V2`=yP1hZhI)Z8 z*3!&Vy~CAHVdN*T7hWJ+$g&WQO9O_c{ zR}XW{HO~P&j(SX2Xr9{`WvRicB&Izh<`<2o`HE5HGE{@&cSLiSLb14R?&zdNVG5O` zxe2|2+@n=gGuBs08pjE!%#5)NYCwU9n5Q1X+y(LmwauDKE;;6c1dIZeKQvhC^AxvqXhniDlF<@ko zt}RT(l}t$sfJU}#W^U96IL}jt5VD@!gt0uJ?v?Z?z7&&xnHBm{h!0~WwW?}TjUydq zL>lTpH*_>9$*Ny#ps8N%H}Dh`nCt!p3%^&fikAM8%Vmea5?L$Y-KtAqso-e9op3bF zE*VLM2JrmDt8g!-lEEjg zC0OBTAcc;9&#=N6u2@AfSw&Vl;EMBLdycSeFuw)iXZYT$4LvZc^GKSprELZDHQLZD zJ7s^Gx$+A$>=N*^-%5E|6=2iWN;WM3PjdxUfYV$SR;qSSa zf2*F(mb~My+^U<&5%T_R7X3x?Eu3{1T=RFTIg&m+MIPa~AWq;2dwMif;MVW_~x3WyOJ2pu|bOw;@)7<8gO@WHmbp){E!K)2LpW z*NnG4*iefrTJ%!B0FTOOVXgv#PHEiZjx{`q_44Ej*+F{X8r!UX{wNuQr|}Be(YD1~ zN4m*>t1#}4fgeAqO;r4eFVHLp9QaJm5s2AQKV~;rHq5t2{TZx~hB+(goNa^Wi&{Eo z$smlnYwON#c96Z2mdq>Au9rAHwgWtW`~lY~Xu&49=4Wu!*AkXK39sHD??I$> zO!~$_@^@&}InpC35FH|)LVxWA8{7@Yy(;M_ZGvMyCND{Oa<4(V-=k2Q33X;(g>&|k zj+j3?FFEq0<2$h80j{+P?glk#2FZ3f>ucn7Nkiu%eEK1r3srm$!4ZR!rqIXmei!_I zeUTi7^9{n4kTvBJTy+qR>L+a_eok#R1g*QuH!5>7 z;|W_;R9)=b{82+%)6_%3jhHJ} zHV!?v5Z83n*khgNPlX64E~7T=qU^b)V;pv1o%EG3*#DpX&|ZD zsjm`dz}S;oWy#Jt;&oy+s3W0t0`8_WR}g37-6_}Q8ORRhZs?=kr~!#PBn1VbN6B$= z5_4*ZnQ5Nm9amm&q6e2`3*Zow*8Jp zL55mq&>O$a^IJYa)uKy;@xNk$UT!*}e!r74rBYBN&dUz)C5(uLxKeh|-jJy!pGMB=r!mHz2%`I4y z%>euRTWdY=*{!RMTA~wsNp0pXur+zs2zZ`^>ZcrYU59Mb9i4F2&EzRQGy zrrq(RDarSp?ruwG$@fZ!`7XB6_prV+xZFA>>{bP>xvY*kWc&lxB+CzC?4#>e1^KW2 zCjcvX^rhN(>lmvk%DsnwC69j>~7Ci_6+%4 zTNLRGOlGdqGR&3C&tb0SB|7_bck`{q!I?#Ar$@;!qvzTmuE}alw8D5Dw<7+CZ zWO@;L?cXxaf6X_?-1qPxe+kg)r+_y;R|Nq{9V4&dZchk#0ZtP53>7z8W>OFPc9!o~ zLEIWPikm`R-2Apv+Q)G}8AmZ{85nyi|IAEO{7E}8ssKRO!i;n_qLsK#$lUaE+yIW5xdpZOEorjvRTvR?2{L%M%kw8 z&epx`?C@-DecBX9jgEB6)0qE(ce|Uth-$fW`XcZB_^nWv=00Q$40W+@hK3{ss5+qq z`Q~u_ouu%8t1=x~5Ap*{FLK~&l6XbAHZ7>2ai+iokNW}9QX2;MKXfYR|H>6*UxZZRz4C5tyt>!f$J`(}s%wo?47)>&cDy`U>EQb`&yhm5kv(IW zY|Uj>I3EtYV95@5@(Ymj3L?L|i}f}y@c{Cx(hQgvwWyUJ`cH)4rxU|&&sO5ke5hy_ z;N`o2>L2jl&$d+$E3S9xEB~)NXPds^6X@d^OCx31g$0NKg(hI+(Jf`S?&E`<0e zo8&R=Qe{-KkjU9hi!xs#*E1c$1oxzjxn@q@*#o*h^_kEQ)F^S5t{c~3X%VfSDak)X zTlgKgRxH@DZXdblH6-*SMxJ#Z@&+<$ixHfua=PrCxYss3V|Zpe(HM?U6SWabC-fn- z$F*Ny#5P*8gXbBIAvOFywu}~y{iYk36UMfcO#nQ6%vH;s!<{el7T2NG2Qy!PNMGVU zj>@rM_xr_J;BBs%rukWH7ptRU+(uSIr$O}P5oSoSaKB5>$rQ!LPjOYynv2zTY$LUu zigEG2k??te^A38Eaw~PHaRQZ0J**n#AebEw<0MI#;nL?@1-nqmZDqHMnbhbyPg7UJ z6}nbPkaugkkV~B|1)RGDGm*7_)Aesq$q-X+LMxHA3-g7vMf?-E_WWyw5mrvS8bcN2 zHT^KWC--9S@TM==#w^M|RCJC#qZx2Ksf78=K95>)`T^*n z)O5U%<*rkQFe6QWsPw!mek`=WT&lC2p=%rWlw4-ob>p~sttw@{b+GJ;RNK2$*G={} z9d_Q6>8O9em+1K{KgT3fT?>sjm6d!?3c=o0Q8CJHLJJ2QcYya;L2r|HR}_Kg>~nMi z^7%yCmB#Ggx#BGO9r7Y^Qd5_~$X%xgu)3FNXSdU7#hDv_KA}rB_nE4SM<81YcfI-x zfp-v6XPGL@*zif?9$b0hu50dN+BM6Yz4}taMtu$D?v-2)&Q?h}hd76rN$$mMr_ev3 zik!qW(B8PGP>AyHa`y0o;OmlBzyeD)qw#C>1McAx25SZzyPOI-XtOSg#xQH1wrX)L z?S!tc#EndU)8x~PS;{ok$n|~v4sEQ(sF&*L9CLMN8+YN|YKU`8Xl5vu-`#d9(#c)V znAP}BF`IrDYEU8~_vg_{S zx;|v8;D$BiXh`i>-aA4UP-~;@6xR`A*4*T_`Aq(QA^jBazWc(1@*ZxO-i5oL)@jCM zyjKk&JIZHNf6?r8be7H3bOrYtjJ%T?h1x_-UHWGogx}G2O0eUOO6^yMU|>VE4qF?a zTLF>S5whPw+$qc?n6;7cAeYW)LO~>RJ$$M0?{BrPYHbju5u)TrW z3?5PgUp%Up{2UN083TK|$M{(5O3@0 zjdIM@4}=F<1$cwzhAT~fU3p`4eX5}5#hNG0wAc|&gs6FibsC_ZSxNGRJNtZLZnM|fuP+M4ny$I#hc6bLtGcKgC(O|PAD6zp!L{EyQ#DfmxT(w# z49<3+_78muMWa|Yx)AuqZ$=rl+)QpQpFt7jYEzA;{tgJ zR(6Fh;99kR^&RsZAwl9juu;$Ecf2tC?14%v+${_52LLa{n+YRrm3UQ2OPSs5v3K7v+UW%qIRbt{nh zi+k3+k6&PWf<0`MVJij1E!SDk&R-Q09I>%sa5 z=w)l{nGcB&BcWy+px91`=}SXA)ylG@aejJb4o7jt0j$TJ2J^3^M-XACu;?-3NtRbsmp58+=uKAq5;qjYT78w zmnoQuOs~~xlp!yygM{50;&{?QRxET7Aq#qJefyN~Ui4r|uVZfTHR@GgK6BN7KLmF`%yaPmq3@>Q^Tlj6v^FFVd>-=xxQ^9B z$nr#uV&=APVc*0`4&nWZL26G)4VNB14v6qTU|-;dXn^@(Tf4o)9g1}yCvOW=a&pVc zg0sV=LY8`n-_0z{e@~m3^JxmI6ZIxM(>ZErfle+_eC zr?gfvg}T=4MC~Hqcl-jjh4t$n7q5D@Dn^N!A(%BPvu+&t?k-0hCv(PW?-ynij{q!w zxa`l)ez{yQ@O`dEVFq)gW|^hP*=KvAuAVaB>LE8Dxjsw2qDDb{Tr5c1e+rTkM;v#Z z|D0SR8kp^O;@!v0B6-4$K!JfFU8+$K0jD9874A!cujm!joE?8qd6W67W?3s(g0d9- zdJ@pX%n`%vX0#`?71s*HO>L*hP1RWB4rK@0PFbDh_uAA&_3~Kcx+vJK`O@lC6x#!u z@us-I4PsLdftTAt_PI~Te}Mgn`Olb{F;B+)N6f64WK9=&k^Dcxz6LI;I_n=T^DVXZ zY1O5tSfAEFlkIGen=h0ZnyUhLxN`@F@!q)ugLh_NUSNQkalqka02zh>28{vKBwe5W znp!5Ap|#o;Yx#mwk)~oI(W90xMUVMM-Tvp?(M{X-|9t!u19RujfBn6k-}n5^Ip6O_ z+LIh0rYK(~zE{{27@X7j$#2w41vIXfKxa+50T%-j~Gu{J-Z{D<_BB737Q= zo)g-h@~4~hXpKfTt}PgnhXdR%4G#0Ojg}rcs_$s|`2v?i*xXN%2 zc}|osqD)WSF~o--f51}id7NMG(A}vHhbINbcCx_OpXZHI=24s_eGYKlubiS9iB}b) z{X|b!5t-#sM9TcPcK005eC^nEA5cy&R5OiuRa5RX%XHx!9IzSFmRLSQ%X1^|X-hYA zMB8I&QFb$1(RX};J$Fe{98z;yuQP^>cC0oM`D* zCMg7COv(af64(M;f=`Klb`Sy z`ln`Df0sSPb$Vu{cjzC`KOWfSPq|xV2^KIDxy4XnWPxWFfl{!qYcjGK4}&_JvTbeV z!^}j-?6PF;3h@I_#lC-HmNnQ*EO+8i;*ulPGfu7UwCt7ol|9-4MDyiD^s18kC^YM8o{bFJ(q) zs;J43IZtl?^HOF&dJa|5a1PZN-^Pb?jG)$c8R`Lg8hpoe!jUFn!rmN{8KM*=SBOTr-X+T9jpFErHXni)nvI?{F4^ zEp58KFIl#%ls<;XXZ&vjdD#%cImLR>5d)BHQ2I# z{o}ehx$W>K#rClO&j+7^4`C^vOtm(d>;HAH)W5?H%KEzoxev_pIaPW3s~Jp|gI(E- zb_4hP#3oUb4;PsTZyr_rEWbu7V`}gvlD0Cjy=bPc#We_~syOR>T`937QgtrHe}{;5 z!1%KDdCCb+{vDW!kpqA3Yu?1nbUcQw>z3vO_SPLvS-{$ZkMV}an$(-YW!lrhbIVuK z=cQcOsiJkNP<977DYxMWWdKX(g$L`ql-=3CF~mC(3$`;as1faO&(qVch&8e{SyPhq z3u_F%n`lioDth586YBtPPU#LNf5N?wL1atpVCW?a)<=Cc=s)#oJT%*c7h2;|C#FB5 z)1z%%VY=7(J#lO&ODjv2Py0WUo>Sd#nq?IbG2lK53sP^UT|wJo3jNt{Usw> zEJoz}2y{t?w6AgYez-IXd%HWiJ7Xhdk?0JH$h4uVF@~|aafWMbg5p5xe@#BQB?e5a z-TDLAaEAw}-*An3G1!?s1#B{#hE4fV;AKQ3Hs#YoO6DfmT3x2Rq*sK9#v4)VCj z5^{aa=0Qd1!e_U$CfFamsfp&)P(j=}ipbQ{WHr%Z;+3$Sl$FsE zpMbqOx!%X0pN{qxcY!WXd`)iJP-awk)vR(*B{}7qJ1fM3yoI>Ze`3U|+-3j7nulR0 z@dxR+q7UE%<5NUh3YCxeW1Zhy;>^!UuoW%hj!`vyV2{VajYpg` zDkCbnAU#_Dc)>k*@1`(s52BYi|3uj7H-!GC?1s|J z3Y>&jlXrS^EZynRf2xNq-R7)po%Cd2zu}r#p!t*;1>e->qQz;`y|0N@M8aX%i936{ z_yZG*`*RPoyCo)j3cCc+dafF;YztwN(KfAn1GO}I;9UlJMZi#^UAqhRK1&)~DPqsb4)Vd1qj~?tL2NyevmdwocnGy-R%;JXcsK z4l)~IC#m_Q_DOS62c(u#mwqn)R`6}j6U`HuFG*{}#|MWf_JYk?kg|o@nEX3tx6WNU zEVzu>O-%pTfA(x$0M~Rsws)ZoEudHcJE@M5@o7G_baSe->DfBdB=##Qx6!2;$J#9q znl7PDPLubN0I=1oe@UG}ngtB-#7zU=tZTw`Q!lG%*ZVe*#a?|Oc+U6Pj3^in9)~f3+U4OlSK1dsn^29p-X#>*%~) zH^*n9)5O$1x@+laX`6y;{vsnPkdaot{IiS%%18d0lJq}pE^*t7`T9Sh|M#TlNN$}o z(Xk&E(9ectfeW|-Y`XWQ{-X7|0Aw4k*+wXz###CqaSP;E33L6=nU?ysNsG?MOo8sr}Jlm7r5w(8pgQNu^Tvf~z;+XfSay`r)Pbd7A ze|H=#od+#jk&Syf#XHMKLa{3fPD2T4_%)W&xelx-xUZ#!AGAM{Jkk(ra7qSUmb5+e z9CJYNQrVO&t~r)YK$ud|Ostjk~Y_g>7w`O@J3gb#M%7>;b@I0jMG?Nzko1qn} zk1KiInV?F{=dRJNs%y`w2#%8!{Gni^fAf1G(lETVO1axMjGG-Aq^ zh5JGsykXrQ!&oRwcU0VuJv}wBIOG9;Fu`=MPi-64(6zEu9V-s97Vp&H4~1vkVj2XO zrBswJ;qNWyGk~DbI@lRZ8IwW+wmCRf23<; zv~U%%m#uaw?o4;ixda@WD^MbBhn)_fx===gzTZ>C#VQU>E4I2c(V8hz)yf;PZTl%# z>h9G|b=a(9wkBT~M>Uo*o98r&xJuhIqPWYdc*Ie2l%&a!(35jgY{c>5j(H>8C(sqboRpRCZ_Z-LnMyTc_W+d5bu#%8yO5^^dhQxurHvif-HNd>DrwsQW9e+(=6 z;ynk21bR&wr(t&ind4S#rr3c&a7t)RgPHa5c9J53P0!?NRPIB zRDPLV#1A$oA%!2zh*Btqxw$+HYf3>=VTP@~WHe~Fu=sYLNKjE&FUshbAie0pQV-qa2WqRlXZI3uqk&pjxe$e zugD}G0^v;RO*xDCpE>B0)SZe;+-%ZCW+sxdBqDPhyUIW6lfu7QHi-97w8?Zy5y_JF z9exAug;&M<5ug4boN3;q{cl9>owlCU$NevJKj18)eKG(GjI92n>aP%ScQh<=%*MVS zt(iiq-o%w0f6nj==K$qRHL~VR;vB8tUSmLy>VN2ToRl>cJrrrw88lz()=RH55kebr z6pBM}eJ2xhuxbp|08kBcb%}J*X!mq+>IS9EXH^(_2S+*vaqr5O4k4jIKD91iB#bI^ z3-$_JSIlVUxR?i9xbsXgyzc#!_?5}tL6Uo{%pyu&e@BVz5tYfFbrRP~ezmQKBEfX- z>{Ao#x;0J>+MfCga0W_=D-~|Y92PgI@*6m4_xwiN!&c@_!%rL&?8?cc_wY;D3j54| zC!5DzuPHY)`;MCPaGm)AZhY9%5Kjp=UZD#qBPOa+{ZARo3yWf8*j>Zakea)g2IHE#0sQE$G*p@s>Tl zQ|R$TN&UfIx}*4{>OD0uU()xW7aWDJ9y3nMHP;=;d;OPYJ?`TFAMR7rGoTAT8d`xp z{7p$+$;QA1$4OX<9@FWihw=L*^bU4F1^UNFam>$J&N;H-L*YU0Fc2roe0gt8!WB-Q ze|}g&D5>xulz6szwiT;1(aJY*9e)TL6vSdUMmNJMkY-zUf}EAIAaEfs(f3znTriUA zvUGp+oG;nz7KN?Fzh_>6b_E9+<%e)yaD~55YbwTmbc$oR-dW+zGknLtC9Y*1#u)JlsxjlfQzq%ocoNBmn)kMJAX@rB{{Wv%)zRKOf2m!> z{T{vE-8y|nRBaDz_eV6}hx@=e<5bwFh;&8qX`w4zZo&4H1;Tx#z)?Dkvg4|2ygB$R z8}42kbQ+JC_O5X){C&<4s`1e2aR%DzyZn2d*K*r&L|<(rjt;3I$yo>&oJC+$jUXng z`X3-cu=}^_A6M6;N1F|$E-6mYf9svfjpx4eXAuJvofR?tsW(N$2vU{dx9%=TD5*o_ zcHDt}u5NwZ0a-bGA#1MszszVvm7Ho!sE>b5H#u~@(WR^k_M(?FE6<&mm3mU@cNW7* z>+^utfAw+lQ_yoRb6z5hkJfvW^sXAv!rT1U;6sI?;Ro= zjO86tJWY9$o!W3nySp^QFb|PygeoAkF)yfNmpx?73ao>a@}Z!v$qTK}OjYvSHPv@^ zBeTi*yy7rPs<@u)mm{CC;Rbpq38z!MrRSQ6W>Gu5`6Tyc zFdhEeF`IMXRZHM#@LaIdRt$l#f5gnR6$c|54%t$P1Ax3N$86~XSyU}nEjH_$H!b-so!6I-g^ixyzzsE|{XvuOit{{#PFQkUbG0Zr7E`xoYrsges@nz>*XBv9$ymxwZ^Ct5o^CVZ4_G!w!f4Ki(Y&&MJ)w8c_zB` z)g^AxHPCR_bcs(Ehgv67^k3S}wN`&6YpuT)d<8a^e?~b7lw;t~aIKWzM)i!OCZV56 z*+oV+@TMy&-Ju;D*cZ+SEUB~_&=+bmPO}wf{kxHEf9TBepuJmL`e(@8RE~yll!{H$<&I?#OohK@&~6&qW`Z z_cF0!IX;D*bQ2mnOX{j?h@~blBgh$xRo_t_zC&i2OdCeZk%HaTuZG-d>L}w&=?;sI zSn@(2e>kFWuD8&MEdQEyGS$Q)7TjYMi0{J~L;gWis!vUfH;B201__c1RJ)2VS< z+3=LL>Q36j{4W>n%Xm1{q48*YD9@5;Y@7o{yx|EjWy@(mkZ)g|IK z%J-17(~DIPhVu?pBMnYwEfZn+sPHLE8@!S3$k-7$3tWCRGo<_!bB~xG>QIdl62x8X zRB>6zV;pI9r7MMT&G(^Id0x>&eENlbXbl+$xDRT3R3k~b8NKp$V+`d)1kX_p4x}(c zf3WqxDLg|_aO%VKGsc&w!h?Dc+uMhTApyN98?%+PI<#XOI+;ez6Z9VC5QWE{`P|6z zgJ`|vR^YgfEqqnEpNXI|Rc1HtpzFB_^qq>abPrcQelqBYY92wV>WJ>_+#yl|VdC&F zI5(S5Hm(X+IPk62HOuoG4mqL_ZD8MVf33P-r@hCcFGbgpW|ZZuYk;D#4zL<yXN9Ab~bHPd5hbKv{9+x66aygXkwS$B*+tLUM5YCf#_e|J^< zt$7{qn7#UVR&l#(CLO$#eJvf(fnGlGcWS1 zT~Rp#YoY6XH>ob%oeaYq;4#q7erUqD8%tp&p?r#esN+@f{A zDDmZ^eP4`LzCQTFofcP`C8O!vb#Jo9F;%)zl^Ya$9=?l@p&ZIc4*_k|G;RXTdt$`~ z);-ob8Ip3RkwsL4t+>+4e@e>XmI+`aRp^Xy#8Z*Erv4pfG^m+A&?+CPZIiY^x@|4R zEd9CEw%|Q_Cn;FV)pEYu?F3cv!?w}Ho!DYWdyV z8A~9WQ#&+p@~5lO25f-@+b5)*Dzj)Um029<`~7gyoTVB;{0;T@f9Ou3FM>W|@E&sw zscGQ747jt-kvSIrKmN^~eeRfj=WqB-N;TZovx)M5#Hn3||CE_Scti2x;A5~MBdS4( zKJZ+$U$>*T6_6O#nOJ^ZITKXuSLxAAAI*_46AAH=DwCS@On=dO#b5msGl$FP9a7qK z-zj3FV-8BQlur{Ee_iHLXZ+ImpBO5^W;(%L(O+y9trM7HM~qKhcL4pdJJ>K}uj{9F zR8#f&Pw!f$TRvJE@4SY{!xY#{YID^-ERwy)PN3nhV@k>aR5~q;~|D2}3iF za^tZdO2jR;f1v6;Ffn6rM0VkK+R85Q)#4V;9_kazm@#D+s7kc-v^8$^zhz|BZ2=p* zh&N=7$(@Gl`hA@9*`SvCmsf*&<^1LOEyEzkd=h=FhFiP=`Pk3Ju$Wgf5lkbo7Q-<( z3r0|Ad%%l!{4-`0E0x%A4r=&hxXvdVe&m0|k$4kFe@H1;YgF?;;x&W%wSg`5pNi$M zlNk>45Y2ID1z$%Gp+p@OjLNUZJCj$p4{#;m`aG^2ZhuCwt81V(n4tSLR5x@&K3+x4 z?^{A$=q(+E%i=502DwnKm>GOZ-|U}Y_)d@Gz$^MC}~^pA>lGy^xlv6QQuO*!JopoWk;*O0=3m(HDGJs*ItqeRv$N9V~JH4 ztzSvHvGHzfUUc_4jaKH#;q^12T)$S>jC02CLpSy#}fpFSsW=;l+tetfK?_PhpIbS5-OwoFZuiJw3 zjZ$ut-m`<9$6aQ|kZn?Mr8f=N{CgXgf8Esw)Vc+CG5M5NJPTUm+PgEUiic4Dl^@E> zD!Ygtd~Nw5byVO&dNftcs?jHAw`PqA>-_P5r&DXI@2-1h-*pDhz=DQld0C|Q1iLKL zSMs<%w!r7G2@b&NvSdO#Xw?_~^m*I^D~L_oqT?n|1qz)D8jDHa9WjPZW?x=Sf0};A zMNEXajBu4@Lu;)qwcu1sNB!594aQIC#Iy3X$_s)$H#hYrcni-2I~_A1Gwf;Do+O?Z z(mo4UbMkvb*TX9FRPC2D#8g>hu)M>X;cfiJF3*wFn}ttt^ROKoDON~+h0tcs5_f5) z5|@#2n*W`Gdx)7^_dYR3gH1IOe^MGcxh0hC^pjVJtN$NCCwbq6P{r?Y*i+4yQv<)J^CX0@9}V0*~7o47@M<{9kfgjUH5T{ zo`z0*qJ^>^`4k!gH+{Z#c^y~SkX+_nnUw5Njnz*T8@6^463vf63}O| zSN>7=kYhG0$tt?9xy6vjF}w0S;_#!=bF7(fU3;F|FIPSL)t#1c>>|Y|?N?|Uk7}kc z!*TSIxG&|(g5MB>x^P8i=b>D)azye~P2Uvo{ltoGve?PY$Xj$&g!@H%7 zaC@Y2#Hw&#yewTb9-#<;xGZ=sJ-YTXRnVtL>yGK#%P(8T1!fdKZ_XtBY3KKd%hy`7 z4A(T#l7dd}xe1Qh=qsVsY3MXQ!aR8krG{0v}wA;`bZP7G+LQ4#Hh19z#(>gGt;SklIHEys9 zGPjV8yTZT5skJ?7!1?SEhXz%;i8wObHIb~D`!Z|^a)#(ie}j=Fb-J2Rhxml)Ui&2P zMBij0v4Hg|<$uJqlMm5|!U zEfMoMwf++wXS6#{vQyKo-W;h#EHD;J{b)s|Q>=kv{Mb8`9exIO(wZ+F64F<BhXZGzo3C~j zhn})eVrz{N89Q2Hq$k~7#6MiW4l#fUZR+{do3*{@`P6vMfi3TKA<{j^(k+q`6kav_))K;1)=`=R zr`=tte>bJ7`Y!2(>XIynxVB)sqG#Dd=7Nl<^p2Jo{x!(Rco?x~1lcS#i1}3Gs~SVP zgv3$1WC-HQNRM55uK0OoH=VQMT=Pp+!DYH!8fDAgh?x=7Bc4Xf#VUE#ccBhp95)`H zyTibhf2G6B1%W-zLTAAwOq3gj&^QYcN6+H#_p$+^7 zZQ-VjsKyQI!NNjMGS?c|;GR?cD(ndkab0wu=RU(d?_fg`KG!Gc5q<{8q&dD*fxT=} zfAD{#7Sa_l{8rKwUiD68Hu|4Q?=WU?X|NYp-v{tF=+4VB8>A|@Si98f;#8hQ*rmzO z{!K8Uq09TWcLZxu#+6-gUMs01^`=lGU)40Q`ZyxmozU(-wQ@dbl_($NuK8=Fe#?W^ zZIH;?SK5_5-1D|+nkjIei?ha=bGT!ff18Y-SQxkfuUo$@zE}Tv{@<7X#rpFgej-s_fy3V9C$1VYzaZHvc z^=9)Ijt=JvoV#(vXs)_nEU-M75yh$WjZ&5AUSFc;h{sN9bq!s~lA_0xsNfnpQ#fus zTB;_+5c?#}r*((3b;fC)Bbw-pe;s0e#Glwo@(ycq`SV4p)PcsD>;#HZx`voD3lF;A zLp#z63o91Ejat9wgm8wcuxrrU#r<9le#)Ouz3I9i{I2_hH^bS{xa)mhdJkn7D7b7= zI*M`6QM_NYui+3`aDKI=7yIC`RZrpCpgaK=e(G+NMd-m9f<&nrPCxC1#uanwA*a z_0Xy>G_s);%sr-Ar8{(o-6FdJ-t_zj6QNtr1d?MNV9OD|5YBieIzTZ~NU&_6dbGe6 zdL`KL^_;LqDLc<#X$85_uW};xXe1sNMtUFxY#>D9k7o{TBewA1nnK;~MiIwW^nt*H>@!rYX zxKTeh|6fKke~qgy)Ap-+L;liK zt1qPI;#e1A|3Bqd!F=|s((mCE?2%Y5&fOI}$8W^D`HSAbwXrS#@31HR&zkY1RIzlL zqeEhK0pHDk$>Qm~h50L>-T@vE?8Kf53DqBi!qy|VK|!42!E^eA=97>~OyQPya4rQ1 z7loc9)JIBB`|tqk>*9tvGySFU-1%k{*2X63m(=RDst#A-m6cq<}D zHF~--ULx*!XqQ>MiKSpZdbX4Upk^!e4=6Z|2Q~&HnYGNpe`YcNIefxw;2Tu(OxFEl z9?!oulgp?Y0Q{+m^8M!9N^zacExmSUq>ZXn*@)tMEgOiP7rnyC_$5 zx6q0HA9{+2Sk(&7Ss_*V|I@$MXA0{v5Zk|MjAt9{ZLBF;Z?0hvJF+vMOz!}j?$@|O z?WR6t5#I&&e_76|M!-rLz5g?-ULrpI0%lah;kuip{}p5?_aXgN{;#$!^y4+?d;K!s z>Q52=vY-B1-*pSS(}?njmcPKU^xo>7e|0j(%6hQ|dRj#?ER?zE=^ljO%W~@qw&RRe zTi!w2f-A7_vLcBowz@#AiTv4pUPr|JPwm4`vAK1!e>b7iC*Uq*g)+r6ff=fNoJC18 z`ydZI`RuuM%xFumyG-pB@1xTwctbOut<2WJ1|Pq?xnR2o93A-0#C|;t7WxgkAz*YC z8g-zPPm(&BM!Axs=9l}+ID%>|DS`vlbc#>);Gj;OBIlo|e=$qwm;PpkRTYcyn-U>k z{x(1Je**Si0$zn)KK(_V-5TeZ-EhbO%n(S!_o}gdh)VEX>f)t$l_+Z17|Eft?UfKQVkGx^eN^1^v+3$@x$JEZRjaAG49tJ8aa%T_8b75*Mh z^FN}kNW@QEfErh=d6qB$?g)$IQcn=}fFQ9Fz1q}TX_1L}7}JmsI~=2Q)3`nl%~ ze{b49R3vd%8dq_Px$#sJ8fV)ou#qx*`U8iUN zo7t8&RF~y>f~i^lmtbTbpN}5)nrBKjTiUtt!qt`A6c5&3ruYh5*>EWJB(s~fDu)~J z+bLs%s&a`p%QcX7obsY5qRFYL$}o6Nf5E92uO8ddk$RGNv^d0$mFFWCl&1yHIbxib z)Qf!!C>BVO8M;$-P1@`JhncZG>yBYbK^$LJ>* zV*)ek4iMvrA-?vq_fKhU+DnG`maWbA5UV$xFq8fZx7c}!Y>y)foY^{`+Ih(_f14TN z_yfoBZ#AwW#v+Q<(|(-yr^+vhFNA!>(;Yo8U?AJc$i2_Q@HAwP4_Xz z7#A6fNp;L;B92zd*h?;`u8}j=qOudxA}H2Nv!?kT>V1l%33lav=Ot5oNY5LBH?^mo zm$)m2sFmB?qHjU{)HR<4BTG|Pf4|NCm;Ys^QMsA?xROdAPq_lw35_lVw{n|isxd}0 z75(51ff=lWnaKHH)h6QWp65wEcNyZqfTF zGm=Z^((`M`+m+hwlRWc7e@<~3J5?262hq=L=MIX?)PFLJ<+X*ULhl%-QX~+4oWYiu zkbd3D&~;-mF;sw!GLRdT6%IZ?`nb@p+zc0CL*7FCZK+&uW;SP~p8lB@Qu5Drw!_-g zh95Ie5<4rYt8$m2jVfT$rq`X7t0%iOBiV&{S>ehVx~gaqu|bj+e@|l#UB~zujs*6j zXVUJ$dujXG%4YP*&|mtLU8r12ypcXr!;$72`UhZx;;+P59llp}4a75}h$T9F9!WJn zOdM6?gq41bFE`eZzN#^b@`jUz<~aH$!*8u|mO_85)QVEFmTX6}zzRfPOAhQ?#h)4Q5PUR`?7w%c_Rp3rws& zf$>Q#ib&kAOt2~MEyF29Hw%O3=y_GW>_TRDUKS}}@`1d!&?EVhsi}C@G_^UYp{xF# zqD9nF{oM3u!!@Rc8KbTt#Grhdou`O|oeGXL)5M|r1k$O)Hwbm}xM0*mM zkyO)Rw7a5=f+gKGfJpTP?O6U};}fQNYx@Pe=~6>iO`49&GpgfRv+_QuE-2v5nv#c{)p!+qV`^~UTKEd@1L0Z{1^0`HJQ)B(!#Rh#~WSQQ=u!rChOl}X>mfaS?YJ3T)hcaIrhWxtg-l+5k^)M zjjQ^@vJ3Ri(lI~1SCmkcP&T5p#?fIqp7&PS-4&~=e~dA?X41C?web@=)310|`SL&2 z_%6UXpjNYY{q2qjrN^Nho;DrZM)#Qy8@)BG#O3Na|Jb~Y@=suELzihn{X3vqvn?&l zb0*V-pSh)%4W_mI=%1TQt4Ws-Is;46nwl?zw`Evfmi-x6Ku=@dy=I9aUU;_oWMF~w z`;}uLe_NlTkHfxS42doGz(@G3r=b|p;y<3QwzsgrHGrQT4xIgQa}j9KSIJXhwU`fyT&sd(UctS;t*jo-LIC~U z3^<6G+@Oq*Jpcyxf4`8>{Ds(rt7pI4idOd+f4>^K>UZQ<%P}K0tmFr^W5XHA)g`x2 zz|Bjg=a`YiG-oX4U$cB<5+F~ws^C;3(4q%u?V8Ot78aHd)g9IjHxv{tau$iZ zf4n)oLAZ}*! zYmu?coy={C$-5|efop*{*VMst8BtAo#6NfX(*t7Ts$N(XR*48l2yxcnOp!Gq%uKPE z2Nie4%wrhM>{Uu^aLR)J1z0usLwleQe)P^QK)gSwJfW)OyMiTkbZWC3rE7t@Qq*;wM`d*!$>gW8i ztSRqx%}CL0{!}*(z1}r22acI$~{}$dA>o?tH5lg@j-v4yt zRPPbLHa^3h@AHtsQw_PFc~SOGf3ue!M&Gp&%DK;&jX$$6t=gXIS5pub{*%Y0PAb55dV*M@CIUm1)B%pbe>!HTBx2+=9}f*%o5iSv5d}IB?BZd zPpLQ4SgB`>roKMF<)k(!0j$wajLNcCmh5^ENJ z(sM+rA}%@q%TQb~&C|tfe+}MDx3W`x-OOwCkB}ZQv(c7X@+tAHDSC;6)pBL!eA}mn zLTQf7h+Hk92h&u7c=`Yof_N{v*OtBxoBD`s>kle_ZLo2_x>f0wydWfD8jD3~tcUN8r} z&|wsLq)fyxuPj|nReE$Cx7yN{-ikA-jyO{&wq%G^1zN{?TBPkS)l-fp`G~Q(h( zR}@tNp)HOt*^HwVYj207CJpQn&X_X|V~rz27uGzZfB7|}@jq&Zn=^ggx{2i@ZNn4? ztfQF(;e~a3ELRjS(dbf)kTOApaY2=^wPdrd#{G?Q>h1k%lbeQE{lWJ@kS1TjGDkH8_V9{@6-kJ#mwj<<|NsJ2jLUm_gAl zs!0{|f0aq5OJ&1#fx=gXHe&B>>9EWsK61|q8Yi5u246ScZDheco+Hq%=yC6B{=zt| zr6X9F!YLZ0D$o4DS^Xze)0*+HVXXICRlqy7e5j(=Jc;AX2HhFW)cQvx1+5Auf_Z^k zB9;?ZFZZD+P+Ln z8TH8$_Uu^I4qj`xMt=PoRh9>R?fmdL53O;lPv9 z9*fR8pnm{yj#`cz&S5Lp?I}E?=+*YH%j6T9GsGP4QSouHw1e*TKxt&;^sNw$rSTnic$1(6WsgA zCRhhd^TJsTViVO?szJOD=XQ%{k}<~eVCqfS7}!MB8OjLn+r|;W<;+@co^>?$CHen! za>PV%lW?uX2G7ZP01LsE-WOWI9i+NBe0od8v(+U~W*AE>@}Bw5!q5+n#~ffNf2f~H zIn4?|Xba5HzN>u~t?;A76UTkXjHY-zy+$8ats?KF7xDD-%dbP1r8_Un-341HLj|_@ zI^a$8vnxnvP-lmPAS1QQEIr!7!r-|eXS$^M_lzjZ1lVPWrxR+}$Zup@;9%(?sUcih z<1-;{DVLQTtL_|S-x1%D%$3F{f9^X+qEEegY?FRfuOYs*Hua>lsx+0(QxK`!^0I_+ zu)z>zeV%%5m4jlkQdMAoFtWN&U#cG{9p>Na<8WVCMU^eEN*7>aUH#6Af8a#_?fe#P zkF5tvY79&_qDZqNyZL1HB=c@>o;Odo-kTT7XSUsiFYb6PTqVq0JVeKFe`?+!xoCAz zyoK2LjBN8|W)$|HEiD4h+oohs$$w7&0Jqrj7#zt?Fc#x}slF4pp+)gg1&IS{FGB|L zWXe^5SF8q0NI$owgE$rGe2K6%uJs?J?d&{Knv!zerrc>MYjJ&zg@s|&A@J)HbOGX^ zW-BRwmpQ0R;$LIui4{I|fA9xwk9@*lI=?!cRxDGaUy z-9*xdq6iRG=}|=rv9-0vWhY>3J585hVQZXO@2-b{WgO1zSA@3Q97}rW%IzAepVjy- zkmrC+R_gi3-y6E}cgXs9N5IC6O#9lA=zYUnbLZ3P>_LWR8qKqxf1h{aIGTQ;n)v5` zxzn;_YA->Gkbs`p|5B0szx_`9&dhG9fwU7#bMATeyrnKB>4L zeb!>-enoz1hG`zG03SDjTcYh}2g{$%*=X57d4V{~(ZeKWQL#K_0r7Xjhp9Kou4#MB znZZu9pa$}0Yw{ekGZ@NIr1MIuEMa1Co(_@)C9b#JX_SLrfAOqsQnzIVOfPCCZ12Lz5-6V2A0XPR=j+18E#+dvq4`O!hMoh8)!#NfBCM z##O^?GTQkcU2Vk22gUB>{2l68w}^8#ny)5hfY5a=E}Q{o*-`zIhIWlcOufi z!=uC5y#mJ(y*f)jMLX`CovH`XE3v@>TwhDgpK5yyf3NY$rdj-dGcySt;4T-3y|+W% zsd|ud;0%+^Czn@?_k_;524D->X3uX{Um%{w(085_Yx_mNag1k&>5?O^?tophY-ow! z)fPM_KC783H83N&=jntw9G6gca`R|a(0C|%g5${dM_hT8Rx+Kk=T~SJ;=YaJs0wI4 zs^4xXe{{9UnRBPvsimpHX2U$TGTjQ9xQ|>Vgb$~|CS2v;;>LRt9iV@J_^)vX8msKF z+sdDYc!)>O`v>A`UGX{I6|IRY3Ra*GRL!i_Wg*gA3$If}Q+7hpKAI1q4~!$1nMtG1 zHf-5L+?T5FMBIzjorVN=a_GAAd(AlSx8&&{f3gwzR>S=nPRCQkJkFowo5ewKSLv@C z4r{#2|FZg5R2}bW@w`#^l&-DOrGFqoPi*(4uFwTui!Ja#p)iN|{Nz4SD`whK#i7Dx zM57ZaTZyV*VV{_vGlX5FoXot)R|&mzUIK}*l-3Xaywk=eDtmA?*eDka_A#R<#!eO6 ze~7rceVi~h$Z;Q0%#14Ssm_Js`-E!AKVg$dLk<>(5J}V_KA-??K$5>_fTP9|tB-ln z^APi8nHki?)Z@BDBS;nXMmGIrU2b}-@+09)x>DH6S4j$M3-cZv46TI>9Fq+5$=i0Q z@c-hyKap#%ui~t~2)m%2Fn6$*iKD6>>i}%B4S(b2X`XOJ30u86h61iN-AXxHtB(`g zuC!gVkmd+w4C^1ndwrbtH3Xc6!5>zfG#|#_!*)=KGh2!KTk*O*S-)ETUo9Q3sKAWS zJD%^ESm?@~CbQOF#XX0mwkDIpeP{h6%nOY*u1BfniP+=SoplFVezeTYGZwyHyHt*; zZGR+BrbVs}tMv<{t=>j+q+q)0JK>C2;NEA=BE<=Bj%|u{vS&U!H9|@120|qNH*1!y zG|R*N;C!E=Ty%Ql3_^Q&CbCIPsVCVj!b-&U%<|8;D~eu8gFA2WU8flfpe&q^QM%r; z0sf|lWM&Ep}MpZhE5w3jsbju|T$V$HHY10NADEw*|G+M5C5UVp{^ z+N?tPq4GocM7yxvefV<=9F(~R{4#gn#=ru!a2o?J;Ro{l z?S^ZJ;)}rRnXk#G`Az!>t_4yvdlSCFPkaRJaD$11*I_?13%28LUt{}8ziy*vw$o!6 z%lqJSy#6!pJNR5WhVLy`FJ9LwjDNG}Qv2!-6VieUG*<nzPi%x8qgl1_k9bDI_L}iK-FZ- zh{`IRT{G32$2YHeO>`R{(T#&P@rlp{?uxnS=li}fN)Z|S0c=aoTc?%|@qdp9MmClj zM+VUzYdpGR6x*WMn=Q2^M%e6l%KB(yskX;G$1&SGi)+QJzDs|ZPj0NC=nL1!E`*PW z!OD@XOv;{GHoW=ouvfnb``)HcAw@Gdtuo=vtH9OS4jZ^mxZs{6Y+YWB_EXjT1$;!D zH^S9)2eF=rO&&e^oL6(xNPja@{%2PID&66pgU=f&*hSz64cE|m@1T>Z*0^#d*OoS2 zQs7Jp(EiH=%m!wjBHt}ipWLqWtS+fMPZ4XJZB4i@^uk865tOrOjG?m^$^)g$I>S7) z6)O5oGmdr;!i=;=12e>-q;YN?jdl}JrS*AY9CsGxnu%?n@||g9$$#_p%n#>Q$;_&_ zwp>x=i$W`S18JJ50=Q;$+_k`B_dYg3vV?Zj5S#cJvR1CBhQpqSz?*HFf`m^+eh34Uz>JrNaT&aN-X7qN_DIb|Kg=I90YsWT)GJ$Jd^`EAiAgO2(>DOE5 z++AHDuKh>NP>F6_wtr3+Nc-9lZ<-WlkkHR{M3GvDrP~n$*sEyU_QM{w5{`M|=?sDx z=E-YU-bV`Jx?FP>|94pxB?1=fCTpT=m-^JKS^4xWHrtUu@!4|E`}i;ym)HcK^M{;& z3ntj61aGotO+Iv!c9YRgEMko{flaWJQ|IU?DnX|blsit^I)8A6PbR*6bEbao>f?^t znMc!pCu8$}RY{QuW*M7Q;BK?emsmQiStTpzt?>tLM+`%Kx>Ho8=(8DHE+#tTj&e{;H?aqtk}oooDT=aNZRuBJOFhv0vq7HFPmw5(`3L z4{uNp64Q|*Mt?b6dRMtdU+VuiU!p=F_D1+B=b^N6c$>0YAwxPAJV&RC+UwptL>*}% zKNF{VkE*5UG+(egtCSt$+SHq>_h3WO-E0v#9ZB^abY#okX0{PV3>|m$#uF4~{ zrS{brgfoi23QP0eQckHJPX2bqi>@KU*6LToUK}yi(to{6axL9Dw`#F@xAZPk10VU` zW4{V)1)G2R?b%}K=9~3%DOcFiZHQO@fZrYV1Iww>631ymxN`sY^)gRnd6?UZ9VC7= zX9Yg@c6bjqTH{ESvn2+O@&;Hynr+rN;u5gsn1o>D>f`P?#5W56mN^x2y!%w6g>)35wQ`EqFA69#SCEw72^Vnai@?On3S7;wtjF9H*~=PnJwxWPR(IE z6%Xnkx4P7ey^n_UC7V|tUwu5o2`kZ?>m~)daDNNPpA9}0ZpY92NfAl>TX)9;NF!Pk zEiMHAq6{$pKJB;U}s64WiMN~W{G8QLtpNL3S2AR zZ!?DkcBKx0Dti`1Pn46z6sqb|1NQf0ju_J7Tvd8&lv*?IX6YuPum4djc z(to~#1a`S{xU1jx@GTY2pT|hEVL`ByVj;w{YMo>L)U=TF_$aeE9Jet>5z{e9h(fZc zUzBTrElM@-OcpdFv#0*VHcRSyx^emhVjf(5+*uKL+0qSPH0c#J$_YV+y9`^5QLx>U z3~hn^>{r5UW)!>|Ou;*UAm8~TLSESGr+?rqo%tw9;j|r&rTsx_$G!Dp=}qW%cZL4e zxIw26tAQr}E?Z~m<}TwM-=n*r#oHydr+uxQEVQLNq<*S2BrBQxJN;bJ4Ma@wDiBUc z#4$^0{4+nOe@-1`jByRP287L_ePIPs1(%y+EP)fS1=sSYa31l+t2q02rK#Zyn%^LSs*hM998tP)?jCHO8stEKb;R6 zS^vx8P;o6@-OKEzQxU3s$cSoO)e@6j(9mU?gm&X?Vpk!i8j7~COV~=~BhJF+O-1`X z=X66X4^r-oBPy^7TezNi5q3&X27gY&UOMxIlg__Uo`~yW@FrwaO@pP49n|D6|4Zdo zaXG{nUe)%)o1P~u(-8$7;nc7}GhWg#8&hvW7js0K!yC-I5#L_V(^|TXj|Bfss;d9N zH5&FowI>nYEvZvI*fgr-Q~d)))0jzO-|FM$ob0snQ^aJa3IxuoJCmEW{ePYlt#QH5 z`l*e7CMAMk0<`D-i7Gcj*DW*QJZnyiD16FUjQzPud<0ig&g$bKz2^is&zJ*83!h>} zmE91=DUutM(B8N~{{ZeZ(G6Xzj~5=aP7YnC9ybhlXBnr7Da;t+l_|RbA35LGEOd*W z6J>3%#WjF!*&n)2*Z{WkRezdjW}~y1n*iU~o+Q0%=leJY_Vme`e99OPU5BG|%FVjng7#B7z?YNruUkCr_DC6+0a8(wo{I=7rF8{!pXK zI1TN~E3gv|I*W~V?2}!VcIft;Sbdz7c`FvBn$UI~)dehPi6cg6V@8=SftkEauGMqG zb3$C}7Nvgi5#rUTe}705t$z|&_Z%n|&XD4o=S1>IVHTkkO|&W?9itiX;th(_Z;G$rtBh${)Q{0^Q(d>+~uP6#wbK*G+(pocYsZ0l3J?!8aF5+v#dJ3 zC)x15Thu?`IindVUS&2KGtxV3rJi_2k8v6l^KW^68&PpXtNH=D3V!ZcgptVqVE)g@7%RhywWs~5v6-S zl*!HZ=Hb<6;hT&Es18vMsjX>%_PyL3smc)tJH2_T2jINVg!gYwF36r@X(5f^aC^aK z=~gYz)_LZOWq-j)soywFxrR4To{{ee;P}=Z&~eJvyw{!A$Wk>8_&VS-+1~7O7N+(g z!e1%Ofy9h!(pF|>>Y#FX`6+GB@|BkUW_*72VrIATVW}$PVd6i@SeR4cyJ`M3w4$|^ z8LiDhd>ujT2|BxNSfk78Vq(cgQS`dv**o(f@HgV6F@I3z0$Sq)S-n|DISb${+6TUh zXOn;Rv)#fB3-YVD%gXkKBhE`S+Qh)COj5kWUB;f8@Ayxty}FFDT1m;`r!%GOlk&+c zMdeL$L_H8pvAn}H$}`ZG$MZ7#9w{K>_pKs+FI!LEG0$&+LzHu#d|SL%E-c5LpbyT# zIk3V&%74B14L8tVRMet{TfIp-$2m%`!O?ZQOWuW~(rP%2zVg|E`)oPrnPxx2E6PW)Xc5KoRl1jt1(bS`E#m#3 zljus_dw=~E+BBJY=lwY6Iq!SU^Na?CaWu6yCAM&N)@XTBusHKxVw?A36i+ltS(8WJfB!*7gT3< z+J6e=l;eDE9E$UqXR5qbM@jlgNFu~Y$S;hnEn_kI{TVx2#u|17ANS0c+YveLY?`E; zMehkS5L#I4V{Sv!XZE?=Q2$%WR)1DSBWBoCTsmYs(vyg# zAAmjix0DC84MkJkHAbhT6I8{=>(^0!cS?KOW}JOT;k5N$b_yvH!5L1*S$~?ZjOL>Z zn}QdKMIEkEm6EU%EhFM)TvZBgX<28mgH@FbVRj2Yl?)+VPha-u8;4~W8xz5ZUT7l{Bz{BHy9mdP=z>RQei2VsBHj${`Wt#17J)< zF%{u@p+C&GPkRvP$>W$2QZKLZe4vYU3~}}5{f$ntEMw7Iy-ZoNw0{R$c+(ibxNTfr ziQ9mvPl3_)Ibz}PzeQ_715~-T>^8A?<)ri1skSiPp8J!&H*nB3h*;~np~PA5AI4PW z7wTf6)l^dM3hberRbi*Qldi(wAnQd}qKY3;At!{HKP)QpXkrpG$B;)XmhvRZiVa`8 z#6=4CVLp(I$CS|pyMJpt5tEe^7W#*!ABJ6N_cfT(PqIy#ex=fq>N$pUOliJVTn&Ci zPz#|LFh-*sP1nFgp*e@t%-g#ut9Se1 zBwp3POzq(2Ie&CAYP}YGl$7!s$EAJN)NY^P6~wa`ALNCY*&LbE8DIM0x|1}ENJXAb zRJ|ep$Y)c;87z?ILcEfAyf3Cb38_`tY(Lsmt1{YijHxmVw(X6WiR1s7E{YqkzE?Sj zwK7#`3ZEoKhM>Y!hsX`e-lY==Tzw;`PQSRiatkw3cz=VLMyJ2hcC_h{{JfgCgd@vx zbyFx%wsl`9 zdCCM;Myt zYyJ~?+tcl7UbJ*~FghE@Y~<(sl5r04bYFHMVSj_4cjrPg-x5>xi1a@9G&3!5P{~W} zo_H>TtP{qViP_cqi@^?VOU*;f;ej(8l2{w8rr-VRX@7?7=r3P{=jlDzyT5Wu`F>{q zQ!%@7#vsa27Kcy7L+{j}ecOxH?>x|sMv^Y~Zhwe~8ZjX;WQ91tKM65A6+MTWI@?%8C<;?v#pyw5rWFL$6RP0rHc)A7{)UZP1_1;p(;FftIy%= zKp#l8x<50j+>O`p9f(Ml=2xKSKCGLJYgB{YtKZf|J48$XzkAY0YGRBNpxeUAF@G2> zX~>0a?O`pe z>^Aj&3)^7wpFn%Hf*Wd|li#Bhb+LbCNtr_5o6^p$@O+)Lpk#;!{I_^@_FWMJD=jVe zkHVfIMi<1)rirktX%h2#U5R#v{(l-10ek&>Eo|1{5E8qag>t8SLwzp!l;H_8B1g!9 zQrMdGK=DSEWO=HAvpCtzvR*?`;bG{qJD7VW4wZT%;z8C$LasbVQ&sX3sh8BR8HJcwg+v6*_|^~&Tt-(9}jkjqe(k_%}K$h+_1`to?r)biXqc6mPNhsROk~i!llWW8oilv80WuJeQeP-!45HT%4M(@5NDw z3#=zzN#cVH{vd3WTxFfK<4|0!n^JxR?SqAz;6IVpLj288BY)uEn}6d5Yfd^h6elRP0Gv5S zuA6Tb^rUu3`JUW_vcHkmbav*-rF6PvVGFNYoW<4rx8hlET7ONXtOEx=nIrjhZO5`) z|K5s4N|m7EZ-8H(nK7GRf^owr(z6rZ5LC+O%*UGAm))k5m7+z-Jvf@G^?NjsBFi&% zPbfv^F!+~hnR%KAaiu3^%;x@*F}vm=q1kR$=9;r~3w2L0yWJ{m^+L4RDk1b$vqz3| zrFrfZ)}*|`4S%&2ax-f?>?495MafJggMOyuLdk{VEleQTQRmW4L7Q|X?UV)o!bCVG zW2_KiGcu7lI_Cm2%?*&K?^a1<$C9lW8NWvAE1?KJ09OBA@jmoLCmQ z;T?VsyFlnSo+aG_Ww$p0K9PZ4l%bHaY44l(4AFbP%?%ZAHf;;zDDnB)6 z=sKDQVSj#8lWw#ct#8c~%lP6gmhtQ&VW;mk2p=7whnv)_Eb7q5aiK|%ec z=?|Q5e5TIj*&#jK_zdNH(z%87tm#={r&lnKLd+gjw!^>PpU&TC+#IrAx56yjkVcwp zIqA|0&qZkA=ahZt?lj*>8P7z~Uc20GAJNcfDu03PAs+7Sx?DL1J}<7eburgUFT-hh zQg+(_j~cRrOb<7i{BZeTKFal+f4%2nR`SfZK9+ok*=_5xjp0A^)tlp~a>SHWSLN#| z*zIdo4zd-dZQxHZRdS4fFKO4Mv|AVYx0!g-wE{Kb;mV>7Ocyh!#D&)3By&6eTDV@L zV1IXhPrBWc;Hy%K?zwCeYZZR-??q(vd$m<)7Dwgm3`JMrs_g(iS9zEZ>^JPlcc1_1 z|5+hH3XK_HEOwaV`8n!ysWEa46NT7pi}81YSv@RR;8~;W=A-O$ixx2>O-W3I`Ig6Q zE0mt(JNOf&moto-Dq_mdS*YG`>*Ah9KYvfC=L&lL&%6nwE+_0XY^6vW<4_CY(PCef zuhk!ye+}CiZ;6EYWm$5JH$j=mf4R~{OeM*8st=J;BgNijv(bWOg!v!UBb_^Nl_*R* zQe&`(biwJ&i8Uu-Kld8<6?efn6F!E67*BU$RJT!kqvRe$d~ZT4w!=!SMs&u&e}AZ% zgxL8s6X9t>wAPj;VhnhSoq}WecOk&5xu?B%SP8BR=KOd>ESKOi>5i#$<%F z%p4{vcu)QL!a_s=F`7wIw(~JUN%psx9(bRb^Q{}!~EAGJQ?E`_&3BlkXf|4%~R#);#K9xmgt z;9_4Xw-&MGMm~l1SyUf*RDbEeXPbm8_?&G@-lTvIIRiRjvpCxHK;tywr(inHjL-6y zV+^^qw9k;_s5eb)++6rt;cK`K5`eG2sPBe8&%?>%_`|^h?e8l7jO$@BEXYj2cksH= zWjpe3=~YZbTC;zg?l17VkY>(u>O4>Qos_E?yd$?`AA5~Y*&QBLaDTcw1CGG4#?9up zUFZFcI9nfplW;mGz5cSzgHN;%mg#<9Sg5>)F$@x~^D$h-<@KGgm>HogW`_SZ zazo_5nmAou&%sjDx_{tw$TZFQUpQIHNl%dSf~7X9iYDC?Y)>lqEB_=qxh=3P%Z`yu zbaftlhP^TX0sgWJ7e3d9w9x-|MLWUAmC-rr!cLVGIIjVm4L)5IyHF{X43T5ZH|XpH zzxr({^`^2;()!`QwXp6=M|b`T-DIgZZ>aIVJr6;VE;ng`IDZ;+xT@znpOM=!ifOU6 zgzrr)&W{hrYPu&ZW96q*lIB5IOpw=KGxYx^2Fif)oCKP2HRG|BnTB1Y@TeV(c=KMv zc+#lJJX&~|vTle$i`bggkFb?1{r+bVWqixbTJ{0@ggCfNdk2=#u1SV**=^%!v<}-~ zH~c*%);|sQAb+O&v@r>~q!m=zlKTkyy`4}+F^XWejV2{leXr+X(t6^SqAloxy>ue& zz2kQ>v-ltUdl5-Rkh+hlWL0@^bdVAHE4M1oti7Un5M$s5+YIcup{d>csQG?ZFMr0GKKvFMl0`%6BmB3z$>GR} zzI2nTkLo6eV_o`v^#i0WR9Ax0-(aT7P)^S)!>`Iq^sn+9RfuzKx=0#9{8BL^@%lzc z)eZ)Y=eVG9ov)cvmgAUccQNA(PjW9yZQA{AL-HLi4S058;Bt||^L4H-@1A9=NK3eZ%SV*mDK$Zf&hCZM6QPpEW3UT`mtUk>w%L-Y73P(L_g$0x| zY-%Shg1VNxp~`Ef&ok4Q`=n>tDHK&9emup_%Ua6MV_mNEvMzh7h0Rd7Vk}d=R*SPd zQjW`>nxPVGz*j#lNVcFFIE?=mOTkE~u(`iQS;m5K7v zV1ch#+FtmN+77g0tJz8ou=9)uK!ZN8199a6VuA?HqSIXa1ZGzDR5}%Q3}HsR^bckl zRiqi#tUpef-%KDwQF*~KmH))?7&E-^u*K;sw)7>RV*7K_)w7k|m4A}KP=VOvyMIt+ zTn|-hpn)Hnr0(9aUY^86WXwz>YO1Q)0C<#CQ4TtO`>j<)z|Etf$-r z;zk$x9m%k-w!`{T?pX_~?8bLGZLOrPQ++-qRy{I%D$O7LD89M2v*{zs;88{L&9)Y% zM^s2IjD1G!0;}pu7eOf4cE#{fqoO{zSXt%t&Rl>$$=|(rKO$AXQE2eSL3m`mej)+yxELIiBwK zaLHF?=r6s@TDe4=;aepa+kanpn0wn&%sowNR>TTcZwl}6)5;DUEO>}ci3Bs9@E97@ z``w)wVO^y2>}9uwjb)>Vc`PSA!w9cKtE5|hyl4X?aErlF^Pbn5+$WepEoB#N@LDl~ zYR4F@5|NpcORP5$lc5H(eH4W!-^s5C-cj#g_N+X~+>qSEtzC1HxPSEEps7U4s}hq> zHBBlTMeLEOuNu&XW+?3DaFtKZL%*zk{V3Q@`*pNmEv;y3*NryZBt^LV?~UW^>AL^G zIoN<#d?&P%Io~qY^AOID(Se!9FVl0ADyTlga6f4^kgj7>yEGRzdX9y!+|(XYdUhCc zv47@L6>r|qU^L}-5`VgYg_?NjS&HBonokj&jFID}rgl0l6U-$;K+n7m8U7QiO5jbQ zng4-$)hkf`jWW7yHnf&?>bvnO3##v+ZTT0*t{{W9OAi^gv4~;z>Zag39B>M~yo^5W zf_W6_n9?fO_mU5zohe!u5z_&E2ys`WbPcS&u&deE!#3JWzc z%gkC>zUoIL3!UuO@I9Jd{ll#&0Esk;N#d6M}x(N z++c_14EES{j0g|~;pi^?1p``^H??~n4(#z&i3*6PSW3!fdPvWlPF1yPw$k|+GsjX) z5jvd|SYF1srVZW+oW|I$i`ZSIrl5kfEz{oO7W?X%D(-3jG~pF7sWx%RDz7zZC*NV3 zXo;x5Er0YAj) zRPoKOZPIqrEDLMzBV`SUhtE@F<2Z~{n%TK`d-b39%hhMMunwjNl`M&+bI`@*+s+)Ksm0=?vN7L&%6MXr&f6>XJO-J%2cCjX2)`jS++_~ zCN0o(H1vh5{OfP47nx4NJCvCwx1%@Ia4$QlD)E%Kg?M6>*OcczWMbGexA% z7}wCZ@_N0A&?F-EGt3C1N!qSCV@M?}CG@b{iKz;95X#WR=%%nQ2BYb;P&ngjg}s)k zy2*wH?}wCYn4!Rt)M%H8PE9-_YPEJS-(2}uVje9wSXxGBm82Pout zgZa|q)>-)@%a6DXcps{ky@Ggk6MwGBK4_B>MMGc2qMV%=dtM2jZT)fr7VMxMXT(_1 zCiHBMAnoKx6suJZd`{^}%1wZ6#HB%g7fzH6;bs~u{o~*x^mIwMa-#5)bIotVY4pRC z35MUo#;Qk*qXVbeg@#R;d+Ba`9APhJT9ug(S!3dr*TquhPw=9xOMFgxKYz#f0IjeCq^H*OL zTuis?{)j%pnpR$K`pvV<&e`d;5&|%khH{VZ-Xl{;ZNyE)RDq7|4{N%Z)=}gb!paV% z9MV#GEI6HXTtYbt1N6<9X#xJ1fsGIue|CjD_Ua6y&@WX}#W?otYHUw`D3<=s87#Mj z`Yq#O{7cSnPr0;LlKV=AWM_GKVtny@pJ7~iz053_tB-QC+;-E%`Z@Lfzyal6>RH%j zD21-fqcyXH6+wj({VLle<#~=#?jC8$*MA(0b{;6&U>hs3=t+_UA0Nj|TiMO6f2F(# zV?fww#W7hu9iOd>azc!zz(J@m28hd3*eGRlPlr!q)g!4w0N?R7Y!#ZJg8z{J659OR z;F9v1Cmv^@k62}djrD1?(?O~#Mt5c&RpQ&{N=;xT=Ciw>Q#In(6HwE0#Jy(>P!3el zqSe!tFX5d&#(CF7nN{{VfrE$)fA+GKo_NC(?zyU`(Uv?BMw&Di}UB7XJ3bk+fnb) z#VQXebCVVj-<$KXH7D~7-UPQHsRv%<4)TXXnOAr9gp59U;0(aHd%0ld=l$Y!&7*#U zJV?V>QROlh2A2_|ueo&K-yM;jhceSFkIki@?eL06viOw zh1V;$Vc%WSMO7jC;ctM0e`+&`$2|W4+KU1>>?SsacTMe5Tc{FzU%h~H;A6Kvb1&r# zt(NOb_#6E5%wf^VF5#n!D}{bb3!HA6g!gRGO>UY*9_ycDo%F9Ofp$(xhNO-bZw5Qc zW}D-^TTOk2@x_PaC%DOlz1DkKo2H+MGJV>-lC?79j6}J%A z7W#9H{fu8)oOwg3lHOVh{t$OiA|x`AA$#Dj{1a6zW=}OKEUCK5btUo>-Y#Rd@=)p{ zt{C$uSFd!{a5Ff)=z^$ltMb3Mk5Inoe#V#%$6YZM_op)OqNqq|7Ps-d^sIdZ6EUzx zCR}r`=}-=@B@X9#e|`hT_=FGAn00sWpz#-i9rY$x?=R6nup|8r*R||++3d#6a3a`Y z94+3xXL+G*a&TvjCj^Cp1eG9?{jIvSIV;ZHRf7*9PLNce;yT%XB|k1vVX^Zgz@}L ziUET$#nsY9@HTKOmzqb}UvTb7nNrT#&&j7ME12Ozq-qf?)!59sXgc^>8N%ek8Fsp&-jYYC>*xw7_2my`_T)Vd7ix+(mH z%;_G0<;*O0e~RFP3eP3uQ)Rs=uklXfS7kYdWeujl`INUnVOwGwoATGPzxi`PSzp-H zBz)+54K(7IRaZ09#L?_7lOpvqZfM|D*HvGYD*q<&hN0@IvmL#2Oil4)ZihO`-%>8pkL_`9Il8;%a1ulb$hgoJk=*7sFuU8$g_TXxWrs zGgyAvpIv!9JcpFg19oXU!hfa8q=B#hf(|Hh6!!9mtIVGHmZ|JK%Lr+^vDGb!PJ3Ul zgI$C(fA_3qlD>yH7Abo_dn*0B>;vN0RAA2jehSRiPPgZONtGd0GmM|5-!&i`i4hgc;vu|Kbif4)vp=D=6%bMtS(F8BnI*8jQI zd{yX0RpCtM;6+y-<(;w%i;^k7CcBN!(kvsF7>zTMuHXB;V2^q4nF^BcoRNT&r17$%wve{jiiko;vz{RedZvuw7e+UKDQ{DbT~|k z>Z66F&_?H<`0Q`O{*+j5Y3b*c+el3uf07KFQqULEPx$}*)R>j7knZ@0X(H@X5gOj; z>(TrW92AT&z73ayk8^KBjWnC@py~l=L8P#Y8Obfhxljtm{9E}I-URueuNBwH2y?vV zOm;OC7iWa_5{?l+qgMbW#wyGIS?4Bhdu?=;FPJmvAgYY-l-ZUJ0o>)HTLq>=f zzAA7T(QXklC+i`mi(9LUG?W+qf6>2p?F*(_KAUPUa@<}kTG3aT;cB+=2DQubW;s`q z2maJY;8M|;rR84h-E&Si1^3ocS*9w7V@x?3BdU4gS;5OLVgjt)t65bd z1AL0ezQg`q&X2xg%OuS=RFgw>RmIiz7vwm*h#tpTw;G>!0Ix+#Y*`lbe*%BOE=pG$ zudgqb<1AvGEBVg))l8&1QWu-=K?Hn{=q&t3LnomJAys*fRT(yEs%&FRhA8>m6{Nuq zmpx$H14^_I<-a+pLM#QP+@q|Af2)6s zpD0!}O|;K#Oyq`g7ffTEe^2Yb3+L?TS1>(%l;aW8L_P{oV2 zcS)WEJ8*{gEiJb{f3K;6%ci=O-D%%bE}ws!>R9b3!AFDX)#r^{YFFuE)t>5=+}f;t zRpYrX-x_Bx^zmBrzsWI5zP2-Os5r(w$}+X~DD?7Cz8r3?IYt+2nkcM6%hF?d&@?ev z;F#Q)STjBtL)JCJ=!stTL48lwfo4-fA8bxOU9dYl(>RlBe{;on9>V8os7+Lj^e6dx ztdEsE!1nu&>m2o+6hX-`CHJ_WDI6j6n`5-gx%+H0xUSm7yrIx1Wv~2iwn?5u)j{wD ze8n}_x!i`DPC3TbqJ4^4F3n+A(kYg>5V}-y>gfDyj>*amwVlu!e8G8u@fPfct!gW@ z8T>}Ru1by(e@BU<3iiY6o@h^WS(dS(t|dtct^6A6GulJ887p1#8860vaFMTAYIi7^V7JFaT6quE!QX_gO~Ce|Kv8*DQ? zPNs)>!L!#Aqv?m$btO3;a%+uWvHjjIUya~(J;!ww%xFx2jp=fxIVIMxOK4_#mX-%& z)Wgunv`X2!+}!!KiE0nG7GwA8Wm(o|xV3d9jR|ssugAF~U3PzKJOGzG(MA*6=6AU+ z(?qvHe>;QruS~-!mygjQrk(Ejni)hY6o_tPyrif4S(SOsN#$r-iDf%DVr}@;{=6l| zkxXZmwA;zdf<*tz7zLek8&=zNxro%y66Z(oUERVUPpH^!cN-8vziw+0R3TeT%(|tZ zv9%yR8x4uB^O}yb9ZZzlZhXU|0zW$iGUNpCf2}@OdD}LY84*~Z?_G8x#Cfr?{xW(E zW&LGGGS!a5>nX9WzT#^6VE*!g8SEl3x`r8^z}Up*nCuwhEA`|P{>izu`VER+D6h&c zmM_ZLiHPNYLOwBd$slnq^M#-)%+uelE1?WuO-G%}5=krs^i6r`h^sPaSD!hI@7Pe5 ze?=!aLW7_e&-qH>4Mu@;A(wD)Sq`(?(^>vB@Q7p`e3bEb!IV^M`RB|meot_^F1B%6 zZDL(XS(drhxdSos@uD%HB}DCd&N#EqCF=;)q7^NZwl|nSkKQ#KZC)SLrpT6;@c)ha z@5=sWYOHmoNMKEo1=Y&dibciMOb>S-e=&EX$F#sIw3*rXS`^{Sy48*M)UQQ!vd^%o zW_RHTE)fyOh1!m^`z$fK-aDI+=hIZ>Y(35osrf-S z<;6_AM<(Q>?^Ht`^!%KmFo*m#+MVV2{6985#-D(Ae8-Bqs)|3?tPSyC2jGCMe-}M- zHZV*H{;kLPG`9JG{fC+_fKNV+cNd}0K>7;AjYS+R0sP*WvyHnC`%?j__?}XHLiKVr zzIUmsk8jrB#`PBB8HOJNyWoSu5r}?Lm|lE$0?bDg7HBZ}4~9-vvuM|XGBr{kDcVOF z7sLvMf5}37>_^N|180CcP&lUTd6Y$W=*Y!!#YterdbuIrAtslTK?@kxEf? zayJY)$&qEVgBJrYg;;vde`co3aW5DT)Vyd!>P3>HB?GdrH zB$>Zac-GQM9HaT)o9_#p53Dz~x%Zi;5t~m_JMH?1*nY|oSF@UFf0_r)g{~MVWiFUU zam`Ilp0WD-iuSEJDMpunV^3fETHt(ryP<%IuvW5)RVBu3eje4oc)NqpZ6#M~-9g|_ccoW|_oUP=0bV~Y5Q#kl)+nj1XqvW(M{R1f2Id8W47^Z z8o2AX1*J*iT%2osIFA7;LR{_%rZG6e5=Q(<=snGlVe5j;(3)xr=^;@C#;>^bE~RH? z1TmdjuX)ovoq0OzpMMjfcH`{+^>YIwE6Q!WtL`^c!RAL>b64(B=<^k;! zDY11Wf_d4Af7})9!hv`FbT)hWIzBew3-IpU!yE_Bliae`!}JH+U0-pU^TW<#vqyuG8O3 zl9R2>Zn{VKx|U+keEO~W7MGZrr;O&WOHYC$Z)oyq`y6$;uqiai)Z47l4k;k`XTazrThs3>jfc-Lq8$p3(&3?)&g#1el_*b@;Y-y@5eW~OK@#LqiO>>xUFe5-AF0A-7{3vb_RE?V(H^UBY46JrN z=l#%VDygzKQ)G81=@#Ty7|L~&5v-uf>@_C`o@u}W(>gDXWhk0bpg&H!OD*hQHJ&t~ ze|h`A-~#(xViFad>-WfUtP|0p!^6S0anJit}FO>X*4UZ z>n-VkcZ)aT{qbFyS*$8GX6=%U*-|z}O0(ev`uo?>G8}@lOUA)gSgj z=a`%!wR1U=uHYfh?8Y-`gLF~(722oNV@QP(*K@1%EcbM%dYW>O57YS|j>tw>>`lPg z`VQ<09E3L3s^tB9r4{fcd5M6LE$}J&?2~YY`!xOce_ktP zk?=Rze$vBKZV=2Flf#VvA@+kMs}+=w?0?Hwqv_{A3>;+UfRver?XbdOW@O`Lca3q2 zE>hVI=Me+`9X8S#I^~e-djl=$hpAQ4cA;60k)CC(?n@d7MwcAP+rH8z>HHD7KN$}g zW~H>7+|b2+nm3e*(6RiNrI&Mde@ZKCW4O2Ls@w*{`26LTk-A0v9BH=uq+nL>SC0XQ z(aoO_c4}wH3E_-sc(Z0bw81{u$c)T*7_8hZa9|rNLfX&WupPQ=UB)lnHJ0V-09y%V zmPzaq+5xivx8rv-7P?5UwffM~IPDcg^p&&^1@i^7u#xsr((QrMC9YDme?H7cU6lBg zeFSr1`SXTNqSH~Lf$BrHG3*kC*hgbb>tG||?R%Ab)%PRDn`y|ko0;Kuk-1OMyZTHM zZHI!7S6s79m1hbnCPJPQuIH*gZfha!QO{#?96twrzmDpzB z0Czx$zq52{XVknWe1uV0gXJXy<-aPL+M6bk>P_|WaJ~V~2|j0`h0Pl(1Ji5sNNMm6 zGh7u(CvEsFoxDbV3NDun65n+jEKcraUu&5ewyr8+7bPu_w!#a(+Bt6Tgmj zuzF-rVLT9w){V9}4drfwQb|e)A!IPk;5JQ!&#I5=M#Cnv@VvNqVIL}!DqEx(tiSCTnKFOJnX&G zV5q+x|CYdOPLWl6<3+aunDkN6+>=iy`ZC>dyO2RoR$kbb~4jODHya`_| zU@n9q7H8SNt4CU|v6-HSn7ZP#btO4}$@z>Qo4=gb;HrqWe@9hycG1?-G%3u|qYglu z=lj}Ds@_RjP=EN3RrBE!L<=j>3V)uzTzL*oab1C#a2@+&lI02Pt?f8N+D*?HopmLK z0>f?fNM;(BNV%q>lkXv&R%$CV!dxn?kYlJH0x$7Bsz}7SQyovb?V1Ob=K}jyURMXg zoW{5cHlj7(0XK0~--gRFly&N2Ls3kBFxvL1vDHw%Tz~DDys8AwRc_PwHlBga%nR1p z7zqs*gF)UiGPlZ*%hZ_^4JL{h__2tOd+0RPcf4jd%_ljIS%=Y3d45shb@dqC6ht%% zUzO2Ky6^VsO~-vz<%0wJwCR->bPM?lWm)1284CV_cCc{+wO$peT~ayGZRf^wiIU4` zVtSx7(|;V8DfKGPiB78FFCZ4kQGuEIi*zqu!nUqhz47Vt%X*k@RCy=pD63_-2FOGe7u4T}$v4 z()yC)+=mOUBMuoY>}3>|sYw-lk2(;%D9*(&eL`sLXY$R;ZYGMk57(p4I$LTBt`J_5 zL4P~Aw!^lEtyD(}7!}z?;|9_}z*uzzDSG>gjR7F_ljz2wK^{KAm9>+dhimD!U8KzU zvQhlE%RZ>TjlG~JX0hZ`Neh1EgkYjqR)0rg+;~S?f&HoAp2k)3DX$4WE^feQ`S1GM z7ALNdHjEXg`U8&Tq?CvAB`(Nou^-E|;!XW1NAk++XgRS*j3$2Unv?EMric6iWlPf9 zwQiQ<*6$&XLBVXyHjhGVwU8@=V1mWHN!eld=0t~ZVN%4NWrP$#}1 zDwN&!mmR4P8h;iml`b_@y34=ed!R!dsf?~ZYA9C+>i5}Zpv6)$bvUCH z!5>JqqqdW~Z~bvieBoi@p=M@j{{UC1p2GAjKUO@4es7%6@1Bc3B$CzudbJ;6Q*ITP zNV^g0k;Lk343uTz827XNWEbj9xmBt><7kYPTZmzi_cXI{S256()sgR&9qm z*H^_&u0g+}oq={D#qv_cpY`3ESI{<$t)HSFMS3u3a~9QCYL}Srn16C~2WGB0S@;k1 z62t5h_`{|Le8sl+G88gv7tP-jVIGX1+W)%cgK$h<(f4|W$lxf^cjs2QFW{`Iqgf2^tM3oI z9qKbDGfv!~y&^irKi8X9UeEuywnGM+k=jaEG33(xC%$l-kycS7wiP;RJL*=G!hk6; z{8Wx^;YeVsA*2+P_9X4?(rVZJk*XyFGcBpo_J1M;)xOY`O|z`CaYb*?kD^bm>$SZ{ zpAx?n8Zeq1jB7EDICd>gM>5)9N4jix$#Ll;5#8*CoK^Fc=L}nQv50f_FbYI1JvCFP zmdEa*-J!xl@=j2MYx zhkrQNkQ(fu8WpAoJ#0q7MVy&)1N*RzH?>RnX3KK4K0aI}b!0#4R?`Us^^NHC-l;1g zhJECC#0)xL*p>mMimXrIzCF@TYtN@b5%)B zdgV4m@hz|)5!BmqOh`}OTzrY@YE^lf(SL-WNI!}g4K+aPJe(<-vyiex4FtHUtj3VhR)a3+~&N<=orQW$4cvTJ|pN;@7x4(>?qgJ%8GV z+74piq4i}mW=}QE5*2nc&2s7+&4bWEbt063tN|<9(clmG6cgmQMlD%pLq)k3ZQcE* z2hjd);BSSrS$m4Bu}3xJANg;IT~HMnjL!KBWwY|xn#IIn?D?8%Sj>;|QFSfk>9VKh zxYr-Ii`oe2GFED@Xm5~ysoUW0Y=1DZ#3nSUZZ+T2G)ab%J3_zb1JaRHMpMPL=nSpc zfYgir8T-sw!n~mA$o){?T|Y&$xUNKa12Nq&Z<;Eyw!<>D=uuvyjx@iKU&Lpl#ecr+ zB||Q8`q?Lt)-Pob<2&Zs5K`u6n`||l|8~n z%Bm>1E^bjp7R|0~U;-6~{kPPSFa4wVePy@p)7s9Qbc@9HTb47k0y8mE{4-+8Ptp61 zBR>AX%)nlKFUHj&%!JX{F^r25F~K`DPneO?iu`M9ztctMFQ+{+w8ejy=TKF%;Z?)n z;2py{CZL-_niSOcq~A%||9`}#3ET4irpoior>)sN7cnPt8uZAVPp=Dkxk8{Rh{QiG2TJJC4&sFYyU(s88gB*)_g~XH78xY zbv}8Lp+FUBoPUs+XShe%ZSW&9p5v_wEC{}$ol!O{$H<)r#B?E__-WYNTcqGc^&@4o zbI%&`nzo4>$gVa`s@X%eH)UDH)kRmArO2?-UwB>I5O|3hUcLz94yOjB?Kbp|823-W zRW{c?y>XZfzAD6UTk1WkNd2gS!9{1qo52*)^AVlwi+{F5>l^ra*2e<-_zUE-b|#rMHI}J` zf6UAk6@M$Q3o7+U;^?niEi|BiiF3~txA1YqJCZ%s))FM#Qdj&wdY|(coA!`0TwtF# z7uRgNAvdr9-b;~5T^ljTeJlN>D^PfyOI&uA!+s$gLfBh95_>D8CT*I<-6!5G7;Jk_ zf1926;;B9%5W^v;) z8AiZZMLC*Kz6{D|ym##8+9SddIyIuI0@4BCn<-0^P=^ezK21Ev0Y?i42WD!Q*xu8` z$bUMiH}i{zSc-hh7d15z?m^%G?y7!RBGkEhg-pw&?5Pw(=n-d;`m?AA%uE|(nuVCY zPSas}PCJ8Q?ch1+3tps8W4w6NB5RjuuV9oI_u_pto-)8Y#qXQH7w2Mh(4t+E?m@p0 zsR8mHx`ounm95wZ#dTF=Pi)5KZCuE`m@lT2zgMU>} z{2#n%pJ2XYkpeS=7nyN}S7{F0zbngHc|CZMR4`=-Ud*vrmLme}Lxk9D7x8mWx(>$G zlSp+i+(We;^mJ%Ar`j`w898=CfH+JBSU z8RCYO{tQLU6$?T{Yt+hfi1i-T_t72z+fQCg^NPOPhW%ulp^49V8ry{am*z2-XqzS8 zw4KMfSPY4d5;wliinBDx%BBk3+)sLZ)iGft^6mZS#_&LC#~j& z>2wG3kHQ<2jccDknsnk^n(y`rw11yb_7bh-@-x970yAxU^xdSW^U~Y2b_n@tXCTt@ z+l*+}GGGaK<+z$DzGA{A!bW_;8FU^Qyl9!^x}V|=Lb2IX%VNYizTzN{G2BM=Fn*5k zk}lSNi}nSGn{s8gzFQS3v`d$0-Uen8Iu3lZ+#bAWYr(ZOEoTbe%fX+Z(|=_|cFW1D z3o6?zT>Cht6|)fgt|g8YO}u{^v})5?yXHY$n=_53oGH0K@fv+MQ@3ilpfV&_CRrwl z7-80|g+uCqEv0@RBxoLFP9k=HPgz{=6^>gb+0Fd_!}#&9mJq6-^EVt-j3ya9#wTCm zoPNfWfO9}$dBXC9eiWfx;eQCWQWBlPAM);DW}(HuYH=Yp;k^lg4ct%}%6C)@*G;CL z6`h57q_$9dG%z!?lhchB7j1Fz`@tWCosK6h!-7A^8P&&WE-{Ch$a+)#?W6_1VkK`M zD~=X#!WHqR@?6aq+8Ne+o3_DC*kMa?3?Y3ML?b(x2t+T4sEe!VcYkIOzOs#}QxDU0 zWGFDEnOZii@l3sk>t1ux^K}G7Opkaf;y)v1M*K;RGbC|CYkMq@gg<9`PO9cl815mx zU2!hG7JmKLe-W{!vZ|b&^mAZqu1~v!__5iS*PKKQ+$xx@3q3IKOpnfRi`LKlkqqotrFy;^k_vqJJ+154eijfs1N03;z zTA8@!BPPOV3SJaGu03X)NqW9ak1jH2r|ALptYF9gcJh*$Re#q~q^LgQz8&HS)-4n)>gqW}GQ-1`+}2`Y zSIrl85@M%_l{hS#J|eXv9HCYzn=+#`9f&#)6H}Snj(>I~nwdz?R(+_J)aj=hmZ2BE zDVU*y*{|PiGtyNEyNj))B1-wxmWI%&V=8F}hSk$pMKGFjtAryMw{2|tjG2Z=qBW%W z_^p07eIm@CAFgYsUT&U4yOY6aZx?IR> zwyb^>_tP#%LiklZ838QTJjK}QjpCDJgM*xN!%a0yF~ zQoUm3C8|p#RpP=z_^ff7E*9FV%uSzB{UPb9gT^+)vK*0hC&p|YR9l~00S>0lJ^`^> z9ojy;mbuVAft1_WDIhzB6jx_{K^TRjEP{=ssDF}tiuTXE3A9&9@lNS|)@xq$v!wDx z{BV@B75Y+ZhwwM322^{)Iz<;ntasH%m)%yqL$M3-4teiT)KWH^J0Ip44@WBb7l_q~ z>8;9^o+VxY`}2+Cl!NH3x+J;qu;|PhM0xl8yv($+@6aQOw$apT3(LK%l2SP1IB9$6 zB!9yR8nOvA8!9hZSn%hiXgcyg#z^)rh?+0e-&UTZJ*HZY){`!lZ3^rKh2hoO4&e=& zy}n}O2DBdg(0A*T6PP#5qw-n}Bz-J~vz;5OemC;T0rI*o$tOKv*W!SK?)mLnqNZf1G?}!Pzn&$*|RUfTB z$``}I>Z1|!@VW<06ElppjPk$n=gjVMQ5 zcWXUzV=^YQiM}58Z@~yU<25}SQlei#3QeS!h*4ua&3ju5Vjg#j3fDb%*VPu|91m-+ zXG*rz`8f7+{<_et%(9zm6&U>9W= zi3^o#GNF?h6#73CtccVO$#M11N=o!MFXs9n-xUMPi>pKa!2!B_57{Ab)PHs&N>YhS znJTy)%76bHTR5;sKET-gpZ%Nb<4=IU(EzF9HXO@7^uevr0)N9*|0$fK)wAX#KHF`o z3P8N{I^OHQpyM}w>+Y*lpWTE{U~eeuzXYAwf-}E)&)4u{a$ok;ia*nt{?a#0bzDwx z5Nu68jo1GOy;mRJ???Z7wtpXbVJjSf4wjhiS{=!76|YN&-RTx2i~Xm;(Pl3 znc?sY>p3wOY~-)Q;sz77R#54t;Cpr0wob$qTj6awgMx4H3j6S>ufleG@^@elu5;2L zxD0RNy}p1hZ0&x0;_eU=)H&EzHXDeGzaky*YAvA(h(2u1-+`(DHhs?&vprR zF(;WhHD6@j%gW41{PaG&(q)LJTu3+_YC#X)w-q+SQM}si(B6F)KIO;Q{?FlTh;!{N zod>U^#lQ8zyZDLY@P7vO*(Pqw+Edte`uP$Zrrc9pYp3xuN3oyU@M@og`uk0M^{n5ns7NigMUn=YQc9yxWf@ z|G!@%D|qb(+kd9X%$ak3&vU-t-|q(UIdkuidWXOUWOZWI0^P~R+Omx`_0lut4jE?N z(MKhz1!66Gzu_3x@H3ouFJU_h-P#}c)?f0zrXu*q(jCp?ivO9f zLf@ntLo`@P6}=B!{~=Rp#U)1{vDy+#hk@N*f{`9$%zx-*yV+r438F`YAM6)Ea0!Y@rB-9KTEhq6}d(bYrY;)B@j_>F8Bki+i{STeZjm)H5U`fLGC$5 zvsiUWNi@tUiqAZlImEYwthM-%sqU5QjxsjAlYg3@)n}Q_4^k>>2Is*T3VfF%$k`Ho z9K--g-WPZ|9Z^v0e$70sdCe)>mgpu4=bU25K+OmlxVhw-KPFPSWU;+}jbq(;ve;AC ze3rqAUulZum}5{OHjthbt$e5{vG?Qqy#-W^w>X9-uj%4+W12NwZ|0S{L;CkX%d?u3 zihp)yKPF!Vd!=LECmj%*VFkQmJ`S%9`lQcuBf8uDI5`V*0e2x9c9=57P^F8DzT1%Q zsiWib+^#ewmWruAso)4Bqlu0MM`G^>xlZvd@fLHRVGTi&mD!|BiQ>xPIy%IZyIT;0 zE`5#n&1Uhwy3x`OUhRIILoGZWGmQ$6n}4B;{BG_t#0GafFW>Xa^O6cW9xK*T!|}3E70>&wi}oDA^W_uU`-A@w(gua(@EP z6Qm-uvyb+`b0JdeLz3^n{-9kTNyT7q5SeuvJH)WNz~jduvxk?tcG52G$a8~TIZRGT zv%wC5wXsgp|D(yUvJmHjT$HcNk9*&Vna`McL_puv#KM|Hp1)bsa6*Yyrodfb_6kkp ztkj20d9XI{uiz2*|EuQdWledOJbw$hS$8OVGVx~)Vzr#+E#~Rk_graC5&U?mX5<>k z5%s^NM$(Y^knZNR@}cJL+G6l()`(85Fg(R}+Y<9E)JU^S6Wj6|ko$Km-w8!!D&0hX ziJM@LLhxuu(c-daF@nGzCf=R;fbK9x6WWKviRw0gQZQa@vb*vunbRqsZ-0q1xjs%# zDa-IDm3@T$Y^fyIVdaK(lKT(-QJMqHpnn$jsz6j4b{8QZvFmxbwq+*vYscEd;;RLZ zEL|Gd%B-m^RBn_G^B*SG##%XrKMQukDuof@>3&pBq0^cMY=2bLQXyoo2e2x!EivN^ zciA>Gn1K98VrAE}len4wSbwsmbVvEE<$Gu$__#bO_tElu4X^MmSWkvNpL<&KP<>qR zo^l5x8K1~JsCd>*%bYIW>+2+*`gd)Kj=tJVzQsQ)!&o$nN|IA@o7ovPwZ0_{HsL<{ zJa)wk-jh9%?asVv|56@RvYM`?zFgC8zUVU|&b54K$?DKFIVJNdGJiDLVW{=lo#axU zg)5{+f#g3ZUk!c0NHDW0>2$4w&kVVgSg|x@kov?X|K#AaFqR725^5$ql?uD1g3N&) zH4T8DO65Psic83sF51~}6#33_lm2;RG6xf)8mODdwMSPn$~#t0g1>qLJl#LZXY|Gu zX=NYPU0}QOM$)u@EPr*Qd6tsU=ukdsI6?RL*SHRwU0Hp>grc4Hvy7xZ3clkxO^G_Z z{36|NdW)*1PUW7q#<6D`Ytwf-`s{AL#g>RM0N=uH0P84;_fo^N`g}`#9N!|0(u`!g zjsK}Ml@60S;C(kqpY*q!1e7^nrzW5dmk!e#*s&g~KbCKC9e*b8DL34Ipapd}(*$cU zXQhUCT!(YhsZr#;+|wu(QfW}bZgBL4Zg{rRv}2Al*|?Bi4-r~NLz<5(H0AxSu)vwz zSQ|JOjXeEIf;jya2;=S~F_vgWT1QD(_j2-JO4qXW5k^%AF z@;AvhBC*V5XMcJ=rf&E;xiO&&HN9-Hl&b_A(wfCQ8_eOiCB+~o??u>h1BUXzK}{@N z?_$|O_k9)5MrQ*w{}MMQ!YbJTIY+hOLH2pb)&|IV>QvtET7FYIo<8qSR=;h&Sa*Tk zgv{)5zJ>00UV*!OSf=5+q+H!Z{hu1v>YGr?>ekp2m48o)`uLW>8Gkd)86LFEt-nHg zxiS8IwT1p4$tCyqwwYy3)~OB0T7F}A(0!j3<`eWIHuQmPFF3HQ(k4keOu2>!vj@sP zV!QpXGg8GxLo+wDumdfD;X&UmeG#nS1h;GrmY1f}dB1b?l@2rIDr$Wb@l&TN9pN_L z9MpG|=zoGonlqPGmi*YfBy&2uUP;i5}6O zZ)kMTf-9e*reU5r3jTu*FmiTumKZzN``=gLp=A9jBI!&tL}mxcMR7c*`tN!WM7pfb$C&Lm=!nC^HSYvr@+u}&Vu5$izTKP8*#jn3qf zALUWDnd-Nx;Vne|iTpED%snlCU$;$uT(~cI4>M?)tBLj9@^!jpx}TZv|BuiIRp!bg z{(on4|DXS$ErD4mjA8~E@NhM~x&LqV8vkKsyg3Eld2|`rNH=7WdT!;@)Ns$oNI8zA5B~{!E zE@uXVkK6mD)r@3#$`k?#O#|K7io8kR5}ZBxC$6j9;g&TAY&wwMrT?cYsuJxEA?2EC zo%N*5znUFJ4QDqHE;x-yx$kj9h)H*tc&H*$WqpF=LL`?GIp^@Dplyo~*ng=JWw zig@WX;e2{8v4-kQZ+W)5rn%!Sb9EE7wb`xwATm&t1myo4REh`ht})(@7k^1Q_>V}G zCiO*Q2#BCku{w4%O3J)K3w4Jezt|%cVzmi~jI6|#*+i;rUwaFRcG?nbf2?VV>|J2w z196XECIzr|$1HO(ii8N~6664jF+$Y;Ho_A84C{_cGDPWcXC z4>6}mbU`YZfSoP)mxU`OtAAS!$dR?pG>>)1`^S+t0%u5vmK0baraF#RnU~cKY)9_> zh6nvgWWT;C)ay?-caxrm6Ct&EI%Fq(8E4!}7&9}dYznmHKZ@9P-yD;l_K138%8X?RMJlmvt7cJ1)UZ1iHadXU~4kYdH`aoi8I zfctsb6S*t;*|>ivKfd-`umLCJtIflxT7R^1(I!JV#6X9aKZ5F7nz$B6 z$Uv?s3Ap>;1fHyHV_62owbq}#ZLQR|rpLWRPElgG5i2MCaQ>Rp)-MgI zTTZ#2mI|#e6?QQ5$bU9>Jmwz_$24(_S^r+>M*gF&wDJc@w`N7?Ld8WoP5q?yY|}t< z8h%bH1Rn-7EtcXZ+^-uNb5B#7rDp=~(LMA=W{~?7{CAsm5_V|8s_MptHNDvr3p>c` z4aXWc8RobygKqE3xRr6mbs2o*-|3C&C*ASp?%XZRLU|UOrhogLE*`Q-wVYCMss04S z7weQ5VVL9FtWo@6Fo7ErZX-J5EPtEfDPlFrFhkoQu+V8!FACa+^N1Lt`~82%JzeuddprV zmg4Hr``j1F7k^C#WdprYm?K}sn%?S1scyd?dT~LVpqXkxBkF{Gj3Cj9boGWgnsU zvmIVKET&UIySCBzNFJa_9Ab_DQ5K(UK}D7vc*{E5^WgRuGG9! zkk#lL9ez&!=z zy0vVlz27OC+aWJ+%$!cgQ%Po*e7$%#SrVztV$E~gt9)GXZhMM;Hbl{t*wF|g>r#{K zav`^aq`<$s_^NoSo7JPwV;=(x{R2tI-t&<4eL`%n>{TX{RoNS8#<->7hmyFQ}Nx z%R;>26K<*WqA8c{Q6_upqP=UJ>e69ZdlWk3R_%D#x$NGo`$MZ-{|nD>Tz-J=$?9Vk zIrl45`L~=Wm}+i}Wdx_y1VWRk1K9sh+lAaVJj?RFY8kNP$@9eJ;A?lezCacwo_{At z&I=gy{aB4p7#;5PX~oCHmmFJbk;1E$CCZ)X`)p-Jv&lwo-d&Ui-gAU+JGm zJPT7zt<+5}dt9DC%@;;nhqj!`x_?#Uk@}RCoYrxn{#L^Y{wFFGG7y|;i+B5 zSTas4MN99&j(CMrk-rgmUYL!jBu8IE7oMpX{I;=%-)u`nY!Wpe&tDLk@BX~?^x@$Zz3N2|5 z>__ehR#atY@S80YkVAr~1ao`C5oIMKAr1yIvt*%2Y2sTEa}?N5cEa68QH`L<0bDu6 zUsAou13~TqGC>rk`Y73=mVa#1K>EJUS9$6f7_&S|i4&JQ64I+s)_mQrQB4^kH)g8d zSkwmHBxZT2Qx6)VCAMU`zdS>kN^Qri8yPE6G#BDfkWmsch(ll`)>>KHMK(8d1utfe zs`;w=Dbhu&h51xtG2AtC2)`TR$f1qv?ETnR6tVSLJ+N-Q%sk;5vVTbATZlvV?&MmF z6}nfMEL_2{3q{($G)>e8bYXD``&#qqV0=TDSn1zDs<^}K!O)9TmVTTt8kq{|3(V64 zyQo0^dwC^!r$QH~80wI2qVP_`iL9@pD14=ev2b&R0$Vb&r1Bv)TI09r@I((r)`s1? zgrbHc;K%hK@6KAec7Hsgm&tL<2(qp2D0$W3X{;^XA@x;Uk~+v`u>Y!@@$OXYP(>Z! zn{*46@rYpM4rgy*Cd>1bv95Ek>^0@F2kCxIpg?2#W07A!j{0+U>&m&Z$}-Tp#?glr zCXu_Xo5AHtoaeQupVEr=qyppo;8r zeoa1VEdQBda~K&m$^b~$4r*j@F+_SFG+(x_EWKCiE1PPVBMz|Of1-ro+v6d z7|+Y}c{~xvv+%;H$eVGcaayrNP$_Y1F6*nsx0-KSSAVMGIFRC++9(QdSzftlBg*@s z$=sKaU+wVJc?)bzb1a_BHxJ8ZgI%FI0a(bWL#lo~Aa=io_D1QLLh3f+|F==Z&;xXo+PS>VU8nS@y_R;CjQM z=;y1OtbaXX6L-a5h}x@N%zYTu17km1OtlH4#VT_+dJE9&B7b)Z@ss}R%yQ&}Ax{i#F4ef^GBP48 z6QYcW{1KXx!1MfWGMh%xoi7UAQ^WNqp z>(CrKW6o|R>GX_(Wx;9sjz)*QOh3-Qf&ZWN1@b(uP!sUSmQnlpj}VMWyBPG;!wy?fq7)%(Mt>9M z(^7F+-(iMs7*1+%jk9{{j#{4)TWr&mr26$RPGknIw5}B9G|z&$PiD*nbkTf86Q_sy zw9M9jhG@y+{}hT$dDH>1QkiO;NA=31=pJ7;xmd7_9}Mh5jHUh@*4uN=rs8yys5XC| z@dd*tIA_ctMgq!8Whyr|(z$^#&wpr6SBj`OZXTnujKHp9s3jbDQhv}=XD?$XVf71G z{hzrSQJx0xqyHsrEIG#yHW{J}KavXba*ZsZ4lqY7sfag(8105d2H!aXwXose>;x@up(-cSflJ!Zj5#`o)r48YaRd(^eytF zY{c$DJ|nNjC$PMMd?|~NucG3DoN1q+x|1;_Y)xOFZz|B|xrJ*DU79$IJKUcmS`}9o z(W=N3Azf4wxdHa+8aWIrHh%$TJei8KW`qoUGw#6fvf(M+M8p{(JA@h+yolVu8jtHW zVKjM7dD$|T8)KWvT@5GdBcmnx&0DJ5sO{WLSag*;2D@aE*O~@2S3PyBe@D(r;Yio6 z!(2A$#%{$WwT3y!xI$*2KM!YH6OdiDWc}OnDD>yj4yVXxQ33gZ^nWTmSEJ(0(_LSv zOUuBnR}Qi1%$t~bc_X9f^7I8_DaIG_sKA2E>FPLdELgHeL@h<<1-zF&iY`yDLb;$o zZi0W&rrhQVW}Qi|qJ{iS)KfuaOZIiAb9lySBZ2+M3WYf3%dAlfv!>mwhn1UeZU<|l z3C3e=2XT3#{d=(_f`3(4ExngbGs!lRuY&C93vR6IHQf|WYu5kF6N@mPl=p>=!Zn(H zsV_4ItozHF*oLmmrGlz)9n}~`xeM38kE?~*^(UF#=Dq4TCDE*hHU1g*j@B2k?_?#s zM}^2$-5A3R+q2l`A!}6qH(7t;*bn#Lg!S2BMiPYCN}@OgarTIC=XaykQ^!^R$!Wau^(A!g;ULklmVqEomI?k&J9sA^He5&2(;;zwSkJbysbh-QXN`FJ=?&FAKcC6E=2 zUR%z6N&Ok^m$P0OD0Wf-vIFghvBL8=#7y7G!lSNcexr-W-;vG6A3-d9=F%pEx-`OH zod$7ggn5T^Wk?gQm8s-g;9rl3VC67Y);*p7D0sA-rh$eNa7U0RwnwD@DyRwJ7k>^=h)Yk!&|NquI0xU>EQJArH=o3#Y_!)1%2 z79JUTOttylC`(Uh*B3T#;cM8m%;}a1HMLP}`)xdVO|4n)x=d|XONf=Uf#rrdm4iRn zk`2wxnLl&VM)CXX-{ zWq(T8l1Z0lB>df0WwQ}a9W}h9W?dwg_8r5$WhyS?G)A;sZ*y#97X!Q$@&jPh*Tm)E zE9PQkg>gHq!LWuSrd;ILL|MDYNv+H*sm1ukom&1|L;~tN3=b+(9SPCuTFm5EnzDbV z39M;{eEZAtoXQ~u%c$6(Cd%OTZxDv9w0}@DAZ~x3F+2BTB?sRv$G65U(+- z*(?OTJB`9^)<>jQl&W!)MG%T!`Iz{TKQ0b&r=~wszk}`pUq7E5C*KO!3SS4GG^iPg zy~7YQf@3b2O3f&ml?Su1wwylSati;#4>HvXlUa%W&>uk7pYjv-C{Y;YG2?xX1b=N8 zbKd@er_KryGj;&hZa=p=?wIr|w*;iaLVoq^%;t=jj;XE=e9DVsup!KBBdkc_dq9ob~vP_U; zVt&^#fb}&{Pmo_CY(#z!GECSBLVwZPLB0_=wNBCbB{c$~htW}<30f;;*hbhSe_`*( zDDdYh3gd$D$dT0kebv1W!8u5{o|0LE+REwm}kKMJ$`u@Ff`cnPQnx0xoO=LuY^S&ua!Zhx~)u=fpW ztFRF?V}3&y@=T0lkj-kDfDtO5`XFUO zznrK{<>kEW(qSOQ=Rpp8xqs{8y;%dO73S%Xk?aTCHHB(K&WW{Li8ZJo8rxjWi@gaJ8Es*W2Y==w!hMR$9qCrb zNnaxi7Cf+u9ft7-MjFV>7AwJyd=%uc7dA3TRx~1qL>-sa(=?!c804Y}JrHt9Am`nV zoiD@^Wd3IkA?TA{7E6##lGTGu66`<#-Zn9`AGsso_1+cl4f&Krb^>xoq`o`ZBUBdd zg6KapPbWLFdXy=`Mt^a+GQ}|fcl%ax=w;-SM42K=A~HqT3Ax90lZ1_2Z=`-kM81&~ zQu8t9#kOe>*Y9)OV@nABAoVp(w2aLf6>hVa3D@9y|BUP*c0siIGdJWm46e&LBUmXn;@ED>^sd=uD4#gNU+ z28co-%Os!aO32O7G;v#mH*v=vGj+gIr~3o$2paG6Z(w_}H-y~j3xZwQHnoKP)bxeb z+Z+j@Ray53HGk}S=YDP}U#}m>%i;s1f_xcR>^UjB==0=N;^FV8Bv*fu;GOENPcXZp z_3cQ$LQ^p%+18VLF_60vWfeQjHLioKeX}-&Yjvk)E^XWd zG2DlN=fxrBP3So@L1)vsY@7Ex{{||?xu0mMdn4HMBY%VmJTL7Cce+n_>Z08_vwDiG zj8ypvNqgm}dAjs^!PI84?hr)iRm6(8zZIWyV+>Cr%NKh+L^1~OmjcYUc#(?_1U&?800ccm+)%31Utd98}Jos9)8DH zqrXSL$Qj*2-9kM1E**v^;GSy2!~g5>tKo>J4u9`~H4ZhgcuH)37jjSaufMP!E3Y;g zc(vOW9S4p=c^QAht5_V-J9C$Hqm`GuJ1Z~a$k+|aOE?b56yRrk6@Mev=;-l^xT<86 ze3LtZV~m_qx8u6%CxpYsEs>GYrNfL{Dr*{!G#o*Dm@^*l7#)*XiT94a4>AyV2k2~@ zQ-8ekq)0kuNfoYPrIqXr)JuU~?!V`Z4}EagS<)Rp<8}2%Yz;7jlZc90xb}7N8R_-v zFJb-Dh+Zke`mCgoSJ$7kK0zAHdUzV-C@lnC%Z{MZ{X`pibu;KSe5V>ojqkt7O2muT zZ8MG~H3bJE*!3!+4L{(vDT%HW@89%X{eL$!L^jT3BJ*mo$-5J-up~%1`f6H8TICVQ z1$VGS|6BR0`t4OF66xeXia-kKNDbDN(UHKcv_{bBsrVa?EGi4ZzYr7rmXEckKvLfa zU1cEuO~;X&$MWjNbp$Ku*AP|dFp}o_U-N}Xr+36&fOH$0JJ&1??%)`u@_!oY zRMB&~eBwov7d+FsNWEO_ijo1JUWtfTb_2}UipaH>fGx^{zh;ny;tZ@-Pre{ll>E$Z zxa&4T3(Q<*K6nSKQQ+0~DkU)(Iq?vRviieqnmFfd*JWmq7#Z*?>@aqMCN?;X+RRAW z|Kg59&i5nrM3bm_z`p^WrW|D9A%Btsu}q)3lpM#IfbVI9Xu%*0K%}HY ztYO_D$c?PQ_#oE6Sf`tU@7GD{(s0Q84&?TU#9H0vI;SpeTnCx;YySorC9FpNdB&N#ZR{}11hC%&(NRVvBKq~St>}(wAb8QK z9A~^wDPmi76B)$K1hD!J*?)w8!MijZffy{=r>%JnYgfWZQX~A{Wu7{iM>qFn_GGdE z5x_*nUG|qi#2beQV7P-XbWtvCJXqHN@e-^IIf~UY&~AXHtgICRUlr$(^f3H~nv43& ztFbRktxT-CiKe5r|KL8uS}TzI_Y_XW6TiZ#mCx16n89H7NX>_+VSlo*-}@b&IWd!U z6SYZ}JYFqz$SEYN^j>O@e6{XS^RQq7`5?lT`J8-_aYp@jX=bFa#*e1A>@NLQuFIW5 z_Ce-@6;yNKT`Esq#+h)ZZlZOP^tC%RI6CWlzFykF|5To_qU3HY4|2FblP=+E`iz>u z-8~AWufgh)>C0~-+gVv$qa#Jqdqnl{|9x|Xs+*P*6 zk-)cl3#c}COyENL0{MEQL*E{HKXgfdE?@IpAL4?S0@^#B8-S6oB2(JjF4dcq&cz<@&Nw6IYu}&wl?ZTZw zF5?!Sq=q{q81ex2Zh-uL1T#6b3gVS>LC*d?o+rDf=-k?*$|2qY>@#6YHsyllqarmw z7m$ioRODXp1?vZqLPW|LoHYX3E!YAT@oQ_dC(1vO`ofOrJ4t=jBC^u^d*l;FxKd~< z{N{IsE8%ecyMGn&(hcI9b{X~Y>u*zu#@iPnY%m>dgSso)+nDeTj z#?j}FQHppOd_fE~KieYhSU!Z$(oHna0Bt~$zwmx1y%^*?Tk$F6@44&DWMuYX|F;@X zV>$T5eNHibfvr>fFxP^)8bsK;@$?MqU*Wz5_Lt-OsMqTn)xsKMI}f$wO#!v zyAGmq;?`ytNreZ}_Dz4#(a~4U_1gt~d<0^;n`(S1|bnzw`^ar$`{YW@R z#aKq@$2k&wJTpJ^eqcXc;{DD#iO~6za4)t#jaw?*FFz3K^mV(wXk9~XcMr|#qx;>D z1l};6;@8V15Cf(!(8Ri)CMghiuPhbGnNVk7 zaaNzV-Tirx^Tt+O!m4Ui5=eJScB}n+-5+x7Y)`Sy@F4PEtk2XPLIx-4UR&OBD&tn@ zhBCGEUa}7~e`RqN>0qi~`kvf?JggI|bLZ==Lo0tS>Gq04a3_H*P?tt3ofVMd#_G@w zY9zIpiZkWfS29JI&$~Zgn~MJ`dV?29xA6t45qCy0BZP?5YKiPjE05)jH#A#=)SpS0 zu^R0gRqh21quQ)P*Z8qNbwjUi5|soom7)w}sT~9Ka4JR^ZJV}wrf|(X9jj!#)aR+o zf4G0)Ln^>d@VAjvtfLCvb5-8&V2u072idQw|E@RqlZgUzRz<}W?jdLGRoDlJtYee? zZN4Q`fNW~q$cOT-_4CP=Rfu~!;WOqQGffj7;(yFdhwPrq>Q_H0K7)OPDlX9! zv6@a&BN4qPy?|UHh%~C;4%T2EA{Ke<_Q_Y2;w+Xk#;Vm$kFmQOMYa+?0P=amH<|uH}E#Iu;LOaU?0;Rrec&B>=O@maT!<> zqb;AT)ptT9#FP*9jzT^I_!fQrNqRk4^j`29X?`)>=1wiki1f(1fE*xmJ7h*$s+NE3 zH8hf=V>C#c3B=t@n6TT5^(p52+#hGF@kmNKp8cUmHMI`dO!*w9w;BmETnu`C#rC2 z;9k$yF`+)P8c|9XVW`2k-;-;>oBRPnoSGf?dP+-LH2$k(iV z939Vn3X-G`YKYaq>1Sh4B$%OH5!T`*@YwsvX_5*ftC2b&nuGV*tMpF!N}hiOtLzdZ z)*8c}H--m`^Rhe11$a$HKf|VF4B%LT7kx|W4tf8}z=3DRzK?6k4ssmwfGxOgcrCKY zc>*Fy`F5>keZV=}yA$&4s&WT0Hg6%z+^M15kY974x((L#3^~uuBqt#z{g!mYtgQuq zXEi((>9&Bir3+yNwQFF8@JWBUAMTtXTVior`OuOn=7-qlnumczd=|KAuVR+-gVapv z#SEi9K&Np>Vb%t~%O4l6kuJ2?SbG!fW+8Q;fel{7Uhr5S2lP0;b*92tS5h&pYb4rq zQfO;n>pq6xkey#-)FNukoz>V+^M}#?3^$g;-f}iQi39qZOXP_djc|0&lOw4wb=MkPGkN)!54{uz|eZ zWPogTiT%rr0rkUJ=Uq1`yOWNO_I(d_Vg07&Ex|5+cSBb}d$fXwvWV!*9l>~zKt24c z6xy3%hGZ4I^E4uu@jQRh_(JHa_%_QU>bf${Q@1L~IE(HNhZR~bP)pRk*a6;@%YJ14 z9z6R``f+?cx0F85%dhMuXSx3tu7utvt8CB0n89vqlO%J?sRovclXmFOVQ)+BaB-gW zVs%@{onA%gwW$q9kqIB|KcJiFwD`32d911v?nI;pqT;|4MLK^^M`{VwdfSmLC_YnO z11oX>p2W{x;RMfCO@LWMv^j5rG+@p2j!3Ms1ZE{IqT{IXT9O8u=^-9hA6cgq@PDkW}dF3e3$uB(*WqH zJ{m)ThE+E#C+~l``XJ62D)lYDTs}1So+8C`vT>cZR+-{|bNO`85u?=Ca>|`T)#^vD zo90fXVrVXuYdaX&uOvX$)tQrEuPQs}#xCP)goVLrB(>suux!}>I#MMwn2z{Lw98<1 zI>^BYgZMOgm2}$*$!nmw-;&J@N8K^DC1}O`B1tRnqWgb!@wf}*wCG1m4y=}=g-9j) zEUa}qJkzy?F6t%s-!aP3jCZGI+o%!J4(b4#rnw4{P6DDLnhX$4uTtV{&-!XZFUm=h zY~G8J7o(y}mS>^g#Ln}CW6ac_^?BK?=CEZzdNH($wYtNXBX3E!|{xl2k(l=<`B6 zUyrc_vncew?zgzBrish3+x|%1E6&iLYjiNC;0opl;$bQ86C`F7p+XB*gu}l?ZTSoEy z%%JIH&=a-A{uuc>Ed-Z0pB2*UE|h8NuORP+*lNCFhmjOm^>)8Z-iI|tzUQYAhWlp! zWITTj=RRd8p(kmqr8djoFWX*s$ajm8z|-Bdmyy@}<9rL;Da>R&N7B@7Vug|bHoc3y z2eNXW+;q<3lG*1B=_twab@SNDMY^A)KKCC?C(&LS`|bVsWMxw$$d6692TZK?)25So z7R>?81Cb7{Mv~TiFT?}K#lOla*wa{K9*yNTYX6HT4vZfGv)63BI6tpw$rb?3%)s zEfM5>s^KZ@xd5K&pO8B;VDrBv{`z;Z_cAepPXUXITn^1cSlKZ60~MnW)LlRi1@nK{ z1~K9ZAsuECcM-iL*Dxd8DYWY*Le}*Gypj)^)C0QTp7mATA#MQfe~H`_htzn;7Wd~6 zxff|ls2J;E#BOPmaPP3OyqV&&h@YK74n%Cr672mT6yeD@?sf#Tvy4F8r(=MrCfa|(sfZj4Y!geGW5KSakbHiS-%R`sCqNfV=pJhv zHJt6%O<{m+l>xE z1f3=24#OPoOYq}kWSxJ!PDs1%9*CCze8-pdx9A1_BF}R-4IoM|k{4v-+Bs zfDOG#dK=e?rI9)UH^~-Q)xSn~d;iqLBJaa=QkkM1G(1HmY0kTzcFPdySv}U$VepXdK|t+arZlJXJ13%|ExO*@j> zaDuV8KlT=rfAC>)(;w?^YaYt|(0Izf#*qt8_fOkQ_k9JAG}h*xUREjXaE)+{V7nbT z=`^=E&%*wL^s2-8lQe$^j8E__29@Cz`Z46gRCvHXY$os7Q_580W0_aO!`-Q58AL`q zHRs7;a?`h@`cHx98&3GgW-g6%I_s|SP%27gKW$%W>?iw5hq3=qmoieGW!*IDaAASw zK%OP@*@mOi>V^~SdSO2MBzcdjtquHNSTy{E2VnI;bAbS37g?kTvJQ`Jv4 zVXe-}IO6ejt0jIr*r|8;-PpUJi4AwAbMCQNX9ue{D^q>lrE%tus<%aW5H$B?!LafS zvX{@w=p{LttC4@c+g84wnJ>OgH&{j(x3E28r7&8e_2W#rkbAF^A6T2JZ?}!Bl^wrt zbhwXIw-Jv%52Qhh9JXM*WkgmVyP8U}__%rcJoW|5_6;gT%R@GP1ftJmWh&&&6`I*K zp3v#Waw?|f6nV!aBZ`pIYDRjthHilN2b9G87pfL%AEtjstoVDT#=DcxHU8d~T)lEl zd)~c(MwBMWK|D^;yAw3=6H-!sk1d&(sU*1fT%q8|U5OY@NX1V}q_ zR_>|=s&YQKSo#w0yGiR~@FXS89JgS%CW?jybqnpE*6SSL)N8ZyLx+SaGAc zjc9W3=Qm>xXPA>c(fb0`%Uyxov7l^GkSqB%ut6EgrePHnc5GuUce&)pic3*e5IkSF z;g~-bZ1YgIgKsscf{(D>Of~j)F5STg?!UPum%%w-yP->a!mZf>=Uy5k(hsX zDpN^2frym5e7jG!HMVR~ah|!GnP*F+YhgB1n}--wQioUyu}KfV89zzKBXcAeZ+1bZ z`ZmAYmP`xb&J{O&T5e2DZO(YlW~}7moQ+*yqnWOdUbbl2c04D?)wRtGeGoWPafud) zM2&&#+K9ELH_yvH#~9r&WOv$KysUp2$*%YDAn#rLcI288n%#>178YYS zKiy%73eO`K5Al)YpO8nY$PIFkTj+1Z&tO+!jIHozc{}bIFxABiF~(9Pyc&OULnE=4 zQS*RqwDWMx3shFjv)o+rDa2!kFai?JDY3yW(81R&b0d4dekBq24{gb7i@jQki!+U$1^LqCqKo4sv%>#u<=IpD8Z{)>ph?PWe@}y#*kD zm73T!?a_DtN;((h>v?tEA@6?+@O^jiV#tr(4ni<4@ZBnHZTV1p6_r#|L28_{v9Gn> z$;9MYz=pgHdeSY7#!ft>fE*$V{Nu1Twf;SPKScK@{{8a@?0U;g@CUNCR!ivk!h#HA zVZpEZ3HxE}((My?aR&1?snimbM=e=%IaJ5>TAvX{GYfO?FCS`{V}5_gy@X22oX-A_ z|2O_v-x6DbzZv_qTVu`L)opBtL6u=_=+P4Ql8^!Gz>yq&(7C^En|(V;gQxiCowF0v z1TQwHLFAr-&kFH-H^$#6@s^neRp20EI*m^-3n6EPtdV@%xQULZ?;&qcwT=PrWchlb zNl@k9Llz68AsdY7550d8yf}7>E5wT2nghjo%skXv+f4Z?l|=dQ+H^b<#_lrqezusr zk=+^nBz_8XZ)b5Hp4oAil?2F3Q|Wm5y3~QvE~u0dB;7_LOouCw!HE^&St>yox&e~l)+wQIq1iF84_q%zJ7qFu4H^UF8 z-;SJIEQ_pLwaa7L6HF%(W`BWgzwSVfHqdkuBI7E)g&S%=P4qbl>@v(H(biPARealU zjDGBw6A_vNUqlm%q=JX^=j&HoXQZY9Wdmd#SXJusUAu=1?>I@(VntA)9U|9XUduPA zKxZmRR&ky)89sj(t$vqFWNG$Y&kkdxM)1w~lh7K6{M;2{H+LI9UU5U?_P^p6)lZ^~ zFoX6gX|?fVeYM_M-NtQ!=gouc0`b=ndHu)lV81a**-bs~R_P zGow~E%HAa@N*tZG;yT0yGf>80oeQn8ViI>HcnfAqT& zA9J_VQQf9JTecB$6%E;yz97^a^gwL6&t7KhtQ`*?qL!N(t*~lbh}=?jY5pYiG4gfv zvBEN}ux0MnJDY|>7V+O)E9z|iqf!`U-yiELF#;<>fQ2HDL2i7dzh#8T$ozw*B3ANhYlQd$4*ns!FwdO?0n5leZO&PaXo zbt>fV^pvr|i`8wm zL|DC7!)=yQ<7EFh;}f(XHWhXRmutIj`&RBVqCv|*&D0z~uWp-(>}vF*mbp%2!!bc3 zsmp)&Fx9qvse=#DbarR)ZuvTO%C{tXKdzTurl`%`4adMIB*2p{xNG!s1n*FTa{jY? z-}%>EvOxT6v?nF_IIQ7z=U+bsy}CVP1;lH46Jqj8m|;~EBTKkQ$9L?~%jg4^H`!(8 z>D6s3UL*(cikkCWZ~4%&MQ*hOF@n$7JQRO)U?DMbW3u|$=crTmDxc9GOPGvX5Vf!< zYfU<`0Q+p>r^`0#M@M>IT)?Oee2agT34X^Ozj}zKKsq#m>NcNId=)!2N`=V1ww7Ci ze2eo6c#m|*&sQVP4da4_FB-a9XQG^7kL!k`p}*RaLkGx*rd*Uq-Dpi9((mRPcO`$q zEAa?du>M8x2Wf}(2|U%qQ*hy2R*zW1tGTiHD)J>FuGDdns;#4ibL7LUud;gNO_en( z=VEtaJm0k?2hL+xhgvPYYiGu~~h{K6qKlTEo!HTH92 zVnBAr;i+)YrHqHX)=!NK0Hu1`p&%r8vAe@6y?H7syZxAb2 z7{QJ*-tVx=t->gbHbqV{<#98!ZPnW>1BOo^w<(YxC|JfVO|No4674RGa~pqDaji~K z`X4F|=Ql8_CX+bzzVqb4}@iFQz57SqNGMF zK|F@SK!(}s-@vyr^L$!lEs$ci$68J`mYp;9m(+@tHMQY3v%&W(MIdx{>pD^iClDdchn`sv{vd#xp+OyPf(4bS0 zlT-;s++}h}AIP2vk#sdRJQzb1<7DS-{b=`_nbYwELl`Z)^d0me-57qbbtX3k8R5Dy z<_pZCh%er)53tX%X=HzwSSnr%#u%PL6m7@=@{?@+jp?LR$Uc|Z1W`*Wd5!H3-CzbS zK3yEKQZd?E_BnI6b-Wbj`uut5At6rOgkB3PLo^S?b5L^7zmFY8w$-$AW4y&HZs18{ zah`k?Yn7!hFn81OkfWUSj|+BT1sXvW>f{IgB6zz#7@vf;LQsD-i==~^LCy!eV76Wj zUPN1zJ+U~iWVQ4RM4CQ&BV_(J@t*iR(R=#S*ojUE%|gll}id4135BGT2~* zHLumY#-?S)1ml0P1HCZI$9uN&gW88p`-s&z3*6d7UXES?=Q3Xv?84Ke+yB_Dnn+&; z=WO&&Kl?6>g#Yco*!3l~SZR)m!FwZ4OB{mTV#0~s*l2ech=Kn|?TPl41pQAJo3OGn zIpMx&eh4IDX5A6%Q0bYnbJ(qn8i(Cmq#dly@h$F`1aE&uPF%k(ou0GM)@jybwf6Aw z`Zq~8IbG`jtNagB%$y{PfjMb45c z&`zN~fz*Fg5bRj0ZJk-amzh_;7tsk7m%!##=d0YGN4hJua9>g{Su=7!_tvUQJzKG^ zLvb55!aSGS({if%>(W2z?%=4r{xyLey5to-@&FZnc>9?ri=Dplv zWu+9R4w+}Lxnvu=#JZAN^~GGYjTKFTbi8ABm+ek*^_FKaZGFI$nK@-%ifhI&~#rJ&yUdaaVLDyo^uo zEvDn0^&oBEgbdh+i&*ue{hxYw;)%WH0aAZOsrbK;*YVwu^H^cttwsT4>>J!)<_Ak^ zbrVAd-DF-i-p5o!u3c+*3i68mc-G6yct5epmdtLDf0OwQHN%m>PGZ;Nb0`u-{_tJ6 z#&72brDNi~*vSa=(o#M&(tpPcw&-KH{GhJVX(_1mX36&`Y0c&&Vuj@LdMGH|WBN#qz=yrP7B2s80bah|>jyW3{2BRj~eXo&Hi3OO0q>_^e8L z5&P2Or}QAN)Zxeu49GVX!yR_cLXYaZRsFRs8F@umodj}AM9CSs>*(hqUmnok0r%(5 z*_slFw(r!ID6*f$y_kPjd#?W3^4zM6z<7Mz!esXN@}%>;nRP2=9f8G z!4wgTp6?EIL+?Dr+|3JQ&UUU!n0~%MytxE zMmm4zV@&+3`(bsRJ9b(aiM^k2_3tuo6MyzZ+dQPwUKAag89Z?8I`Z>Aqz4F zAzJ?0&jBJ-IK2ux8eKNFTH>L8a1*wuV|Jn zk+YG_5Dk48IaBE$~Ka=d_C5qsXGK7 z^hfjb3}dt#J^J&qjVo?M@|@|}6Eii?ZbE59Y)i;+W4g1Ot=ZFo^A zdU=;nlxMq3a&qo?_DX-mJyMN`KEzm$ieXgF{Ysp-KufGEe;X~6&u>|7d4tRg+5t>-Ufl90K)4A)Z z`9eEp2-raiY{h_ihV^jCxwWaHlUd~JcB=Ki@odHGSsYZ1I4EK#@}Il~!GFoWiTKwp zW4{u?ubNH^?bXBX}gT`h?SYF`yEs5)9NM(qkS;*Trc+j z^ZZR$A`eqO5!!!=g&Y-%*3W|Lu0Xsz6(?-{x#m(ENfBlXD)+u98WMXDAZLbarS2E5 znAlosP8mAVak4Km^|AIE;|f#;pGab~dQ6Z~~&=*5_HZjALM zct0&5E5m<^e+A86s3j~f?E_BuX zx#$<~Etygtck8xQvwwd;p)bAU7-)3B8ZQOu?9_F^g=|5P1f7V5mo< zcOhRXW6h!951|*O)tUez2~fU6tNiO6eZo0?hi)P1;_D$gI9NKp`cL9ujVIJ;8G$mu zH+f@~BJ5LAeS>Un1{()sK8R;t)}F|^c7cE7AIs_~slu)f3WLumoWpKdnujupbrLx) zR)+pRU0(y=M3uE)Kt2ir;wrG+#V)UlrAYr?l@$bJwIEVLXEK?zNtnq@o06~QqfOc* zBqeQ{wveVNO{q;=U@0Q6f+7M{u;4DTOJxPAvM$Pk#ny^1;#v!Jfwx%qf6fF~VE2Fh z`4dPonatd|_nhaPd(QK0HdP^h!d@Xec09t`x2IN@N!rWvD?XN3c_yHCYv6HwCTzd9 zOaDP+<;FAc{cR?Zms$R*N=I#Jp$IdLtAS!?OUqkY7 zrFtu|f}3~b%e(?Lk1kqMo!x8x?b3nfbebsOR|UQee^K)=_+pjb z;7LZ-0PK)5Oc2djC85|9-U@%K)~Wd#5e=;G#l!@7-W~&_fidcu8!!VOC-x>Y`L=wx zRNwL=rf0}U^^8n#7v~Y?`G1 zaDeo}pRdAoo&Y?9C=h>ZKzh;Uk=Njw^Y!h)z0_poJy_ck%2VcRiURM~XS&x(yV~!? zYfdPvqCJMALH>s7Ok{hM^}b9k(EJym;cRk%8?1Z}V`e(iZYYReQ(VE$PGb{Vc~z(H|6zqgaDwh3)XXu8L8pJKqj-d?LwKB1kzEik zj0GF*pbnDEjb{LJW$HcBzOO;*34x~_y(Zn4S$j}>5U_1N9AAf85O@vxmc|;4-o1io z&~|B3tIPcffIEB8-(iP@?{)Bgds;dasPMGQHQ(NaGY^&8NUl`ZbX6#7*@f3d?eYxJ zUHC7uLe*(U9l3wEtvTAR92el8Al71n|4Sxpd11~ev>xagDfn%AA$cqCgiwN--!6i2 zC*~`Rda_NqkCq2eFL?zyjlaS>JOidaY8P3>U*(^L(Ua~1wX36@rYG?pu=5noJr-Ab zv=i%#_-@Qnz&VU}Xni$sa%NE4V@jvSGJ5ut=rAG+2(^FVy0>jNP*ILLQ`fH;Me4$j zE5}5irKdI4*ry}&G2%hovB3QXV=_6$RMAPgr^$zK?2dRwUD`!a;=Y;TIx_Yuo+!ys zWRh*hWX!5#r5`n3Qi1u@HB;Y$Jio}RrEm8&5Lx7y;X1@15%}|VJogiFEQPTQNEKNP zKW6YTCwG7A?_mxfuIA)Da)_7d z_YkKg573>a=I6B+;n|1HY)gkH*`6x(+Rvw+FMNLu&|@QUwsaK#S4&6CACJ@ES1OF~ z?8phWpGD;;2E0_R*o_v`jvB>FP#MhK$7G`NvofMtrb%JWktLDyV)vRN(_J~eVBF9w2`iwX-o_!R6a$PM-BvpK=F@S6ZO5( z2jPF|sOl13$?B$9CMl`D7clB_nh!h5*2mt}YXC(n#TV!@aw_|L^YFk3(q{IPZB07s z6mGL|rZAjq3UTnOtC%XTPOf)L-Cy$b; z=U8(v=TsZ!C)O*l8o2Hd+gkDtR`M8U!#XGfHMajH!k@7Yl#eeJ2WzSo@pPJOkn<>=#D1L=kif1K?Q~bB0^$ zWGa+n;`>zMpKh@j>B=#%B3ED}eKX1~%|1`UnpvbWUPp6V2k$K_^xt|zHZWUppVM8* z7PkHj>`z5tr2ps0{6vk#7=?NkkVqTuqhMx>ksH!ELttcWA=bVq$L9@0MI3)`9r-)= zgVQS%=XB^~ZlC^<(5K)(HjpK*1unu)ktarbbWd}GxI)c-@U1KAJL8<{Yi{HyuriG9 zV<*$Yu$sI26@w2^6(F~6axT18>i9k-3~q4HbZE$x9R1bCGj;o%=B%aU1F$5okUiuW zl}IkxJk@RCsdUepKjd^6OO1asJp<$h^6g;u4I@Zh0H0j`lg3i7jo2$QY-YKhovyjx z^(cD8c&?Ooxss7TzP{7l*V3VctM=Tjoj@gOQZ}AZE5%{z1i*f!fL`~gI)h)b^Xa4w z0qm!U>?G&xT^gF2r~SS4J@R(eqr?vJUpx5l9k^zs?)Og1N$l^fe;h zT=TGNZtQ5*Qg83z?R{bw7i*;d4!uof=cM^+4{B67X& ze*^0*2J#7Y#CM;^K<(C!)})|*DmB*iV2wdIP=AWN1>VLHI~wi8U*hC&H&PzcE7&}- zwWLgY0p1g{mNo{89;SbJ#SFX}POgjqG8u`-vCEZ{R$q+Fr5cUDvx@Pn<@V!P;&nDQ z@G|8Xo8cy6y^48ztYgO~Z7-#shxO{hy&!4?s#RlzOZFm6^>l8#-#?h=1J&19%Lv)J%f{T}0N z?S-tRLQ%ne*+cf})n&#~&Ja6_cY5=#dy&B)e)XyAs`IaEBqgj z1L1|(F-popL-2ppPm@={#!eO|7VIS_kcUN?&c9&l({`yK); zNmq;#h8u>68%7{ald4*d*&LzBm<-lP>S9B_QR*SAMI(0gaPm^cM~3Uhgy3E}vv~yD z-`Eh76D7Ocb3xlzU4wk#CBIUuFf&6&$`hN{amzhO@8x4LA^I7B;(NBLLKN!Yn6 z3}+SxJnqV>uaF}<=#2J+4cu2$$o+2PwyampC!(truIygq!ZuuSJ($x`w@=U17^E!E zcB2C=jdcq9Mb=XEl>UplX8#iLe)i9Kqe*{y-k)IQo3-B|BScFK>$=?M49S2eu2Bo} zWlnS9Y{ky1-&B_&2ODGc48ZJPPRa{E_+27dL1$Xv`q|}Ff-tan&a{co`J|4*fF%G$Tq+X zQVzME8)PT@mlS>gYqJM?#W9N4(; z={~t$e2CLV@?&d@_mJHDDP)!6J>`|y4Zb@%k=h})8`A0HSgTHr&@3}LsAqqvBQ|pk z5HyoP$^d6q$Bv3^Y@yA=$QrlVN9wJ%dHOwpFA5K`%l%V@3jI2Ml(oNXXU&tsp!P!K zb!sa0x6+5IzTga;91u(!H>jAQIiY#ZD;Or^%!;#H7tRiLPzNCfu^}I^ViZ`$E@2S$ zhY|gm&SKY|#8fu~wrD%I+n#?d4#ON4Sk}j==h6FYJR{{+`x#p_NnL>%0CH8H$nR8) z(xy^lg^lXrm_w2(Dd73Uj`EJ?QOIVeJ#YQo@>jIKl6v4d>dqzMl!WO zh&tq{@C(hKvHgYZ&F3JhJPls(3h4xt)n>d5bNf6Gv1jA9CP%|PfC7K)zD><#~AL--9ahjBvUz{P=Z`_e%126e4*7155G0Ug~ zzl&{Ust}i8bvJoOnj_y>-)nfte+nyd^n2Ey%pO7x6yAYH>GuF;lcDlD=8Nz=n4dx4 zK~IbNs06@{QVoyMVSj(5;66jTW)|kJvX*)U<=w%T1ZQoSRVv5(u5LV2-A3BT4a6hj zCywb}f$l;^b>t?X(pKN+_Qlx*C1!*+>{Y@mu%3=4`5rS)LpC+Ij;o5y=(W;^TRP-= z80+rHT)g`ziwsY$`N0QJalmH4>eWJZJWHoa2kX`yO)411SZjX_wSS34bCozVAd-EHY-d%t5+s)Bd59KZlm|2^ifMdX!7x&45BR4PRIVHr zSf^hX93vcHCzG&ML_9-Y$6Tm2M<>G$G-|4UNwf#Y8FxWZUoylQUg8e(6C>wCLmuQF zr(+%B46>Fpj6y93@ zzHPvb83{Wxi(T2$kv-7RqwQjB*yGDD0*^4W_FGkcV?*}2`uC|u>Ulun3H6@_JN%2I zo$LQXMJO$mh*d+dIz|Y^LXo5h&=1IH0Q-jQkKn#DScHF{ft`N`pZ3lD=s3$DQ?Foi zLPM&1qwt%}f(um#i->{WiM3wHD2U^LSc4fvWCzzN^L!qetBmBsJW`HvUq{Y!erIEV z?WLZTCn9qu%_F0wy$ji7kq_UNZ++Xv2)$Kb*#2R^-;k_MKrZsY3&v9LaDZGf8>4Vq z-_t$UoTh)SFi+>?(QBJ87@Mr8>t?Asi8S9gEHO^Q>+pOoF|1$3%&+$MtJi{`kTja% zI_0%({7&}I;NO_$G`^c_#`kqHvD?g&Zg%oo3uXx#?m=ci@XB9Tw}BOvECvghmd=!P z2g}7rEuC2X!!8%!clU{NUCFgojSWPpN+)ivOPqg5XHw&|eTMXwU5vbWgzh2mJY&^g zgSY*y`s?~me}ZjM%S`Qs=FcqWVC>sn$)TZQKpol(Y(LdlT}JmXi;cKTVdvy}z}PU_ z@A!WXHf2AKtKpv&PsDC$FOZLf!Ma(f{b0@EcghpNf_7oFrB)(}rsg4=I`5!{fu|e= zv#)=xy zr!>}#@ZHJ?l_(7A+p)3-o`}OxY~6;tboPJLSO@hiAmC5fXE5j0TB{x&y%xIxPxU-o zh|K*k8v*qf%%+})>ywnp`R>X-{1nsoR9hw)L&aCVx?Oy<%Miq(Reb9o&tFv$>mki7#wG23URCVm+f>V`c{nl~zV{4R=Tx`B z40^Bj#VD&-koyaEIe6p=;CX-30Rh~PyJPU=k!8Kf$WV!ZT5lj{J!W=P_p<$}dvTRO ztY27v%IW0>Rq3kbMy4@fULy=D$B;MSNj(VjywmOTJyy0J*5&r#bLzHy(Qk0~*?7Rm zTIzY-L*gP8$s66+0Fe{mevGcv!>y--WAueZ>yX6^qdH<=|31cUL`{Ea^>8}LX$}pU zPLieZbHJYm)x$9cKz2+OaWPaHj;Rq zOWuJwTZmOR##8)QTn~StA;qYoS(+4e0$@|(?n7k&c0RShd`8>FsT98^uVA&0Z4un< zYZzr<_9Svxdm+3KJU;kF{|EjRs(XFi7})}@jJY0+vNq3#CCH${PSLUQVx0`vnqqhBnb^C}*zitDEQ99W}_M&zOJr82_zmr|{Cs9|NZKZpxb2d20 zD`;=T_8)bS*j|6P-;<2~0+7xw+hbs>q)5$}d*|O`#NF4}03M>sm>uFU_O(t#doR39 z@*&ExulWN+&8Nu@z!}@v$!>_tN?w3C>ny~>7UdZK&y{y86ZM}|eC=FD+HtQu`kCrG1^N$PdWN;(I*u`WTECHE+$w_{zJ;U79yq+ZEzUGH^WAU*k-&PZx(Z z4Xj=Z7G#HKA?6iAD-;XpOa^Oa8mJe%i%?-;Lj_hyQ_mwFGPnc9-bLBx;OV?pT}SMI zKfc#hdgp(WmuQw%t!pjY$xdb`>jHK2z~|W&GhkF2aI`7yh9!W2E--8JWv&Oc2Z=1f z78>FVYi>{nHxI;j6R-;~H(6Dqn3tbwnw~v`Jtxwx!smef#w#+5))}`7cN?xmj)fOu zubk9ZWx}ot(=zM=VL#yv^e{q4S7-OSOPpTvvA%!ZF`e`nbGaYDYCay*{d-N7q$&`v ztNO9NG!%XCHnmFZ9=NTxF}k{@5LL>s6ObMzM)Vixq`*kBgxXGR$2!7j(uO5uiK#Cz zGRkHT$ba23Q!_a{756%nN0`Oo$FYl$EJr;<-#9)?ahhp~9MiAMTAI^=^?R=Q`KioG zI6i+pFw!`lyoNneR-g4S*z6@gb|gkwZd-UNl_q){J;vFAk@f=luT?d;ugWaLE`lZ< z_9|kJ6?u~!YgS9_IG@_5<0uiDyhPd+rvoE(55+dO%nS`#M)Hfu3gKn`s`VM7-ITOx zCEE(9RN}NlwMY`SXGi8@?E*Dc!9fHM@c@7Bj$7v#8Nj@o<6IqzuIf6u-e%@D(sK5S zsx$J2rNd%~D%tDc1C!Vjnu+d`&}n4yqI>omGEqA#$A$W8+&{T<)M(Wp?jh^$0UUQglY(3?E>d?e zdNEoZ4TDu5i@fpiOec)PIR9BhwCrMX&StJITYnstSt!~1A*|=uH3`EZe#mgmuQ6bz zTAhHoj8IKHYT>)}d$9V`yT~i(_gH^(sIf4jZ@NhAM%_ND2BO=Y5Ft*fF>w2lZ&F^2 zeQfS`!&@=#k9Q0qHnTlrPpvT&7HE>NR)LoZ2N3OM4{4HGX2x?7uwJ*Re{Jv;k80^? zQfN}xm82Az34;$PS`EI&K*>?UXfNx=)_zNAP$#8s6KbSj4KWrQ(>+FqevyB1cKId$ z2Trfz4ds~n)iw{zu1_$76r6yF8Y31gh`! zr6ZmN9ABOL3(?%tk>is3yo-O}x#7NQ8#~3nBzGTq1GNCK_uj~`tnMSWpPq*CeQ+-# zY4kXr-i7LrqGXv|vq^P}Eq1YJce8EP1gGeiSpy z9^edI2p-<&wRs?#s%%g#)2~)6JtuDCXz1id5gH)Nb#>;4JS6m~R?;s@`f?OeL~^ z%syv)v}BS{xnT~ojBB#?N8aF*#D|I=&MPU|>tYPWnhgK+>T=<&U|ZSFV1ZU%G)u2p ze_VUP#Iw(E8zZkfjqY=dt^88mEc+uZW65^#N^cPh@;PDsR!c|ZbAu0m#+zS#pSrKL zHmY>Zr;oe8qn_pJRNax~B%R457V;rl3ar5M3hr~9R&3MLisxb-*8b}9=23)>o&uGBVIXpnC1H43J=4~I0|dN1M}H1`-@;cJ2bO|;kB!ZYLM$5 zE7klfvJ+M5u~`IgIG`6-y@CR?qW4fA7hv}ecwyg8ZV*uKaI6s1c6n{oIPW6;9{#HC zA)SSuSD@0$FKSYRr?Rgw4i$-Bq?5=l(iS;S_Y@_6=gUZqR|rofnaHg` z?10$*$$p&oLd7o&D%r(whIv@i>{^gLpt=|E_>Gnh&oGF}WH58eqDg^5Wn{IMtE=17 z^iQx#yA2bVWsx^>_i2h83yHnrQ;1zVs5H+o2c>Ue2316F#Zl6Kh39G>gB=ovp(snu zGfeRB<6lslRl)3kUQMdz>rE?-AE8Y^MFve#?1sA(u;6y=BL~0w4d6+L0fchwL5FMp zP&>hNmpBz`tnE#V6jehs$Vje9(dV((EggKf_Z@E? zHQtj_&KDO@?}o z_VzHf2v8FM3_hhCL(zarO^yC1n`x&192hQ*Q30qwn`dd^V5EcSgGRfbLn?k`x? zJgWYb;us~9YP1=mAPhAu=)^h!Wja=aHt8S+mkGm>0|#f}nj6?vvf+EzgE(T;-{O30 zQMT$UaTq>-Y1GYBbvpNxcirzwd$3;u68%sQ=&Rx~`LnSUZMUrZ;TG@ z1uAV_xAsEu9@MX)#xYgRpE0wj-4H|P#?_!&{)s#5SZ_^DE}TtwA;QLv(a2o%bRkaB z)iRUN$f%X;mg|MV$mgEBVIDq@*T}M9YfPGD)n#yhg|mYXK|zB6UYk~=a_@UCxWD6*qA%(%P>T(t-6gTNxpU&wb=%gSbidoO zE4&qdnYBK+af&^4Lm+owQ6*TXe7y!naGib;#Lc_2 z6Om`4Y$vswTc;_Cyzc7A+N>PY@}Y4WJ+@v!wo_@=_TXD2%l|>`Dsm~O18spa0y8&- zEJL0V^bfp)D%B35{m}10mL{)&`49b`s;^pq7gT@w4foyUdR>$_rw-}3&CV#ep z--Ig*y9l>CDAm?tA0rRZoAx_AT@%R-FNA3LfbAWB^w-Fh>HLJ6r~Vq^t)!cM1m&vq#s*Ff*v5hE zgqjpdlW+kC^WSrUU9MlG=px&Kmr=vfSQ>e&^g+P4+W~DO%X+(dxTz0SaZuwWj>9l^ zV0)=?>fyd`TNfxY!MmnWji`Se|CH@5FRTqmuhBf9f(5GO<)h(eHBip7ec- zH5}ajU=4mlqi-6>nT6jYtgxCIXPv|i2KS;GP)J3BntyI-@SkcP&Kdk8k!?$OOOt{+ zBK9u86$9$a(Ib&9%xY~Ha&82lEZa%wpmW3bB&YtQGD29GRo`z~NHT*?%z1g2Q5v|G zVc5ZC>Qkjl`xF!TZn}pwxaMnrdw5xijI1S@sMupT>UHHQ)Bdd0Woqj;T^SMGW= zwz@b+c(3A@1~;`M@`h-(n2mJwh~kQAVa`hshxBD95?OF>)vMJTl@WG-G9xpkBgZ`2 z1Gyftj?L_POjvDLtZ1d4ui8o84CIEtDSf75c-ddG&tdM}Hh{RtGM!}u+1!hO1KkDgpPH_@v-v?>qWx?i}KrEEbVY z@Bz%0;p*6e`p#wkQ^r|;*xkxiTl>iu%q(LfS?ewhwrPHeY`=yHhV_cA%o@d+ijJ(8 ziz*pw;C|r%lfh5SPo)yeQ$54HdiGZ}&RE{YGey6k#)#d*Td-CWjN=%Ke`@Ho;cjxC znn%~i{Fsa5Hv2x^(wbw-T3Rxxd6a8DH6mDGx=VY(n5*v7j%NRV?E8PnvJ2OisT>0s zV=Tn?8Sd{~k8%d1BRtipC*e&i(fibXYn>Cl2y5{SSi~$|MvAa|zrIsUq3d%N& zn-eCqX)&z9n#f%CI(ZGeT!qbpl>k^zX#W|tfMizQB|NMcgFH(3iK&mYlchwKx2ZPF zK4Y5hUt%8#SI<&^FrVQwlPj6L33IJmdAD^A=AE$vLl`7^+EgkHt7KdcGF7C(U3xnw zfcKQUlDtk1k@t`TR?^ydg&cvXd?GbIWYV`+m-CZ^hdD_vo~+z>20PG-*6G`k#pKr5 z7xI%0cF{y!4iUXDGy%>PcaehC>A+H^_pgBCS$I` zU0JeMIX?D(uJ;t?9;oq+HPO|~AjC|YZok^xWFkskR@h;+BeQ zsrz#$Di$c0Yf?Q=!}nEWjrBB)0Pea;`^>z|U5QMaEgfQhc&l6=y~s6V7jMZ6szLr~ z_jS)O#U{A#1>rGyqiOK@OqF7k`qA+9oDSVX&i(p-N62f&nSfXhlB~$d(@Qc+UO@E)cb{{AcpseIz&hNOv0m%xCSC2S>N@=+tLH?vDmF!BOs)R6 zay{Jbe(NObY2g5QJzrdNgBv9Ix_hjr?_`TA?OofiCblx7YFI zab4hlHDu1O2opOMrHDrN5Yg&g#7tgezJv(=^E=r2W!ec4wRWy4;<5HmjC0B~3p6i0 zj*L4c8BCROe6t`__%G%rOFbQSV^e$&^bYoiTWjO0;K+|!I#k5D%e#pE80Pg4Kh~tf zOo&JoJjy~GtGb45(-#_(k>AE)MAj+K0G$LQvLbSS z9`&4ZlXFr+E2RCgbn-UUTarPJJEki}RoD49>SXmFD3#-(i$96{9^Dh>;m2$RM6Bvb2WL!_(Ono?2dr zvqjs7Iw;6BhE=iQLW>SY)6&vL&Id++M)OE0Sil`sjwv6o+4DXi%WFM3)7axgR`=K3 zUb4^e5Oo@&ZXUHn`HT57V<WXK0q5=B~6|M)m;2tUu)^?WM+K>`%BQV;M0fW5tR~qnu>>N8^hUv$qLn8LY)s z;X-1mIzsYQ&ruJNQ^JVKeRr^bqAaZqON_=F5FKkK8=3r6@ECTlz?hnJ##}|J`@3il z+IeFsX8KV{0VDG4UifxpO9!gyNjuc3{^_A1RgI*5l8MK_T2?Vt*fB=_l-+AA!~4N% zcy4_zQX-GssSf_84dL zJ5}*|Rls+q^yoYiHubUnfXODJj<6=>Cr*#-Uc4vd6TvK<)Fn6*yT`r4riIaK7ze9W zV7>bt3n8*9H6}){iS5~cLpfVRD*c{~XN$qd8qx#%f^T^jX^NU z(zAznh;lt`R070`^W!|+>=f*^!XA#o*_huEny{t-xxg_JlX^MZgo?-)>QakA@m@5^ zFvI9jJr`0j)|P*Nf@e9NwKOzjJ)PsCd)U>ID$*A!f}Fe5Sh*haF#J{DrFb7${;aSW z8K6;J18XxF3)xOGQRR@>adeTJUO6e8KuwN)u3zW58*J7Ju=R4HAj){BYRh{IJ z_zBMw{;)R9n9LmwjO174qyX9&huQ|rAiYq3S%h8ZfKZnNot00as9%+4;Dn9RlJxpt^VX{tD%V~$zecOXtUlWcKugi zq1O7p0&Bb}XBJ^yh1?%WyYa7jtM9SUr$yD4a~m&#eTDfQeX;(1Za055xHq`hMQ}#= zmyo^HWrl5kxxc{CEFRUICD*Gu#ctny2A}+4MBbPg=L~|k?61f|Y8w|ADfLpT_$*^G z+}E?Qqf8Zy?S5CXiMLP39x2{I&f{KEqlX`bRrR-Pa+T%Rzi;*{w!&Iru`iHntbZRX zU;!z;$qh1tjW3qhv0q?B8oV6Sk+tvycH}=Yt<%04Z!I;T)R_o^&*+x{Nw*eb4CNb~graSHd%(NeS+aU4hy4 z49-&90J%zya1rW=>Rw$XSf#ZP>D5?U{AYQGZl2|EQ4QH%w!XDi)hU0XG8OK^4%Pv6 zt&oX-cq&1y$+5w`p0?_8(o0RQ$Y^OHy}s_|9r;q-gzlbvSyV<%g;~E=lj2Fnl_snf zoZ!*R$TqGTW~C}#&&OXy4h4uocegG;rXbS;nALmg~gph*;*qQki#nf%>8>wB&T z`CXJu>PM(R1w-TyXg+s`e*n8&@D88`1Iec{iNZ0Rp!$NB6k<=Eq^@X2gmaUp<0spH zg6BlW(4}y_w|%1AuI{(wMRs}au74k%_ks-p#T)tym=_3ms7B1+;!cW@v0WDDMmyOr z*ekbx-`!^{6Ni~*mB{3Yw|GGr+X{cz!F{ZNwS4=vL}0Bh+jxdqocFSGzi$GJR3;!~ z=BNAQ4DdRvJmQ$Htc0`N+V?bB{wDl?$}R6$=NPk*$5eP2nM|wOkf$lMA}Y&G2Jd;4 ztYDVmE@r`O@WRHD4CJvhj?a69xcwKS7m>%5RMu^A%`93M{@8t;xM#WZnebq)C(EkonB=1Gcnq%CBe4op)P<1bAwPL62%`+fh5YTlaX$T3SNR-@!(*#?*@cD~}d=rz9kr)vasu_D$h@!5un zCE6)GEU{7jxZjJ2O;ljVaw|6|tih}EpT*oa>B71#b~!tFwKe>)E|4#OQ~x?t!&u`? zp2Tjutk~pAcFoThn+EJrCPVkM|E##Eut2PGOlQ7S&na9l&W&Aj`}D>1;n>zj)Hx}P zdmKP=oz~N48}^lGn8*tyFQ^|ywM-}6EdPQg#hg=rs*>|vfY^CIv9GxSu@p^~21a@p z2`{OyMBd6tDaoim6_&$)r|pVO{w3_k8=5WecAUUnqE5bFgMJL~SFPLv&y7rP$R?}2%*1!VGpvZ(SczMD!5 zsmNQ(@sZ{9Sh6lBC5w)BQi*;CH;DD(sOLa!7dxaqVu_D0Cq);3Xz7UE0N*P6w?4w# z`7h&agNUN-<}>0%L%KLokqO`H7N${?sa}1ddN@;6GJE40{wh-?FIM+4RRIrMCeFZp zcR+ZaXis>HD<5~?qdnAGI9mlo%HySoeidmDUXo_v(xP>$d%4~Iv-Jw65uZS|iIeA~ z6t)XbDaW(l5{N5*;2GwVuAEtQ2Vs<7kMs92gZc|`H5wmbJz5sYBT z;e64#%$Q82MRt;})N>?+3@BX38m=ow>vyf%O)P4aXvu31zlQyM|7Xs{qP?IzB1Y&W z{4H`AM)U7~;i))&*j)fVG>!Z{{)*e~8<#KQ-*DVnD$Txs{pT$+v7=MU7&%C$s#AE= zx(#B3+k0gzxgUf_qQ0tK;W02`e5CqlbBaV>c#al?Auon5-f#yBNKs?6Xci z$EiiO6=O1>RaNvF?uTn9_)fUyizmSs9zl&7#ipvShzKZimTkcDAbSE4Lm;jKdDXygtF^;CVq&gTYk-z(a~9ktD{PT{ZOG0}_qcCS$Suwup?)iAd{Au6`X zkPfqQsdzuB5O2{+)J}j;cks)FhtUfC$mgqne3&hKQZ-0O;J00r-rC$hcDeK?*(R1e2Ggw_SY2P9sNtIcWAYra<9JfR3?tesz^ zYt}uau}2?dpHZ%@KgndM6L?3VrO+Zg>`vzlu}dVla;okjRDmq2aql*tWL)gzg8Rr< zHQ%1v@}bnRJsfu}$u8U#LUumI=kZ-s z+(RYHBRi-X6$uRqMF|-ROF6@afX}DjL)teiA@4?ZN{oB2Qi=AFnxd**#%a%g{{~{* z?PSNsGqz`q5Z$b{f~{#=^9SvP;AQ)moDN(Y*+bI2T?xLTv%XUp-lRdTGyESc)#u?f zu=Q_3lywX+&L#3S*;d_4J_MW+=R5z3yhL8HPEo7Kk#IBDPFA@VaNDUgYAUXkoD>CE z>S(8T5&5cceduZTubHYXhX5;oe2DB{oI#VK9$qKLbe?ZG196o;7;7o_c?HF3CKE<0 z7tnnTa`ajXOi$7faZ_VMA87RMY-SlXE`OF{QwbnP=l+n1nvUw5O#`lD8@?e8f&Z3t zJeR;z(31@iV{VhWnc=Ud?s z|Ifh=&4V#%01*C5=O=KdOW<0jx_6hawwH3Kj+n@|MLWZXB{gSf)vMrD)5Hi<)!2Z& zcGMa8&2sFv!>%QwR1arc=}DHnpStX%9=q3xy{M+4$C&VAe;vC#c2O8^FGXvKH33*R z23Ilx?9z}PkOKWgNCk0!zlxpW>hL~SV<6`}-?WTHmW=XCE`nX@b^EfGZYjh5C#;2H zpJ}ZnFrQk+A`=Prxrq}Qx${FwU#%Y^ME$BMYmX6A);(es#6Y_+?<>B5`*D7GqlaDY zBFzgqxd+y!DjAsuyo(&uZM>0DD>XD~_PFLZ4M3b%KxBM3Coi0Tt$R*?p*fA(Y~4ns zm94LIu_{s!)no5_{ipUW-wAbtsgD{LWwCA#zd@YHU4z|xbW-yVk@H>~DfPPy>GA%8 z<`LRHxZ;TTD7#!S3adXG8{i1H?jbr;-;Pz(@mg%`8>!m0=D(W-WX!R76i?u>A(NQAxPu{Q{_`lJ(at!qC06#81m zV{|B{ zC0<6oW`D$9YMIVES{G3BQ2#sYo{eY7)i{?8_IA05aVFS*jumVE8{eb55asg@Zo7&! ze`aK;gxYU8IriW-24Dn7PzR9%M0+0jc(5Bq>Oi^KabkHB&hw$|AMvgb{hs+ zo^bcclaURkv4OEv!V_XFq=>OF7V3GS2y1qQBB2<68CKvPCeV}Yzfd=^{oLlc({Pzy@-8q4(S zNTua2x~A^0CCb>lR1LDiUGzO}f> z5MS7T6{8Yn5Lx{Pe0MI@^v_l1=u5(CO^U;aOu4oJgU_Cg$cycTIR%rGj**Y;8AP}yp5$YH zy$^S|#vo3#=KO@VeCdk!Fk>oJUM|L7h@94{FT4U+$+x2afOXbjdJ?Su3RR7$TYo(# z#eddaiM<9*I)0IyCU4<>f>+R_=BL_IVSZobuX+W*c0GVNPp|*nxj(WTy&25wyRo}2 zbXt=lwp;RIH^dpSwOLEuesaL^Cry!mJdu1NX&OdIr2Zs4=_OHCECV%pfM58znE8e~B8enneARs=;s;L?B(tNvMK?dMElPv=@xi;A~GCXR7XvvdmWN+b*I^6n`%~%&jb3 z&tx<_LeHhH05WuoUb79NyT^za7#aE$ySs$VSS_BPO6>V!*x(t4Ogz=S?8kIp9>4m& z8Uyala@&JXs+H6{;bmjCaa&Y>X}b*LR?+BTGFoOzdqtAkPD@P6uHC+BZ)fShbuZ1# zI|9Rqn;Prf59oa2>a}D=#S`%!6_~L^zeh!kr4V(yibsTo0EdM0MYQDHI^nD^nid-q$pPgR?>ja#os=_6 z86kfOshB~hnX!_ONJY7S_eX3R@B57Q;EE`!RB*_YNRM^c$qE~fqlfzd-gmI_HSz*` zMR!k=0WmegEG2 zHrTA&^BezqV$@ja>4tTI%BL&`CA}kvu8a5JlP9vew~ZeWkr`xvKQ8+{uK&iG+vmY1 zrD77>&z@vIMimo4=%S=jb6XT{oJnN%kKC2qxt0#YgwW}Fh;X@T%+OJ{OqwQ+`uCZo+(=&9De+lx@BV(L#_Qq>QhV2mxkvmiwsd-YHS~1);zwCR>GSs_A z)lH#S^Dx%IaRz$;FqXW=Db{4M!XVwJ-_tybIBny6-D@ean;Kg@f*MEn6pzYJ_CHRR zV7*xD0{$vyfpcUK&$m;F*ySDANB0GCTUs!i-Wbq(7)$+sDZLJR!&IH_@1pwJZ)2Bg zoRK%^P+tkOv%TI~#ZQiuN*Q&mjj@g)@;pWcKL=SSbvJOBh(e_ z!qtC+dbOH=6e_KF5AGONd|I~N(qW$-O*YI3Ubc;+i|FIRYHl;;4?M}>8O_x0nqTl& zO*_cC=tayXVm1)-Tj^Jg?orD5)cse*4E zCvvPtid@QP|cx2?VOpwsYA z^or8Tk$8}Go1JE?qg9N;T7mkL{=DXM35@$Y-Gcn-xBt4|OCQhK%8w!y^_|!?qD*A; zye#rLAi7)Q=35z*@7P0?K9fH2k0YzdD#a>)X$J!Jqi<2=iRpNVy_HAeolkMjewwwO zR*X`Q1b_Cg<9L~rtNzz(^BMcd+sB8|OCuEiaXjpI+>v55F#smLWrXTa5nA{6n~YN8 z#xp;T5;8cW%~EX59t69khqG0{Ro-?s%(ucg+`_L#{wzkK7qf@NiHc1SUzY1WD%O~P z&j6MygV_DfE4fAGO8V9CPs&68N0t$;5^a;+lkPhvM1m8Pn(u!YYRSXwh7n3c2tq}@ItnKwIV||k2J7Tyf>IZ*ZkT-|KorfeKxb9*s!h9Q`?1F z@GuK{VNNP7ordd}DGV=E&(TA?6*tE67YIb4MI6$)Z={>?t! zdYqjfIV3Mu4I&!H{VCjk2c%ypv=BSprK-sVKO#mLlPlji+qpldqyA(xY0VAAX;MU% z&@9dgM4XB*;7Ki^4wCOTIEa%@qDIiHxQKioy~cj*6(||M2=my@0&*g42*5f#lHw{!3z_4jPl|_6frQRi6qCVW%ke{X3VrzW^_Av85wl z%pR(asffE$|9eC$$e3sUMfiI09wq}dw3??X=8-lyr`WoGAlm6)A-vT5YvDlMv}lse z!=BL7hGf7qZH8pjrKf7BUba;k!ECy|Ph1Gka0q>H=+5#Ho7r%+DpHHPp$ zVh^qG3M%554tT_d6|(Wzt;`7)s)_Gr^a&Ycd%>UJ2^wMMHnhwPj8q<>u8I+5Pi`{y z{34g=`r|@>lX85%=wBj~H+ryJ3Ojn8+JJ}rz5E+M&+5Ek+Em|uvO)f9VlQlO&h$-C zIGdHGg|V&mr}AD_JYk&^`V>3zTXvZi<|fD0>zroGV{rA!*a;6SzlPZBKWGd4D=san^#8?kXdSXrB~iPr+uWsQ zTlr|$%=-7WT{Y9(rE8VptyChiL|7+^tbZf!N=lsf)ghDFR+3H9?WM%-m`;7cwUWIg zUs%oT7l*+b_%1RR`JkzBMCBDE)vFd}4L`~@qoqS^H_lxBvZ1&xQGn&j`LH|fiQ2b5a z!mM;9*QJ(Z=T1~E_vd15PvlS}*D!(a<|o>o!TnR$g8bB?8tXQb#NPo3dV`HGxQuvL zJ3;k5SZoUn^KJFK@#iwdE3ARx zG=D`!PFSUKJWAi98f+e^Zx5dU-}#7Vp`{?MHf24e?14zOA$pNiqwXSRAG3SW3)cLC ztm2x{0%LEN#*cZW>W$VZ)V9D7l~DeT>sYk2B18SP@Gxi4J%s1V7tOy^w1X9Yc-Of< z?*n%_dG$ZmBmZk8nw5x;qFFFT@fD4g9zW(+{&Q9Ss%U3Uite7m^{!*3%L!|0@{^Jm z)~+NQVmd!*UXb-lUYz2n zqpR#u6bCq1+Ri-d+^@TbA5Kk|RBM*O+Ts3>u|Uj~3nQ8PpFZ`SfRVX1Y7CPsnqB{@ zw2yb|INv_vKb_;|tZWQOYFc)h9S1+{IQtGOKNoFPxhDkCIoCL^)OGrY3 z5eT3mi4b%N7hS1;tY53uT9vAcwrgFbwqEekqHZl#ME3KtRh0hw`C;w;-*;lS;_m+V zDIt@bnK^ULdpYNMpT}SS5BP)(?pOvt&@*6h12|66+Y_0NC2~^%W;sQ_s7)eEGe1~L zXD-f6uJij|qD7{2McN8uNS7n4?@#|D^o$J7UcpT-TSpy#sNQ0l71n>7 zPx-czPp~FH%Hk8l_S`sm@CqL)uuC@o$NX4gdWOD{&@_!PsE%7Y+%w*~G8N(oh#@MB ziO%`t!<@+wmst!^+P6)Y1RY5PJ3dZu%Khxk;tleDzt9e9OfU-dNFnyyL)yf)g593E z@)GeqtmjfZFP}$}T-$Ibmx|@})R3T39Z62>?bK*$n{6IvB};8FIuICI&^+mml8e-1ok0JXADJiK| z23D79i>T4&eyq{sYji(D95m@f{R_%pvt8VOZhnE3KtIUr#i2vV>(m!T2VX;Ms2HYw z+7XpDl-CC?!Kmoq^%W+%($r}#%rh2m2pkp*RitQ^yvv;sQqU&(&rEY%<%QebCv>H} z0wT_JxH@lH9=un3EO067(aJ5nrhJ%TEHl-d?a6gdTK>9oKHE&a=}wS$tMi5I(hRtN z@<-^!wwEYb;~3vd#!P)YU5V_yf!Dc6!$fst`ddx~W+G07S+5M3vx(0%$1{qarXQ~_ z46P7XI-+uy>ORL>QkEsllV8+yQA4WA&A^>_56*pK3C8H=#0y0P6dReTM1 z!KnZ@J>6zWF*{1CE8igTg(H|Q4$w_3lDt#Ho%n(;R7m+`CMQrlI(B0aO(2A`12Rl4xriJgbSP(TSj~>R&MS~(ob79lgG^b@ zg-WU+cDtN2*PEC#mpW?NM^>S#owu|082OC&)cIn4@;Zs<`wq32IvQ4gG9(+1;0bTrH%-8H?~7Y`!VuHYloqdDCWA-v3wKSgE_U# z>V)Kl52K7|lT#ad$M+V0XXUGKA8XapU?iPi&uOjnfMsgKdAKi`T4vm@A~xdL;hD?! zvCZ6X*xPV7L$w*%ztURCckDc5|IM2b-svSLgF_AZv<#6rYMGk^X6x@UF9c?z#xhZ{ zm$T+d>LpUOt|3O;4%RS(z^tSE%kB_gZHKE6*|CCG)SFYU6VJc_gQX$6bor%a! z;K_ArxkhzlV2O}t$wjTOz-)Rk^Oj+^rpppE(2yA{f!Vo7I8NGBPawYoGB4;|$hp8R zLcVBIpSLrxB;@vg+~V9ghZ{x&J}Ahh->gre4v=f+51|S7`u|4#$cFQdev)XL#}5c? zWT|t$ww!L{6`t{-yX=I0nji`X|Dmx*2W6T||-w zM|R1(lGo8D^+l59h*EVhnN&bDaleATprJo4q@b#G={9|T6e*fALRy_EB|gVv;EBKk zBU7iR!0Zt72wQusXc*zkQw{6*ZQQS|eu^_bE9k0^)t-Vp2x7jH@0H_flfp4yfgyOW zaC=p2*5swz=tf_%kk2-gtL$a59sJuCWNA@|>Wd}SLN@ruP3!kLo>9KSreR)c`YhNX zo;5r2K5aUG$M(r1C3Wqk$bNu|mDD7*4;gt?9n_@oZ!>Cr`*c$bqexCeDtt1l;!&&+ zkbb^5`~klU*^Gk8bk5Ifv-+)>B!QdObPg+#=%Sh@ZA2N6Zy-zAw8pJ+)_C5R%&&Bw z0v|9nzXMr;Qm;3iOS#8Q9h@UtUbM~g6et6Y?HNyhVNDG3>{L9)@L*$v+EY#ixuBba z%;fAuQ#z|c?TvcQu^>okUxWRh7UKNkul`tV*Xg zhFJMjI zS=W+(5v5$_$RJCX%goQPc{qv@wV%6@iZ#%o@APkYZc#%l!`a)&mL+bt(WY4>J*Z!1*T)}lwYt4G}4<8uv3!JD);kpP}Q>H3f(^d4Os>7)bb{D2=_lVzkZi(B= zztXj96vCvE&4?y?Xx|9@Z{=lb^!g41ZCSp5HceZn=~}zxf&MfSUl<_^*XJgC`28xd z`=(hC;h#i)t>FJ_I%lA5F<@urX@}veo<*wdqh29pmR#>WPg^jOI^Z;?++&ZLKFkrw zMjMCdAkwK?(r~lRZ+O4(Z{$6)LmlCsS5>05rVb&uaYeInE8cUqjrx7@T)UgJt)7*C zx=Harf!XlX)4)pRvnqZYuC91m-TO`H)DYK9>Im}|t!_xIkFH-;eFS{TSYu|}7DEcJ+!HGN)r*)T)-c;&XrYqa_Izg*?h{f-*L{Ey*V`?t8?PyLnugHy}C zj+IHad32H~-3hTV|BuoXwucC)-=GYCG`w3Mt&Y^XNisLh)IyTk2_zY{c!|dLTZoUd zOcP1Jc3ALAvCK5fULhQmv}b3d)efcyBOAAZ1qaVU5`J9wKve=%ZMUo=pRy|bHq?zr z6*%yW-PDkhYHd;QZTE0i)!0rJYPwVe_v%$0;(LbWL>25N31GzwxQJTx4F3av!1kB&1pAfo&dhSbik5g6+whp$x#eBrF$lbt5vG z8lxYt-4&FjoOeVau3Bg%SF+T$=jZ`Lf66^#DV`DRkVmSZ<~Mjk?F2)H*xWP|5_Y@MSy4*7cm*F*<7NczVmpe9?3=9+SxcNRy|)hXubtDJ2tHKTK7k;5k04+3lYnZ>9jg4B?aEy z+F{59K>1U8Fkj>cEw~&AJpm&vLT%cKV@`0Yn+MwX?_8J(QfR-g59`x zE$^l)L)9vO-~xCG4T-nC6jnsOze|%L)vV(#;e9plhicI?!Z{1{q#oJ%G3SwY5jf>S<^>&Em@@(^bcZ``iQ+<=D(GX+ot$J6!KPY1+LeK2C ze~a0lb{9Y3<+b(MW??>i#$I8+(V(RlyjhRP{tv;fY`R3s&qbR2Fh z!dJ!0)LBGOkM&KXVuji2CBA%H4!xMy*K|~sF>5WD|1Ffyt7};<3w$X2B6BEeF3ET4 z*wEc%IkDJ&OZgRl$4!rmFM6i26M|Qmk(jS8pT4RKu|b}ettbob> zm4wPZj=OGVi?kV}bAj5eb7h7z16JSNm0ZvvD$FKD6biiK?9gtvpS>Lw0S7qkakT?VK=YK5e9q zsAY&I6b?cgZ!CXQ()byTyz+|Cy3d0VJ9hA`Y@ezFBhp|bWMh|j&9Xn!Zy08OteK*l?x$R)oEeBikyMRKi1J=2^zTw4ylfn+>|JbTKWh8YUcHV>{uDeu-gsmsBc=Kl1< ze7)@@)8nBcZztPa+rb>BhIl*WM;hB*y^c^*?&v**4!$v){xYLxb8ISfC zv3B5pnOmr_OcMSR0@5=w=;kmlr<hH*E@FZ;zSMp^p_A=2+>zUzw zyf8ae0FHkl?Go4g$Cb%{-HEWnQ32Y?gcuFgwgM0Rg>5gh-)N3QH5al(S{3`ZEEkxw zOY23rdK55xPLho0F&hZu_X#WLf>$0`zx(HZ>K)j!ENuV&Zlv$uUS%pdSo+_=bnzU=JmHXHRNm8(k)88E8?HbMoQWmSIgyR*4} z>8J)J_TtW`A*1@VJJJ1R@Htx!XVv{o?9E>0nPJFSUCREi`%7JtJCVt(D)GGqqdMP4 z)cN$I%ob!lHH->MDiHi`vDcP^pEYCzpR3nVd$on!uL4`@)|gs!3#g&UL*$%q$f!N0 zew^x|hLG=&E3|Hnri+_^S_SDg%)*&}0AWC$zp3h0M?Z2NDGDJHMnvZ{@||V4AwT7w z)+)Ye3Yl6V6HJ6$)7)%Fz!w zf7)U$nw&Ib*m8o;Ip6tJmYf5oer zBPETzjrIMw9*NfgIZ_W~b6MUK>iq2Ee=w6HRq=-1c}AS~>{+i0S2oFe)yKVw$lhVHBexx+kb9?CabYe+349 zfEo(VJDDEHGum$m0i8@~g;)^z5?WwZERkg)6;n7Q)Dt$s_8eI1_s7@|R(C&W6Qf^6S= zp-+t2wzyCasTjOpCt(EEgg(Lj$5c|c#x}3|bZrNs7!5R7(R`;?sL_VZBI7bgb1vn)M1FhsvyiGEXyrZ zS0|vxnn`e<4jr=1#v@dZfAbafMb8e1?>nHST@Y6(sJ$?YXB%Qrflbn(n~yPKDdP6Z z!SE)RoO+0TVhP)jgu15ImCVbOpZ@_hvqU*$i+9EC%n*zuHOL1z1AQAw@bW1= z$ffA}hE!#GgB?DtPg^?N%acurE5X%aw2JA`!45CKZV|OEoJIJue_}TCWn*0BIb|bQ z9f3RRxSOH1f=^6ff8(@oi@hb)!7JW{HX5Tl@-}-GV)?|3sJbigsaT49SK2go6avpyxA|eWEnQ>L(qfs`_|fwtF}-t>jD%V`-gQveA;F&R3iePY?lSRSV=a4WXp! zOSU}3*oxcDY8+$8;hj5_oMf9*dh&94Maf6Od!&_DxOy`pm~-GaS!suqS3M!x#5Ph) zO6tdug>Y3le})*Mvdxxuv@+B(&yK(z_2!k6kb?uV2jlR8bhpOpjJCRh+>7mY9_+%+m#nu$PtN z1ZTLX;h9e2Tl{&PTdvmJ5Du1IBm0z(QG2N)#f45^#x0vJVS{!53{}@t`R_A>2 zwbVZKFl{|I)$RuST;V)b>Il9htic-LP$m)T$7GuW7tC>MQvW^l#aQd|Bt)_H!e$fh7d{{dG z+4?1%e^d|dPNrUGR#I^gb)%vy^d>i*IEarHp@kf2<;%)`7C0jROGsyn!u_bwDe;83 zlAEsV4jc(8Ng`&2g<`J|V3rzUO`V8>X!zR8GHXkJCIk?bYnsKhF>6ixY%#t` zhyrAm!mPMJE-`C!gk`V!A4LR2^%1$++b&n*Q3*L3LH~`sU;1wO5vJ4bHn|3~8*)>@ ze-@^M+=U}DBJ(@hH2rv6RO#i$c1N#%JpBfHS-k31*(+e)8Ig}KYf%Ws95VIQ>uh<& z8%iG$KPq)FFC(^!`5@b@YxgCS)!Y}z_t!9q+6Wmdq5!g}A?yTtK>K#%R`jma5Klp6 zMNp=CqTm9EM=s<}_xy>oruNDEZ8;^?5KFw5yiiwH;1nCl+h9?y!n{5M_Qi-u zADI6##Dh`eq&1?YVqR)JvJi@ewMlRfOLS8Zd4u<-oI2?Bi#bl@)MJ(&Fn+=7t7pHhKQw=(ktk zh%U$$hKegg*C2lS*wIT@+P8W6x)$ZKhVO-gV5=im{GYjzi#Ff2O|nIm{lT$-^Kp@i z6QQ1P1rx-`M~S62$vmH&gsVRbf1_e&o!?quj*~}bZUFoEIrFv1Wt*vu?zu2#TflN& zFux9Srb~09ZjHSn^m`Sd{KAIR+loCZh3^bEn#cm*RJHnkjyA)0#vKoKJdW%n3GPH8 z;EScR?01y6VFp%MQi#vdzszdi2JvMjvA}&dJ5OnPNk!Q;TU6k%cS~K1fA=eDqiZ~& z>=ijO@x_L(8)9v7VXLGZ2T#r7OU6}k_uR}Ayb8H1i=K3z(%*5;Cu^#YL#8;+z0>TV zO}Z(N9drhtOSxCo!$ng)o?EsUk+yxbHf`l3`(*V+Yo=#>^%3@V##2~v=bTR?nz6kx zhLm`}BDsn}0}a=o0j<)Kf3>LsU%i~Wj(x9_kp$m*rInOrJY|c@9&SslYDF7ba8*&5 z9*rIVB0b55f~Cl&rVvXYja1lTppBYrGjicLPo*6b4pI}8kCD%)aXFKjwN*X!*=RR~ z*@8~fn{tnP$vNNAFLK^{RIIb6aC>^Y`vk6Ak`lOrP2^9S8}RA!+Rj@vr}Z?Gs*?zz-6ZN_V2=R*sTzI~GKd z@CwZhw66u($Q*J%e`ADf(=^e$z?fUNrg{q^X`n{}HPc{jBni&tL&dhz%}v+r+w3VB zk(8gX>CxO#YAoRug=N1bHd5?}f>_#v=tsG~evI>O@#AtfN8sFGDHQ4LwkWeKyYgKeAF^W@1GuwO282RV$oBm3@wIq)JkJYl3elD!WNQmsI7i zKBgQ;#ZhmPf5Yqq8&Qs{*<0nOD+9A}mzKKBykLG)`-pB1s$x)_<;9;=F(7N{GQ@C; z@NNyXDI)!C>Wpn3o7V6O>g8#=Yy_*_g5ArkxZ8^wbr`Fw;@M`?EOma_NXv2@ACyep zs(plh163_?Ey&b@7*10N6#@)2@^!H)+|xlVLkUA1f1}TZ?C3Im3~XkOLy8);19;uR zD;T{fPPmSyLWELR>P|$4kTp~6E3nF_s)XN`C4^Nj*@E{!Tb+n<*iAHhKBfVWt*bo2Dy;v#6UOk7PeB%~0oS=OEKJ^HyGU8I@NJ^E8pJ zw6&MsQ~Z+j(^=W$(*MY}7H%&aReB-tj`{W6f7kT?fLZ9INZ;PWYE9!E!ZZtXW^OegAG3AnS(fUDbg8j{XjH ze_20_o6fJ)PS;22$NSz2vTT~}^|Xcg2eK+Xqnsc6POJRLX2JhJ4GsC&Gg7T!qH!NG zn`31UJwTl!ONp`Jc0o3Oh$vwmVcxm?->uR!BQw|Duf7;`wfcBfbbWvE21Oy;v+S-g zlzc34WOUV@7{rOzgSEi<9K6G0jD+8UfA>B&b;3;DVo*S&zK5J5Z8>w-zT)}~vS$d# zwQtjlvF0flmATsPf+)KuYc8Tt;gkEN%)TucMY?p|WIsQ!?2dV-B?u9k0#^sLFS>5R z=T70Lz;?EQeIHZbk4F*5TCc6XOt7>(=yoQ_P z1YE_(CIK`3`hLk0CrLQgs@e|r46j(NBT2l%cwRszz$9GhlJKClxJDr9f3HLS=*cAk zW&~o~EKgN$;Sa59)&E1WhZ!l2)elO$u|{vT&iud1QD75$xY3#C$=2LFvV^(h$u-}~ zpS)_RzBYe{?L0LmWuVApJ6&_iGS%^{cr_TMEjP||Uq$6|_NE@}tKp06bNYWkuOafB zB4yMoh()jYu;G05CGQ=Qe-H1wNug#ucoSS>J`dwzKglL#p4?zEJn7G1rsSmC;7Su< zJXgW&P{C{TLPmm>0?1jm$@Dn1lP}c)mh-q<(MAqJ=KMYBCtpKc_z}Ff7ycUjj1EFv zywOuY?m~==^PwL;@fEpVw?@o^V;A6QUx#;kB*utda+!SbFDu0*f0F;x1ZJ<9NjAbc z-dkaWynGY1y92Jq1^3kj+5O4%*f}Qw?>?7A; zZe-wo8N^$66?=%Fe;sfg#p)s|uC~kccsT<-elRz$ZVmY!e0M*zbJ9@n*-^O_V(81z zPk#?AlkNG6E`0Y}Xz_FMS2%VO#?!a(&RuCN9KrsS+Wa1_XbbeyR%oje?rJ}@ z@HRZH@1;KfE41?!eBvscyB|LDJzN)F#YyPFWX>v{fY*n}S?I;x@TpVq?w2sW{%o8H z*S7>(z}BzBf9n>o2=BpPtHVkv74SGr5pdV{K9k%f-XnqFmm zV>|NiA!?6l_Kc!U-cEfi)+iWelvHB{u)G^rx*A4>e-5$Dh-wnIuivK}4gMoQ5)s{8 zM*aJky7pK>HhAbn;uR&Y*H@Ip`N><=-%{_j%EwM2M@^6b=EoVh8Bg$MDn5}zF_Zr!#d(H3Ak9WN< z4%9MSH1Z=^Uo*|}{0UhNk>3ZEtPr!-bPn0wf3W7xK!A zEbd{N^;lD`Ee}REOd`n;&v)2fQjB(LLx-rXf!TR8*d93EW1u0rRB6VS4>QD+RAX#p zS_3PJsq<@#us!8%W2PrJ-R!+bPFhOE?GO!;z-+de zf1A$E3!^R78&pr=PK(?MLcn_RJDPe0-|7YqRxT8=_JeYAlr0K(+lJ5ml(AodYBri=^`5;lAo43 zgsgBX%7^7v@aHY1rals{f5S4ha!bh-g6(FW`RKAe#44>jEI(k9vfV1X5aVG|5Bj#1p#VfFHGf%4X zQxD@mQ<+AFyk`B8vnu~g32+7FNTaHmMb^Vf6kAE zNr5HG0IO8x@J;Fw+6sMa<00xc^wTNx>-zEZVi-sB98stlBDNtSIlP$rZMF zmf`f`rgMIMRf(y^l%6*O6|DoaVZ?OhZe*JsQCT;fY{{Ft@En8|CnXyt9!lYC9Ox%N0JGqMxa7lZeLEbi8`6Y&+QJyF{nQA3ts zUJ_=BDj%kO%=|j)aT{XTd8pNGYp3cAF%^sLH)v6Fg^R|lz^tdn3M|{4e|5tU1MgQ- zW7+1$txOWulEEnb6jd%$XOWYIBQka_e_b&;w1S(aj%0tAye@emwT>S^)hM!pJz6*d zoJ`C#+_o1RXjH@$f3n5xsKOJtWX^Vq>CNTC98n~Ly@MPZsE;GQ#_Re2VGh&N zf^Q3xXj91-PHpol?RSFS3vo9hCiIUHF0_Kut@7~-L}jV_D1iz%u2OFzc90@cQ_EQgtyC&-A2$4huLf6`-ADPtG5nn~_ras`NL6&`e@fc1`hGD_Y~$QS zW3Qn08fIj>_0Q%A?!DDV$WEqBAMbvan!rUfYY|yUPL)*4A@V0J%q3l^!tPGgCCSxT zAjlk1o^Hq?G?~&>O+hz6j^BXgT2lvIndbd8avo0X%wi%iX2Jo znPq=Qj$^)xWDy@Te{u~f#&<)6=abfDRw@JPc{oxmDX3#*ia?ZK@Jh|zwaU6RbR}}z z2s&H=Aj!zfjePT}Cqh2+GpWOn!JeFCM&K%mfkr$A;{3B7wG8K`VFf}kGHb3W-GtuS zf}Hkse)}ixQ$rSqx#@+As}q>1lq_$CsHf)8iyK~%xTPR>e^|AYRl&WMLA*SeJ9`vl zeR7PUl zm+QDiY8kf(p8sKSJMP4RZ7WWG7KT8#|CY5I%DiHR(+eq>5T6WP20M z4%HK2)#dJlf9m6^*bF=U26LJ03Ts!9kHN0G*f+=_-U8s1CHQu_EtwTfgbrL%h`dI-C#yxgn%-R1q>dmee_wX(arbojk;Z?px8>a#lp`wr zaKi}WWGZ0(Ft@_JPHRPrl)P0lvhddoZ`50#GG^Mpt;h^2ai~>Jcy}Dx3;b0acD(5!<|qT9LdC zY}0dKx9aO0<-@Y#$)9RZX$Qz2L?5Z1Ku?Pb?{zKiFTs}8tMm1_h?ZzN=lBL9)i$y* zG9qBiIoOOs?HBFR|30)+aHreJu zE2E8>#7CoY04uhc)ub3J>Pb0d;R_+Y*{68E`T-oas)e*T`U|$Qc_kKe95S=lp8EZy z#?$;Al94PYM(gwfslpj%sTz7Ue_OYJw6d3VKVzn9dLOKs#A@*L=AYVS_rcvJs=of| z9clkht~)E?y&lX??xW8r!pV562$!BTx+ z#jBwtYAi{t`H<~1>cTaCp4?Cm5fx87tlWgUa=ao(D4N-@i5i3G9bC<7e;7f<=2e$g zkz}RSFhe^`TW^>FF?9exZJBCo_v_`|{IRBUjqS`*8-a-Sdpm;tgL*;besBpcyZzr#3d)PaH!&qm|tj$`)o^_rgGTKD>8%B^e z@Y40Z_OG<-5F4Q)@Ei3N zx=ESpcVrD@#KQghRhhJ_ltu!DBLe$YIg0B8`zSv$dy>D?i?mx{geFj9JkQvkqc+f@ zTj9Q<9Os+l*%9m@Tgdgo5&QsL(R1130*9&b&aA3dTTJkZe>z`V53>WJqT>3h8p^Mm zLcUj#;teD-^Ze3sx1JuTO$uJoB`;6PYvXs9I@lgDFY}k7Otw(WgHOG~d&$APHfI*; zS9aUK_9i;bYFWYWTuDq`RjWO|&Ov;kPssQDK;4>bvs|rxQ9VMQT%^ln!_6m7{D?rG>R8sJrA-Ww&Xf=@31jPA1pb36@d(MyAs=%ReNr zkFU&sIdm8L?QLdl@gcq`+x+iW4C>a{&P!NgT%CMie%E~XpgxAQ3Z8>DS7NA?A(vQ~ zgUqoYqn3!McbAdb_yNvlW<)syvzZ-)=lbWWI!RR#e|R$8JY-b17#*_k?^>>e(K655 z8Cp^C7`-@oAv;gXs9r!^usjku6P;$wc;|e!536LF<8Zd~+a&(%^5C<^OvK!&x3a3> zJ#Qk6NyyXL<6LxJE+T8!^%6_&P&_B1{<6Ntl{TzsF=om)FfaRJiKvqyZovB$`KBRR z9;qGBe-87_LnMtjw{Uy5Iq-dYyE?h{6uBF`Ctu6&#u`2tE60)1=%Kxqhm@nhCtZ`H zT1E+E^%D?3v+NFJ!ke@M%l@nwO;4*mwYoHUVeN5Sl=mJv9JPv@H*)%PA?_80IcT#aLhK~9_Ef5mHNQoSN)ilD}Eqq*qxc4W*$RSn-x zMWJhan8Aox*uN+rb7t9#b#?Y0)qsjPE;Y6zy0vaij*wbTo5(ftE<1soB^Po8vI$yw z*Y;fQQc~_%0A5(CPEZl4?*6Bdk^@f{>)eq^L}Q!`pIMGi8CU)_Q%U*yW9yG;hgBb^ zfBZp_Mn3sr$d(-hpIG2bxrcbR#u#c&V+^Wjb5@81erh=hBKvZQyUmCyYQe~#l*VW? z6>EAOk#P@son(l_b0E?j^sXg^>?+EIwl3iMmZ}473p-EKh1E_F@uNae21!!SlXhCm z5U*)?Nn&!PFzWE+Dtn2F8X}KmRk;U)f06mGw#b== zm^%}(iY9aoQTg~viV}MoVzX{M@G3&ut(Wlw&2ixvP~tOdwoLUrBjvm?$mfDjw78zO zAwIDBIR40A#7K_XBC%0rNVPH^f0%PD)f0>~?aP`=lDs^*MKb7R+V`B*E*Ceo;U={g zv4WUUbJInK>G8Bl%BL(-_2UrsS?IE zHHM3X*!N9j-(hd+>(eJ##@gKl-!z@ecGsK|W)nj&z0QIAD{_hy)H<}~+%)#G`Iehd zbNDLZB~NeqyZZ6`Xo%&Pf!&mu(%4qd-+Wg7FIDfVA2)xfj-dBYZ#urI^3&6BSEgPE z^YWRDlc65#al;qH6XvwQf6-|?msee8bbm?8SgB5ei?+K`dN?^&;o)9wV2PyTCSd(3 zB@6Q%)iPus_+^XAFx-1XM6aXupR9%Y7*A?5>+^2fcqYxjYfUee~qvrl_SbP`>N7y z;CGUYnbc^x6)Q7LeRhc{36;*!$CF*WMxBq!2UxwyzG43s72;{g_?5RC9;0qs#x}Nl zo?&j+)22S%=iJm4R4`KBZ63RRAE~HMu?$Zgt}SwEu`RL*+PsMQ5>|_=cWA9t91C%g zv=f(n-;O*OwLajHe+=s+pM+K|=ROl5cszrMJP%+&9^{?C{Wv2k8-raLY;PV|DRA^# z{hWwT%kIt*%D$m1!Mn8S<`^>_QIH8#s#`s+`Zwsx(qCwL_2aSTU+>b4RK?Pj5|<-H z&}^EGgV`Y`%Tb+)tX52KY+w7jxSf6j(a791v?qZj_G0a0e|FFJaEt7ZE_lFJ{Cu0SGs-to%R?Al(vCRfgxk&W{QPm!! zr|}AIdd}R+{}S}}v(ymUXzCR7luXbIlT5RyqwXQ}VoH{6PC38+5PHY3G8MV&*HfdB zXS&WmxKG6Ge}b}OETR}*sPk`v&8J5e1) zMONMPK^|CpBJ6dLOJ2~~It>arYbYUKq+}_cH+4b=e~Q&E53T^|5&3L*OIPogWLw#HvSGono zGTc!wb7Brlje%atuzyP`)FX%2+ou73S z^Unu*e>q+`N=xus%y$tX;W`R!7(LGrpD~;0Q!c=>@%$%NXX0CX-n9nxm?8c=Uie60 zbHQ%rWoih_q@~~wvZz?ZLj4p+$|I|fr`(gXVA&3M^pNil=8yd;-u$VjAFNDz;I*k! ze9bosd}flw9CS9!S3@sCwJr8$ju6(OMtq_$e_M=`L%hK%aYrb4rFa9@?A7aBE|bf; zvb06rhp1+Kyl+w{vtSWeVZVGR6)Ujhf}oSDNt-)9v<@*D%v$7$A(was?z)pt$WcUq zTc08~Ev3fuyaK#)ANN`CIkFS3y&IK~i)JdGukRPPA_l`Cpr%#9`?^wj3Hc0>8bO&D ze@Cxcy3M$kZq(HY_1fPGmE;rGQJ+@OHEy-8%!mqXm3Jw2>88{|2qFtQ<) zbfEr0Lmc#NLc=grDDv$ml1h<&Jo3UChVTPoo^KMI`iYwH4d$Uu9WN%+Z4~M zB66lGo`=?DVjd!b!a9HXlN-K97DRl`RXw$*!n$37eb{p8@KC0<(0Q&PyIx1XA^$^= zLZ&zM0_zW?mF$AM#kv7hEl$9Ce`AwN(;J-0H*VF2hXN)@OG$$ED|ze*?(2VmnOA zjXL*4Y7BfAthaISn)zT0P%hu!cX^p zRrLL59PF_AONSGSVH&>cI|FwR%|#E+L%|-c9OT2}SG5k}{KZ-!%xRGq*rJbTl2kZb z=eWPj%a!kECR$gL)#my3e+qRnokl1_6z-qf{#>?8I9NuN6_p-Teq@?xJ6!q+6{~x_ ztkmvia`W=&w~9=pg^Ol7>tI z)KwoL{ZbvkLCn>;XmMR_5?K_Cs@E}{HK$T85clfSb^hQ?M9)@Ve`+FjSH-KOANu<5 zbq?Xb^dnKwV5-~Pt-f8rUIsi^?n&ZeRUAv%5Z!daM+)gaYapH?aLv2LXGF++490~R@D`O`!0;10$ zAqSR@f5xt7MY`tWxTAoN>zTnh#OyyLhqn8|4Aoe`f0RO+sx!X030OP6k&q zPSa}{h3i?&98+gikC(+`VxcW(bpzXxasm09Gol)l+yo)Q9cinTkk^+&I_y`)^TscN zS5$uA8T2TqQ5w>L-`|CG5X@4sQ6Jwhf~X#59|Mn=OMK{=QHMSy3sH1(H9G-)O7RAW zA3m-=V$8P9e?zT2c0%>>^k{88>J5etW6KclTo+f8Zt}NM2h~Fkd$Y(@u`#f@W)Aa# zu!cR85k;p-*JCLiPFH%fw9~VPi`8M?AolgDcO{O8@o;Vn*y=E!`ad<~rM32l<{__W z_}Z6mOoTiqStqOVqXIMTf;Zd)o7X}Td_$-sRjmz5f2?*84#Jq_a7U7P!9b((swX$w zo&I#%v9fF2G_o{(Gd0fkTjYsnp65rCcgd0_$ZHHk$R3!fp9|aSbs@0oas_4@`tb^} z0y%yQQbz0Jk#mC@2N~Z0WNq`1+oE6@Qgn zCsO@Un6o2)GC$x4@9Fr)Rc5*baoQcS8lyir*Ij*7`q#Jus~kt(-z*l|@4$@8 zCrSQ1L8rI#158ple}W#4hCHZ3+GTlxR|tN-E%-JUji}#{PKdx5k|fg#eLQ%luT}n% zjmz#LpB?fb*ejF=+zCu)@gX-6bgF221$^r*GG@BJglybWe#_C1_a$leJ*|!q ze^#Sj3_qYEA)R)Y=!I4|mjde{HKokU34AAA$pk9Z~gbrGLN z{$%iOC#i9%vw|I^7ql6!|MN;Ja^%yLeokyqDhipAh=ft+D<3C2U1gY!s<)EWw5S+u zt?+87O@`%Fr)^Qeit6KvLW9B(Ro9X|f3Do&oUge7k;7Rb9~l~d{E_g}Gw>Cnp*=hJ z0cCgfB~xeS4P`gX|1(0qa+LZ}{s-YJh}7Egt|Y#WnaXY$St=?(l1tOF&B{@!!%~NF zqs2CQ#Y5b-4`Pw~kjq0Ifqd0eEIxCRELGb)4!)sX{as^>B}G3z^UI1?HC+YSe^hMh ztX!qoNY21~%!Qo&iiB)UF548iK$5`^u2#Pa-X}RDDo2nap*!9z=PAVHVw;s)eP`G> z@TwDR?Q-z=UjFyA7?*w2_Gfp#wvZX2nMyX58AIy|cH86mD%)Y}4^FN2ZPTn}XH1>o z9Ws9MecF1`TIM1Pms#;VVlP;!f9x=FHb+R0&i)mQ?$03ZxWc>z_GpvUZ%cIaGykgMPq)}&-PA;+jbog0xOOEp5Y*XrdBim<27HfwrOjTfwz z&#&0S2uq`nUZGX5mQzu4Twit}KiZ{Tyo2@@! zy_YW*wO}!-lSk?<>Pj`e#$6;gu-TR)ww2yfN4VqhN~=oP38=7y+~|hS!*O2mj)FzV zO&=^WPn2)4#YtD%S#}NLf6M)jUg?_Ek_w`Qd`T`LW)ghv-yzT4lI;l`mbmWQe6hZ* zL}M=wY*rqS!?-2g?zuiI{|~G=%REU=l2fD;@`DP7fY07o;Iz9)m-AGPpj!Yr#wR%f zzfrev07C8|0lW#(XQVe}o8`C&<^N4Qolz zH&bIp&R)UqwpYkEaM4pnuoIl8+`se%=z-vsD!*Dr;)4{fxaJ7U?plJyGToG5WVmPK zUG+NmPWp}92;-xnPeiWHk6hu!8`KNjiDXycF#R{NaOrW(ti(p_`N9z-p{hq$>T+f7 z%>ET^qBd%J_1}^`f6n<-9DBwW>neBMlt1mxw-?tY*Nx&os;2^l{hic|;b#@~<6j^myhvA_(Q zKrA`a5Yfxt^sPr<0QuTDb^<)juPs6HrTfdkzS<5hy8ITRV`{b|S`qTCUTCk3dXtOr z4KYk}MB&N+e?Op0*55JIqdoP#CEamM>M)4vI)3^g@5_fKFT^!f!$j2+@<^}+$++7o zj|_ICE^j)Azu`#={D5#!{c6)W{E=FKJ}^Au)LKeODzsujjk@*w@~YY6OUFU)9A-Kd zg~c0IIqDhcnV3M47i}uzgQQo>WuHTr_xCy@4U^iH+2a({&hAF}~2KBdYjygXzO+2A)MdfVG z-U1;o8&|G_-S|{F4}3ZcdB21J_ESl9?vts*!pC`qw10Ayd@GH~Z^(X_$A}@u_4y8X zLRVmZfB&7FA=mybcgaO^7gtlI8sZlCe!p)$#^laZSn)$T!Al}m`fCY`yu}u$c)o58 z>JVZ!N>@si)8oh%YE1DV@;RL6Phd%Q!WEo`?`#9hbONrbjeLVl8|3b?JLK<`Tj82E z!6y!tR1>ha<)6P@hmqLUYr%OoD2-hA(0)^r>9^8?Zz<0e%+?wf0;H^$(|lJ+zD z@Tp3SU<0JG`iK;fm1(*gv?KvuZ&brEY673Cn}QKGjQdD>Rge|8b5osK+JrkB%29*o zabVxW>lKhwL}x@{9VcX-ZS^|cF5mhZf0)ClA>%AF#DsJblfcdU8ai`O<=MK@ScvPD zDHp)cwh5bk>wVgq^$=hD9WxYM!>HGlAFI4eJA?opLw}2E7R4KK1h$7>RDB0MC7!Q% z2Q|*riB+!j8|=-75zJ=SO)6GwEZXaf#gzv>fI21mcvK>k|0Ub(Wiw=$Gr1EXf1(QT z3S_faMOU3x`BB$_lFnVc81AB!S(_0>jidJ<9s;Ys4GPcuSf?Y_LT0;GnC+RX?k?GE z$SBxduTysqo_~ttHljE_xStx^Gom1xw-kSjcgVDn9EfaFm^S_grj3f_e*imV=65q~ z!dWj%F4>~Qw$LZ8qcBft$wnlxfB#EVx(5C2)a#@McOrxcn4JOUt*V;fmF%MupTU|i z3RoVYA5Y>}IoKnEpPh4l=#wyO7vb5wa1;ZxHXfDe<&pY3L|*m{;xmwUtax$$WJ5{8 zB5@@(7T3d!kFwCO!APc)WJ~qtYjGVca5%6P6>gFjifx3h>d{UQw?R@#e`4{+gk?sS ze+723kK}}sP<5RwqvTDuBHq8(1qngCAHH& zPk}+cvc;E2)~J>=oOkuwi~Z$bMFZ;m>LZ#i#OkXfI8j? zAcrU~j?$vNsY}Fl!a=NVY51D5lBA+5 zyu!Yc%ialgm}cu1P|xJZ%wt#G z49td4=J1O2D{gywE;*I=DU1ZH;Z34NUV%8!rbDiyMxEgn(UYa@1QjW<)cI>pxf6Y( z6mzTm%o4hhJ;QsEe;2?si+R}=rJEvD@=f-$LcPdk+t?1Trs{7EUpp3f9R%-%<`(($ zct!r?#;vP-;J-%Fi+QE{*W!ESFWb)ZO{q$zQ(W0N{M-!4xS!IGx3qH=#`E$U&OUEO zO&>KTy`3<`Nz!X@k01f@tn@&|s}h!1kJVT3G$oe6WmT!Of2c9I$I^5ytXqb=EXa;7 z{Fj7@laN)*tjq}1FAMcphLaR?nw}wC?oE7S$8fdx+M6ak`n;+X#{48a#eVEi;s0t)FR@WmNV( zs)rg^kgYAie@r8F7WoLie;i`vJcwYvs69a>bfkGA%qCxb?7}r<0_l{M@;VTIl;r>yE$^mk>(6Sa4$qw!c{keS8Ru2rl{)safFgKIYb*+{UAiCzNW_74i{t(vU1SY zedYSWe_97WwkoN=aFJZ(pm$*eK(wX^T}kbO-s^|+;h2EGapwr^3H#tq7K}@g$TIFQ zT`*4NY){RHoLkzRf^kSPB#tN4oQYRVsd$x}Mly5rh!|ug=KhCjYQs-R@jQFBzF*}J zuj6CRhASY*EfezDE6~3&NnsC%mRMJcdlN*)fBwZ&&@dtxMLxzopW;Ieach;#+LQ}* zYlPXz@1@L9YnkU2<8VCbYIQ&3e<;0Yzd_ECENUZI@X26LKhoRzAK+dU%|E9dp_w^?^MN^~9M!m0QZ2w9 zf03%fU>;{mD~rjV^CTxDir1G8XU}8~g{&>E`cm)_yaVQCZ&vN`ntP@9ETO<=$eHvI z+dBSJ)r|X>!49JyWAI>ykc~R<+_Yt9Y%gU7B(!h7R4sFnT(V4M`!MgZ%`4e#ih!}* ztj-rMimwH)l)sED_?8zDmoK6s{T1Q3fBK^OJ6y3t#KEeY1-w)}6XAGF{(jbE%ZuJb zRXnvcUmSonNn{RnK`4}-Q+KG(lhdW!*)dpm zZJAayWqE?p9=cssLXNVpqTG;uRm4wg-o<{F;B;+USdT2#I9eD(lljWt20P;&Y6jxStyt)NMmaQe zvwjV+d7Z`>_PTX8+Uv|X843I=>rHWkxxn&B^GQ;*s9%!tM#vtpqK5nOf2g?B+meR1 zdk->?5b3)jA?+h;($)T827cj9vW3$Vkx5YQpYJALfc)Q)x3lzi-r$TQe`Kq7j=w!TRTEZs zWX?gpyV61YU>SiU^B$fUo6q2weqW^_>M+z`k$M6f#`IEeyXOZU<91@C45M;+gF_wG z+1yS zLF;u&{FUq9?%tpGe`YeV?>d>+B{9g8iX zi`5Lp`$;_u$9zWhFrAvARXsAxr5dZqQhTXkUP3N~ljSUWHloC1u1}cjc~+br7}B8U z)MRztRL@i|DLos!oVq4$n%BTzb<7m#P!0XM;N3Xomw=cEMDMBM_|Aj!OaReUHKBNQk@WCS~qa6$v( z3wv((Z);+u3yN-|9a;LwM*ciXP;#{Sq*6lcQ?$e2e<{=5LQ^~2gIHFuIx&us&d(MG zBN8fMrFKyd`)EX3UG{j#RK*p~vw1t+$4EX}$-LdNCOF;tg!Y21n8)g6Hs_c82Hu`K z#XXz1r#l;lS)Z^z1$SO-q#IBFKbX1_?c)GxK$gF$Kk%c{4q(S&;Xt9V_Lz{*BX+#n zn?M+OWY1efvVY4~iv55f?QU>jQ5FnlPk_C>$NDN8?>+{erktMx|Nkpzh4iv&EbM?? z-x=*ON{9Qhocv^F3fFK&G-m6;KRQZIVCTBJ z4{@amA5EF(Xm5Nha`n(fWI*#i?#r`oPcZ_&(NCBDUYQ2uG>E z9j;>YSHl@U1&wn?#_;=0_RHT1#97CXJ)Wx|k=`c#P&c&~wR=jQ;|y z)d8BS(|_?>DqdeNchi5s^&z7-oy_%>4#GSav*E{zxv6(a1hAq4QRX(HbziG4k02jA zW{RuB?+JzANj;PHCHQakv;}7fxdOb8)*en%kq*O1x=-#L?m)IC?cc1!*@d|N%o&L0 zip(vxH>ygIvzprH*`j$?+KTZK@8ejh7XlsVJ%7d9u@9oQgNkwx2cd?iP1DRbPC*|r z6ut6eYPhW{zY3n98SWT7GjRZF>TtiJ+c((-XR6vkin+HqrS&O;hrglDw){0ak#x`! zazgN{`5n|_rYpz|!SB#arYmbZ9K7^q_lo!&HB|>569yS|n5=Si8}r!?e{hjXPJmU3kWqL-tEwEB27y zRMVYGf^yB!yQ_u7AU(hKnA_SkF|fTP4`n(3N}~}wFci^_-#Whw>=9YylPLN;>sR$I zePXFAl;z-GYHDvjsqR3@3L~n6e?Uz02(#dk-nL09R#PLd;6 zB4Q09X#9KlpaVZtP5cKupC4@nDlS_L>;c>0+mfZi4LD~4R-9vd zV6TR!EeEMhuqlZ)n&*R8J9+bQ#;Tq@3ggsOI4X-vXMe(7yTJYoVi z=+);69-u9v-Z{rvL7T|_5X{BNU5)LZ=#z5$B|ebuyU^!)lNM0@m}r`mp)cU<8_ z7vUVh6@b-nnQ!5W2VYUWY-rIo=BePDq}Y1Xc^cLv>;c3uhSjiE(xmUKYKFD2dErMZ zKPFpcUV?)}V;hpOKVVS)ob03Ga&j9_TXs9Y)jSWY>gl^?J%1OpT%O;gdd6REo=Q&R ztjk$PdDd~h^M2oWotzK?WtYWYR#k(9EVhrYO{RLB6^(*vmbly+&!q|PsDF-ZF(d=l z53E~X4pz341jlLRg4)B5kGYR^qw~HN!CJ1#v~R1da4f}|_mZXDQ1ZGaR(B>e7jcA0 z;<6P>ZN8lMP{z8*{{e6c5l0tzTmqqw&Iu z1YcR#ZX8P-&hM};J}=ACS~jp`ecGVZ!A)-~W|g@~E`NCMKHazw@Az#*{uw7$VV+>8 zImuk4Po(=~k)R(~RnmT??A)B89TRkh4nfk?QPN3zGO9t0Z+_B(Ace8+vSiFIATIxwe4$d_i* zc0&wkoTRJ~kGv%L1Ta^-FT`hTAsJ5ti%-exIdG6+uLLc>jd-k&J?tKPZxIfFP z+NT`uE>m?oE9zar-Q+9mQpuj|d6pVaS~4C|bbn<(j_e&7`@N3TUSh*|yYh(Rw6ns} z>6mCOsOv7-04sHm=MZSLmK@|@e-ETa*UH`A?ZlVyq4H_(Oyd;h1wO^&aZCtBdxi%$ zfRFw@NRlt*{Lt6vWoA6&E~~F5M&$zb^Uz#5f9?Ni<)L=Kwby(yXTNSV_p$XGak_NL zcYndYjco=!dlA=OWYw`(m#x64xuJouI;HqLt~v1aj3Hep2G<#C7LbP{aHV-Kk!3p2 zE$j|lT_mNp5Z0#XdeSxNhgGGCwTuCOx-|bVDT}Ni(=71c_Xz9I2W7w;OYOzp&Z-@l zK~WyT+JJCR-hA+mufzEc%S_m7$hq)R(0?yInxfaHD@#?sk*^B-Yw%6A(GP$+mKvuXacKJ9)E6} zh5vdJ6yS&76T?fcPGdS{+@iy@GE}nkvm%waf$h*$t|#ZZjqj%r`^ZA z35AbxYgtvPD-^AI+B2N#l(oezvOYwm>;%vKR>=n8&%!h0xSX%+CSQqe`Cj0aY6w*w zh+|b;v+5CQwUMIYGWHh?#;jg_9e>s1xxjQ*Epa3X&rv;Ozk)BErfe!!p{yjg7FA`O z=K2DAK(b=KaAzP(T4HYVw+HNC`5sKY-Y`|pQr?mgnl6$3Tr)FR-(HUVL0`jb&}DUD z_~aIh-+qFTV#IXnEvY02$Su#a$V5ffk=_uCXei7JHMw8|fF196m+aNo*MD}v(fEzE zFi-#BniSDwBfL7{F0**TnSmAsOCOeIGpWpm#zE}OKn>H0IWbp8+I0o1e;9jOnSXem z4NU<5PKBL|v@fD@Av{wm|PGVK$VlHNatyIq{ecD0$tju!$L2rV4rsnyop3sD9 zm#bHL8Aj$-Xu_f@u5al<<{Z<>tqtp`w)&H}erU;mM$|KJW?Ac|Qh$e3`$7|R?c@_x zx93?&W9$!2$g-wA?>9+HoE2;Vl@Fu1pH->Pg(f&AW?8G66@TXixWA311=xukc+5Gc z`4`MT5XXdB!Ov|xhZRKNYqas#urn-eJ=dp><@&NtVvH@4jm1tp@-@Ff+#iV2jiW{{ zdRK9Uk1kSieTY8ulYf=h)ItKyC)o={dz}@|ia-jdS~jj^sW}4?qez|eE!94erTVFA z;}qO)ursUKt5`vYabtHGv6<#mZEOcsouY6|9&VWw?(S zmG!Q?tc)x5F0kp{R6jqM>6GGiv1L78dsA3EQ}0ql*SqkiV1F>!Zaq>{y(@IF-sSu* zbQ|CGoACeqNX*%UVz?@*+OAP`Q!@f_v{dTSKMY#^Y3%0qMoR^$Jq3f)W3bDY$|p%6 z)6DFSNYqMuHgr*aF7>wdteRAV4J)&*E64_}3yw5}=8y{GL{3fJg-ZiAj*NgHfB(M7 zdQ*Ea8~b%!7k^TOl+oHQjQ%3BcV1TQ5%6T<=_bQ>;Dav_gQbHq9>Tgx>r<+3x-!(w zw`jY-Z(V|M8;qkCC5i*Ui#BOu-6qbU$*1DL<28gjGzH&SM7x{;lDf3=nO2&WYOoI9mrfknsP2(%Efa54CCJNOpgUx=-# z9mdCw9e>G=nIP}Bh5JDp9@WG;CU}p*oV`Q-LJci`J=E=rsa0va_)+RP{0??i-NSX= z&MP!{Jy;w4L!A@IDwNPNPoEBa|Zi&jdbXuWg7eUrgpX>QuQP5 z2z9*iqH#>YVDBkv21d!~7QSWW$Emla=g0@fDOMNtnD&rXJ^$EM0+RJ*7!PL)H{toWAiR(igGT#nipzw@k6!HqH ziGMfBJxdc?vVj_EndTO#eW7Uf8rMfXvsdF?=WPCuwrl{wc$CI!gMR9QU+g9lSpYvo)5^NOXbgLskvzt9*C;pD?o%zD}~G zT#~_OhOawjQU^mFnAy-g^TvzJqf{Yu4saFU0;V4g@26#dj8rgkt*#-Jq1SRs1caSYZQ!cf&`3Pp#rbO zd{5=bZ+wQO2gy-m2{{(Jn0i+KH0`)M?$4i>a=D%40Q}bJ6Q$hc<>@iLZ4JGVYU#Wz z$3)u2%C$D3i|H|rPK;wfU?i~&Yf%K1cUxMM0w!pafsiqXH3dKUAf-Vxy*^wflY zQUSL6TSlv5t{ieqVgK@1_ zwvZG>v^XjNcVUddx+2sMwn->2z$3^^PgGam-}mG1^nD}cmi*0VZ%EaSr0qGGH37#= zw#PU{6RR4c|GjMzqJewI@b-ei+>**o=@iRyTK;_aug2kFuLT+027l|;;a#vZdHWxJ z2mgKm`m;mkNGhl*sl3Fl5(g~G$LPQ5LGF*3s}Sf< zRrYhplZ|I|5Z@n}4g3vu6*4~gIm+?>RdU?(KjsYM6wnL< ztxq7^E-68rJNO-7oPYSkai0INTq9-t4SW|P{e;5qW!t2tc5cu8-=yNeTFJy}LT^$i zx~ZLh)AWwq|Nk$2ZHPsQI8Jn>zZ2%aJd{P|!9Jb|`{cEIvq;FAL2S86?pZ&agIcXG z^+q$TV0rG7;>liI?fM4p`yb~Q{(79r-wa}Gi7BP ztes12J_%qfj=ier_9uk~FrAi*ifFL#Mv||oYDKqdANC;GhH%Z&X5^o8R#dhyolIx= zfW;$agfpet-UqFI%^`k(qAO4ns^BV_PSw-kE9`e&089N%s#-OoU@$Y-F)<^>bs_C} zvp!%qy_a^-;(y_q1%j~(?}G~$mOYPWHe5&BF%(6eOsR-?Dzv13IPH4lIchO@_2=+N z@2@jXQ$3mG?B8LeVjL60nWkB}t&-Z@R+3#X*ql-Ba(aThnMu?U{ln=os1IuXJO6vK zr~V|f!qy%*AfBPWK(-oox0C@kiYske#Y=RbF4nAN0| zqWQVC$K12^iQE;95A4mw_r-w&=`rxigs7cF?Yv?v)?QJcOOFxtfgzC`q=Eu(r7{5P zt8OZ%lz&<={z?O14q8Kn-1p{pV1_$DT9uOw zs^#8&%Qo8v(S`J6>aG0khS%VmK5@0ASke~izPDlpQM+}qg;RC0iap5qqWnz+rHG0{ zIS5_}$io$?AG}T2lh}y_D=&8np)%wltMb94r%Cd%V-XG?Td`avOv@Y+36bhy?{*TjENotH8qa5zx|p{;$)JhAZ?n#I zU10LS0%#>gp^Nx!Jxek@WmKYfyCWtqD{Y|olsU6xDJidL0xLESF)R={y|SgM43Vtw z)qir9F{B*X{g}a)H5Soou<|4U(f>W! z8H(on*@a3eIGyY*+RJyR4b;y_TbMSGKaX_+wApdGbWrGG(LAgbrP_oz;b*#I^kVz? zf(Ot_T2uvhk{FzB%dvezk}`H@KDy|?%zwL?htd|3OrgR1Ey$BqO@r`EwI428UiC5A z0$RD8ea&+oc?YoKgW8An8-@b*IwE!&>A-K{DHfBVz+l_YLH!FABO1V{TWx-%Nk)#wp>fY-h>NhstD%P!N2MSt&+67Vb&z3+makq~7uZ@yzDJr|!l#Qo~_Yc9JSY?+LdDKZ7-8leVTCIjwsy8?Uo! zV$%i{y=RdcPrge zaEsBts)kdlN%$f^7qi`^gH$7^w$M$G3b2zMGfm@he<@hsH^J$O9)CU&@qqdBaQ%C* zR8xDENBAAo5pNRLp!qUyHu(ZG<{*V4nl}4KeRx-Q2>0HdJqhopk5a70h#e7~6@e3h z$I32a&0)dd+9Spo(1Ui61NZP#{R=i;#hokNEgd4~{^`nh;~A)p4=AGZmxQ7NLl8{@ zv6vKHptH^sTTz27#eaUZY#Wn{7BGXc*MwZIUz2*4ISDcarKCD^5xb(`{p@?LtD>sy zi*fV~M;I7>~Z|a!xl^ z`YL9569Q4ed8NOtY9@ctDMNFNCCo#f|6xy5ykrZN3KcJr&1_HOdew`|j+fDDW8Zef0DvD z8Fu>O{OvNEa)R$0RZw@n_*IrQ8$zl;9m83(NQu8Q{C{4_hI*H7owSwwrEze0vErcq z;Z-$?E8a)Bokm*PirBfeheI87BHG6&+Y8`c*qcly+FE3{XJq~ozX@>w4Rah5#UL{n ztM;`Qgmp}&CYq~)RW(1=B&-Wv%wMAX4fwZ5NxC<|nuTa4($?@|>u}Jtmo$?Qg-xii zh>9!Bn}3Lxm9FQs#%CPQt2@%idd@VS^PC~Y`cLdeyl(!Iv<72L>22&LkozibA=(O) ziFFL2j-n5lOm-%A?3%;D%P>PWtIPMdd-W=^3aN>060*vJ?SOt!9avORtKyYI@t2$h zn>7LP)3bMzjjQ5IH&|yol8`mUS)rK(o=T+V-+u-+k&Ju*YeWZrStfO|mWg18QJUHg z!*kqQ#D=VE*k1?Zsm#mLUTB(lr`9=}{7VfPlgaJGE=cfu6H1oi)%XN=wNGuCx zM1LjD#?F7U0s9jXxuo=A=Xbhx)eLsD_lS^>)qe{YMk)nVL+a~{?-6ZY7KI*ch1hV{ z6QpKE7zhkxo-WpLfXu{lCD3y3eHrPnypFN9 zq~0Y2#Ph;BWb9N#Q`(ZqZ%HKtz?zN0$kha!bMU00?)I{8m zxRqc79U;ELT49~IpZil&J7SsnIb4BcujQ|iTC+42S&y+62eIhUUeYwVGIB6aFk|YL5hl*ro*bP{W)R84qD4A2PJV8jB%cVSmR) z=%UQl{sFy!{nWdeY{KzzRr}0kVF{uvB*QnJmu~$T1{-WDa9)N z!#H9M`l8j^Nr)4n+Xz}^A7=8f+QwF@z2e=>888B7AK##-I>C#T6ug3>Mu7I~vQ1Gv zV)er)S0T!z_&btFtxY=!(tjOMfdi2-D?Ljx6l_&<_>F?C%wU+o?9{WNi_}RuYd;L* zwO9#-D3L!R2=Bb>mR$tBL_`!TTg_PEjBxgw+Lpxry%c9?`_+rHA|d zNycJJc+rWxuc$cFYwA9JZr)DPN_IuPMoh*xc{@n`%h`!w{i^wpSIBhi_?|(f-_6iLe@HbT>5H}u? zK8-Y;+@KFmHxBh|G>r6|mkeT7C@UY>peZ@7=$5e@(?U~&Z|gr1&xcfq zpUy{veGPt$zuJ5_@Fv!RdLAX8h2L{LZ$0MAA(t&86=fM!Spl|)UmXX&!miR^a?5N( zQ^1c69tbZsj(;OZec!MP^RmE_RjP(6hDH63?u(l0Xpefn+Ms$Q>bI_#sOeENqNYW? z5cOi{zwO(aPr|%SDu2PGti0@Arg;Xe;$bTm>REnu#)`)E+ODERto7&Z)-fa{BZ*41 z8jKTbt~zFxrwJ8YUzQil?%k||>2|O05y=AY-Otm)bp33ruqG_|Zn$oWPn6^-VAaAFhCcCIO z+(n@GKz{=$6v*Y^yh2;qSN*ry(c~RPH)v&|Z9~jC@l(wtOJ|5J9l$3FZ%}hnSi@5o zyK8C>UoIGIHiX}U`+JD%6W%aRNn2>;>DL@Fz8tI<6dte|R705!>es0mcvs85L`EE{ zhu_gOkzGZd?EHHi}_qwE) zxrqV&FYv={*xOWE6{0|IVg-H$k?ytgWNnm;BUkY=`n7U~Do%MAG~7__ZB2AlNo_}c zsjHWYYHHC)4f^_O^`A_0j1#>H{HUzQjn6lqG@Vk%_}^YKFnf4f6q9T$ZeXZ-YM8bQ ztA8!kzGb^~>m2y>D|-ZsR9`$3a*!qcv|#@8O>ntub0?pf3|M6!3!CTq>7!SC#L#E|7_s$8?x zh1QW8bnqRd@VodVdTrsJqHIqRWT)1Z*Y(H8{365OYv3ImSBHl7%jGus}ADBCZzkgAA ziJD;%Q*ZO5tS+|%Ix``6N>w#lgP;Kf7i(z1j0}2T>QQ`VD4L4XKg`>i z*05guZ(VHKz^ae47Lit4JA2q1Ab)F#k=S$_Vce2Pq-s^ROObC5EmK55R1IO?{I}hA zSEc^Y5R1sFsEm+dOPb- zV5a|!ga~t&xhge$j=Wun!dCuKgFXXnJLeu3Gn(5$wt&ZTiGPq&!U`x(kGWUMh<~HP&eYrD-I(+^ z!U6FxTV>GDphiJTRK*pUirdOf^jGp1V$O!Jw{+?+_?pnvi=#u%>>JD~g~1uwON zJ-G)t&A`+To+K2r_~`UCE^8P^@EfP=jx)H$gaXi6$;9qEvA~(=Zs3wd!yAv zSf_s_^=#TSHVv_<^iMl0=*rOR84rp3%PyxClgrk4%z!vz0@DH`VPE;FHg+Z=h!7QB zDdjfk^OrEK(tqEW6;iAI>9C$1t!Hs35jC;^RgVp37fyxG;w`(mK5v41w*F!ERVp6s z=eoE2?Mv_Jq{m(cB5D?BCWZByNzEtSf@Tu`QmCV9BWA}C*N^LS{Y=ibPhw}*mkQ$+ zQ;R9NV*=(BZI!Bxnn|u0#Kc0ZIs8Gd4{Hs;&pc#|aeqv}47PC$4>n3f%LwC|+WqW3 zh#L_Uw2V7QEO+;}{$H=}#fE}ULml^gem7dwOg=I7Hr9Gzha^90(YxS@e?UboFBSU4 z9n=g(H|!$#r7dpog&i^2<--{$Kjv7yr>H~TQ(`H}(I#m|doQ5{g8fq{olOsBzsMQ< zoru4V6@Te6|J-oPw8l7;%%!VIzxs7sPUI7|hh4>ffNW}blzXL3r(bEl9+aFm_4Ag^*mZ+%_l{{2Vr3GnIkUF<3**)olLtNaD0*FKAV4WEh0Nc$2y zzna=L;30aC7)Ca=TbjsX!)sszy_sR+`f38QZQAWuXT4=aDWIf8YBRS4N6Pwy{Ci!l zPJih_R2`<15{Z%o;Hp1v=f{Gd3Tb?fC zGYm&X356>@lwM{>vxmqRwj9?E?xVn)h=}Q)jq49|S-ISmX|n7FJ3J9PYB4Joy68w^ zuaPZj(`=L2(dhHlSBIVi`=pP*;UM65cYh(jG3b#J#U64zFRSsKzdE=}5iJfNXR@qh zbJ~|#)_?*0&LDXw)S=k(FHxd$@H&G{6T#cAyFVut>Y$>$gTPk(m#BF<$IEvZ_-$;QyQAX7Au4J*dE;wCAv~iOJ&sA6*<$q|; zgjDHH{44M86)!o9gJ(%yqmWrHU4T)-9G#l|ygFAgF7FZ%6(!*w<~QNXAOnw+Pr=^! z%KI(+wV(8m{efSEre>DA25{dyJpsg}fgf>t$;Y%gIGvV|lTPl98g3YAb*Ve3xdHIW zmW`v{s@ehat&p6;-Xr8(f>o1{Hh(SL9+4)(Key6Ggtd&k{f)Ttg?;D7Tep5+xUSxbS?z&xlEpFAPLpHJHnxaxdn2YPj=TDsI{FP={r=nB`4S zO4W~hpV6=6{+B(3@pXE#bvU=v;1n%}IIo^rWqME*Y-&;{NvrqKf?sPUm)r{X^XC-@ z4IYqDzh@V6%aFy?5a6m5T^I$7WVkR3%-_IHH{TG; zD>|!ES~iZn&Q)1wW1pm9By+%j8$8QGokNiy_7Yks#OQh1Wpf60v42xN(#x=OW>)r- zKweg8ALt)=cC$epLp{JAsy*!dmVI4&LCp0!%*Si4a;G_E#R6LnvPU}KqULHx)_&v< zgJ-<3Xs_wx%C{;n!&=>>c$iZLr!Sj~N1-H2Tj<-iDqhG}4u#e62~~|*M(-*8?=_>1 z6UjTCL#d~cyRIfT*MIDosV1KP5zn)$a0hs<;`fLu++S6a?ljs-m9&+5NMx}##P>uK zvfjL=|HKs|6k3N9zk8PZt>ARBMsY?g;Sf_ z>)uKm2)p$jokbY=C*T{RiIqE61ICHq`6iQOes1OOsCeNSkp&;WL!TJ&fKy~NaXt~f zl)JmDP{Pz6%bpa7yDvUI@9vr?W(Bo*Wg8nG*p9e_*!QU!4fe+T(m~7%ioaKn#TaSm zB3h|gRz#9ZyMI=))KizTQ__^Wycd}lB+be;1-r7X{3Dr11Z8X;vVSmna%C%8#ioDB z#r!L_#ZRxq`;PuW+QBm-)6_k+X7bZeTDY#w>&zCJ!HQ_ZNGi_v7sDLO7_8_~9ub~v z&^s%Hd}jqn`S&7yYfLL>gLkZck|~a2M~AOFD^hzs$$z4r3Z|OEpMfmL|2D5s*?z%f zltqIj8szQH?|$fDw1p61$%1wIw!5+db$8`1=LJq6sv%j9>|^;A$jlpwNS6*moO|*7#C!fjtp?4XM=_Q(v8GLJags=N;lp`SQTK ze2W|-Uw@Fj(gmS_y@OEo0}>+w-h_ zo29et>&A0(t=ds?R*tTJ8rZ{R<}bk`o!_GTX4OAt58{5(RP3v$LnHU7NN(sYT8$h^ z3YNW=mt~&HUQL@OBd>#pDMx7kL3WXDL`=l`-hYN(Wq~b(D-G`stA^=Hu&?(S<{0J_ zC0aVY-~Lbutd5Z`a0XjQ%B5e+UxEl8Y110xYmXGRv8#;f#Fn?y5d+VFU01fqHxQRH zf_b2W$jsI_p=`b5xx9 zoqs%c_ziKtF-Bc2>ai{zXUlsL&huz`3}R~4GKd#S){)kRUicnq{; z9qHA@F6xK-hC2rD;TSTNVVx+*UlZ7VFc$h(91{aF9wyTYw%&;!5O_)lQ6n&4S=eSw z$7)C>6DzG1EId;jsi-{yJJlAM@%lRUrhjpWP=HTKT@Y^6R|g&oJ&z+LvXtNAVa7SX z%@(Gj<}bk*l$yXjX6j-Qp}MKvXHazOU&(Dv zn+BE-dPfB~wo4BhzLRouTj|$ok7QXR-v`fcE#_Jx_wvIXkc8j?((3#c5p#ugB!59> z0VxoBCt~eN_iSR|FeY zaU@XVB9gZmR^+#&!i5a429hnhjU_M&KB`{lFw&YY(RV?9Je_q_&AqbHU4NGKtBmK+ zdq=N?ZYsJD(UPji>>kLyy;vhs_E2LSt8Qv?%nUq+RYMA}7SZlr91t6^2VcBHl|bknj%a@~)fq#8krLlSQXn_^tkMBhktHR$h-nydVca^^qv zJ0lMl<`rbjg?HF%*@;-kgMT%r-gm{UhTf*8(r$e{j!4)mU65WTCEO~_uLJLj=Sw!M zs((VpcyTD2RqGtqR|zYAO8CG5YN#PD zd|ms6BW6_%BCa{wRYRMOdfy-??y2^;>u=3yuv*)|Te|B#E#kg_Zhwv-N3DvdljUef zKGn^D+QjnyL6E3u`a+`iCnW- zZJWdy8V9cY*fduRW$uAwIBXXtI!smtM9!BE6^@D~w}DSA|o1 zv41=}F)xc+n{~*)Pr-+tZ0OAvg}$bv!W&^dN=)RO*Tkmw%76HB$ZbjC_?xcqtN9zg zZNcexUdeyMrzLQG^^ZJ4>bv7^@b2B?lgQiIRiZw(6|vzov51c+ZMEq9XE2g=_gML! zz}x~A4BcE6kF&0c1-p5XBW76}cttyemw3C7k9TRACR;)B&pmNs@X(k^)V}gFt{5CW z9J@R>$y85N?SHd{Nw;>SVzmfv5fZ&`qw-^%*%@U&pV;%J7=2bY)p?O#pn7 zWHD&E;#mbV`;+~FmR1D&KKssI`_UTFf5O`_Ruk#~s}#IGi~;&y1oe9ujK7Sl&Vk%`#D)?x)Q;&M}Gto)rVvo`*|eqBIFxYa8cJQ3<#tXXZZ_MgyN2)vUR}t-aUQPJ(ArB(CP+GjV zP)Eio*?(&3LHQYqc3p^|X&D;udf>f*uOodOVc)`;%si}!P8%o;M9IMQ&3b|4Q@7JWYO8-sI-5 zN#2TRSaV-iyrlVGW(9aZQOh$Mh9PRZEfv>aB--Y#drELj!Sm~L3m~huVN?-ujMTTvUkK|lqeQmhoyzO13;9z(M#9tJOo2Ct zkvhRKQ?*@rgoui9A(dM&7a-ppJjdI$On>eaO|18b^V>+Y8P_R13HV@m&H7SA{J?4QGmE;~Da+F=H$(aSQrhLyXm>iTKhfZ5`2DHKB85A_bVA^E1d+* z$B7AiZkv33u;yxNFZy^*M;r7tS4l$lWRUgQi@x)os$b*rz&G;Yowei^^M8;cni&ih z+!pdd_GBp@w84KseYr1AS5D2v`LIob(Ktr7T3uF`qUTP>X1VNxXS!bb7e*b-2WDXf zhjB`67xDsu1j6ch8pjSTw#rMP+qj}Z!N% zQ04oNU_BJpLJ>|gnrg!eD2yAF4oaIwORnMGBq~09ZN=P_d3kO`4<=R81tONZz=z0} zy9bJq?MxnR7&%A2P!1N-eavcLXGS#S2V@iZI@JVT*d5In+})V0uC6`C%*bEjPvX8; z_gVRf=jAi7J^EKLdw+{Hy~tz0ynwg@fgz$^{|Z=UBdN8&!XqM^q~Hg zG?h32J4#`toCd$Q3$C_{w1zGs(lZ`ew3=HRh$FiY-3Pl~$sBGi6{p}4+X{Ru);?Zy zJX^GkfpcG=hA}T-^%Z<(@>d&&7?4M%)6#i2n;O+7W2Yr9-+zq1Ah*(Cl+M9u+|9n` zlP)YzAi?^&ycWU+FDw7)@vw(<64k~eb9+=nsHmoXcluHlZ;r=&`i&{;tOo@ej(1%J9D zT@J`tnSY^>1PpWF8W=OH0C@-AW!_G#tw6L&>}Vp(;kf^B7Wg(+HOSwU{nC46BJ7H7 zel`@XNVe!I7G&MdUs8KS*o65B%)>|a4d(dsmt@`Mb|~^gH_0|(ms_c`x}}N*&MTe* zS1+>AI4eXwSg~hFr?x9Q5#te|Xlbjj73-3yIDhR0{S4|L*wC&1+nUM5K}u?mIVLo< zhi;-~w@o6Od_znRVullK9s}5d?!C5Bjmew=_EfndIXlr8V^oq1w!=H37Bp|lJmCSf z-T6_lPwGIbf{n^vFMJw2EZ9M0t78I4X!gDlq2ZJHmA|XM8^smIHn0|So!&7)O|)J5 zPk+eSlzA!h$ZqN_vMYBAG9-Z)!~~~XdAwfPWh-C&Iytxe77z0ZmQ{M#Np}30vrNO| z;ob&f)EyBFD=&dXdDPMFnAv>Nf15uKeqAN$C0%gGf!bpV)FiOV8n2i9jhMin+s@nn z_;%?4!*`Aefm!v{cB8Yn_L%>+|2CL>J?Fs3O<3iC?6v^{< zVparv@5!p6Y%VfuXeLPt#SC&(d@S7VR%$N<9&;9h#s|qD#*+EqeY0#Xxdm3g8vMba zA{z4`LOIw{Tc~)jGtx;5qA`M3cz**%c^A1QEyb=_{(SN4>KLjXXPMt&(FuK)X^H_b zH?XE06B^GsCO9U*b>23_X<}{Tjm6nwaJOn-+VhTyn&Y$*tD&)On16+;Mr1p>27KJ^ zz%=#E;M<1p5VMZhC|D=N#E!OfW{Xst@5Ra%{I2!_qAcp`u~J$wK+&Dr(|<55%c>aX zXm`$`s+S(twX60uO{5pHD&#R`UXWgPR?y&I=U0#2sgO>k4I0>ox z`w_5FCWDPvE;E$hFQfkNY60`VucrwI!2hXqR)Br993I_5Tb|%E5}s(jBn~ovqj;z#MF2d#w>`wj{g-nd!5YYh<{R8g))?XOn zx{*bdgBjPvmfl7-6Mw`y4!;l2^*&fKmoYX?zCzsBaKB+r*=77UFDu;7j#mE0SrP7+ z{zg7aJxe;pUuHZ+b`zVIgx?^a3Iul9rn>Ho^+bhT5s1Mp08>D$zmCH1I_HqnrGu!^ zH3gzRwbxnUIYckcn-BZ%{aiD4M>h(HCT<$5Ox zZ0cEc^`d@cS9MnCOVh3^N`f1Lw~F>=i+BzE;gn1iSX&$E1!Pmj0(La&B=d3Gq`(jb z4}QtpSq`uq_LCGva{gtmIh>&yVsPqW8wE>e=~+6u038VkD$3V&-C7)V6wzHa8m={~x z_3&q)8P<}$wB)?v(2&IN`_*|QrQQ`@iuncRp}d{OA%sH2Rhen!QuuxS!{PT0PbzqR zl;>Hj^f8|?Hygbk6TF~241ktvV8 zO7^DggzsI@v&NWvQR>NB#{ti?jsrElMTvPF*{_&Ul-Rsp_mt<^`ZdOwrJrRyRP(Me zM)k8$wC^wA$>fTOolw}5d^y|FFz`0uj^~%Zx{d3ptp=+ zSA~0w$4OcEx_nP?m(m4R&12jtS*{?nVdWJwn7;<=4!nPj0zvM9Nf6e_-dr{{tSpyD zE{j{nDJbJXsw>hK(p_NBCwtEP*qvlzPjFq>^+OGlGXN3WOfC1Sf#>MZnDxZ0{T^{A zYFs2yzYX&c#(G#wv&+YT-TJQx*>~5v!MQR9$Q?uXN=f!U*4Vqf#xlYMR(hSx3b@l~ z+b_r#ZxnyAEiZM&)Ys8=@(KH@Z?btjRtc4C;FMuKdlM^6sTMxk@Ez`Z#W1SP(Jn2a z?dI{U+F0xsjP~$kaf1*1Y|pc#gkN2>x@3cSyf@0671lTOvNzMNc~7~Iv7;3OypIdd zNCg;g0{^Jn`l>O;dy&ocbLyYhS2O>lT7*7oEgyfKG7syS!8+MZ_SA9Y09b=FKu$FM!{UbKlinn<16f5ao!)5f5?QOgpoz8b zS9E!v%{7-@ELu%2Et|}Yq3vRs-PnB6JichPHwrVRI0A<6QhTYkGM2VeE!60xAK^F% zVcxwRFpA>t4fc-dT#u-@Qg9W;~^)xD$JQJJzTWf@SSE7KdQ2; zX!Y_^M@;HjxaR#;LAD553`if29bGn15uJKARN;Bq^GaqO zMp45_y0)KmuQ(`c!`8HGf?Kx!df_ZOlI^dC^Vz@?r~`Yds>~x-EZgq8Tbd*zswNzD zKRWu4+`jDY43p_SqLo<^?#=e!d3MCE^6p_)EUIGO%-R3rIqt&DKxT%tX$$Acbxwb+ zrGv7?h&OH-lXcs10Fh=De=i-Bw}p04ad~dUy+SN^X9ak3N63ezgZNouFmFrhDWRNP z@;+HQsM=*KL7yA1%(OZVpf3sE!N^Tzwg~UZm7Z)5f5Z18c%9psOv4GTwRnDJa7uIzuex>)7~vQag}G^^f4wb4?RRoo9U{t@;>`dHNv zcDM6WVqSLqzA@lJF$?EqJV(s@EPmEcEG>6rf%d0Sa#qw$m35pvI@y!Nr-(@rEi=1_ z8lPMsJ5%KfbRRsKS*}p{^hfDFPcxYZOIF&Nx09|^C_>Q%$UA>W--(c5 zH_2$Q=WW@rTE+dCJvTjw5hDH56&8#TsUA^{;MN4sB3`~fNouFo(v$DyA~BB9OwKyQ zDSa=>lJP!Utngw}liMm9LLCgqQ|!CId?J%9BEkH$dJb6k*8(sHZh?xcFD2#P zQ`r3slDwas0B^Jx@y+4YCGrpQ8958q+`V^l2;RR;cJYakZ{ZL4r+44qCD@Ta^-|!| z^n=!)59@U>1R)n z{qX7>td76IS&ot8WKV4m*doY|cOrtzD5ExFSHfC&;{D_>j6@4uV;7wDQ+VcXIMYV> zZY!Mm131GcaNc$D-Q0hIcfW-rHo~{@+IX&h_~s|@$vXJq_CqegFU_Z|0C>O;F>to{c*I_dZ+EWYUy^-?OMR< z`s#WrY7cGEx+*Y}nF)kA$pnIv1ajdLk{B>129VsqfJ*?iqOO0ZtJStDtrl%p-IluR z1+}f!)uJM$N9|T^=~@q#_WwK+-Kx9$`+xW-A(@%XyqD+xe82GfHtB}%K>ogM6*`9gbT$(!&=s;m?_ zRB=aXobU|DKYB^)4m3E;fnDLt;92^S#St^7VDb0yy92wBo1Qz3C~4ULiWyGbt+G*( zfD&xkYEayq{oQ6$-pHV@+h3s=3x8I^UZ9Ch}R3Xo*{aWb`MV~Ky z>1fl8;FHdjKqj@ ze8~PfdogDAR!u^F7DT*3e}`ZxtE1^-C6+f~<<%20iSDEhi29`xa^#_J2zKoZaMO z{bUOJ72}ZYM;NHP;Gdw%IjHkT(mjpxW*_iS z+@FzkN^ZbTriz7G{qmv81fRk($U95ltBS?yTCO`Mjk|$-KVY?Zk--4$s8o_JSe=4U zvGjz}YROXX#n?@h;i%~~l1aU69$xi1@{{@c`D(3)Y&JW1-O|yv*>#|^93${~Ng;n@ zB(Dnti!F*jVDF}CYyL=B>78rNC=;^!&0k~85OtVPx$H65+2&?yO1%fXzsX>sS|psr zvzUL?Pp7JMeyHF(ep7p&X0euf}qvEG{4*a&Adq5xFdrjoDzt`7L zNbA~9(lp1!>a`gahjGOaUFl$I9rgs%*I1rE$}KkMdwxz0tviO;$-0Tm(a3*ob&qYf zwpVbPOt*(!t81 z$QEP#L=mJ_i2NVej(vanh;U~ATz(K4f1(~0xl}ev-i6i6WupSSKr2)bjpa!xDp*P8 zuid84;*Npjl13U4AYo2ZH5?fmrXd~? zV!mr;5YvoYxdf@@G+>t~U5w-E{NH_TJZ~nVG{OOh98pc&r+i{&)t3$7; z!t7dAF)vdUD~IBIY16Pu6uBPq{)eQ>@8|V}eSuXf+G67|kcKJu%eim|dI}OE-kVt8 zM7#0%*d)UODyVHB7G+X-*1c8nJgf}vI(T2Po{jf3TM=gsMs@9j za~-XrGF?J0L|R3ZVJga1s~hj=Rb|RCJ_S$K*h>Yo&il57_TZ z8tGr$+3ohj^duCtK&X<`pZl~ivD#^9Rd zFro{&?`%(_j;RHI#564td|&8*Z8kTX3L+wH%bb=uh?s|Y za9g76X`+*);l+X^f2-=EPZ6!Wy3-Rik6D16>JhE#qWK@h`=25uZp)oKeje!j3aKL} zL)xWanJWyYz`6o;C|Nc*}>N><~#JE&< z(!+#3)XP}qrtVavf|aVc=Uh1z48)+Fh1{1$9eQ<$lLG$KgBI>Rks#!81@B2GvBIZ5 zAiL7QE_I7=4@y_%LP}G)(DZ*-Dn`-4wG>UhQ^j$Ag;#~W%oN+)Ue0D;(=+rnd5Au& zOyJe(|CN733WW-P#4?CqLw7X|CgoV~rDtFSM`3lizF3hOwcEKdSwrD&Pb1m`+VI|; zB!IP?57do^a}sRr?AprzHr~S&>=9he`23M>WAK5Vsr%0M&O+Y~xov-R<1tEyHN1$3 zu6L6Id7103kQ3PL;))}k>dQ6P$)0cr=G4HZOL5ogKk&X|n1Hz4T93D+>4I2Y*MV7L zU%I--*Dp5Po+id58PuqSPk6)|@PzQ0l?g@Z1!;)z9?=TVM*GJVMDciY zB6>yPMOeAXf?eDs*b09@>srb;3U6Z$6;?bS(c=A@Ht|RCiKxS23hi2#3^R~mZx~jc zjG0DCs2H-y`h!$ANwABNShD&_ht6)BjmXoyPMJV8=o2kj!XN88Q2MJo%U)BYayMW% z9`L)-+e1c0&Bn%Fr=aMoSm?>6h6`4vFC0gG19GCc@kdU9-G6`0+x5q}v52ITbxzzt zg{rnAijMJZkQblp8ODs(IMtx&&?lNFiq&)+c)^S?Fw9}asxqN@J2li&m^r_}fecvQ zA$C{8CS=pC`rI@_wUrvKU%uwdimUw5D3Z6jGpk=2XPyX_&m?66cpgXiHyYVj=CDb1 z9jaKqMzKgSJp6wLz7J-}6dqqck93lQ zs_on&3#@UzPa&g5;_T!+l^gGQ2FbZ!6&)~R7pk@w{t7#o z_&)4c$FBL78fqvWS1>Cl0efQ?kHhGS>umA!w%KJj)t!Hp?~q)2Kh|#6F(N1IkUIPVeVCxR3Fw^-!&MVyPk z5s)^M$ozT_B22jE@tbgk)La(^ayQW5=XK-+IkI##*&I$&5URWBA?y{8{vZm*9j1ym z@jmhBJD-1apdKZg$a|zM7knc`WM7@e_Z1bYildwg+86P-f=R~xe4nG&(JSu)9Wzn) zjW0d2Zp|5HA^8j4Ron0BkgERg$%i0cEhXZIiBJ(;~6k0OQSxH?_kDOlmUJwh_}>E;c<7@s~7 zvBD6QGum5&D_CEQ7`L85q(+iP2IRu>+1CjF`G> z!7g#EnuM9|#{A!pqlVYNUXTX&(h7evc(1z01pYki4N78yw!wE~a{I_GDYm2_IiZ=P zXqijtA_don=R;VRqAfyXM~5RkR*G1Fk_4MZTp8=nBp(?Fu3*sw#3&}j{Fj=5W)jiKP2ndVHF@NDio_EgM5 zOOhqx>9@Q1HE2aCr&*Hfj)i|$cT(G^fb&CFi`sNQYtdpCvT25?t9WNlf_azfVSAai zn%)??N)01DISJ%Ta=}_HJFfXJe@TNw^L~SadYS1njb#?p9j|{oS$m0ZtvhLX+EdDi z>{{@No+hiSwv*n-ZPN^{V@U<*@LqC?Y$bnzJHK0(p#G^_jJ!oQ(OsUboQYtM=tAe& zN62a6kBF5ClHEqlar7=? zmtm~(2$j6%3^jigyXzcZIZp~!t%vuQPi}A^4kcEL->=^yf$-B@5#qG6gT-nw#iwAZ zP+yBXJU#MIOAY^{DOr4h%tOpll!o`ksqb(=N!=;;Mz5p%1PlJ{d*6pe=jg@%xz7b_%c#(zmQl6+ z4D1T(_hfU!riM*04!zh56#da~-a=kh_^Ue+pnpXk&I66&_s)t0m@4GBQ4pqzU5hm= zn)mIM4V&0YSPwuH7%!tU#3Hdx(bpUyoT5XMBHAL&-dRQ+o1yi%bDX!8V$+l*;H&Vy zNFMe!$wz;Bj@D&l&!}lFGHPaOFPg@RbMlY)(&dJ--_UP|r|12T_8H?Y#=vK1H>$v{ z^*n02T;k-8<(_a|R&I$*w?64FiG0ZP8S^yLa@s-W^n z&PS}*NC0$pI{91nmw{04ySXVTs8ccI?EBSw3`zZW>M9MLLhP>vaS3yiO*i(hE zwrTfTTF50Vyy~viCLK1T{|0-4k)NeeY5!L7JN}&crRL`B86?fJ9QKgTbOX^f zFrQ_u2JM#tnk}R%b_t*d(9^p=-h=Vt0!H+u`-6ekf0_|3my;0AzdJ9&tI9EoV0jkW znB0GL+aY#sWSyr!Cn2;oa0EY#TA%WR7&-SDmhP2gmL;5Ti|2LuzaSq5W@9}idgDzQ zh6!jXf@if6#;ldR&3r*VARoe>y&|CqY$IRL9N6@i8hb-~xEt_1nOaW!Zj==ht5fTa z;_`tI;8B- zKegeKGI+{=U5ggoDAzov16cyWnztK2p?v;s&qLZq?$f}2c5wbLT(iP)$ofNiv7--b zzcneEw%S-~n7-I>EqjLgHgUroTX5xPE5h6|YvHe|=S04Ve53Ac%u)Bi(_7fjg+71A zMD}RY3N+dm)je8IR=1;9va`C_x0c;j_k_p0<_UdG-`EODl=6e{TtgX?avG^u_kf*X z@qX>-r8~11XU|y8m%T|%SKZ8B908Bp>bK1{%~)x)FE2TvPb7;4C$TzuW2T2YHSe0CJosMIgi6P$%^Z8D}6Pj_{ zV)BXWI0+!qgyWLjnj5Qki+@zzwEs{t$+Ne7C$-n`QT{RIuku=yRyI$&aP=Rv7g_!C zWb9d?M*2Pr#|ci&&%wstL=Ko*v$`9x3$Oxa{WaJJ_ArM%(1kUq<%EMlFAL-8cbbyzE*9!E0(?WOU$p?%pM-LY>!D~e+V5arD$uT9tRofbYrcL}n$T#Ng!9hJoF`RjMSkot zs{0JF_Oza5x6MBNKQyuYW=Aj8jmXqOV|^9&V>NBDe@ME>t6AsCPF#Og?CjO!15-ez ze27(K;mgRMYdnV$J5w)=^d7p)yp#%J*0`*~v@aZ|eY?b2mq9)vAG3p%5!l;BWD8=3 zk!_CWy+g1jntqB@ip}=a+<4mUvQr^Nf-Rn!V@u@y+?d8*tWYGcYhp1ojd`oA^UjlG zTfU2vgAM%ls`ccZa4dglr|E;aSGNEZ4*pr@|cGFnXrR*8DbbF;{z|!fY)zN=TPJ%^qKF}nTxS9j| zsR{CA_7NOes+&4fc_eQ@lR#}Y2KgWPHeR;ucD6iwpy`w@RWnm4iL6sS20oF6O;TE^ zy@nwJC*$Sk+wF%b5i(t|H7A%6#C?9v4%h7z6bsjm+ z!TZ}|zs3JxFE4*v9ez4 zSiVp}uvb8SklM?CNH!@GvZsX(kq<#KT&?#|YHn-}OFkzjv-+EcuoE4*KukJy_R;zWRTtD)Y8%6 zr=2NFN2?yAhTf|+yJy>~T{Y${`@#M#cnbe6 z&jNDWHruCQpTllsj60JRx>U^bfX7hD$VjST0j)wLn&Js!b>u@>Kl6(xz&=_B1$n=yt{j` zB;0?9q9eRo>NuHyH=_X0Qq8miJV3pplC%aGJDugwIXdyVf7f+#Q&`>~>anAoD@2!uz$p z=6$IT(eE@6KlUcc&ic~nN5vP!HmY0RMGdP7sBW?uutSzM4TN2=kzPwS`O=%)^@*z{ znKogUy7`x?8@Aclv5wgFsvGK2k#7ppR2vI7b1f3;Z7l4ldpLj?G5Z@_H7p{qypDg? z?5cOme#DyN`q%GdMRPH4zx-ih3~i7y9hLdV!g<&s%9d3AH#OY27kfCH&XL1nO2cZ) z1lWr@es_5qJjZ!{H?pnJ86H92tisc8DA4HRk-;x?$j6a3 z?W3SMju13 z=)PWDN5UVmJ|JrI`GbmJU|bZ-E!y#2Jb{{1k}p`2GXjW z_ACSWisoSK{E{frO^P=1 zz4;s_d$D8y(cSW^*k$?Lq)EVSx>JKK>XUX4ij$oLA5Jbuo&dj>xCBM8kgq-7Th1byIhXXcUWx zl9w?KlA-RAA6z}Y;wU*27y{b=U9zq2IA{`slz|7|B6QW(9=e*75PXV!3DPT>^p+iQ z^jfmOdu(a=1E~mi)E*1}q2jtxryC(3<$auv15bqmE4QOLvFRK&lHA688sf>S(xNQG zsuWcka^d7YsmXuGOeS}o8b(_Y2UByJ8g3(?-xrWnQO6$2DQs?*ho~59rRV3u(ppxh9i?sscesNx*0`eO4*k=B(F3*8kM=RAPk1;5HXoGcG)U?%BC@H)iuQr#dI z_!erYZWJ@ubOZVOkjc*9T6Z$|MD8x{q|kc45i?2lZ@qtCoAU)%fA`Q~2zNZV}ssp`FCOZXkvak>*TLAKe*cisFlVhrdLwaNHgQf_t>*J7K^T_=Xn zBFu+n&KGy+%BYa{Ybu6orG_$Qa&mp6D~3AgdN%tSaf{WaeG!+9kS#D?t>HiLyAeSP zc{OlUSe}2I%l9c4cz;QjBO;ZaLB!RZ4ImGcmDe;yx>1^Z_7D|gco=;5LAn*;SA$QO zdjlJIb?7al4s5lf>pPqWz`xJejB~`R1{?EAh0rGA&bf#^=X#MEW>8VXE0dgJ=6vnP z%7n82%VCY5=td~|s5fj+I|kThljEXaKOCOSjH`c=-|y?U&5pDajb$A36hj}&i^7?(q5es^)M;_AMQg>>TsRpj4bTCQB zXam3BHC`ri3b0B$8kK9#2;Jchx=UB8Oi&ebW7tFVHPa08R`3Z4^_Fv;Em@$7<+yO1 zCyRf7BXo(o!5B%ZxffY%ktrH`l)AcO&ZrQ(Ga*S{B zWL0f%sR8-5O_e6@FvU9Jo0~%gjY`dFafk1eZq%AHj-Kp;@{!^WEv$MQ!JLmNR^2Io zl7GWBukNU-mFWC#@{#lnE8$sEb)$4sbasDnhvDI>Z33|j0*fV+WNBh625OGw^r;^~ zyw`A?NXwq(6trypK4zioi1Pp`;m>hn0~@G=WVzFfXc6wM#7BKD57Ax5Jk{2^&*Z!K zHKDg6D={})@e56n>myHAMY}1P8tE-$V)!4uUu(wEo!(aJ4YoyBD4Oa$O_}d(2Ln@SJkTeOds2KhYKXufgH8O_C_z5dr+=|ZwDl|Bs8b`kYW zgQNTdQ7KetUtqRJ+L^hEKKpXvS>y#5mip2?{Y}qja)@B#F_n01amY<*eW!K*!4+<1SEqvpuJQ7)h!LhczVWX!Wo6P5-`%1*3Zk`<&?R%($>g#)OM%j^V+6~G_%m}woR+NhKNqQU;d5jr1IzHcb$T| z$0<^8=o#*Y{oBZQ$^`B2{O-afG7&L`5jB@_a_$mAnD3x0~obt8YPzL%oL*3Q(cU5iXmFMgs_!F zt%DW)QS`o$e_d#lIHIp1wl9BUQYH|Cb(c>;GC|gy5Ucf*IR%^K6soqnKVc8aLo$(M zS_YAhTzgJPH^uNUcY`RMLj4RIDVQY_v9?^?fh;*S*TFBHLR%%2IyqViP&By?v87u0H@rLbiDrkov+ihUCU?WTvxGNX(wK7rrvGV|Oy<{)OstQ==X=QQNA4>9Vq;N9g z!_$vNWa1pxx8yajsNM`d34fm?@7Si1v?8N0P&3Y%g3O1yLPW0Bl_~l_%U$??BIMQ( zFA4qrzd&~dY62izd%%B>n{P}vJ3u4nVXb&1uX>@_?%fGqjaOCdylrYVjWwtg@ycIN z%h`g+4T2oL8G-fT@4%DX0sioH@(#>}U+NNn6=of->fPx~33pI_YY_aXwAy3JSor)u z;3ZkIOz*-yWP3}LqH#Rw;)=l9`(Lo3zHjgogVGwcwxU)R*%E)vf%3BE#Cx+|tDX|C zaC4Xb5o256A8wXC3-UrHGHtn&jCxBwSJWHp}wBEvLZr-Kns-lOxJ9Af^auh2t#E?Tk&>gGd_^N=9z9F2~(Q zcN(sl$HIO0A?km?LHoa(|*ri>y>m z5|Y_Y*|Qdpu+;FdqC;P-Z=_;8Kd%^wl2rc`-9=7N-`LvMoLTzwisve_LE~=3y@F`s z_f>>e7#@z=t#|ESs+-+_SZnG|xTE{g17z5thKx+^+U0-0R26#*c{ML{jfPzS=i_yv z*HESC6EoM5H__?^`!`lO$wutuhFNtT{-7$2(u8J$Jv))=Mot2}E3(t&3_iK$jJk*V zJ@S%}OkDj$4SK9K949oIl1-OP?`m`~4$G-zNMrhX2t# zjBLh^VRA5h8FYFp#xlxxl5HqAOtJQF-L>qYNV|XO2EWc9l<>DtpHT(%-Mj?5ITTWKVW~eY!1iizWs^KfH6mHe9Kg<6J#@RU#N;h zmlPe!IQ%a2yD-OV$O+wCUq536>tZu}o)VgA)=5Z-H$pS9J_YQhY}G|iQC$aif#983 zerB7UOMy;MfLwS7v1dXvRVj2QyA>^`C^MjKcHK#FN8M4>P;3UWvr*&tKIF6ntA2kq z*FsIH{D2)C%2g1M^N-sIO(RlII1NA7J}Mts0RC9!{6>~BxeqqC>uH>Ia=Wertmg{N z`)Ivl913kcX)YP`-2Cpci$YnEID8nGGJnTx%CedChp)r5V*~_Y~ z=qKZ<6RhBcG5j-8X)MGpGAcO-gb?*P z--qiAw81NUAO8x~E#-<^`957KW(=`z5O*OTvdwmlmJbEHN~%UvUCc3izxGa2-DI~S zDo=E!iaWBp8IxLu*SK5bWw?K4xF%tAMzzQ)e9tigo_-+Ki-9fI3bq{hZ@PCK|3eK~ zbB1JMzD?}GXcl6+JCEp}qI$5Jf*KyCxCIQ>R7})8&unKil)uQCsEpGk#>}GBE?LZf zQNP#6*q)A=fz^QKuUA~vKC|kih70G&N5o90LhMswkIteS9WxE<6N`V0+&=3Mno!Jd zsi845sfTRwj3GQ)5igX+Br`@`zF^f)wy#wFTrb8v$C&BI>Q3s1gr}(nb1#`@h*un6 zA!@lYmKxLGkaw-PDnAG_5M+Oc%m*NSbIH7Aw`mn-YL?xG{W1nSWtQFYmS7)(;d#VJ zVHVbZACQ$dMr)(B&v<`lS^daYi*?M5O{~^9v5uMD5Ez$bD18X=@jVV-ziWK>GU=k@ zkSE$Q$TiY*iXF@S-SeoYpH>yByzvE3*l+pzBe$I=$(!KSEhTQ*uaSYZd|}=I{RYI8 z4rJ!E`&Yn<@PqE!PY!^!u@mIgd!V^LBc0?5HHCai-lXFg6Ip-F_0%4=e@tIswG&rYW=DtU%!Fg$X)j-^zmAcFP-a_ z4Hw_@I242(Y@TELll@v*nLan%Z$B3pA|Dz4hZ4qz0Z*_|D0sp<#Cb+J4c0-bekdKs zCR1m~lJbRccRPQ;y238rvt*NQJUrdoB>n!rqQxdd9Ptzc~P6;!riL! z@Me}cmD2-Uy5N)I)X;g4qv-;5YQ(pw5`TW|OqVy7BH> z&6nmm^kYFC`xs-=Hab(d(@REbsYVq+4t*-xwHz z)@j}!HE(&2nv#DH`YZ2|%-#8Br`a+nGTl4L?DNj@lq!>&hm|-L#GH~jUpJoqGh+Z- zHXt+-3qF5==@izq>4##k9OkS|r-T(^v)03X%Jk*5YeH-WX{DyvD{PtQ*+m z+QamIZwXiqMs}>&>~Y8oxGlBK+W`F$I4GfV0;<7JMj{T+79e0Isd|E?y1WR$1j4|@uB+JCUjsl(u_ zC+dG=VBIXxPu7cA*AKSZL9n3iuaalYOG$vXN~o+M5>j`T{aC`5uVIYFM&aK?*cv3)i82A&TA_t(q&#a9lz}Fx51yb%c8iM3#`v z*#}{+k6AqAZ|o_tC_LVnM^2Hius z1ix++No&eb^x=xN#cR{p!GY(w4!YC1sw_iTg$Pf2kyxlHbs5xNv4~C_nFiENTlia_QduBkXfI34tk*T50uQZ@hn>&Om<@ zbOj=M24GhQ5I>*5d5v2A?eY((&5R7OJjt8*8+^1{UF7aN$T6XGX+8su^;}cBKVq5z zBmF>)WzBVxh81Z{u_~5qiQyjn9PMA-E$|8F!4uS>$HdD(r`q7JRU}>N?$0MieAnZE zJ+ANvl`d(X3rHQzibmql)scTXZcJcYjU%)zFfDIacskQ3=H+EZYfV8qT!CGbM=5H0 z4cAcT!W`ZCCK~}CRDqZS_?PfUu#SxqZcl-PP@u69#JsU0;`VYBgXJUktND8RIy7&QpFVFE;14~+$-W@EJlC4gPfMUXN~3S zKWdJcUZTd-6bV+6=6I1TBYOBI1LD*WD@k9oWz|sCf0OiOf3hhNR~A-LCERm4wU=BW z{#EZ{hfQ54u5sdpxk7$|_sRQoCf5zWv4-mk%&tblD{7Of!4SFRZv^WtzL#)9zK4G& z$hYwO9mH(LcO-`FzY~8}mkRIX8!@k2gH>Gcsax9b5Ado91JQm3{nSR@DQCzj@RLqc z4K5op<%wXeL(nVBNdxETZ8cqMJWhxCGI`u}=mO43tUW$q%PO++r%mG($6h+}4~X zdsHba9zl+5WapDO_N44YO+eL(JtU+IVAx z3h5p&%7%R5%7idSO+mj9{Uh)_iUq4`J2jM3Sd!{JO9z7A(g8l!M8BIc(Oqbzm%_?Y zT5FbIEKF6*c7}i6YRp=5rpTxtl08E`s-_E(7Lcg|adNU3b1i}uxsW-9elmFOJ9BKR zSk*-wDTmH7NOMv9Xw`PVyQK!kA(rIXuThVviVpNqnxZpuLnI|)kfl{#*r(C+aOrM(_gNiggpTgHgc$vCeKGJ@zrWK=Luwyy*dx+G|+1%fg3uIek0@Gafn-Zr!QQd8Jcy4js zMU%~rvLhs&Zvn6MFVUGIUrASF2%pv4uv*)zOelE5kCo}c@OQ}nhL}NyYpRsyh=Sbv zmv|iI6#9Q8q@ZZ>N+WwpI~9BWecMQ{YOCrd>ELd_$Q(qD6U!@2f?^RzCKoKI2jfj#^e@*#he zoF|(DL;P-u1Ey7CZn;QzB4%tI%gaD6v{WwCCz^jYY2FXbtlExIPgOBSUJcib=TtYn zJ;)ks_{cIyRZMs46OkG4j$9@}hc zUG9^Z6EQSamg_~736_1Bzs#=v_MtS~T z8THC(kajy^J>FFQ74&t7jp1dAKHTd~=g@y2wFa>}t8|8*q4tKhaDT3i)hDifo=WzY zD1U)0Y>LOJWSj?fV%B-POFzWaOajXn+lXlsFT?0y*+mLF^1f4d>PPDtU7CBVO{t7! z7P`0cyIp5pgNRDrTCtE=){avq!3;8?nMIQ^LSX5{t{GLDeL1sCqgZ(;SmG4QUt53n z%T?>CAY%Yq`~ouxv3J89GuM2Zsj?&~I$*38A&$JN6?qv}Pqr^t6=TGlT}#C{57?Kp zLjp05-fVd|qj@{x^C%v#$R?YZD(t#b{sJVgpJ)QFlU0T9g9Nsi9oC@sncNd*o$(WE zbyly~Q}LWNC=677V!s9VvQyiuYF&S7ay?P+p}>;PNh?STtS9>|Nrr36gyMYDCThs? z#brNcozv7y{g+0Pt9>!|N%)2t3gQ@%)!(SSubPGz1{w?b-C~<#1a~8R**4qzigzbt z%>ELY474xWNI@DSy0%ta)ea-MP3NLlk?_FNNjf_R{LrK<|mS!`P76i@JR;7k91XKc3$ zus755)*?0+$dUQD_F+B^>QPd+h6b-ukf!f-rW9bu?q<>fUf_T1fA&R44q|R#=dV=5 zRZ#hR<0q<@Njg^X+6q=rr>2N6fb}%jrM-jlRB=D=PeGFQMc3Kv8BsG>*whwgG^Mi6NR_KUDP_*#l$wda6pM(u!29dru-R1inuoe zKy~x7?8T}SlycF?e)N5`2{DczjpBoh+lXvmRJSq#te53sPR}rN^^>K4EZoil4Zq6q zOPHg-X*Pmon8xzlV)s^==ntAF63HGhJZvM}9Ii#13}b#(73YX&J87%sHLSBY4_7Ae zvZgJBEBj10!goqn#{Sh^YwneY$UEv$D~h-ljH-q%1vaQVLvQAok;M(WTzv}ENP;!1 zzwlSeBv*RH6~*9DBJixy-irAXZSv{ss4Mo zmv7;np{im{esiKC6?>}-BqS?+@%nxID=5z;){)zAe5&b^`6aTGjuRd5E@))Lqf#a? zRb>~kTTzw9zrsoEFxa2!OaUA38`Q?=H42T!bnbIqs%|`a+bQUOC$rU@qVyrMgKTc> zC8xsUi3W3;!Sb+Ve+kmdg7?Muy<&Zi_yM}wXDjYj7YK}Q9t{t~$@(y;Q1se^(wu)%kVo8$d|x^O_fhrFroLDaF_UF1al zH)4uwLasgVQCXR-owR~IxS4DrE4VeTrygWvNw(7#1Y z2lE{8v-gpI{aDd2z7TddY;vZoIYVyaN`uvZAR4WAK5tO*Kf1rC4qB2-T@nL&i`3l? z*RIH}ScrT@e4jZ*m4?28#Id&%>s>%o4Tl{#+55}&`!GXqn?_c$YjtyBc)<@~TYPy~ zr^a?RO~G*uUGn6*Mu(^KYV{+^IF94yh8B6h_MO6i8X(8ezy@Ppm@~iYEu`a&oH;*p zel8{MF!$<8HLd(nx{F&BX;K?16|KfjdgFGcRI3!(B@q zcCL~Sm8yQKT_af=Y4aA^q!o)5o7@q;PpDvw`ow5YG{}-CPzsuRVcgf?6<}TbHGdiI zKVx2hGy`N{{H^4qw}eVY*{T0=%^B4@)G*CPYPcEp8LTGoKrnZL-iGR?W$J2Pb+M>W zKGd4zI?E}zv3#Gq7V~1@->2n1iTg)ZdN(rxzSUlu#@qyZDVs#IW9(Cyp@>FNqj@ru zM)hL$AaSaq!;@w8D+qW5f3=tEChF|wuffNE{i5DeR#x?2s=?)xms!OW@dauqV>AzE z`jplNhpm0p7Gq)a2~nx;f%)IVW`Hc&9NJRH#w;QS$cJF@f3^H+YD)NL;ePUWw=9%fa!#r6-4d2A=I z3oRm7sl!}R%zPXnu7%o64b`Rb>NRJ7benLTOpo#YoDHBc{^EDr+9MwXbrgDT`@rtM zfKObaUjDS}IQtg)qGn0c^>CWLST~o7S-;Pmk8%ewnK8SAxf-x&K)>j2u^He~{zW$` zv144dbG~k_jmSf&`%AyTl^D&-{CJ zvoPm{wZ;2{cYF%0j0?wci;a1InBxQ==Pjj`eJe((TY+;8()|SZ$2{ojADsgKBhI)b z3FQ~&>KYt4LdpfE8Nxv1{lY32Y8bl}j(h{F6DqQojuzIDdGclK+Jdw@GQE|KbFI@S zMsCBg$@Lyp8aLY%8}71A$9<-F+;z4fE%Q;>S-VX)s2EORn^rJMnV?I5V-}cNO%d-- zN4)6rdc!#wt3>^4LO6n=udB zBQxjM&vQ+Pw1+voKP`uUoulH8ron*?VL5%+^FRC>?4gK@w1wm3hR}L8i5nZ#@w*X8 z10x43u99~+Mfe|NQ`2>20wPyxVi5-TblV4C-*V!WdK;W-(RG?Py^rI?%T8zXp3*iOlbR4UVjSgBsB)LCP&B zCo(H-@$!+Xw2E?=m!pPjC45%@nlokpN8LfRG|dPtqNY$G#|Wvy;EE-QoFJLe%qukv zbt!VdgyZZV)}6e|yG%|{F>Ez5FWY8ExtC+6QNys(N~1%TL-hEgm?M~phn-=;+$mr-jGuStO#*L}>Ai5&P7%{TpOo1a>q-w&ac^&47LGFA-%aFwlu4ly&ESrwk zu}xzZIt3VQ8upF_#|7UdC%`t0R;pN(39x_i!jjEM4WOQAZnq@WEO828QFI`uoy7wq zvfC6ZwqZwcfhMcpc>wQt%^9pvfIF_HWi?BpBO$io{&JUp2#tc3Q)oRPqy9opxF%4^ zr4RY~OLx#+`eN4RJV|y&k!HYVn;l)bFpEz_BWr8Uh*N`4Anq7EBYfJNDAlMHtGXz4 z6wAfeAJtV+M(fB6D79mLt9t}yKhCUUw??s00^>|GqICsp&PWW7t*VVul|n0W%fm4; zAE!-gsUewvq*@&mc?WUCaXHAG=$(%_i$Ngfs2k&K21+5IKvxLEcu7+GEND@+L^!*T^RH{%Via z9x#GW}EVgc3rJZlc%|&6m4m`WVFOVGJ71 zl#KarU819Wdv5hE1feX9M^O~X|38$x-5&z-XsBJANLF@-&s1C{N0&SJ~?t5uCyO(N!2~* z7m!w7$LtYz6d6PNG$9(EERu&PYp!(RRsWi3Z!Th4l6jtfZVdL{l6`bs-O2FNu6b0@ z*3ONoJ+|z&BDNqYs~!P-JpZdflMnhI~sz4pSjX$71QT` z4fJ3Te8%UpZ@BE?xTT{*-_tbJO+Im5HkXFe=mDhFRZLC?ekHsM6@CNQN*_Q)Qbi)y_PK zEh%+QMY`|AtbE==;{@b_e6R4Q1Hpf zhbykS#!GyLc$MY;ZjF{Pf!9#uk04H=wxKTL_l&3n`?whM`Vt!EoakvOF}A{I;mVaS3)3zxy7n zOlw&wosk>sEitAyw>S3sUyIZ>!OSUwVjH~?^SQE8TYO*~dA+eTtKT)R>^GPM zvQbCMb@BSiY}z?w1nV~twyV7%lK@_K5V{C?0dzsf(O`~^D}t6WIHev53f zonuew#)F@~$Tl$p>Y_rPcEn(8Av|ILt5QY~=>lWdw@LKOiTK zpV->TDeo`Y!Jv`OMtMGQf9NNXu7U~V3;znrN3MV#x>|Rfd`bRZbA45Ywm3`~7WneQ zWr$6N6+ugX_ZpsGbJg=uzL(e00~CGUA$d>Koy<3TzaTqge_D3iF@jkL-g$+(r)dza zQceq9Wty8VcpSQ0xt{+3ij^eAYR?ct@&0zO+M@ITO;&{uXHk?lZksSEs0sk6_xHV zrDj)%O1;dnJ#&8k$l7f*o#$&BjC(Ps9WgG8cY6AL+k|C&ThlnKZg=VAhULGp9jZH~ zimm(1ZJ{}NmnIZgUy$SvO1RgcZ`ie1orX3IX!X^KpleOcm_T{Zc;3 zg1nG_FtS}>-x%y=1f*sDk+R=-`UC45R>Ro;FYMy0S}rgO*MFE}su~=`437lI0NJi)orh=jfHjmT0;=5zs>$gczQUlsI4x;UPe6=`korbw;0R+ znX{51^0g|h!9&NXdt6V{7dv{3jL29o`!&XY?43eRLL>55ZWG&FXTh)Rv&Gwr@?F8A zzz{#!cG)xZ9}A_3OuBly<{t$U49~OA@oUP4yB;ptj;N&kZm`bd$?D~D`4Es_TgcS{ zjaOHDm{>HiCA(e4>{xFJQ>A|vS(-pk1hZ$@ii-BqZa6nY?d7hQEI^rAlFtpYm*ty( zwa>^8dIoW0qIOK^s$mlQ6nPuQWCxbJM2b-rTe)N!n~(laRFOUP#l>CUlxEFjkPCf`S57 zuz&-+P#2a0jwmA*DYgCpWf|)rZxQ`}opS@PE#v$@|4%>ACb_xySI4z;rWb*$O7sAHb2@fh%|lY_`oq9r`u;13OU{bf8DDm>H>hF!j;8 z+7&C%mc52|J&iN$rkbWV>oL}U#k&~S3(madL{fU``1GaBUP9?>IvYAoCs9dV zs^vkBS39z#EHXQ`>WnZNE~+}KPZ0Wz{t33CvIhMh7j#m_r*5?In}$Jiw|v3@jq*h#8GX^-e-{wTvde++j1_$7C0}Dwuki}>NsD2diY)ZcU!d_2H(r0jiZ#a zbx#pLsWL%3%9c?!P)Xd$B}wPCoyr8)HiOGCxAdRk{rO)g`85M!C0ilyFfMAI2kn}v zrfkCwiWa?#Z369oXBFhq-a51!j6ybjU&zjyQAf4w6~x4Cno%;u^D6BGOI7dL>NsPG z?@VI3c2wzKg%&ZFPGYQ^YWCr)n?g(aHTs+0C2m2Xg*7n4l?m2Ol*^ts*xo_=6E>H+ z9V6>@P-46mVH5UCyuNCTkt8nh;3Y+#lqI2tgt}VtW+}gaZ*2?yUX1o$jlXM%&qR4f z9V0BD8V$F|JR)2$<{5Sn&bB;SkQrK2CGG4vmcO$>yw5je#p!(zX$Rr+WsOr3HwfAG zOii?T1jf}z(We{7TL0Rs`O1455_K80gC3~~q22UgJMHnAvTOFzjy*Td5km|!RR7N( zsB>}ZRWs{`%JxB6<8ajl>4RmTyEtvG?s_Thbh2P8*1<`UNo^B2l27jsh|rMotK zUUCI}Ue zM&~S54KuN}5jeiOq|@hj&qnrb_shuWtAj z4iewgy0Xw|Z8!APxs*dzt){#P)*5~nJuiEI&3Env%)Fe-A*Ch0e=aKRx1c1YQdK7U z^_KhbrXWq{F5ZP2QN3PepUS?ene4fs@9BGD%Nx-X-hMYr2&Lb0jyG~gBkO}I1c)<( ztQl%Y=~N8NIhy*(%2w!ES;ovpue%ejrpnN=_@R{PrhEbA5WS30UI-%Wfu=il1ZufDBxZv`^9R%v+IX$P!k9j%-ZH z6*%U+1{X0V{Tepu>)?~HLissL!fs-JKSP`9&B`R)5$JSGseRi2v5EDMH^%um$?w9k zk=S0Zp!IJ-{|8rp(TBmOpxo)fca>xYa}w5Yn$$WqB+|~+zvuW$xf$|)*rI;0^G#ldb=->ayrRCxl4%kOR@(ren z`wp$?o5D?Foc;-6rN?7vGYu^=%Q->{O_ZaK&Qr(aPKT4lfzqAKUeieBV2d$$Y1PxF z8B(Npp5jD`5_N7(9z}U|9T!oM+Ny^B+2aNu5yh;n^MH|t)M2p=%t zs76wBm^`zn8a`r1G69OM#9WFGDKbpSq0P300=>S8Gxv!Yzutt%YkOEVSALMJj0H=X4_wEa^z zD|=#Mx$dcYrFRgvpee!zj28S-Q8hnI6RnvXe4hA#Q+7FjKCD^)!iQl`%GeYI|KCn8 zdnChqj}2JPgk0PgmZx#tXS37z%F^zXSGnwzX}W)aEO1eEFv0^YjIpE<2XKmkSb*(Q z4Li_lcr4sy9Y^J>g%EL@$h8J&D4l!(F zM&$5G=OybE$(nv!%80&#HipI3?nkd76XLj!OBBR^!KHXe_!C}T30GA^`5%=NDqoc{ ztPjE|jPUm1)!XlKG?z=r)C_dPOZZxbx}`>{UQnW5Jd7)41*o&%$E!?IG?7L5==jPe zWp&%3EHA}43gZ3^Ba+yceumkGH8iLozGgpqqAH9V?sD5OXY2J=vYOV+PWfnX<2aRD z^u&&TY#deoCrz$)s`2%l|K`53`XIS*1lrm($j~q3J0P>f0tL!RP?Ok%8e(0_F1$-& z(L4P(AAhoMbZk>r%YpGN(pDiIdmy1sd zH^Fc305h(R-xE@HU{+w3sW4JqD%|81HdoVGLY&O4y1PejubFT^Zxd7+ZxNnPP}Mjk zIGTAraf2FgJrw0u(GTqo;7I01UPXR?bf3`wD+ai0ymK0-m}1yvP$tN@ap5DJnvh8G z{<%PvPPyPu>LIQRv`EV^{uzyp{S$3H?UGwYois}>EZbw_g_$p)K5@KNuK8~~3!lR!~XCyi!dOmZD2S6d^x0EGg zymU&rK6uGIl^Kpbc%K-zbE`^?{#)VO28`R#)3P%oQ4jweK7s9)bHQk9XUz_H%h1g$ z5`SU)r}&`yA*+t+q^T|-{H&&bQ8StH0=Z`AIl@I3b5(@nb%PLi7@6(2jctL0s(^P6 zD`SSs6`E*>Qy5TUY+^5=@)z88%w=L#V+=b22i#&^Rq%1ugV}!L9pewgj>^cw&&oTP zAqBY(4aA!YHPiUN+9p-Jrn^8HE$AuTAS56Mluk1hdgDV%^6==~#-Uk%SM0x)J)e1i zwbgdwI~oU6-w}w_(+3Cnn!@KipFyhVHte9tF@KJ$$2=`}ni{x8#!>!bQa!|tP&=(B z>n2m7(4wDRS4-GrC}}?OxCkYMB0A;N&~c|XYldp5Z4!KiTJQ|?tXqs8B~iNdyz?l3+if`Lxz4?BVhwp|pHjXKY;HPRDMk3)TzNF?qzF0n6o+@93Y^L+ zL#uF8|4Zt(IB@Ot+)8G!q5)u#kwk7S3}fO_yb~j=3(u5HI$yND`ppQ;|P^W6J7Zs zWm;s-5N>iem^x;Ja!B2#6j~@FWwBbhxIn2c9eCt zO`v>7%CFMTCN3Nr``~xpPm`mlr;fR5$T5{A<7mt0@JPiL(y)=k2H&8D--E7WHB%*rC`ezVNMI_7Hkx-K?| zxm7QGXv(&JU>_vr2BVGNxEEN`!qbYA!l+A>r~y%fRMffX4(f*-EbJ6y>d$@gHkW#| zF^1~F$yW~7!K-OcY9{CHu+B0xny0B>3O)v{xRU1ay@3OKuUjlSq+f`$I$Fwp@#@BZ zhxfCK_iUVy6!VA5him!>e zR%{DX=b*ZpQK;d}D+VY=8s7`GGj-vABf6G4m%81G@*6lPS6DBu9wI(axPTeqs|qYh zp2_%>7jXq_G|Q6iXh-Q~f()f)zqTXy!rJSN+cLa3@=pud>~5>BX0Nc(+QKz6&uf;l z75wW|p~l4GjEtfRImg`e3T6a7(W)~Uh=Gav8TL|(Rt>C`nPoNsXa4BQ4Dl6z{X)wD z%~IlB^G_rFA@76|?uPzZZe02tl(_H2a`kfNc?Yb_s4FfOrM&r@gfp#)<`qnxp_M;i zs!uNwo~H^oMut969dR_FU9B@65f)_Xh+~SLYu%4NM|1uf)h;;VFo#!}QbWfvVjjRf z=YZgM>Nw@#yay-St|WZDj4v~?3~C(II?(brj7)NohB1!mb? z_p-r$%2c6uv+mEr#A~DsJYK~!ssYar{LR-khhT6sF z%`#m}X(l@MbBJr1b~0@OzW)mN9bo-n-C~^Cfi)ATI**ZMI8a9CrVR*x9d|t_ahCxc zB`w*w%@IQ@L&z>)Mp+l?xWFu24ebtK_L4l*)oKZ=b!YGr)h1{=N^=}$|BI$n^bU8T zw8$v-hbvN6KU#lYA?DU?ruU29u}>6kvI;|YVUQlY<0wXEa53Y535U$O2|th0jxs%(|AB3itH(N16)0bZ+7{bL_fUhlfmc|J z7z3mWGPf8yo&F2T#77-AvV57d(3Gmm4II>V$TCR)O8~EM1Ri+uaRorui zZa6~g#9^-Q@%#@AVtX^Zju;0hCk462w&a*`=t@8`~1cdD5uSzpfvMymSN4ZZ6H}Uy54WFPddlg4hX6QCy zznB50DGd)`KU1TBAnGa9o;V))l4h9PTWxx zFPovdD2X-ok zL8XqX??JnMkam`YY*VWCJdVQ*?I^N^Wc{_H&{kJ6by+j&s@Mw4N6Ja`Y||7|s`pbk zs_iIyhB>5v3aFQhWnA;>Sk*9+bgr3Kke|d1XGk;cM+)32Fj?)mV( zb+*Y+c0KKsuu+FzCCYMC@>jv{g5Rm)$Qx8YWGbXH9~`F-N{y5O|H2X0LK26ot}esN z{6jO%ni4uL*286MOU*8@TQ6GAK)kgPYLsVCdUsNPrJj(j9~1aY|4Y-O{D;s(Eyq@8 zF$1h;xG&%^GaO%?hxg(873*Oi^A}U9`*fAj(3(D{stk3jOe}+ybi!qs$lZWA{cKlE zU9Ic480*9kuBF1j3)CX;7*cwpn6YYTY%~t}Ps}U${KXiTU@PPb*KeKY(5HEjU4-xLm7`}-_*_V-S;~Ep zKF8XE(Q<0eTw71x4)6y(fj3Kk8}u-Tj1O9W735dQ6&T;Iwm$|kd2U{c8`nJFyRJd^ ziL|StCe&VLug;xegSW(bL!&&J_J!#k;R11&t-Y?CD%NWz)9yjAowOZ!+2F6NV(MVA zW-6UysN3s@qwlv4d$1A;sg9U3z9~nSa`h=s-@6!En6qdtuGi~@Z1c2~m+Pw37trT_ zjSl4v9kAA4ahcF5lArSN@`TU{W<-Q5QAFF7 zxPdzcW{4{uls%DZ`q-supW5=6k%CM!R;MS9ZQ%G0=QY-#8QY+;&LpPdhR?$<>SpPl z@{E9UaNaa6bQ0qHUxHoYHcMrOhpU-?5$p-<$7_Z)hOE+mD$$dJJ+QClG=Ad^*e>mv zoEAj*8ZO(DbOCjhatO2CRAgxvE|_BS>%p$w>%1miZTF9d17LzZA@pu>tP`LLzR3AR z;zh%@=>pDcupDG{wQ1|AhwM^nALzXCRGp)%kZT|g;;F6PCJ&vfPQ&=Q$28r4EQ4C+ zd2bUWIAXY_tYJ=XS|TKK%TZrE>Ekt2QLe^+0dbmY=yYh^Dg09Lf=IrJixs~vlH;PwSQzC6tjiDAQXP3@V4u&Jd`|BCO zD~jy(luxiY?5(~ST9;psmT+%>!7HRed0*36)uH;~I(>al!{_yRd4o$f7)PalBj-HF zOhebUC=;09h8!rPSKz9UoiZ({i#<_xUHJ@?oiF2-1I9U?W0n&__PXta?7%J0IIBFv zEieAoI+OpWzL?mXJnuzJ0HMBMEXZz)z@J zGQHtkYILObTQyYKQL{f%0V<)W6X$t$rVGEug$wyxn3`0mlajpcBM?K>`IM+H#{EV;i^|U zV)*2ojN$>gKZM^E#-L})!fyCp$kvUARGzR5vx)1FYFN>GRsyS;7L4XUM=f$d*h(lh z?gczvA3?9Vhhc+SwN}bYvcpwgkz5P!Yo=lZUyri&03;LFs#wo|jTL(_;}BC&G~IsrgdMK5b6qrY$NU1C%|fHB>kXfUCi*p0b*VG zG4Er18WT$>nCumQaj=9nmw+1n1$c|9!E8o*NBXt3*M*w`?K%75Fn-?6CXk#H{(!{a zy44p?nF{59sy>01Xb-gy77Nd7CZh&4ruCH{nej(ME9gAO`ePRncN10rP(6EI3gJya z&f4px@0evwY;9-3-*_YU4Wvms$!64Z7AT|ph_QGds$=$lxo^M{)OP;=aB`=nQ+cYM zWWQv_*38DJ`v>J#oQszU!OB_Ae#!Tu^$5Vy$|C(+K=KqV)oN@`eKh|dw}@)EoQF{k z7N^LlE}*i=cgK|Ny1H($w!6w0{1?0lm8jcw{BCEG;+ckXCe|%#N6~4Tgm`g*<_4wx z6!RB(G}K~$j2K5baKyaK8=2u^t~i~1*zggm_CY_ep6ct=aeS{$sMj#DZqZ#M?}(g3 zXr_nSi>itJjv1>kpbeAW6}D-j`;I2<|Ce0p`%Y3ktmwNl&V5Yv-6aZK->K4RLAjJ6 z-1i>Ygfn5vX0`=gnyGLbqw?K^2Tn7^-Jt9-%CjebzupzYHxt5d`WC*oW`g`$#cNEI zS*O6*EWFzDKe|?<$As(3HiEB_cj_joM)K$K%4|LE1CE&Bzc8{ujR5Jc9{ZD2i5J$+5;loc8(WncW1gBanND^oPN3>Ij6h_xOGhh3 z+o8yR@>$ysgD{LSu$1( zU}cG1;DzE;qsMUB)}wB>OysrU)j<`vNPd)}GfSFtHK(qu@;q!B#zZCENpYkL%rN^P z+5rx{sk>0;GLPU^u*>R`inc1(o9Zk6xS^YWiN&>Q59Y+%$}u9;l+nS+(0 z`Dsj4V`FjBy5dAm-Oh1A72&=c)=;%*_=x{Q^Hjb`7))*RzbJpweUM!y?vZySmJ2t3 zJfCsx@=m^2HBvQ(sgokWL)?uG-TZN?{wZw>yotSdUOU9LIC~<>@zyo}Q+=Nydx>TgPTTk8PkPjQl1@)>1%2p%bubUb-xZlwb}uljh5fB8sls4K>Q=z&whg2ruYU7njl3!N6=tRA$^^v3h`&U5`% zc`dE*V7q2IYjvK}&n9e6J*UNJ#mZP`20ij?J~d&UVg%5IGB#ScnKgszt*o=t1;WLK z-IZU`ZUXvrqqrM5M-`5kNHvvhMCgR`nyn|u1!fWR=1*%QeU8B;_L^9X@2I+e=z_Mx ztw29;~ceC9BvK$pa%e!Tyhl(S(^7IIkEc>9}^ETI@~T#ac6t zc^}bCW&+;rOjJ;2n^)Q5Ug{rj(4Y-l!wh44F`gS~9fMY@vN4P+H4(I63bq@bCG<<( z1wxip1NEJ-ck7CE87Ql2@88^i_?hY(u9;R7Rkz`%Q{a^MQ{kqBU=v5x$~KqND`E4r z1iy34WfO9%f}Krg#XUh!Fgkxmat7i1xJ6bb=Bgi}`wQ8sK;X@$v&u=0Z8ldhMY!pG zgd|7YQ~7E^?z+YOB^zVYxiljfo2E(?udMO06i0Dt!Qb?MR|R+@YrVIB$H5;L_cY9B zqS)1_)tc_@cW}?q=>u~N5@@dv<3PVEfVO%&&OjESf*K!$POiCOJnWxoac(~*e0camXdE^o5a_!%Y3OAjogT2v>A42MpI-?dnttdPY6>Mqw1Sr zG_{E^SJ`YR(ku;f>7Sb(ZEUmd*Ziijt@*ci6S^wG?6i)5vlj(pxMa_W?89=6*Jzy?I4tH>zsCPqbK3A^WtaG}x{6&EP9vTq zXE}UiJ(K=nz21GB8S6iQEB;W@xtiH14`WSJQe$#PpGSWJo?9{OFyX$C-sOgTQ3GLsjDK@TeY3c@SNRpq4AV(6Xz%)eIi^S z3_!jY-XOn0J1VmrPHDyhqZlUTf8r1R)xivp$JJneSitTfZhLIyN;txe^*(Hj(;d!gMXiw$l<~cWleFvR04BiPtgF@h-5ZtS z0KX$f8&9~m!iDOi@=jqJRi3yWlutnKW}pLBUFSEOaUEMP!cMV_kxBR`o8{|`qcAdS zhxZ`e0S#iXUD#Okk+$1;&OXSOS~k#mt~Aqm&UsFMoSmW+Uq;J!u3t2=rk05%t0%OCFfODVSI6AuwT{QN9oh3uQ|uGVmdO>S8JcO% zd{>WVGMk-$F!j;UX&f0f_XT>M=v%rMXghSDkbiUEseT&xrP?J6lvlngadY*-fG@bM zT#vec^&;0@-{UM-jr0+U=>L9B2&R^|`r&47XSVle15-|r&~MC*Z%X&?n?2B%OH8Uw z{I@Erdze95^i8D}5?7CPrmKgEHGbp#7Uwe_IMNYfu02VLxp)b2OYObD|G0h&=o+pA zr|*H4nGy@oefUI62)UNKb+dKCv5alVfbHI$`254ZO@x3`qLA?U(f7ypzd~%FWzXmqtY5)7LhYX4=kR%h zU)T$^$|1@j$uocI_u3ZCQzAeD*HyE>B#YZe87I1Wu!}cS3`ytFH{kGj%S{`Calm2R z_@u-%RG4yFyzPtc%OrPqUgPg_5tU1S*q{AJx9_WXun^B|^-=QgDfg8!D{|gY1HR&M zEON`2VXSdKZ=uLOm5J3-4)_K8ROOJ+*`)L8_MF|}YA@6fuGkFW zrfw2tSfls#g>H0dx1m+}fnFA=s+KU)qiIzM+4a|$F8frpa01zTpPKA4Veo-}-7Olr z^|Q(AAM|28n;7qI4${mA}!L znO5dKopCnj&*9VI8yO=hk14!TiZ$^ccSFuWCd$lD{p>HlH5jS)-pjdN+fr}~eYk7f zKIJS(iR?w_H{i(E;@W%>;)x4?D)_izf#n>S*k0$gzN^=h=Q~;cCx~x+*Rn4%W4aUi z4LH~3#3g3@QR0!3kf!>#0LSV*T|gI*YCnk^Uj0*B%a7sOiU$_Gf^C&eXmt{dabdrY zBb?)85qR$ij6(bH$_tcpzlIsbe(Ai%3@^B4^VRGpep2RaU8P0u&`|V$73!c2VO*z* z!r%W423ajeI!eO4)OHly3SRPlT5wAj$X}LW(-%`E4wP%VnZ2OSI4fl5%UnJGaa_yp z+XpgfJ1UDLOiPpj$J053(XYSh7S*xdht=)tW~v_|J|9BGbSvPL@w1|>RYozMs`cSC z?;{URLg=t+J4m|LudqLVN&GH^D-yLVio>{6A@4+K?e@ixeM+&BuY%T@w7E=~P_xUP zqz3DL3CU+_(^=1Fh8=X;O_{wxu4XS)PgpmJb;35=qzF!pT<}%ldnwFt#W3q8&vmXj z{Tlj}7Zk%h*Odv{FE@M}&Z6pwq;%cr$|Cp#_SnYRCK0NK8siOrh$9|CpPDj|tTQ#< zirdWD?44lej}z`TwOh!x`ulr{IE{IC84e5Jk< zT5#(`|5xz=@nzux zRm+rpmY;(9y^#CDK2^BTSH~6(@TJj82W`p-nzI za87qP=f4x5Vq$}jq3=bgur^q%8d|en!pYr9h~mP{z$}bl`@E8>Hxih6wX()R+;iZ! zj>~w~bse97zgpQLS@Wj3(T$yY}xYO2rmJ6O?qB#HNEkrQpX|z)|-) zEa!-OeQgWBn`&+it+X=b(!0uNVJ8<<;pO^BThq-)nwUo}v8V=+{KlDzI14{rZl!mG3asyv7%PuYCHo@ zs^+2EA^KMJm;Qx|5Q}?+5<(d-$G~+FRDA zJv!!S$rZu{PM>YOgWsp#aM)@>xnQm1P%1mfAJEMrrbXr~+7$~d30x6Ynu>zU^S*?g zUdY*RV;pZ(uFPLnvCT0hQ;;wMUt~ra=H%@t`Y^l!t$dC1R_V_ENC17tBZ72T zMm{V3UGtG;FM4i$ecO|fyj-+MK1q7j+)a25ENJ!BR1Kv@PsJ=lNg;H)df@_{Jf~lS z#aVmle^gIsQLe{6Wx9TwGFd{i8}0N4JKZ8`)6wDEbeiu|%a3Xr8{3-al?@E4)?O#J zt>7h;RT-Te3OBuu;FvlFm4gl5LXH9 z7o^YOjp3)^4RstO2BWzfL6vZUS48GlH%Y>?e>B$2rGc_>F>CN4hGC5V|Ecbqjt4U2~bhI-d zPIs2`y_K)>y{V6SAGVI8lRfSR#f1@;Sg;d!0LF@&yvB^*F!P8(+Mh@`^`-x0#%4ZT ze>_OY_D6ZYEx7_!a>BW_mt0Dd`-i$u!}n~(3;V3&G?Q^%oi~g4@G1^fkq_ipDEV0=Ce`1o&3Y7t>+Wwk#X*=Z6-o;Xl5srWLMJ87HOb#DG&|v1V6>!ddI(R94f1)FX zH&T5s#(FL_G;VW?)-hnuu;pZ!*vtXMXrg@4dCN7xzbp8-u#ip1cpK85lurm>G|Nme zR1+Ljv4mf4G^7y%J(P1F^TrGtYjq7^Vy!bBf+>di3lmFEbHo?iPP*f^QQbD7{yC1L#yy9<49-#y6c!d(sgjf9I@cG#_y)*H!OHZY)}hd5*bt*t&+#g%;Mzsn9Fg z<#;^!xVD?}p(Wq9-kA@$diArN*SwFc5BaL@({*L{t$S(JyG7Dc)~@=VhS;oXs^@8* zr~8#xA!&g=IK17Ji;)SPy3zPesV#y`e;zGajg_d2a-iHe%96osW=0Teb7mIv4X6wY?(>RMsilth zG76x`$Ae5lul5&I(#}TUuc|q)j_^nwIzcs(ek;cWV}j9veOaxVvGOs_Ta=~291{0<-$tD?-Mfn!QCVYna_vj% z?+X4F%y5`7A{a?`APl##9yLu7-qW6iD}ky`@jE5>`hDV9BlfwlKBbD}8Atb7>3Vv0 zJwAP`JUV@TU9BR|e=~~Mp7p;}jX_Cxjq5_`#QD;&4JLnVxf;EuO^LhZ9o~4Ris`b= zquo08Oa3wwrJ0SoyUcLIoS>s&FyC9YjPF(DQcfy&;@g+sR}94H^{m#Qm@r^xJ8Yea$)4rx{bnC zC_^1^UlmMan{qJi3#Y~yx@pG=eeucMIIwG`%cBYT9@olG9!mhqFe3E*qyxZT{Th^^ zg|OVWR{KYD{XXdz14iyx-tV4~H6-mvK`q^%e5Je3e=z*pS}T|I!u`7xeO`GVA=Z1m zBK;nRHI${DGyX_5K9QxXNrkb`8dwKuvhw*;i2s1qRG+0oQ3JYsc=2lkc z{C^;k_ml4Cc_uP8VMZe_nFi!fE7%s77Ykbf4Jfp#;@RHR9SxE!+K) zWQ^mwh;fARp--wxN{4p+?4M+Y>!KOty3pdb)0|pUU{5ewEc2ZKf7vof$X$HzcWza| zZS+!&ckQ^0Er58`q!#c+SkdpR9hcTpQo32kx@cAuzmrE7-1cwgH%BnxtY_-=f82Fp zp;uAxH(wi$$Gve_A2iROGs-`&H3LcePDf8s4q%&R?xes=$j>Ov^OW zAXU*oJMYH0+^PtAkF%V+?u*w%hI%j$c|l;U>l8Er?ymW<DCvADt|7 zZ;si9^0wzb{x7w5l$fhRe>+|KwDFhj)|lCbL&byi3E=bx8mI6^-7K`lvzXb0iB2_!d0z&jc_VoRfrQXFLz`Nk8yM@1dAk`Od*pd1u z1n554Cx0Vx-UXQ9zLPd1aAKWiEE8LPOs8KpldWJI6?r+kf2)sz5>BuN*y*cET*937 zZ_CPrmzV*8^UN@Lr-==m$5swU-LzHPfpYk8Q8igq!hEg1Lw*h6$rj&fY;zwp%yGvt&|Z4Y^YsfAdC?rPhe_wVfGs0J@mx;Z>hb_NwpJrm2i4mT2!n`K56rqJscoI3vRSC=z>&-Id z2T(|PNH6Rws!nkb611{8bu<%|X@@OdhsKb>sRFDlZwEKdKIpGCmUH?Zag}iq^A}+r z$JzEYZwpJEy0@HM_Ojy89V z@j)oco-gj9oT2cQ7wYZ9)FTRVlQWD?H})^MN;`ztY9@Pk=3M5Eh1-~J&u6Zlf?Jly z)5j?cr9*|$j>i+1cuyt|B=#oNn9@vVeq|Ay!By;UlrZ+epF9!PXuCm{>QpW86I-yG zb~;c#e{t?9rw)G-z>cCzxsm=C_OeT%M9MM#qWU77QpY&v`p&p*n(1ZNCFI^N-<_Nc zKCN*ZH&?g`N^zhj+SOxtLmeCVtKkh^QSnEUJi{iBW;Ve0+Kyl+)yff51Fp$__L3P+ zxv$D0$^`#*wE3^8##EGZ%MGo}2;K-=8r#&MfBql$ZEkGi6vIi!;}XO8EBUevlstW% z=NL1`)uTIMmg%ysGtpA_(g{MQjaaN2+fr;8J7|lO?8jiWFrQFwD4QaqKzxP#__AfF zJ8uZtuAZF1VSSKxGA~1RIWbPPtG_ess4FgC#y6Ml#MjFy&SQp~hH}l;6r0hOhZa2b ze_o7$e-}o6lgxq?ATbNca|wBr5KMpi(M+fJimHpMiBXHYQTw{) zE8#{47rex&pw)X)+a2uG4UnS`y7Gi+hFQnIPUm>E=cMgO9UaztAEtZ&$h^<9U)eND zIS$9{6!B%|XtG-A#E^;A{1=>e%!0R_e;!7v<+fg|@1eb7Vsy>PU}E!+DA)71m=R#- zPGHQN|f#Ht>3%q0{i@MqXiw$zTNh<(XENMZ0ktbDIDGZ-CVe+OV5 z;a13xqLe;Jxv1)xa0OezRGH_{_~g$3^d=~8o-~GWlwnQ%aPPNkU98PIv$0L%wT^z_ zWqX)3gVAGru=aHi-Z@xcjHNu4(rE#6=tSnqrn8<$^uIJbYcE#!7Hw4xL%lX4;~(-4 zdtu;U=meO#W_l8T-0@Td_c_?G^#~nK?r{HT{}z2{TMJ3^kt;bu|l1BlzIzcJyYxz?e%03A}>xXg#m` z(nBYRV}aHv<)5465q(d2=)`b@zfX}I(~iCL|8>|*)`9rxz5UqSg`4>Yf7fk?gJlJ@ zBf*Rpt_Nn>Gx7RV;u4~jz}*mJly_G8Pl*r9V4NhbS~0*IMTj%Zc=*^q)Tb``UfU%f zQ<~HK80DBG4Y7i;kzGQ>@bpFQXc^GAHrCdUce==m)f-Am-;lIGw zZqY5O+et!9XsHP69DUz4;UmFL%~wCo0DAP;o?sOCYd#8fHJl@_O8KH$r))**&?-OB zcdi=F89pJF57W@lam7hUFIz^HRs3$fOx{6K?TGR5c@OYEuoV@Th0&U679)3z&;%$C zh(8V`#GjD*sQ-o3e@9I-4Bhe$&42k&3LR}YO11L&iaflhPUmL2GHhV4%0a(d4Hr>Q zq@q@e@{d=IG<4G`Ji7==^T*h~%{a>|ircB)n0A$lcQLV{lc-zFP${(7jHq?gmUy_L z`GCew&M|wFx==!Qplwc&(2a7jPyc>u5jj_U3nN!G`a+9Mf45Puzl;_qK{>S_1Frwy zb|TCE|9{RJ=nBhT$-nA<-QC?wog2z^70ENT9r8}c{SI)9DI$q zif@BcI-^)-e|)e$349z^Wh}W8{1=?!=Aw>i;TG{)I2Bmp0P;yFb2w`TGn{|D>=~Pp za*l)F)$9$-qRf1`0^)2gIDmGol5#yMw^Yn6{mS5S7Ag#&l=#Wj)(Qe|rFE7(P@9>?6$IfVDmT8**(lgymP zHmd5f7uqJ-GE7qf7aQ9GZzK)l=0ZoXdMaGg;oL8VRdmbJQ}}qI{EZ@De$j0JoXVbya9*9u7u3o)XKLC`d>w z4-zN%5^YEFOxq-?phb%zOaFx{hF91ondgXk4)7$PM_EBRpo(GkLFLOBsvGiCl_|E7 zb9xLr(1X6BPgG87Q0W&oY{A&&bS zS=6wz4Lib4LFS4Hoeu90ys6|ZM(fPtU)wT*s?wIw3Gc%Om)NBWq`$&0BVWL}FKJkc zBlvXsFVfL23qLqL)SBw5&Dpdm4gdzQ~gB*&yiiEd@;ym*u3#c zU8u9(f_?7Ou$T~TDdRHmUc={>j{+|WTl1H3*D0@<*$ZoEhsKb_E()FGn$bGhfBi%C zvm3W*J5t)Pe`@e6&!GQflrroHISpfQ9MM!LHRtPD z)ho9LM=QJ%?$S~TRq5xeSIqdje-wWfgTX(v{7-3iCRVIlZ3$kYI55rb->%=8w#iW_dy&VJ5`0M+r8WCMR9sqZ+OSL58pj+$V>Y_n#oQ=dy@D-QzldOe>TM=xm8Jb z)Nw&BE7>tu*COVcrU0bnx+Yi&2kV z5}vo}=nN;+&J@!fwH?+J>uA!Tu!R}VjiXaMb)2w`m`l)F>$n@tcCj9HVzV-V;&0-s zp)+AiM({gfp}IZzSku|ue+z_$9gKEf3w*!H^l*O@js$RG9_~WO55t>fo_Fna@C{U4ccYVeyM+gC4SeX z4B8MllVTHg;_uHPM~$i`~~%y zgSAPgsBGUXioZ-m>)71bsN9-m(U&Kyv*){QS*=Fm1wV#5f8=FcJC)E<@He=Oo~=fF z8M%8X-3Ph;krAFt7Nl~tzQVX>JQ-+*ofaeMySX*Pa4f=ir3-$lD}HC_RuY5t$iRzU1rw|81;6-*l*y(ky3yQq@|(=v0|_ z9BQ$*{WAma@tyA$62tGJ*SH-$^v&=A&gNo6cVuT3f8y_+6B+yVU)o9i0X6CllukQ0 zmN!ONRPvVv?=X9F*I4p$-tfhz3Ess%!U`{UdLq7SP^ELH32B>xzX!W<5{_(o$rWHF z2E=%-i}{8-7W@u$#yC@qF)pytJT-rrFq+>T!HqXhB}}rMrG_=Mw$L^xq`m4!<$8Iv zT<}L>f4`O(>hIfkHA0#GKjuRcAA=*t_CMi+_xYG_!EMytB-dx|`$XFiYq&2 zZNUpK!&Q2%y@r1NHCKVch`i>)-LS9q=Z$;fln{eiU$A*xr6uenpJ&{l8t`L;LG}efyQKgI`}P zdG9B%O^0C}-o5`5d+vKp=U}g)J*8*&P=6)tfZG-Is8{}upBxcqOUS)%z}s|cw(4P= zf0^@m)oZA4cVMq?qtu?pPj}(m9mJKs4WD=bd+;%w$9ryveQ+GTy-wJTdf)^;;|#n@ zh-r$v(vMIo4#9129A4Fqy5oEF65hp@oW^S|;5Zz>`+WeP;CHWJ?|UR2^cJ>)?!5`0 zy&K!}H9nE{TUzlsgw%c;wuQQ|)qC(xf7Iqyyx&Lo6zrvhlyekbf(wR|_^jLbl+9Gd zg8s#AjG|gW$Be}HPrymy_l9@yXGm zZT2}_#9n-h^7|EZI%c7b{1`u@zHP$qzKPcoR(!j24gQVK#8w>z6}I{$-t9B|e-6$1 z0qpH5*z7-m&u_(h-^TB5k)HMv>eBDAO}nJAIEUkM0k3MsQQe65eF@u*J`!I0y)fE+ znpJq3o9E#S7bPE}y`X!0)e;gd{iLIpQ^l+<__*>*2dHDxuUUQh2Zak|$I<@MDX^cg z#!T6~!V`yjVGFLZgrs;-yL#}hf0b}~%{=i>HY0H@<2^GQuEYOjD@rWvwh*JrMO${I zs2Y6%BklQ!17W3RS$1M}qx>kZWf!TwVGdz5bU#|<66F}wR_pSYRn}n3{P4Yw3ooP! zdWyfXMWt1)x?*7gl$GWXev{@a?+D7r(?0CRX{-Te>>ko@KfzW zR(1YHAY{p}O}9&PLMM~X%MaKe#rJyPvg5t*Y5xnPrO2a2`70L;!k){{xsv2TTuH570 z@ulkm%4gVgb{*Hw_NKI9>2H*JSH7g{a(e{3V_!v3FhODt|_f~?=WrP7MJUt|6syvtSi%B+*t*cDuT@8Gxl zU-gEB2zxiDRzBZ058FuithezSgv6RD4y>z9jmh8Wwn5ser%{uA1h;<_q1Dh`^=QUO z$b`3(?%a3J^Z4x(u&JPu7;POfAlG<7*YLUL_sm(b9zV0Ae>b%=uOu1>qj0|p|Gf> zvOwu1Gm|z6e>1r>?IdY)=`{&yNz*1zcdYq9BE$MHH)r ziYp)&sSmOR+}}A9)E3w0zu$`&kWA+Cna|~%_c@<)-sk=FFX0Y7aK;DFBY5xq@O_II zS@9m}k{`041gV5k&!{0#g1-iz&XNt#^RJ8Y`XD^>e-vE5S=1cg!IfRmI>eBjVznsL zL%ne4Pob4xiKF!;JmUvZBEo3E`TIoub5N`h(nbEpr@=4n@{Ll?a4SQNER$dlyqyKJ3w;S-DE*lvG62& zTsIXnf4dsQ+FY5RYgm#@3+$&DbyM-NSi7AHEvFrIdyv72q?;Gmv*T!__Q$IG@C96!U4!t_emIFVjsAv(}4V0xvUyZgyTL^J*NGe+i|Ml)6t~ z^|pojkiFhCA@g171MDo4>1rW|BvaK_NiL&ee}vF!U0V8=>gz74bwX)c=Ci^~T?#3c z{*jaq$%_ld59Xmlx=Z)MS$Y4}|BY-wKbl#6I%^KM&-svd8*U;^k;DSM{mY0UK!@=E3k zO8{HXb0vX|-qSRUyvK|n=X}o%@eObwMHs@A4L53t9>y+UUPEYl4)PiS5}(6N_04b^ zk$?IYlKlnIB3JKV{OS69NPIf#M&`Ele_RS@=EyKxAMmlp`Rl!4ypw-rR?uG)SyuwL zU0qJf2R}j8W6|sO{9a5v`czb724_!+l2bn9h@ig_zUAW z;4ZmuJkD|NM%{PS{_tAOJX+F7H&Z7BTZydhyg0jA$4gW~cz)mN+kB!CGj@-=YcbnI zR%n)ozBQlH=Gr$gciYq1KE-8Ue?-%rlpi#6mSN>*_Sij~XXd zj4}7?wuF|miMsDpXFT6f-MEH>(aNZNtK$jMmHwsvA(vEgKS|=Mo9-tPz#=S3V|q$b zS{?xTT56c6-2o$KBq>|B-8T^_Eo!?<8lL0@WFDOcsc(VF8_t%3SWtqruKMG?1kl9VyqbnafG)(qyn! z_K*y~2lARcg1Q|sY8`c=f4a{+1zLimm) zi`E{DDH1k|{L6iq`-l0WwnSb+9r518n$RsLn0Nz?OfkVu-PF8Ek{(r$;}4hvh`dj# zp0YdY&Ku?iSyz|re}1z@kzIYvMl>}ckhg0p9*IeRzg=e{H zrn=EasHsdhZEij)dX8x^!>pWSe;_Lo)>V?E+V?hEh_56C zYt2aisa~gJskO!B<@vZ@NvccsmD~@ryvH@)RESx-zj8#BrCS_)R7nc^G8KuLxpWn6 zVNMI1$+_TUj0n)Ne7-zpX+AYIZT3=*e5oF=J&6@{(q@zOzL9`1wv+Yl+Tt(3j)0bh zR@}-&qr+Afe;_+KF_y2Cq*foJs~XlQ#}Z%pO0Y4ZMb*$FRKjg~?K#rs0+|Fh;YQRl z3l~$bC?6(9XBV|X?q|o6b808xm1CyEn8897(y4aWZC;JF;@r6aD0LfJ@9@2I=rfkf z>KVXF*8%?=08ID+)?r0-Wi5qcYlT|mlq08^S&cd}f3LR4c2dWpF97Cpr|22@6g2BO z`1~cvkvHI66}0D4t_F_X0DRU@Hem%bc>X$aW8q?W#tji8AA?q{A?GbT){h2@W*7OI z>=m#!<5qG`k)7TLIQ0#<^M~-}=K(WbfbZ>K(<5r@g(K%cUiXV=a;@kUxBz!M0(boy zq~DwHe|sM}xRh(u@mE#v7%$>qVy7J#`zm35dRrXksn{#a&q?^KO_-}Jb|S>L;@x+eLLsxgcHUf>*}TXqiq7G5Ks zkzp1xjD7QbkDrjsS9(O_w7kq-5hTIR=C}$)f9+v~oJw$7m<=#`N(oDOTTY;t7nuq< z>7rKVRj_h0kSQOmxR1EKCHpWo8BmFjoMX>ubjm_ffc3${to|6)hdY2(XIC`_*2_ET zlgN`U?g4f;AFXy1x8#&Ew&1&xNrgt_xpIAuYe3UWhP#phU#H|u!yQqV)H#!F1vEB> ze_8>n=S$qX&C7MFF{+JfFvMANt+~x{%^esMFB|Fl+z^LZWrkAnu0@Y^xx?9yV6B&9 zZw6rn1*1X2Ou`s3lLQ4)TyiosZ(%0KuiPFJp`<##*JVV832=3K{xQ+xhY-f5RG-WX>7LV#Mcbs<5tb z@LSxML+mQ*vKmq??}YK#fsw4rvFc}0SJvbeI72Jc&oW=5*C{xnVVQLToJkSNe>e?V zcD7*|^2CB9bQ4+AozPmVMNixr8H74=iNs?%)k2-;I^3a-7lKb;=wXu@D%(w!; z9ED3f1#Bz&=V2UD0xvjcVm`K0jXO9&8U2cR4@l_V`c9C?$Q81Uk3ybrr#kc5Ti%)~ zuBkchXP*sS1+q;>R}m|ph7tboe+HVIc>Ois4CL!;QV*`mK?=cs_h2nr-1WpfNz5qa zny3Wtd}kLQMMY?1TTWp8YEEigAO4?{@*+1%b2HYe4u1;&PaXP|?~j^_)us*Oh>FkB zzIr=c&nd1YT*(46>EeuhO2)0oidNJVf_&+I~MDB z@>zvTxE;*Af*oFYaVxBRz#faTD(0r&Br0kbAfyA(my0t8$adw2_KVci=22z$!99mW zG=nZRGk3$v+(?b4FN<-qe^`G_E)~G8UQ3N41xD6T!CT&v2Xu4RX_2M@80T75p_jx7w|Ukk6wcB&R}lvR$@+QK2oa z>8tu9C3Bn9pr?;gYnM${_2en4-I_Zbr)`PpHx2nzBv(zFYO*T-e-gZ@t~5;YJ0z!6 zJl=lXoj~w6ioz0=pM9gI;)|?dS^93AS8^>R@rsqvE zYnwyTNbh{xWQ^lOws(vOCs(a2Fk;udroiCnS1cf%h=6hL9B}p&Hu1JBZUe})3dd<` zl!mQfs0RJN#kj2bf5=@Cq=>5cUqmZpVm~#VM1MhGBQb|kkp+PR>y{c__X+4t7VMie zeGlAIkUn5tK{A=Ig3-iid3nVTCO>)xbkjky42fcZ(aGU^LB1|Rtzs`W(3BrBrEu1- z2W+$*Q03cL$01^FVEv*Azs;XOmNCrM$0$3sytm_Cmj`rp;7@W*eDPFb8AWFkUm|zh%kZ}s zb&yzP(97;-kK^uHs4wijxy5F33T)PPz>8TpzbgM?9ge=3%nDuF|G^@I9uXg2ZE(X# z%!YBCGjwKZe`5_&+I581D7_LHDfVo(6|`PY%d^YP{}6_QxTu`lauemU%`RXsk9L>c9#EOg!|_ zS#|**b&Idn*Vr!`shk)(i3pBK^j+Yj>~U%ozCBjfe{$FIcY(C4h8a)@cbB7u4A>Ca zUh7D`VI_X!Q(Vay8%a$S*;m@2kCR9x^n{+1stNnG>j}$rW)yRGPP}n~XQXE$GhN-# zLYhuyE*JhuBwSCq)UYyqU*#OC4>2lOl~zuwm?E1-Bw**+0Ik^oGnQ7PuTds+P$w2G zg;DZhe;%bvN-i+3!doX(2ZNM8sr(#BW3B!n(duJmBWVF^L8@Po-Cy^KOKtuZW}3GC zBSWqj(+?JwsA-ar0i*O$Z%4xk$=>pB`4^%0)NqCzEW=8XCpyevcmqb;2D+CbHH)3b zi&gE&C5!Pux*oF^_x4~E2915)p3-N?MvO$Yf5w|ZSL&wLcP_jH-@g`Xnjk0V>GYe+ zp0>_&s;LOj_8(ashJ3IAep63?eOdQ0o2VX!xu(q>)@PC1Q{AW-Mn1MB7EdNuF}6!~ zCI17i1EVPdv6B+*BX!2M4LMVtkk?T{Y%qc=-)wB ze?*^<5CjAIFp-ZkCR%<0f{VM*ZKdMEwy!YK5F$wm;N`as=78NJ;2&V-X)!v{}ew+KJU(iMYhK zO73qOj{6_TjqB{vJSe;qoCkA$FF8R)reXX*ntGkAFyqlh*Fgg)wXxcX**0=G`0b(> zb2OT$lDWw7>wbqF%U*JJkyL|Ve~8J^NJsltN&kp!PQn@DuJ&U#h9S~8hZZ~q%^iWA zO*hiN4AmMZmaO*ZH9F)(r>+_&U>$d?#9e!h+NF)fI#_&`ghd8Hbz@$;@hf!^jOCl` zG}(Sb3&x9O-r=3kj5EBd!+o)h{7d>PM5bA-`cmRX?ml0>X)-C5L}%Vjf7*i!$$nig zk3K*onWS{AnBsE7v-o!WtU6bo`zy@vdSXg(1nRqHO z_Gt*Gt`X(4zTV(2$RG=lxvlun$~uy>EQNFh77%;W`c)$K%%358&bOF$0Z!hlj3pny zO1aawS7`oS`Tuj}PxK@Sf1pkNLp4=-EZgUq2CeQ9G3Al}#5Dpk_nIuJ{z$q}$b@s_kq8Qn|iMoj?!H&0Q>%-z;p^hbjXNeo+R>^y2bY0sI6kq2m-;JzDmh#RocWOl0# zxi!2j$jIZjGZ+wWdcVC=tWWx@?iJb7m?67y=5CPi+tgo?YF!Fef0dy;Ha z4^*|K-^4n8bQMODXTDbbddYjiQy8<~+`;KF=L|WnBIeUIe|(C%QRGA!z}&ZRHkxld zHvqC}z|aN#&>!X);CmhYHK(`%=|445?zLnYCv`<=0+{E)U*>04z3E$}S&DbC&Bu&R zMCMA-%V>)W-;;^w1}ZLzTneMe4Q`-nLrC|ZYS5}*)2!wOF!P=$e!jc$B7+{={6?Ly zIXF4Y3X73`f59JBJ+?%Co3&KcLnVaSq=V6{T-BpqC~S80qnAw5V|$M8rBl!=K^;Wy zOjQp(OW3R*!^+FjF|wQZ)H}hFA5IFfjtf?D%Y7Jg>{UIDqtNfyvL0;yYZ!x&K3`<# zSVjvj8%bsE*1Z(QXO4b@Ti1jYo@;y}ijuo}#rRt-e?4H@9_F8`ZAJ#Vg;SUj6-+3V zc@??wh0NSMVl?SUj{L7He!$umbw2_E&a^2TZp$qORGO#xGw64LJ$&1G8S*X2(pAE< zzr#35-?q=98T4EBpwGt#KU=odRB}t2%pS4_v&>#f6fnYr?X_PjF@ik3rIlStWL zNNM_)f5?ARdl>n|NSZb_*r_;AFJQ;o4iKyUimih-4}PlSg5yGigZ;74kDu`KZ?s*t zG7?rm5;Y2=mcfz`Ii!TlrjxqqwWA9D0d|G-Hu(scni>sHB-MVh&U=JeLhbT~sDy$! z=#8UBc{_*zC=^g)W}G+E-shT6nwYd*@-lhk{y4X9?`-r=_qq#Zz zF=Sd7?Iml-2Ji3zZE5akQoEAHeY8$7y3@x*3>lHd$leJpY9~42`j*H)gqf{ig**wi zS!6J}ny0VZOZ*gG6Csxk!vTSRRB?bB` ze}#VXUik%h&S&*&;l0j+#`pyNF@UL&ld2S@9LCytUuwR`zNvgz^|A7W@N1Y+^Qf5j z(Hra}7es!~?}%ryiJXPM{bB{lQDwuadoeqZEDe6ke#+_Pe)+(n>k%xnS%G~3y{ao? z$2z;p9Mo9Q9&2(RQk@Z|^Xjtu%-x~Mf26YTCwr2z5WVZ>DEmc`x!${~+%Rd7CSnG$ zhUG$At3f)ihLt&nz1(s_A*)7Q53+^tHRK29Ir>o=Vk`??CA&AcP_kMp&0IsQ*`DG* zX*-(Z_%vkj56dUfqXIa<*+osK#v)qMY^p!P*r*B8Ka%+r*f`mbDI{x1)d#yGW zy}xu-(|TbEpYJ{Qp$MpqKt$A1gaB^y4$`mkbFPdG+OCidCy)WU%g zPZisU&-K8WauT2&+KJ|IvU??|e?p#QwPBL;x<*&BS}2nKu|BohUw?${^kS5{MKXhA zPzjQrz;2AT&$bl)B)lVytUn@&mfV5(NZUcMj<8&O_OE?|Ue9^r|8lZ`q)1qiHx^o2 zkPX=KM9ns^-v;g9QaDfX-(+eRTm@2FtgRam@009{fORG(HGDp-0%W00f5S{+(*)W5 z>Rz&wR110G`a!`?Nf)tV{tK=x)fmrs#e$p^YL|fyrXWA?(lT43_a-}?91xU}Q?Pob zg3Q|vvtWJclgPrZjHTLGx49dRXyCpXWSOmlc=XrQ&%$ab^>)hw8I&?spTJ}a(~&t| zbusf1W&___Slv9FtF}1!e_nZ~ywl5(3YU%Ffb%tPQaA?7qL)5E-NCmNAHvFtq~iB} zT{uNrgtHj=+?+GLH+3Cpv#CDeG>bmIwP0C(Mk99rH^J|rKIePR?$KYTs_zwQ#_YcLY>U2+M|*g|f=Jl+N0d&q7${s#FQ*sX7p zZDKUbUN~zf{Q9LBqtgr4`Um7Qcve3-NDhhdI2+;KABwC{*Wo^R))O_FB@nkg$ERe?F#cILWbBDxL%Df1SY%*J2!GH`(5l2GZ&uwhpl1z9-2w+X|PE zz1$Al$+B@}SY||!z1=@6;+SpqUHmBDDk6Hd$U$2NAi*^*f>Al?{TR_n_KWom z_Q1P*O}2_Pw7bbW(B{93(M30OtbBlEDde?L)emStw@nvge>FdZH+}O~G}0%~OZ&wh z!aMZCr=8I5>()}}mGjUa>#$mvn9aDJ^f&gyb$Rl6OscR%j7I(d&T1o@z-s;suH7rf zqiz+WSl7V_d+^Q{NV&&JMtRcfy_aiPwL?<47EbUp~f2S3uYpvvdfq z!8iN>{(T?*f5(yg_|`o>6l2b|i?K^*VVtgu5l{VM4e?#@Ht#|o9DqJ}Ta2wb1pgj} zWA9`98uM4#$S~_La`Gu-9We&lTAJQxjn}8JS8`I6h3Lnl67*xzZw}V&q5q}_0;}{P z%8zx8h*kFz)@pMXp!O|Uja;>?Jln#2=H7tZj^qZ`f0g1|_19`H4Y8T1(DKH|Fs?{s zb~b_CWcB3(?x|y*0y(}E+a+93Pjz(xcK)}pdF5Mxi#IhNHPH1RsMnzlyAV82M6 zFlA!Q7k@wKem(Bf3!7b^TYLCzffp>iVG^>GSmV8N=C6QGPZdoeT}310#Fiu5FDHfm z3dZXXf9%5;#;T2cig_E=7mOD97n6w(=GqPNm2rkE8fI>IXZg5TvkiBebF@;+_t0ja z>|TubH_nlyYMf{*%l$&T>k+W@z-j?pn^pX$r8>;9YSe{yHrPH+s`|3Hx7u%uV_Q{c z(v8sWP8cz(s;B7(vX9TV#xJe%jkL{|?H87Ke+qo#or#4%l}v*55390hMBs%+oo#yY zpUQ5MK9EamDZej)YsqV;XO+sxjrvs2IB4|+oIPOi-l*H9iPAky=J-ZBXDX(Y$aG~T zjjnvxUDlDg4>8^B@NA20Kk3Vf_l@LQ%I?&BVR)wa#gH%LbA2AXBY2163LvZ1$W{hu zf9+7y{Gt){UCnVY%hqx&v>@9r+pjn;EyBE1%k&}W?-!pY*Q7Wv)>QB3ua^FyVlL=~ zseD_@3C}cTydkE(OBoOPVj5O~MafK!=C3+u^4qXtD^^yZrW!Ba!W>aBE}eXvGS=`6 z+E681B)oYIk=PFCuLZyLvcEpvaR#HNe{hGMd8)q4-0imVGt`yt4fu4Bvx6PhBXyXv$RYRKLwEL57`Rw5q528(X66UMkY|f1FcI ze`F(p^|}-?r)fTW+!kZMC_U1sYgk74>mrv;uDi^wWygtjy}Uw^ZWKq`%8bC(iq)D# z&YADT8X0f~$g%Be60EdMFKMi~RF_fTX=pT*N+W#-NU~yzVTZICj1EQxWAsJz zT<1P&KUYVN(G!W=UCXv=*D*a>i#)+IF}N_T(xfl`7rUS_olf?4BM!otWmgM~jy!OH zPeU(WlLFagaL2$me%WNSgf$z?#UL}Q0ZZ;P&?dd6-IfR#E?3k@R%E;7f7_^0WD9cO z>0WA`4*hU<;iFg+Tz1Mhp`i>J+K>g3I%9a8o#)qUUgx(d&iiJdU(l5-PtX@D=ahWS zTv0D1Z^7MrnRsCdyMXDjmeCWPhp0$lGe%Q~I!u{WZOj3uu;}kts~edV0GF)5$dsHE zYrN(u?r+XS$C&~R@!6gXfAg4Pq_=0hfp$reWjoYin5do_dXMvlWoqfu)^y^=st@&@ ziUkrr@B(#}t|GqRw?4fgL5)@SdboCsly;o)=gCf0`(+~)Q_vslOq90Si}{z>v6h(` zF<|qpFP=d*Dh~xyFy0m9*#VGuUx6N4%a6&QK|ZK_o8AEu1S2Z;f0BN>$~djYmy;st z!z$A5Pv|P|P1SY%6HYaifO<6et+Okn!>Tv77)i7y3c0uQ+L0@qEGU)9M(XaP{PGyk zC|3Os?hWeKeEGQ#xsQp_zMIMRGDm$U$o!MCX)Gfsu>!dKM{Xefru`zBlMyAcSsdJ6 z)%Utl*h7@EInFk@f9zplvse}T4(bt{w>W3fJI#(GZs_4rEhnf1rj?abk+eY8x@%o} zZlGWeHCh^(mj_3T#yLzpBG_z;?rD%!R@q3H$NO{*hB&OwK`GgBw#m>ZIe2e6mAyno zpcg#7&$*9X5bEIDUp2?c zYk0%gNjq3g4&6)C1dt9=Hc>VcD~93jwWLRQ#W;t$D)DDq0vXI_sCjTrQVIM#_EYk@ z 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

|BK70XPdJ80ldSeI59og2P4;w&hL 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

XAvWulxbAzlYro;x z9BOagJm+f2wyah=BK-@}2%1Mi59E(z0)|&`CeC%tw@+<4RNKim=bMaUx zDy6L`ZDV75v9^%%{i@8CmAmU3mOnWCvm)1{teO``b!K#}JcFre(E z$Z_v$Xgl;WJD1-{$Wytystob$!m0q2BOZKDF|yPSALZ{DzFL))-H?jkvnjviI!o<3 z-W$b8PUibWx!ZlNw$n^3Hj?0MlED;ruAhT5Z?Ae8>JXF?KDBdy3L;@2RA|Q9f3-5e zkF`AnsZ@J_B0QNzDChs69A|&5^aZU>(IsnyzTj+@MF}`vWGx_s-&y+sRrUyHX(sby zopaNVn{IKitXrH9s*(zRaLTQ%&_h}sj!O4es)Qbsq52#XgtwT9!ov!V zk%aZO(c&D>)r=2+eW&Ww6xh2>t5kQX?h2nIZ>1P><~Oaf6p+1Cvy*pNw^)yvR#DaD zj4{?N{ARq@Tzedjjos-!2jgfnA;oMy|0<#DBHl$M;ylZ zY@iumyErR zHyP|xp-0*cmEqIII~rpVefE?hezz5g9+Sn8f?J47th1QoICho^pZ{Ts@9*phF%Rh4 zJoafvINOw_k{2lUt1(gTt^>jAQl{j5OgSIXp=*#mBd21|WJqxeb>p}1xad*IWb^#|dKLKAe z63t@fCC#+V<~py)CDSj;s?P;IbZ85T`gw=;Rva64Zbyh+c^MX}mHzn(#02~;uC>Eh zL83GGuSvz>QZD%>a&5@=Aj*%(HCipHA~YUK8(UZ0$j|Ik=7cK`)VZR~``@p%sQkylT4k`E|rNpDp?@{hINpqo}HlRGJEG_&h!p zgZL{O+bFgu0j)4UFlZ(3H*KUkY_$iA666N!1Z8jfh0Jz}1d(pY_;ZfUdqw_t@hyi+ zcez-9ZD{B_XAjHrN{;eC$**QO|CmPJ3$x)+5#xGz}6_JrPl7%koiSBh3BN;-zBJ0ikaDB_v9@+Ea% zvHI1oLFa_3QnuOT@Eo+hZGBtS$+ZZd7fcK9RVE6bW3N3zdcYr~Y9ma?S{HE#M^;^& zz+SNBXjg zG4E)er@G6XWXr*sB9k5#E58Kzw`%T}8#IqJYz;dNF9%OUw%-9ZkHfGQP#V@h&PV0j zPo5ZN^y+QG5#2t-@B&DP z*A;bsr}b_2LZ%Z@G}NN;QdpA&2r+ zZKEmwSu>5+u1(WracRekW#q#{JEe`2p$^Ipz8>DoHfsw)56G7=9l3U8uj(lF-e|ML zG(8kAw`wM93aDN^Gm-EDv#3}bK3(vGStv?S0U|zKaShtTI??X*i5@~Td2?vBzw7mmaynu9jbchYw&v(vAjl{g{&O5GM)QFukh zmvvk4O+!#+e25Ue_li4}eH!F!tiz=EoiRbIpZC`_`yks`pH5ZDRKy8?TFJUyA{$q- z$ZO;W9oGaes%LUC?3;t7f5ypoOX&;io!Mv0Uro>Ejut0!m2gTu6ZKIyt&9qZEAHX` zpdG3I&~q4dkAw+UpA+^7MtsUGl+1rI?fx*FPFySm0!kxF8B=Ww!gywMQ%}CROV#bqK`D*m_&Qv3`HC> zJ5dX>RAnymVRq_Ss*0I@#r2XH$N%2C{j`^kKqR)4;)T4i=Bc!QeeJBPpV|YFzy3{E z?@PydV@o#Um3-=1h`rc)y&l`mey=epqfgN$PZ*BSf^Umb*KB>8nSqvzAKu|d*4z&Q zwl+#oO+gU#9?x+4M~7_yxx*8q1JYt9gg9sX0i6M^lY^MAJ-NNV>2fklMpq| zz)^RC*TO3Gc~=F0_k%E26>wFkfE}NHMX@1svT7_;xZ-{kP&S>w4R{g_xouhOuiol3`0{420 za-2BYr|2Z>_Oq>)H@H^#+TIR2`6YII=45Arw%%K$>~&Rt$O_r(7@AbwigT|zF z`&|{GldcN+S9GjRQL{w zVhmgYJ3f1wG(K~3dOy|TV|JRvmP)@u^%Ns*0y;W>Qrv%(Vv4U`#Z|Fx|H|*_=pq8Tee=;V;ZZah>g8RDQjAFzW4Qt86#-c>X-Q(Xbrv z>rjnEl*Q3L>MGGs{m*Ob{Hu8p{}ipFmi)O|JGOtqZKk=d-EMxZp^UdhyG4TXHLNoN{WadyBP(Mt*Et*pu5({x0C*jmbeQx@N_6}9#SjfXidU(KlU-vxW! zdhZn&P#nX5sd>4Y$rP_{(MR}7Or<)Bl!Xq(2CfPBoi?nkzs)SE_zz|V)hV&=tMe8e zbI#Tl!tQ?!>HKWJ_}KGlJBDz}IAIIUq-3<=B>H}`6Mt^)8Ik&$@Cw&iYVma+4wvnJ zXfXzK2^oE0!DsFDUQvv6kG{@^k5oDE;aISsv`(h@Uv|7=gY9W{yypSW1N?u0k8+CO zBVEE83tEf*S_Ndti~JF0-mB<40|wHshKzzJX8Q<%Xh$gbiB$*sqgU4( z+l%fnyh8O&iW5tguos9EhkWwfE@C5pgtw>`M2M~Jw7mvB{8%_mku{u*JICyM+L zLt_j4h{HQGy6xS}#87;WEqf9KJu%i<>NB;Sl*t6oV~a7sXxh}Xm^e60Og&XijDXff z0cYeUHe79gr}oxo9MShE&n3SwwD7s%%hs;+?BauYEAaPS&J;Wc zEnCzEN!gPsSpn^O)aEkvOtMzkW;liTl9*%O;d|1rpao@cBI>2woTfu1OEmYPow6O# zZ$IJ0OeeJ9Q>~X~0Td|}pzC7PnRNvpAY&xBOMSb2IEPs{RX-ptq`|PtN;{?5w<+6+yjJf_8 z&5vcLnepmb@+I{@!Y5UK0n-%oB+Y#q%IrAhe%z8`e4yrj&3L!l6D#GJE_oxieVd^} zdr7+;-Z%6$Y=ti9#W#L4e+L{etVIj|6%oZc*%QO(0-K<9JO8>zR2X2Y>*t!B%m9EHla=vJjoJ=(!P19*E z!5*_l#Z5Sw#5QfEGNz2>moMO>Cr@+g9%2C3vDxdNgtx2H=m@3Z$ zV9wjg1UyF2DGSh2yRFm=_OM>@C&lfqin@S5$J*te1vjh(Pk2VT8?n{X`iyg~S>m6u>1`*}e#npGdvpn4C%!M7rOz1>>%53Ljv5*j zU65?L3@VgkX}ScvcjLG6Wv1ykFOsd}@^)tLRZUU6E;mr$;Q3Ne>Ec<+1hY%WvCYo+ zaXhYN4&kUmq>}z+=0h4eyNoh4G7rM3ObM`cTm18XVUP4(MOTQm*#q~(cA*}m!7mAg zgBiycWwYWN4u&h_-5fqRf6_8v|GwRtG^3$1#1z_pD|B`Zwv?0uT-XJ3pE9KJ3*lm zv)FKdG}#<`q-=dZU5nkyFU6ip$7^R~-cRijvGTO_h_lk@DZ?bKlY3po{%VowS zV5}3I2_;L=o|&P2j*c(S=a++D*poTgb2zU}8g-#kcUDFm33S2$a4I*9G~n~(Q8T( zL5rcrI>9XytBr&P@beMMoR@q^Wv|zoYU9`#I?R zpQ&fE9kzL@B(p^Q?{JVJ10Yqb?mag@r*WHd6ug{$7Uf)vXiN93-^-994{67 zF%o|;yuTILmO(L+{=tFbF$ZugBX ziJF`Kq7nbfqheyNU4N*RQhl@c$*YQ5w;XEYL~((x+fS9S{z)CrYg@q~+Y%f>88>86 z7DOvCd)PW?vglv(UH7Iwl*#Kw|HuIRtt1_G!H0_9vCWlvY-jQ1o1yvKdr*siMMt$* z^b+>C_Ib~*8&XkwMIm(4-r>jI__`GF=_^9qkPJq%WQaZR(_0rORxDwgpYb~9L9hE! z;_PH5RV-nSGsi`CpaFOv`u{)1z68FhI@`ZG!nA;(=m1m4S9vZhf*yP*0!~M3Wq`Ez zCikXI!cCJlC0n!5EeT0US1N6PlG2pErcGgB!2VGblw}4j%nTxQ5Gqx0Dxg-VwKFUV zNELZd^ncDx)uzC__bH`W?()08<(%(1zjMAv`jC7tRXhlsrCem@5oQa-LyF8Iv#IlHE>u2$8Jb#hbcvQr zHBRGun9afXyr&xbg8a%u#Q9NOYq-LtLY6TWy5U{y)py}TT>qcsXyKS(K&-hH`e^MK zr&THN-6yL`;T)XH=n{5X_fQ>gL<0t4C;b5NS@o0N(>+Vr5})NDj>Hbw1}%Zz@M`d_ z7?UoIaG&oZJoZD<;0h3bb|R8XqVtJM3f{`-vh1OpOsXeMHGQfSRSNE5VW;|3@Ga(x zDn;a8Ass&_l$|57b~@&i4%3cFzaG*NYd^IVk6j#TQ%08q=zQ_&@vhqh!}8z4o3K51 ziE9-2)X&m)+EUa$c*N4%HILFWmQU5IG+QF)lvGCUChSD?)DV1si@Q7cZ4g_SHc!}z zR?SYdr}opghOk`Fz`_BAl?a+_5`yFZ6-4}9L{J)X^#a@Hy;l^s8?ynM0SrA zend+?wB%aQ=EXCA>y9`cTzSYhgWa?8kT;$=&UJ>aW&fJ*5L#9qqP`GbFT&^Zc)+N* zD!k5i!vU_->484eGwRV$!BiIxXQ~mcO$mLj+35Wy)WdBOc0{d#jQ_;~PQKy&&-{XA z;x1MhL>QHSipzr>iy2YvP!C6h`Ckj44U!cfhVhlxp)HUMo*QyL$-7-_9Y3fY5q8kDfl3D~ zasL%dU@`V#B;!*dW=AEXmN@~;qW1>k-S)s&hV1HJzf>P;*wCnx-`)5_W}CLrK{Y)paJezOlMi8Ws#8otNUJc;8Ig z9g&Yh8#W>-Glt}3MC~BsHjRh;D4>3Ji3HmTvwkG8vJep@Z zb$4k4%m~D<)%e^cP$EwfnGX~!53Do{J~p-bDDa_5jgOh`xu9t%$VZ_j=oVuO_|Qe}Aa@W33y!uug88ds{k_{$(BA)ZEdUN_Ey^6m`-e6B}#0PFmbRR)`IhCIi z^mtPkzjOiD#hiCMh%18pNhN3vCiCNe^kE;OW53d{#N+gB&Nr8AvSjNXaUWriLBDYc zcL4m>F{%REtHWm+$ZMx{$M+1(xxuR**Q)(KQ1OKWDm`BV0ShT*Olsi#>IGj5H ztyhl1q0eDrwfNW<~qN~{>B~@Sx|WI?(D}|Ui)pM zIc>Rqt7C4#3eDA=Ut2rN(uxzyr}+*D2Gl59jKR7tWd%iYIP~1=oL@H$gFfYq@QAwi zVT0JmXYtv;!e>!roL9~?#sP1CxT1MM-^$#%e7`J@JD$eY>=54L&^FZP>T{XV{6{LE z<2C71(uablONZ&)Ioh0wLUr+TWoH-95eymUonMegudajZ)P5@%a(>OmSM5b)+sE?D zuBBfuN@scb-Rd-D1@}3%slnx#%dO_yeIJ=^`rk3DxP0y9t z`R(D;((5I5(AHd_mFAlco9nwl!gUHKS-#32$Z};ixN@d%dPBYMtLhy> ztFpq8;)&N3=+;m>pueGB_bk-{P*(WHGnc71+?q@Ww~0%278NaMa1la9?OcVkt)G0Z zrQ6*L@KTXHwyCkTEUR-M%?Zsg4}|3!05WD-=+Fwu`mXn7}!y$4d+0&bHn5!-^Z(lJ@?_1=N!cR{~w zk#)EEH^ic;oFQa?C{C8xxz57jrPt}X(@okj^yK)|oh5dPq2tHl=&G3Mbw^BU{`p`$ zS{liyu}TOL^Ite-vAp_}JfP2|3N4NY5qT6)#5(wxdsjW$YEXFUiHq;B>SNpBIxl|^9uV?{9z<7^xo$|!G_b9f; z=7N0V*IFGSlK$Lj@L736`RsLbWj3+?$Y6V$tm|9tyb-tCyjxW)`HA-%<>W1FPi@|} zQP)!qphlMQYpxE__T~9z+4Fo~gNun1US~!a`-o8?9L|vhGu?^mi!skbu~@CCk9OQ$ zBeCZy>=Vgj|!4UVy9qvmC6C!8_cXl-Qe3`s#zdcCNTy|P6b8b@bpV)Y4i)NMf-*C16d6l0=p5BvOgiGYA71? zv_sj-qjP5lAD0IeOSFm(5zkaaa#!TIBG5LoYbuC;`4*q$Br&dMNmT8E!F>ev&hC7( ze3WLN`-ot$2lIDUy;k?Wb+}|Cq^sgKE&Wi&gQ1*e#y7YwoGsE@d@IF!PcP4>h+ah9Y32EU%yj2BjXK(&lEzVWaJ`l0UX4#Rj&cLg z;!SBN<$H+5z%k3RcEaXDH zBO!E2JtjP&^uIDEY1bP(M$|)rg~qA4YMvARu2%_-h;@1LY*%3)3R2?M^TseS+!Xk# z_TG#xF=H|sLG3mEq2_{NI+R$7jB8YXzgPW6-|9;69)-o)V~oTwnldbKoJTMtndvJs z6#y+(PiQ|#9dl~Bq2Klw9JyC18o3eIHdUWucBv-etfR;#@F0%W>;pL<#1C9aX!got>a6FRrfe%g!XIF(oZoLxpfUL zT`ITQxx92c`MD97z61vg{P=|L*6xBN5ie!Hc+0>&}yf@VFF8+r1#;74*8~0r_Rf|Ar4A0 zy?mQtx>!HeRJyC7H2)1@hhg;MI}w+hW#)>^qmc+U+Ly3oZwOr*V)^}lX#e~yPiZbk zbL|R)En#By1y&WWiU);{_{U{|Sy2_JZj7WzgIecu<$J*nb361YI#g5Gy9)e@vGyy( zf=U*GAYC*;*cq5rzKvV0`7IM8RF)hCA9n&#QQy*;IQup##^N~kNga?C`fv3e@K?>F z#Q*18oBj#jck8lhoy66DSMP9sZ#rM!?TeA;#F)J%cm?W}=R(B1l5Co|xPn#?B5(;W zhveqtB2!!6&obS&8NX|RSC!`|UpVuActt%t*kOA(cO~&v<0yVbd(Cc*WtV<4mkl4@ zu*ZRRn>?1PK_jZC2)+n!RU~6PD(4;b4_dAwUma@9fg|P(*%!Hgl@`hst)r+v*^I^YeqY*Rim#`grEKAU;_z+va0m_&cJnd9HAyRkJ z^O(r@M~nz>H@$*?uTIysxHaxXcOu%Z9f)P~?4`cx?siq2=4nI(JJQ;eGggbo4`y-XZU1d5S+_P?hfRi-|Puf7)T zeESgpQ-s5IFYTAQ6XDPB7qF|>iyA;ntZ-r_yK3U`(YKO+#>I0=%EuEnY}lZCmMZc= zsyk6R(=j(oA~dtSFP17gH4ST;pw(ITHs7NjZM?>w*R|0rXe~KvdIpGh;Y9O2GPH8! zv5v{5+o_5WR0veQ^pAJ)vpdz5|^mrgmsw?<23P}GOLGbm6q7^ z&4^BC%Db_DWv{?lL_j90n@PBxSV4n;?`zRX-viJ+|m9CBWIN^*P+a^Ox9Y@V4ycb$5r#;1fde+kG zEMcw_Txat=+A(PFEwpx4r62}5su=6Y6{|kpk67$~ggsXFeDJ~SZsRrOrPAwEjReX| zHW7~2w?a|A*_EJMW18<@b_xkIvS3BNxxn9i z5B{BhALPBiE;|dE#HJ*?gwO0}tv&zJ92O=8uhA&1Ic zM%hl5!>R(kN;8VM{WGstuR)FVI}qc)>`! z^LW;VWd(*yv;bE?sJ|Dz@(`hA!zJZR?jd+L@*du;J7Vz@?-wE`o^n7}FEUCIEw#}7 zSW4$`j>riX6Az(_Yu1 z7>l;|9(`CjQ!&;kbAYFv?dCe|>4=p9D)3xfm;5+fC0V!hSpJyRH(&feFtE0$K4-)W z|I;&|Z1N4%?W`aGd@E{%;(^>2^8eF)sLHJ@lD{%wwaIWj zf87>br~&a?y5~atv|5d;5b@#jOncD7v?G?NC~CwjkdL&2zo?WuaEe{RNze{{3T zB)5uF&6Hgw9xIW}a3WqWdUqrVv6`>;AI@)Xbv~X=m8wJ}jaJ+LdZrT(QZkQ$4FJyk8jN%1M`^o#cO1stcmzeql!BlbS2cv)xI>(<$QDLbv*8@c+AJJO&=aIG9+!YN|*ER;AasDld}7Q2xfsE8dS)nc1ehE8ksZ@`81yf8zk{4^}s8_bvMy{rX+l zrfZ-mYvwwun=@ak_S3GC&@AkL6ygoj7v}G@?$zqV8m49c3o441Ez#d92Ik+;8f7WI zyt*S`cJ)Gzy$wgi=kzK-FfcE;z9Jr7okX+IFnZ}O)aSc~-p^NKytZ^#zT5Wn&hsH@-C>s36tX-MKs}5W(3%l$4RhN-3`GUV zTzwhe05P+$Y&YM+7W zWc*yG4`q>lMPnZuFBsU{bf-L?=HpGqs_Vg}s!4o1f7q8sd$-x!m)@Jvn>H`A&C!;> zvt(uU4(1xmYRk;F+}7rMmfTCs(`K7(uH!+Sf28h6U{iyi`+~u1I})_N3f`u?Bp8Sl zz-(jBD`&E-e6Q@PVluqM>=F#6F71=q|4;QR!B9Ayl~xJiw(tizlByK4Aemjv8hC?= z1H1Kerajl97#q@2)f%+P6R@v;VLERZ9lT9u68F8{s1k%~Xsr^w-vs_-Q-eQ}PoL4{ ze@?7^Rh0fLO3$sq_|Oy9nZnh;LhOw`Z5hhcGO!z#n2!TpXC75|DbKeDsSo^aP@Jk8%NZ3M0VbT9jZxf7u8Jz%Fb+X$RJ_2l|*_DnR!LQ{Yb2H|k&D9@0K3?-rz0DJ<`PJKtOu zYxt!l+dc(Kd=tQ8{Lmh3ekI?WC6RlfPkB3h31^fQ{1=&%tm6Y`QOciCFZMVce-FaG zq6O-Us!8EC>u!FW0wVZM)PeJGuI|RU+9F$Ey&KNho>RZ2xm}P72H~n>jyf;2G~A|t zoHA%A;~(CH7R^%rd9?I>j9+Gh9+9Oc5>IiHSR2i69ddpg5J#=-2Kje$%X#Sge$fUZ z?hZT}*TB%LC}>Q@jO$x4#|}iTe@Ev+eie;UC}VBiT+ydlw(PTYbE$@@W|Y@KoRJ}& zX`(!izXECeiSXt%-#8{SaoiM<(IX;bZuT6}K7xMHBRmj4W}6E)R)ie-{$^I8i22Y4 zQqa@-wj&CT#2MnXsp1ne5?56!)te(*cfdQI3d`ktE1s%&icpf4d<7=He@8XWuOvQA z@}lc=eIM!W(&w^=m<;vi!S@Zu7d4jH5%rry9Wu}F3Xgyk%?pSGwBXZ~g0}Q}=yT&W zwq(iM+@Ex9ROPd@I`{x-()3HUyR{RJO)CKK)YJnn0H0Koy_cTJoXzKv@XxfUG7 zc@2KuU-Gu0W<4W)h+SVeJhwF{Z%P%Kb$8VrCSUb{brTS6q3Afop^=I9YT^gphf;)e z7B9Hlkf9nK=@*G8PsdqpT z*nM;0tZaVKdO_~iaGj;EHoroD$?GK|%{?Fqno&CRR9$CAIIb$nizN7rH!wUS8tQ|- zC2w2D(A>vW#=ZYf$1lFUimpUPr~Aj0Yh)*0d-5?6|9evZWZF`Pi8 zllGzoHbV+Z$DewkfB7EWBXB1B|Cw!6i7mI4dq~P^H_;xP$5SMSH^_4eEvVs2h_6VD zB^_#USNNuitE_m4CnMU*7#f>6c&ws1fGR})pqRNLd_Ulu%z?h51=5kw%CFOJ5qAiE z;%-EWScN%jNDN5|WaaNfi=;2#3@s)#6BCKk zR7=*@SBqStbsbE*Vl1%`Iv}IV`WI;--{bvQ(-@4;o0v9Fb`?I#_^V@%qJ#K;gWZsU zXlaD+3WFG|e|9@JK5d?(%}5dTsdXIqYR@s#jd`-l8lOo`(VT`$;Wm30GhH4RO0F(Z zvueTiHF@ETeN?MMzMXhma%Qt##_`fPVP{ne>3r`tMq;?4IO%Dxd(U2+BM}VwX6wu# z@5@!^*+!b~fPQuld=Pv4^H03)I7Nw*X>2(POzsxQ{w>j2Zlq6OT6aGNVZ^_wbzcp_JoHq>jDQogai zSKo^xE7sD;l&F4_(IxkKlWc#HS;YDSe}at`s@J=P@gq9T%bkYkNh*6@Jy$W7@6PB_ z9?)+EgJNuu*9O=w?~&%?REY)NP5&%A5N=b>f0R`+bJg3pR0jm(sp7l?_&Ms!&BsAm zK0Dl|c&VsMXsqifS*ezw&UxK9jVi*_TyOx6+&9Fyrs$AaZ3g0@49p_jY=4~2f({4J zJF3rv_~k3u0I%YDo&X)-N>1raIA~znrH*P9Bwm>cYwtoc$-V* ze=iy*FP}nueYw*r&$=}QZz~rucN&Y!{}7mEoaO*)CVx1*S+i94v~{LYE2~s2bjWni zs(ypEdIxkglsX>d*TK2!{9wHL1?UKNz&7J#ejR_9_FJ`|22WE}n#w2t`^n|o-OKe` z)o)e%X?0YY)Drb6L_ChF6nX|+4-dK%f5mmcBRcAcSx}`A*5N$=07|GzS9J-4Gpy-? z$oVwKG#l6NI{GE;gJVzGNGVnC!z$IIR4WMEwmA45WpZP0UkT(;T_l>n@>s=KimITQ zOu68W$;2(EJV!a=HH#Hvi{;=`%Bc#vI}uJ1Ypb}sTnwk6CHMez%e=ISd z^XoLXQxz1|RO@bo2W3Gmw<*|B*CAWL_NZ@X0`A0+4z{s9f>?)gP=w+sRkK|2+SB%A?B&6tatx-mmE@-`|abDxMZ;R2N z!vtxK3rvnV@&No9N9r#Q8S~!}e>N-Y=hc4IB$*``UyxjS8?&px&mS!CGXY@*Bk{E3 z{9ETvR6Rvv&GS`dp~4n9ymTkop5AWytm&bYXzo`oYY2lY~6 z**k^r)A^1$zCD`X25~;Zn>42Ir_fpO;h27x(M1f6nm3J81%*1#kPzfae^QnIhdNKT zfU1Ku{ld2vUTHqQN=Lh1#E1tS22WiF-RH;efBvh*zQvh0CwGa=B3AgwquMQGy@cD+ zQ}F!h>dWCawo8m6d(N#ANc~H7-rD`@9jl62 zl;%_)ME3~W&BQghG`GV-f5q6^dj%=g-2uiJ3#rC6zI#Y2k#(lct4cA9b|wi1_3!eG z`ZFS5X{VMa21sbp)?570ug!xl(|IuuxRw869+SOTM7F?Pwl>6e6efA9*3*n-TD=rxji zC{_Yc;7E+|4ujX2U5*6Na}s^s6gZZDjDHSZgpEc$yo^@UhuBkJ;xGB>UdF!%(b9SY zd!`o-2KfdTu8r*lk3ygEez*YrXzxkjEvj3fz6^cdkBu_*<;-<>uQ~Q9h)X_zRGhV! zDJIhRwQ5{dTX{aNe?OiX89K|vXmy4E%;*h;m5ShL?j`Bp%B9DVr)|o30 zAu?J>8csD;rdN%_^(oc=4(HPzI3th6xp~TxO&X#3INFWpf8+(Id6(m>orS~Imx&9G z^jt%|e4*KWj##ldJ za&P8j)PHO6zQdI>O5}@t@j*>J5kZ0=unSwC)y_xZ>}KKe^iwGl`78_4r5}7K^kXqps~*| zI-@t;B;Si;^rhKGb~OBpDynD=8C|~VsM)t^-UObi+IwTz0!B-<>O=btqXj8dI13_% zawJgusFFMrQ?iL_HmdWO80$g(8AgIS=T!4?twFn19;X?OGjj+1S`VtmXpiApFRA7; z0hDXwe;IACBjXyblEHZPT@Ueu`w;h}%H{`8qgA&@em8lgWsC6h9D7&J?2OTsn~BG~ z!iB5MK6oDJgW?Vt7qv4mC__h|_+vI3{;e2-Zlkd>Wu8}vGmR~uZJl|8e{`OhW0W$G zd3(cd>R=R(^I9H-%Kx|Q-W;)Y8KN~jG*cH5e{|_x*;k=T9xGz_q3trl%{U+{)R$53 zUAAU2aim`|df{JiHV1VE_CD#k6ttWjvIR01l&#(MzghF{M6MIZCEBLH*`EI`q6ECZ zMtk?eAuS)8**!E1@+YsadJ{h`$eV4N#*8k_(kkA1(0Y(iZMcnCjPczD`xN^W@5l5x ze_;r+HmnDgi%@P71L+iQ6V2M3+43afwbU9k1;Gw=o?>C9+4U^tl4=8b*{HsZsPk<&L*LR5yh8t1JjG3602IWfh0P&}JFPklxicr zyMo_YHwZhm=LqE?CVYn0lXizpk9t7X;Bu@azoPeJriU^|suXCM72MpXMn}Oy#64-m z77S+zn;8+aR-wjW;~_Qg8DC74fw*&Omyhe`>I2Q!-A4$?Zm#Q7IunSy;5wMQL_f^gnhnP?gUkJR{Wmw)Zs+we=vK<$H3b81JO0L*h!&J%Sji1^P9$(9__D56jNt9qLi<^<$U^PPH*6rk8w3pZFyn&P&9+9d zPP=Lf>_Ce-A3kK&(8pg|fA%lG(zzUxm4|Xyx^2u0nnKwET#qHVGWqgpkb+NUx~a4& z(YNZJ^AR4CRxOBQ;L#8j5Me+19S3BEuxByXbr zO!*Q+UCBySJkF|5>kbP?)pyJG=YLguB$(OYVj0MklBVvublfqj0Lufj3#VDJ*ez!D5D|Qg6$nHU#KZ0JyCZA`(c>(uMR+6{TjaO zM@#ZBx4QOz{Z`phe{Pe_Rrx&1>?nPr=J6R**muHh#0ny`!X{ZI&WbaL{SwuQ@&cIW zpeRP5v1$k?y{83|2rmyY+Ss8f+7c>jcc1!+@i_RIXS+Nr`iT!|G_uN_*rPTSm&_zjfg?()@mLEQU}jg-`U25Bh(o=rSvPPgMrY~W%A=|f{cu%~9EDq= zqrj^Na_(vOUkiKDa*G*tHqJM(`fJQ(8!s7k)Lb`>KU5TGg$Vx`s4-N@a)?ZpnT7e6w39C#A~#| zzo`CLf1^(SKH4+2%;gfhya2UCtl4W{QpafumGzoNU!LW#{BCQf$Q<-JF{M#V1mo9! zOR?unk1y6JjjZ3GoaPK#h5R}l>;Y3%Te?Xt;f9xwN1WCH2hhe)D!?{3aMtq}`Ei@? z(dW`GI~>CvBb)Icq&nt0<~GT7r7D)#dr^BNe`ij@-t^h;W8*!Km0mA;n__dVPr8|AS}-e&yF2<~%1;Yg9i7^RU2ed~BQ(?Bc-6fv?8 zk}ZG69%~V6f%Gjhz?Wzb_7kfKK1U1ea?F4?De411`w&{K_IIz ze_vkUo4#0?+loEE1+D5mXaWDjxTZLf8!iniPKxmzI|BzizmxB+_*9TmUXrO2+jxR- z2*rc3@0ccv4i98C{-CVL$~HbK-y6xLRn92*KC>;P^PJMoDmfY+QTMLZ zQ+i$B%j_!Mj@mNZP+z!J*x=Ahe~nMq$$x?NKjAHlWg<#=stH=*>ML2f!l_(je>sfv z#w1@UcR+cW#d#;IcFfJ_;>YQJUs1$A$4u8w;J>Tm@L9$h5_FHi8}3B)4$~dPjP00X zY^+MbcjtwZwr_3UD$g-->dX4AB+F@qG?dB%%x&H9am|GwsXpwF*Fe9#}d2K%Z6f5bP^lA|R@#rFCrM?l`4GqJ=@RXCUKDq0`BUbNqN zzF~vnJMJmpbnj{Vear}|=;WAN)F?C?lDOfzyELO5lPU56&&g8G3^Ge+igjnsvGKte zFXd_N!@ln%y9MXho@IZlxzK!Ec}b8`EE~n(h&If^((C*MI1uWA)@6S)e+IKZX>ftB z?tLgRJ%jpoE*&8c7{1ZxGA~AscOQXOB`8CkNfgObVwZ+xCZ@&nSW&vQQ+E z)fob^sVEHt^o0C{>N3buwNq|QqmH6|^sP;?j=4D7WXy4)*;fqCe zhgg%#6bt_sYqbJ;a2=su)IAI9agDRsYxB@%G7V(?Rt(ilBunu4!N~e7uA?64uekvI zx@Wx)V2^)>D|bC?f^9|HppUt2^)nHR)Hb*95qJgsjMg@nTg`kye|VAWWZus=2Rqyv z;#pAMP*qfn)j_E(eV_JhnCSy`o3FvYP`B?Su0Pm>h;JiW^(M{65_`43HqLmTJk~M8 zSChtOwgs}3GxB%BR+Lk_y&r3J(C1EcE_Z7*zpx(UFRJtOU#Z_>;+Qq**X!OR9&z}Q zn}+(1l@@9q75Ow;e;~rB(E@ppYu)2YsOsc%jd|7`N>EK@Mh3q_O#PYzC?^FfD5{F; zkKoZ%Ett0l`NKkUgUg!4zN5S(k2MxEahhK!&ym+0ZH+ZFXY{#RUiuK2gi6ZNF$SqF zWk^c(EG#;GYx*VKvzm>;d+Ux^3K6wwL8i|&+kD?QrDjPee?#2YUYr<`2A?n=mv`4c zq0hB;dcnC|S)tkJn@%1n>t6Yth^RO*ivNcFPRHbi(xvyBZH@#(lB-u(Cz~%Ava7g* zdX?x?uZARM6?0AVsL+!4)ByHDOspzL%di4vVQlGjT$@x$@(J75Ia+I{#|d8W;PvtU z;AuyK^E}1oe~=z=^(tqoCh1qKd@UX4&8mL1;r2i~YMwLly^aU#js#D;6PH~R4A_gf z*4WhMvlPq2@+)7{F7rwePgC9Ta%L{BkW?_R>y5!kZK0?clO_83enLSJrbO7sZ2~bv zq;wc!HVZ5nvR3Q^p8HgL7i!^+jyYm{NVJz^NJOo?f7?CBl8vJr6)hVbJ%Bpv;1JZ( zkGl38eoECs{(*YxGh)efq%5w;Y-4umo+gej(T{s`wx0vSRa~QQLNC0f&Vw_`nd)vh zSnw!Fl{1+Mq5YmDNE4*W$C*IMCgtNOCEsj%Mm05mv-5S;qs!LSy=QwE6q=2pzyG)= z0Nadzf2g=nvQqC-kHOWqg&AR-?3PmHa{bnuM6qH!&`P0t11U{+!{J;Dr26t|x?#TJ ze};}jLw#_g@Pk-C%?D@QiS}vEldvf0VybnIsJqGk$TXDyi!%DjB4Al2ufQ*QVzYi? zrikRn5T^cjm~<$&pFxzml+$yoS~fI)74le-e~(cm#uNXHst4tC;%e!S`fgB_Sx_~d z6x*3KAV;aCRb0O4U1JM}v*)!27{ZlUI6OKY05y+g=vur>V^E_vBriwoKVU_>Gs@;jqxEC$nZD!lr-SR})REMha zHAI>vVkP)EnZ^EiP_BDgWPCV=ZEn%8e_+`Lv?F1^|JS4m(7IGO=4eKR+nDLX>nPdB znC@T#swu>DEc&#F_i2mjQL2MdeoQqVEtD(P-7=~6nD!W>Wu|A07NpkQs>cK=^8%yg zpCkWtXuq(Id`-DamOdeSE~88Lh~{?wl4@$;^Ryo8ZoaQ%lWc)@Lh*CZQq`IMe@QUD zx*0wIlg&jeEY`oMCdua0{hh^*$-Kgt$30xK((o`MuXW&~U3IEiWBr`=v4ed2b#WZ# z(cU~*X%|;_7ctL?HCwKr6>-iwUU)sDYq6RCDD)yTy)0Jdz_y-*zt?rt9Z5F@)-qbC zE?EgVCiSw9V1=l+DzN7!$d<}ue`Ql`f7hkvo8besMAOKsOI={c*_bc#3BD6<6AVl5 z6{PSk;#>!`tUSa$tvn|fDmU9>8NV)7mufwzzFgswAB2|BMV$35XnFNp3Rk~?(z_L9 zaJ6+e_AS3Me-mEBa(pBLMR|n!A_Wn5L1r6qr#IBQHQv1ROY{l627TJ~*haLNGP)K`5o+;H z*|w1+x0_O=4~ zAE(bvTh4XbL&j-Ue9^(8e{`W4@AGLu_h1V*1Uq0u&TL15>M`igH!IKO?=t3QFg(1R;C1^&)< zRc;1}!jHJ&{qlVNJJIW%0-wM_yuv4S9g3^`Mbvah@Ut4olD$BlQaX@ACJZ1x|50Vdt zas(9O@yX)x+t6x6i&9?TPRzOwR$(7?i&i8_`JI|VM6ip+f8!QAy~b%Q&+PKvYfSLF zGJ5fK=gLDU^ONxTcrd~$Lt*(p`7f62%Q&x-SnXnEmW8H zIwmY@tl%P^f9H&U32~};ZO(%U#l<{R4f6W{k9Gz#)6jx5NHIu(6vx;$? zgw6ZvIo>N{Y;z(8}Rio{GaB{ z9x=Owe|!or;qMu7#-N3Wug(#Vh;6vXTF0xr;47d!-5TQ$ zXt}(F-+qEeTF8HnGe;(7#$5xM#{(av%~ODFq-9Ak-jPtd-P0bFfLP(Ad|P>bV?lZr`3L4v^dJQ&3`TEzdV5 z$QB?5raF6>_p&ZY)E6CGwO{}!BN++>C z2lgU~Y-*6l^^^#L2AG!6(z=e??Kn%Fe>ghzD9`7s3Z#z0U*H|GL>x$SFx9AcJxh6k zva4)-Rf;3Q7ZZH2=@WQS%!tO`t;yxzk>9PG%g*sl4gVdMqm7d+`cr?baA7^4@dj43$23go1@=ceSLKmGcR`1~7$uqKS z6=Eb~O#aT=BRJbWgf}3YJQ1iLfA^&AWO>-8ykuA+t5iTOu^(4ECM#zeW6Z~8s~Y^U zkN>Wr)aqegRL;}}0%tYTIn*e=3I1HtI{IF`Z&gsz;5V1ctbqf;C+s0vrEHb+JpYcg zMt-M0Y>e~XN!(?ji^dpHlWid+0VlL$aLv6@@O{ZqT#Z>EGd%N|A z=IUEDqXGxyqm(l}k5#{_yDPBSS;U=mzL?o29Vupr^)LG!^qFlq=B?brI0}>NpO7u( z9_GJ8JF*2e%~q4GPuXxF~U2)YnW91=lO5gy~srrE}(dTkcd6T)-!Rw)G&La6J=92tQ zlFHI>(<^~L>Q@-2a#IS23+F9`OpNkUP$K-vx<^~;8fh-ql~Pobf7OE{vEH5Nd5rBA z)-fY=cU4^vZ1!!&QJ*g;h3{D&?fPcvSf_`3$d?wnxcUXTw^8RjuXSg>%I6ktt#MhC zmflTJ-tt&~Jryj0*mRRC5+jNgGJ^5}~rPrW6F4glNY3suu=-P;Xueyx#JPe~f z?JUpb%e#vc8(d7ge{u${*m|@PyO|j5y*Os1)1%pkmZeD>(4S7*$#qtxG);FdcVEoZ z2RlNaQw)x1Ck?icSzKq@A)hg{b|c)yI@WkfBYQg1v0l zv0NwdlJh;QlIbW1s2(dE9u8Y~=X$g5t4eWw9@?)w=a?1R4=)n)SVo_wp!5rVkz%ZB zlJa&&!br3e(1xni8nimMR69ZTe8xWoscI?{LzzBin{Ryi5{i~03Cdsb9%XjP56Tu) zKG~GUe=p*?3`}3MsA2drfOSKcilf#p>6RaDg zab{b%&AJD*TX}d`dXIi<$x6l5Uu=4lF;K>0T1b>sLPE%+D-zK?PJ2Y;n} z3A7k(nGWHq-sSz+o1*9lhwD15GbskV!0-GdJfecr-6fC97gUpqW;eL>y}SbY`Aa1$ zf2{|bkL%WuwnC}84}TE<$V`ZhyNIJ1=Le!BxmO=XH2!&w57ELQ1)yE-*W8Ynss*xY z7E{&Z?A7vEiXCg%V0c*brshr9N>M>%V|zcQDpb~k{5pB8b&TIt@r{t}`rJ(wVf*cm z=PoH6E)OtqYfEI6%8BYc`9a%rHQl(Lf9>?6dlu{zWxK3EJtpIPeyM5_TJEfKMfo;R z3DTMiA)O+jh$@k^>Li83?ZvP)_(0|o<;5zK_hZP<=wimUm0mlqTZc3HkP0WvVN0`f0VWsYfe?F|8 zpvkJrUb39#Tg?SH!@t7h-E^KJRLZ9CiS_3}Re_UtTE@7Ro2K5+@Ta&W%I_-Km9@IZhI}@na9!HEz zn75ts>JWpTKRm#fGQ9>ufNiN20!*4!@ucTod`@W)dCdT|5G5dL&yt{Ne*NNKl zOVq39syd+u^Dt~;rBFG1t~s_iRucg9<`3onXP$KK3hEle2!VwuR3N4 zKQLN(+@jlj)3M*;v#e{!kZCgye19ppKqnh8uC<(%fs7BX0M$zRC_V{EK^QoUYg z5q2sjn`R>d&JpA2qJ5wKfsC~J#=eG9^(pAbk-HXdqaA9BYNkjmvn}HrN2FGGA5~s+ z%&EH0j8u)27Wxg22bo>6O4=0&F4dHAUzEQk7;FzaW>H*Zjy9yTe;!2b5woh_+R87& zRV;BI@x_*IH`}y3_;Gp_EP@>AVbj*41!|4omA_MWmm|S2deI_gq<+il*Rf@&8D&>R zy_bgXUNqa5-dnznb~znDe5qpPdqk~_7^OFaCt%)yzFZjPMaNn0i5GJgD`2tuw*!1% z_=;ZynQI%txAL&rf5sg!EMBDY4A2U9n$H0OEr$kepk$MY4dWu(!(;7FBa$W(3qSb<8P!;h9kWw-^>Jv z_s=?>yhwsUG1ie#@f78o2ICcDW1fha!7H@9Z!OvjZ#vOhe^*})%yVnl^}y#$HC~g2 zQMx4ouFe9#VBnh-V>SOJCuVIE9MWv8_9F^St?6E=&E2JMUB1AQVo7m&yfKaxbW!an(( zAzjHP>-dsN@g8N097P971>f|Lj(!}I%{KOa7+@p^f0L&kr4xDZlPPK(wA>%DPX40&h;7HTRW#VAu=mtC#vpg2?1t;E$^gSJxu zEyC~9=80>%2CqnUK(x?myuaxc${#1>&d>LF49`H3>NhxR;wg)qSh-bGm@30J_K-f& zdxz>*f3~?+kMn%l>7YcmK&FQl!vkUzKRxwJ#+@LM-_4~u61;a<#}h)vUf2Pt+GDH~ zUROQJ>{53t#;R}EG{PQd5#r_bl&@vH6ZYW@egdd=>O7Q<@q)BGUwKhl*r;Q672OT5 zt=(@O4_ggM%9;9J*@EC{<5c)Eb5iIcpPOeie_X1fDihh_4yt8HoXT6i*rt<&DWOI% zaKrUmOs(=-={`cpsyshOo4Zss$#g!nIv5}GM1;SV zaF#le-pBk`$g5tm@-WpP*F9~FRp-f;X0G#wz1!Sx3)OH2F`}Umtq8LX$9@>a4~V~~ ze^wrn2TE3IMp?%ThVmm6WxH;!aMf({#ETjIQ4u$6e9;2MSYDJk}HM3y2J@cJId-=egmIl*V5=J(eZm$*M_k1WsdbCkqPe zOy62rrRysuPMzp@5c<@K>>=GF#yPm6e-ncVMGNRBq$}`4h5c9dU%??_YaPnOfLhFi zvV43){mR#}#<=>})Uq^vYw0FuI?bN&(NGwQTnUXj+PU;i$kD32RVmzRp|$ibZDWZ1 zsQse9swYw@6%=T{&`xONQvqMKpjPhBoTQTwhb5w;cIZcKPH62V*n}&u52|&ge{dFF zqS{`Bx~v;Q`%TZFY-+Ub)$Z`cQiV{r6!FdiCa&}gW>@JK;my!e)>HZg{TOBNLHGmN zCy0@-?d|(X;z#woV{*wRZc}v+^s(=FM!OTe6k)tcP}-hjK5|SB#@D^)b*RQ@MlmrN zy^JL5KC%8oL}pY-o4nhixWa7Wj&C%7)zEJ%!fk}R1!?G7$)+3fO8azAf3KSh$?|0= zHD!c03C|$HiwWtp$8>igYLvKF;&ZLi@vujEJNu44*BE4`lPu%c6%N;IgjVgZP%C|s z{mV#HIE|!!tG!sA2Yajs3A>2Zb7;r@6jTV(!r_j|6pJ-T2V_tbT*egad18xcC;4UC z56SF1+zH2nz5_++-saF^fBhDUFu22tst^ODilKpX)PUQx=Kk`Gw&RI4O% zW_fk9F`>HFkfdvK^%f2fthb)#UX8ln&n;RcGL-s%y8dz;M}_E(e=dhqr&l@_wSwZO zAGvmx_*a6zi}1I8h(@KHgk=2|*k95D73@1yrx+rfOfs|)K2iLhQK)yI_M`jd{pj`6 z_l8pQ-#~P2Z+ZpSCPj392J_0tqjZswA6wK4IiN~6)xBTl#`6$wD`zN9TFED#HIOkP zR$@R~mKAMxK6Fucf0r+o<^4*;bvp~buX~>`uKFU%_k}X4!teR5_Z#>ZoXc&kYJ&iA zr{KISQ!i$UeOoMl=8x$bjUOs23b)#l!H4MkecwkEITMTz@|rStBIQt0-D5G+IeRGX z3q673R>6(`x3QP~z!F!JV~#tq7A@-9T`^BMCd)^urg*c&e|2JpztNKvrQ=ijP$~s* zrWs1NyN@)~3ksAqtyvO8Nt3X@wvdNCbPYI*x#q&+3ReQ`Q;dZ()(vQPTu56Z*7(3N zQ_e^?p%her3^muyDjwG4|6bpkwX>$Xrn@{J-gTtNWBGCECSnbR*YK)#Zal>xW=S&p z90xL|f|H~}e_#>XI+7cn^ydnDW6JY28)g4gJ*t|D689v)!Hj{i%rjnJ!`_A_{ zzYwH>Sp)g@Vnqa_KKP#l6(3*35sY|^E5v!gT6d`8Rbv!m4N2TwJbpe^UsGSE>mAaOe+~88Z>hFP?OI<<_GH~s4jyZoXa`7yR_e8OBI37pd(WIz%x?I zg9)t*l6&vMHjA!&yfKcyK)&hH_s}MIR%jOEs7_Ru3C;Rmp_O=tn}$J`a;9>Iev7`h zcCBELSyhvWe^?skziS{#fm)c_4%M1Q$BbY+e+a6_8tN%}%9j^m$n&jL&dl9K{K^(x z));R}!S_t3rLgLK%b)44!6%r@?!??yVxKK)Y`*9J6ZR!=O`U1KXsg9)wYD9#^mEX! zwIX$S?R7@QUfNpQQ3EH-i6rqH&Vk^`0!dg8A;B07q9FtbQUbxPTE12*ty^nF+fS|1 ze~KtB9n@-35t(tPbVowvZlK{1L55eIB@{fw+}nm{~}^RnPa*;N$NFI_x66el_sddUAjV zIcplr7(`-eVrPjlMxo*a(AH=e>o!G5fAuM}{X6ig(6nHAr<~S_40VFE-sWOgG-yEafllf56p5 z#4jqUr`M6qqy>B$?Sh@`y}*y|BJhx|>!JfvPLVRxbtP$?f4cr#Tw?;Sc5i?tA7>d8 z+c1|<`Ii1^w%#zLu)q9psL`=cHIUI@1wu& z=>9auCWRW=du2~*B7=GdXSE~Be^hC^IvgyQE!lGx)Iv+!YtJN&11oZ$Z30+66pRu_ z$qK(GAJg~QOsWH{ME8Oz#?^(zn5&6-V!FB3S24$2sLn}Z6c#wEjGpuci*4el1r<$2@$f1eWGU8V-> zE_jfVp*_GTD!>cJ%&fGr^nLj6cf_jwj%K5Rl3~pNZybHsFqD$<2I_4p%s3LBUBYE+ zr`aPh&njP*DpS5il1mKkqP2V0?qL+BEf4F0{nnnI#$DuF%XDW<)R4rs#fwUPm|v^y z57x>(orgLm#xUL9IIDrwe;K0!Kbme~L?yYPUW_s_b*5^9sJ2beUMJTdD26*i7$cu;?R7wCp`){L*mEc*QZ&qq|Pcs467Kf1R(gnHjr@U-h2q zJ{&vb|75_o6#*n8;{v3H(yTO0ct=G|+ryEi2cB|3HoP_j(e;^2&exZLwM zus-^%fMm%RN8A^TeUwYG6n)NkVkDk|kCJ6tvlJIxNqS8)$^4bmNUCl!*xhp7T#SOy zO@4^xF4Z!&6##9?e-PU-%S@m0f9eV&%k7uIV!_%bC0>nbEL9SS0KanqcNl%6qI!_g zHga?+*a*zecHe`INF9Clr7}!+os{UVhYm7Fh>y*5&W5(xG|xCZhOu zN~tZILGtuziM}jp&|Q=!)5ZJ)Y<6AQCGcMgQ+cXNjIxZ(e|Ze_nNniyS7)xy>XisjKX;A)QO%N1@G{$VGR#zkSE<4p^Fxy zR?JFlbC-csnuEF5mP;bBj{A2j*A^c9tD8xqeoC5Q@mm5Lw^cF9{&HKw87Y6-n_F}yMut7 zQiIgi4HK%#9CjBK#v8zY8AmmP-|aKqsw$v5#5mPJ=enu_psp?2>q(7bCoHc>IX;t+UvOU5WE69pq~<`1~kJE!#JQtUy_LY z0KSJQ@FV6&$Y%i8Dkwj^O9Hg~u>R>l1V75~7HATnQT@}E?YhZab{cr^i~{VqF0lBo zA=1ClSv`{)R6BH)+M7~!#yYDcgCt|#CbioZu75bnm*_^Qn8Y@z+VORxlI$V}5z&G4 zg0(J1!xe$Pm*RDZwtDrqEecp!nQ3N?)y-*X$yvDo$k0t$oHc7OS$5&9;QZHtU;J1xe|cH%W#0wi_cI zCx3`dA;{Z^*_Gws3Xk}vG6q(b_@!hC{}xvLqcp{n1N0sCZSXC?hfsFst|(n(j1rZi zvgi+_MIHefsxbQ^aOg0Q+!&2qZc9MR33Z)o47pmgf?3DDE!C!|Bj0-)4Uu9)Mgvxv z<%V!WTqli@#Ft<)MlG9Xm|ePvNx{rv@PE%2kW#EgMUApFK|gy*8@Y=7N$Rra7{g7s zZ0?LQ{@FkaX~qnl>MoFZ@yq6^v*n}70oMubG}UPOzB*ht!TuWP=j(wMlvQgFLhBYY zU!}zn2lUhlJoo{O&}ve`uf)i^b+dwcY838-3U=HBc8y`*1}!G_05s1HK31wp(tj6k z^*yQdHex1G*pf`AEVLho#EfZF_PV#2gHseHRGkZ_} zwDvmah#oSab|~=9M`-IPa(&9Go+el;@}AnO!0(K?hz;9GW?{*o~N6 zZ02vzxl6>1dd84C6W3-ieOy9?>xR8-M|ufVP#NGvYTb3%+Nf3B*4)CpUKtECthc}+8$Q6zRIc7jhZ z3^A81O|H1K6zVOr)i@HY)_;p4;j5|L;)_{k7&|MWEKNVhFwY$eyuFyjk(-pvv=MaR zFzOyTv~HGC;ftwg!OGwPx}wGM1z5!qA`w=w5g?ty3{DDsVN&SW2Nbt%?Ov49`3G|b zIuxFC|2M+xsy_*@I~1xv8I{28E&8W{f0~s=1;t{FI#%_K{}QS5zkf&ZK|LHl1or)R z@b@6u3V$o%B9kNoR0NCHc?<^a#9%I6sI84gTE?-30J~;=ONBC6+x% zTZ|%OB3P(BLPnaI+U@-ctdTFFcebDFG1UQ(3|LW^A*s2yNTDqq&QZ`EFY7A5Lso)qsUoG;SZM_TY%%J|hnO{mq!@Z& z1>V&G?@860YvQPPDLQWq*9Yi93yfAH^875TMmQ zu#JgrfNGs-CRN2K@Mu=7eun)Ly%4=4brWhF(7cP1#$_6bDRm}&S3`h36`pN!7JME> zk_a}?D3Tg#?Av$XvMY{&9WNk;m*yG$)5a)@FRJGX9h|pS?YHb9E&NLT8n zhcOr6JWq;0%YRG_0)4aB|2^5v{{a!b%vMz^qtGstRz-Xuv+{B61mvji;hG5Up7s7~ z#jYZrQIs9VSbmbq4wPa_rBxi1WX|UD-RPMjRvcA@vMbc+i4>y>Z>Je*&*&zrF)G?e zcL-mC26)9V6xVS)r**&M22y;eUVELsi!zLSPVw^W+J7_Z+0zZ&UkICx|hKZRXX8Bvlsp5pn1cS|FvUi2*+4a?3Y3Il`2WR$aW}8?|q;(uMiSid+_Cy+& zV8yRxVqui2NH?AyS$oF$e~R6T5Wn8~H}!B`Hh)m_VZ>f2JY_tLZ8eV8{*B$VV%~}y z8OP{1?U#&E6)nc7s!G)auG*+fl^LsPO|hGO&E8dUgqoyGv$7VR)X^HOO-WAcWr%cu z)n2`HenReSM=aAIU#}Frv^)Yhr5WkoHkRp@RyC@?E@%r}VTTEw{Q4@pZZ18Nd~nc`Tr z-nd$fqdI_(ec~+i?SZDExE#&++*_D~ERP3zs5J}~BQ;Sq1D&s9X0Udu5Gt^12;w}U zj|HB$f_+=qsvFPV<31*{HM2?GvU%h^_vsO##+w(-y=3L4+vRSuv*6=bUYf#@z|vasryWF3`e{ z0vmHT_c?vv(iEx}wh~RjdGs`>(p!ot4OAfC0mS9i1>&U z2YRfL*~xTMvWk{a2#$ST{#>A)=?*oTz{)_+N-@Z4r({gGrUkt+dYyl|WrKeoIY2h| zp{!?2WG=uHiE13uGMgDZSlva*G@!A?Bnz*!rkqPl@$ABxW4hTLi9>+{BY$cpSvD{y zfe%NDF~INfIIE>TMEAqqsGG1ptA_Ng{c|1aaPdX8i@vNIpZ$8FiXFzU&s~CN;?oJw zWmElBt+}`0P90pf7^(V3yO1789?AN~6-=<$Trr6dQ|Z zfkm4tTC9Il#bbu6?>^U`dVf+k{@qa(-y5UK4qG-@rmgO@zNt(Dez_ccHTb?INhi=9 z#cs=VHZ!G=8mylYXcx9xHW;IrZtk(HKce1oHV5e7Dn#-KM93p*&)C}NA2~bX9!ShJOW52n}e5(_Ox3 z81cRS>FVLCR{2-(j7w6S)ZXM5$S(ShBnQ{2CIGFsv%65zvcu$Uxvl_hOSgAX?@IfE zbzldd3?8KKCU0jHsB-w`7BIEUIsNPS-#9vX zJ0j~NR|!+nQn>yO1%G`PWRa?>k{V1j!U_>ABi|^YA@`Ps2zHdS@cb%IdSYAdElUvS zJ*>)3&*fIb=nR#(x0}lrw(8xu`dU?x2K25QuK^hVybB8uc?!n<(R}DnZ|L z)6IzZhCA25l`)J)*s2W^U!|TmR%evKTs_gJ_woML?M%0_DAx&g@HnGFDS)M8co=*8 zi~Llul4n}SRe$Tjd+m0eh4CpdDqY9ygGHe0Ks(r(8^GQ@Laz(zl|}NsLIc+yV?G%T zBH3Y|e9=||$UtZnby+pet3eM6bM}+QAqI_VMPjFVh$}AVG5riy*2i0j(+GUB&Ztyp zqx{kkR+i9h?}Qa9JLO&bRO zQMzut{+TsViEWljc2?~fF~)Pc*u8Se+CA*1P<_P-dZeaB*{xMmlPYByX%vic(SFrm z!IDeEj7N;gMQLE~L<#SoPWBNS(oNoTY^Jakr5HSQB-#OZmUX1_8Z{|Y4_?KS4$i^R z9T>@pYk&Co*V4p0s4(Z`lyjDmDNm3&ju>UP|GcU-pr*ioH@#L9r#MzsSyfpx0An5a zVM2p&1rgK>22ibXH+{!zqSs~rgEWX!NmI>$n)uvX_DH6d|Gs9R`3%$G98CXcY0X`x z0=o}UF3Jay5o4rFdF9FLo6jfDV+KTA?h`0H(J*!7|zf#Es(&YaXMyV-4ldo|HgpM zH8B%Bl5QM>z85{xb+*`z$7v0YCR}~lI5E&3YSh4Jt2R+@m%N~vE!;G*o^8TbRz_99 z2!Fnf5uHXQX+d0F(vp@!TF_d7@ArT|j`!(X(2$+VH00Z5LnMR^XupNW-3c)!uRl^v zAfm4wc&&4=E5bj$*p2xj`Web1WfABYJm*TFT|FDxRkHYgs*GM&z_FQF?Nd7qD^m60%)|XtW4I7o1Ab(XQMJ}g0)Nk+X1bZ~McX}*?z);uHIt~pmTBaC?yZ`E zbXVeEq`bIJdY!vhHy3HkKV4abJ3eH$QJFCj{BW5VW7(jd9cV}Sv$`u)MtF7*NS1HZ z?Uv!f>%brD*?Z!Pq($gd5BKf0zNsEg4v6Qdr*O|fe3cwz?|FV->{g9qxm zcLm0#!ws#&Xrcp0EYRHDnRR6JLPVJd^zo@N_3I z; z!U~~No^8a4hGp(D-7v(Rb$?DaCZ~-xCc943m#gd&u82+Xyk}eCyo9^93BOvOP;%Mi zuUI3I@{2nEr@CRfXya(EP|n&rjid2JHS40mw}Q5kR7&P93(%fz6-RV)!C&Oji(K<5 z?xbPs;eRuDSUFT!`E&9%YPaexCf#_mD$d<&;T+kV*yz4BrKkzE4Grg(a?>MpcAo!pI%~oxHtg69(D#@T;^5II1x;{;M zLs7vz`FmoNb}IU-D1Ql+MYP5nx1yBRIGb^`-)yyvB)(iH_!yOl9&W!x3T*|FHe{0C zgJX5YJBZBld!&9Yhsw;Jv*;heS4k^){dCn~L?&O+Ka~g1MHBc)H4xV|$Q;wsOk?>8 z@KSko_}UPoIPq}SXa*pg%$xfh@X(C!jilz%O;oh%9bSdc)41s=e7 z6yn{gHYDE4>IHi>3OH-y+JlCnfiYE=sJ8^&>K{NB7CT~f*`D9q=6h2Nk)Z+9VDO-) zTJ5%QkU0WaLN~?fy1BU4jC;fMQL4kZggGc@Nvh}f;&gF3*-RFcN0Xc61JlL@t97rq zM$+rj#-bg@D1Qv;l%Le2zpcH_k8_2nF#XepbVgBBUvZR@1zHU0<)gvM38UUNTUSm? z{~h$|8V%A6kw8sj!D}DSRg()KzvG1|VP?Cfr~asU9O6mR^H)RHna@yTaL= zKaYV~&`u3|D-coe7|?&IZ9)~;Vv0d*go6W5eSdJZN)yRu8iuNIZ(Q@URk2*NmCdx; z(XLT;)0a_Kf=0+hx+d2Uvq7pMx7BnDq|GVJwAIW`l~K+9PmRgiX^vRFpRXPfQ(=r6 z@HoiGmOx8@M#O8-L%rl$pe1!?RY9;!H$L!p(hF2wOy*Ewg|{`&fS+@(qD7g8xOLhc zzkf!!&3P>0F1Z-InZcMOcvGCsNn(Izya`=E9ZTTqBqAd^ zT#a9%CJQa=xy|Z9OT$SWHIv%C_`kuz$;`Up*_J<%9#J#Ulir8pgDb5-Gu@aES2GEo zd4hMO#pJ5U0mh)qhE{AKH**H+2JvUOA%9EaG3!ttzv^vE>(VRauk!eSth!6tZJTJ1 z3?x+*P_wYg0<_;`8P4@by~K1UcFOnC>tH@Frlq^f>|JQvxyIm%Tk+E5NKZOFLc(e5 zNIPl^V1Al}=GI$nMx-`NlWHJ2N=o^^3n3w-&aTL_x%mU6Da))hIhqaQG$eHb=6@C; zE~FUgpKfKX24gbyHvJ}vuhxUDvpaVg)+)pbpNorGnWcdw0zcM@8GI2LkfaYp1bYew zJW^364)yYt! zgVWC-$5mnE7)bwT;7Nz1>QT2zJ#fV%Xv0Y#WE>*L9kIS+%qP^_VKrj!#=D@ z`Tq;w%Xg~J@{yw7-6Yw!R>I2LOML46M9%xAihlX>e#KZzF0xk{?YiPWFUF-mXBeZM${3Kou!Yo9B%WztcB=Oq6<%5h(Lc)B+Gmw{)ChUI zvRjNZTeJTW{93h&ybt_c5Pw_+SAL+1x8F34HH}T3X&8t08qyq_?#%Vlq=+nlk*wsV z0L^xRC6^j%Ea0-{vOAWE%f28BP@Wp@7jR-s@Q8LHW6(~MR(nQKlRO_do1L>Yr08nk z3dqaOzP&MWgZQ}3Xhr!ZWtjtG)Gm;S{WP;da@Uiub^;UH9Df5@(ysc3F({6LwHxL_ zJE>p71FBdzUKwT@Oa2_ZQnOJ`8_b5+g4cBaVHwE|qgt(h(@m&W>BjTd4LQ2sfoAzc znmM0#8gW1yJi6ZzjSzxQkkM|p9D_%06aZa`crTD#Gm}Nv+>jdtqB+UuuFhdh; zmzlXMNFive5r08F#`H3^X=9m&j0UjTevQ|;1b6%bPM~E4ctyV)KaAytU%YQH>m&}Z z^S!2*`OH|0vg|0iv}(3dP>2Z+=yjzT>TK|F_821x{Vx<<)g@Al$eyZ!AeoCvzJzZw zm+VNmi1?6*_n3@P@N-bis!4&fL-)I`j76Ab}Bri zPV4;1+^D zIE_`o!DjBO8TQ+Ej+b8aZ`8PhU%~E+Cv*7e{B({4?>e2!9j24ih`^Oq>Lo9O_57`W zpGb=8AAjEe0=WYIV5Z@FvN87p@am`LPszpd8J0U@Bzw=>3ik7=zKEt@AodpaNl)#a zM1?ObcLh*^kGvy)O*%7K+JpZV{I{sLvVU7~6w#ub&4CuoYokh>&WaY?0|(mh zB({N!t8+asp*oL)8QTZ;L#3!M8`N#*{kTf&cZoZs>iGOpK5i>^l zuz#_Z9jf@XC)r_U5#>$!bL!z-w(vT}w+XL%nV`OW24?b^t++Bz-+_6zF$(zmj!~J| zrfJblcFvZfLc+K_s=4BXIu?I-P7WmLqFracC`;K|JzupU+<@rjTk{EkFYce)%jpeV!b)nF@KDg zTkyD4*-t~Yx-P1RAl?V5EdB^}uGL1hGV7?ZF0AH(x%eMAVyV@+=fIcSKt2Hf=40|X zNVKoP%D4dc-$r(kZ$WnLAfJJ>tC!G!O*&W21+bNRKuV4$P4Md$xMDBCx@iksqHk?h zJxUZ|1zT?!P7t-c7xdTx|E5Hc>VNR?ZhL2k%301apaxfVFcI&hJru2fCsQAHzK_g6{fxgnN(cc`xJHRdZK-Q7(txY-NhcX7-Mz8(WEZTvESxK}!qiyNaB} zJ(^+E?xgYF2dYc?^HigAot~_k3mT$++!O7)uN$w6hEeUQDj}aGoO8v|^h1>59%!Wr z?r{o6@&?P{NLA>iQQ883O@A#{*Z$Y5se%L;v!s+3W)SwxmYO6$v>D(cV+AUYc&0?mzGjmXUa+{$+N-&!~|i z2T38wo;t8RdK?^9v!!-Z?~L)5d~#c1%J> zYQW0Zm~jRaf*$@giLTyy7UBcmxeUCNoY;X`y5v(h{ss9u zdk*OdMIoK@4rsp(tA7%cLn#}8bM{F+l_(l4AjEuXfp4El)YJo1fJjjv!ky~K@iliP z+pmXw9F`7$`w+)^$xhy{$bs)oKWnTcLKf^=@H^A`mWD!jV12llH?b}xZ)k!J35!@ zl2(&7w`QXlWf)_)8$99LOKj<{ke=KQ!~;Oz2E0g=O@Dnfu~!=BzRx`m(cqTAuh%8K z&qERtSS!%=&#OUofUZT<`yOcB&m~S5j8IqNmt=Ex^uzldkx*X|1N}3g2R3+LLxrjjfwEQqUb zbEGjk1b;1*vZB}>q|03gI+UQ*WQF zX8Xe|ZI=4e3mnyu8VxhGiyZc?4b>}h%8sIBbWR5OF(SLfcb`5QcoDqm@uWwY84B9F zz?WP`df0oZeCk-=eHg71(7O%fvegd#*$hwH41eSN4ak5NNqTRB7AH%R=L2{Kj?H%x zKK};!Xo<%*NZ!Y%@P9Mtxx?fn@ckLMu1`zU!#%gcDDDEjK0*Erqwo#%{~X-;GWVg> zpDv((oSRm7YC6!)MM*~8l;(2}MzUkQXQSKwN28+bu=j!MY^5y!UDbQ8G2Rl4AhhjN z&3`A&%XSq%LC%4G>4cd%B=N!5Ql%A;@i3PlXO!I%&9q3;aXrup>b>{j*G&>V)k%8q zkVFGFpna&Xy5P(miJcO)p|8>a{$U63E$&r8%WKa_cR++Z%r3hQ$38;DLTLLj_`CyG zmL+L}8gmyM-z7c$8~D9bIvcZrQB#|M)_*>SzM7!ThhX-%z_%ti)&q14_Cvx0xYs9e z>@XZdiFN|U`g^#p8IJYBQN*!JuiBu0IsG~06!2gh1Rcz46Fq|bw`5)Pz*9Fsudc!M zXp8KF`=6Ci?a*GoDrtjnfu7HhA7B*l`Nx2_{|s}o3;J{ku1V+~tiS6Ll^vEw?LlFUQI z|Eti7KIwcN_^bo(57&MuNtUZ{oV6KBrcOgg~2k4uhR+<&8U5Y8VH-60zk9J8?zDFA6>r!swCYJNB0m?f{wxD)P>`ac#9IF_tdMWTC zxy;rBoosQrge>(Ys<)954AKISBA3p0a(Bw6;!4xfd($^)u zbx5L^uO)5v#lt>h4WUH;bZGZAa=r*CWkoJLe*?}saA_~}Wdq#vq9hd&hkL(d(;Wip z{hYkd{AbQ%q=7$RTupIqn`&S|v1*ky$3LA>7|%P((SK79hu&?&IDgm$tEClH1Nl6- zKhR<;u(G&@j&(@EzDdQbHuY1uK85j8@-}BP_(%=535YU9>Ovv2Ro+Ja3L}su63m8` zyl@|*U!;yIXx8MnJT(V)DWtb;CxV-iZS7EV7?r)DjhXdY&xu@9Nt0$qY!DSt^49Wl6Dh&5`cFxvpc zA0xfsbsx8Es5r_M;x3?RV<<%5XYc8vH7#P4=9!8k&e{BFlI-4u(VS^1nCHV~XPNsd ztMATD@-?6Hy5O;5A1wCc#uC` z{v10PBktX0Sby`?|0$yos)?CVB%a5ZcwGA{f6hN0Bc;)cL_ZR9nyi0kGj)^oPYbV8 zGRq!HCaeJJEJxfaIO76($6lJWyUuz`N2rVWE@M;Mz0BC~A_iD~lm+ zR~YYimw%C)1}D&-HgzUHis&qRoU>tM{Zc&b1*Tjn>LMiXyBybAL}J;KI8?pgaG$t= zBiwAgv6?!J2+HLrjA5#Q`WYCDN^8{NWSbZhh@dZ9$8mWgv6}TWgstqwQt(jZ?TKy0 zZh9TYJYm#GUwuCCz%xxVF;ak)B@RX8Ps;|xoPY99FSH|CbYFxn^|sK-4uckT+a|#1 zcTqY|C&t1Ul{M%3V#P4BkklzHmTCGo==oNA?HTP$Rd(fDQUsU+b11E>*MzYu!1)~5 zyEe=q3cQNzJY1eU!g)K?82Gy}ij~!#kzz(ks?0QVtvmM?w%VAPUE%@?vf8DckUhbJ zx_`Ntx2cXz8%y7{?7^&6%p}U6$DdX)n6pNFn73+tA=J3EYiS47;icg_PrY6K9PY2` zpO&+}Nz{{EHAX!fa*}gNmthDcOKj6WZJ3QYYe-ihi5r*;)LneOaUvC_y>5&OJRmpw z;SPJdos0RFA^t|!_PzOoB+-PNETB(~WWt{Mk- zHPA6agK8DImdY~?+Wy|SmBWRQ_@c2IeO-OfZoSvsF}PG`JMPEW=P^kAD&L zZ|$==10{j}UQ%2z0Cc}DXJErb!g!!svl`kyVU;Tpk+Au7Wy$O z^?5{vr^fm>X{VW9(@ul-da}&gX$#&ddw_9TSObYEB3(#lsy1N-t?|z{3{_?#hia$g z3`9GCzD+)q>QhxZZ@V6^SSd!S+i|}&u}%GybsSJtP&>^qJJbmCvqM|R8-JK}1p~NO zR2WTY zk<_smIg2=Zr8^jJK+XMc;AN?XC0dx2-?%0fv!?em2005om!d4xvn!4i)oX@j&Gr4S z0G+?S=7Kx|{X5I>l$Fds)qnfRQq?L%e$j!)iPfTldSxEsAQ~rXr*f+;4VuX6-wO@$ zc5*dvC2&O(N!FJg#oFXpi_y|5zPNG@V!Z`dg`%|63OKz?9udsL7#<-+y1aCtA6OH; zMg?OqTeZ`igJG06FP{_`Lu=SK4EMv{N;sz*53|*4Y8GE42UM+Khktxb>JYlG(-{}jpMbwa0c ziM^|I2d*?*6jH=jue%H@#v4Z~=ebUB1I6iK%iQ^jSE>p#)&cs|T-Q>dCp^$TS@ES=LBmJL( z{#$4qP4P>+=!NPgjJx4aQ(@c?W`${E#Sx66^31gG&@vf)pMNBKPRp~2jRTr;Jy&r= zd!3Xx!~CCG?a(3xiI?g+gt$D=@nI;h>2=f-l&t6vh$yFSLQRTMR`f!8Avwi;4()9L z4VX#4rOd-x${5=RvZ6)K>fdmGX;j#z)Sg*$S2-6v2ASH=;NoV8W}17Ytw*5gXOv-z-LIE|9u{0hT7p54MVr%XT(P*x*+|%C)n@#He6O zMgwX0W#X!UH;%nW4VJeBe#DosRdXT#g~Y!lJkVTFU4K#ts7)%MXZ+vkk*fH`>ng?6 zb1*iVVz>5&+NGI~c^up_YpiK2@Wy!D_lKDX7gkuN8CN4-JCO@paSvY;CB`i75u*Y! z>M&L!Fop%5`)OapI1#L&2t*OUNGi$?5-AMiW-76j-p1Ot1?z-G|cpF)KQeIx(92VGJBc5fuw>5mR3W~zjBo^p8!V~BU^EA zW0?qC-U`PgR0aLZVvG`GFvkNV_&hC)N0Iyr@{iX;R&>srTn-sxl;c+ zXc4f*!4^G4eIk@Cn}>1m0h%9$wRtH&_bq6RFpM3u%%JZCS`6cY`+}k_I=Byx%YUe5 zE?d5r|2v}4F^a|itsX-8S9cfMs$JhpxfN}X4A&@gos4htGf2xbl%}4oK!oI64F1L49cRBW1XSqgU zCHJ5Uk?WxUCBV6((o!%3AwaL}1%JP>jyeW?jwt@fdC@eM`ovHy$a8<7n)OdJYv?=1 zaH@pFAp(Q=BK@Xst#J*|WrwP*u)k3mykxBA9nNO$G}XY0Bf?f;3V*%Wts$ndfykQM zYu&YHQe|E#BC_@j=4KR^<6rRld{Ui+R>GIhU<};mQ2i2hD$iX+UFX>apMO?!n}Lf) z5}&+X9`8DE?3f4wK%n5>7Lk>%MnM#FdJ(=CvXP9joTl*|y@IjxYHIJ*l zsieylf!UJ@=e?RNvtDLfBd0+&f8mNVM8e2X1s|yvdFhH1^0wR+sDF*+Y;lk(!3-nt z*SZR}lZ#n93yuWii4Q9r13k5aUrS*QI#&fxInCYysdbvZ51v9~pdI{6S~mjm1H5t8 z!A13mCTWb6?**@`o@_?iOpVq}Na$kk5h;h!=|nu1d>LXwx<-lwa{}pgTy{QK>}D&Y zNK#30DZQyPK}s}BnST$vfK!`TnbIV!)Af??^e>lY@Uf;D*fLv!qZ#|lW@;{AMh`iV zds)gMR3h%L7~^H=k;=Dd4bxrGqPd{CAVtN)NJ^g~g$8KgAwZ``0#^zK=-)`_(7!>{FngHwdV@L)Gf9I?$j6%H_BW(UoF&E)jb|cha7K^~@_z`7;rkVG>(BR5X35>?G3X0~ zFNGZDAK+`=5gLN}0=q9J%R%-EUxK#p)xTk#1y=Z8Qf!;x*+qJb{$QD%V5-`nxj>av zzN-4pG`D7eI2C+En}%>7Q1^Tz^>0*FGPU$=%>`qRYC^_tkcGQd-}xpnwd!_fry^wU z)W0D{fqyJ(Q8lRB9kIUBf&mE+%+{KC)py=Fb+|ao^*B?TdyCls{?Lo6fz=>`e9g-4 z@-Ni;17lL2XLiVGshUK$)yw~msilg+&i+9?pW1C{1x;~T-EIqFWmak|y~kIo-mjf% znO$HHJ*jFHI)hHc4kMl`fkhz{s`BkARb zNp&c$gP+z8+`ShwI&h^Q#^ggU&C`ow_}}Tlo`c`6nXS}r?nAt9ezlOJy(`V2CwNEo zp6hX#ku!yM@HgVIj)52%)K{D+7@(R!b&_kwiMdYWYI~>9kUAmPN$OP%*(>-W`bSr? z*MIZ~0_3l;9{+{3_!GY4|6n^xFZILE#gClZhu8QoT*mU`7jj*O9HQZ>q1Uu_n!eE% zB-aY<7$dB`j!2-f$9(%xtj=|IF%d4xPd zS@f{x&tY{t@K`VWwiV9U3N(u=+vmw1X@Awb0e26;*Xxpe@k69oiXz)Wz9ol%6Y7L1 z=)L3pF#i|ycr!*KFm-Un7V;VS8m``=EXpz)-^()NIr=y7FH;At_*fSrTMD(L3y+Xi ztSR6)p??GMk(oOE8{j*_=&ScDi}Y`>Z+JC^`}hkvB(;2tb{fp@DT!B*QxJXT(SH?D zM8_YHc*~Yv_{W-!eep?(=TrLS@3V|lhifiiloFip7CJFTNyq?C77=R-C0xNBx(W1% zpGVbrevhkbncHg5WEWGDs_aa$y$jc_%`ReMcj1%Bev;hxw3HtnMnp-dpnXsEowAGs zJ1N|CR@1l70{lu2K^tzQ{JYifqA2g^vTTr9+rdZJ7)>8Ac7 z{tY#XPKppl)L2~G_DKkcet)tJ|0_b=2aLk@0#;HcexQ@RAiI_)%dBtm>tU`cfs-}A zydyhb!Z8E=u9^-!g_)Oy!U}4Tlrv@Xe?x3#^EJ=7LjN{;@aIUKkLKo~E_|dWC%sNJ z-(eMWYQOtSkloY4c9_i$bi^t}kq|e=)0f_6K1nc%k#S7=wi zfEhe)8!@Q{^2<{B#GwvO%4>;x^ob4*J|*jCq$4N5RUs^4?DOHKM4!?in$zpd|_S9^Ixs`c0>$3GT65DVkoB1o)z9vmn z^*>3a7~?vLt6o3@?tgW&5c^o|*UYXxV`UxX)^W@ya-D0tZoDU4*h-INFOo|1)jZpZ zJ4Cg!8S}GUXMuw1DZb)Jf(a~Hxob@6ZE}$80bk&;M@CbYvZ^eH_!Q3|&q(-e!11my zX;gbL&dUAH0U62(ofU`VUx6)~T#!XzK3nSc-9mw&~!FL(!z ztduhNDht1@P=TjEFDV_gQ#fMH0zKDRXMuJ#CEQIqLB~9-?~E}=h<_?sVd5yD=xbmf zgRcx8>0B6R<-@8ED}*Z*d2$^ovD_iO?0ROWD&8_JrGFn{X94B!mE?Be&-ThNi>eSt z%J7>tBr-w1yOb6-6LT(WNbZ7;wTnLzt} zxdg@V7F?@1oqPuJxgBe?1@C~p^Xsvu;2wCNWJ*Wg@h3Ao={K1R zq_AcZaQov^PdKAceX5*?QTJJMy^Z+^qz#^mYpKcP5VY18 zpusz*b5{hefJR;`e5`+3vIFKybEYAm!+Q~R2J^&=HWj-qt%$k={P7YcqerMFfYk!m zo167d<4aCw{{vc950?7VfiaANcjT_XU4IpP4%u5XphU~%Sd!K@AR@WirQWa0cIM{Z z3S1Ey7Wd=~EZc1CF}qx6<*cLGcM9HX-6vU@&c#*NaLgLsk(`V9^2+YO82!`EW@9Ge z3qVh<*(1>csw&VGibVgqr4{#>!G^hLn-Tyk5k_dU{^e>jW5_Nkyj@iYJnbd%%zp*> zUecz$j%!KGXQU8hsoR*DKQBOA$AM4mmh!JJOFP1Kn8zn>{;$ z**v-ftr4)4x+obdD|Uk)ovCWGMrWi4XlHZafiVhKRjGTHrd%ghtR;2Q8tXfu#u~MQ zTd=z11@<0SUF@c2kd0tXF2THff`1XL^=m&!67j5(7ZQiE_pB^p9$<|J=q@P8!o4%Lqz zhd8s#=INp-UcKEv9V;4QW~TBlY;2$cQGdxtST!B9pmpObMDFumP zRh-CTRN*G2sS>1ofAaOZXG?Fp%cw+>#bsl*9HU^ z+iTsDUv#aw1T!V&d!4iC`+v$%@rOXY5vHYTtRuUZ&0H`QY*dgvp+-rje`4=4;vQc% zJwiK;|GWMu9G?%~{!6NtxE%cqc1PA0W+(qU;Uae&V)vSCAWbn`H6g;d_fc1;n9aLCV0q&*xr~BtCEq?{SgZ?yN1|+%e zP2q+(XCoEpq5x4quD^2z+OOg&IPT#Sw{cBcBh@T_k}Tv;VLp+3G=Jlo*5i?v&0ph0CrzLyo`uhr~|I+QX{t#cno}8tgkp9X1SgAd=o2 zh*OZ*mNC)NL=C1dgK@YH*MxsvVeU=Xv&2rUumSzM=Qv@EWDHClX{S#Gzg90MJ@lPa zULK)&24t>Y&oW8V!;&C*HS1HqtCqCmuu=juFQNItgQ2T2Z zC>LAJ);B$CvX@aKcs&a|&1MGglGC6QwuBnJDTw(3cK6>gLc^!9goG8&SEY5=YW7~L zY{5H$E2%P1xKThn9n8Hzgi6E*@=te{8Kaa%>OtCRQqH|1v5m{NvJw*YW%xhK7+!IN z9I_e$GICut!xQb=Ys`O?A|B2bUDdR3-4#bcVjnLtgpSMGaXtU1y$$Lyr4>B>gJghe zI$~@Edjb($HMRTrbx^b*i^<*PtN@nDB2e9h%w$RmLI48gCp)67=W zg;3+7qg-_`Pu>pW*qH0YSRRlP>%1DQLY`$7Q?=I<+pMozb|incRkS#pv&=Bgv)D}j zBl4MqUR17^fyO)JE-SrFO)`v;u$k^5YQO&JRGBfVFG8jE4D}Y54Yp{$a-Q!LMu6yE zNtNkm;JURiCGotlRTmw26@8&lqr45XC`qAFiL23?NX1L0nak#RzGQYLzhE4#&X&g~ z5A$TD#UaPlsL6lkO0j06rUYwa)?Q2HeWR*#5*{SU=pPk1LL=GBI=vQwM*4XHu8Gk_NoGLmb@SOcI0EjUGSje%+{iM!zW}5;`RE% z$aaiLRK-xO!k5Lt()XPgeS2}|sb-+=pQJ(cM{0y?46T1vt+IE5Z+nn@jR*+j8~r@2 zw5gq@oJU$gcdYVU7U(;)yl^j{M!R%oSnr^by6=xdj zGw98A*+xd-GC;gXM7CYa*v}Z)KTl zMio3J=(2W_t7$n>wVz*FLN-ZT;7Z7Dkiyrn`XbhIF8rP};BJ{}Q!rPOYlyA)KU9lH zN^fIEj4@d`&zS6pwM5KOSd271&UpWYqheHo_Kv`)H_X#T>IyaH=8KU`H@pqxG^3#3Lb;8V15uWFHM;S* zlL=Hf-gOpfP@HbeGz^un&N4%d7@JHDPI!R3dALi=eaoiXFZCg|^dYff+#TqYCjHai zI7EM{W!7L;7V>W&#uc^O!R3QoA}vyN%TB{xW0!Rt%n7d^u5RypiIIKrTVPvVvjg$p{S z$oQ?}Gv zGMX>I*`?RPv(8C6eV3FI)GNlgZR`T{yuo@ZK@A`mRUknu!}68nn)eOgTJlce_u%dK zFvZMXIqfZBy1~!wbzLD!p`pA5<4k`Xv7q5bs742_IARMp>o`wz*(EZED&e}BouECt zv&?ciaKj1eo_+>XgmK#DX6;>JMM;)z>`zt~+E7lXgzh1bVz8d$lV7Mk<8&rGps*s- zji6qu4n(-iLXGU;#G!IlBupacA-YuBUuG}j=;0@f)Ov`P-2o#f@ep!XMazG`c!KOB zH?`MMCnh{7915}>sEsT~9f8PF>^(~;=P#+UoPnU3qcX<^#&F$qv4^;2L4&dr)Dd4fv)HqS&KhY>Cr4fj!mJhuA=eHkR1s?W99DS>B%Ue;Iod_$I5Yf4t&=EXt-YU>)De>nKpDUVIr@ z>QpV2DWrX}JfTT=p5}jPQ?fK0P1__SHQfu@+NN}xE~pizFC(%DRMFO%0ft4PP(`Q0 z2$iMO5l~>LgA5escg{`K7GeJXPd=0^&vKu8&pr2?d(QcOJ*BUbi|~6(*q&_(?v9KW zW)5J!f>Go=i?$7n+mr})A~OZni3=cEAHytq7pwHBWi=M{BUyi6bqJpQJ@O|n=&Fot zTJz8c>q`%;@E_70>Tj?o5SH6A3E3uBj@wqN9gz zu1TV?t`^>Ae;kf%r@Pu6;G4J8%(K%pry_lbMPia#qJGW381)Rl0^0aKw6~kq+w_sQ z$XRI1$K+Fd7JPp)szqmEPNIDQB1|&vo|Lp(@;w+W(!4-r+ba8jY%tFEeC7XNuw`0h zspP}zSU5jG_Au9&c8q<1hdeqrIjlj%A@X5*HxtC@FrrX`w0(h^6`uY*xceTmo$^4W z;%>bHcW>UOd-inxz_T9{!!wI_2`>9|#95`4gBRhf-OzvPi(r=@L^;FwAj}~`eh)o% zh`eX+l0SfGc=iRB1p5c17BSaAx~$|VIUzN}+2uw7S2JdeQ3NZ4hxqDHH#J07Haf2J zq{|u`v0AC5hb-rIHpCIDbR|{?M7;22hW447Vw&pM*BZl{t zuF$s0gMv<;04q9iC9uoL9~cp4UD*lft0ZJdCjI6)yv^I?&0-Ff$tun{Jj|GyBc`b} zhiiWh7gZ6NJVD$oU1(2l+|1iB&jqui*=0j3V)9 zWtn!HooMEHh%!oFsJ>VB1g!nTnK)mOsu6#!k;cukE`I~rY<4sEYM!)D559_-Rw!>~ zti{iCslgI#Ma#uk#DTW~_d4xPR3+z+s5wfOW9=s#R|_lpLGbck3VpYfRc~^fLw^-x zD2j>VUHp3mi!oYH6fj3OAoqz;#C9M*0{GYyNvfhV#M0fsK~E2MUZXmXl!f={##Vnn zWL}S1GgzVED}lKtb^iuzlcDhw#m_zmc#%a1J|yyVl(ARBe$tUMOL=jH5I|G>ntk3yZQao&?KYqJQ9CwWUgvNTty08M>?^uZjgz%>9@)~FXlEO*L0 z!9Jb*0p{RBV&!(0&PRMy%NZH?*qDDsT|NUP(3?W~agUyq=~jS0IntGYNF9SP3uwFH zI{l$q|t(rkyOK^$Ujl5kfuF0Xnk!rJvi1Xc|57`ed~!ALHreNc!yf?zYU5!6N@D80db&%Vfy&W!O# z`Qx;`Y|hUrKL&PKuNjyXz$m5%i7{rS@|{vnKLL1+`@ zOe3uH21X7*qm~mH-T#*IBC1K3!?BBK)H?;F=k{m+@#(-nzC)X=kHGutAHP>pcE!Np z=PXBi$w_QOaDkHVbS+q$Q||cOcVu`2-Ht8uK|lKL(px2WW$5+Y6^DQ5r!xkR_26gx z=?LSHV|J42w5y?|?$cD7^`u<)AUydZn&(nR*D5h(o*Z09wB!dK;*txL9j_LCDUH-K z6%Q}^gcvwo@h#aC*~fi7vMzf(*QDJd)N`$}wRzwBnrfe+?4y3N2HKtpGL$D~X`4jw zJW25V63?G4&IoQ2GQ58pE>${ZYqiLHX_ZSGt`ZT`vSN>Fwm(Pyz)(&5A7Y|IvSl*I zk>RpuWow0hVsz=pO01!^SA#zdjvC*&r?YsGqL-cfCf~NO#8-(ArY6 z8Dyo8v}qg3qKr35O87vw2Wxb|9~=DxDwV8Fmq<)*H)V!`S%8008Dt`~7L!EldUm)! zwr)LHUMND2XUqsDW$>>%a<0&d`$yFFd&i~bMdtU}E3Vy*jmSZh(JY&x&cprBrsEao z@?x3M$dm#WXs6?V;{<=LIi7FjPls4sW8J4!vDO)(XFzuwKwI@ne)R)yvoJ2F4I`6a zbyD4yeOw=76l8yG?$b<{at&Q?Cd{DOJzR&4%N$8%|+8N&25Kp01eA-SD+q zr{vED^h zM_{hD=J59Vqd^-7BpFFwLWu(ZY=Su%NjQq zh)92Cp-9*pddz&Vq{qt*Xk`n%mq7J-WVD2zSph?JmvC3h0Y^_tt$~PrFerNNHNd?X z=>6N*C_l|_xm*8B>AJ4)1>lpBK|5LsJs06_#TMVblK+VJN8_w$YXwQlkTyCgE6Y!J zD5QvEgQY@2{IKq>q4`x}D&LE!ra*QV4(xwNAN^(M3YQtN@Cs(pJkcfailfi|YpbQf(Dv+50`-}@0^*=CTw^PoxEO!?Xz?vyobj|YGLKv;j0 zF-;gJel%km>4EbC`jGKqbC-1_v&z*$`k8f1JJ>8OAcZYh_Y4xgo*yeeqr8|uLfgj5 zm+q|3mW}W<>8>kh=Z{c)r+7%`PyM4Qev^Xwl+mu&ebxVK8I#lWA%yGVIF3ThFN0nU2x{o{0Ov)4~=V)By zqT&YI<9{&kdlPspvS+2qnkS2L{7dtyCs{T{L99<>RzG*DbR?|O%lL893W|S?-lvZp z7{N?jU6$$K$|CSB2FqB|&$QLgKM#@!_ZU(J*8Nal51GbOW%t1q@3uM(wcC9|Y{+za z9^%6ZFC%u+MRzp6j*~cJh&Xdx#-mJB$nBpjt?;IJnq;}mab)ev92b1O=BR6|J%)*@ z+LXJK(fLQH0o}_>DUi147xBbucY73%O^@9hsL9me)kd%D=K1aE6DmhB} zwK<{hNNMSps!@Ut`41@nTC26Y_DSAmz}nk|h>KR|tX%%GFY8+pj4-I{R$~r^{{wPL zml$vw1*$bfbcQd2`7YCjXrF>aDGT{w*%l_Q_?BMcdCVTK5ivcOL8E^xE8d}h1vxV5 zs7uuwgnIC6_c8(dbXq0)jkyc=ibz1ZOr5X1ICKQ^0?0T@))_jON&EL06G{q|Vbki5v!4Ya>5M+Dua!!8l(vGdIB>2Q7KrGG-~;bR01} zvn{2$=7U95Fcu1t>^Fy~d333cF0y%{Ux}1c)%7{RMC1iMGBPS7Zux8LDAsJXn4bT8+H zR#xwDcle5Mf7F}hiBjLMzOj5uNL2c&{c%`*7|jH zWf`Lzs~aom6rG6QoRQ5$Rkwp4#F$(o?qR0g3O$CI--t1mZ9#5a#D8$9L(b9_s$`}| zK0!4NcMpAEl1_Yjt(c^;*X5(MX4NG1{RR8VFR7j?{fB=%fn5grtQo6B#g(MBvC;Qs z^`iy*O8;S;zqE&wtSI+1Vtu@2j3){iyT}(@l#G#$z>-OQN67?ZiIP zPu9ig#(KNFUG9fM--!h4z+5pJ7g%nB6&OWIb+PTwkNor@W zS3e}a1pR+C2H6Gj?}dKQ=_fZWBcHLY@=>a%cw1dD)4|&i6B2C?z7-jJkZn@dEnUnu zqt#J#x^aK-?domnVcOMA$8%PIm0gPC#p!6p@gCCWy+zh}bWD%o5@?+ka+(<<>&E>_ zI8vdvsYfU}8yiU`6SO`pKd4=ek}Tgt`OE&Cn}C0;CGtdW>(U-`MtV1UMK4u!O3fJk zW6#k_v?#1KG>R0IZOAB6m)MD*VSCi~x}T9fQ95$PJ-GLUd)~@97_TqbQm{pQhPQd5 zan#OPP-H&^fK{Xjo=u%17CyMp1pA=1GiS+ofcaK2tSKL1=&c zZ5D51j;9&SbHqGp)1bB3gV9HLz82a`H1EEA7JJU6c6hiO+%B@&Wm!=!HSsq52R*+R zG1b+>*ae{_7AJ4Z-Wtwwso8UyC)soIJlTk>dz6Q>J=*=!8%0)mo^?fy477T!x?VNI zZ!;Z{PXH?%aU0KI6%}}@|3sd8rpJE|Yq?(AtO3ht$a<`o*kceyHYE4%Pcu;FFl4(H zYeb$Vatx&TEpm{gV$8Qet|?ZDGo~@^oQ@=cRb?f9>my(VDkD3X@Pwj*-K57nxeo2$ zi@3uI>ry}IM}%66^wWY&N-K6V0U4q+ws8u3iZp5f*&EIy=i$r}@E=l1lIedP;zvZ= zdJV<8I#2q*-uRlG1V0_{lE41hZfyjUX3~kzI!8Eb)a2FtagRca27*dCeYEJp-)3 z=}ixE5<_xbK$}B$qK6)mLvMdzrN>F_7Ecml?WSF2u2B?*_cD%>K1AMCmStw?XCk&i zrpUZUIXkRzpBCm8eL`gHInpIg)rcIIxSgs=4RW?ed8O)*uorCGeA$SK&0s}{Jdf41 zkfO>~`2+SCw8l#=kei4rMm{EQkj>;hij(-IdYI?)fR2r?-a%4pI>mp{@Viw9x|xYn zzw9}RI2@%b>?fGfO~d@kEm zX0$50={WYkm{FHm{=uFr%~effTlopZWSFnrrp*asJx4NHZ`wAp1+Ki8B!T26V?9&J z1!fZbp9x1KLEnF76Q6pMY=k`pF z40Hws?E8tebUX3tGjTr&b2sddtLwcf<_W~78yotkvkxS4n{@>f#~d$uHhh(IAtrXo z1$&J7kKqezib3Mi;OT0q1wPmY_q#htD*82)=k!Buo92H7&;aM*cPSnBLj81jn$!}B zHcNU#GO?x;t~Gck);FYD1NXOZPNR$z7HHvlLY#T zAz7MNOqjv_j23smbfDY%jiU13faLBal}mqNN>L;#havs}vF4bd^~s?51j2d};cRQv zBGSdaj~Rb~LXaX0xQLE=m#NA*_66auxSjAE23qMP0&6u%yHp#)mV?=-Kk%kezKq#6Q8AW-g4O3OI=5g|% zew1~%w_f_xHOpR2~u(WCq+O(Ghk=F(Muk&QD zq!C8+0ugY>nQ0Gwg;f{qUv!DeId1pztaSdzJBi-NGdHAfxgL?uoYf|6gEI@M3JOB|Pkxx(zq3eebcp`xbPc`l*eFHN6(rvJrog+#cLF0xKm+Ia~V?2bxWNfAyn;vTR5<6P45u z+=LZ@q)0O!?2Y1A-TY=?r8>BS z0iVbouiYYS#OP}X>w3qq&CT(vF3D2Cw#*E^j>qt)5sRLQb5+CrHz;Dj1O|V*neGps zh827dTAslr$Wp7C#*8l7=;bh{FTI=W);h_y5O|*YQJ`I*mEcnw;acEX)15S|aE|Eh zWLi&>O7%8=DyPx7B$7wDQU#3GNO$2ei;W zL|v!2w1$D0uwR!5QY>UYK$a9$>B3aI(0+tjD1udCgSA+L_4SIJS(+#58Ow#aFtUn) z^HT@(av@ghQB34yc+%8?YVlM&0_?Vdci>aY;fYgeR0>yfKl>frDTjZ?0|rN`lW0v} z(m;B2*<0ISO%BBfWTm{{J%F7sMS^JofDNmv}$w~B+ao{)u)r4?XCL$1<$eOHs z=r7f-`3TJOHqs4e>AV8MY=#C{S-{(^t52-1kQqV!9A7UZV4 z=R|aGZgz09xZ8UYB?j~$?g<-7wd}s&I(rP;8^|Hs;F|r4PWB3Dgx%^qQ+xgh<;5Y^ zINt4NO!sUrMzh&o`1OoG3i|XQQMlBy)T{%=X(;)UUx`y2QngRR>@NjxVQpP)-Jk1f z!)NPiao1P9A?<%^-s9_>_3$sh|fO(F0j~Hde zfJlSl==8Cf|3!xLwn`_vP&3csOz#$s>GG9wvO*e5F5`dRAEFK^;&@v~MBdX&4LqV$ ztPmWRLeWwS=8+*jQ+l_ID~)YBUh==F`CRJYCgdL1h%m!bKTB`pbYd~Pl79*F;jA+_ zoqiT03Twa$AC8>Gq@`jrB9@UPp%r?@a9c!Uke|2gFns=$>K+5t6g{d~CXSqel{rcbQuW>Cv?@ky;zOFe6Qnej-I>A?ByeZNznZWWRvM#^PlVXWS zyc01mZETvzeJ^G;BIylHopScdhk~!^p75pwUsr!`$REKq<&Pjq;pNtm?o|8Z!b#b) zvM!;Xi83UM*NIg%M_nC^j|8P!vQ!%{>vFi|9_TNHY$Ib6vt~E0U&<@uGiwT6pA1Aj zZqK|K{7*dOJ-A&NRsL zGRFlo2i7f|bwB!Dm6tuc?CILxv@d?LbQ@AFPTjvOPTwc0*}51aZF&%F+9KCcW~%IO zm6wTB`Xw8$oMWD#-r_o{{)6mPT|oAFaJPT_jHJ=8b{)moGt=IXB0u9FsZGeXm?tb1 z%g>0T(|XJkGNy4&npZNwU-IjeSCv;AN6X%BY;+`Y6#=Dpk;@R)7*5q34Zcs>(t5b> zZ`+j^NfL>*x}C@y?$ys!Z-963S=+15*N+U%{^5UL4>LMu6(aBjgt>5V#P`C@&c`W@tV&swXWu1QrSt{f&itN*m=IM~#2E^Nf2`(sviyRHi}ADG(6{6tr_23sd=8;skkBTmi>4epM;cr6~@rEOwFu*%q)6b+n$LjkGaw_84eKtt-KUxreiJ zwz$`<;h^6P5q~J$Nb#hC8ApGa`j5StQT~)HImDM zbDgqi4$i0AZmeYtzruXb{Twj}E^?x%%1*K^_66jEdL^u+etS%M_bQ&W!FjE? zA8{86w}CaYN0w?QFiwAqB03WH^kB{#2ljdfDsT_Zb^Ac7j#2yig>cKzlNBrj(TZfY1ChmYpqP zo^6)>iVV#@9rB4gKr==b5mops*y8gzWx=d)k1hseu9z5fiA;Z#b93e+4Jl2>)p^Ck zQ6tdm_UNHksVj~|?D7JNiK?e~5!i1jnkO@2-5usXl0KtIF%f!h0skJkj9D5M-j%?Q zE1!Xwc*qIQv>WGRF08LeaU+61h!Gq74d)M5C)yWC&Dw2T1ADGH-bfkHHP7b-IEj9i zq7#uIKq}h(Il_Oj@IG%qc@g7nIkQ61d4W*0tUI(pGhX&v@q|z`yHFL&E)@6Bc!mFm zIxT%BzfLg`#iq74snilG$yKD=*3eQKFZ_UJI$b@5< zcVwKec!7VDi22IP)~DHK)lAb0BB?s0pUhtqbcU%#f2#S2?h<_n7HnGyLrhpX>PmR| zy19`U@>YW-x0mS!yZIQoNSS6RpD*Zye)C!M7MqUajyiZQEwu8flw$28cT2x~58Xw% zNSPm6z(YAk`N54XHOf$qvkJP*e zS{-)**EggRYt0c-%Ot~fTSy<%&M$|1zX#gBR@+EEBVd(!Qe0|PEXGaD?~@i?oFkDL zCEi79O?iAPzZvABoq+sVhqIGF+OIJSnT4cMHY0@DkcN_`jA_Jg`;ZwWwP;sk491m! zvxR@Tn(M;+ApA$pdp;rWaFUu%a#7H+*X#SB-LGP#3RX>9>15fNNmPDH3hU_E=X$B2BQKB7)5#Sk1r(z~~T+W72;Q z5g~DO!R|=>2hp1_;uDEMaSFYJ#)l$No+X3hJhBn?*@lWpqz2`J9WoNNM%h!Qq57rTxgE-%YB8vD)YSSB7CqPcY zzfI&%w9*MV*v`|6m^XjCj-M#$%F%yE&XMiN7E#kPz#ei_sUV$T-6Lz&TLZaGKjb=j z2d!g%Sr_HgI1OV2|C^Crr<3xv971oCY0r4nkF2X%k@wOY@XOE)qV;rKko`ywcJoab z#hYXca^RqMz^lm~d0y`M>K%sPsHTy9<`?Puj9Os>Jjr>ALDomLMnA;@|H^-HNqqw( zpbR;QDI@BKWH;QSmHZ9fodC($L#1N(?K0>(N;y5=gBG2GD}#iwldK`jjy1(E-}FeB z7UYM}&uX|zcJX83Dn-zSo93^`a`B_$ZbPhgTj=+?vCQbD<2Cc-54aQch5Dkh>HIj= zG^xq*NNF!+3pz#KvQKv%&6$5iHv0m8WMNCyenc5QkeLOUfo=}*^HViXf**Sm^vs7j zrbtzv=1FOV|26QJ@OtMdKhkAd5hoCO1VDszbTSj&mz< z4>+;9-B&HUkLfWl16$*~DS#|7Ao=f-Z^%xVMXk_xUyzSLS0k%#8(Dv!8B0=et&U*q3R&zE;&U1B3DX3*+-CFs)b7RA*&)wI z^h$dNG~rF!J7rWOeh6*dM79oa%|*D_+6M0Y`vFFAjS#@C|5f2OVb|(e221YQ~j@B|glwQY9mjsrr6TRAVC% zsm7sA#{@l}G;Xe|0dFN&aRY3<=|xqlJW}bghxaieWcC1?;}9IzQL)L}rCn_;*5wO2 zvS{g|Y)fe?qAxH}7AIOPt^_8)o&(DPv^-j_S@#X>9G8F6RVxWvhHN_hbPsW_?pwNF zxYWNRi`Q&tyq0*WS@x{*;6p*Mm{p_mOjdpXmMgDKXaUB zqbCjQoTrw~q8a-y<7axW5?pDBi?}k!`FEHngD-#hX!t9Ov*C?MT>)u@K2LVL^&_=* zwxe{r?m7Jf;E&Td1Gh`{OUHHfFeXa(Sm{4teO>L}VUO2cb^pdAVVm>54?NJ&9GSW*{=C-&XqH*~b~LH!CDs@lbsq<~U@=_#gD7NX@!$y(zDK zlJ|dBt^do(v$HbOs> zqMQqu?X1qF@ymdrLNzYZZyEL#|C4qCWHJiwSc3aWcva<9I`YVA*6+CFNfhQXtB~Ot zB=!BOL$LZN9Od-7m=o?o$v}iyL|}o2 zE4|rIAV&$S2tO~&%GhBi%av7|w5vUzhf}S^APow#11v3&Lc{^jjLAE~F0;=?E+6q) zacZ{5_^>^N=|OzLY>Vt~TvjCeC#QeS9@C)aMMb$3x1&=dQqIw~aXLq$;W^2#I9)@E zc%333d$#6?m^F`6=*yV9%Gnl4SQMH-B2wKPv5N@o>y-bvrEa$}-v7fD-d(^s~YmVXikN zB-b_?rb@M#t&17I79BfTKV6Z?fj8W6!g`eX$QQ5^&66}1-V)x2ygT4isuA%CJls_D zqmA?Jb1`3(SqNU4&Q8>M!QFqsx1}p-eq4ao=E&$PiOMcU3jM@oo-DY;(Kut7Yba~l z{Y-pB)?7F3IUuCf9*Ja(_D@WgfePhuw-`8d-*}5_(_&7pRBPhHc#d!V0NJTW{r%TLEL}*+763zy&?>?lwbAIw6 zGCIKAYo*c5ZP=#eN@^)8;NNGY4UyF0T6@9j`V=E;Fh?(9U1H<~vcDXx=}iVhFgKvAHnk&O!F{AX8O;fX<_dEoiec4K|X6=uYT8vhaQrYYIBgCm;w=dwh zBpcy=O3bqP%qnC^D|VuP1{!8j#M8t|4ekEo;jr3VWTK3MB;QdE5{KIHc0cbWxJm@TN%GNaiZW{kdGUnsSxrZI8Z7U5WqN5I{H7QT($=zT;R1&^QJH&L}jNw z_7|L_sDhj;-5%-$eJBcbdO2ikBJ1%lb4^{Z99D0@$^n02oa-KvubD><+6j2^;0Ki* zPQNsOIE;~up`2}leX&R;P^9w8Xm*noBxz{Ay1tO+H4Nz!wwY}vWvXbY{Z9P{vh+MN zg&8efRW_YF;2Cb#d0G>?B>yE??0+xRQX%gpPnGpsYD=Jf7{ zI2y6!r4>wzyTkJlczGW)V^ou9UVBbxrFnw8BfXc?sglVB&GYs5$x@|G^VynC&;_4H zEwmHs(=YoF@r1n+LPnu}PQnj!9o5g$_G){Xy0jkqbXcoD#%liJTjYR!KUtUKQNO}O zsh)qbc002WqenSRY7VjLdggbup7ZDX8H?B+X|lSmykq4YX@&bKLF3&|geWCpU#qA3 zrMaK~ z#x-ePQWUw)B!Y2V{$nf?|M!0l z$u;-^S$)}$NbEmkQqY*DWa2Zcimau%X;)<<*hzo7Z%tXXVSlCgFL~dCzJ8)XO|6mFoXEb)CJXp92l$&nr89j40{2LJFw%?o}TvYz-#U~Oyhq=Jb#>j7iLYs(Ff&w*vrrpiL(0!{O>GS zg^v(DtlQGT`-rA2)hI-Bw#R!O&X`6qf8L;;ayDi)%3dcIJr9%1;%Ms(@-cW(&B{5( z`Mv)Oml*DDc9f#Jkk@r+1qVhF7H-P?m`?yehn^Vl(~?uPXhA zOO3oTQ42|5QB~+M-bPA=CqU+Qh^1i1&JAVQi7Ht*mfr1;#mWUc(N9NCEO~-n%T5Ao zEyJZQov)u2`i_&R>vdx-Iz&Q6rVx9EewKb#p3nNK^K8a1!~59l`ssg+P;U265vI_U zakW2Ay3(_qw`Dra?<1F+L+bdqR&Xe$U)PI(ZTQQi$cYg3Ucb))lGo39T%- zuym)p!^_pn(z`hwFY;{R*SU@wMWOH59&bwNtJ+@W>`FgVM=l_CHLUzc%o8x~OFkBZ z#g=W6E(WVGKD`@p?sR`+RZk%TD_EJ2gV!Fd-PYJ>cmt&RAZbxeQ=G!c0NG4Fc3*4! zB=lYR3}&HfX7!`!Ni^=~((MbR70TA;cvpgcr!>{RpyseNw(_#ITUtR{vMrVugL5hN z?5vtjM5Wcmt$57+lzb#JioC<-fG51sSH#kln!Q4?s@_#UjT(R2-BI!Dnoh;^P&C*I zzmuh!Te+?JLhzs8=PF*kk%`FKO~JYPR}~YrtIZh&yA{(>XLDN>)6E&oDAhEBRGpW0 zqF^y*uY~sn=Zd>Yd)9$aXLz4#nrfzDzG^mdsK$_>>IF;VPQ`5r_<>Y8toIShVyN zsg`V)IM6kq{FQDzMSAq2P zkkg)rFuum^0`K=A*q;ilMiL)_UVpQ3zxsZx3er81VHb`W=L=7uh3V~LMp?2k!y3`% zNWY;LW}OnQmDRW(xjEt8Uaa0Jl%v&PUe94HrpJ8tPIgTG2*&10VCvGl?WBA$Ru_g? z$tbKYXC{AnKDT&5FSVHGAWB}-@oWoT6)fww5eJq0S@k}6nqc3!)GjqiBu3j*(3MvG z&A=l$?c|I$N4|uBWEC6?$LF-O%TQ-k9U^-}kAYP&Xbl2uf6+kJi`R@*RIn1k`h17B zn%^&-TzOf{ll~$jPqmkAd?r&U0_*0#xJEP2+})dmE8p$K+IEwgh6b?79HawI(Z`ErfXMM zUe4z9Ne z$s1C@2HFnm$)bS>d$N}!;;OStHx+$C`b&Q&dldzXr4{lClKgCoNn=m($DuZ3y0Sh- zz8QK>3+ZpTdV6fkn;zkjtA0rHygJXM3q|Mo_Z;V^s%y3)kyX|4`#YvpBsqljD0)LG-)CtcMF(EjRI*km?nGmMD8=2ELC@hj{kUKpZ_|3ZDYv6^ahi>T~<)hVQ?Bv&qV6FN%e;YZVO&~2%i-T`} zFhS{JW^{V5cD3^x_NucNak9{Z%FlSM9&;SE+jyIOL2xd5Epm@F4SODD{-=%mOJ8l= zEUc?@>c0gKcCxG5+(o{uylfulSS_4(sYADNwt&U8l;m26+ZV7odFASr*>$9g5g{6L zdN;uKdGig`j4!CVuBW@Y9`ZORArALi;SX*UzfJ(;?jG~SJZjd zkrB*E`{VpDu(>{mYf(QyIa_Z-1~%nvc)DIiCvTIQGwj$m73Zymh-jv_c@Zt$YMkm- zFuqcq@}jhY(|MxQ8}v5`Tj_MEoiUmxacvJCa=7biO-ID6H^rN>HW6&Gua#wg0%#W1 zY^FUFLk@tw_jgX05u1N+D5J5Fl$!;(El1`_emk9@H3=bJD>aB*JBw&O0+qD;2VBgSBrSo zh#MHp{Exoopq6pJ2md}2d4G!_qs#4nA!eB%&IcmJl|?*6$5c|LnyHw`h}g@rje<^Q zlpjPt8o4F)lcB9q%qaP&P;}uaT?rFay50XeyG#*aqSSfp^|F&iRUW(iAlo61CQH0o z$Sf%}F~P7q{U1v3ImqXKCBwkiFqqp)hCw@bkxazP=9&rXe#$ssGu|HaJE>=jUd!pk zEbi+m=VXdtWj@PJV&XkE?epY9#W{G6A=xg)<4eEPJSn}wpUD&rLX;S^CZg8$JnSpt zN2sFxo9Q$AhGegmncuJPBkPgjkyw$b-MkJt1;T6Ls3n+9ZGI7d+23nYt2Xfo;Dw~h zN6PaurpdbeIZp7cGDRhy3McbNKv9GA+Xq~h6NhXTy$XQ|SCbi}{Oq_y*9s_GSGi;aMfcbZp^vRbvd--30 z%wMFDzuvNw{I%SF?6Q-dPr#!&q(~gtvAWnC59{6qm?I+j9(AUCq~j7%$P*O-Pf}%{ zI-eXY`3C&iB3eFkiUk$BA->q zmOX2p<2mXm^vt}AwXuZz1X{I)>weORF<<`_?P`#_6JW=G!}{#8|J2L+>4Vqv#zymG zkOPh=xUDd1Ye;JDPG}uN$~5EsyRbs7M#i)=V+@~2oqk(rrTIm1k>_FMoVr>^IY`Yn z#IG3-dhkl=_R^6wd-YCj`zdR=n(oSqr8m%0p+3!CayGc=4tslp+Q{1BUFRMB`BXLevc(q@U|CWeh}_yzU;Fk@FM5^4X4!ggyluvzmTJj z0%mkgXT`5!CHcL2m^vTpTwl(kdlBU|o#q~rl(A!AXXA&vB`mqZ3v1=I`~-!YuTg$ z{2h?2f?3G@2(vY5$UGjLomxgr>}Aa-{-xTs(BouL_VMCd@+ZaX%w72-1eU!#Sl_dk z#rJ@JzA=$Dik~y+m%0Ekc@imWSQ2|#)lpY#NXE)h+27dj%w32aPBt*B5NAqu-%u1G z{jB0!`dNsfPOSdd9G48w@nZ?=Qe(v)*90E2pw1V5Eoo$Y{tpV$w7u+i$~nr}vQ%L% zwDW#zF%t#%dJYk*h@$wGdV~B)*|TBrd^1IV#kYvyxa910xLpadzu8pIUfozk^JA}I z_K_-Dn`57CdQ8<(d@Fwh*sqUcgxb7Ed`6m_ZQ)zN-grjVB_A2;G%ESip|6~ME(z&J zhH38Kx!L-WF11*~+>0xKY9>4fu4F0p>GtXAUk+JYW5J(vIe#HF;2xGxoZbx@>R{-9 z3}Fl9^2B->L7ueE$arxQvea=&o~M{rnwvJolv3ZCs~SVcf#x}sv=8&GWr6}vXcr@WF?tR$Axjs@rIO!;o{Uv%(>}j z6v{c)QHJNZHb;5YA+Y!dXRjLxe;1L4e}U# zL;4Uykp%pe=rwTbnRd`~=gEbtv)LAkWm=XOKo%at$~L+ZgnH0=nQ+!F{LSBgLB263 zV%A1c6=NGR&;HX4yaTEL^Z{i-1L-SqB@_?${K8IZjz$n~X&vcfAe+JBTgdl`j5r>G zHkIsGb+y|01&bM*E>RXQ9P_5Ie+hku_&XUE{bbK4;Z+!MKpaB74RLPeLAJyF3@0&) z%yW>_JvV`LiO;waY<}=NXMnzcNo|hLjaARAb2`d>0pW>y+1gFoZB56O!+b@Cg}klY zqSB^!R~^#VBicOX(KN?X)OQ*|K&*`B_?pAn9{Yk~AK7HHV)Z4T0Dm{bs@bI=nt7OK zk9*&W@5rY=Tw&nsERa@%-{vkU-l1&_?$&%t`fb)?UkE&%VqdWjysEQ*Ajx|hhp!w) zz78&WZRKk(BR4v^C}Vjd?eJG8fR%?f{yDH z8w%xgFL(l_tFxGU22hfJ%I>)K4Azc=vW2}V%BwVM_G@IKB|Aa$uO6~4M$WzC-gM|I z&|?v{&7t|5KhNj9En09Fj>_APD{8y_8?epKv-YZScibWA$NB)>R*H{jy$ze~_7)BO zEZ{nk@g~fogGP)~mVs4af@{!RYIR)%S8^bNvFNt-DuPgGBm#4PO`azXkW}eHwz=uS zrU!)})d7XXXi9;#RTO+zV8d?axcvjwG$x8&*c=a5F8Hykr*c-f)Y@%ezezDC9hnhW zMV?qUR#)N~lkvJltKDYGDpR^UJfG`I(5K_FNG75~YyYU3*SOg{&Q)zXQA%^;RgK(M z{d5od{u?SUr`;-lUu>9fC(4UWW63wZfIidQ>P_*-sh`$7U-WE|WaUHhk)VJ7EE%Q# zF2t&bp`Ql6)B?PQso8Sreu8WLsqOWb@K{EidXbu{Lh$B8(P_qt)eQm+Okb z+gbsu(C#5{k6zrqCBtNO|CPgvUH ziLx)iYLWClvK03T1d3i{xCH)ctZ8bth3Q~KOfdIY9juO8Rd`=|uaX!=Ym)S{^iuvb zvIme)G4Gjwd6Jz>M680DVz?yylf5eLHcwW+i+hr?8LF9e>%*(C#k#TbAmSW>mOh0$ znvI(=7e=<$^SS%YhB(jXVSg6yQd?&z;&2B-yUjY4?Lp)n@Nl+QUe>wMH#JPHIZRrF zDcKftFVn6|%rdCUqzk>7n&e47-c_)FSoM^Aq|}sc!5tpNPvULRR)5Cp zcFIYmmxlN8wwg}xk)oJMp=j}$qK$S^bwrqgZ4{;yh{76|`juXJQ0FGAaJ6LG5g*ol zI@D>(QV{bTI|0A!^Rkm=m&vjaYto_bZLW1y*EzM@vex2XS2f!V;t{T z8bW4&R?}4GcSJxQm`XpQ5fxP_I_(RXDESUccJMV*mZa585yL_+MruL%)8YNr4)qPa zR5k*vsPm+ayAj?ez9f6r@`Ov$*eD#62XS`=Bmwc3*`|rS4eXN^+ymon@XZG0MNYzR z#C={)BKZ|F8e>w*E0|xvw97`=`X%9*=V4Bv5lMc9{v)E(WIp1~&m3pYaQ5YH<~KI(m##uf138xjn>I(h&Je5I zQ*$!CyCIdeku8#UebsCa=!NYWv0#bNh!}ZW`!s(o+z4LStyg*jV{1j`vjy8h!Zf9S z+sUWF*GuP{bfK@XQo>zJPFY_q{@>#3;O`7X(0H5bf3j}aPsqAJk1S!*YR?#+^Y0L| zRh#VbMnNB=zTfQ5ecfIY$f-Kyk;vN8d%@CaA@8hRmNk>Si(E~?50I@%TonAmuM0g> zazQg*`#dwrlO)@yVNLJI))w^(bF0pOk^|%eO&u|4UI?+47c(}NIicUS>;D1%z{ljM zcayVK<8mEuI03fnC(HxhK*8?P|0c&&qsZUDFFVQUWFPoS%*$jm$c6k7m90Y1kj(i= zOK2(C(6lTgTO6&OAADE2#1db(-o$3cILCemGCzE+@dPud~s3f3dqs$q(T+?xUGQEvG=Q+(ROgo{T*|=Xkmb)QKrR+bg=2o^@F|nvZ z2}=j2*&W%M*I3OX7LR z0;>sXY|T98T792#PU(9gwsATE4TXC&1H3HL>zvNB%UQZuOLl~D2zP1Gb|yC~mn%-GlC|})_Fc#Lvnzp#QcbJrl#c@Y_B4&S z?nW(R-;Wk8?)e!-{?8N>6%)Znfj%ItXA0uqD8_mBH>hEM#6_WKRUWQ?_WhM-5JO0O zre<;0(?(IY#hap-NUh{Qkp9(`MnSeVxX~ZycIzb-o54R=0`@>xLtOZ#J)R8DwuHXZ zC3?FW_v4P4ww`nrRpFkjkb?FE_ys|%mQzd&u^0)|#aRn+=bV7VlrMH{wOLoplIO9V z(7sA?o@r-)+PM?<1=?+zdAQzz#btmeyP!%oWvixnj>0#!_+$|jbp9HyEy(|&-KN*- zUr`YDDp{hus2PuWQ*_5>lkfy$QGz73v)2_QysvB+(_@b*-ENwiV-j@ywGiw6mn(t2 zq8rPMa{o*7yjIMJyj`ZO2(~2ja4h+|xlJ)q-9rw4HN3&;geMd)5M$9s-=OMD2wmX@;p($qKjq?>TArYISezY{!19Q@QOQ|5;>O6Z)<|E{o zemZGQyT!j`-bLC}Gf0aGGXXxtyiR4SUdvw*^Xw$SWu72A=S?BmMOAqLI|jzKsa^Q= zUWIml8>=AS!00AnWta}V>dQ6wBg zE5xPFnZ?^8?;7_jKq{*a>8^+U{>PRO)j<>mgpRqWVb3l7lsHUxbPIVE-3dUqI&VKOP zy2%#s2uayxkP>)iZY$d(K4hAzh(T=nNPb$=aia+1C)#Z_siE)Gr#PMJso>i%qFXqL zX)5LuC|jMqq%wjunqeo)BXKm$WJ77oSKIWu^=p#Ur@+U2NjXfIA`j{dxoY$K+SQnU z_h*`_9Hxrp-)k5l4}$foGmitWO=O#DpI%g@nMZc{cM&VvH%3wE_AGBGI+95yKWG%W zQ>$YsNA>}XOE(?Im^ApsnM7J0tIkvZL6wa2lf7QF(X~6Y0U7VW)|w1YDN#&hUB=31A&Xb6IO& zGG+fi#@+?KsrvjMFDR@91VIO^e*ISFlxyX|v2k-%Sz$ohb8>RhCgG$xO-hnBw_ejU zDQVN2q-olw_S>`t6lMKQnV>*_CtBEs3{kOKWv+l=g<85nk;|xKe6hIy^PJS#qVE5F z<<;hPa?a;`F3;`rJny%JxV+AbYm1R_MT|_Bj}qho^E~K)M%QPxgfD`9rI>3wYTFJ& zX+3Cpj?NRUc08jOiVD;)m%`ulfR*VMQa#mwH#!` zqC^?8j%QSH4evX_xJirm6E+mTK^Ym0Og+{c1uAtrdNlb>E}X~2L9)ks8rS{{+%y=n z=IieFA3;xhi3aC(h{qX4Yw1VYvxd9>)1C_Uu0D4bdWVJNld@V}GwS;n(efD1mV(#d zD30uL_%wUIRL8a(+OZdZ4x+`?o3a{x@>kGmBizB?+Fha8(1Wl}J9R{Ld6|TKz@Z0P z^&i+U5^-jF!DG!1otL7_#ZZo(Ku!26dl_59Ip;`KloF;2$|S0#%90`ihXr~1Y^G0r z5q2^Ar7E5w=%*Yk?9tEh^$QIojbDIz#ZOA>a3yp=PFg?Pn_~rkm3ON}RDm+uHAZ(o zmuvH&*Eu7Eew|``gyYDc#7{3#I_IdS8J60n_-@fIHWRdMS3Jk&!@CXdg}THOrb(Ll z{CXNciYS)WY37^f(41tVT!U%-{v@Uo=V+98qRACDFsR#=(YmFZmY{F)Ipwpu2AK&c zucmM}-8#+moE)@&IM6??F6C}|$^tXhi>aojx~9oh8*s+yig3N&1T|;~wO5eWy{CO0 zTQ=F%&)pQ;N!R$h!-lkeoxZ-y+^mciYeGB|#o21F5bH8tO{yB_ufndfXhH7jFlIul-6EFx{VW_3F3>&!cuCg&plnlb^7 z*Ivn77JgHI8C`*XXrZV6UKpxzX>-f7#W+?=d#{@LdHZ09TdNI)x1g+AkL_NN)`R1> zLVMjA=jqg5SHb$3#$~uVF7ne=(=uln9@eJlnp?(er{EmO)is3;6bDlF3eRNjW@^}2 zv^aQ_Q_t51n*N_TuXusP=@-kbY4X7(@t&5`rj?$5Pf+(Qa4z?hDf3%i%)C>o_Z|e4 znm8LTAs5&F;bM!PDY%|avt8KZbx{ve{YQhaDS=$NIiq@1Xj%pITr?#zV9(2Z0RM8n1 zdVo1p_yrTCoubn_EyOFUeLZyE(}{EXyrYMIYF)7<;x4SuY-eX4%nm0qvDATS-gr7(|S;{h=Bfl_)Xm; zV=KzmPE!FBg?jH0*_+&2(`4baZ9DDy+76&}#nnUnisgSNxnTVZj>QV?DynuX`++up zx5niCfHKRaU9c|VqI3e<8QY)>Ev1agwfKzdv3O6`hQs-|h?;du1ej^-?v zz>*aje~a@q7q8Ms`Rmxm4vPN>CKY;mISU%PB-{Z!8%5AmkY$(0SSG?*Hny-NbRNg* z!OY#93$<}6Gpl?CbeIa_PQs zcJ=D?!IxT(XpD|=c^AyIdfJ(D!cAsrSszM4y`u-E@$1?r%=7pg=&A0nu5r%6Imf|= ze>RWD1KsuaW1FR_tJ*8i9w1I4HkPYWFK%*qI(21C8{2F5Gx55y%tZd0Zfqck{@QeT zL5)c>8|8VGZEEO2PbV?4D)%~~A-UNA9mZEk(q$}E?nOCT%EqGqzCy|vDZ%Rwz!zEG z5U-h?daGbJ*-*M>oMET=8Jvw*5rPG*fA=3UcAytAWcw_1K694y2+F2+nEix4R=&)A z47xS5v%Dm$-~xKLv;BP5fB6rY=a8Ig3US5{zTIjrPtaiM5 zajB#3rNFb$GVE86%_n(;f!LbZ3gGe@m9q%6X2ltlm(?9tPkDe$|(Q4Gp=qO|0J|A z@ocO;5gNI**7vu(jNbS}Qye@W_M(PCYfHTtedrFV?4tOlu+JHXYfUt=P)gpPZ=A&6 z`jO@l+fkHEdYfE$xrlf}kGdbTe~4LjHWpq}P2;!u#xeWT{!VL1HLb~~Zr98vrfkaM z3NEQYD>x8u>!wwsyPug!x&$qnr(AKG+2woSqFb(OCP_~bNwk;RP)d9N+apXs4PC`+ zsSc6muX(}Ne#b2B^@jJ<&9u&qyM;6Sxj;N|SE8*jLRwG-5)<>x{|1*xe;MR5W}}ZZI)vJwm-dDfm0IyXEwbv;?zXD|_|;S^_H!vWzj$9>6wp6)v(S6mx~< z;Ise3HMzXGs54@?wb)jwe~y0#I&2-L_&|J?o$$qNQ(&d>alVs!6FrP=<=N0iY|7%8 z>OS$F!k^^S5#t#f8#b6rojLqJopZeMMj5d5Yx>k0Fg(o0;tIY92Qzo)cwta5Wh|^; z3diNG#t!zNZ(RN+rZ24@Wee4?o`JVQv4MlOsl>UIW*V$`WD%5X2Y1Gil=chaF6Msky&S`(I`kDAM$~f_j!>yHG z)ih$zMa!58P_<&Ue;~&dGbeLdh}Tu1j%w39g8F0+F^~)ULY2ndP%EI$wY5W_YG>gl z$3oj;)D)izXTpzSpL|p{x8+5?4;o2cg_bf+=*upK?NZMVQ6wBkS=M^Qc94l`I7WIE zTe{pV_b26=g_~v3e5d!6W}ai5#u#DBMTs$%xk9Lc7U4)LxfUk>o!d;^mso|-Ne=UD*7(y4`kUTo?nXFaT3FK4+Mmp#(o%LwdUrs z=+s;4MIk;EYre1bNZ}^(-<`{Om1Z`igc$Tqh~v-w4G&`=lZu?K9GxcbCqeOVA3_)pA>@?e~K;ZiS4^lV0>vk#@$WZg`3uc zOgwYVwzRs`$yHrw-ANWI6C>VZzMpxQnP7SdM`)blEB zZs85n$F+fq;=Er~x4U&uC+hO6&Y4SaRZireeCB^`-M*hvgpZ$r8e}eK^&S(paaAc> zQ*Sj7f7ZQ^Jv!ii3~k-jVo-6vV*J;rro>|mD&10&2W%|WLPwbQ(7FI|N%>!?0!rhB zM5@t;(g0zUt%fp*pKA@uJgbyLl&Jrsl*v7ec*{)3XN|-^RGx0MtsF+cO{^}XBf=io zfJc4)Y%>JHk&54sBxG4Rzz4I17Ivrc>c>z!2LX)nq{>-k}-R>!&C>ly^yO?}U78^I>8_E8T%-Ll3&-kwTPF zfA#;wSwUQw>va{_nn<-*HORt+P@k<-Y@y1qEN4(}n^L-?ered?O@iHGLd#<*TQ}@g z9@5Mu?)Ik_qx_vnaUVytZE^8hv{)9QcIwooXwRyz*6%8M6t!nElnW+j9Irs{JX1N< zzJkzPyyulud8KJ(mOT_3I!_~7HlUdvf7mOSYVHe|jDO(O%1O$*sNzbvY%SndWR;7- zj2DeLhP$<6xi!3k?+jm+vs+dXnnBB%3_me8rVc8OI*pvMoEW$B4Km$)saARjIx=Sw zl11wrvTZUSgTsPp^F7eR@-_GAZWi4u9?tN?M*)+74|dGvldeme+1jxMcM$hDfAsnG zDtj~hf@x#2vNsgPjxpT`8@M?3PcY;ugfqq!@Ud2>Tk5!nVmuNv9H(BaNEQ$C(-oW0 ze(RB<3Q^yfxr`XK6=zrhRS88j%!&Oi%q4_v3H zRB%Ao?e@BqBye2_2@tou2m{|VzJ{XX@(=#PHtPT;4* z(Sq@|4hg;NdWf%h7hbAg>irS=K62C>52m4=2o4s#2&q#3Bg!=_ZL1DrZw+j0p;}jz zw(kfx^Zo>{NSHfA5?<0pe+lj6ES|Mj!aUiD_i_>6r(~Uk*VGqv^Xbpb(f{mw(WANm zM^W4ChMjnoenP5|7_HZEHvvaAwGaK3c(*CVdYfk5z|V%&JY|nf2}O66xxIqY$;V- zrzpB>+pF89DAsH6I^ha2@y5rk25i|bCf@!eY;xOGpuNt+mo`nmc z2l?sBLoM;bJ~kH5f3-ts2`Pmny@Y$lf=fb>qWfD8=$QFqIem(lwjqojIVWtz;-mKayl*!XPsJY0* zwC-#k6i;a8Q!Su)!gtPgAT&moFPh*aIEvq}9nfBPq^3>guNv-#Hbq`|gHA7+NDt<% z!Jf@*9u(dLe?I%(;A@^o^4#8K#E(evR}D+N1Z3SqiZzLiH6AIf)J$Ra8~e=*{3^|l zHUAY_$3%IZu#O!gWY}hyuE8sH@4{ZDoAM;#9Yr^DjdX^29lVdS{p|pFMQS71?{9iq?yx5Rc7D9e}PMrvU*p8^1CuAzv(^Q{Dz)} zF1ty+9=(xOwE>Had&>5Es*ROm`foy4d0yyz)z8%H>uA49Wb9D(dQai_ zT$HNsK14mR6g8{^HTDjiL3)UY8tE`sgQOj-tRoK8EM^CALxaOTQvD>B0 zt}MrWf3UHs5qq(s;uFvm><%u`{21QVP4dnt7*Cat%zl$c8N-OQ7bxWti4^6MFsVfN zB=|e`W7Z7kB4e}WzXY_zb+0l}XeH!RB$-*o#NhG!h5AsJ@(_B7F-%nGLDg*CYZ9mV zCCxnbVgnBsJXe%cjk~$3Ks;4(R{uHlPhCD~e+b2|_~TTAQ!w6|Aw@ffni@k76nX?x z`VsS&hGxaj*&cXbT|pRuo{45omv6XRkSi047VC;^B7eio*4n@C)Kg1q59N{MR_Q1jj^?$kEx?zCn_TBRRmQA*Z&LesI z(tnLM@Fe^kS8~z4p(t0si1v8kf2-89BCm{Y+75$?ZnVq3Ec28R%X4P&0%@HLvwjB$ zn7fGao2^mg5e^sA?TRxNaG8ZS46^W-if%)IBt^k^;*(W%?qklhp=xhQax&-Mfb9oz00^&BqPKf-t*QB&e#$Snbm!PT6n?q1>;BQm${-99DmN` zn(3`a#3^u?U%^Zi+6pU!`r_wH+lpn7VY-2O^>?T*H=sAS&Rkk%RZb1@-cx1KWzh=3 zxXIV@EouMV6`!~Bx0a!O7SSr2P|7gRETJK@D9^sXs52uDt1U%+r)1|K8hY? z3}GDw#asxY!w`iM7yDM&7T9UrM1Nb8#AMA(kQY!^5bDnWl%@5{Kj3b%e8G6LT=R$` znNX70WXXq5bDKE|D(JY+5vRHn%+&z$r;4!_PdqZd4Z-NHoWe-(a< z=>#*bw+gC7;8$R~2^+A3<#82ULThbt>PnvS*E{KZ|0nQDD3-qx{;c*&#(x*YL}7h3 zELUGs{fZDtD{W};Y%y*!-2lCFIdH|PsC_IF!^#>78KinR7nbyIq}OiaX}GNyS4$`w z-_A*{9!9Tz3P+;SeGD!0p$#arQz=7#G&V`L0;HGEZEX}8-qBWtT8me5Gs zWi>nH+eef-6y4w^4jEMqYJa6;()cPQ)|GE8pwaI}*g3Ww2=JfzZh21?di=auZtFIG z$@Y2*6&XfC!y0*YvXAtrg(&klIj4iT4{(gB{Yj977H+B6S@#m!tQo>S+X2g5#m|i& zFnz>J=3Js)O!W=+73s50lNBGcy;g%>=7@pk1JS}h(>>;W)-2SK-G5nj@gF{2Ad0Cr z<|un98t06wbrm-oAKzx+uLvghF`J0`WHq3N3jVaehTnAbF#E%Y%vfp zhW-g^lz%fRE3|wMWy820^IoGryFbL&UP-$w|0T0EeKz5G3-Z)k>GL2-dp3PGWjDd+ z%9th}O2&A2MVl+!q{>mC}H1e zc`@}?jY-#>W5vFI8TvQA0Ed|<&L|q7tKhFN#Eii?{6`qnJOX-Yhvoz!f>o|1FWo#x zHO+R^$w8?zZu0>AHpDBEAye_OGfDS?v4ih3E)2fiaIEkI1b^y(&-W1$9(y@+UJ;@2 z6JOhh`hE5D3U)I~h0W@V;edH7A&yd(4q6|(G{0hIx)U-M!c&1L;454GFR7jgJpdmD zqEh>EHH2Y_D`h<^&%Bd~qTLwEB_3%jqIbPo+z4mUKK({2rK8uA^c|M@N@aA`f6*>4 zJ~qQE=D4SGp#q+K2hhkIiq`3ID+RWY7V&K_>)IRSx_%+49 z!snfH_8SnZrp5-v`t`zQ zX8-MDYLF?T4YG_6JY`_9uW-g?-y41of5Ed_$jn&VknEg8d@?0UZz6wO{9)l~wiGJL z^UQHlEgaQj2EC`k=S?^-gbYV1`o%+vW=m{K{@h>(NzEwwx2H&Nw`VE16iHSe$Tzuzc9b# zY?0h5yOy#JO_RlT&Is?qOVTcMo1;fCsiskXQf&%)J>w!sFKmyLW56*JihCU6HlIYR zF(+R9A%8A^p2pbnBE?XdRmIDKOESk=59%ti-p=~iwpg3Xy;fc7ikESy6&6zco4UDm zXZTv?o!VUS1h+A@k78xz|IPH(ULk3c+NV8B8D;J_+zFIz)!JHJs%|GNl&A*+@gW{M z9NDeoC|}hv7uwOryhodxd8c_nOT0PPHJ90_6(N7jf;QWByyIr#7N#sRySC*;?R6MO zc~kg&AovD<17&iYXtK_t-6d@QldGj;D0ZzD5NdtKYE9?QgMUe->jxDXouU5F{Vv1LW#VP<;%SNabj zTl^WbRFX8~gl(yPOdnh{{eU^AeIoQA>TAU)4gWoVm7yqyEa+voDSHdXHyi_=onA7;EdJ!JA2NIo0zHx+W zuU^#DsEcPN$_o_9mU&R3%+yGBQN|Yy#}uEjT0h@Zv-uvhN&>cSWpn_4?fhd?qZmYK z>+s!wa^6Hqm=A-_FMPKk(YzIXxygjK2YhY2?l+t7QBCtEg;D=|Cc^uHgZd1iU9rX1 zO>0?@*U#H{!)ammE4I{q#?^Aago_m}!;wfWCS70fr&LnaX8xvV8!77Yi2_krMF!D@V*Fz}5o7@&x%WDTu<4m|76am)?H64SA+f_Abq=EE8DKIenQ zYt@UH{~; zULM%XOgF4`#tCZT(5C%9&Aj{?ZxpQ4tRdtp^Z-r}(h|16&31rTvzev15*B!p(QkN7 zc}>_V=Fl3XTu!jm-)owL@<>+qQpG3XH=BHHK3dmNgn4SXyF>{!ToHNfx@LP8u#sAO zW_oo!)0x(vW%p-j9wDSMK~6O>nJ*B3x`J~Fd4I zrg&vg84MewEa3~Nha8YdmXEQYzqa`vb2P0#Z!UU{GC{7x*68=T6CA$Q38=59Ip?HJ z7Ub&1R2d1hwkyo{gN$;zLS2O6>0H9Z*e90ODG!l+_jH=KdN-PaciZY5@!Hit94(YEBT(K}NNjfc)K8_F?J}v> zd$sh;LJ9LFXdL&c09+&ScAyY{J~q#nuozfr|7WB#OjuE&TizMy+h0;& zlz%`7@vb;-J=+@^1AXYRE|j+_4^fQ7Qz*29-ta`IE2VGC%Xpn}&_{g2I362dFWT3q zaymAst2d|5=GLZNhF}Vd9y#67dc2ZFst-2Z7UwD^s|UR^J$dTJ4rh*kZ3^?HaanaA zx6$Vc6*2n@pMsA=MH&CE!B+PfbJFKBeF6FqpM5XW4QUyN;Um-)D<~_I=?)zCH2Pe4 zrne!}8%uE!!;w%{P#@eG+?nTwOp#~y>k1@x-*0>ds=dsVe_-oqD9Zi0w0F|xeSkPo zv^vEGF#!%6TVVj#V+Ra>7+cYQ2}+#fpTqmm39q}COIZ8I@hGEE{b|Fu|A>o zKVV*9*WyY$A?)L4h)>t{)V<5A1QQ!u_yrs_CZJuj67N2OeesUOPH`5ko$0BAn&|@J zWUN$8kx&NP;YG)PLiD+I`Nj#`@sopmA6J#uFY+0C36B*j(XUSVo`^72janjg)DS_d ztN=|*k`#AzNb7_U30OU`QP#s1W`9}_TFv|j`!SN`tb)Jtea8cPWZbV zNxX`Qw{<{&qv7``LH<)DesqsiXy#F7VY;*SO88CmOy5MmYQMkRE$51|?37W+5t~oM z51~F5hj$s+VGbqyBPQ$2W&E~^j|hd2iKiX;hA!K7@{8y{RfC84Alk)zAMMaIZC7*~ zwl=(H+fMm(Xa!v_i+0SS${DksjkTL-FU#B<9)SLT(jA`8=I2ls$e_*GpO*z4swYb8 ziq321qZIDUEMxzHYc8jutD#GHnI%7va{^vJTQ{F_Y^my1(amoQ{S)PK9NK~Tj=5-8 zRd;>k`7mW)kyMo`Q7|)2>gwQ{=?M*()Uo~?U88oI%_N)A=ifZDdqPhh| za)@_-E*B0u(5El-__~-H^CBk7FSs8g%N4E2{?ax2R45?1=8{$5;Nf9K{=?ncXL z?OB|eL4!fV~Fd^S(okV$XSYnpyL|J`UVt$BlKlCYo z59Qqlzvha{m+9sU`;>?5E|RtlHW(;g&1$)M+&nm(eJ}L$S7A305@MfjA?PcAfmTat z(4t5(47%dj%XlwsIqw(-^RoOIIoas7T*B{%;7#;A|J@f)Svey~RG*9LHrRLJQ|;Nj zeTwl>tMOjT4L<8>^8)w~{f@5G)9S^4EmuT?uHM$ITDf^LTr5L-jp^iXfMP?1BAI`( za8r}dkqX4RM7ZqxQA&14WTgBj@&d8alPn$j_tl>R@PH0P$JL)BnqVx7YKC z@(_;cVU3ja-aNR4X?RaJNjHf&)F4xkSC=t0f{DE3)N2hrOlNtX_`8-fnX}vmtBJ6& zZAZ~YJV0DvsQ(7wD8BkFj?XSBoBM*q!_fgB;ivDwZtV`m40RSUZt>T|d+-WNs1A&g z@!ObHisaz4yh^HnXk+?pN3-mIWOY(q3ywrA`L#MdN?MCLOL&>0E7_IKxDc^= znr7<|4u&30>oFBN<{B@ELG4+`T&fVXwQJ_1B>EhNw(M#iB+WYlyIdt<{6ylak*j_e zs`=Ng8*J#p9#+F9)IKNhRldZ;<=%K4<$N!m=R#>4Atu|7;z$kY;^6|ejsu7DkJwZB zWks;d9OIc-cZ=UFgYR959M*Telv^Me}33t9b&X7um;PI&dFV~0jMie${uz!dHhc$y1@$Dgdua6WS$2{=+!`sr;(`=w=OmtY z+F_7Mo^&E-M31x7`e%Hn0>1wD)+`<1cY?%RzfQ{ON*w09PnIIwWy8{%SVmR&S0m+r zDWp$138Tt1%xi*w(nPWWR1#aS3X&uXJi-@2{NR#A!ta&VF2dz%QA_A}w?_d|aO|_N zk5#~;7d}M$8H#S{8&zJG?gb{^IY*HP?W`7OjS4+ABesV)XELn@{? zHq%~8=nmUT2q>0HRB=D}LwB&T8^2U6W%`QOGVyr4z#n)1lzh#WvFOQ8#5S@(>=!g6 zp2nUb-k%iUopX!}X@>~{uJ1r>mqw*~_*np}Qu0=@*Kkgt^&*X{R@QQcWWI@T!W`0$ zRWAe#TiHLMuN;tOYlhX})C}+I51$+L(gZeE8O>jR72d>OCQ8>>WBQjZ9qli9%ZtI) zQe7j>=M>Oqoz%*P=N;t&l6{I-s$46*Vg)&|*xD9L-=s*t8-c!<)8Xlayo_IDqmOL= za`v*II#c4quFP$;pM1fUlEmILrM+XIQE4yQ%R<5Cg#2YN9wnq%HXyT3MoXVQ2& zt+Qw@TMb|lf0*_qR0?mB?^pOm=nlfvcun{Vu-q`&D=je>a|mX2dQ$Pc0-DRz}*Sj1H|D zo_nk`HvZ{0o7fYzgDbhSxL$d(Szfv&+Wm~Qkt$3PrG|C9I^c$R=BDFT9 zuoCA~l3$u5Atk&lF}HQ2SMvr+gg&&^4`Pd6f5O(}e`~cRo7bXEt&%cIWf@zj&nUO8 z>H%;qZGWJceJi*{w;6tU0zms9@L=DmofXD%fqN)p-uirpNr3t@_8*#V*Lx)C2S=b<>E>l zK7ozIwD&n$zsDrTPU?S4o;j34eXg0;)QD{=Ap~#bT}_R}YjKoFtBA^}qT4yAYycd^ z3-oc`M94$SQIkPqJ^-IuPoqRMK`~v$fAs{mL&?*QQtDA-KlmDsacc;P zl5`TzX~nQ!Bng9B*Y$)Lgq8ZZ>UQ&+#cQFk+2EYxU5PrmJ!3mX9>LKv6=$*ue|1ly z)VC#guhdp*b>Q|2-ry1%E9vu~bOgn3f~faWbidKZiHC8{QPpq{$goB9{UAx!inaK^ zQAKzE=@#WvR{9Q9II~gLqrN+a$K#dhJ-+LZ-Z|hBTE{Yri1UNaV@4Yc?*P`g?KlHf zlt(J;18X1(63eq&lS17;{$c3bqskRyR8Sp7yF)~}MDEaL; z^8#=s+kxZmfOcIo`bKL|Zhap%u4$AHDM+iLM8YAh7@_${h6U(uxAxO&!cVP|?-$YE zyXY>oGS4G82Ja9flkNrhL=y%FXRPc56@LXBW$hVST?MWYZ28j_60_NdeP_`;)o8rt1LcDQPUY6#^R1xl6l77D?pM735V2{6K5hJ;J zrflNBQ*>l?61E{;@l~cDvIx9b(rWlq_q~t#l4G-K7eB41A`eN~GVU8&LM5tyEk1H++wMKsH)+JJga@ zTD%A4_-;w#8c`#Ejx)7H`dx*!IJm?dO(?z0$-+wIAS8{S&0-;e_R8N%znr> z{fp^CO++|Qdk6swdYCp`-%1>VOi-fDME;5%A1IGJo%o*midv4d82h;tL?&KUqx(ff z3*(GUl%!2AX|;?Nx)y4@h+RvW6^VF;B-E&TOq1~{>sr2Ir{W5#lG;R=gE^3|mFdPB z`*DWSl{OMGuarj?>0O6}e;2+>S|7Xc-KS7U$C+M^JWKh7f%^SyZ0e_Irx05se(F~_ zmqUrR9qphLwwEd)YIDHkn7jETKI1rKj4`(6?V~HC^->HSTfZAplrgmbB5cbl=c<@< zZe3{=WzbNxiE3YIKb$#4s84AQOg;t!S^X#3hMc7 zp+~vZ>h|UdlyNtze?3FALxdV{$h}r>4EMQ@xsNp*6E>&yX!2>7I(<-^TjTO>mUiez z_lyR0-blR|nNj)?QPJ{c8 zcgwsr_%@U)It((iKK%$Y~;BEbs`e%)+q=@VYt`PGa z&t&eV=8^h)nQG3)4hp8SXxe}9onVz*46+jhdD?&9og5>gwUAl4wtNpGqrHtLA9SHD+nF}m)}DE)$yK^T@dLN6@Ur3u zf~oq?+FU2sYFZCr4j3NC^ZnM5DxMHclnG#(wE3hs zlZjD&+Z$UA#~gF{b2gM_>@$TWnY%Uf?GIJ`On05t^6T>iu?$q@af*+XhbZT}M9KCr zqI1#4d>DV?GN~E}RQkBqBYA?SGsL&dtPN<}9jSQj*KnMVme$>-be&Q!RFXNf&1PH}>V za)V`Xk>3Va>fSYe!2HrYhmKcdpk*}(4&D5gnTiawO@`F%`upJdP-WfwN-yYzeQ4Lc zL)d?Dq2HMPCET=a*Hl~UQ_tQ_92tN1#1SiOjHm2*0X_pRB` z)abo4^D)@z{gHDK>f4j`T_|@%%Yu4COP3pD?+^CEtJKqYQ=MbAH};D>#sPt)Yu*`8|b!X9ZJQ zzj{%@_)?vHSzfb%J+OotbK44m@O#y!g zuIO$UDj3gC2ho|+)M#2stjCHK=6TJA;sxO?!e;KT!oI+ah-8U8v}cVul4f>DIOBua z_qyU(Epy$UWZdK_G~MuLhTqao(Vm40w4rWa8^mUHn6Q{bMKw9f-s&)Vi0jY?%62Ri zlUi0VOXlsA%sc9~2(!H8^cb|uqUc-k~sG?^xQ_vnhy8oQ{P z#`dC5C0a!9188UT5wfvuM%sRxsGY)Dl`)lj9X(8ZF=`CmQs?rNt=K1H(1zMTId!FV z*aJ%_YnQ))^KV9|OMQ_L>l%N$m?%wo@>m|$2*E4 zNz90rWv#9B%!q_cXPV52=I9OTP?u#HO3M>ZFE$&QKB}vc5b9z~)x>{B#aR^sNl?W$ zrc*qTWoKlB%%+)F9*0sX=!_#KI2s}Ez1CS48R~>Ox6ZOmv6OI5Je|Z*O4ujP2bul0 z#l%0TEAw;)Uu@`NwOlUkJPRhFnp)P-W!{R?`);Sju@KrqW72-$KBk#%Y(=eb3_i@f z6TR5C2v12u9UIKcQU-sOhir@4gE?MvF7q^1wewH96UtwA#-RpFb}qMFWulC`1-Wf8 zWm{{fU=Iz34dP*vZ}t0~pcqdXv09mn7=tFKO(r%xyOw&zouG`-UN`s*vJDk}L4L|F zkk-@Ys@HQj70C_nnVT6|^AD)fgz`2OA9GHRM`+=k^e1nH*BgJjh_#DpN}Eg-P(@>% z;8(F)^?GG=eho8`^1mD2!?n}ZdPKcG#D~rkFQj%A(}Z)OseYalT!RhoS!CFz9@UWc z^|YSqQs3UXDs8T#C-oK+Z`Y;`hIm3z%*nPbzD>)F<_zw1ClE(D=&4pbU_w2gEk2EF zdOLcrl>O6zo-BXuTOVh6O+E}V`<2lJ6d&joOv;t0^O{s$84H6;P;+cI-`DV7rdDj% zKF^GSzR}lFJe0pF?J|Bw73*`9lbRY!#xU2?XG6XB&+MOy*J`iReogV(ltsGv=ws;( zvck({DHJyXUUR?~BrG~bGL$z@&`$|T{0+n&s`;0vGg5!cZvBgSLGz$LDSbA#MiVgK zRru7FReY!QQAM6_Z=T!dlH|M&^-Ley5p9&cr@jc!YXaU=@HXD(yM$U6xC9rKy|{`G z((Hi?zP-cs%R}r`#dFGDxPa?0Uz3lLa0gT~`{nOv+1)x_!L!XY?zc-vZ(_=w=xKf( zM|ALn04INZ&B>~aX8G^gyDe{W!LNybMvA#BMp>sjQJ36Se_C3_bBZX=Cgo4h!5Msp zIKqW(6`u%laV9)PQV-XUymhB&a`ZTQyixi!;t7+d{$Be-%A=b3#Nf#6_a@cfk1HAf z&=-!<%qL!ERhK!MY6R)C@SDmQJRhD%u>)mN4I6)}na%d1t#*icIs6n#i72Y_(~S@Q z4t3Y(zz`N6H$Xh=j-JeA%mn-2IiqGavlAT5M02j|vu!I>U8=6MKe%-bU3QmF&)+C@ zz-q%2W}|8j+b6ti?3ePP_(=R6HDN$PFLS7%I?QU_Uly+1P*F%22fT1bo9&$Aj6?Z8 zrwkb7t$9ZHGa5bkobR$diR0U0>j=aLU-aFVY{?ZP2~i-3XN`}WvUQi3$rT)bVs38T znUigi(R!vxAY4%H#Wj6BY{;^soPWgdu+?Pn!7iNR4&w@V1OA#W%gb`i&AjaKfC_(g z7Ipjz#Y1pWxNLjL_F3U&Cde;`w$eYKmzc@lz$?G$PGDjr49w-Q2CeBGgop(JT?Mz6 z_PVv#DeINcB%)Sld5y0SV>YvYU-219Z*Y*bPTA*-^Cq>NX|Q-YYkMI_FflucDHvAQ zxco^5Y`d{T^9Wk!>$B(k55WMuRJgLx<4@9#EygSO_M%;U9liB7%6bn(X|LmIoMn7m zd8pv8{F8(!6x@+zuX{<}Dwqn!`^G4?gbjgbMMF>@-V!hvTQ~kqc*ebd7O(axyqLGI zJX+DME3kD?MAQB#91e{E*0(qG8|9>e7_=DAqwW1XdW;ur2jC?^&JruifcqF5tC$O~ zb8==Pd?1(_6wHL2?3@MUS>!B$!`PzFu~)8#(zVxd1teFvLLTi7{;D&MDazvz<@FuN|pI~*{FGC9raG- zPm=Gnb(bV?Mz(kKd?j5~yq4s1@!HKN@rp^(P6b5}xZ5gxZlCFY>~O|FBxA8!s_|i^ zSo}yn41c%}j8O8ej0%%o zgWeLZsXpZ)p`KsgCIEkfIWBYTLM1^WphyR=R#!$)oe z)mwU%TbdWH5=`DJ#3j(#+DbbJswb*mvMf_yWMpamI4){@P!w>eOx}9LtwW3H zT`l^i+)dkJWehXHxEt-!rJ0whdItun?uRmT1iAh9=qswgYLQtp!e83`rb)sXxL7|A zEz=s#32iE9YGm5%Z>if2KGL)3J<9_#Eu!j7el;_HQQb^A`k@DirvoMPYfKcOzoR}F zjQXW&TH2@HU7BL8{bzOpsZ5Gj@aUSK=G&*0D5eqXs(8tX!Q{Ciyv?_koJr9Dog zw8M5gs>gqNHG5FfI;*_^%?j}k3L|R*kN^Re>HyKQL+*qLqYe z?%Pqz|CDuIg1;&pe!ea1lyb2RzXvw>oFvtM1|{hx3|G=6ju?I$IkkTE-O*pege8Qa68l zvLO_^trnk6ut5=3dnIg;va@fm5?>9w@fa2R7;4s7SQ&`QcoA5Qmm(DafOPo9Av52Y%|usXWeh)gs<3A_I~cBb{%{W+}^YuQZmf-#|W3kwh}$_(N}s+ zvMKw}7b^Q!JbLuIA-jl5c_9?GC08UiY=+PuuYkGHS~)3>5B2;tA;09kMMoEX85yk6ONK~ixz9I zI{`ZI$O_w()>g5@)gE}x->rLpjqPncVrw-`vL~cFy-sbrH!*0jZD)IJSK+Pd(q|7i zd?^dzsr2VelkJ1HqqYOepkthVuRTk-*R-pRH@Sc5Q z^Po_#na{bL%bknR#}~J)DBoksR;>*2v^&rCnzAF0CYK`FlwEWlJ*x>qRa!qSFCMqE#H%xSz1T9qzu|cQNPsXQ`WP8KdI_mmR&VXI~G@a zl{?|-#Hw@FjL?{7Lv>!*;ObW|GB3#b(%3KIV0RD-Hgv;VHLm)3gq_OW)XfjQ?oLn! z)fcHwf$gCPNOeuP3N_ev-B_w#C|;|K)=dI4`j!&5LhTiHs-W_mrI@A>ZA0`2hpbuJ zgr-I~25q(N&K1OeuB#XirOjUw#sz;3@BdZntI)T3VDmjFF^0_1I1`5mA>rANBUO1Y zh%06W1W|_E(IdY) zzZw#mnf!EbV&Un+mGXwbQy%5UUC6w5K@PKKuZE@)QQw*;Poe!P2 zn}{z6uX7`9a%(GL2Qm9~MO1CfOvF)XZytnlyB4j7u1F;|ak&s1OnG6!9WcNThGL0p zU6JhlfH*OKu$QWsUrN;|3!D)8r%mM0MzKFsdxh_-Tx*(~<<0Vj{^^`k^nz-dBH6f! zY0|V(MZG&AZGYHn&1mS-=7tUCTxOM9S9eR>E(V2tFq-2JEme0ya0#4cR@s&^@u662 zMx#u#27Ze^&LXC!w9YiSJX+g}o)h}~aEx1P4U`RkXl4gyR(zr>LeF(u=+|jI#WL;n zbSLC{I#uiFZlKMd6gKF_h91!AsS=IwfHZ5+cN-(@(@m0an&NbBt_rfXMr@I+?p@fW z-=~byVoRPb!A|8ZG#m@_Bb4=hd^uB%srKU|;_OeBUD&Sn< zy;Jdj6X<~f%UnG2b9mjKR3F1mg+bj*RFNr|gw32$@v(Qa__LPBgsS=&W|d=BNlJOP z#GaXh8e#@yG84(NS1-1kR9)HxMrPM?c2yiWwAXcdu1dAib4Ar@MLf}p>+af;%ZlMR^d$QX>$pGt8MbJwJq0#-%%Bax?NYnTxX)3OK6qi zDw07U^r-qGS_IpnEBK7(w}c|hZzKK@^8#~oD3)KRNVfY45kCDni7%%uj4M)*2bY*0 zpm=urgYIA62cl9?=zf3P$Nsi{asNs!K?gauT?vM#V|Z zkJI;hlb0RV6(fHw9ohtwTbFt*tzYt!S4+E{x5bGFySpsf8%6l_&{h3cGY1{6xU?SE zpkXP49-xzBqR1OCEUn*{Y`|>lO)42k|xtGD#6(WBn#Is5}n9k*` zJ5@D?hrOq2bJ&ALk4n+dc6dk1hdl#FQRB;~jsbnOiTre7pX&*sr@DsNN;0-ow`-=W zYS2D-0oNmXB=(~01-W~O69x8$80heBCZ;+(*9r9dd*QS6-=fY~oxOoA(J&F%Zg>9L3c;7%$wxXiK-?a6A!(1*KKyy=s4~7 zqeYEk&>r@(Dc4_=&X7nM?fEsjNy-HEV#+XtzriK=Jj)4(2`xs-8u?bGhvyNLQMuBr zD3?5!>f3gw>G;5UQ_B@)G&I__6W=9{##v$@)66D*Bfc*$f!TjA;b^`BjVRk1Y0q`E z{f@m;@x2)lBfT%2r8o-`GsfT%L%Fk*(S|3WS2btzJ+>J^La>TNalVOOeLeTdim&-r z&FXjDFYK}&FrG)rbpb9ER+6-{o;GeO-?K4&W4bR44*cw*l)v}2tt&`t#{&M)DzxAa z^T(x#LK&=XYQ%pYDZkx9=6`AZ3lvv=PFzt;yk<5t5v_vt{5G5?1I7#AifdUQh+aiC zMds9FiE9No+j=S9MdMH-^+@FLEhLN4cbidR_{#7VjOJJ#Id?XWdiT*VqS$wj2-PnI z(Z(Oa&5PfUI)jAM!+|9*(>D(NKdLjq+2bkj?&XZ=-KT$nm03~Q35AN}yez77m+*~8 z^^_nNUWQjH*J|ccjl`(dslYB}A6m!@@f4=@_)&l8ev{K-HEgIrYc#6rsBLlUk%IAT zK9t%H*cOv^Fm57Sr~$1NVvP{$6+OBl)k>z5>C~0Lp77)51(|megD7WY+4^JNWB!`3 zAw4T68!CScDYtn!-|I8#ewz7MOENsAzB;nKRMU!{?W(VLIuZ7XTrlJ-!1ZdeB*+8#g=eiN+sYc=bVD^il1{;#tz{t^rUcRRP7WxG%-xI_H6K7 zO$^$CGbOLK3uowS0_FP;;cU@wTY<7J0}j_-k$->SUgKB@S6aqndxnBboH&)5Toze% zjUX4>9X;iF#57c%O$akyZLz4W zPA{Vl&vekY(|T`L`_PNpVXUSd&3eFWQgtrM+)+V_2a?;pQUK4>oIvd`XYuk~Gf zuk~G=OdjWd#`_+kwFy;>x|``NOMHE;>^(C4Ej5^=kLKtv+V7}a)M(m zzqz*Oj=?dUcO&<_6z58i{rFB%RD)M-9$3ZMHBCj&Xt zX#NJ%V1SV5jOe#<0vqXfc1B zpmKZ*?**%o-FiV=wubh)mtUleIWZ#ZM*Eo^WIqvY&4mWyID>}lzk$Ra<$GI^LNV~A zslGP(%eL>0VWp|sp_PwP4KHbs_fErv=*_}7aLeP$oY`r`F~(%SuHv-yG3}yw94+f4 zl#mE*6z?|apq;`~~GFVc0S3&|0(T-m`JaUg7v89pt8 zK`V^2;CO+=^=`fmJjF5c807_)a=VUk7v6$x>(NB&D%c z2VfaHmXR#A-(hzTZ9Q2|PFBl1H@HI0EmE}o=w}Si_-{_O(CuT{vAzgbsN%HLxxx+K zR1e}Wz+Nj-M=mpEn!IoMS6la)7IBU7Qd@Dw#(w)lH;&Egx(#c_!>50~A2hARN9aE- zjRT1}l5%0?R=G9dxc(L9O0op;Z5Ny^O@$uiZc_^M)y5ViKwnjx(_+-SLj5JK>+D6! zzl677ja-kItH+$gcGbq#hT1OF^4V$Xr`a*3Y|T%CE-gbq$u0O;7+rNJe-w>s(nN~< z5^9PJnu+NGB7q+0^UHr|tYD)n)VU#DaBgsXQ|*GkLZ7ygIEg*uMCS7Y%nsu;SZf$B z=p4z?A$aa)!)1pI-c>Yt47B5qGw2gVJG2CM{e9mqnp#$fnqoe25L2E4rw+7o^yX5w^%U`I*89w(L3n#UB5$4`VS;+mXal=*SAZ&g7X5P?uIP0T;ICHK@f{ZSyvPHfUd zir`d?b$y1tEUtesQcQ<~VzYA`U%=PP8>N4v$PvzP$3686Rln{wNm+j;8nz7Pj#dAi&KAwaWVzvQY;`J*A<%dsPaML zo54SebQNOLSj0aoU@KY>%1i4OneNZy-xl;lIuN_<#NR#?c^=mKo)K8IuiNA$@S!V| zOB7iudc5bb-Cr}MgyQ_?(319Bw-w(JUc32SDJ)cm3CGN1xgX2K+-uZ>WoQ);=hntr znzfSR82o?cHbxkENopaiFowWEktNhE=Cd0H`nh*lL3WGPKHOAu9Op?emi-nIkW~IX z(461Oov`!LUDinjHOesM1Ndwf#VW4O)0)?1&bR)jF`4_(^OZN5__tMU=viGiM&SH* zvKRA5VoUq1llXOL0qQ8D3w6gaZ!#jPzcR~|yP1D0oIxi+c{q=wvJ0(Tnc@ueDZW;o zQidtcEcr5UaNRc5$BnX7;{%yVOga-l`0LJ-X{h!u95x0a$Nm%zO-Cj z@Ue?G)A*pTt$5WMi=%ut%_03;!9Gt~{z+ms)(8B(l~eHg?P(cor*)E1h7zzFzNYn@ zmCt_=_oq72GhKO#GF%ZKQYLy|kOkSts;=ey=-tP(Gh_0)JXzj9D~35@ZC6*l;(N?I zM>~|6P}K%|{Q3T8;OkPBYU98buFf6<-L7}_Pa)Qw<;ufrwZk#y2y>*$Y@5TBb3e%r z_#R_+sGm;xp4ox27G$UCLTzdv%&~bpTZ(_kA|!`Q#CE^5LxHHBqb$IEMjxDJFN(Xa z_;iYPTG59sid9CZ?pGe{5it^KAfJ}}#y(hoMCT6f_JSt$MRDgp7-vr?(=F~Brh#z~ z0*tCDUu$)eG5mSTdIY#%Nt=A+MGT` z`$9LO=RTbG2ke*R%izrb;%j}T;&FMZmKQStlKnE{YQ*v9Q0J5{`G`HNpOHF){hPeR z6YpCr@;!*L#at6?Ft;1#z!tWR*xrBe`%W?XKN-=^b?C!uY=*yM8ybK$x3Cwn|NEf9 zvrGA)>3uP7;XGwhDpo-sMbSFG;Wy*|9-2$8>#pl*8RVykSp~aqw=gVm-goEc6N47& zrnRN9Nsj~7?`1skBEQrgSwM`F_zwTRhAr5-vm(n^2b5)PBYAyeC-%Ue+M$19e}4&| z!@1h&c&yVrHXfgyJ%cm+m*niu*(T+Kq-RjR1)>GT0G%_~IuDd2!!PXf_KQ6Lt@u(6 zI)Zj}3-RB(?dkr^TkF}>?|UiSX$Mww+v>sH)`kW%)(zx_o_pgs>I<*lC&s$`-^5?Y zDej!IqR=*~#0dFc-g9O}^b&uK5|M|qRt2(wtsjsxMQbV~)1KvxD7F9dF~9qW|4&By z|Btc0)4Tuoah`{$GJ^J~QM=x)I*OZey=`asYFcloURxWdc&>7apfj%K*Ln9T+U-%P z6CB~CELx~ply?;5Go_UaFQJD%OPFu5t-ujZ*wFg4NypWh+i72xvLJt?alUZNWFMP7 zGq}1*EUCe4_1ZY+26?n43{1udcptv0I^;O0ljxh6Qp$B2l(jSu+w?U!s}9*m`DOYp zXfWyU8cnY2NsDUZq}b^w@)GZc(o}Ds z{F-A%QnTY*#eI~k2ix(g9`?-iJ<&ty9FThnJ4 zvxEcS(PmX{byiSKX}!-p+V`gMb!Ua&Q5<95nb@Hiru1sB5Mx%l1g=PzQ+|R^B9F22 z@(j}iiaw)g#pM@0S-v)kxX92l!yWH3f691f@leK#2sD2r!$9@fn0w?V!{Z4@HX1IU45j{+gPNI59ta95!xFpc5?<(rjW{I(u(`*+!(_NvSaXz;Czib!q3bBPI zILhRt3w7(U9oygv#YzU6OF6}`!0swW?dFq{CJJjb(X}UPPtfkD6%app78N@yvY*qw z!gz_Pi>kti`HMUJdku54j7%%z)lBgz1y<=43ap#E|F*p2d_ z_}+ga%B18*Jw;(q4UJn;-_K6f_OE@_UoU12T0QIket^t_G96mC{h zA>EPjbG)wbti`cypEw{rwM=TsJim3VwC21}v zquS?+4T3$tHGPH(phtVfGFcOCe$Wc4Huo{w(-PO6J-nxWmNF-=2YNhj44eg3ak770 zI3yi1Xl}%cyKeJuLs7)z`pu1fYujxxba&1K9~fa-D2}E^k{@N4wH`ddT` zVG@wYqYGkiWH$1^t%bcPb^GA+(sF+svnDCabmnfAz7Cq(v}^RBOms$+Ar0D1+Qq*+ zek&7w)Bd&RVh32l{?F@md;wc=-eeJ07IVBm6s0`#XXze@0D|*RBF6I>z%5+^rm8~} z=R>?GwJ%aUo-35AL$8X}HyL}?k=&29aZ6E?R~-^jU0Jp37cAnyPo{!3Mh1UU7eC?~ z&+JHQX4|MX5Hmu(TOQ4f|v_Mms2BF^-_>Xm4r%DE=%r0i&p zxIOz&8?1y6tuvW&sRllVeN2P&f-F}tOqN?+#@0JRaF*WhtVl&$Q1XAQuMK;q1h)CE z=g(R4mMOMm6Z5Bpqrr7aw5(`T2YfckGuW5p(PfSKS5k&hWo*h9=eF}x;iT;~{cF@~ z<`zYVHi|M)9p8YoXq!Hltyh(Ur6A#ry%fn=l&#N{M+-XawI0oA%Tp>~XENi^x{q6a zvFbC!94V2V;B^;_cIdB6j+dHg59Optr3W7wy#p!Kh8fUBDZspfEIsl;X*ac&p)Pp1xH{d z;#aqbwP|O+704EC_O-E>eBr708f%Cdrj#>}HMijGNy8bnpXz;ZhCnm4>ARRtJ{k6g zyljt@q&+4b9{f{ia6bDs_tWqsO5{cWp6Kzq4hw;Fyd)adO4YIyz0M&tfg^z5jo}7 z$1=7cZg`Jfpjfr!BRH;fBui?4)I3RyxYc>)cI!;x-{wY8Q6*_k_Dk_W#@B0Tjo8Cp zGPhWs(oC#70-s~Q_mGTGR+w3ERye+3uhPyX)qTg_D+7NgUXyHl9OeEITOoHry8(64 zQbZS6Ytv%=fzc-XuP}N3zsi;Uqr+{@1}GxUo&5$eUzXM z>$5)ZeIEM!4mb{@^pqZ~R%GFEJR*XOtYnGd&taYZo0&VIZ z*LBBu{)Ox`DI?vZe9-z4JF9vnu}65Pv2;PP$`va6J?g%0l=IEyhSXNxj$X+>aRxsi3xG#4S<{+u zQXOgd39s-^id?)otNr<^N&Z76o3hh_Pj@4l-YxdFJLfrBz-d8zzXs7q6Ibtu+I^r=)2gz;f(cqBG`+$!-Qj=7ZqPuuk_1w&2Sb`D_StcDl_e$oDf$;1Tn^c zQ&}O`#EjGq(GH=VTkF#)M}=dKd#isAd0x~9%uZ@Ma*C6g3bjW(7!nEKkz&(81Tx6@`SR3E4fy?YjpKMp?V|5-lahQ^_5Q!eJh8=08J zc#VPW8R*+_qV-4?_0K%fL-&Y2z+7=(sC2-HlI)iu?&^o56FP$#qvC&>^FS^qj~L6e z(OE&>66Na&2J0k>BX*4Sv8J5ke%ZnC?&yXT!JVuKMz7Vf_qjsn0 zr3Q6D*^SRq>to_)dg@!p2eGZ_jav5^M)5;oB|nsyaeSxp?oXXydCK}2SI_LAI9JU? zZ9HF7a#k2(SsFi2)kc5(4Te#rsuiyMd^?|aULR$g#thfwFw-5e`mOpd=_&ZcxU}4* zcn=!9>+6mrT!;6458JN7KOCzaj}(Ow2L^hYC-qyIu7p%R$M(HoAZB#Lo_j4FlwnM3 zLzF4Vs`&f4cPQ?RtS#c5i*GoW;2Qb%d;0PLaYCdzM6yjMv~O()cVx?>q9 z^Doo5eZ&aVlf4~Va+19i2zBt#q0KU8S;5i)A7i`52I~W9H&Nvk*SngD(2$=Go!;k5 zV~HI^+9AJYjIn>^8>i)+rkoS>7Eb&38b%@JRl&)03GA;sk~%h38(+*_V;WpdFrW*n^04EM2BpQT=abqPnUvsi1UrK#A^GTp8mv?<9Xllt44(w}iwXo@=NiU+pqO z`_s{c(D?n>Pji`abELY)9F@I2BhQi`y^uT1Cy@ozPbpa=2dVnQp#>?G=Q>cA4BNR$hFoez{SO?f(tc$yE%~ zHkuo&+KOgqCf4X|4r5lJ**J}>aaNdHlwR{_{}f_1QnnP$@UhGYs=8o2l%K15h^@y_ zPBlkbBXmzNJEVvybbk~|h`CF?j2Lpf@A=xi@1cL!cn&RJID0keWYVL`DCvIcJAEd* zz+|Avx%f`QC|?`pYv^AyOh=z#v2nO1)b_pf6!)g#ai(?UG`q~)s2$COBz6?6Vg3Yt z+7C@B{9^w8>@6O}QqjIi;45)QeHSz=j#N6}oNa&cA8h*-!%*u>st!U?HF_ZO#p=uI z%bpiK%Mk^4s-G@-mLH0Mu)gJm7N(p z7PUtzzq;^0Jt6u(>R-zpW}Spb6$$qEdAcXE?f7(bZ4YtUK|?`;7=_zIY+BHhI-!== z2RyB58C;z-T*?}IsopVj=4NYzUrT>4sGoM+3!dsc&%3Tr?yC4peAH~$J^6Z^+KYSqjy?9m+Vu-`|T_2)?PtkAsiuktGk;E2-_x=>N64rkW-bFKp z5ciGvp>{EX=u`1(hs9%iM2y{o*WQdzwgo?}#}@X$nHw0qTm1D?Y|&p`q53Yt-oNF> zskfeiyit0m0(GQ15}%w{Wr;JP4}D=e>V0Mwj$jYIJ`rP@C{~c}xI@gf*g_tS@{}ty z=R6%PFELzI5+~@l^oim+b+dn^tZud|)b}kr(|*YJtt(I8B>O#$P*6V5n>b7vYlKYk zDR<$>ZP(3aXYw^D$M`$HS{|*Njq=q1UGiwe4OBH}EwxWtjy7u{_Q*MG**f?n?TGK& zz$EW+I@%S=KSgIJTvvf^c4iaaH}vLrsG;y*^z#l;@4G@(ql2IE9({k*VrwjF;2ZrD zm}Izm^GW!c%%+>)D<0P_q-TQ)8101c-VWSFe9)-_%<6VdhM-l(WGsIpO z`zo5+ME>T$KYEc2+N11;*h|nupREz%w|JKFfm>IlKay{5d+?nrG~qh_in3SjlKoyD zP2AIIN3hrSz;?PDU&DVt0b_s-2xQQ5vqDT@a(49h~trcI1u7m(;#!-syUa|0d?1c%} z)sceN{|r?<&Q7yNpvC-4W|=LYJpkS1nJAlU(|)U1m7TWu5h;Hw4L3ZcBOYF2!l#MRq2!_5k|23*E3qnS+{T4IHmJl%Ic>7^CRh za!%%o==}Cv6uD1%CoG@WrPl}s*YW&0nn3(&;%l=$j~1p#{sG%*4BF%nK1ZKh@G;`t zU5*gdwbEGC9EyL#w$9X^vjHhy>bmvhhh-y5ywFsccKcVCzD3S$0a z>PA&t)j`VS(oBVwfk{-I7W(rpO2s}J7?t7vnfE2Q+k1O1Od&IW0zIqX3Q_UhvpFdG zF0V(?1Yajh2o34GP_pk>Df!Nkt6ZHqzp9Nrqkn~R1%X!3Wxh6_($}V#Y>(0oCq7i1 zshQjf*eKN^nmNZWRy|Z2%Xmv;eQnC!@!P3lE{%Y7l6fbrw9ZVJqZO-RyJPsA*WWYt z*e*aHx1DL#{Mx&Jo=^5k3S!7B5jp85!RLH(-4WuXlI|*qvCbqMORG|;GmO);68~ao zGXCTM^G@?l%VhPXbO|vfXN*L&lFSSbGzT*(DO+4Ck()CY`BV7hf%8F=+;`E$2tUo<4&SfJfB1)4vzJ?BimD z@?20=PJw8Dk(p~?ecGV6ukyV~HSdKdP$qF!nolRaop4;rDB3l{g)Cu%FQgzr`JkeG z(Z`nKl!;^BshO&J$Yij+2GXRrr5%D!w5oe-`S4xJQTt3q96yvP&u=w9xZ=EVn*8Ne zuh^rQE9_-X7V@%>t#%O$6+ZD%#S4iYe6nAM($bZGW%NCdxpUQxt@NDU(G+ov|3!yNPFgpx`)GD;h30@*RMAV z5;UV7GR2?y`yFG6rBV}~x*nYAGdy3>{A4flZrFxBw}_KDEA(BZ?Zk44eJLTXNG61G zVU~P8ui*Ml-tcEvM&>}3*~xirl6*2 zP({Fev?mIfYmOvjODvoar?@ZqKdh4iBWgxuyafLMi!sbPDf`uQ3C^fC_A+r%Bi=rN zEm`Q_%hh||t2%&Q!4!siQ&RZ|X+g%z)fnY}CB2ZWnd)P$5lN47+liNF@gpGd>FrSq z52Rku*ASyV+K7|#7~4{97U6Ntm$}1?tG(};$HKhicT=_2=H(Z466Y6)+nQ7-eBsLR zs{htzrAzby*pI&Gc5Qs^di35579ZMDKCz24l(H*IveTH=D5Lw~Ys3!6Gc&2KJttFt z%tSBmbE>K>=-4sFFBk2`d-c*R2Mh7;66(=YT;!J-dD&^psJ_vuqHXL&XyB`f$yO2P z3m2Sl61HS-=by6pXw{irfF63eXFB?WeN~6_uP8R;4qM*HepUXc!yq?99QP)u%%=(I zAa>fId=TDOK4>1x1LfK?BfRH;Y7v}&EuSEAfV{)U*PakpSLbEFin!&=>b#7Rln0!8 zFL44XhX*zR2RY!WI%qmjn!*fs7uX#3N<#$ADeu0NqwprqftH#c^2zIG!2+h!@r`E} zqBB~TeTxb4d_{h8>I^|A^1L;Hr+${L7+dh|VBMW|{myze5FmyJ^d?l=D5f=k9sMuA zbx|?Qm6s^-d7!B{CVvhmlXlRam^EVYP%e;&zP#b_T;6eraq)}IP39)w_!V<$cZYqM ze*t^+aqg$Yj^HPHubE=!s}A{lZ=Iw4FmV(;zhaj1e&zj&_Kdt$3n;cN?Fd8JX6H~- z978;OC!0^}K7Hn~OTKb^VU2iyW3fI^wK&scjfG7@R$c`36^T7T+z0u&iiM!|g{K`c z?SfSOD>WndxA=9^j@)7VI_o5BtYf4yjBHBPLHe9>RQWaQ&M2>J{W$}q*MnxD%4VX(>dxm%MZw)~tQYjkXz!=Mk;J*>TdQa?-i0PXb` zNJLGqR!6SxvMtqo35C+pia1k>v_mtoXqV&Z1Y@ zM(ZkaGy2(miWGmZHcQn89}7BlB}&Adz^}uqEgtS(~B9&cn|1DR^Dl)$Ef8^LYCq z5laVNR|8qaFilP5Z6t8m!m3a<@_j6#m|lyghZRHP(y%T=hz>9=|)ScB5}W zKIPX`a}jzHI(-Z?(vyYS;u~h9_4$ee%K30gIIzF~4a^Q$sE%ZIRE#d2tr&)A-lB+8 zwA-?&I*s5pTxF(L{sp~|&*2nYbcHh0m+2t7HclO>ddOIRb8DsaM&9V1@|lUPdbwKZ z*MZxeXC?N?3aa)(+$Xg9VQw@X)pV<0TFm|Q8S&r zE$T%|yNbkr$E5h0)|cIC5yQG`*Jp2sCgmLBS<)X&mO!6oGG}mwn%nU>H)?v5$PC_B zy%IjnGHNA!4UQgq?4ljT>m^w;9)~6~dd|eQC`J>N`JZ7**?Q|fyz&RkJwVlgydrzz z=deONVi&|#cKa6+LtOroTB%Xayu7-L@$&cQohBxKYefjtingGYU#yv8nm{X&nr`%T z&!AO`z6}-8s|aZK^`tp+)q+5?XPjdybQk^37^XZWeH3TKJniVBZF#57NwzaECqKWs zyx<9bF(WZ%A-WAk*%z=?XYEm%DX~|Aa3M-1uB3G>ix@$%l zY|LBM z2Ndl!J=!bUMq?QJ(x2p}Sni!tiu#~^`yg{gbq6rRH4~YC5sZr&$sEy4W+=~hf6}AItkQB?t=5ia z$4X_wVZK;1(Gsdo^Ujx>v{~`L()=3bfTs$LKBe_}^dQe-|E8kcP_?vVG4jnrjD@I= z`tMAgpx7h$65fYx#9V>MxC}?)B;weQGxD^fwT1`lnEkTLv^L;CggI*nCBv7)KvL@8%6xr~0#b-r=X6t=(}Jk(~I8OaqLUPr|>qtLzy`N?#yY} z&lkl}ZBD%))^qC-*Hk|x4;XscF@jfI-&t4?lO63_oY3QoC+Xw=fWOtlCfJ4=sR6Hd zqA0ugf);0wX0mr4RiLJdLdqbn{Ej){#JAwE& z&goVco@c*;_u#BH%P`(3hwp)E#uwuVc8ghro$wZ-m@a4)?FRMbr{X%~3HpK0kXmSK-w7ji2cNof9FTSW%{{Ttqi%iIX znb9q_wGo`+42px4)E7N(pk1PK?wsw_-kt|D4$A8|hkj_U zINP>jU!2D~^rF12g%5G8+EM?0iue8izh95-AkXu>C=0>0syIG>2Z#Z=3DLp3o;Nb` z@Z5i(mvS8Cu@|42Bxygi86L+^pP^=9Noo*BokQE*i+HIQkEE+@5PgXjNJ2^YC(f59 zL=xxV9c;rtXqFO_J>{6fTrs-!zaSPh0j(GJ!tUDdMJ_{%ANx*>u{ejCp-p^;(&TFs z$Ffx%lOFh7o&_I&CR``UNEfiLC33y90hFkZP;;V|iOHJa|AZNVa%IuQvq{o${Znw> zmS2=D-hUnT%U7@#eZN`E2(*{Ic-3{fCw#1Gepw@q8}>R%ST9qqSOxPn6N&2?)YL}& zqxpa`rJ+%M6JI@|W_wdfzkMLCjkk!S(2ZJgkJu+vQ|=vq@w^ti&L=pFHUr_oR#>Nh z4SMtL$7@ktEjpi$`U?Lxi|dJf@)eaoh|k>%-!T;T*TRlL9r!8s@=m-G&VKJa^q?B$ z(O}8DAJ6H=*3&g8wgLe?zRBS0u!!@y`t%ui?W=wrV!%#{bmWuSm#k3OBN(9D`B%eq<3a8- zW;$ZYJ+w2-OfPf#!bQ!$89fkM_haF&zHoJXPVQ?)TdV3Y8$yUZx(Qrts@adH`K)J#z~Dx)-0 z5e4MnjQX^GmOM^mwRhWj+KbiaIljRjnyEeMecrs*7p@qVK7-l8-=oh@in#@QZl0K3CxBPPRc^#G>0&)ymN*HLM*~~1 zR~@MtUYct371Y3+>Az8|lCqou_Mwl#;S+d(^&XeS2+xbVfT6;_z2_9GbbsUlSj8%T zDiNA= zM}TEi+>e!qw4?q%NrGIg_S=7@y@B$&P&@5{x#Fs+m|-0VFcOOVU|uHADSgILC0nm~ z(i6s2(yDBRL0qkGD40f7@a$3SnZyq0GY24HW@~-^-A(tJ$ltjE8eXE_Ndy> z)0me$x<+S|5%Z@`f^uv3CWA#Oue}_Mu?bN}724ld9V6QPN$t>%r~ar&}%7e(S#{bf-NVxivQBd$i2MR3{u?DB7ieQ|^|A z*Zib@+Vcju%`JQmI~GxYO4>lFMeR|Pa+EXJiYrdr4|(FV?NG#y;p%)Aig~?FyAAAR z#6Ikp>@-2-E7nRBf2KWU)KAw_hEV=qzq6^nr97|49wk-{Wf^Z-9Z8<`d;83kqqGa9 zd?2F~`j|3DUCPlwv;HYD@-!M)O%bs`S(dKILY(z+?l4Ftn@RS6)cZU$-SSjvc@9;o z9$c5h^u|tF*FgLEq0K?kkdO+=IP!hwB#IBB3T$PK4y#~L{JG4}>>#FKV)Ei-mar_3 zVN^z*{bTR*nkmG7#J+^*@A0wP4=W#WJ-50`-^E_0I!{V3S8sgXzn5u+Wd43%o8ndF zaH^fegvhPFHp^sx!Jzb7A46#$OL=BmNn!Z%#=>~l27OchMJQla)ab}k7;F@qMm$dl~Vtue5%YeIBp2NA-wFFe4i^Sa=Z zAR`hn)e)nE&P9w!p6R~D@)E`Gty z8J~3_bA(e7dzev%I<(0?Q{SX-N_x{3iX-4H{)1;+(!`u{?Lze7?v{f#IO~2Ohnybz z*P6J0xr&J|YqRo!x+58nqm5huZuatu&BR4mcLdzrPsV9@L<3sF(Zpp;NAo#;T~a+o z%vonzXWA>ddii#?Ub^23sjs`s%z|U4aVetJDa$XKTM|3866O`+oiiD%Go2N(;i?GQ zyHmDs^|aGqoW{ve>vr%tOsm1BcvYLFo~>PfV{WuQW^XmWARP9*;R|O}(r|O5^pr0g zQQk!K!?pyP^X`{Q6{m5gPeaWzUvQZg>9<;&&Hi#jVwd$Xl&yn?`}kpeE^M~*r~@m@ zocbM@WG)DB3mQj&B^xz`mP<~8gks@oRWMA3}WKQJ#dox)); zA84N3Dl|fTvW?HNNBPF{h3Mlg^*kJC);7ZD#DA`tTJ7RDat-LwL`olJ7dW<2+$Gf> zQ9)@+l2!f+G%&-#Lo2(*R#*#v{OYbivws=-Smj&*^}omVno#K9oAac}uu{T~rTABM zw=vAWis}#rBUh{u1F?bP&u{GYg-cmh>D*A$!;A?u3(v-{CRX9xVN`(x=3665p4Chd z)>vmc9zoPLhZ$4!J0qe8-}u^biNx2AzNt3K_k;F|y;5k@W=V6z^ZKfP+T?okS}PPN zxV@FvHTv`^)U)hZl>988$d{ze%72@Yu=PM(?pth!6^~cv6>YQgM)D;Gv{HD7lbOB? zG?%78Txkm9t#&pxbE7>fErVo2o5h`fpzKhzx*mCnuA}-* zzEB@9N19veXNfgtg!)LogVzOhHCyA`iV<83EUWB289B4>SDMighzYjnS24wm9m_H98evqmWNCi5GA)lV-N;%mcuG$6MATs6`# zO1fQo5_SGtY`r$iGtN)>Fa3Exe$GN59&OrTRt&q*hJEmzGrRCy)o0e3s2S(t%sPs4 z@EusV6Di)xDbih8F_{kY*u2y7YwQ?(9;)L}%nm*W_3|2KI-jfWs?ojih0s`gkqJ@% zKCuhtlMhFKH9-A)6GsWZW=2?{y4=p^pUmqrPEE_uOkpouf#UkjEtaL!hH4i((>GpZ zPLG4nIYXKwA(eP`Q9Gcft!hg}oroIo5be+{oo|maj4~{OhUK2r8B}Me?g$}M?IK$3 zu}*?MYr1bpb{ctG8D4!C;w5M9)>76uP5pGyzZO@2`NGp@P(A@gVQZ$qLPVIAjKn?E zuqY{mkR&r5C1IpCtLjk6?&27fSW9Au=E?FrIBCAb$;?TJ3MGt0FsOI?b$**MLNUxk z@!R#zimK0;-RQ?en+4%8)wG~kI^i(Y8Wk%LPGNSW3(g8C<9_1rm%c!iTlxFR-=&Bc zu8G-y?A%cKh-m^vV580rVHYqVCC{QC_?3C5xszhe@%Ss$dyF?NBQ3-Au4lS`FGa2( zLhXUg?EI=j%y9E)querCvCsAEKtQbC_JS}@Fwm|h-p`%?h;|dU>ylr`NTlIn9TkCA zjp)VJo5#XF^j1HCy=Y$=YKM8sC>}?f1#@bDzjr@pnozXOaWHdQ#b=p|pv4!y(h8pZ zld^-xFle&)4fi2hecK*IbrfiIPBDylkriRuHHo9-C6-W7VW00<-Q`^)?Jylp7*}^r z|C;Uzc}!j-j^NqSX4qtSoNZxVu|5wC{#Ev<_<0mN_-#TD`>;KVUkoRuIhtsBjL;ZgoE`0%Zj|9%>IREg zFFcMS^U%6QYO@k|R6fGA>R&^=;H8Ln(*fmf!zk{WBi3-0L!=Hpisu+_HQeB`wG;}E0&qCzt1p3 zoF!U`m>oe8O7VuPu*YzpH<=m1z3yWjvf2}f_IseG>HvCr;pj7ZM9*D{v*e$M=aguJ zbG*m#Ii#h>a)*`GdB)Njc)^<5IQ>&8rDcUxamw8|#}_Dfb4@sd-cIaF-D;G7sX(lX zKvCX(iuZ8t_rQ1NwTQUi65|Z^K({{N+<>?p5e}Pxv-~liYrw9=agE0 zUG0wr*j{M2M%2$L*p@CRz13^2v93_-W991Vyejn0IfFVfEu$a-dW2s?+`>7q&-Jcy zxBBV46tu_|IIHW% zkIk!IsaS=&v>P@9;*h-aFwZx{@f+h(%Tu~1#MyMtG(NEd(n_8+?KJIwv_~0}nUJ(4 za>nrhYQEvbuA-X$a~x?oN?}u#Lh)yuZ6gDlsQzyH3`HExb{~r#kma==D@ zbq)j&tL`+ujx+g%qUFqP<5=Zz#Rleg+AQU8Sen>@ay(p{6_lyO4rV{e6=G&!Mp}V> zr9Ufp-(#;*)i>COp8PR?bIYI{HaA2k{uOM@j*wTy`oZ5>A2S_Qyqc~-JJL&)r|mL0 znN!Yf&)%-jOuaye89q!qpE=-u0~n%yX|0ieGVlaE-zjF`d2Z~5 zGk4exAI!~lr(8!Bo{4@gdkG4u20XvccEKG3v8snCB9{G1_5s*AS-J$)vvrm4;#2fM zoN1@+9cG7Po;hCyj`8HjrjSNG!DfOdbv<(gl&A+*;GJE+utqzOS8g!NN!(9^*Pr_L zVkV*r8~Wo*L=KRDvZ6)e{`}lQGV&U;qpaMM1t#vNbV*`w!N+ix8BzHc#1lP*=kTeI zk#Enbn2~}v@q+C4Do{Q^6^N8M+;-K(njX!VTBV??I>dI?9Z_E*79eJa#^Lxz%4#MW z=J-4L+}icT$S>Hd4roUgWiumu@zr_4^N2Rj!a=lzZ?lbmSraI}2-}`6N`*6i9xTAQ zSxNhM${a)~TkzW?n7dSYyWWRQK$-k3NXpeXGJVhmZdd4F@7?#UG@Sh^Lu(%EljO~= zJ;9v0OANLORxUG%E7c3J2Uhwil4PayR4^k})LJV=E+NWHk>KB1oL8Nehkf75a*O|9 zS)>f}cf!Jd%D-qPYbG1!s3W~Q#R!n%OjG4w@P7X@X2AbDUcj3ifT{gC{?Y}lq?Y#U z?i5|*#g_d13EMx%@hx7%NNX6{4a7LKx(hA9Qu4Ztlb9pyS9ttk=tG}HBEI6ZlDqU? z_l+YYuItI8xjM8vO*di&2J-L^=35(BW#mq6_D~joob?%?8n_CPQ{y}LvEmDO?Umww zWjjjA;603PorL`=B_7_UcsRs0OztseMD2QJBslP1Z{bxaDm59e*pKgL$yab3@1TOM zVr0k`apx7EXz5hcjRrBBQlja`c1YaM6}K)kQ3Yr2C!EbUo*d7SpyWuXwl2=jPw=cm zup174w_=?Kw zV#=8z_*^ILQ5E|shKP~ajsjXHbBn6YHy&1hrc3f$)saQ72Ab8~%H7TiM7+1Hf!Sjy zccb_Z`b@)pp6Pg{(@T3sv|8EgkLMNiF;c1zKd5!%6@O021QH$D1TWRo*FHb zXyihs7@L?Xe|g|IDPBM?Xrt|_s$3Xton)8;yPOtCWri!Gh_%P@0FJ;}9HE`Q@xthT zf*N%sRqirB2rA7K<%9XHrZkk(Sw-0tZ^PDC93WPX zJ5>9;8^`6H*))TZJyJ)k(U;b$86#eApamPOo$r3PLeyqK_NiNUvcW)}O=$vW)Z;yG zXGKmLG++9&DGDM}GNZWfuG)iQl**NVQ$>w-_tyWvwEch9;{Q{71#nYq?NQp%w(rvg zb|&Jk6X-9@1C?bdB4o-sX!z5!iuPbd*whJSPU}oDGh575Ntcwo?ceKbL+@(`BUF8+ zY(bBynetGb8!Vy9D5gB6G=82XELCm^)pr@Ep*OaPK@6jrSZ<))2F*l7+9#QRPG6h7 zm0!(o^s%(M#~e(Z!2F5Usf5Fbx;!;KAZK1KO*Xy`^9HT(QvUs|`oo3+$mVA@4WUV{ zAJ9hz?Fje)+)}4zvOh(?m3hD#n{Zw6HO`GfU~6<`g$bA0AM7)QG;4(LIMb?DIYRI$ z$8$2n{YF`SEBbYPs@dj9?A5b>Tz$gzYS+?x6R!K#nQ_iQD|doVF6E#vr<^==kS|rD zXV4FW7)EKPBpl5t&;MiD+kr_L&#+^uG9&pmzHb$iNfW0_XiYI)Qtfhu7L5|t&_2{M zQ+zSSl0a&5gzsDS64^xg%erQEjK#^X%j)9SDTZ;fWJz^i^~xF@U1^1U#ZOjO! zmFlJGD}3R;^Jy8%FtqnBJ{Qv2%Tz-S8Z=LWQ<#`KqpaL^#u}0FyA1S=l}ngT)kAy^ z6JiOqy#@_phIJ>PH^PK}*rWV9)kA)rb&{R8^O`5Qqx!AEHB>%F-Kcs<@wl@Dl8izi zKt40-(-iF$sniOn``=_YwgV2~b3VO6BNzdD(XyrxerIqo2$|?G$YGT)CH95W? zAh}{Aw3{O}IoNk5lohx3q>-}SLfM^Sg)4jA!xZ;s-i>njwfh*3dyi%coJC80$E*mr z%bpc}#+kbCN6ODoItE(`btIfZt2`gv31jaPDMx!ur)ZxYq79=+vXl?diiLj2PS=M)^(QZb(@O~iBmk}fRig;sNW#r_rU#fZg37Iv!7 zcXMaTgeYdA7+WxqXOFl6`+sw5e)o?wiY?kEW@F0fU&K|xz1n1A^+Yd#ax&etqe=*0 zv|es8fN7W96bY}y+3kQmSy3j+GLn*CdrO%-KWUAq6k1E+H z&tNYncIX48v56fv2l^#H8^AMRVo$sKpcD7+>$?sGob8WNw{u*Zi#=Y@=;Ef{|Gajttacr4EK#^Bvqf; zqYzWI_{LLQK%lwwAZjVJ3dB<4eO~v%@{4FQ1&UQk?8uFzdbykov6w_JWkQ%&G!vN+ z+8v=hy{ZGw3TC+Ubt}Z9MWyvM75E~coatmF!ePd%dMI6zomP4f^>GwmqYeq~{3ZW? zhZWLCG9jh0rU|NtpiRhRB&lQA1FDB=r&CNG_Dhdxf^iz&t#j1^r8g}@z64QX3#}9f z^|Te}U$k{iw9cB4TIM9{t!#0GPz__slcY}>27LE=!4GVGs{$Tr6~mZB)A>Zf()in-<{ zK8Ifn4WHb>gNYsXC|{dldNP9=_pGK{Glh92ug54y3H|w8U-+%}%%5)Un2OBFBWuSI zKaWvnbTZ``FF_BpjF@DsGf|dXC`T~RYv_McnzqF4jX2a&Sr0id4;Q$ zRK+3=)Z*(?#jxav8p_>8ZKZQ9`RKLf)~7R~;C*?PGabGM3nP)2Fu~P@Pl>AtTZCvz zF^nCf-(1TlOGNIm7Sz>$d-3%tMVC=Dr3#c`){jv0e~wxsBRdV}RgbSt__x%l9Zh#~ zokIDN-r17dE+F#!K+F{-9lBh<73NmE>PFQ)T=y{S!PcKbo$5qe-7Y&wY$mD`OljpI zt}ZX4=9!RrB5U3`Q$d;EG+rNY7?#8pe$O>f<(abA;A~krSBF=BIOnuDOFWx|4OyD% z@|+*J62)YxRygL#bf#y_GDk8wQpzTZv+AYcE1$`F5$(@eMTaojaWAt>s->Nn+8y9LL<+q}3 z^q?m#u}4vcu`xpSn}Uy3C$v|5Z2lHzhxJ`pn|J}vq2#seB(UD`4OJcbC3}xD&KCU+ zQC-%8d9>!5Ggmc-d%b$4A}*&K8Z0i*RIh|@Zmclh#=$P`gse}8SzdJOuV@nT${RIKNq7*J(^c-n4#+IWLS>@1x1e?s+Y$_8*` z;%s%N&k#lI7tSAxd2JHPGW)~5TJ$-VJL3`L02lvzi(ZwYo)aXx36`T zwTjZ(E>&x(B4vMGTD8)({uI0aa|UezZGWG92)Rsu=JuTDobNf$Ip4!HSPuMj{>%d+ zsZzM=LNTi`ao`%I&!PX7_QAlFmRF=asUBUVliw=+gMT*FDe_lJ#4(hL{kAH^4pN9w zkR9NlNl?3~Cbo{OFo@rShnHsGrHEpi$q)Tvf0%6|*GKgSs%zFT<|<30xqn+GGuf$6 z7%U`zE$h9CCt+JrGl*l82uDL+QDo*BVBG9dUCYj78n7x&zKIkm-UW>^^cwSEq>D*v za-Z#Yfc_ZE`ArV_zd~U{zTJgchxw6gd3ld@1^s*f{@h4?wLB*?P0X8O;fSZ@29qE= zPCE0x1Fxrp*oyM?5@aGONJeh)0S2MeM>)NJ;t}COc?Cb8U+VeDHMi&(Yow33zX3n9 zp6vBcNjpO>XX=?r;NP871ca&b_0$algm5u!|6NoBln2 zvOk2!q)IFYRP(X-DQi@ob&ZpDRTzZ}$vu`%BY1?!caUy1yvwVT&AMW$iC}kyljI$& zh#(({d3H)tNbRaV?yeX4Gi!28q(n)ok^g4Z{k4n*s}JVjn#SAtc4li_f%5iE7Nz<^)+Yh$ca$8J>50F*da5f8{Q zf|8^(0ERdU)_9Zg1zgva^OPiYk2KoHfNW+`Q?M!?wpho?>YhutR&wr%#&{}_u{ebX z#5vg(MFk2KnbQpOGJXlzYChn$WNtcl66~>>YNguCL*8cf3`Y!R&p6+Iqau<@ zgN~4%JIPE=^U<^H?<s#<^VjWz3}fhZIo-=Yox_%$rrH2p!5;j2wLG z8LZJ5YiZ1!hMaCG4Mlr0_hU>$+vQ_l)+++0Ldya=7tqmp?_x1)ZocDu^)baG*wvA! z!E0Y3Rxqrx>=Qcpg?tRtL$#`B)SW?`D_^M?T{RJT?!dADt|WbQC$rXnojT0F_7lG@ zmgx~=Wl|$%(<{ICxf$Y>CW4>8EZ9i=o?K^KQYooPw-y{h<}l<655@%k2IP! z%0@Fwuy3jR({i|n-d~6G-o@rxmPb6t<|! z9nx*KC}C>y9sgF-98w;C+N=n?jJ&w7XS=i4t7kBij4>Fqeb9;+?2#dPbR^jBev=0* zN8Tpv1s6L@tM)o^(WE(PtdjF|fz%PZfYoV87^bzcAQ@YhQ&lV*wvy7KUtLB51 zIGi786IAojM3 zDcQ3wmnnyz33qtEdN%3fXCkvX%+m4)=FgXqQT{J{i~tYUxPfQ_uO@+f}fe4Dcw*1mY=EE0O#0A-oBfSyA!*!d2HmMR0G(p-~BWA20PuYP~`b{ zras~R4OotUCXu5}nIB2^);xpV+{N0_-D18%A0Xg^q!IAH6uj|-x&%@YtT9gi)0)v=~1^K-6$M7Ex*O}BPx%^1~PI8#o zd~N>cjN@{hq!nild^SqH8lK;&?GsnSdVEUoA-l;Z8PkZFJ18i~D9m9h|Hv{qb+2Wz zH@Cc*Eth)eL_oTem`NssF$=xcx`a?!{RFVaqclmzEN@iub$WANS|F8bwTxHI=iY=f ze_j87yUYZ@ve*#>nI@V5pIy=~!w!97{HLGv*Nq~tE6>859c^gwPa$5qvu>0=h@E87 zuer;*_nugzgv?OLnD++!avSLf#C?%`m2Pd&gGcZH>ClbT@&4JtM&=XF3EO)}i4bjFit+pbW_`dU(XiKx>KT{;Y%1i5_YD}E zH~dp7j9?XR=B|SCONH}H4b~v0Gse@KL)T1m)c*nP@?qLHl{)~*`rV(xjA0Z{SeL?o zxPQg{LN$_VWxg%iQ{e#FG*h>c4bG_(7-|yeo)+cV^%Ik%&TGNoX{f=o5UE92pb7~~{yQSk5W_G`Oahflsjq1sDCihVf`I7+W8FTl# za~N9ju<{l;P5R|!fVd7P?PZO@ieN>4q+w;*t7JdkmGobEzm~6J+5s^fVfTW6FMWw> zO_H*EsZLd)lHhv0bcEdEj4N`;SE*<4ZPG5?2C_p{QnbhYjgnLW3NhY<{rp{cs_v|D zT)MR)8!et`4)SJ($H)wsX@zl``TEC#HR>7klgK;_I^l5UGj$2Bu|;?CBc;(rcY-xF z&zQF4ZA|+{Gmex2-T>btGaoyDXZR1-KhC!3AEP2Ho%YgGWVycX@J~4yn)_K zzOo!}*(RB#x?TS`HHMfK-5`I7H6gk)X)la*x9X_>a9|%P)^=st z^v_4c>qZhavxJ$<-eQ!1h~SZK<(j#ZI8*8p#hm)R_D@A2c9-T{+4fq!`cd))bw$3K+C_1ju425d zU@GZjQ6sz!8oZD6irHa*738cgU!6x@RnH(c-6B&=U8IjKUG05?pNZW{;0&=M#2;Gk z-vbD^P>eVC6Tlya+D%v8C)_78TLJl8(&R8b;WqHS7gZirPRN>A9EGT0P$cO4SLWUF z)u4Sca~BfeD?@no8EzDfk5B zwsPu3pHn8w_a#u{3}I#sNp!@RVhp{^8Y-5KH1wLH=*`?gDz;WHHz*$`E;4>)2{xFz{CI_$lMSQ<@ikL0`xqGTqCib0Kg-k$p zm*R*Y5I*y*qnG>4?t)Rw5iVd{n)w3oT8{2%?xd$O@TNg+nweLTIZZWE;--w1biu4yk7i&05mf+_WGA1~?M|3ADM_&@l0@MFO9 zuh8HBEyl&x-TjZOTlcnBh+h9iWB%Rm20k5pjC+6Bzh%YuTMhKGAAD8={qu%?Rv~UB zVaq|A-@|LW8@5xD^0W~oL3KHI zC(~1ToV^v&GuH#}Id%LJa)en*&gq`kZfkQ~%Va{sDdrW)u~vEN==G)m+P=r@j|DuNDoj(M8uGP{>}bx#A*dJm;5 zJQI6=simJ%bW1ht-c48KtJpeim!%Pow8JDX8YOm1Drf5e``#kwKu(Vg@WY087L7vI zUHs#-lRs5m##aOH4Id-}YJu%Pv|jXvj zoM3*=8Arb&&7)r-hg6s4x2RS)mnxKAMww}U)U5|RZlolcX~uD$GK}t(T{Ov+9VA5& zu)m*qJc*$=ij&`x%H1D1dUacv>(=F=L#Ejoi}NFO59`)*Q_`)quLvFK8@|USP4@Vr zJ7CjILp)M5#^td4DDh#Ba{`u?J)}~A{`L-w1!j?K!)|2ehsg9bqU?l)PYW3wIuzZ7mqlWQ{7safGfev89a%*Jy_hn;M!Qaqsr>gt9 zmL=ZJ%={sOIrMwuT?_c&HR%_Jb-(@bzTycmV*}rJbX$S_++drROHc%Ab9 z>{(hoq^q3D^zo3MZfgge`Qx9FjD#rJm(xfj*ApMP!eFCWZn-2W53;YtSe+`L!u{o`jfm|Ja-pQm_Y zkVK+1-=8Ixc;9Na{JxH{Lu3hm<%s$FJqh|=e(p)naLF+blMSaR8xQU|{ovfl;iIpF zvCSFM>w5UOW{Nq`1{m24gA{z01h$!)CSO@}#}q>+atBSfrIfh7KBOb?-F{9#-ZvLJ z7M9fMKqF;f7hJiyyg55FJB!`x=#wUTbCZ6Sneg9JEX}UDx>)4|`C3GOriK<{jKE-2 z-8M_QjqCtzK$5@U^p!`k{#SU$7!SC9Gv*qr7RXl%7fiFsrK&_}bp0jPC>>FKg8rh& zq0aNiTH=#lG^JLa52TVy=I6*oY6?C8o1yLMbj=Nd1gL*QA9mYebi2jw&VAGk(pMZs z-6(P}9YVV5x?>sm;Ctchn`FP0e z3g#yENu>gY=gXc&&ROg@;bU+mZ2bj#Gp-L|UI1wJ(O{p(XGl~k)mr&#p6H&YdN9j~ z^h$q^+=BE%!*1bKvX5CSM8i=ok+&mOQ)6*-EO^($8{=kRm6(Cjye~a!1D>n^u zkv8vQjd^f(wZCGG)D-Zp{2@KD+2cc-N&othjy`2a$tY@!JX4S`*Q+~hqg?-&ip@Ml z?IivIEQdKzCFNF!dWPJBUIrdPbIz=R<9tEP%yq1GOYRXEs{_u|96{9r_cwq~-UDp-U~Szm*DcG_wt@7#1=49FJDB#=C+@Onl(I7HH@mJRvo$kKGcHw6_JM}9mG_Wbuup42 zjv4sHk7g`ZA9Jq|^Tc7U*{^tWH{1sA*$v+*LhI^>vTYg-l^_Q-f8?MkMqF__Zgs$2 zZYP%wy=ZMsPf|w(O1>&{nsK^(r}|fbhkD&IQ$+D4xtVDFyQ@xc3>9It87Ep6ku@^A zFfp^k{*uX{0Uv{!B&Nwbf3fp{U zlEU>UNvCp+sOMfzfB6f{T$^Y?krnSY_+GckH)1a*?GJbSK^5?TEVVz3NSy+%*qn>J zO(lq;G)b_ZRC0(MhwH?Qn^N%BQpsnsPWtesC~+-H90O7UTMpiP)%O+la6Oj4S^h>o z2ekKT(u<;&OR`@f#W4N~@m^!q$VI%s^1~4;Cp=z56oWr*bxJ$wUhcec~xZ4!v1PI$t9@< z_Kb{XufleJfmiR-lLZNQ5VtX}Pki9F$W3xtjCXA#o!F-XB+yM*6p2e^Z0e=!;?OtdZ+u{AQqoC3KE@K2E%-yN767eNo+2AtKt;eY8)IL-=;a}H;b zVI~z{A~ty$+_~H2pExGS0!VJJTLPanliTiS_}nI*YZI~2)8Y9t*$*E1$MEVM@-ATW zBXB1Fg6n(>?#4dkS|cC9nVcgR;JV)?JIDc;YrDy5e??x6M5@V{ZM>o>4G|I>n7BeHg|^1Ls&M^0EH)KRR(w z$c*+O{QiV2zw)TO4Bnpr{{nkU9ELOgCpk?%g>Ns3*$gMeo*>|-v%evK1)2C#?2XYU zW~*I-e~~#PGLu~t8Qi`S|6hh{L%y>nk*h8ZFr zt&WQl)Cbb_u~_pT&O ze<#Vy__nNUmxr7QZ3)(7Ws@50kEw_fo(a6-&0;!aVO&=Oeb+6^*Q}FvDaLaLb;YDT zH@*6VS`J6r2fpL`Qnf)%&eSDV{jFd%9Z65Obmnce-weq}BVdb8x>Fi$UFsUA7;jxp zZ`OD7XGlMDl_V$**q$(sbK3zq989;ue;B?-O;dE^I-{c7x-{5m@A1dV!a;|~J}#bx zy~on2=q^;yPx@nBcDRnXqC42r)3gP)z$pAzj^6x8m&+eTAAxKB8Jw?dU4S%1kG z&&Tjjai0kuM=!`miT;TFN`{1LRV@fMirV&GPd>?Dtqz}Mh@akvs&(_|$boehe<6Z@ zMxVocqBy|Ha18)geX?7{H2~xxJzaU86f)oDri08kk|z1fx>qyxpwlzhW=AicO{&D| zASKi`)ipqRI^=1|;4G8fGP=bd;cuck{W&RnKpQlYHT7##W5{2b9?(^9$#3O4NxR*p znhzSMn|x{hnPX>48{C8YBbbypemFuh;hnB?nSjlxfZ_;dehzd6$xN%7h%0lf!gY>nr`q|2-jf-N-4P^}ilEx7 zCQ=etJk^W+0yQ9 z?To8FZj9GIPqlBYp=X6&V%E}sE!RwqMs}8P+fW`7v1YiBHR6`!9n9bxSjDNP$tO&&5M8jEcyTROs> zpq^1US3N`XXmtlNcTo|(e>=`4Y?&-Sy&bD_NlR@yk=R1aBAo2<8ne<1fKmaH=VknDq(%91)62zoc$gpF~^Cr`b2q^;a#=?aCVa}7Fp>? zlOY@VrIWAcKV*2fLM8BZk+5aIkPcF!6nL>F@+5txbIb5VMZ- z8#ad9s6|d42Up89$in4+A^rSJ^<3*pK)!A2M==vr*JC-t+zf1G8(5ioE?cg9n+m|S z`YlIPYjatt6y#@xr_$)EnwVdLv1LV^bP*L`ZgMAi;y6!I1MmImP0d*3-k>;EW`0fg zFx8q>%014{&yTD=e-;i)yO8$|{^!xNjIqcPse3qofhEjbXKqq2cq%jZGdKB#%uU(q zLIsR{E3yh!{-AGfI1*k0mybU)oiuC{*w<>bcw$ z%paitSl(l3!7=qzI?jVcVh(DY;t19t;A`e4bJLfgetP`{e~P186>%97B@zA%QZ$9# zOUzVj=#bUHFO=WHx>ibp{n{vrI|8#XFh5xlz^VyPC3&g(7&Y1z53@z4y$J__3ioyPJL|O8gdX?rz=y}kMT~vf(v{a*iUhkne>>rcv23+gXKQDAx#|qJa zdm}jG*8S9If4D|1>A>G08v*_|&9O9QXNL4xAziRq5#@@gK8F2Ej4|wf#gV$_@+w^U zfj7a0oE>yn(-os#`R3QcVMd9WxFw&JT(unWY{yR9=w-ouEL4)fo7rGS>$_?VSX{qQtj&5>@LnIFvfAFRNZ=C0wob%^)_Q|2@xgop;C`K?MlC$$_JXS=gX)7h|s?Du72?JHpbb z13ghSF}uYPqpHP7s+)K7x*b%7F`hHho!QwLi1wAAbX$iK9`287`*3Dqe|`Wn**r~GYnn5_UFvLi#8^^X&v4s} z(`}>Hj|@7zi|NGD|913I!O}laTDD$WQPNg_O7&Z;QJ0sgXD~gLM^W0S1M*B$j^TNB zmvwo0vtqpPORQbD?4uTw601>{r-AXMI7^FqF4Y=%6ZsLHak`I588wEA<(Jq5WQ-41 ze+b`VzK%P>{4??*%$KT=Ug&Vd;Jm=zFchbLT6xQLj+I%*QY($)jN@1>>SoduEYfXh zSQ>6?SSsew&&v_*46Rwpo2yDvc)v3YHF zmJl7%J5Si6igZ{FpSzb_RE}k3x#{xNf9kmvMk%9+A{VI$Z7+S=9*^sK#2@hjvS~}_ zrMH8YbPkJbm0-QTGtPcR6Q_wA7O}!;Q{Zlof^soRGtiR=qrAg#nC$oUM;mHWOfB5Qk zkE|>4=5mZ{tosRh%rIta?A-T0o92%~{y?fpy^6UhbO;w%Ex!co9mv@&y?GT>tm_$) z!8Dj=!rXcT)Wt7842R zFPZ)^W-X~P)N)3-#31F2#)lCre}J~pgYE1Mx20PP4q1&<&^ra}#|U3q_8jCL6BuMm zK#c}AwJ@+SSXAz@YB2f{2AQ?Has5P-GqA>JcjGFfl3=d6dKS|FdUVtetB;w}s8)gT z$C}H~8sl8ymncS?Qp0VkwF4HKz2$w!l>L)Q4*|oQUnaON@6*}%8cX4h062cogqHm%Fj%h9xP&(GfUKY zLU+OH%mmVy`h=rTJ&Ekh{})QJ<_6U|z^aD5c|*4gRtt>0jEbe7w7YUw6&!Y7;6`l7 zvy2D1cJVQ3XAJX{1TgZ|e_+MSMQQU4yPY~i9N8WINLX*mA)lMC7}OOG@>cR0b)MrZ z@{bT`QkXMuGD~6pwPe3;Xshibe?`8w;!7!Q`i~3dFv`#+-L3jlq&d^b{e^i!JxjO9 z^RBA)PpRe29AoG;ji$zA+y$MBVIo^*`&GWkG$e}_HB&nK^G9(C_w zn~EG6T*&YFy+@XO2lJ9FlQHAd{izTQQu3&!nTj>dG_7VP!z^o|0`$*|MuhYw4*M0= zW#Ixo$Q!KDpTjIc_GRQ{Di4+akM~6AHr48K)y2BnnVX(6vO?cSBw)K@^nLn1-`~j_ zLborWNax>*(JcKke=2CagIVDkiCNAQ*IcSx8RLJ2J*(L!-S3apjkJVtg0iE4qRxvEtuF5RJyMMNXruZXJdVe1EE zQFDU_d1QCtK0#|Mw0#BRO>?we84`i98Z|j`^VW|n3j_w4e}4S2*kcCsM5>F z$k;=*x<55NNj~P)*0Cao&oxIc?3G|-67JXcaxAyfop|2PxWJoK1m>i0t&NzOic`+VWR}0Ur%r(kV!I4Mk)?+t4vIA_c zoHTiRf0>3&R{=#%(|(Tk(kEsG;UDVE4GroU`nrrW>x;Mavir54E5?&|>Rw}I!mHt( zA|K6J!w13zgS7l3_~u2q1*NW<4uSWFb^S_$E3%qqd@j1KW`U(W+aq_6B6C2mCuf+~xLMe->9%vHl4W7Qe(D;r$wQcKtY!>1ulZ zf{exdLaeO;Oa!@ZjMEWbqP#&Jez zHp%%V$#)7B(k}EigjZRgc+|;qt7QS{cK>ofB6#Bdl%HAhHLf7Y9f8;UIbtu-x2)5Z zg!F(!&U<-9xJ_IQe}g1Epw3E5q%dncf8pB}#Q{13~65Ind0@s1=zn^$DfA~G!h2DA40kdtg=FyDVTR#H5jZBu4NsZ=4=@sD) zb3JqjJe5b;`l^ZcZ%lGug2A%ssy7Sss&pmB_=45Oc&0)37B!_V$rx{p4_#;0>L05= zWsKM5;d^|LCS$xwZfG$)kMG#M#(2Z?=t%_@a?j%Vq7KC_WxQN7F8raie;f5biH8wC zYs$g;y8(=r!EN~8my1HT4RP*ihTZa8VE0xaLRx=;h#l8)9#|bXBDPtW%T3-dSY1*+ zI3i~`0{8p|IZC?8CA6cV1MDtjN-(9~dj|gmh&1is-RM-w-FT-MFQqDiMZ_%CIG3<3q@yC+87E}`Pxq5IQXi!{ zH~pDypd!+}nQx_ie<&|2I_7E@qjZ7>1O%$?mIsx+@6d(Ep1≤M5>l>M!!hJ5 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%0Dinv(8D1<^=OMNH$b#|bd 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 z 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

7S*#Q}DH*W!U?D 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

(pDxxH}&m<&ju;AZW=tKSA z!M?7ys=C3KI+Zd%RFiCms&3;C-G4!CF^x81iuetlp$D(ngcMgy)^+aJ_(XApH{^T+ zsJr$%s4Mis!k|q4>ENuLUU!l$hIVLJcK4=v0(I{3xgUilYX<7XXMtjaeZnc?F&lk< zAzIK_G^jMRA^ zZTC+y&uFhF_MvSugl8U|Q{3ZN@hWGQ{ymQC53$I;km=as^}~r}6LZ!;lW;AonegxQ z%iLcfM~t~uQ-i-Y2Vx2mk0l!h`J>5y`~NcbE^tkqY5utFRBPL5ojUVZmzgegI<2&$ zou^%=?bQBQ$EB_oIUzZbLrh2@n1oA+Tnq>_0-_^?AfXHqv|C4HyenSDOKfMUizsTv zQj1z0ycF3AXq|03wkvVw|2)r0xQXqW59W4q&U@bXd7u09eFE1YJ!KxmA;08*%ChuB zLo|?}A84@0J#~;DzMo6EpH|+XE@b9!!RvG(ZS4RXT3v-6Bitl>DDcjo&G?c-HK4)Q zkzdoNgZF_SG@8Z1V{nuuru5X;`}h99e$^Of3_90R7|71JH&d+Y9+^LICW-xiG)o+> zVE=e<#BxU1PG=*O;cgGiuebnzzA$y=$7rSqzaM;7s%sqSk=wTB{J=Y{8SklAyMi9N zNCp0bgQIM41Z_C{gmwh9xJCJU?FzJ@BIH-#+*NvH}=q?kkn-7B4`$=r<{&Dqe6rgpx*`+n2XEcDjl*;5q$>IRi2^5o9lFM1WET zB3MJapM5`il3XR0IOxm+cu$1g*TTO0pu8lVv&H_*suQ)%LfPB@se3bbg(t!jvBcd_td9 z4e_tIm|}TU*|RKeYdc)z@eKI#N76e+&`(f{_(J^FI#D=eooJn?SZ|%U=EsbkSl~{~ zKVGl}n&vA^wVBCEs~k-fyV)<4j(dAfcSt3%$BXUF4vu$Du1a zOeZjm3(QfOqQhE$x8m1|4xt*)@F4VL&vGwE-KGWS*-M=yhV|d;w~n+sh1=jaKMS`| zn^}fqJig>7uu&mqCOb~M5>N(pOP6!QaemPbw5OylW^6;^vIS^g4$qW1&KKNP^baKXc^DaAJeJn6@jKL$$kS8xzz%WPo=($D?86v4`YPXj22Y>`7ej^!}N zaAcgtVD3mn{~XN`9%UQAg~z^g&pc39<6t+LBGLjunK=jKx;2;f4)>4T#&gvRLA*RV zTRA_g;U;Cda>V19vk`5Z29%qehs<3l>QR>3sImcnsfqHfH&G8m#ai{)N|oW)WFw{+ z5+b#GwR`*Zf)PDYCG&8$WF%85AlE9m4+qXkT$gT~C{?yfp>m!?%td9IZd_bP`7O&4xfA!#;m-S0K@@)?8)v91L=0M%q2z(@HKPNyie>Q?C zQ$BBf#Ul{WKTZS3*){##O7?Una=coeqY=)HRwW&wK0a|W#aME=QcfgITQi@1_QM{O9KL}~_ zP!eB{Z5OU7u0o?Y!Td0J@6dL4ag^yGQjn%_w9RdQhCNFy$XV;N^K5Q7UAV_FkNTHa zwkiG#zxf)^N%$L7zC>qv=ohv@XYj0?c8jH3ajYS$P8hh#z`szZ?RY9$SqwGjG8Ja;HsSH=?EOk_+nW8&?0m|O03V0UERz8U5 z_!#wZ%2pwK(WBHggeoB6GOc~=-e4Wr2zWo=TQQ>0^~+nuJv*nks7G-R%Gy2eiK?}- zWvHOIaWP}gd`L)NLLdrO+f3udJ<M-oo2habd8rp|xsP#0 z8}*BE7gD}M#yw+y8p>-vTDEb?6lJPCOqh@xV|Y#%o_<=`Zppw^CaSUVSbW-@yhlD1 zW|WpukEeh(O&WZ?{2H}~v_O_fBSg4T0+zkVd8Skc6eCWEe@eT?@sRx)Xk-?eW-RWLekIj=Z*?AVV(mIr~Ho8OhVV&cDih|?N;CxT@sQnp~nEn)l z{TY-({_33Sy5y6Dk(PbAx=#Ot-nE<*w%re+ks>fcVRCw$j*-%$=)R zID=#x*V?zpS{U_@#N#SBSLNi;e2bcCuzBf2iUNvtIe(1v*;DeD>N4;fpEF5tPSpXu zw&#=HARjPc`V7-0oNp6$meP6{4pE0{!lA+kp4U7= z{lf6~+zkt7^F!+Dl$VX1GqP~BiKxR25g^w;CV-sX7#%=sHzD=Nc=0W)!$$@5X)n_q zAqdZ69C7N>KYPlf(VpL*LC6g zcOg6Xf21{j`CRi8mZ`|E&*g@T*HCs0S`l3B9dO+JG|A@ZSMYovyF-%G^0KWHwe>Rf z)?7xu*;#%S4iQ3$)~t=zWIV*M`(>2e^NLH!>J_blF}e|ZsUs{#Dt>xvF&LR$3eHgs)1=I8&mB_qLxcuokZJA`e0fXHfJ8>@t*>#z?d-=1_E#X8rXz=Z6A8g?MuRhlgPB|d7Wlwfl>Oh*yQTL?iJ@H!g4c)~@Ul5e>mGg$0k0&@Ax~U9|=m4Q!jJAWL^y9N2mIf z(F(Eu`UCe?IxtdC=dk;g@tHFQ-G}@qdqYZ=EyD9eqU@vd(z_JOLL>UhOom3~T-bxp zQBd#9Agxu^9`jYcEfUu#j~HIn7dx|36HU8T8y!zu+s(6zf2eO| zH`Pp8Cpt&ruit`w+F0m_Z_8e8Sf8eY8_S+B4qm&Vs}~&SQez|xUx|VHmjWIL>W~#B z`z=kB8CU^@I46XkJkq)i`{Pwp1oWZ7R5J89`5f|kO4$xtD~&_(UzRhR_1gle+fSgtW+eF3x~2DNE3K{2zG(Hft;yZy9VDyp>^Hj zISPJvt2i_}%2_hc9u~+1Ew-GgQCC-4OoYO;R(+rT48HsVMrs+K?aQ z9MYh@*$eCOy0g%3>sj_c(5;zLxM#@mRrlJs)Oj6g>z_z!xW%#@)U?r#e?l%_jNCF8 zM?Z&tW2zO`r9F$gmpBX3u$AoG9;)-B-?&BMUp1R!|7xBk9CBaJe^R?2d3WLfHf;eD1P8Yxi58QfDQMTb7wRueP~H zU9(xS-Z^RYVpFqzu@ovCf3iGI$R*b4Zc+1dxT$s^uYSv5M5}3=;sI?U?Gf`==AF=B zUIcrbqg1a8?WLab4YZ4D#t0J}Pv>;OVK{1>D}1GXoJY7)H3lwNUVzV`&K|njrwB=# zkr0YH_A;&6Sm>CSG}&oJ*|je>yfBCQD}q-c>hGlPBcu}Xq<9wff9^IoLte49Z{l4o z7jG@zRq)CD+4|Swo83zipEPxqBxNR>s5(kgJXxZ}t4H9qVo|fX1?J^*p&e<KscSVg1B6>o?+x@0UOkqUbQ>s;^QFfch%_cGED#*W!NtX0UF|QB0)?d%ixBrz3QU=A5uNk6GG_E5$YzKr&cf5}f) zje~{AmwPOa5E>-v!As#3_4bBLs$BrD{th8$P`^1wam)k%vfq>-E$VJVy#z^f@V8FR zxM(DtGOCXx??IZGI!h}$bQ!{%;LA*A3=Pt^&&oOCuJ;vJ8FQsvD|w92fOO-P#>eiB z>BL|Em9!PKe?0wJs5M%qQq4r{gR382{V>|`F{)SG&lK459%FB7oiIum1s#jW@NT5+ z?d=>9Y~hTfZQK*|6!ncoS#u6{L7nOqdzjKBek*>QW)9m2&R~tvSUYKT}NzWy=vxH)?WID)vwp3#zHl)w{*~ zxs`2bMWsP~iHLki89+=*XVjVdal#Rh0}ED(ubWot-V{nKO0~<9pk1j?u)eR$fE3-E z?#M#Yf8d(n24!-Oih-LRqs@~&EB2-0Gf-TXgDc;sjn2MIzMJHqiIRRXQcOJ|>IQVF z1m`5^E5D_!sZmqkBGv?p?-wtoU5dx|t~sw96689=!SZ$;%X5lf%(-7zBf6Poq`?q&khIb1`-O0DW90Tp%zRcw1bDi%Q zXQ~fNVOnoVGjpRtTq`9Z{|2~sL?D)_2;f)+E9d0rV2pEq|EI(y$4o7BFD@R<=6YkXsEzNC&Lq zfh<+8>=BT6O#cyN=Ufqfr}YYlppP={;6tRhBph=TaYR!(?&+PYPUu(1z63&l1Urdy z_H*#4KIWT!DDAixiFLYlx===_f7`~H8ZSzVrO<1gE{#u5B_txeQ|cr+8|6%QZn(Xf zvP5I2QJ)7{Ty{cD1EXd3aSI-)OUPqWOsnzhTVXrPcB{Iinjn`#Z z(!JVG^PDIV-5{dc^Q$AmAxG_>29oM01_ZUrH<7;@X#^wJnS6|y4f5`hB=Cj4e zP-#s1Ttsd-TE57e4S&lG&!KFSSs>?rw2;ppP>-|wdXwRfbq2<4Zu4o5}9B{OwF zEXA3gL%lb1!($idZd=0AatLLQqrv;p*7S2-7T&AUsgGUIMyi!iM$(C} zb@Jyr$3m}Vtf*G4wY-pCinLV$)XDmsyOq1He_R`8{88ba!aatvfBd=RUkJ#9be0xp zfx4#DXHPEv2#@Z8mbAyjuM|`Tk%{+HMJOi75sRrG47h9^=~KX~>E)VDl6-#Dyd>C0 z{FqVf6L1E|A1MlDQY$P2-!jtH4pdjgj?y;jG878!&dOF@hPaOV*zd>tdq3|*;@iuf zSZ#!Xn#MrYdmzs$e==at2Kf)|r+MrXO&R9d8|LSOVAfRcK&DsuRbdj|aicrLu$AO} zZ8J%X+Gf&Zpb4euS=#%xVU%?T!J2`4BX5bk&ne4)8boI%>$l0ZthzVh0OeydP5G#U z7D^Z2n)5N8rd>9V&EuRXev|#B*qJ_6sMck~+%3N)&9d&Le+OCr>gB($Y&CV6PL~$I4wB*I@4+2w!}<3rSBUEju`H?hBcmO{& zfpgUf36>4*{N~Ln(`6L-=@Fn1nP-|pQkmi zELYDGJGIf3t;=>>rV@gZ`f=r4Z{#d+b$*_gwouofu z64xMge6FQQJ6LxF_#_ zks4jP+xo1mvfPuRg!4Q{e7!b|yu`_As^{&Xi*$XM{iV=p2V-P$Y;9QiUgA8|mE3W` zae;Rw@*VdBx#8uvTw8M6$ZBw`DG_r|Y9@?|f0g~YMBAlX3+mn9pfov{G}-tZL}~YD zT8JBG&(h(1%X>k%ot!3=Eq#~j6Y)K9mm4|MmHsB&0O#t5_1g$HN$&MW7)%nxbtTMG zkJa5)=HM|2DAR7DrRt-eN64oo<8zJ+hK%Hsp0zlhaM(!xT1bO7To;tDs+E@2Xiwa9 zf48EXBeap!+Ge~TC%i=*506o!yv;(}mO2t`fI7OWITZPQ9e77Yn|}!1X}^Uk;@Dt| zU4Zg&7v9N2@MnKpTPt=VZ5E)F>eM_h9I{PD&fN`-uJ@oLD+1Ch+R*Ag1Cm=5ZU?$~ zQ7u__;b<@zGEnxd6duXzLjL$UUL84+e>U3oJnT@7LHbM4^gz|`g!@?zf4K>q4do6I zexIF(R#!WYBtyv1FLqqW4NrRvXX(>nm;;12O%kvvp8AJZOAr-kT9G^d2 z-)RZxF4B-lR7#*4XDe!He&|wPExe0!-hdk2c)}!DbAI(dBM0e)c-5npMW~Z?f4Q%V z*HDIadGbc7**Db)P1G|FS8pHZH|pVp@F>zi8EUN(WvDUU<8jD!MA*aZVXHn;yWWW) zeBGLPNs|><-47^2qHB@14kw@Io`bT5-;S@Z!!D$!Lh$TSf(B;0oO(NO6HZ{ z($AyEfbJ@dcZYCZ%J)auys4k2eyY7AR2yFts^hxWz7ca5TF4vcSxa4p;G+0C6x*9o zZzo-lP)z%{!?+JN@$78C_Y`L%H1aDb$@=;q@@Ia2eUj}KAESEqa;0MjdyY@+(oh!nHcUo`iZvzrKo8b`W)MfWEjVIDakyXS@iqD%;S~K>4rGRaXg} zc#Z`73}YnzT7-7Tg_34fyFFCnu+K|~6dq8!V(vP(TYZWGywWbH7vI9?jXY8xe1P`W zHMnG-f$zHTs&k@GTcV)@f9X95r2MH64@vPp<(<^Y?0HfOkBVx}zVyLqIF6PAX(#na zJvOvIJ_A4MO=KNxPB93RIOn2=yL|OALUhmDo3!S*4&3j3Dlhp|;cN1cN@dU|PQ*R4 z8PDVA`8!UUkF`DaFzll&5jdcH0eN5puMwSXKlI_TO-S+G@y$7*f4rZ16d}d0ab={8 zC0>=j3RljCJn8_x>w~RGXM}vcp5_|Q^C#xPJE7kCDvrY!cM13TE6Us~x6jIm8re{uw`_jSrD?ia8TXNd6D6ZqUR#rSYmws1dY3soH9Zmh#qBK**L z^;JB_*Mu^Tvhp16ieqrV{Q%PXG1$%&v<+v+hQ}Phd+Y-P@=T)PKE+i=zNv#9I+}^? zNQdog1yM}0kGslsbG+yz&$N%{ZqxtGV##g8d%J{xxIQV9f64dcoVMsECa*#?d1I%e z%-+Y@!hS+};+_7Ph2?f8)Lh6WXEAQh=-QA)g6nC9VVdvQ~0+_fe+OKjInAGasNeZU-mn*Tl2w zi0Ud(SC%97KNYWiH4lsM{=MEw3LN9V6FszmSbnbd@cw-k+FfGERy>SbH= zceI0)a1pO_i|&o$@3@y6aI}ZDEALqcn=>hcX8arXE5n=!04DQ&dlypU&>oOi|E!H{$3nC_0eVx(H(tSBBy+eeUZ_ z4I6M~aW+xH4e-5B^YZXFHlB|&ILb@O4r4XGrcT#5->IK6_0hbYW~;l$bQw#BdFXrxgJ=>3PDy_s!z#$&j4XVr&O69dwUcFPsx zb7*ny!g;B}U!H+Fj+Nq`Upxl9xexI5>ybk0@Z7tQ5>LY?ID^}9H81fR?*)H#72cB% zIUjieW`RODpFbDZbQwg{JP4%G)19`$NBI9Xf8?58o(<~v*OEDhdrt0vO{f)p!Cb$G zCBzN1$2TIKH*w5ZmeI8T>yTT1&2r^5?(rM=$wo#l{WJc5Qg;=bo!fbb zHsQlYJqZ#o@;ny^rKO+15zi7_pFUv}G@;z5%7;He9s3{l!A72)K0L=!AT-$nc-310 ze>ruD`BNXETj|E(aa%0Ycx`X+4oyOx>;Oo-le*!M>J_RJrA!j>o478#;%C{8BGgON zF6I{d@F?PjefrfnGsl6dOl;2g7LT#d(7!8%N}+hf*U-1@1!!M&N@-7f4F6wYeKPN) z=Vk4F_L%f}mQa6T>%>*3R&7g9)z+rvf5crXnXOQ0UaY#BmXq{G#w)2#^;k32#@^y} z+>9&n8Sctm_-IvT2s4yRU>EV{ir2XJCe8m9MltDSJ?R){Qqe4Sa?QloxGJA>B>oE= zZzuEBTLF&K%iOt#xnC1r=^P%>&H1=;Opqk`F+Nup@-32a^jnf!pW!io#McM#f4c_O z6TI-bR?yyaDg8Rl~)+Jf!%(xJ$eq2ZR}#EMbEERj4Ywo71ITBiyb$ zU3gbDgI>e2$|aRcw9)ZXgic-s>L1yM+VNqQ99Njy&M?0_#g$Zk9_xObnL|j6a<{|N zcx)Tf!^b#U+C#m($7pT{k$^_pe~xrQGN>W(k2t$u<9EA|f}e9_INuWvS@Wo~D{7~x z84!xPA_}#Q9^;P`I)yIwE2Sy+CG%HMU-dH7E9VHE5fy6O+g|3-;HRNjl6{DgjELg?Fl`Eylc z9E~-4#eXFKtmtN1-=e0P)B6R<+?C+bphQE%T2+7(IkK)x@>j z@~-r1d@qk-3(i#we~#!V&ePXOIUnL( zALBWY<^FNjN$PP0P@PvN`mpvRYy09cp6HZF=*zhY%X8b} zr{vFFvAyOpSK0L84y7}H40FJXb8*$Q66c_g@hgtuecaSW;|NGYsz>Vl9Ow8G&Q~K{ zs57u*zvi9ghhX25e@>)IdOpoPLA)FV^WmDxJH3Z8X<0h@I1jFmr4H)x?mY8XN-NUU zL5_=Ur`{jT8IR+fevCV}1846t@8pfBnYZE@t}=)Cnh|++;dt9{75{=etuG)8THq+s zLw7*m@8j9~kTdapT!Zc7(G$w>4m{h}IPxo~&D`YG>t;@Ue~j(*de*@@@t)6^(($Ut za0L7KtaYrBT>$~+t3eOo}9qQ0ZfV&s%|9RFS%VW0C``epnJ6u-imJi~TK z9Ui#@@Ae#?8!cSC-)=nm0DgZAf47zAgXH2-yhG}jOLc@7aI7csuCL&AQ07=C7L6^8 zVGX;F>8Lwle?RV${rKt<9=Q$A)eC>&RlC8O%>leZJIk3ayzd(<)w+=H_AFG{q}JW?;ae%7CzSo{N-snN6rs9|9LOZK8^cxf6h6s!#hJ6g&Oklyu6~DeDyxK zVaZ_JNxI?{p0QKVS6ztLzKm8<6CXuf^(@}s2BuDmilgSvmQpWk7V?b9oLS~b-Ms2s zSdz6fSEF(7V*XvnlxxdO#=UTXDd#eeZ8vKJ?Rd|h;e3D2_rDc?Nf<0`xIR=d*vNaK zo+(hKfBe3RHr6j1(E6VNe(tx_hQB?HzuHbaKKVSOLVN~&ZK*?49ONd}6S^>-RcyYoG~%Y)1-df<k*EWk1*DOeIR=Wndk&W}=+wQRoWScGMZwfx&TZ2lO#&XVu zpJNzpC0e+w-)0F*)8XpOLVkV(+ENU0e_gI)_?sj81e8~3>AOW4lMwIeICUkXoa3b5 z#C2Hf2qT&zJRYMXLU_y_A|vS+tbn7Y9M!|(HO-6UCzi%jH%npKieE4OL20ILCU@o} zF4$VgKp<^ z?kBemZfIWg^x(`op+NjLb>6B|3E8Nro=RQ3>XakHw2QD-XjhBhBDJDWg~lCkvDGIR8ny+A!6Y+GbT0NgawpFqQf} zMrph!FMn=am-8h!S+I)wzfq5F|qHf1XgQ$xw+!2$c9yWu|aBZw2pfFVyGHMecrCMLo@qz!BA2%@nsNe!J=fe>g|Y5=yf#SGE=I zfgrx_NEI(~=8^(}n7jfA@Ew&ZNd4Vh*CS`T2D3R_NYV2Gu^Flr3g&_@<-aPf3!~5C z`ccG#RirXXj~uNlgJS)r_@_$CV06MbLT=4IVfZy68$fSvIdzC-`Qtad3hyhUq0yC~ zU(8t?7wFGaD}G~}f1LCJq*qrVC0_s^_cA)i=xro__o)x#rzc`x63)j?w@!3Cv}}>9 z$N2{1N(|1%Ea&Xp6BL!gU-WRlqaO0h;Q1N?wWCK+wtRuy{|okNQxBy2;WK4$*+Vm^ zA_VO%*KF5pn8nouM5zM(U)!uNs@={W>{O`oT!-OxqQxZ%f7W&@$z)ebApfcg^o8={b_&4FCh2?yadCQZ)E&dcLo zsf}9mkUKoWfBt44^>P})r#EtyqAxj3omG3!@gsdULjG#tY^b9~zTGzjV|JtpTnSfP z!&Q;P&+Fs7nqKR~>~EnS|9srfL{&4bsM9eD*Xvl}=oB-~hEq8gZsc7dtY6}t$OVqj ze!bsp#_rWUnmNaADoD{rBfr^7m5E>zJ9B*QZwmgLf8!G(#R*iyuMEV`U}W@Iq&Jju zN0KI&-->%;sd}jzk}Rufo-?_&M7 zq{$u!-hDbsnNHM`FM>Dcjo(lD{UqdYy--XjpKoX3DkiBO#w#nKTc8ds6HfeI~sQkIcA5o?i<=@(un-S&Z(*1PobmL67Xm57? z!4AUjV=i*d;~COpDZ3P9Zvw}aj+gEwEDqe!e>ZUtA43g_{9QOB6uV$;SduZT7@zlj zJf@2gmU|iPw+Z|K4;cA6s5{viJhqjqXzE$t?d3|ME9?>8fWQ41&q31sQ>slDNbe=D z?I9pks|4KrKCZO9h1WO*J`?GisHMhFDXinp-e~ojyykDA-J}6^*%R&%dsyCWyxIno zf85bjKWTY{DpuSf*|W-TQ5S5~3=-hDmipecSsrnV?pEZS8(HtS!%53nls{y_`V^v# zP1tM6;;<#Bya;+v$^4_C>eo$^*=mE z!B_RNatWO?#h_4VDZWUW!WTkW0K*9Ne_W)C)p#DITNKLj@}N=mDn(?(ZwmEsU0{nn zk(LwJrM!dG8R?v)-{kr*RfKxyF^CcuATQ~bLS@aJy^o3o=9o^{?lG2#1*`NA=G`Wo zMctc1r{SFVy5VmUSUtrLX1tP}CsZ#oq&;hYea(5tY2_X3aXaYN$1boWn0CcIf3X&y zDH9}nmOYH}`DCm_wyux{@m@(kdtYmIZNZ)C&(-5Pohz9~c{xbA-Ebqi7B*8h4&^ax ze#WzPoT;P}CCvLMeK+H3CdmDw@OWJcYLKYKHRulN4!T3+Iv=H-<;W@c0=e*6?iT+k z$~Q^5gl)oua-TiaNwy)i%}3g8e{hH7KWEvmpH^K}e#}g8H4zPR zUJX_DarY=)!g3#350F-Rzg|!Hh;JfY35fT@%6emJ(+%M#;X&cLpj%D1&_= z>Y)Qw_$fnXW}xzo5kj*5f8PJPxIas901M%MeOct+lD@LgC2gYIh3I~jY{$MZnlIi&t9f^@E5GW6#Z%;~>}kvhT` z-;>=kTxJi!8-4G62-aXy-Wl1BP54~Kxj)nsVn+_q6KSA_gnE|Be@dn}T1n#D!D`x) znm4|4c7mvL^8bTTyS(teI9fFZb%-Rc#%(o>BP7h!eL|mhujVD_Ry}WRcfOImT)1sL zEIcw2t;#sPTp|BmV;DJ~d^oc0@Qg}Xryq*sqh0-Q%q5}Ea6UVab;XhUO%1Mtav`@# z3EVqpgOgNdl;9zme-Gwd zL2>y)%HKBCQU?x>eFiCgB%NyH9rfMshthWc8s>#)&1LD8e{GbNP+-gYyFLqNVh-vZ ze?m>+^UVER>Di#VmYk;0fh#y)`EzmpZ!lVQl4+OWZ*bV2&XqC}>=0kixw-fUFgoKE z&5M?$7LyzKeVnf_M(DHFIojg7Do>>t=pjxZ`x<0y(J11s?vUJYQ#ffg$nCrG=f+a^ z)^4E_&bq1Ef58u*q$Z;Ma*!|#ppoin$s5o8&itM}%Uqg2B~{_y#P7}2_1$AsEu>uX z%2x0e>a}KjGsk(VaOA$)Fzrt2H3@#S+7kL}#ZhZgjTts~zCbj|%bs<)WAxxY1A||a z1|{hivz5#>ytC7cUiLvX|6Z z+boU8Uj%C{1Knavv?yPmqG~cz7hF=0O>Nb@$UP1Gm2DiyzY>tFEu4e#VZc`|$L_iV zoSAwRMGSk;SR$yF79!UDn6Ee|@J-R6qq_U67U@xsvm~jh(vWJ}1C@$wantksKy4{k zFIwIOe@VMewbqru`RUZ>$Y~JaD6Y-5fJ{^jx=#h4HTZ6z!f~JuH6rkh0tR{|1Yeac zYT_{kM?uVno+^GK5|Y$eg!YGLDOHV8h^DTXOLE@` zFxN!ERXBm;-h^{}2C01)M^hx`=F2!5v=7gJe_5OWhV13Yk0T*c^Mdtr7)>!_%@pgC zc;qGI)j>&)BUOzV#OoFb)9`%{BSA#)_(`_-V;>Zz3Fn3L8E=@n46ceci-|n{={um* zdOWMtwn#Uwc&;!FE^DUfX2Qp#X0r#Zo-65(5=J^KMD4+=wA!D^eFOSyOpU=hVyXYL zf1$Om5$ddjpDK?qx1%+Uf+)1pC}*GidY>b8A;-?2s*NstD(NAPM??x`sW0O!%T-B3 zbOW4^2q+g$;;Md+loAf9#<1V;e%&~~19OACos8EqvV@nY!dYM3e~&{eU-{m-GIxN& zBKz}w2h-iaibW36+fo9Q7M1OY9?z6Fe%aGsdL*{c4 ztUXK2b!80Q2(%y0v1cq;_rHOwe|)M=sZ5chgXZ@Sq`3A zLMwr;IaJEF@NQG#yCjr_cFuPp%pQ@W75-r!7CL?tp4pG~PZ9Jc6^XBdZ^f@2^K$h% zJ@~YDhRtgP-a{N~fGtQ*E%q?v1JqNk9_i-3+M4)Vyy|cSf${*Amg12Ee_S(&Cr~no z!sYLzwEw~R8Q{ys>chez^2{$D!x@+SX9=@Ib(v)f2!mU@)AcIs zrtac)Ks{h-X@M##_CeRHmZ{WF0WHZ)Xr=zjusilaxIw=VUZYAH&Wu+EzqMpYZ_(%4 zJI3d%<3_L>1`yQof5+4EfBWpOk?LQmzpH3W@j3e_ApAawqPxiyTL$`1nEgWcgT!@xdqfO*@?C*X!}KFW_SC93E#9 zWnv+1QvPEipUJPgtdF6M5DXn9IFf24NlzgcyPs_TqTE_=cG z7ipZe-J~(C)Zd}_DN96(zZ0+Mv1HV2hCbbGMTq;l=0)dw3Nh{plC8K7J5Yx_mfJ?v zboja+b+Mgz9rE-gz(VMR&6Y5sOie4&hw^(PY@`Sf^a;1!FXJ6Y)a=3apWu2b#8{8Xa;5`Bb@l#-*A_OVu0oIMN-kfusgRMW42ZDMSmdm}-oDe}?f#>ca}1L9BShbJX=AcP;mE zmQo)|h%TJ3CiaDHf<}~xb$lh%^-(6YfYa6il%-CHH`_Q;|DX6hMeZBmGt`y(csz2R zj~9B}&nzC3cg2wbp9T;w>cqEDm6)OkDG@opUCv_P%2J^T_Sj!ib>MvWA(c7pp>V+d zFC00RV@$z*Xvl5TIN}MHxWLnvVFAh_zKqsZ1J2++@QM=*E|{g6;>b3>3w@(r zj-O)q3-qNJP%muc%mvizt=EnF@?Ly93;b_WZWoQ0a`0`Oi`2*Y2mA4Oq$0ME4loCl zckc$Fj3w4p)hpV+XXo2fN{a$HE5|vHvP+G22K)>CXN`%APM+h8+gi&ZXhW>hZ0-FhuD=xVL_8Ql(U9r*EVa9Q0F&;D|Io)LyjRGpI~hFI@YVy)QFO(Tvg`;s?XHYYvnlIv8D)5@Rgfhn`Nt4U}R&yD; z(SBY8r|_J|QMdRUui1j1Y(TAae~sFe_H5E`xE7ycB2o5c*Q@GBsKz(xOI?Qg5zkDN zY8xR!88z@=FUA2m`o_LK6{8)K6uF2Rb`(N2G9 zy7i=$>DE(UK8oW|XIJW*$25(W09q#A>fI06pP9d(YFXv# zW1Qn1&_n&w>|xqyT-zI2e=ic2uj`m@CRs@o^FXb+hpGoDGNH_wKbw9<72i}Rg(H@| z-Q)p0+wVCgkDYDMJ3@JuE9eLO@4?7>5OF|$%pYR?MM6a290u0?Y#cvH9nbNOA z%eE$sr<{>v2odRKAS=yJ5jNAv)G<`cKfpB7mYhbNmwKF=$hSn-1QBbm-Mgk-!e9sb#3fa*h`D#q<@V4ASe1k@jMs z-8!-A<-mD@-nQc5@2%~u`^niHb0CNqN%JV9tqt+uo4RqGNs8$rw2+eA zBI?Nz9;5R;q*?GdOd4ri`7O6dC_xf9EeRI&(W~n>{@!dng7MtZW(@A0bp1xgvhBuV>_0C}terl>Qxv zI|8-fi0EIK(g#~`^yf~dJ!{(K08bv?O$KMPkp2ZDGcgf6kobQ+&cb`TynFE&vA!7iajwo;Ov)wDRa&Ngi!2+Q?=!WJR#%~2 zabuW_F+)?0p7VecV8d#o<^|rl^C^a|`gf$*Z2|vT1muH^&mZVPK+zzyLKM|?g?H7@ z5f-;%y|vwu5TuyGyC8R<9KgE5V?mRgrg}y7e|g}$AazkJlOjkbxs!rI_+5YYmy8o? z4jehq%Sz@J8e_A5BX|{w$Ajhuh8Fso~cE1e%>O#txO)4TpO?{RkgmbyQ%A{qP0W`3(5v^|= zi`5&TjDsW6>G!>Ffy5zE%GvM^MW_qvQR+llR@XMWJ`}2{x9_susDJx%_0+!&Wqk{f z&&-e9kkI4M?$>YQ{qIjs6EXzC1@$UIe^MJkU0NWni|f#5NwaK=bdj;i+9SG1>v6Q5 zeyelq+)$u%kNP*D9@7mfTAv%9zREUzg62iX9>r6c$=aQS>qZ?2RPAXxu@)UH}qJ8e(pp~e)NizlY3Bpdt`@ntZCs`#w z==I_;x#8sZaBZOsQtNNsqEMapGS1?sy4%a==KZg<0d`wfTf(IA+MTd zMcz%Qf~AA}cDVluA>SS1xDczBvvXH-b#D&YflY)~D`)J&0rIX>b`D`y6s$;D&VJ^l zl+W#)R1<5e1tn?8mbtKrfAdM2AQJbs*ErLYErn{P5K7wj?j5RLrplY6Y!x2lh~1Sy zr2tjGA4f`~I=AhdBPQp5o#5IOKSyBvoFBHCJ@#Z-9xwZ;FbyIW{Ssy;y>ahewoWuP zjmh)BdY2i zjN^JNO@|ugZX9tZVJ#!aYDc{=L${u6Dq$(=3iIXMLp=9Tf6dpFvl3-p&{S zv**7CpA&tiJ!_rl4lP*ae#RauOtTecU(>y*egrkdkqcf7K3_ur=pb8+GfoJJ+1otygK$hJIQ72w5hkKU=3~m06G1Y_9xB+Yxiu z<4F1sNRI2M*(?&)YnAxAzDN;b7)R7a`zw2vu@IUxQydp+n{oYn3A2W}($hYa#^>A= zrm22GSqmsbNK^Gv_Gu795jAUEQALQ1tC)*xs&+}^e{H|gMk5b94x43bQx&B(mx!X2 z8y-7d#!kw)N&Jm)U<&nxdRKzSxUyVvRey!FYefgtQN@8JRR5s8Ip?M}n(R@e#LsoN zDf7|ua{gS8(GgO7hH(%NkPT{k-mq8mBH_^Jsb=gN*TQzum69gY?30(rW6WA9u1RfN zFv$*@e-|`a+MjEG&Zs6^g;K%}kNzj5`YJp}JIb&;%bBV*oC~si(GtS<{0vJuh>F4plHG5 zxJ6y09dK{&mOyyK5|;EEQ;r>^w+NTXE$02NxUL{mcno>}q&4SR#*T!FC&&L1Aeez* zz;7dAImZDTaCE%^eenbYqu6q^j(@5Bf~EH{7>IEBcNY$+k4y@G2bP z%uQd?8>*+=A>2R3&oxIrxWF}3hjDNHl(;sbj9L=#tj_#M&L}zPj?4{TRX%(s?9YHL zCJ7p1lB(;X50F1rGex0OTrC=#m57q2f6w`P_N?TeCI1X1(Z{S?`&d3uCi{NRS5Q~5 zrQ%c6NYii(U3kac$b$-Cw#T`qM<_FlGwoXWGvp_P;c!zZ%hd;Z+$5$%vN!1aWEE?< zNMmoQIv~aMhe5n}c2H{_p|8%+o|nU|#gnMtcu7+L;%k>U?}lntkCOg`oRXpie@W(9 zs6ij?@1tkn46`IC)0PbCdKQKIqaqN)r&wDqN68cWv$N*+V^b!f)}P3)Dc7qCWZdjv z=jRIiiv=|v6N$D6VYIspzs92^)N1LdbIj3E)6;LVJ&#;{BaThho6D1mVkm!kr?vzw z-KMy%=*9Y9Ip)EEJi?&tjNNM@e@y*uW3%vtwx*~vX%2YRhmo$YK?j_R>#|N1$_hsZ zY6Pi!_Q!(<3^96Xi8||2xT}jvW+)E zWBe38uYc7EUgz0^RxQ|HVW3C3>}64K-TugVlky{y?T@YM9}0&kpBd>}e?kc#X38NA zWKbtz%D-ud>xg9w(n+YiKF<++Zs91|MY3m9E8%L1T+iooPJ;s1F(93CJ&z=)xy^w> zzHS@R_?*F69^g-1B)pmZI7!5NC@k1nbubOyONqf=tArENqeNtkh=6*V+ru4Dl20l^e<;5U`GZ-`Y(lN_4g@>cagK4t2SR&T$>L#PhYOPkLce&Bl~t} zJWkx(#aSzcl%>D@AC;Z-0~1D)yi}%A_9d z$?RXyWz;sO9s4dv*g;9H2NX7;H**D(-#e@3n zNE!IW(CeJ!PR4T;R7FCCas^byQw6$Bj%}LK_5Z>=Af4#K6SZOs^Y628qo{|iw)=VJ zBGM^aSJZFRZ>-&}K5YJq@Ncs7k!F?xAyEzWv&HkZyeMTp!++O}&=LC*lnpzEVh=J3 zbt>l?p=E7wnYtKPN6T4&j!;m| z#o)e3L%SmIxPoWqYl{Q#=>CR{ap*gW6jd$zl=LTD!OL*p4pafklUQ$yVtz0m?@5c_ zm7~-uV~UAKnSU~$xnmLKU_u0C=x|M@i{oyDr@S1x#aqlHnm9IVU|-q+`~;n{Nw zTgE*15Z3|G?9AfXh~Rp?;P`{N`lb45Bj_@N?{Y{73w*@m4&P&(iS)A{S70AL2=loO zpL;Ts19^GFJ5x#cD>=`I;-mAUYbX!+?Rd7LDL&XmaesasC1vl?{E#=uX9=yYdQZ-X z-d}v??W{_b_8-Ns6qf2&uU%kxfY2lIKO`-%<`zfakAlCLa3%cqmpGfDUVS(-8JhG5 zieCZ$;+F-~dMwd6<{mg%Sh{#j&1LoBgvgr9HJ8zXCoYE9#}P;}-INetCJ%Tr)TjKD zI!h}F6Mt&v8CHPb@-Ea1W$9kayLh*Ijm@?~aRU6s{!-06;|ICnmICNRt4Es?${yiv zVS$cnx>mrzkIWzzOwO zl!qkw^YP==~ojlbqKKw6^J@Zz2L zAb(~^CTFy8h-v?Z)db#ot|Fo-jO4)5|_3!UIWQ8AQ9JfU%pdum|%H zMFR_)HYLLylQ;wtO9Xdk0_bAm54X7mrZy8B#xCU@0lz zRTb~k_&`i`cztaI$GwN_QN?=pbW^U^Qh!2CObE4y6@9IZM(KYFHO{F}XMWmXR6KxM z&<^ugj%e7U@;c4b)r8P&RPAtF{kStDcDnoeqF#gizh#@Rlf5)%oO2Ps_mBEF@Mm8{=}j8C4=G8J`ZC_j7twZ{{VJrSGDfOtqpUB+ zr8xl|%O;}jSH~8eKbfTDIj-m=44Fpz44en*eK?16Q2d(hKt8g2C}P1eK__dcb?~{ zb)r4Y{ftCae%gCcVAau1)F)6>Z#Oy_7t?y<1=27!ZP=ZZ&6OY#gu#=_xmXQ zV)siHlgVqJN7;7TSbH;Pn$sFNSqkGT4eb+yTb;ce*Cm&=aytNYeT z;cWKs-g4r6bdi>4Sq(ByT7S2k8;q;f!Ewz9oaqFdckaJ=N%A7AS7Yo*I_1lGociDFx)Ql2`N&0}bWcpX`h%{UqD}QF)@;Gx^FIsbC z(FG&sB8;4=KeW>{#e`cO7tp3M_3NmzRhq)_B}Jf9cd*mt(9eUPY6ksscK_WBwS3dL zD|#{ihCk6vL7jy9*vrV@ZE_t1cx#)rcho;bZkJ2-;BL_pri#M9hf51k63&EqiJ>5O zQ7FXUB*FahTZ})0dVkY@R9KHg6nV-rUKvT#6cOX~A7m58du> zm_j0L&qIC5Y|W<%vAS;lZ0WMTNGMY#nScC_-}5eI{gFR=@elBNgV(8rGt(MHHQ~|% z;lmJ@CjCQcLe19x4ABpHOiM&Xi0T(y=O%mDl)T0zfjU(>V}DdX1r^{c>Xt59OgMKY zlz$R?kL3P&DsYuZfxR=h7lx=<*PLH--dIR}S@tQ*@c`teG@I;; zpn7}1{h64gjtw~oQ3U8&VNPLc>`yr1oVcQW}KJ0WI({IB&+Rjnv9Sdc;uYv}$H5r$PI8l>n zhVYeTs_ACZL)w49#l>UNr|NFwiuUHu#p^bRUx}}~#Z)u+D)zwp6?;m=(v^g`?Y>@l z3ig-fvL1aX+nJ0YS_lIpcs{ zyLi5fVV2V5`2$EfR2w4K^cMHagMqsE!GAjJ>=EX0aNX@}?ha5KsI=!E^TWm&Jc5oH zxXy6tQ#|bb>|x&pUrVfI2fUSO&z6?y6YSu=ZU?o?4pu|`ADiWna?yR zdv;`BHoa1@2d9Yf59BMPqYUHoJM|n{-49==4?|b%fJ|&*YjKV%Vbs4H{^q&_QGeEn zsM*v*y+VW&gj7kLfZVN?iN=}pXX9FbhWbtiA)X|sRkmuTAn$mF%ZftG|37121J~qz z?XP{CFSok7U3F}`*4uTmPP@}y*E-$bYZ-M#oacb-o8p9udi!7B>`m;*{+GPfhI4tV312+fe5YqF#QQb*)cDm3lhm)PFg%U|aEy z;vIu@y8u~;mXXxqK&z(ATey+sG*t*1=*^ieP9Pd~An!C~v)rpTe+Mn21{@DUXbHOS z_Zv&a2^_(lYRME;@ceon;6e1-0e?^6y&CexaC5BU=487~M+6h>L`+`2|}tM1N7W_}x5nl-Nx^ zb45!@hT=0vWU9e2D=(e;gRZ`+Xwk@0?1s!D(Y>r_zADoEjkYNMwES+~$0_#Jr?Tfb zB8%qRml$K))2OL8l>;k&;kngvBToJ40(} zF4q+zw^c=kYD9w4zstEaKsoR%&^4)iDQIvJWFx^n23Cr`Pm2f zR~mAIB-Tk~ArE*+Q_Y>4?jGR7o;#?v?S2;Jx1nfA*=licA3rUYJrb{lKG#{+XHA9z zijE5tbJvp|fi}o7v4v=0U6Q)tJr?^Qkp%YC04#_|jYwP+7`rg6@1 zGrk77mItpH-+z*It=ydx6K~Rc#94TKHzAzaNZUE~g6`~FUlQhD|G4SkyI^_0vXeDF ziWw6kDt}dgy@wJYnlt{Wf5HiO6%YlBN08`vZoglo@fxVZsro*p4mxgh--xb5yXP((raEJ!5~&k$GSgZ=ULjsX z*?-)nnIao*{zjPQ0Mrsxo{4B1*OEn-nNE^b@fmlapvu@D9c5WcD>xj1c&)G2;UV9L z@ka?&U4B=Wi8}c~xC--Sf`B@c^;evGffC(Rk#!6CcUtZiJPPGYS~=6Sf&Cz1Pj__I zD*SDpFbsNx;h^#fR2_~-$bfL2OmfK2Q-9D$V|`SHt0KJCiu zl`IafY=|TDG2!>fABH7d;LZ%hA9K@Qw3y^~%d4!v)>dwa3)y@9XLBw{_*i{NS+eOg z-=Y4fL*p%mzeQRql5j)|SeurR#Au^WX59J^$F#>_zA(y1E1Sm1!Zm{pQ0F+ovVZqM zoj&vlsZ|CNo)u~D*ZXwtFoIDyhoFR?k*6z4k8-TR z){;KL7eW31T#q>>sbAn&0P>=onVv@I(5lcLk4o%NPv?HuaS2x>KQGlgqXu={Z=_y( zmKALADZnF41hxIIY`N9gU%?Srtbcn7lC6_bFPN*_B2~FC?qD=(q6O6Jm38-8?u&k( zuX%j2_F1Tj-mu!6&8)#SE_UzQUM|9ElOXmPPP-lA`r0 zKFfp1xew|B_v4Wda)xk(a$wGdgp{WWQF{R+tx^=K7UkAS?j3N0wf(M8zSCZ~p8H`) z&asYwva5u=dAMe;aF6jT{(q}%1xPcL0bxX}66OSPl3zhjasK%ft&ra}?H;6q)N$Qu zSD&@=?Xl)HxE;rhu5ce-!#}QDD0t)S8)w5Y1(5miJeExcui}Z!m-NeU9MVEZP8<-m z^7iYKC{a`@(&K%(NTWz|^ie+_3URdyia0{BB@akx*tZ(?{KUci{(r{OYw7?FHaI&; z74k6k=PUzySgXJnk<%<2C90@yHS0}P6F988xAJ5W$v?;+lYR3Kf7C?F?<)Rl!6wa= z@)F03i5K6>OEXutinC0bO2QcVgwTX2m%pN(>dmNz0zUEg!g20jRx1=0*T79jy{rwY zOU#<3vNl;nWh-@dPk$bsJe;}14bJ-4Q_dpQwNn&=y=#Qh_Nn}?*si^s_kpZE?}Gzsu40_UBhaWx&{_tZ^INwx!bf~f`S6-1w<=Y9{@4?yaaKGg3myqc>6bqkq$*r|(?>d#2l9uP_V#?1;>Ay0R=u3HRU%+DLr0Xy!3Hix^gxe&c2Y;q5ZL#*Q`(E}WjztYc4>jE1d}YY?=~|-In)@W( zK*Sswqv#aq^o6HWW8ntp^3tj+gg+*Z!8=N`PA+&vUVmt-BF_tD%UdU}nE`>qYt*R~ za%GI9C~GtPt;NUQT)+G(^5z2SN({JzKh&5{&xvujQkUifup%DH=(o}4iEdKcnWQR zZQN_26Mrt_d^b}RVcDZ;MzkZ(Gm-_`vW|e`UAB?B*i*)pM^rJ3GvLAR+u;;m!9k=R z)f>fxMX+H6=L5Acvco8}J5$=@*Cem<{EP zcx`|`Bm8|QUWuHsME9XpSH~L0KJL)if;upD>DsExbW*)h7gd4TN8@#L>+Zm3&@4`X zs>BZXpgcSAqBdT6)c(pF)N`^6>9Z?gB2X_{@_%gdOyr!E0M5F^SDrqrD%e}6rxm#Hs z$_S)**)6Wrx(t8zc!B%KL9gnr=Pl%`b*!804CN4YG1?^6%)ZUOr~sb%DkFi{z#j<< z29Dwwf5iQlq|Qw5;yU>RujD-E?ti?4EBp+v-yPIzNCgI?q6I!ITTZ?$UmMD<%WoZl zYT-#Rc;|&XG1>Ps2FFhB2k3zt`t^A1_h1Vi^K2-ur=2^Wz0Fs6gQXvhXqq` zN2WlPk|^dY_-}mPgL@`BB2k;)2OqHg-V4#37xM+%XkX|bVK4BNRD)|6j(=~jEr9%? zTO6M>2{ekUx<#_QqU7~Pyie3FxJzO$nE1>Yg%kalukOscDtRvdM+yNT4$jrWB2j~eF}`AcvO z^x!e-IJc+)N4W~e{sLq6P=CLhowz;^aVF}1#+1s`?cz>Ywcbl8f6sE2!d@J|_uvH5 zK|0>U+fqM6p_qC}DW6OngJV{W_l2|Qn1t(8SbOWaZK13VJd74{}v5DuH<&})7=gj~@hi`X!YefmVlCy^UnW)D>- zcL3`|TB>8pxWNcNhZyx}3wL-WX|t6nxQ=mjZiH}y>KNTZ%D9$tkgEBgQXjz{sUC{Q z;cZ?I+xYh`u3l+j&40h^K0XEz*80c%-|c+1ZQP&m?a+GOir;?0=k8?Nm9p4(Bv_Hh z^zs=O0Ocun<)x#AaEY%_j(m0vcb7`S>#Jt}?jEN5>g<1E^q#%kYx4_SWoO|Co~fNB zDvqityRUn1@AB_M8|pys;Zff~s=9#Bjht<>7yr`}TGf&*SAWMSuSbFUneAnXN_jS? zL7`~LY3ANbI2zVp=^y2~&mFi<-pBbJjofw=BRfgC)xEN(P?sT$wf?-k2GTVVKv73=qy0O%O33`XA;dltYt9OHPgHpeq(WlhjcM2$n!cbJ7J!wfw!fi-GT`YYe z;jmxAbH9Vf-G2rxDD_U*XPY##Hes@5g|N#q4Ghc6^aVL<<1JHtqJC9Hz1R+c<=-z~=Zhd~#TSv5jJkV0 z;R=z4BzU|!vSnAm@zeQi&q%3Jbjp&moI zI?^>*CmY7*%qEOP)MCOl^zU??SlG@ zsUVteij|H@vQbKJS##n=-vrGR+YH0A`bTtQ(|@6AGVLpP+;S%W-{dh_-=wRH^Riax z|0U-y`lYGQDWA$|Mk_MLA5HdgMSankyd~7{NT`Nuy3BmSOleMyRgJsfiQSS!T{6Vm z6@QVQw-WAY<9(km|J(ug(SAqzFT|&nzk>O$pQqTfqGWC2a?_i%ua3LcYcG=*g!+?6 z-rJmJ&PodkyOI7o@&4k;uGX5(-=kbK$xE~B3C2;PI*9=4Z9O^7-Xz6mXg?o>Gp?_^ zNo0@b=yk7Bowj&8H^%TcTy+5_SEwRKihmKWxqe7k+J(O?Yr;{@hi0;qp+^N2cSnor z9r#KZg*4tHluP}uw0F_EItT5XVH8k~pp7x{Ul+!sJn@(`P_j{(<@64Sl;R5OcAQwa zHT@TG3}?rz|1og_sVjvgDHOYXz#8N%gGOjbaiLaqGiwE7chjCHQ7`EdXL6T?bANuL ztW6CG?c_C1xPZUDo*Prvlz7nra=YeviyY5aizD339dQEQca|KG>iea5JH<4KJ5a^0 z;6>iP7ovS)K1F;EY2&Gn3)LTU&DQP|JL(}p?Om!6N7~z6jMggBC;1e5P|EM1?0me# zAg<6rVh3siH-(AF=>nGZ1M;JzJ%7XCA^4)48*@%Ij_Se*t3 zcU@a<0$90jeI-;G{uMQ0173GK%SJ*1Jia!XJh6n?1Xja(%@oeV>B6~aB*Ye(&c88z z@lvuPDbiV>q%N2Zmi0JNErdG7Jm8Y`S1jY!4PL$aP^YLttDGzi53K~_TYs<=xfOB* z!*Cp@V(<+1^A>609Y?*WB;2zlDFcq)KYOtMnDu}EULOY;KrwIh4z!s_r|xGrbv?vh z8T3uzFOessy!*+pNQVJz!aDsfiY;=)}}Fo4P^Ds!Lr4vdHO+luC! z&ZrCY2W?MzHt;vw(dsA&<=Cb|xMM;=`p@XuGXjDJBcyv%O}_Z+OMg=G-_?zEMgYY< zJ*Ilj*^V-7Vc*eOK3cWyBltL#RD@I(pVpm^<^6u^}WtzT|)X? z)E9>x9IcX${ctLi4K+7INlvaJ(fD7aTp-`qc5~j6ihARBsY;M}mK5<0<^T1?e96-p zP>rKlkl(1D&feD^)WcrY785Qrb!1|XQh?>aQTErMHml!>(tinQK1UB9StsMUx5^@N zr^42}C9(+Lq1DvUGz~S9G?>p6&^FX6<+z#p0exVoJdYu2D=8<-_Bk{lXY*xEtE$x2tf{QupIn%+mL4ovcK#KbKS$N-R}%}+GzD1g-!$7_3J4D614Pk zOk{rFoz4x#0e_F;{_EhNYjyM zdzW}$u56{wp{O|!DoX&ZhuZvKNg39TnXDCgpjs#|`+pN0TNNX|V|y8TERh>VAfGG} z%GI~kx2dC~HeT^rsH(P6oaLG6nB+L&IAL6mQodH0MH&Y*I8Jb^?=!ql>wpnIjv52` z7k9!Qc?D%bqh2%IFdP=9v?gD`eM%jX@ELNlHn@T-{D|f5h+dMCv6{7h zTD|ld?h6^#(J785r~H19Fs7r??xAYF-E29~jAy`7$U+)=gXQC1>g0_)h`4y&nlBZE zyLt}dvidJJh6RuaC>hByZ#UKB=AJv_Wi zc;Yw`6q9;~@QHP?jCx#^{tM)_LEmuaXjz-Kf>0WY=2Q1n>JlVnlu}ka``>HfI>|fnp+p$zWFJ5Xy<(ZC}`9248&M0pkE zubJwLSF!~EgnEE-T(XDl{{T}<57Uk0L+K`+NAYZGEaZl$uYe=VB_V&ehN-o`{V5M+ zAG`)7u4vSaP@fVf6z5rWRQ~`S7SrmTc+WlR7f9PfYpfgB7iEu}M-EY!w;C46B7e-^ zDBCI`Z4)XY7yei|0@w7Uh4m#FRB@1&tc&$2RZV40h1c>vwm)lISa>ZdtE|Z)mu)ee zqv`?&h?^Z?JCbQJPm<~lbeWW=T6isSjJVk{Ra7mmUOi7#mDZSVTSn_L{SMng(|_tR z3#VzGSHCXev9-(b(=W3-bX$a7+JE(`ab)8tT2g=Dm?hjPUkB$cy;--EZE|Z)bM{TL zd5{NmLhXi$l#y3n#W{h2ih9)f8_l$bDD42Pr8i&PyKw(S1=^>eJXGet(VUJDxKe zuhmNSsJ2?_+$;=-Jh2Hix}+kh16gz^CqU{V5*>OU&GF&n&=$?;qxejS{vo|2dVn4} zP?rwH?zw6tz`i8%VAsOiD?9C}xLGGw?*Ps!#eekgA46KH#ZvB7$d3?0M+xWe%nk8!vro#mG;=Or0dvBz<~Ed9;$hmzgAymqx06CS zz6E{nC5@3DD?*Pj(nvIfF%!cTB5QcnyF;J6A#Q#@KX0gO89XE5J%4dVXl8hPW&BNe zG?M$qVPK}4#P#oAos2p0{Tho@_v5Hx?e%iihy3NIf3$1QAdSzxvktSZpO!#w5sJc{Z7kNVLWO~6(-a= zxb}~7W_IJgo$w)fH-AuTpx*UKV7Ilwd)mK0s8h=0;f6(ycE&ngrshXdw#~ZOwE4^p zs_|+LaJEekY%y-KP1goMW{%1+!9_fS0FA3+2uU3Ovrd=>9!5${z1t*e+qYltQ zeaDHXTP6wZ#U+ZDaz9)ZLtSljV;uAK+ms^|KY?Jn-&5=QN`JfATxOr;k9SN$Yw)+S zEo!u{ggZ&Gwxf9;qrUKPjM}*{C?}Y+QwCeFb+!p;2XVD&0@ZHzQk@XmrRm5qwo+6A z>GU#Zn#z>FPMiOb(ffy)%(nL#k-D~TG!Jo&;i)022JjQoh0+z_9Bp|ntqHnN9vx;b zy#<1tiAxo3TYupiT4SADSKZD&_?@tWEjBvOKIV25L!+AeI$u*xGww}Y8wi8{IQ#97 zu&+GGo_0b>sBr*NAa&6=gHrnfN(p7kkGOkwFG`7C?rJdjS`Sh70QCBXCH@62TlcZ7 zMvcqg>wPD_05oWA3}L4e#*~*JXcUMI0KlQL|lAgDOw2Gwb{QgAQF{cl2&`=0xrew&&q|IdL{{+zPS z{FTsHWPdIGSZGB(G#opV9__=@aqLbb?d;|(0*a2ch}}YaZj7PO_;*u{xs?xi?_E+>2aigd( z#TOfj^Z0H#cN-*Rf@+F0G2P)hu#q2VP0|mMD`)BSx?RXs>fnEn1`gu2x8OOIK$YJe zP=77|jX2)0Ru+Le^iw&rlYY2*r>9)_GX5E@S-nm(h5NHeo}eyhFVDuaevthy{LMbk z3-St{rvjt^y5ekzQ{Ogz7d7io@&0xj#&QJr3{ZXe8KKw~u+?xS=ogGDa1&|sFzU;D z%MNj@dTvPX49ksh{uWGMpF`(OLLO0!S9h7C(>FLfoVhZ~MbL!PI>lwo=>hl76UAo{9^WQ~)v2O(X*o^qtQ z2Cg)u*#@DRkmYe7q;R*M@pc2$rvdLQ2#b78Tz$4#R2AoWx0Gj>HIN&0p*Q6fd>5y#kVl$l8n^sL%BKHS}#+v*TsWQe5#jT<6(;+93>eW?o;fZX|gs`Ab%3nd0wCzXX;oki*VHY zU#x7kPDVceA$(NXs-?~*-hbuOEmNUKH%GscYII+HB)SU>gkjlqnU#C z!A`}SWCv-cAoaHSo-yHAn7`4Q&ENQ4iMRCg70>DmO1l#;7MGX;?)}OUwx2DuQQdc3HKb&h!ZSl=-1-B%2ujr%>S$NMMe#MJUzjZDgTq@jH`Kx1&#~T$|&oy zcX7I?N`KsaPirnN(a%QSDWF<)S$}KRE!LWSO~PTtkEOT_&eEsakM%o^bBvj*Ps#26_?+45E@)JN za)b&JFN&KfYc%nq?hejnz2Y1lu&_%SLMHPfI*ZO(zEwvMcfKy{7BhF zX%EUe72D|;!f?$L(>`&t@Tw+4+$<|4+;2y{FvI(@I8(a;wtt$bT4Ojgtu2(>X(K#b zdAvMc5tp7u=UJ3uTc|xCFN9i(+mYXcybpMU$z(;t2dEjgFrL%i((W*--?u#=pYk`U zcP;A&6zS`#h!jc)J;C=h^4jqk%dXcrI*qvGBZrraX#lB%a9wF$9D0f%3%F_x? z;a)vd59_GMS%2=;ZIQLD>?~{cML58cIe61nYpZeG1Et*=yEAr|cB`PQIcK(Iaf+Q# z4(O~6yy}Vy z?PW`(ZH8qNTHS|H2I3>@$pN;TR?y)|Z7guhxD8=b2AAM`Ol z@R_=E=WX{z0A);W6=x>gqZxMIfey=5k@Y%~M<@lNA54aa$^V$ zN$7CR7e*~V?2i}!cVRt8X3j%3bz<!;NhEN z(68bwQ^L*k(*BRYdzkjj33Ib?7RXVdgnS|_I@?#p~d>jS0 z-uF3qL7`eR9v(oCBAZzEhzgKPFClyn9F^C|3(1w9v9y*rY8vaPM=3)HIiKamnBLTy z6FbPZMLVMx|4T8IYU+bj+O1ztF%r$skz)UodLSyENFGjAo8ebRM{F1nog6~8yB{Z1 zN`Liq!b*0)TmNQy6R+qPS-(q}I>}W45o`4&~%RYK zu*N4tDPMVig8)9bepSCL`77b~)HNzpLsPH6%ewGBUaMUw8R9`g(fH@i)L-WR^ZyF< z{PjgF|9;XBMbZlc=EX!EQpN(~fuc3*dx753iesCU@YWve>{Nj3mh&XanxNTro`0V4 zm;QX{5^7mN)i|VwcH4B)K8o{-cWC!$;|p(S_Xw{ly-F{x+K=8?isP_LT_dW5R~2#o zXz=J_6>-`<+^MNH`zG}ZLJHq0H<5CVnm7=P&H&yqAePbTVHsF};U~eGt{r=Um{qLTt z4EI1mx}T8I;T+DyUVI;PW+hyq+I#01xZ>Z0_E-Vu)k>L;jr>ZTA{W5cynoeXJLMnp zJ0Q1TEPfrXO~Qov5ImNtq3=>TyMlCpI&m{qR^T~LqV3&;e5HnR5OGygCY%Qj$!^I_ zZyf{59V29bRoq?lJaiS!!T&$Ri;CBtWEh)6s9w?33#jsY)MHC1adlgIQ(8;Z)H|B7 zCqI!FdNMt`60VpkP)^jE$A4^iLK|?7F3ARua9C(`fpACtLOJ;|J+`B0p{%1m;hs!y zCubc8klyf|;>-%d)klp;`K0EEV^ZQ6-ImnYvL;Q0zn73^Adm3#Lf%WMu2TbHbd&2p-jGl+<)r;$!65E@f@m1 zvMz9p+#F2}6d{8pSz+2o{b|UPK`Y-fNt_8skbA#Q8sD1dw0HG)=v9A*d3ZIvXPr!) zKPn<~r)r*eHd2JeN&GcvSdZg5GB?52;xQ}R^0vd|8f)tzlS zV*X~sd}SL->uW39J%7`(oVf{<+eiLOXQOafYp#ey?$zVWq8PI75v@6;5#_}7B`KC( z^Eb|{B2hiPNL-RqBs#NbudFE4khLWYw2QT-db zO!|lGv8>A#^=ZjOyY9!+N66aXkodJHv#c4l@dnuA`&=_6)qfzAXw5Q_v=G9cV||o3 zAN72s8q>GStF&ghHO2nMb)VArIccS3&5Y!9c!e^p7WcW4V)q`T9(DFt@ESX%E;>20 zOBa<_DUYfPQW}fqr`XYgB=2&a_1CEe-!q;UNbdNa$-3-&rX-tQvo3p2;Qk}Xg9688 z5&C5bJ3ar(IWg}2 z&a9kX?SUeZvG|TC=7~yYR*K8wW9;Ca)J@uTrL|FF|5y-?LEPn4Lxs` zQk0Fm76o(H%ObKaYq#Q2;yg!ZS}T7R?CDUL^Na%(8ZhonS9#VFZE${~j< z3D)HQhK3?5+6}nkgc+{$*_4ysVE&{25#KXndug|!PV+o;t^ba24SJGq8Q(X)-zRxr z!|h>NcmwCa{H+ogkA=Eh6}000;d5R!TXX&Mp~9ov6Uu;}+n1AZ|6M5@&-^tE?hHx4 z(0}|K!*gC@FXB+zOms$CMw)VjgiGeX%{Vn%@%winXn!T^7LIek7SIOzvO)UmAFL^8 zBFJ(;stro0Ll02L{m*G=VRffXUfGG#x4GYO=00%08m=wuVQpUeJ`bPk2)9;Lr`S=q ziuG@lo64)qWBUG={J`0zZx?|VukOCCc7L3!?*>OXoBOQ;)gYRr{{__rnxDaL@~q@7 zQT~vS1J$piK571m>h36?g4Dz@X=dFPxU=8@XD3ly{tpE>G>O*eld zZuUhK-D6Z+k5J-kvgk6VT2}a)gyHJxs5g05Uo~WCmLku&!q{^GLk(G9#yJ&{jCVJO z`(9I*0}pkTLMiqHuSkl{SZq%6qksEvqlDfkitRW~L!rna8}!_pqKBiW)QJE!7hyD=o$~0@(G1W` zsfb+ueMOvRN|9KSt;;O)iK@hlgk-9llj0JU-V>f-)V)hHB?q-L`+u`}ACxuO@+({Y zANoZ5v!3tyUBa(aO}6RO`^$D!(1|t{qk+Rw>>JGA) zvP9`FNynvrSu&m0?AncT=>}=exKcVv`zOD$>wIM^W#^>US7z)jCGbtP?Z})9pLF+m+cc@5nsuTscbD0DXWa}NO~w= zl`9V}z}su7w?QXWW*TRNJpo8tq6@T@9)K*uY8XDOs|2fZo zuCAcUlon|4WV(`sYe)@O?(bFjOYfx+XAV~hOSWPhe>%r_P#u)<$lo5pS3=Y15hyB7 z@1ob-!}~uRLXE=zWqqTF(~S{^nSPP{4rLP<{_Kb}-7wuyjuhJS7fV^=MrW;EKJTzRi7%- zI##D-ZSw`v}x=wt`gGNmwgK&~p94_)|E>M?A{URHtwauT8-1kG$tew5JZ@S}HD@ zudT)F*-ACmc$9%S;xucE258e^2}tWEkl5jQD}-Lv2=_7CRN5M0nym`2IvtNmUC_=# z4}bEeiNgHk_*Mnv_{gB;VRkIa24f7 z9A3i^Tn6p#50hfu_Xu@S+QhG=%^#gZS%21{$b7jQPAQ&+I@EH;lLTC_iASvt_K;N# zYpJgaj&%|!g^92=vBUV&_?IX{T{X_%OYvd2f%~aK)rjs;^umK0)*1SiI3#o%=d3rv z7ruo#v#AnD(L!7qM;Em{wEpAC_n{hxk0`M{Hp)ml8Ky|;?5((?X@o6|pYYzKe`G-4m)Y1V~l`t_=DrQLS3?oO!(j+b_qc1xp?dyF&yiglqJs5Z@JU7Ym>3Gq}lu4q1< zy=T}faF!6oiGoZO+IVfetPS@0VyX5`>CJzQ5vob&gkE79Nj_m(Si(4<03V7tUj*SR z`#0i@ErQ_h(s1kv9|K3!eb2H9dK8NacNOlUXXzn*#_QOR+dI_D$nzHKO&;oTtQ(6q zCO_y|dM`{9ztoMzu?XNyQAS4+XQJHimNn3_ki3*(to~%5~U=c?-7eZHj(B3p7@2@s>tcqFn|DY*HkH?l~QQapK+RJ~};d!a@ z>r*h`UTvIX88l?#H}5g^5PC?!J{$IMZpz+lLh`SY{n&OD>7@bBB8RW={kmbVn|4tj z;0nqQ+RD;#3v=C@exvVmieWh-b7tG0LkUXRSnmw7;tvm-2Oeb`^2F#3^WoEq3h|K* z??4#CZ=lDxK$wMkiWSnA{FZ;ap$r}+!p&LiIqSdLZp4AUt^Kec>L|4vi~*96+h0r3{(c{NL8#MdVd@@id291K=d2MD4*X) z3nc*8OR{Yz$%ZOBGbBYlJfFG0KdJA%FiM9?4ta&BL`}K>HJvZ*=CLjA zTmL+kq1n4X_Te$6O@)7B9*6UWBZxXHk0PkDT*=PAma3cGMs9EEDsvL)&mvPQcdkD*ZON zl=`z`$~SC4ZR~$WagDM~C^3KII&X8vBb{n%+>iS{&uJD8d!`8`6_F(w;w-tzRY?e0 zi5E4`3%lY+iYom<-JR6fk_^-|sXF2fMT?E<4zFm<^e;G^w_R(_+n#kPrNjiOs-Md{vYEQ8{BS@R`_ZH2EfMN!GA&g>q(+#J%uf{xW zd_}!w((-QI7OLg1Y!x#IeM%UqzMX22>2QR5O;p#tH~061YCuP&jtMwc4OC@C^s#0J zY&FeRj_`jy?Gsb%jIrITnBmM)v}8qtLhRMtctM?!yomgW?@V;0olep|>wFZ+|T(O`xi zb(acoRs(~wDv5LUB-|5kqn)2>ovfQ()+D?tFU--~b%_^|R;Iw&vSzkix;P8Ajx)#W z;0hrYLNLJ^qE4h;ztJ-d4i5V*?2WHTPbfv*7DsohFpcs{jNi@rJ5^1aI^=1>G|L&2 zjp~2PM3rSKy;7D1RXG`-!ZV=;u71RQ&z*qhMyuL3!8pe!8t15|3&T}ob7S(CkS|KV z)Ap42<+7&ajmaCu%}C9gy)Ps8-{F`=bi^b21#CmD)JZdIolK9M+4`lvr|}whN;s^f z#TJQF!$m#pah7YLQR-lhYw?1qUU`&!9Fl)$g`%0Lo!706Cf^O|dy1CC4$6SS`Kz_= zD|e&iaHXu7kfw8DAbrzUq6&}K4C~68GClIbOpj)Ymbz5!q)yj3uR-?IR1uniI3dGD zqq#Pk`jMgz(dLh~FY`SuZYF<|?oMLwsu<)X=g3CKRnv&`{*F(?mEolrq55^}ts;MM zQ3`eb%xO-%XvuUyWvc`7-xbPrnPpA3=?+MH&t_0hw;a>m(M0Gn(>^V0^1du?&Of9Y z=WG<((W~Vlbw01Wy9T%bNv0BI7^%* zj8gp3@I9?rI82xv@QG|A#TMz8HTzMc=|rBO0W~#_( z_I<6ba6FUwYsF9C9Im4(pO}$`<8qA=b9yLFNFDEGwd~~~u7fihf7&y`x=(-cnOm>) zlHX4?j&0rm%N(jII8?YxYnG?sOa`ddlKiDe3s>>@R8fF4ra+2=uC;F5`xxB7vmAvk z_K^pM%V8>4%Kv&4h&jyQ|DL%H`m zCaK0{-^A6h2}j@qrjQeqeTaXf)Ji?iv(eV4Sg`#S=vtB@w3AkX`&@)`eR)jOL31l1 z3!_$a0qO5DWlYgkl)DqGzTvb-Nd{RNmQBQ2;m=fO$90l)A3@26qbzIAZHx#ZyX=Kt z>LwvCgcQF~rdvxGeOr-EpGK}jrn2OHnSgGfM8Ty)Sp5 zb^BOavTlpwS*wnIvrcBd(GCY)=l?Os6;-QGL9_Qm{U+)FEN&KNK+~GTWEGS50Gf~w z%~)Epw1mE~OkF<;e?5QVfc2v&XF~cUjHd6GmQd#Qnj@=ERkr#fa6O)aI`j8(X4|HV zr_26i+2s3NInn{P8euf`%L<=6tu}t7Lyq%t+I9Z^HaNqb^G}dn86Hp*! z;KK#S2`$-s{c(u~#=HA}>Q^(!IY`|7M?Iac5H+q|^72a?`PoTl){T|qI%C3gk&bTK z2lCQx^>lwm;Weg`y`gS2Nt7>$|5I_7up`U4HzH*=<6RpT{Y5Cw(Nm|4;w2>+Xg#b@ zju;k2)?twrZK!{t;yMFkmy#ZM2%-&Msyw59C6o!uxN_+foz&iCivE;s)FY^&Qgzfv zTw(u@B1Tp`QyuO}_TYACF#eR0!MYeLteUHoJw8#1yc^|O6&%m*!Fvm$_H+>UP(hDn zD$3b`7@3QxGvlxr##$q6d+KX&9ItB^bmIE%RgS>32h)F+q1}6qk@+anu?X$WDtOm* ze#Jb;GhkRC>ua!R($EO-#fvRNnsfAOPyq0whk9`E% z&?asmOPSEy67F&J%yp3Z`$mIYJgcoVE`Xjl)*`=B=EiXSQo8VD*%`%4a6|kWdBZ7P zro2#Jz({{QTPf!g=i&=loPluGOpJ?|jvD8dbT`#qC62Lv9Ku{|D7>}-xm zhG+4PsDg~VFm?Jn< za!uOUw@Wo<+wqtOd7idXq=ze<_QFYDENd*)Yylj>QKx#TZR}Urix%fwgpkDbWycvI zkFu{m;=QRW?H06CwlPNBSs=tALY3W$=OwvD_h!K7!w|;%BYHdwE&ezKbt${Sh>TV| zTW^2-vc!wNHperzV>mg-c9_T&uUT7`5a^-(6EKUK>*24W`a2yuwj%$)KWYI=6ox z_OEi}%+5=N5&v^^Pr^i4jHBIIyarcSwJ?iNqEOzE)n5(sL-s%6Q|2)Z zn(323eIu!sGYP+&PndqD4$~L(z|}{4Utw%ivK~${LPHNonAy>6OHjROqhb^s@_in{ z(Qg2${!Z0*RGQy|@w*^T^CRTqTQz?_3gKR7Pz{l^_rfXV>$H_fgL@zk?dt&Zf*#J7 z3HvK3n(!IvPmJ17$5(NM@sg$dvK~_h?*9cJkD|A7-eZw*4o7oUTt(Q!RoOD=Uy=Q7 zSoSI?D0id$z6lHMqvLf#NyxXQ!YlEX))cQ%{G>d)=xEMN>UD^k{Bazkz080A7DD=} z7@@Z$L%+=!tJs*oSU~QRV;6eywTqvRqC|NU@8B@&ipYE1Rk;Ze)Xme44RHx;(pdT3 zf^6t2J3||1`bfP$I;qC5tl9Hx|0eym4RNwKQwGw(CDf9t*cTxALBHTwHhEintc?~E z+^|*oh9e~$)GVc5yD4@TA@_gb5ltD&Hd6+jAFZ==@1>=0dM_Ev@jgD{xT@rx(1tt| zlo>E!lx!`2NY#QM%ro|v(c&KlqwKU&k5O$^j-Wf27iw>5Z-tTkYzqxr zaD=v~=E-A}BdF$%a%WWI&{CR$di8Ol^867++SH$0;yhiffScy$Lah1`%IuoZyWHeXRME{`>FXe?f)6haV3D6bAf}d zGp_S1zeBlpj+yosD|VIn93adv#_I0aYUCzkthzvY4u7kSx7Bzu@Y87W`CFzsjOkL^?U=Yhozkn{DK9MTX4<$*5iqfx?26KE{c;=HCEB~HCRLNXaP=v> z4zI8}@gn(xxC#QL2kF=q^?B7ez7f!gx&d+k?lSEuYxcj$nfn7*EOSR(p$m*ZRZq|V z168~Vn;w7A^*qi-dyz@A;DBc$)iIL))prliaGbq9du{KVzbA~c)o7kaj@93{y&1V) z9mp(G)iq0AQ==8>eTO}k)TQS`v{P^32p(sS-i#LgDdJ!i^{R2ch`c2gkuD(5r`yD@)vya1Pzklpx){FX|GyLod?Xgn&|H_+v|4AAY=}`^1#=#Z5GDgX~ zzgK_wDkN-}zCHczeMc?IU(Ao_P+Up6zSK}e=l*EoYvC$Lbph%p>8w{Qq+jHBVLrtg zIo?gEBqUV;Pj?21%q zZw$Z{?PpyE&EJssAFt~*lCmhDB88U9);D_L1o;eUvraa;(cbA#Bh&#*g_h8|;=dUF z)fq=xnQ9y!PaBFs%kfO1ya@CEL5X-)@twX*U&@qt&HR7DDEfsnB*LBGa6cE0sN8>) zyb)qiYfY8kMd`{2izo+FIM(5uRjI#Ibm%VVniQOUtD>Xfxg;II3ngf6t^}#FI~l_L zx-_(p+$0@EJS)Gu=6$Lx??r;oSwB1Vcf0$q%Wb7@8b%OOkq+_htF-tiMXi zvYVkv7%gu0Ex^4qsVZ5RmX<8Nif2=Qrr((|MmUu*)!8Ua(--7-*aE9h6@P#1d)oQu z{I%kQp?}+4O1}xCi_V}_MHyq9gF4VyU8V!nkGODO=+s0gy}H@D?Q6QA%{*qqqofnj zwW+pB{dn-6ewm}U|5Z2J`?79}@Tz%?Zmc*SkNKG}&Hh)pT^J^u;Y`|0+w|fR2WaDk zSIOfmehE#eYc`<_ny~Ua$Qgf|tiM6Y@`s!?Xpir){zfyU@LIXM+`aNEjv`5T>WA51 zL5L{Gr@aRae?zW2ccBCMWR295Thl1CQf{rLk*Wxx&eAK+!q1!q>v{}s##a=HvXbPl zxckHn$|hd8HET~OYDY1@BwQ~irCcDiu?BWtvfz5}kuN8URGhhBQ(1qLZno0|am%QZrTJtGtb^A$s zVXtVFI~ys&4b}b^bM$4+3l2~w3Lz(Q$8^cANn*ZrkaPKJ@g2%&)n$CQ`ycszbdTZ6 zh(hWwC}i1wNW7_xI`Gv|r76<=dxQ@uPFOvbd$bVp zB_ST7tX#cwAs!{uB7VK@MOY)ZQ7;obZ@OW<>bF^|grXI*EkE~PB^{1D6wpA}dz5jM zVt1V2jJsOYDK^8qLWy!I+YH=QjO{4OrC*TJn$k)ZnP*pS3{-#FIvGi3q-G@kx0I-< zyhJm_I+<$LDd*Es&;5arn<5ntzrUgNcaC%3^Y}i)(b~8KTRD1Ri6b-#3AUJuvOA6CW}evQ2bcv5ISHb zuB$ijsQ0fxsyu%rj^$?lWe!!jg|kO{7;}^`>Ld)>611+UBS{_FvvJ(NBCc=W{@ukS zi6~W7gu0yKKh|({LC-^STBK?MY40u<((Hl*JSWs$O`B@ajK_1Gb3a~QC2c11kQyOARMubLGyU7y`6hXH+#wKbXukmEYd=;QP%wzYrH;Xi4{dNLNHjhAQ2ur2h7 zq^~Y=hI-Id>%J`QCIn1frt+wG8)4U_J+Pk{hm94_>EqrgbBkJkKIoiJy&X9ms z#iG;U5qFNJ=#VUe{n^wPJgC@c{tD@DYjFw1N;2P7{1&1Oe-pnHztntcdJ|GamEYl* z1nI&=!ZLqbFqdn_&uQa{7PD`{1?o;f5n<@D1vt7wUb1UBvrUA=@}3mG(VB<-Mm5gy zj3bg_C6tBcnV1{ncak@mHq|)46ILmHMwW+g7`E}15!Ub_=#bll*!;y>Gg%WRjdWIF zn&xK``n%-2mPJrqB3?sv+I)&F`Hi_T74`b{gp+^7(c>R+H0e4$Yo<8rH%!c1UHD7b zC5wP6>*Tcg>MqwA9Qg%`nOYTP@WLsrnIa^z2%O`iP;JtfG*ZpJ{vgF&sFvUM6nopg zf^D)}nx**eBi&ehrAoIdvVO=~p&rmkkExtBH+Mj1&H0?)M!BH#@yr7=^A~Fxq3x~1 z-2Z=XAToMTw+q%G2PXr%4WlC^(Hl!g>jTVC?|TuUV3^Kd2*q3K5_j!{of zXonv6C0=K5Lyt5=mPwS!Kpot?b0LU!)GoZ+Mu=V*D;%b31xA70jCzUOuo4alGvLyy z{|8c!MQJq+u1X8xFv|WnydqIL<>B})!o8wa_Q1UID*r~`i`u`Juk*)4buo2Zt95_< zK=B<{r8YpdgTn8G)&U&zpQ#BP{P}?#7sX4?F@#diIrPZQgjP=}o}1)Qn=7h(9eb6I zfEDuCzKjEvwu*TP`KF`oZTW{Z&zU-WEP zFM4G8FXm)BDHp1&S?NOAyx$R-{FQ%aS`MKMUDW@F;a@%b31!7m?~E!gQAKI*Qbv2x zd|bT&lA7ulpw7EpCS#8+7v@<>DFzKVZAicUcl za+@o;>(wuiFJ?)KJjU??%x82`>Y=g-_EIJQToLZz9TOj=O0;I=@sE*yt2L{lgmP8X zsu!eZ*z3&Vu5NXxYrUu6>G?I`$iPvGCZpyP>j3hJ>0Y^^BgZi1Fnbns7iqK@jjbH zaiZJ}#ll42GfZA86~=T zT^j^sKVFieUrwA6ub>8Md`^uTxj?&Rh3*dYIA0|6DMrz%wN=5~tQCLWOO&@mxhe~% zKsCkSg~R$~`d;yIxg+5MoRzYIiMxtluPuOM$h85s;<20ZM<}*arh(~AT#O``jFx}bMYvGV?#%LuHa{Mz7COlHlh_eIQnv-Q-JrIRvrB^P@$V9T z1=SoSrz^QZ)!tV2Hfy}>A7$#M%u;!cxEoe(^N1cBVH5B*beZSyUg2!^e z{B*e+wf2vY&%Hxv&u`^rMImh#vi%ewY$RGGc^|_LTt{EfIi!Ai!YJv19Qzog>oSFj z#KZAgui$DA$WGB+L3Bl=ISQ|8r6P_vJ>|tn`SVn-M4zma*9H>_?*``quP6z`6uXcp z{2r~8kqH;%cJY4|T_(vkai)5@EJD8u;ucrywit{mLOsLT;dpT!G}|V4w@aBfprs6R zLRim@$%zqXqBMTqZq{!S$`kJS9r{hQHUyNkrV2Px*^08_uGlWN+h4IxwoTxOT^6Ac zNHW~l1OeZ0?E%Wr*F48ZPbVphoaB%szm}HRpQY@l;yi!2k}(y}7H@lMQHnzYv56Ng zI$dVs82u)7mm@NiZP6&@OHd}gTkqBm`eX}%=@GhI!GRWxDKmT#wW;$o1%FxD; z@pA#AUiW{O3#lQ*+<8MBk^WB+?@avH{YtyO9>-}rB@9RZ7CS)AMmi+SGw0C zd}w?E6xk-M_#s#m&a3W*DuKzDH#c`GNR`3;-%Horzt)*vwQwJqSHh5A173TtqGgDy ze0Ux4Ke~s3ckm!8^1ur0Z#&P!Gmsxv9rGZnOIUwrTMR1(oqH`TXPSA~$g3b+1t59l z$o38QMMq1rxTc>5A|WKqeL(LR_|3rF5y?{ews8;D*p!{Y&z|rmj)%v|cTSy;EGtx# z?Ekjpron6QqCWN!coM9n>k{skFTzxjqu1{&Qjz9~+-inmqirGb6*V5^Fm)={jHmv$ zL-c>{?AH|y+voIXVpB_yxb2L{Ux)5>P@JxLJoBl?=0Mf z<8z{)?I__)f4d$wBzA!;LgF39Im%z*Iq^{>>XS5|y7!ZJ!mZEIJ0cYu`(dWdHHB;C zr5cY|sKzz12v>8FazuGm;w|mpeG5Qbu*rY*B(!liAaBTrDAg^Oa4&4BI!=03u;(w2 z(a(!{J~gnAM=;!7n2rs`OH)cbee^Kbyux}jc$?}Jgew^Iz*^0-fd-j0U zK5JpD_#cBPp+DuScx+`*(syh+YeC4~PKCW(z1#&-XSsm$MgK9J%Uaa$^(Og{8Z&?H zx9o`&`?5zZD=2zeoR9ozC;n^wa2k%7PAdqo^a z78jB4z|u=tUvPj>C?S=`I)B2Dw7h=`%fdeSy5tHeLUo3Mj*n5Q1==MAACRkC=GT{;aLW@(25~mQ39pab{U_ zaY>Qr-p^7`@*8%B`+8CD28vfxrmbemvPX;Nqdf1hOd^d$Yeu~+z?j7JO#go*ZKkKV zoiioggSQ=%*8d;uwSG^sYVl~+9KGaq3~y)^HV9O)L=@f3D3#Sz9Sa{RHim5c%e1bo zlim9{iqb=v1~}iP!bH_X_yo1-pCc`*$S#0@{ollPc_DZdFD2f3U}WR)Uvb=R zdwQN?x4JvRv^V|-I=Ke8(>hu46RlZp%Zk#xru1r_U;4ipQ*BQvy|$~i8gYVdi!oN! zB)t0nIeQndrp|0{TszgV?X;bCW@^WtIn@7Lw5`r8=Xj=$_IMnJ@vDC#J0v@j(1Zkn zxp0es1_X*A(XSAK2K@lBGqozms;JmHRim9j#v4dQsm1#Rq*MW|Jx!0(V`Ar9YwaCK z0NeBZpFD(QXJ6jSde`k;>$e;pU^z&*4~gl%KWb2|6}x5eBtk}5mp6J6=_NfldHZUKN9JY zxiiy@ig8?>dpp@=H4}Ba3=a`10qTkxwB_fRX33FLas3sp;`%E)4Mr#leTAaU_QEag z&$!ltCG1KCzxOfkkglqSp(wQy!k6TWldhfLpAU#HmSO6vSDK05(>{|yJO=Y?Idx~*Y1yu!U zV}%`fchu7hv*>?SnL~X@qbi{R*A8e7_Npo`ce=V!qDJc@_74vS!=HtkWypDzYpea0QjLGigYrHcMc+A>k6{l{Z*Cj- z91+l&{7=|!LL%9F?tXtnbDbsqcZ|X@NCKfO7_ME!``8Dc^j*qjXP>c4@mXFrO6N$5->Es8YfwL~ zor?GHBiCrKP9kX|ennWL&`6(^(ezSWQAR_PmT-nBN9eEMr7C%_8)yFnW0jz0n>rs` zwv3}B$vW+3gnVDzKcOVK%9S>JB!5T~T|?GAaj1Xby2pMfM3OD#cgP2zY9~ZpeJ1QQ z=a?FGOh zW>BF$-Us&5xm95`}q6>SuA)9+mi`rznuphV#kyntvsB=wZTD#_H>m<~A=ZG_s zA0J+SWt_>auyqiB9&WWuTve*%yA^F)Eot*$^Gq?GOEH2y{dZPnu0fcrT$$sezClBk z->{flX>#a(wQW%Mnbdxe&zY%}h;-qQ|w(Q5DgK+%KzjD8wOI0-cO8yqJ zZx~J%$^9nO1&w~caDbzbcJ`xMIH^7o*wu}WqjH>ch zCd@!ab_f*K7S@7PZ?O@n%u73ro||wP{|8u< zJ9<8}3aa@#=}GNygsxFtVShX$_o&C1kFrjcn8~6fu7X!lRRhqCCfwoocUI586K4tKxK|^XmoKhFrLi zJ5wknN=Az9gm>_-51-#&euwX@fx3)TokjbQ@xRs?95Y~eJl^4sDZoqki8wl5Pac$_ zzDBu<6q%`6_}*|=pdLdJ3{H-Ac~yQNj{5Q3{HGEo3>|~G0!T=Fa(QoYmSTTn^7*3g zkiS=dmpy5e*@{|`@T~n;rXp-hGw~%txu`Og%z}>8ll@#e1%lSOQ>r!u&VFv30V40r zHo&!_`_>qwAflXRXezo2wc<&+t$40+7yD-qgI$@!csYH1U&=yFWNqcRynoF5t>CLU zYMmJ0X_}>@NMTpShs>|N3FLo?52+)Ygew*4wjP32pJ*RqK$jl|<XxtUOXzyE-_+05nY+WgkE-CvwLn9%`bmC|zjc%n`=LK7;Nj!@! zKwV_S95}={15`<*C+~^Wq@qz2-(nxbaoo4rdXr+Jn;HMb$F*0s@K}Fc;*n(J6Y&ls zz0fFa<0$G@{L}F7^^7c2%VUi86RuLmTE@Fc8J1GqQG@EcAXPGtbib{)yodJqqPS;hcUpW#JPUhJ6HxH)gn&!BVK;tzA2rQGq(dt2#nfc4 zu#d@J0mbUZ!fo!i-8+AXQxS@uFv2hy>Gc>yseV&5O1vYShg8dKxC)IaFBFYZZPPr7 zz2799H+{cMzZA9L5}SC(br#2{P_eP1t;7b=ij8!PeA(+pS-#2~50^{3N^A>v30nYkAzu>H#vo#21;j59^K69-)vu4SAB zKb}!M;ExE2qZ^=(fzRO)aiM>iAy)_E_QE6NB4Gd}BY4~euR#j-)>f8NL@S;4sNPw> zRdpS_)-m)V%N5r0r$S+Jfg|y`)cMsu*R!$r%}15@3`>Lq)=4FrxPO98mgg7!5ay*A z6(cQQK>ex{mPLOBG4P(so3D0_a9M>0`V{$bIUC>u&}r6{Pf8LsxLXus}ZJ;ptP{1|OG z|2F*FjnaVflAFO5S1)T#I+RNk2yv4nsn=tb^AMCb|peK8F zq1~7a+s%~2(;V}&gb9ueuAI~d?m{~ryMygL9rI&6whjChOF6s3uPFoj>nF1Ia{i7~ zg=#ZrJ_We?QaxwbZ027#@q2*(e<){NHREVfRB%50dF75(*V1mrJ@Yzcy5V`|3|&li zKF)vkTI8QD=y838SGIGmP7hwS2|u|U$5|^`h%fS*RmIwh?pOJBrKq!STm3<5mFjwh z3hzZZQ0?ot(hje7inXw46zc6Zlr4VSZ;3AOjID5Bd9S)rKMOwv^ifO|Hng60;JkL? zOx42noLS&Uo$?Ug>uSYP&L_KEbCfHT?Q?&sTq9t!A{vfp_i*l*9shPCeYJ9Bto?YG zkMSPuIY~V4I7&I+L;d5HfvR*7{#<~oTS++s6w%hrcI+m~%qqH%wnC(8w6%~txHuE1 z}bwv(Qb=Ddf}D8PuY*3ufi6jo5dhd{#bv}dn2?X zqIpgEnQ!^s^YD%V&b9OL+y%(0@NCBs#u0G*H13zMy?l>77Ds(Mw~8ofAM(38xQa4e zEZ@V=z6Ji+tA)QwjG#P9Wg1c#J;ARUjdQh8XK_&_)@VW?a81S;7j2*6Xh-K<&*?_p zw#@VkQ<3KB;xR=AQxsYubEtpfc0rArA_RQuPQyNu_$7^$SE`(Ac>THp^bYH`*ell%G+pVA(fxS89qdsFV{}=Grjpa7c#&r zeIDiFVDGnLOOEl#-@@U4tw)rR$YZfz`UQ9b8PEXTnWf)(x!3G+ZogA0FF~T-XR;W^>cN>Ew}>yEN6}OaO-;5zLcyOr{xK* zlH!D|rfS`ugw20kL4K&M_N{r$q6Y1yNrYZ0enP$@&pgf3X+(#$?B5CKh_m>p2CB~D z0O#C{NkXOY3ywPIAGLltN2F~5J&ZzSD?o`R#n74%Y!pfS`L z>bSPiP}CzQW6g!z(}PFI8ETnpK)GxyCqWt2ID#HkG-0IZGqn%p8myDFuPIj&N_70E$&Z)e+!*ST zzBDh1sUbwh*Kbh$o?dE$lg8qhn!V!rX95Z%5gOGRdA}{6j3bFtQ(xKf2DuYG%NN# zYqs0dnz>@7RDYw7bS6TN0C`7dL;JPCNE5|qf)U7u!S^tCeKOkvX zbxeP@j|%#8b&~pH0Z<>M?7Y0$6p2OJq-{Le`4k;1MYJP*Fd{o=><4|@ZjkC9yYlDC z-gVY!mA?n7*|Zk>Kj2&PTPM=p@a|!rY4>qlPY?7F$Pt&C0besn(b$9QHz-h-!S~D` zX2Q~`Y1h-P(;SLp35iPlogDij-LZ7glMa8%@#raGmLBQj%Q%Wgdd16rt~q$N6mLuW zVLwW@P!$tg(KP2&lXYM2E0t^YPsV>%@GvwHYFEuf$BeQZ{er4IqiELPyhZXZqgVMF z*o{A;y;EGz6s1Y}7I|FiOUsZGoRp)<>DAOfVgvhGiOQ9{u0ta*_$;jv$YfFD- zmCQn|sY`3n?J2r%dj;>mGc^e{_Fv(96TFU3rATVZ&-1Ca5x>iOjAn-sgQJsMs!Uch zRfxyYJ`5Sil>)lG$QP@b2OyVNGTM2^>@C{ldJFGK6_NXr)88t@wsc}|sJgqtI!XUz z`NFgW8Y5wZ?w-|`ZqZIHqBv%3Db9b5kLW$)0AtFcF6=m-){fs-6&ctoU4Z}2_c-eEJb^QIbpzNWWQ^7X&J>);0&B&j2y4(=j7G3e3gH2l=YSO zfhs5Wa`r$yP!(TkXa5H8{1ILo>Y~UwgL8+J{EL61y>P0>LXq?Nv5Ik?Ul)(TF{1G| z!Zu3;^y05As4qynorAp{?jamL{CfuLrNc-@%W*u?%$kW$d`5%%GjVysTF0^b6Iu)m)r=Z4j1e%ch`QdoEi~TkYvKD-nZ5q;v z58~%du!nJur5t|3Uf36VKXnP}8`srtq#hq@WgMxBwydjWB3tTBsL$;I!ZN;!pDy4X zw&Q4=<+{3@iONseiRbKNjqgj;DjKkT$8kPRA%&b{9_{CQ)#15Y8IOO2Y7sXn^dqL= zJfCKLsDYyc8^jH81of!Ra!g4rdj&qB{0*vJz+PZ#;W?ulS5*t=^<2QYxt+R*FzfJ| zOR%}>MV#r)_%y{DUBUC#pTL&Y?=hwzSqVG%&NomW2(Z@=wLBh=vph~seD^-+CET2) z@$ua`zA}oG*u$+mzzBc)UbY;MU=MC#pZdr)#IrS^tU1d5r9f^Q)u&AVoiL+%1><{M zK&n=NO+C-B1fRAAb?;u}K$1=ELb*dSgS?mRj23bVN0D$Ew{twpr?A5?8Ld~fI9=8w zH(}4c>{;2wa%2n70=2q_&mbfd)IRmwNMBj>Lm4k&tWhy>`SET@{I{cCAJ2b&XITSIgs z;;loEhOd`0LbT6o@%$aXT}5epZa_*orenWLa}6#-(n!}^xaJi>Bz09ZQbL&2saz|? zTXIBaSHgtzlWKpC#&#j~*-jn z7W<{RoAjR>9um>wP!#gK;`+<%1{YOM=NR0RyeH))3}oa_KGfrVtY>>s6Am3mX%x%k z42PkyjiKK&;9MMYj|X7!I$2(Z)~)d-r)#IyOhgSDO3Qx)w=lwaN4P-Q@)?sfttnBS zzl&p+KBV86w#hMl)klUzAx_iki17SfpDBKh>u|nxu46joJyM((VO1AgB+Ur>(jfay zdeHJ%h8%%xtsazKO;qiJsyORsWu(IH$|A>6I(x}z#)hMcXV;R`4Rz`<`plT$@T%-6 z+-4txYioa7pCII=-Zat(j$zIK3am$< zsu~K;tYl#%KKC8kHA6Z*fjxW&4i-G@nqIl7;3HuN;lH^%Sn{1j&UcPw1?N^}e}gX09VBeFbds#J&U~k1W;T}kI{{^P>(%q79MAfEWln~ z@*p3;^KN1PdZ9jbJl)Ow2CuMA!u=8+WgLIKPUiMB+xviOS9ql=H@pXj^4r{PLjH~P zn8dN&oN++I@xeo~4uw5E=Y}KncM;g;n!7sEx zV*aF6b;5!Cjd-VCC|fs*a*^n-axEdt;M#0cu5|s2!ck)5DjUxh-8W|_Hp1cD>C%4= zj_s9o(XMCdo9z|bEA+cH2Hv%NRdhe&08)cbHQJrX6yl?b2xxClr@W%vnZ``_+uEt6 zt1H?Z6Lss=jWIQ)U8_#y8juroa$d29BYs@+{vUHG9ZYg3s;+ zyCD(!ipOZx1%w#33}o~&2e2=C8(MJ^f{_&SKRDL)RhTbF{{K(V5GmG*s{N(Ly(k># z7E>Ij4g_JmXJk13!=NYq|M zdKKfKLphi0l%M9fS{fNbz_&A(@s{XtRr-vX?1AlqM8*vdud+RulfK845E8FL`I6R2 zIET?vMRkZyJ%Cn1G}Uv`-P7H3zYMo=z8bBWrfHtPSG1<>u`W~IqZ$+*aoyy~qN+%g z>KiIP)b<%8;wE^+T!ViGR{krtwVZptJ25I@0{IUp6AU6XgX+m9Mp5)7@{C@TfakbZ z@31G5_OT<8CTQoR12xU7K$Y!iM~N`lBH1D%S#%m_v5)NriLS{fy9dvY1Yh=w>=lY} zMWg7y@v`u^Vw~e&5{{aeFdml;xx_;GmBe|BgY7Lz=7d+?3!;CtEC|^T4qJo$NbbBI zvyxFxN>TZdVK4G?xz&rAD`~R}RHH3RTv>@vR-6jkWe!DT86LYuem>2+dhwvMrO%pg zxX;jgDniar;cwAF{2lJIjM^`w@o1P=$$c|PwE#k2^4;kU()pJzzKH8}oL!Nl5mWFG1z&99%*qUoV-9ejci21Sb80ygh%>-WO0n(QY zbwVcB<8FT-JhPgks6*z!2Px8wC5apKGpv(5H*1b6S5j7~xm%wZ@6*2KP?nrZ+eC=J zrfEh(NN+7UWli*qb4*`-&@_t>%mw7MjB8#B1ymCnxy>$U(OfIJzicMqfT0DEu(p#C z>7A5KQZteLh)(F!&$3gbH|m4xG3v$=9Y+U$`!0Wm6Bezz6Gn%rEH{YnpANAO!}Z=d z!H7?xjOF&lgb7rG1^H>?FaT#jn7W>l zlGBYp!jE2m$G?EL$|2_z3>TT#h@3mHxD32h`B2l2#IwmQpNiJ?k+;t3HI*i=54}w27h?Xor*K=w^sk#*lX6M*SZD zd>N&%6Q9s5o|NyFl4`R0!CCyz>=8Ed*lg;rVR|Kh#HO~eUJ-7^Q$J@b91vBxslUZx z+(&6+eI)ow<-5cWx{GvWit#d^QxEz1lVBcu&J`io4kxF={p3R{>&}sP0KPr`JTgR= z2!0;Omy|ON7d6T_D+8R4J?}%Jznnsu++Iz;w$qC%`!JzokakV`N1$apYcpy-edTv3 zkJ>YT&ZRE2(;g+Efzu0|gxn$FcEn$S-J+(7YIN<_JgvC~Zo(SIS(ev9N>pJMp#T>D zNq8*&itre;qK3frD6--lplKDyiW@Yo6|MB1Yrr*e4w{{FDN@+Hn<^GSq%LMd`Jg-0 zW2;B$?%}%lgd;N!v*oBk9?~pp!@=6Rk(`HrTiX9!F&y9TkKOO1ia3h5T7AA6Mq$Src5}ix}ebGQ%J9CLOm)tu1WnqCh4W=rXe*b?_ksU7hY3H=}*L3{6i z`=A$XXD?w6q!`I|AVe6&I9~C)I7%~+Ye<`Fc!+9z>OI(xzfmRI)zehdT$AH|sqQRT zpF7jl0F8uHrWi-neAHv|T415!rD4_#?OmObHRG@rX(r0@TJo6D*pVgQjXc4~e$xxk zl)Wo^7hwdbJF)-!SDkRZW&I<)md(t6o~>J7andnSGZE>fqtGs6Cm*&(7^|U=G7<8l zWb2hAMG0HC3gp_v=_TY_xeDGO9+E113!Q|=A^R4Y+W7NuyVis2@eS68g7xqc3E2Z} zi}_V9Mu-liL{Y6c%Kb;p;V`b?LvS4_ZaZoQYUqi-LVmiMiBz4~TvO$OfHE3?4O4}F zAt(qTjwmc{0$z0;?c`?ZDuv$k^r~_~ySiD4rF+>Q?pMvCaUK-epZI^!wGS>c z;$a}wVsxv1LOx^9O|usk3X=^>RHMz^u)s|5f<2yj+9^e&RMRRxWH0T1a5)u{bQsE& z6~>4V>m$?>QLrXH=-80Yp;m%1%)cP{RHDMpE|dIKiO&^h$yR_yMtod=S4-z}Z91yr zMG=hn`8BB$RaJKRp0qrsNy1!wJ%lOOa&?R=`u}%1S zr+PL@$+bwIYnjvf;G?X6x3EvQmUa@#J8>RP0L7CfqTcams&s?T zA#yUiUG7+6a+&%}$DWQf8(- zMf;8BQP*MRUlq#C6@j^TYDYQ;OaM!RTaIc~>?z59qg z3*GER4OWn+9U#?p}4G__vA%^C@8HGreG8#clYlu~E$y6v2i ze;q!>(Wf{_+C%hPCxKKY$3ZXnuH(kbIxlBm`M~Bd!>yX5vG?PjP@3_(T8@hipoI6r34IjD{&uZDPt{t8KmWr3 zNBGJBQe+Q~)H!VLCrksiuD6t#Tp6N)XFQVQC!F!Y+#bm%P1m})dg-Tpyo#=KWqo1Ct{i{pI+T6LPV zgW?AB3?VahiTRW{4vwMb{{*4>Kx4&Hl7{x!_$#!3$Duc9_b^VnEvw428euVV z4?Ea@6O&f_Tgs2o?skH^s&~O3dA@wu${rk9s$n}Q!^!#+bGKp1y6;%Wc&1p#n7i>k zqH?Xd+uUt=g?^#z0NPEo%r-1p-6p;YcFSe!OOk{zOL+t@DW0-i=2~+NvX3KDM*1C? z^8r7~a1|OueacKbmg+Fy$v0i~ZD&Od`4#_vbVvGWa_|*MYqF;bX;V0m|5W00M4$aH zqVI%+=aWWObtRbPtIFlrAG{l9_(-VC3;0*H@nwFN5$QNmTu=2S)r%d!Mv5;^c&~g9 zjFRnLdLLz+!Yx8w+&YF^x0+-XB+GjYN%D>Y#fe72e8)$+kE*&>zsV6mQvM$y4cumb z&yXfkpzUH(^VEqfu`Z z8J8&oqEkPHEMbIfOAi~XiSsu*#9ANvHxz|nu%B@F`wqOqt?_}8AdDxnpTt4OgC2pP zCs111Dabo1?&q7)bl85jKgaQFLBB_M1t%xPs>v33QrL4f{kx}SGX9iA4Fh?_HaM3u z-VvAJOKb1M5tmuyJfTeuY)zT*`d4=ni~`k$=ZRiat(Z_pxJjzK&TJurdOh(*rLVaFz=-J{t_ghex*6#SJaxT29o=IbxujJht zuV)#l(h|E}`xR|Cbml)bhlQXt>KX$ggI<&NZZgMVt5-+GMPNN0U3}^GQ6`$!WLRm}=RW~6ofZ(^j#9r@R#>=?A59iN~wGj$m_KFfwY12AQ zMZz*SUUyB=+0>&g4@MJP25yl2}4mno;0tdxvJCHM2PVTX*codPAs z%lT^E*ZO&Xyi4ZfkytNC*+X#1h%mI|Gz2XtR6S3-N$o6S}>QpWAzSGjC2 zc$n(MsixtGALKnSoHhK0p9s~}@`U0|u`3KqBlxs3)-I)EgbS`DWNwj=x^0k%T&|vH z&0EpNzOwltu}C;>IkULuXn7Xat~%*Bjy$o?-CJ-0>7?=K- zV>((kluvS+G%3P-C5%dvOGuv|7rjS$UugNB1*v9fBuBn723hQVxa~ef_owPk^hEt1 zC^AcNMKfF6pwHAlseh8<0pfmHyr{HLbph6dsfBu+=`+0caBXGhp$?p`pG8^)`0}#db8w}9 zc}vU8yTvA|z~d3CObXHbhWQN#6#m6?Q$JJlv_8`kK{c|eHgIVfWwhu&FZ_%9&rpim zZl+MF-v}x8dGS}4PA~qgI9=TtWA;ROMv`8z@(T3iwsGuBz&w*U)yf^XYHA4wEtm2{ z`luFl{#-p_Rog9#s7fugXnBCcQH$Tc{QS|bQu z7_Xa0xa0b}xvMQ-5jLFXW=28Ub(%LExw6V4NO4S0PPZu45ncEoeuL{tN`z2eKdMwMRR}kefSGxibDrR&tdI^~Kcm8L>9)RK=AA3a;h- zuDTKGSSY2}hv^n(&t>tDiD&R-LeoFCYZ5YpQJ!x#~oIwJEA{t$voOy<%5(C3&4Qq@yx0r9p- z%NyXbykP*Oxn8(jacc1!y7eUO%o(nosKGfE<8U=?v_6MxI}C%9sz}gWqK;Cl_zC<6 zT$kd2`Ms1hGjlf(+J29y#v|qI)p>BFkW=QKRHe^ZxJtYev;%_Hu@o_XL6uAKF1?Gt z1}l`I#dXnW0%>n8{B9}5i`Jjd9B-+}d{=nXe6w&>#YwazpHUt$zHILCM5O*&_lS7M zQe}T3ZbG#QEmt4jKd_E8m|C>*VmMnafc!0xbP=57pFl2X7e9&nCGiLBm83VGVLXb^ z`bfdrNdwi7f-g*%f-WhIf1AJEBz|JU>yk7)pv4#ZmPo8~f5CWdw=PYEJ|Al4>h0gZ~W!p1Xm{ zO5uMRIie5Gp$bddQIdyUuC_FQE;iuPkUTI^kicUirvE4ZI)|fwBroH<6|zr7#2zfe zmS`BULIWPRv_LFy+S6gvmX5`%m-@m*X_!E%;&;)(-yA&pd43I zwW?YLLwCBJ@CL5H;4{`T=Lw?Q4%l-8dQ0%P(D?Y!&uip=b>fDULVJi!ni57u#I?vT zl_Yx{%4C~9L*Cg9x64oTTep#XZizgLL;=zA>X3FZ>E7g<2%bHVV}|!sk1^C0T%?E{ zircF|Nr&2nf87G;sa%WF_ZYP4?&Z#0H`#GiKU4dfZDneMsNy(S$`?c%AZ~(oDoMwR zR^2_}x5Bi4G}`G+wocSUh|?vT8s){*^q&irjtG=!5m~oMatW2%sYUPQwkgJ$igXtB zJvL6BzHJ}*h8OiA8N1PI#uKlD$^2w+=pTwDR{}DM6GGD=YC~T`eW{S zy50H8KmE7atKYa_Mc(WxhXbk{3dQ1=hKx0(4i~k zdc?;_)}tPA4Dar9O`$kWp%T|cG)1k`4Ae{<@jIPG|D=>1#kIYikf?f@YInrF2n%_< zeH7iGYNvg3@fqtR&)?$?;{WPg14UTDC`Uwp#wng3LV@qA%;B6Rs)TUZP=_nL9zPwR z3=GuB>?m7yO1atPcN|pH%S$;6>6CNot!T9-QngCdoo0IePSIqJqmJnnt&}|?JR*E2 z_L2}U{w^&+cozE*a381K67_7)P3fiIm=dLF_58icVR(sSk|>9}jdVKb%bjT(Uuc(q zEzlm;KQi$1Rh>oiwBRQEKywYp{P#*!iMr4@q;JN9jXA0QUdnjG7UV)rWf|5*KxiD@ zXlJ|wn^bRR)$?dd`yf(%0Ft3LqZ{oxw0n$CvaN{nlF$%w6%F{Bl6V&|Xm`xv_-3g_ zYd!=cx7yRj;x!97Qh;Wr5bBL4mmy4l>ihWq9c;ej30DMZCMr0Gm( z6HgS4%1vj~fCJcqU2xb%d0(`H=v6na{@8Im^DvG>lbI|c((qSvMJpfb9OR3*!#kwy ztbQ+xGwKG);fLi{Rz|H9o|8D2l*(?!y)z)--w$aOkRJUVuVOqC2b`P zo|G5zt7Ed^3Ssu*sJ;&uIc~U#-%n7!ns^X;k}h#=i#|sB3CQ)3Z*jYu_;m#PdxK++ z_lLEQa%?)dRl9N4yYZYk*iO=ann~L317BLR=cX`TnZ~GZoX1_F^N87ba0EHkK8hFC z(S8AH1cj^czR}37m*Jg>Khty6kOe|TD_U*y@R^A?J0kw(z`06HJ&C_BK;B(kQ$zVk ze10zPJ=ozjygml6E=8IzME%3Xa;y;MWfxSm;-?i53k%|}P{jj$w*zv28I%Nfk!RV# zUbAEU`NUW8ydGRF4ccTp`pF0pSLaoZ1KgAng|p>`Qe7?A4;ns($CvsM&W;oHB+_^C zQ-94F>iF3)5yJiL^hycl$LTcYH(0tQ4e^i;jer^IMGZzkO0kkYp^R`6fij%D=9#K! z&rROl43K2DjnB(dy)55f<2>yEqg`~f*M{l{H}hVvlov%* zx}T4qkZGo#cZF}@d8fj()nI&a@K|)e1|1ppX{ZjnZ1`WKxMVr@TG4+Wjl5et5Gk!T zzU;WfPaGUOEosOa(lL2Yj3Ty^Wxarorv~G`rCqP|{}c|y6(o&+H)bp zOX+OvRn=%m3hijBMyq~8RWOYfSew1V^zUiSxdu@!bHQK)v}7x261J-sr_Nue77ipv zxSmZLYxzR`IANP5{6twp7-SR+H9~~u{6o?%2TIXjLnp_D48a66g^pol2=5&jJ%uz2 z=AK~BgaaHiUJ6lvrtc%q^TS@YgL|a&^CzYLns>B9vEpfbr0li4`e)lYO^n=@$FIrb`yvi{NNCY@g0N!oqZUZcBsQN_uB_2V}+{AD1pj_~}j*Gvix^46#FM%rByqgdo%)5aY+JsEpZbhRN%r|)WYXbrEIDu$jE^63!W23ie2zY+=TqO=6}y?VVt`L z9Hp~x24`bCdn6^UtCA!0<6&joKa$T6S$Wcbezn)~RaUYC40SlS%N@WpwVa~LT+br6 zzbKr4>mWFdbp9#4cQ5Q^`4GCh+m9R~+g{H8{HxUioI`&%?gjnbC8IgU*N1w>d$2j} z$yK-}bJJ1oN?KA6Ane3*HGLh{jbVX{iZA<`!n$3*m={M$zQ44%e4dMvZU-p zyN0}40fnBinZHD>wGUhd!lmfZS+bXZL4kFdK2yA-pGlQsk@nt=c_imLyqj~~K0f6| z?Q2NqUZwfl_^AC?<{E9E@Tl;ZY(4vUMSl~blCwHxE|o33{f6iSxwc zt_QT`4|2|6xECUP_j{mz&EV{UKzNUZXCA1@4S!UiUp$15)QH-)6w{C(^VGqAaTSBL zI4ReDKq9-4fBK9+f-wjj?w)^G1>iLu*DzKFRRBmv4^gpgW;GDsD(K z>ef5JG)sS1pQ-zk!Ks{Ucu4&?cq!f)b@!>Lt!pSRlJ-N$zBEw1wI-ww)CP<0qegoh zLaW3k!m@9OQuW6Cm=H3|Z&b&B39sO)57&ToXjOf@_WOpNsCymeT&Xs2rjCc}L&pE` z;QkmlVw+qjJ#W))kv!)?OoOsq1NV2$piv3CL)t+It#x!xJuPdm<2cplga_}j5Au59 zDrC%VL!EYN`JLGNtKUOT+(l^mZ~-~j$A*`1Z8wx>c*Lw1;bXGrTxXYmjCLFsXK<8c zk8l9_U$4$mxz;pGXVFeI)KPqhx{>li>>l+Pon`$Gmj1AKjH>-XElP~w2&cIIeaU|Q zs=O!D@j%o|6Zs)1BAt9!2@`m4uby`b1|lUwpQB_N3$6!e`tQ&C9e@-&99`PhBXSSB{{$#L*3}>=pF5Ir}wn(rE^KHWKYhanPQ}wpm4d+~wV`@~tK|YxwdmWRCt}giw z)H^a@zT-Fy&YF-avJB2R3hHJ9M_0qzep+$Dh5r55pfoB&>$r)3?W;h3tlBNpVp76( zxR7c}FM)HFWn7J%?6RwlqiA>beJd|^@otLK9t(k@QNsVudo1s<67sN99@(w@=TVwP zf(tc_2hsO8WmQr2=w;Sr;ymcVmU~M-E&UYrlX~dZN0r}Mxoc%FysMu9?|NF{8fyE5 z?b8bZEXC2~M?q-a zBmA74Zupm^FY~ff31x<=ACMpC7;04HPv6V+LB6f_9zCspjL=~~BwZQIG-|IeCTp8& zd}rqglSwz=N}1C=q9-bUZbhp#(|FEvGi{S?yt{!T{uu4qP{%O>0qDRU?X+i(Qpv28ux10w?ma!~EO9tf=5DvK_TN5BAAaDB{2`99_osGY6bO8T16#kD(-27;}}_D2SPKT$o<*h@h#t}>OXg8omBvESsl zBLcaBlnD}?wIHXXthhadPqgZ!pLh@ zPQ!V)$SAqHxi`mo+0Tc@CW5~>3-3c2_E*7AD1~sFcKcudE1uJ`iqL0& zG}?#U)WVI)=Qqq?MDYEnf%zEW>{ekdaz#HhtvbP2z8@hiUBZ^{=Jqs!7S}^PAxAOx zwv^G+%fHdgQB2Ja8V_u5H*}dZbdooZVun^gui1+l&syhi@QNmQAKTZAy}3kDZrJ)i zQ=j6W;2ei~9;qIl_gm~AC$8JU^FqFVM#8$k#yCt;eg$D$)bea}@Muf*I^JRIy%vtl zARe(9@4G*@jj`@}ab((IpXGUcLR;Y~yf5|SKTwXe!mZ*L88y2OE!KTFDj#7R_wz2z zVeH`=MhKIOQP-HA~vKfxYU`uJmwLm9wL&{02W7Oz+IeW^-@Aiaepnby(9LXI_8__}; zOCPlAZJ)t4U5w+WCHEEM@Ve^)`5*T&MtL1!oa1?aK}zIG&x~Dun^zg_ahyzyShrR9 zOfk|Lkv3LnFF|Xpif|BoYl^ael5sum#Cs49-UX!ZPw}Z+xMuuSszOs*CZ1G$#^dbG z-^gvO1wYC)dh%x2Z2CTP*-h5HjE2hDz`UPBIG<-wCLLHXXN5!j99QIgM*GDVW3}S? zU3HSMyn(WauSx44XNCh%8LErnzDmfY3iSWPRo`~tWfGuW@a2WoYD@IHi{n8MiZ6rEZxS0K88nrsGG z$eTi*EWBsi(jP8#f>$V|s)SU@EB?y5Yk2%NjuEZtEoqzLuW)9}N!0NhxspN~*BT(o z+NfISdJE~RE$*N4-xYs~J>5gb47(GjIhV6=RTIxZEx|6x#1@2i3 z#dC7)%qGt9^FkNT>M>|mM92JWgu?!uwp#q$__Faw#wq11^B%LlSYlJez!e;+eY{h* z1y}SL=u3=HO+%h>gJ<^^{&pHZ#Ao=~i|=Q8A@puL^r^m!|9vHY_raLGLNW67zgGEe zFLKR*KAee*gwcK+xx!hhs}3oupW`!k@L1A{y)MtrNnZPVxDG%U zj`vP{!dg6bn<|^YA@P~~xmmA*-!l&ELOazw$oU@A?YrPlqbg1pxT*&6iT4?;tPWT8 zEuN3fAm!-!WAB%LX0gofEBJBD&nOCzrJsab-n8xx$7j;FZ7!VexJMws@_PqtjvJS2 z;LNOB%$r)UeO!qH4pioFF63tXWec{!$Nx#*yu%!N8_v8E7Q5V3Speq<<&~n7C4vp@ zp&n>2na|moKECoGBd<~9{b}a;QY3D-Jo=RX*n=ANe&%+64UF))jpyVnMGA6zZgEuL zHRLh>OY)B~muz9gJKB+{jaecba4jh9LJfQ?qqPxY{xL@4dk3%nD^q73<;i%SXB_*h zc*m3dnp*w?qc`RZtM%DX5|@X3f6x_!&yz5qC~HG3k&({Czrh^E^rHK`d*$Ra6J#59 zxa<@uVmRD?>oUh!jn~bl{C!76+!Rw3I60zQ!9Ogl)Gr8&<-T*2c*T0e)|6IZ!Oepa09ISSSXovj`NQjO2q zZ0R~fY13but_^4qPc=SO>jwl6PbHT7QGBd#Cy-sydC*@y*Ijim8r?6tf8db9d1w z{58>k_G*ZaE%Z}ZuE`Mk`G)85zHJNZ_kq|i@VqjVk!2v^mak^3D~his3+q6Jm-k`g zaGc!z6|AYE&KW%B4Yo*2H3r_tcg-;E8Galz4{T%j9ERk2WDSSf|3Ar2IWXippIon0 z%K7yv&8oNY(`ksz@TUK#FcO@GorYgIo<$yiwjH0}xcUP)8Gj{x2}N^ai+rd9P>sh| zk>imDf6d%Y)C~KR&!aT51J&W|s{V)OX*i7h)umM%*QnjJa|`x@AB&%RMC&7#MKV8C z$UB@;&Zdzw``5t!xEB>MZxveq5%)szmN+w?5jra6=3mjea)}#i-F7v6PQArom5;SG{yEyk~YYrK&CLmM-)|5*! z@+mVV9zH11U|V;yoJ}eCF-p$fZ}w0)CbF~%X=7Oq6eG_~gi?-+rmC)#o&75EOvR^;^UFpux)PDE+vG$^m8CAWzQ-Y@SGiZKIv(#NIz?FW_nppA7F1ZY32g#T0RE9UFO_>0<@Lw zv6R=xwi(6dP@er^q+JO&x}9xBvNLa?Og+oGM3aPEfI6Rlc`rzQqicAtQ%K#EpQh^T@+# zaG_Silrxwora-ZwuDp{XQfiLo&P0A}&+u9wfp&MD?6C?~Qy6#!`ES2}PEc}`&l-4Q zJR@O{pGvCFQc_L(aA#n^Ydn}&25Wvwxi~?7FZ-LTOx8(R$+V*5ewqIBiVr#V3&%(G zGv0F?*m*$NkZxfvlmUug%lgZF*l_op9$?3&e?toCoGhUqba`wk(MV&$9(fOq`V#r zq0Qf}x{j1}%{f;WLwgpEOBSl=9)NwO84r*c&cQRsbyIHSJ%ReVy+p&AKQ34d94Uj= zVqpCbJmXYv4(d;UymF>#@EYD#s&G*o#3RJDP>O4mkY()FYR^c2iYi=OR=ORnR%bk} z?Su)~hdrqC`Seey3Dx+V@k!TYoYy-FJy!x>E#Bd(l=Ubtn){KCdU-{%Cz9&T@|@iu z-xb%hXr0`pP;F)~<$p6?QIHC$-tR(z z_U{>;O>E^BDCGWsh1@Zxn~&`rvQ~%^7h<1}h?<&-s&+#M?f1!clnYn#*06bw=gPiJ zuR6<+mHh|yOb1uSpkLC)at!8!cb%i;OjId1^LrY>gv`L_y7M9pkN zUHlWmZGP=Xw9EnTIc{+q}#P{CoFnSHx*z3G2iwxU zNFm3CXHa*4*vAr~1HNP*=Pi^&#%r(PSyWl@JicFI zUsgTi+xD@A?&H1A!w}8cNhk{yzhaNuRXpBFzo8{c{=P-1c}oajmson9L#zD=`?juP ztM_3K+Sx<3mu+T0d*l4NUF=o$vF%Pi!!AZ3y#-Q#1?Nuo8=kSuX7uIT*mi8UYN5~$ zpRm2%E9W1R#IIw!{A25ju-*Lc>{p{*!XD$3#Iuzvb$g*XFV9Naz+XYiZ6jZ#mt!G) z95H)~{orTWzu1g-K7->()iZYB(O&G$XJex0Px2&h$FVI@Ws#?tF=e<8 zS`I~jZ8X>TWPV-?YF6ZbEbsIv9PRfk%$wx={`- zPbJiX^c)Cqw6xzJ(9P!0Ha9hcf?;=G8)bb2iVI*+Tj^X1h>QwQf(|hYI*glvH1TSYGnskACM3h@aZn) zT>QNZZPl`B$~FwqsXZdj$}OasF7xh+R$T4x>h3v!>rvTxw6?$&#W;vE&Em}OFmAb+ z@Ohm$zm1xwQI^$`MxB>kvjYN!S;bF(6hDCyFT8FodDNJM(sB1@)!ci6`( z)so*&8ZOu7?BMFS`*>YZ4b0u_;X2_NCroDV`##>m<9af@LcILl$MWt5*RhSxC6tbR zw(&>}KEm7;M%c#NkshdKOKv(L=T9Lx%=)M> zZ&jE~U-56a5{9ckPe%xiqK9{Xst0Kyavutzu)JI2dlmTuSQC`Qtr6 zwlRWPcS({yNv*Uh|Bo`*R(Vc8F=tek@d!K7KD!&H=M3`+t<2@Ym|U=UZmK)gW6a$- zJ3y-4BCXzm-YEL_vdQ*EsjhyUv4{pN(IdRmM}9T(by7t~x=*k5kI+Sb*r@{&e03YH zS0B|MMOqcbv9t>>YRoxs80oF8=BO^l(+YDu<80%t!(d74EULHTuPpr`#eWKqnSP;q z1L=PS^rjLfC{+RHjkY~()4{4!S7N}1zeLq6|Ke-CMd|074=VmzmhN_$FZVM;o{+@^2PIz~F@Oi&HY zdlIek4rmv@C~#PQh}1~=M2C?AS5Un>?Cm@KF;D%T7Q8x~7c56k)=9dHxfkq3pNG0&{_`-1`}|6L4xc*IQX|f^8+pkwoIwSDWi*6w)sQn$YZ)9Z8M5Yu zXABQ{wu5GIXtZ$#c`=2_E9OdZ9I=;B$KPf4CY>%V{)UXP%3H2S~W^T763VlmWNb&F4K?Y=u5km~8q!D1=9=-h@pRt=5SZt?rjATJ@Q+ z_hau1f1u3FDwBE)(G z3hP#XrbLOKz}*qQhivl7dBl}FP#XzQ?a1VGMhNe# zGT|sRDnxyzX13;O&fkpT3_IjSQq?g1U3H_{O~1(XX`Fc7X;ri;8l_;+Yjw*p1Nq~2 zw)qZ^c!aABdQmItf$f^7@p$bB5pL@&srfR0eou3W4#%*=JQF$EX|BygUQDt`{>*#R ze`ep~PNbh(68@L0pA(`gdDyRTwdyl?&3^X5+(!L*JIcOR&fC4fSSPiRBt(%9G;JzZ zknl5Ntd}hjsufRmOJY2=<`VRvMM0L-F{(ulNxBbFJG^T73g5SDzd%d06K$;)xQVZS zt9Z7b?UqB(gPKf_^~K^Wj(+LmHf{kzpK{T@DC#SHtUp}jsF`CxmCOl?bu0c+#qK85 zjZdiF=J=3(_>5C*b5e!uvuyRfgU@NkzTRNn|E#G<=hi=@v&2&kmy_6*9v(GpBWGvq zL5uoh9-Rw#^>KW{X?*f!y#6YV$8~&v0%doeVXLSaM~WcOB2!!*ozbQCaaf+1njp3%HA;z&hYR(8lWJy_mD?K{(8@S`=xc zUUh=o*M@g~7q5R$*6C6IL<$H%7t+tiob52Xb}{OqXlHwsE1@;{anmgNPwU6S z?+K_+x}F89oOfIEG+GHQj-xn+w;@{dv>;WDaYJCi!zJ^<=Dx~SR)9x;kFbh)KLwic zs(JPoJYrr8A>cqH+7GW1{*v|7|=7Eno*n z^~$K6tVxC4Bi)ajp$sjZcC?yf;kIW4%IaU6GF_8(U#orw?b<1SxOy%_pub0l;1ftu zl)-Mpw6JJ_pcNL3gfElpL&V9xdCM?b%wUf=Ri7m$KiXOig?6r(K^B11v;ws+dd>hsnw&E*B9^=w>=O?t)0TV(^{#qlDr!8_ z(E6LEyr<7p+w@O=6^+#26&|h3NwwrFg+I{F8s$Q|53O#iEQ)(cjjIQHm=f07(0+B% z5n)7S4&}_V7S^O*EIfki$EBuqR=e_FVZbl0f$&T!`XvB!%pQo$p9HrGp6B}$N~u$} zI)=Tj;Q1k=9mkw_Q`%VYWxj$vy~S|}bX*ah$6@X!s~whqqaBrTStpz)3{CCl#aU_X zm20g>a25*Hi`S_WCg8bRwCl!Jt|flpm>*N)8e@&YXLM4X3ZqyeD#i(AW-p#;x4oin zRE>5-tbW1tmhm#|wN8rtBK|XXqSmQyEd4a$sC|<-s^3D5l5NK%`4w*AI7#=iJ_m&B z-2sQIeU1o!!*_6o=Osp9uN#zeJvYhk=k6tYJ#`UfTW2MU8SAcP?JaVb*jS$TptPX< z<~s0|kfz(sJp2Za2gOsLgL7#8FGMN9e42M`_j9yWWQuVOA@npL=iBG_DaR+171EF*mnfVI&AcU@hi|WSQnXz5!#@H^@nn|~~1DEwX zSbE!ku!T;pW9LLo)0f*;QU-p#fnKa((LVM@9GkP)o15$#_QNe@n)wZmhLdW7_Tlfx z3EhzVvpCk|OQ$NX9NCOxdBpY^X+iN)r0+G>XZ^|P;wPvB&*2PCueG|oleA*A94sgg zPa^jqKHH<)1$OOJm&Gv=cH!SS*JPQRqWQUhEzAvQk0rpd;+ouO$_N>#=@SQpTD+DuFq>jr>=&qK1)sVc z5^;3Agj#1CpZ@b=3rZP^An9WnCs_yWmf1^24=X8yv52x9l#WS|*9KyC^oA`%kbs7(h{j3bJ5>c=o4auJFU2J;|4RBkGNkaF?D zT~Zi`J&ix>-;BHe=Xrm=AgJx0*SxsQ?R)urp3n1nF7N04?De}FNRalVqY;izbfR?NXT-~DWE})ny1*w>4@W=h8ykFU;1i}-mj5c@MT*a{ z<{l0HfEI?m9C3)HzSbPc7NLiK@8kQd1jmX>f9ZK#O;SbF&#OtiG#ktJ5vf%dEVnr_ z?UN)5x`zVU%Uw*%<1AUP>1P|?6sy+qviPyQu4I%(&5?eYVmm_LRbkE5B9c0ypB-Fm zeMwfOc%^*AvuS5%{Xx2NuS|>n%J56SA6u@lP5Dqv8lncFA^#V(C)2Kf)U-VMfvCAr zPsdq|L%#1sJ#GFjc4_R==&vkSg5Ty58_F_L95iT zAtxZY!2R$XRS)W>DPEICAopEB-YR~iYK=uzH0O5QVGGMczl?p<2P!r#tRA#)*@=y# zN%I8ZV7XQ+HgorEB8jwrIlvF&@qJaQt#q}w;>eOk9j42?N7T`J_7xUnJ+kI2>gD+mE|w785AmsH z{?sUZ63IwN#<74LX@Ae>J&$~$@)@L?iyd_tqws}WfpAi6s>7^*Vrhgs7% zXf*~Npr`8j+O5_PjbHn|0kN;2fwGm`| zAu#yP+@nE)ZW-i%ouUaHYMdG`b-Idi@c>*vqrVK9BL5Q85;DnzBS;M6_RqI}{yi%_ zea%;Fp*Z57Biw~%6iJ33tgs@ zwY1#Jl3@1XH3uEYzSu=zUK~r0LLxiFn>XDb-yUZX?~Q#~$z#_9fA2+%rJl!2cFl&( z(%o?V;B)km)MAapV-;k0 zxb|&3q<=5Vl;F?Lu#7FYRHOPwq_&QVLNfVVXEEcZ%uu#YM|muI!G7IGr;s77Nh5BRca?1SrdCuCsYlzTr2YYBP;_|)Q!3u2eP~lSTQO~ zEmydYudof7yL=pN1l2VvhA^UK2_=$H%j2>S(lY_?wg+oqKmT``kKci=byf;NjZdG{ z%R(dMX;o?bJ+@ffsHlY!oO}~Y!w9-tjH1_* zSgD=J?w4!z0>h}eb)f=clp1xJY^&H&@!~?HrW)Nd50mt5J45C1w{83_Fd#1e5jiW< zYK0`;RU^oSfB1Dk2X-Q7HNp3EnA{uu`FL%JJK1q9b^JU})2NcaIET2E%&?RHyTCs^ zzz-C$bc)4Uhw3s1>J~2Z>mO66URbj2RLASGpGQODg)Ci5UHT=6&Ri5;JA9|!{2d>= z0CQe0m=$0NTGHd*X2p8U`Yw3UMgUo}X&==|x1QMlcg1 zfra?pi-^+@WY>czoCnCzdc=sF(CT&gChxt#W5fqO!5Y647=?VGF(kGJ-W+-dh)%&X zRV2Jbf8GIKQ}OO#@YPAzHIa7}U#g}Pd<-}0SH`tk5f^%)Urd^Zo<=UVSoX0l9m9S% zOrNl<)I)~Kpvi}*d}~GQQlLCOfwpkt|Bx&{g9CfMLqmYL5hrz%!k0PC-xcs) zow=u}&by&YRUe4PWLGjc1h-E3ewXSmtc$@&vW6sS&Q?wvMVK?Af^2~bNTnl`SN zC_Rod64aY1k@~_d8~OD@;Eu=nJfplSFDlee%66PvY&9pUaX+VF-sRoUC2sv!Kn06r zcxFZLCv9v+HnJS^wWRq#7QdkS$ZyGte_r8kR6GvgT9g&w!59kKNX~j0I4{x1L(rQJ zSU93XLc#gp&YJBrK3gSFPJ?`39oV@&^o2qoC1&i3@l99}9(y0Jv;z7}|2``46do&| zcZ4ziMvwT1`q}*IIi9P0))r1g%a8H7OM$C7z1fI;M0%jdOLdg-0Un=n_JNi6f7lBx zRlzIeOiXv?YmkK|)Wmj>>YygIl?7yD4KI~w?dv77KMs_*htKY$GpIOqXg1PmzNQk^ zY9B*?l|j!JLkm~(nIyhmNUB~;&fdPdoHg30bpGYzjYA3qk7VPuSH$yEi~X*F@8~jr zTh3p>vv83r!yad=)6L)N&~4#0e=Jp76_CDST$$9dIoTSW@;*Z9H!mhn#Mt*eba&~V z;UE5e?KSI%Yx6|~EbR%Z- z`sWTD%`7;H)K~q#GxB#ft=b@Ut;=Z`v$lpQgQ-Lrv@)gjiZ<^|u_u{vGzcU4VKIQ(T;{E6>Uy7d{6^fg1ldn5k>FN&|r zpLgG^OVN)Cl2$nOcWy|1)p9F1Ya@l-Ve5p#atbosa7Gwv4IOMn6oh%j{X-HNR>_0< zlYSBR4;0VZ_Y+kKFHBR&e;P^t&=Z&_z8*{8Fx3Y*BOK-f5snDKt$B8Z?FwV*E88VD zf8+K$`7Vc3pEmT-sA-OdHq-q5J>8O3)!h|qOQKlY#vgt(&-`7$tx2>qL%LG)m3VLb zVZg1X*G#VkSF$!gx$%e6D*?GUiPxvE>e_aKy&qLorC3l>&Gx8Jf8Q^IKVYBG75kvr zZ5wVAoL82S_f*25)4IZ(^J8 z%odJc#I|a&YxIXd8xqEIy`2I=4;XF_zs2Ak_A)I8v0A8jks99gY_Uf8F!po9Ihlid8FX{RAvD-d%XaMl{=Y1e){!^sDUC=TRp*6m*DA zVApQJo{i z)@EW!6(BpuTA3Vc-bII;e9WH%R?viK`yIzwrW77hEJQbOf0MmbVQnxB25(FO^E0Vh zRx8l01Mu|axkL(j@n4Z}P{32q$B`z0%Mk?XdEiwA8(P7#(?^$(4V3-(7`ad{FP|44 z1v@anWdYJxr;*m9!dX09o0d6_ml|u}GWky9lC{pF9{9a3ZREsmiUvZYmt3o*lTHzj z8SlZn?|^OEe;4=!`fs|?v8EU^=;R%&Bk(Ehe%!d)^EhLb{#lHScmU@}RaB4gy|v1? zVGmH9QOhjBu)P{t_j^8?M;_kcNAi$CJ%TEYN=UhdTx<8y0^MB! z!k2Ja_<$0_L+1G8BDXyzHEeQZ^x1Sp1S0AoXF7oKf3{I+)Z86!`urEUtRDvTTCR}W zvX8C!|BRB(7H+@H*g@SESPw2_#O1$;S@CRfHX_e`Ew6N*_q+;=bSAaYh|itxl)xHO zb5f6ZcrUf`@jX-!xtiy;EB15Jr?jt+rx2de0?cV8fzboAT94Tsmn*ka1USLTJIZ@& zIWpt>e?u~@A8tG0e^q92_e1Y3$a!<=QQYYnwk!l&KFF)@3?1HhYn0FCqZ>bn$c=p= zbyrlxns0g31&8nn_KlSk0EBzSO*H+@@QLa1Hj<9j!X?-@6^YC+ct>7d_fOJmhxJXB zma~Qxyy6^>#6F&dV#J(e-Sk3hm-AJ$^A+~Me>)JSkUF3RY=Z8`sP*&6$h_4md6KLs ztZ_G36&p35%FYtg04#^0E$AqWr>j=;7^?as=WjLaXtKxa<({auogQ} zDPIbUtc`7qPT(*azxAMiDv0%ybkpHcV>3i;lo8t*(}Wr7=+fJVCrhOIHMnS31f zc-mQVqhc$O8h5#XTrGpHJEe8|9YyC{e_20*YN>=}EAF}V?0)uF^0XX{)I_emcf60sd zowF?Yl7o>x=gs`d5qPZ%Z_)yd#j@;I7jiFuwjJ7u?XIl*n0$7&3Y;!9t`9spz~~CG(E*LoR9S~0=vBg($&VZK8~GJEd2)L z)9lne>z{dCj*u0M=q9oTKA_#Te3V| zBUruti0cUpzHq_RQ%k%*TLtdW@Aznk_^utS7cL{3EQqGh_?tc8=1}KzVq6=kY0D5| z1gI5a`BMF=rJ7It${}s7f1Lrl%V`{E6!wN&+dV~p9s<(FMXFBW5UP2>CyywE6Eh%t z@VTkkkZ6?nbuOUAM9YfL+n#l4mLM>^@Z+7H%yP0dxWG5r(4jYGU6Q;rSy{@xLhdy@ zCf%WSX6TI+uQ#$EVm5wbt(6L7iGsZOJa!;QPPjbtyKh4>#p~{-e^Gu!?tCk>?|yO zd=BA&Nn%?gzz=Kke*`rI_2B#meg9jInbwT_up6~7MVfVF*L0yo5^Jb=O6u(rjnX|M zyMrzxKyssr5}R4FP(Q$Dl@8yZ`}{I=j^T&#S$bp0{FL_OTi#0#cp-SBj8tkK>jrn+ zW*Xa)L4JJahhY5;8D7-Zl6%X$0nWI`l80Y^Kg`SjYEVz|e=seMnj7%C@dEirjIdSo z8^i56zskBwTN1bAtPBZDBIBQe?y=-$-4b+<|J4R}qZYxV8$9Sw9*dYkZ! zb<-v6k*=7ye|UdOg>)A|e*OT&t7k?u@$0y_Ges@HE8|JkoBk7;%HS+=blGo~I z$nzYK+=sr0+}j@(l)&<*L`SSj(QS!+fybl|_iAN3e{+#fF3ZCvicWgYugq+KJWW0-(SIUwZUdnv56L5p%VEY%#^H6Eh4_k+HGVj&(0e71h4E+o=^E^F>H|* z*c>PM?#8fhi`8%vt7jkC(|+)lMDZ8Qw8<=9sa|^u*@rHH7X&^V*8kbN9}2yO_?{{eEtW`=JEc9ke0d02!+uXi0ngzYF7kbe$B_*d zud|3+AK`hdMl|&^MD>rzcg?2IIZ1P@4{d8+fBJ-qsV)zR{94Ce${SA^Khj&Q&xCnd zXDwN1TpIge%HgobEx|s#8Vv91?q*qS=Ob71eT-*40*lD)`zqT260I$bd}Zll||6U-3I0iF%+nUBG~f4f-xy zf4-fF7Km+k7}~TJI&}?5oKb}Rkf0xRye8#)&2(l)p1JicGU{)s*eKRWg3O(+?V?)9OrI2=8fudaUv)p5rPogw+Z|8!0cVe@$wJ z^uoC!e_Dt7i`(Xt4PO>jkL(@aZ-nre}k>JgzOQHv{}h6_Q0L6 zO-261Kk3Vzi@hWsYxpwtXZ{*ze-gxWndu~Zd-KS|e(D&sM-x9!;H$8~o^YkKZ=DDd zkEzS}5nF~uJo3G~!sR~C1`Wq0Z>jLVY6%v@dMbb}c3^ruBu3OigGT*vYta{e4fBmB8bJo&i zr&!50YnV{uyq(GXszlNHb3QN*;q@TxTKMl9KbzcbteMtKD&woF-@JIMe8;Y9-Z(nz zIrMxFpH_D@S@(3UuZrrJvXCaLwp8^~I6f0TtxMn18MRW^dH`;n>J*qplO0mjbK#9$ zu(W9E{HQhJ=Qs8+499B;e{`+Z%u8c33ZGV0CS3ycq@Us(4MAmLI88DhUAr>*f5|k& z-}JNTr|y4xAHvD+dEt8tQ2(`Ls!}OrMm^KDzb1;AaUZy{J>BG+^@}iqCOy z4}5Yej@C~qXPy^gq*|XepIjhhu2qSu>IfHNbK$<3Zl`n2Kp70>VaDIb5)btw8p z)E3)8P5OuVcijzp-Svz|n%-r*M9;^1m;ZOMemDf5dW70`2kY!we8w%YS{jOcL%N|X zElLc}vFe7{VsBx8_(le_>t8u#e8Bpx#7w0>GOA!kVYBrk*3%DOS-}Ui(|F*ol75GZ zfk5^re_1+qzXTjl9(gA%)(x46@9F@{^g-iszdH6QvwE3r=uD*r0EC_3Ix-#k31N9Bz%%%Ppu&K1&56)mu=X-4Bji8Tob4yqTn*s!UFY zh75r2UZ~Y&)U#FC;XkDD*Ue-xdY5HnE1p|vbJ`=&Oe~px1F;8@8?x@{ju^&kVzJml ze~h|6-ZTewO*UP7eEiCJ{Bf4rB>@)PXTlH#C&pv&;{7x8C95y#n2wSj5+ z|6KKdNO0&yV6Cf)d4+%|{49d|P5MmBtAm5}NS7hsT5cME;Iw;Rg7BZY?v<|7YeQYSpG;f5Ap+ z8F~+S$hGB*DU0!X4dGn5jjwMI%x^V3p9Ab$7DxP^=b(d%Efs9_E(!b<&s{zZ^Eg|P zi?T+{=Xr_db>@U_m$;u)DY|1?G%uh{L#;OPc(>751la7%J^|ms686Ano8*Fa_+|3U zRq;JbmY|fad|^GWh?*lKW{}S3e}W#ZfEO#PehDHWl~Hp-=LDv$S`_&;xqV(VylAc6 zW&aPH%~c%M2yYraJ;7(8EMzf5IKML_eE~ z&EeYdSUW@nlIl(B=6NW``OfgOLx>&=|KDjuD#ze$NSv~T&k(v)a8`|cUK@LPg)uGg zZQbAz@c<{*&#UGHbw>V$<@N;jgJYYcAsY_(WwN4Kg0!5YJMHJb39H5gi??+mxWM>L z>>zpcvxEPcrFa}MH8*Mxf88e9@g{uSF`P%{{5W|ubZ9U1mJ1x`d8Du>;%!-jpT#_X zj3{ss@^Q90s5NiU+B@~lMC z$)jbqJ-8MRGKPw;Cl9YGY-l~Kvq>DM;NVY@9kXNyK1N1B5WOw1*VM>(UOY3}YnM}CcJ;CS6E@Su;vE)mv7?1NU=lrn$QZza;7HXEyJP~`5-TbGBhG)wNOIpr3}b0c#84SdFO zbT?%g3%VzSubkIXC|LuZ^Z8|z&(bGSU)2pIHN^XqGwNXyf1V|m&rA7T8U;MZpFT$ycy1eLZ_pvBs;5Tw_}!LZ;q+nYuV+aT ztyD-O$ZyQ(9lLcxDjibhD;x~lhm$>he_r<#Nkr25=JT-~q;N|v z)HirAZpFxloB~2=1bBxk)a{=IN~l`f30iq=c0%q-@ck~t9tFEnPL7bHnT5c53yOj5 ztl$Fjr!;8Qh5FeWZj&GK=AT-!Z~TCyf1)Imd|#IwZY8qzXOOF`K*VnZp0XR3rtIM& zM{WGxUP@=_P}21ZtdLgz&KX{9Qg0=m^C`qRu3=1W&ZauOcaIyhSr2sidA^f<{5#=MfAU=S z?o!1h^gWei-l!knuE~qS(OB^v`AJ7?zYa1SLsiyi_^L#JMKC^+ z=axG>t>GOG0tsYi{n@JRe*yy<%DfD#tAZRfS^wLFR~5>qp095dI`SZE-Fi|Lb&Wu| zxRn2Z@e#c`0%o2OR8n+8f>>X$7CW8&h}a7$^99v_wJviMYIu@-1ODK5pRSoId}Dbf zM)TZnWJ_-ae1Q_ak|MUQqoL6|u*3G~o}p-#gfh+BA4Qan?)`#Z!&F>LjA1g5^ep0e&G-dIA8 zq~)xq+{nfb(=c0>#kgk&_WeowM0j5+ke_yF-yJ~q%7t3Pe`;PKZLquYHH?D|9*#og z?*&h!OT*82z?bX6r(HNtHO|e}G21Vid2kg zyVT>eoYvA{f5dRsY;cGU&H7hrV0)@%%NIKgD_hrZi+C3uB3zcd;9DhAm^FL%GZOvh zwNR0hM#r))86WVgt&AIz|UeI1fI>Rmu`jb*berSew~${H9*dlPiNK! z4I94^`H5XhF4$+hLq)u6-jDe%=IinxyDzrhc}pHSe~tgj<56vWCjC`mhuwY^u`k(` zn|WlMd%AZSGHb;<+7O(ZgH_l`#UUANokXW6V~6$@^nXk@YY}6FBV~T5mtmjoM*%Oy z#6=vEJw33+>`0m$@SOgA!O~fNz;iZ)nG&tG57yfu)_P)xmH15e+0ZB99r;os->10`rCz0Uk9LJ3gFkc1bvq^JK-hG`*Z=-(7`r%rHXU$eeH$y z^LFI7kQ#-`QaSQY4c#O*iez^M8+snmtv191Fk|qul`m-1aufNmf>phTvJZ+Ob7eq| zxqyaim7Q67NXh=pHdYAL1oiN2RZ?r@BS6EBe+Tts4Vb<|{Kx}ektLFMp>gVBX>sJv z^>^u>NqsdvK=+L9p)6zA%UMR&Z*|g>R@hPS@Kup6a2s52--T-VRo-2`zlIi-SWeXS zjB4CmPWa3XGEmWOqHFJxd0K4Kp!4(Sr9-hkeohZU6%N{o9cL8pp2z#ehzCtT)3)+i z3rISeo#X4PMgBti#9boAyX+2r3aH~|d{gX`QJ^wp=RSaMD1PrD%)%HDy>@t;f2wxf zrDeyeu-4Dg1oY!fC7s~id1x|H#J*?zmOrjn zEYprDdr9?C*uwf`CL`ty2G%gJbxyr=J@cvJTJ;M3x#Ypuq)B)0)wi=o8qM-z{j(fa z>H@|1iP(pgvdw?lCS%+|)|fQ@f8@CJCElUg^4-*a&0DYvw{1WBus8Opo|Y32^P(xl z0FE!by(YG6r+>%J_KpFZs?$7zE!X=G#_KW?9^SvEu4cvaw1z4+{TArU1&EKagv7oe ze7bT?Z%IZr1ifUIk?59b=ifNauQjopOuwek72$>-vhTX(y1TPx&E^5Uf8Y4gW;4&> zphyFIJl6OPRIl42oX@(=x>@9mXr(v!>I!aB*+A=}a(q0v<_)Hv&TzM^A@8`}BWYc*B? zsp@ABIQG}r*IN0i27xX-&1dU|Z+eC%yH!rsfGEtQs$myI`Uq-xe^lL#dz~M=gM38c zd(kfgzqO2lV;pOqU@n79b)|e88$*=em|FcGX5#` zRf*-sJ&0Vr_}{GWe~b^1!mxFc>a%InYNN%QJcnIeuDi_Q#qTv6ksC1|M@Hf@DSr4e zO>Z{5mrje9ECi!QKfE02&fcN3FAvFjEm?XYh~L-|)WaU@62Y-=e9rI3sNLAlGa|c_ zFoccs9TXzwcbYZe0Ai)W94Yk>gCvzhXTVQYfjVa=`o6m8e^C6hU=tZ<`5D6Q+#%T0 zkXsN16g&P9jlFY$6w}9EjBp-XjIwjF7a3fjX5Ke}@4im>665_z^{>5*8FA9(RGGPa zOEBtOy0E_~RQ3^`jZ@mbFFVm0jBYRgE!puVYAz)=RE#}ba&}!no)#iQSOHt0m1S`Z zJu40)-_!%if3l%g;*>&5W6!pM0m&C@r~qtMQZ3R+(GkK6Q_c_JNOr>-u*2qODQSayS88;J1)Uq)!K+!KFB{<#PTDGs!Wqg(IRZ<@MOLZd z67B@S6+|T%ma&GC=!YD!j^(ddi)^zO>GSt=j(1vFTLml??yO&k^}hP{H5ZiKzGiL8 zd~>A!f2)jSb48M%0__3MQCZ4MeBb$~BjRJ2eZa=;MuxBoUcC+cUQ)eOh4YkyLG%E> zazXPtMMIr|77>2gGGqnnSU;yhYj_Z?Q*nVJ6N!f9PZuFBRSQetbe7-B6|lE!d5sjq z61TzH6U6f&9`8=fbR+tt_JZ%W5wa%n@D_~fe*wOlD#RIDapjk(3HLDuOVi03cSNhS zar6G(m{qV#xM}`6zv1=o`9?jQ`YJl+f@c}=x0OM|dW-xQl0xZxk>dw_a%f?Vp2zXLhB67j=$o>Acu zfB6cqKbbktXZ||%X^YqTFO0vlyd3ru6Ek>@tukaSrWrfBwn1ve^r5%J!egp17A z+t-_QZy9*HcvN?0WA||I9P~)eJn#v_e}jDAbyOE_o3!fKf`a|TkHdSqLw>z}n{gs0 zjaRu?gI;Xg9ou&AjaL$w_|aCD*~zgU#hUhB`h?;A)wfS$$P7nrLD*wICx(;NG>e`(+6z1jJR~c`7iiOY6ss(s#k(q@h$whVVbPmRi4%W zYtSKN)Le+YjN%>zd2)!4)CL@ae?;R|pJutcI`rMELp|0x+?9BQf>{)=x|1cM1o;`U zM^tB^0%R6G<1u%DVOjNG9|sq(XimXdRPFXy=3}jk|5mP5A*%{8hn52zgy&*ITu#+U z97ZOqNcgjNqjo9f7LA2v91*E}u)ip_ZK-qw_9Ui7%LR!ySS1k{XkWE=e;(FqBM;~; z{#OxKEMs|Xryl6_8&`(JMwHJboJynU!hR7mavV}8a&$toWMt=;+|@or+p76*9x$IB z7<+zymJebWW%zU>*lEN{=t3_kCpup^fRVF7hg1PY;6Y3vpXURpJxGj-z)2tTi(0nQ ztx549qA045OTHE-8Nn(Ne{@Te#IE>tVc!@}eHDAONW&89$hw3|a2u>4;Yt3pk|tMso*bG~R`KT#kwP;l4z+Po zEIuA&sOvTPtwPN63{XD9U^MZ7H*}cKeo}Jvg3?KvC)r8Z6>iADe>i_b7|q1eY(tOv zH(r0p&;$J>y>O1f3J^PH!KMuO%Ce@TfS~V6dM^D%NPz=c(K5`c6R{T6+i94`Vju8z z#i+s*T_W`(HGD^s4Zh50?}K%!5PXGL5r?raN*?Y6R>v0_tNA(bps2M|2F7iPT{pmr z`ve^~-H5*M6-E29e`V|=BO*Js?yl%ZSDDiu(L4*ma17z9L$dsMziXr;Q6C^P-G&t_ z(U&pQP|K>7N;uD3$cqNfMm=>k(1(M9PIxPk>ZSUfRBfvqp@{Fa1ra!@jX1>jXwxDs zPGp;0sKQh>q#H36v22C?MP>Al@g0rh?$5*8lp5w1XqzJJe;^%NjnqL@GLOSXwqf_F zf~Rl}-0wr?T~Ylc4iE%|4bTdW+#j zwmRHNWGO)vQaRR+4Rxe!wV`*Y;N#?cQkQieykVj*JK&KN03jf@)nwMa1ew-WaDbgd z^=>Kat4bgte@>FHEOyhx&SapQ>mfn;V8A+s$jy0R9on>AYnW7pq76Ew8T-^;o zau{n#@?0&j!V5^%d5z$cs*n5xeCGn}ee$;qalK>E26-CFc`sIzLW|qM&+kNpa9rC} zTv(lh(96|8b&EBrj;QL5+E6=nS=*HkW9PVxcU`z|e>=Rk%UH?cdkCUby2qVD97czA@>d1)9nt_MhXJG23~ zx{!%he}9|cajMnnLd0)~Mzr&dV*kp=c*(KRJ3+(WU)J`IVeLxn(4&pGdk<#Kopmxd zhvJPU^ShddlCSyws-K!-$C5qqG_L&=GF58d?*luIilOht)u|fk0?dlUXBxCPVm%~J zWc4tvx)ZyI%=ty!i3g~&JdC#7-$|T9@iXRYe^y8{-gik)TgkD++|46(5E`(9*Ukv! zQ|Z1>FiukM-3h*e3-qO?Uq6NCDttsIz`4+dRo;(%VGN#bDLAF-q`uSVPUvR0)@!bm z*WP((!7@m9F|WY ze~g{EKI_sh(U|Kb79AnBMiKOWCx3fC7#SK_2b>XK09vySDBUqs5GYo;b8JCvQC|3yB+ z|G|3fWs7t_k9-^I+himpN+Otn(|qI!f7A`iy>y_KE?(2}EzsVA5>O){D?mkWdof~y zfgHxw9n^M&8fdXnpuKuDl$Ib)oxr+&s#T{9!=Bj-e^lYpda*8K#6230tQ;%fqpdx) zl1E6PfO|E4AQo~yjhZO=$2f}WkS2AJ?u|a!u{^OAKy}Hw5nJ6E`ylu$cmj8ty^0*ysI6@E@b_f6LCD6eO-Mg-_B8jDaJZLht)0M%P6 z_VT%A^G@$_q}L+e*T>#x#ODzafA>bGrD=Tep+CP#%-)M`-o?yo=67!r>G!(fFM4B1 zZos@{suE1q8K~}9s($Tl(z>y!zsNc)&^;qOzBE}UXP0Zwx{*DL=Ody-SEE&sjfB5X zUOXoodG735cNRMkwPh@)q3`?Ary2JweK^%W;`cywjON~^c@Uyy^P=X8f4o`6c4`S4 zrvLJHncvZstm&hoKUyG{Ze2~R16WkCE(_TvW6ue_Knuv`ccBZee~;;fIi-tw-uzj708r^3*1p}~cA3DwP=#!lQ}gOB!&a?j zecUIgcs{z^V0sG~TSa1VM5hc}e!%(~k>d9OY+8fA`O-pq|(l_}-7} zzaozg`={jh`KU&CIFh^m7}k?8e4f+tgq|!T%g7?u1SaVO$#d|Uco^nA!dz|aqySPC zdnyN+r!ilu3PIUJB|G5S6-Lp!!c0#D??UICBiJQnUp<5hCFS{@=6f1v%_=d~I^?;l zW#`&zjqSkB*J1IBe_Ts%%*-u?{0n(+$?&_wa>e?P{+7tE4IRPhdP~^On6xDe`3|HK z`YhkqMIcZm+FroNECU;4Bac=GaLkkZLY|=EkpIP>JeKr}ZOv?7Cy+yU^s*j-KU^h9 zEnXq)g&5B86%O*z`jI)cioP{|B-)I>BejslLBohWd(!^ifACBCH1$>8k5(O6J7LOT zX*-7*9kqT4$(0QM5G*O)I|38=J9?I(aUf&d@Xf?xcT%XK!*C|{;D7k8xqw}v9=2>T zGNtSx=)K7={D+&P$*uSHeJA%Q>ufi0{*nimh;kDhSy})ut`H2n9@1|+hgp}a=;os= z<6{m`9QJ3~e~X&q<*u`HkD9-eJCWY8RG4)M*DQG^LDSeR30qe2V~F+C9#jE#LL1xR zQ_GlElgjUk4mQ!o_$=MsJ6ipoGTbg#XpKR(xj?s0uVO=ae6B^b&vGS5ss@DtrwwdY zPVi7!5hoJgNjUO_U&Z}_+~Wx4v-CI8$=%*&$4*q!e@yFuIJr8Oh@SMhf7+^<)?bpY z`}~Z@w zu5~lol6s#+SVN=z5;H^n>f-O19@C9Wru5B=rH?mj2P^sVI$p#YF_XMlUrRst1!TY@ z5jaB0e@-q!uGJg($xMDGH3yPy2*vx0_~DJHu&;*BG*11_q!iZw8}VHJW@4Y1{ITNs zI)2y8kM%gy+x*H#FnVs}J4wX%*YRuK{Cg1|nXDle1@FcGa&{};l~02FofMg1z`-K4qUogsN<`}$QZ&xe5>l{kqfa!!`;;T%9O z8$Gq@W@Y^bBV!fZBJ%O+yo#<<7q7pIo!M-YMDjB;KZ~Fh zEH~3Xv7F^UB=9M$@CB4@P1w9xe_zrZx{VT}o(|q+O-P!TdRTZldEd&AoFQU$u;Nz|f^KYf-O(U-0Odbved!%284htqzJj&v$+DtdM_@*drf;9-_( z^#dh{U=$$IHG;UF_=p8Soi@OxDd#gtonYhI^ZdM;ZL&sQ0mt-~w6j!c{ASkkR4<)3 z_%514G9zDE^LEml*p8^D4c>nDf4x((Gedt%)Et8&{D-^ybkFF%rueX*WX*|itodr` zQ6I~y6y4A)Z@LoY%ll~_{G%q}9NP4tUmfqDePH`M1O}u|bnvJ`FMwkawdu3J4A<<9$k7AwL6W7@43k49}Q2eJZu9$moCiiv`8B8O*Thvf4jO~#gXh9 z7iux7`baxsS3^M9tLig55TG(vQwx^=tkwjI5LYB@Z@XZ?@Jc*G9m+Qu4giRvyhv{_W z*ND%u)tCBe>L+23Z~unee$ntQ8^8+Z(PB$>#H$n=tqbVJJjBU_6>$W7Z^c>+MsZ;a zzuW|T=PuY^BdGMPrqQ4t;mVO})~Gu*OqTT}p0t`!?e~8N1_(+W!ezFXC z6p82c(b%$dE&nBX7>O*NLHyW`&RqG3H0_0z>^8i(JOsW+3uf{nIb+g*<`_k!ss(YU zrZ*lTg+p_I!|-Fo7Z1ZT@5LH&lfpZX@ZLV`ukZ(M-4I=P&jWOEBcd1ln%|FE8U*{$ zzom#@t%=CGsU{KTf66KS4yLJe^xCZE_g8AWlWEE)?#c->`y|Z`F5Wu9mi^yhCT60w zZm7&zxy?i=^HX1qy^poT2&p`qRLPVJj5K_Y8`f6#QWRCgloCwbET>}N5~ zf(hhL!+Q@$MSk{_&KB;2a81vLPm3BrV~4$L-p@x~Nh{-@C1EBWUcU|4%Ihnif`9;P zWIt5wW~n2o*zzuWX-jBBLVWH~wnGP$KG)sJ@+D~1FC_Z2Qo)p7QWoPx`GOIAlTOZNc#4ht#U@FIFN@mUS; z@_W5ePiGlZwo8?8#C%P^)kD$*wRHjAG0Nbx)k^)FPO3{?{=I7__*!c%_wlL>$vH;x z<^#HW)-T_>65f-CtVu*RmWWq$ckSt>rF`AJk#od{e}>;Rh%7}ZWTYOb2e)?JzSvhp zd)Lu%QvE|@rizUZq9Rc0NsCFbT#Gj72HIBX5ETLLL%dpa^aM@T>P|o|T|jI~yrC0o z*M;j5=GoJHMupigqGOWPK^2Rv)IuQ8Jz555SYyt0u?NzPeXb1gX*V#(b?`)3+x#V% zJm`n(e*)IEn4Fpqd5&jQ@?6$fiP(FCpTn*E!DP?*{cnEoX7nOpbvO2wl+jPOl8aeeg$grw@x4) z-Go@Ns@D;;?iXt=B+bh#+-&r_JL{IXdC7B(-;f72S<>Zam>umf1V z>X>d)tm&oLokkIl8Hc^liO$W1;3N?Ff7r(>sh?D~Cx2Tr?^C1Hxvg3H4sFT6x@&}t z4@$od#HKxL6?uRJRlTjda4g9@=JDBUXZe$=gH|?91>*L7Ksl+*;s|8O9(Ba{b?BVj zxheAl({#g;kHkLcvwN3IZ;^VCh@(pu2Hqpq z6x>52OXL9!o#2K(90X3^hPasvSZ*h5*GAzsXNy3^$J`1RP6~z5hy3XoFgK{UeK9N) z528SlW2hvL7WXOFV#@oVd26-xDmj^YVA-Y0{<2nSrudUaHH>K$m=Q(KRFh&tFN1BY zx*v(I5r%;UV4QBD!cD(|MJ4m7f1)JH8jy^-TumO2kW-7uh%6t|s-UevM5x?mEvf!# z)xe=$;G>Zqg48X_ zvSMxI^G-2{u0xW!tB`T=7X;*Sb^QQfK%c+H*WO&gqjp%bAl45PGjit&hsCDf?tgv= z%=sS3B%d?tX<>0UKCq(|9Ex4+VP;3<^0TTPt!cSDE@jlSL+sXQQawzXb$4kap!}D7 z^vWv4z98dz3P?BJudW7>j_t6- z#!>GlqaLjxJSW){Dp4IHGe6?`8>SxY11eWQaDSDak)$HYG; zk4Fq!?pyKbb&&y=mWM7Uh30Yrb2rU~`sk;qR2f4wOsb#GYPN3~JV@@>JIWXFViX95;Ou-%_tbrT^fE;GUR6<-Cgi1#*uBdVeddCm4?-JXdYJq zVxM*`i#q~)!;ZVJMKz8ccYiqwT)WEh%Py(%0t$0~iC^VCkS$hE?%brK{zI`#End2k zi1L)}Q3+{hH+3N^;Rdc&MnByk(LA~V=e1D;HS~X@PtO9$) zA+Trh-k&v_XF!f3-nSdI6WtqrLRC?r*d^@#S2Z2LGO zPB_m-$hKz9%5kz3t$U}0uSu9D+Mrj5=}SodAW%vpsJJ~XI?Zy)lDDmSTeBr0?lC@B z9!rvnDKtmTC6yUhb$_ESOTtd!R4zczfMR+t{4CXEUD}x~-7AbkWHr2I`v3f|zWx8k zeoh|a?{be)m)VDUclWUs{>ex4KAIOKOzM@u?z*sh*DDETX}ZYTZ5((7)&FS>SSvx~ zcJOF@!M=ivb>vCd5>5>-=7MdcSOPDAjmH5`y#d-=@o*H&%74a;$m0;7qYMZ%m1lGT zQ6qm(XjrBKNO6<)s=B^%*bfwn>VK}#1ZzT2CM`g4R)VLXTk(3o`7?BwkgN5u84U#3>?tGIA&G>w0cW^g_0 zKClQ&sM3?7B?nR}0vfWK)3mc3d>dl46CfmNJO{ zRqIjXKY!!ZY5DBya@#k_c$?z>TXG{f#&}i7>?``l+ z*l-){smrPUY^NyR?E|Fx{)KAjc|la7@&$Esic zD1S?=!ZW%fA3?{f(l;jfIN}wQ!fWnE9H|V|m|#44z&_hyprqqJS%x*{1p0-?YtWP z)&P33D+}C_G$&E87{ck^&pM_7zL4tAdVg4952HR{k0>7gSuJI2R=7>`azsm(W35$d z@m0m_Qi0xA6_}wq+;K7N>%HJg@nFwyf?e|o-$g0v&JMv&7xvR$d_rN~%JBJPGgppU zH#d32%v=SMUq`M_$-iDhUAT-7;Hd0@B+Ua(T{@~ZAP40({thEEp!Hr5M9w)a0)Obh z%$8Gy*+f0qg9JNV$q%Wf?S@z16eJw&`yiPfsslG)C1&X?dY=?%p3@+IN_^2!K3*?k zM+1n>7ixB07fX{n>k?~0wzHzv@zs|LlU(ATd5p?+L$F7L$=9{%zcs9Xy|D`#@>4|n zJJ8Fj8u+h5a=aIoB^;uMr~sHyJHd9|>tGOYq1&#VR4tu~giau4?hbf? z&p5>L%+{L!V%4vLrSy2@XMb!Bv|08ARQM(%zjJ^Jc-2?%)eB>4FH6jR{!R~ixD=o^ zt^u*M5+47vs#=tKa6EesYvs84v@xU$(L4w5*e;3>h=IM;LaN_#J>+|4udJb|IX&U?v6M&nbH;uuK`uAc_rQ-tS!aVVYxz8X$hn{?@FvP4<1J+JQa!c ze@RaCzsc7;<#EL1WPVPtEPskf-e*8e4!}~`j|#_8RB}ihQ6eFqpu&9wHLik@Y(*@o z7jZzTHWys@3Ftl6dQJi&C$@|WzW^`U?lcC@qp*&h0H)BXC{ zA@?TD<56?z2eOPQ^ONSqq-{1vejQu4;)~3EG-kSg_3eI{A@%y%5%aTdiJTMnhpbDv zC9_^#B6-r72#4|O4XX{m;d|_*5*~#TIw1W)__2_}z(jnMw7tkTR z7jiD~sIt}Nsk>r34Da)(6eD6Hb*mB)%3rkzp5if!m+S#Mvr$1kik!k>XbrX$uwynG z22qVS$)2fv-G2h0md1Gwhq2D&?1!-L^r1+~l;q@qtv#^Ap zfh{1`b2!-$$F0t~<%8kfewih~1=dn>#r;8IbLNVad%}JKbWyJ$j40DDG1kF5i^K8* za!0=;Be5bJ*Xe*AFV=W7uci~4g?kLTL!#g(@t^FM7k@E|a%UZ|QR>07ehSebVR8Ko zSu|DI9F5L-`@uKSnDAfd)VqKCu^7Ki-}COZ^LYKuBbl_Lc>k5-MXqhR$*YU5du}!SaN4s;{W1Am z@Gq0+ntySg*pL;A|F|NeH0zP?y+$*BZt~sh9+@-#+xR_qI{lUZ`H26G5%m4;+AGul zzwROP;S20hruKa13|$*j-x;r`V+^j1hxxisTlq(DtsytLx|?0`jjwH=8oyU`Kl&fu zxi79#qP_)qesj*f>rpwb@415O9%=nNk`dG9bbtE&-}qWG|FrS-OkYL9+AjP;lg|y4 z_i6auUpX@$ef#O}e{aU)W>@Ds?f1;j_)fcT)6^#n(|((^_YB%6eKj;$BoLv)tYe0O zT`}`(%cdPo^;+Agj>-G8^rP^_V+%jlvA)=1xV4x);yFNDupRXs?LAFPW zEGWk7TEjBh#CID_3yl-TiKz8d=JU&_Ie%=c?WI@9>F-*Ts(Z%zA-o$8d#JV8a};0i zJLJq*2`(|GI_6)3QD;&G+o29Nq+N^qyR4bC9$6<3;!~&L8Pp*^)ra~CK_IwwQX^v5 zI8SA^>iIp%)%EZ<3i+I6g22UR%c%{P>9F+Z3+hG8tu^fN)I1tZY9L`b=taKdI)9uQ z?|b!Z1!P9P!mq#0KY{{VjJRqqK3nUT2tDNas}=4GSVKz>h3gqa|2l@@ZE9t&z=d7= z02M`lh3d(6^s1|c9WernUaA*INFi8jFptr^zxI=Tef*wo-J{zD^{=?L^5JK7thycj zQIAp8Do^?;VJc>Mktk)Su<9aCt$#AVD#q^C7$QgEyLF|FuU+Bds?SLFxrjRwd(WLU8*_|))XTm2Rn;RtT=Rox%(o?vOtDRL(RT&C zo_o~CVtin;ne@60^i#N5zZ-?VTc32!?+!!9GCp$BIo+1)@sCjvQ6Cs?-`=i!&+u^Y z>J>3s-Nu%*1veb^+Bdb1=zoY_smCcwRR6`kz;nnNgMT~t8>?vJ(uZRovA8cWg8$D~B2zbuC zhpg-`L<0%$4L_f~JHI+uf$*T$uH`$jB17jzZsRwS%ai&v|EqrD>3@cTL$(*_r9rF| z!P>QLuL%i@a75(lXQxHJ??;a1UP;ewogmfM<8ODUQ1?31V{D-%0k88lwFIf^^D64s z&C_)o9z%ZcJnl<+>-A~Ay+pryz{cj$(B&pX^c#^AmYR?W4ND2X%#uKgcW7qpb0PlT z7BS2^4G7+(U!?j&8hEvktyMBjUp< zmprCr!xTIH1gU&%8S*}-&?WE$q+O~5JK(oBp*}=%b>fLEwtgt{5SPsVU((JlnW83{ zqYbxNKSU3d8^?LN^d3Q+ZswY<^S`>;h^UlQ{ahrEmKFOL(SOJ;AXJ)=qsYc6tWz9i z!a-(yK+|R(_(@|x)2Yt%r?r~XGK{fkP?nKZ|4#jeABNluYb;*+>`MGnle+`(ZKV1= zowe0xBd6(p$Z8RKKul1Z<%+Hbd0_{&qg&r%8r5~9vN0dpPI3Tl z>#R+}#C#F+-hTtk$Cns6Ct_R@*Z53Wd?j9D?Va;j5gCx4>X(k;9I{8}GlEZpcCPynA$ z_52$~{KXv-2ArV6b+-Fo4T!<9>k&)M<1_CiXGEan$s!B<&r-E+DEh0IG;kIR+UOiG zCPk!hoAs!8ma9Dnj6?-S*b^ZdQprmFibn$zljg9_=b(&%3Gl{r0?syYb94W9WWd(1YTGR5ppK8{=1S@PIWrpm6 z?(^lDoYLl*d28;Lj$3PDp*MiF^J%3f6Okurj`drXvHYou59t&tYq>#QvD*)* znn*1tUrwr9q(Uziz^`vW_DXEMYS?`Fq_{jqpIlshJ1NG2d{lVX^Y1drqDQ|J_$2E0 z+@vtP3L)iTTY8gk^5&yBR)5Z*@lOhchOC`pF;I~h56(TJMH(E4(%QkBQqNY7!mtP$ z&wmb#v&#RMV+{;x8F+cMQEVmSpLiD%#wa`D`-)l8gZ$$NY{pJ-BdAUuhmgfBfDNm< zi%BlOhV`vzgaYJT4roXbrBm}^4>@4Jx^T6kNf+qmNq?WniFzQHC_fJfH3+E0v#Y@Q>nWv z>S^hiXB8~A;B4J`u^nAWbInK4B~NxRshKYz)yXFhdaDDwR1K*<>Sw@4vj8KbEW-xu z!p(0>?^w6*ce*=aIrIhp7=NoSMC%pM3zUlJ9l^jP3hFFJj@ldhYaS1lkhp(X^A#0r z2o4%fY3IFUOG@ybZiDw*Zc5d4rnIwH)5Ig4Pi2As#Q%>Yn#=pA;eSil1xqm1^9peS z&E!Ist_~Q0eZ0%9&}=l(pY=No6cm*eu`>Kz#7bPbSOO_z-2SJKe}AEls5`?3Qs!^I zD$L2ex0X?nMlYnicckaprV)g?u)J~1O{v3wSseEHz^sHZ0BmIE1AcPz-PI@Zq}nl={Z zp+efrQhA7_Yw|9>;Mb%&>HxIOK|U7SCA*(tJzD`iruN%>jJJdDPcmxzNHH=TQkv0hgMg95jI(~p#ND9xHCh^u{(JAZ!P<@nRH`>oj}*vXe6cG zBAuJNs7UJMjNb%27hAVtHFO7h&IAnurN%a{);*Z7Zp$je?d&m>`XxsH*7u#5ZcBny zqNVN~?UB2d?I%y-pH26!T4eUoJ)@sZ>nT2I9y+f`CV#6b_yhi*Wm=FIzVEDU@k=w2 zE>ky4_aC}D+2XTB-4S(1?0tL>eW;>WoN3KqJ{t#{;-}C~b>Jm!)fk1Gu%`Eev%d>0 zA~s%m-82!n$p0#&NbzpD10?%ifsrgmHc2X$T7eKP1Vdy6de)zz%Sm&z3U4>8oO+h{ zeaL?|0e?SHpxa4qu#Y#wyJ6dG=LVp+%fJ=sp=5Nl6}yLh3sRk_;{~CY_5(f|pAkNn z+wdYk`+~=*5qHrIO(0cAmF%~)qEhJqxPLnMQIq&*T)l&e*k(|80oU@7q`BeeV&aSs zus0_5Z5@9yJTQ&VeJD`B;WplP&#qdOG|#wlbAL4TZnzri#TGoO4wi>levo!a)>zhB za!>hvVk^BT`S{=zUY}*##Af}18lxY0BR=fq?KM0)OK8C+;ekH}E4T$%le0V;{lN1n zuC7XCFE3;7lD)2o?^Li5f)Wemc{~T^z(K^kDzM+#H(U*HT3fQ8&k>x{S@V9jqNOud z^ncFmrB7I{IqH+LdczUDQyAS!TW$}`5nSDdLcqOBgp7% z=by42Cv*v93)?~CQBSi^zaML^1N?{Ouu<|edyTJypQ#q?h%LaNIuOSjB#Cgg(Xrg4 zmV`Hd7TW|SmsTxqu$_IKEn*QGIyC#S6n_yFw-%uZoYvWdr6w)%#;BFwK-!+0c=8e< zks~apIF_X4tpDOr9X0b2IvEw(aCPdn>uY_}jTcrtfBkuNckym`o-V$H2ub>jq*$ti zAHET_`!?vV3E-UTX_O}WDm&n>2lP=#9ZIsmG2rihTAs_z=z@R(~L} zrR<+-_^)+f8af9VQdO10Aw3Qru?p14oq=5_d|;Cm0gY^t)nK-5bWFM@imqM}4kkvy zc@D!$w1Mx(h260fyP;rqM-ww5B>Ipce7d-bvZYU;+f9XZ@tO6inP^M5{>ayb@x+xTbR(=Nc9-&1b@?lW2X%)p@KX=jA(ruB(WS-p}ks6?-WL&fY;Ch zw&8w!!@O1j1yri7t0wU2wL$v{*V8C8V3Ed>*RIu{oad2I-9)65)G6vqBI$w=6KAb8 z{JTOJnN5f~C_7MmmkgqoQ`R6KeR1yI%}`+rZ%?)JNn zmPAE~Pguq6?L<1B7u-F@H%-qxjjf*j`jlDRfjhznh2*rD?rj zq}yrC_)YvBmLFIWc<)smK0*=kPp77|1b80{Qs$$7!U%Hl1@NXEZ0aW#9 z1>!;CONwQ25;Y4R4YAHYg5_YVMEulvNPgFbTX27&-~efZG^l8ki+`Hd$MdeVKJ6^H z3)$mB7f6X>*?6z@zz35W!aAUhI+F;qJqnh*|DUpVfs6V)(}syn+8o-XN%KW(x36{6 zR?^1yPS;J_xUXwmYPIN$bC6-20c3E7gMgrp3Y35nR~QgST~SQFv?7ZKG>{mD(PWVl zaFBRFgA$Dj5~?s-vwsQsI556v$IoJ=+?XoTs+Z^ zyLo2|65yLOHGh6FNsP75vB5S=Z!f;7Kc|gTlf*57KJC{qXxIWU%_%>u+5A!oemMOy zuNRRupTI7!1)jd@FFK5G4sBS9{N6EYw=U9+2Y$5T4U?$TF5ve`m;3CFt=yZCFz^V}Db=|@;WG^g{w>4Zj z!7gZ6`F{z^ht`Kt?0C@*8K5H z=mzYE%~a33O+{5CO1uv!t&&lYu4f;jPdz~B+<%Vq^|A)4MYZxE7}5^GD{O*}IHL8c zDPAkdNNfjsq8~APx#CVduOf>*nn&?f^wCMSu%8sGOn>Hrxj(3kjuGdH$!Ova7=SyRW z^M4LL*$1>sAG%c)rg{i$#e-U1mLJuR3JAR1W*d}?7*XxCyVilt8B ze~MRk*foY_*m%g#3tBAn6za^x@7*C>zdT}H36tO@9D^<#LTso8wtoXG7~vMI)@UgVBy(h|V)*MEbWW*_XFPEz@*Ej0MIcvu;tac9Q=!v3K2 zb8Av5NDAdIfc}oRpvffabb;!aO?rfYpt%hd{5`3_R?|vqmq|l3+O|5 z*0MT}Lf%{gmT!o4><}V|?f5;YMSml=Q9UrPe6TnKGqGsjK< zdzkFCdiJQ;vIb{!zl=>R?^H*&=V8?Kr_Hy}nXJ3EvaBY7siz9H84RmiP1(k#?U4xwMa2AIz+=#r{K&40Y)8#|E~ zI)?tZDanr{j?sOC5;6g-VYXwnPe%R zk++d_@imlU_&4)3*>eeF1Ob^8i&zWdRi`OfIu`xm0o3#N(GK_;LG%G5!=O`9ABjqT zh@KCrB?)-m7}gD&nX!~t>NYx@A#1A>>^pCP#jOo%IFq%wMDDum*?+7_B=UQZ?GWV& zDdv<@*sm8@3mkw3_aPE;1h&9#o?$^CsKsijh8zfj8%^}gAZGe1{IDaW@Qwcqo}9$j zsZhz{dDy7wHiga5f?eK)9FIcBt<$<~I$*s9 zv@B2va;t~W(7~VEr+@W$R%;y*)$kU4*w-rBSq1Auq5g|LKEUH3c9pDAg?(N}3dwjM zjv~CE15$5e_!ac0jO{6`@GGi6S;hZ6qc)9-xtV{AGId*WJJ^0?d$}@F@>f6=cuN>R z*us^#PAx2|gNkJ+{woF5&>$Xobr&>7-1UM|TVDGghS-2LpMUk+zWh$M_g`A@wBwuF zo;`@DC$ChtZ$xE5*#P4>DA78f@ir zcW9%dBGo-wjIbVBy_RRXBYs=%lx5p!w(F-EFN0-BDu+5DTXunm=@c+`_F)#Aunx}g z*jC|~*C1m$sDDL^#r9*hbZC-J#mg1qfa;dpirh<3TeBf$3G(ZHNX$O0Cs`T0NTEcB z;`(`>-Xp~*D3x+88>(<0@1~E0Cpq9K%zw}<_3qmiPAgo>f2Hnh4^^@5+Qlp3AaX7r z4a19!b{(Gc8NPpoQZM|=lEY23 zZ%H=LY_b|w>K?@%UjoB#3$K9VJY!Pfw%7QgQ98q$lOt(W!j?_ffSq(jSB<<@BRF0l zdvhi&&jo5>NN=C@qC_iDg|?M~U{{oNaRyqi9T8AJUFQ+$^CCj@EI>G|0nhUBnIizMVl81TN)x6!o6078k9X?_7Iy$s#coT6^RED*AK6;8O%!| z_)ArMM?TnCbwDu?+eqaFwkUk;%vZ!)wF^Jqz<=*1+T&wV*rS&CLSxxkWEW~R+0jpb z;ydfY`t8H>0aCd7+Yq1K3)Fdu|284=(S)p?*c<2hvtee;Be19kp?g&>{1W=YFJVj% zYMf&}Dqwlt2@k9n9#aSsXaL`>!CG$NJ5zb|4pN;t5@}St5sH0i3#v!1pu5%wOM3{& zBY!Pgy!ABXAMXxBHc98zc365m=4>$x!b(4@AzXjVcXf<9SeuEDD86=g`UHI9J*>q5 zDHd9=Wl^YLhj5En7x8!ZBd#`tRUVo>)nrCQZVT?b4faqqDoMAKVw@O29xjNZh52kR zicOyT*!l{-i%)>R(S)kRy>#9tR)sHqBY&@!D!#V8=#LTmb30I9$5<##Y97bLzgesg6l~%l_#{ReeMMIjt43X+Vuf~d!>NS;}ZATWN z8u6|!&AY7vvR4ac>>5>TKFkit<$pd%U0EMS?=te(ckx^c$L>eyK^lPcQ~hfvG_<+X zu-z|c{Yg?|)`oa&H)Kolz8{m4mJt7Ado<76Afmtu*`bZ9k^ipNDq2+J z)Q7C{$H;|Lv0U6B*Sb<=N6(OSzhBYv`*LqlUY+pknVu;rr7412;~h<@cz?H_TGP= zkIYURD2DBq2@ij(huo&6bQzCRG_qL z+OP)mq%4(Q3Tamo(4>Kqh=0{uJTnNKxvLru)1X%0qx7({a}*Y|(zV-e>1OGIRk5KI zAjJgP5~%{i_a0JQsdY4jIa63nA$az?@Lm8i!n%AG2}?o;;=H?o?BatJDSBlOdTxDM zJm5MqdlI!$tROo{W$MppadwrT3BY?6-6dHzWq%JKZhQgOjC9R6!+*9qPvLsN23SMK z;BhEEjw*Y$^*PLFFSN7Z4PT`Gg7+kzUU(CAaHnaf@v9q3X(-i=b4v`A*Q(96)YhZD$gpX8h5MwEuNfJzWkpGrJnk}On++0iQz|ThV36Igi7I^ z62-HScQo(Q_vJVLZK8U^@7HC^?3m2=L==4s{?QZR$&Q^cTfcChXB35`YJ8K~>2pod z?N5Gwqaz_FZwisIi|g%^7yWhNzGB5a9lHO$px$>H{f1v(a|i0}a^%*AfN&)?!Bn|c zsxx+>cVG^+$0;O~L@gh6MO*iNM300)<1i^+ka{3B+l1kIWh}yKz*LEJm85Jv%t1s?c;Ww!Wm339H?}13- z^yMxg#o=~Xvvv;vz3oHI^Slb}&`!1U9Xu0xPK6WM2wZ|U`3weL1-{83b?{Ec9O4r zCeZj}`ELTRCdn<9#MfjNQc7w!AA7~Z)XWMRvc2z4^ZZN2>#-B4dVW&!cld5j@ICuu zQh$JfD;?Nps3GQN-1(TB?uqDGs>bYHK|G+0j8tGD_L1MB^~p|ylgzsAyy+_zl4PKw zHjU6dMtWe(57{IF(82f8go>()9?E_MMzRjo?^1+&H;A=Ps29qkt zvh)1Os@NCkU3xp|?Am3nF+gCu2%e%k?0+kXS)cgrHmujf&^?!&$55T0#^29Fj$80O zgQ!3*3HPa(4mkUbGrgB-o;xl1dFfhN(`o!JkVRbH%jVwlT0P5R*A!v2=09++?No|yJ6V(odd4Lx6tSBKK7kFBjHb3?)l`Me@hk8x8gPtmXXBo@cc$; z7%xfqJDU<#Ea1O$w4+J4)-A-B6$|5wfcLV3W+V!_Tu07J#;?s!Dp{U0N&i~H3?4Iu zS@YpNy&iW<$fqEz}m;;ezy2y%NK<){QWxcI{R5#dyxMwVre4zikY4sVNIeFP4@W-x8@{3yn1A;*Kr~sS z)n6tF6Dd%BO2A$pG|nt~@zwv0QBvnIKq@9_74zymcjgUCwYuV@dn^F9zWHp?cf59I zZ%VKAM|WuDJKjzF4*O#7BlgF-DdA0)A0LxKpV$igHMT6{Yjls2pq|%C?GK+#G_40H ztCF)k2n%hO#_SeEef=Tnbbq3)?iVOrecz~Z+%#lJi3!sFEI(qm67vbMFFpuXl0L*^ zLa^nlAoWBeUPZ+IJ^131&)*B{K-JQ#TKMxoyxtN2MdBEiH!FC3rQkYx?vNB#-F{?@ z22wk$<1+00-B&bL8}WpW(`CMg-K=G+z}R}w^*3aeTIiJNFQ&iD`hPyZehv}0|Ae=- zhYqHPD*@j`c1$AH^@ymR)oMlrKjr{xlm*$PxAFu$ILUzuw)lB4w;rJYvH+(I=@ine zR=NAC%yVG9Q7G}d$ei%R+;NC&H8_4~NY_nd9n=q80m-~oXFkXGwv$3^t%?WJgL#UU zXuabXQVAkn1dp(E|9>8IPXu;<2cjsMbUxx|dOcsEk^{Fft&3S+{2m|8`|-%Aaza zt{=oNra)yRvfnid--x{h@m}hvVM8~(wH=60Z3W8L1@Sug6MwMSF)o59aUAO+1*{y$ zQHvzweaPlw+b&Z4tH!3Zm?B_fa#}E_P zi;SWVF*&iM>VL7ngjxLrKYJVVp2RXDS}=>Pf*LxQ9}?&)>b!$su+bje>GxAgEXMkWrypqx1loWB&2Qt zymW(z2uVgj?(RC>##52Izr*7rRsSI|&}*c+r~KqWq*wK2v_US*JOsSU;G2tY#Vf<~ zjKS&nVczuO6w4FXF{ow7_*_JE^eS@gd(o-5oqu*A*3^N_MtJQ>ZIngX)b2=dObj`# z#_uAU+Ah@-?6KCPSLYmb+R*$YR2``CuEsd2{-z;B@ub@3k9ZbEIV>?e?3Jy@H&vYG z7;=>gWwJKzPgoO8Dwd$loMI)ehCLC4Z9Fw+lHk>?{AacjQqWT)%$uiCcNEb76vt>G z#eYjLGoP3voY8Gq`&W5Ysj66s{Y%{D7$rvh+C5SF05_e5Pmw73DZbXDKyN#Xag%-o z#a+6e>gE;Q%G^kN!v}o3cgbUX(OH?`aF1cjcsC+vvUlI+D-^EET6ZL6BW~5EV&r+x z>znxcqte^a6)F62$B@%*2V+LBa9!m;=zlg~CKdK>ilC#)&SGuV4$0VrETF^`YY+{& z0{N=?dUhd$@D9J*1bwv&J6a^sPS+SW#l2_Wg>^fWT!37K?BHIlT3pUjBfY=nhfNRB zkk>SSFR2c+Hm&#UFru4#sJ&z%dZ7of|0QcxgB5%URYgtstmK1(apy9nwq&br1Anpv z1AO#LTHMNq2QeD(l^}2NIM*VRUX9GU4+x7Qx!=^{nCc;YpD8($ zOn*TRXeaF{HkF;%+c7@}aXy9h`w^~SFZfK`_?q4&!Rebv=Q5U3ds?*Aq8fj}HcB(C zNZ*sw$^L8NZ)c`IVO_K^)qfqiwzIf3XOg*@4w;(^A2K(WUlfUKkJk0+M`MQe+vC~d zI4;&OYugk$m48NJXNE79Op$0$!H(RXJ30VGy4No4w?7CyU6Y?J-5c6^0lHy9HC1cX zssmv7ZQ~I+1BrQ3>nIyQH<(|O>8e|`8k%Jg@uaKTr?z3GHc`0GG=HR3IUPfNljsox z=Fh^{CR7?YA1ZFBJ|Z|*kJrb#{jlZQu@fZk*{fwHWq*b`(d)V!*VPa7F&`<^ z3V5yD}Q#S4^@&OAn6T4T36r1ow>!y6~xL9 zYS!8iP!qSpv)Tq5v5!61omlDqh*+#LAd~86YBJxC+?njC0XLxz<~U-JXO$(e{NenE zaJP-f{9M;Ee0;Lw|M)j=^b7W=dYM1M5|Gq2SE2 zMHIiBNAw-cg7~EYJl~47p?Ky`l48`ZLEVZ%R#$kBgIE=+Mm(hD*scKgpdJ3tVeItv zQuWJgTsYp_kb&L(W*nc+j%JPE;QttT#ss1)WDLl*9Cb`7D^g(hWa5}dm4t$xeBs@`m7@ewnSX%p& zzYD8<2vT>*_!?cZK8GHavs(SjPDs6a)(?`umJY)ANO6J(;WH?SxSnl!$=h^bchrz# z`W~c4z0?it)Ow8H(Wi}RBzBhgWLffR$uUX4Mv z8c}#v@g&Su?U;coL@v(5j@^TCJOBy19ep$JptD%@9`8hNhh%_zkh^Q(tCCuiz3||! zpmOU&?Q`wOB)-j`mYtn=t55n9K5iR&RTWElJ?pBYd{1YMS4iiYn`@1ll;KTB;i z`hQD&umr{0t!TUI-~() z2bxi5RD)iflc-$Uf~bL*~) zp!Yrh+X@@a^b)JdXH;zv##|)y0q^&K({+vBTr~oH$OF7DrsY3~o|+vRO0cS9^na78 zK|hNqkYYsPR}-F?cO<_Oj9MRS*~wH|zpiNU4Z|!7MZ|2{j@(Dk`zz@gT=2A2Vy1q4 zmv?l^pHLB44J}uT_0@oi-5S{AQs3J}ExcAFg0vkYaSD}a!ozH0Pu7CCex|Ch<0J2( zH`%i3!CtsRgUOMQk3*Yg;58Kms(-sDo-5Bz3y0{+U9m5)FMVi}^grCTdXnzxdie6# zr0ll48D%|Wne`O4=by=)f^Idj6r(n6Pgu$KIGZxder}s(+n2SUKFN4YvUa4SS!5(L z_PO644Owsv-De^ZC6>OMu5BpPMJ)d>DoTIC=DIt6HFumN+7X>u#m`HrbbtPS@LKd* zE|eYeMDR-54M`l(q6t3odoL$O7i2E}D(owTXMTycuI;3grCDn`6E?2CR#F=K0$oYE z&OY~F;%o9^Y@59gY~a`CJ7Qlj?x1ScS4;1$^i3JdGgfPKR<@eVz&ry7cYLkosU^8Q z-_i0~#cQbG6GfX^qbcT<#pX2c^Ak4QZV{tm%98lvlt$#|~# zzRg1kQjOoJdxxLVjkjj%oB3f^Ox)yB5| zZ|Gu9JmMazOTvdbgmZ`^U)T2ab@=36nsuNm3qIET?`@=drH3@nbI9>SwtoMJPIQqj zJD@G(PDLhGq4Hykc7MOhN*r47G^zMowPzHyvz*w4IvvrIGJ-WU#IHA_QhGP6!wdMP z=)zSL;uY}@@9RB~poq=cqYW!5bJj7(WYaS_lVT?ba`@6Qu@mNw%bBz=wYb&rh3hk3 zVUhvurKP&kgqDPC!4paR4$!Ok%&svaSK;r6%)PcfRKzRs?|)$nMU${0Hj!{P6_E$r z;A|z^E>WV%qI*pDXhtQk{7%V(@U?aF?`g1oY9lfte!`Ch5sM=d`I;JYCdJ&u{IE=p zFh|Ub$f7!y=K)W4?u`h2gqtquze~Z01c@(1yd3ep+$9k+BVM+-lAn)Aj4<0Q&Q+{~ zSW8DZ`MWOI>Sj=|GrHJVfX5szA&Od42LFaUj@wM=A z`L`Q>P{5EKF`Yjv)n$PQ6Lmzq%ttpzEQ(m@eSp8$m@}Qv@GH9FebzXWY9bc$9nGeI zX=K6^S-#5F6NWK%ZfAWYJbE`62=;~9{H-B$m$xdvtLgcySCFi8k|B>gI}ZXWm~dpS$cA|;PG3&h|swyB5~|fQGA2vU{`kLjblt0-=V12(ruecsxa^2iZvz=L_ zm~TVz8;ftoZ)8a?7RCG2Q~ZYwh19hE`GRsFh)VTnD8)|oEOiD@&GhdZza|o*pgO%> zSbxCQO`tjO<^u%_-7neRWXq|ttP|tG(!!oy8L1m@bMf&nP_x&h8=sRQ*KdEK!r?Yl zMpj0O4$+O@+|8f*B6fmfvb&XK%jx6*RY0o0Sz7&VGim~Yxg9H9n#}iTOrG*L1ou>zK+1XDX_Sb*?)Tyhka1=g7^_8v0-xof#wEylN z?SeGg$yYt;j*k1VG_m}Tve9>Gv-FYo>8QcO^||WOvOdArmzn%}>SxTj(a6F^<-BK+Jtk=**`C;29|LI1tMPH8^E%pi7|9XW6 zDm=VXg_*C2t&uJ8c4osiJWo64kM$lE7B(=korD)Hepv%-3SZb~x4BpnH6!BQoSUor z51@=Z5_8s&vG(ZNqd88K#pbd+rG9L#rB{C|1hc2F@NMHvck6~iM`7M{-U~tfpJ-@Z z6yIx=eX{s;dDF|b=iV?s?1<+5Hpb@4o1U5x_qcAqV=|BQ3Le=8`xEvjbmPko+MmdK z-uQDqf}K}%kKsq~@uKKXE~DH3&qDT1YK7%9qQQFff{N-9@6+a5dsMoPbPue)w)%gX z?g2SBb$Cbfj&4=aBXfSrFEjpE?3~y+ytn-+V-sAd`F!_mzgIYThet`@oVht~Rk4LS z^>(>J{uw11GOr083qERqZgUk>FTKh~4_U_vBBEsJZ7$pf?X+F#e_`qA-=DEF-=6#(R6t2D##HOL&D}W}@w}@t z{*n{#y=;38-lmEbvqw4qL3Cy8r31O^k?#;&Td|xf9>X2Nr|MjVo{K$Vp}@LPy%wq# z`=o{&Qg^HRP@;)~KiGx;R3B0!Fc}(Q3H#AiTFtUr{nw}>(DunrAMbzoAa&+N-)AKc zd&aAbcdRpOMZfLM75!m*6IQWbq((5*?6`XO&{q-1M6qy-cBNEm0jBfnKV9HqO{dTt^|5R7m zsvBkc#CzGk#bhC$@i~9nKGW|^eF6!*B*`Qv$+jfibWqF`o*KUXcfzY@3E9_VwqD1jNu@> zOtG{rWXbK=WZq)7sta9pDC~cyYI91N6q?71a zYWA@=e~T19W(|K|qr}1v&1Rj>pQ@4iiDge4yNq2)Kb5{J{bwPv~jt*=~)>XL` zL%B<0RDMr&J2xTA6F`Jb#&NLh5PEEbrq3`&!UB2#`@(+@T%~IA@p>G{U4o-t1_nm%pvE-8Wn#?ky>;YZTb>~dlP`IcRIL7OZ?0Y&_vE*X?ZOY&PKC#jIxefdQ~1`6<~Z+Pn5)}YASajJ}tS%ort9F z%zvH!!2i{Hm+{Gjb-GHphQS-nw2dKGYz%TqLd_eHemX=htp0V#h0{!C@3ZR)z0c}L+g!^BomP{Xed~P`NEw^-)6Lzf|FEIddCa>^ zo+UDQZzyt^Bq2^#pnHZ6bNEn~hd{tKWA$UN`iH6R@Eb&#e(>P^oT ztDYr=*o^~aKhI-tl_i*uua&Ja9;*YQZ&St!&dQPt<%dhNDkGB<`F_sPfV1B41^II( zr^83)rEgI zJ>z3;3MvWYd;?f^r03=!sxzdfey@HsumwaeZKd<5Ckh&0lTJZf3Hh|zz%z86LTnw> zq$TJJsAzbPfS`3Rh8dbCWxfKhjcP#4!D+H4VA08(%AYDB&F- zZWJgz%5xP&--A4s^QYc)_7~4!4N%3;>Nm|yjOO)}S@})Wfw2w8)<7a6?dndx#G6_F zvoDLx>bh`V#p$IYhhqN=6H0LHOjKPouveG4XjR4!q_5!a^|QGle~K` z*fN`_foSBq_}RUq9Hn{LcSaS8VByH;4<{iA{oBe&}h-vCm`HDkCJ%pp-%Y7ybvPn_6UiqDPcO-x3eq8|4n{(gp0Ch)t z$Lm_1eJ1-=^R-@y+qjE&&#(Nfh77qI0dgu!hcM?y)~#8->)hpsSy~iVM#9q_M3exZ ziXBlH<2A8v@;D~5ZZ^xe9f(}ed`N`qC4aj6SbU@~1FDME7$EyRxgGqjAht;KY`Me) zV_(pfu6YDCQ}utF9*TVd7XKw=pw*+3ZOcZSZ4P_mo#ZR}V18b~ht$q8R{E`_l9DBK zu`PB&{9@C@e2J>}^HqjcJe(iJyV@txIW5}!bv|ktOU&W_vQkBd}epIApR9NL63#XEazbw7Gw~VhG*KY$>{*wT=@Xg@3B} zlOaCucK&;X{U?^E89#_QJL?!Vn?6nWex$+T zZRnm?^xM^`?-ZQa(Cv;icBLh-XWcxnh;6<(ng;l?H79QSzqNRUYB=%!#qwBGOVpB<};R~nmc3on> zl~;GnP1Z!QyxSA_$AbTo__vkc{mPvJMkIEU%Uzez?iiOEz!&12l@sju&w#SaJe8J~yjGe&esY&>=x<`C(q|1u_?#F04Ij{Jr~7@nqq+%w0l3 zjj@w0{Nl-u$<9?`L$g<~S)@*KWc&!j%8dV(AInpwPkD{JCAl%%tku_e_OG#Z5i(?~ z{Abh4y8qBc$DGwYBG!fFsj@?;Xeoc70+zEu?`ZpjQpv9ClNcqBP$+gn!k=?Gb)&?q zk$4>6|G=Ux#V%h23r1xL?v)iS z;_0iqV~L<-8^%2-`DTRF1JJ1JzLYT;JZ;rcXsq=}Ih5 zvAw(}=Dg;iNrbbW*QlvtNLQ*weOJm3(4S5=HMr`U#~VkgAznJp-% zK_CPE-*GPg-#`B{4eEbK9)6fKE_?xV_hMgQi!)HNX3;8|xrrar$>yv_pQ9fU!fNIF^EnQ~$MT~h#;@5o zhZWBPeC2x705qa@QDLn}1npf-%QPL&k%3DvUT;f)C|KI_~rrB42P@P#T&QajHnqd6#u-%GrqXBxHT;ypG>Dv z#Tr1x*S+#?uT)d%#?Kvx{tQ3$6bc)ug^$nPu=tvlt-O-9fgz233A^h36<>QiG+Y$j z<_8P_8&Q8EK+!R_m`cRrdhn>hLuw%Pv7e^q^Xi$J>~xRWu%7qNX;K|+?e2-QjtU3k+yk#+mRl0C_qn`2EF9N$Yv|+vH;pEp}nS>DvrH_v2c4;|=$igpc*3H-F0#nKF&`<^C)CH9qP${7ApWwIJrR z#b1>wlGq~GXHqki7#;h9@wH;M$Xp)-FMkGWuo^0guL;L-V2K6G1Rt{zR-1TXp~_b8 zWzT;bHdlp%wT;9HR1Cn+(!q~!PDTFbj)(>CC#k3i8Gk?jLF}h6vXgxNJ=U0kgeQ!z zd7ouH+p3#rJZJnxT7vNxyrZXLMnbfT$Fe!@+-;A5SD>ovQB~)s!&OCWg#`+C#y!s7 zcpb4W%eg3TdS$EF68UGu zx{L|l(V;$-RCn3Ee!#Th@;-kCnQkXr#ivRBRm69~6q(>}9-NV7ay3VZ4(OcP)MQie!*y3wrd0^r(8}OP6R*GFD8rQqk zp3SS}f>`Nvh>t0#dq>z(pKPC8c+;6h18gP!-1OoRsIAyYr^2zv^Lra&vdu7+rtg=5E9Mxc;)AZ|;`QZthOam_4 zhd9`hT-}?KLDk|%p^Gm#dmrK$n2D5Ml5lU_FRBv-X?Ht%#h;n={n!a#Y7sQu=NLr` zgt>mI%&3e@*vH|u%lGG6z^ijRRr6RKXS?<E`4Tao9xB1kM%ZhwC`uj<`ZNOz4O_!^V6sQvwIvNG(75UK!% zzpmnbnG}`xykiq~>7Bb*Je;d63lE52q#h*&rb%!K-ck|1)0dS`#kdASzV(hf zlQEXKzi{A{YSA(IoCVV8cGXy^_B`n>SrW#fDTQw{JT6*vOD2XTq#P#!Xew6zVXL?7 z0Pb4eRrzMMCat%|q!fQx9!2ISZ&_vX6HU?Dohi*9#^8_&cfDr2Dhm#gP+nKJF+)o4 z_+(ge&&1p(;rc8XiBh(=+fZxRPqkV-T6m@1vC8tEH%z+~^)1Cn$fFT6Do1Q5RROY` z-f?`Bk3Jvw+^$(qS9muzh3hg%YC;CXIwUWede(MYpD9Q~HAjCiriY|{A!swt`Zjcu zil9c}EHe9o+}5nOtMz9ZnYW6szgVkN8}5_dA1ka{$%N!bmb_}5NzE*q>XLS{1$~6& zZD!u{$=TLv=?N@b5@{>%z;^p&bT_cp2^i`GnR`GosOeoXH}Bei1MGQ6$_z*b(l)E`?XrV3 zXT<{VV zKTFBORA>4N|E*3Q!(K;P@|amK7MrNi^zy=erk4?y3}ifpov&sn>B}Vj>T8veT3w$o zF5W*1FKcfAGhQl@yvj&nE2IQIv(Ma1>m;AfR&tO|&Z(BF_SCtpra8*0i5;=I+xEM-{=%=g zz7{*e+-vS#GG%jjMU>6uD3mHGL@S!tcG@RPb!P68rB_X#@@}ful~y>)w%AAL9+lj^ zXHwY2i zjA;q%<*l#j)GD;VH9~~-Ix@X~63r-lmkSdqV=lFgH4J+BM%eo~!|EG9VMf{!n z&n>vTOwWj&5{`9>Tna~Wc-%e!E6?pUd3S$4Jr3G9O0@FAR65DW_z$UbHOx0;=;BN- zo6F2ok|V7@8D`CdZQ`U`cQJg$XQ4)*fyXmSkbIWpY2RwLx!5LVE7%@w`in^8+z$91 z3X?qvddLE+KuP*&*a=aH4b11c8B~2`x?g!OFHA*UV{@@ZSm#-a@ZOew9n=6z#6Ew` z_X`;r(u6zZNdh)GTuM_pD znUpe?C7;xF4*v#QddY_5F+2~ufwkD8J+6Xzg8wEs7XE0(!%2d!FL+t^_R{egHmrwK z?%-pjWi2o_7fYQ4`!npD2dJ_91Jg4_AMh*hrgy=rEV^Zl49|_0Qf5xPASizpTljZV z{Gwa``+*d0p{?xyf2iH%)Z7A|B{QwJ%`$yX^Ab#w-=ki>g7t_~giuG^%&(Y%z8mCs zPG~XLe%d2d(Pf9IZo_)iPHtywphaS>ytX|OA*W8$OVqsSCeUw%HK4h&bxi>8_|V1b zffVgQpL7TRPBG48z3!)hoOplt3*?hrtIf4?7e&$kAHtpN|8}Y>D5s!A?r4$mBS^K8 zJSRsoUIwO4QNA!+YcYxYe1FjKLtal==0z07k5f7AM4HMPi)~1jUQ&@?B)O-QKk3G^ z-O^}W#kP^sDa!X1`*Ma@d(KM!PtDAoa^|#V!QPe~V(XUisAlol26cbGaHlDc>)wY{ zUEF?_GS<1&w$ipT!fE`0w~?x2N91HjT2abWHy3=U!97pBle)!sB_N{IGYlXS|ltzsHLw_GooCa^g*&+PX%VTah%)U*erM5fo=p|q308P=mg`6J97{z~+olWR|`c^M!BXt;EkE{l$M<+;W%C(#*cPnKHA= z?b$hNcsED{J4hd!J}{0<8EYEJtGDgeRfqr1({*D^vVis|k2I{~I@VIc3n6%0si=$; z3tVt~K0-9N%=k6qR%-=n+_sT0S#J${ro#3c|6~4^>Xz9LRBj(4?lX9_)_9{KivrsD zB?z6b!1q&r-z_V|@>J5-_&=9+k3OIW-nJLhG!1`Jq(!~-_|Y9ZPnF$eFWwuali%ygelArP zZsK>F^&+!_%0gxds629jT5&sXY$PcMEPp_Y}Sge zZ&<4SldE2ORU74D_rfwY?aOp7>f?srw}D^z@*eUp?=_dToT&ZW`OXTKxOGy`e9!s) zF+IFTlqb-{Ha;pa^PZ>Z`QPK$W+volu^zq#*!m- zWu}+;8>kswdsMRNEDP>a%fdRSp6&lPA)~7#-=6UUYPLLOA7L)5Y)u)ZdVa9BEzDmJjAkYxNo~kAX6I6uQ07=1fX^ zj@G+AE7_(Wo%UQ#hSU0Y_U8Z0j|s=uEEL8(C_*m08Xct=As)fo5iVI}0m!SgJ6?a) z{!jTASp34-P%jk)UveGyv9*`2g=DNkw~5q*i`1&Wm2V63I#M3>9e1gp$!m2m|2l=d z5prhsEQPZrsM{|+a}w)7{9+(2nxajgvY#ON;(6){_}x0{NzGuXla?#k4Q02m^h?d( z;1wm&MZtFzX%Vtj*{X4cR>)fEFFk+B8Zec8_9oLyIh}=X>mMyUXusj6wMWzUcrTkQ zWU{@PywQGR{tVr(4C(o2DqGo8^_3ljhjkdW3bRZdVrjD6T(pjGe8L`Bj9)2Hkm z4aDxj{`aw!TP@Wnk~g%?qUuHP&X&Bo56<)?VX0rRD>uBp}k)7FNwR7t6z8{;4(VD!n40|;i9&IOZ>Dj(DKF81E_?oWTs?A@g zB9@G=(BVa@b{-ZY-*LFcwO4Ao{ua+y6cXvCeX3#gwPG7;x%cz>_dqKp3Z_?OtFwRp zQHfsVtjSzZ^x~%NN!Ndq$81=i{JuSUlR19(tZyehkasY=`Yab5ljHuBbiL?B$=@4R z@>@+5bVJT#=0&r@Rap2eAhP_gzXg_51%iJ6%(F*ScbXOgk2WV8Mc34cx* zTWs3=trd?`fw@`kHFiSoPtYsWL~WbDwJ^1!Tyoen*K204v~;dudNk5NdYADvV1RfE zZ^jlSCYhT{V`E=%yy5s^{4W;$b#ANY4VF$(RItLuBcH$;T{PWx9`*K3f(7x4WAZFF z=BpT4E`#JmdE|fBn}nyT$vQ4pkfWNUj$!q+e2JCU#R@Z{k1az#HO9VBk*n3M-%m3P zw}F+lDxV5>Lyjl^qE&*w%kvsQ&zXm1afo$&Xg=#f*W)xJIg++}#_P{X#87GqZ7!BU z^_7v*JxzPvksFqZhASv%J+a+Fjg35#kv|fKw$wYfx-%@c$d-U*ZDofi0 ziAAbsDwBHWf63VeA8zh;-0`i-$kdEAZ_l18b#;|z^0B3mcf66v&07NlqU zi1;6G?q+{WxNmKz)PeF{9b$W9XYxjt9-=LmQxrc>PEMe0JUg=ILTS;gvDn7lv|S<@ zIi03CVY@bcu5NsCHlJ-f1?(fV_{&~uUwc$PI`_uLpV2YfK0%J)>!?$iXUWU+vnrcw z$tvkRRyZTKaxn_$*e9~w{P5bNiV;K3M!xtSjctD>ENNc3C8zG-CUB@{3cY^CElWZk zW?n&AcYJ%e3{S=HEO;_&CGYsB8b*;qY8I}97esqP$JB9D6l;08D4M9+DaeUM9 zP4U3Vzj_|EIFGSC`=PAbvO|2VjD#(GA2SkK=o+0xKc=8B33lf}9;rI)Z>i!6XN`Zt zk?f>9JYt^z#q32;os0&!ZP`xGy}_?<=kpebRN;5~q+fye&Pjf)DQ`MUeDa!1zmv!O zz4q*!csKhk^1t+S0ZZd8d$w^V1*Mujz1{X^-gIwL&ZM|=;GYcGC#PoEv)S60TJlgu z6c7~MEUkV`0rSH=T1D~SoxeaHnxB83r0XVgg=2%{JlIl8e%_Lno{;ggn6oJ>b&n=r z*FDCw5KPXN*9HAA_NI7Rxz}i5&3@f4GdmaBOBZKOr;>a!@0+{z=TzUHl3A|@*Su{X;l1o!g-$}hb)0|X?&t5f zj(c@_PKI?H>*n>b6AbAUQA@9u{U+-e1uCL+`}v-wVyQaa2af3=HH);|__fpwRFkyO zq1R^8L&*l#P}6dA*>^txJl)L7R$d>nqoPwS1N#}W#W3pTukHvX1ZTgCI%Oe6GOm7GNV7P|SW51y* zWuIt=Ui78tkDc&l4hpt?&LkVU@RGkGu`ZxQ+)w9)C6ibyP4vFh?dDBqfBOKH@mgca znf$yxT6(!7{*6~c9b{=Us;vU7+uHD~+5B*RRDP7m2i<<_hvB zzLXf+9k1qnhp%C!rgvJF2H^vARyZmg)}Q2biX@mlHLgE)g2H!@KIb`8D_$dC#$(i0 z;oy-z1iZ*0)q@M9#V#Ni|B zcV|e$er)EeIR%8sA)w?PSEiB<7w!sFHU#EWb2DE@X?+TqYDMU`u8$32)7H5C^jlAiLN)6eRx$p|` zgo8`_d2e1Lg-U%KVT;{}X># zu+L5#KO(8rs-eEP$J6%+2Ah2{SPQ#Ip?kOU4hiKhVJ%v3zriCc(zo9tKH(AMZWIS| zGo-B_{;?p}%UyqUVqT7eiSsQ)6cp}qHSjA>gFhmKEb(sOn};*Ts;gx^@AnZr9t!XE zBC2SG>*&@ z%D4%4r{t4V=I1ytGwT(f88{3B=@Wqe+Xy`Klfr{)SOIbs&E!=)%I&@Fr|bL2ivf zFRKrjd^5dIo10U+<#^yRy$CGqP7P^KehV_N;EA3G1L23jeh^k%K>|I*&p+f{Bf9Mh z`{=@PmEwOH&pW+p;WTP24uUbHjdZ-%-58f5wt9l>-5=2`v#r!`aC*)5*?H6TcH@gA z2-f}SY||K)lEv}`IBt9!*1IDUqf3|a+P%b5u#x?#QuoBANqW2CM|{0!u#Q6&g4tNh zb1aPA!c!@`t(V9AZGNSOJ*RHgcYAmr)$_V)L*;+9V7s%Al8}=rlC2TUG$HS0`-6}b zKHv}vGWK?=Ub~E6OMGpLoQeN$PESx6`RVWSs@r0I7~^$_jz+|yd#?(ty4ApckUc*@ z)$F&J^QP+r*GMs_2nTQ!uPMb&F6(waKi;PH#4-HN$C#gOeC~r-CxaTNT?;yyLqKH| z6vBT-LkbWVrP4|2ol1ZiZ@_1JutJn5c zp$1+(=UKMYvNjBXe=r2DNX1xi5-5}nJZpbjHN=(k7@aGa-vMy33hSjm?mX{q!S`*z zy>Ln49TOmLK6A(P%Q8KGWMxf3S{*cB#UBhSZ+hXf&4d0ybt)8|9$pPkzjDTIR4BC=dbO!}UPC^Pxv# zJJ7-pLjnpGy>#>lUi4mVXDYVT0LFjvIG*=uh?{%)Y=?Oq;@D=AwSEk!&eEN5p0>?# z*=Efhr|aWAzLf^-H+cUa;BW50?ohnK2PyDILF_|C)9p{Zb}His|L;3%JJ%>V-;P=! z!Kgk3*%tzi$$R{&=slT}o#=KKmY0*T;(cJEIxIR*7g3ren1XEAq_CIXFX(?duFq&7 zeWcSzCgVr(KPHQ=uVk}(%;s;oBQqwNdn?*>`(t0onPhNc2kt>-yfAls1U%o}u-*3n zr}+dJg=>JmuXr2JLjwrw)+u1dTasrL-^}|D^TWD{&@e1PGTx>Y=@Vj8*^Zkl$mhUZ zZNQEc4C!}SYMh7lvX_tA3)Fv>|KvOLV>by~`^QwpT673|ubsl&3{Bt;*&5fs_^T|> zWfcsuW#o5emGs$SlZTAIkFP2Ez&OwNRnw`pZfE8E6J-bHpD5YPa;FaH8#2p^ow^}@ z1o>Usjl!{iak1%QOU0aHAIl>f(DYDO$sae2zGTXYOqf8eY}4Mo1q@E~YWsEGBND|BtDpf=Ua-e&V69zS z-MipvSYwK(;1bv*PLtv>Q_K^Cyqbi^Me^GHz;qVwg?$>XMhkz1`4n1UJp{DTm7Oov zTRo62`oRwp0_RpOkF;3a=QM_g^N>|_u!MGNKJqR;&we1@?BZ8GrXZMAWse-;k!}E5 z_&a<@310KkT`tjZJJ?7122GLdC(D&H=-m>@bOiU&#jo}7u?B&aSOweupr-p&^ejL< zysHlJy}pMt>A-(_BMdvu&|n|&$~cjgD?@im6PWCiGS`Fde)Tb3c`6=*DY=gBGg74K2UX4K@#J6D12H*k6nFP;E_-jJw zR#3e4ilrq4tfp_$mE3+q`odI}k^xd|3_-T38o`F77%YG4HMRyhzTowXh7>PCPz?{E zi$+G|I*z^-_}+p_Uq>@|6yCxJT>&!vKJ<6h@;a-7JUIcTya8ymcd%~{vZTAtBXt&x z=faYAl|Shhrk=8c(1i_PQNIdw_9qPyG+YP1+Srx)>EtZwY6Y+nR{qytK!wFyq$=nQry+Rm9WXuH@ zXOQn_5Nk;>p|`-cQ=IIA8-18U+8S4ndLXpy;cp8A#4#R;>(mH5G~NSo=TV7L4W^+W zcAa>dd$qV#2$oft1t@^E(gNOGVYJx^b~KR#8sRN*WoQIPMB@* zlG%T&+{J#a?1Jm@U|VEebOCzrF=8sfYR)(FoRcbt!Zx*hs@|&7B8ARSW z0N%$=;jW_{Hdn+Wd@t--Ce7A((G;uG4zPc|@%+<%;1~(tmp|f>{4CY^MPZZx z!2w7aYx_WYGI=C~!B66pMZ+RCxBrtW50Sd_-DLXRQnt>Wl{A$Oct(jnm&h!g^t^xJ z{R`U{KJvIJCMf3+^g!MCwMR{##!i?gIq!Ya8AnUN+|{L`3dzp{WlE}&tC!?T#JK!0 zb@8p}z_xOLRPGY`7 zy2ny8j9sZ2*{M|B4A(j@s;VUphX+{x3UUoWeebU}_0cf?#X%_}Hqwqf38Sa`KgFmAp%@ z#{V`UM>-f4;y~QF+coUG&i7D}_p%{fu30c?fpWvPM#7(2-*p1Pc!(`LpVT^#a2TFl zx2dw#uu@+ztSYF?+)SrdEU=6rU*2@S^Jz<_tO=lUx8CM5IGt8rU#Zq{&PvIvnJiMt z6kq%QG4?KCQJvS`xUqk^n4~pdE+?_{fJyzilfOP90G#I3o)osi7254kebg)ZJ#jq`>)^H zd$_3WInRC==DPR0-^+T}?e|;ME<9fW8E;;fm39rGaZ%)Zp!|Otuac+4+uJ1?3FOpa z*~_a%e?@%)zvz>#EPoGZY@h?8(f11mrFv*bXca#BgQ7!uDPQACKO&Z{T4%mb`1!Yz zKc}6oDevlbJIe)RO*yJ0%jb}Ave)Ca>}1=>2zFbn>%0|e%X6Q%H1MnfugfW^O%%{9 zR9GSVxc{!Edgycdk1F@x7$*6aF9G$-*-U^Qi3 zsop!mum(PO8g#5ER?;7~7lfEc!C$iOJ~JVv=q5Efir8gBkGnZ5 z=YO8i85>y{VK4ARa9dzk0v{HLyY8Ao7jveI6h$U!lfHkGt|E#`HQt4EW#y5wO`0|U zKGr}erfV);)@N`dFNH^s&y$u&A8}u?K9H4K*&==a7Wj0y2imEXKMm%mdEd1zbYAEA z*9H83#&p)*ApIjGcLmv$kwZu{C$(nYW7&`KwmxKW@@(W)=}YDPw-J1}G&+-FWG(er zL=P!i%hP`hW$#DIYsiUA8p)>xKK0QN@<&Tq10h^p5PEdN(Jz2pcurdZmKV4cFg!z-{%TZtdYds;OA zZ*XCQ6(dpZE1rKnlCf_1`N&${MH-(R+Su=CM&*B2@K=y`Eax?giUeTK0buza^_ zPkLL5)l8`w2|X!wICx*=b>zDXs}bxD8H4f9fX7mKoH9|nfX*Nv-DRL)+>y*lQ{U^#ju{SZq&Xhx`c3H#=n_@h+oF<|56AtoUz|r&WXE{e* zPsabF^R;Dt!_O)`3&3oC#d>dygEgH-o)4ePFCxf6#~_0oJ-+9tp$y(GGxitP6w?n@ zACLbR*&l1h{JXXb_fsd20#GVv%#ZN?I-L0wQS|{oYY@2&=7~n0Z?GDY9ly}skZ*qg z+3@9v9Y2PJ@=xXS+;c{5%^LWVk*Uto>Aav6TKOD6S*_uo(&|t7!Yb`4 zlj6owKkqY*KE*pBXFBUOhZ6rJ`8S&&m%(&MMdE!5NQE@D#<%FiT8`6KF+Z{W48QO^ z#^bYl^@*%q4uhjgc!Jf{(DQ#!k7&=lV!8HGCx26|B_6@;Nu_EYLGa%<+IEwQO^a}# z&f+H`SNn`Faz7)=(MPj#bK{;%T%$amhpLrbVy(drgAUd!9>_g}>hE=iIc8c@kO7AK z9dsdMG0z{wT6_6FSdI+wo{T3@%Zx5d9okdW9yeC>p=CV&EYFQEbH9JhO|NE|dtN+* z2P6^}$vbJHRIdV)1nN%rFB`l1xO2Se2ew6(&nNzK_GL#;MRxq;)$OkE+2?KREGvx9 zIO;5)I(l+e>F&?}DE{>fE43mMk2UQZeBQrzoD*hocozGl!u==Qiak=V6aJthmEJ7) zeZaWBlgDGPtQys~0j_`HKCzPrtqaAscv@CNP;@qo;ehzFszsusT64WbrK*=)Tt7i{ z9o7fE?<&`mCaQ5}KF^JH_X*CrSG1x1HZ}8>?G?iu*yXD}q*mWVKKm81N9w6IZ>FHd z6`EJJ%{gBDS!%UnFiLylC+F8t$C&5xOf2sX6x?+A#9r?r)4P8MY0$K2{YC5D_H{J4 z1XXN1rQ#@j(&xmRJQ)9v;+x+ko+7DSzNj>2@ycUp>zV?oXV#a^HTtZcN!>_u;~yiTvai+) ze(Er{yjDD>u&aL$YIRe0^8EN%*xAwBAHjE)`KYH#T?3Wgs$IEV++*-59_C+OruH(# zzydro`_mFvl=HYWNbaRn?1dkV?HKq3MRVofeJ;N8-K+y0mG*TB*OfI%Nkz4-{H;cwJAGE0-YVH%pG(`e%S>nx&#&rj*)4yvZ@X9$2Us(BPrUty1(VSx z5tIYcs-T=DAQ=jS>i}^;j=x}uY!eUAA0&3a6B&Nu_xinfuMdb9u3!8@@Qq#N>n}k6 zB=i)H6W`JSIxCUm&C)a5$uFGp0sj3K`oMggN4tg8yg$@EKS3&+)@hZ0z3>TXO|OiP z)M@4K)XT`Whz}2cb&`cekVoq@&lDMNJO_pfKSLy|9b*k79z|oQj@Pwy!x=m`t2{mZJ zY-2s=+_Th(qi$+kzoQOZqCCdPJF2(O@O_Qm5d42z1u7=ivPNI*evZd#TY5(odTJw& z+;E=hf2X6pKD2*hB%*}-X*ADJNXxqQU7TCxsYbnjZWR;j6?PQ#LZoe-^_%i*m3C!g zNq)he@@vJY5F5;~%}$}3yqT65zJv3$m+jV1_^uT0?S3$2WLbPB9pv9(w%LzTCh(om z#ge!2Ig5D@{J;^02>6bt zKf&+ClHajH)7;Dyp`jn6hDK$$N~_8^$YW%Gj2_aaU)OkYqBK?>b^eA>I?{r~f3(y*PCZAzFa8mA3nGr2Achw%LOMeZ$l|Gm9 zE7qpZh0h>oI_yo!`f1_5Yv-M`5!F+2uccS(9;D+{Rq>M*vmt}t=iYRKEp?r6a@c2o z#Lar`T%I3(xL2-2-HayI!o!pGCcS zQ-qbRp02!`PsdA2-=4{P%<0$@XX;}<{4J!ImdF2r3cTuExfxP zU}?TvdT>O4ggBe&M(&O5femMW-A`>e>sp7MprjP9JtyK975;w-J-P>CBY*qBZ$F58 z0dhch7JMp@x2X5S^D~@kguSv_T8MXpm3Hr6c!Z6*3AzbY%`1=ax=%A^;Semeo~o^= zk%>5E8o2)!--|5roOVP*ROGbUHu?kFSCS6~o~4h4xJ)*jwT(qhwuByk+fIF0!JfG5 zV2^hE%<;1gXZ2yp-y#oLc>?GItw*ya_#q-}!#b=hGLCmr6hX1=eqSL9qgU&8z`} z8_veP5*ulsQTTHe^@03_h^pqLY>QRe#i!j)7nN_|+2@(vl`}n| zCw_AJ!|G?*1FPHdJ09Brok7i^)PF?O1nf!F!RNbTendAly>01go&}ewH+z7`t%myZ zfvRsx=t<46&pDa^SQ9~hXzv(qFGJw$} zzee_du9`%p_=0upvagfxqaeT2C3S&R<}p-SkCm7+q-XTp$?1oNJRAYhJ%#(1ztyK# z@@9JO_S{|7EIy6frHNV7P*e?4mEire9#`=-*2;Tp`7CJ|%d(eB z@|V1&blVoG2XG>o+nLW)HCLDX10EP%!*k#|5a<$X^z*29Q>-aV3~?qZ}TiHdlK z1da!hPK_ZD_-axSU&nY{u8LKDRo$&h@~Nh5JJ`5TS+wjW-=F!K1Ef~SXaSSDZK>`T z;7jKHI-WjNOuB=#PnU579vpv4CBb^h%<&gg8lS;>r^f7nFt&Ed-lP6?A!nJokmV|N zQG@Vh)j*3|eL|~JxPzcMo}pm+A@Mn;umxmT`@HyqqQ#0oh)iFpe+rDEnv)vK@5MTL z49ofZZK59-<^2d!tDrzv0}t_BX!N`{rKry|4(wQ|e{n=~S?HK^wcmg83^KgVz49g* zJhL?W08B5fl9AoUdvK!IXYqWs(Dh11S`6({nr;*=RV0dxljApYDqqV)%Ob{5h>??V38L6IqlQl92R zjqXO!Uf*4E#!m#_wqJkbzLT<0UqZD*xOW@*%qc_BVfD;L(K&;fMC~p7Iq#um@(Kt1 zv0#TV6uv37lfX;818kzA3#n(oV*|9#lvnR4Ip#=qSG3HYBGJZ?J#kPXmH|y~1f$*C zys~h|0lBLdR7sKf3C6t8l@J>{61uW})9rQ@x1mey_9V$6GqZn0Y~Z=TqwAjLo>p*^ zx>X)%(>TfpG8R_{-?K4#{Ve+oDRABuk&IY{+jbN~yOFhoIjOBp3kQpi8%HOUh*(tA9% zX4$RM#41uVfogvwtA$6`wnc2_-Qeuu*#a*gvb7J1{{WcVt>Ob|;WK<7zPA8flfAW* zd-)Rg$02#VAeFq;l?v3s$KpFW$Y(h%`eslt6*ZEf+9sY{V0=E5xu@pf`B^({60QDY ze*9c=hk`P9c|VEyi5ejiA5sgS3HXa1mL~OdI4jjVA-#XYJAuyebvnpz`x$y@$sg?n zwA(vjZZp++C+JxNclhI8nA=>kf%cVj^Sh9lO^Ic|gqg$BpWt2Zu;AQNSOTEld9Qcj z9cNsU8jaH|l2(z~A4^rvHqCZIK5bv#`?jsxTrx^Dn|nO|8SIv2hm|>&{gxP?DKUq8 zUZUfOS`dHG486J=yq|7kxqWLjoQ9z|XW6h#SMD9E;57XD){0?iYE2c%zdg6)B5M__ zFY!tqd45asMBeX^z3-Jw{9e{uin3A_vq*vfW%9mtTC$V^G>3JD)22&lKh%e%CHkH+ zEJS5X-a!%bJ0jI*59q@jXJFMOmH}f|aF1n!maTtMCJa7aEef5i$v@ErW(ojw1+h3 z#7(Xz6?5TU6$84?7#nFm?z;=sJXou&llfkwW-fsxW_3F-cf30_)qo9^aSd+;3ptqVh%ziJ7Dykk}2Ij?Ux>xgH) zKOJ=zz$%Ff-#~gQb7rTkdYSyI+bahl+jV~>#tvDB(a`VsKE2@Fit9Jb(UrzO&Uf8G zE&Of^>)w$(qvJf0@wfIYeR3*nuZda@QB9BGlKSla5 z-`A-g;nU%#_&*KZM%asH)jlVb(%7Ap)f zu6$n0tyF`WX(H=Y-R6wMMDBmgk9_C%+N@D`xaT@Gf;;+McXP>(O0V?P?V4fS-_;F^ zMEeonm?Z|4%OzIqbeteCoYbUxcy6DP43;9zLK$Fr;En4CLuOUD@kO5NU3oLT<6!BT zE;&AOd?b~a0-{ex81G%C*82*`KHVxg)!6S~LA5$3Z+KMqGOeB6O{fi0+KWHub?hP< zi*V`amy8P@7=Q27w{d&16M)HI^&;q|CjLqG<`$~8&XBe?AT!%`M^^6J&iFt0jw-Rl zHx*#r;X&W?EXUee4@+8nujsItoo1hoHRCqR6@JH5`5Vj{`0a;wszxmnGoH+`k=os> zl4`grUWANx(FpIaUhAdOA(noymxO*(!dk{!$#_zGSbz0uluC|6lUnPa=F>Ch&qS1f(+YeOF83j?#o3&k$U6psv1W6YCP0eqBzoAq) zJ(Op*NPCus?gQq-^%kC8P#mLxDQi5>rZt+ zezL})wtpiy$}+3HMJlw?S2UVQcKBJBu%Z=Z?8(@}*G$v)oKSz8wcM5<##Zt%Z|7rx zj3|nk2woFMHnOF44<_zq>%3Gq!4RXo0$HnjIe%sP3+ad4v#d8NJ&M_|+z?~kls9w9 zYXy7qW^ym}s|=#>$E81E+v%9jEBmVCMFnH3Sbw_KRNCF))Dlx=iE)Q3X5PoPA>$gm zJ$N^LVTgz+*J+2+t#m_1%->g%Z;Zylngv?e|I04P$Zg=g{-L-RkjZP=PpxBOlz*p2 z;{(*@Q{rB*&!{*n$ep)%X1z_Xf&0ph?CmS8F`MQem$jBMbl@HQg!k@@@EH3bp5Tc#M%)sBVygp1UjGf!66gExrWEtD5vD@W;}=Nbr?w zAn~lw!BKmqPWM*&3+`r93cSMBv9r5{9f37nWdrpWf=6NG9NCJxxv27?RkPcIIDmBq zyzrGPS zd1KxG8xuF?U#Vkb`50vkG9_9omrB$wIrSc_Pu(t!SB&R!h;Og@Pab^$+YzGu@f=fBA9Z~Y%ggwd~qw19VyK|(IuHsrOiowt*F zI-2EoJ^0_&L`W_NGE7**HlY?2uzy}___05yJ@HR$1Gh@#37)wxXg^zZ)u|Z?oz`7! z>i}W)t)Ohq&|sxk>J${w32<6S#zH3V3%ezMp;z)9>xEyt-BiY}8*v4eyr1x%j41y> zKGOg{0^!sm?fFXb3xWhbgmaS3Fd#_ufZ(NT#7_#OOSkO9Os= z-rpm4c~o*LswH&2)dM6y;sv$-hX#>2NS?!km>pj&x$VO%CnY|BK|MGWRw0G|Q{+Vr_f?a8KES{Iy|$yVPE6g_`q(0{RjWko>HaRY*x zL;K-tiAaB#S6?u*lRrH!J{Q63p3E8Lz#-esfQL;htvc)rSf8e!tu&ETuYO zeN^jf!H;u9=F2hqF!3S&hRPNOlF?&PH`Yl>!2JpP+bCo#t5$tc06;Efd_H{GEJ>nFA}7!ryA6WwJi|94q+o z2=^fB5MSUnw_9SC{E_#sBHrhl;LqY2x5e{MG?=(XAC|aA_sybG`^&zYwpkSASYf?k z-Q<2Hp)+B8hJRDq)FEpdE9Gs;u4|(AGaogimm#}qKVL_!%GV}xrJr_IHRmqzg;f+( z+JE_<#&@u%VV{%O`v7fK(NC;bLOQo;@$}%3{}zWDT{4S?iogD$2vf*50R!*0DosE7 z&A02L&EF~C7+;L*_e7LbQX=;h>M0Fd20h~I@(b?;e1HA@^tXAahbuZ90DGxKmx>Yw zc~?I``@Qd0J>aH_wHwZsy+o-S&bq?gWb!1QNpI6tn9AOsY5S?Etn8(fyXl6TlqY^xH%bC-tVT_e#tw%4SiF7%?Esx-%%Am+54`s1JT`# z?EKG%F@GbJshdD-ZPOulc-(c=jS+S!z33U$`B{iws`j;1B<-PX66ZW5Sq$5JUkg4F z7*+n3RQE%YaKiPU}Z$gBtyD&?3)?BFqu``dB$Bu z=AT3}OWd>A);&a-m4kn)9y@E!h^f|663Z3HZ+|ZkCqCrB!it0p?xXp%Mt2|XyksxX zwq^?1Gr&KoSrXm}hz$s%GT)1B9q)fZVKZ!_i>UHU4YLE~*WyvP@EEn1U*o%OG^{bq znyVHsj= z+ka=U&5xaHv#$!ICA`wkte%w z(FK-`VB_DV>Lsp0?^N$pR4G|{(BQB^-hU)j=CWoVmDA2MM{?Mz!d=huoUE~qN44G| zOv;egIK7Q_X8QC`Cce$KbL#vC@4Im?c)BQHTPHr_BQ`LxfInb9%>pV;kgfeo{wO|w z=-QBukXP^X{ES&|a`@xEDSSWgVR|EJV*LLrDW#hDMRd6G8|qgU6sOEbP18?Uc7L9c zxKtCL1C>&0#19rhX5CrcL0%~%+sSj)G_In06hFM`IY=IQuKJBwcBEf6PlWH6=hi`% zN!#Ef<}=p`o95O~zK7?8Zj9#y>v_?0o9$87H?*+=YQ=7F)2($B8a4DRJRw(QoLU8m zTg!X-PQ}D~!b#H}-`BPzaE+B;qkr?Pxew~@qN|0x#xo}&+no-nHU#(v*#?B|dq^?q zraFEGi(=&w-u<)eFXzofrbYZ@9b|9g)A!O5Yt))3@v28kJweuM@@B^T&~YMvyT;Q} zL|qcC$DZAz4@(ZG{zOHjaxm-lC1CpM*DLTor%cM5sY9+c*qfvtsoYZ!_kWamDBCQ= z{adQpvL%&Yi=E7JpZ6-(K`i@Gm5b*x=3f!7hZSs5{rcAi?vvpt$v`8;PhR}JrH}Dk3s6h`XJFXO9^lzK zm39I#OFJvTn+VBP%l86_34a}Uvm=|18PdJ6OCRIkHflKp@KZI49@7dt5o^c?9{7Cz zb)T@lv}#c%cu77HJ@A0$n;FieK*i%L61nzL2=RD>=9Mmpdk)&yaAgnpU2m=Yp-kiZ zR7Sot@^jR7`g=#{+wqf8UsEz{7Og(+eroZ(m4gMdfoZ_Vr+29S0e>14d%6q0Y(Av^ zto><;!-eY0sdcuHzq*U>R3G;oTQ~u+B-xh*g4|)n2hex{EJ}wHy@oihd12l;Zg(-C4brKL`8R zK0Xkiy+ZHnt;T0qe&>_d{vT|cH-cG!RHlr6Y5!(nC{XR~!*sbU5)n07HJ=G)2JAAQ ziH(4Dw3VOL3YXy+9ut3qA1Prx@B5!|TlWaB4(u1O1$7AW>45M;o#1}-)6sWK(gWbg zSu1|AM4yT8Ce!nC@e(YPY?B?rEq0k(epI+mKIUieDs)O-N00Ogm}i9Hoo&$*g2ddd zvRFzsu%23^uCoah5X-)t+sv&2v+ID=tN|O+Zefu5R9LLei*JA9EL$31@_8@k>vD6RtiL*fj9h zbg@-}u(4c?r0qSSX_keg|nrMroNAMbf5t$SH!tNFvA!~lcYwfC5B^+~Nvv?Ho zi*34T`mpSY6tQ%*=?8*Tx+>VG0bv5ErC#?$T?c>OC>BpGj{$P$x>@V4mWVr6#ujcJ zFjRf3mqO=C=%GR0$7*=~W2f3n>TVxc@&jJs3!vS=SHpkzVN|)RS+i~6dv4V*)^}dF zyesCX#nj(129idR$~A7SMQVBaWi7O7xlI9yp*2z+>@V?yH~PYmk<4?hCS#hMxnHuF zx6y9ijT$AZ8#B%?m2HHT&=tco)~k!6<5}@;(mhaoqWFaFfw%5*8xlHM(jC`DxyiEM zyP)`l^~QhdPYuiCC&Pzrc`xJNTnnvHi=HjXH$7ZY@a|`s|KM6!lArQN#msGz!}pZ^ zBr18+QQcJAPFPIJ6Q;XY?Mdh{ACHYher-ZeNogoik|t*hO;VOI`bYpTF3Go zBqDB_Vnvof)dToc*%%w?dMh^4vJtUZv0Kk$&*p#cUPLap#pz+qJ$t}9Hh!}6pGQOw z_|H9&$G6R~n_99`p%*&;!e>x;cJ)#cSfjy&QurU#>J`nx6T!QBP2S93O(nms)V7QQ z#s`o)ELsGCBgEpw$j7~)>H-$0V>&hY?y@-Hz2+Sx)7^|?!`b|mg$MFi>Xr0|mp-Of zGNykyR>XS@3vD}9U5o-g#iw|j$ovMw$&y?kXBOXEJPV&z+RYSqy@2gtFbG*g5oKQx5iQnZ~>kZDU-~E9N@SYShvih-uP#M zHPQVb;}`J4RoYosZ8D8BmzEqJB7axkX^nz6h3~N|d!W(|#5-7K1ZR~=7nE)=xPc?Z zH3h6)_5xt-J$vjkka_R2T4yMK$(w0Qs&q@;d)TrQX)oVHxUs{wbIrmv+}DZ;*0rh3 z_Y@sT_>!%V9_x*qRp9DQiz1b=FGv^4c3GV19q#7*EFg91R(y`Czb_cddw=-vc68`5 zs+D6dZsb-6d|$Jrdr`FIM5$^OO-?HGZQ+#)TYoB@nmZZQ3iy*Qk;Jbhhdcjbx)lGo z`#Ep9Wy3<3Y;gF2QK+;pdClEy8mG=W93!8r2QUL!F3fD8KRkQb zW}iW4?AY%cr2<@i{z?ZV$A2-2nU)~l!V;qoJQa{OSZ8hnI5*kGx`%f)i6-d7P;~$} z40p5dYqW)DMyvQ`YJm4+>uxJDxRQV7ojNM-xQJ9%y#Q@CHF{30MpSnI9Pv4;xDD`; zLqZ4hHi_Q`c{DB7v8cXvyDqCMUi-YVkvnQ8{9v&rs&cGHGufY$s3|-h;hs2B8$9ha4u?cKL z+`FRH7riK`#$e$S;nTygK|VK69*|uU3bA-;p>9Rk{PWr)*rcCoPfo@vf!Dj6*rhU9?3i3^nS1 z?&rrdJRj;M+sO*;0?co25++9#pA#VPY!9+5|F!OZ%x}*L&k01-3+^enXTziVu!?M| zWeuZ^HHubbB(g<(&{Cog^PDh#LG!Dc^QQ0}9HN~-M^uF`eXJ^6@R#AJSk1lAV4soG zp5CF%$z77W#9m-8$X#McH>77+={1*sHD!`3+z?Y0uFT;P?B_kawJ&=9~=Y zkHyzrtM9BRUA4!yMKOuzy(R z-&0F2^1TF|e*u%M?@w8&zNZuuRxR7r=axQ}-jSAQ*`GT;EzvX%_hlOAjb&?p)oXG3 z?ov!V|C$hG@{U90NX5j*9M*UPw5{Nt^bTJb&)SxlWBN`|p3NW`1dd~5#@e#GT!tD>IOtME+A$sOd&G2kMJ$3gYx@PQH6X8h$ zT556K;yT~g1^004V*hT{!6Hoy>(_jV>Y)hUWn}&A0a?rQX%@|bCg+`hfNVhB1gV@d zrv8I+CcTBUr&j6627I43Tc!fQ=M{Hay@K7tPh)pEG6f~xkTW<%l( zz*t#;P%G1oNwJz9Uh*1$YbGm@$5R>MyGt@N&x4<3Q7P~ANmb$2huEq@)vz17m#sJK zGv+%{-9>!Z$fv)E>Lr!)5|>LPb}!E=Bd}oTU&sH!YOt+KM;(VoVZ-xlV{f6-j6vzC z1bGB<~AjPTb*3u8^6WRPJG zyeRwIw#+!xH!K_v%@&%b>wC+;+HltMnPl4DGH$NlNQ6#uRhFi&I;huIHA9C}BO

zm=v8k?j|%sFN5GW{DFh6LAT-^{I;xUC)>ccW-1(~@^om?3Czc@3MMf{>7;}Aiq4Pc z@!0vFWC{ylWth=@D2A^vm7m0?L>)6eM6BTqNw2ydg%y|@(o;}xA$F^D=%_(|M4}UW z;4~P6TA>#=B8K%b?L!rSA{SbOv(oD+H)=NJ&ga+NQPD2x3^2}e_X@N52}+7GvbEph z=&nlw9Z?Yk61mbnbQ98<^l&smszo?0LyE z!tqMxuU8y556k}|DlRaQM__P&Wu?z3F7v-k6~+ms2|T)^(hG$)8oi3=C0`b2+zs$W zOn+xB9k;|x9=f_Idto0kn&|xMcQg&PT{#&M~|j7~z>pVPh%! z2k&6ba0Pk7P0$tB_$-_OmR<47>(EE>Mcr#Ft6{4jV2@HPWwHL&vX+&9J=|q~L9BQ4 z<0R~h5yWUZ`|7=ef=G0X!OyF~87Y!>E!&$%;eB4B%dllPVO~0{R$3n*cg7X;>T9NE!xms_&hR*d)3^=Ul}eQzS*q}a zYxsT4i*y<}1&@CdvVy|c63!eG{|pH;iD=Mm{8aPwLuSV%oP#WAfLvieCZR)QIr`gs zpm8gCZ|}A}tjkzAda6C+MbA%Z2m2F1f&P9FqmEWxLG<+4MV)jkEN3O2x z8?_VHSfq|f8C7Y2-@STY^Wn25j2JWYE&ZU921Sx|>gRj^&*U$ut`$tuc)pHSoi$Ux z`{OxQ=*jIIGUqYZXpCb##-*%?zVGRmAm5sZk;zyms&gQnt1{Im8ISwSRo81G=2?dx zeZsD(thur_$~&Cko^-0$lofaJIh6b6;;-ZTt~wqgQ=V*peBbzcpCn%0876ft=hZAg@2RzP{ysp3QP3Osjk-eK9*@bAhgny6lzzpwfs zd%a%T}v+uOXzXDvpwBMZfzQ6axO<`$)Q3s4OpGB2ohx*t46~MB~ZiOpaO^_h! zZskucd~M;?zGv;7GgIF=ljpOlqt*AVd<>89O`Su3eg8N6T>icUPonHSQ}61Oi#4vN zkmeL*SMN&8J!DtZv4k}NNvzzl|9;YI?xFEKuQHnxc?L_BS>b_L= zbKl;;r+Uw>jIwuL`G1!KSCA{`s_)mSyA?BzpQiMEc2eKEDko?nkHy5hQ~s8k_o{kQ zOgwIXJx1@uQ`#{@#r%6Q_RPeTxA;m4xW0345A9-YQ%}vaYsynk+OawtwUe`6YHssiF-WzC{_0r zdjbUmByFP-&17GiZHMpX9q&4|5Wks5j^p|*y@s{}1mtzlmp0TW2^+V5Sn&k>>+C7sr?fzEj z0xjLy48zLummbyS`QPz=$1__0g6355I*Re0HneL0oR(QMY5B4xch7pseV6zDT2>h+ zXswxJw8K*m*jA)vChqaBO8FP9A?x{nUQsJFCho!hYUjO10pT9c(8Sl#UW3hFPg|kxAGRt-@`J?lGi&!cxwv7~7yx(}S zD_dgHJK@);;tWSkNvGV> zIWh1dl|CY3*X={SO@;8gAkHE&@6(9lrllvV{4(n#uIU}lcC%PXJ@A1fy6Mi4>c&5+ z(UyT|k$&hy&5v@vrZqg%n(RM+8<#w}8^~!NDI9kr<5KoE^hc?HCoLR!66cpVy!2-O z7@cN>acLPi0=M$n3-TwAWK>W{G6*a8@M*0UPFdmh#XEVw0^xAgDv?XT8k3dobF1Ack6rCG55i9?9TO^~W#| z{F|Se(xg-0Kbn_sJ{?RN$|sx8Qr2dQ#D6~r{Dt2v@eul^+YZjm**HEw$F8V}GtQhztZqu5Fp-g+7N`8CLEgsI9AbR71KPJWfO%vH8( z49Sln@6xGASje6eV7-|h{~X);ofMW1nuT{#L-MP9l?qhMR|2~iVGlrdjl}fVvAxoR z%!wcyPXsO^-gNXADPQOcirXaaNb`S*H=5#Nj}pE@;QDb?{a?bZ+{RRifM$Y zWa(K$E2Snpo+#sPwpL5bOjF`8^EKB9$Hz1)b!FyJYU&fh#m<`LJ#bL11=q-7x1=&eQK(=saDzv&$0KA&^GCAbX(WUH@e}9@gMzGN_hQCUUKt>taeIHTSb~}$kcwXECR#E!wO1x}6 zBJn2_76XbPzBrwx%oxHeGj`rI8pnEZg4CYTMCsQ6Y}HxxE)omrW4^91&|E-w;Yh;$ ztjBsNoa+TzJcK@1hbSzFQlS5v`ddRz!9uJli^+IM)9${D#>MXkLw_*awrmM~5qBf* zMw%D>xg<8dn`$)MXFh9~;2fbM%PJ_ibSCTY$r7KoCksO%|7|;>)rTx=5EZQFRX7s3 z0XyV4vP7wT@`Tyv8dWXcNQR_|fk%YSxjME}ZT{aRdjx*XI>dLYc{kPbPTK;$lnPj1VX!SJyy#(MoTSg3tYQax zP&6aL-;J&o)x1VWc)ePv%UBwF*f=5i`&uhoxZPkaJ&q``?0>sv757k)GTCBct7wEX zn$L=RMF`zA!cosi4pa9ZcVIFN7JUpI;%Ab$qFI-!dWK`cbl2OXSn=Gy$=xfj7xTW{%U0la&33D> z-%Vx9xG4P*DlUsHi!F~~PcXuFHWmpNqkly*Fjz}w?IPdY242xgxs#}R-U-MrrQb#O z%x76@ZI4SejiP3jg_XKG|2x#|o&$??FJA@NYu9LCBYy`%Ue5t~#Q_T|Th>9hx1FouxjsaiV z$~)o&BEumdio@utAuLCiXlJ=G{xj`r&1a+_H~qjlcL62%e#vyps;IGi-DR=mMK^eM zvc2CgDu2n@V7QazoAmOKYW8)=q+JDas~YxmJ=>+t*n<@+#%vqdfQ|u^DR|iHY7AdG zqg_P|J%q?|NJZOK3UjNP(&HHj)e8g#FTt&k9O(4c@IVS}Dk# zz3>$_fD!9BusiJIEV{;i>~K2b{slF$wAf9XtbbqdIK&gLCwE*b;z9+qEd8KZBvRvG z_9Ek@bnfcya3Et8OHX2qLGX8Nmuy`^2btI-mHgRRmW9oU6U+QSxUQkFS{Wu;;!4er z5NYq`8S61VpoyCPl=X{u1?P3ZFl^RQf2n6u(ug9{tXEu586OZtK*^62A1*FKZv%Hy z3J*)bR^SAHVdv*-po&?yNtb`Y8z6r(k8(&ZJ;EM&rD52-|3qh{n<`Fc*??`RqtbHY z?9Ip_H`4*lXO0g0|Dn!|W-uN_FyBe!fL0#MbF_^2zi1=TMQ&unt|G6p6{w?4)HE;K z-%#MDCAPJW8MAlh6wkN=Ih!`VoA``U>%N60a!!fW_N4XxdD&@RcYqAb3(bF8+mn{c z+{?yYjxmLInzd%F{S}>qVhWDg8|@`a4;H1GwM!2!JxDt6*B^((R&w{Nsq*i_J}l_4 zn!NAv32e&X6O)$do@348pL*21dlyiR`&rIx!3pXXgpqX%D$ODVZeQN=JfK)FqGIb~ z*geu)Th75&_`AZ)evTUbrOZSgDWj6~u$TP_}sK%q0)A9V0SZ>DL&sW+_z> zZx&JwpY0x&GQwm07xWQ01oYz;KBsG?I#BZ1vE_~q^C%bJ!4<2yM}L0~dq?^~$Zl$Y z{E}Q{6HWq{%4{21kM>Xnp2Mgg5||AAwOVDZ`h%~PZ5GyD`s^hqcs0kC-_B#`!O538 zfjX(Wq~4mSAlB&*65+7K3Qo*XYjKJd$$oMua0qP0$MatH{1hj0A2n*8=Ch|@$!jPw z_x1r6kaWb_zC6$Sh+vnS!y6(oHs9?X4r^p&C+)^`J$jTjQ6Q19VMo>6G*}~ zwVFjFWe=D`BI>(jC)Jfa%(w2t8xH}0+B+O^TR~`V!E>$y=Cln`x{-JFCg+!FnZ{k# zS2ZQjfj)bw)aE*)HBV~|o~em@vbR|s{A3anmTCx7?q&V&Avr=|SdNf0aHZ(5eQ2`u zK7UO3HSLdCC)ze@T5@NbzTzp@ z&wlFlaMTN$JJRlByLr3gu&+3$1Q^|BwR$)RlvKAWKa`$bqO~Hf-LK26H!RPCWDH?` z_VH)Vpp)H?u!fA>I1QVyMeLROWzBK@Fc{+O=M$cZ7 zGn%$1bl`jk%dbmSLU!lUnYm})5)L1>RV9u(?Lo8FpkTEcvd2544cGX8^Cwk{LHyzh ze(hc0SkJPqXaEbM>=(i0?4#h^F4VeIdd9rnp-Z=~o+WYG4&7_Q0hE6Y6+uB^z$-t` z@(cdI>-SUb#_xIlEqAtF*uZ*<3k88rf~dtsTBu6K=6 zA-H(IXDV3nLTU|=d{1S6%fe0JxHemu<``3{!k5RtuMr%DqXYJs^fBF$?o4P?KNCT{ zS%^JC@kykcrJ$8h!}F+7>%I2zJd2L0%zP!ekbQ5z`|(*vr`l&eC|@G$-Ey9NNh22D z5PXX31f4T_JwJ_qCLpWY!wU@oc*BB__#=+hn93h$y%RC8x*7;GX@NxV?jU#;< ztHHp}OWdr+c-PXHDfgANn@=Q9jJuJMzvA!w4E<3`zFS00#yNtH;4R~1|2W?Hzx_Vo zH`aRJ#!=os8{tFLw?9kysDD1{deb|7OHTZgEP%J-spyy0&6nKiw|?5QNAvW}F+cr1 z{CmjvJnBLGuD96*m+CV8jhFn#8$$ukmq5rHbrbFJ*1q?!-2XS8i4y6hti8?jRhP)f z8&7{VYrM6t(ZV_`+Dx-OFO>Y4=qy+Sp?OM0Os^fby>tWHiTij3BuW)T{;z?$($CmS zDOx`zYb5UpVVbx=5%Uuiw*4lqZK^$RCFKtpAEIKc5&fDkqwA+)LscmD9BY;cSlF5n zquC3e)kiUbD_~FX_v;k=G;p?IyL?x$Sr>ni@kM6_o?D~VVErQg)xZQAJNJ6R<6FWM z&X~f>mq~7#HCK=nj$UOa4dpROZ<2o|{adgWufmdwfCD=Me}034M^+=HYn0xDrTY;7 zUBjML$TLYgv9kC3v|#Y0M{9Cn@s@danMbMh%)&H&9{Au8Yx9tGf@%fUVICU5vAtJ! zkh&4EIY(1jE4HBirHyAoi8NHAF0dVAImk1(x9|=!q-CmHzUW8AUsCtrruKiOf)NfS z4dqwP(ACU;UBLT2u6_1@kybdz_&o;AcX>?LX1$U-pBl}>qG;(ys|di3wCKw>ww0hhv`x2MuaL-)Wvn6HIOEcBE}T4(SEv;c_$p{O$_b6JoF0tPdzFQ8xyCYuA%{vb9Ae+J&Ag&3LfQJ`XpeWu`K(98{sT=Q#XA? zQX_PgUy(}p)6lZ@s8k86=lUX_?A1V$pXXVxL=;hpGe{Mi(i?wPy4fxBkY+ji{Kdx7 zrH9J8q|TP&4ecy(F5#3MMqk|nNx5a8PqUM|bX?-kRy^zY70*{g#&hNC=RM(iD*XiO zrUTT$XDvd1@ep>ToQu$#V_B~Cm(wwxF~X_geZ;tH)ep57mzU_i@>f%2)&Xd$K{llR z9IBX5+shg_hQ@!*7{XU8eP@M!h{K~PG2hJ+Xky~S`p3y!@~|O3v1-*R`~R?>o=7Q) zN0CjElduuY_7bT*f=ELJ`nC%H`E_K7s*v512yK_?2aekG6l5P{MAfA5%S%7VeY|oN zYDHqDUATXPiKEo>TSW)rpFy@HB$`>39kqSuUGewBq(pxy+o4tJBqH?!lULt$Ci_21-271LqXX?$;CNTo2MR)_f$ZS-r!&xw6B>t)aMj4Qd(U@bZa zCJ(7mK7x9R2B5JU&`(G#IE61EZ1^xO(>`>``xIvD1Tu=kd@93K!+ztfY87s-5>P66 z`*Uo|zea!lerRwWUC__)5NoNjFwYsSdz0@Ml(>gO|G#$7(fXBPz=)u~P3-s84GJ6_#kkdm7RIqg9R1HmYM)V(jY>F;`+@-H5VC ze4_&zvl0E&?{%5)IAlX_pMnO7p7YoQ?Hqs4C#Q!0jpZwt45G2u!3z(e%R>vF zy;{hOHHZSNLA+=^U1#ez#PgMt#u`-mL)lAXA7yVddigTfUDJbEBaZSAZDgWt;e#VFU2;me|Gn`Ciu%e;#1>nunQ6 zY)^md7APG&Sk5Ya0Xwm)cd&K83GsaKB)XBqklq42(XXRbt)O2EAGih2w~LO%ceCzE z;(r^ZTWIF{qJMd&jzGgm&0h!q)@l8Mzt2balWywb)3Ol}kdOHuN=&dGHF8II=8n>? z1m*t1eA~;8EBjQW?FF2vP)^BBeyr@ef_{IzRK4{x1M|y+x#mksU$_NI#4oWyeHAqP zT#?;Hd)Q{j*jY|aPJEXdXWYR%RH|Ox)a8tptdQmos-AJjg3AMNy)oE}A$5FHQQNx^ zUF^b2$7Qw;Ld9h)S9vz1i;&bEvE-X<{lXPB@89{ALkaiuUwgpb5k!u5EviB4bPIpj zn~eC0aGygK>=kLKQlPnFJUr8Ux*QoN|Fk@_LC!usFmznp(B%?Zp8JS(z8 zH>~}wRod`h^v5qI*-`hLB8rW`p_!#a zk>CcU_gRCg0X|Y~ptTYwNo)n3E+37ci22 zZdY8$@LQIS({vwvr#S4J%K16h5a&f|E0b=x$&h8cUM`k5HX8i#>$X zkam|SOJqA=MJn$u@%M$OgK2+-2CM}daSbV~EAqVUVDge2!8%l%Dl&5)v?i+m&`Ul- zsl^MWkNvxg=07#V=6#9gXzy{BIitO&?JMxiF<{76`W)?-9wxw)oaZqp6-C=sR*Ze< zSJJyer;ug40CvD?c#5K_xA7|0Qk848Yjnn?*Z;&8$1&7NDY0+qQ5=7cebh8mv{;&l zn(d|eUzl}Zv)-lqYVjpH1rPLuXgi4}T0UYghAlAkkZhg_d z3*`Cfesr=psXp5Ya{J&*d zsVVb)&Ak-%OtLs!kXE|8drtlV_?~SkQbN-8u*Fq2=Qh#|4 zp3fF^wvw|Q1V@RS-4?`-dZPY=+R`%FE(&SSl}ry@$&+ZpA*z2V6Ki1yU#p6LcjFXF zRat#s)mjB24f}BSt2o0d_q*_=fDvEnwUj-#8F`^i$Vlx2ilAQYc6CW=Q#GFnA3WbR zM3XYgNHSDme*FVTdK2+s=P`cOTA&pSH7}YUBTpqHhd;x#p1Itp5OyQMz+ifF-6I8K5>W$_S54 zm1YcTVx@j~ERW?PFvlWc8??jIQ#?OS%Vh1`g8eRYa16|tmr*?{984E+O0EYqfu9PO z3VPyJOcwlMJ*u+9dBQUqEU0ANg~$xw@7JiZucGc*uOxqT&;-vYf@=2CLR6#pTb?l#3Jfnl&og^@=^^&GyMcO&p*G+1{!-gU&lvkqt<|_o zYh7}8Sy(ftwC$bUQAXHcl3!xo7W*h=)1BGJXtkFN!!jP?rvQhCF^5mt1*^?GioF;m zVz(8tHcWr#Q%B}Mi@nb_QoIQ$1HryEAde6(`m$8i?gaH6)V zUUW$9g%B}CyPgp_;aJRLQsO~MzpgVh+5J1-dy)@Dr}qTm6_7fMV6s%spG9BX7WC_A zN6xSYIq#(SZtb73eyP9xE$rlaTz9AHjTFhM@Xiw^wt84;!Z{#Jep{*2Qp&sIFPV9U zcQJp-r;CjgE%|J^^Z_-O(gsV~Y>OOG53MNLW=sg8& zOeeh6YpN#LiJbgt_CyVaR`85%hg4dIti6)WY=U1^2R@vw?n10)h^C^?(q8Pe!>nxu zlXsGoY_pOFRU=?nf5md{Mr^PPR{bfkupEDdhE{TNNgU4zj*s}+MuVpLb zgD{rWJ62Gtq1A9rENES-<{r6^>tW#K`2L7-A1=HxJ?Os6p5>S>Q90`u-YayK^;adv z7lMVrk^>#2#4qtvI8JQ)kI=8>Bzkq7qa;hLC3cpL?|Gc%mPGb1Ks#)vZk(t}oDzSr zi4M;iuPK34Y6sKe$Ew{No^|w%Pbm^OWcZTbxeI>Dd)OCA>~}50$xyI(2a62x(phSa z=#ruv$S<}j{j1eE>5b`!9j}NiWqnzT-7HbWKk~?%5h3m%g$3Gg`awp^x1f;wbx}u7 zOYtB}zm;v)r()j5;rl?;^jJ+X>$ZP?)K4mYz$>hkvPL39mq?ACXELI5p3IFdOZHsy zobl}Q?4zr?R9&iPk7tkL7l~`;8mTKTb#DILe9gV(PbZE_ycy9aeunS{4eX)1g?uab zn18M*)kNXn-Q-@mC!s?lJYMSN$q!!5s~(4uR?FV6DXm!4eq?Bw~g<1&lNp3RNEX?%mTZ6}4z zUb=`5@KZ#~jb*8M##B<4d<#7FpnMz8(^yL4@8^Ji@8|JrepG(mzbPY{2771<`_&1O z9_0xtGPpN#;9EX8Kau`h{|3||^cDK+kK<12qORzHRs*$=zO zucx9C(f}`CkU6ESp{3R_1<$btJTnpL`mQN44|5gdUbd~XJ*ge;8O>MU%Oe)Azugt< zydUpx(&d@|UUFR192P5ov(jusYgY8$PN*lpx>7_V+dQUe$9Qfed%GG zHWOc`TcTflWSL!$n4su~3$f3a-&JHH1vREfcCr1sNa<@?1GZOT zEn{u&2wH;aXL#mc@Vsv+*4(FaEMI0GMn>7&#{0_l@;-DIr5eApyrL|YvNchT>5l2< z9RB1*6&bpfb{l`Ltw=Txn=wQ>0SV)dWtC;sj3HWs=9KoL;bdNi=9DAo{SM;P%{10{ z(Z7hj>O}ic<9#V-lE1ILXj$doXFnUbZP~Myp!TBnqGO?Bp*Jbs7yk^u`!4^>sH2Hc zwKj%*j0uYtkWn{&@&4q;44+YEMoU7NqL*yfn!UsAFW7&d(cH6WOa8sCC&Ygh^lbVe zL2dHdY&W#p8nx&6bZzxMX!{<8_0Q`({F|Km9fr?sw|oC(@j;E)*J1Y@+r#9J-}TOi z{Cul1>l@MaR8NywUb5YlaKHD8XN2p2Bs<97o7B+O^GV~iOA>@fn{xzp@y^{1j}Ug* z3Vm@2MN5AMH84|aElMq&fH=b;=*qClWw(L%!aCtlGrmseHASN7%y-+9p<#iOu~t*q zFpNL>M@X)E%QlkkCR)^y6r;w6{VJZ9c5;4eHQY48tR{^Rthnoh>tW6QfJQf7SFMjR z|HOH}rb82D`bui!g!4<6N(pv@{^9uNqMmWOoezJ~gxK7iugT!e4Ls<2D)$YSLo-q{ zjGC}d$MU|>iX?ZwZ2pOPxLif9vE*nV(G``~L&erC+f3!IG?gV$WPrTtC!0J!5`Hzy zG2s(hp{uj+{e))b~e znq%N^Q&EMgeE0RexBura@@sYIc)=b}+?juz67QYlk2em+i13c_8y+ey2n-i)HqDPT zKjK#-?CnQb8vCe+C1a36QNLxaKkok{?S0^yys!OnYFjVuwsy6<)v@hTZ`W!&yLw8-_8RB<)wuo6IZwa@wA=6gUeAk=JbCi``Fzgj{6Fu5{3GbMB<;bm?)Nwr zUu3`NoNW~GnU=65k1kzObwvBejQ@c&(;$>db4X};_Rk@P=CZg_Ldv85l7x>37WX1| zB+_Rg%^9qcKcy{)Ul$FUJ@6`0SS)|xgn`VNV}2OsQJ-jz^2Se{z+~T<7yBR!Y8Izf;9|_sVuZd zPjpROh(v9Hdhs&eD^Uv4zcK;2pbFxUW0ICi9C?2a`{pv) z-$5ASS8;8V$6#3erf`9My5bqNW1~^x;fin?1JX9ss-!cOADcAHJL=h!E#VQ>O4mpe4NYP!+4?Z1kk#>I8s&5wLH56nhe=B zXpN8`VI->=-j(O!Xl!R~{TzQj|0Tv|-zw8VA9b@!j(nrJ<{V1>Or$}o2P%e~%0`Nt zF14yExW329^^a-zZAt0Ar6gUqqjg3W=1$T{aYm0z80F$$0=6y33Kveqxgc*>y=oFT z&3~(|U>v?dc(?Eg8Rc`_Fn?Rw$$2bP6L(t5LJ6Ch=i_YcLvX|X7)XEduY*v(-Z5gC za34;p2|xJ!*xLIY{AK)Q@0QN>D0ON zEzeIg6S?nSJapN94>yt{Y5vUQSw97Pvu3aklgYZlVW=k@182DITJ7|8KSLRCl#${F zp~>E+evLbwG>)r*4efs;6x_RW#C{p>gE|_M3gco{2+DxrC6|iGSpi{0g<;1BUgCywoqU)?>a>*;(7>K2QEv z`GSRnP`W$ajB~h>tX$nL@M-P~L{Ozp-Q<01z%x>8?@OTU?Jre8@kEXbQpPkP|0@%Y zl17!@t$YYFJzsz176SPU-)HoG>QlInyWez=5t+yyzJwYa^P-o0kaMSp;hRDxIG4fh=;Q$`3d@ zRnirYb6=rP1Lxn(@e;JUsoN8LB0eIENS&(q9U-8>Ze@Qsj>!(rYhMD?)#a9kL9xoS zte>7{6t#*xzc^5Y7n)e_&l z2vR;g(dTK7P+sJx>E$ZIX6|OtfNQTGh69;De!i2pwF!)-+Y#__NI4VjeEm<&#P_)5RVrKWYuB5;jfZ zP0j^*m%Ui^e7CK-Yxx=CBMCoWG|l(~<-*~X&v7wAP9*POJ;&H?FmAt}$95-UySIXb zu{acW>_A!_0x4=>sTcw7%6 zl=)ivx%A$()Ea^=vnYr;v8{IrrsumS1~QR^MLd)RZohog*y?7B1e zbEefHey!&S5qTCr(q$)|&6tC{lOi;P=7%%C_y~27(fpKGb*rr-^GQ7SAakU%QpA4= z?Mbp)>#arj?mRSDlGzhYks+sWQt_(FoxkiULju2(4d;L3tVY^ zIFD$zi796v)7lN@WE3aw$ooFZp?=Pe#I=}_mvqMFLCHX|%i(->ih}{J=;c^qKmO4j^>MvpE7eO$-g7*!lGoga+ym}CXy9rc%7xel@1~U5 zdfAUkchzifLyOPLxo!L5-PIS621jz8JJ>3I2dS)q>FPMgsrTUsp5<>Zk#=eNko*5q z|C0`NdLVBJ$CWrJ^}FVbzMX%(*Go1stzq(9)=YTqH5vJwK0%qemq(s>!D*Hgmjab- zgnc|1xYH))c0(LfI?uUugUDlB`Q9!uZo)9Hwm(L=4JL1T3i&`vZaTvYF5{j|nJ5#N?va}|8c_?QT3FPOv)?bd z$ynP>;9oXT7rW~J5&HET^KTel&ztMoZ>lXzkwxIOKCw@?W-N?B{XP?^#n08p4LH7A zQ$8>HY{f5$P8}cf*cX4RfbYhsd8Ecdd<=3tzrp!`zlZhs z`yL+g?Kr19xVqph%e-R&nY>ds7vj-AX<*!a&hHd@88waM9OV|4QvZmxB)R(oyy&Ph z$M&-7|C%FVhmeEZuOIJwsIt>Vh)jJ6yE*4zCmiOw9;&Q5$eA=m@zh~}yvb)-W|Jf% z9bgC3l$T}JDdB%UMjF`3@|JQEV~|fdjV~EX&_+#jnjzYC81KxR*l&oUSwKsgw8=9dM+{VZ08(=b3DSkD31U&z4ygOPnh%8%OXCL6dv|$5MaZqS}k}PuZVJPj@!(T&>70 zx@CDbTALB0fgWRv~6V7Dtv#0fKj?DU5mhNRM^%!Te_*lZehxd$JRjn*skQOWa zMl)?Cb@ZZ2*g@KFdlt_T$cocZR_qPKgMt1AHyW*7iizcQ$x=O)!~t74 z*14@r6#9!kQ@tg8548!Z=*ROX_9ync-k~1k_Q!uv2ROwQF2{;Vesv&)k)=wp{dYL$ zX*W<;mElo7M3pR=Bw>N-__lGJnX(xgxh9tO?uQdO70zs-U#p^iEN)T%Gt~MT;ZW`x zO&aosRPkG`J?Q7!x5c%!zSBD>RK^hL;9ni!-j`Aw_7rD`Qk~jPxGEAVLOtHaRz_Di3u0z?ew1-xa%9nG z`i;7|#D&*h=J^@cZChW0eCojJ?JUP`cqCqgx+mv%5pMcv?i3?sy&m@5;Ov9F0d$Xp z92FeNjU{f*Hd25N2oGA4Wy72?N&4sxT#rIL|iQ3CFj51)w&*va&1^C}2$Cm?>rA1M zvwPyeS4CCC^#h+}`AJw~)P z&p|87ugsMHPL8w|5fV7+I99ZlalUd_tsF}D9wb*b2Kd+@XYC=ax`uM+C8mFB6SxZd z7<8JVc$KH&oW&#Gi@k0BX!J<;l0vG(^QX@$yJ^~4cM|XBH2!{HSzJh^<(Rl@-TB5;=c)zDaKfk3yzSK+?4Ro< zhK$2}7>mo#`0q^N(W8Ge-nDYG_)Tq_?wUoenO57TnI=%S$wi^TbhN5RZmY&4V6ie> zGp#Td9B79O6q$+l_f+)8>8wP9JGSA>uwKfAsA&Aya zz@apQ(9HeMVhrzrEN4x5|MDMgn5CX=%}9H);DM^106N`>pVEI<@JmKpimmK4JgBXc z|0$y^qpb3aq%&?2sqlTplUXy;TXfk8_p#q`JR;XCf!^r>8=l=rbSp&xuNS-xwKUY7;fIee6 z;YEIN0J(ZPw1}z@KQ>**S9cP)^8)P1kHR&6hv5o~e&oaC_2fW6Zpqb!Lj)WG?r}W00zNCh2Qw&(NCxkuxlu6K7B$Bq`i6r=bQS&=E6YOulV^)c&9mG z7L@N~qjlu3W3-RcVRAg4{4wu}%FJ+&5n94h!ji*&74|ap)wUIV20Ja;;9PFA$H9Mz z+P2y@rK`5hW5oR(Y>kpd`8MYm55oI6Hm|@T%M8m5*k{>{cYcCxR@8UHV(|K8_Y5Ax03SpcW{6Axlfn_yvw?IIUKI)cHd=+y3?k+Mz3HPvp3rm zrG3xze9~Fr6)j=y6GD_9xew)Ow7Vk`&%yvbxA+2S-Sk|ktHTxu&0$ugolF{iZGv%b zm;lu81D_o4w}-s}!ype^rkcb)Kk^UkwcH5%Pdr|RzmstX+q5uC*sQPxdAombJX)bA zj65EFVUHG^4oe8r;7slhi;>UAaTB36Y+6{ltrutR6Q2FWVJTJJI8HL8!&ky$I5skb zG&Pt*9`^Py6VndbEX8PTg{i{g;4F^45q8wJk=B6}as-CL;_+&Wkv64D*&Rq5CVC!T za}}JeyA_{jAMQ;C2kLX7+G2k{QWweH1-Z%t z(6!VmK7#wRNVBQl;1-bs`%vr8Or1)eC)8so3V?TLnNeK=>hu&Swz!q&@vdKEIZQn1 zbL0${R!cD(KS~83$IT>f;+K>Or>&!Jme0gJ-YAfn`adZ|TtKIws+3fL!# z9^<;F6sJ}yi3hBgP{Gkcb$6F(jdN3{rcPyV+97#%@qzp(O+Ps=KYo_6|Nblz1 z`(bzwPL$k~>{EZkM$3KBy7n?!>VwV}oL8nUrfBLSNj2hxUqiXObOx!nWE$M6E*uiAPA%#nuePKN;tm z|CawE(gkUqsv0F@fyEaLEPg>fT=#I@!?wx!Jt(oz7Bzo}S~FVbsm>SV2}loUi6hnG zQ)to6S5P+ve7H(SI*j>F<5kQa-4ox`bvwfHV_*TP-{WZ88VdnQ*?x zt*oUx;qBfYE&00;b3!;o!S|}`Z*v#7EXBYquDn_^1^GZ-jXKzh9LI0Q?=!=@!Ufx8 zaG<@3_Ah@dfl}euB;6I>ai>9h%UsNPV$0XYP| zssK)8Rl-@^dl>mpJb2NX^a{$jGL0 z$m3xVe(PB21C8>4dZzq3I4ZxO{yLm#g=3!jB8{ZQG&*N=UvZq@@|{v))D|3z{DhzF zb8vr8@V>0kao>(wr1bu1O+5PmBy_Impfz)%Obc7pRGIZIO4}ug*9mDPy)fwvN`(gT zn^H5%`rC~7qBhwkpk4sIPAl3?yWx^4O23S9)%3rxgX&e(!mpu*(+5%yh(Y*NHAQ^c z{+N8Zw$2lug|=ALQP^MdL0Kvspvb_|!KHtLT!~Jxh4z3Kge1F!luQ{DAHuLq$FT_? zG-~&}{*q>zB0e!S;J@%&GjtO@M$ab03EO0SV^w$Ij8vUwn({t1S`k{a^hdAYFJ7vi zt(yxwWTJYuR;8OzaINm7{ukh1d*1p}q~N~Pskjo*UL>tjYgYUmPUS~gGh|dxIShZt zjWx-!L409k^MX^oOSn(Czv!qoK|G#!NqD;MWYR!&9>k-bP+Yhsbv~Gh%H`K>2CC=K zHwxGCzOe206e)fyypnWA%u!-Ab1@S=^$Ur1@pl z$GU9hGf2&fcspb~ZU^plLb%g0kez@2X!@h<*DDTqHJbyt!ol}i!QPH_NO{TJqrm~Y zl;<^%aGmV{cqj9aKG{gx@&*AMe5gb zi*#?o`)UVug+RR;^;h+5l=$5+q&3S|=Y0WQYevE|#6g@>=x)$XLpk#LAIe1TUEWZ0 zPM$7Kwq|JG)6Es`r(AbiEv(X(DV{OLOFearxUQ*km%4!$^@!9-?|pYSKF1L_u;pRc zXR2L&L3dgAP3Aw-W{1@m)}DU{zgtwqS9Mo)XFIcTO`@*Rt=L2!4qO#|Z~|9&Q_=wH zOg+V!DXHL9K|z7moOcQJz(~AKk2?a66)w;>rcNb&LBA0#0JXEFFvyF zssGP%FBI)Yncj`hQ;M{*(0UTb#e(ngo#8>GhPCWr@Ug#eCmcj8@h$QpQtlu7bCPsaDA$zM!gy#I7{2umr#VvXqiiHO<@-obY z@`amAm!MYLo%Dd~BhC1{Yw2vS-m!wqOJgiPqPzAF_y@=JHMM{By3TSWc9(2Z!NA&G z`d=u|Ya8-=N*~bgFlE^z-AdH%dTY*U%_Sdb%|#K^L(AYYJZN~Z?xbd#@U(uJepvzT zRm7{V>z8TGDgRWsz&KZ^FwQm3MV-3==V!eBaxvw<3lmfR8wS~rtwKFxD{PfjtPC&S z=D7ksxrP&piH0|kw>V%B@A};`k!*zwT}nM(QE{6m zDAvB`ju5vPe`x$6uIQj^YdwdZ}3c0~wwAZPlndTSzr^nt=Rkto1ZR=3IlKe1ESXA&5-ji0pRhWYuYZvMw(c|bq z&eeaE16$2G0Jp4%JLstvliUPpSzc#0YC3_Vt@kF>An#ZuUQQ!Pw+jxf9D*2aLdi|E zFV5nxHGzL)d-s=I4KBZwf`0_i+TCqM|3*uQdSu>>;Gg zo{#Xl()y$0w-It2+E#SU-2n`$p=?Xdz1bH0v>(5x&J5d-`Y4V*02e(JbKO>5&rk5C z{%z^H&c6!RI9|BTR10s4e}Q%K`Se-yNX@-9dd(wft#8At;FU@zqwTegw*07?dljc3 zT0MU=+oCwdI9UFod*JVOz0o%^l9VbC|EM7JRi2O140F+E+V|{GI-t8&Is*WEK!m@# zOJ``WYp-(-w-jF(>Fm=X6WCTr3B+Qe7a}FD4A({BmW>kHk5a}d+)o{MEz@(qW=~a1 zZUMv_7v}42_4*v$HnbT&p-eB~=`=$saze3xt79JFVolviS0i!(l;<^{!!gtxf2rRLJtHvKGI=+W-Ucw85YoNbFmp7D59x4|X+O59?rS53F=5@Hi-q1QNFlhjMGK!<`LJo)eebHxVRfco}0u`QNi6Tj1l3tYu*tg_| z_ZCfC{uRj=*y|c{4He|(&Lerg>~8X4QGI`Ifq1X`QN={{6{PES)TEceuv;*Ht01p` za|8IqE8w+*E>?Tp^{g&dKY?ve)J`~Grx}KkcBqQ80cW4|8v5pa?!ZCs7S%o{#ITA4VoM{?D+)HjpW;Lr$9q~6mx^tl&eK_SDzUu^U1$#Vl~PG)4w@e zln1nRDObtoMQ9;q2dK9~CED#;!VRIkb3(QsM9p;$oRNvn!;op4te$CTH9X6I_CS+1 zAwSA3BIS6=e^!etf@Cb?Tc8yWUPjO#!WpUvSkIK*p#oW%O1@e>0lCxD_%x`KL!7NX z;XXU{=JxAzpojc_oMrB_W)$61+on8^{HLp`hx9U039TaeZK>mHrdDM_E8Y2q`EN_- zQ#84E#Riswa>iMh7~7wq$Y~ZWwKd9~+-=iz|mHvW0rgXLt`ync(8m)DioQH6TO9DAgy!mTu%t~saQ zXpe-Ez99{8sN`O4z1);^Bk7DR!ueacCQLz1=sB%fs!>PYaILn@KAW?g z@(47&egkcj-iGNelsx@=g?ocvASg48|1OGW;maw z*TjBY2dGJM-uh5!H3Hhv#bG}Hj z?uT7SPsg?9)E6x`md-EH>n4z$CtjhAqXAhsetw}J^}2Th^$dQ0#@waM7RqR7A}lSf zIcdNxa^$s-YrDN%YeM~;>Y1Cp$0+6pInVZ8Mg*l1_EB!fBA@O-@;=BS68kg5OY|fK zl&_MU;pM~bLQs^N-s*zi1j7b zjMSa7^K8BJ;Y`2FUi*WR$0uo^EDm*sPWGa3_Zg({bBv4W4^xWDs-7~DGW6+{p0h*` znN>YnGd&xg=Y42WP2!m!6gtuV+gbEuTycGHu^?9&zG0Ss>^vN|KW0h5qrC!Bfcas# z=)McboixZ!Lhq-uLWg>$`!1omEG}t)KFcC<3rao!x$OLU|FXNatJ%jAvD9jxZlCTt zn|qG#Me!VE#L#(hZ)ELs`(tP?-w^uYZBwl^!&Hk$Jp1}_`kgESuQyB?DzvUe<(jqb z#}vOa?1Bw{(zi?JyUtoOED1=VMYhS-42`EoZ+{G}uze+oNTptDMwptZ2Q^_)S@MBQ zhnj|;o_PZ87km+NU2lN z3fi=6qHVUZ#7P(q4x$)+qu>hrchnLIag*?1yK2sV!2zL}(2ImeBnj&l#Vt5{LP}iSaQ`;t z_t7SQudDo`B1;xw`18UTZ4Dy_BllC!MlBmDPN*)?m*|NW70)oW?V|2jLNjCYcv;J( zoQqG1+QWXOz0MrkOTLyeRldGVm0N)4Y30tjUZ(H22=yB8<1}8s0ri$9nGOc<^E8!SYuDWEsKd{Q$OU>o$B>KZ~Y2eo;v`*Wh zf+QENoF>jaaY8#H#r%y|i#vRiGvV`Cb|zot$$EerDO5As-l zM5C=FKmuB#O1!chk6(7PqFYS zxcGfL=Mqw1!ao#lw9TVlLijfXX?V4NXpSLK-|dC`#N>%wXN(nJfY1NyclxcUiO+Do znl;0+qHuvwqR)|EPdc*^bpi4_5GFURCXbQ)HiZjn+uRY%@4ey{)H#L;?S<-|@%-&e zt#qXDG|r_X`Qbu=opvt``D1)bhq-(WPx+jd+X>v18#BBQJ((5d8nHMy`%GJ@cUS>X8cda z|FF-jJ@86V;8NrepR$C;;|)fCkUFZJC9NJ;{&C1OKTg^@YB&{|4xFQpH2dvnbC73R zHvwhG9Vl|t>Iv%jiW1c9j;M*dO&?aN8aPvbxA01CQ5I!%IRYpF4%CcBqM@>pn5dY= z^IHbN5zaJa_^nuHAl@0E366Z0u|(X%G{KvV`pJai^7M~V(%4Ko2LwfbQaLWe|5KkI z-9I*V6MF|QhC%YdNE`ALM@SCnNIq2PnC=|6Cq){G>J4aL(D4)>K2Q_yevG_rGEp_p zR$nknh_wT*q4Tf@Wu1>KOZyA<7o2a9W#o>)&r-C2*2KKbdPdy|#H@sCXo(lwf%BMK zSpVH8{)O}}`}DPcMw;n=D!N(|&s?%k>`XZZhumM`=PxB(JHtOS{_K}jUBp?~CwLtX zgBN8+UqF|mn%WbLDo&Z@14yNBv9xQ2i>eB(mow_5+~_`z6E#C0a;>SR+U%*U)t%s; ztWwu&bJ7ddMv7k^QY^`vwMrIS-%B)qghFRD}EPuNcSxBJoR3iwiXUVTM<1sZS$ zx|CF5(7M#BJdgBV`g%Nj)J>V-l z&Dj~gx|664wS(E#TlkUCTsoPN0Eg7G10KLY=7r@af(xXc)WmDzd2>QM_048$->;sD zJkepFjvR)6qMqGwxD2&18zImQGcRp`OU0S6ud3TL#~F^=*KxiET0ev&g}=H)Sds~~ zifz1N{Olv?#C6k^P)nIUWuoGgP(i-c+UaC_D5!q`&CDgnTWCRxo;U{Op9bej_)r(! z&h@D%TUUJ_wuk*EuT{!0?ZjUkHXYUP0B_ON!i~Cr2ROze)n?KijORWnfp}=>UW&Gd zayI{+eD!0Fi!N!l+)ylDy&czPOn@6os6etnJd=2`^gf!s!O3@!Gq*vz3gl{x&$+%` zmP8!$P0bk1z-u^Nm}od%U5}q-#u0or#pp_sB(xkB1v-|;j>hDrOmoWBpU-&%aY0$E zBoADF{6w*wZ++|6!LK1>YDvZs>aq0(Mkty!G+9ulJRL{ftDK|RK?_H}qvyY+^Njp= zj{0CrQSQX@7I&N8-i`$OxDgzOYG<3Ac!l#G&Y})FO`Gy}e=!~xFSHsUmG2{TpOY|C zZgZx;b8b&1NcBm#=X-yDU#Q&P$45j5UJ0*%edRdW&R#~QsA%rvd+Xh;qvAq5?Elz$ z8Iu!&(rDjzu7_YurD*M*k$t+@(Y?12SMU${c^cjk<h+9ev8^YMRgQ@AMqfuWp~|GFCH}IwMFrU~qO=d0@>1>Nz-~K);I#$$=O@F4UWU z!fzU{MFm$W-Qps_c~_$rVeR&!2psuWwdUf?{3zu5efX)CyzD7IhGVGV@2G6FO(y?g zb)HZm+%SlgXHoPS>~Ia;_MXOeR~z$vNup+&skY`EI8ehQ9=S8qW6dC|#~z6iG5FUg zYlJX7YB+gB=jf?A*b97Wy)~zxFJ8VP8=aoAgNoKhBdIxl6&E`02LlCCMo$A z=c25D6|x=jDT~^iQ!2lJp)7BfS4BNGhO^kyl|^2Y6XvT+twP13HvUBi>3GV2`5e>R z%f4Z>Yz*0~>yaO}3(riwry8IYwN}&-bq}BnjR!AU`%Tb@+UxN=A3g=)EB0A_!1}9$ zsAbvR!Vhq-8HNM)mrS@uK2~`u45v<&6_@YgJX-S0NSfy$dvPiE-0%L29TxqJvTBq5 zwDJDhw%iqNv35FSD!@{`sGw9B4k@L3ZG9i;5`;m-ngk&zQ8hl&0$!-eAZ$|b-jI7!X*8Kg)>EE zb-ihh@d?u$;Ww{$qaERYOfyt=7F{(yA*fakRdz0)m1ZdYPkPqH4)<4;ou)bYdhrU* z>UY&c$w7`!B_VE%vC~khwYZmOh6nMLz?c`AgFglRCJp%^Q%cFrWfSpf$%53NZW~?v z#~^M(*KLKtgxz@TeAXD|k3ro1$0WfW-WSyw#M|IabIY9C%`TH zLNg*O%6BOVkyBHlPS}mMK?CgP`sUqiB~s5@sY0NgeKSWq1?(-|9av`^`>4pvcv2a@ zY$7;~+1VEHI9h9eA5qmubp=|fUVEf^CTr$i)@V~@5y%B(t89wj7G0H_*!CDj8rEgo zsi%Y&SELh?DaL`H(zSci(Haz*4Wjeul&dLMRsR|AK{$kJJfcZ8DWP_$Rj0=hBl`EN zXQPI{1`g#G2>0XpE?E|^PuIzw#p2pO8h_|qi0>}^12$QI19FOs?0@;xG$8cj_6XGH zpM=4(xZ+CFfE{FKs(P|!KxTPG!8~2I@SIwi=~lm{{hRwQsb7~JRmAIJH~vfJRP(oJ z74A*!*Eibg@s7T{gJfJ{>&>Z<+k$1D;WUVaO6^|*?|DC3DrJV#xUVHhHl{H550;g; zEK1zOIg6%$iF35bC*^sd291k+!@G^Xl|#z!6IQ1XR@q1~Cc<0CUuNR{E)~MGx6LK1 zY($C~vwzVv1I1^$ilR~eHG@|(t*QsDI{$5-GZnI&A3%@O1#dZDNcUKO3YW_(s`Jpc zCXHCG3YVMQ)}Bwmx6@<)x>`L_u)gu7mPeG%#@rIhz<>-JpEAe zVhdd$ucJ8DVqL6d^SbBqqt-pA=vDOMI*XxhH@b!9D`ld(6Xg?S#7yFja5Un3Z!^aZ ziVoO+<0M&)>!krw6MjzhR_miz{|7irZffgRM5Rt$N-@Zed_9i-kY_XWl=hT9pZdJ5 zfMkG_P z)M1uvlB&WKIL9$W$uG2zS9nLjPed8&EylUflJUKw&$Q;O8FeS^;QmUA&C1i|8A6iy zvg_H@dsLGsXB7OYQ*r%L?Pw3mVK4IQg&Td~9P#|JjZ^{NwdWaW+Y2}F8Ox!)oG_w) z`qV!sL^RnZ=2Is~8k)aN__-{?9%*>c)W)>rmvR`(w3O`@s6;uYHRmr-&oulQrF|}a zOVx$^jTi5w6W)afS@MClPI=y%K~(~j$(TB|?qPc6N|O`ND1Qod zIj_g)`kiHZb-k!$u2-xzuf0rXrFa#8@o3uQ=^mquvSng3@)X;I=8QbcbSWb;iQ+Ap zoJBPx6R5`n{?U^+re{1cg?cV{(|P0o-3YN(4ud& zEOAbOcbIb#*E^2q+i9vr>e&cBq=tL5(t!|YzGQrGm4d2*F1dzk&LRDJk+0r=5B{2S zWpkmgV1V%}S`+)0|A?_IP9WbTU27lfTZia3;HV)KuCu6v_oYtt+;DCHzx@TI^B&3{ zG|t6y7USF%b2e|W__E0>R14L1oK&IO^^tb9&@W%DbX6Tue&4bJGED=vUAhP9Z~g3z zKBY_l3w^T0>1u0LlkkaTu4kctMb=+C-MvpS(GIA=48uTroOz!1V@Iccc}}@Noi}6P zh}@Ps6}1k^6;Rn$7UXKL%k9?JWukflXRaMp&MWr1BM5t55l>yEJrm3s28$z6BhqqoW&G>w=$e6JjSg4 z^=#jh1reOp<$x7M5fwknh!W?Z1X+BkT z3$Nfx`KTh#a3bj}RlE^Lr$1UXykZXO<|sb1@p(Gb!$@g| z@m-H)hAvhG&h46~WD!dm=q~WODtcC12Wr%KROyrz@0>8ddzFNMT<9DRxkXM}3 zvtXo(BQ!59=u_eqSP3Q2XN*d8aglk3jkdziKAoaH7)7q z_-=i6_A@Yu^w10ka|k_mc&*d8yL7VRh4l{kY8>YlJ4$AJiYds~BI!?iUH2eKVTqnu zM;~7IocfA?Yumc#;BDe#6a$x?PpC!iw98{GTtoJ3L2j8SJ0s7iZ8HsM6Ey#IZBO(d+Bq-rDOijzpqIHg|;dzi@%aXgaD4x3|&n z=$FcWaQy^&RfbES^%L|HijEc?6{^9TNcEk#qN_K!o)vy0+$Y>EPfz^3@Ir=8zgfOq z>7q5O*k*h}tFjVG&;`_BkTq1-(+tw=3Ke2MYQ7ENr`$ob(}uuns?9BM&diSr%_7(5 zNSWo75eq%V4eHtEZ*33JhPLgNH4wOkLJZ+yz z8+?i@>&UI1DtJG~V3F)=@dC<&nTjmbHIN@um1=&E?g7&Ka_8mF3wT9C{kG$=Ugon8 zD0JWLJaD)7%8f^k36WT+xuG?0Kb+VH?RZBV<;FEi$S^ICwK6@iUbqnwX$^kw2&VRb zfEInH+Rc%O8R>_yXssSAs?{$`&w=$daYhjgY|&HQRcd}l@b83c_NvhDZ=Y+8ck4}^ zY6&O5Hy$hTu?mj!lf7ktXx%HIlD$}7fws>)XIP2e{TT9-V^C(&RK=sr)+oMQy;b|y znirkfP+GAR9E=`6K28$)gyiE*8Ld@+L|t(0Wu%09#U|AxaWd)kCHJOIP5Ka4knV!g zY!`TQSLwH+rgocWaGL8LE)7Rb^(3y=4oJ;tVl=|b$kW&3HPi8q=JtU4`l*#foPFbP=?FWk2{TJME7_s(p?!yy&w#SlEtnHh&EDHmYr- z{5$*=`5Oa$B<*wTbI`^PzV=-*B}yJ6M_&#ErnT}!RnU5Yt5YYZ+NzmB4-7I$G{K`x`1Tm(nL5!+-@ znQ|3mX+MSz(@W4r-amUJ>We<(TwAZuj3XAhPJ%vV{0r=qiK+*+=9)NvuGTrA3^yGm zS!PDb;}%hFQdO~^aZCG9PJhL?XTzLfLOuT^i8rD-gs!pMYlxiJgOoZFNswe|Xs$*Q zdE!cLikI=;%c|>PPv96y0!xvC7_QxAuSViG@~7NZ-a8_LDcTrcT~XDec!o2twt?3e z%No9f#H^y8rdh z%72s1igXuk&8TdI7NJY`0NO=J{lc$l<4jQ>&nj9x=6RgU?=ubHY}RS(P_C;WnchJs zp5x2p*v#<4MA%mvuA^SEM@ZtRts|xDncgcBNvB|Pozm*XVP&V77QHlmh_%83)bN#`TZK~a~LmgFnyLY%#>yAQf$IA;fjV! zmd*HX06Jl4!z@KF{T3RE|A_bY&(J_eEk0tKXPak!AQ<<(I!|ksRlra|E^;42#2!>0 zFqSALQhq04VaOwm#e_CY6>?g0MwGoxcE%mCLW%Qo0Y}z`j)!qXhG0LAasx_~L8cn& zY*C+PD9*%xqfQ%)c>}WZif6&8c)TpmvsgUBeQ6JXL-UB~XyJ^?M)mM(=IRY_sC<`k zE>Y;BX>|`nr)(3RDU@?LNi$RQ>NnP%G{)knzn328R;nf;#rzO_#oLPin0w9`i|5As zHEEb;2@OES{f`y=UnReezdJU%(xTa-_Z5#ISpgXW#lqe~~qMmVXT2fh^Yp zOt+LZS<36i%e83azuL-M7iEmg;ti)2i&54&R&Qs|H{C}c@vb6!@=wy^Hu{`XP@haP zwaKr4>z4`5mKkL#%}=4;{OFP&!K-No*@vo~Zkf(CB(JSGr`>{o+P=5!rgOV{xqQC%ubOExG4pK7F*t0j z7LOyXcFBCsg*ESZzCrrFxNN7jC~y11n5BCbwUyk=Em&#=hiQOwCxRuWfFp}iQ~iy# z$UetdqLGy@E#GC?EK~^hS8uS#p%r|pOssoYc_1%xMU*`f<-b?$P#&=S1RTlZycpwu z_rPr;#D#BiE#!E~-E4S}Pz7MWupa!JAvz4Va9QX)O&nj?$Mldg&L`twM9bUKmwE!# zO(^0mGfJO#-$mK1TC<{;v~lt;K@T|Hf6-Hy0$;&AIJNe&ek1!Gg6-rAwwoHzN=jwq zp|NsO%BKm|H&IHV^_Di~*m!W1*Rf20UddTYM0w{adyWyBiO(DXSAYZi;WM;5=b-Ko z`m8Cp(V0_5*BVK>eSF>%urDLZ)~ome|9Uk~xqesUHw`GBBuk@ssUkk(26$KhhcHJd zrEfbeb6i&h#>Q#bV6J@V;5)dMeUpX(&XW1CA^Y4(`W|4c0dEa+`GU5d4 z!()#7-|bm6t$deoKSzE!pPIP7^&~8;>{K40syQCBW32ITH3l5ScXand_BQaZoKSaC z)lG;;;2%#hy8AuGe7*4r<6Mu?4pgh8nuPq0QM&XKpv9U&9W7Bhb)!yx&ORM2oqhQH zQqPjD@CC}m-paKlHyO*xZ>m*)b>lS~parFTJo`UXc%`*uW4R7jcCJicDcC+9!>>vM zS;exDOl6b;xdljp!zORmj--BFENY6~8H69=1&1Bb9*{vC*B~`pGdxDPfzP)Cubf%i zCidg|x8PcOi}2j?rNaFieXAB!^~lbM{bE1Lza6qO@OJ7>*%|efg)w-4q*wC`eGWd& zezHudb~9g}bVeDTIaQdV40k=7ITbRiOJq9oWk9=euI`%q(Q$bvx5o9>J1>~UexW*v zs&Yz8!zG!q_VT)Bt_$#28UlK!gs~*?`Xr_zLf+qv+jxr>N3tl6wvzuDv%(kS|FKyv zp*rfSfbYjK&K7eOH?XgN=IUb07j>Y|L#iCe^9iCd70-(R&LE!JaS_raTRiTQlI%C-=Zm~mkz4AWjuIe_<6etx5Jq3XZ2SSzsr+T(BT$oZ_0`|4kb@~vYc;FqiBGr8^Ur;8(#r!C_iSCrp z@i@~JsU77aog=#@4w7qbN!E6mX#Um?X|a}Y*Q??c%M9e3ca^DxyJ*9^*&{_&6{k|C zS~J88ZmK_j5|AQ>X*@WimMV`w#baEYvl;L>SLY$e{RM5vyHeOQ8;r?D|1(3pM&qkX z#`BAy_{E}kh34g2VliVn-62oQet4YJ4gORbvf>(wejtt57!H8ny1ycn zJ7J3RxAfz+PQbd*VAE=U)kU1zOY@C~+!^4mDGfvUSK?86+Lf3!?F$Hn*r95a%hN>$7|xUb?)MvvKv z((?}YC6X5J!`V#>jH5q9&%4!YPYnE*kTAyiOj$B)z;V`cEmFg}PYESxN5lJ<~>&Y8~Jhn?F@Ek^P(PG{-1^c{sPKwi2H=R?l0iu0@HhpZu5J0rg4(7j1qBRU85^Q;y^N9PhYrud5IlRLHAxD}MkVG*W~B@7JwVk+ZKV`%OP`9Xa}{UU-qL1& zQbwbkBT-Ow$miq@vuIumzDHGIsIU3lV(vWT@`3tvVOs?ptk}=P6vtRAWc^ z4>90kKUP{Gv(^QfVrL)*cPk1feNKZW;VypWlreWhUJl}-@xXP+sLyo;kkiv3rQ}}M zP=F#k7#+Y5@vh(E-HdqW#(Lq)1JwY3UMWhN9?1&GL1XwE zyUmyeqo}^B{cF&*9D(>T&kR0)dra_{k$*W*({bx)$!d~jGW42w$C|E^n}st`#-kH(13b~Kl#DjuVK*EOMWv;g7Sd*f$yNzP;FSMdXf0U=-Mz! zRVCD!i*lt6Jlb-}uSH0)Ob5h&Lr1)V_tUq8^Gb81G1YREmET(;>082o5yIa#!zUmi zO&J1b^}zr%n!iP@EtO-jhYAwpU=^mCdNFVO0Qlx4Sw!DNf;`_Y;mKmrZ|Pa9^&q%gYXgTF3v=rdKo^` zCg}gID6Z`Pgy?P~l`z47S?v`epBd2!?>4sJ0n%sFo)j*W+^e2#?1LQrMs+7hcv6JK z*Z@ta6V0#QfS)=-MzW!x7&SDX?2POT=ip!DNZv>vl$d}QQ5si?i;9pE^iG-`>DUz3 zPlGg6{yTtAA04p0Mx>~Q=h(>}BJ#!Vkhrnp8T=fq#j*t@{6=tpC4OGxm#6C+wYyO3 z7&+pWm&?KHRnpVsP%$dEg0O-E-4q?gX{_Z2d5v|Xzcqe`9X!m47H9!bu9xcE+RNHH zYX;>xCe*^PwM+5%vb&*=Vr6IxM3;%={~+Wq&9tJ=SnoMp`T!oCO0fd%xdg%_Im$HT zb((b(q#PNvI`&h4E+SeyO~Uq|JftxhtKVUf5_R~DKLmeO51!4CIu+%nQ*QI*D#LZz zIycmpSD^0uW-a9tHc?j1vWb=(Y+VltU9e}_L?HB8pG?PDcHaC9l)%46>x8g8Q{k*) z4fHead`D5OdN$)DkteC4Fj48k>s=V9ZBP}Ei~Ew|-3eWPgfC&7t9+Gbgb{h%-MU!g zbH?YONxxARp@Q#{d&QMmUiEDCY_eG83m{W9Ni$88BRgX_fgCDNs>*b9Dj%}UQ2xLk zDT^?@RPupm6VBLf&#cV@_DIE=GO_eu3g&^SwoQIroKtr)zlZ%}Cp6RCHy6erl@1u^ zYNn|kq`0DgX4=9SoQ==Ox9aZJOvAbDTWW=VeCE$-AEP#YqBWxp(n47-o*Q+xj=5u{*g^1#-{9O4s(v(-a9(>fM;4=hYo`lgU^RcMRawIGA}!&_Lr!ov z6)C%negA4g*BYA-g`c!rgXVD2v~(*+MSP6P zKzVi@T-!Q+7QE?4Ql}Ead(e|OWM_~|^l>lbCdLx>1|l%j3AKX}qz3rhgnV;>{j*Y) z!9LC}mGpMXJK+A6_{?9zA_%G$;E@W>OOtAUGNnqtSVo8@4ZvA+4=2L(KO^9?Tp?(4Bo|mqHXzX=ZoNH&jlgE zsMt$S((R z>MLC$JCU$9^}lr4o=R1>aW3VV5pSY@t~25sou0;usI016Yo>ZV%Cbb-_?*1wgavEa zY@aS`DPF3ZTM$vWVEK=<39e++X$G~s@G6fGzNzb3LW;-V3|Dopy=7>qtc)QG=-pkNkc z3R7MqKiM!LmFribW-v(6ox%ldba6zfB`?w)p}PjdCQZ?!wvLqb%n7%zy$n5^#U4#^SU9OQ%je4z3@((} z?ZP#v!0&gmJ$Sn{m=@4{gQLWM{|G*M?dk!rh7!1(~ZI>uS!UPm5C7{iY8;=&o`2gEMn zX{6R*Z^}PZbv3FfIp9_`cUs8%JH@EPu@(vW-qEgc1?+AIxJJ3n7t9NPozO3zZ@G^( zJ;E_1pHph(7b}!wef|)PV}9pKGR{UKPhH^x+hoGKGu1ktk^JGP|5E=YGwb4mqkRd7 z^S;mBt@a@AP~dkhluf{zxu0YHQomw%zewR2-0dO`D*i48pN;B)&Vys&X0Ey% zc_Qg~f}TOW%Q8cJ&HWYf3)D2_t832T-o5yH3CHgpka~_e74aYv>J)yLjGud8u#_Tr z^zAL`9LWt1p%~>)tQ#2D>QsK4u0+{0_Iv!@{vn|1@ZnC7gi~T9;yF+4z590KG;U z(F*<)>Otdc2^Cs%(gVWx)Uz$q34L7`EA&%zL6`mO3wDjW8(g>o-b4Cp7Me?F?XJb~ z=(0TvXN_~!dhK<8x0oNL)`QnXID%d3nPeLh1*3iyZJ8c6D{N-izeAsD-mUSh-hi56 z6XU4`kFq0>`R}KUOZc>K!O9`hM!=`MPZ3Y(?Iw->XX7>RF`xgjyw|tE;VjpEW7}0s z*kz*oFYqy}#MMQ}E%hODajTvoCS-)kGqX_gq9AwB@Li05P%4gUNj=-vJ{XA#mT|N% zCd3m_KI*BWwYUK)*8LvL$`1lkengs&k4Oe*>}&S>1y}t0q0~4x$j%(U!f9(-G>y8t+F!`K#1W%-TL*U$Ye;=jdEhp8b}6tO zhvRFV{C^>T{;5izhjZXH)}Y2lx>9|}3Q-x~P=*_}ndem<&D?`?(Fhf3&$}bE2}o%d zS=wv}eO}9NEs@G_`%L>Bp_#i*b+887jw_Hdf(TQ#9-PiF*pdGNsO+Dc=YbzT`4dwE z{b`PKjYA(^X^8L{bAJFn##yT`s$=<{0>KrS4vsp1C5^LT1ApnwxBXt)H!_lCgs>06 zz69x0VPI9KN@F26AtyjKfEmk6UUGU97i6A|H==V=HU;d+=VYj!$0CsZwbF z=6I%mq+GudR&9FCa2Fvx6@J9I5ld<=v!{lz{9+xa8OdrUo_jA@mdXRj5nJ_pQR?}Z z%|hEK-;#i59fGcs@?{fi&M6Nh$JU%fj{YS$5}r{}y|5#7s_X>#kVjP$G7r_;NnQu= z>p>Q=q_yf}h()g4;Cfd6tCEk^ua$i4de-%Stk^G1

%fMM&RV_oSk~u#RGs@vA49$Doc5CL^|mqpf{N&fcR=D+HQQ&z zPnNv4onlLNP`#?f!i#FPQGfnQK@hPvWk|O;jZb3qfMbJ3Ao!0n7U!yGb0n^lwcldq z!0_)N4Qf28y<(4cC4gV27kRkCXf}uTu?>5XXJ$Qr^(lXb9gE70YPOujF2E+$ z$|Ip_6@J$ku2T>0NDocn9w22>JvuIrPe3mQXDGP9GJEi_Wkk)#CkbwX+Trlgu_$-Fh4Dp8cz+y?S zPOlbE(h;7i2W7U_38o+*7%S8s2Jh^4nKAv|aa1&F2beEfi&^^IKn6<;D&_E=dK`a} zg~%fs*N?nY^?<#E1JOZ=@VBBuDBn>l)k`j7BCqN<*|KTj*%OiKF-A*nb3p1uMu7jB zkCPOCWVsPwS>6Er7%Gp3a@g6z)iB6xg+9c#{4C3N_@9*n-9^Qg;uD%RJK$Jhexz8* z_%}<8`4RWT(JP8fg$IUfd@1IPe_rydlD!E%vv0BnWPaP}{hf0>>|7n|yR;v3r`Swa zJ?C&>Hn}Ep`%n1pVomhC)JpB3t60ZCi@L*q9d#=&TbyNweK)-mc-Ifho4NRV%0^VX z&YQw={2S#P)*_{HxN+X{UHH>-NRWquJcq_Rd%)GKPSyy%7SAjg03xzy2xCfc>0_4l zbDJewwrOs&NZllEqd$HT^%c$Jv1(13*i{V{A1LDl|AmXtS7La7rDaML`Ytk%A1+QTK5I2OPntJ z;9y>?VXf;LZMJ364mvE}q$aKM!y)2Ty1Jd`$YCmSzf{#c#zblzs0h;{x`lxwe>?S8 z!k%&Q-mwhaYvRpH){c?fTjmj!$%a3FE0NsAJ5`wsF$s+3QA?r_cgC%~Hr%fx>zJig zb`NPGD%+P?tEU+9?(??=6{f~w=JT1Q-gdFY_h(`8EV^aYvYwNlr7Ixs>Q6PP(}Y^4 zIqeiB(JM&fPvEy>i?@hBQ@O;k^eoK{ri{3ad8a9W=kUXYyWuXUUY{_dB9mkSWwb{KBJipPEvNko9 z^@nxS=3BAc%tYM@b)b0E=uK+%F1nK|0>qiT{#+Q7`{7J<(flT+^1w@Q6X!gcRRc6Gb1bV*)+;$Cjc*79qfbF3X?x=_2k3))O!R>p&LX6a+rv8vCIs^L{- ziTW}3$)SWE_fsBNx7?RvrEWuiLZdHyf58;VNb#E=DSJsDmObEUN4+?UGb1~(%)5}f ze2Tu4e>vzav)bZbh}|DLgfjyuO5T^Djlrw9;q2@{&h(u2_{kW5I~lR&gw8wbb~xsx zA}>ez=Jrqc>=g-8i4DjmOU%4f#SENHR*t=(>?L?^?FF#jQH_!<00`wT>obab+PVk8=SsaxUb8q?ACEcaQ+Vc{jY~x}&A98-=W&`Ij@7Fe0v@Mo zYJ@MA`YTFTA76ZbZ}~N4+UoYy4Byw4cF))FvwF_4W*E&gy0`pVPDUAYh*RWW{0ElK zrBcZzsGI7E;1Q$;nKXXrq0nsLZkzcdKT{a_k0N1VEmTeL?e?ME+HIh-c8P!}RGq+y#8QW(7-!D0AsFQI~u-x0}{nhQ@Bf?%~pTRwi z&-y)K#wY2#rG)&6O};SRU&E+no&9IJ5+-~^Jx`}{a^}E7d;j0dhZM-|QeUw~5&>3K@h%3lT#!LJg|I1Gm2c)RrW-2qA^sV#Q?SMf z4v|3alAP)Dip&qq&P{rVF1wP19fbD;{gWcA8wB5uxX)+_-=mk%Djpesk~XLNbC(F( zyoTD?k|`1i+9H)J3`rA%sDJ+FG^l$pX<~kj`MdZu-49rEK^?0)3RGm% z;F#A$7uhKh+JFKk4L^8)p5X^9-^=an0|T>2#ZP!mD6XmbncOP9WSSKUyB(ropU@tu z5rJH@lk^#VW-oAL7vJ>#IB#ZJlwIMSb8W?1zDKs^9J}dC{`R?(`T4hk_!h6Nxe`sP3W_x0hDhGTloc@SAqvF~Qt4$)a?Yw9If&ZJVvF`Bs&(p_A6Ip`a5Cr>n zUbiQO+r1wZBIz7|eXeZenT?orJ@vBQ-z4*@RV-Pru*Wq>7VlAhc7aE&U6>2iIwN}} zi%5+I!@GK1dibQif%k(W%BS4sE-kVxc`!VqfW}Z`xVvc;&!)F{{;c2@UDB0iOp}T& z4HDai|Mx5+&}OQr7MrX_i~4SnPrFrni~<_d!d6o2Wem!HxBSL=u9$_B93K_$q(M`o zR7*kK5Zq(E@6TY=WJ&fR_rn&xr>p#pLAm307b?!6!rmp}{Op&Ex`0-_VyAF}B4hpp z&&v*((MPC`=UBgUBJlG-nJAC1JjPmQFy&Ql&q3C$+X)rSlf)X~Q7!wDPM3WtS-t^q zTDhjkXUL9!@`JN`NiL;W7pnHBj03*craX>5;C7zTe(9GvsrEseyw@P#RedsBsI1V* zXAK(vgKgaP#-A*B6MSPOr3Lp??JBs(mSb27FLT*0Jj#^}F+brsv5($E95^dyeROe( zc;wW~25_r(>w02-Vvmw5zE4Hzxkkqw7=KwJB=r1$>NraRKki2~hArmTtkbRAQ~qe% zSM;svVOKccUm$leOY=tE192}XPbk3N)I-Oq^j3Ov+F2{vMQPl>YgG**$Hr$lXpBzi z@hRLtHD>S;`N5=;xT&H*(CWd;->@C2$V#enKjog7zcS;WeaEGz{6G=ADQ*sbo>^>R ziCdF@yCm^U%nw-$7>7NS=YL&Qv*kP1gpTvxVbE2KQ52QClJzpy!_QUP%dbHbO_>BO z(lv1zs=n;ux#I_-O7b3+)t@2)N$1P2>884yL-x4p(_;M#l`+6<_Br2uBcfY$zW7Ak z3y3e`Z+3S{zRJ^&TE+4=@=^OUr@0A#Zd!eR-1437X~S}U&HAKI;WMB1h3S5szq0cB zI_$_^>)w25rnaibyK@}2KbDSt$MEY&*d4C(qX+dA@p zru>{&@IjFzY96>3Y#ruD+~J6G@_gIPf2WJhtQF1Udp9^%u%>7pvh+faB}2BCSu&gg zT7Andww)sB3o066qlR#x$>b5MH1tZf)Kp$+)qZ=MlEn|smgC$VqrP`5&-Z9+f0!$I zh%;MWN6p>A=h261W`JWlYhZ-U8X=Z{RhPyxdP#a@pUCl4Iw?9 zFH}D=yvk*&-7NdJil#McDAQqHD0sC>NX5;UYFzYSIa)=tXbG*&J({;dGW$?}Wwzbj ztXAwmEF3x#xIl#!Foi_WT=JH(QTKp# zJFmvgx(AhwxFRrya%56U#fh@M5pklR_$i{P)%n_g?7%Q917uv@ z6mYnuSk>1dj~pV+>x{5$z%V7A@hOOW6zo}bkP>rNDc4O8^LV7d0y15KKO0d>(}=f1NS05TY6dDi%&@03oKm$b zS({@Y$MrAp`=WebJI7Pd<)CFQ2S1jD(9H6v#*UHMTPm^QP(E=3w*(lEBlKS0%>2*z z`C9u7V~1@ja1QRn<=3nWbsiWJf$A#P~$G?*`dk?lz61wZ5-;y-cg@&VDdulKByR z81XIu+^+YP+1-_Yc3y2Ae1=Wr=h+_t)@e(TM zLL84P_r-j*QVUobrc$G8ow~LWYv*%%`B|c{Eg5^t$@nPE{RbP1J>3+rULPz$BcEmlPt0`8>uZb*vcAo_D!Zh#1G&P!KU1%F? zene)KKlg@zRDm1t-Nm-pAzi8O>$1c7D`^(5lzMI@WW&KM7dS>CJ25i^Zw)RTw!L}( z_`>p@HEMn;ubFH&@wpc3$MfD{!l!&+4T7*;CJ~TQ%xAHRi{?+7UrL!ghk*3lVfwyL zS=}xko}gZnyE!XWJPpUeyfJ@P*~jEvQ)GRJ z`gBuKDVQIR!g{zW`3cp6XU>!=QkNl9 zmhZ}cGv(&$4)QAS({`|^`VL6WZ?8{rPeW9KRG!yu!uE4WvYh(e4nz(HNAm<(AIcmD1|4^^@&v7lU!<53F#&$VFq3WwheIpa zYt|G%gOr(mNcDn+sKMKmjw zA3AbKS1J<3RKy*aOANB&-4v?9^Y>6qkR>`k@ZZ7jm#}p-f!`YAEntbQQ8SXF8ckaERu$^u*|}^%=T_kHhg+Kx4|*Ua&>)l zp&Gv|0+TD`Ew6|V(4y>t#4`SkL690=mLdBkw+Z?AI|O?T`Ll(J5M4ti9^!0}Js}H6 zH#NnoY+QFAyosvzqCAl~J3SFGM=Dpdr=ZKIRt%nbPPi7Pzo45M8(EQU+lfejBBT*8 zq^NJpN26o9#ToM=TB)v>N;^xG7Kx~T;_`8i!z)tjK5R&r9Oe$%4ffY1xf)jHp{0+3 z(aHFv@^5@+Uc_>%nz7^X)u$+!)pf!Jh&+vWL6z3eUu=Cyd4<1G3O;)}ulqH!8D1-|f+8E5Fp*vRxmR0gOVjC(=luN|^FhB0oTzfjijdlaaA zUhuS7(Y2#KgJqP&lD(8-*-lGRWtvD;KLv`L9X*n@twx1V&8}7Xb4p!*++IYX5#w=x zN9~>nWY&URo?FxocINo|9aY-=j~ZG%s?~)Erx}sV^e4!xKBE+Q-Yffe13ZVW!J+&o z)nh-H0|;C-uermuPy zdjd2Q{H&XCW3W81%i!CR6=kX;D(E9yRKN)EECxEPZz& zhlLLC^)h5cN(=S?n^*R+^@jcuEE(%U-|=O8*;4<-$~wz;mJ;PF-7gY1nUAOZ(e}9O z{xr6J3g5TShQ&xtGeDE{S0p1IeSeNY+Oh+qS_9?o5gDKXWcDdgg!M=}{ zdT8Bp^2ha8RNJ5SPRRd==jgvkg}>mMh}k!#%0M9hBjeeO={nxwEHNAS*~%m42{f9I zGy*Xp)^+N+2Mxk?smfE_BVvDhWzMig&pp*UyPH=m5D!5?A=Dv?&hIz+mU63irsuNO z3xr8f_m#bZf3*{Tdaq>m_w)XrIIofWtWMt`xu17tRATAQt1eP>!3Os<;N}Hu8jx6P zy!LpjbiaeQBk$q4w^w50^LmKeeivBCI}Y7rrlkzG(3k0(0M%cwsGgIcr&SSnJBKYEFM5H&?2a`!UM}CtO!j>1n4kK)Dhs zq!o?Q;kQw6NR|}EUl93(dA5bFjEK1p`$*!&y9vhXWRb{ad@SR`>wby?;-CN?AX~44qK)^ivwO>_)jOf!reg)=>o*mDr=+~PKH57W=N0{?lvi_JDY)s1 zq4$^k(Obrnuc2~Y&MS!vSGOnhST?{e(BkURWHv2gIdX|qbYT;nUe+i6so}bGYBofg zmi3S(_YU^O2za04zDf1yN?i{3L~dcCh8p6Lc2A2rVK0c++t%sB3T}cqwlJ$?ugWP) zufNTI`nRrB_kefm!WUI+XT@6YIM;99n(h`XZ~7DX1)p)5>qq1TUjW-CSE+?{q8c;t z6~3T|oauQcx+lHE*s-!)|6kNytW>Ps@Tl`my2L%U1sV@{X?3Mw7iBJWRnK1_I|1{6hd7d9je56loK2$jFmIy$LL>%|0Ul!I5 zL<&w(Z`m8b0E>4Yz4k3ztb;5+wn}b(r&KREBltr^F#_CgdrghTd(%5iji$z5Zsp#8 zM_ssW{OvYbJ4eL2s^@cGkhTSc!vod4JH$# zUNw1}TrsYEDqItkR#e+w77yXaq;i_zUbg6?X>j#YzJD*bW~Wq2zs9@IUdcZ=$+P_{ z!2=?S1HZ@Tf@HkPZTyH^_NAaC@taeB^6Oo!-TC=9m$lys4#v;&ezYYc8AoqJ_j_KWZZqh-};izyic$IO+d20b9MAJm}9wL@H?QgWRjxJl_%1J56UL{u$I_WtctH5+kbR_G3H`@YPCq z)(z%oCUmk!55}i2HPmAp|Kf_&dV;jsEVx)8=umxXha+Ba;9rWC-70;c*0!pVJl+9` z=Aib|0qGg=N4`PZ)-BF@od%uPm2T;ge|Eaa8c>^{&0B>lO+{U|XmRy`ta7zl?tu6Q zck#R(%-?SO3GGaLh{qvGdbm#bPVuaprFSNeAf((pK?4TlmjUtK)yVnajom~&)?e@r z49y-fOz2lxx-l%X<7G~xw*2oAQCkhfXKVQa{^mZ(D;ktO9u#RCMaOtll3335p5>W$ zRS=G-jn^(*&P|R5(kEa(18SpP<-2f&%bM9K70s)uTfVbZ^vb3&al(IACr5QgHZ^5` zUs}Hx%wFPq2fxuK3L56HWqz2ie|}D8F!GJMg~uo;*bc8SmA8uKca1vUd`zmXfzPXT zy^RLPM6!nLXN@E!`!dBS*Q%O*VctE^VD+7bIp7NLJ(YvHHoe7-{QE&!#e;$kxgvBN`kMrM9D9ko9_1~F`v6}wgAE2)u3$j05gN)UBLb+~>W%c~YAf6Ir9Qakxl z?Em6#91;HI7MjmC=OBOMqWo5k>{e?yXO%ImPa@wnqKnta8pV3qF7mY(nO|Zl?ZbYo zA1@hUYstLwGS7fT((d4x=a4hbS3?B5e#~rm8GOe@LIx#XyidmPv_x)_k|yTOwEb^h zZ>f~Y`+RLGa*V%ZIZ5-Z|CzOhWmwZD;=lZ=^b=Hq@*0IPQ1IQ zbmg%%LAA1AA%)$Z1^8!#Ul z?FH7c;6j77OMQt?e$hHNHddLM*HY9W^CfiusSdC}w5H*y2X`cahV{VtKK?N<}v6kE>d<&&R zs0e;0sECpAL|DM_;5R9@#66dm7*l0PPtA}z+g(zrFu=3Cf0IYKOXjm$|5<8iKou5X`%h1nRJPT3)#^~iHXaM7b&>pFQ~@C-x-c5rh&soxUT%h z6>QO(fjk*)(G}kWo{R?B8ddRrr9%kLQT9%1M&(lb3|)c&ma>KI3Fw)_)_$^ZTdQ`G z@ZbQ6=G_Hkf3RT=Y|r9ZVja{AezQUSoeA7pk;~>Uo6nZoW%pq-&q-bqCW4 z2v%^U6pPA2f)hG#Cbh;re<$*!Ms}M6A{o?Nkb2tA^T?8x zNdCOpRGXHF2n@}|uFCJf&#k%@>-0aHuWTbJkI$VfasB{H@k10~iC!a>9+BBN!1F1P z(8;?mi(JNT^dmLC&r#7?OIJ|H{DDc*Gs z3Bw-F_$BW#gV-OW!fmZ)F||lN%1nKj`MYKJ0NrBwE6cDyNDm(rwt`Knq+Gv^_eRv9 z1zTRg>PrC2A$A+Jis}L|Zi~mgPvl)dI2KhTf7WU44a^sCCJxGdLX&O~*7IsXe1e(o zF#lq&B_=j9-5*mWtf^b*T*}?v3E2PQC)42E?Xm~*xXgE2Y9yw9o;9V5{LUw7iFuKl zzedfI+A29sdqrC~AT>n&TK$@C$!82wit#>{)n951BG)uNtrOZ<9~2$&l;~4n5dkaV ze?=Le2FbOokAGaMYit$?|80H^I1H=8x&PneJE^4;q4)s}ROZ451$~O;aBv-}UlnQI zuRF}ZW$2AHRFpHFl7tUGKwn(AmpZ^6Cp!fsLOlG=*#mS0`4y;&h%8oWQ1L~`fg#|F ziqx8DYW1Fxl{4KmGNJ+IAoWuf^}5c;fA3GQF7$<^w;A2AP{DIAIX7y}b@*fE31bBi zO7(OxC&N*P_$9sp)?0Toe7sb>;cTjhzuRH|U(_J=>$eHtNSUzqZZ6EK3ipo7S1W0$ zRf7T=+fu8r9n`b*NJ@s@*f776Y9$Xg%oweDXovmLB9CVw6Bz#5d35@N46B%BR2=tD9>6E^e>qobveU;}+-oZL8pA*ebmb z3xTaMMw6sXuQM_5$4l3a`?#--%AkdsybUyeSql&kMvxTV?&!a<5$xt75a| zuk({xJ3hweIBc7$Y4E&Oov$Ioe=~EOXf5C~s%Aacf1BV)8DedejI|Or8_Ir%d0+PQbHx-|FM8f6rH5^hEHw zZt_H6C$%`;Pf2tH5@KM5PztZ%5U5Py^_eO4*Ug6*LP#}NhlGl7u zmcLdmjr)xjQ@ItNqZj{LKxD@UJ{+<0|(Y8TJkoHk(71ye;k{2hQuT05g0w&`L|oCRhOVev2KlEaVvbsz2i}xWaTJK z@Y+j>@A2J+A~$BK|8X8@P(FL(uMQi=&;iSOs!P7_4pA?ugo+qNrJctVHQ>AB=2#b2 z6qH}fnI1Pb0lAmeZ(1cDUL$^vKu)HEfSEbe52pOx|Dq zug>xGrfratB`awpIw?w<0m<6+M$hCS^p;_!HX@__Z+cSs0kw>-%HOd3xGEASAQt`S zRFwJyusbF;dEdQre{Eyk)UubvU)sRd;AWufg%7}AY0u4-jE+|7@_k(y5w|xEdk{-R zc*{xr`BFEvg#TLgR(LIPbEzL3r1lwx<;5r51RMzO9`EstGl@^)E8ma#3@__gJm6QCG2+e^cQH_;FQFY0;?o?%$6N4`*3L=x*=`-k@q> zMhvP|lVu&8e}kRR7F8V>8HPFZCBN>}hO<_i=LAdf2gObU`t&ML1gQ5(N&M~^$m86# zg6UA_Q`xAQ#qC`mZ78R{%mOL}j)^rSbzkw1($Yuj>!YQx8qpZ>U7kB#>x|-Mu9d8t zAdgSKwvz=>r@`F}+-uJCbw-M=C}j;g%m$tTR39(Of1bgz3|<`A#o!xdOV<1ysWnT6 zq~_db#jb5*9Whoz?yLNHkrd+642=S^8~5o-Oy8#?Da$Bef12-bZ~Xnxh56a%x)RUb z^o7!`djNTVbj16d`J(j~dcEs@cQZ0@sowsy`fZl5@@@OmSvl0U^f6Dw(#LdXu?A6L zRPOD_f0!TZZp2TPGj!4+{;M&4U*BojKet)`PT65y1@971^Jwu|xIG>8v2Ih!GJU7+ zhQ*J}J$x5g=K4+?tcx_Pe1P}YwW8N8Vol|gXjt<^Mwn?h4|JrAy7Mt=-&r;w{@qaa zr(WYVSVl9)ygquJ%|6HLAXF<`A9IZFHciXDf9_4_Oz6!1K6Wd=Np&S-J!MCJx-CYqjxqh)ORMt7f7cPp|aEDk?M}@^6k&}yJJ7BMv zYm8?7WUFYtU|4Gs3xcJgsmyUg@b2%S0y#^sGpw_))$z;d*t>cDg9pB&@O^G$tN1#$ zf6~6px5S^oTB>~^+l>E7zo(Q{AC3WgRjfo%tA#NW-|gYm*{Eq$VZoHte+%2)HL(@ixlhiES9}XwBOmj*Yhjb~vtGd? z>=qXBE{zxb1My8Ef_OrFHQ;RjQZS9*a{CVRIlv5ukiQSl0i1H96Wz{R$Zj|tZ&ZNcb2IZQIPbky$qVl zph<9hP6#gxDpz!v78RXJn&_Sw@3F1ZTjM9su12n$SYEKY{_uBrG(-D!Xm5xb(j0~l zGo@0*2vl$giLCG%OO%{~lc-*$e^vi#$% zdW=W4)+To&nj zLs}g*>S|{C)d;OHO7zQ-dSd<1TpP|)<9kSdqOw~XDgI>jG52TcNUVB?f2Hs-*G$U> zaDMb%;hQ|y6*5`6Zoe~o9(5|8CGKFetA z_CeO*yuz>n#?6z06CBiaQ)A5i+KgYWvY)sn^1geDb{D*bEOe6kcyz4NYn_4G<{3}$ zDmsaMJozqu9(fBI$HSpFOpa00nY#MdtM z&iZ`xF z_PMr&@3ZCti{@ith-VuKSy@2eyI&d;L(!SMlKGz13P$_*d;!|Uwp5cKi!_4#C&;4`#p4WL5t3Cd#L|JaFW8&VjI_@?{ ziOz31tE=l73swt1D`$)7NdR{cxcu7lW?qZnf0?))n4x(l!r~>@32geI=WYV0(Sin4 zj)Cb9F$3T@mwu=8-^q&(*4R+#ed#;EB;@=M73=7R!5S~r5%(|_HV*tNz2Ok^CEN?J zo04l70X6+`JZd>c^m~}mw>HcC7R!R3@=*y)!EZk}&yZ z*Uh=lseC}}t$kzjjtAB2ZAc2cZbc=AL{u7PC1%9;t$7+;dKrHLx>F9me!}@v+-ubx zYc{7Rh~xDWxes6*X&YQuu8qz0C15qze+(3^-;%ea1z6Zs6M8Nx*zdL-CuPmk>)o!K zH_guYSAJz9I6zxOBWLc3)j?;NFb?0pmumhdZcNzAYgpxqaDyd&}QwFN8yNXJ-e;l1Z zs^<-IF;w~iqJ%oO9+f(+&WkyJeC65Szqc|!Uu5ZuZ)3+NJQTM=^-t6^{bai2Z540q z%amGCSFJJrEp3+Nn7OfvFWTy|Su)GfvNB)d+4Y0FQ+0goFAGbZ3mP`>(zX%@oOQDpoL@v!mSOGAt* zcSwOVPUq62l6-Xu`e-%1a#=0d5tXkGlzv@8i)T&sMbp$cZfY5OI;5Z#XZq-;-aZ*ltP-M45k< zH&bQ)V(yl$SM7uAqckSMF^@5h;v2dzGnW|*HhP8T zy|c+#`a#~0$oScw{Zq2w3kSl&Au$4rL@e_J;eRi-vt{;5r~ z4L_es-_r@-%>A1+k0alrD;>(i*uvnQeg1RI{lih@mkgQ**`2u!yM#!B2)SQT71s7@5Bf73 zc1F&~y^b$9?nwTzf6gKGVC;|B4IbIGA!*w5F}>zNWU11g*z#`dZ`FHL&l_vEE%*_*PwamHbfJb4#zU%z>6LnJ%zE>h}@VPLERR_|?Ac;(m@` z^`p;jxMk%?QO4RU2J`jm5%}L*R)f`<7{D&p*mkk6;4vv6e+uU?V}SvB>fo5IlNGvy z+r)6!!orSE-?6QjY=?>Z%3)$~On%tJcPhko6J(stOC1nmUmsLR6|kNi4F5pAg$zR< zEwVM8*(DhE5cV(C0uclW6^YGwb>m>rXEwon3W7Hs{XQ*XBq{>A&l% zzuNMy&hES|?>gU*XPg%wxCL6>aR+j{1q+CinQqmVs7^zL=C9FvRidtwXczErqT0xr z>2Y78Oz4uX(wlS_d{;u5&*?5n&HXO3fo-g+jaXdMe=zeGk!iVrDEXx4ykMF>Fp~F1 z57=~%n)-PvHgQdU8&CC`H+_9pYM36eJS;CSLV|LR(l}hHC;KK&-8`SPThl$3EhsK%o!O!Q=2~I z_<}^zYsIiy1{p({s#9A`4P9_uY@9xboQ9{9e>rngyyM}`$2a~F^{-`VOFcwWRLJEu zkLyT_P>WQ0U;gYZ16%q~C7HeoOiVi-bS+aE8bYMg)$F=b`gOI0H%J@mo$}s!?eoZj zB-f<;ZPT@9{fDlrSeA__h2D0Y0_asmw{{AbpQ zPpr|CTa?-zK$)1l6s3C7+0Tr2j!DFMf4Av8 zOm-5o4MzW1Ve`%76ldRO0ueG&r8md@<2 z)ygLt6h8K%`%8x5)vf;WqWc#-vUa7T*yNe>I+yLePC`tNMkGnm#{Y+y1cNDCOpREt zyB~eYkJz~~_28z)=GuHl*1cBrf1`qTlOLt!HWgP{D8W}Qr!PfMX&F!diK7LTRb}5# z=*?aWh8(pT@GjV=!8lusi2aDux8#16PN$`*a6K!QL-KRgA2o8!@jJ)w$c_Mxn-1NZ zhRqpRr+!+P5n|9i*kO*FV8O0;OMyy^>GOVd@6R7iZ`HZ;J8q{(Yq+0Ge?~rQ@hsiT zxzhN{`^&n^pjTlkq=Sb>Ivh|wosRz57Dm1|kghxM6mqpE}}{U_PH z^i}=DlXew~r>%+Eor#iTJ@{PIMv=SRkBY_8`?4Q##_R52cR?v&?fPf!ujZJur5~^Q z;!FEVos0gBqjM7hQ>aq!f6|&9UD-#gHcXdHpcgd^$Zuuxw!Ude^=Q+><>15T(WB( z`3ZFYAVxH4D*B#LuO|CT;$ttTF4o(a1MG%mu%UjvMuc)T#Cj4p@n&Gt>T=CWeoey8ukjw} zCN;tgN++u@@KlF5f6LvBmbK^{8?<@{tK}ijt4rf}$2~HzV5=OLFfkywlUur$oTi0& zf%fWA@n@Z2wh&#TPOv`{SbD=8cSJhpHtL!3>B&i2UMFMDxL12p?s~Pyfp?7a`6Bvr z4eRK~^@{aeeRLHL#@=INt`YU)z3hS1tD~#nYDIW;!&TZzf7~FR$;)+f(}E4~NxJ2X zgzS#;Gt&oT8FJlt`c?@r`&rB0VQ#L0mz|k97%fp>BJb;rIqj0MyvOuf<&1JrUL<;4 z$@*#J;A%|2FV*FcCL_Ef_|4i_;n9gM)cX6gQU^vSB3y^`-xjG$DdFG4jGe&_9S~DP z3wE#weu%gL zv4$Pj%@f?uy1_l!_oyAvvgw_?$F^;ay*2B^rg!9*e~GV?8Lidk%e-7UH*<>(K;dVX zr<~Chu1-9V{8h<~`&)f)wO+49_noPmiLjSr7rL${jj8{4uROWtMRHu?{QH=n2CvB&IWEo(t z)*v)J3G@of4YJ`juQ0~y>iy^8+0pCy}Vq)Tl!{v zkK;d2oO-`{_USX8lsV{_r?MD3v5H*i6~r)wnZv2zh})?1P?ZtLdnXS_fd>5xsxt=I zjeSt<)zqw9!U`2~$W7Y}vi;nAx_*Q+<^j=eYAZU;*L`F~0j}6M@%&)Qn1$Avl z5K*4{_ml!ndb&^(QN!+NO%f^nAmeM?)nEn*CXE&0Nt>na*{mgPlz)ACw=umx_WnuK z3R)@KMMgWUdn2)N5z3_yIVtyni*n;Xf53NQ_pv709LMx74dDJ`ceX}Ku4+bb2brUX z%sS`%x&9oagb47Na1usi=ZIk;nM6!!^rEKW&F@#Zb1XI3Il0fmrwN&nx={_`t1nkbbEE!=kpRi2dOe;GgLen%S0iq6uQC$T!8muXYJtS7y$=w8NuaavGO5v}s29M4nwF}S5Le=9jB)SpkL-i6IvOHBt9N|Wl4QFgc5OK&E?dJj|a;a2$o zEmX~nFtnbJReQKvm^%6WSRc5LRI2Tgh>iUPXrXxZv)9(Z$C~*GUK#oh9DJid#pHfh zuRcNxvp@R-Ny+wPo9fQplrYfJULYV%mf-ah(ax!8D!8_d7nb(Kf2s*xkEOC|#mnfz zHt&02aABRnuzttf5QVyaM=sRSA542dch4@>El-N!AuHy|Ex3w<3>n`OxhmWnk?D2c zp{#6|5k$)DlX|9p+WLLnJNzm3QJnMTSuZ_Z^!v0Y;@aaMO!RDe=OskYze9^=DyIbr z)gck}8{2iv9V-8Of6?VfB{X_?L^$&=lA*!L6ZuK5iO)QDsx^*@JO31Lk0qVy&_6v= zM1&#oUK<$eor;g8>OK5A9<@~$zq+EBEEjchZtb10iI!)T1lTJnf>^TiGAase#b$)n zBU7H_r*R>D_6TFhr-l){ASMI0koenj$HQQ((J{7cDC8<6e|-iU(`UtQK8?-e(_Z`Z zy1{OHFOQ8s@awhD#|x18VE9)*Ze!Bfym!)HPTPR2N#Xk3TfqH3|Kn?U9QJg2d5T8| z9=-WL_8ZPWB#kX!lX0i&*P$THu=PdRWH=j4{oBDHcpALSMNLwfAr##HZi$p!vhH3_X*lxz#4|u zziQ-~W0ZBOrgDA|5nFaCj_4fq%>Db^`Lw+06Xb4?iI`vL7^-L!k-rEt{#q7uABH{K zqjzf|-XOx7yNLA!D@^r_ejnplhIB?e`rSq^$yDom=)H#=7xlM2`aXCBdb;) zI=A$%e~9KkMU?H7^k{LKj>)JS^Qv?k(;0D#d3G>nA0h^*HUDeym9Ey~dBpUcHls3i zx)plIA#!Ec^0R6SFImV+z*G8qh_+(8{(j8bfxsairO#;Ui2Zu~{VI3Hi1rQfsoZG~ zEd2bE**Xf;@b6l=R>mC(3x0&yvDD4@{xc5&fA_6+v0kBQ9)0C5x#T*pzk@^EUG$H- zfARFe`HRS9&`&;?I{G+xZ#eoadv;@$b>}#rkvTCR>Cfm3jqczc$4=rv4sq4m^e;oK z_zbezxr%F6%SvdSiQHRsPR1ora*P%+aG8dE!>yk?qn|+k=V4au;qJpR*>awr9Fc%) zf0sTxA}1l|J?Qe2f6AVIFX}wif2`LvYxp#Iq3?#5(hfEyL?_vo&3pmj5ZM%;e@ea4 z_KgF~TeJ}q0$sk9eHu;Xtcl)oNX{&tg?u?ZiA(gE`*j4n=qX&{b2riFE2nShrG|!= zA6az&=C86V^OT(xD!4+M%Hc`S1TilA@-8+uD!x&HY#(Y(f20l?Anz&gFy3yN4zWU30 z^_pz-t{c-m;-*iG{;vr!*_%Gr&veEA^=ImqVL=b4Yx$~cBQBKdD}Juo?bq^Ke^FQG z?D{NQytQnir)ISD8NLo&<$C=xS6#g9{$IU>*Y)2K>_^wKSYO^_=*d?4eb+4V)pUTb zV`DS*XbV@tL}Q}X=K>QXOVeML`MO_+RHvfKZ!l&NwQCo@7I3ujVlXDrk~z(qn8JcA zMnAr*d9P3Q4f?F_>9aG7KV9E>e+t;z#rpJ%r+o&@iLu0ofDvi4&crNTDdaL1$KERO zd2)3(nf+sW9mP-W)x6o8;&;?aRBWfIW}l8KBVXo1Fs~KeyKSrMiiEb$POsHfJ`Enk zbx$V^>z;WsGhO0K|B2b9v(tQy&-PG=GFbW@iC=qV`BUIBM@>I@Y@5L|f4Jivb~5!K z^L>p=-F0*Bw;*{O=x^HwgxK_a|0|bOE7lvFgS4YA>5a#7R=JjK{C~-k?p%90=2wm@ zYPAkPzT~05Z8KzBRt}i`oNugxltIU}HtEj1eZxND$l6WEY}mczA`DSefFG`LhLg5@ z8~G6<`BALEj>O+ZTRprne3$Y9d2?*6^# z4X@ASW+X36wxznXpMVoXy_7wybKFbadQ^WtPVKuVcLP~E`eV}9f8Me7j?9Pj-Q&!- zA7kwHGO_og7Hf~FcOa!icg#)`PhlkhI$HqmHY_Jl*Q(Esi1@f=AZeGAjB2ROvdQWA zU)wfVt>Uv!TfxX8BA}N!bEsu+AZ{)~i>89t@iNlt(O26U*SUPvD(TUm(6!=Cecu@U zAXDqHN5am32a^iAe-X*B&cHd&dAYu;j*LHU{Y*E1LT|Q1YI)zCH#;GJdv(UwirNYr zRC_^>WneGsC-*Tb=SM|^UN4Z9&+elQtNu~#i(!ssod2GpJy>kxsv*WRfz?H3tb!hx z>1ol;7?Pi{G{oH&F%CRQi>_A;H^455Sk|KBs;OJ_gooHUe+xRfj-PC`7T*N370|)$ zjH#n{3L9I-A8+9C*RplW~C@r*ADB* z(VzJ}8B*(~e?#{|weInwY8}_fVX_|}Yct9GMYCQJQQk>fVa_+8cCX7(tXg<=Dg3>Q9O&6uBo=U_6@QCazmQ*^&JE=iN9#Mjr& zPkdb}f8u^l%hN<+qDtq9Kk=ihT5u{89a;I3#H@F(cfV??qUwJW6GPsD_`hE8h}xBb zlxNTt+BNu0Yu zeT$;sXWv8XpyX7(=?-q#4yLI- ze>s4=JSugY-xgDY zVNOoF=^i2AIEx~OuIUN3rt^YIflad+gD){17=WvXhK+VQfUF#pIXREJZWe#(2aGvl z%+08Qr=NxAs9(^q=JC9l_(BD8^!oU}&i+!)H!{Do{WhJ)l|>IHpJOkeG%^|(FADV! zCX3$18HQ(EZCO6%sBL(!ESmSEf1d1{7knuDh{*`5KI@CVZ!Px0Ik}|PU^lxj4C=a^ z2A8V7auOUP@gK!xN3TzQQJPRUp`-55le7GKiM8m!=7Y|7*Rn0|CcYKlm$~fs@2Rc& zBgY-_ed}}Qhv)}-xZj|Snq;bLQb^asAQQdoz7u=v#=Wex1go~%YjQzHe=~G#-QwDH zhWs+sofUHCDMrE&D;s3QqnouYI-c}|d4IvW%X5s>26S&7)LEXGF_#t&x}ycixEP@o zu{d>J%txgkvy%IT%-d-byiZFM*;B9DdtvJI21kkG_BESnTb)<^*~9F1fL(VZWO;g* zd`q3ogn9%v;W=t|aPkFLf1#^aSUva-lNXN{z0Sn^kIPm^pBKZyd4V?47*B49TG`Lj z4O_HTM?FFO0isnMJVSf<6dpz^kSp#Ga5RGP^6I>~nv=h)pYEj98q}+V8EcuaY@9yY zc~P9#C$H0lpY?NroX+m%C`Q1nfu3lNmZE!wER8Bxx|c4=d=MIie|$y5lEEBY2%QCi zC}hNbgz^7TpbZg`)KiFhLLE;EaGbsPY1PbxgUuZl)~OsFB(kM4eT@7AWAq}BZyln&c>%Rtv2)a~GMb>8oTWgn1|5Z} zt3pY`;&c?Rd3>GWYX*klFsmMpO33P{0KFT%X8I15?!7Wfe~BC>24g_&U*t`^w#(v4 z>YkH)@r7W$yE()RwwVDi^!Zh%7~Tkvp5q{y-U4Jf4cS~7=CF(ZUJ`fe z-_ly|V$`^W{pFA$Kf+Z5CdM!&vdb;y#z``CH7vMU?N={jczbpHb&O59XfZYSd(t<1tTk;xKV%NsYnqx$cRj;)&+dEINO_xxfitthM17_W3jux!GL1qQ2$%2-e`8&=yJf=#WsaAchO7A>L{)Hz^CO0O1Zlm-s z2ue}XFs=O?dtG3DQqg%gF=KgF^6#?0l$BqyD=S}hz;3-yg&2+ikBvu9*q)7kVibTq zdQR5cXLkfBoBGT8k6Z`|w5wiHX`zTnv1;MxAdj zZK7^w9ZYwJ9-TGyN`GCz%7}5EMXwmfQfPkoh>-QIdOuw?XJ72Uh-X2vzN3N}mk9A@ z<2v>WGW=S|>Z?K3u3@esa7UZO?Yg2C*g@=lontS(>-Plxa|ZQ{0yp)6tt`NP_v&v0 ze~di1X{}>K zi2MlZI;(xQ!!vAI^)f4ZLMB0?$O!K%a|+85(ohf91a_|<*%b0MvE zLu;vIsN-4f&^x#pmk3%rI7GXx60F1e>H#s#dXQ88vEX?0VifR_dz%HlaCpqusyqw+i%Iy-1+RTIU*5zx*}w<^zz(y=x#mDe<&NIE@bXO zO4c5gO2<_ukLa@mn4x`(Xg~CQZDtl{fS9Q>dNwYr96F@?0Q~6hF&AH-I5+KqoUDY0 z^lyV=n6OXkINsx4Zpd-bmJeI}MH?A5b+2!{lQF(wG6}!W`3n(O(V!y$3fjzFGoR1Q zYdNEC^_-o{jBnmNv`Gpu` zJfwFu*3PbkgG3u%(kmU)D_1kJW+JIRwZfno_v>tf>Ai-!9axIvf7FvFX_G_#_H%XK z;~8-4`@@_Gc2<@F9aDtX0`jDT~8jn*pW>DsKHs^ip@L9&!Y$PEP>wU;`3m$m!qn5U~p z=OTJk@P_u#SBh}<#%O6k8#eK@yh*zQKkekR_{shhkY1vbf{c6D6O}bi@50#E@QYD@ zcW6hguK0Ocf6ATos&J3JWX(FloQ%N}Al@*}(+aD`PuucsM%RNp9|l(ieb&$Zfv|d@ zIo%fJKTdBUL`>;1nL@XRsMp(x$VG<1O=ex7a4({71y6qkHO8pUTNTl~`)SJ}uM_6Z z4OmYDQ5yJ7P5k!IC&fv7OW)l=RCGU2-xt=u`x@zmM1;y|Q7)!ffUx>eT%n7RgVWRz4} zEV-AOMdw`YIxl& zCJM$$I`o-qZ1;)^J5wI6%^+XcE8BrOyMxS}y zc7K4kRD^LCEt3kzCd!%#%WzBGtK$aac@Hy;*wt^DNZU5((Vue+0osz)tT|}V(N}Z! zn|QjKcomb)tJe3Oz?nf0DPoIoO1sf(Bkw^z)j{=%5eGrMLM@5y4-<A*oa0K$8G~I?yK+6yd(C8;ALh;qkp<7_ z;Sfe?o;!p`H+dxuDnbS-EYxdsI@p!j?M9t97!b zf0FsK2tC6l-4BO(4P&7rB4SYbgY?(+%e9O;WQb3Fn4VfIt%VL7IT)wpKXQWC@y62S!Yu}H@-$m_#lXTv3evQd5CKi_FX|h}$ zCGNO|b`7d_0y#e|Dq&5AnY~fknpjDdzPb0KcUgKb`zZLH`G(HHehCqexu3}Y5am-? zZgG@wFISVtx|(z3lj=qPpud56e{Z>LWKWOBw-r-QOh}2Yh;zyDR~nwbHE*UgWZzSA zP*6YM)_u_c4xQ*ac6~m^Q@37a!&dcm;?W;2d4+oGizGxI?cJ2@@Gntmb`Cuba~_l0 z?Kd;FrQWRiXsTg#H8G-gX+!1Pf=9@cuDj>iBaA=p5m1)7iCgxjuWYm0nX;w)&>8T-MPcva^q)UYGd#b6+m1O@1x^^|f<0zg@H}c@KB8 zm(hT*97^0IM^?eZ3b>Xzmpa^A=E&uu@422Oe)*8T{-PLucQ<2=4b*;qYGa%hpq|fD zwwt~fP1rT8qiK^VwuAtse_aE0yx)#>On)D@eml7`*UgH9w4I8eBX0hyPqUNO&3f@R z{S5Z|B{Kc>F~8tpZ##JCJ-lnXwCCKRb2!8~g`65^Y^I#vjrw$XkI|lmJZnySV%1Dm zqV1QW?GLX#Cx&w|!0Q_%=y6)}(DSW4b#9#-FE!sd`3&4P>pwv+e`uKb^+x(xb$ZqJ zXjz=rS1O55Mx_l99zZ6Z*Q*Z4i=&uTbdAx@tP|-T*_ij(+MmR=7u_b=MZb@0-{e#c zU(QG>Iuneuvr1sWBeA}?eD<*#C0aeK66I8x%9xVV8|H&yf9;i+?6lLRt5f&kiHdI9 zG+U|@Gm<}&@RmGje^0uzY^||v^+_YnpX!>J>N&)H7D}$;H(Wn6qfPo01N3(e(dv2< zcojV{;L^;^`oFi2IPd0;0%!l*oQH_jf#y7)WdEfQ_cbdch_?t^G>nNj_uHQ$+)X~`>{3*_Qr(-ncBWRsGq5f}{I`y&4ETE$|f0)w^WB)GtBlM0bvnEta zpcY_&-dun@p_Yd;X{_{vl`my{_}rIY3&mtdyJ8k4L`Of8|AC;kY@hDU4lPmi? zKBmuJsd~4Le=^oje-D1xZbqxX5D2z>U{n`Llj}~YL?=m=uATZ6V^}@-RJw@5 zWH#xNg|WBFv#7!s!vkgN53c73kG~F)xmcp7Ar`M;^RBT^8P3co$rr<5`bplXYuB9h ziT|g@e=z-X=Ckvr-2iDomcK9R>fNGb_R5j8pOiY+&0l-xZ{u`-?4E`dooD}FY_Euz zL;=|R<4=IKiIhzl}4 zS;rdeMm;I8iu{gcwB^Q#s152*o$ya|FI8QaeVd1zo_}iaZs{bN+GIxB$+QC&;9*Mt zqts88dWB|{SBS}<&~x>!?%6&)F^9x-O=^r6{qEDxMd|BxJo{i#@v`C$@}rKPOUQcI zA=-nGC9V3jt<39G(2M;fMk7qW3RURnSR76o#=n$1qqP2-D2FZqVVd|BI6@LX(sMti zGkh}l1%C;#_nCkFtGs*2+MqS45EO9n<2sO$wfsvhtpXoMR!+T(O69#O4^OHr=%xVG0~8rrl#;#Ia^kNkP+dUi{-0~^6w z!bl_P2s`z>)-b1x{%lPPPqTXsB55_TYC~t=Q~LcC3)ild(HBRhV9RRAFCsmgoTkwHJ3J@go=R05gY z)PJsZJ8c)@D19B#zl-z<5ZxM4k8*;275l}PutF|VenK)ef^Ch_lz2uuf~x=EBUKdL z`)d=42yq=uEmPjl1(X%<9K_hzv^hC!=~M%?@>*XkROeR!x;&RVc8kx z`ogz8B(+7gjAnImFZ$?}zpb9Y6)_Q|6n{qR+Sy5YN`@56(88N!r=FSueZqqDJn4$Q zFa0Mf5vErh7LeZ{V$YAM<_C7pFHaE(f>Tr#cU!`@mwMJ6rtcQu{=K3zR2hv(+GP6J z44~Fe75qSo7Thd;@=I6ioVKy=URdTNq6^$H#_x{EsOsn4yvhXg>dlPqb~55HrhnSU zXCqRGOAN7A&Qr9MYq?UNY&Y$N7HVqPM;-dgdHwW$oeMuBSVQdmHAHKyTgQ<~O&VfV z#!kj3OtdG8v77)SYXgiB9??0)Z)e41d_(#={N)SGViu`i;FGq@KT3h_DdXQfhl(y* zeOpWW7#FNmFFA#|GcT`VvXv^QVt?ll^=NWVRb=P~_H#G+%6;3mN*ulE+%=Dbm0Q3w02oZGxF-Sf;t@GjNIz~`gDda&*g z>;21#&p^Dyr&1}GlJ%^lrte^kCBV5VXY6cLXJ{`YqkekEh_W@Qt+R_Bc{%-qMq1(6 zQSaLGhj`;t)Q{bi$m>_0rhi=%V5Fx`4mb+qO4j!3e1+4OQZ{*{cFS2_ZzrP|msL8d zM-=T8!;_xN7)p>Q6}Z{~i*Rd`-V}6CMx?A<=LcD4E(dziIDoz5w)YmMHol}sJL6k*ne*w?p6 ztySm7<%zG`jvS-DEA0u#X!2|8o~CpN z+w6C@YM~V}P__`dA?{1MXC~>(g>|0|Q_@bd9y!EQ63Jhtzki>z`>0&Ujf`^zEh~@i z`h7a;NuIV`Mz-CQJ7HKeGP;_T-qa{{w(@QxJd+n2UJI!-+dTIxls1*j{o-U?Tyqnn zMrwDj`;vq+*TbT){u^TG6FeChMHIdJbJQN^xg$q`W_CSMmX`9rWgzjRj9iQV9j1Ok z)ccZU+UX&aU4I4j@_rj#GP*y)jHR*Pnsuif<30(HrRNM|lqN3X=G+*zK(Aa<=@4Sn zF(QWj0kw&Pj31BEOYCCLJ)i8%ouBY+S{l&dxfWkHVRJwM?!}1RMRnW(kS{nFy_8xP znCT9Q>BKimEAuS7NHFi>x|y@6cE^(0`bqdoM+Lp5&wny{f0|b_%oR=Yf!ZBj-owOQ zP3%PNiL9L5vKhjCHz~vFd3DN!qc|(ade9S;T)@({={$OvVHna=0qu$i3^E2+t0GmJ zhB>oAi{0wbJ%doT)_%GVOcZ&2^J2R=w&!* zjPia$GN^~@RazoPFe1SuQ|sVn=GDjCYQ+AnSAR?<$gnn{ZX!&JJVI^WtD^yT(Kuh7 z%7l}Nin-QC;!nnSR#3svO-pV-@7MXu73|p9MUC9E=-<==3{i#yxdk41Ir)D;k-`TbEZ4BhbJpyYeORJq>dAURjDAp zs()ABw5(M@Teak-zVwi*4k)8=VKGlbKP5wieXk;nVh*V6^U+4>CDVderRktdbu}5% zS!u8m8u#vZJjVQFENh#Zt!6SgrJbxjF`3L^9o2tVhc-le_PFsPX8bc(rADo@2J|zA zbWi?v^4-j1^=|>2&kgwfn2#3DOW(l?aeu=q5&x;#**Qe)n}3_pD?lRTVKuL!#{LL% z?J-1pLH-PG^Rl%J4y74%Brk5*F3gy@;Nt?WRi>%j6XT`!=7BZ={3GaA;DwNowUDt}rb zzE^wJ3^00i9XlP*Pp3-TUiQgBJbdiAZ)f{VMXJsbaLgT9IWulgI!i0fFD2^t6{%0s zN88ABmxyOp*v+1PZauHN7@IO4y^b&m`wZ_~Z|lU5Q3nN8){GN10$T}q{B~ma_T@>@ z49d~B*`sz;isSy0c6_*S6o~i44u5(Ue&#zu_QW5PN!__2U9W25mxjrj(XYGcB%>#g z-tX&E;#?0C>)2&ugg8t4^h}v9)gg-=ciZyK4IFHBY&m$(N>LO zKM2#mr;7Trg_5>{V;$1b`(-%qF)s-y%c7Qz;FG!LFRZH^;B=8P8v63p5dgeTI>9fYr8dNjpS|_pnTcMG4)&BZoByGJam!StM@&tHp07RBe&fvb zsc*R{{-q!5wJNwGQwV?##+DF?9ku$Tn={g-QWjPOqPfOu4KwCqu-Dy;hZ^g_D+k#J zx`U{Qa-zRgm+W{a`L*Q-qFuzic*XE|)!EbE$oNaSYNLKyQ6B2gTz}^qxf`}^ja#&R zB(7xnQ?6Pu`Q%{9Fg5&cJMMAWqidI|C%Kn1+{S$c*>Xz9P~^Ju{FUv=Z@jX}>Aaih zzx}Rd)X^hSvHn%;THPfvw5iZ#q;dOg(w+8b#@}S+=yTK}p1$O{^i`$zp$|pu%W9kM zX7}H&m{m*KbUc@6MSsA0^Kq`dkYwbL@Mb;;%P7Yc^EA5SW_*L5WOwEZi~cR+Zwl9o zXXT$@^cBj|BH83h z#@R*1D)DmNT)#o}A5!Q3K)lX>=ebmwk-1)9#s1%E;zy2$WhmoMQ@sC$>s?R0a#?M| zszvv!d@d$-xPO2n?-#@QXEGC0d2(2c@CLD~PjZI68#BhZ5KOXBR9wJ88oTtM! zVuVg|hqzyNQd1j##};x*c!>)~Hp9&FVOBy9(JJ#$0yZ&EP|F!@u`$tO%sfYUrs{e2 zBaChwX7s~EHl|Px2EiX;ZWX_c(E#?I-dnwjYf5gB!f^Vh<$M#zeX(|5^UqlFU8!(8K4J_=+HPll3ca2;Y-)7HwZPa z^-r2;Pk*bP(cNb9!*xl+locMC{rX|*t!udnRG3U>7r0hewoD8sd1%_}3uTJO;g{$# z2!@XMkCu8Y>(9bz*D)EAg1C|!Ye-Z6$J$;2_uKWa$0xs*_aJ;8%Ea@DAKALOsH;}- z)vBrl^k=)?5}a1Ex-o-Dv@SjC@G8BjGxHWp6Mwn~io>Fbueb5wTe){U$m+|Yxbx^8 z8tqN^X8utDpXHl8AEEi^bbu~%4Y~7^&PJb=19Sgg*SC^VypDS)$UO*bM$3ODb0tUh z{b%gokHX&Af+%G8_lN(NLxvXp8#CfKMIl;EA)@Ntj9h?~c1+J?pBQ%5VCqcd5$8Ui zbbofy{kh*wdm#Um>k6>vv0q)ecH={moBk8phZyJXU)6FX$c0uiCIf$SkTz6>&aUB~ zGTbgemPN7~h-L*Y!^<7)VbrgkSU5!8&`Z;4 zZ5SN>Vn*>&-Jk80I)5$JQ*aY&hKlf-q_fuJ@08&4pOYZ7yF<1| zgIDGD5G4*WokuxCgT}{6dw_cUCHcAPJM6(4`iw#G3(s`rOAJtd~v->{9C4pryKedA{CzlU~ZKk-WE<$r{0 zXY9W?e5ht$egLz#qF8rbn9*g(0k`gOUNw*hZxP`inyuw7*2C3hIlu|=tGAh`A@K4{g5sfCPN^ufdHD+rx z!mKa|t@sc6WcYj$W3kN(zxzAHbAPL7hZ(F^mH3}~)=ITnVwIbc&SsZe)KUXGnqo|o z5>8K`UOZ&7BSapbv$J`L^DrTXDdGf2c1~sWh!~`)!Ac_D(jZ2{MHq4GXG|_cv|+7b zT}b|jW4)App1H9qSg4!g(bH1Gaai$rrjPI^WeLwRI~RzEE-*hD}=x2X>SoBEuNd8g4+Gj3_c$uC>S;d=P?}&}2J#Hf%^-d~92Iud2&IZ)v_cC|f?NEmAp0#?3G&<+o>@9jAK2i1kTLVrV65>0TY_tS>} zYWV`KEK|Qd&Jk8|rVJLSE82y6c)c$?G5@-qS^3l}1>}}IO;71s?#v(&>cwEL>xxS9 zW=n19$2x*qMq**RU}oC4ZI!6Z@8o>L@f$~pV}|2%^H0a*q_0XDlKw;wx-P_|t0!c3 zqD4Bbd|7%1H^N%87Jr>bk-((NrlSG}v zhaX`K_Og^)>~1qFT2E8APQd#lqWA=>HK9dn^!;xAy^+Y_5k_kFkiYB%VbRqT^W z>V1=wZ?W|u#((bY7E_UDV&9$2O}6ToMrchKuh_&zk8s8Ju%^+V!XdA!S&?{%wTc7m zRb0-TOS`;pb33MX*JODriPT3le3Z4>kf=ecE#UW`;u@HqLw;&C$oNC75(IYE#7GS1 z_Yfmbhlp_MwtNl-9k|O@K>Nh-`E*c|6W?cZ%~gzF!+)k7Wz40WHHbcyMc1_spyNRkbR@NEDR4?1v8e|RYFj=o_i3vW>ePk+->R4CO zL{IG~8Sl=>S!P?tRZlh2H#o!`>Aeb-MTh?x}Wx|T*i|apUFgmOmqghvsy7e ztZGBG%6}Ruy{l~o;*vBu|6nTV<%?hdrZ8(GB?-p=;w~FDm^|P+lcz^H%l#^3hJw%;|(HbUwSaMsXB3@*w zdb?XT%M$&2k$U1wcjM8k)}4XiIy#Fuo2n=lVmYDpq~cM{~^Yn zOn)6^kl7RTW^YdZszjCi3uX5hGa?O?sLd*sn{6I-E7!zp!dyh>Z&@Z#rzx#?8r`@WOff=UOT{k6JgdSBCga&-R7nKGWB*LoA1KG zlvNp~7mMK;XyPjPxW{2Xj?vok=zrDfnV&9a#u61|hZqOiBYrUNM!TY2(x^VyDDmCE z@u8Bqi4{7v)Ru;)%tXvD=YALQ`^;3JX05cWW6yzc+V6X%i4yQA`S#kV*M}%?gY>ST z;RkhQ_H&+azRe6wvZADmxmCB7Y+h=S0PDOX#BHz_FW+&2yUobXak~>uuYZ9{tW~}Ti)NgGhaQhu&Tp5|)et-SHg+7$Qe4XKp z26_7G=zE_dW;SAcW%jl}b=XB6StT`u!Epu|4d|k8zDG>%XAf5ux~hhHw40JDNbOk1 zYUoa08Ayk5?j2|@M5$4q?59N);p`bk6Vy(WlMAql$lh*SH3H;dI}!JLRAU^bc7-qA zMy-oEgMK%;!w@CChks8Vlqs}Xlb9F~>MSd*ZGlU6K2ttz6cgY>3Cw7{lVEiZ_%dx1gjVN3(NdC1~@ zC&+{0<=st`%CH*dcCKuzyDQi4IynA=cQ9a+SQaw41NS z^Nc-*^}@{TWG-loo}8(ALFA{JIWXfVp5n+VSr-UTsE+!*n&_xgj4NDVcbhPOLXZ3M zqTh1|OwI5ZeVid?m%DjYvQEL`NnuouV4Z(iO215E+VhVUY^Dh($Q!aZ38dTW2wrgjhAaoe6U3 zg?SPOxNqxevzW}7!J@+k^;u*OWby>B=+Rkkwdb%`z=XGt-upQ9eTe#hl3sZeW7Dvo zFX@;e$IjEj=|eOzXBG9)Nn##C(PxD~{bxfw(K}Q>Bx}zIgxs7p$6IbIXlQ#PWF2j?yUgKJS+Nr9ILb<+E z`PBb6#$&FrMqghGGQIE3wf?ZkxXiX!>LPofhrJ%AXFJX_E>gj*mux z@P9Bbia4|C$L-Y_Ka;$Kzhg#gH(0dkUtOeLFgbuDjE#+#I;quOc>P4SZ~ZPJGN-EZ za~Z$5Oc~ZrxfG_ipnJ0PW7a8|?0JNlzjppV!Valx&7NDk(s>Vk;RC$pl;sy$_w=^n z==%_7jCp#^-OsPm-3#74aG3>&_UbFRKH@rj_FL4{=r7kED*VN-x=VfQjsuwttk8 zxqmNnWQg4tLd@`)nikXu?jbh2jTI~PwCN8}#r-_4 zeeF*&K4i683Nf2u+JBc-X7!R6J(s@!n`G{VZ-eN(-x)_v?V!#kq}f^B9q@pc>bj_2 zDb1q(KgoR%TE7@pvPucJbY+=}JAd7KncrS}nXxp3r*Jd-Tg4uo@Ntju3}fF8=wJ4x zJ&|~TGNz8J;igTb^SwS-7NK9Z`1Gf}#7_>=GSyWp`V%r{L{~>>Q>{q3i`R6E;kH=7 zx;U?nzB#)bOfqF@IvUi(1;nTOj2d_0spM}{)?)A0*xYK6cmZGz<6mjWynnrLl*k3Y z^ykjk>sBlqqZPiNC&$BGaf~*ohni=R&PVh5R#r@6&qPnlhEA^%yIw{VUj6CD|D(%B z@o&x_t$diu+oq~KFtsCv{CC!M*PJCUNPNskIe)~L6m0zGO^KTl#VJowlEg6XToQu} z>r?X7=C@VKHQ-3*OTo1Y5rGoyRV5}`zp0)bRWogR~$l2ID%e|)am+qPW zA!6jtKWrI@KAZE6oNu54bH_W2?nft_xOUxv*Cb)bw3zy5F&dk%B0C0M$F(bU_oV0u z7Rs~ixLfc_L*b~}5$Nk#z}h(UB0yg+bm1wK_4?j(?9rmWkUpvU1%DYo152uO#6Kvz ziLWWAw)N>%zzB@7&Ax6VUcDMvxvOc{*3se)(--nE>TTjF1A2`nR+Pe?@3FBBoXls% zV1$q%G~6MGFnyr%w2Ay0sP&9w-d?&oZJSzR(5aQ&v!V5`=I33_G}JT86k+b9f_Apo zdSSQ+EV5m+1H$Yz3V(}uUh2&FVhJZaw4gn?V5z5YRM$8B+)dlcxAf_I;*;)VM(Hwb z17JYH@x|z&xcVD9t~m+4=p>o>JJ+3=bK}|_#oM-uGxm)I-^=!`d}+b=a)--0X8cdb zz5Luz!ne047yU`c2TKJN2fY%qRuyu%qb7r=d!Ss-1B;L}wtwJzxYF{clE#=J@?_5C zxejmmSU-72hRak+m+VR!OFD0~yz}z9rm}hOLzwM^=;*%zs zVw^HwSb#a8cFKL!1p3%_)h8y>VWOQ=asD7ZBxBbb55i6BJxFxi2xG+ktb#CA%j0CF z>>*!I$XffTdVlKU`gm!KnGuUwX< z`M}%0Z>vguvr$3aqS^qu8!x&tdfuR7VmA)wx6(Amd|um&+z+mX@_P(!YtYvS{^(az{%Ozb!#qi@rH>Ze_6 zEZbeIcz=S|S&du+s!p7JT<6mqbu&?!A?ta$S^0Pxk&u<)S}UK+~lNn@#J-Q89$NY zTV>dBf)-<~)FoGP&vwvLP|weKIq$);xs2l)3u`wuGpbc48Cf5+=PtzD+iB()hb1>@ zI96q}^KL!!snIT?%Z@L9%5^0rE&cIQbUQpqCXL-Jb&vZ z>l2cIt&HiYN=E8eE#`ymPYYNB8I%3{uZsUmb&bZxHdxuq8pr4zOQs*fBT2xk7 z(mwDIHB!krGW}AFRt(xF!&BGL^M5z85K%RQ4Q#Se01x}jy7_lJWu;|(G4Zl0Mu+gd zld&kjy)xn%n8i`G?!EjvB_6xu%55CvvK>R0MV~i_VQcBKTHq4-1hJPw&OhWmn6`mW zTWNKvxlaRQCa3g$<6`Pz%yUP!;d#C3p0#r*X~X=6m-rq(7hdo^DQC1FpMN|Yau3yHbZ=7 zXw&St_BA=MPSWdVM5&(u-FAehZk(C;5lU>6t2Fs!FQ0Fm8gnOQ#7R~J9ARX0oN>4a z;|4|xhgku2jyv`}YMMqyU4LtIPZ<_K5BZ}FA0BMUBRX$G)E4cuT)brqDTPDKOrB$X z`fl#_u${LK#{AlOm!QoTw&>_~vLeE8O5tn(@iI5HFZY*y`7*A?~5B8vxwKju4<)3jo8=#`Kic}u0QO%Q@ zj<{D5bDAOCRlg1suE4O>;ajD##Ca$g(A|1iuX>bhSHKFdO9u;#hZ$mU`?ga;bZ~6v zX|IN}@?j?}dQ|1eW%>jG=FU#5eG#2f68lxxUFZ~_ITKN-C4Y@^=hMgZFY}fk$oN_E zqg#%y`wlui5Rr{57pN34wcss8A9$EWfYfPv>FKp=83Tfq)Nl13_DBOI4N#GLS*?V) zuBjkD$Gu)>qt2%OZ=5prBv+xGapp=fSZa^0yt!y)qlsXGgJ>Vm?LN+^kGvH%l!)!D zPAX^SGQ{Xh7k_!lBiu1PJmJVZ9HjNrN~^EU;`9ysMHg%K0>rwQT;Y(lQL8z_ZpsG4 zw$6yDtu!^39Yjp{D3z=EdeiD`@t36)-JAZr)I68s+UcleJ#Hl}4lqkB;*Ok-&C)%^ z-EDY~P-n16q8xYV8NVdWx%2THh07t6SNuoZ3UJnzI)5mqyL8v}vlBe5^q!)7C9Lmu zGoqo=e9P*xwfge_v(N)PkzQipOpne%=`4C!Mr`c`I7koE)(zWAwHj8T2A}z+1oHoa zW7l(6_FMMntY^-7Tz6=y#hLs(=g`8>>u*OTyso+AU$T994=#8_weVkVK_zw^>$Ty1 zL5rQ&`+tM^_kuJho#p934$+tVRqBQz`U2(R1`ErMcUJg6DBgT8{rq^TGE|I$g zQ^2I|)>i6_dTO{jG02q=vmJ&7Jw&_NjXSPqJ%{bYa z!ujA1RC_h{2Wby%T9iK3fz{1wu?{lN1!+SYZ`Sk{aN8p*!BKWo;$6so+f|!;mYIkU^Q<1eBf^MZ1wHu?qr(?@Z)hDz zpg~6Y{rrNCK0^#HqH8Mk5qp^bF*BdgZAbY2Pvy@BW0r)-DB>k+MT9Y6Gjfj|zn^?q zKr$X76GMnn+F0~;)GY?9TtQFY^dRu?iGP4?sjw;Q?0CRV5^6pji zVXz{Y=W{&c6WoJdTe)v+>M)~=*mJ35vouIXptYDQCgHNi+hgjM~6dV;a%`>c&0Vl;CK zp9)`KjM_NJI8hBb6JbAGO87Rh18QqN^Ub^mV?Bj0GJ~N~ICHLJRBgE7l2kA_B;84L z3hQ&Wyi3-g!!nfUS-Y0FBJZY$9WRDwsY%b!UgA~3#C}?ab;qgvT=RI$ zNA!|S*X(oKAEpMvvmE4g%Bic`h_xo3+ty&|SI!^R*Qq0-z*HVX;(ui6|GAvWVTq#U zd07nOa}O(ZDu}r9+lUA5(+{RW*A-WCVusF`hq!znBfTf+cL1w$koAKjtj``|MeTq- zpW3srkG^^#@mJ&w>LJ>;fY!vN_Nbbv@$_4=4d_*od-=H2h2#j+)x9zcWb%2T zjZ53_m8rf0?bN`nwDtRmS2#~e(oYO9GU#=*ygP|AHmAOewtpQ^8K^cnYWrI^l9Rhu zcb3TzjMD#!&=%ZJRJ_T{nGSsDc+y4|ALtmcpNy<1o)N3Na%;{{v4=i~=u@ua3u^|} zB$s|5$Ks{*gEcwxKi+Ul@zT5oduesS}(z4?n8-EDPRQFxXdvoc1)UF{$9o+1+4z1+8 zdRGtqnMukO%viIS3fTkJ*8xXd8n1~|wH9Q0KLrV4&ar}c2&){!`9Aq}Hy zFB@L^7=LnmDiJbtx5Vhb_$uMQiS{>ssr&*?;_C0}n>cknGCt!go?jWvQfAnnr~fs> zzJhzi>KA@S+~Jcs#0;G+GamR=_#fTQ%qOp1=g;|q?KVtn&-@-U?cWTwrZRM1r^fe! zUcXSkyQItc*aF@E`h7qu6AxtkNzc%L!+6y=y??XxD^bUp%Y8Yp@i|n`5rO=!c+_hd z=Wdy#Pd{dv%lA^+qb9A5_7-$v|H?l}{i{bPA=+po8n(FIl*$n)a^Ah}>5_kOd_mH2 zFO@=(vQeN)eiO6x`*WLAo5RNHD0R|SsMGhrt~j3aIKBEh#?OBtA=|~lSodeF{f{0( zg@4q0HMHPO zdV1!S66O4ngy(*Rv7QcQI}4;e?lxKK7?lKMes!NklN)ubp3->gz&b03jXXwWe=Tu7 zgRC-PKZB%UwMx6hbT|m}|1(?<^vDV)tbfS8MYYXEF_A%Z@!Pe0Hpjg0*C>hK zwu(PvZVIF4=uDQV^o&|~(=+c#OVRJ~$)&FnMU%iDq&m)ZJ6ThJ+|Q_(nzAlAOQicO zu$ZjvCEKjQKAWx(qs;q3AJ;7?NPoF2<*w&%UGT_u)l`h!R+0_()4L{(>JuW$Qlr-3 znEEWHKYECW%rh1-TOr3{=MaHn@L*HCP|aexWb|M4G@9t~OyL;DRU!^jZ=zbJGx6R0 zsFI)OEhaZ$?#2vu2=+iP=a1__qSyn?QBNsk=W z{ReiX-OOBjx2%@hvLe$#!*zuk+e3_F5B+V#wvRC~k8z|XJVjr7oJb>_(pu|vjZu>| z@{Xtja>LGCerxRC6HAKE)`~%m8%e<^2GCmC=-Mc8Ocd|o} z;V*!73u_eK_Yk9Om47^gI*Xgy?Y`(LE86%E_$lw}MGxyKWFIqlD)d(V-0o#S7-bkw zB`fDTiL_V>vVHu^z$Ufp$ZhFDu*>MME}J?LSU+k6?k%TzCu z2xAM7asf)Ia(_xIHP{*QO`L;7^106gSHh+duZ)5yr!V?AJ%E zl0N-W{vA7Wf@@Gm`y%9+A%QLERno~F*G!GNh_TpmM%%*dDH35c&2Yt;84A&}2$rSM z8iJhh{k}!I65FV&yG&Ge0r(lqRjT;OtF=c8Y~&U*6MspEPg<**1R36iGR3qGD+o;1 zBYHXzd+H!-aYX)q#@+=i%KJMLCV-*=Llj1vB7YPHh$u0DhX^R41_o-sjLr7y zjQjnc`+xqu;~`1+`>wfw;hmXx-uHKSj`wpvzXOVv^)0Y!ijzJ{`bfO2`>%mSNgQ4K zFM7@Kx{hCA&%{H;`_XmC_OY0r;{opWMn-!Aj0&{6z6E{0_#Y`DeUu(R@tbb91I0!}! zw||28*pXn!^8O5`3()g*tRppX{eXpmpCs4zegQ_|k~G+kFdv}vOP&D3169lXTN~}9 z7BN*u0a^zE#);8?+f?b*^2#P}MBhBb5StOLVf?t$TFI=|GgfAZ4=LmCQ|{r--f-u zZxuLd$I=_Y8uIL>+~?TyzJGJ`OGnD{D^5h+tMg%4Ez#@4t$Vl+QY>pB`iMvi?|d&K zr%k+budLQ%AL>d@k`%{c$70ko#{J7L_Dg)iw@V7+7f@HCbA*4*46cX(^*9hB1Aotc zgOOa*pVVZLhq>vu zU!^l*ZOBrA4=oEEs^q9C1~|VfcET>PAj*By>gy=xtj624%T;=|F1DZca=3uk&JkEtA8}UO8>$u z)$t3s2K#gt;eR%4#P$512q%@-1%E4px__!O|3l6@oAn%ZdiFDnx$S4QeGmIeo+r6qXnYda^-_$ zbqQFS`hZ$i3%C!5XxH}8XS^T*)j$UM(_T6l_H^qBQ+KASG&YPDmDFdWL}41-Ry&#RE{dscK1WSqxE#9JL&Q|0 zAJD&NXx&~FgPle8z<<>fcc6sj?@vNG1^oTSARpwBzmYpPVp>b^ejB; ztATg)T?r7$=dtu~3p1ZVOXs?&C8@0>P#Vwpx>wKRla{=l(Nk!@uP4)Cms%*k#iybk z%XvKio8q?LBOd$Js1H(}idqz5f36|@$%5<86ej$wuDsT*mjo!%KzV>ZtvB@_9Hp`( zD-ozl8BN;BZhr-V*p%%(I%>%HqbARAA@^Ikb4c&Kv^m>vTkRHZrf|w8{_2vI!gKMF_LwAPt0F9 z>c=)WQcIoDP`O_e>{ z-P`x;3iFV8p^sHN2HjLk8+(iqqHv2V&vg2DlTxB7^ZNo0^H3k7R*Stk{5Ga%^t6IU zborvrKEZF)J6n1^ZmNX3I@DPCVpA>e<(Tw~;eXiZXFPI(yFO^?<4cqW0d@&6yUojZ z-w5Ncr@)CuWLNLYg|t!)4_3g!9JT4|7~4!K(03z#7PPDy!w3kU^eSth+&5+*XmPsx zEk5iP+VLH<5>0OE5BPKS`Ky*|nzcm^=b31m6H~Rx#HT;Nr2{GsRtbCBE zB7ZSGTE;AUz$+Imj!9$tUs1UW-)oN;Y;=_str;Nx;xz44RJDzh;prT&shRdqJ$nKh z^h}WUaho--$e^Gb)u{910@Q;B%BrcujpV3igu99PFvG_KM8Q5WEIo$t2wX{L$Q3lk zO8I6+xjSjq0?E9eEDK|_V`|9p7bI^%AAf7d_VMbC&t!i3=v%&RW$!UAsI?j8T{jRJ z4c-y3vK{6OjnX#BBztaP<2L)fVbLm4TNnod``=}oYDh+0yi%2Wm2-;G&lJOgk9dXK z;#n}=g-n0X0Qqi@vqv1f(+v`^R!md&AD9vB&i$Tc*BV?FBJr)3Klq-$a+3kGg@5R7 zptFJT@h-j2tO8g%E{b9Qxx{PfXST?%w$W9UmmMn4n}}SjXEyf|$M-1vyzF~5TIFCs zb)R3~6{oL_Sd}YhtQ9;)l*UPFCDTvOATiMc8GTGr&|`G9XIq`v(cw_b@qu&Y7> zQ#C7M1-;T6_3yBda*m1V(!9~~Ssi)vXq5(@`3QU}CF}F_th(|HtHp%$$4}3iMccp1 z{x~aCe6|^sPMxf38FPL?ZZdtHvhC-Z8m3h^&WK-ttD#-Gom15#OCtMBix~EV32M;> z@no#uq_UDsE?_N1Z)<8U#A>9Osw%_?DwpClorYgX!v97@Csdej8(yV82`&u zZ&E$i=hO5Ky2MmG4U=QUWOVx^cmoZ;k8v#3R0;kB|I!P(4ksmzS%2Dk8MBoVr)khB zhSjNFOlGQ;eV4}McO27hT?G@gn6FVLncdt(-7`s#8~L1Lx`W2aqJ;AdSluzui@{Xg zAUf3HR81B8e`vc0*jEB)>Yz<{l4uwoWh#&_?{kkIq^~@P=0o z^}dyiS6A`64Bv}kmN#9QYKY&QpugmS+~$7+5y-b4W-h9pHa^}zOlgjsC-m8<+M!4F z&W=$(nwpGbk;_z{__>BKen1iIVTSh<=i6XkRT}Hh6}3v=CJtET zRn%o_^D#>r^^0MgIxNP6IZj3)FZ)DYVze0Re1LW3rk@Y4h5UaW_Wz{) zzQ#Cn!54KD`nj^OA_tKr(lzxyy(`$gb+j8yoZ~GT=c@5q?yc;rljDL;~t#s3(Y4kU%6NOel4d@(VGccU6Y^^!j^k{T;K z`mTb{!+UW)qkHq0Vz7&tSxANb+^@iGm|XN2V@=2PXcG_x%h89Zji@8oCFdOfr8~Qc zaprmx&4sO8aDy`2s{+uHwUKe)5O@=qQPAVy*OacrQCY<^pJ5cHj@T4~ ztww~mj{J{UdzbXH^%f2X*^nmAAJJf(3$vaF#UN6#o=0iJ`7K+kgeY$p53Uf;2v zI{pJ$Z^=7TVK#341h`jBJ}tnUt?54yu-4n!=b@u&S3;3iwHI+vhK}d>LRWXEnxbFU|n6Me-Oi1a!|b=R9MGb zqug(e&_1rMN}>&#SwpXK&AEo2D>#1_fw{h{?|O^1O_SEhwz6t)kkx0f@>WTk)1_;n zC2gUOFrrp(Sh=*lV!Dj(W1i7ZfB7)&n}8UMV!wq*GrW5krylaiHIrvK$Vx}l-y+(F zc!f_)l^U)C-7BG=kr}?MBbvmzg5Oe(BT9-W`|mivKz$&--^3X{&w9e+Dl>o3XSmmB zCA|-yRbx}bdC*Z0`}eSLjyMq5&_XThqqT>!fzhP`Ywap=o*mpj9TLjOVNchD^g!lC zmDodB4@kh$7wwEv9poy97u8qrMg3jPR}XMcj>~@aD|Mct|HiT+O?TjZR$V>x$4Q>0 ziF>J&Qn-V@kl%_VVr>mcsQ!Pno1B(FrU!Cf3cHiDxsS;9W@e-fH$@}$AuycXjKCx7 z1=%{he3VsNPm_mjfZgwOW$9Wu$GQW=PEcvpp>`7yIE%l@kpxH2kZWiD7jP_n1=sN? ztv4XA&<}Myr`PF9-YJJ{B|0u$pF(w1Q9f;v4bOcky%mV={4Ca2j%R<&K~8m*$s6rS zj*tE!*8Q?n-btN2#|*Nu+JXFOw0$jlit1+|H)?g1hD^*u*HkBYz;sk{b9FB3WXx4f z8x9)x3|RpTJBCjTf1!!$8Fq>)=2XsDbM9wFMF&?5n1RQ{;GwZE&vTcq!_`Ipge%HN z``S$j<+k2CV0F!^rT%}ftkimQ8C>(+sKkVNf}*5^k9c`jpJRt+77NbW8n;PkNQ<++Vq>@zx|A|1O0T~ zmk{0#SA5Lc0SC)hI-ij^wZc`~s}0UdC0%u$x-SQ~&fb?I)>(h)wJg6VraLiKah1y0 zK5FVrBD%+QR;sMA?Gu9|dYj%tlT}-6EU-PCkxmQ29kjf~Nk)X<7L()m(RSYH%m0BVdd#}24(7^xSp8&}9lWgaGHi>m zX&Z{eitnQ}>L-8i3+z^-B?k1HLpY>HuC3D?aifu7H;ix|yy$1iYDV}MAJDTm6<=n3 z3^KorEHZMXeXJE6v}}4)@zg}=ag=g+kTMc%4sVlz&+LYP7=~V81AtjNz;ABnx-p!I zy#f{q)K|h!LZuNnNW4VFwUdi^NcBYxIxnaM^D=_nP7HraH!V?983m2k;hak365<4V z$fU0NFmGu(kWiEA^&wL=#CHa`vVgt=-&vQ=5SRybl@$Lv>jBfTMvv_g)TzHgB&g}A zG^$sNYIa!X1}S57rNO*T(A)IMn6-ipZw57&%Jx^(?;RJzdbb}On`*_rK}P6)6CWgY z$jz}hO^<(jFL^~L5W|O^;hZaN#lL>8!Lm57vEmldptJIhZ3J~38{IOvDJ`ob>vy+z zZV;1!V`meU|Amg2pU;n;vTLD^jIYR%Jl!^uFn8BN2daF6Kc8EGn-nD5OYCjW8C$7=CCgNL>X|(AL179;Ob#P`uv;UkK z-ErD|ey-u)i+`!ZSYUB5_gZN>_z1s9yy>!}+Nb!a*NOSUQJJxU8>Rh5S;t!F3 z*;0S9r7`;t5!0flM6W9j+x+aV=--`SZ^ zKC=1Q*!(pI<-qQ3p^Yf2H{={}9qUD7du`^f9v?PC> zoBqTeYNmSPwUA*uC}Wm=Vk+ff)zsPlbNQfjsT`lD{(TR+3y9(4_0gKRCZ~&kq@P2_ z+51F|Jes_S`!a?T3N10W0I~EiBsFp(Vx8zvVGb?7=M)Ky{ zMp50Zb`c^KYi(gVR^aQzZt9Q!dpUnqaJ}Fj6@Oj!Akx1~LIxNL#iiyp?rThx9%FFmW`^v;lfTBPr=OPub;C9;C~9_Gav5gBEN zCDXZcoHBV-JeE~FVfDa$PYePFxe|ZmUsMi)j|j{_HH<_ZvGQ%>)NG^48(DuLQB8L1 z(~M@Uwko}1EZp>hxKeb0N%ZLNS8TJzkN?ao#cN*p9oNLIjG_5lBcWppc($AGxY?C$ z!3}oMEfz}A99?tE^P4^0ZZZyr-}bsW!`6J!*Xo&N5B?Rz?q56l>AuAO{r~23C)I`w zXC&Nor}D2WNzYANn3_>!-~E4gsTomwvp+}z&*D)sb{N0DP}gxd`4UTS{FL6pBpAc7 zDz&=Q-5h~ZRwQk)p5J`;BGu_JHy9Zs$QXE&Gcisd=6Sqzt_4!8mM*?wSi&vY3r{rk z++WsXRYCwQ%4#m zo*z3pg)9nVY6V)$Su=vCG-Cfm=B>H#9-DrqhG$tnx!)K4$QPyf#_xSygQ zbDDO~IIWxG)bb7Fyh0p(BC}kd9ThLxK8;;IZe+2J9{5+ofgZ50poMWvrCQ?)ze`7V z@l5jihNGiB_xTuk_rfV%O*{m-QT2Di9&-FbD#2}vcx;h_w$y((S0_FfZq*u@b;Ffq z`)QWAUd#Vy*K2y#!W~tNAO$F=Pm!Bwl-+9lj9Yipb{n(sl?}`ZxH%tJ7_UJ@IgoTe z@hnZn=)|>10?RL^C9S-011o7dXp9oKSFe9zHP)35%7@hBDYmbPiSqZ*BIu-rH_Fx6 z#K_}*j+Edt&EAFUvpRHl9h1uP z=ZhB7Hb=~@mj3!7)!G^II{eZ6Q~It(ViFKH1fC20-^^}-{de^>vF4ID5VqEt;>wgff?#r0tXrVni%t%0|n5zGAdTbpszTQ~+=v4xIL=V5YBmWC( ziJ5AR_auL?^aAZ?H+gHCdHs9DWN-{)&M8*iqq?P+^U}s~KnCk=3s2@3(<^+Kb5_Mj z5aKJ>XjuR)5A;bDHK*ZP0pfQrSHS=+sB!g{duUTPV*ivEBkC4=4@W5=)yqF*B+anp zhA=NaN}fr^e5*O~BSa95GFFK0h5^PJ^$v9BU6p@*4tJb-a*$>!7v7g*Mv*(YPP?U= zD5HRwUecyAsgoJoF)@9R-sem-s$9rsbxx4{@wfw1@m($Z%NDQ>g#EfAocYu8r&+8U zry2d%RbcyAn$(9{K>t&Bf9cP}u%302lhVjl!?<{i-_S%1gz1sswPLFEuZ{ll56ll# zGZKFjWCxAl4GS|ssT`mtY^EiCgc(fsY;f+8zW4=M54;fIp6_SH_oTRqa2>O95>?bW zLAAx6RH<|ly$i%|<>kiN`FC9ER2TGf?*+v40lp%pb2*|Fz}XyP>}P_pGQZW&qD4aZ zpni+5zSW99m^kj4s6|#*vfYaG8iZMu)GU9!E*{$qwU93m4{EZtCc_vgM~CVri*KWg z9-ryyXJU`2X&7Pl#V?h)xkS(!=Kj90JH@ap9w3GXW4K2piCY3zRSWV^nD48UUUkv= z#CCQPy{vmEaiuh7JxuO_bBxjiR96l#GyS@L3b?X1>=Ptr_)j zb-U?f92A4BKv%fpGB8c=lfz_fYM_5rGD(zivyRPSm4?lj;7eV?$yr`43Tx%?wv(1*^Rur~s7H;5JYu)AkzmY*81Xb6l1vO9 z_~-p<7q`)K^&1{_iKe|XAR&K-B{%(_8nTRd94{gtT@ zkA7z3$rlu{SPsSQF+C??YvpyuP30M?#q=3Aoi2uNR88PW1Lw=I6?e1lsfu~DR_4As zIj3p~Jo^m^aW}e|xin186Jk0VHUo1k$Kw*DnGyXl8BtrO@`iNva~4g8b&Pwyt73oB z-|2fjWQk#ileC59$4h_KXFXv5|ICU`?^Eg4wd^5UDIu0<*gRK=A*x}7zKWR`!_Mu5Qp{kCdngET=72yw_U z)tZBe+x7J`tkQr@IYu_RamM{R`2Ky1PnBI4gJ&G&m7Chcag~3SZpvV2&jYGG+F0d? z^BWFHgYg+BZ}bsjcHOKWG5P-sISI(#Rpe@nO0_-Uh5g!@ki;81c1cg*pHC| zcZ~5*R3RXrw}-rA&CF5ti9v(A#q?M_z}yU&m@itR-p=kZ*v)EX==$y>1JXhJRZ1RQ zbq!YxzO9=w=@5U{KCFaBM(~1^B&Wz;6U_gDn0^W#>N>;iY4Qi{;#>bW)NkFiGsnm} z`4-RD&um;fWwt-@MJvl3%BN0RXm|Kms4(reMa@-@n5!zwUnRdaZlp-27Vf@5PAj|iIDw}8t)plj;SB;vBJNTGZ(7Htr4s94DBsr16Ntr zgXzyWM)ZFac9>z$sJ5lOdb`tm6LLdVe<%eZk)8LIrdl?Fym+K7lXVzZ^@}PuFW&FS2`ITFg>#R zxff1~VeqN8Y`IW((lIMvHbGp~RV!0t)}EP#gI0fUgS{5g&e#{mN`9U12WMIzYY$Bv z&s6Tc!7R^d&QT{Qyhc+kq`H83lCUZu$zeSP8bLDrUe$ovMm0(9hM*G@-L(ZaYt<$odUdpZw> z!Q6jOynBG7ZK`|^p<98Sz4W5KqWf)}eSEA6(yi;|O|_z%RTf+pg9E{5-;aKqyJmnk zb0=f8jl?74Ss=ohu)vCh)>DF*h|4R>d}`?oY{LkZMm;Kv)&|uY=!kk8zFJ%izaU^KLS)i#=)Yk4k5%cha{4-X*CbcNdQ(Ibb{;yaz5%eZB*{Bp#!@^D(skXU~{ z+vj8M&dn`Hu53bIPt%``vNB{ny!>803)pYf`qv=V2B}xZXgvp*8K`FjVVqbfpCu&*&irxX1Giy{E(3W_@JHJQH%1P80K-D?;XY|_VC_mAs_~3>A-&gHBb*b zMe1xN?WB!Vzx?Y(3k6sbumqkW>eX~tJ!4tI0o|j6JlC5t!TJ$IAG)M= zJ3=ota5kWeD&zj7yC|SuToal3eUv+pFx;p93*g{FVmBg{(sr8q{gmL*905qRpi zDo#X9`+w%gh^CKR$cV1TRz!cB!k;x=cjKk7m0_7--wR6!%S1(8SSoZ&#s09Uu(je3 zds2d7KS`Jyc7Mu@#5w=-ZsZ=ra>CMK$%dsFz3)hJ-VqiZmZzw=79^jyJ&P|;2>7!+zTM|+BIT_pOk072b|4s45O|{>P5y<(vycL!nJ2QE@ z9MW;PU%z(*V;QzAY^i_Vm0f~m_OKs@Ez#pAbey83SgqAF<>mz5BRis`MU9zsvd4f@fu{ z{Q20Ku`?q!F1?=oUBpIE{kE=TU5V~E^yc!dO;wLzcx~$1)QW!-I|?M0^*u4NBzuHD zLFG|iipTlcqrAk8CuB87X#kLWtDZWoUWz+I@ zs-Bv3Bz-zVq<4S+sT|SD&*`x~*ALgG>fai9xjdn)hnWAGRQ3BSW{HP+l~|t5qn;<& zqtLwrXDMM<5x<`IcE8t6oqJTC5rgV7y-u#^y#ixk?5~>4?>nbDr`l%QX5)A0S(Z5d z;+(pEvOIkKWb$+!H~nNDt#5N=`r9z;kEmhU(86-@s0(Gfm-;S zv=uE(nXzS4!raf4Pt`>!$QSF`-S`AX%8^v|;nu6=ftb6+U!Jg|z&3m7h+6zjtU0Pp z-pM(QV2ykKHh5h@tU4)#o1( z+ADwM<7Q>vXFY>OeUu(Ti{1&mr1;5E`_rm{dgWNL?ql1?+Na2Y=T@osHTob`x_40p zGoG8ht;_ZO%~Rly>?qhY9`)+l9PwwXZcBeCkU(;Lo?5ZbeO|Q~`$Oey%A3FYY~FmV zvhr}Vayg@263iZoo`MH(Z;-UMl7zYZoQM9IAAP>`x`)Md&*_tM=yjCidLh6Vq~AiK z=^D?;$TxT|dXo0&+-z~HOdodaW}H2kGUNGgpN z2ctziMgqNK?DZ9)Qmo`yTfbR$Eop6WO_rr0k)HX+;Z*7G^&gyH19a zza{N9@t%xzd#|cm3qf)TMtT<+&=s z?#HL{53WtknFH*Po_DBpP>=lq=dnlIqtovydtmbv)ik@ab1P;gEWm2f^@4n{ThHAs z!zo~V3^LOCds+|ez)Kg;7Smm+Swg*%z07N2t~N<)YKG3F+WL@b`gbh<3p$EwYZth5 ztye~UrNHH2Rfg?|?FjBcYLXYRY4JhRmgr8Lr&p#D7cy<-%h=l+R|zW2eA}Pbvki;d zIWc!*1a_ZI&B&XN+Rxo*@z~r9WJE$i-ux{a@p|m{^1i#|Fr+PHHgK*xA8)y~lJ!CyWzf>h>k?Ee5L~9vx8CA{Wkw4Lu+-gO1hAq}L^Qet2XRnD` ziPv)irAW^&6+NZvDY1V;QK11=@*-Y##Wvgi8!3!TjF^`E-9(QJ*nWaohF(`o$fA|t zss;S6AZH5k>>9nsP#wb+@vvsX^oZ#qYb5f-#~9%$A|6(?Vc~jK%7GO>WS6g|#j{#x z3x7Y2fSIR9i+Gf_h*}RTi3$p_J``F#FIVd$#GJX>dTsTM_Y{8;#R6<$Bses!hq;Qp zw1>$QTUch-`Cq3qR=4a9YO4+G@YV%wu6N^zOjJ8#wHW5iVaAMt zS8bV;>?d`9^huLy`y&;z^m#2Tq5N?1C#eUuD(;y=r>n^BNQ$0PW>+~otRBuVq!?Io zDrTwl3>L3ZJ-2^`-3!i8E@Y~<9M!+|*m?M?+HyjU+kT~%U5#q{v8`ajxdpqpIBQj$ zdBn}Z?`>VBwT>YCkiZy4)!_gStO@+~`d=YDnj z#qAe!ze;97=#3O<$lFQ2j2bckOZ38SBr~k)c;`<`;~hhhDeTxcT-x^h5ee$P*U#$g*WlWW zH{eLpcZ_cbAI#{Id9pV${gdCd>>s7|rSI78(eLPz$pY8btB{#`^}p5c9+s!YS2jJX zL&w-44LxdW)kr2RDjVV_V3Q1%^_2BQ?Zt2Lss(=sgu+YmQsxXPe*R(XR9e@^D`sIm zK}PA>_1;%r0Gq&VoRR+z&!Zl771Hv!_4TwYQxlM;t1VV;*f0^(FfUotjWmYM9MiM= z?DMTy>3ZiMl_#vckeuiMcR&q#8>h?w2bcuo{)C>^w1Flt)8z>jv$9S&Kb96ss4I9U zY6pMJT&2vgonuXV&0mQM44CiJ_ku$Pv9bvL2B7v@Ez2GfxJ|VsDzJRH*}HTm;f8e)9Q;Bh%3T7vr4qVrs9A=w^eA^hNq%Rq6#m3;T8TUBQ3KvEM_~{IG1~quTO;{F0RN1>Hg8L>ZkX!fsd= z(%v~juW67Gd}KBJYGoQ`8dTUA9+_Z)%2|~bLG@2Yb>EHx1Fq+4Sv;NbvR0LLS81E8 zhK)?j&Lg6#MY>X+%8%c;H|n33rZ6fy4=exIM{!TvpNALjNK!9DrDoJ#R~>&N*}&_z z7XN5d8diS7-1J9OVt%B@BBTLT!@B2MBrd{ffia|!+zJBK2(7c8{32Vn_ z+m(X8hDO)+C(MmZNA<sURko8WH zx9scBzz(Z7j-ywsxmn4hm1$s}KCK8T zv{2c2USd7Mt)nZ6J;#w|*5|=aj^zKV^*C(3XKZI_FPd!7C%(m23Vd18lWKD{((f}p zU=e?5wxg>})kb$nDpG$7ewK_6v3!N?JY5q&A=@q#yz$#e|mW^a7A?EcvA#oQg49x;Ed?8AftdVj&^8uWTv z#DlXWPhUSN-h{b1a}c@RQLuheB`J7Qg6bomPmGP7saF>hJ2N$Z{bcM+Iq8VmH13Fb z{u{f`E+2KR(_M6PW%-!_Qr&3(W9&Np)B$_H?yu7v&4W_7aa(>^@f6s-mX&<#j)u+b z&-}h~O=yiII}?8!%Ix+PX63_{kFbl!>DqlZWrn4bN5!D9{j|ozsZ$%6*>Q_!C+99~ zzTOphGT+qkYS(uFp=F|;{7#j$i;M4bx)^_Jm4+fax)4;%f{lXju+6r8MFQqI_Vluc z)~1@BZ}z(S>mQWo)4M*JH{a<>nNeg%UJQPnt1e|m!rXu4>C$ieSoQWdb`<2yiTl&C zN1SU^4%=)+$!lyS&NbV6Br|zK6BVb1fjY{+rf^QtqxX75+4$RH|xTm_|;R~yc?-C%#(k)(GY zT=suRQOqrI1S5%ceMc>-m=*F4Zhs&aar3{}h#l+8RNt4rwftht^wfXYdbMI!X-CDZ z!&wsjOG>fp;y8>)t!p^%|S*@GM7EXm0D?}nR6=Q(V<7m4CmB}6V(2e>`Z@7 z{H)oI{RbX1H8{pv4YzC^bLAx!C)A2I`@fh+z3cu>@5~^7`^BmHI24aCF$!GMDqVq$ zahG<8*T_=XJBbw$YImxozY6!g_0r~l&3a5cMGKc+x9o)a)b8wDIh`^?ZGA*wJu;v& zc;v5+GiFj7jvJG)i_DkTxY953s!{Yq+fpWRWACGr7~kp)W;VTgZIudXbk z;-|1Ha^~c?)=xfHD9NZQ(b4R*#RAK3E74V0!#VARtW}xgV`NQz?W_}wyj;*Dt?GqR zQbW3%>nVLqt${z9ELeIaeD~u0mL(j%vPjR!?#VeW8AEQEs3*TZ^OvkngI|M~a=l8q z2Xqt%TwEnqV%>=RM_e>(ZhH?#ORd1!a#-baFaLk@sRU2SU+CEV z%;P$Xi2Zn7b-CHLFsZFLLAm8F&qZ8SZDSuR!BpyQPQq&mb2leZKKUf*y2Faj#>>Fk zRQ05e=5!}L7`b2f@Xx~j)wbN$74|Q-Uxhug^g_~;VGr9%!ydAQh5f*GXV_!5&%2%r z`(b37{b#ZNBka-04EukN#b)c$cRdvL1J`r0|KqkDFvR>A;skLV8?5-7abfd-C5$mE zV&pf}GjtWB%d2kD1vewhMrN;CGlM^Vy{k~Xc?(e$@kBs`XZWp8tfB;eDsHDfZ@%&E z_&yVtUTCe81vjq8R4cLcCD%>gzUI zoqSIxdRELVs8l~Qs8tf#m7-XxMKluqbOcPtjv~9~HAqd@OH%)Pu=uLOF}j zC)egInHQO^`z44haMZaS1$pyvUlk`}{-W~qeVvp37}0;bNslQA6F0aP(p#qfnmpPMwdL6U0*NbDKlK(!i?Fz5}88%e@t4_ zAF;=%%xR%?zIBD&%!|Yjr50ly*}zKNWw&Ke?AB{rZmj zZM8oReIqfOo7EpJ)R9AvwIjCJtcM**tc6pnCiDB^GuBwyhnUga+?U?GIWwslvEK{D z8O;C2JHc@rwf`nHg;IZ5J(Q?(aevx%K{bxr@X7H}=NQY3 zkOB503}Wuof~~n-Cuhx4FLpL#OK0R==J;E|or{j%+}CQ`CKO=)U@z&tG(!_17hn3A zb4^T@bSBKTkLYnvdL`sD)`xmTF0v2mm8|x}i0ZA#=)Z9!#kDQJxcuvCk@ciE?kGuK zgWrGYjrQND#aAtpJE~+b=W+DZjZ9Ch&~I62)*12~$RC=WVMfI43B+pfc$KJ`*y8ha|Y_pRikOVYWNP|I&A0t>(;0{x0(N z5+pLeX-#rD7+hMxf`Z(A`d!hN)Jkn&6=$LNY)5FlyuAK?xz|G32TDi&EWjZyxt$qokM9<<=znAe?aC`S#IlN(FJ&rOHUoTD01+JaI zvZ|&0NW`>6baHi*-6KeJQXkJcq5FSCiq$$opH@%&0+Su&I&NasnVWe2PF9HQ)yGj{ zT?JVkzL(f!V5~=U-HwU3yuIi;IUY=fq?=x7b3Sz7 z_^u)1?@b3~y?$2>tHiEGRw;r3ZhWtS+lx zoS%HxZ|ZxRSTEN}w$yRrc>7pE*-ZYKapH44#DoE3<+Ea4o$E^YS(D@O%3BfNB2s&T zvuIe5g2aJ_Q}Os}*$8wH5*dD}k19O4zSX<>9vB7aY=&Z`zfke6J16Nr$rRuh?P zp!mnh3T&#W+$!%sU`2-E+#P=-FPiByA0#h%C0|FyV@Bwc6$#i)Oz51v(Dg@ zWT}pc;NDoIn!`)hrz7+t2VfWI`aVEZOp7$>wV;k}h%38Jd{#9Pn1z2Ub;ZEHtXFx1 z%KJCOaDj|b-ycxu z?Pyb<78o4EI{1O4lrIu=3))ZCj7qCcUFBTTlSxk!|2=8#c+-*WU5*pD@5U$-_p>s# znbicywt&qmTvmwTq&k1Y+UQPshiFiAf^KBJ*QDOXVg05WMlM3#=r8K%-jj5H_DIyD zVaqI8a+*8Lpa-y;Ptzj@TKGNA30Qc$c=kzl=R>VB`JSD3VSgu{;;Oz%R`MEGAv0)~ zcupPH)NX!5lU^t83W&68WI1nVpAy4sam18;ZXX$rSbNAmOZ2vlkS?_?2@p^U&P+C?IamlGt2&@lI!b*)8cH0qcdnBC z0eh%{HAa@!@HWe{utop2P zIjvW%=W%|VB^eJU&rjZv9_NbRQj%Vo9>*%C5QqAHG3y__AFGaPdXP6$NYX`gCj-^_r8BeKedk)VKroIA7mXGxskzG;VM+0 zAz-~XU~!(B+UNlHn&}4N;T4VYiqX>|!20dC#6(T|Sa0W-HVO5EtzpmmM(V9eGMgg8 zG0DuSsg#_wDy9s->uF-$M>wxt%pZWmqMh>B;0)^|7&A+)yUN&^tG7vtO6Lh)^XZb+ zI){JY;62T{955dDZkl55M4O<$9u|4xZc2D~!k5W$;inw%ke4pVxcG4iv1WSNnRn9C z&E4DqZ?lrbU?iLP&TC>Al(E`-#LZYJ&U$~86)g>XKX%Y5R+CJ!R`!}+-x)EiWR$zp#i z@;`3rb4cl0)@pWI8pF%aHyXcATGys>hoaWwbn%}PpU_Vq;0kDBHFO&>9LHH@WO|E3 z=O1G)l}24N#x^rOKM&Aqz`i=eBl|2{0ekv5wL`FYP0ZcJzZSzAFvMA#q)h?6{I&$G z^)N>MV~lDYt)+K#HPo`>S%9mmPse}GRB<=cMsQnJZ=0pPYAFki)p(LflulYZSIA*7 zL~g|auHYK0avF8Z)f_SO7ia+9MbCDg^}T-TzIN`bG48%vJ!`kM*GGxk-7B5RvxpiU zWX%TV{kL+!ms#?{wpk>QMo z^|Q6KK=)d#O@=AjRI@hgXnL(qo~QMj`oyqrg#4dQt7aX&DGIqJEqCMCqGXX?MI#c-RxP4B;! zcMOSifYqMy#+9liTQ~G~hV4rYKP5LtGA4aBRtY0!ug1Ont3L$S&Gvsv9!pQWZg-b`u+auHUj!S>wHQ1llF)K#Q0+FV; z5@|rB^Y)w&Dsb=)Y0IxDPe6uAinn#ySLdIPoofGM$@-YP?cL1RwAkQ%phCm#YO}o@ z_GJDSY%dc#eX|>z!C>6}U#S%V$Ifh)X7#}FT{N-#Z zj+`%TDKij(%bf;nk%@~gy$u1%zQ#e+px9<7g1zH-)Qd8Jth;z(XYM|WsCM45Ph`$~ z8@D;{aJaKNm~pO+m{#znY<47-*^}>N9PYfFx6a-rEv|n$o%L2~XT!q|Zmf0*TAWjz z7Ta63Ww{6G75>>(hiXVh4=-SBq$c-cX)m*j>6!3K()}?*G8C$LB5J^NvGKD%gV(Cc zZ(BM-FQ!{sh|g*jPckY&m#96suVPm2zm@081>HlH_InVSM!lBF-Q~^S`DH}kvQF$i zYma&9%_V>HLP#q-@XF2DcX<{OpOXDS##giR5&tH#!-LK(oA0$cDySSQe@*IfN5Jrs zAJy2+Ejns(Wzn`fD`ur1)pcAtw)w4`$6C z&0gS$MtgVqiHQ2YSBQQBw~+RpfZ6wp^a@*IM6ZA7MSaIsz6V)WA1m|Xm}UJ0@;ogM zk=U(Qr3&o4&m2f7h;Z&2T5DMSaCen|A|GyZqR|Gp8$?^Ydxs)aPE-tkJ*m+&Jm+rBJq zF6jC;-OqJ;9c`!q(;3Oc4$J#)hBL0s{zvv0=woN9BQlW>P9z{Fg6yLgl<@R>v!)AT zqP}Gh>3dDibMzDWwI$4KhnObuch!xnTOfbMX-Rr78&&E+Upg@2w&hrxw%MpBq$F-x zh3wrWW}Cq3gU?n;tnP5&iJ@(;NK?g$oZh5Ai~EJG8{d_PUCZD}7WNmnY`sL3)hAcb z`1(=t#v`*kPv)(x)FW@`{;Sz~HSSL@hl_vXHVeON^y3jRRiS;hr*J&3&5^Y7ntp$O zxaB|fbA<)jp9GbdO{|DJsW!QvY+ILQP<@yxcx0;YUR;}_pE>OOn9LTYA2NKFlQOaM z%S8*pMZWx^bB!zlg3DBU>gx`66pGN}rqk9HWKn2mSCgaUjf{ua`|bT(HkKZ9z20^J;u~I+dz5`^u^w7?$q+bApv0*ejW3ezAZX?6RRjt;K zPp$4Y)}HwI>43ah_)gyZ=$~1B0=kN91m74%5 zj!GSsK-o04n_kj8JFMsHVKlqmvOBJzcZ{o0U$2wKr3<55SIlIe8QkR+i+uxL`2{kS znMlqB`X|+lr0Fg!S{PkQZvbULn!o3)&WzsQFaJxP%zkp|M?_H~+uf@(*&DW4e^+hU zlvuI&n+bDiw>IcEbg=q0D25~5&-HA7;;E2aUG$;HIlueG^b~;=drGeXwL5Q>K9;c2 z(l(}lXA}Fh9+4*J8e1u&52wk*WU>!__K5->*z^b;P@i_(>O0{jCutwO2oG(@Vb;D~ zwJhgrjPo}!o-t-cEkYjXIK8(%?%048H*c}>)SYCD=#<9Pe0p--^Z^j{pOm0~<%j!N z%YkQLa^6G#xQ%{WE$ef^oP;%f#EOWSUPs&sH92M;$taoI8EIle)(9vO&v38t)6yL7deu#jL#f%NjqK;a1IcwCuwI`!Ms76;~@VA=gDn|k!`!+M5!GUjkU{|(o$)T!1h+_)_}cWFxLc&XX+c~;mU%4C&memj>F<*(Kc}`(sd(-8?E1WwK`)UI zkH8HakQ8UlQaj18f9UANO_i3!21c0Cjc=2rZSO(-b(YYp8y3T;H0)ZpEVXo={WrEF zu%T}hjPyk>?oBPr(Ys6N*IUtvE5FY`EtuLd@2v9#yrzVNbto^cT^)bSkG&H5ix zBf9Jno#*h1S=)P1KVNY|N78uHt;|}sNlWp4*+Y>j;xBe#Udn!kijva3@W7;2CG{y{ z_7GcYMOIyB>`G)h=c#GUqd3#nOBE+_v&F-xLyPJYi@!Lrf&X{2)0ggD+Y#cWBZQt> z#6`6_j!J_qjJ0HcSHL`vys_$BiCUyrR~vKpvPW_rSId4lmpQl_n2P&=pGcl=_Q>*4 zvq$iM^c2V9|9C4kV|x#3otVk4k@vUv%F!JrJC9LpR*ijI4WEAMFgPR_bHAiNTXZ#a zhP*W6UEcKBOf?hMuyZOZrp@!b`RR9|-ZeF2*&P+LTzBk$J`3Ao<+Z%|C992vjw2yF z%a+|{XGc%b@m+l@a^)tHB~)=?{@%3lcc0Da4WVLopIv^@U?DQUh@)|8&&s^?xaU5P zRa+ijWM4n&Ttm#VSs-NQp|3rCi%8aZN z;0!5SAZ}fwUh0UTt)$>{>Z>o%tHM5OFgB__MzeEsa}7F{`dz)Wtm(P`mOCtOq|9K> zMkP{4MgBtF1E^s-u6y?t{VA4L)E^m1%}8(E(rEjC7#byZX2jyGSxHYue@$gggRO*q z&MVTp{hfk#`{UgIzA{*qx5^AZ(aE=W&iJ$jI76(On-Mlf&0SrKzht5y?r%Uf0_%;1;)li3; zD63i->sFeGfX?x-4Cn2k&uo}0*v~m9gEF9*QR4dLgR%lE!O9kgQ?st%f3UpG-ze*E zxKz>x|Amg_BJibTJtU#ZZ@+$Og&sS?SlMTP=^ylw56Wj^)A>A;xB?%qfKq;Q5-?2B zt?c^{#R!RhkIGZvwa)-cuIDZ!ZXMkqV%c*B{KUvZwzB&rWZDs;V$oOn5}6=}={JXL zo41M32qt=DVsRGZZ#s(VA9&4Y=_{f~#wNAfj`QmJh=B02F3R*SZC2~Gj^pd6)iln3 zDsxjKZLky`E7ocF2K`pt)N75wn5Eb1X#;s^_jn~#RbFK)VI}++bycMVvwtolwi5LR z+iWE{bJF_~<}Q0^`^(}^oTJBJ_1}(Jent0oA@8JFyf@ef!=Y0nHljK^v0`niWr?SX z-*u1uH_{e$j`tt(;cxY*Z}sgzd0c0I9T708M4iKJJ9NV*uBw)}p-FMa++8tCS2gm9 zW82>$J0zm-Thy0cA3t?RW%QKjzlnO4@%#f4RGatA(vjk%Wj^*#SfIMmRQk9>(OQF1 z!%wKnM6ak7wJ+rf_Iqy8zn`jcCQdEJ$Z>s>UUjU1y))&}+5r7~aR+%5d+yXm&RA)3pR$=`aoE&0zDKjFbp=ywJ zObyw6{MPDS`QJr1)#CarIov?hL9^ve&=$^{pS+Vb3wm`xp5@Jd?(>Me=6nTmP+K0UWuu$|?{lQ*#Xx5-$42dHT_QhG-L z(BNw6gZpa;-)J;t=9F7CJ!&X3zN)s%8Xd!hzXIS$PW&Lm?|-K3QdU>vQDt+cN55>1_i#2|eHopZk)2o5>z~v$o$>sgkVg z^&a~@nSY{>yWn%VVqsnQkV5a zYDVJf;@QQs6W@;dlK9ENc|}(VG`arJ`$)5DA3fXZ4D*xOgB7#N!!7>dR^}9S#$$#) zOFMk>h*^0m?>h`afJ{Ttx<6tZjmQ(+*xTST3y(H;*}!?(P_kZs_a=Ijpg!V0@?Wju zE*;-eLM<52SmhCGJ{B=%3Fhi6i4~?wMuuPbx5U+~X$yX;GVPZCUg&?JAF*!4xE+Tf z$xNQZ@fTfhOZ3^th>zouJnJTkdC5HI$M!#>8X5PHFjqQaXX<)B1HVh}=mWKi+afNa z7IOF5{P111&N~EutokkL|6-LK*Q@kD`(5Zb-7R-*bj#J{qhLzQ{3jiy4eC*x&~MMA zj!%*3v>x`IN)h0e@m~rbUh_BgtXg1Rbe*(6LG29Bz`p`kW?CkytVt{P}e z^4cWKb$#DL9t|@`Swnv>J}v3hABFvk?A`tKuyF9*$$r~cq{OkVlz+JVk`6XJ{id*UNaKEh`qhuXw&@gk~}A)A>So0LG< zotvk}uG4*Rh4*a!`UQ2o-D=TQiRoC}tKVgEV;FbjmEWd)(9R@cWzTV~z#Cj9XEx9#ACP?$JaUMN_EFLeh~L8HjS=6npVk$y19f6p zoloh1^vS{_ze<0VDJfsseOVy#@{6ZWRyLqV5g50UEpJE6_LJ<<>)#N zOTLRJlYNXQ*ATDyIxAoHWNzS!X-5r;+L-IeXkSm{*ggp+e~Z^#Wko+miN7_df-cT~ zA3D}l(%wScHBNkq9{Yew!2nRFR>#VApk^E~%)p!T^wD!X1#F$ul{H=VCC1wSZ2z;Q zls<;PiLt09&w89$K*XYZi4VK1>#!QwztYEI?q2qhoR0WP*qv5~O=Q>G66TgoTdp3j z(Q%9bVLuE}&v`j7rurClAF6vY%UwTza8>7as}Er+HTN>k4S7?Ky7^GVKsMud<`?x@ zW|rJuQMUW6bB_Ht<{7LZJhCMEE^|zE+{gK+(&JK`u66mn&ONSw&Q*KOHXHfu*qMfP zCBwO^He~0LBW1SjK6rll;jTMO{ui%A-$`bfdU&jOFRE*|u){=1WRLN2InRl{9DhLl}@3#B+eoH)88)D)N_RJuFVGU?TIF{$!=fLRnT86f?( zBGwyJid&ymO0Q!#9y0LC!^K>73jb*!Wo8Gra z4pBZo?R1sdS6(ZBHD`Y8%=~yDP7o&pr{WH<$qX+!Y#1cTdqy-m_BNvityZ_vwwyT; zdvddLv!#Z3MBq4^mZn4|TDV@Hgis0f)-_gJImBk$eKB|cwFfGH+jG=+3;mC%KK^d* zHUE9`{kI>1pJ+Z~so zWrnNT;h}ZlWAqt+F_1GR+NqZLM#jzB#I2q**lQWrv!ZB~207>W3p)&ilkwkFjuf)? z&2&&XBZXkq5f48Flw4EVO7)FWT-BKcB{QgBni=KSB0BeaU2>lD+8tx`2} z6Y;2{tiP{h)lz^~4sDCHmF#Zsqb@e}y+;_&+|RzKhiL(SskNE#ZN{f`Kjn5a>NO^& zvkUa8*S0P-Bj)bq7cE;5-Ndh0F{7Igc$xc&3T~uFbInLF<`vs$hahV>A|F~>Z;Y|1 z(N}*&OL0)IE}AH}V%^=FZQXf$C>h&mZH%*rMUCF+K^^lxVzbe=W}56_*X&6>$5qCZ zP?b>4nHyn$Cb*JJbjOG{#ke*~N_1;<>#~QqBTUbyQ)(5#?mH|7%i5vm8Ww{@L(hc~ z?xr>gT6oAtTI~3A=gQZmCHb`&p}ZcTG^%1}i4prf8K_d~u4reMWyJ9gSxD?IqNa~o z(drh))9Tm@vW_-YrBtgA0&C$QagF%SI%^)g^^+%mSMa3# z37z->3nN;Pnn$*wui} zu8uaU0c=m`&PZa+5o>1@_2%d+A0w$}iSuj~Pw8G=$8C&I8&>K`?(YD*{ebbe@`l`W zGm2_|{FF*PZ=t<$d{od3JWM5JO5PcNihiYch9Y3QYVjL2z!GuOS}OQlYKC*o zmW`CZZ`@|xqncK;pT z3q&2WFduLJx*P)Xi~M`xGEU$9Xwugqi}A>tUu4Il;LXHSx!DD8M)le6iTzI5!_4o0 zdCMOD|5SNU)nmg`Me9vFzk0pXc4jBGWgqAlZ}H>T&#cJRtl5q-ts5n0;j4s|l^NRx zlC$CwF}EkoE}jGVtLTp(+_4=~nVqhcW%2VkCnV&!39r0o@}AjTmbn_SJ$X5Q8qJhQ zUA39mlt`X_*zl zi{CVdZ)6y}k!=vKr2kfMboJMNWEH-|UfPLGt^)C8QR6msuYF)Vn-akcR{O@_{A)Ab&Nz@WF)-V%{QrFwu=3Q!iGfXXibypZTYMm1ObhOu9Q| zmfYWfsVnU>OT@cvr@sV?JZ&P@OYxfvz%mfy)nLYqPNSVPFPh2n?i+mb$K^dgXSFBF z=;Y+PUo`8?dhuU3n(cB&h_t|72+r!jjcjy!MsWgPKO-J@NUKt2)S_0O1FAsuNIfeq zZh6uV7)ytlQv%|p0d-G*ROTx)$o4JqRMIKDH~YT0r^}YD`f}N_@?l3`!tC^$c2qlJ zjG_x3tc(>Ig#XyOA~)laj7M-Dopazd#pRhylfQa8Gih_(nr~npeCbmK$b3mmTlr>T zQSQ>xr)1SnRoo>q(X!;n*|RHdTKGT_W_m`}wJil>?OmpM=RJjgBZVW*cKqKtXYX}1}c zD=sHe*1sT!r_!~5A+TU<#i134$aaU*hH0mWFiMs!AwQk`gZ@wd9eUJZN3umfegR$a zqD3&nisEcm19@C{=lTP94&Y_4SIJGj=&^lbonk9LLAI3L;J_`1fGg4JH*^*L2330b z&1ThWOTSk5C{Q?vCFuXPSIlAdw8wZ~`oB!0m8o8GF?2A0=h8Y;np5Vcy-7K%!=!j} z_~Bk5$=k_3U1oJzJ#_)jOAfHZrmko->F$Ia%2T;$?KIIwWbI*`83Jn~*pXd{xOdaG zt$*vPylQ9+>;?6PWyaAcJ9w=*ULXRa96RyXwoL z%`0B`R?N?T(i(uuh(_t+CAGqTL=*r{x=q;Se>0xM+j8zKp2M{Xi$@RSNB}Dhs{^)4 z@U7x1MTMJO@+msC8Cj}R=D0*g@Py!l^^)_mi#|-F8F(eu43;jh$jzTEHu5W_2TBhp z8^6Srt@MK&rZ+prbj0Pb))|V+SzEO*Xau4C=5KRG^2V)=-!m3gJ~ zC+rrOpubsym^67aB73smOzymA^|(k<7kxO^_OtKXHXxGg<@|y%dgdCPh3G$r7~T7g zi}{?8#7DO!zlyle@u}<=dQI}Vo5zjvJ=el2&?h}@64&L6zAZ7ia;m0W|G4Ffz8v@G z+?hCk5|gz4fT?rNA(vIU*_(9y%mF`9EZRT%>Cz#%v}V9==0v2JeXf zeiZ$j_f5^&WPPRx^c7!@@}opw6>~SaW@6F`O!9AD4dpJ)`xtyFmBo&^E6d;|rKEw+ z5K$KpA*-jgMnYUl7B8RCEIljn<p>38|D}F<~Vk7^)%6iqp9PSMa-ANAI(D{&8TKq7!(KuK@BMXJf~9IZ@S)PcdV~ zRHro;uC1uW>C3C66<;rRIf`5a?Bjx*)bWL%XoZVNsqP)?cVDnYirb`aaip;=jMimDjVeWz7Ke0q%qhN5iO_!wu<;=;Y`Ws|Qa*j{$>QV1$6W~`k#(>Axt!#GeT7AP*bv{nRLn$s~3@cPY6z zyENyNJRkCroF#jAKJ|ilS712H0KR9_=cV^n79o$Pv$To|%XeYzG9F>ncF45D+96`Y zJ0xmL%j?1KF+Y2g>xFNBF)z^ND7X3A$co2_{;8!;-Rbzy=tM}M(R&p?XeQI(5r>UO zR&Cl0p-TZdQ(22E8!kI9%8s^U5{WYyzC)%A(vc2k$Xo`}Boj7J=0#b3f_k!Me_;6YQ8 z|26igwlaT@d6?ZBS0ICe8HB4tYkr#XNX!q6vX6w=J3T5I=p3th4dkP^Am`H=GcV;E z66c0FyXQ2yo9fJeqpZOA#ipW57S+Q)uH<)_)7k4>r#C)d^gr3R3k`i%&TdnTGyPU# z0g-74JN|>bH!T04I~!y*8=1k&Nqds|A3q2C!WEk(@v?)r+h$*b;#1-_24Zy296Ag??X$T7fm;6f*bEOQ=&@}_{8s-aPgCW^3`F}4Q}p~k6FtNB~=>C zE#+jW++wpQb(k8r*>+*a5)(H`T^nM>%u9bW%H^!ngHhwdj9!r%^FFH(+OLYtTMw(a z)3gPXb}DX&)7AB>4x?N!Q>^3#nZZJ(p&lzV|F4+I3>uxI8fNv-L-xRknMi>z<6-8_ z$Bu99R;XiteGqGhdUhloJquTDtQj=>WEX4MON^C`l$V>m>mH&V2%2tZnZ%o5JUAgw zGA@?WZGxB#Bu|MInxNhCl82&uWo+g$=pAdHBiu7TJ$B?j2e?u|gk0q_pm!(9#>p6yWPA6qUfsua>9+ZQW32vR;yN41f?s9j*sJTuxfDyd zFNwCgBF{>mqb}39=}B2ju-l-P)0keK^(YwuS=#N{QwW}aL4V8vxem^rTaxEI#^ zSe~_qJ-@-qdF8_yb1N^IlH8^F&s*NkP<*$kLqu0`*R$w;Mg?$@+62cA@q8Yvl)Fp0 zb=A#(;QJCUVcq=zU+I_R#yB?{Jf-l zGk&qHe`!|ABT1(c%9HmMA1~}eRw(UN=Ap&cj?0YytHj&#f9Py?JuTd$T zLN@dH7(0~rvcBy%lVm?Gm34K>Pc|lJWs3Ln`k9nja(-gdzHXko#_9g7WpXbw$?{@% zK{hy0y>iE7>egv@l^Gd7K-DMtf3ebbO3uqOjva+-sn-L2T5wP1xLwys#v{*&t&~&ZUHj`zt}QR2_jw_5*^TsE zZq=L!{5hUAAf-ZznwKkga))&S^-1cw-h|mYHG%AsXQS~*#`=WW$Xkkan1X&lh0JD! z!-y^=iVG!YY35@60<2lVQFK0k791^G?fh+JM&@4G@hVhCUH=ICkNUktGSjH7u1Uqa zQ*I?zWrMPf(_&A8r~C{1b#%*>b#BJC`KH!-A2r0P`Yp08==gN)6J++EDSwK237S~v z9Af`JptcK8TlT@f5ijMSMd(ad7KtCz4evjiJN{GtB=YL|DtuHk6TlyTAdCO!wcS~SbE4b#hq&1m80h!j<3l)k0j zVEiuAzWgT%vsWBS&RVyBHFF$uEkt4tqmv{#%jq(YoBFi6>|4+=FKeL8av|BN_E*0` zDcSu(p7^MJoCb^d!Q)Kf45ZGA?^S$Heltp|f?m8)WXzJYL>KSMgT)%%a;1D25wzkY zDS0iTJAms+H+4(0tmV<^m0@O+fU@fRBI3Bf#sH=?dA{bjFd3nLvcPe>M$MQtOi2jo z?2j+*9i~YUiQLIqU3IqWpR)|}$a=$P0=jpcF7(dsEVPB{ZSIhxJZQfw=>)YM~BR|lJa;5{OZvI0$i&O6+ zcj>|hp;sy{r!^FR7Ex0to3gk+$dz6;Ps*x8+T)Tpzx=LNQAIO$%4bYEK7D09I%lG& z6cc=y>tn!%1vo1*Lr)MgGcyq1Pp-Nd(Sd46=s?F@c0=Yze=_rxF#Gj01$Tkf z6nb*UdfiK&>6;W8jeS`?Eiv>c{Rh89Mjmp?3{-|y*Eq_5iVDq(YoDm-H}%df@?7n?VaL&bZ%*#=|3D&sO`|{D>DA9x(39z*V+dprolWWk`tSM`jPBjXYskBKIFldy^{Koo%C9uR_zNatJzI$fi#`Px z9e8)kR#%pqpm>(SFGfa5KjfLaXp|r6M(*otS)bPu*vHbdURHwAs@*Y)mXkdy2g7tE z{)fnax)*+Ca$KjG1^@rr|M`XQH#cQ^5k~;EVWwY_cryOW&)$^x9caIezaam^Mb;&P zWKoE+7RPRUo;(TozL>r_5EARa-0JwM#mM_@t_Lik$0V}8U+#Z{jpG){U!ImHIR<|_ zf41@E{G{~uH9wXW@R?BlY*|lqRF5FG5#PdpNo10KHl(YS9zf*(&)HM*G>QOKWWoi} z(4x=8iZt0?p-b$G4wGXuLi{9fsm%pOVoc=Z+vPcT%X@1@a!*lL)i9z8S3Drm4Db~D z5joMP(++S%F;}SfYKS7Ku}Drod&QLnt%vnCr+s?;w`s=uWA%am?qu8&vEB4NCb%wt zU;G6{EKf1Fx}On~B1=bj?K(bD$ad6dk34$!$9VFZiLTXd`d$33hj+M(97~<#jzcdw zxXIe&>5t1(pJ7kbAy#HP%ty=~L_fQU*bc>FjF4d~+RHP|&zxdB*1%7w;hh8+v4XMf zeWFl$trEk8IWZny6YxGE@ruKYG4UEFROqxG2wo`elp! z?2PeILMC}t%zrt?+)p#T-H7ZWgQGQZUco|n}j zn;Y^li==+TJzB|CACqqh0$S)w!D`C!~RB~O5pG)!b#kQikk*%b9Xu<1!w z?`xP7Ko$hLuZOm(hglhAa|NV}2pmnMbW`C*axQOCE9 zvMr;V#8(-PiI>ma!#t6jJa@7VG2fHt{iShH=EyEx-XZJxYwl`)wOsdYtDoOt55h6> z6-21j!SxF*?v=QpN8*G=YW{=73cdrr5qJaH_sNr;7SCuWb(xR3HE0mvkI#xsjLFkC z^BG&@Y93R)^%$nOk;kx^^6DWAOtZ*3c$6`3{UEbG(_};wjTZmS6}dK>*Tbtss5e@f zSq<`NjiD571+-BZ~EFS<{J>wUu3_rLHB2pkFm3q_tEqEZXmQ`=`NSFCFQ1B8 zum{O;HSm;EetuD&y_x+tt~Ec+uYCHZO)k^Cb^&C9ciKwL_L00FdS{dzp>1+~@gQ6Y z&Uu^PFZx>cz0@05$kvP=w^3PhFMaQT)%msTEb-Al@$#D53)5wk-8;1EBj*K9Qx(gf z{yVaN>^GQo@@dC#rL=~)m*}nH{rzS*^}>#7;z{<%yH3e-1&I`P+ivbwi@gl7E2os& zMYZ*A`U5BE@l4A)=oA6vW{t2mp&oLCER0(B>|oCe(4ym<+j^4m%P#hxVNw9uO1JjP zXEn>~is^dlF?sj9aZ6wQ-#d>Y%2@u8tnm?l(RTH6jzw;5^(=xOUhMz?8f_-d@HztF zPkk5tUh9dK1^Tm!InW6e--9(&bR7CHh}r GqRIcYT`uX{0g(^3lL>=0C@6|eQJddv5J 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

wIdY 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