From a1af61a1bf712b07e9d31ba6da387f469654ea6d Mon Sep 17 00:00:00 2001 From: Tiago <1585571+xernobyl@users.noreply.github.com> Date: Fri, 28 Aug 2026 05:40:36 +0000 Subject: [PATCH 01/28] feat(observability): record the outcome of every SSO callback (#9026) --- apps/web/app/api/auth/[...all]/route.ts | 40 ++- .../lib/better-auth-observability.test.ts | 277 ++++++++++++++++++ .../auth/lib/better-auth-observability.ts | 240 +++++++++++++++ 3 files changed, 546 insertions(+), 11 deletions(-) diff --git a/apps/web/app/api/auth/[...all]/route.ts b/apps/web/app/api/auth/[...all]/route.ts index 548693302ee6..17e24ec9515e 100644 --- a/apps/web/app/api/auth/[...all]/route.ts +++ b/apps/web/app/api/auth/[...all]/route.ts @@ -1,4 +1,8 @@ import { auth } from "@/modules/auth/lib/auth"; +import { + recordSsoCallbackOutcome, + recordSsoCallbackThrow, +} from "@/modules/auth/lib/better-auth-observability"; import { createAuthPathLabeller } from "@/modules/auth/lib/better-auth-path-label"; import { runWithBetterAuthRequestContext } from "@/modules/auth/lib/better-auth-request-context"; import { runWithEmailVerificationRequestContext } from "@/modules/auth/lib/email-verification-request-context"; @@ -62,17 +66,31 @@ const handler = async (request: Request): Promise => { // neither is ours to change: the pinned SSO callback path, and `application_type` on dynamic client // registration (see each module). Both no-op for every other request. const mappedRequest = await normalizeDcrRequest(mapLegacySsoCallbackRequest(request)); - return runWithBetterAuthRequestContext( - { path: labelAuthPath(mappedRequest.url), method: mappedRequest.method }, - () => - runWithSsoRequestContext(() => - // ENG-2562: carries "this request just verified an email" from Better Auth's - // `afterEmailVerification` hook to the `hooks.after` chain, which is where the session can - // actually be minted. Innermost because it is the narrowest scope of the three — one endpoint, - // not the whole handler. - runWithEmailVerificationRequestContext(() => auth.handler(mappedRequest)) - ) - ); + try { + const response = await runWithBetterAuthRequestContext( + { path: labelAuthPath(mappedRequest.url), method: mappedRequest.method }, + () => + runWithSsoRequestContext(() => + // ENG-2562: carries "this request just verified an email" from Better Auth's + // `afterEmailVerification` hook to the `hooks.after` chain, which is where the session can + // actually be minted. Innermost because it is the narrowest scope of the three — one endpoint, + // not the whole handler. + runWithEmailVerificationRequestContext(() => auth.handler(mappedRequest)) + ) + ); + // ENG-2551: the one place that sees the outcome of every SSO callback, whatever went wrong and + // whichever provider it was — a failed callback is a redirect carrying `?error=`, or a 4xx/5xx. + // Emitted here rather than from a hook because the failures that matter most are the ones Better + // Auth returns as a response rather than throwing, so no error-path hook observes them. + recordSsoCallbackOutcome(mappedRequest.url, response); + return response; + } catch (error) { + // A throw is the most severe callback failure there is — Next answers 500 and the user cannot sign + // in — so it must not be the one case the signal misses. Recorded, then rethrown unchanged so the + // existing error handling (and the Sentry capture in this module) behaves exactly as before. + recordSsoCallbackThrow(mappedRequest.url); + throw error; + } }; export { handler as GET, handler as POST }; diff --git a/apps/web/modules/auth/lib/better-auth-observability.test.ts b/apps/web/modules/auth/lib/better-auth-observability.test.ts index db2ca45c81cf..dd251f3d81f6 100644 --- a/apps/web/modules/auth/lib/better-auth-observability.test.ts +++ b/apps/web/modules/auth/lib/better-auth-observability.test.ts @@ -14,6 +14,8 @@ import { auditVerificationSessionWithheld, betterAuthLogger, getSignInAuthMethod, + recordSsoCallbackOutcome, + recordSsoCallbackThrow, redactEmailsInLogMessage, signInAuditDatabaseHook, } from "./better-auth-observability"; @@ -523,6 +525,9 @@ describe("betterAuthLogger — OAuth state errors (ENG-2471)", () => { log("error", "State mismatch: verification not found", stateError); + // Anchor the negative: an empty `mock.calls` stringifies to "[]", which contains no secret, so + // without this the assertion would hold even if nothing were ever logged. + expect(logger.withContext).toHaveBeenCalled(); expect(JSON.stringify(vi.mocked(logger.withContext).mock.calls)).not.toContain( "super-secret-state-value" ); @@ -704,3 +709,275 @@ describe("betterAuthLogger (request-path tagging, ENG-2259)", () => { expect(Sentry.captureException).not.toHaveBeenCalled(); }); }); + +/** + * ENG-2551: the SSO callback outcome signal. Its whole purpose is to be alertable, so the tests are + * about the *field values* an alert would key on, not about the human-readable message. + * + * The motivating incident is ENG-2750, where 100% of Cloud Microsoft sign-ins failed for ~18 hours + * and produced no Sentry event at all — Better Auth logs that failure as a bare message with no + * `Error`, so the capture gate above never sees anything. Hence a signal keyed on the outcome. + */ +describe("recordSsoCallbackOutcome (ENG-2551)", () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + const redirect = (location: string, status = 302) => new Response(null, { status, headers: { location } }); + + /** + * A completed sign-in, which Better Auth marks by minting the session cookie. Success is asserted + * through that rather than through the redirect target: `getSsoReturnToUrl` preserves the caller's + * query string, so a legitimate `callbackURL` can carry `?error=…` of its own. + */ + const signedInRedirect = (location: string) => { + const response = new Response(null, { status: 302, headers: { location } }); + response.headers.append("set-cookie", "__Secure-formbricks.session_token=abc; Path=/; HttpOnly"); + return response; + }; + + const contextOf = () => vi.mocked(logger.withContext).mock.calls[0]?.[0]; + + test.each([ + ["the Better Auth path", "https://app.test/api/auth/callback/azuread"], + ["the pinned legacy path", "https://app.test/api/auth/oauth2/callback/azuread"], + ["a trailing slash", "https://app.test/api/auth/callback/azuread/"], + ])("records a failed callback on %s", (_label, url) => { + recordSsoCallbackOutcome(url, redirect("https://app.test/auth/login?error=unable_to_get_user_info")); + + expect(contextOf()).toEqual({ + source: "sso-callback", + ssoCallbackOutcome: "failure", + ssoProvider: "azuread", + ssoCallbackReason: "unable_to_get_user_info", + }); + expect(contextLoggerMock.warn).toHaveBeenCalledWith("SSO callback failed"); + }); + + test("records a successful callback, so the alert can key on a ratio", () => { + recordSsoCallbackOutcome("https://app.test/api/auth/callback/openid", signedInRedirect("/")); + + expect(contextOf()).toEqual({ + source: "sso-callback", + ssoCallbackOutcome: "success", + ssoProvider: "openid", + }); + expect(contextLoggerMock.info).toHaveBeenCalledWith("SSO callback succeeded"); + expect(contextLoggerMock.warn).not.toHaveBeenCalled(); + }); + + /** + * The two failure shapes that do not redirect, and the reason this reads the response rather than + * hooking an error path: the SSO licence gate answers 403 and an unhandled fault answers 500. + * Neither throws where an error hook would see it. + */ + test.each([ + [403, "http_403"], + [500, "http_500"], + ])("treats a %i on the callback as a failure", (status, reason) => { + recordSsoCallbackOutcome("https://app.test/api/auth/callback/saml", new Response(null, { status })); + + expect(contextOf()).toMatchObject({ ssoCallbackOutcome: "failure", ssoCallbackReason: reason }); + }); + + // Cardinality guard: anyone can request `/api/auth/callback/`, and a log field an + // outsider can fill with unbounded distinct values is a log field no alert can group on. + test.each([ + ["an unregistered provider id", "https://app.test/api/auth/callback/not-a-provider"], + ["a very long segment", `https://app.test/api/auth/callback/${"a".repeat(300)}`], + ])("buckets %s to unknown", (_label, url) => { + recordSsoCallbackOutcome(url, redirect("/")); + + expect(contextOf()).toMatchObject({ ssoProvider: "unknown" }); + }); + + /** + * The reason needs the same protection as the provider, and the reason is easy to miss: Better Auth + * **echoes the inbound `error` query parameter** into its redirect (`callback.mjs`, + * `if (error) redirectOnError(error, error_description)`). Anyone can get a parseable `state` by + * starting a sign-in, then call the callback with `&error=` — so without an allow-list an + * outsider both inflates this field's cardinality and can forge a specific reason to disguise a + * real outage. A charset regex would not help: it bounds the shape, not the number of values. + */ + test.each([ + ["a plausible but unknown code", "totally_made_up_code"], + ["a forged real-looking code", "state_mismatch_2"], + ["markup", "%3Cscript%3E+injected"], + ])("buckets %s to other", (_label, injected) => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/google", + redirect(`https://app.test/auth/login?error=${injected}`) + ); + + expect(contextOf()).toMatchObject({ ssoCallbackReason: "other" }); + }); + + test.each([ + ["Better Auth's own callback code", "unable_to_get_user_info"], + ["a StateError code", "state_mismatch"], + ["a code this app emits", "account_not_linked"], + // What a database outage mid-callback actually produces — verified by stopping Postgres against a + // live instance. Bucketing this one would hide the clearest infrastructure signal there is. + ["the code an infrastructure fault produces", "internal_server_error"], + ])("records %s verbatim", (_label, code) => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + redirect(`https://app.test/auth/login?error=${code}`) + ); + + expect(contextOf()).toMatchObject({ ssoCallbackReason: code }); + }); + + /** + * The worst callback failure is the one that never produces a response at all: the request throws, + * Next answers 500, nobody signs in. Recording only responses would have left precisely that case + * invisible to the alert. + */ + test("records a callback that threw", () => { + recordSsoCallbackThrow("https://app.test/api/auth/callback/azuread"); + + expect(contextOf()).toEqual({ + source: "sso-callback", + ssoCallbackOutcome: "failure", + ssoProvider: "azuread", + ssoCallbackReason: "exception", + }); + expect(contextLoggerMock.warn).toHaveBeenCalledWith("SSO callback failed"); + }); + + test("stays silent when a non-callback endpoint throws", () => { + recordSsoCallbackThrow("https://app.test/api/auth/sign-in/email"); + + expect(logger.withContext).not.toHaveBeenCalled(); + }); + + test.each([ + ["a non-callback auth endpoint", "https://app.test/api/auth/sign-in/email"], + ["the callback list root", "https://app.test/api/auth/callback"], + ["an unparseable URL", "not-a-url"], + ])("stays silent for %s", (_label, url) => { + recordSsoCallbackOutcome(url, redirect("/")); + + expect(logger.withContext).not.toHaveBeenCalled(); + }); + + /** + * A redirect the browser cannot follow is a failed sign-in. Both of these previously corrupted the + * ratio rather than merely losing detail — a missing `Location` was recorded as a *success*, and a + * malformed one threw into the outer catch so the callback vanished from both sides of the ratio. + * The earlier test here asserted only that it did not throw, which is the weaker property and is + * why the suite stayed green. + */ + /** + * `URLSearchParams.get` reads both `?error=` and a bare `?error` back as `""`, so a truthiness + * check counted an ambiguous error parameter as a clean sign-in. Only a genuinely absent parameter + * (`null`) is a success — same reasoning as the two cases below: anything the browser cannot + * usefully follow belongs on the failure side, because success is the half the ratio must trust. + */ + test.each([ + ["an empty error value", "https://app.test/auth/login?error="], + ["a valueless error parameter", "https://app.test/auth/login?error"], + ])("records %s as a failure, not a success", (_label, location) => { + recordSsoCallbackOutcome("https://app.test/api/auth/callback/azuread", redirect(location)); + + expect(contextOf()).toMatchObject({ ssoCallbackOutcome: "failure", ssoCallbackReason: "other" }); + }); + + test("still records a redirect with no error parameter as a success", () => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + signedInRedirect("https://app.test/?welcome=1") + ); + + expect(contextOf()).toMatchObject({ ssoCallbackOutcome: "success" }); + }); + + /** + * #9026 review, P1. With `response_mode=form_post` Better Auth turns the POST callback into a 302 to + * its own GET twin *before* validating state or exchanging the code, and `legacy-sso-callback.ts` + * preserves that flow deliberately. Recording the hop adds a second outcome per sign-in, and since + * the hop carries no `error` it lands on the success side — so a form_post flow failing 100% of the + * time would still read as only 50% failures, under any threshold the alert picks. + */ + test.each([ + ["the Better Auth twin", "https://app.test/api/auth/callback/azuread?code=abc&state=xyz"], + ["a relative twin", "/api/auth/callback/azuread?code=abc&state=xyz"], + ])("says nothing for the form_post hop to %s", (_label, location) => { + recordSsoCallbackOutcome("https://app.test/api/auth/callback/azuread", redirect(location)); + + expect(logger.withContext).not.toHaveBeenCalled(); + }); + + test("the GET that follows the hop still records the real outcome", () => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + redirect("https://app.test/auth/login?error=state_mismatch") + ); + + expect(contextOf()).toMatchObject({ + ssoCallbackOutcome: "failure", + ssoCallbackReason: "state_mismatch", + }); + }); + + /** + * #9026 review, P2. The success destination is the caller's `callbackURL`, and `getSsoReturnToUrl` + * keeps its query string — so `/page?error=retry` is a supported target. Reading `error` off the + * redirect cannot tell that apart from Better Auth's own error redirect, which goes to the caller's + * `errorCallbackURL` (`/auth/login` for every button here). The session cookie can. + */ + test("a completed sign-in whose callbackURL carries its own error parameter is a success", () => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + signedInRedirect("https://app.test/some-page?error=retry") + ); + + expect(contextOf()).toMatchObject({ ssoCallbackOutcome: "success" }); + expect(contextLoggerMock.warn).not.toHaveBeenCalled(); + }); + + test("a failure redirect to errorCallbackURL is still a failure", () => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + redirect("https://app.test/auth/login?error=account_not_linked") + ); + + expect(contextOf()).toMatchObject({ + ssoCallbackOutcome: "failure", + ssoCallbackReason: "account_not_linked", + }); + }); + + /** + * Verify-before-link recovery ends here on purpose: no session, no error, an inbox-verification + * page. Counting it either way corrupts the ratio, so it is named and excluded from both sides. + */ + test("recovery, with no session and no error, is neither a success nor a failure", () => { + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/openid", + redirect("https://app.test/auth/verification-requested") + ); + + expect(contextOf()).toMatchObject({ + ssoCallbackOutcome: "incomplete", + ssoCallbackReason: "no_session", + }); + expect(contextLoggerMock.warn).not.toHaveBeenCalled(); + expect(contextLoggerMock.info).toHaveBeenCalledWith("SSO callback did not complete a sign-in"); + }); + + test.each([ + ["a redirect with no Location", undefined, "missing_location"], + ["a malformed Location", "http://[", "malformed_location"], + ])("records %s as a failure", (_label, location, reason) => { + expect(() => + recordSsoCallbackOutcome( + "https://app.test/api/auth/callback/azuread", + new Response(null, { status: 302, ...(location ? { headers: { location } } : {}) }) + ) + ).not.toThrow(); + + expect(contextOf()).toMatchObject({ ssoCallbackOutcome: "failure", ssoCallbackReason: reason }); + expect(contextLoggerMock.warn).toHaveBeenCalledWith("SSO callback failed"); + }); +}); diff --git a/apps/web/modules/auth/lib/better-auth-observability.ts b/apps/web/modules/auth/lib/better-auth-observability.ts index bf76ded4e1ed..7c91096bb7bc 100644 --- a/apps/web/modules/auth/lib/better-auth-observability.ts +++ b/apps/web/modules/auth/lib/better-auth-observability.ts @@ -408,3 +408,243 @@ export const auditPasswordReset = async (userId: string): Promise => { logger.withContext({ source: "better-auth" }).error("Failed to queue password-reset audit event"); } }; + +/** + * Providers whose id may appear in an SSO callback outcome record (ENG-2551). + * + * An allow-list rather than a sanitising regex, because the provider id comes from the request path + * and anyone can call `/api/auth/callback/`. A regex would bound the *shape* of the value + * but not the number of distinct values, so it would hand a caller unbounded control over a log + * field's cardinality — the thing that makes a log-based alert unusable. Anything unrecognised + * buckets to `unknown`. + * + * Deliberately not imported from the SSO provider config: this module must not depend on the EE + * surface, and the list answers a different question anyway ("what may we label") rather than "what + * is registered on this instance". + */ +const SSO_CALLBACK_PROVIDER_IDS = new Set(["google", "github", "azuread", "openid", "saml"]); + +/** + * A callback path, capturing the provider id. + * + * Answers two questions: which provider a request is for, and — applied to a *redirect target* — + * whether Better Auth is bouncing a `form_post` callback to its GET twin rather than concluding. + */ +const SSO_CALLBACK_PATH = /\/callback\/([^/?#]+)\/?$/; + +/** + * `success` and `failure` are the two an alert divides; `incomplete` is deliberately neither. + * + * A ratio of `failure / (success + failure)` stays meaningful only while both sides really are + * completed sign-ins or broken ones. Verify-before-link recovery is neither — it ends on the "check + * your inbox" page by design — so it gets its own value rather than being forced into one, and an + * alert should exclude it explicitly. + */ +type SsoCallbackRecord = { outcome: "success" | "failure" | "incomplete"; reason?: string }; + +/** + * Better Auth mints the session cookie only on a completed sign-in, which is why this is the success + * signal rather than the redirect target: the success destination is the caller's `callbackURL` and + * the failure destination its `errorCallbackURL`, and both are ordinary app pages here. + */ +const hasSessionCookie = (response: Response): boolean => + response.headers.getSetCookie().some((cookie) => cookie.includes("session_token")); + +/** + * Callback failure reasons that may be recorded verbatim (ENG-2551). + * + * This has to be an allow-list for the same reason the provider id does, and the reason is easy to + * miss: Better Auth **echoes the inbound `error` query parameter** into its own redirect + * (`api/routes/callback.mjs`, `if (error) redirectOnError(error, error_description)`). Any caller can + * obtain a parseable `state` by starting a sign-in and then request + * `/api/auth/callback/?state=…&error=`, so the value that lands here is outside + * attacker control only if we bound it to a known set. A charset regex would bound the *shape* of the + * value but not the *number of distinct values*, which is the property an alert needs. + * + * Two consequences of that echo, both closed by bucketing to `other`: an outsider cannot inflate the + * cardinality of this field, and cannot forge a specific reason to make a real outage look like + * something else. + * + * Read from `better-auth/dist/oauth2/errors.mjs` (OAUTH_CALLBACK_ERROR_CODES), the two route-level + * codes in `api/routes/callback.mjs`, the five `StateError` codes in `state.mjs`, and the codes this + * app redirects with itself. A code that disappears upstream simply stops occurring; a new one + * buckets to `other` until it is added, which is the safe direction. + */ +const SSO_CALLBACK_REASONS = new Set([ + // Better Auth OAUTH_CALLBACK_ERROR_CODES + "account_already_linked_to_different_user", + "email_does_not_match", + "email_not_found", + "email_not_verified", + "invalid_code", + "issuer_mismatch", + "issuer_missing", + "no_callback_url", + "no_code", + "nonce_binding_missing", + "oauth_provider_not_found", + "unable_to_get_user_info", + "unable_to_link_account", + // Better Auth callback route, and the codes its redirectOnError call sites pass. `internal_server_error` + // is the important one and was found by smoke-testing rather than by reading the enum: stopping the + // database mid-callback produces it, so it is the code an infrastructure outage actually arrives as. + "invalid_callback_request", + "internal_server_error", + "invalid_payload", + "invalid_profile", + "missing_profile", + "payload_expired", + "user_creation_failed", + // Better Auth StateError codes + "state_generation_error", + "state_invalid", + "state_mismatch", + "state_not_found", + "state_security_mismatch", + // Emitted by this app + "OAuthAccountNotLinked", + "account_not_linked", + "invalid_scope", + "unable_to_create_user", +]); + +/** + * Record the outcome of an SSO callback, so a total sign-in outage announces itself (ENG-2551). + * + * The problem this solves is that every SSO outage so far has had a *novel cause* and an *identical + * symptom*. ENG-1800 (RFC 9207 `iss`), ENG-2555 (wrong `Account.issuer`), ENG-2750 (placeholder + * issuer) and the suppressed `state_mismatch` class each needed their own diagnosis, and each ended + * with the callback redirecting to `?error=…` instead of to the callbackURL. Alerting on causes means + * adding a rule after every incident; alerting on the outcome covers the next one for free. + * + * ENG-2750 is why this exists at all: it failed 100% of Cloud Microsoft sign-ins for ~18 hours and + * produced **no Sentry event**, because Better Auth logs that failure as a bare message with no + * `Error` argument, so the capture gate above never has anything to capture. A log line keyed on a + * stable field is what an alert can actually watch. + * + * Emits on success too: the useful alert threshold is a *ratio* ("failures exceed N% of callbacks + * over 15 minutes"), which survives traffic swings, campaigns and quiet weekends in a way an + * absolute count does not. + * + * Failures log at `warn`, not `error`. A single failed callback is routinely the user's own doing — a + * stale tab, an expired state, a declined consent — and promoting each one to `error` would degrade + * the signal this is meant to create. The alert keys on `ssoCallbackOutcome`, so the level is + * presentation, not meaning. + * + * Never throws: observability must not be able to fail a sign-in that otherwise succeeded. + */ +/** A response that minted no session: either a named failure, or a flow that never claimed to sign in. */ +const sessionlessOutcome = (target: URL): SsoCallbackRecord => { + const error = target.searchParams.get("error"); + + // `?error=` and a bare `?error` both read back as `""`. An error parameter that is present but + // empty says something went wrong without saying what, so it belongs on the failure side. + if (error !== null) { + return { outcome: "failure", reason: SSO_CALLBACK_REASONS.has(error) ? error : "other" }; + } + + // No session and no error is neither: verify-before-link recovery ends exactly here, redirecting to + // the "check your inbox" page on purpose (`ssoRecoveryAfterHandler`). Counting it as a failure would + // inflate the ratio during a perfectly healthy flow, and as a success would claim a sign-in that did + // not happen — so it is named and left out of both sides. + return { outcome: "incomplete", reason: "no_session" }; +}; + +/** The outcome carried by a redirect, or `null` when this redirect decides nothing. */ +const redirectOutcome = (target: URL, response: Response): SsoCallbackRecord | null => { + // `response_mode=form_post`: Better Auth 1.7 turns a POST callback into a 302 to the GET callback + // *before* it validates state or exchanges the code (`api/routes/callback.mjs`), and + // `legacy-sso-callback.ts` deliberately preserves that flow. Recording the hop would score every + // form_post sign-in as one extra outcome, and — because the hop carries no `error` — it would score + // it as a success, capping a totally broken form_post flow at a 50% failure ratio. The GET that + // follows is the one that knows what happened, so say nothing here. + if (SSO_CALLBACK_PATH.test(target.pathname)) return null; + + // A completed sign-in is the one thing that mints a session, and Better Auth decides that rather + // than it being inferred from where the browser is sent next. That matters because the success + // destination is the caller's `callbackURL` — `getSsoReturnToUrl` preserves its query string, so a + // legitimate target like `/page?error=retry` exists — while the failure destination is the caller's + // `errorCallbackURL` (`/auth/login` for every button here). Reading the `error` key off whichever + // URL came back cannot tell those apart; the session cookie can. + return hasSessionCookie(response) ? { outcome: "success" } : sessionlessOutcome(target); +}; + +export const recordSsoCallbackOutcome = (requestUrl: string, response: Response): void => { + emitSsoCallbackRecord(requestUrl, (): SsoCallbackRecord | null => { + // A 4xx/5xx on the callback is a failed sign-in too — this is how the SSO licence gate's 403 and + // any unhandled 500 present, and neither redirects. + if (response.status >= 400) return { outcome: "failure", reason: `http_${response.status}` }; + + if (response.status < 300) { + return hasSessionCookie(response) + ? { outcome: "success" } + : { outcome: "incomplete", reason: "no_session" }; + } + + // A redirect the browser cannot follow is a failed sign-in, not a quiet success. Both shapes below + // would otherwise corrupt the ratio rather than merely lose detail: a missing `Location` counted as + // success inflates the healthy side, and a malformed one threw into the outer catch, dropping the + // callback from both sides. + const location = response.headers.get("location"); + if (!location) return { outcome: "failure", reason: "missing_location" }; + + // The catch guards the parse and nothing else: wrapping the classification too would relabel any + // fault inside it as a malformed `Location`, which is a different and misleading claim. + let target: URL; + try { + target = new URL(location, requestUrl); + } catch { + return { outcome: "failure", reason: "malformed_location" }; + } + + return redirectOutcome(target, response); + }); +}; + +/** + * Record an SSO callback that threw rather than returning a response (ENG-2551). + * + * The most severe callback failure there is: the request never produces a redirect, Next answers 500, + * and the user simply cannot sign in. Recording only responses would have left exactly that case + * invisible to the alert this signal exists to feed. + */ +export const recordSsoCallbackThrow = (requestUrl: string): void => { + emitSsoCallbackRecord(requestUrl, () => ({ outcome: "failure", reason: "exception" })); +}; + +/** + * Shared emitter: resolves the provider from the path, applies the outcome, logs once. Never throws — + * observability must not be able to fail a sign-in that otherwise succeeded, nor mask the original + * error on the throwing path. + */ +const emitSsoCallbackRecord = (requestUrl: string, resolveOutcome: () => SsoCallbackRecord | null): void => { + try { + const path = new URL(requestUrl).pathname; + // The internal path Better Auth actually serves. `mapLegacySsoCallbackRequest` has already + // rewritten the pinned `/oauth2/callback/:id` form by the time a response exists, so matching the + // internal shape covers both. + const providerSegment = SSO_CALLBACK_PATH.exec(path)?.[1]; + if (!providerSegment) return; + + const provider = SSO_CALLBACK_PROVIDER_IDS.has(providerSegment.toLowerCase()) + ? providerSegment.toLowerCase() + : "unknown"; + // `null` means "this request is not the one that decides the outcome" — see the form_post hop. + const record = resolveOutcome(); + if (!record) return; + const { outcome, reason } = record; + + const contextLogger = logger.withContext({ + source: "sso-callback", + ssoCallbackOutcome: outcome, + ssoProvider: provider, + ...(reason ? { ssoCallbackReason: reason } : {}), + }); + + if (outcome === "failure") contextLogger.warn("SSO callback failed"); + else if (outcome === "incomplete") contextLogger.info("SSO callback did not complete a sign-in"); + else contextLogger.info("SSO callback succeeded"); + } catch { + // A malformed URL is not worth failing or logging a sign-in over. + } +}; From 2c1c142b3ffd930007039301821c073f857868f3 Mon Sep 17 00:00:00 2001 From: Tiago <1585571+xernobyl@users.noreply.github.com> Date: Fri, 28 Aug 2026 05:42:30 +0000 Subject: [PATCH 02/28] fix(sso): stop generic OIDC failing when pointed at a Microsoft multi-tenant authority (#9023) --- .../ee/sso/lib/better-auth-providers.test.ts | 180 ++++++++++++++++++ .../ee/sso/lib/better-auth-providers.ts | 81 +++++++- .../auth-sso/open-id-connect.mdx | 9 + 3 files changed, 261 insertions(+), 9 deletions(-) diff --git a/apps/web/modules/ee/sso/lib/better-auth-providers.test.ts b/apps/web/modules/ee/sso/lib/better-auth-providers.test.ts index 109889ed0280..e63cb70fb280 100644 --- a/apps/web/modules/ee/sso/lib/better-auth-providers.test.ts +++ b/apps/web/modules/ee/sso/lib/better-auth-providers.test.ts @@ -499,6 +499,80 @@ describe("better-auth SSO providers", () => { }); }); + /** + * ENG-2754: the generic OIDC provider shares ENG-2750's failure mode, because it too resolves its + * endpoints from a discovery document. Pointed at a Microsoft multi-tenant authority it would + * verify id_tokens against a `{tenantid}` placeholder and fail every sign-in, so those authorities + * skip discovery here too — and the operator is told to prefer the dedicated azuread provider. + */ + const oidcBase = { + ENTERPRISE_LICENSE_KEY: "lic", + OIDC_OAUTH_ENABLED: true, + OIDC_CLIENT_ID: "oidc-id", + OIDC_CLIENT_SECRET: "oidc-secret", + }; + + test.each([ + ["https://login.microsoftonline.com/common/v2.0", "common"], + ["https://login.microsoftonline.com/organizations/v2.0", "organizations"], + // Case and a trailing slash are operator typing, not a different provider. + ["https://LOGIN.microsoftonline.com/Common/", "common"], + // No /v2.0 suffix: the authority is the first path segment either way. + ["https://login.microsoftonline.com/common", "common"], + ])("OIDC pointed at %s skips discovery and uses Microsoft's endpoints", async (issuer, authority) => { + const m = await loadProviders({ ...oidcBase, OIDC_ISSUER: issuer }); + const oidc = m.ssoGenericOAuthConfig.find((c) => c.providerId === "openid"); + + expect(oidc?.discoveryUrl).toBeUndefined(); + expect(oidc?.authorizationUrl).toBe( + `https://login.microsoftonline.com/${authority}/oauth2/v2.0/authorize` + ); + expect(oidc?.tokenUrl).toBe(`https://login.microsoftonline.com/${authority}/oauth2/v2.0/token`); + expect(oidc?.userInfoUrl).toBe("https://graph.microsoft.com/oidc/userinfo"); + // Account keying must not move, or existing linked accounts stop matching. + expect(oidc?.accountIssuer).toBe("local:oauth:openid"); + expect(loggerWarn).toHaveBeenCalledTimes(1); + // Recommends the dedicated provider, and — like the azuread warning — does not imply the + // configured authority has been discarded, since `organizations` keeps restricting sign-in. + const message = loggerWarn.mock.calls[0][0] as string; + expect(message).toContain("AZUREAD_CLIENT_ID"); + expect(message).toContain("still applies"); + expect(message).not.toMatch(/like unset|treated as unset/i); + }); + + /** + * Everything else keeps discovery. `consumers` is included deliberately: it is a Microsoft + * authority but advertises a real issuer, so it must not be swept up with the other two — the same + * distinction ENG-2750 turns on. The lookalike host guards against matching on a substring. + */ + test.each([ + ["a normal IdP", "https://idp.test"], + ["Microsoft's personal-accounts authority", "https://login.microsoftonline.com/consumers/v2.0"], + [ + "a concrete Microsoft tenant", + "https://login.microsoftonline.com/00000000-1111-2222-3333-444444444444/v2.0", + ], + ["a lookalike host", "https://login.microsoftonline.com.evil.test/common/v2.0"], + ])("OIDC keeps discovery for %s", async (_label, issuer) => { + const m = await loadProviders({ ...oidcBase, OIDC_ISSUER: issuer }); + const oidc = m.ssoGenericOAuthConfig.find((c) => c.providerId === "openid"); + + expect(oidc?.discoveryUrl).toBe(`${issuer}/.well-known/openid-configuration`); + expect(oidc?.authorizationUrl).toBeUndefined(); + expect(loggerWarn).not.toHaveBeenCalled(); + }); + + test("OIDC does not warn about a Microsoft authority when the instance is unlicensed", async () => { + const m = await loadProviders({ + ...oidcBase, + ENTERPRISE_LICENSE_KEY: undefined, + OIDC_ISSUER: "https://login.microsoftonline.com/common/v2.0", + }); + + expect(m.ssoGenericOAuthConfig.find((c) => c.providerId === "openid")).toBeUndefined(); + expect(loggerWarn).not.toHaveBeenCalled(); + }); + test("SAML bridges to the local Jackson endpoints and resolves first/last name", async () => { const m = await loadProviders({ ENTERPRISE_LICENSE_KEY: "lic", @@ -660,3 +734,109 @@ describe("Azure identity comes from Graph, not an unverified id_token (#9017 rev expect(azure?.discoveryUrl).toBeDefined(); }); }); + +/** + * Raised in review on #9023: the generic OIDC provider reaches the same explicit-endpoint branch when + * `OIDC_ISSUER` points at a Microsoft multi-tenant authority, so it inherited the same unverified + * id_token shortcut. Driven through the initialised provider, for the same reason as the azuread + * suite above: the config object cannot show which of the two paths actually runs. + * + * Also pins the sweep result — `saml` reaches an explicit-endpoint branch too but is NOT affected, + * because it requests no `openid` scope, so BoxyHQ never mints an id_token for the shortcut to read. + */ +describe("OIDC identity comes from Graph when pointed at Microsoft (#9023 review)", () => { + const forgedIdToken = `${Buffer.from(JSON.stringify({ alg: "none" })).toString("base64url")}.${Buffer.from( + JSON.stringify({ sub: "forged-subject", email: "attacker@evil.test" }) + ).toString("base64url")}.`; + + const initializedProvider = async (providerId: string, overrides: Partial) => { + const m = await loadProviders({ ENTERPRISE_LICENSE_KEY: "lic", ...overrides }); + const { betterAuth } = await import("better-auth"); + const { memoryAdapter } = await import("better-auth/adapters/memory"); + const { genericOAuth } = await import("better-auth/plugins"); + const auth = betterAuth({ + baseURL: "https://app.formbricks.test", + secret: "sso-oidc-contract-secret-0123456789ab", + database: memoryAdapter({ user: [], session: [], account: [], verification: [] }), + plugins: [genericOAuth({ config: m.ssoGenericOAuthConfig })], + }); + return (await auth.$context).socialProviders.find((p) => p.id === providerId); + }; + + const oidcAtMicrosoft = { + OIDC_OAUTH_ENABLED: true, + OIDC_CLIENT_ID: "oidc-id", + OIDC_CLIENT_SECRET: "oidc-secret", + OIDC_ISSUER: "https://login.microsoftonline.com/common/v2.0", + }; + + afterEach(() => { + vi.unstubAllGlobals(); + }); + + test("a forged id_token is never accepted as the identity", async () => { + vi.stubGlobal( + "fetch", + vi.fn(async () => { + throw new Error("graph unreachable"); + }) + ); + + const provider = await initializedProvider("openid", oidcAtMicrosoft); + expect(await provider?.getUserInfo?.({ accessToken: "t", idToken: forgedIdToken } as never)).toBeNull(); + }); + + test("the identity is the Graph response, and Graph is actually called", async () => { + const graph = vi.fn(async () => ({ + ok: true, + json: async () => ({ sub: "graph-subject", email: "real@corp.test", name: "Real User" }), + })); + vi.stubGlobal("fetch", graph); + + const provider = await initializedProvider("openid", oidcAtMicrosoft); + const result = await provider?.getUserInfo?.({ + accessToken: "access-token", + idToken: forgedIdToken, + } as never); + + expect(graph).toHaveBeenCalledWith("https://graph.microsoft.com/oidc/userinfo", expect.anything()); + // Assert the Graph identity positively first: on its own, `not.toContain` passes for a `null` + // result, so the two negatives below would hold even if the provider resolved nothing at all. + expect(result?.user).toMatchObject({ email: "real@corp.test" }); + expect(result?.data).toMatchObject({ sub: "graph-subject", email: "real@corp.test" }); + expect(JSON.stringify(result)).not.toContain("forged-subject"); + expect(JSON.stringify(result)).not.toContain("attacker@evil.test"); + }); + + test("a normal OIDC issuer keeps discovery and the default profile path", async () => { + const m = await loadProviders({ + ENTERPRISE_LICENSE_KEY: "lic", + ...oidcAtMicrosoft, + OIDC_ISSUER: "https://idp.test", + }); + const oidc = m.ssoGenericOAuthConfig.find((c) => c.providerId === "openid"); + + expect(oidc?.getUserInfo).toBeUndefined(); + expect(oidc?.discoveryUrl).toBe("https://idp.test/.well-known/openid-configuration"); + }); + + /** + * The sweep result, pinned. `saml` also configures explicit endpoints with no discovery, which is + * the shape that exposed the other two — but BoxyHQ only mints an id_token for an OIDC-flow request + * (`requestedOIDCFlow` in Jackson's oauth controller), and this provider requests no scopes at all. + * No id_token means the shortcut cannot fire, so no override is needed. If someone ever adds + * `openid` to these scopes, this test fails and says why. + */ + test("saml requests no openid scope, so no id_token exists for the shortcut to read", async () => { + const m = await loadProviders({ ENTERPRISE_LICENSE_KEY: "lic", SAML_OAUTH_ENABLED: true }); + const saml = m.ssoGenericOAuthConfig.find((c) => c.providerId === "saml"); + + // Anchor the negatives: without this, an unregistered `saml` makes `saml?.scopes ?? []` an empty + // array and `saml?.discoveryUrl` undefined, so both assertions below would hold while proving + // nothing about the provider they are supposed to be describing. + if (!saml) throw new Error("saml provider not registered"); + + expect(saml.scopes ?? []).not.toContain("openid"); + expect(saml.discoveryUrl).toBeUndefined(); + }); +}); diff --git a/apps/web/modules/ee/sso/lib/better-auth-providers.ts b/apps/web/modules/ee/sso/lib/better-auth-providers.ts index 18ad8baf89dc..690375f5990c 100644 --- a/apps/web/modules/ee/sso/lib/better-auth-providers.ts +++ b/apps/web/modules/ee/sso/lib/better-auth-providers.ts @@ -267,6 +267,53 @@ const microsoftGraphUserInfo = async (tokens: { return null; } }; + +/** + * The endpoints Microsoft publishes for a given authority, configured explicitly so Better Auth never + * builds an id_token verification config for it (ENG-2750). Shared with the `openid` provider, which + * can be pointed at the same authorities and breaks identically when it is (ENG-2754). + * + * These are the values Microsoft's own discovery document returns for a multi-tenant authority, so + * configuring them by hand changes nothing about where the flow goes — only that we skip discovery. + * Skipping it is the sole lever for turning verification off: `GenericOAuthConfig` offers no way to + * opt out once a discovery document has supplied both `jwks_uri` and `issuer`. + * + * Skipping discovery is NOT sufficient on its own, though, and that half is easy to miss — it was + * missed here until review. Removing the verification config also removes the guard that would + * otherwise stop Better Auth reading identity straight out of the unverified id_token, which is why + * `getUserInfo` below is part of this shape rather than an optimisation. + */ +const microsoftExplicitEndpoints = (authority: string) => ({ + authorizationUrl: `https://login.microsoftonline.com/${authority}/oauth2/v2.0/authorize`, + tokenUrl: `https://login.microsoftonline.com/${authority}/oauth2/v2.0/token`, + userInfoUrl: MICROSOFT_GRAPH_USERINFO_URL, + // Not redundant with `userInfoUrl` — see microsoftGraphUserInfo. The URL alone leaves Better Auth's + // unverified-id_token shortcut in play; this override is what actually forces the Graph call, and it + // applies to every provider that reaches this branch (azuread and openid alike). + getUserInfo: microsoftGraphUserInfo, +}); + +/** + * The Microsoft multi-tenant authority a URL names, if it names one — e.g. an `OIDC_ISSUER` of + * `https://login.microsoftonline.com/common/v2.0` resolves to `common` (ENG-2754). + * + * Matched on the parsed host rather than a substring, so a lookalike host cannot be mistaken for + * Microsoft, and returns undefined for a concrete tenant (a GUID or verified domain) since those + * advertise a real issuer and must keep discovery. + */ +const microsoftTemplateIssuerAuthority = (issuerUrl: string | undefined): string | undefined => { + if (!issuerUrl?.trim()) return undefined; + let parsed: URL; + try { + parsed = new URL(issuerUrl.trim()); + } catch { + return undefined; + } + if (parsed.host.toLowerCase() !== "login.microsoftonline.com") return undefined; + const authority = parsed.pathname.split("/").find(Boolean)?.toLowerCase(); + return authority && AZURE_TEMPLATE_ISSUER_TENANTS.has(authority) ? authority : undefined; +}; + // Unset behaves exactly like `common`: Microsoft's multi-tenant authority, and the documented default. const azureTenant = AZUREAD_TENANT_ID?.trim() || "common"; const isAzureTemplateIssuerTenant = AZURE_TEMPLATE_ISSUER_TENANTS.has(azureTenant.toLowerCase()); @@ -291,18 +338,34 @@ if ( ); } const azureEndpoints = isAzureTemplateIssuerTenant - ? { - authorizationUrl: `https://login.microsoftonline.com/${azureAuthority}/oauth2/v2.0/authorize`, - tokenUrl: `https://login.microsoftonline.com/${azureAuthority}/oauth2/v2.0/token`, - userInfoUrl: MICROSOFT_GRAPH_USERINFO_URL, - // Not redundant with `userInfoUrl` — see microsoftGraphUserInfo. The URL alone leaves Better - // Auth's unverified-id_token shortcut in play; this is what actually forces the Graph call. - getUserInfo: microsoftGraphUserInfo, - } + ? microsoftExplicitEndpoints(azureAuthority) : { discoveryUrl: `https://login.microsoftonline.com/${azureAuthority}/v2.0/.well-known/openid-configuration`, }; +/** + * The generic OIDC provider hits the same wall when it is pointed at Microsoft (ENG-2754). + * + * `OIDC_ISSUER` is arbitrary operator input, so unlike azuread there is no set of values to enumerate + * — but the one issuer known to advertise a placeholder is Microsoft's, and we already know its + * endpoints. Anything else keeps discovery: OpenID Discovery §4.3 requires the advertised issuer to be + * identical to the one in the tokens, so a conforming provider cannot land here at all. + * + * Falls back rather than failing at init, matching how azuread treats the identical root cause: this + * configuration worked on 5.3 (1.6 never parsed the id_token), so refusing to start would be a harsher + * regression than the one being fixed. The warning names the better answer instead — the dedicated + * `AZUREAD_*` provider, which maps Entra's profile properly. + */ +const oidcTemplateIssuerAuthority = microsoftTemplateIssuerAuthority(OIDC_ISSUER); +if (ENTERPRISE_LICENSE_KEY && OIDC_OAUTH_ENABLED && oidcTemplateIssuerAuthority) { + logger.warn( + `OIDC_ISSUER points at Microsoft's "${oidcTemplateIssuerAuthority}" authority, whose discovery document advertises a placeholder issuer, so id_tokens cannot be verified against it. Skipping discovery for this provider and taking identity from the userinfo endpoint; the authority you configured still applies at sign-in. Prefer the dedicated AZUREAD_CLIENT_ID / AZUREAD_CLIENT_SECRET provider for Microsoft Entra ID.` + ); +} +const oidcEndpoints = oidcTemplateIssuerAuthority + ? microsoftExplicitEndpoints(oidcTemplateIssuerAuthority) + : { discoveryUrl: `${OIDC_ISSUER}/.well-known/openid-configuration` }; + export const ssoGenericOAuthConfig: GenericOAuthConfig[] = ENTERPRISE_LICENSE_KEY ? [ ...(AZURE_OAUTH_ENABLED @@ -345,7 +408,7 @@ export const ssoGenericOAuthConfig: GenericOAuthConfig[] = ENTERPRISE_LICENSE_KE providerId: "openid", clientId: OIDC_CLIENT_ID ?? "", clientSecret: OIDC_CLIENT_SECRET ?? "", - discoveryUrl: `${OIDC_ISSUER}/.well-known/openid-configuration`, + ...oidcEndpoints, scopes: ["openid", "email", "profile"], // Redundant since 1.7 defaults it to true, kept explicit (see azuread above). pkce: true, diff --git a/docs/self-hosting/configuration/auth-sso/open-id-connect.mdx b/docs/self-hosting/configuration/auth-sso/open-id-connect.mdx index c87182f8fda7..caa625bf4e72 100644 --- a/docs/self-hosting/configuration/auth-sso/open-id-connect.mdx +++ b/docs/self-hosting/configuration/auth-sso/open-id-connect.mdx @@ -23,6 +23,15 @@ Integrating your own OIDC (OpenID Connect) instance with your Formbricks instanc `{WEBAPP_URL}/api/auth/oauth2/callback/openid`. + + **Using Microsoft Entra ID?** Configure it through the dedicated [Azure AD + provider](/self-hosting/configuration/auth-sso/azure-ad-oauth) rather than here — it maps Entra's + profile correctly. If you do point `OIDC_ISSUER` at a multi-tenant authority + (`login.microsoftonline.com/common` or `/organizations`), Formbricks skips OpenID discovery for it + and logs a warning at startup: those authorities advertise a placeholder issuer instead of a real + one, so id_tokens cannot be verified against it and sign-in would otherwise fail. + + **Upgrading from v5.1 or earlier?** This path changed once, at v5.2: From bd28b96a82aa0d6700520d185679d598cd8cc88b Mon Sep 17 00:00:00 2001 From: Johannes <72809645+jobenjada@users.noreply.github.com> Date: Fri, 28 Aug 2026 08:45:31 +0200 Subject: [PATCH 03/28] docs: illustrate four pages that had no screenshots (ENG-2706) (#9034) Co-authored-by: Claude Opus 5 --- .../user-management/two-factor-auth/setup.webp | Bin 0 -> 26976 bytes .../quota-management/quotas.webp | Bin 0 -> 26190 bytes .../surveys/general-features/tags/manager.webp | Bin 0 -> 35888 bytes .../cooldown-period/workspace-setting.webp | Bin 0 -> 28876 bytes .../user-management/two-factor-auth.mdx | 3 +++ .../general-features/quota-management.mdx | 4 ++++ docs/surveys/general-features/tags.mdx | 2 ++ .../website-app-surveys/cooldown-period.mdx | 2 ++ 8 files changed, 11 insertions(+) create mode 100644 docs/images/platform/features/user-management/two-factor-auth/setup.webp create mode 100644 docs/images/surveys/general-features/quota-management/quotas.webp create mode 100644 docs/images/surveys/general-features/tags/manager.webp create mode 100644 docs/images/surveys/website-app-surveys/cooldown-period/workspace-setting.webp diff --git a/docs/images/platform/features/user-management/two-factor-auth/setup.webp b/docs/images/platform/features/user-management/two-factor-auth/setup.webp new file mode 100644 index 0000000000000000000000000000000000000000..b6f61d33da8635d6439efb3da4aba256d29d22e4 GIT binary patch literal 26976 zcmd?PV~{W1lkeNMZQHhO+qP|UH+S2%ZQH#YyKUR}wa+v2k2q(}#KgUGV_x3%V%3Uo zMP%g4Rr#rmtWuGdkkGOQ0@4&0QPNQ2B9i-Ot>g`y3rqt9Ndhduj1?nBLR^USHseGD z3f9u@)I9-&400k6_!Mv9pLc2a`6hl*-ols9lRSs{8K_M7w}0;gG%)I6;Tij@{yVUO z@x1?xUnOww`~0Ku2l0n?jq$x6fT+j#6)?Jc+JF7?^Gfx#@bk}TP5=1*>6aCh6wLk+ z`{DzDZzHYOJ+}BmNF3{tA2{{h<8n2N=TT4+W~;+b;f`@xy-;K8s%btoM)n z6nyW0SiVjJ67F_qf0}-#9s>^`?|(9Oj{=1H(ZBh>B;QW~fw#L`g7#l4Kgrki3xNwi zz2C1_u$QY-g55vfKg>UfAD%^)4}{x+KK?VG^B;(B{kMim`9_3eKj}X~-e|^K!)$e@BUB6_rMLq()``PgTUY)-Jj`C!GGHsN=){n<16E%;QP4gIKiN5%hKiU`>O3A{jcNcz%=_AP~N>kfKmbSv~&bs{Le zNnzNy0bTB04Bylr@Ja7d>bC7bRC$%bwD$zQFgO>vuG_hi(3ICg-gSZ7rTtI0_V{JD zsq|a7AS?e%tNQ^nBFH~;Jr{lO;_Vk~{^Y@KGUpz~)S?@8g;c#xXwf(jv#GHG9W|Vx ze1Bh_z7&pGXWSofEdKk>)pG>po)Pz(J10mdE{vt(KyMddq5+0KSqM z=_P>3X!Gil>wN0|znDJdG)sF4bwm~XCtj^t2A>{r8u<(xSL|?w+A$Ommc^XPe3R?0 z+{Z{B#?p6pNn$KgX>8$eg>p>VY@R{y{r@3={~jd+q}m--JE4lWzv6N}>mq+QZ?d-& z%9x2O)*v>?q2ll-gic`rB4<7b4mUdM$xOh(QTX39q-R7>etCT)Rhop)Q@fMGRVD=c zCB`@&@Om_^ii~~0K%n?+`$mS&eyL2sGa&b!@RW3G{qP_U^Z^UHUuJ>$wV-zx)MjaP zDFNfhmBV8f~FR|%3_xMVC=?>$o zV}S_bk&gwk#6-cczB@%ff!mc6koONd792(B_h4Y^MQ!XnQ%=qM4$yCcsMBgD&k@zo zx&NpNP;wE`bp;qmcwn9UNM7D1Wjn`MBPM-ZW$R|P~qf#R=EcL8RwSpSeJ z8xK%CrZ=$J2o;e`zqwmKVO{!F0Jx&P(Z;d}b0UHFM`>W2iQT##oF)eRBDjr)Gl(^j zuY$<^!Cy4h7Zod}3|}hL#4wALjwQdVt2SSOs>ev}q9nz)VZ2H@<|?4+?h1QoDTdwj z`sz(QrlN58`7Rv;m6+h=TlAK-bU4~#BI)rCM)%+q3^TIf?>kv-+jH!x#2cZlq@#~J>XJF03Jc-q+jjE!{sWbm`LB-~L zHQWw#fA_TPe|g2(5~q7(uSz@l&-|Gch9NwASn<=DkI}xj6`;2qtpT*=V>BQ9&m|fj zRnj{=w%LCn?f->a|A&SeEqMQ3O#W}1)n4r=^OrwwODnM~0rQ3hb*$#=Ar!fdJ53_i z&`9U>?p+zhyz$It$<47C(L7iocC(UwINqwf48NHrnwyG;!4|SHs(lAM)`+5-_gK-( zfgeWiEW|Hypdzsog3;ydeGfFJa6^J!|6Xdfw=%{;ie+ni84rE;l&j&=_x0XO0%RV|AsGK- z5p&z@`H|LPX$OpbFCQ_Y(~dW;{Zg_h7la2ssbNptnw&G4&~jp<*UyI<4hPJ{*Y@QS zsF;+|Zp{JG-SH6*PXf%ui7M_fHg3JlgR-KEQX8v_*<4q2|{5}u!MM;x=se$;uo5TgV5B;^ncg#Vl^|Ms?4 zX7;)$BPq3g$YPoTO_%Dfy{`2h5Uck+X3kriw!{QT(%#meJT-}fX6>o!urd-5HaZ#t z28h4>ntef2lg;utKL$s9xok#6K60bY9+$Pk8Ly*FauliZ>wb6ViF*#0Vt7)VKR#+} z@CZqnyTsqtsz3IP_#nY^UC?YEfQaXQ1O+P7!k=ZRrhgEviaMy&Jz)9sn6~jdMS4Fr zZUG#@!r804L*f8v7}zmME`vy++hiPTa>M=ZRqJ})OG*I63oAI|+(m5wSyVMVOs zcZC7g^gra@U~eP?JH{5T+AniddH1ZCx~|(({GzP?udAg_zJa7jJ$K`K9B91%%)$T1 z%4oUQieGkyFe>(x73zhUV1#rn%oi!a1o=vYKT5Lke<}rQBm@C{UrmU1;*wFfAnq<^ z7t0yHN!=(v7eMB^U+xX!^R_KL4Fy?xsxD@lnGODCQxKyjJg1=ffdi>&1s{PZ47CJ3 zD-;<3`uCA7OL*N4ih15;y?+T@N++0ufHMoVpv54xB^%qv0H7SWy8||1!Y|InO{iOE zA`#&zA{$9+C_00H3>tbf|HQE=DyrQfJy_<9=sL%@1t5d%!k$DwV^1{w4e&Y5Ha2 zm+RcWEW^MnsY%jf4|%7o;{Z=SfnzBuBc*5>#vK&y#EIw=>+F0Zg0XTR4HcDGz=Z{j zhfx7#lJ74@jMFso1<+y0^X3Iq<3T@sTolM3O!~!-Ho5WC2k#zdi0$#{zI!T9@4D0V7j;C&yo6@#N5htgVxb zcY@3UvV+%51sIsRpslq=n?@23P8+_yc_ZyA_uOA^Z7ZHCfE=m?<-?4Z7L1OR@3iIS z#tIGh5hHa(z*VfX>L)&Gv=9Okwm!=f@+^Dh4J(lAIiEFwy^%T^KCk(jjF``Sv)4ZQ z!8GCEL7*|{P3%@XJeSSAzaVI{2a3EJas`mxfPPLlpN$fnheoHdEgbg|mN^WNJkFn`K5)sK# zZMj^UC*~#QNcrP((>Ju(1G5{1mnCLC8BYfxSx z$D_w!5kS82Hj#J0n0(~?8`5a;CMz%L#BCW|rIhQX5#5RSxNt({#cln_O}XI}H1ULQAr zC=~9Ccn&p^mBlgeoEN>8fA@I8t&40ZqgPD3oH{zZzgP2bjM6T2cdQWDXZTHsv^h6| ziL8V$lsuKBIV5Qrq(|~`U@(b`oT0I@>`I_bUY6&_VcL6?mxO&eoy(Co%SyIHF|XCG zzv3CYfs#t|2J#$#C$G2_{bp9G*pnasRHC35_RE!e;W7meSF7RzfSa@cI)A4GuPgM< z?#Yt8K(=&NZ^en*8Qcf0iF&IsV+8kK+A!SksckLB4fmY+$;9L@#KBc|Ll!Z*S1juo z#}K%isrZ~LwZbz?f`|5|9(X57?0PGjs-dUC{@IGzEAU^UK^r0?x3~K5 zVO2ExGKEAf%ztGC_$9h|{5p8qzS}0D?4i60Y~V-&NX&1c`3%=?VtpdBqZE;@)bp7< zwVjmfb1MyvyF`e07+CEPxO{KT)4-$iCSUw4d3Vq3)vVA=UYzUl?e==k0ADQP{51nyf=5){fyWOHA91Kk{W! z?6Bo#R5gtkX#_w0V85~4Y4Awg_h>cy4UeNg6N7JNI#}agqBnYf{|c)89ns4$)6Xev zd{P%f_>eqU1d#yVy1r)`NM9gKi0c-JRgMoEbuIx&+C14x>{hSRxM63Fu&on)AIwm$*u3b)+4@u$}2`xQ#3 z*MfNpSAML`&p{qA^J_0p1fjDBSxi-)#azhbY3$N>k6P_MqApRTq9WfDX}(C6b4&SL$iz|Ta}(*xf-1Sn6b5oL%FQdoYph3bB} zlSivkRcE3b0%UaeEpf=7=v=&NRMdeS$WN5B9aZQ=nbjFp)|DiYYoDmt7)YfqTKx(T zKkQJ<$vxUd{$-WAlc|}w>NBOJ4ChM7a(#Z8jiGq09E*v$#HbqJkL*vsOn>Z@ibI<{ zRUBRIy=Dj{pO$|;3c?b+n#ekHlH?=gPpEpCK}vXEnQnSpI|=uiaREj;yg6XBWnW!D zQ;|xv^NL1c?!C|Q-Xni&MWu!K#J92yWlSAvww5*epQDd(OpojK+JMET zu}tYS$s`LR65t|_Zdv@QlXQ7%Z|EFA8XSqNBQ^KWJHe5B$%-1Ai9}7g$Ryi-;|!}C zE8u}fZF_nDW^4V4xB{-vzF7`{u)?7dQLPB6NDDcAlg(BA2oyf?oU~NJ4oIeRPts^B zwXpsQt16O?Y4WD;e~z8K0frW&JsBj33{yloh#Y$KP@8MD26C6_mjhS!1uP)%ZW1Yb z+7E7=&3TJ&vHpa3$r7`>VnXaq1nFse8wYDK!vo!KvIP-FB9^>{G!7HhSA>d;oK&lj zEhwzn1)J2so)aMoE5;G#H88m<=VaYO;_`7LSOny!8iA6r^_i5ID3)vSj=%V9?rYMu z5Q>yR;Tq+(0D4zgFr2wQ4Gviv2#H5p0sJvD)9bP}@Hn{$J{9JoA!74;K>R$Y^b#f> zzHg=UY*}H9$ls`%?G2pzT#n?>oPHEF!R}a{6w`iIxCIu-fFZ-aPs?hY!uc37T;a+D zBqZ}B!|d$={>_=IjVokW66Ts4L3g_M8N|79i}K+CAaD!%G~K@#K?!xh2pZQLV!Xpr zldqP;B~0FVFTY$<;${W#piS;$jQnvp>Oj2x+3%Z4S5wZhEU!C>6d}88LvaCJ9|HU} zQB2Wi!?f@&>e9a+C@yC7qHO0j4=PgevdRA1F*DW-_mi+64KaC4F%sWIatriV*y*Z$GF5xE1uB#i*9Wn zS4U_EdhY5+hS6l$uyZLlsfk-mI>bcV=X8-G8VFktO$V?R!Iv<51cKbsoQnpEXjy7k9S@*XXp4cTgotf(1D5#b;$d zYR&xae05DgHW?=PaVXJt&c6vlI1FbU8){>QDv)fGhVn!Ne-Me2uHJ{Dm z*JBm+%KKv(SW+gLWO=Wf;zbQn zhOB@8jj$*^4omvF`tC58_|--2_4C%*E@g;eQktTB+yUuV^hDmE{a)XsEb2XcPwY2~ zbOrmd`P zeYV+djs7FVf`=ORx&bs`ObTKxC{Z|%K?bePk_}~L$<+6kI^iH96ZhA0%h559i zLbwKD{S8KSez>w@xcq_c(7Sd^`#i+&`HQ#Sk{b1kvLKHuk$KTtdnU=mQdxX80Sk(v zNP?aflBphRQwdvOH?J2w*kmlMOxRJKfd(@{^8FzRsi_TJpKzUd;P2-}*~MlvZQ+j5 z@G;_PThj(HZlx4oRPs-=$J?zN^5u;ghBGOy7C~x86^dr$Ij41AS4Lx&E2QI@VgHz!qD{@)+1dtU~W#4QF2@&{C!E$!)A&bR*1tqAPH zEyG?yp)EUjOwcH3l`sXSSG;YlXkeFD9D`80Lx7xc0qFSKFBPF;;g?W=t5s}GVCgos2(NQ$ zTBF9r@PNA?&V+%hTZ#l@sAiVpOob5qbW{NjLQ_T>h@Pg!ViI&yRv2)e=Rg1|fIQ4- zl{Dsc1x<^cGzT&jRM`*94aNF=hjFMtoxGPygMn-3B>a^U=IY}rFVSD3$GEunP!f#Y z5vcC~Eii7Ac8)IeiaKMOu*T0oGPUuwPuOE2N4 zU$_vS$KBDxY%heD zW>#k3^pE8gtmGYhVu?*HpvAiC;cN}6s9+`jH}X0JtQmTBoYP->7Y}y2URFoiko8_4 z6Z^y1$$b_XeR&zX0t^Fp;f=x==*vh$E*9neeB=^-=Xm(1FL6LMaVTUbKO5*na?L6V zU*9*POX1Z?^o3R${jzW!bWAbH*Io1SJU8dOw9gzIJTZrKZTv!EcRUNZrdkuzl50%u zfwx|Ngt|8S#`y+cYTpPm9r5RHGy#w_Bua%4clh07@;TXaZF1?skeIlhdP=unFv9kp z4^5N4Cg9Am%RiwX5kJ1J`D-5%|EbBI=bimCXD949>|&mJXxX4zCAFm)rIRhyG|FG$hKKA zHPIA8rfd_HIu-B;#OvSPTF|doh(Nbv9BT|3^@E|?;;GHBG7#WB$)AYM!uqM+Xdpz6 z`(4fycSza?@D3BfS@R}JB?{rtz(vg2z@w*+an36B1M4++pqTR0f2Giym^$iipDsal zH^nWCGKe?`Y;x*4C>Y>Wd?;Dq+)mn@dqe83$n#-pa*&sa#}kEluSa>3mX+v~Juuc8 z2E4*`w}GLfOf*SmjfEV%1#U`iq{?r%-m=!>s1|*%Mr=3B+>0-CRNA1-=rmsq>rR4r z9l*JWUD=cCmVIQfP;9FnW+V}@WB!T@LC}kK&e9n?O=>R-;qf*)X&Xm35TqoF>FO>U zxv=aRpbDlo&3UzIp=afI;561TNy?qecD{MY~4VaAH833wwWOCoVZ8NYn|<(wIo!2|ImPvi zg(F=Zlprbp<#f{P_|d6zis3`Rjoe_!)VJrkDPT0t(_)ji0zwX{LEM^mc0v~(pY{;W z2)Itr_JuDno^)T5x6B{O#xqQgS!6A6*(xH^_(P)jMr_EV@%?sqA6WL#(>1VB*W}W` zeG%;yg1mED9Y&do>%+Wk+@%=w9t@Bo1H1BLgskh3*Ei6`ej=5$8dsH34)|ElkV4A4 zeOEqC5!=xhczwz#I9Pjxr>9VIr7-FYwpCqd`%ae7+Z@+=k@nW5Pa)ZvHAS{ z)^b1(lb66D_XkE$H(PilVsj=CU7GDSdw9bXl_MTS(QXISi#;eh)~xc^4}%IA416rB zklEFyzcLj`?Yg0Gxuov9{~0`HjK_KRn63xJi73uur8+Dw^d=Px_Ib9wusD3r5yxoC zt()8}pIcO4VLX9&BfZkAU1Q#RczOfOHzDq$Ey&+MDg?o5K|TG{?b_Abbe)P#%{d34 zJgLR{XY1KF;FJR4RZ}aoTyNAg@HTF>J{)V6obf}B-y~zJC>Pi@(`;AYg_ca(AuudZ z0D)yq4Iu$Mgprt>HTgG#P;24*?h~cMEABeaW={zR7H@m|O_S$soc7xw?r|a*Oa9+7 zaUxh$FkzFoeNj7YQi!=wnIj?5#AC>7jZu z^F}p&g)~ey6PS=A)NEvN;FL~g!KKoU@B^_Ay?sDrZK#cc07Conxh2?M`xKBH-+9!D z68TolJWlS-0~8px4CmhM;XG&VCm9s;=5Q`%xe)a|H^W~ZyEs$oS2EcsMq0~D7a)g@WsnvZo^3!esSe}Jl(Bo6*gSN)I7=efBL)H3KC0V0TP*K7i;bM`m&-%^K%zR z+3$OPrjg$zU8kw41((y1t&LJ;W`_=Z%QWLhsOPY6#&pUOsPwflZi9$uh1Dd53V@tC zkNFGkYzqZ<`_~hKLC18bpwnxf(u9se&m^;q0+)j(35SM&NhSNh?8*A_fj7@|HiJmT zE8StF07cU3{c^CtHs-TD)nuf(4>`mP1krmQPll?nm)cBee#S|OW=M{5%v}OEQ-9FJ#-}Z5)kV&7b;nkF zN%eECL`|@4LuO2T#oYm`8NO^rw=1!0vtFSYd2&G=%ZOy3{4v`vL@VL8TjgNAd+{qknE`Edq?bV?Sl z?#dWJ;wP#I=3l&%!kmXw{oFt5>lD-%6t1NwnjtS!LE1RN*WXYH9>eyI2tK^jvKJM( z^w*;IO*1HW9N@>>GnhSf+#{nBT7WtYIrHOK z#+oHCFUjl?*kk5i7?h`b!7yI8d$oOBzRgt)CY{E{LRKHz&qZ^e?oJU*zJ%4y z0!6^{RKg7)ufQ1KDiu)3G8T4Y-0z{uW_acCze;scK$}KpuDH6qDHH&NO~?40RD3^e zLTP5}lh=8DJiBAWeitiDUt@q|5M8;R;|y zrEk|CiABB5|16AEl3XS9gxzcLpT!?b)6CLSyPC(1qWoB8|7E$sBjaQ3Pm$bgU=e4V z4{9wLM`*je@V(MzWO{ib9f5YJgGG9esgq*+!d~`GRvPP9W5x6kg^Y45f_!J4zn2-du-QfHo=3VP9V2Z#Y3Y;|5AFbtgF(B_JjxA^uM^zmPTb@xI9vI3-&0P1j;I>! z950lTIn{BnmaH9gej%;`HUdos2VVmL1q{!2R;$Nw!r|V5oZK7Rs&~5T(kOH!v4iKe ztV&!t0)FHziQiN2Prs<6r#!%0E!^UF%sR*GXs2%BUDFq5S@Cvd^;v~f(RK2`xV8{% zEa+qZ5pbXZ>bZgvSLBU)4Y42Y*KGh-!Hzl;R@`YJ8ej?s1ITWgbD}`Cl>sa;i>4?} zZU8Yx-L zz)yr-hVXbw8_yg6^oOUsX~A_m_Kz~DO5u_lULzGwuof|*e)RoOQL{0-CgXH|#Wdd; zoZEy;6Z5`{&z3>g)wfd&noP6fA4=~e@D!ki<8f!F2OBM?Tmd!?f+X9jpQIGoGWYe1 zWya)9X{<+e;KLTek@T>bl;O&u=n9w}y`3J{*cLlxG9u6qusOTFQRxkeByz4Jqa z3Vl$X+f|J`$}cazIbfGFXKdnwPo#&<6a}#2>W#l0mLU+2qm%~})m4NC?rW5XH0uIh zG|qtMg#EO?gmpO@Q=!qWB#^{^uVlH`9vHI60G@axbW$nK^v|8O{#}^0%~mQBIHU=Nt1|-0$+5z z)jIP`U3YRa?4aVQPzZK}uYIOU81f&rcDGrm)K{?!TeyifH%MqbYAR+k9aZ8PHQHd9 ziVwbo63w?VqZ9*N+*I_d984bhzaU5r*KntavOZYa8(M^7%Q)(S<;`!0`RGgE4jPpR z_PaJS)gSlYJthd%K%E`EeG(aNg516<08fpoveba{DQM6eN%1s+t^=TIw zH74lh7?^0XTN|h@$Mc<0*8X%5hn@%D@<1*hrNbBp%X=|U+<3*dCHsVcu^9;nKq2dc z97&Wzv1P3KsB8f7wvC-Fu1et<*1MK=PHWUHl!(TscwR{#6?c?wHsgcFV?x-Z71M3% zN9@}ChOTpRJ)C2JDsP1-t~y9wO)-BwmtQ%4g`ZqG!aACd2oDouqoods+a$-T?xCtE>dlaXg%}^x5!CPp zUx#FN1%($u``+fUwA`iwsH%cSFSlqNxZ{BoQ=>oxzGJm6wC0Q5N}7hZKdUCvR`3wA zYG_|F;bo%>z@y_@&IfAISU*+*M|6|zI!*k@3VQc_ANFcS&B*bOUR2Pcj&P*|WGqQI z;@{2om|0Pa`sBx%*7p>MawSVjG6-F0?ClRN#FES|`=F$^J0bX!M>(rhuwkTh(kJK?ad%f7(`77DHT*Iq_q-G$iv$W^+v;H%eK!U%2l(hshA#! zbex%6&HnfVa<83&YjBEl>j+TwYS}JJO1m`ByN-ogd#ztnIrLLDuAg^9j2^Ai6k7OS zU}yM$t0BFD-|3}>QI)wgbL4o*oYHq^U+ExxI|^Lz{he|za#4WhKyHt~yf%WbO;%|s zR3Rj9VG8K-*m#eN;r-G1QY7~NQ$2G977KMcgu(8PSaIkn>OFmCAzfscNb!tFQC5=k z2U5s0DTr~G{6jJ(-T#9r(jALbi9_U1aB6eaT@ZOqg+B6cH?1tNg(9Vrc*@0SM4;Dw zSE32d;U#u*iT8XFGVj90I5^t0I(MvAUTBSkNZ?$y1X!^P=A(1!zs8g{1TM^RIyt}N z{M;=sGze(3B6yI3`~*&rWCsmJc$iROKSzaxj0|Td-Y?Kj5^IaW2DG%HOpRTPdRvn+ zm*7NQQ|aHFlf^vIY`fo9STU|Ue%TOt(26^vcj~IxDxLvalXS_yYB>JHcQoA-b@^a? z_bG+W`nl_8UG7ImiM4*yRdjsD&tfIIL*Ni>{?pIJB1gCs4y!tr%=OiKnPebuLU~X4 zS^{^{G+yIXV1A346fEP#ToBmQETvA5Q)mr^gq74wXk+9>oX&-OQEL4kDKElaSSLtrH2o120zyRx6zH^0v+d8RHo=0VB3Hj~K8d*Nvv`B^zcW z;ZYM%+_62DX_TbQca7;fEZGsetIfTErly6!E8EAwU@}AjO|gRz>wa|vP7Hg=3`u4j1>CXVEIdR#3E;&;*ThL1(#d=P)d zbtA`nOrwC0-Wx1h9xy9DNDhjO7z)f&cdm*{cr#k07D&b`PzB2Ahr##4& z1wp-KryIZO!r zIn5CsZ_IeEGeb@DC#zm9$St9TEazWqQK+ZKD3Z#RG9LF$N;K&pBLkuHva;G4o595$n#iq*15a1Rr^Pz{V#LQN*HXW-p1oiUjrzN18TOp2;`ylxgN z+^8I%+TtTMi`Tehtv9@i{qbzFzWHFltELQ7!_A=JL9K_VTR5CjST$w_TH+dN(YxbJ zX<-!A-^VNu>n9RyjpRjp0Z;5;2Sv#<)Ey-QPCE5RpI8^oY<<{rk}BltIKkIZ#ExBOhC*AU5Lf9>`1Q-z z9k6K3{W>6cgJLjG)$qGhwE-eNPSGV-*f=b9d_HVz)lH;hO*Q(O*;D4&FTrDD;geC8=Z=A*VkIpkf@M zItiS4FfN@9XS6fdtFTWl2(#i$*GapKVA!JYt)J-5!415=reHG*so&bMIxL09S$;WMCY9pH1Qlvr2r#y*~@kRQ6kWwN8*?G+IUm4 z_5rqH!f%IxmFj)&oV-{_7gshKG{3+t(l?vPFzRlT4{L|tm&<$MGYWq~rqmK1rG_|r zFZZMZ!-Z^bo@VSiuK`Li&*tU!r*C9~tjfzJ4R{frL~;11oM3WQsn0YM$zE|+!2<5@(1l0BiNY915TE z(+6BCcXQdRRXU#RmDvMcLJxkbBy~XS2mPHUR$=7lJDLh5NzCMN2C-bhR=$ezOPW7tEbcDh^QK(v-!%wQ5g%WFT` z|a3vCjp3+~mtrPVtG+2bO z9RI7p#_Rn8R%<(j1xY+_G|jb&4iF#gVlunOx$QkZj|7D1yZo*)&k7bLS*y-=Sw45^@=M8_}Azr=P`ZR_pOsk2oh! z^Trz#)AMTwr1gi;DJj(8@nD@pW?R9wmx<_x+6Rrnw^YSL{NZv(cthv1IwXmPRUNHG ztb$!HfJ@}h6SSUp6p^z>8deAgVZt^p7`y$*vOW|>zwGi6(B$zI-0}kzvmbL5gi}^D z7#|4eiUOc!rT`K=EKCNNN(iAb>PY23m@$lflk_#^-b5=n`om>esLuYIzg@kfXZ?WA@Vye&_|) z8a>x5mB;+;);orbqI7a_dPg(CSs#s>yo@>nPeyq$pWzDRy*_YF@Fm>88jCj(AdYKN z5#pQ03g4KIXMVIfqq?k1*~@!AD&7yHz;4jHoy8>5g#=!i?t#GA9P#D#p&?GHm0ghE z%JwT#s~jhvbDs?{Y`#|#H3pI$J!kuh;iL;ks#Uyh_5_H7Z$T^OK{m+{LQD|hM4q41 z5|c!bS|e{pZ+%^_ zEG|B?Fp)i3^uf6R8Upr=hPf^P**0h9Fe*=6#?E%NB%-l|Th`;(0hHb-vP<4W+MW7| zp?8ugoz}oh^=8#!RN08JAIv5%jV&gEFPq0{aXoR9@zjW5@(~m-x1gkONve!k*;W(!Uxy>Dg@E;6tm51*TA~$Dqvcy7D>8cSs<$`W|eKpkR>#N6)6=N_$B6@s@u6y}bcRC=Z^k(cc z&nLh7C+O+D05=8Oxq}TBbs|L4H$LNig1?}K&FLj<*;p-xe6l&d5Wku{QJQ*{J5Z@M z@aIyp%qYBFtFgirdtg{rZ6i>ks5Fxf;fRXYt->+l1Cx=6Qa{T#?PQdX^lZjh$0HbM z3n%gF?%4V&<_a)uXc# znWG~hkEg7Zp23Z*sXv^JyExgk;zt*g$)Qq+9H0O0LvuLIBAd|O|Dil`Z79y+dBCX- zWSV8iUXJZpGLK-trw$&;XFD|)qnR1lE0=757U7hBhcs4;kGX1~`2cZtEkqrr{DPup zU#V#*%20U&a5W=rOxs2{9FeY1i#n^_{T19itdV@oP-Fl$AM_~#0Y)v9LA=|huyULe1-<7(RrGV+kvTb;wmzrt z=+L$K^<51?2wBHC(tgdn*E`0I= zv-RiW`0ru2iU1=7uH;IycIG)eH}&+B(gq%-zqpgy$B+-7v6;X4LWBbL4EpmCjQHta zSZob*Kh;drI8cw#l&!9B1q30JqWhK;{1e^%zn~fn2RI?6&Hi}_uPAzn)#!izIsieL z>~62FTaZ5SsuVt|6XuhIU3OHpp9lMc6hU5wkYI^yMlf9FJ0%9fFCbJlIqecn%zVIU zcVKMbK5E2$xF*?elkw#Lnb%a4YJm5X=Nj>UIUO4aUE$@Q4Bpl4ETYMW{YyElb3Sff&dAJ2N)9RQb^O6qi{&YyoL1uG zaZHYV&Ql_D09+tM!zlbWMyT0uP^SYf7M+oY0v!)Mt{VSoauYm5&)?=ZQ^TZz>E>K= z`ti~UR6!y??EIaK=R}l8u!ldULt=YEB0hCkxOE-QFIq2<*1lOJh$_jmcB`@{d{{kH zb4{5#{gHVwe;!x`9OvU@l3dzN5RqnRt`{uX5^`|ZHv@Ge{2L>5GGr{*zbJJ7^uI1z zJ6nEaubcALuzY7BIyzj{7pn$pirtQU@yBAiRx$GZsC;BHI*Z>d4$8G*KDyjxN&jiV zB}dAcxd(B245aChy&1Y(b#cD~N6vJ{jyz&PAFn+E&CI+Q-27P3>8Y{>p&q-13@X=` zFx~=lU0;iWKc0WI+S)1hs=wlW%?|1oSEl1am?4QKyL6r9Q2*GdK+f^1`^Q+n`pg?@ z$_!Q2Bxh3ivN%*y;}wR)*ge@o)qEB}2VmORpXAdPF`SlRO3lO(!uP?a>40Yrl53UX zSa=EJ7sW+_PZ1R`QdpFQcm1-&lAemQT=<$ari_b3sv?1hhx18+BiZ7hpQ0Gfv$|$V zWUvTYlORNZ9}DXe$-FTKToHndqmHP0a9q-}(lLfEO@w|K8pVA^Q-d!NV>YzHP2&7$ zs9H8B_b~#4*2Uv#_tdz`un=Il}Kli)=v z)h|wLND`%!Th{HrBl5-`R--f5PQAOZ2jj>bQKBsq+a~f@{(Z^>K?cR9 z9=llBrBSigIqri7oBiJ8ix^?^hN_&q*>nV~Y7;|#W+|2}ohFMsNR}}u3a`gkYY9cs zsP(U3IsY}s*`AWF@mLyskx-KjAvnBQ4T$ySo6g`ZPH53S!F+-A3)TPm|Hq!la7X+qf0-Rf)~Vu%B*2 zaK3|!U%L#hqV_#%R`~D%MK-HcGq3T3h(TYH1~>sx%E&d$J~8P?0w;QF=x!5fvaE>R z@f9xS*S>OAB>CxJ1`L!D$*u?GRnv9s@?@m2J~Nc-lB*lI>Xl^ND#AHiQb&x}>2Gxz zOR7qgBA$NBE$NZ*j_)MB4JwH<+&O@MYaC-1!=NZCoM{exhOU9R%-#W2X)3al0%QjN zNA2kG+I-0R8w+*vW94V-wG7eSpSIC1vyI7iC7cLhOy_F?gaS0HFH9$$&rNHaBl-Kc zl|d$)EbO|-blxA@kN|X~rJ=J^kyXl&*ilPpQ%6P&EZHfvPiK)ghcFPEkeeq;is^^0 zAo!v(Cj~sKG68(e=w5B*_6ndLAkq0Oo#fL4e9uIBT?nmk!2^>8vIzG!9%WvN%|7^> z=vKl=Opm78xafpk!)S}Y^g~JR5l-%Jk{W`eR?wBW9;zRGqgO~%YnQwi9_=~jPvs!b zFrVe&Ci(m56j8pz*3Fbjk@|zBKOfO}TNez9Zs&-G^~C#Ctj(;nNE{R_Cu%6;xAvuL zy}XL(>iNg^om4z-r~zxY0`{Nsn43H;E0>dkg7Sh82>x(%18b>CkpLp>eqm6cWexdt zwS0%~X(yTXEUx*CLV}^{67#Z_265nD0pXS+XFHlxm#c2#nDDm#iCdJAL_5op)m?Z; zqE*X&+^1b*aR5Miwo@Jr zlulOgy{52#Ba71s`t<5Bcn%W=|DxwD1l->Y7!8TVJkKV$y?QKSM?*m2xKEe9%UB(8 zYd9%rd&S98A>8d#)O>n4

w$Y-T?HCF+xz_{*ab%L@>7zgw6nH)YS*K2e?@Qn*V?@!*u~J_&kvvKtN`*|> znS^wqrynBIe(5Ol6K#xK%NiDFE4-}O^ihU+Go`F+b&k-XX5iOB>F@C4(QH+>fz{6h zn4<0-`M8q;JO`bSdF`~SxB8^0aW|TsPnlu4d8f{G{Ihn|&XOR(JSXbCx@e2@(pzVW z$ck&kkj*Ys`+~p47iQ9jnw9znS#coadrZGDPX!eO8J}c~!PeG*XBhK15hf#p#{FsX zbyPV0j;laPj187{8A-8alksB^m5F-3B-;Yx&I6aHz%&xF=c%(!aXEG z^K0FgH z>U_)>d_Y~#nkO2m=4*(SAS1;L)v&?}qbr9TJ9mr|8&g8i=p=`0#&>o_D+Yf52#PFE;$7~1#8tK?y^vyCR)#R(_ozQ+^?4s0ypDR`1RU$C9^g}B zb2^jc&K&cB3JQ=wGojYWuV5F_9w+2)h=zQk&I+9!`J+2Kw^6nS$ocm~52uRx?+2o| zcTp_QJtfYU+{-Wuxy~XTxWv3=Xah`1ob{PonilxMi?jIJq~wHT_xn$eE_3D1{epx` zlwKx@f6~4NwRo}(uTPud;ITu=eBAOEk>1aE0#8D(yZaGw%5e`(SYDNai=(B7Z2DWg z(c0F!gV&20h~KpBeSeRdfg-G3RHlAnkC&=SfE7g@{+*A!kLWc^--9oc?3 zPq@1q^<>?h^w8|DD@U7 zs{*3T!DEU=smQdRSw1rE4mNT2=cNN+tByii83X<(Zt}K?k&)6H;wk`(D!$IeywV^_ z3Wx4nHQv!I(xWnL**aH6TQosD>Vl`z!L(3IwW3s2PT!9}7L^br##G;;uEn5n5Z8x1 z+RRwi@DM%m=P=lh?CS=7pe{G5*I->OnsR&6xoZV6JandS(B$RDQ0K9eupbfL`7&j| zEnH=WF|OhjK2o{-f8^LU3z<;%5g|zoLPmdPsvkgfA=s)pR9q->SBs^o(rvpR+%Hy@ z@bgPAFNpK_hQ&{7#uqaBx$=5;JNRw-S=XKr<1$B5O2(TI-J0G!E6^I8Qx5^Bxm^NR z_O|t<1xK#C^19>UeaAKpcQ$V-ct_Ei0ZpX@g*67}ay;6pjXvzXJ_(Ffqi z-Qsb5S86puV`sKJ{bZlxHz*-vZO&ST(->v-+5gZ000004XwNJF0YY+brg}W$)T$8R zO`nD=rIz*@J?FqMhU~H@)qsC`WPlz)ggHIIP0PHCvsQu!BS;V85~XWL<8wGp*_X>p zt@4{d1K??C!BczYK0!c2Wi_{*nRG2f+g`w7W%OBYGa)}Pfe5o0sj*^h(vV6AVD3ys zqT6xWX}`Y#!nn+?+MbYxw#V$FLJlimTX>UE5N=qPAK@!ZkpzO)YcI>oqD>&qD3YkV zMSF6>NlEqbP&&%8VtX};=SfCt3E0-!TRdJCdynepjRrEi9Gt1y48miSh6NR0^i=i*N;wOPlkD zYIigWM@wXK`G<(qFG=FLckJ?Y*8XyQQaf8?0UqC0wh>QR{XVGV9G(On;bKgRbA(=k z6V@5WJB^}ybbIChP#-1kIC6V}-^BJz$L15uKKm|>TlHjpdmsLsUXXnr3h}o_+ddGT zHUOyX`uW@UJQteiEbWz+lU;8%W=-{XkjOu^DPd1rgNi`|Q|u3c?_Ra`NIF9w8`Mo3kDd!RnxWCY%ri;R47;ueZ2UHX!sD|Oi3V7&^~xkq>AJm#km1uP%lgW z-y4Owwq|pgk7lc*cWT`IsV{H1tb#Aq=8$W*C)zcp3ns-}tXBx77^uF#r?XDt|58Qz z4M*lj&-@PCqxBH9-ENQh@9P3y9a@oODluL?|GL+7Qp25b%+Pm-MC)IYKz{L>3AO^~ zNM#slpzA@w1Tlv9AzRiQ>K}1y9e*H(Qwr}LVO}?+Xc1A9?WqsnAfVNM6#Vg;75<#* z4D$jf1Hi^}Ng5fC>2W-N$dhRGwAgNmyq|$NISC*EEmMP#O{Sf2n7vgBn2bxl<$yhG z;n5Q4y&*FHXb`E^bP$WHqe6%yr7QqOIJ-_ai}GmELD zA*8+4ss`lD3zt4KZP(#by9gHF0|^WjWe|RZ1Jh&5V3$w&o-9I9Yvh;?|L8mVbDZhS zQ=of)TF%xG8-x26!Q1<8oakphAFzs*?(UBpU-BJOMwHC?1Mq!T0j-_CKehZ^jzsidK9GKJQfS67o0ju)jv>J;;Jg_ELlO zRCZeyGv69XiVYU%+X|Wq@>yD79Sb8lMwAbr-YpGyxbj!D$=o8{S2+|SD{YLT1o^SkX)J$N40ogVsv8REp(jpv^?FvsARW0^)mul z?=oU!N{_Uf+7K)|Eru04V@>o9Q|qw?#j=hWnBBPQqG+cDM9*jCRbIGK6O|)R1!(rWAeL2V^y~18QSX&n2ujFy4^(0_+DnXkFqokVMdv^%~TkMOJ^U% z)AuP@QUum`Aj^Sr(a<&G6Wi;PIRm;!iyRD zvWCQlgvb?1B23CZelal;!pqA%IK?nRQ{ z;Zf77Td+g>G^RB~1%e_}21nYao8xB&HuUrnDNVT3{#`zTjqR(}5|UxZhG+J<>Sobg zGy67%Xk7o?CPjS?*Vr{xmV-JR8Bu4P;m4~OV|KT-P0RDHjcGrh{!W5Cai)VkZMc1-iNMq z2s7u2E`He@_2gcp+Sr;Xefx{va~W(xmNH0{UMLg6=Kb(z`BO0F*ru2P&%VZ6P<5+( zPF)Zn`3zo(8l~4eD$0WZZ z2nl%`$~UYfcvi8X@UJhHjVJePt7~(Q>4Hlv)YkCN0Bngs$fUIeo$V!#HcNrNaoz8a z`?!p=_yo5wLJ?abLiFI35QLN(`Ul|buzg0P6yDHQQ)tdhJ@nl`$w5?9zeXGhbBXZk zV-cH9DPR#R1~SB^RGB*Sf58dtCTW}8kex6=(@HIN18%{!qduqN1wR!U1K^^wAQlH&I`4=dD+5;pg_I$g(q$hjwi_ZQ!lZmgS{ zmBqvVe(($Jf#IqKp&F&6tD`(opH(8}PwSHT5>hQUwm^mj01*JM7!A$uD(+^M51<)} z@jBzq?MQNdvWjv4bs!oX2}e*lgyv#kvA6DdMJ34tb*3R>0xxz@^R@cEFv|jG#2MN8 zRJ9~MdKg@iCTrqtu(2rKnXi8uoC{B7Dm)JKn`~!SuW5o?^qgBieD*V=9V@tTS{MA0 zSpq-fE*%}{Y$!{-4Uein$N*4lZo7;2fc&7huPe5hq=xVZjc6jt5Xi&${^hOH*^G?U zZnyY}(NIVGX`;;m343ZXc!Uwgrq4b0Qb!VHn^Z{%;!OT@)!G2bSgk8M`LB2l1* zWV+^LZ!cFZ2c_yBX^hEI@h{{-@sH2XcnQHb#2|T;n3Du=455D=!`quXO+JFC3HPI7 z*pM*KSVd6|3aN!U1Feu&tViP`zjyec4&0egtJb&gJI`-AFes7g(&rMX0E!0pJ`zr{ zwKsiZC##QH;)-|(baTIv7o^#88h_zfQI_2GrT-Av$atL3vyw?pOJ{OUsDOQ8^PQu?bae7J=jb z%sly5+`k_=AjEaM0$`w5x#+RpJ?vB@ib}YNrk~Jqd9BJ&3hA!W`@^EDm$zFdi+b&B z9#&@<4Z&A?ml{(AVwmyXj7VQsC*PW?hi>V$co8d)bHB~yR9wZ*y?;BJI03Gpt^B|4 zr3;4rxk8Q{ZdJ;YKYS8pw#h=IsBEchrgO^t{AGyiXCG+|a^rQr>&01O_+l?99gViM zbf2&@=3Yo#Hwf+?$!DeB>tGRZe{pGO-8G=S?|;uYmuW#Ugt;&t+XS{v}Gw zbf!<9(gyH8Q;qF6^3Al$=7|o7kL%Z8wUrHpC&KU}K5m>7t_n~LYnbQO6Duy}84wb& z)cXql0yag`5??%uvIi-Hgg03PC3Vp0hQ4 zNVcg^u>iwpOY?Q)*cq137->M2@D_|OeXO|xxY6VLh7*ARbC8ek1A{h6(U4f5{ks0F`A(9!bpvJnehRsX|5=oF+!c%Yp{JWXu&#D`qU4^P2#L% zv+{#PibUFT$sSg5MO)VKoUd)tc=R&MUi}U+)-b`e&xH1sNzvnd3|9b-Oi6HM6oXZa zE*^(U7Q*(Z+6DxhdHzP^)rQmcN$itWWJMV%>Vx=yb07yLQrev4@R}xL73DxDs+;T+ z&rR}I=%nhjewb7FW$*p*TWi1ui;^-ufdc`}Tr*4BRfHoTgQM-KzqX%7@f{xa+>}Qa zC@e=`7;f(-6oPCsK1*=>sa?qUq@;b{qpzXAcHKO%EqqF#ofVzE?6z7U2wyUB;j;vM z=>x1HF07O-p#VR?RiZ#JnB-{PUU42Ukv7>i(EGPngt_|1EjQb|wh^9dxxb#u^ zhbrWHiBkTyJ)+~&sUEr1!C^SMAD1=MiEtxW;rjkIPgS>q^tr3`;tiQ72F_wbnm413)=ApWf@>s#c;d1u37eEVWPg%uDuqb-xRx!EH@fhKS|c3b6QcD!DW!$a7T z2F;QTZrW&)e9;=z7-mnH%X=J}Fl?hu2`tE8uf1iBYdE%WZwgBgelKhID{$;VFpb9( zS?*0=xAZ7QYlKQqIgJ=7!+LqP5jy&Cg3Ml=8W#&fMayv2<|8&bQ0q@drZ$nB@cHmzb0Ey{WQwjyJLmr;$k!(Z`Q@4f7js zykv>6$t@(c?z|8F(;@hw&2XZD31r`9qj1XdOR@?TywVQ~G?QT628%~~v2Sxr4#EfO z=kc2xm$>Y$Ulzc0=h4!YxTi_lsq4IC=xJz@KT2?uPm;@NWZco zCTJw>XC-p>(ZX-1$2XZEx@zK$N23zRchH#oMyT~#AnA9SeRBSmkfHMY;O)q%=FY>b zQ@iLV9H%akLn<9NZ4RN2l*R$h0kI~QZSugM6ceO~cs-z+tpKmTRE=WqMeK+32hUUi zY%WT!)jIeupsCC<&OPN<%(~ZUmQ>OyS9B(*=K19)W>;kC_OFUOm=cM|IL3T7SeI68 zD#;BC(75YDGOQ(*4qoexenR%uh-Me_B75jPw|x^p>`H(F6?`ybdYY?dAxGca-j`9d zXlPv4%|c{9j@Xx@-9P{U7wY$^dbLy$zo(M8R0_cM!1g1T_#$p#-@*z+nrJTfuZa|Z zzgOearB*R>2_KO6Hm7I6>XP$!Id!luxn&d`fNt{gvB05_&*Gz!Qy+b7)h#qpydPBF zmO6EjO1M~k6se*eDj_ia9NQK+lxa)KUFFp^^ZSpD=$cn8M8&CkVRu($*j zo&_nkoN~*B+h&EH5#UC+x-AmGd}z$-+V0CCsVzBT3(9wBm+jMQLogDmN(6h;W|? zKFzs18d+!JVE(1KCm}2R?T!hB0epd*5ceHm5Ro$DiD84+7TTU?7>ibDp)D&ywq8Ql z?kQ`2kmp*`i}aiV5&S0DTZOrmt!sMv_y_~|Hw#15h0C5#+d%@kEJ8FZA>vzkIxnnV zfhc0ku+r-v`T4J)|55Zs$GRNtP-;&E{(ZL!e}=HO0Mnn=JhIzvG-w=7m=+xyA8SE! zJLsuu;KQkSIyjYC7B&gzae%uL@oFjc0dK}3q!$@LXNOxecA#GHj?VL_$dHr-8ZKuu z4UXj_UQ#b8q747&9W8O+b39JN@6NLWzQyXKr?d1K8RVCbUe$b9n+8Z7q!@-)MC=8$ z+<~MmdL@H>*h~BK{JSv5k&8sOm>z9y{1BaYSbg7b3OL_t$8_ z)Sfm9%Ezsu?lbW{qxaF(zp$))M(h$BvfD;=J!m4}a)acGSmg=)6AW;8`s-fdxA1+j zU+Kh8BY<~A7+6%kG+=$F?ewK#`nZ3_@!mZJlUnty6@}!u9}+YkFK2k;d^q6rF`k3K zw7^hP&7><1=`bET$F`g5NT<{F2T$85s#3IdhL__{)Xxpk(d^QY3 z^!RRBj)L78{Mn>9ab6bu++qBt$O;?)UNB0Po)C<+U%Ul&e5(E|d-!Oocls+0t49Oq ze%eLly0e!+5IPWn6s%1sxL53~+JT-c0HMe4_Gh?D0I}3v*C=+u zl3TZhNWLP*Kd$Oi-*nhi?oo)15mJ3WO#J?H2*Q6R;9q6+PKoTcOcB`i%_MF|xao@?u99fEcKUwRKk$zG8G6cbklzawL50kK6uAf;=i(;uqKwf$S&L4pijzxRx*9nEB|zp? zPbq;^0C;Ztq8r1zV4Vc4$L|_XuC}#FJ*=>BECs~3c&x1zXcy*)=MlNpRGllV`r)^~ zuZ-K<(Gf3{rKdDg&G=9dWyu;n>6gH1$)hM^9={4vSr+QEYSLj@;eb=+U}PusmT7rl~{He{#WWGcj?85)!)0}uz67T>#?`CcVRhFUl@vP)dG#Kre{gJ+rdY$A9=FbjUzmGt=id4Rm%8XST8!6W&V-iu+ zTFcEjkkFQb zXXmWaE(?b?Jb$|ie~E%fhOM5}1K_`^xxL@txg_DBKal@VZ`;+n3oEmN%S zKi{6X9%trWgq%F8IEbt=JJ~bd;KYWUww3#%8LwHJ6BUzXhY&<9_VNf^iqp_1p+S%= z%H$H?4yrv`_SKz*1l>5S-R-cs*0yKy&`jr$)!zRQWYQ4`uK}q0cql0TV}MQ5+-IlT zJA!6o>&<*e4-)Cjzi@=3X5Z^=7UqzeKrpHhb5JNsbQo^u5ErxQ`J;sXhCfp$helym z2r8uV80vb@j|tuxB(CT?Dj6ZJIKsQ<;x~PBPWq$V1R+iJrGqN{qN}U~n@iFbf{72@Hng=*Q;x?_7YG)!ffl9lgW6X! zqGxB|ZAivi%Mr;Mzq_pUDhM;Ikf_deksAEQ4WEnkQR>&@PxBER-s|iAc=r3jKc1Z) z=!^qT|FL`K)U_A=5`uRvBQcMA}8<$;Ebpe;hzK+-O~3fLPhjL$%|vo(bL`X~$W z{#XQkmSueb>d$)ed~PjEEx=@)(hZ(M_To<(op5M3V&?;dfCwc71jJ3aW9x}N<+Y$2 zdN|E+jg>Ly<1VAjto~kO^bNx4d?q5Q#u3SfoA=T>X6dj*ZlNHz{phXqitFL%t z3?=M#D06{uy}{f4kh6-W@LGv+XIx60ZGxW=pWDN65C9N+aJK#_77u}mEO2G}Xi3O! z>HEeuJ3#s&Qdm(#`m(D={snB27|s170_+i=A*LS2vg@(;u*7p~sbM{F`Y{kMIlQk; zLvGYn?V$HqwPZwu_L!UiS`!!nz}8p-=xYOn%0T!d{q&dRj#; z9sfVpm}`xDQ$`+#)J^zU^XtN^pk(E2@qQh!?{6R>Lwq(GpXZujqdGw>>r>r_hV^l2 z+N8ytZIkoe(CeiQmV^Hd@9j3UHK$PWMtN#nFHu3V9VcD|*Z8D&X`v%g6)ZSvU)QD? zdln&QrZV#pZ@M8PqVMA8PXB&z5WF4KB55Pk$&A=EAhiW&Z7q_?qULzee0(G%Yh$4-7QK+QqgX`LofG2T~2DusAB00LDGj zsDZ=~473fNg}(20RfHP^Zqz5{!+L!`cScg?_o4~Y3a-sDH~hIqq&m+Ln_gVISfLf$ zoaPP5wYdbX9ECo++9jszEaP2O3bcHW(>CPWih@oyYmMy4m<(V4*r=d?X$$lLj+rQ3 zSQsxT7mC-WQI3QYmoJ%oP6>FYqXN;XCiAdN^v9@nz3Q1cUq8*DKoR$-&2zq*FTiC# z#DVmGXxhSA_LuZqk)8pUS;eN3BU`+yxjK~XL$)(!o6UG((5$vwxs@JFv(;|e&ldg0 zdWkgny!nh))*0LpbtCoO9^vKAs5tZ|m;bF6<830kli8{=S@RT!@zI+^r)w4&aR5Pp ztd+YcbfI*!cgIA$G7BRkSd9i&C;bEvTh!Z>B%fySJ>OpM9TzX~3_=~`jb|U4n?4+s zT%t*!!3wqu3H4U*g9$!5VfmZwh}QCIlB|`O{7VtS5%2J~^2D6?N-_nxEl{y+yZ1FT z6b05TNNYA4uaP-=K>>a#jN6({wYU0%*XqAc!NwAzOyr0(;2;V#{o_>QRn1ogagiRh zTl_3~qq_q+CcIw~kd|9E#WDZ3?8kFs(jnIL)ajJWA1%;KAyznUj-4p~{@g=AHR(h* zbBd&m8@3L`mDAEkJf~O}*@ytacUDvPVO}9~5aH~ZY+YJ*Cq+DD!u6yDwVL{%5aOTT zF)pp3cb{3yOWXMj?sw zU2K(9%haEo6{>l7g%mH2Ne+u6N0oCWsi{>fwArsW`|z7xH!dC4`n4}MU`GXa zHN0g`O4OT23<&hT^FsI@S=56~_<#w1qi8t-VnlYI&2gayFJ@B+ST$ZE5M#ifR5r!x znmE>Nl}>|Q>=lwrqtsi7nvmr(}9ETHq# z&H)Q|$)P6$Wv#BeOvSb+xA37j5j8PK!#wlRrDj;8>sw$RyA!$$DT>tKV%m8o$${n% zq2bqcpum&tJK1=v3ib=6rfQ2k1qU2ej1g|b_k`X0o##e$_mwD3wxagrWO$kd`uqLV zQ~n~{Yp1%|a%*$VG_%RwNm1wJ&Za_2iwp0-39vh%vKWY7jD7$B0u)kI08+gJIW_&000000000e)aQg+_R}JvO>n~;wvNKdVKGzm2GG8!LzuF0wPa(0bGSMc zSSpNm_x;gBjk{9)UtbZRtN${38%uqjbO46Rf_i%Q*17-y000001b6AUWnjn~nY Q@{cXq3CrGrt+Frx0I;L%j{pDw literal 0 HcmV?d00001 diff --git a/docs/images/surveys/general-features/quota-management/quotas.webp b/docs/images/surveys/general-features/quota-management/quotas.webp new file mode 100644 index 0000000000000000000000000000000000000000..e94955e3b3a76aadbf0a8ea6ce397e22f11888e7 GIT binary patch literal 26190 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 AiYr_ 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 H_elId8NI;U literal 0 HcmV?d00001 diff --git a/docs/images/surveys/general-features/tags/manager.webp b/docs/images/surveys/general-features/tags/manager.webp new file mode 100644 index 0000000000000000000000000000000000000000..0df6a364b4990b47657c84c3a80f444dc111320d GIT binary patch literal 35888 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 cH8iM7(5>^LM^`IZkI|p8d@Nd5VA9g5{rT_o{ literal 0 HcmV?d00001 diff --git a/docs/images/surveys/website-app-surveys/cooldown-period/workspace-setting.webp b/docs/images/surveys/website-app-surveys/cooldown-period/workspace-setting.webp new file mode 100644 index 0000000000000000000000000000000000000000..6c0e585dbb6c1dedf02cdd7e553ee71409e706cc GIT binary patch literal 28876 zcmb@tW3Vtmlcs&_=h(Jw+qP}nwr$(CZClT=ZTo!h&VI8yGdpk0Y{d4jis>=kb%{)$5h-=6Ac#yszJr>u%`{ZYJ+84_`0B z5BsO;JL^U0Gw)ijt?wz%6qkwP_Py?*Z=cWR2hhjuee8|zChy2^&(Gug5J{~ zbpS8fPwtoDmForYOYhz8&F<3g&~NY8{`dE{=?d;K@9@jicl&4TXY7q`vaTNQ_;-nK z?brL4>yzQB?sNBx@Ba7V_t`JwAJdBt;7TO-e))dazU6*@`|XbM7WtO_9Diwk zi@x%He}8s8{XTnoe3yT(UWLB{e#buD{_)_O+=kir2F!53PP-ZPnbMlKq;ww*>wb1q zft=1g1>;xqW~k$A2#?!v@zleTEyffl^7AfY65W){e`|VE>aLlr>nY`klhB9i+r!p2 zw$ZTpAuf>^`aLH5Sop#yw`eTG0kcCKLQ%AP%)h^xByY}tzAi%wn*RHe{ZoypMW*fe z+epwD$ZO{~nVp_SFV-JJxk3T$or1XXu%w+{92i`x|O2xKVALPM=8Fm_DCOR|Lt83*QQ zyss-%$#2ar2#W%n6!qw_ttrc(E z`~$-?dk#F$%tSH3U?|TjIW=@1wh3GITAvdJp&-Mu+4H^~{}CYa#itJkFeI zv^8T2?cV(L&wcbS4rD5{dSUUyuuaDC6WKxF*@HS+SM~j+Ad%K?#&u|^FfOuyZOQewdh)pX#i6cim-rs|S>-((m~u%k_$w!wR(#8_rtmT{qE%)aC+T8#V%IF$)-b2i|Yp4hNWEKqnY~7 zeoRL8u_K6kc@axxCfRF?No$z>gsGo?LypG)ZIo?W)-E_z_W;UuBcjC}ykb~Hkv6JK zIYV|-F<%~6CUS})Pf)&wksz^=u#L?5z!U-;>0Y@PLH$S_^#_zKRlSPY(EH8%Xguy} zAN}>2wXZyCZqs*g?HMRGxkLa1uy6d0iS9|zCeHhvQ#jr)SZu~S z54BA7!j;2=;ECCv0Bq6<=s(Qb@^6R+z(lUSnV2Ee%pryYF-D~*_$JeJ>l-W}y;&cy zE5x2Rc0Z4*M^+TNU_;8J0hL{0deUy3rOb(JW3{=i#Fhn>M@|g;kPPL(MYPJcW-y=H z;`Qz9ch-12K$R3P3~L>w-ksnz~on< z{xKEO$Tii9a*+029ea$9KD9%FAq2|_)pw*(*eZ9Lk|;^0NrXlDMooqsK1|4?9yt$|U<4p0Z>L}_VXwz6I=m@wG)5=Cb) z$Gnc6MQ+H!Lv9la26X6&qr(#*#cLAjx}I$)5>G7=v3-m>naX!41aj~%B#==DHGOg- zCiI2iGB?S>Y)7whS zFQF8){2zOeO-aI~=hEOyj;d46hYpl+IYj4bhM;e_XB`A*>P$ZIuNTqc^hP-1FRdRd z_%pj@ZVoQtj?9g%>;7lQke>y2CjcepIV>t3_Pl3)Y-BOR%6#m{0iil|n{XD0m*f1( z!m|I$+ek@J3U=z+aKTnZGxtiXK2zZFL?ZC)!ZCa~5wRP^(gMj(v|&AP1nk-qO}aQ( zu<&xf`nej&{!>P1N?+9l%SuYubrtaR?|Kj;;k1on*_zs?In^@%CVcVOk5rWerv0bVeH{{>!b`pf+gVr1@qI>&bJoGe@S`-!jht<|NEu>H-h;u z%NfUFdHlbHyyOaBxL=i#OZ6Hnlo|uresJbg*481Uf49AVf`|Wq060QOd<^UjZ5HS_ z!yul|S1t?s1LCT(i|;)DslWaYgBZZ3%vP4|WG@VSY3hB}4RnXGcDiG4K;ixX6110; zT4@54!>Zp1_#05iA=keDHxQd#;THk6PWq;eQJB?#2D*d_75U$glmC_1u?FJ#{+k-g zf?wBLh*^OOc*yE3WShO*ZEXKt55+OC&@YpX{MV%X@0pycM7Vqh37R&Gj8d9^?m%+l z|5-=yui`$5zwq3a&Ep{^2>|eO6d!z8#U8YdF!PSLpItzccx2l`Q{xc0LzG;lu_I4l+-3x4`N*Z%3aspI2OAyjOS?7}W?xJ5Jt(|NngWplB9F zcBx-)>IB)kYVa5P#l&Uh15<;P_r*>|>b7J#GL@mK6bgWS%xbz2<=zxQfEo6LR)Um- zAz1*zh`xu0)n^Uhe_nvQV~bSMzECU)$Kq&#Bg(wUvqgk~o5P(DS$aoz&1gBnXIhcs zCimIt$hP=&@dcFwd{y&!4&t}ppf2=k*I0{#YQMREm6|qgUj6sP<_cCxz93t)=K*gP zkd$slR_xIh1*KVZ>2NKiRo)&&2jwXL6hGP7)pt9ckH%* zN;M^&x&yvc7K}r5{5ODv<@J)h&IZ67RURAY89Y5`_I2LBgOuF>9NX-vkRP(a=h*X+ zUi&p7qbU};D2vJ6=@ADfA)31NaMdvg0J$M*MDMO&2T)J5@jE%s*$SXhg}B4rp*z`k z{$=kweW{V;BG!fwToiu=1HU_RrYE0VtEp^qrgU5h)PHtzce*IroWiD{?LQwG8Y3nK zy7PB#$Y&k<;SGC3^DO)>D)iI7ZtUAzaQ0#QA$`v@Q)5?qRwb<|*Az&`e+&ykY zZFEOL9Y}}BM3D35jXf8+;89I5t(3htzm~mo5h5y7`!lTl{UiFquU659bzPPq zp&Pncs;~w%M*5O++REUy2y~x$+u=Y)+#`#c_=oE1_y;tjIg?c?q(DAEyYux)j}lkM zr%MF(m8jBu%Xw{`u4w9jy^nDPT_HsnM?!@u8LTt}*nuj1ZD#}(dDXV+N&IuE!#Psu za6O&`G0&tD*`IYY7qQQJ0^swHJl#8+o)0vSV}>)A>Nq$N8l9cvrJ?9ur?!M!z3uC~ zJBRj)1JyeJ_C`C81wWrYi!PF+2Zlhvz~koH)BeG{PnMzW@6qhC%|kDb&ADLK5QARS zbDnm?Xc8)|W$dXw;0HSv5{>_OQ5`k>hGW35C#RUFR#|dm2URc3>JE7sQ+7vhtWj-d zv4vGdzT7^$L7g>(z>5&sDaAKsS|Sm^_@;Xe8EdiHg+;{=|U$-`J9=H2NcMsfl&O!6md z&?hvq;T~PrWE4&FX_3C?O-dS$o;F(#AU0DZeOs-lH6#9zMEzhpVYQmIit+)uvzPD6 zOm95mK}tq(R>tq|5DHlOVJ5a?0}E4Ytp#|%tP9#fU#xjxt%B=auO^ptCs`@)YzD^@ z$_!GJtWX=_UZi}f+SFo1JcgpWxNCq~k3BfNcgOG_i`nubU_ldlBJsANijC`-;Jbe5 zg2bodp`nI*@=K=4;Wg8-#Ui1#zE5a+kPHl}^Uf_)5#Ux_hHIN%E={1gon(xs*i~Pr zxAX^2-GDH5-Kyb`ZlvF%N+N-W#0$3xhB3yOyz3*x*U;_(6)TM+ZMc<7Mf5ChLieS4W=@ zP$-6A*Bm1JMxu;M}(19B5#@-M&XSO{z5eyG}agR z0fxu*lBMz;T>AM2#X#{&LJ!H*mkfAUyb44jurlSEX&ka4Y{B~-wtP#8IA_+_Xh#~- zxcdYYKvU>lTmZEOJ1s16s2P@6n{r!YnXPj=W+y3buc4=}_d={1UhCpxLeH4uN6@M8 zrvrw_+^>vNq9Zo9KLQ;>Y@mg3hpOrFuQlg*A#x=!> zI;ieQ*)p_YtLkvtE~}UI84i7}8r|Bxq(&h+53Tx*m#zRA%ULefJow8UV@MY@m+4fI z9BqCTmDG`qu6gVq&dRql2-O_-v7-=aGTyNK&DtO5CadHK>kq1JW?~wcLc|H&lhJQ} zzL~Pd?5@p(+u{j)3zgtC z7#3H39cem;SA?S%7dos_<#YwS<_61COLz}83q>sJHRo3DVl7jCxold_@!vt(Ur2)w zOJlqDCc_{uKE0Su0js@i4aIzl9J-uAdIqk_p_PS=t7R`mQCjDe^DFcQzpOBK#%vY7l#@!8o!R&LoD(%7vc3WM^D?T!;(yk7g(aK$H zxz#2UFLjzIj(h-d7?}^V6Ps2S-R#LrJu0@ev4|XhWc-(;9|eGx;?ZD)kDKsaqP=eowY~Pj$~woy;{TT4Xsg4_;i| zTq0xSEu)7}UkJT0Tr}W~8znZtT(aEWpMXMr*pziIk&V!E&p@@sR)^G@H{_Lme(@Kn4D)83?P(2zzF$bh==00M53Te zZmw+P{)_A^)%hk5Cw6oZKHyWFwAHe!uJ}1tK+P9u3SwF=D|<_$W(a?tY~`!^6Gp)? z=z_#Mv}kX4N#x@_8IgD!2VIhtXKY6i__K_qi;OM^tHBKW>*zmyNK(dn@#2OJ<<8|_6!p#6EkKt}1ZJ4)7)H8>j>p(bYS zpah-}=Wi$T#*jdJmFjrk^Co~v{xnv!C@c_IUSqH%tr%9Nzqf}(oivfAP4KGluV)92 zd=Uyr5qUOG`iU%$iK|~blE1+&8z*=8{ALRsdu7noTUMyE`m-OBg`{62jaWbFqy(Ms zt`&|OJ*I(IP$JS(gf@2pH{QvK7)6$&+>tgn@;F=TQQ{13dL?J5$U&|bvw6~;Mt<`Q z;*3e_ zOS%^lob>Qc7;kl$D?TN`jzaSe^pbN3hH6xVk$fm#8w{8d$kIn*XY6CB?AR>{l?5G= zuNaeT`8%<7&7w>&2}}2s&Z~pxaeVGm=t<(5OOH!WB3pV66K~+iNr;`*m{t3hqxKBF z4Y{3-%_-fjcRCJE>rZ#LOS2T{?Ao)~0+Cy?H|k&C5)zEN*m8t@oeJcpfAAwqVljUY zm}to6kK@c0KVFMCS{f-6;!T7_o0X2cq>gqodmRE%O-1!6MIrRTOz zjB4^Pqgb~8$nJ13H-a%w2=_g<8_7w$2ewk~M*CFfrqm#eV6g+dkzz6WG_`Zo_g(de z^zd_SF9h5{1O3-xhH=x|@m)s)0qvbIW~!r(CTm|$KZd|3t$hMA+3SI|vfOOGmpELp>7Qnsui!mx7n5K+=V` zKV$D-G;uzv5Xew@^nE9ir)wOUTaq~hZ?mvzY$?`ycK@vtt2zHo@yCRa0S%U~lXXXz zmTnn+hgl+*>2V)-PDvyBaFD9DIZSLr`huG_=rBj2!YHy(CE$MPP1pf8go3QBfH$hY|i|mV-?kh^IU?~7K!1jCb<6dwMEL0*jB(u zHH7@hA2gq8oQM0QBZ=8B5v*3sD`Ul&BLB1Rf(cpHDwhKzE!J?koL^nVBf0XF~6#TrK^$N=^9*Qw(=8p*4( zqm2->CDk^<9KLr#qHA6{{`#}Hi3G2iGUbZ8Ejxy;R*U4cbMkNx#_y~{*gkO@(vkq? z+?JJUi+TCujO4B~+dzXvjOq znt+`rUErurUfvUK9pcI-JjtpgFicJEroeXz&!Q_8DsgCF!y`F=KN$lSA_0e_-|ei@ zJ?}>9^$A8~?*Xajx^smjdN9e!6CPIWmbn!%cc>~h2j(z*tm#%5>T@bUPp#p7ydUM8O(sd<)t(aM~WB{9Zt23?d)oe z$hEO!*&Eh`wM>QMkJj8t#q~##io=y*lKm2_pgD&{>~0y=c{G)>6h6 z1V9CONF*%Aqk#a%u@5dVh~$TsX`N4wD{xW(oWd1~`VuZ`+Q&yZj-pGbN%P|s!n3{S zfV95krUrN^&KSRfu~C2>LuKJKnJ@hARcdvdB5i&hiGaQuGgpWwkY!A-Sv1*nt1XYo z*Mez(JN&df9cg>JarUu+P56j(HO9d4rr8&D2U-oGm6tjhF0*q9>k${B$Bqcxft+^7 zo(B`Ei*T=+X3GXf(j@;Zm37DwbTRLeX&MNo0LI~2B7^@yCP&QlEbVWo1QZtEl3yS=gbZ2b zlu5Km2t1P%w9rI}XB?%nhSSaii1Jlmytv=%dveacz`+YtMw1~DCzqF*?53LVYYM2g zKn=oOCYZ(M2-<+^kX#}Uj^kW^0$0C^z`F;cgO;ezNt~AOS|7`Xkb@@&TDo0mIrG#`6tK>M@XDEEd=uAYEh;h_8Y z$c#W>B-9d+yEI*OtOXRdmC1&oM$(lehFCJ|W`&OiILpp%&7$flZ6OQKeDKYMO^^l4 zNT&&t{kax#FO3~PF>O}Ai^-cDiu1_`i-}{x`0!}S=%N3+Bz*LK<-AjyvhB{NT@3pP zuWxx9%lC%kLFE!*X z`aSus83)tG#FA3lDYSiDcV1C%zXzue?EZXjLW*P)x@#&N`(l6-<4tU`P?*d7m4fSqicBHOJiDIfl2ymlN?N_zksH(dM3r$$Qk|xqWLm z%&P|$;+PxUWCb>Pie|RWbS*Njv;-Z1l)_}Tasb%j@Cw+n4G7WiGflpRF<%F-f)|7` z8tSx7Os^Lr-;=edTsk6D1|)T1S(s2mefg%hG(DI&E*A_M>Pxba(6t|t5g<V3O9d_)vD%+OSdM)X%=2+;1}?)oo~ZPqhFT-DajP|DOCGDv;B zc7T3ktePJ6TV!37K{VTve>!W9pD`v=%FpuV{Y z&M}3)XF?Knv-}9GZfEAVqRuIhkL(n@E~04Y90dRN5P`G-igx85cbhsPTm4OM?xX|$%T1nM?#i&2irP&c_!ZJlln0dBjVty!VnoB-N z()$Jvp_W`N%xA9?&IW%no7_y~F8i9IaBl|cRIY#+5nDw9_O9z%mz#a^VwW5_A}gFk z0ZiE+dWYZXFEm@J1AvBguZbz5DrAKRv=r0&@nnDV2zhLc_9N2Bm&&p=R*oSS3ZB#r z@jhfH4rVe~6x9akFs&`&SJ_bAx(_W=hch)Ir5>;b0)qo)h?@$hpiSfGT?+@Hi*Gyk zX#Bp0o%xa*03p;mE26#@1u3x#4EZO_aNI0Q1c20bGrIR$J}>0s7;H02jqKS}m;VJE zKz$<0;?5!v>rEwvD)WP3Q(#|W1y%$jG>GD~OeSv^gG*_E88wA?P7t9=H#T{14$!F{ zt5}d0adz;2eSW8s-b{#O_+S;@5Cd!HL#f4&*-K6&BfNRfr(X;C6UPXkldw5WiSNj^ zoPDR-6LQeC1K*W;%=0&8jOC&R#A0plFGLi(II3w-Z3Bkve21Ro`!w|K+>Ff5V43kS zrBuoQ4iy>%YF5QGOw=Pkup~HPRP|vHj>lrnQe36F{Q(ShM~G#7q%{ycYrx$peh!$j zPn|zZTTRE##Vh>``61UcXlNQwQU|4|eD3YJZ!9W~C$ z(OlooBlJVwLLq730DRbRu%!WJ34F0GB~qA&Om`nQoG8EhFm}yanju_pP!r~pWJ09x znf_cMpz5yV?-&&g{zI@c2*%yJ`}XS*FBg39joDhbCEbC^j#9LR{u<+Ro_BtacW2;TDYDFW8<(X+-ADE z^f#n#ip{}4Xm&eqUtqb#=o_FFemG70QM7(Q<(#gBY~OsREd+L6jCmOLq1t~MH7a3N ziC@XkunWeYd3SQ@f`Pr9&sLFM!8pF#0Kea)=8U4@lgV3KsC)=%v)9@`OqY;Lovf!< z?Bw`p#*#EpCdeAhrV%p}rbb+U7+H42VbPb*PyCrM8NVv|vl5K0{%6ZfsDaGc<8Aa( zfniBrZtHcDfGOARlu8R2^176}%VZT3ri%S4xiA@_BZ7@f&D0qH0B287E+OU=j>bC4 z?8H&>6n6OpBl;Vsw4IwQTQ2EWZeaW>JX_qeJnJhVo=2Gx{7WP>rqV{t1&a~sxadvM z5)VH?Go5s+9m@?0`=+!WRUzSCOtlQ?so_@Gp0{Z6W+_6&5+JSA8`DjS=Zv8%59oU? z+aQkp9tP&G*FGh-yeUXhUYY`-toYp!i7)(yp4{j8#TtzsEw76^G(BZd z=2ziLw4>>`IW!e+D6T`Oc&DiVCFuc1gBK|LCzxJR;c^{gj$7j_;i(tO3sO~UZ<-wlMM6OEm2}s!QuKv9y>A3fe1&6FCyAb&9dLJ z6dza?f*DQ*R9}Lp zq(81P&=g<~O92Dk9?=X%u>gg|YIF3rC)zi!580<&>(=tjiKq@ynUKu+sNP>7uYH`t zm?aoOPZAG$RR2j~ti1#&_yZuc2iZ(FEFkPwh(LjLT529&4lr%$8xJfblw#Z4q*-?E zFXU}H`~+H`4?hn@<_+FB;2Tqz=lMYT5&G6n(~Z4$lLaYPFyoEZ%Cs)l!d&p8QE_GB z16W&EFR@KNwyzow?kFhoYa_{l;+kW?XE+GiQQ7X;iuZ$41*Oe?8rvr7xbp?HH;MB8 zcL`}(eVhGlBK`EPZ&t8Q@7FW|%3J-_USWb4Ccl@oC4NvNg#1Rt%1KATcA1MijdLN$ zJ>rrnXos+xGpqXK8JD|z(Znk7?+>cdmDTR?8l)cDpV5O^2q*L zs4GFu=1(1{J}dQzT-2leyQicn;)BnjAS*GJ4L_sfLFw)?Ed?UU)L5j3{wno|XctTa z3E%6iPvv>q?pF6UXckdQMQ&%rNO`H22yZgk&*&Q%O>%_XS^ff%NUlTw8{^pVd?064 z3*-n!;WBj@AJ5NbU$B~U7wVJ<>k_+17~Z;(GLmztorj`@9SAgQ9OOe2YkL-J*76zr zNoUHYM}4%vq8J>SWmj4V)yn6r<)vL`A6dfy3XGmb2p9U(onY`3FU+hopSZPMDS4fkLK}tE)0cMB+Y*@m1(E%+yiZKb- z*m9o}D@DwH1dmz57BDu5c^d1Uas!o(dFn%wG%!f3g0%AdAjtaFVcAh$u59XAaXUm} z*|m0D2m(i!yZbniLJE=gwaKiZHa*y4%-ucmpVD>K4BMzjtfZdhCqLnuz6^1k?#k9< zK|co-qgKZCMRjW_gv}pnqF~??v8ryO!OL>iRA6%h9sP80MOU@(vLjm;{ft=WOmqnIj5kZVS@0f96%|S%=24F z5qnEyJKB~q3~MN^CVj#<^eH62%=L*oICG%A9fk;t&P*e!z7tjsY-tWP^NYC-f#1jKA zP^jC7h`MPChZXBHuX|IoqJqyxNeeTidlcO*+~g)#d;N?KUD_oR9q7X9xK`X~O-&|n_{Uk%yQ9H;4|qdX!Jpuc#fRxS^oqZ^ zCAI~K)cC;YwT{miC!ZcasWp&s4r^@K^|bEs9B)@)^jOrZA8SIqNnfD09-M=oNeCGA zG5VhRH&m?KKY!5)fDKf(2A_-jf2n;< zY6F58N}O90MNtFilZ1&z5;k1az0mFHqMDjM>X{=djLZ+)o`;(XzZRMf=2$(7o2V6w zIH00B9V~&3-l?c!b)ez1xy=fKD!O{d)cf;~_fyZ9_ zLZnS5$d0l9A=!f&Y5pZ4fsQCxQccac(v2|;fCIgK`N^PJF;=)xcR3rq;SQ zjkLOd(0 zbF>aAdhOK`Om>)O^2M~4Qq3whCa^-CADvaOP$bPV<9HrdFmKo%>qTc1QM_A9^V90G z!SC0hZ2n~4AOIMa3{j7XnffOcAv1C-R-xFljrNG7V|Wj8a5dbPDHHk!ed2x?F=lk3Q7tVs)Dcj#Oy79L=;B6U!)IDNL!DYuPT9h7P-Yo=ej{2k(~n~3n8|y?b;zNe z9g`avLr%A_q%j8ouMG%Sn5pGH^QZatd2>p+=Yq6(jY#qpV4WKtVCfe-9WR6k^M^vN ztim2Lj(E9?W;16y&&^pyLqH^(Yaq>{7>*A&Sse&eQ_%`X^Mb4_#v&YW`IkLB&S1gf z-bIHC&cPi~ZYi506UMj| zj~=6TC7THI&-A_{FCu_&dCeY!t^2RU`x(0nVJdQtwHtO7Wso1^xO0e;PD}|HZ))`Q zxw0(ob!UecW(Tu(#HW`SSDzg!q%HbiPIAFiGxp1`UTcapL2Ks^lmNSGXbpjcHiaX^ zxXMLNUP+i{<Ajf>00^SH}bA7Id+ffN|XGnI12Y4zr*O3mylKAGba>bU$b^U>TQGhb%+N9J>~Lk z6Pet>7S&Ie1s9lOjI(l(h2AZsO0ZazQO1@PKkU37fnU}D(qS|Y0L`@#F>XR%e-V*- zo+qv7jrfm8$OiQqkoLk;6D2ht3xkbhL=_kNETXQF(SyCQFajOXDYVofOzk*;z7LE_ z-$BEIl_P-P$zq!M@X0aO4Dxvt|0G@|dny$-wYn_Re6deT8&HP!2WlMfA@bwv)}-_F z64$x&3oNnmpt3#BMJ8eFHw^0}Wf~L0SPpjp-bg{LTmBsE==KPL&r50!0`=~(fSu=8 zk@Xx=czYLh)NkDUKkoCY6uTXsUHUUd?Go34r764Y@3&THwE>4KOf5+wv8r5t&Wvx5 z1tK?=BQ+1_qi5v3_mV_YO8L(4Fn>~r$Q5{Z8t1>sVIbK7C?g|A$WHy?Mrhk(CvcaU zzORi51Hw>pWBK72v&obfClo0ogtKbxws)8l&giK9zc>8E+fsIJ@y_$FHpJ%I%ai?Y z<$SIq+REjEU-09zi=fNnM>r_BF1sH?Czgu_+obIkN1soW$Xm}zC5dZMtZ2rRm49Zs z3{|5qWc;t}qP7g6YxzMSkG|i%v9C#K3MCC!I9IGd!A~qGGeJIH2XMx3d!#jsT z&nmq(<}|+Y=5fXzX`1F3U7FkstHYw(0m3i4j2avO+7sg`u2#;!=gc^yrpVScUH?42 ze&a$`PpC?a2R89Aqkn zHm8@5^C8O%giImiJ`Nl{K~I5JWRqgd8$|mc&%W{=%vWCFK>9fPxjxKx>s42cB50t`)@sNa~N@wIPG@ZDrhqLscdp2b!K-nBJpuF92@dRe@;LL$gxi zARV35AyM(BA6N|5*2KAyV|h+;^wR@CAjwF*MSt~_0%px{@qt*5-eQ>0Nt zu6rS^x`FICn~{!8Y>n6f&3GS8K9iY7M$ZjPfC6$r%5wbcf%GAChFu|0)e~dWxU~RY zri4yrvX0$0($*0qCduh(etGk3VNtM% z;vyZe02ze^u2!<0mwm>DxwIiRveU@3q0-9x7sw~cu3VoKkve6y55TWamK$?(pg1}!1ek0n59Fv`v6+$-XY-= zW4W_%a8N}1)s{a5uWOP8o8Jal`jY1$1Q&m`SpC#XJl4n!hq#D@%MQ6xOJ~(RkMY86 zCW?_>e+g4xA}Uo#M4?+DmZ!giMdBrZEGMhQlH2|Os_JVv_FeLI4lQ>FJ!OxN5xy8j6d`0myIbSfC)JYlCa!xL#l6H=L~#BE4n!Ob=T>qX>G zfn2H<1<{;3dLYyf#vw@P0xih1Q|-rG0%u6q*@IsaCwtCz(Eg(reP#{f0Z~_R(QO%U z(Q+ryo31MTRk7*OdO^w_{;^9kxrLUav2%LZ-Uk~_Org)f!UGT}CU^DaSF%$JPY_=n z!Po$~<%ZE11w?}$C53kS9%osvi$C?T)WlWIeJ9~W)_UCO6c$>K0= z2$N?`!8w)30=N#C0MmzR^-8g0SPTPee{l0)v_xszpKRQlC2yAZAOnAy3{yWOWy7PK zPzfc3#?$q6liat{j~pdF`O3Xb`<-S%*K&105|k~iqph3ACDOd;ol_gAzRP)ENOlT1 z{Ex#weikEJ43XAlGnN*+kaUmQfjbI+>j;~j9(TFS|MY27*c&%WIwVEOsY{KyoE;w% zl4(YugTO~)?4K1Ct~waHr6N|466rQLm#N09PQIkZc9QJOnxUSOP^X^6SpM>AAJk9t5#Nr zP;-3jZd|6?57EfXO4Y=%N>kfsTZgcWZ9sUMu>qmRPKr22sb8M2=KCP@Q3a~Lm8=E3 zquS94ne0r@Tz;dXcu+lKH9d zVXkFKUL~pE4|P>t<@Sb`zdWtQfR~Z>ons=XYBXc??xN(|wDVZLK*J!fyETPaz6g9h z3bn-DHLs_J_Rld6JcJZK4atPa8&LI}r;?rav~}Y z+Hc0dT2d)1ML&rzt3;rC0K|J;idT|*=auH zP$y$ezpAag_}#ZGysX*v*3b>r&tZi*#*bL1- zGgb8e*tn>>qr1>GADV5^m2v5gpfJ_-lBp+&1*-PeStF1cH=z%KG3TB#Fmh)XW`vdn z$s~WX=`>4iY>*2VMCYRq?v%MK?5prJ1P3LWAAF~Rc@J~dCk4aWiba`Nic)4sYQu&o zjRd$>ff%|3Xs7gZ4oFbFB+kky%Y(h?fBw01T!jiNGvma0cDfbBFsp8oPO*xyS|6Kg zJ!9*za&$sadYSFd$TJ1jp1FN@=#yTC`iaSYLLVf0jT4UxBZ!f(8V-FJdTf;=7*9f_ z+a`-HQ@vn(`k0M`e|ET4CxEBk94AJLe7S9IP6mGxWGGX^dDANx{ehPUPP0UP;O6Tw zBt|mrY=(JOUIsgW^c|36y_ipuf`#u2^9;;HvD-r?K(vK=o+bR;A+7|@<@9?PIoA>+ z2OV!5u5akb9hD1^b8NsE(|MzcJ-2dGzp<8Rg~i^SaJnmdJpAqGMCMB$#c@t+$ZAP{ z+Hm%=MoyLy6_zMtPm0lDFBcR01E=eUbV&7HZHHiHJubSFFKtuDzDe(|SE%VLdtY8A z#(*maNeR1l;H|TF1_*t<58A5wTy8$9XhS2@ZLpDZKp4p!r^z<|QSe=b8WxMu-uJ<7Yy4Sw{pYknlVB zDJJREw+i?V4nZ6ln)IZabAtt0TCvf?D)OS@Mm!(Jy4Q%*fQ>ypOD8wJzDMKE^vlb z#@KZizKC*9z4LLM&`TNr=~ZmP#hv0>wc{#DW4gV$7fl6-e1ZGsIEP^I7Qi#vhp`#G z3@sqPaJ3RVe~=h%HsU}?S;56!1xuU{8W*S++n;>@f$D|3Q&MZzHiFrXk&U{21rwLb zJaBI&)*UxW2d%Nt)u_>XH{-2>pBO`C`s^uCrLR(d*i>2H(Usz)LbDAxu0YVic12ZJ z{hW@!&-VP~vcbYxt3b=12U*P-KSx_raQ&~BHQ(lkNLWEyR?a1-hV*FIIwpvi$iXg^ zr;UAO(Gi1|zeA(c=?nGEnP^~%Ea%H1f6cQrDez}Ff~?~>4IsjWK!#ukZVdhJtK2}_ zux~!pSVcS!%EYm<#`>wn``Xc&YiO5pB$0&bU~|4>?T$y;{-z!p(K~$DqhkrDQp4sx4{o^_)Q{{4-zw{q+8|F15nfn;Jg{tA8yew@q_iFr zgl0TjKcDkHc=LQ{6}kX&P7JXPl}d7#F~3t3M#}&wdD(qU;64pb0AWaz_#sXn>Bhz3 zN_Bg@hdoN`bQ6H)0}^v2k9_x7AP;7N)9Pv$*`x!eyZnh{=2R&1J_}ifx~iP!9gg~_XK*@3%Ot@ziBWt_ z*`@w;P2m+}iK=YTvN8+Y)@BL3miu$Eyh9|yb@FX#q719G^kF4ZLBVg?>F$jV=y0)W zZ1`>LHC@||(=C+o^ua(q{~942fjj~FKfYe^Cl)3Ng%+YZ{`jNZ;MEVig2zx-Mls__ zCHF^KlJrhsib#Xd)20S}fRl)*vo$s>cabBBoH)$Gng1H}@n7BO_GvGJ@0~Iq35235 zR+Cj6Bg`tu+1vu<0Vl$Ol$iUkC1}y3uEcdZP0XUW!wgM|4b$b{Z>+px#&R9*c$|J? zlXg*A9qw8}xrBhXjrGtS2%jVV`Et7A^;=Jkb`@oVht~nM$M4}Tv#HZUq;l$L0qi^1 zivi!Y5INxFT2|RU(h-G^vbu^vnMS`k@v;(c|R!pIF;Uit4$b}=@KYKUo~Y|H0m57%x@Y-J>#!{_IQWti#jt5hzwSpw z8gHZjri(r;pq@ zv-#bJ9?_(5QFzn8IPecLw`-1^!PVj9IG}yJRyp3qgDs#>Tl`Gc$`dbn=v}S})k>MO z*hFHinaN)js2O2;?4ZFr%3YQKV9$WbBK1=E_1mz8W5V{;GPU|ipJN@=06|84G{qm2 zhH!AhwG2v=L-Qg;iy}{L!kyI{O>C@j=;R>8MI!}={Z|D-JXAO2P#kMpL&CKu8(p$= z^!k`J%9N%(1h`2c6{G+;`Pf!RoR*$B4gR6N^M)alxA>hV9g7L zt^|aSo!0GI^Lr^VdU+eKE*z)vH8URso8O~pJUjF;zot}%^qCbAZE9y@`Kv32v*_!q z%?SPkir{q)u`>sh|LlkNl!w#R+QCOHz}RlSyb+hO2vOMY_cbZ7x5bYBnYAdv^(>!X z4a`j^hHi%C-c>zbEl(p&`5`C?fch?}2#Rp85@C2FN1sUFuSl&iNM%@|mGw8|Djj2_ zBsL1aY)EmJdQN}xXe6SqD}u27t&MHr<(``5&)?Wv=L>00>02Y&+gE}5Bkl5u>%uQj%@#BXGl#yVwYSM@=2pd`IL{S0Xx+I;+! za8|e#0%yTSrR&LOsZID87+5+>z840J1^hV{r>0xqUta8%H1(NsN6N{_g_`|0d-PX;13U0GNgqQ5hqMa>O2g!TYzwmN_LIovmRUFBAj^H7ui|T(*a8G? z1*SjRl!FN59Jv?8+cs!MaUwf+HxQd2n5a~#+mj91C~U$-`2d{~?&iJW4Ax)q`Z>Ir zvz~Bnv$CUIK_>YURmF?av2>%fYG}Pn$if0l+eYd*dN7Ze+PZFJ=;Drq+hR+Mi#B!Y zngiBHb~gEB&yiG?S*$p_nWc7nZd3zo^|K}Oqv&@yMfZ8azs|0())`sj=Do#D>>|4r z1saqG*JUL@u4l@LWePohmnbJRZo^m)&JtOaf=~iZwJRbbu`XDeq2z1Gt&r=t5=NVU z2L_})7I7CTpeWM{n5?dEA;oYaBqK8RO1eHScxG}Nlim|?@Zuzx5E)ejM&xDN*wJ5G z`o6+E``$XrUJbJHgqvG2ahEl>-x6GPXp25celE1*T!962hgGWXta^xV9`fX>G{J_E zMJ}p0oTYOx+&q-Wow6w%8m%o5Ji7$7?Cr-TI2cC1F2K&ndRR$n{4hu#B2G=XIJZM0 z9#-Can%82eEM*N67j@0tPE7LyHqM`t)d_6D$DT5OM}VIo+3&HX0B}IS*PNPU3D3_} zrmAxo!xh-7f@fH3B|I%O4NXP?YMh#W-9hYU1rBmO9Vm0W%Ei5bkgpzJ$OX2^DI-d( zgwH3XRjjPM$qK^u>Dqb`O~%+`55=xmiWtLJaXZbFP}R+1^OI=djbzJcJ=h|5uBFTE z*)1%Q9F?-T zyX#+?`Q!IQEFD<; z&K(yu0u0Rhr{nj5Y%=qbK52Xg_}CS+4{o1D(VyY->34bu?4>RAuJk~RyOYQVA7E8+ z1?#&(k-iM@Xu?YJ`zC_e+EE&9)aELq|2UKZxjWBi=&^;tTJ`7BpU#$>EaEg*==wl; zi;Ys2Ll{Ad$~<_?z{$PP`^GC!aO&rujX7H~+g|B)NeyOByx7aVFqT1rx#r|7j;S=B;;6_siC~B$`x`^@BUlM_^Nd#*N)=_(;p*xhuIcbW_DU~0?*tE z$m*y5n+xFNDlg&GW84*tkoprX!X{tR(hHECUcxwSTLkmuQo;U}3aMfV&tAXk*)+ha zhI6;Xtp;+jO`i5^AqY-%-%R!H$c?@YCCk6Ei@~MI;W%AFoOSY@)bZjO#Kn8c&Cf~U z)9cqZ=yp)q|5gC4En>(-(ZQz|bUIX7hHeY=mnMJ0?oGpY1#|Swo+j7NWL$YxnU%3= zjJi>;dFq;q+8|Xo>Z4urKu&oRn{ z)9fe-$a~+ zr52(>n%x^gw=M#3Cf7>C?vTX!m3)j)WKk%(ie*Vbj#I>d@>MrDmCnHX)t(jf1iqZH zln(nb+Q2qQWUs+K`+hjV%b7Qt*vSmF_w0HIveb;fv=SV>_iMlMd#5-sGrdhR z!PT%6x%<~+i^e#s6|7Tw=Asml+G;q$eq+P%6K|J+srt;ai+EoKnk0-?ocd=T>D+jv z17Y9abqADQz_u;>QjsT@8(;23(_;1HF8ZEbM28prL>K4f&*Z9XP=6;|lMvhL`_k{v zD-lde@2}`;Ib*P45a|CP-{e>TnUMtFd5< z$)48s$O@Jy)U6f@g@WzFTMR4ax z3)bW+=GAhdveN#BlM2{K!9|5zMWF|G?Noz-0A0iv5pO|7s!gflrJ2WNwa87Nmqa!a zM!jl*K4f9m5tSm{9Jh4lB=DhSUKbC9L0+PKZe2n+DjP+N?z-*fBAmIUtd=ju3iCEu z(%b1%W+<1GSrG3HYS)_S;U z7DcYph!h+R<07H7ioe`Om*l)rr}CXD|N1BQ#*QeQ85$7MG;s<_u!8r*6+ZnSC*||PX*YJ82#PQb^n#(d>j02@y7<_pZX(p zx1$}jgD$-tlEKC@MjS%cL^euV(c=#u-pNyk;1rs--4`K-pg1}t2Q)nPwbEc*o7$VH zGdO=g$s~3Q09f#J2@#OXG?t&B9X_y4UocVQnreSeIh$&{giuvXuQbqm+T7vjzxd(A zEVjx?=MCE7W20OD{$4HbHqD4-tocD5Vb9ixWyj7w`7R@;B5PXp?{E2K-i)PHz*TEv z22%?Z7CV?h)tSGWNtMP(zbH=J4d#?o?Ybl7BC-Mm1%vQQq*SMlJin8tJv;RfY=V~- z%-R-7ALwX}uX|3Azp);teRR_*sa(M!iJ1yolJmRR8J?MZ$bttg$l zf`!Gz`T2(v&dqs#m~dlk%4QPTv^8U9msy%#EoZlj(@G=M?#&6t{b zaiui>@~a1&0sz)+o^|?G|DuZ-bI=8CXicpkGFXk1?-~gr9lS@p-%IT6I2g{(hZ%6AJ1N?JR5r9QJ;0!!m04O^~Sk6(VvEfZH0 zUI$ZB?=Ba4i*FE}3w+zobr-$u(QZ=n0<-+cAdABmAuz+ghy4)_74ov;Hgh$1A&3p znWR@5%WaMpIw@dN#H+tF;cLfS4K2(i^zG3#-SXOAtg>x)l$+Gmqrk!X^j(Ic=CT5P zyS89y{z0)kpfIOsplf8q3+(El_=r2MBb>e$&j^btk8tlxT^g*^(4s-79`sAOqghz& zlgY>@RRSTn|8M`|f7W_2xmExZ)ap^S7+R9pFLLyygopNRd0gi>N9TdCGy3>t&Ub^u z5cqj*;tKoco-ruwf<_^w-&a0y2uvbo{)KIuF9bLS!Q-C*$Chhu<{rqzxA0xtEhl4d zc=9L2-nI6_@>4u;Z zx`p1tw5Kc)mXMcS8>#ePMe;VKV7>;Z*6g?S0Jr)&mB7^>R9OTI&CSb<(A08Bs<)19 zqu@7doV*Rdb!Qu;=LJv)P~SCc!|Z}mi>GBNFU45A#AU({*7vQYbyJrKbmiA9l(&|n ztXd(ty!E2O#HnUMb3Lx`qOWI~SjV~JNcyPQO4zpTVqULBHXHkla;}-(k>@0xx?+g+ zH`@dre0pORg1kFR)6SpL1gLl-t=K&gX3MBnDtj!qtsDB%G`pG5vS=OX`Aw02^CGU- z)TwXsvou1T9Mdj{%#in{wPNzgwr7Q%+aP!sIjwKjM-CyS{@iHG<$88q;H7gtqI}bd zwcMr%Fp_-9yX7_lmVCoNGL*;=jc%emzlx0OZgYI|XX)u;v#%$-3wWFzpz8z4v$Oeu zFvbnk^-+VC%v#+^JbZvs4T-5;n~ZD0WHD0m_IpWxvoWp@g}0yc&SJI1AL0L`3zEqX zknB@11DqGxL35)~fX*}63%&4yCea1PdZTQ4>;)cCC@hP;0|uD&3dDb*8V4|@o`2R^ z_c(YHa1Uebs*rC>9Jr38JHGUf1uk0eiF2O0(1;@ucqGBQn{r z>I%y0Bj6QW(HP-#H3J-p<9nztl3|-7+G|)LP=@LZuita=U;LVk;t{xkEO3xEex{T` zrl*BfnH>o+HXJ`^E;~I%Ip%AbuslS1h#zflt$k=mkB+4?J{!B3ojX%8mK zH)l`DNWKK|^znLvUREJ|3)3S`1Rw?)gpII+t4t|={fwG*!mS+rj?PpK&m&~K-u$k~ z`VQx8UbTZD_g~;Wxf)n=GIq#A9uIx}c*{529tjmwKQUCJ2^C~1$jjP?hciqxcm{p7 zPbc%w|7P16Na_Doy#mPxOr#%C3oDO$EMHmY@S27UogQ~Lv7fbLnqYg*qH=_Q>+W(J z<(uJVkpDJ;{gPRlSE{S~PzMpRt?$_Z5?8y`06JL4l$%f@v@0Ht`VK*qY%3BLIh`=5 zn0Z#J^09|)1QpD>QPgxZkisO1V>w*5A2$@w)5CM1XrLGQaJD7!q)I%D^}BLtcqvvR z5NUNJKo#r$ z?67xOzU2=SB#d>&x=f@zwAs*dV969C%|9(Kv2?y@W4lWs>nZ3mzy;Wxf0BLT#Ji=R z6(-9+1;j{t9k;s}c8-dXU`duyr3{y z_q1vmpW5;WcKI`f*=XLq(PMsowFiOsT-qx1lhT00W{;(}2Y|M>GbN^?Pv9o<+Ade? z<_Oj9b{U*Y4!_GpeZ=x;evcAz5XoJI)N?5Y1a>k}t(iY@B7fPE&BaMlLI@&QnokF! zCwB`yb*2Ef>`av`|DF)DTZ5oyiu{~V@EIX^@;(@>1a}YjAH~1_cu7v86n8pA$%pyk zE9r_+*-_Q5Y(am4>`{TY<=wTWf4J#$F@b_ob*x49cFd%yPJoIzudr?1&bhhDcXNTC z&+W90BdrvdYQ^}+Csn~Hv+v#kasEJYJDkP$zo@8zbIkn^{A0 zN2W<+IIOOMo$IGiC|mL}-~@HXnv04n zS}ki@Tw3@1oLEwbd!xE`-SI+UQ_$gyt1KvoYXc%IhPC!U-$I$_lH9!K{=rw1+rdk( zb+*c1CcT}@yYw1GcimCXc6=XzGaOzg-A_u9&$vxiOD3bo?M_Gz-W#n`owgGV+nibA za*w70k`M*6{LlOz?%)TCAbI=e3JksUeQ%>NLIe6h$0}(Vqebh)t9|LisI@wI{vtgt zsPG-0wi|ij5|K!4n=knx<)%hjN+#WOCS)e_2k#N>^A0o{AHMey3Sq5srD~3##dubN z?9^sc*SVeuz#Qn$0ssE0gAxShf=mvrFL)g36C8WSeRS3^TJC7dep`W+XmgK(U!OVf zOk*>DTM^t0xS?9CqjVD?0=2+~`Onv>Zyr&bceN-2J-E2P)}`TY?d(Pj4of3EROs3gAA?MxUW1$_x$dQ#S<-;iAV6`hOKo9!1wGaS6u_8LJ$VKkl{?P~{P z`E8m1%eUHC9YK2IIFuhjmdF|zTQH*(A%ou?8cX9-__@@}L5@$e>DD|SGPFiA^KS+p zSL$m|X+q3=$Z?YBt$!*U>0LRN>GCa?Xp0SRA1{XM**%W9LMrpOx%-C<5>`O%dS}fJ zAbDcDkA_6f5}Dzakwanj7gE3}cVH3A1z_!mmdQ=LQ&(qoscD2KOWo$1`s> zG+&REy5A}{g4_>^mS4rvQ0d*Cv6rie7uI|*jEiv|r-JAS=stn@2)S9IbufoxaY8Q< ziV-StZ5MnPMVe-n5;;x%3CJEZPGtw|R@oE~1wGAD>&nZd$G+~a35V2#rF$^jV^5x$ zobDs1{V2Dze_yly=A!6}B-j=Zfjo&9Yr1DO+GNt-o}_bZ9FzJ>=6??lH7s&~VZfka zvwppZJLq2E&XIggIWB7`>I}SZDJR+oFW;~Nw9i1;-tk^Gs{?`C+Hrpa)l~cbIxSeg zzjawTY2J${G08+0^`(lks}aW<{f1&troJP z-1ocvV4(c@O`;WGoi)Gkm)>%S{Ny2#m%ud~Y~F`)6-k2rU4iD=lQMjuCoR;`rB$3; zv&fcy1`|9ikDbxy$_o!RwK_|#*B5eb{~-;2gyebtBq=Uwnu~S*0y>z&vNtGZK`fz- zdGPRlgL>&=ZC2?>;ems?$ok%rjyZ&hHmp(94jT70cAO6$H$hck=y!FuX_8YtAKC8# zS*LID39S#ik-@KbZG>eUCv16Sx**$GaJGc_y(_Rw({cY6F55)NV2`ql+KQavy9>cf z6Aa>nNq{?jfc_m;r=f`YPBvo#`at($i$dQsK$5Km-Ig-oW{t<=7;j8?|5|H488Tx` z7fuWh{^GYMjR9B?et8)#@euYjLJrBa|0B^eFZ61vZ;69fNo?3ZdNE?>@CpiqIOyEHG`!4( z`^QW|eb5Vw|C@@LvQfoG@6KS+WkYwC9>_05yn(BmJ=g9seSehK%IuTSJ1MQTp>h zK0298sQem~0AZ*kO?v03JE!Ph$qrS7dD~04s}S5Cty`gxHx9Q!#*m7*vemu>Lf#Vqs9(uhVL|AS9?Sp#PGn~$B4(OEO*(v&|o4{)wt z!^Yv&`t&rcvvaAWXnQ{+{(67YmE|$vz(`aVH!Uv-eWgwr1Tx^VQ=$F^)+2;KN67O3 zC@?kA{8x!3W*nKJ!++?3O+{A@Sw>N&bFk1CM@qvNd6DB{9S42Vy(cqe+{AnM(n?fg zN1Al{Kjx|1MdVZ#ux(gbE)$&>5FbD>tDa_|?g`cL)m@a3&+Ybi25484Ch zm4VE1X+iB_Qh%_41zi`rjxXxU;EjGy*uVVaRhl{Ta_!KaTK21GO+|k{K#37g!%@Mm z_H=|;0zs?4dLeG#V7U|;ika0Y@jLdp0zqYrb$uQ_!5gQ4|PHkZq%{ z58gi2z9n_c^u4{f<%t;SRJ@P;0J~*4*l>CAy=RROZ(cjm{PpJPt3ds7E%3UcXIH1X zzwi%F@2Bg$8F^&v`ptL>$#Buq8D}QV+y@AS1^;xIsi#c2CdUxpV(Z(pdzmsb8|WM{&WZVtD%BF( zFV;3GA7$2vK>+t3SM??fS~$mjV;5#xdQQZlWkVerb%|Mo+K!i45HPN=Bbh&rE-k!T z(td<0rp_C;nG!hwLYh1!n7vjPKUK*71g~6maDiFiG|g+Pp2X#jaF-MtLxX;T9h3~* zjkvlwHP6_$9iM&YTn5>B*R+Q;6J%;99re|9tehZ=pli+!nHLJrS@A8*!eI@UaK|~M z1}GuC28c-QzwrpeRl2Y&yO(pIrFJhU$iXo2j#-_3pm*M9$t^cLDo1*v7@4R=G~^=; z^Ya}N`%XJi41DXbXH7LfUVN5m;)=Y5E9wa&YPll}xkhb8{wn$mQn3x+v1ae6nk5SH zs8F|PXes;-sVb)&yJ0^+cY!%&Na(1H`Cd%OGMcc*&IQ}I`+dSe=DJdg8Eunfs(c2r z-5bW}yf&)5l6x%~B=NL~k}V+7fmUlH)A>Xlig{h*-G8r4V#)fp_=m(W@1@(V^1`Gn zN;Zcyw}y?MQSUt=246C1e>0-=M3W+a(n;Z}ddISuhF~>r(lm3+9MYh}oOtlY?>0l4 zJOW-sn8mt>WBP=UuPoLz@b*_|N8D-PBLjOB@1~aONG9h>$ke5*zbIX~hyWf~0ZPjl z-|KmK-jPruxY4p9|DeFJaj{5e(C!%WSU0UurM@L? zFYk}x(Ep-1v#Wr$gi9ET@0|>xq47YgW0@LjVX{^bIPY@}MsshGVf%U%bsJp2nwq_i zBWVRDZo;eisedi?;Opi0G;ixUsG9+`j0}#+uvu-39^EbauKdTo8>$`c#7_$3hwR+D z0rNZ0`W{#k7IZ8^xTV*lKuq5;IW@-X1gcw5rgAKQ9$wjx)9QBx3+pW_=I-nfV+kV% z5I(?zUb8>xBB8A35>B@;2xx0Rtpgg=C}&;}_-9kJEJ#_%lZNjm&>~_vkJY-P9jzCg z=_S+3;`ABQ6L^YIQh!IjL>WzraD(OO;Qt45bAGDjcGGl?vs=T6_YM~S zRcD6xDe1=mr(U`xDdxC_t3A~$xDByhZ__I%h+}s0W=9K-xaf%F?)Sj#s% zvg5#RMBy6!$v5cU^@3TrM}#oTnCpro?0E{ytOT+D6I9f=@`=6w53nfy4_b8l|G-7j z@Oay^&tJe*6z;&ctnOut3cSJpKlm|p1Kr(rt3`VT>}WS?hCFoSemYWW zYg4n`hdMgm`i4qBC0lKYRP@%YK5`kC(o*)YL$<~i70|XdRFuL7 zf`EYb{<97ua@oqi4)T3H3eyhjV)I?A$?asq$laaaCbW^ejh1wLNX*HL$#iUc#ufWd z+P31~0=o4r@?0bUv6M&O%sPQ6A{$QmB4>7*(7@2?Z5gcBFs7usMRg>o%PWL07=> z|8dQ{WJjD*4F*4pFMY%!LkUDTCP&fTyi6zGaVEuX;#4+Px%RaprH`!!6%rLZKSxx%W0AP=%X zziZ5Cf0pS!B4O%Q$7=#p<6(ojpbfzcLC9lG0d)10Gn_P*zLaD10a)yt%dVxq(;JPk z1$)3o8L}8T7<*udK;_$Fpa$3S!&>p;;m4bagE;#x9%yv;Z~iJq1--j92!@AFLd4Ch z4cxAHqA|88tsg2EI4sY~rKSj8V>JN-B- z`d8tT)&-og++2u4&-$7^(xbvdtZ(6*8WYsxi2cqbJid;J`aqX`Zu}oST7<6|omq%W zai6Oh2yL#9yrSeAy0v_&y@tl9;06OdH;4mhAeRst?lZptY=7Ch1Z|#dU@b8V;)Ts* zIQGKzIPkL7zj~eGswPEtu<#N@k(^PFx56S!0esai^bIpQha*;vhaqJeHWvN;qPqg@ z=eLiDtmn{#Z9Hdn3}Gs$r*da8EJ7icXR=`^yJAms7ndq}-aJbpq=>^4MhX)D8C%8- zZJa&kCz9jUft`0t^>kVyEw|3cdnixsvbdh5Cq8266uh9|D!SRZuL}iQ@aFh8UcgY3! z4dQ>y&o}aIpp9M=>nIyn+e5;WeO77yy88{eyYow$1@&~r^`$f4-EqNIwj}ZLLW!n{ z`4G%CK!%*_tyw48sDl$_A>NXLEDPc9T+D%Ry}fLcPc3YSoN$`ebw5-S5wRYu)|*al z7#oAha3tytV^IRgH8PSN0xx5h!B$szuE&V?JD?VpksEDfeuj@vRjQ)vCWBwMJ|C1_ zB*yI`q>(5=u6BU%gEn6f6KVZ_a}M@S;hX)@v5U!F)r$Tg6{(fdPBX3q1xwA=1r?=u z!6IR51_BD47*T_~*FR7& +Quotas live in the survey editor, on the **Settings** tab: + +![The Quotas section of the survey editor settings](/images/surveys/general-features/quota-management/quotas.webp) + ### Key benefits - **Balanced Data Collection**: Ensure your survey responses are evenly distributed across different segments diff --git a/docs/surveys/general-features/tags.mdx b/docs/surveys/general-features/tags.mdx index 15554ccb5632..3cc7af9ec5ac 100644 --- a/docs/surveys/general-features/tags.mdx +++ b/docs/surveys/general-features/tags.mdx @@ -61,6 +61,8 @@ Access the tag management page to view and organize all tags in your environment +![The tag manager, listing each tag with its usage count](/images/surveys/general-features/tags/manager.webp) + ### Edit tag names 1. In the tag management page, click on the tag name field diff --git a/docs/surveys/website-app-surveys/cooldown-period.mdx b/docs/surveys/website-app-surveys/cooldown-period.mdx index ba0f51bf0a38..fdfca4915958 100644 --- a/docs/surveys/website-app-surveys/cooldown-period.mdx +++ b/docs/surveys/website-app-surveys/cooldown-period.mdx @@ -16,6 +16,8 @@ To adjust the workspace-wide Cooldown Period: 2. Find the **Cooldown Period (across surveys)** section. 3. Set the interval, in days. +![The workspace-wide Cooldown Period setting](/images/surveys/website-app-surveys/cooldown-period/workspace-setting.webp) + After a user sees *any* survey, no survey will be shown to them again until the Cooldown Period has elapsed. ## Overriding the Cooldown Period for a survey From c98bb9e096dd36f484de664e1427539d2cb9a694 Mon Sep 17 00:00:00 2001 From: Johannes <72809645+jobenjada@users.noreply.github.com> Date: Fri, 28 Aug 2026 08:46:05 +0200 Subject: [PATCH 04/28] docs(surveys): document the CSAT and CES question types (ENG-2718) (#9035) Co-authored-by: Claude Opus 5 --- docs/docs.json | 2 + .../surveys/question-type/ces/editor.webp | Bin 0 -> 59232 bytes .../surveys/question-type/csat/editor.webp | Bin 0 -> 64044 bytes docs/surveys/question-type/ces.mdx | 49 ++++++++++++++++ docs/surveys/question-type/csat.mdx | 54 ++++++++++++++++++ 5 files changed, 105 insertions(+) create mode 100644 docs/images/surveys/question-type/ces/editor.webp create mode 100644 docs/images/surveys/question-type/csat/editor.webp create mode 100644 docs/surveys/question-type/ces.mdx create mode 100644 docs/surveys/question-type/csat.mdx diff --git a/docs/docs.json b/docs/docs.json index 3eb5492d807f..40afa98c4e77 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -184,8 +184,10 @@ "icon": "question", "pages": [ "surveys/question-type/address", + "surveys/question-type/ces", "surveys/question-type/consent", "surveys/question-type/contact-info", + "surveys/question-type/csat", "surveys/question-type/date", "surveys/question-type/file-upload", "surveys/question-type/free-text", diff --git a/docs/images/surveys/question-type/ces/editor.webp b/docs/images/surveys/question-type/ces/editor.webp new file mode 100644 index 0000000000000000000000000000000000000000..ece647a9c9220c01ccb29009bb01c39f459354a3 GIT binary patch literal 59232 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