From 34256be10ccadc4cac955b63bc2d482839a2d3ea Mon Sep 17 00:00:00 2001 From: zzstoatzz Date: Thu, 16 Jul 2026 21:07:46 -0500 Subject: [PATCH] match v2 dictionary compression contract --- README.md | 3 +- docs/semantic-parity.md | 2 +- docs/upstream-subscribe-protocol.md | 13 + src/assets/zstd_dictionary_v2.b64 | 729 ++++++++++++++++++++++++++++ src/internal/homepage.zig | 2 + src/internal/server.zig | 74 ++- src/internal/xrpcapi.zig | 20 +- src/internal/zstd.zig | 40 +- 8 files changed, 867 insertions(+), 16 deletions(-) create mode 100644 src/assets/zstd_dictionary_v2.b64 diff --git a/README.md b/README.md index ba48121..f0d11fc 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,8 @@ the live, phone-sized field report is at ## capabilities - live Jetstream feeds at `/subscribe` and `/subscribe-v2`, with collection and - DID filters, cursor replay, runtime option updates, and zstd compression + DID filters, cursor replay, runtime option updates, frozen v1 zstd, and + fetchable dictionary-negotiated v2 zstd - a disk-backed historical archive exposed through `listSegments`, `getSegment`, `getBlock`, and `planBackfill`; Stream's sealed `jss` v1 segments are byte-compatible with upstream Jetstream diff --git a/docs/semantic-parity.md b/docs/semantic-parity.md index 2e7515b..9e79b9b 100644 --- a/docs/semantic-parity.md +++ b/docs/semantic-parity.md @@ -15,7 +15,7 @@ this document or `bootstrap-semantic-parity.md` is open. | Bootstrap, merge, retry | Detailed row-by-row contract and adversity receipt | See `bootstrap-semantic-parity.md`; adversity remains open | | JSS v1 storage | Upstream-produced fixture, reciprocal segment parsing, checksum/index/gloom vectors | closed for sealed format; rerun reciprocal corpus before experiment | | Archive XRPC | Official Go client plus Stream conformance replay over listSegments/getSegment/getBlock/planBackfill | implementation present; fresh full suite required | -| Subscribe v1/v2 | Wire/filter/cursor/zstd unit and local e2e coverage | Cursor parsing/resolution now precedes upgrade; both endpoints use the seq/time-us magnitude split, v1 clamps below-floor seqs, and v2 rejects them. Hot/cold scan, skip, encode, options-update, oversize-parser, clean peer/server close, cursor-resolution, and sustained adversarial-rate boundaries feed the canonical metrics, with deterministic offline tests derived from upstream. Subscriber transport sends a ping every 30 seconds, applies a kernel-enforced five-second deadline to every frame write, and sends close code 1001 before intentional server shutdown while keeping transport failure out of clean-disconnect accounting. A failed delivery, cold read, ping, or adversarial-rate check interrupts the server reader and removes the connection instead of leaving a ping-only zombie. **Still open:** official-client replay, v2 dictionary negotiation/download, and pre-upgrade timestamp translation fault classification. | +| Subscribe v1/v2 | Wire/filter/cursor/zstd unit and local e2e coverage | Cursor parsing/resolution now precedes upgrade; both endpoints use the seq/time-us magnitude split, v1 clamps below-floor seqs, and v2 rejects them. Hot/cold scan, skip, encode, options-update, oversize-parser, clean peer/server close, cursor-resolution, and sustained adversarial-rate boundaries feed the canonical metrics, with deterministic offline tests derived from upstream. Subscriber transport sends a ping every 30 seconds, applies a kernel-enforced five-second deadline to every frame write, and sends close code 1001 before intentional server shutdown while keeping transport failure out of clean-disconnect accounting. A failed delivery, cold read, ping, or adversarial-rate check interrupts the server reader and removes the connection instead of leaving a ping-only zombie. V2 dictionary negotiation, exact pinned dictionary download/validators, and v2 binary delivery are implemented independently of the frozen v1 dictionary contract. **Still open:** official-client replay and pre-upgrade timestamp translation fault classification. | | Sync 1.1 live verification | Upstream requires durable per-DID chain/hosting state, MST inversion, op-CID consistency, rev replay/future guards, default acceptance of legacy-shaped commits, transparent whole-repo repair, and Atmos delivery scheduling | **closed at the implementation boundary.** Diff-CAR/MST inversion (including upstream's narrow default lenient carve-out), post-state op-CID proof, signed inner/outer consistency, exact decimal size/future-rev/replay gates, exact legacy-shape detection with default `LegacyAccept`, two-phase durable chain/hosting state, and account/identity replay ratchets are implemented. Recoverable decode/inversion/duplicate-path/op-CID/chain failures route to repair; signature failures and outer/inner producer-integrity mismatches bypass it, and no failed event is archived. `prepareRepo` retains and authenticates the canonical signed complete head without a second multi-gigabyte parse/walk. The live path now uses Atmos's 32 worker slots, one worker-held FIFO chain per DID, a 64-pending drop-oldest boundary, completion-order batches of 50/500 ms across DIDs, and `min(inflight)-1` cursor watermarks. Dropped and silent events leave the inflight set without inventing a delivery batch; cursor advancement remains coupled to durable archive boundaries. Offline receipts use real encoded frames, real RocksDB verifier state, and actual worker blocking rather than fixture verdicts or scheduler mocks. See `live-scheduler.md`. | | Sync 1.1 resync ordering | Upstream serializes per DID, drops stale async repairs, and emits a sync tombstone plus authoritative replacements | **closed at the implementation boundary.** The live coordinator has 32 real fetch workers, a 64-job queue, a five-minute fetch budget plus the 1,000 B/s-for-30-seconds slow-transfer guard, a bounded 16,384-entry 5/minute-per-DID limiter, 2,048 pending commits with drop-oldest overflow, fetch outside the DID lane, authenticated apply with older/equal-contradictory head rejection, ordered pending replay, and trigger-ticket-gated outbox delivery. Commit divergence schedules async repair; `#sync` divergence attempts inline repair and queues one retry only for transient failure, preserving the original relay cursor only on inline success. The writer emits `sync` then bounded 1,024-row `create_resync` batches and stages the fetched/pending chain checkpoints under the archive lock before any matching fsync. Loopback-only tests exercise a real HTTP getRepo mmap, real DID resolution/signature, buffering while the response is held open, slow-transfer cancellation, durable RocksDB promotion/cursor coupling, v2 tail publication, and sealed JSS row order. | | Timestamp import | Canonical dashboard and API include timestamp import lifecycle/rewrite metrics and behavior | **Closed at the implementation boundary.** The format preserves distinct `witnessed_at` and sentinel-zero `indexed_at` columns. Subscriber v1/v2 encoding applies upstream's `indexed_at != 0 ? indexed_at : witnessed_at` display rule while ranges and timestamp cursors remain anchored to immutable witness envelopes. The strict seekable RFC 4180 parser matches upstream's header, row rejection, byte-offset, CID, RFC3339, 64 KiB, and bounded-sampling contracts in a forward-only allocation-free pass. A separate Bloom-filtered RocksDB rule store bulk-loads sorted external SST chunks with CSV-order last-write-wins, reconstructs its resident collection gate on open, and implements specific-CID precedence with all-version fallback. Its central archive-lock hook stamps live, repair, bootstrap, and merge materializations before sequence assignment, and feeds the mutated rows to immediate delivery so hot and cold encodings agree. The sealed-JSS patch primitive preserves block topology/envelopes, clean frames, and the opaque bloom/collection footer while atomically changing only `indexed_at`; it is exercised against an upstream-produced segment. A concrete sealed-segment bloom catalog, bounded DID/FD bucketer, fsynced packed offsets, positioned revalidation, and collision-safe per-segment patch plan implement Phase B/C with specific-CID precedence and idempotent disk-to-disk coverage. A dedicated archive rewrite mutex serializes the real delete compactor with timestamp patching while leaving live append available. The unified metadata DB synchronously persists the current-job pointer, complete job record, and per-segment done set. The real runner activates rules before force-seal, durably crosses the bucketed handoff, checkpoints only after patch fsync/rename/dir-sync, retains partial cancellation progress, and resumes after full archive/rule/metadata reopen. The background manager canonicalizes symlinks, confines regular files, enforces one durable nonterminal job, and adopts it on startup. Bearer-gated import/status XRPC matches the pinned lexicons, fixed-width digest comparison, error names/statuses, steady-state admission, and current/by-id status behavior; a real loopback HTTP run exercised it against the local simulator. Every canonical import metric is produced at its real parse, route, patch, or durable-terminal boundary; cancellation remains a resumable pause and is not counted as terminal failure. | diff --git a/docs/upstream-subscribe-protocol.md b/docs/upstream-subscribe-protocol.md index 55373b1..6e19998 100644 --- a/docs/upstream-subscribe-protocol.md +++ b/docs/upstream-subscribe-protocol.md @@ -31,6 +31,19 @@ endpoint: `GET /subscribe` → websocket upgrade. pre-upgrade errors are plain H - zstd dictionary: dict ID 1612007021, 112640 bytes, upstream `internal/subscribe/zstd_dictionary` (verbatim v1 `pkg/models/zstd_dictionary`). out-of-band, both sides ship identical file. 128KiB window, each message a standalone zstd frame. - offering zstd AND permessage-deflate simultaneously → 400 +### v2 compression +- `/subscribe-v2` rejects the v1 `compress=true` and `Socket-Encoding: zstd` + opt-ins. Its only compression scheme is `zstdDictionary=`. +- the current structured dictionary is the exact pinned upstream 65,536-byte + artifact with ID `20260709`. Clients fetch it from + `network.bsky.jetstream.getZstdDictionary`, then reconnect with that ID. +- a malformed ID is 400. An unknown/retired ID is 400 with the stable + `unknown zstd dictionary id` marker and current ID. V1 ignores this v2-only + parameter. +- the dictionary XRPC serves exact bytes with ETag + `"zstd-dict-20260709"`, `X-Zstd-Dictionary-Id: 20260709`, and one-year + immutable public caching; exact-ID lookup and conditional 304 are supported. + ### requireHello - true iff value is exactly literal `"true"` - when true: upgrade accepted, no events until first valid `options_update`; no pre-hello buffering; invalid update during wait disconnects diff --git a/src/assets/zstd_dictionary_v2.b64 b/src/assets/zstd_dictionary_v2.b64 new file mode 100644 index 0000000..279a26d --- /dev/null +++ b/src/assets/zstd_dictionary_v2.b64 @@ -0,0 +1,729 @@ +N6Qw7GUnNQE1EMCS1AEzMAMzMAMzBGHZJdtdUmdyw23KzKsSa61FP0JFDSr2f/vRjwcKI3uizOROECkDuwpjBwAAAAwCMUCOJJGwHgTAQAcKCosGBIOEAoKG +koiLhgqMCodjwVBEFo3EgiiURTEMI0ncYAAAAHSKgkGhoQKmoWk0DoVCYUAYDA6lYyLWCgAAAAEAAAAEAAAACAAAAHJlaWUyaWVsbDZ5NHZqdHl3bndkcnht +d3V0YW9yN3dibWRmb3o3cGhkaXJpcTIyZ3RnbXlyZ3EiLCJ1cmkiOiJhdDovL2RpZDpwbGM6b29qaGFoZHNteXlwZnl5eHJlb3h3cXFwL2FwcC5ic2t5LmZl +ZWQucG9zdC8zbXE3dHRhbmR0czIyIn19LCJjaWQiOiJiYWZ5cmVpZ3hwbGVycTR6aHUzZmY1bGdicGdoaHl2ZHh4eWp4czRnNnZpcTZ6MmQ2b3BpdTRoNW40 +YSIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcFpUSnBaV3hz +Tm5rMGRtcDBlWGR1ZDJSeWVHMTNkWFJoYjNJM2QySnRaR1p2ZWpkd2FHUnBjbWx4TWpKbmRHZHRlWEpuY1dOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwdmIy +cG9ZV2hrYzIxNWVYQm1lWGw0Y21WdmVIZHhjWEF2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZDBkR0Z1WkhSek1qSnBZM0psWVhSbFpFRjBlQmd5 +TURJMkxUQTNMVEE1VkRFMk9qTTNPakF3TGpJd01Wbz0ifX17ImRpZCI6ImRpZDpwbGM6YTZnNjNpN3Fpc3NmanZnNTdmeWpoYXh2IiwidGltZV91cyI6MTc4 +MzYxNDkxNDcyNjcxMCwiY3Vyc29yIjoyMjU4Mjc1NjgyNCwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI3NTY4MjQsImNvbW1pdCI6eyJyZXYiOiIzbXFh +MnVxYW1wNjJ4Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXkiOiIzbXFhMnVxYWZ1ZzJ4Iiwi +cmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5saWtlIiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNToxNC4yNzlaIiwic3ViamVjdCI6eyJj +aWQiOiJiYWZ5cmVpaHVyZG8ycm0zcWt4dmJiM2NvZ25saW55d3Vyc2d1bWtpYmlqaWZ2eHFteWxidTN6Z3pleXJlaWU1N3N5empxc2JzZjZ6aWRmejJvMzNw +cHFsdHNkcG1teWl3bTQ1ZzNzbnRvYmdpY3Vrb2UiLCJ1cmkiOiJhdDovL2RpZDpwbGM6dXloNWh1enh0dGh0a2c2aHRzZ3Q1NmxoL2FwcC5ic2t5LmZlZWQu +cG9zdC8zbXFhMnNvb3YzaTJmIn19LCJ0ZXh0IjoiU2hlJ3MganVzdCB0aGUgbW9zdCB0cmFuc3BhcmVudC4gLiAuIHRoZXJlIGlzIGEgbm90IGluc2lnbmlm +aWNhbnQgbnVtYmVyIG9mIGN1bHRpc3RzIHRoYXQgZmVlbCB0aGlzIHZlcnkgc2FtZSB3YXkuIn0sImNpZCI6ImJhZnlyZWllenptZGdrN3JqeXN6aHdwN2d2 +Mnk3MjRlcndhb2lnM2Zzc3lrcmRma2licHlydHh0eGs0IiwicmVjb3JkX2Nib3IiOiJwV1IwWlhoMGVISlRhR1VuY3lCcWRYTjBJSFJvWlNCdGIzTjBJSFJ5 +WVc1emNHRnlaVzUwTGlBdUlDNGdkR2hsY21VZ2FYTWdZU0J1YjNRZ2FXNXphV2R1YVdacFkyRnVkQ0J1ZFcxaVpYSWdiMllnWTNWc2RHbHpkSE1nZEdoaGRD +Qm1aV1ZzSUhSb2FYTWdkbVZ5ZVNCellXMWxJSGRoZVM1bEpIUjVjR1Z5WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWld4aGJtZHpnV0psYm1WeVpYQnNlYUpr +Y205dmRLSmpZMmxrZUR0aVlXWjVjbVZwWlRVM2MzbDZhbkZ6WW5ObU5ucHBaR1o2TW04ek0zQndjV3gwYzJSd2JXMTVhWGR0TkRWbk0zTnVkRzlpWjJsamRX +dHZaV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenAxZVdnMWFIVjZlSFIwYUhSclp6Wm9kSE5uZERVMmJHZ3ZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50 +Y1dFeWMyOXZkak5wTW1abWNHRnlaVzUwb21OamFXUjRPMkpoWm5seVpXbGxOVGR6ZVhwcWNYTmljMlkyZW1sa1pub3liek16Y0hCeGJIUnpaSEJ0YlhscGQy +MDBOV2N6YzI1MGIySm5hV04xYTI5bFkzVnlhWGhHWVhRNkx5OWthV1E2Y0d4ak9uVjVhRFZvZFhwNGRIUm9kR3RuTm1oMGMyZDBOVFpzYUM5aGNIQXVZbk5y +ZVM1bVpXVmtMbkJ2YzNRdk0yMXhZVEp6YjI5Mk0ya3labWxqY21WaGRHVmtRWFI0R0RJd01qWXRNRGN0TURsVU1UWTZNemM2TkRVdU56WXpXZz1jbVZwWlhO +dWFEUnRibVpqWW5aaGJXUTBiVE16WkRRMU5qZDJkelYxTldWNmJHOXZOR2hwWnpkMGFuQnpaWEZ3Ykc5elltSmtaV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZ +enB1ZG1ad2IzTnRjRzFvWldkMGVYWm9Zbk0zTlhNemNIY3ZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkNWRHbHRZWGhqTW5ScFkzSmxZWFJsWkVG +MGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMk9qRTNMall4TUZvPSJ9fXsiZGlkIjoiZGlkOnBsYzptYjYya2tpdjV4c2VtMmM3Z2U2d2RrcHMiLCJ0aW1lX3Vz +IjoxNzgzNjE0OTMwMzI3Mzk3LCJjdXJzb3IiOjIyNTgyNzY0NzQ4LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc2NDc0OCwiY29tbWl0Ijp7InJldiI6 +IjNtcWEydjdhdHkyMmwiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNtcWEydjdhamFj +MmwiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM1OjMwLjA1OFoiLCJzdWJqZWN0 +Ijp7ImNpZCI6ImJhZnlyZWlkYWNvNTdnbms2emNveGJqaGZubmdqcWVzeXlhM3Vwb2tnbGF0eWthbDR1YzVqN203ZXBlIiwidXJpIjoiYXQ6Ly9kaWQ6cGxj +OnJyZndydWh1ZDRvdmVsYTNvZTZpc3JlNS9hcHAuYnNreS5mZWVkLnBvc3QvM21xYTJ1MmNxYXMyZSJ9fSwiY2lkIjoiYmFmeXJlaWFpZmI1Ym54cjVudXNv +eXNtZnRzdDVycmc1dXRlNG42YXV0aW1nNmdhcWdkcHliaWxudGkiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJW +bmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBaR0ZqYnpVM1oyNXJObnBqYjNoaWFtaG1ibTVuYW5GbGMzbDVZVE4xY0c5cloyeGhkSGxyWVd3MGRXTTFh +amR0TjJWd1pXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cHljbVozY25Wb2RXUTBiM1psYkdFemIyVTJhWE55WlRVdllYQndMbUp6YTNrdVptVmxaQzV3YjNO +MEx6TnRjV0V5ZFRKai5wb3N0LzNtcTdtNGtsd3VrMnQifX0sInRleHQiOiJTaW5jZSBldmVyeWJvZHkgZWxzZSBoYXMgXCJzaGUncyBhbiBldmlsIHNoaXRi +YWdcIiBzZXduIHVwLCBJJ20gZ29pbmcgdG8gZm9jdXMgb24gdGhhdCBoYWlyY3V0LiJ9LCJjaWQiOiJiYWZ5cmVpZHFsYXBvZ3Rqa21rZXVma3AyNmhsaXpl +M2N5Y2lqeGEyemVueHMybjZuYXB5enJhYzRlcSIsInJlY29yZF9jYm9yIjoicFdSMFpYaDBlRjFUYVc1alpTQmxkbVZ5ZVdKdlpIa2daV3h6WlNCb1lYTWdJ +bk5vWlNkeklHRnVJR1YyYVd3Z2MyaHBkR0poWnlJZ2MyVjNiaUIxY0N3Z1NTZHRJR2R2YVc1bklIUnZJR1p2WTNWeklHOXVJSFJvWVhRZ2FHRnBjbU4xZEM1 +bEpIUjVjR1Z5WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWld4aGJtZHpnV0psYm1WeVpYQnNlYUprY205dmRLSmpZMmxrZUR0aVlXWjVjbVZwWVhFemNXeG1h +MjAzTTJOa2Rtc3lOMkZ3Wm01b2VISnpiV0ZvY1c1cmNtSm1NbWMxTW1ack5YbHJaMnBtYTJ4cWVHbDJkV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenB4ZDI5 +NU5YbDBhbU50YkdVek5uUnhOMmhpWm1WeWFua3ZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkdE5HdHNkM1ZyTW5SbWNHRnlaVzUwb21OamFXUjRP +MkpoWm5seVpXbGhjVE54YkdacmJUY3pZMlIyYXpJM1lYQm1ibWg0Y25OdFlXaHhibXR5WW1ZeVp6VXlabXMxZVd0bmFtWnJiR3A0YVhaMVkzVnlhWGhHWVhR +Nkx5OWthV1E2Y0d4ak9uRjNiM2sxZVhScVkyMXNaVE0yZEhFM2FHSm1aWEpxZVM5aGNIQXVZbk5yZVM1bVpXVmtMbkJ2YzNRdk0yMXhOMjAwYTJ4M2RXc3lk +R2xqY21WaGRHVmtRWFI0R0RJd01qWXRNRGN0TURsVU1UWTZNelU2TlRVdU9UWXpXZz09In19eyJkaWQiOiJkaWQ6cGxjOm15am9pNGxpZjJsaDR3bGhkbWZx +eXFjMyIsInRpbWVfdXMiOjE3ODM2MTQ5NzQ4Mjc1MjEsImN1cnNvciI6MjI1ODI3ODYyNTYsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzg2MjU2LCJj +b21taXQiOnsicmV2IjoiM21xYTJ3anJ1dWcyYSIsIm9wYnNreS5lbWJlZC52aWRlbyIsImFzcGVjdFJhdGlvIjp7ImhlaWdodCI6Mzg0MCwid2lkdGgiOjIx +NjB9LCJwcmVzZW50YXRpb24iOiJkZWZhdWx0IiwidmlkZW8iOnsiJHR5cGUiOiJibG9iIiwibWltZVR5cGUiOiJ2aWRlby9tcDQiLCJyZWYiOnsiJGxpbmsi +OiJiYWZrcmVpaGFqaDJybnJsanh1N3VieWl3azUzNXM0YjJ3aHpyaWI2czdocnZ6a3hkbzVianhwc2N0dSJ9LCJzaXplIjozMzAyMjQxfX0sImxhYmVscyI6 +eyIkdHlwZSI6ImNvbS5hdHByb3RvLmxhYmVsLmRlZnMjc2VsZkxhYmVscyIsInZhbHVlcyI6W3sidmFsIjoicG9ybiJ9XX0sImxhbmdzIjpbImVuIl0sInRl +eHQiOiIifSwiY2lkIjoiYmFmeXJlaWV5amszM291eXF4ZXpmYzJrd2hhdWl6eTVpN2tzZjZleGtheHZsamJlbXJyYzdia3o3YWkiLCJyZWNvcmRfY2JvciI6 +InBtUjBaWGgwWUdVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xuQnZjM1JsWlcxaVpXU2taU1IwZVhCbGRHRndjQzVpYzJ0NUxtVnRZbVZrTG5acFpHVnZa +WFpwWkdWdnBHTnlaV2JZS2xnbEFBRlZFaURnU2ZVV3hXbTlQMERoRmxkMzJYQTZzZk1VQjlMNTQxeXE0M2RDbTc1Q25XUnphWHBsR2dBeVkyRmxKSFI1Y0dW +a1lteHZZbWh0YVcxbFZIbHdaV2wyYVdSbGJ5OXRjRFJyWVhOd1pXTjBVbUYwYVcraVpYZHBaSFJvR1Fod1ptaGxhV2RvZEJrUEFHeHdjbVZ6Wlc1MFlYUnBi +MjVuWkdWbVlYVnNkR1ZzWVc1bmM0RmlaVzVtYkdGaVpXeHpvbVVrZEhsd1pYZ2hZMjl0TG1GMGNISnZkRzh1YkdGaVpXd3VaR1ZtY3lOelpXeG1UR0ZpWld4 +elpuWmhiSFZsYzRHaFkzWmhiR1J3YjNKdWFXTnlaV0YwWldSQmRIZ1lNakF5Tmkwd055MHdPVlF4Tmpvek5qbzFNeTQwTmpGYSJ9fXsiZGlkIjoiZGlkOnBs +YzphcXB0NHFqdWJ1emJjeG9jN3pnYWZuNzMiLCJ0aW1lX3VzIjoxNzgzNjE0OTQ0OTI5ODg1LCJjdXJzb3IiOjIyNTgyNzcxOTc4LCJraW5kIjoiY29tbWl0 +Iiwic2VxIjoyMjU4Mjc3MTk3OCwiY29tbWl0Ijp7InJldiI6IjNtcWEydm42aWdjMnIiLCJwWXpkamNIaDZjWFJwWjJRM2JtNW5ORFV5TTJFdllYQndMbUp6 +YTNrdVptVmxaQzV3YjNOMEx6TnRjVFoyZGpONWNYUXlNalJwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0xT2pReUxqRTNOVm89In19eyJk +aWQiOiJkaWQ6cGxjOnlzMmp0NWRsNmoyd2twdmxvNTJ2emV2YSIsInRpbWVfdXMiOjE3ODM2MTUwMTI4MjU2NzIsImN1cnNvciI6MjI1ODI4MDQxNjgsImtp +bmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODA0MTY4LCJjb21taXQiOnsicmV2IjoiM21xYTJ4bnhlanUybSIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxl +Y3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJya2V5IjoiM21xYTJ4bng1cDQybSIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQubGlrZSIs +ImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6NTIuNTk1WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWhtc3I2YmVmNXVoaHV5cWtxejVqbHp4b2Fk +aWdsZnBnY2dteGt6N2RsNXdlYmtyaXgzZ3EiLCJ1cmkiOiJhdDovL2RpZDpwbGM6dGN1azNvM2d2aXpvYWV3em54YjVydDR5L2FwcC5ic2t5LmZlZWQucG9z +dC8zbXE3cWhuMnozczJyIn19LCJjaWQiOiJiYWZ5cmVpY21jNWszZHJzM2tzaHJ4YWx1NTc3eGZiczVpcHdkbW40cnphNHJ3N2Z4eW0zenRzeW13dSIsInJl +Y29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcGFHMXpjalppWldZMWRX +aG9kWGx4YTNGNk5XcHNlbmh2WVdScFoyeG1jR2RqWjIxNGEzbzNaR3cxZDJWaWEzSnBlRE5uY1dOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwMFkzVnJNMjh6 +WjNacGVtOWhaWGQ2Ym5oaU5YSjBOSGt2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZHhhRzR5ZWpOek1uSnBZM0psWVhSbFpFRjBlQmd5TURJMkxU +QTNMVEE1VkRFMk9qTTJPalV5TGpVNU5Wbz0ifX17ImRpZCI6ImRpZDpwbGM6a280ZDNnc2YzZ25lbmtldzJ0aXU3NmttIiwidCIsImNyZWF0ZWRBdCI6IjIw +MjUtMTEtMTJUMTE6MTU6MjkuNTAzWiIsImxhbmdzIjpbImVuIl0sInRleHQiOiJnZW5zaGluIGZhbnMgd2lsbCBzZWUgYSBjaGFyYWN0ZXIgc28gdGhpbiB5 +b3UgY291bGQgdG91Y2ggdGhlaXIgcmlicyBhbmQgaW5zaXN0IHRoZXlyZSBjaHViYnkgYmMgdGhlaXIgZ2FtZXMgYXJlIHNvIHN0YXJ2ZWQgZm9yIGFueXRo +aW5nIHRoYXQgaXNudCBhIHNraW5ueSB3aGl0ZSB3b21hbiB0aGV5IGhhdmUgdG8gZ2FzbGlnaHQgdGhlbXNlbHZlcyBpbnRvIHRoaW5raW5nIHRoZXJlcyBh +bnkgbW9yZSBtZWxhbmluIG9yIGZhdCBvbiB0aGVpciBib2R5IHRoYW4gMCJ9LCJjaWQiOiJiYWZ5cmVpZXFyY3Fxd3RwdnJwa29oNXFoaWwyMjd0aG1veWQz +cDYzdDR1cmxraDVtZDdwNG02eW5paSIsInJlY29yZF9jYm9yIjoicEdSMFpYaDBlUUVLWjJWdWMyaHBiaUJtWVc1eklIZHBiR3dnYzJWbElHRWdZMmhoY21G +amRHVnlJSE52SUhSb2FXNGdlVzkxSUdOdmRXeGtJSFJ2ZFdOb0lIUm9aV2x5SUhKcFluTWdZVzVrSUdsdWMybHpkQ0IwYUdWNWNtVWdZMmgxWW1KNUlHSmpJ +SFJvWldseUlHZGhiV1Z6SUdGeVpTQnpieUJ6ZEdGeWRtVmtJR1p2Y2lCaGJubDBhR2x1WnlCMGFHRjBJR2x6Ym5RZ1lTQnphMmx1Ym5rZ2QyaHBkR1VnZDI5 +dFlXNGdkR2hsZVNCb1lYWmxJSFJ2SUdkaGMyeHBaMmgwSUhSb1pXMXpaV3gyWlhNZ2FXNTBieUIwYUdsdWEybHVaeUIwYUdWeVpYTWdZVzU1SUcxdmNtVWdi +V1ZzWVc1cGJpQnZjaUJtWVhRZ2IyNGdkR2hsYVhJZ1ltOWtlU0IwYUdGdUlEQmxKSFI1Y0dWeVlYQndMbUp6YTNrdVptVmxaQzV3YjNOMFpXeGhibWR6Z1dK +bGJtbGpjbVZoZEdWa1FYUjRHREl3TWpVdE1URXRNVEpVTVRFNk1UVTZNamt1TlRBeldnPT0ifX17ImRpZCI6ImRpZDpwbGM6ZTc3aW9vcXVmZnZ3aW5scnF6 +cjZ1eXNwIiwidGltZV91cyI6MTc4MzYxNTAwNzMyNzY1NCwiY3Vyc29yIjoyMjU4MjgwMTU1NSwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MDE1NTUs +ImNvMDlUMTY6Mzc6MzAuOTI0WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWU3eXIyczRwYjI2Yzd3bnZ6dGc3NnRqYTd1anR3b2EyN3RpYXMzN3JsMnQ3 +M2Izc3NqYXEiLCJ1cmkiOiJhdDovL2RpZDpwbGM6dXhkd2I0M3ptcGVqejJreXNlaGVtZjV0L2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3enhhN3hoYzJnIn0s +InZpYSI6eyJjaWQiOiJiYWZ5cmVpZXAyNmxkY3B6a2hxbjVhd2Z0dTJyd3dkcDRzM3NyaW5xeTJ2N3RveHByb3FyZGV0eWFobSIsInVyaSI6ImF0Oi8vZGlk +OnBsYzozY3FueDJtdnZia2t1eHIzbWxzNnB2NHUvYXBwLmJza3kuZmVlZC5yZXBvc3QvM21xYTJ2cGw3ZGYyYiJ9fSwiY2lkIjoiYmFmeXJlaWN4aGt5cnh0 +cm9wbHU0MzQ0M3hqemd2enh6N2Y3amRtcHJhY3BydzZhcHR4bWdvaHd4djQiLCJyZWNvcmRfY2JvciI6InBHTjJhV0dpWTJOcFpIZzdZbUZtZVhKbGFXVndN +alpzWkdOd2VtdG9jVzQxWVhkbWRIVXljbmQzWkhBMGN6TnpjbWx1Y1hreWRqZDBiM2h3Y205eGNtUmxkSGxoYUcxamRYSnBlRWhoZERvdkwyUnBaRHB3YkdN +Nk0yTnhibmd5YlhaMlltdHJkWGh5TTIxc2N6WndkalIxTDJGd2NDNWljMnQ1TG1abFpXUXVjbVZ3YjNOMEx6TnRjV0V5ZG5Cc04yUm1NbUpsSkhSNWNHVnlZ +WEJ3TG1KemEza3VabVZsWkM1c2FXdGxaM04xWW1wbFkzU2lZMk5wWkhnN1ltRm1lWEpsYVdVM2VYSXljelJ3WWpJMll6ZDNiblo2ZEdjM05uUnFZVGQxYW5S +M2IyRXlOM1JwWVhNek4zSnNNblEzTTJJemMzTnFZWEZqZFhKcGVFWmhkRG92TDJScFpEcHdiR002ZFhoa2QySTBNM3B0Y0dWcWVqSnJlWE5sYUdWdFpqVjBM +MkZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkQzh6YlhFM2VuaGhOM2hvWXpKbmFXTnlaV0YwWldSQmRIZ1lNakF5Tmkwd055MHdPVlF4Tmpvek56b3pNQzQ1TWpS +YSJ9fXsiZGlkIjoiZGlkOnBsYzp2azdiaWtjZzVuYTM2emw2bW9wN3psaXkiLCJ0aW1lX3VzIjoxNzgzNjE0OTczNDMwOTEyLCJjdXJzb3IiOjIyNTgyNzg1 +NTg1LCJraW5kIjoiYWNjb3VudCIsInN0Oi8vZGlkOnBsYzpoNmduM2FyNXRrM2F2aW56bHd2bndiaHAvYXBwLmJza3kuZmVlZC5wb3N0LzNtcWEyY2ttcDVz +MmoifSwicm9vdCI6eyJjaWQiOiJiYWZ5cmVpYXN4a2l2bG91M3l5ZzRpNmdwa2N0bTN2NWlzYmdmMzRid2xlN2NnYXZnN3N4M29zb3JweSIsInVyaSI6ImF0 +Oi8vZGlkOnBsYzpibndncGNlYWhtbDZhN25lbWF0NG91YWMvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd6Nzdpd2oyMm0ifX0sInRleHQiOiJZZXMsIHRoZSBi +aWdnZXN0IGFkdmFudGFnZSBzaGUgaGFzIGlzIHRoZSBhdG9taXphdGlvbiBvZiB0aGUgZW50aXJlIGZpZWxkIGJldHdlZW4gaGVyIGFuZCBNw6lsZW5jaG9u +LiBCdXQgaXQncyBlYXJseSwgc2hlIGRvZXNuJ3QgYWdlIHdlbGwgd2l0aCBjbG9zZXIgY29udGFjdCwgYW5kIGlmIHNvbWVvbmUgcGFsYXRhYmxlIG9uIHRo +ZSBjZW50ZXIgcmlnaHQgb3IgbGVmdCBtYW5hZ2VzIHRvIGNvbnNvbGlkYXRlIHN1cHBvcnQgKGJpZyBpZiwgSSBrbm93KSwgSSB0aGluayBzaGUnbGwgbG9z +ZSBhZ2Fpbi4ifSwiY2lkIjoiYmFmeXJlaWZ4YXVqYXJ3aGFrdGVsbGl2N3k2M3R4azR2aWJzaHI0MmIybDV1cWp4anljaWluM2FiN2UiLCJyZWNvcmRfY2Jv +ciI6InBXUjBaWGgwZVFFZ1dXVnpMQ0IwYUdVZ1ltbG5aMlZ6ZENCaFpIWmhiblJoWjJVZ2MyaGxJR2hoY3lCcGN5QjBhR1VnWVhSdmJXbDZZWFJwYjI0Z2Iy +WWdkR2hsSUdWdWRHbHlaU0JtYVdWc1pDQmlaWFIzWldWdUlHaGxjaUJoYm1RZ1RjT3BiR1Z1WTJodmJpNGdRblYwSUdsMEozTWdaV0Z5Ykhrc0lITm9aU0Jr +YjJWemJpZDBJR0ZuWlNCM1pXeHNJSGRwZEdnZ1kyeHZjMlZ5SUdOdmJuUmhZM1FzSUdGdVpDQnBaaUJ6YjIxbGIyNWxJSEJoYkdGMFlXSnNaU0J2YmlCMGFH +VWdZMlZ1ZEdWeUlISnBaMmgwSUc5eUlHeGxablFnYldGdVlXZGxjeUIwYnlCamIyNXpiMnhwWkdGMFpTQnpkWEJ3YjNKMElDaGlhV2NnYVdZc0lFa2dhMjV2 +ZHlrc0lFa2dkR2hwYm1zZ2MyaGxKMnhzSUd4dmMyVWdZV2RoYVc0dVpTUnlxcy9hcHAuYnNreS5mZWVkLnBvc3QvM21xYTJ0amh4MjIyayJ9fSwidGV4dCI6 +IlRlZXRoISBNeW90aSB0ZWV0aCBhcmUgYWxsIGVxdWFsbHkgc2hhcnAsIGJ1dCBmb3IgTGlhIG9ubHkgaGVyIGZhbmdzIGFyZSBzaGFycCBhbmQgZWxvbmdh +dGVkLiBUaGF0IGJlaW5nIHNhaWQsIGFsbCBoZXIgdGVldGggYXJlIGp1c3QgYXMgdG91Z2guIFRoZXkncmUgb21uaXZvcmVzIGluIHRoZSB0cnVlc3Qgc2Vu +c2UsIHN1cnZpdmluZyBvZmYgcm9jayBoYXJkIHJvb3QgcGxhbnRzIGFuZCB0b3VnaCBtZWF0cy4gVGhlIGluc2lkZSBvZiBoZXIgbW91dGggaXMgYmxhY2sg +YmVjYXVzZSBJIGxpa2UgaG93IGl0IGxvb2tzLiJ9LCJjaWQiOiJiYWZ5cmVpZ203cHl2ZHJuanZqamdkZ2JudzcyZmJrcW9wcjU0YWo3d2dhZnptNmlvcXcy +YnZkaXI0aSIsInJlY29yZF9jYm9yIjoicG1SMFpYaDBlUUVwVkdWbGRHZ2hJRTE1YjNScElIUmxaWFJvSUdGeVpTQmhiR3dnWlhGMVlXeHNlU0J6YUdGeWND +d2dZblYwSUdadmNpQk1hV0VnYjI1c2VTQm9aWElnWm1GdVozTWdZWEpsSUhOb1lYSndJR0Z1WkNCbGJHOXVaMkYwWldRdUlGUm9ZWFFnWW1WcGJtY2djMkZw +WkN3Z1lXeHNJR2hsY2lCMFpXVjBhQ0JoY21VZ2FuVnpkQ0JoY3lCMGIzVm5hQzRnVkdobGVTZHlaU0J2Ylc1cGRtOXlaWE1nYVc0Z2RHaGxJSFJ5ZFdWemRD +QnpaVzV6WlN3Z2MzVnlkbWwyYVc1bklHOW1aaUJ5YjJOcklHaGhjbVFnY205dmRDQndiR0Z1ZEhNZ1lXNWtJSFJ2ZFdkb0lHMWxZWFJ6TGlCVWFHVWdhVzV6 +YVdSbElHOW1JR2hsY2lCdGIzVjBhQ0JwY3lCaWJHRmpheUJpWldOaGRYTmxJRWtnYkdsclpTQm9iM2NnYVhRZ2JHOXZhM011WlNSMGVYQmxjbUZ3Y0M1aWMy +dDVMbVpsWldRdWNHOXpkR1ZsYldKbFpLSmxKSFI1Y0dWMVlYQndMbUp6YTNrdVpXMWlaV1F1YVcxaFoyVnpabWx0WVdkbGM0R2pZMkZzZEhoL1RHbGhJR2h2 +YkdSeklHaGxjaUIwYVd4MFpXUWdabUZqWlNCcGJpQmliM1JvSUdoaGJtUnpJR0Z1WkNCbmFYWmxjeUIwYUdVLy9kaWQ6cGxjOmR1YjMyNDJlY2JnZ2p2M2F2 +N3VsNW9uZy9hcHAuYnNreS5mZWVkLnBvc3QvM21wdDNmNTd2NWsyYSJ9fSwiY2lkIjoiYmFmeXJlaWVqYmJldmZkcnQ3ZG5jYmoyeTR5YzM0cm93cjd4azV2 +NGxpcXBsMmZwZW5xcXBicWI3NmUiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtl +RHRpWVdaNWNtVnBaelZvYkhaeWREUXlOekpoZVdjek56ZDJiMjgzYm5sM1pYUXliMmhsWkhSbGNuQnplREp3WVdSa2FXcG1OV1oyTjI5aWFXTjFjbWw0Um1G +ME9pOHZaR2xrT25Cc1l6cGtkV0l6TWpReVpXTmlaMmRxZGpOaGRqZDFiRFZ2Ym1jdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjSFF6WmpVM2RqVnJN +bUZwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0yT2pVNUxqRTVNbG89In19eyJkaWQiOiJkaWQ6cGxjOjJ0dmJpeXd2bWR6eDV0bmJsYW1p +am1oZCIsInRpbWVfdXMiOjE3ODM2MTUwMjgzMzExMTcsImN1cnNvciI6MjI1ODI4MTMzOTcsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODEzMzk3LCJj +b21taXQiOnsicmV2IjoiM21xYTJ5NG5oaHIydyIsIm9wZXJhdGlvbiI6InVwZGF0ZSIsImNvbGxlY3Rpb24iOiJmbS50ZWFsLmFscGhhLmFjdG9yLnN0YXR1 +cyIsInJrZXkiOiJzZWxmIiwicmVjb3JkIjp7IiR0eXBlIjoiZm0udGVhbC5hbHBoYS5hY3Rvci5zdGF0dXMiLCJleHBpcnkiOiIyMDI2LTA3LTA5VDE2OjQ3 +OjA3LjgzOFoiLCJpdGVtIjp7ImFydGlzdHMiOlt7ImFydGlzdE5hbWUiOiJSeWFuIEJlYXR0eSJ9XSwiZHVyYXRpb24iOm51bGwsInBsYXllZFRpbWUiOiIy +MDI2LTA3LTA5VDEzOjMxOjM0LjYwM1oiLCJyZWxlYXNlTWJJZCI6Im1iaWQ6ZDY1NzE4YjEtMTcxNS00Mzg3LWI4OTktNjViNTY2NTRlODUzIiwicmVsZWFz +ZU5hbWUiOiJTd2VldCBGb3J0dW5lIiwic3VibWlzc2lvbkNsaWVudEFnZW50IjoibXVsdGktc2Nyb2JibGVyLzAuMTQuMiIsInRyYWNrTmFtZSJvek5UbzBN +eTR6TWpKYSJ9fXsiZGlkIjoiZGlkOnBsYzp4M2phZzVka3dkemF6czQ1andraTQ2eHAiLCJ0aW1lX3VzIjoxNzgzNjE1MDU1MjM1MzY1LCJjdXJzb3IiOjIy +NTgyODI1NjE5LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4MjgyNTYxOSwiY29tbWl0Ijp7InJldiI6IjNtcWEyeXdjNWY1Mm8iLCJvcGVyYXRpb24iOiJj +cmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNtcWEyeXdieWl2Mm8iLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNr +eS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM3OjM0LjkxMVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWllZmVzYTZ5N3JmZ3I0 +bWoyeHE2NnM2eHJxaXZrcGIzaXNuNXJqMnRwaXZia3FxaTI1YWxpIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOnR0Zm9pd295dXY3dG5mdWh4a2R1NHRqNS9hcHAu +YnNreS5mZWVkLnBvc3QvM21xN3hqc3lvczIybCJ9fSwiY2lkIjoiYmFmeXJlaWJybWQ2Mnpvc3Izc24zbXFhbnd1Nmhtamczbzd4azQycGNtdjZpZXN0c2xy +M3BmNmxrM3UiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBa +V1psYzJFMmVUZHlabWR5TkcxcU1uaHhOalp6Tm5oeWNXbDJhM0JpTTJsemJqVnlhakowY0dsMlltdHhjV2t5TldGc2FXTjFjbWw0Um1GME9pOHZaR2xrT25C +c1l6cDBkR1p2YVhkdmVYVjJOM1J1Wm5Wb2VHdGtkVFIwYWpVdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGQ0YW5ONWIzTXlNbXhwWTNKbFlYUmxa +RUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0zT2pNMExqa3hNVm89In19eyJkaWQiOiJkaWQ6cGxjOmI2ZnhjbGVlbGNqZWpuZHByZzNhMnpmcyIsInRpbWVf +dXMiOjE3ODM2MTQ5NDk4NDUzNzIsImN1cnNvciI6MjI1ODI3NzQzNDgsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzc0MzQ4LCJjb21taXQiOnsicmV2 +IjoiM21xYTJ2cnh5bTU0LjU5MFoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlkNHloeGlvd2Rldm51ZHhyajZqM3JjcGVxM2FncnhnNWtpa2lpdm1mYjdu +anlwbHFqcmtpIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmd0dmN0ZGs0MmltYzY1dms3dW43aWNjYy9hcHAuYnNreS5mZWVkLnBvc3QvM21xN2w0MnljZzIydiJ9 +fSwiY2lkIjoiYmFmeXJlaWRxNmtraWh6bTJia2l3ZXA2eWRwc3p0bW93a2Z1NGpwNWZoYm90aHVqc3M1ZDRramQzZmEiLCJyZWNvcmRfY2JvciI6Im8yVWtk +SGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBaRFI1YUhocGIzZGtaWFp1ZFdSNGNtbzJhak55WTNC +bGNUTmhaM0o0WnpWcmFXdHBhWFp0Wm1JM2JtcDVjR3h4YW5KcmFXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cG5kSFpqZEdSck5ESnBiV00yTlhack4zVnVO +MmxqWTJNdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGRzTkRKNVkyY3lNblpwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0xT2pV +MExqVTVNRm89In19eyJkaWQiOiJkaWQ6cGxjOnZjbTNteGFkc2ppaXlkZ24yd212YTN1ZiIsInRpbWVfdXMiOjE3ODM2MTQ5OTAwMjgxNjksImN1cnNvciI6 +MjI1ODI3OTM0MzMsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzkzNDMzLCJjb21taXQiOnsicmV2IjoiM21xYTJ3eWFjancyaSIsIm9wZXJhdGlvbiI6 +ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJya2V5IjoiM21xYTJ3eWEycHcyaSIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5i +c2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6MjkuODk5WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWNkN2V0cmhlN3hv +d3RsaHdvZ2k0bzV0eXZ6b2xrcGFjamxqNmpiYzM1cnUzd3ZxcDd2ZnkiLCJ1cmkiOiJhdDovL2RpZDpwbGM6azJtbDdtYWtvdGtpajR3anBvd3RzZ3BqL2Fw +cC5ic2t5LmZlZWQucG9zdC8zbXE3NTd2c3BmazJjIn19YXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNTo1Mi45NTlaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5 +cmVpYnBuNG1ld3k1aGplZ3RndnBuYTZoeGVmbWp0dWtseWhrcXZ6empic2JhcGV2eHRmejZzYSIsInVyaSI6ImF0Oi8vZGlkOnBsYzpxd295NXl0amNtbGUz +NnRxN2hiZmVyankvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTdyNnVzdHQyMnQifSwidmlhIjp7ImNpZCI6ImJhZnlyZWlicHVsYnNzdzdhYnV0dnNrZWdkcWZx +Y3B3NHYyejJkbWc2eWF4ZnN3Y2F6cHVxZGJ0YnFhIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOjJwZHdieGJqenh2a2t6NnF5eHM1cnZueC9hcHAuYnNreS5mZWVk +LnJlcG9zdC8zbXFhMmczem1ydTJqIn19LCJjaWQiOiJiYWZ5cmVpYmZyaWZ0MmY2emY1Ynd4bGFmajR0ZWMzcGppbm5vY3A3a2VkN3B5Mnc3aWduYmllbzdj +eSIsInJlY29yZF9jYm9yIjoicEdOMmFXR2lZMk5wWkhnN1ltRm1lWEpsYVdKd2RXeGljM04zTjJGaWRYUjJjMnRsWjJSeFpuRmpjSGMwZGpKNk1tUnRaelo1 +WVhobWMzZGpZWHB3ZFhGa1luUmljV0ZqZFhKcGVFaGhkRG92TDJScFpEcHdiR002TW5Ca2QySjRZbXA2ZUhacmEzbzJjWGw0Y3pWeWRtNTRMMkZ3Y0M1aWMy +dDVMbVpsWldRdWNtVndiM04wTHpOdGNXRXlaek42YlhKMU1tcGxKSFI1Y0dWeVlYQndMbUp6YTNrdVptVmxaQzVzYVd0bFozTjFZbXBsWTNTaVkyTnBaSGc3 +WW1GbWVYSmxhV0p3YmpSdFpYZDVOV2hxWldkMFozWndibUUyYUhobFptMXFkSFZyYkhsb2EzRjJlbnBxWW5OaVlYQmxkbmgwWm5vMmMyRmpkWEpwZUVaaGRE +b3ZMMlJwWkRwd2JHTTZjWGR2ZVRWNWRHcGpiV3hsTXpaMGNUZG9ZbVpsY21wNUwyRndjQzVpYzJ0NUxtWmxaV1F1Y0c5emRDOHpiWEUzY2paMWMzUjBNakow +YVdOeVpXRjBaV1JCZEhnWU1qQXlOaTB3Tnkwd09WUXhOam96TlRvMU1pNDVOVGxhIn19eyJkaWQiOiJkaWQ6cGxjOnM3M2Nid2ZpbXJyY2htanc3YWxibmN0 +YSIsInRpbWVfdXMiOjE3ODM2MTQ5NjU5Mzc4NDQsImN1cnNvciI6MjI1ODI3ODE4MjYsImt0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6MDMuOTM2WiIsInN1 +YmplY3QiOnsiY2lkIjoiYmFmeXJlaWY0Z3ZyNXVnbmprZ2h2Nml0cHd3M3hhd3BrbXNmc3IzN2NjcTVkZTJwcmF6cXBrZDdjaHEiLCJ1cmkiOiJhdDovL2Rp +ZDpwbGM6NmhpdDVyamRibWxuc2NtdWs0YmJ0bXVjL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3ejRlZm1oczJrIn0sInZpYSI6eyJjaWQiOiJiYWZ5cmVpZ2pk +Y2Z0eWdsdmRvamM2a3Rja3ZiN2V1Mm5ua2diNXBqNXczZGpvNmk3dnJ1NjY3bGx4cSIsInVyaSI6ImF0Oi8vZGlkOnBsYzpoYnBlZmlvM2Y1Y3NjNDRtc21i +Z2lveHovYXBwLmJza3kuZmVlZC5yZXBvc3QvM21xYTJ2YWFkdWcyZSJ9fSwiY2lkIjoiYmFmeXJlaWFsNWx4bXBhaGVocXc0Z3VpZ3A0dm9rYXRwcmh2eXVv +cWwzdHRkemhpZWJsN2NsYnpwdGEiLCJyZWNvcmRfY2JvciI6InBHTjJhV0dpWTJOcFpIZzdZbUZtZVhKbGFXZHFaR05tZEhsbmJIWmtiMnBqTm10MFkydDJZ +amRsZFRKdWJtdG5ZalZ3YWpWM00yUnFielpwTjNaeWRUWTJOMnhzZUhGamRYSnBlRWhoZERvdkwyUnBaRHB3YkdNNmFHSndaV1pwYnpObU5XTnpZelEwYlhO +dFltZHBiM2g2TDJGd2NDNWljMnQ1TG1abFpXUXVjbVZ3YjNOMEx6TnRjV0V5ZG1GaFpIVm5NbVZsSkhSNWNHVnlZWEJ3TG1KemEza3VabVZsWkM1c2FXdGxa +M04xWW1wbFkzU2lZMk5wWkhnN1ltRm1lWEpsYVdZMFozWnlOWFZuYm1wcloyaDJObWwwY0hkM00zaGhkM0JyYlhObWMzSXpOMk5qY1RWa1pUSndjbUY2Y1hC +clpEZGphSEZqZFhKcGVFWmhkRG92TDJScFpEcHdiR002Tm1ocGREVnlhbVJpYld4dWMyTnRkV3MwWW1KMGJYVmpMMkZ3Y0M1aWMydDVMbVpsWldRdWNHOXpk +Qzh6YlhFM2VqUmxabTFvY3pKcmFXTnlaV0YwWldSQmRIZ1lNakF5Tmkwd055MHdPVlF4Tmpvek5qb3dNeTQ1TXpaYSJ9fXsiZGlkIjoiZGlkOnBsYzpibG5o +enp0M3BwdjVndWQ2eGRhcWEyZW4iLCJ0aW1lX3VzIjoxNzgzNjE1MDg1ODUzMzA1LCJjdXJzb3IiOjIyNTgyODQwMTc4LCJraWVhdGVkQXQiOiIyMDI2LTA3 +LTA5VDE2OjM0OjU1LjAyOFoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlhb2IzeGVuajVqcmpvMnRyY3VqeWR6Y2tvdWJhN2l2cXo0Y3BybDVqc3JjdGs2 +YXh6NHhlIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmxmZ2p4ZWc3Zjd3NnJ5amZib21oY2JzaS9hcHAuYnNreS5mZWVkLnBvc3QvM21xNWZtM2JtNWkyeCJ9LCJ2 +aWEiOnsiY2lkIjoiYmFmeXJlaWM3cGxtcnVxbHV2dnpsN3pxM3Vka3JmYXR4YjR2ZjNuaDVkZGxtNDZkZGoycWJ2ZnB3dHkiLCJ1cmkiOiJhdDovL2RpZDpw +bGM6NGx4Nm51cjV3c3R3b2M0d3RnajU2a3l1L2FwcC5ic2t5LmZlZWQucmVwb3N0LzNtcTd6dTc1Y2lhMjIifX0sImNpZCI6ImJhZnlyZWlhbmJ1ZDVrcm15 +d3Nudm01bWFoN3RvdzZhZGRvMnRlcGxuY213YnlhenJsc2JrNWFuY3JpIiwicmVjb3JkX2Nib3IiOiJwR04yYVdHaVkyTnBaSGc3WW1GbWVYSmxhV00zY0d4 +dGNuVnhiSFYyZG5wc04zcHhNM1ZrYTNKbVlYUjRZalIyWmpOdWFEVmtaR3h0TkRaa1pHb3ljV0oyWm5CM2RIbGpkWEpwZUVoaGREb3ZMMlJwWkRwd2JHTTZO +R3g0Tm01MWNqVjNjM1IzYjJNMGQzUm5halUyYTNsMUwyRndjQzVpYzJ0NUxtWmxaV1F1Y21Wd2IzTjBMek50Y1RkNmRUYzFZMmxoTWpKbEpIUjVjR1Z5WVhC +d0xtSnphM2t1Wm1WbFpDNXNhV3RsWjNOMVltcGxZM1NpWTJOcFpIZzdZbUZtZVhKbGFXRnZZak40Wlc1cU5XcHlhbTh5ZEhKamRXcDVaSHBqYTI5MVltRTNh +WFp4ZWpSamNISnNOV3B6Y21OMGF6WmhlSG8wZUdWamRYSnBlRVpoZERvdkwyUnBaRHB3YkdNNmJHWm5hbmhsWnpkbU4zYzJjbmxxWm1KdmJXaGpZbk5wTDJG +d2NDNWljMnQ1TG1abFpXUXVjRzl6ZEM4emJYRTFabTB6WW0wMWFUSjRhV055WldGMFpXUkJkSGdZTWpBeU5pMHdOeTB3T1ZReE5qb3pORG8xTlM0d01qaGEi +fX17ImRpZCI6ImRpZDpwbGM6ZjVmd3pmcG43YmJqZnJjNHF2c2Z0bnd6IiwidGltZV91cyI6MTc4MzYxNTAzMjU0MzMyNSwiY3Vyc29yIjoyMjU4MjgxNTI0 +MiwibGhhc2dyeXFzem9kdXYvYXBwLmJza3kuZmVlZC5wb3N0LzNsbGJnYzZib3kyMmUifSwicm9vdCI6eyJjaWQiOiJiYWZ5cmVpZmcyMm1vdzd6YXB5Z3Vv +eXRhaWlnajRlZG5oc2FqY3JiZWt6dnF5bndrd214c2F6ejV1aSIsInVyaSI6ImF0Oi8vZGlkOnBsYzpvanJyNGVmMnE0bGhhc2dyeXFzem9kdXYvYXBwLmJz +a3kuZmVlZC5wb3N0LzNsbGFvaXZ6ZXEyMmwifX0sInRleHQiOiJCZXR3ZWVuIHlvdSBhbmQgbWUgYW5kIHRoZSBwZW9wbGUgc3RhbGtpbmcgbXkgcmVwbGll +cyBiZWNhdXNlIEknbSBqdXN0IHRoYXQgZ29vZCBJIGRvIGFjdHVhbGx5IHdhbnQgeW91IHRvIGJlIGhhcHB5IHNvIHByaW9yaXRpc2luZyB5b3VyIG1vcmUg +fmVsYWJvcmF0ZX4gbmVlZHMgZXZlcnkgbm93IGFuZCB0aGVuIGlzIGltcG9ydGFudCEhIVxuXG5BZ2FpbiwgSSBkb24ndCB3YW50IHRvIHRvIGZldGlzaGl6 +ZSB5b3VyIG5lZXQgc2l0IHNpbmNlIEkgZG9uJ3Qga25vdyBtdWNoIGFib3V0IGl0LCBidXQgbGlrZSB0aGF0Li4uIn0sImNpZCI6ImJhZnlyZWlhdmNvNXp5 +NXpsZ214cnVyeG54eW5uNDVsdm91anB5anEyYXNmajI2bG56bTZreWdrZjdtIiwicmVjb3JkX2Nib3IiOiJwV1IwWlhoMGVRRW9RbVYwZDJWbGJpQjViM1Vn +WVc1a0lHMWxJR0Z1WkNCMGFHVWdjR1Z2Y0d4bElITjBZV3hyYVc1bklHMTVJSEpsY0d4cFpYTWdZbVZqWVhWelpTQkpKMjBnYW5WemRDQjBhR0YwSUdkdmIy +UWdTU0JrYnlCaFkzUjFZV3hzZVNCM1lXNTBJSGx2ZFNCMGJ5QmlaU0JvWVhCd2VTQnpieUJ3Y21sdmNtbDBhWE5wYm1jZ2VXOTFjaUJ0YjNKbElINWxiR0Zp +YjNKaGRHVitJRzVsWldSeklHVjJaWEo1SUc1dmR5QmhibVFnZEdobGJpQnBjeUJwYlhCdmNuUmhiblFoSVNFS0NrRm5ZV2x1TENCSklHUnZiaWQwSUhkaGJu +UWdkRzhnZEc4Z1ptVjBhWE5vYVhwbElIbHZkWElnYm1WbGRDQnphWFFnYzJsdVkyVWdTU0JrYjI0bmRDQnJibTkzSUcxMVkyZ2dZV0p2ZFhRZ2FYUXNJR0ox +ZENCc2FXdGxJSFJvWVhRdUxpNWxKSFJzbWdoMnQyamdmNGUzN3lrL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3eTQ3anZ1czJ2In19LCJ0ZXh0IjoiSSB3aXNo +IGEgam91cm5hbGlzdCB3b3VsZCBiZSBicmF2ZSBlbm91Z2ggdG8gYXNrIGhpbSBhYm91dCB0aGVzZSB0aGluZ3MsIE1hcmsuIPCfkpkifSwiY2lkIjoiYmFm +eXJlaWVnanIzdjQ2a3dtZWl4d2IycmRpaGxoYmhkZnR1Zmd6MzJ2aGtpem96eTZ2eTVidXo1em0iLCJyZWNvcmRfY2JvciI6InBXUjBaWGgwZUZOSklIZHBj +MmdnWVNCcWIzVnlibUZzYVhOMElIZHZkV3hrSUdKbElHSnlZWFpsSUdWdWIzVm5hQ0IwYnlCaGMyc2dhR2x0SUdGaWIzVjBJSFJvWlhObElIUm9hVzVuY3l3 +Z1RXRnlheTRnOEorU21XVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbkJ2YzNSbGJHRnVaM09CWW1WdVpYSmxjR3g1b21SeWIyOTBvbU5qYVdSNE8ySmha +bmx5Wldsa2NHWXlhakp6YzNsNGNHZGxlR2h5ZVhoMk5HNXdaVGRwYkcxdU0zWmpkR1JvY0ROcGVUVnBhR0ppWW5Wck4ydDBhMmcwWTNWeWFYaEdZWFE2THk5 +a2FXUTZjR3hqT25oNVpHUndaeloxYzIxbmFESjBNbXBuWmpSbE16ZDVheTloY0hBdVluTnJlUzVtWldWa0xuQnZjM1F2TTIxeE4zazBOMnAyZFhNeWRtWndZ +WEpsYm5TaVkyTnBaSGc3WW1GbWVYSmxhV1J3WmpKcU1uTnplWGh3WjJWNGFISjVlSFkwYm5CbE4ybHNiVzR6ZG1OMFpHaHdNMmw1Tldsb1ltSmlkV3MzYTNS +cmFEUmpkWEpwZUVaaGREb3ZMMlJwWkRwd2JHTTZlSGxrWkhCbk5uVnpiV2RvTW5ReWFtZG1OR1V6TjNsckwyRndjQzVpYzJ0NUxtWmxaV1F1Y0c5emRDOHpi +WEUzZVRRM2FuWjFjekoyYVdOeVpXRjBaV1JCZEhnWU1qQXlOaTB3Tnkwd09WUXhOam96Tmpvek1pNHhPREZhIn19eyJkaWQiOiJkaWQ6cGxjOmt4eGRtY2x0 +eTd6N3cybHc2aTNxeTRkdSIsInRpbWVfdXMiOjE3ODM2MTUwNDA4MzMxNjEsImN1cnNvciI6MjI1ODI4MTg4MzMsImtpbmQiOiJjb21taXQiLCJzZXEiOjIy +NTgyODE4ODMzLCJjb21taXQiOnsicmV2IjoiM21xYTJ5aXFhdG0yNCIsInNZenBuYVhCMloyMXhaSE4wYVdaeGFYWTNjelp4YUdFMVpXa3ZZWEJ3TG1KemEz +a3VabVZsWkM1d2IzTjBMek50Y1RaM00yOHlkamR6TW01cFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNM09qUXlMalUxTlZvPSJ9fXsiZGlk +IjoiZGlkOnBsYzpjajd6aWZuem42MmVwNmQ1dm54azRidWsiLCJ0aW1lX3VzIjoxNzgzNjE0OTI4NzMwNzA0LCJjdXJzb3IiOjIyNTgyNzYzODQ4LCJraW5k +IjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc2Mzg0OCwiY29tbWl0Ijp7InJldiI6IjNtcWEydjVzdDZuMmoiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0 +aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNtcWEydjVzbmQ1MmoiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJj +cmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM1OjI4LjUwMVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlkN3VqbGlqd3hvbXQ0MnBwbHZ4NXhzZnhid2p2 +emx5eHMydTVxemRhYTNzdTJ3YTVqbzRlIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOjRrbWl5YmZxaWVzYjZtN3YydWlkdXZrdC9hcHAuYnNreS5mZWVkLnBvc3Qv +M21xN2NtYnpqd3MyYyJ9fSwiY2lkIjoiYmFmeXJlaWNzZTR3emhteDRzMndtcWY0bmltY2Y2M3Zmd3FmdzRpNjJ5eHZjNWQ1YXU0bGNsMmxjdmEiLCJyZWNv +cmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBaRGQxYW14cGFuZDRiMjEw +TkRKd2NHeDJlRFY0YzJaNFluZHFkbnBzZVhoek1uVTFjWHBrWVdFemMzVXlkMkUxYW04MFpXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6bzBhMjFwZVdKbWNX +bGxjMkkyYlRkMk1uVnBaSFYyYTNRdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGRqYldKNmFuZHpNbU5wWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEz +TFRBNVZERTJPak0xT2pJNExqVXdNVm89In19eyJkaWQiOiJkaWQ6cGxjOnB4eXg1Y3Q2Z3oyamZhd3Zsb3R0QXQiOiIyMDI2LTA3LTA5VDE2OjM3OjM3LjQ1 +MVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlkZXI1eTJmYXpiY2tybmMyYXhhbmQ3Mmo0NmpmNjJsZ2t3MmNxd3Ezbjd3MmpidnhvNjJtIiwidXJpIjoi +YXQ6Ly9kaWQ6cGxjOmh3NnBpajNyZ2xtaTRlZXNjZXJiMnBuNS9hcHAuYnNreS5mZWVkLnBvc3QvM21xN2h6bHd5ZmsybSJ9LCJ2aWEiOnsiY2lkIjoiYmFm +eXJlaWNucm1ibzJrbHJvZTVxZ3R5amJ1d2d4amJzN3pncmFtM2l0azVmZzd5aGZ4bnZ6ZHV6c3EiLCJ1cmkiOiJhdDovL2RpZDpwbGM6bTN6N2l1aHc1aW42 +YWdrdndocXhjNjc3L2FwcC5ic2t5LmZlZWQucmVwb3N0LzNtcWEyeTJvbHp5MjYifX0sImNpZCI6ImJhZnlyZWlneWRld2F3YXRyNXVnZ282aXMzZGx3N2R2 +bDdtanE3aTVqNXdkY2x2NW00NGFkb2V2dmZ5IiwicmVjb3JkX2Nib3IiOiJwR04yYVdHaVkyTnBaSGc3WW1GbWVYSmxhV051Y20xaWJ6SnJiSEp2WlRWeFoz +UjVhbUoxZDJkNGFtSnpOM3BuY21GdE0ybDBhelZtWnpkNWFHWjRiblo2WkhWNmMzRmpkWEpwZUVoaGREb3ZMMlJwWkRwd2JHTTZiVE42TjJsMWFIYzFhVzQy +WVdkcmRuZG9jWGhqTmpjM0wyRndjQzVpYzJ0NUxtWmxaV1F1Y21Wd2IzTjBMek50Y1dFeWVUSnZiSHA1TWpabEpIUjVjR1YwWVhCd0xtSnphM2t1Wm1WbFpD +NXlaWEJ2YzNSbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBaR1Z5TlhreVptRjZZbU5yY201ak1tRjRZVzVrTnpKcU5EWnFaall5YkdkcmR6SmpjWGR4 +TTI0M2R6SnFZblo0YnpZeWJXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cG9kelp3YVdvemNtZHNiV2swWldWelkyVnlZakp3YmpVdllYQndMbUp6YTNrdVpt +VmxaQzV3YjNOMEx6TnRjVGRvZW14M2VXWnJNbTFwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0zT2pNM0xqUTFNVm89In19eyJkaWQiOiJk +aWQ6cGxjOm5qcXZvaTdteWh5eWo1dW5sNnh6eXpwYyIsInRpbWVfdXMiOjE3ODM2MTQ5Mzg1MzMzOTgsImN1cnNvciI6MjI1ODI3Njg4NjEsIms6Mzc6MTYu +MDIxWiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWNhend5cDNid3l2Y25rb3A2YnpnaG11b3hjZ3dzcWNoZDJ2bjRtbXNyeGZsZHB3NTdqdXUiLCJ1cmki +OiJhdDovL2RpZDpwbGM6b2ZxYnZ5aWpwcmI1aTdpNG5wcHVzcjJuL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3dzRxYjRpYzJoIn19LCJjaWQiOiJiYWZ5cmVp +Y2V2anFhcTVzbHdqbmd3dmVmNWZ2aHlpenZ3aWJ6NnBkbXpza28ydDRpa2VhbGZ5eHg3eSIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJl +UzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcFkyRjZkM2x3TTJKM2VYWmpibXR2Y0RaaWVtZG9iWFZ2ZUdObmQzTnhZMmhrTW5a +dU5HMXRjM0o0Wm14a2NIYzFOMnAxZFdOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwdlpuRmlkbmxwYW5CeVlqVnBOMmswYm5Cd2RYTnlNbTR2WVhCd0xtSnph +M2t1Wm1WbFpDNXdiM04wTHpOdGNUZDNOSEZpTkdsak1taHBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTNPakUyTGpBeU1Wbz0ifX17ImRp +ZCI6ImRpZDpwbGM6MmJ0c3RlaHp6djNkem41bWYyNXZoZjU1IiwidGltZV91cyI6MTc4MzYxNDkwNDYxNDkzOCwiY3Vyc29yIjoyMjU4Mjc1MTcxNiwia2lu +ZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI3NTE3MTYsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnVnaTN5ZTJkIiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVj +dGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXkiOiIzbXFhMnVnaGtmdTJkIiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5saWtlIiwi +Y3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNTowMy42NjhaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVpZ2Q0d2JiN2htM2xjb25nbjRlcWF2aDVneXVq +MzR0enFoa2NocW9mZWpmY2F1MzVudHVrbSIsInVyaSI6ImF0Oi8vZGlkOnBsYzpjbnBlN3F2Y3lqcmhtNnc3dzdlNGF0dXIvYXBwLmJza3kuZmVlZC5wb3N0 +LzNtcTd1d3NjaW9zMjIyZCJ9fSwidGV4dCI6InlvdSBlbnRlcmVkIHRoZSBkaXNjdXNzaW9uIGNvbXBsYWluaW5nIGFib3V0IHByb3Rlc3Qgdm90ZXMsIGFu +ZCB0aGF0IHByZWRpY2F0ZXMgdGhhdCB5b3Ugc2hvdWxkIGJlIGFibGUgdG8gZGVmaW5lIHRoZSB0aGluZyB5b3UgYXJlIGNvbXBsYWluaW5nIGFib3V0LiBz +byBkZWZpbmUgZm9yIG1lIHdoYXQgYSBwcm90ZXN0IHZvdGUgaXMifSwiY2lkIjoiYmFmeXJlaWduM2Y1dXRqYXlweDd1NnBicHJ5cXlqZ2tqYTQ1bHRkanB3 +Z3Q1ZjJqbnN0dzNkc3ZvcGEiLCJyZWNvcmRfY2JvciI6InBXUjBaWGgwZUw1NWIzVWdaVzUwWlhKbFpDQjBhR1VnWkdselkzVnpjMmx2YmlCamIyMXdiR0Zw +Ym1sdVp5QmhZbTkxZENCd2NtOTBaWE4wSUhadmRHVnpMQ0JoYm1RZ2RHaGhkQ0J3Y21Wa2FXTmhkR1Z6SUhSb1lYUWdlVzkxSUhOb2IzVnNaQ0JpWlNCaFlt +eGxJSFJ2SUdSbFptbHVaU0IwYUdVZ2RHaHBibWNnZVc5MUlHRnlaU0JqYjIxd2JHRnBibWx1WnlCaFltOTFkQzRnYzI4Z1pHVm1hVzVsSUdadmNpQnRaU0Iz +YUdGMElHRWdjSEp2ZEdWemRDQjJiM1JsSUdselpTUjBlWEJsY21Gd2NDNWljMnQ1TG1abFpXUXVjRzl6ZEdWc1lXNW5jNEZpWlc1bGNtVndiSG1pWkhKdmIz +U2lZMk5wWkhnN1ltRm1lWEpsYVdkMmVXZHdkbkp4YTJscE5YVTNkMkZwYWpKemRtSXlkbU5tYm5JME5EUmpaMloyWld0b1lqSnFiV04zWnpjM1kzUnNkM1Zq +ZFhKcGVFWmhkRG92TDJScFpEcHdiR002YlcwMVpXSnBhSEJxZG5SeVpIVnViMjExYkdKc2N6VnRMMkZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkQzh6YlhFMlpX +NWliR3A1TWpKa1puQmhjbVZ1ZEtKalkybGtlRHRpWVdaNWNtVnBZbTV3TkRJelpubzJaWFV6Wm5sdE0zQmlNbVp1WVRaNmVtRmtjVzUzYkhBMk5tVjBlR1ox +WkhKeU4ycG5kbmR3YkhsdVlXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cG5kSEJzTW14eFpuWjRhRE53Ym1sMWJYUXpabmh3WjNRdllYQndMbUp6YTNrdVpt +VmxaQzV3YjNOMEx6TnRjV0V5ZFc1amNXTnJNbVZwWTNKRW5kIjoxMTksImJ5dGVTdGFydCI6OTR9fSx7IiR0eXBlIjoiYXBwLmJza3kucmljaHRleHQuZmFj +ZXQiLCJmZWF0dXJlcyI6W3siJHR5cGUiOiJhcHAuYnNreS5yaWNodGV4dC5mYWNldCNtZW50aW9uIiwiZGlkIjoiZGlkOnBsYzp6cXhwbmxqNmw1amtobWdw +cHUyZnlvMmcifV0sImluZGV4Ijp7ImJ5dGVFbmQiOjIxMSwiYnl0ZVN0YXJ0IjoxOTN9fSx7ImZlYXR1cmVzIjpbeyIkdHlwZSI6ImFwcC5ic2t5LnJpY2h0 +ZXh0LmZhY2V0I2xpbmsiLCJ1cmkiOiJodHRwczovL2RhaWx5bW9udGFuYW4uY29tLzIwMjYvMDcvMDcvZ2xhY2llci1lbXBsb3llZXMtdm90ZS10by11bmlv +bml6ZS8ifV0sImluZGV4Ijp7ImJ5dGVFbmQiOjI4MSwiYnl0ZVN0YXJ0IjoyNDh9fV0sImxhbmdzIjpbImVuIl0sInRleHQiOiJDb25ncmF0dWxhdGlvbnMg +dG8gTmF0aW9uYWwgUGFyayBTZXJ2aWNlIHdvcmtlcnMgYXQgR2xhY2llciBOYXRpb25hbCBQYXJrLCB3aG8gdW5pb25pemVkIHdpdGggQG50ZXVuYXRpb25h +bC5ic2t5LnNvY2lhbCEgV2VsY29tZSB0byB0aGUgZmFtLCB3ZSBhcmUgdGhyaWxsZWQgdG8gaGF2ZSB5b3UgaW4gdGhlIHVuaW9uIHJhbmtzLiB2aWEgQGRh +aWx5bW9udGFuYW4uY29tIEB1bmlvbnN0cm9uZyBAc3VwcG9ydGZlZGVyYWx3b3JrZXJzIGRhaWx5bW9udGFuYW4uY29tLzIwMjYvMDcvMDcvZy4uLiJ9LCJj +aWQiOiJiYWZ5cmVpZ3RtZmZza3RoZnNqaDdnNG5wYTQ2anJkZmhlbXEya2lvdHVsazZqZGlpanhtN2RnM3c1ZSIsInJlY29yZF9jYm9yIjoicG1SMFpYaDBl +UUVaUTI5dVozSmhkSFZzWVhScGIyNXpJSFJ2SUU1aGRHbHZibUZzSUZCaGNtc2dVMlZ5ZG1salpTQjNiM0pyWlhKeklHRjBJRWRzWVdOcFpYSWdUbUYwYVc5 +dVlXd2dVR0Z5YXl3Z2QyaHZJSFZ1YVc5dWFYcGxaQ0IzYVhSb0lFQnVkR1YxYm1GMGFXOXVZV3d1WW5OcmVTNXpiMk5wWVd3aElGZGxiR052YldVZ2RHOGdk +R2hsSUdaaGJTd2dkMlVnWVhKbElIUm9jbWxzYkdWa0lIUnZJR2hoZG1VZ2VXOTFJR2x1SUhDd2dkMmh2SUhOMFlYSjBaV1FnZEdocGN5QndjbTluY21GdExD +QmlaV2RoYmlCMGJ5QnpkV1ptWlhJZ1puSnZiU0IwYUdVZ1kyOXRjSFYwWlhJZ1pHbHpaV0Z6WlNCMGFHRjBJR0Z1ZVdKdlpIa2dkMmh2SUhkdmNtdHpJSGRw +ZEdnZ1kyOXRjSFYwWlhKeklHNXZkeUJyYm05M2N5QmhZbTkxZEM0Z1NYUW5jeUJoSUhabGNua2djMlZ5YVc5MWN5QmthWE5sWVhObElHRnVaQ0JwZENCcGJu +UmxjbVpsY21WeklHTnZiWEJzWlhSbGJIa2dkMmwwYUNCMGFHVWdkMjl5YXk0Z1ZHaGxJSFJ5YjNWaWJHVWdkMmwwYUNCamIyMXdkWFJsY25NZ2FYTWdlVzkx +SUhCc1lYa2dkMmwwYUNCMGFHVnRMaUJVYUdWNUlHRnlaU0J6YnlCM2IyNWtaWEptZFd3dUlGbHZkU0JvWVhabElIUm9aWE5sSUhOM2FYUmphR1Z6NG9DVWFX +WWdhWFFuY3lCaGJpQmxkbVZ1SUc1MWJXSmxjaUI1YjNVZ1pHOGdkR2hwY3l3Z2FXWWdhWFFuY3lCaGJpQnZaR1FnYm5WdFltVnlJSGx2ZFNCa2J5QjBhR0Yw +NG9DVVlXNWtJSEJ5WlhSMGVTQnpiMjl1SUhsdmRTQmpZVzRnWkc4Z2JXOXlaU0JoYm1RZ2JXOXlaU0JsYkdGaWIzSmhkR1VnZEdocGJtZHpJR2xtSUhsdmRT +QmhjbVVnWTJ4bGRtVnlJR1Z1YjNWbmFDd2diMjRnYjI1bElHMWhZMmhwYm1VdUNncEJablJsY2lCaElIZG9hV3hsSUhSb1pTQjNhRzlzWlNCemVYTjBaVzBn +WW5KdmEyVWdaRzkzYmk0Z1JuSmhibXRsYkNCM1lYTnVKM1FnY0dGNWFXNW5JR0Z1ZVNCaGRIUmxiblJwYjI0N0lHaGxJSGRoYzI0bmRDQnpkWEJsY25acGMy +bHVaeUJoYm5saWIyUjVMaUJVYUdVZ2MzbHpkR1Z0SUhkaGN5Qm5iMmx1WnlCMlpYSjVMQ0IyWlhKNUlITnNiM2RzZWVLQWszZG9hV3hsSUdobElIZGhjeUJ6 +YVhSMGFXNW5JR2x1SUdFZ2NtOXZiU0JtYVdkMWNtbHVaeUJ2ZFhRZ2FHOTNJSFJ2SUcxaGEyVWdiMjVsSUhSaFluVnNZWFJ2Y2lCaGRYUnZiV0YwYVdOaGJH +eDVJSEJ5YVc1MElHRnlZM1JoYm1kbGJuUWdXQ3dnWVc1a0lIUm9aVzRnYVhRZ2QyOTFiR1FnYzNSaGNuUWdZVzVrSUdsMElIZCI6IjNtbWk3anBxNHBlMnUi +fX17ImRpZCI6ImRpZDpwbGM6NXVieDNxZ3FubDI2czcyNHJ5YmVncXgyIiwidGltZV91cyI6MTc4MzYxNTA3MTI0ODA5NiwiY3Vyc29yIjoyMjU4MjgzMzQz +OCwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MzM0MzgsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnpmcXFqYTJ6Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwi +Y29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXkiOiIzbXFhMnpmcWlwYTJ6IiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5s +aWtlIiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNzo1MC4wNzZaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVpZ3VyZ3NsMnBkbG5qaXVmdHJ4YjJ2 +cWZocm1hd2hub29seTJscXNqcXVyZTJkcGV0enFyYSIsInVyaSI6ImF0Oi8vZGlkOnBsYzp5ZjZoY3R0MnVnM3F5ZnR5NGluNjR5b2IvYXBwLmJza3kuZmVl +ZC5wb3N0LzNtcTd4empwaDVzMmcifX0sImNpZCI6ImJhZnlyZWllc3NtNTJ1Mms2bDNiN3Q3aGdmc3JmcHBzZHhsczVoaGQ1aTZqY2JpbHBiNGs0amdsYXV5 +IiwicmVjb3JkX2Nib3IiOiJvMlVrZEhsd1pYSmhjSEF1WW5OcmVTNW1aV1ZrTG14cGEyVm5jM1ZpYW1WamRLSmpZMmxrZUR0aVlXWjVjbVZwWjNWeVozTnNN +bkJrYkc1cWFYVm1kSEo0WWpKMmNXWm9jbTFoZDJodWIyOXNlVEpzY1hOcWNYVnlaVEprY0dWMGVuRnlZV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenA1Wmpa +b1kzUjBNblZuTTNGNVpuUjVOR2x1TmpSNWIySXZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkNGVtcHdhRFZ6TW1kcFkzSmxZWFJsWkVGMGVCZ3lN +REkyTFRBM0xUQTVWREUyT2pNM09qVXdMakEzTmxvPSJ9fXsiZGlkIjoiZGlkOnBsYzpkYzM2YW1oN2pibnduajRydXNhbzVjbDIiLCJ0aW1lX3VzIjoxNzgz +NjE0OTEyMDM2NTgxLCJjdXJzb3IiOjIyNTgyNzU1NjU5LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc1NTY1OSwiY29tbWl0Ijp7InJldiI6IjNtcWEy +dW51cmVpYjMzNGRzb3pxcTQzNmlvdHduM3Fvd2oyZmVmY2FoYWxmenVrNWg1bWp5ZDNwcWx3dGJwaSIsInVyaSI6ImF0Oi8vZGlkOnBsYzozN2V5cnJ5cnBu +MzZoZGJjYjdiN3lrdTQvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd6ZGE2NmhrMmYifX0sImNpZCI6ImJhZnlyZWlmeXRyaGRqZzJqY3M0c3FoZnY2M2lzeW1k +Y3BjMnNmZmVmaWJueG5xaWQ3cHdlemJiNW5hIiwicmVjb3JkX2Nib3IiOiJvMlVrZEhsd1pYSmhjSEF1WW5OcmVTNW1aV1ZrTG14cGEyVm5jM1ZpYW1WamRL +SmpZMmxrZUR0aVlXWjVjbVZwWWpNek5HUnpiM3B4Y1RRek5tbHZkSGR1TTNGdmQyb3labVZtWTJGb1lXeG1lblZyTldnMWJXcDVaRE53Y1d4M2RHSndhV04x +Y21sNFJtRjBPaTh2Wkdsa09uQnNZem96TjJWNWNuSjVjbkJ1TXpab1pHSmpZamRpTjNscmRUUXZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkNlpH +RTJObWhyTW1acFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNM09qUTVMalE1TTFvPSJ9fXsiZGlkIjoiZGlkOnBsYzpiNXNvN3FxcW8zYmpj +eTM0dTJ1ZDR5eWEiLCJ0aW1lX3VzIjoxNzgzNjE1MDY4MjI0Mjk3LCJjdXJzb3IiOjIyNTgyODMxOTk5LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjgz +MTk5OSwiY29tbWl0Ijp7InJldiI6IjNtcWEyemNvdmx5MmciLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtl +IiwicmtleSI6IjNtcWEyemNvbnJ5MmciLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2 +OjM3OjQ3LjMzM1oiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWliY3NzaGU3N3o0YmZ4bDU3N3p6aHdyZzRlc2RuYmoza3Z1a3V2YncyeXhiNjRjbzRsbnRx +IiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOjY1Ym14cWRjYnp6bmhxcmJxNTVuZGRsMy9hcHAuYnNreS5mZWVkLnBvc3QvM21xN3hwYjY2ZTIydyJ9fSwiY2lkIjoi +YmFmeXJlaWFnYXRmbG82Z3liZjd4Y2FlLnN0cmVhbS5saXZlc3RyZWFtIiwiYWN0aXZpdHkiOnsiJHR5cGUiOiJwbGFjZS5zdHJlYW0uZGVmcyNhY3Rpdml0 +eUdhbWUiLCJuYW1lIjoiRGFuY2UgRGFuY2UgUmV2b2x1dGlvbiBHcmFuZCBQcml4IiwidXJpIjoiYXQ6Ly9kaWQ6d2ViOmdhbWVzZ2FtZXNnYW1lc2dhbWVz +LmdhbWVzL2dhbWVzLmdhbWVzZ2FtZXNnYW1lc2dhbWVzLmdhbWUvM21naTR6Ymdsa3cyZCJ9LCJhZ2VudCI6IkBzdHJlYW1wbGFjZS9jb21wb25lbnRzLzAu +MTEuMTIgKHdlYiwgRmlyZWZveCkiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE1OjM3OjI5WiIsImlkbGVUaW1lb3V0U2Vjb25kcyI6MzAwLCJsYXN0U2Vl +bkF0IjoiMjAyNi0wNy0wOVQxNjozNjo1Ni40MTVaIiwibm90aWZpY2F0aW9uU2V0dGluZ3MiOnsicHVzaE5vdGlmaWNhdGlvbiI6dHJ1ZX0sInRhZ3MiOlsi +bGFuZzpmciIsIlJoeXRobUdhbWVzIl0sInRodW1iIjp7IiR0eXBlIjoiYmxvYiIsIm1pbWVUeXBlIjoiaW1hZ2UvanBlZyIsInJlZiI6eyIkbGluayI6ImJh +ZmtyZWlkN2F3aHU1dWg1a3Nhd2N3a2thc2J2bTUyYWl5Z2s3YWJ2NXZiNnIzamdrM21vbDQyNWRlIn0sInNpemUiOjE4ODUxOH0sInRpdGxlIjoiW0ZSL0VO +XSBERFIgYW5kIGNoaWxsIiwidXJsIjoiaHR0cHM6Ly9zdHJlYW0ucGxhY2UvZGlkOnBsYzptenR3bnJ5NmZ1bmg2amF1dDYzZHR2ejIifSwiY2lkIjoiYmFm +eXJlaWMybW15YTJxdXVvZG5tYjd5MnA0YXEzZG80djU2NzVxeDZ6MnU2aGZocm1uNjQ0aGdjYnUiLCJyZWNvcmRfY2JvciI6InEyTjFjbXg0TldoMGRIQnpP +aTh2YzNSeVpXRnRMbkJzWVdObEwyUnBaRHB3YkdNNmJYcDBkMjV5ZVRabWRXNW9ObXBoZFhRMk0yUjBkbm95WkhSaFozT0NaMnhoYm1jNlpuSnJVbWg1ZEdo +dFIyRnRaWE5sSkhSNWNHVjNjR3hoWTJVdWMzUnlaV0Z0TG14cGRtVnpkSEpsWVcxbFlXZGxiblI0TGtCemRISmxZVzF3YkdGalpTOWpiMjF3YjI1bGJuUnpM +ekF1TVRFdU1USWdLSGRsWWl3Z1JtbHlaV1p2ZUNsbGRHaDFiV0trWTNKbDZNelk2TVRndU9EY3hXZz09In19eyJkaWQiOiJkaWQ6cGxjOnZ6M2RrZWVyYm5m +cDM1bHl6NnlsNnF3MyIsInRpbWVfdXMiOjE3ODM2MTQ5OTM3MzMzMTgsImN1cnNvciI6MjI1ODI3OTUxODcsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgy +Nzk1MTg3LCJjb21taXQiOnsicmV2IjoiM21xYTJ4M3NtN2sydiIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxp +a2UiLCJya2V5IjoiM21xYTJ4M3NkZ2MydiIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlU +MTY6MzY6MzUuMTA0WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWFrNzQ2Z2VvbjNrdnBnZTVza2l5NnRwc2JncWZjamhvdHM1a2EyZ3Zlb21lZzU1b2h0 +dHEiLCJ1cmkiOiJhdDovL2RpZDpwbGM6ZWppaGxkNHN5d3Z2cXdlNjdjZGtuNGpxL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3dDJiNzN6MjJ5In19LCJjaWQi +OiJiYWZ5cmVpZjVsZDNidDVxZ3c1a3Y0ZGtqZGF1NmUzdXdtdzU1YmVyaGN4dGxvZWdxa3o3aGNkajZ0ZSIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpo +Y0hBdVluTnJlUzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcFlXczNORFpuWlc5dU0ydDJjR2RsTlhOcmFYazJkSEJ6WW1keFpt +TnFhRzkwY3pWcllUSm5kbVZ2YldWbk5UVnZhSFIwY1dOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwbGFtbG9iR1EwYzNsM2RuWnhkMlUyTjJOa2EyNDBhbkV2 +WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZDBNbUkzTTNveU1ubHBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTJPak0xTGpFd05G +bz0ifX17ImRpZCI6ImRpZDpwbGM6b3U1amM1dzZrdWtqbXJla2c3ZDN6bm5jIiwidGltZV91cyI6MTc4MzYxNTA0MTQ0NTE3MSwiY3Vyc29yIjoyMjU4Mjgx +OTEyNiwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MTkxMjYsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnlqQmd5TURJMkxUQTNMVEE1VkRFMk9qTTNPak0x +TGpZMk4xbz0ifX17ImRpZCI6ImRpZDpwbGM6MzdueHZ0aGRjYWRpZHpobHV5a2lwNTd5IiwidGltZV91cyI6MTc4MzYxNTA4MTAyMzI0OCwiY3Vyc29yIjoy +MjU4MjgzODE3OSwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MzgxNzksImNvbW1pdCI6eyJyZXYiOiIzbXFhMnpvems2NDJtIiwib3BlcmF0aW9uIjoi +Y3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQucG9zdCIsInJrZXkiOiIzbXFhMnZiZ2l2YzJvIiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJz +a3kuZmVlZC5wb3N0IiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNTozMi40MDFaIiwibGFuZ3MiOlsiZW4iXSwicmVwbHkiOnsicGFyZW50Ijp7ImNp +ZCI6ImJhZnlyZWlmNHIyamJ6N3h5cW5rcWdyc21zYTJqbzY1c2xudTZyaGY0YnczdWF5YjQ3cHY0YjY3N25lIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOnE1cXU1 +c2p0bjQ0ZTdtcHlyaTJxeXVndi9hcHAuYnNreS5mZWVkLnBvc3QvM21xN2pneWR6MmMyZyJ9LCJyb290Ijp7ImNpZCI6ImJhZnlyZWlhM2F4b2lyaWxzdDRl +cjdvdXZtNWdkNmF1YzZ4M215M3dzNmhib2liNHMybWJ4M3d6dzdxIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOjJobHRpbXlteTY1emw1YmE3aWZzcTNxci9hcHAu +YnNreS5mZWVkLnBvc3QvM21xN2VlY2dtcDIyZCJ9fSwidGV4dCI6IkhlIGNvdWxkIGNhcmUgbGVzcyBhYm91dCB0aGUgbW9uZXkuIFRoaXMgaXMgYWxsIGFi +b3V0IGhpbSBzYXZpbmcgZmFjZS4uLmZ1bHRpbGUgYXMgdGhhdCBpcy4ifSwiY2lkIjoiYmFmeXJlaWNudzZ1YmZ1ZmxpdDNnbWNsdXBza29ybWd3a3VtZTNi +NGZicGJpNXA0azdkYWx3anhtZmkiLCJyZWNvcmRfY2JvciI6InBXUjBaWGgwZUZ0SVpTQmpiM1ZzWkNCallYSmxJR3hsYzNNZ1lXSnZkWFFnZEdobElHMXZi +bVY1TGlCVWFHbHpJR2x6SUdGc2JDQmhZbTkxZENCb2FXMGdjMkYyYVc1bklHWmhZMlV1TGk1bWRXeDBhV3hsSUdGeklIUm9ZWFFnYVhNdVpTUjBCc1l6cG9O +VGRoYkRKdlpXSTNaV0p1ZG5CbGVHRmhlWGcxYzNVdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGQyYzNreWNHdzNNamRwWTNKbFlYUmxaRUYwZUJn +eU1ESTJMVEEzTFRBNVZERTJPak0zT2pNMkxqYzBNRm89In19eyJkaWQiOiJkaWQ6cGxjOmx5Y3R4cHc2ZmJlcGFrdXg2cmgyNnRkcyIsInRpbWVfdXMiOjE3 +ODM2MTUwMjkyMjk1OTEsImN1cnNvciI6MjI1ODI4MTM3NzMsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODEzNzczLCJjb21taXQiOnsicmV2IjoiM21x +YTJ5NTVnaHAyZiIsIm9wZXJhdGlvbiI6InVwZGF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5hY3Rvci5wcm9maWxlIiwicmtleSI6InNlbGYiLCJyZWNv +cmQiOnsiJHR5cGUiOiJhcHAuYnNreS5hY3Rvci5wcm9maWxlIiwiYXZhdGFyIjp7IiR0eXBlIjoiYmxvYiIsIm1pbWVUeXBlIjoiaW1hZ2UvanBlZyIsInJl +ZiI6eyIkbGluayI6ImJhZmtyZWlhMmVoajJoaXlrbWJscXlrdHA2dzd2Z2lwdnplcDdrY2xvN296cHp0Y3J6Z2p4YmQzZG5tIn0sInNpemUiOjEzMzA4OH0s +ImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6NTMuNjYzWiIsImRpc3BsYXlOYW1lIjoiIn0sImNpZCI6ImJhZnlyZWlodmJjMzdzZXN3ZWozb2Z2ZWxv +b3FmYW0zb3BpaWtkZWxwYmt4eXFzYWwza3J5eGJ3azV1IiwicmVjb3JkX2Nib3IiOiJwR1VrZEhsd1pYWmhjSEF1WW5OcmVTNWhZM1J2Y2k1d2NtOW1hV3hs +Wm1GMllYUmhjcVJqY21WbTJDcFlKUUFCVlJJZ0dpSFRvNk1LWUZjTUttLzF2MU1oOWNrZjlRbHUrN0w4ekZISmszQ1BZMnRrYzJsNlpSb0FBZ2ZnWlNSMGVY +QmxaR0pzYjJKb2JXbHRaVlI1Y0dWcWFXMWhaMlV2YW5CbFoybGpjbVZoZEdWa1FYUjRHREl3TWpZdE1EY3RNRGxVTVRZNk16WTZOVE11TmpZeldtdGthWE53 +YkdGNVRtRnRaV0E9In19eyJkaWQiOiJkaWQ6cGxjOjI3cHRkNHRzY25zbzU3dnprZDR2NGR2ZCIsInRpbWVfdXMiOjE3ODM2MTQ5NDYyMzM3NjQsImN1cnNv +ciI6MjI1ODI3NzI2MDhRR0RfMjAyNjA3MDlfMF9MMkEvdGh1bWJuYWlsIn0sInB1Ymxpc2hlZEF0IjoiMjAyNi0wNy0wOVQxNjozMTo1MC4xNjVaIiwicmVz +b3VyY2UiOiJodHRwczovL2VhcnRoLXNlYXJjaC5hd3MuZWxlbWVudDg0LmNvbS92MS9jb2xsZWN0aW9ucy9zZW50aW5lbC0yLWwyYS9pdGVtcy9TMkJfMjhR +R0RfMjAyNjA3MDlfMF9MMkEifSwiY2lkIjoiYmFmeXJlaWh4ZG52Y2Z4ZG13MnNrbm1hcG1kdWdrNHRwNHZqZGllZnkyZG1qeHlraHV6a3VlcWVnYmEiLCJy +ZWNvcmRfY2JvciI6InBHVWtkSGx3WlhCamVDNTJiWGd1YldGMFlXUnBjMk52WjNCeVpYWnBaWGVpWTNWeWJIaHRhSFIwY0hNNkx5OWxZWEowYUMxelpXRnlZ +Mmd1WVhkekxtVnNaVzFsYm5RNE5DNWpiMjB2ZGpFdlkyOXNiR1ZqZEdsdmJuTXZjMlZ1ZEdsdVpXd3RNaTFzTW1FdmFYUmxiWE12VXpKQ1h6STRVVWRFWHpJ +d01qWXdOekE1WHpCZlRESkJMM1JvZFcxaWJtRnBiR2h0YVcxbFZIbHdaV3BwYldGblpTOXFjR1ZuYUhKbGMyOTFjbU5sZUdOb2RIUndjem92TDJWaGNuUm9M +WE5sWVhKamFDNWhkM011Wld4bGJXVnVkRGcwTG1OdmJTOTJNUzlqYjJ4c1pXTjBhVzl1Y3k5elpXNTBhVzVsYkMweUxXd3lZUzlwZEdWdGN5OVRNa0pmTWpo +UlIwUmZNakF5TmpBM01EbGZNRjlNTWtGcmNIVmliR2x6YUdWa1FYUjRHREl3TWpZdE1EY3RNRGxVTVRZNk16RTZOVEF1TVRZMVdnPT0ifX17ImRpZCI6ImRp +ZDpwbGM6NnBhd3hreWZqbzRwazVlamdqeWtzaWtyIiwidGltZV91cyI6MTc4MzYxNDkyNTI0MzE2MiwiY3Vyc29yIjoyMjU4Mjc2MjA4Nywia2luZCI6ImNv +bW1pdCIsInNlcSI6MjI1ODI3NjIwODcsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnYyaGtubjJ3Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6 +ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXkiOiIzbXFhMnYyM21zdTJ3IiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5saWtlIiwiY3JlYXRl +ZEF0IjoiMjAyNi0wNy0wOVQxNjozNToyMy44ODVaIiwiRTRNMW89In19eyJkaWQiOiJkaWQ6cGxjOmhhdm1nNWJtbGFrZnU3c3dwa3V2b2V3NyIsInRpbWVf +dXMiOjE3ODM2MTQ5ODg2MjY1MjIsImN1cnNvciI6MjI1ODI3OTI3MzYsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzkyNzM2LCJjb21taXQiOnsicmV2 +IjoiM21xYTJ3d3hjcnEyeCIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJya2V5IjoiM21xYTJ3d3gz +d3kyeCIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6MjguMDI5WiIsInN1Ympl +Y3QiOnsiY2lkIjoiYmFmeXJlaWdjYmJpM3B1bXJmZnZ2d256dmJsaWN5a3g3eXg1cm1tZDRzcG9pcm5udXh0MnhvaWYzamkiLCJ1cmkiOiJhdDovL2RpZDpw +bGM6Y3F3ZWRhYXFsNGMzem83eWx6N3JmNnFjL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3czU2ZDQ2czJuIn19LCJjaWQiOiJiYWZ5cmVpY2pzdnpwdGRlZjUz +c2ZuY2ozNGZhenZmN3NqdXh6cW0zZzZtbXh3bHduNDVrNjRsYW9seSIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xteHBh +MlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcFoyTmlZbWt6Y0hWdGNtWm1kblozYm5wMllteHBZM2xyZURkNWVEVnliVzFrTkhOd2IybHlibTUxZUhR +eWVHOXBaak5xYVdOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwamNYZGxaR0ZoY1d3MFl6TjZiemQ1YkhvM2NtWTJjV012WVhCd0xtSnphM2t1Wm1WbFpDNXdi +M04wTHpOdGNUZHpOVFprTkRaek1tNXBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTJPakk0TGpBeU9Wbz0ifX17ImRpZCI6ImRpZDpwbGM6 +dTVucTQ1cHBkcmE3b3dtNGtsZWwzNGFnIiwidGltZV91cyI6MTc4MzYxNTA4NzUyODEwMCwiY3Vyc29yIjoyMjU4Mjg0MTQ4Nywia2luZCI6ImNvbW1pdCIs +InNlcSI6MjI1ODI4NDE0ODcsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnp2NngzZTJ5Iiwib3B6Y3k0dUxtVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbkJ2 +YzNSbFpXMWlaV1NpWlNSMGVYQmxkV0Z3Y0M1aWMydDVMbVZ0WW1Wa0xtbHRZV2RsYzJacGJXRm5aWE9CbzJOaGJIUmdaV2x0WVdkbHBHTnlaV2JZS2xnbEFB +RlZFaURKRWRwSFMza2lBdFNHVERkMGtNYTJVcklvYzRsZVkrOHJjZ1ZGdEFrZ1MyUnphWHBsR2dBRGpTZGxKSFI1Y0dWa1lteHZZbWh0YVcxbFZIbHdaV3Bw +YldGblpTOXFjR1ZuYTJGemNHVmpkRkpoZEdsdm9tVjNhV1IwYUJrRCttWm9aV2xuYUhRWkJhMWxiR0Z1WjNPQlltVnVabVpoWTJWMGM0R2laV2x1WkdWNG9t +ZGllWFJsUlc1a0dEVnBZbmwwWlZOMFlYSjBHQjVvWm1WaGRIVnlaWE9Cb21OMWNtbDRkbWgwZEhCek9pOHZZMmhoY214cFpXaGxZbVJ2TG1aeUwyUmxjM05w +Ymkxa2RTMXFiM1Z5THo5a1pYTnphVzQ5TWprNU5EVXpKblYwYlY5emIzVnlZMlU5WW14MVpYTnJlU1oxZEcxZmJXVmthWFZ0UFhOdlkybGhiQ1oxZEcxZlky +RnRjR0ZwWjI0OVptVmthV05oTFVSbGMzTnBibk5sSkhSNWNHVjRIR0Z3Y0M1aWMydDVMbkpwWTJoMFpYaDBMbVpoWTJWMEkyeHBibXRwWTNKbFlYUmxaRUYw +ZUJneU1ESTJMVEEzTFRBNVZERTJPak0xT2pBd0xqQXdNRm89In19eyJkaWQiOiJkaWQ6cGxjOjM3cHUzb3FjczZ4N2p5aHo2aWluYXdoNCIsInRpbWVfdXMi +OjE3ODM2MTUwODk2NjEzNTAsImN1cnNvciI6MjI1ODI4NDQzMDEsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODQ0MzAxLCJjb21taXQiOnsicmV2Ijoi +M21xYTJ6eGFremUyZCIsIm9wZXJhdGlvbiI6ImRlbGV0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnJlcG9zdCIsInJrZXkiOiIzbXE3YmpteTZl +cDJkIn19eyJkaWQiOiJkaWQ6cGxjOm1mbG1ndTd2czU0Z282cHRld2V4cGx1cCIsInRpbWVfdXMiOjE3ODM2MTQ5MDY0MjYyNTYsImN1cnNvciI6MjI1ODI3 +NTMwNjIsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzUzMDYyLCJjb21taXQiOnsicmV2IjoiM21xYTJ1aWlmZHkyZSIsInlyZWllZTNyZXhycTUzem5j +eTQzZWl4NWJlbTc1N3ZmbnRsN3FpZHV6d3dqeGo2djN4ZWVxZm40IiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmtwZ2NwdWJseGtmdGF1dHJ1d251MzRzMi9hcHAu +YnNreS5mZWVkLnBvc3QvM21xN3J1ZmhidGsycyJ9fSwiY2lkIjoiYmFmeXJlaWNsZDRvNHh3MnB1b29xcm5zdWt0cXRuNWttMmJmNXI0YjI2NGlwdnJ5bG03 +NnlpdTNjcGEiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBa +V1V6Y21WNGNuRTFNM3B1WTNrME0yVnBlRFZpWlcwM05UZDJabTUwYkRkeGFXUjFlbmQzYW5ocU5uWXplR1ZsY1dadU5HTjFjbWw0Um1GME9pOHZaR2xrT25C +c1l6cHJjR2RqY0hWaWJIaHJablJoZFhSeWRYZHVkVE0wY3pJdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGR5ZFdab1luUnJNbk5wWTNKbFlYUmxa +RUYwZUJzeU1ESTJMVEEzTFRBNVZERTJPak0yT2pVMUxqRTNPVEF6TWxvPSJ9fXsiZGlkIjoiZGlkOnBsYzpjdHdsYjZ1bHR0ZGNjcW4yM2Rhd3N5Z3oiLCJ0 +aW1lX3VzIjoxNzgzNjE0OTM2MTI2NDgzLCJjdXJzb3IiOjIyNTgyNzY3NTkzLCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc2NzU5MywiY29tbWl0Ijp7 +InJldiI6IjNtcWEydmVldW5pMnMiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNtcWEy +dmVlbXRpMnMiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM1OjM1LjM0MFoiLCJz +dWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWllNnBnZTVzNHB0aWNkejYzYm9veXBzaGtoaWtkZGEyNjRtcXl5M3ZxNXV0aHZjN2VwMm5xIiwidXJpIjoiYXQ6Ly9k +aWQ6cGxjOm1qYTY1enlqbms2bndraXU0eDM0aGdxeS9hcHAuYnNreS5mZWVkLnBvc3QvM21xNnNlbDc3MmMyeCJ9fSwiY2lkIjoiYmFmeXJlaWVybjczYml2 +MnF3dXJzb3IiOjIyNTgyNzg0NTUyLCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc4NDU1MiwiY29tbWl0Ijp7InJldiI6IjNtcWEyd2dkc2diMnIiLCJv +cGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNtcWEyd2dkb2piMnIiLCJyZWNvcmQiOnsiJHR5 +cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM2OjExLjg0OVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlo +eW5jc3V0czJuc3V2Z2h3NGNndGt2bHkyMjJyYXhpdjVxbWlkNmZoNmxzMnJ2NG5mdGhpIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmJocXJyeHQ3eXlmcHdndWlv +YTdyd2E3eC9hcHAuYnNreS5mZWVkLnBvc3QvM21xN3R3NmVna2MycSJ9fSwiY2lkIjoiYmFmeXJlaWF3Ym9lM3hrMm14eG91NnFnbmgyMnoyZDQ0eHN5ZGtl +ZWZwbHljemt5dnhuZXp1am8zYXkiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtl +RHRpWVdaNWNtVnBhSGx1WTNOMWRITXlibk4xZG1kb2R6UmpaM1JyZG14NU1qSXljbUY0YVhZMWNXMXBaRFptYURac2N6SnlkalJ1Wm5Sb2FXTjFjbWw0Um1G +ME9pOHZaR2xrT25Cc1l6cGlhSEZ5Y25oME4zbDVabkIzWjNWcGIyRTNjbmRoTjNndllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGQwZHpabFoydGpN +bkZwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0yT2pFeExqZzBPVm89In19eyJkaWQiOiJkaWQ6cGxjOjNyeDNlbTI1eDJkanBrNHg2NGE1 +cDZlZSIsInRpbWVfdXMiOjE3ODM2MTQ4OTA5NDU2NTMsImN1cnNvciI6MjI1ODI3NDU5MDUsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzQ1OTA1LCJj +b21taXQiOnsicmV2IjoiM21xYTJ0eXdwYXoyNSIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnJlcG9zdCIsInJr +ZXkiOiIzbXFhMnR5d2docjI1IiwicmVub3llR1F5TWpkcFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMk9qQTFMamN4TWxvPSJ9fXsiZGlk +IjoiZGlkOnBsYzppZXo2d2R5aHQ3bTJrdDc2aXAyeXEzcmEiLCJ0aW1lX3VzIjoxNzgzNjE0OTgzNTI5NDUyLCJjdXJzb3IiOjIyNTgyNzkwMzExLCJraW5k +IjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc5MDMxMSwiY29tbWl0Ijp7InJldiI6IjIyMjIyM3R2NGE3MjIiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0 +aW9uIjoiYXBwLmJza3kuZmVlZC5wb3N0IiwicmtleSI6IjNtcWEyd2c2Y2pmNjIiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLnBvc3QiLCJi +cmlkZ3lPcmlnaW5hbFRleHQiOiJcdTAwM2NmaWd1cmVcdTAwM2VcdTAwM2NpbWcgYWx0PVwiXCIgY2xhc3M9XCJhdHRhY2htZW50LXJzcy1pbWFnZS1zaXpl +IHNpemUtcnNzLWltYWdlLXNpemUgd3AtcG9zdC1pbWFnZVwiIGhlaWdodD1cIjEwMjRcIiBzcmM9XCJodHRwczovL2kwLndwLmNvbS93d3cucG9ydGxhbmRt +ZXJjdXJ5LmNvbS93cC1jb250ZW50L3VwbG9hZHMvMjAyNi8wNy9IYXl3YXJkXzA3MDMyNS0xODRfQ01ZSy1zY2FsZWQuanBnP2ZpdD02ODMlMkMxMDI0XHUw +MDI2YW1wO3NzbD0xXCIgd2lkdGg9XCI2ODNcIiAvXHUwMDNlXHUwMDNjL2ZpZ3VyZVx1MDAzZVxuXHUwMDNjcFx1MDAzZVdoYXQgZm9sbG93cyBpcyBvbmUg +b2YgdGhlIG1hbnkgYXJ0aWNsZXMgaW4gdGhlIE1lcmN1cnnigJlzIDIwMjYgRm9vZCBJc3N1ZS4gRmluZCBhIHByaW50IGNvcHkgaGVyZSwgc3Vic2NyaWJl +IHRvIGdldCBhIGNvcHkgbWFpbGVkIHRvIHlvdSBoZXJlLCBhbmQgaWYgeW914oCZcmUgZmVlbGluZyBnZW5lcm91cyBhbmQgd2FudCB0byBrZWVwIHRoZXNl +IHR5cGVzIG9mIGFydGljbGVzIGNvbWluZywgc3VwcG9ydCB1cyBoZXJlLuKAlGVkcy4gSGF2aW5nIHNwZW50IGVpZ2h0IHllYXJzIGFzIGEgY2l0eSB0cmFu +c3BsYW50IGxpdmluZyBpbiBbXHUwMDI2IzgyMzA7XVx1MDAzYy9wXHUwMEpsWkM1eVpXTnZjbVJtY21WamIzSmtvbU5qYVdSNE8ySmhabmx5Wldsb2QzRnda +bnB6WlRScGQzazFlV2xpZEd4cE5tdGthWGQ2WW1kM00zZDVZV0ZrY0hSdGNtczNjSEp6YVhFMU1tdHRkM2Q1WTNWeWFYaEdZWFE2THk5a2FXUTZjR3hqT25a +cE1tZHllbVpoYkdrMWVHNDFjbWd5Ym5reWJqUmtOQzloY0hBdVluTnJlUzVtWldWa0xuQnZjM1F2TTIxeE4zVTFjMmxoTTJzeVltVnNZVzVuYzRGaVpXNXBZ +M0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTNPalU1TGpReU1Gbz0ifX17ImRpZCI6ImRpZDpwbGM6dXJvMm41Y3A2NjJ1Zm12NTQzM2w0eDY2 +IiwidGltZV91cyI6MTc4MzYxNTA3OTc0NTkwMSwiY3Vyc29yIjoyMjU4MjgzNzU3Mywia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4Mzc1NzMsImNvbW1p +dCI6eyJyZXYiOiIzbXFhMnpubmJvajJvIiwib3BlcmF0aW9uIjoiZGVsZXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQucG9zdCIsInJrZXkiOiIz +bXE0aHNvN2F6azJ2In19eyJkaWQiOiJkaWQ6cGxjOnJhdWZiZWRrcGxvM2Z3cWJ2cGZvanJoaCIsInRpbWVfdXMiOjE3ODM2MTUwMzg3MzA3MTEsImN1cnNv +ciI6MjI1ODI4MTc5NjEsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODE3OTYxLCJjb21taXQiOnsicmV2IjoiM21xYTJ5Z3BrZ2UyNiIsIm9wZXJhdGlv +biI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJya2V5IjoiM21xYTJ5Z3BnamUyNiIsInJlY29yZCI6eyIkdHlwZSI6ImFw +cC5ic2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6Mzc6MTguNDM1WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWVzbmg0bW5m +Y2J2YW1kNG0zM2Q0NTY3dnc1dTVlemxvbzRoaWc3dGpwc2VxcGxvc2JiZGUiLCJ1cmkiOiJhdDovL2RpZDpwbGM6bnZmcG9zbXBtaGVndHl2aGJzNzVzM3B3 +L2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3eXRpbWF4YzJ0In19LCJjaWQiOiJiYWZ5cmVpZ2NuanltcTI2NWdzOjI5Ljc0NloiLCJlbWJlZCI6eyIkdHlwZSI6 +ImFwcC5ic2t5LmVtYmVkLmltYWdlcyIsImltYWdlcyI6W3siYWx0IjoiIiwiYXNwZWN0UmF0aW8iOnsiaGVpZ2h0IjoyMDAwLCJ3aWR0aCI6MTUwMH0sImlt +YWdlIjp7IiR0eXBlIjoiYmxvYiIsIm1pbWVUeXBlIjoiaW1hZ2UvanBlZyIsInJlZiI6eyIkbGluayI6ImJhZmtyZWlnMmI0ZWZienFwNGVrbTZnN2lrZWhu +bHBxNGM0Y2RxZ2dnYWx0Mnlib2Z0ajdsbGFuYWJhIn0sInNpemUiOjkxNTExN319XX0sImxhbmdzIjpbImphIl0sInRleHQiOiLjgaHjgofjgaPjgajmiJHm +haLjgZfjgabjga0ifSwiY2lkIjoiYmFmeXJlaWhvYXF1a29pNDVzeHlleGxxYmF5MzZocXJsa3R5eDdvc3Jsb255Mm1oM3JqcDQ0YW82Y20iLCJyZWNvcmRf +Y2JvciI6InBXUjBaWGgwZUJ2amdhSGpnb2ZqZ2FQamdham1pSkhtaGFMamdaZmpnYWJqZ2ExbEpIUjVjR1Z5WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWldW +dFltVmtvbVVrZEhsd1pYVmhjSEF1WW5OcmVTNWxiV0psWkM1cGJXRm5aWE5tYVcxaFoyVnpnYU5qWVd4MFlHVnBiV0ZuWmFSamNtVm0yQ3BZSlFBQlZSSWcy +ZzhJVU9ZUDRSVFBHK2hSRHRXK0hCY0VPQmpHQXVlc0JjV2FmcldCb0Foa2MybDZaUm9BRGZhdFpTUjBlWEJsWkdKc2IySm9iV2x0WlZSNWNHVnFhVzFoWjJV +dmFuQmxaMnRoYzNCbFkzUlNZWFJwYjZKbGQybGtkR2daQmR4bWFHVnBaMmgwR1FmUVpXeGhibWR6Z1dKcVlXbGpjbVZoZEdWa1FYUjRHREl3TWpZdE1ESXRN +akpVTURJNk1USTZNamt1TnpRMldnPT0ifX17ImRpZCI6ImRpZDpwbGM6N2puZG83ejc3aXhpcWs2enZ6aG10b3p6IiwidGltZV91cyI6MTc4MzYxNDk3OTgy +NjA2MCwiY3Vyc29yIjoyMjU4Mjc4ODU4MSwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI3ODg1ODEsImNvbW1pdCI6eyJyZXYiOiIzbXFhMndvanczeTIy +Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQucG9zdCIsInJrZXkiOiIzbXFhMndvN21iYzJ2IiwicmVCc1l6cHZh +bkp5TkdWbU1uRTBiR2hoYzJkeWVYRnplbTlrZFhZdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnNiR0ZqTkdRMk1qVnpNbmhwWTNKbFlYUmxaRUYwZUJn +eU1ESTFMVEF6TFRJMVZESXlPakV6T2pRNExqRTFPVm89In19eyJkaWQiOiJkaWQ6cGxjOm9iNjZmdmxsdnZzdW11cWdpbjRseHRzdCIsInRpbWVfdXMiOjE3 +ODM2MTQ5NjQ1Mjg0NzEsImN1cnNvciI6MjI1ODI3ODA5NDIsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzgwOTQyLCJjb21taXQiOnsicmV2IjoiM21x +YTJ3N2hyMmQyMyIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnBvc3RnYXRlIiwicmtleSI6IjNtcWEydzZpbmsy +MnUiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLnBvc3RnYXRlIiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNjowMi44ODBaIiwiZGV0 +YWNoZWRFbWJlZGRpbmdVcmlzIjpbXSwiZW1iZWRkaW5nUnVsZXMiOlt7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5wb3N0Z2F0ZSNkaXNhYmxlUnVsZSJ9XSwi +cG9zdCI6ImF0Oi8vZGlkOnBsYzpvYjY2ZnZsbHZ2c3VtdXFnaW40bHh0c3QvYXBwLmJza3kuZmVlZC5wb3N0LzNtcWEydzZpbmsyMnUifSwiY2lkIjoiYmFm +eXJlaWV0a2M1NnVzZW81ZzZieDRjazVnY2Zjcmpydmp4bDR1bW9wYzVodnJ6eWVjcnN0ZG9uNDQiLCJyZWNvcmRfY2JvciI6InBXUndiM04wZUVaaGREb3ZM +MlJwWkRwd2JHTTZiMkkyTm1aMmJHeDJkbk4xYlhWeFoybHVOR3g0ZEhOMEwyRndjQzVpYzJ0NUxtWmxaV1F1Y0c5emRDOHpiWEZoTW5jMmFXNXJNakoxWlNS +MGVYQmxkbUZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkR2RoZEdWcFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMk9qQXlMamc0TUZwdVpXMWla +V1JrYVc1blVuVnNaWE9Cb1dVa2RIbHdaWGdpWVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWjJGMFpTTmthWE5oWW14bFVuVnNaWFZrWlhSaFkyaGxaRVZ0WW1W +a1pHbHVaMVZ5YVhPQXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozODowNS41MzlaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVpaGhlb3Vmd2hzc2h5d2Frcmpy +enJlbm9pdWp0ZTd4ZTZwYWE2d3JybnJzNXFpMmNjZW5yaSIsInVyaSI6ImF0Oi8vZGlkOnBsYzpyb2dxeGh6cTZ2eTU0bmJ1eTRuNnJ3eWQvYXBwLmJza3ku +ZmVlZC5wb3N0LzNtcWEyYWhwN3NzMm4ifSwidmlhIjp7ImNpZCI6ImJhZnlyZWlmYXppNnpqNnhwcHpueHdrbW94ZXNrdnhnNml0eGRrajRmZzY0aTc0dWo0 +emg2cHV0bWh5IiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmx6bHF5bGRoN25mYzM0cGZmZnZkMjRrby9hcHAuYnNreS5mZWVkLnJlcG9zdC8zbXFhMnAzeGhvejJ5 +In19LCJjaWQiOiJiYWZ5cmVpZ2pvcHB4NmNkeWE3aDU1bWdkc3d1bWhrMmE2dnV5N2hjY202bm1tMjNucHhua2FzaG1mbSIsInJlY29yZF9jYm9yIjoicEdO +MmFXR2lZMk5wWkhnN1ltRm1lWEpsYVdaaGVtazJlbW8yZUhCd2VtNTRkMnR0YjNobGMydDJlR2MyYVhSNFpHdHFOR1puTmpScE56UjFhalI2YURad2RYUnRh +SGxqZFhKcGVFaGhkRG92TDJScFpEcHdiR002Ykhwc2NYbHNaR2czYm1aak16UndabVptZG1ReU5HdHZMMkZ3Y0M1aWMydDVMbVpsWldRdWNtVndiM04wTHpO +dGNXRXljRE40YUc5Nk1ubGxKSFI1Y0dWeVlYQndMbUp6YTNrdVptVmxaQzVzYVd0bFozTjFZbXBsWTNTaVkyTnBaSGc3WW1GbWVYSmxhV2hvWlc5MVpuZG9j +M05vZVhkaGEzSnFjbnB5Wlc1dmFYVnFkR1UzZUdVMmNHRmhObmR5Y201eWN6VnhhVEpqWTJWdWNtbGpkWEpwZUVaaGREb3ZMMlJwWkRwd2JHTTZjbTluY1ho +b2VuRTJkbmsxTkc1aWRYazBialp5ZDNsa0wyRndjQzVpYzJ0NUxtWmxaV1F1Y0c5emRDOHpiWEZoTW1Gb2NEZHpjekp1YVdOeVpXRjBaV1JCZEhnWU1qQXlO +aTB3Tnkwd09WUXhOam96T0Rvd05TNDFNemxhIn19eyJkaWQiOiJkaWQ6cGxjOmdrZHpoaGFzbGw1bHdlYnkycG5ha2gzYyIsInRpbWVfdXMiOjE3ODM2MTQ5 +NDI3MzE5NTIsImN1cnNvciI6MjI1ODI3NzA4OTksImtpbWJlZC5yZWNvcmQiLCJyZWNvcmQiOnsiY2lkIjoiYmFmeXJlaWZicDIzZHVka2kyNmdpZGFwMm1r +dHd3am1sMmh3bGZ5aWE2cjV4eWF6dTI3ZXpjaHUzcnUiLCJ1cmkiOiJhdDovL2RpZDpwbGM6NHVzbXNlcmhqcWt2aGxkZ2VkZmpiM2p3L2FwcC5ic2t5LmZl +ZWQucG9zdC8zbXE3dnhzaTd6czJjIn19LCJsYW5ncyI6WyJlbiJdLCJ0ZXh0IjoiQnJlYXRodGFraW5nbHkgcmFjaXN0IGFuZCBhYnN1cmQhIEJ1dCB0aGlz +IGlzIHdobyB0aGUgdm90ZXJzIHNlbGVjdCB0aW1lIGFuZCBhZ2FpbiB0byByZXByZXNlbnQgdGhlaXIgaW50ZXJlc3RzLiBEaXNndXN0aW5nLiJ9LCJjaWQi +OiJiYWZ5cmVpZ2tqN29uNHB4eGRwYnF6M2NmdXM3ZjU0d241N3VnemJwaG01eGZraWYzajdycnY2cTdzNCIsInJlY29yZF9jYm9yIjoicFdSMFpYaDBlSHhD +Y21WaGRHaDBZV3RwYm1kc2VTQnlZV05wYzNRZ1lXNWtJR0ZpYzNWeVpDRWdRblYwSUhSb2FYTWdhWE1nZDJodklIUm9aU0IyYjNSbGNuTWdjMlZzWldOMElI +UnBiV1VnWVc1a0lHRm5ZV2x1SUhSdklISmxjSEpsYzJWdWRDQjBhR1ZwY2lCcGJuUmxjbVZ6ZEhNdUlFUnBjMmQxYzNScGJtY3VaU1IwZVhCbGNtRndjQzVp +YzJ0NUxtWmxaV1F1Y0c5emRHVmxiV0psWktKbEpIUjVjR1YxWVhCd0xtSnphM2t1WlcxaVpXUXVjbVZqYjNKa1puSmxZMjl5WktKalkybGtlRHRpWVdaNWNt +VnBabUp3TWpOa2RXUnJhVEkyWjJsa1lYQXliV3QwZDNkcWJXd3lhSGRzWm5scFlUWnlOWGg1WVhwMU1qZGxlbU5vZFROeWRXTjFjbWw0Um1GME9pOHZaR2xr +T25Cc1l6bzBkWE50YzJWeWFHcHhhM1pvYkdSblpXUm1hbUl6YW5jdllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGQyZUhOcE4zcHpNbU5sYkdGdVoz +T0JZbVZ1YVdOeVpXRjBaV1JCZEhnWU1qQXlOaTB3Tnkwd09WUXhOam96TlRveU15NDJNekJhIn19eyJkaWQiOiJkaWQ6cGxjOmhkbDJ1dGxta2J2N2d2ajZy +ZjdybnFydSIsInRpbWVfdXMiOjE3ODM2MTUwNjk1MjYzMTMsImN1cnNvciI6MjI1ODI4MzJZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkemNuTnBZ +ak15TW1ScFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNM09qRXpMakUyTUZvPSJ9fXsiZGlkIjoiZGlkOnBsYzpoeWZkY3djbHlqZ3V3bXN6 +czRwNHpnZWIiLCJ0aW1lX3VzIjoxNzgzNjE1MDQ4NTI2OTQwLCJjdXJzb3IiOjIyNTgyODIyMzYzLCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4MjgyMjM2 +MywiY29tbWl0Ijp7InJldiI6IjNtcWEyeXB6Z21wMnUiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZ3JhcGguZm9sbG93 +IiwicmtleSI6IjNtcWEyeXBwd2N1MmsiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5ncmFwaC5mb2xsb3ciLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5 +VDE2OjM3OjI4LjA1M1oiLCJzdWJqZWN0IjoiZGlkOnBsYzpqYmgzYW5jcjU3dDV4ZzVtcmpvcjNnemsiLCJ2aWEiOnsiY2lkIjoiYmFmeXJlaWc0Ynl5eDRy +Z3ZvMnhjY2NrdTN6eXBncXZ2eTVxdTNkcHhzamhybGVoM203NGtkd2Z6ZjQiLCJ1cmkiOiJhdDovL2RpZDpwbGM6aXY3N3ZvNjJybjVzN2VyeTRjcmZ3cm5v +L2FwcC5ic2t5LmdyYXBoLnN0YXJ0ZXJwYWNrLzNsd3dxbGNreTc1MmMifX0sImNpZCI6ImJhZnlyZWlmZWp4NzVsNGM3NmpteHp1aXNtZ3o2N3l0em9ucnFy +djU1cnBqY2VhbGNubXZkNXhzcDJhIiwicmVjb3JkX2Nib3IiOiJwR04yYVdHaVkyTnBaSGc3WW1GbWVYSmxhV2MwWW5sNWVEUnlaM1p2TW5oalkyTnJkVE42 +ZVhCbmNYWjJlVFZ4ZFROa2NIaHphbWh5YkdWb00yMDNOR3RrZDJaNlpqUmpkWEpwZUU1aGREb3ZMMlJwWkRwd2JHTTZhWFkzTjNadk5qSnlialZ6TjJWeWVU +UmpjbVozY201dkwyRndjQzVpYzJ0NUxtZHlZWEJvTG5OMFlYSjBaWEp3WVdOckx6TnNkM2R4YkdOcmVUYzFNbU5sSkhSNWNHVjFZWEJ3TG1KemEza3VaM0po +Y0dndVptOXNiRzkzWjNOMVltcGxZM1I0SUdScFpEcHdiR002YW1Kb00yRnVZM0kxTjNRMWVHYzFiWEpxYjNJelozcHJhV055Wkhsd1pYZGhjSEF1WW5OcmVT +NWxiV0psWkM1bGVIUmxjbTVoYkdobGVIUmxjbTVoYktSamRYSnBlQ3RvZEhSd2N6b3ZMM2QzZHk1NWIzVjBkV0psTG1OdmJTOTNZWFJqYUQ5MlBVb3lUVUk0 +VVhsRk1HcFJaWFJvZFcxaXBHTnlaV2JZS2xnbEFBRlZFaUFMTE1UYmF0Zk10bkVGSjBVQWFwWktDZE1SYXBuM1oreWp5VkRQSGxrcWJHUnphWHBsR2dBQlQy +aGxKSFI1Y0dWa1lteHZZbWh0YVcxbFZIbHdaV3BwYldGblpTOXFjR1ZuWlhScGRHeGxlQ0VvVFVRcElFZGhjbWR2ZVd4bGN5QXRJRUZ5WVd0dWFXVW5jeUJT +WlhacFpYZHJaR1Z6WTNKcGNIUnBiMjU0SjFsdmRWUjFZbVVnZG1sa1pXOGdZbmtnUVhKaGEyNXBaU0JNYjNabGN5QkpkQ0JTWlhSeWIyVnNZVzVuYzRGaVpX +NW1abUZqWlhSemdhSmxhVzVrWlhpaVoySjVkR1ZGYm1RWXRHbGllWFJsVTNSaGNuUVlsV2htWldGMGRYSmxjNEdpWTNWeWFYZ3JhSFIwY0hNNkx5OTNkM2N1 +ZVc5MWRIVmlaUzVqYjIwdmQyRjBZMmcvZGoxS01rMUNPRkY1UlRCcVVXVWtkSGx3WlhnY1lYQndMbUp6YTNrdWNtbGphSFJsZUhRdVptRmpaWFFqYkdsdWEy +bGpjbVZoZEdWa1FYUjRHREl3TWpZdE1EY3RNRGxVTVRZNk16VTZNVFF1TURVNVdnPT0ifX17ImRpZCI6ImRpZDpwbGM6dzczd3BnNXVwNW42ZjRvdHZ6ZTZr +dXJqIiwidGltZV91cyI6MTc4MzYxNTAyOTkyOTM2OCwiY3Vyc29yIjoyMjU4MjgxNDA4Miwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MTQwODIsImNv +bW1pdCI6eyJyZXYiOiIzbXFhMnk2YjRuaDJoIiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmdyYXBoLmZvbGxvdyIsInJr +ZXkiOiIzbXFhMnk2YXlxaDJoIiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZ3JhcGguZm9sbG93IiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjoz +NzowOS44NDdaIiwic3ViamVjdCI6ImRpZDpwbGM6N2Jia25rdTJydjJsMmM0NDZmYW01eHVqIn0sImNpZCI6ImJhZnlyZWlkbWp2dXRsdWtudzZqbGhmM2p3 +NXlucmIyazNaelZ3YnpSNWEySnVhMnAyY1dOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwd1pXcDBjWE54YzNWc2VXY3laMlp0ZEdaeFpXazJOMkl2WVhCd0xt +SnphM2t1Wm1WbFpDNXdiM04wTHpOdGNXRXlZbko0YTJFeU1qSm1jR0Z5Wlc1MG9tTmphV1I0TzJKaFpubHlaV2xtWTNGbFpEUnNibUpzZDNkcWFYTnFiRFUy +Y0c5MmFHbHZjVzlsZEdGd1p6TnFNMnR2YVRkbk5YQnZOSGxyWW01cmFuWnhZM1Z5YVhoR1lYUTZMeTlrYVdRNmNHeGpPbkJsYW5SeGMzRnpkV3g1WnpKblpt +MTBabkZsYVRZM1lpOWhjSEF1WW5OcmVTNW1aV1ZrTG5CdmMzUXZNMjF4WVRKaWNuaHJZVEl5TW1samNtVmhkR1ZrUVhSNEdESXdNall0TURjdE1EbFVNVFk2 +TXpZNk5UQXVNRFUzV2c9PSJ9fXsiZGlkIjoiZGlkOnBsYzo1emdqNW9pZ3Z3ajRqZTJkbmY1cWxwZ2IiLCJ0aW1lX3VzIjoxNzgzNjE1MDI1NjM3MzAzLCJj +dXJzb3IiOjIyNTgyODExNzg2LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4MjgxMTc4NiwiY29tbWl0Ijp7InJldiI6IjNtcWEyeTJheWNsMnEiLCJvcGVy +YXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5yZXBvc3QiLCJya2V5IjoiM21xYTJ5MmFua3QycSIsInJlY29yZCI6eyIkdHlw +ZSI6ImFwcC5ic2t5LmZlZWQucmVwb3N0IiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNzowNC40ODJaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVp +YTU0ZTRldG9iYTRyNDVrYXg3ZWZlNDdqNnU1aDd0b3NsZW1mNmNmYXhzN2xidzJvZnJmcSIsInVyaSI6ImF0Oi8vZGlkOnBsYzoyb3JzdWFicmRza2pwdWds +cHJ1NzdwbzIvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTdpNTI1YjdzMmcifSwidmlhIjp7ImNpZCI6ImJhZnlyZWljbmFmNGZ1ZDN2cWk2aWcyYzducm55N2g2 +ZnNvZjdxeXF1Z2VhNXlya2NpNmJ6M3RxM3FhIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOmxyYWVrZjJxZXJpNmQ0YWFpMm1samxhMi9hcHAuYnNreS5mZWVkLnJl +cG9zdC8zbXE3aWFrb3ZudTJoIn19LCJ6WTNvMmJqVTNkV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenBwYm5OdmJqVjVZbloxWjNGM2FHUnRhbmQ2Tlhwa2R6 +VXZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkNk5HeHRObVpyTW5ScFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMU9qVTBMams1 +TkZvPSJ9fXsiZGlkIjoiZGlkOnBsYzpmNHoybmZ0Z3JuNzVoN2gzd3VjZHl6YWYiLCJ0aW1lX3VzIjoxNzgzNjE0OTU2NDIyOTU0LCJjdXJzb3IiOjIyNTgy +Nzc3NTYzLCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc3NzU2MywiY29tbWl0Ijp7InJldiI6IjNtcWEydnkzeWJ3MngiLCJvcGVyYXRpb24iOiJjcmVh +dGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5wb3N0IiwicmtleSI6IjNtcWEydnkzb2pnMngiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5m +ZWVkLnBvc3QiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM1OjU2LjA2MVoiLCJsYW5ncyI6WyJuZSJdLCJ0ZXh0IjoiRGlnaXQ6IDUsNTcyLDgxMFxu +SW4gd29yZHM6IEZpdmUgTWlsbGlvbiBGaXZlIEh1bmRyZWQgU2V2ZW50eSBUd28gVGhvdXNhbmQgRWlnaHQgSHVuZHJlZCBUZW5cbuCkheCkmeCljeCkleCk +gyDgpavgpass4KWt4KWoLOClruClp+Clplxu4KSF4KSV4KWN4KS34KSw4KSDIOCkquCkmuCkquCkqOCljeKAjeCkqCDgpLLgpL7gpJYg4KSs4KS54KSk4KWN +4KSk4KSwIOCkueCknOCkvuCksCDgpIbgpKAg4KS44KSvIOCkpuCkuCJ9LCJjaWQiOiJiYWZ5cmVpYzJpM3F1YnFuYjRjYTc1aTNraWhzajVibWdnejJncGZ5 +N3RxcGw1a2Fha3plaTRuaGRmNCIsInJlY29yZF9jYm9yIjoicEdSMFpYaDBlT3RFYVdkcGREb2dOU3cxTnpJc09ERXdDa2x1SUhkdmNtUnpPaUJHYVhabElF +MXBiR3hwYjI0Z1JtbDJaU0JJZFc1a2NtVmtJRk5sZG1WdWRIa2dWSGR2SUZSb2IzVnpZVzVrSUVWcFoyaDBJRWgxYm1SeVpXUWdWR1Z1Q3VDa2hlQ2ttZUNs +amVDa2xlQ2tneURncGF2Z3Bhc3M0S1d0NEtXb0xPQ2xydUNscCtDbHBnciI6InAyUjBaWGgwZUZoSWJTQnViM2NnZDJoaGRDQm1hV3h0Y3lCa2FXUWdkMlVn +ZDJGMFkyZ2dkRzluWlhSb1pYSS9JRTlvSUhSb1lYUW5jeUJ5YVdkb2RDRUtiR1YwZEdWeVltOTRaQzVqYjIwdmQybG1aWE5qY21WbGJpOW1MaTR1WlNSMGVY +QmxjbUZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkR1ZsYldKbFpLSmxKSFI1Y0dWM1lYQndMbUp6YTNrdVpXMWlaV1F1WlhoMFpYSnVZV3hvWlhoMFpYSnVZV3lr +WTNWeWFYZ3hhSFIwY0hNNkx5OXNaWFIwWlhKaWIzaGtMbU52YlM5M2FXWmxjMk55WldWdUwyWnBiRzB2Y0hWd2NIbG5hWEpzTDJWMGFIVnRZcVJqY21WbTJD +cFlKUUFCVlJJZ1NsK3JURGl3MVFKTU5wQXZnbDN0YW1NOVgxeTRHY2lkTURTNVA4KytIb0ZrYzJsNlpSb0FBVXlzWlNSMGVYQmxaR0pzYjJKb2JXbHRaVlI1 +Y0dWcWFXMWhaMlV2YW5CbFoyVjBhWFJzWlhnY1FTQnlaWFpwWlhjZ2IyWWdVSFZ3Y0hsbmFYSnNJQ2d5TURJMUtXdGtaWE5qY21sd2RHbHZibmpMVkdocGN5 +QjNZWE1nZEdobElHTnNiM05wYm1jZ1ptbHNiU0JoZENCVVNWUkZMaUJKSUhkbGJuUWdkRzhnZEdobElHRm1kR1Z5SUhCaGNuUjVJR0Z1WkNCaGNtMGdkM0ps +YzNSc1pXUWdaWFpsY25sdmJtVWdkMmh2SUhkaGN5QjNhV3hzYVc1bkxpQkpJRzExYzNRZ2FHRjJaU0IzY21WemRHeGxaQ0JoSUdSdmVtVnVJR1pwYkcxdFlX +dGxjbk1zSUdKMWRDQkpJR3RsY0hRZ2QybHVibWx1Wnk0Z1NTQmhjbTBnZDNKbGMzUnNaV1FnZEdobElIUnBkSFZzWVhJZ2NIVndjSGxuYVhJdUxpNWxiR0Z1 +WjNPQlltVnVaWEpsY0d4NW9tUnliMjkwb21OamFXUjRPMkpoWm5seVpXbGhkWFJ5YjJWNGVtNXRkSEEwYjJoaFl6SjZZWFI2YVcxeGFHWnRZMjExZEdabGQz +Rm5kR3R1YzJzMGRtVmlkWFYwZG1oaFkzVnlhWGhHWVhRNkx5OWthV1E2Y0d4ak9uaHVabk55ZEdZMWEyTXlielZ2ZHpKeGRHbDBhWEYzYmk5aGNIQXVZbk5y +ZVM1bVpXVmtMbkJ2YzNRdk0yMXhOM2xwZVdoeGVESXlhMlp3WVhKbGJuU2lZMk5wWkhnN1ltRm1lWEpsYVdOY21WcFpIQm1NbW95YzNONWVIQm5aWGhvY25s +NGRqUnVjR1UzYVd4dGJqTjJZM1JrYUhBemFYazFhV2hpWW1KMWF6ZHJkR3RvTkdOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwNGVXUmtjR2MyZFhOdFoyZ3lk +REpxWjJZMFpUTTNlV3N2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZDVORGRxZG5Wek1uWnBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRF +Mk9qTTNPakF3TGpFek9Gbz0ifX17ImRpZCI6ImRpZDpwbGM6M3ZoN295ZXFkeWIzdG00bXJnd3M2ZWpsIiwidGltZV91cyI6MTc4MzYxNTA4NzIzNDc1MCwi +Y3Vyc29yIjoyMjU4Mjg0MTMwOSwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4NDEzMDksImNvbW1pdCI6eyJyZXYiOiIzbXFhMnp1eHVycjJmIiwib3Bl +cmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXkiOiIzbXFhMnp1eGx5ajJmIiwicmVjb3JkIjp7IiR0eXBl +IjoiYXBwLmJza3kuZmVlZC5saWtlIiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozODowNy4wNjJaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVpZ3F6 +dGhkZHBtNzNqNGg0am01NXZoNW5yaTI0bXp2bGlzaDZoczZsNW1sZnhoNHJkNXllbSIsInVyaSI6ImF0Oi8vZGlkOnBsYzprdXZsMnl1eTJpa2huMmwyc3pz +dnh2eGEvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd4c3poNmQyMmcifX0sImNpZCI6ImJhZnlyZWloZmJpbmRqaWE0dXQzeTc3dHYza2ZwbXdkM3lwbXBobHRi +Z2l3NjdleTVuZ2Y3d3g3bW5lIiwicmVjb3JkX2Nib3IiOiJvMlVrZEhsd1pYSmhjSEF1WW5OcmVTNW1aV1ZrTG14cGEyVm5jM1ZpYW1WamRLSmpZMmxrZUR0 +aVlXWjVjbVZwWjNGNmRHaGtaSEJ0TnpOcU5HZzBhbTAxTlhab05XNXlhVEkwYlhwMmJHbHphRFpvY3pac05XMXNabmhvTkhKa05YbGxiV04xY21sNFJtRjBP +aTh2Wkdsa09uQnNZenByZFhac01ubDFlVEpwYTJodU1td3ljM3B6ZG5oMmVHRXZZWEJ3TG1KemEza3VabVZsWkM1d2IzTjBMek50Y1RkNGMzcG9oNnFjM3Nk +cGFsNXZxaCIsInRpbWVfdXMiOjE3ODM2MTQ5MDc1NDY3NTcsImN1cnNvciI6MjI1ODI3NTM2MzcsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzUzNjM3 +LCJjb21taXQiOnsicmV2IjoiM21xYTJ1ampjM3AyYiIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJy +a2V5IjoiM21xYTJ1aml5ZDcyYiIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzU6 +MDcuMjgyNDEyKzAwOjAwIiwic3ViamVjdCI6eyIkdHlwZSI6ImNvbS5hdHByb3RvLnJlcG8uc3Ryb25nUmVmIiwiY2lkIjoiYmFmeXJlaWFqdjJtM3ZnbzZt +YzJmdHVtdzR0dHNnYTM0eWxvcTVxbGxneXFwb3U2a3VocW9hbXV0dmUiLCJ1cmkiOiJhdDovL2RpZDpwbGM6dmY1cWh0ZWllZW82eW9sYWJzY3dtanc2L2Fw +cC5ic2t5LmZlZWQucG9zdC8zbXE3eHBkd2tpMjJ1In19LCJjaWQiOiJiYWZ5cmVpaHlza2Z4bHM3cXBsd21ia202dDU1NXJiYmoyZ2thZHRod3d0cnZ0dDI1 +b2p2MnlsaGx0bSIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS05qWTJsa2VEdGlZV1o1Y21W +cFlXcDJNbTB6ZG1kdk5tMWpNbVowZFcxM05IUjBjMmRoTXpSNWJHOXhOWEZzYkdkNWNYQnZkVFpyZFdoeGIyRnRkWFIyWldOMWNtbDRSbUYwT2k4dlpHbGtP +bkJzWXpwMlpqVnhhSFJsYVdWbGJ6WjViMnhoWW5OamQyMXFkell2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZDRjR1IzYTJreU1uVmxKSFI1Y0dW +NEdtTnZiUzVoZEhCeWIzUnZMbkpsY0c4dWMzUnliMjVuVW1WbWFXTnlaV0YwWldSQmRIZ2dNakF5Tmkwd055MHdPVlF4Tmpvek5Ub3dOeTR5T0RJME1USXJN +REE2TURBPSJ9fXsiZGlkIjoiZGlkOnBsYzpnNjI3dzVsMnBweW9pNTZpbjJmYXFiZ3ciLCJ0aW1lX3VzIjoxNzgzNjE1MDU0NzI1ODM3LCJjdXJzb3IiOjIy +NTgyODI1Mzg1LCJraTRHREl3TWpZdE1EY3RNRGxVTVRZNk16VTZOVGN1TXpVeVdnPT0ifX17ImRpZCI6ImRpZDpwbGM6c2Znb2l1eTVqdW5mMnRwdmpkcWQ2 +ejI0IiwidGltZV91cyI6MTc4MzYxNTAwOTczMDg0OCwiY3Vyc29yIjoyMjU4MjgwMjc0Mywia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MDI3NDMsImNv +bW1pdCI6eyJyZXYiOiIzbXFhMnhsMm14ajJ0Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIsInJrZXki +OiIzbXFhMnhsMmY1ajJ0IiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5saWtlIiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0wOVQxNjozNjo0OS40 +MDdaIiwic3ViamVjdCI6eyJjaWQiOiJiYWZ5cmVpaHQyaWV1cmhhNHM3bGl6NmN5azNmNDZsamc0dGI3dHZsa3FkMmFhYTViZWtsZmY0dmlheSIsInVyaSI6 +ImF0Oi8vZGlkOnBsYzpzM20zM3d2ZHNpeHhyMmlmbmtsZGxmcDMvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd6aTdkZHZzMmkifX0sImNpZCI6ImJhZnlyZWln +Y3VsN2E1cnF2am14cWVwM3Y0dWNqajdmcmlpb3I0bzZ1a2RzZGw0NmFvaW9jcG1wMnh1IiwicmVjb3JkX2Nib3IiOiJvMlVrZEhsd1pYSmhjSEF1WW5OcmVT +NW1aV1ZrTG14cGEyVm5jM1ZpYW1WamRLSmpZMmxrZUR0aVlXWjVjbVZwYUhReWFXVjFjbWhoTkhNM2JHbDZObU41YXpObU5EWnNhbWMwZEdJM2RIWnNhM0Zr +TW1GaFlUVmlaV3RzWm1ZMGRtbGhlV04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenB6TTIwek0zZDJaSE5wZUhoeU1tbG1ibXRzWkd4bWNETXZZWEJ3TG1KemEz +a3VabVZsWkM1d2IzTjBMek50Y1RkNmFUZGtaSFp6TW1scFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMk9qUTVMalF3TjFvPSJ9fXsiZGlk +IjoiZGlkOnBsYzptYXF4ZTRvYWc2eDdjYXhwbWs2NWlpbG8iLCJ0aW1lX3VzIjoxNzgzNjE0OTQzNDQ5OTE1LCJjdXJzb3IiOjIyNTgyNzcxMjQyLCJraW5k +IjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc3MTI0MiwiY29tTHpOdGNUZDZiR3cxYnpKek1tWnBZM0psWVhSbFpFRjBlQnN5TURJMkxUQTNMVEE1VkRFMk9qTTJP +alEyTGpBMk56azRPVm89In19eyJkaWQiOiJkaWQ6cGxjOjN1enBhNTNhMzJqcDNhc2hrM2xhemZlbCIsInRpbWVfdXMiOjE3ODM2MTQ5MTEyNTI4MDYsImN1 +cnNvciI6MjI1ODI3NTUyOTQsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzU1Mjk0LCJjb21taXQiOnsicmV2IjoiM21xYTJ1bXpubDcyYyIsIm9wZXJh +dGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJya2V5IjoiM21xYTJ1bXpmcjcyYyIsInJlY29yZCI6eyIkdHlwZSI6 +ImFwcC5ic2t5LmZlZWQubGlrZSIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzU6MTAuOTI2WiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWNhajZv +eW1lYmVsc3liYW9rcTV3YW1xZXhvMnYyYXVrbHUya2I1ZHAyM2VndGpkdDNjNTQiLCJ1cmkiOiJhdDovL2RpZDpwbGM6ZmIzcDRmZnV0anNmN2p1NTNwdmF3 +Zm96L2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3cW5od3hpazJ1In19LCJjaWQiOiJiYWZ5cmVpZWk3NmY2NHo1a2Y1dWJicjRnbW1ndm9ma3A1Z2dqMnpmb2t1 +YzZkZjI1bWV0ZmpvcG5nNCIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xteHBhMlZuYzNWaWFtVmpkS0pqWTJsa2VEdGlZ +V1o1Y21WcFkyRnFObTk1YldWaVpXeHplV0poYjJ0eE5YZGhiWEZsZUc4eWRqSmhkV3RzZFRKcllqVmtjREl6WldkMGFtUjBNMk0xTkdOMWNtbDRSbUYwT2k4 +dlpHbGtPbkJzWXpwbVlqTndOR1ptZFhScWMyWTNhblUxTTNCMllYZG1iM292WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZHhibWgzZUdsck1uVnBZ +M0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTFPakV3TGpreU5sbz0ifX17ImRpZCI6ImRpZDpwbGM6dW10dzQybHljeW10dDN6MnIyeTdkZTJy +IiwidGltZV91cyI6MTc4MzYxNTA0MTEyNjYxMSwiY3Vyc29yIjoyMjU4MjgxODk0MSwia2lkZ2F0ZSIsImFsbG93IjpbeyIkdHlwZSI6ImFwcC5ic2t5LmZl +ZWQudGhyZWFkZ2F0ZSNmb2xsb3dlclJ1bGUifSx7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC50aHJlYWRnYXRlI2ZvbGxvd2luZ1J1bGUifV0sImNyZWF0ZWRB +dCI6IjIwMjYtMDctMDlUMTY6Mzc6MTcuMjkyWiIsImhpZGRlblJlcGxpZXMiOltdLCJwb3N0IjoiYXQ6Ly9kaWQ6cGxjOnh5bDNhcG5la3RpN2J0eWRuZGdu +dnFiZS9hcHAuYnNreS5mZWVkLnBvc3QvM21xYTJ5YWs2ZTIyeSJ9LCJjaWQiOiJiYWZ5cmVpaGpsN2phbG42YWtyaXNxMzRhaHRvbnlxZmhtZGFpZGhsazYz +YW8yZ25yZmw0NG1jaGhkaSIsInJlY29yZF9jYm9yIjoicFdSd2IzTjBlRVpoZERvdkwyUnBaRHB3YkdNNmVIbHNNMkZ3Ym1WcmRHazNZblI1Wkc1a1oyNTJj +V0psTDJGd2NDNWljMnQ1TG1abFpXUXVjRzl6ZEM4emJYRmhNbmxoYXpabE1qSjVaU1IwZVhCbGVCaGhjSEF1WW5OcmVTNW1aV1ZrTG5Sb2NtVmhaR2RoZEdW +bFlXeHNiM2VDb1dVa2RIbHdaWGdsWVhCd0xtSnphM2t1Wm1WbFpDNTBhSEpsWVdSbllYUmxJMlp2Ykd4dmQyVnlVblZzWmFGbEpIUjVjR1Y0Sm1Gd2NDNWlj +MnQ1TG1abFpXUXVkR2h5WldGa1oyRjBaU05tYjJ4c2IzZHBibWRTZFd4bGFXTnlaV0YwWldSQmRIZ1lNakF5Tmkwd055MHdPVlF4Tmpvek56b3hOeTR5T1RK +YWJXaHBaR1JsYmxKbGNHeHBaWE9BIn19eyJkaWQiOiJkaWQ6cGxjOm1seGRveGhwMnpwdnZteTJobmh1Y2E3NSIsInRpbWVfdXMiOjE3ODM2MTQ5MjMzMjg3 +OTMsImN1cnNvciI6MjI1ODI3NjExMjMsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzYxMTIzLCJjb21taXQiOnsicmV2IjoiM21xYTJ1eWt4bnMybiIs +Im9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5ncmFwaC5mb2xsb3ciLCJya2V5IjoiM21xYTJ1eWtzcmsybiIsInJlY29yZCI6 +eyIkdHlwZSI6ImFwcC5ic2t5LmdyYXBoLmZvbGxvdyIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzU6MjUuNDkxWiIsImIzTjBMek50Y1Rkdk5HSnlk +M05qTW5kcFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNME9qVXpMak14TVZvPSJ9fXsiZGlkIjoiZGlkOnBsYzp3MnlkdmV2aXc1eGJreWp6 +Z3N2aXR0dGwiLCJ0aW1lX3VzIjoxNzgzNjE1MDYxMjQ3NjMzLCJjdXJzb3IiOjIyNTgyODI4NTQ1LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4MjgyODU0 +NSwiY29tbWl0Ijp7InJldiI6IjNtcWEyejN0YWQzMnAiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwi +cmtleSI6IjNtcWEyejNzeWozMnAiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM3 +OjQxLjE1MVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlneWRlNXFsNmNobHZzYWNrejZ3dWYyNTdxazYzaHpnNDNjZWs3ZnBoa3Bpc3AyNHdmY3JhIiwi +dXJpIjoiYXQ6Ly9kaWQ6cGxjOnFna3A1dzJvZDVwbHR1a2o2YWF0aXUyYy9hcHAuYnNreS5mZWVkLnBvc3QvM21xN3cyYnNqbWsycCJ9fSwiY2lkIjoiYmFm +eXJlaWZ2dGlkaW1xc3Jqd3R1dnp6N242bG1scGN6a3pqb3NkdWZoeTR4aG9rdm82cmdzeG12eWkiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZ +bk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBaM2xrWlRWeGJEWmphR3gyYzJGamEzbzJkM1ZtTWpVM2NXczJNMmg2WnpR +elkyVnJOMlp3YUd0d2FYTndNalIzWm1OeVlXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cHhaMnR3TlhjeWIyUTFjR3gwZFd0cU5tRmhkR2wxTW1NdllYQndM +bUp6YTNrdVptVmxaQzV3YjNOMEx6TnRjVGQzTW1KemFtMXJNbkJwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0zT2pReExqRTFNVm89In19 +eyJkaWQiOiJkaWQ6cGxjOm83ZTR2eGNiYXZiZWI0cXlyYXNjN3Q1NiIsInRpbWVfdXMiOjE3ODM2MTQ4OTMxMjY3OTksImN1cnNvciI6MjI1ODI3NDY4NTEs +ImtpdCI6IjIwMjYtMDctMDlUMTY6MzU6NDQuMjAzWiIsInN1YmplY3QiOnsiY2lkIjoiYmFmeXJlaWZ0a3BiNnYycXhrZmhpZGRoZTNrNjJsb2g2a3VmbWs2 +ZHdkYTd2NGNqajUzanVqcjc0d3EiLCJ1cmkiOiJhdDovL2RpZDpwbGM6bng3em52b2V4N2V2M3djeG4zdGlwb3ZtL2FwcC5ic2t5LmZlZWQucG9zdC8zbXE3 +dW13Z2dvazJrIn0sInZpYSI6eyJjaWQiOiJiYWZ5cmVpYnIzemZzdWdpcXRpNHZta3p2ZzU0anRoNDZtdnhmdm4yc2J1ZHd5a3QzbGh5dWFjNnJyYSIsInVy +aSI6ImF0Oi8vZGlkOnBsYzphdTJ0aTVqZnNtcjZieGZyNmFrbmxuZHUvYXBwLmJza3kuZmVlZC5yZXBvc3QvM21xYTJzd2hvb20yMiJ9fSwiY2lkIjoiYmFm +eXJlaWUybjJ4d2dxZnV4eGgyaWl1eTZncTZhcWMydnVwa2l3Z3NyYjd1aGhiemFobTU3bnNiM3EiLCJyZWNvcmRfY2JvciI6InBHTjJhV0dpWTJOcFpIZzdZ +bUZtZVhKbGFXSnlNM3BtYzNWbmFYRjBhVFIyYld0NmRtYzFOR3AwYURRMmJYWjRablp1TW5OaWRXUjNlV3QwTTJ4b2VYVmhZelp5Y21GamRYSnBlRWhoZERv +dkwyUnBaRHB3YkdNNllYVXlkR2sxYW1aemJYSTJZbmhtY2paaGEyNXNibVIxTDJGd2NDNWljMnQ1TG1abFpXUXVjbVZ3YjNOMEx6TnRjV0V5YzNkb2IyOXRN +akpsSkhSNWNHVjBZWEJ3TG1KemEza3VabVZsWkM1eVpYQnZjM1JuYzNWaWFtVmpkS0pqWTJsa2VEdGlZV1o1Y21WcFpuUnJjR0kyZGpKeGVHdG1hR2xrWkdo +bE0yczJNbXh2YURacmRXWnRhelprZDJSaE4zWTBZMnBxTlROcWRXcHlOelIzY1dOMWNtbDRSbUYwT2k4dlpHbGtPbkJzWXpwdWVEZDZiblp2WlhnM1pYWXpk +Mk40YmpOMGFYQnZkbTB2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUZDFiWGRuWjI5ck1tdHBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRF +Mk9qTTFPalEwTGpJd00xbz0ifX17ImRpZCI6ImRpZDpwbGM6cHdlaW00eGltdzYydXZwNXdpZjZpcTNhIiwidGltZV91cyI6MTc4MzYxNDk1ODUyODQ0MSwi +Y3Vyc29yIjoyMjU4Mjc3ODUzMywia2kzTjBMek50Y1RWeWRtcHdZbkF5TWpacFkzSmxZWFJsWkVGMGVCZ3lNREkyTFRBM0xUQTVWREUyT2pNMk9qTXdMakk0 +T0ZvPSJ9fXsiZGlkIjoiZGlkOnBsYzp4enVleTVkZXZ0b3Fpbno2bW4zNndncTMiLCJ0aW1lX3VzIjoxNzgzNjE1MDIyODEwOTAwLCJjdXJzb3IiOjIyNTgy +ODA4OTQ1LCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4MjgwODk0NSwiY29tbWl0Ijp7InJldiI6IjNtb2Q1NjR5azNyMmkiLCJvcGVyYXRpb24iOiJjcmVh +dGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNscm0yY2p6amVpMmUiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5m +ZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI1LTA2LTE0VDIyOjU1OjU4LjYyNVoiLCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWlieXF0aGJpcWZ2d3Y0dGh2 +YTNlc2h3YXVuNGhrNWMyZXA1aWluMjRhNnl3cXU2aHUzaWtpIiwidXJpIjoiYXQ6Ly9kaWQ6cGxjOjZrbTUzZXZtM3N4bWZwaHpzZzNicmR0bi9hcHAuYnNr +eS5mZWVkLnBvc3QvM2xybGF1cXRya2syaiJ9fSwiY2lkIjoiYmFmeXJlaWRpenJhaGdycHV1eHg1c3B4ZW52aXlodHFpN2s1bGo3YWhhY3M3NTNjeW55ZHgy +ZTRxamkiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpXVmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBZbmx4 +ZEdoaWFYRm1kbmQyTkhSb2RtRXpaWE5vZDJGMWJqUm9helZqTW1Wd05XbHBiakkwWVRaNWQzRjFObWgxTTJscmFXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6 +bzJhMjAxTTJWMmJUTnplRzFtY0doNmMyY3pZbkprZEc0dllYQndMbUp6YTNrdVptVmxaQzV3YjNOMEx6TnNjbXhoZFhGMGNtdHJNbXBwWTNKbFlYUmxaRUYw +ZUJneU1ESTFMVEEyTFRFMFZESXlPalUxT2pVNExqWXlOVm89In19eyJkaWQiOiJkaWQ6cGxjOnd4YmtxaTJqNGdhd2s1NHVxMm0za2lldiIsInRpbWVfdXMi +OjE3ODM2MTUwMjkzMzM4NTAsImN1cnNvciI6MjI1ODI4MTM4MzIsImtpblRZNk16UTZOVFV1TURjeFdnPT0ifX17ImRpZCI6ImRpZDpwbGM6YWE2bHNzZWhq +Y3UzbXNpeDJvampwdGZhIiwidGltZV91cyI6MTc4MzYxNTA1Mzg5MTQ0MCwiY3Vyc29yIjoyMjU4MjgyNDk1OCwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1 +ODI4MjQ5NTgsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnl2NGJjbzI3Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQu +cG9zdCIsInJrZXkiOiIzbXFhMnl1enB2YzI3IiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5wb3N0IiwiY3JlYXRlZEF0IjoiMjAyNi0wNy0w +OVQxNjozNzozMy42MThaIiwiZW1iZWQiOnsiJHR5cGUiOiJhcHAuYnNreS5lbWJlZC5leHRlcm5hbCIsImV4dGVybmFsIjp7ImRlc2NyaXB0aW9uIjoiIiwi +dGl0bGUiOiJGYWNlYm9vayIsInVyaSI6Imh0dHBzOi8vd3d3LmZhY2Vib29rLmNvbS9zaGFyZS9yLzE5M1V5cFNDYXcvP21pYmV4dGlkPXd3WElmciJ9fSwi +ZmFjZXRzIjpbeyJmZWF0dXJlcyI6W3siJHR5cGUiOiJhcHAuYnNreS5yaWNodGV4dC5mYWNldCNsaW5rIiwidXJpIjoiaHR0cHM6Ly93d3cuZmFjZWJvb2su +Y29tL3NoYXJlL3IvMTkzVXlwU0Nhdy8/bWliZXh0aWQ9d3dYSWZyIn1dLCJpbmRleCI6eyJieXRlRW5kIjozMiwiYnl0ZVN0YXJ0IjowfX1dLCJsYW5ncyI6 +WyJlbiJdLCJ0ZXh0Ijoid3d3LmZhY2Vib29rLmNvbS9zaGFyZS9yLzE5M1UuLi4ifSwiY2lkIjoiYmFmeXJlaWF4bXp2MmRrMmR2aGd3NHE2YzdnNDV2YWpt +cjRtZWl5cDJrYW9kbXBlbmRlam1jam43aGEiLCJyZWNvcmRfY2JvciI6InBtUjBaWGgwZUNCM2QzY3VabUZqWldKdmIyc3VZMjl0TDNOb1lYSmxMM0l2TVRr +elZTNHVMbVVrZEhsd1pYSmhjSEF1WW5OcmVTNW1aV1ZrTG5CdmMzUmxaVzFpWldTaVpTUjBlWEJsZDJGd2NDNWljMnQ1TG1WdFltVmtMbVY0ZEdWeWJtRnNh +R1Y0ZEdWeWJtRnNvMk4xY21sNFBHaDBkSEJ6T2k4dmQzZDNMbVpoWTJWaWIyOXJMbU52YlM5emFHRnlaUzl5cmVTNW1aV1ZrTG5Sb2NtVmhaR2RoZEdWbFlX +eHNiM2VCb1dVa2RIbHdaWGdtWVhCd0xtSnphM2t1Wm1WbFpDNTBhSEpsWVdSbllYUmxJMlp2Ykd4dmQybHVaMUoxYkdWcFkzSmxZWFJsWkVGMGVCZ3lNREky +TFRBM0xUQTVWREUyT2pNM09qSXdMakl4TUZwdGFHbGtaR1Z1VW1Wd2JHbGxjNEE9In19eyJkaWQiOiJkaWQ6cGxjOm9yZnNjb3dod3lqbGU3enR6bWZma2Fu +biIsInRpbWVfdXMiOjE3ODM2MTUwMDU5Mjg2OTcsImN1cnNvciI6MjI1ODI4MDA4ODksImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODAwODg5LCJjb21t +aXQiOnsicmV2IjoiM21xYTJ4aDZhZjUyZiIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnBvc3QiLCJya2V5Ijoi +M21xYTJ4Z2l5YWsyeSIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQucG9zdCIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzY6NDQuODM0 +WiIsImxhbmdzIjpbImVuIl0sInJlcGx5Ijp7InBhcmVudCI6eyJjaWQiOiJiYWZ5cmVpZHBmMmoyc3N5eHBnZXhocnl4djRucGU3aWxtbjN2Y3RkaHAzaXk1 +aWhiYmJ1azdrdGtoNCIsInVyaSI6ImF0Oi8vZGlkOnBsYzp4eWRkcGc2dXNtZ2gydDJqZ2Y0ZTM3eWsvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd5NDdqdnVz +MnYifSwicm9vdCI6eyJjaWQiOiJiYWZ5cmVpZHBmMmoyc3N5eHBnZXhocnl4djRucGU3aWxtbjN2Y3RkaHAzaXk1aWhiYmJ1azdrdGtoNCIsInVyaSI6ImF0 +Oi8vZGlkOnBsYzp4eWRkcGc2dXNtZ2gydDJqZ2Y0ZTM3eWsvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd5NDdqdnVzMnYifX0sInRleHQiOiJVbmNvbi1Eb24i +fSwiY2lkIjoiYmFmeXJlaWRlbXZ3Y3Y1bmRvN2FkMzRtZmdvaXdtcWNjeDZzajZja2MzdG5hNjNvcDRndnN4enNiNm0iLCJyZWNvcmRfY2JvciI6InBXUjBa +WGgwYVZWdVkyOXVMVVJ2Ym1Va2RIbHdaWEpoY0hBdVluTnJlUzVtWldWa0xuQnZjM1JsYkdGdVozT0JZbVZ1WlhKbGNHeDVvbVJ5YjI5MG9tTmpjYm5obHZt +cjVkdGNqd3N6NmxucmV3cjJjYzR0ajVvcXRoYmRmYzdhbSIsInVyaSI6ImF0Oi8vZGlkOnBsYzo0a3lwNGFod3h1cjVtNmVkZ2c2empob2YvYXBwLmJza3ku +ZmVlZC5yZXBvc3QvM21xYTJvY3hkdXQyNCJ9fSwiY2lkIjoiYmFmeXJlaWh2Y3E2YmxpeHM0ZGhpa3ZveGtmM2tzdmp0NWNucmNzaDVhaHZncXJidGxiczR1 +d3NjdHEiLCJyZWNvcmRfY2JvciI6InBHTjJhV0dpWTJOcFpIZzdZbUZtZVhKbGFXVm9iR3R3ZHpONllqUjNZMkp1YUd4MmJYSTFaSFJqYW5kemVqWnNibkps +ZDNJeVkyTTBkR28xYjNGMGFHSmtabU0zWVcxamRYSnBlRWhoZERvdkwyUnBaRHB3YkdNNk5HdDVjRFJoYUhkNGRYSTFiVFpsWkdkbk5ucHFhRzltTDJGd2ND +NWljMnQ1TG1abFpXUXVjbVZ3YjNOMEx6TnRjV0V5YjJONFpIVjBNalJsSkhSNWNHVjBZWEJ3TG1KemEza3VabVZsWkM1eVpYQnZjM1JuYzNWaWFtVmpkS0pq +WTJsa2VEdGlZV1o1Y21WcFpEUTFNMlpyZUdOeFoyeG1lV1J6Y0dsMlltdG1lSG8xY25CNGNUVjROWFJoYUhCaU0zTmxlV1pzTm01aGN6VnZNemR4WVdOMWNt +bDRSbUYwT2k4dlpHbGtPbkJzWXpveWRIRjVkVzV4TjNodGRtSnVOV1JrWVRSeGFtVjNNblF2WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wTHpOdGNUWmxjMjUz +TkhKck1tSnBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTNPalEwTGpnd05sbz0ifX17ImRpZCI6ImRpZDpwbGM6amhwNnA3Y2l6bm9iamMy +NGJudGM0NjJxIiwidGltZV91cyI6MTc4MzYxNTA4OTQ5Mjk0NSwiY3Vyc29yIjoyMjU4Mjg0MjM5Niwia2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4NDIz +OTYsImNvbW1pdCI6eyJyZXYiOiIzbXBvbzZoaXpzZTJlIiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29sbGVjdGlvbiI6ImFwcC5ic2t5LmZlZWQubGlrZSIs +InJrZXkiOiIzbHhwM29saWRsazJiIiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5saWtlIiwiY3JlYXRlZEF0IjoiMjAyNS0wOC0zMVQxMjoy +OTo0NC45MzhaIiwiczY3NjIsImN1cnNvciI6MjI1ODI3NTAxNjEsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyNzUwMTYxLCJjb21taXQiOnsicmV2Ijoi +M21xYTJ1Y2tnZDYyNCIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnBvc3QiLCJya2V5IjoiM21xYTJ1Y2FmZ3My +MyIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQucG9zdCIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzQ6NTkuNjk2WiIsImxhbmdzIjpb +ImVuIl0sInJlcGx5Ijp7InBhcmVudCI6eyJjaWQiOiJiYWZ5cmVpZ2Jkd3VzM3h3Y3g1ZWI3ZG0yN3ZjZGJ2M29iaW96NHRrbHBhdnh0Y2ViN2Nhc2pqcXJ2 +eSIsInVyaSI6ImF0Oi8vZGlkOnBsYzo1bzMyenh5c2VtdHBrcTQ2d3lueHI0ZHAvYXBwLmJza3kuZmVlZC5wb3N0LzNtcWEycW92a3lrMngifSwicm9vdCI6 +eyJjaWQiOiJiYWZ5cmVpYjNtamZ1aDM3MmEycjNoM2NmcmNyYWl2bDVvd2o2M3RxNmRxb3JmaGd1dHlsN2hpNWV1NCIsInVyaSI6ImF0Oi8vZGlkOnBsYzpr +cjUzY2FtampvMnJtemJ4cm83endjaHQvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd6Y3hoZmtzMjMifX0sInRleHQiOiJ5ZXNzcyBpdHMgbXkgY2FsbSBicmFp +biBvZmYgZ2FtZSBmb3Igc3VyZSAhISEifSwiY2lkIjoiYmFmeXJlaWg0ZGI3bjdvdHp1ZXE3bjdhdW5leXJjZXI0bnVocGtmenoybmNsdmJ5bXEzNW42amRp +ZTQiLCJyZWNvcmRfY2JvciI6InBXUjBaWGgwZUMxNVpYTnpjeUJwZEhNZ2JYa2dZMkZzYlNCaWNtRnBiaUJ2Wm1ZZ1oyRnRaU0JtYjNJZ2MzVnlaU0FoSVNG +bEpIUjVjR1Z5WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWld4aGJtZHpnV0psYm1WeVpYQnNlYUprY205dmRLSmpZMmxrZUR0aVlXWjVjbVZwWWpOdGFtWjFh +RE0zTW1FeWNqTm9NMk5tY21OeVlXbDJiRFZ2ZDJvMk0zUnhObVJ4YjNKbWFHZDFkSGxzTjJocE5XVjFOR04xY21sNFJtRjBPaTh2Wkdsa09uQnNZenByY2pV +elkyRnRhbXB2TW5KdGVtSjRjbTgzZW5kamFIUXZZWEJ3amdyWGpnN1BqZzVmamc2c0s1WVdvNWJtMDZiMmlMMEUxTHpVMFVBcmpnWVRqZ1kvamdhVGpnWXZq +Z1lyb3FiSG9xYkRqZ29IamdiN2pnWmZqZ1ovd240NkJDdW1GcXVpK3N1V3V0dU9CcnVlTGd1T0JtT09CbGVPQ2srT0JxT09CaytPQmh1T0JsK09CcnVpQm9l +T0J2K09CaitPQ2srT0JydU9CdStPQnJ1T0J2T09CcmlqdnZKOHA0NEdxNDRHSzZLbXg0NEduNDRHWjhKK1FoQW9LTVREbW5wcm5sTHZsZzQvb3ZJbmpnWnZq +Z296amdvdmpnYTducFo1bEpIUjVjR1Z5WVhCd0xtSnphM2t1Wm1WbFpDNXdiM04wWldWdFltVmtvbVVrZEhsd1pYWmhjSEF1WW5OcmVTNWxiV0psWkM1bllX +eHNaWEo1WldsMFpXMXppYVJqWVd4MFlHVWtkSGx3WlhnY1lYQndMbUp6YTNrdVpXMWlaV1F1WjJGc2JHVnllU05wYldGblpXVnBiV0ZuWmFSamNtVm0yQ3BZ +SlFBQlZSSWdUUENESlFHczFidDdhZDRSRjErQlgxWXNGKzc2WHRQU3lWWXpHckcwZGNSa2MybDZaUm9BQ2FzL1pTUjBlWEJsWkdKc2IySm9iV2x0WlZSNWNH +VnFhVzFoWjJVdmFuQmxaMnRoYzNCbFkzUlNZWFJwYjZKbGQybGtkR2daQXlCbWFHVnBaMmgwR1FSOXBHTmhiSFJnWlNSMGVYQmxlQnhoY0hBdVluTnJlUzVs +YldKbFpDNW5ZV3hzWlhKNUkybHRZV2RsWldsdFlXZGxwR055WldiWUtsZ2xBQUZWRWlEdEFRK3JyTUdlMGNCVjJSUVZncW1vWGFhMFFYdXJobnppSXlIRHVR +cW5HbVJ6YVhwbEdnQUNnbDlsSkhSNWNHVmtZbXh2WW1odGFXMWxWSGx3WldwcGJXRm5aUzlxY0dWbmEyRnpjR1ZqZEZKaGRHbHZvbVYzYVdSMGFCa0RJR1pv +WldsbmFIUVpCRytrWTJGc2RHQmxKSFI1Y0dWNEhHRndjQzVpYzJ0NUxtVnRZbVZrTG1kaGJHeGxjbmtqYVcxaFoyVmxhVzFoWjJXa1kzSmxadGdxV0NVQUFW +VVNJSE90T2RSV3oxVlAvTmZmNXV4K3FEZndiT1hrTFJtOEFRWlZNWkh0NjBQNVpITnBlbVVhQUFiZ20yVWtkSGx3WldSaWJHOWlhRzFwYldWVWVYQmxhbWx0 +WVdkbEwycHdaV2RyWVhOd1pXTjBVbUYwYVcraVpYZHBaSFJvR1FNZ1ptaGxhV2RvZEJrRWJtcTd1cjdvb2dzMnoifSwicm9vdCI6eyJjaWQiOiJiYWZ5cmVp +ZGNrdG83bTdrdGRpMnozdGhmNDRpZWRtbzI1emxweW90amI1emo1NmZkdTZvZWh5eWh0ZSIsInVyaSI6ImF0Oi8vZGlkOnBsYzp4NGc0bGF4a21zcmN6d3Zu +dmJiZ3NtN2cvYXBwLmJza3kuZmVlZC5wb3N0LzNtcTd1cjdvb2dzMnoifX0sInRleHQiOiJXZSBuZWVkIEJPTEQgcmlnaHQgbm93LiJ9LCJjaWQiOiJiYWZ5 +cmVpaGt0NjZ2bHZxdjJrdmllNDU1YWNmemJnaGJxNjd1Z3lsa29hYWRweXMyMmR2NXFoa2x1YSIsInJlY29yZF9jYm9yIjoicFdSMFpYaDBkMWRsSUc1bFpX +UWdRazlNUkNCeWFXZG9kQ0J1YjNjdVpTUjBlWEJsY21Gd2NDNWljMnQ1TG1abFpXUXVjRzl6ZEdWc1lXNW5jNEZpWlc1bGNtVndiSG1pWkhKdmIzU2lZMk5w +WkhnN1ltRm1lWEpsYVdSamEzUnZOMjAzYTNSa2FUSjZNM1JvWmpRMGFXVmtiVzh5Tlhwc2NIbHZkR3BpTlhwcU5UWm1aSFUyYjJWb2VYbG9kR1ZqZFhKcGVF +WmhkRG92TDJScFpEcHdiR002ZURSbk5HeGhlR3R0YzNKamVuZDJiblppWW1kemJUZG5MMkZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkQzh6YlhFM2RYSTNiMjlu +Y3pKNlpuQmhjbVZ1ZEtKalkybGtlRHRpWVdaNWNtVnBaR05yZEc4M2JUZHJkR1JwTW5vemRHaG1ORFJwWldSdGJ6STFlbXh3ZVc5MGFtSTFlbW8xTm1aa2RU +WnZaV2g1ZVdoMFpXTjFjbWw0Um1GME9pOHZaR2xrT25Cc1l6cDROR2MwYkdGNGEyMXpjbU42ZDNadWRtSmlaM050TjJjdllYQndMbUp6YTNrdVptVmxaQzV3 +YjNOMEx6TnRjVGQxY2pkdmIyZHpNbnBwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0xT2pBMkxqUTVOVm89In19eyJkaWQiOiJkaWQ6cGxj +OnR0Mm1pZDN3aXkzZWxkemZpM2NsdHllaCIsInRpbWVfdXMiOjE3ODM2MTUwMTQ4MjY5OTQsImN1cnNvciI6MjI1ODI4MDUxMTQsImtpbmQiOiJjb21taXQi +LCJzZXEiOjIyNTgyODA1MTE0LCJjb21taXQiOnsicmV2IjoiM21xYTJ4cHZvMnkyYyIsIm9wZXJhdGlvbiI6ImRlbGV0ZSIsIkhsd1pYZ2JZWEJ3TG1KemEz +a3VjbWxqYUhSbGVIUXVabUZqWlhRamRHRm5vbVZwYm1SbGVLSm5ZbmwwWlVWdVpCaldhV0o1ZEdWVGRHRnlkQmpGYUdabFlYUjFjbVZ6Z2FKamRHRm5jRk4x +Y0hCdmNuUkpibVJwWlVacGJHMWxKSFI1Y0dWNEcyRndjQzVpYzJ0NUxuSnBZMmgwWlhoMExtWmhZMlYwSTNSaFo2SmxhVzVrWlhpaVoySjVkR1ZGYm1RWTRt +bGllWFJsVTNSaGNuUVkxMmhtWldGMGRYSmxjNEdpWTNSaFoycEdhV3h0YldGcmFXNW5aU1IwZVhCbGVCdGhjSEF1WW5OcmVTNXlhV05vZEdWNGRDNW1ZV05s +ZENOMFlXZWlaV2x1WkdWNG9tZGllWFJsUlc1a0dPMXBZbmwwWlZOMFlYSjBHT05vWm1WaGRIVnlaWE9Cb21OMFlXZHBSbWxzYlcxaGEyVnlaU1IwZVhCbGVC +dGhjSEF1WW5OcmVTNXlhV05vZEdWNGRDNW1ZV05sZENOMFlXZHBZM0psWVhSbFpFRjBlQmd5TURJMkxUQTNMVEE1VkRFMk9qTTRPakEzTGpnNE5sbz0ifX17 +ImRpZCI6ImRpZDpwbGM6eTZsdXNkbGlkZm15ZXlqaGQybGVhaXRtIiwidGltZV91cyI6MTc4MzYxNTA3ODUzMzk5OSwiY3Vyc29yIjoyMjU4MjgzNjg1Nywi +a2luZCI6ImNvbW1pdCIsInNlcSI6MjI1ODI4MzY4NTcsImNvbW1pdCI6eyJyZXYiOiIzbXFhMnptbnB1cTI0Iiwib3BlcmF0aW9uIjoiY3JlYXRlIiwiY29s +bGVjdGlvbiI6ImFwcC5ic2t5LmdyYXBoLmJsb2NrIiwicmtleSI6IjNtcWEyem1uaXp5MjQiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5ncmFwaC5i +bG9jayIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlUMTY6Mzc6NTUuNDg0WiIsInN1YmplY3QiOiJkaWQ6cGxjOmRjNnlwcXNiZTZ6aWNnZjNkNmhrbjVxZSJ9 +LCJjaWQiOiJiYWZ5cmVpY2oyYXhiM2tnYmFoZ2p1amZsa3RrM3JvMmRicWt4cm5uNzRsdHZwa2x2cXd4b3QzaHZkcSIsInJlY29yZF9jYm9yIjoibzJVa2RI +bHdaWFJoY0hBdVluTnJlUzVuY21Gd2FDNWliRzlqYTJkemRXSnFaV04wZUNCa2FXUTZjR3hqT21Sak5ubHdjWE5pWlRaNmFXTm5aak5rTm1ocmJqVnhaV2xq +Y21WaE5tcHpNakpwWTNKbFlYUmxaRUYwZUJneU1ESTJMVEEzTFRBNVZERTJPak0zT2pNNExqVTROVm89In19eyJkaWQiOiJkaWQ6cGxjOmhlNDJtM2o1Y21m +enNiNHpjNnlieTd4dCIsInRpbWVfdXMiOjE3ODM2MTQ5OTY3Mjg2NjksImN1cnNvciI6MjI1ODI3OTY1OTgsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgy +Nzk2NTk4LCJjb21taXQiOnsicmV2IjoiM21xYTJ4NXgyNmEyZSIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnBv +c3QiLCJya2V5IjoiM21xYTJ3emFtNjIydSIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmZlZWQucG9zdCIsImNyZWF0ZWRBdCI6IjIwMjYtMDctMDlU +MTY6MzY6MzAuOTE1WiIsImVtYmVkIjp7IiR0eXBlIjoiYXBwLmJza3kuZW1iZWQuaW1hZ2VzIiwiaW1hZ2VzIjpbeyJhbHQiOiJFY2hpbmFjZWEgQmzDvHRl +IGltIEdyw7xuZW4uIEFsbGVyZGluZ3MgaXN0IGRpZXNlIEJsw7x0ZSBhbiBpaHJlbiB2aW9sZXR0ZW4gU3BpdHplbiB2ZXJ0cm9ja25ldCBvZGVyIHZlcmJy +YW5udC4iLCJhc3BlY3RSYXRpbyI6eyJoZWlnaHQiOjIwNDgsIndpZHRoIjoxMzY1fSwiaW1hZ2UiOnsiJHR5cGUiOiJibG9iIiwibWltZVR5cGUiOiJpbWFn +ZS9qcGVnIiwicmVmIjp7IiRsaW5rIjoiYmFma3JlaWd3d2tmc2Zwc2s2djNhd3BibDR3ZG5rcmU1Zmt0bzJmc3JvNHZsZ2hrbjd5NnBvemxsbXkifSwic2l6 +ZSI6MTg1MDc4NH19XX0sImZhY2V0cyI6W3siZmVhdHVyZXMiOlt7IiR0eXBlIjoiYXBwLmJza3kucmljaHRleHQuZmFjZXQjdGFnIiwidGFnIjoiYmxvb21z +Y3JvbGxpbmcifV0sImluZGV4Ijp7ImJ5dGVFbmQiOjI3LCJieXRlU3RhcnQiOjEyfX1dLCJsYW5ncyI6WyJkZSJdLCJ0ZXh0IjoiU3RpbGwgYWxpdmVcbiNi +bG9vbXNjcm9sbGluZyJ9LCJjaWQiOiJiYWZ5cmVpZXRkYjRhams0MnJobnQ2Z3ZuYXRrbWF0d2NsdTNiMzRvY3ZsejQ3anFyZ3FrN2Q0NHFubSIsInJlY29y +ZF9jYm9yIjoicG1SMFpYaDBlQnRUZEcydDVMbVpsWldRdWNtVndiM04wTHpOdGNXRXlkbnB3WW5kb01tSmxKSFI1Y0dWeVlYQndMbUp6YTNrdVptVmxaQzVz +YVd0bFozTjFZbXBsWTNTaVkyTnBaSGc3WW1GbWVYSmxhV0ZyTnpRMloyVnZiak5yZG5CblpUVnphMmw1Tm5Sd2MySm5jV1pqYW1odmRITTFhMkV5WjNabGIy +MWxaelUxYjJoMGRIRmpkWEpwZUVaaGREb3ZMMlJwWkRwd2JHTTZaV3BwYUd4a05ITjVkM1oyY1hkbE5qZGpaR3R1TkdweEwyRndjQzVpYzJ0NUxtWmxaV1F1 +Y0c5emRDOHpiWEUzZERKaU56TjZNako1YVdOeVpXRjBaV1JCZEhnWU1qQXlOaTB3Tnkwd09WUXhOam96Tmpvd09TNHdOVGhhIn19eyJkaWQiOiJkaWQ6cGxj +OnQzbmN0eHg2cWZ0cWFoNnhtajYyZGJ0YSIsInRpbWVfdXMiOjE3ODM2MTQ5MzY2NDIyMzksImN1cnNvciI6MjI1ODI3Njc4NzAsImtpbmQiOiJjb21taXQi +LCJzZXEiOjIyNTgyNzY3ODcwLCJjb21taXQiOnsicmV2IjoiM21xYTJ2ZmNzb3AybCIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAu +YnNreS5ncmFwaC5mb2xsb3ciLCJya2V5IjoiM21xYTJ2ZmNwcXgybCIsInJlY29yZCI6eyIkdHlwZSI6ImFwcC5ic2t5LmdyYXBoLmZvbGxvdyIsImNyZWF0 +ZWRBdCI6IjIwMjYtMDctMDlUMTY6MzU6MzYuMTU3WiIsInN1YmplY3QiOiJkaWQ6cGxjOmw2eDVmaGpyMm15YnliMzJwYjdpcnczayJ9LCJjaWQiOiJiYWZ5 +cmVpYWI1NWd4dzN5ZnFwbzJqaXh6bnZoZzU2aGY0bWZyM213c2VzY3Bia3lvY3d6ZzIycGt6NCIsInJlY29yZF9jYm9yIjoibzJVa2RIbHdaWFZoY0hBdVlu +TnJlUzVuY21Gd2FDNW1iMnhzYjNkbmMzVmlhbVZqZEhnZ1pHbGtPbkJzWXpwc05uZzFabWhxY2pKdGVXSjVZak15Y0dJM2FYSjNNMnRwWTNKbFlYUmxaRUYw +ZUJneU1ESTJMVEEzTFRBNVZERTJPak0xT2pNMkxqRTFOMW89In19eyJkaWQiOiJkaWQ6cGxjOnh6dWV5NWRldnRvcWluejZtbjM2d2dxMyIsInRpbWVfdXMi +OjE3ODM2MTUwMjI4MTA5MDAsImN1cnNvciI6MjI1ODI4MDg3NjQsImtpbldWa0xuSmxjRzl6ZEdkemRXSnFaV04wb21OamFXUjRPMkpoWm5seVpXbG5lbWxu +Y1dkbWFUSmxkWGN5TjNCMGMzbHBZbmx5YWpOcllYQTFhbkEwZEhObE0yeHdkSGRqZERkak5IYzJNblpwWlc5cFkzVnlhWGhHWVhRNkx5OWthV1E2Y0d4ak9q +SnVjWGhwTm5RMVkycDNNbVkxZFhacGRHOWhOWHBoZUM5aGNIQXVZbk5yZVM1bVpXVmtMbkJ2YzNRdk0yMXhOek50WldOeWFHc3ljMmxqY21WaGRHVmtRWFI0 +R0RJd01qWXRNRGN0TURsVU1UWTZNemM2TVRjdU16a3hXZz09In19eyJkaWQiOiJkaWQ6cGxjOmU2djYybzI1YWhxN2NpNnNqdXZwdGN1dyIsInRpbWVfdXMi +OjE3ODM2MTUwODAyMzA2MjgsImN1cnNvciI6MjI1ODI4Mzc4MTcsImtpbmQiOiJjb21taXQiLCJzZXEiOjIyNTgyODM3ODE3LCJjb21taXQiOnsicmV2Ijoi +M21xYTJ6bzNyYmIycyIsIm9wZXJhdGlvbiI6ImNyZWF0ZSIsImNvbGxlY3Rpb24iOiJhcHAuYnNreS5mZWVkLnJlcG9zdCIsInJrZXkiOiIzbXFhMnpvM2po +YjJzIiwicmVjb3JkIjp7IiR0eXBlIjoiYXBwLmJza3kuZmVlZC5yZXBvc3QiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM3OjU5LjY3MFoiLCJzdWJq +ZWN0Ijp7ImNpZCI6ImJhZnlyZWljemljanZmNHo1Z2IydXhjZG0zYmppcnhjYjZ4eTJib2gybzN3YmZrdGVxZWRoa3RkZXJxIiwidXJpIjoiYXQ6Ly9kaWQ6 +cGxjOnhteG9jdnVlM3ZsdWxxYjJodm8zbnlmaC9hcHAuYnNreS5mZWVkLnBvc3QvM21xNXZ1anJsMzIyZSJ9LCJ2aWEiOnsiY2lkIjoiYmFmeXJlaWF6eG9m +djRtdzVyeHByb25xYjJydzJja3l4dnB6eHJidGY1NG02ZTVpNmF0c2VzdDVhM2EiLCJ1cmkiOiJhdDovL2RpZDpwbGM6M3dxZTZ4d292YnM1NzJoM2w0ZmRp +YWJpL2FwcC5ic2t5LmZlZWQucmVwb3N0LzNtcWEyeTZsbXh0MjcifX0sImNpZCI6ImJhZnlyZWloNXRldWE2dnd3bWVzcnNqeGp0N3c0YmxodmR2cHNlMnpm +cjdtdHBmNGRhY2pjYmlrNGJ5IiwicmVjb3JkX2Nib3IiOiJwR04yYVdHaVkyTnBaSGc3WW1GbWVYSmxhV0Y2R2h5ZERjM2JYUnBiWGxqZFhKcGVFWmhkRG92 +TDJScFpEcHdiR002ZVcxNllYRmhOR2hxYVhwcmMyNTZZMk5rYUdkbGVHSXpMMkZ3Y0M1aWMydDVMbVpsWldRdWNHOXpkQzh6YlhGaE1uWTJaSFJ2TWpKemFX +TnlaV0YwWldSQmRIZ1lNakF5Tmkwd055MHdPVlF4Tmpvek56b3dPQzR6TmpKYSJ9fXsiZGlkIjoiZGlkOnBsYzp6M3Nua2xweDZzN3hsM3VwNWdnNGdqbzQi +LCJ0aW1lX3VzIjoxNzgzNjE0OTY5ODQ0NTI5LCJjdXJzb3IiOjIyNTgyNzgzOTAzLCJraW5kIjoiY29tbWl0Iiwic2VxIjoyMjU4Mjc4MzkwMywiY29tbWl0 +Ijp7InJldiI6IjNtcWEyd2V4anV5MnMiLCJvcGVyYXRpb24iOiJjcmVhdGUiLCJjb2xsZWN0aW9uIjoiYXBwLmJza3kuZmVlZC5saWtlIiwicmtleSI6IjNt +cWEyd2V4YTRpMnMiLCJyZWNvcmQiOnsiJHR5cGUiOiJhcHAuYnNreS5mZWVkLmxpa2UiLCJjcmVhdGVkQXQiOiIyMDI2LTA3LTA5VDE2OjM2OjA5LjQ5Nloi +LCJzdWJqZWN0Ijp7ImNpZCI6ImJhZnlyZWliM2ZxZnk0eWN5eWdxNHA0cW02MnpkN29keW1hbGp6dHZzamRnNXJ0d3BrYXRleXJzM291IiwidXJpIjoiYXQ6 +Ly9kaWQ6cGxjOnh0a3hpM2xoNWd5YWFsN2h5bjJ4bWx6by9hcHAuYnNreS5mZWVkLnBvc3QvM21xN3Bhdm5kYmMyMyJ9fSwiY2lkIjoiYmFmeXJlaWY2NXNk +c2d4Zmt2YXA2NWV3ejVtczJmZnJldmd1anlvNjYyNGNlYzZmdmpodWdjemF3Z2UiLCJyZWNvcmRfY2JvciI6Im8yVWtkSGx3WlhKaGNIQXVZbk5yZVM1bVpX +VmtMbXhwYTJWbmMzVmlhbVZqZEtKalkybGtlRHRpWVdaNWNtVnBZak5tY1daNU5IbGplWGxuY1RSd05IRnROako2WkRkdlpIbHRZV3hxZW5SMmMycGtaelZ5 +ZEhkd2EyRjBaWGx5Y3pOdg== diff --git a/src/internal/homepage.zig b/src/internal/homepage.zig index 11b9a49..17a71ba 100644 --- a/src/internal/homepage.zig +++ b/src/internal/homepage.zig @@ -116,6 +116,7 @@ pub fn render(buf: []u8, args: Args) []const u8 { \\ live \\ GET /subscribe jetstream-compatible json firehose \\ GET /subscribe-v2 + seq cursors, record cbor, #sync + \\ GET /xrpc/network.bsky.jetstream.getZstdDictionary \\ \\ archive \\ GET /xrpc/network.bsky.jetstream.listSegments @@ -181,6 +182,7 @@ pub fn renderHtml(buf: []u8, args: Args) []const u8 { \\

