From 6eca991a7a0a1b72b1c5b922e22045cb34ddfdeb Mon Sep 17 00:00:00 2001 From: fenleon Date: Fri, 9 Oct 2026 08:42:30 +0200 Subject: [PATCH] Sign-model fresh-input divergence closed: P region is input-dependent (rev 33) Two session-20-frozen constants falsified on fresh live inputs: - staging i==10 ecx2 = perm2u[st[0x6fa2]] (was frozen perm2u[0x40]) - the P region (state+0x6898, 7x256): five of seven tables are parameterized on five body-derived byte-XOR pairs by the SSE builder at 0x17a1381-0x17a20b5 (tables 2/5 constant). The builder's instruction stream is serialized into generated NacPTable.kt (1833 ints + 46 const vectors) and re-executed lane-wise, byte-exact vs the emulated builder on fresh + random + s20 states. NacSign re-ported with every body-derived region computed: u32tab/nacMasksFlags (12-step barrett chain, full 128-bit product), mapKey cursor0, dynamic N, base-7 0x6fd8 selectors, region6f98(state) (tsel6f98 span, 4 tables strided 0xf0), masks/flags at 0x6fe8/0x6fec, scatterMutated & ~masks, cipher RC = state 0x25d8 words. The four former state-embedded constants (region6f98/ sel6fd8/maskC68/pTable) dropped from NacSignTablesData. Verified: fresh live sig16 307d7151... and the full fresh 517-B stamp byte-exact vs the live capture; session-20 stamp still byte-exact; sig_hand.py verify 20/20. 209 registration tests green (vectors regenerated). Spec -> rev 33. Method + dumps: registration/dev/clearadi/captures/NAC-NOTES.md (gitignored). --- docs/imessage-protocol-spec.md | 3 +- .../fenn/imessage/registration/NacPTable.kt | 136 +++++++++ .../dev/fenn/imessage/registration/NacSign.kt | 219 +++++++++----- .../imessage/registration/NacSignTables.kt | 54 ++-- .../registration/NacSignTablesData.kt | 280 +++++++++--------- .../fenn/imessage/registration/NacSignTest.kt | 19 +- .../registration/NacValidationTest.kt | 2 +- 7 files changed, 451 insertions(+), 262 deletions(-) create mode 100644 registration/src/main/kotlin/dev/fenn/imessage/registration/NacPTable.kt diff --git a/docs/imessage-protocol-spec.md b/docs/imessage-protocol-spec.md index 3fd87c1..ed1a6cf 100644 --- a/docs/imessage-protocol-spec.md +++ b/docs/imessage-protocol-spec.md @@ -21,7 +21,7 @@ - Current shipped flow (OpenBubbles, 2026): the Mac-side helper (`Mac-Hardware-Info` 1.2.0, notarized) only *reads* the machine identifiers — serial, board ID, model, etc. — via public IORegistry/sysctl APIs (docs: "High Sierra and above", no upper macOS version bound) and exports them as a shareable code (≤ 20 users per code, optional one-time-use/48-hour mode); it never invokes an Apple private framework [OB-MHI], [OB-FAQ]. The client then performs the three-step exchange above itself, in software, keyed with those identifiers and paired with an Apple-Account login — the [JJ] emulation path with an official identifier-export helper in front of it. `TODO(capture):` **C56** — the client-side generation procedure behind the three-step exchange: what the client computes with the `id-initialize-validation` session info (the key-establishment math and blob assembly), how it interacts with the Apple-Account/GSA login and the anisette header set (C6) at activation time, and which pieces are fixed protocol constants vs per-account/per-session state. — 2026-09-10: steps 1–2 of C56 are recorded (bullet above); step 3 — key establishment + signing — is closed source: the public OpenAbsinthe-Stub repo is an official mock whose methods are stubs (its README states the real repository is closed source), so the spec records only the API contract: context creation consumes the certificate chain + hardware configuration and outputs the session-info-request blob; key establishment consumes the server response; signing produces the final blob with no further inputs (all state retained in the context) [RP:macos.rs], [RP:activation.rs], [RP:auth.rs], [OA]. Remaining: wire-verification of the blob against one live activation; the enc-variant derivation rides C57. — 2026-09-11 (rev 14 extraction): the five obfuscation labels are now MAPPED to their fields (previously only listed together): serial → `Gq3489ugfi`, platform UUID → `Fyp98tpgj`, root-disk UUID → `kbjfrfpoJU`, ROM → `oycqAZloTNDm`, MLB → `abKPld1EcMni` [OA:nac.rs]; the derivation producing each `_enc` byte variant is still closed source. The hardware-configuration field set is recorded in full: product name (Apple product-type form, e.g. `Macmini9,1`), MAC address (exactly 6 raw bytes), platform serial, platform UUID, root-disk UUID, board ID, OS build number, ROM (raw bytes), MLB, plus the five `_enc` raw-byte variants [OA:nac.rs]. Step 3's closure is confirmed at the source level: the crate holding the key-establishment math ships as a closed-source stub whose mock methods panic; only the API contract is observable [OA:README.md], [OA:nac.rs]. - The helper's export-code format (2026-09-11, rev 15 — **C58 closed** by facts-only extraction from the helper's public upstream repo, which is unlicensed — facts only): the payload is a 4-byte ASCII magic `OABS`, a one-byte flag (1 = "prevent sharing" mode, 0 otherwise), then a raw protobuf message (no length prefix; protobuf starts at offset 5). Protobuf field map: outer — 1 nested identifier message, 2 macOS product version (sysctl `kern.osproductversion`), 3 protocol version (hardcoded `1640`), 4 device id (the IOPlatformUUID again), 5 a hardcoded iCloudHelper user-agent string, 6 a hardcoded AOSKit version string; nested identifier message — 1 product name (e.g. `MacBookPro18,3`), 2 MAC address (6 raw bytes), 3 platform serial, 4 platform UUID, 5 root-disk UUID, 6 board ID (Apple Silicon: literal prefix `Mac-` + lowercase hex of the device-tree board-id bytes), 7 OS build number (sysctl `kern.osversion`), 8/9/10/12/14 the five `_enc` obfuscated blobs read from the `IOPower:/` registry under Apple's key names (`Gq3489ugfi` serial, `Fyp98tpgj` platform UUID, `kbjfrfpoJU` root-disk UUID, `oycqAZloTNDm` ROM, `abKPld1EcMni` MLB — matching §1.1's label mapping), 11 ROM (Intel: the device-tree options ROM value; Apple Silicon: last 6 bytes of SHA-256 of `/chosen` `unique-chip-id`), 13 MLB string. Two delivery modes: plain = standard base64 of the payload (clipboard text, or the raw payload bytes as a QR code at medium error correction); restricted = AES-256-CBC/PKCS7 over the payload, ciphertext prefixed with ASCII `Salted__` + 8-byte random salt (legacy OpenSSL `enc` container), key/IV derived by the legacy EVP_BytesToKey KDF (repeated MD5 of previous-hash ‖ password ‖ salt to 48 bytes: first 32 = key, next 16 = IV) keyed by a human activation code (`MB` + 4×4 chars from the alphabet `ABCDEFGHJKLMNPQRSTUVWXYZ123456789`), then base64. The restricted mode additionally uploads the blob (JSON `data` + `id` = lowercase hex SHA-256 of the activation code) to the vendor's server (`hw.openbubbles.app/code`) — the ≤20-user/one-time/48-hour mechanics live SERVER-side; nothing is embedded in the payload (no checksum, signature, compression, or expiry). No public parser exists (the client apps are closed-source); the construction above is the parse specification [MHG:ViewController.swift], [MHG:HwIdentifiers.swift], [MHG:mac_hw_info.pb.swift]. - The validation blob is submitted as the `validation-data` field of the IDS register body and, base64, in the `X-Mme-Nas-Qualify` header of the iCloud account login [RP:ids/user.rs], [RP:auth.rs]. `TODO(capture):` C5 — exact byte shape of the blob a genuine Mac produces, and the current exchange over the two validation bag URLs. — 2026-10-04 (rev 26, live): **REPLAY GUARD — one mint = one device record.** Apple keys a validation blob's consumption server-side: re-submitting an already-consumed blob at the sign-in/register pair answers HTTP 409, which is a REPLAY refusal, NOT a blob rejection — a fresh blob under the same device identity succeeds where the reused one failed, and a captured blob of external provenance succeeds outright (session 17: a captured stamp replaced the local mint and the 409 vanished). Client consequences: mint or fetch a fresh blob per registration attempt (the 15-minute validity above makes stale reuse doubly fatal), and mint the sign-in's blob AT SIGN-IN TIME — never a login-start blob carried across the 2FA wait. A caller-injected blob from any source (local mint, relay Mac, staged capture) is a legitimate stamp; the injection points are the register body's `validation-data` and the sign-in's `X-Mme-Nas-Qualify` header. -- Hardware-related anisette headers seen in activation flows: `X-Apple-I-SRL-NO` (serial), `X-Apple-I-MLB` (logic-board serial), `X-Apple-I-ROM` (hex ROM, lowercase) [RP:relay.rs], [APA:anisette]. `TODO(capture):` C6 — the full anisette header set a current client actually sends, including which optional hardware headers appear. — 2026-09-10: the header-set half of C6 is closed by facts-only extraction: per-request anisette headers `X-Apple-I-Client-Time`, `X-Apple-I-TimeZone`, `X-Apple-Locale`, `X-Apple-I-MD-RINFO`, `X-Mme-Device-Id`, `X-Apple-I-MD` (base64 OTP), `X-Apple-I-MD-M` (base64 machine ID), plus per-platform hardware headers — macOS: `X-Apple-I-MLB`, `X-Apple-I-ROM` (lowercase hex), `X-Apple-I-SRL-NO` [APA:omnisette], [APA:icloud-auth], [RP:relay.rs]. They are produced by an ADI provisioning exchange with gsa.apple.com (start/finish provisioning returning machine tokens), then a local OTP [APA:omnisette]. GSA context (cross-referenced with C6): the Albert activation itself needs NO Apple-Account login — only the FairPlay-signed activation-info plist (§1.2); the GSA login (full Apple-ID password, SRP over gsa.apple.com/grandslam/GsService2, s2k/s2k_fo PBKDF2, 2FA-capable) feeds the delegate logins that yield the IDS `auth-token`/`profile-id` and the PET token [RP:auth.rs], [APA:icloud-auth]. The extraction confirms the validation blob rides base64 in the `X-Mme-Nas-Qualify` header of the iCloud sign-in POST (recorded above) [RP:auth.rs]. — 2026-09-11 (rev 14 extraction round over the anisette crates): the value-format and provisioning halves of C6 are closed. Per-request value forms: `X-Apple-I-Client-Time` = UTC now truncated to whole seconds, RFC 3339/ISO-8601 with the offset suffix replaced by `Z` (provisioning requests send the raw offset form without the Z — a recorded inconsistency between code paths); `X-Apple-I-TimeZone` = literal `UTC` (not the device zone); `X-Apple-Locale` = `en_US` hardcoded (a companion `X-Apple-I-Locale: en_US` variant exists on the browser-style header set); `X-Apple-I-MD-RINFO` = verbatim passthrough of the string returned in the finish-provisioning response; `X-Mme-Device-Id` = lowercase hyphenated UUID string of 16 locally random bytes (`keychain_identifier`); `X-Apple-I-MD-M` = base64 (standard, padded) of the 60-byte `mid`; `X-Apple-I-MD-LU` = lowercase hex (no dashes) SHA-256 over the same 16 bytes (real macOS instead uses AuthKit's local-user UUID) — present in some header sets, omitted in others (disagreement — C57). Header sets are cached 60 s; a fresh OTP is generated per cache miss. The ADI provisioning flow: `GET https://gsa.apple.com/grandslam/GsService2/lookup` → XML plist whose `urls` keys `midStartProvisioning`/`midFinishProvisioning` give the endpoint URLs (never hardcoded); POST to the start URL with an XML plist body of two empty top-level dicts `Header` and `Request` → response `Response` → `spim` (base64); a local session is built from `spim` (+ empty hostuuid, DSID `-2`, flavor `Mac`=1 / `IOS`=3, flavor chosen by whether the client-info string contains `iPhone OS`) yielding `cpim` (base64); POST to the finish URL with `Request` = {`cpim`} → response `Response` → `ptm`, `tk` (both base64) and `X-Apple-I-MD-RINFO`; finishing the session with the decoded `tk`/`ptm` yields the machine state: `client_secret` (32 bytes), `mid` (60 bytes, Apple-issued at provisioning — reused for every OTP until re-provisioning, which happens only on a not-provisioned failure, e.g. ADI error -45061), `metadata` (variable blob). Provisioning HTTP specifics: `Content-Type: application/x-www-form-urlencoded` despite the XML-plist body (intentional), title-cased header names forced, HTTP/1.1, Apple root CA pinned (embedded DER), and a fixed companion header set on all three requests: akd `User-Agent`, `X-Apple-Baa-E: -10000`, `X-Apple-Baa-Avail: 2`, `X-Apple-Baa-UE: AKAuthenticationError:-7066|com.apple.devicecheck.error.baa:-10000`, `X-Apple-Host-Baa-E: -7066`, `X-Apple-Client-App-Name: akd`, `Accept: */*`, `Accept-Language: en-US,en;q=0.9`, plus `X-Apple-I-MD-LU`, `X-Mme-Device-Id`, `X-Mme-Client-Info`, `X-Apple-I-Client-Time` and any caller-supplied hardware headers. State persists as an XML plist with `keychain_identifier` (data) + the provisioned fields (`client_secret`, `mid`, `metadata`, `rinfo`, `flavor`) [APA:omnisette]. CLOSED-SOURCE RESIDUE: the OTP (`X-Apple-I-MD`) and trusted-device 2FA-code derivations live inside a closed-source crate — its public repo is a stub with `todo!()` methods; recorded is only the call contract: inputs (32-byte `client_secret`, 60-byte `mid`, `metadata`, flavor) → raw OTP bytes (base64 into the header) / 32-bit 2FA code [OA-stub], [APA:omnisette]. — rides C57/C56 residue; the seam stays injectable in the code. — 2026-10-07 (rev 27, clean-room RE of the OpenBubbles ADI library — unstripped Linux `.so`, oracle-verified; the derivation is no longer closed residue): the OTP is fully local and pure. `gen = unix_seconds / 30`; dispatch by OTP flavor byte: 1 (IOS) → `gen_otp` (0x17fba60), 0 (Mac) → `gen_otp_ios` (0x1801d90) — the binary's naming is inverted relative to the flavor (a distinct numbering from the §1.1 session flavor `Mac`=1/`IOS`=3). Cipher inputs: `one` = the machine's `client_info` (required ≥ 0x190 B IOS / ≥ 0xd0 B Mac, length-checked) and `two` = the 32-byte `mid`; output 16 bytes. The wire `X-Apple-I-MD` frame is 28 B: `u32be(5)` ‖ `u32be(16)` ‖ sig16 ‖ `u32be(flavor)`. The 2FA code is `SHA-1(sig16 ‖ secret60) mod 1_000_000` over the machine's full 60-byte secret slice (`machine[0x38..0x74]`; two standard SHA-1 blocks — an earlier report's "48-byte" reading is wrong, 0x18013a2/0x18013bb/0x18013ef). Provisioning framing, asm-pinned: `spim` = `field1` u32 BE @0 ‖ payload-length u32 BE @4 ‖ payload @8 (payload must exceed 59 B, 0x17efb33; more than 23 trailing bytes rejected with error 0x41); `cpim` = 9 fields (u32be(32) ‖ `encsec(rng2)` 32 B ‖ u32be(32) ‖ rng1 32 B ‖ 60 B blob = caller-extra ‖ rng3 pad ‖ u64 BE of arg9 = −2 ‖ u32 BE of the byte-swapped LE dword at rng3[8..12] ‖ two 256-bit tail fields fed by `encrypt(session, rng16, data)` + `spim_map_signature` — the tail's exact wire assembly is `TODO(capture)`); `ptm` is lenient (u32 BE then the whole tail — every candidate shape accepted, error 0); finish requires `tk` exactly 16 B (error 0x8, 0x17f1f11), key16 = `encrypt(session, NULL iv, tk)` (0x17f1eac), decrypt block count = payload.size/16 (0x17f2548), yielding the 0x78-byte provisioned struct (+0x00 16 B, +0x10 u64, +0x18 u64, +0x20 16 B, +0x30..0x70 64 B metadata, +0x70 u32, +0x74 u8 flavor — which bytes are `client_secret` vs `mid` vs `metadata` is `TODO(capture)`). Kotlin: `registration` module `ClearAdiOtp`/`ClearAdiProvision`/`ClearAdiFraming`/`ClearAnisetteProvider`, 192 tests green incl. byte-exact oracle vectors. — 2026-10-07 (rev 28, live capture: one real OpenBubbles provisioning run under gdb, `registration/dev/clearadi/captures/WIRE-NOTES.md`; the framer is corrected): `spim` trailing is NOT capped at 23 B — the live spim carries 99 trailing bytes and parses fine (the earlier 0x41 pin was a probe-harness artifact); the trailing is server material the client relays. `cpim` = an OUTER 276-B message `[u32be(5)][iv 16][u32be(160)][encout 160][X 32][u32be(52)][u32be(4)][Y 52]` whose 160-B encrypt plaintext = `u32be(32) ‖ encsec(rng2) ‖ u32be(32) ‖ rng1 ‖ 60 B blob (caller-extra ‖ rng3 pad) ‖ u64 BE arg9 = −2 (live-confirmed) ‖ u32 BE unix-seconds ‖ u32be(1) ‖ 12 B (source TODO)`; the iv is 16 plain RNG bytes — the earlier 'IV assembled from the Spim's trailing fields' reading was actually the thread-RNG pool (words at r14+0x10, cursor at r14+0x110). `spim_map_signature` (0x17fe2a0) args are (rdi = in, rsi = out): the live call signs a constant 16-B block `e955a4f0…` → `f877c30e…`, and NEITHER that signature nor the SHA-256(encout) digest appears anywhere in the captured wire — the §6 'two 256-bit tail fields' reading is falsified. The `[u32be(52)][u32be(4)][Y 52]` group is the spim's trailing[16:76] relayed verbatim; X (32 B) = `TODO(capture)`. `ptm` = `[u32 BE 4][seed 16][u32 BE payloadLen][payload][tail]` (live 503 B: seed = ptm[4:20] feeds decryptPTM as its chain seed via rcx; block count = payloadLen/16 = 28); key16 = `encrypt(session, NULL iv, tk)` confirmed byte-exact against the live call. ProvisionedData = the 0x78-B Rust struct `{metadata: Vec (400 B live = decrypt out[4:404], length u32 BE at out[0]), client_secret = rng2 (32 B), mid = rng3 (60 B), flavor u8 (0x01 on a live Mac run — distinct from the OTP flavor numbering)}`; the finish gate is the decrypt output's **out[408:440] == rng1 echo** (NOT out[0:32]); the OTP-path report's ProvisionedMachine note (mid[32]@+0x18, secret[60]@+0x38) had the two swapped. Kotlin `ClearAdiFraming`/`ClearAnisetteProvider` restructured to the live shapes; 194 tests green. Remaining `TODO(capture)`: the X32 source, the 12-B plaintext tail, trailing[0:16]'s role. — 2026-10-07 (rev 29, continuation capture — two further live provisioning runs, `gdb_prov8/9.gdb`, byte-exact on both): the three remaining cpim TODOs are CLOSED. X = SHA-256(encout ‖ spim_map_signature(trailing[0:16]) ‖ a fixed 24-byte filler constant `3795020c05f77009cbfeaa78a5bcb3175bad60b9deaaaa8d` (.so .rodata) — the digest is written to the wire byte-exact as the `[X 32]` group, so the rev-28 "sig16 and the digest appear nowhere on the wire" note resolves: both are on the wire transitively (sig16 as the hash input, the digest as X). The signature's INPUT is NOT a constant block — the "constant e955a4f0…" seen in the morning runs was that session's trailing[0:16]; the trailing head is server material that differs between provisioning sessions, and the signature model still reproduces the live output exactly. The 12-B plaintext tail = 12 fresh RNG bytes (low bytes of 12 thread-RNG pool words drawn immediately before the IV's 16 — the same construction as the IV, so the framer draws 12). Kotlin: the pinned production seal (`CpimShaTailSeal` — SHA-256 via the platform, sig via the ported `spimMapSignature`) is the provider default; 195 tests green. — 2026-10-08 (rev 30, clean-room RE of the NAC mint — the validation blob "C5" — over the same unstripped Linux `.so`; gdb oracle quadruples first, then python model, then Kotlin; method + findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the mint is local and pure, and every byte of the 517-B validation stamp is now derived EXCEPT one residue (below). The stamp = `0x02 ‖ rand16 (RNG) ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`; blob480 = `tag 0x05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79`, where cert79 is the first 79 B of the ctx cert chain and session250 the 250-B session slice — E2E the full stamp computes byte-exact from (cert79, session250, rng_pad130, body576, rand16). The crypto layers, all byte-exact vs three independent live runs: **pear_aes** — a white-box AES variant (`create_rounds` = AES-128-style expansion with pluggable sbox/rcon; `init_key` = S1-scramble → schedule; `establish_key` = schedule + T-transform of blocks 1–9 only, blocks 0/10 raw; `encrypt_cbc` = whitening + **9 rounds** + final `SE[st9[p]]^rk11` with p=[12,10,4,3,15,5,2,8,14,1,9,7,0,13,11,6]; `decrypt_cbc` = backward rounds with the key xor fused into the table index, final `perm(SDI[st9^rk1])^chain^rk0`); **domergestep2** — the white-box core of `scramble_body` (KP key schedule over 80 B, 4 blocks of the `0x51·m` constant with state[0] xored on EVERY block, final `TC[x]+k`, out = state ⊕ in1; 21/21 live captures); **key_establishment** — the EstablishKeyResponse wire is `tag ‖ key16@0x01 ‖ u32be bodyLen@0x11 ‖ body@0x15 (0x250) ‖ trailing (85 B, unused by the crypto)`. **SignState::sign** (the 16-B OTS signature over the blob): structure fully decoded — scatter → polynomial chain → flag table → u32 permutations → divisor table → key map → keygen → matrix/phases B–F → 16 position rounds → tail (fold chains + threshold cipher + staging + final formula); stages 1–9 are hand-transcribed and byte-exact vs ground truth, the tail's threshold cipher (AES-like, 9 rounds × 30 generator runs) is structurally decoded with 270 checkpointed rounds, and the signature the model produces is byte-exact vs the live stamp. CLOSED (same day, follow-up): the capture-free pure-code transcription of the tail cipher and the pre-init region — the full 517-B stamp now computes byte-exact from (cert79, session250, rng_pad130, body576, rand16) in a pure-Python model (no emulator, no captures; `sig_hand.py verify` 20/20) with the complete constant inventory recorded for the Kotlin port (see WORKLOG session 20). Kotlin: `registration` `PearTablesData`/`PearTables` (generated base64 table image, ClearAdiTablesData pattern), `PearAes`, `NacMerge`, `NacValidation` (`mint` + `keyEstablishment`; sig16 a parameter — no placeholder signature), 206 tests green (synthetic vectors, no Apple bytes). — 2026-10-08 (rev 31, Kotlin port of the sign model — the sig16 residue above is CLOSED): `SignState::sign` is transcribed to `registration` `NacSign` (full pipeline: scatter → u32 flag table → perms → divisor/key map → keygen → matrix/phases B–E → 16 position rounds, then the 30-run tail — RS32/rec0/r70ab init, run-start feedback, soup57/soup80, the 9-round threshold cipher, staging from the generator soup, final formula, chain1 fold), with its .rodata tables embedded as a generated base64 image (`NacSignTablesData`/`NacSignTables`, PearTablesData pattern; the 17-loop byte tables are in-range slices of the T2_BIG span). `NacValidation.mint(cert79, session250, rngPad130, rand16, body576)` now computes the full 517-B stamp including sig16 internally (the sig16-parameter assembly step remains as `mintWithSig`); Kotlin sign == python model on LCG-seeded synthetic vectors (incl. zero-rand16 and zero-blob edges), full-mint e2e byte-exact, 208 tests green. — 2026-10-08 (rev 32, three instrumented live runs of the same OpenBubbles app under gdb — the mint's INPUT mappings (C56-b/c/d/e + cert79) are now wire-pinned, and a live-input divergence in the rev-30/31 sign model is discovered; dumps + method in `registration/dev/clearadi/captures/NAC-NOTES.md` session-21 continuation): the five mint inputs map from the exchange as follows — **C56-b pearKey16** = 16 fresh client RNG bytes created inside `ValidationCtx::new` (rand-crate `[u8;16]` sample; wrapped to the server inside the step-2 request blob, which is why it never appears in the session-info response); **C56-c session250** = the 250-B `HardwareConfig::to_bin` output — the client's hardware-identity serialization (model identifier, serial, platform-UUID + second UUID, board-id `Mac-…`, OS build, MLB — ASCII, len-prefixed), held at ctx+0x20 and NOT a slice of any server response; **C56-d rngPad130** = 130 fresh thread-RNG bytes filling the 0x180-B scramble buffer after `u32be(len) ‖ data` (pad content is irrelevant filler, drawn fresh per mint); **C56-e body576** = the SDAT-mapped decrypt of the session-info response's `body@0x15` (0x250 B) region `[2:578]` — i.e. ctx[0x40:0x280]; and **cert79 is NOT the step-1 certificate** (the rev-30 reading is falsified): it is the first 0x4f bytes of the response's 85-B trailing Vec (ctx+0x00), server material relayed into the stamp — wire-verified ×3 (stamp[438:517] == trailing[0:79]). The step-2 request blob itself is now wire-captured: 338 B = constant header `01 08 4b2c91481d9b7da0` + 328 B per-session material (RSA-OAEP under the step-1 cert's public key + digests, built inside `ValidationCtx::new`, held at ctx+0x2c0) — its exact field map and the HardwareConfig serialization grammar remain `TODO(capture)` (C56-a/C56-c). **Live-input divergence (new residue):** with ALL FOUR `sign::sign` args byte-verified against the captured call (rsi=body576, rdx=rand16, rcx=blob480), the rev-30/31 pure model produces a WRONG sig16 on two independent fresh runs (e.g. `7a9555e5…`/`b2c72389…` vs live `0160f19c…`) while still reproducing the session-20 capture byte-exact — the empirical tail-cipher/initial-carry fit contains an input-dependent path that the session-20 data never exercised; a live mint is blocked on closing this, and the rev-30/31 "byte-exact" claims hold only for the session-20 capture and the synthetic vectors. Kotlin: `NacValidation.keyEstablishmentFull` (payload + trailing), `NacMint` facade updated with the pinned mappings; 209 registration tests green. +- Hardware-related anisette headers seen in activation flows: `X-Apple-I-SRL-NO` (serial), `X-Apple-I-MLB` (logic-board serial), `X-Apple-I-ROM` (hex ROM, lowercase) [RP:relay.rs], [APA:anisette]. `TODO(capture):` C6 — the full anisette header set a current client actually sends, including which optional hardware headers appear. — 2026-09-10: the header-set half of C6 is closed by facts-only extraction: per-request anisette headers `X-Apple-I-Client-Time`, `X-Apple-I-TimeZone`, `X-Apple-Locale`, `X-Apple-I-MD-RINFO`, `X-Mme-Device-Id`, `X-Apple-I-MD` (base64 OTP), `X-Apple-I-MD-M` (base64 machine ID), plus per-platform hardware headers — macOS: `X-Apple-I-MLB`, `X-Apple-I-ROM` (lowercase hex), `X-Apple-I-SRL-NO` [APA:omnisette], [APA:icloud-auth], [RP:relay.rs]. They are produced by an ADI provisioning exchange with gsa.apple.com (start/finish provisioning returning machine tokens), then a local OTP [APA:omnisette]. GSA context (cross-referenced with C6): the Albert activation itself needs NO Apple-Account login — only the FairPlay-signed activation-info plist (§1.2); the GSA login (full Apple-ID password, SRP over gsa.apple.com/grandslam/GsService2, s2k/s2k_fo PBKDF2, 2FA-capable) feeds the delegate logins that yield the IDS `auth-token`/`profile-id` and the PET token [RP:auth.rs], [APA:icloud-auth]. The extraction confirms the validation blob rides base64 in the `X-Mme-Nas-Qualify` header of the iCloud sign-in POST (recorded above) [RP:auth.rs]. — 2026-09-11 (rev 14 extraction round over the anisette crates): the value-format and provisioning halves of C6 are closed. Per-request value forms: `X-Apple-I-Client-Time` = UTC now truncated to whole seconds, RFC 3339/ISO-8601 with the offset suffix replaced by `Z` (provisioning requests send the raw offset form without the Z — a recorded inconsistency between code paths); `X-Apple-I-TimeZone` = literal `UTC` (not the device zone); `X-Apple-Locale` = `en_US` hardcoded (a companion `X-Apple-I-Locale: en_US` variant exists on the browser-style header set); `X-Apple-I-MD-RINFO` = verbatim passthrough of the string returned in the finish-provisioning response; `X-Mme-Device-Id` = lowercase hyphenated UUID string of 16 locally random bytes (`keychain_identifier`); `X-Apple-I-MD-M` = base64 (standard, padded) of the 60-byte `mid`; `X-Apple-I-MD-LU` = lowercase hex (no dashes) SHA-256 over the same 16 bytes (real macOS instead uses AuthKit's local-user UUID) — present in some header sets, omitted in others (disagreement — C57). Header sets are cached 60 s; a fresh OTP is generated per cache miss. The ADI provisioning flow: `GET https://gsa.apple.com/grandslam/GsService2/lookup` → XML plist whose `urls` keys `midStartProvisioning`/`midFinishProvisioning` give the endpoint URLs (never hardcoded); POST to the start URL with an XML plist body of two empty top-level dicts `Header` and `Request` → response `Response` → `spim` (base64); a local session is built from `spim` (+ empty hostuuid, DSID `-2`, flavor `Mac`=1 / `IOS`=3, flavor chosen by whether the client-info string contains `iPhone OS`) yielding `cpim` (base64); POST to the finish URL with `Request` = {`cpim`} → response `Response` → `ptm`, `tk` (both base64) and `X-Apple-I-MD-RINFO`; finishing the session with the decoded `tk`/`ptm` yields the machine state: `client_secret` (32 bytes), `mid` (60 bytes, Apple-issued at provisioning — reused for every OTP until re-provisioning, which happens only on a not-provisioned failure, e.g. ADI error -45061), `metadata` (variable blob). Provisioning HTTP specifics: `Content-Type: application/x-www-form-urlencoded` despite the XML-plist body (intentional), title-cased header names forced, HTTP/1.1, Apple root CA pinned (embedded DER), and a fixed companion header set on all three requests: akd `User-Agent`, `X-Apple-Baa-E: -10000`, `X-Apple-Baa-Avail: 2`, `X-Apple-Baa-UE: AKAuthenticationError:-7066|com.apple.devicecheck.error.baa:-10000`, `X-Apple-Host-Baa-E: -7066`, `X-Apple-Client-App-Name: akd`, `Accept: */*`, `Accept-Language: en-US,en;q=0.9`, plus `X-Apple-I-MD-LU`, `X-Mme-Device-Id`, `X-Mme-Client-Info`, `X-Apple-I-Client-Time` and any caller-supplied hardware headers. State persists as an XML plist with `keychain_identifier` (data) + the provisioned fields (`client_secret`, `mid`, `metadata`, `rinfo`, `flavor`) [APA:omnisette]. CLOSED-SOURCE RESIDUE: the OTP (`X-Apple-I-MD`) and trusted-device 2FA-code derivations live inside a closed-source crate — its public repo is a stub with `todo!()` methods; recorded is only the call contract: inputs (32-byte `client_secret`, 60-byte `mid`, `metadata`, flavor) → raw OTP bytes (base64 into the header) / 32-bit 2FA code [OA-stub], [APA:omnisette]. — rides C57/C56 residue; the seam stays injectable in the code. — 2026-10-07 (rev 27, clean-room RE of the OpenBubbles ADI library — unstripped Linux `.so`, oracle-verified; the derivation is no longer closed residue): the OTP is fully local and pure. `gen = unix_seconds / 30`; dispatch by OTP flavor byte: 1 (IOS) → `gen_otp` (0x17fba60), 0 (Mac) → `gen_otp_ios` (0x1801d90) — the binary's naming is inverted relative to the flavor (a distinct numbering from the §1.1 session flavor `Mac`=1/`IOS`=3). Cipher inputs: `one` = the machine's `client_info` (required ≥ 0x190 B IOS / ≥ 0xd0 B Mac, length-checked) and `two` = the 32-byte `mid`; output 16 bytes. The wire `X-Apple-I-MD` frame is 28 B: `u32be(5)` ‖ `u32be(16)` ‖ sig16 ‖ `u32be(flavor)`. The 2FA code is `SHA-1(sig16 ‖ secret60) mod 1_000_000` over the machine's full 60-byte secret slice (`machine[0x38..0x74]`; two standard SHA-1 blocks — an earlier report's "48-byte" reading is wrong, 0x18013a2/0x18013bb/0x18013ef). Provisioning framing, asm-pinned: `spim` = `field1` u32 BE @0 ‖ payload-length u32 BE @4 ‖ payload @8 (payload must exceed 59 B, 0x17efb33; more than 23 trailing bytes rejected with error 0x41); `cpim` = 9 fields (u32be(32) ‖ `encsec(rng2)` 32 B ‖ u32be(32) ‖ rng1 32 B ‖ 60 B blob = caller-extra ‖ rng3 pad ‖ u64 BE of arg9 = −2 ‖ u32 BE of the byte-swapped LE dword at rng3[8..12] ‖ two 256-bit tail fields fed by `encrypt(session, rng16, data)` + `spim_map_signature` — the tail's exact wire assembly is `TODO(capture)`); `ptm` is lenient (u32 BE then the whole tail — every candidate shape accepted, error 0); finish requires `tk` exactly 16 B (error 0x8, 0x17f1f11), key16 = `encrypt(session, NULL iv, tk)` (0x17f1eac), decrypt block count = payload.size/16 (0x17f2548), yielding the 0x78-byte provisioned struct (+0x00 16 B, +0x10 u64, +0x18 u64, +0x20 16 B, +0x30..0x70 64 B metadata, +0x70 u32, +0x74 u8 flavor — which bytes are `client_secret` vs `mid` vs `metadata` is `TODO(capture)`). Kotlin: `registration` module `ClearAdiOtp`/`ClearAdiProvision`/`ClearAdiFraming`/`ClearAnisetteProvider`, 192 tests green incl. byte-exact oracle vectors. — 2026-10-07 (rev 28, live capture: one real OpenBubbles provisioning run under gdb, `registration/dev/clearadi/captures/WIRE-NOTES.md`; the framer is corrected): `spim` trailing is NOT capped at 23 B — the live spim carries 99 trailing bytes and parses fine (the earlier 0x41 pin was a probe-harness artifact); the trailing is server material the client relays. `cpim` = an OUTER 276-B message `[u32be(5)][iv 16][u32be(160)][encout 160][X 32][u32be(52)][u32be(4)][Y 52]` whose 160-B encrypt plaintext = `u32be(32) ‖ encsec(rng2) ‖ u32be(32) ‖ rng1 ‖ 60 B blob (caller-extra ‖ rng3 pad) ‖ u64 BE arg9 = −2 (live-confirmed) ‖ u32 BE unix-seconds ‖ u32be(1) ‖ 12 B (source TODO)`; the iv is 16 plain RNG bytes — the earlier 'IV assembled from the Spim's trailing fields' reading was actually the thread-RNG pool (words at r14+0x10, cursor at r14+0x110). `spim_map_signature` (0x17fe2a0) args are (rdi = in, rsi = out): the live call signs a constant 16-B block `e955a4f0…` → `f877c30e…`, and NEITHER that signature nor the SHA-256(encout) digest appears anywhere in the captured wire — the §6 'two 256-bit tail fields' reading is falsified. The `[u32be(52)][u32be(4)][Y 52]` group is the spim's trailing[16:76] relayed verbatim; X (32 B) = `TODO(capture)`. `ptm` = `[u32 BE 4][seed 16][u32 BE payloadLen][payload][tail]` (live 503 B: seed = ptm[4:20] feeds decryptPTM as its chain seed via rcx; block count = payloadLen/16 = 28); key16 = `encrypt(session, NULL iv, tk)` confirmed byte-exact against the live call. ProvisionedData = the 0x78-B Rust struct `{metadata: Vec (400 B live = decrypt out[4:404], length u32 BE at out[0]), client_secret = rng2 (32 B), mid = rng3 (60 B), flavor u8 (0x01 on a live Mac run — distinct from the OTP flavor numbering)}`; the finish gate is the decrypt output's **out[408:440] == rng1 echo** (NOT out[0:32]); the OTP-path report's ProvisionedMachine note (mid[32]@+0x18, secret[60]@+0x38) had the two swapped. Kotlin `ClearAdiFraming`/`ClearAnisetteProvider` restructured to the live shapes; 194 tests green. Remaining `TODO(capture)`: the X32 source, the 12-B plaintext tail, trailing[0:16]'s role. — 2026-10-07 (rev 29, continuation capture — two further live provisioning runs, `gdb_prov8/9.gdb`, byte-exact on both): the three remaining cpim TODOs are CLOSED. X = SHA-256(encout ‖ spim_map_signature(trailing[0:16]) ‖ a fixed 24-byte filler constant `3795020c05f77009cbfeaa78a5bcb3175bad60b9deaaaa8d` (.so .rodata) — the digest is written to the wire byte-exact as the `[X 32]` group, so the rev-28 "sig16 and the digest appear nowhere on the wire" note resolves: both are on the wire transitively (sig16 as the hash input, the digest as X). The signature's INPUT is NOT a constant block — the "constant e955a4f0…" seen in the morning runs was that session's trailing[0:16]; the trailing head is server material that differs between provisioning sessions, and the signature model still reproduces the live output exactly. The 12-B plaintext tail = 12 fresh RNG bytes (low bytes of 12 thread-RNG pool words drawn immediately before the IV's 16 — the same construction as the IV, so the framer draws 12). Kotlin: the pinned production seal (`CpimShaTailSeal` — SHA-256 via the platform, sig via the ported `spimMapSignature`) is the provider default; 195 tests green. — 2026-10-08 (rev 30, clean-room RE of the NAC mint — the validation blob "C5" — over the same unstripped Linux `.so`; gdb oracle quadruples first, then python model, then Kotlin; method + findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the mint is local and pure, and every byte of the 517-B validation stamp is now derived EXCEPT one residue (below). The stamp = `0x02 ‖ rand16 (RNG) ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`; blob480 = `tag 0x05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79`, where cert79 is the first 79 B of the ctx cert chain and session250 the 250-B session slice — E2E the full stamp computes byte-exact from (cert79, session250, rng_pad130, body576, rand16). The crypto layers, all byte-exact vs three independent live runs: **pear_aes** — a white-box AES variant (`create_rounds` = AES-128-style expansion with pluggable sbox/rcon; `init_key` = S1-scramble → schedule; `establish_key` = schedule + T-transform of blocks 1–9 only, blocks 0/10 raw; `encrypt_cbc` = whitening + **9 rounds** + final `SE[st9[p]]^rk11` with p=[12,10,4,3,15,5,2,8,14,1,9,7,0,13,11,6]; `decrypt_cbc` = backward rounds with the key xor fused into the table index, final `perm(SDI[st9^rk1])^chain^rk0`); **domergestep2** — the white-box core of `scramble_body` (KP key schedule over 80 B, 4 blocks of the `0x51·m` constant with state[0] xored on EVERY block, final `TC[x]+k`, out = state ⊕ in1; 21/21 live captures); **key_establishment** — the EstablishKeyResponse wire is `tag ‖ key16@0x01 ‖ u32be bodyLen@0x11 ‖ body@0x15 (0x250) ‖ trailing (85 B, unused by the crypto)`. **SignState::sign** (the 16-B OTS signature over the blob): structure fully decoded — scatter → polynomial chain → flag table → u32 permutations → divisor table → key map → keygen → matrix/phases B–F → 16 position rounds → tail (fold chains + threshold cipher + staging + final formula); stages 1–9 are hand-transcribed and byte-exact vs ground truth, the tail's threshold cipher (AES-like, 9 rounds × 30 generator runs) is structurally decoded with 270 checkpointed rounds, and the signature the model produces is byte-exact vs the live stamp. CLOSED (same day, follow-up): the capture-free pure-code transcription of the tail cipher and the pre-init region — the full 517-B stamp now computes byte-exact from (cert79, session250, rng_pad130, body576, rand16) in a pure-Python model (no emulator, no captures; `sig_hand.py verify` 20/20) with the complete constant inventory recorded for the Kotlin port (see WORKLOG session 20). Kotlin: `registration` `PearTablesData`/`PearTables` (generated base64 table image, ClearAdiTablesData pattern), `PearAes`, `NacMerge`, `NacValidation` (`mint` + `keyEstablishment`; sig16 a parameter — no placeholder signature), 206 tests green (synthetic vectors, no Apple bytes). — 2026-10-08 (rev 31, Kotlin port of the sign model — the sig16 residue above is CLOSED): `SignState::sign` is transcribed to `registration` `NacSign` (full pipeline: scatter → u32 flag table → perms → divisor/key map → keygen → matrix/phases B–E → 16 position rounds, then the 30-run tail — RS32/rec0/r70ab init, run-start feedback, soup57/soup80, the 9-round threshold cipher, staging from the generator soup, final formula, chain1 fold), with its .rodata tables embedded as a generated base64 image (`NacSignTablesData`/`NacSignTables`, PearTablesData pattern; the 17-loop byte tables are in-range slices of the T2_BIG span). `NacValidation.mint(cert79, session250, rngPad130, rand16, body576)` now computes the full 517-B stamp including sig16 internally (the sig16-parameter assembly step remains as `mintWithSig`); Kotlin sign == python model on LCG-seeded synthetic vectors (incl. zero-rand16 and zero-blob edges), full-mint e2e byte-exact, 208 tests green. — 2026-10-08 (rev 32, three instrumented live runs of the same OpenBubbles app under gdb — the mint's INPUT mappings (C56-b/c/d/e + cert79) are now wire-pinned, and a live-input divergence in the rev-30/31 sign model is discovered; dumps + method in `registration/dev/clearadi/captures/NAC-NOTES.md` session-21 continuation): the five mint inputs map from the exchange as follows — **C56-b pearKey16** = 16 fresh client RNG bytes created inside `ValidationCtx::new` (rand-crate `[u8;16]` sample; wrapped to the server inside the step-2 request blob, which is why it never appears in the session-info response); **C56-c session250** = the 250-B `HardwareConfig::to_bin` output — the client's hardware-identity serialization (model identifier, serial, platform-UUID + second UUID, board-id `Mac-…`, OS build, MLB — ASCII, len-prefixed), held at ctx+0x20 and NOT a slice of any server response; **C56-d rngPad130** = 130 fresh thread-RNG bytes filling the 0x180-B scramble buffer after `u32be(len) ‖ data` (pad content is irrelevant filler, drawn fresh per mint); **C56-e body576** = the SDAT-mapped decrypt of the session-info response's `body@0x15` (0x250 B) region `[2:578]` — i.e. ctx[0x40:0x280]; and **cert79 is NOT the step-1 certificate** (the rev-30 reading is falsified): it is the first 0x4f bytes of the response's 85-B trailing Vec (ctx+0x00), server material relayed into the stamp — wire-verified ×3 (stamp[438:517] == trailing[0:79]). The step-2 request blob itself is now wire-captured: 338 B = constant header `01 08 4b2c91481d9b7da0` + 328 B per-session material (RSA-OAEP under the step-1 cert's public key + digests, built inside `ValidationCtx::new`, held at ctx+0x2c0) — its exact field map and the HardwareConfig serialization grammar remain `TODO(capture)` (C56-a/C56-c). **Live-input divergence (new residue):** with ALL FOUR `sign::sign` args byte-verified against the captured call (rsi=body576, rdx=rand16, rcx=blob480), the rev-30/31 pure model produces a WRONG sig16 on two independent fresh runs (e.g. `7a9555e5…`/`b2c72389…` vs live `0160f19c…`) while still reproducing the session-20 capture byte-exact — the empirical tail-cipher/initial-carry fit contains an input-dependent path that the session-20 data never exercised; a live mint is blocked on closing this, and the rev-30/31 "byte-exact" claims hold only for the session-20 capture and the synthetic vectors. Kotlin: `NacValidation.keyEstablishmentFull` (payload + trailing), `NacMint` facade updated with the pinned mappings; 209 registration tests green. — 2026-10-09 (rev 33, the sign-model fresh-input divergence is CLOSED — the live-mint blocker from rev 32 is gone; method + dumps in `registration/dev/clearadi/captures/NAC-NOTES.md` session-23 continuation): the divergence was two more session-20-frozen constants inside `SignState::sign`, both found by rebuilding a fresh-input round-state checkpoint harness (`gdb_c56d.gdb`, 270 round dumps in `captures/c56d/`) and diffing stage-by-stage against a unicorn execution of the same input (the emulator reproduces the live sig16 byte-exact, so the fit — not the emulator — was wrong). (1) **staging i==10 ecx2**: the staging maze's i==10 branch multiplies in `perm2u[st[0x6fa2]]` (rsp+0x28, loaded at 0x17a36c0 from state+0x6fa2); the fitted `perm2u[0x40]` was the session-20 snapshot (s20 st[0x6fa2]==0x40 — a no-op there, silently wrong elsewhere). (2) **the P region (state+0x6898, 7×256) is INPUT-DEPENDENT** — the "runtime constant, byte-identical across base/mod/body-flip" reading (rev 30) is falsified: the SSE builder at 0x17a1381-0x17a20b5 parameterizes five of the seven 256-byte tables on five body-derived bytes (`st[0x288a]^st[0x287a]`, `st[0x287f]^st[0x267f]`, `st[0x2683]^st[0x2753]`, `st[0x287d]^st[0x288d]`, `st[0x274b]^st[0x288b]`); tables 2/5 are the only true constants. The builder's instruction stream is serialized and re-executed lane-wise (generated `NacPTable.kt`, 1833 ints + 46 const vectors), verified byte-exact vs the emulated builder on the fresh input, two random states and the session-20 capture. Also pinned while re-diffing: the region-0x6f98 sel bytes, 0x6fd8 selectors (base-7 digits of `body[0xe0+i]^body[0xf0+i]`), 0x6fe8/0x6fec masks/flags, the scatter N and the map-key cursor are all body-derived (already fixed in-session in the python model; now ported), and the cipher's round "RC constants" are the state's own 0x25d8 words. Verification: the pure model + Kotlin `NacSign` reproduce the FRESH live sig16 `307d7151…` and the FULL fresh 517-B stamp byte-exact (`captures/c56d/fresh_stamp.bin`), the session-20 stamp still byte-exact, `sig_hand.py verify` 20/20; Kotlin: `NacSign` re-ported (region6f98/masks/sel/N/cursor/scatter-mutated/RC now computed; the four former state-embedded constants dropped from `NacSignTablesData`), 209 registration tests green (vectors regenerated), imessage `:server:testDebugUnitTest` green. Remaining before a live attempt: C56-a (request-blob field map) + C56-c (HardwareConfig grammar) — both `TODO(capture)`, C58 OABS parser. ### 1.2 Activation endpoints and certificates @@ -331,6 +331,7 @@ Ordered by value. IDs match the inline `TODO(capture):` markers above. ## Revision history +- Rev 33 (2026-10-09, the sign-model fresh-input divergence CLOSED — the last functional live-mint blocker on the sign path): two session-20-frozen constants inside `SignState::sign` are falsified and replaced by their input-dependent forms — the staging maze's i==10 `ecx2` index (`perm2u[st[0x6fa2]]`, was frozen `perm2u[0x40]`) and the ENTIRE P region state+0x6898 (7×256; five of seven tables are parameterized on five body-derived byte XOR pairs via the SSE builder at 0x17a1381-0x17a20b5 — the "byte-identical across base/mod/body-flip" claim held only because those captures shared a body). The builder stream is serialized into generated Kotlin (`NacPTable`) and re-executed lane-wise, byte-exact vs the emulated builder on fresh + random + s20 states. `NacSign` re-ported with all body-derived regions computed (region6f98/0x6fd8/0x6fe8/0x6fec/N/cursor/RC); fresh live sig16 + full 517-B stamp byte-exact, session-20 still byte-exact; 209 registration tests green, imessage `:server:testDebugUnitTest` green. Live mint still gated on C56-a + C56-c (capture) and C58 (OABS parser). - Rev 32 (2026-10-08, three instrumented live runs — the mint's input mappings C56-b/c/d/e + cert79 are wire-pinned; a live-input divergence in the rev-30/31 sign model is discovered and recorded as a new residue): pearKey16/rngPad130/rand16 = fresh client RNG draws; session250 = the HardwareConfig::to_bin hardware-identity blob; body576 = the established payload's [2:578]; cert79 = the session-info response's trailing[0:79] (NOT the step-1 cert — falsified); step-2 request blob wire-captured (338 B, constant header + OAEP + digests; field map open). Kotlin `keyEstablishmentFull`; 209 tests green. Live mint blocked on: C56-a field map, C56-c grammar, and the sign-model fresh-input divergence. - Rev 31 (2026-10-08, Kotlin port of the sign model — the rev-30 sig16 residue is CLOSED; method in `registration/dev/clearadi/captures/NAC-NOTES.md`, constant inventory in `STAGE7-10-REPORT.md` session 6): `SignState::sign` is transcribed to Kotlin `registration` `NacSign` (full pipeline — scatter → u32 flag table → perms → divisor/key map → keygen → matrix/phases B–E → 16 position rounds, then the 30-run tail: RS32/rec0/r70ab init, run-start feedback, soup57/soup80, the 9-round threshold cipher, staging from the generator soup, final formula, chain1 fold), byte-exact vs the pure-Python model on LCG-seeded synthetic vectors incl. edge inputs, with the .rodata tables embedded as a generated base64 image (`NacSignTablesData`/`NacSignTables`, PearTablesData pattern; the 17-loop byte tables are in-range slices of the T2_BIG span, no duplicate embedding). `NacValidation.mint(cert79, session250, rngPad130, rand16, body576)` now computes the full 517-B stamp including sig16 internally (assembly-with-sig kept as `mintWithSig`); full-mint e2e test byte-exact vs the python-generated vector. 208 tests green (synthetic vectors only, no Apple bytes). - Rev 30 (2026-10-08, clean-room RE of the NAC mint — the validation blob "C5" — gdb oracle + python model + Kotlin; method/findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the 517-B validation stamp is fully derived — stamp = `0x02 ‖ rand16 ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`, blob480 = `05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79` — with pear_aes (white-box AES variant: 9-round CBC, custom whitening/final maps, pluggable sbox schedules, establish_key T-transform on blocks 1–9), domergestep2 (21/21 live captures) and key_establishment (EstablishKeyResponse wire `tag ‖ key16@1 ‖ u32be len@0x11 ‖ body@0x15 ‖ 85-B trailing`) byte-exact vs three independent live runs, and the full stamp computed byte-exact end-to-end from (cert79, session250, rng_pad130, body576, rand16). SignState::sign (the 16-B OTS) is structurally decoded with stages 1–9 hand-verified; the tail threshold cipher is checkpointed (270 rounds) and CLOSED the same day via an empirical fit against those checkpoints — the capture-free pure-Python model now computes the full 517-B stamp byte-exact from its inputs, with the constant inventory recorded for the Kotlin port (the Kotlin signature port is the next step). Kotlin `PearTables`/`PearAes`/`NacMerge`/`NacValidation`; 206 tests green. diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacPTable.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacPTable.kt new file mode 100644 index 0000000..6a7f8ee --- /dev/null +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacPTable.kt @@ -0,0 +1,136 @@ +package dev.fenn.imessage.registration + +/** + * GENERATED FILE — regenerate with /tmp/clearadi-re/gen_p_table.py (session 23); do not + * hand-edit. Byte-serialised instruction stream of the P-table SSE builder + * (state+0x6898, 7x256 bytes) inside SignState::sign at 0x17a1381-0x17a20b5, + * plus the 46 16-byte .rodata const vectors it consumes. The P region is + * INPUT-DEPENDENT: five body-derived bytes (st[a]^st[b] pairs read by the RM/XRM + * ops) select one of 256 variants per variable table — the old frozen pTable + * was the session-20 snapshot, falsified on fresh inputs 2026-10-08. + * + * Verified: the serialised program reproduces the unicorn-executed builder + * byte-exact on the fresh live input (c56d) and on the session-20 capture + * (NAC-NOTES.md "P region CLOSED"). + */ +internal object NacPTable { + + /** program: little-endian i32 words (opcode + operands), see gen_p_table.py. */ + private val prog: IntArray by lazy { + val b = java.util.Base64.getDecoder().decode(PROG) + IntArray(b.size / 4) { i -> + (b[4 * i].toInt() and 0xff) or ((b[4 * i + 1].toInt() and 0xff) shl 8) or + ((b[4 * i + 2].toInt() and 0xff) shl 16) or (b[4 * i + 3].toInt() shl 24) + } + } + + private val consts: Array by lazy { + val b = java.util.Base64.getDecoder().decode(CONSTS) + Array(b.size / 16) { i -> b.copyOfRange(16 * i, 16 * i + 16) } + } + + private const val PROG = "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" + private const val CONSTS = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8AAQIDBAUGB/j5+vv8/f7/CAgICAgICAgICAgICAgICO7u7u7u7u7u7u7u7u7u7u4gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wAAAgIEBAYGCAgKCgwMDg4QEBISFBQWFhgYGhocHB4eICAiIiQkJiYoKCoqLCwuLjAwMjI0NDY2ODg6Ojw8Pj6wsrS2sLK0tsDCxMbAwsTG0NLU1tDS1Nbg4uTm4OLk5nBydHZwcnR2gIKEhoCChIaQkpSWkJKUlqCipKagoqSmMDI0NjAyNDZAQkRGQEJERlBSVFZQUlRWYGJkZmBiZGbw8vT28PL09gACBAYAAgQGEBIUFhASFBYgIiQmICIkJhAQEBAQEBAQEBAQEBAQEBBxcXFxcXFxcXFxcXFxcXFxAwMDAwMDAwMDAwMDAwMDA/z8/Pz8/Pz8/Pz8/Pz8/Pz4+Pj4+Pj4+Pj4+Pj4+Pj4AAEAAQQFBAUAAQABBAUEBRAREBEUFRQVEBEQERQVFBVAQUBBREVERUBBQEFERURFUFFQUVRVVFVQUVBRVFVUVaakqqiurLKwpqSqqK6ssrAmJCooLiwyMCYkKiguLDIwAAECAwABAgMAAQIDAAECAyAhIiMgISIjICEiIyAhIiNAQUJDQEFCQ0BBQkNAQUJDYGFiY2BhYmNgYWJjYGFiYw==" + + /** Build the 7x256 P region (state+0x6898..0x6f98) for this state. */ + internal fun build(state: ByteArray): ByteArray { + val p = ByteArray(0x700) + val gpr = IntArray(6) + val xmm = Array(16) { IntArray(16) } + fun gr(r: Int): Int = if (r and 8 != 0) gpr[r and 7] and 0xff else gpr[r and 7] + fun sr(r: Int, v: Int) { + if (r and 8 != 0) gpr[r and 7] = (gpr[r and 7] and -256) or (v and 0xff) + else gpr[r and 7] = v + } + var pc = 0 + while (pc < prog.size) { + when (prog[pc]) { + 0 -> { sr(prog[pc + 2], state[prog[pc + 1]].toInt() and 0xff); pc += 3 } + 1 -> { sr(prog[pc + 2], gr(prog[pc + 1])); pc += 3 } + 2 -> { sr(prog[pc + 2], gr(prog[pc + 2]) xor prog[pc + 1]); pc += 3 } + 3 -> { sr(prog[pc + 2], gr(prog[pc + 2]) xor (state[prog[pc + 1]].toInt() and 0xff)); pc += 3 } + 4 -> { + val a = prog[pc + 1]; val b = prog[pc + 2] + sr(b, if (a == b) 0 else gr(b) xor gr(a)); pc += 3 + } + 5 -> { sr(prog[pc + 2], gr(prog[pc + 2]) + prog[pc + 1]); pc += 3 } + 6 -> { sr(prog[pc + 2], gr(prog[pc + 2]) and prog[pc + 1]); pc += 3 } + 7 -> { + val v = gr(prog[pc + 1]) and 0xff + val x = xmm[prog[pc + 2]] + for (i in 1 until 16) x[i] = 0 + x[0] = v; pc += 3 + } + 8 -> { + val s = xmm[prog[pc + 1]]; val d = xmm[prog[pc + 2]] + for (i in 0..7) { d[2 * i] = s[i]; d[2 * i + 1] = s[i] } + pc += 3 + } + 9 -> { + val imm = prog[pc + 1]; val s = xmm[prog[pc + 2]]; val d = xmm[prog[pc + 3]] + val out = s.copyOf() + for (i in 0..3) { + val w = (imm shr (2 * i)) and 3 + out[4 * i] = s[2 * w]; out[4 * i + 1] = s[2 * w + 1] + } + for (i in 0 until 16) d[i] = out[i] + pc += 4 + } + 10 -> { + val imm = prog[pc + 1]; val s = xmm[prog[pc + 2]]; val d = xmm[prog[pc + 3]] + val out = IntArray(16) + for (i in 0..3) { + val w = (imm shr (2 * i)) and 3 + for (k in 0..3) out[4 * i + k] = s[4 * w + k] + } + for (i in 0 until 16) d[i] = out[i] + pc += 4 + } + 11 -> { + val s = xmm[prog[pc + 1]]; val d = xmm[prog[pc + 2]] + for (i in 0 until 16) d[i] = s[i] + pc += 3 + } + 12 -> { + val c = consts[prog[pc + 1]]; val d = xmm[prog[pc + 2]] + for (i in 0 until 16) d[i] = c[i].toInt() and 0xff + pc += 3 + } + in 13..17 -> { + val a = xmm[prog[pc + 2]]; val b = xmm[prog[pc + 1]] + for (i in 0 until 16) a[i] = lane(prog[pc] - 13, a[i], b[i]) + pc += 3 + } + in 18..22 -> { + val c = consts[prog[pc + 1]]; val a = xmm[prog[pc + 2]] + for (i in 0 until 16) a[i] = lane(prog[pc] - 18, a[i], c[i].toInt() and 0xff) + pc += 3 + } + 23 -> { + val s = xmm[prog[pc + 2]] + for (i in 0 until 16) p[prog[pc + 1] + i] = s[i].toByte() + pc += 3 + } + 24 -> { + val off = prog[pc + 1] + gpr[4] + if (off >= 0x6898 && off < 0x6f98) { + val s = xmm[prog[pc + 2]] + for (i in 0 until 16) p[off - 0x6898 + i] = s[i].toByte() + } + pc += 3 + } + 25 -> pc = if (gpr[4] != 0x100) prog[pc + 1] else pc + 2 + else -> error("bad P-builder op ${prog[pc]} at $pc") + } + } + return p + } + + private fun lane(k: Int, x: Int, y: Int): Int = when (k) { + 0 -> x and y + 1 -> x or y + 2 -> x xor y + 3 -> (x + y) and 0xff + else -> (x - y) and 0xff + } +} diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt index 99eeeb9..fd41940 100644 --- a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt @@ -6,8 +6,11 @@ package dev.fenn.imessage.registration * sig_hand.py / sig_init.py / sig_tail.py (NAC-NOTES.md; STAGE7-10-REPORT.md session 6: * e2e verified against the live stamp, 270/270 base + 225/225 mod tail rounds, `sig_hand.py * verify` 20/20). Tables come from [NacSignTables]; state-embedded constants (region 0x6f98, - * 0x6fd8 selectors, 0x6fe8 mask/C68, P table) were runtime constants of the binary, verified - * input- and body-independent. + * 0x6fd8 selectors, 0x6fe8 mask/C68, P table) proved INPUT-DEPENDENT (falsified on fresh live + * inputs, 2026-10-08; NAC-NOTES.md session 23) and are now computed: 0x17e8 u32 flag table + * (12-step barrett chain), 0x6f98 sel bytes ([region6f98]), 0x6fd8 selectors (base-7 digits), + * 0x6fe8 masks / 0x6fec flags ([nacMasksFlags]), the P region 0x6898 ([NacPTable]), the cipher + * round constants (state+0x25d8) and the map-key cursor (body[0x31]^body[0xc1]). * * Pipeline: static state build (stages 1–9: scatter, u32 flag table, perms, divisor, key map, * keygen, matrix copy + phases B–E, 16 position rounds) with the input mapped in (rand16 at @@ -16,8 +19,7 @@ package dev.fenn.imessage.registration * staging from the generator soup, final formula, and the chain1 fold with tmp. sig16 = the 30th * final-formula output. * - * The N constant (scatter size 2571 and the RS-init index modulo) is the model's pinned value — - * byte-faithful to the verified Python. + * The N constant (scatter size and the RS-init index modulo) is body-derived ([scatter]). */ internal object NacSign { @@ -32,10 +34,9 @@ internal object NacSign { var tmp = ByteArray(16) for (run in 0 until 30) { val (rs, r0, r70ab) = rsInit(state, bs.bufs, chain1) - val region = NacSignTables.region6f98 val ts = TailState(rs, r0, r70ab, intArrayOf( - region[4].toInt() and 0xff, region[5].toInt() and 0xff, - region[7].toInt() and 0xff, region[10].toInt() and 0xff)) + state[0x6f98 + 4].toInt() and 0xff, state[0x6f98 + 5].toInt() and 0xff, + state[0x6f98 + 7].toInt() and 0xff, state[0x6f98 + 10].toInt() and 0xff)) runstartFeedback(ts, rs[16], rs[12]) // [rsp+0x80] is re-seeded per run with chain1[10] — no cross-run chaining val s = soup(state, chain1, chain1[10], chain1[7], chain1[4]) @@ -71,24 +72,31 @@ internal object NacSign { /** Static state (0x7888 B) + derived pieces for one sign() call (sig_init.build_state). */ private fun buildState(body: ByteArray, rand16: ByteArray, blob480: ByteArray): BuiltState { - val t = NacSignTables val state = ByteArray(0x7888) - val u32t = u32tab() + val u32t = u32tab(body) val (perm1, perm2) = perms(u32t) for (i in 0..255) putU32le(state, 0x21d8 + 4 * i, perm2[i]) for (i in 0..255) putU32le(state, 0x1dd8 + 4 * i, perm1[i]) - putU64le(state, 0x17e0, N.toLong()) - val kbmap = mapKey(divisor(body)) + val n = scatter(body).first + putU64le(state, 0x17e0, n.toLong()) + val kbmap = mapKey(divisor(body), (body[0x31].toInt() xor body[0xc1].toInt()) and 0xff) kbmap.copyInto(state, 0x1be8) val kg = keygen(body, kbmap) kg.copyInto(state, 0x2678) - phaseBCDE(body, kbmap, u32t, state) - val (n, _, vecA, vecB) = vecABMut(body, u32t) + val (masks, flags) = nacMasksFlags(body) + phaseBCDE(body, kbmap, u32t, flags, state) + val (_, _, vecA, vecB) = vecABMut(body, u32t, masks) rounds(state) - t.region6f98.copyInto(state, 0x6f98) - t.sel6fd8.copyInto(state, 0x6fd8) - t.maskC68.copyInto(state, 0x6fe8) - t.pTable.copyInto(state, 0x6898) + region6f98(state).copyInto(state, 0x6f98) + // state+0x6fd8: base-7 digits of body[0xe0+i]^body[0xf0+i] (0x179e487-0x179e6e3) + for (i in 0..7) { + val x = (body[0xe0 + i].toInt() xor body[0xf0 + i].toInt()) and 0xff + state[0x6fd8 + 2 * i] = (x % 7).toByte() + state[0x6fd8 + 2 * i + 1] = (x / 7 % 7).toByte() + } + putU32le(state, 0x6fe8, masks) + putU32le(state, 0x6fec, flags) + NacPTable.build(state).copyInto(state, 0x6898) rand16.copyInto(state, 0x15f0) blob480.copyInto(state, 0x1600) val bufs = genBufs(state.copyOfRange(0x2678, 0x2678 + 544), vecA) @@ -109,24 +117,63 @@ internal object NacSign { // ------------------------- stage 3: flags u32 table (state+0x17e8) ------ - private val C0 = 0xb4b41272.toInt() - private val CFL = intArrayOf( - 0x89e23c5f.toInt(), 0xc74c4a03.toInt(), 0xb8f43515.toInt(), 0x07297e18, - 0xf2cc1c57.toInt(), 0x292bcf40, 0xe863df66.toInt(), 0x8aa0b814.toInt(), - ) + // barrett reduction for D = 0xffffffff00000005: q = (x * 0x800000028000000d) >> 95 + // over the FULL 128-bit product (a 64-bit wrapping multiply would drop the bits + // above 2^64 that >>95 consumes — BigInteger keeps this exact and cheap). + private val BM = java.math.BigInteger("800000028000000d", 16) + private val D_BI = java.math.BigInteger("ffffffff00000005", 16) + private val MASK64 = java.math.BigInteger("ffffffffffffffff", 16) - private fun u32tab(): IntArray { + /** barrett reduction; see sig_hand.barrett. */ + private fun barrett(x: Long): Long { + val xu = java.math.BigInteger.valueOf(x).and(MASK64) + val q = xu.multiply(BM).shiftRight(95) + return xu.add(q.multiply(D_BI)).and(MASK64).longValueExact() + } + + /** the 12-step square chain seeded by 4 body-byte XORs (0x179de61..). */ + private fun chainSeq(body: ByteArray): LongArray { + val s = (((body[0xea].toInt() xor body[0xfa].toInt()) and 0xff).toLong() shl 24 or + (((body[0xe4].toInt() xor body[0xf4].toInt()) and 0xff).toLong() shl 16) or + (((body[0xed].toInt() xor body[0xfd].toInt()) and 0xff).toLong() shl 8) or + ((body[0xe6].toInt() xor body[0xf6].toInt()) and 0xff).toLong()) + val xs = LongArray(13) + xs[0] = s + for (i in 1..12) { + xs[i] = barrett(xs[i - 1] * xs[i - 1] + 1) + } + return xs + } + + /** stage 3: flags u32 table (state+0x17e8) — INPUT-DEPENDENT (0x179de61-0x179e26a). */ + private fun u32tab(body: ByteArray): IntArray { + val xs = chainSeq(body) + val masks = (((1L shl (xs[3].toInt() and 7)) shl 24) or + ((1L shl (xs[2].toInt() and 7)) shl 16) or + ((1L shl (xs[1].toInt() and 7)) shl 8) or + (1L shl ((body[0xe6].toInt() xor body[0xf6].toInt()) and 7))) + val base = masks xor (xs[12] and 0xffffffffL) val t = IntArray(256) for (b in 0..255) { - var v = C0 + var v = base for (i in 0..7) { - if (b and (1 shl i) != 0) v = v xor CFL[i] + if (b and (1 shl i) != 0) v = v xor (xs[4 + i] and 0xffffffffL) } - t[b] = v + t[b] = v.toInt() } return t } + /** state+0x6fe8 masks / +0x6fec flags — INPUT-DEPENDENT (same chain as [u32tab]). */ + private fun nacMasksFlags(body: ByteArray): Pair { + val xs = chainSeq(body) + val masks = (((1L shl (xs[3].toInt() and 7)) shl 24) or + ((1L shl (xs[2].toInt() and 7)) shl 16) or + ((1L shl (xs[1].toInt() and 7)) shl 8) or + (1L shl ((body[0xe6].toInt() xor body[0xf6].toInt()) and 7))) + return masks.toInt() to (xs[12] and 0xffffffffL).toInt() + } + // ------------- stages 4/5: divisor+map (state+0x1be8) ------------------- private val B4 = intArrayOf(0x00, 0x14, 0x28, 0x46) @@ -161,7 +208,7 @@ internal object NacSign { else -> error("bad key byte ${kb.toString(16)}") } - private fun mapKey(div: ByteArray): ByteArray { + private fun mapKey(div: ByteArray, cursor0: Int): ByteArray { val km = div.copyOf() for (c in 0..10) { var acc = 0 @@ -174,7 +221,7 @@ internal object NacSign { } var k = 0 while (acc > 32) { // exit when acc <= 0x20 - val row = (12 + 5 * k) and 0xf + val row = (cursor0 + 5 * k) and 0xf when (km[11 * row + c].toInt() and 0xff) { 0x01 -> { acc -= 4; km[11 * row + c] = 0x24 } 0x18 -> { acc -= 2; km[11 * row + c] = 0x24 } @@ -241,9 +288,13 @@ internal object NacSign { // ----------- stage 8: matrix copy + phases B..E ------------------------- - private val FLAGS = 0xa4b51a62.toInt() // state+0x6fec constant - - private fun phaseBCDE(body: ByteArray, kbmap: ByteArray, u32t: IntArray, state: ByteArray) { + private fun phaseBCDE( + body: ByteArray, + kbmap: ByteArray, + u32t: IntArray, + flags: Int, + state: ByteArray, + ) { val t = NacSignTables for (j in 0..13) { val src = (t.mtxSrc[j] * 16).toInt() @@ -260,7 +311,7 @@ internal object NacSign { x = x xor ((body[0x1a0 + pos + k].toInt() and 0xff) xor (t.phbT[0x20 * j + ((pos + k) and 0xf)].toInt() and 0xff)) } - putU32le(state, 0x1d98 + 4 * t.phbIdx[j].toInt(), FLAGS xor u32t[x]) + putU32le(state, 0x1d98 + 4 * t.phbIdx[j].toInt(), flags xor u32t[x]) } pos += s } @@ -327,16 +378,19 @@ internal object NacSign { // ----------- stage 9: vecA/vecB + 16 position rounds -------------------- - private val C68 = 0xa4b51a62.toInt() // scatter-mutation index const - private val MUT_MASK = 0xeffef7ef.toInt() - - private fun scatterMutated(body: ByteArray, u32t: IntArray): Pair { + private fun scatterMutated( + body: ByteArray, + u32t: IntArray, + masks: Int, + ): Pair { val (n, scat) = scatter(body) val buf = scat.copyOf() var d = 0xb0 for (i in 0..255) { - val idx = (((u32t[i] xor C0) xor C68).toLong() and MUT_MASK.toLong() and 0xffffffffL) - .rem(n.toLong()).toInt() + // idx = (u32t[i] ^ masks) & ~masks — the frozen (u32t^C0^C68)&MUT_MASK pair was + // the s20 snapshot of this formula (sig_hand.scatter_mutated, session 23) + val idx = ((u32t[i].toLong() xor masks.toLong()) and masks.inv().toLong() and + 0xffffffffL).rem(n.toLong()).toInt() buf[idx] = (d xor 0xb0).toByte() val r10 = (2 * (i + 1)) and 0xff d = (((0xa0 - (r10 and 0x60)) or 0x11) + i) and 0xff @@ -344,9 +398,13 @@ internal object NacSign { return n to buf } - private fun vecABMut(body: ByteArray, u32t: IntArray): Quad { + private fun vecABMut( + body: ByteArray, + u32t: IntArray, + masks: Int, + ): Quad { val t = NacSignTables - val (n, scat) = scatterMutated(body, u32t) + val (n, scat) = scatterMutated(body, u32t, masks) val vecA = ByteArray(n) val vecB = ByteArray(n) for (i in 0 until n) { @@ -389,6 +447,23 @@ internal object NacSign { } } + /** state+0x6f98 sel bytes (producer 0x17a2100-0x17a2387) — INPUT-DEPENDENT. */ + private fun region6f98(state: ByteArray): ByteArray { + val sel = NacSignTables.tsel6f98 + val out = ByteArray(16) + for (j in 0..3) { + val mv = u32At(state, 0x2628 + 4 * j).toLong() and 0xffffffffL + out[4 * j + 0] = sel[(mv % 0xe9).toInt()] + out[4 * j + 1] = sel[0xf0 + (mv % 0xef).toInt()] + out[4 * j + 2] = sel[0x1e0 + (mv % 0xf1).toInt()] + out[4 * j + 3] = sel[0x2e0 + (mv % 0xfb).toInt()] + } + for (i in 0..15) { + out[i] = (out[i].toInt() xor state[0x2668 + i].toInt()).toByte() + } + return out + } + // ----------- 16 generator buffers (sig_init.gen_bufs) ------------------- private fun genBufs(kg: ByteArray, vecA: ByteArray): Array { @@ -420,15 +495,14 @@ internal object NacSign { // ----------- per-run init: RS32, rec0, r70ab (sig_init.rs_init) --------- - private const val N = 2571 - private val MASK_IDX = 0xeffef7ef.toInt() - /** RS byte template: perm1[c] ^ PDE[k] -> masked index -> BUF lookup. */ private fun rsIdxVal(c: Int, k: Int, state: ByteArray, buf: ByteArray): Int { val w = u32At(state, 0x1dd8 + 4 * c) xor u32At(state, 0x1d98 + 4 * k) - // w & MASK_IDX is an unsigned u32 in the model — keep it unsigned here too - var idx = (w.toLong() and MASK_IDX.toLong() and 0xffffffffL) - if (idx >= N) idx %= N + // MASK_IDX was ~masks_s20 (frozen); the general form is w & ~masks (session 23) + val masks = u32At(state, 0x6fe8) + var idx = (w.toLong() and masks.inv().toLong() and 0xffffffffL) + val n = buf.size + if (idx >= n) idx %= n val i = idx.toInt() return ((((i and 0xff) xor 0xf3) + 0x45) and 0xff) xor (buf[i].toInt() and 0xff) xor 0x89 @@ -486,23 +560,22 @@ internal object NacSign { r10b: Int, r11b: Int, ): Pair { - val g = NacSignTables.region6f98 val c = chain1 - val dl = ((c[8] xor 5) + (g[9].toInt().inv() and 0xff) + (g[8].toInt() and 0xff)) and 0xff + val dl = ((c[8] xor 5) + ((state[0x6f98 + 9].toInt().inv() and 0xff)) + ((state[0x6f98 + 8].toInt() and 0xff))) and 0xff var cl = ((dl * 2 + 2).inv() and 0xcc) + dl + 0x9b and 0xff cl = (cl xor c[9]) xor 0x99 var r8b = sp80In - r8b = (r8b - (g[13].toInt() and 0xff)) and 0xff + r8b = (r8b - ((state[0x6f98 + 13].toInt() and 0xff))) and 0xff r8b = (r8b + cl) and 0xff - r8b = r8b xor (g[15].toInt() and 0xff) + r8b = r8b xor ((state[0x6f98 + 15].toInt() and 0xff)) r8b = (r8b + (c[11] xor 0x7f)) and 0xff r8b = (r8b + 0x81) and 0xff - var r11 = ((r11b xor 0xf4) - (g[6].toInt() and 0xff) + (g[1].toInt() and 0xff)) and 0xff + var r11 = ((r11b xor 0xf4) - ((state[0x6f98 + 6].toInt() and 0xff)) + ((state[0x6f98 + 1].toInt() and 0xff))) and 0xff r11 = (r11 xor c[5]) and 0xff var r9 = (c[6] + 0x80) and 0xff - r9 = (r9 - (g[3].toInt() and 0xff)) and 0xff + r9 = (r9 - ((state[0x6f98 + 3].toInt() and 0xff))) and 0xff r9 = (r9 + r11) and 0xff - r9 = r9 xor (g[14].toInt() and 0xff) + r9 = r9 xor ((state[0x6f98 + 14].toInt() and 0xff)) r9 = (r9 + 0x80) and 0xff r9 = (r9 - r10b) and 0xff return r9 to r8b @@ -555,19 +628,6 @@ internal object NacSign { ) } - // round constants (rc-xor at 0x17a347b): (ecx, ebx, eax, edx) per r12. - private val RC = arrayOf( - intArrayOf(0x6db4d78c, 0x39c17123, 0x10000800, 0x7d2b7a3d), - intArrayOf(0x91c9e17b.toInt(), 0x43c27516, 0x8833bd3f.toInt(), 0x2be7e3f8), - intArrayOf(0xc5c95c16.toInt(), 0x3600f2eb, 0x4b150d7f, 0x1e1561a0), - intArrayOf(0x9d272c48.toInt(), 0xff511567.toInt(), 0xf52b2b67.toInt(), 0xc974d62c.toInt()), - intArrayOf(0xc21d8753.toInt(), 0x533fd05b, 0x253d787c, 0xc1481826.toInt()), - intArrayOf(0xd7915485.toInt(), 0xf959e065.toInt(), 0x3e03b158, 0x07d5db45), - intArrayOf(0xfd338a1f.toInt(), 0x8a4a0677.toInt(), 0xf2cc1c47.toInt(), 0x0a536e6c), - intArrayOf(0x935aec40.toInt(), 0x596dbe37, 0x647bccd7, 0x6c2bb938), - intArrayOf(0x6cede063, 0x23361c77, 0xa0cee083.toInt(), 0x4b8b7e10), - ) - /** r14b after mixing: constant per r12; record-window byte offset in the export D formula. */ private val XR14 = intArrayOf(0, 1, 1, 2, 2, 2, 5, 3, 3) @@ -615,10 +675,12 @@ internal object NacSign { val r10 = utab(5, m["bl"]!!) xor utab(4, m["b6"]!!) var ebx = utab(7, m["sp48"]!!) xor utab(6, m["cl3"]!!) var edx = utab(7, m["r13mid"]!!) xor utab(6, m["dil1x"]!!) - ecx = ecx xor ebp xor RC[r12][0] - ebx = ebx xor edi xor RC[r12][1] - eax = eax xor RC[r12][2] - edx = edx xor r10 xor RC[r12][3] + // the 'RC' table was the s20 snapshot of state+0x25d8+16*(8-r12) — input-dependent + val rcBase = 0x25d8 + 16 * (8 - r12) + ecx = ecx xor ebp xor u32At(state, rcBase) + ebx = ebx xor edi xor u32At(state, rcBase + 4) + eax = eax xor u32At(state, rcBase + 8) + edx = edx xor r10 xor u32At(state, rcBase + 12) // export val x14 = XR14[r12] val d = ts.r70ab xor ts.rec[17 * x14 + 16] xor ts.rec[17 * x14 + 8] xor @@ -669,9 +731,6 @@ internal object NacSign { // ----------- staging from the generator soup (sig_hand) ----------------- - private const val MASK6FE8 = 0x10010810 - private const val SP28 = 0x40 - private fun stagingFromSoup( state: ByteArray, vecB: ByteArray, @@ -680,6 +739,7 @@ internal object NacSign { ): ByteArray { val t = NacSignTables val t2 = t.t2Big + val masks = u32At(state, 0x6fe8) // was MASK6FE8 (s20-frozen) val stg = ByteArray(16) for (i in 0..15) { val idxP = (t.t2Sel[i] shr 2).toInt() // phaseD/E u32 index (<= 0xff) @@ -701,9 +761,9 @@ internal object NacSign { else -> { edi = u32At(state, 0x5898 + 4 * rdx); ebp = p2u } } val ecx = r10 xor 0x4b2270b0 - val b0 = MASK6FE8 and edi - val r12v = ecx and MASK6FE8 - val r8v = MASK6FE8 and ebp + val b0 = masks and edi + val r12v = ecx and masks + val r8v = masks and ebp val out: Int if (i == 10) { // al source captured live = st[0x7009] ^ idx (head xor at 0x17a374a) @@ -713,11 +773,12 @@ internal object NacSign { val r10x = u32At(state, 0x5098 + 4 * ebx) val eax = u32At(state, 0x21d8 + 4 * al) xor r10x xor u32At(state, 0x21d8 + 4 * (sp20 and 0xff)) xor r9 xor 0x6dafefff - val ecx2 = u32At(state, 0x21d8 + 4 * SP28) + // rsp+0x28 = st[0x6fa2] (loaded at 0x17a36c0) — was frozen 0x40 + val ecx2 = u32At(state, 0x21d8 + 4 * (state[0x6fa2].toInt() and 0xff)) val edi2 = edi xor ebp xor r10 xor b0 xor r8v xor r12v xor ecx2 xor eax - out = edi2 xor (((eax xor ecx2) xor 0x4b2270b0) and MASK6FE8) + out = edi2 xor (((eax xor ecx2) xor 0x4b2270b0) and masks) } else { - val r15n = MASK6FE8 and (r9 xor 0x268d9f4f) + val r15n = masks and (r9 xor 0x268d9f4f) val edi2 = edi xor r15n val ebp2 = ebp xor r9 xor ecx xor edi2 out = (b0 xor r12v xor ebp2 xor r8v) xor 0x268d9f4f diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt index d476305..2a28392 100644 --- a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt @@ -46,38 +46,40 @@ internal object NacSignTables { val tA: ByteArray by lazy { bytesAt(1, 328, 256) } /** .rodata 0x225420 — 256 B. */ val tC: ByteArray by lazy { bytesAt(1, 584, 256) } + /** .rodata 0x2256b8 — 992 B. */ + val tsel6f98: ByteArray by lazy { bytesAt(1, 840, 992) } /** .rodata 0x225a98 — 512 B. */ - val k1: ByteArray by lazy { bytesAt(1, 840, 512) } + val k1: ByteArray by lazy { bytesAt(1, 1832, 512) } /** .rodata 0x225c98 — 512 B. */ - val k2: ByteArray by lazy { bytesAt(1, 1352, 512) } + val k2: ByteArray by lazy { bytesAt(1, 2344, 512) } /** .rodata 0x225e98 — 512 B. */ - val k3: ByteArray by lazy { bytesAt(1, 1864, 512) } + val k3: ByteArray by lazy { bytesAt(1, 2856, 512) } /** .rodata 0x226098 — 128 B. */ - val phbIdx: LongArray by lazy { longsAt(1, 2376, 128 / 8) } + val phbIdx: LongArray by lazy { longsAt(1, 3368, 128 / 8) } /** .rodata 0x226118 — 512 B. */ - val phbT: ByteArray by lazy { bytesAt(1, 2504, 512) } + val phbT: ByteArray by lazy { bytesAt(1, 3496, 512) } /** .rodata 0x226318 — 56 B. */ - val fin: LongArray by lazy { longsAt(1, 3016, 56 / 8) } + val fin: LongArray by lazy { longsAt(1, 4008, 56 / 8) } /** .rodata 0x22635b — 512 B. */ - val pheT: ByteArray by lazy { bytesAt(1, 3072, 512) } + val pheT: ByteArray by lazy { bytesAt(1, 4064, 512) } /** .rodata 0x226560 — 128 B. */ - val pheIdx: LongArray by lazy { longsAt(1, 3584, 128 / 8) } + val pheIdx: LongArray by lazy { longsAt(1, 4576, 128 / 8) } /** .rodata 0x2265e0 — 4608 B. */ - val tbl9: ByteArray by lazy { bytesAt(1, 3712, 4608) } + val tbl9: ByteArray by lazy { bytesAt(1, 4704, 4608) } /** .rodata 0x2277e0 — 112 B. */ - val mtxSrc: LongArray by lazy { longsAt(1, 8320, 112 / 8) } + val mtxSrc: LongArray by lazy { longsAt(1, 9312, 112 / 8) } /** .rodata 0x227850 — 112 B. */ - val mtxDst: LongArray by lazy { longsAt(1, 8432, 112 / 8) } + val mtxDst: LongArray by lazy { longsAt(1, 9424, 112 / 8) } /** .rodata 0x2278c0 — 18 B. */ - val e16: IntArray by lazy { u16sAt(1, 8544, 18 / 2) } + val e16: IntArray by lazy { u16sAt(1, 9536, 18 / 2) } /** .rodata 0x2278d2 — 18 B. */ - val skip: IntArray by lazy { u16sAt(1, 8562, 18 / 2) } + val skip: IntArray by lazy { u16sAt(1, 9554, 18 / 2) } /** .rodata 0x2278f8 — 128 B. */ - val t1Sel: LongArray by lazy { longsAt(1, 8580, 128 / 8) } + val t1Sel: LongArray by lazy { longsAt(1, 9572, 128 / 8) } /** .rodata 0x227978 — 128 B. */ - val t2Sel: LongArray by lazy { longsAt(1, 8708, 128 / 8) } + val t2Sel: LongArray by lazy { longsAt(1, 9700, 128 / 8) } /** .rodata 0x2279f8 — 40960 B. */ - val t2Big: ByteArray by lazy { bytesAt(1, 8836, 40960) } + val t2Big: ByteArray by lazy { bytesAt(1, 9828, 40960) } /** per-round u32 T-tables (sig_tail.UTAB), 9 rounds x 8 slots x 256. */ val utab: Array> by lazy { Array(9) { r12 -> Array(8) { slot -> @@ -85,24 +87,16 @@ internal object NacSignTables { } } } private val utabOffs = intArrayOf( - 82564, 106116, 55940, 79492, 103044, 52868, 76420, 99972, 115332, 65156, 88708, 112260, 62084, 85636, 109188, 59012, 74372, 97924, 121476, 71300, 94852, 118404, 68228, 91780, 107140, 56964, 80516, 104068, 53892, 77444, 100996, 50820, 66180, 89732, 113284, 63108, 86660, 110212, 60036, 83588, 98948, 122500, 72324, 95876, 119428, 69252, 92804, 116356, 57988, 81540, 105092, 54916, 78468, 102020, 51844, 75396, 90756, 114308, 64132, 87684, 111236, 61060, 84612, 108164, 49796, 73348, 96900, 120452, 70276, 93828, 117380, 67204, + 83556, 107108, 56932, 80484, 104036, 53860, 77412, 100964, 116324, 66148, 89700, 113252, 63076, 86628, 110180, 60004, 75364, 98916, 122468, 72292, 95844, 119396, 69220, 92772, 108132, 57956, 81508, 105060, 54884, 78436, 101988, 51812, 67172, 90724, 114276, 64100, 87652, 111204, 61028, 84580, 99940, 123492, 73316, 96868, 120420, 70244, 93796, 117348, 58980, 82532, 106084, 55908, 79460, 103012, 52836, 76388, 91748, 115300, 65124, 88676, 112228, 62052, 85604, 109156, 50788, 74340, 97892, 121444, 71268, 94820, 118372, 68196, ) /** .rodata 0x243a40 — 136 B. */ - val ts17: LongArray by lazy { longsAt(1, 123524, 136 / 8) } + val ts17: LongArray by lazy { longsAt(1, 124516, 136 / 8) } /** .rodata 0x243ac8 — 136 B. */ - val md17: LongArray by lazy { longsAt(1, 123660, 136 / 8) } + val md17: LongArray by lazy { longsAt(1, 124652, 136 / 8) } /** .rodata 0x243b50 — 256 B. */ - val t243b50: ByteArray by lazy { bytesAt(1, 123796, 256) } + val t243b50: ByteArray by lazy { bytesAt(1, 124788, 256) } /** .rodata 0x243c50 — 256 B. */ - val t243c50: ByteArray by lazy { bytesAt(1, 124052, 256) } + val t243c50: ByteArray by lazy { bytesAt(1, 125044, 256) } /** .rodata 0x243d50 — 256 B. */ - val t243d50: ByteArray by lazy { bytesAt(1, 124308, 256) } - /** embedded constant — 16 B. */ - val region6f98: ByteArray by lazy { bytesAt(1, 124564, 16) } - /** embedded constant — 16 B. */ - val sel6fd8: ByteArray by lazy { bytesAt(1, 124580, 16) } - /** embedded constant — 8 B. */ - val maskC68: ByteArray by lazy { bytesAt(1, 124596, 8) } - /** embedded constant — 1792 B. */ - val pTable: ByteArray by lazy { bytesAt(1, 124604, 1792) } + val t243d50: ByteArray by lazy { bytesAt(1, 125300, 256) } } diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt index c54af3c..cd72a8d 100644 --- a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt @@ -9,159 +9,155 @@ package dev.fenn.imessage.registration * first use; raw dev copies stay under registration/dev/clearadi/ (gitignored) for byte-level * cross-checks. * - * Image layout (126940 bytes, 102 entries): + * Image layout (126100 bytes, 99 entries): tG: vaddr 0x1a10f0, image 0, offset 0, 544 B (b) sel: vaddr 0x2251d8, image 1, offset 0, 72 B (u64) tB: vaddr 0x225220, image 1, offset 72, 256 B (b) tA: vaddr 0x225320, image 1, offset 328, 256 B (b) tC: vaddr 0x225420, image 1, offset 584, 256 B (b) - k1: vaddr 0x225a98, image 1, offset 840, 512 B (b) - k2: vaddr 0x225c98, image 1, offset 1352, 512 B (b) - k3: vaddr 0x225e98, image 1, offset 1864, 512 B (b) - phbIdx: vaddr 0x226098, image 1, offset 2376, 128 B (u64) - phbT: vaddr 0x226118, image 1, offset 2504, 512 B (b) - fin: vaddr 0x226318, image 1, offset 3016, 56 B (u64) - pheT: vaddr 0x22635b, image 1, offset 3072, 512 B (b) - pheIdx: vaddr 0x226560, image 1, offset 3584, 128 B (u64) - tbl9: vaddr 0x2265e0, image 1, offset 3712, 4608 B (b) - mtxSrc: vaddr 0x2277e0, image 1, offset 8320, 112 B (u64) - mtxDst: vaddr 0x227850, image 1, offset 8432, 112 B (u64) - e16: vaddr 0x2278c0, image 1, offset 8544, 18 B (u16) - skip: vaddr 0x2278d2, image 1, offset 8562, 18 B (u16) - t1Sel: vaddr 0x2278f8, image 1, offset 8580, 128 B (u64) - t2Sel: vaddr 0x227978, image 1, offset 8708, 128 B (u64) - t2Big: vaddr 0x2279f8, image 1, offset 8836, 40960 B (b) - utab[8][0]: vaddr 0x2319f8, image 1, offset 49796, 1024 B (u32) - utab[3][7]: vaddr 0x231df8, image 1, offset 50820, 1024 B (u32) - utab[6][6]: vaddr 0x2321f8, image 1, offset 51844, 1024 B (u32) - utab[0][5]: vaddr 0x2325f8, image 1, offset 52868, 1024 B (u32) - utab[3][4]: vaddr 0x2329f8, image 1, offset 53892, 1024 B (u32) - utab[6][3]: vaddr 0x232df8, image 1, offset 54916, 1024 B (u32) - utab[0][2]: vaddr 0x2331f8, image 1, offset 55940, 1024 B (u32) - utab[3][1]: vaddr 0x2335f8, image 1, offset 56964, 1024 B (u32) - utab[6][0]: vaddr 0x2339f8, image 1, offset 57988, 1024 B (u32) - utab[1][7]: vaddr 0x233df8, image 1, offset 59012, 1024 B (u32) - utab[4][6]: vaddr 0x2341f8, image 1, offset 60036, 1024 B (u32) - utab[7][5]: vaddr 0x2345f8, image 1, offset 61060, 1024 B (u32) - utab[1][4]: vaddr 0x2349f8, image 1, offset 62084, 1024 B (u32) - utab[4][3]: vaddr 0x234df8, image 1, offset 63108, 1024 B (u32) - utab[7][2]: vaddr 0x2351f8, image 1, offset 64132, 1024 B (u32) - utab[1][1]: vaddr 0x2355f8, image 1, offset 65156, 1024 B (u32) - utab[4][0]: vaddr 0x2359f8, image 1, offset 66180, 1024 B (u32) - utab[8][7]: vaddr 0x235df8, image 1, offset 67204, 1024 B (u32) - utab[2][6]: vaddr 0x2361f8, image 1, offset 68228, 1024 B (u32) - utab[5][5]: vaddr 0x2365f8, image 1, offset 69252, 1024 B (u32) - utab[8][4]: vaddr 0x2369f8, image 1, offset 70276, 1024 B (u32) - utab[2][3]: vaddr 0x236df8, image 1, offset 71300, 1024 B (u32) - utab[5][2]: vaddr 0x2371f8, image 1, offset 72324, 1024 B (u32) - utab[8][1]: vaddr 0x2375f8, image 1, offset 73348, 1024 B (u32) - utab[2][0]: vaddr 0x2379f8, image 1, offset 74372, 1024 B (u32) - utab[6][7]: vaddr 0x237df8, image 1, offset 75396, 1024 B (u32) - utab[0][6]: vaddr 0x2381f8, image 1, offset 76420, 1024 B (u32) - utab[3][5]: vaddr 0x2385f8, image 1, offset 77444, 1024 B (u32) - utab[6][4]: vaddr 0x2389f8, image 1, offset 78468, 1024 B (u32) - utab[0][3]: vaddr 0x238df8, image 1, offset 79492, 1024 B (u32) - utab[3][2]: vaddr 0x2391f8, image 1, offset 80516, 1024 B (u32) - utab[6][1]: vaddr 0x2395f8, image 1, offset 81540, 1024 B (u32) - utab[0][0]: vaddr 0x2399f8, image 1, offset 82564, 1024 B (u32) - utab[4][7]: vaddr 0x239df8, image 1, offset 83588, 1024 B (u32) - utab[7][6]: vaddr 0x23a1f8, image 1, offset 84612, 1024 B (u32) - utab[1][5]: vaddr 0x23a5f8, image 1, offset 85636, 1024 B (u32) - utab[4][4]: vaddr 0x23a9f8, image 1, offset 86660, 1024 B (u32) - utab[7][3]: vaddr 0x23adf8, image 1, offset 87684, 1024 B (u32) - utab[1][2]: vaddr 0x23b1f8, image 1, offset 88708, 1024 B (u32) - utab[4][1]: vaddr 0x23b5f8, image 1, offset 89732, 1024 B (u32) - utab[7][0]: vaddr 0x23b9f8, image 1, offset 90756, 1024 B (u32) - utab[2][7]: vaddr 0x23bdf8, image 1, offset 91780, 1024 B (u32) - utab[5][6]: vaddr 0x23c1f8, image 1, offset 92804, 1024 B (u32) - utab[8][5]: vaddr 0x23c5f8, image 1, offset 93828, 1024 B (u32) - utab[2][4]: vaddr 0x23c9f8, image 1, offset 94852, 1024 B (u32) - utab[5][3]: vaddr 0x23cdf8, image 1, offset 95876, 1024 B (u32) - utab[8][2]: vaddr 0x23d1f8, image 1, offset 96900, 1024 B (u32) - utab[2][1]: vaddr 0x23d5f8, image 1, offset 97924, 1024 B (u32) - utab[5][0]: vaddr 0x23d9f8, image 1, offset 98948, 1024 B (u32) - utab[0][7]: vaddr 0x23ddf8, image 1, offset 99972, 1024 B (u32) - utab[3][6]: vaddr 0x23e1f8, image 1, offset 100996, 1024 B (u32) - utab[6][5]: vaddr 0x23e5f8, image 1, offset 102020, 1024 B (u32) - utab[0][4]: vaddr 0x23e9f8, image 1, offset 103044, 1024 B (u32) - utab[3][3]: vaddr 0x23edf8, image 1, offset 104068, 1024 B (u32) - utab[6][2]: vaddr 0x23f1f8, image 1, offset 105092, 1024 B (u32) - utab[0][1]: vaddr 0x23f5f8, image 1, offset 106116, 1024 B (u32) - utab[3][0]: vaddr 0x23f9f8, image 1, offset 107140, 1024 B (u32) - utab[7][7]: vaddr 0x23fdf8, image 1, offset 108164, 1024 B (u32) - utab[1][6]: vaddr 0x2401f8, image 1, offset 109188, 1024 B (u32) - utab[4][5]: vaddr 0x2405f8, image 1, offset 110212, 1024 B (u32) - utab[7][4]: vaddr 0x2409f8, image 1, offset 111236, 1024 B (u32) - utab[1][3]: vaddr 0x240df8, image 1, offset 112260, 1024 B (u32) - utab[4][2]: vaddr 0x2411f8, image 1, offset 113284, 1024 B (u32) - utab[7][1]: vaddr 0x2415f8, image 1, offset 114308, 1024 B (u32) - utab[1][0]: vaddr 0x2419f8, image 1, offset 115332, 1024 B (u32) - utab[5][7]: vaddr 0x241df8, image 1, offset 116356, 1024 B (u32) - utab[8][6]: vaddr 0x2421f8, image 1, offset 117380, 1024 B (u32) - utab[2][5]: vaddr 0x2425f8, image 1, offset 118404, 1024 B (u32) - utab[5][4]: vaddr 0x2429f8, image 1, offset 119428, 1024 B (u32) - utab[8][3]: vaddr 0x242df8, image 1, offset 120452, 1024 B (u32) - utab[2][2]: vaddr 0x2431f8, image 1, offset 121476, 1024 B (u32) - utab[5][1]: vaddr 0x2435f8, image 1, offset 122500, 1024 B (u32) - ts17: vaddr 0x243a40, image 1, offset 123524, 136 B (u64) - md17: vaddr 0x243ac8, image 1, offset 123660, 136 B (u64) - t243b50: vaddr 0x243b50, image 1, offset 123796, 256 B (b) - t243c50: vaddr 0x243c50, image 1, offset 124052, 256 B (b) - t243d50: vaddr 0x243d50, image 1, offset 124308, 256 B (b) - region6f98: vaddr embedded, image 1, offset 124564, 16 B (b) - sel6fd8: vaddr embedded, image 1, offset 124580, 16 B (b) - maskC68: vaddr embedded, image 1, offset 124596, 8 B (b) - pTable: vaddr embedded, image 1, offset 124604, 1792 B (b) + tsel6f98: vaddr 0x2256b8, image 1, offset 840, 992 B (b) + k1: vaddr 0x225a98, image 1, offset 1832, 512 B (b) + k2: vaddr 0x225c98, image 1, offset 2344, 512 B (b) + k3: vaddr 0x225e98, image 1, offset 2856, 512 B (b) + phbIdx: vaddr 0x226098, image 1, offset 3368, 128 B (u64) + phbT: vaddr 0x226118, image 1, offset 3496, 512 B (b) + fin: vaddr 0x226318, image 1, offset 4008, 56 B (u64) + pheT: vaddr 0x22635b, image 1, offset 4064, 512 B (b) + pheIdx: vaddr 0x226560, image 1, offset 4576, 128 B (u64) + tbl9: vaddr 0x2265e0, image 1, offset 4704, 4608 B (b) + mtxSrc: vaddr 0x2277e0, image 1, offset 9312, 112 B (u64) + mtxDst: vaddr 0x227850, image 1, offset 9424, 112 B (u64) + e16: vaddr 0x2278c0, image 1, offset 9536, 18 B (u16) + skip: vaddr 0x2278d2, image 1, offset 9554, 18 B (u16) + t1Sel: vaddr 0x2278f8, image 1, offset 9572, 128 B (u64) + t2Sel: vaddr 0x227978, image 1, offset 9700, 128 B (u64) + t2Big: vaddr 0x2279f8, image 1, offset 9828, 40960 B (b) + utab[8][0]: vaddr 0x2319f8, image 1, offset 50788, 1024 B (u32) + utab[3][7]: vaddr 0x231df8, image 1, offset 51812, 1024 B (u32) + utab[6][6]: vaddr 0x2321f8, image 1, offset 52836, 1024 B (u32) + utab[0][5]: vaddr 0x2325f8, image 1, offset 53860, 1024 B (u32) + utab[3][4]: vaddr 0x2329f8, image 1, offset 54884, 1024 B (u32) + utab[6][3]: vaddr 0x232df8, image 1, offset 55908, 1024 B (u32) + utab[0][2]: vaddr 0x2331f8, image 1, offset 56932, 1024 B (u32) + utab[3][1]: vaddr 0x2335f8, image 1, offset 57956, 1024 B (u32) + utab[6][0]: vaddr 0x2339f8, image 1, offset 58980, 1024 B (u32) + utab[1][7]: vaddr 0x233df8, image 1, offset 60004, 1024 B (u32) + utab[4][6]: vaddr 0x2341f8, image 1, offset 61028, 1024 B (u32) + utab[7][5]: vaddr 0x2345f8, image 1, offset 62052, 1024 B (u32) + utab[1][4]: vaddr 0x2349f8, image 1, offset 63076, 1024 B (u32) + utab[4][3]: vaddr 0x234df8, image 1, offset 64100, 1024 B (u32) + utab[7][2]: vaddr 0x2351f8, image 1, offset 65124, 1024 B (u32) + utab[1][1]: vaddr 0x2355f8, image 1, offset 66148, 1024 B (u32) + utab[4][0]: vaddr 0x2359f8, image 1, offset 67172, 1024 B (u32) + utab[8][7]: vaddr 0x235df8, image 1, offset 68196, 1024 B (u32) + utab[2][6]: vaddr 0x2361f8, image 1, offset 69220, 1024 B (u32) + utab[5][5]: vaddr 0x2365f8, image 1, offset 70244, 1024 B (u32) + utab[8][4]: vaddr 0x2369f8, image 1, offset 71268, 1024 B (u32) + utab[2][3]: vaddr 0x236df8, image 1, offset 72292, 1024 B (u32) + utab[5][2]: vaddr 0x2371f8, image 1, offset 73316, 1024 B (u32) + utab[8][1]: vaddr 0x2375f8, image 1, offset 74340, 1024 B (u32) + utab[2][0]: vaddr 0x2379f8, image 1, offset 75364, 1024 B (u32) + utab[6][7]: vaddr 0x237df8, image 1, offset 76388, 1024 B (u32) + utab[0][6]: vaddr 0x2381f8, image 1, offset 77412, 1024 B (u32) + utab[3][5]: vaddr 0x2385f8, image 1, offset 78436, 1024 B (u32) + utab[6][4]: vaddr 0x2389f8, image 1, offset 79460, 1024 B (u32) + utab[0][3]: vaddr 0x238df8, image 1, offset 80484, 1024 B (u32) + utab[3][2]: vaddr 0x2391f8, image 1, offset 81508, 1024 B (u32) + utab[6][1]: vaddr 0x2395f8, image 1, offset 82532, 1024 B (u32) + utab[0][0]: vaddr 0x2399f8, image 1, offset 83556, 1024 B (u32) + utab[4][7]: vaddr 0x239df8, image 1, offset 84580, 1024 B (u32) + utab[7][6]: vaddr 0x23a1f8, image 1, offset 85604, 1024 B (u32) + utab[1][5]: vaddr 0x23a5f8, image 1, offset 86628, 1024 B (u32) + utab[4][4]: vaddr 0x23a9f8, image 1, offset 87652, 1024 B (u32) + utab[7][3]: vaddr 0x23adf8, image 1, offset 88676, 1024 B (u32) + utab[1][2]: vaddr 0x23b1f8, image 1, offset 89700, 1024 B (u32) + utab[4][1]: vaddr 0x23b5f8, image 1, offset 90724, 1024 B (u32) + utab[7][0]: vaddr 0x23b9f8, image 1, offset 91748, 1024 B (u32) + utab[2][7]: vaddr 0x23bdf8, image 1, offset 92772, 1024 B (u32) + utab[5][6]: vaddr 0x23c1f8, image 1, offset 93796, 1024 B (u32) + utab[8][5]: vaddr 0x23c5f8, image 1, offset 94820, 1024 B (u32) + utab[2][4]: vaddr 0x23c9f8, image 1, offset 95844, 1024 B (u32) + utab[5][3]: vaddr 0x23cdf8, image 1, offset 96868, 1024 B (u32) + utab[8][2]: vaddr 0x23d1f8, image 1, offset 97892, 1024 B (u32) + utab[2][1]: vaddr 0x23d5f8, image 1, offset 98916, 1024 B (u32) + utab[5][0]: vaddr 0x23d9f8, image 1, offset 99940, 1024 B (u32) + utab[0][7]: vaddr 0x23ddf8, image 1, offset 100964, 1024 B (u32) + utab[3][6]: vaddr 0x23e1f8, image 1, offset 101988, 1024 B (u32) + utab[6][5]: vaddr 0x23e5f8, image 1, offset 103012, 1024 B (u32) + utab[0][4]: vaddr 0x23e9f8, image 1, offset 104036, 1024 B (u32) + utab[3][3]: vaddr 0x23edf8, image 1, offset 105060, 1024 B (u32) + utab[6][2]: vaddr 0x23f1f8, image 1, offset 106084, 1024 B (u32) + utab[0][1]: vaddr 0x23f5f8, image 1, offset 107108, 1024 B (u32) + utab[3][0]: vaddr 0x23f9f8, image 1, offset 108132, 1024 B (u32) + utab[7][7]: vaddr 0x23fdf8, image 1, offset 109156, 1024 B (u32) + utab[1][6]: vaddr 0x2401f8, image 1, offset 110180, 1024 B (u32) + utab[4][5]: vaddr 0x2405f8, image 1, offset 111204, 1024 B (u32) + utab[7][4]: vaddr 0x2409f8, image 1, offset 112228, 1024 B (u32) + utab[1][3]: vaddr 0x240df8, image 1, offset 113252, 1024 B (u32) + utab[4][2]: vaddr 0x2411f8, image 1, offset 114276, 1024 B (u32) + utab[7][1]: vaddr 0x2415f8, image 1, offset 115300, 1024 B (u32) + utab[1][0]: vaddr 0x2419f8, image 1, offset 116324, 1024 B (u32) + utab[5][7]: vaddr 0x241df8, image 1, offset 117348, 1024 B (u32) + utab[8][6]: vaddr 0x2421f8, image 1, offset 118372, 1024 B (u32) + utab[2][5]: vaddr 0x2425f8, image 1, offset 119396, 1024 B (u32) + utab[5][4]: vaddr 0x2429f8, image 1, offset 120420, 1024 B (u32) + utab[8][3]: vaddr 0x242df8, image 1, offset 121444, 1024 B (u32) + utab[2][2]: vaddr 0x2431f8, image 1, offset 122468, 1024 B (u32) + utab[5][1]: vaddr 0x2435f8, image 1, offset 123492, 1024 B (u32) + ts17: vaddr 0x243a40, image 1, offset 124516, 136 B (u64) + md17: vaddr 0x243ac8, image 1, offset 124652, 136 B (u64) + t243b50: vaddr 0x243b50, image 1, offset 124788, 256 B (b) + t243c50: vaddr 0x243c50, image 1, offset 125044, 256 B (b) + t243d50: vaddr 0x243d50, image 1, offset 125300, 256 B (b) */ internal object NacSignTablesData { /** sign tables image 0, base64, 1 chunk(s) — concatenate in order. */ val signChunks0: List = listOf( "DR0LIQkRGwUVBxkfAxcPEz4ycIJStLaFUbV8EHBjQ9ugtHNOHLikryaCnhJgPJyzaw+alRDZ669c1jbGMZHVAK3X5kPktZaPEzStLAv+PoXwCQTtGdonj5iveg7WJ2F0b0ehTD+DDDNeNOjUfW7hjzAxMjM0NTY3ODlBQkNERUY69J0n7Slocv5MrLcFHwhXIHdoZW4gZXhwZWN0aW5nIEJvZHlXcml0ZUFib3J0ZWQAAAAAAAAAAAQAAAAAAAAA/////w2AAPwBAAB4AQAAuC8x7N8YvCoW+dbt7nTrtqj96AAgMB4wCAYGKoUDAgIJMjU1MTkgY29sbGlzaW9uc1VVVVVVVVVVVVVVVVVVVVVzZW50ZW5jZXRlcm1pbmFsYAsBAHILAQB4CwEAfwsBAIAIAQCeCAEApwgBAK8IAQByaW5nX2NpcmNsZV90eXBlaWNlU2Vjb25kYXJ5QXV0aERpZCBjaXJjbGUgc3RlcCAta2V5AAAAAAAAAAAAAAAATG9nU3BlY2lmaWNhdGlvbkFzc2V0R2V0UmVzcG9uc2VkAAAAAAAAAAAAAAAAAAAATm8gcmVjb3JkIGZvdW5kP0Nsb3VkUGFydGljaXBhbnRfGQ64GLniSynFj4/cNUZddHJ1bmNhdGVkX2tleV9pZHNvZnR3YXJlX3ZlcnNpb25nZXRfMmZhX3Ntc19vcHRzVHJhbnNjcmlwdER5bmFtaQ==", ) - /** sign tables image 1, base64, 43 chunk(s) — concatenate in order. */ + /** sign tables image 1, base64, 42 chunk(s) — concatenate in order. */ val signChunks1: List = listOf( - "wAEAAAAAAACwAAAAAAAAABAAAAAAAAAAcAAAAAAAAAAwAAAAAAAAAKABAAAAAAAAgAEAAAAAAADgAQAAAAAAAJAAAAAAAAAA4NryRbDiWYghBidEqW5rnEfLEDS7C8dejKOtGx7dTJju8/EmWCkFquMjQ6/I3vztJTeL0Kym39fOoigBhEGUNpIRmtk7j5FOjmGBE/VPs1uy1gAIofakF8Hh2xXo7F8HOvh7Yod/5qAOUHTJM3fD/atJL5DMb0K4cI2VMlLCz5OCgLdGl7UtuXL0sT/Up3nYtlyKUaj7aPnlehg9yp7RGbzT7xZTA2pVZv6GbVcSm1ZkCmcqDcZzXepKMIXV57rAAgyuH5ZaBGyDcTU8MX1UQDl+n/+0HaWJfOkgxSLES9wJzdLkZWmZv2M+SL6d8CxNdXZgLve9Gg84eCT6FOsrHPbrdZRRwsq78b6jBXq2bqkwhfXd/+OqHrOCfsaM00gR6vhFYMwD3FqnuOBWxb0Oub9rQE2RyytsizTbiM2xV1R99CDQalMXbWev7cSdM3vAmVIvFIopJOcm+c/kFTfO1mGfXsEZBELZkFBGc+Ud0bemqLyT6VhoAmL6PawjobKreXYa/Sp4+zXfQbrz4SiGg2OVCdU6No8t5vxHQ658omTJSkTYOOJwBu6ld/JvFtI7kpjwX8d0W7SBLAhlmtocLiJVAPfXtYQh/iVyDQw/Po4fiTHDXEwncRKeEAuc3qBZOX+ksI1dE60yyAdLGOzUSZsPTu+Wl+hmGwpPPGmHAYDgGPOGY/OLmMInxWSZnFpvktzEIr3PwJu6V5ru+/qovnGub3oUp0gln50+EGezUoFvv8BZNf1HjWfJgGv++e+PXh9X1iRSj5KhjK//CXFOZKsNGNJr/m8eO9kgLMEHd+1paSnyBz1n474ixbpQ1qFdLQ2o1Zn4Fi4VKvGU5LZ45rl5jb5/n8SSqu5oJN9ucxBYcGV8lQRUB+i1FPMUgg4EGLVKcSS2HOEhe8Dpw0QOARW5F5ivptA8eBqj1JRk+kL1OVgrsrwhi5enIOv2eJJEG568HkUuVbu96uDHMBRYDWFnu0/eECPH6HfC9sVqddbICdxQmRF1ombke2eZpKdSvr+QuOm5kUXCRpIn6q1eutu7X43rDDiuwyiHR7cgk3g8eZx0sHDmIcxbZSkRQIA3JO4BhJiOWJuJrznE9ApRDRUOUnz1T00LitNJqP/FOvclXLzvfoUC2WrkWReZBwiPPS3Hehp1nfnxIufLsQT8ceIwgZQSHt1BzUtjpKoqZtZu12fPq6FVK85toFSmpWyn41Y0MaKVgrTQQt5vE2DIHz6DtS6We8CjV/qe7Bs1MnZDcv3Rst9oBfLJGCNh1OAcFmkGD9h9U7NzFE5M9v7SSMrwO/P4GSzGi+Ed3NWpSmL7iAlQmp/tAGszd+U2EFpkJsGsXUTovZeM2gM/f7YvhnSgjGWShaVpEl6YcGaQr1oxIdP6GkLy2XM/ew40k3QhXJ6m1xu0WHqgoT70r3HHVBPwd8QhNK7DmkWwo+qV0wu/DY3qvRqJfJ+KgZ3FHChYiSt04JtZB40dTpKsYGmEAsERDnKelYoB5/j8PEM1s3cG69w7xTCMf7dNFHNxZuDTMC30I87QjoeI4Z1eXAOXe3KMYvg/F6UQyoOi2MPoD4Yn4Qbas0TRfcU8sym7eCFaF+rr+wj75ugKx2C79TNB+hl1p0iH7EWEBTYMpO9NpFCY0iXQAEmMdWXc2rMdedFPFxQXYcuapjglDO32kC+Tn/kYQUa4h6c4FWepjUfNEuHsxt+MCXesHbVl+ppsCI3OfimdAdf3kKnj7qsVrlov0sj8dc2OWKUXOUL5ZoTMdgriqu+Tcni9LGg4ED9ppwckK0/Dhf5vLRKokRS0Hom5U1VNICbVV59UXLAjvvhDt13go3Dy6dyCN8Dl1CdONGOb9DFLmLtnSUb20BqkWa8T8XGcKiUh5159z9PqD23Zh3t0/Ybas6F8X49ktkxW1gJAPhEuWxuIHwQ9QTq4ipU8BQxrRMphwkhgy+YisXqADuvkwWI1xN7HMPVHAwagvHmy2wCeUDOWGdEof3Oi4QuS6PPJRUoyUZSLUrqZ+zaD2G7/vzsYl/AcrRamag2B3cXsxt+MCXesHbVl+ppsCI3OfimdAdf3kKnj7qsVrlov0sj8dc2OWKUXOUL5ZoTMdgriqu+Tcni9LGg4ED9ppwckK0/Dhf5vLRKokRS0Hom5U1VNICbVV59UXLAjvvhDt13go3Dy6dyCN8Dl1CdONGOb9DFLmLtnSUb20BqkWa8T8XGcKiUh5159z9PqD23Zh3t0/Ybas6F8X49ktkxW1gJAPhEuWxuIHwQ9QTq4ipU8BQxrRMphwkhgy+YisXqADuvkwWI1xN7HMPVHAwagvHmy2wCeUDOWGdEof3Oi4QuS6PPJRUoyUZSLUrqZ+zaD2G7/vzsYl/AcrRamag2B3cXspAEDBQ8RM1X/Gi5ylqH4EzVf4ThI2HOVpPcCBgoeImaq5TRc5DdZ6yZqvtlwkKvmMVP1BAwUPETMT9FouNNuss1M1Gep4DtN12Km8QgYKHiIg5650Gu93H+BmLPOSdt2mrXEV/kQMFDwCx0nabvWYaP+GSt9h5Kt7C9xk67pIGCg+xY6TtJtt8Jd5zJW+hU/QcNe4j1HyUDAW+0sdJy/2nWfutVkrO8qfoKdvN96jomAm7bBWOgjZa/qJW+xyEPFVPwfIWOl9AcJGy13mbDLRspFz0reeYuGkajjPkLGUfMOEjZa7il7jYyPioWUp/INFzlL3XyEl6L9HCRstMdS9gEDBQ8RM1X/Gi5ylqH4EzVf4ThI2HOVpPcCBgoeImaq5TRc5DdZ6yZqvtlwkKvmMVP1BAwUPETMT9FouNNuss1M1Gep4DtN12Km8QgYKHiIg5650Gu93H+BmLPOSdt2mrXEV/kQMFDwCx0nabvWYaP+GSt9h5Kt7C9xk67pIGCg+xY6TtJtt8Jd5zJW+hU/QcNe4j1HyUDAW+0sdJy/2nWfutVkrO8qfoKdvN96jomAm7bBWOgjZa/qJW+xyEPFVPwfIWOl9AcJGy13mbDLRspFz0reeYuGkajjPkLGUfMOEjZa7il7jYyPioWUp/INFzlL3XyEl6L9HCRstMdS9gERBQAAAAAAAAAHAAAAAAAAAAoAAAAAAAAAAwAAAAAAAAANAAAAAAAAAAQAAAAAAAAAAgAAAAAAAAAIAAAAAAAAAAsAAAAAAAAADAAAAAAAAAAJAAAAAAAAAAEAAAAAAAAADwAAAAAAAAAGAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAAB3U9+nat5YBb5UkFku8AfufdUhlO3fBOKznZAuh66e+E9r559S5mA9hmyoYRbIP9ZF7Rms1ec82oulqBa/lqbcq48De7YChNliiEyF8izbMqEJ/UgxA9g+b0FM8ltyQgK1kR1lqByax3yWUpvsMsUsvxfjVi8dxiBxX1LsRWxcESYCjvY7jwlU7wXBCH+hVr8shHDFvI5Vs+LMwX/W/8+BNhKe5iufGUT/FdEYb7FGrzyUYNWsnkWj8tzRb8bv37HG4m4W22/ptA/lIeifQbZfzGSQJVxutVMCLCGfNh8vcgUhrdUYrCp3zCbiK1yCdZwPp1Pmn612kMHv4lz13Oy4j6snX5ImoP1GrGih1gj/FoUt2WwVJ/waS2Vo1n9WZjEGIq7WG68pdM8l4ShfgXafDKRQ5ZyudZPC7OFf9t/vphE1ucEMuD5j2DL2P0iWYYgbs0fyi7lihNX79kjhyPi3wORoEN1p77IJ4yfumUewWcpiliNaaLNVBConmTAZKUM0EJzkKZ0bRv0X0xpts0StPpZi166cR6Hw3tNtxO3dlGNHy7N+ykwRqkCETTrkE/ppwTWA+csQ9qeJhDqTuorhVnL+hkv/eSSfdbF4D9Emz1z0ALXM/iXDkryxD6aPv+DX838Hyn74pR70MPmOUKd", - "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", - "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", - "suV3kyKHDpWXrVrZur9GbG3+gZjGgvXVoKlg+SMVJ4sq58k/sNcFCvMrcRRPRHVMf70C8euR/9xRrsV0W1Uwff0tO6z3oUC8qz3YpLh+mgCZDHJO3shv0uij0Bx96vwsrOGEinUJ7HptkXAmn6PdSNFLr2nNAXI5A74ZD+4YNvta9sTyxaD6ItvUBmEg02yunaSVnqUUf4ANLkA6QqY0Y/EFTbMIi3xGRN9W80lQL7y9l25rKLF4cQQkUxe6oje7MLIeKoK/lHQzReX1xrSrpz1VzrAO15KNg7jYd1h2UZuTKbdoVOM4eQqYDB0AG9wcfpDAb0HHhsrvMYeFc+IS1s/C/RY+YFv/qGddwWQLtVLwLf7MydVPB6kf0pxiwys1iI7I4InrmUwauUf3E9Ayy4EVZTxXqmZD6Y/o2VlK5D/eofkCmiVqttrtEF87e/TmXK3nll74JyOMIU4R+s7UVtNfXkYBEdehcJBmWypU2bFPQyJQPJNnXHZp6jOpVxXh0IemQrIXoDuYouxvio9Zc8tYrbS38+DAnJXMVSAWvhLSHwr84oU/MB7GIURxenlAiErEN6Te6cqbZEHwYG5IBRjImQ6Uwol1CJ6R7UuNNa85rHtH/evnWpbdKeUd5jpFANu9rvS7PgmOUn7BA3K4SRAC35+q9WjFw8e6HCwEbGrP0YYnoxP+XX2obQ+B2GXx1i/3NAw9DWuCp7NOGfIrJvYylwa5JUyDvxvahBooFMlRtoDvNnhN+6vjLTFTjHfNtX+8kuj57nzcnbAHJIuadDj45P9jYQvVYi6lIy2xi0QTt4zS+hEuIzr+Dp9wPvNF66M5JSASwRy+WeeI8eB05pXUD7iEW8V/d72atGlr3QMmaiutgyx8kvAw9+yz/AE2WobJdu4VTTLTCKa1/aLNYM/LFLJ6C0GwChiX1xurVfagdQdlDCRiZNnHL441BGMFr4pGu9CJ+W0n3jz/jeo4N84WTCkeKBq2F9r0AtaswuFsk/hJcnlIcUKAP8zKnH2BlgDlmWZoDUDAEAaR4/VS79We7SGFQ6c9pDFPcxkJqd+YeFNuxvJe3FfbTlabNFRvYX474lwiudFLR1gqH7ozqKqQZ+Rfoekdj9hKrvu/yOidlF3Eh4J7UVDDvKV8d3RNhUfJOqnT5MeWaUz9LRuzH98SB/HviDI9E8ssSUaAOKI0oXZK8ObqV5vQJOhtY0UIFcWUA5nPhHgFk5zgJ1nUvEJOL10xnmpRe2TnPvfD2VveUlNLDBzarH2da1aHglR+xlWgubr+7c2RmMFYpFoY7N2Kq0+/Gq02la/hYhclGcRcu43iO3VA9qbuIDwU/yYr+z+aC7QoQY6yFteJKYaXeTX16fJubAbYbyOoLl6BesC4crGf5fTjcdGQvQoOf7VEHQ/Skqf4ZcjOyrcREOs3SA3WsKP5tjMEg19zzIzVaPzbIvo5ATAAZo+qvkMhCWFnwtyLKq4e81BwpWACrhE94WZR1JvB0rRvKlWJcnPVqKyqB5rF8LBtfybXHWxgAscSMpF8zEjpvqAFA2tDIdzI7QRiUmNbmEC5ngq37uu1dNDsI0rWafhdmUlEnXZeQozElCIXWYDv2T6me0d1aN/ysxOBlof90xDaohjjPEzKQQ26ZA4MkIuXVxv15Es0Cf8fzrh+bikxMLw5u6GVXIUGGTMI/FM/TSwg3rY7RQCDzfdUz3jdLcnov456OMY6o/rzr4+c2NvCN6QcNuDlK06pcV9Q6o2TZXC9fdF5T58uC/SlhrHLWKsl5y8WFR6C/vFnGuat+2H2p3dqJwEPikay+TWIhJIoFMNWwFriJJVO4POoUwt0HMCPMPW6R3BMXtGRPE0H9omNUvS75Ismn4FpyEpiJCLmM0EjXe0TsGGYermWz78r6cwA/XNCJUN8uEjZvFdoZVXxypRr980C+B+hzmZUh1qt5X9jNni1AzH73PLCHYM505JJ/remMqC2drGqxWo61GAsbesvLZtFEZ0IEIC0GJrePhUoX0/vmQ0BHmwaZP+XJzh9pN1yEinJngzoGeevW+zWIaJZ/HXuFoX648HEPRfb0huCvfmOrlGcskRYblzwiFAKb8usfnEExnmKND8ONyrVvg+Q6oSnhlZA1yAuSwbQRqPfjNo7x+J3CTXDBeF7k9irZ6WzFKlp3+qko79xOVuGuoh9EiTDEd63KxZIiS20uWCLlAWgZEeZ8/GxN7zw5ggZtm12aqrufGt6lSIPTl/lHsEALu0nV/pnOI4oVVHbKuCRDU2QgpusKWZT7MAc16h0jzwvSZL5n6+e3CE1EGP3ShOmZb1Ez2yBMZ3/Ou/4/pa+tRRDXVh7TDZi0/YJ0uvo46VW2BqirRdw1rNUjIAshLJumI1AyHV5b3e7TwQ9px/Z1ek+q+cbUAZ/Awyal9r88pwLWorO9QGuoXj75CNLxrjCsNHdM0WDk8n0AuLERlxo1MzNQVJyYSXHXgcO4csdGCY/ylmpMoUg/X4wCnOHxTvQNBVCIwYS762crMp3jlaVIHnEUNwJzK4Csl/8bnAnho2lzctiZhu9C1TJZLGjfj6i0xnoL/PfYFUan6ihehwPvEeb5MOPBILCwKp0mVlFXoUqO9V9PBGmSVhP3RTeHTPyLdZsCkKMkJfZ7FrwFyFOu4m1aB66eyUYhO0iV5M2p7hTioc9NG30FlJBYWr5DBUrLvjSOQNNzhO2AZpxJgfjCPa0QNfIS5KdMsb97uKD8Yv1eBDRMcf6oLB2AHL+/+dbb3X3N3yIRFxKRvuYDdrm6iyUDqk/MEw1YyjUuWk4r8HP6aQ6xeBRBX9IaynrZZbQ29jhv2eA5UMknpFzvqtdgbcfs53yTKsJ1Ac1MCy2/lDmK2WKG+svNjsE78eZogZRnqQ4+eIl5YdpOZa4Pn8zFsh+fKGPqGJq0E6RrRrBgPNh9eTCgg0fpVQeb6cB3tp12LfooLMdxidYAPtj3JNPIxTppuopyzJ47JzFrlOfuhB2ESCbOtLMcXcxGXASYLXjQL4O2SqVV2RdbGdc7YZ59Ne5wxfhzwKjDz0LPFkD2yIt/5hmWiSxKLJWkDT4i8D6R+D2hBMF1VUYfXOM8BWDlGiJ3z9NUl7ErDdJ9y5rdHpBIY5DW85CyUvn03tGbY3KvBwMsKnWRURul5LRSIGI/d2q7rtfzZoI/LRK8XKFv70mrwqboe9ssRSjONOEpUGqVBbin5bPVrTw48PIW663iYxacHOTZVgCEtSi0FxdRfnN11V1aukwP5BkX0xAIVMpV9qyC52S7pfBinYby5oNY21LBpXeKub+6ORZOq94REiONqwdxSJH4YY8M9EcCf8jFb0RmGdC86fd6smLScc0cnl6Q36rbgygEP1ezNKFJC8Hb2mBpLBNDz4OaNUs9DeC22byjVF9wve4PQoD2L6tHuU5RsDEuR+p9mvGEwHcnABxu0rfnrME6/rtf7Z8v5FQj3TOYS2mIGBiCNY7++f8J4iZd7wY2Ye6Jk+A9TGUBRrxKCWo4C4yNXtO+FK1g+wZKxfKVoqmGSxj5tHYA2V2xT7inRsfYsRyLbAdyNoHR9uqYJGlcLXXe8smhRcJXv/03LSyWn9rltTl1bMO9y/sWQC9KWfDAlxh/ZRbLupP3sEq8/5zO/Xp7qCVI4luWDfC8MwRBEVo3zAhNqRtp2RKi1SvFbr2ffu7udMN4CA8J/xTQqyoSL6D2ckPeQuHhp4iFgyOrrEy6+RLv4SXm/qI8owBaUB6NLdqz3jjCF9+mnGPzTlETRSNbys4GBOAdWxSV4Grxh75nDpd5+gKx9Ik+M5mykO8mSh8BjESUJIc76mioZjQRkk1TBpRrcAQQda4tpDdTgXxPSUzP4LhdKOfk1Xtd3WrwcODBY7C1DorhF9EWJjcTllIpxA9fG3XLPMyHN8VW+3YlpGNQwtptIi6TyAW8SPshRkkersfhotSuaY3klbLrZ2s7hMHIlHFeCGUV492/V6zA6/NCN3KzKSM", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "iHY0wOU1I7RDTShlsyXAvO+5WKSBFGpWoGaCGPC7yATG0HfKMv/RJzsNP5PrM2kMqM8dEmelGulXXG1USbbdbPOJ58Sq/W+LeoTMOI+1QsE6nxaNdeaZgKKnXnS4sXjh3prtzXL+a3Pj13v5vV12SzwsjPpuYn0PeQec9ERbHse+EXFKUpi/kaF+4Fqw8Sqd1MVRw9UV0smmCVm3A08OiExO+CYf2yu63zQLBjaSqfcIlK5hm3zCrQU35DnOhhwAVRvWYPziCqspAUdBhVAiQD6OcNMC+xna9azcSIqvY54QIUYg9i2DkMswaBd/o+xTltkkEy89svJfLmSV6u4xl9iH6EXfHZNgJi0uF8wzFqfzib6dhUhdq3dB6UVJkXYTtdJoZ277LBAc2mL4wYp+sqq8sA1Pn85ZNzkfUl/JxrrDld4iGBR1B30DjuYhPr1ka8QwC4QICRGtmYMBJ8cxDFZGgPacD/rj3dgOJMvCmwLgpLeXh9DxFf4AQrbP9bs45UD3bAbh17hNf0Oe/LR6ZmEvGqyhZcBRTqV8cehMjdPuchvUb6+zqHPczSM1efJ0NDZcguIo68UE2yCai8rnUL+uuStHVYjIVCXvHpSQ7Uv9oj+SV4zq+UqxbRLZBSmWo+xpXoF4oGPWjzKm1fDkGVtqWjyYhtFwe1M7PSr/Olj0RKkKUJq9k6N84liy8yif1sdTwdcX0MukC1u1AU0Mik5M+iQd2Sm43TYJBDSQq/UKlqxjmX7Arwc15jvMhB4CVxnUYv7gCKkrA0VDh1IgQjyMctEA+RvY967eSoitYZwSI0Qi9C+BkskyahV9oe5RlNsmES0/sPBdLGaX6OwzldqF6kfnNyG2QU8qZ7Enwr7tu1qmgxZoVKJkgBryucoGxNJ1yDD90yU5Dz2R6TFrDqrNHxBlpxjrVV5vVku0327xi+XGqP9tiXiGzjqNt0DDOJ0Uj3fkm4KgpVx2urN649yY789w/Glx4dV5+79fdEk+Lo74bGB/DXsFnvZGWRzFvBNzSDgD91hXjg0S1b0wTjRGJyvFs3VlPwL0FDKwqp4iOju3pISX0zGo8fgXPevu0Mk8r1/Ec9YLiMb8hXEzzSbC47SujbrAlCUA/yQdHhVToC7sVFvhhiBFonp22nJEmG57tj6Dj5mBTbnyy1HpLyMfyF0R7abwifX6bGEsCgRq/ax8oQyRznjeo6ct3BZn+7tmdG1a35ClGjbqIV6CecrZv2QPaVloKtfD5pUBvOVQk0uyOZp3x2sJzBkOCGBIQ+K1q58pHFJVSYfPrXBMfovk0jXnKEHd4L5/20JPln1i81aSsW8FB0fBSgYQ/u9Am4CcXBiKnYxj1Pm4qRPoN/bYG9Eya9ZCZZxEh7+OvtgxFAD9n7ff2XxiNZQQoE3uzhvevLDBC/qjsWwsGUbbdnB0Ca+uVYn2s2gOHUcIjbo94c1ylzgpx4tLV0zQ0rhm0Z0WkOA/xH4GzA8hW0pdz28uA7Spm6d64gUzXIXL/kgYUJ6CqkGYlUWBJLUKlv8wDKhpNzk86sB46x4HBEBTcy8mf+Ya5KZSYzQV8QGkE4grEV/cmedqAvzwkeOPINTvxdpZgEl9Z+Vg7O31sqJkEsMj1ej4PoYcih/I9E5YVOklbppW0937tqt7Kr0ncTrGuy0iXsLJyvM7+XeEF21aeSjX8kOTpQ2hYay5T1E2jIOtdZL3YyypnhnF6VaKca3Sl0wqOT1i/1JUUC2LlOUv3oeVSAg0hGnK6j/6mLuT+/1YRhGwm6qa/BUwJNkWT/JmQbhgoy6y2xQojE0TjmW8sWGlAJGh79psPHS6po2/g17GIRd4f25560sKJ5DEG+BaIugrBfT2nEL1uTK0sxwN469vc2iWhkA25wfxzG1ZQ8FEyMnRqwTwy+H+faS9w04m2NS1xyWAN6wPNXv4PsCCdkcQMdUgZHdXCwJbwh0YzuRczzojdRKop4lRttO3gSmFRYidazNJfl0M89Zn5u3u1x/dU6ADVR7inwkGevf535KPXw6ZanxwzQFKvnLcGqI4rjvs0Nw7DWKXpZlEJm6gvLv1wHZ7vxqLlH+mqzKWVwk0qMEOtXVpcqkGF/nvoyiu7uyGWDjyMR/eAfpAURA9imV0Y/Gdj1ISjv81xE5KN5EneOVIjVYwI5Brt8gD3/NMeTazhFuierkMVeh8Dyo+w4GwgOZCXAuqoYnh5/Al4IIunnPQBcdJuvz39M0W6cx9KVNkR1+Sh3GtmzOfk0usyW8Isr20IfbKxgC4IhtQpGhwZmrXlUUUg+3jxYiFExxgGU8E+MLOr92n2VQ8++RnvrEe6tFe0tPLd0NZ2/0d69aMnFosRtUgOQcC1P4RGEHYOn5tTV0KK88k2phsFS9h4j+aLbZcVjiaJODfsoUVOwH9o9wps1xbGMvqvDBqH1iDEqm/q1k0bqMhgomLgHdtOPjBihC2Pg0hzojqCW99DroXy+mS/hziuIaqBZAnX+EjX+kGCxEWgTppoGYSyFWCobDjZYn7frSBg8hTqSI9txpai1AyFHTXA2zCMCvNN9SYtYEzsCk4535RjgBW8Hvk5YjNA83GMoT8voRj1B9xh2dnx2BPLFqxR1TsVm/1GbLcja9V9MNQ0sW75jXtGhPRXmKlNnaLcj1c88TadFIxPscqh9nvZHhe3hzOufa9O11FxY26bY4Qa2X2poxNV1No/i/lj9ZhGgjnGazvz7hZC3zA7+xUTJgpFTQuzj2V2yqO7W3NpqOSSpfbJK2/etFJDAJnriRJ+n8sMUyYBJC5fLfoD5ufpvAcrt5G+4Z/sx81BwX4He7S8zeWZBQfN5HwrE8nF4QB2JC1eW53ndibky6gLXQG67ClDpMGQiYy86aVSkVBvQS6xox8DCGk3fnFF6VPIj859vbxQUAR2eC19WqYAxJC1vyVc65KclsPv5bodwlxwDyUoMhEIkfg5dejU51hRHvTnsNKqygkYgrdwNFyayf5m7ws0+MKy/tC/y9IOknIYHS2T1EMAKh5rfVMytVDq+Ke3nrq5midwkedeXE/K55ZcdQZaAli/kColxrz0CH92zW340lNAQRh7PTg0pRCB/ravYDLogtn4wP+g1B7SGR4MNW1cEhjUljplrbrkSBRw9/f1vKnaTHaBpzVaX4qMkGX/Tlr70veQ06+OvA2CN3YePda6QBBvcGhtFly2QK+WpKfb1LqKYh6S9xsyTNqi+F9lQzQBSPr+KTWD0vcYOhjQNk8rThv24WZmj824SzYHq/TXy/XZbgHdpBctA4mu5xFu2qUPQ2NvJz4aQ/kTo4nqrEJFtIH7j5z8gqNC0TtpeKT5o+aJQGnO9DlFENmAjwNmYUNdS9iJdTahpasbGG+5/Gwtp9HV54+srMtRgRUBQj70zRwTTQc0bjQr6kON4clefLGXc8V7vw68V2EjBZ1ynORRLLFdmwTMJLfa4Z19yAbpP9YrUPX+VinZIHuQEzPEcd9t6cgVRZSxOZu5CPOhzMo5P+Fz8xecCt/JsbMV2g5S2YQj6xOsXpI/cnMr9WCUX7d+ueZ9VsSfUYjpJpubVsdXxXt+ne0GB7EzK757FAXLSIoocoKiVQuufHiyZG/HU6gx6upiGZeTTse6KoTVXV7Gy3DnDOMNniA9ICfqLp/GJnCyf+xYzwbAhuK/CryXfcAiusQKCse9JtTqBOzHVeUgmXhc6rEFJcZvKJwMfc/oTmPiUYRLnyiolbKRYoYNcK7YIMlk8F2wSC5wCYI3+5JcGkJYQic7dKpKgr60dWNy59jauPnlo5QRiBpeD69uHB1C19YDf6766xIXMPUt9vymgE82uL02GlDQj9BO5U0a9Ij00Oq1jfwC2DQ2HOfV+k9KbDBRdxUcuRqs1qc92JS10GFeq+0YckOAobhdv0B0DhL5vhAvgJL4QjlY5mxMa0FB9aFffIyNtxE1R6ku1Iv6g21B5L4UbQzTracS9NnlABlgLx4kGQP2SaDJ6HZBBbv", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "UECSq2EObSxJdtvL+tcuL9KvmMj4Rk/D0D75JGOfDMBL57oneqlFoFLR80fhcAajyQiwRMFDLZXpO5tyWppulnLi2HFDrCf2a9SREdh1ZPXwDdISPpFrxhbp3SGlSCjFjTCeIrx+YaWUBtdCJ6cipg/flEEHlAmQL+y/d5xNSpO0Nfx0hXsD860DtRQeokDwNtr2FxwzIRw0S5f7h+piH6+S1Pie3Ct/tqSdmAUFaHwtfd6bJTZDSg1O9a2+7wBJlpe2rqfZSSmPof/OPAAKKhR4vM1V9MsIfYx9784tiAvmVT7s1xvBa/9jd4xMwoJoZLo0j2zxqV5EiR+59yjqXd9QXLruHqM9xmYV2nXH4D5dv1bZd1aB0l8uNzXsj8LRxPd0NvW5i7HdwT1WbmDIskYYflVOU+OEZitVY9WKoIf98hZgzLzp5+TEXwBXZarkfx0cA7GBpdeZ+RMwKljm1AIgUDMzbq+0GxYZU6i37LeAz1pQiITHgaD8cWYTXYSCOyUyZQprzeIiE3sFkbKO4bnKOAaTI+8Nu1tZ6gj6rA4gghrpEczlbjm0U4mKFaZtom0QiqomjVuCXju8Mf/OWBmHeL8oyYc4ALEx37MQxDubaHLcAPBXSXhGsGHZs1TSoQWz+u/6NMuXTNPjNrk3UE4P0HgFkgFwfSTmWNzRAuukZ+XD6phi8pIuhdoz22FpS22GQaK6jWvaDGpDe/mO8ANPadhNsO7pNQYJwZTz7XLsRQpap9jbUt9uPHp+m9jJBi0/4UjSuNAwZF/4kZG7S+knXGN1noitDShvhazdizbUa2wempTrL+IiDAdD1+i0O2EPnHD83pQISjm8qb/dD9EJOief9r0W50BaPka1vo0+A1ml19RSj69itacOl1EUdiG2PDjeMQ1AaNYl4Z0ylpkr1b7StgS2qgDjngv1By1zQ+AFPbxnNEUKgBzk/2SvnEmDhxA+RsZoiKHuyX1FXbHLonX/NCVEh4LCbCZ3Jt9ewcH3FVwQ/23q99fMHxNktKn0TPpWc32C4JRVIxVw5lujl86ydJzkysJ7zGs3n38TgXhXXX7/ZiXIGE6EPfz9/Isb1bcWyt3PoC31blXJRhbjLm5YHKlfIKpOd4FfqsT56U3sZVCZIh3mfgq8E5q5xKV9kYpa+qDy7B2IUxn5OyuvHhNgMs8bGIQoM7lxzIDBxyuojzismfeOS7FWe68CLs1IKscaQwC/rKQoHllAm2bvp7MoECCCUKbHqvFTIxmJ5cQxwngVObrO8hEbOxaiY43xii1ydrtVxJGT9DF1IIyHkghpEYyaEadrsrBSjwHI5GgphhvvGP6tCDBfWOyDJ+4Lq2xz2qMUxT2LtTDZOM2GPhCDebkh+89eCVo6uroijF2Sy1tWuLPtsZASGFUjaq6yCyRRNTpc59IS/RI2oYWk0YnOOQCBto/nqRd6AxpvzOQyITNjA1mFhCv4cGCYgMaHsBx/U35kybRWxTxQ5b2Kt83zdTD8i8PX1Co2M2dSgNRPGR0FR2Gr4m/AXgbcuOjh9PYXZsWOoYHtL1RlXlfigna+NYlcxoNudGd2iscfwG3vUT/q3imJDfaIfOlF8MoObbtX32XD4ThNYhTc/hqiO9ZUXbznLOtbz40ev3z1qFhUed+dFQFpej2gnJ6O2Cp5ppbV/pfuYxm/T5b9DDcgGiR8vcssBAssBKX+yLfdSC+fk7eorusBT4ZK9Ks1MkJMHduVRzejI6AfAtZErHpgo4Q0nyS1TCnDne3cJy6VasAG3vcRDqZB9iYHtBKVfwL1vTH9coxJS5Wk6L5xF5AIlj8MsULxdAel2dXyQWqtRKZC47shc5sNxls6+CLoQk7FwAnTFMhxZfPg0JAXU6gm8Hvm2XdKnm+QYj+adNFHLJP5rvuY09ZNf/t3uJtIDw58YEHx+1E5Rxx5mLL4yuAEH+Krmc7q0y8pwnLazXEKbCpZRJOtaDwlSkCd0K7z5WZJ2y+Uv/KZc5eKbJckK9pwDFMl9z0dkxAVZWb0psTQE468TcKG9/slro8OwR0uuCY1VkehBBjxRixgBKKfwbJFt7llTp1Q06m1KCZNBomQqi7xby0fv9nKN8csLoRmmsmsHgcYpFWx/4wtRBs/jPL8F/QNeya6u5wOwk54vWP4n5UbQUtbh/esc/8CSMBetK/oJkso2Wj9z/EQCCtCsb7MaskjHWKClfpK+mAe+VvW+dEjKX7gbZ+ZyBVqfXu03JpTzAuReSW9dlFdSJLi/P51yoQB8vvKtxXTskLxYBP0FkhracdAIN8gaFgqxNv5nCPzgWOkws/VQ+q3IKdZFpZAcW7hhTDiV2IYmqKGqzsUYYND6+ayDV0BmnWo5SnUHgIBrIPTCec1NCGfwNCSPnY3ukaJsIsIP1ejcMqzENF8VDipq18SQB24OjjoXImZXruh4aE8kK8X27jX4j8LdlTYIw7JCStFf+4DPYoKsJw87Zjkw2qpqnWNgdKAaTJzNo4aC49a1Jc5vfzvzFlPTnq+ZzaFOVZ4M95+AMY6zaFw3eXZ7QztklvrxequD3ZLGOheM+dvb31RiEcFpGz0pBKL3NzFgPY1c2feTYaDbewwZEWUz+N02nkEXKKM4O8DOgfHe6fWzzARMedI5NVU6VIyfJGttU3fG1Jlp+621gZYUf5+zk9sm3ioROONTPdCO6vfOsQs7nRyy8YMhy91rTHIXdWsGVWeGv595u8azkdZ/eY/pnrXcRCd/wnleUyoU55k0ISVTjkycmZBx5bV4HFx/ZiO9szWOBHkrs31Vw97En935sN3PFAkX0SlwOzlEyfEneyg9dNaR92rr6NuChlERnKgkIjuFnegluOTEzdVdDtPqvMKARwUInnp8JHYXxe5oMLGset0IZmTgcUqMjciAkrIpTMEfkIbfIumqN09QYCl6kqqTFytgjSpSTGVH64Z7eApKKNWzgDboyqzehXNmwKIHJNJPvu7McsfCJB9+CDogn8RpjSYOd7BfIp/d5uiBwBe44u2ucvzQ114UvW6UCoKPWFkvNpJHEk++r3/2dLFYgjajtTv8vYhC0FXl+xpL2hrWGHejHAZK2jDuJ2P68BKhMEp/GPpUQmHWvC/YHKIQOdDxvYAa74D5NgftQPwZyjS+CyeNdBUa9Fj9d02S40isXrDlFZSu2Gy4RrXVcliboEH/thmL4Ytgpwnm2W0X2TihRHSBa1pJ+EeyJEGNrAM1z77ujAWg0/UpSL5M41aBrS8FLBTlGxFtyfN81APtSRbJVySvA0kZ1i+hdG/lv0uOKezmN+Py207PGrb3BQSRg0cWfDqNCEFDoeAs+mv+Exunrb6ibbOD20Fb7mKLRe1dxE3Ul9pgbbsyHRRxLDC1vX+PTHdhovVbid+MkZfyONOFFUEZmzj4NXNFgf9taCAzPtfZ+SD6YNXIhxkf1qqb1WzfYh9y8tszmo+i+YSiAzXXHfr/yTBD0yFNOhk/YI5bLYf3kTOqTr3b1zd3xfqWu5ZFb3GIaNZdYBWvl344GqTZFmNuxzvaQi9Go4gxawJEYtT7jnz5QqKUhDtoiqmPKphO9uCGY0/Mbh42BnAzl8ojjG4APaHXLNXcrubL8SwscYTV5m+pbMqH1BUAmfm0zMpGTQbUa/QqPBaN4CI7OaIw3EBoLvH5RMaMgI7YoSFCix7YiJUzYaR9ThhuY2OpPgB+UPQeU+nY9i6QEugDMd67vMgUpZFxOE3sCPJTwbywQSbFel8LfFa3dgWcqVukUPrkXZrkyeS2DLSdfBKZH7ao7OZ8tsFfUF68JppAkYdWEy5+nA0Dx7Dlfr56+1MKOOm0c/L3mcreH+SzFAHJEthSdusSTFtSPqQmK/S6C57HHSXnDQMIXiHrdSfr9ViGJ6bnf+24ysbBULe/C06aC0lcfXKDQlDLr6otsmW0ABOp57/qY/mSU08R7yqFD8KoT7W3UYWrmuipQ+eRY13KMK8OdcllEFhwSfglCYPmCL3B9O/", - "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", - "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", - "nz+CwT7KZnJGfIFaDeFQUnVXt3rUolPJrBS04eLrM9CaXdT4O6gwS0Me12PfpwOtpxHkhQbkADZ+UuceMK1gL0gbhwfp7mO0kViEnNrFVZSic7K8A4ZWD3swsSc1zzYWTXnRPuyMNY2UOtKlfe3ZjwVbPqekrtoU3Bg9PJLnug3qUV0lS6S5ljMSXr54j4+2ADlonqHMjC3ZemsFl4XsNO8zCxxOxu+vNnAIh9PmFhWrUPE9CqUVjnIT8qY87HWXRFqSv+WvdgydGZEk1oRALK4ypwQPx0O3d3GknzmOI65BOMSG4M0gNZh7xx1xrMw3CRorH6jvz6zQWSiEnqavteYQSJ1H5awuP1NLBnTOmg4MeH0mrY2ZldU7fr2bxPmM43IepEKH+hc6MR0/pojJ8d4+Ltl/y8pqB30tQkmCqnMxNE1bkMGp6Oh3TsCj6p/I21x44HqpnFMCH3t7TOD8SjRWG2KVo//R7RUY+QTCE9N8dPT73YEQSKU392DryHBRk36XeTKLc8pKPZTiAaBF6nkWosLY40ZxoFWhWe6qJmiWHMFAN+kl809fwtvDKAeau57gshprBAFi3eMpLCJkGFSUgzD1YWeDjdeAq8ZKUaO+/LaLHwlSOGe/tRApQDIhUfbVCfADMbqItdaSYWLduBnUOpC4Id4jwJc5C45ovjr23lkSVyu9oS+dWolkAIuBHLZsqb1DiBrF9W8yiwroA/O8DytSSeuYKv8MsLZG2H7O8D9WbwXb5RezPM1ZTLv8Ifpc1IAPuGf4uV9PsySOR8uSaW9qZ43cEtFq9Fwu7cUkmArthW3uXv3bCXYUDAJcbLrldM1PAce1+ebv+wZh3oOwhvYiRWJFWvOFbRFuVGVp2LNNyC1X/rCbsNb+ZDfnhtLQzycnNHxfkdNUgXnFGTee7WHCel7AdJ12uIsaR/Y9/W+OyBncL37+9FfjL/wcVcjUZKAsZ8UWy0+96Ux+81+rVouqT+UqHKjNUsuj57t9RM/DiKB8Yj5HVBrBwGVUdydNLILD/o00JNb1qfXevh8S9sbq9kVnXBFtH6OWXFEVcXQp4JXHiFZy7/DvpiFsWUEJFKylurUaQpLN5cWjg1Mii/umxjhaECEQIo3wGGk7FzARzvODsHgUq8iHk5qGMXSy/sSQAV9ydyknpXwDzhObK7bmf5gXUJiwb68fgSEZ+KlZ7Bwa+Fr7MoDHKjrLcc0Ss4QpoRIyzolqzUm4JHuukFyOSiP9OK0LhU9oSgn5j2JxDGvR0LqM+ahFC8jm8+zgngYIUz+w73tHLT5zDJvZW3RuPejV2NrArSdd8eORutmbZF5qOtK5QkIFsmirs1VA00ax83LwVtsKD9HqRLk2wjxM0nGd+jVZ5WfkUa7RA3nWJOfKd5IA4g9th9NB22D7OS6ESJiYY2DgIbeufJdQhgRitDWl1FMd3SvULJOdMwTraNe3St4wnzJD4Zd59Qa/AQDiDKC2BSTYSYIVlv9lPe4KgY5PvGamN2ttjN7diqSmKG4XB56JP39hDg4x1+kmSSINleiU6r2QCTu127/cnaNKOC4C/N8GegNYNzS1vx9MQFus7fa8hJVgohZw1kU+CCOhjamVRqXRasGUn9wmvOcpwg9GnyUnPgL0L3W0EwcNQfe0rPcQnNQIl62avnCF4kuUNkP9cx47Kng00pyfHKppe68L35yHcyAbtj2W/J5FYxgt5NX/BZxILg3X/sklrwstlg69yr52Qk2POPSqp0ABThTht6k8mQ598gW4mtp9TX5p3PuZQaQEHnDqsvlYkkcd6zPx+sNLbCvLANrM43gvKFDZmc94oWZISe/Qr2GXJUvSNpOs+k5Ep9Cn8kD43wekS36xQ2MGTsRSSPgjejANx8mRuyDh6Sbx6aKQFsHaZfJye9MVWgMskmtNmnVDNW+R8JTZdtjsrrOZYBhUsRjtsAK5W1cqwaTQG48SNzP359OAVlE0qC7M5aBlegKIHY/mO7w5ARPExoYiinBhCvKFhblTM2KRK+Rpu8JSjpO6p2ogGxGNCGPuCjktWO0RVa0JovQb7oqMhj+CxzDYqr/FPBkec9sxZoxcACg6uyhQz1+b8Xm4s4nAbH0VdotVbYNv5sw1iM60yg//+nzo14KJDGQjP+tMW6I6RBAU3Wxo4TnfyVfe97GoWcb/Hr7uh+taXSZdvXVeirZftzxRd8/JtcRuf1LsFoDV3Vg2MvUgw9ZGgXUxbvno4GayXgdOyqvj/WsdBNUT4oPkXVRkzCWhgH+EF2dX/C5FnrbJbeYALd5H9cr2P0NNx3G8qu8JCk5cqP+pdNBJeHyb1J9U42J750KXnM86IRv+dN781gxoGGWtnf9N1Sv0Zzz8E09ESvf85b8Q1J0Jl+XT9nDNq0CUfgq1c1ZyA6JeOZ5FdkEoocXg3UbtmGvB3NaUJvSuIsJHD9clb3dh8aHr2BaJk27yOjKbFRJKLZIjBNJ1C3xkkbjdkXaQpSenmO66QLCWDKQDN/lDK09PxBoBsCMyeQbHgdjzIKmgRSuDSZLMqzEkKBiQ0c8w6GdIAaaYryneLkuaf9ussgdtfbpM8JqSNEZ+IZWzmQntBR44o/r5ENtMHaN6ufqLAg8/yo542OL2zjxRVzvbeS+NXEhhcrtgGcRf07gxuPvAh2nzixqO2/OsamhSWY1AKu8KcWQQ7VkcpgnqvVPuwsXl5egsMgLAVITmc/VxAVuNx4ZqwzhhQruOhfEae2LZYs2z0SlQVPlR5rBK8BNXYoil0FPGWjd7vuzTyB8ZNOBnr+Au+xYHBoOg47UiVQSdWuODrBQcZIRsqoA3zV9nH7Xpthf+dFE/hsK1jCc3UqRfgdWVEX4yvWnI1g7IPTEmsIs6DFlc3SQh6jmXgB/ev/ipWY62Vr6mzuBaFW8VvT0Xo2w1XD6LHSSIb66FfYiG/csPt7M06J/LggwsanfrBBLB9Zb3VxK+j+H2DS4UESVWopYUGF1xPGDrlY/BHnKnuaijr/I1RIeKg6A0K3ZHHFPAwC0dPycFZYnDtsR8JJ68yi+0VR3InC2rLC+MXssH9OhMNroXqx7CoU+tY1SohRvieY1Qf56lKMl6Fok8nT7xihoPv3X9J8fDGZRmNv68HoAqcoI5zVr6jynpW3rOwSPMSfBtM67YFYVKa7RwrUPMxnxLh1ubY//tf9BeGJj4Jq4fyWhR+OEQ5xxSsRL7esmk8FAgcxd4WMXzy/kwFOOBhpPSz3l0+rfPkEkWOndhboymaSURQUFdp6Xy/FJC2oTkxevKGyLDsq3GcBNYIVhr7uQZ55kDMZ8v54I+2gCqRmyHmwiTYLNwJYQA0dBjKKlmsiDi+1UImk2xuzu4VpNDDtGiDfE2inVH0jnUsjURrAQ+O0XT2RM9ZT2gnJDaiOQmXbmq2bqR0m9eInOauQoLLGgCQLGPKjgHa5mZ8oyx4UQLgK+77KjXDQgbdvjvMw5OO/2S99zV6kE4Zku0304zAlh/ff2/VwVLW+SkvrzM3AhtxJeViuzvI25fTtaJdzZgDkZ4n+luACkN3aHc6vXZauHfML0G90gL4kTp/gVskUiCXd+3ZXWnAYHGBvRm7n5Ct+Y131DOTWm0feycU1WUKtRk2tUzTKJj1/8DljDXeyC7A5Qhk3sixiDa1yIIomHFOeyeQhGUKKWiNd1Bik1rpoIG9neqfkCQGd+1dDGnA5MA6fwUKJFK85swvxezSAnwmaHe+7HZaBwCeJ34KgArHxtO1JgzNmJ/gJeXm6jvIXygpLytiNwKSjt9/64TBUlJIku2zgozACm5kvXNkepDKl92+v53DkwZxK+5/ezXDxrdmfCd9eFGekZAs55uOAV5ZnOYqE4LLk/9qtur1dJtTOScksvM5CQsf0XRyFc9Zy991LAkVawGw+YN8yfOdUXA/zu6R9dDDKBk4vlETJpPo0TR0nJsqWSV3wiRcfdwJ5bGPtgR7kZu9l3nmxJ1ny31NBNaMBxr7Nevyhkz", - "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", - "fBpEWpip5a9/gZ0Z+LDT5h+Yq1D7KwqlHANyE80LOY4qI0E4zpDgzSm4mHuuidaESaGuMq0SD8dKOndxj3v7BmhTg7CM4CJFa8ha8+z5FAwL0Wy672LNTwhKtfnZQv5kPmqG0trZJyc98V+RusARbl3oadi5W8gtXnOwm1VZWUyycSH6VsKAD7Hq+Lk227ZG0fPO8DVAbwXSaBezA2BcLuRIJJgA+4Vt59P922DisySHysuSY3lqZ4RREtFQn45ot7f23lMEVyu0LC+dMx1hYtQ1GdQwhrgh167AlwamiwrhjvO8BT1SSeIVKv9lJGQAggwctma/vUOBl8X1ir0sIm2VVJSJJvVhbg6N1+k/wygOF7ue6qQaaw2MYt3chClAO6xR9t8f8AM4N4i1vwbGSlguvvy8nR8JW7Vnv0UngimiD/qfRrxbaqGUI9wmpW0jwY0VlSU+tGDCFszWEx6HS/Q2//0QhV4I960mvnCcaEGXtBD3cwexApQvybSfBSBjeC1Y1Zye+SB7toGW/IfPaRuvt9//HBYqGDRunMk8JQEuFF23yqf8Qi2PhPSqvsoLTZayvaklE0hODWv+msP3R33rj/GZWC4EfnBWsvlBGE0eaWD7+trBDh3yubjM+vIlK9KKk89hK2YoSVPQr3gdL0hQZZms48RsS8u82kDhVQ2nyS27Q3qMTqRS9PgjY7oHxEvCsSD4Y0TH0BvyFthQb/HwKNkVQ4ks8mvxmnVav2WScsfTdsFmJpHpHpBUqJLns4DqUVczS6SwGzMSNyp97dACBVs0saSu05ncGAKRl4Xlue8zAQpOxuYiNnBhE3iPhjsAOWKIocyFoNl6joowrWmiSBuNEenuajmRWO0I36cKIKcR7pMG5Am7flLYszXPP5tNedso7Iw8AJQ6uzHaxVwZonO4qgOGX4J7MItM54lsZJ8/iNc+ym//RnzozgiDD+ZwNetV0cAMfal23XXi6zpdml3e7juoOcZDHr73DeFZ33VXvWzUolpErBRRbkXDtkY9dVL1nIC13eQ2MuyqydXE0n8xd3OK1l8LPAdXQKHgfzgXBMyZ4uPk4VRk1a+rg/3XHWdOduiAZg5ePULYghU6bmWmm5uBjuMtZr+t0uGX1WQGJHSR4gwMJwUER7rULD8MM5+e+de35k8whqiwt67QBlAdcfO0NQlFUx/gklg3mCS/hDnRW6xBZ7ydD5g7tXcu3AbW2zgurm3fJuXwDg6dRum9PLMNlUQF6qQK+m2MckyKP9O5bherD4nZN7Zd8U8AukLu9V5qlkO5W9i8PnOgCtnAAf896HlJ2uAy1AvISmLse+uXCFOTIe9i3d5oSqVoj/kEnWvRfCuM+5X8h9PtSmBgTL+ESDQJY3l69uRRAkAD4qO158rbAwDCkJ7R6ugoNllJ3dJxMWs1QH+UsmgHIlXbptex895hVrJSFpOaKqB0KYtVkAHz43cwvRzwGMWqF6tkX/ODHOkUi1d0xaMvwiIQjjfGOPaBIQm4fqYhwMhBkmE9pboZi0KQ8FxJuIjqrgspH0ojUamtEh9WKjpn4M2JxhUpob6jzqn1Ph+BjYj4Mix9HBpUy/srGjR8A2KCm7DDd3+Yu8GYVid4TH5fzqvN/jtP5YaNqNTIci/8sMTITxExLGdph8tvIhoaR1qs/fT7WRncg+/+7c0QecW1pp52FFN6XmzlnXSFMpZc/YRx71xxlcckx3L2ajj13hKOEm2ze/ZFy80RTYBQwGX45ifWWRPD/iGlJM9vWqPnF+xEVLYZoHzOr0fuKzlZxlOPvnXyelpdisy9bMQzOkS8hd33HXA532XG3tcuWw//Vu3oTPcYDGSPrutVwVFsfbnni84YEm/mYKSIzIlzg+TxxWRXUDCAfyiGZ05meeBmHs8H1b864/3HjAT1jBHV3fSnMm5VUtZGLeQxd2Mbtl8brVHsuli1xMLuUgpeV4YiJuFhkYcUhbn/omKIsV3loMnrAhNoHuY7EKgBM1s10BsjgzeognbTgPrANLG0P7OZzIlUKm18sAIVylco/B1cAISru7MlXl+bXei4qhMXP4JrodgxylQ8GbLi2xH5fwo5gcntiiA8CaJYiu6TFnVpu27DjgjPNmogt4CNYTv3SElDQa/64rRL0poCrOPU/SvLrEvMeA2+KFB1CM9YPpUecEYj+cPn1h3rn2D62tGfffKpKZpBCNx+aXBqmUOZvZJr4Qt12ED+kfA4SHbBdrfx6Q4BFlqv9PJy10IVepzfxFLkaSPhRZzHyT0qIPhz1afQC2NAY6qWpEvSIEOFTpmXrTYvcB6X2pQ272xzB6GT9C/ZJROceND3tABmELxL+8GUM00mJ5K4wg/qDiU+pPGiFtxHRaV9sqGNBQRGp+zTTY+UZao8NZBOFE0mqSUD2S4Ne2/JvtqaLZaiLMqe6bEbtpEH/AUw8hgtSET/HAa7eDR+DZ+H3/h7r6dOnPQ0QG6MgqdGLXdD9VXBpN0bPiPsY4jExMJ9IHe6y8df8VYWV4ng8X8oFRXMUKPy5B5cddVm6pL9xx92Tr+pkWZWfppMLsh9ZI89mdf3i37/uXT5zsHCHuZgN/pVGIEdfVMczHUrqitdil/P7vLpKMa8Fq/3xKBI32VVrGwd40tEgVqfivnseKJYGZwRIK97OW5Q/AgW5hsgtxP/k8+lGLuEOMmz/I4um117yiglzS0AazKqMROETRmycamqysdOgiMQRahbpqKA+lNGM4LloRvMGiYqtKzBAhVZJbFt78KZJnITkV7E9Ln/MRAKh4f3Isl4cBOxzpc7EDtziGiNlKDk+lHhnEy2yT25UnpFD7VSC/AyY3NG1UvSszH4qgXW0OGYB9iZLuDwONsEQ0Bt42sOkmRadiSDctfRZ8GvZ4DpRrCLwz4GbOuf84hY50VvcKm66EHRDA9pcPnr2ghPDPJD0t36O2Q60pqR3mHiJzlJrNi+eNRuWVB1m73jDS1ay5GUjgXpImktSNeNnjBharZ+nu2HBigKr6fd7hzfawk0lPbYPOxAPxRNtdunNQM8j3v8u74DSlyWor+4JdoJXw0z3lQnS2izD+qdV7ySK7CU3NQ3paRi0I0FlzQ+fSHTFja8Ah5OCuU27/8BhZdJ5q3ZtmGcoQCGtAD1Ygd4Q4UvndWbveVjfJVElpgmPCB/DnLf+D8KaR8Xq5z7pNMqHIyYt82E4AEqrEH0zh85Qik3d72uBg8LSS6u/q2d1khKtT+fQZ9HKaa35txCBJ5qpSzQlSIdqCPFNQnWIYZxYMauOv0XpkJL8I7jvhQ9mwjzFdX3dCStQZMMDLR3v3QCkJfou0RZkA2jcTH4R8JJTqDqB7En238HwPPe8iRApkTDaO3ZEmCVb/VINJoR+0ws9tMC03HiemWWytuQcnmjJpVRSvGeezJHeVOTsp3g6wR6yKX7/fndTRrRfLj+YgQOGUpPk8hCNyUvapbQy9nuZizxoJmrwNgvTOh52qhbAWxPc40bijL1rW0aVFiJqSzuboFiEemwGqcOmLtS6ivD5A0DiHncC/DPOyNROt+QKYw4uGdzv4kfxVihvjC8EsaGWzovUVAQV+e3OPYSU4uOpLSjwFszkrjt1LoZGDAJYa7XISozBilSheEB83AFsovG4prFOWWrvY+Cgxx6ZjBkzIEY+HVV1oDDsv4hNlZNWYCxZRd/NlRvydF8zjw1z7aK0uf9FwPvhaHkxyRUAHRc4udcEh1gbWqrh0XLXmP2s+iE3lo/j/QiiWjcg3yMb/vKa0e1Nex2zYMLXmx27+0UwAjFX13ZzSfrPuWGHtpW/qg9frBXuk/I4V1naRS51BGiXvzfQBO5aac7wZxDiGAqpKAY1SORVmPEuS6WIAqPIMci970WKrwL8QLE/hWxZUjymR23dahTAZKAK/R2M4pCkRvylZoxGyN9GWPWmarCYH6Cup/5s/QpHpuM3PooLWodAFX3zAgeQSsgZrTPk8cCKLu//a+K8UtIoom+rBEo", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "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", - "LiwyMCYkKiguLDIwpqSqqK6ssrCmpKqorqyysKakqqiurLKwpqSqqK6ssrCmpKqorqyysKakqqiurLKwpqSqqK6ssrCmpKqorqyysCYkKiguLDIwJiQqKC4sMjAmJCooLiwyMCYkKiguLDIwJiQqKC4sMjAmJCooLiwyMCYkKiguLDIwJiQqKC4sMjCusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYo", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "mQscDXdZmlAokmm2xkDLhzDuhIYaAR3dkX9uwb6DdZVEMvTko7u6NrMxKx/WD4yTuYJ22bXHpqpUPLHPiglHfd5F8lenQ2I1BPCyTLApcHklBRZSUUi9Lpa8am+hxCP71dpgBxnv+jf3W/PFFaSBfi8MO0HSIa9tpZyflAh0e+2QbCdx63wt/eCti4UAzDhzvwIOGKKeSdxK0Giuw4xxRir2uQaeZT1Co3jWxY3SvRC/u2TCCnsxwHpo56dr2yWG0AV3FXxUEhSpt1/+RXQTdd/6Nsug+YkdV65Mj13B+zRjx/yiimFeU0qOfu8AToM1m9NJVVBisWzOKZf4gZAEluWkf8j0K7UPB83qxBkbrXNWGlvd81wM4oBAh5xpedmv6AgjHraCLqwnqz4m60QkHxEOS5IsUsmhOzcoWm/KQ9ja4BeUL9GZbf+oOt6Lz7iY7eQttPfyCyEgs8zV/ZpIR75mPFluWGrGZ6qEcqbcspEc44g5Agk4ATLwT7y67A3x5nCV6RYYfTCwYHbhk4Uin6XunVH1M9dN1EE/A+yOS56+HfBAxGUyLImP58+tUERhiO7e79cUzDUShjtiIp2xberdWBdNXjjjptkF/v9ZJCAmixZJfDzh86pbkeDkU34/nw0aC3FfnFYulG+wwEbNgTbogoAcBxvbl3lox2c5+Fxgr8Za5XTRFcXIEfrSzgBIGK6b1QxjVbIq98v5jA9Be9hD9FGhRWQzAva0SrYvdn8jAxBUV067KJC6bGm4hXOTQjTy4qW9vDC1Ny0Z0AmKlb+EcN+zwaCsUjq3yQ5yfeuWaiF37Xor++arjYMGyj51uQQIHqSYT9pM1m6op8Il/dPcZgEf6fwx8V31wxOih3gpCj1H1Cepa6OamZLzYpJWT0J9lr7g238o591B5Is10nCtfkxJVc+HKZ9SHNj20RsTqTfo1GO4+YoYjJ2Am1yc/hBA78FHBkpvsQcF2cpkv14heYIapeo2Wm2Q37v7dGbcLWcW3ninowyhzpHiQ6u1CA5IYAlrGcyaOcd3k1CySwGV5bzXKubDaQ9oWW6YtnvadkRyRSB6oltUhuGgU+wuHSQVHiWU/wCNrsC6/Wp8rCxhBAr1iWz67RHwph8jXchRyy/pTYHyuYM+mY86Irc7sDKeqgI/FPSzxWV1RjQrJ73VTjCOVxINAzhY98ImtONxhc0ziAv8xsRf1nPJ0K88PRfu66gx+PGEpNOXwz7y130bfE2HRKZfFYHxqB1/DdiOLdNj9le/oRwaXHTKbLO3GLXaha/vYHLIOXMCDrH+Ik55hMvN3nCrSjVtltVTEl57pRMRlI9IiOoEVPvAd6ztngyYiczixQ8HvSP8XUHbkz2LRgjwnyHGZLlqWKr0z2s888lV53aGQltWaYK8JezlkLDHg93EuygpA/r/nB/o0tBLwmfWMqD3ZZHZJ5pDBhkXLEzjUiA/M6nBWiQWKwDgp9FxYS42oy+kJoq+WZXmrZcqjZsLN0ncRd87/eGdeO75BeSy6X5ouDh1EB4xgOsUmbrUrrRH+DoJMAEKUTRutk9AkvV6jKJvzmJQZozIv5/q4yqz8PUMJie0y9JozUTf3ecQkyjWnmr4rz3Z7EMjGBYJTJUrVc6mPDAvXW5+3qjvDyQZsYUpqyCsOSGUgiWYoumaVvI00ErTRjgEvesK9uF3ku4RH3o3t2dx5qHbtZYb5I8+BQ4/BjX3SLv6nU9AuWE7XmlfbcFgrYN1QnMUctj9Mcyn/o4aUKlLiGzcIoHXAnASe1MVE66wWPmK1boXuLxjxQ18Nsd9b+CgxIt2QS3xvgGZYjpFpH/Rwh4cqnRRHVza9FsL5YdHgJuGlwOR4qN4z/MssggAyu3DB0mEMpzUTlJXZbZryS6Q/1rG/DNkwPuljWZZVE2Jeeg1Kqlwf9AkHwwAYRNpF5ryM9MlGEJSlOKQHB0FuY2XFd/Wjxb0sKODiBvu98nMGjDb4a8s8VTjeJPE5QHqFFai2CcCs+edqonLCYd0Mjk6A12FYgehxnxzkVxJv2NV/VHVnmqmvqikGXrvOAQIznbsS93SrteByjZbi9pNIy0LRoCE+V/ptiuGU0Gc3EAx+wrNET2Ct/h9SkOY/u1epXkGweTwDU9+TiiVbLR3wpsmsj7rLkzgUL0ejJLFZG9HLynooG5ydTsOuBL1w6xZa1eK/FiZx/pmD8C1cdRFWrFoZSFt5mAgIkiWe7unvGfI2Tef3vNEq7qtP/Y8/9EQzzSOCTAzOH6NA8GDoJftuQgt0lv3X2m1Q1abeXbMqw1oj1fmfMQCDjLlcBOuorSsYJTfTAEnKUfQgVE8wIvdpNjXQfiQHWMZawoGFS7adXqjID8fnYezDxcWmuieWEgSL9k5OhDGw/3kEYKJqbr+HIXc1ahcHuAL786Zcule+yal69GAXWFTpsn/GLIEMX94ZKrib2K7UE/ee7/KBWzwzZNS9j3Twm22rbFxnEIoKmrsZyuEPsUa2/U2/DWnsKFO+dSVAPE7StaWS1mMIbzjVfOOigxzr1Tn9JJJQHfyvYg3G8e4LJHIfb5mnyJEdEUH+u7LIyVNZW7PmIYUt1rqRiThNCD+SEqOCEkFsV8PoM/UE9PFV8PSmyz3tlzmeKeXuZ5UZtAdUwYagMg/4jEDq8R6nWeokg7xr5QwAA0y2bwt3RkmQCcWmGWpjE7aqvPcH/0E1XaIOEYkVoNHQQcvrQzk+kPugd6RN+jsk2IoWfS0OykVIt+QVeqleRFuNs2WhSvwzHHWwALOvfYehGCmUGwSh6Jev+m6xiO1Yy5LRbIlM+PC4Y/1atuwT1JrWlHvHKNhFBvJrgpvNe2VOQs9Idf5NMvrnNjnfre+clihpIaf4HOLEJk8x0SziT7KgnyNafusTHcXuMEYXULymgF/CXtkaPyKKjpNcFu7/33R5XVt+HQfhT3798sciepXW01VmW0mtfje0L4peKjFOXIkXSEuuPDJysGHdPo4elluFEDx1CuiDqaQTLqvYoCPNVL0kXauw+k/OgQd6HtwUEMH5XwlLFGl5xnyFjdgixCnAt9cEigBaeSa4JLz/+zXI4yDWtnG5mR+Svbu72MRZ6Gx69YgwMQqO5RPVEiIZbvR05MVntJ9xzzjIgzPBcxeSVi3AC1seaSYql8wBuFL/ciGgZ1TG5abQqm2J4JGM/yVCTRqqw9B1WgxhEefZtu9jbz+Axcy2ty0nJc2YX/tTqMTv90YzfkIwrMvb7KgddhFGqwKd3P1ilatHg1rsLmOC0RxzuI+EuTxPPxQ+M6qzyjw3tFrDNkqpGaul5SfHq+KdSQHMErgdyb266aAjgN/cOabZyx6qZVC10HbY6ULxzN4tAkFE6iwsT24OiAUtYh+nk85/+++zK2hXze6xN0Eh5iyiX3SrEhpPg/7uUeBAkx21U75XFpDtiWdt2FkuyJ7ci4OHVnoedwYyMUc92o09VFtostXAW5Yvyf6xvTfww1FFaOW2HxSkVsjmWK96V5zMpIAFwYRChbWmnRlys1LwIw75Y+NQFM17qvUCPMvkLxg59BVGnEx7P6nVpzt8lQpLSuGG0TJaD8hhILqwuGDRpOzEP1N2hnBOB+LNm+gXUlshePT4u9eNcpHZApwapkm5Nfu39SP6rBokZ5MK6RSfLEQvI64h0s4c0n0U0XV6ZcCmwHlIz9DpjAn2zpsN6C2ZuarzsBEndjHyfKSPYz+4e13H4T6yPXePnkPr7/w6H3xevhUYGL7MjtObhldAxpl9vfdJCFCwTYMDpUcuQjsfim7Twf5g58FTeNVmNYuQf8Yume0hnQqEbXiLReLOahYnIWIt1wLjcyApXvNz0pRllY02oolHqlyM0DSRlcSPBvR2WP9IhSybWnGawRbcTG+rBbnrdzQbyD8kKdaFRMArnWU67NIHeAsCaPFopNZmniBy18vdsOh0wZQ8w29KIlhf8LEgqqjBo8UFizbWOMdVaEzZPYSRwN0VCEo4Xg7Psft", + "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", + "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", + "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", + "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", + "Ai7KR2T2xTzSEe1EJ/Ve5ZESdp1ulUfT2HJvqy2W3AqbcfRyBqD8ObBH1EFFo2fg80RPmAzDfta6JFauT8DlD/knzXcuLOeemMvP5m0vfEfbyFQ/JE9lcZKoTQlnTP6o0avW0Ex63pv6nfbjD3lFQrmebTpGGVx08P50DAUax62z/e/VCikhSbzOCTFJKrqQ/82S6ABKo6a2rYveQ0k4f/WuEAdofxhM3pgwNCt8g5Wdm6vtYhyao9T7stshHwF6l/gpAkDzA+v2FCuTA/CYMrUXsEpKkIEE/HepfAmTGt2/dDKlIqU67pRCEpZhpqE310GJTyjGuAGeIZB5a8Uj2N0iC6Cq50osHABiVOnk0fVfA/mNoITIwxZj4Lvjh1MaVWB7Ysixcyl+VltRi7Lo8D1VwIjC0vHGdDXZvoHRah83NkJn4D1ojlbaQPajPvNXFdnbL+pe6mFcucIZqV1xuB+6WcCCa1GLNIx588FoylJ3j+IqiAjTZD7v+xzLC0i9fexgxcQ4rlly34Yhhzs1gDHcHfjOWyy2eLwEzo1Yt287v58Xpm6XXBCJvyTlbQyFU4ok/awNFbMa6j3L7w6OalnpphKO4oz7OAWkg83hFyJ7Bj9ahIEOFDJmJmzHgpXNcWW9tey0tf5aU52Gr7cuJxlQBl/m1zcRUDAfaaXUrMgTM4SwhS0WVTPKPi3GLo2McMml9I9OlLo5qbzCzE0PY3qqJxvney9QUZwHKKR4tIkSn5zx7Ritv1v/hceuGzZmGPweHs/3NPd5EByPjPSvLjoTh1bFlLYYc3OeYIaXLcEwcAW5raEN8htGJYruopYrWEW+U6fCjx0RJadl5MEUxFImPLzr8vIgXRXaWKjxafkeFkGB4ZFwz1d2WLeikusWFHXDbomkyyU/Q+NdyqdQ/HxAeISDx0nKNSBhssDE0hN2I/proSjQghfP+PriK0tbVMxjI6tLUm0drHoV6EjJtF6v4czDfumHdZnB/4B9cl42mlomyR1raH/6QxCKHvCxPPnYyUs8mUX927E9CD8CnL7YKuRBXxuq97gz0gJcgHO0u6gLKWqgQJ+NiDhqaTuZ3I4T4SMJIq+V7grXYAq5dtbtkQ4B5rvntwGTn0LlID70AghGC4U5CL1iEXBIhqLR/mGKqWOwguLVV6qaILMZO5ZUMUNp0wAN3zQodSrQm9ScN7OsJeN9MJMEVUhm4Obp0AfOkS+A/9+ZZ9enbINkBtpkTH5HtUQ18VJsTQS23+yyUfeUTdbG2vsx7qIO1V0DuDJ1e285X5LZ3nfqLDrES5rd7DNlWt190731BSZZRqSQvm7cDW9ml7uITu9ObP1O+IvVNgcM5Hix68wARA9/ofLoV9kxDws61idzjDKU0nnVvKrPUo3kMLWlnIZRFj1ztj5FxWc2DliAHnbuZK3XG4OFr60EtOFS45yZ5AcvOBHgB0Cn6y2pcAwF0cbotnAzD54IhYivRnpvhz7MizSfOWwc54+9FKwSWjzUpL6PdVFZpw3n3pZDGDm+O67dDZpbOiXi7e7rflQJwwbi7XCnFwpY36GNaZFeakHp6I7ySB1p2jCruNJ7Nl/6A4C7SaJ1XGHaw9tQlDw8eOyK2MtNfz/jNck0ydwe0+GkqDdSBV3Qen3rV0szFLBjS6JU0OpXs/iS4WLw2XyF2KHKYWsAP4ZDeIkBcjZ25lpOwALp7zXlwZeDIIAb9MeoY0IjG8K3xDO6AUMC9P6kKoxIQJktvaexVQt2uR6WkZFmIHUix9WSCr9jFTvxnPITiSoWoCjf8YhQafqiub4disEI+Tlg/R4RGEuZIFa0fgguApq7j/d9k/dBrJu83EuzxGqvAGWfSCgdKc8ZU9YoMStgzIKKlSuq8iP/ZG6aGEwWLPz/t9kb189vnOaBkHvO+SaffVjTeFUgZalda/hOdRNOqsayu03uyg3K34TyLff8RMlEXbEubCUHJUbM0MJutGYm3RWTwfVtJUbEI9qh7FtsRV/6maJ3gi9zf8mylFexBHDkEPGXzGhHEP0muPfVXg4TZv/79E6HTercYtsN9Bpt6Ue7mA5vwy6JXo3Rbnb1Z4rFVJJt7SwkvOVnuVvNHw+/fr76WFbGTN9niLM4T/AF3PxR8DvUKUYw/sCR19a4JzNlGdLUTWFkU3wvm7RUVy1Q5/bYt8+ObmbHxfOB771FZVwcsIJ0ZAYFRSr54m1STwbe87rh9osMNTgXtdIQbwM2o8720Yu2QFa6+L+xkoAJVSEh/LIJWUpjARLXhClqYWCay5SHsrMiAIP93eerhWsDGCSe5DBcKO8atf8IMs1J7IFsvAupFAqMmFr1a7AiQ48Dg7ZoK/sAuSOwnV4LyCu6uGneXZARaNqhX5c9iSch2TqG1D4S/mL7U3IVHHsKo/jIq1Yf4NPgmNGdH3/55ambSkRcfGI86q1qd3dKQg/BrvGuNEnZ1oLO6Jh9KcDgy81zQT4qWzmIIXHQX8ZZqOki6gkcxcJxqkLzP1Wl20fjQWjmFqZAnqB3SNU9kGCti3TTDH6T+3TIFMo6N/PiQoEXUeN08HmbwiS3B3vDn3/NJyzeOMAEpo5HNehxoB2Qx0SuMTKjhkmEco4CGZWmeq9xFdtalj2j7BEM7RP2JJWlEpc0UPW/TOb+laUxGb3dh/0OfHIaJgTEnRdKO3o/Mo2ejJN4eaTrzqisoFNPhNjlqzd5EEwfAabLLk9ZLAY378i1lhovne6sSdNNDWGr++rSCg4O+nK46cs8R27jRPGJUOUEbXidsopw1i9bWK6ZvOsPbFjDd9q/8jklONpBk99p4GY7QZjQ3GtxB9dDCbEw8KhE1NjQ8jPpng20wea7U3JHTrdaP/hQUnRlgXoM02bJrSaC4dWQZdCbb+L449kFS0Is4WM6mgatpiPShd6VNTZ/YNEeB9Y2L0kpsQcxn1a0kGqynOjcVZSjQYS82/djD3oChycCtGAWTEvnPjT9AI2VCOSl7b4DjwRpCKd83+8U3SoLPKWc7A3rY2slk9WMljIgaL5Klo+2AQtennm9uS3YSF0FoP66NO4BPRyWt9qvN0I+h0/02cbDgxzuuzX7XRrAH3VidvhELIl/bFQ/mN/1ynz3jXyb/8bhSte+V61kH6JJTGcUrn0p6ylVUV3O5vCoKs6IHs3kYcnGzBl/IX+4isVXwDwiZo7DpU72dUL9V4Cm1S82Qd1kq5D1HB13Rr3ok27FXnRfi6Hzd/MXFMRS4vDsKlQXIrbtwwrOWyS5b67AkRcYJ6BZ56CIIVFHO4CkoxP4EkQbs4+VM8s5coBqzJaoEnpxmVyF9rEkMxEChcb1Kv1wEgAUpxkobBH+m83kGrO1Uv2C+616qoMbnRki7nkxWlieORHFTxFpc6iiyIZMirAwq7v+zyyThnnLICeMLwhfOsiauqzWssIaMQFj79UpG1kyGFWmtTAtEFKDjOW2q/RTUaO/zoCLx3hnOGaNgxAeO2QhUMTjCShyBLqJh+CS8TEHuBjmDJBgUOsjwaUPC7kT6Dr37G8Sj1qIoS6vbIlWGYuBHYRaqWUyvRrEx1kyvHG+A/KOOSuKON6YK806sFN73X7PwglWt3Tu5RaBCs1uN+38IMhq1Fh+jWf5i2lPgT2OR8qgX2+yFrjcE+Nc9GtVu8UlqjztXRzbXvzpP3aEX9hcbYjTdBU+NMe0y9DvzH033oKCsPb6NFdFW8GzbSN3VGVo6oVNEFxi/rGphtbJH2Hnh+Dmz/9WAXxeo+VUJhUCFapixz3S1CCOcyHEpguXI5dFaKS/Pd5DDJwrpyTknUAsrwCRBNe2drd2Q5KfDvV1rkAK8oY4vBU1mUnxHeH/FjcIKB0fcJ76rNFrHoSp3fm15yJ+nZ+UmS4+YX0GRteaDg1KSyZ1/KyV1AlIvay/r4ziQCikmvbPFzsDKz9Dtczx3wwY2ae6/2oGTxtCfvn8czAGe1tIsJzo6UV4wJHzn8jabk7gotipUwMtTXt7m6pKNWQt", + "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", + "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", + "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", + "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", + "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", + "rJJG3SujCCLMi3CUKDjRYc8QqdceGOJK+TCa/B2DOwn6q0O/fZoNQJqydfZ+AdQDmSmstU3nMAyqz0i6TnzpT6lUkfkuZd8GyU2nsC3+BkXK1n7zG941bvz2TdgYRewt/22Um3hc2mSfdKLSe8cDJ5zve5GXxZJGcO3q8JReSwVzdjOz9Ed9TBNvBfr33KQPEPTcucH8lyQm1O+SwmdOZyVPNtGifnguRVYAmKHloW1Gzdnbg4xVrGSkLRqAF4zvZz/0WeAOuqYHJsIQ45Vj5QS9G1PVtVDOMp0oeNYuiY0xBvE7tje/xFEfx3K1rGaHUoQeMVmu9+a+ho9QWjUupb0dVhM6LBjs3QRgWjm3wa/en7kZD5fyhOi/ijIMDCvH6yRTcWwVHY6LPWU4b47EzYimvHtcaCDCu0BYdF/z+YG424E3P+rPyNjCt348cRaL21luPQpRJaDteV0WCcr84+7ihFVp08qqjvuyHGpIE+mNYGtfhkqCiGFi+j6F0VvLYvkjfeXIbYIC4BU05lO0wQF7zHfQc4fqN1v/XNPoXqk0wCYfs/Fo4FTZEFawarGjV0LJFQmN5MIh9VIlklSnwbosESaLYu6hoxpYRhC7raI4wxtFMIiGlBjwMHOrUcWXgylzcLJnjPeaHzoQKb7P9AHGeRMrL64YA1cY/7D27RuYjlv8qcCke4G4EpwyGed4GmFRnxIqzE46UnqpifOPTaGLOaqQxcYtuL1wygschS4jZDPJ7fiKHcWAPPp2IckeXll/+W8XgH5HbzaZ9M7Dfdy2dZrU/ehL/IVerE8kq0hnXB2vVhLiKH5qVM/Ny6Er5bMXzM9awMfnInYgVIODxHz7NSNNtcqkZc18Q9Zsiaf+FD9A9l+ikd4nFHZthuGSRf5XdXSwqPJcyB4V72nr8ccRXRaGnSrTruWcNB1EadA1PN83BHIgsCwKllefq2Ozt9PVVL+YSIWX4P5iJEELhgw5vWE9d0LmFQ/0AaauAeWO1rcCpD9gCYxH1u4/5iMKF56V7SbQamoOqNyNvQkpaZVxn46dOgJftUK0uAbjQVwum/e7H9UIPDetvtuEDEs/rHT92GLoRAxKkPLr+TEHD9FJsejgB05vyH/4iHveDWxTpruLW+0mWnOVkL3ANGVZ6EzTvtkCLDnxepreQttvOmqj2d1ASg7WaDK4MduTTdXz6/sywqUEterdslJZfEe2cQTxUXlPbIBRN9pn4pYvg8rumWT7oGbj09jQBGB5JeBIAZMH2uQFGfKcs/5BPUYaaUXw/VgLD3pwc7mdw9JMeeuq+p7j4WdPy5nRqHg4JExQQJKrYQ5tLEl228v61y4v0q+YyPhGT8PQPvkkY58MwEvnuid6qUWgUtHzR+FwBqPJCLBEwUMtlek7m3Jamm6WcuLYcUOsJ/Zr1JER2HVk9fAN0hI+kWvGFundIaVIKMWNMJ4ivH5hpZQG10InpyKmD9+UQQeUCZAv7L93nE1Kk7Q1/HSFewPzrQO1FB6iQPA22vYXHDMhHDRLl/uH6mIfr5LU+J7cK3+2pJ2YBQVofC193pslNkNKDU71rb7vAEmWl7aup9lJKY+h/848AAoqFHi8zVX0ywh9jH3vzi2IC+ZVPuzXG8Fr/2N3jEzCgmhkujSPbPGpXkSJH7n3KOpd31Bcuu4eoz3GZhXadcfgPl2/Vtl3VoHSXy43NeyPwtHE93Q29bmLsd3BPVZuYMiyRhh+VU5T44RmK1Vj1Yqgh/3yFmDMvOnn5MRfAFdlquR/HRwDsYGl15n5EzAqWObUAiBQMzNur7QbFhlTqLfst4DPWlCIhMeBoPxxZhNdhII7JTJlCmvN4iITewWRso7huco4BpMj7w27W1nqCPqsDiCCGukRzOVuObRTiYoVpm2ibRCKqiaNW4JeO7wx/85YGYd4vyjJhzgAsTHfsxDEO5toctwA8FdJeEawYdmzVNKhBbP67/o0y5dM0+M2uTdQTg/QeAWSAXB9JOZY3NEC66Rn5cPqmGLyki6F2jPbYWlLbYZBorqNa9oMakN7+Y7wA09p2E2w7uk1BgnBlPPtcuxFClqn2NtS3248en6b2MkGLT/hSNK40DBkX/iRkbtL6SdcY3WeiK0NKG+FrN2LNtRrbB6alOsv4iIMB0PX6LQ7YQ+ccPzelAhKObypv90P0Qk6J5/2vRbnQFo+RrW+jT4DWaXX1FKPr2K1pw6XURR2IbY8ON4xDUBo1iXhnTKWmSvVvtK2BLaqAOOeC/UHLXND4AU9vGc0RQqAHOT/ZK+cSYOHED5GxmiIoe7JfUVdscuidf80JUSHgsJsJncm317BwfcVXBD/ber318wfE2S0qfRM+lZzfYLglFUjFXDmW6OXzrJ0nOTKwnvMazeffxOBeFddfv9mJcgYToQ9/P38ixvVtxbK3c+gLfVuVclGFuMublgcqV8gqk53gV+qxPnpTexlUJkiHeZ+CrwTmrnEpX2Rilr6oPLsHYhTGfk7K68eE2AyzxsYhCgzuXHMgMHHK6iPOKyZ945LsVZ7rwIuzUgqxxpDAL+spCgeWUCbZu+nsygQIIJQpseq8VMjGYnlxDHCeBU5us7yERs7FqJjjfGKLXJ2u1XEkZP0MXUgjIeSCGkRjJoRp2uysFKPAcjkaCmGG+8Y/q0IMF9Y7IMn7gurbHPaoxTFPYu1MNk4zYY+EIN5uSH7z14JWjq6uiKMXZLLW1a4s+2xkBIYVSNqrrILJFE1Olzn0hL9EjahhaTRic45AIG2j+epF3oDGm/M5DIhM2MDWYWEK/hwYJiAxoewHH9TfmTJtFbFPFDlvYq3zfN1MPyLw9fUKjYzZ1KA1E8ZHQVHYavib8BeBty46OH09hdmxY6hge0vVGVeV+KCdr41iVzGg250Z3aKxx/Abe9RP+reKYkN9oh86UXwyg5tu1ffZcPhOE1iFNz+GqI71lRdvOcs61vPjR6/fPWoWFR5350VAWl6PaCcno7YKnmmltX+l+5jGb9Plv0MNyAaJHy9yywECywEpf7It91IL5+Tt6iu6wFPhkr0qzUyQkwd25VHN6MjoB8C1kSsemCjhDSfJLVMKcOd7dwnLpVqwAbe9xEOpkH2Jge0EpV/AvW9Mf1yjElLlaTovnEXkAiWPwyxQvF0B6XZ1fJBaq1EpkLjuyFzmw3GWzr4IuhCTsXACdMUyHFl8+DQkBdTqCbwe+bZd0qeb5BiP5p00Ucsk/mu+5jT1k1/+3e4m0gPDnxgQfH7UTlHHHmYsvjK4AQf4quZzurTLynCctrNcQpsKllEk61oPCVKQJ3QrvPlZknbL5S/8plzl4pslyQr2nAMUyX3PR2TEBVlZvSmxNATjrxNwob3+yWujw7BHS64JjVWR6EEGPFGLGAEop/BskW3uWVOnVDTqbUoJk0GiZCqLvFvLR+/2co3xywuhGaayaweBxikVbH/jC1EGz+M8vwX9A17Jrq7nA7CTni9Y/iflRtBS1uH96xz/wJIwF60r+gmSyjZaP3P8RAIK0KxvsxqySMdYoKV+kr6YB75W9b50SMpfuBtn5nIFWp9e7TcmlPMC5F5Jb12UV1IkuL8/nXKhAHy+8q3FdOyQvFgE/QWSGtpx0Ag3yBoWCrE2/mcI/OBY6TCz9VD6rcgp1kWlkBxbuGFMOJXYhiaooarOxRhg0Pr5rINXQGadajlKdQeAgGsg9MJ5zU0IZ/A0JI+dje6Romwiwg/V6NwyrMQ0XxUOKmrXxJAHbg6OOhciZleu6HhoTyQrxfbuNfiPwt2VNgjDskJK0V/7gM9igqwnDztmOTDaqmqdY2B0oBpMnM2jhoLj1rUlzm9/O/MWU9Oer5nNoU5Vngz3n4AxjrNoXDd5dntDO2SW+vF6q4PdksY6F4z529vfVGIRwWkbPSkEovc3MWA9jVzZ95NhoNt7DBkRZTP43TaeQRcoozg7wM6B8d7p9bPMBEx50jk1VTpUjJ8ka21Td8bUmWn7rbWBlhR/n7OT2yb", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "KY/7l4h6HyTwzPgMvjN/PcaFmBVncHymH8abjlRbSoYs7a2ujRhJHfWurjW7USkEw+fOLGISKp8apM23gwflMzXgzUvABH7qduNWkolkZ9w/g0+kymf8BXyA1H3hUdw2V7b0TqJSR+8UtW+X6zJe2V3VdqGoMcUAHtbteMndx5F/Ou/pit5cSDw5dDDDvkV+dVltBoC93qc2Wvbfq4v+lB1s1uzoiGVNXm9NNaHofHsXD1QD4uvnolQMz9rt2AFGWz8pPq7bmp8YPLLn57uDqVFcq9GkuBhwEl8wCI+OOEM5aRA7zI2jmnpqi+KF7bqsMwqS1MbuIXVwCQkNpwIj5BHlC5zkAbg9UuaQRa1hoQsbholz7mI60liFEqrFVBrhc7MymYZXgTgwsKlAzzeYDnnQsHaMNAPXOtMrr00WaiP78UJbDhXx+rjy2YJHdejM8ZLAtAR2cxWykVttL0BTJpmne15sQ8j/2qTghyUj0cmTxPmxZiBKENDHYmgHzEiBsStg+UTP01jyKPsgDa/KbrtI4hZOrFG3+Et5z2WacYTTfVn8JpnqXZB+wiVv+fNr2R7bEyz6aLKaHUDKI8mOVpUupi5gyhWP1i099ymqDLmfTSTBaqmXYNxOvxhBn7dT93ifKwKcLIq0ewTyS/w1vP0bHcQI/65lvhiGHWkTrPTf9ISMKhA3LZz3H1VjcC4b1ZcGYyBztcKWlJ26C0WV8b2ivYlIRg4o/qEmUAEmFx63wT9mQiWMx/TCpL9i3DZa1DseIiHfrYOXOIX7aL+0td5YnM0rvC9snVsHFACKD1+2bScnQ4mUhvVuvP4K6Y2wvA6lyEnqFmn/DT4RKAYU+J7hPIBrBY8h3eKnWSJllheUgr5vYWYNzteBJbZKUC39/LcFhQlTtiS/tJ5cQDOvEvbUh2oDMDTLtdccswwD0i+65PpXTwBJ9vnnYY4GYFDAsId4uEVjyxnzhONhblXrKtiyw1ItVnDzm7FYi2Q2acXS0UG9JzXyHJHS2mRG2fCN8D7Y9QXaa1SzPUMsTLpyYvpdWhoPuem7uV7BwySPyYiSaOHwZ4xSUdFreiku7EtnmAtjH23v0L7bCPjGrM25ShoqkTLvziKTWSkK66auO6UQSRPd5a2gfFNKiATOm4BPeHyoN42YG5Y7fzPuxPgCoHIfKtiH+5l5MRyxAeYXm+hQ8LOQpRQAMRPzKEnsdBkHWpMxf693gt4ZkKqmhEGi7TKmipXHQjk0caURTI4iIAI4xQh6zSG723vGk6PCEl0/dPV1R4ERxuY39u6eyHHf0H6W96iLckQJPZVscaBEZDoWo0xC40f/41Wg15uqJ+bVHMDOrekkfQxfw1V0iMh/nT4vV+XLy+REfSzMPIKr/XI0TNUKwahmq3dPTtPqnkaYXHlu4Kmd3UEfevU54P3Ed1Ya7A+j/l+uFRl31olqOiNuQkKVivHjYG3Zm9bq6NUpDcCtn+lzDGoOW3Tc31M/QTh7R/fcyOYCO+CetLzR0Etb+aj9v0oJCFhicb5TSJhptGDg31DTQSq3+zmcMMp3Y9fiD9UzUa4g1HnWlgVxnQviWeW9BupESOHCPP5m83IBgdsKt2Voq0KCQNP0Vo5PTbGmN/tVFZYOsj3uuDUMoEfSJNjxNpd5BNG/AbIAt0ov558ymQMsk2zkBOvaYzWlJYQd3ZNgrnxmh4YE0Iys7QdrhJWxjzc0RGgfTPLvLgINCAZ6u+y1204LnaP42pXoZT29kNPZDjEmPiZJkLkXB29eP3/ZuozeLF2kppqY5Srtf81SW5t+8658VosY+2fF5xxPvVH4/BykH9RkEs7cL48p9Fc5zUf2zCpvjnqtXsCFSna4M67FGcZJ7WFwQseIp6Xv8BFBXFHkpnQpUiFFZ63GbR8bIt6+7sX2xlgU/o3F89b1cxdlVIbwTSwwd3xiz5BUGnl057uMk8/DOkcBX4OgKSc1RJqGwKOy/nYkg7CJw6vIPycYacrAMBF8ETha4fYQIlcSo4Oi9Yv7FHK6teuVks1dcSFsqJYJFB6dI/3JeguFf564JIp5kFw8/qESwxmJanX9OsuAGhKzNssa+KssMoAdyIEh6C+pWV6omBehT7BvF6sDzuJMK7ZUUrlTwrWRK3RRIoqBtgryNzE7vMjWE8R+MqBli9WIHT0EgFag46guFgcbj+PgM/dVZwK5qoAqwRxkmWDpg7EYX4ib8Yhvs4k+iwAoy2woUH3rGR6CDDFmNOiCx8EPqr933qL06jmKjFzdOS2pOhFVH70gG+BaCGNWvrvCo1mTuhWNXSasanVeGo7G/+9p7odZ7t/Jpgn3sRDtRBDlCmxoU9tkI848TFt42P/6jT/Xgju45szEX860crt9FYdcVW0xV3+E5rBX/FBU5F2ls8wlEzT9a+zT1RNaN2ayr9BOyhkBRoGE5m75MgLdWMfl9SBxYsRujoXsFjhhX7fNhnfPe0M2QwykHju6QK2aT6eF4vkgtKwGx5zUsCMvdUXEBw3zFQ9GbvInPtgWlJ8t8bznm3aNqWSRpdHSdRZwJ5I+CJGZFOFGfjyZ8JqPOAV9p0Cz+pYOTB2+dvr5DdcPHiWvuc8t5CQoBZySzLY9ZyueRdGsrwsuS4dzmK800m1IHKrbnNI2Ynv6TtSfSe8heGGXl/9Q2WgYeKHe/MsAKxvjeJ3K6zMALcNLtslw6kMuWJL1qWncCk5BpLyq8gVJTdp9/0bwlCih2OyeRWtNa6JDNd0lcnsiwloDlCbpomHBwdrXEMmRSvfh6fwTUkgJ9Howv3NLfkCUYwb2cNCnA5f437U5rSqeEdWceaJ0aZ2KDN96u0Ig/ZM6lhogm2P+COPVGQCoSMgo0P4vm3ELy7MJvSyCR0Krqj/0TBmeAagx5rdPGw9gRDN31qOA1iNHqK6VoJngaiexmNzAAjkpJCpBn8MiCgISCnK09bnTQRGRq/f2oOUIcYidvpY7PEtyE0T9ld3YREH1oPKmRgEHQm55saVfN04id0/4xcTuDSHslrvG5N0mF8ylkPB/BGUUV3zT82YyLHROSpqT/etvd9WT2ZD/eg6b1wK4fGSjTZhM2/t/fZUE+FXtsh/mTEf7zjTxHMZ/bM3uB9oqXaYvznXemSlEkGaubOjQSd9JJa33MZNKtr3kj57FUmgtZKeMBRwRazRS7uwcKlgLr4ut74fzGwiPuIbZp8AwPhRhxdo8GXM9DVeMuiUvOl2Wjs+5vvZ5XpQfrlW8ZxiyD8btVie+W7EW8KQ2PogS0Y0p5zWlUVHSrRrMA4VieuQ2w48AHrs55y/1xmAHjXCHtCyFY5xUM4RSyIpQerA8t8kRyVPhaX+00CeAM/hfNtRL/sMwY4Z112vN6AZDtV7h8BSrBdhsHeLpIuJlwVpUgnL7oWZagxeBcGrAilgSdm3rs4OJw8s1bvKFyuna/XwOaVyJ6kEkPw1Jb6LcYRcUO9K24d/6zlc4y4Cov+P4HlhQWeu8eCFdW+rEy0XCvH2icR2IRlllPqFoK8EmQFN3wfPygiXbijTC08GpE/u5H/RIGOoQYGBc91Euo3B5VhWXyvfgc+KPVpTIZoGf4B43eFO/wpx7x3R7SomL/GLxPRvRUMj/+Sh+GPFj48nZG1UuarqgykLCFi1zjOmqW/RfTehVqqnALRxODrGlmibJE32VaOaZvRBQfoxer/mkJhkeF4fs+j//Wh03tMfMH8xxK6xthM+EFTIotVvNr50je0gugo6sBvo4SywT70AEa1mnt8qsQ5+yGqSu/OUjhoRTxDUlpiAdXRDHFRaNFj1uO/GOz84Vprd48pf5h3W/gTGSDCDEdiRYcpFl1AVUTayzs/4NRlfWdfCw5zsPN89DudB84kw0VJr601zRZwJ0qdHlxwgkAe9wkubePm1h9kbbhkXnLmJtn5iFR3ZPjm8O+WncrwyN9Ne6asWZRe3t4fMKXkAG7nY4sAl+cy3YVgubP+WqbtvN0tg8/Jwnu9TkkVxnRWS4", + "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", + "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", + "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", + "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", + "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", + "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", ) } diff --git a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt index cd12621..643a59e 100644 --- a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt +++ b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt @@ -5,7 +5,8 @@ import kotlin.test.assertContentEquals /** * Synthetic LCG-seeded vectors for the SignState::sign port ([NacSign]); expected sig16 values - * generated by the verified Python model (sig_hand.py sign_sig16 — session 21; see WORKLOG). + * generated by the verified Python model (sig_hand.py sign_sig16 — session 23 model, incl. the + * input-dependent P builder / masks / sel / region6f98 / N fixes; see WORKLOG). * Inputs: LCG(1103515245, 12345, little-endian dwords) — no capture-derived bytes. */ class NacSignTest { @@ -20,39 +21,39 @@ class NacSignTest { private val vectors = listOf( SignVector( - "lcg-101", + "101", "3a213df3eb01039e489b9f58e13df5be06174c04c7d10d58f423b77a1dd7a6cf929d02fd63c30b77608b1c8719c8de65de00295dbf326d328cfdae7cd5cc0a0eea4cc0c6db3b4c1e786614075161b8f3b64dcec8b7ba48ac247265648dc1d013428fe98a534b24de908c99f989e994568e5d85a5af491e86bce1b2c14595594d9ac4fd32cbd10f31a85daa83c1400310669063e5a7bf479654ac1b7bfd274276f24c08ad43af2629c039b1dff9468ea83e46ca3b9ffc7a28ec315077b559e3c44a882071bbc39c47d880041f31dc3c1316dfe67a97e049cd84d2acf66d0ad205a2d6e93633ef41c4f092669b69e01101eeba32218f4ba2991ceeb99c251a5fa7fa9713dbab11024508d08518a1338c24c639f316871d4ed6b4e4ab29dd6817b5522cd974230b650520987c95d9b526659ebbb99b7f36731f4c16e3e395d643c3aaf3819b9bbb0e6e384b51ce1147d80276a0e363777613f4e4e26bb14d4369ca024ee1db13033f1c5049766d49c793a94e481ae66fbd8cb57caa7ee1058fc8f25a9bd65d8bc1515968f249ed8116c8742613d3d867eb181714cdffa5bd99de4fb23bcdb903d73e0280a69629b914e0e2fe60cfdf5fe04dfdacaaff3c7543e48b0a8f3cfe7b231adf98c512a1f1a1c2b8d6919c69577c9dcd44a33aca2d6c4e8362f527e5f386936ab0afe066299e52d5ae0514bd4f9fd52ddc1699e0e5f34dd0bace9e396be17609c8c40ec461e9eef4861cdb364729a0337465afbb9dba4f46127b3c6de3122cb2e06417899963f2645e36e3b63ffa02040cef3d2955a07c5d", "a76f0335549ca560fd571dd9f2bcfbac", "0500000001000001809daa70106844a654fa12bc8259e24e389238f0bf2a97cec941169a1432f8ad22bfa4909dedb5f489f94012be765a21d3e7866d85940d5410c4b06224a967f2361839cd9ab0db9291a569ffec988ee3c98ebf3f37602a64c60640a8a13eab708a953bb7ac4904c82af566d0b54ba8edabe4518e92e4c9bde6acef7ad9e42839c2f6cc25c9e63e8835df144f5c5e0cb1150d02c27395caea75dacd2d2d4b6f051e7828190e4bed710cbe6f70ccfd7786c83b0665da666c0150bd20a27bf2406515632c6f3416c1bfc2ab8ef5f68bf8af0f4bb80a2f880d9c32e32bc55c5fd5855af1258c5796be3542c422404abea395d99d886612c0490092683bcfaf3c6cd1a9356ce2097bbba51ad832877864082b0765f7a87c8e528f728919336b54a61f1b942b7a9713d936dd0f16ca3c06e04717bd1f656a1e8db1c1bb7fddde5b5e6b7eeb9e7982799cf0cb1a772946bf2482591fcf1ab046cdb3fb035930d6ba71c2645aeed76d3c2c381092624df9fa5e063d77f9970551a6c5280fe263f9ddc1de29000000000000004f14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a", - "deb0d8abb9ee3f6c9d5cd696955b66db", + "b9eca9352029e56e986b7a0936e5715e", ), SignVector( - "lcg-2024", + "2024", "013edc07a6e470a9e71e208994bac1b93db9cd0032a536c883c2455c00ec493f39ac61007ee22599df0398eb2cc8613ef5d2a7588aa83940fbfea24e183b391671a9efb256c311f4d78f983fc4f01267ad6b04a4e2be7e637352ecff3055b0f0a91529482ee7cde7cfa2afea5c947deb6563d4a23a48d58feb9cadd0489a7dc8e1d02c3e06aebfcfc71c47faf412f6031d9a444692a4986163be0e6b606adb7619bb151cde7798a2bfdd24c38cccfc52d5ef3d1cea333079db9653da7825f0b551b47a15b6a4d58fb7c5eaf02421be7e8d44e5aa42568f7053065c12902b4ed2899cee9d8e9440cdafb49605bc70927a45781bbc9a6bb500cbec23e7a8dc730cc15380ec66a76e94a78a0249541b7e80fd6afd98f2d32d57432a4374c0984baaf9b93a6f3e3d41509f276428ec80b1bab5fc63354aef8f9bbb9e6df4d8bfabb831afa42e16b665fa976bcd058401099d6d0d644ba21dffa4332af308f0b1d67c69134121ee71d5a88f36ac771cfd8cee257dce66fabeaadfabac3f7108cffa95a1c60e6fc6d0554b87684af8b4d3f182dd2bb0e052334e6223065b322077b2ced9a808a59e32f8987fe14d054ce517a495f9d1caaadab0339b16692e380a849e119aa5d876f7992d778138afe4918b2b4dc638cb021526c013be292c50e8615b497a58bb4e7f64d76f28e8987c39054c0572a5e75a420d7f8bdc784e68712a1b8129109e262a4d1467b61667143ce90abddc1441b2c251c80352cefb80052845b987b764fe5795bf5f0bda9facf9c76975e63fbf0af6ead97bfebd35980491d3", "6e8ca2490f7f136c9cdb9d09a539c8a7", "050000000100000180b49fc061af5995307c3ed10a68f4212659e46cdc5cb722990345f480d8e9a8cd20e35a29f0927843abc203406811fbfa85c028cbd136008ec4d13eb4aca51f960f0f5ed28846f5315f81d9d88defcab9fce5482a928a15a020cccbdec6d9c43c813e5541ab9f362c566e24b72a28ed5ddc7b8e3f825beeace225f1f2e6b0510f8c80bf1483ca21365e4305c32260f5bc6364f219e68a2bc7066a4fba9d4ce81dd6ecebc1b8192a3176b06f0d3cc74f21be344d9bf0c9bbbbdc3b74ad66f6d16b2812d16da3e09fe5f84b3ddf11da0aa3c8097aceeab1fa939c5b4d10ccf7954191be29ddbbc38137d558b43e234a5a7fcb904aae0df34fee751cf4fbfb0a932f3c6d0ab1e664a8e309e5ae28dccdf889f7a7b1449d877bae3b8934eda6f69d319a55ff1ddc7cad6bc4637e6e532dba7aefe7bc914bbfb8b7af9c23c5d395c4ade7a5e57e8a2f6122b1214f993e4186cd088b86e70bff38742bc486e5fd72c080247e990beaacd8e0e2e20ca03cf428062b14d62151256b24ea3d8730f9bcd41c000000000000004fdbda688b7819b62e51981b8ab6b8ce95b74910d82455ef6f8d68b09242aa05df53ca5520909f5e77890048a18e28c8ceafb86873bc243652451ca7a59a3f22d5cb30127aa8d09eccc137228d66bbd4", - "dc2f658fce2e8f2747dda92dd1ff96c7", + "519535a4120819999800b1de27da81bd", ), SignVector( - "lcg-90210", + "90210", "f315c0d9b0926bea29459fbaae2099e34f1ebc04dc296fd5e50a3efbba99da726b50c6a1c807b3ab617049748697886f4788f75274d8d42c9db14bce12a6c622e3611a59e007a15299ca36365e1165523f39072d0cc23ea55577209c6ae5ec3e5b2ac052f8f21ba6d133be2136ee6b7637114d42a44699fd0d3ca1f4c2b70008d3895702102976d7098c32900e8e26642ff086d03cc6fc99c5df6e231a7dc1f54b609cf3280aeee341b36296e650ea3f27b64e93d4a02d7d7d42666b72957a0cc38de63140f62da679891978be9658f71f439a236c361cf235442032ca6083623bf2a91f584dcc97b1ee9d0b96bfde9e17773bc704e764e5edc4711b223fbfd5b36df6bd706fcb42e9c2320d6e2b36ff0f3260b09c12d0eea5a4eb147a901df12be0f76388bc196321e69662463ae452075412ad3419d20a5dc35a51d2b41902a32976e6a09411b85938854e1e4cba33ffbcb746cc5a0b04150148342a0c3b5e1b2a552fb857f98591993494f6c055b8f74c92516437c88ccd3d782d82f694d893c11445d06583c7c9e9d78acef89fc1efe33fecfc0e810885596c84dad346670bd050c2e81e4e0f01091e21a6534e78e7613aef94415a053d34e1133204fcf8833541bd00e3631939d7b1d07e3162fadfa657cc2c2fa465f5ad4ff58ae76b7afbd1391f1812bb0c7134ba8156f2a838d79249dec4375b39ada66c1ce2ddd90b73852a6c300cb66ca9005a5e2ef63b04cf051e285cbba74765fea8e23a479566eb2f1ffa4831a3bae11b3096069d004cc7dfbe84f4195e481d95b18292837972", "6064861b192d0eadde011d3bbf9f9fd1", "0500000001000001809864569e0efac39fe3162d85c7e3ec1388485e9fc4beee29225204decdacca1213dbfbadc0773ba42840d935a33fdfe2b1d539d050bca35e108f4ac9f499687921741ecefb1f43b5127b6cdbc079e187f1e6d3555ebf6c3e72d2ecbec39c922bcebf38aec21d15ac40463ea995c567b04b9cdc6e0381d02d9174ade540b52e5f6366c27e9cce8bf5fcc7fcf2d385e6d7c5f37ddfca194f021ba34a863f8bcb9f4c52126f49769b96aaf8afc98781bb69ba795201c526e1fc73fb7e45341bbe9b7e769919dea07c1a91e65cf8367a53b45b6322cce179751cfa119cd47b30c3de671b4fa6a339e2b271af824b31ac4bac14e136cc43a288ee140532e6c8276ed300d08758e0ece7cc0a4c75940235d93f69474f6f1bc70378ab6f84f1f84a61d6ec882bab065af68fc621158e796c5fbb42d3f325921f632403c8bdf5d014a2f6b802803f9345385e146ef08dd1ed86f0f9fe8cd0991baa08a5602ea9ee808862445683bd6664289fb98ddd6507a964b3803ff0ec2ac69d5b4f4e9deec0a5d72e000000000000004fcdb24c5d82c7b06f93be9abbd01ea6bfc9aefedbced9277defb0a831fc579612856ebac1dac4eb890b6df929e8f7eeff016eb86da654d13ee7ce4f2594aaafe13de93c2032152e2b8372c08300dc26", - "fdd96429c83a964f8f800c4f5b109e6b", + "5d9c4ba636de75d1efed7800115a6efd", ), SignVector( "edge-7-norand", "34556ccc5d4f4e26d250742aa3959258a090137f5984258d1ea8227dffe82e7ccc16311f150da1aa2a28cd2b1b1613e3b8d3be73916512e5f69ced82f7f8420164736937cdc9665c8292ceca932d249dd061fc80c9352348ce54d713ef0fdaf3fcca8d4685652039daef977b0bbc61c7e89a6ae701d506bba62f95b6e70d6e32947dc2683dc08a9132a0d46a83a103de00df13d13923688d7e8d28a7dfd2d4f42ceb57cef5b91eb58a033c83fbbd5df0188eee9271006e3d56ce5eb4d73ec01bc4734a95ad32918de27911a373f15f6830085d9ea94c3b4b2e52514dcf313ef05c77c252650a532a3a63a401eb1b164248adad22e1e76efc0679e5bec78b3853f455944c1d21113c921fd0c4631d28b360dd9a5e19b2a30fdea24ca1bf2cf55c8c6fc062d5563480ea0e7cc6dbd5594278f8caa1518bf05fb62f8475b7f4956c2424f3a88d8b611c42911b8a53250b4f905e50fe895368788e7fd572afc398a7bcd304b0459ff9e99a062e62cbebb708a86f29aac1ea991766f25584a77957e954de797ffd7199b1f2cebec5430978d6c08bc010f93010a33ee866769ff68722eca3023fb5e399564a4ae5d5bb5d7f2ed8126c943106d28a16c13554971abc288484fb8f6dd48ff2a2d8441333c99dddf064eeff694ae29ceedc3bf58fc5e1f51ce0ec962524cce0fad98c43ab2bbfbe08e2f5a7a1ddbf48c69bbeba87d7c257b4160bb5ddb2dbb952aef88623656be220ea9c3cd99fe5d29e5d4f7d7f30850f4c88b6f19560073faab5cf9d9b55462638dde94a11714a7876824baa77b02a61", "00000000000000000000000000000000", "050000000100000180d6d7551c3e07cbd46c1e698f193e0ba2c6a497c480975feb7cb56c8af582dde8026b2f2ae3cf9e90320d54ce99678a229071ab0b2cc97574c0c3974693052fc41378dea21f421ab95f8cdd35df0adbac1e045422f9e979e2b22236f51c8410645abca375e1899e0d75732ef8270325d2abe8739965b0368765841c1aeac3125a88dd27800d618971c56bee4fcaa557266b797cefd64fc9ea4c0007a1b366f8608fb5bd3e46480d6ccb5aad18adb8f5f90c1c38b5590680fa51078b7fad3b18e72309fd240a71b608608ae3ee61a0d9ac58e7bbeade93aef89c17a069870917c3e4f1da722a126164d1d772d4abc3232235bdf4d8f22b7a31b8c10139aaf8896c59df2ef9abb0db7c5ac76ea82013bd5fb9dd664f08cc20536262380c45c727822f7e01012e0d16a56668c9c6b173323e4161c7cd4dfaa2f01e81020b33284a956ba9ce2c37a4bb40d4010182c70652073dbedf0109987f29d786b25fd46fab10a4c99f2a9de2c04b3997c3547ac328e27c018f2f6798a2cfc9c417651de6112b000000000000004f0ef2f84f2f8493ab3cca6f2bc5939f341a2156564b34de34284e8db341a7ea1be634253f27cad988d4247de17d76797372b97f8ec3e10ef740baf1d979fd2bc0befa8bfe1fd7f3346c3a581835f8e5", - "a9569d4508e3415a7d9206c3a6cf8e25", + "3670570863b80133b4995703e378406c", ), SignVector( "edge-8-rand-zeroblob", "a1a3320ec6e9f0e8870df2aab4149946ddd8b46a52dc016123fb571820c80c4cd9252b2f9e6bbd997f26a5864c4646ab95461f01aaa3106e9bab6fae387bb76011b7fa9a7650ad48776693f1e412053c4db3429a02fe953b13f3cd09507972c0493794f54ef869046fad1a057cda0da005ff5fd65a4b71098bb1ceab68229cbd8186665226c3681b67db742c14fd4461bd09f440b2eb0d8803c769a980d6fe0bb984dc27fe106bc95fd03704acdaba1575b337fc0a3fe3dd7b13b30298f55002f111dd32d641fe14576cd5a944d32b392ddc9f5c62a5f4dcf3765a6ab0dfb48b290e4b4aaeb5fbdc4f8f1b7bdc4680b6e5635d74ba7e51686bd12b7dc8f438c96159852286cc08164719b44574954c219d2add8e122b9509e3028f69e094576399d3e6005ee616383feaa4e60c1f519f5510489c6a0a67b65beb0707f81f778bd15c465f3663e3db37e2cf59a443fa810df5028dc27cfac5d36ab65d10f669ad09d5767f0ea377882fe172393c63e08fc5b82e9d1ae28e164b61d69d2877eed0411cc7eee605a9b027c7a7add4dd47fe7d3b2890729aef62c3ae3f8740032fab791282f9beeb98e01f74e4cb6c13a11a355d08dcca05f4c73b33e64058fa4160b1976e0e96b4341b17c87a66046408a4edfd23c52284ff79b3ce59a070bca9f4e98b4f126ec0b5670fa3184c9c2fc6d4a5fd8b697a7581aa2b6146e188a9d46e21cf63a3466f218f07e547f734d6ce1b5d3c8dbcd239759da3caf3cca0219da85941e64c1e21c909ff6deeadccb74286159a30722a31e2ee1bebc551b884c9d0", "0ef2f84f2f8493ab3cca6f2bc5939f34", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "5f7b04163f44e800282b20c5d7c395a7", + "702083139ebbbf95ebae6c4b183ed211", ), ) diff --git a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt index 29b9d37..99c17e1 100644 --- a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt +++ b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt @@ -69,7 +69,7 @@ class NacValidationTest { val pad = hex("ee5a56fa8f6b8da81c8e965a253a0f77fa37d1b2ab317fa708708ce7a1531e0fc6d9ea3c873d7d33b4847cf2dd88ab8652ccaa92232b66562038b72ad9d5dc8b9e5b05557f5666cf4cb627a295f63b6faa93e72d9bdb137a38eb3f3c116732467640034777964a0be482a41f4d6345b902ee5a611323c8bf50e9989649e7117a4ee8") val body = hex("3a213df3eb01039e489b9f58e13df5be06174c04c7d10d58f423b77a1dd7a6cf929d02fd63c30b77608b1c8719c8de65de00295dbf326d328cfdae7cd5cc0a0eea4cc0c6db3b4c1e786614075161b8f3b64dcec8b7ba48ac247265648dc1d013428fe98a534b24de908c99f989e994568e5d85a5af491e86bce1b2c14595594d9ac4fd32cbd10f31a85daa83c1400310669063e5a7bf479654ac1b7bfd274276f24c08ad43af2629c039b1dff9468ea83e46ca3b9ffc7a28ec315077b559e3c44a882071bbc39c47d880041f31dc3c1316dfe67a97e049cd84d2acf66d0ad205a2d6e93633ef41c4f092669b69e01101eeba32218f4ba2991ceeb99c251a5fa7fa9713dbab11024508d08518a1338c24c639f316871d4ed6b4e4ab29dd6817b5522cd974230b650520987c95d9b526659ebbb99b7f36731f4c16e3e395d643c3aaf3819b9bbb0e6e384b51ce1147d80276a0e363777613f4e4e26bb14d4369ca024ee1db13033f1c5049766d49c793a94e481ae66fbd8cb57caa7ee1058fc8f25a9bd65d8bc1515968f249ed8116c8742613d3d867eb181714cdffa5bd99de4fb23bcdb903d73e0280a69629b914e0e2fe60cfdf5fe04dfdacaaff3c7543e48b0a8f3cfe7b231adf98c512a1f1a1c2b8d6919c69577c9dcd44a33aca2d6c4e8362f527e5f386936ab0afe066299e52d5ae0514bd4f9fd52ddc1699e0e5f34dd0bace9e396be17609c8c40ec461e9eef4861cdb364729a0337465afbb9dba4f46127b3c6de3122cb2e06417899963f2645e36e3b63ffa02040cef3d2955a07c5d") val rand = hex("a76f0335549ca560fd571dd9f2bcfbac") - val expected = hex("02a76f0335549ca560fd571dd9f2bcfbacdeb0d8abb9ee3f6c9d5cd696955b66db000001e00500000001000001809daa70106844a654fa12bc8259e24e389238f0bf2a97cec941169a1432f8ad22bfa4909dedb5f489f94012be765a21d3e7866d85940d5410c4b06224a967f2361839cd9ab0db9291a569ffec988ee3c98ebf3f37602a64c60640a8a13eab708a953bb7ac4904c82af566d0b54ba8edabe4518e92e4c9bde6acef7ad9e42839c2f6cc25c9e63e8835df144f5c5e0cb1150d02c27395caea75dacd2d2d4b6f051e7828190e4bed710cbe6f70ccfd7786c83b0665da666c0150bd20a27bf2406515632c6f3416c1bfc2ab8ef5f68bf8af0f4bb80a2f880d9c32e32bc55c5fd5855af1258c5796be3542c422404abea395d99d886612c0490092683bcfaf3c6cd1a9356ce2097bbba51ad832877864082b0765f7a87c8e528f728919336b54a61f1b942b7a9713d936dd0f16ca3c06e04717bd1f656a1e8db1c1bb7fddde5b5e6b7eeb9e7982799cf0cb1a772946bf2482591fcf1ab046cdb3fb035930d6ba71c2645aeed76d3c2c381092624df9fa5e063d77f9970551a6c5280fe263f9ddc1de29000000000000004f14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a") + val expected = hex("02a76f0335549ca560fd571dd9f2bcfbacb9eca9352029e56e986b7a0936e5715e000001e00500000001000001809daa70106844a654fa12bc8259e24e389238f0bf2a97cec941169a1432f8ad22bfa4909dedb5f489f94012be765a21d3e7866d85940d5410c4b06224a967f2361839cd9ab0db9291a569ffec988ee3c98ebf3f37602a64c60640a8a13eab708a953bb7ac4904c82af566d0b54ba8edabe4518e92e4c9bde6acef7ad9e42839c2f6cc25c9e63e8835df144f5c5e0cb1150d02c27395caea75dacd2d2d4b6f051e7828190e4bed710cbe6f70ccfd7786c83b0665da666c0150bd20a27bf2406515632c6f3416c1bfc2ab8ef5f68bf8af0f4bb80a2f880d9c32e32bc55c5fd5855af1258c5796be3542c422404abea395d99d886612c0490092683bcfaf3c6cd1a9356ce2097bbba51ad832877864082b0765f7a87c8e528f728919336b54a61f1b942b7a9713d936dd0f16ca3c06e04717bd1f656a1e8db1c1bb7fddde5b5e6b7eeb9e7982799cf0cb1a772946bf2482591fcf1ab046cdb3fb035930d6ba71c2645aeed76d3c2c381092624df9fa5e063d77f9970551a6c5280fe263f9ddc1de29000000000000004f14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a") val stamp = NacValidation.mint(cert, session, pad, rand, body) assertEquals(517, stamp.size) assertContentEquals(expected.copyOfRange(17, 33), stamp.copyOfRange(17, 33))