Open the stream

\\
GET/subscribeJetstream-compatible JSON firehose
\\
GET/subscribe-v2Sequence cursors, record CBOR, and sync events
+ \\
GET/xrpc/network.bsky.jetstream.getZstdDictionaryFetch the current v2 compression dictionary
\\
GET/xrpc/network.bsky.jetstream.listSegmentsBrowse sealed archive segments
\\
GET/xrpc/network.bsky.jetstream.getSegmentDownload a sealed segment
\\
GET/xrpc/network.bsky.jetstream.getBlockRead one compressed block
diff --git a/src/internal/server.zig b/src/internal/server.zig index b2b3084..93840f2 100644 --- a/src/internal/server.zig +++ b/src/internal/server.zig @@ -352,6 +352,44 @@ pub const Handler = struct { const v2 = std.mem.eql(u8, path, "/subscribe-v2"); if (!v2 and !std.mem.eql(u8, path, "/subscribe")) return error.NotFound; + var compress = false; + const legacy_compress = if (queryParam(query, "compress")) |v| std.mem.eql(u8, v, "true") else false; + const header_zstd = if (handshake.headers.get("socket-encoding")) |enc| + std.mem.indexOf(u8, enc, "zstd") != null + else + false; + if (v2) { + if (legacy_compress or header_zstd) { + respond(conn, "400 Bad Request", "text/plain", "compress=true / Socket-Encoding: zstd is the /subscribe (v1) opt-in; /subscribe-v2 uses zstdDictionary= with the dictionary from getZstdDictionary\n"); + return error.Close; + } + if (queryParam(query, "zstdDictionary")) |raw| if (raw.len != 0) { + const id = std.fmt.parseInt(u32, raw, 10) catch { + respond(conn, "400 Bad Request", "text/plain", "zstdDictionary must be a positive integer zstd dictionary ID\n"); + return error.Close; + }; + if (id == 0) { + respond(conn, "400 Bad Request", "text/plain", "zstdDictionary must be a positive integer zstd dictionary ID\n"); + return error.Close; + } + if (id != zstd.v2_dictionary_id) { + var buf: [224]u8 = undefined; + const body = std.fmt.bufPrint(&buf, "unknown zstd dictionary id {d}; current dictionary id is {d} (fetch it via getZstdDictionary and reconnect)\n", .{ id, zstd.v2_dictionary_id }) catch unreachable; + respond(conn, "400 Bad Request", "text/plain", body); + return error.Close; + } + compress = true; + }; + } else { + compress = legacy_compress or header_zstd; + if (compress) if (handshake.headers.get("sec-websocket-extensions")) |extensions| { + if (offersPerMessageDeflate(extensions)) { + respond(conn, "400 Bad Request", "text/plain", "choose one compression scheme: custom zstd (compress=true / Socket-Encoding: zstd) or RFC 7692 permessage-deflate, not both\n"); + return error.Close; + } + }; + } + var filter = filter_mod.Filter.parseQuery(hub.allocator, query) catch |err| { log.debug("subscribe: invalid options: {s}", .{@errorName(err)}); return error.InvalidRequest; @@ -378,16 +416,6 @@ pub const Handler = struct { else false; - // v1 zstd opt-in: compress=true or Socket-Encoding: zstd - var compress = if (queryParam(query, "compress")) |v| std.mem.eql(u8, v, "true") else false; - if (handshake.headers.get("socket-encoding")) |enc| { - if (std.mem.eql(u8, enc, "zstd")) compress = true; - } - // The custom zstd message format and RFC 7692 are mutually exclusive: - // accepting both makes the wire ambiguous and can double-compress. - if (compress) if (handshake.headers.get("sec-websocket-extensions")) |extensions| { - if (offersPerMessageDeflate(extensions)) return error.InvalidRequest; - }; try conn.writeTimeout(frame_write_timeout_ms); return .{ @@ -418,7 +446,10 @@ pub const Handler = struct { const start_idx = plan.start_idx orelse hub.tail.publishedTip(); var compressor: ?zstd.DictCompressor = if (self.compress) - try zstd.DictCompressor.init(zstd.v1_dictionary) + if (self.v2) + try zstd.DictCompressor.initLevel(&zstd.v2_dictionary, 1) + else + try zstd.DictCompressor.init(zstd.v1_dictionary) else null; errdefer if (compressor) |*comp| comp.deinit(); @@ -611,7 +642,8 @@ pub const Handler = struct { // the homepage stays up during bootstrap too (it says so) const import_ops = std.mem.eql(u8, path, "/xrpc/network.bsky.jetstream.importTimestamps") or std.mem.eql(u8, path, "/xrpc/network.bsky.jetstream.getImportStatus"); - const ops_path = std.mem.eql(u8, path, "/healthz") or std.mem.eql(u8, path, "/metrics") or std.mem.eql(u8, path, "/status") or std.mem.eql(u8, path, "/") or import_ops; + const dictionary_path = std.mem.eql(u8, path, "/xrpc/network.bsky.jetstream.getZstdDictionary"); + const ops_path = std.mem.eql(u8, path, "/healthz") or std.mem.eql(u8, path, "/metrics") or std.mem.eql(u8, path, "/status") or std.mem.eql(u8, path, "/") or import_ops or dictionary_path; if (!hub.serving.load(.acquire) and !ops_path) { return respond(conn, "503 Service Unavailable", "text/plain", "bootstrap in progress\n"); } @@ -715,6 +747,24 @@ const XrpcResponder = struct { if (body.len > 0) self.conn.writeFramed(body) catch return; } + pub fn dictionary(self: *XrpcResponder, body: []const u8, id: u32, etag: []const u8, not_modified: bool) void { + var buf: [384]u8 = undefined; + const header = if (not_modified) + std.fmt.bufPrint( + &buf, + "HTTP/1.1 304 Not Modified\r\nETag: {s}\r\nCache-Control: public, max-age=31536000, immutable\r\nX-Zstd-Dictionary-Id: {d}\r\nContent-Length: 0\r\nConnection: close\r\nServer: stream\r\n\r\n", + .{ etag, id }, + ) catch return + else + std.fmt.bufPrint( + &buf, + "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {d}\r\nETag: {s}\r\nCache-Control: public, max-age=31536000, immutable\r\nX-Zstd-Dictionary-Id: {d}\r\nConnection: close\r\nServer: stream\r\n\r\n", + .{ body.len, etag, id }, + ) catch return; + self.conn.writeFramed(header) catch return; + if (!not_modified) self.conn.writeFramed(body) catch return; + } + pub fn partial(self: *XrpcResponder, body: []const u8, etag_hex: []const u8, start: u64, end: u64, total: u64) void { var buf: [400]u8 = undefined; const header = std.fmt.bufPrint( diff --git a/src/internal/xrpcapi.zig b/src/internal/xrpcapi.zig index 65ff980..6ffbb25 100644 --- a/src/internal/xrpcapi.zig +++ b/src/internal/xrpcapi.zig @@ -16,6 +16,7 @@ const segment = @import("segment.zig"); const import_manager = @import("timestamp/manager.zig"); const import_jobs = @import("timestamp/jobs.zig"); const time_format = @import("bootstrap/resync.zig"); +const zstd = @import("zstd.zig"); const Io = std.Io; const Allocator = std.mem.Allocator; @@ -76,7 +77,9 @@ pub const Api = struct { respond.err(405, "InvalidRequest", "queries are GET"); return true; } - if (std.mem.eql(u8, method, "listSegments")) { + if (std.mem.eql(u8, method, "getZstdDictionary")) { + self.getZstdDictionary(respond, query, if_none_match); + } else if (std.mem.eql(u8, method, "listSegments")) { self.listSegments(respond, query); } else if (std.mem.eql(u8, method, "getSegment")) { self.getSegment(respond, query, range_header, if_none_match, if_range); @@ -88,6 +91,21 @@ pub const Api = struct { return true; } + fn getZstdDictionary(_: *Api, respond: anytype, query: []const u8, if_none_match: ?[]const u8) void { + if (queryParam(query, "id")) |raw| { + const parsed = std.fmt.parseInt(i64, raw, 10) catch + return respond.err(400, "InvalidRequest", "id must be an integer zstd dictionary ID"); + if (parsed <= 0 or parsed > std.math.maxInt(u32) or @as(u32, @intCast(parsed)) != zstd.v2_dictionary_id) { + var message: [160]u8 = undefined; + const out = std.fmt.bufPrint(&message, "no dictionary with id {d}; current dictionary id is {d}", .{ parsed, zstd.v2_dictionary_id }) catch unreachable; + return respond.err(404, "DictionaryNotFound", out); + } + } + var etag_buf: [48]u8 = undefined; + const etag = std.fmt.bufPrint(&etag_buf, "\"zstd-dict-{d}\"", .{zstd.v2_dictionary_id}) catch unreachable; + respond.dictionary(&zstd.v2_dictionary, zstd.v2_dictionary_id, etag, if_none_match != null and std.mem.eql(u8, if_none_match.?, etag)); + } + fn importTimestamps(self: *Api, respond: anytype, body: []const u8) void { const manager = self.import orelse return respond.err(503, "ImportNotReady", "timestamp import is not configured"); var parsed = std.json.parseFromSlice(std.json.Value, self.allocator, body, .{}) catch diff --git a/src/internal/zstd.zig b/src/internal/zstd.zig index cb82aca..fccfc08 100644 --- a/src/internal/zstd.zig +++ b/src/internal/zstd.zig @@ -77,9 +77,13 @@ pub const DictCompressor = struct { cctx: *anyopaque, pub fn init(dictionary: []const u8) !DictCompressor { + return initLevel(dictionary, level_default); + } + + pub fn initLevel(dictionary: []const u8, level: c_int) !DictCompressor { const cctx = c.ZSTD_createCCtx() orelse return error.OutOfMemory; errdefer _ = c.ZSTD_freeCCtx(cctx); - if (c.ZSTD_isError(c.ZSTD_CCtx_setParameter(cctx, c.ZSTD_c_compressionLevel, level_default)) != 0) + if (c.ZSTD_isError(c.ZSTD_CCtx_setParameter(cctx, c.ZSTD_c_compressionLevel, level)) != 0) return error.CompressFailed; if (c.ZSTD_isError(c.ZSTD_CCtx_setParameter(cctx, c.ZSTD_c_checksumFlag, 1)) != 0) return error.CompressFailed; @@ -110,6 +114,29 @@ pub const DictCompressor = struct { pub const v1_dictionary = @embedFile("../assets/zstd_dictionary"); +const v2_dictionary_b64 = @embedFile("../assets/zstd_dictionary_v2.b64"); +pub const v2_dictionary = blk: { + @setEvalBranchQuota(200_000); + const decoder = std.base64.standard.decoderWithIgnore("\r\n"); + var decoded: [65_536]u8 = undefined; + const written = decoder.decode(&decoded, v2_dictionary_b64) catch + @compileError("invalid embedded v2 zstd dictionary base64"); + if (written != decoded.len) @compileError("embedded v2 zstd dictionary has the wrong length"); + break :blk decoded; +}; + +pub fn dictionaryId(dictionary: []const u8) !u32 { + if (dictionary.len < 8) return error.InvalidDictionary; + if (std.mem.readInt(u32, dictionary[0..4], .little) != 0xEC30A437) + return error.InvalidDictionary; + const id = std.mem.readInt(u32, dictionary[4..8], .little); + if (id == 0) return error.InvalidDictionary; + return id; +} + +pub const v2_dictionary_id = dictionaryId(&v2_dictionary) catch + @compileError("invalid embedded v2 zstd dictionary header"); + test "dictionary round-trip carries the v1 dict id" { var comp = try DictCompressor.init(v1_dictionary); defer comp.deinit(); @@ -124,3 +151,14 @@ test "dictionary round-trip carries the v1 dict id" { defer std.testing.allocator.free(frame2); try std.testing.expect(frame2.len > 0); } + +test "v2 dictionary is the pinned upstream artifact" { + try std.testing.expectEqual(@as(usize, 65_536), v2_dictionary.len); + try std.testing.expectEqual(@as(u32, 20_260_709), v2_dictionary_id); + try std.testing.expectEqual(@as(u32, 0xEC30A437), std.mem.readInt(u32, v2_dictionary[0..4], .little)); + var digest: [32]u8 = undefined; + std.crypto.hash.sha2.Sha256.hash(&v2_dictionary, &digest, .{}); + var expected: [32]u8 = undefined; + _ = try std.fmt.hexToBytes(&expected, "738b9917d6fbdf5eb51eb90c46adbdb2c127e4ae4df7ca78a81c2e1666205ca2"); + try std.testing.expectEqualSlices(u8, &expected, &digest); +} -- 2.51.2